v4 specs-actors integration, nv12 migration

.circleci/config.yml

@@ -130,6 +130,9 @@ jobs:
       winpost-test:
         type: string
         default: "0"
+      deadline-test:
+        type: string
+        default: "0"
       test-suite-name:
         type: string
         default: unit
@@ -163,6 +166,7 @@ jobs:
           name: go test
           environment:
             LOTUS_TEST_WINDOW_POST: << parameters.winpost-test >>
+            LOTUS_TEST_DEADLINE_TOGGLING: << parameters.deadline-test >>
             SKIP_CONFORMANCE: "1"
           command: |
             mkdir -p /tmp/test-reports/<< parameters.test-suite-name >>
@@ -204,6 +208,8 @@ jobs:
     <<: *test
   test-window-post-dispute:
     <<: *test
+  test-deadline-toggling:
+    <<: *test
   test-terminate:
     <<: *test
   test-conformance:
@@ -649,6 +655,11 @@ workflows:
           go-test-flags: "-run=TestTerminate"
           winpost-test: "1"
           test-suite-name: terminate
+      - test-deadline-toggling:
+          codecov-upload: true
+          go-test-flags: "-run=TestDeadlineToggling"
+          deadline-test: "1"
+          test-suite-name: deadline-toggling
       - test-short:
           go-test-flags: "--timeout 10m --short"
           test-suite-name: short

api/test/ccupgrade.go

