add a generic load method for actor state

This will make it easier to load arbitrary actors. We can:

* Type switch (sort of unsafe, may want marker methods?)
* Use this with `vm.MutateActorState`.

chain/actors/builtin/account/account.go

@@ -5,29 +5,31 @@ import (
 
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/cbor"
-	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
-	builtin1 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
+	"github.com/ipfs/go-cid"
 
 	"github.com/filecoin-project/lotus/chain/actors/adt"
+	"github.com/filecoin-project/lotus/chain/actors/builtin"
 	"github.com/filecoin-project/lotus/chain/types"
+
+	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
+	builtin1 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
 )
 
+func init() {
+	builtin.RegisterActorState(builtin0.AccountActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
+		return load0(store, root)
+	})
+	builtin.RegisterActorState(builtin1.AccountActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
+		return load1(store, root)
+	})
+}
+
 func Load(store adt.Store, act *types.Actor) (State, error) {
 	switch act.Code {
 	case builtin0.AccountActorCodeID:
-		out := state0{store: store}
-		err := store.Get(store.Context(), act.Head, &out)
-		if err != nil {
-			return nil, err
-		}
-		return &out, nil
+		return load0(store, act.Head)
 	case builtin1.AccountActorCodeID:
-		out := state1{store: store}
-		err := store.Get(store.Context(), act.Head, &out)
-		if err != nil {
-			return nil, err
-		}
-		return &out, nil
+		return load1(store, act.Head)
 	}
 	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
 }

chain/actors/builtin/account/v0.go

@@ -2,14 +2,26 @@ package account
 
 import (
 	"github.com/filecoin-project/go-address"
+	"github.com/ipfs/go-cid"
+
 	"github.com/filecoin-project/lotus/chain/actors/adt"
-	"github.com/filecoin-project/specs-actors/actors/builtin/account"
+
+	account0 "github.com/filecoin-project/specs-actors/actors/builtin/account"
 )
 
 var _ State = (*state0)(nil)
 
+func load0(store adt.Store, root cid.Cid) (State, error) {
+	out := state0{store: store}
+	err := store.Get(store.Context(), root, &out)
+	if err != nil {
+		return nil, err
+	}
+	return &out, nil
+}
+
 type state0 struct {
-	account.State
+	account0.State
 	store adt.Store
 }
 

chain/actors/builtin/account/v1.go

@@ -2,14 +2,26 @@ package account
 
 import (
 	"github.com/filecoin-project/go-address"
+	"github.com/ipfs/go-cid"
+
 	"github.com/filecoin-project/lotus/chain/actors/adt"
-	"github.com/filecoin-project/specs-actors/v2/actors/builtin/account"
+
+	account1 "github.com/filecoin-project/specs-actors/v2/actors/builtin/account"
 )
 
 var _ State = (*state1)(nil)
 
+func load1(store adt.Store, root cid.Cid) (State, error) {
+	out := state1{store: store}
+	err := store.Get(store.Context(), root, &out)
+	if err != nil {
+		return nil, err
+	}
+	return &out, nil
+}
+
 type state1 struct {
-	account.State
+	account1.State
 	store adt.Store
 }
 

chain/actors/builtin/builtin.go

@@ -1,10 +1,17 @@
 package builtin
 
 import (
+	"github.com/ipfs/go-cid"
+	"golang.org/x/xerrors"
+
 	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/cbor"
+
+	"github.com/filecoin-project/lotus/chain/actors/adt"
+	"github.com/filecoin-project/lotus/chain/types"
+
 	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
 	proof0 "github.com/filecoin-project/specs-actors/actors/runtime/proof"
-
 	smoothing0 "github.com/filecoin-project/specs-actors/actors/util/smoothing"
 	smoothing1 "github.com/filecoin-project/specs-actors/v2/actors/util/smoothing"
 )
