317 lines
7.5 KiB
Go
317 lines
7.5 KiB
Go
package stmgr_test
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"io"
|
|
"testing"
|
|
|
|
"github.com/filecoin-project/go-address"
|
|
"github.com/filecoin-project/go-state-types/abi"
|
|
"github.com/filecoin-project/go-state-types/cbor"
|
|
"github.com/filecoin-project/specs-actors/actors/builtin"
|
|
init0 "github.com/filecoin-project/specs-actors/actors/builtin/init"
|
|
"github.com/filecoin-project/specs-actors/actors/runtime"
|
|
"github.com/stretchr/testify/require"
|
|
"golang.org/x/xerrors"
|
|
|
|
"github.com/filecoin-project/lotus/chain/actors"
|
|
"github.com/filecoin-project/lotus/chain/actors/aerrors"
|
|
lotusinit "github.com/filecoin-project/lotus/chain/actors/builtin/init"
|
|
"github.com/filecoin-project/lotus/chain/actors/policy"
|
|
"github.com/filecoin-project/lotus/chain/gen"
|
|
. "github.com/filecoin-project/lotus/chain/stmgr"
|
|
"github.com/filecoin-project/lotus/chain/types"
|
|
"github.com/filecoin-project/lotus/chain/vm"
|
|
_ "github.com/filecoin-project/lotus/lib/sigs/bls"
|
|
_ "github.com/filecoin-project/lotus/lib/sigs/secp"
|
|
|
|
"github.com/ipfs/go-cid"
|
|
ipldcbor "github.com/ipfs/go-ipld-cbor"
|
|
logging "github.com/ipfs/go-log"
|
|
cbg "github.com/whyrusleeping/cbor-gen"
|
|
)
|
|
|
|
func init() {
|
|
policy.SetSupportedProofTypes(abi.RegisteredSealProof_StackedDrg2KiBV1)
|
|
policy.SetConsensusMinerMinPower(abi.NewStoragePower(2048))
|
|
policy.SetMinVerifiedDealSize(abi.NewStoragePower(256))
|
|
}
|
|
|
|
const testForkHeight = 40
|
|
|
|
type testActor struct {
|
|
}
|
|
|
|
// must use existing actor that an account is allowed to exec.
|
|
func (testActor) Code() cid.Cid { return builtin.PaymentChannelActorCodeID }
|
|
func (testActor) State() cbor.Er { return new(testActorState) }
|
|
|
|
type testActorState struct {
|
|
HasUpgraded uint64
|
|
}
|
|
|
|
func (tas *testActorState) MarshalCBOR(w io.Writer) error {
|
|
return cbg.CborWriteHeader(w, cbg.MajUnsignedInt, tas.HasUpgraded)
|
|
}
|
|
|
|
func (tas *testActorState) UnmarshalCBOR(r io.Reader) error {
|
|
t, v, err := cbg.CborReadHeader(r)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if t != cbg.MajUnsignedInt {
|
|
return fmt.Errorf("wrong type in test actor state (got %d)", t)
|
|
}
|
|
tas.HasUpgraded = v
|
|
return nil
|
|
}
|
|
|
|
func (ta testActor) Exports() []interface{} {
|
|
return []interface{}{
|
|
1: ta.Constructor,
|
|
2: ta.TestMethod,
|
|
}
|
|
}
|
|
|
|
func (ta *testActor) Constructor(rt runtime.Runtime, params *abi.EmptyValue) *abi.EmptyValue {
|
|
rt.ValidateImmediateCallerAcceptAny()
|
|
rt.StateCreate(&testActorState{11})
|
|
//fmt.Println("NEW ACTOR ADDRESS IS: ", rt.Receiver())
|
|
|
|
return abi.Empty
|
|
}
|
|
|
|
func (ta *testActor) TestMethod(rt runtime.Runtime, params *abi.EmptyValue) *abi.EmptyValue {
|
|
rt.ValidateImmediateCallerAcceptAny()
|
|
var st testActorState
|
|
rt.StateReadonly(&st)
|
|
|
|
if rt.CurrEpoch() > testForkHeight {
|
|
if st.HasUpgraded != 55 {
|
|
panic(aerrors.Fatal("fork updating applied in wrong order"))
|
|
}
|
|
} else {
|
|
if st.HasUpgraded != 11 {
|
|
panic(aerrors.Fatal("fork updating happened too early"))
|
|
}
|
|
}
|
|
|
|
return abi.Empty
|
|
}
|
|
|
|
func TestForkHeightTriggers(t *testing.T) {
|
|
logging.SetAllLoggers(logging.LevelInfo)
|
|
|
|
ctx := context.TODO()
|
|
|
|
cg, err := gen.NewGenerator()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
// predicting the address here... may break if other assumptions change
|
|
taddr, err := address.NewIDAddress(1002)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
sm, err := NewStateManagerWithUpgradeSchedule(
|
|
cg.ChainStore(), UpgradeSchedule{{
|
|
Network: 1,
|
|
Height: testForkHeight,
|
|
Migration: func(ctx context.Context, sm *StateManager, cb ExecCallback,
|
|
root cid.Cid, height abi.ChainEpoch, ts *types.TipSet) (cid.Cid, error) {
|
|
cst := ipldcbor.NewCborStore(sm.ChainStore().Blockstore())
|
|
|
|
st, err := sm.StateTree(root)
|
|
if err != nil {
|
|
return cid.Undef, xerrors.Errorf("getting state tree: %w", err)
|
|
}
|
|
|
|
act, err := st.GetActor(taddr)
|
|
if err != nil {
|
|
return cid.Undef, err
|
|
}
|
|
|
|
var tas testActorState
|
|
if err := cst.Get(ctx, act.Head, &tas); err != nil {
|
|
return cid.Undef, xerrors.Errorf("in fork handler, failed to run get: %w", err)
|
|
}
|
|
|
|
tas.HasUpgraded = 55
|
|
|
|
ns, err := cst.Put(ctx, &tas)
|
|
if err != nil {
|
|
return cid.Undef, err
|
|
}
|
|
|
|
act.Head = ns
|
|
|
|
if err := st.SetActor(taddr, act); err != nil {
|
|
return cid.Undef, err
|
|
}
|
|
|
|
return st.Flush(ctx)
|
|
}}})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
inv := vm.NewActorRegistry()
|
|
inv.Register(nil, testActor{})
|
|
|
|
sm.SetVMConstructor(func(ctx context.Context, vmopt *vm.VMOpts) (*vm.VM, error) {
|
|
nvm, err := vm.NewVM(ctx, vmopt)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
nvm.SetInvoker(inv)
|
|
return nvm, nil
|
|
})
|
|
|
|
cg.SetStateManager(sm)
|
|
|
|
var msgs []*types.SignedMessage
|
|
|
|
enc, err := actors.SerializeParams(&init0.ExecParams{CodeCID: (testActor{}).Code()})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
m := &types.Message{
|
|
From: cg.Banker(),
|
|
To: lotusinit.Address,
|
|
Method: builtin.MethodsInit.Exec,
|
|
Params: enc,
|
|
GasLimit: types.TestGasLimit,
|
|
}
|
|
sig, err := cg.Wallet().Sign(ctx, cg.Banker(), m.Cid().Bytes())
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
msgs = append(msgs, &types.SignedMessage{
|
|
Signature: *sig,
|
|
Message: *m,
|
|
})
|
|
|
|
nonce := uint64(1)
|
|
cg.GetMessages = func(cg *gen.ChainGen) ([]*types.SignedMessage, error) {
|
|
if len(msgs) > 0 {
|
|
fmt.Println("added construct method")
|
|
m := msgs
|
|
msgs = nil
|
|
return m, nil
|
|
}
|
|
|
|
m := &types.Message{
|
|
From: cg.Banker(),
|
|
To: taddr,
|
|
Method: 2,
|
|
Params: nil,
|
|
Nonce: nonce,
|
|
GasLimit: types.TestGasLimit,
|
|
}
|
|
nonce++
|
|
|
|
sig, err := cg.Wallet().Sign(ctx, cg.Banker(), m.Cid().Bytes())
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return []*types.SignedMessage{
|
|
{
|
|
Signature: *sig,
|
|
Message: *m,
|
|
},
|
|
}, nil
|
|
}
|
|
|
|
for i := 0; i < 50; i++ {
|
|
_, err = cg.NextTipSet()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestForkRefuseCall(t *testing.T) {
|
|
logging.SetAllLoggers(logging.LevelInfo)
|
|
|
|
ctx := context.TODO()
|
|
|
|
cg, err := gen.NewGenerator()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
sm, err := NewStateManagerWithUpgradeSchedule(
|
|
cg.ChainStore(), UpgradeSchedule{{
|
|
Network: 1,
|
|
Height: testForkHeight,
|
|
Migration: func(ctx context.Context, sm *StateManager, cb ExecCallback,
|
|
root cid.Cid, height abi.ChainEpoch, ts *types.TipSet) (cid.Cid, error) {
|
|
return root, nil
|
|
}}})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
inv := vm.NewActorRegistry()
|
|
inv.Register(nil, testActor{})
|
|
|
|
sm.SetVMConstructor(func(ctx context.Context, vmopt *vm.VMOpts) (*vm.VM, error) {
|
|
nvm, err := vm.NewVM(ctx, vmopt)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
nvm.SetInvoker(inv)
|
|
return nvm, nil
|
|
})
|
|
|
|
cg.SetStateManager(sm)
|
|
|
|
enc, err := actors.SerializeParams(&init0.ExecParams{CodeCID: (testActor{}).Code()})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
m := &types.Message{
|
|
From: cg.Banker(),
|
|
To: lotusinit.Address,
|
|
Method: builtin.MethodsInit.Exec,
|
|
Params: enc,
|
|
GasLimit: types.TestGasLimit,
|
|
Value: types.NewInt(0),
|
|
GasPremium: types.NewInt(0),
|
|
GasFeeCap: types.NewInt(0),
|
|
}
|
|
|
|
for i := 0; i < 50; i++ {
|
|
ts, err := cg.NextTipSet()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
ret, err := sm.CallWithGas(ctx, m, nil, ts.TipSet.TipSet())
|
|
switch ts.TipSet.TipSet().Height() {
|
|
case testForkHeight, testForkHeight + 1:
|
|
// If I had a fork, or I _will_ have a fork, it should fail.
|
|
require.Equal(t, ErrWouldFork, err)
|
|
default:
|
|
require.NoError(t, err)
|
|
require.True(t, ret.MsgRct.ExitCode.IsSuccess())
|
|
}
|
|
// Call just runs on the parent state for a tipset, so we only
|
|
// expect an error at the fork height.
|
|
ret, err = sm.Call(ctx, m, ts.TipSet.TipSet())
|
|
switch ts.TipSet.TipSet().Height() {
|
|
case testForkHeight + 1:
|
|
require.Equal(t, ErrWouldFork, err)
|
|
default:
|
|
require.NoError(t, err)
|
|
require.True(t, ret.MsgRct.ExitCode.IsSuccess())
|
|
}
|
|
}
|
|
}
|