lotus/cli/filplus.go

622 lines
15 KiB
Go
Raw Normal View History

2021-04-28 23:24:09 +00:00
package cli
import (
"bytes"
2021-04-28 23:24:09 +00:00
"context"
"encoding/hex"
2021-04-28 23:24:09 +00:00
"fmt"
"os"
"strconv"
2021-04-28 23:24:09 +00:00
2022-06-14 15:00:51 +00:00
cbor "github.com/ipfs/go-ipld-cbor"
2021-04-28 23:24:09 +00:00
"github.com/urfave/cli/v2"
"golang.org/x/xerrors"
"github.com/filecoin-project/go-address"
"github.com/filecoin-project/go-state-types/abi"
actorstypes "github.com/filecoin-project/go-state-types/actors"
2022-06-14 15:00:51 +00:00
"github.com/filecoin-project/go-state-types/big"
2022-09-10 14:34:47 +00:00
verifregtypes8 "github.com/filecoin-project/go-state-types/builtin/v8/verifreg"
verifregtypes9 "github.com/filecoin-project/go-state-types/builtin/v9/verifreg"
"github.com/filecoin-project/go-state-types/network"
2021-04-28 23:24:09 +00:00
2021-05-31 19:43:21 +00:00
"github.com/filecoin-project/lotus/api/v0api"
2021-04-28 23:24:09 +00:00
"github.com/filecoin-project/lotus/blockstore"
"github.com/filecoin-project/lotus/build"
"github.com/filecoin-project/lotus/chain/actors"
"github.com/filecoin-project/lotus/chain/actors/adt"
"github.com/filecoin-project/lotus/chain/actors/builtin/datacap"
2021-04-28 23:24:09 +00:00
"github.com/filecoin-project/lotus/chain/actors/builtin/verifreg"
"github.com/filecoin-project/lotus/chain/types"
"github.com/filecoin-project/lotus/lib/tablewriter"
2021-04-28 23:24:09 +00:00
)
2021-04-28 23:24:09 +00:00
var filplusCmd = &cli.Command{
Name: "filplus",
Usage: "Interact with the verified registry actor used by Filplus",
2021-04-28 23:24:09 +00:00
Flags: []cli.Flag{},
Subcommands: []*cli.Command{
2021-04-28 23:24:09 +00:00
filplusVerifyClientCmd,
filplusListNotariesCmd,
filplusListClientsCmd,
filplusCheckClientCmd,
filplusCheckNotaryCmd,
filplusSignRemoveDataCapProposal,
filplusListAllocationsCmd,
filplusRemoveExpiredAllocationsCmd,
2021-04-28 23:24:09 +00:00
},
}
2021-04-28 23:24:09 +00:00
var filplusVerifyClientCmd = &cli.Command{
2022-09-29 21:32:24 +00:00
Name: "grant-datacap",
Usage: "give allowance to the specified verified client address",
ArgsUsage: "[clientAddress datacap]",
2021-04-28 23:24:09 +00:00
Flags: []cli.Flag{
&cli.StringFlag{
Name: "from",
2021-04-28 23:24:09 +00:00
Usage: "specify your notary address to send the message from",
2021-04-28 23:24:09 +00:00
Required: true,
},
},
Action: func(cctx *cli.Context) error {
froms := cctx.String("from")
if froms == "" {
return fmt.Errorf("must specify from address with --from")
}
fromk, err := address.NewFromString(froms)
if err != nil {
return err
}
2022-09-14 18:33:29 +00:00
if cctx.NArg() != 2 {
return IncorrectNumArgs(cctx)
2021-04-28 23:24:09 +00:00
}
target, err := address.NewFromString(cctx.Args().Get(0))
if err != nil {
return err
}
allowance, err := types.BigFromString(cctx.Args().Get(1))
if err != nil {
return err
}
api, closer, err := GetFullNodeAPI(cctx)
if err != nil {
return err
}
defer closer()
ctx := ReqContext(cctx)
2021-04-28 23:24:09 +00:00
found, dcap, err := checkNotary(ctx, api, fromk)
2021-04-28 23:24:09 +00:00
if err != nil {
return err
}
if !found {
2021-04-28 23:24:09 +00:00
return xerrors.New("sender address must be a notary")
2021-04-28 23:24:09 +00:00
}
if dcap.Cmp(allowance.Int) < 0 {
2021-04-28 23:24:09 +00:00
return xerrors.Errorf("cannot allot more allowance than notary data cap: %s < %s", dcap, allowance)
2021-04-28 23:24:09 +00:00
}
// TODO: This should be abstracted over actor versions
2022-09-10 14:34:47 +00:00
params, err := actors.SerializeParams(&verifregtypes9.AddVerifiedClientParams{Address: target, Allowance: allowance})
2021-04-28 23:24:09 +00:00
if err != nil {
return err
}
msg := &types.Message{
To: verifreg.Address,
From: fromk,
Method: verifreg.Methods.AddVerifiedClient,
Params: params,
}
smsg, err := api.MpoolPushMessage(ctx, msg, nil)
if err != nil {
return err
}
fmt.Printf("message sent, now waiting on cid: %s\n", smsg.Cid())
mwait, err := api.StateWaitMsg(ctx, smsg.Cid(), build.MessageConfidence)
if err != nil {
return err
}
if mwait.Receipt.ExitCode.IsError() {
2021-04-28 23:24:09 +00:00
return fmt.Errorf("failed to add verified client: %d", mwait.Receipt.ExitCode)
}
return nil
},
}
2021-04-28 23:24:09 +00:00
var filplusListNotariesCmd = &cli.Command{
Name: "list-notaries",
Usage: "list all notaries",
2021-04-28 23:24:09 +00:00
Action: func(cctx *cli.Context) error {
2022-09-29 21:32:24 +00:00
if cctx.NArg() != 0 {
return IncorrectNumArgs(cctx)
}
2021-04-28 23:24:09 +00:00
api, closer, err := GetFullNodeAPI(cctx)
if err != nil {
return err
}
defer closer()
ctx := ReqContext(cctx)
act, err := api.StateGetActor(ctx, verifreg.Address, types.EmptyTSK)
if err != nil {
return err
}
apibs := blockstore.NewAPIBlockstore(api)
store := adt.WrapStore(ctx, cbor.NewCborStore(apibs))
st, err := verifreg.Load(store, act)
if err != nil {
return err
}
return st.ForEachVerifier(func(addr address.Address, dcap abi.StoragePower) error {
_, err := fmt.Printf("%s: %s\n", addr, dcap)
return err
})
},
}
2021-04-28 23:24:09 +00:00
var filplusListClientsCmd = &cli.Command{
2021-04-28 23:24:09 +00:00
Name: "list-clients",
Usage: "list all verified clients",
Action: func(cctx *cli.Context) error {
2022-09-29 21:32:24 +00:00
if cctx.NArg() != 0 {
return IncorrectNumArgs(cctx)
}
2021-04-28 23:24:09 +00:00
api, closer, err := GetFullNodeAPI(cctx)
if err != nil {
return err
}
defer closer()
ctx := ReqContext(cctx)
apibs := blockstore.NewAPIBlockstore(api)
store := adt.WrapStore(ctx, cbor.NewCborStore(apibs))
nv, err := api.StateNetworkVersion(ctx, types.EmptyTSK)
2021-04-28 23:24:09 +00:00
if err != nil {
return err
}
av, err := actorstypes.VersionForNetwork(nv)
if err != nil {
return err
}
2021-04-28 23:24:09 +00:00
if av <= 8 {
act, err := api.StateGetActor(ctx, verifreg.Address, types.EmptyTSK)
if err != nil {
return err
}
st, err := verifreg.Load(store, act)
if err != nil {
return err
}
return st.ForEachClient(func(addr address.Address, dcap abi.StoragePower) error {
_, err := fmt.Printf("%s: %s\n", addr, dcap)
return err
})
}
act, err := api.StateGetActor(ctx, datacap.Address, types.EmptyTSK)
if err != nil {
return err
}
st, err := datacap.Load(store, act)
2021-04-28 23:24:09 +00:00
if err != nil {
return err
}
return st.ForEachClient(func(addr address.Address, dcap abi.StoragePower) error {
_, err := fmt.Printf("%s: %s\n", addr, dcap)
return err
})
},
}
var filplusListAllocationsCmd = &cli.Command{
Name: "list-allocations",
Usage: "List allocations made by client",
ArgsUsage: "clientAddress",
Flags: []cli.Flag{
&cli.BoolFlag{
Name: "expired",
Usage: "list only expired allocations",
},
},
Action: func(cctx *cli.Context) error {
if cctx.NArg() != 1 {
return IncorrectNumArgs(cctx)
}
api, closer, err := GetFullNodeAPI(cctx)
if err != nil {
return err
}
defer closer()
ctx := ReqContext(cctx)
clientAddr, err := address.NewFromString(cctx.Args().Get(0))
if err != nil {
return err
}
clientIdAddr, err := api.StateLookupID(ctx, clientAddr, types.EmptyTSK)
if err != nil {
return err
}
store := adt.WrapStore(ctx, cbor.NewCborStore(blockstore.NewAPIBlockstore(api)))
verifregActor, err := api.StateGetActor(ctx, verifreg.Address, types.EmptyTSK)
if err != nil {
return err
}
verifregState, err := verifreg.Load(store, verifregActor)
if err != nil {
return err
}
ts, err := api.ChainHead(ctx)
if err != nil {
return err
}
allocationsMap, err := verifregState.GetAllocations(clientIdAddr)
if err != nil {
return err
}
tw := tablewriter.New(
tablewriter.Col("ID"),
tablewriter.Col("Provider"),
tablewriter.Col("Data"),
tablewriter.Col("Size"),
tablewriter.Col("TermMin"),
tablewriter.Col("TermMax"),
tablewriter.Col("Expiration"),
)
for allocationId, allocation := range allocationsMap {
if ts.Height() > allocation.Expiration || !cctx.IsSet("expired") {
tw.Write(map[string]interface{}{
"ID": allocationId,
"Provider": allocation.Provider,
"Data": allocation.Data,
"Size": allocation.Size,
"TermMin": allocation.TermMin,
"TermMax": allocation.TermMax,
"Expiration": allocation.Expiration,
})
}
}
return tw.Flush(os.Stdout)
},
}
var filplusRemoveExpiredAllocationsCmd = &cli.Command{
Name: "remove-expired-allocations",
Usage: "remove expired allocations (if no allocations are specified all eligible allocations are removed)",
ArgsUsage: "clientAddress Optional[...allocationId]",
Flags: []cli.Flag{
&cli.StringFlag{
Name: "from",
Usage: "optionally specify the account to send the message from",
},
},
Action: func(cctx *cli.Context) error {
if cctx.NArg() < 1 {
return IncorrectNumArgs(cctx)
}
api, closer, err := GetFullNodeAPI(cctx)
if err != nil {
return err
}
defer closer()
ctx := ReqContext(cctx)
args := cctx.Args().Slice()
clientAddr, err := address.NewFromString(args[0])
if err != nil {
return err
}
clientIdAddr, err := api.StateLookupID(ctx, clientAddr, types.EmptyTSK)
if err != nil {
return err
}
clientId, err := address.IDFromAddress(clientIdAddr)
if err != nil {
return err
}
fromAddr := clientIdAddr
if from := cctx.String("from"); from != "" {
addr, err := address.NewFromString(from)
if err != nil {
return err
}
fromAddr = addr
}
allocationIDs := make([]verifregtypes9.AllocationId, len(args)-1)
for i, allocationString := range args[1:] {
id, err := strconv.ParseUint(allocationString, 10, 64)
if err != nil {
return err
}
allocationIDs[i] = verifregtypes9.AllocationId(id)
}
params, err := actors.SerializeParams(&verifregtypes9.RemoveExpiredAllocationsParams{
Client: abi.ActorID(clientId),
AllocationIds: allocationIDs,
})
if err != nil {
return err
}
msg := &types.Message{
To: verifreg.Address,
From: fromAddr,
Method: verifreg.Methods.RemoveExpiredAllocations,
Params: params,
}
smsg, err := api.MpoolPushMessage(ctx, msg, nil)
if err != nil {
return err
}
fmt.Printf("message sent, now waiting on cid: %s\n", smsg.Cid())
mwait, err := api.StateWaitMsg(ctx, smsg.Cid(), build.MessageConfidence)
if err != nil {
return err
}
if mwait.Receipt.ExitCode.IsError() {
return fmt.Errorf("failed to remove expired allocations: %d", mwait.Receipt.ExitCode)
}
return nil
},
}
2021-04-28 23:24:09 +00:00
var filplusCheckClientCmd = &cli.Command{
2022-09-29 21:32:24 +00:00
Name: "check-client-datacap",
Usage: "check verified client remaining bytes",
ArgsUsage: "clientAddress",
2021-04-28 23:24:09 +00:00
Action: func(cctx *cli.Context) error {
2022-09-29 21:32:24 +00:00
if cctx.NArg() != 1 {
2021-04-28 23:24:09 +00:00
return fmt.Errorf("must specify client address to check")
}
caddr, err := address.NewFromString(cctx.Args().First())
if err != nil {
return err
}
api, closer, err := GetFullNodeAPI(cctx)
if err != nil {
return err
}
defer closer()
ctx := ReqContext(cctx)
dcap, err := api.StateVerifiedClientStatus(ctx, caddr, types.EmptyTSK)
if err != nil {
return err
}
if dcap == nil {
2021-07-02 16:02:56 +00:00
return xerrors.Errorf("client %s is not a verified client", caddr)
2021-04-28 23:24:09 +00:00
}
fmt.Println(*dcap)
return nil
},
}
2021-04-28 23:24:09 +00:00
var filplusCheckNotaryCmd = &cli.Command{
2022-09-29 21:32:24 +00:00
Name: "check-notary-datacap",
Usage: "check a notary's remaining bytes",
ArgsUsage: "notaryAddress",
2021-04-28 23:24:09 +00:00
Action: func(cctx *cli.Context) error {
2022-09-29 21:32:24 +00:00
if cctx.NArg() != 1 {
2021-04-28 23:24:09 +00:00
return fmt.Errorf("must specify notary address to check")
2021-04-28 23:24:09 +00:00
}
vaddr, err := address.NewFromString(cctx.Args().First())
if err != nil {
return err
}
api, closer, err := GetFullNodeAPI(cctx)
if err != nil {
return err
}
defer closer()
ctx := ReqContext(cctx)
2021-04-28 23:24:09 +00:00
found, dcap, err := checkNotary(ctx, api, vaddr)
2021-04-28 23:24:09 +00:00
if err != nil {
return err
}
if !found {
return fmt.Errorf("not found")
}
fmt.Println(dcap)
return nil
},
}
func checkNotary(ctx context.Context, api v0api.FullNode, vaddr address.Address) (bool, abi.StoragePower, error) {
2021-04-28 23:24:09 +00:00
vid, err := api.StateLookupID(ctx, vaddr, types.EmptyTSK)
if err != nil {
return false, big.Zero(), err
}
act, err := api.StateGetActor(ctx, verifreg.Address, types.EmptyTSK)
if err != nil {
return false, big.Zero(), err
}
apibs := blockstore.NewAPIBlockstore(api)
store := adt.WrapStore(ctx, cbor.NewCborStore(apibs))
st, err := verifreg.Load(store, act)
if err != nil {
return false, big.Zero(), err
}
return st.VerifierDataCap(vid)
}
var filplusSignRemoveDataCapProposal = &cli.Command{
2022-09-29 21:32:24 +00:00
Name: "sign-remove-data-cap-proposal",
Usage: "allows a notary to sign a Remove Data Cap Proposal",
ArgsUsage: "[verifierAddress clientAddress allowanceToRemove]",
Flags: []cli.Flag{
&cli.Int64Flag{
Name: "id",
Usage: "specify the RemoveDataCapProposal ID (will look up on chain if unspecified)",
Required: false,
},
},
Action: func(cctx *cli.Context) error {
2022-09-14 18:33:29 +00:00
if cctx.NArg() != 3 {
return IncorrectNumArgs(cctx)
}
2022-02-23 03:58:51 +00:00
api, closer, err := GetFullNodeAPI(cctx)
if err != nil {
return xerrors.Errorf("failed to get full node api: %w", err)
}
defer closer()
ctx := ReqContext(cctx)
act, err := api.StateGetActor(ctx, verifreg.Address, types.EmptyTSK)
if err != nil {
return xerrors.Errorf("failed to get verifreg actor: %w", err)
}
apibs := blockstore.NewAPIBlockstore(api)
store := adt.WrapStore(ctx, cbor.NewCborStore(apibs))
st, err := verifreg.Load(store, act)
if err != nil {
return xerrors.Errorf("failed to load verified registry state: %w", err)
}
verifier, err := address.NewFromString(cctx.Args().Get(0))
if err != nil {
return err
}
2022-02-23 03:58:51 +00:00
verifierIdAddr, err := api.StateLookupID(ctx, verifier, types.EmptyTSK)
if err != nil {
return err
}
client, err := address.NewFromString(cctx.Args().Get(1))
if err != nil {
return err
}
2022-02-23 03:58:51 +00:00
clientIdAddr, err := api.StateLookupID(ctx, client, types.EmptyTSK)
if err != nil {
return err
}
2022-02-23 03:58:51 +00:00
allowanceToRemove, err := types.BigFromString(cctx.Args().Get(2))
if err != nil {
return err
}
dataCap, err := api.StateVerifiedClientStatus(ctx, clientIdAddr, types.EmptyTSK)
2022-02-24 17:40:13 +00:00
if err != nil {
return xerrors.Errorf("failed to find verified client data cap: %w", err)
}
if dataCap.LessThanEqual(big.Zero()) {
return xerrors.Errorf("client data cap %s is less than amount requested to be removed %s", dataCap.String(), allowanceToRemove.String())
}
found, _, err := checkNotary(ctx, api, verifier)
if err != nil {
2022-02-23 03:58:51 +00:00
return xerrors.Errorf("failed to check notary status: %w", err)
}
if !found {
return xerrors.New("verifier address must be a notary")
}
id := cctx.Uint64("id")
if id == 0 {
2022-02-23 03:58:51 +00:00
_, id, err = st.RemoveDataCapProposalID(verifierIdAddr, clientIdAddr)
if err != nil {
2022-02-23 03:58:51 +00:00
return xerrors.Errorf("failed find remove data cap proposal id: %w", err)
}
}
2022-09-10 14:34:47 +00:00
nv, err := api.StateNetworkVersion(ctx, types.EmptyTSK)
if err != nil {
return xerrors.Errorf("failed to get network version: %w", err)
}
paramBuf := new(bytes.Buffer)
2022-09-10 14:34:47 +00:00
paramBuf.WriteString(verifregtypes9.SignatureDomainSeparation_RemoveDataCap)
if nv <= network.Version16 {
params := verifregtypes8.RemoveDataCapProposal{
RemovalProposalID: id,
DataCapAmount: allowanceToRemove,
VerifiedClient: clientIdAddr,
}
err = params.MarshalCBOR(paramBuf)
} else {
params := verifregtypes9.RemoveDataCapProposal{
RemovalProposalID: verifregtypes9.RmDcProposalID{ProposalID: id},
DataCapAmount: allowanceToRemove,
VerifiedClient: clientIdAddr,
}
err = params.MarshalCBOR(paramBuf)
}
if err != nil {
2022-02-23 03:58:51 +00:00
return xerrors.Errorf("failed to marshall paramBuf: %w", err)
}
sig, err := api.WalletSign(ctx, verifier, paramBuf.Bytes())
if err != nil {
2022-02-23 03:58:51 +00:00
return xerrors.Errorf("failed to sign message: %w", err)
}
sigBytes := append([]byte{byte(sig.Type)}, sig.Data...)
fmt.Println(hex.EncodeToString(sigBytes))
return nil
},
}