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

Lotus version 0.7.1
2020-09-17 21:32:04 -04:00 · 2020-09-17 21:31:47 -04:00 · 2020-09-18 03:14:05 +02:00 · 2020-09-18 03:00:31 +02:00 · 2020-09-18 02:40:01 +02:00 · 2020-09-18 02:39:08 +02:00
171 changed files with 7286 additions and 1643 deletions
@@ -225,12 +225,17 @@ jobs:
                  cd extern/test-vectors
                  git fetch
                  git checkout origin/<< parameters.vectors-branch >>
-            - run:
-                name: go get vectors branch
-                command: go get github.com/filecoin-project/test-vectors@<< parameters.vectors-branch >>
      - go/install-gotestsum:
          gobin: $HOME/.local/bin
          version: 0.5.2
+      - run:
+          name: install statediff globally
+          command: |
+            ## statediff is optional; we succeed even if compilation fails.
+            mkdir -p /tmp/statediff
+            git clone https://github.com/filecoin-project/statediff.git /tmp/statediff
+            cd /tmp/statediff
+            go install ./cmd/statediff || exit 0
      - run:
          name: go test
          environment:
@@ -249,6 +254,25 @@ jobs:
          path: /tmp/test-reports
      - store_artifacts:
          path: /tmp/test-artifacts/conformance-coverage.html
+  build-lotus-soup:
+    description: |
+      Compile `lotus-soup` Testground test plan using the current version of Lotus.
+    parameters:
+      <<: *test-params
+    executor: << parameters.executor >>
+    steps:
+      - install-deps
+      - prepare
+      - run: cd extern/oni && git submodule sync
+      - run: cd extern/oni && git submodule update --init
+      - run: cd extern/filecoin-ffi && make
+      - run:
+          name: "replace lotus, filecoin-ffi, blst and fil-blst deps"
+          command: cd extern/oni/lotus-soup && go mod edit -replace github.com/filecoin-project/lotus=../../../ && go mod edit -replace github.com/filecoin-project/filecoin-ffi=../../filecoin-ffi && go mod edit -replace github.com/supranational/blst=../../fil-blst/blst && go mod edit -replace github.com/filecoin-project/fil-blst=../../fil-blst
+      - run:
+          name: "build lotus-soup testplan"
+          command: pushd extern/oni/lotus-soup && go build -tags=testground .
+

  build-macos:
    description: build darwin lotus binary
@@ -395,7 +419,8 @@ workflows:
  version: 2.1
  ci:
    jobs:
-      - lint-all
+      - lint-all:
+          concurrency: "16"   # expend all docker 2xlarge CPUs.
      - mod-tidy-check
      - gofmt
      - cbor-gen-check
@@ -422,6 +447,7 @@ workflows:
          test-suite-name: conformance-bleeding-edge
          packages: "./conformance"
          vectors-branch: master
+      - build-lotus-soup
      - build-debug
      - build-all:
          requires:
@@ -0,0 +1,15 @@
+## filecoin-project/lotus CODEOWNERS
+## Refer to https://docs.github.com/en/github/creating-cloning-and-archiving-repositories/about-code-owners.
+##
+## These users or groups will be automatically assigned as reviewers every time
+## a PR is submitted that modifies code in the specified locations.
+##
+## The Lotus repo configuration requires that at least ONE codeowner approves
+## the PR before merging.
+
+### Global owners.
+*                       @magik6k @whyrusleeping @Kubuxu
+
+### Conformance testing.
+conformance/            @raulk
+extern/test-vectors     @raulk
@@ -10,6 +10,8 @@
 /lotus-fountain
 /lotus-stats
 /lotus-bench
+/lotus-gateway
+/lotus-pcr
 /bench.json
 /lotuspond/front/node_modules
 /lotuspond/front/build
@@ -8,3 +8,9 @@
 [submodule "extern/test-vectors"]
 	path = extern/test-vectors
 	url = https://github.com/filecoin-project/test-vectors.git
+[submodule "extern/fil-blst"]
+	path = extern/fil-blst
+	url = https://github.com/filecoin-project/fil-blst.git
+[submodule "extern/oni"]
+	path = extern/oni
+	url = https://github.com/filecoin-project/oni
@@ -1,5 +1,131 @@
 # Lotus changelog