@@ -26,3 +33,19 @@ func QAPowerForWeight(size abi.SectorSize, duration abi.ChainEpoch, dealWeight,
 func FromV1FilterEstimate(v1 smoothing1.FilterEstimate) FilterEstimate {
 	return (FilterEstimate)(v1)
 }
+
+type ActorStateLoader func(store adt.Store, root cid.Cid) (cbor.Marshaler, error)
+
+var ActorStateLoaders = make(map[cid.Cid]ActorStateLoader)
+
+func RegisterActorState(code cid.Cid, loader ActorStateLoader) {
+	ActorStateLoaders[code] = loader
+}
+
+func Load(store adt.Store, act *types.Actor) (cbor.Marshaler, error) {
+	loader, found := ActorStateLoaders[act.Code]
+	if !found {
+		return nil, xerrors.Errorf("unknown actor code %s", act.Code)
+	}
+	return loader(store, act.Head)
+}

chain/actors/builtin/init/init.go

@@ -6,32 +6,34 @@ import (
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/cbor"
-	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
-	builtin1 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
+	"github.com/ipfs/go-cid"
 
 	"github.com/filecoin-project/lotus/chain/actors/adt"
+	"github.com/filecoin-project/lotus/chain/actors/builtin"
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/node/modules/dtypes"
+
+	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
+	builtin1 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
 )
 
+func init() {
+	builtin.RegisterActorState(builtin0.InitActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
+		return load0(store, root)
+	})
+	builtin.RegisterActorState(builtin1.InitActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
+		return load1(store, root)
+	})
+}
+
 var Address = builtin0.InitActorAddr
 
 func Load(store adt.Store, act *types.Actor) (State, error) {
 	switch act.Code {
 	case builtin0.InitActorCodeID:
-		out := state0{store: store}
-		err := store.Get(store.Context(), act.Head, &out)
-		if err != nil {
-			return nil, err
-		}
-		return &out, nil
+		return load0(store, act.Head)
 	case builtin1.InitActorCodeID:
-		out := state1{store: store}
-		err := store.Get(store.Context(), act.Head, &out)
-		if err != nil {
-			return nil, err
-		}
-		return &out, nil
+		return load1(store, act.Head)
 	}
 	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
 }

chain/actors/builtin/init/v0.go

@@ -3,20 +3,30 @@ package init
 import (
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/ipfs/go-cid"
 	cbg "github.com/whyrusleeping/cbor-gen"
 	"golang.org/x/xerrors"
 
 	"github.com/filecoin-project/lotus/chain/actors/adt"
 	"github.com/filecoin-project/lotus/node/modules/dtypes"
 
-	init_ "github.com/filecoin-project/specs-actors/actors/builtin/init"
+	init0 "github.com/filecoin-project/specs-actors/actors/builtin/init"
 	adt0 "github.com/filecoin-project/specs-actors/actors/util/adt"
 )
 
 var _ State = (*state0)(nil)
 
+func load0(store adt.Store, root cid.Cid) (State, error) {
+	out := state0{store: store}
+	err := store.Get(store.Context(), root, &out)
+	if err != nil {
+		return nil, err
+	}
+	return &out, nil
+}
+
 type state0 struct {
-	init_.State
+	init0.State
 	store adt.Store
 }
 

chain/actors/builtin/init/v1.go

@@ -3,20 +3,30 @@ package init
 import (
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/ipfs/go-cid"
 	cbg "github.com/whyrusleeping/cbor-gen"
 	"golang.org/x/xerrors"
 
 	"github.com/filecoin-project/lotus/chain/actors/adt"
 	"github.com/filecoin-project/lotus/node/modules/dtypes"
 
-	init_ "github.com/filecoin-project/specs-actors/v2/actors/builtin/init"
+	init1 "github.com/filecoin-project/specs-actors/v2/actors/builtin/init"
 	adt1 "github.com/filecoin-project/specs-actors/v2/actors/util/adt"
 )
 
 var _ State = (*state1)(nil)
 
+func load1(store adt.Store, root cid.Cid) (State, error) {
+	out := state1{store: store}
+	err := store.Get(store.Context(), root, &out)
+	if err != nil {
+		return nil, err
+	}
+	return &out, nil
+}
+
 type state1 struct {
-	init_.State
+	init1.State
 	store adt.Store
 }
 

chain/actors/builtin/market/market.go

@@ -14,27 +14,27 @@ import (
 	builtin1 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
 
 	"github.com/filecoin-project/lotus/chain/actors/adt"
+	"github.com/filecoin-project/lotus/chain/actors/builtin"
 	"github.com/filecoin-project/lotus/chain/types"
 )
 
+func init() {
+	builtin.RegisterActorState(builtin0.StorageMarketActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
+		return load0(store, root)
+	})
+	builtin.RegisterActorState(builtin1.StorageMarketActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
+		return load1(store, root)
+	})
+}
+
 var Address = builtin0.StorageMarketActorAddr
 
 func Load(store adt.Store, act *types.Actor) (st State, err error) {
 	switch act.Code {
 	case builtin0.StorageMarketActorCodeID:
-		out := state0{store: store}
-		err := store.Get(store.Context(), act.Head, &out)
-		if err != nil {
-			return nil, err
-		}
-		return &out, nil
+		return load0(store, act.Head)
 	case builtin1.StorageMarketActorCodeID:
-		out := state1{store: store}
-		err := store.Get(store.Context(), act.Head, &out)
-		if err != nil {
-			return nil, err
-		}
-		return &out, nil
+		return load1(store, act.Head)
 	}
 	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
 }

chain/actors/builtin/market/v0.go

