Merge pull request #4040 from filecoin-project/asr/changelog

Lotus version 0.8.0

CHANGELOG.md

@@ -1,5 +1,97 @@
 # Lotus changelog
 
+# 0.8.0 / 2020-09-26
+
+This consensus-breaking release of Lotus introduces an upgrade to the network. The changes that break consensus are:
+
+- Upgrading to specs-actors v0.9.11, which reduces WindowPoSt faults per [FIP 0002](https://github.com/filecoin-project/FIPs/blob/master/FIPS/fip-0002.md) to reduce cost for honest miners with occasional faults (see https://github.com/filecoin-project/specs-actors/pull/1181)
+- Revisions to some cryptoeconomics and network params
+
+This release also updates go-fil-markets to fix an incompatibility issue between v0.7.2 and earlier versions.
+
+## Changes 
+
+#### Dependencies
+
+- Update spec actors to 0.9.11 (https://github.com/filecoin-project/lotus/pull/4039)
+- Update markets to 0.6.3 (https://github.com/filecoin-project/lotus/pull/4013)
+
+#### Core Lotus
+
+- Network upgrade (https://github.com/filecoin-project/lotus/pull/4039)
+- Fix AddSupportedProofTypes (https://github.com/filecoin-project/lotus/pull/4033)
+- Return an error when we fail to find a sector when checking sector expiration (https://github.com/filecoin-project/lotus/pull/4026)
+- Batch blockstore copies after block validation (https://github.com/filecoin-project/lotus/pull/3980)
+- Remove a misleading miner actor abstraction (https://github.com/filecoin-project/lotus/pull/3977)
+- Fix out-of-bounds when loading all sector infos (https://github.com/filecoin-project/lotus/pull/3976)
+- Fix break condition in the miner (https://github.com/filecoin-project/lotus/pull/3953)
+
+#### UX
+
+- Correct helptext around miners setting ask (https://github.com/filecoin-project/lotus/pull/4009)
+- Make sync wait nicer (https://github.com/filecoin-project/lotus/pull/3991)
+
+#### Tooling and validation
+
+- Small adjustments following network upgradability changes (https://github.com/filecoin-project/lotus/pull/3996)
+- Add some more big pictures stats to stateroot stat (https://github.com/filecoin-project/lotus/pull/3995)
+- Add some actors policy setters for testing (https://github.com/filecoin-project/lotus/pull/3975)
+
+## Contributors
+
+The following contributors had 5 or more commits go into this release.
+We are grateful for every contribution!
+
+| Contributor        | Commits | Lines ±       |
+|--------------------|---------|---------------|
+| arajasek           | 66       | +3140/-1261  |
+| Stebalien          | 64       | +3797/-3434  |
+| magik6k            | 48       | +1892/-976   |
+| raulk              | 40       | +2412/-1549  |
+| vyzo               | 22       | +287/-196    |
+| alanshaw           | 15       | +761/-146    |
+| whyrusleeping      | 15       | +736/-52     |
+| hannahhoward       | 14       | +1237/837-   | 
+| anton              | 6        | +32/-8       |
+| travisperson       | 5        | +502/-6      |
+| Frank              | 5        | +78/-39      |
+| Jennifer           | 5        | +148/-41     |
+
+# 0.7.2 / 2020-09-23
+
+This optional release of Lotus introduces a major refactor around how a Lotus node interacts with code from the specs-actors repo. We now use interfaces to read the state of actors, which is required to be able to reason about different versions of actors code at the same time.
+
+Additionally, this release introduces various improvements to the sync process, as well as changes to better the overall UX experience.
+
+## Changes
+
+#### Core Lotus
+
+- Network upgrade support (https://github.com/filecoin-project/lotus/pull/3781)
+- Upgrade markets to `v0.6.2` (https://github.com/filecoin-project/lotus/pull/3974)
+- Validate chain sync response indices when fetching messages (https://github.com/filecoin-project/lotus/pull/3939)
+- Add height diff to sync wait (https://github.com/filecoin-project/lotus/pull/3926)
+- Replace Requires with Wants (https://github.com/filecoin-project/lotus/pull/3898)
+- Update state diffing for market actor (https://github.com/filecoin-project/lotus/pull/3889)
+- Parallel fetch for sync (https://github.com/filecoin-project/lotus/pull/3887)
+- Fix SectorState (https://github.com/filecoin-project/lotus/pull/3881)
+
+#### User Experience
+
+- Add basic deal stats api server for spacerace slingshot (https://github.com/filecoin-project/lotus/pull/3963)
+- When doing `sectors update-state`, show a list of existing states if user inputs an invalid one (https://github.com/filecoin-project/lotus/pull/3944)
+- Fix `lotus-miner storage find` error (https://github.com/filecoin-project/lotus/pull/3927)
+- Log shutdown method for lotus daemon and miner (https://github.com/filecoin-project/lotus/pull/3925)
+- Update build and setup instruction link (https://github.com/filecoin-project/lotus/pull/3919)
+- Add an option to hide removed sectors from `sectors list` output (https://github.com/filecoin-project/lotus/pull/3903)
+
+#### Testing and validation
+
+- Add init.State#Remove() for testing (https://github.com/filecoin-project/lotus/pull/3971)
+- lotus-shed: add consensus check command (https://github.com/filecoin-project/lotus/pull/3933)
+- Add keyinfo verify and jwt token command to lotus-shed (https://github.com/filecoin-project/lotus/pull/3914)
+- Fix conformance gen (https://github.com/filecoin-project/lotus/pull/3892)
+
 # 0.7.1 / 2020-09-17
 
 This optional release of Lotus introduces some critical fixes to the window PoSt process. It also upgrades some core dependencies, and introduces many improvements to the mining process, deal-making cycle, and overall User Experience.

api/api_full.go

@@ -21,9 +21,9 @@ import (
 	"github.com/filecoin-project/go-state-types/dline"
 	"github.com/filecoin-project/lotus/chain/actors/builtin/market"
 	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
-	"github.com/filecoin-project/specs-actors/actors/builtin/paych"
-	"github.com/filecoin-project/specs-actors/actors/runtime/proof"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/paych"
 
+	"github.com/filecoin-project/lotus/chain/actors/builtin"
 	"github.com/filecoin-project/lotus/chain/actors/builtin/power"
 	"github.com/filecoin-project/lotus/chain/types"
 	marketevents "github.com/filecoin-project/lotus/markets/loggers"
@@ -76,6 +76,9 @@ type FullNode interface {
 	// blockstore and returns raw bytes.
 	ChainReadObj(context.Context, cid.Cid) ([]byte, error)
 
+	// ChainDeleteObj deletes node referenced by the given CID
+	ChainDeleteObj(context.Context, cid.Cid) error
+
 	// ChainHasObj checks if a given CID exists in the chain blockstore.
 	ChainHasObj(context.Context, cid.Cid) (bool, error)
 
@@ -313,11 +316,9 @@ type FullNode interface {
 	// StateNetworkName returns the name of the network the node is synced to
 	StateNetworkName(context.Context) (dtypes.NetworkName, error)
 	// StateMinerSectors returns info about the given miner's sectors. If the filter bitfield is nil, all sectors are included.
-	// If the filterOut boolean is set to true, any sectors in the filter are excluded.
-	// If false, only those sectors in the filter are included.
-	StateMinerSectors(context.Context, address.Address, *bitfield.BitField, bool, types.TipSetKey) ([]*miner.ChainSectorInfo, error)
+	StateMinerSectors(context.Context, address.Address, *bitfield.BitField, types.TipSetKey) ([]*miner.SectorOnChainInfo, error)
 	// StateMinerActiveSectors returns info about sectors that a given miner is actively proving.
-	StateMinerActiveSectors(context.Context, address.Address, types.TipSetKey) ([]*miner.ChainSectorInfo, error)
+	StateMinerActiveSectors(context.Context, address.Address, types.TipSetKey) ([]*miner.SectorOnChainInfo, error)
 	// StateMinerProvingDeadline calculates the deadline at some epoch for a proving period
 	// and returns the deadline-related calculations.
 	StateMinerProvingDeadline(context.Context, address.Address, types.TipSetKey) (*dline.Info, error)
@@ -724,6 +725,8 @@ type ActiveSync struct {
 
 type SyncState struct {
 	ActiveSyncs []ActiveSync
+
+	VMApplied uint64
 }
 
 type SyncStateStage int
@@ -790,7 +793,7 @@ type CirculatingSupply struct {
 type MiningBaseInfo struct {
 	MinerPower      types.BigInt
 	NetworkPower    types.BigInt
-	Sectors         []proof.SectorInfo
+	Sectors         []builtin.SectorInfo
 	WorkerKey       address.Address
 	SectorSize      abi.SectorSize
 	PrevBeaconEntry types.BeaconEntry
@@ -807,7 +810,7 @@ type BlockTemplate struct {
 	Messages         []*types.SignedMessage
 	Epoch            abi.ChainEpoch
 	Timestamp        uint64
-	WinningPoStProof []proof.PoStProof
+	WinningPoStProof []builtin.PoStProof
 }
 
 type DataSize struct {

api/apistruct/struct.go

@@ -29,12 +29,12 @@ import (
 	"github.com/filecoin-project/lotus/extern/sector-storage/stores"
 	"github.com/filecoin-project/lotus/extern/sector-storage/storiface"
 	marketevents "github.com/filecoin-project/lotus/markets/loggers"
-	"github.com/filecoin-project/specs-actors/actors/builtin/paych"
 	"github.com/filecoin-project/specs-storage/storage"
 
 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/paych"
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/node/modules/dtypes"
 )
@@ -87,6 +87,7 @@ type FullNodeStruct struct {
 		ChainGetParentMessages        func(context.Context, cid.Cid) ([]api.Message, error)                                                              `perm:"read"`
 		ChainGetTipSetByHeight        func(context.Context, abi.ChainEpoch, types.TipSetKey) (*types.TipSet, error)                                      `perm:"read"`
 		ChainReadObj                  func(context.Context, cid.Cid) ([]byte, error)                                                                     `perm:"read"`
+		ChainDeleteObj                func(context.Context, cid.Cid) error                                                                               `perm:"admin"`
 		ChainHasObj                   func(context.Context, cid.Cid) (bool, error)                                                                       `perm:"read"`
 		ChainStatObj                  func(context.Context, cid.Cid, cid.Cid) (api.ObjStat, error)                                                       `perm:"read"`
 		ChainSetHead                  func(context.Context, types.TipSetKey) error                                                                       `perm:"admin"`
@@ -162,8 +163,8 @@ type FullNodeStruct struct {
 		ClientRetrieveTryRestartInsufficientFunds func(ctx context.Context, paymentChannel address.Address) error                                                   `perm:"write"`
 
 		StateNetworkName                   func(context.Context) (dtypes.NetworkName, error)                                                                   `perm:"read"`
-		StateMinerSectors                  func(context.Context, address.Address, *bitfield.BitField, bool, types.TipSetKey) ([]*miner.ChainSectorInfo, error) `perm:"read"`
-		StateMinerActiveSectors            func(context.Context, address.Address, types.TipSetKey) ([]*miner.ChainSectorInfo, error)                           `perm:"read"`
+		StateMinerSectors                  func(context.Context, address.Address, *bitfield.BitField, types.TipSetKey) ([]*miner.SectorOnChainInfo, error)     `perm:"read"`
+		StateMinerActiveSectors            func(context.Context, address.Address, types.TipSetKey) ([]*miner.SectorOnChainInfo, error)                         `perm:"read"`
 		StateMinerProvingDeadline          func(context.Context, address.Address, types.TipSetKey) (*dline.Info, error)                                        `perm:"read"`
 		StateMinerPower                    func(context.Context, address.Address, types.TipSetKey) (*api.MinerPower, error)                                    `perm:"read"`
 		StateMinerInfo                     func(context.Context, address.Address, types.TipSetKey) (miner.MinerInfo, error)                                    `perm:"read"`
@@ -662,6 +663,10 @@ func (c *FullNodeStruct) ChainReadObj(ctx context.Context, obj cid.Cid) ([]byte,
 	return c.Internal.ChainReadObj(ctx, obj)
 }
 
+func (c *FullNodeStruct) ChainDeleteObj(ctx context.Context, obj cid.Cid) error {
+	return c.Internal.ChainDeleteObj(ctx, obj)
+}
+
 func (c *FullNodeStruct) ChainHasObj(ctx context.Context, o cid.Cid) (bool, error) {
 	return c.Internal.ChainHasObj(ctx, o)
 }
@@ -734,11 +739,11 @@ func (c *FullNodeStruct) StateNetworkName(ctx context.Context) (dtypes.NetworkNa
 	return c.Internal.StateNetworkName(ctx)
 }
 
-func (c *FullNodeStruct) StateMinerSectors(ctx context.Context, addr address.Address, filter *bitfield.BitField, filterOut bool, tsk types.TipSetKey) ([]*miner.ChainSectorInfo, error) {
-	return c.Internal.StateMinerSectors(ctx, addr, filter, filterOut, tsk)
+func (c *FullNodeStruct) StateMinerSectors(ctx context.Context, addr address.Address, sectorNos *bitfield.BitField, tsk types.TipSetKey) ([]*miner.SectorOnChainInfo, error) {
+	return c.Internal.StateMinerSectors(ctx, addr, sectorNos, tsk)
 }
 
-func (c *FullNodeStruct) StateMinerActiveSectors(ctx context.Context, addr address.Address, tsk types.TipSetKey) ([]*miner.ChainSectorInfo, error) {
+func (c *FullNodeStruct) StateMinerActiveSectors(ctx context.Context, addr address.Address, tsk types.TipSetKey) ([]*miner.SectorOnChainInfo, error) {
 	return c.Internal.StateMinerActiveSectors(ctx, addr, tsk)
 }
 

api/test/ccupgrade.go

@@ -94,6 +94,22 @@ func TestCCUpgrade(t *testing.T, b APIBuilder, blocktime time.Duration) {
 		require.Less(t, 50000, int(exp.OnTime))
 	}
 
+	dlInfo, err := client.StateMinerProvingDeadline(ctx, maddr, types.EmptyTSK)
+	require.NoError(t, err)
+
+	// Sector should expire.
+	for {
+		// Wait for the sector to expire.
+		status, err := miner.SectorsStatus(ctx, CC, true)
+		require.NoError(t, err)
+		if status.OnTime == 0 && status.Early == 0 {
+			break
+		}
+		t.Log("waiting for sector to expire")
+		// wait one deadline per loop.
+		time.Sleep(time.Duration(dlInfo.WPoStChallengeWindow) * blocktime)
+	}
+
 	fmt.Println("shutting down mining")
 	atomic.AddInt64(&mine, -1)
 	<-done

build/bootstrap/bootstrappers.pi

@@ -1,2 +1,6 @@
-/dns4/bootstrap-0.butterfly.fildev.network/tcp/1347/p2p/12D3KooWGnRx1WypbTcGsxw8k4fXP2RmFSGqGUxNYn8E6rLS5Qnp
-/dns4/bootstrap-1.butterfly.fildev.network/tcp/1347/p2p/12D3KooWG1ns2ejaTx9HQhe4F5ox6PPE4misuJqNFzHa4pSdVVdq
+/dns4/bootstrap-0.testnet.fildev.network/tcp/1347/p2p/12D3KooWJTUBUjtzWJGWU1XSiY21CwmHaCNLNYn2E7jqHEHyZaP7
+/dns4/bootstrap-1.testnet.fildev.network/tcp/1347/p2p/12D3KooW9yeKXha4hdrJKq74zEo99T8DhriQdWNoojWnnQbsgB3v
+/dns4/bootstrap-2.testnet.fildev.network/tcp/1347/p2p/12D3KooWCrx8yVG9U9Kf7w8KLN3Edkj5ZKDhgCaeMqQbcQUoB6CT
+/dns4/bootstrap-4.testnet.fildev.network/tcp/1347/p2p/12D3KooWPkL9LrKRQgHtq7kn9ecNhGU9QaziG8R5tX8v9v7t3h34
+/dns4/bootstrap-3.testnet.fildev.network/tcp/1347/p2p/12D3KooWKYSsbpgZ3HAjax5M1BXCwXLa6gVkUARciz7uN3FNtr7T
+/dns4/bootstrap-5.testnet.fildev.network/tcp/1347/p2p/12D3KooWQYzqnLASJAabyMpPb1GcWZvNSe7JDcRuhdRqonFoiK9W

build/params_2k.go

@@ -4,27 +4,25 @@ package build
 
 import (
 	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/go-state-types/big"
-	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
-	power0 "github.com/filecoin-project/specs-actors/actors/builtin/power"
-	verifreg0 "github.com/filecoin-project/specs-actors/actors/builtin/verifreg"
+
+	"github.com/filecoin-project/lotus/chain/actors/policy"
 )
 
 const UpgradeBreezeHeight = -1
 const BreezeGasTampingDuration = 0
 
 const UpgradeSmokeHeight = -1
+const UpgradeIgnitionHeight = -2
+const UpgradeLiftoffHeight = -3
 
 var DrandSchedule = map[abi.ChainEpoch]DrandEnum{
 	0: DrandMainnet,
 }
 
 func init() {
-	power0.ConsensusMinerMinPower = big.NewInt(2048)
-	miner0.SupportedProofTypes = map[abi.RegisteredSealProof]struct{}{
-		abi.RegisteredSealProof_StackedDrg2KiBV1: {},
-	}
-	verifreg0.MinVerifiedDealSize = big.NewInt(256)
+	policy.SetSupportedProofTypes(abi.RegisteredSealProof_StackedDrg2KiBV1)
+	policy.SetConsensusMinerMinPower(abi.NewStoragePower(2048))
+	policy.SetMinVerifiedDealSize(abi.NewStoragePower(256))
 
 	BuildType |= Build2k
 }

build/params_shared_vals.go

@@ -22,8 +22,8 @@ const UnixfsLinksPerLevel = 1024
 // Consensus / Network
 
 const AllowableClockDriftSecs = uint64(1)
-const NewestNetworkVersion = network.Version2
-const ActorUpgradeNetworkVersion = network.Version3
+const NewestNetworkVersion = network.Version3
+const ActorUpgradeNetworkVersion = network.Version4
 
 // Epochs
 const ForkLengthThreshold = Finality
@@ -63,6 +63,8 @@ const WinningPoStSectorSetLookback = abi.ChainEpoch(10)
 // /////
 // Devnet settings
 
+var Devnet = true
+
 const FilBase = uint64(2_000_000_000)
 const FilAllocStorageMining = uint64(1_100_000_000)
 

build/params_testground.go

@@ -74,7 +74,9 @@ var (
 	UpgradeBreezeHeight      abi.ChainEpoch = -1
 	BreezeGasTampingDuration abi.ChainEpoch = 0
 
-	UpgradeSmokeHeight abi.ChainEpoch = -1
+	UpgradeSmokeHeight    abi.ChainEpoch = -1
+	UpgradeIgnitionHeight abi.ChainEpoch = -2
+	UpgradeLiftoffHeight  abi.ChainEpoch = -3
 
 	DrandSchedule = map[abi.ChainEpoch]DrandEnum{
 		0: DrandMainnet,
@@ -82,4 +84,6 @@ var (
 
 	NewestNetworkVersion       = network.Version2
 	ActorUpgradeNetworkVersion = network.Version3
+
+	Devnet = true
 )

build/params_testnet.go

@@ -6,27 +6,37 @@ package build
 
 import (
 	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/specs-actors/actors/builtin"
-	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
+	"github.com/filecoin-project/lotus/chain/actors/policy"
+
+	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
 )
 
 var DrandSchedule = map[abi.ChainEpoch]DrandEnum{
-	0: DrandMainnet,
+	0:                  DrandIncentinet,
+	UpgradeSmokeHeight: DrandMainnet,
 }
 
-const UpgradeBreezeHeight = -1
+const UpgradeBreezeHeight = 41280
 const BreezeGasTampingDuration = 120
 
-const UpgradeSmokeHeight = -1
+const UpgradeSmokeHeight = 51000
+
+const UpgradeIgnitionHeight = 94000
+
+// This signals our tentative epoch for mainnet launch. Can make it later, but not earlier.
+// Miners, clients, developers, custodians all need time to prepare.
+// We still have upgrades and state changes to do, but can happen after signaling timing here.
+const UpgradeLiftoffHeight = 148888
 
 func init() {
-	miner0.SupportedProofTypes = map[abi.RegisteredSealProof]struct{}{
-		abi.RegisteredSealProof_StackedDrg512MiBV1: {},
-		abi.RegisteredSealProof_StackedDrg32GiBV1:  {},
-		abi.RegisteredSealProof_StackedDrg64GiBV1:  {},
-	}
+	policy.SetConsensusMinerMinPower(abi.NewStoragePower(10 << 40))
+	policy.SetSupportedProofTypes(
+		abi.RegisteredSealProof_StackedDrg32GiBV1,
+		abi.RegisteredSealProof_StackedDrg64GiBV1,
+	)
+	Devnet = false
 }
 
-const BlockDelaySecs = uint64(builtin.EpochDurationSeconds)
+const BlockDelaySecs = uint64(builtin0.EpochDurationSeconds)
 
 const PropagationDelaySecs = uint64(6)

build/version.go

@@ -29,7 +29,7 @@ func buildType() string {
 }
 
 // BuildVersion is the local build version, set by build system
-const BuildVersion = "0.7.1"
+const BuildVersion = "0.8.0"
 
 func UserVersion() string {
 	return BuildVersion + buildType() + CurrentCommit
@@ -83,9 +83,9 @@ func VersionForType(nodeType NodeType) (Version, error) {
 
 // semver versions of the rpc api exposed
 var (
-	FullAPIVersion   = newVer(0, 15, 0)
-	MinerAPIVersion  = newVer(0, 14, 0)
-	WorkerAPIVersion = newVer(0, 14, 0)
+	FullAPIVersion   = newVer(0, 16, 0)
+	MinerAPIVersion  = newVer(0, 15, 0)
+	WorkerAPIVersion = newVer(0, 15, 0)
 )
 
 //nolint:varcheck,deadcode

chain/actors/adt/adt.go

@@ -55,3 +55,11 @@ func AsArray(store Store, root cid.Cid, version network.Version) (Array, error)
 	}
 	return nil, xerrors.Errorf("unknown network version: %d", version)
 }
+
+func NewArray(store Store, version builtin.Version) (Array, error) {
+	switch version {
+	case builtin.Version0:
+		return adt0.MakeEmptyArray(store), nil
+	}
+	return nil, xerrors.Errorf("unknown network version: %d", version)
+}

chain/actors/adt/diff_adt.go

@@ -27,6 +27,7 @@ type AdtArrayDiff interface {
 // - All values that exist in preArr and in curArr are passed to AdtArrayDiff.Modify()
 //  - It is the responsibility of AdtArrayDiff.Modify() to determine if the values it was passed have been modified.
 func DiffAdtArray(preArr, curArr Array, out AdtArrayDiff) error {
+	notNew := make(map[int64]struct{}, curArr.Length())
 	prevVal := new(typegen.Deferred)
 	if err := preArr.ForEach(prevVal, func(i int64) error {
 		curVal := new(typegen.Deferred)
@@ -47,14 +48,17 @@ func DiffAdtArray(preArr, curArr Array, out AdtArrayDiff) error {
 				return err
 			}
 		}
-
-		return curArr.Delete(uint64(i))
+		notNew[i] = struct{}{}
+		return nil
 	}); err != nil {
 		return err
 	}
 
 	curVal := new(typegen.Deferred)
 	return curArr.ForEach(curVal, func(i int64) error {
+		if _, ok := notNew[i]; ok {
+			return nil
+		}
 		return out.Add(uint64(i), curVal)
 	})
 }
@@ -76,6 +80,7 @@ type AdtMapDiff interface {
 }
 
 func DiffAdtMap(preMap, curMap Map, out AdtMapDiff) error {
+	notNew := make(map[string]struct{})
 	prevVal := new(typegen.Deferred)
 	if err := preMap.ForEach(prevVal, func(key string) error {
 		curVal := new(typegen.Deferred)
@@ -101,14 +106,17 @@ func DiffAdtMap(preMap, curMap Map, out AdtMapDiff) error {
 				return err
 			}
 		}
-
-		return curMap.Delete(k)
+		notNew[key] = struct{}{}
+		return nil
 	}); err != nil {
 		return err
 	}
 
 	curVal := new(typegen.Deferred)
 	return curMap.ForEach(curVal, func(key string) error {
+		if _, ok := notNew[key]; ok {
+			return nil
+		}
 		return out.Add(key, curVal)
 	})
 }

chain/actors/builtin/account/v0.go

@@ -6,6 +6,8 @@ import (
 	"github.com/filecoin-project/specs-actors/actors/builtin/account"
 )
 
+var _ State = (*state0)(nil)
+
 type state0 struct {
 	account.State
 	store adt.Store

chain/actors/builtin/builtin.go

@@ -3,9 +3,13 @@ package builtin
 import (
 	"fmt"
 
-	"github.com/filecoin-project/go-state-types/network"
+	"github.com/filecoin-project/go-state-types/abi"
+	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
+	proof0 "github.com/filecoin-project/specs-actors/actors/runtime/proof"
 
 	smoothing0 "github.com/filecoin-project/specs-actors/actors/util/smoothing"
+
+	"github.com/filecoin-project/go-state-types/network"
 )
 
 type Version int
@@ -17,12 +21,23 @@ const (
 // Converts a network version into a specs-actors version.
 func VersionForNetwork(version network.Version) Version {
 	switch version {
-	case network.Version0, network.Version1, network.Version2:
+	case network.Version0, network.Version1, network.Version2, network.Version3:
 		return Version0
 	default:
 		panic(fmt.Sprintf("unsupported network version %d", version))
 	}
 }
 
-// TODO: find some way to abstract over this.
+// TODO: Why does actors have 2 different versions of this?
+type SectorInfo = proof0.SectorInfo
+type PoStProof = proof0.PoStProof
 type FilterEstimate = smoothing0.FilterEstimate
+
+func FromV0FilterEstimate(v0 smoothing0.FilterEstimate) FilterEstimate {
+	return (FilterEstimate)(v0)
+}
+
+// Doesn't change between actors v0 and v1
+func QAPowerForWeight(size abi.SectorSize, duration abi.ChainEpoch, dealWeight, verifiedWeight abi.DealWeight) abi.StoragePower {
+	return miner0.QAPowerForWeight(size, duration, dealWeight, verifiedWeight)
+}

chain/actors/builtin/init/init.go

@@ -36,4 +36,9 @@ type State interface {
 	NetworkName() (dtypes.NetworkName, error)
 
 	ForEachActor(func(id abi.ActorID, address address.Address) error) error
+
+	// Remove exists to support tooling that manipulates state for testing.
+	// It should not be used in production code, as init actor entries are
+	// immutable.
+	Remove(addrs ...address.Address) error
 }

chain/actors/builtin/init/v0.go

@@ -4,6 +4,7 @@ import (
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
 	cbg "github.com/whyrusleeping/cbor-gen"
+	"golang.org/x/xerrors"
 
 	init_ "github.com/filecoin-project/specs-actors/actors/builtin/init"
 
@@ -13,6 +14,8 @@ import (
 	adt0 "github.com/filecoin-project/specs-actors/actors/util/adt"
 )
 
+var _ State = (*state0)(nil)
+
 type state0 struct {
 	init_.State
 	store adt.Store
@@ -44,3 +47,21 @@ func (s *state0) ForEachActor(cb func(id abi.ActorID, address address.Address) e
 func (s *state0) NetworkName() (dtypes.NetworkName, error) {
 	return dtypes.NetworkName(s.State.NetworkName), nil
 }
+
+func (s *state0) Remove(addrs ...address.Address) (err error) {
+	m, err := adt0.AsMap(s.store, s.State.AddressMap)
+	if err != nil {
+		return err
+	}
+	for _, addr := range addrs {
+		if err = m.Delete(abi.AddrKey(addr)); err != nil {
+			return xerrors.Errorf("failed to delete entry for address: %s; err: %w", addr, err)
+		}
+	}
+	amr, err := m.Root()
+	if err != nil {
+		return xerrors.Errorf("failed to get address map root: %w", err)
+	}
+	s.State.AddressMap = amr
+	return nil
+}

chain/actors/builtin/market/market.go

@@ -7,6 +7,7 @@ import (
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/cbor"
 	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
+	market0 "github.com/filecoin-project/specs-actors/actors/builtin/market"
 	"github.com/ipfs/go-cid"
 	cbg "github.com/whyrusleeping/cbor-gen"
 
@@ -31,13 +32,13 @@ func Load(store adt.Store, act *types.Actor) (st State, err error) {
 
 type State interface {
 	cbor.Marshaler
-	BalancesChanged(State) bool
+	BalancesChanged(State) (bool, error)
 	EscrowTable() (BalanceTable, error)
 	LockedTable() (BalanceTable, error)
 	TotalLocked() (abi.TokenAmount, error)
-	StatesChanged(State) bool
+	StatesChanged(State) (bool, error)
 	States() (DealStates, error)
-	ProposalsChanged(State) bool
+	ProposalsChanged(State) (bool, error)
 	Proposals() (DealProposals, error)
 	VerifyDealsForActivation(
 		minerAddr address.Address, deals []abi.DealID, currEpoch, sectorExpiry abi.ChainEpoch,
@@ -50,6 +51,7 @@ type BalanceTable interface {
 }
 
 type DealStates interface {
+	ForEach(cb func(id abi.DealID, ds DealState) error) error
 	Get(id abi.DealID) (*DealState, bool, error)
 
 	array() adt.Array
@@ -64,6 +66,12 @@ type DealProposals interface {
 	decode(*cbg.Deferred) (*DealProposal, error)
 }
 
+type PublishStorageDealsParams = market0.PublishStorageDealsParams
+type PublishStorageDealsReturn = market0.PublishStorageDealsReturn
+type VerifyDealsForActivationParams = market0.VerifyDealsForActivationParams
+
+type ClientDealProposal = market0.ClientDealProposal
+
 type DealState struct {
 	SectorStartEpoch abi.ChainEpoch // -1 if not yet included in proven sector
 	LastUpdatedEpoch abi.ChainEpoch // -1 if deal state never updated

chain/actors/builtin/market/v0.go

@@ -12,6 +12,8 @@ import (
 	cbg "github.com/whyrusleeping/cbor-gen"
 )
 
+var _ State = (*state0)(nil)
+
 type state0 struct {
 	market.State
 	store adt.Store
@@ -23,24 +25,24 @@ func (s *state0) TotalLocked() (abi.TokenAmount, error) {
 	return fml, nil
 }
 
-func (s *state0) BalancesChanged(otherState State) bool {
+func (s *state0) BalancesChanged(otherState State) (bool, error) {
 	otherState0, ok := otherState.(*state0)
 	if !ok {
-		// there's no way to compare differnt versions of the state, so let's
+		// 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
+		return true, nil
 	}
-	return !s.State.EscrowTable.Equals(otherState0.State.EscrowTable) || !s.State.LockedTable.Equals(otherState0.State.LockedTable)
+	return !s.State.EscrowTable.Equals(otherState0.State.EscrowTable) || !s.State.LockedTable.Equals(otherState0.State.LockedTable), nil
 }
 
-func (s *state0) StatesChanged(otherState State) bool {
+func (s *state0) StatesChanged(otherState State) (bool, error) {
 	otherState0, ok := otherState.(*state0)
 	if !ok {
-		// there's no way to compare differnt versions of the state, so let's
+		// 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
+		return true, nil
 	}
-	return !s.State.States.Equals(otherState0.State.States)
+	return !s.State.States.Equals(otherState0.State.States), nil
 }
 
 func (s *state0) States() (DealStates, error) {
@@ -51,14 +53,14 @@ func (s *state0) States() (DealStates, error) {
 	return &dealStates0{stateArray}, nil
 }
 
-func (s *state0) ProposalsChanged(otherState State) bool {
+func (s *state0) ProposalsChanged(otherState State) (bool, error) {
 	otherState0, ok := otherState.(*state0)
 	if !ok {
-		// there's no way to compare differnt versions of the state, so let's
+		// 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
+		return true, nil
 	}
-	return !s.State.Proposals.Equals(otherState0.State.Proposals)
+	return !s.State.Proposals.Equals(otherState0.State.Proposals), nil
 }
 
 func (s *state0) Proposals() (DealProposals, error) {
@@ -124,6 +126,13 @@ func (s *dealStates0) Get(dealID abi.DealID) (*DealState, bool, error) {
 	return &deal, true, nil
 }
 
+func (s *dealStates0) ForEach(cb func(dealID abi.DealID, ds DealState) error) error {
+	var ds0 market.DealState
+	return s.Array.ForEach(&ds0, func(idx int64) error {
+		return cb(abi.DealID(idx), fromV0DealState(ds0))
+	})
+}
+
 func (s *dealStates0) decode(val *cbg.Deferred) (*DealState, error) {
 	var ds0 market.DealState
 	if err := ds0.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil {

chain/actors/builtin/miner/miner.go

@@ -1,7 +1,7 @@
 package miner
 
 import (
-	"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"
@@ -10,6 +10,7 @@ import (
 	"github.com/filecoin-project/go-bitfield"
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/cbor"
+	"github.com/filecoin-project/go-state-types/dline"
 	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
 	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
 
@@ -17,7 +18,10 @@ import (
 	"github.com/filecoin-project/lotus/chain/types"
 )
 
-var Address = builtin0.InitActorAddr
+// Unchanged between v0 and v1 actors
+var WPoStProvingPeriod = miner0.WPoStProvingPeriod
+
+const MinSectorExpiration = miner0.MinSectorExpiration
 
 func Load(store adt.Store, act *types.Actor) (st State, err error) {
 	switch act.Code {
@@ -46,17 +50,18 @@ type State interface {
 	FindSector(abi.SectorNumber) (*SectorLocation, error)
 	GetSectorExpiration(abi.SectorNumber) (*SectorExpiration, error)
 	GetPrecommittedSector(abi.SectorNumber) (*SectorPreCommitOnChainInfo, error)
-	LoadSectorsFromSet(filter *bitfield.BitField, filterOut bool) (adt.Array, error)
+	LoadSectors(sectorNos *bitfield.BitField) ([]*SectorOnChainInfo, error)
+	NumLiveSectors() (uint64, error)
 	IsAllocated(abi.SectorNumber) (bool, error)
 
 	LoadDeadline(idx uint64) (Deadline, error)
 	ForEachDeadline(cb func(idx uint64, dl Deadline) error) error
 	NumDeadlines() (uint64, error)
-	DeadlinesChanged(State) bool
+	DeadlinesChanged(State) (bool, error)
 
 	Info() (MinerInfo, error)
 
-	DeadlineInfo(epoch abi.ChainEpoch) *dline.Info
+	DeadlineInfo(epoch abi.ChainEpoch) (*dline.Info, error)
 
 	// Diff helpers. Used by Diff* functions internally.
 	sectors() (adt.Array, error)
@@ -70,7 +75,7 @@ type Deadline interface {
 	ForEachPartition(cb func(idx uint64, part Partition) error) error
 	PostSubmissions() (bitfield.BitField, error)
 
-	PartitionsChanged(Deadline) bool
+	PartitionsChanged(Deadline) (bool, error)
 }
 
 type Partition interface {
@@ -81,9 +86,30 @@ type Partition interface {
 	ActiveSectors() (bitfield.BitField, error)
 }
 
-type SectorOnChainInfo = miner0.SectorOnChainInfo
+type SectorOnChainInfo struct {
+	SectorNumber          abi.SectorNumber
+	SealProof             abi.RegisteredSealProof
+	SealedCID             cid.Cid
+	DealIDs               []abi.DealID
+	Activation            abi.ChainEpoch
+	Expiration            abi.ChainEpoch
+	DealWeight            abi.DealWeight
+	VerifiedDealWeight    abi.DealWeight
+	InitialPledge         abi.TokenAmount
+	ExpectedDayReward     abi.TokenAmount
+	ExpectedStoragePledge abi.TokenAmount
+}
+
 type SectorPreCommitInfo = miner0.SectorPreCommitInfo
-type SectorPreCommitOnChainInfo = miner0.SectorPreCommitOnChainInfo
+
+type SectorPreCommitOnChainInfo struct {
+	Info               SectorPreCommitInfo
+	PreCommitDeposit   abi.TokenAmount
+	PreCommitEpoch     abi.ChainEpoch
+	DealWeight         abi.DealWeight
+	VerifiedDealWeight abi.DealWeight
+}
+
 type PoStPartition = miner0.PoStPartition
 type RecoveryDeclaration = miner0.RecoveryDeclaration
 type FaultDeclaration = miner0.FaultDeclaration
@@ -107,11 +133,6 @@ type MinerInfo struct {
 	WindowPoStPartitionSectors uint64
 }
 
-type ChainSectorInfo struct {
-	Info SectorOnChainInfo
-	ID   abi.SectorNumber
-}
-
 type SectorExpiration struct {
 	OnTime abi.ChainEpoch
 

chain/actors/builtin/miner/v0.go

@@ -4,19 +4,22 @@ 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/filecoin-project/lotus/chain/actors/adt"
-	adt0 "github.com/filecoin-project/specs-actors/actors/util/adt"
 	"github.com/libp2p/go-libp2p-core/peer"
 	cbg "github.com/whyrusleeping/cbor-gen"
 	"golang.org/x/xerrors"
 
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-bitfield"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/dline"
 	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
+	adt0 "github.com/filecoin-project/specs-actors/actors/util/adt"
+
+	"github.com/filecoin-project/lotus/chain/actors/adt"
 )
 
+var _ State = (*state0)(nil)
+
 type state0 struct {
 	miner0.State
 	store adt.Store
@@ -62,7 +65,8 @@ func (s *state0) GetSector(num abi.SectorNumber) (*SectorOnChainInfo, error) {
 		return nil, err
 	}
 
-	return info, nil
+	ret := fromV0SectorOnChainInfo(*info)
+	return &ret, nil
 }
 
 func (s *state0) FindSector(num abi.SectorNumber) (*SectorLocation, error) {
@@ -76,11 +80,24 @@ func (s *state0) FindSector(num abi.SectorNumber) (*SectorLocation, error) {
 	}, nil
 }
 
+func (s *state0) 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 *miner0.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 isn't found or has already been terminated, this method returns
-// nil and no error. If the sector does not expire early, the Early expiration
-// field is 0.
+// If the sector does not expire early, the Early expiration field is 0.
 func (s *state0) GetSectorExpiration(num abi.SectorNumber) (*SectorExpiration, error) {
 	dls, err := s.State.LoadDeadlines(s.store)
 	if err != nil {
@@ -143,7 +160,7 @@ func (s *state0) GetSectorExpiration(num abi.SectorNumber) (*SectorExpiration, e
 		return nil, err
 	}
 	if out.Early == 0 && out.OnTime == 0 {
-		return nil, nil
+		return nil, xerrors.Errorf("failed to find sector %d", num)
 	}
 	return &out, nil
 }
@@ -154,39 +171,41 @@ func (s *state0) GetPrecommittedSector(num abi.SectorNumber) (*SectorPreCommitOn
 		return nil, err
 	}
 
-	return info, nil
+	ret := fromV0SectorPreCommitOnChainInfo(*info)
+	return &ret, nil
 }
 
-func (s *state0) LoadSectorsFromSet(filter *bitfield.BitField, filterOut bool) (adt.Array, error) {
-	a, err := adt0.AsArray(s.store, s.State.Sectors)
+func (s *state0) LoadSectors(snos *bitfield.BitField) ([]*SectorOnChainInfo, error) {
+	sectors, err := miner0.LoadSectors(s.store, s.State.Sectors)
 	if err != nil {
 		return nil, err
 	}
 
-	var v cbg.Deferred
-	if err := a.ForEach(&v, func(i int64) error {
-		if filter != nil {
-			set, err := filter.IsSet(uint64(i))
-			if err != nil {
-				return xerrors.Errorf("filter check error: %w", err)
-			}
-			if set == filterOut {
-				err = a.Delete(uint64(i))
-				if err != nil {
-					return xerrors.Errorf("filtering error: %w", err)
-				}
-			}
+	// If no sector numbers are specified, load all.
+	if snos == nil {
+		infos := make([]*SectorOnChainInfo, 0, sectors.Length())
+		var info0 miner0.SectorOnChainInfo
+		if err := sectors.ForEach(&info0, func(_ int64) error {
+			info := fromV0SectorOnChainInfo(info0)
+			infos = append(infos, &info)
+			return nil
+		}); err != nil {
+			return nil, err
 		}
-		return nil
-	}); err != nil {
-		return nil, err
+		return infos, nil
 	}
 
-	return a, nil
-}
-
-func (s *state0) LoadPreCommittedSectors() (adt.Map, error) {
-	return adt0.AsMap(s.store, s.State.PreCommittedSectors)
+	// Otherwise, load selected.
+	infos0, err := sectors.Load(*snos)
+	if err != nil {
+		return nil, err
+	}
+	infos := make([]*SectorOnChainInfo, len(infos0))
+	for i, info0 := range infos0 {
+		info := fromV0SectorOnChainInfo(*info0)
+		infos[i] = &info
+	}
+	return infos, nil
 }
 
 func (s *state0) IsAllocated(num abi.SectorNumber) (bool, error) {
@@ -224,14 +243,14 @@ func (s *state0) NumDeadlines() (uint64, error) {
 	return miner0.WPoStPeriodDeadlines, nil
 }
 
-func (s *state0) DeadlinesChanged(other State) bool {
+func (s *state0) DeadlinesChanged(other State) (bool, error) {
 	other0, ok := other.(*state0)
 	if !ok {
 		// treat an upgrade as a change, always
-		return true
+		return true, nil
 	}
 
-	return s.State.Deadlines.Equals(other0.Deadlines)
+	return s.State.Deadlines.Equals(other0.Deadlines), nil
 }
 
 func (s *state0) Info() (MinerInfo, error) {
@@ -268,8 +287,8 @@ func (s *state0) Info() (MinerInfo, error) {
 	return mi, nil
 }
 
-func (s *state0) DeadlineInfo(epoch abi.ChainEpoch) *dline.Info {
-	return s.State.DeadlineInfo(epoch)
+func (s *state0) DeadlineInfo(epoch abi.ChainEpoch) (*dline.Info, error) {
+	return s.State.DeadlineInfo(epoch), nil
 }
 
 func (s *state0) sectors() (adt.Array, error) {
@@ -279,7 +298,11 @@ func (s *state0) sectors() (adt.Array, error) {
 func (s *state0) decodeSectorOnChainInfo(val *cbg.Deferred) (SectorOnChainInfo, error) {
 	var si miner0.SectorOnChainInfo
 	err := si.UnmarshalCBOR(bytes.NewReader(val.Raw))
-	return si, err
+	if err != nil {
+		return SectorOnChainInfo{}, err
+	}
+
+	return fromV0SectorOnChainInfo(si), nil
 }
 
 func (s *state0) precommits() (adt.Map, error) {
@@ -289,7 +312,11 @@ func (s *state0) precommits() (adt.Map, error) {
 func (s *state0) decodeSectorPreCommitOnChainInfo(val *cbg.Deferred) (SectorPreCommitOnChainInfo, error) {
 	var sp miner0.SectorPreCommitOnChainInfo
 	err := sp.UnmarshalCBOR(bytes.NewReader(val.Raw))
-	return sp, err
+	if err != nil {
+		return SectorPreCommitOnChainInfo{}, err
+	}
+
+	return fromV0SectorPreCommitOnChainInfo(sp), nil
 }
 
 func (d *deadline0) LoadPartition(idx uint64) (Partition, error) {
@@ -311,14 +338,14 @@ func (d *deadline0) ForEachPartition(cb func(uint64, Partition) error) error {
 	})
 }
 
-func (d *deadline0) PartitionsChanged(other Deadline) bool {
+func (d *deadline0) PartitionsChanged(other Deadline) (bool, error) {
 	other0, ok := other.(*deadline0)
 	if !ok {
 		// treat an upgrade as a change, always
-		return true
+		return true, nil
 	}
 
-	return d.Deadline.Partitions.Equals(other0.Deadline.Partitions)
+	return d.Deadline.Partitions.Equals(other0.Deadline.Partitions), nil
 }
 
 func (d *deadline0) PostSubmissions() (bitfield.BitField, error) {
@@ -336,3 +363,11 @@ func (p *partition0) FaultySectors() (bitfield.BitField, error) {
 func (p *partition0) RecoveringSectors() (bitfield.BitField, error) {
 	return p.Partition.Recoveries, nil
 }
+
+func fromV0SectorOnChainInfo(v0 miner0.SectorOnChainInfo) SectorOnChainInfo {
+	return (SectorOnChainInfo)(v0)
+}
+
+func fromV0SectorPreCommitOnChainInfo(v0 miner0.SectorPreCommitOnChainInfo) SectorPreCommitOnChainInfo {
+	return (SectorPreCommitOnChainInfo)(v0)
+}

chain/actors/builtin/multisig/multisig.go

@@ -3,9 +3,12 @@ package multisig
 import (
 	"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"
+	msig0 "github.com/filecoin-project/specs-actors/actors/builtin/multisig"
 
 	"github.com/filecoin-project/lotus/chain/actors/adt"
 	"github.com/filecoin-project/lotus/chain/types"
@@ -28,7 +31,13 @@ type State interface {
 	cbor.Marshaler
 
 	LockedBalance(epoch abi.ChainEpoch) (abi.TokenAmount, error)
-	StartEpoch() abi.ChainEpoch
-	UnlockDuration() abi.ChainEpoch
-	InitialBalance() abi.TokenAmount
+	StartEpoch() (abi.ChainEpoch, error)
+	UnlockDuration() (abi.ChainEpoch, error)
+	InitialBalance() (abi.TokenAmount, error)
+	Threshold() (uint64, error)
+	Signers() ([]address.Address, error)
+
+	ForEachPendingTxn(func(id int64, txn Transaction) error) error
 }
+
+type Transaction = msig0.Transaction

chain/actors/builtin/multisig/v0.go

@@ -1,13 +1,21 @@
 package multisig
 
 import (
+	"encoding/binary"
+
+	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/lotus/chain/actors/adt"
-	"github.com/filecoin-project/specs-actors/actors/builtin/multisig"
+	"golang.org/x/xerrors"
+
+	msig0 "github.com/filecoin-project/specs-actors/actors/builtin/multisig"
+	adt0 "github.com/filecoin-project/specs-actors/actors/util/adt"
 )
 
+var _ State = (*state0)(nil)
+
 type state0 struct {
-	multisig.State
+	msig0.State
 	store adt.Store
 }
 
@@ -15,14 +23,37 @@ func (s *state0) LockedBalance(currEpoch abi.ChainEpoch) (abi.TokenAmount, error
 	return s.State.AmountLocked(currEpoch - s.State.StartEpoch), nil
 }
 
-func (s *state0) StartEpoch() abi.ChainEpoch {
-	return s.State.StartEpoch
+func (s *state0) StartEpoch() (abi.ChainEpoch, error) {
+	return s.State.StartEpoch, nil
 }
 
-func (s *state0) UnlockDuration() abi.ChainEpoch {
-	return s.State.UnlockDuration
+func (s *state0) UnlockDuration() (abi.ChainEpoch, error) {
+	return s.State.UnlockDuration, nil
 }
 
-func (s *state0) InitialBalance() abi.TokenAmount {
-	return s.State.InitialBalance
+func (s *state0) InitialBalance() (abi.TokenAmount, error) {
+	return s.State.InitialBalance, nil
+}
+
+func (s *state0) Threshold() (uint64, error) {
+	return s.State.NumApprovalsThreshold, nil
+}
+
+func (s *state0) Signers() ([]address.Address, error) {
+	return s.State.Signers, nil
+}
+
+func (s *state0) ForEachPendingTxn(cb func(id int64, txn Transaction) error) error {
+	arr, err := adt0.AsMap(s.store, s.State.PendingTxns)
+	if err != nil {
+		return err
+	}
+	var out msig0.Transaction
+	return arr.ForEach(&out, func(key string) error {
+		txid, n := binary.Varint([]byte(key))
+		if n <= 0 {
+			return xerrors.Errorf("invalid pending transaction key: %v", key)
+		}
+		return cb(txid, (Transaction)(out))
+	})
 }

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

@@ -45,23 +45,23 @@ func (ms *mockState) MarshalCBOR(io.Writer) error {
 }
 
 // Channel owner, who has funded the actor
-func (ms *mockState) From() address.Address {
-	return ms.from
+func (ms *mockState) From() (address.Address, error) {
+	return ms.from, nil
 }
 
 // Recipient of payouts from channel
-func (ms *mockState) To() address.Address {
-	return ms.to
+func (ms *mockState) To() (address.Address, error) {
+	return ms.to, nil
 }
 
 // Height at which the channel can be `Collected`
-func (ms *mockState) SettlingAt() abi.ChainEpoch {
-	return ms.settlingAt
+func (ms *mockState) SettlingAt() (abi.ChainEpoch, error) {
+	return ms.settlingAt, nil
 }
 
 // Amount successfully redeemed through the payment channel, paid out on `Collect()`
-func (ms *mockState) ToSend() abi.TokenAmount {
-	return ms.toSend
+func (ms *mockState) ToSend() (abi.TokenAmount, error) {
+	return ms.toSend, nil
 }
 
 // Get total number of lanes
@@ -80,10 +80,10 @@ func (ms *mockState) ForEachLaneState(cb func(idx uint64, dl paych.LaneState) er
 	return lastErr
 }
 
-func (mls *mockLaneState) Redeemed() big.Int {
-	return mls.redeemed
+func (mls *mockLaneState) Redeemed() (big.Int, error) {
+	return mls.redeemed, nil
 }
 
-func (mls *mockLaneState) Nonce() uint64 {
-	return mls.nonce
+func (mls *mockLaneState) Nonce() (uint64, error) {
+	return mls.nonce, nil
 }

chain/actors/builtin/paych/paych.go

@@ -8,6 +8,7 @@ import (
 	big "github.com/filecoin-project/go-state-types/big"
 	"github.com/filecoin-project/go-state-types/cbor"
 	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
+	paych0 "github.com/filecoin-project/specs-actors/actors/builtin/paych"
 
 	"github.com/filecoin-project/lotus/chain/actors/adt"
 	"github.com/filecoin-project/lotus/chain/types"
@@ -32,15 +33,15 @@ func Load(store adt.Store, act *types.Actor) (State, error) {
 type State interface {
 	cbor.Marshaler
 	// Channel owner, who has funded the actor
-	From() address.Address
+	From() (address.Address, error)
 	// Recipient of payouts from channel
-	To() address.Address
+	To() (address.Address, error)
 
 	// Height at which the channel can be `Collected`
-	SettlingAt() abi.ChainEpoch
+	SettlingAt() (abi.ChainEpoch, error)
 
 	// Amount successfully redeemed through the payment channel, paid out on `Collect()`
-	ToSend() abi.TokenAmount
+	ToSend() (abi.TokenAmount, error)
 
 	// Get total number of lanes
 	LaneCount() (uint64, error)
@@ -51,6 +52,9 @@ type State interface {
 
 // LaneState is an abstract copy of the state of a single lane
 type LaneState interface {
-	Redeemed() big.Int
-	Nonce() uint64
+	Redeemed() (big.Int, error)
+	Nonce() (uint64, error)
 }
+
+type SignedVoucher = paych0.SignedVoucher
+type ModVerifyParams = paych0.ModVerifyParams

chain/actors/builtin/paych/v0.go

@@ -9,6 +9,8 @@ import (
 	adt0 "github.com/filecoin-project/specs-actors/actors/util/adt"
 )
 
+var _ State = (*state0)(nil)
+
 type state0 struct {
 	paych.State
 	store adt.Store
@@ -16,23 +18,23 @@ type state0 struct {
 }
 
 // Channel owner, who has funded the actor
-func (s *state0) From() address.Address {
-	return s.State.From
+func (s *state0) From() (address.Address, error) {
+	return s.State.From, nil
 }
 
 // Recipient of payouts from channel
-func (s *state0) To() address.Address {
-	return s.State.To
+func (s *state0) To() (address.Address, error) {
+	return s.State.To, nil
 }
 
 // Height at which the channel can be `Collected`
-func (s *state0) SettlingAt() abi.ChainEpoch {
-	return s.State.SettlingAt
+func (s *state0) SettlingAt() (abi.ChainEpoch, error) {
+	return s.State.SettlingAt, nil
 }
 
 // Amount successfully redeemed through the payment channel, paid out on `Collect()`
-func (s *state0) ToSend() abi.TokenAmount {
-	return s.State.ToSend
+func (s *state0) ToSend() (abi.TokenAmount, error) {
+	return s.State.ToSend, nil
 }
 
 func (s *state0) getOrLoadLsAmt() (*adt0.Array, error) {
@@ -80,10 +82,10 @@ type laneState0 struct {
 	paych.LaneState
 }
 
-func (ls *laneState0) Redeemed() big.Int {
-	return ls.LaneState.Redeemed
+func (ls *laneState0) Redeemed() (big.Int, error) {
+	return ls.LaneState.Redeemed, nil
 }
 
-func (ls *laneState0) Nonce() uint64 {
-	return ls.LaneState.Nonce
+func (ls *laneState0) Nonce() (uint64, error) {
+	return ls.LaneState.Nonce, nil
 }

chain/actors/builtin/power/v0.go

@@ -8,6 +8,8 @@ import (
 	"github.com/filecoin-project/specs-actors/actors/util/adt"
 )
 
+var _ State = (*state0)(nil)
+
 type state0 struct {
 	power0.State
 	store adt.Store
@@ -53,7 +55,7 @@ func (s *state0) MinerNominalPowerMeetsConsensusMinimum(a address.Address) (bool
 }
 
 func (s *state0) TotalPowerSmoothed() (builtin.FilterEstimate, error) {
-	return *s.State.ThisEpochQAPowerSmoothed, nil
+	return builtin.FromV0FilterEstimate(*s.State.ThisEpochQAPowerSmoothed), nil
 }
 
 func (s *state0) MinerCounts() (uint64, uint64, error) {

chain/actors/builtin/reward/reward.go

@@ -2,6 +2,7 @@ package reward
 
 import (
 	"github.com/filecoin-project/go-state-types/abi"
+	reward0 "github.com/filecoin-project/specs-actors/actors/builtin/reward"
 	"golang.org/x/xerrors"
 
 	"github.com/filecoin-project/go-state-types/cbor"
@@ -28,7 +29,7 @@ func Load(store adt.Store, act *types.Actor) (st State, err error) {
 }
 
 type State interface {
-	cbor.Er
+	cbor.Marshaler
 
 	ThisEpochBaselinePower() (abi.StoragePower, error)
 	ThisEpochReward() (abi.StoragePower, error)
@@ -41,4 +42,9 @@ type State interface {
 
 	CumsumBaseline() (abi.StoragePower, error)
 	CumsumRealized() (abi.StoragePower, error)
+
+	InitialPledgeForPower(abi.StoragePower, abi.TokenAmount, *builtin.FilterEstimate, abi.TokenAmount) (abi.TokenAmount, error)
+	PreCommitDepositForPower(builtin.FilterEstimate, abi.StoragePower) (abi.TokenAmount, error)
 }
+
+type AwardBlockRewardParams = reward0.AwardBlockRewardParams

chain/actors/builtin/reward/v0.go

@@ -3,10 +3,14 @@ package reward
 import (
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/lotus/chain/actors/builtin"
+	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
 	"github.com/filecoin-project/specs-actors/actors/builtin/reward"
 	"github.com/filecoin-project/specs-actors/actors/util/adt"
+	"github.com/filecoin-project/specs-actors/actors/util/smoothing"
 )
 
+var _ State = (*state0)(nil)
+
 type state0 struct {
 	reward.State
 	store adt.Store
@@ -17,7 +21,7 @@ func (s *state0) ThisEpochReward() (abi.StoragePower, error) {
 }
 
 func (s *state0) ThisEpochRewardSmoothed() (builtin.FilterEstimate, error) {
-	return *s.State.ThisEpochRewardSmoothed, nil
+	return builtin.FromV0FilterEstimate(*s.State.ThisEpochRewardSmoothed), nil
 }
 
 func (s *state0) ThisEpochBaselinePower() (abi.StoragePower, error) {
@@ -43,3 +47,25 @@ func (s *state0) CumsumBaseline() (abi.StoragePower, error) {
 func (s *state0) CumsumRealized() (abi.StoragePower, error) {
 	return s.State.CumsumBaseline, nil
 }
+
+func (s *state0) InitialPledgeForPower(sectorWeight abi.StoragePower, networkTotalPledge abi.TokenAmount, networkQAPower *builtin.FilterEstimate, circSupply abi.TokenAmount) (abi.TokenAmount, error) {
+	return miner0.InitialPledgeForPower(
+		sectorWeight,
+		s.State.ThisEpochBaselinePower,
+		networkTotalPledge,
+		s.State.ThisEpochRewardSmoothed,
+		&smoothing.FilterEstimate{
+			PositionEstimate: networkQAPower.PositionEstimate,
+			VelocityEstimate: networkQAPower.VelocityEstimate,
+		},
+		circSupply), nil
+}
+
+func (s *state0) PreCommitDepositForPower(networkQAPower builtin.FilterEstimate, sectorWeight abi.StoragePower) (abi.TokenAmount, error) {
+	return miner0.PreCommitDepositForPower(s.State.ThisEpochRewardSmoothed,
+		&smoothing.FilterEstimate{
+			PositionEstimate: networkQAPower.PositionEstimate,
+			VelocityEstimate: networkQAPower.VelocityEstimate,
+		},
+		sectorWeight), nil
+}

chain/actors/builtin/verifreg/v0.go

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

chain/actors/builtin/verifreg/verifreg.go

@@ -31,4 +31,7 @@ type State interface {
 	cbor.Marshaler
 
 	VerifiedClientDataCap(address.Address) (bool, abi.StoragePower, error)
+	VerifierDataCap(address.Address) (bool, abi.StoragePower, error)
+	ForEachVerifier(func(addr address.Address, dcap abi.StoragePower) error) error
+	ForEachClient(func(addr address.Address, dcap abi.StoragePower) error) error
 }

chain/actors/policy/policy.go

@@ -0,0 +1,54 @@
+package policy
+
+import (
+	"github.com/filecoin-project/go-state-types/abi"
+
+	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
+	power0 "github.com/filecoin-project/specs-actors/actors/builtin/power"
+	verifreg0 "github.com/filecoin-project/specs-actors/actors/builtin/verifreg"
+)
+
+// SetSupportedProofTypes sets supported proof types, across all actor versions.
+// This should only be used for testing.
+func SetSupportedProofTypes(types ...abi.RegisteredSealProof) {
+	newTypes := make(map[abi.RegisteredSealProof]struct{}, len(types))
+	for _, t := range types {
+		newTypes[t] = struct{}{}
+	}
+	// Set for all miner versions.
+	miner0.SupportedProofTypes = newTypes
+}
+
+// AddSupportedProofTypes sets supported proof types, across all actor versions.
+// This should only be used for testing.
+func AddSupportedProofTypes(types ...abi.RegisteredSealProof) {
+	for _, t := range types {
+		// Set for all miner versions.
+		miner0.SupportedProofTypes[t] = struct{}{}
+	}
+}
+
+// SetPreCommitChallengeDelay sets the pre-commit challenge delay across all
+// actors versions. Use for testing.
+func SetPreCommitChallengeDelay(delay abi.ChainEpoch) {
+	// Set for all miner versions.
+	miner0.PreCommitChallengeDelay = delay
+}
+
+// TODO: this function shouldn't really exist. Instead, the API should expose the precommit delay.
+func GetPreCommitChallengeDelay() abi.ChainEpoch {
+	return miner0.PreCommitChallengeDelay
+}
+
+// SetConsensusMinerMinPower sets the minimum power of an individual miner must
+// meet for leader election, across all actor versions. This should only be used
+// for testing.
+func SetConsensusMinerMinPower(p abi.StoragePower) {
+	power0.ConsensusMinerMinPower = p
+}
+
+// SetMinVerifiedDealSize sets the minimum size of a verified deal. This should
+// only be used for testing.
+func SetMinVerifiedDealSize(size abi.StoragePower) {
+	verifreg0.MinVerifiedDealSize = size
+}

chain/actors/policy/policy_test.go

@@ -0,0 +1,36 @@
+package policy
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/filecoin-project/go-state-types/abi"
+	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
+)
+
+func TestSupportedProofTypes(t *testing.T) {
+	var oldTypes []abi.RegisteredSealProof
+	for t := range miner0.SupportedProofTypes {
+		oldTypes = append(oldTypes, t)
+	}
+	t.Cleanup(func() {
+		SetSupportedProofTypes(oldTypes...)
+	})
+
+	SetSupportedProofTypes(abi.RegisteredSealProof_StackedDrg2KiBV1)
+	require.EqualValues(t,
+		miner0.SupportedProofTypes,
+		map[abi.RegisteredSealProof]struct{}{
+			abi.RegisteredSealProof_StackedDrg2KiBV1: {},
+		},
+	)
+	AddSupportedProofTypes(abi.RegisteredSealProof_StackedDrg8MiBV1)
+	require.EqualValues(t,
+		miner0.SupportedProofTypes,
+		map[abi.RegisteredSealProof]struct{}{
+			abi.RegisteredSealProof_StackedDrg2KiBV1: {},
+			abi.RegisteredSealProof_StackedDrg8MiBV1: {},
+		},
+	)
+}

chain/events/state/predicates.go

@@ -97,7 +97,12 @@ type DiffBalanceTablesFunc func(ctx context.Context, oldBalanceTable, newBalance
 // OnBalanceChanged runs when the escrow table for available balances changes
 func (sp *StatePredicates) OnBalanceChanged(diffBalances DiffBalanceTablesFunc) DiffStorageMarketStateFunc {
 	return func(ctx context.Context, oldState market.State, newState market.State) (changed bool, user UserData, err error) {
-		if !oldState.BalancesChanged(newState) {
+		bc, err := oldState.BalancesChanged(newState)
+		if err != nil {
+			return false, nil, err
+		}
+
+		if !bc {
 			return false, nil, nil
 		}
 
@@ -132,7 +137,12 @@ type DiffAdtArraysFunc func(ctx context.Context, oldDealStateRoot, newDealStateR
 // OnDealStateChanged calls diffDealStates when the market deal state changes
 func (sp *StatePredicates) OnDealStateChanged(diffDealStates DiffDealStatesFunc) DiffStorageMarketStateFunc {
 	return func(ctx context.Context, oldState market.State, newState market.State) (changed bool, user UserData, err error) {
-		if !oldState.StatesChanged(newState) {
+		sc, err := oldState.StatesChanged(newState)
+		if err != nil {
+			return false, nil, err
+		}
+
+		if !sc {
 			return false, nil, nil
 		}
 
@@ -152,7 +162,12 @@ func (sp *StatePredicates) OnDealStateChanged(diffDealStates DiffDealStatesFunc)
 // OnDealProposalChanged calls diffDealProps when the market proposal state changes
 func (sp *StatePredicates) OnDealProposalChanged(diffDealProps DiffDealProposalsFunc) DiffStorageMarketStateFunc {
 	return func(ctx context.Context, oldState market.State, newState market.State) (changed bool, user UserData, err error) {
-		if !oldState.ProposalsChanged(newState) {
+		pc, err := oldState.ProposalsChanged(newState)
+		if err != nil {
+			return false, nil, err
+		}
+
+		if !pc {
 			return false, nil, nil
 		}
 
@@ -303,7 +318,7 @@ func (sp *StatePredicates) OnInitActorChange(diffInitActorState DiffInitActorSta
 		if err != nil {
 			return false, nil, err
 		}
-		return diffInitActorState(ctx, &oldState, &newState)
+		return diffInitActorState(ctx, oldState, newState)
 	})
 
 }
@@ -379,12 +394,22 @@ type PayChToSendChange struct {
 // OnToSendAmountChanges monitors changes on the total amount to send from one party to the other on a payment channel
 func (sp *StatePredicates) OnToSendAmountChanges() DiffPaymentChannelStateFunc {
 	return func(ctx context.Context, oldState paych.State, newState paych.State) (changed bool, user UserData, err error) {
-		if oldState.ToSend().Equals(newState.ToSend()) {
+		ots, err := oldState.ToSend()
+		if err != nil {
+			return false, nil, err
+		}
+
+		nts, err := newState.ToSend()
+		if err != nil {
+			return false, nil, err
+		}
+
+		if ots.Equals(nts) {
 			return false, nil, nil
 		}
 		return true, &PayChToSendChange{
-			OldToSend: oldState.ToSend(),
-			NewToSend: newState.ToSend(),
+			OldToSend: ots,
+			NewToSend: nts,
 		}, nil
 	}
 }
@@ -405,7 +430,7 @@ type AddressChange struct {
 	To   AddressPair
 }
 
-type DiffInitActorStateFunc func(ctx context.Context, oldState *init_.State, newState *init_.State) (changed bool, user UserData, err error)
+type DiffInitActorStateFunc func(ctx context.Context, oldState init_.State, newState init_.State) (changed bool, user UserData, err error)
 
 func (i *InitActorAddressChanges) AsKey(key string) (abi.Keyer, error) {
 	addr, err := address.NewFromBytes([]byte(key))
@@ -493,33 +518,73 @@ func (i *InitActorAddressChanges) Remove(key string, val *typegen.Deferred) erro
 }
 
 func (sp *StatePredicates) OnAddressMapChange() DiffInitActorStateFunc {
-	return func(ctx context.Context, oldState, newState *init_.State) (changed bool, user UserData, err error) {
-		/*ctxStore := &contextStore{
-			ctx: ctx,
-			cst: sp.cst,
-		}
-
+	return func(ctx context.Context, oldState, newState init_.State) (changed bool, user UserData, err error) {
 		addressChanges := &InitActorAddressChanges{
 			Added:    []AddressPair{},
 			Modified: []AddressChange{},
 			Removed:  []AddressPair{},
 		}
 
-		if oldState.AddressMap.Equals(newState.AddressMap) {
-			return false, nil, nil
-		}
+		err = oldState.ForEachActor(func(oldId abi.ActorID, oldAddress address.Address) error {
+			oldIdAddress, err := address.NewIDAddress(uint64(oldId))
+			if err != nil {
+				return err
+			}
+
+			newIdAddress, found, err := newState.ResolveAddress(oldAddress)
+			if err != nil {
+				return err
+			}
+
+			if !found {
+				addressChanges.Removed = append(addressChanges.Removed, AddressPair{
+					ID: oldIdAddress,
+					PK: oldAddress,
+				})
+			}
+
+			if oldIdAddress != newIdAddress {
+				addressChanges.Modified = append(addressChanges.Modified, AddressChange{
+					From: AddressPair{
+						ID: oldIdAddress,
+						PK: oldAddress,
+					},
+					To: AddressPair{
+						ID: newIdAddress,
+						PK: oldAddress,
+					},
+				})
+			}
+
+			return nil
+		})
 
-		oldAddrs, err := adt0.AsMap(ctxStore, oldState.AddressMap)
 		if err != nil {
 			return false, nil, err
 		}
 
-		newAddrs, err := adt0.AsMap(ctxStore, newState.AddressMap)
-		if err != nil {
-			return false, nil, err
-		}
+		err = newState.ForEachActor(func(newId abi.ActorID, newAddress address.Address) error {
+			newIdAddress, err := address.NewIDAddress(uint64(newId))
+			if err != nil {
+				return err
+			}
 
-		if err := adt.DiffAdtMap(oldAddrs, newAddrs, addressChanges); err != nil {
+			_, found, err := newState.ResolveAddress(newAddress)
+			if err != nil {
+				return err
+			}
+
+			if !found {
+				addressChanges.Added = append(addressChanges.Added, AddressPair{
+					ID: newIdAddress,
+					PK: newAddress,
+				})
+			}
+
+			return nil
+		})
+
+		if err != nil {
 			return false, nil, err
 		}
 
@@ -527,8 +592,6 @@ func (sp *StatePredicates) OnAddressMapChange() DiffInitActorStateFunc {
 			return false, nil, nil
 		}
 
-		return true, addressChanges, nil*/
-
-		panic("TODO")
+		return true, addressChanges, nil
 	}
 }

chain/events/state/predicates_test.go

@@ -581,7 +581,7 @@ func createEmptyMinerState(ctx context.Context, t *testing.T, store adt.Store, o
 func createSectorsAMT(ctx context.Context, t *testing.T, store adt.Store, sectors []miner.SectorOnChainInfo) cid.Cid {
 	root := adt.MakeEmptyArray(store)
 	for _, sector := range sectors {
-		sector := sector
+		sector := (miner0.SectorOnChainInfo)(sector)
 		err := root.Set(uint64(sector.SectorNumber), &sector)
 		require.NoError(t, err)
 	}
@@ -614,8 +614,8 @@ const (
 )
 
 // returns a unique SectorPreCommitInfo with each invocation with SectorNumber set to `sectorNo`.
-func newSectorPreCommitInfo(sectorNo abi.SectorNumber, sealed cid.Cid, expiration abi.ChainEpoch) *miner.SectorPreCommitInfo {
-	return &miner.SectorPreCommitInfo{
+func newSectorPreCommitInfo(sectorNo abi.SectorNumber, sealed cid.Cid, expiration abi.ChainEpoch) *miner0.SectorPreCommitInfo {
+	return &miner0.SectorPreCommitInfo{
 		SealProof:     abi.RegisteredSealProof_StackedDrg32GiBV1,
 		SectorNumber:  sectorNo,
 		SealedCID:     sealed,

chain/exchange/client.go

@@ -7,6 +7,7 @@ import (
 	"math/rand"
 	"time"
 
+	"github.com/libp2p/go-libp2p-core/helpers"
 	"github.com/libp2p/go-libp2p-core/host"
 	"github.com/libp2p/go-libp2p-core/network"
 	"github.com/libp2p/go-libp2p-core/peer"
@@ -64,7 +65,15 @@ func NewClient(lc fx.Lifecycle, host host.Host, pmgr peermgr.MaybePeerMgr) Clien
 // request options without disrupting external calls. In the future the
 // consumers should be forced to use a more standardized service and
 // adhere to a single API derived from this function.
-func (c *client) doRequest(ctx context.Context, req *Request, singlePeer *peer.ID) (*validatedResponse, error) {
+func (c *client) doRequest(
+	ctx context.Context,
+	req *Request,
+	singlePeer *peer.ID,
+	// In the `GetChainMessages` case, we won't request the headers but we still
+	// need them to check the integrity of the `CompactedMessages` in the response
+	// so the tipset blocks need to be provided by the caller.
+	tipsets []*types.TipSet,
+) (*validatedResponse, error) {
 	// Validate request.
 	if req.Length == 0 {
 		return nil, xerrors.Errorf("invalid request of length 0")
@@ -115,7 +124,7 @@ func (c *client) doRequest(ctx context.Context, req *Request, singlePeer *peer.I
 		}
 
 		// Process and validate response.
-		validRes, err := c.processResponse(req, res)
+		validRes, err := c.processResponse(req, res, tipsets)
 		if err != nil {
 			log.Warnf("processing peer %s response failed: %s",
 				peer.String(), err)
@@ -143,7 +152,7 @@ func (c *client) doRequest(ctx context.Context, req *Request, singlePeer *peer.I
 // errors. Peer penalization should happen here then, before returning, so
 // we can apply the correct penalties depending on the cause of the error.
 // FIXME: Add the `peer` as argument once we implement penalties.
-func (c *client) processResponse(req *Request, res *Response) (*validatedResponse, error) {
+func (c *client) processResponse(req *Request, res *Response, tipsets []*types.TipSet) (*validatedResponse, error) {
 	err := res.statusToError()
 	if err != nil {
 		return nil, xerrors.Errorf("status error: %s", err)
@@ -175,6 +184,16 @@ func (c *client) processResponse(req *Request, res *Response) (*validatedRespons
 		// Check for valid block sets and extract them into `TipSet`s.
 		validRes.tipsets = make([]*types.TipSet, resLength)
 		for i := 0; i < resLength; i++ {
+			if res.Chain[i] == nil {
+				return nil, xerrors.Errorf("response with nil tipset in pos %d", i)
+			}
+			for blockIdx, block := range res.Chain[i].Blocks {
+				if block == nil {
+					return nil, xerrors.Errorf("tipset with nil block in pos %d", blockIdx)
+					// FIXME: Maybe we should move this check to `NewTipSet`.
+				}
+			}
+
 			validRes.tipsets[i], err = types.NewTipSet(res.Chain[i].Blocks)
 			if err != nil {
 				return nil, xerrors.Errorf("invalid tipset blocks at height (head - %d): %w", i, err)
@@ -209,31 +228,28 @@ func (c *client) processResponse(req *Request, res *Response) (*validatedRespons
 			// If the headers were also returned check that the compression
 			// indexes are valid before `toFullTipSets()` is called by the
 			// consumer.
-			for tipsetIdx := 0; tipsetIdx < resLength; tipsetIdx++ {
-				msgs := res.Chain[tipsetIdx].Messages
-				blocksNum := len(res.Chain[tipsetIdx].Blocks)
-				if len(msgs.BlsIncludes) != blocksNum {
-					return nil, xerrors.Errorf("BlsIncludes (%d) does not match number of blocks (%d)",
-						len(msgs.BlsIncludes), blocksNum)
-				}
-				if len(msgs.SecpkIncludes) != blocksNum {
-					return nil, xerrors.Errorf("SecpkIncludes (%d) does not match number of blocks (%d)",
-						len(msgs.SecpkIncludes), blocksNum)
-				}
-				for blockIdx := 0; blockIdx < blocksNum; blockIdx++ {
-					for _, mi := range msgs.BlsIncludes[blockIdx] {
-						if int(mi) >= len(msgs.Bls) {
-							return nil, xerrors.Errorf("index in BlsIncludes (%d) exceeds number of messages (%d)",
-								mi, len(msgs.Bls))
-						}
-					}
-					for _, mi := range msgs.SecpkIncludes[blockIdx] {
-						if int(mi) >= len(msgs.Secpk) {
-							return nil, xerrors.Errorf("index in SecpkIncludes (%d) exceeds number of messages (%d)",
-								mi, len(msgs.Secpk))
-						}
-					}
+			err := c.validateCompressedIndices(res.Chain)
+			if err != nil {
+				return nil, err
+			}
+		} else {
+			// If we didn't request the headers they should have been provided
+			// by the caller.
+			if len(tipsets) < len(res.Chain) {
+				return nil, xerrors.Errorf("not enought tipsets provided for message response validation, needed %d, have %d", len(res.Chain), len(tipsets))
+			}
+			chain := make([]*BSTipSet, 0, resLength)
+			for i, resChain := range res.Chain {
+				next := &BSTipSet{
+					Blocks:   tipsets[i].Blocks(),
+					Messages: resChain.Messages,
 				}
+				chain = append(chain, next)
+			}
+
+			err := c.validateCompressedIndices(chain)
+			if err != nil {
+				return nil, err
 			}
 		}
 	}
@@ -241,6 +257,42 @@ func (c *client) processResponse(req *Request, res *Response) (*validatedRespons
 	return validRes, nil
 }
 
+func (c *client) validateCompressedIndices(chain []*BSTipSet) error {
+	resLength := len(chain)
+	for tipsetIdx := 0; tipsetIdx < resLength; tipsetIdx++ {
+		msgs := chain[tipsetIdx].Messages
+		blocksNum := len(chain[tipsetIdx].Blocks)
+
+		if len(msgs.BlsIncludes) != blocksNum {
+			return xerrors.Errorf("BlsIncludes (%d) does not match number of blocks (%d)",
+				len(msgs.BlsIncludes), blocksNum)
+		}
+
+		if len(msgs.SecpkIncludes) != blocksNum {
+			return xerrors.Errorf("SecpkIncludes (%d) does not match number of blocks (%d)",
+				len(msgs.SecpkIncludes), blocksNum)
+		}
+
+		for blockIdx := 0; blockIdx < blocksNum; blockIdx++ {
+			for _, mi := range msgs.BlsIncludes[blockIdx] {
+				if int(mi) >= len(msgs.Bls) {
+					return xerrors.Errorf("index in BlsIncludes (%d) exceeds number of messages (%d)",
+						mi, len(msgs.Bls))
+				}
+			}
+
+			for _, mi := range msgs.SecpkIncludes[blockIdx] {
+				if int(mi) >= len(msgs.Secpk) {
+					return xerrors.Errorf("index in SecpkIncludes (%d) exceeds number of messages (%d)",
+						mi, len(msgs.Secpk))
+				}
+			}
+		}
+	}
+
+	return nil
+}
+
 // GetBlocks implements Client.GetBlocks(). Refer to the godocs there.
 func (c *client) GetBlocks(ctx context.Context, tsk types.TipSetKey, count int) ([]*types.TipSet, error) {
 	ctx, span := trace.StartSpan(ctx, "bsync.GetBlocks")
@@ -258,7 +310,7 @@ func (c *client) GetBlocks(ctx context.Context, tsk types.TipSetKey, count int)
 		Options: Headers,
 	}
 
-	validRes, err := c.doRequest(ctx, req, nil)
+	validRes, err := c.doRequest(ctx, req, nil, nil)
 	if err != nil {
 		return nil, err
 	}
@@ -276,7 +328,7 @@ func (c *client) GetFullTipSet(ctx context.Context, peer peer.ID, tsk types.TipS
 		Options: Headers | Messages,
 	}
 
-	validRes, err := c.doRequest(ctx, req, &peer)
+	validRes, err := c.doRequest(ctx, req, &peer, nil)
 	if err != nil {
 		return nil, err
 	}
@@ -287,7 +339,10 @@ func (c *client) GetFullTipSet(ctx context.Context, peer peer.ID, tsk types.TipS
 }
 
 // GetChainMessages implements Client.GetChainMessages(). Refer to the godocs there.
-func (c *client) GetChainMessages(ctx context.Context, head *types.TipSet, length uint64) ([]*CompactedMessages, error) {
+func (c *client) GetChainMessages(ctx context.Context, tipsets []*types.TipSet) ([]*CompactedMessages, error) {
+	head := tipsets[0]
+	length := uint64(len(tipsets))
+
 	ctx, span := trace.StartSpan(ctx, "GetChainMessages")
 	if span.IsRecordingEvents() {
 		span.AddAttributes(
@@ -303,7 +358,7 @@ func (c *client) GetChainMessages(ctx context.Context, head *types.TipSet, lengt
 		Options: Messages,
 	}
 
-	validRes, err := c.doRequest(ctx, req, nil)
+	validRes, err := c.doRequest(ctx, req, nil, tipsets)
 	if err != nil {
 		return nil, err
 	}
@@ -357,6 +412,12 @@ func (c *client) sendRequestToPeer(ctx context.Context, peer peer.ID, req *Reque
 		return nil, xerrors.Errorf("failed to open stream to peer: %w", err)
 	}
 
+	defer func() {
+		// Note: this will become just stream.Close once we've completed the go-libp2p migration to
+		//       go-libp2p-core 0.7.0
+		go helpers.FullClose(stream) //nolint:errcheck
+	}()
+
 	// Write request.
 	_ = stream.SetWriteDeadline(time.Now().Add(WriteReqDeadline))
 	if err := cborutil.WriteCborRPC(stream, req); err != nil {

chain/exchange/interfaces.go

@@ -32,10 +32,9 @@ type Client interface {
 	// or less.
 	GetBlocks(ctx context.Context, tsk types.TipSetKey, count int) ([]*types.TipSet, error)
 
-	// GetChainMessages fetches messages from the network, from the provided
-	// tipset *backwards*, returning the messages from as many tipsets as the
-	// count parameter, or less.
-	GetChainMessages(ctx context.Context, head *types.TipSet, length uint64) ([]*CompactedMessages, error)
+	// GetChainMessages fetches messages from the network, starting from the first provided tipset
+	// and returning messages from as many tipsets as requested or less.
+	GetChainMessages(ctx context.Context, tipsets []*types.TipSet) ([]*CompactedMessages, error)
 
 	// GetFullTipSet fetches a full tipset from a given peer. If successful,
 	// the fetched object contains block headers and all messages in full form.

chain/exchange/protocol.go

@@ -40,7 +40,7 @@ const (
 	WriteReqDeadline    = 5 * time.Second
 	ReadResDeadline     = WriteReqDeadline
 	ReadResMinSpeed     = 50 << 10
-	ShufflePeersPrefix  = 5
+	ShufflePeersPrefix  = 16
 	WriteResDeadline    = 60 * time.Second
 )
 
@@ -139,6 +139,8 @@ func (res *Response) statusToError() error {
 
 // FIXME: Rename.
 type BSTipSet struct {
+	// List of blocks belonging to a single tipset to which the
+	// `CompactedMessages` are linked.
 	Blocks   []*types.BlockHeader
 	Messages *CompactedMessages
 }

chain/exchange/server.go

@@ -15,6 +15,7 @@ import (
 	"github.com/filecoin-project/lotus/chain/types"
 
 	"github.com/ipfs/go-cid"
+	"github.com/libp2p/go-libp2p-core/helpers"
 	inet "github.com/libp2p/go-libp2p-core/network"
 )
 
@@ -39,7 +40,9 @@ func (s *server) HandleStream(stream inet.Stream) {
 	ctx, span := trace.StartSpan(context.Background(), "chainxchg.HandleStream")
 	defer span.End()
 
-	defer stream.Close() //nolint:errcheck
+	// Note: this will become just stream.Close once we've completed the go-libp2p migration to
+	//       go-libp2p-core 0.7.0
+	defer helpers.FullClose(stream) //nolint:errcheck
 
 	var req Request
 	if err := cborutil.ReadCborRPC(bufio.NewReader(stream), &req); err != nil {

chain/gen/gen.go

@@ -14,7 +14,6 @@ import (
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/big"
 	"github.com/filecoin-project/go-state-types/crypto"
-	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
 	block "github.com/ipfs/go-block-format"
 	"github.com/ipfs/go-blockservice"
 	"github.com/ipfs/go-cid"
@@ -28,6 +27,7 @@ import (
 
 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/actors/policy"
 	"github.com/filecoin-project/lotus/chain/beacon"
 	genesis2 "github.com/filecoin-project/lotus/chain/gen/genesis"
 	"github.com/filecoin-project/lotus/chain/stmgr"
@@ -121,9 +121,8 @@ var DefaultRemainderAccountActor = genesis.Actor{
 }
 
 func NewGeneratorWithSectors(numSectors int) (*ChainGen, error) {
-	miner0.SupportedProofTypes = map[abi.RegisteredSealProof]struct{}{
-		abi.RegisteredSealProof_StackedDrg2KiBV1: {},
-	}
+	// TODO: we really shouldn't modify a global variable here.
+	policy.SetSupportedProofTypes(abi.RegisteredSealProof_StackedDrg2KiBV1)
 
 	mr := repo.NewMemory(nil)
 	lr, err := mr.Lock(repo.StorageMiner)

chain/gen/gen_test.go

@@ -4,21 +4,16 @@ import (
 	"testing"
 
 	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/go-state-types/big"
-	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
-	power0 "github.com/filecoin-project/specs-actors/actors/builtin/power"
-	verifreg0 "github.com/filecoin-project/specs-actors/actors/builtin/verifreg"
 
+	"github.com/filecoin-project/lotus/chain/actors/policy"
 	_ "github.com/filecoin-project/lotus/lib/sigs/bls"
 	_ "github.com/filecoin-project/lotus/lib/sigs/secp"
 )
 
 func init() {
-	miner0.SupportedProofTypes = map[abi.RegisteredSealProof]struct{}{
-		abi.RegisteredSealProof_StackedDrg2KiBV1: {},
-	}
-	power0.ConsensusMinerMinPower = big.NewInt(2048)
-	verifreg0.MinVerifiedDealSize = big.NewInt(256)
+	policy.SetSupportedProofTypes(abi.RegisteredSealProof_StackedDrg2KiBV1)
+	policy.SetConsensusMinerMinPower(abi.NewStoragePower(2048))
+	policy.SetMinVerifiedDealSize(abi.NewStoragePower(256))
 }
 
 func testGeneration(t testing.TB, n int, msgs int, sectors int) {

chain/gen/genesis/miners.go

@@ -6,6 +6,12 @@ import (
 	"fmt"
 	"math/rand"
 
+	market0 "github.com/filecoin-project/specs-actors/actors/builtin/market"
+
+	"github.com/filecoin-project/lotus/chain/actors/builtin/power"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/reward"
+
+	"github.com/filecoin-project/lotus/chain/actors/builtin/market"
 	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
 
 	"github.com/ipfs/go-cid"
@@ -19,7 +25,6 @@ import (
 	"github.com/filecoin-project/go-state-types/crypto"
 	"github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper"
 	"github.com/filecoin-project/specs-actors/actors/builtin"
-	"github.com/filecoin-project/specs-actors/actors/builtin/market"
 	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
 	power0 "github.com/filecoin-project/specs-actors/actors/builtin/power"
 	reward0 "github.com/filecoin-project/specs-actors/actors/builtin/reward"
@@ -109,7 +114,7 @@ func SetupStorageMiners(ctx context.Context, cs *store.ChainStore, sroot cid.Cid
 			}
 
 			params := mustEnc(constructorParams)
-			rval, err := doExecValue(ctx, vm, builtin.StoragePowerActorAddr, m.Owner, m.PowerBalance, builtin.MethodsPower.CreateMiner, params)
+			rval, err := doExecValue(ctx, vm, power.Address, m.Owner, m.PowerBalance, builtin.MethodsPower.CreateMiner, params)
 			if err != nil {
 				return cid.Undef, xerrors.Errorf("failed to create genesis miner: %w", err)
 			}
@@ -141,7 +146,7 @@ func SetupStorageMiners(ctx context.Context, cs *store.ChainStore, sroot cid.Cid
 
 		if m.MarketBalance.GreaterThan(big.Zero()) {
 			params := mustEnc(&minerInfos[i].maddr)
-			_, err := doExecValue(ctx, vm, builtin.StorageMarketActorAddr, m.Worker, m.MarketBalance, builtin.MethodsMarket.AddBalance, params)
+			_, err := doExecValue(ctx, vm, market.Address, m.Worker, m.MarketBalance, builtin.MethodsMarket.AddBalance, params)
 			if err != nil {
 				return cid.Undef, xerrors.Errorf("failed to create genesis miner (add balance): %w", err)
 			}
@@ -153,7 +158,7 @@ func SetupStorageMiners(ctx context.Context, cs *store.ChainStore, sroot cid.Cid
 			publish := func(params *market.PublishStorageDealsParams) error {
 				fmt.Printf("publishing %d storage deals on miner %s with worker %s\n", len(params.Deals), params.Deals[0].Proposal.Provider, m.Worker)
 
-				ret, err := doExecValue(ctx, vm, builtin.StorageMarketActorAddr, m.Worker, big.Zero(), builtin.MethodsMarket.PublishStorageDeals, mustEnc(params))
+				ret, err := doExecValue(ctx, vm, market.Address, m.Worker, big.Zero(), builtin.MethodsMarket.PublishStorageDeals, mustEnc(params))
 				if err != nil {
 					return xerrors.Errorf("failed to create genesis miner (publish deals): %w", err)
 				}
@@ -210,7 +215,7 @@ func SetupStorageMiners(ctx context.Context, cs *store.ChainStore, sroot cid.Cid
 			}
 		}
 
-		err = vm.MutateState(ctx, builtin.StoragePowerActorAddr, func(cst cbor.IpldStore, st *power0.State) error {
+		err = vm.MutateState(ctx, power.Address, func(cst cbor.IpldStore, st *power0.State) error {
 			st.TotalQualityAdjPower = qaPow
 			st.TotalRawBytePower = rawPow
 
@@ -222,7 +227,7 @@ func SetupStorageMiners(ctx context.Context, cs *store.ChainStore, sroot cid.Cid
 			return cid.Undef, xerrors.Errorf("mutating state: %w", err)
 		}
 
-		err = vm.MutateState(ctx, builtin.RewardActorAddr, func(sct cbor.IpldStore, st *reward0.State) error {
+		err = vm.MutateState(ctx, reward.Address, func(sct cbor.IpldStore, st *reward0.State) error {
 			*st = *reward0.ConstructState(qaPow)
 			return nil
 		})
@@ -252,7 +257,7 @@ func SetupStorageMiners(ctx context.Context, cs *store.ChainStore, sroot cid.Cid
 				sectorWeight := miner0.QAPowerForWeight(m.SectorSize, minerInfos[i].presealExp, dweight.DealWeight, dweight.VerifiedDealWeight)
 
 				// we've added fake power for this sector above, remove it now
-				err = vm.MutateState(ctx, builtin.StoragePowerActorAddr, func(cst cbor.IpldStore, st *power0.State) error {
+				err = vm.MutateState(ctx, power.Address, func(cst cbor.IpldStore, st *power0.State) error {
 					st.TotalQualityAdjPower = types.BigSub(st.TotalQualityAdjPower, sectorWeight) //nolint:scopelint
 					st.TotalRawBytePower = types.BigSub(st.TotalRawBytePower, types.NewInt(uint64(m.SectorSize)))
 					return nil
@@ -295,7 +300,7 @@ func SetupStorageMiners(ctx context.Context, cs *store.ChainStore, sroot cid.Cid
 					Sectors: []abi.SectorNumber{preseal.SectorID},
 				}
 
-				_, err = doExecValue(ctx, vm, minerInfos[i].maddr, builtin.StoragePowerActorAddr, big.Zero(), builtin.MethodsMiner.ConfirmSectorProofsValid, mustEnc(confirmParams))
+				_, err = doExecValue(ctx, vm, minerInfos[i].maddr, power.Address, big.Zero(), builtin.MethodsMiner.ConfirmSectorProofsValid, mustEnc(confirmParams))
 				if err != nil {
 					return cid.Undef, xerrors.Errorf("failed to confirm presealed sectors: %w", err)
 				}
@@ -304,7 +309,7 @@ func SetupStorageMiners(ctx context.Context, cs *store.ChainStore, sroot cid.Cid
 	}
 
 	// Sanity-check total network power
-	err = vm.MutateState(ctx, builtin.StoragePowerActorAddr, func(cst cbor.IpldStore, st *power0.State) error {
+	err = vm.MutateState(ctx, power.Address, func(cst cbor.IpldStore, st *power0.State) error {
 		if !st.TotalRawBytePower.Equals(rawPow) {
 			return xerrors.Errorf("st.TotalRawBytePower doesn't match previously calculated rawPow")
 		}
@@ -344,7 +349,7 @@ func (fr *fakeRand) GetBeaconRandomness(ctx context.Context, personalization cry
 }
 
 func currentTotalPower(ctx context.Context, vm *vm.VM, maddr address.Address) (*power0.CurrentTotalPowerReturn, error) {
-	pwret, err := doExecValue(ctx, vm, builtin.StoragePowerActorAddr, maddr, big.Zero(), builtin.MethodsPower.CurrentTotalPower, nil)
+	pwret, err := doExecValue(ctx, vm, power.Address, maddr, big.Zero(), builtin.MethodsPower.CurrentTotalPower, nil)
 	if err != nil {
 		return nil, err
 	}
@@ -356,33 +361,33 @@ func currentTotalPower(ctx context.Context, vm *vm.VM, maddr address.Address) (*
 	return &pwr, nil
 }
 
-func dealWeight(ctx context.Context, vm *vm.VM, maddr address.Address, dealIDs []abi.DealID, sectorStart, sectorExpiry abi.ChainEpoch) (market.VerifyDealsForActivationReturn, error) {
+func dealWeight(ctx context.Context, vm *vm.VM, maddr address.Address, dealIDs []abi.DealID, sectorStart, sectorExpiry abi.ChainEpoch) (market0.VerifyDealsForActivationReturn, error) {
 	params := &market.VerifyDealsForActivationParams{
 		DealIDs:      dealIDs,
 		SectorStart:  sectorStart,
 		SectorExpiry: sectorExpiry,
 	}
 
-	var dealWeights market.VerifyDealsForActivationReturn
+	var dealWeights market0.VerifyDealsForActivationReturn
 	ret, err := doExecValue(ctx, vm,
-		builtin.StorageMarketActorAddr,
+		market.Address,
 		maddr,
 		abi.NewTokenAmount(0),
 		builtin.MethodsMarket.VerifyDealsForActivation,
 		mustEnc(params),
 	)
 	if err != nil {
-		return market.VerifyDealsForActivationReturn{}, err
+		return market0.VerifyDealsForActivationReturn{}, err
 	}
 	if err := dealWeights.UnmarshalCBOR(bytes.NewReader(ret)); err != nil {
-		return market.VerifyDealsForActivationReturn{}, err
+		return market0.VerifyDealsForActivationReturn{}, err
 	}
 
 	return dealWeights, nil
 }
 
 func currentEpochBlockReward(ctx context.Context, vm *vm.VM, maddr address.Address) (*reward0.ThisEpochRewardReturn, error) {
-	rwret, err := doExecValue(ctx, vm, builtin.RewardActorAddr, maddr, big.Zero(), builtin.MethodsReward.ThisEpochReward, nil)
+	rwret, err := doExecValue(ctx, vm, reward.Address, maddr, big.Zero(), builtin.MethodsReward.ThisEpochReward, nil)
 	if err != nil {
 		return nil, err
 	}

chain/market/fundmgr.go

@@ -15,6 +15,7 @@ import (
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/chain/actors"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/market"
 	"github.com/filecoin-project/lotus/chain/events"
 	"github.com/filecoin-project/lotus/chain/events/state"
 	"github.com/filecoin-project/lotus/chain/types"
@@ -151,7 +152,7 @@ func (fm *FundMgr) EnsureAvailable(ctx context.Context, addr, wallet address.Add
 	}
 
 	smsg, err := fm.api.MpoolPushMessage(ctx, &types.Message{
-		To:     builtin.StorageMarketActorAddr,
+		To:     market.Address,
 		From:   wallet,
 		Value:  toAdd,
 		Method: builtin.MethodsMarket.AddBalance,

chain/market/fundmgr_test.go

@@ -17,6 +17,7 @@ import (
 
 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/chain/actors"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/market"
 	"github.com/filecoin-project/lotus/chain/types"
 )
 
@@ -47,7 +48,7 @@ func (fapi *fakeAPI) MpoolPushMessage(ctx context.Context, msg *types.Message, s
 func addFundsMsg(toAdd abi.TokenAmount, addr address.Address, wallet address.Address) *types.Message {
 	params, _ := actors.SerializeParams(&addr)
 	return &types.Message{
-		To:     builtin.StorageMarketActorAddr,
+		To:     market.Address,
 		From:   wallet,
 		Value:  toAdd,
 		Method: builtin.MethodsMarket.AddBalance,

chain/state/statetree.go

@@ -1,6 +1,7 @@
 package state
 
 import (
+	"bytes"
 	"context"
 	"fmt"
 
@@ -14,6 +15,7 @@ import (
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/lotus/chain/actors/builtin"
 	init_ "github.com/filecoin-project/lotus/chain/actors/builtin/init"
+	cbg "github.com/whyrusleeping/cbor-gen"
 
 	"github.com/filecoin-project/lotus/chain/actors/adt"
 	"github.com/filecoin-project/lotus/chain/types"
@@ -383,6 +385,7 @@ func (st *StateTree) MutateActor(addr address.Address, f func(*types.Actor) erro
 func (st *StateTree) ForEach(f func(address.Address, *types.Actor) error) error {
 	var act types.Actor
 	return st.root.ForEach(&act, func(k string) error {
+		act := act // copy
 		addr, err := address.NewFromBytes([]byte(k))
 		if err != nil {
 			return xerrors.Errorf("invalid address (%x) found in state tree key: %w", []byte(k), err)
@@ -391,3 +394,49 @@ func (st *StateTree) ForEach(f func(address.Address, *types.Actor) error) error
 		return f(addr, &act)
 	})
 }
+
+// Version returns the version of the StateTree data structure in use.
+func (st *StateTree) Version() builtin.Version {
+	return st.version
+}
+
+func Diff(oldTree, newTree *StateTree) (map[string]types.Actor, error) {
+	out := map[string]types.Actor{}
+
+	var (
+		ncval, ocval cbg.Deferred
+		buf          = bytes.NewReader(nil)
+	)
+	if err := newTree.root.ForEach(&ncval, func(k string) error {
+		var act types.Actor
+
+		addr, err := address.NewFromBytes([]byte(k))
+		if err != nil {
+			return xerrors.Errorf("address in state tree was not valid: %w", err)
+		}
+
+		found, err := oldTree.root.Get(abi.AddrKey(addr), &ocval)
+		if err != nil {
+			return err
+		}
+
+		if found && bytes.Equal(ocval.Raw, ncval.Raw) {
+			return nil // not changed
+		}
+
+		buf.Reset(ncval.Raw)
+		err = act.UnmarshalCBOR(buf)
+		buf.Reset(nil)
+
+		if err != nil {
+			return err
+		}
+
+		out[addr.String()] = act
+
+		return nil
+	}); err != nil {
+		return nil, err
+	}
+	return out, nil
+}

chain/stmgr/forks.go

@@ -1,42 +1,59 @@
 package stmgr
 
 import (
+	"bytes"
 	"context"
+	"encoding/binary"
+	"math"
+
+	multisig0 "github.com/filecoin-project/specs-actors/actors/builtin/multisig"
+
+	"github.com/filecoin-project/lotus/chain/actors/builtin/multisig"
+
+	"github.com/filecoin-project/lotus/chain/state"
+
+	"github.com/filecoin-project/specs-actors/actors/migration/nv3"
+
+	"github.com/ipfs/go-cid"
 
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/big"
-	"github.com/filecoin-project/lotus/build"
-	"github.com/filecoin-project/lotus/chain/types"
-	"github.com/filecoin-project/specs-actors/actors/builtin"
+
+	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
+	init0 "github.com/filecoin-project/specs-actors/actors/builtin/init"
 	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
 	power0 "github.com/filecoin-project/specs-actors/actors/builtin/power"
-	"github.com/filecoin-project/specs-actors/actors/util/adt"
+	adt0 "github.com/filecoin-project/specs-actors/actors/util/adt"
+
+	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/chain/vm"
 	cbor "github.com/ipfs/go-ipld-cbor"
 	"golang.org/x/xerrors"
 )
 
-var ForksAtHeight = map[abi.ChainEpoch]func(context.Context, *StateManager, types.StateTree, *types.TipSet) error{
-	build.UpgradeBreezeHeight: UpgradeFaucetBurnRecovery,
+var ForksAtHeight = map[abi.ChainEpoch]func(context.Context, *StateManager, ExecCallback, cid.Cid, *types.TipSet) (cid.Cid, error){
+	build.UpgradeBreezeHeight:   UpgradeFaucetBurnRecovery,
+	build.UpgradeIgnitionHeight: UpgradeIgnition,
+	build.UpgradeLiftoffHeight:  UpgradeLiftoff,
 }
 
-func (sm *StateManager) handleStateForks(ctx context.Context, st types.StateTree, height abi.ChainEpoch, ts *types.TipSet) (err error) {
+func (sm *StateManager) handleStateForks(ctx context.Context, root cid.Cid, height abi.ChainEpoch, cb ExecCallback, ts *types.TipSet) (cid.Cid, error) {
+	retCid := root
+	var err error
 	f, ok := ForksAtHeight[height]
 	if ok {
-		err := f(ctx, sm, st, ts)
+		retCid, err = f(ctx, sm, cb, root, ts)
 		if err != nil {
-			return err
+			return cid.Undef, err
 		}
 	}
 
-	return nil
+	return retCid, nil
 }
 
-type forEachTree interface {
-	ForEach(func(address.Address, *types.Actor) error) error
-}
-
-func doTransfer(tree types.StateTree, from, to address.Address, amt abi.TokenAmount) error {
+func doTransfer(cb ExecCallback, tree types.StateTree, from, to address.Address, amt abi.TokenAmount) error {
 	fromAct, err := tree.GetActor(from)
 	if err != nil {
 		return xerrors.Errorf("failed to get 'from' actor for transfer: %w", err)
@@ -62,10 +79,43 @@ func doTransfer(tree types.StateTree, from, to address.Address, amt abi.TokenAmo
 		return xerrors.Errorf("failed to persist to actor: %w", err)
 	}
 
+	if cb != nil {
+		// record the transfer in execution traces
+
+		fakeMsg := &types.Message{
+			From:  from,
+			To:    to,
+			Value: amt,
+			Nonce: math.MaxUint64,
+		}
+		fakeRct := &types.MessageReceipt{
+			ExitCode: 0,
+			Return:   nil,
+			GasUsed:  0,
+		}
+
+		if err := cb(fakeMsg.Cid(), fakeMsg, &vm.ApplyRet{
+			MessageReceipt: *fakeRct,
+			ActorErr:       nil,
+			ExecutionTrace: types.ExecutionTrace{
+				Msg:        fakeMsg,
+				MsgRct:     fakeRct,
+				Error:      "",
+				Duration:   0,
+				GasCharges: nil,
+				Subcalls:   nil,
+			},
+			Duration: 0,
+			GasCosts: vm.ZeroGasOutputs(),
+		}); err != nil {
+			return xerrors.Errorf("recording transfer: %w", err)
+		}
+	}
+
 	return nil
 }
 
-func UpgradeFaucetBurnRecovery(ctx context.Context, sm *StateManager, tree types.StateTree, ts *types.TipSet) error {
+func UpgradeFaucetBurnRecovery(ctx context.Context, sm *StateManager, cb ExecCallback, root cid.Cid, ts *types.TipSet) (cid.Cid, error) {
 	// Some initial parameters
 	FundsForMiners := types.FromFil(1_000_000)
 	LookbackEpoch := abi.ChainEpoch(32000)
@@ -92,22 +142,22 @@ func UpgradeFaucetBurnRecovery(ctx context.Context, sm *StateManager, tree types
 	// Grab lookback state for account checks
 	lbts, err := sm.ChainStore().GetTipsetByHeight(ctx, LookbackEpoch, ts, false)
 	if err != nil {
-		return xerrors.Errorf("failed to get tipset at lookback height: %w", err)
+		return cid.Undef, xerrors.Errorf("failed to get tipset at lookback height: %w", err)
 	}
 
 	lbtree, err := sm.ParentState(lbts)
 	if err != nil {
-		return xerrors.Errorf("loading state tree failed: %w", err)
+		return cid.Undef, xerrors.Errorf("loading state tree failed: %w", err)
 	}
 
 	ReserveAddress, err := address.NewFromString("t090")
 	if err != nil {
-		return xerrors.Errorf("failed to parse reserve address: %w", err)
+		return cid.Undef, xerrors.Errorf("failed to parse reserve address: %w", err)
 	}
 
-	fetree, ok := tree.(forEachTree)
-	if !ok {
-		return xerrors.Errorf("fork transition state tree doesnt support ForEach (%T)", tree)
+	tree, err := sm.StateTree(root)
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("getting state tree: %w", err)
 	}
 
 	type transfer struct {
@@ -119,9 +169,9 @@ func UpgradeFaucetBurnRecovery(ctx context.Context, sm *StateManager, tree types
 	var transfers []transfer
 
 	// Take all excess funds away, put them into the reserve account
-	err = fetree.ForEach(func(addr address.Address, act *types.Actor) error {
+	err = tree.ForEach(func(addr address.Address, act *types.Actor) error {
 		switch act.Code {
-		case builtin.AccountActorCodeID, builtin.MultisigActorCodeID, builtin.PaymentChannelActorCodeID:
+		case builtin0.AccountActorCodeID, builtin0.MultisigActorCodeID, builtin0.PaymentChannelActorCodeID:
 			sysAcc, err := isSystemAccount(addr)
 			if err != nil {
 				return xerrors.Errorf("checking system account: %w", err)
@@ -134,7 +184,7 @@ func UpgradeFaucetBurnRecovery(ctx context.Context, sm *StateManager, tree types
 					Amt:  act.Balance,
 				})
 			}
-		case builtin.StorageMinerActorCodeID:
+		case builtin0.StorageMinerActorCodeID:
 			var st miner0.State
 			if err := sm.ChainStore().Store(ctx).Get(ctx, act.Head, &st); err != nil {
 				return xerrors.Errorf("failed to load miner state: %w", err)
@@ -161,33 +211,33 @@ func UpgradeFaucetBurnRecovery(ctx context.Context, sm *StateManager, tree types
 		return nil
 	})
 	if err != nil {
-		return xerrors.Errorf("foreach over state tree failed: %w", err)
+		return cid.Undef, xerrors.Errorf("foreach over state tree failed: %w", err)
 	}
 
 	// Execute transfers from previous step
 	for _, t := range transfers {
-		if err := doTransfer(tree, t.From, t.To, t.Amt); err != nil {
-			return xerrors.Errorf("transfer %s %s->%s failed: %w", t.Amt, t.From, t.To, err)
+		if err := doTransfer(cb, tree, t.From, t.To, t.Amt); err != nil {
+			return cid.Undef, xerrors.Errorf("transfer %s %s->%s failed: %w", t.Amt, t.From, t.To, err)
 		}
 	}
 
 	// pull up power table to give miners back some funds proportional to their power
 	var ps power0.State
-	powAct, err := tree.GetActor(builtin.StoragePowerActorAddr)
+	powAct, err := tree.GetActor(builtin0.StoragePowerActorAddr)
 	if err != nil {
-		return xerrors.Errorf("failed to load power actor: %w", err)
+		return cid.Undef, xerrors.Errorf("failed to load power actor: %w", err)
 	}
 
 	cst := cbor.NewCborStore(sm.ChainStore().Blockstore())
 	if err := cst.Get(ctx, powAct.Head, &ps); err != nil {
-		return xerrors.Errorf("failed to get power actor state: %w", err)
+		return cid.Undef, xerrors.Errorf("failed to get power actor state: %w", err)
 	}
 
 	totalPower := ps.TotalBytesCommitted
 
 	var transfersBack []transfer
 	// Now, we return some funds to places where they are needed
-	err = fetree.ForEach(func(addr address.Address, act *types.Actor) error {
+	err = tree.ForEach(func(addr address.Address, act *types.Actor) error {
 		lbact, err := lbtree.GetActor(addr)
 		if err != nil {
 			if !xerrors.Is(err, types.ErrActorNotFound) {
@@ -201,7 +251,7 @@ func UpgradeFaucetBurnRecovery(ctx context.Context, sm *StateManager, tree types
 		}
 
 		switch act.Code {
-		case builtin.AccountActorCodeID, builtin.MultisigActorCodeID, builtin.PaymentChannelActorCodeID:
+		case builtin0.AccountActorCodeID, builtin0.MultisigActorCodeID, builtin0.PaymentChannelActorCodeID:
 			nbalance := big.Min(prevBalance, AccountCap)
 			if nbalance.Sign() != 0 {
 				transfersBack = append(transfersBack, transfer{
@@ -210,7 +260,7 @@ func UpgradeFaucetBurnRecovery(ctx context.Context, sm *StateManager, tree types
 					Amt:  nbalance,
 				})
 			}
-		case builtin.StorageMinerActorCodeID:
+		case builtin0.StorageMinerActorCodeID:
 			var st miner0.State
 			if err := sm.ChainStore().Store(ctx).Get(ctx, act.Head, &st); err != nil {
 				return xerrors.Errorf("failed to load miner state: %w", err)
@@ -221,7 +271,7 @@ func UpgradeFaucetBurnRecovery(ctx context.Context, sm *StateManager, tree types
 				return xerrors.Errorf("failed to get miner info: %w", err)
 			}
 
-			sectorsArr, err := adt.AsArray(sm.ChainStore().Store(ctx), st.Sectors)
+			sectorsArr, err := adt0.AsArray(sm.ChainStore().Store(ctx), st.Sectors)
 			if err != nil {
 				return xerrors.Errorf("failed to load sectors array: %w", err)
 			}
@@ -245,7 +295,7 @@ func UpgradeFaucetBurnRecovery(ctx context.Context, sm *StateManager, tree types
 					return xerrors.Errorf("failed to load miner state: %w", err)
 				}
 
-				lbsectors, err := adt.AsArray(sm.ChainStore().Store(ctx), lbst.Sectors)
+				lbsectors, err := adt0.AsArray(sm.ChainStore().Store(ctx), lbst.Sectors)
 				if err != nil {
 					return xerrors.Errorf("failed to load lb sectors array: %w", err)
 				}
@@ -265,53 +315,310 @@ func UpgradeFaucetBurnRecovery(ctx context.Context, sm *StateManager, tree types
 		return nil
 	})
 	if err != nil {
-		return xerrors.Errorf("foreach over state tree failed: %w", err)
+		return cid.Undef, xerrors.Errorf("foreach over state tree failed: %w", err)
 	}
 
 	for _, t := range transfersBack {
-		if err := doTransfer(tree, t.From, t.To, t.Amt); err != nil {
-			return xerrors.Errorf("transfer %s %s->%s failed: %w", t.Amt, t.From, t.To, err)
+		if err := doTransfer(cb, tree, t.From, t.To, t.Amt); err != nil {
+			return cid.Undef, xerrors.Errorf("transfer %s %s->%s failed: %w", t.Amt, t.From, t.To, err)
 		}
 	}
 
 	// transfer all burnt funds back to the reserve account
-	burntAct, err := tree.GetActor(builtin.BurntFundsActorAddr)
+	burntAct, err := tree.GetActor(builtin0.BurntFundsActorAddr)
 	if err != nil {
-		return xerrors.Errorf("failed to load burnt funds actor: %w", err)
+		return cid.Undef, xerrors.Errorf("failed to load burnt funds actor: %w", err)
 	}
-	if err := doTransfer(tree, builtin.BurntFundsActorAddr, ReserveAddress, burntAct.Balance); err != nil {
-		return xerrors.Errorf("failed to unburn funds: %w", err)
+	if err := doTransfer(cb, tree, builtin0.BurntFundsActorAddr, ReserveAddress, burntAct.Balance); err != nil {
+		return cid.Undef, xerrors.Errorf("failed to unburn funds: %w", err)
 	}
 
 	// Top up the reimbursement service
 	reimbAddr, err := address.NewFromString("t0111")
 	if err != nil {
-		return xerrors.Errorf("failed to parse reimbursement service address")
+		return cid.Undef, xerrors.Errorf("failed to parse reimbursement service address")
 	}
 
 	reimb, err := tree.GetActor(reimbAddr)
 	if err != nil {
-		return xerrors.Errorf("failed to load reimbursement account actor: %w", err)
+		return cid.Undef, xerrors.Errorf("failed to load reimbursement account actor: %w", err)
 	}
 
 	difference := types.BigSub(DesiredReimbursementBalance, reimb.Balance)
-	if err := doTransfer(tree, ReserveAddress, reimbAddr, difference); err != nil {
-		return xerrors.Errorf("failed to top up reimbursement account: %w", err)
+	if err := doTransfer(cb, tree, ReserveAddress, reimbAddr, difference); err != nil {
+		return cid.Undef, xerrors.Errorf("failed to top up reimbursement account: %w", err)
 	}
 
 	// Now, a final sanity check to make sure the balances all check out
 	total := abi.NewTokenAmount(0)
-	err = fetree.ForEach(func(addr address.Address, act *types.Actor) error {
+	err = tree.ForEach(func(addr address.Address, act *types.Actor) error {
 		total = types.BigAdd(total, act.Balance)
 		return nil
 	})
 	if err != nil {
-		return xerrors.Errorf("checking final state balance failed: %w", err)
+		return cid.Undef, xerrors.Errorf("checking final state balance failed: %w", err)
 	}
 
 	exp := types.FromFil(build.FilBase)
 	if !exp.Equals(total) {
-		return xerrors.Errorf("resultant state tree account balance was not correct: %s", total)
+		return cid.Undef, xerrors.Errorf("resultant state tree account balance was not correct: %s", total)
+	}
+
+	return tree.Flush(ctx)
+}
+
+func UpgradeIgnition(ctx context.Context, sm *StateManager, cb ExecCallback, root cid.Cid, ts *types.TipSet) (cid.Cid, error) {
+	store := sm.cs.Store(ctx)
+
+	nst, err := nv3.MigrateStateTree(ctx, store, root, build.UpgradeIgnitionHeight)
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("migrating actors state: %w", err)
+	}
+
+	tree, err := sm.StateTree(nst)
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("getting state tree: %w", err)
+	}
+
+	err = setNetworkName(ctx, store, tree, "ignition")
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("setting network name: %w", err)
+	}
+
+	split1, err := address.NewFromString("t0115")
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("first split address: %w", err)
+	}
+
+	split2, err := address.NewFromString("t0116")
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("second split address: %w", err)
+	}
+
+	err = resetGenesisMsigs(ctx, sm, store, tree)
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("resetting genesis msig start epochs: %w", err)
+	}
+
+	err = splitGenesisMultisig(ctx, cb, split1, store, tree, 50)
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("splitting first msig: %w", err)
+	}
+
+	err = splitGenesisMultisig(ctx, cb, split2, store, tree, 50)
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("splitting second msig: %w", err)
+	}
+
+	err = nv3.CheckStateTree(ctx, store, nst, build.UpgradeIgnitionHeight, builtin0.TotalFilecoin)
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("sanity check after ignition upgrade failed: %w", err)
+	}
+
+	return tree.Flush(ctx)
+}
+
+func UpgradeLiftoff(ctx context.Context, sm *StateManager, cb ExecCallback, root cid.Cid, ts *types.TipSet) (cid.Cid, error) {
+	tree, err := sm.StateTree(root)
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("getting state tree: %w", err)
+	}
+
+	err = setNetworkName(ctx, sm.cs.Store(ctx), tree, "mainnet")
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("setting network name: %w", err)
+	}
+
+	return tree.Flush(ctx)
+}
+
+func setNetworkName(ctx context.Context, store adt0.Store, tree *state.StateTree, name string) error {
+	ia, err := tree.GetActor(builtin0.InitActorAddr)
+	if err != nil {
+		return xerrors.Errorf("getting init actor: %w", err)
+	}
+
+	var initState init0.State
+	if err := store.Get(ctx, ia.Head, &initState); err != nil {
+		return xerrors.Errorf("reading init state: %w", err)
+	}
+
+	initState.NetworkName = name
+
+	ia.Head, err = store.Put(ctx, &initState)
+	if err != nil {
+		return xerrors.Errorf("writing new init state: %w", err)
+	}
+
+	if err := tree.SetActor(builtin0.InitActorAddr, ia); err != nil {
+		return xerrors.Errorf("setting init actor: %w", err)
+	}
+
+	return nil
+}
+
+func splitGenesisMultisig(ctx context.Context, cb ExecCallback, addr address.Address, store adt0.Store, tree *state.StateTree, portions uint64) error {
+	if portions < 1 {
+		return xerrors.Errorf("cannot split into 0 portions")
+	}
+
+	mact, err := tree.GetActor(addr)
+	if err != nil {
+		return xerrors.Errorf("getting msig actor: %w", err)
+	}
+
+	mst, err := multisig.Load(store, mact)
+	if err != nil {
+		return xerrors.Errorf("getting msig state: %w", err)
+	}
+
+	signers, err := mst.Signers()
+	if err != nil {
+		return xerrors.Errorf("getting msig signers: %w", err)
+	}
+
+	thresh, err := mst.Threshold()
+	if err != nil {
+		return xerrors.Errorf("getting msig threshold: %w", err)
+	}
+
+	ibal, err := mst.InitialBalance()
+	if err != nil {
+		return xerrors.Errorf("getting msig initial balance: %w", err)
+	}
+
+	se, err := mst.StartEpoch()
+	if err != nil {
+		return xerrors.Errorf("getting msig start epoch: %w", err)
+	}
+
+	ud, err := mst.UnlockDuration()
+	if err != nil {
+		return xerrors.Errorf("getting msig unlock duration: %w", err)
+	}
+
+	pending, err := adt0.MakeEmptyMap(store).Root()
+	if err != nil {
+		return xerrors.Errorf("failed to create empty map: %w", err)
+	}
+
+	newIbal := big.Div(ibal, types.NewInt(portions))
+	newState := &multisig0.State{
+		Signers:               signers,
+		NumApprovalsThreshold: thresh,
+		NextTxnID:             0,
+		InitialBalance:        newIbal,
+		StartEpoch:            se,
+		UnlockDuration:        ud,
+		PendingTxns:           pending,
+	}
+
+	scid, err := store.Put(ctx, newState)
+	if err != nil {
+		return xerrors.Errorf("storing new state: %w", err)
+	}
+
+	newActor := types.Actor{
+		Code:    builtin0.MultisigActorCodeID,
+		Head:    scid,
+		Nonce:   0,
+		Balance: big.Zero(),
+	}
+
+	i := uint64(0)
+	for i < portions {
+		keyAddr, err := makeKeyAddr(addr, i)
+		if err != nil {
+			return xerrors.Errorf("creating key address: %w", err)
+		}
+
+		idAddr, err := tree.RegisterNewAddress(keyAddr)
+		if err != nil {
+			return xerrors.Errorf("registering new address: %w", err)
+		}
+
+		err = tree.SetActor(idAddr, &newActor)
+		if err != nil {
+			return xerrors.Errorf("setting new msig actor state: %w", err)
+		}
+
+		if err := doTransfer(cb, tree, addr, idAddr, newIbal); err != nil {
+			return xerrors.Errorf("transferring split msig balance: %w", err)
+		}
+
+		i++
+	}
+
+	return nil
+}
+
+func makeKeyAddr(splitAddr address.Address, count uint64) (address.Address, error) {
+	var b bytes.Buffer
+	if err := splitAddr.MarshalCBOR(&b); err != nil {
+		return address.Undef, xerrors.Errorf("marshalling split address: %w", err)
+	}
+
+	if err := binary.Write(&b, binary.BigEndian, count); err != nil {
+		return address.Undef, xerrors.Errorf("writing count into a buffer: %w", err)
+	}
+
+	if err := binary.Write(&b, binary.BigEndian, []byte("Ignition upgrade")); err != nil {
+		return address.Undef, xerrors.Errorf("writing fork name into a buffer: %w", err)
+	}
+
+	addr, err := address.NewActorAddress(b.Bytes())
+	if err != nil {
+		return address.Undef, xerrors.Errorf("create actor address: %w", err)
+	}
+
+	return addr, nil
+}
+
+func resetGenesisMsigs(ctx context.Context, sm *StateManager, store adt0.Store, tree *state.StateTree) error {
+	gb, err := sm.cs.GetGenesis()
+	if err != nil {
+		return xerrors.Errorf("getting genesis block: %w", err)
+	}
+
+	gts, err := types.NewTipSet([]*types.BlockHeader{gb})
+	if err != nil {
+		return xerrors.Errorf("getting genesis tipset: %w", err)
+	}
+
+	cst := cbor.NewCborStore(sm.cs.Blockstore())
+	genesisTree, err := state.LoadStateTree(cst, gts.ParentState())
+	if err != nil {
+		return xerrors.Errorf("loading state tree: %w", err)
+	}
+
+	err = genesisTree.ForEach(func(addr address.Address, genesisActor *types.Actor) error {
+		if genesisActor.Code == builtin0.MultisigActorCodeID {
+			currActor, err := tree.GetActor(addr)
+			if err != nil {
+				return xerrors.Errorf("loading actor: %w", err)
+			}
+
+			var currState multisig0.State
+			if err := store.Get(ctx, currActor.Head, &currState); err != nil {
+				return xerrors.Errorf("reading multisig state: %w", err)
+			}
+
+			currState.StartEpoch = build.UpgradeLiftoffHeight
+
+			currActor.Head, err = store.Put(ctx, &currState)
+			if err != nil {
+				return xerrors.Errorf("writing new multisig state: %w", err)
+			}
+
+			if err := tree.SetActor(addr, currActor); err != nil {
+				return xerrors.Errorf("setting multisig actor: %w", err)
+			}
+		}
+		return nil
+	})
+
+	if err != nil {
+		return xerrors.Errorf("iterating over genesis actors: %w", err)
 	}
 
 	return nil

chain/stmgr/forks_test.go

@@ -8,17 +8,15 @@ import (
 
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/go-state-types/big"
 	"github.com/filecoin-project/specs-actors/actors/builtin"
 	init_ "github.com/filecoin-project/specs-actors/actors/builtin/init"
-	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
-	power0 "github.com/filecoin-project/specs-actors/actors/builtin/power"
-	verifreg0 "github.com/filecoin-project/specs-actors/actors/builtin/verifreg"
 	"github.com/filecoin-project/specs-actors/actors/runtime"
 	"golang.org/x/xerrors"
 
 	"github.com/filecoin-project/lotus/chain/actors"
 	"github.com/filecoin-project/lotus/chain/actors/aerrors"
+	lotusinit "github.com/filecoin-project/lotus/chain/actors/builtin/init"
+	"github.com/filecoin-project/lotus/chain/actors/policy"
 	"github.com/filecoin-project/lotus/chain/gen"
 	"github.com/filecoin-project/lotus/chain/stmgr"
 	. "github.com/filecoin-project/lotus/chain/stmgr"
@@ -27,17 +25,16 @@ import (
 	_ "github.com/filecoin-project/lotus/lib/sigs/bls"
 	_ "github.com/filecoin-project/lotus/lib/sigs/secp"
 
+	"github.com/ipfs/go-cid"
 	cbor "github.com/ipfs/go-ipld-cbor"
 	logging "github.com/ipfs/go-log"
 	cbg "github.com/whyrusleeping/cbor-gen"
 )
 
 func init() {
-	miner0.SupportedProofTypes = map[abi.RegisteredSealProof]struct{}{
-		abi.RegisteredSealProof_StackedDrg2KiBV1: {},
-	}
-	power0.ConsensusMinerMinPower = big.NewInt(2048)
-	verifreg0.MinVerifiedDealSize = big.NewInt(256)
+	policy.SetSupportedProofTypes(abi.RegisteredSealProof_StackedDrg2KiBV1)
+	policy.SetConsensusMinerMinPower(abi.NewStoragePower(2048))
+	policy.SetMinVerifiedDealSize(abi.NewStoragePower(256))
 }
 
 const testForkHeight = 40
@@ -118,33 +115,38 @@ func TestForkHeightTriggers(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	stmgr.ForksAtHeight[testForkHeight] = func(ctx context.Context, sm *StateManager, st types.StateTree, ts *types.TipSet) error {
+	stmgr.ForksAtHeight[testForkHeight] = func(ctx context.Context, sm *StateManager, cb ExecCallback, root cid.Cid, ts *types.TipSet) (cid.Cid, error) {
 		cst := cbor.NewCborStore(sm.ChainStore().Blockstore())
 
+		st, err := sm.StateTree(root)
+		if err != nil {
+			return cid.Undef, xerrors.Errorf("getting state tree: %w", err)
+		}
+
 		act, err := st.GetActor(taddr)
 		if err != nil {
-			return err
+			return cid.Undef, err
 		}
 
 		var tas testActorState
 		if err := cst.Get(ctx, act.Head, &tas); err != nil {
-			return xerrors.Errorf("in fork handler, failed to run get: %w", err)
+			return cid.Undef, xerrors.Errorf("in fork handler, failed to run get: %w", err)
 		}
 
 		tas.HasUpgraded = 55
 
 		ns, err := cst.Put(ctx, &tas)
 		if err != nil {
-			return err
+			return cid.Undef, err
 		}
 
 		act.Head = ns
 
 		if err := st.SetActor(taddr, act); err != nil {
-			return err
+			return cid.Undef, err
 		}
 
-		return nil
+		return st.Flush(ctx)
 	}
 
 	inv.Register(builtin.PaymentChannelActorCodeID, &testActor{}, &testActorState{})
@@ -168,7 +170,7 @@ func TestForkHeightTriggers(t *testing.T) {
 
 	m := &types.Message{
 		From:     cg.Banker(),
-		To:       builtin.InitActorAddr,
+		To:       lotusinit.Address,
 		Method:   builtin.MethodsInit.Exec,
 		Params:   enc,
 		GasLimit: types.TestGasLimit,

chain/stmgr/stmgr.go

@@ -5,12 +5,9 @@ import (
 	"fmt"
 	"sync"
 
+	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
 	msig0 "github.com/filecoin-project/specs-actors/actors/builtin/multisig"
 
-	"github.com/filecoin-project/lotus/chain/actors/builtin/multisig"
-
-	"github.com/filecoin-project/lotus/chain/actors/builtin/reward"
-
 	"github.com/ipfs/go-cid"
 	cbor "github.com/ipfs/go-ipld-cbor"
 	logging "github.com/ipfs/go-log/v2"
@@ -22,16 +19,17 @@ import (
 	"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/specs-actors/actors/builtin"
-	reward0 "github.com/filecoin-project/specs-actors/actors/builtin/reward"
-	"github.com/filecoin-project/specs-actors/actors/util/adt"
 
 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain/actors"
+	"github.com/filecoin-project/lotus/chain/actors/adt"
+	"github.com/filecoin-project/lotus/chain/actors/builtin"
 	"github.com/filecoin-project/lotus/chain/actors/builtin/market"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/multisig"
 	"github.com/filecoin-project/lotus/chain/actors/builtin/paych"
 	"github.com/filecoin-project/lotus/chain/actors/builtin/power"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/reward"
 	"github.com/filecoin-project/lotus/chain/state"
 	"github.com/filecoin-project/lotus/chain/store"
 	"github.com/filecoin-project/lotus/chain/types"
@@ -43,12 +41,13 @@ var log = logging.Logger("statemgr")
 type StateManager struct {
 	cs *store.ChainStore
 
-	stCache       map[string][]cid.Cid
-	compWait      map[string]chan struct{}
-	stlk          sync.Mutex
-	genesisMsigLk sync.Mutex
-	newVM         func(context.Context, *vm.VMOpts) (*vm.VM, error)
-	genInfo       *genesisInfo
+	stCache              map[string][]cid.Cid
+	compWait             map[string]chan struct{}
+	stlk                 sync.Mutex
+	genesisMsigLk        sync.Mutex
+	newVM                func(context.Context, *vm.VMOpts) (*vm.VM, error)
+	preIgnitionGenInfos  *genesisInfo
+	postIgnitionGenInfos *genesisInfo
 }
 
 func NewStateManager(cs *store.ChainStore) *StateManager {
@@ -125,9 +124,8 @@ func (sm *StateManager) TipSetState(ctx context.Context, ts *types.TipSet) (st c
 	return st, rec, nil
 }
 
-func (sm *StateManager) ExecutionTrace(ctx context.Context, ts *types.TipSet) (cid.Cid, []*api.InvocResult, error) {
-	var trace []*api.InvocResult
-	st, _, err := sm.computeTipSetState(ctx, ts, func(mcid cid.Cid, msg *types.Message, ret *vm.ApplyRet) error {
+func traceFunc(trace *[]*api.InvocResult) func(mcid cid.Cid, msg *types.Message, ret *vm.ApplyRet) error {
+	return func(mcid cid.Cid, msg *types.Message, ret *vm.ApplyRet) error {
 		ir := &api.InvocResult{
 			Msg:            msg,
 			MsgRct:         &ret.MessageReceipt,
@@ -137,9 +135,14 @@ func (sm *StateManager) ExecutionTrace(ctx context.Context, ts *types.TipSet) (c
 		if ret.ActorErr != nil {
 			ir.Error = ret.ActorErr.Error()
 		}
-		trace = append(trace, ir)
+		*trace = append(*trace, ir)
 		return nil
-	})
+	}
+}
+
+func (sm *StateManager) ExecutionTrace(ctx context.Context, ts *types.TipSet) (cid.Cid, []*api.InvocResult, error) {
+	var trace []*api.InvocResult
+	st, _, err := sm.computeTipSetState(ctx, ts, traceFunc(&trace))
 	if err != nil {
 		return cid.Undef, nil, err
 	}
@@ -151,38 +154,42 @@ type ExecCallback func(cid.Cid, *types.Message, *vm.ApplyRet) error
 
 func (sm *StateManager) ApplyBlocks(ctx context.Context, parentEpoch abi.ChainEpoch, pstate cid.Cid, bms []store.BlockMessages, epoch abi.ChainEpoch, r vm.Rand, cb ExecCallback, baseFee abi.TokenAmount, ts *types.TipSet) (cid.Cid, cid.Cid, error) {
 
-	vmopt := &vm.VMOpts{
-		StateBase:      pstate,
-		Epoch:          epoch,
-		Rand:           r,
-		Bstore:         sm.cs.Blockstore(),
-		Syscalls:       sm.cs.VMSys(),
-		CircSupplyCalc: sm.GetCirculatingSupply,
-		NtwkVersion:    sm.GetNtwkVersion,
-		BaseFee:        baseFee,
+	makeVmWithBaseState := func(base cid.Cid) (*vm.VM, error) {
+		vmopt := &vm.VMOpts{
+			StateBase:      base,
+			Epoch:          epoch,
+			Rand:           r,
+			Bstore:         sm.cs.Blockstore(),
+			Syscalls:       sm.cs.VMSys(),
+			CircSupplyCalc: sm.GetCirculatingSupply,
+			NtwkVersion:    sm.GetNtwkVersion,
+			BaseFee:        baseFee,
+		}
+
+		return sm.newVM(ctx, vmopt)
 	}
 
-	vmi, err := sm.newVM(ctx, vmopt)
+	vmi, err := makeVmWithBaseState(pstate)
 	if err != nil {
-		return cid.Undef, cid.Undef, xerrors.Errorf("instantiating VM failed: %w", err)
+		return cid.Undef, cid.Undef, xerrors.Errorf("making vm: %w", err)
 	}
 
 	runCron := func() error {
 		// TODO: this nonce-getting is a tiny bit ugly
-		ca, err := vmi.StateTree().GetActor(builtin.SystemActorAddr)
+		ca, err := vmi.StateTree().GetActor(builtin0.SystemActorAddr)
 		if err != nil {
 			return err
 		}
 
 		cronMsg := &types.Message{
-			To:         builtin.CronActorAddr,
-			From:       builtin.SystemActorAddr,
+			To:         builtin0.CronActorAddr,
+			From:       builtin0.SystemActorAddr,
 			Nonce:      ca.Nonce,
 			Value:      types.NewInt(0),
 			GasFeeCap:  types.NewInt(0),
 			GasPremium: types.NewInt(0),
 			GasLimit:   build.BlockGasLimit * 10000, // Make super sure this is never too little
-			Method:     builtin.MethodsCron.EpochTick,
+			Method:     builtin0.MethodsCron.EpochTick,
 			Params:     nil,
 		}
 		ret, err := vmi.ApplyImplicitMessage(ctx, cronMsg)
@@ -204,19 +211,32 @@ func (sm *StateManager) ApplyBlocks(ctx context.Context, parentEpoch abi.ChainEp
 	for i := parentEpoch; i < epoch; i++ {
 		// handle state forks
 		// XXX: The state tree
-		err = sm.handleStateForks(ctx, vmi.StateTree(), i, ts)
+		newState, err := sm.handleStateForks(ctx, pstate, i, cb, ts)
 		if err != nil {
 			return cid.Undef, cid.Undef, xerrors.Errorf("error handling state forks: %w", err)
 		}
 
+		if pstate != newState {
+			vmi, err = makeVmWithBaseState(newState)
+			if err != nil {
+				return cid.Undef, cid.Undef, xerrors.Errorf("making vm: %w", err)
+			}
+		}
+
 		if i > parentEpoch {
 			// run cron for null rounds if any
 			if err := runCron(); err != nil {
 				return cid.Cid{}, cid.Cid{}, err
 			}
+
+			newState, err = vmi.Flush(ctx)
+			if err != nil {
+				return cid.Undef, cid.Undef, xerrors.Errorf("flushing vm: %w", err)
+			}
 		}
 
 		vmi.SetBlockHeight(i + 1)
+		pstate = newState
 	}
 
 	var receipts []cbg.CBORMarshaler
@@ -247,42 +267,34 @@ func (sm *StateManager) ApplyBlocks(ctx context.Context, parentEpoch abi.ChainEp
 			processedMsgs[m.Cid()] = true
 		}
 
-		var params []byte
-
-		nv := sm.GetNtwkVersion(ctx, epoch)
-		if nv < build.ActorUpgradeNetworkVersion {
-			params, err = actors.SerializeParams(&reward0.AwardBlockRewardParams{
-				Miner:     b.Miner,
-				Penalty:   penalty,
-				GasReward: gasReward,
-				WinCount:  b.WinCount,
-			})
-			if err != nil {
-				return cid.Undef, cid.Undef, xerrors.Errorf("failed to serialize award params: %w", err)
-			}
-		} else {
-			// TODO: ActorUpgrade
-			params = nil
+		params, err := actors.SerializeParams(&reward.AwardBlockRewardParams{
+			Miner:     b.Miner,
+			Penalty:   penalty,
+			GasReward: gasReward,
+			WinCount:  b.WinCount,
+		})
+		if err != nil {
+			return cid.Undef, cid.Undef, xerrors.Errorf("failed to serialize award params: %w", err)
 		}
 
-		sysAct, err := vmi.StateTree().GetActor(builtin.SystemActorAddr)
-		if err != nil {
+		sysAct, actErr := vmi.StateTree().GetActor(builtin0.SystemActorAddr)
+		if actErr != nil {
 			return cid.Undef, cid.Undef, xerrors.Errorf("failed to get system actor: %w", err)
 		}
 
 		rwMsg := &types.Message{
-			From:       builtin.SystemActorAddr,
-			To:         builtin.RewardActorAddr,
+			From:       builtin0.SystemActorAddr,
+			To:         reward.Address,
 			Nonce:      sysAct.Nonce,
 			Value:      types.NewInt(0),
 			GasFeeCap:  types.NewInt(0),
 			GasPremium: types.NewInt(0),
 			GasLimit:   1 << 30,
-			Method:     builtin.MethodsReward.AwardBlockReward,
+			Method:     builtin0.MethodsReward.AwardBlockReward,
 			Params:     params,
 		}
-		ret, err := vmi.ApplyImplicitMessage(ctx, rwMsg)
-		if err != nil {
+		ret, actErr := vmi.ApplyImplicitMessage(ctx, rwMsg)
+		if actErr != nil {
 			return cid.Undef, cid.Undef, xerrors.Errorf("failed to apply reward message for miner %s: %w", b.Miner, err)
 		}
 		if cb != nil {
@@ -300,7 +312,11 @@ func (sm *StateManager) ApplyBlocks(ctx context.Context, parentEpoch abi.ChainEp
 		return cid.Cid{}, cid.Cid{}, err
 	}
 
-	rectarr := adt.MakeEmptyArray(sm.cs.Store(ctx))
+	// XXX: Is the height correct? Or should it be epoch-1?
+	rectarr, err := adt.NewArray(sm.cs.Store(ctx), builtin.VersionForNetwork(sm.GetNtwkVersion(ctx, epoch)))
+	if err != nil {
+		return cid.Undef, cid.Undef, xerrors.Errorf("failed to create receipts amt: %w", err)
+	}
 	for i, receipt := range receipts {
 		if err := rectarr.Set(uint64(i), receipt); err != nil {
 			return cid.Undef, cid.Undef, xerrors.Errorf("failed to build receipts amt: %w", err)
@@ -698,17 +714,13 @@ func (sm *StateManager) ListAllActors(ctx context.Context, ts *types.TipSet) ([]
 		return nil, err
 	}
 
-	r, err := adt.AsMap(sm.cs.Store(ctx), st)
+	stateTree, err := sm.StateTree(st)
 	if err != nil {
 		return nil, err
 	}
 
 	var out []address.Address
-	err = r.ForEach(nil, func(k string) error {
-		addr, err := address.NewFromBytes([]byte(k))
-		if err != nil {
-			return xerrors.Errorf("address in state tree was not valid: %w", err)
-		}
+	err = stateTree.ForEach(func(addr address.Address, act *types.Actor) error {
 		out = append(out, addr)
 		return nil
 	})
@@ -725,7 +737,7 @@ func (sm *StateManager) MarketBalance(ctx context.Context, addr address.Address,
 		return api.MarketBalance{}, err
 	}
 
-	act, err := st.GetActor(builtin.StorageMarketActorAddr)
+	act, err := st.GetActor(market.Address)
 	if err != nil {
 		return api.MarketBalance{}, err
 	}
@@ -845,51 +857,56 @@ func (sm *StateManager) setupGenesisActors(ctx context.Context) error {
 		return xerrors.Errorf("setting up genesis pledge: %w", err)
 	}
 
-	r, err := adt.AsMap(sm.cs.Store(ctx), st)
-	if err != nil {
-		return xerrors.Errorf("getting genesis actors: %w", err)
-	}
-
 	totalsByEpoch := make(map[abi.ChainEpoch]abi.TokenAmount)
-	var act types.Actor
-	err = r.ForEach(&act, func(k string) error {
-		if act.Code == builtin.MultisigActorCodeID {
-			var s multisig.State
-			err := sm.cs.Store(ctx).Get(ctx, act.Head, &s)
+	err = sTree.ForEach(func(kaddr address.Address, act *types.Actor) error {
+		if act.IsMultisigActor() {
+			s, err := multisig.Load(sm.cs.Store(ctx), act)
 			if err != nil {
 				return err
 			}
 
-			if s.StartEpoch() != 0 {
+			se, err := s.StartEpoch()
+			if err != nil {
+				return err
+			}
+
+			if se != 0 {
 				return xerrors.New("genesis multisig doesn't start vesting at epoch 0!")
 			}
 
-			ot, f := totalsByEpoch[s.UnlockDuration()]
-			if f {
-				totalsByEpoch[s.UnlockDuration()] = big.Add(ot, s.InitialBalance())
-			} else {
-				totalsByEpoch[s.UnlockDuration()] = s.InitialBalance()
+			ud, err := s.UnlockDuration()
+			if err != nil {
+				return err
 			}
 
-		} else if act.Code == builtin.AccountActorCodeID {
+			ib, err := s.InitialBalance()
+			if err != nil {
+				return err
+			}
+
+			ot, f := totalsByEpoch[ud]
+			if f {
+				totalsByEpoch[ud] = big.Add(ot, ib)
+			} else {
+				totalsByEpoch[ud] = ib
+			}
+
+		} else if act.IsAccountActor() {
 			// should exclude burnt funds actor and "remainder account actor"
 			// should only ever be "faucet" accounts in testnets
-			kaddr, err := address.NewFromBytes([]byte(k))
+			if kaddr == builtin0.BurntFundsActorAddr {
+				return nil
+			}
+
+			kid, err := sTree.LookupID(kaddr)
 			if err != nil {
-				return xerrors.Errorf("decoding address: %w", err)
+				return xerrors.Errorf("resolving address: %w", err)
 			}
 
-			if kaddr != builtin.BurntFundsActorAddr {
-				kid, err := sTree.LookupID(kaddr)
-				if err != nil {
-					return xerrors.Errorf("resolving address: %w", err)
-				}
-
-				gi.genesisActors = append(gi.genesisActors, genesisActor{
-					addr:    kid,
-					initBal: act.Balance,
-				})
-			}
+			gi.genesisActors = append(gi.genesisActors, genesisActor{
+				addr:    kid,
+				initBal: act.Balance,
+			})
 		}
 		return nil
 	})
@@ -898,6 +915,7 @@ func (sm *StateManager) setupGenesisActors(ctx context.Context) error {
 		return xerrors.Errorf("error setting up genesis infos: %w", err)
 	}
 
+	// TODO: use network upgrade abstractions or always start at actors v0?
 	gi.genesisMsigs = make([]msig0.State, 0, len(totalsByEpoch))
 	for k, v := range totalsByEpoch {
 		ns := msig0.State{
@@ -908,7 +926,7 @@ func (sm *StateManager) setupGenesisActors(ctx context.Context) error {
 		gi.genesisMsigs = append(gi.genesisMsigs, ns)
 	}
 
-	sm.genInfo = &gi
+	sm.preIgnitionGenInfos = &gi
 
 	return nil
 }
@@ -916,7 +934,7 @@ func (sm *StateManager) setupGenesisActors(ctx context.Context) error {
 // sets up information about the actors in the genesis state
 // For testnet we use a hardcoded set of multisig states, instead of what's actually in the genesis multisigs
 // We also do not consider ANY account actors (including the faucet)
-func (sm *StateManager) setupGenesisActorsTestnet(ctx context.Context) error {
+func (sm *StateManager) setupPreIgnitionGenesisActorsTestnet(ctx context.Context) error {
 
 	gi := genesisInfo{}
 
@@ -954,24 +972,24 @@ func (sm *StateManager) setupGenesisActorsTestnet(ctx context.Context) error {
 	totalsByEpoch := make(map[abi.ChainEpoch]abi.TokenAmount)
 
 	// 6 months
-	sixMonths := abi.ChainEpoch(183 * builtin.EpochsInDay)
+	sixMonths := abi.ChainEpoch(183 * builtin0.EpochsInDay)
 	totalsByEpoch[sixMonths] = big.NewInt(49_929_341)
 	totalsByEpoch[sixMonths] = big.Add(totalsByEpoch[sixMonths], big.NewInt(32_787_700))
 
 	// 1 year
-	oneYear := abi.ChainEpoch(365 * builtin.EpochsInDay)
+	oneYear := abi.ChainEpoch(365 * builtin0.EpochsInDay)
 	totalsByEpoch[oneYear] = big.NewInt(22_421_712)
 
 	// 2 years
-	twoYears := abi.ChainEpoch(2 * 365 * builtin.EpochsInDay)
+	twoYears := abi.ChainEpoch(2 * 365 * builtin0.EpochsInDay)
 	totalsByEpoch[twoYears] = big.NewInt(7_223_364)
 
 	// 3 years
-	threeYears := abi.ChainEpoch(3 * 365 * builtin.EpochsInDay)
+	threeYears := abi.ChainEpoch(3 * 365 * builtin0.EpochsInDay)
 	totalsByEpoch[threeYears] = big.NewInt(87_637_883)
 
 	// 6 years
-	sixYears := abi.ChainEpoch(6 * 365 * builtin.EpochsInDay)
+	sixYears := abi.ChainEpoch(6 * 365 * builtin0.EpochsInDay)
 	totalsByEpoch[sixYears] = big.NewInt(100_000_000)
 	totalsByEpoch[sixYears] = big.Add(totalsByEpoch[sixYears], big.NewInt(300_000_000))
 
@@ -985,7 +1003,87 @@ func (sm *StateManager) setupGenesisActorsTestnet(ctx context.Context) error {
 		gi.genesisMsigs = append(gi.genesisMsigs, ns)
 	}
 
-	sm.genInfo = &gi
+	sm.preIgnitionGenInfos = &gi
+
+	return nil
+}
+
+// sets up information about the actors in the genesis state, post the ignition fork
+func (sm *StateManager) setupPostIgnitionGenesisActors(ctx context.Context) error {
+
+	gi := genesisInfo{}
+
+	gb, err := sm.cs.GetGenesis()
+	if err != nil {
+		return xerrors.Errorf("getting genesis block: %w", err)
+	}
+
+	gts, err := types.NewTipSet([]*types.BlockHeader{gb})
+	if err != nil {
+		return xerrors.Errorf("getting genesis tipset: %w", err)
+	}
+
+	st, _, err := sm.TipSetState(ctx, gts)
+	if err != nil {
+		return xerrors.Errorf("getting genesis tipset state: %w", err)
+	}
+
+	cst := cbor.NewCborStore(sm.cs.Blockstore())
+	sTree, err := state.LoadStateTree(cst, st)
+	if err != nil {
+		return xerrors.Errorf("loading state tree: %w", err)
+	}
+
+	// Unnecessary, should be removed
+	gi.genesisMarketFunds, err = getFilMarketLocked(ctx, sTree)
+	if err != nil {
+		return xerrors.Errorf("setting up genesis market funds: %w", err)
+	}
+
+	// Unnecessary, should be removed
+	gi.genesisPledge, err = getFilPowerLocked(ctx, sTree)
+	if err != nil {
+		return xerrors.Errorf("setting up genesis pledge: %w", err)
+	}
+
+	totalsByEpoch := make(map[abi.ChainEpoch]abi.TokenAmount)
+
+	// 6 months
+	sixMonths := abi.ChainEpoch(183 * builtin0.EpochsInDay)
+	totalsByEpoch[sixMonths] = big.NewInt(49_929_341)
+	totalsByEpoch[sixMonths] = big.Add(totalsByEpoch[sixMonths], big.NewInt(32_787_700))
+
+	// 1 year
+	oneYear := abi.ChainEpoch(365 * builtin0.EpochsInDay)
+	totalsByEpoch[oneYear] = big.NewInt(22_421_712)
+
+	// 2 years
+	twoYears := abi.ChainEpoch(2 * 365 * builtin0.EpochsInDay)
+	totalsByEpoch[twoYears] = big.NewInt(7_223_364)
+
+	// 3 years
+	threeYears := abi.ChainEpoch(3 * 365 * builtin0.EpochsInDay)
+	totalsByEpoch[threeYears] = big.NewInt(87_637_883)
+
+	// 6 years
+	sixYears := abi.ChainEpoch(6 * 365 * builtin0.EpochsInDay)
+	totalsByEpoch[sixYears] = big.NewInt(100_000_000)
+	totalsByEpoch[sixYears] = big.Add(totalsByEpoch[sixYears], big.NewInt(300_000_000))
+
+	gi.genesisMsigs = make([]msig0.State, 0, len(totalsByEpoch))
+	for k, v := range totalsByEpoch {
+		ns := msig0.State{
+			// In the pre-ignition logic, we incorrectly set this value in Fil, not attoFil, an off-by-10^18 error
+			InitialBalance: big.Mul(v, big.NewInt(int64(build.FilecoinPrecision))),
+			UnlockDuration: k,
+			PendingTxns:    cid.Undef,
+			// In the pre-ignition logic, the start epoch was 0. This changes in the fork logic of the Ignition upgrade itself.
+			StartEpoch: build.UpgradeLiftoffHeight,
+		}
+		gi.genesisMsigs = append(gi.genesisMsigs, ns)
+	}
+
+	sm.postIgnitionGenInfos = &gi
 
 	return nil
 }
@@ -995,13 +1093,23 @@ func (sm *StateManager) setupGenesisActorsTestnet(ctx context.Context) error {
 // - For Accounts, it counts max(currentBalance - genesisBalance, 0).
 func (sm *StateManager) GetFilVested(ctx context.Context, height abi.ChainEpoch, st *state.StateTree) (abi.TokenAmount, error) {
 	vf := big.Zero()
-	for _, v := range sm.genInfo.genesisMsigs {
-		au := big.Sub(v.InitialBalance, v.AmountLocked(height))
-		vf = big.Add(vf, au)
+	if height <= build.UpgradeIgnitionHeight {
+		for _, v := range sm.preIgnitionGenInfos.genesisMsigs {
+			au := big.Sub(v.InitialBalance, v.AmountLocked(height))
+			vf = big.Add(vf, au)
+		}
+	} else {
+		for _, v := range sm.postIgnitionGenInfos.genesisMsigs {
+			// In the pre-ignition logic, we simply called AmountLocked(height), assuming startEpoch was 0.
+			// The start epoch changed in the Ignition upgrade.
+			au := big.Sub(v.InitialBalance, v.AmountLocked(height-v.StartEpoch))
+			vf = big.Add(vf, au)
+		}
 	}
 
 	// there should not be any such accounts in testnet (and also none in mainnet?)
-	for _, v := range sm.genInfo.genesisActors {
+	// continue to use preIgnitionGenInfos, nothing changed at the Ignition epoch
+	for _, v := range sm.preIgnitionGenInfos.genesisActors {
 		act, err := st.GetActor(v.addr)
 		if err != nil {
 			return big.Zero(), xerrors.Errorf("failed to get actor: %w", err)
@@ -1013,14 +1121,16 @@ func (sm *StateManager) GetFilVested(ctx context.Context, height abi.ChainEpoch,
 		}
 	}
 
-	vf = big.Add(vf, sm.genInfo.genesisPledge)
-	vf = big.Add(vf, sm.genInfo.genesisMarketFunds)
+	// continue to use preIgnitionGenInfos, nothing changed at the Ignition epoch
+	vf = big.Add(vf, sm.preIgnitionGenInfos.genesisPledge)
+	// continue to use preIgnitionGenInfos, nothing changed at the Ignition epoch
+	vf = big.Add(vf, sm.preIgnitionGenInfos.genesisMarketFunds)
 
 	return vf, nil
 }
 
 func GetFilMined(ctx context.Context, st *state.StateTree) (abi.TokenAmount, error) {
-	ractor, err := st.GetActor(builtin.RewardActorAddr)
+	ractor, err := st.GetActor(reward.Address)
 	if err != nil {
 		return big.Zero(), xerrors.Errorf("failed to load reward actor state: %w", err)
 	}
@@ -1034,7 +1144,7 @@ func GetFilMined(ctx context.Context, st *state.StateTree) (abi.TokenAmount, err
 }
 
 func getFilMarketLocked(ctx context.Context, st *state.StateTree) (abi.TokenAmount, error) {
-	act, err := st.GetActor(builtin.StorageMarketActorAddr)
+	act, err := st.GetActor(market.Address)
 	if err != nil {
 		return big.Zero(), xerrors.Errorf("failed to load market actor: %w", err)
 	}
@@ -1048,7 +1158,7 @@ func getFilMarketLocked(ctx context.Context, st *state.StateTree) (abi.TokenAmou
 }
 
 func getFilPowerLocked(ctx context.Context, st *state.StateTree) (abi.TokenAmount, error) {
-	pactor, err := st.GetActor(builtin.StoragePowerActorAddr)
+	pactor, err := st.GetActor(power.Address)
 	if err != nil {
 		return big.Zero(), xerrors.Errorf("failed to load power actor: %w", err)
 	}
@@ -1077,7 +1187,7 @@ func (sm *StateManager) GetFilLocked(ctx context.Context, st *state.StateTree) (
 }
 
 func GetFilBurnt(ctx context.Context, st *state.StateTree) (abi.TokenAmount, error) {
-	burnt, err := st.GetActor(builtin.BurntFundsActorAddr)
+	burnt, err := st.GetActor(builtin0.BurntFundsActorAddr)
 	if err != nil {
 		return big.Zero(), xerrors.Errorf("failed to load burnt actor: %w", err)
 	}
@@ -1088,10 +1198,16 @@ func GetFilBurnt(ctx context.Context, st *state.StateTree) (abi.TokenAmount, err
 func (sm *StateManager) GetCirculatingSupplyDetailed(ctx context.Context, height abi.ChainEpoch, st *state.StateTree) (api.CirculatingSupply, error) {
 	sm.genesisMsigLk.Lock()
 	defer sm.genesisMsigLk.Unlock()
-	if sm.genInfo == nil {
-		err := sm.setupGenesisActorsTestnet(ctx)
+	if sm.preIgnitionGenInfos == nil {
+		err := sm.setupPreIgnitionGenesisActorsTestnet(ctx)
 		if err != nil {
-			return api.CirculatingSupply{}, xerrors.Errorf("failed to setup genesis information: %w", err)
+			return api.CirculatingSupply{}, xerrors.Errorf("failed to setup pre-ignition genesis information: %w", err)
+		}
+	}
+	if sm.postIgnitionGenInfos == nil {
+		err := sm.setupPostIgnitionGenesisActors(ctx)
+		if err != nil {
+			return api.CirculatingSupply{}, xerrors.Errorf("failed to setup post-ignition genesis information: %w", err)
 		}
 	}
 
@@ -1156,6 +1272,10 @@ func (sm *StateManager) GetNtwkVersion(ctx context.Context, height abi.ChainEpoc
 		return network.Version1
 	}
 
+	if height <= build.UpgradeIgnitionHeight {
+		return network.Version2
+	}
+
 	return build.NewestNetworkVersion
 }
 

chain/stmgr/utils.go

@@ -9,15 +9,6 @@ import (
 	"runtime"
 	"strings"
 
-	init0 "github.com/filecoin-project/specs-actors/actors/builtin/init"
-	market0 "github.com/filecoin-project/specs-actors/actors/builtin/market"
-	power0 "github.com/filecoin-project/specs-actors/actors/builtin/power"
-
-	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
-
-	saruntime "github.com/filecoin-project/specs-actors/actors/runtime"
-	"github.com/filecoin-project/specs-actors/actors/runtime/proof"
-
 	cid "github.com/ipfs/go-cid"
 	cbg "github.com/whyrusleeping/cbor-gen"
 	"golang.org/x/xerrors"
@@ -26,26 +17,32 @@ import (
 	"github.com/filecoin-project/go-bitfield"
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/crypto"
-	"github.com/filecoin-project/lotus/chain/actors/builtin/power"
-	"github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper"
-	"github.com/filecoin-project/specs-actors/actors/builtin"
-	"github.com/filecoin-project/specs-actors/actors/builtin/account"
-	"github.com/filecoin-project/specs-actors/actors/builtin/cron"
+
+	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
+	account0 "github.com/filecoin-project/specs-actors/actors/builtin/account"
+	cron0 "github.com/filecoin-project/specs-actors/actors/builtin/cron"
+	init0 "github.com/filecoin-project/specs-actors/actors/builtin/init"
+	market0 "github.com/filecoin-project/specs-actors/actors/builtin/market"
+	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
 	msig0 "github.com/filecoin-project/specs-actors/actors/builtin/multisig"
-	"github.com/filecoin-project/specs-actors/actors/builtin/paych"
+	paych0 "github.com/filecoin-project/specs-actors/actors/builtin/paych"
+	power0 "github.com/filecoin-project/specs-actors/actors/builtin/power"
 	reward0 "github.com/filecoin-project/specs-actors/actors/builtin/reward"
 	verifreg0 "github.com/filecoin-project/specs-actors/actors/builtin/verifreg"
+	proof0 "github.com/filecoin-project/specs-actors/actors/runtime/proof"
 
 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/build"
 	init_ "github.com/filecoin-project/lotus/chain/actors/builtin/init"
 	"github.com/filecoin-project/lotus/chain/actors/builtin/market"
 	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/power"
 	"github.com/filecoin-project/lotus/chain/beacon"
 	"github.com/filecoin-project/lotus/chain/state"
 	"github.com/filecoin-project/lotus/chain/store"
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/chain/vm"
+	"github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper"
 	"github.com/filecoin-project/lotus/node/modules/dtypes"
 )
 
@@ -89,7 +86,7 @@ func GetPower(ctx context.Context, sm *StateManager, ts *types.TipSet, maddr add
 }
 
 func GetPowerRaw(ctx context.Context, sm *StateManager, st cid.Cid, maddr address.Address) (power.Claim, power.Claim, bool, error) {
-	act, err := sm.LoadActorRaw(ctx, builtin.StoragePowerActorAddr, st)
+	act, err := sm.LoadActorRaw(ctx, power.Address, st)
 	if err != nil {
 		return power.Claim{}, power.Claim{}, false, xerrors.Errorf("(get sset) failed to load power actor state: %w", err)
 	}
@@ -150,7 +147,7 @@ func MinerSectorInfo(ctx context.Context, sm *StateManager, maddr address.Addres
 	return mas.GetSector(sid)
 }
 
-func GetMinerSectorSet(ctx context.Context, sm *StateManager, ts *types.TipSet, maddr address.Address, filter *bitfield.BitField, filterOut bool) ([]*miner.ChainSectorInfo, error) {
+func GetMinerSectorSet(ctx context.Context, sm *StateManager, ts *types.TipSet, maddr address.Address, snos *bitfield.BitField) ([]*miner.SectorOnChainInfo, error) {
 	act, err := sm.LoadActor(ctx, maddr, ts)
 	if err != nil {
 		return nil, xerrors.Errorf("(get sset) failed to load miner actor: %w", err)
@@ -161,32 +158,10 @@ func GetMinerSectorSet(ctx context.Context, sm *StateManager, ts *types.TipSet,
 		return nil, xerrors.Errorf("(get sset) failed to load miner actor state: %w", err)
 	}
 
-	sectors, err := mas.LoadSectorsFromSet(filter, filterOut)
-	if err != nil {
-		return nil, xerrors.Errorf("(get sset) failed to load sectors: %w", err)
-	}
-
-	var sset []*miner.ChainSectorInfo
-	var v cbg.Deferred
-	if err := sectors.ForEach(&v, func(i int64) error {
-		var oci miner0.SectorOnChainInfo
-		if err := oci.UnmarshalCBOR(bytes.NewReader(v.Raw)); err != nil {
-			return err
-		}
-		sset = append(sset, &miner.ChainSectorInfo{
-			Info: oci,
-			ID:   abi.SectorNumber(i),
-		})
-
-		return nil
-	}); err != nil {
-		return nil, err
-	}
-
-	return sset, nil
+	return mas.LoadSectors(snos)
 }
 
-func GetSectorsForWinningPoSt(ctx context.Context, pv ffiwrapper.Verifier, sm *StateManager, st cid.Cid, maddr address.Address, rand abi.PoStRandomness) ([]proof.SectorInfo, error) {
+func GetSectorsForWinningPoSt(ctx context.Context, pv ffiwrapper.Verifier, sm *StateManager, st cid.Cid, maddr address.Address, rand abi.PoStRandomness) ([]proof0.SectorInfo, error) {
 	act, err := sm.LoadActorRaw(ctx, maddr, st)
 	if err != nil {
 		return nil, xerrors.Errorf("failed to load miner actor: %w", err)
@@ -197,12 +172,21 @@ func GetSectorsForWinningPoSt(ctx context.Context, pv ffiwrapper.Verifier, sm *S
 		return nil, xerrors.Errorf("failed to load miner actor state: %w", err)
 	}
 
-	// TODO (!!): This was partition.Sectors-partition.Faults originally, which was likely very wrong, and will need to be an upgrade
-	//  ^ THE CURRENT THING HERE WON'T SYNC v
+	// TODO (!!): Actor Update: Make this active sectors
 
-	provingSectors, err := miner.AllPartSectors(mas, miner.Partition.ActiveSectors)
+	allSectors, err := miner.AllPartSectors(mas, miner.Partition.AllSectors)
 	if err != nil {
-		return nil, xerrors.Errorf("merge partition proving sets: %w", err)
+		return nil, xerrors.Errorf("get all sectors: %w", err)
+	}
+
+	faultySectors, err := miner.AllPartSectors(mas, miner.Partition.FaultySectors)
+	if err != nil {
+		return nil, xerrors.Errorf("get faulty sectors: %w", err)
+	}
+
+	provingSectors, err := bitfield.SubtractBitField(allSectors, faultySectors) // TODO: This is wrong, as it can contain faaults, change to just ActiveSectors in an upgrade
+	if err != nil {
+		return nil, xerrors.Errorf("calc proving sectors: %w", err)
 	}
 
 	numProvSect, err := provingSectors.Count()
@@ -240,35 +224,31 @@ func GetSectorsForWinningPoSt(ctx context.Context, pv ffiwrapper.Verifier, sm *S
 		return nil, xerrors.Errorf("generating winning post challenges: %w", err)
 	}
 
-	sectors, err := mas.LoadSectorsFromSet(&provingSectors, false)
+	iter, err := provingSectors.BitIterator()
+	if err != nil {
+		return nil, xerrors.Errorf("iterating over proving sectors: %w", err)
+	}
+
+	// Select winning sectors by _index_ in the all-sectors bitfield.
+	selectedSectors := bitfield.New()
+	prev := uint64(0)
+	for _, n := range ids {
+		sno, err := iter.Nth(n - prev)
+		if err != nil {
+			return nil, xerrors.Errorf("iterating over proving sectors: %w", err)
+		}
+		selectedSectors.Set(sno)
+		prev = n
+	}
+
+	sectors, err := mas.LoadSectors(&selectedSectors)
 	if err != nil {
 		return nil, xerrors.Errorf("loading proving sectors: %w", err)
 	}
 
-	out := make([]proof.SectorInfo, len(ids))
-	for i, n := range ids {
-		sb, err := provingSectors.Slice(n, 1)
-		if err != nil {
-			return nil, err
-		}
-
-		sid, err := sb.First()
-		if err != nil {
-			return nil, err
-		}
-
-		var sinfo miner.SectorOnChainInfo
-		found, err := sectors.Get(sid, &sinfo)
-
-		if err != nil {
-			return nil, xerrors.Errorf("loading sector info: %w", err)
-		}
-
-		if !found {
-			return nil, xerrors.Errorf("didn't find sector info for sector %d", n)
-		}
-
-		out[i] = proof.SectorInfo{
+	out := make([]proof0.SectorInfo, len(sectors))
+	for i, sinfo := range sectors {
+		out[i] = proof0.SectorInfo{
 			SealProof:    spt,
 			SectorNumber: sinfo.SectorNumber,
 			SealedCID:    sinfo.SealedCID,
@@ -298,7 +278,7 @@ func StateMinerInfo(ctx context.Context, sm *StateManager, ts *types.TipSet, mad
 }
 
 func GetMinerSlashed(ctx context.Context, sm *StateManager, ts *types.TipSet, maddr address.Address) (bool, error) {
-	act, err := sm.LoadActor(ctx, builtin.StoragePowerActorAddr, ts)
+	act, err := sm.LoadActor(ctx, power.Address, ts)
 	if err != nil {
 		return false, xerrors.Errorf("failed to load power actor: %w", err)
 	}
@@ -321,7 +301,7 @@ func GetMinerSlashed(ctx context.Context, sm *StateManager, ts *types.TipSet, ma
 }
 
 func GetStorageDeal(ctx context.Context, sm *StateManager, dealID abi.DealID, ts *types.TipSet) (*api.MarketDeal, error) {
-	act, err := sm.LoadActor(ctx, builtin.StorageMarketActorAddr, ts)
+	act, err := sm.LoadActor(ctx, market.Address, ts)
 	if err != nil {
 		return nil, xerrors.Errorf("failed to load market actor: %w", err)
 	}
@@ -365,7 +345,7 @@ func GetStorageDeal(ctx context.Context, sm *StateManager, dealID abi.DealID, ts
 }
 
 func ListMinerActors(ctx context.Context, sm *StateManager, ts *types.TipSet) ([]address.Address, error) {
-	act, err := sm.LoadActor(ctx, builtin.StoragePowerActorAddr, ts)
+	act, err := sm.LoadActor(ctx, power.Address, ts)
 	if err != nil {
 		return nil, xerrors.Errorf("failed to load power actor: %w", err)
 	}
@@ -388,6 +368,16 @@ func ComputeState(ctx context.Context, sm *StateManager, height abi.ChainEpoch,
 		return cid.Undef, nil, err
 	}
 
+	for i := ts.Height(); i < height; i++ {
+		// handle state forks
+		base, err = sm.handleStateForks(ctx, base, i, traceFunc(&trace), ts)
+		if err != nil {
+			return cid.Undef, nil, xerrors.Errorf("error handling state forks: %w", err)
+		}
+
+		// TODO: should we also run cron here?
+	}
+
 	r := store.NewChainRand(sm.cs, ts.Cids())
 	vmopt := &vm.VMOpts{
 		StateBase:      base,
@@ -404,16 +394,6 @@ func ComputeState(ctx context.Context, sm *StateManager, height abi.ChainEpoch,
 		return cid.Undef, nil, err
 	}
 
-	for i := ts.Height(); i < height; i++ {
-		// handle state forks
-		err = sm.handleStateForks(ctx, vmi.StateTree(), i, ts)
-		if err != nil {
-			return cid.Undef, nil, xerrors.Errorf("error handling state forks: %w", err)
-		}
-
-		// TODO: should we also run cron here?
-	}
-
 	for i, msg := range msgs {
 		// TODO: Use the signed message length for secp messages
 		ret, err := vmi.ApplyMessage(ctx, msg)
@@ -555,24 +535,24 @@ var MethodsMap = map[cid.Cid]map[abi.MethodNum]MethodMeta{}
 func init() {
 	cidToMethods := map[cid.Cid][2]interface{}{
 		// builtin.SystemActorCodeID:        {builtin.MethodsSystem, system.Actor{} }- apparently it doesn't have methods
-		builtin.InitActorCodeID:             {builtin.MethodsInit, init0.Actor{}},
-		builtin.CronActorCodeID:             {builtin.MethodsCron, cron.Actor{}},
-		builtin.AccountActorCodeID:          {builtin.MethodsAccount, account.Actor{}},
-		builtin.StoragePowerActorCodeID:     {builtin.MethodsPower, power0.Actor{}},
-		builtin.StorageMinerActorCodeID:     {builtin.MethodsMiner, miner0.Actor{}},
-		builtin.StorageMarketActorCodeID:    {builtin.MethodsMarket, market0.Actor{}},
-		builtin.PaymentChannelActorCodeID:   {builtin.MethodsPaych, paych.Actor{}},
-		builtin.MultisigActorCodeID:         {builtin.MethodsMultisig, msig0.Actor{}},
-		builtin.RewardActorCodeID:           {builtin.MethodsReward, reward0.Actor{}},
-		builtin.VerifiedRegistryActorCodeID: {builtin.MethodsVerifiedRegistry, verifreg0.Actor{}},
+		builtin0.InitActorCodeID:             {builtin0.MethodsInit, init0.Actor{}},
+		builtin0.CronActorCodeID:             {builtin0.MethodsCron, cron0.Actor{}},
+		builtin0.AccountActorCodeID:          {builtin0.MethodsAccount, account0.Actor{}},
+		builtin0.StoragePowerActorCodeID:     {builtin0.MethodsPower, power0.Actor{}},
+		builtin0.StorageMinerActorCodeID:     {builtin0.MethodsMiner, miner0.Actor{}},
+		builtin0.StorageMarketActorCodeID:    {builtin0.MethodsMarket, market0.Actor{}},
+		builtin0.PaymentChannelActorCodeID:   {builtin0.MethodsPaych, paych0.Actor{}},
+		builtin0.MultisigActorCodeID:         {builtin0.MethodsMultisig, msig0.Actor{}},
+		builtin0.RewardActorCodeID:           {builtin0.MethodsReward, reward0.Actor{}},
+		builtin0.VerifiedRegistryActorCodeID: {builtin0.MethodsVerifiedRegistry, verifreg0.Actor{}},
 	}
 
 	for c, m := range cidToMethods {
-		exports := m[1].(saruntime.Invokee).Exports()
+		exports := m[1].(vm.Invokee).Exports()
 		methods := make(map[abi.MethodNum]MethodMeta, len(exports))
 
 		// Explicitly add send, it's special.
-		methods[builtin.MethodSend] = MethodMeta{
+		methods[builtin0.MethodSend] = MethodMeta{
 			Name:   "Send",
 			Params: reflect.TypeOf(new(abi.EmptyValue)),
 			Ret:    reflect.TypeOf(new(abi.EmptyValue)),
@@ -612,9 +592,9 @@ func init() {
 			}
 
 			switch abi.MethodNum(number) {
-			case builtin.MethodSend:
+			case builtin0.MethodSend:
 				panic("method 0 is reserved for Send")
-			case builtin.MethodConstructor:
+			case builtin0.MethodConstructor:
 				if fnName != "Constructor" {
 					panic("method 1 is reserved for Constructor")
 				}
@@ -644,7 +624,7 @@ func GetReturnType(ctx context.Context, sm *StateManager, to address.Address, me
 }
 
 func MinerHasMinPower(ctx context.Context, sm *StateManager, addr address.Address, ts *types.TipSet) (bool, error) {
-	pact, err := sm.LoadActor(ctx, builtin.StoragePowerActorAddr, ts)
+	pact, err := sm.LoadActor(ctx, power.Address, ts)
 	if err != nil {
 		return false, xerrors.Errorf("loading power actor state: %w", err)
 	}

chain/store/store.go

@@ -1301,7 +1301,7 @@ func (cs *ChainStore) GetLatestBeaconEntry(ts *types.TipSet) (*types.BeaconEntry
 		}, nil
 	}
 
-	return nil, xerrors.Errorf("found NO beacon entries in the 20 blocks prior to given tipset")
+	return nil, xerrors.Errorf("found NO beacon entries in the 20 latest tipsets")
 }
 
 type chainRand struct {

chain/store/store_test.go

@@ -8,12 +8,9 @@ import (
 	datastore "github.com/ipfs/go-datastore"
 
 	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/go-state-types/big"
 	"github.com/filecoin-project/go-state-types/crypto"
-	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
-	power0 "github.com/filecoin-project/specs-actors/actors/builtin/power"
-	verifreg0 "github.com/filecoin-project/specs-actors/actors/builtin/verifreg"
 
+	"github.com/filecoin-project/lotus/chain/actors/policy"
 	"github.com/filecoin-project/lotus/chain/gen"
 	"github.com/filecoin-project/lotus/chain/store"
 	"github.com/filecoin-project/lotus/chain/types"
@@ -22,11 +19,9 @@ import (
 )
 
 func init() {
-	miner0.SupportedProofTypes = map[abi.RegisteredSealProof]struct{}{
-		abi.RegisteredSealProof_StackedDrg2KiBV1: {},
-	}
-	power0.ConsensusMinerMinPower = big.NewInt(2048)
-	verifreg0.MinVerifiedDealSize = big.NewInt(256)
+	policy.SetSupportedProofTypes(abi.RegisteredSealProof_StackedDrg2KiBV1)
+	policy.SetConsensusMinerMinPower(abi.NewStoragePower(2048))
+	policy.SetMinVerifiedDealSize(abi.NewStoragePower(256))
 }
 
 func BenchmarkGetRandomness(b *testing.B) {

chain/store/weight.go

@@ -10,7 +10,6 @@ import (
 	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain/state"
 	"github.com/filecoin-project/lotus/chain/types"
-	"github.com/filecoin-project/specs-actors/actors/builtin"
 	cbor "github.com/ipfs/go-ipld-cbor"
 	"golang.org/x/xerrors"
 )
@@ -35,7 +34,7 @@ func (cs *ChainStore) Weight(ctx context.Context, ts *types.TipSet) (types.BigIn
 			return types.NewInt(0), xerrors.Errorf("load state tree: %w", err)
 		}
 
-		act, err := state.GetActor(builtin.StoragePowerActorAddr)
+		act, err := state.GetActor(power.Address)
 		if err != nil {
 			return types.NewInt(0), xerrors.Errorf("get power actor: %w", err)
 		}

chain/sync.go

@@ -7,7 +7,6 @@ import (
 	"fmt"
 	"os"
 	"sort"
-	"strconv"
 	"strings"
 	"sync"
 	"time"
@@ -18,6 +17,7 @@ import (
 
 	"github.com/Gurpartap/async"
 	"github.com/hashicorp/go-multierror"
+	blocks "github.com/ipfs/go-block-format"
 	"github.com/ipfs/go-cid"
 	cbor "github.com/ipfs/go-ipld-cbor"
 	logging "github.com/ipfs/go-log/v2"
@@ -33,7 +33,6 @@ import (
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/crypto"
 	"github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper"
-	"github.com/filecoin-project/specs-actors/actors/builtin"
 	"github.com/filecoin-project/specs-actors/actors/util/adt"
 	blst "github.com/supranational/blst/bindings/go"
 
@@ -63,20 +62,12 @@ var (
 	// where the Syncer publishes candidate chain heads to be synced.
 	LocalIncoming = "incoming"
 
-	log                           = logging.Logger("chain")
-	defaultMessageFetchWindowSize = 200
-)
+	log = logging.Logger("chain")
 
-func init() {
-	if s := os.Getenv("LOTUS_BSYNC_MSG_WINDOW"); s != "" {
-		val, err := strconv.Atoi(s)
-		if err != nil {
-			log.Errorf("failed to parse LOTUS_BSYNC_MSG_WINDOW: %s", err)
-			return
-		}
-		defaultMessageFetchWindowSize = val
-	}
-}
+	concurrentSyncRequests = exchange.ShufflePeersPrefix
+	syncRequestBatchSize   = 8
+	syncRequestRetries     = 5
+)
 
 // Syncer is in charge of running the chain synchronization logic. As such, it
 // is tasked with these functions, amongst others:
@@ -132,8 +123,6 @@ type Syncer struct {
 
 	verifier ffiwrapper.Verifier
 
-	windowSize int
-
 	tickerCtxCancel context.CancelFunc
 
 	checkptLk sync.Mutex
@@ -175,7 +164,6 @@ func NewSyncer(ds dtypes.MetadataDS, sm *stmgr.StateManager, exchange exchange.C
 		receiptTracker: newBlockReceiptTracker(),
 		connmgr:        connmgr,
 		verifier:       verifier,
-		windowSize:     defaultMessageFetchWindowSize,
 
 		incoming: pubsub.New(50),
 	}
@@ -387,21 +375,28 @@ func (syncer *Syncer) InformNewBlock(from peer.ID, blk *types.FullBlock) bool {
 	return syncer.InformNewHead(from, fts)
 }
 
-func copyBlockstore(from, to bstore.Blockstore) error {
-	cids, err := from.AllKeysChan(context.TODO())
+func copyBlockstore(ctx context.Context, from, to bstore.Blockstore) error {
+	ctx, span := trace.StartSpan(ctx, "copyBlockstore")
+	defer span.End()
+
+	cids, err := from.AllKeysChan(ctx)
 	if err != nil {
 		return err
 	}
 
+	// TODO: should probably expose better methods on the blockstore for this operation
+	var blks []blocks.Block
 	for c := range cids {
 		b, err := from.Get(c)
 		if err != nil {
 			return err
 		}
 
-		if err := to.Put(b); err != nil {
-			return err
-		}
+		blks = append(blks, b)
+	}
+
+	if err := to.PutMany(blks); err != nil {
+		return err
 	}
 
 	return nil
@@ -640,7 +635,7 @@ func (syncer *Syncer) ValidateTipSet(ctx context.Context, fts *store.FullTipSet)
 }
 
 func (syncer *Syncer) minerIsValid(ctx context.Context, maddr address.Address, baseTs *types.TipSet) error {
-	act, err := syncer.sm.LoadActor(ctx, builtin.StoragePowerActorAddr, baseTs)
+	act, err := syncer.sm.LoadActor(ctx, power.Address, baseTs)
 	if err != nil {
 		return xerrors.Errorf("failed to load power actor: %w", err)
 	}
@@ -1482,8 +1477,6 @@ func (syncer *Syncer) iterFullTipsets(ctx context.Context, headers []*types.TipS
 
 	span.AddAttributes(trace.Int64Attribute("num_headers", int64(len(headers))))
 
-	windowSize := syncer.windowSize
-mainLoop:
 	for i := len(headers) - 1; i >= 0; {
 		fts, err := syncer.store.TryFillTipSet(headers[i])
 		if err != nil {
@@ -1497,35 +1490,20 @@ mainLoop:
 			continue
 		}
 
-		batchSize := windowSize
+		batchSize := concurrentSyncRequests * syncRequestBatchSize
 		if i < batchSize {
-			batchSize = i
+			batchSize = i + 1
 		}
 
-		nextI := (i + 1) - batchSize // want to fetch batchSize values, 'i' points to last one we want to fetch, so its 'inclusive' of our request, thus we need to add one to our request start index
-
 		ss.SetStage(api.StageFetchingMessages)
-		var bstout []*exchange.CompactedMessages
-		for len(bstout) < batchSize {
-			next := headers[nextI]
-
-			nreq := batchSize - len(bstout)
-			bstips, err := syncer.Exchange.GetChainMessages(ctx, next, uint64(nreq))
-			if err != nil {
-				// TODO check errors for temporary nature
-				if windowSize > 1 {
-					windowSize /= 2
-					log.Infof("error fetching messages: %s; reducing window size to %d and trying again", err, windowSize)
-					continue mainLoop
-				}
-				return xerrors.Errorf("message processing failed: %w", err)
-			}
-
-			bstout = append(bstout, bstips...)
-			nextI += len(bstips)
-		}
+		startOffset := i + 1 - batchSize
+		bstout, batchErr := syncer.fetchMessages(ctx, headers[startOffset:startOffset+batchSize], startOffset)
 		ss.SetStage(api.StageMessages)
 
+		if batchErr != nil {
+			return xerrors.Errorf("failed to fetch messages: %w", err)
+		}
+
 		for bsi := 0; bsi < len(bstout); bsi++ {
 			// temp storage so we don't persist data we dont want to
 			bs := bstore.NewTemporary()
@@ -1545,36 +1523,91 @@ mainLoop:
 				return err
 			}
 
-			if err := persistMessages(bs, bstip); err != nil {
+			if err := persistMessages(ctx, bs, bstip); err != nil {
 				return err
 			}
 
-			if err := copyBlockstore(bs, syncer.store.Blockstore()); err != nil {
+			if err := copyBlockstore(ctx, bs, syncer.store.Blockstore()); err != nil {
 				return xerrors.Errorf("message processing failed: %w", err)
 			}
 		}
 
-		if i >= windowSize {
-			newWindowSize := windowSize + 10
-			if newWindowSize > int(exchange.MaxRequestLength) {
-				newWindowSize = int(exchange.MaxRequestLength)
-			}
-			if newWindowSize > windowSize {
-				windowSize = newWindowSize
-				log.Infof("successfully fetched %d messages; increasing window size to %d", len(bstout), windowSize)
-			}
-		}
-
 		i -= batchSize
 	}
 
-	// remember our window size
-	syncer.windowSize = windowSize
-
 	return nil
 }
 
-func persistMessages(bs bstore.Blockstore, bst *exchange.CompactedMessages) error {
+func (syncer *Syncer) fetchMessages(ctx context.Context, headers []*types.TipSet, startOffset int) ([]*exchange.CompactedMessages, error) {
+	batchSize := len(headers)
+	batch := make([]*exchange.CompactedMessages, batchSize)
+
+	var wg sync.WaitGroup
+	var mx sync.Mutex
+	var batchErr error
+
+	start := build.Clock.Now()
+
+	for j := 0; j < batchSize; j += syncRequestBatchSize {
+		wg.Add(1)
+		go func(j int) {
+			defer wg.Done()
+
+			nreq := syncRequestBatchSize
+			if j+nreq > batchSize {
+				nreq = batchSize - j
+			}
+
+			failed := false
+			for offset := 0; !failed && offset < nreq; {
+				nextI := j + offset
+				lastI := j + nreq
+
+				var requestErr error
+				var requestResult []*exchange.CompactedMessages
+				for retry := 0; requestResult == nil && retry < syncRequestRetries; retry++ {
+					if retry > 0 {
+						log.Infof("fetching messages at %d (retry %d)", startOffset+nextI, retry)
+					} else {
+						log.Infof("fetching messages at %d", startOffset+nextI)
+					}
+
+					result, err := syncer.Exchange.GetChainMessages(ctx, headers[nextI:lastI])
+					if err != nil {
+						requestErr = multierror.Append(requestErr, err)
+					} else {
+						requestResult = result
+					}
+				}
+
+				mx.Lock()
+				if requestResult != nil {
+					copy(batch[j+offset:], requestResult)
+					offset += len(requestResult)
+				} else {
+					log.Errorf("error fetching messages at %d: %s", nextI, requestErr)
+					batchErr = multierror.Append(batchErr, requestErr)
+					failed = true
+				}
+				mx.Unlock()
+			}
+		}(j)
+	}
+	wg.Wait()
+
+	if batchErr != nil {
+		return nil, batchErr
+	}
+
+	log.Infof("fetching messages for %d tipsets at %d done; took %s", batchSize, startOffset, build.Clock.Since(start))
+
+	return batch, nil
+}
+
+func persistMessages(ctx context.Context, bs bstore.Blockstore, bst *exchange.CompactedMessages) error {
+	_, span := trace.StartSpan(ctx, "persistMessages")
+	defer span.End()
+
 	for _, m := range bst.Bls {
 		//log.Infof("putting BLS message: %s", m.Cid())
 		if _, err := store.PutMessage(bs, m); err != nil {
@@ -1706,7 +1739,7 @@ func (syncer *Syncer) getLatestBeaconEntry(_ context.Context, ts *types.TipSet)
 		cur = next
 	}
 
-	return nil, xerrors.Errorf("found NO beacon entries in the 20 blocks prior to given tipset")
+	return nil, xerrors.Errorf("found NO beacon entries in the 20 latest tipsets")
 }
 
 func (syncer *Syncer) IsEpochBeyondCurrMax(epoch abi.ChainEpoch) bool {

chain/sync_test.go

@@ -19,13 +19,10 @@ import (
 
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/go-state-types/big"
-	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
-	power0 "github.com/filecoin-project/specs-actors/actors/builtin/power"
-	verifreg0 "github.com/filecoin-project/specs-actors/actors/builtin/verifreg"
 
 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/actors/policy"
 	"github.com/filecoin-project/lotus/chain/gen"
 	"github.com/filecoin-project/lotus/chain/gen/slashfilter"
 	"github.com/filecoin-project/lotus/chain/store"
@@ -43,11 +40,9 @@ func init() {
 	if err != nil {
 		panic(err)
 	}
-	miner0.SupportedProofTypes = map[abi.RegisteredSealProof]struct{}{
-		abi.RegisteredSealProof_StackedDrg2KiBV1: {},
-	}
-	power0.ConsensusMinerMinPower = big.NewInt(2048)
-	verifreg0.MinVerifiedDealSize = big.NewInt(256)
+	policy.SetSupportedProofTypes(abi.RegisteredSealProof_StackedDrg2KiBV1)
+	policy.SetConsensusMinerMinPower(abi.NewStoragePower(2048))
+	policy.SetMinVerifiedDealSize(abi.NewStoragePower(256))
 }
 
 const source = 0

chain/types/actor.go

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

chain/vm/vm.go

@@ -5,6 +5,7 @@ import (
 	"context"
 	"fmt"
 	"reflect"
+	"sync/atomic"
 	"time"
 
 	block "github.com/ipfs/go-block-format"
@@ -28,6 +29,7 @@ import (
 	"github.com/filecoin-project/lotus/chain/actors/adt"
 	"github.com/filecoin-project/lotus/chain/actors/aerrors"
 	"github.com/filecoin-project/lotus/chain/actors/builtin/account"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/reward"
 	"github.com/filecoin-project/lotus/chain/state"
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/lib/blockstore"
@@ -39,6 +41,12 @@ var log = logging.Logger("vm")
 var actorLog = logging.Logger("actors")
 var gasOnActorExec = newGasCharge("OnActorExec", 0, 0)
 
+// stat counters
+var (
+	StatSends   uint64
+	StatApplied uint64
+)
+
 // ResolveToKeyAddr returns the public key type of address (`BLS`/`SECP256K1`) of an account actor identified by `addr`.
 func ResolveToKeyAddr(state types.StateTree, cst cbor.IpldStore, addr address.Address) (address.Address, error) {
 	if addr.Protocol() == address.BLS || addr.Protocol() == address.SECP256K1 {
@@ -203,6 +211,8 @@ type ApplyRet struct {
 func (vm *VM) send(ctx context.Context, msg *types.Message, parent *Runtime,
 	gasCharge *GasCharge, start time.Time) ([]byte, aerrors.ActorError, *Runtime) {
 
+	defer atomic.AddUint64(&StatSends, 1)
+
 	st := vm.cstate
 
 	origin := msg.From
@@ -311,6 +321,7 @@ func checkMessage(msg *types.Message) error {
 
 func (vm *VM) ApplyImplicitMessage(ctx context.Context, msg *types.Message) (*ApplyRet, error) {
 	start := build.Clock.Now()
+	defer atomic.AddUint64(&StatApplied, 1)
 	ret, actorErr, rt := vm.send(ctx, msg, nil, nil, start)
 	rt.finilizeGasTracing()
 	return &ApplyRet{
@@ -330,6 +341,7 @@ func (vm *VM) ApplyMessage(ctx context.Context, cmsg types.ChainMsg) (*ApplyRet,
 	start := build.Clock.Now()
 	ctx, span := trace.StartSpan(ctx, "vm.ApplyMessage")
 	defer span.End()
+	defer atomic.AddUint64(&StatApplied, 1)
 	msg := cmsg.VMMessage()
 	if span.IsRecordingEvents() {
 		span.AddAttributes(
@@ -384,7 +396,7 @@ func (vm *VM) ApplyMessage(ctx context.Context, cmsg types.ChainMsg) (*ApplyRet,
 	}
 
 	// this should never happen, but is currently still exercised by some tests
-	if !fromActor.Code.Equals(builtin.AccountActorCodeID) {
+	if !fromActor.IsAccountActor() {
 		gasOutputs := ZeroGasOutputs()
 		gasOutputs.MinerPenalty = minerPenaltyAmount
 		return &ApplyRet{
@@ -493,7 +505,7 @@ func (vm *VM) ApplyMessage(ctx context.Context, cmsg types.ChainMsg) (*ApplyRet,
 		return nil, xerrors.Errorf("failed to burn base fee: %w", err)
 	}
 
-	if err := vm.transferFromGasHolder(builtin.RewardActorAddr, gasHolder, gasOutputs.MinerTip); err != nil {
+	if err := vm.transferFromGasHolder(reward.Address, gasHolder, gasOutputs.MinerTip); err != nil {
 		return nil, xerrors.Errorf("failed to give miner gas reward: %w", err)
 	}
 
@@ -545,7 +557,7 @@ func (vm *VM) Flush(ctx context.Context) (cid.Cid, error) {
 		return cid.Undef, xerrors.Errorf("flushing vm: %w", err)
 	}
 
-	if err := Copy(from, to, root); err != nil {
+	if err := Copy(ctx, from, to, root); err != nil {
 		return cid.Undef, xerrors.Errorf("copying tree: %w", err)
 	}
 
@@ -599,9 +611,18 @@ func linksForObj(blk block.Block, cb func(cid.Cid)) error {
 	}
 }
 
-func Copy(from, to blockstore.Blockstore, root cid.Cid) error {
+func Copy(ctx context.Context, from, to blockstore.Blockstore, root cid.Cid) error {
+	ctx, span := trace.StartSpan(ctx, "vm.Copy") // nolint
+	defer span.End()
+
+	var numBlocks int
+	var totalCopySize int
+
 	var batch []block.Block
 	batchCp := func(blk block.Block) error {
+		numBlocks++
+		totalCopySize += len(blk.RawData())
+
 		batch = append(batch, blk)
 		if len(batch) > 100 {
 			if err := to.PutMany(batch); err != nil {
@@ -622,6 +643,11 @@ func Copy(from, to blockstore.Blockstore, root cid.Cid) error {
 		}
 	}
 
+	span.AddAttributes(
+		trace.Int64Attribute("numBlocks", int64(numBlocks)),
+		trace.Int64Attribute("copySize", int64(totalCopySize)),
+	)
+
 	return nil
 }
 

cli/chain.go

@@ -40,6 +40,7 @@ var chainCmd = &cli.Command{
 		chainHeadCmd,
 		chainGetBlock,
 		chainReadObjCmd,
+		chainDeleteObjCmd,
 		chainStatObjCmd,
 		chainGetMsgCmd,
 		chainSetHeadCmd,
@@ -193,6 +194,43 @@ var chainReadObjCmd = &cli.Command{
 	},
 }
 
+var chainDeleteObjCmd = &cli.Command{
+	Name:        "delete-obj",
+	Usage:       "Delete an object from the chain blockstore",
+	Description: "WARNING: Removing wrong objects from the chain blockstore may lead to sync issues",
+	ArgsUsage:   "[objectCid]",
+	Flags: []cli.Flag{
+		&cli.BoolFlag{
+			Name: "really-do-it",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		api, closer, err := GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+		ctx := ReqContext(cctx)
+
+		c, err := cid.Decode(cctx.Args().First())
+		if err != nil {
+			return fmt.Errorf("failed to parse cid input: %s", err)
+		}
+
+		if !cctx.Bool("really-do-it") {
+			return xerrors.Errorf("pass the --really-do-it flag to proceed")
+		}
+
+		err = api.ChainDeleteObj(ctx, c)
+		if err != nil {
+			return err
+		}
+
+		fmt.Printf("Obj %s deleted\n", c.String())
+		return nil
+	},
+}
+
 var chainStatObjCmd = &cli.Command{
 	Name:      "stat-obj",
 	Usage:     "Collect size and ipld link counts for objs",

cli/multisig.go

@@ -2,8 +2,6 @@ package cli
 
 import (
 	"bytes"
-	"context"
-	"encoding/binary"
 	"encoding/hex"
 	"fmt"
 	"os"
@@ -11,22 +9,26 @@ import (
 	"strconv"
 	"text/tabwriter"
 
+	"github.com/filecoin-project/lotus/chain/actors"
+
+	"github.com/filecoin-project/go-state-types/big"
+
 	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/specs-actors/actors/builtin"
-	"github.com/filecoin-project/specs-actors/actors/util/adt"
 
 	"github.com/filecoin-project/go-address"
-	init_ "github.com/filecoin-project/specs-actors/actors/builtin/init"
-	msig0 "github.com/filecoin-project/specs-actors/actors/builtin/multisig"
-	cid "github.com/ipfs/go-cid"
 	cbor "github.com/ipfs/go-ipld-cbor"
 	"github.com/urfave/cli/v2"
 	"golang.org/x/xerrors"
 
-	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/specs-actors/actors/builtin"
+	init0 "github.com/filecoin-project/specs-actors/actors/builtin/init"
+	msig0 "github.com/filecoin-project/specs-actors/actors/builtin/multisig"
+
 	"github.com/filecoin-project/lotus/api/apibstore"
 	"github.com/filecoin-project/lotus/build"
-	types "github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/chain/actors/adt"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/multisig"
+	"github.com/filecoin-project/lotus/chain/types"
 )
 
 var multisigCmd = &cli.Command{
@@ -43,6 +45,9 @@ var multisigCmd = &cli.Command{
 		msigSwapProposeCmd,
 		msigSwapApproveCmd,
 		msigSwapCancelCmd,
+		msigLockProposeCmd,
+		msigLockApproveCmd,
+		msigLockCancelCmd,
 		msigVestedCmd,
 	},
 }
@@ -146,7 +151,7 @@ var msigCreateCmd = &cli.Command{
 
 		// get address of newly created miner
 
-		var execreturn init_.ExecReturn
+		var execreturn init0.ExecReturn
 		if err := execreturn.UnmarshalCBOR(bytes.NewReader(wait.Receipt.Return)); err != nil {
 			return err
 		}
@@ -179,50 +184,73 @@ var msigInspectCmd = &cli.Command{
 		defer closer()
 		ctx := ReqContext(cctx)
 
+		store := adt.WrapStore(ctx, cbor.NewCborStore(apibstore.NewAPIBlockstore(api)))
+
 		maddr, err := address.NewFromString(cctx.Args().First())
 		if err != nil {
 			return err
 		}
 
-		act, err := api.StateGetActor(ctx, maddr, types.EmptyTSK)
-		if err != nil {
-			return err
-		}
-
-		obj, err := api.ChainReadObj(ctx, act.Head)
-		if err != nil {
-			return err
-		}
-
 		head, err := api.ChainHead(ctx)
 		if err != nil {
 			return err
 		}
 
-		var mstate msig0.State
-		if err := mstate.UnmarshalCBOR(bytes.NewReader(obj)); err != nil {
+		act, err := api.StateGetActor(ctx, maddr, head.Key())
+		if err != nil {
+			return err
+		}
+
+		mstate, err := multisig.Load(store, act)
+		if err != nil {
+			return err
+		}
+		locked, err := mstate.LockedBalance(head.Height())
+		if err != nil {
 			return err
 		}
 
-		locked := mstate.AmountLocked(head.Height() - mstate.StartEpoch)
 		fmt.Printf("Balance: %s\n", types.FIL(act.Balance))
 		fmt.Printf("Spendable: %s\n", types.FIL(types.BigSub(act.Balance, locked)))
 
 		if cctx.Bool("vesting") {
-			fmt.Printf("InitialBalance: %s\n", types.FIL(mstate.InitialBalance))
-			fmt.Printf("StartEpoch: %d\n", mstate.StartEpoch)
-			fmt.Printf("UnlockDuration: %d\n", mstate.UnlockDuration)
+			ib, err := mstate.InitialBalance()
+			if err != nil {
+				return err
+			}
+			fmt.Printf("InitialBalance: %s\n", types.FIL(ib))
+			se, err := mstate.StartEpoch()
+			if err != nil {
+				return err
+			}
+			fmt.Printf("StartEpoch: %d\n", se)
+			ud, err := mstate.UnlockDuration()
+			if err != nil {
+				return err
+			}
+			fmt.Printf("UnlockDuration: %d\n", ud)
 		}
 
-		fmt.Printf("Threshold: %d / %d\n", mstate.NumApprovalsThreshold, len(mstate.Signers))
+		signers, err := mstate.Signers()
+		if err != nil {
+			return err
+		}
+		threshold, err := mstate.Threshold()
+		if err != nil {
+			return err
+		}
+		fmt.Printf("Threshold: %d / %d\n", threshold, len(signers))
 		fmt.Println("Signers:")
-		for _, s := range mstate.Signers {
+		for _, s := range signers {
 			fmt.Printf("\t%s\n", s)
 		}
 
-		pending, err := GetMultisigPending(ctx, api, mstate.PendingTxns)
-		if err != nil {
-			return fmt.Errorf("reading pending transactions: %w", err)
+		pending := make(map[int64]multisig.Transaction)
+		if err := mstate.ForEachPendingTxn(func(id int64, txn multisig.Transaction) error {
+			pending[id] = txn
+			return nil
+		}); err != nil {
+			return xerrors.Errorf("reading pending transactions: %w", err)
 		}
 
 		fmt.Println("Transactions: ", len(pending))
@@ -239,7 +267,7 @@ var msigInspectCmd = &cli.Command{
 			fmt.Fprintf(w, "ID\tState\tApprovals\tTo\tValue\tMethod\tParams\n")
 			for _, txid := range txids {
 				tx := pending[txid]
-				fmt.Fprintf(w, "%d\t%s\t%d\t%s\t%s\t%d\t%x\n", txid, state(tx), len(tx.Approved), tx.To, types.FIL(tx.Value), tx.Method, tx.Params)
+				fmt.Fprintf(w, "%d\t%s\t%d\t%s\t%s\t%d\t%x\n", txid, "pending", len(tx.Approved), tx.To, types.FIL(tx.Value), tx.Method, tx.Params)
 			}
 			if err := w.Flush(); err != nil {
 				return xerrors.Errorf("flushing output: %+v", err)
@@ -251,43 +279,6 @@ var msigInspectCmd = &cli.Command{
 	},
 }
 
-func GetMultisigPending(ctx context.Context, lapi api.FullNode, hroot cid.Cid) (map[int64]*msig0.Transaction, error) {
-	bs := apibstore.NewAPIBlockstore(lapi)
-	store := adt.WrapStore(ctx, cbor.NewCborStore(bs))
-
-	nd, err := adt.AsMap(store, hroot)
-	if err != nil {
-		return nil, err
-	}
-
-	txs := make(map[int64]*msig0.Transaction)
-	var tx msig0.Transaction
-	err = nd.ForEach(&tx, func(k string) error {
-		txid, _ := binary.Varint([]byte(k))
-
-		cpy := tx // copy so we don't clobber on future iterations.
-		txs[txid] = &cpy
-		return nil
-	})
-	if err != nil {
-		return nil, xerrors.Errorf("failed to iterate transactions hamt: %w", err)
-	}
-
-	return txs, nil
-}
-
-func state(tx *msig0.Transaction) string {
-	/* // TODO(why): I strongly disagree with not having these... but i need to move forward
-	if tx.Complete {
-		return "done"
-	}
-	if tx.Canceled {
-		return "canceled"
-	}
-	*/
-	return "pending"
-}
-
 var msigProposeCmd = &cli.Command{
 	Name:      "propose",
 	Usage:     "Propose a multisig transaction",
@@ -365,7 +356,7 @@ var msigProposeCmd = &cli.Command{
 			return fmt.Errorf("failed to look up multisig %s: %w", msig, err)
 		}
 
-		if act.Code != builtin.MultisigActorCodeID {
+		if !act.IsMultisigActor() {
 			return fmt.Errorf("actor %s is not a multisig actor", msig)
 		}
 
@@ -971,6 +962,282 @@ var msigSwapCancelCmd = &cli.Command{
 	},
 }
 
+var msigLockProposeCmd = &cli.Command{
+	Name:      "lock-propose",
+	Usage:     "Propose to lock up some balance",
+	ArgsUsage: "[multisigAddress startEpoch unlockDuration amount]",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:  "from",
+			Usage: "account to send the propose message from",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		if cctx.Args().Len() != 4 {
+			return ShowHelp(cctx, fmt.Errorf("must pass multisig address, start epoch, unlock duration, and amount"))
+		}
+
+		api, closer, err := GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+		ctx := ReqContext(cctx)
+
+		msig, err := address.NewFromString(cctx.Args().Get(0))
+		if err != nil {
+			return err
+		}
+
+		start, err := strconv.ParseUint(cctx.Args().Get(1), 10, 64)
+		if err != nil {
+			return err
+		}
+
+		duration, err := strconv.ParseUint(cctx.Args().Get(2), 10, 64)
+		if err != nil {
+			return err
+		}
+
+		amount, err := types.ParseFIL(cctx.Args().Get(3))
+		if err != nil {
+			return err
+		}
+
+		var from address.Address
+		if cctx.IsSet("from") {
+			f, err := address.NewFromString(cctx.String("from"))
+			if err != nil {
+				return err
+			}
+			from = f
+		} else {
+			defaddr, err := api.WalletDefaultAddress(ctx)
+			if err != nil {
+				return err
+			}
+			from = defaddr
+		}
+
+		params, actErr := actors.SerializeParams(&msig0.LockBalanceParams{
+			StartEpoch:     abi.ChainEpoch(start),
+			UnlockDuration: abi.ChainEpoch(duration),
+			Amount:         abi.NewTokenAmount(amount.Int64()),
+		})
+
+		if actErr != nil {
+			return actErr
+		}
+
+		msgCid, err := api.MsigPropose(ctx, msig, msig, big.Zero(), from, uint64(builtin.MethodsMultisig.LockBalance), params)
+		if err != nil {
+			return err
+		}
+
+		fmt.Println("sent lock proposal in message: ", msgCid)
+
+		wait, err := api.StateWaitMsg(ctx, msgCid, build.MessageConfidence)
+		if err != nil {
+			return err
+		}
+
+		if wait.Receipt.ExitCode != 0 {
+			return fmt.Errorf("lock proposal returned exit %d", wait.Receipt.ExitCode)
+		}
+
+		return nil
+	},
+}
+
+var msigLockApproveCmd = &cli.Command{
+	Name:      "lock-approve",
+	Usage:     "Approve a message to lock up some balance",
+	ArgsUsage: "[multisigAddress proposerAddress txId startEpoch unlockDuration amount]",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:  "from",
+			Usage: "account to send the approve message from",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		if cctx.Args().Len() != 6 {
+			return ShowHelp(cctx, fmt.Errorf("must pass multisig address, proposer address, tx id, start epoch, unlock duration, and amount"))
+		}
+
+		api, closer, err := GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+		ctx := ReqContext(cctx)
+
+		msig, err := address.NewFromString(cctx.Args().Get(0))
+		if err != nil {
+			return err
+		}
+
+		prop, err := address.NewFromString(cctx.Args().Get(1))
+		if err != nil {
+			return err
+		}
+
+		txid, err := strconv.ParseUint(cctx.Args().Get(2), 10, 64)
+		if err != nil {
+			return err
+		}
+
+		start, err := strconv.ParseUint(cctx.Args().Get(3), 10, 64)
+		if err != nil {
+			return err
+		}
+
+		duration, err := strconv.ParseUint(cctx.Args().Get(4), 10, 64)
+		if err != nil {
+			return err
+		}
+
+		amount, err := types.ParseFIL(cctx.Args().Get(5))
+		if err != nil {
+			return err
+		}
+
+		var from address.Address
+		if cctx.IsSet("from") {
+			f, err := address.NewFromString(cctx.String("from"))
+			if err != nil {
+				return err
+			}
+			from = f
+		} else {
+			defaddr, err := api.WalletDefaultAddress(ctx)
+			if err != nil {
+				return err
+			}
+			from = defaddr
+		}
+
+		params, actErr := actors.SerializeParams(&msig0.LockBalanceParams{
+			StartEpoch:     abi.ChainEpoch(start),
+			UnlockDuration: abi.ChainEpoch(duration),
+			Amount:         abi.NewTokenAmount(amount.Int64()),
+		})
+
+		if actErr != nil {
+			return actErr
+		}
+
+		msgCid, err := api.MsigApprove(ctx, msig, txid, prop, msig, big.Zero(), from, uint64(builtin.MethodsMultisig.LockBalance), params)
+		if err != nil {
+			return err
+		}
+
+		fmt.Println("sent lock approval in message: ", msgCid)
+
+		wait, err := api.StateWaitMsg(ctx, msgCid, build.MessageConfidence)
+		if err != nil {
+			return err
+		}
+
+		if wait.Receipt.ExitCode != 0 {
+			return fmt.Errorf("lock approval returned exit %d", wait.Receipt.ExitCode)
+		}
+
+		return nil
+	},
+}
+
+var msigLockCancelCmd = &cli.Command{
+	Name:      "lock-cancel",
+	Usage:     "Cancel a message to lock up some balance",
+	ArgsUsage: "[multisigAddress txId startEpoch unlockDuration amount]",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:  "from",
+			Usage: "account to send the cancel message from",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		if cctx.Args().Len() != 6 {
+			return ShowHelp(cctx, fmt.Errorf("must pass multisig address, tx id, start epoch, unlock duration, and amount"))
+		}
+
+		api, closer, err := GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+		ctx := ReqContext(cctx)
+
+		msig, err := address.NewFromString(cctx.Args().Get(0))
+		if err != nil {
+			return err
+		}
+
+		txid, err := strconv.ParseUint(cctx.Args().Get(1), 10, 64)
+		if err != nil {
+			return err
+		}
+
+		start, err := strconv.ParseUint(cctx.Args().Get(2), 10, 64)
+		if err != nil {
+			return err
+		}
+
+		duration, err := strconv.ParseUint(cctx.Args().Get(3), 10, 64)
+		if err != nil {
+			return err
+		}
+
+		amount, err := types.ParseFIL(cctx.Args().Get(4))
+		if err != nil {
+			return err
+		}
+
+		var from address.Address
+		if cctx.IsSet("from") {
+			f, err := address.NewFromString(cctx.String("from"))
+			if err != nil {
+				return err
+			}
+			from = f
+		} else {
+			defaddr, err := api.WalletDefaultAddress(ctx)
+			if err != nil {
+				return err
+			}
+			from = defaddr
+		}
+
+		params, actErr := actors.SerializeParams(&msig0.LockBalanceParams{
+			StartEpoch:     abi.ChainEpoch(start),
+			UnlockDuration: abi.ChainEpoch(duration),
+			Amount:         abi.NewTokenAmount(amount.Int64()),
+		})
+
+		if actErr != nil {
+			return actErr
+		}
+
+		msgCid, err := api.MsigCancel(ctx, msig, txid, msig, big.Zero(), from, uint64(builtin.MethodsMultisig.LockBalance), params)
+		if err != nil {
+			return err
+		}
+
+		fmt.Println("sent lock cancellation in message: ", msgCid)
+
+		wait, err := api.StateWaitMsg(ctx, msgCid, build.MessageConfidence)
+		if err != nil {
+			return err
+		}
+
+		if wait.Receipt.ExitCode != 0 {
+			return fmt.Errorf("lock cancellation returned exit %d", wait.Receipt.ExitCode)
+		}
+
+		return nil
+	},
+}
+
 var msigVestedCmd = &cli.Command{
 	Name:      "vested",
 	Usage:     "Gets the amount vested in an msig between two epochs",

cli/paych_test.go

@@ -12,39 +12,31 @@ import (
 	"testing"
 	"time"
 
-	"github.com/filecoin-project/lotus/build"
-
-	"github.com/filecoin-project/go-state-types/big"
-	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
-	power0 "github.com/filecoin-project/specs-actors/actors/builtin/power"
-	verifreg0 "github.com/filecoin-project/specs-actors/actors/builtin/verifreg"
-
-	"github.com/multiformats/go-multiaddr"
-
-	"github.com/filecoin-project/lotus/chain/events"
-
-	"github.com/filecoin-project/lotus/api/apibstore"
-	"github.com/filecoin-project/lotus/chain/actors/adt"
-	"github.com/filecoin-project/lotus/chain/actors/builtin/paych"
-	cbor "github.com/ipfs/go-ipld-cbor"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/lotus/chain/types"
-
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/lotus/api/test"
-	"github.com/filecoin-project/lotus/chain/wallet"
-	builder "github.com/filecoin-project/lotus/node/test"
 	"github.com/stretchr/testify/require"
 	"github.com/urfave/cli/v2"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/abi"
+	cbor "github.com/ipfs/go-ipld-cbor"
+	"github.com/multiformats/go-multiaddr"
+
+	"github.com/filecoin-project/lotus/chain/actors/adt"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/paych"
+	"github.com/filecoin-project/lotus/chain/actors/policy"
+
+	"github.com/filecoin-project/lotus/api/apibstore"
+	"github.com/filecoin-project/lotus/api/test"
+	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/events"
+	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/chain/wallet"
+	builder "github.com/filecoin-project/lotus/node/test"
 )
 
 func init() {
-	power0.ConsensusMinerMinPower = big.NewInt(2048)
-	miner0.SupportedProofTypes = map[abi.RegisteredSealProof]struct{}{
-		abi.RegisteredSealProof_StackedDrg2KiBV1: {},
-	}
-	verifreg0.MinVerifiedDealSize = big.NewInt(256)
+	policy.SetSupportedProofTypes(abi.RegisteredSealProof_StackedDrg2KiBV1)
+	policy.SetConsensusMinerMinPower(abi.NewStoragePower(2048))
+	policy.SetMinVerifiedDealSize(abi.NewStoragePower(256))
 }
 
 // TestPaymentChannels does a basic test to exercise the payment channel CLI
@@ -89,7 +81,9 @@ func TestPaymentChannels(t *testing.T) {
 
 	// Wait for the chain to reach the settle height
 	chState := getPaychState(ctx, t, paymentReceiver, chAddr)
-	waitForHeight(ctx, t, paymentReceiver, chState.SettlingAt())
+	sa, err := chState.SettlingAt()
+	require.NoError(t, err)
+	waitForHeight(ctx, t, paymentReceiver, sa)
 
 	// receiver: paych collect <channel>
 	cmd = []string{chAddr.String()}

cli/state.go

@@ -19,6 +19,7 @@ import (
 	"github.com/multiformats/go-multiaddr"
 
 	"github.com/ipfs/go-cid"
+	cbor "github.com/ipfs/go-ipld-cbor"
 	"github.com/libp2p/go-libp2p-core/peer"
 	"github.com/multiformats/go-multihash"
 	"github.com/urfave/cli/v2"
@@ -33,7 +34,9 @@ import (
 	"github.com/filecoin-project/specs-actors/actors/builtin/exported"
 
 	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/api/apibstore"
 	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/state"
 	"github.com/filecoin-project/lotus/chain/stmgr"
 	"github.com/filecoin-project/lotus/chain/types"
 )
@@ -259,13 +262,13 @@ var stateSectorsCmd = &cli.Command{
 			return err
 		}
 
-		sectors, err := api.StateMinerSectors(ctx, maddr, nil, true, ts.Key())
+		sectors, err := api.StateMinerSectors(ctx, maddr, nil, ts.Key())
 		if err != nil {
 			return err
 		}
 
 		for _, s := range sectors {
-			fmt.Printf("%d: %x\n", s.Info.SectorNumber, s.Info.SealedCID)
+			fmt.Printf("%d: %x\n", s.SectorNumber, s.SealedCID)
 		}
 
 		return nil
@@ -305,7 +308,7 @@ var stateActiveSectorsCmd = &cli.Command{
 		}
 
 		for _, s := range sectors {
-			fmt.Printf("%d: %x\n", s.Info.SectorNumber, s.Info.SealedCID)
+			fmt.Printf("%d: %x\n", s.SectorNumber, s.SealedCID)
 		}
 
 		return nil
@@ -834,14 +837,14 @@ var stateComputeStateCmd = &cli.Command{
 		}
 
 		h := abi.ChainEpoch(cctx.Uint64("vm-height"))
-		if h == 0 {
-			if ts == nil {
-				head, err := api.ChainHead(ctx)
-				if err != nil {
-					return err
-				}
-				ts = head
+		if ts == nil {
+			head, err := api.ChainHead(ctx)
+			if err != nil {
+				return err
 			}
+			ts = head
+		}
+		if h == 0 {
 			h = ts.Height()
 		}
 
@@ -863,13 +866,18 @@ var stateComputeStateCmd = &cli.Command{
 		}
 
 		if cctx.Bool("html") {
+			st, err := state.LoadStateTree(cbor.NewCborStore(apibstore.NewAPIBlockstore(api)), stout.Root)
+			if err != nil {
+				return xerrors.Errorf("loading state tree: %w", err)
+			}
+
 			codeCache := map[address.Address]cid.Cid{}
 			getCode := func(addr address.Address) (cid.Cid, error) {
 				if c, found := codeCache[addr]; found {
 					return c, nil
 				}
 
-				c, err := api.StateGetActor(ctx, addr, ts.Key())
+				c, err := st.GetActor(addr)
 				if err != nil {
 					return cid.Cid{}, err
 				}

cli/sync.go

@@ -225,6 +225,16 @@ var syncCheckpointCmd = &cli.Command{
 }
 
 func SyncWait(ctx context.Context, napi api.FullNode) error {
+	tick := time.Second / 4
+
+	lastLines := 0
+	ticker := time.NewTicker(tick)
+	defer ticker.Stop()
+
+	samples := 8
+	i := 0
+	var app, lastApp uint64
+
 	for {
 		state, err := napi.SyncState(ctx)
 		if err != nil {
@@ -249,14 +259,41 @@ func SyncWait(ctx context.Context, napi api.FullNode) error {
 
 		ss := state.ActiveSyncs[working]
 
+		var baseHeight abi.ChainEpoch
 		var target []cid.Cid
 		var theight abi.ChainEpoch
+		var heightDiff int64
+
+		if ss.Base != nil {
+			baseHeight = ss.Base.Height()
+			heightDiff = int64(ss.Base.Height())
+		}
 		if ss.Target != nil {
 			target = ss.Target.Cids()
 			theight = ss.Target.Height()
+			heightDiff = int64(ss.Target.Height()) - heightDiff
+		} else {
+			heightDiff = 0
 		}
 
-		fmt.Printf("\r\x1b[2KWorker %d: Target Height: %d\tTarget: %s\tState: %s\tHeight: %d", working, theight, target, ss.Stage, ss.Height)
+		for i := 0; i < lastLines; i++ {
+			fmt.Print("\r\x1b[2K\x1b[A")
+		}
+
+		fmt.Printf("Worker: %d; Base: %d; Target: %d (diff: %d)\n", working, baseHeight, theight, heightDiff)
+		fmt.Printf("State: %s; Current Epoch: %d; Todo: %d\n", ss.Stage, ss.Height, theight-ss.Height)
+		lastLines = 2
+
+		if i%samples == 0 {
+			lastApp = app
+			app = state.VMApplied
+		}
+		if i > 0 {
+			fmt.Printf("Validated %d messages (%d per second)\n", state.VMApplied, (app-lastApp)*uint64(time.Second/tick)/uint64(samples))
+			lastLines++
+		}
+
+		_ = target // todo: maybe print? (creates a bunch of line wrapping issues with most tipsets)
 
 		if time.Now().Unix()-int64(head.MinTimestamp()) < int64(build.BlockDelaySecs) {
 			fmt.Println("\nDone!")
@@ -267,7 +304,9 @@ func SyncWait(ctx context.Context, napi api.FullNode) error {
 		case <-ctx.Done():
 			fmt.Println("\nExit by user")
 			return nil
-		case <-build.Clock.After(1 * time.Second):
+		case <-ticker.C:
 		}
+
+		i++
 	}
 }

cmd/lotus-bench/main.go

@@ -27,11 +27,11 @@ import (
 	"github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper"
 	"github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper/basicfs"
 	"github.com/filecoin-project/lotus/extern/sector-storage/stores"
-	"github.com/filecoin-project/specs-actors/actors/builtin/miner"
 	"github.com/filecoin-project/specs-storage/storage"
 
 	lapi "github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/actors/policy"
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/genesis"
 )
@@ -76,7 +76,7 @@ func main() {
 
 	log.Info("Starting lotus-bench")
 
-	miner.SupportedProofTypes[abi.RegisteredSealProof_StackedDrg2KiBV1] = struct{}{}
+	policy.AddSupportedProofTypes(abi.RegisteredSealProof_StackedDrg2KiBV1)
 
 	app := &cli.App{
 		Name:    "lotus-bench",

cmd/lotus-chainwatch/processor/miner.go

@@ -684,7 +684,11 @@ func (p *Processor) diffMinerPartitions(ctx context.Context, m minerActorInfo, e
 		return err
 	}
 	curMiner := m.state
-	if !prevMiner.DeadlinesChanged(curMiner) {
+	dc, err := prevMiner.DeadlinesChanged(curMiner)
+	if err != nil {
+		return err
+	}
+	if !dc {
 		return nil
 	}
 	panic("TODO")

cmd/lotus-pcr/main.go

@@ -12,10 +12,10 @@ import (
 	"strconv"
 	"time"
 
+	"github.com/filecoin-project/specs-actors/actors/builtin"
 	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
 
 	"github.com/filecoin-project/go-state-types/network"
-	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
 
 	"github.com/ipfs/go-cid"
 	logging "github.com/ipfs/go-log/v2"
@@ -28,11 +28,11 @@ import (
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/big"
 	"github.com/filecoin-project/go-state-types/exitcode"
-	"github.com/filecoin-project/specs-actors/actors/builtin"
 
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/tools/stats"
 )
@@ -375,7 +375,7 @@ func (r *refunder) ProcessTipset(ctx context.Context, tipset *types.TipSet, refu
 			continue
 		}
 
-		if a.Code != builtin.StorageMinerActorCodeID {
+		if !a.IsStorageMinerActor() {
 			continue
 		}
 
@@ -396,24 +396,13 @@ func (r *refunder) ProcessTipset(ctx context.Context, tipset *types.TipSet, refu
 
 			var sn abi.SectorNumber
 
-			nv, err := r.api.StateNetworkVersion(ctx, tipset.Key())
-			if err != nil {
-				log.Warnw("failed to get network version")
+			var proveCommitSector miner0.ProveCommitSectorParams
+			if err := proveCommitSector.UnmarshalCBOR(bytes.NewBuffer(m.Params)); err != nil {
+				log.Warnw("failed to decode provecommit params", "err", err, "method", messageMethod, "cid", msg.Cid, "miner", m.To)
 				continue
 			}
 
-			if nv < build.ActorUpgradeNetworkVersion {
-				var proveCommitSector miner0.ProveCommitSectorParams
-				if err := proveCommitSector.UnmarshalCBOR(bytes.NewBuffer(m.Params)); err != nil {
-					log.Warnw("failed to decode provecommit params", "err", err, "method", messageMethod, "cid", msg.Cid, "miner", m.To)
-					continue
-				}
-
-				sn = proveCommitSector.SectorNumber
-			} else {
-				// TODO: ActorUpgrade
-				sn = 0
-			}
+			sn = proveCommitSector.SectorNumber
 
 			// We use the parent tipset key because precommit information is removed when ProveCommitSector is executed
 			precommitChainInfo, err := r.api.StateSectorPreCommitInfo(ctx, m.To, sn, tipset.Parents())

cmd/lotus-shed/balances.go

@@ -3,15 +3,24 @@ package main
 import (
 	"context"
 	"fmt"
+	"strconv"
+
+	"github.com/docker/go-units"
+	lotusbuiltin "github.com/filecoin-project/lotus/chain/actors/builtin"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/power"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/reward"
 
 	"github.com/ipfs/go-cid"
 	cbor "github.com/ipfs/go-ipld-cbor"
+	logging "github.com/ipfs/go-log/v2"
 	"github.com/urfave/cli/v2"
 	"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/big"
+	"github.com/filecoin-project/lotus/chain/actors/adt"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
 	"github.com/filecoin-project/lotus/chain/state"
 	"github.com/filecoin-project/lotus/chain/stmgr"
 	"github.com/filecoin-project/lotus/chain/store"
@@ -21,9 +30,6 @@ import (
 	"github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper"
 	"github.com/filecoin-project/lotus/lib/blockstore"
 	"github.com/filecoin-project/lotus/node/repo"
-	"github.com/filecoin-project/specs-actors/actors/builtin"
-	"github.com/filecoin-project/specs-actors/actors/builtin/miner"
-	"github.com/filecoin-project/specs-actors/actors/util/adt"
 )
 
 type accountInfo struct {
@@ -45,6 +51,7 @@ var auditsCmd = &cli.Command{
 	Subcommands: []*cli.Command{
 		chainBalanceCmd,
 		chainBalanceStateCmd,
+		chainPledgeCmd,
 	},
 }
 
@@ -90,7 +97,7 @@ var chainBalanceCmd = &cli.Command{
 				Type:    string(act.Code.Hash()[2:]),
 			}
 
-			if act.Code == builtin.StorageMinerActorCodeID {
+			if act.IsStorageMinerActor() {
 				pow, err := api.StateMinerPower(ctx, addr, tsk)
 				if err != nil {
 					return xerrors.Errorf("failed to get power: %w", err)
@@ -167,10 +174,10 @@ var chainBalanceStateCmd = &cli.Command{
 		cs := store.NewChainStore(bs, mds, vm.Syscalls(ffiwrapper.ProofVerifier))
 
 		cst := cbor.NewCborStore(bs)
+		store := adt.WrapStore(ctx, cst)
 
 		sm := stmgr.NewStateManager(cs)
 
-		// Options: (a) encode the version in the chain or (b) pass a flag.
 		tree, err := state.LoadStateTree(cst, sroot)
 		if err != nil {
 			return err
@@ -191,7 +198,7 @@ var chainBalanceStateCmd = &cli.Command{
 				PreCommits:    types.FIL(big.NewInt(0)),
 			}
 
-			if act.Code == builtin.StorageMinerActorCodeID && minerInfo {
+			if minerInfo && act.IsStorageMinerActor() {
 				pow, _, _, err := stmgr.GetPowerRaw(ctx, sm, sroot, addr)
 				if err != nil {
 					return xerrors.Errorf("failed to get power: %w", err)
@@ -199,24 +206,29 @@ var chainBalanceStateCmd = &cli.Command{
 
 				ai.Power = pow.RawBytePower
 
-				var st miner.State
-				if err := cst.Get(ctx, act.Head, &st); err != nil {
+				st, err := miner.Load(store, act)
+				if err != nil {
 					return xerrors.Errorf("failed to read miner state: %w", err)
 				}
 
-				sectors, err := adt.AsArray(cs.Store(ctx), st.Sectors)
+				liveSectorCount, err := st.NumLiveSectors()
 				if err != nil {
-					return xerrors.Errorf("failed to load sector set: %w", err)
+					return xerrors.Errorf("failed to compute live sector count: %w", err)
 				}
 
-				ai.InitialPledge = types.FIL(st.InitialPledgeRequirement)
-				ai.LockedFunds = types.FIL(st.LockedFunds)
-				ai.PreCommits = types.FIL(st.PreCommitDeposits)
-				ai.Sectors = sectors.Length()
+				lockedFunds, err := st.LockedFunds()
+				if err != nil {
+					return xerrors.Errorf("failed to compute locked funds: %w", err)
+				}
 
-				var minfo miner.MinerInfo
-				if err := cst.Get(ctx, st.Info, &minfo); err != nil {
-					return xerrors.Errorf("failed to read miner info: %w", err)
+				ai.InitialPledge = types.FIL(lockedFunds.InitialPledgeRequirement)
+				ai.LockedFunds = types.FIL(lockedFunds.VestingFunds)
+				ai.PreCommits = types.FIL(lockedFunds.PreCommitDeposits)
+				ai.Sectors = liveSectorCount
+
+				minfo, err := st.Info()
+				if err != nil {
+					return xerrors.Errorf("failed to get miner info: %w", err)
 				}
 
 				ai.Worker = minfo.Worker
@@ -244,3 +256,133 @@ var chainBalanceStateCmd = &cli.Command{
 		return nil
 	},
 }
+
+var chainPledgeCmd = &cli.Command{
+	Name:        "stateroot-pledge",
+	Description: "Calculate sector pledge numbers",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:  "repo",
+			Value: "~/.lotus",
+		},
+	},
+	ArgsUsage: "[stateroot epoch]",
+	Action: func(cctx *cli.Context) error {
+		logging.SetLogLevel("badger", "ERROR")
+		ctx := context.TODO()
+
+		if !cctx.Args().Present() {
+			return fmt.Errorf("must pass state root")
+		}
+
+		sroot, err := cid.Decode(cctx.Args().First())
+		if err != nil {
+			return fmt.Errorf("failed to parse input: %w", err)
+		}
+
+		epoch, err := strconv.ParseInt(cctx.Args().Get(1), 10, 64)
+		if err != nil {
+			return xerrors.Errorf("parsing epoch arg: %w", err)
+		}
+
+		fsrepo, err := repo.NewFS(cctx.String("repo"))
+		if err != nil {
+			return err
+		}
+
+		lkrepo, err := fsrepo.Lock(repo.FullNode)
+		if err != nil {
+			return err
+		}
+
+		defer lkrepo.Close() //nolint:errcheck
+
+		ds, err := lkrepo.Datastore("/chain")
+		if err != nil {
+			return err
+		}
+
+		mds, err := lkrepo.Datastore("/metadata")
+		if err != nil {
+			return err
+		}
+
+		bs := blockstore.NewBlockstore(ds)
+
+		cs := store.NewChainStore(bs, mds, vm.Syscalls(ffiwrapper.ProofVerifier))
+
+		cst := cbor.NewCborStore(bs)
+		store := adt.WrapStore(ctx, cst)
+
+		sm := stmgr.NewStateManager(cs)
+
+		state, err := state.LoadStateTree(cst, sroot)
+		if err != nil {
+			return err
+		}
+
+		var (
+			powerSmoothed    lotusbuiltin.FilterEstimate
+			pledgeCollateral abi.TokenAmount
+		)
+		if act, err := state.GetActor(power.Address); err != nil {
+			return xerrors.Errorf("loading miner actor: %w", err)
+		} else if s, err := power.Load(store, act); err != nil {
+			return xerrors.Errorf("loading power actor state: %w", err)
+		} else if p, err := s.TotalPowerSmoothed(); err != nil {
+			return xerrors.Errorf("failed to determine total power: %w", err)
+		} else if c, err := s.TotalLocked(); err != nil {
+			return xerrors.Errorf("failed to determine pledge collateral: %w", err)
+		} else {
+			powerSmoothed = p
+			pledgeCollateral = c
+		}
+
+		circ, err := sm.GetCirculatingSupplyDetailed(ctx, abi.ChainEpoch(epoch), state)
+		if err != nil {
+			return err
+		}
+
+		fmt.Println("(real) circulating supply: ", types.FIL(circ.FilCirculating))
+		if circ.FilCirculating.LessThan(big.Zero()) {
+			circ.FilCirculating = big.Zero()
+		}
+
+		rewardActor, err := state.GetActor(reward.Address)
+		if err != nil {
+			return xerrors.Errorf("loading miner actor: %w", err)
+		}
+
+		rewardState, err := reward.Load(store, rewardActor)
+		if err != nil {
+			return xerrors.Errorf("loading reward actor state: %w", err)
+		}
+
+		fmt.Println("FilVested", types.FIL(circ.FilVested))
+		fmt.Println("FilMined", types.FIL(circ.FilMined))
+		fmt.Println("FilBurnt", types.FIL(circ.FilBurnt))
+		fmt.Println("FilLocked", types.FIL(circ.FilLocked))
+		fmt.Println("FilCirculating", types.FIL(circ.FilCirculating))
+
+		for _, sectorWeight := range []abi.StoragePower{
+			types.NewInt(32 << 30),
+			types.NewInt(64 << 30),
+			types.NewInt(32 << 30 * 10),
+			types.NewInt(64 << 30 * 10),
+		} {
+			initialPledge, err := rewardState.InitialPledgeForPower(
+				sectorWeight,
+				pledgeCollateral,
+				&powerSmoothed,
+				circ.FilCirculating,
+			)
+			if err != nil {
+				return xerrors.Errorf("calculating initial pledge: %w", err)
+			}
+
+			fmt.Println("IP ", units.HumanSize(float64(sectorWeight.Uint64())), types.FIL(initialPledge))
+		}
+
+		return nil
+	},
+}

cmd/lotus-shed/consensus.go

@@ -0,0 +1,286 @@
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"io"
+	"os"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/api/client"
+	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/types"
+	lcli "github.com/filecoin-project/lotus/cli"
+	"github.com/libp2p/go-libp2p-core/peer"
+	"github.com/multiformats/go-multiaddr"
+	"github.com/urfave/cli/v2"
+)
+
+var consensusCmd = &cli.Command{
+	Name:  "consensus",
+	Usage: "tools for gathering information about consensus between nodes",
+	Flags: []cli.Flag{},
+	Subcommands: []*cli.Command{
+		consensusCheckCmd,
+	},
+}
+
+type consensusItem struct {
+	multiaddr     multiaddr.Multiaddr
+	genesisTipset *types.TipSet
+	targetTipset  *types.TipSet
+	headTipset    *types.TipSet
+	peerID        peer.ID
+	version       api.Version
+	api           api.FullNode
+}
+
+var consensusCheckCmd = &cli.Command{
+	Name:  "check",
+	Usage: "verify if all nodes agree upon a common tipset for a given tipset height",
+	Description: `Consensus check verifies that all nodes share a common tipset for a given
+   height.
+
+   The height flag specifies a chain height to start a comparison from. There are two special
+   arguments for this flag. All other expected values should be chain tipset heights.
+
+   @common   - Use the maximum common chain height between all nodes
+   @expected - Use the current time and the genesis timestamp to determine a height
+
+   Examples
+
+   Find the highest common tipset and look back 10 tipsets
+   lotus-shed consensus check --height @common --lookback 10
+
+   Calculate the expected tipset height and look back 10 tipsets
+   lotus-shed consensus check --height @expected --lookback 10
+
+   Check if nodes all share a common genesis
+   lotus-shed consensus check --height 0
+
+   Check that all nodes agree upon the tipset for 1day post genesis
+   lotus-shed consensus check --height 2880 --lookback 0
+	`,
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:  "height",
+			Value: "@common",
+			Usage: "height of tipset to start check from",
+		},
+		&cli.IntFlag{
+			Name:  "lookback",
+			Value: int(build.MessageConfidence * 2),
+			Usage: "number of tipsets behind to look back when comparing nodes",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		filePath := cctx.Args().First()
+
+		var input *bufio.Reader
+		if cctx.Args().Len() == 0 {
+			input = bufio.NewReader(os.Stdin)
+		} else {
+			var err error
+			inputFile, err := os.Open(filePath)
+			if err != nil {
+				return err
+			}
+			defer inputFile.Close() //nolint:errcheck
+			input = bufio.NewReader(inputFile)
+		}
+
+		var nodes []*consensusItem
+		ctx := lcli.ReqContext(cctx)
+
+		for {
+			strma, errR := input.ReadString('\n')
+			strma = strings.TrimSpace(strma)
+
+			if len(strma) == 0 {
+				if errR == io.EOF {
+					break
+				}
+				continue
+			}
+
+			apima, err := multiaddr.NewMultiaddr(strma)
+			if err != nil {
+				return err
+			}
+			ainfo := lcli.APIInfo{Addr: apima}
+			addr, err := ainfo.DialArgs()
+			if err != nil {
+				return err
+			}
+
+			api, closer, err := client.NewFullNodeRPC(cctx.Context, addr, nil)
+			if err != nil {
+				return err
+			}
+			defer closer()
+
+			peerID, err := api.ID(ctx)
+			if err != nil {
+				return err
+			}
+
+			version, err := api.Version(ctx)
+			if err != nil {
+				return err
+			}
+
+			genesisTipset, err := api.ChainGetGenesis(ctx)
+			if err != nil {
+				return err
+			}
+
+			headTipset, err := api.ChainHead(ctx)
+			if err != nil {
+				return err
+			}
+
+			nodes = append(nodes, &consensusItem{
+				genesisTipset: genesisTipset,
+				headTipset:    headTipset,
+				multiaddr:     apima,
+				api:           api,
+				peerID:        peerID,
+				version:       version,
+			})
+
+			if errR != nil && errR != io.EOF {
+				return err
+			}
+
+			if errR == io.EOF {
+				break
+			}
+		}
+
+		if len(nodes) == 0 {
+			return fmt.Errorf("no nodes")
+		}
+
+		genesisBuckets := make(map[types.TipSetKey][]*consensusItem)
+		for _, node := range nodes {
+			genesisBuckets[node.genesisTipset.Key()] = append(genesisBuckets[node.genesisTipset.Key()], node)
+
+		}
+
+		if len(genesisBuckets) != 1 {
+			for _, nodes := range genesisBuckets {
+				for _, node := range nodes {
+					log.Errorw(
+						"genesis do not match",
+						"genesis_tipset", node.genesisTipset.Key(),
+						"peer_id", node.peerID,
+						"version", node.version,
+					)
+				}
+			}
+
+			return fmt.Errorf("genesis does not match between all nodes")
+		}
+
+		target := abi.ChainEpoch(0)
+
+		switch cctx.String("height") {
+		case "@common":
+			minTipset := nodes[0].headTipset
+			for _, node := range nodes {
+				if node.headTipset.Height() < minTipset.Height() {
+					minTipset = node.headTipset
+				}
+			}
+
+			target = minTipset.Height()
+		case "@expected":
+			tnow := uint64(time.Now().Unix())
+			tgen := nodes[0].genesisTipset.MinTimestamp()
+
+			target = abi.ChainEpoch((tnow - tgen) / build.BlockDelaySecs)
+		default:
+			h, err := strconv.Atoi(strings.TrimSpace(cctx.String("height")))
+			if err != nil {
+				return fmt.Errorf("failed to parse string: %s", cctx.String("height"))
+			}
+
+			target = abi.ChainEpoch(h)
+		}
+
+		lookback := abi.ChainEpoch(cctx.Int("lookback"))
+		if lookback > target {
+			target = abi.ChainEpoch(0)
+		} else {
+			target = target - lookback
+		}
+
+		for _, node := range nodes {
+			targetTipset, err := node.api.ChainGetTipSetByHeight(ctx, target, types.EmptyTSK)
+			if err != nil {
+				log.Errorw("error checking target", "err", err)
+				node.targetTipset = nil
+			} else {
+				node.targetTipset = targetTipset
+			}
+
+		}
+		for _, node := range nodes {
+			log.Debugw(
+				"node info",
+				"peer_id", node.peerID,
+				"version", node.version,
+				"genesis_tipset", node.genesisTipset.Key(),
+				"head_tipset", node.headTipset.Key(),
+				"target_tipset", node.targetTipset.Key(),
+			)
+		}
+
+		targetBuckets := make(map[types.TipSetKey][]*consensusItem)
+		for _, node := range nodes {
+			if node.targetTipset == nil {
+				targetBuckets[types.EmptyTSK] = append(targetBuckets[types.EmptyTSK], node)
+				continue
+			}
+
+			targetBuckets[node.targetTipset.Key()] = append(targetBuckets[node.targetTipset.Key()], node)
+		}
+
+		if nodes, ok := targetBuckets[types.EmptyTSK]; ok {
+			for _, node := range nodes {
+				log.Errorw(
+					"targeted tipset not found",
+					"peer_id", node.peerID,
+					"version", node.version,
+					"genesis_tipset", node.genesisTipset.Key(),
+					"head_tipset", node.headTipset.Key(),
+					"target_tipset", node.targetTipset.Key(),
+				)
+			}
+
+			return fmt.Errorf("targeted tipset not found")
+		}
+
+		if len(targetBuckets) != 1 {
+			for _, nodes := range targetBuckets {
+				for _, node := range nodes {
+					log.Errorw(
+						"targeted tipset not found",
+						"peer_id", node.peerID,
+						"version", node.version,
+						"genesis_tipset", node.genesisTipset.Key(),
+						"head_tipset", node.headTipset.Key(),
+						"target_tipset", node.targetTipset.Key(),
+					)
+				}
+			}
+			return fmt.Errorf("nodes not in consensus at tipset height %d", target)
+		}
+
+		return nil
+	},
+}

cmd/lotus-shed/dealtracker.go

@@ -0,0 +1,265 @@
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"net"
+	"net/http"
+	"os"
+	"strings"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/lotus/api"
+	lcli "github.com/filecoin-project/lotus/cli"
+	"github.com/ipfs/go-cid"
+	"github.com/urfave/cli/v2"
+)
+
+type dealStatsServer struct {
+	api api.FullNode
+}
+
+var filteredClients map[address.Address]bool
+
+func init() {
+	fc := []string{"t0112", "t0113", "t0114", "t010089"}
+
+	filtered, set := os.LookupEnv("FILTERED_CLIENTS")
+	if set {
+		fc = strings.Split(filtered, ":")
+	}
+
+	filteredClients = make(map[address.Address]bool)
+	for _, a := range fc {
+		addr, err := address.NewFromString(a)
+		if err != nil {
+			panic(err)
+		}
+		filteredClients[addr] = true
+	}
+}
+
+type dealCountResp struct {
+	Total int64 `json:"total"`
+	Epoch int64 `json:"epoch"`
+}
+
+func (dss *dealStatsServer) handleStorageDealCount(w http.ResponseWriter, r *http.Request) {
+	ctx := context.Background()
+
+	head, err := dss.api.ChainHead(ctx)
+	if err != nil {
+		log.Warnf("failed to get chain head: %s", err)
+		w.WriteHeader(500)
+		return
+	}
+
+	deals, err := dss.api.StateMarketDeals(ctx, head.Key())
+	if err != nil {
+		log.Warnf("failed to get market deals: %s", err)
+		w.WriteHeader(500)
+		return
+	}
+
+	var count int64
+	for _, d := range deals {
+		if !filteredClients[d.Proposal.Client] {
+			count++
+		}
+	}
+
+	if err := json.NewEncoder(w).Encode(&dealCountResp{
+		Total: count,
+		Epoch: int64(head.Height()),
+	}); err != nil {
+		log.Warnf("failed to write back deal count response: %s", err)
+		return
+	}
+}
+
+type dealAverageResp struct {
+	AverageSize int64 `json:"average_size"`
+	Epoch       int64 `json:"epoch"`
+}
+
+func (dss *dealStatsServer) handleStorageDealAverageSize(w http.ResponseWriter, r *http.Request) {
+	ctx := context.Background()
+
+	head, err := dss.api.ChainHead(ctx)
+	if err != nil {
+		log.Warnf("failed to get chain head: %s", err)
+		w.WriteHeader(500)
+		return
+	}
+
+	deals, err := dss.api.StateMarketDeals(ctx, head.Key())
+	if err != nil {
+		log.Warnf("failed to get market deals: %s", err)
+		w.WriteHeader(500)
+		return
+	}
+
+	var count int64
+	var totalBytes int64
+	for _, d := range deals {
+		if !filteredClients[d.Proposal.Client] {
+			count++
+			totalBytes += int64(d.Proposal.PieceSize.Unpadded())
+		}
+	}
+
+	if err := json.NewEncoder(w).Encode(&dealAverageResp{
+		AverageSize: totalBytes / count,
+		Epoch:       int64(head.Height()),
+	}); err != nil {
+		log.Warnf("failed to write back deal average response: %s", err)
+		return
+	}
+}
+
+type dealTotalResp struct {
+	TotalBytes int64 `json:"total_size"`
+	Epoch      int64 `json:"epoch"`
+}
+
+func (dss *dealStatsServer) handleStorageDealTotalReal(w http.ResponseWriter, r *http.Request) {
+	ctx := context.Background()
+
+	head, err := dss.api.ChainHead(ctx)
+	if err != nil {
+		log.Warnf("failed to get chain head: %s", err)
+		w.WriteHeader(500)
+		return
+	}
+
+	deals, err := dss.api.StateMarketDeals(ctx, head.Key())
+	if err != nil {
+		log.Warnf("failed to get market deals: %s", err)
+		w.WriteHeader(500)
+		return
+	}
+
+	var totalBytes int64
+	for _, d := range deals {
+		if !filteredClients[d.Proposal.Client] {
+			totalBytes += int64(d.Proposal.PieceSize.Unpadded())
+		}
+	}
+
+	if err := json.NewEncoder(w).Encode(&dealTotalResp{
+		TotalBytes: totalBytes,
+		Epoch:      int64(head.Height()),
+	}); err != nil {
+		log.Warnf("failed to write back deal average response: %s", err)
+		return
+	}
+
+}
+
+type clientStatsOutput struct {
+	Client    address.Address `json:"client"`
+	DataSize  int64           `json:"data_size"`
+	NumCids   int             `json:"num_cids"`
+	NumDeals  int             `json:"num_deals"`
+	NumMiners int             `json:"num_miners"`
+
+	cids      map[cid.Cid]bool
+	providers map[address.Address]bool
+}
+
+func (dss *dealStatsServer) handleStorageClientStats(w http.ResponseWriter, r *http.Request) {
+	ctx := context.Background()
+
+	head, err := dss.api.ChainHead(ctx)
+	if err != nil {
+		log.Warnf("failed to get chain head: %s", err)
+		w.WriteHeader(500)
+		return
+	}
+
+	deals, err := dss.api.StateMarketDeals(ctx, head.Key())
+	if err != nil {
+		log.Warnf("failed to get market deals: %s", err)
+		w.WriteHeader(500)
+		return
+	}
+
+	stats := make(map[address.Address]*clientStatsOutput)
+
+	for _, d := range deals {
+		if filteredClients[d.Proposal.Client] {
+			continue
+		}
+
+		st, ok := stats[d.Proposal.Client]
+		if !ok {
+			st = &clientStatsOutput{
+				Client:    d.Proposal.Client,
+				cids:      make(map[cid.Cid]bool),
+				providers: make(map[address.Address]bool),
+			}
+			stats[d.Proposal.Client] = st
+		}
+
+		st.DataSize += int64(d.Proposal.PieceSize.Unpadded())
+		st.cids[d.Proposal.PieceCID] = true
+		st.providers[d.Proposal.Provider] = true
+		st.NumDeals++
+	}
+
+	out := make([]*clientStatsOutput, 0, len(stats))
+	for _, cso := range stats {
+		cso.NumCids = len(cso.cids)
+		cso.NumMiners = len(cso.providers)
+
+		out = append(out, cso)
+	}
+
+	if err := json.NewEncoder(w).Encode(out); err != nil {
+		log.Warnf("failed to write back client stats response: %s", err)
+		return
+	}
+}
+
+var serveDealStatsCmd = &cli.Command{
+	Name:  "serve-deal-stats",
+	Flags: []cli.Flag{},
+	Action: func(cctx *cli.Context) error {
+		api, closer, err := lcli.GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+
+		defer closer()
+		ctx := lcli.ReqContext(cctx)
+
+		_ = ctx
+
+		dss := &dealStatsServer{api}
+
+		mux := &http.ServeMux{}
+		mux.HandleFunc("/api/storagedeal/count", dss.handleStorageDealCount)
+		mux.HandleFunc("/api/storagedeal/averagesize", dss.handleStorageDealAverageSize)
+		mux.HandleFunc("/api/storagedeal/totalreal", dss.handleStorageDealTotalReal)
+		mux.HandleFunc("/api/storagedeal/clientstats", dss.handleStorageClientStats)
+
+		s := &http.Server{
+			Addr:    ":7272",
+			Handler: mux,
+		}
+
+		go func() {
+			<-ctx.Done()
+			if err := s.Shutdown(context.TODO()); err != nil {
+				log.Error(err)
+			}
+		}()
+
+		list, err := net.Listen("tcp", ":7272") // nolint
+		if err != nil {
+			panic(err)
+		}
+
+		return s.Serve(list)
+	},
+}

cmd/lotus-shed/genesis-verify.go

@@ -14,16 +14,17 @@ import (
 
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/big"
+
 	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/actors/adt"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/account"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/multisig"
 	"github.com/filecoin-project/lotus/chain/state"
 	"github.com/filecoin-project/lotus/chain/stmgr"
 	"github.com/filecoin-project/lotus/chain/store"
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/lib/blockstore"
-	"github.com/filecoin-project/specs-actors/actors/builtin"
-	saacc "github.com/filecoin-project/specs-actors/actors/builtin/account"
-	saminer "github.com/filecoin-project/specs-actors/actors/builtin/miner"
-	samsig "github.com/filecoin-project/specs-actors/actors/builtin/multisig"
 )
 
 type addrInfo struct {
@@ -90,36 +91,50 @@ var genesisVerifyCmd = &cli.Command{
 		kminers := make(map[address.Address]minerInfo)
 
 		ctx := context.TODO()
+		store := adt.WrapStore(ctx, cst)
 
 		if err := stree.ForEach(func(addr address.Address, act *types.Actor) error {
-			switch act.Code {
-			case builtin.StorageMinerActorCodeID:
-				var st saminer.State
-				if err := cst.Get(ctx, act.Head, &st); err != nil {
-					return err
+			switch {
+			case act.IsStorageMinerActor():
+				_, err := miner.Load(store, act)
+				if err != nil {
+					return xerrors.Errorf("miner actor: %w", err)
+				}
+				// TODO: actually verify something here?
+				kminers[addr] = minerInfo{}
+			case act.IsMultisigActor():
+				st, err := multisig.Load(store, act)
+				if err != nil {
+					return xerrors.Errorf("multisig actor: %w", err)
 				}
 
-				kminers[addr] = minerInfo{}
-			case builtin.MultisigActorCodeID:
-				var st samsig.State
-				if err := cst.Get(ctx, act.Head, &st); err != nil {
+				signers, err := st.Signers()
+				if err != nil {
+					return xerrors.Errorf("multisig actor: %w", err)
+				}
+				threshold, err := st.Threshold()
+				if err != nil {
 					return xerrors.Errorf("multisig actor: %w", err)
 				}
 
 				kmultisigs[addr] = msigInfo{
 					Balance:   types.FIL(act.Balance),
-					Signers:   st.Signers,
-					Threshold: st.NumApprovalsThreshold,
+					Signers:   signers,
+					Threshold: threshold,
 				}
 				msigAddrs = append(msigAddrs, addr)
-			case builtin.AccountActorCodeID:
-				var st saacc.State
-				if err := cst.Get(ctx, act.Head, &st); err != nil {
-					log.Warn(xerrors.Errorf("account actor %s: %w", addr, err))
+			case act.IsAccountActor():
+				st, err := account.Load(store, act)
+				if err != nil {
+					// TODO: magik6k: this _used_ to log instead of failing, why?
+					return xerrors.Errorf("account actor %s: %w", addr, err)
+				}
+				pkaddr, err := st.PubkeyAddress()
+				if err != nil {
+					return xerrors.Errorf("failed to get actor pk address %s: %w", addr, err)
 				}
-
 				kaccounts[addr] = addrInfo{
-					Key:     st.Address,
+					Key:     pkaddr,
 					Balance: types.FIL(act.Balance.Copy()),
 				}
 				accAddrs = append(accAddrs, addr)

cmd/lotus-shed/main.go

@@ -35,6 +35,8 @@ func main() {
 		mathCmd,
 		mpoolStatsCmd,
 		exportChainCmd,
+		consensusCmd,
+		serveDealStatsCmd,
 	}
 
 	app := &cli.App{
@@ -49,6 +51,13 @@ func main() {
 				Hidden:  true,
 				Value:   "~/.lotus", // TODO: Consider XDG_DATA_HOME
 			},
+			&cli.StringFlag{
+				Name:  "log-level",
+				Value: "info",
+			},
+		},
+		Before: func(cctx *cli.Context) error {
+			return logging.SetLogLevel("lotus-shed", cctx.String("log-level"))
 		},
 	}
 

cmd/lotus-shed/mempool-stats.go

@@ -14,11 +14,12 @@ import (
 	"go.opencensus.io/stats/view"
 	"go.opencensus.io/tag"
 
+	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
+
 	"github.com/filecoin-project/go-address"
 	lapi "github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/chain/types"
 	lcli "github.com/filecoin-project/lotus/cli"
-	"github.com/filecoin-project/specs-actors/actors/builtin"
 )
 
 var (
@@ -121,7 +122,7 @@ var mpoolStatsCmd = &cli.Command{
 				return false, err
 			}
 
-			ism := act.Code == builtin.StorageMinerActorCodeID
+			ism := act.IsStorageMinerActor()
 			mcache[addr] = ism
 			return ism, nil
 		}
@@ -143,7 +144,7 @@ var mpoolStatsCmd = &cli.Command{
 						seen: time.Now(),
 					}
 
-					if u.Message.Message.Method == builtin.MethodsMiner.SubmitWindowedPoSt {
+					if u.Message.Message.Method == builtin0.MethodsMiner.SubmitWindowedPoSt {
 
 						miner, err := isMiner(u.Message.Message.To)
 						if err != nil {

cmd/lotus-shed/stateroot-stats.go

@@ -182,6 +182,11 @@ var staterootStatCmd = &cli.Command{
 			return infos[i].Stat.Size > infos[j].Stat.Size
 		})
 
+		var totalActorsSize uint64
+		for _, info := range infos {
+			totalActorsSize += info.Stat.Size
+		}
+
 		outcap := 10
 		if cctx.Args().Len() > outcap {
 			outcap = cctx.Args().Len()
@@ -190,6 +195,15 @@ var staterootStatCmd = &cli.Command{
 			outcap = len(infos)
 		}
 
+		totalStat, err := api.ChainStatObj(ctx, ts.ParentState(), cid.Undef)
+		if err != nil {
+			return err
+		}
+
+		fmt.Println("Total state tree size: ", totalStat.Size)
+		fmt.Println("Sum of actor state size: ", totalActorsSize)
+		fmt.Println("State tree structure size: ", totalStat.Size-totalActorsSize)
+
 		fmt.Print("Addr\tType\tSize\n")
 		for _, inf := range infos[:outcap] {
 			cmh, err := multihash.Decode(inf.Actor.Code.Hash())

cmd/lotus-shed/verifreg.go

@@ -8,13 +8,15 @@ import (
 
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/specs-actors/actors/builtin"
-	"github.com/filecoin-project/specs-actors/actors/builtin/verifreg"
-	"github.com/filecoin-project/specs-actors/actors/util/adt"
+
+	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
+	verifreg0 "github.com/filecoin-project/specs-actors/actors/builtin/verifreg"
 
 	"github.com/filecoin-project/lotus/api/apibstore"
 	"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/verifreg"
 	"github.com/filecoin-project/lotus/chain/types"
 	lcli "github.com/filecoin-project/lotus/cli"
 	cbor "github.com/ipfs/go-ipld-cbor"
@@ -57,7 +59,7 @@ var verifRegAddVerifierCmd = &cli.Command{
 			return err
 		}
 
-		params, err := actors.SerializeParams(&verifreg.AddVerifierParams{Address: target, Allowance: allowance})
+		params, err := actors.SerializeParams(&verifreg0.AddVerifierParams{Address: target, Allowance: allowance})
 		if err != nil {
 			return err
 		}
@@ -70,9 +72,9 @@ var verifRegAddVerifierCmd = &cli.Command{
 		ctx := lcli.ReqContext(cctx)
 
 		msg := &types.Message{
-			To:     builtin.VerifiedRegistryActorAddr,
+			To:     verifreg.Address,
 			From:   fromk,
-			Method: builtin.MethodsVerifiedRegistry.AddVerifier,
+			Method: builtin0.MethodsVerifiedRegistry.AddVerifier,
 			Params: params,
 		}
 
@@ -131,7 +133,7 @@ var verifRegVerifyClientCmd = &cli.Command{
 			return err
 		}
 
-		params, err := actors.SerializeParams(&verifreg.AddVerifiedClientParams{Address: target, Allowance: allowance})
+		params, err := actors.SerializeParams(&verifreg0.AddVerifiedClientParams{Address: target, Allowance: allowance})
 		if err != nil {
 			return err
 		}
@@ -144,9 +146,9 @@ var verifRegVerifyClientCmd = &cli.Command{
 		ctx := lcli.ReqContext(cctx)
 
 		msg := &types.Message{
-			To:     builtin.VerifiedRegistryActorAddr,
+			To:     verifreg.Address,
 			From:   fromk,
-			Method: builtin.MethodsVerifiedRegistry.AddVerifiedClient,
+			Method: builtin0.MethodsVerifiedRegistry.AddVerifiedClient,
 			Params: params,
 		}
 
@@ -181,7 +183,7 @@ var verifRegListVerifiersCmd = &cli.Command{
 		defer closer()
 		ctx := lcli.ReqContext(cctx)
 
-		act, err := api.StateGetActor(ctx, builtin.VerifiedRegistryActorAddr, types.EmptyTSK)
+		act, err := api.StateGetActor(ctx, verifreg.Address, types.EmptyTSK)
 		if err != nil {
 			return err
 		}
@@ -189,31 +191,14 @@ var verifRegListVerifiersCmd = &cli.Command{
 		apibs := apibstore.NewAPIBlockstore(api)
 		store := adt.WrapStore(ctx, cbor.NewCborStore(apibs))
 
-		var st verifreg.State
-		if err := store.Get(ctx, act.Head, &st); err != nil {
-			return err
-		}
-
-		vh, err := adt.AsMap(store, st.Verifiers)
+		st, err := verifreg.Load(store, act)
 		if err != nil {
 			return err
 		}
-
-		var dcap verifreg.DataCap
-		if err := vh.ForEach(&dcap, func(k string) error {
-			addr, err := address.NewFromBytes([]byte(k))
-			if err != nil {
-				return err
-			}
-
-			fmt.Printf("%s: %s\n", addr, dcap)
-
-			return nil
-		}); err != nil {
+		return st.ForEachVerifier(func(addr address.Address, dcap abi.StoragePower) error {
+			_, err := fmt.Printf("%s: %s\n", addr, dcap)
 			return err
-		}
-
-		return nil
+		})
 	},
 }
 
@@ -228,7 +213,7 @@ var verifRegListClientsCmd = &cli.Command{
 		defer closer()
 		ctx := lcli.ReqContext(cctx)
 
-		act, err := api.StateGetActor(ctx, builtin.VerifiedRegistryActorAddr, types.EmptyTSK)
+		act, err := api.StateGetActor(ctx, verifreg.Address, types.EmptyTSK)
 		if err != nil {
 			return err
 		}
@@ -236,31 +221,14 @@ var verifRegListClientsCmd = &cli.Command{
 		apibs := apibstore.NewAPIBlockstore(api)
 		store := adt.WrapStore(ctx, cbor.NewCborStore(apibs))
 
-		var st verifreg.State
-		if err := store.Get(ctx, act.Head, &st); err != nil {
-			return err
-		}
-
-		vh, err := adt.AsMap(store, st.VerifiedClients)
+		st, err := verifreg.Load(store, act)
 		if err != nil {
 			return err
 		}
-
-		var dcap verifreg.DataCap
-		if err := vh.ForEach(&dcap, func(k string) error {
-			addr, err := address.NewFromBytes([]byte(k))
-			if err != nil {
-				return err
-			}
-
-			fmt.Printf("%s: %s\n", addr, dcap)
-
-			return nil
-		}); err != nil {
+		return st.ForEachClient(func(addr address.Address, dcap abi.StoragePower) error {
+			_, err := fmt.Printf("%s: %s\n", addr, dcap)
 			return err
-		}
-
-		return nil
+		})
 	},
 }
 
@@ -318,7 +286,17 @@ var verifRegCheckVerifierCmd = &cli.Command{
 		defer closer()
 		ctx := lcli.ReqContext(cctx)
 
-		act, err := api.StateGetActor(ctx, builtin.VerifiedRegistryActorAddr, types.EmptyTSK)
+		head, err := api.ChainHead(ctx)
+		if err != nil {
+			return err
+		}
+
+		vid, err := api.StateLookupID(ctx, vaddr, head.Key())
+		if err != nil {
+			return err
+		}
+
+		act, err := api.StateGetActor(ctx, verifreg.Address, head.Key())
 		if err != nil {
 			return err
 		}
@@ -326,20 +304,16 @@ var verifRegCheckVerifierCmd = &cli.Command{
 		apibs := apibstore.NewAPIBlockstore(api)
 		store := adt.WrapStore(ctx, cbor.NewCborStore(apibs))
 
-		var st verifreg.State
-		if err := store.Get(ctx, act.Head, &st); err != nil {
-			return err
-		}
-
-		vh, err := adt.AsMap(store, st.Verifiers)
+		st, err := verifreg.Load(store, act)
 		if err != nil {
 			return err
 		}
 
-		var dcap verifreg.DataCap
-		if found, err := vh.Get(abi.AddrKey(vaddr), &dcap); err != nil {
+		found, dcap, err := st.VerifierDataCap(vid)
+		if err != nil {
 			return err
-		} else if !found {
+		}
+		if !found {
 			return fmt.Errorf("not found")
 		}
 

cmd/lotus-storage-miner/market.go

@@ -156,12 +156,12 @@ var setAskCmd = &cli.Command{
 	Flags: []cli.Flag{
 		&cli.Uint64Flag{
 			Name:     "price",
-			Usage:    "Set the price of the ask for unverified deals (specified as FIL / GiB / Epoch) to `PRICE`",
+			Usage:    "Set the price of the ask for unverified deals (specified as attoFIL / GiB / Epoch) to `PRICE`",
 			Required: true,
 		},
 		&cli.Uint64Flag{
 			Name:     "verified-price",
-			Usage:    "Set the price of the ask for verified deals (specified as FIL / GiB / Epoch) to `PRICE`",
+			Usage:    "Set the price of the ask for verified deals (specified as attoFIL / GiB / Epoch) to `PRICE`",
 			Required: true,
 		},
 		&cli.StringFlag{

cmd/lotus-storage-miner/proving.go

@@ -3,6 +3,7 @@ package main
 import (
 	"fmt"
 	"os"
+	"strconv"
 	"text/tabwriter"
 
 	"github.com/fatih/color"
@@ -22,6 +23,7 @@ var provingCmd = &cli.Command{
 	Subcommands: []*cli.Command{
 		provingInfoCmd,
 		provingDeadlinesCmd,
+		provingDeadlineInfoCmd,
 		provingFaultsCmd,
 	},
 }
@@ -279,3 +281,93 @@ var provingDeadlinesCmd = &cli.Command{
 		return tw.Flush()
 	},
 }
+
+var provingDeadlineInfoCmd = &cli.Command{
+	Name:      "deadline",
+	Usage:     "View the current proving period deadline information by its index ",
+	ArgsUsage: "<deadlineIdx>",
+	Action: func(cctx *cli.Context) error {
+
+		if cctx.Args().Len() != 1 {
+			return xerrors.Errorf("must pass deadline index")
+		}
+
+		dlIdx, err := strconv.ParseUint(cctx.Args().Get(0), 10, 64)
+		if err != nil {
+			return xerrors.Errorf("could not parse deadline index: %w", err)
+		}
+
+		nodeApi, closer, err := lcli.GetStorageMinerAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+
+		api, acloser, err := lcli.GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer acloser()
+
+		ctx := lcli.ReqContext(cctx)
+
+		maddr, err := getActorAddress(ctx, nodeApi, cctx.String("actor"))
+		if err != nil {
+			return err
+		}
+
+		deadlines, err := api.StateMinerDeadlines(ctx, maddr, types.EmptyTSK)
+		if err != nil {
+			return xerrors.Errorf("getting deadlines: %w", err)
+		}
+
+		di, err := api.StateMinerProvingDeadline(ctx, maddr, types.EmptyTSK)
+		if err != nil {
+			return xerrors.Errorf("getting deadlines: %w", err)
+		}
+
+		partitions, err := api.StateMinerPartitions(ctx, maddr, dlIdx, types.EmptyTSK)
+		if err != nil {
+			return xerrors.Errorf("getting partitions for deadline %d: %w", dlIdx, err)
+		}
+
+		provenPartitions, err := deadlines[dlIdx].PostSubmissions.Count()
+		if err != nil {
+			return err
+		}
+
+		fmt.Printf("Deadline Index:           %d\n", dlIdx)
+		fmt.Printf("Partitions:               %d\n", len(partitions))
+		fmt.Printf("Proven Partitions:        %d\n", provenPartitions)
+		fmt.Printf("Current:                  %t\n\n", di.Index == dlIdx)
+
+		for pIdx, partition := range partitions {
+			sectorCount, err := partition.AllSectors.Count()
+			if err != nil {
+				return err
+			}
+
+			sectorNumbers, err := partition.AllSectors.All(sectorCount)
+			if err != nil {
+				return err
+			}
+
+			faultsCount, err := partition.FaultySectors.Count()
+			if err != nil {
+				return err
+			}
+
+			fn, err := partition.FaultySectors.All(faultsCount)
+			if err != nil {
+				return err
+			}
+
+			fmt.Printf("Partition Index:          %d\n", pIdx)
+			fmt.Printf("Sectors:                  %d\n", sectorCount)
+			fmt.Printf("Sector Numbers:           %v\n", sectorNumbers)
+			fmt.Printf("Faults:                   %d\n", faultsCount)
+			fmt.Printf("Faulty Sectors:           %d\n", fn)
+		}
+		return nil
+	},
+}

cmd/lotus-storage-miner/run.go

@@ -163,8 +163,10 @@ var runCmd = &cli.Command{
 		sigChan := make(chan os.Signal, 2)
 		go func() {
 			select {
-			case <-sigChan:
+			case sig := <-sigChan:
+				log.Warnw("received shutdown", "signal", sig)
 			case <-shutdownChan:
+				log.Warn("received shutdown")
 			}
 
 			log.Warn("Shutting down...")

cmd/lotus-storage-miner/sectors.go

@@ -18,7 +18,9 @@ import (
 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
 	"github.com/filecoin-project/lotus/chain/types"
+
 	lcli "github.com/filecoin-project/lotus/cli"
+	sealing "github.com/filecoin-project/lotus/extern/storage-sealing"
 )
 
 var sectorsCmd = &cli.Command{
@@ -137,6 +139,12 @@ var sectorsStatusCmd = &cli.Command{
 var sectorsListCmd = &cli.Command{
 	Name:  "list",
 	Usage: "List sectors",
+	Flags: []cli.Flag{
+		&cli.BoolFlag{
+			Name:  "show-removed",
+			Usage: "show removed sectors",
+		},
+	},
 	Action: func(cctx *cli.Context) error {
 		nodeApi, closer, err := lcli.GetStorageMinerAPI(cctx)
 		if err != nil {
@@ -168,16 +176,16 @@ var sectorsListCmd = &cli.Command{
 		}
 		activeIDs := make(map[abi.SectorNumber]struct{}, len(activeSet))
 		for _, info := range activeSet {
-			activeIDs[info.ID] = struct{}{}
+			activeIDs[info.SectorNumber] = struct{}{}
 		}
 
-		sset, err := fullApi.StateMinerSectors(ctx, maddr, nil, true, types.EmptyTSK)
+		sset, err := fullApi.StateMinerSectors(ctx, maddr, nil, types.EmptyTSK)
 		if err != nil {
 			return err
 		}
 		commitedIDs := make(map[abi.SectorNumber]struct{}, len(activeSet))
 		for _, info := range sset {
-			commitedIDs[info.ID] = struct{}{}
+			commitedIDs[info.SectorNumber] = struct{}{}
 		}
 
 		sort.Slice(list, func(i, j int) bool {
@@ -193,19 +201,21 @@ var sectorsListCmd = &cli.Command{
 				continue
 			}
 
-			_, inSSet := commitedIDs[s]
-			_, inASet := activeIDs[s]
+			if cctx.Bool("show-removed") || st.State != api.SectorState(sealing.Removed) {
+				_, inSSet := commitedIDs[s]
+				_, inASet := activeIDs[s]
 
-			fmt.Fprintf(w, "%d: %s\tsSet: %s\tactive: %s\ttktH: %d\tseedH: %d\tdeals: %v\t toUpgrade:%t\n",
-				s,
-				st.State,
-				yesno(inSSet),
-				yesno(inASet),
-				st.Ticket.Epoch,
-				st.Seed.Epoch,
-				st.Deals,
-				st.ToUpgrade,
-			)
+				_, _ = fmt.Fprintf(w, "%d: %s\tsSet: %s\tactive: %s\ttktH: %d\tseedH: %d\tdeals: %v\t toUpgrade:%t\n",
+					s,
+					st.State,
+					yesno(inSSet),
+					yesno(inASet),
+					st.Ticket.Epoch,
+					st.Seed.Epoch,
+					st.Deals,
+					st.ToUpgrade,
+				)
+			}
 		}
 
 		return w.Flush()
@@ -394,8 +404,9 @@ var sectorsCapacityCollateralCmd = &cli.Command{
 }
 
 var sectorsUpdateCmd = &cli.Command{
-	Name:  "update-state",
-	Usage: "ADVANCED: manually update the state of a sector, this may aid in error recovery",
+	Name:      "update-state",
+	Usage:     "ADVANCED: manually update the state of a sector, this may aid in error recovery",
+	ArgsUsage: "<sectorNum> <newState>",
 	Flags: []cli.Flag{
 		&cli.BoolFlag{
 			Name:  "really-do-it",
@@ -421,6 +432,15 @@ var sectorsUpdateCmd = &cli.Command{
 			return xerrors.Errorf("could not parse sector number: %w", err)
 		}
 
+		newState := cctx.Args().Get(1)
+		if _, ok := sealing.ExistSectorStateList[sealing.SectorState(newState)]; !ok {
+			fmt.Printf(" \"%s\" is not a valid state. Possible states for sectors are: \n", newState)
+			for state := range sealing.ExistSectorStateList {
+				fmt.Printf("%s\n", string(state))
+			}
+			return nil
+		}
+
 		return nodeApi.SectorsUpdate(ctx, abi.SectorNumber(id), api.SectorState(cctx.Args().Get(1)))
 	},
 }

cmd/lotus-storage-miner/storage.go

@@ -370,7 +370,7 @@ var storageFindCmd = &cli.Command{
 			}
 
 			fmt.Printf("In %s (%s)\n", info.id, types[:len(types)-2])
-			fmt.Printf("\tSealing: %t; Storage: %t\n", info.store.CanSeal, info.store.CanSeal)
+			fmt.Printf("\tSealing: %t; Storage: %t\n", info.store.CanSeal, info.store.CanStore)
 			if localPath, ok := local[info.id]; ok {
 				fmt.Printf("\tLocal (%s)\n", localPath)
 			} else {

cmd/lotus/rpc.go

@@ -66,8 +66,10 @@ func serveRPC(a api.FullNode, stop node.StopFunc, addr multiaddr.Multiaddr, shut
 	shutdownDone := make(chan struct{})
 	go func() {
 		select {
-		case <-sigCh:
+		case sig := <-sigCh:
+			log.Warnw("received shutdown", "signal", sig)
 		case <-shutdownCh:
+			log.Warn("received shutdown")
 		}
 
 		log.Warn("Shutting down...")

conformance/chaos/actor.go

@@ -7,8 +7,6 @@ import (
 	"github.com/filecoin-project/specs-actors/actors/builtin"
 	"github.com/filecoin-project/specs-actors/actors/runtime"
 	"github.com/ipfs/go-cid"
-
-	typegen "github.com/whyrusleeping/cbor-gen"
 )
 
 //go:generate go run ./gen
@@ -31,10 +29,14 @@ type Actor struct{}
 type CallerValidationBranch int64
 
 const (
+	// CallerValidationBranchNone causes no caller validation to take place.
 	CallerValidationBranchNone CallerValidationBranch = iota
+	// CallerValidationBranchTwice causes Runtime.ValidateImmediateCallerAcceptAny to be called twice.
 	CallerValidationBranchTwice
-	CallerValidationBranchAddrNilSet
-	CallerValidationBranchTypeNilSet
+	// CallerValidationBranchIsAddress causes caller validation against CallerValidationArgs.Addrs.
+	CallerValidationBranchIsAddress
+	// CallerValidationBranchIsType causes caller validation against CallerValidationArgs.Types.
+	CallerValidationBranchIsType
 )
 
 // MutateStateBranch is an enum used to select the type of state mutation to attempt.
@@ -123,23 +125,29 @@ func (a Actor) Constructor(_ runtime.Runtime, _ *abi.EmptyValue) *abi.EmptyValue
 	panic("constructor should not be called; the Chaos actor is a singleton actor")
 }
 
+// CallerValidationArgs are the arguments to Actor.CallerValidation.
+type CallerValidationArgs struct {
+	Branch CallerValidationBranch
+	Addrs  []address.Address
+	Types  []cid.Cid
+}
+
 // CallerValidation violates VM call validation constraints.
 //
 //  CallerValidationBranchNone performs no validation.
 //  CallerValidationBranchTwice validates twice.
-//  CallerValidationBranchAddrNilSet validates against an empty caller
-//  address set.
-//  CallerValidationBranchTypeNilSet validates against an empty caller type set.
-func (a Actor) CallerValidation(rt runtime.Runtime, branch *typegen.CborInt) *abi.EmptyValue {
-	switch CallerValidationBranch(*branch) {
+//  CallerValidationBranchIsAddress validates caller against CallerValidationArgs.Addrs.
+//  CallerValidationBranchIsType validates caller against CallerValidationArgs.Types.
+func (a Actor) CallerValidation(rt runtime.Runtime, args *CallerValidationArgs) *abi.EmptyValue {
+	switch args.Branch {
 	case CallerValidationBranchNone:
 	case CallerValidationBranchTwice:
 		rt.ValidateImmediateCallerAcceptAny()
 		rt.ValidateImmediateCallerAcceptAny()
-	case CallerValidationBranchAddrNilSet:
-		rt.ValidateImmediateCallerIs()
-	case CallerValidationBranchTypeNilSet:
-		rt.ValidateImmediateCallerType()
+	case CallerValidationBranchIsAddress:
+		rt.ValidateImmediateCallerIs(args.Addrs...)
+	case CallerValidationBranchIsType:
+		rt.ValidateImmediateCallerType(args.Types...)
 	default:
 		panic("invalid branch passed to CallerValidation")
 	}

conformance/chaos/actor_test.go

@@ -4,11 +4,13 @@ import (
 	"context"
 	"testing"
 
+	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/exitcode"
 	"github.com/filecoin-project/specs-actors/actors/builtin"
 	"github.com/filecoin-project/specs-actors/support/mock"
 	atesting "github.com/filecoin-project/specs-actors/support/testing"
+	"github.com/ipfs/go-cid"
 )
 
 func TestSingleton(t *testing.T) {
@@ -25,6 +27,86 @@ func TestSingleton(t *testing.T) {
 	rt.Verify()
 }
 
+func TestCallerValidationNone(t *testing.T) {
+	receiver := atesting.NewIDAddr(t, 100)
+	builder := mock.NewBuilder(context.Background(), receiver)
+
+	rt := builder.Build(t)
+	var a Actor
+
+	rt.Call(a.CallerValidation, &CallerValidationArgs{Branch: CallerValidationBranchNone})
+	rt.Verify()
+}
+
+func TestCallerValidationIs(t *testing.T) {
+	caller := atesting.NewIDAddr(t, 100)
+	receiver := atesting.NewIDAddr(t, 101)
+	builder := mock.NewBuilder(context.Background(), receiver)
+
+	rt := builder.Build(t)
+	rt.SetCaller(caller, builtin.AccountActorCodeID)
+	var a Actor
+
+	caddrs := []address.Address{atesting.NewIDAddr(t, 101)}
+
+	rt.ExpectValidateCallerAddr(caddrs...)
+	// FIXME: https://github.com/filecoin-project/specs-actors/pull/1155
+	rt.ExpectAbort(exitcode.ErrForbidden, func() {
+		rt.Call(a.CallerValidation, &CallerValidationArgs{
+			Branch: CallerValidationBranchIsAddress,
+			Addrs:  caddrs,
+		})
+	})
+	rt.Verify()
+
+	rt.ExpectValidateCallerAddr(caller)
+	rt.Call(a.CallerValidation, &CallerValidationArgs{
+		Branch: CallerValidationBranchIsAddress,
+		Addrs:  []address.Address{caller},
+	})
+	rt.Verify()
+}
+
+func TestCallerValidationType(t *testing.T) {
+	caller := atesting.NewIDAddr(t, 100)
+	receiver := atesting.NewIDAddr(t, 101)
+	builder := mock.NewBuilder(context.Background(), receiver)
+
+	rt := builder.Build(t)
+	rt.SetCaller(caller, builtin.AccountActorCodeID)
+	var a Actor
+
+	rt.ExpectValidateCallerType(builtin.CronActorCodeID)
+	// FIXME: https://github.com/filecoin-project/specs-actors/pull/1155
+	rt.ExpectAbort(exitcode.ErrForbidden, func() {
+		rt.Call(a.CallerValidation, &CallerValidationArgs{
+			Branch: CallerValidationBranchIsType,
+			Types:  []cid.Cid{builtin.CronActorCodeID},
+		})
+	})
+	rt.Verify()
+
+	rt.ExpectValidateCallerType(builtin.AccountActorCodeID)
+	rt.Call(a.CallerValidation, &CallerValidationArgs{
+		Branch: CallerValidationBranchIsType,
+		Types:  []cid.Cid{builtin.AccountActorCodeID},
+	})
+	rt.Verify()
+}
+
+func TestCallerValidationInvalidBranch(t *testing.T) {
+	receiver := atesting.NewIDAddr(t, 100)
+	builder := mock.NewBuilder(context.Background(), receiver)
+
+	rt := builder.Build(t)
+	var a Actor
+
+	rt.ExpectAssertionFailure("invalid branch passed to CallerValidation", func() {
+		rt.Call(a.CallerValidation, &CallerValidationArgs{Branch: -1})
+	})
+	rt.Verify()
+}
+
 func TestDeleteActor(t *testing.T) {
 	receiver := atesting.NewIDAddr(t, 100)
 	beneficiary := atesting.NewIDAddr(t, 101)
@@ -118,6 +200,20 @@ func TestMutateStateReadonly(t *testing.T) {
 	rt.Verify()
 }
 
+func TestMutateStateInvalidBranch(t *testing.T) {
+	receiver := atesting.NewIDAddr(t, 100)
+	builder := mock.NewBuilder(context.Background(), receiver)
+
+	rt := builder.Build(t)
+	var a Actor
+
+	rt.ExpectValidateCallerAny()
+	rt.ExpectAssertionFailure("unknown mutation type", func() {
+		rt.Call(a.MutateState, &MutateStateArgs{Branch: -1})
+	})
+	rt.Verify()
+}
+
 func TestAbortWith(t *testing.T) {
 	receiver := atesting.NewIDAddr(t, 100)
 	builder := mock.NewBuilder(context.Background(), receiver)

conformance/chaos/cbor_gen.go

@@ -6,8 +6,10 @@ import (
 	"fmt"
 	"io"
 
+	address "github.com/filecoin-project/go-address"
 	abi "github.com/filecoin-project/go-state-types/abi"
 	exitcode "github.com/filecoin-project/go-state-types/exitcode"
+	cid "github.com/ipfs/go-cid"
 	cbg "github.com/whyrusleeping/cbor-gen"
 	xerrors "golang.org/x/xerrors"
 )
@@ -115,6 +117,163 @@ func (t *State) UnmarshalCBOR(r io.Reader) error {
 	return nil
 }
 
+var lengthBufCallerValidationArgs = []byte{131}
+
+func (t *CallerValidationArgs) MarshalCBOR(w io.Writer) error {
+	if t == nil {
+		_, err := w.Write(cbg.CborNull)
+		return err
+	}
+	if _, err := w.Write(lengthBufCallerValidationArgs); err != nil {
+		return err
+	}
+
+	scratch := make([]byte, 9)
+
+	// t.Branch (chaos.CallerValidationBranch) (int64)
+	if t.Branch >= 0 {
+		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.Branch)); err != nil {
+			return err
+		}
+	} else {
+		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajNegativeInt, uint64(-t.Branch-1)); err != nil {
+			return err
+		}
+	}
+
+	// t.Addrs ([]address.Address) (slice)
+	if len(t.Addrs) > cbg.MaxLength {
+		return xerrors.Errorf("Slice value in field t.Addrs was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajArray, uint64(len(t.Addrs))); err != nil {
+		return err
+	}
+	for _, v := range t.Addrs {
+		if err := v.MarshalCBOR(w); err != nil {
+			return err
+		}
+	}
+
+	// t.Types ([]cid.Cid) (slice)
+	if len(t.Types) > cbg.MaxLength {
+		return xerrors.Errorf("Slice value in field t.Types was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajArray, uint64(len(t.Types))); err != nil {
+		return err
+	}
+	for _, v := range t.Types {
+		if err := cbg.WriteCidBuf(scratch, w, v); err != nil {
+			return xerrors.Errorf("failed writing cid field t.Types: %w", err)
+		}
+	}
+	return nil
+}
+
+func (t *CallerValidationArgs) UnmarshalCBOR(r io.Reader) error {
+	*t = CallerValidationArgs{}
+
+	br := cbg.GetPeeker(r)
+	scratch := make([]byte, 8)
+
+	maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
+	if err != nil {
+		return err
+	}
+	if maj != cbg.MajArray {
+		return fmt.Errorf("cbor input should be of type array")
+	}
+
+	if extra != 3 {
+		return fmt.Errorf("cbor input had wrong number of fields")
+	}
+
+	// t.Branch (chaos.CallerValidationBranch) (int64)
+	{
+		maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
+		var extraI int64
+		if err != nil {
+			return err
+		}
+		switch maj {
+		case cbg.MajUnsignedInt:
+			extraI = int64(extra)
+			if extraI < 0 {
+				return fmt.Errorf("int64 positive overflow")
+			}
+		case cbg.MajNegativeInt:
+			extraI = int64(extra)
+			if extraI < 0 {
+				return fmt.Errorf("int64 negative oveflow")
+			}
+			extraI = -1 - extraI
+		default:
+			return fmt.Errorf("wrong type for int64 field: %d", maj)
+		}
+
+		t.Branch = CallerValidationBranch(extraI)
+	}
+	// t.Addrs ([]address.Address) (slice)
+
+	maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
+	if err != nil {
+		return err
+	}
+
+	if extra > cbg.MaxLength {
+		return fmt.Errorf("t.Addrs: array too large (%d)", extra)
+	}
+
+	if maj != cbg.MajArray {
+		return fmt.Errorf("expected cbor array")
+	}
+
+	if extra > 0 {
+		t.Addrs = make([]address.Address, extra)
+	}
+
+	for i := 0; i < int(extra); i++ {
+
+		var v address.Address
+		if err := v.UnmarshalCBOR(br); err != nil {
+			return err
+		}
+
+		t.Addrs[i] = v
+	}
+
+	// t.Types ([]cid.Cid) (slice)
+
+	maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
+	if err != nil {
+		return err
+	}
+
+	if extra > cbg.MaxLength {
+		return fmt.Errorf("t.Types: array too large (%d)", extra)
+	}
+
+	if maj != cbg.MajArray {
+		return fmt.Errorf("expected cbor array")
+	}
+
+	if extra > 0 {
+		t.Types = make([]cid.Cid, extra)
+	}
+
+	for i := 0; i < int(extra); i++ {
+
+		c, err := cbg.ReadCid(br)
+		if err != nil {
+			return xerrors.Errorf("reading cid field t.Types failed: %w", err)
+		}
+		t.Types[i] = c
+	}
+
+	return nil
+}
+
 var lengthBufCreateActorArgs = []byte{132}
 
 func (t *CreateActorArgs) MarshalCBOR(w io.Writer) error {

conformance/chaos/gen/gen.go

@@ -9,6 +9,7 @@ import (
 func main() {
 	if err := gen.WriteTupleEncodersToFile("./cbor_gen.go", "chaos",
 		chaos.State{},
+		chaos.CallerValidationArgs{},
 		chaos.CreateActorArgs{},
 		chaos.ResolveAddressResponse{},
 		chaos.SendArgs{},

conformance/driver.go

@@ -122,6 +122,8 @@ func (d *Driver) ExecuteTipset(bs blockstore.Blockstore, ds ds.Batching, preroot
 
 // ExecuteMessage executes a conformance test vector message in a temporary VM.
 func (d *Driver) ExecuteMessage(bs blockstore.Blockstore, preroot cid.Cid, epoch abi.ChainEpoch, msg *types.Message) (*vm.ApplyRet, cid.Cid, error) {
+	// dummy state manager; only to reference the GetNetworkVersion method, which does not depend on state.
+	sm := new(stmgr.StateManager)
 	vmOpts := &vm.VMOpts{
 		StateBase:      preroot,
 		Epoch:          epoch,
@@ -130,6 +132,7 @@ func (d *Driver) ExecuteMessage(bs blockstore.Blockstore, preroot cid.Cid, epoch
 		Syscalls:       mkFakedSigSyscalls(vm.Syscalls(ffiwrapper.ProofVerifier)), // TODO always succeeds; need more flexibility.
 		CircSupplyCalc: nil,
 		BaseFee:        BaseFee,
+		NtwkVersion:    sm.GetNtwkVersion,
 	}
 
 	lvm, err := vm.NewVM(context.TODO(), vmOpts)

documentation/en/api-methods.md

@@ -9,6 +9,7 @@
 * [Beacon](#Beacon)
   * [BeaconGetEntry](#BeaconGetEntry)
 * [Chain](#Chain)
+  * [ChainDeleteObj](#ChainDeleteObj)
   * [ChainExport](#ChainExport)
   * [ChainGetBlock](#ChainGetBlock)
   * [ChainGetBlockMessages](#ChainGetBlockMessages)
@@ -213,7 +214,7 @@ Response:
 ```json
 {
   "Version": "string value",
-  "APIVersion": 3840,
+  "APIVersion": 4096,
   "BlockDelay": 42
 }
 ```
@@ -281,6 +282,23 @@ The Chain method group contains methods for interacting with the
 blockchain, but that do not require any form of state computation.
 
 
+### ChainDeleteObj
+ChainDeleteObj deletes node referenced by the given CID
+
+
+Perms: admin
+
+Inputs:
+```json
+[
+  {
+    "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+  }
+]
+```
+
+Response: `{}`
+
 ### ChainExport
 ChainExport returns a stream of bytes with CAR dump of chain data.
 The exported chain data includes the header chain from the given tipset
@@ -3714,8 +3732,6 @@ Response:
 
 ### StateMinerSectors
 StateMinerSectors returns info about the given miner's sectors. If the filter bitfield is nil, all sectors are included.
-If the filterOut boolean is set to true, any sectors in the filter are excluded.
-If false, only those sectors in the filter are included.
 
 
 Perms: read
@@ -3727,7 +3743,6 @@ Inputs:
   [
     0
   ],
-  true,
   [
     {
       "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
@@ -3810,7 +3825,7 @@ Inputs:
 ]
 ```
 
-Response: `2`
+Response: `3`
 
 ### StateReadState
 StateReadState returns the indicated actor's state.
@@ -4288,7 +4303,8 @@ Inputs: `null`
 Response:
 ```json
 {
-  "ActiveSyncs": null
+  "ActiveSyncs": null,
+  "VMApplied": 42
 }
 ```
 

extern/storage-sealing/checks.go

@@ -4,6 +4,8 @@ import (
 	"bytes"
 	"context"
 
+	"github.com/filecoin-project/lotus/chain/actors/policy"
+
 	"github.com/filecoin-project/lotus/build"
 	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
 
@@ -104,7 +106,7 @@ func checkPrecommit(ctx context.Context, maddr address.Address, si SectorInfo, t
 	if nv < build.ActorUpgradeNetworkVersion {
 		msd = miner0.MaxSealDuration[si.SectorType]
 	} else {
-		// TODO: ActorUpgrade
+		// TODO: ActorUpgrade(use MaxProveCommitDuration)
 		msd = 0
 	}
 
@@ -154,13 +156,8 @@ func (m *Sealing) checkCommit(ctx context.Context, si SectorInfo, proof []byte,
 		return &ErrNoPrecommit{xerrors.Errorf("precommit info not found on-chain")}
 	}
 
-	pccd, err := m.getPreCommitChallengeDelay(ctx, tok)
-	if err != nil {
-		return xerrors.Errorf("failed to get precommit challenge delay: %w", err)
-	}
-
-	if pci.PreCommitEpoch+pccd != si.SeedEpoch {
-		return &ErrBadSeed{xerrors.Errorf("seed epoch doesn't match on chain info: %d != %d", pci.PreCommitEpoch+pccd, si.SeedEpoch)}
+	if pci.PreCommitEpoch+policy.GetPreCommitChallengeDelay() != si.SeedEpoch {
+		return &ErrBadSeed{xerrors.Errorf("seed epoch doesn't match on chain info: %d != %d", pci.PreCommitEpoch+policy.GetPreCommitChallengeDelay(), si.SeedEpoch)}
 	}
 
 	buf := new(bytes.Buffer)

extern/storage-sealing/precommit_policy.go

@@ -3,11 +3,11 @@ package sealing
 import (
 	"context"
 
+	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
+
 	"github.com/filecoin-project/go-state-types/network"
-	"github.com/filecoin-project/lotus/build"
 
 	"github.com/filecoin-project/go-state-types/abi"
-	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
 )
 
 type PreCommitPolicy interface {
@@ -52,7 +52,7 @@ func NewBasicPreCommitPolicy(api Chain, duration abi.ChainEpoch, provingBoundary
 // Expiration produces the pre-commit sector expiration epoch for an encoded
 // replica containing the provided enumeration of pieces and deals.
 func (p *BasicPreCommitPolicy) Expiration(ctx context.Context, ps ...Piece) (abi.ChainEpoch, error) {
-	tok, epoch, err := p.api.ChainHead(ctx)
+	_, epoch, err := p.api.ChainHead(ctx)
 	if err != nil {
 		return 0, err
 	}
@@ -80,20 +80,7 @@ func (p *BasicPreCommitPolicy) Expiration(ctx context.Context, ps ...Piece) (abi
 		end = &tmp
 	}
 
-	nv, err := p.api.StateNetworkVersion(ctx, tok)
-	if err != nil {
-		return 0, err
-	}
-
-	var wpp abi.ChainEpoch
-	if nv < build.ActorUpgradeNetworkVersion {
-		wpp = miner0.WPoStProvingPeriod
-	} else {
-		// TODO: ActorUpgrade
-		wpp = 0
-	}
-
-	*end += wpp - (*end % wpp) + p.provingBoundary - 1
+	*end += miner.WPoStProvingPeriod - (*end % miner.WPoStProvingPeriod) + p.provingBoundary - 1
 
 	return *end, nil
 }

extern/storage-sealing/sealing.go

@@ -8,9 +8,6 @@ import (
 	"sync"
 	"time"
 
-	"github.com/filecoin-project/lotus/build"
-	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
-
 	"github.com/filecoin-project/go-state-types/network"
 	"github.com/ipfs/go-cid"
 	"github.com/ipfs/go-datastore"
@@ -422,17 +419,3 @@ func getDealPerSectorLimit(size abi.SectorSize) uint64 {
 	}
 	return 512
 }
-
-func (m *Sealing) getPreCommitChallengeDelay(ctx context.Context, tok TipSetToken) (abi.ChainEpoch, error) {
-	nv, err := m.api.StateNetworkVersion(ctx, tok)
-	if err != nil {
-		return -1, xerrors.Errorf("failed to get network version: %w", err)
-	}
-
-	if nv < build.ActorUpgradeNetworkVersion {
-		return miner0.PreCommitChallengeDelay, nil
-	}
-
-	// TODO: ActorUpgrade
-	return -1, nil
-}

extern/storage-sealing/sector_state.go

@@ -2,6 +2,38 @@ package sealing
 
 type SectorState string
 
+var ExistSectorStateList = map[SectorState]struct{}{
+	Empty:                {},
+	WaitDeals:            {},
+	Packing:              {},
+	PreCommit1:           {},
+	PreCommit2:           {},
+	PreCommitting:        {},
+	PreCommitWait:        {},
+	WaitSeed:             {},
+	Committing:           {},
+	SubmitCommit:         {},
+	CommitWait:           {},
+	FinalizeSector:       {},
+	Proving:              {},
+	FailedUnrecoverable:  {},
+	SealPreCommit1Failed: {},
+	SealPreCommit2Failed: {},
+	PreCommitFailed:      {},
+	ComputeProofFailed:   {},
+	CommitFailed:         {},
+	PackingFailed:        {},
+	FinalizeFailed:       {},
+	DealsExpired:         {},
+	RecoverDealIDs:       {},
+	Faulty:               {},
+	FaultReported:        {},
+	FaultedFinal:         {},
+	Removing:             {},
+	RemoveFailed:         {},
+	Removed:              {},
+}
+
 const (
 	UndefinedSectorState SectorState = ""
 

extern/storage-sealing/states_sealing.go

@@ -6,6 +6,7 @@ import (
 
 	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
+	"github.com/filecoin-project/lotus/chain/actors/policy"
 	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
 
 	"golang.org/x/xerrors"
@@ -189,17 +190,14 @@ func (m *Sealing) handlePreCommitting(ctx statemachine.Context, sector SectorInf
 	}
 
 	var msd abi.ChainEpoch
-	var mse abi.ChainEpoch
 	if nv < build.ActorUpgradeNetworkVersion {
 		msd = miner0.MaxSealDuration[sector.SectorType]
-		mse = miner0.MinSectorExpiration
 	} else {
-		// TODO: ActorUpgrade
+		// TODO: ActorUpgrade(use MaxProveCommitDuration)
 		msd = 0
-		mse = 0
 	}
 
-	if minExpiration := height + msd + mse + 10; expiration < minExpiration {
+	if minExpiration := height + msd + miner.MinSectorExpiration + 10; expiration < minExpiration {
 		expiration = minExpiration
 	}
 	// TODO: enforce a reasonable _maximum_ sector lifetime?
@@ -284,12 +282,7 @@ func (m *Sealing) handleWaitSeed(ctx statemachine.Context, sector SectorInfo) er
 		return ctx.Send(SectorChainPreCommitFailed{error: xerrors.Errorf("precommit info not found on chain")})
 	}
 
-	pccd, err := m.getPreCommitChallengeDelay(ctx.Context(), tok)
-	if err != nil {
-		return ctx.Send(SectorChainPreCommitFailed{xerrors.Errorf("failed to get precommit challenge delay: %w", err)})
-	}
-
-	randHeight := pci.PreCommitEpoch + pccd
+	randHeight := pci.PreCommitEpoch + policy.GetPreCommitChallengeDelay()
 
 	err = m.events.ChainAt(func(ectx context.Context, _ TipSetToken, curH abi.ChainEpoch) error {
 		// in case of null blocks the randomness can land after the tipset we
@@ -380,24 +373,14 @@ func (m *Sealing) handleSubmitCommit(ctx statemachine.Context, sector SectorInfo
 		return ctx.Send(SectorCommitFailed{xerrors.Errorf("commit check error: %w", err)})
 	}
 
-	nv, err := m.api.StateNetworkVersion(ctx.Context(), tok)
-	if err != nil {
-		return ctx.Send(SectorCommitFailed{xerrors.Errorf("failed to get network version: %w", err)})
+	enc := new(bytes.Buffer)
+	params := &miner.ProveCommitSectorParams{
+		SectorNumber: sector.SectorNumber,
+		Proof:        sector.Proof,
 	}
 
-	enc := new(bytes.Buffer)
-	if nv < build.ActorUpgradeNetworkVersion {
-		params := &miner0.ProveCommitSectorParams{
-			SectorNumber: sector.SectorNumber,
-			Proof:        sector.Proof,
-		}
-
-		if err := params.MarshalCBOR(enc); err != nil {
-			return ctx.Send(SectorCommitFailed{xerrors.Errorf("could not serialize commit sector parameters: %w", err)})
-		}
-	} else {
-		// TODO: ActorUpgrade
-		enc = nil
+	if err := params.MarshalCBOR(enc); err != nil {
+		return ctx.Send(SectorCommitFailed{xerrors.Errorf("could not serialize commit sector parameters: %w", err)})
 	}
 
 	waddr, err := m.api.StateMinerWorkerAddress(ctx.Context(), m.maddr, tok)

gen/main.go

@@ -75,5 +75,4 @@ func main() {
 		fmt.Println(err)
 		os.Exit(1)
 	}
-
 }

go.mod

@@ -25,9 +25,9 @@ require (
 	github.com/filecoin-project/go-bitfield v0.2.0
 	github.com/filecoin-project/go-cbor-util v0.0.0-20191219014500-08c40a1e63a2
 	github.com/filecoin-project/go-crypto v0.0.0-20191218222705-effae4ea9f03
-	github.com/filecoin-project/go-data-transfer v0.6.4
+	github.com/filecoin-project/go-data-transfer v0.6.6
 	github.com/filecoin-project/go-fil-commcid v0.0.0-20200716160307-8f644712406f
-	github.com/filecoin-project/go-fil-markets v0.6.1-0.20200917052354-ee0af754c6e9
+	github.com/filecoin-project/go-fil-markets v0.6.3
 	github.com/filecoin-project/go-jsonrpc v0.1.2-0.20200822201400-474f4fdccc52
 	github.com/filecoin-project/go-multistore v0.0.3
 	github.com/filecoin-project/go-padreader v0.0.0-20200903213702-ed5fae088b20
@@ -36,7 +36,7 @@ require (
 	github.com/filecoin-project/go-statemachine v0.0.0-20200813232949-df9b130df370
 	github.com/filecoin-project/go-statestore v0.1.0
 	github.com/filecoin-project/go-storedcounter v0.0.0-20200421200003-1c99c62e8a5b
-	github.com/filecoin-project/specs-actors v0.9.10
+	github.com/filecoin-project/specs-actors v0.9.11
 	github.com/filecoin-project/specs-storage v0.1.1-0.20200907031224-ed2e5cd13796
 	github.com/filecoin-project/test-vectors/schema v0.0.1
 	github.com/gbrlsnchs/jwt/v3 v3.0.0-beta.1
@@ -60,7 +60,7 @@ require (
 	github.com/ipfs/go-ds-measure v0.1.0
 	github.com/ipfs/go-filestore v1.0.0
 	github.com/ipfs/go-fs-lock v0.0.6
-	github.com/ipfs/go-graphsync v0.1.2
+	github.com/ipfs/go-graphsync v0.2.1
 	github.com/ipfs/go-ipfs-blockstore v1.0.1
 	github.com/ipfs/go-ipfs-chunker v0.0.5
 	github.com/ipfs/go-ipfs-ds-help v1.0.0
@@ -77,8 +77,8 @@ require (
 	github.com/ipfs/go-path v0.0.7
 	github.com/ipfs/go-unixfs v0.2.4
 	github.com/ipfs/interface-go-ipfs-core v0.2.3
-	github.com/ipld/go-car v0.1.1-0.20200526133713-1c7508d55aae
-	github.com/ipld/go-ipld-prime v0.0.4-0.20200828224805-5ff8c8b0b6ef
+	github.com/ipld/go-car v0.1.1-0.20200923150018-8cdef32e2da4
+	github.com/ipld/go-ipld-prime v0.5.1-0.20200828233916-988837377a7f
 	github.com/kelseyhightower/envconfig v1.4.0
 	github.com/lib/pq v1.7.0
 	github.com/libp2p/go-eventbus v0.2.1

go.sum

@@ -222,13 +222,12 @@ github.com/filecoin-project/go-cbor-util v0.0.0-20191219014500-08c40a1e63a2 h1:a
 github.com/filecoin-project/go-cbor-util v0.0.0-20191219014500-08c40a1e63a2/go.mod h1:pqTiPHobNkOVM5thSRsHYjyQfq7O5QSCMhvuu9JoDlg=
 github.com/filecoin-project/go-crypto v0.0.0-20191218222705-effae4ea9f03 h1:2pMXdBnCiXjfCYx/hLqFxccPoqsSveQFxVLvNxy9bus=
 github.com/filecoin-project/go-crypto v0.0.0-20191218222705-effae4ea9f03/go.mod h1:+viYnvGtUTgJRdy6oaeF4MTFKAfatX071MPDPBL11EQ=
-github.com/filecoin-project/go-data-transfer v0.6.3/go.mod h1:PmBKVXkhh67/tnEdJXQwDHl5mT+7Tbcwe1NPninqhnM=
-github.com/filecoin-project/go-data-transfer v0.6.4 h1:Q08ABa+cOTOLoAyHeA94fPLcwu53p6eeAaxMxQb0m0A=
-github.com/filecoin-project/go-data-transfer v0.6.4/go.mod h1:PmBKVXkhh67/tnEdJXQwDHl5mT+7Tbcwe1NPninqhnM=
+github.com/filecoin-project/go-data-transfer v0.6.6 h1:2TccLSxPYJENcYRdov2WvpTvQ1qUMrPkWe8sBrfj36g=
+github.com/filecoin-project/go-data-transfer v0.6.6/go.mod h1:C++k1U6+jMQODOaen5OPDo9XQbth9Yq3ie94vNjBJbk=
 github.com/filecoin-project/go-fil-commcid v0.0.0-20200716160307-8f644712406f h1:GxJzR3oRIMTPtpZ0b7QF8FKPK6/iPAc7trhlL5k/g+s=
 github.com/filecoin-project/go-fil-commcid v0.0.0-20200716160307-8f644712406f/go.mod h1:Eaox7Hvus1JgPrL5+M3+h7aSPHc0cVqpSxA+TxIEpZQ=
-github.com/filecoin-project/go-fil-markets v0.6.1-0.20200917052354-ee0af754c6e9 h1:SnCUC9wHDId9TtV8PsQp8q1OOsi+NOLOwitIDnAgUa4=
-github.com/filecoin-project/go-fil-markets v0.6.1-0.20200917052354-ee0af754c6e9/go.mod h1:PLr9svZxsnHkae1Ky7+66g7fP9AlneVxIVu+oSMq56A=
+github.com/filecoin-project/go-fil-markets v0.6.3 h1:3kTxfquGvk3zQY+hJH1kEA28tRQ47phqSRqOI4+YcQM=
+github.com/filecoin-project/go-fil-markets v0.6.3/go.mod h1:Ug1yhGhzTYC6qrpKsR2QpU8QRCeBpwkTA9RICVKuOMM=
 github.com/filecoin-project/go-hamt-ipld v0.1.5 h1:uoXrKbCQZ49OHpsTCkrThPNelC4W3LPEk0OrS/ytIBM=
 github.com/filecoin-project/go-hamt-ipld v0.1.5 h1:uoXrKbCQZ49OHpsTCkrThPNelC4W3LPEk0OrS/ytIBM=
 github.com/filecoin-project/go-hamt-ipld v0.1.5/go.mod h1:6Is+ONR5Cd5R6XZoCse1CWaXZc0Hdb/JeX+EQCQzX24=
@@ -255,8 +254,8 @@ github.com/filecoin-project/go-storedcounter v0.0.0-20200421200003-1c99c62e8a5b
 github.com/filecoin-project/go-storedcounter v0.0.0-20200421200003-1c99c62e8a5b/go.mod h1:Q0GQOBtKf1oE10eSXSlhN45kDBdGvEcVOqMiffqX+N8=
 github.com/filecoin-project/specs-actors v0.9.4/go.mod h1:BStZQzx5x7TmCkLv0Bpa07U6cPKol6fd3w9KjMPZ6Z4=
 github.com/filecoin-project/specs-actors v0.9.7/go.mod h1:wM2z+kwqYgXn5Z7scV1YHLyd1Q1cy0R8HfTIWQ0BFGU=
-github.com/filecoin-project/specs-actors v0.9.10 h1:gU0TrRhgkCsBEOP42sGDE7RQuR0Cov9hJhBqq+RJmjU=
-github.com/filecoin-project/specs-actors v0.9.10/go.mod h1:czlvLQGEX0fjLLfdNHD7xLymy6L3n7aQzRWzsYGf+ys=
+github.com/filecoin-project/specs-actors v0.9.11 h1:TnpG7HAeiUrfj0mJM7UaPW0P2137H62RGof7ftT5Mas=
+github.com/filecoin-project/specs-actors v0.9.11/go.mod h1:czlvLQGEX0fjLLfdNHD7xLymy6L3n7aQzRWzsYGf+ys=
 github.com/filecoin-project/specs-storage v0.1.1-0.20200907031224-ed2e5cd13796 h1:dJsTPWpG2pcTeojO2pyn0c6l+x/3MZYCBgo/9d11JEk=
 github.com/filecoin-project/specs-storage v0.1.1-0.20200907031224-ed2e5cd13796/go.mod h1:nJRRM7Aa9XVvygr3W9k6xGF46RWzr2zxF/iGoAIfA/g=
 github.com/filecoin-project/test-vectors/schema v0.0.1 h1:5fNF76nl4qolEvcIsjc0kUADlTMVHO73tW4kXXPnsus=
@@ -396,9 +395,8 @@ github.com/gxed/go-shellwords v1.0.3/go.mod h1:N7paucT91ByIjmVJHhvoarjoQnmsi3Jd3
 github.com/gxed/hashland/keccakpg v0.0.1/go.mod h1:kRzw3HkwxFU1mpmPP8v1WyQzwdGfmKFJ6tItnhQ67kU=
 github.com/gxed/hashland/murmur3 v0.0.1/go.mod h1:KjXop02n4/ckmZSnY2+HKcLud/tcmvhST0bie/0lS48=
 github.com/gxed/pubsub v0.0.0-20180201040156-26ebdf44f824/go.mod h1:OiEWyHgK+CWrmOlVquHaIK1vhpUJydC9m0Je6mhaiNE=
-github.com/hannahhoward/cbor-gen-for v0.0.0-20191218204337-9ab7b1bcc099/go.mod h1:WVPCl0HO/0RAL5+vBH2GMxBomlxBF70MAS78+Lu1//k=
-github.com/hannahhoward/cbor-gen-for v0.0.0-20200723175505-5892b522820a h1:wfqh5oiHXvn3Rk54xy8Cwqh+HnYihGnjMNzdNb3/ld0=
-github.com/hannahhoward/cbor-gen-for v0.0.0-20200723175505-5892b522820a/go.mod h1:jvfsLIxk0fY/2BKSQ1xf2406AKA5dwMmKKv0ADcOfN8=
+github.com/hannahhoward/cbor-gen-for v0.0.0-20200817222906-ea96cece81f1 h1:F9k+7wv5OIk1zcq23QpdiL0hfDuXPjuOmMNaC6fgQ0Q=
+github.com/hannahhoward/cbor-gen-for v0.0.0-20200817222906-ea96cece81f1/go.mod h1:jvfsLIxk0fY/2BKSQ1xf2406AKA5dwMmKKv0ADcOfN8=
 github.com/hannahhoward/go-pubsub v0.0.0-20200423002714-8d62886cc36e h1:3YKHER4nmd7b5qy5t0GWDTwSn4OyRgfAXSmo6VnryBY=
 github.com/hannahhoward/go-pubsub v0.0.0-20200423002714-8d62886cc36e/go.mod h1:I8h3MITA53gN9OnWGCgaMa0JWVRdXthWw4M3CPM54OY=
 github.com/hashicorp/consul/api v1.3.0/go.mod h1:MmDNSzIMUjNpY/mQ398R4bk2FnqQLoPndWW5VkKPlCE=
@@ -504,8 +502,8 @@ github.com/ipfs/go-filestore v1.0.0/go.mod h1:/XOCuNtIe2f1YPbiXdYvD0BKLA0JR1MgPi
 github.com/ipfs/go-fs-lock v0.0.6 h1:sn3TWwNVQqSeNjlWy6zQ1uUGAZrV3hPOyEA6y1/N2a0=
 github.com/ipfs/go-fs-lock v0.0.6/go.mod h1:OTR+Rj9sHiRubJh3dRhD15Juhd/+w6VPOY28L7zESmM=
 github.com/ipfs/go-graphsync v0.1.0/go.mod h1:jMXfqIEDFukLPZHqDPp8tJMbHO9Rmeb9CEGevngQbmE=
-github.com/ipfs/go-graphsync v0.1.2 h1:25Ll9kIXCE+DY0dicvfS3KMw+U5sd01b/FJbA7KAbhg=
-github.com/ipfs/go-graphsync v0.1.2/go.mod h1:sLXVXm1OxtE2XYPw62MuXCdAuNwkAdsbnfrmos5odbA=
+github.com/ipfs/go-graphsync v0.2.1 h1:MdehhqBSuTI2LARfKLkpYnt0mUrqHs/mtuDnESXHBfU=
+github.com/ipfs/go-graphsync v0.2.1/go.mod h1:gEBvJUNelzMkaRPJTpg/jaKN4AQW/7wDWu0K92D8o10=
 github.com/ipfs/go-hamt-ipld v0.1.1/go.mod h1:1EZCr2v0jlCnhpa+aZ0JZYp8Tt2w16+JJOAVz17YcDk=
 github.com/ipfs/go-ipfs-blockstore v0.0.1/go.mod h1:d3WClOmRQKFnJ0Jz/jj/zmksX0ma1gROTlovZKBmN08=
 github.com/ipfs/go-ipfs-blockstore v0.1.0/go.mod h1:5aD0AvHPi7mZc6Ci1WCAhiBQu2IsfTduLl+422H6Rqw=
@@ -609,14 +607,14 @@ github.com/ipfs/iptb v1.4.0 h1:YFYTrCkLMRwk/35IMyC6+yjoQSHTEcNcefBStLJzgvo=
 github.com/ipfs/iptb v1.4.0/go.mod h1:1rzHpCYtNp87/+hTxG5TfCVn/yMY3dKnLn8tBiMfdmg=
 github.com/ipfs/iptb-plugins v0.2.1 h1:au4HWn9/pRPbkxA08pDx2oRAs4cnbgQWgV0teYXuuGA=
 github.com/ipfs/iptb-plugins v0.2.1/go.mod h1:QXMbtIWZ+jRsW8a4h13qAKU7jcM7qaittO8wOsTP0Rs=
-github.com/ipld/go-car v0.1.1-0.20200526133713-1c7508d55aae h1:OV9dxl8iPMCOD8Vi/hvFwRh3JWPXqmkYSVxWr9JnEzM=
-github.com/ipld/go-car v0.1.1-0.20200526133713-1c7508d55aae/go.mod h1:2mvxpu4dKRnuH3mj5u6KW/tmRSCcXvy/KYiJ4nC6h4c=
+github.com/ipld/go-car v0.1.1-0.20200923150018-8cdef32e2da4 h1:6phjU3kXvCEWOZpu+Ob0w6DzgPFZmDLgLPxJhD8RxEY=
+github.com/ipld/go-car v0.1.1-0.20200923150018-8cdef32e2da4/go.mod h1:xrMEcuSq+D1vEwl+YAXsg/JfA98XGpXDwnkIL4Aimqw=
 github.com/ipld/go-ipld-prime v0.0.2-0.20200428162820-8b59dc292b8e/go.mod h1:uVIwe/u0H4VdKv3kaN1ck7uCb6yD9cFLS9/ELyXbsw8=
-github.com/ipld/go-ipld-prime v0.0.4-0.20200828224805-5ff8c8b0b6ef h1:/yPelt/0CuzZsmRkYzBBnJ499JnAOGaIaAXHujx96ic=
-github.com/ipld/go-ipld-prime v0.0.4-0.20200828224805-5ff8c8b0b6ef/go.mod h1:uVIwe/u0H4VdKv3kaN1ck7uCb6yD9cFLS9/ELyXbsw8=
+github.com/ipld/go-ipld-prime v0.5.1-0.20200828233916-988837377a7f h1:XpOuNQ5GbXxUcSukbQcW9jkE7REpaFGJU2/T00fo9kA=
+github.com/ipld/go-ipld-prime v0.5.1-0.20200828233916-988837377a7f/go.mod h1:0xEgdD6MKbZ1vF0GC+YcR/C4SQCAlRuOjIJ2i0HxqzM=
 github.com/ipld/go-ipld-prime-proto v0.0.0-20200428191222-c1ffdadc01e1/go.mod h1:OAV6xBmuTLsPZ+epzKkPB1e25FHk/vCtyatkdHcArLs=
-github.com/ipld/go-ipld-prime-proto v0.0.0-20200828231332-ae0aea07222b h1:ZtlW6pubN17TDaStlxgrwEXXwwUfJaXu9RobwczXato=
-github.com/ipld/go-ipld-prime-proto v0.0.0-20200828231332-ae0aea07222b/go.mod h1:OAV6xBmuTLsPZ+epzKkPB1e25FHk/vCtyatkdHcArLs=
+github.com/ipld/go-ipld-prime-proto v0.0.0-20200922192210-9a2bfd4440a6 h1:6Mq+tZGSEMEoJJ1NbJRhddeelkXZcU8yfH/ZRYUo/Es=
+github.com/ipld/go-ipld-prime-proto v0.0.0-20200922192210-9a2bfd4440a6/go.mod h1:3pHYooM9Ea65jewRwrb2u5uHZCNkNTe9ABsVB+SrkH0=
 github.com/ipsn/go-secp256k1 v0.0.0-20180726113642-9d62b9f0bc52 h1:QG4CGBqCeuBo6aZlGAamSkxWdgWfZGeE49eUOWJPA4c=
 github.com/ipsn/go-secp256k1 v0.0.0-20180726113642-9d62b9f0bc52/go.mod h1:fdg+/X9Gg4AsAIzWpEHwnqd+QY3b7lajxyjE1m4hkq4=
 github.com/jackpal/gateway v1.0.4/go.mod h1:lTpwd4ACLXmpyiCTRtfiNyVnUmqT9RivzCDQetPfnjA=
@@ -1362,7 +1360,6 @@ github.com/weaveworks/promrus v1.2.0/go.mod h1:SaE82+OJ91yqjrE1rsvBWVzNZKcHYFtMU
 github.com/whyrusleeping/base32 v0.0.0-20170828182744-c30ac30633cc/go.mod h1:r45hJU7yEoA81k6MWNhpMj/kms0n14dkzkxYHoB96UM=
 github.com/whyrusleeping/bencher v0.0.0-20190829221104-bb6607aa8bba h1:X4n8JG2e2biEZZXdBKt9HX7DN3bYGFUqljqqy0DqgnY=
 github.com/whyrusleeping/bencher v0.0.0-20190829221104-bb6607aa8bba/go.mod h1:CHQnYnQUEPydYCwuy8lmTHfGmdw9TKrhWV0xLx8l0oM=
-github.com/whyrusleeping/cbor-gen v0.0.0-20191212224538-d370462a7e8a/go.mod h1:xdlJQaiqipF0HW+Mzpg7XRM3fWbGvfgFlcppuvlkIvY=
 github.com/whyrusleeping/cbor-gen v0.0.0-20191216205031-b047b6acb3c0/go.mod h1:xdlJQaiqipF0HW+Mzpg7XRM3fWbGvfgFlcppuvlkIvY=
 github.com/whyrusleeping/cbor-gen v0.0.0-20200123233031-1cdf64d27158/go.mod h1:Xj/M2wWU+QdTdRbu/L/1dIZY8/Wb2K9pAhtroQuxJJI=
 github.com/whyrusleeping/cbor-gen v0.0.0-20200402171437-3d27c146c105/go.mod h1:Xj/M2wWU+QdTdRbu/L/1dIZY8/Wb2K9pAhtroQuxJJI=

lotuspond/spawn.go

@@ -11,6 +11,7 @@ import (
 	"sync/atomic"
 	"time"
 
+	"github.com/filecoin-project/lotus/chain/actors/policy"
 	"github.com/filecoin-project/lotus/chain/types"
 
 	"golang.org/x/xerrors"
@@ -18,7 +19,6 @@ import (
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
 	genesis2 "github.com/filecoin-project/lotus/chain/gen/genesis"
-	"github.com/filecoin-project/specs-actors/actors/builtin/miner"
 
 	"github.com/filecoin-project/lotus/chain/gen"
 	"github.com/filecoin-project/lotus/cmd/lotus-seed/seed"
@@ -26,9 +26,7 @@ import (
 )
 
 func init() {
-	miner.SupportedProofTypes = map[abi.RegisteredSealProof]struct{}{
-		abi.RegisteredSealProof_StackedDrg2KiBV1: {},
-	}
+	policy.SetSupportedProofTypes(abi.RegisteredSealProof_StackedDrg2KiBV1)
 }
 
 func (api *api) Spawn() (nodeInfo, error) {

markets/storageadapter/client.go

@@ -6,9 +6,9 @@ import (
 	"bytes"
 	"context"
 
-	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
-
 	"github.com/filecoin-project/go-state-types/big"
+	miner0 "github.com/filecoin-project/specs-actors/actors/builtin"
+	market0 "github.com/filecoin-project/specs-actors/actors/builtin/market"
 
 	"golang.org/x/xerrors"
 
@@ -20,6 +20,7 @@ import (
 	"github.com/filecoin-project/go-state-types/crypto"
 	"github.com/filecoin-project/go-state-types/exitcode"
 	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
 	"github.com/filecoin-project/lotus/chain/events"
 	"github.com/filecoin-project/lotus/chain/events/state"
 	"github.com/filecoin-project/lotus/chain/market"
@@ -29,8 +30,6 @@ import (
 	"github.com/filecoin-project/lotus/lib/sigs"
 	"github.com/filecoin-project/lotus/markets/utils"
 	"github.com/filecoin-project/lotus/node/impl/full"
-	"github.com/filecoin-project/specs-actors/actors/builtin"
-	samarket "github.com/filecoin-project/specs-actors/actors/builtin/market"
 	"github.com/ipfs/go-cid"
 )
 
@@ -102,10 +101,10 @@ func (c *ClientNodeAdapter) VerifySignature(ctx context.Context, sig crypto.Sign
 func (c *ClientNodeAdapter) AddFunds(ctx context.Context, addr address.Address, amount abi.TokenAmount) (cid.Cid, error) {
 	// (Provider Node API)
 	smsg, err := c.MpoolPushMessage(ctx, &types.Message{
-		To:     builtin.StorageMarketActorAddr,
+		To:     miner0.StorageMarketActorAddr,
 		From:   addr,
 		Value:  amount,
-		Method: builtin.MethodsMarket.AddBalance,
+		Method: miner0.MethodsMarket.AddBalance,
 	}, nil)
 	if err != nil {
 		return cid.Undef, err
@@ -156,15 +155,15 @@ func (c *ClientNodeAdapter) ValidatePublishedDeal(ctx context.Context, deal stor
 		return 0, xerrors.Errorf("deal wasn't published by storage provider: from=%s, provider=%s", pubmsg.From, deal.Proposal.Provider)
 	}
 
-	if pubmsg.To != builtin.StorageMarketActorAddr {
+	if pubmsg.To != miner0.StorageMarketActorAddr {
 		return 0, xerrors.Errorf("deal publish message wasn't set to StorageMarket actor (to=%s)", pubmsg.To)
 	}
 
-	if pubmsg.Method != builtin.MethodsMarket.PublishStorageDeals {
+	if pubmsg.Method != miner0.MethodsMarket.PublishStorageDeals {
 		return 0, xerrors.Errorf("deal publish message called incorrect method (method=%s)", pubmsg.Method)
 	}
 
-	var params samarket.PublishStorageDealsParams
+	var params market0.PublishStorageDealsParams
 	if err := params.UnmarshalCBOR(bytes.NewReader(pubmsg.Params)); err != nil {
 		return 0, err
 	}
@@ -196,7 +195,7 @@ func (c *ClientNodeAdapter) ValidatePublishedDeal(ctx context.Context, deal stor
 		return 0, xerrors.Errorf("deal publish failed: exit=%d", ret.ExitCode)
 	}
 
-	var res samarket.PublishStorageDealsReturn
+	var res market0.PublishStorageDealsReturn
 	if err := res.UnmarshalCBOR(bytes.NewReader(ret.Return)); err != nil {
 		return 0, err
 	}
@@ -274,7 +273,7 @@ func (c *ClientNodeAdapter) OnDealSectorCommitted(ctx context.Context, provider
 		}
 
 		switch msg.Method {
-		case builtin.MethodsMiner.PreCommitSector:
+		case miner0.MethodsMiner.PreCommitSector:
 			var params miner.SectorPreCommitInfo
 			if err := params.UnmarshalCBOR(bytes.NewReader(msg.Params)); err != nil {
 				return true, false, xerrors.Errorf("unmarshal pre commit: %w", err)
@@ -289,7 +288,7 @@ func (c *ClientNodeAdapter) OnDealSectorCommitted(ctx context.Context, provider
 			}
 
 			return true, false, nil
-		case builtin.MethodsMiner.ProveCommitSector:
+		case miner0.MethodsMiner.ProveCommitSector:
 			var params miner.ProveCommitSectorParams
 			if err := params.UnmarshalCBOR(bytes.NewReader(msg.Params)); err != nil {
 				return true, false, xerrors.Errorf("failed to unmarshal prove commit sector params: %w", err)
@@ -411,7 +410,7 @@ func (c *ClientNodeAdapter) OnDealExpiredOrSlashed(ctx context.Context, dealID a
 	return nil
 }
 
-func (c *ClientNodeAdapter) SignProposal(ctx context.Context, signer address.Address, proposal samarket.DealProposal) (*samarket.ClientDealProposal, error) {
+func (c *ClientNodeAdapter) SignProposal(ctx context.Context, signer address.Address, proposal market0.DealProposal) (*market0.ClientDealProposal, error) {
 	// TODO: output spec signed proposal
 	buf, err := cborutil.Dump(&proposal)
 	if err != nil {
@@ -428,7 +427,7 @@ func (c *ClientNodeAdapter) SignProposal(ctx context.Context, signer address.Add
 		return nil, err
 	}
 
-	return &samarket.ClientDealProposal{
+	return &market0.ClientDealProposal{
 		Proposal:        proposal,
 		ClientSignature: *sig,
 	}, nil

markets/storageadapter/provider.go

@@ -8,25 +8,27 @@ import (
 	"io"
 	"time"
 
-	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
-
 	"github.com/ipfs/go-cid"
 	logging "github.com/ipfs/go-log/v2"
 	"golang.org/x/xerrors"
 
+	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
+	market0 "github.com/filecoin-project/specs-actors/actors/builtin/market"
+
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-fil-markets/shared"
 	"github.com/filecoin-project/go-fil-markets/storagemarket"
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/crypto"
 	"github.com/filecoin-project/go-state-types/exitcode"
-	"github.com/filecoin-project/specs-actors/actors/builtin"
-	"github.com/filecoin-project/specs-actors/actors/builtin/market"
 
 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain/actors"
 	"github.com/filecoin-project/lotus/chain/events"
+
+	"github.com/filecoin-project/lotus/chain/actors/builtin/market"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
 	"github.com/filecoin-project/lotus/chain/events/state"
 	"github.com/filecoin-project/lotus/chain/types"
 	sealing "github.com/filecoin-project/lotus/extern/storage-sealing"
@@ -67,8 +69,8 @@ func (n *ProviderNodeAdapter) PublishDeals(ctx context.Context, deal storagemark
 		return cid.Undef, err
 	}
 
-	params, err := actors.SerializeParams(&market.PublishStorageDealsParams{
-		Deals: []market.ClientDealProposal{deal.ClientDealProposal},
+	params, err := actors.SerializeParams(&market0.PublishStorageDealsParams{
+		Deals: []market0.ClientDealProposal{deal.ClientDealProposal},
 	})
 
 	if err != nil {
@@ -77,10 +79,10 @@ func (n *ProviderNodeAdapter) PublishDeals(ctx context.Context, deal storagemark
 
 	// TODO: We may want this to happen after fetching data
 	smsg, err := n.MpoolPushMessage(ctx, &types.Message{
-		To:     builtin.StorageMarketActorAddr,
+		To:     market.Address,
 		From:   mi.Worker,
 		Value:  types.NewInt(0),
-		Method: builtin.MethodsMarket.PublishStorageDeals,
+		Method: builtin0.MethodsMarket.PublishStorageDeals,
 		Params: params,
 	}, nil)
 	if err != nil {
@@ -177,10 +179,10 @@ func (n *ProviderNodeAdapter) EnsureFunds(ctx context.Context, addr, wallet addr
 func (n *ProviderNodeAdapter) AddFunds(ctx context.Context, addr address.Address, amount abi.TokenAmount) (cid.Cid, error) {
 	// (Provider Node API)
 	smsg, err := n.MpoolPushMessage(ctx, &types.Message{
-		To:     builtin.StorageMarketActorAddr,
+		To:     market.Address,
 		From:   addr,
 		Value:  amount,
-		Method: builtin.MethodsMarket.AddBalance,
+		Method: builtin0.MethodsMarket.AddBalance,
 	}, nil)
 	if err != nil {
 		return cid.Undef, err
@@ -302,7 +304,7 @@ func (n *ProviderNodeAdapter) OnDealSectorCommitted(ctx context.Context, provide
 		}
 
 		switch msg.Method {
-		case builtin.MethodsMiner.PreCommitSector:
+		case builtin0.MethodsMiner.PreCommitSector:
 			var params miner.SectorPreCommitInfo
 			if err := params.UnmarshalCBOR(bytes.NewReader(msg.Params)); err != nil {
 				return true, false, xerrors.Errorf("unmarshal pre commit: %w", err)
@@ -317,7 +319,7 @@ func (n *ProviderNodeAdapter) OnDealSectorCommitted(ctx context.Context, provide
 			}
 
 			return true, false, nil
-		case builtin.MethodsMiner.ProveCommitSector:
+		case builtin0.MethodsMiner.ProveCommitSector:
 			var params miner.ProveCommitSectorParams
 			if err := params.UnmarshalCBOR(bytes.NewReader(msg.Params)); err != nil {
 				return true, false, xerrors.Errorf("failed to unmarshal prove commit sector params: %w", err)

miner/miner.go

@@ -9,7 +9,7 @@ import (
 	"sync"
 	"time"
 
-	"github.com/filecoin-project/specs-actors/actors/runtime/proof"
+	proof0 "github.com/filecoin-project/specs-actors/actors/runtime/proof"
 
 	"github.com/filecoin-project/lotus/chain/gen/slashfilter"
 
@@ -149,7 +149,7 @@ func (m *Miner) mine(ctx context.Context) {
 	defer span.End()
 
 	var lastBase MiningBase
-
+minerLoop:
 	for {
 		select {
 		case <-m.stop:
@@ -171,7 +171,7 @@ func (m *Miner) mine(ctx context.Context) {
 			if err != nil {
 				log.Errorf("failed to get best mining candidate: %s", err)
 				if !m.niceSleep(time.Second * 5) {
-					break
+					continue minerLoop
 				}
 				continue
 			}
@@ -203,7 +203,7 @@ func (m *Miner) mine(ctx context.Context) {
 			if err != nil {
 				log.Errorf("failed getting beacon entry: %s", err)
 				if !m.niceSleep(time.Second) {
-					break
+					continue minerLoop
 				}
 				continue
 			}
@@ -214,7 +214,7 @@ func (m *Miner) mine(ctx context.Context) {
 		if base.TipSet.Equals(lastBase.TipSet) && lastBase.NullRounds == base.NullRounds {
 			log.Warnf("BestMiningCandidate from the previous round: %s (nulls:%d)", lastBase.TipSet.Cids(), lastBase.NullRounds)
 			if !m.niceSleep(time.Duration(build.BlockDelaySecs) * time.Second) {
-				break
+				continue minerLoop
 			}
 			continue
 		}
@@ -225,7 +225,7 @@ func (m *Miner) mine(ctx context.Context) {
 		if err != nil {
 			log.Errorf("mining block failed: %+v", err)
 			if !m.niceSleep(time.Second) {
-				break
+				continue minerLoop
 			}
 			onDone(false, 0, err)
 			continue
@@ -489,7 +489,7 @@ func (m *Miner) computeTicket(ctx context.Context, brand *types.BeaconEntry, bas
 }
 
 func (m *Miner) createBlock(base *MiningBase, addr address.Address, ticket *types.Ticket,
-	eproof *types.ElectionProof, bvals []types.BeaconEntry, wpostProof []proof.PoStProof, msgs []*types.SignedMessage) (*types.BlockMsg, error) {
+	eproof *types.ElectionProof, bvals []types.BeaconEntry, wpostProof []proof0.PoStProof, msgs []*types.SignedMessage) (*types.BlockMsg, error) {
 	uts := base.TipSet.MinTimestamp() + build.BlockDelaySecs*(uint64(base.NullRounds)+1)
 
 	nheight := base.TipSet.Height() + base.NullRounds + 1

node/impl/client/client.go

@@ -711,7 +711,7 @@ func (a *API) ClientGenCar(ctx context.Context, ref api.FileRef, outputPath stri
 
 	// TODO: does that defer mean to remove the whole blockstore?
 	defer bufferedDS.Remove(ctx, c) //nolint:errcheck
-	ssb := builder.NewSelectorSpecBuilder(basicnode.Style.Any)
+	ssb := builder.NewSelectorSpecBuilder(basicnode.Prototype.Any)
 
 	// entire DAG selector
 	allSelector := ssb.ExploreRecursive(selector.RecursionLimitNone(),

node/impl/full/chain.go

@@ -197,6 +197,10 @@ func (a *ChainAPI) ChainReadObj(ctx context.Context, obj cid.Cid) ([]byte, error
 	return blk.RawData(), nil
 }
 
+func (a *ChainAPI) ChainDeleteObj(ctx context.Context, obj cid.Cid) error {
+	return a.Chain.Blockstore().DeleteBlock(obj)
+}
+
 func (a *ChainAPI) ChainHasObj(ctx context.Context, obj cid.Cid) (bool, error) {
 	return a.Chain.Blockstore().Has(obj)
 }