+# 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.
+
+## Changes
+
+#### Some notable improvements: 
+
+- Correctly construct params for `SubmitWindowedPoSt` messages (https://github.com/filecoin-project/lotus/pull/3909)
+- Skip sectors correctly for Window PoSt (https://github.com/filecoin-project/lotus/pull/3839)
+- Split window PoST submission into multiple messages (https://github.com/filecoin-project/lotus/pull/3689)
+- Improve journal coverage (https://github.com/filecoin-project/lotus/pull/2455)
+- Allow retrievals while sealing (https://github.com/filecoin-project/lotus/pull/3778)
+- Don't prune locally published messages (https://github.com/filecoin-project/lotus/pull/3772)
+- Add get-ask, set-ask retrieval commands (https://github.com/filecoin-project/lotus/pull/3886)
+- Consistently name winning and window post in logs (https://github.com/filecoin-project/lotus/pull/3873))
+- Add auto flag to mpool replace (https://github.com/filecoin-project/lotus/pull/3752))
+
+#### Dependencies
+
+- Upgrade markets to `v0.6.1` (https://github.com/filecoin-project/lotus/pull/3906)
+- Upgrade specs-actors to `v0.9.10` (https://github.com/filecoin-project/lotus/pull/3846)
+- Upgrade badger (https://github.com/filecoin-project/lotus/pull/3739)
+
+# 0.7.0 / 2020-09-10
+
+This consensus-breaking release of Lotus is designed to test a network upgrade on the space race testnet. The changes that break consensus are:
+
+- Upgrading the Drand network used from the test Drand network to the League of Entropy main drand network. This is the same Drand network that will be used in the Filecoin mainnet.
+- Upgrading to specs-actors v0.9.8, which adds a new method to the Multisig actor.
+
+## Changes
+
+#### Core Lotus
+
+- Fix IsAncestorOf (https://github.com/filecoin-project/lotus/pull/3717)
+- Update to specs-actors v0.9.8 (https://github.com/filecoin-project/lotus/pull/3725)
+- Increase chain throughput by 20% (https://github.com/filecoin-project/lotus/pull/3732)
+- Updare to go-libp2p-pubsub `master` (https://github.com/filecoin-project/lotus/pull/3735)
+- Drand upgrade (https://github.com/filecoin-project/lotus/pull/3670)
+- Multisig API additions (https://github.com/filecoin-project/lotus/pull/3590)
+
+#### Storage Miner 
+
+- Increase the number of times precommit2 is attempted before moving back to precommit1 (https://github.com/filecoin-project/lotus/pull/3720)
+
+#### Message pool
+
+- Relax mpool add strictness checks for local pushes (https://github.com/filecoin-project/lotus/pull/3724)
+
+
+#### Maintenance
+
+- Fix devnets (https://github.com/filecoin-project/lotus/pull/3712)
+- Fix(chainwatch): compare prev miner with cur miner (https://github.com/filecoin-project/lotus/pull/3715)
+- CI: fix statediff build; make optional (https://github.com/filecoin-project/lotus/pull/3729)
+- Feat: Chaos abort (https://github.com/filecoin-project/lotus/pull/3733)
+
+## Contributors
+
+The following contributors had commits go into this release.
+We are grateful for every contribution!
+
+| Contributor        | Commits | Lines ±       |
+|--------------------|---------|---------------|
+| arajasek           | 28      | +1144/-239    |
+| Kubuxu             | 19      | +452/-261     |
+| whyrusleeping      | 13      | +456/-87      |
+| vyzo               | 11      | +318/-20      |
+| raulk              | 10      | +1289/-350    |
+| magik6k            | 6       | +188/-55      |
+| dirkmc             | 3       | +31/-8        |
+| alanshaw           | 3       | +176/-37      |
+| Stebalien          | 2       | +9/-12        |
+| lanzafame          | 1       | +1/-1         |
+| frrist             | 1       | +1/-1         |
+| mishmosh           | 1       | +1/-1         |
+| nonsense           | 1       | +1/-0         |
+
+# 0.6.2 / 2020-09-09
+
+This release introduces some critical fixes to message selection and gas estimation logic. It also adds the ability for nodes to mark a certain tipset as checkpointed, as well as various minor improvements and bugfixes.
+
+## Changes
+
+#### Messagepool 
+
+- Warn when optimal selection fails to pack a block and we fall back to random selection (https://github.com/filecoin-project/lotus/pull/3708)
+- Add basic command for printing gas performance of messages in the mpool (https://github.com/filecoin-project/lotus/pull/3701)
+- Adjust optimal selection to always try to fill blocks (https://github.com/filecoin-project/lotus/pull/3685)
+- Fix very minor bug in repub baseFeeLowerBound (https://github.com/filecoin-project/lotus/pull/3663)
+- Add an auto flag to mpool replace (https://github.com/filecoin-project/lotus/pull/3676)
+- Fix mpool optimal selection packing failure (https://github.com/filecoin-project/lotus/pull/3698)
+
+#### Core Lotus
+
+- Don't use latency as initital estimate for blocksync (https://github.com/filecoin-project/lotus/pull/3648)
+- Add niceSleep 1 second when drand errors (https://github.com/filecoin-project/lotus/pull/3664)
+- Fix isChainNearSync check in block validator (https://github.com/filecoin-project/lotus/pull/3650)
+- Add peer to peer manager before fetching the tipset (https://github.com/filecoin-project/lotus/pull/3667)
+- Add StageFetchingMessages to sync status (https://github.com/filecoin-project/lotus/pull/3668)
+- Pass tipset through upgrade logic (https://github.com/filecoin-project/lotus/pull/3673)
+- Allow nodes to mark tipsets as checkpointed (https://github.com/filecoin-project/lotus/pull/3680)
+- Remove hard-coded late-fee in window PoSt (https://github.com/filecoin-project/lotus/pull/3702)
+- Gas: Fix median calc (https://github.com/filecoin-project/lotus/pull/3686)
+
+#### Storage
+
+- Storage manager: bail out with an error if unsealed cid is undefined (https://github.com/filecoin-project/lotus/pull/3655)
+- Storage: return true from Sealer.ReadPiece() on success (https://github.com/filecoin-project/lotus/pull/3657)
+
+#### Maintenance
+
+- Resolve lotus, test-vectors, statediff dependency cycle (https://github.com/filecoin-project/lotus/pull/3688)
+- Paych: add docs on how to use paych status (https://github.com/filecoin-project/lotus/pull/3690)
+- Initial CODEOWNERS (https://github.com/filecoin-project/lotus/pull/3691)
+
+# 0.6.1 / 2020-09-08
+
+This optional release introduces a minor improvement to the sync process, ensuring nodes don't fall behind and then resync.
+
+## Changes
+
+- Update `test-vectors` (https://github.com/filecoin-project/lotus/pull/3645)
+- Revert "only subscribe to pubsub topics once we are synced" (https://github.com/filecoin-project/lotus/pull/3643)
+
 # 0.6.0 / 2020-09-07

 This consensus-breaking release of Lotus is designed to test a network upgrade on the space race testnet. The changes that break consensus are:
@@ -92,6 +92,12 @@ lotus-shed: $(BUILD_DEPS)
 .PHONY: lotus-shed
 BINS+=lotus-shed

+lotus-gateway: $(BUILD_DEPS)
+	rm -f lotus-gateway
+	go build $(GOFLAGS) -o lotus-gateway ./cmd/lotus-gateway
+.PHONY: lotus-gateway
+BINS+=lotus-gateway
+
 build: lotus lotus-miner lotus-worker
 	@[[ $$(type -P "lotus") ]] && echo "Caution: you have \
 an existing lotus binary in your PATH. This may cause problems if you don't run 'sudo make install'" || true
@@ -2,8 +2,11 @@ package api

 import (
 	"context"
+	"fmt"
 	"time"

+	"github.com/filecoin-project/go-state-types/dline"
+
 	"github.com/filecoin-project/specs-actors/actors/runtime/proof"

 	"github.com/ipfs/go-cid"
@@ -115,7 +118,8 @@ type FullNode interface {
 	// The exported chain data includes the header chain from the given tipset
 	// back to genesis, the entire genesis state, and the most recent 'nroots'
 	// state trees.
-	ChainExport(ctx context.Context, nroots abi.ChainEpoch, tsk types.TipSetKey) (<-chan []byte, error)
+	// If oldmsgskip is set, messages from before the requested roots are also not included.
+	ChainExport(ctx context.Context, nroots abi.ChainEpoch, oldmsgskip bool, tsk types.TipSetKey) (<-chan []byte, error)

 	// MethodGroup: Beacon
 	// The Beacon method group contains methods for interacting with the random beacon (DRAND)
@@ -156,10 +160,16 @@ type FullNode interface {
 	// yet synced block headers.
 	SyncIncomingBlocks(ctx context.Context) (<-chan *types.BlockHeader, error)

+	// SyncCheckpoint marks a blocks as checkpointed, meaning that it won't ever fork away from it.
+	SyncCheckpoint(ctx context.Context, tsk types.TipSetKey) error
+
 	// SyncMarkBad marks a blocks as bad, meaning that it won't ever by synced.
 	// Use with extreme caution.
 	SyncMarkBad(ctx context.Context, bcid cid.Cid) error

+	// SyncUnmarkBad unmarks a blocks as bad, making it possible to be validated and synced again.
+	SyncUnmarkBad(ctx context.Context, bcid cid.Cid) error
+
 	// SyncCheckBad checks if a block was marked as bad, and if it was, returns
 	// the reason.
 	SyncCheckBad(ctx context.Context, bcid cid.Cid) (string, error)
@@ -311,7 +321,7 @@ type FullNode interface {
 	StateMinerActiveSectors(context.Context, address.Address, types.TipSetKey) ([]*ChainSectorInfo, 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) (*miner.DeadlineInfo, error)
+	StateMinerProvingDeadline(context.Context, address.Address, types.TipSetKey) (*dline.Info, error)
 	// StateMinerPower returns the power of the indicated miner
 	StateMinerPower(context.Context, address.Address, types.TipSetKey) (*MinerPower, error)
 	// StateMinerInfo returns info about the indicated miner
@@ -344,6 +354,8 @@ type FullNode interface {
 	StateSectorPartition(ctx context.Context, maddr address.Address, sectorNumber abi.SectorNumber, tok types.TipSetKey) (*SectorLocation, error)
 	// StateSearchMsg searches for a message in the chain, and returns its receipt and the tipset where it was executed
 	StateSearchMsg(context.Context, cid.Cid) (*MsgLookup, error)
+	// StateMsgGasCost searches for a message in the chain, and returns details of the messages gas costs, including the penalty and miner tip
+	StateMsgGasCost(context.Context, cid.Cid, types.TipSetKey) (*MsgGasCost, error)
 	// StateWaitMsg looks back in the chain for a message. If not found, it blocks until the
 	// message arrives on chain, and gets to the indicated confidence depth.
 	StateWaitMsg(ctx context.Context, cid cid.Cid, confidence uint64) (*MsgLookup, error)
@@ -390,6 +402,9 @@ type FullNode interface {

 	// MsigGetAvailableBalance returns the portion of a multisig's balance that can be withdrawn or spent
 	MsigGetAvailableBalance(context.Context, address.Address, types.TipSetKey) (types.BigInt, error)
+	// MsigGetVested returns the amount of FIL that vested in a multisig in a certain period.
+	// It takes the following params: <multisig address>, <start epoch>, <end epoch>
+	MsigGetVested(context.Context, address.Address, types.TipSetKey, types.TipSetKey) (types.BigInt, error)
 	// MsigCreate creates a multisig wallet
 	// It takes the following params: <required number of senders>, <approving addresses>, <unlock duration>
 	//<initial balance>, <sender address of the create msg>, <gas price>
@@ -406,17 +421,29 @@ type FullNode interface {
 	// It takes the following params: <multisig address>, <proposed message ID>, <recipient address>, <value to transfer>,
 	// <sender address of the cancel msg>, <method to call in the proposed message>, <params to include in the proposed message>
 	MsigCancel(context.Context, address.Address, uint64, address.Address, types.BigInt, address.Address, uint64, []byte) (cid.Cid, error)
+	// MsigAddPropose proposes adding a signer in the multisig
+	// It takes the following params: <multisig address>, <sender address of the propose msg>,
+	// <new signer>, <whether the number of required signers should be increased>
+	MsigAddPropose(context.Context, address.Address, address.Address, address.Address, bool) (cid.Cid, error)
+	// MsigAddApprove approves a previously proposed AddSigner message
+	// It takes the following params: <multisig address>, <sender address of the approve msg>, <proposed message ID>,
+	// <proposer address>, <new signer>, <whether the number of required signers should be increased>
+	MsigAddApprove(context.Context, address.Address, address.Address, uint64, address.Address, address.Address, bool) (cid.Cid, error)
+	// MsigAddCancel cancels a previously proposed AddSigner message
+	// It takes the following params: <multisig address>, <sender address of the cancel msg>, <proposed message ID>,
+	// <new signer>, <whether the number of required signers should be increased>
+	MsigAddCancel(context.Context, address.Address, address.Address, uint64, address.Address, bool) (cid.Cid, error)
 	// MsigSwapPropose proposes swapping 2 signers in the multisig
 	// It takes the following params: <multisig address>, <sender address of the propose msg>,
-	// <old signer> <new signer>
+	// <old signer>, <new signer>
 	MsigSwapPropose(context.Context, address.Address, address.Address, address.Address, address.Address) (cid.Cid, error)
 	// MsigSwapApprove approves a previously proposed SwapSigner
 	// It takes the following params: <multisig address>, <sender address of the approve msg>, <proposed message ID>,
-	// <proposer address>, <old signer> <new signer>
+	// <proposer address>, <old signer>, <new signer>
 	MsigSwapApprove(context.Context, address.Address, address.Address, uint64, address.Address, address.Address, address.Address) (cid.Cid, error)
 	// MsigSwapCancel cancels a previously proposed SwapSigner message
 	// It takes the following params: <multisig address>, <sender address of the cancel msg>, <proposed message ID>,
-	// <old signer> <new signer>
+	// <old signer>, <new signer>
 	MsigSwapCancel(context.Context, address.Address, address.Address, uint64, address.Address, address.Address) (cid.Cid, error)

 	MarketEnsureAvailable(context.Context, address.Address, address.Address, types.BigInt) (cid.Cid, error)
@@ -427,8 +454,8 @@ type FullNode interface {

 	PaychGet(ctx context.Context, from, to address.Address, amt types.BigInt) (*ChannelInfo, error)
 	PaychGetWaitReady(context.Context, cid.Cid) (address.Address, error)
-	PaychAvailableFunds(ch address.Address) (*ChannelAvailableFunds, error)
-	PaychAvailableFundsByFromTo(from, to address.Address) (*ChannelAvailableFunds, error)
+	PaychAvailableFunds(ctx context.Context, ch address.Address) (*ChannelAvailableFunds, error)
+	PaychAvailableFundsByFromTo(ctx context.Context, from, to address.Address) (*ChannelAvailableFunds, error)
 	PaychList(context.Context) ([]address.Address, error)
 	PaychStatus(context.Context, address.Address) (*PaychStatus, error)
 	PaychSettle(context.Context, address.Address) (cid.Cid, error)
@@ -506,6 +533,17 @@ type MsgLookup struct {
 	Height    abi.ChainEpoch
 }

+type MsgGasCost struct {
+	Message            cid.Cid // Can be different than requested, in case it was replaced, but only gas values changed
+	GasUsed            abi.TokenAmount
+	BaseFeeBurn        abi.TokenAmount
+	OverEstimationBurn abi.TokenAmount
+	MinerPenalty       abi.TokenAmount
+	MinerTip           abi.TokenAmount
+	Refund             abi.TokenAmount
+	TotalCost          abi.TokenAmount
+}
+
 type BlockMessages struct {
 	BlsMessages   []*types.Message
 	SecpkMessages []*types.SignedMessage
@@ -709,8 +747,28 @@ const (
 	StageMessages
 	StageSyncComplete
 	StageSyncErrored
+	StageFetchingMessages
 )

+func (v SyncStateStage) String() string {
+	switch v {
+	case StageHeaders:
+		return "header sync"
+	case StagePersistHeaders:
+		return "persisting headers"
+	case StageMessages:
+		return "message sync"
+	case StageSyncComplete:
+		return "complete"
+	case StageSyncErrored:
+		return "error"
+	case StageFetchingMessages:
+		return "fetching messages"
+	default:
+		return fmt.Sprintf("<unknown: %d>", v)
+	}
+}
+
 type MpoolChange int

 const (
@@ -5,6 +5,8 @@ import (
 	"io"
 	"time"

+	"github.com/filecoin-project/go-state-types/dline"
+
 	"github.com/ipfs/go-cid"
 	metrics "github.com/libp2p/go-libp2p-core/metrics"
 	"github.com/libp2p/go-libp2p-core/network"
@@ -93,7 +95,7 @@ type FullNodeStruct struct {
 		ChainGetNode                  func(ctx context.Context, p string) (*api.IpldObject, error)                                                       `perm:"read"`
 		ChainGetMessage               func(context.Context, cid.Cid) (*types.Message, error)                                                             `perm:"read"`
 		ChainGetPath                  func(context.Context, types.TipSetKey, types.TipSetKey) ([]*api.HeadChange, error)                                 `perm:"read"`
-		ChainExport                   func(context.Context, abi.ChainEpoch, types.TipSetKey) (<-chan []byte, error)                                      `perm:"read"`
+		ChainExport                   func(context.Context, abi.ChainEpoch, bool, types.TipSetKey) (<-chan []byte, error)                                `perm:"read"`

 		BeaconGetEntry func(ctx context.Context, epoch abi.ChainEpoch) (*types.BeaconEntry, error) `perm:"read"`

@@ -105,7 +107,9 @@ type FullNodeStruct struct {
 		SyncState          func(context.Context) (*api.SyncState, error)                `perm:"read"`
 		SyncSubmitBlock    func(ctx context.Context, blk *types.BlockMsg) error         `perm:"write"`
 		SyncIncomingBlocks func(ctx context.Context) (<-chan *types.BlockHeader, error) `perm:"read"`
+		SyncCheckpoint     func(ctx context.Context, key types.TipSetKey) error         `perm:"admin"`
 		SyncMarkBad        func(ctx context.Context, bcid cid.Cid) error                `perm:"admin"`
+		SyncUnmarkBad      func(ctx context.Context, bcid cid.Cid) error                `perm:"admin"`
 		SyncCheckBad       func(ctx context.Context, bcid cid.Cid) (string, error)      `perm:"read"`

 		MpoolGetConfig func(context.Context) (*types.MpoolConfig, error) `perm:"read"`
@@ -160,7 +164,7 @@ type FullNodeStruct struct {
 		StateNetworkName                   func(context.Context) (dtypes.NetworkName, error)                                                                   `perm:"read"`
 		StateMinerSectors                  func(context.Context, address.Address, *bitfield.BitField, bool, types.TipSetKey) ([]*api.ChainSectorInfo, error)   `perm:"read"`
 		StateMinerActiveSectors            func(context.Context, address.Address, types.TipSetKey) ([]*api.ChainSectorInfo, error)                             `perm:"read"`
-		StateMinerProvingDeadline          func(context.Context, address.Address, types.TipSetKey) (*miner.DeadlineInfo, 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) (api.MinerInfo, error)                                      `perm:"read"`
 		StateMinerDeadlines                func(context.Context, address.Address, types.TipSetKey) ([]*miner.Deadline, error)                                  `perm:"read"`
@@ -179,6 +183,7 @@ type FullNodeStruct struct {
 		StateReplay                        func(context.Context, types.TipSetKey, cid.Cid) (*api.InvocResult, error)                                           `perm:"read"`
 		StateGetActor                      func(context.Context, address.Address, types.TipSetKey) (*types.Actor, error)                                       `perm:"read"`
 		StateReadState                     func(context.Context, address.Address, types.TipSetKey) (*api.ActorState, error)                                    `perm:"read"`
+		StateMsgGasCost                    func(context.Context, cid.Cid, types.TipSetKey) (*api.MsgGasCost, error)                                            `perm:"read"`
 		StateWaitMsg                       func(ctx context.Context, cid cid.Cid, confidence uint64) (*api.MsgLookup, error)                                   `perm:"read"`
 		StateSearchMsg                     func(context.Context, cid.Cid) (*api.MsgLookup, error)                                                              `perm:"read"`
 		StateListMiners                    func(context.Context, types.TipSetKey) ([]address.Address, error)                                                   `perm:"read"`
@@ -199,10 +204,14 @@ type FullNodeStruct struct {
 		StateCirculatingSupply             func(context.Context, types.TipSetKey) (api.CirculatingSupply, error)                                               `perm:"read"`

 		MsigGetAvailableBalance func(context.Context, address.Address, types.TipSetKey) (types.BigInt, error)                                                                    `perm:"read"`
+		MsigGetVested           func(context.Context, address.Address, types.TipSetKey, types.TipSetKey) (types.BigInt, error)                                                   `perm:"read"`
 		MsigCreate              func(context.Context, uint64, []address.Address, abi.ChainEpoch, types.BigInt, address.Address, types.BigInt) (cid.Cid, error)                   `perm:"sign"`
 		MsigPropose             func(context.Context, address.Address, address.Address, types.BigInt, address.Address, uint64, []byte) (cid.Cid, error)                          `perm:"sign"`
 		MsigApprove             func(context.Context, address.Address, uint64, address.Address, address.Address, types.BigInt, address.Address, uint64, []byte) (cid.Cid, error) `perm:"sign"`
 		MsigCancel              func(context.Context, address.Address, uint64, address.Address, types.BigInt, address.Address, uint64, []byte) (cid.Cid, error)                  `perm:"sign"`
+		MsigAddPropose          func(context.Context, address.Address, address.Address, address.Address, bool) (cid.Cid, error)                                                  `perm:"sign"`
+		MsigAddApprove          func(context.Context, address.Address, address.Address, uint64, address.Address, address.Address, bool) (cid.Cid, error)                         `perm:"sign"`
+		MsigAddCancel           func(context.Context, address.Address, address.Address, uint64, address.Address, bool) (cid.Cid, error)                                          `perm:"sign"`
 		MsigSwapPropose         func(context.Context, address.Address, address.Address, address.Address, address.Address) (cid.Cid, error)                                       `perm:"sign"`
 		MsigSwapApprove         func(context.Context, address.Address, address.Address, uint64, address.Address, address.Address, address.Address) (cid.Cid, error)              `perm:"sign"`
 		MsigSwapCancel          func(context.Context, address.Address, address.Address, uint64, address.Address, address.Address) (cid.Cid, error)                               `perm:"sign"`
@@ -211,8 +220,8 @@ type FullNodeStruct struct {

 		PaychGet                    func(ctx context.Context, from, to address.Address, amt types.BigInt) (*api.ChannelInfo, error)           `perm:"sign"`
 		PaychGetWaitReady           func(context.Context, cid.Cid) (address.Address, error)                                                   `perm:"sign"`
-		PaychAvailableFunds         func(address.Address) (*api.ChannelAvailableFunds, error)                                                 `perm:"sign"`
-		PaychAvailableFundsByFromTo func(address.Address, address.Address) (*api.ChannelAvailableFunds, error)                                `perm:"sign"`
+		PaychAvailableFunds         func(context.Context, address.Address) (*api.ChannelAvailableFunds, error)                                `perm:"sign"`
+		PaychAvailableFundsByFromTo func(context.Context, address.Address, address.Address) (*api.ChannelAvailableFunds, error)               `perm:"sign"`
 		PaychList                   func(context.Context) ([]address.Address, error)                                                          `perm:"read"`
 		PaychStatus                 func(context.Context, address.Address) (*api.PaychStatus, error)                                          `perm:"read"`
 		PaychSettle                 func(context.Context, address.Address) (cid.Cid, error)                                                   `perm:"sign"`
@@ -684,8 +693,8 @@ func (c *FullNodeStruct) ChainGetPath(ctx context.Context, from types.TipSetKey,
 	return c.Internal.ChainGetPath(ctx, from, to)
 }

-func (c *FullNodeStruct) ChainExport(ctx context.Context, nroots abi.ChainEpoch, tsk types.TipSetKey) (<-chan []byte, error) {
-	return c.Internal.ChainExport(ctx, nroots, tsk)
+func (c *FullNodeStruct) ChainExport(ctx context.Context, nroots abi.ChainEpoch, iom bool, tsk types.TipSetKey) (<-chan []byte, error) {
+	return c.Internal.ChainExport(ctx, nroots, iom, tsk)
 }

 func (c *FullNodeStruct) BeaconGetEntry(ctx context.Context, epoch abi.ChainEpoch) (*types.BeaconEntry, error) {
@@ -704,10 +713,18 @@ func (c *FullNodeStruct) SyncIncomingBlocks(ctx context.Context) (<-chan *types.
 	return c.Internal.SyncIncomingBlocks(ctx)
 }

+func (c *FullNodeStruct) SyncCheckpoint(ctx context.Context, tsk types.TipSetKey) error {
+	return c.Internal.SyncCheckpoint(ctx, tsk)
+}
+
 func (c *FullNodeStruct) SyncMarkBad(ctx context.Context, bcid cid.Cid) error {
 	return c.Internal.SyncMarkBad(ctx, bcid)
 }

+func (c *FullNodeStruct) SyncUnmarkBad(ctx context.Context, bcid cid.Cid) error {
+	return c.Internal.SyncUnmarkBad(ctx, bcid)
+}
+
 func (c *FullNodeStruct) SyncCheckBad(ctx context.Context, bcid cid.Cid) (string, error) {
 	return c.Internal.SyncCheckBad(ctx, bcid)
 }
@@ -724,7 +741,7 @@ func (c *FullNodeStruct) StateMinerActiveSectors(ctx context.Context, addr addre
 	return c.Internal.StateMinerActiveSectors(ctx, addr, tsk)
 }

-func (c *FullNodeStruct) StateMinerProvingDeadline(ctx context.Context, addr address.Address, tsk types.TipSetKey) (*miner.DeadlineInfo, error) {
+func (c *FullNodeStruct) StateMinerProvingDeadline(ctx context.Context, addr address.Address, tsk types.TipSetKey) (*dline.Info, error) {
 	return c.Internal.StateMinerProvingDeadline(ctx, addr, tsk)
 }

@@ -800,6 +817,10 @@ func (c *FullNodeStruct) StateReadState(ctx context.Context, addr address.Addres
 	return c.Internal.StateReadState(ctx, addr, tsk)
 }

+func (c *FullNodeStruct) StateMsgGasCost(ctx context.Context, msgc cid.Cid, tsk types.TipSetKey) (*api.MsgGasCost, error) {
+	return c.Internal.StateMsgGasCost(ctx, msgc, tsk)
+}
+
 func (c *FullNodeStruct) StateWaitMsg(ctx context.Context, msgc cid.Cid, confidence uint64) (*api.MsgLookup, error) {
 	return c.Internal.StateWaitMsg(ctx, msgc, confidence)
 }
@@ -872,6 +893,10 @@ func (c *FullNodeStruct) MsigGetAvailableBalance(ctx context.Context, a address.
 	return c.Internal.MsigGetAvailableBalance(ctx, a, tsk)
 }

+func (c *FullNodeStruct) MsigGetVested(ctx context.Context, a address.Address, sTsk types.TipSetKey, eTsk types.TipSetKey) (types.BigInt, error) {
+	return c.Internal.MsigGetVested(ctx, a, sTsk, eTsk)
+}
+
 func (c *FullNodeStruct) MsigCreate(ctx context.Context, req uint64, addrs []address.Address, duration abi.ChainEpoch, val types.BigInt, src address.Address, gp types.BigInt) (cid.Cid, error) {
 	return c.Internal.MsigCreate(ctx, req, addrs, duration, val, src, gp)
 }
@@ -888,6 +913,18 @@ func (c *FullNodeStruct) MsigCancel(ctx context.Context, msig address.Address, t
 	return c.Internal.MsigCancel(ctx, msig, txID, to, amt, src, method, params)
 }

+func (c *FullNodeStruct) MsigAddPropose(ctx context.Context, msig address.Address, src address.Address, newAdd address.Address, inc bool) (cid.Cid, error) {
+	return c.Internal.MsigAddPropose(ctx, msig, src, newAdd, inc)
+}
+
+func (c *FullNodeStruct) MsigAddApprove(ctx context.Context, msig address.Address, src address.Address, txID uint64, proposer address.Address, newAdd address.Address, inc bool) (cid.Cid, error) {
+	return c.Internal.MsigAddApprove(ctx, msig, src, txID, proposer, newAdd, inc)
+}
+
+func (c *FullNodeStruct) MsigAddCancel(ctx context.Context, msig address.Address, src address.Address, txID uint64, newAdd address.Address, inc bool) (cid.Cid, error) {
+	return c.Internal.MsigAddCancel(ctx, msig, src, txID, newAdd, inc)
+}
+
 func (c *FullNodeStruct) MsigSwapPropose(ctx context.Context, msig address.Address, src address.Address, oldAdd address.Address, newAdd address.Address) (cid.Cid, error) {
 	return c.Internal.MsigSwapPropose(ctx, msig, src, oldAdd, newAdd)
 }
@@ -912,12 +949,12 @@ func (c *FullNodeStruct) PaychGetWaitReady(ctx context.Context, sentinel cid.Cid
 	return c.Internal.PaychGetWaitReady(ctx, sentinel)
 }

-func (c *FullNodeStruct) PaychAvailableFunds(ch address.Address) (*api.ChannelAvailableFunds, error) {
-	return c.Internal.PaychAvailableFunds(ch)
+func (c *FullNodeStruct) PaychAvailableFunds(ctx context.Context, ch address.Address) (*api.ChannelAvailableFunds, error) {
+	return c.Internal.PaychAvailableFunds(ctx, ch)
 }

-func (c *FullNodeStruct) PaychAvailableFundsByFromTo(from, to address.Address) (*api.ChannelAvailableFunds, error) {
-	return c.Internal.PaychAvailableFundsByFromTo(from, to)
+func (c *FullNodeStruct) PaychAvailableFundsByFromTo(ctx context.Context, from, to address.Address) (*api.ChannelAvailableFunds, error) {
+	return c.Internal.PaychAvailableFundsByFromTo(ctx, from, to)
 }

 func (c *FullNodeStruct) PaychList(ctx context.Context) ([]address.Address, error) {
@@ -105,7 +105,7 @@ func init() {
 	addExample(network.Connected)
 	addExample(dtypes.NetworkName("lotus"))
 	addExample(api.SyncStateStage(1))
-	addExample(build.APIVersion)
+	addExample(build.FullAPIVersion)
 	addExample(api.PCHInbound)
 	addExample(time.Minute)
 	addExample(datatransfer.TransferID(3))
@@ -65,6 +65,8 @@ func TestApis(t *testing.T, b APIBuilder) {
 var OneMiner = []StorageMiner{{Full: 0, Preseal: PresealGenesis}}

 func (ts *testSuite) testVersion(t *testing.T) {
+	build.RunningNodeType = build.NodeFull
+
 	ctx := context.Background()
 	apis, _ := ts.makeNodes(t, 1, OneMiner)
 	api := apis[0]
@@ -192,7 +192,7 @@ func TestWindowPost(t *testing.T, b APIBuilder, blocktime time.Duration, nSector

 		// Drop the partition
 		err = parts[0].Sectors.ForEach(func(sid uint64) error {
-			return miner.StorageMiner.(*impl.StorageMinerAPI).IStorageMgr.(*mock.SectorMgr).MarkFailed(abi.SectorID{
+			return miner.StorageMiner.(*impl.StorageMinerAPI).IStorageMgr.(*mock.SectorMgr).MarkCorrupted(abi.SectorID{
 				Miner:  abi.ActorID(mid),
 				Number: abi.SectorNumber(sid),
 			}, true)
@@ -1,15 +1,26 @@
 package build

-import "github.com/filecoin-project/lotus/node/modules/dtypes"
+import (
+	"sort"

-var DrandNetwork = DrandIncentinet
-
-func DrandConfig() dtypes.DrandConfig {
-	return DrandConfigs[DrandNetwork]
-}
+	"github.com/filecoin-project/lotus/node/modules/dtypes"
+)

 type DrandEnum int

+func DrandConfigSchedule() dtypes.DrandSchedule {
+	out := dtypes.DrandSchedule{}
+	for start, config := range DrandSchedule {
+		out = append(out, dtypes.DrandPoint{Start: start, Config: DrandConfigs[config]})
+	}
+
+	sort.Slice(out, func(i, j int) bool {
+		return out[i].Start < out[j].Start
+	})
+
+	return out
+}
+
 const (
 	DrandMainnet DrandEnum = iota + 1
 	DrandTestnet
@@ -10,9 +10,15 @@ import (
 	"github.com/filecoin-project/specs-actors/actors/builtin/verifreg"
 )

-const UpgradeBreezeHeight = 0
+const UpgradeBreezeHeight = -1
 const BreezeGasTampingDuration = 0

+const UpgradeSmokeHeight = -1
+
+var DrandSchedule = map[abi.ChainEpoch]DrandEnum{
+	0: DrandMainnet,
+}
+
 func init() {
 	power.ConsensusMinerMinPower = big.NewInt(2048)
 	miner.SupportedProofTypes = map[abi.RegisteredSealProof]struct{}{
@@ -36,3 +36,11 @@ func MessagesTopic(netName dtypes.NetworkName) string { return "/fil/msgs/" + st
 func DhtProtocolName(netName dtypes.NetworkName) protocol.ID {
 	return protocol.ID("/fil/kad/" + string(netName))
 }
+
+func UseNewestNetwork() bool {
+	// TODO: Put these in a container we can iterate over
+	if UpgradeBreezeHeight <= 0 && UpgradeSmokeHeight <= 0 {
+		return true
+	}
+	return false
+}
@@ -5,6 +5,8 @@ package build
 import (
 	"math/big"

+	"github.com/filecoin-project/go-state-types/network"
+
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/specs-actors/actors/builtin"
 	"github.com/filecoin-project/specs-actors/actors/builtin/miner"
@@ -20,6 +22,7 @@ const UnixfsLinksPerLevel = 1024
 // Consensus / Network

 const AllowableClockDriftSecs = uint64(1)
+const NewestNetworkVersion = network.Version2

 // Epochs
 const ForkLengthThreshold = Finality
@@ -11,6 +11,7 @@ import (
 	"math/big"

 	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/network"
 	"github.com/filecoin-project/specs-actors/actors/builtin"
 	"github.com/filecoin-project/specs-actors/actors/builtin/miner"
 )
@@ -70,6 +71,14 @@ var (
 	PackingEfficiencyNum   int64 = 4
 	PackingEfficiencyDenom int64 = 5

-	UpgradeBreezeHeight      abi.ChainEpoch = 0
+	UpgradeBreezeHeight      abi.ChainEpoch = -1
 	BreezeGasTampingDuration abi.ChainEpoch = 0
+
+	UpgradeSmokeHeight abi.ChainEpoch = -1
+
+	DrandSchedule = map[abi.ChainEpoch]DrandEnum{
+		0: DrandMainnet,
+	}
+
+	NewestNetworkVersion = network.Version2
 )
@@ -12,9 +12,16 @@ import (
 	"github.com/filecoin-project/specs-actors/actors/builtin/power"
 )

+var DrandSchedule = map[abi.ChainEpoch]DrandEnum{
+	0:                  DrandIncentinet,
+	UpgradeSmokeHeight: DrandMainnet,
+}
+
 const UpgradeBreezeHeight = 41280
 const BreezeGasTampingDuration = 120

+const UpgradeSmokeHeight = 51000
+
 func init() {
 	power.ConsensusMinerMinPower = big.NewInt(10 << 40)
 	miner.SupportedProofTypes = map[abi.RegisteredSealProof]struct{}{
@@ -1,6 +1,10 @@
 package build

-import "fmt"
+import (
+	"fmt"
+
+	"golang.org/x/xerrors"
+)

 var CurrentCommit string
 var BuildType int
@@ -25,7 +29,7 @@ func buildType() string {
 }

 // BuildVersion is the local build version, set by build system
-const BuildVersion = "0.6.0"
+const BuildVersion = "0.7.1"

 func UserVersion() string {
 	return BuildVersion + buildType() + CurrentCommit
@@ -52,8 +56,37 @@ func (ve Version) EqMajorMinor(v2 Version) bool {
 	return ve&minorMask == v2&minorMask
 }

-// APIVersion is a semver version of the rpc api exposed
-var APIVersion Version = newVer(0, 14, 0)
+type NodeType int
+
+const (
+	NodeUnknown NodeType = iota
+
+	NodeFull
+	NodeMiner
+	NodeWorker
+)
+
+var RunningNodeType NodeType
+
+func VersionForType(nodeType NodeType) (Version, error) {
+	switch nodeType {
+	case NodeFull:
+		return FullAPIVersion, nil
+	case NodeMiner:
+		return MinerAPIVersion, nil
+	case NodeWorker:
+		return WorkerAPIVersion, nil
+	default:
+		return Version(0), xerrors.Errorf("unknown node type %d", nodeType)
+	}
+}
+
+// semver versions of the rpc api exposed
+var (
+	FullAPIVersion   = newVer(0, 15, 0)
+	MinerAPIVersion  = newVer(0, 14, 0)
+	WorkerAPIVersion = newVer(0, 14, 0)
+)

 //nolint:varcheck,deadcode
 const (
@@ -56,6 +56,10 @@ func (bts *BadBlockCache) Add(c cid.Cid, bbr BadBlockReason) {
 	bts.badBlocks.Add(c, bbr)
 }

+func (bts *BadBlockCache) Remove(c cid.Cid) {
+	bts.badBlocks.Remove(c)
+}
+
 func (bts *BadBlockCache) Has(c cid.Cid) (BadBlockReason, bool) {
 	rval, ok := bts.badBlocks.Get(c)
 	if !ok {
@@ -18,6 +18,23 @@ type Response struct {
 	Err   error
 }

+type Schedule []BeaconPoint
+
+func (bs Schedule) BeaconForEpoch(e abi.ChainEpoch) RandomBeacon {
+	for i := len(bs) - 1; i >= 0; i-- {
+		bp := bs[i]
+		if e >= bp.Start {
+			return bp.Beacon
+		}
+	}
+	return bs[0].Beacon
+}
+
+type BeaconPoint struct {
+	Start  abi.ChainEpoch
+	Beacon RandomBeacon
+}
+
 // RandomBeacon represents a system that provides randomness to Lotus.
 // Other components interrogate the RandomBeacon to acquire randomness that's
 // valid for a specific chain epoch. Also to verify beacon entries that have
@@ -25,11 +42,30 @@ type Response struct {
 type RandomBeacon interface {
 	Entry(context.Context, uint64) <-chan Response
 	VerifyEntry(types.BeaconEntry, types.BeaconEntry) error
-	MaxBeaconRoundForEpoch(abi.ChainEpoch, types.BeaconEntry) uint64
+	MaxBeaconRoundForEpoch(abi.ChainEpoch) uint64
 }

-func ValidateBlockValues(b RandomBeacon, h *types.BlockHeader, prevEntry types.BeaconEntry) error {
-	maxRound := b.MaxBeaconRoundForEpoch(h.Height, prevEntry)
+func ValidateBlockValues(bSchedule Schedule, h *types.BlockHeader, parentEpoch abi.ChainEpoch,
+	prevEntry types.BeaconEntry) error {
+	{
+		parentBeacon := bSchedule.BeaconForEpoch(parentEpoch)
+		currBeacon := bSchedule.BeaconForEpoch(h.Height)
+		if parentBeacon != currBeacon {
+			if len(h.BeaconEntries) != 2 {
+				return xerrors.Errorf("expected two beacon entries at beacon fork, got %d", len(h.BeaconEntries))
+			}
+			err := currBeacon.VerifyEntry(h.BeaconEntries[1], h.BeaconEntries[0])
+			if err != nil {
+				return xerrors.Errorf("beacon at fork point invalid: (%v, %v): %w",
+					h.BeaconEntries[1], h.BeaconEntries[0], err)
+			}
+			return nil
+		}
+	}
+
+	// TODO: fork logic
+	b := bSchedule.BeaconForEpoch(h.Height)
+	maxRound := b.MaxBeaconRoundForEpoch(h.Height)
 	if maxRound == prevEntry.Round {
 		if len(h.BeaconEntries) != 0 {
 			return xerrors.Errorf("expected not to have any beacon entries in this block, got %d", len(h.BeaconEntries))
@@ -56,10 +92,35 @@ func ValidateBlockValues(b RandomBeacon, h *types.BlockHeader, prevEntry types.B
 	return nil
 }

-func BeaconEntriesForBlock(ctx context.Context, beacon RandomBeacon, round abi.ChainEpoch, prev types.BeaconEntry) ([]types.BeaconEntry, error) {
+func BeaconEntriesForBlock(ctx context.Context, bSchedule Schedule, epoch abi.ChainEpoch, parentEpoch abi.ChainEpoch, prev types.BeaconEntry) ([]types.BeaconEntry, error) {
+	{
+		parentBeacon := bSchedule.BeaconForEpoch(parentEpoch)
+		currBeacon := bSchedule.BeaconForEpoch(epoch)
+		if parentBeacon != currBeacon {
+			// Fork logic
+			round := currBeacon.MaxBeaconRoundForEpoch(epoch)
+			out := make([]types.BeaconEntry, 2)
+			rch := currBeacon.Entry(ctx, round-1)
+			res := <-rch
+			if res.Err != nil {
+				return nil, xerrors.Errorf("getting entry %d returned error: %w", round-1, res.Err)
+			}
+			out[0] = res.Entry
+			rch = currBeacon.Entry(ctx, round)
+			res = <-rch
+			if res.Err != nil {
+				return nil, xerrors.Errorf("getting entry %d returned error: %w", round, res.Err)
+			}
+			out[1] = res.Entry
+			return out, nil
+		}
+	}
+
+	beacon := bSchedule.BeaconForEpoch(epoch)
+
 	start := build.Clock.Now()

-	maxRound := beacon.MaxBeaconRoundForEpoch(round, prev)
+	maxRound := beacon.MaxBeaconRoundForEpoch(epoch)
 	if maxRound == prev.Round {
 		return nil, nil
 	}
@@ -82,7 +143,7 @@ func BeaconEntriesForBlock(ctx context.Context, beacon RandomBeacon, round abi.C
 			out = append(out, resp.Entry)
 			cur = resp.Entry.Round - 1
 		case <-ctx.Done():
-			return nil, xerrors.Errorf("context timed out waiting on beacon entry to come back for round %d: %w", round, ctx.Err())
+			return nil, xerrors.Errorf("context timed out waiting on beacon entry to come back for epoch %d: %w", epoch, ctx.Err())
 		}
 	}

@@ -187,7 +187,7 @@ func (db *DrandBeacon) VerifyEntry(curr types.BeaconEntry, prev types.BeaconEntr
 	return err
 }

-func (db *DrandBeacon) MaxBeaconRoundForEpoch(filEpoch abi.ChainEpoch, prevEntry types.BeaconEntry) uint64 {
+func (db *DrandBeacon) MaxBeaconRoundForEpoch(filEpoch abi.ChainEpoch) uint64 {
 	// TODO: sometimes the genesis time for filecoin is zero and this goes negative
 	latestTs := ((uint64(filEpoch) * db.filRoundTime) + db.filGenTime) - db.filRoundTime
 	dround := (latestTs - db.drandGenTime) / uint64(db.interval.Seconds())
@@ -12,7 +12,7 @@ import (
 )

 func TestPrintGroupInfo(t *testing.T) {
-	server := build.DrandConfig().Servers[0]
+	server := build.DrandConfigs[build.DrandIncentinet].Servers[0]
 	c, err := hclient.New(server, nil, nil)
 	assert.NoError(t, err)
 	cg := c.(interface {
@@ -53,11 +53,7 @@ func (mb *mockBeacon) VerifyEntry(from types.BeaconEntry, to types.BeaconEntry)
 	return nil
 }

-func (mb *mockBeacon) IsEntryForEpoch(e types.BeaconEntry, epoch abi.ChainEpoch, nulls int) (bool, error) {
-	return int64(e.Round) <= int64(epoch) && int64(epoch)-int64(nulls) >= int64(e.Round), nil
-}
-
-func (mb *mockBeacon) MaxBeaconRoundForEpoch(epoch abi.ChainEpoch, prevEntry types.BeaconEntry) uint64 {
+func (mb *mockBeacon) MaxBeaconRoundForEpoch(epoch abi.ChainEpoch) uint64 {
 	return uint64(epoch)
 }

@@ -0,0 +1,81 @@
+package chain
+
+import (
+	"encoding/json"
+
+	"github.com/filecoin-project/lotus/chain/types"
+
+	"github.com/filecoin-project/lotus/node/modules/dtypes"
+	"github.com/ipfs/go-datastore"
+	"golang.org/x/xerrors"
+)
+
+var CheckpointKey = datastore.NewKey("/chain/checks")
+
+func loadCheckpoint(ds dtypes.MetadataDS) (types.TipSetKey, error) {
+	haveChks, err := ds.Has(CheckpointKey)
+	if err != nil {
+		return types.EmptyTSK, err
+	}
+
+	if !haveChks {
+		return types.EmptyTSK, nil
+	}
+
+	tskBytes, err := ds.Get(CheckpointKey)
+	if err != nil {
+		return types.EmptyTSK, err
+	}
+
+	var tsk types.TipSetKey
+	err = json.Unmarshal(tskBytes, &tsk)
+	if err != nil {
+		return types.EmptyTSK, err
+	}
+
+	return tsk, err
+}
+
+func (syncer *Syncer) SetCheckpoint(tsk types.TipSetKey) error {
+	if tsk == types.EmptyTSK {
+		return xerrors.Errorf("called with empty tsk")
+	}
+
+	syncer.checkptLk.Lock()
+	defer syncer.checkptLk.Unlock()
+
+	ts, err := syncer.ChainStore().LoadTipSet(tsk)
+	if err != nil {
+		return xerrors.Errorf("cannot find tipset: %w", err)
+	}
+
+	hts := syncer.ChainStore().GetHeaviestTipSet()
+	anc, err := syncer.ChainStore().IsAncestorOf(ts, hts)
+	if err != nil {
+		return xerrors.Errorf("cannot determine whether checkpoint tipset is in main-chain: %w", err)
+	}
+
+	if !hts.Equals(ts) && !anc {
+		return xerrors.Errorf("cannot mark tipset as checkpoint, since it isn't in the main-chain: %w", err)
+	}
+
+	tskBytes, err := json.Marshal(tsk)
+	if err != nil {
+		return err
+	}
+
+	err = syncer.ds.Put(CheckpointKey, tskBytes)
+	if err != nil {
+		return err
+	}
+
+	syncer.checkpt = tsk
+
+	return nil
+}
+
+func (syncer *Syncer) GetCheckpoint() types.TipSetKey {
+	syncer.checkptLk.Lock()
+	defer syncer.checkptLk.Unlock()
+	return syncer.checkpt
+}
@@ -27,7 +27,6 @@ type heightEvents struct {
 }

 func (e *heightEvents) headChangeAt(rev, app []*types.TipSet) error {
-
 	ctx, span := trace.StartSpan(e.ctx, "events.HeightHeadChange")
 	defer span.End()
 	span.AddAttributes(trace.Int64Attribute("endHeight", int64(app[0].Height())))
@@ -145,12 +144,11 @@ func (e *heightEvents) headChangeAt(rev, app []*types.TipSet) error {
 }

 // ChainAt invokes the specified `HeightHandler` when the chain reaches the
-//  specified height+confidence threshold. If the chain is rolled-back under the
-//  specified height, `RevertHandler` will be called.
+// specified height+confidence threshold. If the chain is rolled-back under the
+// specified height, `RevertHandler` will be called.
 //
 // ts passed to handlers is the tipset at the specified, or above, if lower tipsets were null
 func (e *heightEvents) ChainAt(hnd HeightHandler, rev RevertHandler, confidence int, h abi.ChainEpoch) error {
-
 	e.lk.Lock() // Tricky locking, check your locks if you modify this function!

 	best, err := e.tsc.best()
@@ -3,6 +3,7 @@ package state
 import (
 	"bytes"

+	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/specs-actors/actors/util/adt"
 	typegen "github.com/whyrusleeping/cbor-gen"
 )
@@ -69,7 +70,7 @@ func DiffAdtArray(preArr, curArr *adt.Array, out AdtArrayDiff) error {
 // Modify should be called when a value is modified in the map
 // Remove should be called when a value is removed from the map
 type AdtMapDiff interface {
-	AsKey(key string) (adt.Keyer, error)
+	AsKey(key string) (abi.Keyer, error)
 	Add(key string, val *typegen.Deferred) error
 	Modify(key string, from, to *typegen.Deferred) error
 	Remove(key string, val *typegen.Deferred) error
@@ -11,6 +11,7 @@ import (
 	cbornode "github.com/ipfs/go-ipld-cbor"
 	typegen "github.com/whyrusleeping/cbor-gen"

+	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/specs-actors/actors/runtime"
 	"github.com/filecoin-project/specs-actors/actors/util/adt"

@@ -78,21 +79,21 @@ func TestDiffAdtMap(t *testing.T) {
 	mapA := adt.MakeEmptyMap(ctxstoreA)
 	mapB := adt.MakeEmptyMap(ctxstoreB)

-	require.NoError(t, mapA.Put(adt.UIntKey(0), runtime.CBORBytes([]byte{0}))) // delete
+	require.NoError(t, mapA.Put(abi.UIntKey(0), runtime.CBORBytes([]byte{0}))) // delete

-	require.NoError(t, mapA.Put(adt.UIntKey(1), runtime.CBORBytes([]byte{0}))) // modify
-	require.NoError(t, mapB.Put(adt.UIntKey(1), runtime.CBORBytes([]byte{1})))
+	require.NoError(t, mapA.Put(abi.UIntKey(1), runtime.CBORBytes([]byte{0}))) // modify
+	require.NoError(t, mapB.Put(abi.UIntKey(1), runtime.CBORBytes([]byte{1})))

-	require.NoError(t, mapA.Put(adt.UIntKey(2), runtime.CBORBytes([]byte{1}))) // delete
+	require.NoError(t, mapA.Put(abi.UIntKey(2), runtime.CBORBytes([]byte{1}))) // delete

-	require.NoError(t, mapA.Put(adt.UIntKey(3), runtime.CBORBytes([]byte{0}))) // noop
-	require.NoError(t, mapB.Put(adt.UIntKey(3), runtime.CBORBytes([]byte{0})))
+	require.NoError(t, mapA.Put(abi.UIntKey(3), runtime.CBORBytes([]byte{0}))) // noop
+	require.NoError(t, mapB.Put(abi.UIntKey(3), runtime.CBORBytes([]byte{0})))

-	require.NoError(t, mapA.Put(adt.UIntKey(4), runtime.CBORBytes([]byte{0}))) // modify
-	require.NoError(t, mapB.Put(adt.UIntKey(4), runtime.CBORBytes([]byte{6})))
+	require.NoError(t, mapA.Put(abi.UIntKey(4), runtime.CBORBytes([]byte{0}))) // modify
+	require.NoError(t, mapB.Put(abi.UIntKey(4), runtime.CBORBytes([]byte{6})))

-	require.NoError(t, mapB.Put(adt.UIntKey(5), runtime.CBORBytes{8})) // add
-	require.NoError(t, mapB.Put(adt.UIntKey(6), runtime.CBORBytes{9})) // add
+	require.NoError(t, mapB.Put(abi.UIntKey(5), runtime.CBORBytes{8})) // add
+	require.NoError(t, mapB.Put(abi.UIntKey(6), runtime.CBORBytes{9})) // add

 	changes := new(TestDiffMap)

@@ -134,12 +135,12 @@ type TestDiffMap struct {

 var _ AdtMapDiff = &TestDiffMap{}

-func (t *TestDiffMap) AsKey(key string) (adt.Keyer, error) {
-	k, err := adt.ParseUIntKey(key)
+func (t *TestDiffMap) AsKey(key string) (abi.Keyer, error) {
+	k, err := abi.ParseUIntKey(key)
 	if err != nil {
 		return nil, err
 	}
-	return adt.UIntKey(k), nil
+	return abi.UIntKey(k), nil
 }

 func (t *TestDiffMap) Add(key string, val *typegen.Deferred) error {
@@ -148,7 +149,7 @@ func (t *TestDiffMap) Add(key string, val *typegen.Deferred) error {
 	if err != nil {
 		return err
 	}
-	k, err := adt.ParseUIntKey(key)
+	k, err := abi.ParseUIntKey(key)
 	if err != nil {
 		return err
 	}
@@ -172,7 +173,7 @@ func (t *TestDiffMap) Modify(key string, from, to *typegen.Deferred) error {
 		return err
 	}

-	k, err := adt.ParseUIntKey(key)
+	k, err := abi.ParseUIntKey(key)
 	if err != nil {
 		return err
 	}
@@ -198,7 +199,7 @@ func (t *TestDiffMap) Remove(key string, val *typegen.Deferred) error {
 	if err != nil {
 		return err
 	}
-	k, err := adt.ParseUIntKey(key)
+	k, err := abi.ParseUIntKey(key)
 	if err != nil {
 		return err
 	}
@@ -537,8 +537,8 @@ type MinerPreCommitChanges struct {
 	Removed []miner.SectorPreCommitOnChainInfo
 }

-func (m *MinerPreCommitChanges) AsKey(key string) (adt.Keyer, error) {
-	sector, err := adt.ParseUIntKey(key)
+func (m *MinerPreCommitChanges) AsKey(key string) (abi.Keyer, error) {
+	sector, err := abi.ParseUIntKey(key)
 	if err != nil {
 		return nil, err
 	}
@@ -662,12 +662,12 @@ type AddressChange struct {

 type DiffInitActorStateFunc func(ctx context.Context, oldState *init_.State, newState *init_.State) (changed bool, user UserData, err error)

-func (i *InitActorAddressChanges) AsKey(key string) (adt.Keyer, error) {
+func (i *InitActorAddressChanges) AsKey(key string) (abi.Keyer, error) {
 	addr, err := address.NewFromBytes([]byte(key))
 	if err != nil {
 		return nil, err
 	}
-	return adt.AddrKey(addr), nil
+	return abi.AddrKey(addr), nil
 }

 func (i *InitActorAddressChanges) Add(key string, val *typegen.Deferred) error {
@@ -1,6 +1,6 @@
 // Code generated by github.com/whyrusleeping/cbor-gen. DO NOT EDIT.

-package blocksync
+package exchange

 import (
 	"fmt"
@@ -1,4 +1,4 @@
-package blocksync
+package exchange

 import (
 	"bufio"
@@ -7,13 +7,16 @@ import (
 	"math/rand"
 	"time"

-	host "github.com/libp2p/go-libp2p-core/host"
-	inet "github.com/libp2p/go-libp2p-core/network"
+	"github.com/libp2p/go-libp2p-core/host"
+	"github.com/libp2p/go-libp2p-core/network"
 	"github.com/libp2p/go-libp2p-core/peer"
+
 	"go.opencensus.io/trace"
+	"go.uber.org/fx"
 	"golang.org/x/xerrors"

 	cborutil "github.com/filecoin-project/go-cbor-util"
+
 	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain/store"
 	"github.com/filecoin-project/lotus/chain/types"
@@ -21,11 +24,9 @@ import (
 	"github.com/filecoin-project/lotus/lib/peermgr"
 )

-// Protocol client.
-// FIXME: Rename to just `Client`. Not done at the moment to avoid
-//  disrupting too much of the consumer code, should be done along
-//  https://github.com/filecoin-project/lotus/issues/2612.
-type BlockSync struct {
+// client implements exchange.Client, using the libp2p ChainExchange protocol
+// as the fetching mechanism.
+type client struct {
 	// Connection manager used to contact the server.
 	// FIXME: We should have a reduced interface here, initialized
 	//  just with our protocol ID, we shouldn't be able to open *any*
@@ -35,13 +36,14 @@ type BlockSync struct {
 	peerTracker *bsPeerTracker
 }

-func NewClient(
-	host host.Host,
-	pmgr peermgr.MaybePeerMgr,
-) *BlockSync {
-	return &BlockSync{
+var _ Client = (*client)(nil)
+
+// NewClient creates a new libp2p-based exchange.Client that uses the libp2p
+// ChainExhange protocol as the fetching mechanism.
+func NewClient(lc fx.Lifecycle, host host.Host, pmgr peermgr.MaybePeerMgr) Client {
+	return &client{
 		host:        host,
-		peerTracker: newPeerTracker(pmgr.Mgr),
+		peerTracker: newPeerTracker(lc, host, pmgr.Mgr),
 	}
 }

@@ -62,11 +64,7 @@ func NewClient(
 // 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 (client *BlockSync) doRequest(
-	ctx context.Context,
-	req *Request,
-	singlePeer *peer.ID,
-) (*validatedResponse, error) {
+func (c *client) doRequest(ctx context.Context, req *Request, singlePeer *peer.ID) (*validatedResponse, error) {
 	// Validate request.
 	if req.Length == 0 {
 		return nil, xerrors.Errorf("invalid request of length 0")
@@ -86,7 +84,7 @@ func (client *BlockSync) doRequest(
 	if singlePeer != nil {
 		peers = []peer.ID{*singlePeer}
 	} else {
-		peers = client.getShuffledPeers()
+		peers = c.getShuffledPeers()
 		if len(peers) == 0 {
 			return nil, xerrors.Errorf("no peers available")
 		}
@@ -107,9 +105,9 @@ func (client *BlockSync) doRequest(
 		}

 		// Send request, read response.
-		res, err := client.sendRequestToPeer(ctx, peer, req)
+		res, err := c.sendRequestToPeer(ctx, peer, req)
 		if err != nil {
-			if !xerrors.Is(err, inet.ErrNoConn) {
+			if !xerrors.Is(err, network.ErrNoConn) {
 				log.Warnf("could not connect to peer %s: %s",
 					peer.String(), err)
 			}
@@ -117,15 +115,15 @@ func (client *BlockSync) doRequest(
 		}

 		// Process and validate response.
-		validRes, err := client.processResponse(req, res)
+		validRes, err := c.processResponse(req, res)
 		if err != nil {
 			log.Warnf("processing peer %s response failed: %s",
 				peer.String(), err)
 			continue
 		}

-		client.peerTracker.logGlobalSuccess(build.Clock.Since(globalTime))
-		client.host.ConnManager().TagPeer(peer, "bsync", SUCCESS_PEER_TAG_VALUE)
+		c.peerTracker.logGlobalSuccess(build.Clock.Since(globalTime))
+		c.host.ConnManager().TagPeer(peer, "bsync", SuccessPeerTagValue)
 		return validRes, nil
 	}

@@ -144,11 +142,8 @@ func (client *BlockSync) doRequest(
 // We are conflating in the single error returned both status and validation
 // errors. Peer penalization should happen here then, before returning, so
 // we can apply the correct penalties depending on the cause of the error.
-func (client *BlockSync) processResponse(
-	req *Request,
-	res *Response,
-	// FIXME: Add the `peer` as argument once we implement penalties.
-) (*validatedResponse, error) {
+// FIXME: Add the `peer` as argument once we implement penalties.
+func (c *client) processResponse(req *Request, res *Response) (*validatedResponse, error) {
 	err := res.statusToError()
 	if err != nil {
 		return nil, xerrors.Errorf("status error: %s", err)
@@ -246,16 +241,8 @@ func (client *BlockSync) processResponse(
 	return validRes, nil
 }

-// GetBlocks fetches count blocks from the network, from the provided tipset
-// *backwards*, returning as many tipsets as count.
-//
-// {hint/usage}: This is used by the Syncer during normal chain syncing and when
-// resolving forks.
-func (client *BlockSync) GetBlocks(
-	ctx context.Context,
-	tsk types.TipSetKey,
-	count int,
-) ([]*types.TipSet, error) {
+// 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")
 	defer span.End()
 	if span.IsRecordingEvents() {
@@ -271,7 +258,7 @@ func (client *BlockSync) GetBlocks(
 		Options: Headers,
 	}

-	validRes, err := client.doRequest(ctx, req, nil)
+	validRes, err := c.doRequest(ctx, req, nil)
 	if err != nil {
 		return nil, err
 	}
@@ -279,11 +266,8 @@ func (client *BlockSync) GetBlocks(
 	return validRes.tipsets, nil
 }

-func (client *BlockSync) GetFullTipSet(
-	ctx context.Context,
-	peer peer.ID,
-	tsk types.TipSetKey,
-) (*store.FullTipSet, error) {
+// GetFullTipSet implements Client.GetFullTipSet(). Refer to the godocs there.
+func (c *client) GetFullTipSet(ctx context.Context, peer peer.ID, tsk types.TipSetKey) (*store.FullTipSet, error) {
 	// TODO: round robin through these peers on error

 	req := &Request{
@@ -292,7 +276,7 @@ func (client *BlockSync) GetFullTipSet(
 		Options: Headers | Messages,
 	}

-	validRes, err := client.doRequest(ctx, req, &peer)
+	validRes, err := c.doRequest(ctx, req, &peer)
 	if err != nil {
 		return nil, err
 	}
@@ -302,11 +286,8 @@ func (client *BlockSync) GetFullTipSet(
 	//  *one* tipset here, so it's safe to index directly.
 }

-func (client *BlockSync) GetChainMessages(
-	ctx context.Context,
-	head *types.TipSet,
-	length uint64,
-) ([]*CompactedMessages, error) {
+// GetChainMessages implements Client.GetChainMessages(). Refer to the godocs there.
+func (c *client) GetChainMessages(ctx context.Context, head *types.TipSet, length uint64) ([]*CompactedMessages, error) {
 	ctx, span := trace.StartSpan(ctx, "GetChainMessages")
 	if span.IsRecordingEvents() {
 		span.AddAttributes(
@@ -322,7 +303,7 @@ func (client *BlockSync) GetChainMessages(
 		Options: Messages,
 	}

-	validRes, err := client.doRequest(ctx, req, nil)
+	validRes, err := c.doRequest(ctx, req, nil)
 	if err != nil {
 		return nil, err
 	}
@@ -333,11 +314,7 @@ func (client *BlockSync) GetChainMessages(
 // Send a request to a peer. Write request in the stream and read the
 // response back. We do not do any processing of the request/response
 // here.
-func (client *BlockSync) sendRequestToPeer(
-	ctx context.Context,
-	peer peer.ID,
-	req *Request,
-) (_ *Response, err error) {
+func (c *client) sendRequestToPeer(ctx context.Context, peer peer.ID, req *Request) (_ *Response, err error) {
 	// Trace code.
 	ctx, span := trace.StartSpan(ctx, "sendRequestToPeer")
 	defer span.End()
@@ -358,34 +335,33 @@ func (client *BlockSync) sendRequestToPeer(
 	}()
 	// -- TRACE --

-	supported, err := client.host.Peerstore().SupportsProtocols(peer, BlockSyncProtocolID)
+	supported, err := c.host.Peerstore().SupportsProtocols(peer, BlockSyncProtocolID, ChainExchangeProtocolID)
 	if err != nil {
+		c.RemovePeer(peer)
 		return nil, xerrors.Errorf("failed to get protocols for peer: %w", err)
 	}
-	if len(supported) == 0 || supported[0] != BlockSyncProtocolID {
-		return nil, xerrors.Errorf("peer %s does not support protocol %s",
-			peer, BlockSyncProtocolID)
-		// FIXME: `ProtoBook` should support a *single* protocol check that returns
-		//  a bool instead of a list.
+	if len(supported) == 0 || (supported[0] != BlockSyncProtocolID && supported[0] != ChainExchangeProtocolID) {
+		return nil, xerrors.Errorf("peer %s does not support protocols %s",
+			peer, []string{BlockSyncProtocolID, ChainExchangeProtocolID})
 	}

 	connectionStart := build.Clock.Now()

 	// Open stream to peer.
-	stream, err := client.host.NewStream(
-		inet.WithNoDial(ctx, "should already have connection"),
+	stream, err := c.host.NewStream(
+		network.WithNoDial(ctx, "should already have connection"),
 		peer,
-		BlockSyncProtocolID)
+		ChainExchangeProtocolID, BlockSyncProtocolID)
 	if err != nil {
-		client.RemovePeer(peer)
+		c.RemovePeer(peer)
 		return nil, xerrors.Errorf("failed to open stream to peer: %w", err)
 	}

 	// Write request.
-	_ = stream.SetWriteDeadline(time.Now().Add(WRITE_REQ_DEADLINE))
+	_ = stream.SetWriteDeadline(time.Now().Add(WriteReqDeadline))
 	if err := cborutil.WriteCborRPC(stream, req); err != nil {
 		_ = stream.SetWriteDeadline(time.Time{})
-		client.peerTracker.logFailure(peer, build.Clock.Since(connectionStart))
+		c.peerTracker.logFailure(peer, build.Clock.Since(connectionStart), req.Length)
 		// FIXME: Should we also remove peer here?
 		return nil, err
 	}
@@ -395,11 +371,11 @@ func (client *BlockSync) sendRequestToPeer(
 	// Read response.
 	var res Response
 	err = cborutil.ReadCborRPC(
-		bufio.NewReader(incrt.New(stream, READ_RES_MIN_SPEED, READ_RES_DEADLINE)),
+		bufio.NewReader(incrt.New(stream, ReadResMinSpeed, ReadResDeadline)),
 		&res)
 	if err != nil {
-		client.peerTracker.logFailure(peer, build.Clock.Since(connectionStart))
-		return nil, xerrors.Errorf("failed to read blocksync response: %w", err)
+		c.peerTracker.logFailure(peer, build.Clock.Since(connectionStart), req.Length)
+		return nil, xerrors.Errorf("failed to read chainxchg response: %w", err)
 	}

 	// FIXME: Move all this together at the top using a defer as done elsewhere.
@@ -412,32 +388,34 @@ func (client *BlockSync) sendRequestToPeer(
 		)
 	}

-	client.peerTracker.logSuccess(peer, build.Clock.Since(connectionStart))
+	c.peerTracker.logSuccess(peer, build.Clock.Since(connectionStart), uint64(len(res.Chain)))
 	// FIXME: We should really log a success only after we validate the response.
 	//  It might be a bit hard to do.
 	return &res, nil
 }

-func (client *BlockSync) AddPeer(p peer.ID) {
-	client.peerTracker.addPeer(p)
+// AddPeer implements Client.AddPeer(). Refer to the godocs there.
+func (c *client) AddPeer(p peer.ID) {
+	c.peerTracker.addPeer(p)
 }

-func (client *BlockSync) RemovePeer(p peer.ID) {
-	client.peerTracker.removePeer(p)
+// RemovePeer implements Client.RemovePeer(). Refer to the godocs there.
+func (c *client) RemovePeer(p peer.ID) {
+	c.peerTracker.removePeer(p)
 }

 // getShuffledPeers returns a preference-sorted set of peers (by latency
 // and failure counting), shuffling the first few peers so we don't always
 // pick the same peer.
 // FIXME: Consider merging with `shufflePrefix()s`.
-func (client *BlockSync) getShuffledPeers() []peer.ID {
-	peers := client.peerTracker.prefSortedPeers()
+func (c *client) getShuffledPeers() []peer.ID {
+	peers := c.peerTracker.prefSortedPeers()
 	shufflePrefix(peers)
 	return peers
 }

 func shufflePrefix(peers []peer.ID) {
-	prefix := SHUFFLE_PEERS_PREFIX
+	prefix := ShufflePeersPrefix
 	if len(peers) < prefix {
 		prefix = len(peers)
 	}
@@ -0,0 +1,19 @@
+// Package exchange contains the ChainExchange server and client components.
+//
+// ChainExchange is the basic chain synchronization protocol of Filecoin.
+// ChainExchange is an RPC-oriented protocol, with a single operation to
+// request blocks for now.
+//
+// A request contains a start anchor block (referred to with a CID), and a
+// amount of blocks requested beyond the anchor (including the anchor itself).
+//
+// A client can also pass options, encoded as a 64-bit bitfield. Lotus supports
+// two options at the moment:
+//
+//  - include block contents
+//  - include block messages
+//
+// The response will include a status code, an optional message, and the
+// response payload in case of success. The payload is a slice of serialized
+// tipsets.
+package exchange
@@ -0,0 +1,51 @@
+package exchange
+
+import (
+	"context"
+
+	"github.com/libp2p/go-libp2p-core/network"
+	"github.com/libp2p/go-libp2p-core/peer"
+
+	"github.com/filecoin-project/lotus/chain/store"
+	"github.com/filecoin-project/lotus/chain/types"
+)
+
+// Server is the responder side of the ChainExchange protocol. It accepts
+// requests from clients and services them by returning the requested
+// chain data.
+type Server interface {
+	// HandleStream is the protocol handler to be registered on a libp2p
+	// protocol router.
+	//
+	// In the current version of the protocol, streams are single-use. The
+	// server will read a single Request, and will respond with a single
+	// Response. It will dispose of the stream straight after.
+	HandleStream(stream network.Stream)
+}
+
+// Client is the requesting side of the ChainExchange protocol. It acts as
+// a proxy for other components to request chain data from peers. It is chiefly
+// used by the Syncer.
+type Client interface {
+	// GetBlocks fetches block headers from the network, from the provided
+	// tipset *backwards*, returning as many tipsets as the count parameter,
+	// 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)
+
+	// GetFullTipSet fetches a full tipset from a given peer. If successful,
+	// the fetched object contains block headers and all messages in full form.
+	GetFullTipSet(ctx context.Context, peer peer.ID, tsk types.TipSetKey) (*store.FullTipSet, error)
+
+	// AddPeer adds a peer to the pool of peers that the Client requests
+	// data from.
+	AddPeer(peer peer.ID)
+
+	// RemovePeer removes a peer from the pool of peers that the Client
+	// requests data from.
+	RemovePeer(peer peer.ID)
+}
@@ -1,13 +1,16 @@
-package blocksync
+package exchange

 // FIXME: This needs to be reviewed.

 import (
+	"context"
 	"sort"
 	"sync"
 	"time"

+	host "github.com/libp2p/go-libp2p-core/host"
 	"github.com/libp2p/go-libp2p-core/peer"
+	"go.uber.org/fx"

 	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/lib/peermgr"
@@ -29,11 +32,30 @@ type bsPeerTracker struct {
 	pmgr *peermgr.PeerMgr
 }

-func newPeerTracker(pmgr *peermgr.PeerMgr) *bsPeerTracker {
-	return &bsPeerTracker{
+func newPeerTracker(lc fx.Lifecycle, h host.Host, pmgr *peermgr.PeerMgr) *bsPeerTracker {
+	bsPt := &bsPeerTracker{
 		peers: make(map[peer.ID]*peerStats),
 		pmgr:  pmgr,
 	}
+
+	sub, err := h.EventBus().Subscribe(new(peermgr.NewFilPeer))
+	if err != nil {
+		panic(err)
+	}
+
+	go func() {
+		for newPeer := range sub.Out() {
+			bsPt.addPeer(newPeer.(peermgr.NewFilPeer).Id)
+		}
+	}()
+
+	lc.Append(fx.Hook{
+		OnStop: func(ctx context.Context) error {
+			return sub.Close()
+		},
+	})
+
+	return bsPt
 }

 func (bpt *bsPeerTracker) addPeer(p peer.ID) {
@@ -72,16 +94,7 @@ func (bpt *bsPeerTracker) prefSortedPeers() []peer.ID {
 		var costI, costJ float64

 		getPeerInitLat := func(p peer.ID) float64 {
-			var res float64
-			if bpt.pmgr != nil {
-				if lat, ok := bpt.pmgr.GetPeerLatency(p); ok {
-					res = float64(lat)
-				}
-			}
-			if res == 0 {
-				res = float64(bpt.avgGlobalTime)
-			}
-			return res * newPeerMul
+			return float64(bpt.avgGlobalTime) * newPeerMul
 		}

 		if pi.successes+pi.failures > 0 {
@@ -107,8 +120,8 @@ func (bpt *bsPeerTracker) prefSortedPeers() []peer.ID {
 const (
 	// xInvAlpha = (N+1)/2

-	localInvAlpha  = 5  // 86% of the value is the last 9
-	globalInvAlpha = 20 // 86% of the value is the last 39
+	localInvAlpha  = 10 // 86% of the value is the last 19
+	globalInvAlpha = 25 // 86% of the value is the last 49
 )

 func (bpt *bsPeerTracker) logGlobalSuccess(dur time.Duration) {
@@ -133,7 +146,7 @@ func logTime(pi *peerStats, dur time.Duration) {

 }

-func (bpt *bsPeerTracker) logSuccess(p peer.ID, dur time.Duration) {
+func (bpt *bsPeerTracker) logSuccess(p peer.ID, dur time.Duration, reqSize uint64) {
 	bpt.lk.Lock()
 	defer bpt.lk.Unlock()

@@ -145,10 +158,13 @@ func (bpt *bsPeerTracker) logSuccess(p peer.ID, dur time.Duration) {
 	}

 	pi.successes++
-	logTime(pi, dur)
+	if reqSize == 0 {
+		reqSize = 1
+	}
+	logTime(pi, dur/time.Duration(reqSize))
 }

-func (bpt *bsPeerTracker) logFailure(p peer.ID, dur time.Duration) {
+func (bpt *bsPeerTracker) logFailure(p peer.ID, dur time.Duration, reqSize uint64) {
 	bpt.lk.Lock()
 	defer bpt.lk.Unlock()

@@ -160,7 +176,10 @@ func (bpt *bsPeerTracker) logFailure(p peer.ID, dur time.Duration) {
 	}

 	pi.failures++
-	logTime(pi, dur)
+	if reqSize == 0 {
+		reqSize = 1
+	}
+	logTime(pi, dur/time.Duration(reqSize))
 }

 func (bpt *bsPeerTracker) removePeer(p peer.ID) {
@@ -1,4 +1,4 @@
-package blocksync
+package exchange

 import (
 	"time"
@@ -13,9 +13,17 @@ import (
 	"github.com/filecoin-project/lotus/chain/types"
 )

-var log = logging.Logger("blocksync")
+var log = logging.Logger("chainxchg")

-const BlockSyncProtocolID = "/fil/sync/blk/0.0.1"
+const (
+	// BlockSyncProtocolID is the protocol ID of the former blocksync protocol.
+	// Deprecated.
+	BlockSyncProtocolID = "/fil/sync/blk/0.0.1"
+
+	// ChainExchangeProtocolID is the protocol ID of the chain exchange
+	// protocol.
+	ChainExchangeProtocolID = "/fil/chain/xchg/0.0.1"
+)

 // FIXME: Bumped from original 800 to this to accommodate `syncFork()`
 //  use of `GetBlocks()`. It seems the expectation of that API is to
@@ -25,14 +33,16 @@ const BlockSyncProtocolID = "/fil/sync/blk/0.0.1"
 //   qualifier to avoid "const initializer [...] is not a constant" error.)
 var MaxRequestLength = uint64(build.ForkLengthThreshold)

-// Extracted constants from the code.
-// FIXME: Should be reviewed and confirmed.
-const SUCCESS_PEER_TAG_VALUE = 25
-const WRITE_REQ_DEADLINE = 5 * time.Second
-const READ_RES_DEADLINE = WRITE_REQ_DEADLINE
-const READ_RES_MIN_SPEED = 50 << 10
-const SHUFFLE_PEERS_PREFIX = 5
-const WRITE_RES_DEADLINE = 60 * time.Second
+const (
+	// Extracted constants from the code.
+	// FIXME: Should be reviewed and confirmed.
+	SuccessPeerTagValue = 25
+	WriteReqDeadline    = 5 * time.Second
+	ReadResDeadline     = WriteReqDeadline
+	ReadResMinSpeed     = 50 << 10
+	ShufflePeersPrefix  = 5
+	WriteResDeadline    = 60 * time.Second
+)

 // FIXME: Rename. Make private.
 type Request struct {
@@ -117,7 +127,7 @@ func (res *Response) statusToError() error {
 	case NotFound:
 		return xerrors.Errorf("not found")
 	case GoAway:
-		return xerrors.Errorf("not handling 'go away' blocksync responses yet")
+		return xerrors.Errorf("not handling 'go away' chainxchg responses yet")
 	case InternalError:
 		return xerrors.Errorf("block sync peer errored: %s", res.ErrorMessage)
 	case BadRequest:
@@ -1,4 +1,4 @@
-package blocksync
+package exchange

 import (
 	"bufio"
@@ -18,38 +18,25 @@ import (
 	inet "github.com/libp2p/go-libp2p-core/network"
 )

-// BlockSyncService is the component that services BlockSync requests from
-// peers.
-//
-// BlockSync is the basic chain synchronization protocol of Filecoin. BlockSync
-// is an RPC-oriented protocol, with a single operation to request blocks.
-//
-// A request contains a start anchor block (referred to with a CID), and a
-// amount of blocks requested beyond the anchor (including the anchor itself).
-//
-// A client can also pass options, encoded as a 64-bit bitfield. Lotus supports
-// two options at the moment:
-//
-//  - include block contents
-//  - include block messages
-//
-// The response will include a status code, an optional message, and the
-// response payload in case of success. The payload is a slice of serialized
-// tipsets.
-// FIXME: Rename to just `Server` (will be done later, see note on `BlockSync`).
-type BlockSyncService struct {
+// server implements exchange.Server. It services requests for the
+// libp2p ChainExchange protocol.
+type server struct {
 	cs *store.ChainStore
 }

-func NewBlockSyncService(cs *store.ChainStore) *BlockSyncService {
-	return &BlockSyncService{
+var _ Server = (*server)(nil)
+
+// NewServer creates a new libp2p-based exchange.Server. It services requests
+// for the libp2p ChainExchange protocol.
+func NewServer(cs *store.ChainStore) Server {
+	return &server{
 		cs: cs,
 	}
 }

-// Entry point of the service, handles `Request`s.
-func (server *BlockSyncService) HandleStream(stream inet.Stream) {
-	ctx, span := trace.StartSpan(context.Background(), "blocksync.HandleStream")
+// HandleStream implements Server.HandleStream. Refer to the godocs there.
+func (s *server) HandleStream(stream inet.Stream) {
+	ctx, span := trace.StartSpan(context.Background(), "chainxchg.HandleStream")
 	defer span.End()

 	defer stream.Close() //nolint:errcheck
@@ -62,13 +49,13 @@ func (server *BlockSyncService) HandleStream(stream inet.Stream) {
 	log.Infow("block sync request",
 		"start", req.Head, "len", req.Length)

-	resp, err := server.processRequest(ctx, &req)
+	resp, err := s.processRequest(ctx, &req)
 	if err != nil {
 		log.Warn("failed to process request: ", err)
 		return
 	}

-	_ = stream.SetDeadline(time.Now().Add(WRITE_RES_DEADLINE))
+	_ = stream.SetDeadline(time.Now().Add(WriteResDeadline))
 	if err := cborutil.WriteCborRPC(stream, resp); err != nil {
 		_ = stream.SetDeadline(time.Time{})
 		log.Warnw("failed to write back response for handle stream",
@@ -80,10 +67,7 @@ func (server *BlockSyncService) HandleStream(stream inet.Stream) {

 // Validate and service the request. We return either a protocol
 // response or an internal error.
-func (server *BlockSyncService) processRequest(
-	ctx context.Context,
-	req *Request,
-) (*Response, error) {
+func (s *server) processRequest(ctx context.Context, req *Request) (*Response, error) {
 	validReq, errResponse := validateRequest(ctx, req)
 	if errResponse != nil {
 		// The request did not pass validation, return the response
@@ -91,17 +75,14 @@ func (server *BlockSyncService) processRequest(
 		return errResponse, nil
 	}

-	return server.serviceRequest(ctx, validReq)
+	return s.serviceRequest(ctx, validReq)
 }

 // Validate request. We either return a `validatedRequest`, or an error
 // `Response` indicating why we can't process it. We do not return any
 // internal errors here, we just signal protocol ones.
-func validateRequest(
-	ctx context.Context,
-	req *Request,
-) (*validatedRequest, *Response) {
-	_, span := trace.StartSpan(ctx, "blocksync.ValidateRequest")
+func validateRequest(ctx context.Context, req *Request) (*validatedRequest, *Response) {
+	_, span := trace.StartSpan(ctx, "chainxchg.ValidateRequest")
 	defer span.End()

 	validReq := validatedRequest{}
@@ -147,14 +128,11 @@ func validateRequest(
 	return &validReq, nil
 }

-func (server *BlockSyncService) serviceRequest(
-	ctx context.Context,
-	req *validatedRequest,
-) (*Response, error) {
-	_, span := trace.StartSpan(ctx, "blocksync.ServiceRequest")
+func (s *server) serviceRequest(ctx context.Context, req *validatedRequest) (*Response, error) {
+	_, span := trace.StartSpan(ctx, "chainxchg.ServiceRequest")
 	defer span.End()

-	chain, err := collectChainSegment(server.cs, req)
+	chain, err := collectChainSegment(s.cs, req)
 	if err != nil {
 		log.Warn("block sync request: collectChainSegment failed: ", err)
 		return &Response{
@@ -174,10 +152,7 @@ func (server *BlockSyncService) serviceRequest(
 	}, nil
 }

-func collectChainSegment(
-	cs *store.ChainStore,
-	req *validatedRequest,
-) ([]*BSTipSet, error) {
+func collectChainSegment(cs *store.ChainStore, req *validatedRequest) ([]*BSTipSet, error) {
 	var bstips []*BSTipSet

 	cur := req.head
@@ -59,7 +59,7 @@ type ChainGen struct {

 	cs *store.ChainStore

-	beacon beacon.RandomBeacon
+	beacon beacon.Schedule

 	sm *stmgr.StateManager

@@ -252,7 +252,7 @@ func NewGeneratorWithSectors(numSectors int) (*ChainGen, error) {

 	miners := []address.Address{maddr1, maddr2}

-	beac := beacon.NewMockBeacon(time.Second)
+	beac := beacon.Schedule{{Start: 0, Beacon: beacon.NewMockBeacon(time.Second)}}
 	//beac, err := drand.NewDrandBeacon(tpl.Timestamp, build.BlockDelaySecs)
 	//if err != nil {
 	//return nil, xerrors.Errorf("creating drand beacon: %w", err)
@@ -338,7 +338,7 @@ func (cg *ChainGen) nextBlockProof(ctx context.Context, pts *types.TipSet, m add

 	prev := mbi.PrevBeaconEntry

-	entries, err := beacon.BeaconEntriesForBlock(ctx, cg.beacon, round, prev)
+	entries, err := beacon.BeaconEntriesForBlock(ctx, cg.beacon, round, pts.Height(), prev)
 	if err != nil {
 		return nil, nil, nil, xerrors.Errorf("get beacon entries for block: %w", err)
 	}
@@ -358,7 +358,7 @@ func (cg *ChainGen) nextBlockProof(ctx context.Context, pts *types.TipSet, m add
 		return nil, nil, nil, xerrors.Errorf("failed to cbor marshal address: %w", err)
 	}

-	if len(entries) == 0 {
+	if round > build.UpgradeSmokeHeight {
 		buf.Write(pts.MinTicket().VRFProof)
 	}

@@ -559,7 +559,7 @@ type mca struct {
 	w   *wallet.Wallet
 	sm  *stmgr.StateManager
 	pv  ffiwrapper.Verifier
-	bcn beacon.RandomBeacon
+	bcn beacon.Schedule
 }

 func (mca mca) ChainGetRandomnessFromTickets(ctx context.Context, tsk types.TipSetKey, personalization crypto.DomainSeparationTag, randEpoch abi.ChainEpoch, entropy []byte) (abi.Randomness, error) {
@@ -6,7 +6,7 @@ import (
 	"encoding/json"
 	"fmt"

-	"github.com/filecoin-project/specs-actors/actors/runtime"
+	"github.com/filecoin-project/go-state-types/network"

 	"github.com/ipfs/go-cid"
 	"github.com/ipfs/go-datastore"
@@ -406,8 +406,8 @@ func VerifyPreSealedData(ctx context.Context, cs *store.ChainStore, stateroot ci
 	verifNeeds := make(map[address.Address]abi.PaddedPieceSize)
 	var sum abi.PaddedPieceSize

-	nwv := func(context.Context, abi.ChainEpoch) runtime.NetworkVersion {
-		return runtime.NetworkVersion1
+	nwv := func(context.Context, abi.ChainEpoch) network.Version {
+		return build.NewestNetworkVersion
 	}

 	vmopt := vm.VMOpts{
@@ -6,6 +6,10 @@ import (
 	"fmt"
 	"math/rand"

+	"github.com/filecoin-project/lotus/build"
+
+	"github.com/filecoin-project/go-state-types/network"
+
 	"github.com/filecoin-project/lotus/chain/state"

 	"github.com/ipfs/go-cid"
@@ -61,8 +65,8 @@ func SetupStorageMiners(ctx context.Context, cs *store.ChainStore, sroot cid.Cid
 		return big.Zero(), nil
 	}

-	nwv := func(context.Context, abi.ChainEpoch) runtime.NetworkVersion {
-		return runtime.NetworkVersion1
+	nwv := func(context.Context, abi.ChainEpoch) network.Version {
+		return build.NewestNetworkVersion
 	}

 	vmopt := &vm.VMOpts{
@@ -6,6 +6,7 @@ import (
 	"fmt"

 	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/abi"

 	"github.com/filecoin-project/specs-actors/actors/builtin"
 	"github.com/filecoin-project/specs-actors/actors/util/adt"
@@ -50,7 +51,7 @@ func SetupInitActor(bs bstore.Blockstore, netname string, initialActors []genesi
 				fmt.Printf("init set %s t0%d\n", e, counter)

 				value := cbg.CborInt(counter)
-				if err := amap.Put(adt.AddrKey(e), &value); err != nil {
+				if err := amap.Put(abi.AddrKey(e), &value); err != nil {
 					return 0, nil, nil, err
 				}
 				counter = counter + 1
@@ -77,7 +78,7 @@ func SetupInitActor(bs bstore.Blockstore, netname string, initialActors []genesi
 		fmt.Printf("init set %s t0%d\n", ainfo.Owner, counter)

 		value := cbg.CborInt(counter)
-		if err := amap.Put(adt.AddrKey(ainfo.Owner), &value); err != nil {
+		if err := amap.Put(abi.AddrKey(ainfo.Owner), &value); err != nil {
 			return 0, nil, nil, err
 		}
 		counter = counter + 1
@@ -95,7 +96,7 @@ func SetupInitActor(bs bstore.Blockstore, netname string, initialActors []genesi
 			return 0, nil, nil, xerrors.Errorf("unmarshaling account meta: %w", err)
 		}
 		value := cbg.CborInt(80)
-		if err := amap.Put(adt.AddrKey(ainfo.Owner), &value); err != nil {
+		if err := amap.Put(abi.AddrKey(ainfo.Owner), &value); err != nil {
 			return 0, nil, nil, err
 		}
 	} else if rootVerifier.Type == genesis.TMultisig {
@@ -110,7 +111,7 @@ func SetupInitActor(bs bstore.Blockstore, netname string, initialActors []genesi
 			fmt.Printf("init set %s t0%d\n", e, counter)

 			value := cbg.CborInt(counter)
-			if err := amap.Put(adt.AddrKey(e), &value); err != nil {
+			if err := amap.Put(abi.AddrKey(e), &value); err != nil {
 				return 0, nil, nil, err
 			}
 			counter = counter + 1
@@ -11,6 +11,8 @@ import (
 	"sync"
 	"time"

+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/big"
 	"github.com/filecoin-project/go-state-types/crypto"
 	"github.com/hashicorp/go-multierror"
 	lru "github.com/hashicorp/golang-lru"
@@ -30,6 +32,7 @@ import (
 	"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/journal"
 	"github.com/filecoin-project/lotus/lib/sigs"
 	"github.com/filecoin-project/lotus/node/modules/dtypes"

@@ -49,6 +52,7 @@ var RepublishInterval = time.Duration(10*build.BlockDelaySecs+build.PropagationD

 var minimumBaseFee = types.NewInt(uint64(build.MinimumBaseFee))
 var baseFeeLowerBoundFactor = types.NewInt(10)
+var baseFeeLowerBoundFactorConservative = types.NewInt(100)

 var MaxActorPendingMessages = 1000

@@ -81,9 +85,25 @@ const (
 	localUpdates = "update"
 )

-// this is *temporary* mutilation until we have implemented uncapped miner penalties -- it will go
-// away in the next fork.
-var strictBaseFeeValidation = false
+// Journal event types.
+const (
+	evtTypeMpoolAdd = iota
+	evtTypeMpoolRemove
+	evtTypeMpoolRepub
+)
+
+// MessagePoolEvt is the journal entry for message pool events.
+type MessagePoolEvt struct {
+	Action   string
+	Messages []MessagePoolEvtMessage
+	Error    error `json:",omitempty"`
+}
+
+type MessagePoolEvtMessage struct {
+	types.Message
+
+	CID cid.Cid
+}

 func init() {
 	// if the republish interval is too short compared to the pubsub timecache, adjust it
@@ -138,6 +158,8 @@ type MessagePool struct {
 	netName dtypes.NetworkName

 	sigValCache *lru.TwoQueueCache
+
+	evtTypes [3]journal.EventType
 }

 type msgSet struct {
@@ -154,6 +176,27 @@ func newMsgSet(nonce uint64) *msgSet {
 	}
 }

+func ComputeMinRBF(curPrem abi.TokenAmount) abi.TokenAmount {
+	minPrice := types.BigAdd(curPrem, types.BigDiv(types.BigMul(curPrem, rbfNumBig), rbfDenomBig))
+	return types.BigAdd(minPrice, types.NewInt(1))
+}
+
+func CapGasFee(msg *types.Message, maxFee abi.TokenAmount) {
+	if maxFee.Equals(big.Zero()) {
+		maxFee = types.NewInt(build.FilecoinPrecision / 10)
+	}
+
+	gl := types.NewInt(uint64(msg.GasLimit))
+	totalFee := types.BigMul(msg.GasFeeCap, gl)
+
+	if totalFee.LessThanEqual(maxFee) {
+		return
+	}
+
+	msg.GasFeeCap = big.Div(maxFee, gl)
+	msg.GasPremium = big.Min(msg.GasFeeCap, msg.GasPremium) // cap premium at FeeCap
+}
+
 func (ms *msgSet) add(m *types.SignedMessage, mp *MessagePool, strict bool) (bool, error) {
 	nextNonce := ms.nextNonce
 	nonceGap := false
@@ -181,9 +224,7 @@ func (ms *msgSet) add(m *types.SignedMessage, mp *MessagePool, strict bool) (boo

 		if m.Cid() != exms.Cid() {
 			// check if RBF passes
-			minPrice := exms.Message.GasPremium
-			minPrice = types.BigAdd(minPrice, types.BigDiv(types.BigMul(minPrice, rbfNumBig), rbfDenomBig))
-			minPrice = types.BigAdd(minPrice, types.NewInt(1))
+			minPrice := ComputeMinRBF(exms.Message.GasPremium)
 			if types.BigCmp(m.Message.GasPremium, minPrice) >= 0 {
 				log.Infow("add with RBF", "oldpremium", exms.Message.GasPremium,
 					"newpremium", m.Message.GasPremium, "addr", m.Message.From, "nonce", m.Message.Nonce)
@@ -295,6 +336,11 @@ func New(api Provider, ds dtypes.MetadataDS, netName dtypes.NetworkName) (*Messa
 		api:           api,
 		netName:       netName,
 		cfg:           cfg,
+		evtTypes: [...]journal.EventType{
+			evtTypeMpoolAdd:    journal.J.RegisterEventType("mpool", "add"),
+			evtTypeMpoolRemove: journal.J.RegisterEventType("mpool", "remove"),
+			evtTypeMpoolRepub:  journal.J.RegisterEventType("mpool", "repub"),
+		},
 	}

 	// enable initial prunes
@@ -346,10 +392,12 @@ func (mp *MessagePool) runLoop() {
 			if err := mp.republishPendingMessages(); err != nil {
 				log.Errorf("error while republishing messages: %s", err)
 			}
+
 		case <-mp.pruneTrigger:
 			if err := mp.pruneExcessMessages(); err != nil {
 				log.Errorf("failed to prune excess messages from mempool: %s", err)
 			}
+
 		case <-mp.closer:
 			mp.repubTk.Stop()
 			return
@@ -393,18 +441,27 @@ func (mp *MessagePool) verifyMsgBeforeAdd(m *types.SignedMessage, curTs *types.T
 	// Note that for local messages, we always add them so that they can be accepted and republished
 	// automatically.
 	publish := local
-	if strictBaseFeeValidation && len(curTs.Blocks()) > 0 {
-		baseFee := curTs.Blocks()[0].ParentBaseFee
-		baseFeeLowerBound := types.BigDiv(baseFee, baseFeeLowerBoundFactor)
-		if m.Message.GasFeeCap.LessThan(baseFeeLowerBound) {
-			if local {
-				log.Warnf("local message will not be immediately published because GasFeeCap doesn't meet the lower bound for inclusion in the next 20 blocks (GasFeeCap: %s, baseFeeLowerBound: %s)",
-					m.Message.GasFeeCap, baseFeeLowerBound)
-				publish = false
-			} else {
-				return false, xerrors.Errorf("GasFeeCap doesn't meet base fee lower bound for inclusion in the next 20 blocks (GasFeeCap: %s, baseFeeLowerBound: %s): %w",
-					m.Message.GasFeeCap, baseFeeLowerBound, ErrSoftValidationFailure)
-			}
+
+	var baseFee big.Int
+	if len(curTs.Blocks()) > 0 {
+		baseFee = curTs.Blocks()[0].ParentBaseFee
+	} else {
+		var err error
+		baseFee, err = mp.api.ChainComputeBaseFee(context.TODO(), curTs)
+		if err != nil {
+			return false, xerrors.Errorf("computing basefee: %w", err)
+		}
+	}
+
+	baseFeeLowerBound := getBaseFeeLowerBound(baseFee, baseFeeLowerBoundFactorConservative)
+	if m.Message.GasFeeCap.LessThan(baseFeeLowerBound) {
+		if local {
+			log.Warnf("local message will not be immediately published because GasFeeCap doesn't meet the lower bound for inclusion in the next 20 blocks (GasFeeCap: %s, baseFeeLowerBound: %s)",
+				m.Message.GasFeeCap, baseFeeLowerBound)
+			publish = false
+		} else {
+			return false, xerrors.Errorf("GasFeeCap doesn't meet base fee lower bound for inclusion in the next 20 blocks (GasFeeCap: %s, baseFeeLowerBound: %s): %w",
+				m.Message.GasFeeCap, baseFeeLowerBound, ErrSoftValidationFailure)
 		}
 	}

@@ -586,7 +643,7 @@ func (mp *MessagePool) addTs(m *types.SignedMessage, curTs *types.TipSet, local
 		return false, err
 	}

-	return publish, mp.addLocked(m, true)
+	return publish, mp.addLocked(m, !local)
 }

 func (mp *MessagePool) addLoaded(m *types.SignedMessage) error {
@@ -679,6 +736,14 @@ func (mp *MessagePool) addLocked(m *types.SignedMessage, strict bool) error {
 		Type:    api.MpoolAdd,
 		Message: m,
 	}, localUpdates)
+
+	journal.J.RecordEvent(mp.evtTypes[evtTypeMpoolAdd], func() interface{} {
+		return MessagePoolEvt{
+			Action:   "add",
+			Messages: []MessagePoolEvtMessage{{Message: m.Message, CID: m.Cid()}},
+		}
+	})
+
 	return nil
 }

@@ -808,7 +873,7 @@ func (mp *MessagePool) PushWithNonce(ctx context.Context, addr address.Address,
 		return nil, err
 	}

-	if err := mp.addLocked(msg, true); err != nil {
+	if err := mp.addLocked(msg, false); err != nil {
 		return nil, xerrors.Errorf("add locked failed: %w", err)
 	}
 	if err := mp.addLocal(msg, msgb); err != nil {
@@ -841,6 +906,12 @@ func (mp *MessagePool) remove(from address.Address, nonce uint64, applied bool)
 			Message: m,
 		}, localUpdates)

+		journal.J.RecordEvent(mp.evtTypes[evtTypeMpoolRemove], func() interface{} {
+			return MessagePoolEvt{
+				Action:   "remove",
+				Messages: []MessagePoolEvtMessage{{Message: m.Message, CID: m.Cid()}}}
+		})
+
 		mp.currentSize--
 	}

@@ -1278,3 +1349,12 @@ func (mp *MessagePool) Clear(local bool) {
 		delete(mp.pending, a)
 	}
 }
+
+func getBaseFeeLowerBound(baseFee, factor types.BigInt) types.BigInt {
+	baseFeeLowerBound := types.BigDiv(baseFee, factor)
+	if baseFeeLowerBound.LessThan(minimumBaseFee) {
+		baseFeeLowerBound = minimumBaseFee
+	}
+
+	return baseFeeLowerBound
+}
@@ -7,6 +7,7 @@ import (
 	"testing"

 	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/crypto"
 	"github.com/filecoin-project/lotus/chain/messagepool/gasguess"
 	"github.com/filecoin-project/lotus/chain/types"
@@ -56,6 +57,13 @@ func (tma *testMpoolAPI) nextBlock() *types.BlockHeader {
 	return newBlk
 }

+func (tma *testMpoolAPI) nextBlockWithHeight(height uint64) *types.BlockHeader {
+	newBlk := mock.MkBlock(tma.tipsets[len(tma.tipsets)-1], 1, 1)
+	newBlk.Height = abi.ChainEpoch(height)
+	tma.tipsets = append(tma.tipsets, mock.TipSet(newBlk))
+	return newBlk
+}
+
 func (tma *testMpoolAPI) applyBlock(t *testing.T, b *types.BlockHeader) {
 	t.Helper()
 	if err := tma.cb(nil, []*types.TipSet{mock.TipSet(b)}); err != nil {
@@ -46,13 +46,21 @@ func (mp *MessagePool) pruneMessages(ctx context.Context, ts *types.TipSet) erro
 	if err != nil {
 		return xerrors.Errorf("computing basefee: %w", err)
 	}
+	baseFeeLowerBound := getBaseFeeLowerBound(baseFee, baseFeeLowerBoundFactor)

 	pending, _ := mp.getPendingMessages(ts, ts)

-	// priority actors -- not pruned
-	priority := make(map[address.Address]struct{})
+	// protected actors -- not pruned
+	protected := make(map[address.Address]struct{})
+
+	// we never prune priority addresses
 	for _, actor := range mp.cfg.PriorityAddrs {
-		priority[actor] = struct{}{}
+		protected[actor] = struct{}{}
+	}
+
+	// we also never prune locally published messages
+	for actor := range mp.localAddrs {
+		protected[actor] = struct{}{}
 	}

 	// Collect all messages to track which ones to remove and create chains for block inclusion
@@ -61,18 +69,18 @@ func (mp *MessagePool) pruneMessages(ctx context.Context, ts *types.TipSet) erro

 	var chains []*msgChain
 	for actor, mset := range pending {
-		// we never prune priority actors
-		_, keep := priority[actor]
+		// we never prune protected actors
+		_, keep := protected[actor]
 		if keep {
 			keepCount += len(mset)
 			continue
 		}

-		// not a priority actor, track the messages and create chains
+		// not a protected actor, track the messages and create chains
 		for _, m := range mset {
 			pruneMsgs[m.Message.Cid()] = m
 		}
-		actorChains := mp.createMessageChains(actor, mset, baseFee, ts)
+		actorChains := mp.createMessageChains(actor, mset, baseFeeLowerBound, ts)
 		chains = append(chains, actorChains...)
 	}

@@ -11,6 +11,7 @@ import (
 	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain/messagepool/gasguess"
 	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/journal"
 	"github.com/ipfs/go-cid"
 )

@@ -27,7 +28,7 @@ func (mp *MessagePool) republishPendingMessages() error {
 		mp.curTsLk.Unlock()
 		return xerrors.Errorf("computing basefee: %w", err)
 	}
-	baseFeeLowerBound := types.BigDiv(baseFee, baseFeeLowerBoundFactor)
+	baseFeeLowerBound := getBaseFeeLowerBound(baseFee, baseFeeLowerBoundFactor)

 	pending := make(map[address.Address]map[uint64]*types.SignedMessage)
 	mp.lk.Lock()
@@ -146,6 +147,19 @@ loop:
 		}
 	}

+	if len(msgs) > 0 {
+		journal.J.RecordEvent(mp.evtTypes[evtTypeMpoolRepub], func() interface{} {
+			msgs := make([]MessagePoolEvtMessage, 0, len(msgs))
+			for _, m := range msgs {
+				msgs = append(msgs, MessagePoolEvtMessage{Message: m.Message, CID: m.Cid()})
+			}
+			return MessagePoolEvt{
+				Action:   "repub",
+				Messages: msgs,
+			}
+		})
+	}
+
 	// track most recently republished messages
 	republished := make(map[cid.Cid]struct{})
 	for _, m := range msgs[:count] {
@@ -3,6 +3,7 @@ package messagepool
 import (
 	"context"
 	"math/big"
+	"math/rand"
 	"sort"
 	"time"

@@ -198,9 +199,11 @@ func (mp *MessagePool) selectMessagesOptimal(curTs, ts *types.TipSet, tq float64
 			gasLimit -= chainGasLimit

 			// resort to account for already merged chains and effective performance adjustments
-			sort.Slice(chains[i+1:], func(i, j int) bool {
+			// the sort *must* be stable or we end up getting negative gasPerfs pushed up.
+			sort.SliceStable(chains[i+1:], func(i, j int) bool {
 				return chains[i].BeforeEffective(chains[j])
 			})
+
 			continue
 		}

@@ -304,6 +307,79 @@ tailLoop:
 		log.Infow("pack tail chains done", "took", dt)
 	}

+	// if we have gasLimit to spare, pick some random (non-negative) chains to fill the block
+	// we pick randomly so that we minimize the probability of duplication among all miners
+	if gasLimit >= minGas {
+		randomCount := 0
+
+		startRandom := time.Now()
+		shuffleChains(chains)
+
+		for _, chain := range chains {
+			// have we filled the block
+			if gasLimit < minGas {
+				break
+			}
+
+			// has it been merged or invalidated?
+			if chain.merged || !chain.valid {
+				continue
+			}
+
+			// is it negative?
+			if !allowNegativeChains(curTs.Height()) && chain.gasPerf < 0 {
+				continue
+			}
+
+			// compute the dependencies that must be merged and the gas limit including deps
+			chainGasLimit := chain.gasLimit
+			depGasLimit := int64(0)
+			var chainDeps []*msgChain
+			for curChain := chain.prev; curChain != nil && !curChain.merged; curChain = curChain.prev {
+				chainDeps = append(chainDeps, curChain)
+				chainGasLimit += curChain.gasLimit
+				depGasLimit += curChain.gasLimit
+			}
+
+			// do the deps fit? if the deps won't fit, invalidate the chain
+			if depGasLimit > gasLimit {
+				chain.Invalidate()
+				continue
+			}
+
+			// do they fit as is? if it doesn't, trim to make it fit if possible
+			if chainGasLimit > gasLimit {
+				chain.Trim(gasLimit-depGasLimit, mp, baseFee, allowNegativeChains(curTs.Height()))
+
+				if !chain.valid {
+					continue
+				}
+			}
+
+			// include it together with all dependencies
+			for i := len(chainDeps) - 1; i >= 0; i-- {
+				curChain := chainDeps[i]
+				curChain.merged = true
+				result = append(result, curChain.msgs...)
+				randomCount += len(curChain.msgs)
+			}
+
+			chain.merged = true
+			result = append(result, chain.msgs...)
+			randomCount += len(chain.msgs)
+			gasLimit -= chainGasLimit
+		}
+
+		if dt := time.Since(startRandom); dt > time.Millisecond {
+			log.Infow("pack random tail chains done", "took", dt)
+		}
+
+		if randomCount > 0 {
+			log.Warnf("optimal selection failed to pack a block; picked %d messages with random selection",
+				randomCount)
+		}
+	}
+
 	return result, nil
 }

@@ -848,7 +924,16 @@ func (mc *msgChain) SetNullEffectivePerf() {

 func (mc *msgChain) BeforeEffective(other *msgChain) bool {
 	// move merged chains to the front so we can discard them earlier
-	return (mc.merged && !other.merged) || mc.effPerf > other.effPerf ||
+	return (mc.merged && !other.merged) ||
+		(mc.gasPerf >= 0 && other.gasPerf < 0) ||
+		mc.effPerf > other.effPerf ||
 		(mc.effPerf == other.effPerf && mc.gasPerf > other.gasPerf) ||
 		(mc.effPerf == other.effPerf && mc.gasPerf == other.gasPerf && mc.gasReward.Cmp(other.gasReward) > 0)
 }
+
+func shuffleChains(lst []*msgChain) {
+	for i := range lst {
+		j := rand.Intn(i + 1)
+		lst[i], lst[j] = lst[j], lst[i]
+	}
+}
@@ -1,11 +1,16 @@
 package messagepool

 import (
+	"compress/gzip"
 	"context"
+	"encoding/json"
 	"fmt"
+	"io"
 	"math"
 	"math/big"
 	"math/rand"
+	"os"
+	"sort"
 	"testing"

 	"github.com/filecoin-project/go-address"
@@ -1281,3 +1286,177 @@ func TestGasReward(t *testing.T) {
 		})
 	}
 }
+
+func TestRealWorldSelection(t *testing.T) {
+	// load test-messages.json.gz and rewrite the messages so that
+	// 1) we map each real actor to a test actor so that we can sign the messages
+	// 2) adjust the nonces so that they start from 0
+	file, err := os.Open("test-messages.json.gz")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	gzr, err := gzip.NewReader(file)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	dec := json.NewDecoder(gzr)
+
+	var msgs []*types.SignedMessage
+	baseNonces := make(map[address.Address]uint64)
+
+readLoop:
+	for {
+		m := new(types.SignedMessage)
+		err := dec.Decode(m)
+		switch err {
+		case nil:
+			msgs = append(msgs, m)
+			nonce, ok := baseNonces[m.Message.From]
+			if !ok || m.Message.Nonce < nonce {
+				baseNonces[m.Message.From] = m.Message.Nonce
+			}
+
+		case io.EOF:
+			break readLoop
+
+		default:
+			t.Fatal(err)
+		}
+	}
+
+	actorMap := make(map[address.Address]address.Address)
+	actorWallets := make(map[address.Address]*wallet.Wallet)
+
+	for _, m := range msgs {
+		baseNonce := baseNonces[m.Message.From]
+
+		localActor, ok := actorMap[m.Message.From]
+		if !ok {
+			w, err := wallet.NewWallet(wallet.NewMemKeyStore())
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			a, err := w.GenerateKey(crypto.SigTypeSecp256k1)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			actorMap[m.Message.From] = a
+			actorWallets[a] = w
+			localActor = a
+		}
+
+		w, ok := actorWallets[localActor]
+		if !ok {
+			t.Fatalf("failed to lookup wallet for actor %s", localActor)
+		}
+
+		m.Message.From = localActor
+		m.Message.Nonce -= baseNonce
+
+		sig, err := w.Sign(context.TODO(), localActor, m.Message.Cid().Bytes())
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		m.Signature = *sig
+	}
+
+	mp, tma := makeTestMpool()
+
+	block := tma.nextBlockWithHeight(build.UpgradeBreezeHeight + 10)
+	ts := mock.TipSet(block)
+	tma.applyBlock(t, block)
+
+	for _, a := range actorMap {
+		tma.setBalance(a, 1000000)
+	}
+
+	tma.baseFee = types.NewInt(800_000_000)
+
+	sort.Slice(msgs, func(i, j int) bool {
+		return msgs[i].Message.Nonce < msgs[j].Message.Nonce
+	})
+
+	// add the messages
+	for _, m := range msgs {
+		mustAdd(t, mp, m)
+	}
+
+	// do message selection and check block packing
+	minGasLimit := int64(0.9 * float64(build.BlockGasLimit))
+
+	// greedy first
+	selected, err := mp.SelectMessages(ts, 1.0)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	gasLimit := int64(0)
+	for _, m := range selected {
+		gasLimit += m.Message.GasLimit
+	}
+	if gasLimit < minGasLimit {
+		t.Fatalf("failed to pack with tq=1.0; packed %d, minimum packing: %d", gasLimit, minGasLimit)
+	}
+
+	// high quality ticket
+	selected, err = mp.SelectMessages(ts, .8)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	gasLimit = int64(0)
+	for _, m := range selected {
+		gasLimit += m.Message.GasLimit
+	}
+	if gasLimit < minGasLimit {
+		t.Fatalf("failed to pack with tq=0.8; packed %d, minimum packing: %d", gasLimit, minGasLimit)
+	}
+
+	// mid quality ticket
+	selected, err = mp.SelectMessages(ts, .4)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	gasLimit = int64(0)
+	for _, m := range selected {
+		gasLimit += m.Message.GasLimit
+	}
+	if gasLimit < minGasLimit {
+		t.Fatalf("failed to pack with tq=0.4; packed %d, minimum packing: %d", gasLimit, minGasLimit)
+	}
+
+	// low quality ticket
+	selected, err = mp.SelectMessages(ts, .1)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	gasLimit = int64(0)
+	for _, m := range selected {
+		gasLimit += m.Message.GasLimit
+	}
+	if gasLimit < minGasLimit {
+		t.Fatalf("failed to pack with tq=0.1; packed %d, minimum packing: %d", gasLimit, minGasLimit)
+	}
+
+	// very low quality ticket
+	selected, err = mp.SelectMessages(ts, .01)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	gasLimit = int64(0)
+	for _, m := range selected {
+		gasLimit += m.Message.GasLimit
+	}
+	if gasLimit < minGasLimit {
+		t.Fatalf("failed to pack with tq=0.01; packed %d, minimum packing: %d", gasLimit, minGasLimit)
+	}
+
+}
@@ -4,6 +4,7 @@ import (
 	"context"
 	"fmt"

+	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/specs-actors/actors/builtin"
 	init_ "github.com/filecoin-project/specs-actors/actors/builtin/init"

@@ -209,7 +210,7 @@ func (st *StateTree) GetActor(addr address.Address) (*types.Actor, error) {
 	}

 	var act types.Actor
-	if found, err := st.root.Get(adt.AddrKey(addr), &act); err != nil {
+	if found, err := st.root.Get(abi.AddrKey(addr), &act); err != nil {
 		return nil, xerrors.Errorf("hamt find failed: %w", err)
 	} else if !found {
 		return nil, types.ErrActorNotFound
@@ -254,11 +255,11 @@ func (st *StateTree) Flush(ctx context.Context) (cid.Cid, error) {

 	for addr, sto := range st.snaps.layers[0].actors {
 		if sto.Delete {
-			if err := st.root.Delete(adt.AddrKey(addr)); err != nil {
+			if err := st.root.Delete(abi.AddrKey(addr)); err != nil {
 				return cid.Undef, err
 			}
 		} else {
-			if err := st.root.Put(adt.AddrKey(addr), &sto.Act); err != nil {
+			if err := st.root.Put(abi.AddrKey(addr), &sto.Act); err != nil {
 				return cid.Undef, err
 			}
 		}
@@ -17,14 +17,14 @@ import (
 	"golang.org/x/xerrors"
 )

-var ForksAtHeight = map[abi.ChainEpoch]func(context.Context, *StateManager, types.StateTree) error{
+var ForksAtHeight = map[abi.ChainEpoch]func(context.Context, *StateManager, types.StateTree, *types.TipSet) error{
 	build.UpgradeBreezeHeight: UpgradeFaucetBurnRecovery,
 }

-func (sm *StateManager) handleStateForks(ctx context.Context, st types.StateTree, height abi.ChainEpoch) (err error) {
+func (sm *StateManager) handleStateForks(ctx context.Context, st types.StateTree, height abi.ChainEpoch, ts *types.TipSet) (err error) {
 	f, ok := ForksAtHeight[height]
 	if ok {
-		err := f(ctx, sm, st)
+		err := f(ctx, sm, st, ts)
 		if err != nil {
 			return err
 		}
@@ -66,7 +66,7 @@ func doTransfer(tree types.StateTree, from, to address.Address, amt abi.TokenAmo
 	return nil
 }

-func UpgradeFaucetBurnRecovery(ctx context.Context, sm *StateManager, tree types.StateTree) error {
+func UpgradeFaucetBurnRecovery(ctx context.Context, sm *StateManager, tree types.StateTree, ts *types.TipSet) error {
 	// Some initial parameters
 	FundsForMiners := types.FromFil(1_000_000)
 	LookbackEpoch := abi.ChainEpoch(32000)
@@ -91,7 +91,7 @@ func UpgradeFaucetBurnRecovery(ctx context.Context, sm *StateManager, tree types
 	}

 	// Grab lookback state for account checks
-	lbts, err := sm.ChainStore().GetTipsetByHeight(ctx, LookbackEpoch, nil, false)
+	lbts, err := sm.ChainStore().GetTipsetByHeight(ctx, LookbackEpoch, ts, false)
 	if err != nil {
 		return xerrors.Errorf("failed to get tipset at lookback height: %w", err)
 	}
@@ -15,7 +15,6 @@ import (
 	"github.com/filecoin-project/specs-actors/actors/builtin/power"
 	"github.com/filecoin-project/specs-actors/actors/builtin/verifreg"
 	"github.com/filecoin-project/specs-actors/actors/runtime"
-	"github.com/filecoin-project/specs-actors/actors/util/adt"
 	"golang.org/x/xerrors"

 	"github.com/filecoin-project/lotus/chain/actors"
@@ -73,18 +72,18 @@ func (ta *testActor) Exports() []interface{} {
 	}
 }

-func (ta *testActor) Constructor(rt runtime.Runtime, params *adt.EmptyValue) *adt.EmptyValue {
+func (ta *testActor) Constructor(rt runtime.Runtime, params *abi.EmptyValue) *abi.EmptyValue {
 	rt.ValidateImmediateCallerAcceptAny()
-	rt.State().Create(&testActorState{11})
-	fmt.Println("NEW ACTOR ADDRESS IS: ", rt.Message().Receiver())
+	rt.StateCreate(&testActorState{11})
+	fmt.Println("NEW ACTOR ADDRESS IS: ", rt.Receiver())

-	return adt.Empty
+	return abi.Empty
 }

-func (ta *testActor) TestMethod(rt runtime.Runtime, params *adt.EmptyValue) *adt.EmptyValue {
+func (ta *testActor) TestMethod(rt runtime.Runtime, params *abi.EmptyValue) *abi.EmptyValue {
 	rt.ValidateImmediateCallerAcceptAny()
 	var st testActorState
-	rt.State().Readonly(&st)
+	rt.StateReadonly(&st)

 	if rt.CurrEpoch() > testForkHeight {
 		if st.HasUpgraded != 55 {
@@ -96,7 +95,7 @@ func (ta *testActor) TestMethod(rt runtime.Runtime, params *adt.EmptyValue) *adt
 		}
 	}

-	return adt.Empty
+	return abi.Empty
 }

 func TestForkHeightTriggers(t *testing.T) {
@@ -119,7 +118,7 @@ func TestForkHeightTriggers(t *testing.T) {
 		t.Fatal(err)
 	}

-	stmgr.ForksAtHeight[testForkHeight] = func(ctx context.Context, sm *StateManager, st types.StateTree) error {
+	stmgr.ForksAtHeight[testForkHeight] = func(ctx context.Context, sm *StateManager, st types.StateTree, ts *types.TipSet) error {
 		cst := cbor.NewCborStore(sm.ChainStore().Blockstore())

 		act, err := st.GetActor(taddr)
@@ -5,7 +5,7 @@ import (
 	"fmt"
 	"sync"

-	"github.com/filecoin-project/specs-actors/actors/runtime"
+	"github.com/filecoin-project/go-state-types/network"

 	"github.com/filecoin-project/specs-actors/actors/builtin/power"

@@ -147,7 +147,7 @@ func (sm *StateManager) ExecutionTrace(ctx context.Context, ts *types.TipSet) (c

 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) (cid.Cid, cid.Cid, 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,
@@ -201,7 +201,7 @@ func (sm *StateManager) ApplyBlocks(ctx context.Context, parentEpoch abi.ChainEp

 	for i := parentEpoch; i < epoch; i++ {
 		// handle state forks
-		err = sm.handleStateForks(ctx, vmi.StateTree(), i)
+		err = sm.handleStateForks(ctx, vmi.StateTree(), i, ts)
 		if err != nil {
 			return cid.Undef, cid.Undef, xerrors.Errorf("error handling state forks: %w", err)
 		}
@@ -233,8 +233,8 @@ func (sm *StateManager) ApplyBlocks(ctx context.Context, parentEpoch abi.ChainEp
 			}

 			receipts = append(receipts, &r.MessageReceipt)
-			gasReward = big.Add(gasReward, r.MinerTip)
-			penalty = big.Add(penalty, r.Penalty)
+			gasReward = big.Add(gasReward, r.GasCosts.MinerTip)
+			penalty = big.Add(penalty, r.GasCosts.MinerPenalty)

 			if cb != nil {
 				if err := cb(cm.Cid(), m, r); err != nil {
@@ -350,7 +350,7 @@ func (sm *StateManager) computeTipSetState(ctx context.Context, ts *types.TipSet

 	baseFee := blks[0].ParentBaseFee

-	return sm.ApplyBlocks(ctx, parentEpoch, pstate, blkmsgs, blks[0].Height, r, cb, baseFee)
+	return sm.ApplyBlocks(ctx, parentEpoch, pstate, blkmsgs, blks[0].Height, r, cb, baseFee, ts)
 }

 func (sm *StateManager) parentState(ts *types.TipSet) cid.Cid {
@@ -1124,14 +1124,18 @@ func (sm *StateManager) GetCirculatingSupply(ctx context.Context, height abi.Cha
 	return csi.FilCirculating, nil
 }

-func (sm *StateManager) GetNtwkVersion(ctx context.Context, height abi.ChainEpoch) runtime.NetworkVersion {
-	if build.UpgradeBreezeHeight == 0 {
-		return runtime.NetworkVersion1
+func (sm *StateManager) GetNtwkVersion(ctx context.Context, height abi.ChainEpoch) network.Version {
+	if build.UseNewestNetwork() {
+		return build.NewestNetworkVersion
 	}

 	if height <= build.UpgradeBreezeHeight {
-		return runtime.NetworkVersion0
+		return network.Version0
 	}

-	return runtime.NetworkVersion1
+	if height <= build.UpgradeSmokeHeight {
+		return network.Version1
+	}
+
+	return build.NewestNetworkVersion
 }
@@ -120,7 +120,7 @@ func GetPowerRaw(ctx context.Context, sm *StateManager, st cid.Cid, maddr addres
 		}

 		var claim power.Claim
-		if _, err := cm.Get(adt.AddrKey(maddr), &claim); err != nil {
+		if _, err := cm.Get(abi.AddrKey(maddr), &claim); err != nil {
 			return power.Claim{}, power.Claim{}, err
 		}

@@ -312,7 +312,7 @@ func GetMinerSlashed(ctx context.Context, sm *StateManager, ts *types.TipSet, ma
 		return false, err
 	}

-	ok, err := claims.Get(power.AddrKey(maddr), nil)
+	ok, err := claims.Get(abi.AddrKey(maddr), nil)
 	if err != nil {
 		return false, err
 	}
@@ -456,7 +456,7 @@ func ComputeState(ctx context.Context, sm *StateManager, height abi.ChainEpoch,

 	for i := ts.Height(); i < height; i++ {
 		// handle state forks
-		err = sm.handleStateForks(ctx, vmi.StateTree(), i)
+		err = sm.handleStateForks(ctx, vmi.StateTree(), i, ts)
 		if err != nil {
 			return cid.Undef, nil, xerrors.Errorf("error handling state forks: %w", err)
 		}
@@ -502,7 +502,7 @@ func GetLookbackTipSetForRound(ctx context.Context, sm *StateManager, ts *types.
 	return lbts, nil
 }

-func MinerGetBaseInfo(ctx context.Context, sm *StateManager, bcn beacon.RandomBeacon, tsk types.TipSetKey, round abi.ChainEpoch, maddr address.Address, pv ffiwrapper.Verifier) (*api.MiningBaseInfo, error) {
+func MinerGetBaseInfo(ctx context.Context, sm *StateManager, bcs beacon.Schedule, tsk types.TipSetKey, round abi.ChainEpoch, maddr address.Address, pv ffiwrapper.Verifier) (*api.MiningBaseInfo, error) {
 	ts, err := sm.ChainStore().LoadTipSet(tsk)
 	if err != nil {
 		return nil, xerrors.Errorf("failed to load tipset for mining base: %w", err)
@@ -517,7 +517,7 @@ func MinerGetBaseInfo(ctx context.Context, sm *StateManager, bcn beacon.RandomBe
 		prev = &types.BeaconEntry{}
 	}

-	entries, err := beacon.BeaconEntriesForBlock(ctx, bcn, round, *prev)
+	entries, err := beacon.BeaconEntriesForBlock(ctx, bcs, round, ts.Height(), *prev)
 	if err != nil {
 		return nil, err
 	}
@@ -554,7 +554,7 @@ func MinerGetBaseInfo(ctx context.Context, sm *StateManager, bcn beacon.RandomBe

 	sectors, err := GetSectorsForWinningPoSt(ctx, pv, sm, lbst, maddr, prand)
 	if err != nil {
-		return nil, xerrors.Errorf("getting wpost proving set: %w", err)
+		return nil, xerrors.Errorf("getting winning post proving set: %w", err)
 	}

 	if len(sectors) == 0 {
@@ -624,8 +624,8 @@ func init() {
 		// Explicitly add send, it's special.
 		methods[builtin.MethodSend] = MethodMeta{
 			Name:   "Send",
-			Params: reflect.TypeOf(new(adt.EmptyValue)),
-			Ret:    reflect.TypeOf(new(adt.EmptyValue)),
+			Params: reflect.TypeOf(new(abi.EmptyValue)),
+			Ret:    reflect.TypeOf(new(abi.EmptyValue)),
 		}

 		// Learn method names from the builtin.Methods* structs.
@@ -11,14 +11,20 @@ import (
 	"golang.org/x/xerrors"
 )

-func computeNextBaseFee(baseFee types.BigInt, gasLimitUsed int64, noOfBlocks int) types.BigInt {
-	// deta := 1/PackingEfficiency * gasLimitUsed/noOfBlocks - build.BlockGasTarget
-	// change := baseFee * deta / BlockGasTarget / BaseFeeMaxChangeDenom
+func ComputeNextBaseFee(baseFee types.BigInt, gasLimitUsed int64, noOfBlocks int, epoch abi.ChainEpoch) types.BigInt {
+	// deta := gasLimitUsed/noOfBlocks - build.BlockGasTarget
+	// change := baseFee * deta / BlockGasTarget
 	// nextBaseFee = baseFee + change
 	// nextBaseFee = max(nextBaseFee, build.MinimumBaseFee)

-	delta := build.PackingEfficiencyDenom * gasLimitUsed / (int64(noOfBlocks) * build.PackingEfficiencyNum)
-	delta -= build.BlockGasTarget
+	var delta int64
+	if epoch > build.UpgradeSmokeHeight {
+		delta = gasLimitUsed / int64(noOfBlocks)
+		delta -= build.BlockGasTarget
+	} else {
+		delta = build.PackingEfficiencyDenom * gasLimitUsed / (int64(noOfBlocks) * build.PackingEfficiencyNum)
+		delta -= build.BlockGasTarget
+	}

 	// cap change at 12.5% (BaseFeeMaxChangeDenom) by capping delta
 	if delta > build.BlockGasTarget {
@@ -73,5 +79,5 @@ func (cs *ChainStore) ComputeBaseFee(ctx context.Context, ts *types.TipSet) (abi
 	}
 	parentBaseFee := ts.Blocks()[0].ParentBaseFee

-	return computeNextBaseFee(parentBaseFee, totalLimit, len(ts.Blocks())), nil
+	return ComputeNextBaseFee(parentBaseFee, totalLimit, len(ts.Blocks()), ts.Height()), nil
 }
@@ -27,7 +27,7 @@ func TestBaseFee(t *testing.T) {
 	for _, test := range tests {
 		test := test
 		t.Run(fmt.Sprintf("%v", test), func(t *testing.T) {
-			output := computeNextBaseFee(types.NewInt(test.basefee), test.limitUsed, test.noOfBlocks)
+			output := ComputeNextBaseFee(types.NewInt(test.basefee), test.limitUsed, test.noOfBlocks, 0)
 			assert.Equal(t, fmt.Sprintf("%d", test.output), output.String())
 		})
 	}
@@ -5,7 +5,6 @@ import (
 	"context"
 	"encoding/binary"
 	"encoding/json"
-	"errors"
 	"io"
 	"os"
 	"strconv"
@@ -19,7 +18,6 @@ import (
 	"github.com/filecoin-project/specs-actors/actors/util/adt"

 	"github.com/filecoin-project/lotus/api"
-	"github.com/filecoin-project/lotus/chain/state"
 	"github.com/filecoin-project/lotus/chain/vm"
 	"github.com/filecoin-project/lotus/journal"
 	bstore "github.com/filecoin-project/lotus/lib/blockstore"
@@ -52,8 +50,6 @@ var blockValidationCacheKeyPrefix = dstore.NewKey("blockValidation")
 var DefaultTipSetCacheSize = 8192
 var DefaultMsgMetaCacheSize = 2048

-var ErrNotifieeDone = errors.New("notifee is done and should be removed")
-
 func init() {
 	if s := os.Getenv("LOTUS_CHAIN_TIPSET_CACHE"); s != "" {
 		tscs, err := strconv.Atoi(s)
@@ -75,6 +71,20 @@ func init() {
 // ReorgNotifee represents a callback that gets called upon reorgs.
 type ReorgNotifee func(rev, app []*types.TipSet) error

+// Journal event types.
+const (
+	evtTypeHeadChange = iota
+)
+
+type HeadChangeEvt struct {
+	From        types.TipSetKey
+	FromHeight  abi.ChainEpoch
+	To          types.TipSetKey
+	ToHeight    abi.ChainEpoch
+	RevertCount int
+	ApplyCount  int
+}
+
 // ChainStore is the main point of access to chain data.
 //
 // Raw chain data is stored in the Blockstore, with relevant markers (genesis,
@@ -106,6 +116,8 @@ type ChainStore struct {
 	tsCache *lru.ARCCache

 	vmcalls vm.SyscallBuilder
+
+	evtTypes [1]journal.EventType
 }

 func NewChainStore(bs bstore.Blockstore, ds dstore.Batching, vmcalls vm.SyscallBuilder) *ChainStore {
@@ -121,6 +133,10 @@ func NewChainStore(bs bstore.Blockstore, ds dstore.Batching, vmcalls vm.SyscallB
 		vmcalls:  vmcalls,
 	}

+	cs.evtTypes = [1]journal.EventType{
+		evtTypeHeadChange: journal.J.RegisterEventType("sync", "head_change"),
+	}
+
 	ci := NewChainIndex(cs.LoadTipSet)

 	cs.cindex = ci
@@ -347,12 +363,15 @@ func (cs *ChainStore) reorgWorker(ctx context.Context, initialNotifees []ReorgNo
 					continue
 				}

-				journal.Add("sync", map[string]interface{}{
-					"op":    "headChange",
-					"from":  r.old.Key(),
-					"to":    r.new.Key(),
-					"rev":   len(revert),
-					"apply": len(apply),
+				journal.J.RecordEvent(cs.evtTypes[evtTypeHeadChange], func() interface{} {
+					return HeadChangeEvt{
+						From:        r.old.Key(),
+						FromHeight:  r.old.Height(),
+						To:          r.new.Key(),
+						ToHeight:    r.new.Height(),
+						RevertCount: len(revert),
+						ApplyCount:  len(apply),
+					}
 				})

 				// reverse the apply array
@@ -361,33 +380,11 @@ func (cs *ChainStore) reorgWorker(ctx context.Context, initialNotifees []ReorgNo
 					apply[i], apply[opp] = apply[opp], apply[i]
 				}

-				var toremove map[int]struct{}
-				for i, hcf := range notifees {
-					err := hcf(revert, apply)
-					if err != nil {
-						if err == ErrNotifieeDone {
-							if toremove == nil {
-								toremove = make(map[int]struct{})
-							}
-							toremove[i] = struct{}{}
-						} else {
-							log.Error("head change func errored (BAD): ", err)
-						}
+				for _, hcf := range notifees {
+					if err := hcf(revert, apply); err != nil {
+						log.Error("head change func errored (BAD): ", err)
 					}
 				}
-
-				if len(toremove) > 0 {
-					newNotifees := make([]ReorgNotifee, 0, len(notifees)-len(toremove))
-					for i, hcf := range notifees {
-						_, remove := toremove[i]
-						if remove {
-							continue
-						}
-						newNotifees = append(newNotifees, hcf)
-					}
-					notifees = newNotifees
-				}
-
 			case <-ctx.Done():
 				return
 			}
@@ -496,7 +493,7 @@ func (cs *ChainStore) IsAncestorOf(a, b *types.TipSet) (bool, error) {

 	cur := b
 	for !a.Equals(cur) && cur.Height() > a.Height() {
-		next, err := cs.LoadTipSet(b.Parents())
+		next, err := cs.LoadTipSet(cur.Parents())
 		if err != nil {
 			return false, err
 		}
@@ -769,32 +766,16 @@ type BlockMessages struct {
 func (cs *ChainStore) BlockMsgsForTipset(ts *types.TipSet) ([]BlockMessages, error) {
 	applied := make(map[address.Address]uint64)

-	cst := cbor.NewCborStore(cs.bs)
-	st, err := state.LoadStateTree(cst, ts.Blocks()[0].ParentStateRoot)
-	if err != nil {
-		return nil, xerrors.Errorf("failed to load state tree")
-	}
-
-	preloadAddr := func(a address.Address) error {
-		if _, ok := applied[a]; !ok {
-			act, err := st.GetActor(a)
-			if err != nil {
-				return err
-			}
-
-			applied[a] = act.Nonce
-		}
-		return nil
-	}
-
 	selectMsg := func(m *types.Message) (bool, error) {
-		if err := preloadAddr(m.From); err != nil {
-			return false, err
+		// The first match for a sender is guaranteed to have correct nonce -- the block isn't valid otherwise
+		if _, ok := applied[m.From]; !ok {
+			applied[m.From] = m.Nonce
 		}

 		if applied[m.From] != m.Nonce {
 			return false, nil
 		}
+
 		applied[m.From]++

 		return true, nil
@@ -1184,7 +1165,7 @@ func recurseLinks(bs bstore.Blockstore, walked *cid.Set, root cid.Cid, in []cid.
 	return in, rerr
 }

-func (cs *ChainStore) Export(ctx context.Context, ts *types.TipSet, inclRecentRoots abi.ChainEpoch, w io.Writer) error {
+func (cs *ChainStore) Export(ctx context.Context, ts *types.TipSet, inclRecentRoots abi.ChainEpoch, skipOldMsgs bool, w io.Writer) error {
 	if ts == nil {
 		ts = cs.GetHeaviestTipSet()
 	}
@@ -1222,9 +1203,13 @@ func (cs *ChainStore) Export(ctx context.Context, ts *types.TipSet, inclRecentRo
 			return xerrors.Errorf("unmarshaling block header (cid=%s): %w", blk, err)
 		}

-		cids, err := recurseLinks(cs.bs, walked, b.Messages, []cid.Cid{b.Messages})
-		if err != nil {
-			return xerrors.Errorf("recursing messages failed: %w", err)
+		var cids []cid.Cid
+		if !skipOldMsgs || b.Height > ts.Height()-inclRecentRoots {
+			mcids, err := recurseLinks(cs.bs, walked, b.Messages, []cid.Cid{b.Messages})
+			if err != nil {
+				return xerrors.Errorf("recursing messages failed: %w", err)
+			}
+			cids = mcids
 		}

 		if b.Height > 0 {
@@ -96,7 +96,7 @@ func TestChainExportImport(t *testing.T) {
 	}

 	buf := new(bytes.Buffer)
-	if err := cg.ChainStore().Export(context.TODO(), last, 0, buf); err != nil {
+	if err := cg.ChainStore().Export(context.TODO(), last, 0, false, buf); err != nil {
 		t.Fatal(err)
 	}

@@ -369,9 +369,8 @@ func (bv *BlockValidator) decodeAndCheckBlock(msg *pubsub.Message) (*types.Block
 func (bv *BlockValidator) isChainNearSynced() bool {
 	ts := bv.chain.GetHeaviestTipSet()
 	timestamp := ts.MinTimestamp()
-	now := build.Clock.Now().UnixNano()
-	cutoff := uint64(now) - uint64(6*time.Hour)
-	return timestamp > cutoff
+	timestampTime := time.Unix(int64(timestamp), 0)
+	return build.Clock.Since(timestampTime) < 6*time.Hour
 }

 func (bv *BlockValidator) validateMsgMeta(ctx context.Context, msg *types.BlockMsg) error {
@@ -9,8 +9,11 @@ import (
 	"sort"
 	"strconv"
 	"strings"
+	"sync"
 	"time"

+	"github.com/filecoin-project/lotus/node/modules/dtypes"
+
 	"github.com/filecoin-project/specs-actors/actors/runtime/proof"

 	"github.com/Gurpartap/async"
@@ -38,7 +41,7 @@ import (
 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain/beacon"
-	"github.com/filecoin-project/lotus/chain/blocksync"
+	"github.com/filecoin-project/lotus/chain/exchange"
 	"github.com/filecoin-project/lotus/chain/gen"
 	"github.com/filecoin-project/lotus/chain/state"
 	"github.com/filecoin-project/lotus/chain/stmgr"
@@ -52,10 +55,17 @@ import (
 )

 // Blocks that are more than MaxHeightDrift epochs above
-//the theoretical max height based on systime are quickly rejected
+// the theoretical max height based on systime are quickly rejected
 const MaxHeightDrift = 5

-var defaultMessageFetchWindowSize = 200
+var (
+	// LocalIncoming is the _local_ pubsub (unrelated to libp2p pubsub) topic
+	// where the Syncer publishes candidate chain heads to be synced.
+	LocalIncoming = "incoming"
+
+	log                           = logging.Logger("chain")
+	defaultMessageFetchWindowSize = 200
+)

 func init() {
 	if s := os.Getenv("LOTUS_BSYNC_MSG_WINDOW"); s != "" {
@@ -68,10 +78,6 @@ func init() {
 	}
 }

-var log = logging.Logger("chain")
-
-var LocalIncoming = "incoming"
-
 // Syncer is in charge of running the chain synchronization logic. As such, it
 // is tasked with these functions, amongst others:
 //
@@ -89,7 +95,7 @@ var LocalIncoming = "incoming"
 // The Syncer does not run workers itself. It's mainly concerned with
 // ensuring a consistent state of chain consensus. The reactive and network-
 // interfacing processes are part of other components, such as the SyncManager
-// (which owns the sync scheduler and sync workers), BlockSync, the HELLO
+// (which owns the sync scheduler and sync workers), ChainExchange, the HELLO
 // protocol, and the gossipsub block propagation layer.
 //
 // {hint/concept} The fork-choice rule as it currently stands is: "pick the
@@ -100,7 +106,7 @@ type Syncer struct {
 	store *store.ChainStore

 	// handle to the random beacon for verification
-	beacon beacon.RandomBeacon
+	beacon beacon.Schedule

 	// the state manager handles making state queries
 	sm *stmgr.StateManager
@@ -112,11 +118,11 @@ type Syncer struct {
 	bad *BadBlockCache

 	// handle to the block sync service
-	Bsync *blocksync.BlockSync
+	Exchange exchange.Client

 	self peer.ID

-	syncmgr *SyncManager
+	syncmgr SyncManager

 	connmgr connmgr.ConnManager

@@ -129,10 +135,18 @@ type Syncer struct {
 	windowSize int

 	tickerCtxCancel context.CancelFunc
+
+	checkptLk sync.Mutex
+
+	checkpt types.TipSetKey
+
+	ds dtypes.MetadataDS
 }

+type SyncManagerCtor func(syncFn SyncFunc) SyncManager
+
 // NewSyncer creates a new Syncer object.
-func NewSyncer(sm *stmgr.StateManager, bsync *blocksync.BlockSync, connmgr connmgr.ConnManager, self peer.ID, beacon beacon.RandomBeacon, verifier ffiwrapper.Verifier) (*Syncer, error) {
+func NewSyncer(ds dtypes.MetadataDS, sm *stmgr.StateManager, exchange exchange.Client, syncMgrCtor SyncManagerCtor, connmgr connmgr.ConnManager, self peer.ID, beacon beacon.Schedule, verifier ffiwrapper.Verifier) (*Syncer, error) {
 	gen, err := sm.ChainStore().GetGenesis()
 	if err != nil {
 		return nil, xerrors.Errorf("getting genesis block: %w", err)
@@ -143,11 +157,18 @@ func NewSyncer(sm *stmgr.StateManager, bsync *blocksync.BlockSync, connmgr connm
 		return nil, err
 	}

+	cp, err := loadCheckpoint(ds)
+	if err != nil {
+		return nil, xerrors.Errorf("error loading mpool config: %w", err)
+	}
+
 	s := &Syncer{
+		ds:             ds,
+		checkpt:        cp,
 		beacon:         beacon,
 		bad:            NewBadBlockCache(),
 		Genesis:        gent,
-		Bsync:          bsync,
+		Exchange:       exchange,
 		store:          sm.ChainStore(),
 		sm:             sm,
 		self:           self,
@@ -165,7 +186,7 @@ func NewSyncer(sm *stmgr.StateManager, bsync *blocksync.BlockSync, connmgr connm
 		log.Warn("*********************************************************************************************")
 	}

-	s.syncmgr = NewSyncManager(s.Sync)
+	s.syncmgr = syncMgrCtor(s.Sync)
 	return s, nil
 }

@@ -248,7 +269,7 @@ func (syncer *Syncer) InformNewHead(from peer.ID, fts *store.FullTipSet) bool {
 		return false
 	}

-	syncer.Bsync.AddPeer(from)
+	syncer.Exchange.AddPeer(from)

 	bestPweight := syncer.store.GetHeaviestTipSet().ParentWeight()
 	targetWeight := fts.TipSet().ParentWeight()
@@ -479,7 +500,7 @@ func computeMsgMeta(bs cbor.IpldStore, bmsgCids, smsgCids []cid.Cid) (cid.Cid, e
 }

 // FetchTipSet tries to load the provided tipset from the store, and falls back
-// to the network (BlockSync) by querying the supplied peer if not found
+// to the network (client) by querying the supplied peer if not found
 // locally.
 //
 // {hint/usage} This is used from the HELLO protocol, to fetch the greeting
@@ -490,7 +511,7 @@ func (syncer *Syncer) FetchTipSet(ctx context.Context, p peer.ID, tsk types.TipS
 	}

 	// fall back to the network.
-	return syncer.Bsync.GetFullTipSet(ctx, p, tsk)
+	return syncer.Exchange.GetFullTipSet(ctx, p, tsk)
 }

 // tryLoadFullTipSet queries the tipset in the ChainStore, and returns a full
@@ -632,7 +653,7 @@ func (syncer *Syncer) minerIsValid(ctx context.Context, maddr address.Address, b
 	}

 	var claim power.Claim
-	exist, err := cm.Get(adt.AddrKey(maddr), &claim)
+	exist, err := cm.Get(abi.AddrKey(maddr), &claim)
 	if err != nil {
 		return err
 	}
@@ -863,7 +884,7 @@ func (syncer *Syncer) ValidateBlock(ctx context.Context, b *types.FullBlock) (er
 			return nil
 		}

-		if err := beacon.ValidateBlockValues(syncer.beacon, h, *prevBeacon); err != nil {
+		if err := beacon.ValidateBlockValues(syncer.beacon, h, baseTs.Height(), *prevBeacon); err != nil {
 			return xerrors.Errorf("failed to validate blocks random beacon values: %w", err)
 		}
 		return nil
@@ -875,10 +896,12 @@ func (syncer *Syncer) ValidateBlock(ctx context.Context, b *types.FullBlock) (er
 			return xerrors.Errorf("failed to marshal miner address to cbor: %w", err)
 		}

-		beaconBase := *prevBeacon
-		if len(h.BeaconEntries) == 0 {
+		if h.Height > build.UpgradeSmokeHeight {
 			buf.Write(baseTs.MinTicket().VRFProof)
-		} else {
+		}
+
+		beaconBase := *prevBeacon
+		if len(h.BeaconEntries) != 0 {
 			beaconBase = h.BeaconEntries[len(h.BeaconEntries)-1]
 		}

@@ -968,7 +991,7 @@ func (syncer *Syncer) VerifyWinningPoStProof(ctx context.Context, h *types.Block

 	rand, err := store.DrawRandomness(rbase.Data, crypto.DomainSeparationTag_WinningPoStChallengeSeed, h.Height, buf.Bytes())
 	if err != nil {
-		return xerrors.Errorf("failed to get randomness for verifying winningPost proof: %w", err)
+		return xerrors.Errorf("failed to get randomness for verifying winning post proof: %w", err)
 	}

 	mid, err := address.IDFromAddress(h.Miner)
@@ -1192,7 +1215,7 @@ func extractSyncState(ctx context.Context) *SyncerState {
 //     total equality of the BeaconEntries in each block.
 //  3. Traverse the chain backwards, for each tipset:
 //  	3a. Load it from the chainstore; if found, it move on to its parent.
-//      3b. Query our peers via BlockSync in batches, requesting up to a
+//      3b. Query our peers via client in batches, requesting up to a
 //      maximum of 500 tipsets every time.
 //
 // Once we've concluded, if we find a mismatching tipset at the height where the
@@ -1293,7 +1316,7 @@ loop:
 		if gap := int(blockSet[len(blockSet)-1].Height() - untilHeight); gap < window {
 			window = gap
 		}
-		blks, err := syncer.Bsync.GetBlocks(ctx, at, window)
+		blks, err := syncer.Exchange.GetBlocks(ctx, at, window)
 		if err != nil {
 			// Most likely our peers aren't fully synced yet, but forwarded
 			// new block message (ideally we'd find better peers)
@@ -1311,7 +1334,7 @@ loop:
 		// have. Since we fetch from the head backwards our reassembled chain
 		// is sorted in reverse here: we have a child -> parent order, our last
 		// tipset then should be child of the first tipset retrieved.
-		// FIXME: The reassembly logic should be part of the `BlockSync`
+		// FIXME: The reassembly logic should be part of the `client`
 		//  service, the consumer should not be concerned with the
 		//  `MaxRequestLength` limitation, it should just be able to request
 		//  an segment of arbitrary length. The same burden is put on
@@ -1361,7 +1384,7 @@ loop:
 	log.Warnf("(fork detected) synced header chain (%s - %d) does not link to our best block (%s - %d)", incoming.Cids(), incoming.Height(), known.Cids(), known.Height())
 	fork, err := syncer.syncFork(ctx, base, known)
 	if err != nil {
-		if xerrors.Is(err, ErrForkTooLong) {
+		if xerrors.Is(err, ErrForkTooLong) || xerrors.Is(err, ErrForkCheckpoint) {
 			// TODO: we're marking this block bad in the same way that we mark invalid blocks bad. Maybe distinguish?
 			log.Warn("adding forked chain to our bad tipset cache")
 			for _, b := range incoming.Blocks() {
@@ -1377,15 +1400,24 @@ loop:
 }

 var ErrForkTooLong = fmt.Errorf("fork longer than threshold")
+var ErrForkCheckpoint = fmt.Errorf("fork would require us to diverge from checkpointed block")

 // syncFork tries to obtain the chain fragment that links a fork into a common
 // ancestor in our view of the chain.
 //
-// If the fork is too long (build.ForkLengthThreshold), we add the entire subchain to the
-// denylist. Else, we find the common ancestor, and add the missing chain
+// If the fork is too long (build.ForkLengthThreshold), or would cause us to diverge from the checkpoint (ErrForkCheckpoint),
+// we add the entire subchain to the denylist. Else, we find the common ancestor, and add the missing chain
 // fragment until the fork point to the returned []TipSet.
 func (syncer *Syncer) syncFork(ctx context.Context, incoming *types.TipSet, known *types.TipSet) ([]*types.TipSet, error) {
-	tips, err := syncer.Bsync.GetBlocks(ctx, incoming.Parents(), int(build.ForkLengthThreshold))
+
+	chkpt := syncer.GetCheckpoint()
+	if known.Key() == chkpt {
+		return nil, ErrForkCheckpoint
+	}
+
+	// TODO: Does this mean we always ask for ForkLengthThreshold blocks from the network, even if we just need, like, 2?
+	// Would it not be better to ask in smaller chunks, given that an ~ForkLengthThreshold is very rare?
+	tips, err := syncer.Exchange.GetBlocks(ctx, incoming.Parents(), int(build.ForkLengthThreshold))
 	if err != nil {
 		return nil, err
 	}
@@ -1410,12 +1442,18 @@ func (syncer *Syncer) syncFork(ctx context.Context, incoming *types.TipSet, know
 		if nts.Height() < tips[cur].Height() {
 			cur++
 		} else {
+			// We will be forking away from nts, check that it isn't checkpointed
+			if nts.Key() == chkpt {
+				return nil, ErrForkCheckpoint
+			}
+
 			nts, err = syncer.store.LoadTipSet(nts.Parents())
 			if err != nil {
 				return nil, xerrors.Errorf("loading next local tipset: %w", err)
 			}
 		}
 	}
+
 	return nil, ErrForkTooLong
 }

@@ -1439,6 +1477,7 @@ func (syncer *Syncer) syncMessagesAndCheckState(ctx context.Context, headers []*

 // fills out each of the given tipsets with messages and calls the callback with it
 func (syncer *Syncer) iterFullTipsets(ctx context.Context, headers []*types.TipSet, cb func(context.Context, *store.FullTipSet) error) error {
+	ss := extractSyncState(ctx)
 	ctx, span := trace.StartSpan(ctx, "iterFullTipsets")
 	defer span.End()

@@ -1466,12 +1505,13 @@ mainLoop:

 		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

-		var bstout []*blocksync.CompactedMessages
+		ss.SetStage(api.StageFetchingMessages)
+		var bstout []*exchange.CompactedMessages
 		for len(bstout) < batchSize {
 			next := headers[nextI]

 			nreq := batchSize - len(bstout)
-			bstips, err := syncer.Bsync.GetChainMessages(ctx, next, uint64(nreq))
+			bstips, err := syncer.Exchange.GetChainMessages(ctx, next, uint64(nreq))
 			if err != nil {
 				// TODO check errors for temporary nature
 				if windowSize > 1 {
@@ -1485,6 +1525,7 @@ mainLoop:
 			bstout = append(bstout, bstips...)
 			nextI += len(bstips)
 		}
+		ss.SetStage(api.StageMessages)

 		for bsi := 0; bsi < len(bstout); bsi++ {
 			// temp storage so we don't persist data we dont want to
@@ -1516,8 +1557,8 @@ mainLoop:

 		if i >= windowSize {
 			newWindowSize := windowSize + 10
-			if newWindowSize > int(blocksync.MaxRequestLength) {
-				newWindowSize = int(blocksync.MaxRequestLength)
+			if newWindowSize > int(exchange.MaxRequestLength) {
+				newWindowSize = int(exchange.MaxRequestLength)
 			}
 			if newWindowSize > windowSize {
 				windowSize = newWindowSize
@@ -1534,7 +1575,7 @@ mainLoop:
 	return nil
 }

-func persistMessages(bs bstore.Blockstore, bst *blocksync.CompactedMessages) error {
+func persistMessages(bs bstore.Blockstore, bst *exchange.CompactedMessages) error {
 	for _, m := range bst.Bls {
 		//log.Infof("putting BLS message: %s", m.Cid())
 		if _, err := store.PutMessage(bs, m); err != nil {
@@ -1629,11 +1670,7 @@ func VerifyElectionPoStVRF(ctx context.Context, worker address.Address, rand []b
 }

 func (syncer *Syncer) State() []SyncerState {
-	var out []SyncerState
-	for _, ss := range syncer.syncmgr.syncStates {
-		out = append(out, ss.Snapshot())
-	}
-	return out
+	return syncer.syncmgr.State()
 }

 // MarkBad manually adds a block to the "bad blocks" cache.
@@ -1641,6 +1678,11 @@ func (syncer *Syncer) MarkBad(blk cid.Cid) {
 	syncer.bad.Add(blk, NewBadBlockReason([]cid.Cid{blk}, "manually marked bad"))
 }

+// UnmarkBad manually adds a block to the "bad blocks" cache.
+func (syncer *Syncer) UnmarkBad(blk cid.Cid) {
+	syncer.bad.Remove(blk)
+}
+
 func (syncer *Syncer) CheckBadBlockCache(blk cid.Cid) (string, bool) {
 	bbr, ok := syncer.bad.Has(blk)
 	return bbr.String(), ok
@@ -20,7 +20,28 @@ const (

 type SyncFunc func(context.Context, *types.TipSet) error

-type SyncManager struct {
+// SyncManager manages the chain synchronization process, both at bootstrap time
+// and during ongoing operation.
+//
+// It receives candidate chain heads in the form of tipsets from peers,
+// and schedules them onto sync workers, deduplicating processing for
+// already-active syncs.
+type SyncManager interface {
+	// Start starts the SyncManager.
+	Start()
+
+	// Stop stops the SyncManager.
+	Stop()
+
+	// SetPeerHead informs the SyncManager that the supplied peer reported the
+	// supplied tipset.
+	SetPeerHead(ctx context.Context, p peer.ID, ts *types.TipSet)
+
+	// State retrieves the state of the sync workers.
+	State() []SyncerState
+}
+
+type syncManager struct {
 	lk        sync.Mutex
 	peerHeads map[peer.ID]*types.TipSet

@@ -48,6 +69,8 @@ type SyncManager struct {
 	workerChan     chan *types.TipSet
 }

+var _ SyncManager = (*syncManager)(nil)
+
 type syncResult struct {
 	ts      *types.TipSet
 	success bool
@@ -55,8 +78,8 @@ type syncResult struct {

 const syncWorkerCount = 3

-func NewSyncManager(sync SyncFunc) *SyncManager {
-	return &SyncManager{
+func NewSyncManager(sync SyncFunc) SyncManager {
+	return &syncManager{
 		bspThresh:       1,
 		peerHeads:       make(map[peer.ID]*types.TipSet),
 		syncTargets:     make(chan *types.TipSet),
@@ -69,18 +92,18 @@ func NewSyncManager(sync SyncFunc) *SyncManager {
 	}
 }

-func (sm *SyncManager) Start() {
+func (sm *syncManager) Start() {
 	go sm.syncScheduler()
 	for i := 0; i < syncWorkerCount; i++ {
 		go sm.syncWorker(i)
 	}
 }

-func (sm *SyncManager) Stop() {
+func (sm *syncManager) Stop() {
 	close(sm.stop)
 }

-func (sm *SyncManager) SetPeerHead(ctx context.Context, p peer.ID, ts *types.TipSet) {
+func (sm *syncManager) SetPeerHead(ctx context.Context, p peer.ID, ts *types.TipSet) {
 	sm.lk.Lock()
 	defer sm.lk.Unlock()
 	sm.peerHeads[p] = ts
@@ -105,6 +128,14 @@ func (sm *SyncManager) SetPeerHead(ctx context.Context, p peer.ID, ts *types.Tip
 	sm.incomingTipSets <- ts
 }

+func (sm *syncManager) State() []SyncerState {
+	ret := make([]SyncerState, 0, len(sm.syncStates))
+	for _, s := range sm.syncStates {
+		ret = append(ret, s.Snapshot())
+	}
+	return ret
+}
+
 type syncBucketSet struct {
 	buckets []*syncTargetBucket
 }
@@ -234,7 +265,7 @@ func (stb *syncTargetBucket) heaviestTipSet() *types.TipSet {
 	return best
 }

-func (sm *SyncManager) selectSyncTarget() (*types.TipSet, error) {
+func (sm *syncManager) selectSyncTarget() (*types.TipSet, error) {
 	var buckets syncBucketSet

 	var peerHeads []*types.TipSet
@@ -258,7 +289,7 @@ func (sm *SyncManager) selectSyncTarget() (*types.TipSet, error) {
 	return buckets.Heaviest(), nil
 }

-func (sm *SyncManager) syncScheduler() {
+func (sm *syncManager) syncScheduler() {

 	for {
 		select {
@@ -280,7 +311,7 @@ func (sm *SyncManager) syncScheduler() {
 	}
 }

-func (sm *SyncManager) scheduleIncoming(ts *types.TipSet) {
+func (sm *syncManager) scheduleIncoming(ts *types.TipSet) {
 	log.Debug("scheduling incoming tipset sync: ", ts.Cids())
 	if sm.getBootstrapState() == BSStateSelected {
 		sm.setBootstrapState(BSStateScheduled)
@@ -328,10 +359,11 @@ func (sm *SyncManager) scheduleIncoming(ts *types.TipSet) {
 	}
 }

-func (sm *SyncManager) scheduleProcessResult(res *syncResult) {
+func (sm *syncManager) scheduleProcessResult(res *syncResult) {
 	if res.success && sm.getBootstrapState() != BSStateComplete {
 		sm.setBootstrapState(BSStateComplete)
 	}
+
 	delete(sm.activeSyncs, res.ts.Key())
 	relbucket := sm.activeSyncTips.PopRelated(res.ts)
 	if relbucket != nil {
@@ -360,7 +392,7 @@ func (sm *SyncManager) scheduleProcessResult(res *syncResult) {
 	}
 }

-func (sm *SyncManager) scheduleWorkSent() {
+func (sm *syncManager) scheduleWorkSent() {
 	hts := sm.nextSyncTarget.heaviestTipSet()
 	sm.activeSyncs[hts.Key()] = hts

@@ -372,7 +404,7 @@ func (sm *SyncManager) scheduleWorkSent() {
 	}
 }

-func (sm *SyncManager) syncWorker(id int) {
+func (sm *syncManager) syncWorker(id int) {
 	ss := &SyncerState{}
 	sm.syncStates[id] = ss
 	for {
@@ -397,7 +429,7 @@ func (sm *SyncManager) syncWorker(id int) {
 	}
 }

-func (sm *SyncManager) syncedPeerCount() int {
+func (sm *syncManager) syncedPeerCount() int {
 	var count int
 	for _, ts := range sm.peerHeads {
 		if ts.Height() > 0 {
@@ -407,19 +439,19 @@ func (sm *SyncManager) syncedPeerCount() int {
 	return count
 }

-func (sm *SyncManager) getBootstrapState() int {
+func (sm *syncManager) getBootstrapState() int {
 	sm.bssLk.Lock()
 	defer sm.bssLk.Unlock()
 	return sm.bootstrapState
 }

-func (sm *SyncManager) setBootstrapState(v int) {
+func (sm *syncManager) setBootstrapState(v int) {
 	sm.bssLk.Lock()
 	defer sm.bssLk.Unlock()
 	sm.bootstrapState = v
 }

-func (sm *SyncManager) IsBootstrapped() bool {
+func (sm *syncManager) IsBootstrapped() bool {
 	sm.bssLk.Lock()
 	defer sm.bssLk.Unlock()
 	return sm.bootstrapState == BSStateComplete
@@ -17,7 +17,7 @@ type syncOp struct {
 	done func()
 }

-func runSyncMgrTest(t *testing.T, tname string, thresh int, tf func(*testing.T, *SyncManager, chan *syncOp)) {
+func runSyncMgrTest(t *testing.T, tname string, thresh int, tf func(*testing.T, *syncManager, chan *syncOp)) {
 	syncTargets := make(chan *syncOp)
 	sm := NewSyncManager(func(ctx context.Context, ts *types.TipSet) error {
 		ch := make(chan struct{})
@@ -27,7 +27,7 @@ func runSyncMgrTest(t *testing.T, tname string, thresh int, tf func(*testing.T,
 		}
 		<-ch
 		return nil
-	})
+	}).(*syncManager)
 	sm.bspThresh = thresh

 	sm.Start()
@@ -77,12 +77,12 @@ func TestSyncManager(t *testing.T) {
 	c3 := mock.TipSet(mock.MkBlock(b, 3, 5))
 	d := mock.TipSet(mock.MkBlock(c1, 4, 5))

-	runSyncMgrTest(t, "testBootstrap", 1, func(t *testing.T, sm *SyncManager, stc chan *syncOp) {
+	runSyncMgrTest(t, "testBootstrap", 1, func(t *testing.T, sm *syncManager, stc chan *syncOp) {
 		sm.SetPeerHead(ctx, "peer1", c1)
 		assertGetSyncOp(t, stc, c1)
 	})

-	runSyncMgrTest(t, "testBootstrap", 2, func(t *testing.T, sm *SyncManager, stc chan *syncOp) {
+	runSyncMgrTest(t, "testBootstrap", 2, func(t *testing.T, sm *syncManager, stc chan *syncOp) {
 		sm.SetPeerHead(ctx, "peer1", c1)
 		assertNoOp(t, stc)

@@ -90,7 +90,7 @@ func TestSyncManager(t *testing.T) {
 		assertGetSyncOp(t, stc, c1)
 	})

-	runSyncMgrTest(t, "testSyncAfterBootstrap", 1, func(t *testing.T, sm *SyncManager, stc chan *syncOp) {
+	runSyncMgrTest(t, "testSyncAfterBootstrap", 1, func(t *testing.T, sm *syncManager, stc chan *syncOp) {
 		sm.SetPeerHead(ctx, "peer1", b)
 		assertGetSyncOp(t, stc, b)

@@ -101,7 +101,7 @@ func TestSyncManager(t *testing.T) {
 		assertGetSyncOp(t, stc, c2)
 	})

-	runSyncMgrTest(t, "testCoalescing", 1, func(t *testing.T, sm *SyncManager, stc chan *syncOp) {
+	runSyncMgrTest(t, "testCoalescing", 1, func(t *testing.T, sm *syncManager, stc chan *syncOp) {
 		sm.SetPeerHead(ctx, "peer1", a)
 		assertGetSyncOp(t, stc, a)

@@ -122,7 +122,7 @@ func TestSyncManager(t *testing.T) {
 		assertGetSyncOp(t, stc, d)
 	})

-	runSyncMgrTest(t, "testSyncIncomingTipset", 1, func(t *testing.T, sm *SyncManager, stc chan *syncOp) {
+	runSyncMgrTest(t, "testSyncIncomingTipset", 1, func(t *testing.T, sm *syncManager, stc chan *syncOp) {
 		sm.SetPeerHead(ctx, "peer1", a)
 		assertGetSyncOp(t, stc, a)

@@ -34,7 +34,6 @@ import (
 	"github.com/filecoin-project/lotus/node"
 	"github.com/filecoin-project/lotus/node/impl"
 	"github.com/filecoin-project/lotus/node/modules"
-	"github.com/filecoin-project/lotus/node/modules/dtypes"
 	"github.com/filecoin-project/lotus/node/repo"
 )

@@ -234,7 +233,6 @@ func (tu *syncTestUtil) addSourceNode(gen int) {
 		node.Repo(sourceRepo),
 		node.MockHost(tu.mn),
 		node.Test(),
-		node.Override(new(dtypes.Bootstrapper), dtypes.Bootstrapper(true)),

 		node.Override(new(modules.Genesis), modules.LoadGenesis(genesis)),
 	)
@@ -267,7 +265,6 @@ func (tu *syncTestUtil) addClientNode() int {
 		node.Repo(repo.NewMemory(nil)),
 		node.MockHost(tu.mn),
 		node.Test(),
-		node.Override(new(dtypes.Bootstrapper), dtypes.Bootstrapper(true)),

 		node.Override(new(modules.Genesis), modules.LoadGenesis(tu.genesis)),
 	)
@@ -336,6 +333,36 @@ func (tu *syncTestUtil) compareSourceState(with int) {
 	}
 }

+func (tu *syncTestUtil) assertBad(node int, ts *types.TipSet) {
+	for _, blk := range ts.Cids() {
+		rsn, err := tu.nds[node].SyncCheckBad(context.TODO(), blk)
+		require.NoError(tu.t, err)
+		require.True(tu.t, len(rsn) != 0)
+	}
+}
+
+func (tu *syncTestUtil) getHead(node int) *types.TipSet {
+	ts, err := tu.nds[node].ChainHead(context.TODO())
+	require.NoError(tu.t, err)
+	return ts
+}
+
+func (tu *syncTestUtil) checkpointTs(node int, tsk types.TipSetKey) {
+	require.NoError(tu.t, tu.nds[node].SyncCheckpoint(context.TODO(), tsk))
+}
+
+func (tu *syncTestUtil) waitUntilNodeHasTs(node int, tsk types.TipSetKey) {
+	for {
+		_, err := tu.nds[node].ChainGetTipSet(context.TODO(), tsk)
+		if err != nil {
+			break
+		}
+	}
+
+	// Time to allow for syncing and validation
+	time.Sleep(2 * time.Second)
+}
+
 func (tu *syncTestUtil) waitUntilSync(from, to int) {
 	target, err := tu.nds[from].ChainHead(tu.ctx)
 	if err != nil {
@@ -635,6 +662,49 @@ func TestDuplicateNonce(t *testing.T) {
 	require.Equal(t, includedMsg, mft[0].VMMessage().Cid(), "messages for tipset didn't contain expected message")
 }

+// This test asserts that a block that includes a message with bad nonce can't be synced. A nonce is "bad" if it can't
+// be applied on the parent state.
+func TestBadNonce(t *testing.T) {
+	H := 10
+	tu := prepSyncTest(t, H)
+
+	base := tu.g.CurTipset
+
+	// Produce a message from the banker with a bad nonce
+	makeBadMsg := func() *types.SignedMessage {
+
+		ba, err := tu.nds[0].StateGetActor(context.TODO(), tu.g.Banker(), base.TipSet().Key())
+		require.NoError(t, err)
+		msg := types.Message{
+			To:   tu.g.Banker(),
+			From: tu.g.Banker(),
+
+			Nonce: ba.Nonce + 5,
+
+			Value: types.NewInt(1),
+
+			Method: 0,
+
+			GasLimit:   100_000_000,
+			GasFeeCap:  types.NewInt(0),
+			GasPremium: types.NewInt(0),
+		}
+
+		sig, err := tu.g.Wallet().Sign(context.TODO(), tu.g.Banker(), msg.Cid().Bytes())
+		require.NoError(t, err)
+
+		return &types.SignedMessage{
+			Message:   msg,
+			Signature: *sig,
+		}
+	}
+
+	msgs := make([][]*types.SignedMessage, 1)
+	msgs[0] = []*types.SignedMessage{makeBadMsg()}
+
+	tu.mineOnBlock(base, 0, []int{0}, true, true, msgs)
+}
+
 func BenchmarkSyncBasic(b *testing.B) {
 	for i := 0; i < b.N; i++ {
 		runSyncBenchLength(b, 100)
@@ -681,3 +751,87 @@ func TestSyncInputs(t *testing.T) {
 		t.Fatal("should error on block with nil election proof")
 	}
 }
+
+func TestSyncCheckpointHead(t *testing.T) {
+	H := 10
+	tu := prepSyncTest(t, H)
+
+	p1 := tu.addClientNode()
+	p2 := tu.addClientNode()
+
+	fmt.Println("GENESIS: ", tu.g.Genesis().Cid())
+	tu.loadChainToNode(p1)
+	tu.loadChainToNode(p2)
+
+	base := tu.g.CurTipset
+	fmt.Println("Mining base: ", base.TipSet().Cids(), base.TipSet().Height())
+
+	// The two nodes fork at this point into 'a' and 'b'
+	a1 := tu.mineOnBlock(base, p1, []int{0}, true, false, nil)
+	a := tu.mineOnBlock(a1, p1, []int{0}, true, false, nil)
+	a = tu.mineOnBlock(a, p1, []int{0}, true, false, nil)
+
+	tu.waitUntilSyncTarget(p1, a.TipSet())
+	tu.checkpointTs(p1, a.TipSet().Key())
+
+	require.NoError(t, tu.g.ResyncBankerNonce(a1.TipSet()))
+	// chain B will now be heaviest
+	b := tu.mineOnBlock(base, p2, []int{1}, true, false, nil)
+	b = tu.mineOnBlock(b, p2, []int{1}, true, false, nil)
+	b = tu.mineOnBlock(b, p2, []int{1}, true, false, nil)
+	b = tu.mineOnBlock(b, p2, []int{1}, true, false, nil)
+
+	fmt.Println("A: ", a.Cids(), a.TipSet().Height())
+	fmt.Println("B: ", b.Cids(), b.TipSet().Height())
+
+	// Now for the fun part!! p1 should mark p2's head as BAD.
+
+	require.NoError(t, tu.mn.LinkAll())
+	tu.connect(p1, p2)
+	tu.waitUntilNodeHasTs(p1, b.TipSet().Key())
+	p1Head := tu.getHead(p1)
+	require.Equal(tu.t, p1Head, a.TipSet())
+	tu.assertBad(p1, b.TipSet())
+}
+
+func TestSyncCheckpointEarlierThanHead(t *testing.T) {
+	H := 10
+	tu := prepSyncTest(t, H)
+
+	p1 := tu.addClientNode()
+	p2 := tu.addClientNode()
+
+	fmt.Println("GENESIS: ", tu.g.Genesis().Cid())
+	tu.loadChainToNode(p1)
+	tu.loadChainToNode(p2)
+
+	base := tu.g.CurTipset
+	fmt.Println("Mining base: ", base.TipSet().Cids(), base.TipSet().Height())
+
+	// The two nodes fork at this point into 'a' and 'b'
+	a1 := tu.mineOnBlock(base, p1, []int{0}, true, false, nil)
+	a := tu.mineOnBlock(a1, p1, []int{0}, true, false, nil)
+	a = tu.mineOnBlock(a, p1, []int{0}, true, false, nil)
+
+	tu.waitUntilSyncTarget(p1, a.TipSet())
+	tu.checkpointTs(p1, a1.TipSet().Key())
+
+	require.NoError(t, tu.g.ResyncBankerNonce(a1.TipSet()))
+	// chain B will now be heaviest
+	b := tu.mineOnBlock(base, p2, []int{1}, true, false, nil)
+	b = tu.mineOnBlock(b, p2, []int{1}, true, false, nil)
+	b = tu.mineOnBlock(b, p2, []int{1}, true, false, nil)
+	b = tu.mineOnBlock(b, p2, []int{1}, true, false, nil)
+
+	fmt.Println("A: ", a.Cids(), a.TipSet().Height())
+	fmt.Println("B: ", b.Cids(), b.TipSet().Height())
+
+	// Now for the fun part!! p1 should mark p2's head as BAD.
+
+	require.NoError(t, tu.mn.LinkAll())
+	tu.connect(p1, p2)
+	tu.waitUntilNodeHasTs(p1, b.TipSet().Key())
+	p1Head := tu.getHead(p1)
+	require.Equal(tu.t, p1Head, a.TipSet())
+	tu.assertBad(p1, b.TipSet())
+}
@@ -1,7 +1,6 @@
 package chain

 import (
-	"fmt"
 	"sync"
 	"time"

@@ -12,23 +11,6 @@ import (
 	"github.com/filecoin-project/lotus/chain/types"
 )

-func SyncStageString(v api.SyncStateStage) string {
-	switch v {
-	case api.StageHeaders:
-		return "header sync"
-	case api.StagePersistHeaders:
-		return "persisting headers"
-	case api.StageMessages:
-		return "message sync"
-	case api.StageSyncComplete:
-		return "complete"
-	case api.StageSyncErrored:
-		return "error"
-	default:
-		return fmt.Sprintf("<unknown: %d>", v)
-	}
-}
-
 type SyncerState struct {
 	lk      sync.Mutex
 	Target  *types.TipSet
@@ -22,6 +22,17 @@ type GasOutputs struct {
 	GasBurned int64
 }

+// ZeroGasOutputs returns a logically zeroed GasOutputs.
+func ZeroGasOutputs() GasOutputs {
+	return GasOutputs{
+		BaseFeeBurn:        big.Zero(),
+		OverEstimationBurn: big.Zero(),
+		MinerPenalty:       big.Zero(),
+		MinerTip:           big.Zero(),
+		Refund:             big.Zero(),
+	}
+}
+
 // ComputeGasOverestimationBurn computes amount of gas to be refunded and amount of gas to be burned
 // Result is (refund, burn)
 func ComputeGasOverestimationBurn(gasUsed, gasLimit int64) (int64, int64) {
@@ -58,13 +69,7 @@ func ComputeGasOverestimationBurn(gasUsed, gasLimit int64) (int64, int64) {

 func ComputeGasOutputs(gasUsed, gasLimit int64, baseFee, feeCap, gasPremium abi.TokenAmount) GasOutputs {
 	gasUsedBig := big.NewInt(gasUsed)
-	out := GasOutputs{
-		BaseFeeBurn:        big.Zero(),
-		OverEstimationBurn: big.Zero(),
-		MinerPenalty:       big.Zero(),
-		MinerTip:           big.Zero(),
-		Refund:             big.Zero(),
-	}
+	out := ZeroGasOutputs()

 	baseFeeToPay := baseFee
 	if baseFee.Cmp(feeCap.Int) > 0 {
@@ -15,6 +15,7 @@ import (
 	"golang.org/x/xerrors"

 	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/lotus/chain/actors/aerrors"
 	"github.com/filecoin-project/specs-actors/actors/builtin"
 	"github.com/filecoin-project/specs-actors/actors/builtin/cron"
 	init_ "github.com/filecoin-project/specs-actors/actors/builtin/init"
@@ -27,9 +28,6 @@ import (
 	"github.com/filecoin-project/specs-actors/actors/builtin/system"
 	"github.com/filecoin-project/specs-actors/actors/runtime"
 	vmr "github.com/filecoin-project/specs-actors/actors/runtime"
-	"github.com/filecoin-project/specs-actors/actors/util/adt"
-
-	"github.com/filecoin-project/lotus/chain/actors/aerrors"
 )

 type Invoker struct {
@@ -47,7 +45,7 @@ func NewInvoker() *Invoker {
 	}

 	// add builtInCode using: register(cid, singleton)
-	inv.Register(builtin.SystemActorCodeID, system.Actor{}, adt.EmptyValue{})
+	inv.Register(builtin.SystemActorCodeID, system.Actor{}, abi.EmptyValue{})
 	inv.Register(builtin.InitActorCodeID, init_.Actor{}, init_.State{})
 	inv.Register(builtin.RewardActorCodeID, reward.Actor{}, reward.State{})
 	inv.Register(builtin.CronActorCodeID, cron.Actor{}, cron.State{})
@@ -66,7 +64,7 @@ func (inv *Invoker) Invoke(codeCid cid.Cid, rt runtime.Runtime, method abi.Metho

 	code, ok := inv.builtInCode[codeCid]
 	if !ok {
-		log.Errorf("no code for actor %s (Addr: %s)", codeCid, rt.Message().Receiver())
+		log.Errorf("no code for actor %s (Addr: %s)", codeCid, rt.Receiver())
 		return nil, aerrors.Newf(exitcode.SysErrorIllegalActor, "no code for actor %s(%d)(%s)", codeCid, method, hex.EncodeToString(params))
 	}
 	if method >= abi.MethodNum(len(code)) || code[method] == nil {
@@ -5,6 +5,8 @@ import (
 	"io"
 	"testing"

+	"github.com/filecoin-project/go-state-types/abi"
+
 	cbor "github.com/ipfs/go-ipld-cbor"
 	"github.com/stretchr/testify/assert"
 	cbg "github.com/whyrusleeping/cbor-gen"
@@ -13,7 +15,6 @@ import (
 	"github.com/filecoin-project/lotus/chain/actors"
 	"github.com/filecoin-project/lotus/chain/actors/aerrors"
 	"github.com/filecoin-project/specs-actors/actors/runtime"
-	"github.com/filecoin-project/specs-actors/actors/util/adt"
 )

 type basicContract struct{}
@@ -60,17 +61,17 @@ func (b basicContract) Exports() []interface{} {
 	}
 }

-func (basicContract) InvokeSomething0(rt runtime.Runtime, params *basicParams) *adt.EmptyValue {
+func (basicContract) InvokeSomething0(rt runtime.Runtime, params *basicParams) *abi.EmptyValue {
 	rt.Abortf(exitcode.ExitCode(params.B), "params.B")
 	return nil
 }

-func (basicContract) BadParam(rt runtime.Runtime, params *basicParams) *adt.EmptyValue {
+func (basicContract) BadParam(rt runtime.Runtime, params *basicParams) *abi.EmptyValue {
 	rt.Abortf(255, "bad params")
 	return nil
 }

-func (basicContract) InvokeSomething10(rt runtime.Runtime, params *basicParams) *adt.EmptyValue {
+func (basicContract) InvokeSomething10(rt runtime.Runtime, params *basicParams) *abi.EmptyValue {
 	rt.Abortf(exitcode.ExitCode(params.B+10), "params.B")
 	return nil
 }
@@ -8,18 +8,19 @@ import (
 	gruntime "runtime"
 	"time"

+	"github.com/filecoin-project/go-state-types/cbor"
+	"github.com/filecoin-project/go-state-types/network"
+	rtt "github.com/filecoin-project/go-state-types/rt"
+
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/big"
 	"github.com/filecoin-project/go-state-types/crypto"
 	"github.com/filecoin-project/go-state-types/exitcode"
 	"github.com/filecoin-project/specs-actors/actors/builtin"
-	"github.com/filecoin-project/specs-actors/actors/runtime"
-	vmr "github.com/filecoin-project/specs-actors/actors/runtime"
-	"github.com/filecoin-project/specs-actors/actors/util/adt"
+	rt0 "github.com/filecoin-project/specs-actors/actors/runtime"
 	"github.com/ipfs/go-cid"
-	cbor "github.com/ipfs/go-ipld-cbor"
-	cbg "github.com/whyrusleeping/cbor-gen"
+	ipldcbor "github.com/ipfs/go-ipld-cbor"
 	"go.opencensus.io/trace"
 	"golang.org/x/xerrors"

@@ -30,20 +31,20 @@ import (
 )

 type Runtime struct {
+	types.Message
+	rt0.Syscalls
+
 	ctx context.Context

 	vm        *VM
 	state     *state.StateTree
-	vmsg      vmr.Message
 	height    abi.ChainEpoch
-	cst       cbor.IpldStore
+	cst       ipldcbor.IpldStore
 	pricelist Pricelist

 	gasAvailable int64
 	gasUsed      int64

-	sys runtime.Syscalls
-
 	// address that started invoke chain
 	origin      address.Address
 	originNonce uint64
@@ -56,7 +57,7 @@ type Runtime struct {
 	lastGasCharge     *types.GasTrace
 }

-func (rt *Runtime) NetworkVersion() vmr.NetworkVersion {
+func (rt *Runtime) NetworkVersion() network.Version {
 	return rt.vm.GetNtwkVersion(rt.ctx, rt.CurrEpoch())
 }

@@ -84,11 +85,11 @@ type notFoundErr interface {
 	IsNotFound() bool
 }

-func (rt *Runtime) Get(c cid.Cid, o vmr.CBORUnmarshaler) bool {
+func (rt *Runtime) StoreGet(c cid.Cid, o cbor.Unmarshaler) bool {
 	if err := rt.cst.Get(context.TODO(), c, o); err != nil {
 		var nfe notFoundErr
 		if xerrors.As(err, &nfe) && nfe.IsNotFound() {
-			if xerrors.As(err, new(cbor.SerializationError)) {
+			if xerrors.As(err, new(ipldcbor.SerializationError)) {
 				panic(aerrors.Newf(exitcode.ErrSerialization, "failed to unmarshal cbor object %s", err))
 			}
 			return false
@@ -99,10 +100,10 @@ func (rt *Runtime) Get(c cid.Cid, o vmr.CBORUnmarshaler) bool {
 	return true
 }

-func (rt *Runtime) Put(x vmr.CBORMarshaler) cid.Cid {
+func (rt *Runtime) StorePut(x cbor.Marshaler) cid.Cid {
 	c, err := rt.cst.Put(context.TODO(), x)
 	if err != nil {
-		if xerrors.As(err, new(cbor.SerializationError)) {
+		if xerrors.As(err, new(ipldcbor.SerializationError)) {
 			panic(aerrors.Newf(exitcode.ErrSerialization, "failed to marshal cbor object %s", err))
 		}
 		panic(aerrors.Fatalf("failed to put cbor object: %s", err))
@@ -110,7 +111,7 @@ func (rt *Runtime) Put(x vmr.CBORMarshaler) cid.Cid {
 	return c
 }

-var _ vmr.Runtime = (*Runtime)(nil)
+var _ rt0.Runtime = (*Runtime)(nil)

 func (rt *Runtime) shimCall(f func() interface{}) (rval []byte, aerr aerrors.ActorError) {
 	defer func() {
@@ -136,9 +137,9 @@ func (rt *Runtime) shimCall(f func() interface{}) (rval []byte, aerr aerrors.Act
 	switch ret := ret.(type) {
 	case []byte:
 		return ret, nil
-	case *adt.EmptyValue:
+	case *abi.EmptyValue:
 		return nil, nil
-	case cbg.CBORMarshaler:
+	case cbor.Marshaler:
 		buf := new(bytes.Buffer)
 		if err := ret.MarshalCBOR(buf); err != nil {
 			return nil, aerrors.Absorb(err, 2, "failed to marshal response to cbor")
@@ -151,17 +152,13 @@ func (rt *Runtime) shimCall(f func() interface{}) (rval []byte, aerr aerrors.Act
 	}
 }

-func (rt *Runtime) Message() vmr.Message {
-	return rt.vmsg
-}
-
 func (rt *Runtime) ValidateImmediateCallerAcceptAny() {
 	rt.abortIfAlreadyValidated()
 	return
 }

 func (rt *Runtime) CurrentBalance() abi.TokenAmount {
-	b, err := rt.GetBalance(rt.Message().Receiver())
+	b, err := rt.GetBalance(rt.Receiver())
 	if err != nil {
 		rt.Abortf(err.RetCode(), "get current balance: %v", err)
 	}
@@ -197,10 +194,6 @@ func (rt *Runtime) GetRandomnessFromBeacon(personalization crypto.DomainSeparati
 	return res
 }

-func (rt *Runtime) Store() vmr.Store {
-	return rt
-}
-
 func (rt *Runtime) NewActorAddress() address.Address {
 	var b bytes.Buffer
 	oa, _ := ResolveToKeyAddr(rt.vm.cstate, rt.vm.cst, rt.origin)
@@ -257,7 +250,7 @@ func (rt *Runtime) CreateActor(codeID cid.Cid, address address.Address) {
 // May only be called by the actor itself.
 func (rt *Runtime) DeleteActor(beneficiary address.Address) {
 	rt.chargeGas(rt.Pricelist().OnDeleteActor())
-	act, err := rt.state.GetActor(rt.Message().Receiver())
+	act, err := rt.state.GetActor(rt.Receiver())
 	if err != nil {
 		if xerrors.Is(err, types.ErrActorNotFound) {
 			rt.Abortf(exitcode.SysErrorIllegalActor, "failed to load actor in delete actor: %s", err)
@@ -266,36 +259,32 @@ func (rt *Runtime) DeleteActor(beneficiary address.Address) {
 	}
 	if !act.Balance.IsZero() {
 		// Transfer the executing actor's balance to the beneficiary
-		if err := rt.vm.transfer(rt.Message().Receiver(), beneficiary, act.Balance); err != nil {
+		if err := rt.vm.transfer(rt.Receiver(), beneficiary, act.Balance); err != nil {
 			panic(aerrors.Fatalf("failed to transfer balance to beneficiary actor: %s", err))
 		}
 	}

 	// Delete the executing actor
-	if err := rt.state.DeleteActor(rt.Message().Receiver()); err != nil {
+	if err := rt.state.DeleteActor(rt.Receiver()); err != nil {
 		panic(aerrors.Fatalf("failed to delete actor: %s", err))
 	}
 	_ = rt.chargeGasSafe(gasOnActorExec)
 }

-func (rt *Runtime) Syscalls() vmr.Syscalls {
-	return rt.sys
-}
-
-func (rt *Runtime) StartSpan(name string) vmr.TraceSpan {
+func (rt *Runtime) StartSpan(name string) func() {
 	panic("implement me")
 }

 func (rt *Runtime) ValidateImmediateCallerIs(as ...address.Address) {
 	rt.abortIfAlreadyValidated()
-	imm := rt.Message().Caller()
+	imm := rt.Caller()

 	for _, a := range as {
 		if imm == a {
 			return
 		}
 	}
-	rt.Abortf(exitcode.SysErrForbidden, "caller %s is not one of %s", rt.Message().Caller(), as)
+	rt.Abortf(exitcode.SysErrForbidden, "caller %s is not one of %s", rt.Caller(), as)
 }

 func (rt *Runtime) Context() context.Context {
@@ -313,7 +302,7 @@ func (rt *Runtime) AbortStateMsg(msg string) {

 func (rt *Runtime) ValidateImmediateCallerType(ts ...cid.Cid) {
 	rt.abortIfAlreadyValidated()
-	callerCid, ok := rt.GetActorCodeCID(rt.Message().Caller())
+	callerCid, ok := rt.GetActorCodeCID(rt.Caller())
 	if !ok {
 		panic(aerrors.Fatalf("failed to lookup code cid for caller"))
 	}
@@ -333,11 +322,11 @@ type dumbWrapperType struct {
 	val []byte
 }

-func (dwt *dumbWrapperType) Into(um vmr.CBORUnmarshaler) error {
+func (dwt *dumbWrapperType) Into(um cbor.Unmarshaler) error {
 	return um.UnmarshalCBOR(bytes.NewReader(dwt.val))
 }

-func (rt *Runtime) Send(to address.Address, method abi.MethodNum, m vmr.CBORMarshaler, value abi.TokenAmount) (vmr.SendReturn, exitcode.ExitCode) {
+func (rt *Runtime) Send(to address.Address, method abi.MethodNum, m cbor.Marshaler, value abi.TokenAmount, out cbor.Er) exitcode.ExitCode {
 	if !rt.allowInternal {
 		rt.Abortf(exitcode.SysErrorIllegalActor, "runtime.Send() is currently disallowed")
 	}
@@ -350,16 +339,20 @@ func (rt *Runtime) Send(to address.Address, method abi.MethodNum, m vmr.CBORMars
 		params = buf.Bytes()
 	}

-	ret, err := rt.internalSend(rt.Message().Receiver(), to, method, value, params)
+	ret, err := rt.internalSend(rt.Receiver(), to, method, value, params)
 	if err != nil {
 		if err.IsFatal() {
 			panic(err)
 		}
 		log.Warnf("vmctx send failed: to: %s, method: %d: ret: %d, err: %s", to, method, ret, err)
-		return &dumbWrapperType{nil}, err.RetCode()
+		return err.RetCode()
 	}
 	_ = rt.chargeGasSafe(gasOnActorExec)
-	return &dumbWrapperType{ret}, 0
+
+	if err := out.UnmarshalCBOR(bytes.NewReader(ret)); err != nil {
+		rt.Abortf(exitcode.ErrSerialization, "failed to unmarshal return value: %s", err)
+	}
+	return 0
 }

 func (rt *Runtime) internalSend(from, to address.Address, method abi.MethodNum, value types.BigInt, params []byte) ([]byte, aerrors.ActorError) {
@@ -403,49 +396,41 @@ func (rt *Runtime) internalSend(from, to address.Address, method abi.MethodNum,
 	return ret, errSend
 }

-func (rt *Runtime) State() vmr.StateHandle {
-	return &shimStateHandle{rt: rt}
-}
-
-type shimStateHandle struct {
-	rt *Runtime
-}
-
-func (ssh *shimStateHandle) Create(obj vmr.CBORMarshaler) {
-	c := ssh.rt.Put(obj)
-	err := ssh.rt.stateCommit(EmptyObjectCid, c)
+func (rt *Runtime) StateCreate(obj cbor.Marshaler) {
+	c := rt.StorePut(obj)
+	err := rt.stateCommit(EmptyObjectCid, c)
 	if err != nil {
 		panic(fmt.Errorf("failed to commit state after creating object: %w", err))
 	}
 }

-func (ssh *shimStateHandle) Readonly(obj vmr.CBORUnmarshaler) {
-	act, err := ssh.rt.state.GetActor(ssh.rt.Message().Receiver())
+func (rt *Runtime) StateReadonly(obj cbor.Unmarshaler) {
+	act, err := rt.state.GetActor(rt.Receiver())
 	if err != nil {
-		ssh.rt.Abortf(exitcode.SysErrorIllegalArgument, "failed to get actor for Readonly state: %s", err)
+		rt.Abortf(exitcode.SysErrorIllegalArgument, "failed to get actor for Readonly state: %s", err)
 	}
-	ssh.rt.Get(act.Head, obj)
+	rt.StoreGet(act.Head, obj)
 }

-func (ssh *shimStateHandle) Transaction(obj vmr.CBORer, f func()) {
+func (rt *Runtime) StateTransaction(obj cbor.Er, f func()) {
 	if obj == nil {
-		ssh.rt.Abortf(exitcode.SysErrorIllegalActor, "Must not pass nil to Transaction()")
+		rt.Abortf(exitcode.SysErrorIllegalActor, "Must not pass nil to Transaction()")
 	}

-	act, err := ssh.rt.state.GetActor(ssh.rt.Message().Receiver())
+	act, err := rt.state.GetActor(rt.Receiver())
 	if err != nil {
-		ssh.rt.Abortf(exitcode.SysErrorIllegalActor, "failed to get actor for Transaction: %s", err)
+		rt.Abortf(exitcode.SysErrorIllegalActor, "failed to get actor for Transaction: %s", err)
 	}
 	baseState := act.Head
-	ssh.rt.Get(baseState, obj)
+	rt.StoreGet(baseState, obj)

-	ssh.rt.allowInternal = false
+	rt.allowInternal = false
 	f()
-	ssh.rt.allowInternal = true
+	rt.allowInternal = true

-	c := ssh.rt.Put(obj)
+	c := rt.StorePut(obj)

-	err = ssh.rt.stateCommit(baseState, c)
+	err = rt.stateCommit(baseState, c)
 	if err != nil {
 		panic(fmt.Errorf("failed to commit state after transaction: %w", err))
 	}
@@ -465,7 +450,7 @@ func (rt *Runtime) GetBalance(a address.Address) (types.BigInt, aerrors.ActorErr

 func (rt *Runtime) stateCommit(oldh, newh cid.Cid) aerrors.ActorError {
 	// TODO: we can make this more efficient in the future...
-	act, err := rt.state.GetActor(rt.Message().Receiver())
+	act, err := rt.state.GetActor(rt.Receiver())
 	if err != nil {
 		return aerrors.Escalate(err, "failed to get actor to commit state")
 	}
@@ -476,7 +461,7 @@ func (rt *Runtime) stateCommit(oldh, newh cid.Cid) aerrors.ActorError {

 	act.Head = newh

-	if err := rt.state.SetActor(rt.Message().Receiver(), act); err != nil {
+	if err := rt.state.SetActor(rt.Receiver(), act); err != nil {
 		return aerrors.Fatalf("failed to set actor in commit state: %s", err)
 	}

@@ -571,15 +556,15 @@ func (rt *Runtime) abortIfAlreadyValidated() {
 	rt.callerValidated = true
 }

-func (rt *Runtime) Log(level vmr.LogLevel, msg string, args ...interface{}) {
+func (rt *Runtime) Log(level rtt.LogLevel, msg string, args ...interface{}) {
 	switch level {
-	case vmr.DEBUG:
+	case rtt.DEBUG:
 		actorLog.Debugf(msg, args...)
-	case vmr.INFO:
+	case rtt.INFO:
 		actorLog.Infof(msg, args...)
-	case vmr.WARN:
+	case rtt.WARN:
 		actorLog.Warnf(msg, args...)
-	case vmr.ERROR:
+	case rtt.ERROR:
 		actorLog.Errorf(msg, args...)
 	}
 }
@@ -42,6 +42,6 @@ func TestRuntimePutErrors(t *testing.T) {
 		cst: cbor.NewCborStore(nil),
 	}

-	rt.Put(&NotAVeryGoodMarshaler{})
+	rt.StorePut(&NotAVeryGoodMarshaler{})
 	t.Error("expected panic")
 }
@@ -7,7 +7,7 @@ import (
 	"reflect"
 	"time"

-	"github.com/filecoin-project/specs-actors/actors/runtime"
+	"github.com/filecoin-project/go-state-types/network"

 	bstore "github.com/filecoin-project/lotus/lib/blockstore"

@@ -116,7 +116,7 @@ func (vm *VM) makeRuntime(ctx context.Context, msg *types.Message, origin addres
 		Blocks: &gasChargingBlocks{rt.chargeGasFunc(2), rt.pricelist, vm.cst.Blocks},
 		Atlas:  vm.cst.Atlas,
 	}
-	rt.sys = pricedSyscalls{
+	rt.Syscalls = pricedSyscalls{
 		under:     vm.Syscalls(ctx, vm.cstate, rt.cst),
 		chargeGas: rt.chargeGasFunc(1),
 		pl:        rt.pricelist,
@@ -128,7 +128,7 @@ func (vm *VM) makeRuntime(ctx context.Context, msg *types.Message, origin addres
 		rt.Abortf(exitcode.SysErrInvalidReceiver, "resolve msg.From address failed")
 	}
 	vmm.From = resF
-	rt.vmsg = &vmm
+	rt.Message = vmm

 	return rt
 }
@@ -142,7 +142,7 @@ func (vm *UnsafeVM) MakeRuntime(ctx context.Context, msg *types.Message, origin
 }

 type CircSupplyCalculator func(context.Context, abi.ChainEpoch, *state.StateTree) (abi.TokenAmount, error)
-type NtwkVersionGetter func(context.Context, abi.ChainEpoch) runtime.NetworkVersion
+type NtwkVersionGetter func(context.Context, abi.ChainEpoch) network.Version

 type VM struct {
 	cstate         *state.StateTree
@@ -201,10 +201,9 @@ type Rand interface {
 type ApplyRet struct {
 	types.MessageReceipt
 	ActorErr       aerrors.ActorError
-	Penalty        types.BigInt
-	MinerTip       types.BigInt
 	ExecutionTrace types.ExecutionTrace
 	Duration       time.Duration
+	GasCosts       GasOutputs
 }

 func (vm *VM) send(ctx context.Context, msg *types.Message, parent *Runtime,
@@ -328,8 +327,7 @@ func (vm *VM) ApplyImplicitMessage(ctx context.Context, msg *types.Message) (*Ap
 		},
 		ActorErr:       actorErr,
 		ExecutionTrace: rt.executionTrace,
-		Penalty:        types.NewInt(0),
-		MinerTip:       types.NewInt(0),
+		GasCosts:       GasOutputs{},
 		Duration:       time.Since(start),
 	}, actorErr
 }
@@ -357,14 +355,15 @@ func (vm *VM) ApplyMessage(ctx context.Context, cmsg types.ChainMsg) (*ApplyRet,
 	msgGasCost := msgGas.Total()
 	// this should never happen, but is currently still exercised by some tests
 	if msgGasCost > msg.GasLimit {
+		gasOutputs := ZeroGasOutputs()
+		gasOutputs.MinerPenalty = types.BigMul(vm.baseFee, abi.NewTokenAmount(msgGasCost))
 		return &ApplyRet{
 			MessageReceipt: types.MessageReceipt{
 				ExitCode: exitcode.SysErrOutOfGas,
 				GasUsed:  0,
 			},
-			Penalty:  types.BigMul(vm.baseFee, abi.NewTokenAmount(msgGasCost)),
+			GasCosts: gasOutputs,
 			Duration: time.Since(start),
-			MinerTip: big.Zero(),
 		}, nil
 	}

@@ -375,15 +374,16 @@ func (vm *VM) ApplyMessage(ctx context.Context, cmsg types.ChainMsg) (*ApplyRet,
 	// this should never happen, but is currently still exercised by some tests
 	if err != nil {
 		if xerrors.Is(err, types.ErrActorNotFound) {
+			gasOutputs := ZeroGasOutputs()
+			gasOutputs.MinerPenalty = minerPenaltyAmount
 			return &ApplyRet{
 				MessageReceipt: types.MessageReceipt{
 					ExitCode: exitcode.SysErrSenderInvalid,
 					GasUsed:  0,
 				},
 				ActorErr: aerrors.Newf(exitcode.SysErrSenderInvalid, "actor not found: %s", msg.From),
-				Penalty:  minerPenaltyAmount,
+				GasCosts: gasOutputs,
 				Duration: time.Since(start),
-				MinerTip: big.Zero(),
 			}, nil
 		}
 		return nil, xerrors.Errorf("failed to look up from actor: %w", err)
@@ -391,19 +391,22 @@ 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) {
+		gasOutputs := ZeroGasOutputs()
+		gasOutputs.MinerPenalty = minerPenaltyAmount
 		return &ApplyRet{
 			MessageReceipt: types.MessageReceipt{
 				ExitCode: exitcode.SysErrSenderInvalid,
 				GasUsed:  0,
 			},
 			ActorErr: aerrors.Newf(exitcode.SysErrSenderInvalid, "send from not account actor: %s", fromActor.Code),
-			Penalty:  minerPenaltyAmount,
+			GasCosts: gasOutputs,
 			Duration: time.Since(start),
-			MinerTip: big.Zero(),
 		}, nil
 	}

 	if msg.Nonce != fromActor.Nonce {
+		gasOutputs := ZeroGasOutputs()
+		gasOutputs.MinerPenalty = minerPenaltyAmount
 		return &ApplyRet{
 			MessageReceipt: types.MessageReceipt{
 				ExitCode: exitcode.SysErrSenderStateInvalid,
@@ -411,14 +414,16 @@ func (vm *VM) ApplyMessage(ctx context.Context, cmsg types.ChainMsg) (*ApplyRet,
 			},
 			ActorErr: aerrors.Newf(exitcode.SysErrSenderStateInvalid,
 				"actor nonce invalid: msg:%d != state:%d", msg.Nonce, fromActor.Nonce),
-			Penalty:  minerPenaltyAmount,
+
+			GasCosts: gasOutputs,
 			Duration: time.Since(start),
-			MinerTip: big.Zero(),
 		}, nil
 	}

 	gascost := types.BigMul(types.NewInt(uint64(msg.GasLimit)), msg.GasFeeCap)
 	if fromActor.Balance.LessThan(gascost) {
+		gasOutputs := ZeroGasOutputs()
+		gasOutputs.MinerPenalty = minerPenaltyAmount
 		return &ApplyRet{
 			MessageReceipt: types.MessageReceipt{
 				ExitCode: exitcode.SysErrSenderStateInvalid,
@@ -426,9 +431,8 @@ func (vm *VM) ApplyMessage(ctx context.Context, cmsg types.ChainMsg) (*ApplyRet,
 			},
 			ActorErr: aerrors.Newf(exitcode.SysErrSenderStateInvalid,
 				"actor balance less than needed: %s < %s", types.FIL(fromActor.Balance), types.FIL(gascost)),
-			Penalty:  minerPenaltyAmount,
+			GasCosts: gasOutputs,
 			Duration: time.Since(start),
-			MinerTip: big.Zero(),
 		}, nil
 	}

@@ -521,8 +525,7 @@ func (vm *VM) ApplyMessage(ctx context.Context, cmsg types.ChainMsg) (*ApplyRet,
 		},
 		ActorErr:       actorErr,
 		ExecutionTrace: rt.executionTrace,
-		Penalty:        gasOutputs.MinerPenalty,
-		MinerTip:       gasOutputs.MinerTip,
+		GasCosts:       gasOutputs,
 		Duration:       time.Since(start),
 	}, nil
 }
@@ -700,9 +703,9 @@ func (vm *VM) Invoke(act *types.Actor, rt *Runtime, method abi.MethodNum, params
 	defer span.End()
 	if span.IsRecordingEvents() {
 		span.AddAttributes(
-			trace.StringAttribute("to", rt.Message().Receiver().String()),
+			trace.StringAttribute("to", rt.Receiver().String()),
 			trace.Int64Attribute("method", int64(method)),
-			trace.StringAttribute("value", rt.Message().ValueReceived().String()),
+			trace.StringAttribute("value", rt.ValueReceived().String()),
 		)
 	}

@@ -722,7 +725,7 @@ func (vm *VM) SetInvoker(i *Invoker) {
 	vm.inv = i
 }

-func (vm *VM) GetNtwkVersion(ctx context.Context, ce abi.ChainEpoch) runtime.NetworkVersion {
+func (vm *VM) GetNtwkVersion(ctx context.Context, ce abi.ChainEpoch) network.Version {
 	return vm.ntwkVersion(ctx, ce)
 }

@@ -337,25 +337,6 @@ var chainSetHeadCmd = &cli.Command{
 	},
 }

-func parseTipSet(ctx context.Context, api api.FullNode, vals []string) (*types.TipSet, error) {
-	var headers []*types.BlockHeader
-	for _, c := range vals {
-		blkc, err := cid.Decode(c)
-		if err != nil {
-			return nil, err
-		}
-
-		bh, err := api.ChainGetBlock(ctx, blkc)
-		if err != nil {
-			return nil, err
-		}
-
-		headers = append(headers, bh)
-	}
-
-	return types.NewTipSet(headers)
-}
-
 var chainListCmd = &cli.Command{
 	Name:  "list",
 	Usage: "View a segment of the chain",
@@ -678,7 +659,7 @@ func handleHamtEpoch(ctx context.Context, api api.FullNode, r cid.Cid) error {
 	}

 	return mp.ForEach(nil, func(key string) error {
-		ik, err := adt.ParseIntKey(key)
+		ik, err := abi.ParseIntKey(key)
 		if err != nil {
 			return err
 		}
@@ -863,6 +844,9 @@ var chainExportCmd = &cli.Command{
 			Name:  "recent-stateroots",
 			Usage: "specify the number of recent state roots to include in the export",
 		},
+		&cli.BoolFlag{
+			Name: "skip-old-msgs",
+		},
 	},
 	Action: func(cctx *cli.Context) error {
 		api, closer, err := GetFullNodeAPI(cctx)
@@ -897,7 +881,13 @@ var chainExportCmd = &cli.Command{
 			return err
 		}

-		stream, err := api.ChainExport(ctx, rsrs, ts.Key())
+		skipold := cctx.Bool("skip-old-msgs")
+
+		if rsrs == 0 && skipold {
+			return fmt.Errorf("must pass recent stateroots along with skip-old-msgs")
+		}
+
+		stream, err := api.ChainExport(ctx, rsrs, skipold, ts.Key())
 		if err != nil {
 			return err
 		}
@@ -12,6 +12,8 @@ import (
 	"text/tabwriter"
 	"time"

+	"github.com/filecoin-project/specs-actors/actors/builtin"
+
 	tm "github.com/buger/goterm"
 	"github.com/docker/go-units"
 	"github.com/fatih/color"
@@ -527,6 +529,11 @@ func interactiveDeal(cctx *cli.Context) error {
 				continue
 			}

+			if days < int(build.MinDealDuration/builtin.EpochsInDay) {
+				printErr(xerrors.Errorf("minimum duration is %d days", int(build.MinDealDuration/builtin.EpochsInDay)))
+				continue
+			}
+
 			state = "miner"
 		case "miner":
 			fmt.Print("Miner Address (t0..): ")
@@ -49,7 +49,7 @@ var logSetLevel = &cli.Command{

   The system flag can be specified multiple times.

-   eg) log set-level --system chain --system blocksync debug
+   eg) log set-level --system chain --system chainxchg debug

   Available Levels:
   debug
@@ -3,6 +3,7 @@ package cli
 import (
 	"encoding/json"
 	"fmt"
+	stdbig "math/big"
 	"sort"
 	"strconv"

@@ -11,7 +12,11 @@ import (

 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/big"

+	lapi "github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/messagepool"
 	"github.com/filecoin-project/lotus/chain/types"
 )

@@ -26,6 +31,7 @@ var mpoolCmd = &cli.Command{
 		mpoolReplaceCmd,
 		mpoolFindCmd,
 		mpoolConfig,
+		mpoolGasPerfCmd,
 	},
 }

@@ -293,6 +299,14 @@ var mpoolReplaceCmd = &cli.Command{
 			Name:  "gas-limit",
 			Usage: "gas price for new message",
 		},
+		&cli.BoolFlag{
+			Name:  "auto",
+			Usage: "automatically reprice the specified message",
+		},
+		&cli.StringFlag{
+			Name:  "max-fee",
+			Usage: "Spend up to X FIL for this message (applicable for auto mode)",
+		},
 	},
 	ArgsUsage: "[from] [nonce]",
 	Action: func(cctx *cli.Context) error {
@@ -342,15 +356,42 @@ var mpoolReplaceCmd = &cli.Command{

 		msg := found.Message

-		msg.GasLimit = cctx.Int64("gas-limit")
-		msg.GasPremium, err = types.BigFromString(cctx.String("gas-premium"))
-		if err != nil {
-			return fmt.Errorf("parsing gas-premium: %w", err)
-		}
-		// TODO: estimate fee cap here
-		msg.GasFeeCap, err = types.BigFromString(cctx.String("gas-feecap"))
-		if err != nil {
-			return fmt.Errorf("parsing gas-feecap: %w", err)
+		if cctx.Bool("auto") {
+			minRBF := messagepool.ComputeMinRBF(msg.GasPremium)
+
+			var mss *lapi.MessageSendSpec
+			if cctx.IsSet("max-fee") {
+				maxFee, err := types.BigFromString(cctx.String("max-fee"))
+				if err != nil {
+					return fmt.Errorf("parsing max-spend: %w", err)
+				}
+				mss = &lapi.MessageSendSpec{
+					MaxFee: maxFee,
+				}
+			}
+
+			// msg.GasLimit = 0 // TODO: need to fix the way we estimate gas limits to account for the messages already being in the mempool
+			msg.GasFeeCap = abi.NewTokenAmount(0)
+			msg.GasPremium = abi.NewTokenAmount(0)
+			retm, err := api.GasEstimateMessageGas(ctx, &msg, mss, types.EmptyTSK)
+			if err != nil {
+				return fmt.Errorf("failed to estimate gas values: %w", err)
+			}
+
+			msg.GasPremium = big.Max(retm.GasPremium, minRBF)
+			msg.GasFeeCap = big.Max(retm.GasFeeCap, msg.GasPremium)
+			messagepool.CapGasFee(&msg, mss.Get().MaxFee)
+		} else {
+			msg.GasLimit = cctx.Int64("gas-limit")
+			msg.GasPremium, err = types.BigFromString(cctx.String("gas-premium"))
+			if err != nil {
+				return fmt.Errorf("parsing gas-premium: %w", err)
+			}
+			// TODO: estimate fee cap here
+			msg.GasFeeCap, err = types.BigFromString(cctx.String("gas-feecap"))
+			if err != nil {
+				return fmt.Errorf("parsing gas-feecap: %w", err)
+			}
 		}

 		smsg, err := api.WalletSignMessage(ctx, msg.From, &msg)
@@ -495,3 +536,86 @@ var mpoolConfig = &cli.Command{
 		return nil
 	},
 }
+
+var mpoolGasPerfCmd = &cli.Command{
+	Name:  "gas-perf",
+	Usage: "Check gas performance of messages in mempool",
+	Flags: []cli.Flag{
+		&cli.BoolFlag{
+			Name:  "all",
+			Usage: "print gas performance for all mempool messages (default only prints for local)",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		api, closer, err := GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+
+		ctx := ReqContext(cctx)
+
+		msgs, err := api.MpoolPending(ctx, types.EmptyTSK)
+		if err != nil {
+			return err
+		}
+
+		var filter map[address.Address]struct{}
+		if !cctx.Bool("all") {
+			filter = map[address.Address]struct{}{}
+
+			addrss, err := api.WalletList(ctx)
+			if err != nil {
+				return xerrors.Errorf("getting local addresses: %w", err)
+			}
+
+			for _, a := range addrss {
+				filter[a] = struct{}{}
+			}
+
+			var filtered []*types.SignedMessage
+			for _, msg := range msgs {
+				if _, has := filter[msg.Message.From]; !has {
+					continue
+				}
+				filtered = append(filtered, msg)
+			}
+			msgs = filtered
+		}
+
+		ts, err := api.ChainHead(ctx)
+		if err != nil {
+			return xerrors.Errorf("failed to get chain head: %w", err)
+		}
+
+		baseFee := ts.Blocks()[0].ParentBaseFee
+
+		bigBlockGasLimit := big.NewInt(build.BlockGasLimit)
+
+		getGasReward := func(msg *types.SignedMessage) big.Int {
+			maxPremium := types.BigSub(msg.Message.GasFeeCap, baseFee)
+			if types.BigCmp(maxPremium, msg.Message.GasPremium) < 0 {
+				maxPremium = msg.Message.GasPremium
+			}
+			return types.BigMul(maxPremium, types.NewInt(uint64(msg.Message.GasLimit)))
+		}
+
+		getGasPerf := func(gasReward big.Int, gasLimit int64) float64 {
+			// gasPerf = gasReward * build.BlockGasLimit / gasLimit
+			a := new(stdbig.Rat).SetInt(new(stdbig.Int).Mul(gasReward.Int, bigBlockGasLimit.Int))
+			b := stdbig.NewRat(1, gasLimit)
+			c := new(stdbig.Rat).Mul(a, b)
+			r, _ := c.Float64()
+			return r
+		}
+
+		for _, m := range msgs {
+			gasReward := getGasReward(m)
+			gasPerf := getGasPerf(gasReward, m.Message.GasLimit)
+
+			fmt.Printf("%s\t%d\t%s\t%f\n", m.Message.From, m.Message.Nonce, gasReward, gasPerf)
+		}
+
+		return nil
+	},
+}
@@ -37,9 +37,13 @@ var multisigCmd = &cli.Command{
 		msigInspectCmd,
 		msigProposeCmd,
 		msigApproveCmd,
+		msigAddProposeCmd,
+		msigAddApproveCmd,
+		msigAddCancelCmd,
 		msigSwapProposeCmd,
 		msigSwapApproveCmd,
 		msigSwapCancelCmd,
+		msigVestedCmd,
 	},
 }

@@ -506,6 +510,236 @@ var msigApproveCmd = &cli.Command{
 	},
 }

+var msigAddProposeCmd = &cli.Command{
+	Name:      "add-propose",
+	Usage:     "Propose to add a signer",
+	ArgsUsage: "[multisigAddress signer]",
+	Flags: []cli.Flag{
+		&cli.BoolFlag{
+			Name:  "increase-threshold",
+			Usage: "whether the number of required signers should be increased",
+		},
+		&cli.StringFlag{
+			Name:  "from",
+			Usage: "account to send the propose message from",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		if cctx.Args().Len() != 2 {
+			return ShowHelp(cctx, fmt.Errorf("must pass multisig address and signer address"))
+		}
+
+		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
+		}
+
+		addr, err := address.NewFromString(cctx.Args().Get(1))
+		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
+		}
+
+		msgCid, err := api.MsigAddPropose(ctx, msig, from, addr, cctx.Bool("increase-threshold"))
+		if err != nil {
+			return err
+		}
+
+		fmt.Println("sent add 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("add proposal returned exit %d", wait.Receipt.ExitCode)
+		}
+
+		return nil
+	},
+}
+
+var msigAddApproveCmd = &cli.Command{
+	Name:      "add-approve",
+	Usage:     "Approve a message to add a signer",
+	ArgsUsage: "[multisigAddress proposerAddress txId newAddress increaseThreshold]",
+	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() != 5 {
+			return ShowHelp(cctx, fmt.Errorf("must pass multisig address, proposer address, transaction id, new signer address, whether to increase threshold"))
+		}
+
+		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
+		}
+
+		newAdd, err := address.NewFromString(cctx.Args().Get(3))
+		if err != nil {
+			return err
+		}
+
+		inc, err := strconv.ParseBool(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
+		}
+
+		msgCid, err := api.MsigAddApprove(ctx, msig, from, txid, prop, newAdd, inc)
+		if err != nil {
+			return err
+		}
+
+		fmt.Println("sent add 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("add approval returned exit %d", wait.Receipt.ExitCode)
+		}
+
+		return nil
+	},
+}
+
+var msigAddCancelCmd = &cli.Command{
+	Name:      "add-cancel",
+	Usage:     "Cancel a message to add a signer",
+	ArgsUsage: "[multisigAddress txId newAddress increaseThreshold]",
+	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() != 4 {
+			return ShowHelp(cctx, fmt.Errorf("must pass multisig address, transaction id, new signer address, whether to increase threshold"))
+		}
+
+		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
+		}
+
+		newAdd, err := address.NewFromString(cctx.Args().Get(2))
+		if err != nil {
+			return err
+		}
+
+		inc, err := strconv.ParseBool(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
+		}
+
+		msgCid, err := api.MsigAddCancel(ctx, msig, from, txid, newAdd, inc)
+		if err != nil {
+			return err
+		}
+
+		fmt.Println("sent add 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("add cancellation returned exit %d", wait.Receipt.ExitCode)
+		}
+
+		return nil
+	},
+}
+
 var msigSwapProposeCmd = &cli.Command{
 	Name:      "swap-propose",
 	Usage:     "Propose to swap signers",
@@ -722,7 +956,7 @@ var msigSwapCancelCmd = &cli.Command{
 			return err
 		}

-		fmt.Println("sent swap approval in message: ", msgCid)
+		fmt.Println("sent swap cancellation in message: ", msgCid)

 		wait, err := api.StateWaitMsg(ctx, msgCid, build.MessageConfidence)
 		if err != nil {
@@ -730,9 +964,71 @@ var msigSwapCancelCmd = &cli.Command{
 		}

 		if wait.Receipt.ExitCode != 0 {
-			return fmt.Errorf("swap approval returned exit %d", wait.Receipt.ExitCode)
+			return fmt.Errorf("swap 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",
+	ArgsUsage: "[multisigAddress]",
+	Flags: []cli.Flag{
+		&cli.Int64Flag{
+			Name:  "start-epoch",
+			Usage: "start epoch to measure vesting from",
+			Value: 0,
+		},
+		&cli.Int64Flag{
+			Name:  "end-epoch",
+			Usage: "end epoch to stop measure vesting at",
+			Value: -1,
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		if cctx.Args().Len() != 1 {
+			return ShowHelp(cctx, fmt.Errorf("must pass multisig address"))
+		}
+
+		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 := api.ChainGetTipSetByHeight(ctx, abi.ChainEpoch(cctx.Int64("start-epoch")), types.EmptyTSK)
+		if err != nil {
+			return err
+		}
+
+		var end *types.TipSet
+		if cctx.Int64("end-epoch") < 0 {
+			end, err = LoadTipSet(ctx, cctx, api)
+			if err != nil {
+				return err
+			}
+		} else {
+			end, err = api.ChainGetTipSetByHeight(ctx, abi.ChainEpoch(cctx.Int64("end-epoch")), types.EmptyTSK)
+			if err != nil {
+				return err
+			}
+		}
+
+		ret, err := api.MsigGetVested(ctx, msig, start.Key(), end.Key())
+		if err != nil {
+			return err
+		}
+
+		fmt.Printf("Vested: %s between %d and %d\n", types.FIL(ret), start.Height(), end.Height())
+
+		return nil
+	},
+}
@@ -8,12 +8,17 @@ import (
 	"strings"
 	"text/tabwriter"

-	"github.com/libp2p/go-libp2p-core/peer"
-	protocol "github.com/libp2p/go-libp2p-core/protocol"
-
 	"github.com/dustin/go-humanize"
 	"github.com/urfave/cli/v2"
+	"golang.org/x/xerrors"

+	"github.com/libp2p/go-libp2p-core/peer"
+	protocol "github.com/libp2p/go-libp2p-core/protocol"
+	"github.com/multiformats/go-multiaddr"
+
+	"github.com/filecoin-project/go-address"
+
+	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/lib/addrutil"
 )

@@ -141,7 +146,7 @@ var NetListen = &cli.Command{
 var netConnect = &cli.Command{
 	Name:      "connect",
 	Usage:     "Connect to a peer",
-	ArgsUsage: "[peerMultiaddr]",
+	ArgsUsage: "[peerMultiaddr|minerActorAddress]",
 	Action: func(cctx *cli.Context) error {
 		api, closer, err := GetAPI(cctx)
 		if err != nil {
@@ -152,7 +157,43 @@ var netConnect = &cli.Command{

 		pis, err := addrutil.ParseAddresses(ctx, cctx.Args().Slice())
 		if err != nil {
-			return err
+			a, perr := address.NewFromString(cctx.Args().First())
+			if perr != nil {
+				return err
+			}
+
+			na, fc, err := GetFullNodeAPI(cctx)
+			if err != nil {
+				return err
+			}
+			defer fc()
+
+			mi, err := na.StateMinerInfo(ctx, a, types.EmptyTSK)
+			if err != nil {
+				return xerrors.Errorf("getting miner info: %w", err)
+			}
+
+			if mi.PeerId == nil {
+				return xerrors.Errorf("no PeerID for miner")
+			}
+			multiaddrs := make([]multiaddr.Multiaddr, 0, len(mi.Multiaddrs))
+			for i, a := range mi.Multiaddrs {
+				maddr, err := multiaddr.NewMultiaddrBytes(a)
+				if err != nil {
+					log.Warnf("parsing multiaddr %d (%x): %s", i, a, err)
+					continue
+				}
+				multiaddrs = append(multiaddrs, maddr)
+			}
+
+			pi := peer.AddrInfo{
+				ID:    *mi.PeerId,
+				Addrs: multiaddrs,
+			}
+
+			fmt.Printf("%s -> %s\n", a, pi)
+
+			pis = append(pis, pi)
 		}

 		for _, pi := range pis {
@@ -28,6 +28,8 @@ var paychCmd = &cli.Command{
 		paychListCmd,
 		paychVoucherCmd,
 		paychSettleCmd,
+		paychStatusCmd,
+		paychStatusByFromToCmd,
 		paychCloseCmd,
 	},
 }
@@ -102,6 +104,7 @@ var paychStatusByFromToCmd = &cli.Command{
 		if cctx.Args().Len() != 2 {
 			return ShowHelp(cctx, fmt.Errorf("must pass two arguments: <from address> <to address>"))
 		}
+		ctx := ReqContext(cctx)

 		from, err := address.NewFromString(cctx.Args().Get(0))
 		if err != nil {
@@ -119,7 +122,7 @@ var paychStatusByFromToCmd = &cli.Command{
 		}
 		defer closer()

-		avail, err := api.PaychAvailableFundsByFromTo(from, to)
+		avail, err := api.PaychAvailableFundsByFromTo(ctx, from, to)
 		if err != nil {
 			return err
 		}
@@ -137,6 +140,7 @@ var paychStatusCmd = &cli.Command{
 		if cctx.Args().Len() != 1 {
 			return ShowHelp(cctx, fmt.Errorf("must pass an argument: <channel address>"))
 		}
+		ctx := ReqContext(cctx)

 		ch, err := address.NewFromString(cctx.Args().Get(0))
 		if err != nil {
@@ -149,7 +153,7 @@ var paychStatusCmd = &cli.Command{
 		}
 		defer closer()

-		avail, err := api.PaychAvailableFunds(ch)
+		avail, err := api.PaychAvailableFunds(ctx, ch)
 		if err != nil {
 			return err
 		}
@@ -27,6 +27,7 @@ import (

 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/big"
 	"github.com/filecoin-project/go-state-types/exitcode"
 	"github.com/filecoin-project/specs-actors/actors/builtin"
 	"github.com/filecoin-project/specs-actors/actors/builtin/exported"
@@ -53,6 +54,7 @@ var stateCmd = &cli.Command{
 		stateListActorsCmd,
 		stateListMinersCmd,
 		stateCircSupplyCmd,
+		stateSectorCmd,
 		stateGetActorCmd,
 		stateLookupIDCmd,
 		stateReplaySetCmd,
@@ -64,6 +66,7 @@ var stateCmd = &cli.Command{
 		stateGetDealSetCmd,
 		stateWaitMsgCmd,
 		stateSearchMsgCmd,
+		stateMsgCostCmd,
 		stateMinerInfo,
 		stateMarketCmd,
 	},
@@ -118,11 +121,18 @@ var stateMinerInfo = &cli.Command{
 		}
 		fmt.Println()

+		cd, err := api.StateMinerProvingDeadline(ctx, addr, ts.Key())
+		if err != nil {
+			return xerrors.Errorf("getting miner info: %w", err)
+		}
+
+		fmt.Printf("Proving Period Start:\t%s\n", EpochTime(cd.CurrentEpoch, cd.PeriodStart))
+
 		return nil
 	},
 }

-func parseTipSetString(ts string) ([]cid.Cid, error) {
+func ParseTipSetString(ts string) ([]cid.Cid, error) {
 	strs := strings.Split(ts, ",")

 	var cids []cid.Cid
@@ -160,7 +170,7 @@ func ParseTipSetRef(ctx context.Context, api api.FullNode, tss string) (*types.T
 		return api.ChainGetTipSetByHeight(ctx, abi.ChainEpoch(h), types.EmptyTSK)
 	}

-	cids, err := parseTipSetString(tss)
+	cids, err := ParseTipSetString(tss)
 	if err != nil {
 		return nil, err
 	}
@@ -1303,6 +1313,60 @@ var stateSearchMsgCmd = &cli.Command{
 	},
 }

+var stateMsgCostCmd = &cli.Command{
+	Name:      "msg-cost",
+	Usage:     "Get the detailed gas costs of a message",
+	ArgsUsage: "[messageCid]",
+	Action: func(cctx *cli.Context) error {
+		if !cctx.Args().Present() {
+			return fmt.Errorf("must specify message cid to get gas costs for")
+		}
+
+		api, closer, err := GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+
+		ctx := ReqContext(cctx)
+
+		msg, err := cid.Decode(cctx.Args().First())
+		if err != nil {
+			return err
+		}
+
+		tsk := types.EmptyTSK
+
+		ts, err := LoadTipSet(ctx, cctx, api)
+		if err != nil {
+			return err
+		}
+
+		if ts != nil {
+			tsk = ts.Key()
+		}
+
+		mgc, err := api.StateMsgGasCost(ctx, msg, tsk)
+		if err != nil {
+			return err
+		}
+
+		if mgc != nil {
+			fmt.Printf("Message CID: %s", mgc.Message)
+			fmt.Printf("\nGas Used: %d", mgc.GasUsed)
+			fmt.Printf("\nBase Fee Burn: %d", mgc.BaseFeeBurn)
+			fmt.Printf("\nOverestimation Burn: %d", mgc.OverEstimationBurn)
+			fmt.Printf("\nMiner Tip: %d", mgc.MinerTip)
+			fmt.Printf("\nRefund: %d", mgc.Refund)
+			fmt.Printf("\nTotal Cost: %d", mgc.TotalCost)
+			fmt.Printf("\nMiner Penalty: %d", mgc.MinerPenalty)
+		} else {
+			fmt.Print("message was not found on chain")
+		}
+		return nil
+	},
+}
+
 var stateCallCmd = &cli.Command{
 	Name:      "call",
 	Usage:     "Invoke a method on an actor locally",
@@ -1384,7 +1448,7 @@ var stateCallCmd = &cli.Command{
 		}

 		if ret.MsgRct.ExitCode != 0 {
-			return fmt.Errorf("invocation failed (exit: %d): %s", ret.MsgRct.ExitCode, ret.Error)
+			return fmt.Errorf("invocation failed (exit: %d, gasUsed: %d): %s", ret.MsgRct.ExitCode, ret.MsgRct.GasUsed, ret.Error)
 		}

 		s, err := formatOutput(cctx.String("ret"), ret.MsgRct.Return)
@@ -1392,6 +1456,7 @@ var stateCallCmd = &cli.Command{
 			return fmt.Errorf("failed to format output: %s", err)
 		}

+		fmt.Printf("gas used: %d\n", ret.MsgRct.GasUsed)
 		fmt.Printf("return: %s\n", s)

 		return nil
@@ -1465,11 +1530,11 @@ func parseParamsForMethod(act cid.Cid, method uint64, args []string) ([]byte, er
 	f := methods[method]

 	rf := reflect.TypeOf(f)
-	if rf.NumIn() != 3 {
+	if rf.NumIn() != 2 {
 		return nil, fmt.Errorf("expected referenced method to have three arguments")
 	}

-	paramObj := rf.In(2).Elem()
+	paramObj := rf.In(1).Elem()
 	if paramObj.NumField() != len(args) {
 		return nil, fmt.Errorf("not enough arguments given to call that method (expecting %d)", paramObj.NumField())
 	}
@@ -1489,6 +1554,18 @@ func parseParamsForMethod(act cid.Cid, method uint64, args []string) ([]byte, er
 				return nil, err
 			}
 			p.Elem().Field(i).Set(reflect.ValueOf(val))
+		case reflect.TypeOf(abi.ChainEpoch(0)):
+			val, err := strconv.ParseInt(args[i], 10, 64)
+			if err != nil {
+				return nil, err
+			}
+			p.Elem().Field(i).Set(reflect.ValueOf(abi.ChainEpoch(val)))
+		case reflect.TypeOf(big.Int{}):
+			val, err := big.FromString(args[i])
+			if err != nil {
+				return nil, err
+			}
+			p.Elem().Field(i).Set(reflect.ValueOf(val))
 		case reflect.TypeOf(peer.ID("")):
 			pid, err := peer.Decode(args[i])
 			if err != nil {
@@ -1540,6 +1617,77 @@ var stateCircSupplyCmd = &cli.Command{
 	},
 }

+var stateSectorCmd = &cli.Command{
+	Name:      "sector",
+	Usage:     "Get miner sector info",
+	ArgsUsage: "[miner address] [sector number]",
+	Action: func(cctx *cli.Context) error {
+		api, closer, err := GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+
+		ctx := ReqContext(cctx)
+
+		if cctx.Args().Len() != 2 {
+			return xerrors.Errorf("expected 2 params")
+		}
+
+		ts, err := LoadTipSet(ctx, cctx, api)
+		if err != nil {
+			return err
+		}
+
+		if ts == nil {
+			ts, err = api.ChainHead(ctx)
+			if err != nil {
+				return err
+			}
+		}
+
+		maddr, err := address.NewFromString(cctx.Args().Get(0))
+		if err != nil {
+			return err
+		}
+
+		sid, err := strconv.ParseInt(cctx.Args().Get(1), 10, 64)
+		if err != nil {
+			return err
+		}
+
+		si, err := api.StateSectorGetInfo(ctx, maddr, abi.SectorNumber(sid), ts.Key())
+		if err != nil {
+			return err
+		}
+
+		fmt.Println("SectorNumber: ", si.SectorNumber)
+		fmt.Println("SealProof: ", si.SealProof)
+		fmt.Println("SealedCID: ", si.SealedCID)
+		fmt.Println("DealIDs: ", si.DealIDs)
+		fmt.Println()
+		fmt.Println("Activation: ", EpochTime(ts.Height(), si.Activation))
+		fmt.Println("Expiration: ", EpochTime(ts.Height(), si.Expiration))
+		fmt.Println()
+		fmt.Println("DealWeight: ", si.DealWeight)
+		fmt.Println("VerifiedDealWeight: ", si.VerifiedDealWeight)
+		fmt.Println("InitialPledge: ", types.FIL(si.InitialPledge))
+		fmt.Println("ExpectedDayReward: ", types.FIL(si.ExpectedDayReward))
+		fmt.Println("ExpectedStoragePledge: ", types.FIL(si.ExpectedStoragePledge))
+		fmt.Println()
+
+		sp, err := api.StateSectorPartition(ctx, maddr, abi.SectorNumber(sid), ts.Key())
+		if err != nil {
+			return err
+		}
+
+		fmt.Println("Deadline: ", sp.Deadline)
+		fmt.Println("Partition: ", sp.Partition)
+
+		return nil
+	},
+}
+
 var stateMarketCmd = &cli.Command{
 	Name:  "market",
 	Usage: "Inspect the storage market actor",
@@ -5,13 +5,14 @@ import (
 	"fmt"
 	"time"

+	"github.com/filecoin-project/lotus/chain/types"
+
 	"github.com/filecoin-project/go-state-types/abi"
 	cid "github.com/ipfs/go-cid"
 	"github.com/urfave/cli/v2"

 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/build"
-	"github.com/filecoin-project/lotus/chain"
 )

 var syncCmd = &cli.Command{
@@ -21,7 +22,9 @@ var syncCmd = &cli.Command{
 		syncStatusCmd,
 		syncWaitCmd,
 		syncMarkBadCmd,
+		syncUnmarkBadCmd,
 		syncCheckBadCmd,
+		syncCheckpointCmd,
 	},
 }

@@ -61,7 +64,7 @@ var syncStatusCmd = &cli.Command{
 			fmt.Printf("\tBase:\t%s\n", base)
 			fmt.Printf("\tTarget:\t%s (%d)\n", target, theight)
 			fmt.Printf("\tHeight diff:\t%d\n", heightDiff)
-			fmt.Printf("\tStage: %s\n", chain.SyncStageString(ss.Stage))
+			fmt.Printf("\tStage: %s\n", ss.Stage)
 			fmt.Printf("\tHeight: %d\n", ss.Height)
 			if ss.End.IsZero() {
 				if !ss.Start.IsZero() {
@@ -118,6 +121,31 @@ var syncMarkBadCmd = &cli.Command{
 	},
 }

+var syncUnmarkBadCmd = &cli.Command{
+	Name:      "unmark-bad",
+	Usage:     "Unmark the given block as bad, makes it possible to sync to a chain containing it",
+	ArgsUsage: "[blockCid]",
+	Action: func(cctx *cli.Context) error {
+		napi, closer, err := GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+		ctx := ReqContext(cctx)
+
+		if !cctx.Args().Present() {
+			return fmt.Errorf("must specify block cid to unmark")
+		}
+
+		bcid, err := cid.Decode(cctx.Args().First())
+		if err != nil {
+			return fmt.Errorf("failed to decode input as a cid: %s", err)
+		}
+
+		return napi.SyncUnmarkBad(ctx, bcid)
+	},
+}
+
 var syncCheckBadCmd = &cli.Command{
 	Name:      "check-bad",
 	Usage:     "check if the given block was marked bad, and for what reason",
@@ -154,6 +182,48 @@ var syncCheckBadCmd = &cli.Command{
 	},
 }

+var syncCheckpointCmd = &cli.Command{
+	Name:      "checkpoint",
+	Usage:     "mark a certain tipset as checkpointed; the node will never fork away from this tipset",
+	ArgsUsage: "[tipsetKey]",
+	Flags: []cli.Flag{
+		&cli.Uint64Flag{
+			Name:  "epoch",
+			Usage: "checkpoint the tipset at the given epoch",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		napi, closer, err := GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+		ctx := ReqContext(cctx)
+
+		var ts *types.TipSet
+
+		if cctx.IsSet("epoch") {
+			ts, err = napi.ChainGetTipSetByHeight(ctx, abi.ChainEpoch(cctx.Uint64("epoch")), types.EmptyTSK)
+		}
+		if ts == nil {
+			ts, err = parseTipSet(ctx, napi, cctx.Args().Slice())
+		}
+		if err != nil {
+			return err
+		}
+
+		if ts == nil {
+			return fmt.Errorf("must pass cids for tipset to set as head, or specify epoch flag")
+		}
+
+		if err := napi.SyncCheckpoint(ctx, ts.Key()); err != nil {
+			return err
+		}
+
+		return nil
+	},
+}
+
 func SyncWait(ctx context.Context, napi api.FullNode) error {
 	for {
 		state, err := napi.SyncState(ctx)
@@ -186,7 +256,7 @@ func SyncWait(ctx context.Context, napi api.FullNode) error {
 			theight = ss.Target.Height()
 		}

-		fmt.Printf("\r\x1b[2KWorker %d: Target Height: %d\tTarget: %s\tState: %s\tHeight: %d", working, theight, target, chain.SyncStageString(ss.Stage), ss.Height)
+		fmt.Printf("\r\x1b[2KWorker %d: Target Height: %d\tTarget: %s\tState: %s\tHeight: %d", working, theight, target, ss.Stage, ss.Height)

 		if time.Now().Unix()-int64(head.MinTimestamp()) < int64(build.BlockDelaySecs) {
 			fmt.Println("\nDone!")
@@ -0,0 +1,47 @@
+package cli
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/ipfs/go-cid"
+
+	"github.com/filecoin-project/go-state-types/abi"
+
+	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/types"
+)
+
+func parseTipSet(ctx context.Context, api api.FullNode, vals []string) (*types.TipSet, error) {
+	var headers []*types.BlockHeader
+	for _, c := range vals {
+		blkc, err := cid.Decode(c)
+		if err != nil {
+			return nil, err
+		}
+
+		bh, err := api.ChainGetBlock(ctx, blkc)
+		if err != nil {
+			return nil, err
+		}
+
+		headers = append(headers, bh)
+	}
+
+	return types.NewTipSet(headers)
+}
+
+func EpochTime(curr, e abi.ChainEpoch) string {
+	switch {
+	case curr > e:
+		return fmt.Sprintf("%d (%s ago)", e, time.Second*time.Duration(int64(build.BlockDelaySecs)*int64(curr-e)))
+	case curr == e:
+		return fmt.Sprintf("%d (now)", e)
+	case curr < e:
+		return fmt.Sprintf("%d (in %s)", e, time.Second*time.Duration(int64(build.BlockDelaySecs)*int64(e-curr)))
+	}
+
+	panic("math broke")
+}
@@ -56,6 +56,10 @@ var importBenchCmd = &cli.Command{
 			Usage: "set the parallelism factor for batch seal verification",
 			Value: runtime.NumCPU(),
 		},
+		&cli.StringFlag{
+			Name:  "repodir",
+			Usage: "set the repo directory for the lotus bench run (defaults to /tmp)",
+		},
 	},
 	Action: func(cctx *cli.Context) error {
 		vm.BatchSealVerifyParallelism = cctx.Int("batch-seal-verify-threads")
@@ -70,9 +74,15 @@ var importBenchCmd = &cli.Command{
 		}
 		defer cfi.Close() //nolint:errcheck // read only file

-		tdir, err := ioutil.TempDir("", "lotus-import-bench")
-		if err != nil {
-			return err
+		var tdir string
+		if rdir := cctx.String("repodir"); rdir != "" {
+			tdir = rdir
+		} else {
+			tmp, err := ioutil.TempDir("", "lotus-import-bench")
+			if err != nil {
+				return err
+			}
+			tdir = tmp
 		}

 		bds, err := badger.NewDatastore(tdir, nil)
@@ -387,7 +387,7 @@ var sealBenchCmd = &cli.Command{
 				return err
 			}
 			if !ok {
-				log.Error("post verification failed")
+				log.Error("window post verification failed")
 			}

 			verifyWindowpost1 := time.Now()
@@ -403,7 +403,7 @@ var sealBenchCmd = &cli.Command{
 				return err
 			}
 			if !ok {
-				log.Error("post verification failed")
+				log.Error("window post verification failed")
 			}

 			verifyWindowpost2 := time.Now()
@@ -221,7 +221,7 @@ func (p *Processor) processMiners(ctx context.Context, minerTips map[types.TipSe
 			var claim power.Claim
 			// get miner claim from power actors claim map and store if found, else the miner had no claim at
 			// this tipset
-			found, err := minersClaims.Get(adt.AddrKey(act.addr), &claim)
+			found, err := minersClaims.Get(abi.AddrKey(act.addr), &claim)
 			if err != nil {
 				return nil, err
 			}
@@ -694,7 +694,7 @@ func (p *Processor) getMinerSectorChanges(ctx context.Context, m minerActorInfo)
 }

 func (p *Processor) diffMinerPartitions(ctx context.Context, m minerActorInfo, events chan<- *MinerSectorsEvent) error {
-	prevMiner, err := p.getMinerStateAt(ctx, m.common.addr, m.common.tsKey)
+	prevMiner, err := p.getMinerStateAt(ctx, m.common.addr, m.common.parentTsKey)
 	if err != nil {
 		return err
 	}
@@ -136,7 +136,8 @@ create unique index if not exists block_cid_uindex
 	on blocks (cid,height);

 create materialized view if not exists state_heights
-    as select distinct height, parentstateroot from blocks;
+    as select min(b.height) height, b.parentstateroot
+	from blocks b group by b.parentstateroot;

 create index if not exists state_heights_height_index
 	on state_heights (height);
@@ -0,0 +1,90 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/ipfs/go-cid"
+
+	"go.opencensus.io/trace"
+)
+
+const LookbackCap = time.Hour
+
+var (
+	ErrLookbackTooLong = fmt.Errorf("lookbacks of more than %s are disallowed", LookbackCap)
+)
+
+type GatewayAPI struct {
+	api api.FullNode
+}
+
+func (a *GatewayAPI) getTipsetTimestamp(ctx context.Context, tsk types.TipSetKey) (time.Time, error) {
+	if tsk.IsEmpty() {
+		return time.Now(), nil
+	}
+
+	ts, err := a.api.ChainGetTipSet(ctx, tsk)
+	if err != nil {
+		return time.Time{}, err
+	}
+
+	return time.Unix(int64(ts.Blocks()[0].Timestamp), 0), nil
+}
+
+func (a *GatewayAPI) checkTipset(ctx context.Context, ts types.TipSetKey) error {
+	when, err := a.getTipsetTimestamp(ctx, ts)
+	if err != nil {
+		return err
+	}
+
+	if time.Since(when) > time.Hour {
+		return ErrLookbackTooLong
+	}
+
+	return nil
+}
+
+func (a *GatewayAPI) StateGetActor(ctx context.Context, actor address.Address, ts types.TipSetKey) (*types.Actor, error) {
+	ctx, span := trace.StartSpan(ctx, "StateGetActor")
+	defer span.End()
+
+	if err := a.checkTipset(ctx, ts); err != nil {
+		return nil, fmt.Errorf("bad tipset: %w", err)
+	}
+
+	return a.api.StateGetActor(ctx, actor, ts)
+}
+
+func (a *GatewayAPI) ChainHead(ctx context.Context) (*types.TipSet, error) {
+	ctx, span := trace.StartSpan(ctx, "ChainHead")
+	defer span.End()
+	// TODO: cache and invalidate cache when timestamp is up (or have internal ChainNotify)
+
+	return a.api.ChainHead(ctx)
+}
+
+func (a *GatewayAPI) ChainGetTipSet(ctx context.Context, tsk types.TipSetKey) (*types.TipSet, error) {
+	ctx, span := trace.StartSpan(ctx, "ChainGetTipSet")
+	defer span.End()
+
+	if err := a.checkTipset(ctx, tsk); err != nil {
+		return nil, fmt.Errorf("bad tipset: %w", err)
+	}
+
+	// TODO: since we're limiting lookbacks, should just cache this (could really even cache the json response bytes)
+	return a.api.ChainGetTipSet(ctx, tsk)
+}
+
+func (a *GatewayAPI) MpoolPush(ctx context.Context, sm *types.SignedMessage) (cid.Cid, error) {
+	ctx, span := trace.StartSpan(ctx, "MpoolPush")
+	defer span.End()
+
+	// TODO: additional anti-spam checks
+
+	return a.api.MpoolPush(ctx, sm)
+}
@@ -0,0 +1,112 @@
+package main
+
+import (
+	"context"
+	"net"
+	"net/http"
+	"os"
+
+	"github.com/filecoin-project/go-jsonrpc"
+	"github.com/filecoin-project/lotus/build"
+	lcli "github.com/filecoin-project/lotus/cli"
+	"github.com/filecoin-project/lotus/lib/lotuslog"
+	logging "github.com/ipfs/go-log"
+
+	"github.com/gorilla/mux"
+	"github.com/urfave/cli/v2"
+)
+
+var log = logging.Logger("gateway")
+
+func main() {
+	lotuslog.SetupLogLevels()
+
+	local := []*cli.Command{
+		runCmd,
+	}
+
+	app := &cli.App{
+		Name:    "lotus-gateway",
+		Usage:   "Public API server for lotus",
+		Version: build.UserVersion(),
+		Flags: []cli.Flag{
+			&cli.StringFlag{
+				Name:    "repo",
+				EnvVars: []string{"LOTUS_PATH"},
+				Value:   "~/.lotus", // TODO: Consider XDG_DATA_HOME
+			},
+		},
+
+		Commands: local,
+	}
+	app.Setup()
+
+	if err := app.Run(os.Args); err != nil {
+		log.Warnf("%+v", err)
+		return
+	}
+}
+
+var runCmd = &cli.Command{
+	Name:  "run",
+	Usage: "Start api server",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:  "listen",
+			Usage: "host address and port the api server will listen on",
+			Value: "0.0.0.0:2346",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		log.Info("Starting lotus gateway")
+
+		ctx := lcli.ReqContext(cctx)
+		ctx, cancel := context.WithCancel(ctx)
+		defer cancel()
+
+		api, closer, err := lcli.GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+
+		address := cctx.String("listen")
+		mux := mux.NewRouter()
+
+		log.Info("Setting up API endpoint at " + address)
+
+		rpcServer := jsonrpc.NewServer()
+		rpcServer.Register("Filecoin", &GatewayAPI{api: api})
+
+		mux.Handle("/rpc/v0", rpcServer)
+		mux.PathPrefix("/").Handler(http.DefaultServeMux)
+
+		/*ah := &auth.Handler{
+			Verify: nodeApi.AuthVerify,
+			Next:   mux.ServeHTTP,
+		}*/
+
+		srv := &http.Server{
+			Handler: mux,
+			BaseContext: func(listener net.Listener) context.Context {
+				return ctx
+			},
+		}
+
+		go func() {
+			<-ctx.Done()
+			log.Warn("Shutting down...")
+			if err := srv.Shutdown(context.TODO()); err != nil {
+				log.Errorf("shutting down RPC server failed: %s", err)
+			}
+			log.Warn("Graceful shutdown successful")
+		}()
+
+		nl, err := net.Listen("tcp", address)
+		if err != nil {
+			return err
+		}
+
+		return srv.Serve(nl)
+	},
+}
@@ -45,6 +45,8 @@ const FlagWorkerRepo = "worker-repo"
 const FlagWorkerRepoDeprecation = "workerrepo"

 func main() {
+	build.RunningNodeType = build.NodeWorker
+
 	lotuslog.SetupLogLevels()

 	local := []*cli.Command{
@@ -187,8 +189,8 @@ var runCmd = &cli.Command{
 		if err != nil {
 			return err
 		}
-		if v.APIVersion != build.APIVersion {
-			return xerrors.Errorf("lotus-miner API version doesn't match: local: %s", api.Version{APIVersion: build.APIVersion})
+		if v.APIVersion != build.MinerAPIVersion {
+			return xerrors.Errorf("lotus-miner API version doesn't match: expected: %s", api.Version{APIVersion: build.MinerAPIVersion})
 		}
 		log.Infof("Remote version %s", v)

@@ -21,7 +21,7 @@ type worker struct {
 }

 func (w *worker) Version(context.Context) (build.Version, error) {
-	return build.APIVersion, nil
+	return build.WorkerAPIVersion, nil
 }

 func (w *worker) StorageAddLocal(ctx context.Context, path string) error {
@@ -4,6 +4,7 @@ import (
 	"encoding/base64"
 	"encoding/hex"
 	"fmt"
+	"io"
 	"io/ioutil"
 	"os"

@@ -28,6 +29,9 @@ var bitFieldCmd = &cli.Command{
 		bitFieldRunsCmd,
 		bitFieldStatCmd,
 		bitFieldDecodeCmd,
+		bitFieldIntersectCmd,
+		bitFieldEncodeCmd,
+		bitFieldSubCmd,
 	},
 }

@@ -200,38 +204,9 @@ var bitFieldDecodeCmd = &cli.Command{
 		},
 	},
 	Action: func(cctx *cli.Context) error {
-		var val string
-		if cctx.Args().Present() {
-			val = cctx.Args().Get(0)
-		} else {
-			b, err := ioutil.ReadAll(os.Stdin)
-			if err != nil {
-				return err
-			}
-			val = string(b)
-		}
-
-		var dec []byte
-		switch cctx.String("enc") {
-		case "base64":
-			d, err := base64.StdEncoding.DecodeString(val)
-			if err != nil {
-				return fmt.Errorf("decoding base64 value: %w", err)
-			}
-			dec = d
-		case "hex":
-			d, err := hex.DecodeString(val)
-			if err != nil {
-				return fmt.Errorf("decoding hex value: %w", err)
-			}
-			dec = d
-		default:
-			return fmt.Errorf("unrecognized encoding: %s", cctx.String("enc"))
-		}
-
-		rle, err := bitfield.NewFromBytes(dec)
+		rle, err := decode(cctx, 0)
 		if err != nil {
-			return xerrors.Errorf("failed to parse bitfield: %w", err)
+			return err
 		}

 		vals, err := rle.All(100000000000)
@@ -243,3 +218,170 @@ var bitFieldDecodeCmd = &cli.Command{
 		return nil
 	},
 }
+
+var bitFieldIntersectCmd = &cli.Command{
+	Name:        "intersect",
+	Description: "intersect 2 bitfields and print the resulting bitfield as base64",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:  "enc",
+			Value: "base64",
+			Usage: "specify input encoding to parse",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		b, err := decode(cctx, 1)
+		if err != nil {
+			return err
+		}
+
+		a, err := decode(cctx, 0)
+		if err != nil {
+			return err
+		}
+
+		o, err := bitfield.IntersectBitField(a, b)
+		if err != nil {
+			return xerrors.Errorf("intersect: %w", err)
+		}
+
+		s, err := o.RunIterator()
+		if err != nil {
+			return err
+		}
+
+		bytes, err := rlepluslazy.EncodeRuns(s, []byte{})
+		if err != nil {
+			return err
+		}
+
+		fmt.Println(base64.StdEncoding.EncodeToString(bytes))
+
+		return nil
+	},
+}
+
+var bitFieldSubCmd = &cli.Command{
+	Name:        "sub",
+	Description: "subtract 2 bitfields and print the resulting bitfield as base64",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:  "enc",
+			Value: "base64",
+			Usage: "specify input encoding to parse",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		b, err := decode(cctx, 1)
+		if err != nil {
+			return err
+		}
+
+		a, err := decode(cctx, 0)
+		if err != nil {
+			return err
+		}
+
+		o, err := bitfield.SubtractBitField(a, b)
+		if err != nil {
+			return xerrors.Errorf("intersect: %w", err)
+		}
+
+		s, err := o.RunIterator()
+		if err != nil {
+			return err
+		}
+
+		bytes, err := rlepluslazy.EncodeRuns(s, []byte{})
+		if err != nil {
+			return err
+		}
+
+		fmt.Println(base64.StdEncoding.EncodeToString(bytes))
+
+		return nil
+	},
+}
+
+var bitFieldEncodeCmd = &cli.Command{
+	Name:        "encode",
+	Description: "encode a series of decimal numbers into a bitfield",
+	ArgsUsage:   "[infile]",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:  "enc",
+			Value: "base64",
+			Usage: "specify input encoding to parse",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		f, err := os.Open(cctx.Args().First())
+		if err != nil {
+			return err
+		}
+		defer f.Close() // nolint
+
+		out := bitfield.New()
+		for {
+			var i uint64
+			_, err := fmt.Fscan(f, &i)
+			if err == io.EOF {
+				break
+			}
+			out.Set(i)
+		}
+
+		s, err := out.RunIterator()
+		if err != nil {
+			return err
+		}
+
+		bytes, err := rlepluslazy.EncodeRuns(s, []byte{})
+		if err != nil {
+			return err
+		}
+
+		fmt.Println(base64.StdEncoding.EncodeToString(bytes))
+
+		return nil
+	},
+}
+
+func decode(cctx *cli.Context, a int) (bitfield.BitField, error) {
+	var val string
+	if cctx.Args().Present() {
+		if a >= cctx.NArg() {
+			return bitfield.BitField{}, xerrors.Errorf("need more than %d args", a)
+		}
+		val = cctx.Args().Get(a)
+	} else {
+		if a > 0 {
+			return bitfield.BitField{}, xerrors.Errorf("need more than %d args", a)
+		}
+		b, err := ioutil.ReadAll(os.Stdin)
+		if err != nil {
+			return bitfield.BitField{}, err
+		}
+		val = string(b)
+	}
+
+	var dec []byte
+	switch cctx.String("enc") {
+	case "base64":
+		d, err := base64.StdEncoding.DecodeString(val)
+		if err != nil {
+			return bitfield.BitField{}, fmt.Errorf("decoding base64 value: %w", err)
+		}
+		dec = d
+	case "hex":
+		d, err := hex.DecodeString(val)
+		if err != nil {
+			return bitfield.BitField{}, fmt.Errorf("decoding hex value: %w", err)
+		}
+		dec = d
+	default:
+		return bitfield.BitField{}, fmt.Errorf("unrecognized encoding: %s", cctx.String("enc"))
+	}
+
+	return bitfield.NewFromBytes(dec)
+}
@@ -0,0 +1,123 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"os"
+
+	"github.com/urfave/cli/v2"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/lotus/chain/store"
+	"github.com/filecoin-project/lotus/chain/types"
+	lcli "github.com/filecoin-project/lotus/cli"
+	"github.com/filecoin-project/lotus/lib/blockstore"
+	"github.com/filecoin-project/lotus/node/repo"
+)
+
+var exportChainCmd = &cli.Command{
+	Name:        "export",
+	Description: "Export chain from repo (requires node to be offline)",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:  "repo",
+			Value: "~/.lotus",
+		},
+		&cli.StringFlag{
+			Name:  "tipset",
+			Usage: "tipset to export from",
+		},
+		&cli.Int64Flag{
+			Name: "recent-stateroots",
+		},
+		&cli.BoolFlag{
+			Name: "full-state",
+		},
+		&cli.BoolFlag{
+			Name: "skip-old-msgs",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		if !cctx.Args().Present() {
+			return lcli.ShowHelp(cctx, fmt.Errorf("must specify file name to write export to"))
+		}
+
+		ctx := context.TODO()
+
+		r, err := repo.NewFS(cctx.String("repo"))
+		if err != nil {
+			return xerrors.Errorf("opening fs repo: %w", err)
+		}
+
+		exists, err := r.Exists()
+		if err != nil {
+			return err
+		}
+		if !exists {
+			return xerrors.Errorf("lotus repo doesn't exist")
+		}
+
+		lr, err := r.Lock(repo.FullNode)
+		if err != nil {
+			return err
+		}
+		defer lr.Close() //nolint:errcheck
+
+		fi, err := os.Create(cctx.Args().First())
+		if err != nil {
+			return xerrors.Errorf("opening the output file: %w", err)
+		}
+
+		defer fi.Close() //nolint:errcheck
+
+		ds, err := lr.Datastore("/chain")
+		if err != nil {
+			return err
+		}
+
+		mds, err := lr.Datastore("/metadata")
+		if err != nil {
+			return err
+		}
+
+		bs := blockstore.NewBlockstore(ds)
+
+		cs := store.NewChainStore(bs, mds, nil)
+		if err := cs.Load(); err != nil {
+			return err
+		}
+
+		nroots := abi.ChainEpoch(cctx.Int64("recent-stateroots"))
+		fullstate := cctx.Bool("full-state")
+		skipoldmsgs := cctx.Bool("skip-old-msgs")
+
+		var ts *types.TipSet
+		if tss := cctx.String("tipset"); tss != "" {
+			cids, err := lcli.ParseTipSetString(tss)
+			if err != nil {
+				return xerrors.Errorf("failed to parse tipset (%q): %w", tss, err)
+			}
+
+			tsk := types.NewTipSetKey(cids...)
+
+			selts, err := cs.LoadTipSet(tsk)
+			if err != nil {
+				return xerrors.Errorf("loading tipset: %w", err)
+			}
+			ts = selts
+		} else {
+			ts = cs.GetHeaviestTipSet()
+		}
+
+		if fullstate {
+			nroots = ts.Height() + 1
+		}
+
+		if err := cs.Export(ctx, ts, nroots, skipoldmsgs, fi); err != nil {
+			return xerrors.Errorf("export failed: %w", err)
+		}
+
+		return nil
+	},
+}
@@ -33,6 +33,8 @@ func main() {
 		mpoolCmd,
 		genesisVerifyCmd,
 		mathCmd,
+		mpoolStatsCmd,
+		exportChainCmd,
 	}

 	app := &cli.App{
@@ -0,0 +1,273 @@
+package main
+
+import (
+	"fmt"
+	"net/http"
+	"sort"
+	"time"
+
+	"contrib.go.opencensus.io/exporter/prometheus"
+	"github.com/ipfs/go-cid"
+	logging "github.com/ipfs/go-log"
+	"github.com/urfave/cli/v2"
+	"go.opencensus.io/stats"
+	"go.opencensus.io/stats/view"
+	"go.opencensus.io/tag"
+
+	"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 (
+	MpoolAge           = stats.Float64("mpoolage", "Age of messages in the mempool", stats.UnitSeconds)
+	MpoolSize          = stats.Int64("mpoolsize", "Number of messages in mempool", stats.UnitDimensionless)
+	MpoolInboundRate   = stats.Int64("inbound", "Counter for inbound messages", stats.UnitDimensionless)
+	BlockInclusionRate = stats.Int64("inclusion", "Counter for message included in blocks", stats.UnitDimensionless)
+	MsgWaitTime        = stats.Float64("msg-wait-time", "Wait time of messages to make it into a block", stats.UnitSeconds)
+)
+
+var (
+	LeTag, _ = tag.NewKey("quantile")
+	MTTag, _ = tag.NewKey("msg_type")
+)
+
+var (
+	AgeView = &view.View{
+		Name:        "mpool-age",
+		Measure:     MpoolAge,
+		TagKeys:     []tag.Key{LeTag, MTTag},
+		Aggregation: view.LastValue(),
+	}
+	SizeView = &view.View{
+		Name:        "mpool-size",
+		Measure:     MpoolSize,
+		TagKeys:     []tag.Key{MTTag},
+		Aggregation: view.LastValue(),
+	}
+	InboundRate = &view.View{
+		Name:        "msg-inbound",
+		Measure:     MpoolInboundRate,
+		TagKeys:     []tag.Key{MTTag},
+		Aggregation: view.Count(),
+	}
+	InclusionRate = &view.View{
+		Name:        "msg-inclusion",
+		Measure:     BlockInclusionRate,
+		TagKeys:     []tag.Key{MTTag},
+		Aggregation: view.Count(),
+	}
+	MsgWait = &view.View{
+		Name:        "msg-wait",
+		Measure:     MsgWaitTime,
+		TagKeys:     []tag.Key{MTTag},
+		Aggregation: view.Distribution(10, 30, 60, 120, 240, 600, 1800, 3600),
+	}
+)
+
+type msgInfo struct {
+	msg  *types.SignedMessage
+	seen time.Time
+}
+
+var mpoolStatsCmd = &cli.Command{
+	Name: "mpool-stats",
+	Action: func(cctx *cli.Context) error {
+		logging.SetLogLevel("rpc", "ERROR")
+
+		if err := view.Register(AgeView, SizeView, InboundRate, InclusionRate, MsgWait); err != nil {
+			return err
+		}
+
+		expo, err := prometheus.NewExporter(prometheus.Options{
+			Namespace: "lotusmpool",
+		})
+		if err != nil {
+			return err
+		}
+
+		http.Handle("/debug/metrics", expo)
+
+		go func() {
+			if err := http.ListenAndServe(":10555", nil); err != nil {
+				panic(err)
+			}
+		}()
+
+		api, closer, err := lcli.GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+
+		defer closer()
+		ctx := lcli.ReqContext(cctx)
+
+		updates, err := api.MpoolSub(ctx)
+		if err != nil {
+			return err
+		}
+
+		mcache := make(map[address.Address]bool)
+		isMiner := func(addr address.Address) (bool, error) {
+			cache, ok := mcache[addr]
+			if ok {
+				return cache, nil
+			}
+
+			act, err := api.StateGetActor(ctx, addr, types.EmptyTSK)
+			if err != nil {
+				return false, err
+			}
+
+			ism := act.Code == builtin.StorageMinerActorCodeID
+			mcache[addr] = ism
+			return ism, nil
+		}
+
+		wpostTracker := make(map[cid.Cid]*msgInfo)
+		tracker := make(map[cid.Cid]*msgInfo)
+		tick := time.Tick(time.Second)
+		for {
+			select {
+			case u, ok := <-updates:
+				if !ok {
+					return fmt.Errorf("connection with lotus node broke")
+				}
+				switch u.Type {
+				case lapi.MpoolAdd:
+					stats.Record(ctx, MpoolInboundRate.M(1))
+					tracker[u.Message.Cid()] = &msgInfo{
+						msg:  u.Message,
+						seen: time.Now(),
+					}
+
+					if u.Message.Message.Method == builtin.MethodsMiner.SubmitWindowedPoSt {
+
+						miner, err := isMiner(u.Message.Message.To)
+						if err != nil {
+							log.Warnf("failed to determine if message target was to a miner: %s", err)
+							continue
+						}
+
+						if miner {
+							wpostTracker[u.Message.Cid()] = &msgInfo{
+								msg:  u.Message,
+								seen: time.Now(),
+							}
+							_ = stats.RecordWithTags(ctx, []tag.Mutator{tag.Upsert(MTTag, "wpost")}, MpoolInboundRate.M(1))
+						}
+					}
+
+				case lapi.MpoolRemove:
+					mi, ok := tracker[u.Message.Cid()]
+					if ok {
+						fmt.Printf("%s was in the mempool for %s (feecap=%s, prem=%s)\n", u.Message.Cid(), time.Since(mi.seen), u.Message.Message.GasFeeCap, u.Message.Message.GasPremium)
+						stats.Record(ctx, BlockInclusionRate.M(1))
+						stats.Record(ctx, MsgWaitTime.M(time.Since(mi.seen).Seconds()))
+						delete(tracker, u.Message.Cid())
+					}
+
+					wm, ok := wpostTracker[u.Message.Cid()]
+					if ok {
+						_ = stats.RecordWithTags(ctx, []tag.Mutator{tag.Upsert(MTTag, "wpost")}, BlockInclusionRate.M(1))
+						_ = stats.RecordWithTags(ctx, []tag.Mutator{tag.Upsert(MTTag, "wpost")}, MsgWaitTime.M(time.Since(wm.seen).Seconds()))
+						delete(wpostTracker, u.Message.Cid())
+					}
+				default:
+					return fmt.Errorf("unrecognized mpool update state: %d", u.Type)
+				}
+			case <-tick:
+				var ages []time.Duration
+				if len(tracker) > 0 {
+					for _, v := range tracker {
+						age := time.Since(v.seen)
+						ages = append(ages, age)
+					}
+
+					st := ageStats(ages)
+					_ = stats.RecordWithTags(ctx, []tag.Mutator{tag.Upsert(LeTag, "40")}, MpoolAge.M(st.Perc40.Seconds()))
+					_ = stats.RecordWithTags(ctx, []tag.Mutator{tag.Upsert(LeTag, "50")}, MpoolAge.M(st.Perc50.Seconds()))
+					_ = stats.RecordWithTags(ctx, []tag.Mutator{tag.Upsert(LeTag, "60")}, MpoolAge.M(st.Perc60.Seconds()))
+					_ = stats.RecordWithTags(ctx, []tag.Mutator{tag.Upsert(LeTag, "70")}, MpoolAge.M(st.Perc70.Seconds()))
+					_ = stats.RecordWithTags(ctx, []tag.Mutator{tag.Upsert(LeTag, "80")}, MpoolAge.M(st.Perc80.Seconds()))
+					_ = stats.RecordWithTags(ctx, []tag.Mutator{tag.Upsert(LeTag, "90")}, MpoolAge.M(st.Perc90.Seconds()))
+					_ = stats.RecordWithTags(ctx, []tag.Mutator{tag.Upsert(LeTag, "95")}, MpoolAge.M(st.Perc95.Seconds()))
+
+					stats.Record(ctx, MpoolSize.M(int64(len(tracker))))
+					fmt.Printf("%d messages in mempool for average of %s, (%s / %s / %s)\n", st.Count, st.Average, st.Perc50, st.Perc80, st.Perc95)
+				}
+
+				var wpages []time.Duration
+				if len(wpostTracker) > 0 {
+					for _, v := range wpostTracker {
+						age := time.Since(v.seen)
+						wpages = append(wpages, age)
+					}
+
+					st := ageStats(wpages)
+					_ = stats.RecordWithTags(ctx, []tag.Mutator{tag.Upsert(LeTag, "40"), tag.Upsert(MTTag, "wpost")}, MpoolAge.M(st.Perc40.Seconds()))
+					_ = stats.RecordWithTags(ctx, []tag.Mutator{tag.Upsert(LeTag, "50"), tag.Upsert(MTTag, "wpost")}, MpoolAge.M(st.Perc50.Seconds()))
+					_ = stats.RecordWithTags(ctx, []tag.Mutator{tag.Upsert(LeTag, "60"), tag.Upsert(MTTag, "wpost")}, MpoolAge.M(st.Perc60.Seconds()))
+					_ = stats.RecordWithTags(ctx, []tag.Mutator{tag.Upsert(LeTag, "70"), tag.Upsert(MTTag, "wpost")}, MpoolAge.M(st.Perc70.Seconds()))
+					_ = stats.RecordWithTags(ctx, []tag.Mutator{tag.Upsert(LeTag, "80"), tag.Upsert(MTTag, "wpost")}, MpoolAge.M(st.Perc80.Seconds()))
+					_ = stats.RecordWithTags(ctx, []tag.Mutator{tag.Upsert(LeTag, "90"), tag.Upsert(MTTag, "wpost")}, MpoolAge.M(st.Perc90.Seconds()))
+					_ = stats.RecordWithTags(ctx, []tag.Mutator{tag.Upsert(LeTag, "95"), tag.Upsert(MTTag, "wpost")}, MpoolAge.M(st.Perc95.Seconds()))
+
+					_ = stats.RecordWithTags(ctx, []tag.Mutator{tag.Upsert(MTTag, "wpost")}, MpoolSize.M(int64(len(wpostTracker))))
+					fmt.Printf("%d wpost messages in mempool for average of %s, (%s / %s / %s)\n", st.Count, st.Average, st.Perc50, st.Perc80, st.Perc95)
+				}
+			}
+		}
+	},
+}
+
+type ageStat struct {
+	Average time.Duration
+	Max     time.Duration
+	Perc40  time.Duration
+	Perc50  time.Duration
+	Perc60  time.Duration
+	Perc70  time.Duration
+	Perc80  time.Duration
+	Perc90  time.Duration
+	Perc95  time.Duration
+	Count   int
+}
+
+func ageStats(ages []time.Duration) *ageStat {
+	sort.Slice(ages, func(i, j int) bool {
+		return ages[i] < ages[j]
+	})
+
+	st := ageStat{
+		Count: len(ages),
+	}
+	var sum time.Duration
+	for _, a := range ages {
+		sum += a
+		if a > st.Max {
+			st.Max = a
+		}
+	}
+	st.Average = sum / time.Duration(len(ages))
+
+	p40 := (4 * len(ages)) / 10
+	p50 := len(ages) / 2
+	p60 := (6 * len(ages)) / 10
+	p70 := (7 * len(ages)) / 10
+	p80 := (4 * len(ages)) / 5
+	p90 := (9 * len(ages)) / 10
+	p95 := (19 * len(ages)) / 20
+
+	st.Perc40 = ages[p40]
+	st.Perc50 = ages[p50]
+	st.Perc60 = ages[p60]
+	st.Perc70 = ages[p70]
+	st.Perc80 = ages[p80]
+	st.Perc90 = ages[p90]
+	st.Perc95 = ages[p95]
+
+	return &st
+}
@@ -7,6 +7,7 @@ import (
 	"golang.org/x/xerrors"

 	"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"
@@ -336,7 +337,7 @@ var verifRegCheckVerifierCmd = &cli.Command{
 		}

 		var dcap verifreg.DataCap
-		if found, err := vh.Get(adt.AddrKey(vaddr), &dcap); err != nil {
+		if found, err := vh.Get(abi.AddrKey(vaddr), &dcap); err != nil {
 			return err
 		} else if !found {
 			return fmt.Errorf("not found")
@@ -44,6 +44,7 @@ import (
 	lcli "github.com/filecoin-project/lotus/cli"
 	sealing "github.com/filecoin-project/lotus/extern/storage-sealing"
 	"github.com/filecoin-project/lotus/genesis"
+	"github.com/filecoin-project/lotus/journal"
 	"github.com/filecoin-project/lotus/miner"
 	"github.com/filecoin-project/lotus/node/modules"
 	"github.com/filecoin-project/lotus/node/modules/dtypes"
@@ -179,8 +180,8 @@ var initCmd = &cli.Command{
 			return err
 		}

-		if !v.APIVersion.EqMajorMinor(build.APIVersion) {
-			return xerrors.Errorf("Remote API version didn't match (local %s, remote %s)", build.APIVersion, v.APIVersion)
+		if !v.APIVersion.EqMajorMinor(build.FullAPIVersion) {
+			return xerrors.Errorf("Remote API version didn't match (expected %s, remote %s)", build.FullAPIVersion, v.APIVersion)
 		}

 		log.Info("Initializing repo")
@@ -459,6 +460,12 @@ func storageMinerInit(ctx context.Context, cctx *cli.Context, api lapi.FullNode,
 				return err
 			}

+			if jrnl, err := journal.OpenFSJournal(lr, journal.DefaultDisabledEvents); err == nil {
+				journal.J = jrnl
+			} else {
+				return fmt.Errorf("failed to open filesystem journal: %w", err)
+			}
+
 			m := miner.NewMiner(api, epp, a, slashfilter.New(mds))
 			{
 				if err := m.Start(ctx); err != nil {
@@ -26,6 +26,8 @@ const FlagMinerRepo = "miner-repo"
 const FlagMinerRepoDeprecation = "storagerepo"

 func main() {
+	build.RunningNodeType = build.NodeMiner
+
 	lotuslog.SetupLogLevels()

 	local := []*cli.Command{
@@ -5,16 +5,13 @@ import (
 	"fmt"
 	"os"
 	"text/tabwriter"
-	"time"

 	"github.com/fatih/color"
 	"github.com/urfave/cli/v2"
 	"golang.org/x/xerrors"

-	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/specs-actors/actors/builtin/miner"

-	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain/types"
 	lcli "github.com/filecoin-project/lotus/cli"
 )
@@ -203,8 +200,8 @@ var provingInfoCmd = &cli.Command{
 		fmt.Printf("Current Epoch:           %d\n", cd.CurrentEpoch)

 		fmt.Printf("Proving Period Boundary: %d\n", cd.PeriodStart%miner.WPoStProvingPeriod)
-		fmt.Printf("Proving Period Start:    %s\n", epochTime(cd.CurrentEpoch, cd.PeriodStart))
-		fmt.Printf("Next Period Start:       %s\n\n", epochTime(cd.CurrentEpoch, cd.PeriodStart+miner.WPoStProvingPeriod))
+		fmt.Printf("Proving Period Start:    %s\n", lcli.EpochTime(cd.CurrentEpoch, cd.PeriodStart))
+		fmt.Printf("Next Period Start:       %s\n\n", lcli.EpochTime(cd.CurrentEpoch, cd.PeriodStart+miner.WPoStProvingPeriod))

 		fmt.Printf("Faults:      %d (%.2f%%)\n", faults, faultPerc)
 		fmt.Printf("Recovering:  %d\n", recovering)
@@ -224,27 +221,14 @@ var provingInfoCmd = &cli.Command{
 			fmt.Printf("Deadline Sectors:     %d\n", curDeadlineSectors)
 		}

-		fmt.Printf("Deadline Open:        %s\n", epochTime(cd.CurrentEpoch, cd.Open))
-		fmt.Printf("Deadline Close:       %s\n", epochTime(cd.CurrentEpoch, cd.Close))
-		fmt.Printf("Deadline Challenge:   %s\n", epochTime(cd.CurrentEpoch, cd.Challenge))
-		fmt.Printf("Deadline FaultCutoff: %s\n", epochTime(cd.CurrentEpoch, cd.FaultCutoff))
+		fmt.Printf("Deadline Open:        %s\n", lcli.EpochTime(cd.CurrentEpoch, cd.Open))
+		fmt.Printf("Deadline Close:       %s\n", lcli.EpochTime(cd.CurrentEpoch, cd.Close))
+		fmt.Printf("Deadline Challenge:   %s\n", lcli.EpochTime(cd.CurrentEpoch, cd.Challenge))
+		fmt.Printf("Deadline FaultCutoff: %s\n", lcli.EpochTime(cd.CurrentEpoch, cd.FaultCutoff))
 		return nil
 	},
 }

-func epochTime(curr, e abi.ChainEpoch) string {
-	switch {
-	case curr > e:
-		return fmt.Sprintf("%d (%s ago)", e, time.Second*time.Duration(int64(build.BlockDelaySecs)*int64(curr-e)))
-	case curr == e:
-		return fmt.Sprintf("%d (now)", e)
-	case curr < e:
-		return fmt.Sprintf("%d (in %s)", e, time.Second*time.Duration(int64(build.BlockDelaySecs)*int64(e-curr)))
-	}
-
-	panic("math broke")
-}
-
 var provingDeadlinesCmd = &cli.Command{
 	Name:  "deadlines",
 	Usage: "View the current proving period deadlines information",
@@ -5,9 +5,12 @@ import (
 	"os"
 	"text/tabwriter"

+	"github.com/docker/go-units"
 	"github.com/filecoin-project/go-fil-markets/retrievalmarket"
+	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/urfave/cli/v2"

+	"github.com/filecoin-project/lotus/chain/types"
 	lcli "github.com/filecoin-project/lotus/cli"
 )

@@ -17,6 +20,8 @@ var retrievalDealsCmd = &cli.Command{
 	Subcommands: []*cli.Command{
 		retrievalDealSelectionCmd,
 		retrievalDealsListCmd,
+		retrievalSetAskCmd,
+		retrievalGetAskCmd,
 	},
 }

@@ -154,3 +159,112 @@ var retrievalDealsListCmd = &cli.Command{
 		return w.Flush()
 	},
 }
+
+var retrievalSetAskCmd = &cli.Command{
+	Name:  "set-ask",
+	Usage: "Configure the provider's retrieval ask",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:  "price",
+			Usage: "Set the price of the ask for retrievals (FIL/GiB)",
+		},
+		&cli.StringFlag{
+			Name:  "unseal-price",
+			Usage: "Set the price to unseal",
+		},
+		&cli.StringFlag{
+			Name:        "payment-interval",
+			Usage:       "Set the payment interval (in bytes) for retrieval",
+			DefaultText: "1MiB",
+		},
+		&cli.StringFlag{
+			Name:        "payment-interval-increase",
+			Usage:       "Set the payment interval increase (in bytes) for retrieval",
+			DefaultText: "1MiB",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		ctx := lcli.DaemonContext(cctx)
+
+		api, closer, err := lcli.GetStorageMinerAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+
+		ask, err := api.MarketGetRetrievalAsk(ctx)
+		if err != nil {
+			return err
+		}
+
+		if cctx.IsSet("price") {
+			v, err := types.ParseFIL(cctx.String("price"))
+			if err != nil {
+				return err
+			}
+			ask.PricePerByte = types.BigDiv(types.BigInt(v), types.NewInt(1<<30))
+		}
+
+		if cctx.IsSet("unseal-price") {
+			v, err := types.ParseFIL(cctx.String("unseal-price"))
+			if err != nil {
+				return err
+			}
+			ask.UnsealPrice = abi.TokenAmount(v)
+		}
+
+		if cctx.IsSet("payment-interval") {
+			v, err := units.RAMInBytes(cctx.String("payment-interval"))
+			if err != nil {
+				return err
+			}
+			ask.PaymentInterval = uint64(v)
+		}
+
+		if cctx.IsSet("payment-interval-increase") {
+			v, err := units.RAMInBytes(cctx.String("payment-interval-increase"))
+			if err != nil {
+				return err
+			}
+			ask.PaymentIntervalIncrease = uint64(v)
+		}
+
+		return api.MarketSetRetrievalAsk(ctx, ask)
+	},
+}
+
+var retrievalGetAskCmd = &cli.Command{
+	Name:  "get-ask",
+	Usage: "Get the provider's current retrieval ask",
+	Flags: []cli.Flag{},
+	Action: func(cctx *cli.Context) error {
+		ctx := lcli.DaemonContext(cctx)
+
+		api, closer, err := lcli.GetStorageMinerAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+
+		ask, err := api.MarketGetRetrievalAsk(ctx)
+		if err != nil {
+			return err
+		}
+
+		w := tabwriter.NewWriter(os.Stdout, 2, 4, 2, ' ', 0)
+		fmt.Fprintf(w, "Price per Byte\tUnseal Price\tPayment Interval\tPayment Interval Increase\n")
+		if ask == nil {
+			fmt.Fprintf(w, "<miner does not have an retrieval ask set>\n")
+			return w.Flush()
+		}
+
+		fmt.Fprintf(w, "%s\t%s\t%s\t%s\n",
+			types.FIL(ask.PricePerByte),
+			types.FIL(ask.UnsealPrice),
+			units.BytesSize(float64(ask.PaymentInterval)),
+			units.BytesSize(float64(ask.PaymentIntervalIncrease)),
+		)
+		return w.Flush()
+
+	},
+}
@@ -77,8 +77,8 @@ var runCmd = &cli.Command{
 			}
 		}

-		if v.APIVersion != build.APIVersion {
-			return xerrors.Errorf("lotus-daemon API version doesn't match: local: %s", api.Version{APIVersion: build.APIVersion})
+		if v.APIVersion != build.FullAPIVersion {
+			return xerrors.Errorf("lotus-daemon API version doesn't match: expected: %s", api.Version{APIVersion: build.FullAPIVersion})
 		}

 		log.Info("Checking full node sync status")
@@ -46,6 +46,7 @@ func init() {
 					return xerrors.Errorf("StateMinerWorker: %w", err)
 				}

+				// XXX: This can't be right
 				rand, err := api.ChainGetRandomnessFromTickets(ctx, head.Key(), crypto.DomainSeparationTag_TicketProduction, head.Height(), addr.Bytes())
 				if err != nil {
 					return xerrors.Errorf("failed to get randomness: %w", err)
@@ -16,6 +16,8 @@ import (
 var AdvanceBlockCmd *cli.Command

 func main() {
+	build.RunningNodeType = build.NodeFull
+
 	lotuslog.SetupLogLevels()

 	local := []*cli.Command{
@@ -0,0 +1,278 @@
+package chaos
+
+import (
+	"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/actors/runtime"
+	"github.com/ipfs/go-cid"
+
+	typegen "github.com/whyrusleeping/cbor-gen"
+)
+
+//go:generate go run ./gen
+
+// Actor is a chaos actor. It implements a variety of illegal behaviours that
+// trigger violations of VM invariants. These behaviours are not found in
+// production code, but are important to test that the VM constraints are
+// properly enforced.
+//
+// The chaos actor is being incubated and its behaviour and ABI be standardised
+// shortly. Its CID is ChaosActorCodeCID, and its singleton address is 98 (Address).
+// It cannot be instantiated via the init actor, and its constructor panics.
+//
+// Test vectors relying on the chaos actor being deployed will carry selector
+// "chaos_actor:true".
+type Actor struct{}
+
+// CallerValidationBranch is an enum used to select a branch in the
+// CallerValidation method.
+type CallerValidationBranch int64
+
+const (
+	CallerValidationBranchNone CallerValidationBranch = iota
+	CallerValidationBranchTwice
+	CallerValidationBranchAddrNilSet
+	CallerValidationBranchTypeNilSet
+)
+
+// MutateStateBranch is an enum used to select the type of state mutation to attempt.
+type MutateStateBranch int64
+
+const (
+	// MutateInTransaction legally mutates state within a transaction.
+	MutateInTransaction MutateStateBranch = iota
+	// MutateReadonly ILLEGALLY mutates readonly state.
+	MutateReadonly
+	// MutateAfterTransaction ILLEGALLY mutates state after a transaction.
+	MutateAfterTransaction
+)
+
+const (
+	_                      = 0 // skip zero iota value; first usage of iota gets 1.
+	MethodCallerValidation = builtin.MethodConstructor + iota
+	MethodCreateActor
+	MethodResolveAddress
+	// MethodDeleteActor is the identifier for the method that deletes this actor.
+	MethodDeleteActor
+	// MethodSend is the identifier for the method that sends a message to another actor.
+	MethodSend
+	// MethodMutateState is the identifier for the method that attempts to mutate
+	// a state value in the actor.
+	MethodMutateState
+	// MethodAbortWith is the identifier for the method that panics optionally with
+	// a passed exit code.
+	MethodAbortWith
+	// MethodInspectRuntime is the identifier for the method that returns the
+	// current runtime values.
+	MethodInspectRuntime
+)
+
+// Exports defines the methods this actor exposes publicly.
+func (a Actor) Exports() []interface{} {
+	return []interface{}{
+		builtin.MethodConstructor: a.Constructor,
+		MethodCallerValidation:    a.CallerValidation,
+		MethodCreateActor:         a.CreateActor,
+		MethodResolveAddress:      a.ResolveAddress,
+		MethodDeleteActor:         a.DeleteActor,
+		MethodSend:                a.Send,
+		MethodMutateState:         a.MutateState,
+		MethodAbortWith:           a.AbortWith,
+		MethodInspectRuntime:      a.InspectRuntime,
+	}
+}
+
+var _ runtime.Invokee = Actor{}
+
+// SendArgs are the arguments for the Send method.
+type SendArgs struct {
+	To     address.Address
+	Value  abi.TokenAmount
+	Method abi.MethodNum
+	Params []byte
+}
+
+// SendReturn is the return values for the Send method.
+type SendReturn struct {
+	Return runtime.CBORBytes
+	Code   exitcode.ExitCode
+}
+
+// Send requests for this actor to send a message to an actor with the
+// passed parameters.
+func (a Actor) Send(rt runtime.Runtime, args *SendArgs) *SendReturn {
+	rt.ValidateImmediateCallerAcceptAny()
+	var out runtime.CBORBytes
+	code := rt.Send(
+		args.To,
+		args.Method,
+		runtime.CBORBytes(args.Params),
+		args.Value,
+		&out,
+	)
+	return &SendReturn{
+		Return: out,
+		Code:   code,
+	}
+}
+
+// Constructor will panic because the Chaos actor is a singleton.
+func (a Actor) Constructor(_ runtime.Runtime, _ *abi.EmptyValue) *abi.EmptyValue {
+	panic("constructor should not be called; the Chaos actor is a singleton actor")
+}
+
+// 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) {
+	case CallerValidationBranchNone:
+	case CallerValidationBranchTwice:
+		rt.ValidateImmediateCallerAcceptAny()
+		rt.ValidateImmediateCallerAcceptAny()
+	case CallerValidationBranchAddrNilSet:
+		rt.ValidateImmediateCallerIs()
+	case CallerValidationBranchTypeNilSet:
+		rt.ValidateImmediateCallerType()
+	default:
+		panic("invalid branch passed to CallerValidation")
+	}
+
+	return nil
+}
+
+// CreateActorArgs are the arguments to CreateActor.
+type CreateActorArgs struct {
+	// UndefActorCID instructs us to use cid.Undef; we can't pass cid.Undef
+	// in ActorCID because it doesn't serialize.
+	UndefActorCID bool
+	ActorCID      cid.Cid
+
+	// UndefAddress is the same as UndefActorCID but for Address.
+	UndefAddress bool
+	Address      address.Address
+}
+
+// CreateActor creates an actor with the supplied CID and Address.
+func (a Actor) CreateActor(rt runtime.Runtime, args *CreateActorArgs) *abi.EmptyValue {
+	rt.ValidateImmediateCallerAcceptAny()
+
+	var (
+		acid = args.ActorCID
+		addr = args.Address
+	)
+
+	if args.UndefActorCID {
+		acid = cid.Undef
+	}
+	if args.UndefAddress {
+		addr = address.Undef
+	}
+
+	rt.CreateActor(acid, addr)
+	return nil
+}
+
+// ResolveAddressResponse holds the response of a call to runtime.ResolveAddress
+type ResolveAddressResponse struct {
+	Address address.Address
+	Success bool
+}
+
+func (a Actor) ResolveAddress(rt runtime.Runtime, args *address.Address) *ResolveAddressResponse {
+	rt.ValidateImmediateCallerAcceptAny()
+
+	resolvedAddr, ok := rt.ResolveAddress(*args)
+	if !ok {
+		invalidAddr, _ := address.NewIDAddress(0)
+		resolvedAddr = invalidAddr
+	}
+	return &ResolveAddressResponse{resolvedAddr, ok}
+}
+
+// DeleteActor deletes the executing actor from the state tree, transferring any
+// balance to beneficiary.
+func (a Actor) DeleteActor(rt runtime.Runtime, beneficiary *address.Address) *abi.EmptyValue {
+	rt.ValidateImmediateCallerAcceptAny()
+	rt.DeleteActor(*beneficiary)
+	return nil
+}
+
+// MutateStateArgs specify the value to set on the state and the way in which
+// it should be attempted to be set.
+type MutateStateArgs struct {
+	Value  string
+	Branch MutateStateBranch
+}
+
+// MutateState attempts to mutate a state value in the actor.
+func (a Actor) MutateState(rt runtime.Runtime, args *MutateStateArgs) *abi.EmptyValue {
+	rt.ValidateImmediateCallerAcceptAny()
+	var st State
+	switch args.Branch {
+	case MutateInTransaction:
+		rt.StateTransaction(&st, func() {
+			st.Value = args.Value
+		})
+	case MutateReadonly:
+		rt.StateReadonly(&st)
+		st.Value = args.Value
+	case MutateAfterTransaction:
+		rt.StateTransaction(&st, func() {
+			st.Value = args.Value + "-in"
+		})
+		st.Value = args.Value
+	default:
+		panic("unknown mutation type")
+	}
+	return nil
+}
+
+// AbortWithArgs are the arguments to the Actor.AbortWith method, specifying the
+// exit code to (optionally) abort with and the message.
+type AbortWithArgs struct {
+	Code         exitcode.ExitCode
+	Message      string
+	Uncontrolled bool
+}
+
+// AbortWith simply causes a panic with the passed exit code.
+func (a Actor) AbortWith(rt runtime.Runtime, args *AbortWithArgs) *abi.EmptyValue {
+	if args.Uncontrolled { // uncontrolled abort: directly panic
+		panic(args.Message)
+	} else {
+		rt.Abortf(args.Code, args.Message)
+	}
+	return nil
+}
+
+// InspectRuntimeReturn is the return value for the Actor.InspectRuntime method.
+type InspectRuntimeReturn struct {
+	Caller         address.Address
+	Receiver       address.Address
+	ValueReceived  abi.TokenAmount
+	CurrEpoch      abi.ChainEpoch
+	CurrentBalance abi.TokenAmount
+	State          State
+}
+
+// InspectRuntime returns a copy of the serializable values available in the Runtime.
+func (a Actor) InspectRuntime(rt runtime.Runtime, _ *abi.EmptyValue) *InspectRuntimeReturn {
+	rt.ValidateImmediateCallerAcceptAny()
+	var st State
+	rt.StateReadonly(&st)
+	return &InspectRuntimeReturn{
+		Caller:         rt.Caller(),
+		Receiver:       rt.Receiver(),
+		ValueReceived:  rt.ValueReceived(),
+		CurrEpoch:      rt.CurrEpoch(),
+		CurrentBalance: rt.CurrentBalance(),
+		State:          st,
+	}
+}
@@ -0,0 +1,179 @@
+package chaos
+
+import (
+	"context"
+	"testing"
+
+	"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"
+)
+
+func TestSingleton(t *testing.T) {
+	receiver := atesting.NewIDAddr(t, 100)
+	builder := mock.NewBuilder(context.Background(), receiver)
+
+	rt := builder.Build(t)
+	var a Actor
+
+	msg := "constructor should not be called; the Chaos actor is a singleton actor"
+	rt.ExpectAssertionFailure(msg, func() {
+		rt.Call(a.Constructor, abi.Empty)
+	})
+	rt.Verify()
+}
+
+func TestDeleteActor(t *testing.T) {
+	receiver := atesting.NewIDAddr(t, 100)
+	beneficiary := atesting.NewIDAddr(t, 101)
+	builder := mock.NewBuilder(context.Background(), receiver)
+
+	rt := builder.Build(t)
+	var a Actor
+
+	rt.ExpectValidateCallerAny()
+	rt.ExpectDeleteActor(beneficiary)
+	rt.Call(a.DeleteActor, &beneficiary)
+	rt.Verify()
+}
+
+func TestMutateStateInTransaction(t *testing.T) {
+	receiver := atesting.NewIDAddr(t, 100)
+	builder := mock.NewBuilder(context.Background(), receiver)
+
+	rt := builder.Build(t)
+	var a Actor
+
+	rt.ExpectValidateCallerAny()
+	rt.StateCreate(&State{})
+
+	val := "__mutstat test"
+	rt.Call(a.MutateState, &MutateStateArgs{
+		Value:  val,
+		Branch: MutateInTransaction,
+	})
+
+	var st State
+	rt.GetState(&st)
+
+	if st.Value != val {
+		t.Fatal("state was not updated")
+	}
+
+	rt.Verify()
+}
+
+func TestMutateStateAfterTransaction(t *testing.T) {
+	receiver := atesting.NewIDAddr(t, 100)
+	builder := mock.NewBuilder(context.Background(), receiver)
+
+	rt := builder.Build(t)
+	var a Actor
+
+	rt.ExpectValidateCallerAny()
+	rt.StateCreate(&State{})
+
+	val := "__mutstat test"
+	rt.Call(a.MutateState, &MutateStateArgs{
+		Value:  val,
+		Branch: MutateAfterTransaction,
+	})
+
+	var st State
+	rt.GetState(&st)
+
+	// state should be updated successfully _in_ the transaction but not outside
+	if st.Value != val+"-in" {
+		t.Fatal("state was not updated")
+	}
+
+	rt.Verify()
+}
+
+func TestMutateStateReadonly(t *testing.T) {
+	receiver := atesting.NewIDAddr(t, 100)
+	builder := mock.NewBuilder(context.Background(), receiver)
+
+	rt := builder.Build(t)
+	var a Actor
+
+	rt.ExpectValidateCallerAny()
+	rt.StateCreate(&State{})
+
+	val := "__mutstat test"
+	rt.Call(a.MutateState, &MutateStateArgs{
+		Value:  val,
+		Branch: MutateReadonly,
+	})
+
+	var st State
+	rt.GetState(&st)
+
+	if st.Value != "" {
+		t.Fatal("state was not expected to be updated")
+	}
+
+	rt.Verify()
+}
+
+func TestAbortWith(t *testing.T) {
+	receiver := atesting.NewIDAddr(t, 100)
+	builder := mock.NewBuilder(context.Background(), receiver)
+
+	rt := builder.Build(t)
+	var a Actor
+
+	msg := "__test forbidden"
+	rt.ExpectAbortContainsMessage(exitcode.ErrForbidden, msg, func() {
+		rt.Call(a.AbortWith, &AbortWithArgs{
+			Code:         exitcode.ErrForbidden,
+			Message:      msg,
+			Uncontrolled: false,
+		})
+	})
+	rt.Verify()
+}
+
+func TestAbortWithUncontrolled(t *testing.T) {
+	receiver := atesting.NewIDAddr(t, 100)
+	builder := mock.NewBuilder(context.Background(), receiver)
+
+	rt := builder.Build(t)
+	var a Actor
+
+	msg := "__test uncontrolled panic"
+	rt.ExpectAssertionFailure(msg, func() {
+		rt.Call(a.AbortWith, &AbortWithArgs{
+			Message:      msg,
+			Uncontrolled: true,
+		})
+	})
+	rt.Verify()
+}
+
+func TestInspectRuntime(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)
+	rt.StateCreate(&State{})
+	var a Actor
+
+	rt.ExpectValidateCallerAny()
+	ret := rt.Call(a.InspectRuntime, abi.Empty)
+	rtr, ok := ret.(*InspectRuntimeReturn)
+	if !ok {
+		t.Fatal("invalid return value")
+	}
+	if rtr.Caller != caller {
+		t.Fatal("unexpected runtime caller")
+	}
+	if rtr.Receiver != receiver {
+		t.Fatal("unexpected runtime receiver")
+	}
+	rt.Verify()
+}
@@ -0,0 +1,874 @@
+// Code generated by github.com/whyrusleeping/cbor-gen. DO NOT EDIT.
+
+package chaos
+
+import (
+	"fmt"
+	"io"
+
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/exitcode"
+	cbg "github.com/whyrusleeping/cbor-gen"
+	"golang.org/x/xerrors"
+)
+
+var _ = xerrors.Errorf
+
+var lengthBufState = []byte{130}
+
+func (t *State) MarshalCBOR(w io.Writer) error {
+	if t == nil {
+		_, err := w.Write(cbg.CborNull)
+		return err
+	}
+	if _, err := w.Write(lengthBufState); err != nil {
+		return err
+	}
+
+	scratch := make([]byte, 9)
+
+	// t.Value (string) (string)
+	if len(t.Value) > cbg.MaxLength {
+		return xerrors.Errorf("Value in field t.Value was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len(t.Value))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string(t.Value)); err != nil {
+		return err
+	}
+
+	// t.Unmarshallable ([]*chaos.UnmarshallableCBOR) (slice)
+	if len(t.Unmarshallable) > cbg.MaxLength {
+		return xerrors.Errorf("Slice value in field t.Unmarshallable was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajArray, uint64(len(t.Unmarshallable))); err != nil {
+		return err
+	}
+	for _, v := range t.Unmarshallable {
+		if err := v.MarshalCBOR(w); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (t *State) UnmarshalCBOR(r io.Reader) error {
+	*t = State{}
+
+	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 != 2 {
+		return fmt.Errorf("cbor input had wrong number of fields")
+	}
+
+	// t.Value (string) (string)
+
+	{
+		sval, err := cbg.ReadStringBuf(br, scratch)
+		if err != nil {
+			return err
+		}
+
+		t.Value = string(sval)
+	}
+	// t.Unmarshallable ([]*chaos.UnmarshallableCBOR) (slice)
+
+	maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
+	if err != nil {
+		return err
+	}
+
+	if extra > cbg.MaxLength {
+		return fmt.Errorf("t.Unmarshallable: array too large (%d)", extra)
+	}
+
+	if maj != cbg.MajArray {
+		return fmt.Errorf("expected cbor array")
+	}
+
+	if extra > 0 {
+		t.Unmarshallable = make([]*UnmarshallableCBOR, extra)
+	}
+
+	for i := 0; i < int(extra); i++ {
+
+		var v UnmarshallableCBOR
+		if err := v.UnmarshalCBOR(br); err != nil {
+			return err
+		}
+
+		t.Unmarshallable[i] = &v
+	}
+
+	return nil
+}
+
+var lengthBufCreateActorArgs = []byte{132}
+
+func (t *CreateActorArgs) MarshalCBOR(w io.Writer) error {
+	if t == nil {
+		_, err := w.Write(cbg.CborNull)
+		return err
+	}
+	if _, err := w.Write(lengthBufCreateActorArgs); err != nil {
+		return err
+	}
+
+	scratch := make([]byte, 9)
+
+	// t.UndefActorCID (bool) (bool)
+	if err := cbg.WriteBool(w, t.UndefActorCID); err != nil {
+		return err
+	}
+
+	// t.ActorCID (cid.Cid) (struct)
+
+	if err := cbg.WriteCidBuf(scratch, w, t.ActorCID); err != nil {
+		return xerrors.Errorf("failed to write cid field t.ActorCID: %w", err)
+	}
+
+	// t.UndefAddress (bool) (bool)
+	if err := cbg.WriteBool(w, t.UndefAddress); err != nil {
+		return err
+	}
+
+	// t.Address (address.Address) (struct)
+	if err := t.Address.MarshalCBOR(w); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (t *CreateActorArgs) UnmarshalCBOR(r io.Reader) error {
+	*t = CreateActorArgs{}
+
+	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 != 4 {
+		return fmt.Errorf("cbor input had wrong number of fields")
+	}
+
+	// t.UndefActorCID (bool) (bool)
+
+	maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
+	if err != nil {
+		return err
+	}
+	if maj != cbg.MajOther {
+		return fmt.Errorf("booleans must be major type 7")
+	}
+	switch extra {
+	case 20:
+		t.UndefActorCID = false
+	case 21:
+		t.UndefActorCID = true
+	default:
+		return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
+	}
+	// t.ActorCID (cid.Cid) (struct)
+
+	{
+
+		c, err := cbg.ReadCid(br)
+		if err != nil {
+			return xerrors.Errorf("failed to read cid field t.ActorCID: %w", err)
+		}
+
+		t.ActorCID = c
+
+	}
+	// t.UndefAddress (bool) (bool)
+
+	maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
+	if err != nil {
+		return err
+	}
+	if maj != cbg.MajOther {
+		return fmt.Errorf("booleans must be major type 7")
+	}
+	switch extra {
+	case 20:
+		t.UndefAddress = false
+	case 21:
+		t.UndefAddress = true
+	default:
+		return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
+	}
+	// t.Address (address.Address) (struct)
+
+	{
+
+		if err := t.Address.UnmarshalCBOR(br); err != nil {
+			return xerrors.Errorf("unmarshaling t.Address: %w", err)
+		}
+
+	}
+	return nil
+}
+
+var lengthBufResolveAddressResponse = []byte{130}
+
+func (t *ResolveAddressResponse) MarshalCBOR(w io.Writer) error {
+	if t == nil {
+		_, err := w.Write(cbg.CborNull)
+		return err
+	}
+	if _, err := w.Write(lengthBufResolveAddressResponse); err != nil {
+		return err
+	}
+
+	// t.Address (address.Address) (struct)
+	if err := t.Address.MarshalCBOR(w); err != nil {
+		return err
+	}
+
+	// t.Success (bool) (bool)
+	if err := cbg.WriteBool(w, t.Success); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (t *ResolveAddressResponse) UnmarshalCBOR(r io.Reader) error {
+	*t = ResolveAddressResponse{}
+
+	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 != 2 {
+		return fmt.Errorf("cbor input had wrong number of fields")
+	}
+
+	// t.Address (address.Address) (struct)
+
+	{
+
+		if err := t.Address.UnmarshalCBOR(br); err != nil {
+			return xerrors.Errorf("unmarshaling t.Address: %w", err)
+		}
+
+	}
+	// t.Success (bool) (bool)
+
+	maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
+	if err != nil {
+		return err
+	}
+	if maj != cbg.MajOther {
+		return fmt.Errorf("booleans must be major type 7")
+	}
+	switch extra {
+	case 20:
+		t.Success = false
+	case 21:
+		t.Success = true
+	default:
+		return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
+	}
+	return nil
+}
+
+var lengthBufSendArgs = []byte{132}
+
+func (t *SendArgs) MarshalCBOR(w io.Writer) error {
+	if t == nil {
+		_, err := w.Write(cbg.CborNull)
+		return err
+	}
+	if _, err := w.Write(lengthBufSendArgs); err != nil {
+		return err
+	}
+
+	scratch := make([]byte, 9)
+
+	// t.To (address.Address) (struct)
+	if err := t.To.MarshalCBOR(w); err != nil {
+		return err
+	}
+
+	// t.Value (big.Int) (struct)
+	if err := t.Value.MarshalCBOR(w); err != nil {
+		return err
+	}
+
+	// t.Method (abi.MethodNum) (uint64)
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.Method)); err != nil {
+		return err
+	}
+
+	// t.Params ([]uint8) (slice)
+	if len(t.Params) > cbg.ByteArrayMaxLen {
+		return xerrors.Errorf("Byte array in field t.Params was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajByteString, uint64(len(t.Params))); err != nil {
+		return err
+	}
+
+	if _, err := w.Write(t.Params[:]); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (t *SendArgs) UnmarshalCBOR(r io.Reader) error {
+	*t = SendArgs{}
+
+	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 != 4 {
+		return fmt.Errorf("cbor input had wrong number of fields")
+	}
+
+	// t.To (address.Address) (struct)
+
+	{
+
+		if err := t.To.UnmarshalCBOR(br); err != nil {
+			return xerrors.Errorf("unmarshaling t.To: %w", err)
+		}
+
+	}
+	// t.Value (big.Int) (struct)
+
+	{
+
+		if err := t.Value.UnmarshalCBOR(br); err != nil {
+			return xerrors.Errorf("unmarshaling t.Value: %w", err)
+		}
+
+	}
+	// t.Method (abi.MethodNum) (uint64)
+
+	{
+
+		maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
+		if err != nil {
+			return err
+		}
+		if maj != cbg.MajUnsignedInt {
+			return fmt.Errorf("wrong type for uint64 field")
+		}
+		t.Method = abi.MethodNum(extra)
+
+	}
+	// t.Params ([]uint8) (slice)
+
+	maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
+	if err != nil {
+		return err
+	}
+
+	if extra > cbg.ByteArrayMaxLen {
+		return fmt.Errorf("t.Params: byte array too large (%d)", extra)
+	}
+	if maj != cbg.MajByteString {
+		return fmt.Errorf("expected byte array")
+	}
+
+	if extra > 0 {
+		t.Params = make([]uint8, extra)
+	}
+
+	if _, err := io.ReadFull(br, t.Params[:]); err != nil {
+		return err
+	}
+	return nil
+}
+
+var lengthBufSendReturn = []byte{130}
+
+func (t *SendReturn) MarshalCBOR(w io.Writer) error {
+	if t == nil {
+		_, err := w.Write(cbg.CborNull)
+		return err
+	}
+	if _, err := w.Write(lengthBufSendReturn); err != nil {
+		return err
+	}
+
+	scratch := make([]byte, 9)
+
+	// t.Return (runtime.CBORBytes) (slice)
+	if len(t.Return) > cbg.ByteArrayMaxLen {
+		return xerrors.Errorf("Byte array in field t.Return was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajByteString, uint64(len(t.Return))); err != nil {
+		return err
+	}
+
+	if _, err := w.Write(t.Return[:]); err != nil {
+		return err
+	}
+
+	// t.Code (exitcode.ExitCode) (int64)
+	if t.Code >= 0 {
+		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.Code)); err != nil {
+			return err
+		}
+	} else {
+		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajNegativeInt, uint64(-t.Code-1)); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (t *SendReturn) UnmarshalCBOR(r io.Reader) error {
+	*t = SendReturn{}
+
+	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 != 2 {
+		return fmt.Errorf("cbor input had wrong number of fields")
+	}
+
+	// t.Return (runtime.CBORBytes) (slice)
+
+	maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
+	if err != nil {
+		return err
+	}
+
+	if extra > cbg.ByteArrayMaxLen {
+		return fmt.Errorf("t.Return: byte array too large (%d)", extra)
+	}
+	if maj != cbg.MajByteString {
+		return fmt.Errorf("expected byte array")
+	}
+
+	if extra > 0 {
+		t.Return = make([]uint8, extra)
+	}
+
+	if _, err := io.ReadFull(br, t.Return[:]); err != nil {
+		return err
+	}
+	// t.Code (exitcode.ExitCode) (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.Code = exitcode.ExitCode(extraI)
+	}
+	return nil
+}
+
+var lengthBufMutateStateArgs = []byte{130}
+
+func (t *MutateStateArgs) MarshalCBOR(w io.Writer) error {
+	if t == nil {
+		_, err := w.Write(cbg.CborNull)
+		return err
+	}
+	if _, err := w.Write(lengthBufMutateStateArgs); err != nil {
+		return err
+	}
+
+	scratch := make([]byte, 9)
+
+	// t.Value (string) (string)
+	if len(t.Value) > cbg.MaxLength {
+		return xerrors.Errorf("Value in field t.Value was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len(t.Value))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string(t.Value)); err != nil {
+		return err
+	}
+
+	// t.Branch (chaos.MutateStateBranch) (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
+		}
+	}
+	return nil
+}
+
+func (t *MutateStateArgs) UnmarshalCBOR(r io.Reader) error {
+	*t = MutateStateArgs{}
+
+	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 != 2 {
+		return fmt.Errorf("cbor input had wrong number of fields")
+	}
+
+	// t.Value (string) (string)
+
+	{
+		sval, err := cbg.ReadStringBuf(br, scratch)
+		if err != nil {
+			return err
+		}
+
+		t.Value = string(sval)
+	}
+	// t.Branch (chaos.MutateStateBranch) (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 = MutateStateBranch(extraI)
+	}
+	return nil
+}
+
+var lengthBufAbortWithArgs = []byte{131}
+
+func (t *AbortWithArgs) MarshalCBOR(w io.Writer) error {
+	if t == nil {
+		_, err := w.Write(cbg.CborNull)
+		return err
+	}
+	if _, err := w.Write(lengthBufAbortWithArgs); err != nil {
+		return err
+	}
+
+	scratch := make([]byte, 9)
+
+	// t.Code (exitcode.ExitCode) (int64)
+	if t.Code >= 0 {
+		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.Code)); err != nil {
+			return err
+		}
+	} else {
+		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajNegativeInt, uint64(-t.Code-1)); err != nil {
+			return err
+		}
+	}
+
+	// t.Message (string) (string)
+	if len(t.Message) > cbg.MaxLength {
+		return xerrors.Errorf("Value in field t.Message was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len(t.Message))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string(t.Message)); err != nil {
+		return err
+	}
+
+	// t.Uncontrolled (bool) (bool)
+	if err := cbg.WriteBool(w, t.Uncontrolled); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (t *AbortWithArgs) UnmarshalCBOR(r io.Reader) error {
+	*t = AbortWithArgs{}
+
+	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.Code (exitcode.ExitCode) (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.Code = exitcode.ExitCode(extraI)
+	}
+	// t.Message (string) (string)
+
+	{
+		sval, err := cbg.ReadStringBuf(br, scratch)
+		if err != nil {
+			return err
+		}
+
+		t.Message = string(sval)
+	}
+	// t.Uncontrolled (bool) (bool)
+
+	maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
+	if err != nil {
+		return err
+	}
+	if maj != cbg.MajOther {
+		return fmt.Errorf("booleans must be major type 7")
+	}
+	switch extra {
+	case 20:
+		t.Uncontrolled = false
+	case 21:
+		t.Uncontrolled = true
+	default:
+		return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
+	}
+	return nil
+}
+
+var lengthBufInspectRuntimeReturn = []byte{134}
+
+func (t *InspectRuntimeReturn) MarshalCBOR(w io.Writer) error {
+	if t == nil {
+		_, err := w.Write(cbg.CborNull)
+		return err
+	}
+	if _, err := w.Write(lengthBufInspectRuntimeReturn); err != nil {
+		return err
+	}
+
+	scratch := make([]byte, 9)
+
+	// t.Caller (address.Address) (struct)
+	if err := t.Caller.MarshalCBOR(w); err != nil {
+		return err
+	}
+
+	// t.Receiver (address.Address) (struct)
+	if err := t.Receiver.MarshalCBOR(w); err != nil {
+		return err
+	}
+
+	// t.ValueReceived (big.Int) (struct)
+	if err := t.ValueReceived.MarshalCBOR(w); err != nil {
+		return err
+	}
+
+	// t.CurrEpoch (abi.ChainEpoch) (int64)
+	if t.CurrEpoch >= 0 {
+		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.CurrEpoch)); err != nil {
+			return err
+		}
+	} else {
+		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajNegativeInt, uint64(-t.CurrEpoch-1)); err != nil {
+			return err
+		}
+	}
+
+	// t.CurrentBalance (big.Int) (struct)
+	if err := t.CurrentBalance.MarshalCBOR(w); err != nil {
+		return err
+	}
+
+	// t.State (chaos.State) (struct)
+	if err := t.State.MarshalCBOR(w); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (t *InspectRuntimeReturn) UnmarshalCBOR(r io.Reader) error {
+	*t = InspectRuntimeReturn{}
+
+	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 != 6 {
+		return fmt.Errorf("cbor input had wrong number of fields")
+	}
+
+	// t.Caller (address.Address) (struct)
+
+	{
+
+		if err := t.Caller.UnmarshalCBOR(br); err != nil {
+			return xerrors.Errorf("unmarshaling t.Caller: %w", err)
+		}
+
+	}
+	// t.Receiver (address.Address) (struct)
+
+	{
+
+		if err := t.Receiver.UnmarshalCBOR(br); err != nil {
+			return xerrors.Errorf("unmarshaling t.Receiver: %w", err)
+		}
+
+	}
+	// t.ValueReceived (big.Int) (struct)
+
+	{
+
+		if err := t.ValueReceived.UnmarshalCBOR(br); err != nil {
+			return xerrors.Errorf("unmarshaling t.ValueReceived: %w", err)
+		}
+
+	}
+	// t.CurrEpoch (abi.ChainEpoch) (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.CurrEpoch = abi.ChainEpoch(extraI)
+	}
+	// t.CurrentBalance (big.Int) (struct)
+
+	{
+
+		if err := t.CurrentBalance.UnmarshalCBOR(br); err != nil {
+			return xerrors.Errorf("unmarshaling t.CurrentBalance: %w", err)
+		}
+
+	}
+	// t.State (chaos.State) (struct)
+
+	{
+
+		if err := t.State.UnmarshalCBOR(br); err != nil {
+			return xerrors.Errorf("unmarshaling t.State: %w", err)
+		}
+
+	}
+	return nil
+}
--- a/Show More
+++ b/Show More