/
delegate.go
99 lines (80 loc) · 2.53 KB
/
delegate.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
package cmds
import (
"context"
currencycmds "github.com/ProtoconNet/mitum-currency/v3/cmds"
"github.com/ProtoconNet/mitum-nft/v2/operation/nft"
"github.com/ProtoconNet/mitum2/base"
"github.com/ProtoconNet/mitum2/util"
"github.com/pkg/errors"
)
type DelegateCommand struct {
BaseCommand
currencycmds.OperationFlags
Sender currencycmds.AddressFlag `arg:"" name:"sender" help:"sender address" required:"true"`
Contract currencycmds.AddressFlag `arg:"" name:"contract" help:"contract address" required:"true"`
Operator currencycmds.AddressFlag `arg:"" name:"operator" help:"operator account address"`
Currency currencycmds.CurrencyIDFlag `arg:"" name:"currency" help:"currency id" required:"true"`
Mode string `name:"mode" help:"delegate mode" optional:""`
sender base.Address
contract base.Address
operator base.Address
mode nft.DelegateMode
}
func (cmd *DelegateCommand) Run(pctx context.Context) error {
if _, err := cmd.prepare(pctx); err != nil {
return err
}
if err := cmd.parseFlags(); err != nil {
return err
}
op, err := cmd.createOperation()
if err != nil {
return err
}
currencycmds.PrettyPrint(cmd.Out, op)
return nil
}
func (cmd *DelegateCommand) parseFlags() error {
if err := cmd.OperationFlags.IsValid(nil); err != nil {
return err
}
if a, err := cmd.Sender.Encode(cmd.Encoders.JSON()); err != nil {
return errors.Wrapf(err, "invalid sender address format; %q", cmd.Sender)
} else {
cmd.sender = a
}
if a, err := cmd.Contract.Encode(cmd.Encoders.JSON()); err != nil {
return errors.Wrapf(err, "invalid contract address format; %q", cmd.Contract)
} else {
cmd.contract = a
}
if a, err := cmd.Operator.Encode(cmd.Encoders.JSON()); err != nil {
return errors.Wrapf(err, "invalid operator address format; %q", cmd.Operator)
} else {
cmd.operator = a
}
if len(cmd.Mode) < 1 {
cmd.mode = nft.DelegateAllow
} else {
mode := nft.DelegateMode(cmd.Mode)
if err := mode.IsValid(nil); err != nil {
return err
}
cmd.mode = mode
}
return nil
}
func (cmd *DelegateCommand) createOperation() (base.Operation, error) {
e := util.StringError("failed to create delegate operation")
items := []nft.DelegateItem{nft.NewDelegateItem(cmd.contract, cmd.operator, cmd.mode, cmd.Currency.CID)}
fact := nft.NewDelegateFact([]byte(cmd.Token), cmd.sender, items)
op, err := nft.NewDelegate(fact)
if err != nil {
return nil, e.Wrap(err)
}
err = op.Sign(cmd.Privatekey, cmd.NetworkID.NetworkID())
if err != nil {
return nil, e.Wrap(err)
}
return op, nil
}