Butterfly genesis

Update to actors v2.0.1

api/api_full.go

@@ -192,6 +192,9 @@ type FullNode interface {
 	// MpoolPush pushes a signed message to mempool.
 	MpoolPush(context.Context, *types.SignedMessage) (cid.Cid, error)
 
+	// MpoolPushUntrusted pushes a signed message to mempool from untrusted sources.
+	MpoolPushUntrusted(context.Context, *types.SignedMessage) (cid.Cid, error)
+
 	// MpoolPushMessage atomically assigns a nonce, signs, and pushes a message
 	// to mempool.
 	// maxFee is only used when GasFeeCap/GasPremium fields aren't specified
@@ -390,10 +393,16 @@ type FullNode interface {
 	// StateCompute is a flexible command that applies the given messages on the given tipset.
 	// The messages are run as though the VM were at the provided height.
 	StateCompute(context.Context, abi.ChainEpoch, []*types.Message, types.TipSetKey) (*ComputeStateOutput, error)
+	// StateVerifierStatus returns the data cap for the given address.
+	// Returns nil if there is no entry in the data cap table for the
+	// address.
+	StateVerifierStatus(ctx context.Context, addr address.Address, tsk types.TipSetKey) (*abi.StoragePower, error)
 	// StateVerifiedClientStatus returns the data cap for the given address.
 	// Returns nil if there is no entry in the data cap table for the
 	// address.
 	StateVerifiedClientStatus(ctx context.Context, addr address.Address, tsk types.TipSetKey) (*abi.StoragePower, error)
+	// StateVerifiedClientStatus returns the address of the Verified Registry's root key
+	StateVerifiedRegistryRootKey(ctx context.Context, tsk types.TipSetKey) (address.Address, error)
 	// StateDealProviderCollateralBounds returns the min and max collateral a storage provider
 	// can issue. It takes the deal size and verified status as parameters.
 	StateDealProviderCollateralBounds(context.Context, abi.PaddedPieceSize, bool, types.TipSetKey) (DealCollateralBounds, error)
@@ -475,6 +484,12 @@ type FullNode interface {
 	PaychVoucherAdd(context.Context, address.Address, *paych.SignedVoucher, []byte, types.BigInt) (types.BigInt, error)
 	PaychVoucherList(context.Context, address.Address) ([]*paych.SignedVoucher, error)
 	PaychVoucherSubmit(context.Context, address.Address, *paych.SignedVoucher, []byte, []byte) (cid.Cid, error)
+
+	// CreateBackup creates node backup onder the specified file name. The
+	// method requires that the lotus daemon is running with the
+	// LOTUS_BACKUP_BASE_PATH environment variable set to some path, and that
+	// the path specified when calling CreateBackup is within the base path
+	CreateBackup(ctx context.Context, fpath string) error
 }
 
 type FileRef struct {
@@ -521,6 +536,7 @@ type DealInfo struct {
 	DealID abi.DealID
 
 	CreationTime time.Time
+	Verified     bool
 }
 
 type MsgLookup struct {
@@ -796,14 +812,14 @@ type CirculatingSupply struct {
 }
 
 type MiningBaseInfo struct {
-	MinerPower      types.BigInt
-	NetworkPower    types.BigInt
-	Sectors         []builtin.SectorInfo
-	WorkerKey       address.Address
-	SectorSize      abi.SectorSize
-	PrevBeaconEntry types.BeaconEntry
-	BeaconEntries   []types.BeaconEntry
-	HasMinPower     bool
+	MinerPower        types.BigInt
+	NetworkPower      types.BigInt
+	Sectors           []builtin.SectorInfo
+	WorkerKey         address.Address
+	SectorSize        abi.SectorSize
+	PrevBeaconEntry   types.BeaconEntry
+	BeaconEntries     []types.BeaconEntry
+	EligibleForMining bool
 }
 
 type BlockTemplate struct {

api/api_storage.go

@@ -101,6 +101,12 @@ type StorageMiner interface {
 	PiecesListCidInfos(ctx context.Context) ([]cid.Cid, error)
 	PiecesGetPieceInfo(ctx context.Context, pieceCid cid.Cid) (*piecestore.PieceInfo, error)
 	PiecesGetCIDInfo(ctx context.Context, payloadCid cid.Cid) (*piecestore.CIDInfo, error)
+
+	// CreateBackup creates node backup onder the specified file name. The
+	// method requires that the lotus-miner is running with the
+	// LOTUS_BACKUP_BASE_PATH environment variable set to some path, and that
+	// the path specified when calling CreateBackup is within the base path
+	CreateBackup(ctx context.Context, fpath string) error
 }
 
 type SealRes struct {

api/apistruct/struct.go

@@ -122,7 +122,9 @@ type FullNodeStruct struct {
 		MpoolPending func(context.Context, types.TipSetKey) ([]*types.SignedMessage, error) `perm:"read"`
 		MpoolClear   func(context.Context, bool) error                                      `perm:"write"`
 
-		MpoolPush        func(context.Context, *types.SignedMessage) (cid.Cid, error)                              `perm:"write"`
+		MpoolPush          func(context.Context, *types.SignedMessage) (cid.Cid, error) `perm:"write"`
+		MpoolPushUntrusted func(context.Context, *types.SignedMessage) (cid.Cid, error) `perm:"write"`
+
 		MpoolPushMessage func(context.Context, *types.Message, *api.MessageSendSpec) (*types.SignedMessage, error) `perm:"sign"`
 		MpoolGetNonce    func(context.Context, address.Address) (uint64, error)                                    `perm:"read"`
 		MpoolSub         func(context.Context) (<-chan api.MpoolUpdate, error)                                     `perm:"read"`
@@ -202,7 +204,9 @@ type FullNodeStruct struct {
 		StateMinerSectorCount              func(context.Context, address.Address, types.TipSetKey) (api.MinerSectors, error)                                   `perm:"read"`
 		StateListMessages                  func(ctx context.Context, match *types.Message, tsk types.TipSetKey, toht abi.ChainEpoch) ([]cid.Cid, error)        `perm:"read"`
 		StateCompute                       func(context.Context, abi.ChainEpoch, []*types.Message, types.TipSetKey) (*api.ComputeStateOutput, error)           `perm:"read"`
+		StateVerifierStatus                func(context.Context, address.Address, types.TipSetKey) (*abi.StoragePower, error)                                  `perm:"read"`
 		StateVerifiedClientStatus          func(context.Context, address.Address, types.TipSetKey) (*abi.StoragePower, error)                                  `perm:"read"`
+		StateVerifiedRegistryRootKey       func(ctx context.Context, tsk types.TipSetKey) (address.Address, error)                                             `perm:"read"`
 		StateDealProviderCollateralBounds  func(context.Context, abi.PaddedPieceSize, bool, types.TipSetKey) (api.DealCollateralBounds, error)                 `perm:"read"`
 		StateCirculatingSupply             func(context.Context, types.TipSetKey) (api.CirculatingSupply, error)                                               `perm:"read"`
 		StateNetworkVersion                func(context.Context, types.TipSetKey) (stnetwork.Version, error)                                                   `perm:"read"`
@@ -239,6 +243,8 @@ type FullNodeStruct struct {
 		PaychVoucherCreate          func(context.Context, address.Address, big.Int, uint64) (*api.VoucherCreateResult, error)                 `perm:"sign"`
 		PaychVoucherList            func(context.Context, address.Address) ([]*paych.SignedVoucher, error)                                    `perm:"write"`
 		PaychVoucherSubmit          func(context.Context, address.Address, *paych.SignedVoucher, []byte, []byte) (cid.Cid, error)             `perm:"sign"`
+
+		CreateBackup func(ctx context.Context, fpath string) error `perm:"admin"`
 	}
 }
 
@@ -319,6 +325,8 @@ type StorageMinerStruct struct {
 		PiecesListCidInfos func(ctx context.Context) ([]cid.Cid, error)                               `perm:"read"`
 		PiecesGetPieceInfo func(ctx context.Context, pieceCid cid.Cid) (*piecestore.PieceInfo, error) `perm:"read"`
 		PiecesGetCIDInfo   func(ctx context.Context, payloadCid cid.Cid) (*piecestore.CIDInfo, error) `perm:"read"`
+
+		CreateBackup func(ctx context.Context, fpath string) error `perm:"admin"`
 	}
 }
 
@@ -553,6 +561,10 @@ func (c *FullNodeStruct) MpoolPush(ctx context.Context, smsg *types.SignedMessag
 	return c.Internal.MpoolPush(ctx, smsg)
 }
 
+func (c *FullNodeStruct) MpoolPushUntrusted(ctx context.Context, smsg *types.SignedMessage) (cid.Cid, error) {
+	return c.Internal.MpoolPushUntrusted(ctx, smsg)
+}
+
 func (c *FullNodeStruct) MpoolPushMessage(ctx context.Context, msg *types.Message, spec *api.MessageSendSpec) (*types.SignedMessage, error) {
 	return c.Internal.MpoolPushMessage(ctx, msg, spec)
 }
@@ -893,10 +905,18 @@ func (c *FullNodeStruct) StateCompute(ctx context.Context, height abi.ChainEpoch
 	return c.Internal.StateCompute(ctx, height, msgs, tsk)
 }
 
+func (c *FullNodeStruct) StateVerifierStatus(ctx context.Context, addr address.Address, tsk types.TipSetKey) (*abi.StoragePower, error) {
+	return c.Internal.StateVerifierStatus(ctx, addr, tsk)
+}
+
 func (c *FullNodeStruct) StateVerifiedClientStatus(ctx context.Context, addr address.Address, tsk types.TipSetKey) (*abi.StoragePower, error) {
 	return c.Internal.StateVerifiedClientStatus(ctx, addr, tsk)
 }
 
+func (c *FullNodeStruct) StateVerifiedRegistryRootKey(ctx context.Context, tsk types.TipSetKey) (address.Address, error) {
+	return c.Internal.StateVerifiedRegistryRootKey(ctx, tsk)
+}
+
 func (c *FullNodeStruct) StateDealProviderCollateralBounds(ctx context.Context, size abi.PaddedPieceSize, verified bool, tsk types.TipSetKey) (api.DealCollateralBounds, error) {
 	return c.Internal.StateDealProviderCollateralBounds(ctx, size, verified, tsk)
 }
@@ -1025,6 +1045,10 @@ func (c *FullNodeStruct) PaychVoucherSubmit(ctx context.Context, ch address.Addr
 	return c.Internal.PaychVoucherSubmit(ctx, ch, sv, secret, proof)
 }
 
+func (c *FullNodeStruct) CreateBackup(ctx context.Context, fpath string) error {
+	return c.Internal.CreateBackup(ctx, fpath)
+}
+
 // StorageMinerStruct
 
 func (c *StorageMinerStruct) ActorAddress(ctx context.Context) (address.Address, error) {
@@ -1265,6 +1289,10 @@ func (c *StorageMinerStruct) PiecesGetCIDInfo(ctx context.Context, payloadCid ci
 	return c.Internal.PiecesGetCIDInfo(ctx, payloadCid)
 }
 
+func (c *StorageMinerStruct) CreateBackup(ctx context.Context, fpath string) error {
+	return c.Internal.CreateBackup(ctx, fpath)
+}
+
 // WorkerStruct
 
 func (w *WorkerStruct) Version(ctx context.Context) (build.Version, error) {

api/test/ccupgrade.go

@@ -12,15 +12,36 @@ import (
 
 	"github.com/filecoin-project/go-state-types/abi"
 
+	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/stmgr"
 	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/node"
 	"github.com/filecoin-project/lotus/node/impl"
 )
 
 func TestCCUpgrade(t *testing.T, b APIBuilder, blocktime time.Duration) {
 	_ = os.Setenv("BELLMAN_NO_GPU", "1")
 
+	for _, height := range []abi.ChainEpoch{
+		1,    // before
+		162,  // while sealing
+		520,  // after upgrade deal
+		5000, // after
+	} {
+		height := height // make linters happy by copying
+		t.Run(fmt.Sprintf("upgrade-%d", height), func(t *testing.T) {
+			testCCUpgrade(t, b, blocktime, height)
+		})
+	}
+}
+
+func testCCUpgrade(t *testing.T, b APIBuilder, blocktime time.Duration, upgradeHeight abi.ChainEpoch) {
 	ctx := context.Background()
-	n, sn := b(t, 1, OneMiner)
+	n, sn := b(t, 1, OneMiner, node.Override(new(stmgr.UpgradeSchedule), stmgr.UpgradeSchedule{{
+		Network:   build.ActorUpgradeNetworkVersion,
+		Height:    upgradeHeight,
+		Migration: stmgr.UpgradeActorsV2,
+	}}))
 	client := n[0].FullNode.(*impl.FullNodeAPI)
 	miner := sn[0]
 

api/test/deals.go

@@ -402,9 +402,12 @@ func testRetrieval(t *testing.T, ctx context.Context, client *impl.FullNodeAPI,
 		IsCAR: carExport,
 	}
 	updates, err := client.ClientRetrieveWithEvents(ctx, offers[0].Order(caddr), ref)
+	if err != nil {
+		t.Fatal(err)
+	}
 	for update := range updates {
 		if update.Err != "" {
-			t.Fatalf("%v", err)
+			t.Fatalf("retrieval failed: %s", update.Err)
 		}
 	}
 

api/test/paych.go

@@ -8,17 +8,21 @@ import (
 	"testing"
 	"time"
 
-	"github.com/filecoin-project/specs-actors/actors/builtin"
+	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
+	paych0 "github.com/filecoin-project/specs-actors/actors/builtin/paych"
 
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/big"
-	"github.com/filecoin-project/specs-actors/actors/builtin/paych"
 	"github.com/ipfs/go-cid"
 
 	"github.com/filecoin-project/go-address"
+	cbor "github.com/ipfs/go-ipld-cbor"
 
 	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/api/apibstore"
 	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/actors/adt"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/paych"
 	"github.com/filecoin-project/lotus/chain/events"
 	"github.com/filecoin-project/lotus/chain/events/state"
 	"github.com/filecoin-project/lotus/chain/types"
@@ -67,7 +71,7 @@ func TestPaymentChannels(t *testing.T, b APIBuilder, blocktime time.Duration) {
 		t.Fatal(err)
 	}
 
-	channelAmt := int64(100000)
+	channelAmt := int64(7000)
 	channelInfo, err := paymentCreator.PaychGet(ctx, createrAddr, receiverAddr, abi.NewTokenAmount(channelAmt))
 	if err != nil {
 		t.Fatal(err)
@@ -133,17 +137,26 @@ func TestPaymentChannels(t *testing.T, b APIBuilder, blocktime time.Duration) {
 		t.Fatal("Unable to settle payment channel")
 	}
 
+	creatorStore := adt.WrapStore(ctx, cbor.NewCborStore(apibstore.NewAPIBlockstore(paymentCreator)))
+
 	// wait for the receiver to submit their vouchers
 	ev := events.NewEvents(ctx, paymentCreator)
 	preds := state.NewStatePredicates(paymentCreator)
 	finished := make(chan struct{})
 	err = ev.StateChanged(func(ts *types.TipSet) (done bool, more bool, err error) {
-		act, err := paymentCreator.StateReadState(ctx, channel, ts.Key())
+		act, err := paymentCreator.StateGetActor(ctx, channel, ts.Key())
 		if err != nil {
 			return false, false, err
 		}
-		state := act.State.(paych.State)
-		if state.ToSend.GreaterThanEqual(abi.NewTokenAmount(6000)) {
+		state, err := paych.Load(creatorStore, act)
+		if err != nil {
+			return false, false, err
+		}
+		toSend, err := state.ToSend()
+		if err != nil {
+			return false, false, err
+		}
+		if toSend.GreaterThanEqual(abi.NewTokenAmount(6000)) {
 			return true, false, nil
 		}
 		return false, true, nil
@@ -156,7 +169,7 @@ func TestPaymentChannels(t *testing.T, b APIBuilder, blocktime time.Duration) {
 		return true, nil
 	}, func(ctx context.Context, ts *types.TipSet) error {
 		return nil
-	}, int(build.MessageConfidence)+1, build.SealRandomnessLookbackLimit, func(oldTs, newTs *types.TipSet) (bool, events.StateChange, error) {
+	}, int(build.MessageConfidence)+1, build.Finality, func(oldTs, newTs *types.TipSet) (bool, events.StateChange, error) {
 		return preds.OnPaymentChannelActorChanged(channel, preds.OnToSendAmountChanges())(ctx, oldTs.Key(), newTs.Key())
 	})
 	if err != nil {
@@ -169,8 +182,53 @@ func TestPaymentChannels(t *testing.T, b APIBuilder, blocktime time.Duration) {
 		t.Fatal("Timed out waiting for receiver to submit vouchers")
 	}
 
+	// Create a new voucher now that some vouchers have already been submitted
+	vouchRes, err := paymentCreator.PaychVoucherCreate(ctx, channel, abi.NewTokenAmount(1000), 3)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if vouchRes.Voucher == nil {
+		t.Fatal(fmt.Errorf("Not enough funds to create voucher: missing %d", vouchRes.Shortfall))
+	}
+	vdelta, err := paymentReceiver.PaychVoucherAdd(ctx, channel, vouchRes.Voucher, nil, abi.NewTokenAmount(1000))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !vdelta.Equals(abi.NewTokenAmount(1000)) {
+		t.Fatal("voucher didn't have the right amount")
+	}
+
+	// Create a new voucher whose value would exceed the channel balance
+	excessAmt := abi.NewTokenAmount(1000)
+	vouchRes, err = paymentCreator.PaychVoucherCreate(ctx, channel, excessAmt, 4)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if vouchRes.Voucher != nil {
+		t.Fatal("Expected not to be able to create voucher whose value would exceed channel balance")
+	}
+	if !vouchRes.Shortfall.Equals(excessAmt) {
+		t.Fatal(fmt.Errorf("Expected voucher shortfall of %d, got %d", excessAmt, vouchRes.Shortfall))
+	}
+
+	// Add a voucher whose value would exceed the channel balance
+	vouch := &paych.SignedVoucher{ChannelAddr: channel, Amount: excessAmt, Lane: 4, Nonce: 1}
+	vb, err := vouch.SigningBytes()
+	if err != nil {
+		t.Fatal(err)
+	}
+	sig, err := paymentCreator.WalletSign(ctx, createrAddr, vb)
+	if err != nil {
+		t.Fatal(err)
+	}
+	vouch.Signature = sig
+	_, err = paymentReceiver.PaychVoucherAdd(ctx, channel, vouch, nil, abi.NewTokenAmount(1000))
+	if err == nil {
+		t.Fatal(fmt.Errorf("Expected shortfall error of %d", excessAmt))
+	}
+
 	// wait for the settlement period to pass before collecting
-	waitForBlocks(ctx, t, bm, paymentReceiver, receiverAddr, paych.SettleDelay)
+	waitForBlocks(ctx, t, bm, paymentReceiver, receiverAddr, paych0.SettleDelay)
 
 	creatorPreCollectBalance, err := paymentCreator.WalletBalance(ctx, createrAddr)
 	if err != nil {
@@ -226,7 +284,7 @@ func waitForBlocks(ctx context.Context, t *testing.T, bm *BlockMiner, paymentRec
 
 		// Add a real block
 		m, err := paymentReceiver.MpoolPushMessage(ctx, &types.Message{
-			To:    builtin.BurntFundsActorAddr,
+			To:    builtin0.BurntFundsActorAddr,
 			From:  receiverAddr,
 			Value: types.NewInt(0),
 		}, nil)

api/test/test.go

@@ -12,6 +12,7 @@ import (
 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/miner"
+	"github.com/filecoin-project/lotus/node"
 )
 
 type TestNode struct {
@@ -44,7 +45,7 @@ type StorageMiner struct {
 //
 // storage array defines storage nodes, numbers in the array specify full node
 // index the storage node 'belongs' to
-type APIBuilder func(t *testing.T, nFull int, storage []StorageMiner) ([]TestNode, []TestStorageNode)
+type APIBuilder func(t *testing.T, nFull int, storage []StorageMiner, opts ...node.Option) ([]TestNode, []TestStorageNode)
 type testSuite struct {
 	makeNodes APIBuilder
 }

api/test/window_post.go

@@ -15,9 +15,11 @@ import (
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/lotus/extern/sector-storage/mock"
 	sealing "github.com/filecoin-project/lotus/extern/storage-sealing"
+	"github.com/filecoin-project/lotus/node"
 
 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/stmgr"
 	"github.com/filecoin-project/lotus/chain/types"
 	bminer "github.com/filecoin-project/lotus/miner"
 	"github.com/filecoin-project/lotus/node/impl"
@@ -114,8 +116,29 @@ func pledgeSectors(t *testing.T, ctx context.Context, miner TestStorageNode, n,
 }
 
 func TestWindowPost(t *testing.T, b APIBuilder, blocktime time.Duration, nSectors int) {
-	ctx := context.Background()
-	n, sn := b(t, 1, OneMiner)
+	for _, height := range []abi.ChainEpoch{
+		1,    // before
+		162,  // while sealing
+		5000, // while proving
+	} {
+		height := height // copy to satisfy lints
+		t.Run(fmt.Sprintf("upgrade-%d", height), func(t *testing.T) {
+			testWindowPostUpgrade(t, b, blocktime, nSectors, height)
+		})
+	}
+
+}
+func testWindowPostUpgrade(t *testing.T, b APIBuilder, blocktime time.Duration, nSectors int,
+	upgradeHeight abi.ChainEpoch) {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	n, sn := b(t, 1, OneMiner, node.Override(new(stmgr.UpgradeSchedule), stmgr.UpgradeSchedule{{
+		Network:   build.ActorUpgradeNetworkVersion,
+		Height:    upgradeHeight,
+		Migration: stmgr.UpgradeActorsV2,
+	}}))
+
 	client := n[0].FullNode.(*impl.FullNodeAPI)
 	miner := sn[0]
 
@@ -129,17 +152,24 @@ func TestWindowPost(t *testing.T, b APIBuilder, blocktime time.Duration, nSector
 	}
 	build.Clock.Sleep(time.Second)
 
-	mine := true
 	done := make(chan struct{})
 	go func() {
 		defer close(done)
-		for mine {
+		for ctx.Err() == nil {
 			build.Clock.Sleep(blocktime)
 			if err := sn[0].MineOne(ctx, MineNext); err != nil {
+				if ctx.Err() != nil {
+					// context was canceled, ignore the error.
+					return
+				}
 				t.Error(err)
 			}
 		}
 	}()
+	defer func() {
+		cancel()
+		<-done
+	}()
 
 	pledgeSectors(t, ctx, miner, nSectors, 0, nil)
 
@@ -159,7 +189,7 @@ func TestWindowPost(t *testing.T, b APIBuilder, blocktime time.Duration, nSector
 		head, err := client.ChainHead(ctx)
 		require.NoError(t, err)
 
-		if head.Height() > di.PeriodStart+(di.WPoStProvingPeriod)+2 {
+		if head.Height() > di.PeriodStart+di.WPoStProvingPeriod+2 {
 			fmt.Printf("Now head.Height = %d\n", head.Height())
 			break
 		}
@@ -289,12 +319,11 @@ func TestWindowPost(t *testing.T, b APIBuilder, blocktime time.Duration, nSector
 	pledgeSectors(t, ctx, miner, 1, nSectors, nil)
 
 	{
-		// wait a bit more
-
-		head, err := client.ChainHead(ctx)
+		// Wait until proven.
+		di, err = client.StateMinerProvingDeadline(ctx, maddr, types.EmptyTSK)
 		require.NoError(t, err)
 
-		waitUntil := head.Height() + 10
+		waitUntil := di.PeriodStart + di.WPoStProvingPeriod + 2
 		fmt.Printf("End for head.Height > %d\n", waitUntil)
 
 		for {
@@ -315,7 +344,4 @@ func TestWindowPost(t *testing.T, b APIBuilder, blocktime time.Duration, nSector
 
 	sectors = p.MinerPower.RawBytePower.Uint64() / uint64(ssz)
 	require.Equal(t, nSectors+GenesisPreseals-2+1, int(sectors)) // -2 not recovered sectors + 1 just pledged
-
-	mine = false
-	<-done
 }

build/bootstrap/bootstrappers.pi

@@ -1,12 +1,2 @@
-/dns4/bootstrap-0.testnet.fildev.network/tcp/1347/p2p/12D3KooWJTUBUjtzWJGWU1XSiY21CwmHaCNLNYn2E7jqHEHyZaP7
-/dns4/bootstrap-1.testnet.fildev.network/tcp/1347/p2p/12D3KooW9yeKXha4hdrJKq74zEo99T8DhriQdWNoojWnnQbsgB3v
-/dns4/bootstrap-2.testnet.fildev.network/tcp/1347/p2p/12D3KooWCrx8yVG9U9Kf7w8KLN3Edkj5ZKDhgCaeMqQbcQUoB6CT
-/dns4/bootstrap-4.testnet.fildev.network/tcp/1347/p2p/12D3KooWPkL9LrKRQgHtq7kn9ecNhGU9QaziG8R5tX8v9v7t3h34
-/dns4/bootstrap-3.testnet.fildev.network/tcp/1347/p2p/12D3KooWKYSsbpgZ3HAjax5M1BXCwXLa6gVkUARciz7uN3FNtr7T
-/dns4/bootstrap-5.testnet.fildev.network/tcp/1347/p2p/12D3KooWQYzqnLASJAabyMpPb1GcWZvNSe7JDcRuhdRqonFoiK9W
-/dns4/lotus-bootstrap.forceup.cn/tcp/41778/p2p/12D3KooWFQsv3nRMUevZNWWsY1Wu6NUzUbawnWU5NcRhgKuJA37C
-/dns4/bootstrap-0.starpool.in/tcp/12757/p2p/12D3KooWGHpBMeZbestVEWkfdnC9u7p6uFHXL1n7m1ZBqsEmiUzz
-/dns4/bootstrap-1.starpool.in/tcp/12757/p2p/12D3KooWQZrGH1PxSNZPum99M1zNvjNFM33d1AAu5DcvdHptuU7u
-/dns4/node.glif.io/tcp/1235/p2p/12D3KooWBF8cpp65hp2u9LK5mh19x67ftAam84z9LsfaquTDSBpt
-/dns4/bootstrap-0.ipfsmain.cn/tcp/34721/p2p/12D3KooWQnwEGNqcM2nAcPtRR9rAX8Hrg4k9kJLCHoTR5chJfz6d
-/dns4/bootstrap-1.ipfsmain.cn/tcp/34723/p2p/12D3KooWMKxMkD5DMpSWsW7dBddKxKT7L2GgbNuckz9otxvkvByP
+/dns4/bootstrap-0.butterfly.fildev.network/tcp/1347/p2p/12D3KooWCYDmiVU7yXfg8MsuCAwuMmueCrjeaqduFA8gMFTWCUJk
+/dns4/bootstrap-1.butterfly.fildev.network/tcp/1347/p2p/12D3KooWKap2ouokyEu2kF56CCBsgxx3e54TGzdzcbYhxk4DtSRr

build/params_2k.go

@@ -14,6 +14,7 @@ const BreezeGasTampingDuration = 0
 const UpgradeSmokeHeight = -1
 const UpgradeIgnitionHeight = -2
 const UpgradeLiftoffHeight = -3
+const UpgradeActorsV2Height = 10
 
 var DrandSchedule = map[abi.ChainEpoch]DrandEnum{
 	0: DrandMainnet,

build/params_shared_funcs.go

@@ -41,7 +41,7 @@ func DhtProtocolName(netName dtypes.NetworkName) protocol.ID {
 
 func UseNewestNetwork() bool {
 	// TODO: Put these in a container we can iterate over
-	if UpgradeBreezeHeight <= 0 && UpgradeSmokeHeight <= 0 {
+	if UpgradeBreezeHeight <= 0 && UpgradeSmokeHeight <= 0 && UpgradeActorsV2Height <= 0 {
 		return true
 	}
 	return false

build/params_shared_vals.go

@@ -7,12 +7,12 @@ import (
 	"os"
 
 	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/lotus/chain/actors/policy"
 
 	"github.com/filecoin-project/go-state-types/network"
 
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/specs-actors/actors/builtin"
-	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
 )
 
 // /////
@@ -25,7 +25,7 @@ const UnixfsLinksPerLevel = 1024
 // Consensus / Network
 
 const AllowableClockDriftSecs = uint64(1)
-const NewestNetworkVersion = network.Version3
+const NewestNetworkVersion = network.Version4
 const ActorUpgradeNetworkVersion = network.Version4
 
 // Epochs
@@ -35,7 +35,7 @@ const ForkLengthThreshold = Finality
 var BlocksPerEpoch = uint64(builtin.ExpectedLeadersPerEpoch)
 
 // Epochs
-const Finality = miner0.ChainFinality
+const Finality = policy.ChainFinality
 const MessageConfidence = uint64(5)
 
 // constants for Weight calculation
@@ -47,13 +47,8 @@ const WRatioDen = uint64(2)
 // Proofs
 
 // Epochs
-const SealRandomnessLookback = Finality
-
-// Epochs
-const SealRandomnessLookbackLimit = SealRandomnessLookback + 2000 // TODO: Get from spec specs-actors
-
-// Maximum lookback that randomness can be sourced from for a seal proof submission
-const MaxSealLookback = SealRandomnessLookbackLimit + 2000 // TODO: Get from specs-actors
+// TODO: unused
+const SealRandomnessLookback = policy.SealRandomnessLookback
 
 // /////
 // Mining
@@ -61,8 +56,6 @@ const MaxSealLookback = SealRandomnessLookbackLimit + 2000 // TODO: Get from spe
 // Epochs
 const TicketRandomnessLookback = abi.ChainEpoch(1)
 
-const WinningPoStSectorSetLookback = abi.ChainEpoch(10)
-
 // /////
 // Address
 
@@ -77,8 +70,10 @@ const FilBase = uint64(2_000_000_000)
 const FilAllocStorageMining = uint64(1_100_000_000)
 
 const FilecoinPrecision = uint64(1_000_000_000_000_000_000)
+const FilReserved = uint64(300_000_000)
 
 var InitialRewardBalance *big.Int
+var InitialFilReserved *big.Int
 
 // TODO: Move other important consts here
 
@@ -86,6 +81,9 @@ func init() {
 	InitialRewardBalance = big.NewInt(int64(FilAllocStorageMining))
 	InitialRewardBalance = InitialRewardBalance.Mul(InitialRewardBalance, big.NewInt(int64(FilecoinPrecision)))
 
+	InitialFilReserved = big.NewInt(int64(FilReserved))
+	InitialFilReserved = InitialFilReserved.Mul(InitialFilReserved, big.NewInt(int64(FilecoinPrecision)))
+
 	if os.Getenv("LOTUS_ADDRESS_TYPE") == AddressMainnetEnvVar {
 		SetAddressNetwork(address.Mainnet)
 	}

build/params_testground.go

@@ -13,7 +13,8 @@ import (
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/network"
 	"github.com/filecoin-project/specs-actors/actors/builtin"
-	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
+
+	"github.com/filecoin-project/lotus/chain/actors/policy"
 )
 
 var (
@@ -32,7 +33,7 @@ var (
 
 	AllowableClockDriftSecs = uint64(1)
 
-	Finality            = miner0.ChainFinality
+	Finality            = policy.ChainFinality
 	ForkLengthThreshold = Finality
 
 	SlashablePowerDelay        = 20
@@ -47,15 +48,13 @@ var (
 	BlsSignatureCacheSize = 40000
 	VerifSigCacheSize     = 32000
 
-	SealRandomnessLookback      = Finality
-	SealRandomnessLookbackLimit = SealRandomnessLookback + 2000
-	MaxSealLookback             = SealRandomnessLookbackLimit + 2000
+	SealRandomnessLookback = policy.SealRandomnessLookback
 
-	TicketRandomnessLookback     = abi.ChainEpoch(1)
-	WinningPoStSectorSetLookback = abi.ChainEpoch(10)
+	TicketRandomnessLookback = abi.ChainEpoch(1)
 
 	FilBase               uint64 = 2_000_000_000
 	FilAllocStorageMining uint64 = 1_400_000_000
+	FilReserved           uint64 = 300_000_000
 
 	FilecoinPrecision uint64 = 1_000_000_000_000_000_000
 
@@ -64,6 +63,13 @@ var (
 		v = v.Mul(v, big.NewInt(int64(FilecoinPrecision)))
 		return v
 	}()
+
+	InitialFilReserved = func() *big.Int {
+		v := big.NewInt(int64(FilReserved))
+		v = v.Mul(v, big.NewInt(int64(FilecoinPrecision)))
+		return v
+	}()
+
 	// Actor consts
 	// TODO: Pull from actors when its made not private
 	MinDealDuration = abi.ChainEpoch(180 * builtin.EpochsInDay)
@@ -77,13 +83,14 @@ var (
 	UpgradeSmokeHeight    abi.ChainEpoch = -1
 	UpgradeIgnitionHeight abi.ChainEpoch = -2
 	UpgradeLiftoffHeight  abi.ChainEpoch = -3
+	UpgradeActorsV2Height abi.ChainEpoch = 10
 
 	DrandSchedule = map[abi.ChainEpoch]DrandEnum{
 		0: DrandMainnet,
 	}
 
-	NewestNetworkVersion       = network.Version2
-	ActorUpgradeNetworkVersion = network.Version3
+	NewestNetworkVersion       = network.Version4
+	ActorUpgradeNetworkVersion = network.Version4
 
 	Devnet = true
 )

build/params_testnet.go

@@ -5,6 +5,7 @@
 package build
 
 import (
+	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/lotus/chain/actors/policy"
 
@@ -12,16 +13,17 @@ import (
 )
 
 var DrandSchedule = map[abi.ChainEpoch]DrandEnum{
-	0:                  DrandIncentinet,
-	UpgradeSmokeHeight: DrandMainnet,
+	0: DrandMainnet,
 }
 
-const UpgradeBreezeHeight = 41280
+const UpgradeBreezeHeight = -1
 const BreezeGasTampingDuration = 120
 
-const UpgradeSmokeHeight = 51000
+const UpgradeSmokeHeight = -2
 
-const UpgradeIgnitionHeight = 94000
+const UpgradeIgnitionHeight = -3
+
+const UpgradeActorsV2Height = 500
 
 // This signals our tentative epoch for mainnet launch. Can make it later, but not earlier.
 // Miners, clients, developers, custodians all need time to prepare.
@@ -29,11 +31,15 @@ const UpgradeIgnitionHeight = 94000
 const UpgradeLiftoffHeight = 148888
 
 func init() {
-	policy.SetConsensusMinerMinPower(abi.NewStoragePower(10 << 40))
+	policy.SetConsensusMinerMinPower(abi.NewStoragePower(1 << 30))
 	policy.SetSupportedProofTypes(
+		abi.RegisteredSealProof_StackedDrg512MiBV1,
 		abi.RegisteredSealProof_StackedDrg32GiBV1,
 		abi.RegisteredSealProof_StackedDrg64GiBV1,
 	)
+
+	SetAddressNetwork(address.Testnet)
+
 	Devnet = false
 }
 

chain/actors/adt/adt.go

@@ -7,8 +7,11 @@ import (
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/cbor"
 	"github.com/filecoin-project/go-state-types/network"
-	"github.com/filecoin-project/lotus/chain/actors/builtin"
+
+	"github.com/filecoin-project/lotus/chain/actors"
+
 	adt0 "github.com/filecoin-project/specs-actors/actors/util/adt"
+	adt2 "github.com/filecoin-project/specs-actors/v2/actors/util/adt"
 )
 
 type Map interface {
@@ -21,18 +24,22 @@ type Map interface {
 	ForEach(v cbor.Unmarshaler, fn func(key string) error) error
 }
 
-func AsMap(store Store, root cid.Cid, version builtin.Version) (Map, error) {
+func AsMap(store Store, root cid.Cid, version actors.Version) (Map, error) {
 	switch version {
-	case builtin.Version0:
+	case actors.Version0:
 		return adt0.AsMap(store, root)
+	case actors.Version2:
+		return adt2.AsMap(store, root)
 	}
 	return nil, xerrors.Errorf("unknown network version: %d", version)
 }
 
-func NewMap(store Store, version builtin.Version) (Map, error) {
+func NewMap(store Store, version actors.Version) (Map, error) {
 	switch version {
-	case builtin.Version0:
+	case actors.Version0:
 		return adt0.MakeEmptyMap(store), nil
+	case actors.Version2:
+		return adt2.MakeEmptyMap(store), nil
 	}
 	return nil, xerrors.Errorf("unknown network version: %d", version)
 }
@@ -49,17 +56,21 @@ type Array interface {
 }
 
 func AsArray(store Store, root cid.Cid, version network.Version) (Array, error) {
-	switch builtin.VersionForNetwork(version) {
-	case builtin.Version0:
+	switch actors.VersionForNetwork(version) {
+	case actors.Version0:
 		return adt0.AsArray(store, root)
+	case actors.Version2:
+		return adt2.AsArray(store, root)
 	}
 	return nil, xerrors.Errorf("unknown network version: %d", version)
 }
 
-func NewArray(store Store, version builtin.Version) (Array, error) {
+func NewArray(store Store, version actors.Version) (Array, error) {
 	switch version {
-	case builtin.Version0:
+	case actors.Version0:
 		return adt0.MakeEmptyArray(store), nil
+	case actors.Version2:
+		return adt2.MakeEmptyArray(store), nil
 	}
 	return nil, xerrors.Errorf("unknown network version: %d", version)
 }

chain/actors/builtin/account/account.go

@@ -5,21 +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"
+	"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"
+	builtin2 "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(builtin2.AccountActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
+		return load2(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 builtin2.AccountActorCodeID:
+		return load2(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/v2.go

@@ -0,0 +1,30 @@
+package account
+
+import (
+	"github.com/filecoin-project/go-address"
+	"github.com/ipfs/go-cid"
+
+	"github.com/filecoin-project/lotus/chain/actors/adt"
+
+	account2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/account"
+)
+
+var _ State = (*state2)(nil)
+
+func load2(store adt.Store, root cid.Cid) (State, error) {
+	out := state2{store: store}
+	err := store.Get(store.Context(), root, &out)
+	if err != nil {
+		return nil, err
+	}
+	return &out, nil
+}
+
+type state2 struct {
+	account2.State
+	store adt.Store
+}
+
+func (s *state2) PubkeyAddress() (address.Address, error) {
+	return s.Address, nil
+}

chain/actors/builtin/builtin.go

@@ -1,32 +1,27 @@
 package builtin
 
 import (
-	"fmt"
+	"github.com/filecoin-project/go-address"
+	"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"
+
+	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
 	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"
-
-	"github.com/filecoin-project/go-state-types/network"
+	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
+	smoothing2 "github.com/filecoin-project/specs-actors/v2/actors/util/smoothing"
 )
 
-type Version int
-
-const (
-	Version0 = iota
-)
-
-// Converts a network version into a specs-actors version.
-func VersionForNetwork(version network.Version) Version {
-	switch version {
-	case network.Version0, network.Version1, network.Version2, network.Version3:
-		return Version0
-	default:
-		panic(fmt.Sprintf("unsupported network version %d", version))
-	}
-}
+var SystemActorAddr = builtin0.SystemActorAddr
+var BurntFundsActorAddr = builtin0.BurntFundsActorAddr
+var ReserveAddress = makeAddress("t090")
 
 // TODO: Why does actors have 2 different versions of this?
 type SectorInfo = proof0.SectorInfo
@@ -41,3 +36,64 @@ func FromV0FilterEstimate(v0 smoothing0.FilterEstimate) FilterEstimate {
 func QAPowerForWeight(size abi.SectorSize, duration abi.ChainEpoch, dealWeight, verifiedWeight abi.DealWeight) abi.StoragePower {
 	return miner0.QAPowerForWeight(size, duration, dealWeight, verifiedWeight)
 }
+
+func FromV2FilterEstimate(v1 smoothing2.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)
+}
+
+func ActorNameByCode(c cid.Cid) string {
+	switch {
+	case builtin0.IsBuiltinActor(c):
+		return builtin0.ActorNameByCode(c)
+	case builtin2.IsBuiltinActor(c):
+		return builtin2.ActorNameByCode(c)
+	default:
+		return "<unknown>"
+	}
+}
+
+func IsBuiltinActor(c cid.Cid) bool {
+	return builtin0.IsBuiltinActor(c) || builtin2.IsBuiltinActor(c)
+}
+
+func IsAccountActor(c cid.Cid) bool {
+	return c == builtin0.AccountActorCodeID || c == builtin2.AccountActorCodeID
+}
+
+func IsStorageMinerActor(c cid.Cid) bool {
+	return c == builtin0.StorageMinerActorCodeID || c == builtin2.StorageMinerActorCodeID
+}
+
+func IsMultisigActor(c cid.Cid) bool {
+	return c == builtin0.MultisigActorCodeID || c == builtin2.MultisigActorCodeID
+
+}
+
+func IsPaymentChannelActor(c cid.Cid) bool {
+	return c == builtin0.PaymentChannelActorCodeID || c == builtin2.PaymentChannelActorCodeID
+}
+
+func makeAddress(addr string) address.Address {
+	ret, err := address.NewFromString(addr)
+	if err != nil {
+		panic(err)
+	}
+
+	return ret
+}

chain/actors/builtin/init/init.go

@@ -6,24 +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"
+	"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"
+	builtin2 "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(builtin2.InitActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
+		return load2(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 builtin2.InitActorCodeID:
+		return load2(store, act.Head)
 	}
 	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
 }
@@ -41,4 +51,7 @@ type State interface {
 	// It should not be used in production code, as init actor entries are
 	// immutable.
 	Remove(addrs ...address.Address) error
+
+	// Sets the network's name. This should only be used on upgrade/fork.
+	SetNetworkName(name string) error
 }

chain/actors/builtin/init/v0.go

@@ -3,21 +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"
 
-	init_ "github.com/filecoin-project/specs-actors/actors/builtin/init"
-
 	"github.com/filecoin-project/lotus/chain/actors/adt"
 	"github.com/filecoin-project/lotus/node/modules/dtypes"
 
+	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
 }
 
@@ -48,6 +57,11 @@ func (s *state0) NetworkName() (dtypes.NetworkName, error) {
 	return dtypes.NetworkName(s.State.NetworkName), nil
 }
 
+func (s *state0) SetNetworkName(name string) error {
+	s.State.NetworkName = name
+	return nil
+}
+
 func (s *state0) Remove(addrs ...address.Address) (err error) {
 	m, err := adt0.AsMap(s.store, s.State.AddressMap)
 	if err != nil {

chain/actors/builtin/init/v2.go

@@ -0,0 +1,81 @@
+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"
+
+	init2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/init"
+	adt2 "github.com/filecoin-project/specs-actors/v2/actors/util/adt"
+)
+
+var _ State = (*state2)(nil)
+
+func load2(store adt.Store, root cid.Cid) (State, error) {
+	out := state2{store: store}
+	err := store.Get(store.Context(), root, &out)
+	if err != nil {
+		return nil, err
+	}
+	return &out, nil
+}
+
+type state2 struct {
+	init2.State
+	store adt.Store
+}
+
+func (s *state2) ResolveAddress(address address.Address) (address.Address, bool, error) {
+	return s.State.ResolveAddress(s.store, address)
+}
+
+func (s *state2) MapAddressToNewID(address address.Address) (address.Address, error) {
+	return s.State.MapAddressToNewID(s.store, address)
+}
+
+func (s *state2) ForEachActor(cb func(id abi.ActorID, address address.Address) error) error {
+	addrs, err := adt2.AsMap(s.store, s.State.AddressMap)
+	if err != nil {
+		return err
+	}
+	var actorID cbg.CborInt
+	return addrs.ForEach(&actorID, func(key string) error {
+		addr, err := address.NewFromBytes([]byte(key))
+		if err != nil {
+			return err
+		}
+		return cb(abi.ActorID(actorID), addr)
+	})
+}
+
+func (s *state2) NetworkName() (dtypes.NetworkName, error) {
+	return dtypes.NetworkName(s.State.NetworkName), nil
+}
+
+func (s *state2) SetNetworkName(name string) error {
+	s.State.NetworkName = name
+	return nil
+}
+
+func (s *state2) Remove(addrs ...address.Address) (err error) {
+	m, err := adt2.AsMap(s.store, s.State.AddressMap)
+	if err != nil {
+		return err
+	}
+	for _, addr := range addrs {
+		if err = m.Delete(abi.AddrKey(addr)); err != nil {
+			return xerrors.Errorf("failed to delete entry for address: %s; err: %w", addr, err)
+		}
+	}
+	amr, err := m.Root()
+	if err != nil {
+		return xerrors.Errorf("failed to get address map root: %w", err)
+	}
+	s.State.AddressMap = amr
+	return nil
+}

chain/actors/builtin/market/market.go

@@ -6,26 +6,35 @@ 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"
-	market0 "github.com/filecoin-project/specs-actors/actors/builtin/market"
 	"github.com/ipfs/go-cid"
 	cbg "github.com/whyrusleeping/cbor-gen"
 
+	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
+	market0 "github.com/filecoin-project/specs-actors/actors/builtin/market"
+	builtin2 "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(builtin2.StorageMarketActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
+		return load2(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 builtin2.StorageMarketActorCodeID:
+		return load2(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/v2.go

@@ -0,0 +1,205 @@
+package market
+
+import (
+	"bytes"
+
+	"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"
+
+	market2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/market"
+	adt2 "github.com/filecoin-project/specs-actors/v2/actors/util/adt"
+)
+
+var _ State = (*state2)(nil)
+
+func load2(store adt.Store, root cid.Cid) (State, error) {
+	out := state2{store: store}
+	err := store.Get(store.Context(), root, &out)
+	if err != nil {
+		return nil, err
+	}
+	return &out, nil
+}
+
+type state2 struct {
+	market2.State
+	store adt.Store
+}
+
+func (s *state2) TotalLocked() (abi.TokenAmount, error) {
+	fml := types.BigAdd(s.TotalClientLockedCollateral, s.TotalProviderLockedCollateral)
+	fml = types.BigAdd(fml, s.TotalClientStorageFee)
+	return fml, nil
+}
+
+func (s *state2) BalancesChanged(otherState State) (bool, error) {
+	otherState2, ok := otherState.(*state2)
+	if !ok {
+		// there's no way to compare different versions of the state, so let's
+		// just say that means the state of balances has changed
+		return true, nil
+	}
+	return !s.State.EscrowTable.Equals(otherState2.State.EscrowTable) || !s.State.LockedTable.Equals(otherState2.State.LockedTable), nil
+}
+
+func (s *state2) StatesChanged(otherState State) (bool, error) {
+	otherState2, ok := otherState.(*state2)
+	if !ok {
+		// there's no way to compare different versions of the state, so let's
+		// just say that means the state of balances has changed
+		return true, nil
+	}
+	return !s.State.States.Equals(otherState2.State.States), nil
+}
+
+func (s *state2) States() (DealStates, error) {
+	stateArray, err := adt2.AsArray(s.store, s.State.States)
+	if err != nil {
+		return nil, err
+	}
+	return &dealStates2{stateArray}, nil
+}
+
+func (s *state2) ProposalsChanged(otherState State) (bool, error) {
+	otherState2, ok := otherState.(*state2)
+	if !ok {
+		// there's no way to compare different versions of the state, so let's
+		// just say that means the state of balances has changed
+		return true, nil
+	}
+	return !s.State.Proposals.Equals(otherState2.State.Proposals), nil
+}
+
+func (s *state2) Proposals() (DealProposals, error) {
+	proposalArray, err := adt2.AsArray(s.store, s.State.Proposals)
+	if err != nil {
+		return nil, err
+	}
+	return &dealProposals2{proposalArray}, nil
+}
+
+func (s *state2) EscrowTable() (BalanceTable, error) {
+	bt, err := adt2.AsBalanceTable(s.store, s.State.EscrowTable)
+	if err != nil {
+		return nil, err
+	}
+	return &balanceTable2{bt}, nil
+}
+
+func (s *state2) LockedTable() (BalanceTable, error) {
+	bt, err := adt2.AsBalanceTable(s.store, s.State.LockedTable)
+	if err != nil {
+		return nil, err
+	}
+	return &balanceTable2{bt}, nil
+}
+
+func (s *state2) VerifyDealsForActivation(
+	minerAddr address.Address, deals []abi.DealID, currEpoch, sectorExpiry abi.ChainEpoch,
+) (weight, verifiedWeight abi.DealWeight, err error) {
+	w, vw, _, err := market2.ValidateDealsForActivation(&s.State, s.store, deals, minerAddr, sectorExpiry, currEpoch)
+	return w, vw, err
+}
+
+type balanceTable2 struct {
+	*adt2.BalanceTable
+}
+
+func (bt *balanceTable2) ForEach(cb func(address.Address, abi.TokenAmount) error) error {
+	asMap := (*adt2.Map)(bt.BalanceTable)
+	var ta abi.TokenAmount
+	return asMap.ForEach(&ta, func(key string) error {
+		a, err := address.NewFromBytes([]byte(key))
+		if err != nil {
+			return err
+		}
+		return cb(a, ta)
+	})
+}
+
+type dealStates2 struct {
+	adt.Array
+}
+
+func (s *dealStates2) Get(dealID abi.DealID) (*DealState, bool, error) {
+	var deal2 market2.DealState
+	found, err := s.Array.Get(uint64(dealID), &deal2)
+	if err != nil {
+		return nil, false, err
+	}
+	if !found {
+		return nil, false, nil
+	}
+	deal := fromV2DealState(deal2)
+	return &deal, true, nil
+}
+
+func (s *dealStates2) ForEach(cb func(dealID abi.DealID, ds DealState) error) error {
+	var ds1 market2.DealState
+	return s.Array.ForEach(&ds1, func(idx int64) error {
+		return cb(abi.DealID(idx), fromV2DealState(ds1))
+	})
+}
+
+func (s *dealStates2) decode(val *cbg.Deferred) (*DealState, error) {
+	var ds1 market2.DealState
+	if err := ds1.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil {
+		return nil, err
+	}
+	ds := fromV2DealState(ds1)
+	return &ds, nil
+}
+
+func (s *dealStates2) array() adt.Array {
+	return s.Array
+}
+
+func fromV2DealState(v1 market2.DealState) DealState {
+	return (DealState)(v1)
+}
+
+type dealProposals2 struct {
+	adt.Array
+}
+
+func (s *dealProposals2) Get(dealID abi.DealID) (*DealProposal, bool, error) {
+	var proposal2 market2.DealProposal
+	found, err := s.Array.Get(uint64(dealID), &proposal2)
+	if err != nil {
+		return nil, false, err
+	}
+	if !found {
+		return nil, false, nil
+	}
+	proposal := fromV2DealProposal(proposal2)
+	return &proposal, true, nil
+}
+
+func (s *dealProposals2) ForEach(cb func(dealID abi.DealID, dp DealProposal) error) error {
+	var dp1 market2.DealProposal
+	return s.Array.ForEach(&dp1, func(idx int64) error {
+		return cb(abi.DealID(idx), fromV2DealProposal(dp1))
+	})
+}
+
+func (s *dealProposals2) decode(val *cbg.Deferred) (*DealProposal, error) {
+	var dp1 market2.DealProposal
+	if err := dp1.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil {
+		return nil, err
+	}
+	dp := fromV2DealProposal(dp1)
+	return &dp, nil
+}
+
+func (s *dealProposals2) array() adt.Array {
+	return s.Array
+}
+
+func fromV2DealProposal(v1 market2.DealProposal) DealProposal {
+	return (DealProposal)(v1)
+}

chain/actors/builtin/miner/miner.go

@@ -11,14 +11,26 @@ import (
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/cbor"
 	"github.com/filecoin-project/go-state-types/dline"
-	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
-	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
 
 	"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"
+	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
+	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
 )
 
-// Unchanged between v0 and v1 actors
+func init() {
+	builtin.RegisterActorState(builtin0.StorageMinerActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
+		return load0(store, root)
+	})
+	builtin.RegisterActorState(builtin2.StorageMinerActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
+		return load2(store, root)
+	})
+}
+
+// Unchanged between v0 and v2 actors
 var WPoStProvingPeriod = miner0.WPoStProvingPeriod
 var WPoStPeriodDeadlines = miner0.WPoStPeriodDeadlines
 var WPoStChallengeWindow = miner0.WPoStChallengeWindow
@@ -30,12 +42,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 builtin2.StorageMinerActorCodeID:
+		return load2(store, act.Head)
 	}
 	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
 }
@@ -49,6 +58,7 @@ type State interface {
 	VestedFunds(abi.ChainEpoch) (abi.TokenAmount, error)
 	// Funds locked for various reasons.
 	LockedFunds() (LockedFunds, error)
+	FeeDebt() (abi.TokenAmount, error)
 
 	GetSector(abi.SectorNumber) (*SectorOnChainInfo, error)
 	FindSector(abi.SectorNumber) (*SectorLocation, error)
@@ -135,6 +145,7 @@ type MinerInfo struct {
 	SealProofType              abi.RegisteredSealProof
 	SectorSize                 abi.SectorSize
 	WindowPoStPartitionSectors uint64
+	ConsensusFaultElapsed      abi.ChainEpoch
 }
 
 type SectorExpiration struct {

chain/actors/builtin/miner/v0.go

@@ -4,22 +4,34 @@ import (
 	"bytes"
 	"errors"
 
-	"github.com/libp2p/go-libp2p-core/peer"
-	cbg "github.com/whyrusleeping/cbor-gen"
-	"golang.org/x/xerrors"
+	"github.com/filecoin-project/go-state-types/big"
 
 	"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"
+	"golang.org/x/xerrors"
 
 	"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
@@ -51,6 +63,10 @@ func (s *state0) LockedFunds() (LockedFunds, error) {
 	}, nil
 }
 
+func (s *state0) FeeDebt() (abi.TokenAmount, error) {
+	return big.Zero(), nil
+}
+
 func (s *state0) InitialPledge() (abi.TokenAmount, error) {
 	return s.State.InitialPledgeRequirement, nil
 }
@@ -277,6 +293,7 @@ func (s *state0) Info() (MinerInfo, error) {
 		SealProofType:              info.SealProofType,
 		SectorSize:                 info.SectorSize,
 		WindowPoStPartitionSectors: info.WindowPoStPartitionSectors,
+		ConsensusFaultElapsed:      -1,
 	}
 
 	if info.PendingWorkerKey != nil {

chain/actors/builtin/miner/v2.go

@@ -0,0 +1,407 @@
+package miner
+
+import (
+	"bytes"
+	"errors"
+
+	"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"
+	"github.com/ipfs/go-cid"
+	"github.com/libp2p/go-libp2p-core/peer"
+	cbg "github.com/whyrusleeping/cbor-gen"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/lotus/chain/actors/adt"
+
+	miner2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/miner"
+	adt2 "github.com/filecoin-project/specs-actors/v2/actors/util/adt"
+)
+
+var _ State = (*state2)(nil)
+
+func load2(store adt.Store, root cid.Cid) (State, error) {
+	out := state2{store: store}
+	err := store.Get(store.Context(), root, &out)
+	if err != nil {
+		return nil, err
+	}
+	return &out, nil
+}
+
+type state2 struct {
+	miner2.State
+	store adt.Store
+}
+
+type deadline2 struct {
+	miner2.Deadline
+	store adt.Store
+}
+
+type partition2 struct {
+	miner2.Partition
+	store adt.Store
+}
+
+func (s *state2) AvailableBalance(bal abi.TokenAmount) (abi.TokenAmount, error) {
+	return s.GetAvailableBalance(bal)
+}
+
+func (s *state2) VestedFunds(epoch abi.ChainEpoch) (abi.TokenAmount, error) {
+	return s.CheckVestedFunds(s.store, epoch)
+}
+
+func (s *state2) LockedFunds() (LockedFunds, error) {
+	return LockedFunds{
+		VestingFunds:             s.State.LockedFunds,
+		InitialPledgeRequirement: s.State.InitialPledge,
+		PreCommitDeposits:        s.State.PreCommitDeposits,
+	}, nil
+}
+
+func (s *state2) FeeDebt() (abi.TokenAmount, error) {
+	return s.State.FeeDebt, nil
+}
+
+func (s *state2) InitialPledge() (abi.TokenAmount, error) {
+	return s.State.InitialPledge, nil
+}
+
+func (s *state2) PreCommitDeposits() (abi.TokenAmount, error) {
+	return s.State.PreCommitDeposits, nil
+}
+
+func (s *state2) GetSector(num abi.SectorNumber) (*SectorOnChainInfo, error) {
+	info, ok, err := s.State.GetSector(s.store, num)
+	if !ok || err != nil {
+		return nil, err
+	}
+
+	ret := fromV2SectorOnChainInfo(*info)
+	return &ret, nil
+}
+
+func (s *state2) FindSector(num abi.SectorNumber) (*SectorLocation, error) {
+	dlIdx, partIdx, err := s.State.FindSector(s.store, num)
+	if err != nil {
+		return nil, err
+	}
+	return &SectorLocation{
+		Deadline:  dlIdx,
+		Partition: partIdx,
+	}, nil
+}
+
+func (s *state2) NumLiveSectors() (uint64, error) {
+	dls, err := s.State.LoadDeadlines(s.store)
+	if err != nil {
+		return 0, err
+	}
+	var total uint64
+	if err := dls.ForEach(s.store, func(dlIdx uint64, dl *miner2.Deadline) error {
+		total += dl.LiveSectors
+		return nil
+	}); err != nil {
+		return 0, err
+	}
+	return total, nil
+}
+
+// GetSectorExpiration returns the effective expiration of the given sector.
+//
+// If the sector does not expire early, the Early expiration field is 0.
+func (s *state2) GetSectorExpiration(num abi.SectorNumber) (*SectorExpiration, error) {
+	dls, err := s.State.LoadDeadlines(s.store)
+	if err != nil {
+		return nil, err
+	}
+	// NOTE: this can be optimized significantly.
+	// 1. If the sector is non-faulty, it will either expire on-time (can be
+	// learned from the sector info), or in the next quantized expiration
+	// epoch (i.e., the first element in the partition's expiration queue.
+	// 2. If it's faulty, it will expire early within the first 14 entries
+	// of the expiration queue.
+	stopErr := errors.New("stop")
+	out := SectorExpiration{}
+	err = dls.ForEach(s.store, func(dlIdx uint64, dl *miner2.Deadline) error {
+		partitions, err := dl.PartitionsArray(s.store)
+		if err != nil {
+			return err
+		}
+		quant := s.State.QuantSpecForDeadline(dlIdx)
+		var part miner2.Partition
+		return partitions.ForEach(&part, func(partIdx int64) error {
+			if found, err := part.Sectors.IsSet(uint64(num)); err != nil {
+				return err
+			} else if !found {
+				return nil
+			}
+			if found, err := part.Terminated.IsSet(uint64(num)); err != nil {
+				return err
+			} else if found {
+				// already terminated
+				return stopErr
+			}
+
+			q, err := miner2.LoadExpirationQueue(s.store, part.ExpirationsEpochs, quant)
+			if err != nil {
+				return err
+			}
+			var exp miner2.ExpirationSet
+			return q.ForEach(&exp, func(epoch int64) error {
+				if early, err := exp.EarlySectors.IsSet(uint64(num)); err != nil {
+					return err
+				} else if early {
+					out.Early = abi.ChainEpoch(epoch)
+					return nil
+				}
+				if onTime, err := exp.OnTimeSectors.IsSet(uint64(num)); err != nil {
+					return err
+				} else if onTime {
+					out.OnTime = abi.ChainEpoch(epoch)
+					return stopErr
+				}
+				return nil
+			})
+		})
+	})
+	if err == stopErr {
+		err = nil
+	}
+	if err != nil {
+		return nil, err
+	}
+	if out.Early == 0 && out.OnTime == 0 {
+		return nil, xerrors.Errorf("failed to find sector %d", num)
+	}
+	return &out, nil
+}
+
+func (s *state2) GetPrecommittedSector(num abi.SectorNumber) (*SectorPreCommitOnChainInfo, error) {
+	info, ok, err := s.State.GetPrecommittedSector(s.store, num)
+	if !ok || err != nil {
+		return nil, err
+	}
+
+	ret := fromV2SectorPreCommitOnChainInfo(*info)
+
+	return &ret, nil
+}
+
+func (s *state2) LoadSectors(snos *bitfield.BitField) ([]*SectorOnChainInfo, error) {
+	sectors, err := miner2.LoadSectors(s.store, s.State.Sectors)
+	if err != nil {
+		return nil, err
+	}
+
+	// If no sector numbers are specified, load all.
+	if snos == nil {
+		infos := make([]*SectorOnChainInfo, 0, sectors.Length())
+		var info2 miner2.SectorOnChainInfo
+		if err := sectors.ForEach(&info2, func(_ int64) error {
+			info := fromV2SectorOnChainInfo(info2)
+			infos = append(infos, &info)
+			return nil
+		}); err != nil {
+			return nil, err
+		}
+		return infos, nil
+	}
+
+	// Otherwise, load selected.
+	infos2, err := sectors.Load(*snos)
+	if err != nil {
+		return nil, err
+	}
+	infos := make([]*SectorOnChainInfo, len(infos2))
+	for i, info2 := range infos2 {
+		info := fromV2SectorOnChainInfo(*info2)
+		infos[i] = &info
+	}
+	return infos, nil
+}
+
+func (s *state2) IsAllocated(num abi.SectorNumber) (bool, error) {
+	var allocatedSectors bitfield.BitField
+	if err := s.store.Get(s.store.Context(), s.State.AllocatedSectors, &allocatedSectors); err != nil {
+		return false, err
+	}
+
+	return allocatedSectors.IsSet(uint64(num))
+}
+
+func (s *state2) LoadDeadline(idx uint64) (Deadline, error) {
+	dls, err := s.State.LoadDeadlines(s.store)
+	if err != nil {
+		return nil, err
+	}
+	dl, err := dls.LoadDeadline(s.store, idx)
+	if err != nil {
+		return nil, err
+	}
+	return &deadline2{*dl, s.store}, nil
+}
+
+func (s *state2) ForEachDeadline(cb func(uint64, Deadline) error) error {
+	dls, err := s.State.LoadDeadlines(s.store)
+	if err != nil {
+		return err
+	}
+	return dls.ForEach(s.store, func(i uint64, dl *miner2.Deadline) error {
+		return cb(i, &deadline2{*dl, s.store})
+	})
+}
+
+func (s *state2) NumDeadlines() (uint64, error) {
+	return miner2.WPoStPeriodDeadlines, nil
+}
+
+func (s *state2) DeadlinesChanged(other State) (bool, error) {
+	other2, ok := other.(*state2)
+	if !ok {
+		// treat an upgrade as a change, always
+		return true, nil
+	}
+
+	return s.State.Deadlines.Equals(other2.Deadlines), nil
+}
+
+func (s *state2) Info() (MinerInfo, error) {
+	info, err := s.State.GetInfo(s.store)
+	if err != nil {
+		return MinerInfo{}, err
+	}
+
+	var pid *peer.ID
+	if peerID, err := peer.IDFromBytes(info.PeerId); err == nil {
+		pid = &peerID
+	}
+
+	mi := MinerInfo{
+		Owner:            info.Owner,
+		Worker:           info.Worker,
+		ControlAddresses: info.ControlAddresses,
+
+		NewWorker:         address.Undef,
+		WorkerChangeEpoch: -1,
+
+		PeerId:                     pid,
+		Multiaddrs:                 info.Multiaddrs,
+		SealProofType:              info.SealProofType,
+		SectorSize:                 info.SectorSize,
+		WindowPoStPartitionSectors: info.WindowPoStPartitionSectors,
+		ConsensusFaultElapsed:      info.ConsensusFaultElapsed,
+	}
+
+	if info.PendingWorkerKey != nil {
+		mi.NewWorker = info.PendingWorkerKey.NewWorker
+		mi.WorkerChangeEpoch = info.PendingWorkerKey.EffectiveAt
+	}
+
+	return mi, nil
+}
+
+func (s *state2) DeadlineInfo(epoch abi.ChainEpoch) (*dline.Info, error) {
+	return s.State.DeadlineInfo(epoch), nil
+}
+
+func (s *state2) sectors() (adt.Array, error) {
+	return adt2.AsArray(s.store, s.Sectors)
+}
+
+func (s *state2) decodeSectorOnChainInfo(val *cbg.Deferred) (SectorOnChainInfo, error) {
+	var si miner2.SectorOnChainInfo
+	err := si.UnmarshalCBOR(bytes.NewReader(val.Raw))
+	if err != nil {
+		return SectorOnChainInfo{}, err
+	}
+
+	return fromV2SectorOnChainInfo(si), nil
+}
+
+func (s *state2) precommits() (adt.Map, error) {
+	return adt2.AsMap(s.store, s.PreCommittedSectors)
+}
+
+func (s *state2) decodeSectorPreCommitOnChainInfo(val *cbg.Deferred) (SectorPreCommitOnChainInfo, error) {
+	var sp miner2.SectorPreCommitOnChainInfo
+	err := sp.UnmarshalCBOR(bytes.NewReader(val.Raw))
+	if err != nil {
+		return SectorPreCommitOnChainInfo{}, err
+	}
+
+	return fromV2SectorPreCommitOnChainInfo(sp), nil
+}
+
+func (d *deadline2) LoadPartition(idx uint64) (Partition, error) {
+	p, err := d.Deadline.LoadPartition(d.store, idx)
+	if err != nil {
+		return nil, err
+	}
+	return &partition2{*p, d.store}, nil
+}
+
+func (d *deadline2) ForEachPartition(cb func(uint64, Partition) error) error {
+	ps, err := d.Deadline.PartitionsArray(d.store)
+	if err != nil {
+		return err
+	}
+	var part miner2.Partition
+	return ps.ForEach(&part, func(i int64) error {
+		return cb(uint64(i), &partition2{part, d.store})
+	})
+}
+
+func (d *deadline2) PartitionsChanged(other Deadline) (bool, error) {
+	other2, ok := other.(*deadline2)
+	if !ok {
+		// treat an upgrade as a change, always
+		return true, nil
+	}
+
+	return d.Deadline.Partitions.Equals(other2.Deadline.Partitions), nil
+}
+
+func (d *deadline2) PostSubmissions() (bitfield.BitField, error) {
+	return d.Deadline.PostSubmissions, nil
+}
+
+func (p *partition2) AllSectors() (bitfield.BitField, error) {
+	return p.Partition.Sectors, nil
+}
+
+func (p *partition2) FaultySectors() (bitfield.BitField, error) {
+	return p.Partition.Faults, nil
+}
+
+func (p *partition2) RecoveringSectors() (bitfield.BitField, error) {
+	return p.Partition.Recoveries, nil
+}
+
+func fromV2SectorOnChainInfo(v2 miner2.SectorOnChainInfo) SectorOnChainInfo {
+	return SectorOnChainInfo{
+		SectorNumber:          v2.SectorNumber,
+		SealProof:             v2.SealProof,
+		SealedCID:             v2.SealedCID,
+		DealIDs:               v2.DealIDs,
+		Activation:            v2.Activation,
+		Expiration:            v2.Expiration,
+		DealWeight:            v2.DealWeight,
+		VerifiedDealWeight:    v2.VerifiedDealWeight,
+		InitialPledge:         v2.InitialPledge,
+		ExpectedDayReward:     v2.ExpectedDayReward,
+		ExpectedStoragePledge: v2.ExpectedStoragePledge,
+	}
+}
+
+func fromV2SectorPreCommitOnChainInfo(v2 miner2.SectorPreCommitOnChainInfo) SectorPreCommitOnChainInfo {
+	return SectorPreCommitOnChainInfo{
+		Info:               (SectorPreCommitInfo)(v2.Info),
+		PreCommitDeposit:   v2.PreCommitDeposit,
+		PreCommitEpoch:     v2.PreCommitEpoch,
+		DealWeight:         v2.DealWeight,
+		VerifiedDealWeight: v2.VerifiedDealWeight,
+	}
+}

chain/actors/builtin/multisig/message.go

@@ -0,0 +1,70 @@
+package multisig
+
+import (
+	"fmt"
+
+	"github.com/minio/blake2b-simd"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/abi"
+
+	multisig2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/multisig"
+
+	"github.com/filecoin-project/lotus/chain/actors"
+	"github.com/filecoin-project/lotus/chain/types"
+)
+
+func Message(version actors.Version, from address.Address) MessageBuilder {
+	switch version {
+	case actors.Version0:
+		return message0{from}
+	case actors.Version2:
+		return message2{message0{from}}
+	default:
+		panic(fmt.Sprintf("unsupported actors version: %d", version))
+	}
+}
+
+type MessageBuilder interface {
+	// Create a new multisig with the specified parameters.
+	Create(signers []address.Address, threshold uint64,
+		vestingStart, vestingDuration abi.ChainEpoch,
+		initialAmount abi.TokenAmount) (*types.Message, error)
+
+	// Propose a transaction to the given multisig.
+	Propose(msig, target address.Address, amt abi.TokenAmount,
+		method abi.MethodNum, params []byte) (*types.Message, error)
+
+	// Approve a multisig transaction. The "hash" is optional.
+	Approve(msig address.Address, txID uint64, hash *ProposalHashData) (*types.Message, error)
+
+	// Cancel a multisig transaction. The "hash" is optional.
+	Cancel(msig address.Address, txID uint64, hash *ProposalHashData) (*types.Message, error)
+}
+
+// this type is the same between v0 and v2
+type ProposalHashData = multisig2.ProposalHashData
+
+func txnParams(id uint64, data *ProposalHashData) ([]byte, error) {
+	params := multisig2.TxnIDParams{ID: multisig2.TxnID(id)}
+	if data != nil {
+		if data.Requester.Protocol() != address.ID {
+			return nil, xerrors.Errorf("proposer address must be an ID address, was %s", data.Requester)
+		}
+		if data.Value.Sign() == -1 {
+			return nil, xerrors.Errorf("proposal value must be non-negative, was %s", data.Value)
+		}
+		if data.To == address.Undef {
+			return nil, xerrors.Errorf("proposed destination address must be set")
+		}
+		pser, err := data.Serialize()
+		if err != nil {
+			return nil, err
+		}
+		hash := blake2b.Sum256(pser)
+		params.ProposalHash = hash[:]
+	}
+
+	return actors.SerializeParams(&params)
+}

chain/actors/builtin/multisig/message0.go

@@ -0,0 +1,142 @@
+package multisig
+
+import (
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/abi"
+
+	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
+	init0 "github.com/filecoin-project/specs-actors/actors/builtin/init"
+	multisig0 "github.com/filecoin-project/specs-actors/actors/builtin/multisig"
+
+	"github.com/filecoin-project/lotus/chain/actors"
+	init_ "github.com/filecoin-project/lotus/chain/actors/builtin/init"
+	"github.com/filecoin-project/lotus/chain/types"
+)
+
+type message0 struct{ from address.Address }
+
+func (m message0) Create(
+	signers []address.Address, threshold uint64,
+	unlockStart, unlockDuration abi.ChainEpoch,
+	initialAmount abi.TokenAmount,
+) (*types.Message, error) {
+
+	lenAddrs := uint64(len(signers))
+
+	if lenAddrs < threshold {
+		return nil, xerrors.Errorf("cannot require signing of more addresses than provided for multisig")
+	}
+
+	if threshold == 0 {
+		threshold = lenAddrs
+	}
+
+	if m.from == address.Undef {
+		return nil, xerrors.Errorf("must provide source address")
+	}
+
+	if unlockStart != 0 {
+		return nil, xerrors.Errorf("actors v0 does not support a non-zero vesting start time")
+	}
+
+	// Set up constructor parameters for multisig
+	msigParams := &multisig0.ConstructorParams{
+		Signers:               signers,
+		NumApprovalsThreshold: threshold,
+		UnlockDuration:        unlockDuration,
+	}
+
+	enc, actErr := actors.SerializeParams(msigParams)
+	if actErr != nil {
+		return nil, actErr
+	}
+
+	// new actors are created by invoking 'exec' on the init actor with the constructor params
+	execParams := &init0.ExecParams{
+		CodeCID:           builtin0.MultisigActorCodeID,
+		ConstructorParams: enc,
+	}
+
+	enc, actErr = actors.SerializeParams(execParams)
+	if actErr != nil {
+		return nil, actErr
+	}
+
+	return &types.Message{
+		To:     init_.Address,
+		From:   m.from,
+		Method: builtin0.MethodsInit.Exec,
+		Params: enc,
+		Value:  initialAmount,
+	}, nil
+}
+
+func (m message0) Propose(msig, to address.Address, amt abi.TokenAmount,
+	method abi.MethodNum, params []byte) (*types.Message, error) {
+
+	if msig == address.Undef {
+		return nil, xerrors.Errorf("must provide a multisig address for proposal")
+	}
+
+	if to == address.Undef {
+		return nil, xerrors.Errorf("must provide a target address for proposal")
+	}
+
+	if amt.Sign() == -1 {
+		return nil, xerrors.Errorf("must provide a non-negative amount for proposed send")
+	}
+
+	if m.from == address.Undef {
+		return nil, xerrors.Errorf("must provide source address")
+	}
+
+	enc, actErr := actors.SerializeParams(&multisig0.ProposeParams{
+		To:     to,
+		Value:  amt,
+		Method: method,
+		Params: params,
+	})
+	if actErr != nil {
+		return nil, xerrors.Errorf("failed to serialize parameters: %w", actErr)
+	}
+
+	return &types.Message{
+		To:     msig,
+		From:   m.from,
+		Value:  abi.NewTokenAmount(0),
+		Method: builtin0.MethodsMultisig.Propose,
+		Params: enc,
+	}, nil
+}
+
+func (m message0) Approve(msig address.Address, txID uint64, hashData *ProposalHashData) (*types.Message, error) {
+	enc, err := txnParams(txID, hashData)
+	if err != nil {
+		return nil, err
+	}
+
+	return &types.Message{
+		To:     msig,
+		From:   m.from,
+		Value:  types.NewInt(0),
+		Method: builtin0.MethodsMultisig.Approve,
+		Params: enc,
+	}, nil
+}
+
+func (m message0) Cancel(msig address.Address, txID uint64, hashData *ProposalHashData) (*types.Message, error) {
+	enc, err := txnParams(txID, hashData)
+	if err != nil {
+		return nil, err
+	}
+
+	return &types.Message{
+		To:     msig,
+		From:   m.from,
+		Value:  types.NewInt(0),
+		Method: builtin0.MethodsMultisig.Cancel,
+		Params: enc,
+	}, nil
+}

chain/actors/builtin/multisig/message2.go

@@ -0,0 +1,71 @@
+package multisig
+
+import (
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/abi"
+
+	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
+	init2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/init"
+	multisig2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/multisig"
+
+	"github.com/filecoin-project/lotus/chain/actors"
+	init_ "github.com/filecoin-project/lotus/chain/actors/builtin/init"
+	"github.com/filecoin-project/lotus/chain/types"
+)
+
+type message2 struct{ message0 }
+
+func (m message2) Create(
+	signers []address.Address, threshold uint64,
+	unlockStart, unlockDuration abi.ChainEpoch,
+	initialAmount abi.TokenAmount,
+) (*types.Message, error) {
+
+	lenAddrs := uint64(len(signers))
+
+	if lenAddrs < threshold {
+		return nil, xerrors.Errorf("cannot require signing of more addresses than provided for multisig")
+	}
+
+	if threshold == 0 {
+		threshold = lenAddrs
+	}
+
+	if m.from == address.Undef {
+		return nil, xerrors.Errorf("must provide source address")
+	}
+
+	// Set up constructor parameters for multisig
+	msigParams := &multisig2.ConstructorParams{
+		Signers:               signers,
+		NumApprovalsThreshold: threshold,
+		UnlockDuration:        unlockDuration,
+		StartEpoch:            unlockStart,
+	}
+
+	enc, actErr := actors.SerializeParams(msigParams)
+	if actErr != nil {
+		return nil, actErr
+	}
+
+	// new actors are created by invoking 'exec' on the init actor with the constructor params
+	execParams := &init2.ExecParams{
+		CodeCID:           builtin2.MultisigActorCodeID,
+		ConstructorParams: enc,
+	}
+
+	enc, actErr = actors.SerializeParams(execParams)
+	if actErr != nil {
+		return nil, actErr
+	}
+
+	return &types.Message{
+		To:     init_.Address,
+		From:   m.from,
+		Method: builtin2.MethodsInit.Exec,
+		Params: enc,
+		Value:  initialAmount,
+	}, nil
+}

chain/actors/builtin/multisig/state.go

@@ -6,23 +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"
+	builtin2 "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(builtin2.MultisigActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
+		return load2(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 builtin2.MultisigActorCodeID:
+		return load2(store, act.Head)
 	}
 	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
 }

chain/actors/builtin/multisig/state0.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/state2.go

@@ -0,0 +1,70 @@
+package multisig
+
+import (
+	"encoding/binary"
+
+	"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/lotus/chain/actors/adt"
+
+	msig2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/multisig"
+	adt2 "github.com/filecoin-project/specs-actors/v2/actors/util/adt"
+)
+
+var _ State = (*state2)(nil)
+
+func load2(store adt.Store, root cid.Cid) (State, error) {
+	out := state2{store: store}
+	err := store.Get(store.Context(), root, &out)
+	if err != nil {
+		return nil, err
+	}
+	return &out, nil
+}
+
+type state2 struct {
+	msig2.State
+	store adt.Store
+}
+
+func (s *state2) LockedBalance(currEpoch abi.ChainEpoch) (abi.TokenAmount, error) {
+	return s.State.AmountLocked(currEpoch - s.State.StartEpoch), nil
+}
+
+func (s *state2) StartEpoch() (abi.ChainEpoch, error) {
+	return s.State.StartEpoch, nil
+}
+
+func (s *state2) UnlockDuration() (abi.ChainEpoch, error) {
+	return s.State.UnlockDuration, nil
+}
+
+func (s *state2) InitialBalance() (abi.TokenAmount, error) {
+	return s.State.InitialBalance, nil
+}
+
+func (s *state2) Threshold() (uint64, error) {
+	return s.State.NumApprovalsThreshold, nil
+}
+
+func (s *state2) Signers() ([]address.Address, error) {
+	return s.State.Signers, nil
+}
+
+func (s *state2) ForEachPendingTxn(cb func(id int64, txn Transaction) error) error {
+	arr, err := adt2.AsMap(s.store, s.State.PendingTxns)
+	if err != nil {
+		return err
+	}
+	var out msig2.Transaction
+	return arr.ForEach(&out, func(key string) error {
+		txid, n := binary.Varint([]byte(key))
+		if n <= 0 {
+			return xerrors.Errorf("invalid pending transaction key: %v", key)
+		}
+		return cb(txid, (Transaction)(out))
+	})
+}

chain/actors/builtin/paych/message.go

@@ -0,0 +1,28 @@
+package paych
+
+import (
+	"fmt"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/lotus/chain/actors"
+	"github.com/filecoin-project/lotus/chain/types"
+)
+
+func Message(version actors.Version, from address.Address) MessageBuilder {
+	switch version {
+	case actors.Version0:
+		return message0{from}
+	case actors.Version2:
+		return message2{from}
+	default:
+		panic(fmt.Sprintf("unsupported actors version: %d", version))
+	}
+}
+
+type MessageBuilder interface {
+	Create(to address.Address, initialAmount abi.TokenAmount) (*types.Message, error)
+	Update(paych address.Address, voucher *SignedVoucher, secret []byte) (*types.Message, error)
+	Settle(paych address.Address) (*types.Message, error)
+	Collect(paych address.Address) (*types.Message, error)
+}

chain/actors/builtin/paych/message0.go

@@ -0,0 +1,74 @@
+package paych
+
+import (
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/abi"
+
+	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
+	init0 "github.com/filecoin-project/specs-actors/actors/builtin/init"
+	paych0 "github.com/filecoin-project/specs-actors/actors/builtin/paych"
+
+	"github.com/filecoin-project/lotus/chain/actors"
+	init_ "github.com/filecoin-project/lotus/chain/actors/builtin/init"
+	"github.com/filecoin-project/lotus/chain/types"
+)
+
+type message0 struct{ from address.Address }
+
+func (m message0) Create(to address.Address, initialAmount abi.TokenAmount) (*types.Message, error) {
+	params, aerr := actors.SerializeParams(&paych0.ConstructorParams{From: m.from, To: to})
+	if aerr != nil {
+		return nil, aerr
+	}
+	enc, aerr := actors.SerializeParams(&init0.ExecParams{
+		CodeCID:           builtin0.PaymentChannelActorCodeID,
+		ConstructorParams: params,
+	})
+	if aerr != nil {
+		return nil, aerr
+	}
+
+	return &types.Message{
+		To:     init_.Address,
+		From:   m.from,
+		Value:  initialAmount,
+		Method: builtin0.MethodsInit.Exec,
+		Params: enc,
+	}, nil
+}
+
+func (m message0) Update(paych address.Address, sv *SignedVoucher, secret []byte) (*types.Message, error) {
+	params, aerr := actors.SerializeParams(&paych0.UpdateChannelStateParams{
+		Sv:     *sv,
+		Secret: secret,
+	})
+	if aerr != nil {
+		return nil, aerr
+	}
+
+	return &types.Message{
+		To:     paych,
+		From:   m.from,
+		Value:  abi.NewTokenAmount(0),
+		Method: builtin0.MethodsPaych.UpdateChannelState,
+		Params: params,
+	}, nil
+}
+
+func (m message0) Settle(paych address.Address) (*types.Message, error) {
+	return &types.Message{
+		To:     paych,
+		From:   m.from,
+		Value:  abi.NewTokenAmount(0),
+		Method: builtin0.MethodsPaych.Settle,
+	}, nil
+}
+
+func (m message0) Collect(paych address.Address) (*types.Message, error) {
+	return &types.Message{
+		To:     paych,
+		From:   m.from,
+		Value:  abi.NewTokenAmount(0),
+		Method: builtin0.MethodsPaych.Collect,
+	}, nil
+}

chain/actors/builtin/paych/message2.go

@@ -0,0 +1,74 @@
+package paych
+
+import (
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/abi"
+
+	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
+	init2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/init"
+	paych2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/paych"
+
+	"github.com/filecoin-project/lotus/chain/actors"
+	init_ "github.com/filecoin-project/lotus/chain/actors/builtin/init"
+	"github.com/filecoin-project/lotus/chain/types"
+)
+
+type message2 struct{ from address.Address }
+
+func (m message2) Create(to address.Address, initialAmount abi.TokenAmount) (*types.Message, error) {
+	params, aerr := actors.SerializeParams(&paych2.ConstructorParams{From: m.from, To: to})
+	if aerr != nil {
+		return nil, aerr
+	}
+	enc, aerr := actors.SerializeParams(&init2.ExecParams{
+		CodeCID:           builtin2.PaymentChannelActorCodeID,
+		ConstructorParams: params,
+	})
+	if aerr != nil {
+		return nil, aerr
+	}
+
+	return &types.Message{
+		To:     init_.Address,
+		From:   m.from,
+		Value:  initialAmount,
+		Method: builtin2.MethodsInit.Exec,
+		Params: enc,
+	}, nil
+}
+
+func (m message2) Update(paych address.Address, sv *SignedVoucher, secret []byte) (*types.Message, error) {
+	params, aerr := actors.SerializeParams(&paych2.UpdateChannelStateParams{
+		Sv:     *sv,
+		Secret: secret,
+	})
+	if aerr != nil {
+		return nil, aerr
+	}
+
+	return &types.Message{
+		To:     paych,
+		From:   m.from,
+		Value:  abi.NewTokenAmount(0),
+		Method: builtin2.MethodsPaych.UpdateChannelState,
+		Params: params,
+	}, nil
+}
+
+func (m message2) Settle(paych address.Address) (*types.Message, error) {
+	return &types.Message{
+		To:     paych,
+		From:   m.from,
+		Value:  abi.NewTokenAmount(0),
+		Method: builtin2.MethodsPaych.Settle,
+	}, nil
+}
+
+func (m message2) Collect(paych address.Address) (*types.Message, error) {
+	return &types.Message{
+		To:     paych,
+		From:   m.from,
+		Value:  abi.NewTokenAmount(0),
+		Method: builtin2.MethodsPaych.Collect,
+	}, nil
+}

chain/actors/builtin/paych/mock/mock.go

@@ -27,10 +27,9 @@ type mockLaneState struct {
 func NewMockPayChState(from address.Address,
 	to address.Address,
 	settlingAt abi.ChainEpoch,
-	toSend abi.TokenAmount,
 	lanes map[uint64]paych.LaneState,
 ) paych.State {
-	return &mockState{from, to, settlingAt, toSend, lanes}
+	return &mockState{from: from, to: to, settlingAt: settlingAt, toSend: big.NewInt(0), lanes: lanes}
 }
 
 // NewMockLaneState constructs a state for a payment channel lane with the set fixed values

chain/actors/builtin/paych/state.go

@@ -1,29 +1,42 @@
 package paych
 
 import (
+	"encoding/base64"
+
 	"golang.org/x/xerrors"
 
 	"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/cbor"
+	"github.com/ipfs/go-cid"
+	ipldcbor "github.com/ipfs/go-ipld-cbor"
+
 	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
 	paych0 "github.com/filecoin-project/specs-actors/actors/builtin/paych"
+	builtin2 "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(builtin2.PaymentChannelActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
+		return load2(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 builtin2.PaymentChannelActorCodeID:
+		return load2(store, act.Head)
 	}
 	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
 }
@@ -58,3 +71,18 @@ type LaneState interface {
 
 type SignedVoucher = paych0.SignedVoucher
 type ModVerifyParams = paych0.ModVerifyParams
+
+// DecodeSignedVoucher decodes base64 encoded signed voucher.
+func DecodeSignedVoucher(s string) (*SignedVoucher, error) {
+	data, err := base64.RawURLEncoding.DecodeString(s)
+	if err != nil {
+		return nil, err
+	}
+
+	var sv SignedVoucher
+	if err := ipldcbor.DecodeInto(data, &sv); err != nil {
+		return nil, err
+	}
+
+	return &sv, nil
+}

chain/actors/builtin/paych/state0.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/state2.go

@@ -0,0 +1,104 @@
+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"
+
+	paych2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/paych"
+	adt2 "github.com/filecoin-project/specs-actors/v2/actors/util/adt"
+)
+
+var _ State = (*state2)(nil)
+
+func load2(store adt.Store, root cid.Cid) (State, error) {
+	out := state2{store: store}
+	err := store.Get(store.Context(), root, &out)
+	if err != nil {
+		return nil, err
+	}
+	return &out, nil
+}
+
+type state2 struct {
+	paych2.State
+	store adt.Store
+	lsAmt *adt2.Array
+}
+
+// Channel owner, who has funded the actor
+func (s *state2) From() (address.Address, error) {
+	return s.State.From, nil
+}
+
+// Recipient of payouts from channel
+func (s *state2) To() (address.Address, error) {
+	return s.State.To, nil
+}
+
+// Height at which the channel can be `Collected`
+func (s *state2) SettlingAt() (abi.ChainEpoch, error) {
+	return s.State.SettlingAt, nil
+}
+
+// Amount successfully redeemed through the payment channel, paid out on `Collect()`
+func (s *state2) ToSend() (abi.TokenAmount, error) {
+	return s.State.ToSend, nil
+}
+
+func (s *state2) getOrLoadLsAmt() (*adt2.Array, error) {
+	if s.lsAmt != nil {
+		return s.lsAmt, nil
+	}
+
+	// Get the lane state from the chain
+	lsamt, err := adt2.AsArray(s.store, s.State.LaneStates)
+	if err != nil {
+		return nil, err
+	}
+
+	s.lsAmt = lsamt
+	return lsamt, nil
+}
+
+// Get total number of lanes
+func (s *state2) LaneCount() (uint64, error) {
+	lsamt, err := s.getOrLoadLsAmt()
+	if err != nil {
+		return 0, err
+	}
+	return lsamt.Length(), nil
+}
+
+// Iterate lane states
+func (s *state2) ForEachLaneState(cb func(idx uint64, dl LaneState) error) error {
+	// Get the lane state from the chain
+	lsamt, err := s.getOrLoadLsAmt()
+	if err != nil {
+		return err
+	}
+
+	// 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 paych2.LaneState
+	return lsamt.ForEach(&ls, func(i int64) error {
+		return cb(uint64(i), &laneState2{ls})
+	})
+}
+
+type laneState2 struct {
+	paych2.LaneState
+}
+
+func (ls *laneState2) Redeemed() (big.Int, error) {
+	return ls.LaneState.Redeemed, nil
+}
+
+func (ls *laneState2) Nonce() (uint64, error) {
+	return ls.LaneState.Nonce, nil
+}

chain/actors/builtin/power/power.go

@@ -2,28 +2,37 @@ 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"
 	"github.com/filecoin-project/go-state-types/cbor"
-	builtin0 "github.com/filecoin-project/specs-actors/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"
+
+	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
+	builtin2 "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(builtin2.StoragePowerActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
+		return load2(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 builtin2.StoragePowerActorCodeID:
+		return load2(store, act.Head)
 	}
 	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
 }

chain/actors/builtin/power/v0.go

@@ -3,13 +3,26 @@ 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"
+
 	power0 "github.com/filecoin-project/specs-actors/actors/builtin/power"
-	"github.com/filecoin-project/specs-actors/actors/util/adt"
+	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 {
 	power0.State
 	store adt.Store
@@ -35,7 +48,7 @@ func (s *state0) TotalCommitted() (Claim, error) {
 }
 
 func (s *state0) MinerPower(addr address.Address) (Claim, bool, error) {
-	claims, err := adt.AsMap(s.store, s.Claims)
+	claims, err := adt0.AsMap(s.store, s.Claims)
 	if err != nil {
 		return Claim{}, false, err
 	}
@@ -63,7 +76,7 @@ func (s *state0) MinerCounts() (uint64, uint64, error) {
 }
 
 func (s *state0) ListAllMiners() ([]address.Address, error) {
-	claims, err := adt.AsMap(s.store, s.Claims)
+	claims, err := adt0.AsMap(s.store, s.Claims)
 	if err != nil {
 		return nil, err
 	}

chain/actors/builtin/power/v2.go

@@ -0,0 +1,98 @@
+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"
+
+	power2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/power"
+	adt2 "github.com/filecoin-project/specs-actors/v2/actors/util/adt"
+)
+
+var _ State = (*state2)(nil)
+
+func load2(store adt.Store, root cid.Cid) (State, error) {
+	out := state2{store: store}
+	err := store.Get(store.Context(), root, &out)
+	if err != nil {
+		return nil, err
+	}
+	return &out, nil
+}
+
+type state2 struct {
+	power2.State
+	store adt.Store
+}
+
+func (s *state2) TotalLocked() (abi.TokenAmount, error) {
+	return s.TotalPledgeCollateral, nil
+}
+
+func (s *state2) TotalPower() (Claim, error) {
+	return Claim{
+		RawBytePower:    s.TotalRawBytePower,
+		QualityAdjPower: s.TotalQualityAdjPower,
+	}, nil
+}
+
+// Committed power to the network. Includes miners below the minimum threshold.
+func (s *state2) TotalCommitted() (Claim, error) {
+	return Claim{
+		RawBytePower:    s.TotalBytesCommitted,
+		QualityAdjPower: s.TotalQABytesCommitted,
+	}, nil
+}
+
+func (s *state2) MinerPower(addr address.Address) (Claim, bool, error) {
+	claims, err := adt2.AsMap(s.store, s.Claims)
+	if err != nil {
+		return Claim{}, false, err
+	}
+	var claim power2.Claim
+	ok, err := claims.Get(abi.AddrKey(addr), &claim)
+	if err != nil {
+		return Claim{}, false, err
+	}
+	return Claim{
+		RawBytePower:    claim.RawBytePower,
+		QualityAdjPower: claim.QualityAdjPower,
+	}, ok, nil
+}
+
+func (s *state2) MinerNominalPowerMeetsConsensusMinimum(a address.Address) (bool, error) {
+	return s.State.MinerNominalPowerMeetsConsensusMinimum(s.store, a)
+}
+
+func (s *state2) TotalPowerSmoothed() (builtin.FilterEstimate, error) {
+	return builtin.FromV2FilterEstimate(s.State.ThisEpochQAPowerSmoothed), nil
+}
+
+func (s *state2) MinerCounts() (uint64, uint64, error) {
+	return uint64(s.State.MinerAboveMinPowerCount), uint64(s.State.MinerCount), nil
+}
+
+func (s *state2) ListAllMiners() ([]address.Address, error) {
+	claims, err := adt2.AsMap(s.store, s.Claims)
+	if err != nil {
+		return nil, err
+	}
+
+	var miners []address.Address
+	err = claims.ForEach(nil, func(k string) error {
+		a, err := address.NewFromBytes([]byte(k))
+		if err != nil {
+			return err
+		}
+		miners = append(miners, a)
+		return nil
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	return miners, nil
+}

chain/actors/builtin/reward/reward.go

@@ -3,27 +3,35 @@ 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"
 	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
+	builtin2 "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.RewardActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
+		return load0(store, root)
+	})
+	builtin.RegisterActorState(builtin2.RewardActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
+		return load2(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 builtin2.RewardActorCodeID:
+		return load2(store, act.Head)
 	}
 	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
 }

chain/actors/builtin/reward/v0.go

@@ -2,17 +2,29 @@ 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"
+
 	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
-	"github.com/filecoin-project/specs-actors/actors/builtin/reward"
-	"github.com/filecoin-project/specs-actors/actors/util/adt"
-	"github.com/filecoin-project/specs-actors/actors/util/smoothing"
+	reward0 "github.com/filecoin-project/specs-actors/actors/builtin/reward"
+	smoothing0 "github.com/filecoin-project/specs-actors/actors/util/smoothing"
 )
 
 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 {
-	reward.State
+	reward0.State
 	store adt.Store
 }
 
@@ -54,7 +66,7 @@ func (s *state0) InitialPledgeForPower(sectorWeight abi.StoragePower, networkTot
 		s.State.ThisEpochBaselinePower,
 		networkTotalPledge,
 		s.State.ThisEpochRewardSmoothed,
-		&smoothing.FilterEstimate{
+		&smoothing0.FilterEstimate{
 			PositionEstimate: networkQAPower.PositionEstimate,
 			VelocityEstimate: networkQAPower.VelocityEstimate,
 		},
@@ -63,7 +75,7 @@ func (s *state0) InitialPledgeForPower(sectorWeight abi.StoragePower, networkTot
 
 func (s *state0) PreCommitDepositForPower(networkQAPower builtin.FilterEstimate, sectorWeight abi.StoragePower) (abi.TokenAmount, error) {
 	return miner0.PreCommitDepositForPower(s.State.ThisEpochRewardSmoothed,
-		&smoothing.FilterEstimate{
+		&smoothing0.FilterEstimate{
 			PositionEstimate: networkQAPower.PositionEstimate,
 			VelocityEstimate: networkQAPower.VelocityEstimate,
 		},

chain/actors/builtin/reward/v2.go

@@ -0,0 +1,86 @@
+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"
+
+	miner2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/miner"
+	reward2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/reward"
+	smoothing2 "github.com/filecoin-project/specs-actors/v2/actors/util/smoothing"
+)
+
+var _ State = (*state2)(nil)
+
+func load2(store adt.Store, root cid.Cid) (State, error) {
+	out := state2{store: store}
+	err := store.Get(store.Context(), root, &out)
+	if err != nil {
+		return nil, err
+	}
+	return &out, nil
+}
+
+type state2 struct {
+	reward2.State
+	store adt.Store
+}
+
+func (s *state2) ThisEpochReward() (abi.StoragePower, error) {
+	return s.State.ThisEpochReward, nil
+}
+
+func (s *state2) ThisEpochRewardSmoothed() (builtin.FilterEstimate, error) {
+	return builtin.FilterEstimate{
+		PositionEstimate: s.State.ThisEpochRewardSmoothed.PositionEstimate,
+		VelocityEstimate: s.State.ThisEpochRewardSmoothed.VelocityEstimate,
+	}, nil
+}
+
+func (s *state2) ThisEpochBaselinePower() (abi.StoragePower, error) {
+	return s.State.ThisEpochBaselinePower, nil
+}
+
+func (s *state2) TotalStoragePowerReward() (abi.TokenAmount, error) {
+	return s.State.TotalStoragePowerReward, nil
+}
+
+func (s *state2) EffectiveBaselinePower() (abi.StoragePower, error) {
+	return s.State.EffectiveBaselinePower, nil
+}
+
+func (s *state2) EffectiveNetworkTime() (abi.ChainEpoch, error) {
+	return s.State.EffectiveNetworkTime, nil
+}
+
+func (s *state2) CumsumBaseline() (abi.StoragePower, error) {
+	return s.State.CumsumBaseline, nil
+}
+
+func (s *state2) CumsumRealized() (abi.StoragePower, error) {
+	return s.State.CumsumBaseline, nil
+}
+
+func (s *state2) InitialPledgeForPower(qaPower abi.StoragePower, networkTotalPledge abi.TokenAmount, networkQAPower *builtin.FilterEstimate, circSupply abi.TokenAmount) (abi.TokenAmount, error) {
+	return miner2.InitialPledgeForPower(
+		qaPower,
+		s.State.ThisEpochBaselinePower,
+		s.State.ThisEpochRewardSmoothed,
+		smoothing2.FilterEstimate{
+			PositionEstimate: networkQAPower.PositionEstimate,
+			VelocityEstimate: networkQAPower.VelocityEstimate,
+		},
+		circSupply,
+	), nil
+}
+
+func (s *state2) PreCommitDepositForPower(networkQAPower builtin.FilterEstimate, sectorWeight abi.StoragePower) (abi.TokenAmount, error) {
+	return miner2.PreCommitDepositForPower(s.State.ThisEpochRewardSmoothed,
+		smoothing2.FilterEstimate{
+			PositionEstimate: networkQAPower.PositionEstimate,
+			VelocityEstimate: networkQAPower.VelocityEstimate,
+		},
+		sectorWeight), nil
+}

chain/actors/builtin/verifreg/util.go

@@ -0,0 +1,46 @@
+package verifreg
+
+import (
+	"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"
+	"github.com/filecoin-project/lotus/chain/actors/adt"
+	"github.com/ipfs/go-cid"
+	"golang.org/x/xerrors"
+)
+
+func getDataCap(store adt.Store, ver actors.Version, root cid.Cid, addr address.Address) (bool, abi.StoragePower, error) {
+	if addr.Protocol() != address.ID {
+		return false, big.Zero(), xerrors.Errorf("can only look up ID addresses")
+	}
+
+	vh, err := adt.AsMap(store, root, ver)
+	if err != nil {
+		return false, big.Zero(), xerrors.Errorf("loading verifreg: %w", err)
+	}
+
+	var dcap abi.StoragePower
+	if found, err := vh.Get(abi.AddrKey(addr), &dcap); err != nil {
+		return false, big.Zero(), xerrors.Errorf("looking up addr: %w", err)
+	} else if !found {
+		return false, big.Zero(), nil
+	}
+
+	return true, dcap, nil
+}
+
+func forEachCap(store adt.Store, ver actors.Version, root cid.Cid, cb func(addr address.Address, dcap abi.StoragePower) error) error {
+	vh, err := adt.AsMap(store, root, ver)
+	if err != nil {
+		return xerrors.Errorf("loading verified clients: %w", err)
+	}
+	var dcap abi.StoragePower
+	return vh.ForEach(&dcap, func(key string) error {
+		a, err := address.NewFromBytes([]byte(key))
+		if err != nil {
+			return err
+		}
+		return cb(a, dcap)
+	})
+}

chain/actors/builtin/verifreg/v0.go

@@ -3,69 +3,46 @@ package verifreg
 import (
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/go-state-types/big"
-	verifreg0 "github.com/filecoin-project/specs-actors/actors/builtin/verifreg"
-	adt0 "github.com/filecoin-project/specs-actors/actors/util/adt"
 	"github.com/ipfs/go-cid"
-	"golang.org/x/xerrors"
 
+	"github.com/filecoin-project/lotus/chain/actors"
 	"github.com/filecoin-project/lotus/chain/actors/adt"
+
+	verifreg0 "github.com/filecoin-project/specs-actors/actors/builtin/verifreg"
 )
 
 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
 }
 
-func getDataCap(store adt.Store, root cid.Cid, addr address.Address) (bool, abi.StoragePower, error) {
-	if addr.Protocol() != address.ID {
-		return false, big.Zero(), xerrors.Errorf("can only look up ID addresses")
-	}
-
-	vh, err := adt0.AsMap(store, root)
-	if err != nil {
-		return false, big.Zero(), xerrors.Errorf("loading verifreg: %w", err)
-	}
-
-	var dcap abi.StoragePower
-	if found, err := vh.Get(abi.AddrKey(addr), &dcap); err != nil {
-		return false, big.Zero(), xerrors.Errorf("looking up addr: %w", err)
-	} else if !found {
-		return false, big.Zero(), nil
-	}
-
-	return true, dcap, nil
+func (s *state0) RootKey() (address.Address, error) {
+	return s.State.RootKey, nil
 }
 
 func (s *state0) VerifiedClientDataCap(addr address.Address) (bool, abi.StoragePower, error) {
-	return getDataCap(s.store, s.State.VerifiedClients, addr)
+	return getDataCap(s.store, actors.Version0, s.State.VerifiedClients, addr)
 }
 
 func (s *state0) VerifierDataCap(addr address.Address) (bool, abi.StoragePower, error) {
-	return getDataCap(s.store, s.State.Verifiers, addr)
-}
-
-func forEachCap(store adt.Store, root cid.Cid, cb func(addr address.Address, dcap abi.StoragePower) error) error {
-	vh, err := adt0.AsMap(store, root)
-	if err != nil {
-		return xerrors.Errorf("loading verified clients: %w", err)
-	}
-	var dcap abi.StoragePower
-	return vh.ForEach(&dcap, func(key string) error {
-		a, err := address.NewFromBytes([]byte(key))
-		if err != nil {
-			return err
-		}
-		return cb(a, dcap)
-	})
+	return getDataCap(s.store, actors.Version0, s.State.Verifiers, addr)
 }
 
 func (s *state0) ForEachVerifier(cb func(addr address.Address, dcap abi.StoragePower) error) error {
-	return forEachCap(s.store, s.State.Verifiers, cb)
+	return forEachCap(s.store, actors.Version0, s.State.Verifiers, cb)
 }
 
 func (s *state0) ForEachClient(cb func(addr address.Address, dcap abi.StoragePower) error) error {
-	return forEachCap(s.store, s.State.VerifiedClients, cb)
+	return forEachCap(s.store, actors.Version0, s.State.VerifiedClients, cb)
 }

chain/actors/builtin/verifreg/v2.go

@@ -0,0 +1,48 @@
+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"
+
+	verifreg2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/verifreg"
+)
+
+var _ State = (*state2)(nil)
+
+func load2(store adt.Store, root cid.Cid) (State, error) {
+	out := state2{store: store}
+	err := store.Get(store.Context(), root, &out)
+	if err != nil {
+		return nil, err
+	}
+	return &out, nil
+}
+
+type state2 struct {
+	verifreg2.State
+	store adt.Store
+}
+
+func (s *state2) RootKey() (address.Address, error) {
+	return s.State.RootKey, nil
+}
+
+func (s *state2) VerifiedClientDataCap(addr address.Address) (bool, abi.StoragePower, error) {
+	return getDataCap(s.store, actors.Version2, s.State.VerifiedClients, addr)
+}
+
+func (s *state2) VerifierDataCap(addr address.Address) (bool, abi.StoragePower, error) {
+	return getDataCap(s.store, actors.Version2, s.State.Verifiers, addr)
+}
+
+func (s *state2) ForEachVerifier(cb func(addr address.Address, dcap abi.StoragePower) error) error {
+	return forEachCap(s.store, actors.Version2, s.State.Verifiers, cb)
+}
+
+func (s *state2) ForEachClient(cb func(addr address.Address, dcap abi.StoragePower) error) error {
+	return forEachCap(s.store, actors.Version2, s.State.VerifiedClients, cb)
+}

chain/actors/builtin/verifreg/verifreg.go

@@ -3,26 +3,35 @@ 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"
 	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
+	builtin2 "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(builtin2.VerifiedRegistryActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
+		return load2(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 builtin2.VerifiedRegistryActorCodeID:
+		return load2(store, act.Head)
 	}
 	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
 }
@@ -30,6 +39,7 @@ func Load(store adt.Store, act *types.Actor) (State, error) {
 type State interface {
 	cbor.Marshaler
 
+	RootKey() (address.Address, error)
 	VerifiedClientDataCap(address.Address) (bool, abi.StoragePower, error)
 	VerifierDataCap(address.Address) (bool, abi.StoragePower, error)
 	ForEachVerifier(func(addr address.Address, dcap abi.StoragePower) error) error

chain/actors/policy/policy.go

@@ -2,10 +2,21 @@ package policy
 
 import (
 	"github.com/filecoin-project/go-state-types/abi"
-
+	"github.com/filecoin-project/go-state-types/network"
+	"github.com/filecoin-project/lotus/chain/actors"
+	market0 "github.com/filecoin-project/specs-actors/actors/builtin/market"
 	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
 	power0 "github.com/filecoin-project/specs-actors/actors/builtin/power"
 	verifreg0 "github.com/filecoin-project/specs-actors/actors/builtin/verifreg"
+	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
+	market2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/market"
+	miner2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/miner"
+	verifreg2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/verifreg"
+)
+
+const (
+	ChainFinality          = miner0.ChainFinality
+	SealRandomnessLookback = ChainFinality
 )
 
 // SetSupportedProofTypes sets supported proof types, across all actor versions.
@@ -17,6 +28,7 @@ func SetSupportedProofTypes(types ...abi.RegisteredSealProof) {
 	}
 	// Set for all miner versions.
 	miner0.SupportedProofTypes = newTypes
+	miner2.SupportedProofTypes = newTypes
 }
 
 // AddSupportedProofTypes sets supported proof types, across all actor versions.
@@ -25,6 +37,7 @@ func AddSupportedProofTypes(types ...abi.RegisteredSealProof) {
 	for _, t := range types {
 		// Set for all miner versions.
 		miner0.SupportedProofTypes[t] = struct{}{}
+		miner2.SupportedProofTypes[t] = struct{}{}
 	}
 }
 
@@ -33,6 +46,7 @@ func AddSupportedProofTypes(types ...abi.RegisteredSealProof) {
 func SetPreCommitChallengeDelay(delay abi.ChainEpoch) {
 	// Set for all miner versions.
 	miner0.PreCommitChallengeDelay = delay
+	miner2.PreCommitChallengeDelay = delay
 }
 
 // TODO: this function shouldn't really exist. Instead, the API should expose the precommit delay.
@@ -45,10 +59,58 @@ func GetPreCommitChallengeDelay() abi.ChainEpoch {
 // for testing.
 func SetConsensusMinerMinPower(p abi.StoragePower) {
 	power0.ConsensusMinerMinPower = p
+	for _, policy := range builtin2.SealProofPolicies {
+		policy.ConsensusMinerMinPower = p
+	}
 }
 
 // SetMinVerifiedDealSize sets the minimum size of a verified deal. This should
 // only be used for testing.
 func SetMinVerifiedDealSize(size abi.StoragePower) {
 	verifreg0.MinVerifiedDealSize = size
+	verifreg2.MinVerifiedDealSize = size
+}
+
+func GetMaxProveCommitDuration(ver actors.Version, t abi.RegisteredSealProof) abi.ChainEpoch {
+	switch ver {
+	case actors.Version0:
+		return miner0.MaxSealDuration[t]
+	case actors.Version2:
+		return miner2.MaxProveCommitDuration[t]
+	default:
+		panic("unsupported actors version")
+	}
+}
+
+func DealProviderCollateralBounds(
+	size abi.PaddedPieceSize, verified bool,
+	rawBytePower, qaPower, baselinePower abi.StoragePower,
+	circulatingFil abi.TokenAmount, nwVer network.Version,
+) (min, max abi.TokenAmount) {
+	switch actors.VersionForNetwork(nwVer) {
+	case actors.Version0:
+		return market0.DealProviderCollateralBounds(size, verified, rawBytePower, qaPower, baselinePower, circulatingFil, nwVer)
+	case actors.Version2:
+		return market2.DealProviderCollateralBounds(size, verified, rawBytePower, qaPower, baselinePower, circulatingFil)
+	default:
+		panic("unsupported network version")
+	}
+}
+
+// Sets the challenge window and scales the proving period to match (such that
+// there are always 48 challenge windows in a proving period).
+func SetWPoStChallengeWindow(period abi.ChainEpoch) {
+	miner0.WPoStChallengeWindow = period
+	miner0.WPoStProvingPeriod = period * abi.ChainEpoch(miner0.WPoStPeriodDeadlines)
+
+	miner2.WPoStChallengeWindow = period
+	miner2.WPoStProvingPeriod = period * abi.ChainEpoch(miner2.WPoStPeriodDeadlines)
+}
+
+func GetWinningPoStSectorSetLookback(nwVer network.Version) abi.ChainEpoch {
+	if nwVer <= network.Version3 {
+		return 10
+	}
+
+	return ChainFinality
 }

chain/actors/policy/policy_test.go

@@ -7,6 +7,9 @@ import (
 
 	"github.com/filecoin-project/go-state-types/abi"
 	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
+	verifreg0 "github.com/filecoin-project/specs-actors/actors/builtin/verifreg"
+	miner2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/miner"
+	verifreg2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/verifreg"
 )
 
 func TestSupportedProofTypes(t *testing.T) {
@@ -34,3 +37,14 @@ func TestSupportedProofTypes(t *testing.T) {
 		},
 	)
 }
+
+// Tests assumptions about policies being the same between actor versions.
+func TestAssumptions(t *testing.T) {
+	require.EqualValues(t, miner0.SupportedProofTypes, miner2.SupportedProofTypes)
+	require.Equal(t, miner0.PreCommitChallengeDelay, miner2.PreCommitChallengeDelay)
+	require.Equal(t, miner0.ChainFinality, miner2.ChainFinality)
+	require.Equal(t, miner0.WPoStChallengeWindow, miner2.WPoStChallengeWindow)
+	require.Equal(t, miner0.WPoStProvingPeriod, miner2.WPoStProvingPeriod)
+	require.Equal(t, miner0.WPoStPeriodDeadlines, miner2.WPoStPeriodDeadlines)
+	require.True(t, verifreg0.MinVerifiedDealSize.Equals(verifreg2.MinVerifiedDealSize))
+}

chain/actors/version.go

@@ -0,0 +1,26 @@
+package actors
+
+import (
+	"fmt"
+
+	"github.com/filecoin-project/go-state-types/network"
+)
+
+type Version int
+
+const (
+	Version0 = 0
+	Version2 = 2
+)
+
+// Converts a network version into an actors adt version.
+func VersionForNetwork(version network.Version) Version {
+	switch version {
+	case network.Version0, network.Version1, network.Version2, network.Version3:
+		return Version0
+	case network.Version4:
+		return Version2
+	default:
+		panic(fmt.Sprintf("unsupported network version %d", version))
+	}
+}

chain/exchange/client.go

@@ -117,7 +117,7 @@ func (c *client) doRequest(
 		res, err := c.sendRequestToPeer(ctx, peer, req)
 		if err != nil {
 			if !xerrors.Is(err, network.ErrNoConn) {
-				log.Warnf("could not connect to peer %s: %s",
+				log.Warnf("could not send request to peer %s: %s",
 					peer.String(), err)
 			}
 			continue

chain/gen/gen.go

@@ -9,6 +9,7 @@ import (
 	"time"
 
 	"github.com/filecoin-project/specs-actors/actors/runtime/proof"
+	"github.com/google/uuid"
 
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
@@ -224,7 +225,7 @@ func NewGeneratorWithSectors(numSectors int) (*ChainGen, error) {
 		},
 		VerifregRootKey:  DefaultVerifregRootkeyActor,
 		RemainderAccount: DefaultRemainderAccountActor,
-		NetworkName:      "",
+		NetworkName:      uuid.New().String(),
 		Timestamp:        uint64(build.Clock.Now().Add(-500 * time.Duration(build.BlockDelaySecs) * time.Second).Unix()),
 	}
 

chain/gen/genesis/genesis.go

@@ -6,6 +6,8 @@ import (
 	"encoding/json"
 	"fmt"
 
+	"github.com/filecoin-project/lotus/chain/actors/builtin"
+
 	"github.com/ipfs/go-cid"
 	"github.com/ipfs/go-datastore"
 	cbor "github.com/ipfs/go-ipld-cbor"
@@ -24,7 +26,7 @@ import (
 	adt0 "github.com/filecoin-project/specs-actors/actors/util/adt"
 
 	"github.com/filecoin-project/lotus/build"
-	"github.com/filecoin-project/lotus/chain/actors/builtin"
+	"github.com/filecoin-project/lotus/chain/actors"
 	"github.com/filecoin-project/lotus/chain/state"
 	"github.com/filecoin-project/lotus/chain/store"
 	"github.com/filecoin-project/lotus/chain/types"
@@ -115,7 +117,7 @@ func MakeInitialStateTree(ctx context.Context, bs bstore.Blockstore, template ge
 		return nil, nil, xerrors.Errorf("putting empty object: %w", err)
 	}
 
-	state, err := state.NewStateTree(cst, builtin.Version0)
+	state, err := state.NewStateTree(cst, actors.Version0)
 	if err != nil {
 		return nil, nil, xerrors.Errorf("making new state tree: %w", err)
 	}
@@ -296,14 +298,9 @@ func MakeInitialStateTree(ctx context.Context, bs bstore.Blockstore, template ge
 		return nil, nil, xerrors.Errorf("somehow overallocated filecoin (allocated = %s)", types.FIL(totalFilAllocated))
 	}
 
-	remAccKey, err := address.NewIDAddress(90)
-	if err != nil {
-		return nil, nil, err
-	}
-
 	template.RemainderAccount.Balance = remainingFil
 
-	if err := createMultisigAccount(ctx, bs, cst, state, remAccKey, template.RemainderAccount, keyIDs); err != nil {
+	if err := createMultisigAccount(ctx, bs, cst, state, builtin.ReserveAddress, template.RemainderAccount, keyIDs); err != nil {
 		return nil, nil, xerrors.Errorf("failed to set up remainder account: %w", err)
 	}
 

chain/gen/slashfilter/slashfilter.go

@@ -105,6 +105,10 @@ func checkFault(t ds.Datastore, key ds.Key, bh *types.BlockHeader, faultType str
 			return err
 		}
 
+		if other == bh.Cid() {
+			return nil
+		}
+
 		return xerrors.Errorf("produced block would trigger '%s' consensus fault; miner: %s; bh: %s, other: %s", faultType, bh.Miner, bh.Cid(), other)
 	}
 

chain/messagepool/gasguess/guessgas.go

@@ -10,7 +10,9 @@ import (
 
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/specs-actors/actors/builtin"
+
+	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
+	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
 )
 
 type ActorLookup func(context.Context, address.Address, types.TipSetKey) (*types.Actor, error)
@@ -27,19 +29,33 @@ type CostKey struct {
 }
 
 var Costs = map[CostKey]int64{
-	{builtin.InitActorCodeID, 2}:          8916753,
-	{builtin.StorageMarketActorCodeID, 2}: 6955002,
-	{builtin.StorageMarketActorCodeID, 4}: 245436108,
-	{builtin.StorageMinerActorCodeID, 4}:  2315133,
-	{builtin.StorageMinerActorCodeID, 5}:  1600271356,
-	{builtin.StorageMinerActorCodeID, 6}:  22864493,
-	{builtin.StorageMinerActorCodeID, 7}:  142002419,
-	{builtin.StorageMinerActorCodeID, 10}: 23008274,
-	{builtin.StorageMinerActorCodeID, 11}: 19303178,
-	{builtin.StorageMinerActorCodeID, 14}: 566356835,
-	{builtin.StorageMinerActorCodeID, 16}: 5325185,
-	{builtin.StorageMinerActorCodeID, 18}: 2328637,
-	{builtin.StoragePowerActorCodeID, 2}:  23600956,
+	{builtin0.InitActorCodeID, 2}:          8916753,
+	{builtin0.StorageMarketActorCodeID, 2}: 6955002,
+	{builtin0.StorageMarketActorCodeID, 4}: 245436108,
+	{builtin0.StorageMinerActorCodeID, 4}:  2315133,
+	{builtin0.StorageMinerActorCodeID, 5}:  1600271356,
+	{builtin0.StorageMinerActorCodeID, 6}:  22864493,
+	{builtin0.StorageMinerActorCodeID, 7}:  142002419,
+	{builtin0.StorageMinerActorCodeID, 10}: 23008274,
+	{builtin0.StorageMinerActorCodeID, 11}: 19303178,
+	{builtin0.StorageMinerActorCodeID, 14}: 566356835,
+	{builtin0.StorageMinerActorCodeID, 16}: 5325185,
+	{builtin0.StorageMinerActorCodeID, 18}: 2328637,
+	{builtin0.StoragePowerActorCodeID, 2}:  23600956,
+	// TODO: Just reuse v0 values for now, this isn't actually used
+	{builtin2.InitActorCodeID, 2}:          8916753,
+	{builtin2.StorageMarketActorCodeID, 2}: 6955002,
+	{builtin2.StorageMarketActorCodeID, 4}: 245436108,
+	{builtin2.StorageMinerActorCodeID, 4}:  2315133,
+	{builtin2.StorageMinerActorCodeID, 5}:  1600271356,
+	{builtin2.StorageMinerActorCodeID, 6}:  22864493,
+	{builtin2.StorageMinerActorCodeID, 7}:  142002419,
+	{builtin2.StorageMinerActorCodeID, 10}: 23008274,
+	{builtin2.StorageMinerActorCodeID, 11}: 19303178,
+	{builtin2.StorageMinerActorCodeID, 14}: 566356835,
+	{builtin2.StorageMinerActorCodeID, 16}: 5325185,
+	{builtin2.StorageMinerActorCodeID, 18}: 2328637,
+	{builtin2.StoragePowerActorCodeID, 2}:  23600956,
 }
 
 func failedGuess(msg *types.SignedMessage) int64 {
@@ -51,7 +67,8 @@ func failedGuess(msg *types.SignedMessage) int64 {
 }
 
 func GuessGasUsed(ctx context.Context, tsk types.TipSetKey, msg *types.SignedMessage, al ActorLookup) (int64, error) {
-	if msg.Message.Method == builtin.MethodSend {
+	// MethodSend is the same in all versions.
+	if msg.Message.Method == builtin0.MethodSend {
 		switch msg.Message.From.Protocol() {
 		case address.BLS:
 			return 1298450, nil

chain/messagepool/messagepool.go

@@ -55,6 +55,7 @@ var baseFeeLowerBoundFactor = types.NewInt(10)
 var baseFeeLowerBoundFactorConservative = types.NewInt(100)
 
 var MaxActorPendingMessages = 1000
+var MaxUntrustedActorPendingMessages = 10
 
 var MaxNonceGap = uint64(4)
 
@@ -195,9 +196,17 @@ func CapGasFee(msg *types.Message, maxFee abi.TokenAmount) {
 	msg.GasPremium = big.Min(msg.GasFeeCap, msg.GasPremium) // cap premium at FeeCap
 }
 
-func (ms *msgSet) add(m *types.SignedMessage, mp *MessagePool, strict bool) (bool, error) {
+func (ms *msgSet) add(m *types.SignedMessage, mp *MessagePool, strict, untrusted bool) (bool, error) {
 	nextNonce := ms.nextNonce
 	nonceGap := false
+
+	maxNonceGap := MaxNonceGap
+	maxActorPendingMessages := MaxActorPendingMessages
+	if untrusted {
+		maxNonceGap = 0
+		maxActorPendingMessages = MaxUntrustedActorPendingMessages
+	}
+
 	switch {
 	case m.Message.Nonce == nextNonce:
 		nextNonce++
@@ -206,7 +215,7 @@ func (ms *msgSet) add(m *types.SignedMessage, mp *MessagePool, strict bool) (boo
 			nextNonce++
 		}
 
-	case strict && m.Message.Nonce > nextNonce+MaxNonceGap:
+	case strict && m.Message.Nonce > nextNonce+maxNonceGap:
 		return false, xerrors.Errorf("message nonce has too big a gap from expected nonce (Nonce: %d, nextNonce: %d): %w", m.Message.Nonce, nextNonce, ErrNonceGap)
 
 	case m.Message.Nonce > nextNonce:
@@ -242,7 +251,7 @@ func (ms *msgSet) add(m *types.SignedMessage, mp *MessagePool, strict bool) (boo
 		//ms.requiredFunds.Sub(ms.requiredFunds, exms.Message.Value.Int)
 	}
 
-	if !has && strict && len(ms.msgs) > MaxActorPendingMessages {
+	if !has && strict && len(ms.msgs) >= maxActorPendingMessages {
 		log.Errorf("too many pending messages from actor %s", m.Message.From)
 		return false, ErrTooManyPendingMessages
 	}
@@ -484,7 +493,7 @@ func (mp *MessagePool) Push(m *types.SignedMessage) (cid.Cid, error) {
 	}
 
 	mp.curTsLk.Lock()
-	publish, err := mp.addTs(m, mp.curTs, true)
+	publish, err := mp.addTs(m, mp.curTs, true, false)
 	if err != nil {
 		mp.curTsLk.Unlock()
 		return cid.Undef, err
@@ -551,7 +560,7 @@ func (mp *MessagePool) Add(m *types.SignedMessage) error {
 	mp.curTsLk.Lock()
 	defer mp.curTsLk.Unlock()
 
-	_, err = mp.addTs(m, mp.curTs, false)
+	_, err = mp.addTs(m, mp.curTs, false, false)
 	return err
 }
 
@@ -619,7 +628,7 @@ func (mp *MessagePool) checkBalance(m *types.SignedMessage, curTs *types.TipSet)
 	return nil
 }
 
-func (mp *MessagePool) addTs(m *types.SignedMessage, curTs *types.TipSet, local bool) (bool, error) {
+func (mp *MessagePool) addTs(m *types.SignedMessage, curTs *types.TipSet, local, untrusted bool) (bool, error) {
 	snonce, err := mp.getStateNonce(m.Message.From, curTs)
 	if err != nil {
 		return false, xerrors.Errorf("failed to look up actor state nonce: %s: %w", err, ErrSoftValidationFailure)
@@ -641,7 +650,7 @@ func (mp *MessagePool) addTs(m *types.SignedMessage, curTs *types.TipSet, local
 		return false, err
 	}
 
-	return publish, mp.addLocked(m, !local)
+	return publish, mp.addLocked(m, !local, untrusted)
 }
 
 func (mp *MessagePool) addLoaded(m *types.SignedMessage) error {
@@ -676,17 +685,17 @@ func (mp *MessagePool) addLoaded(m *types.SignedMessage) error {
 		return err
 	}
 
-	return mp.addLocked(m, false)
+	return mp.addLocked(m, false, false)
 }
 
 func (mp *MessagePool) addSkipChecks(m *types.SignedMessage) error {
 	mp.lk.Lock()
 	defer mp.lk.Unlock()
 
-	return mp.addLocked(m, false)
+	return mp.addLocked(m, false, false)
 }
 
-func (mp *MessagePool) addLocked(m *types.SignedMessage, strict bool) error {
+func (mp *MessagePool) addLocked(m *types.SignedMessage, strict, untrusted bool) error {
 	log.Debugf("mpooladd: %s %d", m.Message.From, m.Message.Nonce)
 	if m.Signature.Type == crypto.SigTypeBLS {
 		mp.blsSigCache.Add(m.Cid(), m.Signature)
@@ -713,7 +722,7 @@ func (mp *MessagePool) addLocked(m *types.SignedMessage, strict bool) error {
 		mp.pending[m.Message.From] = mset
 	}
 
-	incr, err := mset.add(m, mp, strict)
+	incr, err := mset.add(m, mp, strict, untrusted)
 	if err != nil {
 		log.Debug(err)
 		return err
@@ -793,6 +802,50 @@ func (mp *MessagePool) getStateBalance(addr address.Address, ts *types.TipSet) (
 	return act.Balance, nil
 }
 
+// this method is provided for the gateway to push messages.
+// differences from Push:
+//  - strict checks are enabled
+//  - extra strict add checks are used when adding the messages to the msgSet
+//    that means: no nonce gaps, at most 10 pending messages for the actor
+func (mp *MessagePool) PushUntrusted(m *types.SignedMessage) (cid.Cid, error) {
+	err := mp.checkMessage(m)
+	if err != nil {
+		return cid.Undef, err
+	}
+
+	// serialize push access to reduce lock contention
+	mp.addSema <- struct{}{}
+	defer func() {
+		<-mp.addSema
+	}()
+
+	msgb, err := m.Serialize()
+	if err != nil {
+		return cid.Undef, err
+	}
+
+	mp.curTsLk.Lock()
+	publish, err := mp.addTs(m, mp.curTs, false, true)
+	if err != nil {
+		mp.curTsLk.Unlock()
+		return cid.Undef, err
+	}
+	mp.curTsLk.Unlock()
+
+	mp.lk.Lock()
+	if err := mp.addLocal(m, msgb); err != nil {
+		mp.lk.Unlock()
+		return cid.Undef, err
+	}
+	mp.lk.Unlock()
+
+	if publish {
+		err = mp.api.PubSubPublish(build.MessagesTopic(mp.netName), msgb)
+	}
+
+	return m.Cid(), err
+}
+
 func (mp *MessagePool) Remove(from address.Address, nonce uint64, applied bool) {
 	mp.lk.Lock()
 	defer mp.lk.Unlock()

chain/messagesigner/messagesigner.go

@@ -3,6 +3,7 @@ package messagesigner
 import (
 	"bytes"
 	"context"
+	"sync"
 
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/lotus/chain/messagepool"
@@ -16,7 +17,7 @@ import (
 	"golang.org/x/xerrors"
 )
 
-const dsKeyActorNonce = "ActorNonce"
+const dsKeyActorNonce = "ActorNextNonce"
 
 var log = logging.Logger("messagesigner")
 
@@ -28,6 +29,7 @@ type mpoolAPI interface {
 // when signing a message
 type MessageSigner struct {
 	wallet *wallet.Wallet
+	lk     sync.Mutex
 	mpool  mpoolAPI
 	ds     datastore.Batching
 }
@@ -47,25 +49,42 @@ func newMessageSigner(wallet *wallet.Wallet, mpool mpoolAPI, ds dtypes.MetadataD
 
 // SignMessage increments the nonce for the message From address, and signs
 // the message
-func (ms *MessageSigner) SignMessage(ctx context.Context, msg *types.Message) (*types.SignedMessage, error) {
+func (ms *MessageSigner) SignMessage(ctx context.Context, msg *types.Message, cb func(*types.SignedMessage) error) (*types.SignedMessage, error) {
+	ms.lk.Lock()
+	defer ms.lk.Unlock()
+
+	// Get the next message nonce
 	nonce, err := ms.nextNonce(msg.From)
 	if err != nil {
 		return nil, xerrors.Errorf("failed to create nonce: %w", err)
 	}
 
+	// Sign the message with the nonce
 	msg.Nonce = nonce
 	sig, err := ms.wallet.Sign(ctx, msg.From, msg.Cid().Bytes())
 	if err != nil {
 		return nil, xerrors.Errorf("failed to sign message: %w", err)
 	}
 
-	return &types.SignedMessage{
+	// Callback with the signed message
+	smsg := &types.SignedMessage{
 		Message:   *msg,
 		Signature: *sig,
-	}, nil
+	}
+	err = cb(smsg)
+	if err != nil {
+		return nil, err
+	}
+
+	// If the callback executed successfully, write the nonce to the datastore
+	if err := ms.saveNonce(msg.From, nonce); err != nil {
+		return nil, xerrors.Errorf("failed to save nonce: %w", err)
+	}
+
+	return smsg, nil
 }
 
-// nextNonce increments the nonce.
+// nextNonce gets the next nonce for the given address.
 // If there is no nonce in the datastore, gets the nonce from the message pool.
 func (ms *MessageSigner) nextNonce(addr address.Address) (uint64, error) {
 	// Nonces used to be created by the mempool and we need to support nodes
@@ -77,21 +96,22 @@ func (ms *MessageSigner) nextNonce(addr address.Address) (uint64, error) {
 		return 0, xerrors.Errorf("failed to get nonce from mempool: %w", err)
 	}
 
-	// Get the nonce for this address from the datastore
-	addrNonceKey := datastore.KeyWithNamespaces([]string{dsKeyActorNonce, addr.String()})
+	// Get the next nonce for this address from the datastore
+	addrNonceKey := ms.dstoreKey(addr)
 	dsNonceBytes, err := ms.ds.Get(addrNonceKey)
 
 	switch {
 	case xerrors.Is(err, datastore.ErrNotFound):
 		// If a nonce for this address hasn't yet been created in the
 		// datastore, just use the nonce from the mempool
+		return nonce, nil
 
 	case err != nil:
 		return 0, xerrors.Errorf("failed to get nonce from datastore: %w", err)
 
 	default:
-		// There is a nonce in the datastore, so unmarshall and increment it
-		maj, val, err := cbg.CborReadHeader(bytes.NewReader(dsNonceBytes))
+		// There is a nonce in the datastore, so unmarshall it
+		maj, dsNonce, err := cbg.CborReadHeader(bytes.NewReader(dsNonceBytes))
 		if err != nil {
 			return 0, xerrors.Errorf("failed to parse nonce from datastore: %w", err)
 		}
@@ -99,26 +119,37 @@ func (ms *MessageSigner) nextNonce(addr address.Address) (uint64, error) {
 			return 0, xerrors.Errorf("bad cbor type parsing nonce from datastore")
 		}
 
-		dsNonce := val + 1
-
 		// The message pool nonce should be <= than the datastore nonce
 		if nonce <= dsNonce {
 			nonce = dsNonce
 		} else {
 			log.Warnf("mempool nonce was larger than datastore nonce (%d > %d)", nonce, dsNonce)
 		}
-	}
 
-	// Write the nonce for this address to the datastore
+		return nonce, nil
+	}
+}
+
+// saveNonce increments the nonce for this address and writes it to the
+// datastore
+func (ms *MessageSigner) saveNonce(addr address.Address, nonce uint64) error {
+	// Increment the nonce
+	nonce++
+
+	// Write the nonce to the datastore
+	addrNonceKey := ms.dstoreKey(addr)
 	buf := bytes.Buffer{}
-	_, err = buf.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, nonce))
+	_, err := buf.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, nonce))
 	if err != nil {
-		return 0, xerrors.Errorf("failed to marshall nonce: %w", err)
+		return xerrors.Errorf("failed to marshall nonce: %w", err)
 	}
 	err = ms.ds.Put(addrNonceKey, buf.Bytes())
 	if err != nil {
-		return 0, xerrors.Errorf("failed to write nonce to datastore: %w", err)
+		return xerrors.Errorf("failed to write nonce to datastore: %w", err)
 	}
+	return nil
+}
 
-	return nonce, nil
+func (ms *MessageSigner) dstoreKey(addr address.Address) datastore.Key {
+	return datastore.KeyWithNamespaces([]string{dsKeyActorNonce, addr.String()})
 }

chain/messagesigner/messagesigner_test.go

@@ -5,6 +5,8 @@ import (
 	"sync"
 	"testing"
 
+	"golang.org/x/xerrors"
+
 	"github.com/filecoin-project/lotus/chain/wallet"
 
 	"github.com/filecoin-project/go-state-types/crypto"
@@ -58,6 +60,7 @@ func TestMessageSignerSignMessage(t *testing.T) {
 		msg        *types.Message
 		mpoolNonce [1]uint64
 		expNonce   uint64
+		cbErr      error
 	}
 	tests := []struct {
 		name string
@@ -137,6 +140,37 @@ func TestMessageSignerSignMessage(t *testing.T) {
 			},
 			expNonce: 2,
 		}},
+	}, {
+		name: "recover from callback error",
+		msgs: []msgSpec{{
+			// No nonce yet in datastore
+			msg: &types.Message{
+				To:   to1,
+				From: from1,
+			},
+			expNonce: 0,
+		}, {
+			// Increment nonce
+			msg: &types.Message{
+				To:   to1,
+				From: from1,
+			},
+			expNonce: 1,
+		}, {
+			// Callback returns error
+			msg: &types.Message{
+				To:   to1,
+				From: from1,
+			},
+			cbErr: xerrors.Errorf("err"),
+		}, {
+			// Callback successful, should increment nonce in datastore
+			msg: &types.Message{
+				To:   to1,
+				From: from1,
+			},
+			expNonce: 2,
+		}},
 	}}
 	for _, tt := range tests {
 		tt := tt
@@ -149,9 +183,18 @@ func TestMessageSignerSignMessage(t *testing.T) {
 				if len(m.mpoolNonce) == 1 {
 					mpool.setNonce(m.msg.From, m.mpoolNonce[0])
 				}
-				smsg, err := ms.SignMessage(ctx, m.msg)
-				require.NoError(t, err)
-				require.Equal(t, m.expNonce, smsg.Message.Nonce)
+				merr := m.cbErr
+				smsg, err := ms.SignMessage(ctx, m.msg, func(message *types.SignedMessage) error {
+					return merr
+				})
+
+				if m.cbErr != nil {
+					require.Error(t, err)
+					require.Nil(t, smsg)
+				} else {
+					require.NoError(t, err)
+					require.Equal(t, m.expNonce, smsg.Message.Nonce)
+				}
 			}
 		})
 	}

chain/state/statetree.go

@@ -13,7 +13,7 @@ import (
 
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/lotus/chain/actors/builtin"
+	"github.com/filecoin-project/lotus/chain/actors"
 	init_ "github.com/filecoin-project/lotus/chain/actors/builtin/init"
 	cbg "github.com/whyrusleeping/cbor-gen"
 
@@ -26,7 +26,7 @@ var log = logging.Logger("statetree")
 // StateTree stores actors state by their ID.
 type StateTree struct {
 	root    adt.Map
-	version builtin.Version // TODO
+	version actors.Version // TODO
 	info    cid.Cid
 	Store   cbor.IpldStore
 
@@ -120,11 +120,17 @@ func (ss *stateSnaps) deleteActor(addr address.Address) {
 	ss.layers[len(ss.layers)-1].actors[addr] = streeOp{Delete: true}
 }
 
-func NewStateTree(cst cbor.IpldStore, version builtin.Version) (*StateTree, error) {
+func NewStateTree(cst cbor.IpldStore, version actors.Version) (*StateTree, error) {
 	var info cid.Cid
 	switch version {
-	case builtin.Version0:
+	case actors.Version0:
 		// info is undefined
+	case actors.Version2:
+		var err error
+		info, err = cst.Put(context.TODO(), new(types.StateInfo))
+		if err != nil {
+			return nil, err
+		}
 	default:
 		return nil, xerrors.Errorf("unsupported state tree version: %d", version)
 	}
@@ -148,30 +154,28 @@ func LoadStateTree(cst cbor.IpldStore, c cid.Cid) (*StateTree, error) {
 	if err := cst.Get(context.TODO(), c, &root); err != nil {
 		// We failed to decode as the new version, must be an old version.
 		root.Actors = c
-		root.Version = builtin.Version0
-	}
-
-	// If that fails, load as an old-style state-tree (direct hampt, version 0.
-	nd, err := adt.AsMap(adt.WrapStore(context.TODO(), cst), root.Actors, builtin.Version(root.Version))
-	if err != nil {
-		log.Errorf("loading hamt node %s failed: %s", c, err)
-		return nil, err
+		root.Version = actors.Version0
 	}
 
 	switch root.Version {
-	case builtin.Version0:
-		// supported
+	case actors.Version0, actors.Version2:
+		// Load the actual state-tree HAMT.
+		nd, err := adt.AsMap(adt.WrapStore(context.TODO(), cst), root.Actors, actors.Version(root.Version))
+		if err != nil {
+			log.Errorf("loading hamt node %s failed: %s", c, err)
+			return nil, err
+		}
+
+		return &StateTree{
+			root:    nd,
+			info:    root.Info,
+			version: actors.Version(root.Version),
+			Store:   cst,
+			snaps:   newStateSnaps(),
+		}, nil
 	default:
 		return nil, xerrors.Errorf("unsupported state tree version: %d", root.Version)
 	}
-
-	return &StateTree{
-		root:    nd,
-		info:    root.Info,
-		version: builtin.Version(root.Version),
-		Store:   cst,
-		snaps:   newStateSnaps(),
-	}, nil
 }
 
 func (st *StateTree) SetActor(addr address.Address, act *types.Actor) error {
@@ -305,7 +309,7 @@ func (st *StateTree) Flush(ctx context.Context) (cid.Cid, error) {
 		return cid.Undef, xerrors.Errorf("failed to flush state-tree hamt: %w", err)
 	}
 	// If we're version 0, return a raw tree.
-	if st.version == builtin.Version0 {
+	if st.version == actors.Version0 {
 		return root, nil
 	}
 	// Otherwise, return a versioned tree.
@@ -396,7 +400,7 @@ func (st *StateTree) ForEach(f func(address.Address, *types.Actor) error) error
 }
 
 // Version returns the version of the StateTree data structure in use.
-func (st *StateTree) Version() builtin.Version {
+func (st *StateTree) Version() actors.Version {
 	return st.version
 }
 

chain/state/statetree_test.go

@@ -9,16 +9,17 @@ import (
 	cbor "github.com/ipfs/go-ipld-cbor"
 
 	address "github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/network"
 	"github.com/filecoin-project/specs-actors/actors/builtin"
 
 	"github.com/filecoin-project/lotus/build"
-	builtin2 "github.com/filecoin-project/lotus/chain/actors/builtin"
+	"github.com/filecoin-project/lotus/chain/actors"
 	"github.com/filecoin-project/lotus/chain/types"
 )
 
 func BenchmarkStateTreeSet(b *testing.B) {
 	cst := cbor.NewMemCborStore()
-	st, err := NewStateTree(cst, builtin2.VersionForNetwork(build.NewestNetworkVersion))
+	st, err := NewStateTree(cst, actors.VersionForNetwork(build.NewestNetworkVersion))
 	if err != nil {
 		b.Fatal(err)
 	}
@@ -45,7 +46,7 @@ func BenchmarkStateTreeSet(b *testing.B) {
 
 func BenchmarkStateTreeSetFlush(b *testing.B) {
 	cst := cbor.NewMemCborStore()
-	st, err := NewStateTree(cst, builtin2.VersionForNetwork(build.NewestNetworkVersion))
+	st, err := NewStateTree(cst, actors.VersionForNetwork(build.NewestNetworkVersion))
 	if err != nil {
 		b.Fatal(err)
 	}
@@ -75,7 +76,7 @@ func BenchmarkStateTreeSetFlush(b *testing.B) {
 
 func BenchmarkStateTree10kGetActor(b *testing.B) {
 	cst := cbor.NewMemCborStore()
-	st, err := NewStateTree(cst, builtin2.VersionForNetwork(build.NewestNetworkVersion))
+	st, err := NewStateTree(cst, actors.VersionForNetwork(build.NewestNetworkVersion))
 	if err != nil {
 		b.Fatal(err)
 	}
@@ -117,7 +118,7 @@ func BenchmarkStateTree10kGetActor(b *testing.B) {
 
 func TestSetCache(t *testing.T) {
 	cst := cbor.NewMemCborStore()
-	st, err := NewStateTree(cst, builtin2.VersionForNetwork(build.NewestNetworkVersion))
+	st, err := NewStateTree(cst, actors.VersionForNetwork(build.NewestNetworkVersion))
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -154,7 +155,7 @@ func TestSetCache(t *testing.T) {
 func TestSnapshots(t *testing.T) {
 	ctx := context.Background()
 	cst := cbor.NewMemCborStore()
-	st, err := NewStateTree(cst, builtin2.VersionForNetwork(build.NewestNetworkVersion))
+	st, err := NewStateTree(cst, actors.VersionForNetwork(build.NewestNetworkVersion))
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -237,7 +238,8 @@ func assertNotHas(t *testing.T, st *StateTree, addr address.Address) {
 
 func TestStateTreeConsistency(t *testing.T) {
 	cst := cbor.NewMemCborStore()
-	st, err := NewStateTree(cst, builtin2.VersionForNetwork(build.NewestNetworkVersion))
+	// TODO: ActorUpgrade: this test tests pre actors v2
+	st, err := NewStateTree(cst, actors.VersionForNetwork(network.Version3))
 	if err != nil {
 		t.Fatal(err)
 	}

chain/stmgr/call.go

@@ -5,7 +5,6 @@ import (
 	"fmt"
 
 	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/crypto"
 	"github.com/ipfs/go-cid"
 	"go.opencensus.io/trace"
@@ -18,14 +17,26 @@ import (
 	"github.com/filecoin-project/lotus/chain/vm"
 )
 
-func (sm *StateManager) CallRaw(ctx context.Context, msg *types.Message, bstate cid.Cid, r vm.Rand, bheight abi.ChainEpoch) (*api.InvocResult, error) {
-	ctx, span := trace.StartSpan(ctx, "statemanager.CallRaw")
+func (sm *StateManager) Call(ctx context.Context, msg *types.Message, ts *types.TipSet) (*api.InvocResult, error) {
+	ctx, span := trace.StartSpan(ctx, "statemanager.Call")
 	defer span.End()
 
+	if ts == nil {
+		ts = sm.cs.GetHeaviestTipSet()
+	}
+
+	bstate := ts.ParentState()
+	bheight := ts.Height()
+
+	bstate, err := sm.handleStateForks(ctx, bstate, bheight-1, nil, ts)
+	if err != nil {
+		return nil, fmt.Errorf("failed to handle fork: %w", err)
+	}
+
 	vmopt := &vm.VMOpts{
 		StateBase:      bstate,
 		Epoch:          bheight,
-		Rand:           r,
+		Rand:           store.NewChainRand(sm.cs, ts.Cids()),
 		Bstore:         sm.cs.Blockstore(),
 		Syscalls:       sm.cs.VMSys(),
 		CircSupplyCalc: sm.GetCirculatingSupply,
@@ -89,18 +100,6 @@ func (sm *StateManager) CallRaw(ctx context.Context, msg *types.Message, bstate
 
 }
 
-func (sm *StateManager) Call(ctx context.Context, msg *types.Message, ts *types.TipSet) (*api.InvocResult, error) {
-	if ts == nil {
-		ts = sm.cs.GetHeaviestTipSet()
-	}
-
-	state := ts.ParentState()
-
-	r := store.NewChainRand(sm.cs, ts.Cids())
-
-	return sm.CallRaw(ctx, msg, state, r, ts.Height())
-}
-
 func (sm *StateManager) CallWithGas(ctx context.Context, msg *types.Message, priorMsgs []types.ChainMsg, ts *types.TipSet) (*api.InvocResult, error) {
 	ctx, span := trace.StartSpan(ctx, "statemanager.CallWithGas")
 	defer span.End()
@@ -114,6 +113,11 @@ func (sm *StateManager) CallWithGas(ctx context.Context, msg *types.Message, pri
 		return nil, xerrors.Errorf("computing tipset state: %w", err)
 	}
 
+	state, err = sm.handleStateForks(ctx, state, ts.Height(), nil, ts)
+	if err != nil {
+		return nil, fmt.Errorf("failed to handle fork: %w", err)
+	}
+
 	r := store.NewChainRand(sm.cs, ts.Cids())
 
 	if span.IsRecordingEvents() {

chain/stmgr/forks.go

@@ -6,43 +6,108 @@ import (
 	"encoding/binary"
 	"math"
 
-	multisig0 "github.com/filecoin-project/specs-actors/actors/builtin/multisig"
-
-	"github.com/filecoin-project/lotus/chain/actors/builtin/multisig"
-
-	"github.com/filecoin-project/lotus/chain/state"
-
-	"github.com/filecoin-project/specs-actors/actors/migration/nv3"
-
-	"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/go-state-types/network"
+	"github.com/ipfs/go-cid"
+	cbor "github.com/ipfs/go-ipld-cbor"
+	"golang.org/x/xerrors"
 
 	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
-	init0 "github.com/filecoin-project/specs-actors/actors/builtin/init"
 	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
+	multisig0 "github.com/filecoin-project/specs-actors/actors/builtin/multisig"
 	power0 "github.com/filecoin-project/specs-actors/actors/builtin/power"
 	adt0 "github.com/filecoin-project/specs-actors/actors/util/adt"
 
+	"github.com/filecoin-project/specs-actors/actors/migration/nv3"
+	m2 "github.com/filecoin-project/specs-actors/v2/actors/migration"
+	states2 "github.com/filecoin-project/specs-actors/v2/actors/states"
+
 	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/actors"
+	"github.com/filecoin-project/lotus/chain/actors/adt"
+	init_ "github.com/filecoin-project/lotus/chain/actors/builtin/init"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/multisig"
+	"github.com/filecoin-project/lotus/chain/state"
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/chain/vm"
-	cbor "github.com/ipfs/go-ipld-cbor"
-	"golang.org/x/xerrors"
 )
 
-var ForksAtHeight = map[abi.ChainEpoch]func(context.Context, *StateManager, ExecCallback, cid.Cid, *types.TipSet) (cid.Cid, error){
-	build.UpgradeBreezeHeight:   UpgradeFaucetBurnRecovery,
-	build.UpgradeIgnitionHeight: UpgradeIgnition,
-	build.UpgradeLiftoffHeight:  UpgradeLiftoff,
+type UpgradeFunc func(context.Context, *StateManager, ExecCallback, cid.Cid, *types.TipSet) (cid.Cid, error)
+
+type Upgrade struct {
+	Height    abi.ChainEpoch
+	Network   network.Version
+	Migration UpgradeFunc
+}
+
+type UpgradeSchedule []Upgrade
+
+func DefaultUpgradeSchedule() UpgradeSchedule {
+	var us UpgradeSchedule
+
+	for _, u := range []Upgrade{{
+		Height:    build.UpgradeBreezeHeight,
+		Network:   network.Version1,
+		Migration: UpgradeFaucetBurnRecovery,
+	}, {
+		Height:    build.UpgradeSmokeHeight,
+		Network:   network.Version2,
+		Migration: nil,
+	}, {
+		Height:    build.UpgradeIgnitionHeight,
+		Network:   network.Version3,
+		Migration: UpgradeIgnition,
+	}, {
+		Height:    build.UpgradeActorsV2Height,
+		Network:   network.Version4,
+		Migration: UpgradeActorsV2,
+	}, {
+		Height:    build.UpgradeLiftoffHeight,
+		Network:   network.Version4,
+		Migration: UpgradeLiftoff,
+	}} {
+		if u.Height < 0 {
+			// upgrade disabled
+			continue
+		}
+		us = append(us, u)
+	}
+	return us
+}
+
+func (us UpgradeSchedule) Validate() error {
+	// Make sure we're not trying to upgrade to version 0.
+	for _, u := range us {
+		if u.Network <= 0 {
+			return xerrors.Errorf("cannot upgrade to version <= 0: %d", u.Network)
+		}
+	}
+
+	// Make sure all the upgrades make sense.
+	for i := 1; i < len(us); i++ {
+		prev := &us[i-1]
+		curr := &us[i]
+		if !(prev.Network <= curr.Network) {
+			return xerrors.Errorf("cannot downgrade from version %d to version %d", prev.Network, curr.Network)
+		}
+		// Make sure the heights make sense.
+		if prev.Height < 0 {
+			// Previous upgrade was disabled.
+			continue
+		}
+		if !(prev.Height < curr.Height) {
+			return xerrors.Errorf("upgrade heights must be strictly increasing: upgrade %d was at height %d, followed by upgrade %d at height %d", i-1, prev.Height, i, curr.Height)
+		}
+	}
+	return nil
 }
 
 func (sm *StateManager) handleStateForks(ctx context.Context, root cid.Cid, height abi.ChainEpoch, cb ExecCallback, ts *types.TipSet) (cid.Cid, error) {
 	retCid := root
 	var err error
-	f, ok := ForksAtHeight[height]
+	f, ok := sm.stateMigrations[height]
 	if ok {
 		retCid, err = f(ctx, sm, cb, root, ts)
 		if err != nil {
@@ -370,7 +435,13 @@ func UpgradeFaucetBurnRecovery(ctx context.Context, sm *StateManager, cb ExecCal
 func UpgradeIgnition(ctx context.Context, sm *StateManager, cb ExecCallback, root cid.Cid, ts *types.TipSet) (cid.Cid, error) {
 	store := sm.cs.Store(ctx)
 
-	nst, err := nv3.MigrateStateTree(ctx, store, root, build.UpgradeIgnitionHeight)
+	epoch := ts.Height() - 1
+
+	if build.UpgradeLiftoffHeight <= epoch {
+		return cid.Undef, xerrors.Errorf("liftoff height must be beyond ignition height")
+	}
+
+	nst, err := nv3.MigrateStateTree(ctx, store, root, epoch)
 	if err != nil {
 		return cid.Undef, xerrors.Errorf("migrating actors state: %w", err)
 	}
@@ -395,7 +466,7 @@ func UpgradeIgnition(ctx context.Context, sm *StateManager, cb ExecCallback, roo
 		return cid.Undef, xerrors.Errorf("second split address: %w", err)
 	}
 
-	err = resetGenesisMsigs(ctx, sm, store, tree)
+	err = resetGenesisMsigs(ctx, sm, store, tree, build.UpgradeLiftoffHeight)
 	if err != nil {
 		return cid.Undef, xerrors.Errorf("resetting genesis msig start epochs: %w", err)
 	}
@@ -410,7 +481,7 @@ func UpgradeIgnition(ctx context.Context, sm *StateManager, cb ExecCallback, roo
 		return cid.Undef, xerrors.Errorf("splitting second msig: %w", err)
 	}
 
-	err = nv3.CheckStateTree(ctx, store, nst, build.UpgradeIgnitionHeight, builtin0.TotalFilecoin)
+	err = nv3.CheckStateTree(ctx, store, nst, epoch, builtin0.TotalFilecoin)
 	if err != nil {
 		return cid.Undef, xerrors.Errorf("sanity check after ignition upgrade failed: %w", err)
 	}
@@ -418,6 +489,58 @@ func UpgradeIgnition(ctx context.Context, sm *StateManager, cb ExecCallback, roo
 	return tree.Flush(ctx)
 }
 
+func UpgradeActorsV2(ctx context.Context, sm *StateManager, cb ExecCallback, root cid.Cid, ts *types.TipSet) (cid.Cid, error) {
+	store := sm.cs.Store(ctx)
+
+	epoch := ts.Height() - 1
+
+	info, err := store.Put(ctx, new(types.StateInfo))
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("failed to create new state info for actors v2: %w", err)
+	}
+
+	newHamtRoot, err := m2.MigrateStateTree(ctx, store, root, epoch, m2.DefaultConfig())
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("upgrading to actors v2: %w", err)
+	}
+
+	newStateTree, err := states2.LoadTree(store, newHamtRoot)
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("failed to load new state tree: %w", err)
+	}
+
+	// Check all state-tree invariants.
+	if msgs, err := states2.CheckStateInvariants(newStateTree, types.TotalFilecoinInt); err != nil {
+		return cid.Undef, xerrors.Errorf("failed to check new state tree: %w", err)
+	} else if !msgs.IsEmpty() {
+		// This error is going to be really nasty.
+		return cid.Undef, xerrors.Errorf("network upgrade failed: %v", msgs.Messages())
+	}
+
+	newRoot, err := store.Put(ctx, &types.StateRoot{
+		// TODO: ActorUpgrade: should be state-tree specific, not just the actors version.
+		Version: actors.Version2,
+		Actors:  newHamtRoot,
+		Info:    info,
+	})
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("failed to persist new state root: %w", err)
+	}
+
+	// perform some basic sanity checks to make sure everything still works.
+	if newSm, err := state.LoadStateTree(store, newRoot); err != nil {
+		return cid.Undef, xerrors.Errorf("state tree sanity load failed: %w", err)
+	} else if newRoot2, err := newSm.Flush(ctx); err != nil {
+		return cid.Undef, xerrors.Errorf("state tree sanity flush failed: %w", err)
+	} else if newRoot2 != newRoot {
+		return cid.Undef, xerrors.Errorf("state-root mismatch: %s != %s", newRoot, newRoot2)
+	} else if _, err := newSm.GetActor(builtin0.InitActorAddr); err != nil {
+		return cid.Undef, xerrors.Errorf("failed to load init actor after upgrade: %w", err)
+	}
+
+	return newRoot, nil
+}
+
 func UpgradeLiftoff(ctx context.Context, sm *StateManager, cb ExecCallback, root cid.Cid, ts *types.TipSet) (cid.Cid, error) {
 	tree, err := sm.StateTree(root)
 	if err != nil {
@@ -432,20 +555,22 @@ func UpgradeLiftoff(ctx context.Context, sm *StateManager, cb ExecCallback, root
 	return tree.Flush(ctx)
 }
 
-func setNetworkName(ctx context.Context, store adt0.Store, tree *state.StateTree, name string) error {
+func setNetworkName(ctx context.Context, store adt.Store, tree *state.StateTree, name string) error {
 	ia, err := tree.GetActor(builtin0.InitActorAddr)
 	if err != nil {
 		return xerrors.Errorf("getting init actor: %w", err)
 	}
 
-	var initState init0.State
-	if err := store.Get(ctx, ia.Head, &initState); err != nil {
+	initState, err := init_.Load(store, ia)
+	if err != nil {
 		return xerrors.Errorf("reading init state: %w", err)
 	}
 
-	initState.NetworkName = name
+	if err := initState.SetNetworkName(name); err != nil {
+		return xerrors.Errorf("setting network name: %w", err)
+	}
 
-	ia.Head, err = store.Put(ctx, &initState)
+	ia.Head, err = store.Put(ctx, initState)
 	if err != nil {
 		return xerrors.Errorf("writing new init state: %w", err)
 	}
@@ -574,7 +699,7 @@ func makeKeyAddr(splitAddr address.Address, count uint64) (address.Address, erro
 	return addr, nil
 }
 
-func resetGenesisMsigs(ctx context.Context, sm *StateManager, store adt0.Store, tree *state.StateTree) error {
+func resetGenesisMsigs(ctx context.Context, sm *StateManager, store adt0.Store, tree *state.StateTree, startEpoch abi.ChainEpoch) error {
 	gb, err := sm.cs.GetGenesis()
 	if err != nil {
 		return xerrors.Errorf("getting genesis block: %w", err)
@@ -603,7 +728,7 @@ func resetGenesisMsigs(ctx context.Context, sm *StateManager, store adt0.Store,
 				return xerrors.Errorf("reading multisig state: %w", err)
 			}
 
-			currState.StartEpoch = build.UpgradeLiftoffHeight
+			currState.StartEpoch = startEpoch
 
 			currActor.Head, err = store.Put(ctx, &currState)
 			if err != nil {

chain/stmgr/forks_test.go

@@ -8,6 +8,7 @@ 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/filecoin-project/specs-actors/actors/builtin"
 	init_ "github.com/filecoin-project/specs-actors/actors/builtin/init"
 	"github.com/filecoin-project/specs-actors/actors/runtime"
@@ -18,7 +19,6 @@ import (
 	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/stmgr"
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/chain/vm"
@@ -26,7 +26,7 @@ import (
 	_ "github.com/filecoin-project/lotus/lib/sigs/secp"
 
 	"github.com/ipfs/go-cid"
-	cbor "github.com/ipfs/go-ipld-cbor"
+	ipldcbor "github.com/ipfs/go-ipld-cbor"
 	logging "github.com/ipfs/go-log"
 	cbg "github.com/whyrusleeping/cbor-gen"
 )
@@ -42,6 +42,10 @@ 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
 }
@@ -62,7 +66,7 @@ func (tas *testActorState) UnmarshalCBOR(r io.Reader) error {
 	return nil
 }
 
-func (ta *testActor) Exports() []interface{} {
+func (ta testActor) Exports() []interface{} {
 	return []interface{}{
 		1: ta.Constructor,
 		2: ta.TestMethod,
@@ -105,51 +109,57 @@ func TestForkHeightTriggers(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	sm := NewStateManager(cg.ChainStore())
-
-	inv := vm.NewInvoker()
-
 	// predicting the address here... may break if other assumptions change
 	taddr, err := address.NewIDAddress(1002)
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	stmgr.ForksAtHeight[testForkHeight] = func(ctx context.Context, sm *StateManager, cb ExecCallback, root cid.Cid, ts *types.TipSet) (cid.Cid, error) {
-		cst := cbor.NewCborStore(sm.ChainStore().Blockstore())
+	sm, err := NewStateManagerWithUpgradeSchedule(
+		cg.ChainStore(), UpgradeSchedule{{
+			Network: 1,
+			Height:  testForkHeight,
+			Migration: func(ctx context.Context, sm *StateManager, cb ExecCallback,
+				root cid.Cid, 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)
-		}
+				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
-		}
+				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)
-		}
+				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
+				tas.HasUpgraded = 55
 
-		ns, err := cst.Put(ctx, &tas)
-		if err != nil {
-			return cid.Undef, err
-		}
+				ns, err := cst.Put(ctx, &tas)
+				if err != nil {
+					return cid.Undef, err
+				}
 
-		act.Head = ns
+				act.Head = ns
 
-		if err := st.SetActor(taddr, act); err != nil {
-			return cid.Undef, err
-		}
+				if err := st.SetActor(taddr, act); err != nil {
+					return cid.Undef, err
+				}
 
-		return st.Flush(ctx)
+				return st.Flush(ctx)
+			}}})
+	if err != nil {
+		t.Fatal(err)
 	}
 
-	inv.Register(builtin.PaymentChannelActorCodeID, &testActor{}, &testActorState{})
+	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 {
@@ -163,7 +173,7 @@ func TestForkHeightTriggers(t *testing.T) {
 
 	var msgs []*types.SignedMessage
 
-	enc, err := actors.SerializeParams(&init_.ExecParams{CodeCID: builtin.PaymentChannelActorCodeID})
+	enc, err := actors.SerializeParams(&init_.ExecParams{CodeCID: (testActor{}).Code()})
 	if err != nil {
 		t.Fatal(err)
 	}

chain/stmgr/stmgr.go

@@ -5,6 +5,8 @@ import (
 	"fmt"
 	"sync"
 
+	"github.com/filecoin-project/lotus/chain/actors/builtin"
+
 	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
 	msig0 "github.com/filecoin-project/specs-actors/actors/builtin/multisig"
 
@@ -24,7 +26,6 @@ import (
 	"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"
 	"github.com/filecoin-project/lotus/chain/actors/builtin/market"
 	"github.com/filecoin-project/lotus/chain/actors/builtin/multisig"
 	"github.com/filecoin-project/lotus/chain/actors/builtin/paych"
@@ -38,9 +39,21 @@ import (
 
 var log = logging.Logger("statemgr")
 
+type versionSpec struct {
+	networkVersion network.Version
+	atOrBelow      abi.ChainEpoch
+}
+
 type StateManager struct {
 	cs *store.ChainStore
 
+	// Determines the network version at any given epoch.
+	networkVersions []versionSpec
+	latestVersion   network.Version
+
+	// Maps chain epochs to upgrade functions.
+	stateMigrations map[abi.ChainEpoch]UpgradeFunc
+
 	stCache              map[string][]cid.Cid
 	compWait             map[string]chan struct{}
 	stlk                 sync.Mutex
@@ -51,12 +64,49 @@ type StateManager struct {
 }
 
 func NewStateManager(cs *store.ChainStore) *StateManager {
-	return &StateManager{
-		newVM:    vm.NewVM,
-		cs:       cs,
-		stCache:  make(map[string][]cid.Cid),
-		compWait: make(map[string]chan struct{}),
+	sm, err := NewStateManagerWithUpgradeSchedule(cs, DefaultUpgradeSchedule())
+	if err != nil {
+		panic(fmt.Sprintf("default upgrade schedule is invalid: %s", err))
 	}
+	return sm
+}
+
+func NewStateManagerWithUpgradeSchedule(cs *store.ChainStore, us UpgradeSchedule) (*StateManager, error) {
+	// If we have upgrades, make sure they're in-order and make sense.
+	if err := us.Validate(); err != nil {
+		return nil, err
+	}
+
+	stateMigrations := make(map[abi.ChainEpoch]UpgradeFunc, len(us))
+	var networkVersions []versionSpec
+	lastVersion := network.Version0
+	if len(us) > 0 {
+		// If we have any upgrades, process them and create a version
+		// schedule.
+		for _, upgrade := range us {
+			if upgrade.Migration != nil {
+				stateMigrations[upgrade.Height] = upgrade.Migration
+			}
+			networkVersions = append(networkVersions, versionSpec{
+				networkVersion: lastVersion,
+				atOrBelow:      upgrade.Height,
+			})
+			lastVersion = upgrade.Network
+		}
+	} else {
+		// Otherwise, go directly to the latest version.
+		lastVersion = build.NewestNetworkVersion
+	}
+
+	return &StateManager{
+		networkVersions: networkVersions,
+		latestVersion:   lastVersion,
+		stateMigrations: stateMigrations,
+		newVM:           vm.NewVM,
+		cs:              cs,
+		stCache:         make(map[string][]cid.Cid),
+		compWait:        make(map[string]chan struct{}),
+	}, nil
 }
 
 func cidsToKey(cids []cid.Cid) string {
@@ -209,6 +259,18 @@ func (sm *StateManager) ApplyBlocks(ctx context.Context, parentEpoch abi.ChainEp
 	}
 
 	for i := parentEpoch; i < epoch; i++ {
+		if i > parentEpoch {
+			// run cron for null rounds if any
+			if err := runCron(); err != nil {
+				return cid.Undef, cid.Undef, err
+			}
+
+			pstate, err = vmi.Flush(ctx)
+			if err != nil {
+				return cid.Undef, cid.Undef, xerrors.Errorf("flushing vm: %w", err)
+			}
+		}
+
 		// handle state forks
 		// XXX: The state tree
 		newState, err := sm.handleStateForks(ctx, pstate, i, cb, ts)
@@ -223,18 +285,6 @@ func (sm *StateManager) ApplyBlocks(ctx context.Context, parentEpoch abi.ChainEp
 			}
 		}
 
-		if i > parentEpoch {
-			// run cron for null rounds if any
-			if err := runCron(); err != nil {
-				return cid.Cid{}, cid.Cid{}, err
-			}
-
-			newState, err = vmi.Flush(ctx)
-			if err != nil {
-				return cid.Undef, cid.Undef, xerrors.Errorf("flushing vm: %w", err)
-			}
-		}
-
 		vmi.SetBlockHeight(i + 1)
 		pstate = newState
 	}
@@ -279,7 +329,7 @@ func (sm *StateManager) ApplyBlocks(ctx context.Context, parentEpoch abi.ChainEp
 
 		sysAct, actErr := vmi.StateTree().GetActor(builtin0.SystemActorAddr)
 		if actErr != nil {
-			return cid.Undef, cid.Undef, xerrors.Errorf("failed to get system actor: %w", err)
+			return cid.Undef, cid.Undef, xerrors.Errorf("failed to get system actor: %w", actErr)
 		}
 
 		rwMsg := &types.Message{
@@ -295,7 +345,7 @@ func (sm *StateManager) ApplyBlocks(ctx context.Context, parentEpoch abi.ChainEp
 		}
 		ret, actErr := vmi.ApplyImplicitMessage(ctx, rwMsg)
 		if actErr != nil {
-			return cid.Undef, cid.Undef, xerrors.Errorf("failed to apply reward message for miner %s: %w", b.Miner, err)
+			return cid.Undef, cid.Undef, xerrors.Errorf("failed to apply reward message for miner %s: %w", b.Miner, actErr)
 		}
 		if cb != nil {
 			if err := cb(rwMsg.Cid(), rwMsg, ret); err != nil {
@@ -313,7 +363,7 @@ func (sm *StateManager) ApplyBlocks(ctx context.Context, parentEpoch abi.ChainEp
 	}
 
 	// XXX: Is the height correct? Or should it be epoch-1?
-	rectarr, err := adt.NewArray(sm.cs.Store(ctx), builtin.VersionForNetwork(sm.GetNtwkVersion(ctx, epoch)))
+	rectarr, err := adt.NewArray(sm.cs.Store(ctx), actors.VersionForNetwork(sm.GetNtwkVersion(ctx, epoch)))
 	if err != nil {
 		return cid.Undef, cid.Undef, xerrors.Errorf("failed to create receipts amt: %w", err)
 	}
@@ -859,7 +909,7 @@ func (sm *StateManager) setupGenesisActors(ctx context.Context) error {
 
 	totalsByEpoch := make(map[abi.ChainEpoch]abi.TokenAmount)
 	err = sTree.ForEach(func(kaddr address.Address, act *types.Actor) error {
-		if act.IsMultisigActor() {
+		if builtin.IsMultisigActor(act.Code) {
 			s, err := multisig.Load(sm.cs.Store(ctx), act)
 			if err != nil {
 				return err
@@ -891,7 +941,7 @@ func (sm *StateManager) setupGenesisActors(ctx context.Context) error {
 				totalsByEpoch[ud] = ib
 			}
 
-		} else if act.IsAccountActor() {
+		} else if builtin.IsAccountActor(act.Code) {
 			// should exclude burnt funds actor and "remainder account actor"
 			// should only ever be "faucet" accounts in testnets
 			if kaddr == builtin0.BurntFundsActorAddr {
@@ -1121,14 +1171,27 @@ func (sm *StateManager) GetFilVested(ctx context.Context, height abi.ChainEpoch,
 		}
 	}
 
-	// continue to use preIgnitionGenInfos, nothing changed at the Ignition epoch
-	vf = big.Add(vf, sm.preIgnitionGenInfos.genesisPledge)
-	// continue to use preIgnitionGenInfos, nothing changed at the Ignition epoch
-	vf = big.Add(vf, sm.preIgnitionGenInfos.genesisMarketFunds)
+	// After UpgradeActorsV2Height these funds are accounted for in GetFilReserveDisbursed
+	if height <= build.UpgradeActorsV2Height {
+		// continue to use preIgnitionGenInfos, nothing changed at the Ignition epoch
+		vf = big.Add(vf, sm.preIgnitionGenInfos.genesisPledge)
+		// continue to use preIgnitionGenInfos, nothing changed at the Ignition epoch
+		vf = big.Add(vf, sm.preIgnitionGenInfos.genesisMarketFunds)
+	}
 
 	return vf, nil
 }
 
+func GetFilReserveDisbursed(ctx context.Context, st *state.StateTree) (abi.TokenAmount, error) {
+	ract, err := st.GetActor(builtin.ReserveAddress)
+	if err != nil {
+		return big.Zero(), xerrors.Errorf("failed to get reserve actor: %w", err)
+	}
+
+	// If money enters the reserve actor, this could lead to a negative term
+	return big.Sub(big.NewFromGo(build.InitialFilReserved), ract.Balance), nil
+}
+
 func GetFilMined(ctx context.Context, st *state.StateTree) (abi.TokenAmount, error) {
 	ractor, err := st.GetActor(reward.Address)
 	if err != nil {
@@ -1216,6 +1279,14 @@ func (sm *StateManager) GetCirculatingSupplyDetailed(ctx context.Context, height
 		return api.CirculatingSupply{}, xerrors.Errorf("failed to calculate filVested: %w", err)
 	}
 
+	filReserveDisbursed := big.Zero()
+	if height > build.UpgradeActorsV2Height {
+		filReserveDisbursed, err = GetFilReserveDisbursed(ctx, st)
+		if err != nil {
+			return api.CirculatingSupply{}, xerrors.Errorf("failed to calculate filReserveDisbursed: %w", err)
+		}
+	}
+
 	filMined, err := GetFilMined(ctx, st)
 	if err != nil {
 		return api.CirculatingSupply{}, xerrors.Errorf("failed to calculate filMined: %w", err)
@@ -1232,6 +1303,7 @@ func (sm *StateManager) GetCirculatingSupplyDetailed(ctx context.Context, height
 	}
 
 	ret := types.BigAdd(filVested, filMined)
+	ret = types.BigAdd(ret, filReserveDisbursed)
 	ret = types.BigSub(ret, filBurnt)
 	ret = types.BigSub(ret, filLocked)
 
@@ -1258,25 +1330,14 @@ func (sm *StateManager) GetCirculatingSupply(ctx context.Context, height abi.Cha
 }
 
 func (sm *StateManager) GetNtwkVersion(ctx context.Context, height abi.ChainEpoch) network.Version {
-	// TODO: move hard fork epoch checks to a schedule defined in build/
-
-	if build.UseNewestNetwork() {
-		return build.NewestNetworkVersion
+	// The epochs here are the _last_ epoch for every version, or -1 if the
+	// version is disabled.
+	for _, spec := range sm.networkVersions {
+		if height <= spec.atOrBelow {
+			return spec.networkVersion
+		}
 	}
-
-	if height <= build.UpgradeBreezeHeight {
-		return network.Version0
-	}
-
-	if height <= build.UpgradeSmokeHeight {
-		return network.Version1
-	}
-
-	if height <= build.UpgradeIgnitionHeight {
-		return network.Version2
-	}
-
-	return build.NewestNetworkVersion
+	return sm.latestVersion
 }
 
 func (sm *StateManager) GetPaychState(ctx context.Context, addr address.Address, ts *types.TipSet) (*types.Actor, paych.State, error) {

chain/stmgr/utils.go

@@ -9,6 +9,11 @@ import (
 	"runtime"
 	"strings"
 
+	"github.com/filecoin-project/go-state-types/big"
+
+	"github.com/filecoin-project/go-state-types/network"
+	"github.com/filecoin-project/lotus/chain/actors/policy"
+
 	cid "github.com/ipfs/go-cid"
 	cbg "github.com/whyrusleeping/cbor-gen"
 	"golang.org/x/xerrors"
@@ -17,22 +22,14 @@ import (
 	"github.com/filecoin-project/go-bitfield"
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/crypto"
+	"github.com/filecoin-project/go-state-types/rt"
 
 	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
-	account0 "github.com/filecoin-project/specs-actors/actors/builtin/account"
-	cron0 "github.com/filecoin-project/specs-actors/actors/builtin/cron"
-	init0 "github.com/filecoin-project/specs-actors/actors/builtin/init"
-	market0 "github.com/filecoin-project/specs-actors/actors/builtin/market"
-	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
-	msig0 "github.com/filecoin-project/specs-actors/actors/builtin/multisig"
-	paych0 "github.com/filecoin-project/specs-actors/actors/builtin/paych"
-	power0 "github.com/filecoin-project/specs-actors/actors/builtin/power"
-	reward0 "github.com/filecoin-project/specs-actors/actors/builtin/reward"
-	verifreg0 "github.com/filecoin-project/specs-actors/actors/builtin/verifreg"
+	exported0 "github.com/filecoin-project/specs-actors/actors/builtin/exported"
 	proof0 "github.com/filecoin-project/specs-actors/actors/runtime/proof"
+	exported2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/exported"
 
 	"github.com/filecoin-project/lotus/api"
-	"github.com/filecoin-project/lotus/build"
 	init_ "github.com/filecoin-project/lotus/chain/actors/builtin/init"
 	"github.com/filecoin-project/lotus/chain/actors/builtin/market"
 	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
@@ -416,8 +413,9 @@ func ComputeState(ctx context.Context, sm *StateManager, height abi.ChainEpoch,
 
 func GetLookbackTipSetForRound(ctx context.Context, sm *StateManager, ts *types.TipSet, round abi.ChainEpoch) (*types.TipSet, error) {
 	var lbr abi.ChainEpoch
-	if round > build.WinningPoStSectorSetLookback {
-		lbr = round - build.WinningPoStSectorSetLookback
+	lb := policy.GetWinningPoStSectorSetLookback(sm.GetNtwkVersion(ctx, round))
+	if round > lb {
+		lbr = round - lb
 	}
 
 	// more null blocks than our lookback
@@ -497,7 +495,7 @@ func MinerGetBaseInfo(ctx context.Context, sm *StateManager, bcs beacon.Schedule
 		return nil, nil
 	}
 
-	mpow, tpow, hmp, err := GetPowerRaw(ctx, sm, lbst, maddr)
+	mpow, tpow, _, err := GetPowerRaw(ctx, sm, lbst, maddr)
 	if err != nil {
 		return nil, xerrors.Errorf("failed to get power: %w", err)
 	}
@@ -512,15 +510,21 @@ func MinerGetBaseInfo(ctx context.Context, sm *StateManager, bcs beacon.Schedule
 		return nil, xerrors.Errorf("resolving worker address: %w", err)
 	}
 
+	// TODO: Not ideal performance...This method reloads miner and power state (already looked up here and in GetPowerRaw)
+	eligible, err := MinerEligibleToMine(ctx, sm, maddr, ts, lbts)
+	if err != nil {
+		return nil, xerrors.Errorf("determining miner eligibility: %w", err)
+	}
+
 	return &api.MiningBaseInfo{
-		MinerPower:      mpow.QualityAdjPower,
-		NetworkPower:    tpow.QualityAdjPower,
-		Sectors:         sectors,
-		WorkerKey:       worker,
-		SectorSize:      info.SectorSize,
-		PrevBeaconEntry: *prev,
-		BeaconEntries:   entries,
-		HasMinPower:     hmp,
+		MinerPower:        mpow.QualityAdjPower,
+		NetworkPower:      tpow.QualityAdjPower,
+		Sectors:           sectors,
+		WorkerKey:         worker,
+		SectorSize:        info.SectorSize,
+		PrevBeaconEntry:   *prev,
+		BeaconEntries:     entries,
+		EligibleForMining: eligible,
 	}, nil
 }
 
@@ -534,42 +538,23 @@ type MethodMeta struct {
 var MethodsMap = map[cid.Cid]map[abi.MethodNum]MethodMeta{}
 
 func init() {
-	cidToMethods := map[cid.Cid][2]interface{}{
-		// builtin.SystemActorCodeID:        {builtin.MethodsSystem, system.Actor{} }- apparently it doesn't have methods
-		builtin0.InitActorCodeID:             {builtin0.MethodsInit, init0.Actor{}},
-		builtin0.CronActorCodeID:             {builtin0.MethodsCron, cron0.Actor{}},
-		builtin0.AccountActorCodeID:          {builtin0.MethodsAccount, account0.Actor{}},
-		builtin0.StoragePowerActorCodeID:     {builtin0.MethodsPower, power0.Actor{}},
-		builtin0.StorageMinerActorCodeID:     {builtin0.MethodsMiner, miner0.Actor{}},
-		builtin0.StorageMarketActorCodeID:    {builtin0.MethodsMarket, market0.Actor{}},
-		builtin0.PaymentChannelActorCodeID:   {builtin0.MethodsPaych, paych0.Actor{}},
-		builtin0.MultisigActorCodeID:         {builtin0.MethodsMultisig, msig0.Actor{}},
-		builtin0.RewardActorCodeID:           {builtin0.MethodsReward, reward0.Actor{}},
-		builtin0.VerifiedRegistryActorCodeID: {builtin0.MethodsVerifiedRegistry, verifreg0.Actor{}},
-	}
+	// TODO: combine with the runtime actor registry.
+	var actors []rt.VMActor
+	actors = append(actors, exported0.BuiltinActors()...)
+	actors = append(actors, exported2.BuiltinActors()...)
 
-	for c, m := range cidToMethods {
-		exports := m[1].(vm.Invokee).Exports()
+	for _, actor := range actors {
+		exports := actor.Exports()
 		methods := make(map[abi.MethodNum]MethodMeta, len(exports))
 
 		// Explicitly add send, it's special.
+		// Note that builtin2.MethodSend = builtin0.MethodSend = 0.
 		methods[builtin0.MethodSend] = MethodMeta{
 			Name:   "Send",
 			Params: reflect.TypeOf(new(abi.EmptyValue)),
 			Ret:    reflect.TypeOf(new(abi.EmptyValue)),
 		}
 
-		// Learn method names from the builtin.Methods* structs.
-		rv := reflect.ValueOf(m[0])
-		rt := rv.Type()
-		nf := rt.NumField()
-		methodToName := make([]string, len(exports))
-		for i := 0; i < nf; i++ {
-			name := rt.Field(i).Name
-			number := rv.Field(i).Interface().(abi.MethodNum)
-			methodToName[number] = name
-		}
-
 		// Iterate over exported methods. Some of these _may_ be nil and
 		// must be skipped.
 		for number, export := range exports {
@@ -580,22 +565,19 @@ func init() {
 			ev := reflect.ValueOf(export)
 			et := ev.Type()
 
-			// Make sure the method name is correct.
-			// This is just a nice sanity check.
+			// Extract the method names using reflection. These
+			// method names always match the field names in the
+			// `builtin.Method*` structs (tested in the specs-actors
+			// tests).
 			fnName := runtime.FuncForPC(ev.Pointer()).Name()
 			fnName = strings.TrimSuffix(fnName[strings.LastIndexByte(fnName, '.')+1:], "-fm")
-			mName := methodToName[number]
-			if mName != fnName {
-				panic(fmt.Sprintf(
-					"actor method name is %s but exported method name is %s",
-					fnName, mName,
-				))
-			}
 
 			switch abi.MethodNum(number) {
 			case builtin0.MethodSend:
+				// Note that builtin2.MethodSend = builtin0.MethodSend = 0.
 				panic("method 0 is reserved for Send")
 			case builtin0.MethodConstructor:
+				// Note that builtin2.MethodConstructor = builtin0.MethodConstructor = 1.
 				if fnName != "Constructor" {
 					panic("method 1 is reserved for Constructor")
 				}
@@ -607,7 +589,7 @@ func init() {
 				Ret:    et.Out(0),
 			}
 		}
-		MethodsMap[c] = methods
+		MethodsMap[actor.Code()] = methods
 	}
 }
 
@@ -624,7 +606,7 @@ func GetReturnType(ctx context.Context, sm *StateManager, to address.Address, me
 	return reflect.New(m.Ret.Elem()).Interface().(cbg.CBORUnmarshaler), nil
 }
 
-func MinerHasMinPower(ctx context.Context, sm *StateManager, addr address.Address, ts *types.TipSet) (bool, error) {
+func minerHasMinPower(ctx context.Context, sm *StateManager, addr address.Address, ts *types.TipSet) (bool, error) {
 	pact, err := sm.LoadActor(ctx, power.Address, ts)
 	if err != nil {
 		return false, xerrors.Errorf("loading power actor state: %w", err)
@@ -638,6 +620,70 @@ func MinerHasMinPower(ctx context.Context, sm *StateManager, addr address.Addres
 	return ps.MinerNominalPowerMeetsConsensusMinimum(addr)
 }
 
+func MinerEligibleToMine(ctx context.Context, sm *StateManager, addr address.Address, baseTs *types.TipSet, lookbackTs *types.TipSet) (bool, error) {
+	hmp, err := minerHasMinPower(ctx, sm, addr, lookbackTs)
+
+	// TODO: We're blurring the lines between a "runtime network version" and a "Lotus upgrade epoch", is that unavoidable?
+	if sm.GetNtwkVersion(ctx, baseTs.Height()) <= network.Version3 {
+		return hmp, err
+	}
+
+	if err != nil {
+		return false, err
+	}
+
+	if !hmp {
+		return false, nil
+	}
+
+	// Post actors v2, also check MinerEligibleForElection with base ts
+
+	pact, err := sm.LoadActor(ctx, power.Address, baseTs)
+	if err != nil {
+		return false, xerrors.Errorf("loading power actor state: %w", err)
+	}
+
+	pstate, err := power.Load(sm.cs.Store(ctx), pact)
+	if err != nil {
+		return false, err
+	}
+
+	mact, err := sm.LoadActor(ctx, addr, baseTs)
+	if err != nil {
+		return false, xerrors.Errorf("loading miner actor state: %w", err)
+	}
+
+	mstate, err := miner.Load(sm.cs.Store(ctx), mact)
+	if err != nil {
+		return false, err
+	}
+
+	// Non-empty power claim.
+	if claim, found, err := pstate.MinerPower(addr); err != nil {
+		return false, err
+	} else if !found {
+		return false, err
+	} else if claim.QualityAdjPower.LessThanEqual(big.Zero()) {
+		return false, err
+	}
+
+	// No fee debt.
+	if debt, err := mstate.FeeDebt(); err != nil {
+		return false, err
+	} else if !debt.IsZero() {
+		return false, err
+	}
+
+	// No active consensus faults.
+	if mInfo, err := mstate.Info(); err != nil {
+		return false, err
+	} else if baseTs.Height() <= mInfo.ConsensusFaultElapsed {
+		return false, nil
+	}
+
+	return true, nil
+}
+
 func CheckTotalFIL(ctx context.Context, sm *StateManager, ts *types.TipSet) (abi.TokenAmount, error) {
 	str, err := state.LoadStateTree(sm.ChainStore().Store(ctx), ts.ParentState())
 	if err != nil {

chain/store/basefee.go

@@ -46,7 +46,7 @@ func ComputeNextBaseFee(baseFee types.BigInt, gasLimitUsed int64, noOfBlocks int
 }
 
 func (cs *ChainStore) ComputeBaseFee(ctx context.Context, ts *types.TipSet) (abi.TokenAmount, error) {
-	if ts.Height() > build.UpgradeBreezeHeight && ts.Height() < build.UpgradeBreezeHeight+build.BreezeGasTampingDuration {
+	if build.UpgradeBreezeHeight >= 0 && ts.Height() > build.UpgradeBreezeHeight && ts.Height() < build.UpgradeBreezeHeight+build.BreezeGasTampingDuration {
 		return abi.NewTokenAmount(100), nil
 	}
 

chain/store/basefee_test.go

@@ -11,24 +11,27 @@ import (
 
 func TestBaseFee(t *testing.T) {
 	tests := []struct {
-		basefee    uint64
-		limitUsed  int64
-		noOfBlocks int
-		output     uint64
+		basefee             uint64
+		limitUsed           int64
+		noOfBlocks          int
+		preSmoke, postSmoke uint64
 	}{
-		{100e6, 0, 1, 87.5e6},
-		{100e6, 0, 5, 87.5e6},
-		{100e6, build.BlockGasTarget, 1, 103.125e6},
-		{100e6, build.BlockGasTarget * 2, 2, 103.125e6},
-		{100e6, build.BlockGasLimit * 2, 2, 112.5e6},
-		{100e6, build.BlockGasLimit * 1.5, 2, 110937500},
+		{100e6, 0, 1, 87.5e6, 87.5e6},
+		{100e6, 0, 5, 87.5e6, 87.5e6},
+		{100e6, build.BlockGasTarget, 1, 103.125e6, 100e6},
+		{100e6, build.BlockGasTarget * 2, 2, 103.125e6, 100e6},
+		{100e6, build.BlockGasLimit * 2, 2, 112.5e6, 112.5e6},
+		{100e6, build.BlockGasLimit * 1.5, 2, 110937500, 106.250e6},
 	}
 
 	for _, test := range tests {
 		test := test
 		t.Run(fmt.Sprintf("%v", test), func(t *testing.T) {
-			output := ComputeNextBaseFee(types.NewInt(test.basefee), test.limitUsed, test.noOfBlocks, 0)
-			assert.Equal(t, fmt.Sprintf("%d", test.output), output.String())
+			preSmoke := ComputeNextBaseFee(types.NewInt(test.basefee), test.limitUsed, test.noOfBlocks, build.UpgradeSmokeHeight-1)
+			assert.Equal(t, fmt.Sprintf("%d", test.preSmoke), preSmoke.String())
+
+			postSmoke := ComputeNextBaseFee(types.NewInt(test.basefee), test.limitUsed, test.noOfBlocks, build.UpgradeSmokeHeight+1)
+			assert.Equal(t, fmt.Sprintf("%d", test.postSmoke), postSmoke.String())
 		})
 	}
 }

chain/store/store.go

@@ -17,11 +17,13 @@ import (
 
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
+
 	"github.com/filecoin-project/specs-actors/actors/builtin"
-	"github.com/filecoin-project/specs-actors/actors/util/adt"
+	adt0 "github.com/filecoin-project/specs-actors/actors/util/adt"
 
 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/actors/adt"
 	"github.com/filecoin-project/lotus/chain/vm"
 	"github.com/filecoin-project/lotus/journal"
 	bstore "github.com/filecoin-project/lotus/lib/blockstore"
@@ -757,7 +759,8 @@ func (cs *ChainStore) GetSignedMessage(c cid.Cid) (*types.SignedMessage, error)
 
 func (cs *ChainStore) readAMTCids(root cid.Cid) ([]cid.Cid, error) {
 	ctx := context.TODO()
-	a, err := adt.AsArray(cs.Store(ctx), root)
+	// block headers use adt0, for now.
+	a, err := adt0.AsArray(cs.Store(ctx), root)
 	if err != nil {
 		return nil, xerrors.Errorf("amt load: %w", err)
 	}
@@ -950,7 +953,8 @@ func (cs *ChainStore) MessagesForBlock(b *types.BlockHeader) ([]*types.Message,
 
 func (cs *ChainStore) GetParentReceipt(b *types.BlockHeader, i int) (*types.MessageReceipt, error) {
 	ctx := context.TODO()
-	a, err := adt.AsArray(cs.Store(ctx), b.ParentMessageReceipts)
+	// block headers use adt0, for now.
+	a, err := adt0.AsArray(cs.Store(ctx), b.ParentMessageReceipts)
 	if err != nil {
 		return nil, xerrors.Errorf("amt load: %w", err)
 	}
@@ -1191,13 +1195,6 @@ func recurseLinks(bs bstore.Blockstore, walked *cid.Set, root cid.Cid, in []cid.
 }
 
 func (cs *ChainStore) Export(ctx context.Context, ts *types.TipSet, inclRecentRoots abi.ChainEpoch, skipOldMsgs bool, w io.Writer) error {
-	if ts == nil {
-		ts = cs.GetHeaviestTipSet()
-	}
-
-	seen := cid.NewSet()
-	walked := cid.NewSet()
-
 	h := &car.CarHeader{
 		Roots:   ts.Cids(),
 		Version: 1,
@@ -1207,6 +1204,28 @@ func (cs *ChainStore) Export(ctx context.Context, ts *types.TipSet, inclRecentRo
 		return xerrors.Errorf("failed to write car header: %s", err)
 	}
 
+	return cs.WalkSnapshot(ctx, ts, inclRecentRoots, skipOldMsgs, func(c cid.Cid) error {
+		blk, err := cs.bs.Get(c)
+		if err != nil {
+			return xerrors.Errorf("writing object to car, bs.Get: %w", err)
+		}
+
+		if err := carutil.LdWrite(w, c.Bytes(), blk.RawData()); err != nil {
+			return xerrors.Errorf("failed to write block to car output: %w", err)
+		}
+
+		return nil
+	})
+}
+
+func (cs *ChainStore) WalkSnapshot(ctx context.Context, ts *types.TipSet, inclRecentRoots abi.ChainEpoch, skipOldMsgs bool, cb func(cid.Cid) error) error {
+	if ts == nil {
+		ts = cs.GetHeaviestTipSet()
+	}
+
+	seen := cid.NewSet()
+	walked := cid.NewSet()
+
 	blocksToWalk := ts.Cids()
 	currentMinHeight := ts.Height()
 
@@ -1215,15 +1234,15 @@ func (cs *ChainStore) Export(ctx context.Context, ts *types.TipSet, inclRecentRo
 			return nil
 		}
 
+		if err := cb(blk); err != nil {
+			return err
+		}
+
 		data, err := cs.bs.Get(blk)
 		if err != nil {
 			return xerrors.Errorf("getting block: %w", err)
 		}
 
-		if err := carutil.LdWrite(w, blk.Bytes(), data.RawData()); err != nil {
-			return xerrors.Errorf("failed to write block to car output: %w", err)
-		}
-
 		var b types.BlockHeader
 		if err := b.UnmarshalCBOR(bytes.NewBuffer(data.RawData())); err != nil {
 			return xerrors.Errorf("unmarshaling block header (cid=%s): %w", blk, err)
@@ -1270,14 +1289,11 @@ func (cs *ChainStore) Export(ctx context.Context, ts *types.TipSet, inclRecentRo
 				if c.Prefix().Codec != cid.DagCBOR {
 					continue
 				}
-				data, err := cs.bs.Get(c)
-				if err != nil {
-					return xerrors.Errorf("writing object to car (get %s): %w", c, err)
+
+				if err := cb(c); err != nil {
+					return err
 				}
 
-				if err := carutil.LdWrite(w, c.Bytes(), data.RawData()); err != nil {
-					return xerrors.Errorf("failed to write out car object: %w", err)
-				}
 			}
 		}
 

chain/sub/incoming.go

@@ -10,7 +10,6 @@ import (
 	"golang.org/x/xerrors"
 
 	address "github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/specs-actors/actors/util/adt"
 	lru "github.com/hashicorp/golang-lru"
 	blocks "github.com/ipfs/go-block-format"
 	bserv "github.com/ipfs/go-blockservice"
@@ -24,6 +23,8 @@ import (
 	"go.opencensus.io/stats"
 	"go.opencensus.io/tag"
 
+	adt0 "github.com/filecoin-project/specs-actors/actors/util/adt"
+
 	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain"
 	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
@@ -43,7 +44,11 @@ var log = logging.Logger("sub")
 var ErrSoftFailure = errors.New("soft validation failure")
 var ErrInsufficientPower = errors.New("incoming block's miner does not have minimum power")
 
-func HandleIncomingBlocks(ctx context.Context, bsub *pubsub.Subscription, s *chain.Syncer, bserv bserv.BlockService, cmgr connmgr.ConnManager) {
+func HandleIncomingBlocks(ctx context.Context, bsub *pubsub.Subscription, s *chain.Syncer, bs bserv.BlockService, cmgr connmgr.ConnManager) {
+	// Timeout after (block time + propagation delay). This is useless at
+	// this point.
+	timeout := time.Duration(build.BlockDelaySecs+build.PropagationDelaySecs) * time.Second
+
 	for {
 		msg, err := bsub.Next(ctx)
 		if err != nil {
@@ -64,15 +69,22 @@ func HandleIncomingBlocks(ctx context.Context, bsub *pubsub.Subscription, s *cha
 		src := msg.GetFrom()
 
 		go func() {
+			ctx, cancel := context.WithTimeout(ctx, timeout)
+			defer cancel()
+
+			// NOTE: we could also share a single session between
+			// all requests but that may have other consequences.
+			ses := bserv.NewSession(ctx, bs)
+
 			start := build.Clock.Now()
 			log.Debug("about to fetch messages for block from pubsub")
-			bmsgs, err := FetchMessagesByCids(context.TODO(), bserv, blk.BlsMessages)
+			bmsgs, err := FetchMessagesByCids(ctx, ses, blk.BlsMessages)
 			if err != nil {
 				log.Errorf("failed to fetch all bls messages for block received over pubusb: %s; source: %s", err, src)
 				return
 			}
 
-			smsgs, err := FetchSignedMessagesByCids(context.TODO(), bserv, blk.SecpkMessages)
+			smsgs, err := FetchSignedMessagesByCids(ctx, ses, blk.SecpkMessages)
 			if err != nil {
 				log.Errorf("failed to fetch all secpk messages for block received over pubusb: %s; source: %s", err, src)
 				return
@@ -97,7 +109,7 @@ func HandleIncomingBlocks(ctx context.Context, bsub *pubsub.Subscription, s *cha
 
 func FetchMessagesByCids(
 	ctx context.Context,
-	bserv bserv.BlockService,
+	bserv bserv.BlockGetter,
 	cids []cid.Cid,
 ) ([]*types.Message, error) {
 	out := make([]*types.Message, len(cids))
@@ -126,7 +138,7 @@ func FetchMessagesByCids(
 // FIXME: Duplicate of above.
 func FetchSignedMessagesByCids(
 	ctx context.Context,
-	bserv bserv.BlockService,
+	bserv bserv.BlockGetter,
 	cids []cid.Cid,
 ) ([]*types.SignedMessage, error) {
 	out := make([]*types.SignedMessage, len(cids))
@@ -156,12 +168,11 @@ func FetchSignedMessagesByCids(
 //  blocks we did not request.
 func fetchCids(
 	ctx context.Context,
-	bserv bserv.BlockService,
+	bserv bserv.BlockGetter,
 	cids []cid.Cid,
 	cb func(int, blocks.Block) error,
 ) error {
-	// FIXME: Why don't we use the context here?
-	fetchedBlocks := bserv.GetBlocks(context.TODO(), cids)
+	fetchedBlocks := bserv.GetBlocks(ctx, cids)
 
 	cidIndex := make(map[cid.Cid]int)
 	for i, c := range cids {
@@ -374,9 +385,10 @@ func (bv *BlockValidator) isChainNearSynced() bool {
 
 func (bv *BlockValidator) validateMsgMeta(ctx context.Context, msg *types.BlockMsg) error {
 	// TODO there has to be a simpler way to do this without the blockstore dance
-	store := adt.WrapStore(ctx, cbor.NewCborStore(blockstore.NewTemporary()))
-	bmArr := adt.MakeEmptyArray(store)
-	smArr := adt.MakeEmptyArray(store)
+	// block headers use adt0
+	store := adt0.WrapStore(ctx, cbor.NewCborStore(blockstore.NewTemporary()))
+	bmArr := adt0.MakeEmptyArray(store)
+	smArr := adt0.MakeEmptyArray(store)
 
 	for i, m := range msg.BlsMessages {
 		c := cbg.CborCid(m)
@@ -473,14 +485,14 @@ func (bv *BlockValidator) checkPowerAndGetWorkerKey(ctx context.Context, bh *typ
 		return address.Undef, ErrSoftFailure
 	}
 
-	hmp, err := stmgr.MinerHasMinPower(ctx, bv.stmgr, bh.Miner, lbts)
+	eligible, err := stmgr.MinerEligibleToMine(ctx, bv.stmgr, bh.Miner, baseTs, lbts)
 	if err != nil {
 		log.Warnf("failed to determine if incoming block's miner has minimum power: %s", err)
 		return address.Undef, ErrSoftFailure
 	}
 
-	if !hmp {
-		log.Warnf("incoming block's miner does not have minimum power")
+	if !eligible {
+		log.Warnf("incoming block's miner is ineligible")
 		return address.Undef, ErrInsufficientPower
 	}
 

chain/sync.go

@@ -11,6 +11,8 @@ import (
 	"sync"
 	"time"
 
+	"github.com/filecoin-project/lotus/chain/actors/builtin"
+
 	"github.com/filecoin-project/lotus/node/modules/dtypes"
 
 	"github.com/filecoin-project/specs-actors/actors/runtime/proof"
@@ -33,9 +35,10 @@ import (
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/crypto"
 	"github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper"
-	"github.com/filecoin-project/specs-actors/actors/util/adt"
 	blst "github.com/supranational/blst/bindings/go"
 
+	adt0 "github.com/filecoin-project/specs-actors/actors/util/adt"
+
 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain/actors/builtin/power"
@@ -455,9 +458,10 @@ func zipTipSetAndMessages(bs cbor.IpldStore, ts *types.TipSet, allbmsgs []*types
 // computeMsgMeta computes the root CID of the combined arrays of message CIDs
 // of both types (BLS and Secpk).
 func computeMsgMeta(bs cbor.IpldStore, bmsgCids, smsgCids []cid.Cid) (cid.Cid, error) {
-	store := adt.WrapStore(context.TODO(), bs)
-	bmArr := adt.MakeEmptyArray(store)
-	smArr := adt.MakeEmptyArray(store)
+	// block headers use adt0
+	store := adt0.WrapStore(context.TODO(), bs)
+	bmArr := adt0.MakeEmptyArray(store)
+	smArr := adt0.MakeEmptyArray(store)
 
 	for i, m := range bmsgCids {
 		c := cbg.CborCid(m)
@@ -823,13 +827,13 @@ func (syncer *Syncer) ValidateBlock(ctx context.Context, b *types.FullBlock, use
 			return xerrors.Errorf("block is not claiming to be a winner")
 		}
 
-		hp, err := stmgr.MinerHasMinPower(ctx, syncer.sm, h.Miner, lbts)
+		eligible, err := stmgr.MinerEligibleToMine(ctx, syncer.sm, h.Miner, baseTs, lbts)
 		if err != nil {
 			return xerrors.Errorf("determining if miner has min power failed: %w", err)
 		}
 
-		if !hp {
-			return xerrors.New("block's miner does not meet minimum power threshold")
+		if !eligible {
+			return xerrors.New("block's miner is ineligible to mine")
 		}
 
 		rBeacon := *prevBeacon
@@ -1087,7 +1091,7 @@ func (syncer *Syncer) checkBlockMessages(ctx context.Context, b *types.FullBlock
 				return xerrors.Errorf("failed to get actor: %w", err)
 			}
 
-			if !act.IsAccountActor() {
+			if !builtin.IsAccountActor(act.Code) {
 				return xerrors.New("Sender must be an account actor")
 			}
 			nonces[m.From] = act.Nonce
@@ -1101,9 +1105,9 @@ func (syncer *Syncer) checkBlockMessages(ctx context.Context, b *types.FullBlock
 		return nil
 	}
 
-	store := adt.WrapStore(ctx, cst)
+	store := adt0.WrapStore(ctx, cst)
 
-	bmArr := adt.MakeEmptyArray(store)
+	bmArr := adt0.MakeEmptyArray(store)
 	for i, m := range b.BlsMessages {
 		if err := checkMsg(m); err != nil {
 			return xerrors.Errorf("block had invalid bls message at index %d: %w", i, err)
@@ -1115,7 +1119,7 @@ func (syncer *Syncer) checkBlockMessages(ctx context.Context, b *types.FullBlock
 		}
 	}
 
-	smArr := adt.MakeEmptyArray(store)
+	smArr := adt0.MakeEmptyArray(store)
 	for i, m := range b.SecpkMessages {
 		if err := checkMsg(m); err != nil {
 			return xerrors.Errorf("block had invalid secpk message at index %d: %w", i, err)

chain/types/actor.go

@@ -4,8 +4,6 @@ import (
 	"errors"
 
 	"github.com/ipfs/go-cid"
-
-	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
 )
 
 var ErrActorNotFound = errors.New("actor not found")
@@ -17,19 +15,3 @@ type Actor struct {
 	Nonce   uint64
 	Balance BigInt
 }
-
-func (a *Actor) IsAccountActor() bool {
-	return a.Code == builtin0.AccountActorCodeID
-}
-
-func (a *Actor) IsStorageMinerActor() bool {
-	return a.Code == builtin0.StorageMinerActorCodeID
-}
-
-func (a *Actor) IsMultisigActor() bool {
-	return a.Code == builtin0.MultisigActorCodeID
-}
-
-func (a *Actor) IsPaymentChannelActor() bool {
-	return a.Code == builtin0.PaymentChannelActorCodeID
-}

chain/types/voucher.go

@@ -1,22 +0,0 @@
-package types
-
-import (
-	"encoding/base64"
-
-	"github.com/filecoin-project/specs-actors/actors/builtin/paych"
-	cbor "github.com/ipfs/go-ipld-cbor"
-)
-
-func DecodeSignedVoucher(s string) (*paych.SignedVoucher, error) {
-	data, err := base64.RawURLEncoding.DecodeString(s)
-	if err != nil {
-		return nil, err
-	}
-
-	var sv paych.SignedVoucher
-	if err := cbor.DecodeInto(data, &sv); err != nil {
-		return nil, err
-	}
-
-	return &sv, nil
-}

chain/vectors/gen/main.go

@@ -6,28 +6,25 @@ import (
 	"math/rand"
 	"os"
 
-	power0 "github.com/filecoin-project/specs-actors/actors/builtin/power"
-
 	"github.com/filecoin-project/go-address"
 	"golang.org/x/xerrors"
 
 	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/go-state-types/big"
 	"github.com/filecoin-project/go-state-types/crypto"
+	"github.com/filecoin-project/lotus/chain/actors/policy"
 	"github.com/filecoin-project/lotus/chain/gen"
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/chain/types/mock"
 	"github.com/filecoin-project/lotus/chain/vectors"
 	"github.com/filecoin-project/lotus/chain/wallet"
-	verifreg0 "github.com/filecoin-project/specs-actors/actors/builtin/verifreg"
 
 	_ "github.com/filecoin-project/lotus/lib/sigs/bls"
 	_ "github.com/filecoin-project/lotus/lib/sigs/secp"
 )
 
 func init() {
-	verifreg0.MinVerifiedDealSize = big.NewInt(2048)
-	power0.ConsensusMinerMinPower = big.NewInt(2048)
+	policy.SetMinVerifiedDealSize(abi.NewStoragePower(2048))
+	policy.SetConsensusMinerMinPower(abi.NewStoragePower(2048))
 }
 
 func MakeHeaderVectors() []vectors.HeaderVector {

chain/vm/gas.go

@@ -9,7 +9,6 @@ import (
 	addr "github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/crypto"
-	"github.com/filecoin-project/specs-actors/actors/runtime"
 	vmr "github.com/filecoin-project/specs-actors/actors/runtime"
 	"github.com/ipfs/go-cid"
 )
@@ -210,7 +209,7 @@ func (ps pricedSyscalls) VerifyPoSt(vi proof.WindowPoStVerifyInfo) error {
 // the "parent grinding fault", in which case it must be the sibling of h1 (same parent tipset) and one of the
 // blocks in the parent of h2 (i.e. h2's grandparent).
 // Returns nil and an error if the headers don't prove a fault.
-func (ps pricedSyscalls) VerifyConsensusFault(h1 []byte, h2 []byte, extra []byte) (*runtime.ConsensusFault, error) {
+func (ps pricedSyscalls) VerifyConsensusFault(h1 []byte, h2 []byte, extra []byte) (*vmr.ConsensusFault, error) {
 	ps.chargeGas(ps.pl.OnVerifyConsensusFault())
 	defer ps.chargeGas(gasOnActorExec)
 

chain/vm/gas_v0.go

@@ -8,7 +8,7 @@ import (
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/big"
 	"github.com/filecoin-project/go-state-types/crypto"
-	"github.com/filecoin-project/specs-actors/actors/builtin"
+	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
 )
 
 type scalingCost struct {
@@ -112,14 +112,14 @@ func (pl *pricelistV0) OnMethodInvocation(value abi.TokenAmount, methodNum abi.M
 
 	if big.Cmp(value, abi.NewTokenAmount(0)) != 0 {
 		ret += pl.sendTransferFunds
-		if methodNum == builtin.MethodSend {
+		if methodNum == builtin0.MethodSend {
 			// transfer only
 			ret += pl.sendTransferOnlyPremium
 		}
 		extra += "t"
 	}
 
-	if methodNum != builtin.MethodSend {
+	if methodNum != builtin0.MethodSend {
 		extra += "i"
 		// running actors is cheaper becase we hand over to actors
 		ret += pl.sendInvokeMethod

chain/vm/invoker.go

@@ -6,91 +6,126 @@ import (
 	"fmt"
 	"reflect"
 
+	"github.com/filecoin-project/lotus/chain/actors/builtin"
+
 	"github.com/ipfs/go-cid"
 	cbg "github.com/whyrusleeping/cbor-gen"
 	"golang.org/x/xerrors"
 
-	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
-	account0 "github.com/filecoin-project/specs-actors/actors/builtin/account"
-	cron0 "github.com/filecoin-project/specs-actors/actors/builtin/cron"
-	init0 "github.com/filecoin-project/specs-actors/actors/builtin/init"
-	market0 "github.com/filecoin-project/specs-actors/actors/builtin/market"
-	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
-	msig0 "github.com/filecoin-project/specs-actors/actors/builtin/multisig"
-	paych0 "github.com/filecoin-project/specs-actors/actors/builtin/paych"
-	power0 "github.com/filecoin-project/specs-actors/actors/builtin/power"
-	reward0 "github.com/filecoin-project/specs-actors/actors/builtin/reward"
-	system0 "github.com/filecoin-project/specs-actors/actors/builtin/system"
-	verifreg0 "github.com/filecoin-project/specs-actors/actors/builtin/verifreg"
-	vmr "github.com/filecoin-project/specs-actors/actors/runtime"
+	exported0 "github.com/filecoin-project/specs-actors/actors/builtin/exported"
+	exported2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/exported"
+	vmr "github.com/filecoin-project/specs-actors/v2/actors/runtime"
 
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/exitcode"
+	rtt "github.com/filecoin-project/go-state-types/rt"
 
+	"github.com/filecoin-project/lotus/chain/actors"
 	"github.com/filecoin-project/lotus/chain/actors/aerrors"
+	"github.com/filecoin-project/lotus/chain/types"
 )
 
-type Invoker struct {
-	builtInCode  map[cid.Cid]nativeCode
-	builtInState map[cid.Cid]reflect.Type
+type ActorRegistry struct {
+	actors map[cid.Cid]*actorInfo
+}
+
+// An ActorPredicate returns an error if the given actor is not valid for the given runtime environment (e.g., chain height, version, etc.).
+type ActorPredicate func(vmr.Runtime, rtt.VMActor) error
+
+func ActorsVersionPredicate(ver actors.Version) ActorPredicate {
+	return func(rt vmr.Runtime, v rtt.VMActor) error {
+		nver := actors.VersionForNetwork(rt.NetworkVersion())
+		if nver != ver {
+			return xerrors.Errorf("actor %s is a version %d actor; chain only supports actor version %d at height %d", v.Code(), ver, nver, rt.CurrEpoch())
+		}
+		return nil
+	}
 }
 
 type invokeFunc func(rt vmr.Runtime, params []byte) ([]byte, aerrors.ActorError)
 type nativeCode []invokeFunc
 
-func NewInvoker() *Invoker {
-	inv := &Invoker{
-		builtInCode:  make(map[cid.Cid]nativeCode),
-		builtInState: make(map[cid.Cid]reflect.Type),
-	}
+type actorInfo struct {
+	methods nativeCode
+	vmActor rtt.VMActor
+	// TODO: consider making this a network version range?
+	predicate ActorPredicate
+}
+
+func NewActorRegistry() *ActorRegistry {
+	inv := &ActorRegistry{actors: make(map[cid.Cid]*actorInfo)}
+
+	// TODO: define all these properties on the actors themselves, in specs-actors.
 
 	// add builtInCode using: register(cid, singleton)
-	// NETUPGRADE: register code IDs for v2, etc.
-	inv.Register(builtin0.SystemActorCodeID, system0.Actor{}, abi.EmptyValue{})
-	inv.Register(builtin0.InitActorCodeID, init0.Actor{}, init0.State{})
-	inv.Register(builtin0.RewardActorCodeID, reward0.Actor{}, reward0.State{})
-	inv.Register(builtin0.CronActorCodeID, cron0.Actor{}, cron0.State{})
-	inv.Register(builtin0.StoragePowerActorCodeID, power0.Actor{}, power0.State{})
-	inv.Register(builtin0.StorageMarketActorCodeID, market0.Actor{}, market0.State{})
-	inv.Register(builtin0.StorageMinerActorCodeID, miner0.Actor{}, miner0.State{})
-	inv.Register(builtin0.MultisigActorCodeID, msig0.Actor{}, msig0.State{})
-	inv.Register(builtin0.PaymentChannelActorCodeID, paych0.Actor{}, paych0.State{})
-	inv.Register(builtin0.VerifiedRegistryActorCodeID, verifreg0.Actor{}, verifreg0.State{})
-	inv.Register(builtin0.AccountActorCodeID, account0.Actor{}, account0.State{})
+	inv.Register(ActorsVersionPredicate(actors.Version0), exported0.BuiltinActors()...)
+	inv.Register(ActorsVersionPredicate(actors.Version2), exported2.BuiltinActors()...)
 
 	return inv
 }
 
-func (inv *Invoker) Invoke(codeCid cid.Cid, rt vmr.Runtime, method abi.MethodNum, params []byte) ([]byte, aerrors.ActorError) {
-
-	code, ok := inv.builtInCode[codeCid]
+func (ar *ActorRegistry) Invoke(codeCid cid.Cid, rt vmr.Runtime, method abi.MethodNum, params []byte) ([]byte, aerrors.ActorError) {
+	act, ok := ar.actors[codeCid]
 	if !ok {
 		log.Errorf("no code for actor %s (Addr: %s)", codeCid, rt.Receiver())
 		return nil, aerrors.Newf(exitcode.SysErrorIllegalActor, "no code for actor %s(%d)(%s)", codeCid, method, hex.EncodeToString(params))
 	}
-	if method >= abi.MethodNum(len(code)) || code[method] == nil {
+	if method >= abi.MethodNum(len(act.methods)) || act.methods[method] == nil {
 		return nil, aerrors.Newf(exitcode.SysErrInvalidMethod, "no method %d on actor", method)
 	}
-	return code[method](rt, params)
-
-}
-
-func (inv *Invoker) Register(c cid.Cid, instance Invokee, state interface{}) {
-	code, err := inv.transform(instance)
-	if err != nil {
-		panic(xerrors.Errorf("%s: %w", string(c.Hash()), err))
+	if err := act.predicate(rt, act.vmActor); err != nil {
+		return nil, aerrors.Newf(exitcode.SysErrInvalidMethod, "unsupported actor: %s", err)
 	}
-	inv.builtInCode[c] = code
-	inv.builtInState[c] = reflect.TypeOf(state)
+	return act.methods[method](rt, params)
+
 }
 
-type Invokee interface {
+func (ar *ActorRegistry) Register(pred ActorPredicate, actors ...rtt.VMActor) {
+	if pred == nil {
+		pred = func(vmr.Runtime, rtt.VMActor) error { return nil }
+	}
+	for _, a := range actors {
+		code, err := ar.transform(a)
+		if err != nil {
+			panic(xerrors.Errorf("%s: %w", string(a.Code().Hash()), err))
+		}
+		ar.actors[a.Code()] = &actorInfo{
+			methods:   code,
+			vmActor:   a,
+			predicate: pred,
+		}
+	}
+}
+
+func (ar *ActorRegistry) Create(codeCid cid.Cid, rt vmr.Runtime) (*types.Actor, aerrors.ActorError) {
+	act, ok := ar.actors[codeCid]
+	if !ok {
+		return nil, aerrors.Newf(exitcode.SysErrorIllegalArgument, "Can only create built-in actors.")
+	}
+
+	if err := act.predicate(rt, act.vmActor); err != nil {
+		return nil, aerrors.Newf(exitcode.SysErrorIllegalArgument, "Cannot create actor: %w", err)
+	}
+
+	if rtt.IsSingletonActor(act.vmActor) {
+		return nil, aerrors.Newf(exitcode.SysErrorIllegalArgument, "Can only have one instance of singleton actors.")
+	}
+	return &types.Actor{
+		Code:    codeCid,
+		Head:    EmptyObjectCid,
+		Nonce:   0,
+		Balance: abi.NewTokenAmount(0),
+	}, nil
+}
+
+type invokee interface {
 	Exports() []interface{}
 }
 
-func (*Invoker) transform(instance Invokee) (nativeCode, error) {
+func (*ActorRegistry) transform(instance invokee) (nativeCode, error) {
 	itype := reflect.TypeOf(instance)
 	exports := instance.Exports()
+	runtimeType := reflect.TypeOf((*vmr.Runtime)(nil)).Elem()
 	for i, m := range exports {
 		i := i
 		newErr := func(format string, args ...interface{}) error {
@@ -111,7 +146,7 @@ func (*Invoker) transform(instance Invokee) (nativeCode, error) {
 			return nil, newErr("wrong number of inputs should be: " +
 				"vmr.Runtime, <parameter>")
 		}
-		if t.In(0) != reflect.TypeOf((*vmr.Runtime)(nil)).Elem() {
+		if !runtimeType.Implements(t.In(0)) {
 			return nil, newErr("first arguemnt should be vmr.Runtime")
 		}
 		if t.In(1).Kind() != reflect.Ptr {
@@ -176,27 +211,22 @@ func DecodeParams(b []byte, out interface{}) error {
 	return um.UnmarshalCBOR(bytes.NewReader(b))
 }
 
-func DumpActorState(code cid.Cid, b []byte) (interface{}, error) {
-	if code == builtin0.AccountActorCodeID { // Account code special case
+func DumpActorState(act *types.Actor, b []byte) (interface{}, error) {
+	if builtin.IsAccountActor(act.Code) { // Account code special case
 		return nil, nil
 	}
 
-	i := NewInvoker() // TODO: register builtins in init block
+	i := NewActorRegistry() // TODO: register builtins in init block
 
-	typ, ok := i.builtInState[code]
+	actInfo, ok := i.actors[act.Code]
 	if !ok {
-		return nil, xerrors.Errorf("state type for actor %s not found", code)
-	}
-
-	rv := reflect.New(typ)
-	um, ok := rv.Interface().(cbg.CBORUnmarshaler)
-	if !ok {
-		return nil, xerrors.New("state type does not implement CBORUnmarshaler")
+		return nil, xerrors.Errorf("state type for actor %s not found", act.Code)
 	}
 
+	um := actInfo.vmActor.State()
 	if err := um.UnmarshalCBOR(bytes.NewReader(b)); err != nil {
 		return nil, xerrors.Errorf("unmarshaling actor state: %w", err)
 	}
 
-	return rv.Elem().Interface(), nil
+	return um, nil
 }

chain/vm/invoker_test.go

@@ -77,7 +77,7 @@ func (basicContract) InvokeSomething10(rt runtime.Runtime, params *basicParams)
 }
 
 func TestInvokerBasic(t *testing.T) {
-	inv := Invoker{}
+	inv := ActorRegistry{}
 	code, err := inv.transform(basicContract{})
 	assert.NoError(t, err)
 

chain/vm/mkactor.go

@@ -6,11 +6,13 @@ import (
 	"github.com/filecoin-project/go-state-types/big"
 	"github.com/filecoin-project/go-state-types/exitcode"
 	"github.com/filecoin-project/lotus/chain/actors"
-	"github.com/filecoin-project/specs-actors/actors/builtin"
 
 	"github.com/ipfs/go-cid"
 	cbor "github.com/ipfs/go-ipld-cbor"
 
+	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
+	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
+
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/lotus/chain/actors/aerrors"
 	"github.com/filecoin-project/lotus/chain/types"
@@ -29,49 +31,47 @@ func init() {
 var EmptyObjectCid cid.Cid
 
 // TryCreateAccountActor creates account actors from only BLS/SECP256K1 addresses.
-func TryCreateAccountActor(rt *Runtime, addr address.Address) (*types.Actor, aerrors.ActorError) {
+func TryCreateAccountActor(rt *Runtime, addr address.Address) (*types.Actor, address.Address, aerrors.ActorError) {
 	if err := rt.chargeGasSafe(PricelistByEpoch(rt.height).OnCreateActor()); err != nil {
-		return nil, err
+		return nil, address.Undef, err
 	}
 
 	addrID, err := rt.state.RegisterNewAddress(addr)
 	if err != nil {
-		return nil, aerrors.Escalate(err, "registering actor address")
+		return nil, address.Undef, aerrors.Escalate(err, "registering actor address")
 	}
 
-	act, aerr := makeActor(addr)
+	act, aerr := makeActor(actors.VersionForNetwork(rt.NetworkVersion()), addr)
 	if aerr != nil {
-		return nil, aerr
+		return nil, address.Undef, aerr
 	}
 
 	if err := rt.state.SetActor(addrID, act); err != nil {
-		return nil, aerrors.Escalate(err, "creating new actor failed")
+		return nil, address.Undef, aerrors.Escalate(err, "creating new actor failed")
 	}
 
 	p, err := actors.SerializeParams(&addr)
 	if err != nil {
-		return nil, aerrors.Escalate(err, "couldn't serialize params for actor construction")
+		return nil, address.Undef, aerrors.Escalate(err, "couldn't serialize params for actor construction")
 	}
 	// call constructor on account
 
-	_, aerr = rt.internalSend(builtin.SystemActorAddr, addrID, builtin.MethodsAccount.Constructor, big.Zero(), p)
+	_, aerr = rt.internalSend(builtin0.SystemActorAddr, addrID, builtin0.MethodsAccount.Constructor, big.Zero(), p)
 	if aerr != nil {
-		return nil, aerrors.Wrap(aerr, "failed to invoke account constructor")
+		return nil, address.Undef, aerrors.Wrap(aerr, "failed to invoke account constructor")
 	}
 
 	act, err = rt.state.GetActor(addrID)
 	if err != nil {
-		return nil, aerrors.Escalate(err, "loading newly created actor failed")
+		return nil, address.Undef, aerrors.Escalate(err, "loading newly created actor failed")
 	}
-	return act, nil
+	return act, addrID, nil
 }
 
-func makeActor(addr address.Address) (*types.Actor, aerrors.ActorError) {
+func makeActor(ver actors.Version, addr address.Address) (*types.Actor, aerrors.ActorError) {
 	switch addr.Protocol() {
-	case address.BLS:
-		return NewBLSAccountActor(), nil
-	case address.SECP256K1:
-		return NewSecp256k1AccountActor(), nil
+	case address.BLS, address.SECP256K1:
+		return newAccountActor(ver), nil
 	case address.ID:
 		return nil, aerrors.Newf(exitcode.SysErrInvalidReceiver, "no actor with given ID: %s", addr)
 	case address.Actor:
@@ -81,19 +81,19 @@ func makeActor(addr address.Address) (*types.Actor, aerrors.ActorError) {
 	}
 }
 
-func NewBLSAccountActor() *types.Actor {
+func newAccountActor(ver actors.Version) *types.Actor {
+	// TODO: ActorsUpgrade use a global actor registry?
+	var code cid.Cid
+	switch ver {
+	case actors.Version0:
+		code = builtin0.AccountActorCodeID
+	case actors.Version2:
+		code = builtin2.AccountActorCodeID
+	default:
+		panic("unsupported actors version")
+	}
 	nact := &types.Actor{
-		Code:    builtin.AccountActorCodeID,
-		Balance: types.NewInt(0),
-		Head:    EmptyObjectCid,
-	}
-
-	return nact
-}
-
-func NewSecp256k1AccountActor() *types.Actor {
-	nact := &types.Actor{
-		Code:    builtin.AccountActorCodeID,
+		Code:    code,
 		Balance: types.NewInt(0),
 		Head:    EmptyObjectCid,
 	}

chain/vm/runtime.go

@@ -9,14 +9,13 @@ import (
 
 	"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/cbor"
 	"github.com/filecoin-project/go-state-types/crypto"
 	"github.com/filecoin-project/go-state-types/exitcode"
 	"github.com/filecoin-project/go-state-types/network"
 	rtt "github.com/filecoin-project/go-state-types/rt"
-	"github.com/filecoin-project/specs-actors/actors/builtin"
 	rt0 "github.com/filecoin-project/specs-actors/actors/runtime"
+	rt2 "github.com/filecoin-project/specs-actors/v2/actors/runtime"
 	"github.com/ipfs/go-cid"
 	ipldcbor "github.com/ipfs/go-ipld-cbor"
 	"go.opencensus.io/trace"
@@ -28,8 +27,30 @@ import (
 	"github.com/filecoin-project/lotus/chain/types"
 )
 
+type Message struct {
+	msg types.Message
+}
+
+func (m *Message) Caller() address.Address {
+	if m.msg.From.Protocol() != address.ID {
+		panic("runtime message has a non-ID caller")
+	}
+	return m.msg.From
+}
+
+func (m *Message) Receiver() address.Address {
+	if m.msg.To != address.Undef && m.msg.To.Protocol() != address.ID {
+		panic("runtime message has a non-ID receiver")
+	}
+	return m.msg.To
+}
+
+func (m *Message) ValueReceived() abi.TokenAmount {
+	return m.msg.Value
+}
+
 type Runtime struct {
-	types.Message
+	rt0.Message
 	rt0.Syscalls
 
 	ctx context.Context
@@ -110,6 +131,7 @@ func (rt *Runtime) StorePut(x cbor.Marshaler) cid.Cid {
 }
 
 var _ rt0.Runtime = (*Runtime)(nil)
+var _ rt2.Runtime = (*Runtime)(nil)
 
 func (rt *Runtime) shimCall(f func() interface{}) (rval []byte, aerr aerrors.ActorError) {
 	defer func() {
@@ -122,7 +144,11 @@ func (rt *Runtime) shimCall(f func() interface{}) (rval []byte, aerr aerrors.Act
 			//log.Desugar().WithOptions(zap.AddStacktrace(zapcore.ErrorLevel)).
 			//Sugar().Errorf("spec actors failure: %s", r)
 			log.Errorf("spec actors failure: %s", r)
-			aerr = aerrors.Newf(1, "spec actors failure: %s", r)
+			if rt.NetworkVersion() <= network.Version3 {
+				aerr = aerrors.Newf(1, "spec actors failure: %s", r)
+			} else {
+				aerr = aerrors.Newf(exitcode.SysErrReserved1, "spec actors failure: %s", r)
+			}
 		}
 	}()
 
@@ -215,12 +241,9 @@ func (rt *Runtime) NewActorAddress() address.Address {
 }
 
 func (rt *Runtime) CreateActor(codeID cid.Cid, address address.Address) {
-	if !builtin.IsBuiltinActor(codeID) {
-		rt.Abortf(exitcode.SysErrorIllegalArgument, "Can only create built-in actors.")
-	}
-
-	if builtin.IsSingletonActor(codeID) {
-		rt.Abortf(exitcode.SysErrorIllegalArgument, "Can only have one instance of singleton actors.")
+	act, aerr := rt.vm.areg.Create(codeID, rt)
+	if aerr != nil {
+		rt.Abortf(aerr.RetCode(), aerr.Error())
 	}
 
 	_, err := rt.state.GetActor(address)
@@ -230,12 +253,7 @@ func (rt *Runtime) CreateActor(codeID cid.Cid, address address.Address) {
 
 	rt.chargeGas(rt.Pricelist().OnCreateActor())
 
-	err = rt.state.SetActor(address, &types.Actor{
-		Code:    codeID,
-		Head:    EmptyObjectCid,
-		Nonce:   0,
-		Balance: big.Zero(),
-	})
+	err = rt.state.SetActor(address, act)
 	if err != nil {
 		panic(aerrors.Fatalf("creating actor entry: %v", err))
 	}

chain/vm/vm.go

@@ -8,6 +8,8 @@ import (
 	"sync/atomic"
 	"time"
 
+	"github.com/filecoin-project/lotus/chain/actors/builtin"
+
 	block "github.com/ipfs/go-block-format"
 	cid "github.com/ipfs/go-cid"
 	cbor "github.com/ipfs/go-ipld-cbor"
@@ -23,7 +25,6 @@ import (
 	"github.com/filecoin-project/go-state-types/crypto"
 	"github.com/filecoin-project/go-state-types/exitcode"
 	"github.com/filecoin-project/go-state-types/network"
-	"github.com/filecoin-project/specs-actors/actors/builtin"
 
 	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain/actors/adt"
@@ -130,7 +131,15 @@ func (vm *VM) makeRuntime(ctx context.Context, msg *types.Message, origin addres
 		rt.Abortf(exitcode.SysErrInvalidReceiver, "resolve msg.From address failed")
 	}
 	vmm.From = resF
-	rt.Message = vmm
+
+	if vm.ntwkVersion(ctx, vm.blockHeight) <= network.Version3 {
+		rt.Message = &vmm
+	} else {
+		resT, _ := rt.ResolveAddress(msg.To)
+		// may be set to undef if recipient doesn't exist yet
+		vmm.To = resT
+		rt.Message = &Message{msg: vmm}
+	}
 
 	return rt
 }
@@ -152,7 +161,7 @@ type VM struct {
 	cst            *cbor.BasicIpldStore
 	buf            *bufbstore.BufferedBS
 	blockHeight    abi.ChainEpoch
-	inv            *Invoker
+	areg           *ActorRegistry
 	rand           Rand
 	circSupplyCalc CircSupplyCalculator
 	ntwkVersion    NtwkVersionGetter
@@ -186,7 +195,7 @@ func NewVM(ctx context.Context, opts *VMOpts) (*VM, error) {
 		cst:            cst,
 		buf:            buf,
 		blockHeight:    opts.Epoch,
-		inv:            NewInvoker(),
+		areg:           NewActorRegistry(),
 		rand:           opts.Rand, // TODO: Probably should be a syscall
 		circSupplyCalc: opts.CircSupplyCalc,
 		ntwkVersion:    opts.NtwkVersion,
@@ -256,11 +265,24 @@ func (vm *VM) send(ctx context.Context, msg *types.Message, parent *Runtime,
 		toActor, err := st.GetActor(msg.To)
 		if err != nil {
 			if xerrors.Is(err, types.ErrActorNotFound) {
-				a, err := TryCreateAccountActor(rt, msg.To)
+				a, aid, err := TryCreateAccountActor(rt, msg.To)
 				if err != nil {
 					return nil, aerrors.Wrapf(err, "could not create account")
 				}
 				toActor = a
+				if vm.ntwkVersion(ctx, vm.blockHeight) <= network.Version3 {
+					// Leave the rt.Message as is
+				} else {
+					nmsg := Message{
+						msg: types.Message{
+							To:    aid,
+							From:  rt.Message.Caller(),
+							Value: rt.Message.ValueReceived(),
+						},
+					}
+
+					rt.Message = &nmsg
+				}
 			} else {
 				return nil, aerrors.Escalate(err, "getting actor")
 			}
@@ -403,7 +425,7 @@ func (vm *VM) ApplyMessage(ctx context.Context, cmsg types.ChainMsg) (*ApplyRet,
 	}
 
 	// this should never happen, but is currently still exercised by some tests
-	if !fromActor.IsAccountActor() {
+	if !builtin.IsAccountActor(fromActor.Code) {
 		gasOutputs := ZeroGasOutputs()
 		gasOutputs.MinerPenalty = minerPenaltyAmount
 		return &ApplyRet{
@@ -741,15 +763,15 @@ func (vm *VM) Invoke(act *types.Actor, rt *Runtime, method abi.MethodNum, params
 	defer func() {
 		rt.ctx = oldCtx
 	}()
-	ret, err := vm.inv.Invoke(act.Code, rt, method, params)
+	ret, err := vm.areg.Invoke(act.Code, rt, method, params)
 	if err != nil {
 		return nil, err
 	}
 	return ret, nil
 }
 
-func (vm *VM) SetInvoker(i *Invoker) {
-	vm.inv = i
+func (vm *VM) SetInvoker(i *ActorRegistry) {
+	vm.areg = i
 }
 
 func (vm *VM) GetNtwkVersion(ctx context.Context, ce abi.ChainEpoch) network.Version {

chain/wallet/wallet.go

@@ -81,7 +81,7 @@ func (w *Wallet) findKey(addr address.Address) (*Key, error) {
 		return nil, nil
 	}
 
-	ki, err := w.keystore.Get(KNamePrefix + addr.String())
+	ki, err := w.tryFind(addr)
 	if err != nil {
 		if xerrors.Is(err, types.ErrKeyInfoNotFound) {
 			return nil, nil
@@ -96,6 +96,42 @@ func (w *Wallet) findKey(addr address.Address) (*Key, error) {
 	return k, nil
 }
 
+func (w *Wallet) tryFind(addr address.Address) (types.KeyInfo, error) {
+
+	ki, err := w.keystore.Get(KNamePrefix + addr.String())
+	if err == nil {
+		return ki, err
+	}
+
+	if !xerrors.Is(err, types.ErrKeyInfoNotFound) {
+		return types.KeyInfo{}, err
+	}
+
+	// We got an ErrKeyInfoNotFound error
+	// Try again, this time with the testnet prefix
+
+	aChars := []rune(addr.String())
+	prefixRunes := []rune(address.TestnetPrefix)
+	if len(prefixRunes) != 1 {
+		return types.KeyInfo{}, xerrors.Errorf("unexpected prefix length: %d", len(prefixRunes))
+	}
+
+	aChars[0] = prefixRunes[0]
+	ki, err = w.keystore.Get(KNamePrefix + string(aChars))
+	if err != nil {
+		return types.KeyInfo{}, err
+	}
+
+	// We found it with the testnet prefix
+	// Add this KeyInfo with the mainnet prefix address string
+	err = w.keystore.Put(KNamePrefix+addr.String(), ki)
+	if err != nil {
+		return types.KeyInfo{}, err
+	}
+
+	return ki, nil
+}
+
 func (w *Wallet) Export(addr address.Address) (*types.KeyInfo, error) {
 	k, err := w.findKey(addr)
 	if err != nil {
@@ -129,6 +165,7 @@ func (w *Wallet) ListAddrs() ([]address.Address, error) {
 
 	sort.Strings(all)
 
+	seen := map[address.Address]struct{}{}
 	out := make([]address.Address, 0, len(all))
 	for _, a := range all {
 		if strings.HasPrefix(a, KNamePrefix) {
@@ -137,10 +174,19 @@ func (w *Wallet) ListAddrs() ([]address.Address, error) {
 			if err != nil {
 				return nil, xerrors.Errorf("converting name to address: %w", err)
 			}
+			if _, ok := seen[addr]; ok {
+				continue // got duplicate with a different prefix
+			}
+			seen[addr] = struct{}{}
+
 			out = append(out, addr)
 		}
 	}
 
+	sort.Slice(out, func(i, j int) bool {
+		return out[i].String() < out[j].String()
+	})
+
 	return out, nil
 }
 

cli/backup.go

@@ -0,0 +1,125 @@
+package cli
+
+import (
+	"context"
+	"fmt"
+	"os"
+
+	logging "github.com/ipfs/go-log/v2"
+	"github.com/mitchellh/go-homedir"
+	"github.com/urfave/cli/v2"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-jsonrpc"
+
+	"github.com/filecoin-project/lotus/lib/backupds"
+	"github.com/filecoin-project/lotus/node/repo"
+)
+
+type BackupAPI interface {
+	CreateBackup(ctx context.Context, fpath string) error
+}
+
+type BackupApiFn func(ctx *cli.Context) (BackupAPI, jsonrpc.ClientCloser, error)
+
+func BackupCmd(repoFlag string, rt repo.RepoType, getApi BackupApiFn) *cli.Command {
+	var offlineBackup = func(cctx *cli.Context) error {
+		logging.SetLogLevel("badger", "ERROR") // nolint:errcheck
+
+		repoPath := cctx.String(repoFlag)
+		r, err := repo.NewFS(repoPath)
+		if err != nil {
+			return err
+		}
+
+		ok, err := r.Exists()
+		if err != nil {
+			return err
+		}
+		if !ok {
+			return xerrors.Errorf("repo at '%s' is not initialized", cctx.String(repoFlag))
+		}
+
+		lr, err := r.LockRO(rt)
+		if err != nil {
+			return xerrors.Errorf("locking repo: %w", err)
+		}
+		defer lr.Close() // nolint:errcheck
+
+		mds, err := lr.Datastore("/metadata")
+		if err != nil {
+			return xerrors.Errorf("getting metadata datastore: %w", err)
+		}
+
+		bds := backupds.Wrap(mds)
+
+		fpath, err := homedir.Expand(cctx.Args().First())
+		if err != nil {
+			return xerrors.Errorf("expanding file path: %w", err)
+		}
+
+		out, err := os.OpenFile(fpath, os.O_CREATE|os.O_WRONLY, 0644)
+		if err != nil {
+			return xerrors.Errorf("opening backup file %s: %w", fpath, err)
+		}
+
+		if err := bds.Backup(out); err != nil {
+			if cerr := out.Close(); cerr != nil {
+				log.Errorw("error closing backup file while handling backup error", "closeErr", cerr, "backupErr", err)
+			}
+			return xerrors.Errorf("backup error: %w", err)
+		}
+
+		if err := out.Close(); err != nil {
+			return xerrors.Errorf("closing backup file: %w", err)
+		}
+
+		return nil
+	}
+
+	var onlineBackup = func(cctx *cli.Context) error {
+		api, closer, err := getApi(cctx)
+		if err != nil {
+			return xerrors.Errorf("getting api: %w (if the node isn't running you can use the --offline flag)", err)
+		}
+		defer closer()
+
+		err = api.CreateBackup(ReqContext(cctx), cctx.Args().First())
+		if err != nil {
+			return err
+		}
+
+		fmt.Println("Success")
+
+		return nil
+	}
+
+	return &cli.Command{
+		Name:  "backup",
+		Usage: "Create node metadata backup",
+		Description: `The backup command writes a copy of node metadata under the specified path
+
+Online backups:
+For security reasons, the daemon must be have LOTUS_BACKUP_BASE_PATH env var set
+to a path where backup files are supposed to be saved, and the path specified in
+this command must be within this base path`,
+		Flags: []cli.Flag{
+			&cli.BoolFlag{
+				Name:  "offline",
+				Usage: "create backup without the node running",
+			},
+		},
+		ArgsUsage: "[backup file path]",
+		Action: func(cctx *cli.Context) error {
+			if cctx.Args().Len() != 1 {
+				return xerrors.Errorf("expected 1 argument")
+			}
+
+			if cctx.Bool("offline") {
+				return offlineBackup(cctx)
+			}
+
+			return onlineBackup(cctx)
+		},
+	}
+}

cli/chain.go

@@ -8,6 +8,7 @@ import (
 	"os"
 	"os/exec"
 	"path"
+	"sort"
 	"strconv"
 	"strings"
 	"time"
@@ -27,9 +28,10 @@ import (
 	cbg "github.com/whyrusleeping/cbor-gen"
 	"golang.org/x/xerrors"
 
-	"github.com/filecoin-project/lotus/api"
+	lapi "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/stmgr"
 	types "github.com/filecoin-project/lotus/chain/types"
 )
 
@@ -50,6 +52,7 @@ var chainCmd = &cli.Command{
 		chainExportCmd,
 		slashConsensusFault,
 		chainGasPriceCmd,
+		chainInspectUsage,
 	},
 }
 
@@ -159,7 +162,7 @@ var chainGetBlock = &cli.Command{
 	},
 }
 
-func apiMsgCids(in []api.Message) []cid.Cid {
+func apiMsgCids(in []lapi.Message) []cid.Cid {
 	out := make([]cid.Cid, len(in))
 	for k, v := range in {
 		out[k] = v.Cid
@@ -375,6 +378,143 @@ var chainSetHeadCmd = &cli.Command{
 	},
 }
 
+var chainInspectUsage = &cli.Command{
+	Name:  "inspect-usage",
+	Usage: "Inspect block space usage of a given tipset",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:  "tipset",
+			Usage: "specify tipset to view block space usage of",
+			Value: "@head",
+		},
+		&cli.IntFlag{
+			Name:  "length",
+			Usage: "length of chain to inspect block space usage for",
+			Value: 1,
+		},
+		&cli.IntFlag{
+			Name:  "num-results",
+			Usage: "number of results to print per category",
+			Value: 10,
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		api, closer, err := GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+		ctx := ReqContext(cctx)
+
+		ts, err := LoadTipSet(ctx, cctx, api)
+		if err != nil {
+			return err
+		}
+
+		cur := ts
+		var msgs []lapi.Message
+		for i := 0; i < cctx.Int("length"); i++ {
+			pmsgs, err := api.ChainGetParentMessages(ctx, cur.Blocks()[0].Cid())
+			if err != nil {
+				return err
+			}
+
+			msgs = append(msgs, pmsgs...)
+
+			next, err := api.ChainGetTipSet(ctx, cur.Parents())
+			if err != nil {
+				return err
+			}
+
+			cur = next
+		}
+
+		codeCache := make(map[address.Address]cid.Cid)
+
+		lookupActorCode := func(a address.Address) (cid.Cid, error) {
+			c, ok := codeCache[a]
+			if ok {
+				return c, nil
+			}
+
+			act, err := api.StateGetActor(ctx, a, ts.Key())
+			if err != nil {
+				return cid.Undef, err
+			}
+
+			codeCache[a] = act.Code
+			return act.Code, nil
+		}
+
+		bySender := make(map[string]int64)
+		byDest := make(map[string]int64)
+		byMethod := make(map[string]int64)
+
+		var sum int64
+		for _, m := range msgs {
+			bySender[m.Message.From.String()] += m.Message.GasLimit
+			byDest[m.Message.To.String()] += m.Message.GasLimit
+			sum += m.Message.GasLimit
+
+			code, err := lookupActorCode(m.Message.To)
+			if err != nil {
+				return err
+			}
+
+			mm := stmgr.MethodsMap[code][m.Message.Method]
+
+			byMethod[mm.Name] += m.Message.GasLimit
+
+		}
+
+		type keyGasPair struct {
+			Key string
+			Gas int64
+		}
+
+		mapToSortedKvs := func(m map[string]int64) []keyGasPair {
+			var vals []keyGasPair
+			for k, v := range m {
+				vals = append(vals, keyGasPair{
+					Key: k,
+					Gas: v,
+				})
+			}
+			sort.Slice(vals, func(i, j int) bool {
+				return vals[i].Gas > vals[j].Gas
+			})
+			return vals
+		}
+
+		senderVals := mapToSortedKvs(bySender)
+		destVals := mapToSortedKvs(byDest)
+		methodVals := mapToSortedKvs(byMethod)
+
+		numRes := cctx.Int("num-results")
+
+		fmt.Printf("Total Gas Limit: %d\n", sum)
+		fmt.Printf("By Sender:\n")
+		for i := 0; i < numRes && i < len(senderVals); i++ {
+			sv := senderVals[i]
+			fmt.Printf("%s\t%0.2f%%\t(%d)\n", sv.Key, (100*float64(sv.Gas))/float64(sum), sv.Gas)
+		}
+		fmt.Println()
+		fmt.Printf("By Receiver:\n")
+		for i := 0; i < numRes && i < len(destVals); i++ {
+			sv := destVals[i]
+			fmt.Printf("%s\t%0.2f%%\t(%d)\n", sv.Key, (100*float64(sv.Gas))/float64(sum), sv.Gas)
+		}
+		fmt.Println()
+		fmt.Printf("By Method:\n")
+		for i := 0; i < numRes && i < len(methodVals); i++ {
+			sv := methodVals[i]
+			fmt.Printf("%s\t%0.2f%%\t(%d)\n", sv.Key, (100*float64(sv.Gas))/float64(sum), sv.Gas)
+		}
+
+		return nil
+	},
+}
+
 var chainListCmd = &cli.Command{
 	Name:  "list",
 	Usage: "View a segment of the chain",
@@ -648,7 +788,7 @@ var chainGetCmd = &cli.Command{
 
 type apiIpldStore struct {
 	ctx context.Context
-	api api.FullNode
+	api lapi.FullNode
 }
 
 func (ht *apiIpldStore) Context() context.Context {
@@ -676,7 +816,7 @@ func (ht *apiIpldStore) Put(ctx context.Context, v interface{}) (cid.Cid, error)
 	panic("No mutations allowed")
 }
 
-func handleAmt(ctx context.Context, api api.FullNode, r cid.Cid) error {
+func handleAmt(ctx context.Context, api lapi.FullNode, r cid.Cid) error {
 	s := &apiIpldStore{ctx, api}
 	mp, err := adt.AsArray(s, r)
 	if err != nil {
@@ -689,7 +829,7 @@ func handleAmt(ctx context.Context, api api.FullNode, r cid.Cid) error {
 	})
 }
 
-func handleHamtEpoch(ctx context.Context, api api.FullNode, r cid.Cid) error {
+func handleHamtEpoch(ctx context.Context, api lapi.FullNode, r cid.Cid) error {
 	s := &apiIpldStore{ctx, api}
 	mp, err := adt.AsMap(s, r)
 	if err != nil {
@@ -707,7 +847,7 @@ func handleHamtEpoch(ctx context.Context, api api.FullNode, r cid.Cid) error {
 	})
 }
 
-func handleHamtAddress(ctx context.Context, api api.FullNode, r cid.Cid) error {
+func handleHamtAddress(ctx context.Context, api lapi.FullNode, r cid.Cid) error {
 	s := &apiIpldStore{ctx, api}
 	mp, err := adt.AsMap(s, r)
 	if err != nil {
@@ -930,13 +1070,20 @@ var chainExportCmd = &cli.Command{
 			return err
 		}
 
+		var last bool
 		for b := range stream {
+			last = len(b) == 0
+
 			_, err := fi.Write(b)
 			if err != nil {
 				return err
 			}
 		}
 
+		if !last {
+			return xerrors.Errorf("incomplete export (remote connection lost?)")
+		}
+
 		return nil
 	},
 }

cli/client.go

@@ -12,13 +12,12 @@ import (
 	"text/tabwriter"
 	"time"
 
-	"github.com/filecoin-project/specs-actors/actors/builtin"
-
 	tm "github.com/buger/goterm"
 	"github.com/docker/go-units"
 	"github.com/fatih/color"
 	datatransfer "github.com/filecoin-project/go-data-transfer"
 	"github.com/filecoin-project/go-fil-markets/retrievalmarket"
+	"github.com/filecoin-project/specs-actors/actors/builtin"
 	"github.com/ipfs/go-cid"
 	"github.com/ipfs/go-cidutil/cidenc"
 	"github.com/libp2p/go-libp2p-core/peer"
@@ -476,6 +475,7 @@ func interactiveDeal(cctx *cli.Context) error {
 	var ask storagemarket.StorageAsk
 	var epochPrice big.Int
 	var epochs abi.ChainEpoch
+	var verified bool
 
 	var a address.Address
 	if from := cctx.String("from"); from != "" {
@@ -572,6 +572,53 @@ func interactiveDeal(cctx *cli.Context) error {
 			ask = *a
 
 			// TODO: run more validation
+			state = "verified"
+		case "verified":
+			ts, err := api.ChainHead(ctx)
+			if err != nil {
+				return err
+			}
+
+			dcap, err := api.StateVerifiedClientStatus(ctx, a, ts.Key())
+			if err != nil {
+				return err
+			}
+
+			if dcap == nil {
+				state = "confirm"
+				continue
+			}
+
+			color.Blue(".. checking verified deal eligibility\n")
+			ds, err := api.ClientDealSize(ctx, data)
+			if err != nil {
+				return err
+			}
+
+			if dcap.Uint64() < uint64(ds.PieceSize) {
+				color.Yellow(".. not enough DataCap available for a verified deal\n")
+				state = "confirm"
+				continue
+			}
+
+			fmt.Print("\nMake this a verified deal? (yes/no): ")
+
+			var yn string
+			_, err = fmt.Scan(&yn)
+			if err != nil {
+				return err
+			}
+
+			switch yn {
+			case "yes":
+				verified = true
+			case "no":
+				verified = false
+			default:
+				fmt.Println("Type in full 'yes' or 'no'")
+				continue
+			}
+
 			state = "confirm"
 		case "confirm":
 			fromBal, err := api.WalletBalance(ctx, a)
@@ -590,10 +637,15 @@ func interactiveDeal(cctx *cli.Context) error {
 			epochs = abi.ChainEpoch(dur / (time.Duration(build.BlockDelaySecs) * time.Second))
 			// TODO: do some more or epochs math (round to miner PP, deal start buffer)
 
+			pricePerGib := ask.Price
+			if verified {
+				pricePerGib = ask.VerifiedPrice
+			}
+
 			gib := types.NewInt(1 << 30)
 
 			// TODO: price is based on PaddedPieceSize, right?
-			epochPrice = types.BigDiv(types.BigMul(ask.Price, types.NewInt(uint64(ds.PieceSize))), gib)
+			epochPrice = types.BigDiv(types.BigMul(pricePerGib, types.NewInt(uint64(ds.PieceSize))), gib)
 			totalPrice := types.BigMul(epochPrice, types.NewInt(uint64(epochs)))
 
 			fmt.Printf("-----\n")
@@ -603,6 +655,7 @@ func interactiveDeal(cctx *cli.Context) error {
 			fmt.Printf("Piece size: %s (Payload size: %s)\n", units.BytesSize(float64(ds.PieceSize)), units.BytesSize(float64(ds.PayloadSize)))
 			fmt.Printf("Duration: %s\n", dur)
 			fmt.Printf("Total price: ~%s (%s per epoch)\n", types.FIL(totalPrice), types.FIL(epochPrice))
+			fmt.Printf("Verified: %v\n", verified)
 
 			state = "accept"
 		case "accept":
@@ -637,7 +690,7 @@ func interactiveDeal(cctx *cli.Context) error {
 				MinBlocksDuration: uint64(epochs),
 				DealStartEpoch:    abi.ChainEpoch(cctx.Int64("start-epoch")),
 				FastRetrieval:     cctx.Bool("fast-retrieval"),
-				VerifiedDeal:      false, // TODO: Allow setting
+				VerifiedDeal:      verified,
 			})
 			if err != nil {
 				return err

cli/cmd.go

@@ -216,6 +216,13 @@ func GetAPI(ctx *cli.Context) (api.Common, jsonrpc.ClientCloser, error) {
 		log.Errorf("repoType type does not match the type of repo.RepoType")
 	}
 
+	if tn, ok := ctx.App.Metadata["testnode-storage"]; ok {
+		return tn.(api.StorageMiner), func() {}, nil
+	}
+	if tn, ok := ctx.App.Metadata["testnode-full"]; ok {
+		return tn.(api.FullNode), func() {}, nil
+	}
+
 	addr, headers, err := GetRawAPI(ctx, t)
 	if err != nil {
 		return nil, nil, err
@@ -225,6 +232,10 @@ func GetAPI(ctx *cli.Context) (api.Common, jsonrpc.ClientCloser, error) {
 }
 
 func GetFullNodeAPI(ctx *cli.Context) (api.FullNode, jsonrpc.ClientCloser, error) {
+	if tn, ok := ctx.App.Metadata["testnode-full"]; ok {
+		return tn.(api.FullNode), func() {}, nil
+	}
+
 	addr, headers, err := GetRawAPI(ctx, repo.FullNode)
 	if err != nil {
 		return nil, nil, err
@@ -234,6 +245,10 @@ func GetFullNodeAPI(ctx *cli.Context) (api.FullNode, jsonrpc.ClientCloser, error
 }
 
 func GetStorageMinerAPI(ctx *cli.Context, opts ...jsonrpc.Option) (api.StorageMiner, jsonrpc.ClientCloser, error) {
+	if tn, ok := ctx.App.Metadata["testnode-storage"]; ok {
+		return tn.(api.StorageMiner), func() {}, nil
+	}
+
 	addr, headers, err := GetRawAPI(ctx, repo.StorageMiner)
 	if err != nil {
 		return nil, nil, err

cli/mpool.go

@@ -7,6 +7,7 @@ import (
 	"sort"
 	"strconv"
 
+	cid "github.com/ipfs/go-cid"
 	"github.com/urfave/cli/v2"
 	"golang.org/x/xerrors"
 
@@ -43,6 +44,10 @@ var mpoolPending = &cli.Command{
 			Name:  "local",
 			Usage: "print pending messages for addresses in local wallet only",
 		},
+		&cli.BoolFlag{
+			Name:  "cids",
+			Usage: "only print cids of messages in output",
+		},
 	},
 	Action: func(cctx *cli.Context) error {
 		api, closer, err := GetFullNodeAPI(cctx)
@@ -79,11 +84,15 @@ var mpoolPending = &cli.Command{
 				}
 			}
 
-			out, err := json.MarshalIndent(msg, "", "  ")
-			if err != nil {
-				return err
+			if cctx.Bool("cids") {
+				fmt.Println(msg.Cid())
+			} else {
+				out, err := json.MarshalIndent(msg, "", "  ")
+				if err != nil {
+					return err
+				}
+				fmt.Println(string(out))
 			}
-			fmt.Println(string(out))
 		}
 
 		return nil
@@ -155,14 +164,6 @@ var mpoolSub = &cli.Command{
 	},
 }
 
-type statBucket struct {
-	msgs map[uint64]*types.SignedMessage
-}
-type mpStat struct {
-	addr              string
-	past, cur, future uint64
-}
-
 var mpoolStat = &cli.Command{
 	Name:  "stat",
 	Usage: "print mempool stats",
@@ -171,6 +172,11 @@ var mpoolStat = &cli.Command{
 			Name:  "local",
 			Usage: "print stats for addresses in local wallet only",
 		},
+		&cli.IntFlag{
+			Name:  "basefee-lookback",
+			Usage: "number of blocks to look back for minimum basefee",
+			Value: 60,
+		},
 	},
 	Action: func(cctx *cli.Context) error {
 		api, closer, err := GetFullNodeAPI(cctx)
@@ -185,6 +191,20 @@ var mpoolStat = &cli.Command{
 		if err != nil {
 			return xerrors.Errorf("getting chain head: %w", err)
 		}
+		currBF := ts.Blocks()[0].ParentBaseFee
+		minBF := currBF
+		{
+			currTs := ts
+			for i := 0; i < cctx.Int("basefee-lookback"); i++ {
+				currTs, err = api.ChainGetTipSet(ctx, currTs.Parents())
+				if err != nil {
+					return xerrors.Errorf("walking chain: %w", err)
+				}
+				if newBF := currTs.Blocks()[0].ParentBaseFee; newBF.LessThan(minBF) {
+					minBF = newBF
+				}
+			}
+		}
 
 		var filter map[address.Address]struct{}
 		if cctx.Bool("local") {
@@ -205,8 +225,16 @@ var mpoolStat = &cli.Command{
 			return err
 		}
 
-		buckets := map[address.Address]*statBucket{}
+		type statBucket struct {
+			msgs map[uint64]*types.SignedMessage
+		}
+		type mpStat struct {
+			addr                 string
+			past, cur, future    uint64
+			belowCurr, belowPast uint64
+		}
 
+		buckets := map[address.Address]*statBucket{}
 		for _, v := range msgs {
 			if filter != nil {
 				if _, has := filter[v.Message.From]; !has {
@@ -243,23 +271,27 @@ var mpoolStat = &cli.Command{
 				cur++
 			}
 
-			past := uint64(0)
-			future := uint64(0)
+			var s mpStat
+			s.addr = a.String()
+
 			for _, m := range bkt.msgs {
 				if m.Message.Nonce < act.Nonce {
-					past++
+					s.past++
+				} else if m.Message.Nonce > cur {
+					s.future++
+				} else {
+					s.cur++
 				}
-				if m.Message.Nonce > cur {
-					future++
+
+				if m.Message.GasFeeCap.LessThan(currBF) {
+					s.belowCurr++
+				}
+				if m.Message.GasFeeCap.LessThan(minBF) {
+					s.belowPast++
 				}
 			}
 
-			out = append(out, mpStat{
-				addr:   a.String(),
-				past:   past,
-				cur:    cur - act.Nonce,
-				future: future,
-			})
+			out = append(out, s)
 		}
 
 		sort.Slice(out, func(i, j int) bool {
@@ -272,12 +304,14 @@ var mpoolStat = &cli.Command{
 			total.past += stat.past
 			total.cur += stat.cur
 			total.future += stat.future
+			total.belowCurr += stat.belowCurr
+			total.belowPast += stat.belowPast
 
-			fmt.Printf("%s: past: %d, cur: %d, future: %d\n", stat.addr, stat.past, stat.cur, stat.future)
+			fmt.Printf("%s: Nonce past: %d, cur: %d, future: %d; FeeCap cur: %d, min-%d: %d \n", stat.addr, stat.past, stat.cur, stat.future, stat.belowCurr, cctx.Int("basefee-lookback"), stat.belowPast)
 		}
 
 		fmt.Println("-----")
-		fmt.Printf("total: past: %d, cur: %d, future: %d\n", total.past, total.cur, total.future)
+		fmt.Printf("total: Nonce past: %d, cur: %d, future: %d; FeeCap cur: %d, min-%d: %d \n", total.past, total.cur, total.future, total.belowCurr, cctx.Int("basefee-lookback"), total.belowPast)
 
 		return nil
 	},
@@ -308,21 +342,8 @@ var mpoolReplaceCmd = &cli.Command{
 			Usage: "Spend up to X FIL for this message (applicable for auto mode)",
 		},
 	},
-	ArgsUsage: "[from] [nonce]",
+	ArgsUsage: "<from nonce> | <message-cid>",
 	Action: func(cctx *cli.Context) error {
-		if cctx.Args().Len() < 2 {
-			return cli.ShowCommandHelp(cctx, cctx.Command.Name)
-		}
-
-		from, err := address.NewFromString(cctx.Args().Get(0))
-		if err != nil {
-			return err
-		}
-
-		nonce, err := strconv.ParseUint(cctx.Args().Get(1), 10, 64)
-		if err != nil {
-			return err
-		}
 
 		api, closer, err := GetFullNodeAPI(cctx)
 		if err != nil {
@@ -332,6 +353,39 @@ var mpoolReplaceCmd = &cli.Command{
 
 		ctx := ReqContext(cctx)
 
+		var from address.Address
+		var nonce uint64
+		switch cctx.Args().Len() {
+		case 1:
+			mcid, err := cid.Decode(cctx.Args().First())
+			if err != nil {
+				return err
+			}
+
+			msg, err := api.ChainGetMessage(ctx, mcid)
+			if err != nil {
+				return fmt.Errorf("could not find referenced message: %w", err)
+			}
+
+			from = msg.From
+			nonce = msg.Nonce
+		case 2:
+			f, err := address.NewFromString(cctx.Args().Get(0))
+			if err != nil {
+				return err
+			}
+
+			n, err := strconv.ParseUint(cctx.Args().Get(1), 10, 64)
+			if err != nil {
+				return err
+			}
+
+			from = f
+			nonce = n
+		default:
+			return cli.ShowCommandHelp(cctx, cctx.Command.Name)
+		}
+
 		ts, err := api.ChainHead(ctx)
 		if err != nil {
 			return xerrors.Errorf("getting chain head: %w", err)

cli/multisig.go

@@ -9,6 +9,10 @@ import (
 	"strconv"
 	"text/tabwriter"
 
+	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
+
+	"github.com/filecoin-project/lotus/chain/actors/builtin"
+
 	"github.com/filecoin-project/lotus/chain/actors"
 
 	"github.com/filecoin-project/go-state-types/big"
@@ -20,7 +24,6 @@ import (
 	"github.com/urfave/cli/v2"
 	"golang.org/x/xerrors"
 
-	"github.com/filecoin-project/specs-actors/actors/builtin"
 	init0 "github.com/filecoin-project/specs-actors/actors/builtin/init"
 	msig0 "github.com/filecoin-project/specs-actors/actors/builtin/multisig"
 
@@ -356,7 +359,7 @@ var msigProposeCmd = &cli.Command{
 			return fmt.Errorf("failed to look up multisig %s: %w", msig, err)
 		}
 
-		if !act.IsMultisigActor() {
+		if !builtin.IsMultisigActor(act.Code) {
 			return fmt.Errorf("actor %s is not a multisig actor", msig)
 		}
 
@@ -1029,7 +1032,7 @@ var msigLockProposeCmd = &cli.Command{
 			return actErr
 		}
 
-		msgCid, err := api.MsigPropose(ctx, msig, msig, big.Zero(), from, uint64(builtin.MethodsMultisig.LockBalance), params)
+		msgCid, err := api.MsigPropose(ctx, msig, msig, big.Zero(), from, uint64(builtin2.MethodsMultisig.LockBalance), params)
 		if err != nil {
 			return err
 		}
@@ -1126,7 +1129,7 @@ var msigLockApproveCmd = &cli.Command{
 			return actErr
 		}
 
-		msgCid, err := api.MsigApprove(ctx, msig, txid, prop, msig, big.Zero(), from, uint64(builtin.MethodsMultisig.LockBalance), params)
+		msgCid, err := api.MsigApprove(ctx, msig, txid, prop, msig, big.Zero(), from, uint64(builtin2.MethodsMultisig.LockBalance), params)
 		if err != nil {
 			return err
 		}
@@ -1218,7 +1221,7 @@ var msigLockCancelCmd = &cli.Command{
 			return actErr
 		}
 
-		msgCid, err := api.MsigCancel(ctx, msig, txid, msig, big.Zero(), from, uint64(builtin.MethodsMultisig.LockBalance), params)
+		msgCid, err := api.MsigCancel(ctx, msig, txid, msig, big.Zero(), from, uint64(builtin2.MethodsMultisig.LockBalance), params)
 		if err != nil {
 			return err
 		}

cli/paych.go

@@ -14,10 +14,10 @@ import (
 
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/lotus/build"
-	"github.com/filecoin-project/specs-actors/actors/builtin/paych"
 	"github.com/urfave/cli/v2"
 
-	types "github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/paych"
+	"github.com/filecoin-project/lotus/chain/types"
 )
 
 var paychCmd = &cli.Command{
@@ -404,7 +404,7 @@ var paychVoucherCheckCmd = &cli.Command{
 			return err
 		}
 
-		sv, err := types.DecodeSignedVoucher(cctx.Args().Get(1))
+		sv, err := paych.DecodeSignedVoucher(cctx.Args().Get(1))
 		if err != nil {
 			return err
 		}
@@ -440,7 +440,7 @@ var paychVoucherAddCmd = &cli.Command{
 			return err
 		}
 
-		sv, err := types.DecodeSignedVoucher(cctx.Args().Get(1))
+		sv, err := paych.DecodeSignedVoucher(cctx.Args().Get(1))
 		if err != nil {
 			return err
 		}
@@ -598,7 +598,7 @@ var paychVoucherSubmitCmd = &cli.Command{
 			return err
 		}
 
-		sv, err := types.DecodeSignedVoucher(cctx.Args().Get(1))
+		sv, err := paych.DecodeSignedVoucher(cctx.Args().Get(1))
 		if err != nil {
 			return err
 		}

cli/state.go

@@ -14,7 +14,7 @@ import (
 	"strings"
 	"time"
 
-	"github.com/filecoin-project/specs-actors/actors/runtime"
+	"github.com/filecoin-project/lotus/chain/actors/builtin"
 
 	"github.com/multiformats/go-multiaddr"
 
@@ -30,8 +30,6 @@ import (
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/big"
 	"github.com/filecoin-project/go-state-types/exitcode"
-	"github.com/filecoin-project/specs-actors/actors/builtin"
-	"github.com/filecoin-project/specs-actors/actors/builtin/exported"
 
 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/api/apibstore"
@@ -1534,28 +1532,18 @@ func parseParamsForMethod(act cid.Cid, method uint64, args []string) ([]byte, er
 		return nil, nil
 	}
 
-	var target runtime.Invokee
-	for _, actor := range exported.BuiltinActors() {
-		if actor.Code() == act {
-			target = actor
-		}
-	}
-	if target == nil {
+	// TODO: consider moving this to a dedicated helper
+	actMeta, ok := stmgr.MethodsMap[act]
+	if !ok {
 		return nil, fmt.Errorf("unknown actor %s", act)
 	}
-	methods := target.Exports()
-	if uint64(len(methods)) <= method || methods[method] == nil {
+
+	methodMeta, ok := actMeta[abi.MethodNum(method)]
+	if !ok {
 		return nil, fmt.Errorf("unknown method %d for actor %s", method, act)
 	}
 
-	f := methods[method]
-
-	rf := reflect.TypeOf(f)
-	if rf.NumIn() != 2 {
-		return nil, fmt.Errorf("expected referenced method to have three arguments")
-	}
-
-	paramObj := rf.In(1).Elem()
+	paramObj := methodMeta.Params
 	if paramObj.NumField() != len(args) {
 		return nil, fmt.Errorf("not enough arguments given to call that method (expecting %d)", paramObj.NumField())
 	}

cmd/lotus-chainwatch/processor/common_actors.go

@@ -9,12 +9,15 @@ import (
 
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/ipfs/go-cid"
+
+	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
+
+	"github.com/filecoin-project/lotus/chain/actors/builtin"
 	_init "github.com/filecoin-project/lotus/chain/actors/builtin/init"
 	"github.com/filecoin-project/lotus/chain/events/state"
 	"github.com/filecoin-project/lotus/chain/types"
 	cw_util "github.com/filecoin-project/lotus/cmd/lotus-chainwatch/util"
-	"github.com/filecoin-project/specs-actors/actors/builtin"
-	"github.com/ipfs/go-cid"
 )
 
 func (p *Processor) setupCommonActors() error {
@@ -135,15 +138,15 @@ func (p Processor) storeActorAddresses(ctx context.Context, actors map[cid.Cid]A
 
 	addressToID := map[address.Address]address.Address{}
 	// HACK until genesis storage is figured out:
-	addressToID[builtin.SystemActorAddr] = builtin.SystemActorAddr
-	addressToID[builtin.InitActorAddr] = builtin.InitActorAddr
-	addressToID[builtin.RewardActorAddr] = builtin.RewardActorAddr
-	addressToID[builtin.CronActorAddr] = builtin.CronActorAddr
-	addressToID[builtin.StoragePowerActorAddr] = builtin.StoragePowerActorAddr
-	addressToID[builtin.StorageMarketActorAddr] = builtin.StorageMarketActorAddr
-	addressToID[builtin.VerifiedRegistryActorAddr] = builtin.VerifiedRegistryActorAddr
-	addressToID[builtin.BurntFundsActorAddr] = builtin.BurntFundsActorAddr
-	initActor, err := p.node.StateGetActor(ctx, builtin.InitActorAddr, types.EmptyTSK)
+	addressToID[builtin2.SystemActorAddr] = builtin2.SystemActorAddr
+	addressToID[builtin2.InitActorAddr] = builtin2.InitActorAddr
+	addressToID[builtin2.RewardActorAddr] = builtin2.RewardActorAddr
+	addressToID[builtin2.CronActorAddr] = builtin2.CronActorAddr
+	addressToID[builtin2.StoragePowerActorAddr] = builtin2.StoragePowerActorAddr
+	addressToID[builtin2.StorageMarketActorAddr] = builtin2.StorageMarketActorAddr
+	addressToID[builtin2.VerifiedRegistryActorAddr] = builtin2.VerifiedRegistryActorAddr
+	addressToID[builtin2.BurntFundsActorAddr] = builtin2.BurntFundsActorAddr
+	initActor, err := p.node.StateGetActor(ctx, builtin2.InitActorAddr, types.EmptyTSK)
 	if err != nil {
 		return err
 	}

cmd/lotus-gateway/api.go

@@ -86,5 +86,5 @@ func (a *GatewayAPI) MpoolPush(ctx context.Context, sm *types.SignedMessage) (ci
 
 	// TODO: additional anti-spam checks
 
-	return a.api.MpoolPush(ctx, sm)
+	return a.api.MpoolPushUntrusted(ctx, sm)
 }

cmd/lotus-pcr/main.go

@@ -1,8 +1,10 @@
 package main
 
 import (
+	"bufio"
 	"bytes"
 	"context"
+	"encoding/csv"
 	"fmt"
 	"io/ioutil"
 	"net/http"
@@ -12,7 +14,9 @@ import (
 	"strconv"
 	"time"
 
-	"github.com/filecoin-project/specs-actors/actors/builtin"
+	"github.com/filecoin-project/lotus/chain/actors/builtin"
+	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
+
 	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
 
 	"github.com/filecoin-project/go-state-types/network"
@@ -25,11 +29,12 @@ import (
 
 	"golang.org/x/xerrors"
 
+	"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/big"
 	"github.com/filecoin-project/go-state-types/exitcode"
 
-	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
@@ -42,6 +47,8 @@ var log = logging.Logger("main")
 func main() {
 	local := []*cli.Command{
 		runCmd,
+		recoverMinersCmd,
+		findMinersCmd,
 		versionCmd,
 	}
 
@@ -105,6 +112,186 @@ var versionCmd = &cli.Command{
 	},
 }
 
+var findMinersCmd = &cli.Command{
+	Name:  "find-miners",
+	Usage: "find miners with a desired minimum balance",
+	Description: `Find miners returns a list of miners and their balances that are below a
+   threhold value. By default only the miner actor available balance is considered but other
+   account balances can be included by enabling them through the flags.
+
+   Examples
+   Find all miners with an available balance below 100 FIL
+
+     lotus-pcr find-miners --threshold 100
+
+   Find all miners with a balance below zero, which includes the owner and worker balances
+
+     lotus-pcr find-miners --threshold 0 --owner --worker
+`,
+	Flags: []cli.Flag{
+		&cli.BoolFlag{
+			Name:    "no-sync",
+			EnvVars: []string{"LOTUS_PCR_NO_SYNC"},
+			Usage:   "do not wait for chain sync to complete",
+		},
+		&cli.IntFlag{
+			Name:    "threshold",
+			EnvVars: []string{"LOTUS_PCR_THRESHOLD"},
+			Usage:   "balance below this limit will be printed",
+			Value:   0,
+		},
+		&cli.BoolFlag{
+			Name:  "owner",
+			Usage: "include owner balance",
+			Value: false,
+		},
+		&cli.BoolFlag{
+			Name:  "worker",
+			Usage: "include worker balance",
+			Value: false,
+		},
+		&cli.BoolFlag{
+			Name:  "control",
+			Usage: "include control balance",
+			Value: false,
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		ctx := context.Background()
+		api, closer, err := stats.GetFullNodeAPI(cctx.Context, cctx.String("lotus-path"))
+		if err != nil {
+			log.Fatal(err)
+		}
+		defer closer()
+
+		if !cctx.Bool("no-sync") {
+			if err := stats.WaitForSyncComplete(ctx, api); err != nil {
+				log.Fatal(err)
+			}
+		}
+
+		owner := cctx.Bool("owner")
+		worker := cctx.Bool("worker")
+		control := cctx.Bool("control")
+		threshold := uint64(cctx.Int("threshold"))
+
+		rf := &refunder{
+			api:       api,
+			threshold: types.FromFil(threshold),
+		}
+
+		refundTipset, err := api.ChainHead(ctx)
+		if err != nil {
+			return err
+		}
+
+		balanceRefund, err := rf.FindMiners(ctx, refundTipset, NewMinersRefund(), owner, worker, control)
+		if err != nil {
+			return err
+		}
+
+		for _, maddr := range balanceRefund.Miners() {
+			fmt.Printf("%s\t%s\n", maddr, types.FIL(balanceRefund.GetRefund(maddr)))
+		}
+
+		return nil
+	},
+}
+
+var recoverMinersCmd = &cli.Command{
+	Name:  "recover-miners",
+	Usage: "Ensure all miners with a negative available balance have a FIL surplus across accounts",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:    "from",
+			EnvVars: []string{"LOTUS_PCR_FROM"},
+			Usage:   "wallet address to send refund from",
+		},
+		&cli.BoolFlag{
+			Name:    "no-sync",
+			EnvVars: []string{"LOTUS_PCR_NO_SYNC"},
+			Usage:   "do not wait for chain sync to complete",
+		},
+		&cli.BoolFlag{
+			Name:    "dry-run",
+			EnvVars: []string{"LOTUS_PCR_DRY_RUN"},
+			Usage:   "do not send any messages",
+			Value:   false,
+		},
+		&cli.StringFlag{
+			Name:  "output",
+			Usage: "dump data as a csv format to this file",
+		},
+		&cli.IntFlag{
+			Name:    "miner-recovery-cutoff",
+			EnvVars: []string{"LOTUS_PCR_MINER_RECOVERY_CUTOFF"},
+			Usage:   "maximum amount of FIL that can be sent to any one miner before refund percent is applied",
+			Value:   3000,
+		},
+		&cli.IntFlag{
+			Name:    "miner-recovery-bonus",
+			EnvVars: []string{"LOTUS_PCR_MINER_RECOVERY_BONUS"},
+			Usage:   "additional FIL to send to each miner",
+			Value:   5,
+		},
+		&cli.IntFlag{
+			Name:    "miner-recovery-refund-percent",
+			EnvVars: []string{"LOTUS_PCR_MINER_RECOVERY_REFUND_PERCENT"},
+			Usage:   "percent of refund to issue",
+			Value:   110,
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		ctx := context.Background()
+		api, closer, err := stats.GetFullNodeAPI(cctx.Context, cctx.String("lotus-path"))
+		if err != nil {
+			log.Fatal(err)
+		}
+		defer closer()
+
+		from, err := address.NewFromString(cctx.String("from"))
+		if err != nil {
+			return xerrors.Errorf("parsing source address (provide correct --from flag!): %w", err)
+		}
+
+		if !cctx.Bool("no-sync") {
+			if err := stats.WaitForSyncComplete(ctx, api); err != nil {
+				log.Fatal(err)
+			}
+		}
+
+		dryRun := cctx.Bool("dry-run")
+		minerRecoveryRefundPercent := cctx.Int("miner-recovery-refund-percent")
+		minerRecoveryCutoff := uint64(cctx.Int("miner-recovery-cutoff"))
+		minerRecoveryBonus := uint64(cctx.Int("miner-recovery-bonus"))
+
+		rf := &refunder{
+			api:                        api,
+			wallet:                     from,
+			dryRun:                     dryRun,
+			minerRecoveryRefundPercent: minerRecoveryRefundPercent,
+			minerRecoveryCutoff:        types.FromFil(minerRecoveryCutoff),
+			minerRecoveryBonus:         types.FromFil(minerRecoveryBonus),
+		}
+
+		refundTipset, err := api.ChainHead(ctx)
+		if err != nil {
+			return err
+		}
+
+		balanceRefund, err := rf.EnsureMinerMinimums(ctx, refundTipset, NewMinersRefund(), cctx.String("output"))
+		if err != nil {
+			return err
+		}
+
+		if err := rf.Refund(ctx, "refund to recover miner", refundTipset, balanceRefund, 0); err != nil {
+			return err
+		}
+
+		return nil
+	},
+}
+
 var runCmd = &cli.Command{
 	Name:  "run",
 	Usage: "Start message reimpursement",
@@ -120,10 +307,10 @@ var runCmd = &cli.Command{
 			Usage:   "do not wait for chain sync to complete",
 		},
 		&cli.IntFlag{
-			Name:    "percent-extra",
-			EnvVars: []string{"LOTUS_PCR_PERCENT_EXTRA"},
-			Usage:   "extra funds to send above the refund",
-			Value:   3,
+			Name:    "refund-percent",
+			EnvVars: []string{"LOTUS_PCR_REFUND_PERCENT"},
+			Usage:   "percent of refund to issue",
+			Value:   103,
 		},
 		&cli.IntFlag{
 			Name:    "max-message-queue",
@@ -161,6 +348,36 @@ var runCmd = &cli.Command{
 			Usage:   "the number of tipsets to delay message processing to smooth chain reorgs",
 			Value:   int(build.MessageConfidence),
 		},
+		&cli.BoolFlag{
+			Name:    "miner-recovery",
+			EnvVars: []string{"LOTUS_PCR_MINER_RECOVERY"},
+			Usage:   "run the miner recovery job",
+			Value:   false,
+		},
+		&cli.IntFlag{
+			Name:    "miner-recovery-period",
+			EnvVars: []string{"LOTUS_PCR_MINER_RECOVERY_PERIOD"},
+			Usage:   "interval between running miner recovery",
+			Value:   2880,
+		},
+		&cli.IntFlag{
+			Name:    "miner-recovery-cutoff",
+			EnvVars: []string{"LOTUS_PCR_MINER_RECOVERY_CUTOFF"},
+			Usage:   "maximum amount of FIL that can be sent to any one miner before refund percent is applied",
+			Value:   3000,
+		},
+		&cli.IntFlag{
+			Name:    "miner-recovery-bonus",
+			EnvVars: []string{"LOTUS_PCR_MINER_RECOVERY_BONUS"},
+			Usage:   "additional FIL to send to each miner",
+			Value:   5,
+		},
+		&cli.IntFlag{
+			Name:    "miner-recovery-refund-percent",
+			EnvVars: []string{"LOTUS_PCR_MINER_RECOVERY_REFUND_PERCENT"},
+			Usage:   "percent of refund to issue",
+			Value:   110,
+		},
 	},
 	Action: func(cctx *cli.Context) error {
 		go func() {
@@ -199,24 +416,33 @@ var runCmd = &cli.Command{
 			log.Fatal(err)
 		}
 
-		percentExtra := cctx.Int("percent-extra")
+		refundPercent := cctx.Int("refund-percent")
 		maxMessageQueue := cctx.Int("max-message-queue")
 		dryRun := cctx.Bool("dry-run")
 		preCommitEnabled := cctx.Bool("pre-commit")
 		proveCommitEnabled := cctx.Bool("prove-commit")
 		aggregateTipsets := cctx.Int("aggregate-tipsets")
+		minerRecoveryEnabled := cctx.Bool("miner-recovery")
+		minerRecoveryPeriod := abi.ChainEpoch(int64(cctx.Int("miner-recovery-period")))
+		minerRecoveryRefundPercent := cctx.Int("miner-recovery-refund-percent")
+		minerRecoveryCutoff := uint64(cctx.Int("miner-recovery-cutoff"))
+		minerRecoveryBonus := uint64(cctx.Int("miner-recovery-bonus"))
 
 		rf := &refunder{
-			api:                api,
-			wallet:             from,
-			percentExtra:       percentExtra,
-			dryRun:             dryRun,
-			preCommitEnabled:   preCommitEnabled,
-			proveCommitEnabled: proveCommitEnabled,
+			api:                        api,
+			wallet:                     from,
+			refundPercent:              refundPercent,
+			minerRecoveryRefundPercent: minerRecoveryRefundPercent,
+			minerRecoveryCutoff:        types.FromFil(minerRecoveryCutoff),
+			minerRecoveryBonus:         types.FromFil(minerRecoveryBonus),
+			dryRun:                     dryRun,
+			preCommitEnabled:           preCommitEnabled,
+			proveCommitEnabled:         proveCommitEnabled,
 		}
 
 		var refunds *MinersRefund = NewMinersRefund()
 		var rounds int = 0
+		nextMinerRecovery := r.MinerRecoveryHeight() + minerRecoveryPeriod
 
 		for tipset := range tipsetsCh {
 			refunds, err = rf.ProcessTipset(ctx, tipset, refunds)
@@ -224,17 +450,34 @@ var runCmd = &cli.Command{
 				return err
 			}
 
-			rounds = rounds + 1
-			if rounds < aggregateTipsets {
-				continue
-			}
-
 			refundTipset, err := api.ChainHead(ctx)
 			if err != nil {
 				return err
 			}
 
-			if err := rf.Refund(ctx, refundTipset, refunds, rounds); err != nil {
+			if minerRecoveryEnabled && refundTipset.Height() >= nextMinerRecovery {
+				recoveryRefund, err := rf.EnsureMinerMinimums(ctx, refundTipset, NewMinersRefund(), "")
+				if err != nil {
+					return err
+				}
+
+				if err := rf.Refund(ctx, "refund to recover miners", refundTipset, recoveryRefund, 0); err != nil {
+					return err
+				}
+
+				if err := r.SetMinerRecoveryHeight(tipset.Height()); err != nil {
+					return err
+				}
+
+				nextMinerRecovery = r.MinerRecoveryHeight() + minerRecoveryPeriod
+			}
+
+			rounds = rounds + 1
+			if rounds < aggregateTipsets {
+				continue
+			}
+
+			if err := rf.Refund(ctx, "refund stats", refundTipset, refunds, rounds); err != nil {
 				return err
 			}
 
@@ -293,7 +536,6 @@ func (m *MinersRefund) Track(addr address.Address, value types.BigInt) {
 
 	m.count = m.count + 1
 	m.totalRefunds = types.BigAdd(m.totalRefunds, value)
-
 	m.refunds[addr] = types.BigAdd(m.refunds[addr], value)
 }
 
@@ -322,8 +564,14 @@ type refunderNodeApi interface {
 	ChainGetParentMessages(ctx context.Context, blockCid cid.Cid) ([]api.Message, error)
 	ChainGetParentReceipts(ctx context.Context, blockCid cid.Cid) ([]*types.MessageReceipt, error)
 	ChainGetTipSetByHeight(ctx context.Context, epoch abi.ChainEpoch, tsk types.TipSetKey) (*types.TipSet, error)
+	ChainReadObj(context.Context, cid.Cid) ([]byte, error)
 	StateMinerInitialPledgeCollateral(ctx context.Context, addr address.Address, precommitInfo miner.SectorPreCommitInfo, tsk types.TipSetKey) (types.BigInt, error)
+	StateMinerInfo(context.Context, address.Address, types.TipSetKey) (miner.MinerInfo, error)
 	StateSectorPreCommitInfo(ctx context.Context, addr address.Address, sector abi.SectorNumber, tsk types.TipSetKey) (miner.SectorPreCommitOnChainInfo, error)
+	StateMinerAvailableBalance(context.Context, address.Address, types.TipSetKey) (types.BigInt, error)
+	StateMinerSectors(ctx context.Context, addr address.Address, filter *bitfield.BitField, tsk types.TipSetKey) ([]*miner.SectorOnChainInfo, error)
+	StateMinerFaults(ctx context.Context, addr address.Address, tsk types.TipSetKey) (bitfield.BitField, error)
+	StateListMiners(context.Context, types.TipSetKey) ([]address.Address, error)
 	StateGetActor(ctx context.Context, actor address.Address, tsk types.TipSetKey) (*types.Actor, error)
 	StateNetworkVersion(ctx context.Context, tsk types.TipSetKey) (network.Version, error)
 	MpoolPushMessage(ctx context.Context, msg *types.Message, spec *api.MessageSendSpec) (*types.SignedMessage, error)
@@ -332,12 +580,241 @@ type refunderNodeApi interface {
 }
 
 type refunder struct {
-	api                refunderNodeApi
-	wallet             address.Address
-	percentExtra       int
-	dryRun             bool
-	preCommitEnabled   bool
-	proveCommitEnabled bool
+	api                        refunderNodeApi
+	wallet                     address.Address
+	refundPercent              int
+	minerRecoveryRefundPercent int
+	minerRecoveryCutoff        big.Int
+	minerRecoveryBonus         big.Int
+	dryRun                     bool
+	preCommitEnabled           bool
+	proveCommitEnabled         bool
+	threshold                  big.Int
+}
+
+func (r *refunder) FindMiners(ctx context.Context, tipset *types.TipSet, refunds *MinersRefund, owner, worker, control bool) (*MinersRefund, error) {
+	miners, err := r.api.StateListMiners(ctx, tipset.Key())
+	if err != nil {
+		return nil, err
+	}
+
+	for _, maddr := range miners {
+		mact, err := r.api.StateGetActor(ctx, maddr, types.EmptyTSK)
+		if err != nil {
+			log.Errorw("failed", "err", err, "height", tipset.Height(), "key", tipset.Key(), "miner", maddr)
+			continue
+		}
+
+		if !mact.Balance.GreaterThan(big.Zero()) {
+			continue
+		}
+
+		minerAvailableBalance, err := r.api.StateMinerAvailableBalance(ctx, maddr, tipset.Key())
+		if err != nil {
+			log.Errorw("failed", "err", err, "height", tipset.Height(), "key", tipset.Key(), "miner", maddr)
+			continue
+		}
+
+		// Look up and find all addresses associated with the miner
+		minerInfo, err := r.api.StateMinerInfo(ctx, maddr, tipset.Key())
+		if err != nil {
+			log.Errorw("failed", "err", err, "height", tipset.Height(), "key", tipset.Key(), "miner", maddr)
+			continue
+		}
+
+		allAddresses := []address.Address{}
+
+		if worker {
+			allAddresses = append(allAddresses, minerInfo.Worker)
+		}
+
+		if owner {
+			allAddresses = append(allAddresses, minerInfo.Owner)
+		}
+
+		if control {
+			allAddresses = append(allAddresses, minerInfo.ControlAddresses...)
+		}
+
+		// Sum the balancer of all the addresses
+		addrSum := big.Zero()
+		addrCheck := make(map[address.Address]struct{}, len(allAddresses))
+		for _, addr := range allAddresses {
+			if _, found := addrCheck[addr]; !found {
+				balance, err := r.api.WalletBalance(ctx, addr)
+				if err != nil {
+					log.Errorw("failed", "err", err, "height", tipset.Height(), "key", tipset.Key(), "miner", maddr)
+					continue
+				}
+
+				addrSum = big.Add(addrSum, balance)
+				addrCheck[addr] = struct{}{}
+			}
+		}
+
+		totalAvailableBalance := big.Add(addrSum, minerAvailableBalance)
+
+		if totalAvailableBalance.GreaterThanEqual(r.threshold) {
+			continue
+		}
+
+		refunds.Track(maddr, totalAvailableBalance)
+
+		log.Debugw("processing miner", "miner", maddr, "sectors", "available_balance", totalAvailableBalance)
+	}
+
+	return refunds, nil
+}
+
+func (r *refunder) EnsureMinerMinimums(ctx context.Context, tipset *types.TipSet, refunds *MinersRefund, output string) (*MinersRefund, error) {
+	miners, err := r.api.StateListMiners(ctx, tipset.Key())
+	if err != nil {
+		return nil, err
+	}
+
+	w := ioutil.Discard
+	if len(output) != 0 {
+		f, err := os.Create(output)
+		if err != nil {
+			return nil, err
+		}
+
+		defer f.Close() // nolint:errcheck
+
+		w = bufio.NewWriter(f)
+	}
+
+	csvOut := csv.NewWriter(w)
+	defer csvOut.Flush()
+	if err := csvOut.Write([]string{"MinerID", "FaultedSectors", "AvailableBalance", "ProposedRefund"}); err != nil {
+		return nil, err
+	}
+
+	for _, maddr := range miners {
+		mact, err := r.api.StateGetActor(ctx, maddr, types.EmptyTSK)
+		if err != nil {
+			log.Errorw("failed", "err", err, "height", tipset.Height(), "key", tipset.Key(), "miner", maddr)
+			continue
+		}
+
+		if !mact.Balance.GreaterThan(big.Zero()) {
+			continue
+		}
+
+		minerAvailableBalance, err := r.api.StateMinerAvailableBalance(ctx, maddr, tipset.Key())
+		if err != nil {
+			log.Errorw("failed", "err", err, "height", tipset.Height(), "key", tipset.Key(), "miner", maddr)
+			continue
+		}
+
+		// Look up and find all addresses associated with the miner
+		minerInfo, err := r.api.StateMinerInfo(ctx, maddr, tipset.Key())
+		if err != nil {
+			log.Errorw("failed", "err", err, "height", tipset.Height(), "key", tipset.Key(), "miner", maddr)
+			continue
+		}
+
+		allAddresses := []address.Address{minerInfo.Worker, minerInfo.Owner}
+		allAddresses = append(allAddresses, minerInfo.ControlAddresses...)
+
+		// Sum the balancer of all the addresses
+		addrSum := big.Zero()
+		addrCheck := make(map[address.Address]struct{}, len(allAddresses))
+		for _, addr := range allAddresses {
+			if _, found := addrCheck[addr]; !found {
+				balance, err := r.api.WalletBalance(ctx, addr)
+				if err != nil {
+					log.Errorw("failed", "err", err, "height", tipset.Height(), "key", tipset.Key(), "miner", maddr)
+					continue
+				}
+
+				addrSum = big.Add(addrSum, balance)
+				addrCheck[addr] = struct{}{}
+			}
+		}
+
+		faults, err := r.api.StateMinerFaults(ctx, maddr, tipset.Key())
+		if err != nil {
+			log.Errorw("failed to look up miner faults", "err", err, "height", tipset.Height(), "key", tipset.Key(), "miner", maddr)
+			continue
+		}
+
+		faultsCount, err := faults.Count()
+		if err != nil {
+			log.Errorw("failed to get count of faults", "err", err, "height", tipset.Height(), "key", tipset.Key(), "miner", maddr)
+			continue
+		}
+
+		if faultsCount == 0 {
+			log.Debugw("skipping miner with zero faults", "height", tipset.Height(), "key", tipset.Key(), "miner", maddr)
+			continue
+		}
+
+		totalAvailableBalance := big.Add(addrSum, minerAvailableBalance)
+		balanceCutoff := big.Mul(big.Div(big.NewIntUnsigned(faultsCount), big.NewInt(10)), big.NewIntUnsigned(build.FilecoinPrecision))
+
+		if totalAvailableBalance.GreaterThan(balanceCutoff) {
+			log.Debugw(
+				"skipping over miner with total available balance larger than refund",
+				"height", tipset.Height(),
+				"key", tipset.Key(),
+				"miner", maddr,
+				"available_balance", totalAvailableBalance,
+				"balance_cutoff", balanceCutoff,
+				"faults_count", faultsCount,
+				"available_balance_fil", big.Div(totalAvailableBalance, big.NewIntUnsigned(build.FilecoinPrecision)).Int64(),
+				"balance_cutoff_fil", big.Div(balanceCutoff, big.NewIntUnsigned(build.FilecoinPrecision)).Int64(),
+			)
+			continue
+		}
+
+		refundValue := big.Sub(balanceCutoff, totalAvailableBalance)
+		if r.minerRecoveryRefundPercent > 0 {
+			refundValue = types.BigMul(types.BigDiv(refundValue, types.NewInt(100)), types.NewInt(uint64(r.minerRecoveryRefundPercent)))
+		}
+
+		refundValue = big.Add(refundValue, r.minerRecoveryBonus)
+
+		if refundValue.GreaterThan(r.minerRecoveryCutoff) {
+			log.Infow(
+				"skipping over miner with refund greater than refund cutoff",
+				"height", tipset.Height(),
+				"key", tipset.Key(),
+				"miner", maddr,
+				"available_balance", totalAvailableBalance,
+				"balance_cutoff", balanceCutoff,
+				"faults_count", faultsCount,
+				"refund", refundValue,
+				"available_balance_fil", big.Div(totalAvailableBalance, big.NewIntUnsigned(build.FilecoinPrecision)).Int64(),
+				"balance_cutoff_fil", big.Div(balanceCutoff, big.NewIntUnsigned(build.FilecoinPrecision)).Int64(),
+				"refund_fil", big.Div(refundValue, big.NewIntUnsigned(build.FilecoinPrecision)).Int64(),
+			)
+			continue
+		}
+
+		refunds.Track(maddr, refundValue)
+		record := []string{
+			maddr.String(),
+			fmt.Sprintf("%d", faultsCount),
+			big.Div(totalAvailableBalance, big.NewIntUnsigned(build.FilecoinPrecision)).String(),
+			big.Div(refundValue, big.NewIntUnsigned(build.FilecoinPrecision)).String(),
+		}
+		if err := csvOut.Write(record); err != nil {
+			return nil, err
+		}
+
+		log.Debugw(
+			"processing miner",
+			"miner", maddr,
+			"faults_count", faultsCount,
+			"available_balance", totalAvailableBalance,
+			"refund", refundValue,
+			"available_balance_fil", big.Div(totalAvailableBalance, big.NewIntUnsigned(build.FilecoinPrecision)).Int64(),
+			"refund_fil", big.Div(refundValue, big.NewIntUnsigned(build.FilecoinPrecision)).Int64(),
+		)
+	}
+
+	return refunds, nil
 }
 
 func (r *refunder) ProcessTipset(ctx context.Context, tipset *types.TipSet, refunds *MinersRefund) (*MinersRefund, error) {
@@ -375,14 +852,14 @@ func (r *refunder) ProcessTipset(ctx context.Context, tipset *types.TipSet, refu
 			continue
 		}
 
-		if !a.IsStorageMinerActor() {
+		if !builtin.IsStorageMinerActor(a.Code) {
 			continue
 		}
 
 		var messageMethod string
 
 		switch m.Method {
-		case builtin.MethodsMiner.ProveCommitSector:
+		case builtin0.MethodsMiner.ProveCommitSector:
 			if !r.proveCommitEnabled {
 				continue
 			}
@@ -429,7 +906,7 @@ func (r *refunder) ProcessTipset(ctx context.Context, tipset *types.TipSet, refu
 			}
 
 			refundValue = collateral
-		case builtin.MethodsMiner.PreCommitSector:
+		case builtin0.MethodsMiner.PreCommitSector:
 			if !r.preCommitEnabled {
 				continue
 			}
@@ -458,22 +935,41 @@ func (r *refunder) ProcessTipset(ctx context.Context, tipset *types.TipSet, refu
 			continue
 		}
 
-		if r.percentExtra > 0 {
-			refundValue = types.BigAdd(refundValue, types.BigMul(types.BigDiv(refundValue, types.NewInt(100)), types.NewInt(uint64(r.percentExtra))))
+		if r.refundPercent > 0 {
+			refundValue = types.BigMul(types.BigDiv(refundValue, types.NewInt(100)), types.NewInt(uint64(r.refundPercent)))
 		}
 
-		log.Debugw("processing message", "method", messageMethod, "cid", msg.Cid, "from", m.From, "to", m.To, "value", m.Value, "gas_fee_cap", m.GasFeeCap, "gas_premium", m.GasPremium, "gas_used", recps[i].GasUsed, "refund", refundValue)
+		log.Debugw(
+			"processing message",
+			"method", messageMethod,
+			"cid", msg.Cid,
+			"from", m.From,
+			"to", m.To,
+			"value", m.Value,
+			"gas_fee_cap", m.GasFeeCap,
+			"gas_premium", m.GasPremium,
+			"gas_used", recps[i].GasUsed,
+			"refund", refundValue,
+			"refund_fil", big.Div(refundValue, big.NewIntUnsigned(build.FilecoinPrecision)).Int64(),
+		)
 
 		refunds.Track(m.From, refundValue)
 		tipsetRefunds.Track(m.From, refundValue)
 	}
 
-	log.Infow("tipset stats", "height", tipset.Height(), "key", tipset.Key(), "total_refunds", tipsetRefunds.TotalRefunds(), "messages_processed", tipsetRefunds.Count())
+	log.Infow(
+		"tipset stats",
+		"height", tipset.Height(),
+		"key", tipset.Key(),
+		"total_refunds", tipsetRefunds.TotalRefunds(),
+		"total_refunds_fil", big.Div(tipsetRefunds.TotalRefunds(), big.NewIntUnsigned(build.FilecoinPrecision)).Int64(),
+		"messages_processed", tipsetRefunds.Count(),
+	)
 
 	return refunds, nil
 }
 
-func (r *refunder) Refund(ctx context.Context, tipset *types.TipSet, refunds *MinersRefund, rounds int) error {
+func (r *refunder) Refund(ctx context.Context, name string, tipset *types.TipSet, refunds *MinersRefund, rounds int) error {
 	if refunds.Count() == 0 {
 		log.Debugw("no messages to refund in tipset", "height", tipset.Height(), "key", tipset.Key())
 		return nil
@@ -531,13 +1027,24 @@ func (r *refunder) Refund(ctx context.Context, tipset *types.TipSet, refunds *Mi
 		refundSum = types.BigAdd(refundSum, msg.Value)
 	}
 
-	log.Infow("refund stats", "tipsets_processed", rounds, "height", tipset.Height(), "key", tipset.Key(), "messages_sent", len(messages)-failures, "refund_sum", refundSum, "messages_failures", failures, "messages_processed", refunds.Count())
+	log.Infow(
+		name,
+		"tipsets_processed", rounds,
+		"height", tipset.Height(),
+		"key", tipset.Key(),
+		"messages_sent", len(messages)-failures,
+		"refund_sum", refundSum,
+		"refund_sum_fil", big.Div(refundSum, big.NewIntUnsigned(build.FilecoinPrecision)).Int64(),
+		"messages_failures", failures,
+		"messages_processed", refunds.Count(),
+	)
 	return nil
 }
 
 type Repo struct {
-	last abi.ChainEpoch
-	path string
+	lastHeight              abi.ChainEpoch
+	lastMinerRecoveryHeight abi.ChainEpoch
+	path                    string
 }
 
 func NewRepo(path string) (*Repo, error) {
@@ -547,8 +1054,9 @@ func NewRepo(path string) (*Repo, error) {
 	}
 
 	return &Repo{
-		last: 0,
-		path: path,
+		lastHeight:              0,
+		lastMinerRecoveryHeight: 0,
+		path:                    path,
 	}, nil
 }
 
@@ -579,43 +1087,66 @@ func (r *Repo) init() error {
 	return nil
 }
 
-func (r *Repo) Open() (err error) {
-	if err = r.init(); err != nil {
-		return
+func (r *Repo) Open() error {
+	if err := r.init(); err != nil {
+		return err
 	}
 
-	var f *os.File
+	if err := r.loadHeight(); err != nil {
+		return err
+	}
 
-	f, err = os.OpenFile(filepath.Join(r.path, "height"), os.O_RDWR|os.O_CREATE, 0644)
+	if err := r.loadMinerRecoveryHeight(); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func loadChainEpoch(fn string) (abi.ChainEpoch, error) {
+	f, err := os.OpenFile(fn, os.O_RDWR|os.O_CREATE, 0644)
 	if err != nil {
-		return
+		return 0, err
 	}
 	defer func() {
 		err = f.Close()
 	}()
 
-	var raw []byte
-
-	raw, err = ioutil.ReadAll(f)
+	raw, err := ioutil.ReadAll(f)
 	if err != nil {
-		return
+		return 0, err
 	}
 
 	height, err := strconv.Atoi(string(bytes.TrimSpace(raw)))
 	if err != nil {
-		return
+		return 0, err
 	}
 
-	r.last = abi.ChainEpoch(height)
-	return
+	return abi.ChainEpoch(height), nil
+}
+
+func (r *Repo) loadHeight() error {
+	var err error
+	r.lastHeight, err = loadChainEpoch(filepath.Join(r.path, "height"))
+	return err
+}
+
+func (r *Repo) loadMinerRecoveryHeight() error {
+	var err error
+	r.lastMinerRecoveryHeight, err = loadChainEpoch(filepath.Join(r.path, "miner_recovery_height"))
+	return err
 }
 
 func (r *Repo) Height() abi.ChainEpoch {
-	return r.last
+	return r.lastHeight
+}
+
+func (r *Repo) MinerRecoveryHeight() abi.ChainEpoch {
+	return r.lastMinerRecoveryHeight
 }
 
 func (r *Repo) SetHeight(last abi.ChainEpoch) (err error) {
-	r.last = last
+	r.lastHeight = last
 	var f *os.File
 	f, err = os.OpenFile(filepath.Join(r.path, "height"), os.O_RDWR, 0644)
 	if err != nil {
@@ -626,7 +1157,26 @@ func (r *Repo) SetHeight(last abi.ChainEpoch) (err error) {
 		err = f.Close()
 	}()
 
-	if _, err = fmt.Fprintf(f, "%d", r.last); err != nil {
+	if _, err = fmt.Fprintf(f, "%d", r.lastHeight); err != nil {
+		return
+	}
+
+	return
+}
+
+func (r *Repo) SetMinerRecoveryHeight(last abi.ChainEpoch) (err error) {
+	r.lastMinerRecoveryHeight = last
+	var f *os.File
+	f, err = os.OpenFile(filepath.Join(r.path, "miner_recovery_height"), os.O_RDWR, 0644)
+	if err != nil {
+		return
+	}
+
+	defer func() {
+		err = f.Close()
+	}()
+
+	if _, err = fmt.Fprintf(f, "%d", r.lastMinerRecoveryHeight); err != nil {
 		return
 	}
 

cmd/lotus-shed/balances.go

@@ -6,7 +6,7 @@ import (
 	"strconv"
 
 	"github.com/docker/go-units"
-	lotusbuiltin "github.com/filecoin-project/lotus/chain/actors/builtin"
+	"github.com/filecoin-project/lotus/chain/actors/builtin"
 	"github.com/filecoin-project/lotus/chain/actors/builtin/power"
 	"github.com/filecoin-project/lotus/chain/actors/builtin/reward"
 
@@ -97,7 +97,7 @@ var chainBalanceCmd = &cli.Command{
 				Type:    string(act.Code.Hash()[2:]),
 			}
 
-			if act.IsStorageMinerActor() {
+			if builtin.IsStorageMinerActor(act.Code) {
 				pow, err := api.StateMinerPower(ctx, addr, tsk)
 				if err != nil {
 					return xerrors.Errorf("failed to get power: %w", err)
@@ -198,7 +198,7 @@ var chainBalanceStateCmd = &cli.Command{
 				PreCommits:    types.FIL(big.NewInt(0)),
 			}
 
-			if minerInfo && act.IsStorageMinerActor() {
+			if minerInfo && builtin.IsStorageMinerActor(act.Code) {
 				pow, _, _, err := stmgr.GetPowerRaw(ctx, sm, sroot, addr)
 				if err != nil {
 					return xerrors.Errorf("failed to get power: %w", err)
@@ -322,7 +322,7 @@ var chainPledgeCmd = &cli.Command{
 		}
 
 		var (
-			powerSmoothed    lotusbuiltin.FilterEstimate
+			powerSmoothed    builtin.FilterEstimate
 			pledgeCollateral abi.TokenAmount
 		)
 		if act, err := state.GetActor(power.Address); err != nil {

cmd/lotus-shed/datastore.go

@@ -0,0 +1,290 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"strings"
+
+	"github.com/docker/go-units"
+	"github.com/ipfs/go-datastore"
+	dsq "github.com/ipfs/go-datastore/query"
+	logging "github.com/ipfs/go-log"
+	"github.com/polydawn/refmt/cbor"
+	"github.com/urfave/cli/v2"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/lotus/lib/backupds"
+	"github.com/filecoin-project/lotus/node/repo"
+)
+
+var datastoreCmd = &cli.Command{
+	Name:        "datastore",
+	Description: "access node datastores directly",
+	Subcommands: []*cli.Command{
+		datastoreBackupCmd,
+		datastoreListCmd,
+		datastoreGetCmd,
+	},
+}
+
+var datastoreListCmd = &cli.Command{
+	Name:        "list",
+	Description: "list datastore keys",
+	Flags: []cli.Flag{
+		&cli.IntFlag{
+			Name:  "repo-type",
+			Usage: "node type (1 - full, 2 - storage, 3 - worker)",
+			Value: 1,
+		},
+		&cli.BoolFlag{
+			Name:  "top-level",
+			Usage: "only print top-level keys",
+		},
+		&cli.StringFlag{
+			Name:  "get-enc",
+			Usage: "print values [esc/hex/cbor]",
+		},
+	},
+	ArgsUsage: "[namespace prefix]",
+	Action: func(cctx *cli.Context) error {
+		logging.SetLogLevel("badger", "ERROR") // nolint:errcheck
+
+		r, err := repo.NewFS(cctx.String("repo"))
+		if err != nil {
+			return xerrors.Errorf("opening fs repo: %w", err)
+		}
+
+		exists, err := r.Exists()
+		if err != nil {
+			return err
+		}
+		if !exists {
+			return xerrors.Errorf("lotus repo doesn't exist")
+		}
+
+		lr, err := r.Lock(repo.RepoType(cctx.Int("repo-type")))
+		if err != nil {
+			return err
+		}
+		defer lr.Close() //nolint:errcheck
+
+		ds, err := lr.Datastore(datastore.NewKey(cctx.Args().First()).String())
+		if err != nil {
+			return err
+		}
+
+		genc := cctx.String("get-enc")
+
+		q, err := ds.Query(dsq.Query{
+			Prefix:   datastore.NewKey(cctx.Args().Get(1)).String(),
+			KeysOnly: genc == "",
+		})
+		if err != nil {
+			return xerrors.Errorf("datastore query: %w", err)
+		}
+		defer q.Close() //nolint:errcheck
+
+		printKv := kvPrinter(cctx.Bool("top-level"), genc)
+
+		for res := range q.Next() {
+			if err := printKv(res.Key, res.Value); err != nil {
+				return err
+			}
+		}
+
+		return nil
+	},
+}
+
+var datastoreGetCmd = &cli.Command{
+	Name:        "get",
+	Description: "list datastore keys",
+	Flags: []cli.Flag{
+		&cli.IntFlag{
+			Name:  "repo-type",
+			Usage: "node type (1 - full, 2 - storage, 3 - worker)",
+			Value: 1,
+		},
+		&cli.StringFlag{
+			Name:  "enc",
+			Usage: "encoding (esc/hex/cbor)",
+			Value: "esc",
+		},
+	},
+	ArgsUsage: "[namespace key]",
+	Action: func(cctx *cli.Context) error {
+		logging.SetLogLevel("badger", "ERROR") // nolint:errchec
+
+		r, err := repo.NewFS(cctx.String("repo"))
+		if err != nil {
+			return xerrors.Errorf("opening fs repo: %w", err)
+		}
+
+		exists, err := r.Exists()
+		if err != nil {
+			return err
+		}
+		if !exists {
+			return xerrors.Errorf("lotus repo doesn't exist")
+		}
+
+		lr, err := r.Lock(repo.RepoType(cctx.Int("repo-type")))
+		if err != nil {
+			return err
+		}
+		defer lr.Close() //nolint:errcheck
+
+		ds, err := lr.Datastore(datastore.NewKey(cctx.Args().First()).String())
+		if err != nil {
+			return err
+		}
+
+		val, err := ds.Get(datastore.NewKey(cctx.Args().Get(1)))
+		if err != nil {
+			return xerrors.Errorf("get: %w", err)
+		}
+
+		return printVal(cctx.String("enc"), val)
+	},
+}
+
+var datastoreBackupCmd = &cli.Command{
+	Name:        "backup",
+	Description: "manage datastore backups",
+	Subcommands: []*cli.Command{
+		datastoreBackupStatCmd,
+		datastoreBackupListCmd,
+	},
+}
+
+var datastoreBackupStatCmd = &cli.Command{
+	Name:        "stat",
+	Description: "validate and print info about datastore backup",
+	ArgsUsage:   "[file]",
+	Action: func(cctx *cli.Context) error {
+		if cctx.Args().Len() != 1 {
+			return xerrors.Errorf("expected 1 argument")
+		}
+
+		f, err := os.Open(cctx.Args().First())
+		if err != nil {
+			return xerrors.Errorf("opening backup file: %w", err)
+		}
+		defer f.Close() // nolint:errcheck
+
+		var keys, kbytes, vbytes uint64
+		err = backupds.ReadBackup(f, func(key datastore.Key, value []byte) error {
+			keys++
+			kbytes += uint64(len(key.String()))
+			vbytes += uint64(len(value))
+			return nil
+		})
+		if err != nil {
+			return err
+		}
+
+		fmt.Println("Keys:        ", keys)
+		fmt.Println("Key bytes:   ", units.BytesSize(float64(kbytes)))
+		fmt.Println("Value bytes: ", units.BytesSize(float64(vbytes)))
+
+		return err
+	},
+}
+
+var datastoreBackupListCmd = &cli.Command{
+	Name:        "list",
+	Description: "list data in a backup",
+	Flags: []cli.Flag{
+		&cli.BoolFlag{
+			Name:  "top-level",
+			Usage: "only print top-level keys",
+		},
+		&cli.StringFlag{
+			Name:  "get-enc",
+			Usage: "print values [esc/hex/cbor]",
+		},
+	},
+	ArgsUsage: "[file]",
+	Action: func(cctx *cli.Context) error {
+		if cctx.Args().Len() != 1 {
+			return xerrors.Errorf("expected 1 argument")
+		}
+
+		f, err := os.Open(cctx.Args().First())
+		if err != nil {
+			return xerrors.Errorf("opening backup file: %w", err)
+		}
+		defer f.Close() // nolint:errcheck
+
+		printKv := kvPrinter(cctx.Bool("top-level"), cctx.String("get-enc"))
+		err = backupds.ReadBackup(f, func(key datastore.Key, value []byte) error {
+			return printKv(key.String(), value)
+		})
+		if err != nil {
+			return err
+		}
+
+		return err
+	},
+}
+
+func kvPrinter(toplevel bool, genc string) func(sk string, value []byte) error {
+	seen := map[string]struct{}{}
+
+	return func(s string, value []byte) error {
+		if toplevel {
+			k := datastore.NewKey(datastore.NewKey(s).List()[0])
+			if k.Type() != "" {
+				s = k.Type()
+			} else {
+				s = k.String()
+			}
+
+			_, has := seen[s]
+			if has {
+				return nil
+			}
+			seen[s] = struct{}{}
+		}
+
+		s = fmt.Sprintf("%q", s)
+		s = strings.Trim(s, "\"")
+		fmt.Println(s)
+
+		if genc != "" {
+			fmt.Print("\t")
+			if err := printVal(genc, value); err != nil {
+				return err
+			}
+		}
+
+		return nil
+	}
+}
+
+func printVal(enc string, val []byte) error {
+	switch enc {
+	case "esc":
+		s := fmt.Sprintf("%q", string(val))
+		s = strings.Trim(s, "\"")
+		fmt.Println(s)
+	case "hex":
+		fmt.Printf("%x\n", val)
+	case "cbor":
+		var out interface{}
+		if err := cbor.Unmarshal(cbor.DecodeOptions{}, val, &out); err != nil {
+			return xerrors.Errorf("unmarshaling cbor: %w", err)
+		}
+		s, err := json.Marshal(&out)
+		if err != nil {
+			return xerrors.Errorf("remarshaling as json: %w", err)
+		}
+
+		fmt.Println(string(s))
+	default:
+		return xerrors.New("unknown encoding")
+	}
+
+	return nil
+}

cmd/lotus-shed/genesis-verify.go

@@ -6,6 +6,8 @@ import (
 	"os"
 	"sort"
 
+	"github.com/filecoin-project/lotus/chain/actors/builtin"
+
 	"github.com/fatih/color"
 	"github.com/ipfs/go-datastore"
 	cbor "github.com/ipfs/go-ipld-cbor"
@@ -95,14 +97,14 @@ var genesisVerifyCmd = &cli.Command{
 
 		if err := stree.ForEach(func(addr address.Address, act *types.Actor) error {
 			switch {
-			case act.IsStorageMinerActor():
+			case builtin.IsStorageMinerActor(act.Code):
 				_, err := miner.Load(store, act)
 				if err != nil {
 					return xerrors.Errorf("miner actor: %w", err)
 				}
 				// TODO: actually verify something here?
 				kminers[addr] = minerInfo{}
-			case act.IsMultisigActor():
+			case builtin.IsMultisigActor(act.Code):
 				st, err := multisig.Load(store, act)
 				if err != nil {
 					return xerrors.Errorf("multisig actor: %w", err)
@@ -123,7 +125,7 @@ var genesisVerifyCmd = &cli.Command{
 					Threshold: threshold,
 				}
 				msigAddrs = append(msigAddrs, addr)
-			case act.IsAccountActor():
+			case builtin.IsAccountActor(act.Code):
 				st, err := account.Load(store, act)
 				if err != nil {
 					// TODO: magik6k: this _used_ to log instead of failing, why?