solve merage problem

2020-11-22 16:15:30 +08:00 · 2020-11-22 16:15:30 +08:00 · b6893b0a3f
commit b6893b0a3f
parent 1a7aea1906 375b7a1c4c
511 changed files with 44427 additions and 12265 deletions
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@ -5,7 +5,7 @@ orbs:
 executors:
  golang:
    docker:
-      - image: circleci/golang:1.14.6
+      - image: circleci/golang:1.15.5
    resource_class: 2xlarge
  ubuntu:
    docker:
@ -34,7 +34,7 @@ commands:
          condition: << parameters.linux >>
          steps:
            - run: sudo apt-get update
-            - run: sudo apt-get install ocl-icd-opencl-dev
+            - run: sudo apt-get install ocl-icd-opencl-dev libhwloc-dev
      - run: git submodule sync
      - run: git submodule update --init
  download-params:
@ -188,6 +188,14 @@ jobs:
                command: |
                  bash <(curl -s https://codecov.io/bash)
  test-chain:
    <<: *test
  test-node:
    <<: *test
  test-storage:
    <<: *test
  test-cli:
    <<: *test
  test-short:
    <<: *test
  test-window-post:
@ -268,7 +276,7 @@ jobs:
      - 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
+          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=../../blst
      - run:
          name: "build lotus-soup testplan"
          command: pushd extern/oni/lotus-soup && go build -tags=testground .
@ -286,8 +294,8 @@ jobs:
      - run:
          name: Install go
          command: |
-            curl -O https://dl.google.com/go/go1.14.2.darwin-amd64.pkg && \
+            curl -O https://dl.google.com/go/go1.15.5.darwin-amd64.pkg && \
-            sudo installer -pkg go1.14.2.darwin-amd64.pkg -target /
+            sudo installer -pkg go1.15.5.darwin-amd64.pkg -target /
      - run:
          name: Install pkg-config
          command: HOMEBREW_NO_AUTO_UPDATE=1 brew install pkg-config
@ -351,6 +359,7 @@ jobs:
    steps:
      - install-deps
      - prepare
      - run: make deps
      - run: make docsgen
      - run: git --no-pager diff
      - run: git --no-pager diff --quiet
@ -428,6 +437,22 @@ workflows:
      - test:
          codecov-upload: true
          test-suite-name: full
      - test-chain:
          codecov-upload: true
          test-suite-name: chain
          packages: "./chain/..."
      - test-node:
          codecov-upload: true
          test-suite-name: node
          packages: "./node/..."
      - test-storage:
          codecov-upload: true
          test-suite-name: storage
          packages: "./storage/... ./extern/..."
      - test-cli:
          codecov-upload: true
          test-suite-name: cli
          packages: "./cli/... ./cmd/... ./api/..."
      - test-window-post:
          go-test-flags: "-run=TestWindowedPost"
          winpost-test: "1"
--- a/.codecov.yml
+++ b/.codecov.yml
@ -1,5 +1,9 @@
 comment: off
 ignore:
-  - "cbor_gen.go"
+  - "**/cbor_gen.go"
  - "api/test/**/*"
  - "api/test/*"
  - "gen/**/*"
  - "gen/*"
 github_checks:
  annotations: false
--- a/.github/CODEOWNERS
+++ b/.github/CODEOWNERS
@ -13,3 +13,4 @@
 ### Conformance testing.
 conformance/            @raulk
 extern/test-vectors     @raulk
 cmd/tvx                 @raulk
--- a/.gitignore
+++ b/.gitignore
@ -12,6 +12,7 @@
 /lotus-bench
 /lotus-gateway
 /lotus-pcr
 /lotus-wallet
 /bench.json
 /lotuspond/front/node_modules
 /lotuspond/front/build
--- a/.gitmodules
+++ b/.gitmodules
@ -1,16 +1,15 @@
 [submodule "extern/filecoin-ffi"]
 	path = extern/filecoin-ffi
 	url = https://github.com/filecoin-project/filecoin-ffi.git
 	branch = master
 [submodule "extern/serialization-vectors"]
 	path = extern/serialization-vectors
-	url = https://github.com/filecoin-project/serialization-vectors
+	url = https://github.com/filecoin-project/serialization-vectors.git
 [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
+	url = https://github.com/filecoin-project/oni.git
 [submodule "extern/blst"]
 	path = extern/blst
 	url = https://github.com/supranational/blst.git
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -1,5 +1,574 @@
 # Lotus changelog
 # 1.2.1 / 2020-11-20
 This is a very small release of Lotus that fixes an issue users are experiencing when importing snapshots. There is no need to upgrade unless you experience an issue with creating a new `datastore` directory in the Lotus repo.
 ## Changes
 - fix blockstore directory not created automatically (https://github.com/filecoin-project/lotus/pull/4922)
 - WindowPoStScheduler.checkSectors() delete useless judgment (https://github.com/filecoin-project/lotus/pull/4918)
 # 1.2.0 / 2020-11-18
 This is a mandatory release of Lotus that introduces the second post-liftoff upgrade to the Filecoin network. The network upgrade occurs at height 265200, before which time all nodes must have update to this release (or later). This release also bumps the required version of Go to 1.15.
 The changes that break consensus are:
 - Upgrading to sepcs-actors 2.3.2 (https://github.com/filecoin-project/specs-actors/releases/tag/v2.3.2)
 - Introducing proofs v5.4.0 (https://github.com/filecoin-project/rust-fil-proofs/releases/tag/storage-proofs-v5.4.0), and switching between the proof types (https://github.com/filecoin-project/lotus/pull/4873)
 - Don't use terminated sectors for winning PoSt (https://github.com/filecoin-project/lotus/pull/4770)
 - Various small VM-level edge-case handling (https://github.com/filecoin-project/lotus/pull/4783)
 - Correction of the VM circulating supply calculation (https://github.com/filecoin-project/lotus/pull/4862)
 - Retuning gas costs (https://github.com/filecoin-project/lotus/pull/4830)
 - Avoid sending messages to the zero BLS address (https://github.com/filecoin-project/lotus/pull/4888)
 ## Other Changes
 - delayed pubsub subscribe for messages topic (https://github.com/filecoin-project/lotus/pull/3646)
 - add chain base64 decode params (https://github.com/filecoin-project/lotus/pull/4748)
 - chore(dep): update bitswap to fix an initialization race that could panic (https://github.com/filecoin-project/lotus/pull/4855)
 - Chore/blockstore nits (https://github.com/filecoin-project/lotus/pull/4813)
 - Print Consensus Faults in miner info (https://github.com/filecoin-project/lotus/pull/4853)
 - Truncate genesis file before generating (https://github.com/filecoin-project/lotus/pull/4851)
 - miner: Winning PoSt Warmup (https://github.com/filecoin-project/lotus/pull/4824)
 - Fix init actor address map diffing (https://github.com/filecoin-project/lotus/pull/4875)
 - Bump API versions to 1.0.0 (https://github.com/filecoin-project/lotus/pull/4884)
 - Fix cid recording issue (https://github.com/filecoin-project/lotus/pull/4874)
 - Speed up worker key retrieval (https://github.com/filecoin-project/lotus/pull/4885)
 - Add error codes to worker return (https://github.com/filecoin-project/lotus/pull/4890)
 - Update go to 1.15.5 (https://github.com/filecoin-project/lotus/pull/4896)
 - Fix MaxSealingSectrosForDeals getting reset to 0 (https://github.com/filecoin-project/lotus/pull/4879)
 - add sanity check for maximum block size (https://github.com/filecoin-project/lotus/pull/3171)
 - Check (pre)commit receipt before other checks in failed states (https://github.com/filecoin-project/lotus/pull/4712)
 - fix badger double open on daemon --import-snapshot; chainstore lifecycle (https://github.com/filecoin-project/lotus/pull/4872)
 - Update to ipfs-blockstore 1.0.3 (https://github.com/filecoin-project/lotus/pull/4897)
 - break loop when found warm up sector (https://github.com/filecoin-project/lotus/pull/4869)
 - Tweak handling of bad beneficaries in DeleteActor (https://github.com/filecoin-project/lotus/pull/4903)
 - cap maximum number of messages per block in selection (https://github.com/filecoin-project/lotus/pull/4905)
 - Set Calico epoch (https://github.com/filecoin-project/lotus/pull/4889)
 # 1.1.3 / 2020-11-13
 This is an optional release of Lotus that upgrades Lotus dependencies, and includes many performance enhancements, bugfixes, and UX improvements.
 ## Highlights
 - Refactored much of the miner code (https://github.com/filecoin-project/lotus/pull/3618), improving its recovery from restarts and overall sector success rate
 - Updated [proofs](https://github.com/filecoin-project/rust-fil-proofs) to v5.3.0, which brings significant performance improvements
 - Updated [markets](https://github.com/filecoin-project/go-fil-markets/releases/tag/v1.0.4) to v1.0.4, which reduces failures due to reorgs (https://github.com/filecoin-project/lotus/pull/4730) and uses the newly refactored fund manager (https://github.com/filecoin-project/lotus/pull/4736)
 ## Changes
 #### Core Lotus
 - polish: add Equals method to MinerInfo shim (https://github.com/filecoin-project/lotus/pull/4604)
 - Fix messagepool accounting (https://github.com/filecoin-project/lotus/pull/4668)
 - Prep for gas balancing (https://github.com/filecoin-project/lotus/pull/4651)
 - Reduce badger ValueThreshold to 128 (https://github.com/filecoin-project/lotus/pull/4629)
 - Config for default max gas fee (https://github.com/filecoin-project/lotus/pull/4652)
 - bootstrap: don't return early when one drand resolution fails (https://github.com/filecoin-project/lotus/pull/4626)
 - polish: add ClaimsChanged and DiffClaims method to power shim (https://github.com/filecoin-project/lotus/pull/4628)
 - Simplify chain event Called API (https://github.com/filecoin-project/lotus/pull/4664)
 - Cache deal states for most recent old/new tipset (https://github.com/filecoin-project/lotus/pull/4623)
 - Add miner available balance and power info to state miner info (https://github.com/filecoin-project/lotus/pull/4618)
 - Call GetHeaviestTipSet() only once when syncing (https://github.com/filecoin-project/lotus/pull/4696)
 - modify runtime gasUsed printf (https://github.com/filecoin-project/lotus/pull/4704)
 - Rename builtin actor generators (https://github.com/filecoin-project/lotus/pull/4697)
 - Move gas multiplier as property of pricelist (https://github.com/filecoin-project/lotus/pull/4728)
 - polish: add msig pendingtxn diffing and comp (https://github.com/filecoin-project/lotus/pull/4719)
 - Optional chain Bitswap (https://github.com/filecoin-project/lotus/pull/4717)
 - rewrite sync manager (https://github.com/filecoin-project/lotus/pull/4599)
 - async connect to bootstrappers (https://github.com/filecoin-project/lotus/pull/4785)
 - head change coalescer (https://github.com/filecoin-project/lotus/pull/4688)
 - move to native badger blockstore; leverage zero-copy View() to deserialize in-place (https://github.com/filecoin-project/lotus/pull/4681)
 - badger blockstore: minor improvements (https://github.com/filecoin-project/lotus/pull/4811)
 - Do not fail wallet delete because of pre-existing trashed key (https://github.com/filecoin-project/lotus/pull/4589)
 - Correctly delete the default wallet address (https://github.com/filecoin-project/lotus/pull/4705)
 - Reduce badger ValueTreshold to 128 (https://github.com/filecoin-project/lotus/pull/4629)
 - predicates: Fast StateGetActor wrapper (https://github.com/filecoin-project/lotus/pull/4835)
 #### Mining
 - worker key should change when set sender found key not equal with the value on chain (https://github.com/filecoin-project/lotus/pull/4595)
 - extern/sector-storage: fix GPU usage overwrite bug (https://github.com/filecoin-project/lotus/pull/4627)
 - sectorstorage: Fix manager restart edge-case (https://github.com/filecoin-project/lotus/pull/4645)
 - storagefsm: Fix GetTicket loop when the sector is already precommitted (https://github.com/filecoin-project/lotus/pull/4643)
 - Debug flag to force running sealing scheduler (https://github.com/filecoin-project/lotus/pull/4662)
 - Fix worker reenabling, handle multiple restarts in worker (https://github.com/filecoin-project/lotus/pull/4666)
 - keep retrying the proof until we run out of sectors to skip (https://github.com/filecoin-project/lotus/pull/4633)
 - worker: Commands to pause/resume task processing (https://github.com/filecoin-project/lotus/pull/4615)
 - struct name incorrect (https://github.com/filecoin-project/lotus/pull/4699)
 - optimize code replace strings with constants (https://github.com/filecoin-project/lotus/pull/4769)
 - optimize pledge sector (https://github.com/filecoin-project/lotus/pull/4765)
 - Track sealing processes across lotus-miner restarts (https://github.com/filecoin-project/lotus/pull/3618)
 - Fix scheduler lockups after storage is freed (https://github.com/filecoin-project/lotus/pull/4778)
 - storage: Track worker hostnames with work (https://github.com/filecoin-project/lotus/pull/4779)
 - Expand sched-diag; Command to abort sealing calls (https://github.com/filecoin-project/lotus/pull/4804)
 - miner: Winning PoSt Warmup (https://github.com/filecoin-project/lotus/pull/4824)
 - docsgen: Support miner/worker (https://github.com/filecoin-project/lotus/pull/4817)
 - miner: Basic storage cleanup command (https://github.com/filecoin-project/lotus/pull/4834)
 #### Markets and Data Transfer
 - Flesh out data transfer features (https://github.com/filecoin-project/lotus/pull/4572)
 - Fix memory leaks in data transfer (https://github.com/filecoin-project/lotus/pull/4619)
 - Handle deal id changes in OnDealSectorCommitted (https://github.com/filecoin-project/lotus/pull/4730)
 - Refactor FundManager (https://github.com/filecoin-project/lotus/pull/4736)
 - refactor: integrate new FundManager (https://github.com/filecoin-project/lotus/pull/4787)
 - Fix race in paych manager when req context is cancelled (https://github.com/filecoin-project/lotus/pull/4803)
 - fix race in paych manager add funds (https://github.com/filecoin-project/lotus/pull/4597)
 - Fix panic in FundManager (https://github.com/filecoin-project/lotus/pull/4808)
 - Fix: dont crash on startup if funds migration fails (https://github.com/filecoin-project/lotus/pull/4827)
 #### UX
 - Make EarlyExpiration in sectors list less scary (https://github.com/filecoin-project/lotus/pull/4600)
 - Add commands to change the worker key (https://github.com/filecoin-project/lotus/pull/4513)
 - Expose ClientDealSize via CLI (https://github.com/filecoin-project/lotus/pull/4569)
 - client deal: Cache CommD when creating multiple deals (https://github.com/filecoin-project/lotus/pull/4535)
 - miner sectors list: flags for events/seal time (https://github.com/filecoin-project/lotus/pull/4649)
 - make IPFS online mode configurable (https://github.com/filecoin-project/lotus/pull/4650)
 - Add sync status to miner info command (https://github.com/filecoin-project/lotus/pull/4669)
 - Add a StateDecodeParams method (https://github.com/filecoin-project/lotus/pull/4105)
 - sched: Interactive RPC Shell (https://github.com/filecoin-project/lotus/pull/4692)
 - Add api for getting status given a code (https://github.com/filecoin-project/lotus/pull/4210)
 - Update lotus-stats with a richer cli (https://github.com/filecoin-project/lotus/pull/4718)
 - Use TSK passed to GasEstimateGasLimit (https://github.com/filecoin-project/lotus/pull/4739)
 - match data type for reward state api (https://github.com/filecoin-project/lotus/pull/4745)
 - Add `termination-estimate` to get an estimation for how much a termination penalty will be (https://github.com/filecoin-project/lotus/pull/4617)
 - Restrict `ParseFIL` input length (https://github.com/filecoin-project/lotus/pull/4780)
 - cmd sectors commitIDs len debug (https://github.com/filecoin-project/lotus/pull/4786)
 - Add client deal-stats CLI (https://github.com/filecoin-project/lotus/pull/4788)
 - Modify printf format (https://github.com/filecoin-project/lotus/pull/4795)
 - Updated msig inspect (https://github.com/filecoin-project/lotus/pull/4533)
 - Delete the duplicate output (https://github.com/filecoin-project/lotus/pull/4819)
 - miner: Storage list sectors command (https://github.com/filecoin-project/lotus/pull/4831)
 - drop a few logs down to debug (https://github.com/filecoin-project/lotus/pull/4832)
 #### Testing and Tooling
 - refactor: share code between CLI tests (https://github.com/filecoin-project/lotus/pull/4598)
 - Fix flaky TestCLIDealFlow (https://github.com/filecoin-project/lotus/pull/4608)
 - Fix flaky testMiningReal (https://github.com/filecoin-project/lotus/pull/4609)
 - Add election run-dummy command (https://github.com/filecoin-project/lotus/pull/4498)
 - Fix .gitmodules (https://github.com/filecoin-project/lotus/pull/4713)
 - fix metrics wiring.(https://github.com/filecoin-project/lotus/pull/4691)
 - shed: Util for creating ID CIDs (https://github.com/filecoin-project/lotus/pull/4726)
 - Run kumquat upgrade on devnets (https://github.com/filecoin-project/lotus/pull/4734)
 - Make pond work again (https://github.com/filecoin-project/lotus/pull/4775)
 - lotus-stats: fix influx flags (https://github.com/filecoin-project/lotus/pull/4810)
 - 2k sync BootstrapPeerThreshold (https://github.com/filecoin-project/lotus/pull/4797)
 - test for FundManager panic to ensure it is fixed (https://github.com/filecoin-project/lotus/pull/4825)
 - Stop mining at the end of tests (https://github.com/filecoin-project/lotus/pull/4826)
 - Make some logs quieter (https://github.com/filecoin-project/lotus/pull/4709)
 #### Dependencies
 - update filecoin-ffi in go mod (https://github.com/filecoin-project/lotus/pull/4584)
 - Update FFI (https://github.com/filecoin-project/lotus/pull/4613)
 - feat: integrate new optional blst backend and verification optimizations from proofs (https://github.com/filecoin-project/lotus/pull/4630)
 - Use https for blst submodule (https://github.com/filecoin-project/lotus/pull/4710)
 - Update go-bitfield (https://github.com/filecoin-project/lotus/pull/4756)
 - Update Yamux (https://github.com/filecoin-project/lotus/pull/4758)
 - Update to latest go-bitfield (https://github.com/filecoin-project/lotus/pull/4793)
 - Update to latest go-address (https://github.com/filecoin-project/lotus/pull/4798)
 - update libp2p for stream interface changes (https://github.com/filecoin-project/lotus/pull/4814)
 # 1.1.2 / 2020-10-24
 This is a patch release of Lotus that builds on the fixes involving worker keys that was introduced in v1.1.1. Miners and node operators should update to this release as soon as possible in order to ensure their blocks are propagated and validated.
 ## Changes 
 - Handle worker key changes correctly in runtime (https://github.com/filecoin-project/lotus/pull/4579)
 # 1.1.1 / 2020-10-24
 This is a patch release of Lotus that addresses some issues caused by when miners change their worker keys. Miners and node operators should update to this release as soon as possible, especially any miner who has changed their worker key recently.
 ## Changes
 - Miner finder for interactive client deal CLI (https://github.com/filecoin-project/lotus/pull/4504)
 - Disable blockstore bloom filter (https://github.com/filecoin-project/lotus/pull/4512)
 - Add api for getting status given a code (https://github.com/filecoin-project/lotus/pull/4210)
 - add batch api for push messages (https://github.com/filecoin-project/lotus/pull/4236)
 - add measure datastore wrapper around bench chain datastore (https://github.com/filecoin-project/lotus/pull/4302)
 - Look at block base fee for PCR (https://github.com/filecoin-project/lotus/pull/4313)
 - Add a shed util to determine % of power that has won a block (https://github.com/filecoin-project/lotus/pull/4318)
 - Shed/borked cmd (https://github.com/filecoin-project/lotus/pull/4339)
 - optimize mining code (https://github.com/filecoin-project/lotus/pull/4379)
 - heaviestTipSet reurning nil is a ok (https://github.com/filecoin-project/lotus/pull/4523)
 - Remove most v0 actor imports (https://github.com/filecoin-project/lotus/pull/4383)
 - Small chain export optimization (https://github.com/filecoin-project/lotus/pull/4536)
 - Add block list to pcr (https://github.com/filecoin-project/lotus/pull/4314)
 - Fix circ supply default in conformance (https://github.com/filecoin-project/lotus/pull/4449)
 - miner: fix init --create-worker-key (https://github.com/filecoin-project/lotus/pull/4475)
 - make push and addLocal atomic (https://github.com/filecoin-project/lotus/pull/4500)
 - add some methods that oni needs (https://github.com/filecoin-project/lotus/pull/4501)
 - MinerGetBaseInfo: if miner is not found in lookback, check current (https://github.com/filecoin-project/lotus/pull/4508)
 - Delete wallet from local wallet cache (https://github.com/filecoin-project/lotus/pull/4526)
 - Fix lotus-shed ledger list (https://github.com/filecoin-project/lotus/pull/4521)
 - Manage sectors by size instead of proof type (https://github.com/filecoin-project/lotus/pull/4511)
 - Feat/api request metrics wrapper (https://github.com/filecoin-project/lotus/pull/4516)
 - Fix chain sync stopping to sync (https://github.com/filecoin-project/lotus/pull/4541)
 - Use the correct lookback for the worker key when creating blocks (https://github.com/filecoin-project/lotus/pull/4539)
 - Cleanup test initialization and always validate VRFs in tests (https://github.com/filecoin-project/lotus/pull/4538)
 - Add a market WithdrawBalance CLI (https://github.com/filecoin-project/lotus/pull/4524)
 - wallet list: Add market balance and ID address flags (https://github.com/filecoin-project/lotus/pull/4555)
 - tvx simulate command; tvx extract --ignore-sanity-checks (https://github.com/filecoin-project/lotus/pull/4554)
 - lotus-lite: CLI tests for `lotus client` commands (https://github.com/filecoin-project/lotus/pull/4497)
 - lite-mode - market storage and retrieval clients (https://github.com/filecoin-project/lotus/pull/4263)
 - Chore: update drand to v1.2.0 (https://github.com/filecoin-project/lotus/pull/4420)
 - Fix random test failures (https://github.com/filecoin-project/lotus/pull/4559)
 - Fix flaky TestTimedBSSimple (https://github.com/filecoin-project/lotus/pull/4561)
 - Make wallet market withdraw usable with miner addresses (https://github.com/filecoin-project/lotus/pull/4556)
 - Fix flaky TestChainExportImportFull (https://github.com/filecoin-project/lotus/pull/4564)
 - Use older randomness for the PoSt commit on specs-actors version 2 (https://github.com/filecoin-project/lotus/pull/4563)
 - shed: Commad to decode messages (https://github.com/filecoin-project/lotus/pull/4565)
 - Fetch worker key from correct block on sync (https://github.com/filecoin-project/lotus/pull/4573)
 # 1.1.0 / 2020-10-20
 This is a mandatory release that introduces the first post-liftoff upgrade to the Filecoin network. The changes that break consensus are an upgrade to specs-actors v2.2.0 at epoch 170000.
 ## Changes
 - Introduce Network version 6 (https://github.com/filecoin-project/lotus/pull/4506)
 - Update markets v1.0.0 (https://github.com/filecoin-project/lotus/pull/4505)
 - Add some extra logging to try and debug sync issues (https://github.com/filecoin-project/lotus/pull/4486)
 - Circle: Run tests for some subsystems separately (https://github.com/filecoin-project/lotus/pull/4496)
 - Add a terminate sectors command to lotus-shed (https://github.com/filecoin-project/lotus/pull/4507)
 - Add a comment to BlockMessages to address #4446 (https://github.com/filecoin-project/lotus/pull/4491)
 # 1.0.0 / 2020-10-19
 It's 1.0.0! This is an optional release of Lotus that introduces some UX improvements to the 0.10 series.
 This very small release is largely cosmetic, and intended to flag the code that the Filecoin mainnet was launched with.
 ## API changes
 - `StateMsgGasCost` has been removed. The equivalent information can be gained by calling `StateReplay`.
 - A `GasCost` field has been added to the `InvocResult` type, meaning detailed gas costs will be returned when calling `StateReplay`, `StateCompute`, and `StateCall`.
 - The behaviour of `StateReplay` in response to an empty tipset key has been changed. Instead of simply using the heaviest tipset (which is almost guaranteed to be an unsuccessful replay), we search now search the chain for the tipset that included the message, and replay the message in that tipset (we fail if no such tipset is found).
 ## Changes
 - Increase code coverage! (https://github.com/filecoin-project/lotus/pull/4410)
 - Mpool: Don't block node startup loading messages (https://github.com/filecoin-project/lotus/pull/4411)
 - Improve the UX of multisig approves (https://github.com/filecoin-project/lotus/pull/4398)
 - Use build.BlockDelaySecs for deal start buffer (https://github.com/filecoin-project/lotus/pull/4415)
 - Conformance: support multiple protocol versions (https://github.com/filecoin-project/lotus/pull/4393)
 - Ensure msig inspect cli works with lotus-lite (https://github.com/filecoin-project/lotus/pull/4421)
 - Add command to (slowly) prune lotus chain datastore (https://github.com/filecoin-project/lotus/pull/3876)
 - Add WalletVerify to lotus-gateway (https://github.com/filecoin-project/lotus/pull/4373)
 - Improve StateMsg APIs (https://github.com/filecoin-project/lotus/pull/4429)
 - Add endpoints needed by spacegap (https://github.com/filecoin-project/lotus/pull/4426)
 - Make audit balances capable of printing robust addresses (https://github.com/filecoin-project/lotus/pull/4423)
 - Custom filters for retrieval deals (https://github.com/filecoin-project/lotus/pull/4424)
 - Fix message list api (https://github.com/filecoin-project/lotus/pull/4422)
 - Replace bootstrap peers (https://github.com/filecoin-project/lotus/pull/4447)
 - Don't overwrite previously-configured maxPieceSize for a persisted ask (https://github.com/filecoin-project/lotus/pull/4480)
 - State: optimize state snapshot address cache (https://github.com/filecoin-project/lotus/pull/4481)
 # 0.10.2 / 2020-10-14
 This is an optional release of Lotus that updates markets to 0.9.1, which fixes an issue affecting deals that were mid-transfer when the node was upgraded to 0.9.0. This release also includes some tweaks to default gas values and minor performance improvements.
 ## Changes
 - Use updated stored ask API (https://github.com/filecoin-project/lotus/pull/4384)
 - tvx: trace puts to blockstore for inclusion in CAR. (https://github.com/filecoin-project/lotus/pull/4278)
 - Add propose remove (https://github.com/filecoin-project/lotus/pull/4311)
 - Update to 0.9.1 bugfix release (https://github.com/filecoin-project/lotus/pull/4402)
 - Update drand endpoints (https://github.com/filecoin-project/lotus/pull/4125)
 - fix: return true when deadlines changed (https://github.com/filecoin-project/lotus/pull/4403)
 - sync wait --watch (https://github.com/filecoin-project/lotus/pull/4396)
 - reduce garbage in blockstore (https://github.com/filecoin-project/lotus/pull/4406)
 - give the TimeCacheBS tests a bit more time (https://github.com/filecoin-project/lotus/pull/4407)
 - Improve gas defaults (https://github.com/filecoin-project/lotus/pull/4408)
 - Change default gas premium to for 10 block inclusion (https://github.com/filecoin-project/lotus/pull/4222)
 # 0.10.1 / 2020-10-14
 This is an optional release of Lotus that updates markets to 0.9.0, which adds the ability to restart data transfers. This release also introduces Ledger support, and various UX improvements.
 ## Changes
 - Test the tape upgrade (https://github.com/filecoin-project/lotus/pull/4328)
 - Adding in Ledger support (https://github.com/filecoin-project/lotus/pull/4290)
 - Improve the UX for lotus-miner sealing workers (https://github.com/filecoin-project/lotus/pull/4329)
 - Add a CLI tool for miner's to repay debt (https://github.com/filecoin-project/lotus/pull/4319)
 - Rename params_testnet to params_mainnet (https://github.com/filecoin-project/lotus/pull/4336)
 - Use seal-duration in calculating the earliest StartEpoch (https://github.com/filecoin-project/lotus/pull/4337)
 - Reject deals that are > 7 days in the future in the BasicDealFilter (https://github.com/filecoin-project/lotus/pull/4173)
 - Add an API endpoint to calculate the exact circulating supply (https://github.com/filecoin-project/lotus/pull/4148)
 - lotus-pcr: ignore all other market messages (https://github.com/filecoin-project/lotus/pull/4341)
 - Add message CID to InvocResult (https://github.com/filecoin-project/lotus/pull/4382)
 - types: Add CID fields to messages in json marshalers (https://github.com/filecoin-project/lotus/pull/4338)
 - fix(sync state): set state height to actual tipset height (https://github.com/filecoin-project/lotus/pull/4347)
 - Fix off by one tipset in searchBackForMsg (https://github.com/filecoin-project/lotus/pull/4367)
 - fix a panic on startup when we fail to load the tipset (https://github.com/filecoin-project/lotus/pull/4376)
 - Avoid having the same message CID show up in execution traces (https://github.com/filecoin-project/lotus/pull/4350)
 - feat(markets): update markets 0.9.0 and add data transfer restart (https://github.com/filecoin-project/lotus/pull/4363)
 # 0.10.0 / 2020-10-12
 This is a consensus-breaking hotfix that addresses an issue in specs-actors v2.0.3 that made it impossible to pledge new 32GiB sectors. The change in Lotus is to update to actors v2.1.0, behind the new network version 5.
 ## Changes
 - make pledge test pass with the race detector (https://github.com/filecoin-project/lotus/pull/4291)
 - fix a race in tipset cache usage (https://github.com/filecoin-project/lotus/pull/4282)
 - add an api for removing multisig signers (https://github.com/filecoin-project/lotus/pull/4274)
 - cli: Don't output errors to stdout (https://github.com/filecoin-project/lotus/pull/4298)
 - Fix panic in wallet export when key is not found (https://github.com/filecoin-project/lotus/pull/4299)
 - Dump the block validation cache whenever we perform an import (https://github.com/filecoin-project/lotus/pull/4287)
 - Fix two races (https://github.com/filecoin-project/lotus/pull/4301)
 - sync unmark-bad --all (https://github.com/filecoin-project/lotus/pull/4296)
 - decode parameters for multisig transactions in inspect (https://github.com/filecoin-project/lotus/pull/4312)
 - Chain is love (https://github.com/filecoin-project/lotus/pull/4321)
 - lotus-stats: optmize getting miner power (https://github.com/filecoin-project/lotus/pull/4315)
 - implement tape upgrade (https://github.com/filecoin-project/lotus/pull/4322)
 # 0.9.1 / 2020-10-10
 This release fixes an issue which may cause the actors v2 migration to compute the state incorrectly when more than one migration is running in parallel.
 ## Changes
 - Make concurrent actor migrations safe (https://github.com/filecoin-project/lotus/pull/4293)
 - Remote wallet backends (https://github.com/filecoin-project/lotus/pull/3583)
 - Track funds in FundMgr correctly in case of AddFunds failing (https://github.com/filecoin-project/lotus/pull/4273)
 - Partial lite-node mode (https://github.com/filecoin-project/lotus/pull/4095)
 - Fix potential infinite loop in GetBestMiningCandidate (https://github.com/filecoin-project/lotus/pull/3444)
 - sync wait: Handle processed message offset (https://github.com/filecoin-project/lotus/pull/4253)
 - Add some new endpoints for querying Msig info (https://github.com/filecoin-project/lotus/pull/4250)
 - Update markets v0.7.1 (https://github.com/filecoin-project/lotus/pull/4254)
 - Optimize SearchForMessage and GetReceipt (https://github.com/filecoin-project/lotus/pull/4246)
 - Use FIL instead of attoFIL in CLI more consistently (https://github.com/filecoin-project/lotus/pull/4249)
 - fix: clash between daemon --api flag and cli tests (https://github.com/filecoin-project/lotus/pull/4241)
 - add more info to chain sync lookback failure (https://github.com/filecoin-project/lotus/pull/4245)
 - Add message counts to inspect chain output (https://github.com/filecoin-project/lotus/pull/4230)
 # 0.9.0 / 2020-10-07
 This consensus-breaking release of Lotus upgrades the actors version to v2.0.0. This requires migrating actor state from v0 to v2. The changes that break consensus are:
 - Introducing v2 actors and its migration (https://github.com/filecoin-project/lotus/pull/3936)
 - Runtime's Receiver() should only return ID addresses  (https://github.com/filecoin-project/lotus/pull/3589)
 - Update miner eligibility checks for v2 actors (https://github.com/filecoin-project/lotus/pull/4188)
 - Add funds that have left FilReserve to circ supply (https://github.com/filecoin-project/lotus/pull/4160)
 - Set WinningPoStSectorSetLookback to finality post-v2 actors (https://github.com/filecoin-project/lotus/pull/4190)
 - fix: error when actor panics directly (https://github.com/filecoin-project/lotus/pull/3697)
 ## Changes
 #### Dependencies
 - Update go-bitfield (https://github.com/filecoin-project/lotus/pull/4171)
 - update the AMT implementation (https://github.com/filecoin-project/lotus/pull/4194)
 - Update to actors v0.2.1 (https://github.com/filecoin-project/lotus/pull/4199)
 #### Core Lotus
 - Paych: fix voucher amount verification (https://github.com/filecoin-project/lotus/pull/3821)
 - Cap market provider messages (https://github.com/filecoin-project/lotus/pull/4141)
 - Run fork function after cron for null block safety (https://github.com/filecoin-project/lotus/pull/4114)
 - use bitswap sessions when fetching messages, and cancel them (https://github.com/filecoin-project/lotus/pull/4142)
 - relax pubsub IPColocationFactorThreshold to 5 (https://github.com/filecoin-project/lotus/pull/4183)
 - Support addresses with mainnet prefixes (https://github.com/filecoin-project/lotus/pull/4186)
 - fix: make message signer nonce generation transactional (https://github.com/filecoin-project/lotus/pull/4165)
 - build: Env var to keep test address output (https://github.com/filecoin-project/lotus/pull/4213)
 - make vm.EnableGasTracing public (https://github.com/filecoin-project/lotus/pull/4214)
 - introduce separate state-tree versions (https://github.com/filecoin-project/lotus/pull/4197)
 - reject explicit "calls" at the upgrade height (https://github.com/filecoin-project/lotus/pull/4231)
 - return an illegal actor error when we see an unsupported actor version (https://github.com/filecoin-project/lotus/pull/4232)
 - Set head should unmark blocks as valid (https://gist.github.com/travisperson/3c7cddd77a33979a519ccef4e6515f20)
 #### Mining
 - Increased ExpectedSealDuration and and WaitDealsDelay (https://github.com/filecoin-project/lotus/pull/3743)
 - Miner backup/restore commands (https://github.com/filecoin-project/lotus/pull/4133)
 - lotus-miner: add more help text to storage / attach (https://github.com/filecoin-project/lotus/pull/3961)
 - Reject deals that are > 7 days in the future in the BasicDealFilter (https://github.com/filecoin-project/lotus/pull/4173)
 - feat(miner): add miner deadline diffing logic (https://github.com/filecoin-project/lotus/pull/4178)
 #### UX
 - Improve the UX for replacing messages (https://github.com/filecoin-project/lotus/pull/4134)
 - Add verified flag to interactive deal creation (https://github.com/filecoin-project/lotus/pull/4145)
 - Add command to (slowly) prune lotus chain datastore (https://github.com/filecoin-project/lotus/pull/3876)
 - Some helpers for verifreg work (https://github.com/filecoin-project/lotus/pull/4124)
 - Always use default 720h for setask duration and hide the duration param option (https://github.com/filecoin-project/lotus/pull/4077)
 - Convert ID addresses to key addresses before checking wallet (https://github.com/filecoin-project/lotus/pull/4122)
 - add a command to view block space utilization (https://github.com/filecoin-project/lotus/pull/4176)
 - allow usage inspection on a chain segment (https://github.com/filecoin-project/lotus/pull/4177)
 - Add mpool stats for base fee (https://github.com/filecoin-project/lotus/pull/4170)
 - Add verified status to api.DealInfo (https://github.com/filecoin-project/lotus/pull/4153)
 - Add a CLI command to set a miner's owner address (https://github.com/filecoin-project/lotus/pull/4189)
 #### Tooling and validation
 - Lotus-pcr: add recover-miners command (https://github.com/filecoin-project/lotus/pull/3714)
 - MpoolPushUntrusted API for gateway (https://github.com/filecoin-project/lotus/pull/3915)
 - Test lotus-miner info all (https://github.com/filecoin-project/lotus/pull/4166)
 - chain export: Error with unfinished exports (https://github.com/filecoin-project/lotus/pull/4179)
 - add printf in TestWindowPost (https://github.com/filecoin-project/lotus/pull/4043)
 - add trace wdpost (https://github.com/filecoin-project/lotus/pull/4020)
 - Fix noncefix (https://github.com/filecoin-project/lotus/pull/4202)
 - Lotus-pcr: Limit the fee cap of messages we will process, refund gas fees for windowed post and storage deals (https://github.com/filecoin-project/lotus/pull/4198)
 - Fix pond (https://github.com/filecoin-project/lotus/pull/4203)
 - allow manual setting of noncefix fee cap (https://github.com/filecoin-project/lotus/pull/4205)
 - implement command to get execution traces of any message (https://github.com/filecoin-project/lotus/pull/4200)
 - conformance: minor driver refactors (https://github.com/filecoin-project/lotus/pull/4211) 
 - lotus-pcr: ignore all other messages (https://github.com/filecoin-project/lotus/pull/4218)
 - lotus-pcr: zero refund (https://github.com/filecoin-project/lotus/pull/4229)
 ## Contributors
 The following contributors had 5 or more commits go into this release.
 We are grateful for every contribution!
 | Contributor        | Commits | Lines ±       |
 |--------------------|---------|---------------|
 | Stebalien          | 84       | +3425/-2287  |
 | magik6k            | 41       | +2121/-506   |
 | arajasek           | 39       | +2467/-424   |
 | Kubuxu             | 25       | +2344/-775   |
 | raulk              | 21       | +287/-196    |
 | whyrusleeping      | 13       | +727/-71     |
 | hsanjuan           | 13       | +5886/-7956  |
 | dirkmc             | 11       | +2634/-576   | 
 | travisperson       | 8        | +923/-202    |
 | ribasushi          | 6        | +188/-128    |
 | zgfzgf             | 5        | +21/-17      |
 # 0.8.1 / 2020-09-30
 This optional release of Lotus introduces a new version of markets which switches to CBOR-map encodings, and allows datastore migrations. The release also introduces several improvements to the mining process, a few performance optimizations, and a battery of UX additions and enhancements.
 ## Changes 
 #### Dependencies
 - Markets 0.7.0 with updated data stores (https://github.com/filecoin-project/lotus/pull/4089)
 - Update ffi to code with blst fixes (https://github.com/filecoin-project/lotus/pull/3998)
 #### Core Lotus
 - Fix GetPower with no miner address (https://github.com/filecoin-project/lotus/pull/4049)
 - Refactor: Move nonce generation out of mpool (https://github.com/filecoin-project/lotus/pull/3970)
 #### Performance
 - Implement caching syscalls for import-bench (https://github.com/filecoin-project/lotus/pull/3888)
 - Fetch tipset blocks in parallel (https://github.com/filecoin-project/lotus/pull/4074)
 - Optimize Tipset equals() (https://github.com/filecoin-project/lotus/pull/4056)
 - Make state transition in validation async (https://github.com/filecoin-project/lotus/pull/3868)
 #### Mining
 - Add trace window post (https://github.com/filecoin-project/lotus/pull/4020)
 - Use abstract types for Dont recompute post on revert (https://github.com/filecoin-project/lotus/pull/4022)
 - Fix injectNulls logic in test miner (https://github.com/filecoin-project/lotus/pull/4058)
 - Fix potential panic in FinalizeSector (https://github.com/filecoin-project/lotus/pull/4092)
 - Don't recompute post on revert (https://github.com/filecoin-project/lotus/pull/3924)
 - Fix some failed precommit handling (https://github.com/filecoin-project/lotus/pull/3445)
 - Add --no-swap flag for worker (https://github.com/filecoin-project/lotus/pull/4107)
 - Allow some single-thread tasks to run in parallel with PC2/C2 (https://github.com/filecoin-project/lotus/pull/4116)
 #### UX
 - Add an envvar to set address network version (https://github.com/filecoin-project/lotus/pull/4028)
 - Add logging to chain export (https://github.com/filecoin-project/lotus/pull/4030)
 - Add JSON output to state compute (https://github.com/filecoin-project/lotus/pull/4038)
 - Wallet list CLI: Print balances/nonces (https://github.com/filecoin-project/lotus/pull/4088)
 - Added an option to show or not show sector info for `lotus-miner info` (https://github.com/filecoin-project/lotus/pull/4003)
 - Add a command to import an ipld object into the chainstore (https://github.com/filecoin-project/lotus/pull/3434)
 - Improve the lotus-shed dealtracker (https://github.com/filecoin-project/lotus/pull/4051)
 - Docs review and re-organization (https://github.com/filecoin-project/lotus/pull/3431)
 - Fix wallet list (https://github.com/filecoin-project/lotus/pull/4104)
 - Add an endpoint to validate whether a string is a well-formed address (https://github.com/filecoin-project/lotus/pull/4106)
 - Add an option to set config path (https://github.com/filecoin-project/lotus/pull/4103)
 - Add printf in TestWindowPost (https://github.com/filecoin-project/lotus/pull/4043)
 - Improve miner sectors list UX (https://github.com/filecoin-project/lotus/pull/4108)
 #### Tooling
 - Move policy change to seal bench (https://github.com/filecoin-project/lotus/pull/4032)
 - Add back network power to stats (https://github.com/filecoin-project/lotus/pull/4050)
 - Conformance: Record and feed circulating supply (https://github.com/filecoin-project/lotus/pull/4078)
 - Snapshot import progress bar, add HTTP support (https://github.com/filecoin-project/lotus/pull/4070)
 - Add lotus shed util to validate a tipset (https://github.com/filecoin-project/lotus/pull/4065)
 - tvx: a test vector extraction and execution tool (https://github.com/filecoin-project/lotus/pull/4064)
 #### Bootstrap
 - Add new bootstrappers (https://github.com/filecoin-project/lotus/pull/4007)
 - Add Glif node to bootstrap peers (https://github.com/filecoin-project/lotus/pull/4004)
 - Add one more node located in China (https://github.com/filecoin-project/lotus/pull/4041)
 - Add ipfsmain bootstrapper (https://github.com/filecoin-project/lotus/pull/4067)
 # 0.8.0 / 2020-09-26
 This consensus-breaking release of Lotus introduces an upgrade to the network. The changes that break consensus are:
 - Upgrading to specs-actors v0.9.11, which reduces WindowPoSt faults per [FIP 0002](https://github.com/filecoin-project/FIPs/blob/master/FIPS/fip-0002.md) to reduce cost for honest miners with occasional faults (see https://github.com/filecoin-project/specs-actors/pull/1181)
 - Revisions to some cryptoeconomics and network params
 This release also updates go-fil-markets to fix an incompatibility issue between v0.7.2 and earlier versions.
 ## Changes 
 #### Dependencies
 - Update spec actors to 0.9.11 (https://github.com/filecoin-project/lotus/pull/4039)
 - Update markets to 0.6.3 (https://github.com/filecoin-project/lotus/pull/4013)
 #### Core Lotus
 - Network upgrade (https://github.com/filecoin-project/lotus/pull/4039)
 - Fix AddSupportedProofTypes (https://github.com/filecoin-project/lotus/pull/4033)
 - Return an error when we fail to find a sector when checking sector expiration (https://github.com/filecoin-project/lotus/pull/4026)
 - Batch blockstore copies after block validation (https://github.com/filecoin-project/lotus/pull/3980)
 - Remove a misleading miner actor abstraction (https://github.com/filecoin-project/lotus/pull/3977)
 - Fix out-of-bounds when loading all sector infos (https://github.com/filecoin-project/lotus/pull/3976)
 - Fix break condition in the miner (https://github.com/filecoin-project/lotus/pull/3953)
 #### UX
 - Correct helptext around miners setting ask (https://github.com/filecoin-project/lotus/pull/4009)
 - Make sync wait nicer (https://github.com/filecoin-project/lotus/pull/3991)
 #### Tooling and validation
 - Small adjustments following network upgradability changes (https://github.com/filecoin-project/lotus/pull/3996)
 - Add some more big pictures stats to stateroot stat (https://github.com/filecoin-project/lotus/pull/3995)
 - Add some actors policy setters for testing (https://github.com/filecoin-project/lotus/pull/3975)
 ## Contributors
 The following contributors had 5 or more commits go into this release.
 We are grateful for every contribution!
 | Contributor        | Commits | Lines ±       |
 |--------------------|---------|---------------|
 | arajasek           | 66       | +3140/-1261  |
 | Stebalien          | 64       | +3797/-3434  |
 | magik6k            | 48       | +1892/-976   |
 | raulk              | 40       | +2412/-1549  |
 | vyzo               | 22       | +287/-196    |
 | alanshaw           | 15       | +761/-146    |
 | whyrusleeping      | 15       | +736/-52     |
 | hannahhoward       | 14       | +1237/-837   | 
 | anton              | 6        | +32/-8       |
 | travisperson       | 5        | +502/-6      |
 | Frank              | 5        | +78/-39      |
 | Jennifer           | 5        | +148/-41     |
 # 0.7.2 / 2020-09-23
 This optional release of Lotus introduces a major refactor around how a Lotus node interacts with code from the specs-actors repo. We now use interfaces to read the state of actors, which is required to be able to reason about different versions of actors code at the same time.
--- a/38
+++ b/38
@ -5,10 +5,10 @@ all: build
 unexport GOFLAGS
-GOVERSION:=$(shell go version | cut -d' ' -f 3 | cut -d. -f 2)
+GOVERSION:=$(shell go version | cut -d' ' -f 3 | sed 's/^go//' | awk -F. '{printf "%d%03d%03d", $$1, $$2, $$3}')
-ifeq ($(shell expr $(GOVERSION) \< 14), 1)
+ifeq ($(shell expr $(GOVERSION) \< 1015005), 1)
-$(warning Your Golang version is go 1.$(GOVERSION))
+$(warning Your Golang version is go$(shell expr $(GOVERSION) / 1000000).$(shell expr $(GOVERSION) % 1000000 / 1000).$(shell expr $(GOVERSION) % 1000))
-$(error Update Golang to version $(shell grep '^go' go.mod))
+$(error Update Golang to version to at least 1.15.5)
 endif
 # git modules that need to be loaded
@ -133,18 +133,30 @@ benchmarks:
 lotus-pond: 2k
 	go build -o lotus-pond ./lotuspond
 	(cd lotuspond/front && npm i && CI=false npm run build)
 .PHONY: lotus-pond
 BINS+=lotus-pond
 lotus-pond-front:
 	(cd lotuspond/front && npm i && CI=false npm run build)
 .PHONY: lotus-pond-front
 lotus-pond-app: lotus-pond-front lotus-pond
 .PHONY: lotus-pond-app
 lotus-townhall:
 	rm -f lotus-townhall
 	go build -o lotus-townhall ./cmd/lotus-townhall
 	(cd ./cmd/lotus-townhall/townhall && npm i && npm run build)
 	go run github.com/GeertJohan/go.rice/rice append --exec lotus-townhall -i ./cmd/lotus-townhall -i ./build
 .PHONY: lotus-townhall
 BINS+=lotus-townhall
 lotus-townhall-front:
 	(cd ./cmd/lotus-townhall/townhall && npm i && npm run build)
 .PHONY: lotus-townhall-front
 lotus-townhall-app: lotus-touch lotus-townhall-front
 	go run github.com/GeertJohan/go.rice/rice append --exec lotus-townhall -i ./cmd/lotus-townhall -i ./build
 .PHONY: lotus-townhall-app
 lotus-fountain:
 	rm -f lotus-fountain
 	go build -o lotus-fountain ./cmd/lotus-fountain
@ -167,7 +179,7 @@ BINS+=lotus-bench
 lotus-stats:
 	rm -f lotus-stats
-	go build -o lotus-stats ./cmd/lotus-stats
+	go build $(GOFLAGS) -o lotus-stats ./cmd/lotus-stats
 	go run github.com/GeertJohan/go.rice/rice append --exec lotus-stats -i ./build
 .PHONY: lotus-stats
 BINS+=lotus-stats
@ -186,6 +198,12 @@ lotus-health:
 .PHONY: lotus-health
 BINS+=lotus-health
 lotus-wallet:
 	rm -f lotus-wallet
 	go build -o lotus-wallet ./cmd/lotus-wallet
 .PHONY: lotus-wallet
 BINS+=lotus-wallet
 testground:
 	go build -tags testground -o /dev/null ./cmd/lotus
 .PHONY: testground
@ -286,7 +304,9 @@ method-gen:
 gen: type-gen method-gen
 docsgen:
-	go run ./api/docgen > documentation/en/api-methods.md
+	go run ./api/docgen "api/api_full.go" "FullNode" > documentation/en/api-methods.md
 	go run ./api/docgen "api/api_storage.go" "StorageMiner" > documentation/en/api-methods-miner.md
 	go run ./api/docgen "api/api_worker.go" "WorkerAPI" > documentation/en/api-methods-worker.md
 print-%:
 	@echo $*=$($*)
--- a/README.md
+++ b/README.md
@ -1,5 +1,5 @@
 <p align="center">
-  <a href="https://lotu.sh/" title="Lotus Docs">
+  <a href="https://docs.filecoin.io/" title="Filecoin Docs">
    <img src="documentation/images/lotus_logo_h.png" alt="Project Lotus Logo" width="244" />
  </a>
 </p>
@ -18,7 +18,7 @@ Lotus is an implementation of the Filecoin Distributed Storage Network. For more
 ## Building & Documentation
-For instructions on how to build lotus from source, please visit [Lotus build and setup instruction](https://docs.filecoin.io/get-started/lotus/installation/#minimal-requirements) or read the source [here](https://github.com/filecoin-project/lotus/tree/master/documentation).
+For instructions on how to build, install and setup lotus, please visit [https://docs.filecoin.io/get-started/lotus](https://docs.filecoin.io/get-started/lotus/).
 ## Reporting a Vulnerability
--- a/SECURITY.md
+++ b/SECURITY.md
@ -2,9 +2,7 @@
 ## Reporting a Vulnerability
-For *critical* bugs, please send an email to security@filecoin.org.
+For *critical* bugs, please consult our Security Policy and Responsible Disclosure Program information at https://github.com/filecoin-project/community/blob/master/SECURITY.md
 The bug reporting process differs between bugs that are critical and may crash the network, and others that are unlikely to cause problems if malicious parties know about it. For non-critical bugs, please simply file a GitHub [issue](https://github.com/filecoin-project/lotus/issues/new?template=bug_report.md). 
 Please try to provide a clear description of any bugs reported, along with how to reproduce the bug if possible. More detailed bug reports (especially those with a PoC included) will help us move forward much faster. Additionally, please avoid reporting bugs that already have open issues. Take a moment to search the issue list of the related GitHub repositories before writing up a new report.
@ -20,10 +18,6 @@ Here are some examples of bugs we would consider 'critical':
 This is not an exhaustive list, but should provide some idea of what we consider 'critical'.
-## Supported Versions
+## Reporting a non security bug
-* TODO: This should be defined and set up by Mainnet launch.
+For non-critical bugs, please simply file a GitHub [issue](https://github.com/filecoin-project/lotus/issues/new?template=bug_report.md). 
 | Version | Supported          |
 | ------- | ------------------ |
 | Testnet | :white_check_mark: |
--- a/api/api_common.go
+++ b/api/api_common.go
@ -4,6 +4,8 @@ import (
 	"context"
 	"fmt"
 	"github.com/google/uuid"
 	"github.com/filecoin-project/go-jsonrpc/auth"
 	metrics "github.com/libp2p/go-libp2p-core/metrics"
 	"github.com/libp2p/go-libp2p-core/network"
@ -44,6 +46,11 @@ type Common interface {
 	// usage and current rate per protocol
 	NetBandwidthStatsByProtocol(ctx context.Context) (map[protocol.ID]metrics.Stats, error)
 	// ConnectionGater API
 	NetBlockAdd(ctx context.Context, acl NetBlockList) error
 	NetBlockRemove(ctx context.Context, acl NetBlockList) error
 	NetBlockList(ctx context.Context) (NetBlockList, error)
 	// MethodGroup: Common
 	// ID returns peerID of libp2p node backing this API
@ -58,6 +65,9 @@ type Common interface {
 	// trigger graceful shutdown
 	Shutdown(context.Context) error
 	// Session returns a random UUID of api provider session
 	Session(context.Context) (uuid.UUID, error)
 	Closing(context.Context) (<-chan struct{}, error)
 }
--- a/api/api_full.go
+++ b/api/api_full.go
@ -5,6 +5,7 @@ import (
 	"fmt"
 	"time"
 	datatransfer "github.com/filecoin-project/go-data-transfer"
 	"github.com/filecoin-project/go-state-types/network"
 	"github.com/ipfs/go-cid"
@ -172,10 +173,16 @@ type FullNode interface {
 	// SyncUnmarkBad unmarks a blocks as bad, making it possible to be validated and synced again.
 	SyncUnmarkBad(ctx context.Context, bcid cid.Cid) error
 	// SyncUnmarkAllBad purges bad block cache, making it possible to sync to chains previously marked as bad
 	SyncUnmarkAllBad(ctx context.Context) 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)
 	// SyncValidateTipset indicates whether the provided tipset is valid or not
 	SyncValidateTipset(ctx context.Context, tsk types.TipSetKey) (bool, error)
 	// MethodGroup: Mpool
 	// The Mpool methods are for interacting with the message pool. The message pool
 	// manages all incoming and outgoing 'messages' going over the network.
@ -189,6 +196,9 @@ type FullNode interface {
 	// MpoolPush pushes a signed message to mempool.
 	MpoolPush(context.Context, *types.SignedMessage) (cid.Cid, error)
 	// MpoolPushUntrusted pushes a signed message to mempool from untrusted sources.
 	MpoolPushUntrusted(context.Context, *types.SignedMessage) (cid.Cid, error)
 	// MpoolPushMessage atomically assigns a nonce, signs, and pushes a message
 	// to mempool.
 	// maxFee is only used when GasFeeCap/GasPremium fields aren't specified
@ -197,6 +207,15 @@ type FullNode interface {
 	// based on current chain conditions
 	MpoolPushMessage(ctx context.Context, msg *types.Message, spec *MessageSendSpec) (*types.SignedMessage, error)
 	// MpoolBatchPush batch pushes a signed message to mempool.
 	MpoolBatchPush(context.Context, []*types.SignedMessage) ([]cid.Cid, error)
 	// MpoolBatchPushUntrusted batch pushes a signed message to mempool from untrusted sources.
 	MpoolBatchPushUntrusted(context.Context, []*types.SignedMessage) ([]cid.Cid, error)
 	// MpoolBatchPushMessage batch pushes a unsigned message to mempool.
 	MpoolBatchPushMessage(context.Context, []*types.Message, *MessageSendSpec) ([]*types.SignedMessage, error)
 	// MpoolGetNonce gets next nonce for the specified sender.
 	// Note that this method may not be atomic. Use MpoolPushMessage instead.
 	MpoolGetNonce(context.Context, address.Address) (uint64, error)
@ -220,7 +239,9 @@ type FullNode interface {
 	// MethodGroup: Wallet
 	// WalletNew creates a new address in the wallet with the given sigType.
-	WalletNew(context.Context, crypto.SigType) (address.Address, error)
+	// Available key types: bls, secp256k1, secp256k1-ledger
 	// Support for numerical types: 1 - secp256k1, 2 - BLS is deprecated
 	WalletNew(context.Context, types.KeyType) (address.Address, error)
 	// WalletHas indicates whether the given address is in the wallet.
 	WalletHas(context.Context, address.Address) (bool, error)
 	// WalletList lists all the addresses in the wallet.
@ -244,6 +265,8 @@ type FullNode interface {
 	WalletImport(context.Context, *types.KeyInfo) (address.Address, error)
 	// WalletDelete deletes an address from the wallet.
 	WalletDelete(context.Context, address.Address) error
 	// WalletValidateAddress validates whether a given string can be decoded as a well-formed address
 	WalletValidateAddress(context.Context, string) (address.Address, error)
 	// Other
@ -263,6 +286,8 @@ type FullNode interface {
 	ClientListDeals(ctx context.Context) ([]DealInfo, error)
 	// ClientGetDealUpdates returns the status of updated deals
 	ClientGetDealUpdates(ctx context.Context) (<-chan DealInfo, error)
 	// ClientGetDealStatus returns status given a code
 	ClientGetDealStatus(ctx context.Context, statusCode uint64) (string, error)
 	// ClientHasLocal indicates whether a certain CID is locally stored.
 	ClientHasLocal(ctx context.Context, root cid.Cid) (bool, error)
 	// ClientFindData identifies peers that have a certain file, and returns QueryOffers (one per peer).
@ -275,7 +300,9 @@ type FullNode interface {
 	// of status updates.
 	ClientRetrieveWithEvents(ctx context.Context, order RetrievalOrder, ref *FileRef) (<-chan marketevents.RetrievalEvent, error)
 	// ClientQueryAsk returns a signed StorageAsk from the specified miner.
-	ClientQueryAsk(ctx context.Context, p peer.ID, miner address.Address) (*storagemarket.SignedStorageAsk, error)
+	ClientQueryAsk(ctx context.Context, p peer.ID, miner address.Address) (*storagemarket.StorageAsk, error)
 	// ClientCalcCommP calculates the CommP and data size of the specified CID
 	ClientDealPieceCID(ctx context.Context, root cid.Cid) (DataCIDSize, error)
 	// ClientCalcCommP calculates the CommP for a specified file
 	ClientCalcCommP(ctx context.Context, inpath string) (*CommPRet, error)
 	// ClientGenCar generates a CAR file for the specified file.
@ -285,6 +312,10 @@ type FullNode interface {
 	// ClientListTransfers returns the status of all ongoing transfers of data
 	ClientListDataTransfers(ctx context.Context) ([]DataTransferChannel, error)
 	ClientDataTransferUpdates(ctx context.Context) (<-chan DataTransferChannel, error)
 	// ClientRestartDataTransfer attempts to restart a data transfer with the given transfer ID and other peer
 	ClientRestartDataTransfer(ctx context.Context, transferID datatransfer.TransferID, otherPeer peer.ID, isInitiator bool) error
 	// ClientCancelDataTransfer cancels a data transfer with the given transfer ID and other peer
 	ClientCancelDataTransfer(ctx context.Context, transferID datatransfer.TransferID, otherPeer peer.ID, isInitiator bool) error
 	// ClientRetrieveTryRestartInsufficientFunds attempts to restart stalled retrievals on a given payment channel
 	// which are stuck due to insufficient funds
 	ClientRetrieveTryRestartInsufficientFunds(ctx context.Context, paymentChannel address.Address) error
@ -299,19 +330,22 @@ type FullNode interface {
 	// MethodGroup: State
 	// The State methods are used to query, inspect, and interact with chain state.
-	// All methods take a TipSetKey as a parameter. The state looked up is the state at that tipset.
+	// Most methods take a TipSetKey as a parameter. The state looked up is the state at that tipset.
 	// A nil TipSetKey can be provided as a param, this will cause the heaviest tipset in the chain to be used.
 	// StateCall runs the given message and returns its result without any persisted changes.
 	StateCall(context.Context, *types.Message, types.TipSetKey) (*InvocResult, error)
-	// StateReplay returns the result of executing the indicated message, assuming it was executed in the indicated tipset.
+	// StateReplay replays a given message, assuming it was included in a block in the specified tipset.
 	// If no tipset key is provided, the appropriate tipset is looked up.
 	StateReplay(context.Context, types.TipSetKey, cid.Cid) (*InvocResult, error)
 	// StateGetActor returns the indicated actor's nonce and balance.
 	StateGetActor(ctx context.Context, actor address.Address, tsk types.TipSetKey) (*types.Actor, error)
 	// StateReadState returns the indicated actor's state.
 	StateReadState(ctx context.Context, actor address.Address, tsk types.TipSetKey) (*ActorState, error)
 	// StateListMessages looks back and returns all messages with a matching to or from address, stopping at the given height.
-	StateListMessages(ctx context.Context, match *types.Message, tsk types.TipSetKey, toht abi.ChainEpoch) ([]cid.Cid, error)
+	StateListMessages(ctx context.Context, match *MessageMatch, tsk types.TipSetKey, toht abi.ChainEpoch) ([]cid.Cid, error)
 	// StateDecodeParams attempts to decode the provided params, based on the recipient actor address and method number.
 	StateDecodeParams(ctx context.Context, toAddr address.Address, method abi.MethodNum, params []byte, tsk types.TipSetKey) (interface{}, error)
 	// StateNetworkName returns the name of the network the node is synced to
 	StateNetworkName(context.Context) (dtypes.NetworkName, error)
@ -342,6 +376,8 @@ type FullNode interface {
 	StateMinerInitialPledgeCollateral(context.Context, address.Address, miner.SectorPreCommitInfo, types.TipSetKey) (types.BigInt, error)
 	// StateMinerAvailableBalance returns the portion of a miner's balance that can be withdrawn or spent
 	StateMinerAvailableBalance(context.Context, address.Address, types.TipSetKey) (types.BigInt, error)
 	// StateMinerSectorAllocated checks if a sector is allocated
 	StateMinerSectorAllocated(context.Context, address.Address, abi.SectorNumber, types.TipSetKey) (bool, error)
 	// StateSectorPreCommitInfo returns the PreCommit info for the specified miner's sector
 	StateSectorPreCommitInfo(context.Context, address.Address, abi.SectorNumber, types.TipSetKey) (miner.SectorPreCommitOnChainInfo, error)
 	// StateSectorGetInfo returns the on-chain info for the specified miner's sector. Returns null in case the sector info isn't found
@ -354,11 +390,13 @@ type FullNode interface {
 	StateSectorPartition(ctx context.Context, maddr address.Address, sectorNumber abi.SectorNumber, tok types.TipSetKey) (*miner.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)
 	// StateWaitMsgLimited looks back up to limit epochs in the chain for a message.
 	// If not found, it blocks until the message arrives on chain, and gets to the
 	// indicated confidence depth.
 	StateWaitMsgLimited(ctx context.Context, cid cid.Cid, confidence uint64, limit abi.ChainEpoch) (*MsgLookup, error)
 	// StateListMiners returns the addresses of every miner that has claimed power in the Power Actor
 	StateListMiners(context.Context, types.TipSetKey) ([]address.Address, error)
 	// StateListActors returns the addresses of every actor in the state
@ -385,16 +423,26 @@ type FullNode interface {
 	// StateCompute is a flexible command that applies the given messages on the given tipset.
 	// The messages are run as though the VM were at the provided height.
 	StateCompute(context.Context, abi.ChainEpoch, []*types.Message, types.TipSetKey) (*ComputeStateOutput, error)
 	// StateVerifierStatus returns the data cap for the given address.
 	// Returns nil if there is no entry in the data cap table for the
 	// address.
 	StateVerifierStatus(ctx context.Context, addr address.Address, tsk types.TipSetKey) (*abi.StoragePower, error)
 	// StateVerifiedClientStatus returns the data cap for the given address.
 	// Returns nil if there is no entry in the data cap table for the
 	// address.
 	StateVerifiedClientStatus(ctx context.Context, addr address.Address, tsk types.TipSetKey) (*abi.StoragePower, error)
 	// StateVerifiedClientStatus returns the address of the Verified Registry's root key
 	StateVerifiedRegistryRootKey(ctx context.Context, tsk types.TipSetKey) (address.Address, error)
 	// StateDealProviderCollateralBounds returns the min and max collateral a storage provider
 	// can issue. It takes the deal size and verified status as parameters.
 	StateDealProviderCollateralBounds(context.Context, abi.PaddedPieceSize, bool, types.TipSetKey) (DealCollateralBounds, error)
-	// StateCirculatingSupply returns the circulating supply of Filecoin at the given tipset
+	// StateCirculatingSupply returns the exact circulating supply of Filecoin at the given tipset.
-	StateCirculatingSupply(context.Context, types.TipSetKey) (CirculatingSupply, error)
+	// This is not used anywhere in the protocol itself, and is only for external consumption.
 	StateCirculatingSupply(context.Context, types.TipSetKey) (abi.TokenAmount, error)
 	// StateVMCirculatingSupplyInternal returns an approximation of the circulating supply of Filecoin at the given tipset.
 	// This is the value reported by the runtime interface to actors code.
 	StateVMCirculatingSupplyInternal(context.Context, types.TipSetKey) (CirculatingSupply, error)
 	// StateNetworkVersion returns the network version at the given tipset
 	StateNetworkVersion(context.Context, types.TipSetKey) (network.Version, error)
@ -404,6 +452,8 @@ 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)
 	// MsigGetVestingSchedule returns the vesting details of a given multisig.
 	MsigGetVestingSchedule(context.Context, address.Address, types.TipSetKey) (MsigVesting, 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)
@ -415,12 +465,21 @@ type FullNode interface {
 	// It takes the following params: <multisig address>, <recipient address>, <value to transfer>,
 	// <sender address of the propose msg>, <method to call in the proposed message>, <params to include in the proposed message>
 	MsigPropose(context.Context, address.Address, address.Address, types.BigInt, address.Address, uint64, []byte) (cid.Cid, error)
-	// MsigApprove approves a previously-proposed multisig message
+
 	// MsigApprove approves a previously-proposed multisig message by transaction ID
 	// It takes the following params: <multisig address>, <proposed transaction ID> <signer address>
 	MsigApprove(context.Context, address.Address, uint64, address.Address) (cid.Cid, error)
 	// MsigApproveTxnHash approves a previously-proposed multisig message, specified
 	// using both transaction ID and a hash of the parameters used in the
 	// proposal. This method of approval can be used to ensure you only approve
 	// exactly the transaction you think you are.
 	// It takes the following params: <multisig address>, <proposed message ID>, <proposer address>, <recipient address>, <value to transfer>,
 	// <sender address of the approve msg>, <method to call in the proposed message>, <params to include in the proposed message>
-	MsigApprove(context.Context, address.Address, uint64, address.Address, address.Address, types.BigInt, address.Address, uint64, []byte) (cid.Cid, error)
+	MsigApproveTxnHash(context.Context, address.Address, uint64, address.Address, address.Address, types.BigInt, address.Address, uint64, []byte) (cid.Cid, error)
 	// MsigCancel cancels a previously-proposed multisig message
-	// It takes the following params: <multisig address>, <proposed message ID>, <recipient address>, <value to transfer>,
+	// It takes the following params: <multisig address>, <proposed transaction 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
@ -448,8 +507,17 @@ type FullNode interface {
 	// <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)
+	// MsigRemoveSigner proposes the removal of a signer from the multisig.
-	// MarketFreeBalance
+	// It accepts the multisig to make the change on, the proposer address to
 	// send the message from, the address to be removed, and a boolean
 	// indicating whether or not the signing threshold should be lowered by one
 	// along with the address removal.
 	MsigRemoveSigner(ctx context.Context, msig address.Address, proposer address.Address, toRemove address.Address, decrease bool) (cid.Cid, error)
 	// MarketReserveFunds reserves funds for a deal
 	MarketReserveFunds(ctx context.Context, wallet address.Address, addr address.Address, amt types.BigInt) (cid.Cid, error)
 	// MarketReleaseFunds releases funds reserved by MarketReserveFunds
 	MarketReleaseFunds(ctx context.Context, addr address.Address, amt types.BigInt) error
 	// MethodGroup: Paych
 	// The Paych methods are for interacting with and managing payment channels
@ -470,6 +538,12 @@ type FullNode interface {
 	PaychVoucherAdd(context.Context, address.Address, *paych.SignedVoucher, []byte, types.BigInt) (types.BigInt, error)
 	PaychVoucherList(context.Context, address.Address) ([]*paych.SignedVoucher, error)
 	PaychVoucherSubmit(context.Context, address.Address, *paych.SignedVoucher, []byte, []byte) (cid.Cid, error)
 	// CreateBackup creates node backup onder the specified file name. The
 	// method requires that the lotus daemon is running with the
 	// LOTUS_BACKUP_BASE_PATH environment variable set to some path, and that
 	// the path specified when calling CreateBackup is within the base path
 	CreateBackup(ctx context.Context, fpath string) error
 }
 type FileRef struct {
@ -516,6 +590,7 @@ type DealInfo struct {
 	DealID abi.DealID
 	CreationTime time.Time
 	Verified     bool
 }
 type MsgLookup struct {
@ -537,6 +612,8 @@ type MsgGasCost struct {
 	TotalCost          abi.TokenAmount
 }
 // BlsMessages[x].cid = Cids[x]
 // SecpkMessages[y].cid = Cids[BlsMessages.length + y]
 type BlockMessages struct {
 	BlsMessages   []*types.Message
 	SecpkMessages []*types.SignedMessage
@ -682,8 +759,10 @@ type RetrievalOrder struct {
 }
 type InvocResult struct {
 	MsgCid         cid.Cid
 	Msg            *types.Message
 	MsgRct         *types.MessageReceipt
 	GasCost        MsgGasCost
 	ExecutionTrace types.ExecutionTrace
 	Error          string
 	Duration       time.Duration
@ -712,8 +791,9 @@ type IpldObject struct {
 }
 type ActiveSync struct {
-	Base   *types.TipSet
+	WorkerID uint64
-	Target *types.TipSet
+	Base     *types.TipSet
 	Target   *types.TipSet
 	Stage  SyncStateStage
 	Height abi.ChainEpoch
@ -791,14 +871,14 @@ type CirculatingSupply struct {
 }
 type MiningBaseInfo struct {
-	MinerPower      types.BigInt
+	MinerPower        types.BigInt
-	NetworkPower    types.BigInt
+	NetworkPower      types.BigInt
-	Sectors         []builtin.SectorInfo
+	Sectors           []builtin.SectorInfo
-	WorkerKey       address.Address
+	WorkerKey         address.Address
-	SectorSize      abi.SectorSize
+	SectorSize        abi.SectorSize
-	PrevBeaconEntry types.BeaconEntry
+	PrevBeaconEntry   types.BeaconEntry
-	BeaconEntries   []types.BeaconEntry
+	BeaconEntries     []types.BeaconEntry
-	HasMinPower     bool
+	EligibleForMining bool
 }
 type BlockTemplate struct {
@ -818,6 +898,12 @@ type DataSize struct {
 	PieceSize   abi.PaddedPieceSize
 }
 type DataCIDSize struct {
 	PayloadSize int64
 	PieceSize   abi.PaddedPieceSize
 	PieceCID    cid.Cid
 }
 type CommPRet struct {
 	Root cid.Cid
 	Size abi.UnpaddedPieceSize
@ -850,3 +936,20 @@ type Fault struct {
 	Miner address.Address
 	Epoch abi.ChainEpoch
 }
 var EmptyVesting = MsigVesting{
 	InitialBalance: types.EmptyInt,
 	StartEpoch:     -1,
 	UnlockDuration: -1,
 }
 type MsigVesting struct {
 	InitialBalance abi.TokenAmount
 	StartEpoch     abi.ChainEpoch
 	UnlockDuration abi.ChainEpoch
 }
 type MessageMatch struct {
 	To   address.Address
 	From address.Address
 }
--- a/api/api_gateway.go
+++ b/api/api_gateway.go
@ -0,0 +1,44 @@
 package api
 import (
 	"context"
 	"github.com/ipfs/go-cid"
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/dline"
 	"github.com/filecoin-project/go-state-types/network"
 	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
 	"github.com/filecoin-project/lotus/chain/types"
 )
 type GatewayAPI interface {
 	ChainHasObj(context.Context, cid.Cid) (bool, error)
 	ChainHead(ctx context.Context) (*types.TipSet, error)
 	ChainGetBlockMessages(context.Context, cid.Cid) (*BlockMessages, error)
 	ChainGetMessage(ctx context.Context, mc cid.Cid) (*types.Message, error)
 	ChainGetTipSet(ctx context.Context, tsk types.TipSetKey) (*types.TipSet, error)
 	ChainGetTipSetByHeight(ctx context.Context, h abi.ChainEpoch, tsk types.TipSetKey) (*types.TipSet, error)
 	ChainNotify(context.Context) (<-chan []*HeadChange, error)
 	ChainReadObj(context.Context, cid.Cid) ([]byte, error)
 	GasEstimateMessageGas(ctx context.Context, msg *types.Message, spec *MessageSendSpec, tsk types.TipSetKey) (*types.Message, error)
 	MpoolPush(ctx context.Context, sm *types.SignedMessage) (cid.Cid, error)
 	MsigGetAvailableBalance(ctx context.Context, addr address.Address, tsk types.TipSetKey) (types.BigInt, error)
 	MsigGetVested(ctx context.Context, addr address.Address, start types.TipSetKey, end types.TipSetKey) (types.BigInt, error)
 	StateAccountKey(ctx context.Context, addr address.Address, tsk types.TipSetKey) (address.Address, error)
 	StateDealProviderCollateralBounds(ctx context.Context, size abi.PaddedPieceSize, verified bool, tsk types.TipSetKey) (DealCollateralBounds, error)
 	StateGetActor(ctx context.Context, actor address.Address, ts types.TipSetKey) (*types.Actor, error)
 	StateGetReceipt(context.Context, cid.Cid, types.TipSetKey) (*types.MessageReceipt, error)
 	StateListMiners(ctx context.Context, tsk types.TipSetKey) ([]address.Address, error)
 	StateLookupID(ctx context.Context, addr address.Address, tsk types.TipSetKey) (address.Address, error)
 	StateMarketBalance(ctx context.Context, addr address.Address, tsk types.TipSetKey) (MarketBalance, error)
 	StateMarketStorageDeal(ctx context.Context, dealId abi.DealID, tsk types.TipSetKey) (*MarketDeal, error)
 	StateMinerInfo(ctx context.Context, actor address.Address, tsk types.TipSetKey) (miner.MinerInfo, error)
 	StateMinerProvingDeadline(ctx context.Context, addr address.Address, tsk types.TipSetKey) (*dline.Info, error)
 	StateMinerPower(context.Context, address.Address, types.TipSetKey) (*MinerPower, error)
 	StateNetworkVersion(context.Context, types.TipSetKey) (network.Version, error)
 	StateVerifiedClientStatus(ctx context.Context, addr address.Address, tsk types.TipSetKey) (*abi.StoragePower, error)
 	StateWaitMsg(ctx context.Context, msg cid.Cid, confidence uint64) (*MsgLookup, error)
 }
--- a/api/api_storage.go
+++ b/api/api_storage.go
@ -5,7 +5,10 @@ import (
 	"context"
 	"time"
 	datatransfer "github.com/filecoin-project/go-data-transfer"
 	"github.com/google/uuid"
 	"github.com/ipfs/go-cid"
 	"github.com/libp2p/go-libp2p-core/peer"
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-fil-markets/piecestore"
@ -62,11 +65,13 @@ type StorageMiner interface {
 	// WorkerConnect tells the node to connect to workers RPC
 	WorkerConnect(context.Context, string) error
-	WorkerStats(context.Context) (map[uint64]storiface.WorkerStats, error)
+	WorkerStats(context.Context) (map[uuid.UUID]storiface.WorkerStats, error)
-	WorkerJobs(context.Context) (map[uint64][]storiface.WorkerJob, error)
+	WorkerJobs(context.Context) (map[uuid.UUID][]storiface.WorkerJob, error)
 	storiface.WorkerReturn
 	// SealingSchedDiag dumps internal sealing scheduler state
-	SealingSchedDiag(context.Context) (interface{}, error)
+	SealingSchedDiag(ctx context.Context, doSched bool) (interface{}, error)
 	SealingAbort(ctx context.Context, call storiface.CallID) error
 	stores.SectorIndex
@ -81,6 +86,10 @@ type StorageMiner interface {
 	MarketGetRetrievalAsk(ctx context.Context) (*retrievalmarket.Ask, error)
 	MarketListDataTransfers(ctx context.Context) ([]DataTransferChannel, error)
 	MarketDataTransferUpdates(ctx context.Context) (<-chan DataTransferChannel, error)
 	// MinerRestartDataTransfer attempts to restart a data transfer with the given transfer ID and other peer
 	MarketRestartDataTransfer(ctx context.Context, transferID datatransfer.TransferID, otherPeer peer.ID, isInitiator bool) error
 	// ClientCancelDataTransfer cancels a data transfer with the given transfer ID and other peer
 	MarketCancelDataTransfer(ctx context.Context, transferID datatransfer.TransferID, otherPeer peer.ID, isInitiator bool) error
 	DealsImportData(ctx context.Context, dealPropCid cid.Cid, file string) error
 	DealsList(ctx context.Context) ([]MarketDeal, error)
@ -101,6 +110,12 @@ type StorageMiner interface {
 	PiecesListCidInfos(ctx context.Context) ([]cid.Cid, error)
 	PiecesGetPieceInfo(ctx context.Context, pieceCid cid.Cid) (*piecestore.PieceInfo, error)
 	PiecesGetCIDInfo(ctx context.Context, payloadCid cid.Cid) (*piecestore.CIDInfo, error)
 	// CreateBackup creates node backup onder the specified file name. The
 	// method requires that the lotus-miner is running with the
 	// LOTUS_BACKUP_BASE_PATH environment variable set to some path, and that
 	// the path specified when calling CreateBackup is within the base path
 	CreateBackup(ctx context.Context, fpath string) error
 }
 type SealRes struct {
--- a/api/api_wallet.go
+++ b/api/api_wallet.go
@ -0,0 +1,47 @@
 package api
 import (
 	"context"
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/crypto"
 	"github.com/filecoin-project/lotus/chain/types"
 )
 type MsgType string
 const (
 	MTUnknown = "unknown"
 	// Signing message CID. MsgMeta.Extra contains raw cbor message bytes
 	MTChainMsg = "message"
 	// Signing a blockheader. signing raw cbor block bytes (MsgMeta.Extra is empty)
 	MTBlock = "block"
 	// Signing a deal proposal. signing raw cbor proposal bytes (MsgMeta.Extra is empty)
 	MTDealProposal = "dealproposal"
 	// TODO: Deals, Vouchers, VRF
 )
 type MsgMeta struct {
 	Type MsgType
 	// Additional data related to what is signed. Should be verifiable with the
 	// signed bytes (e.g. CID(Extra).Bytes() == toSign)
 	Extra []byte
 }
 type WalletAPI interface {
 	WalletNew(context.Context, types.KeyType) (address.Address, error)
 	WalletHas(context.Context, address.Address) (bool, error)
 	WalletList(context.Context) ([]address.Address, error)
 	WalletSign(ctx context.Context, signer address.Address, toSign []byte, meta MsgMeta) (*crypto.Signature, error)
 	WalletExport(context.Context, address.Address) (*types.KeyInfo, error)
 	WalletImport(context.Context, *types.KeyInfo) (address.Address, error)
 	WalletDelete(context.Context, address.Address) error
 }
--- a/api/api_worker.go
+++ b/api/api_worker.go
@ -2,15 +2,13 @@ package api
 import (
 	"context"
 	"io"
-	"github.com/ipfs/go-cid"
+	"github.com/google/uuid"
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/lotus/extern/sector-storage/sealtasks"
 	"github.com/filecoin-project/lotus/extern/sector-storage/stores"
 	"github.com/filecoin-project/lotus/extern/sector-storage/storiface"
 	"github.com/filecoin-project/specs-storage/storage"
 	"github.com/filecoin-project/lotus/build"
 )
@ -23,18 +21,26 @@ type WorkerAPI interface {
 	Paths(context.Context) ([]stores.StoragePath, error)
 	Info(context.Context) (storiface.WorkerInfo, error)
-	AddPiece(ctx context.Context, sector abi.SectorID, pieceSizes []abi.UnpaddedPieceSize, newPieceSize abi.UnpaddedPieceSize, pieceData storage.Data) (abi.PieceInfo, error)
+	storiface.WorkerCalls
-	storage.Sealer
+	// Storage / Other
-
+	Remove(ctx context.Context, sector abi.SectorID) error
 	MoveStorage(ctx context.Context, sector abi.SectorID, types stores.SectorFileType) error
 	UnsealPiece(context.Context, abi.SectorID, storiface.UnpaddedByteIndex, abi.UnpaddedPieceSize, abi.SealRandomness, cid.Cid) error
 	ReadPiece(context.Context, io.Writer, abi.SectorID, storiface.UnpaddedByteIndex, abi.UnpaddedPieceSize) (bool, error)
 	StorageAddLocal(ctx context.Context, path string) error
-	Fetch(context.Context, abi.SectorID, stores.SectorFileType, stores.PathType, stores.AcquireMode) error
+	// SetEnabled marks the worker as enabled/disabled. Not that this setting
 	// may take a few seconds to propagate to task scheduler
 	SetEnabled(ctx context.Context, enabled bool) error
-	Closing(context.Context) (<-chan struct{}, error)
+	Enabled(ctx context.Context) (bool, error)
 	// WaitQuiet blocks until there are no tasks running
 	WaitQuiet(ctx context.Context) error
 	// returns a random UUID of worker session, generated randomly when worker
 	// process starts
 	ProcessSession(context.Context) (uuid.UUID, error)
 	// Like ProcessSession, but returns an error when worker is disabled
 	Session(context.Context) (uuid.UUID, error)
 }
--- a/api/apistruct/permissioned.go
+++ b/api/apistruct/permissioned.go
@ -36,3 +36,9 @@ func PermissionedWorkerAPI(a api.WorkerAPI) api.WorkerAPI {
 	auth.PermissionedProxy(AllPermissions, DefaultPerms, a, &out.Internal)
 	return &out
 }
 func PermissionedWalletAPI(a api.WalletAPI) api.WalletAPI {
 	var out WalletStruct
 	auth.PermissionedProxy(AllPermissions, DefaultPerms, a, &out.Internal)
 	return &out
 }
--- a/api/apistruct/struct.go
+++ b/api/apistruct/struct.go
@ -5,8 +5,7 @@ import (
 	"io"
 	"time"
-	stnetwork "github.com/filecoin-project/go-state-types/network"
+	"github.com/google/uuid"
 	"github.com/ipfs/go-cid"
 	metrics "github.com/libp2p/go-libp2p-core/metrics"
 	"github.com/libp2p/go-libp2p-core/network"
@ -15,6 +14,7 @@ import (
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-bitfield"
 	datatransfer "github.com/filecoin-project/go-data-transfer"
 	"github.com/filecoin-project/go-fil-markets/piecestore"
 	"github.com/filecoin-project/go-fil-markets/retrievalmarket"
 	"github.com/filecoin-project/go-fil-markets/storagemarket"
@ -24,6 +24,7 @@ import (
 	"github.com/filecoin-project/go-state-types/big"
 	"github.com/filecoin-project/go-state-types/crypto"
 	"github.com/filecoin-project/go-state-types/dline"
 	stnetwork "github.com/filecoin-project/go-state-types/network"
 	"github.com/filecoin-project/lotus/extern/sector-storage/fsutil"
 	"github.com/filecoin-project/lotus/extern/sector-storage/sealtasks"
 	"github.com/filecoin-project/lotus/extern/sector-storage/stores"
@ -59,6 +60,9 @@ type CommonStruct struct {
 		NetBandwidthStatsByPeer     func(ctx context.Context) (map[string]metrics.Stats, error)      `perm:"read"`
 		NetBandwidthStatsByProtocol func(ctx context.Context) (map[protocol.ID]metrics.Stats, error) `perm:"read"`
 		NetAgentVersion             func(ctx context.Context, p peer.ID) (string, error)             `perm:"read"`
 		NetBlockAdd                 func(ctx context.Context, acl api.NetBlockList) error            `perm:"admin"`
 		NetBlockRemove              func(ctx context.Context, acl api.NetBlockList) error            `perm:"admin"`
 		NetBlockList                func(ctx context.Context) (api.NetBlockList, error)              `perm:"read"`
 		ID      func(context.Context) (peer.ID, error)     `perm:"read"`
 		Version func(context.Context) (api.Version, error) `perm:"read"`
@ -67,6 +71,7 @@ type CommonStruct struct {
 		LogSetLevel func(context.Context, string, string) error `perm:"write"`
 		Shutdown func(context.Context) error                    `perm:"admin"`
 		Session  func(context.Context) (uuid.UUID, error)       `perm:"read"`
 		Closing  func(context.Context) (<-chan struct{}, error) `perm:"read"`
 	}
 }
@ -111,7 +116,9 @@ type FullNodeStruct struct {
 		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"`
 		SyncUnmarkAllBad   func(ctx context.Context) error                              `perm:"admin"`
 		SyncCheckBad       func(ctx context.Context, bcid cid.Cid) (string, error)      `perm:"read"`
 		SyncValidateTipset func(ctx context.Context, tsk types.TipSetKey) (bool, error) `perm:"read"`
 		MpoolGetConfig func(context.Context) (*types.MpoolConfig, error) `perm:"read"`
 		MpoolSetConfig func(context.Context, *types.MpoolConfig) error   `perm:"write"`
@ -121,26 +128,33 @@ type FullNodeStruct struct {
 		MpoolPending func(context.Context, types.TipSetKey) ([]*types.SignedMessage, error) `perm:"read"`
 		MpoolClear   func(context.Context, bool) error                                      `perm:"write"`
-		MpoolPush        func(context.Context, *types.SignedMessage) (cid.Cid, error)                              `perm:"write"`
+		MpoolPush          func(context.Context, *types.SignedMessage) (cid.Cid, error) `perm:"write"`
 		MpoolPushUntrusted func(context.Context, *types.SignedMessage) (cid.Cid, error) `perm:"write"`
 		MpoolPushMessage func(context.Context, *types.Message, *api.MessageSendSpec) (*types.SignedMessage, error) `perm:"sign"`
 		MpoolGetNonce    func(context.Context, address.Address) (uint64, error)                                    `perm:"read"`
 		MpoolSub         func(context.Context) (<-chan api.MpoolUpdate, error)                                     `perm:"read"`
 		MpoolBatchPush          func(ctx context.Context, smsgs []*types.SignedMessage) ([]cid.Cid, error)                                  `perm:"write"`
 		MpoolBatchPushUntrusted func(ctx context.Context, smsgs []*types.SignedMessage) ([]cid.Cid, error)                                  `perm:"write"`
 		MpoolBatchPushMessage   func(ctx context.Context, msgs []*types.Message, spec *api.MessageSendSpec) ([]*types.SignedMessage, error) `perm:"sign"`
 		MinerGetBaseInfo func(context.Context, address.Address, abi.ChainEpoch, types.TipSetKey) (*api.MiningBaseInfo, error) `perm:"read"`
 		MinerCreateBlock func(context.Context, *api.BlockTemplate) (*types.BlockMsg, error)                                   `perm:"write"`
-		WalletNew            func(context.Context, crypto.SigType) (address.Address, error)                       `perm:"write"`
+		WalletNew             func(context.Context, types.KeyType) (address.Address, error)                        `perm:"write"`
-		WalletHas            func(context.Context, address.Address) (bool, error)                                 `perm:"write"`
+		WalletHas             func(context.Context, address.Address) (bool, error)                                 `perm:"write"`
-		WalletList           func(context.Context) ([]address.Address, error)                                     `perm:"write"`
+		WalletList            func(context.Context) ([]address.Address, error)                                     `perm:"write"`
-		WalletBalance        func(context.Context, address.Address) (types.BigInt, error)                         `perm:"read"`
+		WalletBalance         func(context.Context, address.Address) (types.BigInt, error)                         `perm:"read"`
-		WalletSign           func(context.Context, address.Address, []byte) (*crypto.Signature, error)            `perm:"sign"`
+		WalletSign            func(context.Context, address.Address, []byte) (*crypto.Signature, error)            `perm:"sign"`
-		WalletSignMessage    func(context.Context, address.Address, *types.Message) (*types.SignedMessage, error) `perm:"sign"`
+		WalletSignMessage     func(context.Context, address.Address, *types.Message) (*types.SignedMessage, error) `perm:"sign"`
-		WalletVerify         func(context.Context, address.Address, []byte, *crypto.Signature) (bool, error)      `perm:"read"`
+		WalletVerify          func(context.Context, address.Address, []byte, *crypto.Signature) (bool, error)      `perm:"read"`
-		WalletDefaultAddress func(context.Context) (address.Address, error)                                       `perm:"write"`
+		WalletDefaultAddress  func(context.Context) (address.Address, error)                                       `perm:"write"`
-		WalletSetDefault     func(context.Context, address.Address) error                                         `perm:"admin"`
+		WalletSetDefault      func(context.Context, address.Address) error                                         `perm:"admin"`
-		WalletExport         func(context.Context, address.Address) (*types.KeyInfo, error)                       `perm:"admin"`
+		WalletExport          func(context.Context, address.Address) (*types.KeyInfo, error)                       `perm:"admin"`
-		WalletImport         func(context.Context, *types.KeyInfo) (address.Address, error)                       `perm:"admin"`
+		WalletImport          func(context.Context, *types.KeyInfo) (address.Address, error)                       `perm:"admin"`
-		WalletDelete         func(context.Context, address.Address) error                                         `perm:"write"`
+		WalletDelete          func(context.Context, address.Address) error                                         `perm:"write"`
 		WalletValidateAddress func(context.Context, string) (address.Address, error)                               `perm:"read"`
 		ClientImport                              func(ctx context.Context, ref api.FileRef) (*api.ImportRes, error)                                                `perm:"admin"`
 		ClientListImports                         func(ctx context.Context) ([]api.Import, error)                                                                   `perm:"write"`
@ -150,16 +164,20 @@ type FullNodeStruct struct {
 		ClientMinerQueryOffer                     func(ctx context.Context, miner address.Address, root cid.Cid, piece *cid.Cid) (api.QueryOffer, error)            `perm:"read"`
 		ClientStartDeal                           func(ctx context.Context, params *api.StartDealParams) (*cid.Cid, error)                                          `perm:"admin"`
 		ClientGetDealInfo                         func(context.Context, cid.Cid) (*api.DealInfo, error)                                                             `perm:"read"`
 		ClientGetDealStatus                       func(context.Context, uint64) (string, error)                                                                     `perm:"read"`
 		ClientListDeals                           func(ctx context.Context) ([]api.DealInfo, error)                                                                 `perm:"write"`
 		ClientGetDealUpdates                      func(ctx context.Context) (<-chan api.DealInfo, error)                                                            `perm:"read"`
 		ClientRetrieve                            func(ctx context.Context, order api.RetrievalOrder, ref *api.FileRef) error                                       `perm:"admin"`
 		ClientRetrieveWithEvents                  func(ctx context.Context, order api.RetrievalOrder, ref *api.FileRef) (<-chan marketevents.RetrievalEvent, error) `perm:"admin"`
-		ClientQueryAsk                            func(ctx context.Context, p peer.ID, miner address.Address) (*storagemarket.SignedStorageAsk, error)              `perm:"read"`
+		ClientQueryAsk                            func(ctx context.Context, p peer.ID, miner address.Address) (*storagemarket.StorageAsk, error)                    `perm:"read"`
 		ClientDealPieceCID                        func(ctx context.Context, root cid.Cid) (api.DataCIDSize, error)                                                  `perm:"read"`
 		ClientCalcCommP                           func(ctx context.Context, inpath string) (*api.CommPRet, error)                                                   `perm:"read"`
 		ClientGenCar                              func(ctx context.Context, ref api.FileRef, outpath string) error                                                  `perm:"write"`
 		ClientDealSize                            func(ctx context.Context, root cid.Cid) (api.DataSize, error)                                                     `perm:"read"`
 		ClientListDataTransfers                   func(ctx context.Context) ([]api.DataTransferChannel, error)                                                      `perm:"write"`
 		ClientDataTransferUpdates                 func(ctx context.Context) (<-chan api.DataTransferChannel, error)                                                 `perm:"write"`
 		ClientRestartDataTransfer                 func(ctx context.Context, transferID datatransfer.TransferID, otherPeer peer.ID, isInitiator bool) error          `perm:"write"`
 		ClientCancelDataTransfer                  func(ctx context.Context, transferID datatransfer.TransferID, otherPeer peer.ID, isInitiator bool) error          `perm:"write"`
 		ClientRetrieveTryRestartInsufficientFunds func(ctx context.Context, paymentChannel address.Address) error                                                   `perm:"write"`
 		StateNetworkName                   func(context.Context) (dtypes.NetworkName, error)                                                                   `perm:"read"`
@ -176,6 +194,7 @@ type FullNodeStruct struct {
 		StateMinerPreCommitDepositForPower func(context.Context, address.Address, miner.SectorPreCommitInfo, types.TipSetKey) (types.BigInt, error)            `perm:"read"`
 		StateMinerInitialPledgeCollateral  func(context.Context, address.Address, miner.SectorPreCommitInfo, types.TipSetKey) (types.BigInt, error)            `perm:"read"`
 		StateMinerAvailableBalance         func(context.Context, address.Address, types.TipSetKey) (types.BigInt, error)                                       `perm:"read"`
 		StateMinerSectorAllocated          func(context.Context, address.Address, abi.SectorNumber, types.TipSetKey) (bool, error)                             `perm:"read"`
 		StateSectorPreCommitInfo           func(context.Context, address.Address, abi.SectorNumber, types.TipSetKey) (miner.SectorPreCommitOnChainInfo, error) `perm:"read"`
 		StateSectorGetInfo                 func(context.Context, address.Address, abi.SectorNumber, types.TipSetKey) (*miner.SectorOnChainInfo, error)         `perm:"read"`
 		StateSectorExpiration              func(context.Context, address.Address, abi.SectorNumber, types.TipSetKey) (*miner.SectorExpiration, error)          `perm:"read"`
@ -184,8 +203,8 @@ 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"`
 		StateWaitMsgLimited                func(context.Context, cid.Cid, uint64, abi.ChainEpoch) (*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"`
 		StateListActors                    func(context.Context, types.TipSetKey) ([]address.Address, error)                                                   `perm:"read"`
@ -198,18 +217,24 @@ type FullNodeStruct struct {
 		StateChangedActors                 func(context.Context, cid.Cid, cid.Cid) (map[string]types.Actor, error)                                             `perm:"read"`
 		StateGetReceipt                    func(context.Context, cid.Cid, types.TipSetKey) (*types.MessageReceipt, error)                                      `perm:"read"`
 		StateMinerSectorCount              func(context.Context, address.Address, types.TipSetKey) (api.MinerSectors, error)                                   `perm:"read"`
-		StateListMessages                  func(ctx context.Context, match *types.Message, tsk types.TipSetKey, toht abi.ChainEpoch) ([]cid.Cid, error)        `perm:"read"`
+		StateListMessages                  func(ctx context.Context, match *api.MessageMatch, tsk types.TipSetKey, toht abi.ChainEpoch) ([]cid.Cid, error)     `perm:"read"`
 		StateDecodeParams                  func(context.Context, address.Address, abi.MethodNum, []byte, types.TipSetKey) (interface{}, error)                 `perm:"read"`
 		StateCompute                       func(context.Context, abi.ChainEpoch, []*types.Message, types.TipSetKey) (*api.ComputeStateOutput, error)           `perm:"read"`
 		StateVerifierStatus                func(context.Context, address.Address, types.TipSetKey) (*abi.StoragePower, error)                                  `perm:"read"`
 		StateVerifiedClientStatus          func(context.Context, address.Address, types.TipSetKey) (*abi.StoragePower, error)                                  `perm:"read"`
 		StateVerifiedRegistryRootKey       func(ctx context.Context, tsk types.TipSetKey) (address.Address, error)                                             `perm:"read"`
 		StateDealProviderCollateralBounds  func(context.Context, abi.PaddedPieceSize, bool, types.TipSetKey) (api.DealCollateralBounds, error)                 `perm:"read"`
-		StateCirculatingSupply             func(context.Context, types.TipSetKey) (api.CirculatingSupply, error)                                               `perm:"read"`
+		StateCirculatingSupply             func(context.Context, types.TipSetKey) (abi.TokenAmount, error)                                                     `perm:"read"`
 		StateVMCirculatingSupplyInternal   func(context.Context, types.TipSetKey) (api.CirculatingSupply, error)                                               `perm:"read"`
 		StateNetworkVersion                func(context.Context, types.TipSetKey) (stnetwork.Version, error)                                                   `perm:"read"`
 		MsigGetAvailableBalance func(context.Context, address.Address, types.TipSetKey) (types.BigInt, error)                                                                    `perm:"read"`
 		MsigGetVestingSchedule  func(context.Context, address.Address, types.TipSetKey) (api.MsigVesting, 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"`
+		MsigApprove             func(context.Context, address.Address, uint64, address.Address) (cid.Cid, error)                                                                 `perm:"sign"`
 		MsigApproveTxnHash      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"`
@ -217,8 +242,10 @@ type FullNodeStruct struct {
 		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"`
 		MsigRemoveSigner        func(ctx context.Context, msig address.Address, proposer address.Address, toRemove address.Address, decrease bool) (cid.Cid, error)              `perm:"sign"`
-		MarketEnsureAvailable func(context.Context, address.Address, address.Address, types.BigInt) (cid.Cid, error) `perm:"sign"`
+		MarketReserveFunds func(ctx context.Context, wallet address.Address, addr address.Address, amt types.BigInt) (cid.Cid, error) `perm:"sign"`
 		MarketReleaseFunds func(ctx context.Context, addr address.Address, amt types.BigInt) error                                    `perm:"sign"`
 		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"`
@ -237,6 +264,8 @@ type FullNodeStruct struct {
 		PaychVoucherCreate          func(context.Context, address.Address, big.Int, uint64) (*api.VoucherCreateResult, error)                 `perm:"sign"`
 		PaychVoucherList            func(context.Context, address.Address) ([]*paych.SignedVoucher, error)                                    `perm:"write"`
 		PaychVoucherSubmit          func(context.Context, address.Address, *paych.SignedVoucher, []byte, []byte) (cid.Cid, error)             `perm:"sign"`
 		CreateBackup func(ctx context.Context, fpath string) error `perm:"admin"`
 	}
 }
@ -264,6 +293,8 @@ type StorageMinerStruct struct {
 		MarketGetRetrievalAsk     func(ctx context.Context) (*retrievalmarket.Ask, error)                                                                                                                      `perm:"read"`
 		MarketListDataTransfers   func(ctx context.Context) ([]api.DataTransferChannel, error)                                                                                                                 `perm:"write"`
 		MarketDataTransferUpdates func(ctx context.Context) (<-chan api.DataTransferChannel, error)                                                                                                            `perm:"write"`
 		MarketRestartDataTransfer func(ctx context.Context, transferID datatransfer.TransferID, otherPeer peer.ID, isInitiator bool) error                                                                     `perm:"read"`
 		MarketCancelDataTransfer  func(ctx context.Context, transferID datatransfer.TransferID, otherPeer peer.ID, isInitiator bool) error                                                                     `perm:"read"`
 		PledgeSector func(context.Context) error `perm:"write"`
@ -279,24 +310,37 @@ type StorageMinerStruct struct {
 		SectorRemove                  func(context.Context, abi.SectorNumber) error                                                 `perm:"admin"`
 		SectorMarkForUpgrade          func(ctx context.Context, id abi.SectorNumber) error                                          `perm:"admin"`
-		WorkerConnect func(context.Context, string) error                             `perm:"admin"` // TODO: worker perm
+		WorkerConnect func(context.Context, string) error                                `perm:"admin" retry:"true"` // TODO: worker perm
-		WorkerStats   func(context.Context) (map[uint64]storiface.WorkerStats, error) `perm:"admin"`
+		WorkerStats   func(context.Context) (map[uuid.UUID]storiface.WorkerStats, error) `perm:"admin"`
-		WorkerJobs    func(context.Context) (map[uint64][]storiface.WorkerJob, error) `perm:"admin"`
+		WorkerJobs    func(context.Context) (map[uuid.UUID][]storiface.WorkerJob, error) `perm:"admin"`
-		SealingSchedDiag func(context.Context) (interface{}, error) `perm:"admin"`
+		ReturnAddPiece        func(ctx context.Context, callID storiface.CallID, pi abi.PieceInfo, err *storiface.CallError) error          `perm:"admin" retry:"true"`
 		ReturnSealPreCommit1  func(ctx context.Context, callID storiface.CallID, p1o storage.PreCommit1Out, err *storiface.CallError) error `perm:"admin" retry:"true"`
 		ReturnSealPreCommit2  func(ctx context.Context, callID storiface.CallID, sealed storage.SectorCids, err *storiface.CallError) error `perm:"admin" retry:"true"`
 		ReturnSealCommit1     func(ctx context.Context, callID storiface.CallID, out storage.Commit1Out, err *storiface.CallError) error    `perm:"admin" retry:"true"`
 		ReturnSealCommit2     func(ctx context.Context, callID storiface.CallID, proof storage.Proof, err *storiface.CallError) error       `perm:"admin" retry:"true"`
 		ReturnFinalizeSector  func(ctx context.Context, callID storiface.CallID, err *storiface.CallError) error                            `perm:"admin" retry:"true"`
 		ReturnReleaseUnsealed func(ctx context.Context, callID storiface.CallID, err *storiface.CallError) error                            `perm:"admin" retry:"true"`
 		ReturnMoveStorage     func(ctx context.Context, callID storiface.CallID, err *storiface.CallError) error                            `perm:"admin" retry:"true"`
 		ReturnUnsealPiece     func(ctx context.Context, callID storiface.CallID, err *storiface.CallError) error                            `perm:"admin" retry:"true"`
 		ReturnReadPiece       func(ctx context.Context, callID storiface.CallID, ok bool, err *storiface.CallError) error                   `perm:"admin" retry:"true"`
 		ReturnFetch           func(ctx context.Context, callID storiface.CallID, err *storiface.CallError) error                            `perm:"admin" retry:"true"`
-		StorageList          func(context.Context) (map[stores.ID][]stores.Decl, error)                                                                                    `perm:"admin"`
+		SealingSchedDiag func(context.Context, bool) (interface{}, error)       `perm:"admin"`
-		StorageLocal         func(context.Context) (map[stores.ID]string, error)                                                                                           `perm:"admin"`
+		SealingAbort     func(ctx context.Context, call storiface.CallID) error `perm:"admin"`
-		StorageStat          func(context.Context, stores.ID) (fsutil.FsStat, error)                                                                                       `perm:"admin"`
+
-		StorageAttach        func(context.Context, stores.StorageInfo, fsutil.FsStat) error                                                                                `perm:"admin"`
+		StorageList          func(context.Context) (map[stores.ID][]stores.Decl, error)                                                                                   `perm:"admin"`
-		StorageDeclareSector func(context.Context, stores.ID, abi.SectorID, stores.SectorFileType, bool) error                                                             `perm:"admin"`
+		StorageLocal         func(context.Context) (map[stores.ID]string, error)                                                                                          `perm:"admin"`
-		StorageDropSector    func(context.Context, stores.ID, abi.SectorID, stores.SectorFileType) error                                                                   `perm:"admin"`
+		StorageStat          func(context.Context, stores.ID) (fsutil.FsStat, error)                                                                                      `perm:"admin"`
-		StorageFindSector    func(context.Context, abi.SectorID, stores.SectorFileType, abi.RegisteredSealProof, bool) ([]stores.SectorStorageInfo, error)                 `perm:"admin"`
+		StorageAttach        func(context.Context, stores.StorageInfo, fsutil.FsStat) error                                                                               `perm:"admin"`
-		StorageInfo          func(context.Context, stores.ID) (stores.StorageInfo, error)                                                                                  `perm:"admin"`
+		StorageDeclareSector func(context.Context, stores.ID, abi.SectorID, storiface.SectorFileType, bool) error                                                         `perm:"admin"`
-		StorageBestAlloc     func(ctx context.Context, allocate stores.SectorFileType, spt abi.RegisteredSealProof, sealing stores.PathType) ([]stores.StorageInfo, error) `perm:"admin"`
+		StorageDropSector    func(context.Context, stores.ID, abi.SectorID, storiface.SectorFileType) error                                                               `perm:"admin"`
-		StorageReportHealth  func(ctx context.Context, id stores.ID, report stores.HealthReport) error                                                                     `perm:"admin"`
+		StorageFindSector    func(context.Context, abi.SectorID, storiface.SectorFileType, abi.SectorSize, bool) ([]stores.SectorStorageInfo, error)                      `perm:"admin"`
-		StorageLock          func(ctx context.Context, sector abi.SectorID, read stores.SectorFileType, write stores.SectorFileType) error                                 `perm:"admin"`
+		StorageInfo          func(context.Context, stores.ID) (stores.StorageInfo, error)                                                                                 `perm:"admin"`
-		StorageTryLock       func(ctx context.Context, sector abi.SectorID, read stores.SectorFileType, write stores.SectorFileType) (bool, error)                         `perm:"admin"`
+		StorageBestAlloc     func(ctx context.Context, allocate storiface.SectorFileType, ssize abi.SectorSize, sealing storiface.PathType) ([]stores.StorageInfo, error) `perm:"admin"`
 		StorageReportHealth  func(ctx context.Context, id stores.ID, report stores.HealthReport) error                                                                    `perm:"admin"`
 		StorageLock          func(ctx context.Context, sector abi.SectorID, read storiface.SectorFileType, write storiface.SectorFileType) error                          `perm:"admin"`
 		StorageTryLock       func(ctx context.Context, sector abi.SectorID, read storiface.SectorFileType, write storiface.SectorFileType) (bool, error)                  `perm:"admin"`
 		DealsImportData                       func(ctx context.Context, dealPropCid cid.Cid, file string) error `perm:"write"`
 		DealsList                             func(ctx context.Context) ([]api.MarketDeal, error)               `perm:"read"`
@ -317,6 +361,8 @@ type StorageMinerStruct struct {
 		PiecesListCidInfos func(ctx context.Context) ([]cid.Cid, error)                               `perm:"read"`
 		PiecesGetPieceInfo func(ctx context.Context, pieceCid cid.Cid) (*piecestore.PieceInfo, error) `perm:"read"`
 		PiecesGetCIDInfo   func(ctx context.Context, payloadCid cid.Cid) (*piecestore.CIDInfo, error) `perm:"read"`
 		CreateBackup func(ctx context.Context, fpath string) error `perm:"admin"`
 	}
 }
@ -330,23 +376,71 @@ type WorkerStruct struct {
 		Paths     func(context.Context) ([]stores.StoragePath, error)            `perm:"admin"`
 		Info      func(context.Context) (storiface.WorkerInfo, error)            `perm:"admin"`
-		AddPiece        func(ctx context.Context, sector abi.SectorID, pieceSizes []abi.UnpaddedPieceSize, newPieceSize abi.UnpaddedPieceSize, pieceData storage.Data) (abi.PieceInfo, error)                      `perm:"admin"`
+		AddPiece        func(ctx context.Context, sector storage.SectorRef, pieceSizes []abi.UnpaddedPieceSize, newPieceSize abi.UnpaddedPieceSize, pieceData storage.Data) (storiface.CallID, error)                 `perm:"admin"`
-		SealPreCommit1  func(ctx context.Context, sector abi.SectorID, ticket abi.SealRandomness, pieces []abi.PieceInfo) (storage.PreCommit1Out, error)                                                           `perm:"admin"`
+		SealPreCommit1  func(ctx context.Context, sector storage.SectorRef, ticket abi.SealRandomness, pieces []abi.PieceInfo) (storiface.CallID, error)                                                              `perm:"admin"`
-		SealPreCommit2  func(context.Context, abi.SectorID, storage.PreCommit1Out) (cids storage.SectorCids, err error)                                                                                            `perm:"admin"`
+		SealPreCommit2  func(ctx context.Context, sector storage.SectorRef, pc1o storage.PreCommit1Out) (storiface.CallID, error)                                                                                     `perm:"admin"`
-		SealCommit1     func(ctx context.Context, sector abi.SectorID, ticket abi.SealRandomness, seed abi.InteractiveSealRandomness, pieces []abi.PieceInfo, cids storage.SectorCids) (storage.Commit1Out, error) `perm:"admin"`
+		SealCommit1     func(ctx context.Context, sector storage.SectorRef, ticket abi.SealRandomness, seed abi.InteractiveSealRandomness, pieces []abi.PieceInfo, cids storage.SectorCids) (storiface.CallID, error) `perm:"admin"`
-		SealCommit2     func(context.Context, abi.SectorID, storage.Commit1Out) (storage.Proof, error)                                                                                                             `perm:"admin"`
+		SealCommit2     func(ctx context.Context, sector storage.SectorRef, c1o storage.Commit1Out) (storiface.CallID, error)                                                                                         `perm:"admin"`
-		FinalizeSector  func(context.Context, abi.SectorID, []storage.Range) error                                                                                                                                 `perm:"admin"`
+		FinalizeSector  func(ctx context.Context, sector storage.SectorRef, keepUnsealed []storage.Range) (storiface.CallID, error)                                                                                   `perm:"admin"`
-		ReleaseUnsealed func(ctx context.Context, sector abi.SectorID, safeToFree []storage.Range) error                                                                                                           `perm:"admin"`
+		ReleaseUnsealed func(ctx context.Context, sector storage.SectorRef, safeToFree []storage.Range) (storiface.CallID, error)                                                                                     `perm:"admin"`
-		Remove          func(ctx context.Context, sector abi.SectorID) error                                                                                                                                       `perm:"admin"`
+		MoveStorage     func(ctx context.Context, sector storage.SectorRef, types storiface.SectorFileType) (storiface.CallID, error)                                                                                 `perm:"admin"`
-		MoveStorage     func(ctx context.Context, sector abi.SectorID, types stores.SectorFileType) error                                                                                                          `perm:"admin"`
+		UnsealPiece     func(context.Context, storage.SectorRef, storiface.UnpaddedByteIndex, abi.UnpaddedPieceSize, abi.SealRandomness, cid.Cid) (storiface.CallID, error)                                           `perm:"admin"`
-		StorageAddLocal func(ctx context.Context, path string) error                                                                                                                                               `perm:"admin"`
+		ReadPiece       func(context.Context, io.Writer, storage.SectorRef, storiface.UnpaddedByteIndex, abi.UnpaddedPieceSize) (storiface.CallID, error)                                                             `perm:"admin"`
 		Fetch           func(context.Context, storage.SectorRef, storiface.SectorFileType, storiface.PathType, storiface.AcquireMode) (storiface.CallID, error)                                                       `perm:"admin"`
-		UnsealPiece func(context.Context, abi.SectorID, storiface.UnpaddedByteIndex, abi.UnpaddedPieceSize, abi.SealRandomness, cid.Cid) error `perm:"admin"`
+		Remove          func(ctx context.Context, sector abi.SectorID) error `perm:"admin"`
-		ReadPiece   func(context.Context, io.Writer, abi.SectorID, storiface.UnpaddedByteIndex, abi.UnpaddedPieceSize) (bool, error)           `perm:"admin"`
+		StorageAddLocal func(ctx context.Context, path string) error         `perm:"admin"`
-		Fetch func(context.Context, abi.SectorID, stores.SectorFileType, stores.PathType, stores.AcquireMode) error `perm:"admin"`
+		SetEnabled func(ctx context.Context, enabled bool) error `perm:"admin"`
 		Enabled    func(ctx context.Context) (bool, error)       `perm:"admin"`
-		Closing func(context.Context) (<-chan struct{}, error) `perm:"admin"`
+		WaitQuiet func(ctx context.Context) error `perm:"admin"`
 		ProcessSession func(context.Context) (uuid.UUID, error) `perm:"admin"`
 		Session        func(context.Context) (uuid.UUID, error) `perm:"admin"`
 	}
 }
 type GatewayStruct struct {
 	Internal struct {
 		ChainGetBlockMessages             func(ctx context.Context, c cid.Cid) (*api.BlockMessages, error)
 		ChainGetMessage                   func(ctx context.Context, mc cid.Cid) (*types.Message, error)
 		ChainGetTipSet                    func(ctx context.Context, tsk types.TipSetKey) (*types.TipSet, error)
 		ChainGetTipSetByHeight            func(ctx context.Context, h abi.ChainEpoch, tsk types.TipSetKey) (*types.TipSet, error)
 		ChainHasObj                       func(context.Context, cid.Cid) (bool, error)
 		ChainHead                         func(ctx context.Context) (*types.TipSet, error)
 		ChainNotify                       func(ctx context.Context) (<-chan []*api.HeadChange, error)
 		ChainReadObj                      func(context.Context, cid.Cid) ([]byte, error)
 		GasEstimateMessageGas             func(ctx context.Context, msg *types.Message, spec *api.MessageSendSpec, tsk types.TipSetKey) (*types.Message, error)
 		MpoolPush                         func(ctx context.Context, sm *types.SignedMessage) (cid.Cid, error)
 		MsigGetAvailableBalance           func(ctx context.Context, addr address.Address, tsk types.TipSetKey) (types.BigInt, error)
 		MsigGetVested                     func(ctx context.Context, addr address.Address, start types.TipSetKey, end types.TipSetKey) (types.BigInt, error)
 		StateAccountKey                   func(ctx context.Context, addr address.Address, tsk types.TipSetKey) (address.Address, error)
 		StateDealProviderCollateralBounds func(ctx context.Context, size abi.PaddedPieceSize, verified bool, tsk types.TipSetKey) (api.DealCollateralBounds, error)
 		StateGetActor                     func(ctx context.Context, actor address.Address, ts types.TipSetKey) (*types.Actor, error)
 		StateGetReceipt                   func(ctx context.Context, c cid.Cid, tsk types.TipSetKey) (*types.MessageReceipt, error)
 		StateLookupID                     func(ctx context.Context, addr address.Address, tsk types.TipSetKey) (address.Address, error)
 		StateListMiners                   func(ctx context.Context, tsk types.TipSetKey) ([]address.Address, error)
 		StateMinerInfo                    func(ctx context.Context, actor address.Address, tsk types.TipSetKey) (miner.MinerInfo, error)
 		StateMinerProvingDeadline         func(ctx context.Context, addr address.Address, tsk types.TipSetKey) (*dline.Info, error)
 		StateMinerPower                   func(context.Context, address.Address, types.TipSetKey) (*api.MinerPower, error)
 		StateMarketBalance                func(ctx context.Context, addr address.Address, tsk types.TipSetKey) (api.MarketBalance, error)
 		StateMarketStorageDeal            func(ctx context.Context, dealId abi.DealID, tsk types.TipSetKey) (*api.MarketDeal, error)
 		StateNetworkVersion               func(ctx context.Context, tsk types.TipSetKey) (stnetwork.Version, error)
 		StateVerifiedClientStatus         func(ctx context.Context, addr address.Address, tsk types.TipSetKey) (*abi.StoragePower, error)
 		StateWaitMsg                      func(ctx context.Context, msg cid.Cid, confidence uint64) (*api.MsgLookup, error)
 	}
 }
 type WalletStruct struct {
 	Internal struct {
 		WalletNew    func(context.Context, types.KeyType) (address.Address, error)                          `perm:"write"`
 		WalletHas    func(context.Context, address.Address) (bool, error)                                   `perm:"write"`
 		WalletList   func(context.Context) ([]address.Address, error)                                       `perm:"write"`
 		WalletSign   func(context.Context, address.Address, []byte, api.MsgMeta) (*crypto.Signature, error) `perm:"sign"`
 		WalletExport func(context.Context, address.Address) (*types.KeyInfo, error)                         `perm:"admin"`
 		WalletImport func(context.Context, *types.KeyInfo) (address.Address, error)                         `perm:"admin"`
 		WalletDelete func(context.Context, address.Address) error                                           `perm:"write"`
 	}
 }
@ -404,6 +498,18 @@ func (c *CommonStruct) NetBandwidthStatsByProtocol(ctx context.Context) (map[pro
 	return c.Internal.NetBandwidthStatsByProtocol(ctx)
 }
 func (c *CommonStruct) NetBlockAdd(ctx context.Context, acl api.NetBlockList) error {
 	return c.Internal.NetBlockAdd(ctx, acl)
 }
 func (c *CommonStruct) NetBlockRemove(ctx context.Context, acl api.NetBlockList) error {
 	return c.Internal.NetBlockRemove(ctx, acl)
 }
 func (c *CommonStruct) NetBlockList(ctx context.Context) (api.NetBlockList, error) {
 	return c.Internal.NetBlockList(ctx)
 }
 func (c *CommonStruct) NetAgentVersion(ctx context.Context, p peer.ID) (string, error) {
 	return c.Internal.NetAgentVersion(ctx, p)
 }
@ -430,6 +536,10 @@ func (c *CommonStruct) Shutdown(ctx context.Context) error {
 	return c.Internal.Shutdown(ctx)
 }
 func (c *CommonStruct) Session(ctx context.Context) (uuid.UUID, error) {
 	return c.Internal.Session(ctx)
 }
 func (c *CommonStruct) Closing(ctx context.Context) (<-chan struct{}, error) {
 	return c.Internal.Closing(ctx)
 }
@ -468,6 +578,10 @@ func (c *FullNodeStruct) ClientGetDealInfo(ctx context.Context, deal cid.Cid) (*
 	return c.Internal.ClientGetDealInfo(ctx, deal)
 }
 func (c *FullNodeStruct) ClientGetDealStatus(ctx context.Context, statusCode uint64) (string, error) {
 	return c.Internal.ClientGetDealStatus(ctx, statusCode)
 }
 func (c *FullNodeStruct) ClientListDeals(ctx context.Context) ([]api.DealInfo, error) {
 	return c.Internal.ClientListDeals(ctx)
 }
@ -484,9 +598,14 @@ func (c *FullNodeStruct) ClientRetrieveWithEvents(ctx context.Context, order api
 	return c.Internal.ClientRetrieveWithEvents(ctx, order, ref)
 }
-func (c *FullNodeStruct) ClientQueryAsk(ctx context.Context, p peer.ID, miner address.Address) (*storagemarket.SignedStorageAsk, error) {
+func (c *FullNodeStruct) ClientQueryAsk(ctx context.Context, p peer.ID, miner address.Address) (*storagemarket.StorageAsk, error) {
 	return c.Internal.ClientQueryAsk(ctx, p, miner)
 }
 func (c *FullNodeStruct) ClientDealPieceCID(ctx context.Context, root cid.Cid) (api.DataCIDSize, error) {
 	return c.Internal.ClientDealPieceCID(ctx, root)
 }
 func (c *FullNodeStruct) ClientCalcCommP(ctx context.Context, inpath string) (*api.CommPRet, error) {
 	return c.Internal.ClientCalcCommP(ctx, inpath)
 }
@ -507,6 +626,14 @@ func (c *FullNodeStruct) ClientDataTransferUpdates(ctx context.Context) (<-chan
 	return c.Internal.ClientDataTransferUpdates(ctx)
 }
 func (c *FullNodeStruct) ClientRestartDataTransfer(ctx context.Context, transferID datatransfer.TransferID, otherPeer peer.ID, isInitiator bool) error {
 	return c.Internal.ClientRestartDataTransfer(ctx, transferID, otherPeer, isInitiator)
 }
 func (c *FullNodeStruct) ClientCancelDataTransfer(ctx context.Context, transferID datatransfer.TransferID, otherPeer peer.ID, isInitiator bool) error {
 	return c.Internal.ClientCancelDataTransfer(ctx, transferID, otherPeer, isInitiator)
 }
 func (c *FullNodeStruct) ClientRetrieveTryRestartInsufficientFunds(ctx context.Context, paymentChannel address.Address) error {
 	return c.Internal.ClientRetrieveTryRestartInsufficientFunds(ctx, paymentChannel)
 }
@ -551,10 +678,26 @@ func (c *FullNodeStruct) MpoolPush(ctx context.Context, smsg *types.SignedMessag
 	return c.Internal.MpoolPush(ctx, smsg)
 }
 func (c *FullNodeStruct) MpoolPushUntrusted(ctx context.Context, smsg *types.SignedMessage) (cid.Cid, error) {
 	return c.Internal.MpoolPushUntrusted(ctx, smsg)
 }
 func (c *FullNodeStruct) MpoolPushMessage(ctx context.Context, msg *types.Message, spec *api.MessageSendSpec) (*types.SignedMessage, error) {
 	return c.Internal.MpoolPushMessage(ctx, msg, spec)
 }
 func (c *FullNodeStruct) MpoolBatchPush(ctx context.Context, smsgs []*types.SignedMessage) ([]cid.Cid, error) {
 	return c.Internal.MpoolBatchPush(ctx, smsgs)
 }
 func (c *FullNodeStruct) MpoolBatchPushUntrusted(ctx context.Context, smsgs []*types.SignedMessage) ([]cid.Cid, error) {
 	return c.Internal.MpoolBatchPushUntrusted(ctx, smsgs)
 }
 func (c *FullNodeStruct) MpoolBatchPushMessage(ctx context.Context, msgs []*types.Message, spec *api.MessageSendSpec) ([]*types.SignedMessage, error) {
 	return c.Internal.MpoolBatchPushMessage(ctx, msgs, spec)
 }
 func (c *FullNodeStruct) MpoolSub(ctx context.Context) (<-chan api.MpoolUpdate, error) {
 	return c.Internal.MpoolSub(ctx)
 }
@ -583,7 +726,7 @@ func (c *FullNodeStruct) ChainGetTipSetByHeight(ctx context.Context, h abi.Chain
 	return c.Internal.ChainGetTipSetByHeight(ctx, h, tsk)
 }
-func (c *FullNodeStruct) WalletNew(ctx context.Context, typ crypto.SigType) (address.Address, error) {
+func (c *FullNodeStruct) WalletNew(ctx context.Context, typ types.KeyType) (address.Address, error) {
 	return c.Internal.WalletNew(ctx, typ)
 }
@ -631,6 +774,10 @@ func (c *FullNodeStruct) WalletDelete(ctx context.Context, addr address.Address)
 	return c.Internal.WalletDelete(ctx, addr)
 }
 func (c *FullNodeStruct) WalletValidateAddress(ctx context.Context, str string) (address.Address, error) {
 	return c.Internal.WalletValidateAddress(ctx, str)
 }
 func (c *FullNodeStruct) MpoolGetNonce(ctx context.Context, addr address.Address) (uint64, error) {
 	return c.Internal.MpoolGetNonce(ctx, addr)
 }
@ -731,10 +878,18 @@ func (c *FullNodeStruct) SyncUnmarkBad(ctx context.Context, bcid cid.Cid) error
 	return c.Internal.SyncUnmarkBad(ctx, bcid)
 }
 func (c *FullNodeStruct) SyncUnmarkAllBad(ctx context.Context) error {
 	return c.Internal.SyncUnmarkAllBad(ctx)
 }
 func (c *FullNodeStruct) SyncCheckBad(ctx context.Context, bcid cid.Cid) (string, error) {
 	return c.Internal.SyncCheckBad(ctx, bcid)
 }
 func (c *FullNodeStruct) SyncValidateTipset(ctx context.Context, tsk types.TipSetKey) (bool, error) {
 	return c.Internal.SyncValidateTipset(ctx, tsk)
 }
 func (c *FullNodeStruct) StateNetworkName(ctx context.Context) (dtypes.NetworkName, error) {
 	return c.Internal.StateNetworkName(ctx)
 }
@ -791,6 +946,10 @@ func (c *FullNodeStruct) StateMinerAvailableBalance(ctx context.Context, maddr a
 	return c.Internal.StateMinerAvailableBalance(ctx, maddr, tsk)
 }
 func (c *FullNodeStruct) StateMinerSectorAllocated(ctx context.Context, maddr address.Address, s abi.SectorNumber, tsk types.TipSetKey) (bool, error) {
 	return c.Internal.StateMinerSectorAllocated(ctx, maddr, s, tsk)
 }
 func (c *FullNodeStruct) StateSectorPreCommitInfo(ctx context.Context, maddr address.Address, n abi.SectorNumber, tsk types.TipSetKey) (miner.SectorPreCommitOnChainInfo, error) {
 	return c.Internal.StateSectorPreCommitInfo(ctx, maddr, n, tsk)
 }
@ -823,14 +982,14 @@ 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)
 }
 func (c *FullNodeStruct) StateWaitMsgLimited(ctx context.Context, msgc cid.Cid, confidence uint64, limit abi.ChainEpoch) (*api.MsgLookup, error) {
 	return c.Internal.StateWaitMsgLimited(ctx, msgc, confidence, limit)
 }
 func (c *FullNodeStruct) StateSearchMsg(ctx context.Context, msgc cid.Cid) (*api.MsgLookup, error) {
 	return c.Internal.StateSearchMsg(ctx, msgc)
 }
@ -875,26 +1034,42 @@ func (c *FullNodeStruct) StateGetReceipt(ctx context.Context, msg cid.Cid, tsk t
 	return c.Internal.StateGetReceipt(ctx, msg, tsk)
 }
-func (c *FullNodeStruct) StateListMessages(ctx context.Context, match *types.Message, tsk types.TipSetKey, toht abi.ChainEpoch) ([]cid.Cid, error) {
+func (c *FullNodeStruct) StateListMessages(ctx context.Context, match *api.MessageMatch, tsk types.TipSetKey, toht abi.ChainEpoch) ([]cid.Cid, error) {
 	return c.Internal.StateListMessages(ctx, match, tsk, toht)
 }
 func (c *FullNodeStruct) StateDecodeParams(ctx context.Context, toAddr address.Address, method abi.MethodNum, params []byte, tsk types.TipSetKey) (interface{}, error) {
 	return c.Internal.StateDecodeParams(ctx, toAddr, method, params, tsk)
 }
 func (c *FullNodeStruct) StateCompute(ctx context.Context, height abi.ChainEpoch, msgs []*types.Message, tsk types.TipSetKey) (*api.ComputeStateOutput, error) {
 	return c.Internal.StateCompute(ctx, height, msgs, tsk)
 }
 func (c *FullNodeStruct) StateVerifierStatus(ctx context.Context, addr address.Address, tsk types.TipSetKey) (*abi.StoragePower, error) {
 	return c.Internal.StateVerifierStatus(ctx, addr, tsk)
 }
 func (c *FullNodeStruct) StateVerifiedClientStatus(ctx context.Context, addr address.Address, tsk types.TipSetKey) (*abi.StoragePower, error) {
 	return c.Internal.StateVerifiedClientStatus(ctx, addr, tsk)
 }
 func (c *FullNodeStruct) StateVerifiedRegistryRootKey(ctx context.Context, tsk types.TipSetKey) (address.Address, error) {
 	return c.Internal.StateVerifiedRegistryRootKey(ctx, tsk)
 }
 func (c *FullNodeStruct) StateDealProviderCollateralBounds(ctx context.Context, size abi.PaddedPieceSize, verified bool, tsk types.TipSetKey) (api.DealCollateralBounds, error) {
 	return c.Internal.StateDealProviderCollateralBounds(ctx, size, verified, tsk)
 }
-func (c *FullNodeStruct) StateCirculatingSupply(ctx context.Context, tsk types.TipSetKey) (api.CirculatingSupply, error) {
+func (c *FullNodeStruct) StateCirculatingSupply(ctx context.Context, tsk types.TipSetKey) (abi.TokenAmount, error) {
 	return c.Internal.StateCirculatingSupply(ctx, tsk)
 }
 func (c *FullNodeStruct) StateVMCirculatingSupplyInternal(ctx context.Context, tsk types.TipSetKey) (api.CirculatingSupply, error) {
 	return c.Internal.StateVMCirculatingSupplyInternal(ctx, tsk)
 }
 func (c *FullNodeStruct) StateNetworkVersion(ctx context.Context, tsk types.TipSetKey) (stnetwork.Version, error) {
 	return c.Internal.StateNetworkVersion(ctx, tsk)
 }
@ -903,6 +1078,10 @@ func (c *FullNodeStruct) MsigGetAvailableBalance(ctx context.Context, a address.
 	return c.Internal.MsigGetAvailableBalance(ctx, a, tsk)
 }
 func (c *FullNodeStruct) MsigGetVestingSchedule(ctx context.Context, a address.Address, tsk types.TipSetKey) (api.MsigVesting, error) {
 	return c.Internal.MsigGetVestingSchedule(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)
 }
@ -915,8 +1094,12 @@ func (c *FullNodeStruct) MsigPropose(ctx context.Context, msig address.Address,
 	return c.Internal.MsigPropose(ctx, msig, to, amt, src, method, params)
 }
-func (c *FullNodeStruct) MsigApprove(ctx context.Context, msig address.Address, txID uint64, proposer address.Address, to address.Address, amt types.BigInt, src address.Address, method uint64, params []byte) (cid.Cid, error) {
+func (c *FullNodeStruct) MsigApprove(ctx context.Context, msig address.Address, txID uint64, signer address.Address) (cid.Cid, error) {
-	return c.Internal.MsigApprove(ctx, msig, txID, proposer, to, amt, src, method, params)
+	return c.Internal.MsigApprove(ctx, msig, txID, signer)
 }
 func (c *FullNodeStruct) MsigApproveTxnHash(ctx context.Context, msig address.Address, txID uint64, proposer address.Address, to address.Address, amt types.BigInt, src address.Address, method uint64, params []byte) (cid.Cid, error) {
 	return c.Internal.MsigApproveTxnHash(ctx, msig, txID, proposer, to, amt, src, method, params)
 }
 func (c *FullNodeStruct) MsigCancel(ctx context.Context, msig address.Address, txID uint64, to address.Address, amt types.BigInt, src address.Address, method uint64, params []byte) (cid.Cid, error) {
@ -947,8 +1130,16 @@ func (c *FullNodeStruct) MsigSwapCancel(ctx context.Context, msig address.Addres
 	return c.Internal.MsigSwapCancel(ctx, msig, src, txID, oldAdd, newAdd)
 }
-func (c *FullNodeStruct) MarketEnsureAvailable(ctx context.Context, addr, wallet address.Address, amt types.BigInt) (cid.Cid, error) {
+func (c *FullNodeStruct) MsigRemoveSigner(ctx context.Context, msig address.Address, proposer address.Address, toRemove address.Address, decrease bool) (cid.Cid, error) {
-	return c.Internal.MarketEnsureAvailable(ctx, addr, wallet, amt)
+	return c.Internal.MsigRemoveSigner(ctx, msig, proposer, toRemove, decrease)
 }
 func (c *FullNodeStruct) MarketReserveFunds(ctx context.Context, wallet address.Address, addr address.Address, amt types.BigInt) (cid.Cid, error) {
 	return c.Internal.MarketReserveFunds(ctx, wallet, addr, amt)
 }
 func (c *FullNodeStruct) MarketReleaseFunds(ctx context.Context, addr address.Address, amt types.BigInt) error {
 	return c.Internal.MarketReleaseFunds(ctx, addr, amt)
 }
 func (c *FullNodeStruct) PaychGet(ctx context.Context, from, to address.Address, amt types.BigInt) (*api.ChannelInfo, error) {
@ -1015,6 +1206,10 @@ func (c *FullNodeStruct) PaychVoucherSubmit(ctx context.Context, ch address.Addr
 	return c.Internal.PaychVoucherSubmit(ctx, ch, sv, secret, proof)
 }
 func (c *FullNodeStruct) CreateBackup(ctx context.Context, fpath string) error {
 	return c.Internal.CreateBackup(ctx, fpath)
 }
 // StorageMinerStruct
 func (c *StorageMinerStruct) ActorAddress(ctx context.Context) (address.Address, error) {
@ -1083,32 +1278,80 @@ func (c *StorageMinerStruct) WorkerConnect(ctx context.Context, url string) erro
 	return c.Internal.WorkerConnect(ctx, url)
 }
-func (c *StorageMinerStruct) WorkerStats(ctx context.Context) (map[uint64]storiface.WorkerStats, error) {
+func (c *StorageMinerStruct) WorkerStats(ctx context.Context) (map[uuid.UUID]storiface.WorkerStats, error) {
 	return c.Internal.WorkerStats(ctx)
 }
-func (c *StorageMinerStruct) WorkerJobs(ctx context.Context) (map[uint64][]storiface.WorkerJob, error) {
+func (c *StorageMinerStruct) WorkerJobs(ctx context.Context) (map[uuid.UUID][]storiface.WorkerJob, error) {
 	return c.Internal.WorkerJobs(ctx)
 }
-func (c *StorageMinerStruct) SealingSchedDiag(ctx context.Context) (interface{}, error) {
+func (c *StorageMinerStruct) ReturnAddPiece(ctx context.Context, callID storiface.CallID, pi abi.PieceInfo, err *storiface.CallError) error {
-	return c.Internal.SealingSchedDiag(ctx)
+	return c.Internal.ReturnAddPiece(ctx, callID, pi, err)
 }
 func (c *StorageMinerStruct) ReturnSealPreCommit1(ctx context.Context, callID storiface.CallID, p1o storage.PreCommit1Out, err *storiface.CallError) error {
 	return c.Internal.ReturnSealPreCommit1(ctx, callID, p1o, err)
 }
 func (c *StorageMinerStruct) ReturnSealPreCommit2(ctx context.Context, callID storiface.CallID, sealed storage.SectorCids, err *storiface.CallError) error {
 	return c.Internal.ReturnSealPreCommit2(ctx, callID, sealed, err)
 }
 func (c *StorageMinerStruct) ReturnSealCommit1(ctx context.Context, callID storiface.CallID, out storage.Commit1Out, err *storiface.CallError) error {
 	return c.Internal.ReturnSealCommit1(ctx, callID, out, err)
 }
 func (c *StorageMinerStruct) ReturnSealCommit2(ctx context.Context, callID storiface.CallID, proof storage.Proof, err *storiface.CallError) error {
 	return c.Internal.ReturnSealCommit2(ctx, callID, proof, err)
 }
 func (c *StorageMinerStruct) ReturnFinalizeSector(ctx context.Context, callID storiface.CallID, err *storiface.CallError) error {
 	return c.Internal.ReturnFinalizeSector(ctx, callID, err)
 }
 func (c *StorageMinerStruct) ReturnReleaseUnsealed(ctx context.Context, callID storiface.CallID, err *storiface.CallError) error {
 	return c.Internal.ReturnReleaseUnsealed(ctx, callID, err)
 }
 func (c *StorageMinerStruct) ReturnMoveStorage(ctx context.Context, callID storiface.CallID, err *storiface.CallError) error {
 	return c.Internal.ReturnMoveStorage(ctx, callID, err)
 }
 func (c *StorageMinerStruct) ReturnUnsealPiece(ctx context.Context, callID storiface.CallID, err *storiface.CallError) error {
 	return c.Internal.ReturnUnsealPiece(ctx, callID, err)
 }
 func (c *StorageMinerStruct) ReturnReadPiece(ctx context.Context, callID storiface.CallID, ok bool, err *storiface.CallError) error {
 	return c.Internal.ReturnReadPiece(ctx, callID, ok, err)
 }
 func (c *StorageMinerStruct) ReturnFetch(ctx context.Context, callID storiface.CallID, err *storiface.CallError) error {
 	return c.Internal.ReturnFetch(ctx, callID, err)
 }
 func (c *StorageMinerStruct) SealingSchedDiag(ctx context.Context, doSched bool) (interface{}, error) {
 	return c.Internal.SealingSchedDiag(ctx, doSched)
 }
 func (c *StorageMinerStruct) SealingAbort(ctx context.Context, call storiface.CallID) error {
 	return c.Internal.SealingAbort(ctx, call)
 }
 func (c *StorageMinerStruct) StorageAttach(ctx context.Context, si stores.StorageInfo, st fsutil.FsStat) error {
 	return c.Internal.StorageAttach(ctx, si, st)
 }
-func (c *StorageMinerStruct) StorageDeclareSector(ctx context.Context, storageId stores.ID, s abi.SectorID, ft stores.SectorFileType, primary bool) error {
+func (c *StorageMinerStruct) StorageDeclareSector(ctx context.Context, storageId stores.ID, s abi.SectorID, ft storiface.SectorFileType, primary bool) error {
 	return c.Internal.StorageDeclareSector(ctx, storageId, s, ft, primary)
 }
-func (c *StorageMinerStruct) StorageDropSector(ctx context.Context, storageId stores.ID, s abi.SectorID, ft stores.SectorFileType) error {
+func (c *StorageMinerStruct) StorageDropSector(ctx context.Context, storageId stores.ID, s abi.SectorID, ft storiface.SectorFileType) error {
 	return c.Internal.StorageDropSector(ctx, storageId, s, ft)
 }
-func (c *StorageMinerStruct) StorageFindSector(ctx context.Context, si abi.SectorID, types stores.SectorFileType, spt abi.RegisteredSealProof, allowFetch bool) ([]stores.SectorStorageInfo, error) {
+func (c *StorageMinerStruct) StorageFindSector(ctx context.Context, si abi.SectorID, types storiface.SectorFileType, ssize abi.SectorSize, allowFetch bool) ([]stores.SectorStorageInfo, error) {
-	return c.Internal.StorageFindSector(ctx, si, types, spt, allowFetch)
+	return c.Internal.StorageFindSector(ctx, si, types, ssize, allowFetch)
 }
 func (c *StorageMinerStruct) StorageList(ctx context.Context) (map[stores.ID][]stores.Decl, error) {
@ -1127,19 +1370,19 @@ func (c *StorageMinerStruct) StorageInfo(ctx context.Context, id stores.ID) (sto
 	return c.Internal.StorageInfo(ctx, id)
 }
-func (c *StorageMinerStruct) StorageBestAlloc(ctx context.Context, allocate stores.SectorFileType, spt abi.RegisteredSealProof, pt stores.PathType) ([]stores.StorageInfo, error) {
+func (c *StorageMinerStruct) StorageBestAlloc(ctx context.Context, allocate storiface.SectorFileType, ssize abi.SectorSize, pt storiface.PathType) ([]stores.StorageInfo, error) {
-	return c.Internal.StorageBestAlloc(ctx, allocate, spt, pt)
+	return c.Internal.StorageBestAlloc(ctx, allocate, ssize, pt)
 }
 func (c *StorageMinerStruct) StorageReportHealth(ctx context.Context, id stores.ID, report stores.HealthReport) error {
 	return c.Internal.StorageReportHealth(ctx, id, report)
 }
-func (c *StorageMinerStruct) StorageLock(ctx context.Context, sector abi.SectorID, read stores.SectorFileType, write stores.SectorFileType) error {
+func (c *StorageMinerStruct) StorageLock(ctx context.Context, sector abi.SectorID, read storiface.SectorFileType, write storiface.SectorFileType) error {
 	return c.Internal.StorageLock(ctx, sector, read, write)
 }
-func (c *StorageMinerStruct) StorageTryLock(ctx context.Context, sector abi.SectorID, read stores.SectorFileType, write stores.SectorFileType) (bool, error) {
+func (c *StorageMinerStruct) StorageTryLock(ctx context.Context, sector abi.SectorID, read storiface.SectorFileType, write storiface.SectorFileType) (bool, error) {
 	return c.Internal.StorageTryLock(ctx, sector, read, write)
 }
@ -1187,6 +1430,14 @@ func (c *StorageMinerStruct) MarketDataTransferUpdates(ctx context.Context) (<-c
 	return c.Internal.MarketDataTransferUpdates(ctx)
 }
 func (c *StorageMinerStruct) MarketRestartDataTransfer(ctx context.Context, transferID datatransfer.TransferID, otherPeer peer.ID, isInitiator bool) error {
 	return c.Internal.MarketRestartDataTransfer(ctx, transferID, otherPeer, isInitiator)
 }
 func (c *StorageMinerStruct) MarketCancelDataTransfer(ctx context.Context, transferID datatransfer.TransferID, otherPeer peer.ID, isInitiator bool) error {
 	return c.Internal.MarketCancelDataTransfer(ctx, transferID, otherPeer, isInitiator)
 }
 func (c *StorageMinerStruct) DealsImportData(ctx context.Context, dealPropCid cid.Cid, file string) error {
 	return c.Internal.DealsImportData(ctx, dealPropCid, file)
 }
@ -1255,6 +1506,10 @@ func (c *StorageMinerStruct) PiecesGetCIDInfo(ctx context.Context, payloadCid ci
 	return c.Internal.PiecesGetCIDInfo(ctx, payloadCid)
 }
 func (c *StorageMinerStruct) CreateBackup(ctx context.Context, fpath string) error {
 	return c.Internal.CreateBackup(ctx, fpath)
 }
 // WorkerStruct
 func (w *WorkerStruct) Version(ctx context.Context) (build.Version, error) {
@ -1273,63 +1528,213 @@ func (w *WorkerStruct) Info(ctx context.Context) (storiface.WorkerInfo, error) {
 	return w.Internal.Info(ctx)
 }
-func (w *WorkerStruct) AddPiece(ctx context.Context, sector abi.SectorID, pieceSizes []abi.UnpaddedPieceSize, newPieceSize abi.UnpaddedPieceSize, pieceData storage.Data) (abi.PieceInfo, error) {
+func (w *WorkerStruct) AddPiece(ctx context.Context, sector storage.SectorRef, pieceSizes []abi.UnpaddedPieceSize, newPieceSize abi.UnpaddedPieceSize, pieceData storage.Data) (storiface.CallID, error) {
 	return w.Internal.AddPiece(ctx, sector, pieceSizes, newPieceSize, pieceData)
 }
-func (w *WorkerStruct) SealPreCommit1(ctx context.Context, sector abi.SectorID, ticket abi.SealRandomness, pieces []abi.PieceInfo) (storage.PreCommit1Out, error) {
+func (w *WorkerStruct) SealPreCommit1(ctx context.Context, sector storage.SectorRef, ticket abi.SealRandomness, pieces []abi.PieceInfo) (storiface.CallID, error) {
 	return w.Internal.SealPreCommit1(ctx, sector, ticket, pieces)
 }
-func (w *WorkerStruct) SealPreCommit2(ctx context.Context, sector abi.SectorID, p1o storage.PreCommit1Out) (storage.SectorCids, error) {
+func (w *WorkerStruct) SealPreCommit2(ctx context.Context, sector storage.SectorRef, pc1o storage.PreCommit1Out) (storiface.CallID, error) {
-	return w.Internal.SealPreCommit2(ctx, sector, p1o)
+	return w.Internal.SealPreCommit2(ctx, sector, pc1o)
 }
-func (w *WorkerStruct) SealCommit1(ctx context.Context, sector abi.SectorID, ticket abi.SealRandomness, seed abi.InteractiveSealRandomness, pieces []abi.PieceInfo, cids storage.SectorCids) (storage.Commit1Out, error) {
+func (w *WorkerStruct) SealCommit1(ctx context.Context, sector storage.SectorRef, ticket abi.SealRandomness, seed abi.InteractiveSealRandomness, pieces []abi.PieceInfo, cids storage.SectorCids) (storiface.CallID, error) {
 	return w.Internal.SealCommit1(ctx, sector, ticket, seed, pieces, cids)
 }
-func (w *WorkerStruct) SealCommit2(ctx context.Context, sector abi.SectorID, c1o storage.Commit1Out) (storage.Proof, error) {
+func (w *WorkerStruct) SealCommit2(ctx context.Context, sector storage.SectorRef, c1o storage.Commit1Out) (storiface.CallID, error) {
 	return w.Internal.SealCommit2(ctx, sector, c1o)
 }
-func (w *WorkerStruct) FinalizeSector(ctx context.Context, sector abi.SectorID, keepUnsealed []storage.Range) error {
+func (w *WorkerStruct) FinalizeSector(ctx context.Context, sector storage.SectorRef, keepUnsealed []storage.Range) (storiface.CallID, error) {
 	return w.Internal.FinalizeSector(ctx, sector, keepUnsealed)
 }
-func (w *WorkerStruct) ReleaseUnsealed(ctx context.Context, sector abi.SectorID, safeToFree []storage.Range) error {
+func (w *WorkerStruct) ReleaseUnsealed(ctx context.Context, sector storage.SectorRef, safeToFree []storage.Range) (storiface.CallID, error) {
 	return w.Internal.ReleaseUnsealed(ctx, sector, safeToFree)
 }
 func (w *WorkerStruct) MoveStorage(ctx context.Context, sector storage.SectorRef, types storiface.SectorFileType) (storiface.CallID, error) {
 	return w.Internal.MoveStorage(ctx, sector, types)
 }
 func (w *WorkerStruct) UnsealPiece(ctx context.Context, sector storage.SectorRef, offset storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize, ticket abi.SealRandomness, c cid.Cid) (storiface.CallID, error) {
 	return w.Internal.UnsealPiece(ctx, sector, offset, size, ticket, c)
 }
 func (w *WorkerStruct) ReadPiece(ctx context.Context, sink io.Writer, sector storage.SectorRef, offset storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize) (storiface.CallID, error) {
 	return w.Internal.ReadPiece(ctx, sink, sector, offset, size)
 }
 func (w *WorkerStruct) Fetch(ctx context.Context, id storage.SectorRef, fileType storiface.SectorFileType, ptype storiface.PathType, am storiface.AcquireMode) (storiface.CallID, error) {
 	return w.Internal.Fetch(ctx, id, fileType, ptype, am)
 }
 func (w *WorkerStruct) Remove(ctx context.Context, sector abi.SectorID) error {
 	return w.Internal.Remove(ctx, sector)
 }
 func (w *WorkerStruct) MoveStorage(ctx context.Context, sector abi.SectorID, types stores.SectorFileType) error {
 	return w.Internal.MoveStorage(ctx, sector, types)
 }
 func (w *WorkerStruct) StorageAddLocal(ctx context.Context, path string) error {
 	return w.Internal.StorageAddLocal(ctx, path)
 }
-func (w *WorkerStruct) UnsealPiece(ctx context.Context, id abi.SectorID, index storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize, randomness abi.SealRandomness, c cid.Cid) error {
+func (w *WorkerStruct) SetEnabled(ctx context.Context, enabled bool) error {
-	return w.Internal.UnsealPiece(ctx, id, index, size, randomness, c)
+	return w.Internal.SetEnabled(ctx, enabled)
 }
-func (w *WorkerStruct) ReadPiece(ctx context.Context, writer io.Writer, id abi.SectorID, index storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize) (bool, error) {
+func (w *WorkerStruct) Enabled(ctx context.Context) (bool, error) {
-	return w.Internal.ReadPiece(ctx, writer, id, index, size)
+	return w.Internal.Enabled(ctx)
 }
-func (w *WorkerStruct) Fetch(ctx context.Context, id abi.SectorID, fileType stores.SectorFileType, ptype stores.PathType, am stores.AcquireMode) error {
+func (w *WorkerStruct) WaitQuiet(ctx context.Context) error {
-	return w.Internal.Fetch(ctx, id, fileType, ptype, am)
+	return w.Internal.WaitQuiet(ctx)
 }
-func (w *WorkerStruct) Closing(ctx context.Context) (<-chan struct{}, error) {
+func (w *WorkerStruct) ProcessSession(ctx context.Context) (uuid.UUID, error) {
-	return w.Internal.Closing(ctx)
+	return w.Internal.ProcessSession(ctx)
 }
 func (w *WorkerStruct) Session(ctx context.Context) (uuid.UUID, error) {
 	return w.Internal.Session(ctx)
 }
 func (g GatewayStruct) ChainGetBlockMessages(ctx context.Context, c cid.Cid) (*api.BlockMessages, error) {
 	return g.Internal.ChainGetBlockMessages(ctx, c)
 }
 func (g GatewayStruct) ChainGetMessage(ctx context.Context, mc cid.Cid) (*types.Message, error) {
 	return g.Internal.ChainGetMessage(ctx, mc)
 }
 func (g GatewayStruct) ChainGetTipSet(ctx context.Context, tsk types.TipSetKey) (*types.TipSet, error) {
 	return g.Internal.ChainGetTipSet(ctx, tsk)
 }
 func (g GatewayStruct) ChainGetTipSetByHeight(ctx context.Context, h abi.ChainEpoch, tsk types.TipSetKey) (*types.TipSet, error) {
 	return g.Internal.ChainGetTipSetByHeight(ctx, h, tsk)
 }
 func (g GatewayStruct) ChainHasObj(ctx context.Context, c cid.Cid) (bool, error) {
 	return g.Internal.ChainHasObj(ctx, c)
 }
 func (g GatewayStruct) ChainHead(ctx context.Context) (*types.TipSet, error) {
 	return g.Internal.ChainHead(ctx)
 }
 func (g GatewayStruct) ChainNotify(ctx context.Context) (<-chan []*api.HeadChange, error) {
 	return g.Internal.ChainNotify(ctx)
 }
 func (g GatewayStruct) ChainReadObj(ctx context.Context, c cid.Cid) ([]byte, error) {
 	return g.Internal.ChainReadObj(ctx, c)
 }
 func (g GatewayStruct) GasEstimateMessageGas(ctx context.Context, msg *types.Message, spec *api.MessageSendSpec, tsk types.TipSetKey) (*types.Message, error) {
 	return g.Internal.GasEstimateMessageGas(ctx, msg, spec, tsk)
 }
 func (g GatewayStruct) MpoolPush(ctx context.Context, sm *types.SignedMessage) (cid.Cid, error) {
 	return g.Internal.MpoolPush(ctx, sm)
 }
 func (g GatewayStruct) MsigGetAvailableBalance(ctx context.Context, addr address.Address, tsk types.TipSetKey) (types.BigInt, error) {
 	return g.Internal.MsigGetAvailableBalance(ctx, addr, tsk)
 }
 func (g GatewayStruct) MsigGetVested(ctx context.Context, addr address.Address, start types.TipSetKey, end types.TipSetKey) (types.BigInt, error) {
 	return g.Internal.MsigGetVested(ctx, addr, start, end)
 }
 func (g GatewayStruct) StateAccountKey(ctx context.Context, addr address.Address, tsk types.TipSetKey) (address.Address, error) {
 	return g.Internal.StateAccountKey(ctx, addr, tsk)
 }
 func (g GatewayStruct) StateDealProviderCollateralBounds(ctx context.Context, size abi.PaddedPieceSize, verified bool, tsk types.TipSetKey) (api.DealCollateralBounds, error) {
 	return g.Internal.StateDealProviderCollateralBounds(ctx, size, verified, tsk)
 }
 func (g GatewayStruct) StateGetActor(ctx context.Context, actor address.Address, ts types.TipSetKey) (*types.Actor, error) {
 	return g.Internal.StateGetActor(ctx, actor, ts)
 }
 func (g GatewayStruct) StateGetReceipt(ctx context.Context, c cid.Cid, tsk types.TipSetKey) (*types.MessageReceipt, error) {
 	return g.Internal.StateGetReceipt(ctx, c, tsk)
 }
 func (g GatewayStruct) StateLookupID(ctx context.Context, addr address.Address, tsk types.TipSetKey) (address.Address, error) {
 	return g.Internal.StateLookupID(ctx, addr, tsk)
 }
 func (g GatewayStruct) StateListMiners(ctx context.Context, tsk types.TipSetKey) ([]address.Address, error) {
 	return g.Internal.StateListMiners(ctx, tsk)
 }
 func (g GatewayStruct) StateMarketBalance(ctx context.Context, addr address.Address, tsk types.TipSetKey) (api.MarketBalance, error) {
 	return g.Internal.StateMarketBalance(ctx, addr, tsk)
 }
 func (g GatewayStruct) StateMarketStorageDeal(ctx context.Context, dealId abi.DealID, tsk types.TipSetKey) (*api.MarketDeal, error) {
 	return g.Internal.StateMarketStorageDeal(ctx, dealId, tsk)
 }
 func (g GatewayStruct) StateMinerInfo(ctx context.Context, actor address.Address, tsk types.TipSetKey) (miner.MinerInfo, error) {
 	return g.Internal.StateMinerInfo(ctx, actor, tsk)
 }
 func (g GatewayStruct) StateMinerProvingDeadline(ctx context.Context, addr address.Address, tsk types.TipSetKey) (*dline.Info, error) {
 	return g.Internal.StateMinerProvingDeadline(ctx, addr, tsk)
 }
 func (g GatewayStruct) StateMinerPower(ctx context.Context, addr address.Address, tsk types.TipSetKey) (*api.MinerPower, error) {
 	return g.Internal.StateMinerPower(ctx, addr, tsk)
 }
 func (g GatewayStruct) StateNetworkVersion(ctx context.Context, tsk types.TipSetKey) (stnetwork.Version, error) {
 	return g.Internal.StateNetworkVersion(ctx, tsk)
 }
 func (g GatewayStruct) StateVerifiedClientStatus(ctx context.Context, addr address.Address, tsk types.TipSetKey) (*abi.StoragePower, error) {
 	return g.Internal.StateVerifiedClientStatus(ctx, addr, tsk)
 }
 func (g GatewayStruct) StateWaitMsg(ctx context.Context, msg cid.Cid, confidence uint64) (*api.MsgLookup, error) {
 	return g.Internal.StateWaitMsg(ctx, msg, confidence)
 }
 func (c *WalletStruct) WalletNew(ctx context.Context, typ types.KeyType) (address.Address, error) {
 	return c.Internal.WalletNew(ctx, typ)
 }
 func (c *WalletStruct) WalletHas(ctx context.Context, addr address.Address) (bool, error) {
 	return c.Internal.WalletHas(ctx, addr)
 }
 func (c *WalletStruct) WalletList(ctx context.Context) ([]address.Address, error) {
 	return c.Internal.WalletList(ctx)
 }
 func (c *WalletStruct) WalletSign(ctx context.Context, k address.Address, msg []byte, meta api.MsgMeta) (*crypto.Signature, error) {
 	return c.Internal.WalletSign(ctx, k, msg, meta)
 }
 func (c *WalletStruct) WalletExport(ctx context.Context, a address.Address) (*types.KeyInfo, error) {
 	return c.Internal.WalletExport(ctx, a)
 }
 func (c *WalletStruct) WalletImport(ctx context.Context, ki *types.KeyInfo) (address.Address, error) {
 	return c.Internal.WalletImport(ctx, ki)
 }
 func (c *WalletStruct) WalletDelete(ctx context.Context, addr address.Address) error {
 	return c.Internal.WalletDelete(ctx, addr)
 }
 var _ api.Common = &CommonStruct{}
 var _ api.FullNode = &FullNodeStruct{}
 var _ api.StorageMiner = &StorageMinerStruct{}
 var _ api.WorkerAPI = &WorkerStruct{}
 var _ api.GatewayAPI = &GatewayStruct{}
 var _ api.WalletAPI = &WalletStruct{}
--- a/api/client/client.go
+++ b/api/client/client.go
@ -82,3 +82,29 @@ func NewWorkerRPC(ctx context.Context, addr string, requestHeader http.Header) (
 	return &res, closer, err
 }
 // NewGatewayRPC creates a new http jsonrpc client for a gateway node.
 func NewGatewayRPC(ctx context.Context, addr string, requestHeader http.Header, opts ...jsonrpc.Option) (api.GatewayAPI, jsonrpc.ClientCloser, error) {
 	var res apistruct.GatewayStruct
 	closer, err := jsonrpc.NewMergeClient(ctx, addr, "Filecoin",
 		[]interface{}{
 			&res.Internal,
 		},
 		requestHeader,
 		opts...,
 	)
 	return &res, closer, err
 }
 func NewWalletRPC(ctx context.Context, addr string, requestHeader http.Header) (api.WalletAPI, jsonrpc.ClientCloser, error) {
 	var res apistruct.WalletStruct
 	closer, err := jsonrpc.NewMergeClient(ctx, addr, "Filecoin",
 		[]interface{}{
 			&res.Internal,
 		},
 		requestHeader,
 	)
 	return &res, closer, err
 }
--- a/api/docgen/docgen.go
+++ b/api/docgen/docgen.go
@ -6,12 +6,14 @@ import (
 	"go/ast"
 	"go/parser"
 	"go/token"
 	"os"
 	"reflect"
 	"sort"
 	"strings"
 	"time"
 	"unicode"
 	"github.com/google/uuid"
 	"github.com/ipfs/go-cid"
 	"github.com/ipfs/go-filestore"
 	metrics "github.com/libp2p/go-libp2p-core/metrics"
@ -24,6 +26,7 @@ import (
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-bitfield"
 	datatransfer "github.com/filecoin-project/go-data-transfer"
 	filestore2 "github.com/filecoin-project/go-fil-markets/filestore"
 	"github.com/filecoin-project/go-fil-markets/retrievalmarket"
 	"github.com/filecoin-project/go-jsonrpc/auth"
 	"github.com/filecoin-project/go-multistore"
@ -36,6 +39,10 @@ import (
 	"github.com/filecoin-project/lotus/api/apistruct"
 	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/extern/sector-storage/sealtasks"
 	"github.com/filecoin-project/lotus/extern/sector-storage/stores"
 	"github.com/filecoin-project/lotus/extern/sector-storage/storiface"
 	sealing "github.com/filecoin-project/lotus/extern/storage-sealing"
 	"github.com/filecoin-project/lotus/node/modules/dtypes"
 )
@ -83,10 +90,11 @@ func init() {
 	addExample(&pid)
 	addExample(bitfield.NewFromSet([]uint64{5}))
-	addExample(abi.RegisteredSealProof_StackedDrg32GiBV1)
+	addExample(abi.RegisteredSealProof_StackedDrg32GiBV1_1)
 	addExample(abi.RegisteredPoStProof_StackedDrgWindow32GiBV1)
 	addExample(abi.ChainEpoch(10101))
 	addExample(crypto.SigTypeBLS)
 	addExample(types.KTBLS)
 	addExample(int64(9))
 	addExample(12.3)
 	addExample(123)
@ -116,17 +124,17 @@ func init() {
 	addExample(network.ReachabilityPublic)
 	addExample(build.NewestNetworkVersion)
 	addExample(&types.ExecutionTrace{
-		Msg:    exampleValue(reflect.TypeOf(&types.Message{}), nil).(*types.Message),
+		Msg:    exampleValue("init", reflect.TypeOf(&types.Message{}), nil).(*types.Message),
-		MsgRct: exampleValue(reflect.TypeOf(&types.MessageReceipt{}), nil).(*types.MessageReceipt),
+		MsgRct: exampleValue("init", reflect.TypeOf(&types.MessageReceipt{}), nil).(*types.MessageReceipt),
 	})
 	addExample(map[string]types.Actor{
-		"t01236": exampleValue(reflect.TypeOf(types.Actor{}), nil).(types.Actor),
+		"t01236": exampleValue("init", reflect.TypeOf(types.Actor{}), nil).(types.Actor),
 	})
 	addExample(map[string]api.MarketDeal{
-		"t026363": exampleValue(reflect.TypeOf(api.MarketDeal{}), nil).(api.MarketDeal),
+		"t026363": exampleValue("init", reflect.TypeOf(api.MarketDeal{}), nil).(api.MarketDeal),
 	})
 	addExample(map[string]api.MarketBalance{
-		"t026363": exampleValue(reflect.TypeOf(api.MarketBalance{}), nil).(api.MarketBalance),
+		"t026363": exampleValue("init", reflect.TypeOf(api.MarketBalance{}), nil).(api.MarketBalance),
 	})
 	addExample(map[string]*pubsub.TopicScoreSnapshot{
 		"/blocks": {
@ -161,9 +169,81 @@ func init() {
 	// because reflect.TypeOf(maddr) returns the concrete type...
 	ExampleValues[reflect.TypeOf(struct{ A multiaddr.Multiaddr }{}).Field(0).Type] = maddr
 	// miner specific
 	addExample(filestore2.Path(".lotusminer/fstmp123"))
 	si := multistore.StoreID(12)
 	addExample(&si)
 	addExample(retrievalmarket.DealID(5))
 	addExample(abi.ActorID(1000))
 	addExample(map[string][]api.SealedRef{
 		"98000": {
 			api.SealedRef{
 				SectorID: 100,
 				Offset:   10 << 20,
 				Size:     1 << 20,
 			},
 		},
 	})
 	addExample(api.SectorState(sealing.Proving))
 	addExample(stores.ID("76f1988b-ef30-4d7e-b3ec-9a627f4ba5a8"))
 	addExample(storiface.FTUnsealed)
 	addExample(storiface.PathSealing)
 	addExample(map[stores.ID][]stores.Decl{
 		"76f1988b-ef30-4d7e-b3ec-9a627f4ba5a8": {
 			{
 				SectorID:       abi.SectorID{Miner: 1000, Number: 100},
 				SectorFileType: storiface.FTSealed,
 			},
 		},
 	})
 	addExample(map[stores.ID]string{
 		"76f1988b-ef30-4d7e-b3ec-9a627f4ba5a8": "/data/path",
 	})
 	addExample(map[uuid.UUID][]storiface.WorkerJob{
 		uuid.MustParse("ef8d99a2-6865-4189-8ffa-9fef0f806eee"): {
 			{
 				ID: storiface.CallID{
 					Sector: abi.SectorID{Miner: 1000, Number: 100},
 					ID:     uuid.MustParse("76081ba0-61bd-45a5-bc08-af05f1c26e5d"),
 				},
 				Sector:   abi.SectorID{Miner: 1000, Number: 100},
 				Task:     sealtasks.TTPreCommit2,
 				RunWait:  0,
 				Start:    time.Unix(1605172927, 0).UTC(),
 				Hostname: "host",
 			},
 		},
 	})
 	addExample(map[uuid.UUID]storiface.WorkerStats{
 		uuid.MustParse("ef8d99a2-6865-4189-8ffa-9fef0f806eee"): {
 			Info: storiface.WorkerInfo{
 				Hostname: "host",
 				Resources: storiface.WorkerResources{
 					MemPhysical: 256 << 30,
 					MemSwap:     120 << 30,
 					MemReserved: 2 << 30,
 					CPUs:        64,
 					GPUs:        []string{"aGPU 1337"},
 				},
 			},
 			Enabled:    true,
 			MemUsedMin: 0,
 			MemUsedMax: 0,
 			GpuUsed:    false,
 			CpuUse:     0,
 		},
 	})
 	addExample(storiface.ErrorCode(0))
 	// worker specific
 	addExample(storiface.AcquireMove)
 	addExample(storiface.UnpaddedByteIndex(abi.PaddedPieceSize(1 << 20).Unpadded()))
 	addExample(map[sealtasks.TaskType]struct{}{
 		sealtasks.TTPreCommit2: {},
 	})
 }
-func exampleValue(t, parent reflect.Type) interface{} {
+func exampleValue(method string, t, parent reflect.Type) interface{} {
 	v, ok := ExampleValues[t]
 	if ok {
 		return v
@ -172,25 +252,25 @@ func exampleValue(t, parent reflect.Type) interface{} {
 	switch t.Kind() {
 	case reflect.Slice:
 		out := reflect.New(t).Elem()
-		reflect.Append(out, reflect.ValueOf(exampleValue(t.Elem(), t)))
+		reflect.Append(out, reflect.ValueOf(exampleValue(method, t.Elem(), t)))
 		return out.Interface()
 	case reflect.Chan:
-		return exampleValue(t.Elem(), nil)
+		return exampleValue(method, t.Elem(), nil)
 	case reflect.Struct:
-		es := exampleStruct(t, parent)
+		es := exampleStruct(method, t, parent)
 		v := reflect.ValueOf(es).Elem().Interface()
 		ExampleValues[t] = v
 		return v
 	case reflect.Array:
 		out := reflect.New(t).Elem()
 		for i := 0; i < t.Len(); i++ {
-			out.Index(i).Set(reflect.ValueOf(exampleValue(t.Elem(), t)))
+			out.Index(i).Set(reflect.ValueOf(exampleValue(method, t.Elem(), t)))
 		}
 		return out.Interface()
 	case reflect.Ptr:
 		if t.Elem().Kind() == reflect.Struct {
-			es := exampleStruct(t.Elem(), t)
+			es := exampleStruct(method, t.Elem(), t)
 			//ExampleValues[t] = es
 			return es
 		}
@ -198,10 +278,10 @@ func exampleValue(t, parent reflect.Type) interface{} {
 		return struct{}{}
 	}
-	panic(fmt.Sprintf("No example value for type: %s", t))
+	panic(fmt.Sprintf("No example value for type: %s (method '%s')", t, method))
 }
-func exampleStruct(t, parent reflect.Type) interface{} {
+func exampleStruct(method string, t, parent reflect.Type) interface{} {
 	ns := reflect.New(t)
 	for i := 0; i < t.NumField(); i++ {
 		f := t.Field(i)
@ -209,7 +289,7 @@ func exampleStruct(t, parent reflect.Type) interface{} {
 			continue
 		}
 		if strings.Title(f.Name) == f.Name {
-			ns.Elem().Field(i).Set(reflect.ValueOf(exampleValue(f.Type, t)))
+			ns.Elem().Field(i).Set(reflect.ValueOf(exampleValue(method, f.Type, t)))
 		}
 	}
@ -217,6 +297,7 @@ func exampleStruct(t, parent reflect.Type) interface{} {
 }
 type Visitor struct {
 	Root    string
 	Methods map[string]ast.Node
 }
@ -226,7 +307,7 @@ func (v *Visitor) Visit(node ast.Node) ast.Visitor {
 		return v
 	}
-	if st.Name.Name != "FullNode" {
+	if st.Name.Name != v.Root {
 		return nil
 	}
@ -242,7 +323,7 @@ func (v *Visitor) Visit(node ast.Node) ast.Visitor {
 const noComment = "There are not yet any comments for this method."
-func parseApiASTInfo() (map[string]string, map[string]string) { //nolint:golint
+func parseApiASTInfo(apiFile, iface string) (map[string]string, map[string]string) { //nolint:golint
 	fset := token.NewFileSet()
 	pkgs, err := parser.ParseDir(fset, "./api", nil, parser.AllErrors|parser.ParseComments)
 	if err != nil {
@ -251,11 +332,11 @@ func parseApiASTInfo() (map[string]string, map[string]string) { //nolint:golint
 	ap := pkgs["api"]
-	f := ap.Files["api/api_full.go"]
+	f := ap.Files[apiFile]
 	cmap := ast.NewCommentMap(fset, f, f.Comments)
-	v := &Visitor{make(map[string]ast.Node)}
+	v := &Visitor{iface, make(map[string]ast.Node)}
 	ast.Walk(v, pkgs["api"])
 	groupDocs := make(map[string]string)
@ -311,13 +392,30 @@ func methodGroupFromName(mn string) string {
 }
 func main() {
-
+	comments, groupComments := parseApiASTInfo(os.Args[1], os.Args[2])
 	comments, groupComments := parseApiASTInfo()
 	groups := make(map[string]*MethodGroup)
-	var api struct{ api.FullNode }
+	var t reflect.Type
-	t := reflect.TypeOf(api)
+	var permStruct, commonPermStruct reflect.Type
 	switch os.Args[2] {
 	case "FullNode":
 		t = reflect.TypeOf(new(struct{ api.FullNode })).Elem()
 		permStruct = reflect.TypeOf(apistruct.FullNodeStruct{}.Internal)
 		commonPermStruct = reflect.TypeOf(apistruct.CommonStruct{}.Internal)
 	case "StorageMiner":
 		t = reflect.TypeOf(new(struct{ api.StorageMiner })).Elem()
 		permStruct = reflect.TypeOf(apistruct.StorageMinerStruct{}.Internal)
 		commonPermStruct = reflect.TypeOf(apistruct.CommonStruct{}.Internal)
 	case "WorkerAPI":
 		t = reflect.TypeOf(new(struct{ api.WorkerAPI })).Elem()
 		permStruct = reflect.TypeOf(apistruct.WorkerStruct{}.Internal)
 		commonPermStruct = reflect.TypeOf(apistruct.WorkerStruct{}.Internal)
 	default:
 		panic("unknown type")
 	}
 	for i := 0; i < t.NumMethod(); i++ {
 		m := t.Method(i)
@ -335,7 +433,7 @@ func main() {
 		ft := m.Func.Type()
 		for j := 2; j < ft.NumIn(); j++ {
 			inp := ft.In(j)
-			args = append(args, exampleValue(inp, nil))
+			args = append(args, exampleValue(m.Name, inp, nil))
 		}
 		v, err := json.MarshalIndent(args, "", "  ")
@ -343,7 +441,7 @@ func main() {
 			panic(err)
 		}
-		outv := exampleValue(ft.Out(0), nil)
+		outv := exampleValue(m.Name, ft.Out(0), nil)
 		ov, err := json.MarshalIndent(outv, "", "  ")
 		if err != nil {
@ -376,9 +474,6 @@ func main() {
 		}
 	}
 	permStruct := reflect.TypeOf(apistruct.FullNodeStruct{}.Internal)
 	commonPermStruct := reflect.TypeOf(apistruct.CommonStruct{}.Internal)
 	for _, g := range groupslice {
 		g := g
 		fmt.Printf("## %s\n", g.GroupName)
--- a/api/test/blockminer.go
+++ b/api/test/blockminer.go
@ -37,7 +37,12 @@ func (bm *BlockMiner) MineBlocks() {
 	go func() {
 		defer close(bm.done)
 		for atomic.LoadInt64(&bm.mine) == 1 {
-			time.Sleep(bm.blocktime)
+			select {
 			case <-bm.ctx.Done():
 				return
 			case <-time.After(bm.blocktime):
 			}
 			nulls := atomic.SwapInt64(&bm.nulls, 0)
 			if err := bm.miner.MineOne(bm.ctx, miner.MineReq{
 				InjectNulls: abi.ChainEpoch(nulls),
--- a/api/test/ccupgrade.go
+++ b/api/test/ccupgrade.go
@ -3,7 +3,6 @@ package test
 import (
 	"context"
 	"fmt"
 	"os"
 	"sync/atomic"
 	"testing"
 	"time"
@ -17,10 +16,22 @@ import (
 )
 func TestCCUpgrade(t *testing.T, b APIBuilder, blocktime time.Duration) {
-	_ = os.Setenv("BELLMAN_NO_GPU", "1")
+	for _, height := range []abi.ChainEpoch{
 		1,    // before
 		162,  // while sealing
 		520,  // after upgrade deal
 		5000, // after
 	} {
 		height := height // make linters happy by copying
 		t.Run(fmt.Sprintf("upgrade-%d", height), func(t *testing.T) {
 			testCCUpgrade(t, b, blocktime, height)
 		})
 	}
 }
 func testCCUpgrade(t *testing.T, b APIBuilder, blocktime time.Duration, upgradeHeight abi.ChainEpoch) {
 	ctx := context.Background()
-	n, sn := b(t, 1, OneMiner)
+	n, sn := b(t, []FullNodeOpts{FullNodeWithActorsV2At(upgradeHeight)}, OneMiner)
 	client := n[0].FullNode.(*impl.FullNodeAPI)
 	miner := sn[0]
@ -78,7 +89,7 @@ func TestCCUpgrade(t *testing.T, b APIBuilder, blocktime time.Duration) {
 		t.Fatal(err)
 	}
-	makeDeal(t, ctx, 6, client, miner, false, false)
+	MakeDeal(t, ctx, 6, client, miner, false, false)
 	// Validate upgrade
@ -94,6 +105,22 @@ func TestCCUpgrade(t *testing.T, b APIBuilder, blocktime time.Duration) {
 		require.Less(t, 50000, int(exp.OnTime))
 	}
 	dlInfo, err := client.StateMinerProvingDeadline(ctx, maddr, types.EmptyTSK)
 	require.NoError(t, err)
 	// Sector should expire.
 	for {
 		// Wait for the sector to expire.
 		status, err := miner.SectorsStatus(ctx, CC, true)
 		require.NoError(t, err)
 		if status.OnTime == 0 && status.Early == 0 {
 			break
 		}
 		t.Log("waiting for sector to expire")
 		// wait one deadline per loop.
 		time.Sleep(time.Duration(dlInfo.WPoStChallengeWindow) * blocktime)
 	}
 	fmt.Println("shutting down mining")
 	atomic.AddInt64(&mine, -1)
 	<-done
--- a/api/test/deals.go
+++ b/api/test/deals.go
@ -16,15 +16,12 @@ import (
 	"github.com/ipfs/go-cid"
 	files "github.com/ipfs/go-ipfs-files"
 	logging "github.com/ipfs/go-log/v2"
 	"github.com/ipld/go-car"
 	"github.com/filecoin-project/go-fil-markets/storagemarket"
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/build"
 	sealing "github.com/filecoin-project/lotus/extern/storage-sealing"
 	"github.com/filecoin-project/lotus/miner"
 	dag "github.com/ipfs/go-merkledag"
 	dstest "github.com/ipfs/go-merkledag/test"
 	unixfile "github.com/ipfs/go-unixfs/file"
@ -34,21 +31,10 @@ import (
 	ipld "github.com/ipfs/go-ipld-format"
 )
 var MineNext = miner.MineReq{
 	InjectNulls: 0,
 	Done:        func(bool, abi.ChainEpoch, error) {},
 }
 func init() {
 	logging.SetAllLoggers(logging.LevelInfo)
 	build.InsecurePoStValidation = true
 }
 func TestDealFlow(t *testing.T, b APIBuilder, blocktime time.Duration, carExport, fastRet bool) {
 	_ = os.Setenv("BELLMAN_NO_GPU", "1")
 	ctx := context.Background()
-	n, sn := b(t, 1, OneMiner)
+	n, sn := b(t, OneFull, OneMiner)
 	client := n[0].FullNode.(*impl.FullNodeAPI)
 	miner := sn[0]
@ -74,7 +60,7 @@ func TestDealFlow(t *testing.T, b APIBuilder, blocktime time.Duration, carExport
 		}
 	}()
-	makeDeal(t, ctx, 6, client, miner, carExport, fastRet)
+	MakeDeal(t, ctx, 6, client, miner, carExport, fastRet)
 	atomic.AddInt64(&mine, -1)
 	fmt.Println("shutting down mining")
@ -82,10 +68,9 @@ func TestDealFlow(t *testing.T, b APIBuilder, blocktime time.Duration, carExport
 }
 func TestDoubleDealFlow(t *testing.T, b APIBuilder, blocktime time.Duration) {
 	_ = os.Setenv("BELLMAN_NO_GPU", "1")
 	ctx := context.Background()
-	n, sn := b(t, 1, OneMiner)
+	n, sn := b(t, OneFull, OneMiner)
 	client := n[0].FullNode.(*impl.FullNodeAPI)
 	miner := sn[0]
@ -112,24 +97,21 @@ func TestDoubleDealFlow(t *testing.T, b APIBuilder, blocktime time.Duration) {
 		}
 	}()
-	makeDeal(t, ctx, 6, client, miner, false, false)
+	MakeDeal(t, ctx, 6, client, miner, false, false)
-	makeDeal(t, ctx, 7, client, miner, false, false)
+	MakeDeal(t, ctx, 7, client, miner, false, false)
 	atomic.AddInt64(&mine, -1)
 	fmt.Println("shutting down mining")
 	<-done
 }
-func makeDeal(t *testing.T, ctx context.Context, rseed int, client *impl.FullNodeAPI, miner TestStorageNode, carExport, fastRet bool) {
+func MakeDeal(t *testing.T, ctx context.Context, rseed int, client api.FullNode, miner TestStorageNode, carExport, fastRet bool) {
-	data := make([]byte, 1600)
+	res, data, err := CreateClientFile(ctx, client, rseed)
 	rand.New(rand.NewSource(int64(rseed))).Read(data)
 	r := bytes.NewReader(data)
 	fcid, err := client.ClientImportLocal(ctx, r)
 	if err != nil {
 		t.Fatal(err)
 	}
 	fcid := res.Root
 	fmt.Println("FILE CID: ", fcid)
 	deal := startDeal(t, ctx, miner, client, fcid, fastRet)
@ -145,11 +127,32 @@ func makeDeal(t *testing.T, ctx context.Context, rseed int, client *impl.FullNod
 	testRetrieval(t, ctx, client, fcid, &info.PieceCID, carExport, data)
 }
 func CreateClientFile(ctx context.Context, client api.FullNode, rseed int) (*api.ImportRes, []byte, error) {
 	data := make([]byte, 1600)
 	rand.New(rand.NewSource(int64(rseed))).Read(data)
 	dir, err := ioutil.TempDir(os.TempDir(), "test-make-deal-")
 	if err != nil {
 		return nil, nil, err
 	}
 	path := filepath.Join(dir, "sourcefile.dat")
 	err = ioutil.WriteFile(path, data, 0644)
 	if err != nil {
 		return nil, nil, err
 	}
 	res, err := client.ClientImport(ctx, api.FileRef{Path: path})
 	if err != nil {
 		return nil, nil, err
 	}
 	return res, data, nil
 }
 func TestFastRetrievalDealFlow(t *testing.T, b APIBuilder, blocktime time.Duration) {
 	_ = os.Setenv("BELLMAN_NO_GPU", "1")
 	ctx := context.Background()
-	n, sn := b(t, 1, OneMiner)
+	n, sn := b(t, OneFull, OneMiner)
 	client := n[0].FullNode.(*impl.FullNodeAPI)
 	miner := sn[0]
@ -201,10 +204,9 @@ func TestFastRetrievalDealFlow(t *testing.T, b APIBuilder, blocktime time.Durati
 }
 func TestSenondDealRetrieval(t *testing.T, b APIBuilder, blocktime time.Duration) {
 	_ = os.Setenv("BELLMAN_NO_GPU", "1")
 	ctx := context.Background()
-	n, sn := b(t, 1, OneMiner)
+	n, sn := b(t, OneFull, OneMiner)
 	client := n[0].FullNode.(*impl.FullNodeAPI)
 	miner := sn[0]
@ -276,7 +278,7 @@ func TestSenondDealRetrieval(t *testing.T, b APIBuilder, blocktime time.Duration
 	<-done
 }
-func startDeal(t *testing.T, ctx context.Context, miner TestStorageNode, client *impl.FullNodeAPI, fcid cid.Cid, fastRet bool) *cid.Cid {
+func startDeal(t *testing.T, ctx context.Context, miner TestStorageNode, client api.FullNode, fcid cid.Cid, fastRet bool) *cid.Cid {
 	maddr, err := miner.ActorAddress(ctx)
 	if err != nil {
 		t.Fatal(err)
@ -303,7 +305,7 @@ func startDeal(t *testing.T, ctx context.Context, miner TestStorageNode, client
 	return deal
 }
-func waitDealSealed(t *testing.T, ctx context.Context, miner TestStorageNode, client *impl.FullNodeAPI, deal *cid.Cid, noseal bool) {
+func waitDealSealed(t *testing.T, ctx context.Context, miner TestStorageNode, client api.FullNode, deal *cid.Cid, noseal bool) {
 loop:
 	for {
 		di, err := client.ClientGetDealInfo(ctx, *deal)
@ -376,7 +378,7 @@ func startSealingWaiting(t *testing.T, ctx context.Context, miner TestStorageNod
 	}
 }
-func testRetrieval(t *testing.T, ctx context.Context, client *impl.FullNodeAPI, fcid cid.Cid, piece *cid.Cid, carExport bool, data []byte) {
+func testRetrieval(t *testing.T, ctx context.Context, client api.FullNode, fcid cid.Cid, piece *cid.Cid, carExport bool, data []byte) {
 	offers, err := client.ClientFindData(ctx, fcid, piece)
 	if err != nil {
 		t.Fatal(err)
@ -402,9 +404,12 @@ func testRetrieval(t *testing.T, ctx context.Context, client *impl.FullNodeAPI,
 		IsCAR: carExport,
 	}
 	updates, err := client.ClientRetrieveWithEvents(ctx, offers[0].Order(caddr), ref)
 	if err != nil {
 		t.Fatal(err)
 	}
 	for update := range updates {
 		if update.Err != "" {
-			t.Fatalf("%v", err)
+			t.Fatalf("retrieval failed: %s", update.Err)
 		}
 	}
--- a/api/test/mining.go
+++ b/api/test/mining.go
@ -5,7 +5,6 @@ import (
 	"context"
 	"fmt"
 	"math/rand"
 	"os"
 	"sync/atomic"
 	"testing"
 	"time"
@ -25,7 +24,7 @@ var log = logging.Logger("apitest")
 func (ts *testSuite) testMining(t *testing.T) {
 	ctx := context.Background()
-	apis, sn := ts.makeNodes(t, 1, OneMiner)
+	apis, sn := ts.makeNodes(t, OneFull, OneMiner)
 	api := apis[0]
 	newHeads, err := api.ChainNotify(ctx)
@ -54,19 +53,16 @@ func (ts *testSuite) testMiningReal(t *testing.T) {
 	}()
 	ctx := context.Background()
-	apis, sn := ts.makeNodes(t, 1, OneMiner)
+	apis, sn := ts.makeNodes(t, OneFull, OneMiner)
 	api := apis[0]
 	newHeads, err := api.ChainNotify(ctx)
 	require.NoError(t, err)
-	initHead := (<-newHeads)[0]
+	at := (<-newHeads)[0].Val.Height()
 	if initHead.Val.Height() != 2 {
 		<-newHeads
 	}
 	h1, err := api.ChainHead(ctx)
 	require.NoError(t, err)
-	require.Equal(t, abi.ChainEpoch(2), h1.Height())
+	require.Equal(t, int64(at), int64(h1.Height()))
 	MineUntilBlock(ctx, t, apis[0], sn[0], nil)
 	require.NoError(t, err)
@ -75,25 +71,23 @@ func (ts *testSuite) testMiningReal(t *testing.T) {
 	h2, err := api.ChainHead(ctx)
 	require.NoError(t, err)
-	require.Equal(t, abi.ChainEpoch(3), h2.Height())
+	require.Greater(t, int64(h2.Height()), int64(h1.Height()))
 	MineUntilBlock(ctx, t, apis[0], sn[0], nil)
 	require.NoError(t, err)
 	<-newHeads
-	h2, err = api.ChainHead(ctx)
+	h3, err := api.ChainHead(ctx)
 	require.NoError(t, err)
-	require.Equal(t, abi.ChainEpoch(4), h2.Height())
+	require.Greater(t, int64(h3.Height()), int64(h2.Height()))
 }
 func TestDealMining(t *testing.T, b APIBuilder, blocktime time.Duration, carExport bool) {
 	_ = os.Setenv("BELLMAN_NO_GPU", "1")
 	// test making a deal with a fresh miner, and see if it starts to mine
 	ctx := context.Background()
-	n, sn := b(t, 1, []StorageMiner{
+	n, sn := b(t, OneFull, []StorageMiner{
 		{Full: 0, Preseal: PresealGenesis},
 		{Full: 0, Preseal: 0}, // TODO: Add support for miners on non-first full node
 	})
--- a/api/test/paych.go
+++ b/api/test/paych.go
@ -3,33 +3,32 @@ package test
 import (
 	"context"
 	"fmt"
 	"os"
 	"sync/atomic"
 	"testing"
 	"time"
 	"github.com/filecoin-project/specs-actors/actors/builtin"
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/big"
 	"github.com/filecoin-project/specs-actors/actors/builtin/paych"
 	"github.com/ipfs/go-cid"
 	"github.com/filecoin-project/go-address"
 	cbor "github.com/ipfs/go-ipld-cbor"
 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/api/apibstore"
 	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain/actors/adt"
 	"github.com/filecoin-project/lotus/chain/actors/builtin"
 	"github.com/filecoin-project/lotus/chain/actors/builtin/paych"
 	"github.com/filecoin-project/lotus/chain/actors/policy"
 	"github.com/filecoin-project/lotus/chain/events"
 	"github.com/filecoin-project/lotus/chain/events/state"
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/chain/wallet"
 )
 func TestPaymentChannels(t *testing.T, b APIBuilder, blocktime time.Duration) {
 	_ = os.Setenv("BELLMAN_NO_GPU", "1")
 	ctx := context.Background()
-	n, sn := b(t, 2, OneMiner)
+	n, sn := b(t, TwoFull, OneMiner)
 	paymentCreator := n[0]
 	paymentReceiver := n[1]
@ -54,7 +53,7 @@ func TestPaymentChannels(t *testing.T, b APIBuilder, blocktime time.Duration) {
 	bm.MineBlocks()
 	// send some funds to register the receiver
-	receiverAddr, err := paymentReceiver.WalletNew(ctx, wallet.ActSigType("secp256k1"))
+	receiverAddr, err := paymentReceiver.WalletNew(ctx, types.KTSecp256k1)
 	if err != nil {
 		t.Fatal(err)
 	}
@ -67,7 +66,7 @@ func TestPaymentChannels(t *testing.T, b APIBuilder, blocktime time.Duration) {
 		t.Fatal(err)
 	}
-	channelAmt := int64(100000)
+	channelAmt := int64(7000)
 	channelInfo, err := paymentCreator.PaychGet(ctx, createrAddr, receiverAddr, abi.NewTokenAmount(channelAmt))
 	if err != nil {
 		t.Fatal(err)
@ -133,17 +132,26 @@ func TestPaymentChannels(t *testing.T, b APIBuilder, blocktime time.Duration) {
 		t.Fatal("Unable to settle payment channel")
 	}
 	creatorStore := adt.WrapStore(ctx, cbor.NewCborStore(apibstore.NewAPIBlockstore(paymentCreator)))
 	// wait for the receiver to submit their vouchers
 	ev := events.NewEvents(ctx, paymentCreator)
 	preds := state.NewStatePredicates(paymentCreator)
 	finished := make(chan struct{})
 	err = ev.StateChanged(func(ts *types.TipSet) (done bool, more bool, err error) {
-		act, err := paymentCreator.StateReadState(ctx, channel, ts.Key())
+		act, err := paymentCreator.StateGetActor(ctx, channel, ts.Key())
 		if err != nil {
 			return false, false, err
 		}
-		state := act.State.(paych.State)
+		state, err := paych.Load(creatorStore, act)
-		if state.ToSend.GreaterThanEqual(abi.NewTokenAmount(6000)) {
+		if err != nil {
 			return false, false, err
 		}
 		toSend, err := state.ToSend()
 		if err != nil {
 			return false, false, err
 		}
 		if toSend.GreaterThanEqual(abi.NewTokenAmount(6000)) {
 			return true, false, nil
 		}
 		return false, true, nil
@ -156,7 +164,7 @@ func TestPaymentChannels(t *testing.T, b APIBuilder, blocktime time.Duration) {
 		return true, nil
 	}, func(ctx context.Context, ts *types.TipSet) error {
 		return nil
-	}, int(build.MessageConfidence)+1, build.SealRandomnessLookbackLimit, func(oldTs, newTs *types.TipSet) (bool, events.StateChange, error) {
+	}, int(build.MessageConfidence)+1, build.Finality, func(oldTs, newTs *types.TipSet) (bool, events.StateChange, error) {
 		return preds.OnPaymentChannelActorChanged(channel, preds.OnToSendAmountChanges())(ctx, oldTs.Key(), newTs.Key())
 	})
 	if err != nil {
@ -169,8 +177,53 @@ func TestPaymentChannels(t *testing.T, b APIBuilder, blocktime time.Duration) {
 		t.Fatal("Timed out waiting for receiver to submit vouchers")
 	}
 	// Create a new voucher now that some vouchers have already been submitted
 	vouchRes, err := paymentCreator.PaychVoucherCreate(ctx, channel, abi.NewTokenAmount(1000), 3)
 	if err != nil {
 		t.Fatal(err)
 	}
 	if vouchRes.Voucher == nil {
 		t.Fatal(fmt.Errorf("Not enough funds to create voucher: missing %d", vouchRes.Shortfall))
 	}
 	vdelta, err := paymentReceiver.PaychVoucherAdd(ctx, channel, vouchRes.Voucher, nil, abi.NewTokenAmount(1000))
 	if err != nil {
 		t.Fatal(err)
 	}
 	if !vdelta.Equals(abi.NewTokenAmount(1000)) {
 		t.Fatal("voucher didn't have the right amount")
 	}
 	// Create a new voucher whose value would exceed the channel balance
 	excessAmt := abi.NewTokenAmount(1000)
 	vouchRes, err = paymentCreator.PaychVoucherCreate(ctx, channel, excessAmt, 4)
 	if err != nil {
 		t.Fatal(err)
 	}
 	if vouchRes.Voucher != nil {
 		t.Fatal("Expected not to be able to create voucher whose value would exceed channel balance")
 	}
 	if !vouchRes.Shortfall.Equals(excessAmt) {
 		t.Fatal(fmt.Errorf("Expected voucher shortfall of %d, got %d", excessAmt, vouchRes.Shortfall))
 	}
 	// Add a voucher whose value would exceed the channel balance
 	vouch := &paych.SignedVoucher{ChannelAddr: channel, Amount: excessAmt, Lane: 4, Nonce: 1}
 	vb, err := vouch.SigningBytes()
 	if err != nil {
 		t.Fatal(err)
 	}
 	sig, err := paymentCreator.WalletSign(ctx, createrAddr, vb)
 	if err != nil {
 		t.Fatal(err)
 	}
 	vouch.Signature = sig
 	_, err = paymentReceiver.PaychVoucherAdd(ctx, channel, vouch, nil, abi.NewTokenAmount(1000))
 	if err == nil {
 		t.Fatal(fmt.Errorf("Expected shortfall error of %d", excessAmt))
 	}
 	// wait for the settlement period to pass before collecting
-	waitForBlocks(ctx, t, bm, paymentReceiver, receiverAddr, paych.SettleDelay)
+	waitForBlocks(ctx, t, bm, paymentReceiver, receiverAddr, policy.PaychSettleDelay)
 	creatorPreCollectBalance, err := paymentCreator.WalletBalance(ctx, createrAddr)
 	if err != nil {
--- a/api/test/tape.go
+++ b/api/test/tape.go
@ -0,0 +1,114 @@
 package test
 import (
 	"context"
 	"fmt"
 	"testing"
 	"time"
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/network"
 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain/stmgr"
 	sealing "github.com/filecoin-project/lotus/extern/storage-sealing"
 	"github.com/filecoin-project/lotus/node"
 	"github.com/filecoin-project/lotus/node/impl"
 	"github.com/stretchr/testify/require"
 )
 func TestTapeFix(t *testing.T, b APIBuilder, blocktime time.Duration) {
 	t.Run("before", func(t *testing.T) { testTapeFix(t, b, blocktime, false) })
 	t.Run("after", func(t *testing.T) { testTapeFix(t, b, blocktime, true) })
 }
 func testTapeFix(t *testing.T, b APIBuilder, blocktime time.Duration, after bool) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 	upgradeSchedule := stmgr.UpgradeSchedule{{
 		Network:   build.ActorUpgradeNetworkVersion,
 		Height:    1,
 		Migration: stmgr.UpgradeActorsV2,
 	}}
 	if after {
 		upgradeSchedule = append(upgradeSchedule, stmgr.Upgrade{
 			Network: network.Version5,
 			Height:  2,
 		})
 	}
 	n, sn := b(t, []FullNodeOpts{{Opts: func(_ []TestNode) node.Option {
 		return node.Override(new(stmgr.UpgradeSchedule), upgradeSchedule)
 	}}}, OneMiner)
 	client := n[0].FullNode.(*impl.FullNodeAPI)
 	miner := sn[0]
 	addrinfo, err := client.NetAddrsListen(ctx)
 	if err != nil {
 		t.Fatal(err)
 	}
 	if err := miner.NetConnect(ctx, addrinfo); err != nil {
 		t.Fatal(err)
 	}
 	build.Clock.Sleep(time.Second)
 	done := make(chan struct{})
 	go func() {
 		defer close(done)
 		for ctx.Err() == nil {
 			build.Clock.Sleep(blocktime)
 			if err := sn[0].MineOne(ctx, MineNext); err != nil {
 				if ctx.Err() != nil {
 					// context was canceled, ignore the error.
 					return
 				}
 				t.Error(err)
 			}
 		}
 	}()
 	defer func() {
 		cancel()
 		<-done
 	}()
 	err = miner.PledgeSector(ctx)
 	require.NoError(t, err)
 	// Wait till done.
 	var sectorNo abi.SectorNumber
 	for {
 		s, err := miner.SectorsList(ctx) // Note - the test builder doesn't import genesis sectors into FSM
 		require.NoError(t, err)
 		fmt.Printf("Sectors: %d\n", len(s))
 		if len(s) == 1 {
 			sectorNo = s[0]
 			break
 		}
 		build.Clock.Sleep(100 * time.Millisecond)
 	}
 	fmt.Printf("All sectors is fsm\n")
 	// If before, we expect the precommit to fail
 	successState := api.SectorState(sealing.CommitFailed)
 	failureState := api.SectorState(sealing.Proving)
 	if after {
 		// otherwise, it should succeed.
 		successState, failureState = failureState, successState
 	}
 	for {
 		st, err := miner.SectorsStatus(ctx, sectorNo, false)
 		require.NoError(t, err)
 		if st.State == successState {
 			break
 		}
 		require.NotEqual(t, failureState, st.State)
 		build.Clock.Sleep(100 * time.Millisecond)
 		fmt.Println("WaitSeal")
 	}
 }
--- a/api/test/test.go
+++ b/api/test/test.go
@ -2,18 +2,38 @@ package test
 import (
 	"context"
 	"fmt"
 	"os"
 	"testing"
 	"time"
 	"github.com/filecoin-project/lotus/chain/stmgr"
 	"github.com/filecoin-project/lotus/chain/types"
 	logging "github.com/ipfs/go-log/v2"
 	"github.com/multiformats/go-multiaddr"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/big"
 	"github.com/filecoin-project/go-state-types/network"
 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/miner"
 	"github.com/filecoin-project/lotus/node"
 )
 func init() {
 	logging.SetAllLoggers(logging.LevelInfo)
 	err := os.Setenv("BELLMAN_NO_GPU", "1")
 	if err != nil {
 		panic(fmt.Sprintf("failed to set BELLMAN_NO_GPU env variable: %s", err))
 	}
 	build.InsecurePoStValidation = true
 }
 type TestNode struct {
 	api.FullNode
 	// ListenAddr is the address on which an API server is listening, if an
@ -34,17 +54,27 @@ var PresealGenesis = -1
 const GenesisPreseals = 2
 // Options for setting up a mock storage miner
 type StorageMiner struct {
 	Full    int
 	Preseal int
 }
 type OptionGenerator func([]TestNode) node.Option
 // Options for setting up a mock full node
 type FullNodeOpts struct {
 	Lite bool            // run node in "lite" mode
 	Opts OptionGenerator // generate dependency injection options
 }
 // APIBuilder is a function which is invoked in test suite to provide
 // test nodes and networks
 //
 // fullOpts array defines options for each full node
 // storage array defines storage nodes, numbers in the array specify full node
 // index the storage node 'belongs' to
-type APIBuilder func(t *testing.T, nFull int, storage []StorageMiner) ([]TestNode, []TestStorageNode)
+type APIBuilder func(t *testing.T, full []FullNodeOpts, storage []StorageMiner) ([]TestNode, []TestStorageNode)
 type testSuite struct {
 	makeNodes APIBuilder
 }
@ -60,15 +90,67 @@ func TestApis(t *testing.T, b APIBuilder) {
 	t.Run("testConnectTwo", ts.testConnectTwo)
 	t.Run("testMining", ts.testMining)
 	t.Run("testMiningReal", ts.testMiningReal)
 	t.Run("testSearchMsg", ts.testSearchMsg)
 }
 func DefaultFullOpts(nFull int) []FullNodeOpts {
 	full := make([]FullNodeOpts, nFull)
 	for i := range full {
 		full[i] = FullNodeOpts{
 			Opts: func(nodes []TestNode) node.Option {
 				return node.Options()
 			},
 		}
 	}
 	return full
 }
 var OneMiner = []StorageMiner{{Full: 0, Preseal: PresealGenesis}}
 var OneFull = DefaultFullOpts(1)
 var TwoFull = DefaultFullOpts(2)
 var FullNodeWithActorsV2At = func(upgradeHeight abi.ChainEpoch) FullNodeOpts {
 	return FullNodeOpts{
 		Opts: func(nodes []TestNode) node.Option {
 			return node.Override(new(stmgr.UpgradeSchedule), stmgr.UpgradeSchedule{{
 				// Skip directly to tape height so precommits work.
 				Network:   network.Version5,
 				Height:    upgradeHeight,
 				Migration: stmgr.UpgradeActorsV2,
 			}})
 		},
 	}
 }
 var FullNodeWithSDRAt = func(calico, persian abi.ChainEpoch) FullNodeOpts {
 	return FullNodeOpts{
 		Opts: func(nodes []TestNode) node.Option {
 			return node.Override(new(stmgr.UpgradeSchedule), stmgr.UpgradeSchedule{{
 				Network:   network.Version6,
 				Height:    1,
 				Migration: stmgr.UpgradeActorsV2,
 			}, {
 				Network:   network.Version7,
 				Height:    calico,
 				Migration: stmgr.UpgradeCalico,
 			}, {
 				Network: network.Version8,
 				Height:  persian,
 			}})
 		},
 	}
 }
 var MineNext = miner.MineReq{
 	InjectNulls: 0,
 	Done:        func(bool, abi.ChainEpoch, error) {},
 }
 func (ts *testSuite) testVersion(t *testing.T) {
 	build.RunningNodeType = build.NodeFull
 	ctx := context.Background()
-	apis, _ := ts.makeNodes(t, 1, OneMiner)
+	apis, _ := ts.makeNodes(t, OneFull, OneMiner)
 	api := apis[0]
 	v, err := api.Version(ctx)
@ -78,9 +160,52 @@ func (ts *testSuite) testVersion(t *testing.T) {
 	require.Equal(t, v.Version, build.BuildVersion)
 }
 func (ts *testSuite) testSearchMsg(t *testing.T) {
 	apis, miners := ts.makeNodes(t, OneFull, OneMiner)
 	api := apis[0]
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 	senderAddr, err := api.WalletDefaultAddress(ctx)
 	if err != nil {
 		t.Fatal(err)
 	}
 	msg := &types.Message{
 		From:  senderAddr,
 		To:    senderAddr,
 		Value: big.Zero(),
 	}
 	bm := NewBlockMiner(ctx, t, miners[0], 100*time.Millisecond)
 	bm.MineBlocks()
 	defer bm.Stop()
 	sm, err := api.MpoolPushMessage(ctx, msg, nil)
 	if err != nil {
 		t.Fatal(err)
 	}
 	res, err := api.StateWaitMsg(ctx, sm.Cid(), 1)
 	if err != nil {
 		t.Fatal(err)
 	}
 	if res.Receipt.ExitCode != 0 {
 		t.Fatal("did not successfully send message")
 	}
 	searchRes, err := api.StateSearchMsg(ctx, sm.Cid())
 	if err != nil {
 		t.Fatal(err)
 	}
 	if searchRes.TipSet != res.TipSet {
 		t.Fatalf("search ts: %s, different from wait ts: %s", searchRes.TipSet, res.TipSet)
 	}
 }
 func (ts *testSuite) testID(t *testing.T) {
 	ctx := context.Background()
-	apis, _ := ts.makeNodes(t, 1, OneMiner)
+	apis, _ := ts.makeNodes(t, OneFull, OneMiner)
 	api := apis[0]
 	id, err := api.ID(ctx)
@ -92,7 +217,7 @@ func (ts *testSuite) testID(t *testing.T) {
 func (ts *testSuite) testConnectTwo(t *testing.T) {
 	ctx := context.Background()
-	apis, _ := ts.makeNodes(t, 2, OneMiner)
+	apis, _ := ts.makeNodes(t, TwoFull, OneMiner)
 	p, err := apis[0].NetPeers(ctx)
 	if err != nil {
--- a/api/test/window_post.go
+++ b/api/test/window_post.go
@ -3,18 +3,22 @@ package test
 import (
 	"context"
 	"fmt"
 	"sort"
 	"sync/atomic"
 	"os"
 	"strings"
 	"testing"
 	"time"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/network"
 	"github.com/filecoin-project/lotus/extern/sector-storage/mock"
 	sealing "github.com/filecoin-project/lotus/extern/storage-sealing"
 	"github.com/filecoin-project/specs-storage/storage"
 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/build"
@ -23,16 +27,11 @@ import (
 	"github.com/filecoin-project/lotus/node/impl"
 )
-func init() {
+func TestSDRUpgrade(t *testing.T, b APIBuilder, blocktime time.Duration) {
-	err := os.Setenv("BELLMAN_NO_GPU", "1")
+	ctx, cancel := context.WithCancel(context.Background())
-	if err != nil {
+	defer cancel()
 		panic(fmt.Sprintf("failed to set BELLMAN_NO_GPU env variable: %s", err))
 	}
 }
-func TestPledgeSector(t *testing.T, b APIBuilder, blocktime time.Duration, nSectors int) {
+	n, sn := b(t, []FullNodeOpts{FullNodeWithSDRAt(500, 1000)}, OneMiner)
 	ctx := context.Background()
 	n, sn := b(t, 1, OneMiner)
 	client := n[0].FullNode.(*impl.FullNodeAPI)
 	miner := sn[0]
@ -46,11 +45,95 @@ func TestPledgeSector(t *testing.T, b APIBuilder, blocktime time.Duration, nSect
 	}
 	build.Clock.Sleep(time.Second)
-	mine := true
+	pledge := make(chan struct{})
 	mine := int64(1)
 	done := make(chan struct{})
 	go func() {
 		defer close(done)
-		for mine {
+		round := 0
 		for atomic.LoadInt64(&mine) != 0 {
 			build.Clock.Sleep(blocktime)
 			if err := sn[0].MineOne(ctx, bminer.MineReq{Done: func(bool, abi.ChainEpoch, error) {
 			}}); err != nil {
 				t.Error(err)
 			}
 			// 3 sealing rounds: before, during after.
 			if round >= 3 {
 				continue
 			}
 			head, err := client.ChainHead(ctx)
 			assert.NoError(t, err)
 			// rounds happen every 100 blocks, with a 50 block offset.
 			if head.Height() >= abi.ChainEpoch(round*500+50) {
 				round++
 				pledge <- struct{}{}
 				ver, err := client.StateNetworkVersion(ctx, head.Key())
 				assert.NoError(t, err)
 				switch round {
 				case 1:
 					assert.Equal(t, network.Version6, ver)
 				case 2:
 					assert.Equal(t, network.Version7, ver)
 				case 3:
 					assert.Equal(t, network.Version8, ver)
 				}
 			}
 		}
 	}()
 	// before.
 	pledgeSectors(t, ctx, miner, 9, 0, pledge)
 	s, err := miner.SectorsList(ctx)
 	require.NoError(t, err)
 	sort.Slice(s, func(i, j int) bool {
 		return s[i] < s[j]
 	})
 	for i, id := range s {
 		info, err := miner.SectorsStatus(ctx, id, true)
 		require.NoError(t, err)
 		expectProof := abi.RegisteredSealProof_StackedDrg2KiBV1
 		if i >= 3 {
 			// after
 			expectProof = abi.RegisteredSealProof_StackedDrg2KiBV1_1
 		}
 		assert.Equal(t, expectProof, info.SealProof, "sector %d, id %d", i, id)
 	}
 	atomic.StoreInt64(&mine, 0)
 	<-done
 }
 func TestPledgeSector(t *testing.T, b APIBuilder, blocktime time.Duration, nSectors int) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 	n, sn := b(t, OneFull, OneMiner)
 	client := n[0].FullNode.(*impl.FullNodeAPI)
 	miner := sn[0]
 	addrinfo, err := client.NetAddrsListen(ctx)
 	if err != nil {
 		t.Fatal(err)
 	}
 	if err := miner.NetConnect(ctx, addrinfo); err != nil {
 		t.Fatal(err)
 	}
 	build.Clock.Sleep(time.Second)
 	mine := int64(1)
 	done := make(chan struct{})
 	go func() {
 		defer close(done)
 		for atomic.LoadInt64(&mine) != 0 {
 			build.Clock.Sleep(blocktime)
 			if err := sn[0].MineOne(ctx, bminer.MineReq{Done: func(bool, abi.ChainEpoch, error) {
@ -62,17 +145,19 @@ func TestPledgeSector(t *testing.T, b APIBuilder, blocktime time.Duration, nSect
 	pledgeSectors(t, ctx, miner, nSectors, 0, nil)
-	mine = false
+	atomic.StoreInt64(&mine, 0)
 	<-done
 }
 func pledgeSectors(t *testing.T, ctx context.Context, miner TestStorageNode, n, existing int, blockNotif <-chan struct{}) {
 	for i := 0; i < n; i++ {
 		err := miner.PledgeSector(ctx)
 		require.NoError(t, err)
 		if i%3 == 0 && blockNotif != nil {
 			<-blockNotif
 			log.Errorf("WAIT")
 		}
 		log.Errorf("PLEDGING %d", i)
 		err := miner.PledgeSector(ctx)
 		require.NoError(t, err)
 	}
 	for {
@ -114,8 +199,25 @@ func pledgeSectors(t *testing.T, ctx context.Context, miner TestStorageNode, n,
 }
 func TestWindowPost(t *testing.T, b APIBuilder, blocktime time.Duration, nSectors int) {
-	ctx := context.Background()
+	for _, height := range []abi.ChainEpoch{
-	n, sn := b(t, 1, OneMiner)
+		1,    // before
 		162,  // while sealing
 		5000, // while proving
 	} {
 		height := height // copy to satisfy lints
 		t.Run(fmt.Sprintf("upgrade-%d", height), func(t *testing.T) {
 			testWindowPostUpgrade(t, b, blocktime, nSectors, height)
 		})
 	}
 }
 func testWindowPostUpgrade(t *testing.T, b APIBuilder, blocktime time.Duration, nSectors int,
 	upgradeHeight abi.ChainEpoch) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 	n, sn := b(t, []FullNodeOpts{FullNodeWithActorsV2At(upgradeHeight)}, OneMiner)
 	client := n[0].FullNode.(*impl.FullNodeAPI)
 	miner := sn[0]
@ -129,17 +231,24 @@ func TestWindowPost(t *testing.T, b APIBuilder, blocktime time.Duration, nSector
 	}
 	build.Clock.Sleep(time.Second)
 	mine := true
 	done := make(chan struct{})
 	go func() {
 		defer close(done)
-		for mine {
+		for ctx.Err() == nil {
 			build.Clock.Sleep(blocktime)
 			if err := sn[0].MineOne(ctx, MineNext); err != nil {
 				if ctx.Err() != nil {
 					// context was canceled, ignore the error.
 					return
 				}
 				t.Error(err)
 			}
 		}
 	}()
 	defer func() {
 		cancel()
 		<-done
 	}()
 	pledgeSectors(t, ctx, miner, nSectors, 0, nil)
@ -153,18 +262,16 @@ func TestWindowPost(t *testing.T, b APIBuilder, blocktime time.Duration, nSector
 	require.NoError(t, err)
 	fmt.Printf("Running one proving period\n")
 	fmt.Printf("End for head.Height > %d\n", di.PeriodStart+di.WPoStProvingPeriod+2)
 	for {
 		head, err := client.ChainHead(ctx)
 		require.NoError(t, err)
-		if head.Height() > di.PeriodStart+(di.WPoStProvingPeriod)+2 {
+		if head.Height() > di.PeriodStart+di.WPoStProvingPeriod+2 {
 			fmt.Printf("Now head.Height = %d\n", head.Height())
 			break
 		}
 		if head.Height()%100 == 0 {
 			fmt.Printf("@%d\n", head.Height())
 		}
 		build.Clock.Sleep(blocktime)
 	}
@ -186,22 +293,23 @@ func TestWindowPost(t *testing.T, b APIBuilder, blocktime time.Duration, nSector
 		require.Greater(t, len(parts), 0)
 		secs := parts[0].AllSectors
 		require.NoError(t, err)
 		n, err := secs.Count()
 		require.NoError(t, err)
 		require.Equal(t, uint64(2), n)
 		// Drop the partition
 		err = secs.ForEach(func(sid uint64) error {
-			return miner.StorageMiner.(*impl.StorageMinerAPI).IStorageMgr.(*mock.SectorMgr).MarkCorrupted(abi.SectorID{
+			return miner.StorageMiner.(*impl.StorageMinerAPI).IStorageMgr.(*mock.SectorMgr).MarkCorrupted(storage.SectorRef{
-				Miner:  abi.ActorID(mid),
+				ID: abi.SectorID{
-				Number: abi.SectorNumber(sid),
+					Miner:  abi.ActorID(mid),
 					Number: abi.SectorNumber(sid),
 				},
 			}, true)
 		})
 		require.NoError(t, err)
 	}
-	var s abi.SectorID
+	var s storage.SectorRef
 	// Drop 1 sectors from deadline 3 partition 0
 	{
@ -210,7 +318,6 @@ func TestWindowPost(t *testing.T, b APIBuilder, blocktime time.Duration, nSector
 		require.Greater(t, len(parts), 0)
 		secs := parts[0].AllSectors
 		require.NoError(t, err)
 		n, err := secs.Count()
 		require.NoError(t, err)
 		require.Equal(t, uint64(2), n)
@ -223,9 +330,11 @@ func TestWindowPost(t *testing.T, b APIBuilder, blocktime time.Duration, nSector
 		require.NoError(t, err)
 		fmt.Println("the sectors", all)
-		s = abi.SectorID{
+		s = storage.SectorRef{
-			Miner:  abi.ActorID(mid),
+			ID: abi.SectorID{
-			Number: abi.SectorNumber(sn),
+				Miner:  abi.ActorID(mid),
 				Number: abi.SectorNumber(sn),
 			},
 		}
 		err = miner.StorageMiner.(*impl.StorageMinerAPI).IStorageMgr.(*mock.SectorMgr).MarkFailed(s, true)
@ -236,18 +345,17 @@ func TestWindowPost(t *testing.T, b APIBuilder, blocktime time.Duration, nSector
 	require.NoError(t, err)
 	fmt.Printf("Go through another PP, wait for sectors to become faulty\n")
 	fmt.Printf("End for head.Height > %d\n", di.PeriodStart+di.WPoStProvingPeriod+2)
 	for {
 		head, err := client.ChainHead(ctx)
 		require.NoError(t, err)
 		if head.Height() > di.PeriodStart+(di.WPoStProvingPeriod)+2 {
 			fmt.Printf("Now head.Height = %d\n", head.Height())
 			break
 		}
 		if head.Height()%100 == 0 {
 			fmt.Printf("@%d\n", head.Height())
 		}
 		build.Clock.Sleep(blocktime)
 	}
@ -267,17 +375,17 @@ func TestWindowPost(t *testing.T, b APIBuilder, blocktime time.Duration, nSector
 	di, err = client.StateMinerProvingDeadline(ctx, maddr, types.EmptyTSK)
 	require.NoError(t, err)
 	fmt.Printf("End for head.Height > %d\n", di.PeriodStart+di.WPoStProvingPeriod+2)
 	for {
 		head, err := client.ChainHead(ctx)
 		require.NoError(t, err)
 		if head.Height() > di.PeriodStart+di.WPoStProvingPeriod+2 {
 			fmt.Printf("Now head.Height = %d\n", head.Height())
 			break
 		}
 		if head.Height()%100 == 0 {
 			fmt.Printf("@%d\n", head.Height())
 		}
 		build.Clock.Sleep(blocktime)
 	}
@ -294,18 +402,19 @@ func TestWindowPost(t *testing.T, b APIBuilder, blocktime time.Duration, nSector
 	pledgeSectors(t, ctx, miner, 1, nSectors, nil)
 	{
-		// wait a bit more
+		// Wait until proven.
-
+		di, err = client.StateMinerProvingDeadline(ctx, maddr, types.EmptyTSK)
 		head, err := client.ChainHead(ctx)
 		require.NoError(t, err)
-		waitUntil := head.Height() + 10
+		waitUntil := di.PeriodStart + di.WPoStProvingPeriod + 2
 		fmt.Printf("End for head.Height > %d\n", waitUntil)
 		for {
 			head, err := client.ChainHead(ctx)
 			require.NoError(t, err)
 			if head.Height() > waitUntil {
 				fmt.Printf("Now head.Height = %d\n", head.Height())
 				break
 			}
 		}
@ -318,7 +427,4 @@ func TestWindowPost(t *testing.T, b APIBuilder, blocktime time.Duration, nSector
 	sectors = p.MinerPower.RawBytePower.Uint64() / uint64(ssz)
 	require.Equal(t, nSectors+GenesisPreseals-2+1, int(sectors)) // -2 not recovered sectors + 1 just pledged
 	mine = false
 	<-done
 }
--- a/api/types.go
+++ b/api/types.go
@ -107,3 +107,9 @@ func NewDataTransferChannel(hostID peer.ID, channelState datatransfer.ChannelSta
 	}
 	return channel
 }
 type NetBlockList struct {
 	Peers     []peer.ID
 	IPAddrs   []string
 	IPSubnets []string
 }
--- a/build/bootstrap/bootstrappers.pi
+++ b/build/bootstrap/bootstrappers.pi
@ -1,6 +1,15 @@
-/dns4/bootstrap-0.testnet.fildev.network/tcp/1347/p2p/12D3KooWJTUBUjtzWJGWU1XSiY21CwmHaCNLNYn2E7jqHEHyZaP7
+/dns4/bootstrap-0.mainnet.filops.net/tcp/1347/p2p/12D3KooWCVe8MmsEMes2FzgTpt9fXtmCY7wrq91GRiaC8PHSCCBj
-/dns4/bootstrap-1.testnet.fildev.network/tcp/1347/p2p/12D3KooW9yeKXha4hdrJKq74zEo99T8DhriQdWNoojWnnQbsgB3v
+/dns4/bootstrap-1.mainnet.filops.net/tcp/1347/p2p/12D3KooWCwevHg1yLCvktf2nvLu7L9894mcrJR4MsBCcm4syShVc
-/dns4/bootstrap-2.testnet.fildev.network/tcp/1347/p2p/12D3KooWCrx8yVG9U9Kf7w8KLN3Edkj5ZKDhgCaeMqQbcQUoB6CT
+/dns4/bootstrap-2.mainnet.filops.net/tcp/1347/p2p/12D3KooWEWVwHGn2yR36gKLozmb4YjDJGerotAPGxmdWZx2nxMC4
-/dns4/bootstrap-4.testnet.fildev.network/tcp/1347/p2p/12D3KooWPkL9LrKRQgHtq7kn9ecNhGU9QaziG8R5tX8v9v7t3h34
+/dns4/bootstrap-3.mainnet.filops.net/tcp/1347/p2p/12D3KooWKhgq8c7NQ9iGjbyK7v7phXvG6492HQfiDaGHLHLQjk7R
-/dns4/bootstrap-3.testnet.fildev.network/tcp/1347/p2p/12D3KooWKYSsbpgZ3HAjax5M1BXCwXLa6gVkUARciz7uN3FNtr7T
+/dns4/bootstrap-4.mainnet.filops.net/tcp/1347/p2p/12D3KooWL6PsFNPhYftrJzGgF5U18hFoaVhfGk7xwzD8yVrHJ3Uc
-/dns4/bootstrap-5.testnet.fildev.network/tcp/1347/p2p/12D3KooWQYzqnLASJAabyMpPb1GcWZvNSe7JDcRuhdRqonFoiK9W
+/dns4/bootstrap-5.mainnet.filops.net/tcp/1347/p2p/12D3KooWLFynvDQiUpXoHroV1YxKHhPJgysQGH2k3ZGwtWzR4dFH
 /dns4/bootstrap-6.mainnet.filops.net/tcp/1347/p2p/12D3KooWP5MwCiqdMETF9ub1P3MbCvQCcfconnYHbWg6sUJcDRQQ
 /dns4/bootstrap-7.mainnet.filops.net/tcp/1347/p2p/12D3KooWRs3aY1p3juFjPy8gPN95PEQChm2QKGUCAdcDCC4EBMKf
 /dns4/bootstrap-8.mainnet.filops.net/tcp/1347/p2p/12D3KooWScFR7385LTyR4zU1bYdzSiiAb5rnNABfVahPvVSzyTkR
 /dns4/lotus-bootstrap.forceup.cn/tcp/41778/p2p/12D3KooWFQsv3nRMUevZNWWsY1Wu6NUzUbawnWU5NcRhgKuJA37C
 /dns4/bootstrap-0.starpool.in/tcp/12757/p2p/12D3KooWGHpBMeZbestVEWkfdnC9u7p6uFHXL1n7m1ZBqsEmiUzz
 /dns4/bootstrap-1.starpool.in/tcp/12757/p2p/12D3KooWQZrGH1PxSNZPum99M1zNvjNFM33d1AAu5DcvdHptuU7u
 /dns4/node.glif.io/tcp/1235/p2p/12D3KooWBF8cpp65hp2u9LK5mh19x67ftAam84z9LsfaquTDSBpt
 /dns4/bootstrap-0.ipfsmain.cn/tcp/34721/p2p/12D3KooWQnwEGNqcM2nAcPtRR9rAX8Hrg4k9kJLCHoTR5chJfz6d
 /dns4/bootstrap-1.ipfsmain.cn/tcp/34723/p2p/12D3KooWMKxMkD5DMpSWsW7dBddKxKT7L2GgbNuckz9otxvkvByP
--- a/build/drand.go
+++ b/build/drand.go
@ -35,6 +35,7 @@ var DrandConfigs = map[DrandEnum]dtypes.DrandConfig{
 			"https://api.drand.sh",
 			"https://api2.drand.sh",
 			"https://api3.drand.sh",
 			"https://drand.cloudflare.com",
 		},
 		Relays: []string{
 			"/dnsaddr/api.drand.sh/",
@ -68,16 +69,6 @@ var DrandConfigs = map[DrandEnum]dtypes.DrandConfig{
 		ChainInfoJSON: `{"public_key":"8cda589f88914aa728fd183f383980b35789ce81b274e5daee1f338b77d02566ef4d3fb0098af1f844f10f9c803c1827","period":25,"genesis_time":1595348225,"hash":"e73b7dc3c4f6a236378220c0dd6aa110eb16eed26c11259606e07ee122838d4f","groupHash":"567d4785122a5a3e75a9bc9911d7ea807dd85ff76b78dc4ff06b075712898607"}`,
 	},
 	DrandIncentinet: {
 		Servers: []string{
 			"https://pl-eu.incentinet.drand.sh",
 			"https://pl-us.incentinet.drand.sh",
 			"https://pl-sin.incentinet.drand.sh",
 		},
 		Relays: []string{
 			"/dnsaddr/pl-eu.incentinet.drand.sh/",
 			"/dnsaddr/pl-us.incentinet.drand.sh/",
 			"/dnsaddr/pl-sin.incentinet.drand.sh/",
 		},
 		ChainInfoJSON: `{"public_key":"8cad0c72c606ab27d36ee06de1d5b2db1faf92e447025ca37575ab3a8aac2eaae83192f846fc9e158bc738423753d000","period":30,"genesis_time":1595873820,"hash":"80c8b872c714f4c00fdd3daa465d5514049f457f01f85a4caf68cdcd394ba039","groupHash":"d9406aaed487f7af71851b4399448e311f2328923d454e971536c05398ce2d9b"}`,
 	},
 }
--- a/build/params_2k.go
+++ b/build/params_2k.go
@ -3,8 +3,10 @@
 package build
 import (
-	"github.com/filecoin-project/go-state-types/abi"
+	"math"
 	"os"
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/lotus/chain/actors/policy"
 )
@ -12,6 +14,16 @@ const UpgradeBreezeHeight = -1
 const BreezeGasTampingDuration = 0
 const UpgradeSmokeHeight = -1
 const UpgradeIgnitionHeight = -2
 const UpgradeRefuelHeight = -3
 const UpgradeTapeHeight = -4
 var UpgradeActorsV2Height = abi.ChainEpoch(10)
 var UpgradeLiftoffHeight = abi.ChainEpoch(-5)
 const UpgradeKumquatHeight = 15
 const UpgradeCalicoHeight = 20
 const UpgradePersianHeight = 25
 var DrandSchedule = map[abi.ChainEpoch]DrandEnum{
 	0: DrandMainnet,
@ -22,6 +34,11 @@ func init() {
 	policy.SetConsensusMinerMinPower(abi.NewStoragePower(2048))
 	policy.SetMinVerifiedDealSize(abi.NewStoragePower(256))
 	if os.Getenv("LOTUS_DISABLE_V2_ACTOR_MIGRATION") == "1" {
 		UpgradeActorsV2Height = math.MaxInt64
 		UpgradeLiftoffHeight = 11
 	}
 	BuildType |= Build2k
 }
@ -37,3 +54,5 @@ const SlashablePowerDelay = 20
 // Epochs
 const InteractivePoRepConfidence = 6
 const BootstrapPeerThreshold = 1
--- a/build/params_mainnet.go
+++ b/build/params_mainnet.go
@ -0,0 +1,62 @@
 // +build !debug
 // +build !2k
 // +build !testground
 package build
 import (
 	"math"
 	"os"
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/lotus/chain/actors/policy"
 	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
 )
 var DrandSchedule = map[abi.ChainEpoch]DrandEnum{
 	0:                  DrandIncentinet,
 	UpgradeSmokeHeight: DrandMainnet,
 }
 const UpgradeBreezeHeight = 41280
 const BreezeGasTampingDuration = 120
 const UpgradeSmokeHeight = 51000
 const UpgradeIgnitionHeight = 94000
 const UpgradeRefuelHeight = 130800
 var UpgradeActorsV2Height = abi.ChainEpoch(138720)
 const UpgradeTapeHeight = 140760
 // This signals our tentative epoch for mainnet launch. Can make it later, but not earlier.
 // Miners, clients, developers, custodians all need time to prepare.
 // We still have upgrades and state changes to do, but can happen after signaling timing here.
 const UpgradeLiftoffHeight = 148888
 const UpgradeKumquatHeight = 170000
 const UpgradeCalicoHeight = 265200
 const UpgradePersianHeight = UpgradeCalicoHeight + (builtin2.EpochsInHour * 60)
 func init() {
 	policy.SetConsensusMinerMinPower(abi.NewStoragePower(10 << 40))
 	if os.Getenv("LOTUS_USE_TEST_ADDRESSES") != "1" {
 		SetAddressNetwork(address.Mainnet)
 	}
 	if os.Getenv("LOTUS_DISABLE_V2_ACTOR_MIGRATION") == "1" {
 		UpgradeActorsV2Height = math.MaxInt64
 	}
 	Devnet = false
 }
 const BlockDelaySecs = uint64(builtin2.EpochDurationSeconds)
 const PropagationDelaySecs = uint64(6)
 const BootstrapPeerThreshold = 4
--- a/build/params_shared_funcs.go
+++ b/build/params_shared_funcs.go
@ -1,34 +1,13 @@
 package build
 import (
-	"sort"
+	"github.com/filecoin-project/go-address"
 	"github.com/libp2p/go-libp2p-core/protocol"
 	"github.com/filecoin-project/go-state-types/abi"
 	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
 	"github.com/filecoin-project/lotus/node/modules/dtypes"
 )
 func DefaultSectorSize() abi.SectorSize {
 	szs := make([]abi.SectorSize, 0, len(miner0.SupportedProofTypes))
 	for spt := range miner0.SupportedProofTypes {
 		ss, err := spt.SectorSize()
 		if err != nil {
 			panic(err)
 		}
 		szs = append(szs, ss)
 	}
 	sort.Slice(szs, func(i, j int) bool {
 		return szs[i] < szs[j]
 	})
 	return szs[0]
 }
 // Core network constants
 func BlocksTopic(netName dtypes.NetworkName) string   { return "/fil/blocks/" + string(netName) }
@ -37,10 +16,15 @@ func DhtProtocolName(netName dtypes.NetworkName) protocol.ID {
 	return protocol.ID("/fil/kad/" + string(netName))
 }
-func UseNewestNetwork() bool {
+func SetAddressNetwork(n address.Network) {
-	// TODO: Put these in a container we can iterate over
+	address.CurrentNetwork = n
-	if UpgradeBreezeHeight <= 0 && UpgradeSmokeHeight <= 0 {
+}
-		return true
+
-	}
+func MustParseAddress(addr string) address.Address {
-	return false
+	ret, err := address.NewFromString(addr)
 	if err != nil {
 		panic(err)
 	}
 	return ret
 }
--- a/build/params_shared_vals.go
+++ b/build/params_shared_vals.go
@ -4,12 +4,15 @@ package build
 import (
 	"math/big"
 	"os"
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/network"
-	"github.com/filecoin-project/go-state-types/abi"
+	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
-	"github.com/filecoin-project/specs-actors/actors/builtin"
+
-	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
+	"github.com/filecoin-project/lotus/chain/actors/policy"
 )
 // /////
@ -22,17 +25,17 @@ const UnixfsLinksPerLevel = 1024
 // Consensus / Network
 const AllowableClockDriftSecs = uint64(1)
-const NewestNetworkVersion = network.Version2
+const NewestNetworkVersion = network.Version8
-const ActorUpgradeNetworkVersion = network.Version3
+const ActorUpgradeNetworkVersion = network.Version4
 // Epochs
 const ForkLengthThreshold = Finality
 // Blocks (e)
-var BlocksPerEpoch = uint64(builtin.ExpectedLeadersPerEpoch)
+var BlocksPerEpoch = uint64(builtin2.ExpectedLeadersPerEpoch)
 // Epochs
-const Finality = miner0.ChainFinality
+const Finality = policy.ChainFinality
 const MessageConfidence = uint64(5)
 // constants for Weight calculation
@ -44,13 +47,8 @@ const WRatioDen = uint64(2)
 // Proofs
 // Epochs
-const SealRandomnessLookback = Finality
+// TODO: unused
-
+const SealRandomnessLookback = policy.SealRandomnessLookback
 // Epochs
 const SealRandomnessLookbackLimit = SealRandomnessLookback + 2000 // TODO: Get from spec specs-actors
 // Maximum lookback that randomness can be sourced from for a seal proof submission
 const MaxSealLookback = SealRandomnessLookbackLimit + 2000 // TODO: Get from specs-actors
 // /////
 // Mining
@ -58,23 +56,40 @@ const MaxSealLookback = SealRandomnessLookbackLimit + 2000 // TODO: Get from spe
 // Epochs
 const TicketRandomnessLookback = abi.ChainEpoch(1)
-const WinningPoStSectorSetLookback = abi.ChainEpoch(10)
+// /////
 // Address
 const AddressMainnetEnvVar = "_mainnet_"
 // the 'f' prefix doesn't matter
 var ZeroAddress = MustParseAddress("f3yaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaby2smx7a")
 // /////
 // Devnet settings
 var Devnet = true
 const FilBase = uint64(2_000_000_000)
 const FilAllocStorageMining = uint64(1_100_000_000)
 const FilecoinPrecision = uint64(1_000_000_000_000_000_000)
 const FilReserved = uint64(300_000_000)
 var InitialRewardBalance *big.Int
 var InitialFilReserved *big.Int
 // TODO: Move other important consts here
 func init() {
 	InitialRewardBalance = big.NewInt(int64(FilAllocStorageMining))
 	InitialRewardBalance = InitialRewardBalance.Mul(InitialRewardBalance, big.NewInt(int64(FilecoinPrecision)))
 	InitialFilReserved = big.NewInt(int64(FilReserved))
 	InitialFilReserved = InitialFilReserved.Mul(InitialFilReserved, big.NewInt(int64(FilecoinPrecision)))
 	if os.Getenv("LOTUS_ADDRESS_TYPE") == AddressMainnetEnvVar {
 		SetAddressNetwork(address.Mainnet)
 	}
 }
 // Sync
@ -104,4 +119,4 @@ const PackingEfficiencyDenom = 5
 // Actor consts
 // TODO: Pull from actors when its made not private
-var MinDealDuration = abi.ChainEpoch(180 * builtin.EpochsInDay)
+var MinDealDuration = abi.ChainEpoch(180 * builtin2.EpochsInDay)
--- a/build/params_testground.go
+++ b/build/params_testground.go
@ -12,27 +12,29 @@ import (
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/network"
-	"github.com/filecoin-project/specs-actors/actors/builtin"
+
-	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
+	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
 	"github.com/filecoin-project/lotus/chain/actors/policy"
 )
 var (
 	UnixfsChunkSize     = uint64(1 << 20)
 	UnixfsLinksPerLevel = 1024
-	BlocksPerEpoch        = uint64(builtin.ExpectedLeadersPerEpoch)
+	BlocksPerEpoch        = uint64(builtin2.ExpectedLeadersPerEpoch)
 	BlockMessageLimit     = 512
 	BlockGasLimit         = int64(100_000_000_000)
 	BlockGasTarget        = int64(BlockGasLimit / 2)
 	BaseFeeMaxChangeDenom = int64(8) // 12.5%
 	InitialBaseFee        = int64(100e6)
 	MinimumBaseFee        = int64(100)
-	BlockDelaySecs        = uint64(builtin.EpochDurationSeconds)
+	BlockDelaySecs        = uint64(builtin2.EpochDurationSeconds)
 	PropagationDelaySecs  = uint64(6)
 	AllowableClockDriftSecs = uint64(1)
-	Finality            = miner0.ChainFinality
+	Finality            = policy.ChainFinality
 	ForkLengthThreshold = Finality
 	SlashablePowerDelay        = 20
@ -47,15 +49,13 @@ var (
 	BlsSignatureCacheSize = 40000
 	VerifSigCacheSize     = 32000
-	SealRandomnessLookback      = Finality
+	SealRandomnessLookback = policy.SealRandomnessLookback
 	SealRandomnessLookbackLimit = SealRandomnessLookback + 2000
 	MaxSealLookback             = SealRandomnessLookbackLimit + 2000
-	TicketRandomnessLookback     = abi.ChainEpoch(1)
+	TicketRandomnessLookback = abi.ChainEpoch(1)
 	WinningPoStSectorSetLookback = abi.ChainEpoch(10)
 	FilBase               uint64 = 2_000_000_000
 	FilAllocStorageMining uint64 = 1_400_000_000
 	FilReserved           uint64 = 300_000_000
 	FilecoinPrecision uint64 = 1_000_000_000_000_000_000
@ -64,9 +64,16 @@ var (
 		v = v.Mul(v, big.NewInt(int64(FilecoinPrecision)))
 		return v
 	}()
 	InitialFilReserved = func() *big.Int {
 		v := big.NewInt(int64(FilReserved))
 		v = v.Mul(v, big.NewInt(int64(FilecoinPrecision)))
 		return v
 	}()
 	// Actor consts
 	// TODO: Pull from actors when its made not private
-	MinDealDuration = abi.ChainEpoch(180 * builtin.EpochsInDay)
+	MinDealDuration = abi.ChainEpoch(180 * builtin2.EpochsInDay)
 	PackingEfficiencyNum   int64 = 4
 	PackingEfficiencyDenom int64 = 5
@ -74,12 +81,25 @@ var (
 	UpgradeBreezeHeight      abi.ChainEpoch = -1
 	BreezeGasTampingDuration abi.ChainEpoch = 0
-	UpgradeSmokeHeight abi.ChainEpoch = -1
+	UpgradeSmokeHeight    abi.ChainEpoch = -1
 	UpgradeIgnitionHeight abi.ChainEpoch = -2
 	UpgradeRefuelHeight   abi.ChainEpoch = -3
 	UpgradeTapeHeight     abi.ChainEpoch = -4
 	UpgradeActorsV2Height abi.ChainEpoch = 10
 	UpgradeLiftoffHeight  abi.ChainEpoch = -5
 	UpgradeKumquatHeight  abi.ChainEpoch = -6
 	UpgradeCalicoHeight   abi.ChainEpoch = -7
 	UpgradePersianHeight  abi.ChainEpoch = -8
 	DrandSchedule = map[abi.ChainEpoch]DrandEnum{
 		0: DrandMainnet,
 	}
-	NewestNetworkVersion       = network.Version2
+	NewestNetworkVersion       = network.Version8
-	ActorUpgradeNetworkVersion = network.Version3
+	ActorUpgradeNetworkVersion = network.Version4
 	Devnet      = true
 	ZeroAddress = MustParseAddress("f3yaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaby2smx7a")
 )
 const BootstrapPeerThreshold = 1
--- a/build/params_testnet.go
+++ b/build/params_testnet.go
@ -1,34 +0,0 @@
 // +build !debug
 // +build !2k
 // +build !testground
 package build
 import (
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/lotus/chain/actors/policy"
 	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
 )
 var DrandSchedule = map[abi.ChainEpoch]DrandEnum{
 	0:                  DrandIncentinet,
 	UpgradeSmokeHeight: DrandMainnet,
 }
 const UpgradeBreezeHeight = 41280
 const BreezeGasTampingDuration = 120
 const UpgradeSmokeHeight = 51000
 func init() {
 	policy.SetConsensusMinerMinPower(abi.NewStoragePower(10 << 40))
 	policy.SetSupportedProofTypes(
 		abi.RegisteredSealProof_StackedDrg32GiBV1,
 		abi.RegisteredSealProof_StackedDrg64GiBV1,
 	)
 }
 const BlockDelaySecs = uint64(builtin0.EpochDurationSeconds)
 const PropagationDelaySecs = uint64(6)
--- a/build/version.go
+++ b/build/version.go
@ -29,7 +29,7 @@ func buildType() string {
 }
 // BuildVersion is the local build version, set by build system
-const BuildVersion = "0.7.2"
+const BuildVersion = "1.2.1"
 func UserVersion() string {
 	return BuildVersion + buildType() + CurrentCommit
@ -83,9 +83,9 @@ func VersionForType(nodeType NodeType) (Version, error) {
 // semver versions of the rpc api exposed
 var (
-	FullAPIVersion   = newVer(0, 16, 0)
+	FullAPIVersion   = newVer(1, 0, 0)
-	MinerAPIVersion  = newVer(0, 15, 0)
+	MinerAPIVersion  = newVer(1, 0, 0)
-	WorkerAPIVersion = newVer(0, 15, 0)
+	WorkerAPIVersion = newVer(1, 0, 0)
 )
 //nolint:varcheck,deadcode
--- a/chain/actors/adt/adt.go
+++ b/chain/actors/adt/adt.go
@ -7,8 +7,11 @@ import (
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/cbor"
 	"github.com/filecoin-project/go-state-types/network"
-	"github.com/filecoin-project/lotus/chain/actors/builtin"
+
 	"github.com/filecoin-project/lotus/chain/actors"
 	adt0 "github.com/filecoin-project/specs-actors/actors/util/adt"
 	adt2 "github.com/filecoin-project/specs-actors/v2/actors/util/adt"
 )
 type Map interface {
@ -21,18 +24,22 @@ type Map interface {
 	ForEach(v cbor.Unmarshaler, fn func(key string) error) error
 }
-func AsMap(store Store, root cid.Cid, version builtin.Version) (Map, error) {
+func AsMap(store Store, root cid.Cid, version actors.Version) (Map, error) {
 	switch version {
-	case builtin.Version0:
+	case actors.Version0:
 		return adt0.AsMap(store, root)
 	case actors.Version2:
 		return adt2.AsMap(store, root)
 	}
 	return nil, xerrors.Errorf("unknown network version: %d", version)
 }
-func NewMap(store Store, version builtin.Version) (Map, error) {
+func NewMap(store Store, version actors.Version) (Map, error) {
 	switch version {
-	case builtin.Version0:
+	case actors.Version0:
 		return adt0.MakeEmptyMap(store), nil
 	case actors.Version2:
 		return adt2.MakeEmptyMap(store), nil
 	}
 	return nil, xerrors.Errorf("unknown network version: %d", version)
 }
@ -49,17 +56,21 @@ type Array interface {
 }
 func AsArray(store Store, root cid.Cid, version network.Version) (Array, error) {
-	switch builtin.VersionForNetwork(version) {
+	switch actors.VersionForNetwork(version) {
-	case builtin.Version0:
+	case actors.Version0:
 		return adt0.AsArray(store, root)
 	case actors.Version2:
 		return adt2.AsArray(store, root)
 	}
 	return nil, xerrors.Errorf("unknown network version: %d", version)
 }
-func NewArray(store Store, version builtin.Version) (Array, error) {
+func NewArray(store Store, version actors.Version) (Array, error) {
 	switch version {
-	case builtin.Version0:
+	case actors.Version0:
 		return adt0.MakeEmptyArray(store), nil
 	case actors.Version2:
 		return adt2.MakeEmptyArray(store), nil
 	}
 	return nil, xerrors.Errorf("unknown network version: %d", version)
 }
--- a/chain/actors/adt/diff_adt_test.go
+++ b/chain/actors/adt/diff_adt_test.go
@ -12,8 +12,9 @@ import (
 	typegen "github.com/whyrusleeping/cbor-gen"
 	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/specs-actors/actors/runtime"
+
-	adt0 "github.com/filecoin-project/specs-actors/actors/util/adt"
+	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
 	adt2 "github.com/filecoin-project/specs-actors/v2/actors/util/adt"
 	bstore "github.com/filecoin-project/lotus/lib/blockstore"
 )
@ -22,24 +23,24 @@ func TestDiffAdtArray(t *testing.T) {
 	ctxstoreA := newContextStore()
 	ctxstoreB := newContextStore()
-	arrA := adt0.MakeEmptyArray(ctxstoreA)
+	arrA := adt2.MakeEmptyArray(ctxstoreA)
-	arrB := adt0.MakeEmptyArray(ctxstoreB)
+	arrB := adt2.MakeEmptyArray(ctxstoreB)
-	require.NoError(t, arrA.Set(0, runtime.CBORBytes([]byte{0}))) // delete
+	require.NoError(t, arrA.Set(0, builtin2.CBORBytes([]byte{0}))) // delete
-	require.NoError(t, arrA.Set(1, runtime.CBORBytes([]byte{0}))) // modify
+	require.NoError(t, arrA.Set(1, builtin2.CBORBytes([]byte{0}))) // modify
-	require.NoError(t, arrB.Set(1, runtime.CBORBytes([]byte{1})))
+	require.NoError(t, arrB.Set(1, builtin2.CBORBytes([]byte{1})))
-	require.NoError(t, arrA.Set(2, runtime.CBORBytes([]byte{1}))) // delete
+	require.NoError(t, arrA.Set(2, builtin2.CBORBytes([]byte{1}))) // delete
-	require.NoError(t, arrA.Set(3, runtime.CBORBytes([]byte{0}))) // noop
+	require.NoError(t, arrA.Set(3, builtin2.CBORBytes([]byte{0}))) // noop
-	require.NoError(t, arrB.Set(3, runtime.CBORBytes([]byte{0})))
+	require.NoError(t, arrB.Set(3, builtin2.CBORBytes([]byte{0})))
-	require.NoError(t, arrA.Set(4, runtime.CBORBytes([]byte{0}))) // modify
+	require.NoError(t, arrA.Set(4, builtin2.CBORBytes([]byte{0}))) // modify
-	require.NoError(t, arrB.Set(4, runtime.CBORBytes([]byte{6})))
+	require.NoError(t, arrB.Set(4, builtin2.CBORBytes([]byte{6})))
-	require.NoError(t, arrB.Set(5, runtime.CBORBytes{8})) // add
+	require.NoError(t, arrB.Set(5, builtin2.CBORBytes{8})) // add
-	require.NoError(t, arrB.Set(6, runtime.CBORBytes{9})) // add
+	require.NoError(t, arrB.Set(6, builtin2.CBORBytes{9})) // add
 	changes := new(TestDiffArray)
@ -76,24 +77,24 @@ func TestDiffAdtMap(t *testing.T) {
 	ctxstoreA := newContextStore()
 	ctxstoreB := newContextStore()
-	mapA := adt0.MakeEmptyMap(ctxstoreA)
+	mapA := adt2.MakeEmptyMap(ctxstoreA)
-	mapB := adt0.MakeEmptyMap(ctxstoreB)
+	mapB := adt2.MakeEmptyMap(ctxstoreB)
-	require.NoError(t, mapA.Put(abi.UIntKey(0), runtime.CBORBytes([]byte{0}))) // delete
+	require.NoError(t, mapA.Put(abi.UIntKey(0), builtin2.CBORBytes([]byte{0}))) // delete
-	require.NoError(t, mapA.Put(abi.UIntKey(1), runtime.CBORBytes([]byte{0}))) // modify
+	require.NoError(t, mapA.Put(abi.UIntKey(1), builtin2.CBORBytes([]byte{0}))) // modify
-	require.NoError(t, mapB.Put(abi.UIntKey(1), runtime.CBORBytes([]byte{1})))
+	require.NoError(t, mapB.Put(abi.UIntKey(1), builtin2.CBORBytes([]byte{1})))
-	require.NoError(t, mapA.Put(abi.UIntKey(2), runtime.CBORBytes([]byte{1}))) // delete
+	require.NoError(t, mapA.Put(abi.UIntKey(2), builtin2.CBORBytes([]byte{1}))) // delete
-	require.NoError(t, mapA.Put(abi.UIntKey(3), runtime.CBORBytes([]byte{0}))) // noop
+	require.NoError(t, mapA.Put(abi.UIntKey(3), builtin2.CBORBytes([]byte{0}))) // noop
-	require.NoError(t, mapB.Put(abi.UIntKey(3), runtime.CBORBytes([]byte{0})))
+	require.NoError(t, mapB.Put(abi.UIntKey(3), builtin2.CBORBytes([]byte{0})))
-	require.NoError(t, mapA.Put(abi.UIntKey(4), runtime.CBORBytes([]byte{0}))) // modify
+	require.NoError(t, mapA.Put(abi.UIntKey(4), builtin2.CBORBytes([]byte{0}))) // modify
-	require.NoError(t, mapB.Put(abi.UIntKey(4), runtime.CBORBytes([]byte{6})))
+	require.NoError(t, mapB.Put(abi.UIntKey(4), builtin2.CBORBytes([]byte{6})))
-	require.NoError(t, mapB.Put(abi.UIntKey(5), runtime.CBORBytes{8})) // add
+	require.NoError(t, mapB.Put(abi.UIntKey(5), builtin2.CBORBytes{8})) // add
-	require.NoError(t, mapB.Put(abi.UIntKey(6), runtime.CBORBytes{9})) // add
+	require.NoError(t, mapB.Put(abi.UIntKey(6), builtin2.CBORBytes{9})) // add
 	changes := new(TestDiffMap)
@ -144,7 +145,7 @@ func (t *TestDiffMap) AsKey(key string) (abi.Keyer, error) {
 }
 func (t *TestDiffMap) Add(key string, val *typegen.Deferred) error {
-	v := new(runtime.CBORBytes)
+	v := new(builtin2.CBORBytes)
 	err := v.UnmarshalCBOR(bytes.NewReader(val.Raw))
 	if err != nil {
 		return err
@ -161,13 +162,13 @@ func (t *TestDiffMap) Add(key string, val *typegen.Deferred) error {
 }
 func (t *TestDiffMap) Modify(key string, from, to *typegen.Deferred) error {
-	vFrom := new(runtime.CBORBytes)
+	vFrom := new(builtin2.CBORBytes)
 	err := vFrom.UnmarshalCBOR(bytes.NewReader(from.Raw))
 	if err != nil {
 		return err
 	}
-	vTo := new(runtime.CBORBytes)
+	vTo := new(builtin2.CBORBytes)
 	err = vTo.UnmarshalCBOR(bytes.NewReader(to.Raw))
 	if err != nil {
 		return err
@ -194,7 +195,7 @@ func (t *TestDiffMap) Modify(key string, from, to *typegen.Deferred) error {
 }
 func (t *TestDiffMap) Remove(key string, val *typegen.Deferred) error {
-	v := new(runtime.CBORBytes)
+	v := new(builtin2.CBORBytes)
 	err := v.UnmarshalCBOR(bytes.NewReader(val.Raw))
 	if err != nil {
 		return err
@ -212,7 +213,7 @@ func (t *TestDiffMap) Remove(key string, val *typegen.Deferred) error {
 type adtMapDiffResult struct {
 	key uint64
-	val runtime.CBORBytes
+	val builtin2.CBORBytes
 }
 type TestAdtMapDiffModified struct {
@ -222,7 +223,7 @@ type TestAdtMapDiffModified struct {
 type adtArrayDiffResult struct {
 	key uint64
-	val runtime.CBORBytes
+	val builtin2.CBORBytes
 }
 type TestDiffArray struct {
@ -239,7 +240,7 @@ type TestAdtArrayDiffModified struct {
 }
 func (t *TestDiffArray) Add(key uint64, val *typegen.Deferred) error {
-	v := new(runtime.CBORBytes)
+	v := new(builtin2.CBORBytes)
 	err := v.UnmarshalCBOR(bytes.NewReader(val.Raw))
 	if err != nil {
 		return err
@ -252,13 +253,13 @@ func (t *TestDiffArray) Add(key uint64, val *typegen.Deferred) error {
 }
 func (t *TestDiffArray) Modify(key uint64, from, to *typegen.Deferred) error {
-	vFrom := new(runtime.CBORBytes)
+	vFrom := new(builtin2.CBORBytes)
 	err := vFrom.UnmarshalCBOR(bytes.NewReader(from.Raw))
 	if err != nil {
 		return err
 	}
-	vTo := new(runtime.CBORBytes)
+	vTo := new(builtin2.CBORBytes)
 	err = vTo.UnmarshalCBOR(bytes.NewReader(to.Raw))
 	if err != nil {
 		return err
@ -280,7 +281,7 @@ func (t *TestDiffArray) Modify(key uint64, from, to *typegen.Deferred) error {
 }
 func (t *TestDiffArray) Remove(key uint64, val *typegen.Deferred) error {
-	v := new(runtime.CBORBytes)
+	v := new(builtin2.CBORBytes)
 	err := v.UnmarshalCBOR(bytes.NewReader(val.Raw))
 	if err != nil {
 		return err
--- a/chain/actors/builtin/account/account.go
+++ b/chain/actors/builtin/account/account.go
@ -5,21 +5,33 @@ import (
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/cbor"
-	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
+	"github.com/ipfs/go-cid"
 	"github.com/filecoin-project/lotus/chain/actors/adt"
 	"github.com/filecoin-project/lotus/chain/actors/builtin"
 	"github.com/filecoin-project/lotus/chain/types"
 	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
 	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
 )
 func init() {
 	builtin.RegisterActorState(builtin0.AccountActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
 		return load0(store, root)
 	})
 	builtin.RegisterActorState(builtin2.AccountActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
 		return load2(store, root)
 	})
 }
 var Methods = builtin2.MethodsAccount
 func Load(store adt.Store, act *types.Actor) (State, error) {
 	switch act.Code {
 	case builtin0.AccountActorCodeID:
-		out := state0{store: store}
+		return load0(store, act.Head)
-		err := store.Get(store.Context(), act.Head, &out)
+	case builtin2.AccountActorCodeID:
-		if err != nil {
+		return load2(store, act.Head)
 			return nil, err
 		}
 		return &out, nil
 	}
 	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
 }
--- a/chain/actors/builtin/account/v0.go
+++ b/chain/actors/builtin/account/v0.go
@ -2,14 +2,26 @@ package account
 import (
 	"github.com/filecoin-project/go-address"
 	"github.com/ipfs/go-cid"
 	"github.com/filecoin-project/lotus/chain/actors/adt"
-	"github.com/filecoin-project/specs-actors/actors/builtin/account"
+
 	account0 "github.com/filecoin-project/specs-actors/actors/builtin/account"
 )
 var _ State = (*state0)(nil)
 func load0(store adt.Store, root cid.Cid) (State, error) {
 	out := state0{store: store}
 	err := store.Get(store.Context(), root, &out)
 	if err != nil {
 		return nil, err
 	}
 	return &out, nil
 }
 type state0 struct {
-	account.State
+	account0.State
 	store adt.Store
 }
--- a/chain/actors/builtin/account/v2.go
+++ b/chain/actors/builtin/account/v2.go
@ -0,0 +1,30 @@
 package account
 import (
 	"github.com/filecoin-project/go-address"
 	"github.com/ipfs/go-cid"
 	"github.com/filecoin-project/lotus/chain/actors/adt"
 	account2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/account"
 )
 var _ State = (*state2)(nil)
 func load2(store adt.Store, root cid.Cid) (State, error) {
 	out := state2{store: store}
 	err := store.Get(store.Context(), root, &out)
 	if err != nil {
 		return nil, err
 	}
 	return &out, nil
 }
 type state2 struct {
 	account2.State
 	store adt.Store
 }
 func (s *state2) PubkeyAddress() (address.Address, error) {
 	return s.Address, nil
 }
--- a/chain/actors/builtin/builtin.go
+++ b/chain/actors/builtin/builtin.go
@ -1,32 +1,46 @@
 package builtin
 import (
-	"fmt"
+	"github.com/filecoin-project/go-address"
 	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
 	smoothing2 "github.com/filecoin-project/specs-actors/v2/actors/util/smoothing"
 	"github.com/ipfs/go-cid"
 	"golang.org/x/xerrors"
 	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/cbor"
 	"github.com/filecoin-project/lotus/chain/actors/adt"
 	"github.com/filecoin-project/lotus/chain/types"
 	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
 	proof0 "github.com/filecoin-project/specs-actors/actors/runtime/proof"
 	smoothing0 "github.com/filecoin-project/specs-actors/actors/util/smoothing"
 	"github.com/filecoin-project/go-state-types/network"
 )
-type Version int
+var SystemActorAddr = builtin0.SystemActorAddr
 var BurntFundsActorAddr = builtin0.BurntFundsActorAddr
 var CronActorAddr = builtin0.CronActorAddr
 var SaftAddress = makeAddress("t0122")
 var ReserveAddress = makeAddress("t090")
 var RootVerifierAddress = makeAddress("t080")
 var (
 	ExpectedLeadersPerEpoch = builtin0.ExpectedLeadersPerEpoch
 )
 const (
-	Version0 = iota
+	EpochDurationSeconds = builtin0.EpochDurationSeconds
 	EpochsInDay          = builtin0.EpochsInDay
 	SecondsInDay         = builtin0.SecondsInDay
 )
-// Converts a network version into a specs-actors version.
+const (
-func VersionForNetwork(version network.Version) Version {
+	MethodSend        = builtin2.MethodSend
-	switch version {
+	MethodConstructor = builtin2.MethodConstructor
-	case network.Version0, network.Version1, network.Version2:
+)
 		return Version0
 	default:
 		panic(fmt.Sprintf("unsupported network version %d", version))
 	}
 }
 // TODO: Why does actors have 2 different versions of this?
 type SectorInfo = proof0.SectorInfo
@ -41,3 +55,64 @@ func FromV0FilterEstimate(v0 smoothing0.FilterEstimate) FilterEstimate {
 func QAPowerForWeight(size abi.SectorSize, duration abi.ChainEpoch, dealWeight, verifiedWeight abi.DealWeight) abi.StoragePower {
 	return miner0.QAPowerForWeight(size, duration, dealWeight, verifiedWeight)
 }
 func FromV2FilterEstimate(v1 smoothing2.FilterEstimate) FilterEstimate {
 	return (FilterEstimate)(v1)
 }
 type ActorStateLoader func(store adt.Store, root cid.Cid) (cbor.Marshaler, error)
 var ActorStateLoaders = make(map[cid.Cid]ActorStateLoader)
 func RegisterActorState(code cid.Cid, loader ActorStateLoader) {
 	ActorStateLoaders[code] = loader
 }
 func Load(store adt.Store, act *types.Actor) (cbor.Marshaler, error) {
 	loader, found := ActorStateLoaders[act.Code]
 	if !found {
 		return nil, xerrors.Errorf("unknown actor code %s", act.Code)
 	}
 	return loader(store, act.Head)
 }
 func ActorNameByCode(c cid.Cid) string {
 	switch {
 	case builtin0.IsBuiltinActor(c):
 		return builtin0.ActorNameByCode(c)
 	case builtin2.IsBuiltinActor(c):
 		return builtin2.ActorNameByCode(c)
 	default:
 		return "<unknown>"
 	}
 }
 func IsBuiltinActor(c cid.Cid) bool {
 	return builtin0.IsBuiltinActor(c) || builtin2.IsBuiltinActor(c)
 }
 func IsAccountActor(c cid.Cid) bool {
 	return c == builtin0.AccountActorCodeID || c == builtin2.AccountActorCodeID
 }
 func IsStorageMinerActor(c cid.Cid) bool {
 	return c == builtin0.StorageMinerActorCodeID || c == builtin2.StorageMinerActorCodeID
 }
 func IsMultisigActor(c cid.Cid) bool {
 	return c == builtin0.MultisigActorCodeID || c == builtin2.MultisigActorCodeID
 }
 func IsPaymentChannelActor(c cid.Cid) bool {
 	return c == builtin0.PaymentChannelActorCodeID || c == builtin2.PaymentChannelActorCodeID
 }
 func makeAddress(addr string) address.Address {
 	ret, err := address.NewFromString(addr)
 	if err != nil {
 		panic(err)
 	}
 	return ret
 }
--- a/chain/actors/builtin/cron/cron.go
+++ b/chain/actors/builtin/cron/cron.go
@ -0,0 +1,10 @@
 package cron
 import (
 	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
 )
 var (
 	Address = builtin2.CronActorAddr
 	Methods = builtin2.MethodsCron
 )
--- a/chain/actors/builtin/init/diff.go
+++ b/chain/actors/builtin/init/diff.go
@ -0,0 +1,152 @@
 package init
 import (
 	"bytes"
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
 	typegen "github.com/whyrusleeping/cbor-gen"
 	"github.com/filecoin-project/lotus/chain/actors/adt"
 )
 func DiffAddressMap(pre, cur State) (*AddressMapChanges, error) {
 	prem, err := pre.addressMap()
 	if err != nil {
 		return nil, err
 	}
 	curm, err := cur.addressMap()
 	if err != nil {
 		return nil, err
 	}
 	preRoot, err := prem.Root()
 	if err != nil {
 		return nil, err
 	}
 	curRoot, err := curm.Root()
 	if err != nil {
 		return nil, err
 	}
 	results := new(AddressMapChanges)
 	// no change.
 	if curRoot.Equals(preRoot) {
 		return results, nil
 	}
 	err = adt.DiffAdtMap(prem, curm, &addressMapDiffer{results, pre, cur})
 	if err != nil {
 		return nil, err
 	}
 	return results, nil
 }
 type addressMapDiffer struct {
 	Results    *AddressMapChanges
 	pre, adter State
 }
 type AddressMapChanges struct {
 	Added    []AddressPair
 	Modified []AddressChange
 	Removed  []AddressPair
 }
 func (i *addressMapDiffer) AsKey(key string) (abi.Keyer, error) {
 	addr, err := address.NewFromBytes([]byte(key))
 	if err != nil {
 		return nil, err
 	}
 	return abi.AddrKey(addr), nil
 }
 func (i *addressMapDiffer) Add(key string, val *typegen.Deferred) error {
 	pkAddr, err := address.NewFromBytes([]byte(key))
 	if err != nil {
 		return err
 	}
 	id := new(typegen.CborInt)
 	if err := id.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil {
 		return err
 	}
 	idAddr, err := address.NewIDAddress(uint64(*id))
 	if err != nil {
 		return err
 	}
 	i.Results.Added = append(i.Results.Added, AddressPair{
 		ID: idAddr,
 		PK: pkAddr,
 	})
 	return nil
 }
 func (i *addressMapDiffer) Modify(key string, from, to *typegen.Deferred) error {
 	pkAddr, err := address.NewFromBytes([]byte(key))
 	if err != nil {
 		return err
 	}
 	fromID := new(typegen.CborInt)
 	if err := fromID.UnmarshalCBOR(bytes.NewReader(from.Raw)); err != nil {
 		return err
 	}
 	fromIDAddr, err := address.NewIDAddress(uint64(*fromID))
 	if err != nil {
 		return err
 	}
 	toID := new(typegen.CborInt)
 	if err := toID.UnmarshalCBOR(bytes.NewReader(to.Raw)); err != nil {
 		return err
 	}
 	toIDAddr, err := address.NewIDAddress(uint64(*toID))
 	if err != nil {
 		return err
 	}
 	i.Results.Modified = append(i.Results.Modified, AddressChange{
 		From: AddressPair{
 			ID: fromIDAddr,
 			PK: pkAddr,
 		},
 		To: AddressPair{
 			ID: toIDAddr,
 			PK: pkAddr,
 		},
 	})
 	return nil
 }
 func (i *addressMapDiffer) Remove(key string, val *typegen.Deferred) error {
 	pkAddr, err := address.NewFromBytes([]byte(key))
 	if err != nil {
 		return err
 	}
 	id := new(typegen.CborInt)
 	if err := id.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil {
 		return err
 	}
 	idAddr, err := address.NewIDAddress(uint64(*id))
 	if err != nil {
 		return err
 	}
 	i.Results.Removed = append(i.Results.Removed, AddressPair{
 		ID: idAddr,
 		PK: pkAddr,
 	})
 	return nil
 }
 type AddressChange struct {
 	From AddressPair
 	To   AddressPair
 }
 type AddressPair struct {
 	ID address.Address
 	PK address.Address
 }
--- a/chain/actors/builtin/init/init.go
+++ b/chain/actors/builtin/init/init.go
@ -6,24 +6,37 @@ import (
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/cbor"
-	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
+	"github.com/ipfs/go-cid"
 	"github.com/filecoin-project/lotus/chain/actors/adt"
 	"github.com/filecoin-project/lotus/chain/actors/builtin"
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/node/modules/dtypes"
 	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
 	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
 )
-var Address = builtin0.InitActorAddr
+func init() {
 	builtin.RegisterActorState(builtin0.InitActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
 		return load0(store, root)
 	})
 	builtin.RegisterActorState(builtin2.InitActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
 		return load2(store, root)
 	})
 }
 var (
 	Address = builtin2.InitActorAddr
 	Methods = builtin2.MethodsInit
 )
 func Load(store adt.Store, act *types.Actor) (State, error) {
 	switch act.Code {
 	case builtin0.InitActorCodeID:
-		out := state0{store: store}
+		return load0(store, act.Head)
-		err := store.Get(store.Context(), act.Head, &out)
+	case builtin2.InitActorCodeID:
-		if err != nil {
+		return load2(store, act.Head)
 			return nil, err
 		}
 		return &out, nil
 	}
 	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
 }
@ -41,4 +54,9 @@ type State interface {
 	// It should not be used in production code, as init actor entries are
 	// immutable.
 	Remove(addrs ...address.Address) error
 	// Sets the network's name. This should only be used on upgrade/fork.
 	SetNetworkName(name string) error
 	addressMap() (adt.Map, error)
 }
--- a/chain/actors/builtin/init/v0.go
+++ b/chain/actors/builtin/init/v0.go
@ -3,21 +3,30 @@ package init
 import (
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/ipfs/go-cid"
 	cbg "github.com/whyrusleeping/cbor-gen"
 	"golang.org/x/xerrors"
 	init_ "github.com/filecoin-project/specs-actors/actors/builtin/init"
 	"github.com/filecoin-project/lotus/chain/actors/adt"
 	"github.com/filecoin-project/lotus/node/modules/dtypes"
 	init0 "github.com/filecoin-project/specs-actors/actors/builtin/init"
 	adt0 "github.com/filecoin-project/specs-actors/actors/util/adt"
 )
 var _ State = (*state0)(nil)
 func load0(store adt.Store, root cid.Cid) (State, error) {
 	out := state0{store: store}
 	err := store.Get(store.Context(), root, &out)
 	if err != nil {
 		return nil, err
 	}
 	return &out, nil
 }
 type state0 struct {
-	init_.State
+	init0.State
 	store adt.Store
 }
@ -48,6 +57,11 @@ func (s *state0) NetworkName() (dtypes.NetworkName, error) {
 	return dtypes.NetworkName(s.State.NetworkName), nil
 }
 func (s *state0) SetNetworkName(name string) error {
 	s.State.NetworkName = name
 	return nil
 }
 func (s *state0) Remove(addrs ...address.Address) (err error) {
 	m, err := adt0.AsMap(s.store, s.State.AddressMap)
 	if err != nil {
@ -65,3 +79,7 @@ func (s *state0) Remove(addrs ...address.Address) (err error) {
 	s.State.AddressMap = amr
 	return nil
 }
 func (s *state0) addressMap() (adt.Map, error) {
 	return adt0.AsMap(s.store, s.AddressMap)
 }
--- a/chain/actors/builtin/init/v2.go
+++ b/chain/actors/builtin/init/v2.go
@ -0,0 +1,85 @@
 package init
 import (
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/ipfs/go-cid"
 	cbg "github.com/whyrusleeping/cbor-gen"
 	"golang.org/x/xerrors"
 	"github.com/filecoin-project/lotus/chain/actors/adt"
 	"github.com/filecoin-project/lotus/node/modules/dtypes"
 	init2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/init"
 	adt2 "github.com/filecoin-project/specs-actors/v2/actors/util/adt"
 )
 var _ State = (*state2)(nil)
 func load2(store adt.Store, root cid.Cid) (State, error) {
 	out := state2{store: store}
 	err := store.Get(store.Context(), root, &out)
 	if err != nil {
 		return nil, err
 	}
 	return &out, nil
 }
 type state2 struct {
 	init2.State
 	store adt.Store
 }
 func (s *state2) ResolveAddress(address address.Address) (address.Address, bool, error) {
 	return s.State.ResolveAddress(s.store, address)
 }
 func (s *state2) MapAddressToNewID(address address.Address) (address.Address, error) {
 	return s.State.MapAddressToNewID(s.store, address)
 }
 func (s *state2) ForEachActor(cb func(id abi.ActorID, address address.Address) error) error {
 	addrs, err := adt2.AsMap(s.store, s.State.AddressMap)
 	if err != nil {
 		return err
 	}
 	var actorID cbg.CborInt
 	return addrs.ForEach(&actorID, func(key string) error {
 		addr, err := address.NewFromBytes([]byte(key))
 		if err != nil {
 			return err
 		}
 		return cb(abi.ActorID(actorID), addr)
 	})
 }
 func (s *state2) NetworkName() (dtypes.NetworkName, error) {
 	return dtypes.NetworkName(s.State.NetworkName), nil
 }
 func (s *state2) SetNetworkName(name string) error {
 	s.State.NetworkName = name
 	return nil
 }
 func (s *state2) Remove(addrs ...address.Address) (err error) {
 	m, err := adt2.AsMap(s.store, s.State.AddressMap)
 	if err != nil {
 		return err
 	}
 	for _, addr := range addrs {
 		if err = m.Delete(abi.AddrKey(addr)); err != nil {
 			return xerrors.Errorf("failed to delete entry for address: %s; err: %w", addr, err)
 		}
 	}
 	amr, err := m.Root()
 	if err != nil {
 		return xerrors.Errorf("failed to get address map root: %w", err)
 	}
 	s.State.AddressMap = amr
 	return nil
 }
 func (s *state2) addressMap() (adt.Map, error) {
 	return adt2.AsMap(s.store, s.AddressMap)
 }
--- a/chain/actors/builtin/market/market.go
+++ b/chain/actors/builtin/market/market.go
@ -6,26 +6,38 @@ import (
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/cbor"
 	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
 	market0 "github.com/filecoin-project/specs-actors/actors/builtin/market"
 	"github.com/ipfs/go-cid"
 	cbg "github.com/whyrusleeping/cbor-gen"
 	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
 	market0 "github.com/filecoin-project/specs-actors/actors/builtin/market"
 	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
 	"github.com/filecoin-project/lotus/chain/actors/adt"
 	"github.com/filecoin-project/lotus/chain/actors/builtin"
 	"github.com/filecoin-project/lotus/chain/types"
 )
-var Address = builtin0.StorageMarketActorAddr
+func init() {
 	builtin.RegisterActorState(builtin0.StorageMarketActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
 		return load0(store, root)
 	})
 	builtin.RegisterActorState(builtin2.StorageMarketActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
 		return load2(store, root)
 	})
 }
 var (
 	Address = builtin2.StorageMarketActorAddr
 	Methods = builtin2.MethodsMarket
 )
 func Load(store adt.Store, act *types.Actor) (st State, err error) {
 	switch act.Code {
 	case builtin0.StorageMarketActorCodeID:
-		out := state0{store: store}
+		return load0(store, act.Head)
-		err := store.Get(store.Context(), act.Head, &out)
+	case builtin2.StorageMarketActorCodeID:
-		if err != nil {
+		return load2(store, act.Head)
 			return nil, err
 		}
 		return &out, nil
 	}
 	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
 }
@ -69,6 +81,7 @@ type DealProposals interface {
 type PublishStorageDealsParams = market0.PublishStorageDealsParams
 type PublishStorageDealsReturn = market0.PublishStorageDealsReturn
 type VerifyDealsForActivationParams = market0.VerifyDealsForActivationParams
 type WithdrawBalanceParams = market0.WithdrawBalanceParams
 type ClientDealProposal = market0.ClientDealProposal
--- a/chain/actors/builtin/market/v0.go
+++ b/chain/actors/builtin/market/v0.go
@ -5,17 +5,29 @@ import (
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/ipfs/go-cid"
 	cbg "github.com/whyrusleeping/cbor-gen"
 	"github.com/filecoin-project/lotus/chain/actors/adt"
 	"github.com/filecoin-project/lotus/chain/types"
-	"github.com/filecoin-project/specs-actors/actors/builtin/market"
+
 	market0 "github.com/filecoin-project/specs-actors/actors/builtin/market"
 	adt0 "github.com/filecoin-project/specs-actors/actors/util/adt"
 	cbg "github.com/whyrusleeping/cbor-gen"
 )
 var _ State = (*state0)(nil)
 func load0(store adt.Store, root cid.Cid) (State, error) {
 	out := state0{store: store}
 	err := store.Get(store.Context(), root, &out)
 	if err != nil {
 		return nil, err
 	}
 	return &out, nil
 }
 type state0 struct {
-	market.State
+	market0.State
 	store adt.Store
 }
@ -90,7 +102,7 @@ func (s *state0) LockedTable() (BalanceTable, error) {
 func (s *state0) VerifyDealsForActivation(
 	minerAddr address.Address, deals []abi.DealID, currEpoch, sectorExpiry abi.ChainEpoch,
 ) (weight, verifiedWeight abi.DealWeight, err error) {
-	return market.ValidateDealsForActivation(&s.State, s.store, deals, minerAddr, sectorExpiry, currEpoch)
+	return market0.ValidateDealsForActivation(&s.State, s.store, deals, minerAddr, sectorExpiry, currEpoch)
 }
 type balanceTable0 struct {
@ -114,7 +126,7 @@ type dealStates0 struct {
 }
 func (s *dealStates0) Get(dealID abi.DealID) (*DealState, bool, error) {
-	var deal0 market.DealState
+	var deal0 market0.DealState
 	found, err := s.Array.Get(uint64(dealID), &deal0)
 	if err != nil {
 		return nil, false, err
@ -127,14 +139,14 @@ func (s *dealStates0) Get(dealID abi.DealID) (*DealState, bool, error) {
 }
 func (s *dealStates0) ForEach(cb func(dealID abi.DealID, ds DealState) error) error {
-	var ds0 market.DealState
+	var ds0 market0.DealState
 	return s.Array.ForEach(&ds0, func(idx int64) error {
 		return cb(abi.DealID(idx), fromV0DealState(ds0))
 	})
 }
 func (s *dealStates0) decode(val *cbg.Deferred) (*DealState, error) {
-	var ds0 market.DealState
+	var ds0 market0.DealState
 	if err := ds0.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil {
 		return nil, err
 	}
@ -146,7 +158,7 @@ func (s *dealStates0) array() adt.Array {
 	return s.Array
 }
-func fromV0DealState(v0 market.DealState) DealState {
+func fromV0DealState(v0 market0.DealState) DealState {
 	return (DealState)(v0)
 }
@ -155,7 +167,7 @@ type dealProposals0 struct {
 }
 func (s *dealProposals0) Get(dealID abi.DealID) (*DealProposal, bool, error) {
-	var proposal0 market.DealProposal
+	var proposal0 market0.DealProposal
 	found, err := s.Array.Get(uint64(dealID), &proposal0)
 	if err != nil {
 		return nil, false, err
@ -168,14 +180,14 @@ func (s *dealProposals0) Get(dealID abi.DealID) (*DealProposal, bool, error) {
 }
 func (s *dealProposals0) ForEach(cb func(dealID abi.DealID, dp DealProposal) error) error {
-	var dp0 market.DealProposal
+	var dp0 market0.DealProposal
 	return s.Array.ForEach(&dp0, func(idx int64) error {
 		return cb(abi.DealID(idx), fromV0DealProposal(dp0))
 	})
 }
 func (s *dealProposals0) decode(val *cbg.Deferred) (*DealProposal, error) {
-	var dp0 market.DealProposal
+	var dp0 market0.DealProposal
 	if err := dp0.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil {
 		return nil, err
 	}
@ -187,6 +199,6 @@ func (s *dealProposals0) array() adt.Array {
 	return s.Array
 }
-func fromV0DealProposal(v0 market.DealProposal) DealProposal {
+func fromV0DealProposal(v0 market0.DealProposal) DealProposal {
 	return (DealProposal)(v0)
 }
--- a/chain/actors/builtin/market/v2.go
+++ b/chain/actors/builtin/market/v2.go
@ -0,0 +1,205 @@
 package market
 import (
 	"bytes"
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/ipfs/go-cid"
 	cbg "github.com/whyrusleeping/cbor-gen"
 	"github.com/filecoin-project/lotus/chain/actors/adt"
 	"github.com/filecoin-project/lotus/chain/types"
 	market2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/market"
 	adt2 "github.com/filecoin-project/specs-actors/v2/actors/util/adt"
 )
 var _ State = (*state2)(nil)
 func load2(store adt.Store, root cid.Cid) (State, error) {
 	out := state2{store: store}
 	err := store.Get(store.Context(), root, &out)
 	if err != nil {
 		return nil, err
 	}
 	return &out, nil
 }
 type state2 struct {
 	market2.State
 	store adt.Store
 }
 func (s *state2) TotalLocked() (abi.TokenAmount, error) {
 	fml := types.BigAdd(s.TotalClientLockedCollateral, s.TotalProviderLockedCollateral)
 	fml = types.BigAdd(fml, s.TotalClientStorageFee)
 	return fml, nil
 }
 func (s *state2) BalancesChanged(otherState State) (bool, error) {
 	otherState2, ok := otherState.(*state2)
 	if !ok {
 		// there's no way to compare different versions of the state, so let's
 		// just say that means the state of balances has changed
 		return true, nil
 	}
 	return !s.State.EscrowTable.Equals(otherState2.State.EscrowTable) || !s.State.LockedTable.Equals(otherState2.State.LockedTable), nil
 }
 func (s *state2) StatesChanged(otherState State) (bool, error) {
 	otherState2, ok := otherState.(*state2)
 	if !ok {
 		// there's no way to compare different versions of the state, so let's
 		// just say that means the state of balances has changed
 		return true, nil
 	}
 	return !s.State.States.Equals(otherState2.State.States), nil
 }
 func (s *state2) States() (DealStates, error) {
 	stateArray, err := adt2.AsArray(s.store, s.State.States)
 	if err != nil {
 		return nil, err
 	}
 	return &dealStates2{stateArray}, nil
 }
 func (s *state2) ProposalsChanged(otherState State) (bool, error) {
 	otherState2, ok := otherState.(*state2)
 	if !ok {
 		// there's no way to compare different versions of the state, so let's
 		// just say that means the state of balances has changed
 		return true, nil
 	}
 	return !s.State.Proposals.Equals(otherState2.State.Proposals), nil
 }
 func (s *state2) Proposals() (DealProposals, error) {
 	proposalArray, err := adt2.AsArray(s.store, s.State.Proposals)
 	if err != nil {
 		return nil, err
 	}
 	return &dealProposals2{proposalArray}, nil
 }
 func (s *state2) EscrowTable() (BalanceTable, error) {
 	bt, err := adt2.AsBalanceTable(s.store, s.State.EscrowTable)
 	if err != nil {
 		return nil, err
 	}
 	return &balanceTable2{bt}, nil
 }
 func (s *state2) LockedTable() (BalanceTable, error) {
 	bt, err := adt2.AsBalanceTable(s.store, s.State.LockedTable)
 	if err != nil {
 		return nil, err
 	}
 	return &balanceTable2{bt}, nil
 }
 func (s *state2) VerifyDealsForActivation(
 	minerAddr address.Address, deals []abi.DealID, currEpoch, sectorExpiry abi.ChainEpoch,
 ) (weight, verifiedWeight abi.DealWeight, err error) {
 	w, vw, _, err := market2.ValidateDealsForActivation(&s.State, s.store, deals, minerAddr, sectorExpiry, currEpoch)
 	return w, vw, err
 }
 type balanceTable2 struct {
 	*adt2.BalanceTable
 }
 func (bt *balanceTable2) ForEach(cb func(address.Address, abi.TokenAmount) error) error {
 	asMap := (*adt2.Map)(bt.BalanceTable)
 	var ta abi.TokenAmount
 	return asMap.ForEach(&ta, func(key string) error {
 		a, err := address.NewFromBytes([]byte(key))
 		if err != nil {
 			return err
 		}
 		return cb(a, ta)
 	})
 }
 type dealStates2 struct {
 	adt.Array
 }
 func (s *dealStates2) Get(dealID abi.DealID) (*DealState, bool, error) {
 	var deal2 market2.DealState
 	found, err := s.Array.Get(uint64(dealID), &deal2)
 	if err != nil {
 		return nil, false, err
 	}
 	if !found {
 		return nil, false, nil
 	}
 	deal := fromV2DealState(deal2)
 	return &deal, true, nil
 }
 func (s *dealStates2) ForEach(cb func(dealID abi.DealID, ds DealState) error) error {
 	var ds1 market2.DealState
 	return s.Array.ForEach(&ds1, func(idx int64) error {
 		return cb(abi.DealID(idx), fromV2DealState(ds1))
 	})
 }
 func (s *dealStates2) decode(val *cbg.Deferred) (*DealState, error) {
 	var ds1 market2.DealState
 	if err := ds1.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil {
 		return nil, err
 	}
 	ds := fromV2DealState(ds1)
 	return &ds, nil
 }
 func (s *dealStates2) array() adt.Array {
 	return s.Array
 }
 func fromV2DealState(v1 market2.DealState) DealState {
 	return (DealState)(v1)
 }
 type dealProposals2 struct {
 	adt.Array
 }
 func (s *dealProposals2) Get(dealID abi.DealID) (*DealProposal, bool, error) {
 	var proposal2 market2.DealProposal
 	found, err := s.Array.Get(uint64(dealID), &proposal2)
 	if err != nil {
 		return nil, false, err
 	}
 	if !found {
 		return nil, false, nil
 	}
 	proposal := fromV2DealProposal(proposal2)
 	return &proposal, true, nil
 }
 func (s *dealProposals2) ForEach(cb func(dealID abi.DealID, dp DealProposal) error) error {
 	var dp1 market2.DealProposal
 	return s.Array.ForEach(&dp1, func(idx int64) error {
 		return cb(abi.DealID(idx), fromV2DealProposal(dp1))
 	})
 }
 func (s *dealProposals2) decode(val *cbg.Deferred) (*DealProposal, error) {
 	var dp1 market2.DealProposal
 	if err := dp1.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil {
 		return nil, err
 	}
 	dp := fromV2DealProposal(dp1)
 	return &dp, nil
 }
 func (s *dealProposals2) array() adt.Array {
 	return s.Array
 }
 func fromV2DealProposal(v1 market2.DealProposal) DealProposal {
 	return (DealProposal)(v1)
 }
--- a/chain/actors/builtin/miner/diff_deadlines.go
+++ b/chain/actors/builtin/miner/diff_deadlines.go
@ -0,0 +1,176 @@
 package miner
 import (
 	"errors"
 	"github.com/filecoin-project/go-bitfield"
 	"github.com/filecoin-project/go-state-types/exitcode"
 )
 type DeadlinesDiff map[uint64]DeadlineDiff
 func DiffDeadlines(pre, cur State) (DeadlinesDiff, error) {
 	changed, err := pre.DeadlinesChanged(cur)
 	if err != nil {
 		return nil, err
 	}
 	if !changed {
 		return nil, nil
 	}
 	dlDiff := make(DeadlinesDiff)
 	if err := pre.ForEachDeadline(func(idx uint64, preDl Deadline) error {
 		curDl, err := cur.LoadDeadline(idx)
 		if err != nil {
 			return err
 		}
 		diff, err := DiffDeadline(preDl, curDl)
 		if err != nil {
 			return err
 		}
 		dlDiff[idx] = diff
 		return nil
 	}); err != nil {
 		return nil, err
 	}
 	return dlDiff, nil
 }
 type DeadlineDiff map[uint64]*PartitionDiff
 func DiffDeadline(pre, cur Deadline) (DeadlineDiff, error) {
 	changed, err := pre.PartitionsChanged(cur)
 	if err != nil {
 		return nil, err
 	}
 	if !changed {
 		return nil, nil
 	}
 	partDiff := make(DeadlineDiff)
 	if err := pre.ForEachPartition(func(idx uint64, prePart Partition) error {
 		// try loading current partition at this index
 		curPart, err := cur.LoadPartition(idx)
 		if err != nil {
 			if errors.Is(err, exitcode.ErrNotFound) {
 				// TODO correctness?
 				return nil // the partition was removed.
 			}
 			return err
 		}
 		// compare it with the previous partition
 		diff, err := DiffPartition(prePart, curPart)
 		if err != nil {
 			return err
 		}
 		partDiff[idx] = diff
 		return nil
 	}); err != nil {
 		return nil, err
 	}
 	// all previous partitions have been walked.
 	// all partitions in cur and not in prev are new... can they be faulty already?
 	// TODO is this correct?
 	if err := cur.ForEachPartition(func(idx uint64, curPart Partition) error {
 		if _, found := partDiff[idx]; found {
 			return nil
 		}
 		faults, err := curPart.FaultySectors()
 		if err != nil {
 			return err
 		}
 		recovering, err := curPart.RecoveringSectors()
 		if err != nil {
 			return err
 		}
 		partDiff[idx] = &PartitionDiff{
 			Removed:    bitfield.New(),
 			Recovered:  bitfield.New(),
 			Faulted:    faults,
 			Recovering: recovering,
 		}
 		return nil
 	}); err != nil {
 		return nil, err
 	}
 	return partDiff, nil
 }
 type PartitionDiff struct {
 	Removed    bitfield.BitField
 	Recovered  bitfield.BitField
 	Faulted    bitfield.BitField
 	Recovering bitfield.BitField
 }
 func DiffPartition(pre, cur Partition) (*PartitionDiff, error) {
 	prevLiveSectors, err := pre.LiveSectors()
 	if err != nil {
 		return nil, err
 	}
 	curLiveSectors, err := cur.LiveSectors()
 	if err != nil {
 		return nil, err
 	}
 	removed, err := bitfield.SubtractBitField(prevLiveSectors, curLiveSectors)
 	if err != nil {
 		return nil, err
 	}
 	prevRecoveries, err := pre.RecoveringSectors()
 	if err != nil {
 		return nil, err
 	}
 	curRecoveries, err := cur.RecoveringSectors()
 	if err != nil {
 		return nil, err
 	}
 	recovering, err := bitfield.SubtractBitField(curRecoveries, prevRecoveries)
 	if err != nil {
 		return nil, err
 	}
 	prevFaults, err := pre.FaultySectors()
 	if err != nil {
 		return nil, err
 	}
 	curFaults, err := cur.FaultySectors()
 	if err != nil {
 		return nil, err
 	}
 	faulted, err := bitfield.SubtractBitField(curFaults, prevFaults)
 	if err != nil {
 		return nil, err
 	}
 	// all current good sectors
 	curActiveSectors, err := cur.ActiveSectors()
 	if err != nil {
 		return nil, err
 	}
 	// sectors that were previously fault and are now currently active are considered recovered.
 	recovered, err := bitfield.IntersectBitField(prevFaults, curActiveSectors)
 	if err != nil {
 		return nil, err
 	}
 	return &PartitionDiff{
 		Removed:    removed,
 		Recovered:  recovered,
 		Faulted:    faulted,
 		Recovering: recovering,
 	}, nil
 }
--- a/chain/actors/builtin/miner/miner.go
+++ b/chain/actors/builtin/miner/miner.go
@ -1,6 +1,7 @@
 package miner
 import (
 	"github.com/filecoin-project/go-state-types/big"
 	"github.com/ipfs/go-cid"
 	"github.com/libp2p/go-libp2p-core/peer"
 	cbg "github.com/whyrusleeping/cbor-gen"
@ -11,27 +12,42 @@ import (
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/cbor"
 	"github.com/filecoin-project/go-state-types/dline"
 	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
 	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
 	"github.com/filecoin-project/lotus/chain/actors/adt"
 	"github.com/filecoin-project/lotus/chain/actors/builtin"
 	"github.com/filecoin-project/lotus/chain/types"
 	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
 	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
 	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
 )
-// Unchanged between v0 and v1 actors
+func init() {
 	builtin.RegisterActorState(builtin0.StorageMinerActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
 		return load0(store, root)
 	})
 	builtin.RegisterActorState(builtin2.StorageMinerActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
 		return load2(store, root)
 	})
 }
 var Methods = builtin2.MethodsMiner
 // Unchanged between v0 and v2 actors
 var WPoStProvingPeriod = miner0.WPoStProvingPeriod
 var WPoStPeriodDeadlines = miner0.WPoStPeriodDeadlines
 var WPoStChallengeWindow = miner0.WPoStChallengeWindow
 var WPoStChallengeLookback = miner0.WPoStChallengeLookback
 var FaultDeclarationCutoff = miner0.FaultDeclarationCutoff
 const MinSectorExpiration = miner0.MinSectorExpiration
 func Load(store adt.Store, act *types.Actor) (st State, err error) {
 	switch act.Code {
 	case builtin0.StorageMinerActorCodeID:
-		out := state0{store: store}
+		return load0(store, act.Head)
-		err := store.Get(store.Context(), act.Head, &out)
+	case builtin2.StorageMinerActorCodeID:
-		if err != nil {
+		return load2(store, act.Head)
 			return nil, err
 		}
 		return &out, nil
 	}
 	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
 }
@ -45,6 +61,7 @@ type State interface {
 	VestedFunds(abi.ChainEpoch) (abi.TokenAmount, error)
 	// Funds locked for various reasons.
 	LockedFunds() (LockedFunds, error)
 	FeeDebt() (abi.TokenAmount, error)
 	GetSector(abi.SectorNumber) (*SectorOnChainInfo, error)
 	FindSector(abi.SectorNumber) (*SectorLocation, error)
@ -60,6 +77,7 @@ type State interface {
 	DeadlinesChanged(State) (bool, error)
 	Info() (MinerInfo, error)
 	MinerInfoChanged(State) (bool, error)
 	DeadlineInfo(epoch abi.ChainEpoch) (*dline.Info, error)
@ -131,6 +149,21 @@ type MinerInfo struct {
 	SealProofType              abi.RegisteredSealProof
 	SectorSize                 abi.SectorSize
 	WindowPoStPartitionSectors uint64
 	ConsensusFaultElapsed      abi.ChainEpoch
 }
 func (mi MinerInfo) IsController(addr address.Address) bool {
 	if addr == mi.Owner || addr == mi.Worker {
 		return true
 	}
 	for _, ca := range mi.ControlAddresses {
 		if addr == ca {
 			return true
 		}
 	}
 	return false
 }
 type SectorExpiration struct {
@ -167,3 +200,7 @@ type LockedFunds struct {
 	InitialPledgeRequirement abi.TokenAmount
 	PreCommitDeposits        abi.TokenAmount
 }
 func (lf LockedFunds) TotalLockedFunds() abi.TokenAmount {
 	return big.Add(lf.VestingFunds, big.Add(lf.InitialPledgeRequirement, lf.PreCommitDeposits))
 }
--- a/chain/actors/builtin/miner/utils.go
+++ b/chain/actors/builtin/miner/utils.go
@ -4,6 +4,8 @@ import (
 	"golang.org/x/xerrors"
 	"github.com/filecoin-project/go-bitfield"
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/network"
 )
 func AllPartSectors(mas State, sget func(Partition) (bitfield.BitField, error)) (bitfield.BitField, error) {
@ -26,3 +28,42 @@ func AllPartSectors(mas State, sget func(Partition) (bitfield.BitField, error))
 	return bitfield.MultiMerge(parts...)
 }
 // SealProofTypeFromSectorSize returns preferred seal proof type for creating
 // new miner actors and new sectors
 func SealProofTypeFromSectorSize(ssize abi.SectorSize, nv network.Version) (abi.RegisteredSealProof, error) {
 	switch {
 	case nv < network.Version7:
 		switch ssize {
 		case 2 << 10:
 			return abi.RegisteredSealProof_StackedDrg2KiBV1, nil
 		case 8 << 20:
 			return abi.RegisteredSealProof_StackedDrg8MiBV1, nil
 		case 512 << 20:
 			return abi.RegisteredSealProof_StackedDrg512MiBV1, nil
 		case 32 << 30:
 			return abi.RegisteredSealProof_StackedDrg32GiBV1, nil
 		case 64 << 30:
 			return abi.RegisteredSealProof_StackedDrg64GiBV1, nil
 		default:
 			return 0, xerrors.Errorf("unsupported sector size for miner: %v", ssize)
 		}
 	case nv >= network.Version7:
 		switch ssize {
 		case 2 << 10:
 			return abi.RegisteredSealProof_StackedDrg2KiBV1_1, nil
 		case 8 << 20:
 			return abi.RegisteredSealProof_StackedDrg8MiBV1_1, nil
 		case 512 << 20:
 			return abi.RegisteredSealProof_StackedDrg512MiBV1_1, nil
 		case 32 << 30:
 			return abi.RegisteredSealProof_StackedDrg32GiBV1_1, nil
 		case 64 << 30:
 			return abi.RegisteredSealProof_StackedDrg64GiBV1_1, nil
 		default:
 			return 0, xerrors.Errorf("unsupported sector size for miner: %v", ssize)
 		}
 	}
 	return 0, xerrors.Errorf("unsupported network version")
 }
--- a/chain/actors/builtin/miner/v0.go
+++ b/chain/actors/builtin/miner/v0.go
@ -4,21 +4,34 @@ import (
 	"bytes"
 	"errors"
-	"github.com/libp2p/go-libp2p-core/peer"
+	"github.com/filecoin-project/go-state-types/big"
 	cbg "github.com/whyrusleeping/cbor-gen"
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-bitfield"
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/dline"
-	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
+	"github.com/ipfs/go-cid"
-	adt0 "github.com/filecoin-project/specs-actors/actors/util/adt"
+	"github.com/libp2p/go-libp2p-core/peer"
 	cbg "github.com/whyrusleeping/cbor-gen"
 	"golang.org/x/xerrors"
 	"github.com/filecoin-project/lotus/chain/actors/adt"
 	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
 	adt0 "github.com/filecoin-project/specs-actors/actors/util/adt"
 )
 var _ State = (*state0)(nil)
 func load0(store adt.Store, root cid.Cid) (State, error) {
 	out := state0{store: store}
 	err := store.Get(store.Context(), root, &out)
 	if err != nil {
 		return nil, err
 	}
 	return &out, nil
 }
 type state0 struct {
 	miner0.State
 	store adt.Store
@ -34,8 +47,16 @@ type partition0 struct {
 	store adt.Store
 }
-func (s *state0) AvailableBalance(bal abi.TokenAmount) (abi.TokenAmount, error) {
+func (s *state0) AvailableBalance(bal abi.TokenAmount) (available abi.TokenAmount, err error) {
-	return s.GetAvailableBalance(bal), nil
+	defer func() {
 		if r := recover(); r != nil {
 			err = xerrors.Errorf("failed to get available balance: %w", r)
 			available = abi.NewTokenAmount(0)
 		}
 	}()
 	// this panics if the miner doesnt have enough funds to cover their locked pledge
 	available = s.GetAvailableBalance(bal)
 	return available, err
 }
 func (s *state0) VestedFunds(epoch abi.ChainEpoch) (abi.TokenAmount, error) {
@ -50,6 +71,10 @@ func (s *state0) LockedFunds() (LockedFunds, error) {
 	}, nil
 }
 func (s *state0) FeeDebt() (abi.TokenAmount, error) {
 	return big.Zero(), nil
 }
 func (s *state0) InitialPledge() (abi.TokenAmount, error) {
 	return s.State.InitialPledgeRequirement, nil
 }
@ -96,9 +121,7 @@ func (s *state0) NumLiveSectors() (uint64, error) {
 // GetSectorExpiration returns the effective expiration of the given sector.
 //
-// If the sector isn't found or has already been terminated, this method returns
+// If the sector does not expire early, the Early expiration field is 0.
 // nil and no error. If the sector does not expire early, the Early expiration
 // field is 0.
 func (s *state0) GetSectorExpiration(num abi.SectorNumber) (*SectorExpiration, error) {
 	dls, err := s.State.LoadDeadlines(s.store)
 	if err != nil {
@ -161,7 +184,7 @@ func (s *state0) GetSectorExpiration(num abi.SectorNumber) (*SectorExpiration, e
 		return nil, err
 	}
 	if out.Early == 0 && out.OnTime == 0 {
-		return nil, nil
+		return nil, xerrors.Errorf("failed to find sector %d", num)
 	}
 	return &out, nil
 }
@ -251,7 +274,16 @@ func (s *state0) DeadlinesChanged(other State) (bool, error) {
 		return true, nil
 	}
-	return s.State.Deadlines.Equals(other0.Deadlines), nil
+	return !s.State.Deadlines.Equals(other0.Deadlines), nil
 }
 func (s *state0) MinerInfoChanged(other State) (bool, error) {
 	other0, ok := other.(*state0)
 	if !ok {
 		// treat an upgrade as a change, always
 		return true, nil
 	}
 	return !s.State.Info.Equals(other0.State.Info), nil
 }
 func (s *state0) Info() (MinerInfo, error) {
@ -278,6 +310,7 @@ func (s *state0) Info() (MinerInfo, error) {
 		SealProofType:              info.SealProofType,
 		SectorSize:                 info.SectorSize,
 		WindowPoStPartitionSectors: info.WindowPoStPartitionSectors,
 		ConsensusFaultElapsed:      -1,
 	}
 	if info.PendingWorkerKey != nil {
@ -346,7 +379,7 @@ func (d *deadline0) PartitionsChanged(other Deadline) (bool, error) {
 		return true, nil
 	}
-	return d.Deadline.Partitions.Equals(other0.Deadline.Partitions), nil
+	return !d.Deadline.Partitions.Equals(other0.Deadline.Partitions), nil
 }
 func (d *deadline0) PostSubmissions() (bitfield.BitField, error) {
--- a/chain/actors/builtin/miner/v2.go
+++ b/chain/actors/builtin/miner/v2.go
@ -0,0 +1,424 @@
 package miner
 import (
 	"bytes"
 	"errors"
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-bitfield"
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/dline"
 	"github.com/ipfs/go-cid"
 	"github.com/libp2p/go-libp2p-core/peer"
 	cbg "github.com/whyrusleeping/cbor-gen"
 	"golang.org/x/xerrors"
 	"github.com/filecoin-project/lotus/chain/actors/adt"
 	miner2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/miner"
 	adt2 "github.com/filecoin-project/specs-actors/v2/actors/util/adt"
 )
 var _ State = (*state2)(nil)
 func load2(store adt.Store, root cid.Cid) (State, error) {
 	out := state2{store: store}
 	err := store.Get(store.Context(), root, &out)
 	if err != nil {
 		return nil, err
 	}
 	return &out, nil
 }
 type state2 struct {
 	miner2.State
 	store adt.Store
 }
 type deadline2 struct {
 	miner2.Deadline
 	store adt.Store
 }
 type partition2 struct {
 	miner2.Partition
 	store adt.Store
 }
 func (s *state2) AvailableBalance(bal abi.TokenAmount) (available abi.TokenAmount, err error) {
 	defer func() {
 		if r := recover(); r != nil {
 			err = xerrors.Errorf("failed to get available balance: %w", r)
 			available = abi.NewTokenAmount(0)
 		}
 	}()
 	// this panics if the miner doesnt have enough funds to cover their locked pledge
 	available, err = s.GetAvailableBalance(bal)
 	return available, err
 }
 func (s *state2) VestedFunds(epoch abi.ChainEpoch) (abi.TokenAmount, error) {
 	return s.CheckVestedFunds(s.store, epoch)
 }
 func (s *state2) LockedFunds() (LockedFunds, error) {
 	return LockedFunds{
 		VestingFunds:             s.State.LockedFunds,
 		InitialPledgeRequirement: s.State.InitialPledge,
 		PreCommitDeposits:        s.State.PreCommitDeposits,
 	}, nil
 }
 func (s *state2) FeeDebt() (abi.TokenAmount, error) {
 	return s.State.FeeDebt, nil
 }
 func (s *state2) InitialPledge() (abi.TokenAmount, error) {
 	return s.State.InitialPledge, nil
 }
 func (s *state2) PreCommitDeposits() (abi.TokenAmount, error) {
 	return s.State.PreCommitDeposits, nil
 }
 func (s *state2) GetSector(num abi.SectorNumber) (*SectorOnChainInfo, error) {
 	info, ok, err := s.State.GetSector(s.store, num)
 	if !ok || err != nil {
 		return nil, err
 	}
 	ret := fromV2SectorOnChainInfo(*info)
 	return &ret, nil
 }
 func (s *state2) FindSector(num abi.SectorNumber) (*SectorLocation, error) {
 	dlIdx, partIdx, err := s.State.FindSector(s.store, num)
 	if err != nil {
 		return nil, err
 	}
 	return &SectorLocation{
 		Deadline:  dlIdx,
 		Partition: partIdx,
 	}, nil
 }
 func (s *state2) NumLiveSectors() (uint64, error) {
 	dls, err := s.State.LoadDeadlines(s.store)
 	if err != nil {
 		return 0, err
 	}
 	var total uint64
 	if err := dls.ForEach(s.store, func(dlIdx uint64, dl *miner2.Deadline) error {
 		total += dl.LiveSectors
 		return nil
 	}); err != nil {
 		return 0, err
 	}
 	return total, nil
 }
 // GetSectorExpiration returns the effective expiration of the given sector.
 //
 // If the sector does not expire early, the Early expiration field is 0.
 func (s *state2) GetSectorExpiration(num abi.SectorNumber) (*SectorExpiration, error) {
 	dls, err := s.State.LoadDeadlines(s.store)
 	if err != nil {
 		return nil, err
 	}
 	// NOTE: this can be optimized significantly.
 	// 1. If the sector is non-faulty, it will either expire on-time (can be
 	// learned from the sector info), or in the next quantized expiration
 	// epoch (i.e., the first element in the partition's expiration queue.
 	// 2. If it's faulty, it will expire early within the first 14 entries
 	// of the expiration queue.
 	stopErr := errors.New("stop")
 	out := SectorExpiration{}
 	err = dls.ForEach(s.store, func(dlIdx uint64, dl *miner2.Deadline) error {
 		partitions, err := dl.PartitionsArray(s.store)
 		if err != nil {
 			return err
 		}
 		quant := s.State.QuantSpecForDeadline(dlIdx)
 		var part miner2.Partition
 		return partitions.ForEach(&part, func(partIdx int64) error {
 			if found, err := part.Sectors.IsSet(uint64(num)); err != nil {
 				return err
 			} else if !found {
 				return nil
 			}
 			if found, err := part.Terminated.IsSet(uint64(num)); err != nil {
 				return err
 			} else if found {
 				// already terminated
 				return stopErr
 			}
 			q, err := miner2.LoadExpirationQueue(s.store, part.ExpirationsEpochs, quant)
 			if err != nil {
 				return err
 			}
 			var exp miner2.ExpirationSet
 			return q.ForEach(&exp, func(epoch int64) error {
 				if early, err := exp.EarlySectors.IsSet(uint64(num)); err != nil {
 					return err
 				} else if early {
 					out.Early = abi.ChainEpoch(epoch)
 					return nil
 				}
 				if onTime, err := exp.OnTimeSectors.IsSet(uint64(num)); err != nil {
 					return err
 				} else if onTime {
 					out.OnTime = abi.ChainEpoch(epoch)
 					return stopErr
 				}
 				return nil
 			})
 		})
 	})
 	if err == stopErr {
 		err = nil
 	}
 	if err != nil {
 		return nil, err
 	}
 	if out.Early == 0 && out.OnTime == 0 {
 		return nil, xerrors.Errorf("failed to find sector %d", num)
 	}
 	return &out, nil
 }
 func (s *state2) GetPrecommittedSector(num abi.SectorNumber) (*SectorPreCommitOnChainInfo, error) {
 	info, ok, err := s.State.GetPrecommittedSector(s.store, num)
 	if !ok || err != nil {
 		return nil, err
 	}
 	ret := fromV2SectorPreCommitOnChainInfo(*info)
 	return &ret, nil
 }
 func (s *state2) LoadSectors(snos *bitfield.BitField) ([]*SectorOnChainInfo, error) {
 	sectors, err := miner2.LoadSectors(s.store, s.State.Sectors)
 	if err != nil {
 		return nil, err
 	}
 	// If no sector numbers are specified, load all.
 	if snos == nil {
 		infos := make([]*SectorOnChainInfo, 0, sectors.Length())
 		var info2 miner2.SectorOnChainInfo
 		if err := sectors.ForEach(&info2, func(_ int64) error {
 			info := fromV2SectorOnChainInfo(info2)
 			infos = append(infos, &info)
 			return nil
 		}); err != nil {
 			return nil, err
 		}
 		return infos, nil
 	}
 	// Otherwise, load selected.
 	infos2, err := sectors.Load(*snos)
 	if err != nil {
 		return nil, err
 	}
 	infos := make([]*SectorOnChainInfo, len(infos2))
 	for i, info2 := range infos2 {
 		info := fromV2SectorOnChainInfo(*info2)
 		infos[i] = &info
 	}
 	return infos, nil
 }
 func (s *state2) IsAllocated(num abi.SectorNumber) (bool, error) {
 	var allocatedSectors bitfield.BitField
 	if err := s.store.Get(s.store.Context(), s.State.AllocatedSectors, &allocatedSectors); err != nil {
 		return false, err
 	}
 	return allocatedSectors.IsSet(uint64(num))
 }
 func (s *state2) LoadDeadline(idx uint64) (Deadline, error) {
 	dls, err := s.State.LoadDeadlines(s.store)
 	if err != nil {
 		return nil, err
 	}
 	dl, err := dls.LoadDeadline(s.store, idx)
 	if err != nil {
 		return nil, err
 	}
 	return &deadline2{*dl, s.store}, nil
 }
 func (s *state2) ForEachDeadline(cb func(uint64, Deadline) error) error {
 	dls, err := s.State.LoadDeadlines(s.store)
 	if err != nil {
 		return err
 	}
 	return dls.ForEach(s.store, func(i uint64, dl *miner2.Deadline) error {
 		return cb(i, &deadline2{*dl, s.store})
 	})
 }
 func (s *state2) NumDeadlines() (uint64, error) {
 	return miner2.WPoStPeriodDeadlines, nil
 }
 func (s *state2) DeadlinesChanged(other State) (bool, error) {
 	other2, ok := other.(*state2)
 	if !ok {
 		// treat an upgrade as a change, always
 		return true, nil
 	}
 	return !s.State.Deadlines.Equals(other2.Deadlines), nil
 }
 func (s *state2) MinerInfoChanged(other State) (bool, error) {
 	other0, ok := other.(*state2)
 	if !ok {
 		// treat an upgrade as a change, always
 		return true, nil
 	}
 	return !s.State.Info.Equals(other0.State.Info), nil
 }
 func (s *state2) Info() (MinerInfo, error) {
 	info, err := s.State.GetInfo(s.store)
 	if err != nil {
 		return MinerInfo{}, err
 	}
 	var pid *peer.ID
 	if peerID, err := peer.IDFromBytes(info.PeerId); err == nil {
 		pid = &peerID
 	}
 	mi := MinerInfo{
 		Owner:            info.Owner,
 		Worker:           info.Worker,
 		ControlAddresses: info.ControlAddresses,
 		NewWorker:         address.Undef,
 		WorkerChangeEpoch: -1,
 		PeerId:                     pid,
 		Multiaddrs:                 info.Multiaddrs,
 		SealProofType:              info.SealProofType,
 		SectorSize:                 info.SectorSize,
 		WindowPoStPartitionSectors: info.WindowPoStPartitionSectors,
 		ConsensusFaultElapsed:      info.ConsensusFaultElapsed,
 	}
 	if info.PendingWorkerKey != nil {
 		mi.NewWorker = info.PendingWorkerKey.NewWorker
 		mi.WorkerChangeEpoch = info.PendingWorkerKey.EffectiveAt
 	}
 	return mi, nil
 }
 func (s *state2) DeadlineInfo(epoch abi.ChainEpoch) (*dline.Info, error) {
 	return s.State.DeadlineInfo(epoch), nil
 }
 func (s *state2) sectors() (adt.Array, error) {
 	return adt2.AsArray(s.store, s.Sectors)
 }
 func (s *state2) decodeSectorOnChainInfo(val *cbg.Deferred) (SectorOnChainInfo, error) {
 	var si miner2.SectorOnChainInfo
 	err := si.UnmarshalCBOR(bytes.NewReader(val.Raw))
 	if err != nil {
 		return SectorOnChainInfo{}, err
 	}
 	return fromV2SectorOnChainInfo(si), nil
 }
 func (s *state2) precommits() (adt.Map, error) {
 	return adt2.AsMap(s.store, s.PreCommittedSectors)
 }
 func (s *state2) decodeSectorPreCommitOnChainInfo(val *cbg.Deferred) (SectorPreCommitOnChainInfo, error) {
 	var sp miner2.SectorPreCommitOnChainInfo
 	err := sp.UnmarshalCBOR(bytes.NewReader(val.Raw))
 	if err != nil {
 		return SectorPreCommitOnChainInfo{}, err
 	}
 	return fromV2SectorPreCommitOnChainInfo(sp), nil
 }
 func (d *deadline2) LoadPartition(idx uint64) (Partition, error) {
 	p, err := d.Deadline.LoadPartition(d.store, idx)
 	if err != nil {
 		return nil, err
 	}
 	return &partition2{*p, d.store}, nil
 }
 func (d *deadline2) ForEachPartition(cb func(uint64, Partition) error) error {
 	ps, err := d.Deadline.PartitionsArray(d.store)
 	if err != nil {
 		return err
 	}
 	var part miner2.Partition
 	return ps.ForEach(&part, func(i int64) error {
 		return cb(uint64(i), &partition2{part, d.store})
 	})
 }
 func (d *deadline2) PartitionsChanged(other Deadline) (bool, error) {
 	other2, ok := other.(*deadline2)
 	if !ok {
 		// treat an upgrade as a change, always
 		return true, nil
 	}
 	return !d.Deadline.Partitions.Equals(other2.Deadline.Partitions), nil
 }
 func (d *deadline2) PostSubmissions() (bitfield.BitField, error) {
 	return d.Deadline.PostSubmissions, nil
 }
 func (p *partition2) AllSectors() (bitfield.BitField, error) {
 	return p.Partition.Sectors, nil
 }
 func (p *partition2) FaultySectors() (bitfield.BitField, error) {
 	return p.Partition.Faults, nil
 }
 func (p *partition2) RecoveringSectors() (bitfield.BitField, error) {
 	return p.Partition.Recoveries, nil
 }
 func fromV2SectorOnChainInfo(v2 miner2.SectorOnChainInfo) SectorOnChainInfo {
 	return SectorOnChainInfo{
 		SectorNumber:          v2.SectorNumber,
 		SealProof:             v2.SealProof,
 		SealedCID:             v2.SealedCID,
 		DealIDs:               v2.DealIDs,
 		Activation:            v2.Activation,
 		Expiration:            v2.Expiration,
 		DealWeight:            v2.DealWeight,
 		VerifiedDealWeight:    v2.VerifiedDealWeight,
 		InitialPledge:         v2.InitialPledge,
 		ExpectedDayReward:     v2.ExpectedDayReward,
 		ExpectedStoragePledge: v2.ExpectedStoragePledge,
 	}
 }
 func fromV2SectorPreCommitOnChainInfo(v2 miner2.SectorPreCommitOnChainInfo) SectorPreCommitOnChainInfo {
 	return SectorPreCommitOnChainInfo{
 		Info:               (SectorPreCommitInfo)(v2.Info),
 		PreCommitDeposit:   v2.PreCommitDeposit,
 		PreCommitEpoch:     v2.PreCommitEpoch,
 		DealWeight:         v2.DealWeight,
 		VerifiedDealWeight: v2.VerifiedDealWeight,
 	}
 }
--- a/chain/actors/builtin/multisig/diff.go
+++ b/chain/actors/builtin/multisig/diff.go
@ -0,0 +1,134 @@
 package multisig
 import (
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
 	cbg "github.com/whyrusleeping/cbor-gen"
 	"github.com/filecoin-project/lotus/chain/actors/adt"
 )
 type PendingTransactionChanges struct {
 	Added    []TransactionChange
 	Modified []TransactionModification
 	Removed  []TransactionChange
 }
 type TransactionChange struct {
 	TxID int64
 	Tx   Transaction
 }
 type TransactionModification struct {
 	TxID int64
 	From Transaction
 	To   Transaction
 }
 func DiffPendingTransactions(pre, cur State) (*PendingTransactionChanges, error) {
 	results := new(PendingTransactionChanges)
 	if changed, err := pre.PendingTxnChanged(cur); err != nil {
 		return nil, err
 	} else if !changed { // if nothing has changed then return an empty result and bail.
 		return results, nil
 	}
 	pret, err := pre.transactions()
 	if err != nil {
 		return nil, err
 	}
 	curt, err := cur.transactions()
 	if err != nil {
 		return nil, err
 	}
 	if err := adt.DiffAdtMap(pret, curt, &transactionDiffer{results, pre, cur}); err != nil {
 		return nil, err
 	}
 	return results, nil
 }
 type transactionDiffer struct {
 	Results    *PendingTransactionChanges
 	pre, after State
 }
 func (t *transactionDiffer) AsKey(key string) (abi.Keyer, error) {
 	txID, err := abi.ParseIntKey(key)
 	if err != nil {
 		return nil, err
 	}
 	return abi.IntKey(txID), nil
 }
 func (t *transactionDiffer) Add(key string, val *cbg.Deferred) error {
 	txID, err := abi.ParseIntKey(key)
 	if err != nil {
 		return err
 	}
 	tx, err := t.after.decodeTransaction(val)
 	if err != nil {
 		return err
 	}
 	t.Results.Added = append(t.Results.Added, TransactionChange{
 		TxID: txID,
 		Tx:   tx,
 	})
 	return nil
 }
 func (t *transactionDiffer) Modify(key string, from, to *cbg.Deferred) error {
 	txID, err := abi.ParseIntKey(key)
 	if err != nil {
 		return err
 	}
 	txFrom, err := t.pre.decodeTransaction(from)
 	if err != nil {
 		return err
 	}
 	txTo, err := t.after.decodeTransaction(to)
 	if err != nil {
 		return err
 	}
 	if approvalsChanged(txFrom.Approved, txTo.Approved) {
 		t.Results.Modified = append(t.Results.Modified, TransactionModification{
 			TxID: txID,
 			From: txFrom,
 			To:   txTo,
 		})
 	}
 	return nil
 }
 func approvalsChanged(from, to []address.Address) bool {
 	if len(from) != len(to) {
 		return true
 	}
 	for idx := range from {
 		if from[idx] != to[idx] {
 			return true
 		}
 	}
 	return false
 }
 func (t *transactionDiffer) Remove(key string, val *cbg.Deferred) error {
 	txID, err := abi.ParseIntKey(key)
 	if err != nil {
 		return err
 	}
 	tx, err := t.pre.decodeTransaction(val)
 	if err != nil {
 		return err
 	}
 	t.Results.Removed = append(t.Results.Removed, TransactionChange{
 		TxID: txID,
 		Tx:   tx,
 	})
 	return nil
 }
--- a/chain/actors/builtin/multisig/message.go
+++ b/chain/actors/builtin/multisig/message.go
@ -0,0 +1,74 @@
 package multisig
 import (
 	"fmt"
 	"github.com/minio/blake2b-simd"
 	"golang.org/x/xerrors"
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
 	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
 	multisig2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/multisig"
 	"github.com/filecoin-project/lotus/chain/actors"
 	"github.com/filecoin-project/lotus/chain/types"
 )
 var Methods = builtin2.MethodsMultisig
 func Message(version actors.Version, from address.Address) MessageBuilder {
 	switch version {
 	case actors.Version0:
 		return message0{from}
 	case actors.Version2:
 		return message2{message0{from}}
 	default:
 		panic(fmt.Sprintf("unsupported actors version: %d", version))
 	}
 }
 type MessageBuilder interface {
 	// Create a new multisig with the specified parameters.
 	Create(signers []address.Address, threshold uint64,
 		vestingStart, vestingDuration abi.ChainEpoch,
 		initialAmount abi.TokenAmount) (*types.Message, error)
 	// Propose a transaction to the given multisig.
 	Propose(msig, target address.Address, amt abi.TokenAmount,
 		method abi.MethodNum, params []byte) (*types.Message, error)
 	// Approve a multisig transaction. The "hash" is optional.
 	Approve(msig address.Address, txID uint64, hash *ProposalHashData) (*types.Message, error)
 	// Cancel a multisig transaction. The "hash" is optional.
 	Cancel(msig address.Address, txID uint64, hash *ProposalHashData) (*types.Message, error)
 }
 // this type is the same between v0 and v2
 type ProposalHashData = multisig2.ProposalHashData
 type ProposeReturn = multisig2.ProposeReturn
 func txnParams(id uint64, data *ProposalHashData) ([]byte, error) {
 	params := multisig2.TxnIDParams{ID: multisig2.TxnID(id)}
 	if data != nil {
 		if data.Requester.Protocol() != address.ID {
 			return nil, xerrors.Errorf("proposer address must be an ID address, was %s", data.Requester)
 		}
 		if data.Value.Sign() == -1 {
 			return nil, xerrors.Errorf("proposal value must be non-negative, was %s", data.Value)
 		}
 		if data.To == address.Undef {
 			return nil, xerrors.Errorf("proposed destination address must be set")
 		}
 		pser, err := data.Serialize()
 		if err != nil {
 			return nil, err
 		}
 		hash := blake2b.Sum256(pser)
 		params.ProposalHash = hash[:]
 	}
 	return actors.SerializeParams(&params)
 }
--- a/chain/actors/builtin/multisig/message0.go
+++ b/chain/actors/builtin/multisig/message0.go
@ -0,0 +1,142 @@
 package multisig
 import (
 	"golang.org/x/xerrors"
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
 	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
 	init0 "github.com/filecoin-project/specs-actors/actors/builtin/init"
 	multisig0 "github.com/filecoin-project/specs-actors/actors/builtin/multisig"
 	"github.com/filecoin-project/lotus/chain/actors"
 	init_ "github.com/filecoin-project/lotus/chain/actors/builtin/init"
 	"github.com/filecoin-project/lotus/chain/types"
 )
 type message0 struct{ from address.Address }
 func (m message0) Create(
 	signers []address.Address, threshold uint64,
 	unlockStart, unlockDuration abi.ChainEpoch,
 	initialAmount abi.TokenAmount,
 ) (*types.Message, error) {
 	lenAddrs := uint64(len(signers))
 	if lenAddrs < threshold {
 		return nil, xerrors.Errorf("cannot require signing of more addresses than provided for multisig")
 	}
 	if threshold == 0 {
 		threshold = lenAddrs
 	}
 	if m.from == address.Undef {
 		return nil, xerrors.Errorf("must provide source address")
 	}
 	if unlockStart != 0 {
 		return nil, xerrors.Errorf("actors v0 does not support a non-zero vesting start time")
 	}
 	// Set up constructor parameters for multisig
 	msigParams := &multisig0.ConstructorParams{
 		Signers:               signers,
 		NumApprovalsThreshold: threshold,
 		UnlockDuration:        unlockDuration,
 	}
 	enc, actErr := actors.SerializeParams(msigParams)
 	if actErr != nil {
 		return nil, actErr
 	}
 	// new actors are created by invoking 'exec' on the init actor with the constructor params
 	execParams := &init0.ExecParams{
 		CodeCID:           builtin0.MultisigActorCodeID,
 		ConstructorParams: enc,
 	}
 	enc, actErr = actors.SerializeParams(execParams)
 	if actErr != nil {
 		return nil, actErr
 	}
 	return &types.Message{
 		To:     init_.Address,
 		From:   m.from,
 		Method: builtin0.MethodsInit.Exec,
 		Params: enc,
 		Value:  initialAmount,
 	}, nil
 }
 func (m message0) Propose(msig, to address.Address, amt abi.TokenAmount,
 	method abi.MethodNum, params []byte) (*types.Message, error) {
 	if msig == address.Undef {
 		return nil, xerrors.Errorf("must provide a multisig address for proposal")
 	}
 	if to == address.Undef {
 		return nil, xerrors.Errorf("must provide a target address for proposal")
 	}
 	if amt.Sign() == -1 {
 		return nil, xerrors.Errorf("must provide a non-negative amount for proposed send")
 	}
 	if m.from == address.Undef {
 		return nil, xerrors.Errorf("must provide source address")
 	}
 	enc, actErr := actors.SerializeParams(&multisig0.ProposeParams{
 		To:     to,
 		Value:  amt,
 		Method: method,
 		Params: params,
 	})
 	if actErr != nil {
 		return nil, xerrors.Errorf("failed to serialize parameters: %w", actErr)
 	}
 	return &types.Message{
 		To:     msig,
 		From:   m.from,
 		Value:  abi.NewTokenAmount(0),
 		Method: builtin0.MethodsMultisig.Propose,
 		Params: enc,
 	}, nil
 }
 func (m message0) Approve(msig address.Address, txID uint64, hashData *ProposalHashData) (*types.Message, error) {
 	enc, err := txnParams(txID, hashData)
 	if err != nil {
 		return nil, err
 	}
 	return &types.Message{
 		To:     msig,
 		From:   m.from,
 		Value:  types.NewInt(0),
 		Method: builtin0.MethodsMultisig.Approve,
 		Params: enc,
 	}, nil
 }
 func (m message0) Cancel(msig address.Address, txID uint64, hashData *ProposalHashData) (*types.Message, error) {
 	enc, err := txnParams(txID, hashData)
 	if err != nil {
 		return nil, err
 	}
 	return &types.Message{
 		To:     msig,
 		From:   m.from,
 		Value:  types.NewInt(0),
 		Method: builtin0.MethodsMultisig.Cancel,
 		Params: enc,
 	}, nil
 }
--- a/chain/actors/builtin/multisig/message2.go
+++ b/chain/actors/builtin/multisig/message2.go
@ -0,0 +1,71 @@
 package multisig
 import (
 	"golang.org/x/xerrors"
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
 	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
 	init2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/init"
 	multisig2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/multisig"
 	"github.com/filecoin-project/lotus/chain/actors"
 	init_ "github.com/filecoin-project/lotus/chain/actors/builtin/init"
 	"github.com/filecoin-project/lotus/chain/types"
 )
 type message2 struct{ message0 }
 func (m message2) Create(
 	signers []address.Address, threshold uint64,
 	unlockStart, unlockDuration abi.ChainEpoch,
 	initialAmount abi.TokenAmount,
 ) (*types.Message, error) {
 	lenAddrs := uint64(len(signers))
 	if lenAddrs < threshold {
 		return nil, xerrors.Errorf("cannot require signing of more addresses than provided for multisig")
 	}
 	if threshold == 0 {
 		threshold = lenAddrs
 	}
 	if m.from == address.Undef {
 		return nil, xerrors.Errorf("must provide source address")
 	}
 	// Set up constructor parameters for multisig
 	msigParams := &multisig2.ConstructorParams{
 		Signers:               signers,
 		NumApprovalsThreshold: threshold,
 		UnlockDuration:        unlockDuration,
 		StartEpoch:            unlockStart,
 	}
 	enc, actErr := actors.SerializeParams(msigParams)
 	if actErr != nil {
 		return nil, actErr
 	}
 	// new actors are created by invoking 'exec' on the init actor with the constructor params
 	execParams := &init2.ExecParams{
 		CodeCID:           builtin2.MultisigActorCodeID,
 		ConstructorParams: enc,
 	}
 	enc, actErr = actors.SerializeParams(execParams)
 	if actErr != nil {
 		return nil, actErr
 	}
 	return &types.Message{
 		To:     init_.Address,
 		From:   m.from,
 		Method: builtin2.MethodsInit.Exec,
 		Params: enc,
 		Value:  initialAmount,
 	}, nil
 }
--- a/chain/actors/builtin/multisig/multisig.go
+++ b/chain/actors/builtin/multisig/multisig.go
@ -1,28 +1,38 @@
 package multisig
 import (
 	cbg "github.com/whyrusleeping/cbor-gen"
 	"golang.org/x/xerrors"
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/cbor"
 	"github.com/ipfs/go-cid"
 	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
 	msig0 "github.com/filecoin-project/specs-actors/actors/builtin/multisig"
 	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
 	"github.com/filecoin-project/lotus/chain/actors/adt"
 	"github.com/filecoin-project/lotus/chain/actors/builtin"
 	"github.com/filecoin-project/lotus/chain/types"
 )
 func init() {
 	builtin.RegisterActorState(builtin0.MultisigActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
 		return load0(store, root)
 	})
 	builtin.RegisterActorState(builtin2.MultisigActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
 		return load2(store, root)
 	})
 }
 func Load(store adt.Store, act *types.Actor) (State, error) {
 	switch act.Code {
 	case builtin0.MultisigActorCodeID:
-		out := state0{store: store}
+		return load0(store, act.Head)
-		err := store.Get(store.Context(), act.Head, &out)
+	case builtin2.MultisigActorCodeID:
-		if err != nil {
+		return load2(store, act.Head)
 			return nil, err
 		}
 		return &out, nil
 	}
 	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
 }
@ -38,6 +48,10 @@ type State interface {
 	Signers() ([]address.Address, error)
 	ForEachPendingTxn(func(id int64, txn Transaction) error) error
 	PendingTxnChanged(State) (bool, error)
 	transactions() (adt.Map, error)
 	decodeTransaction(val *cbg.Deferred) (Transaction, error)
 }
 type Transaction = msig0.Transaction
--- a/chain/actors/builtin/multisig/state0.go
+++ b/chain/actors/builtin/multisig/state0.go
@ -1,19 +1,33 @@
 package multisig
 import (
 	"bytes"
 	"encoding/binary"
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/lotus/chain/actors/adt"
+	"github.com/ipfs/go-cid"
 	cbg "github.com/whyrusleeping/cbor-gen"
 	"golang.org/x/xerrors"
 	"github.com/filecoin-project/lotus/chain/actors/adt"
 	msig0 "github.com/filecoin-project/specs-actors/actors/builtin/multisig"
 	adt0 "github.com/filecoin-project/specs-actors/actors/util/adt"
 	multisig0 "github.com/filecoin-project/specs-actors/v2/actors/builtin/multisig"
 )
 var _ State = (*state0)(nil)
 func load0(store adt.Store, root cid.Cid) (State, error) {
 	out := state0{store: store}
 	err := store.Get(store.Context(), root, &out)
 	if err != nil {
 		return nil, err
 	}
 	return &out, nil
 }
 type state0 struct {
 	msig0.State
 	store adt.Store
@ -57,3 +71,24 @@ func (s *state0) ForEachPendingTxn(cb func(id int64, txn Transaction) error) err
 		return cb(txid, (Transaction)(out))
 	})
 }
 func (s *state0) PendingTxnChanged(other State) (bool, error) {
 	other0, ok := other.(*state0)
 	if !ok {
 		// treat an upgrade as a change, always
 		return true, nil
 	}
 	return !s.State.PendingTxns.Equals(other0.PendingTxns), nil
 }
 func (s *state0) transactions() (adt.Map, error) {
 	return adt0.AsMap(s.store, s.PendingTxns)
 }
 func (s *state0) decodeTransaction(val *cbg.Deferred) (Transaction, error) {
 	var tx multisig0.Transaction
 	if err := tx.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil {
 		return Transaction{}, err
 	}
 	return tx, nil
 }
--- a/chain/actors/builtin/multisig/state2.go
+++ b/chain/actors/builtin/multisig/state2.go
@ -0,0 +1,93 @@
 package multisig
 import (
 	"bytes"
 	"encoding/binary"
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/ipfs/go-cid"
 	cbg "github.com/whyrusleeping/cbor-gen"
 	"golang.org/x/xerrors"
 	"github.com/filecoin-project/lotus/chain/actors/adt"
 	msig2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/multisig"
 	adt2 "github.com/filecoin-project/specs-actors/v2/actors/util/adt"
 )
 var _ State = (*state2)(nil)
 func load2(store adt.Store, root cid.Cid) (State, error) {
 	out := state2{store: store}
 	err := store.Get(store.Context(), root, &out)
 	if err != nil {
 		return nil, err
 	}
 	return &out, nil
 }
 type state2 struct {
 	msig2.State
 	store adt.Store
 }
 func (s *state2) LockedBalance(currEpoch abi.ChainEpoch) (abi.TokenAmount, error) {
 	return s.State.AmountLocked(currEpoch - s.State.StartEpoch), nil
 }
 func (s *state2) StartEpoch() (abi.ChainEpoch, error) {
 	return s.State.StartEpoch, nil
 }
 func (s *state2) UnlockDuration() (abi.ChainEpoch, error) {
 	return s.State.UnlockDuration, nil
 }
 func (s *state2) InitialBalance() (abi.TokenAmount, error) {
 	return s.State.InitialBalance, nil
 }
 func (s *state2) Threshold() (uint64, error) {
 	return s.State.NumApprovalsThreshold, nil
 }
 func (s *state2) Signers() ([]address.Address, error) {
 	return s.State.Signers, nil
 }
 func (s *state2) ForEachPendingTxn(cb func(id int64, txn Transaction) error) error {
 	arr, err := adt2.AsMap(s.store, s.State.PendingTxns)
 	if err != nil {
 		return err
 	}
 	var out msig2.Transaction
 	return arr.ForEach(&out, func(key string) error {
 		txid, n := binary.Varint([]byte(key))
 		if n <= 0 {
 			return xerrors.Errorf("invalid pending transaction key: %v", key)
 		}
 		return cb(txid, (Transaction)(out))
 	})
 }
 func (s *state2) PendingTxnChanged(other State) (bool, error) {
 	other2, ok := other.(*state2)
 	if !ok {
 		// treat an upgrade as a change, always
 		return true, nil
 	}
 	return !s.State.PendingTxns.Equals(other2.PendingTxns), nil
 }
 func (s *state2) transactions() (adt.Map, error) {
 	return adt2.AsMap(s.store, s.PendingTxns)
 }
 func (s *state2) decodeTransaction(val *cbg.Deferred) (Transaction, error) {
 	var tx msig2.Transaction
 	if err := tx.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil {
 		return Transaction{}, err
 	}
 	return tx, nil
 }
--- a/chain/actors/builtin/paych/message.go
+++ b/chain/actors/builtin/paych/message.go
@ -0,0 +1,32 @@
 package paych
 import (
 	"fmt"
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/lotus/chain/actors"
 	"github.com/filecoin-project/lotus/chain/types"
 	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
 )
 var Methods = builtin2.MethodsPaych
 func Message(version actors.Version, from address.Address) MessageBuilder {
 	switch version {
 	case actors.Version0:
 		return message0{from}
 	case actors.Version2:
 		return message2{from}
 	default:
 		panic(fmt.Sprintf("unsupported actors version: %d", version))
 	}
 }
 type MessageBuilder interface {
 	Create(to address.Address, initialAmount abi.TokenAmount) (*types.Message, error)
 	Update(paych address.Address, voucher *SignedVoucher, secret []byte) (*types.Message, error)
 	Settle(paych address.Address) (*types.Message, error)
 	Collect(paych address.Address) (*types.Message, error)
 }
--- a/chain/actors/builtin/paych/message0.go
+++ b/chain/actors/builtin/paych/message0.go
@ -0,0 +1,74 @@
 package paych
 import (
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
 	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
 	init0 "github.com/filecoin-project/specs-actors/actors/builtin/init"
 	paych0 "github.com/filecoin-project/specs-actors/actors/builtin/paych"
 	"github.com/filecoin-project/lotus/chain/actors"
 	init_ "github.com/filecoin-project/lotus/chain/actors/builtin/init"
 	"github.com/filecoin-project/lotus/chain/types"
 )
 type message0 struct{ from address.Address }
 func (m message0) Create(to address.Address, initialAmount abi.TokenAmount) (*types.Message, error) {
 	params, aerr := actors.SerializeParams(&paych0.ConstructorParams{From: m.from, To: to})
 	if aerr != nil {
 		return nil, aerr
 	}
 	enc, aerr := actors.SerializeParams(&init0.ExecParams{
 		CodeCID:           builtin0.PaymentChannelActorCodeID,
 		ConstructorParams: params,
 	})
 	if aerr != nil {
 		return nil, aerr
 	}
 	return &types.Message{
 		To:     init_.Address,
 		From:   m.from,
 		Value:  initialAmount,
 		Method: builtin0.MethodsInit.Exec,
 		Params: enc,
 	}, nil
 }
 func (m message0) Update(paych address.Address, sv *SignedVoucher, secret []byte) (*types.Message, error) {
 	params, aerr := actors.SerializeParams(&paych0.UpdateChannelStateParams{
 		Sv:     *sv,
 		Secret: secret,
 	})
 	if aerr != nil {
 		return nil, aerr
 	}
 	return &types.Message{
 		To:     paych,
 		From:   m.from,
 		Value:  abi.NewTokenAmount(0),
 		Method: builtin0.MethodsPaych.UpdateChannelState,
 		Params: params,
 	}, nil
 }
 func (m message0) Settle(paych address.Address) (*types.Message, error) {
 	return &types.Message{
 		To:     paych,
 		From:   m.from,
 		Value:  abi.NewTokenAmount(0),
 		Method: builtin0.MethodsPaych.Settle,
 	}, nil
 }
 func (m message0) Collect(paych address.Address) (*types.Message, error) {
 	return &types.Message{
 		To:     paych,
 		From:   m.from,
 		Value:  abi.NewTokenAmount(0),
 		Method: builtin0.MethodsPaych.Collect,
 	}, nil
 }
--- a/chain/actors/builtin/paych/message2.go
+++ b/chain/actors/builtin/paych/message2.go
@ -0,0 +1,74 @@
 package paych
 import (
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
 	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
 	init2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/init"
 	paych2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/paych"
 	"github.com/filecoin-project/lotus/chain/actors"
 	init_ "github.com/filecoin-project/lotus/chain/actors/builtin/init"
 	"github.com/filecoin-project/lotus/chain/types"
 )
 type message2 struct{ from address.Address }
 func (m message2) Create(to address.Address, initialAmount abi.TokenAmount) (*types.Message, error) {
 	params, aerr := actors.SerializeParams(&paych2.ConstructorParams{From: m.from, To: to})
 	if aerr != nil {
 		return nil, aerr
 	}
 	enc, aerr := actors.SerializeParams(&init2.ExecParams{
 		CodeCID:           builtin2.PaymentChannelActorCodeID,
 		ConstructorParams: params,
 	})
 	if aerr != nil {
 		return nil, aerr
 	}
 	return &types.Message{
 		To:     init_.Address,
 		From:   m.from,
 		Value:  initialAmount,
 		Method: builtin2.MethodsInit.Exec,
 		Params: enc,
 	}, nil
 }
 func (m message2) Update(paych address.Address, sv *SignedVoucher, secret []byte) (*types.Message, error) {
 	params, aerr := actors.SerializeParams(&paych2.UpdateChannelStateParams{
 		Sv:     *sv,
 		Secret: secret,
 	})
 	if aerr != nil {
 		return nil, aerr
 	}
 	return &types.Message{
 		To:     paych,
 		From:   m.from,
 		Value:  abi.NewTokenAmount(0),
 		Method: builtin2.MethodsPaych.UpdateChannelState,
 		Params: params,
 	}, nil
 }
 func (m message2) Settle(paych address.Address) (*types.Message, error) {
 	return &types.Message{
 		To:     paych,
 		From:   m.from,
 		Value:  abi.NewTokenAmount(0),
 		Method: builtin2.MethodsPaych.Settle,
 	}, nil
 }
 func (m message2) Collect(paych address.Address) (*types.Message, error) {
 	return &types.Message{
 		To:     paych,
 		From:   m.from,
 		Value:  abi.NewTokenAmount(0),
 		Method: builtin2.MethodsPaych.Collect,
 	}, nil
 }
--- a/chain/actors/builtin/paych/mock/mock.go
+++ b/chain/actors/builtin/paych/mock/mock.go
@ -27,10 +27,9 @@ type mockLaneState struct {
 func NewMockPayChState(from address.Address,
 	to address.Address,
 	settlingAt abi.ChainEpoch,
 	toSend abi.TokenAmount,
 	lanes map[uint64]paych.LaneState,
 ) paych.State {
-	return &mockState{from, to, settlingAt, toSend, lanes}
+	return &mockState{from: from, to: to, settlingAt: settlingAt, toSend: big.NewInt(0), lanes: lanes}
 }
 // NewMockLaneState constructs a state for a payment channel lane with the set fixed values
--- a/chain/actors/builtin/paych/state.go
+++ b/chain/actors/builtin/paych/state.go
@ -1,29 +1,42 @@
 package paych
 import (
 	"encoding/base64"
 	"golang.org/x/xerrors"
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
 	big "github.com/filecoin-project/go-state-types/big"
 	"github.com/filecoin-project/go-state-types/cbor"
 	"github.com/ipfs/go-cid"
 	ipldcbor "github.com/ipfs/go-ipld-cbor"
 	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
 	paych0 "github.com/filecoin-project/specs-actors/actors/builtin/paych"
 	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
 	"github.com/filecoin-project/lotus/chain/actors/adt"
 	"github.com/filecoin-project/lotus/chain/actors/builtin"
 	"github.com/filecoin-project/lotus/chain/types"
 )
 func init() {
 	builtin.RegisterActorState(builtin0.PaymentChannelActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
 		return load0(store, root)
 	})
 	builtin.RegisterActorState(builtin2.PaymentChannelActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
 		return load2(store, root)
 	})
 }
 // Load returns an abstract copy of payment channel state, irregardless of actor version
 func Load(store adt.Store, act *types.Actor) (State, error) {
 	switch act.Code {
 	case builtin0.PaymentChannelActorCodeID:
-		out := state0{store: store}
+		return load0(store, act.Head)
-		err := store.Get(store.Context(), act.Head, &out)
+	case builtin2.PaymentChannelActorCodeID:
-		if err != nil {
+		return load2(store, act.Head)
 			return nil, err
 		}
 		return &out, nil
 	}
 	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
 }
@ -58,3 +71,18 @@ type LaneState interface {
 type SignedVoucher = paych0.SignedVoucher
 type ModVerifyParams = paych0.ModVerifyParams
 // DecodeSignedVoucher decodes base64 encoded signed voucher.
 func DecodeSignedVoucher(s string) (*SignedVoucher, error) {
 	data, err := base64.RawURLEncoding.DecodeString(s)
 	if err != nil {
 		return nil, err
 	}
 	var sv SignedVoucher
 	if err := ipldcbor.DecodeInto(data, &sv); err != nil {
 		return nil, err
 	}
 	return &sv, nil
 }
--- a/chain/actors/builtin/paych/state0.go
+++ b/chain/actors/builtin/paych/state0.go
@ -1,18 +1,31 @@
 package paych
 import (
 	"github.com/ipfs/go-cid"
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
-	big "github.com/filecoin-project/go-state-types/big"
+	"github.com/filecoin-project/go-state-types/big"
 	"github.com/filecoin-project/lotus/chain/actors/adt"
-	"github.com/filecoin-project/specs-actors/actors/builtin/paych"
+
 	paych0 "github.com/filecoin-project/specs-actors/actors/builtin/paych"
 	adt0 "github.com/filecoin-project/specs-actors/actors/util/adt"
 )
 var _ State = (*state0)(nil)
 func load0(store adt.Store, root cid.Cid) (State, error) {
 	out := state0{store: store}
 	err := store.Get(store.Context(), root, &out)
 	if err != nil {
 		return nil, err
 	}
 	return &out, nil
 }
 type state0 struct {
-	paych.State
+	paych0.State
 	store adt.Store
 	lsAmt *adt0.Array
 }
@ -72,14 +85,14 @@ func (s *state0) ForEachLaneState(cb func(idx uint64, dl LaneState) error) error
 	// Note: we use a map instead of an array to store laneStates because the
 	// client sets the lane ID (the index) and potentially they could use a
 	// very large index.
-	var ls paych.LaneState
+	var ls paych0.LaneState
 	return lsamt.ForEach(&ls, func(i int64) error {
 		return cb(uint64(i), &laneState0{ls})
 	})
 }
 type laneState0 struct {
-	paych.LaneState
+	paych0.LaneState
 }
 func (ls *laneState0) Redeemed() (big.Int, error) {
--- a/chain/actors/builtin/paych/state2.go
+++ b/chain/actors/builtin/paych/state2.go
@ -0,0 +1,104 @@
 package paych
 import (
 	"github.com/ipfs/go-cid"
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/big"
 	"github.com/filecoin-project/lotus/chain/actors/adt"
 	paych2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/paych"
 	adt2 "github.com/filecoin-project/specs-actors/v2/actors/util/adt"
 )
 var _ State = (*state2)(nil)
 func load2(store adt.Store, root cid.Cid) (State, error) {
 	out := state2{store: store}
 	err := store.Get(store.Context(), root, &out)
 	if err != nil {
 		return nil, err
 	}
 	return &out, nil
 }
 type state2 struct {
 	paych2.State
 	store adt.Store
 	lsAmt *adt2.Array
 }
 // Channel owner, who has funded the actor
 func (s *state2) From() (address.Address, error) {
 	return s.State.From, nil
 }
 // Recipient of payouts from channel
 func (s *state2) To() (address.Address, error) {
 	return s.State.To, nil
 }
 // Height at which the channel can be `Collected`
 func (s *state2) SettlingAt() (abi.ChainEpoch, error) {
 	return s.State.SettlingAt, nil
 }
 // Amount successfully redeemed through the payment channel, paid out on `Collect()`
 func (s *state2) ToSend() (abi.TokenAmount, error) {
 	return s.State.ToSend, nil
 }
 func (s *state2) getOrLoadLsAmt() (*adt2.Array, error) {
 	if s.lsAmt != nil {
 		return s.lsAmt, nil
 	}
 	// Get the lane state from the chain
 	lsamt, err := adt2.AsArray(s.store, s.State.LaneStates)
 	if err != nil {
 		return nil, err
 	}
 	s.lsAmt = lsamt
 	return lsamt, nil
 }
 // Get total number of lanes
 func (s *state2) LaneCount() (uint64, error) {
 	lsamt, err := s.getOrLoadLsAmt()
 	if err != nil {
 		return 0, err
 	}
 	return lsamt.Length(), nil
 }
 // Iterate lane states
 func (s *state2) ForEachLaneState(cb func(idx uint64, dl LaneState) error) error {
 	// Get the lane state from the chain
 	lsamt, err := s.getOrLoadLsAmt()
 	if err != nil {
 		return err
 	}
 	// Note: we use a map instead of an array to store laneStates because the
 	// client sets the lane ID (the index) and potentially they could use a
 	// very large index.
 	var ls paych2.LaneState
 	return lsamt.ForEach(&ls, func(i int64) error {
 		return cb(uint64(i), &laneState2{ls})
 	})
 }
 type laneState2 struct {
 	paych2.LaneState
 }
 func (ls *laneState2) Redeemed() (big.Int, error) {
 	return ls.LaneState.Redeemed, nil
 }
 func (ls *laneState2) Nonce() (uint64, error) {
 	return ls.LaneState.Nonce, nil
 }
--- a/chain/actors/builtin/power/diff.go
+++ b/chain/actors/builtin/power/diff.go
@ -0,0 +1,117 @@
 package power
 import (
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
 	cbg "github.com/whyrusleeping/cbor-gen"
 	"github.com/filecoin-project/lotus/chain/actors/adt"
 )
 type ClaimChanges struct {
 	Added    []ClaimInfo
 	Modified []ClaimModification
 	Removed  []ClaimInfo
 }
 type ClaimModification struct {
 	Miner address.Address
 	From  Claim
 	To    Claim
 }
 type ClaimInfo struct {
 	Miner address.Address
 	Claim Claim
 }
 func DiffClaims(pre, cur State) (*ClaimChanges, error) {
 	results := new(ClaimChanges)
 	prec, err := pre.claims()
 	if err != nil {
 		return nil, err
 	}
 	curc, err := cur.claims()
 	if err != nil {
 		return nil, err
 	}
 	if err := adt.DiffAdtMap(prec, curc, &claimDiffer{results, pre, cur}); err != nil {
 		return nil, err
 	}
 	return results, nil
 }
 type claimDiffer struct {
 	Results    *ClaimChanges
 	pre, after State
 }
 func (c *claimDiffer) AsKey(key string) (abi.Keyer, error) {
 	addr, err := address.NewFromBytes([]byte(key))
 	if err != nil {
 		return nil, err
 	}
 	return abi.AddrKey(addr), nil
 }
 func (c *claimDiffer) Add(key string, val *cbg.Deferred) error {
 	ci, err := c.after.decodeClaim(val)
 	if err != nil {
 		return err
 	}
 	addr, err := address.NewFromBytes([]byte(key))
 	if err != nil {
 		return err
 	}
 	c.Results.Added = append(c.Results.Added, ClaimInfo{
 		Miner: addr,
 		Claim: ci,
 	})
 	return nil
 }
 func (c *claimDiffer) Modify(key string, from, to *cbg.Deferred) error {
 	ciFrom, err := c.pre.decodeClaim(from)
 	if err != nil {
 		return err
 	}
 	ciTo, err := c.after.decodeClaim(to)
 	if err != nil {
 		return err
 	}
 	addr, err := address.NewFromBytes([]byte(key))
 	if err != nil {
 		return err
 	}
 	if ciFrom != ciTo {
 		c.Results.Modified = append(c.Results.Modified, ClaimModification{
 			Miner: addr,
 			From:  ciFrom,
 			To:    ciTo,
 		})
 	}
 	return nil
 }
 func (c *claimDiffer) Remove(key string, val *cbg.Deferred) error {
 	ci, err := c.after.decodeClaim(val)
 	if err != nil {
 		return err
 	}
 	addr, err := address.NewFromBytes([]byte(key))
 	if err != nil {
 		return err
 	}
 	c.Results.Removed = append(c.Results.Removed, ClaimInfo{
 		Miner: addr,
 		Claim: ci,
 	})
 	return nil
 }
--- a/chain/actors/builtin/power/power.go
+++ b/chain/actors/builtin/power/power.go
@ -2,28 +2,42 @@ package power
 import (
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/big"
 	"github.com/ipfs/go-cid"
 	cbg "github.com/whyrusleeping/cbor-gen"
 	"golang.org/x/xerrors"
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/cbor"
 	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
 	"github.com/filecoin-project/lotus/chain/actors/adt"
 	"github.com/filecoin-project/lotus/chain/actors/builtin"
 	"github.com/filecoin-project/lotus/chain/types"
 	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
 	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
 )
-var Address = builtin0.StoragePowerActorAddr
+func init() {
 	builtin.RegisterActorState(builtin0.StoragePowerActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
 		return load0(store, root)
 	})
 	builtin.RegisterActorState(builtin2.StoragePowerActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
 		return load2(store, root)
 	})
 }
 var (
 	Address = builtin2.StoragePowerActorAddr
 	Methods = builtin2.MethodsPower
 )
 func Load(store adt.Store, act *types.Actor) (st State, err error) {
 	switch act.Code {
 	case builtin0.StoragePowerActorCodeID:
-		out := state0{store: store}
+		return load0(store, act.Head)
-		err := store.Get(store.Context(), act.Head, &out)
+	case builtin2.StoragePowerActorCodeID:
-		if err != nil {
+		return load2(store, act.Head)
 			return nil, err
 		}
 		return &out, nil
 	}
 	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
 }
@ -42,6 +56,12 @@ type State interface {
 	MinerPower(address.Address) (Claim, bool, error)
 	MinerNominalPowerMeetsConsensusMinimum(address.Address) (bool, error)
 	ListAllMiners() ([]address.Address, error)
 	ForEachClaim(func(miner address.Address, claim Claim) error) error
 	ClaimsChanged(State) (bool, error)
 	// Diff helpers. Used by Diff* functions internally.
 	claims() (adt.Map, error)
 	decodeClaim(*cbg.Deferred) (Claim, error)
 }
 type Claim struct {
@ -51,3 +71,10 @@ type Claim struct {
 	// Sum of quality adjusted power for a miner's sectors.
 	QualityAdjPower abi.StoragePower
 }
 func AddClaims(a Claim, b Claim) Claim {
 	return Claim{
 		RawBytePower:    big.Add(a.RawBytePower, b.RawBytePower),
 		QualityAdjPower: big.Add(a.QualityAdjPower, b.QualityAdjPower),
 	}
 }
--- a/chain/actors/builtin/power/v0.go
+++ b/chain/actors/builtin/power/v0.go
@ -1,15 +1,31 @@
 package power
 import (
 	"bytes"
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/ipfs/go-cid"
 	cbg "github.com/whyrusleeping/cbor-gen"
 	"github.com/filecoin-project/lotus/chain/actors/adt"
 	"github.com/filecoin-project/lotus/chain/actors/builtin"
 	power0 "github.com/filecoin-project/specs-actors/actors/builtin/power"
-	"github.com/filecoin-project/specs-actors/actors/util/adt"
+	adt0 "github.com/filecoin-project/specs-actors/actors/util/adt"
 )
 var _ State = (*state0)(nil)
 func load0(store adt.Store, root cid.Cid) (State, error) {
 	out := state0{store: store}
 	err := store.Get(store.Context(), root, &out)
 	if err != nil {
 		return nil, err
 	}
 	return &out, nil
 }
 type state0 struct {
 	power0.State
 	store adt.Store
@ -35,7 +51,7 @@ func (s *state0) TotalCommitted() (Claim, error) {
 }
 func (s *state0) MinerPower(addr address.Address) (Claim, bool, error) {
-	claims, err := adt.AsMap(s.store, s.Claims)
+	claims, err := adt0.AsMap(s.store, s.Claims)
 	if err != nil {
 		return Claim{}, false, err
 	}
@ -63,7 +79,7 @@ func (s *state0) MinerCounts() (uint64, uint64, error) {
 }
 func (s *state0) ListAllMiners() ([]address.Address, error) {
-	claims, err := adt.AsMap(s.store, s.Claims)
+	claims, err := adt0.AsMap(s.store, s.Claims)
 	if err != nil {
 		return nil, err
 	}
@ -83,3 +99,47 @@ func (s *state0) ListAllMiners() ([]address.Address, error) {
 	return miners, nil
 }
 func (s *state0) ForEachClaim(cb func(miner address.Address, claim Claim) error) error {
 	claims, err := adt0.AsMap(s.store, s.Claims)
 	if err != nil {
 		return err
 	}
 	var claim power0.Claim
 	return claims.ForEach(&claim, func(k string) error {
 		a, err := address.NewFromBytes([]byte(k))
 		if err != nil {
 			return err
 		}
 		return cb(a, Claim{
 			RawBytePower:    claim.RawBytePower,
 			QualityAdjPower: claim.QualityAdjPower,
 		})
 	})
 }
 func (s *state0) ClaimsChanged(other State) (bool, error) {
 	other0, ok := other.(*state0)
 	if !ok {
 		// treat an upgrade as a change, always
 		return true, nil
 	}
 	return !s.State.Claims.Equals(other0.State.Claims), nil
 }
 func (s *state0) claims() (adt.Map, error) {
 	return adt0.AsMap(s.store, s.Claims)
 }
 func (s *state0) decodeClaim(val *cbg.Deferred) (Claim, error) {
 	var ci power0.Claim
 	if err := ci.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil {
 		return Claim{}, err
 	}
 	return fromV0Claim(ci), nil
 }
 func fromV0Claim(v0 power0.Claim) Claim {
 	return (Claim)(v0)
 }
--- a/chain/actors/builtin/power/v2.go
+++ b/chain/actors/builtin/power/v2.go
@ -0,0 +1,148 @@
 package power
 import (
 	"bytes"
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/ipfs/go-cid"
 	cbg "github.com/whyrusleeping/cbor-gen"
 	"github.com/filecoin-project/lotus/chain/actors/adt"
 	"github.com/filecoin-project/lotus/chain/actors/builtin"
 	power2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/power"
 	adt2 "github.com/filecoin-project/specs-actors/v2/actors/util/adt"
 )
 var _ State = (*state2)(nil)
 func load2(store adt.Store, root cid.Cid) (State, error) {
 	out := state2{store: store}
 	err := store.Get(store.Context(), root, &out)
 	if err != nil {
 		return nil, err
 	}
 	return &out, nil
 }
 type state2 struct {
 	power2.State
 	store adt.Store
 }
 func (s *state2) TotalLocked() (abi.TokenAmount, error) {
 	return s.TotalPledgeCollateral, nil
 }
 func (s *state2) TotalPower() (Claim, error) {
 	return Claim{
 		RawBytePower:    s.TotalRawBytePower,
 		QualityAdjPower: s.TotalQualityAdjPower,
 	}, nil
 }
 // Committed power to the network. Includes miners below the minimum threshold.
 func (s *state2) TotalCommitted() (Claim, error) {
 	return Claim{
 		RawBytePower:    s.TotalBytesCommitted,
 		QualityAdjPower: s.TotalQABytesCommitted,
 	}, nil
 }
 func (s *state2) MinerPower(addr address.Address) (Claim, bool, error) {
 	claims, err := adt2.AsMap(s.store, s.Claims)
 	if err != nil {
 		return Claim{}, false, err
 	}
 	var claim power2.Claim
 	ok, err := claims.Get(abi.AddrKey(addr), &claim)
 	if err != nil {
 		return Claim{}, false, err
 	}
 	return Claim{
 		RawBytePower:    claim.RawBytePower,
 		QualityAdjPower: claim.QualityAdjPower,
 	}, ok, nil
 }
 func (s *state2) MinerNominalPowerMeetsConsensusMinimum(a address.Address) (bool, error) {
 	return s.State.MinerNominalPowerMeetsConsensusMinimum(s.store, a)
 }
 func (s *state2) TotalPowerSmoothed() (builtin.FilterEstimate, error) {
 	return builtin.FromV2FilterEstimate(s.State.ThisEpochQAPowerSmoothed), nil
 }
 func (s *state2) MinerCounts() (uint64, uint64, error) {
 	return uint64(s.State.MinerAboveMinPowerCount), uint64(s.State.MinerCount), nil
 }
 func (s *state2) ListAllMiners() ([]address.Address, error) {
 	claims, err := adt2.AsMap(s.store, s.Claims)
 	if err != nil {
 		return nil, err
 	}
 	var miners []address.Address
 	err = claims.ForEach(nil, func(k string) error {
 		a, err := address.NewFromBytes([]byte(k))
 		if err != nil {
 			return err
 		}
 		miners = append(miners, a)
 		return nil
 	})
 	if err != nil {
 		return nil, err
 	}
 	return miners, nil
 }
 func (s *state2) ForEachClaim(cb func(miner address.Address, claim Claim) error) error {
 	claims, err := adt2.AsMap(s.store, s.Claims)
 	if err != nil {
 		return err
 	}
 	var claim power2.Claim
 	return claims.ForEach(&claim, func(k string) error {
 		a, err := address.NewFromBytes([]byte(k))
 		if err != nil {
 			return err
 		}
 		return cb(a, Claim{
 			RawBytePower:    claim.RawBytePower,
 			QualityAdjPower: claim.QualityAdjPower,
 		})
 	})
 }
 func (s *state2) ClaimsChanged(other State) (bool, error) {
 	other2, ok := other.(*state2)
 	if !ok {
 		// treat an upgrade as a change, always
 		return true, nil
 	}
 	return !s.State.Claims.Equals(other2.State.Claims), nil
 }
 func (s *state2) claims() (adt.Map, error) {
 	return adt2.AsMap(s.store, s.Claims)
 }
 func (s *state2) decodeClaim(val *cbg.Deferred) (Claim, error) {
 	var ci power2.Claim
 	if err := ci.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil {
 		return Claim{}, err
 	}
 	return fromV2Claim(ci), nil
 }
 func fromV2Claim(v2 power2.Claim) Claim {
 	return Claim{
 		RawBytePower:    v2.RawBytePower,
 		QualityAdjPower: v2.QualityAdjPower,
 	}
 }
--- a/chain/actors/builtin/reward/reward.go
+++ b/chain/actors/builtin/reward/reward.go
@ -3,27 +3,38 @@ package reward
 import (
 	"github.com/filecoin-project/go-state-types/abi"
 	reward0 "github.com/filecoin-project/specs-actors/actors/builtin/reward"
 	"github.com/ipfs/go-cid"
 	"golang.org/x/xerrors"
 	"github.com/filecoin-project/go-state-types/cbor"
 	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
 	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
 	"github.com/filecoin-project/lotus/chain/actors/adt"
 	"github.com/filecoin-project/lotus/chain/actors/builtin"
 	"github.com/filecoin-project/lotus/chain/types"
 )
-var Address = builtin0.RewardActorAddr
+func init() {
 	builtin.RegisterActorState(builtin0.RewardActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
 		return load0(store, root)
 	})
 	builtin.RegisterActorState(builtin2.RewardActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
 		return load2(store, root)
 	})
 }
 var (
 	Address = builtin2.RewardActorAddr
 	Methods = builtin2.MethodsReward
 )
 func Load(store adt.Store, act *types.Actor) (st State, err error) {
 	switch act.Code {
 	case builtin0.RewardActorCodeID:
-		out := state0{store: store}
+		return load0(store, act.Head)
-		err := store.Get(store.Context(), act.Head, &out)
+	case builtin2.RewardActorCodeID:
-		if err != nil {
+		return load2(store, act.Head)
 			return nil, err
 		}
 		return &out, nil
 	}
 	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
 }
--- a/chain/actors/builtin/reward/v0.go
+++ b/chain/actors/builtin/reward/v0.go
@ -2,17 +2,29 @@ package reward
 import (
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/ipfs/go-cid"
 	"github.com/filecoin-project/lotus/chain/actors/adt"
 	"github.com/filecoin-project/lotus/chain/actors/builtin"
 	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
-	"github.com/filecoin-project/specs-actors/actors/builtin/reward"
+	reward0 "github.com/filecoin-project/specs-actors/actors/builtin/reward"
-	"github.com/filecoin-project/specs-actors/actors/util/adt"
+	smoothing0 "github.com/filecoin-project/specs-actors/actors/util/smoothing"
 	"github.com/filecoin-project/specs-actors/actors/util/smoothing"
 )
 var _ State = (*state0)(nil)
 func load0(store adt.Store, root cid.Cid) (State, error) {
 	out := state0{store: store}
 	err := store.Get(store.Context(), root, &out)
 	if err != nil {
 		return nil, err
 	}
 	return &out, nil
 }
 type state0 struct {
-	reward.State
+	reward0.State
 	store adt.Store
 }
@ -45,7 +57,7 @@ func (s *state0) CumsumBaseline() (abi.StoragePower, error) {
 }
 func (s *state0) CumsumRealized() (abi.StoragePower, error) {
-	return s.State.CumsumBaseline, nil
+	return s.State.CumsumRealized, nil
 }
 func (s *state0) InitialPledgeForPower(sectorWeight abi.StoragePower, networkTotalPledge abi.TokenAmount, networkQAPower *builtin.FilterEstimate, circSupply abi.TokenAmount) (abi.TokenAmount, error) {
@ -54,7 +66,7 @@ func (s *state0) InitialPledgeForPower(sectorWeight abi.StoragePower, networkTot
 		s.State.ThisEpochBaselinePower,
 		networkTotalPledge,
 		s.State.ThisEpochRewardSmoothed,
-		&smoothing.FilterEstimate{
+		&smoothing0.FilterEstimate{
 			PositionEstimate: networkQAPower.PositionEstimate,
 			VelocityEstimate: networkQAPower.VelocityEstimate,
 		},
@ -63,7 +75,7 @@ func (s *state0) InitialPledgeForPower(sectorWeight abi.StoragePower, networkTot
 func (s *state0) PreCommitDepositForPower(networkQAPower builtin.FilterEstimate, sectorWeight abi.StoragePower) (abi.TokenAmount, error) {
 	return miner0.PreCommitDepositForPower(s.State.ThisEpochRewardSmoothed,
-		&smoothing.FilterEstimate{
+		&smoothing0.FilterEstimate{
 			PositionEstimate: networkQAPower.PositionEstimate,
 			VelocityEstimate: networkQAPower.VelocityEstimate,
 		},
--- a/chain/actors/builtin/reward/v2.go
+++ b/chain/actors/builtin/reward/v2.go
@ -0,0 +1,86 @@
 package reward
 import (
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/ipfs/go-cid"
 	"github.com/filecoin-project/lotus/chain/actors/adt"
 	"github.com/filecoin-project/lotus/chain/actors/builtin"
 	miner2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/miner"
 	reward2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/reward"
 	smoothing2 "github.com/filecoin-project/specs-actors/v2/actors/util/smoothing"
 )
 var _ State = (*state2)(nil)
 func load2(store adt.Store, root cid.Cid) (State, error) {
 	out := state2{store: store}
 	err := store.Get(store.Context(), root, &out)
 	if err != nil {
 		return nil, err
 	}
 	return &out, nil
 }
 type state2 struct {
 	reward2.State
 	store adt.Store
 }
 func (s *state2) ThisEpochReward() (abi.TokenAmount, error) {
 	return s.State.ThisEpochReward, nil
 }
 func (s *state2) ThisEpochRewardSmoothed() (builtin.FilterEstimate, error) {
 	return builtin.FilterEstimate{
 		PositionEstimate: s.State.ThisEpochRewardSmoothed.PositionEstimate,
 		VelocityEstimate: s.State.ThisEpochRewardSmoothed.VelocityEstimate,
 	}, nil
 }
 func (s *state2) ThisEpochBaselinePower() (abi.StoragePower, error) {
 	return s.State.ThisEpochBaselinePower, nil
 }
 func (s *state2) TotalStoragePowerReward() (abi.TokenAmount, error) {
 	return s.State.TotalStoragePowerReward, nil
 }
 func (s *state2) EffectiveBaselinePower() (abi.StoragePower, error) {
 	return s.State.EffectiveBaselinePower, nil
 }
 func (s *state2) EffectiveNetworkTime() (abi.ChainEpoch, error) {
 	return s.State.EffectiveNetworkTime, nil
 }
 func (s *state2) CumsumBaseline() (reward2.Spacetime, error) {
 	return s.State.CumsumBaseline, nil
 }
 func (s *state2) CumsumRealized() (reward2.Spacetime, error) {
 	return s.State.CumsumRealized, nil
 }
 func (s *state2) InitialPledgeForPower(qaPower abi.StoragePower, networkTotalPledge abi.TokenAmount, networkQAPower *builtin.FilterEstimate, circSupply abi.TokenAmount) (abi.TokenAmount, error) {
 	return miner2.InitialPledgeForPower(
 		qaPower,
 		s.State.ThisEpochBaselinePower,
 		s.State.ThisEpochRewardSmoothed,
 		smoothing2.FilterEstimate{
 			PositionEstimate: networkQAPower.PositionEstimate,
 			VelocityEstimate: networkQAPower.VelocityEstimate,
 		},
 		circSupply,
 	), nil
 }
 func (s *state2) PreCommitDepositForPower(networkQAPower builtin.FilterEstimate, sectorWeight abi.StoragePower) (abi.TokenAmount, error) {
 	return miner2.PreCommitDepositForPower(s.State.ThisEpochRewardSmoothed,
 		smoothing2.FilterEstimate{
 			PositionEstimate: networkQAPower.PositionEstimate,
 			VelocityEstimate: networkQAPower.VelocityEstimate,
 		},
 		sectorWeight), nil
 }
--- a/chain/actors/builtin/verifreg/util.go
+++ b/chain/actors/builtin/verifreg/util.go
@ -0,0 +1,46 @@
 package verifreg
 import (
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/big"
 	"github.com/filecoin-project/lotus/chain/actors"
 	"github.com/filecoin-project/lotus/chain/actors/adt"
 	"github.com/ipfs/go-cid"
 	"golang.org/x/xerrors"
 )
 func getDataCap(store adt.Store, ver actors.Version, root cid.Cid, addr address.Address) (bool, abi.StoragePower, error) {
 	if addr.Protocol() != address.ID {
 		return false, big.Zero(), xerrors.Errorf("can only look up ID addresses")
 	}
 	vh, err := adt.AsMap(store, root, ver)
 	if err != nil {
 		return false, big.Zero(), xerrors.Errorf("loading verifreg: %w", err)
 	}
 	var dcap abi.StoragePower
 	if found, err := vh.Get(abi.AddrKey(addr), &dcap); err != nil {
 		return false, big.Zero(), xerrors.Errorf("looking up addr: %w", err)
 	} else if !found {
 		return false, big.Zero(), nil
 	}
 	return true, dcap, nil
 }
 func forEachCap(store adt.Store, ver actors.Version, root cid.Cid, cb func(addr address.Address, dcap abi.StoragePower) error) error {
 	vh, err := adt.AsMap(store, root, ver)
 	if err != nil {
 		return xerrors.Errorf("loading verified clients: %w", err)
 	}
 	var dcap abi.StoragePower
 	return vh.ForEach(&dcap, func(key string) error {
 		a, err := address.NewFromBytes([]byte(key))
 		if err != nil {
 			return err
 		}
 		return cb(a, dcap)
 	})
 }
--- a/chain/actors/builtin/verifreg/v0.go
+++ b/chain/actors/builtin/verifreg/v0.go
@ -3,69 +3,46 @@ package verifreg
 import (
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/big"
 	verifreg0 "github.com/filecoin-project/specs-actors/actors/builtin/verifreg"
 	adt0 "github.com/filecoin-project/specs-actors/actors/util/adt"
 	"github.com/ipfs/go-cid"
 	"golang.org/x/xerrors"
 	"github.com/filecoin-project/lotus/chain/actors"
 	"github.com/filecoin-project/lotus/chain/actors/adt"
 	verifreg0 "github.com/filecoin-project/specs-actors/actors/builtin/verifreg"
 )
 var _ State = (*state0)(nil)
 func load0(store adt.Store, root cid.Cid) (State, error) {
 	out := state0{store: store}
 	err := store.Get(store.Context(), root, &out)
 	if err != nil {
 		return nil, err
 	}
 	return &out, nil
 }
 type state0 struct {
 	verifreg0.State
 	store adt.Store
 }
-func getDataCap(store adt.Store, root cid.Cid, addr address.Address) (bool, abi.StoragePower, error) {
+func (s *state0) RootKey() (address.Address, error) {
-	if addr.Protocol() != address.ID {
+	return s.State.RootKey, nil
 		return false, big.Zero(), xerrors.Errorf("can only look up ID addresses")
 	}
 	vh, err := adt0.AsMap(store, root)
 	if err != nil {
 		return false, big.Zero(), xerrors.Errorf("loading verifreg: %w", err)
 	}
 	var dcap abi.StoragePower
 	if found, err := vh.Get(abi.AddrKey(addr), &dcap); err != nil {
 		return false, big.Zero(), xerrors.Errorf("looking up addr: %w", err)
 	} else if !found {
 		return false, big.Zero(), nil
 	}
 	return true, dcap, nil
 }
 func (s *state0) VerifiedClientDataCap(addr address.Address) (bool, abi.StoragePower, error) {
-	return getDataCap(s.store, s.State.VerifiedClients, addr)
+	return getDataCap(s.store, actors.Version0, s.State.VerifiedClients, addr)
 }
 func (s *state0) VerifierDataCap(addr address.Address) (bool, abi.StoragePower, error) {
-	return getDataCap(s.store, s.State.Verifiers, addr)
+	return getDataCap(s.store, actors.Version0, s.State.Verifiers, addr)
 }
 func forEachCap(store adt.Store, root cid.Cid, cb func(addr address.Address, dcap abi.StoragePower) error) error {
 	vh, err := adt0.AsMap(store, root)
 	if err != nil {
 		return xerrors.Errorf("loading verified clients: %w", err)
 	}
 	var dcap abi.StoragePower
 	return vh.ForEach(&dcap, func(key string) error {
 		a, err := address.NewFromBytes([]byte(key))
 		if err != nil {
 			return err
 		}
 		return cb(a, dcap)
 	})
 }
 func (s *state0) ForEachVerifier(cb func(addr address.Address, dcap abi.StoragePower) error) error {
-	return forEachCap(s.store, s.State.Verifiers, cb)
+	return forEachCap(s.store, actors.Version0, s.State.Verifiers, cb)
 }
 func (s *state0) ForEachClient(cb func(addr address.Address, dcap abi.StoragePower) error) error {
-	return forEachCap(s.store, s.State.VerifiedClients, cb)
+	return forEachCap(s.store, actors.Version0, s.State.VerifiedClients, cb)
 }
--- a/chain/actors/builtin/verifreg/v2.go
+++ b/chain/actors/builtin/verifreg/v2.go
@ -0,0 +1,48 @@
 package verifreg
 import (
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/ipfs/go-cid"
 	"github.com/filecoin-project/lotus/chain/actors"
 	"github.com/filecoin-project/lotus/chain/actors/adt"
 	verifreg2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/verifreg"
 )
 var _ State = (*state2)(nil)
 func load2(store adt.Store, root cid.Cid) (State, error) {
 	out := state2{store: store}
 	err := store.Get(store.Context(), root, &out)
 	if err != nil {
 		return nil, err
 	}
 	return &out, nil
 }
 type state2 struct {
 	verifreg2.State
 	store adt.Store
 }
 func (s *state2) RootKey() (address.Address, error) {
 	return s.State.RootKey, nil
 }
 func (s *state2) VerifiedClientDataCap(addr address.Address) (bool, abi.StoragePower, error) {
 	return getDataCap(s.store, actors.Version2, s.State.VerifiedClients, addr)
 }
 func (s *state2) VerifierDataCap(addr address.Address) (bool, abi.StoragePower, error) {
 	return getDataCap(s.store, actors.Version2, s.State.Verifiers, addr)
 }
 func (s *state2) ForEachVerifier(cb func(addr address.Address, dcap abi.StoragePower) error) error {
 	return forEachCap(s.store, actors.Version2, s.State.Verifiers, cb)
 }
 func (s *state2) ForEachClient(cb func(addr address.Address, dcap abi.StoragePower) error) error {
 	return forEachCap(s.store, actors.Version2, s.State.VerifiedClients, cb)
 }
--- a/chain/actors/builtin/verifreg/verifreg.go
+++ b/chain/actors/builtin/verifreg/verifreg.go
@ -3,26 +3,38 @@ package verifreg
 import (
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/ipfs/go-cid"
 	"golang.org/x/xerrors"
 	"github.com/filecoin-project/go-state-types/cbor"
 	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
 	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
 	"github.com/filecoin-project/lotus/chain/actors/adt"
 	"github.com/filecoin-project/lotus/chain/actors/builtin"
 	"github.com/filecoin-project/lotus/chain/types"
 )
-var Address = builtin0.VerifiedRegistryActorAddr
+func init() {
 	builtin.RegisterActorState(builtin0.VerifiedRegistryActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
 		return load0(store, root)
 	})
 	builtin.RegisterActorState(builtin2.VerifiedRegistryActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
 		return load2(store, root)
 	})
 }
 var (
 	Address = builtin2.VerifiedRegistryActorAddr
 	Methods = builtin2.MethodsVerifiedRegistry
 )
 func Load(store adt.Store, act *types.Actor) (State, error) {
 	switch act.Code {
 	case builtin0.VerifiedRegistryActorCodeID:
-		out := state0{store: store}
+		return load0(store, act.Head)
-		err := store.Get(store.Context(), act.Head, &out)
+	case builtin2.VerifiedRegistryActorCodeID:
-		if err != nil {
+		return load2(store, act.Head)
 			return nil, err
 		}
 		return &out, nil
 	}
 	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
 }
@ -30,6 +42,7 @@ func Load(store adt.Store, act *types.Actor) (State, error) {
 type State interface {
 	cbor.Marshaler
 	RootKey() (address.Address, error)
 	VerifiedClientDataCap(address.Address) (bool, abi.StoragePower, error)
 	VerifierDataCap(address.Address) (bool, abi.StoragePower, error)
 	ForEachVerifier(func(addr address.Address, dcap abi.StoragePower) error) error
--- a/chain/actors/params.go
+++ b/chain/actors/params.go
@ -3,6 +3,8 @@ package actors
 import (
 	"bytes"
 	"github.com/filecoin-project/go-state-types/exitcode"
 	"github.com/filecoin-project/lotus/chain/actors/aerrors"
 	cbg "github.com/whyrusleeping/cbor-gen"
 )
@ -11,7 +13,7 @@ func SerializeParams(i cbg.CBORMarshaler) ([]byte, aerrors.ActorError) {
 	buf := new(bytes.Buffer)
 	if err := i.MarshalCBOR(buf); err != nil {
 		// TODO: shouldnt this be a fatal error?
-		return nil, aerrors.Absorb(err, 1, "failed to encode parameter")
+		return nil, aerrors.Absorb(err, exitcode.ErrSerialization, "failed to encode parameter")
 	}
 	return buf.Bytes(), nil
 }
--- a/chain/actors/policy/policy.go
+++ b/chain/actors/policy/policy.go
@ -1,33 +1,55 @@
 package policy
 import (
-	"github.com/filecoin-project/go-state-types/abi"
+	"sort"
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/network"
 	"github.com/filecoin-project/lotus/chain/actors"
 	market0 "github.com/filecoin-project/specs-actors/actors/builtin/market"
 	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
 	power0 "github.com/filecoin-project/specs-actors/actors/builtin/power"
 	verifreg0 "github.com/filecoin-project/specs-actors/actors/builtin/verifreg"
 	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
 	market2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/market"
 	miner2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/miner"
 	paych2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/paych"
 	verifreg2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/verifreg"
 )
 const (
 	ChainFinality          = miner0.ChainFinality
 	SealRandomnessLookback = ChainFinality
 	PaychSettleDelay       = paych2.SettleDelay
 )
 // SetSupportedProofTypes sets supported proof types, across all actor versions.
 // This should only be used for testing.
 func SetSupportedProofTypes(types ...abi.RegisteredSealProof) {
-	newTypes := make(map[abi.RegisteredSealProof]struct{}, len(types))
+	miner0.SupportedProofTypes = make(map[abi.RegisteredSealProof]struct{}, len(types))
-	for _, t := range types {
+	miner2.PreCommitSealProofTypesV0 = make(map[abi.RegisteredSealProof]struct{}, len(types))
-		newTypes[t] = struct{}{}
+	miner2.PreCommitSealProofTypesV7 = make(map[abi.RegisteredSealProof]struct{}, len(types)*2)
-	}
+	miner2.PreCommitSealProofTypesV8 = make(map[abi.RegisteredSealProof]struct{}, len(types))
-	// Set for all miner versions.
+
-	miner0.SupportedProofTypes = newTypes
+	AddSupportedProofTypes(types...)
 }
 // AddSupportedProofTypes sets supported proof types, across all actor versions.
 // This should only be used for testing.
 func AddSupportedProofTypes(types ...abi.RegisteredSealProof) {
 	newTypes := make(map[abi.RegisteredSealProof]struct{}, len(types))
 	for _, t := range types {
-		newTypes[t] = struct{}{}
+		if t >= abi.RegisteredSealProof_StackedDrg2KiBV1_1 {
 			panic("must specify v1 proof types only")
 		}
 		// Set for all miner versions.
 		miner0.SupportedProofTypes[t] = struct{}{}
 		miner2.PreCommitSealProofTypesV0[t] = struct{}{}
 		miner2.PreCommitSealProofTypesV7[t] = struct{}{}
 		miner2.PreCommitSealProofTypesV7[t+abi.RegisteredSealProof_StackedDrg2KiBV1_1] = struct{}{}
 		miner2.PreCommitSealProofTypesV8[t+abi.RegisteredSealProof_StackedDrg2KiBV1_1] = struct{}{}
 	}
 	// Set for all miner versions.
 	miner0.SupportedProofTypes = newTypes
 }
 // SetPreCommitChallengeDelay sets the pre-commit challenge delay across all
@ -35,6 +57,7 @@ func AddSupportedProofTypes(types ...abi.RegisteredSealProof) {
 func SetPreCommitChallengeDelay(delay abi.ChainEpoch) {
 	// Set for all miner versions.
 	miner0.PreCommitChallengeDelay = delay
 	miner2.PreCommitChallengeDelay = delay
 }
 // TODO: this function shouldn't really exist. Instead, the API should expose the precommit delay.
@ -47,10 +70,90 @@ func GetPreCommitChallengeDelay() abi.ChainEpoch {
 // for testing.
 func SetConsensusMinerMinPower(p abi.StoragePower) {
 	power0.ConsensusMinerMinPower = p
 	for _, policy := range builtin2.SealProofPolicies {
 		policy.ConsensusMinerMinPower = p
 	}
 }
 // SetMinVerifiedDealSize sets the minimum size of a verified deal. This should
 // only be used for testing.
 func SetMinVerifiedDealSize(size abi.StoragePower) {
 	verifreg0.MinVerifiedDealSize = size
 	verifreg2.MinVerifiedDealSize = size
 }
 func GetMaxProveCommitDuration(ver actors.Version, t abi.RegisteredSealProof) abi.ChainEpoch {
 	switch ver {
 	case actors.Version0:
 		return miner0.MaxSealDuration[t]
 	case actors.Version2:
 		return miner2.MaxProveCommitDuration[t]
 	default:
 		panic("unsupported actors version")
 	}
 }
 func DealProviderCollateralBounds(
 	size abi.PaddedPieceSize, verified bool,
 	rawBytePower, qaPower, baselinePower abi.StoragePower,
 	circulatingFil abi.TokenAmount, nwVer network.Version,
 ) (min, max abi.TokenAmount) {
 	switch actors.VersionForNetwork(nwVer) {
 	case actors.Version0:
 		return market0.DealProviderCollateralBounds(size, verified, rawBytePower, qaPower, baselinePower, circulatingFil, nwVer)
 	case actors.Version2:
 		return market2.DealProviderCollateralBounds(size, verified, rawBytePower, qaPower, baselinePower, circulatingFil)
 	default:
 		panic("unsupported network version")
 	}
 }
 // Sets the challenge window and scales the proving period to match (such that
 // there are always 48 challenge windows in a proving period).
 func SetWPoStChallengeWindow(period abi.ChainEpoch) {
 	miner0.WPoStChallengeWindow = period
 	miner0.WPoStProvingPeriod = period * abi.ChainEpoch(miner0.WPoStPeriodDeadlines)
 	miner2.WPoStChallengeWindow = period
 	miner2.WPoStProvingPeriod = period * abi.ChainEpoch(miner2.WPoStPeriodDeadlines)
 }
 func GetWinningPoStSectorSetLookback(nwVer network.Version) abi.ChainEpoch {
 	if nwVer <= network.Version3 {
 		return 10
 	}
 	return ChainFinality
 }
 func GetMaxSectorExpirationExtension() abi.ChainEpoch {
 	return miner0.MaxSectorExpirationExtension
 }
 // TODO: we'll probably need to abstract over this better in the future.
 func GetMaxPoStPartitions(p abi.RegisteredPoStProof) (int, error) {
 	sectorsPerPart, err := builtin2.PoStProofWindowPoStPartitionSectors(p)
 	if err != nil {
 		return 0, err
 	}
 	return int(miner2.AddressedSectorsMax / sectorsPerPart), nil
 }
 func GetDefaultSectorSize() abi.SectorSize {
 	// supported sector sizes are the same across versions.
 	szs := make([]abi.SectorSize, 0, len(miner2.PreCommitSealProofTypesV8))
 	for spt := range miner2.PreCommitSealProofTypesV8 {
 		ss, err := spt.SectorSize()
 		if err != nil {
 			panic(err)
 		}
 		szs = append(szs, ss)
 	}
 	sort.Slice(szs, func(i, j int) bool {
 		return szs[i] < szs[j]
 	})
 	return szs[0]
 }
--- a/chain/actors/policy/policy_test.go
+++ b/chain/actors/policy/policy_test.go
@ -0,0 +1,70 @@
 package policy
 import (
 	"testing"
 	"github.com/stretchr/testify/require"
 	"github.com/filecoin-project/go-state-types/abi"
 	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
 	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
 	paych0 "github.com/filecoin-project/specs-actors/actors/builtin/paych"
 	verifreg0 "github.com/filecoin-project/specs-actors/actors/builtin/verifreg"
 	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
 	miner2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/miner"
 	paych2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/paych"
 	verifreg2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/verifreg"
 )
 func TestSupportedProofTypes(t *testing.T) {
 	var oldTypes []abi.RegisteredSealProof
 	for t := range miner0.SupportedProofTypes {
 		oldTypes = append(oldTypes, t)
 	}
 	t.Cleanup(func() {
 		SetSupportedProofTypes(oldTypes...)
 	})
 	SetSupportedProofTypes(abi.RegisteredSealProof_StackedDrg2KiBV1)
 	require.EqualValues(t,
 		miner0.SupportedProofTypes,
 		map[abi.RegisteredSealProof]struct{}{
 			abi.RegisteredSealProof_StackedDrg2KiBV1: {},
 		},
 	)
 	AddSupportedProofTypes(abi.RegisteredSealProof_StackedDrg8MiBV1)
 	require.EqualValues(t,
 		miner0.SupportedProofTypes,
 		map[abi.RegisteredSealProof]struct{}{
 			abi.RegisteredSealProof_StackedDrg2KiBV1: {},
 			abi.RegisteredSealProof_StackedDrg8MiBV1: {},
 		},
 	)
 }
 // Tests assumptions about policies being the same between actor versions.
 func TestAssumptions(t *testing.T) {
 	require.EqualValues(t, miner0.SupportedProofTypes, miner2.PreCommitSealProofTypesV0)
 	require.Equal(t, miner0.PreCommitChallengeDelay, miner2.PreCommitChallengeDelay)
 	require.Equal(t, miner0.MaxSectorExpirationExtension, miner2.MaxSectorExpirationExtension)
 	require.Equal(t, miner0.ChainFinality, miner2.ChainFinality)
 	require.Equal(t, miner0.WPoStChallengeWindow, miner2.WPoStChallengeWindow)
 	require.Equal(t, miner0.WPoStProvingPeriod, miner2.WPoStProvingPeriod)
 	require.Equal(t, miner0.WPoStPeriodDeadlines, miner2.WPoStPeriodDeadlines)
 	require.Equal(t, miner0.AddressedSectorsMax, miner2.AddressedSectorsMax)
 	require.Equal(t, paych0.SettleDelay, paych2.SettleDelay)
 	require.True(t, verifreg0.MinVerifiedDealSize.Equals(verifreg2.MinVerifiedDealSize))
 }
 func TestPartitionSizes(t *testing.T) {
 	for _, p := range abi.SealProofInfos {
 		sizeNew, err := builtin2.PoStProofWindowPoStPartitionSectors(p.WindowPoStProof)
 		require.NoError(t, err)
 		sizeOld, err := builtin0.PoStProofWindowPoStPartitionSectors(p.WindowPoStProof)
 		if err != nil {
 			// new proof type.
 			continue
 		}
 		require.Equal(t, sizeOld, sizeNew)
 	}
 }
--- a/chain/actors/version.go
+++ b/chain/actors/version.go
@ -0,0 +1,26 @@
 package actors
 import (
 	"fmt"
 	"github.com/filecoin-project/go-state-types/network"
 )
 type Version int
 const (
 	Version0 Version = 0
 	Version2 Version = 2
 )
 // Converts a network version into an actors adt version.
 func VersionForNetwork(version network.Version) Version {
 	switch version {
 	case network.Version0, network.Version1, network.Version2, network.Version3:
 		return Version0
 	case network.Version4, network.Version5, network.Version6, network.Version7, network.Version8:
 		return Version2
 	default:
 		panic(fmt.Sprintf("unsupported network version %d", version))
 	}
 }
--- a/chain/badtscache.go
+++ b/chain/badtscache.go
@ -60,6 +60,10 @@ func (bts *BadBlockCache) Remove(c cid.Cid) {
 	bts.badBlocks.Remove(c)
 }
 func (bts *BadBlockCache) Purge() {
 	bts.badBlocks.Purge()
 }
 func (bts *BadBlockCache) Has(c cid.Cid) (BadBlockReason, bool) {
 	rval, ok := bts.badBlocks.Get(c)
 	if !ok {
--- a/chain/beacon/drand/drand.go
+++ b/chain/beacon/drand/drand.go
@ -65,6 +65,11 @@ type DrandBeacon struct {
 	localCache map[uint64]types.BeaconEntry
 }
 // DrandHTTPClient interface overrides the user agent used by drand
 type DrandHTTPClient interface {
 	SetUserAgent(string)
 }
 func NewDrandBeacon(genesisTs, interval uint64, ps *pubsub.PubSub, config dtypes.DrandConfig) (*DrandBeacon, error) {
 	if genesisTs == 0 {
 		panic("what are you doing this cant be zero")
@ -84,6 +89,7 @@ func NewDrandBeacon(genesisTs, interval uint64, ps *pubsub.PubSub, config dtypes
 		if err != nil {
 			return nil, xerrors.Errorf("could not create http drand client: %w", err)
 		}
 		hc.(DrandHTTPClient).SetUserAgent("drand-client-lotus/" + build.BuildVersion)
 		clients = append(clients, hc)
 	}
@ -92,7 +98,6 @@ func NewDrandBeacon(genesisTs, interval uint64, ps *pubsub.PubSub, config dtypes
 		dclient.WithChainInfo(drandChain),
 		dclient.WithCacheSize(1024),
 		dclient.WithLogger(dlogger),
 		dclient.WithAutoWatch(),
 	}
 	if ps != nil {
--- a/chain/beacon/drand/drand_test.go
+++ b/chain/beacon/drand/drand_test.go
@ -12,7 +12,7 @@ import (
 )
 func TestPrintGroupInfo(t *testing.T) {
-	server := build.DrandConfigs[build.DrandIncentinet].Servers[0]
+	server := build.DrandConfigs[build.DrandDevnet].Servers[0]
 	c, err := hclient.New(server, nil, nil)
 	assert.NoError(t, err)
 	cg := c.(interface {
--- a/chain/events/events_called.go
+++ b/chain/events/events_called.go
@ -459,7 +459,7 @@ type messageEvents struct {
 	hcAPI headChangeAPI
 	lk       sync.RWMutex
-	matchers map[triggerID][]MsgMatchFunc
+	matchers map[triggerID]MsgMatchFunc
 }
 func newMessageEvents(ctx context.Context, hcAPI headChangeAPI, cs eventAPI) messageEvents {
@ -467,7 +467,7 @@ func newMessageEvents(ctx context.Context, hcAPI headChangeAPI, cs eventAPI) mes
 		ctx:      ctx,
 		cs:       cs,
 		hcAPI:    hcAPI,
-		matchers: map[triggerID][]MsgMatchFunc{},
+		matchers: make(map[triggerID]MsgMatchFunc),
 	}
 }
@ -482,32 +482,23 @@ func (me *messageEvents) checkNewCalls(ts *types.TipSet) (map[triggerID]eventDat
 	me.lk.RLock()
 	defer me.lk.RUnlock()
 	// For each message in the tipset
 	res := make(map[triggerID]eventData)
 	me.messagesForTs(pts, func(msg *types.Message) {
 		// TODO: provide receipts
-		for tid, matchFns := range me.matchers {
+		// Run each trigger's matcher against the message
-			var matched bool
+		for tid, matchFn := range me.matchers {
-			var once bool
+			matched, err := matchFn(msg)
-			for _, matchFn := range matchFns {
+			if err != nil {
-				matchOne, ok, err := matchFn(msg)
+				log.Errorf("event matcher failed: %s", err)
-				if err != nil {
+				continue
 					log.Errorf("event matcher failed: %s", err)
 					continue
 				}
 				matched = ok
 				once = matchOne
 				if matched {
 					break
 				}
 			}
 			// If there was a match, include the message in the results for the
 			// trigger
 			if matched {
 				res[tid] = msg
 				if once {
 					break
 				}
 			}
 		}
 	})
@ -555,7 +546,7 @@ func (me *messageEvents) messagesForTs(ts *types.TipSet, consume func(*types.Mes
 // `curH`-`ts.Height` = `confidence`
 type MsgHandler func(msg *types.Message, rec *types.MessageReceipt, ts *types.TipSet, curH abi.ChainEpoch) (more bool, err error)
-type MsgMatchFunc func(msg *types.Message) (matchOnce bool, matched bool, err error)
+type MsgMatchFunc func(msg *types.Message) (matched bool, err error)
 // Called registers a callback which is triggered when a specified method is
 //  called on an actor, or a timeout is reached.
@ -607,7 +598,7 @@ func (me *messageEvents) Called(check CheckFunc, msgHnd MsgHandler, rev RevertHa
 	me.lk.Lock()
 	defer me.lk.Unlock()
-	me.matchers[id] = append(me.matchers[id], mf)
+	me.matchers[id] = mf
 	return nil
 }
--- a/chain/events/events_test.go
+++ b/chain/events/events_test.go
@ -572,9 +572,9 @@ func TestAtChainedConfidenceNull(t *testing.T) {
 	require.Equal(t, false, reverted)
 }
-func matchAddrMethod(to address.Address, m abi.MethodNum) func(msg *types.Message) (matchOnce bool, matched bool, err error) {
+func matchAddrMethod(to address.Address, m abi.MethodNum) func(msg *types.Message) (matched bool, err error) {
-	return func(msg *types.Message) (matchOnce bool, matched bool, err error) {
+	return func(msg *types.Message) (matched bool, err error) {
-		return true, to == msg.To && m == msg.Method, nil
+		return to == msg.To && m == msg.Method, nil
 	}
 }
--- a/chain/events/state/fastapi.go
+++ b/chain/events/state/fastapi.go
@ -0,0 +1,34 @@
 package state
 import (
 	"context"
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/lotus/chain/types"
 )
 type FastChainApiAPI interface {
 	ChainAPI
 	ChainGetTipSet(context.Context, types.TipSetKey) (*types.TipSet, error)
 }
 type fastAPI struct {
 	FastChainApiAPI
 }
 func WrapFastAPI(api FastChainApiAPI) ChainAPI {
 	return &fastAPI{
 		api,
 	}
 }
 func (a *fastAPI) StateGetActor(ctx context.Context, actor address.Address, tsk types.TipSetKey) (*types.Actor, error) {
 	ts, err := a.FastChainApiAPI.ChainGetTipSet(ctx, tsk)
 	if err != nil {
 		return nil, err
 	}
 	return a.FastChainApiAPI.StateGetActor(ctx, actor, ts.Parents())
 }
--- a/chain/events/state/mock/api.go
+++ b/chain/events/state/mock/api.go
@ -0,0 +1,69 @@
 package test
 import (
 	"context"
 	"sync"
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/lib/blockstore"
 	"github.com/ipfs/go-cid"
 	"golang.org/x/xerrors"
 )
 type MockAPI struct {
 	bs blockstore.Blockstore
 	lk                  sync.Mutex
 	ts                  map[types.TipSetKey]*types.Actor
 	stateGetActorCalled int
 }
 func NewMockAPI(bs blockstore.Blockstore) *MockAPI {
 	return &MockAPI{
 		bs: bs,
 		ts: make(map[types.TipSetKey]*types.Actor),
 	}
 }
 func (m *MockAPI) ChainHasObj(ctx context.Context, c cid.Cid) (bool, error) {
 	return m.bs.Has(c)
 }
 func (m *MockAPI) ChainReadObj(ctx context.Context, c cid.Cid) ([]byte, error) {
 	blk, err := m.bs.Get(c)
 	if err != nil {
 		return nil, xerrors.Errorf("blockstore get: %w", err)
 	}
 	return blk.RawData(), nil
 }
 func (m *MockAPI) StateGetActor(ctx context.Context, actor address.Address, tsk types.TipSetKey) (*types.Actor, error) {
 	m.lk.Lock()
 	defer m.lk.Unlock()
 	m.stateGetActorCalled++
 	return m.ts[tsk], nil
 }
 func (m *MockAPI) StateGetActorCallCount() int {
 	m.lk.Lock()
 	defer m.lk.Unlock()
 	return m.stateGetActorCalled
 }
 func (m *MockAPI) ResetCallCounts() {
 	m.lk.Lock()
 	defer m.lk.Unlock()
 	m.stateGetActorCalled = 0
 }
 func (m *MockAPI) SetActor(tsk types.TipSetKey, act *types.Actor) {
 	m.lk.Lock()
 	defer m.lk.Unlock()
 	m.ts[tsk] = act
 }
--- a/chain/events/state/mock/state.go
+++ b/chain/events/state/mock/state.go
@ -0,0 +1,32 @@
 package test
 import (
 	"context"
 	"testing"
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/ipfs/go-cid"
 	"github.com/filecoin-project/specs-actors/v2/actors/builtin/market"
 	"github.com/filecoin-project/specs-actors/v2/actors/util/adt"
 	"github.com/stretchr/testify/require"
 )
 func CreateEmptyMarketState(t *testing.T, store adt.Store) *market.State {
 	emptyArrayCid, err := adt.MakeEmptyArray(store).Root()
 	require.NoError(t, err)
 	emptyMap, err := adt.MakeEmptyMap(store).Root()
 	require.NoError(t, err)
 	return market.ConstructState(emptyArrayCid, emptyMap, emptyMap)
 }
 func CreateDealAMT(ctx context.Context, t *testing.T, store adt.Store, deals map[abi.DealID]*market.DealState) cid.Cid {
 	root := adt.MakeEmptyArray(store)
 	for dealID, dealState := range deals {
 		err := root.Set(uint64(dealID), dealState)
 		require.NoError(t, err)
 	}
 	rootCid, err := root.Root()
 	require.NoError(t, err)
 	return rootCid
 }
--- a/chain/events/state/mock/tipset.go
+++ b/chain/events/state/mock/tipset.go
@ -0,0 +1,27 @@
 package test
 import (
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/crypto"
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/ipfs/go-cid"
 )
 var dummyCid cid.Cid
 func init() {
 	dummyCid, _ = cid.Parse("bafkqaaa")
 }
 func MockTipset(minerAddr address.Address, timestamp uint64) (*types.TipSet, error) {
 	return types.NewTipSet([]*types.BlockHeader{{
 		Miner:                 minerAddr,
 		Height:                5,
 		ParentStateRoot:       dummyCid,
 		Messages:              dummyCid,
 		ParentMessageReceipts: dummyCid,
 		BlockSig:              &crypto.Signature{Type: crypto.SigTypeBLS},
 		BLSAggregate:          &crypto.Signature{Type: crypto.SigTypeBLS},
 		Timestamp:             timestamp,
 	}})
 }
--- a/chain/events/state/predicates.go
+++ b/chain/events/state/predicates.go
@ -1,7 +1,6 @@
 package state
 import (
 	"bytes"
 	"context"
 	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
@ -10,7 +9,6 @@ import (
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/big"
 	cbor "github.com/ipfs/go-ipld-cbor"
 	typegen "github.com/whyrusleeping/cbor-gen"
 	"github.com/filecoin-project/lotus/api/apibstore"
 	"github.com/filecoin-project/lotus/chain/actors/adt"
@ -419,179 +417,17 @@ type AddressPair struct {
 	PK address.Address
 }
 type InitActorAddressChanges struct {
 	Added    []AddressPair
 	Modified []AddressChange
 	Removed  []AddressPair
 }
 type AddressChange struct {
 	From AddressPair
 	To   AddressPair
 }
 type DiffInitActorStateFunc func(ctx context.Context, oldState init_.State, newState init_.State) (changed bool, user UserData, err error)
 func (i *InitActorAddressChanges) AsKey(key string) (abi.Keyer, error) {
 	addr, err := address.NewFromBytes([]byte(key))
 	if err != nil {
 		return nil, err
 	}
 	return abi.AddrKey(addr), nil
 }
 func (i *InitActorAddressChanges) Add(key string, val *typegen.Deferred) error {
 	pkAddr, err := address.NewFromBytes([]byte(key))
 	if err != nil {
 		return err
 	}
 	id := new(typegen.CborInt)
 	if err := id.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil {
 		return err
 	}
 	idAddr, err := address.NewIDAddress(uint64(*id))
 	if err != nil {
 		return err
 	}
 	i.Added = append(i.Added, AddressPair{
 		ID: idAddr,
 		PK: pkAddr,
 	})
 	return nil
 }
 func (i *InitActorAddressChanges) Modify(key string, from, to *typegen.Deferred) error {
 	pkAddr, err := address.NewFromBytes([]byte(key))
 	if err != nil {
 		return err
 	}
 	fromID := new(typegen.CborInt)
 	if err := fromID.UnmarshalCBOR(bytes.NewReader(from.Raw)); err != nil {
 		return err
 	}
 	fromIDAddr, err := address.NewIDAddress(uint64(*fromID))
 	if err != nil {
 		return err
 	}
 	toID := new(typegen.CborInt)
 	if err := toID.UnmarshalCBOR(bytes.NewReader(to.Raw)); err != nil {
 		return err
 	}
 	toIDAddr, err := address.NewIDAddress(uint64(*toID))
 	if err != nil {
 		return err
 	}
 	i.Modified = append(i.Modified, AddressChange{
 		From: AddressPair{
 			ID: fromIDAddr,
 			PK: pkAddr,
 		},
 		To: AddressPair{
 			ID: toIDAddr,
 			PK: pkAddr,
 		},
 	})
 	return nil
 }
 func (i *InitActorAddressChanges) Remove(key string, val *typegen.Deferred) error {
 	pkAddr, err := address.NewFromBytes([]byte(key))
 	if err != nil {
 		return err
 	}
 	id := new(typegen.CborInt)
 	if err := id.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil {
 		return err
 	}
 	idAddr, err := address.NewIDAddress(uint64(*id))
 	if err != nil {
 		return err
 	}
 	i.Removed = append(i.Removed, AddressPair{
 		ID: idAddr,
 		PK: pkAddr,
 	})
 	return nil
 }
 func (sp *StatePredicates) OnAddressMapChange() DiffInitActorStateFunc {
 	return func(ctx context.Context, oldState, newState init_.State) (changed bool, user UserData, err error) {
-		addressChanges := &InitActorAddressChanges{
+		addressChanges, err := init_.DiffAddressMap(oldState, newState)
 			Added:    []AddressPair{},
 			Modified: []AddressChange{},
 			Removed:  []AddressPair{},
 		}
 		err = oldState.ForEachActor(func(oldId abi.ActorID, oldAddress address.Address) error {
 			oldIdAddress, err := address.NewIDAddress(uint64(oldId))
 			if err != nil {
 				return err
 			}
 			newIdAddress, found, err := newState.ResolveAddress(oldAddress)
 			if err != nil {
 				return err
 			}
 			if !found {
 				addressChanges.Removed = append(addressChanges.Removed, AddressPair{
 					ID: oldIdAddress,
 					PK: oldAddress,
 				})
 			}
 			if oldIdAddress != newIdAddress {
 				addressChanges.Modified = append(addressChanges.Modified, AddressChange{
 					From: AddressPair{
 						ID: oldIdAddress,
 						PK: oldAddress,
 					},
 					To: AddressPair{
 						ID: newIdAddress,
 						PK: oldAddress,
 					},
 				})
 			}
 			return nil
 		})
 		if err != nil {
 			return false, nil, err
 		}
-
+		if len(addressChanges.Added)+len(addressChanges.Modified)+len(addressChanges.Removed) == 0 {
 		err = newState.ForEachActor(func(newId abi.ActorID, newAddress address.Address) error {
 			newIdAddress, err := address.NewIDAddress(uint64(newId))
 			if err != nil {
 				return err
 			}
 			_, found, err := newState.ResolveAddress(newAddress)
 			if err != nil {
 				return err
 			}
 			if !found {
 				addressChanges.Added = append(addressChanges.Added, AddressPair{
 					ID: newIdAddress,
 					PK: newAddress,
 				})
 			}
 			return nil
 		})
 		if err != nil {
 			return false, nil, err
 		}
 		if len(addressChanges.Added)+len(addressChanges.Removed)+len(addressChanges.Modified) == 0 {
 			return false, nil, nil
 		}
 		return true, addressChanges, nil
 	}
 }
--- a/chain/events/state/predicates_test.go
+++ b/chain/events/state/predicates_test.go
@ -4,28 +4,26 @@ import (
 	"context"
 	"testing"
 	test "github.com/filecoin-project/lotus/chain/events/state/mock"
 	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
 	"github.com/filecoin-project/go-bitfield"
 	"github.com/stretchr/testify/require"
 	"golang.org/x/xerrors"
 	"github.com/ipfs/go-cid"
 	cbornode "github.com/ipfs/go-ipld-cbor"
 	"github.com/stretchr/testify/require"
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/big"
-	"github.com/filecoin-project/go-state-types/crypto"
+	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
 	market2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/market"
 	miner2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/miner"
 	adt2 "github.com/filecoin-project/specs-actors/v2/actors/util/adt"
 	tutils "github.com/filecoin-project/specs-actors/v2/support/testing"
 	"github.com/filecoin-project/lotus/chain/actors/builtin/market"
 	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
 	market0 "github.com/filecoin-project/specs-actors/actors/builtin/market"
 	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
 	"github.com/filecoin-project/specs-actors/actors/util/adt"
 	tutils "github.com/filecoin-project/specs-actors/support/testing"
 	"github.com/filecoin-project/lotus/chain/types"
 	bstore "github.com/filecoin-project/lotus/lib/blockstore"
 )
@ -36,60 +34,27 @@ func init() {
 	dummyCid, _ = cid.Parse("bafkqaaa")
 }
 type mockAPI struct {
 	ts map[types.TipSetKey]*types.Actor
 	bs bstore.Blockstore
 }
 func newMockAPI(bs bstore.Blockstore) *mockAPI {
 	return &mockAPI{
 		bs: bs,
 		ts: make(map[types.TipSetKey]*types.Actor),
 	}
 }
 func (m mockAPI) ChainHasObj(ctx context.Context, c cid.Cid) (bool, error) {
 	return m.bs.Has(c)
 }
 func (m mockAPI) ChainReadObj(ctx context.Context, c cid.Cid) ([]byte, error) {
 	blk, err := m.bs.Get(c)
 	if err != nil {
 		return nil, xerrors.Errorf("blockstore get: %w", err)
 	}
 	return blk.RawData(), nil
 }
 func (m mockAPI) StateGetActor(ctx context.Context, actor address.Address, tsk types.TipSetKey) (*types.Actor, error) {
 	return m.ts[tsk], nil
 }
 func (m mockAPI) setActor(tsk types.TipSetKey, act *types.Actor) {
 	m.ts[tsk] = act
 }
 func TestMarketPredicates(t *testing.T) {
 	ctx := context.Background()
 	bs := bstore.NewTemporarySync()
-	store := adt.WrapStore(ctx, cbornode.NewCborStore(bs))
+	store := adt2.WrapStore(ctx, cbornode.NewCborStore(bs))
-	oldDeal1 := &market0.DealState{
+	oldDeal1 := &market2.DealState{
 		SectorStartEpoch: 1,
 		LastUpdatedEpoch: 2,
 		SlashEpoch:       0,
 	}
-	oldDeal2 := &market0.DealState{
+	oldDeal2 := &market2.DealState{
 		SectorStartEpoch: 4,
 		LastUpdatedEpoch: 5,
 		SlashEpoch:       0,
 	}
-	oldDeals := map[abi.DealID]*market0.DealState{
+	oldDeals := map[abi.DealID]*market2.DealState{
 		abi.DealID(1): oldDeal1,
 		abi.DealID(2): oldDeal2,
 	}
-	oldProp1 := &market0.DealProposal{
+	oldProp1 := &market2.DealProposal{
 		PieceCID:             dummyCid,
 		PieceSize:            0,
 		VerifiedDeal:         false,
@ -101,7 +66,7 @@ func TestMarketPredicates(t *testing.T) {
 		ProviderCollateral:   big.Zero(),
 		ClientCollateral:     big.Zero(),
 	}
-	oldProp2 := &market0.DealProposal{
+	oldProp2 := &market2.DealProposal{
 		PieceCID:             dummyCid,
 		PieceSize:            0,
 		VerifiedDeal:         false,
@ -113,7 +78,7 @@ func TestMarketPredicates(t *testing.T) {
 		ProviderCollateral:   big.Zero(),
 		ClientCollateral:     big.Zero(),
 	}
-	oldProps := map[abi.DealID]*market0.DealProposal{
+	oldProps := map[abi.DealID]*market2.DealProposal{
 		abi.DealID(1): oldProp1,
 		abi.DealID(2): oldProp2,
 	}
@ -127,7 +92,7 @@ func TestMarketPredicates(t *testing.T) {
 	oldStateC := createMarketState(ctx, t, store, oldDeals, oldProps, oldBalances)
-	newDeal1 := &market0.DealState{
+	newDeal1 := &market2.DealState{
 		SectorStartEpoch: 1,
 		LastUpdatedEpoch: 3,
 		SlashEpoch:       0,
@ -136,19 +101,19 @@ func TestMarketPredicates(t *testing.T) {
 	// deal 2 removed
 	// added
-	newDeal3 := &market0.DealState{
+	newDeal3 := &market2.DealState{
 		SectorStartEpoch: 1,
 		LastUpdatedEpoch: 2,
 		SlashEpoch:       3,
 	}
-	newDeals := map[abi.DealID]*market0.DealState{
+	newDeals := map[abi.DealID]*market2.DealState{
 		abi.DealID(1): newDeal1,
 		// deal 2 was removed
 		abi.DealID(3): newDeal3,
 	}
 	// added
-	newProp3 := &market0.DealProposal{
+	newProp3 := &market2.DealProposal{
 		PieceCID:             dummyCid,
 		PieceSize:            0,
 		VerifiedDeal:         false,
@ -160,7 +125,7 @@ func TestMarketPredicates(t *testing.T) {
 		ProviderCollateral:   big.Zero(),
 		ClientCollateral:     big.Zero(),
 	}
-	newProps := map[abi.DealID]*market0.DealProposal{
+	newProps := map[abi.DealID]*market2.DealProposal{
 		abi.DealID(1): oldProp1, // 1 was persisted
 		// prop 2 was removed
 		abi.DealID(3): newProp3, // new
@ -177,14 +142,14 @@ func TestMarketPredicates(t *testing.T) {
 	minerAddr, err := address.NewFromString("t00")
 	require.NoError(t, err)
-	oldState, err := mockTipset(minerAddr, 1)
+	oldState, err := test.MockTipset(minerAddr, 1)
 	require.NoError(t, err)
-	newState, err := mockTipset(minerAddr, 2)
+	newState, err := test.MockTipset(minerAddr, 2)
 	require.NoError(t, err)
-	api := newMockAPI(bs)
+	api := test.NewMockAPI(bs)
-	api.setActor(oldState.Key(), &types.Actor{Code: builtin0.StorageMarketActorCodeID, Head: oldStateC})
+	api.SetActor(oldState.Key(), &types.Actor{Code: builtin2.StorageMarketActorCodeID, Head: oldStateC})
-	api.setActor(newState.Key(), &types.Actor{Code: builtin0.StorageMarketActorCodeID, Head: newStateC})
+	api.SetActor(newState.Key(), &types.Actor{Code: builtin2.StorageMarketActorCodeID, Head: newStateC})
 	t.Run("deal ID predicate", func(t *testing.T) {
 		preds := NewStatePredicates(api)
@ -239,11 +204,11 @@ func TestMarketPredicates(t *testing.T) {
 			t.Fatal("No state change so this should not be called")
 			return false, nil, nil
 		})
-		marketState0 := createEmptyMarketState(t, store)
+		marketState0 := test.CreateEmptyMarketState(t, store)
 		marketCid, err := store.Put(ctx, marketState0)
 		require.NoError(t, err)
 		marketState, err := market.Load(store, &types.Actor{
-			Code: builtin0.StorageMarketActorCodeID,
+			Code: builtin2.StorageMarketActorCodeID,
 			Head: marketCid,
 		})
 		require.NoError(t, err)
@ -352,11 +317,11 @@ func TestMarketPredicates(t *testing.T) {
 			t.Fatal("No state change so this should not be called")
 			return false, nil, nil
 		})
-		marketState0 := createEmptyMarketState(t, store)
+		marketState0 := test.CreateEmptyMarketState(t, store)
 		marketCid, err := store.Put(ctx, marketState0)
 		require.NoError(t, err)
 		marketState, err := market.Load(store, &types.Actor{
-			Code: builtin0.StorageMarketActorCodeID,
+			Code: builtin2.StorageMarketActorCodeID,
 			Head: marketCid,
 		})
 		require.NoError(t, err)
@ -370,7 +335,7 @@ func TestMarketPredicates(t *testing.T) {
 func TestMinerSectorChange(t *testing.T) {
 	ctx := context.Background()
 	bs := bstore.NewTemporarySync()
-	store := adt.WrapStore(ctx, cbornode.NewCborStore(bs))
+	store := adt2.WrapStore(ctx, cbornode.NewCborStore(bs))
 	nextID := uint64(0)
 	nextIDAddrF := func() address.Address {
@ -379,12 +344,12 @@ func TestMinerSectorChange(t *testing.T) {
 	}
 	owner, worker := nextIDAddrF(), nextIDAddrF()
-	si0 := newSectorOnChainInfo(0, tutils.MakeCID("0", &miner0.SealedCIDPrefix), big.NewInt(0), abi.ChainEpoch(0), abi.ChainEpoch(10))
+	si0 := newSectorOnChainInfo(0, tutils.MakeCID("0", &miner2.SealedCIDPrefix), big.NewInt(0), abi.ChainEpoch(0), abi.ChainEpoch(10))
-	si1 := newSectorOnChainInfo(1, tutils.MakeCID("1", &miner0.SealedCIDPrefix), big.NewInt(1), abi.ChainEpoch(1), abi.ChainEpoch(11))
+	si1 := newSectorOnChainInfo(1, tutils.MakeCID("1", &miner2.SealedCIDPrefix), big.NewInt(1), abi.ChainEpoch(1), abi.ChainEpoch(11))
-	si2 := newSectorOnChainInfo(2, tutils.MakeCID("2", &miner0.SealedCIDPrefix), big.NewInt(2), abi.ChainEpoch(2), abi.ChainEpoch(11))
+	si2 := newSectorOnChainInfo(2, tutils.MakeCID("2", &miner2.SealedCIDPrefix), big.NewInt(2), abi.ChainEpoch(2), abi.ChainEpoch(11))
 	oldMinerC := createMinerState(ctx, t, store, owner, worker, []miner.SectorOnChainInfo{si0, si1, si2})
-	si3 := newSectorOnChainInfo(3, tutils.MakeCID("3", &miner0.SealedCIDPrefix), big.NewInt(3), abi.ChainEpoch(3), abi.ChainEpoch(12))
+	si3 := newSectorOnChainInfo(3, tutils.MakeCID("3", &miner2.SealedCIDPrefix), big.NewInt(3), abi.ChainEpoch(3), abi.ChainEpoch(12))
 	// 0 delete
 	// 1 extend
 	// 2 same
@ -394,14 +359,14 @@ func TestMinerSectorChange(t *testing.T) {
 	newMinerC := createMinerState(ctx, t, store, owner, worker, []miner.SectorOnChainInfo{si1Ext, si2, si3})
 	minerAddr := nextIDAddrF()
-	oldState, err := mockTipset(minerAddr, 1)
+	oldState, err := test.MockTipset(minerAddr, 1)
 	require.NoError(t, err)
-	newState, err := mockTipset(minerAddr, 2)
+	newState, err := test.MockTipset(minerAddr, 2)
 	require.NoError(t, err)
-	api := newMockAPI(bs)
+	api := test.NewMockAPI(bs)
-	api.setActor(oldState.Key(), &types.Actor{Head: oldMinerC, Code: builtin0.StorageMinerActorCodeID})
+	api.SetActor(oldState.Key(), &types.Actor{Head: oldMinerC, Code: builtin2.StorageMinerActorCodeID})
-	api.setActor(newState.Key(), &types.Actor{Head: newMinerC, Code: builtin0.StorageMinerActorCodeID})
+	api.SetActor(newState.Key(), &types.Actor{Head: newMinerC, Code: builtin2.StorageMinerActorCodeID})
 	preds := NewStatePredicates(api)
@ -449,29 +414,16 @@ func TestMinerSectorChange(t *testing.T) {
 	require.Equal(t, si1Ext, sectorChanges.Extended[0].From)
 }
 func mockTipset(minerAddr address.Address, timestamp uint64) (*types.TipSet, error) {
 	return types.NewTipSet([]*types.BlockHeader{{
 		Miner:                 minerAddr,
 		Height:                5,
 		ParentStateRoot:       dummyCid,
 		Messages:              dummyCid,
 		ParentMessageReceipts: dummyCid,
 		BlockSig:              &crypto.Signature{Type: crypto.SigTypeBLS},
 		BLSAggregate:          &crypto.Signature{Type: crypto.SigTypeBLS},
 		Timestamp:             timestamp,
 	}})
 }
 type balance struct {
 	available abi.TokenAmount
 	locked    abi.TokenAmount
 }
-func createMarketState(ctx context.Context, t *testing.T, store adt.Store, deals map[abi.DealID]*market0.DealState, props map[abi.DealID]*market0.DealProposal, balances map[address.Address]balance) cid.Cid {
+func createMarketState(ctx context.Context, t *testing.T, store adt2.Store, deals map[abi.DealID]*market2.DealState, props map[abi.DealID]*market2.DealProposal, balances map[address.Address]balance) cid.Cid {
-	dealRootCid := createDealAMT(ctx, t, store, deals)
+	dealRootCid := test.CreateDealAMT(ctx, t, store, deals)
 	propRootCid := createProposalAMT(ctx, t, store, props)
 	balancesCids := createBalanceTable(ctx, t, store, balances)
-	state := createEmptyMarketState(t, store)
+	state := test.CreateEmptyMarketState(t, store)
 	state.States = dealRootCid
 	state.Proposals = propRootCid
 	state.EscrowTable = balancesCids[0]
@ -482,27 +434,8 @@ func createMarketState(ctx context.Context, t *testing.T, store adt.Store, deals
 	return stateC
 }
-func createEmptyMarketState(t *testing.T, store adt.Store) *market0.State {
+func createProposalAMT(ctx context.Context, t *testing.T, store adt2.Store, props map[abi.DealID]*market2.DealProposal) cid.Cid {
-	emptyArrayCid, err := adt.MakeEmptyArray(store).Root()
+	root := adt2.MakeEmptyArray(store)
 	require.NoError(t, err)
 	emptyMap, err := adt.MakeEmptyMap(store).Root()
 	require.NoError(t, err)
 	return market0.ConstructState(emptyArrayCid, emptyMap, emptyMap)
 }
 func createDealAMT(ctx context.Context, t *testing.T, store adt.Store, deals map[abi.DealID]*market0.DealState) cid.Cid {
 	root := adt.MakeEmptyArray(store)
 	for dealID, dealState := range deals {
 		err := root.Set(uint64(dealID), dealState)
 		require.NoError(t, err)
 	}
 	rootCid, err := root.Root()
 	require.NoError(t, err)
 	return rootCid
 }
 func createProposalAMT(ctx context.Context, t *testing.T, store adt.Store, props map[abi.DealID]*market0.DealProposal) cid.Cid {
 	root := adt.MakeEmptyArray(store)
 	for dealID, prop := range props {
 		err := root.Set(uint64(dealID), prop)
 		require.NoError(t, err)
@ -512,16 +445,16 @@ func createProposalAMT(ctx context.Context, t *testing.T, store adt.Store, props
 	return rootCid
 }
-func createBalanceTable(ctx context.Context, t *testing.T, store adt.Store, balances map[address.Address]balance) [2]cid.Cid {
+func createBalanceTable(ctx context.Context, t *testing.T, store adt2.Store, balances map[address.Address]balance) [2]cid.Cid {
-	escrowMapRoot := adt.MakeEmptyMap(store)
+	escrowMapRoot := adt2.MakeEmptyMap(store)
 	escrowMapRootCid, err := escrowMapRoot.Root()
 	require.NoError(t, err)
-	escrowRoot, err := adt.AsBalanceTable(store, escrowMapRootCid)
+	escrowRoot, err := adt2.AsBalanceTable(store, escrowMapRootCid)
 	require.NoError(t, err)
-	lockedMapRoot := adt.MakeEmptyMap(store)
+	lockedMapRoot := adt2.MakeEmptyMap(store)
 	lockedMapRootCid, err := lockedMapRoot.Root()
 	require.NoError(t, err)
-	lockedRoot, err := adt.AsBalanceTable(store, lockedMapRootCid)
+	lockedRoot, err := adt2.AsBalanceTable(store, lockedMapRootCid)
 	require.NoError(t, err)
 	for addr, balance := range balances {
@ -538,7 +471,7 @@ func createBalanceTable(ctx context.Context, t *testing.T, store adt.Store, bala
 	return [2]cid.Cid{escrowRootCid, lockedRootCid}
 }
-func createMinerState(ctx context.Context, t *testing.T, store adt.Store, owner, worker address.Address, sectors []miner.SectorOnChainInfo) cid.Cid {
+func createMinerState(ctx context.Context, t *testing.T, store adt2.Store, owner, worker address.Address, sectors []miner.SectorOnChainInfo) cid.Cid {
 	rootCid := createSectorsAMT(ctx, t, store, sectors)
 	state := createEmptyMinerState(ctx, t, store, owner, worker)
@ -549,20 +482,20 @@ func createMinerState(ctx context.Context, t *testing.T, store adt.Store, owner,
 	return stateC
 }
-func createEmptyMinerState(ctx context.Context, t *testing.T, store adt.Store, owner, worker address.Address) *miner0.State {
+func createEmptyMinerState(ctx context.Context, t *testing.T, store adt2.Store, owner, worker address.Address) *miner2.State {
-	emptyArrayCid, err := adt.MakeEmptyArray(store).Root()
+	emptyArrayCid, err := adt2.MakeEmptyArray(store).Root()
 	require.NoError(t, err)
-	emptyMap, err := adt.MakeEmptyMap(store).Root()
+	emptyMap, err := adt2.MakeEmptyMap(store).Root()
 	require.NoError(t, err)
-	emptyDeadline, err := store.Put(store.Context(), miner0.ConstructDeadline(emptyArrayCid))
+	emptyDeadline, err := store.Put(store.Context(), miner2.ConstructDeadline(emptyArrayCid))
 	require.NoError(t, err)
-	emptyVestingFunds := miner0.ConstructVestingFunds()
+	emptyVestingFunds := miner2.ConstructVestingFunds()
 	emptyVestingFundsCid, err := store.Put(store.Context(), emptyVestingFunds)
 	require.NoError(t, err)
-	emptyDeadlines := miner0.ConstructDeadlines(emptyDeadline)
+	emptyDeadlines := miner2.ConstructDeadlines(emptyDeadline)
 	emptyDeadlinesCid, err := store.Put(store.Context(), emptyDeadlines)
 	require.NoError(t, err)
@ -572,16 +505,30 @@ func createEmptyMinerState(ctx context.Context, t *testing.T, store adt.Store, o
 	emptyBitfieldCid, err := store.Put(store.Context(), emptyBitfield)
 	require.NoError(t, err)
-	state, err := miner0.ConstructState(minerInfo, 123, emptyBitfieldCid, emptyArrayCid, emptyMap, emptyDeadlinesCid, emptyVestingFundsCid)
+	state, err := miner2.ConstructState(minerInfo, 123, 4, emptyBitfieldCid, emptyArrayCid, emptyMap, emptyDeadlinesCid, emptyVestingFundsCid)
 	require.NoError(t, err)
 	return state
 }
-func createSectorsAMT(ctx context.Context, t *testing.T, store adt.Store, sectors []miner.SectorOnChainInfo) cid.Cid {
+func createSectorsAMT(ctx context.Context, t *testing.T, store adt2.Store, sectors []miner.SectorOnChainInfo) cid.Cid {
-	root := adt.MakeEmptyArray(store)
+	root := adt2.MakeEmptyArray(store)
 	for _, sector := range sectors {
-		sector := (miner0.SectorOnChainInfo)(sector)
+		sector := miner2.SectorOnChainInfo{
 			SectorNumber:          sector.SectorNumber,
 			SealProof:             sector.SealProof,
 			SealedCID:             sector.SealedCID,
 			DealIDs:               sector.DealIDs,
 			Activation:            sector.Activation,
 			Expiration:            sector.Expiration,
 			DealWeight:            sector.DealWeight,
 			VerifiedDealWeight:    sector.VerifiedDealWeight,
 			InitialPledge:         sector.InitialPledge,
 			ExpectedDayReward:     sector.ExpectedDayReward,
 			ExpectedStoragePledge: sector.ExpectedStoragePledge,
 			ReplacedSectorAge:     0,
 			ReplacedDayReward:     big.NewInt(0),
 		}
 		err := root.Set(uint64(sector.SectorNumber), &sector)
 		require.NoError(t, err)
 	}
@ -614,8 +561,8 @@ const (
 )
 // returns a unique SectorPreCommitInfo with each invocation with SectorNumber set to `sectorNo`.
-func newSectorPreCommitInfo(sectorNo abi.SectorNumber, sealed cid.Cid, expiration abi.ChainEpoch) *miner0.SectorPreCommitInfo {
+func newSectorPreCommitInfo(sectorNo abi.SectorNumber, sealed cid.Cid, expiration abi.ChainEpoch) *miner2.SectorPreCommitInfo {
-	return &miner0.SectorPreCommitInfo{
+	return &miner2.SectorPreCommitInfo{
 		SealProof:     abi.RegisteredSealProof_StackedDrg32GiBV1,
 		SectorNumber:  sectorNo,
 		SealedCID:     sealed,
@ -625,7 +572,7 @@ func newSectorPreCommitInfo(sectorNo abi.SectorNumber, sealed cid.Cid, expiratio
 	}
 }
-func dealEquality(expected market0.DealState, actual market.DealState) bool {
+func dealEquality(expected market2.DealState, actual market.DealState) bool {
 	return expected.LastUpdatedEpoch == actual.LastUpdatedEpoch &&
 		expected.SectorStartEpoch == actual.SectorStartEpoch &&
 		expected.SlashEpoch == actual.SlashEpoch
--- a/chain/events/tscache.go
+++ b/chain/events/tscache.go
@ -2,6 +2,7 @@ package events
 import (
 	"context"
 	"sync"
 	"github.com/filecoin-project/go-state-types/abi"
 	"golang.org/x/xerrors"
@ -17,6 +18,8 @@ type tsCacheAPI interface {
 // tipSetCache implements a simple ring-buffer cache to keep track of recent
 // tipsets
 type tipSetCache struct {
 	mu sync.RWMutex
 	cache []*types.TipSet
 	start int
 	len   int
@ -35,6 +38,9 @@ func newTSCache(cap abi.ChainEpoch, storage tsCacheAPI) *tipSetCache {
 }
 func (tsc *tipSetCache) add(ts *types.TipSet) error {
 	tsc.mu.Lock()
 	defer tsc.mu.Unlock()
 	if tsc.len > 0 {
 		if tsc.cache[tsc.start].Height() >= ts.Height() {
 			return xerrors.Errorf("tipSetCache.add: expected new tipset height to be at least %d, was %d", tsc.cache[tsc.start].Height()+1, ts.Height())
@ -65,6 +71,13 @@ func (tsc *tipSetCache) add(ts *types.TipSet) error {
 }
 func (tsc *tipSetCache) revert(ts *types.TipSet) error {
 	tsc.mu.Lock()
 	defer tsc.mu.Unlock()
 	return tsc.revertUnlocked(ts)
 }
 func (tsc *tipSetCache) revertUnlocked(ts *types.TipSet) error {
 	if tsc.len == 0 {
 		return nil // this can happen, and it's fine
 	}
@ -77,7 +90,7 @@ func (tsc *tipSetCache) revert(ts *types.TipSet) error {
 	tsc.start = normalModulo(tsc.start-1, len(tsc.cache))
 	tsc.len--
-	_ = tsc.revert(nil) // revert null block gap
+	_ = tsc.revertUnlocked(nil) // revert null block gap
 	return nil
 }
@ -95,7 +108,10 @@ func (tsc *tipSetCache) getNonNull(height abi.ChainEpoch) (*types.TipSet, error)
 }
 func (tsc *tipSetCache) get(height abi.ChainEpoch) (*types.TipSet, error) {
 	tsc.mu.RLock()
 	if tsc.len == 0 {
 		tsc.mu.RUnlock()
 		log.Warnf("tipSetCache.get: cache is empty, requesting from storage (h=%d)", height)
 		return tsc.storage.ChainGetTipSetByHeight(context.TODO(), height, types.EmptyTSK)
 	}
@ -103,6 +119,7 @@ func (tsc *tipSetCache) get(height abi.ChainEpoch) (*types.TipSet, error) {
 	headH := tsc.cache[tsc.start].Height()
 	if height > headH {
 		tsc.mu.RUnlock()
 		return nil, xerrors.Errorf("tipSetCache.get: requested tipset not in cache (req: %d, cache head: %d)", height, headH)
 	}
@ -116,15 +133,20 @@ func (tsc *tipSetCache) get(height abi.ChainEpoch) (*types.TipSet, error) {
 	}
 	if height < tail.Height() {
 		tsc.mu.RUnlock()
 		log.Warnf("tipSetCache.get: requested tipset not in cache, requesting from storage (h=%d; tail=%d)", height, tail.Height())
 		return tsc.storage.ChainGetTipSetByHeight(context.TODO(), height, tail.Key())
 	}
-	return tsc.cache[normalModulo(tsc.start-int(headH-height), clen)], nil
+	ts := tsc.cache[normalModulo(tsc.start-int(headH-height), clen)]
 	tsc.mu.RUnlock()
 	return ts, nil
 }
 func (tsc *tipSetCache) best() (*types.TipSet, error) {
 	tsc.mu.RLock()
 	best := tsc.cache[tsc.start]
 	tsc.mu.RUnlock()
 	if best == nil {
 		return tsc.storage.ChainHead(context.TODO())
 	}
--- a/chain/events/utils.go
+++ b/chain/events/utils.go
@ -34,11 +34,11 @@ func (me *messageEvents) CheckMsg(ctx context.Context, smsg types.ChainMsg, hnd
 }
 func (me *messageEvents) MatchMsg(inmsg *types.Message) MsgMatchFunc {
-	return func(msg *types.Message) (matchOnce bool, matched bool, err error) {
+	return func(msg *types.Message) (matched bool, err error) {
 		if msg.From == inmsg.From && msg.Nonce == inmsg.Nonce && !inmsg.Equals(msg) {
-			return true, false, xerrors.Errorf("matching msg %s from %s, nonce %d: got duplicate origin/nonce msg %d", inmsg.Cid(), inmsg.From, inmsg.Nonce, msg.Nonce)
+			return false, xerrors.Errorf("matching msg %s from %s, nonce %d: got duplicate origin/nonce msg %d", inmsg.Cid(), inmsg.From, inmsg.Nonce, msg.Nonce)
 		}
-		return true, inmsg.Equals(msg), nil
+		return inmsg.Equals(msg), nil
 	}
 }
--- a/chain/exchange/client.go
+++ b/chain/exchange/client.go
@ -7,7 +7,6 @@ import (
 	"math/rand"
 	"time"
 	"github.com/libp2p/go-libp2p-core/helpers"
 	"github.com/libp2p/go-libp2p-core/host"
 	"github.com/libp2p/go-libp2p-core/network"
 	"github.com/libp2p/go-libp2p-core/peer"
@ -117,7 +116,7 @@ func (c *client) doRequest(
 		res, err := c.sendRequestToPeer(ctx, peer, req)
 		if err != nil {
 			if !xerrors.Is(err, network.ErrNoConn) {
-				log.Warnf("could not connect to peer %s: %s",
+				log.Warnf("could not send request to peer %s: %s",
 					peer.String(), err)
 			}
 			continue
@ -412,11 +411,7 @@ func (c *client) sendRequestToPeer(ctx context.Context, peer peer.ID, req *Reque
 		return nil, xerrors.Errorf("failed to open stream to peer: %w", err)
 	}
-	defer func() {
+	defer stream.Close() //nolint:errcheck
 		// Note: this will become just stream.Close once we've completed the go-libp2p migration to
 		//       go-libp2p-core 0.7.0
 		go helpers.FullClose(stream) //nolint:errcheck
 	}()
 	// Write request.
 	_ = stream.SetWriteDeadline(time.Now().Add(WriteReqDeadline))
--- a/chain/exchange/peer_tracker.go
+++ b/chain/exchange/peer_tracker.go
@ -38,20 +38,26 @@ func newPeerTracker(lc fx.Lifecycle, h host.Host, pmgr *peermgr.PeerMgr) *bsPeer
 		pmgr:  pmgr,
 	}
-	sub, err := h.EventBus().Subscribe(new(peermgr.NewFilPeer))
+	evtSub, err := h.EventBus().Subscribe(new(peermgr.FilPeerEvt))
 	if err != nil {
 		panic(err)
 	}
 	go func() {
-		for newPeer := range sub.Out() {
+		for evt := range evtSub.Out() {
-			bsPt.addPeer(newPeer.(peermgr.NewFilPeer).Id)
+			pEvt := evt.(peermgr.FilPeerEvt)
 			switch pEvt.Type {
 			case peermgr.AddFilPeerEvt:
 				bsPt.addPeer(pEvt.ID)
 			case peermgr.RemoveFilPeerEvt:
 				bsPt.removePeer(pEvt.ID)
 			}
 		}
 	}()
 	lc.Append(fx.Hook{
 		OnStop: func(ctx context.Context) error {
-			return sub.Close()
+			return evtSub.Close()
 		},
 	})
--- a/Show More
+++ b/Show More