@@ -5,17 +5,29 @@ import (
 
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/ipfs/go-cid"
+	cbg "github.com/whyrusleeping/cbor-gen"
+
 	"github.com/filecoin-project/lotus/chain/actors/adt"
 	"github.com/filecoin-project/lotus/chain/types"
-	"github.com/filecoin-project/specs-actors/actors/builtin/market"
+
+	market0 "github.com/filecoin-project/specs-actors/actors/builtin/market"
 	adt0 "github.com/filecoin-project/specs-actors/actors/util/adt"
-	cbg "github.com/whyrusleeping/cbor-gen"
 )
 
 var _ State = (*state0)(nil)
 
+func load0(store adt.Store, root cid.Cid) (State, error) {
+	out := state0{store: store}
+	err := store.Get(store.Context(), root, &out)
+	if err != nil {
+		return nil, err
+	}
+	return &out, nil
+}
+
 type state0 struct {
-	market.State
+	market0.State
 	store adt.Store
 }
 
@@ -90,7 +102,7 @@ func (s *state0) LockedTable() (BalanceTable, error) {
 func (s *state0) VerifyDealsForActivation(
 	minerAddr address.Address, deals []abi.DealID, currEpoch, sectorExpiry abi.ChainEpoch,
 ) (weight, verifiedWeight abi.DealWeight, err error) {
-	return market.ValidateDealsForActivation(&s.State, s.store, deals, minerAddr, sectorExpiry, currEpoch)
+	return market0.ValidateDealsForActivation(&s.State, s.store, deals, minerAddr, sectorExpiry, currEpoch)
 }
 
 type balanceTable0 struct {
@@ -114,7 +126,7 @@ type dealStates0 struct {
 }
 
 func (s *dealStates0) Get(dealID abi.DealID) (*DealState, bool, error) {
-	var deal0 market.DealState
+	var deal0 market0.DealState
 	found, err := s.Array.Get(uint64(dealID), &deal0)
 	if err != nil {
 		return nil, false, err
@@ -127,14 +139,14 @@ func (s *dealStates0) Get(dealID abi.DealID) (*DealState, bool, error) {
 }
 
 func (s *dealStates0) ForEach(cb func(dealID abi.DealID, ds DealState) error) error {
-	var ds0 market.DealState
+	var ds0 market0.DealState
 	return s.Array.ForEach(&ds0, func(idx int64) error {
 		return cb(abi.DealID(idx), fromV0DealState(ds0))
 	})
 }
 
 func (s *dealStates0) decode(val *cbg.Deferred) (*DealState, error) {
-	var ds0 market.DealState
+	var ds0 market0.DealState
 	if err := ds0.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil {
 		return nil, err
 	}
@@ -146,7 +158,7 @@ func (s *dealStates0) array() adt.Array {
 	return s.Array
 }
 
-func fromV0DealState(v0 market.DealState) DealState {
+func fromV0DealState(v0 market0.DealState) DealState {
 	return (DealState)(v0)
 }
 
@@ -155,7 +167,7 @@ type dealProposals0 struct {
 }
 
 func (s *dealProposals0) Get(dealID abi.DealID) (*DealProposal, bool, error) {
-	var proposal0 market.DealProposal
+	var proposal0 market0.DealProposal
 	found, err := s.Array.Get(uint64(dealID), &proposal0)
 	if err != nil {
 		return nil, false, err
@@ -168,14 +180,14 @@ func (s *dealProposals0) Get(dealID abi.DealID) (*DealProposal, bool, error) {
 }
 
 func (s *dealProposals0) ForEach(cb func(dealID abi.DealID, dp DealProposal) error) error {
-	var dp0 market.DealProposal
+	var dp0 market0.DealProposal
 	return s.Array.ForEach(&dp0, func(idx int64) error {
 		return cb(abi.DealID(idx), fromV0DealProposal(dp0))
 	})
 }
 
 func (s *dealProposals0) decode(val *cbg.Deferred) (*DealProposal, error) {
-	var dp0 market.DealProposal
+	var dp0 market0.DealProposal
 	if err := dp0.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil {
 		return nil, err
 	}
@@ -187,6 +199,6 @@ func (s *dealProposals0) array() adt.Array {
 	return s.Array
 }
 
-func fromV0DealProposal(v0 market.DealProposal) DealProposal {
+func fromV0DealProposal(v0 market0.DealProposal) DealProposal {
 	return (DealProposal)(v0)
 }

chain/actors/builtin/market/v1.go

@@ -5,17 +5,29 @@ import (
 
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/ipfs/go-cid"
+	cbg "github.com/whyrusleeping/cbor-gen"
+
 	"github.com/filecoin-project/lotus/chain/actors/adt"
 	"github.com/filecoin-project/lotus/chain/types"
-	"github.com/filecoin-project/specs-actors/v2/actors/builtin/market"
+
+	market1 "github.com/filecoin-project/specs-actors/v2/actors/builtin/market"
 	adt1 "github.com/filecoin-project/specs-actors/v2/actors/util/adt"
-	cbg "github.com/whyrusleeping/cbor-gen"
 )
 
 var _ State = (*state1)(nil)
 
+func load1(store adt.Store, root cid.Cid) (State, error) {
+	out := state1{store: store}
+	err := store.Get(store.Context(), root, &out)
+	if err != nil {
+		return nil, err
+	}
+	return &out, nil
+}
+
 type state1 struct {
-	market.State
+	market1.State
 	store adt.Store
 }
 
@@ -90,7 +102,7 @@ func (s *state1) LockedTable() (BalanceTable, error) {
 func (s *state1) VerifyDealsForActivation(
 	minerAddr address.Address, deals []abi.DealID, currEpoch, sectorExpiry abi.ChainEpoch,
 ) (weight, verifiedWeight abi.DealWeight, err error) {
-	w, vw, _, err := market.ValidateDealsForActivation(&s.State, s.store, deals, minerAddr, sectorExpiry, currEpoch)
+	w, vw, _, err := market1.ValidateDealsForActivation(&s.State, s.store, deals, minerAddr, sectorExpiry, currEpoch)
 	return w, vw, err
 }
 
@@ -115,7 +127,7 @@ type dealStates1 struct {
 }
 
 func (s *dealStates1) Get(dealID abi.DealID) (*DealState, bool, error) {
-	var deal1 market.DealState
+	var deal1 market1.DealState
 	found, err := s.Array.Get(uint64(dealID), &deal1)
 	if err != nil {
 		return nil, false, err
@@ -128,14 +140,14 @@ func (s *dealStates1) Get(dealID abi.DealID) (*DealState, bool, error) {
 }
 
 func (s *dealStates1) ForEach(cb func(dealID abi.DealID, ds DealState) error) error {
-	var ds1 market.DealState
+	var ds1 market1.DealState
 	return s.Array.ForEach(&ds1, func(idx int64) error {
 		return cb(abi.DealID(idx), fromV1DealState(ds1))
 	})
 }
 
 func (s *dealStates1) decode(val *cbg.Deferred) (*DealState, error) {
-	var ds1 market.DealState
+	var ds1 market1.DealState
 	if err := ds1.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil {
 		return nil, err
 	}
@@ -147,7 +159,7 @@ func (s *dealStates1) array() adt.Array {
 	return s.Array
 }
 
-func fromV1DealState(v1 market.DealState) DealState {
+func fromV1DealState(v1 market1.DealState) DealState {
 	return (DealState)(v1)
 }
 
@@ -156,7 +168,7 @@ type dealProposals1 struct {
 }
 
 func (s *dealProposals1) Get(dealID abi.DealID) (*DealProposal, bool, error) {
-	var proposal1 market.DealProposal
+	var proposal1 market1.DealProposal
 	found, err := s.Array.Get(uint64(dealID), &proposal1)
 	if err != nil {
 		return nil, false, err
@@ -169,14 +181,14 @@ func (s *dealProposals1) Get(dealID abi.DealID) (*DealProposal, bool, error) {
 }
 
 func (s *dealProposals1) ForEach(cb func(dealID abi.DealID, dp DealProposal) error) error {
-	var dp1 market.DealProposal
+	var dp1 market1.DealProposal
 	return s.Array.ForEach(&dp1, func(idx int64) error {
 		return cb(abi.DealID(idx), fromV1DealProposal(dp1))
 	})
 }
 
 func (s *dealProposals1) decode(val *cbg.Deferred) (*DealProposal, error) {
-	var dp1 market.DealProposal
+	var dp1 market1.DealProposal
 	if err := dp1.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil {
 		return nil, err
 	}
@@ -188,6 +200,6 @@ func (s *dealProposals1) array() adt.Array {
 	return s.Array
 }
 
-func fromV1DealProposal(v1 market.DealProposal) DealProposal {
+func fromV1DealProposal(v1 market1.DealProposal) DealProposal {
 	return (DealProposal)(v1)
 }

chain/actors/builtin/miner/miner.go

@@ -13,6 +13,7 @@ import (
 	"github.com/filecoin-project/go-state-types/dline"
 
 	"github.com/filecoin-project/lotus/chain/actors/adt"
+	"github.com/filecoin-project/lotus/chain/actors/builtin"
 	"github.com/filecoin-project/lotus/chain/types"
 
 	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
@@ -20,6 +21,15 @@ import (
 	builtin1 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
 )
 
+func init() {
+	builtin.RegisterActorState(builtin0.StorageMinerActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
+		return load0(store, root)
+	})
+	builtin.RegisterActorState(builtin1.StorageMinerActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
+		return load1(store, root)
+	})
+}
+
 // Unchanged between v0 and v1 actors
 var WPoStProvingPeriod = miner0.WPoStProvingPeriod
 
@@ -28,19 +38,9 @@ const MinSectorExpiration = miner0.MinSectorExpiration
 func Load(store adt.Store, act *types.Actor) (st State, err error) {
 	switch act.Code {
 	case builtin0.StorageMinerActorCodeID:
-		out := state0{store: store}
-		err := store.Get(store.Context(), act.Head, &out)
-		if err != nil {
-			return nil, err
-		}
-		return &out, nil
+		return load0(store, act.Head)
 	case builtin1.StorageMinerActorCodeID:
-		out := state1{store: store}
-		err := store.Get(store.Context(), act.Head, &out)
-		if err != nil {
-			return nil, err
-		}
-		return &out, nil
+		return load1(store, act.Head)
 	}
 	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
 }

chain/actors/builtin/miner/v0.go

@@ -4,21 +4,31 @@ import (
 	"bytes"
 	"errors"
 
-	"github.com/libp2p/go-libp2p-core/peer"
-	cbg "github.com/whyrusleeping/cbor-gen"
-
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-bitfield"
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/dline"
-	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
-	adt0 "github.com/filecoin-project/specs-actors/actors/util/adt"
+	"github.com/ipfs/go-cid"
+	"github.com/libp2p/go-libp2p-core/peer"
+	cbg "github.com/whyrusleeping/cbor-gen"
 
 	"github.com/filecoin-project/lotus/chain/actors/adt"
+
+	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
+	adt0 "github.com/filecoin-project/specs-actors/actors/util/adt"
 )
 
 var _ State = (*state0)(nil)
 
+func load0(store adt.Store, root cid.Cid) (State, error) {
+	out := state0{store: store}
+	err := store.Get(store.Context(), root, &out)
+	if err != nil {
+		return nil, err
+	}
+	return &out, nil
+}
+
 type state0 struct {
 	miner0.State
 	store adt.Store

chain/actors/builtin/miner/v1.go

@@ -8,16 +8,27 @@ import (
 	"github.com/filecoin-project/go-bitfield"
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/dline"
-	"github.com/filecoin-project/lotus/chain/actors/adt"
-	adt1 "github.com/filecoin-project/specs-actors/v2/actors/util/adt"
+	"github.com/ipfs/go-cid"
 	"github.com/libp2p/go-libp2p-core/peer"
 	cbg "github.com/whyrusleeping/cbor-gen"
 
+	"github.com/filecoin-project/lotus/chain/actors/adt"
+
 	miner1 "github.com/filecoin-project/specs-actors/v2/actors/builtin/miner"
+	adt1 "github.com/filecoin-project/specs-actors/v2/actors/util/adt"
 )
 
 var _ State = (*state1)(nil)
 
+func load1(store adt.Store, root cid.Cid) (State, error) {
+	out := state1{store: store}
+	err := store.Get(store.Context(), root, &out)
+	if err != nil {
+		return nil, err
+	}
+	return &out, nil
+}
+
 type state1 struct {
 	miner1.State
 	store adt.Store

chain/actors/builtin/multisig/multisig.go

@@ -6,31 +6,32 @@ import (
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/cbor"
+	"github.com/ipfs/go-cid"
 
 	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
 	msig0 "github.com/filecoin-project/specs-actors/actors/builtin/multisig"
 	builtin1 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
 
 	"github.com/filecoin-project/lotus/chain/actors/adt"
+	"github.com/filecoin-project/lotus/chain/actors/builtin"
 	"github.com/filecoin-project/lotus/chain/types"
 )
 
+func init() {
+	builtin.RegisterActorState(builtin0.MultisigActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
+		return load0(store, root)
+	})
+	builtin.RegisterActorState(builtin1.MultisigActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
+		return load1(store, root)
+	})
+}
+
 func Load(store adt.Store, act *types.Actor) (State, error) {
 	switch act.Code {
 	case builtin0.MultisigActorCodeID:
-		out := state0{store: store}
-		err := store.Get(store.Context(), act.Head, &out)
-		if err != nil {
-			return nil, err
-		}
-		return &out, nil
+		return load0(store, act.Head)
 	case builtin1.MultisigActorCodeID:
-		out := state1{store: store}
-		err := store.Get(store.Context(), act.Head, &out)
-		if err != nil {
-			return nil, err
-		}
-		return &out, nil
+		return load1(store, act.Head)
 	}
 	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
 }

chain/actors/builtin/multisig/v0.go

@@ -5,15 +5,26 @@ import (
 
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/lotus/chain/actors/adt"
+	"github.com/ipfs/go-cid"
 	"golang.org/x/xerrors"
 
+	"github.com/filecoin-project/lotus/chain/actors/adt"
+
 	msig0 "github.com/filecoin-project/specs-actors/actors/builtin/multisig"
 	adt0 "github.com/filecoin-project/specs-actors/actors/util/adt"
 )
 
 var _ State = (*state0)(nil)
 
+func load0(store adt.Store, root cid.Cid) (State, error) {
+	out := state0{store: store}
+	err := store.Get(store.Context(), root, &out)
+	if err != nil {
+		return nil, err
+	}
+	return &out, nil
+}
+
 type state0 struct {
 	msig0.State
 	store adt.Store

chain/actors/builtin/multisig/v1.go

@@ -5,15 +5,26 @@ import (
 
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/lotus/chain/actors/adt"
+	"github.com/ipfs/go-cid"
 	"golang.org/x/xerrors"
 
+	"github.com/filecoin-project/lotus/chain/actors/adt"
+
 	msig1 "github.com/filecoin-project/specs-actors/actors/builtin/multisig"
 	adt1 "github.com/filecoin-project/specs-actors/actors/util/adt"
 )
 
 var _ State = (*state1)(nil)
 
+func load1(store adt.Store, root cid.Cid) (State, error) {
+	out := state1{store: store}
+	err := store.Get(store.Context(), root, &out)
+	if err != nil {
+		return nil, err
+	}
+	return &out, nil
+}
+
 type state1 struct {
 	msig1.State
 	store adt.Store

chain/actors/builtin/paych/paych.go

@@ -7,32 +7,33 @@ import (
 	"github.com/filecoin-project/go-state-types/abi"
 	big "github.com/filecoin-project/go-state-types/big"
 	"github.com/filecoin-project/go-state-types/cbor"
+	"github.com/ipfs/go-cid"
 
 	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
 	paych0 "github.com/filecoin-project/specs-actors/actors/builtin/paych"
 	builtin1 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
 
 	"github.com/filecoin-project/lotus/chain/actors/adt"
+	"github.com/filecoin-project/lotus/chain/actors/builtin"
 	"github.com/filecoin-project/lotus/chain/types"
 )
 
+func init() {
+	builtin.RegisterActorState(builtin0.PaymentChannelActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
+		return load0(store, root)
+	})
+	builtin.RegisterActorState(builtin1.PaymentChannelActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
+		return load1(store, root)
+	})
+}
+
 // Load returns an abstract copy of payment channel state, irregardless of actor version
 func Load(store adt.Store, act *types.Actor) (State, error) {
 	switch act.Code {
 	case builtin0.PaymentChannelActorCodeID:
-		out := state0{store: store}
-		err := store.Get(store.Context(), act.Head, &out)
-		if err != nil {
-			return nil, err
-		}
-		return &out, nil
+		return load0(store, act.Head)
 	case builtin1.PaymentChannelActorCodeID:
-		out := state1{store: store}
-		err := store.Get(store.Context(), act.Head, &out)
-		if err != nil {
-			return nil, err
-		}
-		return &out, nil
+		return load1(store, act.Head)
 	}
 	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
 }

chain/actors/builtin/paych/v0.go

@@ -1,18 +1,31 @@
 package paych
 
 import (
+	"github.com/ipfs/go-cid"
+
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
-	big "github.com/filecoin-project/go-state-types/big"
+	"github.com/filecoin-project/go-state-types/big"
+
 	"github.com/filecoin-project/lotus/chain/actors/adt"
-	"github.com/filecoin-project/specs-actors/actors/builtin/paych"
+
+	paych0 "github.com/filecoin-project/specs-actors/actors/builtin/paych"
 	adt0 "github.com/filecoin-project/specs-actors/actors/util/adt"
 )
 
 var _ State = (*state0)(nil)
 
+func load0(store adt.Store, root cid.Cid) (State, error) {
+	out := state0{store: store}
+	err := store.Get(store.Context(), root, &out)
+	if err != nil {
+		return nil, err
+	}
+	return &out, nil
+}
+
 type state0 struct {
-	paych.State
+	paych0.State
 	store adt.Store
 	lsAmt *adt0.Array
 }
@@ -72,14 +85,14 @@ func (s *state0) ForEachLaneState(cb func(idx uint64, dl LaneState) error) error
 	// Note: we use a map instead of an array to store laneStates because the
 	// client sets the lane ID (the index) and potentially they could use a
 	// very large index.
-	var ls paych.LaneState
+	var ls paych0.LaneState
 	return lsamt.ForEach(&ls, func(i int64) error {
 		return cb(uint64(i), &laneState0{ls})
 	})
 }
 
 type laneState0 struct {
-	paych.LaneState
+	paych0.LaneState
 }
 
 func (ls *laneState0) Redeemed() (big.Int, error) {

chain/actors/builtin/paych/v1.go

@@ -1,18 +1,31 @@
 package paych
 
 import (
+	"github.com/ipfs/go-cid"
+
 	"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/lotus/chain/actors/adt"
-	"github.com/filecoin-project/specs-actors/v2/actors/builtin/paych"
+
+	paych1 "github.com/filecoin-project/specs-actors/v2/actors/builtin/paych"
 	adt1 "github.com/filecoin-project/specs-actors/v2/actors/util/adt"
 )
 
 var _ State = (*state1)(nil)
 
+func load1(store adt.Store, root cid.Cid) (State, error) {
+	out := state1{store: store}
+	err := store.Get(store.Context(), root, &out)
+	if err != nil {
+		return nil, err
+	}
+	return &out, nil
+}
+
 type state1 struct {
-	paych.State
+	paych1.State
 	store adt.Store
 	lsAmt *adt1.Array
 }
@@ -72,14 +85,14 @@ func (s *state1) ForEachLaneState(cb func(idx uint64, dl LaneState) error) error
 	// Note: we use a map instead of an array to store laneStates because the
 	// client sets the lane ID (the index) and potentially they could use a
 	// very large index.
-	var ls paych.LaneState
+	var ls paych1.LaneState
 	return lsamt.ForEach(&ls, func(i int64) error {
 		return cb(uint64(i), &laneState1{ls})
 	})
 }
 
 type laneState1 struct {
-	paych.LaneState
+	paych1.LaneState
 }
 
 func (ls *laneState1) Redeemed() (big.Int, error) {

chain/actors/builtin/power/power.go

@@ -2,6 +2,7 @@ package power
 
 import (
 	"github.com/filecoin-project/go-address"
+	"github.com/ipfs/go-cid"
 	"golang.org/x/xerrors"
 
 	"github.com/filecoin-project/go-state-types/abi"
@@ -15,24 +16,23 @@ import (
 	builtin1 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
 )
 
+func init() {
+	builtin.RegisterActorState(builtin0.StoragePowerActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
+		return load0(store, root)
+	})
+	builtin.RegisterActorState(builtin1.StoragePowerActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
+		return load1(store, root)
+	})
+}
+
 var Address = builtin0.StoragePowerActorAddr
 
 func Load(store adt.Store, act *types.Actor) (st State, err error) {
 	switch act.Code {
 	case builtin0.StoragePowerActorCodeID:
-		out := state0{store: store}
-		err := store.Get(store.Context(), act.Head, &out)
-		if err != nil {
-			return nil, err
-		}
-		return &out, nil
+		return load0(store, act.Head)
 	case builtin1.StoragePowerActorCodeID:
-		out := state1{store: store}
-		err := store.Get(store.Context(), act.Head, &out)
-		if err != nil {
-			return nil, err
-		}
-		return &out, nil
+		return load1(store, act.Head)
 	}
 	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
 }

chain/actors/builtin/power/v0.go

@@ -3,6 +3,8 @@ package power
 import (
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/ipfs/go-cid"
+
 	"github.com/filecoin-project/lotus/chain/actors/adt"
 	"github.com/filecoin-project/lotus/chain/actors/builtin"
 
@@ -12,6 +14,15 @@ import (
 
 var _ State = (*state0)(nil)
 
+func load0(store adt.Store, root cid.Cid) (State, error) {
+	out := state0{store: store}
+	err := store.Get(store.Context(), root, &out)
+	if err != nil {
+		return nil, err
+	}
+	return &out, nil
+}
+
 type state0 struct {
 	power0.State
 	store adt.Store

chain/actors/builtin/power/v1.go

@@ -3,6 +3,8 @@ package power
 import (
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/ipfs/go-cid"
+
 	"github.com/filecoin-project/lotus/chain/actors/adt"
 	"github.com/filecoin-project/lotus/chain/actors/builtin"
 
@@ -12,6 +14,15 @@ import (
 
 var _ State = (*state1)(nil)
 
+func load1(store adt.Store, root cid.Cid) (State, error) {
+	out := state1{store: store}
+	err := store.Get(store.Context(), root, &out)
+	if err != nil {
+		return nil, err
+	}
+	return &out, nil
+}
+
 type state1 struct {
 	power1.State
 	store adt.Store

chain/actors/builtin/reward/reward.go

@@ -3,6 +3,7 @@ package reward
 import (
 	"github.com/filecoin-project/go-state-types/abi"
 	reward0 "github.com/filecoin-project/specs-actors/actors/builtin/reward"
+	"github.com/ipfs/go-cid"
 	"golang.org/x/xerrors"
 
 	"github.com/filecoin-project/go-state-types/cbor"
@@ -14,24 +15,23 @@ import (
 	"github.com/filecoin-project/lotus/chain/types"
 )
 
+func init() {
+	builtin.RegisterActorState(builtin0.RewardActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
+		return load0(store, root)
+	})
+	builtin.RegisterActorState(builtin1.RewardActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
+		return load1(store, root)
+	})
+}
+
 var Address = builtin0.RewardActorAddr
 
 func Load(store adt.Store, act *types.Actor) (st State, err error) {
 	switch act.Code {
 	case builtin0.RewardActorCodeID:
-		out := state0{store: store}
-		err := store.Get(store.Context(), act.Head, &out)
-		if err != nil {
-			return nil, err
-		}
-		return &out, nil
+		return load0(store, act.Head)
 	case builtin1.RewardActorCodeID:
-		out := state1{store: store}
-		err := store.Get(store.Context(), act.Head, &out)
-		if err != nil {
-			return nil, err
-		}
-		return &out, nil
+		return load1(store, act.Head)
 	}
 	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
 }

chain/actors/builtin/reward/v0.go

@@ -2,6 +2,8 @@ package reward
 
 import (
 	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/ipfs/go-cid"
+
 	"github.com/filecoin-project/lotus/chain/actors/adt"
 	"github.com/filecoin-project/lotus/chain/actors/builtin"
 
@@ -12,6 +14,15 @@ import (
 
 var _ State = (*state0)(nil)
 
+func load0(store adt.Store, root cid.Cid) (State, error) {
+	out := state0{store: store}
+	err := store.Get(store.Context(), root, &out)
+	if err != nil {
+		return nil, err
+	}
+	return &out, nil
+}
+
 type state0 struct {
 	reward0.State
 	store adt.Store

chain/actors/builtin/reward/v1.go

@@ -2,6 +2,8 @@ package reward
 
 import (
 	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/ipfs/go-cid"
+
 	"github.com/filecoin-project/lotus/chain/actors/adt"
 	"github.com/filecoin-project/lotus/chain/actors/builtin"
 
@@ -12,6 +14,15 @@ import (
 
 var _ State = (*state1)(nil)
 
+func load1(store adt.Store, root cid.Cid) (State, error) {
+	out := state1{store: store}
+	err := store.Get(store.Context(), root, &out)
+	if err != nil {
+		return nil, err
+	}
+	return &out, nil
+}
+
 type state1 struct {
 	reward1.State
 	store adt.Store

chain/actors/builtin/verifreg/v0.go

@@ -3,6 +3,7 @@ package verifreg
 import (
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/ipfs/go-cid"
 
 	"github.com/filecoin-project/lotus/chain/actors"
 	"github.com/filecoin-project/lotus/chain/actors/adt"
@@ -12,6 +13,15 @@ import (
 
 var _ State = (*state0)(nil)
 
+func load0(store adt.Store, root cid.Cid) (State, error) {
+	out := state0{store: store}
+	err := store.Get(store.Context(), root, &out)
+	if err != nil {
+		return nil, err
+	}
+	return &out, nil
+}
+
 type state0 struct {
 	verifreg0.State
 	store adt.Store

chain/actors/builtin/verifreg/v1.go

@@ -3,6 +3,7 @@ package verifreg
 import (
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/ipfs/go-cid"
 
 	"github.com/filecoin-project/lotus/chain/actors"
 	"github.com/filecoin-project/lotus/chain/actors/adt"
@@ -12,6 +13,15 @@ import (
 
 var _ State = (*state1)(nil)
 
+func load1(store adt.Store, root cid.Cid) (State, error) {
+	out := state1{store: store}
+	err := store.Get(store.Context(), root, &out)
+	if err != nil {
+		return nil, err
+	}
+	return &out, nil
+}
+
 type state1 struct {
 	verifreg1.State
 	store adt.Store

chain/actors/builtin/verifreg/verifreg.go

@@ -3,6 +3,7 @@ package verifreg
 import (
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/ipfs/go-cid"
 	"golang.org/x/xerrors"
 
 	"github.com/filecoin-project/go-state-types/cbor"
@@ -10,27 +11,27 @@ import (
 	builtin1 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
 
 	"github.com/filecoin-project/lotus/chain/actors/adt"
+	"github.com/filecoin-project/lotus/chain/actors/builtin"
 	"github.com/filecoin-project/lotus/chain/types"
 )
 
+func init() {
+	builtin.RegisterActorState(builtin0.VerifiedRegistryActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
+		return load0(store, root)
+	})
+	builtin.RegisterActorState(builtin1.VerifiedRegistryActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
+		return load1(store, root)
+	})
+}
+
 var Address = builtin0.VerifiedRegistryActorAddr
 
 func Load(store adt.Store, act *types.Actor) (State, error) {
 	switch act.Code {
 	case builtin0.VerifiedRegistryActorCodeID:
-		out := state0{store: store}
-		err := store.Get(store.Context(), act.Head, &out)
-		if err != nil {
-			return nil, err
-		}
-		return &out, nil
+		return load0(store, act.Head)
 	case builtin1.VerifiedRegistryActorCodeID:
-		out := state1{store: store}
-		err := store.Get(store.Context(), act.Head, &out)
-		if err != nil {
-			return nil, err
-		}
-		return &out, nil
+		return load1(store, act.Head)
 	}
 	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
 }