Merge pull request #9557 from filecoin-project/gstuart/remove-datacap-verifreg-test

test: verifreg: Test notaries cannot remove datacap from verifreg
This commit is contained in:
Aayush Rajasekaran 2022-10-31 19:27:31 +00:00 committed by GitHub
commit 4463abd009
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
3 changed files with 291 additions and 5 deletions

View File

@ -991,6 +991,11 @@ workflows:
suite: itest-pending_deal_allocation suite: itest-pending_deal_allocation
target: "./itests/pending_deal_allocation_test.go" target: "./itests/pending_deal_allocation_test.go"
- test:
name: test-itest-remove_verifreg_datacap
suite: itest-remove_verifreg_datacap
target: "./itests/remove_verifreg_datacap_test.go"
- test: - test:
name: test-itest-sdr_upgrade name: test-itest-sdr_upgrade
suite: itest-sdr_upgrade suite: itest-sdr_upgrade

View File

@ -133,9 +133,7 @@ func (sm *StateManager) Call(ctx context.Context, msg *types.Message, ts *types.
// TODO: maybe just use the invoker directly? // TODO: maybe just use the invoker directly?
ret, err := vmi.ApplyImplicitMessage(ctx, msg) ret, err := vmi.ApplyImplicitMessage(ctx, msg)
if err != nil { // Don't check for error here, we want to bubble it up, but also return ret as an InvocResult
return nil, xerrors.Errorf("apply message failed: %w", err)
}
var errs string var errs string
if ret.ActorErr != nil { if ret.ActorErr != nil {
@ -150,8 +148,7 @@ func (sm *StateManager) Call(ctx context.Context, msg *types.Message, ts *types.
ExecutionTrace: ret.ExecutionTrace, ExecutionTrace: ret.ExecutionTrace,
Error: errs, Error: errs,
Duration: ret.Duration, Duration: ret.Duration,
}, nil }, err
} }
func (sm *StateManager) CallWithGas(ctx context.Context, msg *types.Message, priorMsgs []types.ChainMsg, ts *types.TipSet) (*api.InvocResult, error) { func (sm *StateManager) CallWithGas(ctx context.Context, msg *types.Message, priorMsgs []types.ChainMsg, ts *types.TipSet) (*api.InvocResult, error) {

View File

@ -0,0 +1,284 @@
package itests
import (
"bytes"
"context"
"fmt"
"testing"
"time"
"github.com/stretchr/testify/require"
"github.com/filecoin-project/go-state-types/abi"
"github.com/filecoin-project/go-state-types/big"
"github.com/filecoin-project/go-state-types/builtin"
markettypes "github.com/filecoin-project/go-state-types/builtin/v9/market"
migration "github.com/filecoin-project/go-state-types/builtin/v9/migration/test"
verifregst "github.com/filecoin-project/go-state-types/builtin/v9/verifreg"
"github.com/filecoin-project/go-state-types/crypto"
"github.com/filecoin-project/lotus/api"
"github.com/filecoin-project/lotus/build"
"github.com/filecoin-project/lotus/chain/actors"
"github.com/filecoin-project/lotus/chain/actors/builtin/market"
"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 TestNoRemoveDatacapFromVerifreg(t *testing.T) {
ctx := context.Background()
kit.QuietMiningLogs()
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)
testClient, testMiner, 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(10 * time.Millisecond)
clientApi := testClient.FullNode.(*impl.FullNodeAPI)
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
// Before the upgrade, we need to:
// Setup a verified client
// Publish (but NOT activate) a verified storage deal from that clien
// get VRH
//stm: @CHAIN_STATE_VERIFIED_REGISTRY_ROOT_KEY_001
vrh, err := clientApi.StateVerifiedRegistryRootKey(ctx, types.TipSetKey{})
fmt.Println(vrh.String())
require.NoError(t, err)
// import the root key.
rootAddr, err := clientApi.WalletImport(ctx, &rootKey.KeyInfo)
require.NoError(t, err)
// import the verifier's key.
verifier1Addr, err := clientApi.WalletImport(ctx, &verifier1Key.KeyInfo)
require.NoError(t, err)
verifier1IDAddr, err := clientApi.StateLookupID(ctx, verifier1Addr, types.EmptyTSK)
require.NoError(t, err)
verifier2Addr, err := clientApi.WalletImport(ctx, &verifier2Key.KeyInfo)
require.NoError(t, err)
verifier2IDAddr, err := clientApi.StateLookupID(ctx, verifier2Addr, types.EmptyTSK)
require.NoError(t, err)
// import the verified client's key.
verifiedClientAddr, err := clientApi.WalletImport(ctx, &verifiedClientKey.KeyInfo)
require.NoError(t, err)
verifiedClientIDAddr, err := clientApi.StateLookupID(ctx, verifiedClientAddr, types.EmptyTSK)
require.NoError(t, err)
params, err := actors.SerializeParams(&verifregst.AddVerifierParams{Address: verifier1Addr, 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 := clientApi.MpoolPushMessage(ctx, msg, nil)
require.NoError(t, err, "AddVerifier failed")
//stm: @CHAIN_STATE_WAIT_MSG_001
res, err := clientApi.StateWaitMsg(ctx, sm.Cid(), 1, api.LookbackNoLimit, true)
require.NoError(t, err)
require.True(t, res.Receipt.ExitCode.IsSuccess())
params, err = actors.SerializeParams(&verifregst.AddVerifierParams{Address: verifier2Addr, 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 = clientApi.MpoolPushMessage(ctx, msg, nil)
require.NoError(t, err, "AddVerifier failed")
//stm: @CHAIN_STATE_WAIT_MSG_001
res, err = clientApi.StateWaitMsg(ctx, sm.Cid(), 1, api.LookbackNoLimit, true)
require.NoError(t, err)
require.True(t, res.Receipt.ExitCode.IsSuccess())
// assign datacap to a client
datacapToAssign := big.NewInt(10000)
params, err = actors.SerializeParams(&verifregst.AddVerifiedClientParams{Address: verifiedClientAddr, Allowance: datacapToAssign})
require.NoError(t, err)
msg = &types.Message{
From: verifier1Addr,
To: verifreg.Address,
Method: verifreg.Methods.AddVerifiedClient,
Params: params,
Value: big.Zero(),
}
sm, err = clientApi.MpoolPushMessage(ctx, msg, nil)
require.NoError(t, err)
//stm: @CHAIN_STATE_WAIT_MSG_001
res, err = clientApi.StateWaitMsg(ctx, sm.Cid(), 1, api.LookbackNoLimit, true)
require.NoError(t, err)
require.True(t, res.Receipt.ExitCode.IsSuccess())
// check datacap balance
//stm: @CHAIN_STATE_VERIFIED_CLIENT_STATUS_001
dc, err := clientApi.StateVerifiedClientStatus(ctx, verifiedClientAddr, types.EmptyTSK)
require.NoError(t, err)
require.Equal(t, *dc, datacapToAssign)
// END OF VERIFIED CLIENT BOILERPLATE
label, err := markettypes.NewLabelFromString("")
require.NoError(t, err)
dealStartEpoch := abi.ChainEpoch(1000)
dealProposal := markettypes.DealProposal{
PieceCID: migration.MakeCID("1", &markettypes.PieceCIDPrefix),
PieceSize: 1024,
Client: verifiedClientAddr,
Provider: testMiner.ActorAddr,
Label: label,
StartEpoch: dealStartEpoch,
EndEpoch: abi.ChainEpoch(1000_000),
StoragePricePerEpoch: big.Zero(),
ProviderCollateral: big.Zero(),
ClientCollateral: big.Zero(),
VerifiedDeal: true,
}
serializedProposal := new(bytes.Buffer)
err = dealProposal.MarshalCBOR(serializedProposal)
require.NoError(t, err)
sig, err := clientApi.WalletSign(ctx, verifiedClientAddr, serializedProposal.Bytes())
publishDealParams := markettypes.PublishStorageDealsParams{
Deals: []markettypes.ClientDealProposal{{
Proposal: dealProposal,
ClientSignature: crypto.Signature{
Type: crypto.SigTypeBLS,
Data: sig.Data,
},
}},
}
serializedParams := new(bytes.Buffer)
require.NoError(t, publishDealParams.MarshalCBOR(serializedParams))
m, err := clientApi.MpoolPushMessage(ctx, &types.Message{
To: builtin.StorageMarketActorAddr,
From: testMiner.OwnerKey.Address,
Value: types.FromFil(0),
Method: builtin.MethodsMarket.PublishStorageDeals,
Params: serializedParams.Bytes(),
}, nil)
require.NoError(t, err)
r, err := clientApi.StateWaitMsg(ctx, m.Cid(), 2, api.LookbackNoLimit, true)
require.NoError(t, err)
require.True(t, r.Receipt.ExitCode.IsSuccess())
ret, err := market.DecodePublishStorageDealsReturn(r.Receipt.Return, build.TestNetworkVersion)
require.NoError(t, err)
valid, _, err := ret.IsDealValid(0)
require.NoError(t, err)
require.True(t, valid)
verifiedClientDcap, err := clientApi.StateVerifiedClientStatus(ctx, verifiedClientIDAddr, types.EmptyTSK)
require.NoError(t, err)
// The client has already spent datacap equal to the deal's size -- this will be found in the VerifiedRegistryActor
require.Equal(t, big.Sub(datacapToAssign, big.NewIntUnsigned(uint64(dealProposal.PieceSize))), *verifiedClientDcap)
verifregDcapBefore, err := clientApi.StateVerifiedClientStatus(ctx, builtin.VerifiedRegistryActorAddr, types.EmptyTSK)
require.NoError(t, err)
// Verifreg should now have the datacap for this deal
require.Equal(t, big.NewIntUnsigned(uint64(dealProposal.PieceSize)), *verifregDcapBefore)
// Now let's try to remove datacap from Verifreg
removeProposal := verifregst.RemoveDataCapProposal{
VerifiedClient: verifreg.Address,
DataCapAmount: *verifregDcapBefore,
RemovalProposalID: verifregst.RmDcProposalID{ProposalID: 0},
}
buf := bytes.Buffer{}
buf.WriteString(verifregst.SignatureDomainSeparation_RemoveDataCap)
require.NoError(t, removeProposal.MarshalCBOR(&buf), "failed to marshal proposal")
removeProposalSer := buf.Bytes()
verifier1Sig, err := clientApi.WalletSign(ctx, verifier1Addr, removeProposalSer)
require.NoError(t, err, "failed to sign proposal")
removeRequest1 := verifregst.RemoveDataCapRequest{
Verifier: verifier1IDAddr,
VerifierSignature: *verifier1Sig,
}
verifier2Sig, err := clientApi.WalletSign(ctx, verifier2Addr, removeProposalSer)
require.NoError(t, err, "failed to sign proposal")
removeRequest2 := verifregst.RemoveDataCapRequest{
Verifier: verifier2IDAddr,
VerifierSignature: *verifier2Sig,
}
removeDataCapParams := verifregst.RemoveDataCapParams{
VerifiedClientToRemove: verifreg.Address,
DataCapAmountToRemove: *verifregDcapBefore,
VerifierRequest1: removeRequest1,
VerifierRequest2: removeRequest2,
}
params, aerr := actors.SerializeParams(&removeDataCapParams)
require.NoError(t, aerr)
callResult, err := clientApi.StateCall(ctx, &types.Message{
From: rootAddr,
To: verifreg.Address,
Method: verifreg.Methods.RemoveVerifiedClientDataCap,
Params: params,
Value: big.Zero(),
}, types.EmptyTSK)
require.False(t, callResult.MsgRct.ExitCode.IsSuccess())
verifregDatacapAfter, err := clientApi.StateVerifiedClientStatus(ctx, builtin.VerifiedRegistryActorAddr, types.EmptyTSK)
require.NoError(t, err)
require.Equal(t, *verifregDcapBefore, *verifregDatacapAfter) // Verifreg should not have lost datacap
}