-
Notifications
You must be signed in to change notification settings - Fork 4
/
transfer.go
145 lines (120 loc) · 3.67 KB
/
transfer.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
package cmds
import (
"bytes"
"github.com/pkg/errors"
currency "github.com/spikeekips/mitum-currency/currency"
"github.com/spikeekips/mitum/base"
"github.com/spikeekips/mitum/base/operation"
"github.com/spikeekips/mitum/base/seal"
mitumcmds "github.com/spikeekips/mitum/launch/cmds"
"github.com/spikeekips/mitum/util"
)
type TransferCommand struct {
*BaseCommand
OperationFlags
Sender AddressFlag `arg:"" name:"sender" help:"sender address" required:"true"`
Receiver AddressFlag `arg:"" name:"receiver" help:"receiver address" required:"true"`
Seal mitumcmds.FileLoad `help:"seal" optional:""`
Amounts []CurrencyAmountFlag `arg:"" name:"currency-amount" help:"amount (ex: \"<currency>,<amount>\")"`
sender base.Address
receiver base.Address
}
func NewTransferCommand() TransferCommand {
return TransferCommand{
BaseCommand: NewBaseCommand("transfer-operation"),
}
}
func (cmd *TransferCommand) Run(version util.Version) error {
if err := cmd.Initialize(cmd, version); err != nil {
return errors.Wrap(err, "failed to initialize command")
}
if err := cmd.parseFlags(); err != nil {
return err
}
op, err := cmd.createOperation()
if err != nil {
return err
}
sl, err := LoadSealAndAddOperation(
cmd.Seal.Bytes(),
cmd.Privatekey,
cmd.NetworkID.NetworkID(),
op,
)
if err != nil {
return err
}
PrettyPrint(cmd.Out, cmd.Pretty, sl)
return nil
}
func (cmd *TransferCommand) parseFlags() error {
if err := cmd.OperationFlags.IsValid(nil); err != nil {
return err
}
if len(cmd.Amounts) < 1 {
return errors.Errorf("empty currency-amount, must be given at least one")
}
if sender, err := cmd.Sender.Encode(jenc); err != nil {
return errors.Wrapf(err, "invalid sender format, %q", cmd.Sender.String())
} else if receiver, err := cmd.Receiver.Encode(jenc); err != nil {
return errors.Wrapf(err, "invalid sender format, %q", cmd.Sender.String())
} else {
cmd.sender = sender
cmd.receiver = receiver
}
return nil
}
func (cmd *TransferCommand) createOperation() (operation.Operation, error) { // nolint:dupl
i, err := loadOperations(cmd.Seal.Bytes(), cmd.NetworkID.NetworkID())
if err != nil {
return nil, err
}
var items []currency.TransfersItem
for j := range i {
if t, ok := i[j].(currency.Transfers); ok {
items = t.Fact().(currency.TransfersFact).Items()
}
}
ams := make([]currency.Amount, len(cmd.Amounts))
for i := range cmd.Amounts {
a := cmd.Amounts[i]
am := currency.NewAmount(a.Big, a.CID)
if err = am.IsValid(nil); err != nil {
return nil, err
}
ams[i] = am
}
item := currency.NewTransfersItemMultiAmounts(cmd.receiver, ams)
if err = item.IsValid(nil); err != nil {
return nil, err
}
items = append(items, item)
fact := currency.NewTransfersFact([]byte(cmd.Token), cmd.sender, items)
var fs []base.FactSign
sig, err := base.NewFactSignature(cmd.Privatekey, fact, cmd.NetworkID.NetworkID())
if err != nil {
return nil, err
}
fs = append(fs, base.NewBaseFactSign(cmd.Privatekey.Publickey(), sig))
op, err := currency.NewTransfers(fact, fs, cmd.Memo)
if err != nil {
return nil, errors.Wrap(err, "failed to create transfers operation")
}
return op, nil
}
func loadOperations(b []byte, networkID base.NetworkID) ([]operation.Operation, error) {
if len(bytes.TrimSpace(b)) < 1 {
return nil, nil
}
var sl seal.Seal
if s, err := LoadSeal(b, networkID); err != nil {
return nil, err
} else if so, ok := s.(operation.Seal); !ok {
return nil, errors.Errorf("seal is not operation.Seal, %T", s)
} else if _, ok := so.(operation.SealUpdater); !ok {
return nil, errors.Errorf("seal is not operation.SealUpdater, %T", s)
} else {
sl = so
}
return sl.(operation.Seal).Operations(), nil
}