92503075a6
* new verireg methods * update changelog and add itest * update itest and cli * update new method's support till v9 * remove gateway APIs * fix cli internal var names
655 lines
21 KiB
Go
655 lines
21 KiB
Go
// stm: #integration
|
|
package itests
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"fmt"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/ipfs/go-cid"
|
|
"github.com/stretchr/testify/require"
|
|
|
|
"github.com/filecoin-project/go-address"
|
|
"github.com/filecoin-project/go-state-types/abi"
|
|
"github.com/filecoin-project/go-state-types/big"
|
|
"github.com/filecoin-project/go-state-types/builtin"
|
|
datacap2 "github.com/filecoin-project/go-state-types/builtin/v9/datacap"
|
|
verifregst "github.com/filecoin-project/go-state-types/builtin/v9/verifreg"
|
|
"github.com/filecoin-project/go-state-types/network"
|
|
|
|
lapi "github.com/filecoin-project/lotus/api"
|
|
"github.com/filecoin-project/lotus/chain/actors"
|
|
"github.com/filecoin-project/lotus/chain/actors/builtin/datacap"
|
|
"github.com/filecoin-project/lotus/chain/actors/builtin/verifreg"
|
|
"github.com/filecoin-project/lotus/chain/types"
|
|
"github.com/filecoin-project/lotus/chain/wallet/key"
|
|
"github.com/filecoin-project/lotus/itests/kit"
|
|
"github.com/filecoin-project/lotus/node/impl"
|
|
)
|
|
|
|
func TestVerifiedClientTopUp(t *testing.T) {
|
|
//stm: @CHAIN_SYNCER_LOAD_GENESIS_001, @CHAIN_SYNCER_FETCH_TIPSET_001,
|
|
//stm: @CHAIN_SYNCER_START_001, @CHAIN_SYNCER_SYNC_001, @BLOCKCHAIN_BEACON_VALIDATE_BLOCK_VALUES_01
|
|
//stm: @CHAIN_SYNCER_COLLECT_CHAIN_001, @CHAIN_SYNCER_COLLECT_HEADERS_001, @CHAIN_SYNCER_VALIDATE_TIPSET_001
|
|
//stm: @CHAIN_SYNCER_NEW_PEER_HEAD_001, @CHAIN_SYNCER_VALIDATE_MESSAGE_META_001, @CHAIN_SYNCER_STOP_001
|
|
|
|
//stm: @CHAIN_INCOMING_HANDLE_INCOMING_BLOCKS_001, @CHAIN_INCOMING_VALIDATE_BLOCK_PUBSUB_001, @CHAIN_INCOMING_VALIDATE_MESSAGE_PUBSUB_001
|
|
blockTime := 100 * time.Millisecond
|
|
|
|
test := func(nv network.Version, shouldWork bool) func(*testing.T) {
|
|
return func(t *testing.T) {
|
|
rootKey, err := key.GenerateKey(types.KTSecp256k1)
|
|
require.NoError(t, err)
|
|
|
|
verifierKey, err := key.GenerateKey(types.KTSecp256k1)
|
|
require.NoError(t, err)
|
|
|
|
verifiedClientKey, err := key.GenerateKey(types.KTBLS)
|
|
require.NoError(t, err)
|
|
|
|
bal, err := types.ParseFIL("100fil")
|
|
require.NoError(t, err)
|
|
|
|
node, _, ens := kit.EnsembleMinimal(t, kit.MockProofs(),
|
|
kit.RootVerifier(rootKey, abi.NewTokenAmount(bal.Int64())),
|
|
kit.Account(verifierKey, abi.NewTokenAmount(bal.Int64())), // assign some balance to the verifier so they can send an AddClient message.
|
|
kit.GenesisNetworkVersion(nv))
|
|
|
|
ens.InterconnectAll().BeginMining(blockTime)
|
|
|
|
api := node.FullNode.(*impl.FullNodeAPI)
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
defer cancel()
|
|
|
|
// get VRH
|
|
//stm: @CHAIN_STATE_VERIFIED_REGISTRY_ROOT_KEY_001
|
|
vrh, err := api.StateVerifiedRegistryRootKey(ctx, types.TipSetKey{})
|
|
fmt.Println(vrh.String())
|
|
require.NoError(t, err)
|
|
|
|
// import the root key.
|
|
rootAddr, err := api.WalletImport(ctx, &rootKey.KeyInfo)
|
|
require.NoError(t, err)
|
|
|
|
// import the verifier's key.
|
|
verifierAddr, err := api.WalletImport(ctx, &verifierKey.KeyInfo)
|
|
require.NoError(t, err)
|
|
|
|
// import the verified client's key.
|
|
verifiedClientAddr, err := api.WalletImport(ctx, &verifiedClientKey.KeyInfo)
|
|
require.NoError(t, err)
|
|
|
|
params, err := actors.SerializeParams(&verifregst.AddVerifierParams{Address: verifierAddr, Allowance: big.NewInt(100000000000)})
|
|
require.NoError(t, err)
|
|
|
|
msg := &types.Message{
|
|
From: rootAddr,
|
|
To: verifreg.Address,
|
|
Method: verifreg.Methods.AddVerifier,
|
|
Params: params,
|
|
Value: big.Zero(),
|
|
}
|
|
|
|
sm, err := api.MpoolPushMessage(ctx, msg, nil)
|
|
require.NoError(t, err, "AddVerifier failed")
|
|
|
|
//stm: @CHAIN_STATE_WAIT_MSG_001
|
|
res, err := api.StateWaitMsg(ctx, sm.Cid(), 1, lapi.LookbackNoLimit, true)
|
|
require.NoError(t, err)
|
|
require.EqualValues(t, 0, res.Receipt.ExitCode)
|
|
|
|
// assign datacap to a client
|
|
datacap := big.NewInt(10000)
|
|
|
|
params, err = actors.SerializeParams(&verifregst.AddVerifiedClientParams{Address: verifiedClientAddr, Allowance: datacap})
|
|
require.NoError(t, err)
|
|
|
|
msg = &types.Message{
|
|
From: verifierAddr,
|
|
To: verifreg.Address,
|
|
Method: verifreg.Methods.AddVerifiedClient,
|
|
Params: params,
|
|
Value: big.Zero(),
|
|
}
|
|
|
|
sm, err = api.MpoolPushMessage(ctx, msg, nil)
|
|
require.NoError(t, err)
|
|
|
|
//stm: @CHAIN_STATE_WAIT_MSG_001
|
|
res, err = api.StateWaitMsg(ctx, sm.Cid(), 1, lapi.LookbackNoLimit, true)
|
|
require.NoError(t, err)
|
|
require.EqualValues(t, 0, res.Receipt.ExitCode)
|
|
|
|
// check datacap balance
|
|
//stm: @CHAIN_STATE_VERIFIED_CLIENT_STATUS_001
|
|
dcap, err := api.StateVerifiedClientStatus(ctx, verifiedClientAddr, types.EmptyTSK)
|
|
require.NoError(t, err)
|
|
require.Equal(t, *dcap, datacap)
|
|
|
|
// try to assign datacap to the same client should fail for actor v4 and below
|
|
params, err = actors.SerializeParams(&verifregst.AddVerifiedClientParams{Address: verifiedClientAddr, Allowance: datacap})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
msg = &types.Message{
|
|
From: verifierAddr,
|
|
To: verifreg.Address,
|
|
Method: verifreg.Methods.AddVerifiedClient,
|
|
Params: params,
|
|
Value: big.Zero(),
|
|
}
|
|
|
|
_, err = api.MpoolPushMessage(ctx, msg, nil)
|
|
if shouldWork && err != nil {
|
|
t.Fatal("expected nil err", err)
|
|
}
|
|
|
|
if !shouldWork && (err == nil || !strings.Contains(err.Error(), "verified client already exists")) {
|
|
t.Fatal("Add datacap to an existing verified client should fail")
|
|
}
|
|
}
|
|
}
|
|
|
|
t.Run("nv12", test(network.Version12, false))
|
|
t.Run("nv13", test(network.Version13, true))
|
|
}
|
|
|
|
func TestRemoveDataCap(t *testing.T) {
|
|
//stm: @CHAIN_SYNCER_LOAD_GENESIS_001, @CHAIN_SYNCER_FETCH_TIPSET_001,
|
|
//stm: @CHAIN_SYNCER_START_001, @CHAIN_SYNCER_SYNC_001, @BLOCKCHAIN_BEACON_VALIDATE_BLOCK_VALUES_01
|
|
//stm: @CHAIN_SYNCER_COLLECT_CHAIN_001, @CHAIN_SYNCER_COLLECT_HEADERS_001, @CHAIN_SYNCER_VALIDATE_TIPSET_001
|
|
//stm: @CHAIN_SYNCER_NEW_PEER_HEAD_001, @CHAIN_SYNCER_VALIDATE_MESSAGE_META_001, @CHAIN_SYNCER_STOP_001
|
|
|
|
//stm: @CHAIN_INCOMING_HANDLE_INCOMING_BLOCKS_001, @CHAIN_INCOMING_VALIDATE_BLOCK_PUBSUB_001, @CHAIN_INCOMING_VALIDATE_MESSAGE_PUBSUB_001
|
|
blockTime := 100 * time.Millisecond
|
|
|
|
rootKey, err := key.GenerateKey(types.KTSecp256k1)
|
|
require.NoError(t, err)
|
|
|
|
verifier1Key, err := key.GenerateKey(types.KTSecp256k1)
|
|
require.NoError(t, err)
|
|
|
|
verifier2Key, err := key.GenerateKey(types.KTSecp256k1)
|
|
require.NoError(t, err)
|
|
|
|
verifiedClientKey, err := key.GenerateKey(types.KTBLS)
|
|
require.NoError(t, err)
|
|
|
|
bal, err := types.ParseFIL("100fil")
|
|
require.NoError(t, err)
|
|
|
|
node, _, ens := kit.EnsembleMinimal(t, kit.MockProofs(),
|
|
kit.RootVerifier(rootKey, abi.NewTokenAmount(bal.Int64())),
|
|
kit.Account(verifier1Key, abi.NewTokenAmount(bal.Int64())),
|
|
kit.Account(verifier2Key, abi.NewTokenAmount(bal.Int64())),
|
|
kit.Account(verifiedClientKey, abi.NewTokenAmount(bal.Int64())),
|
|
)
|
|
|
|
ens.InterconnectAll().BeginMining(blockTime)
|
|
|
|
api := node.FullNode.(*impl.FullNodeAPI)
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
defer cancel()
|
|
|
|
// get VRH
|
|
//stm: @CHAIN_STATE_VERIFIED_REGISTRY_ROOT_KEY_001
|
|
vrh, err := api.StateVerifiedRegistryRootKey(ctx, types.TipSetKey{})
|
|
fmt.Println(vrh.String())
|
|
require.NoError(t, err)
|
|
|
|
// import the root key.
|
|
rootAddr, err := api.WalletImport(ctx, &rootKey.KeyInfo)
|
|
require.NoError(t, err)
|
|
|
|
// import the verifiers' keys.
|
|
verifier1Addr, err := api.WalletImport(ctx, &verifier1Key.KeyInfo)
|
|
require.NoError(t, err)
|
|
|
|
verifier2Addr, err := api.WalletImport(ctx, &verifier2Key.KeyInfo)
|
|
require.NoError(t, err)
|
|
|
|
// import the verified client's key.
|
|
verifiedClientAddr, err := api.WalletImport(ctx, &verifiedClientKey.KeyInfo)
|
|
require.NoError(t, err)
|
|
|
|
// resolve all keys
|
|
|
|
verifier1ID, err := api.StateLookupID(ctx, verifier1Addr, types.EmptyTSK)
|
|
require.NoError(t, err)
|
|
|
|
verifier2ID, err := api.StateLookupID(ctx, verifier2Addr, types.EmptyTSK)
|
|
require.NoError(t, err)
|
|
|
|
verifiedClientID, err := api.StateLookupID(ctx, verifiedClientAddr, types.EmptyTSK)
|
|
require.NoError(t, err)
|
|
|
|
// make the 2 verifiers
|
|
|
|
makeVerifier(ctx, t, api, rootAddr, verifier1Addr)
|
|
makeVerifier(ctx, t, api, rootAddr, verifier2Addr)
|
|
|
|
// assign datacap to a client
|
|
datacap := big.NewInt(10000)
|
|
|
|
params, err := actors.SerializeParams(&verifregst.AddVerifiedClientParams{Address: verifiedClientAddr, Allowance: datacap})
|
|
require.NoError(t, err)
|
|
|
|
msg := &types.Message{
|
|
From: verifier1Addr,
|
|
To: verifreg.Address,
|
|
Method: verifreg.Methods.AddVerifiedClient,
|
|
Params: params,
|
|
Value: big.Zero(),
|
|
}
|
|
|
|
sm, err := api.MpoolPushMessage(ctx, msg, nil)
|
|
require.NoError(t, err)
|
|
|
|
//stm: @CHAIN_STATE_WAIT_MSG_001
|
|
res, err := api.StateWaitMsg(ctx, sm.Cid(), 1, lapi.LookbackNoLimit, true)
|
|
require.NoError(t, err)
|
|
require.EqualValues(t, 0, res.Receipt.ExitCode)
|
|
|
|
// check datacap balance
|
|
//stm: @CHAIN_STATE_VERIFIED_CLIENT_STATUS_001
|
|
dcap, err := api.StateVerifiedClientStatus(ctx, verifiedClientAddr, types.EmptyTSK)
|
|
require.NoError(t, err)
|
|
require.Equal(t, *dcap, datacap)
|
|
|
|
// helper to create removedatacap message
|
|
makeRemoveDatacapMsg := func(removeDatacap big.Int, proposalID uint64) *types.Message {
|
|
removeProposal := verifregst.RemoveDataCapProposal{
|
|
VerifiedClient: verifiedClientID,
|
|
DataCapAmount: removeDatacap,
|
|
RemovalProposalID: verifregst.RmDcProposalID{ProposalID: proposalID},
|
|
}
|
|
|
|
buf := bytes.Buffer{}
|
|
buf.WriteString(verifregst.SignatureDomainSeparation_RemoveDataCap)
|
|
require.NoError(t, removeProposal.MarshalCBOR(&buf), "failed to marshal proposal")
|
|
|
|
removeProposalSer := buf.Bytes()
|
|
|
|
verifier1Sig, err := api.WalletSign(ctx, verifier1Addr, removeProposalSer)
|
|
require.NoError(t, err, "failed to sign proposal")
|
|
|
|
removeRequest1 := verifregst.RemoveDataCapRequest{
|
|
Verifier: verifier1ID,
|
|
VerifierSignature: *verifier1Sig,
|
|
}
|
|
|
|
verifier2Sig, err := api.WalletSign(ctx, verifier2Addr, removeProposalSer)
|
|
require.NoError(t, err, "failed to sign proposal")
|
|
|
|
removeRequest2 := verifregst.RemoveDataCapRequest{
|
|
Verifier: verifier2ID,
|
|
VerifierSignature: *verifier2Sig,
|
|
}
|
|
|
|
removeDataCapParams := verifregst.RemoveDataCapParams{
|
|
VerifiedClientToRemove: verifiedClientAddr,
|
|
DataCapAmountToRemove: removeDatacap,
|
|
VerifierRequest1: removeRequest1,
|
|
VerifierRequest2: removeRequest2,
|
|
}
|
|
|
|
params, aerr := actors.SerializeParams(&removeDataCapParams)
|
|
require.NoError(t, aerr)
|
|
|
|
msg = &types.Message{
|
|
From: rootAddr,
|
|
To: verifreg.Address,
|
|
Method: verifreg.Methods.RemoveVerifiedClientDataCap,
|
|
Params: params,
|
|
Value: big.Zero(),
|
|
}
|
|
|
|
return msg
|
|
}
|
|
|
|
// let's take away half the client's datacap now
|
|
|
|
removeDatacap := big.Div(datacap, big.NewInt(2))
|
|
// proposal ids are 0 the first time
|
|
removeMsg := makeRemoveDatacapMsg(removeDatacap, 0)
|
|
|
|
sm, err = api.MpoolPushMessage(ctx, removeMsg, nil)
|
|
require.NoError(t, err, "RemoveDataCap failed")
|
|
|
|
//stm: @CHAIN_STATE_WAIT_MSG_001
|
|
res, err = api.StateWaitMsg(ctx, sm.Cid(), 1, lapi.LookbackNoLimit, true)
|
|
require.NoError(t, err)
|
|
require.EqualValues(t, 0, res.Receipt.ExitCode)
|
|
|
|
// check datacap balance
|
|
//stm: @CHAIN_STATE_VERIFIED_CLIENT_STATUS_001
|
|
dcap, err = api.StateVerifiedClientStatus(ctx, verifiedClientAddr, types.EmptyTSK)
|
|
require.NoError(t, err)
|
|
require.Equal(t, *dcap, big.Sub(datacap, removeDatacap))
|
|
|
|
// now take away the second half!
|
|
|
|
// proposal ids are 1 the second time
|
|
removeMsg = makeRemoveDatacapMsg(removeDatacap, 1)
|
|
|
|
sm, err = api.MpoolPushMessage(ctx, removeMsg, nil)
|
|
require.NoError(t, err, "RemoveDataCap failed")
|
|
|
|
//stm: @CHAIN_STATE_WAIT_MSG_001
|
|
res, err = api.StateWaitMsg(ctx, sm.Cid(), 1, lapi.LookbackNoLimit, true)
|
|
require.NoError(t, err)
|
|
require.EqualValues(t, 0, res.Receipt.ExitCode)
|
|
|
|
// check datacap balance
|
|
//stm: @CHAIN_STATE_VERIFIED_CLIENT_STATUS_001
|
|
dcap, err = api.StateVerifiedClientStatus(ctx, verifiedClientAddr, types.EmptyTSK)
|
|
require.NoError(t, err)
|
|
require.Nil(t, dcap, "expected datacap to be nil")
|
|
}
|
|
|
|
func TestVerifiedClientCanCreateAllocation(t *testing.T) {
|
|
blockTime := 100 * time.Millisecond
|
|
|
|
rootKey, err := key.GenerateKey(types.KTSecp256k1)
|
|
require.NoError(t, err)
|
|
|
|
verifier1Key, err := key.GenerateKey(types.KTSecp256k1)
|
|
require.NoError(t, err)
|
|
|
|
verifiedClientKey, err := key.GenerateKey(types.KTBLS)
|
|
require.NoError(t, err)
|
|
|
|
bal, err := types.ParseFIL("100fil")
|
|
require.NoError(t, err)
|
|
|
|
node, miner, ens := kit.EnsembleMinimal(t, kit.MockProofs(),
|
|
kit.RootVerifier(rootKey, abi.NewTokenAmount(bal.Int64())),
|
|
kit.Account(verifier1Key, abi.NewTokenAmount(bal.Int64())),
|
|
kit.Account(verifiedClientKey, abi.NewTokenAmount(bal.Int64())),
|
|
)
|
|
|
|
ens.InterconnectAll().BeginMining(blockTime)
|
|
|
|
api := node.FullNode.(*impl.FullNodeAPI)
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
defer cancel()
|
|
|
|
// get VRH
|
|
vrh, err := api.StateVerifiedRegistryRootKey(ctx, types.TipSetKey{})
|
|
fmt.Println(vrh.String())
|
|
require.NoError(t, err)
|
|
|
|
// import the root key.
|
|
rootAddr, err := api.WalletImport(ctx, &rootKey.KeyInfo)
|
|
require.NoError(t, err)
|
|
|
|
// import the verifiers' keys.
|
|
verifier1Addr, err := api.WalletImport(ctx, &verifier1Key.KeyInfo)
|
|
require.NoError(t, err)
|
|
|
|
// import the verified client's key.
|
|
verifiedClientAddr, err := api.WalletImport(ctx, &verifiedClientKey.KeyInfo)
|
|
require.NoError(t, err)
|
|
|
|
// resolve all keys
|
|
|
|
// make the 2 verifiers
|
|
|
|
makeVerifier(ctx, t, api, rootAddr, verifier1Addr)
|
|
|
|
// assign datacap to a client
|
|
initialDatacap := big.NewInt(10000)
|
|
|
|
params, err := actors.SerializeParams(&verifregst.AddVerifiedClientParams{Address: verifiedClientAddr, Allowance: initialDatacap})
|
|
require.NoError(t, err)
|
|
|
|
msg := &types.Message{
|
|
From: verifier1Addr,
|
|
To: verifreg.Address,
|
|
Method: verifreg.Methods.AddVerifiedClient,
|
|
Params: params,
|
|
Value: big.Zero(),
|
|
}
|
|
|
|
sm, err := api.MpoolPushMessage(ctx, msg, nil)
|
|
require.NoError(t, err)
|
|
|
|
res, err := api.StateWaitMsg(ctx, sm.Cid(), 1, lapi.LookbackNoLimit, true)
|
|
require.NoError(t, err)
|
|
require.EqualValues(t, 0, res.Receipt.ExitCode)
|
|
|
|
// check datacap balance
|
|
dcap, err := api.StateVerifiedClientStatus(ctx, verifiedClientAddr, types.EmptyTSK)
|
|
require.NoError(t, err)
|
|
require.Equal(t, *dcap, initialDatacap)
|
|
|
|
minerId, err := address.IDFromAddress(miner.ActorAddr)
|
|
require.NoError(t, err)
|
|
|
|
allocationRequest := verifregst.AllocationRequest{
|
|
Provider: abi.ActorID(minerId),
|
|
Data: cid.MustParse("bafkqaaa"),
|
|
Size: abi.PaddedPieceSize(initialDatacap.Uint64()),
|
|
TermMin: verifregst.MinimumVerifiedAllocationTerm,
|
|
TermMax: verifregst.MinimumVerifiedAllocationTerm,
|
|
Expiration: verifregst.MaximumVerifiedAllocationExpiration,
|
|
}
|
|
|
|
allocationRequests := verifregst.AllocationRequests{
|
|
Allocations: []verifregst.AllocationRequest{allocationRequest},
|
|
}
|
|
|
|
receiverParams, err := actors.SerializeParams(&allocationRequests)
|
|
require.NoError(t, err)
|
|
|
|
transferParams, err := actors.SerializeParams(&datacap2.TransferParams{
|
|
To: builtin.VerifiedRegistryActorAddr,
|
|
Amount: big.Mul(initialDatacap, builtin.TokenPrecision),
|
|
OperatorData: receiverParams,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
msg = &types.Message{
|
|
To: builtin.DatacapActorAddr,
|
|
From: verifiedClientAddr,
|
|
Method: datacap.Methods.TransferExported,
|
|
Params: transferParams,
|
|
Value: big.Zero(),
|
|
}
|
|
|
|
sm, err = api.MpoolPushMessage(ctx, msg, nil)
|
|
require.NoError(t, err)
|
|
|
|
res, err = api.StateWaitMsg(ctx, sm.Cid(), 1, lapi.LookbackNoLimit, true)
|
|
require.NoError(t, err)
|
|
require.EqualValues(t, 0, res.Receipt.ExitCode)
|
|
|
|
// check datacap balance
|
|
dcap, err = api.StateVerifiedClientStatus(ctx, verifiedClientAddr, types.EmptyTSK)
|
|
require.NoError(t, err)
|
|
require.Nil(t, dcap)
|
|
|
|
allocations, err := api.StateGetAllocations(ctx, verifiedClientAddr, types.EmptyTSK)
|
|
require.NoError(t, err)
|
|
|
|
require.Equal(t, 1, len(allocations))
|
|
}
|
|
|
|
func makeVerifier(ctx context.Context, t *testing.T, api *impl.FullNodeAPI, rootAddr address.Address, addr address.Address) {
|
|
allowance := big.NewInt(100000000000)
|
|
params, aerr := actors.SerializeParams(&verifregst.AddVerifierParams{Address: addr, Allowance: allowance})
|
|
require.NoError(t, aerr)
|
|
|
|
msg := &types.Message{
|
|
From: rootAddr,
|
|
To: verifreg.Address,
|
|
Method: verifreg.Methods.AddVerifier,
|
|
Params: params,
|
|
Value: big.Zero(),
|
|
}
|
|
|
|
sm, err := api.MpoolPushMessage(ctx, msg, nil)
|
|
require.NoError(t, err, "AddVerifier failed")
|
|
|
|
res, err := api.StateWaitMsg(ctx, sm.Cid(), 1, lapi.LookbackNoLimit, true)
|
|
require.NoError(t, err)
|
|
require.EqualValues(t, 0, res.Receipt.ExitCode)
|
|
|
|
verifierAllowance, err := api.StateVerifierStatus(ctx, addr, types.EmptyTSK)
|
|
require.NoError(t, err)
|
|
require.Equal(t, allowance, *verifierAllowance)
|
|
}
|
|
|
|
func TestVerifiedListAllAllocationsAndClaims(t *testing.T) {
|
|
blockTime := 100 * time.Millisecond
|
|
|
|
rootKey, err := key.GenerateKey(types.KTSecp256k1)
|
|
require.NoError(t, err)
|
|
|
|
verifier1Key, err := key.GenerateKey(types.KTSecp256k1)
|
|
require.NoError(t, err)
|
|
|
|
verifiedClientKey, err := key.GenerateKey(types.KTBLS)
|
|
require.NoError(t, err)
|
|
|
|
bal, err := types.ParseFIL("100fil")
|
|
require.NoError(t, err)
|
|
|
|
node, miner, ens := kit.EnsembleMinimal(t, kit.MockProofs(),
|
|
kit.RootVerifier(rootKey, abi.NewTokenAmount(bal.Int64())),
|
|
kit.Account(verifier1Key, abi.NewTokenAmount(bal.Int64())),
|
|
kit.Account(verifiedClientKey, abi.NewTokenAmount(bal.Int64())),
|
|
)
|
|
|
|
ens.InterconnectAll().BeginMining(blockTime)
|
|
|
|
api := node.FullNode.(*impl.FullNodeAPI)
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
defer cancel()
|
|
|
|
// get VRH
|
|
vrh, err := api.StateVerifiedRegistryRootKey(ctx, types.TipSetKey{})
|
|
fmt.Println(vrh.String())
|
|
require.NoError(t, err)
|
|
|
|
// import the root key.
|
|
rootAddr, err := api.WalletImport(ctx, &rootKey.KeyInfo)
|
|
require.NoError(t, err)
|
|
|
|
// import the verifiers' keys.
|
|
verifier1Addr, err := api.WalletImport(ctx, &verifier1Key.KeyInfo)
|
|
require.NoError(t, err)
|
|
|
|
// import the verified client's key.
|
|
verifiedClientAddr, err := api.WalletImport(ctx, &verifiedClientKey.KeyInfo)
|
|
require.NoError(t, err)
|
|
|
|
// resolve all keys
|
|
|
|
// make the 2 verifiers
|
|
|
|
makeVerifier(ctx, t, api, rootAddr, verifier1Addr)
|
|
|
|
// assign datacap to a client
|
|
initialDatacap := big.NewInt(20000)
|
|
|
|
params, err := actors.SerializeParams(&verifregst.AddVerifiedClientParams{Address: verifiedClientAddr, Allowance: initialDatacap})
|
|
require.NoError(t, err)
|
|
|
|
msg := &types.Message{
|
|
From: verifier1Addr,
|
|
To: verifreg.Address,
|
|
Method: verifreg.Methods.AddVerifiedClient,
|
|
Params: params,
|
|
Value: big.Zero(),
|
|
}
|
|
|
|
sm, err := api.MpoolPushMessage(ctx, msg, nil)
|
|
require.NoError(t, err)
|
|
|
|
res, err := api.StateWaitMsg(ctx, sm.Cid(), 1, lapi.LookbackNoLimit, true)
|
|
require.NoError(t, err)
|
|
require.EqualValues(t, 0, res.Receipt.ExitCode)
|
|
|
|
// check datacap balance
|
|
dcap, err := api.StateVerifiedClientStatus(ctx, verifiedClientAddr, types.EmptyTSK)
|
|
require.NoError(t, err)
|
|
require.Equal(t, *dcap, initialDatacap)
|
|
|
|
minerId, err := address.IDFromAddress(miner.ActorAddr)
|
|
require.NoError(t, err)
|
|
|
|
allocationRequest1 := verifregst.AllocationRequest{
|
|
Provider: abi.ActorID(minerId),
|
|
Data: cid.MustParse("baga6ea4seaaqa"),
|
|
Size: abi.PaddedPieceSize(initialDatacap.Uint64() / 2),
|
|
TermMin: verifregst.MinimumVerifiedAllocationTerm,
|
|
TermMax: verifregst.MinimumVerifiedAllocationTerm,
|
|
Expiration: verifregst.MaximumVerifiedAllocationExpiration,
|
|
}
|
|
|
|
allocationRequest2 := verifregst.AllocationRequest{
|
|
Provider: abi.ActorID(minerId),
|
|
Data: cid.MustParse("baga6ea4seaaqc"),
|
|
Size: abi.PaddedPieceSize(initialDatacap.Uint64() / 2),
|
|
TermMin: verifregst.MinimumVerifiedAllocationTerm,
|
|
TermMax: verifregst.MinimumVerifiedAllocationTerm,
|
|
Expiration: verifregst.MaximumVerifiedAllocationExpiration,
|
|
}
|
|
|
|
allocationRequests := verifregst.AllocationRequests{
|
|
Allocations: []verifregst.AllocationRequest{allocationRequest1, allocationRequest2},
|
|
}
|
|
|
|
receiverParams, err := actors.SerializeParams(&allocationRequests)
|
|
require.NoError(t, err)
|
|
|
|
transferParams, err := actors.SerializeParams(&datacap2.TransferParams{
|
|
To: builtin.VerifiedRegistryActorAddr,
|
|
Amount: big.Mul(initialDatacap, builtin.TokenPrecision),
|
|
OperatorData: receiverParams,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
msg = &types.Message{
|
|
To: builtin.DatacapActorAddr,
|
|
From: verifiedClientAddr,
|
|
Method: datacap.Methods.TransferExported,
|
|
Params: transferParams,
|
|
Value: big.Zero(),
|
|
}
|
|
|
|
sm, err = api.MpoolPushMessage(ctx, msg, nil)
|
|
require.NoError(t, err)
|
|
|
|
res, err = api.StateWaitMsg(ctx, sm.Cid(), 1, lapi.LookbackNoLimit, true)
|
|
require.NoError(t, err)
|
|
require.EqualValues(t, 0, res.Receipt.ExitCode)
|
|
|
|
allocations, err := api.StateGetAllAllocations(ctx, types.EmptyTSK)
|
|
require.NoError(t, err)
|
|
|
|
require.Equal(t, 2, len(allocations))
|
|
|
|
var pcids []string
|
|
|
|
for _, a := range allocations {
|
|
clientIdAddr, err := api.StateLookupID(ctx, verifiedClientAddr, types.EmptyTSK)
|
|
require.NoError(t, err)
|
|
clientId, err := address.IDFromAddress(clientIdAddr)
|
|
require.NoError(t, err)
|
|
require.Equal(t, abi.ActorID(clientId), a.Client)
|
|
require.Equal(t, abi.ActorID(minerId), a.Provider)
|
|
require.Equal(t, abi.PaddedPieceSize(10000), a.Size)
|
|
pcids = append(pcids, a.Data.String())
|
|
}
|
|
|
|
require.ElementsMatch(t, []string{"baga6ea4seaaqa", "baga6ea4seaaqc"}, pcids)
|
|
|
|
// TODO: Add claims check to this test once https://github.com/filecoin-project/lotus/pull/11618 lands
|
|
}
|