@@ -17,7 +17,7 @@ import (
 
 func TestCCUpgrade(t *testing.T, b APIBuilder, blocktime time.Duration) {
 	for _, height := range []abi.ChainEpoch{
-		2,    // before
+		-1,   // before
 		162,  // while sealing
 		530,  // after upgrade deal
 		5000, // after
@@ -31,7 +31,7 @@ func TestCCUpgrade(t *testing.T, b APIBuilder, blocktime time.Duration) {
 
 func testCCUpgrade(t *testing.T, b APIBuilder, blocktime time.Duration, upgradeHeight abi.ChainEpoch) {
 	ctx := context.Background()
-	n, sn := b(t, []FullNodeOpts{FullNodeWithActorsV3At(upgradeHeight)}, OneMiner)
+	n, sn := b(t, []FullNodeOpts{FullNodeWithActorsV4At(upgradeHeight)}, OneMiner)
 	client := n[0].FullNode.(*impl.FullNodeAPI)
 	miner := sn[0]
 

api/test/deadlines.go

@@ -0,0 +1,350 @@
+package test
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+
+	"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-state-types/network"
+	miner2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/miner"
+	"github.com/ipfs/go-cid"
+	cbor "github.com/ipfs/go-ipld-cbor"
+
+	"github.com/filecoin-project/lotus/blockstore"
+	"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/miner"
+	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/extern/sector-storage/mock"
+	"github.com/filecoin-project/lotus/node/impl"
+)
+
+// TestDeadlineToggling:
+// * spins up a v3 network (miner A)
+// * creates an inactive miner (miner B)
+// * creates another miner, pledges a sector, waits for power (miner C)
+//
+// * goes through v4 upgrade
+// * goes through PP
+// * creates minerD, minerE
+// * makes sure that miner B/D are inactive, A/C still are
+// * pledges sectors on miner B/D
+// * precommits a sector on minerE
+// * disables post on miner C
+// * goes through PP 0.5PP
+// * asserts that minerE is active
+// * goes through rest of PP (1.5)
+// * asserts that miner C loses power
+// * asserts that miner B/D is active and has power
+// * asserts that minerE is inactive
+// * disables post on miner B
+// * terminates sectors on miner D
+// * goes through another PP
+// * asserts that miner B loses power
+// * asserts that miner D loses power, is inactive
+func TestDeadlineToggling(t *testing.T, b APIBuilder, blocktime time.Duration) {
+	var upgradeH abi.ChainEpoch = 4000
+	var provingPeriod abi.ChainEpoch = 2880
+
+	const sectorsC, sectorsD, sectersB = 10, 9, 8
+
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	n, sn := b(t, []FullNodeOpts{FullNodeWithActorsV4At(upgradeH)}, OneMiner)
+
+	client := n[0].FullNode.(*impl.FullNodeAPI)
+	minerA := sn[0]
+
+	{
+		addrinfo, err := client.NetAddrsListen(ctx)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		if err := minerA.NetConnect(ctx, addrinfo); err != nil {
+			t.Fatal(err)
+		}
+	}
+
+	defaultFrom, err := client.WalletDefaultAddress(ctx)
+	require.NoError(t, err)
+
+	maddrA, err := minerA.ActorAddress(ctx)
+	require.NoError(t, err)
+
+	build.Clock.Sleep(time.Second)
+
+	done := make(chan struct{})
+	go func() {
+		defer close(done)
+		for ctx.Err() == nil {
+			build.Clock.Sleep(blocktime)
+			if err := minerA.MineOne(ctx, MineNext); err != nil {
+				if ctx.Err() != nil {
+					// context was canceled, ignore the error.
+					return
+				}
+				t.Error(err)
+			}
+		}
+	}()
+	defer func() {
+		cancel()
+		<-done
+	}()
+
+	minerB := n[0].Stb(ctx, t, TestSpt, defaultFrom)
+	minerC := n[0].Stb(ctx, t, TestSpt, defaultFrom)
+
+	maddrB, err := minerB.ActorAddress(ctx)
+	require.NoError(t, err)
+	maddrC, err := minerC.ActorAddress(ctx)
+	require.NoError(t, err)
+
+	ssz, err := minerC.ActorSectorSize(ctx, maddrC)
+	require.NoError(t, err)
+
+	// pledge sectors on C, go through a PP, check for power
+	{
+		pledgeSectors(t, ctx, minerC, sectorsC, 0, nil)
+
+		di, err := client.StateMinerProvingDeadline(ctx, maddrC, types.EmptyTSK)
+		require.NoError(t, err)
+
+		fmt.Printf("Running one proving period (miner C)\n")
+		fmt.Printf("End for head.Height > %d\n", di.PeriodStart+di.WPoStProvingPeriod*2)
+
+		for {
+			head, err := client.ChainHead(ctx)
+			require.NoError(t, err)
+
+			if head.Height() > di.PeriodStart+provingPeriod*2 {
+				fmt.Printf("Now head.Height = %d\n", head.Height())
+				break
+			}
+			build.Clock.Sleep(blocktime)
+		}
+
+		expectedPower := types.NewInt(uint64(ssz) * sectorsC)
+
+		p, err := client.StateMinerPower(ctx, maddrC, types.EmptyTSK)
+		require.NoError(t, err)
+
+		// make sure it has gained power.
+		require.Equal(t, p.MinerPower.RawBytePower, expectedPower)
+	}
+
+	// go through upgrade + PP
+	for {
+		head, err := client.ChainHead(ctx)
+		require.NoError(t, err)
+
+		if head.Height() > upgradeH+provingPeriod {
+			fmt.Printf("Now head.Height = %d\n", head.Height())
+			break
+		}
+		build.Clock.Sleep(blocktime)
+	}
+
+	checkMiner := func(ma address.Address, power abi.StoragePower, active bool, tsk types.TipSetKey) {
+		p, err := client.StateMinerPower(ctx, ma, tsk)
+		require.NoError(t, err)
+
+		// make sure it has the expected power.
+		require.Equal(t, p.MinerPower.RawBytePower, power)
+
+		mact, err := client.StateGetActor(ctx, ma, tsk)
+		require.NoError(t, err)
+
+		mst, err := miner.Load(adt.WrapStore(ctx, cbor.NewCborStore(blockstore.NewAPIBlockstore(client))), mact)
+		require.NoError(t, err)
+
+		act, err := mst.DeadlineCronActive()
+		require.NoError(t, err)
+		require.Equal(t, active, act)
+	}
+
+	// check that just after the upgrade minerB was still active
+	{
+		uts, err := client.ChainGetTipSetByHeight(ctx, upgradeH+2, types.EmptyTSK)
+		require.NoError(t, err)
+		checkMiner(maddrB, types.NewInt(0), true, uts.Key())
+	}
+
+	nv, err := client.StateNetworkVersion(ctx, types.EmptyTSK)
+	require.NoError(t, err)
+	require.GreaterOrEqual(t, nv, network.Version12)
+
+	minerD := n[0].Stb(ctx, t, TestSpt, defaultFrom)
+	minerE := n[0].Stb(ctx, t, TestSpt, defaultFrom)
+
+	maddrD, err := minerD.ActorAddress(ctx)
+	require.NoError(t, err)
+	maddrE, err := minerE.ActorAddress(ctx)
+	require.NoError(t, err)
+
+	// first round of miner checks
+	checkMiner(maddrA, types.NewInt(uint64(ssz)*GenesisPreseals), true, types.EmptyTSK)
+	checkMiner(maddrC, types.NewInt(uint64(ssz)*sectorsC), true, types.EmptyTSK)
+
+	checkMiner(maddrB, types.NewInt(0), false, types.EmptyTSK)
+	checkMiner(maddrD, types.NewInt(0), false, types.EmptyTSK)
+	checkMiner(maddrE, types.NewInt(0), false, types.EmptyTSK)
+
+	// pledge sectors on minerB/minerD, stop post on minerC
+	pledgeSectors(t, ctx, minerB, sectersB, 0, nil)
+	checkMiner(maddrB, types.NewInt(0), true, types.EmptyTSK)
+
+	pledgeSectors(t, ctx, minerD, sectorsD, 0, nil)
+	checkMiner(maddrD, types.NewInt(0), true, types.EmptyTSK)
+
+	minerC.StorageMiner.(*impl.StorageMinerAPI).IStorageMgr.(*mock.SectorMgr).Fail()
+
+	// precommit a sector on minerE
+	{
+		head, err := client.ChainHead(ctx)
+		require.NoError(t, err)
+
+		cr, err := cid.Parse("bagboea4b5abcatlxechwbp7kjpjguna6r6q7ejrhe6mdp3lf34pmswn27pkkiekz")
+		require.NoError(t, err)
+
+		params := &miner.SectorPreCommitInfo{
+			Expiration:   2880 * 300,
+			SectorNumber: 22,
+			SealProof:    TestSpt,
+
+			SealedCID:     cr,
+			SealRandEpoch: head.Height() - 200,
+		}
+
+		enc := new(bytes.Buffer)
+		require.NoError(t, params.MarshalCBOR(enc))
+
+		m, err := client.MpoolPushMessage(ctx, &types.Message{
+			To:     maddrE,
+			From:   defaultFrom,
+			Value:  types.FromFil(1),
+			Method: miner.Methods.PreCommitSector,
+			Params: enc.Bytes(),
+		}, nil)
+		require.NoError(t, err)
+
+		r, err := client.StateWaitMsg(ctx, m.Cid(), 2)
+		require.NoError(t, err)
+		require.Equal(t, exitcode.Ok, r.Receipt.ExitCode)
+	}
+
+	// go through 0.5 PP
+	for {
+		head, err := client.ChainHead(ctx)
+		require.NoError(t, err)
+
+		if head.Height() > upgradeH+provingPeriod+(provingPeriod/2) {
+			fmt.Printf("Now head.Height = %d\n", head.Height())
+			break
+		}
+		build.Clock.Sleep(blocktime)
+	}
+
+	checkMiner(maddrE, types.NewInt(0), true, types.EmptyTSK)
+
+	// go through rest of the PP
+	for {
+		head, err := client.ChainHead(ctx)
+		require.NoError(t, err)
+
+		if head.Height() > upgradeH+(provingPeriod*3) {
+			fmt.Printf("Now head.Height = %d\n", head.Height())
+			break
+		}
+		build.Clock.Sleep(blocktime)
+	}
+
+	// second round of miner checks
+	checkMiner(maddrA, types.NewInt(uint64(ssz)*GenesisPreseals), true, types.EmptyTSK)
+	checkMiner(maddrC, types.NewInt(0), true, types.EmptyTSK)
+	checkMiner(maddrB, types.NewInt(uint64(ssz)*sectersB), true, types.EmptyTSK)
+	checkMiner(maddrD, types.NewInt(uint64(ssz)*sectorsD), true, types.EmptyTSK)
+	checkMiner(maddrE, types.NewInt(0), false, types.EmptyTSK)
+
+	// disable post on minerB
+	minerB.StorageMiner.(*impl.StorageMinerAPI).IStorageMgr.(*mock.SectorMgr).Fail()
+
+	// terminate sectors on minerD
+	{
+		var terminationDeclarationParams []miner2.TerminationDeclaration
+		secs, err := minerD.SectorsList(ctx)
+		require.NoError(t, err)
+		require.Len(t, secs, sectorsD)
+
+		for _, sectorNum := range secs {
+			sectorbit := bitfield.New()
+			sectorbit.Set(uint64(sectorNum))
+
+			loca, err := client.StateSectorPartition(ctx, maddrD, sectorNum, types.EmptyTSK)
+			require.NoError(t, err)
+
+			para := miner2.TerminationDeclaration{
+				Deadline:  loca.Deadline,
+				Partition: loca.Partition,
+				Sectors:   sectorbit,
+			}
+
+			terminationDeclarationParams = append(terminationDeclarationParams, para)
+		}
+
+		terminateSectorParams := &miner2.TerminateSectorsParams{
+			Terminations: terminationDeclarationParams,
+		}
+
+		sp, aerr := actors.SerializeParams(terminateSectorParams)
+		require.NoError(t, aerr)
+
+		smsg, err := client.MpoolPushMessage(ctx, &types.Message{
+			From:   defaultFrom,
+			To:     maddrD,
+			Method: miner.Methods.TerminateSectors,
+
+			Value:  big.Zero(),
+			Params: sp,
+		}, nil)
+		require.NoError(t, err)
+
+		fmt.Println("sent termination message:", smsg.Cid())
+
+		r, err := client.StateWaitMsg(ctx, smsg.Cid(), 2)
+		require.NoError(t, err)
+		require.Equal(t, exitcode.Ok, r.Receipt.ExitCode)
+
+		checkMiner(maddrD, types.NewInt(0), true, r.TipSet)
+	}
+
+	// go through another PP
+	for {
+		head, err := client.ChainHead(ctx)
+		require.NoError(t, err)
+
+		if head.Height() > upgradeH+(provingPeriod*5) {
+			fmt.Printf("Now head.Height = %d\n", head.Height())
+			break
+		}
+		build.Clock.Sleep(blocktime)
+	}
+
+	// third round of miner checks
+	checkMiner(maddrA, types.NewInt(uint64(ssz)*GenesisPreseals), true, types.EmptyTSK)
+	checkMiner(maddrC, types.NewInt(0), true, types.EmptyTSK)
+	checkMiner(maddrB, types.NewInt(0), true, types.EmptyTSK)
+	checkMiner(maddrD, types.NewInt(0), false, types.EmptyTSK)
+}

api/test/mining.go

@@ -11,10 +11,13 @@ import (
 
 	logging "github.com/ipfs/go-log/v2"
 
-	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/stretchr/testify/require"
 
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/abi"
+
 	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/miner"
 	"github.com/filecoin-project/lotus/node/impl"
 )
@@ -199,3 +202,39 @@ func TestDealMining(t *testing.T, b APIBuilder, blocktime time.Duration, carExpo
 	fmt.Println("shutting down mining")
 	<-done
 }
+
+func (ts *testSuite) testNonGenesisMiner(t *testing.T) {
+	ctx := context.Background()
+	n, sn := ts.makeNodes(t, []FullNodeOpts{
+		FullNodeWithActorsV4At(-1),
+	}, []StorageMiner{
+		{Full: 0, Preseal: PresealGenesis},
+	})
+
+	full, ok := n[0].FullNode.(*impl.FullNodeAPI)
+	if !ok {
+		t.Skip("not testing with a full node")
+		return
+	}
+	genesisMiner := sn[0]
+
+	bm := NewBlockMiner(ctx, t, genesisMiner, 4*time.Millisecond)
+	bm.MineBlocks()
+	t.Cleanup(bm.Stop)
+
+	gaa, err := genesisMiner.ActorAddress(ctx)
+	require.NoError(t, err)
+
+	gmi, err := full.StateMinerInfo(ctx, gaa, types.EmptyTSK)
+	require.NoError(t, err)
+
+	testm := n[0].Stb(ctx, t, TestSpt, gmi.Owner)
+
+	ta, err := testm.ActorAddress(ctx)
+	require.NoError(t, err)
+
+	tid, err := address.IDFromAddress(ta)
+	require.NoError(t, err)
+
+	require.Equal(t, uint64(1001), tid)
+}

api/test/test.go

@@ -8,20 +8,21 @@ import (
 	"testing"
 	"time"
 
-	"github.com/filecoin-project/lotus/chain/stmgr"
-	"github.com/filecoin-project/lotus/chain/types"
-
 	logging "github.com/ipfs/go-log/v2"
 	"github.com/multiformats/go-multiaddr"
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
+	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/big"
 	"github.com/filecoin-project/go-state-types/network"
+
 	"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"
 	"github.com/filecoin-project/lotus/miner"
 	"github.com/filecoin-project/lotus/node"
 )
@@ -35,11 +36,15 @@ func init() {
 	build.InsecurePoStValidation = true
 }
 
+type StorageBuilder func(context.Context, *testing.T, abi.RegisteredSealProof, address.Address) TestStorageNode
+
 type TestNode struct {
 	api.FullNode
 	// ListenAddr is the address on which an API server is listening, if an
 	// API server is created for this Node
 	ListenAddr multiaddr.Multiaddr
+
+	Stb StorageBuilder
 }
 
 type TestStorageNode struct {
@@ -56,6 +61,8 @@ var PresealGenesis = -1
 
 const GenesisPreseals = 2
 
+const TestSpt = abi.RegisteredSealProof_StackedDrg2KiBV1_1
+
 // Options for setting up a mock storage miner
 type StorageMiner struct {
 	Full    int
@@ -94,6 +101,7 @@ func TestApis(t *testing.T, b APIBuilder) {
 	t.Run("testMining", ts.testMining)
 	t.Run("testMiningReal", ts.testMiningReal)
 	t.Run("testSearchMsg", ts.testSearchMsg)
+	t.Run("testNonGenesisMiner", ts.testNonGenesisMiner)
 }
 
 func DefaultFullOpts(nFull int) []FullNodeOpts {
@@ -112,7 +120,11 @@ var OneMiner = []StorageMiner{{Full: 0, Preseal: PresealGenesis}}
 var OneFull = DefaultFullOpts(1)
 var TwoFull = DefaultFullOpts(2)
 
-var FullNodeWithActorsV3At = func(upgradeHeight abi.ChainEpoch) FullNodeOpts {
+var FullNodeWithActorsV4At = func(upgradeHeight abi.ChainEpoch) FullNodeOpts {
+	if upgradeHeight == -1 {
+		upgradeHeight = 3
+	}
+
 	return FullNodeOpts{
 		Opts: func(nodes []TestNode) node.Option {
 			return node.Override(new(stmgr.UpgradeSchedule), stmgr.UpgradeSchedule{{
@@ -121,10 +133,13 @@ var FullNodeWithActorsV3At = func(upgradeHeight abi.ChainEpoch) FullNodeOpts {
 				Height:    1,
 				Migration: stmgr.UpgradeActorsV2,
 			}, {
-				// Skip directly to tape height so precommits work.
 				Network:   network.Version10,
-				Height:    upgradeHeight,
+				Height:    2,
 				Migration: stmgr.UpgradeActorsV3,
+			}, {
+				Network:   network.Version12,
+				Height:    upgradeHeight,
+				Migration: stmgr.UpgradeActorsV4,
 			}})
 		},
 	}
@@ -156,6 +171,9 @@ var MineNext = miner.MineReq{
 
 func (ts *testSuite) testVersion(t *testing.T) {
 	api.RunningNodeType = api.NodeFull
+	t.Cleanup(func() {
+		api.RunningNodeType = api.NodeUnknown
+	})
 
 	ctx := context.Background()
 	apis, _ := ts.makeNodes(t, OneFull, OneMiner)

api/test/window_post.go

@@ -206,7 +206,7 @@ func pledgeSectors(t *testing.T, ctx context.Context, miner TestStorageNode, n,
 
 func TestWindowPost(t *testing.T, b APIBuilder, blocktime time.Duration, nSectors int) {
 	for _, height := range []abi.ChainEpoch{
-		2,    // before
+		-1,   // before
 		162,  // while sealing
 		5000, // while proving
 	} {
@@ -223,7 +223,7 @@ func testWindowPostUpgrade(t *testing.T, b APIBuilder, blocktime time.Duration,
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	n, sn := b(t, []FullNodeOpts{FullNodeWithActorsV3At(upgradeHeight)}, OneMiner)
+	n, sn := b(t, []FullNodeOpts{FullNodeWithActorsV4At(upgradeHeight)}, OneMiner)
 
 	client := n[0].FullNode.(*impl.FullNodeAPI)
 	miner := sn[0]
@@ -442,7 +442,7 @@ func TestTerminate(t *testing.T, b APIBuilder, blocktime time.Duration) {
 
 	nSectors := uint64(2)
 
-	n, sn := b(t, []FullNodeOpts{FullNodeWithActorsV3At(2)}, []StorageMiner{{Full: 0, Preseal: int(nSectors)}})
+	n, sn := b(t, []FullNodeOpts{FullNodeWithActorsV4At(-1)}, []StorageMiner{{Full: 0, Preseal: int(nSectors)}})
 
 	client := n[0].FullNode.(*impl.FullNodeAPI)
 	miner := sn[0]
@@ -617,7 +617,7 @@ func TestWindowPostDispute(t *testing.T, b APIBuilder, blocktime time.Duration)
 	///
 	// Then we're going to manually submit bad proofs.
 	n, sn := b(t, []FullNodeOpts{
-		FullNodeWithActorsV3At(2),
+		FullNodeWithActorsV4At(-1),
 	}, []StorageMiner{
 		{Full: 0, Preseal: PresealGenesis},
 		{Full: 0},
@@ -900,7 +900,7 @@ func TestWindowPostDisputeFails(t *testing.T, b APIBuilder, blocktime time.Durat
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	n, sn := b(t, []FullNodeOpts{FullNodeWithActorsV3At(2)}, OneMiner)
+	n, sn := b(t, []FullNodeOpts{FullNodeWithActorsV4At(-1)}, OneMiner)
 
 	client := n[0].FullNode.(*impl.FullNodeAPI)
 	miner := sn[0]

api/version.go

@@ -54,7 +54,7 @@ func VersionForType(nodeType NodeType) (Version, error) {
 
 // semver versions of the rpc api exposed
 var (
-	FullAPIVersion   = newVer(1, 1, 0)
+	FullAPIVersion   = newVer(1, 2, 0)
 	MinerAPIVersion  = newVer(1, 0, 1)
 	WorkerAPIVersion = newVer(1, 0, 0)
 )

build/params_2k.go

@@ -35,6 +35,8 @@ var UpgradeActorsV3Height = abi.ChainEpoch(35)
 
 var UpgradeNorwegianHeight = abi.ChainEpoch(40)
 
+var UpgradeActorsV4Height = abi.ChainEpoch(45)
+
 var DrandSchedule = map[abi.ChainEpoch]DrandEnum{
 	0: DrandMainnet,
 }
@@ -72,6 +74,7 @@ func init() {
 	UpgradeClausHeight = getUpgradeHeight("LOTUS_CLAUS_HEIGHT", UpgradeClausHeight)
 	UpgradeActorsV3Height = getUpgradeHeight("LOTUS_ACTORSV3_HEIGHT", UpgradeActorsV3Height)
 	UpgradeNorwegianHeight = getUpgradeHeight("LOTUS_NORWEGIAN_HEIGHT", UpgradeNorwegianHeight)
+	UpgradeActorsV4Height = getUpgradeHeight("LOTUS_ACTORSV4_HEIGHT", UpgradeActorsV4Height)
 
 	BuildType |= Build2k
 }

build/params_butterfly.go

@@ -33,6 +33,7 @@ const UpgradeClausHeight = 180
 const UpgradeOrangeHeight = 210
 const UpgradeActorsV3Height = 240
 const UpgradeNorwegianHeight = UpgradeActorsV3Height + (builtin2.EpochsInHour * 12)
+const UpgradeActorsV4Height = 8922
 
 func init() {
 	policy.SetConsensusMinerMinPower(abi.NewStoragePower(2 << 30))

build/params_calibnet.go

@@ -42,6 +42,8 @@ const UpgradeOrangeHeight = 300
 const UpgradeActorsV3Height = 600
 const UpgradeNorwegianHeight = 114000
 
+const UpgradeActorsV4Height = 193789
+
 func init() {
 	policy.SetConsensusMinerMinPower(abi.NewStoragePower(32 << 30))
 	policy.SetSupportedProofTypes(

build/params_mainnet.go

@@ -59,6 +59,9 @@ var UpgradeActorsV3Height = abi.ChainEpoch(550321)
 // 2021-04-12T22:00:00Z
 const UpgradeNorwegianHeight = 665280
 
+// 2021-04-29T06:00:00Z
+var UpgradeActorsV4Height = abi.ChainEpoch(712320)
+
 func init() {
 	policy.SetConsensusMinerMinPower(abi.NewStoragePower(10 << 40))
 
@@ -70,6 +73,10 @@ func init() {
 		UpgradeActorsV3Height = math.MaxInt64
 	}
 
+	if os.Getenv("LOTUS_DISABLE_V4_ACTOR_MIGRATION") == "1" {
+		UpgradeActorsV4Height = math.MaxInt64
+	}
+
 	Devnet = false
 
 	BuildType = BuildMainnet

build/params_nerpanet.go

@@ -40,6 +40,7 @@ const UpgradeOrangeHeight = 300
 
 const UpgradeActorsV3Height = 600
 const UpgradeNorwegianHeight = 999999
+const UpgradeActorsV4Height = 99999999
 
 func init() {
 	// Minimum block production power is set to 4 TiB

build/params_testground.go

@@ -94,6 +94,7 @@ var (
 	UpgradeClausHeight     abi.ChainEpoch = -10
 	UpgradeActorsV3Height  abi.ChainEpoch = -11
 	UpgradeNorwegianHeight abi.ChainEpoch = -12
+	UpgradeActorsV4Height  abi.ChainEpoch = -13
 
 	DrandSchedule = map[abi.ChainEpoch]DrandEnum{
 		0: DrandMainnet,

chain/actors/builtin/account/account.go

@@ -14,6 +14,7 @@ import (
 	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
 	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
 	builtin3 "github.com/filecoin-project/specs-actors/v3/actors/builtin"
+	builtin4 "github.com/filecoin-project/specs-actors/v4/actors/builtin"
 )
 
 func init() {
@@ -26,9 +27,12 @@ func init() {
 	builtin.RegisterActorState(builtin3.AccountActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
 		return load3(store, root)
 	})
+	builtin.RegisterActorState(builtin4.AccountActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
+		return load4(store, root)
+	})
 }
 
-var Methods = builtin3.MethodsAccount
+var Methods = builtin4.MethodsAccount
 
 func Load(store adt.Store, act *types.Actor) (State, error) {
 	switch act.Code {
@@ -38,6 +42,8 @@ func Load(store adt.Store, act *types.Actor) (State, error) {
 		return load2(store, act.Head)
 	case builtin3.AccountActorCodeID:
 		return load3(store, act.Head)
+	case builtin4.AccountActorCodeID:
+		return load4(store, act.Head)
 	}
 	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
 }

chain/actors/builtin/account/v4.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"
+
+	account4 "github.com/filecoin-project/specs-actors/v4/actors/builtin/account"
+)
+
+var _ State = (*state4)(nil)
+
+func load4(store adt.Store, root cid.Cid) (State, error) {
+	out := state4{store: store}
+	err := store.Get(store.Context(), root, &out)
+	if err != nil {
+		return nil, err
+	}
+	return &out, nil
+}
+
+type state4 struct {
+	account4.State
+	store adt.Store
+}
+
+func (s *state4) PubkeyAddress() (address.Address, error) {
+	return s.Address, nil
+}

chain/actors/builtin/builtin.go

@@ -8,6 +8,7 @@ import (
 	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
 	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
 	builtin3 "github.com/filecoin-project/specs-actors/v3/actors/builtin"
+	builtin4 "github.com/filecoin-project/specs-actors/v4/actors/builtin"
 
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/cbor"
@@ -18,6 +19,7 @@ import (
 	smoothing0 "github.com/filecoin-project/specs-actors/actors/util/smoothing"
 	smoothing2 "github.com/filecoin-project/specs-actors/v2/actors/util/smoothing"
 	smoothing3 "github.com/filecoin-project/specs-actors/v3/actors/util/smoothing"
+	smoothing4 "github.com/filecoin-project/specs-actors/v4/actors/util/smoothing"
 
 	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
 	proof0 "github.com/filecoin-project/specs-actors/actors/runtime/proof"
@@ -41,8 +43,8 @@ const (
 )
 
 const (
-	MethodSend        = builtin3.MethodSend
+	MethodSend        = builtin4.MethodSend
-	MethodConstructor = builtin3.MethodConstructor
+	MethodConstructor = builtin4.MethodConstructor
 )
 
 // These are all just type aliases across actor versions 0, 2, & 3. In the future, that might change
@@ -68,6 +70,10 @@ func FromV3FilterEstimate(v3 smoothing3.FilterEstimate) FilterEstimate {
 	return (FilterEstimate)(v3)
 }
 
+func FromV4FilterEstimate(v4 smoothing4.FilterEstimate) FilterEstimate {
+	return (FilterEstimate)(v4)
+}
+
 type ActorStateLoader func(store adt.Store, root cid.Cid) (cbor.Marshaler, error)
 
 var ActorStateLoaders = make(map[cid.Cid]ActorStateLoader)
@@ -92,6 +98,8 @@ func ActorNameByCode(c cid.Cid) string {
 		return builtin2.ActorNameByCode(c)
 	case builtin3.IsBuiltinActor(c):
 		return builtin3.ActorNameByCode(c)
+	case builtin4.IsBuiltinActor(c):
+		return builtin4.ActorNameByCode(c)
 	default:
 		return "<unknown>"
 	}
@@ -100,32 +108,36 @@ func ActorNameByCode(c cid.Cid) string {
 func IsBuiltinActor(c cid.Cid) bool {
 	return builtin0.IsBuiltinActor(c) ||
 		builtin2.IsBuiltinActor(c) ||
-		builtin3.IsBuiltinActor(c)
+		builtin3.IsBuiltinActor(c) ||
+		builtin4.IsBuiltinActor(c)
 }
 
 func IsAccountActor(c cid.Cid) bool {
 	return c == builtin0.AccountActorCodeID ||
 		c == builtin2.AccountActorCodeID ||
-		c == builtin3.AccountActorCodeID
+		c == builtin3.AccountActorCodeID ||
+		c == builtin4.AccountActorCodeID
 }
 
 func IsStorageMinerActor(c cid.Cid) bool {
 	return c == builtin0.StorageMinerActorCodeID ||
 		c == builtin2.StorageMinerActorCodeID ||
-		c == builtin3.StorageMinerActorCodeID
+		c == builtin3.StorageMinerActorCodeID ||
+		c == builtin4.StorageMinerActorCodeID
 }
 
 func IsMultisigActor(c cid.Cid) bool {
 	return c == builtin0.MultisigActorCodeID ||
 		c == builtin2.MultisigActorCodeID ||
-		c == builtin3.MultisigActorCodeID
+		c == builtin3.MultisigActorCodeID ||
-
+		c == builtin4.MultisigActorCodeID
 }
 
 func IsPaymentChannelActor(c cid.Cid) bool {
 	return c == builtin0.PaymentChannelActorCodeID ||
 		c == builtin2.PaymentChannelActorCodeID ||
-		c == builtin3.PaymentChannelActorCodeID
+		c == builtin3.PaymentChannelActorCodeID ||
+		c == builtin4.PaymentChannelActorCodeID
 }
 
 func makeAddress(addr string) address.Address {

chain/actors/builtin/cron/cron.go

@@ -1,10 +1,10 @@
 package cron
 
 import (
-	builtin3 "github.com/filecoin-project/specs-actors/v3/actors/builtin"
+	builtin4 "github.com/filecoin-project/specs-actors/v4/actors/builtin"
 )
 
 var (
-	Address = builtin3.CronActorAddr
+	Address = builtin4.CronActorAddr
-	Methods = builtin3.MethodsCron
+	Methods = builtin4.MethodsCron
 )

chain/actors/builtin/init/init.go

@@ -16,6 +16,7 @@ import (
 	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
 	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
 	builtin3 "github.com/filecoin-project/specs-actors/v3/actors/builtin"
+	builtin4 "github.com/filecoin-project/specs-actors/v4/actors/builtin"
 )
 
 func init() {
@@ -28,11 +29,14 @@ func init() {
 	builtin.RegisterActorState(builtin3.InitActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
 		return load3(store, root)
 	})
+	builtin.RegisterActorState(builtin4.InitActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
+		return load4(store, root)
+	})
 }
 
 var (
-	Address = builtin3.InitActorAddr
+	Address = builtin4.InitActorAddr
-	Methods = builtin3.MethodsInit
+	Methods = builtin4.MethodsInit
 )
 
 func Load(store adt.Store, act *types.Actor) (State, error) {
@@ -43,6 +47,8 @@ func Load(store adt.Store, act *types.Actor) (State, error) {
 		return load2(store, act.Head)
 	case builtin3.InitActorCodeID:
 		return load3(store, act.Head)
+	case builtin4.InitActorCodeID:
+		return load4(store, act.Head)
 	}
 	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
 }

chain/actors/builtin/init/v4.go

@@ -0,0 +1,86 @@
+package init
+
+import (
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/abi"
+	builtin4 "github.com/filecoin-project/specs-actors/v4/actors/builtin"
+	"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"
+
+	init4 "github.com/filecoin-project/specs-actors/v4/actors/builtin/init"
+	adt4 "github.com/filecoin-project/specs-actors/v4/actors/util/adt"
+)
+
+var _ State = (*state4)(nil)
+
+func load4(store adt.Store, root cid.Cid) (State, error) {
+	out := state4{store: store}
+	err := store.Get(store.Context(), root, &out)
+	if err != nil {
+		return nil, err
+	}
+	return &out, nil
+}
+
+type state4 struct {
+	init4.State
+	store adt.Store
+}
+
+func (s *state4) ResolveAddress(address address.Address) (address.Address, bool, error) {
+	return s.State.ResolveAddress(s.store, address)
+}
+
+func (s *state4) MapAddressToNewID(address address.Address) (address.Address, error) {
+	return s.State.MapAddressToNewID(s.store, address)
+}
+
+func (s *state4) ForEachActor(cb func(id abi.ActorID, address address.Address) error) error {
+	addrs, err := adt4.AsMap(s.store, s.State.AddressMap, builtin4.DefaultHamtBitwidth)
+	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 *state4) NetworkName() (dtypes.NetworkName, error) {
+	return dtypes.NetworkName(s.State.NetworkName), nil
+}
+
+func (s *state4) SetNetworkName(name string) error {
+	s.State.NetworkName = name
+	return nil
+}
+
+func (s *state4) Remove(addrs ...address.Address) (err error) {
+	m, err := adt4.AsMap(s.store, s.State.AddressMap, builtin4.DefaultHamtBitwidth)
+	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
+}
+
+func (s *state4) addressMap() (adt.Map, error) {
+	return adt4.AsMap(s.store, s.AddressMap, builtin4.DefaultHamtBitwidth)
+}

chain/actors/builtin/market/market.go

@@ -13,6 +13,7 @@ import (
 	market0 "github.com/filecoin-project/specs-actors/actors/builtin/market"
 	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
 	builtin3 "github.com/filecoin-project/specs-actors/v3/actors/builtin"
+	builtin4 "github.com/filecoin-project/specs-actors/v4/actors/builtin"
 
 	"github.com/filecoin-project/lotus/chain/actors/adt"
 	"github.com/filecoin-project/lotus/chain/actors/builtin"
@@ -29,11 +30,14 @@ func init() {
 	builtin.RegisterActorState(builtin3.StorageMarketActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
 		return load3(store, root)
 	})
+	builtin.RegisterActorState(builtin4.StorageMarketActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
+		return load4(store, root)
+	})
 }
 
 var (
-	Address = builtin3.StorageMarketActorAddr
+	Address = builtin4.StorageMarketActorAddr
-	Methods = builtin3.MethodsMarket
+	Methods = builtin4.MethodsMarket
 )
 
 func Load(store adt.Store, act *types.Actor) (st State, err error) {
@@ -44,6 +48,8 @@ func Load(store adt.Store, act *types.Actor) (st State, err error) {
 		return load2(store, act.Head)
 	case builtin3.StorageMarketActorCodeID:
 		return load3(store, act.Head)
+	case builtin4.StorageMarketActorCodeID:
+		return load4(store, act.Head)
 	}
 	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
 }

chain/actors/builtin/market/v4.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"
+
+	market4 "github.com/filecoin-project/specs-actors/v4/actors/builtin/market"
+	adt4 "github.com/filecoin-project/specs-actors/v4/actors/util/adt"
+)
+
+var _ State = (*state4)(nil)
+
+func load4(store adt.Store, root cid.Cid) (State, error) {
+	out := state4{store: store}
+	err := store.Get(store.Context(), root, &out)
+	if err != nil {
+		return nil, err
+	}
+	return &out, nil
+}
+
+type state4 struct {
+	market4.State
+	store adt.Store
+}
+
+func (s *state4) TotalLocked() (abi.TokenAmount, error) {
+	fml := types.BigAdd(s.TotalClientLockedCollateral, s.TotalProviderLockedCollateral)
+	fml = types.BigAdd(fml, s.TotalClientStorageFee)
+	return fml, nil
+}
+
+func (s *state4) BalancesChanged(otherState State) (bool, error) {
+	otherState2, ok := otherState.(*state4)
+	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 *state4) StatesChanged(otherState State) (bool, error) {
+	otherState2, ok := otherState.(*state4)
+	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 *state4) States() (DealStates, error) {
+	stateArray, err := adt4.AsArray(s.store, s.State.States, market4.StatesAmtBitwidth)
+	if err != nil {
+		return nil, err
+	}
+	return &dealStates4{stateArray}, nil
+}
+
+func (s *state4) ProposalsChanged(otherState State) (bool, error) {
+	otherState2, ok := otherState.(*state4)
+	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 *state4) Proposals() (DealProposals, error) {
+	proposalArray, err := adt4.AsArray(s.store, s.State.Proposals, market4.ProposalsAmtBitwidth)
+	if err != nil {
+		return nil, err
+	}
+	return &dealProposals4{proposalArray}, nil
+}
+
+func (s *state4) EscrowTable() (BalanceTable, error) {
+	bt, err := adt4.AsBalanceTable(s.store, s.State.EscrowTable)
+	if err != nil {
+		return nil, err
+	}
+	return &balanceTable4{bt}, nil
+}
+
+func (s *state4) LockedTable() (BalanceTable, error) {
+	bt, err := adt4.AsBalanceTable(s.store, s.State.LockedTable)
+	if err != nil {
+		return nil, err
+	}
+	return &balanceTable4{bt}, nil
+}
+
+func (s *state4) VerifyDealsForActivation(
+	minerAddr address.Address, deals []abi.DealID, currEpoch, sectorExpiry abi.ChainEpoch,
+) (weight, verifiedWeight abi.DealWeight, err error) {
+	w, vw, _, err := market4.ValidateDealsForActivation(&s.State, s.store, deals, minerAddr, sectorExpiry, currEpoch)
+	return w, vw, err
+}
+
+type balanceTable4 struct {
+	*adt4.BalanceTable
+}
+
+func (bt *balanceTable4) ForEach(cb func(address.Address, abi.TokenAmount) error) error {
+	asMap := (*adt4.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 dealStates4 struct {
+	adt.Array
+}
+
+func (s *dealStates4) Get(dealID abi.DealID) (*DealState, bool, error) {
+	var deal2 market4.DealState
+	found, err := s.Array.Get(uint64(dealID), &deal2)
+	if err != nil {
+		return nil, false, err
+	}
+	if !found {
+		return nil, false, nil
+	}
+	deal := fromV4DealState(deal2)
+	return &deal, true, nil
+}
+
+func (s *dealStates4) ForEach(cb func(dealID abi.DealID, ds DealState) error) error {
+	var ds1 market4.DealState
+	return s.Array.ForEach(&ds1, func(idx int64) error {
+		return cb(abi.DealID(idx), fromV4DealState(ds1))
+	})
+}
+
+func (s *dealStates4) decode(val *cbg.Deferred) (*DealState, error) {
+	var ds1 market4.DealState
+	if err := ds1.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil {
+		return nil, err
+	}
+	ds := fromV4DealState(ds1)
+	return &ds, nil
+}
+
+func (s *dealStates4) array() adt.Array {
+	return s.Array
+}
+
+func fromV4DealState(v4 market4.DealState) DealState {
+	return (DealState)(v4)
+}
+
+type dealProposals4 struct {
+	adt.Array
+}
+
+func (s *dealProposals4) Get(dealID abi.DealID) (*DealProposal, bool, error) {
+	var proposal2 market4.DealProposal
+	found, err := s.Array.Get(uint64(dealID), &proposal2)
+	if err != nil {
+		return nil, false, err
+	}
+	if !found {
+		return nil, false, nil
+	}
+	proposal := fromV4DealProposal(proposal2)
+	return &proposal, true, nil
+}
+
+func (s *dealProposals4) ForEach(cb func(dealID abi.DealID, dp DealProposal) error) error {
+	var dp1 market4.DealProposal
+	return s.Array.ForEach(&dp1, func(idx int64) error {
+		return cb(abi.DealID(idx), fromV4DealProposal(dp1))
+	})
+}
+
+func (s *dealProposals4) decode(val *cbg.Deferred) (*DealProposal, error) {
+	var dp1 market4.DealProposal
+	if err := dp1.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil {
+		return nil, err
+	}
+	dp := fromV4DealProposal(dp1)
+	return &dp, nil
+}
+
+func (s *dealProposals4) array() adt.Array {
+	return s.Array
+}
+
+func fromV4DealProposal(v4 market4.DealProposal) DealProposal {
+	return (DealProposal)(v4)
+}

chain/actors/builtin/miner/miner.go

@@ -24,6 +24,7 @@ import (
 	miner2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/miner"
 	builtin3 "github.com/filecoin-project/specs-actors/v3/actors/builtin"
 	miner3 "github.com/filecoin-project/specs-actors/v3/actors/builtin/miner"
+	builtin4 "github.com/filecoin-project/specs-actors/v4/actors/builtin"
 )
 
 func init() {
@@ -36,11 +37,14 @@ func init() {
 	builtin.RegisterActorState(builtin3.StorageMinerActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
 		return load3(store, root)
 	})
+	builtin.RegisterActorState(builtin4.StorageMinerActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
+		return load4(store, root)
+	})
 }
 
-var Methods = builtin3.MethodsMiner
+var Methods = builtin4.MethodsMiner
 
-// Unchanged between v0, v2, and v3 actors
+// Unchanged between v0, v2, v3, and v4 actors
 var WPoStProvingPeriod = miner0.WPoStProvingPeriod
 var WPoStPeriodDeadlines = miner0.WPoStPeriodDeadlines
 var WPoStChallengeWindow = miner0.WPoStChallengeWindow
@@ -62,6 +66,8 @@ func Load(store adt.Store, act *types.Actor) (st State, err error) {
 		return load2(store, act.Head)
 	case builtin3.StorageMinerActorCodeID:
 		return load3(store, act.Head)
+	case builtin4.StorageMinerActorCodeID:
+		return load4(store, act.Head)
 	}
 	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
 }
@@ -94,6 +100,7 @@ type State interface {
 	MinerInfoChanged(State) (bool, error)
 
 	DeadlineInfo(epoch abi.ChainEpoch) (*dline.Info, error)
+	DeadlineCronActive() (bool, error)
 
 	// Diff helpers. Used by Diff* functions internally.
 	sectors() (adt.Array, error)

chain/actors/builtin/miner/v0.go

@@ -330,6 +330,10 @@ func (s *state0) DeadlineInfo(epoch abi.ChainEpoch) (*dline.Info, error) {
 	return s.State.DeadlineInfo(epoch), nil
 }
 
+func (s *state0) DeadlineCronActive() (bool, error) {
+	return true, nil // always active in this version
+}
+
 func (s *state0) sectors() (adt.Array, error) {
 	return adt0.AsArray(s.store, s.Sectors)
 }

chain/actors/builtin/miner/v2.go

@@ -329,6 +329,10 @@ func (s *state2) DeadlineInfo(epoch abi.ChainEpoch) (*dline.Info, error) {
 	return s.State.DeadlineInfo(epoch), nil
 }
 
+func (s *state2) DeadlineCronActive() (bool, error) {
+	return true, nil // always active in this version
+}
+
 func (s *state2) sectors() (adt.Array, error) {
 	return adt2.AsArray(s.store, s.Sectors)
 }

chain/actors/builtin/miner/v3.go

@@ -325,6 +325,10 @@ func (s *state3) DeadlineInfo(epoch abi.ChainEpoch) (*dline.Info, error) {
 	return s.State.DeadlineInfo(epoch), nil
 }
 
+func (s *state3) DeadlineCronActive() (bool, error) {
+	return true, nil // always active in this version
+}
+
 func (s *state3) sectors() (adt.Array, error) {
 	return adt3.AsArray(s.store, s.Sectors, miner3.SectorsAmtBitwidth)
 }

chain/actors/builtin/miner/v4.go

@@ -0,0 +1,438 @@
+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"
+
+	builtin4 "github.com/filecoin-project/specs-actors/v4/actors/builtin"
+	miner4 "github.com/filecoin-project/specs-actors/v4/actors/builtin/miner"
+	adt4 "github.com/filecoin-project/specs-actors/v4/actors/util/adt"
+)
+
+var _ State = (*state4)(nil)
+
+func load4(store adt.Store, root cid.Cid) (State, error) {
+	out := state4{store: store}
+	err := store.Get(store.Context(), root, &out)
+	if err != nil {
+		return nil, err
+	}
+	return &out, nil
+}
+
+type state4 struct {
+	miner4.State
+	store adt.Store
+}
+
+type deadline4 struct {
+	miner4.Deadline
+	store adt.Store
+}
+
+type partition4 struct {
+	miner4.Partition
+	store adt.Store
+}
+
+func (s *state4) AvailableBalance(bal abi.TokenAmount) (available abi.TokenAmount, err error) {
+	defer func() {
+		if r := recover(); r != nil {
+			err = xerrors.Errorf("failed to get available balance: %w", r)
+			available = abi.NewTokenAmount(0)
+		}
+	}()
+	// this panics if the miner doesnt have enough funds to cover their locked pledge
+	available, err = s.GetAvailableBalance(bal)
+	return available, err
+}
+
+func (s *state4) VestedFunds(epoch abi.ChainEpoch) (abi.TokenAmount, error) {
+	return s.CheckVestedFunds(s.store, epoch)
+}
+
+func (s *state4) LockedFunds() (LockedFunds, error) {
+	return LockedFunds{
+		VestingFunds:             s.State.LockedFunds,
+		InitialPledgeRequirement: s.State.InitialPledge,
+		PreCommitDeposits:        s.State.PreCommitDeposits,
+	}, nil
+}
+
+func (s *state4) FeeDebt() (abi.TokenAmount, error) {
+	return s.State.FeeDebt, nil
+}
+
+func (s *state4) InitialPledge() (abi.TokenAmount, error) {
+	return s.State.InitialPledge, nil
+}
+
+func (s *state4) PreCommitDeposits() (abi.TokenAmount, error) {
+	return s.State.PreCommitDeposits, nil
+}
+
+func (s *state4) GetSector(num abi.SectorNumber) (*SectorOnChainInfo, error) {
+	info, ok, err := s.State.GetSector(s.store, num)
+	if !ok || err != nil {
+		return nil, err
+	}
+
+	ret := fromV4SectorOnChainInfo(*info)
+	return &ret, nil
+}
+
+func (s *state4) 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 *state4) 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 *miner4.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 *state4) 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 *miner4.Deadline) error {
+		partitions, err := dl.PartitionsArray(s.store)
+		if err != nil {
+			return err
+		}
+		quant := s.State.QuantSpecForDeadline(dlIdx)
+		var part miner4.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 := miner4.LoadExpirationQueue(s.store, part.ExpirationsEpochs, quant, miner4.PartitionExpirationAmtBitwidth)
+			if err != nil {
+				return err
+			}
+			var exp miner4.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 *state4) GetPrecommittedSector(num abi.SectorNumber) (*SectorPreCommitOnChainInfo, error) {
+	info, ok, err := s.State.GetPrecommittedSector(s.store, num)
+	if !ok || err != nil {
+		return nil, err
+	}
+
+	ret := fromV4SectorPreCommitOnChainInfo(*info)
+
+	return &ret, nil
+}
+
+func (s *state4) LoadSectors(snos *bitfield.BitField) ([]*SectorOnChainInfo, error) {
+	sectors, err := miner4.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 miner4.SectorOnChainInfo
+		if err := sectors.ForEach(&info2, func(_ int64) error {
+			info := fromV4SectorOnChainInfo(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 := fromV4SectorOnChainInfo(*info2)
+		infos[i] = &info
+	}
+	return infos, nil
+}
+
+func (s *state4) 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 *state4) 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 &deadline4{*dl, s.store}, nil
+}
+
+func (s *state4) 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 *miner4.Deadline) error {
+		return cb(i, &deadline4{*dl, s.store})
+	})
+}
+
+func (s *state4) NumDeadlines() (uint64, error) {
+	return miner4.WPoStPeriodDeadlines, nil
+}
+
+func (s *state4) DeadlinesChanged(other State) (bool, error) {
+	other2, ok := other.(*state4)
+	if !ok {
+		// treat an upgrade as a change, always
+		return true, nil
+	}
+
+	return !s.State.Deadlines.Equals(other2.Deadlines), nil
+}
+
+func (s *state4) MinerInfoChanged(other State) (bool, error) {
+	other0, ok := other.(*state4)
+	if !ok {
+		// treat an upgrade as a change, always
+		return true, nil
+	}
+	return !s.State.Info.Equals(other0.State.Info), nil
+}
+
+func (s *state4) 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,
+		WindowPoStProofType:        info.WindowPoStProofType,
+		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 *state4) DeadlineInfo(epoch abi.ChainEpoch) (*dline.Info, error) {
+	return s.State.RecordedDeadlineInfo(epoch), nil
+}
+
+func (s *state4) DeadlineCronActive() (bool, error) {
+	return s.State.DeadlineCronActive, nil
+}
+
+func (s *state4) sectors() (adt.Array, error) {
+	return adt4.AsArray(s.store, s.Sectors, miner4.SectorsAmtBitwidth)
+}
+
+func (s *state4) decodeSectorOnChainInfo(val *cbg.Deferred) (SectorOnChainInfo, error) {
+	var si miner4.SectorOnChainInfo
+	err := si.UnmarshalCBOR(bytes.NewReader(val.Raw))
+	if err != nil {
+		return SectorOnChainInfo{}, err
+	}
+
+	return fromV4SectorOnChainInfo(si), nil
+}
+
+func (s *state4) precommits() (adt.Map, error) {
+	return adt4.AsMap(s.store, s.PreCommittedSectors, builtin4.DefaultHamtBitwidth)
+}
+
+func (s *state4) decodeSectorPreCommitOnChainInfo(val *cbg.Deferred) (SectorPreCommitOnChainInfo, error) {
+	var sp miner4.SectorPreCommitOnChainInfo
+	err := sp.UnmarshalCBOR(bytes.NewReader(val.Raw))
+	if err != nil {
+		return SectorPreCommitOnChainInfo{}, err
+	}
+
+	return fromV4SectorPreCommitOnChainInfo(sp), nil
+}
+
+func (d *deadline4) LoadPartition(idx uint64) (Partition, error) {
+	p, err := d.Deadline.LoadPartition(d.store, idx)
+	if err != nil {
+		return nil, err
+	}
+	return &partition4{*p, d.store}, nil
+}
+
+func (d *deadline4) ForEachPartition(cb func(uint64, Partition) error) error {
+	ps, err := d.Deadline.PartitionsArray(d.store)
+	if err != nil {
+		return err
+	}
+	var part miner4.Partition
+	return ps.ForEach(&part, func(i int64) error {
+		return cb(uint64(i), &partition4{part, d.store})
+	})
+}
+
+func (d *deadline4) PartitionsChanged(other Deadline) (bool, error) {
+	other2, ok := other.(*deadline4)
+	if !ok {
+		// treat an upgrade as a change, always
+		return true, nil
+	}
+
+	return !d.Deadline.Partitions.Equals(other2.Deadline.Partitions), nil
+}
+
+func (d *deadline4) PartitionsPoSted() (bitfield.BitField, error) {
+	return d.Deadline.PartitionsPoSted, nil
+}
+
+func (d *deadline4) DisputableProofCount() (uint64, error) {
+	ops, err := d.OptimisticProofsSnapshotArray(d.store)
+	if err != nil {
+		return 0, err
+	}
+
+	return ops.Length(), nil
+}
+
+func (p *partition4) AllSectors() (bitfield.BitField, error) {
+	return p.Partition.Sectors, nil
+}
+
+func (p *partition4) FaultySectors() (bitfield.BitField, error) {
+	return p.Partition.Faults, nil
+}
+
+func (p *partition4) RecoveringSectors() (bitfield.BitField, error) {
+	return p.Partition.Recoveries, nil
+}
+
+func fromV4SectorOnChainInfo(v4 miner4.SectorOnChainInfo) SectorOnChainInfo {
+	return SectorOnChainInfo{
+		SectorNumber:          v4.SectorNumber,
+		SealProof:             v4.SealProof,
+		SealedCID:             v4.SealedCID,
+		DealIDs:               v4.DealIDs,
+		Activation:            v4.Activation,
+		Expiration:            v4.Expiration,
+		DealWeight:            v4.DealWeight,
+		VerifiedDealWeight:    v4.VerifiedDealWeight,
+		InitialPledge:         v4.InitialPledge,
+		ExpectedDayReward:     v4.ExpectedDayReward,
+		ExpectedStoragePledge: v4.ExpectedStoragePledge,
+	}
+}
+
+func fromV4SectorPreCommitOnChainInfo(v4 miner4.SectorPreCommitOnChainInfo) SectorPreCommitOnChainInfo {
+	return SectorPreCommitOnChainInfo{
+		Info:               (SectorPreCommitInfo)(v4.Info),
+		PreCommitDeposit:   v4.PreCommitDeposit,
+		PreCommitEpoch:     v4.PreCommitEpoch,
+		DealWeight:         v4.DealWeight,
+		VerifiedDealWeight: v4.VerifiedDealWeight,
+	}
+}

chain/actors/builtin/multisig/message.go

@@ -9,14 +9,14 @@ import (
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
 
-	builtin3 "github.com/filecoin-project/specs-actors/v3/actors/builtin"
+	builtin4 "github.com/filecoin-project/specs-actors/v4/actors/builtin"
-	multisig3 "github.com/filecoin-project/specs-actors/v3/actors/builtin/multisig"
+	multisig4 "github.com/filecoin-project/specs-actors/v4/actors/builtin/multisig"
 
 	"github.com/filecoin-project/lotus/chain/actors"
 	"github.com/filecoin-project/lotus/chain/types"
 )
 
-var Methods = builtin3.MethodsMultisig
+var Methods = builtin4.MethodsMultisig
 
 func Message(version actors.Version, from address.Address) MessageBuilder {
 	switch version {
@@ -26,6 +26,8 @@ func Message(version actors.Version, from address.Address) MessageBuilder {
 		return message2{message0{from}}
 	case actors.Version3:
 		return message3{message0{from}}
+	case actors.Version4:
+		return message4{message0{from}}
 	default:
 		panic(fmt.Sprintf("unsupported actors version: %d", version))
 	}
@@ -49,12 +51,12 @@ type MessageBuilder interface {
 }
 
 // this type is the same between v0 and v2
-type ProposalHashData = multisig3.ProposalHashData
+type ProposalHashData = multisig4.ProposalHashData
-type ProposeReturn = multisig3.ProposeReturn
+type ProposeReturn = multisig4.ProposeReturn
-type ProposeParams = multisig3.ProposeParams
+type ProposeParams = multisig4.ProposeParams
 
 func txnParams(id uint64, data *ProposalHashData) ([]byte, error) {
-	params := multisig3.TxnIDParams{ID: multisig3.TxnID(id)}
+	params := multisig4.TxnIDParams{ID: multisig4.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)

chain/actors/builtin/multisig/message4.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"
+
+	builtin4 "github.com/filecoin-project/specs-actors/v4/actors/builtin"
+	init4 "github.com/filecoin-project/specs-actors/v4/actors/builtin/init"
+	multisig4 "github.com/filecoin-project/specs-actors/v4/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 message4 struct{ message0 }
+
+func (m message4) 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 := &multisig4.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 := &init4.ExecParams{
+		CodeCID:           builtin4.MultisigActorCodeID,
+		ConstructorParams: enc,
+	}
+
+	enc, actErr = actors.SerializeParams(execParams)
+	if actErr != nil {
+		return nil, actErr
+	}
+
+	return &types.Message{
+		To:     init_.Address,
+		From:   m.from,
+		Method: builtin4.MethodsInit.Exec,
+		Params: enc,
+		Value:  initialAmount,
+	}, nil
+}

chain/actors/builtin/multisig/state.go

@@ -13,6 +13,7 @@ import (
 	msig0 "github.com/filecoin-project/specs-actors/actors/builtin/multisig"
 	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
 	builtin3 "github.com/filecoin-project/specs-actors/v3/actors/builtin"
+	builtin4 "github.com/filecoin-project/specs-actors/v4/actors/builtin"
 
 	"github.com/filecoin-project/lotus/chain/actors/adt"
 	"github.com/filecoin-project/lotus/chain/actors/builtin"
@@ -29,6 +30,9 @@ func init() {
 	builtin.RegisterActorState(builtin3.MultisigActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
 		return load3(store, root)
 	})
+	builtin.RegisterActorState(builtin4.MultisigActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
+		return load4(store, root)
+	})
 }
 
 func Load(store adt.Store, act *types.Actor) (State, error) {
@@ -39,6 +43,8 @@ func Load(store adt.Store, act *types.Actor) (State, error) {
 		return load2(store, act.Head)
 	case builtin3.MultisigActorCodeID:
 		return load3(store, act.Head)
+	case builtin4.MultisigActorCodeID:
+		return load4(store, act.Head)
 	}
 	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
 }

chain/actors/builtin/multisig/state4.go

@@ -0,0 +1,95 @@
+package multisig
+
+import (
+	"bytes"
+	"encoding/binary"
+
+	adt4 "github.com/filecoin-project/specs-actors/v4/actors/util/adt"
+
+	"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"
+
+	builtin4 "github.com/filecoin-project/specs-actors/v4/actors/builtin"
+	msig4 "github.com/filecoin-project/specs-actors/v4/actors/builtin/multisig"
+)
+
+var _ State = (*state4)(nil)
+
+func load4(store adt.Store, root cid.Cid) (State, error) {
+	out := state4{store: store}
+	err := store.Get(store.Context(), root, &out)
+	if err != nil {
+		return nil, err
+	}
+	return &out, nil
+}
+
+type state4 struct {
+	msig4.State
+	store adt.Store
+}
+
+func (s *state4) LockedBalance(currEpoch abi.ChainEpoch) (abi.TokenAmount, error) {
+	return s.State.AmountLocked(currEpoch - s.State.StartEpoch), nil
+}
+
+func (s *state4) StartEpoch() (abi.ChainEpoch, error) {
+	return s.State.StartEpoch, nil
+}
+
+func (s *state4) UnlockDuration() (abi.ChainEpoch, error) {
+	return s.State.UnlockDuration, nil
+}
+
+func (s *state4) InitialBalance() (abi.TokenAmount, error) {
+	return s.State.InitialBalance, nil
+}
+
+func (s *state4) Threshold() (uint64, error) {
+	return s.State.NumApprovalsThreshold, nil
+}
+
+func (s *state4) Signers() ([]address.Address, error) {
+	return s.State.Signers, nil
+}
+
+func (s *state4) ForEachPendingTxn(cb func(id int64, txn Transaction) error) error {
+	arr, err := adt4.AsMap(s.store, s.State.PendingTxns, builtin4.DefaultHamtBitwidth)
+	if err != nil {
+		return err
+	}
+	var out msig4.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))
+	})
+}
+
+func (s *state4) PendingTxnChanged(other State) (bool, error) {
+	other2, ok := other.(*state4)
+	if !ok {
+		// treat an upgrade as a change, always
+		return true, nil
+	}
+	return !s.State.PendingTxns.Equals(other2.PendingTxns), nil
+}
+
+func (s *state4) transactions() (adt.Map, error) {
+	return adt4.AsMap(s.store, s.PendingTxns, builtin4.DefaultHamtBitwidth)
+}
+
+func (s *state4) decodeTransaction(val *cbg.Deferred) (Transaction, error) {
+	var tx msig4.Transaction
+	if err := tx.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil {
+		return Transaction{}, err
+	}
+	return tx, nil
+}

chain/actors/builtin/paych/message.go

@@ -8,10 +8,10 @@ import (
 	"github.com/filecoin-project/lotus/chain/actors"
 	"github.com/filecoin-project/lotus/chain/types"
 
-	builtin3 "github.com/filecoin-project/specs-actors/v3/actors/builtin"
+	builtin4 "github.com/filecoin-project/specs-actors/v4/actors/builtin"
 )
 
-var Methods = builtin3.MethodsPaych
+var Methods = builtin4.MethodsPaych
 
 func Message(version actors.Version, from address.Address) MessageBuilder {
 	switch version {
@@ -21,6 +21,8 @@ func Message(version actors.Version, from address.Address) MessageBuilder {
 		return message2{from}
 	case actors.Version3:
 		return message3{from}
+	case actors.Version4:
+		return message4{from}
 	default:
 		panic(fmt.Sprintf("unsupported actors version: %d", version))
 	}

chain/actors/builtin/paych/message4.go

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

chain/actors/builtin/paych/state.go

@@ -16,6 +16,7 @@ import (
 	paych0 "github.com/filecoin-project/specs-actors/actors/builtin/paych"
 	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
 	builtin3 "github.com/filecoin-project/specs-actors/v3/actors/builtin"
+	builtin4 "github.com/filecoin-project/specs-actors/v4/actors/builtin"
 
 	"github.com/filecoin-project/lotus/chain/actors/adt"
 	"github.com/filecoin-project/lotus/chain/actors/builtin"
@@ -32,6 +33,9 @@ func init() {
 	builtin.RegisterActorState(builtin3.PaymentChannelActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
 		return load3(store, root)
 	})
+	builtin.RegisterActorState(builtin4.PaymentChannelActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
+		return load4(store, root)
+	})
 }
 
 // Load returns an abstract copy of payment channel state, irregardless of actor version
@@ -43,6 +47,8 @@ func Load(store adt.Store, act *types.Actor) (State, error) {
 		return load2(store, act.Head)
 	case builtin3.PaymentChannelActorCodeID:
 		return load3(store, act.Head)
+	case builtin4.PaymentChannelActorCodeID:
+		return load4(store, act.Head)
 	}
 	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
 }

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

chain/actors/builtin/power/power.go

@@ -17,6 +17,7 @@ import (
 	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
 	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
 	builtin3 "github.com/filecoin-project/specs-actors/v3/actors/builtin"
+	builtin4 "github.com/filecoin-project/specs-actors/v4/actors/builtin"
 )
 
 func init() {
@@ -29,11 +30,14 @@ func init() {
 	builtin.RegisterActorState(builtin3.StoragePowerActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
 		return load3(store, root)
 	})
+	builtin.RegisterActorState(builtin4.StoragePowerActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
+		return load4(store, root)
+	})
 }
 
 var (
-	Address = builtin3.StoragePowerActorAddr
+	Address = builtin4.StoragePowerActorAddr
-	Methods = builtin3.MethodsPower
+	Methods = builtin4.MethodsPower
 )
 
 func Load(store adt.Store, act *types.Actor) (st State, err error) {
@@ -44,6 +48,8 @@ func Load(store adt.Store, act *types.Actor) (st State, err error) {
 		return load2(store, act.Head)
 	case builtin3.StoragePowerActorCodeID:
 		return load3(store, act.Head)
+	case builtin4.StoragePowerActorCodeID:
+		return load4(store, act.Head)
 	}
 	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
 }

chain/actors/builtin/power/v4.go

@@ -0,0 +1,149 @@
+package power
+
+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/actors/builtin"
+
+	builtin4 "github.com/filecoin-project/specs-actors/v4/actors/builtin"
+	power4 "github.com/filecoin-project/specs-actors/v4/actors/builtin/power"
+	adt4 "github.com/filecoin-project/specs-actors/v4/actors/util/adt"
+)
+
+var _ State = (*state4)(nil)
+
+func load4(store adt.Store, root cid.Cid) (State, error) {
+	out := state4{store: store}
+	err := store.Get(store.Context(), root, &out)
+	if err != nil {
+		return nil, err
+	}
+	return &out, nil
+}
+
+type state4 struct {
+	power4.State
+	store adt.Store
+}
+
+func (s *state4) TotalLocked() (abi.TokenAmount, error) {
+	return s.TotalPledgeCollateral, nil
+}
+
+func (s *state4) 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 *state4) TotalCommitted() (Claim, error) {
+	return Claim{
+		RawBytePower:    s.TotalBytesCommitted,
+		QualityAdjPower: s.TotalQABytesCommitted,
+	}, nil
+}
+
+func (s *state4) MinerPower(addr address.Address) (Claim, bool, error) {
+	claims, err := s.claims()
+	if err != nil {
+		return Claim{}, false, err
+	}
+	var claim power4.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 *state4) MinerNominalPowerMeetsConsensusMinimum(a address.Address) (bool, error) {
+	return s.State.MinerNominalPowerMeetsConsensusMinimum(s.store, a)
+}
+
+func (s *state4) TotalPowerSmoothed() (builtin.FilterEstimate, error) {
+	return builtin.FromV4FilterEstimate(s.State.ThisEpochQAPowerSmoothed), nil
+}
+
+func (s *state4) MinerCounts() (uint64, uint64, error) {
+	return uint64(s.State.MinerAboveMinPowerCount), uint64(s.State.MinerCount), nil
+}
+
+func (s *state4) ListAllMiners() ([]address.Address, error) {
+	claims, err := 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
+}
+
+func (s *state4) ForEachClaim(cb func(miner address.Address, claim Claim) error) error {
+	claims, err := s.claims()
+	if err != nil {
+		return err
+	}
+
+	var claim power4.Claim
+	return claims.ForEach(&claim, func(k string) error {
+		a, err := address.NewFromBytes([]byte(k))
+		if err != nil {
+			return err
+		}
+		return cb(a, Claim{
+			RawBytePower:    claim.RawBytePower,
+			QualityAdjPower: claim.QualityAdjPower,
+		})
+	})
+}
+
+func (s *state4) ClaimsChanged(other State) (bool, error) {
+	other2, ok := other.(*state4)
+	if !ok {
+		// treat an upgrade as a change, always
+		return true, nil
+	}
+	return !s.State.Claims.Equals(other2.State.Claims), nil
+}
+
+func (s *state4) claims() (adt.Map, error) {
+	return adt4.AsMap(s.store, s.Claims, builtin4.DefaultHamtBitwidth)
+}
+
+func (s *state4) decodeClaim(val *cbg.Deferred) (Claim, error) {
+	var ci power4.Claim
+	if err := ci.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil {
+		return Claim{}, err
+	}
+	return fromV4Claim(ci), nil
+}
+
+func fromV4Claim(v4 power4.Claim) Claim {
+	return Claim{
+		RawBytePower:    v4.RawBytePower,
+		QualityAdjPower: v4.QualityAdjPower,
+	}
+}

chain/actors/builtin/reward/reward.go

@@ -10,6 +10,7 @@ import (
 	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
 	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
 	builtin3 "github.com/filecoin-project/specs-actors/v3/actors/builtin"
+	builtin4 "github.com/filecoin-project/specs-actors/v4/actors/builtin"
 
 	"github.com/filecoin-project/lotus/chain/actors/adt"
 	"github.com/filecoin-project/lotus/chain/actors/builtin"
@@ -26,11 +27,14 @@ func init() {
 	builtin.RegisterActorState(builtin3.RewardActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
 		return load3(store, root)
 	})
+	builtin.RegisterActorState(builtin4.RewardActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
+		return load4(store, root)
+	})
 }
 
 var (
-	Address = builtin3.RewardActorAddr
+	Address = builtin4.RewardActorAddr
-	Methods = builtin3.MethodsReward
+	Methods = builtin4.MethodsReward
 )
 
 func Load(store adt.Store, act *types.Actor) (st State, err error) {
@@ -41,6 +45,8 @@ func Load(store adt.Store, act *types.Actor) (st State, err error) {
 		return load2(store, act.Head)
 	case builtin3.RewardActorCodeID:
 		return load3(store, act.Head)
+	case builtin4.RewardActorCodeID:
+		return load4(store, act.Head)
 	}
 	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
 }

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

chain/actors/builtin/verifreg/v4.go

@@ -0,0 +1,58 @@
+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"
+
+	builtin4 "github.com/filecoin-project/specs-actors/v4/actors/builtin"
+	verifreg4 "github.com/filecoin-project/specs-actors/v4/actors/builtin/verifreg"
+	adt4 "github.com/filecoin-project/specs-actors/v4/actors/util/adt"
+)
+
+var _ State = (*state4)(nil)
+
+func load4(store adt.Store, root cid.Cid) (State, error) {
+	out := state4{store: store}
+	err := store.Get(store.Context(), root, &out)
+	if err != nil {
+		return nil, err
+	}
+	return &out, nil
+}
+
+type state4 struct {
+	verifreg4.State
+	store adt.Store
+}
+
+func (s *state4) RootKey() (address.Address, error) {
+	return s.State.RootKey, nil
+}
+
+func (s *state4) VerifiedClientDataCap(addr address.Address) (bool, abi.StoragePower, error) {
+	return getDataCap(s.store, actors.Version4, s.verifiedClients, addr)
+}
+
+func (s *state4) VerifierDataCap(addr address.Address) (bool, abi.StoragePower, error) {
+	return getDataCap(s.store, actors.Version4, s.verifiers, addr)
+}
+
+func (s *state4) ForEachVerifier(cb func(addr address.Address, dcap abi.StoragePower) error) error {
+	return forEachCap(s.store, actors.Version4, s.verifiers, cb)
+}
+
+func (s *state4) ForEachClient(cb func(addr address.Address, dcap abi.StoragePower) error) error {
+	return forEachCap(s.store, actors.Version4, s.verifiedClients, cb)
+}
+
+func (s *state4) verifiedClients() (adt.Map, error) {
+	return adt4.AsMap(s.store, s.VerifiedClients, builtin4.DefaultHamtBitwidth)
+}
+
+func (s *state4) verifiers() (adt.Map, error) {
+	return adt4.AsMap(s.store, s.Verifiers, builtin4.DefaultHamtBitwidth)
+}

chain/actors/builtin/verifreg/verifreg.go

@@ -1,15 +1,17 @@
 package verifreg
 
 import (
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/abi"
-	builtin3 "github.com/filecoin-project/specs-actors/v3/actors/builtin"
 	"github.com/ipfs/go-cid"
 	"golang.org/x/xerrors"
 
+	"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"
 	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
+	builtin3 "github.com/filecoin-project/specs-actors/v3/actors/builtin"
+	builtin4 "github.com/filecoin-project/specs-actors/v4/actors/builtin"
 
 	"github.com/filecoin-project/lotus/chain/actors/adt"
 	"github.com/filecoin-project/lotus/chain/actors/builtin"
@@ -26,11 +28,14 @@ func init() {
 	builtin.RegisterActorState(builtin3.VerifiedRegistryActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
 		return load3(store, root)
 	})
+	builtin.RegisterActorState(builtin4.VerifiedRegistryActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
+		return load4(store, root)
+	})
 }
 
 var (
-	Address = builtin3.VerifiedRegistryActorAddr
+	Address = builtin4.VerifiedRegistryActorAddr
-	Methods = builtin3.MethodsVerifiedRegistry
+	Methods = builtin4.MethodsVerifiedRegistry
 )
 
 func Load(store adt.Store, act *types.Actor) (State, error) {
@@ -41,6 +46,8 @@ func Load(store adt.Store, act *types.Actor) (State, error) {
 		return load2(store, act.Head)
 	case builtin3.VerifiedRegistryActorCodeID:
 		return load3(store, act.Head)
+	case builtin4.VerifiedRegistryActorCodeID:
+		return load4(store, act.Head)
 	}
 	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
 }

chain/actors/policy/policy.go

@@ -20,14 +20,19 @@ import (
 	builtin3 "github.com/filecoin-project/specs-actors/v3/actors/builtin"
 	market3 "github.com/filecoin-project/specs-actors/v3/actors/builtin/market"
 	miner3 "github.com/filecoin-project/specs-actors/v3/actors/builtin/miner"
-	paych3 "github.com/filecoin-project/specs-actors/v3/actors/builtin/paych"
 	verifreg3 "github.com/filecoin-project/specs-actors/v3/actors/builtin/verifreg"
+
+	builtin4 "github.com/filecoin-project/specs-actors/v4/actors/builtin"
+	market4 "github.com/filecoin-project/specs-actors/v4/actors/builtin/market"
+	miner4 "github.com/filecoin-project/specs-actors/v4/actors/builtin/miner"
+	paych4 "github.com/filecoin-project/specs-actors/v4/actors/builtin/paych"
+	verifreg4 "github.com/filecoin-project/specs-actors/v4/actors/builtin/verifreg"
 )
 
 const (
-	ChainFinality          = miner3.ChainFinality
+	ChainFinality          = miner4.ChainFinality
 	SealRandomnessLookback = ChainFinality
-	PaychSettleDelay       = paych3.SettleDelay
+	PaychSettleDelay       = paych4.SettleDelay
 )
 
 // SetSupportedProofTypes sets supported proof types, across all actor versions.
@@ -42,6 +47,10 @@ func SetSupportedProofTypes(types ...abi.RegisteredSealProof) {
 	miner3.PreCommitSealProofTypesV7 = make(map[abi.RegisteredSealProof]struct{}, len(types)*2)
 	miner3.PreCommitSealProofTypesV8 = make(map[abi.RegisteredSealProof]struct{}, len(types))
 
+	miner4.PreCommitSealProofTypesV0 = make(map[abi.RegisteredSealProof]struct{}, len(types))
+	miner4.PreCommitSealProofTypesV7 = make(map[abi.RegisteredSealProof]struct{}, len(types)*2)
+	miner4.PreCommitSealProofTypesV8 = make(map[abi.RegisteredSealProof]struct{}, len(types))
+
 	AddSupportedProofTypes(types...)
 }
 
@@ -54,19 +63,21 @@ func AddSupportedProofTypes(types ...abi.RegisteredSealProof) {
 		}
 		// Set for all miner versions.
 		miner0.SupportedProofTypes[t] = struct{}{}
-		miner2.PreCommitSealProofTypesV0[t] = struct{}{}
 
+		miner2.PreCommitSealProofTypesV0[t] = struct{}{}
 		miner2.PreCommitSealProofTypesV7[t] = struct{}{}
 		miner2.PreCommitSealProofTypesV7[t+abi.RegisteredSealProof_StackedDrg2KiBV1_1] = struct{}{}
-
 		miner2.PreCommitSealProofTypesV8[t+abi.RegisteredSealProof_StackedDrg2KiBV1_1] = struct{}{}
 
 		miner3.PreCommitSealProofTypesV0[t] = struct{}{}
-
 		miner3.PreCommitSealProofTypesV7[t] = struct{}{}
 		miner3.PreCommitSealProofTypesV7[t+abi.RegisteredSealProof_StackedDrg2KiBV1_1] = struct{}{}
-
 		miner3.PreCommitSealProofTypesV8[t+abi.RegisteredSealProof_StackedDrg2KiBV1_1] = struct{}{}
+
+		miner4.PreCommitSealProofTypesV0[t] = struct{}{}
+		miner4.PreCommitSealProofTypesV7[t] = struct{}{}
+		miner4.PreCommitSealProofTypesV7[t+abi.RegisteredSealProof_StackedDrg2KiBV1_1] = struct{}{}
+		miner4.PreCommitSealProofTypesV8[t+abi.RegisteredSealProof_StackedDrg2KiBV1_1] = struct{}{}
 	}
 }
 
@@ -77,6 +88,7 @@ func SetPreCommitChallengeDelay(delay abi.ChainEpoch) {
 	miner0.PreCommitChallengeDelay = delay
 	miner2.PreCommitChallengeDelay = delay
 	miner3.PreCommitChallengeDelay = delay
+	miner4.PreCommitChallengeDelay = delay
 }
 
 // TODO: this function shouldn't really exist. Instead, the API should expose the precommit delay.
@@ -96,6 +108,10 @@ func SetConsensusMinerMinPower(p abi.StoragePower) {
 	for _, policy := range builtin3.PoStProofPolicies {
 		policy.ConsensusMinerMinPower = p
 	}
+
+	for _, policy := range builtin4.PoStProofPolicies {
+		policy.ConsensusMinerMinPower = p
+	}
 }
 
 // SetMinVerifiedDealSize sets the minimum size of a verified deal. This should
@@ -104,6 +120,7 @@ func SetMinVerifiedDealSize(size abi.StoragePower) {
 	verifreg0.MinVerifiedDealSize = size
 	verifreg2.MinVerifiedDealSize = size
 	verifreg3.MinVerifiedDealSize = size
+	verifreg4.MinVerifiedDealSize = size
 }
 
 func GetMaxProveCommitDuration(ver actors.Version, t abi.RegisteredSealProof) abi.ChainEpoch {
@@ -114,6 +131,8 @@ func GetMaxProveCommitDuration(ver actors.Version, t abi.RegisteredSealProof) ab
 		return miner2.MaxProveCommitDuration[t]
 	case actors.Version3:
 		return miner3.MaxProveCommitDuration[t]
+	case actors.Version4:
+		return miner4.MaxProveCommitDuration[t]
 	default:
 		panic("unsupported actors version")
 	}
@@ -131,6 +150,8 @@ func DealProviderCollateralBounds(
 		return market2.DealProviderCollateralBounds(size, verified, rawBytePower, qaPower, baselinePower, circulatingFil)
 	case actors.Version3:
 		return market3.DealProviderCollateralBounds(size, verified, rawBytePower, qaPower, baselinePower, circulatingFil)
+	case actors.Version4:
+		return market4.DealProviderCollateralBounds(size, verified, rawBytePower, qaPower, baselinePower, circulatingFil)
 	default:
 		panic("unsupported actors version")
 	}
@@ -150,6 +171,10 @@ func SetWPoStChallengeWindow(period abi.ChainEpoch) {
 	// by default, this is 2x finality which is 30 periods.
 	// scale it if we're scaling the challenge period.
 	miner3.WPoStDisputeWindow = period * 30
+
+	miner4.WPoStChallengeWindow = period
+	miner4.WPoStProvingPeriod = period * abi.ChainEpoch(miner4.WPoStPeriodDeadlines)
+	miner4.WPoStDisputeWindow = period * 30 // see the miner3 comment
 }
 
 func GetWinningPoStSectorSetLookback(nwVer network.Version) abi.ChainEpoch {
@@ -170,13 +195,13 @@ func GetMaxPoStPartitions(p abi.RegisteredPoStProof) (int, error) {
 	if err != nil {
 		return 0, err
 	}
-	return int(miner3.AddressedSectorsMax / sectorsPerPart), nil
+	return int(miner4.AddressedSectorsMax / sectorsPerPart), nil
 }
 
 func GetDefaultSectorSize() abi.SectorSize {
 	// supported sector sizes are the same across versions.
-	szs := make([]abi.SectorSize, 0, len(miner3.PreCommitSealProofTypesV8))
+	szs := make([]abi.SectorSize, 0, len(miner4.PreCommitSealProofTypesV8))
-	for spt := range miner3.PreCommitSealProofTypesV8 {
+	for spt := range miner4.PreCommitSealProofTypesV8 {
 		ss, err := spt.SectorSize()
 		if err != nil {
 			panic(err)
@@ -194,10 +219,10 @@ func GetDefaultSectorSize() abi.SectorSize {
 
 func GetSectorMaxLifetime(proof abi.RegisteredSealProof, nwVer network.Version) abi.ChainEpoch {
 	if nwVer <= network.Version10 {
-		return builtin3.SealProofPoliciesV0[proof].SectorMaxLifetime
+		return builtin4.SealProofPoliciesV0[proof].SectorMaxLifetime
 	}
 
-	return builtin3.SealProofPoliciesV11[proof].SectorMaxLifetime
+	return builtin4.SealProofPoliciesV11[proof].SectorMaxLifetime
 }
 
 func GetAddressedSectorsMax(nwVer network.Version) int {
@@ -208,6 +233,8 @@ func GetAddressedSectorsMax(nwVer network.Version) int {
 		return miner2.AddressedSectorsMax
 	case actors.Version3:
 		return miner3.AddressedSectorsMax
+	case actors.Version4:
+		return miner4.AddressedSectorsMax
 	default:
 		panic("unsupported network version")
 	}
@@ -222,6 +249,8 @@ func GetDeclarationsMax(nwVer network.Version) int {
 		return miner2.DeclarationsMax
 	case actors.Version3:
 		return miner3.DeclarationsMax
+	case actors.Version4:
+		return miner4.DeclarationsMax
 	default:
 		panic("unsupported network version")
 	}

chain/actors/version.go

@@ -12,6 +12,7 @@ const (
 	Version0 Version = 0
 	Version2 Version = 2
 	Version3 Version = 3
+	Version4 Version = 4
 )
 
 // Converts a network version into an actors adt version.
@@ -23,6 +24,8 @@ func VersionForNetwork(version network.Version) Version {
 		return Version2
 	case network.Version10, network.Version11:
 		return Version3
+	case network.Version12:
+		return Version4
 	default:
 		panic(fmt.Sprintf("unsupported network version %d", version))
 	}

chain/beacon/drand/drand.go

@@ -3,7 +3,6 @@ package drand
 import (
 	"bytes"
 	"context"
-	"sync"
 	"time"
 
 	dchain "github.com/drand/drand/chain"
@@ -13,6 +12,7 @@ import (
 	gclient "github.com/drand/drand/lp2p/client"
 	"github.com/drand/kyber"
 	kzap "github.com/go-kit/kit/log/zap"
+	lru "github.com/hashicorp/golang-lru"
 	"go.uber.org/zap/zapcore"
 	"golang.org/x/xerrors"
 
@@ -61,8 +61,7 @@ type DrandBeacon struct {
 	filGenTime   uint64
 	filRoundTime uint64
 
-	cacheLk    sync.Mutex
+	localCache *lru.Cache
-	localCache map[uint64]types.BeaconEntry
 }
 
 // DrandHTTPClient interface overrides the user agent used by drand
@@ -111,9 +110,14 @@ func NewDrandBeacon(genesisTs, interval uint64, ps *pubsub.PubSub, config dtypes
 		return nil, xerrors.Errorf("creating drand client")
 	}
 
+	lc, err := lru.New(1024)
+	if err != nil {
+		return nil, err
+	}
+
 	db := &DrandBeacon{
 		client:     client,
-		localCache: make(map[uint64]types.BeaconEntry),
+		localCache: lc,
 	}
 
 	db.pubkey = drandChain.PublicKey
@@ -156,19 +160,16 @@ func (db *DrandBeacon) Entry(ctx context.Context, round uint64) <-chan beacon.Re
 	return out
 }
 func (db *DrandBeacon) cacheValue(e types.BeaconEntry) {
-	db.cacheLk.Lock()
+	db.localCache.Add(e.Round, e)
-	defer db.cacheLk.Unlock()
-	db.localCache[e.Round] = e
 }
 
 func (db *DrandBeacon) getCachedValue(round uint64) *types.BeaconEntry {
-	db.cacheLk.Lock()
+	v, ok := db.localCache.Get(round)
-	defer db.cacheLk.Unlock()
-	v, ok := db.localCache[round]
 	if !ok {
 		return nil
 	}
-	return &v
+	e, _ := v.(*types.BeaconEntry)
+	return e
 }
 
 func (db *DrandBeacon) VerifyEntry(curr types.BeaconEntry, prev types.BeaconEntry) error {

chain/messagepool/selection.go

@@ -11,7 +11,9 @@ import (
 
 	"github.com/filecoin-project/go-address"
 	tbig "github.com/filecoin-project/go-state-types/big"
+	"github.com/filecoin-project/specs-actors/v3/actors/builtin"
 
+	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain/messagepool/gasguess"
 	"github.com/filecoin-project/lotus/chain/types"
@@ -698,6 +700,17 @@ func (*MessagePool) getGasPerf(gasReward *big.Int, gasLimit int64) float64 {
 	return r
 }
 
+func isMessageMute(m *types.Message, ts *types.TipSet) bool {
+	if api.RunningNodeType != api.NodeFull || ts.Height() > build.UpgradeActorsV4Height {
+		return false
+	}
+
+	if m.To == builtin.StoragePowerActorAddr {
+		return m.Method == builtin.MethodsPower.CreateMiner
+	}
+	return false
+}
+
 func (mp *MessagePool) createMessageChains(actor address.Address, mset map[uint64]*types.SignedMessage, baseFee types.BigInt, ts *types.TipSet) []*msgChain {
 	// collect all messages
 	msgs := make([]*types.SignedMessage, 0, len(mset))
@@ -758,6 +771,11 @@ func (mp *MessagePool) createMessageChains(actor address.Address, mset map[uint6
 		if balance.Cmp(required) < 0 {
 			break
 		}
+
+		if isMessageMute(&m.Message, ts) {
+			break
+		}
+
 		balance = new(big.Int).Sub(balance, required)
 
 		value := m.Message.Value.Int

chain/state/statetree.go

@@ -24,6 +24,7 @@ import (
 	states0 "github.com/filecoin-project/specs-actors/actors/states"
 	states2 "github.com/filecoin-project/specs-actors/v2/actors/states"
 	states3 "github.com/filecoin-project/specs-actors/v3/actors/states"
+	states4 "github.com/filecoin-project/specs-actors/v4/actors/states"
 )
 
 var log = logging.Logger("statetree")
@@ -184,6 +185,12 @@ func NewStateTree(cst cbor.IpldStore, ver types.StateTreeVersion) (*StateTree, e
 			return nil, xerrors.Errorf("failed to create state tree: %w", err)
 		}
 		hamt = tree.Map
+	case types.StateTreeVersion3:
+		tree, err := states4.NewTree(store)
+		if err != nil {
+			return nil, xerrors.Errorf("failed to create state tree: %w", err)
+		}
+		hamt = tree.Map
 	default:
 		return nil, xerrors.Errorf("unsupported state tree version: %d", ver)
 	}
@@ -233,6 +240,12 @@ func LoadStateTree(cst cbor.IpldStore, c cid.Cid) (*StateTree, error) {
 		if tree != nil {
 			hamt = tree.Map
 		}
+	case types.StateTreeVersion3:
+		var tree *states4.Tree
+		tree, err = states4.LoadTree(store, root.Actors)
+		if tree != nil {
+			hamt = tree.Map
+		}
 	default:
 		return nil, xerrors.Errorf("unsupported state tree version: %d", root.Version)
 	}

chain/stmgr/forks.go

@@ -34,6 +34,7 @@ import (
 	"github.com/filecoin-project/specs-actors/v2/actors/migration/nv4"
 	"github.com/filecoin-project/specs-actors/v2/actors/migration/nv7"
 	"github.com/filecoin-project/specs-actors/v3/actors/migration/nv10"
+	"github.com/filecoin-project/specs-actors/v4/actors/migration/nv12"
 	"github.com/ipfs/go-cid"
 	cbor "github.com/ipfs/go-ipld-cbor"
 	"golang.org/x/xerrors"
@@ -190,6 +191,22 @@ func DefaultUpgradeSchedule() UpgradeSchedule {
 		Height:    build.UpgradeNorwegianHeight,
 		Network:   network.Version11,
 		Migration: nil,
+	}, {
+		Height:    build.UpgradeActorsV4Height,
+		Network:   network.Version12,
+		Migration: UpgradeActorsV4,
+		PreMigrations: []PreMigration{{
+			PreMigration:    PreUpgradeActorsV4,
+			StartWithin:     120,
+			DontStartWithin: 60,
+			StopWithin:      35,
+		}, {
+			PreMigration:    PreUpgradeActorsV4,
+			StartWithin:     30,
+			DontStartWithin: 15,
+			StopWithin:      5,
+		}},
+		Expensive: true,
 	}}
 
 	for _, u := range updates {
@@ -1063,6 +1080,92 @@ func upgradeActorsV3Common(
 	return newRoot, nil
 }
 
+func UpgradeActorsV4(ctx context.Context, sm *StateManager, cache MigrationCache, cb ExecCallback, root cid.Cid, epoch abi.ChainEpoch, ts *types.TipSet) (cid.Cid, error) {
+	// Use all the CPUs except 3.
+	workerCount := runtime.NumCPU() - 3
+	if workerCount <= 0 {
+		workerCount = 1
+	}
+
+	config := nv12.Config{
+		MaxWorkers:        uint(workerCount),
+		JobQueueSize:      1000,
+		ResultQueueSize:   100,
+		ProgressLogPeriod: 10 * time.Second,
+	}
+
+	newRoot, err := upgradeActorsV4Common(ctx, sm, cache, root, epoch, ts, config)
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("migrating actors v4 state: %w", err)
+	}
+
+	return newRoot, nil
+}
+
+func PreUpgradeActorsV4(ctx context.Context, sm *StateManager, cache MigrationCache, root cid.Cid, epoch abi.ChainEpoch, ts *types.TipSet) error {
+	// Use half the CPUs for pre-migration, but leave at least 3.
+	workerCount := runtime.NumCPU()
+	if workerCount <= 4 {
+		workerCount = 1
+	} else {
+		workerCount /= 2
+	}
+	config := nv12.Config{MaxWorkers: uint(workerCount)}
+	_, err := upgradeActorsV4Common(ctx, sm, cache, root, epoch, ts, config)
+	return err
+}
+
+func upgradeActorsV4Common(
+	ctx context.Context, sm *StateManager, cache MigrationCache,
+	root cid.Cid, epoch abi.ChainEpoch, ts *types.TipSet,
+	config nv12.Config,
+) (cid.Cid, error) {
+	buf := blockstore.NewTieredBstore(sm.cs.StateBlockstore(), blockstore.NewMemorySync())
+	store := store.ActorStore(ctx, buf)
+
+	// Load the state root.
+	var stateRoot types.StateRoot
+	if err := store.Get(ctx, root, &stateRoot); err != nil {
+		return cid.Undef, xerrors.Errorf("failed to decode state root: %w", err)
+	}
+
+	if stateRoot.Version != types.StateTreeVersion2 {
+		return cid.Undef, xerrors.Errorf(
+			"expected state root version 2 for actors v4 upgrade, got %d",
+			stateRoot.Version,
+		)
+	}
+
+	// Perform the migration
+	newHamtRoot, err := nv12.MigrateStateTree(ctx, store, stateRoot.Actors, epoch, config, migrationLogger{}, cache)
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("upgrading to actors v2: %w", err)
+	}
+
+	// Persist the result.
+	newRoot, err := store.Put(ctx, &types.StateRoot{
+		Version: types.StateTreeVersion3,
+		Actors:  newHamtRoot,
+		Info:    stateRoot.Info,
+	})
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("failed to persist new state root: %w", err)
+	}
+
+	// Persist the new tree.
+
+	{
+		from := buf
+		to := buf.Read()
+
+		if err := vm.Copy(ctx, from, to, newRoot); err != nil {
+			return cid.Undef, xerrors.Errorf("copying migrated tree: %w", err)
+		}
+	}
+
+	return newRoot, nil
+}
+
 func setNetworkName(ctx context.Context, store adt.Store, tree *state.StateTree, name string) error {
 	ia, err := tree.GetActor(builtin0.InitActorAddr)
 	if err != nil {

chain/stmgr/utils.go

@@ -26,6 +26,7 @@ import (
 	exported0 "github.com/filecoin-project/specs-actors/actors/builtin/exported"
 	exported2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/exported"
 	exported3 "github.com/filecoin-project/specs-actors/v3/actors/builtin/exported"
+	exported4 "github.com/filecoin-project/specs-actors/v4/actors/builtin/exported"
 
 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/chain/actors/builtin"
@@ -548,6 +549,7 @@ func init() {
 	actors = append(actors, exported0.BuiltinActors()...)
 	actors = append(actors, exported2.BuiltinActors()...)
 	actors = append(actors, exported3.BuiltinActors()...)
+	actors = append(actors, exported4.BuiltinActors()...)
 
 	for _, actor := range actors {
 		exports := actor.Exports()

chain/types/state.go

@@ -11,8 +11,10 @@ const (
 	StateTreeVersion0 StateTreeVersion = iota
 	// StateTreeVersion1 corresponds to actors v2
 	StateTreeVersion1
-	// StateTreeVersion2 corresponds to actors >= v3.
+	// StateTreeVersion2 corresponds to actors v3.
 	StateTreeVersion2
+	// StateTreeVersion3 corresponds to actors >= v4.
+	StateTreeVersion3
 )
 
 type StateRoot struct {

chain/vm/invoker.go

@@ -18,6 +18,7 @@ import (
 	exported2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/exported"
 	vmr "github.com/filecoin-project/specs-actors/v2/actors/runtime"
 	exported3 "github.com/filecoin-project/specs-actors/v3/actors/builtin/exported"
+	exported4 "github.com/filecoin-project/specs-actors/v4/actors/builtin/exported"
 
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/exitcode"
@@ -64,6 +65,7 @@ func NewActorRegistry() *ActorRegistry {
 	inv.Register(ActorsVersionPredicate(actors.Version0), exported0.BuiltinActors()...)
 	inv.Register(ActorsVersionPredicate(actors.Version2), exported2.BuiltinActors()...)
 	inv.Register(ActorsVersionPredicate(actors.Version3), exported3.BuiltinActors()...)
+	inv.Register(ActorsVersionPredicate(actors.Version4), exported4.BuiltinActors()...)
 
 	return inv
 }

chain/vm/mkactor.go

@@ -17,6 +17,7 @@ import (
 	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
 	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
 	builtin3 "github.com/filecoin-project/specs-actors/v3/actors/builtin"
+	builtin4 "github.com/filecoin-project/specs-actors/v4/actors/builtin"
 
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/lotus/chain/actors/aerrors"
@@ -102,6 +103,8 @@ func newAccountActor(ver actors.Version) *types.Actor {
 		code = builtin2.AccountActorCodeID
 	case actors.Version3:
 		code = builtin3.AccountActorCodeID
+	case actors.Version4:
+		code = builtin4.AccountActorCodeID
 	default:
 		panic("unsupported actors version")
 	}

cmd/lotus-storage-miner/actor_test.go

@@ -51,7 +51,7 @@ func TestWorkerKeyChange(t *testing.T) {
 
 	blocktime := 1 * time.Millisecond
 
-	n, sn := builder.MockSbBuilder(t, []test.FullNodeOpts{test.FullNodeWithActorsV3At(2), test.FullNodeWithActorsV3At(2)}, test.OneMiner)
+	n, sn := builder.MockSbBuilder(t, []test.FullNodeOpts{test.FullNodeWithActorsV4At(-1), test.FullNodeWithActorsV4At(-1)}, test.OneMiner)
 
 	client1 := n[0]
 	client2 := n[1]

documentation/en/api-methods-miner.md

@@ -171,7 +171,7 @@ Response:
 ```json
 {
   "Version": "string value",
-  "APIVersion": 65792,
+  "APIVersion": 66048,
   "BlockDelay": 42
 }
 ```

documentation/en/api-methods-worker.md

@@ -146,7 +146,7 @@ Perms: admin
 
 Inputs: `null`
 
-Response: `65792`
+Response: `66048`
 
 ## Add
 

documentation/en/api-methods.md

@@ -255,7 +255,7 @@ Response:
 ```json
 {
   "Version": "string value",
-  "APIVersion": 65792,
+  "APIVersion": 66048,
   "BlockDelay": 42
 }
 ```

extern/sector-storage/mock/mock.go

@@ -27,6 +27,7 @@ var log = logging.Logger("sbmock")
 
 type SectorMgr struct {
 	sectors      map[abi.SectorID]*sectorState
+	failPoSt     bool
 	pieces       map[cid.Cid][]byte
 	nextSectorID abi.SectorNumber
 
@@ -263,6 +264,14 @@ func (mgr *SectorMgr) MarkFailed(sid storage.SectorRef, failed bool) error {
 	return nil
 }
 
+func (mgr *SectorMgr) Fail() {
+	mgr.lk.Lock()
+	defer mgr.lk.Unlock()
+	mgr.failPoSt = true
+
+	return
+}
+
 func (mgr *SectorMgr) MarkCorrupted(sid storage.SectorRef, corrupted bool) error {
 	mgr.lk.Lock()
 	defer mgr.lk.Unlock()
@@ -292,10 +301,20 @@ func AddOpFinish(ctx context.Context) (context.Context, func()) {
 }
 
 func (mgr *SectorMgr) GenerateWinningPoSt(ctx context.Context, minerID abi.ActorID, sectorInfo []proof2.SectorInfo, randomness abi.PoStRandomness) ([]proof2.PoStProof, error) {
+	mgr.lk.Lock()
+	defer mgr.lk.Unlock()
+
 	return generateFakePoSt(sectorInfo, abi.RegisteredSealProof.RegisteredWinningPoStProof, randomness), nil
 }
 
 func (mgr *SectorMgr) GenerateWindowPoSt(ctx context.Context, minerID abi.ActorID, sectorInfo []proof2.SectorInfo, randomness abi.PoStRandomness) ([]proof2.PoStProof, []abi.SectorID, error) {
+	mgr.lk.Lock()
+	defer mgr.lk.Unlock()
+
+	if mgr.failPoSt {
+		return nil, nil, xerrors.Errorf("failed to post (mock)")
+	}
+
 	si := make([]proof2.SectorInfo, 0, len(sectorInfo))
 	var skipped []abi.SectorID
 

go.mod

@@ -44,6 +44,7 @@ require (
 	github.com/filecoin-project/specs-actors v0.9.13
 	github.com/filecoin-project/specs-actors/v2 v2.3.5-0.20210114162132-5b58b773f4fb
 	github.com/filecoin-project/specs-actors/v3 v3.1.0
+	github.com/filecoin-project/specs-actors/v4 v4.0.0
 	github.com/filecoin-project/specs-storage v0.1.1-0.20201105051918-5188d9774506
 	github.com/filecoin-project/test-vectors/schema v0.0.5
 	github.com/gbrlsnchs/jwt/v3 v3.0.0-beta.1

go.sum

@@ -297,6 +297,8 @@ github.com/filecoin-project/specs-actors/v2 v2.3.5-0.20210114162132-5b58b773f4fb
 github.com/filecoin-project/specs-actors/v2 v2.3.5-0.20210114162132-5b58b773f4fb/go.mod h1:LljnY2Mn2homxZsmokJZCpRuhOPxfXhvcek5gWkmqAc=
 github.com/filecoin-project/specs-actors/v3 v3.1.0 h1:s4qiPw8pgypqBGAy853u/zdZJ7K9cTZdM1rTiSonHrg=
 github.com/filecoin-project/specs-actors/v3 v3.1.0/go.mod h1:mpynccOLlIRy0QnR008BwYBwT9fen+sPR13MA1VmMww=
+github.com/filecoin-project/specs-actors/v4 v4.0.0 h1:vMALksY5G3J5rj3q9rbcyB+f4Tk1xrLqSgdB3jOok4s=
+github.com/filecoin-project/specs-actors/v4 v4.0.0/go.mod h1:TkHXf/l7Wyw4ZejyXIPS2rK8bBO0rdwhTZyQQgaglng=
 github.com/filecoin-project/specs-storage v0.1.1-0.20201105051918-5188d9774506 h1:Ur/l2+6qN+lQiqjozWWc5p9UDaAMDZKTlDS98oRnlIw=
 github.com/filecoin-project/specs-storage v0.1.1-0.20201105051918-5188d9774506/go.mod h1:nJRRM7Aa9XVvygr3W9k6xGF46RWzr2zxF/iGoAIfA/g=
 github.com/filecoin-project/test-vectors/schema v0.0.5 h1:w3zHQhzM4pYxJDl21avXjOKBLF8egrvwUwjpT8TquDg=

lotuspond/front/src/chain/methods.json

@@ -306,5 +306,109 @@
     "AddVerifiedClient",
     "UseBytes",
     "RestoreBytes"
+  ],
+  "fil/4/account": [
+    "Send",
+    "Constructor",
+    "PubkeyAddress"
+  ],
+  "fil/4/cron": [
+    "Send",
+    "Constructor",
+    "EpochTick"
+  ],
+  "fil/4/init": [
+    "Send",
+    "Constructor",
+    "Exec"
+  ],
+  "fil/4/multisig": [
+    "Send",
+    "Constructor",
+    "Propose",
+    "Approve",
+    "Cancel",
+    "AddSigner",
+    "RemoveSigner",
+    "SwapSigner",
+    "ChangeNumApprovalsThreshold",
+    "LockBalance"
+  ],
+  "fil/4/paymentchannel": [
+    "Send",
+    "Constructor",
+    "UpdateChannelState",
+    "Settle",
+    "Collect"
+  ],
+  "fil/4/reward": [
+    "Send",
+    "Constructor",
+    "AwardBlockReward",
+    "ThisEpochReward",
+    "UpdateNetworkKPI"
+  ],
+  "fil/4/storagemarket": [
+    "Send",
+    "Constructor",
+    "AddBalance",
+    "WithdrawBalance",
+    "PublishStorageDeals",
+    "VerifyDealsForActivation",
+    "ActivateDeals",
+    "OnMinerSectorsTerminate",
+    "ComputeDataCommitment",
+    "CronTick"
+  ],
+  "fil/4/storageminer": [
+    "Send",
+    "Constructor",
+    "ControlAddresses",
+    "ChangeWorkerAddress",
+    "ChangePeerID",
+    "SubmitWindowedPoSt",
+    "PreCommitSector",
+    "ProveCommitSector",
+    "ExtendSectorExpiration",
+    "TerminateSectors",
+    "DeclareFaults",
+    "DeclareFaultsRecovered",
+    "OnDeferredCronEvent",
+    "CheckSectorProven",
+    "ApplyRewards",
+    "ReportConsensusFault",
+    "WithdrawBalance",
+    "ConfirmSectorProofsValid",
+    "ChangeMultiaddrs",
+    "CompactPartitions",
+    "CompactSectorNumbers",
+    "ConfirmUpdateWorkerKey",
+    "RepayDebt",
+    "ChangeOwnerAddress",
+    "DisputeWindowedPoSt"
+  ],
+  "fil/4/storagepower": [
+    "Send",
+    "Constructor",
+    "CreateMiner",
+    "UpdateClaimedPower",
+    "EnrollCronEvent",
+    "OnEpochTickEnd",
+    "UpdatePledgeTotal",
+    "SubmitPoRepForBulkVerify",
+    "CurrentTotalPower"
+  ],
+  "fil/4/system": [
+    "Send",
+    "Constructor"
+  ],
+  "fil/4/verifiedregistry": [
+    "Send",
+    "Constructor",
+    "AddVerifier",
+    "RemoveVerifier",
+    "AddVerifiedClient",
+    "UseBytes",
+    "RestoreBytes"
   ]
 }

node/node_test.go

@@ -229,3 +229,16 @@ func TestWindowPostDisputeFails(t *testing.T) {
 
 	test.TestWindowPostDisputeFails(t, builder.MockSbBuilder, 2*time.Millisecond)
 }
+
+func TestDeadlineToggling(t *testing.T) {
+	if os.Getenv("LOTUS_TEST_DEADLINE_TOGGLING") != "1" {
+		t.Skip("this takes a few minutes, set LOTUS_TEST_DEADLINE_TOGGLING=1 to run")
+	}
+	logging.SetLogLevel("miner", "ERROR")
+	logging.SetLogLevel("chainstore", "ERROR")
+	logging.SetLogLevel("chain", "ERROR")
+	logging.SetLogLevel("sub", "ERROR")
+	logging.SetLogLevel("storageminer", "FATAL")
+
+	test.TestDeadlineToggling(t, builder.MockSbBuilder, 2*time.Millisecond)
+}

node/test/builder.go

@@ -18,6 +18,7 @@ import (
 	"github.com/filecoin-project/go-jsonrpc"
 	"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-storedcounter"
 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/api/client"
@@ -26,6 +27,7 @@ import (
 	"github.com/filecoin-project/lotus/chain"
 	"github.com/filecoin-project/lotus/chain/actors"
 	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/power"
 	"github.com/filecoin-project/lotus/chain/gen"
 	genesis2 "github.com/filecoin-project/lotus/chain/gen/genesis"
 	"github.com/filecoin-project/lotus/chain/messagepool"
@@ -44,6 +46,7 @@ import (
 	"github.com/filecoin-project/lotus/node/repo"
 	"github.com/filecoin-project/lotus/storage/mockstorage"
 	miner2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/miner"
+	power2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/power"
 	"github.com/ipfs/go-datastore"
 	"github.com/libp2p/go-libp2p-core/crypto"
 	"github.com/libp2p/go-libp2p-core/peer"
@@ -151,6 +154,49 @@ func CreateTestStorageNode(ctx context.Context, t *testing.T, waddr address.Addr
 	return test.TestStorageNode{StorageMiner: minerapi, MineOne: mineOne, Stop: stop}
 }
 
+func storageBuilder(parentNode test.TestNode, mn mocknet.Mocknet, opts node.Option) test.StorageBuilder {
+	return func(ctx context.Context, t *testing.T, spt abi.RegisteredSealProof, owner address.Address) test.TestStorageNode {
+		pk, _, err := crypto.GenerateEd25519Key(rand.Reader)
+		require.NoError(t, err)
+
+		minerPid, err := peer.IDFromPrivateKey(pk)
+		require.NoError(t, err)
+
+		params, serr := actors.SerializeParams(&power2.CreateMinerParams{
+			Owner:         owner,
+			Worker:        owner,
+			SealProofType: spt,
+			Peer:          abi.PeerID(minerPid),
+		})
+		require.NoError(t, serr)
+
+		createStorageMinerMsg := &types.Message{
+			To:    power.Address,
+			From:  owner,
+			Value: big.Zero(),
+
+			Method: power.Methods.CreateMiner,
+			Params: params,
+
+			GasLimit:   0,
+			GasPremium: big.NewInt(5252),
+		}
+
+		signed, err := parentNode.MpoolPushMessage(ctx, createStorageMinerMsg, nil)
+		require.NoError(t, err)
+
+		mw, err := parentNode.StateWaitMsg(ctx, signed.Cid(), build.MessageConfidence)
+		require.NoError(t, err)
+		require.Equal(t, exitcode.Ok, mw.Receipt.ExitCode)
+
+		var retval power2.CreateMinerReturn
+		err = retval.UnmarshalCBOR(bytes.NewReader(mw.Receipt.Return))
+		require.NoError(t, err)
+
+		return CreateTestStorageNode(ctx, t, owner, retval.IDAddress, pk, parentNode, mn, opts)
+	}
+}
+
 func Builder(t *testing.T, fullOpts []test.FullNodeOpts, storage []test.StorageMiner) ([]test.TestNode, []test.TestStorageNode) {
 	return mockBuilderOpts(t, fullOpts, storage, false)
 }
@@ -266,6 +312,8 @@ func mockBuilderOpts(t *testing.T, fullOpts []test.FullNodeOpts, storage []test.
 		if rpc {
 			fulls[i] = fullRpc(t, fulls[i])
 		}
+
+		fulls[i].Stb = storageBuilder(fulls[i], mn, node.Options())
 	}
 
 	for i, def := range storage {
@@ -432,6 +480,14 @@ func mockSbBuilderOpts(t *testing.T, fullOpts []test.FullNodeOpts, storage []tes
 		if rpc {
 			fulls[i] = fullRpc(t, fulls[i])
 		}
+
+		fulls[i].Stb = storageBuilder(fulls[i], mn, node.Options(
+			node.Override(new(sectorstorage.SectorManager), func() (sectorstorage.SectorManager, error) {
+				return mock.NewMockSectorMgr(nil), nil
+			}),
+			node.Override(new(ffiwrapper.Verifier), mock.MockVerifier),
+			node.Unset(new(*sectorstorage.Manager)),
+		))
 	}
 
 	for i, def := range storage {