Merge branch 'master' into ntwk-calibration

New calibration genesis
New calibration network info
2020-11-13 19:01:44 -05:00 · 2020-11-07 21:34:59 -05:00 · 2020-11-07 21:34:59 -05:00
386 changed files with 4405 additions and 31242 deletions
@@ -1,12 +1,11 @@
 version: 2.1
 orbs:
  go: gotest/tools@0.0.13
-  aws-cli: circleci/aws-cli@1.3.2

 executors:
  golang:
    docker:
-      - image: circleci/golang:1.15.5
+      - image: circleci/golang:1.14.6
    resource_class: 2xlarge
  ubuntu:
    docker:
@@ -201,10 +200,6 @@ jobs:
    <<: *test
  test-window-post:
    <<: *test
-  test-window-post-dispute:
-    <<: *test
-  test-terminate:
-    <<: *test
  test-conformance:
    description: |
      Run tests using a corpus of interoperable test vectors for Filecoin 
@@ -267,56 +262,24 @@ jobs:
          path: /tmp/test-reports
      - store_artifacts:
          path: /tmp/test-artifacts/conformance-coverage.html
-  build-ntwk-calibration:
-    description: |
-      Compile lotus binaries for the calibration network
-    parameters:
-      <<: *test-params
-    executor: << parameters.executor >>
-    steps:
-      - install-deps
-      - prepare
-      - run: make calibnet
  build-lotus-soup:
    description: |
-      Compile `lotus-soup` Testground test plan
+      Compile `lotus-soup` Testground test plan using the current version of Lotus.
    parameters:
      <<: *test-params
    executor: << parameters.executor >>
    steps:
      - install-deps
      - prepare
+      - run: cd extern/oni && git submodule sync
+      - run: cd extern/oni && git submodule update --init
      - run: cd extern/filecoin-ffi && make
+      - run:
+          name: "replace lotus, filecoin-ffi, blst and fil-blst deps"
+          command: cd extern/oni/lotus-soup && go mod edit -replace github.com/filecoin-project/lotus=../../../ && go mod edit -replace github.com/filecoin-project/filecoin-ffi=../../filecoin-ffi && go mod edit -replace github.com/supranational/blst=../../blst
      - run:
          name: "build lotus-soup testplan"
-          command: pushd testplans/lotus-soup && go build -tags=testground .
-  trigger-testplans:
-    description: |
-      Trigger `lotus-soup` test cases on TaaS
-    parameters:
-      <<: *test-params
-    executor: << parameters.executor >>
-    steps:
-      - install-deps
-      - prepare
-      - run:
-          name: "download testground"
-          command: wget https://gist.github.com/nonsense/5fbf3167cac79945f658771aed32fc44/raw/2e17eb0debf7ec6bdf027c1bdafc2c92dd97273b/testground-d3e9603 -O ~/testground-cli && chmod +x ~/testground-cli
-      - run:
-          name: "prepare .env.toml"
-          command: pushd testplans/lotus-soup && mkdir -p $HOME/testground && cp env-ci.toml $HOME/testground/.env.toml && echo 'endpoint="https://ci.testground.ipfs.team"' >> $HOME/testground/.env.toml && echo 'user="circleci"' >> $HOME/testground/.env.toml
-      - run:
-          name: "prepare testground home dir"
-          command: mkdir -p $HOME/testground/plans && mv testplans/lotus-soup testplans/graphsync $HOME/testground/plans/
-      - run:
-          name: "trigger deals baseline testplan on taas"
-          command: ~/testground-cli run composition -f $HOME/testground/plans/lotus-soup/_compositions/baseline-k8s-3-1.toml --metadata-commit=$CIRCLE_SHA1 --metadata-repo=filecoin-project/lotus --metadata-branch=$CIRCLE_BRANCH
-      - run:
-          name: "trigger payment channel stress testplan on taas"
-          command: ~/testground-cli run composition -f $HOME/testground/plans/lotus-soup/_compositions/paych-stress-k8s.toml --metadata-commit=$CIRCLE_SHA1 --metadata-repo=filecoin-project/lotus --metadata-branch=$CIRCLE_BRANCH
-      - run:
-          name: "trigger graphsync testplan on taas"
-          command: ~/testground-cli run composition -f $HOME/testground/plans/graphsync/_compositions/stress-k8s.toml --metadata-commit=$CIRCLE_SHA1 --metadata-repo=filecoin-project/lotus --metadata-branch=$CIRCLE_BRANCH
+          command: pushd extern/oni/lotus-soup && go build -tags=testground .


  build-macos:
@@ -331,8 +294,8 @@ jobs:
      - run:
          name: Install go
          command: |
-            curl -O https://dl.google.com/go/go1.15.5.darwin-amd64.pkg && \
-            sudo installer -pkg go1.15.5.darwin-amd64.pkg -target /
+            curl -O https://dl.google.com/go/go1.14.2.darwin-amd64.pkg && \
+            sudo installer -pkg go1.14.2.darwin-amd64.pkg -target /
      - run:
          name: Install pkg-config
          command: HOMEBREW_NO_AUTO_UPDATE=1 brew install pkg-config
@@ -460,114 +423,6 @@ jobs:
          name: Publish release
          command: ./scripts/publish-release.sh

-  build-and-push-image:
-    description: build and push docker images to public AWS ECR registry
-    executor: aws-cli/default
-    parameters:
-      profile-name:
-        type: string
-        default: "default"
-        description: AWS profile name to be configured.
-
-      aws-access-key-id:
-        type: env_var_name
-        default: AWS_ACCESS_KEY_ID
-        description: >
-          AWS access key id for IAM role. Set this to the name of
-          the environment variable you will set to hold this
-          value, i.e. AWS_ACCESS_KEY.
-
-      aws-secret-access-key:
-        type: env_var_name
-        default: AWS_SECRET_ACCESS_KEY
-        description: >
-          AWS secret key for IAM role. Set this to the name of
-          the environment variable you will set to hold this
-          value, i.e. AWS_SECRET_ACCESS_KEY.
-
-      region:
-        type: env_var_name
-        default: AWS_REGION
-        description: >
-          Name of env var storing your AWS region information,
-          defaults to AWS_REGION
-
-      account-url:
-        type: env_var_name
-        default: AWS_ECR_ACCOUNT_URL
-        description: >
-          Env var storing Amazon ECR account URL that maps to an AWS account,
-          e.g. {awsAccountNum}.dkr.ecr.us-west-2.amazonaws.com
-          defaults to AWS_ECR_ACCOUNT_URL
-
-      dockerfile:
-        type: string
-        default: Dockerfile
-        description: Name of dockerfile to use. Defaults to Dockerfile.
-
-      path:
-        type: string
-        default: .
-        description: Path to the directory containing your Dockerfile and build context. Defaults to . (working directory).
-
-      extra-build-args:
-        type: string
-        default: ""
-        description: >
-          Extra flags to pass to docker build. For examples, see
-          https://docs.docker.com/engine/reference/commandline/build
-
-      repo:
-        type: string
-        description: Name of an Amazon ECR repository
-
-      tag:
-        type: string
-        default: "latest"
-        description: A comma-separated string containing docker image tags to build and push (default = latest)
-
-    steps:
-      - aws-cli/setup:
-          profile-name: <<parameters.profile-name>>
-          aws-access-key-id: <<parameters.aws-access-key-id>>
-          aws-secret-access-key: <<parameters.aws-secret-access-key>>
-          aws-region: <<parameters.region>>
-
-      - run:
-          name: Log into Amazon ECR
-          command: |
-            aws ecr-public get-login-password --region $<<parameters.region>> --profile <<parameters.profile-name>> | docker login --username AWS --password-stdin $<<parameters.account-url>>
-
-      - checkout
-
-      - setup_remote_docker:
-          version: 19.03.13
-          docker_layer_caching: false
-
-      - run:
-          name: Build docker image
-          command: |
-            registry_id=$(echo $<<parameters.account-url>> | sed "s;\..*;;g")
-
-            docker_tag_args=""
-            IFS="," read -ra DOCKER_TAGS \<<< "<< parameters.tag >>"
-            for tag in "${DOCKER_TAGS[@]}"; do
-              docker_tag_args="$docker_tag_args -t $<<parameters.account-url>>/<<parameters.repo>>:$tag"
-            done
-
-            docker build \
-              <<#parameters.extra-build-args>><<parameters.extra-build-args>><</parameters.extra-build-args>> \
-              -f <<parameters.path>>/<<parameters.dockerfile>> \
-              $docker_tag_args \
-              <<parameters.path>>
-
-      - run:
-          name: Push image to Amazon ECR
-          command: |
-            IFS="," read -ra DOCKER_TAGS \<<< "<< parameters.tag >>"
-            for tag in "${DOCKER_TAGS[@]}"; do
-              docker push $<<parameters.account-url>>/<<parameters.repo>>:${tag}
-            done

 workflows:
  version: 2.1
@@ -599,20 +454,9 @@ workflows:
          test-suite-name: cli
          packages: "./cli/... ./cmd/... ./api/..."
      - test-window-post:
-          codecov-upload: true
          go-test-flags: "-run=TestWindowedPost"
          winpost-test: "1"
          test-suite-name: window-post
-      - test-window-post-dispute:
-          codecov-upload: true
-          go-test-flags: "-run=TestWindowPostDispute"
-          winpost-test: "1"
-          test-suite-name: window-post-dispute
-      - test-terminate:
-          codecov-upload: true
-          go-test-flags: "-run=TestTerminate"
-          winpost-test: "1"
-          test-suite-name: terminate
      - test-short:
          go-test-flags: "--timeout 10m --short"
          test-suite-name: short
@@ -628,13 +472,7 @@ workflows:
          test-suite-name: conformance-bleeding-edge
          packages: "./conformance"
          vectors-branch: master
-      - build-ntwk-calibration
      - build-lotus-soup
-      - trigger-testplans:
-          filters:
-            branches:
-              only:
-                - master
      - build-debug
      - build-all:
          requires:
@@ -664,8 +502,3 @@ workflows:
            tags:
              only:
                - /^v\d+\.\d+\.\d+$/
-      - build-and-push-image:
-          dockerfile: Dockerfile.lotus
-          path: .
-          repo: lotus-dev
-          tag: '${CIRCLE_SHA1:0:8}'
@@ -5,15 +5,5 @@ ignore:
  - "api/test/*"
  - "gen/**/*"
  - "gen/*"
-  - "cmd/lotus-shed/*"
-  - "cmd/tvx/*"
-  - "cmd/lotus-pcr/*"
-  - "cmd/tvx/*"
-  - "cmd/lotus-chainwatch/*"
-  - "cmd/lotus-health/*"
-  - "cmd/lotus-fountain/*"
-  - "cmd/lotus-townhall/*"
-  - "cmd/lotus-stats/*"
-  - "cmd/lotus-pcr/*"
 github_checks:
  annotations: false
@@ -13,7 +13,6 @@
 /lotus-gateway
 /lotus-pcr
 /lotus-wallet
-/lotus-keygen
 /bench.json
 /lotuspond/front/node_modules
 /lotuspond/front/build
@@ -7,3 +7,9 @@
 [submodule "extern/test-vectors"]
 	path = extern/test-vectors
 	url = https://github.com/filecoin-project/test-vectors.git
+[submodule "extern/oni"]
+	path = extern/oni
+	url = https://github.com/filecoin-project/oni.git
+[submodule "extern/blst"]
+	path = extern/blst
+	url = https://github.com/supranational/blst.git
@@ -1,250 +1,5 @@
 # Lotus changelog

-# 1.4.1 / 2021-01-20
-
-This is an optional Lotus release that introduces various improvements to the sealing, mining, and deal-making processes. In particular, [#5341](https://github.com/filecoin-project/lotus/pull/5341) introduces the ability for Lotus miners to terminate sectors.
-
-## Changes
-
-#### Core Lotus
-
- fix(sync): enforce ForkLengthThreshold for synced chain (https://github.com/filecoin-project/lotus/pull/5182)
- introduce memory watchdog; LOTUS_MAX_HEAP (https://github.com/filecoin-project/lotus/pull/5101)
- Skip bootstrapping if no peers specified (https://github.com/filecoin-project/lotus/pull/5301)
- Chainxchg write response timeout (https://github.com/filecoin-project/lotus/pull/5254)
- update NewestNetworkVersion (https://github.com/filecoin-project/lotus/pull/5277)
- fix(sync): remove checks bypass when we submit the block (https://github.com/filecoin-project/lotus/pull/4192)
- chore: export vm.ShouldBurn (https://github.com/filecoin-project/lotus/pull/5355)
- fix(sync): enforce fork len when changing head (https://github.com/filecoin-project/lotus/pull/5244)
- Use 55th percentile instead of median for gas-price (https://github.com/filecoin-project/lotus/pull/5369)
- update go-libp2p-pubsub to v0.4.1 (https://github.com/filecoin-project/lotus/pull/5329)
-
-#### Sealing
-
- Sector termination support (https://github.com/filecoin-project/lotus/pull/5341)
- update weight canSeal and canStore when attach (https://github.com/filecoin-project/lotus/pull/5242/files)
- sector-storage/mock: improve mocked readpiece (https://github.com/filecoin-project/lotus/pull/5208)
- Fix deadlock in runWorker in sched_worker.go (https://github.com/filecoin-project/lotus/pull/5251)
- Skip checking terminated sectors provable (https://github.com/filecoin-project/lotus/pull/5217)
- storagefsm: Fix unsealedInfoMap.lk init race (https://github.com/filecoin-project/lotus/pull/5319)
- Multicore AddPiece CommP (https://github.com/filecoin-project/lotus/pull/5320)
- storagefsm: Send correct event on ErrExpiredTicket in CommitFailed (https://github.com/filecoin-project/lotus/pull/5366)
- expose StateSearchMessage on gateway (https://github.com/filecoin-project/lotus/pull/5382)
- fix FileSize to return correct disk usage recursively (https://github.com/filecoin-project/lotus/pull/5384)
-
-#### Dealmaking
-
- Better error message when withdrawing funds (https://github.com/filecoin-project/lotus/pull/5293)
- add verbose for list transfers (https://github.com/filecoin-project/lotus/pull/5259)
- cli - rename `client info` to `client balances` (https://github.com/filecoin-project/lotus/pull/5304)
- Better CLI for wallet market withdraw and client info (https://github.com/filecoin-project/lotus/pull/5303)
-
-#### UX
-
- correct flag usages for replace cmd (https://github.com/filecoin-project/lotus/pull/5255)
- lotus state call will panic (https://github.com/filecoin-project/lotus/pull/5275)
- fix get sector bug (https://github.com/filecoin-project/lotus/pull/4976)
- feat: lotus wallet market add (adds funds to storage market actor) (https://github.com/filecoin-project/lotus/pull/5300)
- Fix client flag parsing in client balances cli (https://github.com/filecoin-project/lotus/pull/5312)
- delete slash-consensus miner (https://github.com/filecoin-project/lotus/pull/4577)
- add fund sufficient check in send (https://github.com/filecoin-project/lotus/pull/5252)
- enable parse and shorten negative FIL values (https://github.com/filecoin-project/lotus/pull/5315)
- add limit and rate for chain noise (https://github.com/filecoin-project/lotus/pull/5223)
- add bench env print (https://github.com/filecoin-project/lotus/pull/5222)
- Implement full-node restore option (https://github.com/filecoin-project/lotus/pull/5362)
- add color for token amount (https://github.com/filecoin-project/lotus/pull/5352)
- correct log in maybeUseAddress (https://github.com/filecoin-project/lotus/pull/5359)
- add slash-consensus from flag (https://github.com/filecoin-project/lotus/pull/5378)
-
-#### Testing
-
- tvx extract: more tipset extraction goodness (https://github.com/filecoin-project/lotus/pull/5258)
- Fix race in blockstore test suite (https://github.com/filecoin-project/lotus/pull/5297)
-
-
-#### Build & Networks
-
- Remove LOTUS_DISABLE_V2_ACTOR_MIGRATION envvar (https://github.com/filecoin-project/lotus/pull/5289)
- Create a calibnet build option (https://github.com/filecoin-project/lotus/pull/5288)
- Calibnet: Set Orange epoch (https://github.com/filecoin-project/lotus/pull/5325)
-
-#### Management
-
- Update SECURITY.md (https://github.com/filecoin-project/lotus/pull/5246)
- README: Contribute section (https://github.com/filecoin-project/lotus/pull/5330)
- README: refine Contribute section (https://github.com/filecoin-project/lotus/pull/5331)
- Add misc tooling to codecov ignore list (https://github.com/filecoin-project/lotus/pull/5347)
-
-# 1.4.0 / 2020-12-19
-
-This is a MANDATORY hotfix release of Lotus that resolves a chain halt at height 336,459 caused by nondeterminism in specs-actors. The fix is to update actors to 2.3.3 in order to incorporate this fix https://github.com/filecoin-project/specs-actors/pull/1334.
-
-# 1.3.0 / 2020-12-16
-
-This is a mandatory release of Lotus that introduces the third post-liftoff upgrade to the Filecoin network. The network upgrade occurs at height 343200, before which time all nodes must have updated to this release (or later). The change that breaks consensus is an implementation of FIP-0009(https://github.com/filecoin-project/FIPs/blob/master/FIPS/fip-0009.md).
-
-## Changes
-
- Disable gas burning for window post messages (https://github.com/filecoin-project/lotus/pull/5200)
- fix lock propose (https://github.com/filecoin-project/lotus/pull/5197)
-
-# 1.2.3 / 2020-12-15
-
-This is an optional Lotus release that introduces many performance improvements, bugfixes, and UX improvements.
-
-## Changes
-
- When waiting for deal commit messages, ignore unsuccessful messages (https://github.com/filecoin-project/lotus/pull/5189)
- Bigger copy buffer size for stores (https://github.com/filecoin-project/lotus/pull/5177)
- Print MinPieceSize when querying ask (https://github.com/filecoin-project/lotus/pull/5178)
- Optimize miner info & sectors list loading (https://github.com/filecoin-project/lotus/pull/5176)
- Allow miners to filter (un)verified deals (https://github.com/filecoin-project/lotus/pull/5094)
- Fix curSealing out of MaxSealingSectors limit (https://github.com/filecoin-project/lotus/pull/5166)
- Add mpool pending from / to filter (https://github.com/filecoin-project/lotus/pull/5169)
- Add metrics for delayed blocks (https://github.com/filecoin-project/lotus/pull/5171)
- Fix PushUntrusted publishing -- the message is local (https://github.com/filecoin-project/lotus/pull/5173)
- Avoid potential hang in events API when starting event listener (https://github.com/filecoin-project/lotus/pull/5159)
- Show data transfer ID in list-deals (https://github.com/filecoin-project/lotus/pull/5150)
- Fix events API mutex locking (https://github.com/filecoin-project/lotus/pull/5160)
- Message pool refactors (https://github.com/filecoin-project/lotus/pull/5162)
- Fix lotus-shed cid output (https://github.com/filecoin-project/lotus/pull/5072)
- Use FundManager to withdraw funds, add MarketWithdraw API (https://github.com/filecoin-project/lotus/pull/5112)
- Add keygen outfile (https://github.com/filecoin-project/lotus/pull/5118)
- Update sr2 stat aggregation (https://github.com/filecoin-project/lotus/pull/5114)
- Fix miner control address lookup (https://github.com/filecoin-project/lotus/pull/5119)
- Fix send with declared nonce 0 (https://github.com/filecoin-project/lotus/pull/5111)
- Introduce memory watchdog; LOTUS_MAX_HEAP (https://github.com/filecoin-project/lotus/pull/5101)
- Miner control address config for (pre)commits (https://github.com/filecoin-project/lotus/pull/5103)
- Delete repeated call func (https://github.com/filecoin-project/lotus/pull/5099)
- lotus-shed ledger show command (https://github.com/filecoin-project/lotus/pull/5098)
- Log a message when there aren't enough peers for sync (https://github.com/filecoin-project/lotus/pull/5105)
- Miner code cleanup (https://github.com/filecoin-project/lotus/pull/5107)
-
-# 1.2.2 / 2020-12-03
-
-This is an optional Lotus release that introduces various improvements to the mining logic and deal-making workflow, as well as several new UX features.
-
-## Changes
-
- Set lower feecap on PoSt messages with low balance (https://github.com/filecoin-project/lotus/pull/4217)
- Add options to set BlockProfileRate and MutexProfileFraction (https://github.com/filecoin-project/lotus/pull/4140)
- Shed/post find (https://github.com/filecoin-project/lotus/pull/4355)
- tvx extract: make it work with secp messages.(https://github.com/filecoin-project/lotus/pull/4583)
- update go from 1.14 to 1.15 (https://github.com/filecoin-project/lotus/pull/4909)
- print multiple blocks from miner cid (https://github.com/filecoin-project/lotus/pull/4767)
- Connection Gater support (https://github.com/filecoin-project/lotus/pull/4849)
- just return storedask.NewStoredAsk to reduce unuseful code (https://github.com/filecoin-project/lotus/pull/4902)
- add go main version (https://github.com/filecoin-project/lotus/pull/4910)
- Use version0 when pre-sealing (https://github.com/filecoin-project/lotus/pull/4911)
- optimize code UpgradeTapeHeight and go fmt (https://github.com/filecoin-project/lotus/pull/4913)
- CLI to get network version (https://github.com/filecoin-project/lotus/pull/4914)
- Improve error for ActorsVersionPredicate (https://github.com/filecoin-project/lotus/pull/4915)
- upgrade to go-fil-markets 1.0.5 (https://github.com/filecoin-project/lotus/pull/4916)
- bug:replace with func recordFailure (https://github.com/filecoin-project/lotus/pull/4919)
- Remove unused key (https://github.com/filecoin-project/lotus/pull/4924)
- change typeV7 make len (https://github.com/filecoin-project/lotus/pull/4943)
- emit events for peer disconnections and act upon them in the blocksync tracker (https://github.com/filecoin-project/lotus/pull/4754)
- Fix lotus bench error (https://github.com/filecoin-project/lotus/pull/4305)
- Reduce badger ValueTreshold to 128 (https://github.com/filecoin-project/lotus/pull/4629)
- Downgrade duplicate nonce logs to debug (https://github.com/filecoin-project/lotus/pull/4933)
- readme update golang version from 1.14.7 to 1.15.5 (https://github.com/filecoin-project/lotus/pull/4974)
- add data transfer logging (https://github.com/filecoin-project/lotus/pull/4975)
- Remove all temp file generation for deals (https://github.com/filecoin-project/lotus/pull/4929)
- fix get sector bug (https://github.com/filecoin-project/lotus/pull/4976)
- fix nil pointer in StateSectorPreCommitInfo (https://github.com/filecoin-project/lotus/pull/4082)
- Add logging on data-transfer to miner (https://github.com/filecoin-project/lotus/pull/4980)
- bugfix: fixup devnet script (https://github.com/filecoin-project/lotus/pull/4956)
- modify for unsafe (https://github.com/filecoin-project/lotus/pull/4024)
- move testground/lotus-soup testplan from oni to lotus (https://github.com/filecoin-project/lotus/pull/4727)
- Setup remainder msig signers when parsing genesis template (https://github.com/filecoin-project/lotus/pull/4904)
- Update JSON RPC server to enforce a maximum request size (https://github.com/filecoin-project/lotus/pull/4923)
- New SR-specific lotus-shed cmd (https://github.com/filecoin-project/lotus/pull/4971)
- update index to sectorNumber (https://github.com/filecoin-project/lotus/pull/4987)
- storagefsm: Fix expired ticket retry loop (https://github.com/filecoin-project/lotus/pull/4876)
- add .sec scale to measurements; humanize for metric tags (https://github.com/filecoin-project/lotus/pull/4989)
- Support seal proof type switching (https://github.com/filecoin-project/lotus/pull/4873)
- fix log format (https://github.com/filecoin-project/lotus/pull/4984)
- Format workerID as string (https://github.com/filecoin-project/lotus/pull/4973)
- miner: Winning PoSt Warmup (https://github.com/filecoin-project/lotus/pull/4824)
- Default StartDealParams's fast retrieval field to true over JSON (https://github.com/filecoin-project/lotus/pull/4998)
- Fix actor not found in chain inspect-usage (https://github.com/filecoin-project/lotus/pull/5010)
- storagefsm: Improve new deal sector logic (https://github.com/filecoin-project/lotus/pull/5007)
- Configure simultaneous requests (https://github.com/filecoin-project/lotus/pull/4996)
- miner: log winningPoSt duration separately (https://github.com/filecoin-project/lotus/pull/5005)
- fix wallet dead lock (https://github.com/filecoin-project/lotus/pull/5002)
- Update go-jsonrpc to v0.1.2 (https://github.com/filecoin-project/lotus/pull/5015)
- markets - separate watching for pre-commit from prove-commit (https://github.com/filecoin-project/lotus/pull/4945)
- storagefsm: Add missing planners (https://github.com/filecoin-project/lotus/pull/5016)
- fix wallet delete address where address is default (https://github.com/filecoin-project/lotus/pull/5019)
- worker: More robust remote checks (https://github.com/filecoin-project/lotus/pull/5008)
- Add new booststrappers (https://github.com/filecoin-project/lotus/pull/4007)
- add a tooling to make filecoin accounting a little easier (https://github.com/filecoin-project/lotus/pull/5025)
- fix: start a new line in print miner-info to avoid ambiguous display (https://github.com/filecoin-project/lotus/pull/5029)
- Print gas limit sum in mpool stat (https://github.com/filecoin-project/lotus/pull/5035)
- Fix chainstore tipset leak (https://github.com/filecoin-project/lotus/pull/5037)
- shed rpc: Allow calling with args (https://github.com/filecoin-project/lotus/pull/5036)
- Make --gas-limit optional in mpool replace cli (https://github.com/filecoin-project/lotus/pull/5059)
- client list-asks --by-ping (https://github.com/filecoin-project/lotus/pull/5060)
- Ledger signature verification (https://github.com/filecoin-project/lotus/pull/5068)
- Fix helptext for verified-deal default in client deal (https://github.com/filecoin-project/lotus/pull/5074)
- worker: Support setting task types at runtime (https://github.com/filecoin-project/lotus/pull/5023)
- Enable Callers tracing when GasTracing is enabled (https://github.com/filecoin-project/lotus/pull/5080)
- Cancel transfer cancels storage deal (https://github.com/filecoin-project/lotus/pull/5032)
- Sector check command (https://github.com/filecoin-project/lotus/pull/5041)
- add commp-to-cid base64 decode (https://github.com/filecoin-project/lotus/pull/5079)
- miner info cli improvements (https://github.com/filecoin-project/lotus/pull/5083)
- miner: Add slow mode to proving check (https://github.com/filecoin-project/lotus/pull/5086)
- Error out deals that are not activated by proposed deal start epoch (https://github.com/filecoin-project/lotus/pull/5061)
-
-# 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 updated 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.
@@ -1,74 +0,0 @@
-FROM golang:1.15.6 AS builder-deps
-MAINTAINER Lotus Development Team
-
-RUN apt-get update && apt-get install -y ca-certificates build-essential clang ocl-icd-opencl-dev ocl-icd-libopencl1 jq libhwloc-dev
-
-ARG RUST_VERSION=nightly
-ENV XDG_CACHE_HOME="/tmp"
-
-ENV RUSTUP_HOME=/usr/local/rustup \
-    CARGO_HOME=/usr/local/cargo \
-    PATH=/usr/local/cargo/bin:$PATH
-
-RUN wget "https://static.rust-lang.org/rustup/dist/x86_64-unknown-linux-gnu/rustup-init"; \
-    chmod +x rustup-init; \
-    ./rustup-init -y --no-modify-path --profile minimal --default-toolchain $RUST_VERSION; \
-    rm rustup-init; \
-    chmod -R a+w $RUSTUP_HOME $CARGO_HOME; \
-    rustup --version; \
-    cargo --version; \
-    rustc --version;
-
-
-FROM builder-deps AS builder-local
-MAINTAINER Lotus Development Team
-
-COPY ./ /opt/filecoin
-WORKDIR /opt/filecoin
-RUN make clean deps
-
-
-FROM builder-local AS builder
-MAINTAINER Lotus Development Team
-
-WORKDIR /opt/filecoin
-
-ARG RUSTFLAGS=""
-ARG GOFLAGS=""
-
-RUN make deps lotus lotus-miner lotus-worker lotus-shed lotus-chainwatch lotus-stats
-
-
-FROM ubuntu:20.04 AS base
-MAINTAINER Lotus Development Team
-
-# Base resources
-COPY --from=builder /etc/ssl/certs                           /etc/ssl/certs
-COPY --from=builder /lib/x86_64-linux-gnu/libdl.so.2         /lib/
-COPY --from=builder /lib/x86_64-linux-gnu/librt.so.1         /lib/
-COPY --from=builder /lib/x86_64-linux-gnu/libgcc_s.so.1      /lib/
-COPY --from=builder /lib/x86_64-linux-gnu/libutil.so.1       /lib/
-COPY --from=builder /usr/lib/x86_64-linux-gnu/libltdl.so.7   /lib/
-COPY --from=builder /usr/lib/x86_64-linux-gnu/libnuma.so.1   /lib/
-COPY --from=builder /usr/lib/x86_64-linux-gnu/libhwloc.so.5  /lib/
-COPY --from=builder /usr/lib/x86_64-linux-gnu/libOpenCL.so.1 /lib/
-
-RUN useradd -r -u 532 -U fc
-
-
-FROM base AS lotus
-MAINTAINER Lotus Development Team
-
-COPY --from=builder /opt/filecoin/lotus      /usr/local/bin/
-COPY --from=builder /opt/filecoin/lotus-shed /usr/local/bin/
-
-ENV FILECOIN_PARAMETER_CACHE /var/tmp/filecoin-proof-parameters
-ENV LOTUS_PATH /var/lib/lotus
-
-RUN mkdir /var/lib/lotus /var/tmp/filecoin-proof-parameters && chown fc /var/lib/lotus /var/tmp/filecoin-proof-parameters
-
-USER fc
-
-ENTRYPOINT ["/usr/local/bin/lotus"]
-
-CMD ["-help"]
@@ -5,10 +5,10 @@ all: build

 unexport GOFLAGS

-GOVERSION:=$(shell go version | cut -d' ' -f 3 | sed 's/^go//' | awk -F. '{printf "%d%03d%03d", $$1, $$2, $$3}')
-ifeq ($(shell expr $(GOVERSION) \< 1015005), 1)
-$(warning Your Golang version is go$(shell expr $(GOVERSION) / 1000000).$(shell expr $(GOVERSION) % 1000000 / 1000).$(shell expr $(GOVERSION) % 1000))
-$(error Update Golang to version to at least 1.15.5)
+GOVERSION:=$(shell go version | cut -d' ' -f 3 | cut -d. -f 2)
+ifeq ($(shell expr $(GOVERSION) \< 14), 1)
+$(warning Your Golang version is go 1.$(GOVERSION))
+$(error Update Golang to version $(shell grep '^go' go.mod))
 endif

 # git modules that need to be loaded
@@ -63,9 +63,6 @@ debug: lotus lotus-miner lotus-worker lotus-seed
 2k: GOFLAGS+=-tags=2k
 2k: lotus lotus-miner lotus-worker lotus-seed

-calibnet: GOFLAGS+=-tags=calibnet
-calibnet: lotus lotus-miner lotus-worker lotus-seed
-
 lotus: $(BUILD_DEPS)
 	rm -f lotus
 	go build $(GOFLAGS) -o lotus ./cmd/lotus
@@ -207,12 +204,6 @@ lotus-wallet:
 .PHONY: lotus-wallet
 BINS+=lotus-wallet

-lotus-keygen:
-	rm -f lotus-keygen
-	go build -o lotus-keygen ./cmd/lotus-keygen
-.PHONY: lotus-keygen
-BINS+=lotus-keygen
-
 testground:
 	go build -tags testground -o /dev/null ./cmd/lotus
 .PHONY: testground
@@ -10,7 +10,7 @@
  <a href="https://circleci.com/gh/filecoin-project/lotus"><img src="https://circleci.com/gh/filecoin-project/lotus.svg?style=svg"></a>
  <a href="https://codecov.io/gh/filecoin-project/lotus"><img src="https://codecov.io/gh/filecoin-project/lotus/branch/master/graph/badge.svg"></a>
  <a href="https://goreportcard.com/report/github.com/filecoin-project/lotus"><img src="https://goreportcard.com/badge/github.com/filecoin-project/lotus" /></a>  
-  <a href=""><img src="https://img.shields.io/badge/golang-%3E%3D1.15.5-blue.svg" /></a>
+  <a href=""><img src="https://img.shields.io/badge/golang-%3E%3D1.14.7-blue.svg" /></a>
  <br>
 </p>

@@ -24,31 +24,24 @@ For instructions on how to build, install and setup lotus, please visit [https:/

 Please send an email to security@filecoin.org. See our [security policy](SECURITY.md) for more details.

-## Related packages
+## Development

-These repos are independent and reusable modules, but are tightly integrated into Lotus to make up a fully featured Filecoin implementation:
+The main branches under development at the moment are:
+* [`master`](https://github.com/filecoin-project/lotus): current testnet.
+* [`next`](https://github.com/filecoin-project/lotus/tree/next): working branch with chain-breaking changes.
+* [`ntwk-calibration`](https://github.com/filecoin-project/lotus/tree/ntwk-calibration): devnet running one of `next` commits.

+### Tracker
+
+All work is tracked via issues. An attempt at keeping an up-to-date view on remaining work towards Mainnet launch can be seen at the [lotus github project board](https://github.com/orgs/filecoin-project/projects/8). The issues labeled with `incentives` are there to identify the issues needed for Space Race launch.
+
+### Packages
+
+The lotus Filecoin implementation unfolds into the following packages:
+
+- [This repo](https://github.com/filecoin-project/lotus)
 - [go-fil-markets](https://github.com/filecoin-project/go-fil-markets) which has its own [kanban work tracker available here](https://app.zenhub.com/workspaces/markets-shared-components-5daa144a7046a60001c6e253/board)
- [specs-actors](https://github.com/filecoin-project/specs-actors) which has its own [kanban work tracker available here](https://app.zenhub.com/workspaces/actors-5ee6f3aa87591f0016c05685/board)
-
-## Contribute
-
-Lotus is a universally open project and welcomes contributions of all kinds: code, docs, and more. However, before making a contribution, we ask you to heed these recommendations:
-
-1. If the proposal entails a protocol change, please first submit a [Filecoin Improvement Proposal](https://github.com/filecoin-project/FIPs).
-2. If the change is complex and requires prior discussion, [open an issue](github.com/filecoin-project/lotus/issues) or a [discussion](https://github.com/filecoin-project/lotus/discussions) to request feedback before you start working on a pull request. This is to avoid disappointment and sunk costs, in case the change is not actually needed or accepted.
-3. Please refrain from submitting PRs to adapt existing code to subjective preferences. The changeset should contain functional or technical improvements/enhancements, bug fixes, new features, or some other clear material contribution. Simple stylistic changes are likely to be rejected in order to reduce code churn.
-
-When implementing a change:
-
-1. Adhere to the standard Go formatting guidelines, e.g. [Effective Go](https://golang.org/doc/effective_go.html). Run `go fmt`.
-2. Stick to the idioms and patterns used in the codebase. Familiar-looking code has a higher chance of being accepted than eerie code. Pay attention to commonly used variable and parameter names, avoidance of naked returns, error handling patterns, etc.
-3. Comments: follow the advice on the [Commentary](https://golang.org/doc/effective_go.html#commentary) section of Effective Go.
-4. Minimize code churn. Modify only what is strictly necessary. Well-encapsulated changesets will get a quicker response from maintainers.
-5. Lint your code with [`golangci-lint`](https://golangci-lint.run) (CI will reject your PR if unlinted).
-6. Add tests.
-7. Title the PR in a meaningful way and describe the rationale and the thought process in the PR description.
-8. Write clean, thoughtful, and detailed [commit messages](https://chris.beams.io/posts/git-commit/). This is even more important than the PR description, because commit messages are stored _inside_ the Git history. One good rule is: if you are happy posting the commit message as the PR description, then it's a good commit message.
+- [spec-actors](https://github.com/filecoin-project/specs-actors) which has its own [kanban work tracker available here](https://app.zenhub.com/workspaces/actors-5ee6f3aa87591f0016c05685/board)

 ## License

@@ -2,11 +2,11 @@

 ## Reporting a Vulnerability

-For reporting security vulnerabilities/bugs, please consult our Security Policy and Responsible Disclosure Program information at https://github.com/filecoin-project/community/blob/master/SECURITY.md. Security vulnerabilities should be reported via our [Vulnerability Reporting channels](https://github.com/filecoin-project/community/blob/master/SECURITY.md#vulnerability-reporting) and will be eligible for a [Bug Bounty](https://security.filecoin.io/bug-bounty/).
+For *critical* bugs, please consult our Security Policy and Responsible Disclosure Program information at https://github.com/filecoin-project/community/blob/master/SECURITY.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.

-Here are some examples of bugs we would consider to be security vulnerabilities:
+Here are some examples of bugs we would consider 'critical':

 * If you can spend from a `multisig` wallet you do not control the keys for.
 * If you can cause a miner to be slashed without them actually misbehaving.
@@ -16,8 +16,8 @@ Here are some examples of bugs we would consider to be security vulnerabilities:
 * If you can craft a message that causes a persistent fork in the network.
 * If you can cause the total amount of Filecoin in the network to no longer be 2 billion.

-This is not an exhaustive list, but should provide some idea of what we consider as a security vulnerability, . 
+This is not an exhaustive list, but should provide some idea of what we consider 'critical'.

 ## Reporting a non security bug

-For non-security bugs, please simply file a GitHub [issue](https://github.com/filecoin-project/lotus/issues/new?template=bug_report.md). 
+For non-critical bugs, please simply file a GitHub [issue](https://github.com/filecoin-project/lotus/issues/new?template=bug_report.md). 
@@ -46,11 +46,6 @@ 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
@@ -2,7 +2,6 @@ package api

 import (
 	"context"
-	"encoding/json"
 	"fmt"
 	"time"

@@ -391,8 +390,6 @@ 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)
-	// StateSearchMsgLimited looks back up to limit epochs in the chain for a message, and returns its receipt and the tipset where it was executed
-	StateSearchMsgLimited(ctx context.Context, msg cid.Cid, limit abi.ChainEpoch) (*MsgLookup, 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)
@@ -517,16 +514,10 @@ type FullNode interface {
 	// along with the address removal.
 	MsigRemoveSigner(ctx context.Context, msig address.Address, proposer address.Address, toRemove address.Address, decrease bool) (cid.Cid, error)

-	// MarketAddBalance adds funds to the market actor
-	MarketAddBalance(ctx context.Context, wallet, addr address.Address, amt types.BigInt) (cid.Cid, error)
-	// MarketGetReserved gets the amount of funds that are currently reserved for the address
-	MarketGetReserved(ctx context.Context, addr address.Address) (types.BigInt, 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
-	// MarketWithdraw withdraws unlocked funds from the market actor
-	MarketWithdraw(ctx context.Context, wallet, addr address.Address, amt types.BigInt) (cid.Cid, error)

 	// MethodGroup: Paych
 	// The Paych methods are for interacting with and managing payment channels
@@ -600,9 +591,6 @@ type DealInfo struct {

 	CreationTime time.Time
 	Verified     bool
-
-	TransferChannelID *datatransfer.ChannelID
-	DataTransfer      *DataTransferChannel
 }

 type MsgLookup struct {
@@ -797,22 +785,6 @@ type StartDealParams struct {
 	VerifiedDeal       bool
 }

-func (s *StartDealParams) UnmarshalJSON(raw []byte) (err error) {
-	type sdpAlias StartDealParams
-
-	sdp := sdpAlias{
-		FastRetrieval: true,
-	}
-
-	if err := json.Unmarshal(raw, &sdp); err != nil {
-		return err
-	}
-
-	*s = StartDealParams(sdp)
-
-	return nil
-}
-
 type IpldObject struct {
 	Cid cid.Cid
 	Obj interface{}
@@ -949,8 +921,7 @@ const (
 )

 type Deadline struct {
-	PostSubmissions      bitfield.BitField
-	DisputableProofCount uint64
+	PostSubmissions bitfield.BitField
 }

 type Partition struct {
@@ -39,8 +39,6 @@ type GatewayAPI interface {
 	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)
-	StateSearchMsg(ctx context.Context, msg cid.Cid) (*MsgLookup, error)
-	StateSectorGetInfo(ctx context.Context, maddr address.Address, n abi.SectorNumber, tsk types.TipSetKey) (*miner.SectorOnChainInfo, 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)
 }
@@ -5,18 +5,16 @@ 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"
-	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"
 	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/specs-storage/storage"
-
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/extern/sector-storage/fsutil"
 	"github.com/filecoin-project/lotus/extern/sector-storage/stores"
@@ -30,7 +28,6 @@ type StorageMiner interface {
 	ActorAddress(context.Context) (address.Address, error)

 	ActorSectorSize(context.Context, address.Address) (abi.SectorSize, error)
-	ActorAddressConfig(ctx context.Context) (AddressConfig, error)

 	MiningBase(context.Context) (*types.TipSet, error)

@@ -43,12 +40,6 @@ type StorageMiner interface {
 	// List all staged sectors
 	SectorsList(context.Context) ([]abi.SectorNumber, error)

-	// Get summary info of sectors
-	SectorsSummary(ctx context.Context) (map[SectorState]int, error)
-
-	// List sectors in particular states
-	SectorsListInStates(context.Context, []SectorState) ([]abi.SectorNumber, error)
-
 	SectorsRefs(context.Context) (map[string][]SealedRef, error)

 	// SectorStartSealing can be called on sectors in Empty or WaitDeals states
@@ -65,17 +56,7 @@ type StorageMiner interface {
 	// SectorGetExpectedSealDuration gets the expected time for a sector to seal
 	SectorGetExpectedSealDuration(context.Context) (time.Duration, error)
 	SectorsUpdate(context.Context, abi.SectorNumber, SectorState) error
-	// SectorRemove removes the sector from storage. It doesn't terminate it on-chain, which can
-	// be done with SectorTerminate. Removing and not terminating live sectors will cause additional penalties.
 	SectorRemove(context.Context, abi.SectorNumber) error
-	// SectorTerminate terminates the sector on-chain (adding it to a termination batch first), then
-	// automatically removes it from storage
-	SectorTerminate(context.Context, abi.SectorNumber) error
-	// SectorTerminateFlush immediately sends a terminate message with sectors batched for termination.
-	// Returns null if message wasn't sent
-	SectorTerminateFlush(ctx context.Context) (*cid.Cid, error)
-	// SectorTerminatePending returns a list of pending sector terminations to be sent in the next batch message
-	SectorTerminatePending(ctx context.Context) ([]abi.SectorID, error)
 	SectorMarkForUpgrade(ctx context.Context, id abi.SectorNumber) error

 	StorageList(ctx context.Context) (map[stores.ID][]stores.Decl, error)
@@ -122,10 +103,6 @@ type StorageMiner interface {
 	DealsSetConsiderOfflineStorageDeals(context.Context, bool) error
 	DealsConsiderOfflineRetrievalDeals(context.Context) (bool, error)
 	DealsSetConsiderOfflineRetrievalDeals(context.Context, bool) error
-	DealsConsiderVerifiedStorageDeals(context.Context) (bool, error)
-	DealsSetConsiderVerifiedStorageDeals(context.Context, bool) error
-	DealsConsiderUnverifiedStorageDeals(context.Context) (bool, error)
-	DealsSetConsiderUnverifiedStorageDeals(context.Context, bool) error

 	StorageAddLocal(ctx context.Context, path string) error

@@ -139,8 +116,6 @@ type StorageMiner interface {
 	// 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
-
-	CheckProvable(ctx context.Context, pp abi.RegisteredPoStProof, sectors []storage.SectorRef, expensive bool) (map[abi.SectorNumber]string, error)
 }

 type SealRes struct {
@@ -220,19 +195,3 @@ func (st *SealSeed) Equals(ost *SealSeed) bool {
 }

 type SectorState string
-
-type AddrUse int
-
-const (
-	PreCommitAddr AddrUse = iota
-	CommitAddr
-	PoStAddr
-
-	TerminateSectorsAddr
-)
-
-type AddressConfig struct {
-	PreCommitControl []address.Address
-	CommitControl    []address.Address
-	TerminateControl []address.Address
-}
@@ -23,9 +23,6 @@ type WorkerAPI interface {

 	storiface.WorkerCalls

-	TaskDisable(ctx context.Context, tt sealtasks.TaskType) error
-	TaskEnable(ctx context.Context, tt sealtasks.TaskType) error
-
 	// Storage / Other
 	Remove(ctx context.Context, sector abi.SectorID) error

@@ -60,9 +60,6 @@ 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"`
@@ -206,7 +203,6 @@ type FullNodeStruct struct {
 		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"`
-		StateSearchMsgLimited              func(context.Context, cid.Cid, abi.ChainEpoch) (*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"`
 		StateMarketBalance                 func(context.Context, address.Address, types.TipSetKey) (api.MarketBalance, error)                                  `perm:"read"`
@@ -245,11 +241,8 @@ type FullNodeStruct struct {
 		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"`

-		MarketAddBalance   func(ctx context.Context, wallet, addr address.Address, amt types.BigInt) (cid.Cid, error)                 `perm:"sign"`
-		MarketGetReserved  func(ctx context.Context, addr address.Address) (types.BigInt, 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"`
-		MarketWithdraw     func(ctx context.Context, wallet, addr address.Address, amt types.BigInt) (cid.Cid, 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"`
@@ -281,9 +274,8 @@ type StorageMinerStruct struct {
 	CommonStruct

 	Internal struct {
-		ActorAddress       func(context.Context) (address.Address, error)                 `perm:"read"`
-		ActorSectorSize    func(context.Context, address.Address) (abi.SectorSize, error) `perm:"read"`
-		ActorAddressConfig func(ctx context.Context) (api.AddressConfig, error)           `perm:"read"`
+		ActorAddress    func(context.Context) (address.Address, error)                 `perm:"read"`
+		ActorSectorSize func(context.Context, address.Address) (abi.SectorSize, error) `perm:"read"`

 		MiningBase func(context.Context) (*types.TipSet, error) `perm:"read"`

@@ -305,8 +297,6 @@ type StorageMinerStruct struct {

 		SectorsStatus                 func(ctx context.Context, sid abi.SectorNumber, showOnChainInfo bool) (api.SectorInfo, error) `perm:"read"`
 		SectorsList                   func(context.Context) ([]abi.SectorNumber, error)                                             `perm:"read"`
-		SectorsListInStates           func(context.Context, []api.SectorState) ([]abi.SectorNumber, error)                          `perm:"read"`
-		SectorsSummary                func(ctx context.Context) (map[api.SectorState]int, error)                                    `perm:"read"`
 		SectorsRefs                   func(context.Context) (map[string][]api.SealedRef, error)                                     `perm:"read"`
 		SectorStartSealing            func(context.Context, abi.SectorNumber) error                                                 `perm:"write"`
 		SectorSetSealDelay            func(context.Context, time.Duration) error                                                    `perm:"write"`
@@ -315,26 +305,23 @@ type StorageMinerStruct struct {
 		SectorGetExpectedSealDuration func(context.Context) (time.Duration, error)                                                  `perm:"read"`
 		SectorsUpdate                 func(context.Context, abi.SectorNumber, api.SectorState) error                                `perm:"admin"`
 		SectorRemove                  func(context.Context, abi.SectorNumber) error                                                 `perm:"admin"`
-		SectorTerminate               func(context.Context, abi.SectorNumber) error                                                 `perm:"admin"`
-		SectorTerminateFlush          func(ctx context.Context) (*cid.Cid, error)                                                   `perm:"admin"`
-		SectorTerminatePending        func(ctx context.Context) ([]abi.SectorID, error)                                             `perm:"admin"`
 		SectorMarkForUpgrade          func(ctx context.Context, id abi.SectorNumber) error                                          `perm:"admin"`

 		WorkerConnect func(context.Context, string) error                                `perm:"admin" retry:"true"` // TODO: worker perm
 		WorkerStats   func(context.Context) (map[uuid.UUID]storiface.WorkerStats, error) `perm:"admin"`
 		WorkerJobs    func(context.Context) (map[uuid.UUID][]storiface.WorkerJob, 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"`
+		ReturnAddPiece        func(ctx context.Context, callID storiface.CallID, pi abi.PieceInfo, err string) error          `perm:"admin" retry:"true"`
+		ReturnSealPreCommit1  func(ctx context.Context, callID storiface.CallID, p1o storage.PreCommit1Out, err string) error `perm:"admin" retry:"true"`
+		ReturnSealPreCommit2  func(ctx context.Context, callID storiface.CallID, sealed storage.SectorCids, err string) error `perm:"admin" retry:"true"`
+		ReturnSealCommit1     func(ctx context.Context, callID storiface.CallID, out storage.Commit1Out, err string) error    `perm:"admin" retry:"true"`
+		ReturnSealCommit2     func(ctx context.Context, callID storiface.CallID, proof storage.Proof, err string) error       `perm:"admin" retry:"true"`
+		ReturnFinalizeSector  func(ctx context.Context, callID storiface.CallID, err string) error                            `perm:"admin" retry:"true"`
+		ReturnReleaseUnsealed func(ctx context.Context, callID storiface.CallID, err string) error                            `perm:"admin" retry:"true"`
+		ReturnMoveStorage     func(ctx context.Context, callID storiface.CallID, err string) error                            `perm:"admin" retry:"true"`
+		ReturnUnsealPiece     func(ctx context.Context, callID storiface.CallID, err string) error                            `perm:"admin" retry:"true"`
+		ReturnReadPiece       func(ctx context.Context, callID storiface.CallID, ok bool, err string) error                   `perm:"admin" retry:"true"`
+		ReturnFetch           func(ctx context.Context, callID storiface.CallID, err string) error                            `perm:"admin" retry:"true"`

 		SealingSchedDiag func(context.Context, bool) (interface{}, error)       `perm:"admin"`
 		SealingAbort     func(ctx context.Context, call storiface.CallID) error `perm:"admin"`
@@ -352,22 +339,18 @@ type StorageMinerStruct struct {
 		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"`
-		DealsConsiderOnlineStorageDeals        func(context.Context) (bool, error)                               `perm:"read"`
-		DealsSetConsiderOnlineStorageDeals     func(context.Context, bool) error                                 `perm:"admin"`
-		DealsConsiderOnlineRetrievalDeals      func(context.Context) (bool, error)                               `perm:"read"`
-		DealsSetConsiderOnlineRetrievalDeals   func(context.Context, bool) error                                 `perm:"admin"`
-		DealsConsiderOfflineStorageDeals       func(context.Context) (bool, error)                               `perm:"read"`
-		DealsSetConsiderOfflineStorageDeals    func(context.Context, bool) error                                 `perm:"admin"`
-		DealsConsiderOfflineRetrievalDeals     func(context.Context) (bool, error)                               `perm:"read"`
-		DealsSetConsiderOfflineRetrievalDeals  func(context.Context, bool) error                                 `perm:"admin"`
-		DealsConsiderVerifiedStorageDeals      func(context.Context) (bool, error)                               `perm:"read"`
-		DealsSetConsiderVerifiedStorageDeals   func(context.Context, bool) error                                 `perm:"admin"`
-		DealsConsiderUnverifiedStorageDeals    func(context.Context) (bool, error)                               `perm:"read"`
-		DealsSetConsiderUnverifiedStorageDeals func(context.Context, bool) error                                 `perm:"admin"`
-		DealsPieceCidBlocklist                 func(context.Context) ([]cid.Cid, error)                          `perm:"read"`
-		DealsSetPieceCidBlocklist              func(context.Context, []cid.Cid) 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"`
+		DealsConsiderOnlineStorageDeals       func(context.Context) (bool, error)                               `perm:"read"`
+		DealsSetConsiderOnlineStorageDeals    func(context.Context, bool) error                                 `perm:"admin"`
+		DealsConsiderOnlineRetrievalDeals     func(context.Context) (bool, error)                               `perm:"read"`
+		DealsSetConsiderOnlineRetrievalDeals  func(context.Context, bool) error                                 `perm:"admin"`
+		DealsConsiderOfflineStorageDeals      func(context.Context) (bool, error)                               `perm:"read"`
+		DealsSetConsiderOfflineStorageDeals   func(context.Context, bool) error                                 `perm:"admin"`
+		DealsConsiderOfflineRetrievalDeals    func(context.Context) (bool, error)                               `perm:"read"`
+		DealsSetConsiderOfflineRetrievalDeals func(context.Context, bool) error                                 `perm:"admin"`
+		DealsPieceCidBlocklist                func(context.Context) ([]cid.Cid, error)                          `perm:"read"`
+		DealsSetPieceCidBlocklist             func(context.Context, []cid.Cid) error                            `perm:"admin"`

 		StorageAddLocal func(ctx context.Context, path string) error `perm:"admin"`

@@ -377,8 +360,6 @@ type StorageMinerStruct struct {
 		PiecesGetCIDInfo   func(ctx context.Context, payloadCid cid.Cid) (*piecestore.CIDInfo, error) `perm:"read"`

 		CreateBackup func(ctx context.Context, fpath string) error `perm:"admin"`
-
-		CheckProvable func(ctx context.Context, pp abi.RegisteredPoStProof, sectors []storage.SectorRef, expensive bool) (map[abi.SectorNumber]string, error) `perm:"admin"`
 	}
 }

@@ -392,20 +373,17 @@ 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 storage.SectorRef, pieceSizes []abi.UnpaddedPieceSize, newPieceSize abi.UnpaddedPieceSize, pieceData storage.Data) (storiface.CallID, error)                 `perm:"admin"`
-		SealPreCommit1  func(ctx context.Context, sector storage.SectorRef, ticket abi.SealRandomness, pieces []abi.PieceInfo) (storiface.CallID, 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 storage.SectorRef, ticket abi.SealRandomness, seed abi.InteractiveSealRandomness, pieces []abi.PieceInfo, cids storage.SectorCids) (storiface.CallID, error) `perm:"admin"`
-		SealCommit2     func(ctx context.Context, sector storage.SectorRef, c1o storage.Commit1Out) (storiface.CallID, 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 storage.SectorRef, safeToFree []storage.Range) (storiface.CallID, error)                                                                                     `perm:"admin"`
-		MoveStorage     func(ctx context.Context, sector storage.SectorRef, types storiface.SectorFileType) (storiface.CallID, error)                                                                                 `perm:"admin"`
-		UnsealPiece     func(context.Context, storage.SectorRef, storiface.UnpaddedByteIndex, abi.UnpaddedPieceSize, abi.SealRandomness, cid.Cid) (storiface.CallID, 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"`
-
-		TaskDisable func(ctx context.Context, tt sealtasks.TaskType) error `perm:"admin"`
-		TaskEnable  func(ctx context.Context, tt sealtasks.TaskType) error `perm:"admin"`
+		AddPiece        func(ctx context.Context, sector abi.SectorID, 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) (storiface.CallID, error)                                                              `perm:"admin"`
+		SealPreCommit2  func(ctx context.Context, sector abi.SectorID, 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) (storiface.CallID, error) `perm:"admin"`
+		SealCommit2     func(ctx context.Context, sector abi.SectorID, c1o storage.Commit1Out) (storiface.CallID, error)                                                                                         `perm:"admin"`
+		FinalizeSector  func(ctx context.Context, sector abi.SectorID, keepUnsealed []storage.Range) (storiface.CallID, error)                                                                                   `perm:"admin"`
+		ReleaseUnsealed func(ctx context.Context, sector abi.SectorID, safeToFree []storage.Range) (storiface.CallID, error)                                                                                     `perm:"admin"`
+		MoveStorage     func(ctx context.Context, sector abi.SectorID, types storiface.SectorFileType) (storiface.CallID, error)                                                                                 `perm:"admin"`
+		UnsealPiece     func(context.Context, abi.SectorID, storiface.UnpaddedByteIndex, abi.UnpaddedPieceSize, abi.SealRandomness, cid.Cid) (storiface.CallID, error)                                           `perm:"admin"`
+		ReadPiece       func(context.Context, io.Writer, abi.SectorID, storiface.UnpaddedByteIndex, abi.UnpaddedPieceSize) (storiface.CallID, error)                                                             `perm:"admin"`
+		Fetch           func(context.Context, abi.SectorID, storiface.SectorFileType, storiface.PathType, storiface.AcquireMode) (storiface.CallID, error)                                                       `perm:"admin"`

 		Remove          func(ctx context.Context, sector abi.SectorID) error `perm:"admin"`
 		StorageAddLocal func(ctx context.Context, path string) error         `perm:"admin"`
@@ -444,10 +422,8 @@ type GatewayStruct struct {
 		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)
-		StateSearchMsg                    func(ctx context.Context, msg cid.Cid) (*api.MsgLookup, 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)
-		StateSectorGetInfo                func(ctx context.Context, maddr address.Address, n abi.SectorNumber, tsk types.TipSetKey) (*miner.SectorOnChainInfo, 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)
 	}
@@ -519,18 +495,6 @@ 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)
 }
@@ -1015,10 +979,6 @@ func (c *FullNodeStruct) StateSearchMsg(ctx context.Context, msgc cid.Cid) (*api
 	return c.Internal.StateSearchMsg(ctx, msgc)
 }

-func (c *FullNodeStruct) StateSearchMsgLimited(ctx context.Context, msgc cid.Cid, limit abi.ChainEpoch) (*api.MsgLookup, error) {
-	return c.Internal.StateSearchMsgLimited(ctx, msgc, limit)
-}
-
 func (c *FullNodeStruct) StateListMiners(ctx context.Context, tsk types.TipSetKey) ([]address.Address, error) {
 	return c.Internal.StateListMiners(ctx, tsk)
 }
@@ -1159,14 +1119,6 @@ func (c *FullNodeStruct) MsigRemoveSigner(ctx context.Context, msig address.Addr
 	return c.Internal.MsigRemoveSigner(ctx, msig, proposer, toRemove, decrease)
 }

-func (c *FullNodeStruct) MarketAddBalance(ctx context.Context, wallet address.Address, addr address.Address, amt types.BigInt) (cid.Cid, error) {
-	return c.Internal.MarketAddBalance(ctx, wallet, addr, amt)
-}
-
-func (c *FullNodeStruct) MarketGetReserved(ctx context.Context, addr address.Address) (types.BigInt, error) {
-	return c.Internal.MarketGetReserved(ctx, addr)
-}
-
 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)
 }
@@ -1175,10 +1127,6 @@ func (c *FullNodeStruct) MarketReleaseFunds(ctx context.Context, addr address.Ad
 	return c.Internal.MarketReleaseFunds(ctx, addr, amt)
 }

-func (c *FullNodeStruct) MarketWithdraw(ctx context.Context, wallet, addr address.Address, amt types.BigInt) (cid.Cid, error) {
-	return c.Internal.MarketWithdraw(ctx, wallet, addr, amt)
-}
-
 func (c *FullNodeStruct) PaychGet(ctx context.Context, from, to address.Address, amt types.BigInt) (*api.ChannelInfo, error) {
 	return c.Internal.PaychGet(ctx, from, to, amt)
 }
@@ -1261,10 +1209,6 @@ func (c *StorageMinerStruct) ActorSectorSize(ctx context.Context, addr address.A
 	return c.Internal.ActorSectorSize(ctx, addr)
 }

-func (c *StorageMinerStruct) ActorAddressConfig(ctx context.Context) (api.AddressConfig, error) {
-	return c.Internal.ActorAddressConfig(ctx)
-}
-
 func (c *StorageMinerStruct) PledgeSector(ctx context.Context) error {
 	return c.Internal.PledgeSector(ctx)
 }
@@ -1279,14 +1223,6 @@ func (c *StorageMinerStruct) SectorsList(ctx context.Context) ([]abi.SectorNumbe
 	return c.Internal.SectorsList(ctx)
 }

-func (c *StorageMinerStruct) SectorsListInStates(ctx context.Context, states []api.SectorState) ([]abi.SectorNumber, error) {
-	return c.Internal.SectorsListInStates(ctx, states)
-}
-
-func (c *StorageMinerStruct) SectorsSummary(ctx context.Context) (map[api.SectorState]int, error) {
-	return c.Internal.SectorsSummary(ctx)
-}
-
 func (c *StorageMinerStruct) SectorsRefs(ctx context.Context) (map[string][]api.SealedRef, error) {
 	return c.Internal.SectorsRefs(ctx)
 }
@@ -1319,18 +1255,6 @@ func (c *StorageMinerStruct) SectorRemove(ctx context.Context, number abi.Sector
 	return c.Internal.SectorRemove(ctx, number)
 }

-func (c *StorageMinerStruct) SectorTerminate(ctx context.Context, number abi.SectorNumber) error {
-	return c.Internal.SectorTerminate(ctx, number)
-}
-
-func (c *StorageMinerStruct) SectorTerminateFlush(ctx context.Context) (*cid.Cid, error) {
-	return c.Internal.SectorTerminateFlush(ctx)
-}
-
-func (c *StorageMinerStruct) SectorTerminatePending(ctx context.Context) ([]abi.SectorID, error) {
-	return c.Internal.SectorTerminatePending(ctx)
-}
-
 func (c *StorageMinerStruct) SectorMarkForUpgrade(ctx context.Context, number abi.SectorNumber) error {
 	return c.Internal.SectorMarkForUpgrade(ctx, number)
 }
@@ -1347,47 +1271,47 @@ func (c *StorageMinerStruct) WorkerJobs(ctx context.Context) (map[uuid.UUID][]st
 	return c.Internal.WorkerJobs(ctx)
 }

-func (c *StorageMinerStruct) ReturnAddPiece(ctx context.Context, callID storiface.CallID, pi abi.PieceInfo, err *storiface.CallError) error {
+func (c *StorageMinerStruct) ReturnAddPiece(ctx context.Context, callID storiface.CallID, pi abi.PieceInfo, err string) error {
 	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 {
+func (c *StorageMinerStruct) ReturnSealPreCommit1(ctx context.Context, callID storiface.CallID, p1o storage.PreCommit1Out, err string) 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 {
+func (c *StorageMinerStruct) ReturnSealPreCommit2(ctx context.Context, callID storiface.CallID, sealed storage.SectorCids, err string) 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 {
+func (c *StorageMinerStruct) ReturnSealCommit1(ctx context.Context, callID storiface.CallID, out storage.Commit1Out, err string) 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 {
+func (c *StorageMinerStruct) ReturnSealCommit2(ctx context.Context, callID storiface.CallID, proof storage.Proof, err string) error {
 	return c.Internal.ReturnSealCommit2(ctx, callID, proof, err)
 }

-func (c *StorageMinerStruct) ReturnFinalizeSector(ctx context.Context, callID storiface.CallID, err *storiface.CallError) error {
+func (c *StorageMinerStruct) ReturnFinalizeSector(ctx context.Context, callID storiface.CallID, err string) error {
 	return c.Internal.ReturnFinalizeSector(ctx, callID, err)
 }

-func (c *StorageMinerStruct) ReturnReleaseUnsealed(ctx context.Context, callID storiface.CallID, err *storiface.CallError) error {
+func (c *StorageMinerStruct) ReturnReleaseUnsealed(ctx context.Context, callID storiface.CallID, err string) error {
 	return c.Internal.ReturnReleaseUnsealed(ctx, callID, err)
 }

-func (c *StorageMinerStruct) ReturnMoveStorage(ctx context.Context, callID storiface.CallID, err *storiface.CallError) error {
+func (c *StorageMinerStruct) ReturnMoveStorage(ctx context.Context, callID storiface.CallID, err string) error {
 	return c.Internal.ReturnMoveStorage(ctx, callID, err)
 }

-func (c *StorageMinerStruct) ReturnUnsealPiece(ctx context.Context, callID storiface.CallID, err *storiface.CallError) error {
+func (c *StorageMinerStruct) ReturnUnsealPiece(ctx context.Context, callID storiface.CallID, err string) error {
 	return c.Internal.ReturnUnsealPiece(ctx, callID, err)
 }

-func (c *StorageMinerStruct) ReturnReadPiece(ctx context.Context, callID storiface.CallID, ok bool, err *storiface.CallError) error {
+func (c *StorageMinerStruct) ReturnReadPiece(ctx context.Context, callID storiface.CallID, ok bool, err string) error {
 	return c.Internal.ReturnReadPiece(ctx, callID, ok, err)
 }

-func (c *StorageMinerStruct) ReturnFetch(ctx context.Context, callID storiface.CallID, err *storiface.CallError) error {
+func (c *StorageMinerStruct) ReturnFetch(ctx context.Context, callID storiface.CallID, err string) error {
 	return c.Internal.ReturnFetch(ctx, callID, err)
 }

@@ -1547,22 +1471,6 @@ func (c *StorageMinerStruct) DealsSetConsiderOfflineRetrievalDeals(ctx context.C
 	return c.Internal.DealsSetConsiderOfflineRetrievalDeals(ctx, b)
 }

-func (c *StorageMinerStruct) DealsConsiderVerifiedStorageDeals(ctx context.Context) (bool, error) {
-	return c.Internal.DealsConsiderVerifiedStorageDeals(ctx)
-}
-
-func (c *StorageMinerStruct) DealsSetConsiderVerifiedStorageDeals(ctx context.Context, b bool) error {
-	return c.Internal.DealsSetConsiderVerifiedStorageDeals(ctx, b)
-}
-
-func (c *StorageMinerStruct) DealsConsiderUnverifiedStorageDeals(ctx context.Context) (bool, error) {
-	return c.Internal.DealsConsiderUnverifiedStorageDeals(ctx)
-}
-
-func (c *StorageMinerStruct) DealsSetConsiderUnverifiedStorageDeals(ctx context.Context, b bool) error {
-	return c.Internal.DealsSetConsiderUnverifiedStorageDeals(ctx, b)
-}
-
 func (c *StorageMinerStruct) StorageAddLocal(ctx context.Context, path string) error {
 	return c.Internal.StorageAddLocal(ctx, path)
 }
@@ -1587,10 +1495,6 @@ func (c *StorageMinerStruct) CreateBackup(ctx context.Context, fpath string) err
 	return c.Internal.CreateBackup(ctx, fpath)
 }

-func (c *StorageMinerStruct) CheckProvable(ctx context.Context, pp abi.RegisteredPoStProof, sectors []storage.SectorRef, expensive bool) (map[abi.SectorNumber]string, error) {
-	return c.Internal.CheckProvable(ctx, pp, sectors, expensive)
-}
-
 // WorkerStruct

 func (w *WorkerStruct) Version(ctx context.Context) (build.Version, error) {
@@ -1609,58 +1513,50 @@ func (w *WorkerStruct) Info(ctx context.Context) (storiface.WorkerInfo, error) {
 	return w.Internal.Info(ctx)
 }

-func (w *WorkerStruct) AddPiece(ctx context.Context, sector storage.SectorRef, pieceSizes []abi.UnpaddedPieceSize, newPieceSize abi.UnpaddedPieceSize, pieceData storage.Data) (storiface.CallID, error) {
+func (w *WorkerStruct) AddPiece(ctx context.Context, sector abi.SectorID, 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 storage.SectorRef, ticket abi.SealRandomness, pieces []abi.PieceInfo) (storiface.CallID, error) {
+func (w *WorkerStruct) SealPreCommit1(ctx context.Context, sector abi.SectorID, 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 storage.SectorRef, pc1o storage.PreCommit1Out) (storiface.CallID, error) {
+func (w *WorkerStruct) SealPreCommit2(ctx context.Context, sector abi.SectorID, pc1o storage.PreCommit1Out) (storiface.CallID, error) {
 	return w.Internal.SealPreCommit2(ctx, sector, pc1o)
 }

-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) {
+func (w *WorkerStruct) SealCommit1(ctx context.Context, sector abi.SectorID, 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 storage.SectorRef, c1o storage.Commit1Out) (storiface.CallID, error) {
+func (w *WorkerStruct) SealCommit2(ctx context.Context, sector abi.SectorID, c1o storage.Commit1Out) (storiface.CallID, error) {
 	return w.Internal.SealCommit2(ctx, sector, c1o)
 }

-func (w *WorkerStruct) FinalizeSector(ctx context.Context, sector storage.SectorRef, keepUnsealed []storage.Range) (storiface.CallID, error) {
+func (w *WorkerStruct) FinalizeSector(ctx context.Context, sector abi.SectorID, keepUnsealed []storage.Range) (storiface.CallID, error) {
 	return w.Internal.FinalizeSector(ctx, sector, keepUnsealed)
 }

-func (w *WorkerStruct) ReleaseUnsealed(ctx context.Context, sector storage.SectorRef, safeToFree []storage.Range) (storiface.CallID, error) {
+func (w *WorkerStruct) ReleaseUnsealed(ctx context.Context, sector abi.SectorID, 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) {
+func (w *WorkerStruct) MoveStorage(ctx context.Context, sector abi.SectorID, 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) {
+func (w *WorkerStruct) UnsealPiece(ctx context.Context, sector abi.SectorID, 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) {
+func (w *WorkerStruct) ReadPiece(ctx context.Context, sink io.Writer, sector abi.SectorID, 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) {
+func (w *WorkerStruct) Fetch(ctx context.Context, id abi.SectorID, fileType storiface.SectorFileType, ptype storiface.PathType, am storiface.AcquireMode) (storiface.CallID, error) {
 	return w.Internal.Fetch(ctx, id, fileType, ptype, am)
 }

-func (w *WorkerStruct) TaskDisable(ctx context.Context, tt sealtasks.TaskType) error {
-	return w.Internal.TaskDisable(ctx, tt)
-}
-
-func (w *WorkerStruct) TaskEnable(ctx context.Context, tt sealtasks.TaskType) error {
-	return w.Internal.TaskEnable(ctx, tt)
-}
-
 func (w *WorkerStruct) Remove(ctx context.Context, sector abi.SectorID) error {
 	return w.Internal.Remove(ctx, sector)
 }
@@ -1785,14 +1681,6 @@ func (g GatewayStruct) StateNetworkVersion(ctx context.Context, tsk types.TipSet
 	return g.Internal.StateNetworkVersion(ctx, tsk)
 }

-func (g GatewayStruct) StateSearchMsg(ctx context.Context, msg cid.Cid) (*api.MsgLookup, error) {
-	return g.Internal.StateSearchMsg(ctx, msg)
-}
-
-func (g GatewayStruct) StateSectorGetInfo(ctx context.Context, maddr address.Address, n abi.SectorNumber, tsk types.TipSetKey) (*miner.SectorOnChainInfo, error) {
-	return g.Internal.StateSectorGetInfo(ctx, maddr, n, tsk)
-}
-
 func (g GatewayStruct) StateVerifiedClientStatus(ctx context.Context, addr address.Address, tsk types.TipSetKey) (*abi.StoragePower, error) {
 	return g.Internal.StateVerifiedClientStatus(ctx, addr, tsk)
 }
@@ -90,7 +90,7 @@ func init() {
 	addExample(&pid)

 	addExample(bitfield.NewFromSet([]uint64{5}))
-	addExample(abi.RegisteredSealProof_StackedDrg32GiBV1_1)
+	addExample(abi.RegisteredSealProof_StackedDrg32GiBV1)
 	addExample(abi.RegisteredPoStProof_StackedDrgWindow32GiBV1)
 	addExample(abi.ChainEpoch(10101))
 	addExample(crypto.SigTypeBLS)
@@ -233,14 +233,6 @@ func init() {
 			CpuUse:     0,
 		},
 	})
-	addExample(storiface.ErrorCode(0))
-	addExample(map[abi.SectorNumber]string{
-		123: "can't acquire read lock",
-	})
-	addExample(map[api.SectorState]int{
-		api.SectorState(sealing.Proving): 120,
-	})
-	addExample([]abi.SectorNumber{123, 124})

 	// worker specific
 	addExample(storiface.AcquireMove)
@@ -248,7 +240,6 @@ func init() {
 	addExample(map[sealtasks.TaskType]struct{}{
 		sealtasks.TTPreCommit2: {},
 	})
-	addExample(sealtasks.TTCommit2)
 }

 func exampleValue(method string, t, parent reflect.Type) interface{} {
@@ -17,9 +17,9 @@ import (

 func TestCCUpgrade(t *testing.T, b APIBuilder, blocktime time.Duration) {
 	for _, height := range []abi.ChainEpoch{
-		2,    // before
+		1,    // before
 		162,  // while sealing
-		530,  // after upgrade deal
+		520,  // after upgrade deal
 		5000, // after
 	} {
 		height := height // make linters happy by copying
@@ -31,7 +31,7 @@ func TestCCUpgrade(t *testing.T, b APIBuilder, blocktime time.Duration) {

 func testCCUpgrade(t *testing.T, b APIBuilder, blocktime time.Duration, upgradeHeight abi.ChainEpoch) {
 	ctx := context.Background()
-	n, sn := b(t, []FullNodeOpts{FullNodeWithActorsV3At(upgradeHeight)}, OneMiner)
+	n, sn := b(t, []FullNodeOpts{FullNodeWithUpgradeAt(upgradeHeight)}, OneMiner)
 	client := n[0].FullNode.(*impl.FullNodeAPI)
 	miner := sn[0]

@@ -89,7 +89,7 @@ func testCCUpgrade(t *testing.T, b APIBuilder, blocktime time.Duration, upgradeH
 		t.Fatal(err)
 	}

-	MakeDeal(t, ctx, 6, client, miner, false, false, 0)
+	MakeDeal(t, ctx, 6, client, miner, false, false)

 	// Validate upgrade

@@ -8,43 +8,104 @@ import (
 	"math/rand"
 	"os"
 	"path/filepath"
+	"sync/atomic"
 	"testing"
 	"time"

+	"github.com/stretchr/testify/require"
+
 	"github.com/ipfs/go-cid"
 	files "github.com/ipfs/go-ipfs-files"
 	"github.com/ipld/go-car"
-	"github.com/stretchr/testify/require"

 	"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"
-	"github.com/filecoin-project/lotus/chain/types"
 	sealing "github.com/filecoin-project/lotus/extern/storage-sealing"
-	"github.com/filecoin-project/lotus/node/impl"
-	ipld "github.com/ipfs/go-ipld-format"
 	dag "github.com/ipfs/go-merkledag"
 	dstest "github.com/ipfs/go-merkledag/test"
 	unixfile "github.com/ipfs/go-unixfs/file"
+
+	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/node/impl"
+	ipld "github.com/ipfs/go-ipld-format"
 )

-func TestDealFlow(t *testing.T, b APIBuilder, blocktime time.Duration, carExport, fastRet bool, startEpoch abi.ChainEpoch) {
-	s := setupOneClientOneMiner(t, b, blocktime)
-	defer s.blockMiner.Stop()
+func TestDealFlow(t *testing.T, b APIBuilder, blocktime time.Duration, carExport, fastRet bool) {

-	MakeDeal(t, s.ctx, 6, s.client, s.miner, carExport, fastRet, startEpoch)
+	ctx := context.Background()
+	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)
+	}
+	time.Sleep(time.Second)
+
+	mine := int64(1)
+	done := make(chan struct{})
+	go func() {
+		defer close(done)
+		for atomic.LoadInt64(&mine) == 1 {
+			time.Sleep(blocktime)
+			if err := sn[0].MineOne(ctx, MineNext); err != nil {
+				t.Error(err)
+			}
+		}
+	}()
+
+	MakeDeal(t, ctx, 6, client, miner, carExport, fastRet)
+
+	atomic.AddInt64(&mine, -1)
+	fmt.Println("shutting down mining")
+	<-done
 }

-func TestDoubleDealFlow(t *testing.T, b APIBuilder, blocktime time.Duration, startEpoch abi.ChainEpoch) {
-	s := setupOneClientOneMiner(t, b, blocktime)
-	defer s.blockMiner.Stop()
+func TestDoubleDealFlow(t *testing.T, b APIBuilder, blocktime time.Duration) {

-	MakeDeal(t, s.ctx, 6, s.client, s.miner, false, false, startEpoch)
-	MakeDeal(t, s.ctx, 7, s.client, s.miner, false, false, startEpoch)
+	ctx := context.Background()
+	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)
+	}
+	time.Sleep(time.Second)
+
+	mine := int64(1)
+	done := make(chan struct{})
+
+	go func() {
+		defer close(done)
+		for atomic.LoadInt64(&mine) == 1 {
+			time.Sleep(blocktime)
+			if err := sn[0].MineOne(ctx, MineNext); err != nil {
+				t.Error(err)
+			}
+		}
+	}()
+
+	MakeDeal(t, ctx, 6, 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 api.FullNode, miner TestStorageNode, carExport, fastRet bool, startEpoch abi.ChainEpoch) {
+func MakeDeal(t *testing.T, ctx context.Context, rseed int, client api.FullNode, miner TestStorageNode, carExport, fastRet bool) {
 	res, data, err := CreateClientFile(ctx, client, rseed)
 	if err != nil {
 		t.Fatal(err)
@@ -53,7 +114,7 @@ func MakeDeal(t *testing.T, ctx context.Context, rseed int, client api.FullNode,
 	fcid := res.Root
 	fmt.Println("FILE CID: ", fcid)

-	deal := startDeal(t, ctx, miner, client, fcid, fastRet, startEpoch)
+	deal := startDeal(t, ctx, miner, client, fcid, fastRet)

 	// TODO: this sleep is only necessary because deals don't immediately get logged in the dealstore, we should fix this
 	time.Sleep(time.Second)
@@ -88,42 +149,96 @@ func CreateClientFile(ctx context.Context, client api.FullNode, rseed int) (*api
 	return res, data, nil
 }

-func TestFastRetrievalDealFlow(t *testing.T, b APIBuilder, blocktime time.Duration, startEpoch abi.ChainEpoch) {
-	s := setupOneClientOneMiner(t, b, blocktime)
-	defer s.blockMiner.Stop()
+func TestFastRetrievalDealFlow(t *testing.T, b APIBuilder, blocktime time.Duration) {
+
+	ctx := context.Background()
+	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)
+	}
+	time.Sleep(time.Second)
+
+	mine := int64(1)
+	done := make(chan struct{})
+	go func() {
+		defer close(done)
+		for atomic.LoadInt64(&mine) == 1 {
+			time.Sleep(blocktime)
+			if err := sn[0].MineOne(ctx, MineNext); err != nil {
+				t.Error(err)
+			}
+		}
+	}()

 	data := make([]byte, 1600)
 	rand.New(rand.NewSource(int64(8))).Read(data)

 	r := bytes.NewReader(data)
-	fcid, err := s.client.ClientImportLocal(s.ctx, r)
+	fcid, err := client.ClientImportLocal(ctx, r)
 	if err != nil {
 		t.Fatal(err)
 	}

 	fmt.Println("FILE CID: ", fcid)

-	deal := startDeal(t, s.ctx, s.miner, s.client, fcid, true, startEpoch)
+	deal := startDeal(t, ctx, miner, client, fcid, true)

-	waitDealPublished(t, s.ctx, s.miner, deal)
+	waitDealPublished(t, ctx, miner, deal)
 	fmt.Println("deal published, retrieving")
 	// Retrieval
-	info, err := s.client.ClientGetDealInfo(s.ctx, *deal)
+	info, err := client.ClientGetDealInfo(ctx, *deal)
 	require.NoError(t, err)

-	testRetrieval(t, s.ctx, s.client, fcid, &info.PieceCID, false, data)
+	testRetrieval(t, ctx, client, fcid, &info.PieceCID, false, data)
+	atomic.AddInt64(&mine, -1)
+	fmt.Println("shutting down mining")
+	<-done
 }

-func TestSecondDealRetrieval(t *testing.T, b APIBuilder, blocktime time.Duration) {
-	s := setupOneClientOneMiner(t, b, blocktime)
-	defer s.blockMiner.Stop()
+func TestSenondDealRetrieval(t *testing.T, b APIBuilder, blocktime time.Duration) {
+
+	ctx := context.Background()
+	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)
+	}
+	time.Sleep(time.Second)
+
+	mine := int64(1)
+	done := make(chan struct{})
+
+	go func() {
+		defer close(done)
+		for atomic.LoadInt64(&mine) == 1 {
+			time.Sleep(blocktime)
+			if err := sn[0].MineOne(ctx, MineNext); err != nil {
+				t.Error(err)
+			}
+		}
+	}()

 	{
 		data1 := make([]byte, 800)
 		rand.New(rand.NewSource(int64(3))).Read(data1)
 		r := bytes.NewReader(data1)

-		fcid1, err := s.client.ClientImportLocal(s.ctx, r)
+		fcid1, err := client.ClientImportLocal(ctx, r)
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -132,34 +247,38 @@ func TestSecondDealRetrieval(t *testing.T, b APIBuilder, blocktime time.Duration
 		rand.New(rand.NewSource(int64(9))).Read(data2)
 		r2 := bytes.NewReader(data2)

-		fcid2, err := s.client.ClientImportLocal(s.ctx, r2)
+		fcid2, err := client.ClientImportLocal(ctx, r2)
 		if err != nil {
 			t.Fatal(err)
 		}

-		deal1 := startDeal(t, s.ctx, s.miner, s.client, fcid1, true, 0)
+		deal1 := startDeal(t, ctx, miner, client, fcid1, true)

 		// TODO: this sleep is only necessary because deals don't immediately get logged in the dealstore, we should fix this
 		time.Sleep(time.Second)
-		waitDealSealed(t, s.ctx, s.miner, s.client, deal1, true)
+		waitDealSealed(t, ctx, miner, client, deal1, true)

-		deal2 := startDeal(t, s.ctx, s.miner, s.client, fcid2, true, 0)
+		deal2 := startDeal(t, ctx, miner, client, fcid2, true)

 		time.Sleep(time.Second)
-		waitDealSealed(t, s.ctx, s.miner, s.client, deal2, false)
+		waitDealSealed(t, ctx, miner, client, deal2, false)

 		// Retrieval
-		info, err := s.client.ClientGetDealInfo(s.ctx, *deal2)
+		info, err := client.ClientGetDealInfo(ctx, *deal2)
 		require.NoError(t, err)

-		rf, _ := s.miner.SectorsRefs(s.ctx)
+		rf, _ := miner.SectorsRefs(ctx)
 		fmt.Printf("refs: %+v\n", rf)

-		testRetrieval(t, s.ctx, s.client, fcid2, &info.PieceCID, false, data2)
+		testRetrieval(t, ctx, client, fcid2, &info.PieceCID, false, data2)
 	}
+
+	atomic.AddInt64(&mine, -1)
+	fmt.Println("shutting down mining")
+	<-done
 }

-func startDeal(t *testing.T, ctx context.Context, miner TestStorageNode, client api.FullNode, fcid cid.Cid, fastRet bool, startEpoch abi.ChainEpoch) *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)
@@ -177,7 +296,6 @@ func startDeal(t *testing.T, ctx context.Context, miner TestStorageNode, client
 		Wallet:            addr,
 		Miner:             maddr,
 		EpochPrice:        types.NewInt(1000000),
-		DealStartEpoch:    startEpoch,
 		MinBlocksDuration: uint64(build.MinDealDuration),
 		FastRetrieval:     fastRet,
 	})
@@ -195,7 +313,7 @@ loop:
 			t.Fatal(err)
 		}
 		switch di.State {
-		case storagemarket.StorageDealAwaitingPreCommit, storagemarket.StorageDealSealing:
+		case storagemarket.StorageDealSealing:
 			if noseal {
 				return
 			}
@@ -235,7 +353,7 @@ func waitDealPublished(t *testing.T, ctx context.Context, miner TestStorageNode,
 					t.Fatal("deal failed")
 				case storagemarket.StorageDealError:
 					t.Fatal("deal errored", di.Message)
-				case storagemarket.StorageDealFinalizing, storagemarket.StorageDealAwaitingPreCommit, storagemarket.StorageDealSealing, storagemarket.StorageDealActive:
+				case storagemarket.StorageDealFinalizing, storagemarket.StorageDealSealing, storagemarket.StorageDealActive:
 					fmt.Println("COMPLETE", di)
 					return
 				}
@@ -338,40 +456,3 @@ func extractCarData(t *testing.T, ctx context.Context, rdata []byte, rpath strin
 	}
 	return rdata
 }
-
-type dealsScaffold struct {
-	ctx        context.Context
-	client     *impl.FullNodeAPI
-	miner      TestStorageNode
-	blockMiner *BlockMiner
-}
-
-func setupOneClientOneMiner(t *testing.T, b APIBuilder, blocktime time.Duration) *dealsScaffold {
-	n, sn := b(t, OneFull, OneMiner)
-	client := n[0].FullNode.(*impl.FullNodeAPI)
-	miner := sn[0]
-	return connectAndStartMining(t, b, blocktime, client, miner)
-}
-
-func connectAndStartMining(t *testing.T, b APIBuilder, blocktime time.Duration, client *impl.FullNodeAPI, miner TestStorageNode) *dealsScaffold {
-	ctx := context.Background()
-	addrinfo, err := client.NetAddrsListen(ctx)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if err := miner.NetConnect(ctx, addrinfo); err != nil {
-		t.Fatal(err)
-	}
-	time.Sleep(time.Second)
-
-	blockMiner := NewBlockMiner(ctx, t, miner, blocktime)
-	blockMiner.MineBlocks()
-
-	return &dealsScaffold{
-		ctx:        ctx,
-		client:     client,
-		miner:      miner,
-		blockMiner: blockMiner,
-	}
-}
@@ -186,7 +186,7 @@ func TestDealMining(t *testing.T, b APIBuilder, blocktime time.Duration, carExpo
 		}
 	}()

-	deal := startDeal(t, ctx, provider, client, fcid, false, 0)
+	deal := startDeal(t, ctx, provider, client, fcid, false)

 	// TODO: this sleep is only necessary because deals don't immediately get logged in the dealstore, we should fix this
 	time.Sleep(time.Second)
@@ -4,7 +4,6 @@ import (
 	"context"
 	"fmt"
 	"os"
-	"strings"
 	"testing"
 	"time"

@@ -49,7 +48,6 @@ type TestStorageNode struct {
 	ListenAddr multiaddr.Multiaddr

 	MineOne func(context.Context, miner.MineReq) error
-	Stop    func(context.Context) error
 }

 var PresealGenesis = -1
@@ -111,38 +109,14 @@ var OneMiner = []StorageMiner{{Full: 0, Preseal: PresealGenesis}}
 var OneFull = DefaultFullOpts(1)
 var TwoFull = DefaultFullOpts(2)

-var FullNodeWithActorsV3At = func(upgradeHeight abi.ChainEpoch) FullNodeOpts {
+var FullNodeWithUpgradeAt = func(upgradeHeight abi.ChainEpoch) FullNodeOpts {
 	return FullNodeOpts{
 		Opts: func(nodes []TestNode) node.Option {
 			return node.Override(new(stmgr.UpgradeSchedule), stmgr.UpgradeSchedule{{
-				// prepare for upgrade.
-				Network:   network.Version9,
-				Height:    1,
-				Migration: stmgr.UpgradeActorsV2,
-			}, {
 				// Skip directly to tape height so precommits work.
-				Network:   network.Version10,
+				Network:   network.Version5,
 				Height:    upgradeHeight,
-				Migration: stmgr.UpgradeActorsV3,
-			}})
-		},
-	}
-}
-
-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,
 			}})
 		},
 	}
@@ -164,11 +138,7 @@ func (ts *testSuite) testVersion(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	versions := strings.Split(v.Version, "+")
-	if len(versions) <= 0 {
-		t.Fatal("empty version")
-	}
-	require.Equal(t, versions[0], build.BuildVersion)
+	require.Equal(t, v.Version, build.BuildVersion)
 }

 func (ts *testSuite) testSearchMsg(t *testing.T) {
@@ -3,120 +3,26 @@ package test
 import (
 	"context"
 	"fmt"
-	"sort"
 	"sync/atomic"

 	"strings"
 	"testing"
 	"time"

-	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"

 	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-bitfield"
 	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/go-state-types/crypto"
-	"github.com/filecoin-project/go-state-types/dline"
-	"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"
-	proof3 "github.com/filecoin-project/specs-actors/v3/actors/runtime/proof"
-	"github.com/filecoin-project/specs-storage/storage"

 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/build"
-	"github.com/filecoin-project/lotus/chain/actors"
-	minerActor "github.com/filecoin-project/lotus/chain/actors/builtin/miner"
 	"github.com/filecoin-project/lotus/chain/types"
 	bminer "github.com/filecoin-project/lotus/miner"
 	"github.com/filecoin-project/lotus/node/impl"
 )

-func TestSDRUpgrade(t *testing.T, b APIBuilder, blocktime time.Duration) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	n, sn := b(t, []FullNodeOpts{FullNodeWithSDRAt(500, 1000)}, 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)
-
-	pledge := make(chan struct{})
-	mine := int64(1)
-	done := make(chan struct{})
-	go func() {
-		defer close(done)
-		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()
@@ -157,13 +63,11 @@ func TestPledgeSector(t *testing.T, b APIBuilder, blocktime time.Duration, nSect

 func pledgeSectors(t *testing.T, ctx context.Context, miner TestStorageNode, n, existing int, blockNotif <-chan struct{}) {
 	for i := 0; i < n; i++ {
-		if i%3 == 0 && blockNotif != nil {
-			<-blockNotif
-			log.Errorf("WAIT")
-		}
-		log.Errorf("PLEDGING %d", i)
 		err := miner.PledgeSector(ctx)
 		require.NoError(t, err)
+		if i%3 == 0 && blockNotif != nil {
+			<-blockNotif
+		}
 	}

 	for {
@@ -206,7 +110,7 @@ func pledgeSectors(t *testing.T, ctx context.Context, miner TestStorageNode, n,

 func TestWindowPost(t *testing.T, b APIBuilder, blocktime time.Duration, nSectors int) {
 	for _, height := range []abi.ChainEpoch{
-		2,    // before
+		1,    // before
 		162,  // while sealing
 		5000, // while proving
 	} {
@@ -217,13 +121,12 @@ func TestWindowPost(t *testing.T, b APIBuilder, blocktime time.Duration, nSector
 	}

 }
-
 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{FullNodeWithActorsV3At(upgradeHeight)}, OneMiner)
+	n, sn := b(t, []FullNodeOpts{FullNodeWithUpgradeAt(upgradeHeight)}, OneMiner)

 	client := n[0].FullNode.(*impl.FullNodeAPI)
 	miner := sn[0]
@@ -306,17 +209,15 @@ func testWindowPostUpgrade(t *testing.T, b APIBuilder, blocktime time.Duration,

 		// Drop the partition
 		err = secs.ForEach(func(sid uint64) error {
-			return miner.StorageMiner.(*impl.StorageMinerAPI).IStorageMgr.(*mock.SectorMgr).MarkCorrupted(storage.SectorRef{
-				ID: abi.SectorID{
-					Miner:  abi.ActorID(mid),
-					Number: abi.SectorNumber(sid),
-				},
+			return miner.StorageMiner.(*impl.StorageMinerAPI).IStorageMgr.(*mock.SectorMgr).MarkCorrupted(abi.SectorID{
+				Miner:  abi.ActorID(mid),
+				Number: abi.SectorNumber(sid),
 			}, true)
 		})
 		require.NoError(t, err)
 	}

-	var s storage.SectorRef
+	var s abi.SectorID

 	// Drop 1 sectors from deadline 3 partition 0
 	{
@@ -337,11 +238,9 @@ func testWindowPostUpgrade(t *testing.T, b APIBuilder, blocktime time.Duration,
 		require.NoError(t, err)
 		fmt.Println("the sectors", all)

-		s = storage.SectorRef{
-			ID: abi.SectorID{
-				Miner:  abi.ActorID(mid),
-				Number: abi.SectorNumber(sn),
-			},
+		s = abi.SectorID{
+			Miner:  abi.ActorID(mid),
+			Number: abi.SectorNumber(sn),
 		}

 		err = miner.StorageMiner.(*impl.StorageMinerAPI).IStorageMgr.(*mock.SectorMgr).MarkFailed(s, true)
@@ -435,592 +334,3 @@ func testWindowPostUpgrade(t *testing.T, b APIBuilder, blocktime time.Duration,
 	sectors = p.MinerPower.RawBytePower.Uint64() / uint64(ssz)
 	require.Equal(t, nSectors+GenesisPreseals-2+1, int(sectors)) // -2 not recovered sectors + 1 just pledged
 }
-
-func TestTerminate(t *testing.T, b APIBuilder, blocktime time.Duration) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	nSectors := uint64(2)
-
-	n, sn := b(t, []FullNodeOpts{FullNodeWithActorsV3At(2)}, []StorageMiner{{Full: 0, Preseal: int(nSectors)}})
-
-	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
-	}()
-
-	maddr, err := miner.ActorAddress(ctx)
-	require.NoError(t, err)
-
-	ssz, err := miner.ActorSectorSize(ctx, maddr)
-	require.NoError(t, err)
-
-	p, err := client.StateMinerPower(ctx, maddr, types.EmptyTSK)
-	require.NoError(t, err)
-	require.Equal(t, p.MinerPower, p.TotalPower)
-	require.Equal(t, p.MinerPower.RawBytePower, types.NewInt(uint64(ssz)*nSectors))
-
-	fmt.Printf("Seal a sector\n")
-
-	pledgeSectors(t, ctx, miner, 1, 0, nil)
-
-	fmt.Printf("wait for power\n")
-
-	{
-		// Wait until proven.
-		di, err := client.StateMinerProvingDeadline(ctx, maddr, types.EmptyTSK)
-		require.NoError(t, err)
-
-		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
-			}
-		}
-	}
-
-	nSectors++
-
-	p, err = client.StateMinerPower(ctx, maddr, types.EmptyTSK)
-	require.NoError(t, err)
-	require.Equal(t, p.MinerPower, p.TotalPower)
-	require.Equal(t, p.MinerPower.RawBytePower, types.NewInt(uint64(ssz)*nSectors))
-
-	fmt.Println("Terminate a sector")
-
-	toTerminate := abi.SectorNumber(3)
-
-	err = miner.SectorTerminate(ctx, toTerminate)
-	require.NoError(t, err)
-
-	msgTriggerred := false
-loop:
-	for {
-		si, err := miner.SectorsStatus(ctx, toTerminate, false)
-		require.NoError(t, err)
-
-		fmt.Println("state: ", si.State, msgTriggerred)
-
-		switch sealing.SectorState(si.State) {
-		case sealing.Terminating:
-			if !msgTriggerred {
-				{
-					p, err := miner.SectorTerminatePending(ctx)
-					require.NoError(t, err)
-					require.Len(t, p, 1)
-					require.Equal(t, abi.SectorNumber(3), p[0].Number)
-				}
-
-				c, err := miner.SectorTerminateFlush(ctx)
-				require.NoError(t, err)
-				if c != nil {
-					msgTriggerred = true
-					fmt.Println("terminate message:", c)
-
-					{
-						p, err := miner.SectorTerminatePending(ctx)
-						require.NoError(t, err)
-						require.Len(t, p, 0)
-					}
-				}
-			}
-		case sealing.TerminateWait, sealing.TerminateFinality, sealing.Removed:
-			break loop
-		}
-
-		time.Sleep(100 * time.Millisecond)
-	}
-
-	// check power decreased
-	p, err = client.StateMinerPower(ctx, maddr, types.EmptyTSK)
-	require.NoError(t, err)
-	require.Equal(t, p.MinerPower, p.TotalPower)
-	require.Equal(t, p.MinerPower.RawBytePower, types.NewInt(uint64(ssz)*(nSectors-1)))
-
-	// check in terminated set
-	{
-		parts, err := client.StateMinerPartitions(ctx, maddr, 1, types.EmptyTSK)
-		require.NoError(t, err)
-		require.Greater(t, len(parts), 0)
-
-		bflen := func(b bitfield.BitField) uint64 {
-			l, err := b.Count()
-			require.NoError(t, err)
-			return l
-		}
-
-		require.Equal(t, uint64(1), bflen(parts[0].AllSectors))
-		require.Equal(t, uint64(0), bflen(parts[0].LiveSectors))
-	}
-
-	di, err := client.StateMinerProvingDeadline(ctx, maddr, types.EmptyTSK)
-	require.NoError(t, err)
-	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
-		}
-		build.Clock.Sleep(blocktime)
-	}
-	require.NoError(t, err)
-	fmt.Printf("End for head.Height > %d\n", di.PeriodStart+di.WPoStProvingPeriod+2)
-
-	p, err = client.StateMinerPower(ctx, maddr, types.EmptyTSK)
-	require.NoError(t, err)
-
-	require.Equal(t, p.MinerPower, p.TotalPower)
-	require.Equal(t, p.MinerPower.RawBytePower, types.NewInt(uint64(ssz)*(nSectors-1)))
-}
-
-func TestWindowPostDispute(t *testing.T, b APIBuilder, blocktime time.Duration) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	// First, we configure two miners. After sealing, we're going to turn off the first miner so
-	// it doesn't submit proofs.
-	///
-	// Then we're going to manually submit bad proofs.
-	n, sn := b(t, []FullNodeOpts{
-		FullNodeWithActorsV3At(2),
-	}, []StorageMiner{
-		{Full: 0, Preseal: PresealGenesis},
-		{Full: 0},
-	})
-
-	client := n[0].FullNode.(*impl.FullNodeAPI)
-	chainMiner := sn[0]
-	evilMiner := sn[1]
-
-	{
-		addrinfo, err := client.NetAddrsListen(ctx)
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		if err := chainMiner.NetConnect(ctx, addrinfo); err != nil {
-			t.Fatal(err)
-		}
-
-		if err := evilMiner.NetConnect(ctx, addrinfo); err != nil {
-			t.Fatal(err)
-		}
-	}
-
-	defaultFrom, err := client.WalletDefaultAddress(ctx)
-	require.NoError(t, err)
-
-	build.Clock.Sleep(time.Second)
-
-	// Mine with the _second_ node (the good one).
-	done := make(chan struct{})
-	go func() {
-		defer close(done)
-		for ctx.Err() == nil {
-			build.Clock.Sleep(blocktime)
-			if err := chainMiner.MineOne(ctx, MineNext); err != nil {
-				if ctx.Err() != nil {
-					// context was canceled, ignore the error.
-					return
-				}
-				t.Error(err)
-			}
-		}
-	}()
-	defer func() {
-		cancel()
-		<-done
-	}()
-
-	// Give the chain miner enough sectors to win every block.
-	pledgeSectors(t, ctx, chainMiner, 10, 0, nil)
-	// And the evil one 1 sector. No cookie for you.
-	pledgeSectors(t, ctx, evilMiner, 1, 0, nil)
-
-	// Let the evil miner's sectors gain power.
-	evilMinerAddr, err := evilMiner.ActorAddress(ctx)
-	require.NoError(t, err)
-
-	di, err := client.StateMinerProvingDeadline(ctx, evilMinerAddr, types.EmptyTSK)
-	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 {
-			fmt.Printf("Now head.Height = %d\n", head.Height())
-			break
-		}
-		build.Clock.Sleep(blocktime)
-	}
-
-	p, err := client.StateMinerPower(ctx, evilMinerAddr, types.EmptyTSK)
-	require.NoError(t, err)
-
-	ssz, err := evilMiner.ActorSectorSize(ctx, evilMinerAddr)
-	require.NoError(t, err)
-
-	// make sure it has gained power.
-	require.Equal(t, p.MinerPower.RawBytePower, types.NewInt(uint64(ssz)))
-
-	evilSectors, err := evilMiner.SectorsList(ctx)
-	require.NoError(t, err)
-	evilSectorNo := evilSectors[0] // only one.
-	evilSectorLoc, err := client.StateSectorPartition(ctx, evilMinerAddr, evilSectorNo, types.EmptyTSK)
-	require.NoError(t, err)
-
-	fmt.Println("evil miner stopping")
-
-	// Now stop the evil miner, and start manually submitting bad proofs.
-	require.NoError(t, evilMiner.Stop(ctx))
-
-	fmt.Println("evil miner stopped")
-
-	// Wait until we need to prove our sector.
-	for {
-		di, err = client.StateMinerProvingDeadline(ctx, evilMinerAddr, types.EmptyTSK)
-		require.NoError(t, err)
-		if di.Index == evilSectorLoc.Deadline {
-			break
-		}
-		build.Clock.Sleep(blocktime)
-	}
-
-	err = submitBadProof(ctx, client, evilMinerAddr, di, evilSectorLoc.Deadline, evilSectorLoc.Partition)
-	require.NoError(t, err, "evil proof not accepted")
-
-	// Wait until after the proving period.
-	for {
-		di, err = client.StateMinerProvingDeadline(ctx, evilMinerAddr, types.EmptyTSK)
-		require.NoError(t, err)
-		if di.Index != evilSectorLoc.Deadline {
-			break
-		}
-		build.Clock.Sleep(blocktime)
-	}
-
-	fmt.Println("accepted evil proof")
-
-	// Make sure the evil node didn't lose any power.
-	p, err = client.StateMinerPower(ctx, evilMinerAddr, types.EmptyTSK)
-	require.NoError(t, err)
-	require.Equal(t, p.MinerPower.RawBytePower, types.NewInt(uint64(ssz)))
-
-	// OBJECTION! The good miner files a DISPUTE!!!!
-	{
-		params := &minerActor.DisputeWindowedPoStParams{
-			Deadline:  evilSectorLoc.Deadline,
-			PoStIndex: 0,
-		}
-
-		enc, aerr := actors.SerializeParams(params)
-		require.NoError(t, aerr)
-
-		msg := &types.Message{
-			To:     evilMinerAddr,
-			Method: minerActor.Methods.DisputeWindowedPoSt,
-			Params: enc,
-			Value:  types.NewInt(0),
-			From:   defaultFrom,
-		}
-		sm, err := client.MpoolPushMessage(ctx, msg, nil)
-		require.NoError(t, err)
-
-		fmt.Println("waiting dispute")
-		rec, err := client.StateWaitMsg(ctx, sm.Cid(), build.MessageConfidence)
-		require.NoError(t, err)
-		require.Zero(t, rec.Receipt.ExitCode, "dispute not accepted: %s", rec.Receipt.ExitCode.Error())
-	}
-
-	// Objection SUSTAINED!
-	// Make sure the evil node lost power.
-	p, err = client.StateMinerPower(ctx, evilMinerAddr, types.EmptyTSK)
-	require.NoError(t, err)
-	require.True(t, p.MinerPower.RawBytePower.IsZero())
-
-	// Now we begin the redemption arc.
-	require.True(t, p.MinerPower.RawBytePower.IsZero())
-
-	// First, recover the sector.
-
-	{
-		minerInfo, err := client.StateMinerInfo(ctx, evilMinerAddr, types.EmptyTSK)
-		require.NoError(t, err)
-
-		params := &minerActor.DeclareFaultsRecoveredParams{
-			Recoveries: []minerActor.RecoveryDeclaration{{
-				Deadline:  evilSectorLoc.Deadline,
-				Partition: evilSectorLoc.Partition,
-				Sectors:   bitfield.NewFromSet([]uint64{uint64(evilSectorNo)}),
-			}},
-		}
-
-		enc, aerr := actors.SerializeParams(params)
-		require.NoError(t, aerr)
-
-		msg := &types.Message{
-			To:     evilMinerAddr,
-			Method: minerActor.Methods.DeclareFaultsRecovered,
-			Params: enc,
-			Value:  types.FromFil(30), // repay debt.
-			From:   minerInfo.Owner,
-		}
-		sm, err := client.MpoolPushMessage(ctx, msg, nil)
-		require.NoError(t, err)
-
-		rec, err := client.StateWaitMsg(ctx, sm.Cid(), build.MessageConfidence)
-		require.NoError(t, err)
-		require.Zero(t, rec.Receipt.ExitCode, "recovery not accepted: %s", rec.Receipt.ExitCode.Error())
-	}
-
-	// Then wait for the deadline.
-	for {
-		di, err = client.StateMinerProvingDeadline(ctx, evilMinerAddr, types.EmptyTSK)
-		require.NoError(t, err)
-		if di.Index == evilSectorLoc.Deadline {
-			break
-		}
-		build.Clock.Sleep(blocktime)
-	}
-
-	// Now try to be evil again
-	err = submitBadProof(ctx, client, evilMinerAddr, di, evilSectorLoc.Deadline, evilSectorLoc.Partition)
-	require.Error(t, err)
-	require.Contains(t, err.Error(), "message execution failed: exit 16, reason: window post failed: invalid PoSt")
-
-	// It didn't work because we're recovering.
-}
-
-func submitBadProof(
-	ctx context.Context,
-	client api.FullNode, maddr address.Address,
-	di *dline.Info, dlIdx, partIdx uint64,
-) error {
-	head, err := client.ChainHead(ctx)
-	if err != nil {
-		return err
-	}
-
-	from, err := client.WalletDefaultAddress(ctx)
-	if err != nil {
-		return err
-	}
-
-	minerInfo, err := client.StateMinerInfo(ctx, maddr, head.Key())
-	if err != nil {
-		return err
-	}
-
-	commEpoch := di.Open
-	commRand, err := client.ChainGetRandomnessFromTickets(
-		ctx, head.Key(), crypto.DomainSeparationTag_PoStChainCommit,
-		commEpoch, nil,
-	)
-	if err != nil {
-		return err
-	}
-	params := &minerActor.SubmitWindowedPoStParams{
-		ChainCommitEpoch: commEpoch,
-		ChainCommitRand:  commRand,
-		Deadline:         dlIdx,
-		Partitions:       []minerActor.PoStPartition{{Index: partIdx}},
-		Proofs: []proof3.PoStProof{{
-			PoStProof:  minerInfo.WindowPoStProofType,
-			ProofBytes: []byte("I'm soooo very evil."),
-		}},
-	}
-
-	enc, aerr := actors.SerializeParams(params)
-	if aerr != nil {
-		return aerr
-	}
-
-	msg := &types.Message{
-		To:     maddr,
-		Method: minerActor.Methods.SubmitWindowedPoSt,
-		Params: enc,
-		Value:  types.NewInt(0),
-		From:   from,
-	}
-	sm, err := client.MpoolPushMessage(ctx, msg, nil)
-	if err != nil {
-		return err
-	}
-
-	rec, err := client.StateWaitMsg(ctx, sm.Cid(), build.MessageConfidence)
-	if err != nil {
-		return err
-	}
-	if rec.Receipt.ExitCode.IsError() {
-		return rec.Receipt.ExitCode
-	}
-	return nil
-}
-
-func TestWindowPostDisputeFails(t *testing.T, b APIBuilder, blocktime time.Duration) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	n, sn := b(t, []FullNodeOpts{FullNodeWithActorsV3At(2)}, 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)
-		}
-	}
-
-	defaultFrom, err := client.WalletDefaultAddress(ctx)
-	require.NoError(t, err)
-
-	maddr, err := miner.ActorAddress(ctx)
-	require.NoError(t, err)
-
-	build.Clock.Sleep(time.Second)
-
-	// Mine with the _second_ node (the good one).
-	done := make(chan struct{})
-	go func() {
-		defer close(done)
-		for ctx.Err() == nil {
-			build.Clock.Sleep(blocktime)
-			if err := miner.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, 10, 0, nil)
-
-	di, err := client.StateMinerProvingDeadline(ctx, maddr, types.EmptyTSK)
-	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 {
-			fmt.Printf("Now head.Height = %d\n", head.Height())
-			break
-		}
-		build.Clock.Sleep(blocktime)
-	}
-
-	ssz, err := miner.ActorSectorSize(ctx, maddr)
-	require.NoError(t, err)
-	expectedPower := types.NewInt(uint64(ssz) * (GenesisPreseals + 10))
-
-	p, err := client.StateMinerPower(ctx, maddr, types.EmptyTSK)
-	require.NoError(t, err)
-
-	// make sure it has gained power.
-	require.Equal(t, p.MinerPower.RawBytePower, expectedPower)
-
-	// Wait until a proof has been submitted.
-	var targetDeadline uint64
-waitForProof:
-	for {
-		deadlines, err := client.StateMinerDeadlines(ctx, maddr, types.EmptyTSK)
-		require.NoError(t, err)
-		for dlIdx, dl := range deadlines {
-			nonEmpty, err := dl.PostSubmissions.IsEmpty()
-			require.NoError(t, err)
-			if nonEmpty {
-				targetDeadline = uint64(dlIdx)
-				break waitForProof
-			}
-		}
-
-		build.Clock.Sleep(blocktime)
-	}
-
-	for {
-		di, err := client.StateMinerProvingDeadline(ctx, maddr, types.EmptyTSK)
-		require.NoError(t, err)
-		// wait until the deadline finishes.
-		if di.Index == ((targetDeadline + 1) % di.WPoStPeriodDeadlines) {
-			break
-		}
-
-		build.Clock.Sleep(blocktime)
-	}
-
-	// Try to object to the proof. This should fail.
-	{
-		params := &minerActor.DisputeWindowedPoStParams{
-			Deadline:  targetDeadline,
-			PoStIndex: 0,
-		}
-
-		enc, aerr := actors.SerializeParams(params)
-		require.NoError(t, aerr)
-
-		msg := &types.Message{
-			To:     maddr,
-			Method: minerActor.Methods.DisputeWindowedPoSt,
-			Params: enc,
-			Value:  types.NewInt(0),
-			From:   defaultFrom,
-		}
-		_, err := client.MpoolPushMessage(ctx, msg, nil)
-		require.Error(t, err)
-		require.Contains(t, err.Error(), "failed to dispute valid post (RetCode=16)")
-	}
-}
@@ -6,6 +6,7 @@ import (

 	datatransfer "github.com/filecoin-project/go-data-transfer"
 	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/lotus/build"
 	"github.com/ipfs/go-cid"

 	"github.com/libp2p/go-libp2p-core/peer"
@@ -50,6 +51,19 @@ type MessageSendSpec struct {
 	MaxFee abi.TokenAmount
 }

+var DefaultMessageSendSpec = MessageSendSpec{
+	// MaxFee of 0.1FIL
+	MaxFee: abi.NewTokenAmount(int64(build.FilecoinPrecision) / 10),
+}
+
+func (ms *MessageSendSpec) Get() MessageSendSpec {
+	if ms == nil {
+		return DefaultMessageSendSpec
+	}
+
+	return *ms
+}
+
 type DataTransferChannel struct {
 	TransferID  datatransfer.TransferID
 	Status      datatransfer.Status
@@ -93,9 +107,3 @@ func NewDataTransferChannel(hostID peer.ID, channelState datatransfer.ChannelSta
 	}
 	return channel
 }
-
-type NetBlockList struct {
-	Peers     []peer.ID
-	IPAddrs   []string
-	IPSubnets []string
-}
@@ -2,9 +2,11 @@ package build

 import (
 	"context"
+	"os"
 	"strings"

 	"github.com/filecoin-project/lotus/lib/addrutil"
+	"golang.org/x/xerrors"

 	rice "github.com/GeertJohan/go.rice"
 	"github.com/libp2p/go-libp2p-core/peer"
@@ -15,16 +17,24 @@ func BuiltinBootstrap() ([]peer.AddrInfo, error) {
 		return nil, nil
 	}

-	b := rice.MustFindBox("bootstrap")
+	var out []peer.AddrInfo

-	if BootstrappersFile != "" {
-		spi := b.MustString(BootstrappersFile)
-		if spi == "" {
-			return nil, nil
+	b := rice.MustFindBox("bootstrap")
+	err := b.Walk("", func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			return xerrors.Errorf("failed to walk box: %w", err)
 		}

-		return addrutil.ParseAddresses(context.TODO(), strings.Split(strings.TrimSpace(spi), "\n"))
-	}
-
-	return nil, nil
+		if !strings.HasSuffix(path, ".pi") {
+			return nil
+		}
+		spi := b.MustString(path)
+		if spi == "" {
+			return nil
+		}
+		pi, err := addrutil.ParseAddresses(context.TODO(), strings.Split(strings.TrimSpace(spi), "\n"))
+		out = append(out, pi...)
+		return err
+	})
+	return out, err
 }
@@ -1,15 +0,0 @@
-/dns4/bootstrap-0.mainnet.filops.net/tcp/1347/p2p/12D3KooWCVe8MmsEMes2FzgTpt9fXtmCY7wrq91GRiaC8PHSCCBj
-/dns4/bootstrap-1.mainnet.filops.net/tcp/1347/p2p/12D3KooWCwevHg1yLCvktf2nvLu7L9894mcrJR4MsBCcm4syShVc
-/dns4/bootstrap-2.mainnet.filops.net/tcp/1347/p2p/12D3KooWEWVwHGn2yR36gKLozmb4YjDJGerotAPGxmdWZx2nxMC4
-/dns4/bootstrap-3.mainnet.filops.net/tcp/1347/p2p/12D3KooWKhgq8c7NQ9iGjbyK7v7phXvG6492HQfiDaGHLHLQjk7R
-/dns4/bootstrap-4.mainnet.filops.net/tcp/1347/p2p/12D3KooWL6PsFNPhYftrJzGgF5U18hFoaVhfGk7xwzD8yVrHJ3Uc
-/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
@@ -14,7 +14,7 @@ func MaybeGenesis() []byte {
 		log.Warnf("loading built-in genesis: %s", err)
 		return nil
 	}
-	genBytes, err := builtinGen.Bytes(GenesisFile)
+	genBytes, err := builtinGen.Bytes("devnet.car")
 	if err != nil {
 		log.Warnf("loading built-in genesis: %s", err)
 	}
@@ -1,9 +0,0 @@
-package build
-
-import (
-	"github.com/filecoin-project/go-state-types/abi"
-)
-
-func IsNearUpgrade(epoch, upgradeEpoch abi.ChainEpoch) bool {
-	return epoch > upgradeEpoch-Finality && epoch < upgradeEpoch+Finality
-}
@@ -3,13 +3,13 @@
 package build

 import (
+	"math"
+	"os"
+
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/lotus/chain/actors/policy"
 )

-const BootstrappersFile = ""
-const GenesisFile = ""
-
 const UpgradeBreezeHeight = -1
 const BreezeGasTampingDuration = 0

@@ -18,16 +18,10 @@ const UpgradeIgnitionHeight = -2
 const UpgradeRefuelHeight = -3
 const UpgradeTapeHeight = -4

-const UpgradeActorsV2Height = 10
-const UpgradeLiftoffHeight = -5
+var UpgradeActorsV2Height = abi.ChainEpoch(10)
+var UpgradeLiftoffHeight = abi.ChainEpoch(-5)

 const UpgradeKumquatHeight = 15
-const UpgradeCalicoHeight = 20
-const UpgradePersianHeight = 25
-const UpgradeOrangeHeight = 27
-const UpgradeClausHeight = 30
-
-const UpgradeActorsV3Height = 35

 var DrandSchedule = map[abi.ChainEpoch]DrandEnum{
 	0: DrandMainnet,
@@ -38,6 +32,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
 }

@@ -1,70 +0,0 @@
-// +build calibnet
-
-package build
-
-import (
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/lotus/chain/actors/policy"
-	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
-)
-
-var DrandSchedule = map[abi.ChainEpoch]DrandEnum{
-	0: DrandMainnet,
-}
-
-const BootstrappersFile = "calibnet.pi"
-const GenesisFile = "calibnet.car"
-
-const UpgradeBreezeHeight = -1
-const BreezeGasTampingDuration = 120
-
-const UpgradeSmokeHeight = -2
-
-const UpgradeIgnitionHeight = -3
-const UpgradeRefuelHeight = -4
-
-var UpgradeActorsV2Height = abi.ChainEpoch(30)
-
-const UpgradeTapeHeight = 60
-
-// 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 = -5
-
-const UpgradeKumquatHeight = 90
-
-const UpgradeCalicoHeight = 92000
-const UpgradePersianHeight = UpgradeCalicoHeight + (builtin2.EpochsInHour * 60)
-
-// 2020-12-17T19:00:00Z
-const UpgradeClausHeight = 161386
-
-// 2021-01-17T19:00:00Z
-const UpgradeOrangeHeight = 250666
-
-// 2021-01-28T21:00:00Z
-const UpgradeActorsV3Height = 282586
-
-func init() {
-	policy.SetConsensusMinerMinPower(abi.NewStoragePower(10 << 30))
-	policy.SetSupportedProofTypes(
-		abi.RegisteredSealProof_StackedDrg512MiBV1,
-		abi.RegisteredSealProof_StackedDrg32GiBV1,
-		abi.RegisteredSealProof_StackedDrg64GiBV1,
-	)
-
-	SetAddressNetwork(address.Testnet)
-
-	Devnet = true
-
-	BuildType = BuildCalibnet
-}
-
-const BlockDelaySecs = uint64(builtin2.EpochDurationSeconds)
-
-const PropagationDelaySecs = uint64(6)
-
-// BootstrapPeerThreshold is the minimum number peers we need to track for a sync worker to start
-const BootstrapPeerThreshold = 4
@@ -1,13 +1,10 @@
 // +build !debug
 // +build !2k
 // +build !testground
-// +build !calibnet

 package build

 import (
-	"os"
-
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/lotus/chain/actors/policy"
@@ -15,59 +12,43 @@ import (
 )

 var DrandSchedule = map[abi.ChainEpoch]DrandEnum{
-	0:                  DrandIncentinet,
-	UpgradeSmokeHeight: DrandMainnet,
+	0: DrandMainnet,
 }

-const BootstrappersFile = "mainnet.pi"
-const GenesisFile = "mainnet.car"
-
-const UpgradeBreezeHeight = 41280
-
+const UpgradeBreezeHeight = -1
 const BreezeGasTampingDuration = 120

-const UpgradeSmokeHeight = 51000
+const UpgradeSmokeHeight = -2

-const UpgradeIgnitionHeight = 94000
-const UpgradeRefuelHeight = 130800
+const UpgradeIgnitionHeight = -3
+const UpgradeRefuelHeight = -4

-const UpgradeActorsV2Height = 138720
+var UpgradeActorsV2Height = abi.ChainEpoch(30)

-const UpgradeTapeHeight = 140760
+const UpgradeTapeHeight = 60

 // 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 UpgradeLiftoffHeight = -5

-const UpgradeKumquatHeight = 170000
-
-const UpgradeCalicoHeight = 265200
-const UpgradePersianHeight = UpgradeCalicoHeight + (builtin2.EpochsInHour * 60)
-
-const UpgradeOrangeHeight = 336458
-
-// 2020-12-22T02:00:00Z
-const UpgradeClausHeight = 343200
-
-// TODO
-const UpgradeActorsV3Height = 999999999
+const UpgradeKumquatHeight = 90

 func init() {
-	policy.SetConsensusMinerMinPower(abi.NewStoragePower(10 << 40))
+	policy.SetConsensusMinerMinPower(abi.NewStoragePower(10 << 30))
+	policy.SetSupportedProofTypes(
+		abi.RegisteredSealProof_StackedDrg512MiBV1,
+		abi.RegisteredSealProof_StackedDrg32GiBV1,
+		abi.RegisteredSealProof_StackedDrg64GiBV1,
+	)

-	if os.Getenv("LOTUS_USE_TEST_ADDRESSES") != "1" {
-		SetAddressNetwork(address.Mainnet)
-	}
+	SetAddressNetwork(address.Testnet)

-	Devnet = false
-
-	BuildType = BuildMainnet
+	Devnet = true
 }

 const BlockDelaySecs = uint64(builtin2.EpochDurationSeconds)

 const PropagationDelaySecs = uint64(6)

-// BootstrapPeerThreshold is the minimum number peers we need to track for a sync worker to start
 const BootstrapPeerThreshold = 4
@@ -19,12 +19,3 @@ func DhtProtocolName(netName dtypes.NetworkName) protocol.ID {
 func SetAddressNetwork(n address.Network) {
 	address.CurrentNetwork = n
 }
-
-func MustParseAddress(addr string) address.Address {
-	ret, err := address.NewFromString(addr)
-	if err != nil {
-		panic(err)
-	}
-
-	return ret
-}
@@ -25,7 +25,7 @@ const UnixfsLinksPerLevel = 1024
 // Consensus / Network

 const AllowableClockDriftSecs = uint64(1)
-const NewestNetworkVersion = network.Version9
+const NewestNetworkVersion = network.Version6
 const ActorUpgradeNetworkVersion = network.Version4

 // Epochs
@@ -61,9 +61,6 @@ const TicketRandomnessLookback = abi.ChainEpoch(1)

 const AddressMainnetEnvVar = "_mainnet_"

-// the 'f' prefix doesn't matter
-var ZeroAddress = MustParseAddress("f3yaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaby2smx7a")
-
 // /////
 // Devnet settings

@@ -88,24 +88,15 @@ var (
 	UpgradeActorsV2Height abi.ChainEpoch = 10
 	UpgradeLiftoffHeight  abi.ChainEpoch = -5
 	UpgradeKumquatHeight  abi.ChainEpoch = -6
-	UpgradeCalicoHeight   abi.ChainEpoch = -7
-	UpgradePersianHeight  abi.ChainEpoch = -8
-	UpgradeOrangeHeight   abi.ChainEpoch = -9
-	UpgradeClausHeight    abi.ChainEpoch = -10
-	UpgradeActorsV3Height abi.ChainEpoch = -11

 	DrandSchedule = map[abi.ChainEpoch]DrandEnum{
 		0: DrandMainnet,
 	}

-	NewestNetworkVersion       = network.Version9
+	NewestNetworkVersion       = network.Version5
 	ActorUpgradeNetworkVersion = network.Version4

-	Devnet      = true
-	ZeroAddress = MustParseAddress("f3yaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaby2smx7a")
-
-	BootstrappersFile = ""
-	GenesisFile       = ""
+	Devnet = true
 )

 const BootstrapPeerThreshold = 1
@@ -10,32 +10,26 @@ var CurrentCommit string
 var BuildType int

 const (
-	BuildDefault  = 0
-	BuildMainnet  = 0x1
-	Build2k       = 0x2
-	BuildDebug    = 0x3
-	BuildCalibnet = 0x4
+	BuildDefault = 0
+	Build2k      = 0x1
+	BuildDebug   = 0x3
 )

 func buildType() string {
 	switch BuildType {
 	case BuildDefault:
 		return ""
-	case BuildMainnet:
-		return "+mainnet"
-	case Build2k:
-		return "+2k"
 	case BuildDebug:
 		return "+debug"
-	case BuildCalibnet:
-		return "+calibnet"
+	case Build2k:
+		return "+2k"
 	default:
 		return "+huh?"
 	}
 }

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

 func UserVersion() string {
 	return BuildVersion + buildType() + CurrentCommit
@@ -89,9 +83,9 @@ func VersionForType(nodeType NodeType) (Version, error) {

 // semver versions of the rpc api exposed
 var (
-	FullAPIVersion   = newVer(1, 0, 0)
-	MinerAPIVersion  = newVer(1, 0, 1)
-	WorkerAPIVersion = newVer(1, 0, 0)
+	FullAPIVersion   = newVer(0, 17, 0)
+	MinerAPIVersion  = newVer(0, 17, 0)
+	WorkerAPIVersion = newVer(0, 16, 0)
 )

 //nolint:varcheck,deadcode
@@ -2,9 +2,16 @@ package adt

 import (
 	"github.com/ipfs/go-cid"
+	"golang.org/x/xerrors"

 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/cbor"
+	"github.com/filecoin-project/go-state-types/network"
+
+	"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 {
@@ -17,6 +24,26 @@ type Map interface {
 	ForEach(v cbor.Unmarshaler, fn func(key string) error) error
 }

+func AsMap(store Store, root cid.Cid, version actors.Version) (Map, error) {
+	switch version {
+	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 actors.Version) (Map, error) {
+	switch version {
+	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)
+}
+
 type Array interface {
 	Root() (cid.Cid, error)

@@ -27,3 +54,23 @@ type Array interface {

 	ForEach(v cbor.Unmarshaler, fn func(idx int64) error) error
 }
+
+func AsArray(store Store, root cid.Cid, version network.Version) (Array, error) {
+	switch actors.VersionForNetwork(version) {
+	case actors.Version0:
+		return adt0.AsArray(store, root)
+	case actors.Version2:
+		return adt2.AsArray(store, root)
+	}
+	return nil, xerrors.Errorf("unknown network version: %d", version)
+}
+
+func NewArray(store Store, version actors.Version) (Array, error) {
+	switch version {
+	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)
+}
@@ -13,7 +13,6 @@ import (

 	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
 	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
-	builtin3 "github.com/filecoin-project/specs-actors/v3/actors/builtin"
 )

 func init() {
@@ -23,12 +22,9 @@ func init() {
 	builtin.RegisterActorState(builtin2.AccountActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
 		return load2(store, root)
 	})
-	builtin.RegisterActorState(builtin3.AccountActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
-		return load3(store, root)
-	})
 }

-var Methods = builtin3.MethodsAccount
+var Methods = builtin2.MethodsAccount

 func Load(store adt.Store, act *types.Actor) (State, error) {
 	switch act.Code {
@@ -36,8 +32,6 @@ func Load(store adt.Store, act *types.Actor) (State, error) {
 		return load0(store, act.Head)
 	case builtin2.AccountActorCodeID:
 		return load2(store, act.Head)
-	case builtin3.AccountActorCodeID:
-		return load3(store, act.Head)
 	}
 	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
 }
@@ -1,30 +0,0 @@
-package account
-
-import (
-	"github.com/filecoin-project/go-address"
-	"github.com/ipfs/go-cid"
-
-	"github.com/filecoin-project/lotus/chain/actors/adt"
-
-	account3 "github.com/filecoin-project/specs-actors/v3/actors/builtin/account"
-)
-
-var _ State = (*state3)(nil)
-
-func load3(store adt.Store, root cid.Cid) (State, error) {
-	out := state3{store: store}
-	err := store.Get(store.Context(), root, &out)
-	if err != nil {
-		return nil, err
-	}
-	return &out, nil
-}
-
-type state3 struct {
-	account3.State
-	store adt.Store
-}
-
-func (s *state3) PubkeyAddress() (address.Address, error) {
-	return s.Address, nil
-}
@@ -2,12 +2,12 @@ package builtin

 import (
 	"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"
-	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
-	builtin3 "github.com/filecoin-project/specs-actors/v3/actors/builtin"

 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/cbor"
@@ -15,12 +15,9 @@ import (
 	"github.com/filecoin-project/lotus/chain/actors/adt"
 	"github.com/filecoin-project/lotus/chain/types"

-	smoothing0 "github.com/filecoin-project/specs-actors/actors/util/smoothing"
-	smoothing2 "github.com/filecoin-project/specs-actors/v2/actors/util/smoothing"
-	smoothing3 "github.com/filecoin-project/specs-actors/v3/actors/util/smoothing"
-
 	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"
 )

 var SystemActorAddr = builtin0.SystemActorAddr
@@ -41,12 +38,11 @@ const (
 )

 const (
-	MethodSend        = builtin3.MethodSend
-	MethodConstructor = builtin3.MethodConstructor
+	MethodSend        = builtin2.MethodSend
+	MethodConstructor = builtin2.MethodConstructor
 )

-// These are all just type aliases across actor versions 0, 2, & 3. In the future, that might change
-// and we might need to do something fancier.
+// TODO: Why does actors have 2 different versions of this?
 type SectorInfo = proof0.SectorInfo
 type PoStProof = proof0.PoStProof
 type FilterEstimate = smoothing0.FilterEstimate
@@ -55,17 +51,13 @@ func FromV0FilterEstimate(v0 smoothing0.FilterEstimate) FilterEstimate {
 	return (FilterEstimate)(v0)
 }

-// Doesn't change between actors v0, v2, and v3.
+// Doesn't change between actors v0 and v1
 func QAPowerForWeight(size abi.SectorSize, duration abi.ChainEpoch, dealWeight, verifiedWeight abi.DealWeight) abi.StoragePower {
 	return miner0.QAPowerForWeight(size, duration, dealWeight, verifiedWeight)
 }

-func FromV2FilterEstimate(v2 smoothing2.FilterEstimate) FilterEstimate {
-	return (FilterEstimate)(v2)
-}
-
-func FromV3FilterEstimate(v3 smoothing3.FilterEstimate) FilterEstimate {
-	return (FilterEstimate)(v3)
+func FromV2FilterEstimate(v1 smoothing2.FilterEstimate) FilterEstimate {
+	return (FilterEstimate)(v1)
 }

 type ActorStateLoader func(store adt.Store, root cid.Cid) (cbor.Marshaler, error)
@@ -90,42 +82,30 @@ func ActorNameByCode(c cid.Cid) string {
 		return builtin0.ActorNameByCode(c)
 	case builtin2.IsBuiltinActor(c):
 		return builtin2.ActorNameByCode(c)
-	case builtin3.IsBuiltinActor(c):
-		return builtin3.ActorNameByCode(c)
 	default:
 		return "<unknown>"
 	}
 }

 func IsBuiltinActor(c cid.Cid) bool {
-	return builtin0.IsBuiltinActor(c) ||
-		builtin2.IsBuiltinActor(c) ||
-		builtin3.IsBuiltinActor(c)
+	return builtin0.IsBuiltinActor(c) || builtin2.IsBuiltinActor(c)
 }

 func IsAccountActor(c cid.Cid) bool {
-	return c == builtin0.AccountActorCodeID ||
-		c == builtin2.AccountActorCodeID ||
-		c == builtin3.AccountActorCodeID
+	return c == builtin0.AccountActorCodeID || c == builtin2.AccountActorCodeID
 }

 func IsStorageMinerActor(c cid.Cid) bool {
-	return c == builtin0.StorageMinerActorCodeID ||
-		c == builtin2.StorageMinerActorCodeID ||
-		c == builtin3.StorageMinerActorCodeID
+	return c == builtin0.StorageMinerActorCodeID || c == builtin2.StorageMinerActorCodeID
 }

 func IsMultisigActor(c cid.Cid) bool {
-	return c == builtin0.MultisigActorCodeID ||
-		c == builtin2.MultisigActorCodeID ||
-		c == builtin3.MultisigActorCodeID
+	return c == builtin0.MultisigActorCodeID || c == builtin2.MultisigActorCodeID

 }

 func IsPaymentChannelActor(c cid.Cid) bool {
-	return c == builtin0.PaymentChannelActorCodeID ||
-		c == builtin2.PaymentChannelActorCodeID ||
-		c == builtin3.PaymentChannelActorCodeID
+	return c == builtin0.PaymentChannelActorCodeID || c == builtin2.PaymentChannelActorCodeID
 }

 func makeAddress(addr string) address.Address {
@@ -1,10 +1,10 @@
 package cron

 import (
-	builtin3 "github.com/filecoin-project/specs-actors/v3/actors/builtin"
+	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
 )

 var (
-	Address = builtin3.CronActorAddr
-	Methods = builtin3.MethodsCron
+	Address = builtin2.CronActorAddr
+	Methods = builtin2.MethodsCron
 )
@@ -1,152 +0,0 @@
-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
-}
@@ -15,7 +15,6 @@ import (

 	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
 	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
-	builtin3 "github.com/filecoin-project/specs-actors/v3/actors/builtin"
 )

 func init() {
@@ -25,14 +24,11 @@ func init() {
 	builtin.RegisterActorState(builtin2.InitActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
 		return load2(store, root)
 	})
-	builtin.RegisterActorState(builtin3.InitActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
-		return load3(store, root)
-	})
 }

 var (
-	Address = builtin3.InitActorAddr
-	Methods = builtin3.MethodsInit
+	Address = builtin2.InitActorAddr
+	Methods = builtin2.MethodsInit
 )

 func Load(store adt.Store, act *types.Actor) (State, error) {
@@ -41,8 +37,6 @@ func Load(store adt.Store, act *types.Actor) (State, error) {
 		return load0(store, act.Head)
 	case builtin2.InitActorCodeID:
 		return load2(store, act.Head)
-	case builtin3.InitActorCodeID:
-		return load3(store, act.Head)
 	}
 	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
 }
@@ -63,6 +57,4 @@ type State interface {

 	// Sets the network's name. This should only be used on upgrade/fork.
 	SetNetworkName(name string) error
-
-	addressMap() (adt.Map, error)
 }
@@ -79,7 +79,3 @@ 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)
-}
@@ -79,7 +79,3 @@ func (s *state2) Remove(addrs ...address.Address) (err error) {
 	s.State.AddressMap = amr
 	return nil
 }
-
-func (s *state2) addressMap() (adt.Map, error) {
-	return adt2.AsMap(s.store, s.AddressMap)
-}
@@ -1,86 +0,0 @@
-package init
-
-import (
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/abi"
-	builtin3 "github.com/filecoin-project/specs-actors/v3/actors/builtin"
-	"github.com/ipfs/go-cid"
-	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"
-
-	init3 "github.com/filecoin-project/specs-actors/v3/actors/builtin/init"
-	adt3 "github.com/filecoin-project/specs-actors/v3/actors/util/adt"
-)
-
-var _ State = (*state3)(nil)
-
-func load3(store adt.Store, root cid.Cid) (State, error) {
-	out := state3{store: store}
-	err := store.Get(store.Context(), root, &out)
-	if err != nil {
-		return nil, err
-	}
-	return &out, nil
-}
-
-type state3 struct {
-	init3.State
-	store adt.Store
-}
-
-func (s *state3) ResolveAddress(address address.Address) (address.Address, bool, error) {
-	return s.State.ResolveAddress(s.store, address)
-}
-
-func (s *state3) MapAddressToNewID(address address.Address) (address.Address, error) {
-	return s.State.MapAddressToNewID(s.store, address)
-}
-
-func (s *state3) ForEachActor(cb func(id abi.ActorID, address address.Address) error) error {
-	addrs, err := adt3.AsMap(s.store, s.State.AddressMap, builtin3.DefaultHamtBitwidth)
-	if err != nil {
-		return err
-	}
-	var actorID cbg.CborInt
-	return addrs.ForEach(&actorID, func(key string) error {
-		addr, err := address.NewFromBytes([]byte(key))
-		if err != nil {
-			return err
-		}
-		return cb(abi.ActorID(actorID), addr)
-	})
-}
-
-func (s *state3) NetworkName() (dtypes.NetworkName, error) {
-	return dtypes.NetworkName(s.State.NetworkName), nil
-}
-
-func (s *state3) SetNetworkName(name string) error {
-	s.State.NetworkName = name
-	return nil
-}
-
-func (s *state3) Remove(addrs ...address.Address) (err error) {
-	m, err := adt3.AsMap(s.store, s.State.AddressMap, builtin3.DefaultHamtBitwidth)
-	if err != nil {
-		return err
-	}
-	for _, addr := range addrs {
-		if err = m.Delete(abi.AddrKey(addr)); err != nil {
-			return xerrors.Errorf("failed to delete entry for address: %s; err: %w", addr, err)
-		}
-	}
-	amr, err := m.Root()
-	if err != nil {
-		return xerrors.Errorf("failed to get address map root: %w", err)
-	}
-	s.State.AddressMap = amr
-	return nil
-}
-
-func (s *state3) addressMap() (adt.Map, error) {
-	return adt3.AsMap(s.store, s.AddressMap, builtin3.DefaultHamtBitwidth)
-}
@@ -12,7 +12,6 @@ import (
 	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"
-	builtin3 "github.com/filecoin-project/specs-actors/v3/actors/builtin"

 	"github.com/filecoin-project/lotus/chain/actors/adt"
 	"github.com/filecoin-project/lotus/chain/actors/builtin"
@@ -26,14 +25,11 @@ func init() {
 	builtin.RegisterActorState(builtin2.StorageMarketActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
 		return load2(store, root)
 	})
-	builtin.RegisterActorState(builtin3.StorageMarketActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
-		return load3(store, root)
-	})
 }

 var (
-	Address = builtin3.StorageMarketActorAddr
-	Methods = builtin3.MethodsMarket
+	Address = builtin2.StorageMarketActorAddr
+	Methods = builtin2.MethodsMarket
 )

 func Load(store adt.Store, act *types.Actor) (st State, err error) {
@@ -42,8 +38,6 @@ func Load(store adt.Store, act *types.Actor) (st State, err error) {
 		return load0(store, act.Head)
 	case builtin2.StorageMarketActorCodeID:
 		return load2(store, act.Head)
-	case builtin3.StorageMarketActorCodeID:
-		return load3(store, act.Head)
 	}
 	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
 }
@@ -1,205 +0,0 @@
-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"
-
-	market3 "github.com/filecoin-project/specs-actors/v3/actors/builtin/market"
-	adt3 "github.com/filecoin-project/specs-actors/v3/actors/util/adt"
-)
-
-var _ State = (*state3)(nil)
-
-func load3(store adt.Store, root cid.Cid) (State, error) {
-	out := state3{store: store}
-	err := store.Get(store.Context(), root, &out)
-	if err != nil {
-		return nil, err
-	}
-	return &out, nil
-}
-
-type state3 struct {
-	market3.State
-	store adt.Store
-}
-
-func (s *state3) TotalLocked() (abi.TokenAmount, error) {
-	fml := types.BigAdd(s.TotalClientLockedCollateral, s.TotalProviderLockedCollateral)
-	fml = types.BigAdd(fml, s.TotalClientStorageFee)
-	return fml, nil
-}
-
-func (s *state3) BalancesChanged(otherState State) (bool, error) {
-	otherState2, ok := otherState.(*state3)
-	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 *state3) StatesChanged(otherState State) (bool, error) {
-	otherState2, ok := otherState.(*state3)
-	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 *state3) States() (DealStates, error) {
-	stateArray, err := adt3.AsArray(s.store, s.State.States, market3.StatesAmtBitwidth)
-	if err != nil {
-		return nil, err
-	}
-	return &dealStates3{stateArray}, nil
-}
-
-func (s *state3) ProposalsChanged(otherState State) (bool, error) {
-	otherState2, ok := otherState.(*state3)
-	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 *state3) Proposals() (DealProposals, error) {
-	proposalArray, err := adt3.AsArray(s.store, s.State.Proposals, market3.ProposalsAmtBitwidth)
-	if err != nil {
-		return nil, err
-	}
-	return &dealProposals3{proposalArray}, nil
-}
-
-func (s *state3) EscrowTable() (BalanceTable, error) {
-	bt, err := adt3.AsBalanceTable(s.store, s.State.EscrowTable)
-	if err != nil {
-		return nil, err
-	}
-	return &balanceTable3{bt}, nil
-}
-
-func (s *state3) LockedTable() (BalanceTable, error) {
-	bt, err := adt3.AsBalanceTable(s.store, s.State.LockedTable)
-	if err != nil {
-		return nil, err
-	}
-	return &balanceTable3{bt}, nil
-}
-
-func (s *state3) VerifyDealsForActivation(
-	minerAddr address.Address, deals []abi.DealID, currEpoch, sectorExpiry abi.ChainEpoch,
-) (weight, verifiedWeight abi.DealWeight, err error) {
-	w, vw, _, err := market3.ValidateDealsForActivation(&s.State, s.store, deals, minerAddr, sectorExpiry, currEpoch)
-	return w, vw, err
-}
-
-type balanceTable3 struct {
-	*adt3.BalanceTable
-}
-
-func (bt *balanceTable3) ForEach(cb func(address.Address, abi.TokenAmount) error) error {
-	asMap := (*adt3.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 dealStates3 struct {
-	adt.Array
-}
-
-func (s *dealStates3) Get(dealID abi.DealID) (*DealState, bool, error) {
-	var deal2 market3.DealState
-	found, err := s.Array.Get(uint64(dealID), &deal2)
-	if err != nil {
-		return nil, false, err
-	}
-	if !found {
-		return nil, false, nil
-	}
-	deal := fromV3DealState(deal2)
-	return &deal, true, nil
-}
-
-func (s *dealStates3) ForEach(cb func(dealID abi.DealID, ds DealState) error) error {
-	var ds1 market3.DealState
-	return s.Array.ForEach(&ds1, func(idx int64) error {
-		return cb(abi.DealID(idx), fromV3DealState(ds1))
-	})
-}
-
-func (s *dealStates3) decode(val *cbg.Deferred) (*DealState, error) {
-	var ds1 market3.DealState
-	if err := ds1.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil {
-		return nil, err
-	}
-	ds := fromV3DealState(ds1)
-	return &ds, nil
-}
-
-func (s *dealStates3) array() adt.Array {
-	return s.Array
-}
-
-func fromV3DealState(v1 market3.DealState) DealState {
-	return (DealState)(v1)
-}
-
-type dealProposals3 struct {
-	adt.Array
-}
-
-func (s *dealProposals3) Get(dealID abi.DealID) (*DealProposal, bool, error) {
-	var proposal2 market3.DealProposal
-	found, err := s.Array.Get(uint64(dealID), &proposal2)
-	if err != nil {
-		return nil, false, err
-	}
-	if !found {
-		return nil, false, nil
-	}
-	proposal := fromV3DealProposal(proposal2)
-	return &proposal, true, nil
-}
-
-func (s *dealProposals3) ForEach(cb func(dealID abi.DealID, dp DealProposal) error) error {
-	var dp1 market3.DealProposal
-	return s.Array.ForEach(&dp1, func(idx int64) error {
-		return cb(abi.DealID(idx), fromV3DealProposal(dp1))
-	})
-}
-
-func (s *dealProposals3) decode(val *cbg.Deferred) (*DealProposal, error) {
-	var dp1 market3.DealProposal
-	if err := dp1.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil {
-		return nil, err
-	}
-	dp := fromV3DealProposal(dp1)
-	return &dp, nil
-}
-
-func (s *dealProposals3) array() adt.Array {
-	return s.Array
-}
-
-func fromV3DealProposal(v1 market3.DealProposal) DealProposal {
-	return (DealProposal)(v1)
-}
@@ -2,7 +2,6 @@ package miner

 import (
 	"github.com/filecoin-project/go-state-types/big"
-	"github.com/filecoin-project/go-state-types/network"
 	"github.com/ipfs/go-cid"
 	"github.com/libp2p/go-libp2p-core/peer"
 	cbg "github.com/whyrusleeping/cbor-gen"
@@ -21,9 +20,6 @@ import (
 	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"
-	miner2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/miner"
-	builtin3 "github.com/filecoin-project/specs-actors/v3/actors/builtin"
-	miner3 "github.com/filecoin-project/specs-actors/v3/actors/builtin/miner"
 )

 func init() {
@@ -33,14 +29,11 @@ func init() {
 	builtin.RegisterActorState(builtin2.StorageMinerActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
 		return load2(store, root)
 	})
-	builtin.RegisterActorState(builtin3.StorageMinerActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
-		return load3(store, root)
-	})
 }

-var Methods = builtin3.MethodsMiner
+var Methods = builtin2.MethodsMiner

-// Unchanged between v0, v2, and v3 actors
+// Unchanged between v0 and v2 actors
 var WPoStProvingPeriod = miner0.WPoStProvingPeriod
 var WPoStPeriodDeadlines = miner0.WPoStPeriodDeadlines
 var WPoStChallengeWindow = miner0.WPoStChallengeWindow
@@ -49,18 +42,12 @@ var FaultDeclarationCutoff = miner0.FaultDeclarationCutoff

 const MinSectorExpiration = miner0.MinSectorExpiration

-// Not used / checked in v0
-var DeclarationsMax = miner2.DeclarationsMax
-var AddressedSectorsMax = miner2.AddressedSectorsMax
-
 func Load(store adt.Store, act *types.Actor) (st State, err error) {
 	switch act.Code {
 	case builtin0.StorageMinerActorCodeID:
 		return load0(store, act.Head)
 	case builtin2.StorageMinerActorCodeID:
 		return load2(store, act.Head)
-	case builtin3.StorageMinerActorCodeID:
-		return load3(store, act.Head)
 	}
 	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
 }
@@ -104,10 +91,9 @@ type State interface {
 type Deadline interface {
 	LoadPartition(idx uint64) (Partition, error)
 	ForEachPartition(cb func(idx uint64, part Partition) error) error
-	PartitionsPoSted() (bitfield.BitField, error)
+	PostSubmissions() (bitfield.BitField, error)

 	PartitionsChanged(Deadline) (bool, error)
-	DisputableProofCount() (uint64, error)
 }

 type Partition interface {
@@ -151,60 +137,6 @@ type DeclareFaultsParams = miner0.DeclareFaultsParams
 type DeclareFaultsRecoveredParams = miner0.DeclareFaultsRecoveredParams
 type SubmitWindowedPoStParams = miner0.SubmitWindowedPoStParams
 type ProveCommitSectorParams = miner0.ProveCommitSectorParams
-type DisputeWindowedPoStParams = miner3.DisputeWindowedPoStParams
-
-func PreferredSealProofTypeFromWindowPoStType(nver network.Version, proof abi.RegisteredPoStProof) (abi.RegisteredSealProof, error) {
-	// We added support for the new proofs in network version 7, and removed support for the old
-	// ones in network version 8.
-	if nver < network.Version7 {
-		switch proof {
-		case abi.RegisteredPoStProof_StackedDrgWindow2KiBV1:
-			return abi.RegisteredSealProof_StackedDrg2KiBV1, nil
-		case abi.RegisteredPoStProof_StackedDrgWindow8MiBV1:
-			return abi.RegisteredSealProof_StackedDrg8MiBV1, nil
-		case abi.RegisteredPoStProof_StackedDrgWindow512MiBV1:
-			return abi.RegisteredSealProof_StackedDrg512MiBV1, nil
-		case abi.RegisteredPoStProof_StackedDrgWindow32GiBV1:
-			return abi.RegisteredSealProof_StackedDrg32GiBV1, nil
-		case abi.RegisteredPoStProof_StackedDrgWindow64GiBV1:
-			return abi.RegisteredSealProof_StackedDrg64GiBV1, nil
-		default:
-			return -1, xerrors.Errorf("unrecognized window post type: %d", proof)
-		}
-	}
-
-	switch proof {
-	case abi.RegisteredPoStProof_StackedDrgWindow2KiBV1:
-		return abi.RegisteredSealProof_StackedDrg2KiBV1_1, nil
-	case abi.RegisteredPoStProof_StackedDrgWindow8MiBV1:
-		return abi.RegisteredSealProof_StackedDrg8MiBV1_1, nil
-	case abi.RegisteredPoStProof_StackedDrgWindow512MiBV1:
-		return abi.RegisteredSealProof_StackedDrg512MiBV1_1, nil
-	case abi.RegisteredPoStProof_StackedDrgWindow32GiBV1:
-		return abi.RegisteredSealProof_StackedDrg32GiBV1_1, nil
-	case abi.RegisteredPoStProof_StackedDrgWindow64GiBV1:
-		return abi.RegisteredSealProof_StackedDrg64GiBV1_1, nil
-	default:
-		return -1, xerrors.Errorf("unrecognized window post type: %d", proof)
-	}
-}
-
-func WinningPoStProofTypeFromWindowPoStProofType(nver network.Version, proof abi.RegisteredPoStProof) (abi.RegisteredPoStProof, error) {
-	switch proof {
-	case abi.RegisteredPoStProof_StackedDrgWindow2KiBV1:
-		return abi.RegisteredPoStProof_StackedDrgWinning2KiBV1, nil
-	case abi.RegisteredPoStProof_StackedDrgWindow8MiBV1:
-		return abi.RegisteredPoStProof_StackedDrgWinning8MiBV1, nil
-	case abi.RegisteredPoStProof_StackedDrgWindow512MiBV1:
-		return abi.RegisteredPoStProof_StackedDrgWinning512MiBV1, nil
-	case abi.RegisteredPoStProof_StackedDrgWindow32GiBV1:
-		return abi.RegisteredPoStProof_StackedDrgWinning32GiBV1, nil
-	case abi.RegisteredPoStProof_StackedDrgWindow64GiBV1:
-		return abi.RegisteredPoStProof_StackedDrgWinning64GiBV1, nil
-	default:
-		return -1, xerrors.Errorf("unknown proof type %d", proof)
-	}
-}

 type MinerInfo struct {
 	Owner                      address.Address   // Must be an ID-address.
@@ -214,7 +146,7 @@ type MinerInfo struct {
 	WorkerChangeEpoch          abi.ChainEpoch
 	PeerId                     *peer.ID
 	Multiaddrs                 []abi.Multiaddrs
-	WindowPoStProofType        abi.RegisteredPoStProof
+	SealProofType              abi.RegisteredSealProof
 	SectorSize                 abi.SectorSize
 	WindowPoStPartitionSectors uint64
 	ConsensusFaultElapsed      abi.ChainEpoch
@@ -4,8 +4,6 @@ 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) {
@@ -28,42 +26,3 @@ 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")
-}
@@ -297,11 +297,6 @@ func (s *state0) Info() (MinerInfo, error) {
 		pid = &peerID
 	}

-	wpp, err := info.SealProofType.RegisteredWindowPoStProof()
-	if err != nil {
-		return MinerInfo{}, err
-	}
-
 	mi := MinerInfo{
 		Owner:            info.Owner,
 		Worker:           info.Worker,
@@ -312,7 +307,7 @@ func (s *state0) Info() (MinerInfo, error) {

 		PeerId:                     pid,
 		Multiaddrs:                 info.Multiaddrs,
-		WindowPoStProofType:        wpp,
+		SealProofType:              info.SealProofType,
 		SectorSize:                 info.SectorSize,
 		WindowPoStPartitionSectors: info.WindowPoStPartitionSectors,
 		ConsensusFaultElapsed:      -1,
@@ -387,15 +382,10 @@ func (d *deadline0) PartitionsChanged(other Deadline) (bool, error) {
 	return !d.Deadline.Partitions.Equals(other0.Deadline.Partitions), nil
 }

-func (d *deadline0) PartitionsPoSted() (bitfield.BitField, error) {
+func (d *deadline0) PostSubmissions() (bitfield.BitField, error) {
 	return d.Deadline.PostSubmissions, nil
 }

-func (d *deadline0) DisputableProofCount() (uint64, error) {
-	// field doesn't exist until v3
-	return 0, nil
-}
-
 func (p *partition0) AllSectors() (bitfield.BitField, error) {
 	return p.Partition.Sectors, nil
 }
@@ -296,11 +296,6 @@ func (s *state2) Info() (MinerInfo, error) {
 		pid = &peerID
 	}

-	wpp, err := info.SealProofType.RegisteredWindowPoStProof()
-	if err != nil {
-		return MinerInfo{}, err
-	}
-
 	mi := MinerInfo{
 		Owner:            info.Owner,
 		Worker:           info.Worker,
@@ -311,7 +306,7 @@ func (s *state2) Info() (MinerInfo, error) {

 		PeerId:                     pid,
 		Multiaddrs:                 info.Multiaddrs,
-		WindowPoStProofType:        wpp,
+		SealProofType:              info.SealProofType,
 		SectorSize:                 info.SectorSize,
 		WindowPoStPartitionSectors: info.WindowPoStPartitionSectors,
 		ConsensusFaultElapsed:      info.ConsensusFaultElapsed,
@@ -386,15 +381,10 @@ func (d *deadline2) PartitionsChanged(other Deadline) (bool, error) {
 	return !d.Deadline.Partitions.Equals(other2.Deadline.Partitions), nil
 }

-func (d *deadline2) PartitionsPoSted() (bitfield.BitField, error) {
+func (d *deadline2) PostSubmissions() (bitfield.BitField, error) {
 	return d.Deadline.PostSubmissions, nil
 }

-func (d *deadline2) DisputableProofCount() (uint64, error) {
-	// field doesn't exist until v3
-	return 0, nil
-}
-
 func (p *partition2) AllSectors() (bitfield.BitField, error) {
 	return p.Partition.Sectors, nil
 }
@@ -1,434 +0,0 @@
-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"
-
-	builtin3 "github.com/filecoin-project/specs-actors/v3/actors/builtin"
-	miner3 "github.com/filecoin-project/specs-actors/v3/actors/builtin/miner"
-	adt3 "github.com/filecoin-project/specs-actors/v3/actors/util/adt"
-)
-
-var _ State = (*state3)(nil)
-
-func load3(store adt.Store, root cid.Cid) (State, error) {
-	out := state3{store: store}
-	err := store.Get(store.Context(), root, &out)
-	if err != nil {
-		return nil, err
-	}
-	return &out, nil
-}
-
-type state3 struct {
-	miner3.State
-	store adt.Store
-}
-
-type deadline3 struct {
-	miner3.Deadline
-	store adt.Store
-}
-
-type partition3 struct {
-	miner3.Partition
-	store adt.Store
-}
-
-func (s *state3) 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 *state3) VestedFunds(epoch abi.ChainEpoch) (abi.TokenAmount, error) {
-	return s.CheckVestedFunds(s.store, epoch)
-}
-
-func (s *state3) LockedFunds() (LockedFunds, error) {
-	return LockedFunds{
-		VestingFunds:             s.State.LockedFunds,
-		InitialPledgeRequirement: s.State.InitialPledge,
-		PreCommitDeposits:        s.State.PreCommitDeposits,
-	}, nil
-}
-
-func (s *state3) FeeDebt() (abi.TokenAmount, error) {
-	return s.State.FeeDebt, nil
-}
-
-func (s *state3) InitialPledge() (abi.TokenAmount, error) {
-	return s.State.InitialPledge, nil
-}
-
-func (s *state3) PreCommitDeposits() (abi.TokenAmount, error) {
-	return s.State.PreCommitDeposits, nil
-}
-
-func (s *state3) GetSector(num abi.SectorNumber) (*SectorOnChainInfo, error) {
-	info, ok, err := s.State.GetSector(s.store, num)
-	if !ok || err != nil {
-		return nil, err
-	}
-
-	ret := fromV3SectorOnChainInfo(*info)
-	return &ret, nil
-}
-
-func (s *state3) 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 *state3) 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 *miner3.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 *state3) 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 *miner3.Deadline) error {
-		partitions, err := dl.PartitionsArray(s.store)
-		if err != nil {
-			return err
-		}
-		quant := s.State.QuantSpecForDeadline(dlIdx)
-		var part miner3.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 := miner3.LoadExpirationQueue(s.store, part.ExpirationsEpochs, quant, miner3.PartitionExpirationAmtBitwidth)
-			if err != nil {
-				return err
-			}
-			var exp miner3.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 *state3) GetPrecommittedSector(num abi.SectorNumber) (*SectorPreCommitOnChainInfo, error) {
-	info, ok, err := s.State.GetPrecommittedSector(s.store, num)
-	if !ok || err != nil {
-		return nil, err
-	}
-
-	ret := fromV3SectorPreCommitOnChainInfo(*info)
-
-	return &ret, nil
-}
-
-func (s *state3) LoadSectors(snos *bitfield.BitField) ([]*SectorOnChainInfo, error) {
-	sectors, err := miner3.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 miner3.SectorOnChainInfo
-		if err := sectors.ForEach(&info2, func(_ int64) error {
-			info := fromV3SectorOnChainInfo(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 := fromV3SectorOnChainInfo(*info2)
-		infos[i] = &info
-	}
-	return infos, nil
-}
-
-func (s *state3) 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 *state3) 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 &deadline3{*dl, s.store}, nil
-}
-
-func (s *state3) 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 *miner3.Deadline) error {
-		return cb(i, &deadline3{*dl, s.store})
-	})
-}
-
-func (s *state3) NumDeadlines() (uint64, error) {
-	return miner3.WPoStPeriodDeadlines, nil
-}
-
-func (s *state3) DeadlinesChanged(other State) (bool, error) {
-	other2, ok := other.(*state3)
-	if !ok {
-		// treat an upgrade as a change, always
-		return true, nil
-	}
-
-	return !s.State.Deadlines.Equals(other2.Deadlines), nil
-}
-
-func (s *state3) MinerInfoChanged(other State) (bool, error) {
-	other0, ok := other.(*state3)
-	if !ok {
-		// treat an upgrade as a change, always
-		return true, nil
-	}
-	return !s.State.Info.Equals(other0.State.Info), nil
-}
-
-func (s *state3) Info() (MinerInfo, error) {
-	info, err := s.State.GetInfo(s.store)
-	if err != nil {
-		return MinerInfo{}, err
-	}
-
-	var pid *peer.ID
-	if peerID, err := peer.IDFromBytes(info.PeerId); err == nil {
-		pid = &peerID
-	}
-
-	mi := MinerInfo{
-		Owner:            info.Owner,
-		Worker:           info.Worker,
-		ControlAddresses: info.ControlAddresses,
-
-		NewWorker:         address.Undef,
-		WorkerChangeEpoch: -1,
-
-		PeerId:                     pid,
-		Multiaddrs:                 info.Multiaddrs,
-		WindowPoStProofType:        info.WindowPoStProofType,
-		SectorSize:                 info.SectorSize,
-		WindowPoStPartitionSectors: info.WindowPoStPartitionSectors,
-		ConsensusFaultElapsed:      info.ConsensusFaultElapsed,
-	}
-
-	if info.PendingWorkerKey != nil {
-		mi.NewWorker = info.PendingWorkerKey.NewWorker
-		mi.WorkerChangeEpoch = info.PendingWorkerKey.EffectiveAt
-	}
-
-	return mi, nil
-}
-
-func (s *state3) DeadlineInfo(epoch abi.ChainEpoch) (*dline.Info, error) {
-	return s.State.DeadlineInfo(epoch), nil
-}
-
-func (s *state3) sectors() (adt.Array, error) {
-	return adt3.AsArray(s.store, s.Sectors, miner3.SectorsAmtBitwidth)
-}
-
-func (s *state3) decodeSectorOnChainInfo(val *cbg.Deferred) (SectorOnChainInfo, error) {
-	var si miner3.SectorOnChainInfo
-	err := si.UnmarshalCBOR(bytes.NewReader(val.Raw))
-	if err != nil {
-		return SectorOnChainInfo{}, err
-	}
-
-	return fromV3SectorOnChainInfo(si), nil
-}
-
-func (s *state3) precommits() (adt.Map, error) {
-	return adt3.AsMap(s.store, s.PreCommittedSectors, builtin3.DefaultHamtBitwidth)
-}
-
-func (s *state3) decodeSectorPreCommitOnChainInfo(val *cbg.Deferred) (SectorPreCommitOnChainInfo, error) {
-	var sp miner3.SectorPreCommitOnChainInfo
-	err := sp.UnmarshalCBOR(bytes.NewReader(val.Raw))
-	if err != nil {
-		return SectorPreCommitOnChainInfo{}, err
-	}
-
-	return fromV3SectorPreCommitOnChainInfo(sp), nil
-}
-
-func (d *deadline3) LoadPartition(idx uint64) (Partition, error) {
-	p, err := d.Deadline.LoadPartition(d.store, idx)
-	if err != nil {
-		return nil, err
-	}
-	return &partition3{*p, d.store}, nil
-}
-
-func (d *deadline3) ForEachPartition(cb func(uint64, Partition) error) error {
-	ps, err := d.Deadline.PartitionsArray(d.store)
-	if err != nil {
-		return err
-	}
-	var part miner3.Partition
-	return ps.ForEach(&part, func(i int64) error {
-		return cb(uint64(i), &partition3{part, d.store})
-	})
-}
-
-func (d *deadline3) PartitionsChanged(other Deadline) (bool, error) {
-	other2, ok := other.(*deadline3)
-	if !ok {
-		// treat an upgrade as a change, always
-		return true, nil
-	}
-
-	return !d.Deadline.Partitions.Equals(other2.Deadline.Partitions), nil
-}
-
-func (d *deadline3) PartitionsPoSted() (bitfield.BitField, error) {
-	return d.Deadline.PartitionsPoSted, nil
-}
-
-func (d *deadline3) DisputableProofCount() (uint64, error) {
-	ops, err := d.OptimisticProofsSnapshotArray(d.store)
-	if err != nil {
-		return 0, err
-	}
-
-	return ops.Length(), nil
-}
-
-func (p *partition3) AllSectors() (bitfield.BitField, error) {
-	return p.Partition.Sectors, nil
-}
-
-func (p *partition3) FaultySectors() (bitfield.BitField, error) {
-	return p.Partition.Faults, nil
-}
-
-func (p *partition3) RecoveringSectors() (bitfield.BitField, error) {
-	return p.Partition.Recoveries, nil
-}
-
-func fromV3SectorOnChainInfo(v3 miner3.SectorOnChainInfo) SectorOnChainInfo {
-	return SectorOnChainInfo{
-		SectorNumber:          v3.SectorNumber,
-		SealProof:             v3.SealProof,
-		SealedCID:             v3.SealedCID,
-		DealIDs:               v3.DealIDs,
-		Activation:            v3.Activation,
-		Expiration:            v3.Expiration,
-		DealWeight:            v3.DealWeight,
-		VerifiedDealWeight:    v3.VerifiedDealWeight,
-		InitialPledge:         v3.InitialPledge,
-		ExpectedDayReward:     v3.ExpectedDayReward,
-		ExpectedStoragePledge: v3.ExpectedStoragePledge,
-	}
-}
-
-func fromV3SectorPreCommitOnChainInfo(v3 miner3.SectorPreCommitOnChainInfo) SectorPreCommitOnChainInfo {
-	return SectorPreCommitOnChainInfo{
-		Info:               (SectorPreCommitInfo)(v3.Info),
-		PreCommitDeposit:   v3.PreCommitDeposit,
-		PreCommitEpoch:     v3.PreCommitEpoch,
-		DealWeight:         v3.DealWeight,
-		VerifiedDealWeight: v3.VerifiedDealWeight,
-	}
-}
@@ -9,14 +9,14 @@ import (
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"

-	builtin3 "github.com/filecoin-project/specs-actors/v3/actors/builtin"
-	multisig3 "github.com/filecoin-project/specs-actors/v3/actors/builtin/multisig"
+	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 = builtin3.MethodsMultisig
+var Methods = builtin2.MethodsMultisig

 func Message(version actors.Version, from address.Address) MessageBuilder {
 	switch version {
@@ -24,8 +24,6 @@ func Message(version actors.Version, from address.Address) MessageBuilder {
 		return message0{from}
 	case actors.Version2:
 		return message2{message0{from}}
-	case actors.Version3:
-		return message3{message0{from}}
 	default:
 		panic(fmt.Sprintf("unsupported actors version: %d", version))
 	}
@@ -49,11 +47,11 @@ type MessageBuilder interface {
 }

 // this type is the same between v0 and v2
-type ProposalHashData = multisig3.ProposalHashData
-type ProposeReturn = multisig3.ProposeReturn
+type ProposalHashData = multisig2.ProposalHashData
+type ProposeReturn = multisig2.ProposeReturn

 func txnParams(id uint64, data *ProposalHashData) ([]byte, error) {
-	params := multisig3.TxnIDParams{ID: multisig3.TxnID(id)}
+	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)
@@ -1,71 +0,0 @@
-package multisig
-
-import (
-	"golang.org/x/xerrors"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/abi"
-
-	builtin3 "github.com/filecoin-project/specs-actors/v3/actors/builtin"
-	init3 "github.com/filecoin-project/specs-actors/v3/actors/builtin/init"
-	multisig3 "github.com/filecoin-project/specs-actors/v3/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 message3 struct{ message0 }
-
-func (m message3) 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 := &multisig3.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 := &init3.ExecParams{
-		CodeCID:           builtin3.MultisigActorCodeID,
-		ConstructorParams: enc,
-	}
-
-	enc, actErr = actors.SerializeParams(execParams)
-	if actErr != nil {
-		return nil, actErr
-	}
-
-	return &types.Message{
-		To:     init_.Address,
-		From:   m.from,
-		Method: builtin3.MethodsInit.Exec,
-		Params: enc,
-		Value:  initialAmount,
-	}, nil
-}
@@ -12,7 +12,6 @@ import (
 	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"
-	builtin3 "github.com/filecoin-project/specs-actors/v3/actors/builtin"

 	"github.com/filecoin-project/lotus/chain/actors/adt"
 	"github.com/filecoin-project/lotus/chain/actors/builtin"
@@ -26,9 +25,6 @@ func init() {
 	builtin.RegisterActorState(builtin2.MultisigActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
 		return load2(store, root)
 	})
-	builtin.RegisterActorState(builtin3.MultisigActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
-		return load3(store, root)
-	})
 }

 func Load(store adt.Store, act *types.Actor) (State, error) {
@@ -37,8 +33,6 @@ func Load(store adt.Store, act *types.Actor) (State, error) {
 		return load0(store, act.Head)
 	case builtin2.MultisigActorCodeID:
 		return load2(store, act.Head)
-	case builtin3.MultisigActorCodeID:
-		return load3(store, act.Head)
 	}
 	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
 }
@@ -13,8 +13,8 @@ import (
 	"github.com/filecoin-project/lotus/chain/actors/adt"

 	msig0 "github.com/filecoin-project/specs-actors/actors/builtin/multisig"
-	multisig0 "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)
@@ -1,95 +0,0 @@
-package multisig
-
-import (
-	"bytes"
-	"encoding/binary"
-
-	adt3 "github.com/filecoin-project/specs-actors/v3/actors/util/adt"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/ipfs/go-cid"
-	cbg "github.com/whyrusleeping/cbor-gen"
-	"golang.org/x/xerrors"
-
-	"github.com/filecoin-project/lotus/chain/actors/adt"
-
-	builtin3 "github.com/filecoin-project/specs-actors/v3/actors/builtin"
-	msig3 "github.com/filecoin-project/specs-actors/v3/actors/builtin/multisig"
-)
-
-var _ State = (*state3)(nil)
-
-func load3(store adt.Store, root cid.Cid) (State, error) {
-	out := state3{store: store}
-	err := store.Get(store.Context(), root, &out)
-	if err != nil {
-		return nil, err
-	}
-	return &out, nil
-}
-
-type state3 struct {
-	msig3.State
-	store adt.Store
-}
-
-func (s *state3) LockedBalance(currEpoch abi.ChainEpoch) (abi.TokenAmount, error) {
-	return s.State.AmountLocked(currEpoch - s.State.StartEpoch), nil
-}
-
-func (s *state3) StartEpoch() (abi.ChainEpoch, error) {
-	return s.State.StartEpoch, nil
-}
-
-func (s *state3) UnlockDuration() (abi.ChainEpoch, error) {
-	return s.State.UnlockDuration, nil
-}
-
-func (s *state3) InitialBalance() (abi.TokenAmount, error) {
-	return s.State.InitialBalance, nil
-}
-
-func (s *state3) Threshold() (uint64, error) {
-	return s.State.NumApprovalsThreshold, nil
-}
-
-func (s *state3) Signers() ([]address.Address, error) {
-	return s.State.Signers, nil
-}
-
-func (s *state3) ForEachPendingTxn(cb func(id int64, txn Transaction) error) error {
-	arr, err := adt3.AsMap(s.store, s.State.PendingTxns, builtin3.DefaultHamtBitwidth)
-	if err != nil {
-		return err
-	}
-	var out msig3.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 *state3) PendingTxnChanged(other State) (bool, error) {
-	other2, ok := other.(*state3)
-	if !ok {
-		// treat an upgrade as a change, always
-		return true, nil
-	}
-	return !s.State.PendingTxns.Equals(other2.PendingTxns), nil
-}
-
-func (s *state3) transactions() (adt.Map, error) {
-	return adt3.AsMap(s.store, s.PendingTxns, builtin3.DefaultHamtBitwidth)
-}
-
-func (s *state3) decodeTransaction(val *cbg.Deferred) (Transaction, error) {
-	var tx msig3.Transaction
-	if err := tx.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil {
-		return Transaction{}, err
-	}
-	return tx, nil
-}
@@ -8,10 +8,10 @@ import (
 	"github.com/filecoin-project/lotus/chain/actors"
 	"github.com/filecoin-project/lotus/chain/types"

-	builtin3 "github.com/filecoin-project/specs-actors/v3/actors/builtin"
+	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
 )

-var Methods = builtin3.MethodsPaych
+var Methods = builtin2.MethodsPaych

 func Message(version actors.Version, from address.Address) MessageBuilder {
 	switch version {
@@ -19,8 +19,6 @@ func Message(version actors.Version, from address.Address) MessageBuilder {
 		return message0{from}
 	case actors.Version2:
 		return message2{from}
-	case actors.Version3:
-		return message3{from}
 	default:
 		panic(fmt.Sprintf("unsupported actors version: %d", version))
 	}
@@ -1,74 +0,0 @@
-package paych
-
-import (
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/abi"
-
-	builtin3 "github.com/filecoin-project/specs-actors/v3/actors/builtin"
-	init3 "github.com/filecoin-project/specs-actors/v3/actors/builtin/init"
-	paych3 "github.com/filecoin-project/specs-actors/v3/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 message3 struct{ from address.Address }
-
-func (m message3) Create(to address.Address, initialAmount abi.TokenAmount) (*types.Message, error) {
-	params, aerr := actors.SerializeParams(&paych3.ConstructorParams{From: m.from, To: to})
-	if aerr != nil {
-		return nil, aerr
-	}
-	enc, aerr := actors.SerializeParams(&init3.ExecParams{
-		CodeCID:           builtin3.PaymentChannelActorCodeID,
-		ConstructorParams: params,
-	})
-	if aerr != nil {
-		return nil, aerr
-	}
-
-	return &types.Message{
-		To:     init_.Address,
-		From:   m.from,
-		Value:  initialAmount,
-		Method: builtin3.MethodsInit.Exec,
-		Params: enc,
-	}, nil
-}
-
-func (m message3) Update(paych address.Address, sv *SignedVoucher, secret []byte) (*types.Message, error) {
-	params, aerr := actors.SerializeParams(&paych3.UpdateChannelStateParams{
-		Sv:     *sv,
-		Secret: secret,
-	})
-	if aerr != nil {
-		return nil, aerr
-	}
-
-	return &types.Message{
-		To:     paych,
-		From:   m.from,
-		Value:  abi.NewTokenAmount(0),
-		Method: builtin3.MethodsPaych.UpdateChannelState,
-		Params: params,
-	}, nil
-}
-
-func (m message3) Settle(paych address.Address) (*types.Message, error) {
-	return &types.Message{
-		To:     paych,
-		From:   m.from,
-		Value:  abi.NewTokenAmount(0),
-		Method: builtin3.MethodsPaych.Settle,
-	}, nil
-}
-
-func (m message3) Collect(paych address.Address) (*types.Message, error) {
-	return &types.Message{
-		To:     paych,
-		From:   m.from,
-		Value:  abi.NewTokenAmount(0),
-		Method: builtin3.MethodsPaych.Collect,
-	}, nil
-}
@@ -15,7 +15,6 @@ import (
 	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"
-	builtin3 "github.com/filecoin-project/specs-actors/v3/actors/builtin"

 	"github.com/filecoin-project/lotus/chain/actors/adt"
 	"github.com/filecoin-project/lotus/chain/actors/builtin"
@@ -29,9 +28,6 @@ func init() {
 	builtin.RegisterActorState(builtin2.PaymentChannelActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
 		return load2(store, root)
 	})
-	builtin.RegisterActorState(builtin3.PaymentChannelActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
-		return load3(store, root)
-	})
 }

 // Load returns an abstract copy of payment channel state, irregardless of actor version
@@ -41,8 +37,6 @@ func Load(store adt.Store, act *types.Actor) (State, error) {
 		return load0(store, act.Head)
 	case builtin2.PaymentChannelActorCodeID:
 		return load2(store, act.Head)
-	case builtin3.PaymentChannelActorCodeID:
-		return load3(store, act.Head)
 	}
 	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
 }
@@ -1,104 +0,0 @@
-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"
-
-	paych3 "github.com/filecoin-project/specs-actors/v3/actors/builtin/paych"
-	adt3 "github.com/filecoin-project/specs-actors/v3/actors/util/adt"
-)
-
-var _ State = (*state3)(nil)
-
-func load3(store adt.Store, root cid.Cid) (State, error) {
-	out := state3{store: store}
-	err := store.Get(store.Context(), root, &out)
-	if err != nil {
-		return nil, err
-	}
-	return &out, nil
-}
-
-type state3 struct {
-	paych3.State
-	store adt.Store
-	lsAmt *adt3.Array
-}
-
-// Channel owner, who has funded the actor
-func (s *state3) From() (address.Address, error) {
-	return s.State.From, nil
-}
-
-// Recipient of payouts from channel
-func (s *state3) To() (address.Address, error) {
-	return s.State.To, nil
-}
-
-// Height at which the channel can be `Collected`
-func (s *state3) SettlingAt() (abi.ChainEpoch, error) {
-	return s.State.SettlingAt, nil
-}
-
-// Amount successfully redeemed through the payment channel, paid out on `Collect()`
-func (s *state3) ToSend() (abi.TokenAmount, error) {
-	return s.State.ToSend, nil
-}
-
-func (s *state3) getOrLoadLsAmt() (*adt3.Array, error) {
-	if s.lsAmt != nil {
-		return s.lsAmt, nil
-	}
-
-	// Get the lane state from the chain
-	lsamt, err := adt3.AsArray(s.store, s.State.LaneStates, paych3.LaneStatesAmtBitwidth)
-	if err != nil {
-		return nil, err
-	}
-
-	s.lsAmt = lsamt
-	return lsamt, nil
-}
-
-// Get total number of lanes
-func (s *state3) LaneCount() (uint64, error) {
-	lsamt, err := s.getOrLoadLsAmt()
-	if err != nil {
-		return 0, err
-	}
-	return lsamt.Length(), nil
-}
-
-// Iterate lane states
-func (s *state3) 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 paych3.LaneState
-	return lsamt.ForEach(&ls, func(i int64) error {
-		return cb(uint64(i), &laneState3{ls})
-	})
-}
-
-type laneState3 struct {
-	paych3.LaneState
-}
-
-func (ls *laneState3) Redeemed() (big.Int, error) {
-	return ls.LaneState.Redeemed, nil
-}
-
-func (ls *laneState3) Nonce() (uint64, error) {
-	return ls.LaneState.Nonce, nil
-}
@@ -16,7 +16,6 @@ import (

 	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
 	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
-	builtin3 "github.com/filecoin-project/specs-actors/v3/actors/builtin"
 )

 func init() {
@@ -26,14 +25,11 @@ func init() {
 	builtin.RegisterActorState(builtin2.StoragePowerActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
 		return load2(store, root)
 	})
-	builtin.RegisterActorState(builtin3.StoragePowerActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
-		return load3(store, root)
-	})
 }

 var (
-	Address = builtin3.StoragePowerActorAddr
-	Methods = builtin3.MethodsPower
+	Address = builtin2.StoragePowerActorAddr
+	Methods = builtin2.MethodsPower
 )

 func Load(store adt.Store, act *types.Actor) (st State, err error) {
@@ -42,8 +38,6 @@ func Load(store adt.Store, act *types.Actor) (st State, err error) {
 		return load0(store, act.Head)
 	case builtin2.StoragePowerActorCodeID:
 		return load2(store, act.Head)
-	case builtin3.StoragePowerActorCodeID:
-		return load3(store, act.Head)
 	}
 	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
 }
@@ -1,149 +0,0 @@
-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"
-
-	builtin3 "github.com/filecoin-project/specs-actors/v3/actors/builtin"
-	power3 "github.com/filecoin-project/specs-actors/v3/actors/builtin/power"
-	adt3 "github.com/filecoin-project/specs-actors/v3/actors/util/adt"
-)
-
-var _ State = (*state3)(nil)
-
-func load3(store adt.Store, root cid.Cid) (State, error) {
-	out := state3{store: store}
-	err := store.Get(store.Context(), root, &out)
-	if err != nil {
-		return nil, err
-	}
-	return &out, nil
-}
-
-type state3 struct {
-	power3.State
-	store adt.Store
-}
-
-func (s *state3) TotalLocked() (abi.TokenAmount, error) {
-	return s.TotalPledgeCollateral, nil
-}
-
-func (s *state3) 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 *state3) TotalCommitted() (Claim, error) {
-	return Claim{
-		RawBytePower:    s.TotalBytesCommitted,
-		QualityAdjPower: s.TotalQABytesCommitted,
-	}, nil
-}
-
-func (s *state3) MinerPower(addr address.Address) (Claim, bool, error) {
-	claims, err := s.claims()
-	if err != nil {
-		return Claim{}, false, err
-	}
-	var claim power3.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 *state3) MinerNominalPowerMeetsConsensusMinimum(a address.Address) (bool, error) {
-	return s.State.MinerNominalPowerMeetsConsensusMinimum(s.store, a)
-}
-
-func (s *state3) TotalPowerSmoothed() (builtin.FilterEstimate, error) {
-	return builtin.FromV3FilterEstimate(s.State.ThisEpochQAPowerSmoothed), nil
-}
-
-func (s *state3) MinerCounts() (uint64, uint64, error) {
-	return uint64(s.State.MinerAboveMinPowerCount), uint64(s.State.MinerCount), nil
-}
-
-func (s *state3) ListAllMiners() ([]address.Address, error) {
-	claims, err := s.claims()
-	if err != nil {
-		return nil, err
-	}
-
-	var miners []address.Address
-	err = claims.ForEach(nil, func(k string) error {
-		a, err := address.NewFromBytes([]byte(k))
-		if err != nil {
-			return err
-		}
-		miners = append(miners, a)
-		return nil
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	return miners, nil
-}
-
-func (s *state3) ForEachClaim(cb func(miner address.Address, claim Claim) error) error {
-	claims, err := s.claims()
-	if err != nil {
-		return err
-	}
-
-	var claim power3.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 *state3) ClaimsChanged(other State) (bool, error) {
-	other2, ok := other.(*state3)
-	if !ok {
-		// treat an upgrade as a change, always
-		return true, nil
-	}
-	return !s.State.Claims.Equals(other2.State.Claims), nil
-}
-
-func (s *state3) claims() (adt.Map, error) {
-	return adt3.AsMap(s.store, s.Claims, builtin3.DefaultHamtBitwidth)
-}
-
-func (s *state3) decodeClaim(val *cbg.Deferred) (Claim, error) {
-	var ci power3.Claim
-	if err := ci.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil {
-		return Claim{}, err
-	}
-	return fromV3Claim(ci), nil
-}
-
-func fromV3Claim(v3 power3.Claim) Claim {
-	return Claim{
-		RawBytePower:    v3.RawBytePower,
-		QualityAdjPower: v3.QualityAdjPower,
-	}
-}
@@ -9,7 +9,6 @@ import (
 	"github.com/filecoin-project/go-state-types/cbor"
 	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
 	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
-	builtin3 "github.com/filecoin-project/specs-actors/v3/actors/builtin"

 	"github.com/filecoin-project/lotus/chain/actors/adt"
 	"github.com/filecoin-project/lotus/chain/actors/builtin"
@@ -23,14 +22,11 @@ func init() {
 	builtin.RegisterActorState(builtin2.RewardActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
 		return load2(store, root)
 	})
-	builtin.RegisterActorState(builtin3.RewardActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
-		return load3(store, root)
-	})
 }

 var (
-	Address = builtin3.RewardActorAddr
-	Methods = builtin3.MethodsReward
+	Address = builtin2.RewardActorAddr
+	Methods = builtin2.MethodsReward
 )

 func Load(store adt.Store, act *types.Actor) (st State, err error) {
@@ -39,8 +35,6 @@ func Load(store adt.Store, act *types.Actor) (st State, err error) {
 		return load0(store, act.Head)
 	case builtin2.RewardActorCodeID:
 		return load2(store, act.Head)
-	case builtin3.RewardActorCodeID:
-		return load3(store, act.Head)
 	}
 	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
 }
@@ -1,86 +0,0 @@
-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"
-
-	miner3 "github.com/filecoin-project/specs-actors/v3/actors/builtin/miner"
-	reward3 "github.com/filecoin-project/specs-actors/v3/actors/builtin/reward"
-	smoothing3 "github.com/filecoin-project/specs-actors/v3/actors/util/smoothing"
-)
-
-var _ State = (*state3)(nil)
-
-func load3(store adt.Store, root cid.Cid) (State, error) {
-	out := state3{store: store}
-	err := store.Get(store.Context(), root, &out)
-	if err != nil {
-		return nil, err
-	}
-	return &out, nil
-}
-
-type state3 struct {
-	reward3.State
-	store adt.Store
-}
-
-func (s *state3) ThisEpochReward() (abi.TokenAmount, error) {
-	return s.State.ThisEpochReward, nil
-}
-
-func (s *state3) ThisEpochRewardSmoothed() (builtin.FilterEstimate, error) {
-	return builtin.FilterEstimate{
-		PositionEstimate: s.State.ThisEpochRewardSmoothed.PositionEstimate,
-		VelocityEstimate: s.State.ThisEpochRewardSmoothed.VelocityEstimate,
-	}, nil
-}
-
-func (s *state3) ThisEpochBaselinePower() (abi.StoragePower, error) {
-	return s.State.ThisEpochBaselinePower, nil
-}
-
-func (s *state3) TotalStoragePowerReward() (abi.TokenAmount, error) {
-	return s.State.TotalStoragePowerReward, nil
-}
-
-func (s *state3) EffectiveBaselinePower() (abi.StoragePower, error) {
-	return s.State.EffectiveBaselinePower, nil
-}
-
-func (s *state3) EffectiveNetworkTime() (abi.ChainEpoch, error) {
-	return s.State.EffectiveNetworkTime, nil
-}
-
-func (s *state3) CumsumBaseline() (reward3.Spacetime, error) {
-	return s.State.CumsumBaseline, nil
-}
-
-func (s *state3) CumsumRealized() (reward3.Spacetime, error) {
-	return s.State.CumsumRealized, nil
-}
-
-func (s *state3) InitialPledgeForPower(qaPower abi.StoragePower, networkTotalPledge abi.TokenAmount, networkQAPower *builtin.FilterEstimate, circSupply abi.TokenAmount) (abi.TokenAmount, error) {
-	return miner3.InitialPledgeForPower(
-		qaPower,
-		s.State.ThisEpochBaselinePower,
-		s.State.ThisEpochRewardSmoothed,
-		smoothing3.FilterEstimate{
-			PositionEstimate: networkQAPower.PositionEstimate,
-			VelocityEstimate: networkQAPower.VelocityEstimate,
-		},
-		circSupply,
-	), nil
-}
-
-func (s *state3) PreCommitDepositForPower(networkQAPower builtin.FilterEstimate, sectorWeight abi.StoragePower) (abi.TokenAmount, error) {
-	return miner3.PreCommitDepositForPower(s.State.ThisEpochRewardSmoothed,
-		smoothing3.FilterEstimate{
-			PositionEstimate: networkQAPower.PositionEstimate,
-			VelocityEstimate: networkQAPower.VelocityEstimate,
-		},
-		sectorWeight), nil
-}
@@ -6,21 +6,16 @@ import (
 	"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"
 )

-// taking this as a function instead of asking the caller to call it helps reduce some of the error
-// checking boilerplate.
-//
-// "go made me do it"
-type rootFunc func() (adt.Map, error)
-
-// Assumes that the bitwidth for v3 HAMTs is the DefaultHamtBitwidth
-func getDataCap(store adt.Store, ver actors.Version, root rootFunc, addr address.Address) (bool, abi.StoragePower, error) {
+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 := root()
+
+	vh, err := adt.AsMap(store, root, ver)
 	if err != nil {
 		return false, big.Zero(), xerrors.Errorf("loading verifreg: %w", err)
 	}
@@ -35,9 +30,8 @@ func getDataCap(store adt.Store, ver actors.Version, root rootFunc, addr address
 	return true, dcap, nil
 }

-// Assumes that the bitwidth for v3 HAMTs is the DefaultHamtBitwidth
-func forEachCap(store adt.Store, ver actors.Version, root rootFunc, cb func(addr address.Address, dcap abi.StoragePower) error) error {
-	vh, err := root()
+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)
 	}
@@ -9,7 +9,6 @@ import (
 	"github.com/filecoin-project/lotus/chain/actors/adt"

 	verifreg0 "github.com/filecoin-project/specs-actors/actors/builtin/verifreg"
-	adt0 "github.com/filecoin-project/specs-actors/actors/util/adt"
 )

 var _ State = (*state0)(nil)
@@ -33,25 +32,17 @@ func (s *state0) RootKey() (address.Address, error) {
 }

 func (s *state0) VerifiedClientDataCap(addr address.Address) (bool, abi.StoragePower, error) {
-	return getDataCap(s.store, actors.Version0, s.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, actors.Version0, s.verifiers, addr)
+	return getDataCap(s.store, actors.Version0, s.State.Verifiers, addr)
 }

 func (s *state0) ForEachVerifier(cb func(addr address.Address, dcap abi.StoragePower) error) error {
-	return forEachCap(s.store, actors.Version0, s.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, actors.Version0, s.verifiedClients, cb)
-}
-
-func (s *state0) verifiedClients() (adt.Map, error) {
-	return adt0.AsMap(s.store, s.VerifiedClients)
-}
-
-func (s *state0) verifiers() (adt.Map, error) {
-	return adt0.AsMap(s.store, s.Verifiers)
+	return forEachCap(s.store, actors.Version0, s.State.VerifiedClients, cb)
 }
@@ -9,7 +9,6 @@ import (
 	"github.com/filecoin-project/lotus/chain/actors/adt"

 	verifreg2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/verifreg"
-	adt2 "github.com/filecoin-project/specs-actors/v2/actors/util/adt"
 )

 var _ State = (*state2)(nil)
@@ -33,25 +32,17 @@ func (s *state2) RootKey() (address.Address, error) {
 }

 func (s *state2) VerifiedClientDataCap(addr address.Address) (bool, abi.StoragePower, error) {
-	return getDataCap(s.store, actors.Version2, s.verifiedClients, addr)
+	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.verifiers, addr)
+	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.verifiers, cb)
+	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.verifiedClients, cb)
-}
-
-func (s *state2) verifiedClients() (adt.Map, error) {
-	return adt2.AsMap(s.store, s.VerifiedClients)
-}
-
-func (s *state2) verifiers() (adt.Map, error) {
-	return adt2.AsMap(s.store, s.Verifiers)
+	return forEachCap(s.store, actors.Version2, s.State.VerifiedClients, cb)
 }
@@ -1,58 +0,0 @@
-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"
-
-	builtin3 "github.com/filecoin-project/specs-actors/v3/actors/builtin"
-	verifreg3 "github.com/filecoin-project/specs-actors/v3/actors/builtin/verifreg"
-	adt3 "github.com/filecoin-project/specs-actors/v3/actors/util/adt"
-)
-
-var _ State = (*state3)(nil)
-
-func load3(store adt.Store, root cid.Cid) (State, error) {
-	out := state3{store: store}
-	err := store.Get(store.Context(), root, &out)
-	if err != nil {
-		return nil, err
-	}
-	return &out, nil
-}
-
-type state3 struct {
-	verifreg3.State
-	store adt.Store
-}
-
-func (s *state3) RootKey() (address.Address, error) {
-	return s.State.RootKey, nil
-}
-
-func (s *state3) VerifiedClientDataCap(addr address.Address) (bool, abi.StoragePower, error) {
-	return getDataCap(s.store, actors.Version3, s.verifiedClients, addr)
-}
-
-func (s *state3) VerifierDataCap(addr address.Address) (bool, abi.StoragePower, error) {
-	return getDataCap(s.store, actors.Version3, s.verifiers, addr)
-}
-
-func (s *state3) ForEachVerifier(cb func(addr address.Address, dcap abi.StoragePower) error) error {
-	return forEachCap(s.store, actors.Version3, s.verifiers, cb)
-}
-
-func (s *state3) ForEachClient(cb func(addr address.Address, dcap abi.StoragePower) error) error {
-	return forEachCap(s.store, actors.Version3, s.verifiedClients, cb)
-}
-
-func (s *state3) verifiedClients() (adt.Map, error) {
-	return adt3.AsMap(s.store, s.VerifiedClients, builtin3.DefaultHamtBitwidth)
-}
-
-func (s *state3) verifiers() (adt.Map, error) {
-	return adt3.AsMap(s.store, s.Verifiers, builtin3.DefaultHamtBitwidth)
-}
@@ -3,7 +3,6 @@ package verifreg
 import (
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
-	builtin3 "github.com/filecoin-project/specs-actors/v3/actors/builtin"
 	"github.com/ipfs/go-cid"
 	"golang.org/x/xerrors"

@@ -23,14 +22,11 @@ func init() {
 	builtin.RegisterActorState(builtin2.VerifiedRegistryActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
 		return load2(store, root)
 	})
-	builtin.RegisterActorState(builtin3.VerifiedRegistryActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
-		return load3(store, root)
-	})
 }

 var (
-	Address = builtin3.VerifiedRegistryActorAddr
-	Methods = builtin3.MethodsVerifiedRegistry
+	Address = builtin2.VerifiedRegistryActorAddr
+	Methods = builtin2.MethodsVerifiedRegistry
 )

 func Load(store adt.Store, act *types.Actor) (State, error) {
@@ -39,8 +35,6 @@ func Load(store adt.Store, act *types.Actor) (State, error) {
 		return load0(store, act.Head)
 	case builtin2.VerifiedRegistryActorCodeID:
 		return load2(store, act.Head)
-	case builtin3.VerifiedRegistryActorCodeID:
-		return load3(store, act.Head)
 	}
 	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
 }
@@ -3,8 +3,6 @@ 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"
 )
@@ -13,7 +11,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, exitcode.ErrSerialization, "failed to encode parameter")
+		return nil, aerrors.Absorb(err, 1, "failed to encode parameter")
 	}
 	return buf.Bytes(), nil
 }
@@ -6,67 +6,42 @@ import (
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/network"
 	"github.com/filecoin-project/lotus/chain/actors"
-
 	market0 "github.com/filecoin-project/specs-actors/actors/builtin/market"
 	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
 	power0 "github.com/filecoin-project/specs-actors/actors/builtin/power"
 	verifreg0 "github.com/filecoin-project/specs-actors/actors/builtin/verifreg"
-
 	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
 	market2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/market"
 	miner2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/miner"
+	paych2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/paych"
 	verifreg2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/verifreg"
-
-	builtin3 "github.com/filecoin-project/specs-actors/v3/actors/builtin"
-	market3 "github.com/filecoin-project/specs-actors/v3/actors/builtin/market"
-	miner3 "github.com/filecoin-project/specs-actors/v3/actors/builtin/miner"
-	paych3 "github.com/filecoin-project/specs-actors/v3/actors/builtin/paych"
-	verifreg3 "github.com/filecoin-project/specs-actors/v3/actors/builtin/verifreg"
 )

 const (
-	ChainFinality          = miner3.ChainFinality
+	ChainFinality          = miner0.ChainFinality
 	SealRandomnessLookback = ChainFinality
-	PaychSettleDelay       = paych3.SettleDelay
+	PaychSettleDelay       = paych2.SettleDelay
 )

 // SetSupportedProofTypes sets supported proof types, across all actor versions.
 // This should only be used for testing.
 func SetSupportedProofTypes(types ...abi.RegisteredSealProof) {
-	miner0.SupportedProofTypes = make(map[abi.RegisteredSealProof]struct{}, len(types))
-	miner2.PreCommitSealProofTypesV0 = make(map[abi.RegisteredSealProof]struct{}, len(types))
-	miner2.PreCommitSealProofTypesV7 = make(map[abi.RegisteredSealProof]struct{}, len(types)*2)
-	miner2.PreCommitSealProofTypesV8 = make(map[abi.RegisteredSealProof]struct{}, len(types))
-
-	miner3.PreCommitSealProofTypesV0 = make(map[abi.RegisteredSealProof]struct{}, len(types))
-	miner3.PreCommitSealProofTypesV7 = make(map[abi.RegisteredSealProof]struct{}, len(types)*2)
-	miner3.PreCommitSealProofTypesV8 = make(map[abi.RegisteredSealProof]struct{}, len(types))
-
-	AddSupportedProofTypes(types...)
+	newTypes := make(map[abi.RegisteredSealProof]struct{}, len(types))
+	for _, t := range types {
+		newTypes[t] = struct{}{}
+	}
+	// Set for all miner versions.
+	miner0.SupportedProofTypes = newTypes
+	miner2.SupportedProofTypes = newTypes
 }

 // AddSupportedProofTypes sets supported proof types, across all actor versions.
 // This should only be used for testing.
 func AddSupportedProofTypes(types ...abi.RegisteredSealProof) {
 	for _, t := range types {
-		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{}{}
-
-		miner3.PreCommitSealProofTypesV0[t] = struct{}{}
-
-		miner3.PreCommitSealProofTypesV7[t] = struct{}{}
-		miner3.PreCommitSealProofTypesV7[t+abi.RegisteredSealProof_StackedDrg2KiBV1_1] = struct{}{}
-
-		miner3.PreCommitSealProofTypesV8[t+abi.RegisteredSealProof_StackedDrg2KiBV1_1] = struct{}{}
+		miner2.SupportedProofTypes[t] = struct{}{}
 	}
 }

@@ -76,7 +51,6 @@ func SetPreCommitChallengeDelay(delay abi.ChainEpoch) {
 	// Set for all miner versions.
 	miner0.PreCommitChallengeDelay = delay
 	miner2.PreCommitChallengeDelay = delay
-	miner3.PreCommitChallengeDelay = delay
 }

 // TODO: this function shouldn't really exist. Instead, the API should expose the precommit delay.
@@ -92,10 +66,6 @@ func SetConsensusMinerMinPower(p abi.StoragePower) {
 	for _, policy := range builtin2.SealProofPolicies {
 		policy.ConsensusMinerMinPower = p
 	}
-
-	for _, policy := range builtin3.PoStProofPolicies {
-		policy.ConsensusMinerMinPower = p
-	}
 }

 // SetMinVerifiedDealSize sets the minimum size of a verified deal. This should
@@ -103,7 +73,6 @@ func SetConsensusMinerMinPower(p abi.StoragePower) {
 func SetMinVerifiedDealSize(size abi.StoragePower) {
 	verifreg0.MinVerifiedDealSize = size
 	verifreg2.MinVerifiedDealSize = size
-	verifreg3.MinVerifiedDealSize = size
 }

 func GetMaxProveCommitDuration(ver actors.Version, t abi.RegisteredSealProof) abi.ChainEpoch {
@@ -112,8 +81,6 @@ func GetMaxProveCommitDuration(ver actors.Version, t abi.RegisteredSealProof) ab
 		return miner0.MaxSealDuration[t]
 	case actors.Version2:
 		return miner2.MaxProveCommitDuration[t]
-	case actors.Version3:
-		return miner3.MaxProveCommitDuration[t]
 	default:
 		panic("unsupported actors version")
 	}
@@ -129,8 +96,6 @@ func DealProviderCollateralBounds(
 		return market0.DealProviderCollateralBounds(size, verified, rawBytePower, qaPower, baselinePower, circulatingFil, nwVer)
 	case actors.Version2:
 		return market2.DealProviderCollateralBounds(size, verified, rawBytePower, qaPower, baselinePower, circulatingFil)
-	case actors.Version3:
-		return market3.DealProviderCollateralBounds(size, verified, rawBytePower, qaPower, baselinePower, circulatingFil)
 	default:
 		panic("unsupported network version")
 	}
@@ -144,12 +109,6 @@ func SetWPoStChallengeWindow(period abi.ChainEpoch) {

 	miner2.WPoStChallengeWindow = period
 	miner2.WPoStProvingPeriod = period * abi.ChainEpoch(miner2.WPoStPeriodDeadlines)
-
-	miner3.WPoStChallengeWindow = period
-	miner3.WPoStProvingPeriod = period * abi.ChainEpoch(miner3.WPoStPeriodDeadlines)
-	// by default, this is 2x finality which is 30 periods.
-	// scale it if we're scaling the challenge period.
-	miner3.WPoStDisputeWindow = period * 30
 }

 func GetWinningPoStSectorSetLookback(nwVer network.Version) abi.ChainEpoch {
@@ -166,17 +125,17 @@ func GetMaxSectorExpirationExtension() abi.ChainEpoch {

 // TODO: we'll probably need to abstract over this better in the future.
 func GetMaxPoStPartitions(p abi.RegisteredPoStProof) (int, error) {
-	sectorsPerPart, err := builtin3.PoStProofWindowPoStPartitionSectors(p)
+	sectorsPerPart, err := builtin2.PoStProofWindowPoStPartitionSectors(p)
 	if err != nil {
 		return 0, err
 	}
-	return int(miner3.AddressedSectorsMax / sectorsPerPart), nil
+	return int(miner2.AddressedSectorsMax / sectorsPerPart), nil
 }

 func GetDefaultSectorSize() abi.SectorSize {
-	// supported sector sizes are the same across versions.
-	szs := make([]abi.SectorSize, 0, len(miner3.PreCommitSealProofTypesV8))
-	for spt := range miner3.PreCommitSealProofTypesV8 {
+	// supported proof types are the same across versions.
+	szs := make([]abi.SectorSize, 0, len(miner2.SupportedProofTypes))
+	for spt := range miner2.SupportedProofTypes {
 		ss, err := spt.SectorSize()
 		if err != nil {
 			panic(err)
@@ -44,7 +44,7 @@ func TestSupportedProofTypes(t *testing.T) {

 // Tests assumptions about policies being the same between actor versions.
 func TestAssumptions(t *testing.T) {
-	require.EqualValues(t, miner0.SupportedProofTypes, miner2.PreCommitSealProofTypesV0)
+	require.EqualValues(t, miner0.SupportedProofTypes, miner2.SupportedProofTypes)
 	require.Equal(t, miner0.PreCommitChallengeDelay, miner2.PreCommitChallengeDelay)
 	require.Equal(t, miner0.MaxSectorExpirationExtension, miner2.MaxSectorExpirationExtension)
 	require.Equal(t, miner0.ChainFinality, miner2.ChainFinality)
@@ -57,10 +57,10 @@ func TestAssumptions(t *testing.T) {
 }

 func TestPartitionSizes(t *testing.T) {
-	for _, p := range abi.SealProofInfos {
-		sizeNew, err := builtin2.PoStProofWindowPoStPartitionSectors(p.WindowPoStProof)
+	for p := range abi.PoStSealProofTypes {
+		sizeNew, err := builtin2.PoStProofWindowPoStPartitionSectors(p)
 		require.NoError(t, err)
-		sizeOld, err := builtin0.PoStProofWindowPoStPartitionSectors(p.WindowPoStProof)
+		sizeOld, err := builtin0.PoStProofWindowPoStPartitionSectors(p)
 		if err != nil {
 			// new proof type.
 			continue
@@ -11,7 +11,6 @@ type Version int
 const (
 	Version0 Version = 0
 	Version2 Version = 2
-	Version3 Version = 3
 )

 // Converts a network version into an actors adt version.
@@ -19,10 +18,8 @@ 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, network.Version9:
+	case network.Version4, network.Version5, network.Version6:
 		return Version2
-	case network.Version10:
-		return Version3
 	default:
 		panic(fmt.Sprintf("unsupported network version %d", version))
 	}
@@ -20,10 +20,8 @@ import (
 var log = logging.Logger("events")

 // HeightHandler `curH`-`ts.Height` = `confidence`
-type (
-	HeightHandler func(ctx context.Context, ts *types.TipSet, curH abi.ChainEpoch) error
-	RevertHandler func(ctx context.Context, ts *types.TipSet) error
-)
+type HeightHandler func(ctx context.Context, ts *types.TipSet, curH abi.ChainEpoch) error
+type RevertHandler func(ctx context.Context, ts *types.TipSet) error

 type heightHandler struct {
 	confidence int
@@ -50,7 +48,7 @@ type Events struct {
 	tsc *tipSetCache
 	lk  sync.Mutex

-	ready     chan struct{}
+	ready     sync.WaitGroup
 	readyOnce sync.Once

 	heightEvents
@@ -78,16 +76,15 @@ func NewEvents(ctx context.Context, api eventAPI) *Events {
 		},

 		hcEvents: newHCEvents(ctx, api, tsc, uint64(gcConfidence)),
-		ready:    make(chan struct{}),
 	}

+	e.ready.Add(1)
+
 	go e.listenHeadChanges(ctx)

-	// Wait for the first tipset to be seen or bail if shutting down
-	select {
-	case <-e.ready:
-	case <-ctx.Done():
-	}
+	e.ready.Wait()
+
+	// TODO: cleanup/gc goroutine

 	return e
 }
@@ -114,21 +111,13 @@ func (e *Events) listenHeadChangesOnce(ctx context.Context) error {

 	notifs, err := e.api.ChainNotify(ctx)
 	if err != nil {
-		// Retry is handled by caller
+		// TODO: retry
 		return xerrors.Errorf("listenHeadChanges ChainNotify call failed: %w", err)
 	}

-	var cur []*api.HeadChange
-	var ok bool
-
-	// Wait for first tipset or bail
-	select {
-	case cur, ok = <-notifs:
-		if !ok {
-			return xerrors.Errorf("notification channel closed")
-		}
-	case <-ctx.Done():
-		return ctx.Err()
+	cur, ok := <-notifs // TODO: timeout?
+	if !ok {
+		return xerrors.Errorf("notification channel closed")
 	}

 	if len(cur) != 1 {
@@ -140,13 +129,13 @@ func (e *Events) listenHeadChangesOnce(ctx context.Context) error {
 	}

 	if err := e.tsc.add(cur[0].Val); err != nil {
-		log.Warnf("tsc.add: adding current tipset failed: %v", err)
+		log.Warn("tsc.add: adding current tipset failed: %w", err)
 	}

 	e.readyOnce.Do(func() {
 		e.lastTs = cur[0].Val
-		// Signal that we have seen first tipset
-		close(e.ready)
+
+		e.ready.Done()
 	})

 	for notif := range notifs {
@@ -153,7 +153,6 @@ func (e *heightEvents) ChainAt(hnd HeightHandler, rev RevertHandler, confidence

 	best, err := e.tsc.best()
 	if err != nil {
-		e.lk.Unlock()
 		return xerrors.Errorf("error getting best tipset: %w", err)
 	}

@@ -178,7 +177,6 @@ func (e *heightEvents) ChainAt(hnd HeightHandler, rev RevertHandler, confidence
 		e.lk.Lock()
 		best, err = e.tsc.best()
 		if err != nil {
-			e.lk.Unlock()
 			return xerrors.Errorf("error getting best tipset: %w", err)
 		}
 		bestH = best.Height()
@@ -1,6 +1,7 @@
 package state

 import (
+	"bytes"
 	"context"

 	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
@@ -9,6 +10,7 @@ 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"
@@ -417,17 +419,179 @@ 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, err := init_.DiffAddressMap(oldState, newState)
+		addressChanges := &InitActorAddressChanges{
+			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
 	}
 }
@@ -38,26 +38,20 @@ func newPeerTracker(lc fx.Lifecycle, h host.Host, pmgr *peermgr.PeerMgr) *bsPeer
 		pmgr:  pmgr,
 	}

-	evtSub, err := h.EventBus().Subscribe(new(peermgr.FilPeerEvt))
+	sub, err := h.EventBus().Subscribe(new(peermgr.NewFilPeer))
 	if err != nil {
 		panic(err)
 	}

 	go func() {
-		for evt := range evtSub.Out() {
-			pEvt := evt.(peermgr.FilPeerEvt)
-			switch pEvt.Type {
-			case peermgr.AddFilPeerEvt:
-				bsPt.addPeer(pEvt.ID)
-			case peermgr.RemoveFilPeerEvt:
-				bsPt.removePeer(pEvt.ID)
-			}
+		for newPeer := range sub.Out() {
+			bsPt.addPeer(newPeer.(peermgr.NewFilPeer).Id)
 		}
 	}()

 	lc.Append(fx.Hook{
 		OnStop: func(ctx context.Context) error {
-			return evtSub.Close()
+			return sub.Close()
 		},
 	})

@@ -56,11 +56,7 @@ func (s *server) HandleStream(stream inet.Stream) {
 	}

 	_ = stream.SetDeadline(time.Now().Add(WriteResDeadline))
-	buffered := bufio.NewWriter(stream)
-	if err = cborutil.WriteCborRPC(buffered, resp); err == nil {
-		err = buffered.Flush()
-	}
-	if err != nil {
+	if err := cborutil.WriteCborRPC(stream, resp); err != nil {
 		_ = stream.SetDeadline(time.Time{})
 		log.Warnw("failed to write back response for handle stream",
 			"err", err, "peer", stream.Conn().RemotePeer())
@@ -14,6 +14,7 @@ import (
 	"github.com/filecoin-project/go-state-types/big"
 	"github.com/filecoin-project/go-state-types/crypto"
 	"github.com/google/uuid"
+	block "github.com/ipfs/go-block-format"
 	"github.com/ipfs/go-blockservice"
 	"github.com/ipfs/go-cid"
 	offline "github.com/ipfs/go-ipfs-exchange-offline"
@@ -84,6 +85,19 @@ type ChainGen struct {
 	lr repo.LockedRepo
 }

+type mybs struct {
+	blockstore.Blockstore
+}
+
+func (m mybs) Get(c cid.Cid) (block.Block, error) {
+	b, err := m.Blockstore.Get(c)
+	if err != nil {
+		return nil, err
+	}
+
+	return b, nil
+}
+
 var rootkeyMultisig = genesis.MultisigMeta{
 	Signers:         []address.Address{remAccTestKey},
 	Threshold:       1,
@@ -138,6 +152,8 @@ func NewGeneratorWithSectors(numSectors int) (*ChainGen, error) {
 		}
 	}()

+	bs = mybs{bs}
+
 	ks, err := lr.KeyStore()
 	if err != nil {
 		return nil, xerrors.Errorf("getting repo keystore failed: %w", err)
@@ -331,8 +347,14 @@ func (cg *ChainGen) nextBlockProof(ctx context.Context, pts *types.TipSet, m add
 		return nil, nil, nil, xerrors.Errorf("get miner base info: %w", err)
 	}

-	entries := mbi.BeaconEntries
-	rbase := mbi.PrevBeaconEntry
+	prev := mbi.PrevBeaconEntry
+
+	entries, err := beacon.BeaconEntriesForBlock(ctx, cg.beacon, round, pts.Height(), prev)
+	if err != nil {
+		return nil, nil, nil, xerrors.Errorf("get beacon entries for block: %w", err)
+	}
+
+	rbase := prev
 	if len(entries) > 0 {
 		rbase = entries[len(entries)-1]
 	}
@@ -449,12 +471,7 @@ func (cg *ChainGen) NextTipSetFromMinersWithMessages(base *types.TipSet, miners
 		}
 	}

-	fts := store.NewFullTipSet(blks)
-	if err := cg.cs.PutTipSet(context.TODO(), fts.TipSet()); err != nil {
-		return nil, err
-	}
-
-	return fts, nil
+	return store.NewFullTipSet(blks), nil
 }

 func (cg *ChainGen) makeBlock(parents *types.TipSet, m address.Address, vrfticket *types.Ticket,
@@ -21,7 +21,7 @@ import (
 	bstore "github.com/filecoin-project/lotus/lib/blockstore"
 )

-func SetupInitActor(bs bstore.Blockstore, netname string, initialActors []genesis.Actor, rootVerifier genesis.Actor, remainder genesis.Actor) (int64, *types.Actor, map[address.Address]address.Address, error) {
+func SetupInitActor(bs bstore.Blockstore, netname string, initialActors []genesis.Actor, rootVerifier genesis.Actor) (int64, *types.Actor, map[address.Address]address.Address, error) {
 	if len(initialActors) > MaxAccounts {
 		return 0, nil, nil, xerrors.New("too many initial actors")
 	}
@@ -90,33 +90,6 @@ func SetupInitActor(bs bstore.Blockstore, netname string, initialActors []genesi
 		}
 	}

-	setupMsig := func(meta json.RawMessage) error {
-		var ainfo genesis.MultisigMeta
-		if err := json.Unmarshal(meta, &ainfo); err != nil {
-			return xerrors.Errorf("unmarshaling account meta: %w", err)
-		}
-		for _, e := range ainfo.Signers {
-			if _, ok := keyToId[e]; ok {
-				continue
-			}
-			fmt.Printf("init set %s t0%d\n", e, counter)
-
-			value := cbg.CborInt(counter)
-			if err := amap.Put(abi.AddrKey(e), &value); err != nil {
-				return err
-			}
-			counter = counter + 1
-			var err error
-			keyToId[e], err = address.NewIDAddress(uint64(value))
-			if err != nil {
-				return err
-			}
-
-		}
-
-		return nil
-	}
-
 	if rootVerifier.Type == genesis.TAccount {
 		var ainfo genesis.AccountMeta
 		if err := json.Unmarshal(rootVerifier.Meta, &ainfo); err != nil {
@@ -127,15 +100,28 @@ func SetupInitActor(bs bstore.Blockstore, netname string, initialActors []genesi
 			return 0, nil, nil, err
 		}
 	} else if rootVerifier.Type == genesis.TMultisig {
-		err := setupMsig(rootVerifier.Meta)
-		if err != nil {
-			return 0, nil, nil, xerrors.Errorf("setting up root verifier msig: %w", err)
+		var ainfo genesis.MultisigMeta
+		if err := json.Unmarshal(rootVerifier.Meta, &ainfo); err != nil {
+			return 0, nil, nil, xerrors.Errorf("unmarshaling account meta: %w", err)
 		}
-	}
+		for _, e := range ainfo.Signers {
+			if _, ok := keyToId[e]; ok {
+				continue
+			}
+			fmt.Printf("init set %s t0%d\n", e, counter)

-	err := setupMsig(remainder.Meta)
-	if err != nil {
-		return 0, nil, nil, xerrors.Errorf("setting up remainder msig: %w", err)
+			value := cbg.CborInt(counter)
+			if err := amap.Put(abi.AddrKey(e), &value); err != nil {
+				return 0, nil, nil, err
+			}
+			counter = counter + 1
+			var err error
+			keyToId[e], err = address.NewIDAddress(uint64(value))
+			if err != nil {
+				return 0, nil, nil, err
+			}
+
+		}
 	}

 	amapaddr, err := amap.Root()
@@ -134,7 +134,7 @@ func MakeInitialStateTree(ctx context.Context, bs bstore.Blockstore, template ge

 	// Create init actor

-	idStart, initact, keyIDs, err := SetupInitActor(bs, template.NetworkName, template.Accounts, template.VerifregRootKey, template.RemainderAccount)
+	idStart, initact, keyIDs, err := SetupInitActor(bs, template.NetworkName, template.Accounts, template.VerifregRootKey)
 	if err != nil {
 		return nil, nil, xerrors.Errorf("setup init actor: %w", err)
 	}
@@ -23,6 +23,8 @@ import (
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/big"
 	"github.com/filecoin-project/go-state-types/crypto"
+	"github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper"
+
 	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
 	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
 	power0 "github.com/filecoin-project/specs-actors/actors/builtin/power"
@@ -99,7 +101,7 @@ func SetupStorageMiners(ctx context.Context, cs *store.ChainStore, sroot cid.Cid
 		i := i
 		m := m

-		spt, err := miner.SealProofTypeFromSectorSize(m.SectorSize, GenesisNetworkVersion)
+		spt, err := ffiwrapper.SealProofTypeFromSectorSize(m.SectorSize)
 		if err != nil {
 			return cid.Undef, err
 		}
@@ -9,10 +9,10 @@ import (
 	cbg "github.com/whyrusleeping/cbor-gen"
 	"golang.org/x/xerrors"

-	ffi "github.com/filecoin-project/filecoin-ffi"
 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/chain/stmgr"
 	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/lib/sigs/bls"
 )

 func MinerCreateBlock(ctx context.Context, sm *stmgr.StateManager, w api.WalletAPI, bt *api.BlockTemplate) (*types.FullBlock, error) {
@@ -140,29 +140,35 @@ func MinerCreateBlock(ctx context.Context, sm *stmgr.StateManager, w api.WalletA
 }

 func aggregateSignatures(sigs []crypto.Signature) (*crypto.Signature, error) {
-	sigsS := make([]ffi.Signature, len(sigs))
+	sigsS := make([][]byte, len(sigs))
 	for i := 0; i < len(sigs); i++ {
-		copy(sigsS[i][:], sigs[i].Data[:ffi.SignatureBytes])
+		sigsS[i] = sigs[i].Data
 	}

-	aggSig := ffi.Aggregate(sigsS)
-	if aggSig == nil {
+	aggregator := new(bls.AggregateSignature).AggregateCompressed(sigsS)
+	if aggregator == nil {
 		if len(sigs) > 0 {
 			return nil, xerrors.Errorf("bls.Aggregate returned nil with %d signatures", len(sigs))
 		}

-		zeroSig := ffi.CreateZeroSignature()
-
 		// Note: for blst this condition should not happen - nil should not
 		// be returned
 		return &crypto.Signature{
 			Type: crypto.SigTypeBLS,
-			Data: zeroSig[:],
+			Data: new(bls.Signature).Compress(),
 		}, nil
 	}
+	aggSigAff := aggregator.ToAffine()
+	if aggSigAff == nil {
+		return &crypto.Signature{
+			Type: crypto.SigTypeBLS,
+			Data: new(bls.Signature).Compress(),
+		}, nil
+	}
+	aggSig := aggSigAff.Compress()
 	return &crypto.Signature{
 		Type: crypto.SigTypeBLS,
-		Data: aggSig[:],
+		Data: aggSig,
 	}, nil
 }

@@ -3,8 +3,6 @@ package slashfilter
 import (
 	"fmt"

-	"github.com/filecoin-project/lotus/build"
-
 	"golang.org/x/xerrors"

 	"github.com/ipfs/go-cid"
@@ -28,10 +26,6 @@ func New(dstore ds.Batching) *SlashFilter {
 }

 func (f *SlashFilter) MinedBlock(bh *types.BlockHeader, parentEpoch abi.ChainEpoch) error {
-	if build.IsNearUpgrade(bh.Height, build.UpgradeOrangeHeight) {
-		return nil
-	}
-
 	epochKey := ds.NewKey(fmt.Sprintf("/%s/%d", bh.Miner, bh.Height))
 	{
 		// double-fork mining (2 blocks at one epoch)
@@ -2,7 +2,6 @@ package market

 import (
 	"context"
-	"fmt"
 	"sync"

 	"github.com/filecoin-project/go-address"
@@ -130,11 +129,6 @@ func (fm *FundManager) Withdraw(ctx context.Context, wallet, addr address.Addres
 	return fm.getFundedAddress(addr).withdraw(ctx, wallet, amt)
 }

-// GetReserved returns the amount that is currently reserved for the address
-func (fm *FundManager) GetReserved(addr address.Address) abi.TokenAmount {
-	return fm.getFundedAddress(addr).getReserved()
-}
-
 // FundedAddressState keeps track of the state of an address with funds in the
 // datastore
 type FundedAddressState struct {
@@ -153,7 +147,7 @@ type fundedAddress struct {
 	env *fundManagerEnvironment
 	str *Store

-	lk    sync.RWMutex
+	lk    sync.Mutex
 	state *FundedAddressState

 	// Note: These request queues are ephemeral, they are not saved to store
@@ -189,13 +183,6 @@ func (a *fundedAddress) start() {
 	}
 }

-func (a *fundedAddress) getReserved() abi.TokenAmount {
-	a.lk.RLock()
-	defer a.lk.RUnlock()
-
-	return a.state.AmtReserved
-}
-
 func (a *fundedAddress) reserve(ctx context.Context, wallet address.Address, amt abi.TokenAmount) (cid.Cid, error) {
 	return a.requestAndWait(ctx, wallet, amt, &a.reservations)
 }
@@ -514,13 +501,7 @@ func (a *fundedAddress) processWithdrawals(withdrawals []*fundRequest) (msgCid c
 		// request with an error
 		newWithdrawalAmt := types.BigAdd(withdrawalAmt, amt)
 		if newWithdrawalAmt.GreaterThan(netAvail) {
-			msg := fmt.Sprintf("insufficient funds for withdrawal of %s: ", types.FIL(amt))
-			msg += fmt.Sprintf("net available (%s) = available (%s) - reserved (%s)",
-				types.FIL(types.BigSub(netAvail, withdrawalAmt)), types.FIL(avail), types.FIL(a.state.AmtReserved))
-			if !withdrawalAmt.IsZero() {
-				msg += fmt.Sprintf(" - queued withdrawals (%s)", types.FIL(withdrawalAmt))
-			}
-			err := xerrors.Errorf(msg)
+			err := xerrors.Errorf("insufficient funds for withdrawal of %d", amt)
 			a.debugf("%s", err)
 			req.Complete(cid.Undef, err)
 			continue
@@ -181,20 +181,7 @@ func ComputeMinRBF(curPrem abi.TokenAmount) abi.TokenAmount {
 	return types.BigAdd(minPrice, types.NewInt(1))
 }

-func CapGasFee(mff dtypes.DefaultMaxFeeFunc, msg *types.Message, sendSepc *api.MessageSendSpec) {
-	var maxFee abi.TokenAmount
-	if sendSepc != nil {
-		maxFee = sendSepc.MaxFee
-	}
-	if maxFee.Int == nil || maxFee.Equals(big.Zero()) {
-		mf, err := mff()
-		if err != nil {
-			log.Errorf("failed to get default max gas fee: %+v", err)
-			mf = big.Zero()
-		}
-		maxFee = mf
-	}
-
+func CapGasFee(mff dtypes.DefaultMaxFeeFunc, msg *types.Message, maxFee abi.TokenAmount) {
 	if maxFee.Equals(big.Zero()) {
 		mf, err := mff()
 		if err != nil {
@@ -253,13 +240,10 @@ func (ms *msgSet) add(m *types.SignedMessage, mp *MessagePool, strict, untrusted
 			// check if RBF passes
 			minPrice := ComputeMinRBF(exms.Message.GasPremium)
 			if types.BigCmp(m.Message.GasPremium, minPrice) >= 0 {
-				log.Debugw("add with RBF", "oldpremium", exms.Message.GasPremium,
+				log.Infow("add with RBF", "oldpremium", exms.Message.GasPremium,
 					"newpremium", m.Message.GasPremium, "addr", m.Message.From, "nonce", m.Message.Nonce)
 			} else {
-				log.Debugf("add with duplicate nonce. message from %s with nonce %d already in mpool,"+
-					" increase GasPremium to %s from %s to trigger replace by fee: %s",
-					m.Message.From, m.Message.Nonce, minPrice, m.Message.GasPremium,
-					ErrRBFTooLowPremium)
+				log.Info("add with duplicate nonce")
 				return false, xerrors.Errorf("message from %s with nonce %d already in mpool,"+
 					" increase GasPremium to %s from %s to trigger replace by fee: %w",
 					m.Message.From, m.Message.Nonce, minPrice, m.Message.GasPremium,
@@ -481,7 +465,7 @@ func (mp *MessagePool) verifyMsgBeforeAdd(m *types.SignedMessage, curTs *types.T
 	epoch := curTs.Height()
 	minGas := vm.PricelistByEpoch(epoch).OnChainMessage(m.ChainLength())

-	if err := m.VMMessage().ValidForBlockInclusion(minGas.Total(), build.NewestNetworkVersion); err != nil {
+	if err := m.VMMessage().ValidForBlockInclusion(minGas.Total()); err != nil {
 		return false, xerrors.Errorf("message will not be included in a block: %w", err)
 	}

@@ -562,7 +546,7 @@ func (mp *MessagePool) checkMessage(m *types.SignedMessage) error {
 	}

 	// Perform syntactic validation, minGas=0 as we check the actual mingas before we add it
-	if err := m.Message.ValidForBlockInclusion(0, build.NewestNetworkVersion); err != nil {
+	if err := m.Message.ValidForBlockInclusion(0); err != nil {
 		return xerrors.Errorf("message not valid for block inclusion: %w", err)
 	}

@@ -871,7 +855,7 @@ func (mp *MessagePool) PushUntrusted(m *types.SignedMessage) (cid.Cid, error) {
 	}()

 	mp.curTsLk.Lock()
-	publish, err := mp.addTs(m, mp.curTs, true, true)
+	publish, err := mp.addTs(m, mp.curTs, false, true)
 	if err != nil {
 		mp.curTsLk.Unlock()
 		return cid.Undef, err
@@ -100,7 +100,7 @@ loop:
 			// check the baseFee lower bound -- only republish messages that can be included in the chain
 			// within the next 20 blocks.
 			for _, m := range chain.msgs {
-				if m.Message.GasFeeCap.LessThan(baseFeeLowerBound) {
+				if !allowNegativeChains(ts.Height()) && m.Message.GasFeeCap.LessThan(baseFeeLowerBound) {
 					chain.Invalidate()
 					continue loop
 				}
@@ -115,7 +115,7 @@ loop:

 		// we can't fit the current chain but there is gas to spare
 		// trim it and push it down
-		chain.Trim(gasLimit, mp, baseFee)
+		chain.Trim(gasLimit, mp, baseFee, true)
 		for j := i; j < len(chains)-1; j++ {
 			if chains[j].Before(chains[j+1]) {
 				break
@@ -10,6 +10,7 @@ import (
 	"golang.org/x/xerrors"

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

 	"github.com/filecoin-project/lotus/build"
@@ -20,7 +21,11 @@ import (

 var bigBlockGasLimit = big.NewInt(build.BlockGasLimit)

-var MaxBlockMessages = 16000
+// this is *temporary* mutilation until we have implemented uncapped miner penalties -- it will go
+// away in the next fork.
+func allowNegativeChains(epoch abi.ChainEpoch) bool {
+	return epoch < build.UpgradeBreezeHeight+5
+}

 const MaxBlocks = 15

@@ -38,7 +43,7 @@ type msgChain struct {
 	prev         *msgChain
 }

-func (mp *MessagePool) SelectMessages(ts *types.TipSet, tq float64) (msgs []*types.SignedMessage, err error) {
+func (mp *MessagePool) SelectMessages(ts *types.TipSet, tq float64) ([]*types.SignedMessage, error) {
 	mp.curTsLk.Lock()
 	defer mp.curTsLk.Unlock()

@@ -49,20 +54,10 @@ func (mp *MessagePool) SelectMessages(ts *types.TipSet, tq float64) (msgs []*typ
 	// than any other block, then we don't bother with optimal selection because the
 	// first block will always have higher effective performance
 	if tq > 0.84 {
-		msgs, err = mp.selectMessagesGreedy(mp.curTs, ts)
-	} else {
-		msgs, err = mp.selectMessagesOptimal(mp.curTs, ts, tq)
+		return mp.selectMessagesGreedy(mp.curTs, ts)
 	}

-	if err != nil {
-		return nil, err
-	}
-
-	if len(msgs) > MaxBlockMessages {
-		msgs = msgs[:MaxBlockMessages]
-	}
-
-	return msgs, nil
+	return mp.selectMessagesOptimal(mp.curTs, ts, tq)
 }

 func (mp *MessagePool) selectMessagesOptimal(curTs, ts *types.TipSet, tq float64) ([]*types.SignedMessage, error) {
@@ -114,7 +109,7 @@ func (mp *MessagePool) selectMessagesOptimal(curTs, ts *types.TipSet, tq float64
 		return chains[i].Before(chains[j])
 	})

-	if len(chains) != 0 && chains[0].gasPerf < 0 {
+	if !allowNegativeChains(curTs.Height()) && len(chains) != 0 && chains[0].gasPerf < 0 {
 		log.Warnw("all messages in mpool have non-positive gas performance", "bestGasPerf", chains[0].gasPerf)
 		return result, nil
 	}
@@ -167,7 +162,7 @@ func (mp *MessagePool) selectMessagesOptimal(curTs, ts *types.TipSet, tq float64
 	last := len(chains)
 	for i, chain := range chains {
 		// did we run out of performing chains?
-		if chain.gasPerf < 0 {
+		if !allowNegativeChains(curTs.Height()) && chain.gasPerf < 0 {
 			break
 		}

@@ -233,7 +228,7 @@ tailLoop:
 	for gasLimit >= minGas && last < len(chains) {
 		// trim if necessary
 		if chains[last].gasLimit > gasLimit {
-			chains[last].Trim(gasLimit, mp, baseFee)
+			chains[last].Trim(gasLimit, mp, baseFee, allowNegativeChains(curTs.Height()))
 		}

 		// push down if it hasn't been invalidated
@@ -259,7 +254,7 @@ tailLoop:
 			}

 			// if gasPerf < 0 we have no more profitable chains
-			if chain.gasPerf < 0 {
+			if !allowNegativeChains(curTs.Height()) && chain.gasPerf < 0 {
 				break tailLoop
 			}

@@ -300,7 +295,7 @@ tailLoop:
 			}

 			// dependencies fit, just trim it
-			chain.Trim(gasLimit-depGasLimit, mp, baseFee)
+			chain.Trim(gasLimit-depGasLimit, mp, baseFee, allowNegativeChains(curTs.Height()))
 			last += i
 			continue tailLoop
 		}
@@ -333,7 +328,7 @@ tailLoop:
 			}

 			// is it negative?
-			if chain.gasPerf < 0 {
+			if !allowNegativeChains(curTs.Height()) && chain.gasPerf < 0 {
 				continue
 			}

@@ -355,7 +350,7 @@ tailLoop:

 			// do they fit as is? if it doesn't, trim to make it fit if possible
 			if chainGasLimit > gasLimit {
-				chain.Trim(gasLimit-depGasLimit, mp, baseFee)
+				chain.Trim(gasLimit-depGasLimit, mp, baseFee, allowNegativeChains(curTs.Height()))

 				if !chain.valid {
 					continue
@@ -438,7 +433,7 @@ func (mp *MessagePool) selectMessagesGreedy(curTs, ts *types.TipSet) ([]*types.S
 		return chains[i].Before(chains[j])
 	})

-	if len(chains) != 0 && chains[0].gasPerf < 0 {
+	if !allowNegativeChains(curTs.Height()) && len(chains) != 0 && chains[0].gasPerf < 0 {
 		log.Warnw("all messages in mpool have non-positive gas performance", "bestGasPerf", chains[0].gasPerf)
 		return result, nil
 	}
@@ -449,7 +444,7 @@ func (mp *MessagePool) selectMessagesGreedy(curTs, ts *types.TipSet) ([]*types.S
 	last := len(chains)
 	for i, chain := range chains {
 		// did we run out of performing chains?
-		if chain.gasPerf < 0 {
+		if !allowNegativeChains(curTs.Height()) && chain.gasPerf < 0 {
 			break
 		}

@@ -478,7 +473,7 @@ func (mp *MessagePool) selectMessagesGreedy(curTs, ts *types.TipSet) ([]*types.S
 tailLoop:
 	for gasLimit >= minGas && last < len(chains) {
 		// trim
-		chains[last].Trim(gasLimit, mp, baseFee)
+		chains[last].Trim(gasLimit, mp, baseFee, allowNegativeChains(curTs.Height()))

 		// push down if it hasn't been invalidated
 		if chains[last].valid {
@@ -498,7 +493,7 @@ tailLoop:
 			}

 			// if gasPerf < 0 we have no more profitable chains
-			if chain.gasPerf < 0 {
+			if !allowNegativeChains(curTs.Height()) && chain.gasPerf < 0 {
 				break tailLoop
 			}

@@ -560,7 +555,7 @@ func (mp *MessagePool) selectPriorityMessages(pending map[address.Address]map[ui
 		return chains[i].Before(chains[j])
 	})

-	if len(chains) != 0 && chains[0].gasPerf < 0 {
+	if !allowNegativeChains(ts.Height()) && len(chains) != 0 && chains[0].gasPerf < 0 {
 		log.Warnw("all priority messages in mpool have negative gas performance", "bestGasPerf", chains[0].gasPerf)
 		return nil, gasLimit
 	}
@@ -568,7 +563,7 @@ func (mp *MessagePool) selectPriorityMessages(pending map[address.Address]map[ui
 	// 3. Merge chains until the block limit, as long as they have non-negative gas performance
 	last := len(chains)
 	for i, chain := range chains {
-		if chain.gasPerf < 0 {
+		if !allowNegativeChains(ts.Height()) && chain.gasPerf < 0 {
 			break
 		}

@@ -586,7 +581,7 @@ func (mp *MessagePool) selectPriorityMessages(pending map[address.Address]map[ui
 tailLoop:
 	for gasLimit >= minGas && last < len(chains) {
 		// trim, discarding negative performing messages
-		chains[last].Trim(gasLimit, mp, baseFee)
+		chains[last].Trim(gasLimit, mp, baseFee, allowNegativeChains(ts.Height()))

 		// push down if it hasn't been invalidated
 		if chains[last].valid {
@@ -606,7 +601,7 @@ tailLoop:
 			}

 			// if gasPerf < 0 we have no more profitable chains
-			if chain.gasPerf < 0 {
+			if !allowNegativeChains(ts.Height()) && chain.gasPerf < 0 {
 				break tailLoop
 			}

@@ -682,10 +677,6 @@ func (*MessagePool) getGasReward(msg *types.SignedMessage, baseFee types.BigInt)
 	}

 	gasReward := tbig.Mul(maxPremium, types.NewInt(uint64(msg.Message.GasLimit)))
-	if gasReward.Sign() == -1 {
-		// penalty multiplier
-		gasReward = tbig.Mul(gasReward, types.NewInt(3))
-	}
 	return gasReward.Int
 }

@@ -761,6 +752,9 @@ func (mp *MessagePool) createMessageChains(actor address.Address, mset map[uint6
 		balance = new(big.Int).Sub(balance, required)

 		value := m.Message.Value.Int
+		if balance.Cmp(value) < 0 {
+			break
+		}
 		balance = new(big.Int).Sub(balance, value)

 		gasReward := mp.getGasReward(m, baseFee)
@@ -864,9 +858,9 @@ func (mc *msgChain) Before(other *msgChain) bool {
 		(mc.gasPerf == other.gasPerf && mc.gasReward.Cmp(other.gasReward) > 0)
 }

-func (mc *msgChain) Trim(gasLimit int64, mp *MessagePool, baseFee types.BigInt) {
+func (mc *msgChain) Trim(gasLimit int64, mp *MessagePool, baseFee types.BigInt, allowNegative bool) {
 	i := len(mc.msgs) - 1
-	for i >= 0 && (mc.gasLimit > gasLimit || mc.gasPerf < 0) {
+	for i >= 0 && (mc.gasLimit > gasLimit || (!allowNegative && mc.gasPerf < 0)) {
 		gasReward := mp.getGasReward(mc.msgs[i], baseFee)
 		mc.gasReward = new(big.Int).Sub(mc.gasReward, gasReward)
 		mc.gasLimit -= mc.msgs[i].Message.GasLimit
@@ -736,6 +736,8 @@ func TestPriorityMessageSelection2(t *testing.T) {
 }

 func TestPriorityMessageSelection3(t *testing.T) {
+	t.Skip("reenable after removing allow negative")
+
 	mp, tma := makeTestMpool()

 	// the actors
@@ -1239,9 +1241,6 @@ func TestCompetitiveMessageSelectionExp(t *testing.T) {
 }

 func TestCompetitiveMessageSelectionZipf(t *testing.T) {
-	if testing.Short() {
-		t.Skip("skipping in short mode")
-	}
 	var capacityBoost, rewardBoost, tqReward float64
 	seeds := []int64{1947, 1976, 2020, 2100, 10000, 143324, 432432, 131, 32, 45}
 	for _, seed := range seeds {
@@ -1269,9 +1268,9 @@ func TestGasReward(t *testing.T) {
 		GasReward int64
 	}{
 		{Premium: 100, FeeCap: 200, BaseFee: 100, GasReward: 100},
-		{Premium: 100, FeeCap: 200, BaseFee: 210, GasReward: -10 * 3},
+		{Premium: 100, FeeCap: 200, BaseFee: 210, GasReward: -10},
 		{Premium: 200, FeeCap: 250, BaseFee: 210, GasReward: 40},
-		{Premium: 200, FeeCap: 250, BaseFee: 2000, GasReward: -1750 * 3},
+		{Premium: 200, FeeCap: 250, BaseFee: 2000, GasReward: -1750},
 	}

 	mp := new(MessagePool)
@@ -20,10 +20,6 @@ import (

 	"github.com/filecoin-project/lotus/chain/actors/adt"
 	"github.com/filecoin-project/lotus/chain/types"
-
-	states0 "github.com/filecoin-project/specs-actors/actors/states"
-	states2 "github.com/filecoin-project/specs-actors/v2/actors/states"
-	states3 "github.com/filecoin-project/specs-actors/v3/actors/states"
 )

 var log = logging.Logger("statetree")
@@ -148,12 +144,23 @@ func VersionForNetwork(ver network.Version) types.StateTreeVersion {
 	return types.StateTreeVersion1
 }

+func adtForSTVersion(ver types.StateTreeVersion) actors.Version {
+	switch ver {
+	case types.StateTreeVersion0:
+		return actors.Version0
+	case types.StateTreeVersion1:
+		return actors.Version2
+	default:
+		panic("unhandled state tree version")
+	}
+}
+
 func NewStateTree(cst cbor.IpldStore, ver types.StateTreeVersion) (*StateTree, error) {
 	var info cid.Cid
 	switch ver {
 	case types.StateTreeVersion0:
 		// info is undefined
-	case types.StateTreeVersion1, types.StateTreeVersion2:
+	case types.StateTreeVersion1:
 		var err error
 		info, err = cst.Put(context.TODO(), new(types.StateInfo0))
 		if err != nil {
@@ -162,34 +169,13 @@ func NewStateTree(cst cbor.IpldStore, ver types.StateTreeVersion) (*StateTree, e
 	default:
 		return nil, xerrors.Errorf("unsupported state tree version: %d", ver)
 	}
-
-	store := adt.WrapStore(context.TODO(), cst)
-	var hamt adt.Map
-	switch ver {
-	case types.StateTreeVersion0:
-		tree, err := states0.NewTree(store)
-		if err != nil {
-			return nil, xerrors.Errorf("failed to create state tree: %w", err)
-		}
-		hamt = tree.Map
-	case types.StateTreeVersion1:
-		tree, err := states2.NewTree(store)
-		if err != nil {
-			return nil, xerrors.Errorf("failed to create state tree: %w", err)
-		}
-		hamt = tree.Map
-	case types.StateTreeVersion2:
-		tree, err := states3.NewTree(store)
-		if err != nil {
-			return nil, xerrors.Errorf("failed to create state tree: %w", err)
-		}
-		hamt = tree.Map
-	default:
-		return nil, xerrors.Errorf("unsupported state tree version: %d", ver)
+	root, err := adt.NewMap(adt.WrapStore(context.TODO(), cst), adtForSTVersion(ver))
+	if err != nil {
+		return nil, err
 	}

 	s := &StateTree{
-		root:    hamt,
+		root:    root,
 		info:    info,
 		version: ver,
 		Store:   cst,
@@ -208,49 +194,30 @@ func LoadStateTree(cst cbor.IpldStore, c cid.Cid) (*StateTree, error) {
 		root.Version = types.StateTreeVersion0
 	}

-	store := adt.WrapStore(context.TODO(), cst)
-
-	var (
-		hamt adt.Map
-		err  error
-	)
 	switch root.Version {
-	case types.StateTreeVersion0:
-		var tree *states0.Tree
-		tree, err = states0.LoadTree(store, root.Actors)
-		if tree != nil {
-			hamt = tree.Map
+	case types.StateTreeVersion0, types.StateTreeVersion1:
+		// Load the actual state-tree HAMT.
+		nd, err := adt.AsMap(
+			adt.WrapStore(context.TODO(), cst), root.Actors,
+			adtForSTVersion(root.Version),
+		)
+		if err != nil {
+			log.Errorf("loading hamt node %s failed: %s", c, err)
+			return nil, err
 		}
-	case types.StateTreeVersion1:
-		var tree *states2.Tree
-		tree, err = states2.LoadTree(store, root.Actors)
-		if tree != nil {
-			hamt = tree.Map
-		}
-	case types.StateTreeVersion2:
-		var tree *states3.Tree
-		tree, err = states3.LoadTree(store, root.Actors)
-		if tree != nil {
-			hamt = tree.Map
+
+		s := &StateTree{
+			root:    nd,
+			info:    root.Info,
+			version: root.Version,
+			Store:   cst,
+			snaps:   newStateSnaps(),
 		}
+		s.lookupIDFun = s.lookupIDinternal
+		return s, nil
 	default:
 		return nil, xerrors.Errorf("unsupported state tree version: %d", root.Version)
 	}
-	if err != nil {
-		log.Errorf("failed to load state tree: %s", err)
-		return nil, xerrors.Errorf("failed to load state tree: %w", err)
-	}
-
-	s := &StateTree{
-		root:    hamt,
-		info:    root.Info,
-		version: root.Version,
-		Store:   cst,
-		snaps:   newStateSnaps(),
-	}
-	s.lookupIDFun = s.lookupIDinternal
-
-	return s, nil
 }

 func (st *StateTree) SetActor(addr address.Address, act *types.Actor) error {
@@ -4,20 +4,29 @@ import (
 	"bytes"
 	"context"
 	"encoding/binary"
-	"runtime"
-	"sort"
-	"sync"
-	"time"
+	"math"

-	"github.com/filecoin-project/go-state-types/rt"
+	"github.com/filecoin-project/lotus/chain/actors/builtin"

 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/big"
 	"github.com/filecoin-project/go-state-types/network"
+	"github.com/ipfs/go-cid"
+	cbor "github.com/ipfs/go-ipld-cbor"
+	"golang.org/x/xerrors"
+
+	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
+	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
+	multisig0 "github.com/filecoin-project/specs-actors/actors/builtin/multisig"
+	power0 "github.com/filecoin-project/specs-actors/actors/builtin/power"
+	adt0 "github.com/filecoin-project/specs-actors/actors/util/adt"
+
+	"github.com/filecoin-project/specs-actors/actors/migration/nv3"
+	m2 "github.com/filecoin-project/specs-actors/v2/actors/migration"
+
 	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain/actors/adt"
-	"github.com/filecoin-project/lotus/chain/actors/builtin"
 	init_ "github.com/filecoin-project/lotus/chain/actors/builtin/init"
 	"github.com/filecoin-project/lotus/chain/actors/builtin/multisig"
 	"github.com/filecoin-project/lotus/chain/state"
@@ -26,103 +35,26 @@ import (
 	"github.com/filecoin-project/lotus/chain/vm"
 	bstore "github.com/filecoin-project/lotus/lib/blockstore"
 	"github.com/filecoin-project/lotus/lib/bufbstore"
-	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
-	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
-	multisig0 "github.com/filecoin-project/specs-actors/actors/builtin/multisig"
-	power0 "github.com/filecoin-project/specs-actors/actors/builtin/power"
-	"github.com/filecoin-project/specs-actors/actors/migration/nv3"
-	adt0 "github.com/filecoin-project/specs-actors/actors/util/adt"
-	"github.com/filecoin-project/specs-actors/v2/actors/migration/nv4"
-	"github.com/filecoin-project/specs-actors/v2/actors/migration/nv7"
-	"github.com/filecoin-project/specs-actors/v3/actors/migration/nv10"
-	"github.com/ipfs/go-cid"
-	cbor "github.com/ipfs/go-ipld-cbor"
-	"golang.org/x/xerrors"
 )

-// MigrationCache can be used to cache information used by a migration. This is primarily useful to
-// "pre-compute" some migration state ahead of time, and make it accessible in the migration itself.
-type MigrationCache interface {
-	Write(key string, value cid.Cid) error
-	Read(key string) (bool, cid.Cid, error)
-	Load(key string, loadFunc func() (cid.Cid, error)) (cid.Cid, error)
-}
-
-// MigrationFunc is a migration function run at every upgrade.
+// UpgradeFunc is a migration function run at every upgrade.
 //
-// - The cache is a per-upgrade cache, pre-populated by pre-migrations.
 // - The oldState is the state produced by the upgrade epoch.
 // - The returned newState is the new state that will be used by the next epoch.
 // - The height is the upgrade epoch height (already executed).
 // - The tipset is the tipset for the last non-null block before the upgrade. Do
 //   not assume that ts.Height() is the upgrade height.
-type MigrationFunc func(
-	ctx context.Context,
-	sm *StateManager, cache MigrationCache,
-	cb ExecCallback, oldState cid.Cid,
-	height abi.ChainEpoch, ts *types.TipSet,
-) (newState cid.Cid, err error)
-
-// PreMigrationFunc is a function run _before_ a network upgrade to pre-compute part of the network
-// upgrade and speed it up.
-type PreMigrationFunc func(
-	ctx context.Context,
-	sm *StateManager, cache MigrationCache,
-	oldState cid.Cid,
-	height abi.ChainEpoch, ts *types.TipSet,
-) error
-
-// PreMigration describes a pre-migration step to prepare for a network state upgrade. Pre-migrations
-// are optimizations, are not guaranteed to run, and may be canceled and/or run multiple times.
-type PreMigration struct {
-	// PreMigration is the pre-migration function to run at the specified time. This function is
-	// run asynchronously and must abort promptly when canceled.
-	PreMigration PreMigrationFunc
-
-	// StartWithin specifies that this pre-migration should be started at most StartWithin
-	// epochs before the upgrade.
-	StartWithin abi.ChainEpoch
-
-	// DontStartWithin specifies that this pre-migration should not be started DontStartWithin
-	// epochs before the final upgrade epoch.
-	//
-	// This should be set such that the pre-migration is likely to complete before StopWithin.
-	DontStartWithin abi.ChainEpoch
-
-	// StopWithin specifies that this pre-migration should be stopped StopWithin epochs of the
-	// final upgrade epoch.
-	StopWithin abi.ChainEpoch
-}
+type UpgradeFunc func(ctx context.Context, sm *StateManager, cb ExecCallback, oldState cid.Cid, height abi.ChainEpoch, ts *types.TipSet) (newState cid.Cid, err error)

 type Upgrade struct {
 	Height    abi.ChainEpoch
 	Network   network.Version
 	Expensive bool
-	Migration MigrationFunc
-
-	// PreMigrations specifies a set of pre-migration functions to run at the indicated epochs.
-	// These functions should fill the given cache with information that can speed up the
-	// eventual full migration at the upgrade epoch.
-	PreMigrations []PreMigration
+	Migration UpgradeFunc
 }

 type UpgradeSchedule []Upgrade

-type migrationLogger struct{}
-
-func (ml migrationLogger) Log(level rt.LogLevel, msg string, args ...interface{}) {
-	switch level {
-	case rt.DEBUG:
-		log.Debugf(msg, args...)
-	case rt.INFO:
-		log.Infof(msg, args...)
-	case rt.WARN:
-		log.Warnf(msg, args...)
-	case rt.ERROR:
-		log.Errorf(msg, args...)
-	}
-}
-
 func DefaultUpgradeSchedule() UpgradeSchedule {
 	var us UpgradeSchedule

@@ -148,9 +80,8 @@ func DefaultUpgradeSchedule() UpgradeSchedule {
 		Expensive: true,
 		Migration: UpgradeActorsV2,
 	}, {
-		Height:    build.UpgradeTapeHeight,
-		Network:   network.Version5,
-		Migration: nil,
+		Height:  build.UpgradeTapeHeight,
+		Network: network.Version5,
 	}, {
 		Height:    build.UpgradeLiftoffHeight,
 		Network:   network.Version5,
@@ -159,36 +90,32 @@ func DefaultUpgradeSchedule() UpgradeSchedule {
 		Height:    build.UpgradeKumquatHeight,
 		Network:   network.Version6,
 		Migration: nil,
-	}, {
-		Height:    build.UpgradeCalicoHeight,
-		Network:   network.Version7,
-		Migration: UpgradeCalico,
-	}, {
-		Height:    build.UpgradePersianHeight,
-		Network:   network.Version8,
-		Migration: nil,
-	}, {
-		Height:    build.UpgradeOrangeHeight,
-		Network:   network.Version9,
-		Migration: nil,
-	}, {
-		Height:    build.UpgradeActorsV3Height,
-		Network:   network.Version10,
-		Migration: UpgradeActorsV3,
-		PreMigrations: []PreMigration{{
-			PreMigration:    PreUpgradeActorsV3,
-			StartWithin:     120,
-			DontStartWithin: 60,
-			StopWithin:      35,
-		}, {
-			PreMigration:    PreUpgradeActorsV3,
-			StartWithin:     30,
-			DontStartWithin: 15,
-			StopWithin:      5,
-		}},
-		Expensive: true,
 	}}

+	if build.UpgradeActorsV2Height == math.MaxInt64 { // disable actors upgrade
+		updates = []Upgrade{{
+			Height:    build.UpgradeBreezeHeight,
+			Network:   network.Version1,
+			Migration: UpgradeFaucetBurnRecovery,
+		}, {
+			Height:    build.UpgradeSmokeHeight,
+			Network:   network.Version2,
+			Migration: nil,
+		}, {
+			Height:    build.UpgradeIgnitionHeight,
+			Network:   network.Version3,
+			Migration: UpgradeIgnition,
+		}, {
+			Height:    build.UpgradeRefuelHeight,
+			Network:   network.Version3,
+			Migration: UpgradeRefuel,
+		}, {
+			Height:    build.UpgradeLiftoffHeight,
+			Network:   network.Version3,
+			Migration: UpgradeLiftoff,
+		}}
+	}
+
 	for _, u := range updates {
 		if u.Height < 0 {
 			// upgrade disabled
@@ -200,43 +127,14 @@ func DefaultUpgradeSchedule() UpgradeSchedule {
 }

 func (us UpgradeSchedule) Validate() error {
-	// Make sure each upgrade is valid.
+	// Make sure we're not trying to upgrade to version 0.
 	for _, u := range us {
 		if u.Network <= 0 {
 			return xerrors.Errorf("cannot upgrade to version <= 0: %d", u.Network)
 		}
-
-		for _, m := range u.PreMigrations {
-			if m.StartWithin <= 0 {
-				return xerrors.Errorf("pre-migration must specify a positive start-within epoch")
-			}
-
-			if m.DontStartWithin < 0 || m.StopWithin < 0 {
-				return xerrors.Errorf("pre-migration must specify non-negative epochs")
-			}
-
-			if m.StartWithin <= m.StopWithin {
-				return xerrors.Errorf("pre-migration start-within must come before stop-within")
-			}
-
-			// If we have a dont-start-within.
-			if m.DontStartWithin != 0 {
-				if m.DontStartWithin < m.StopWithin {
-					return xerrors.Errorf("pre-migration dont-start-within must come before stop-within")
-				}
-				if m.StartWithin <= m.DontStartWithin {
-					return xerrors.Errorf("pre-migration start-within must come after dont-start-within")
-				}
-			}
-		}
-		if !sort.SliceIsSorted(u.PreMigrations, func(i, j int) bool {
-			return u.PreMigrations[i].StartWithin > u.PreMigrations[j].StartWithin //nolint:scopelint,gosec
-		}) {
-			return xerrors.Errorf("pre-migrations must be sorted by start epoch")
-		}
 	}

-	// Make sure the upgrade order makes sense.
+	// Make sure all the upgrades make sense.
 	for i := 1; i < len(us); i++ {
 		prev := &us[i-1]
 		curr := &us[i]
@@ -258,26 +156,12 @@ func (us UpgradeSchedule) Validate() error {
 func (sm *StateManager) handleStateForks(ctx context.Context, root cid.Cid, height abi.ChainEpoch, cb ExecCallback, ts *types.TipSet) (cid.Cid, error) {
 	retCid := root
 	var err error
-	u := sm.stateMigrations[height]
-	if u != nil && u.upgrade != nil {
-		startTime := time.Now()
-		log.Warnw("STARTING migration", "height", height)
-		// Yes, we clone the cache, even for the final upgrade epoch. Why? Reverts. We may
-		// have to migrate multiple times.
-		tmpCache := u.cache.Clone()
-		retCid, err = u.upgrade(ctx, sm, tmpCache, cb, root, height, ts)
+	f, ok := sm.stateMigrations[height]
+	if ok {
+		retCid, err = f(ctx, sm, cb, root, height, ts)
 		if err != nil {
-			log.Errorw("FAILED migration", "height", height, "error", err)
 			return cid.Undef, err
 		}
-		// Yes, we update the cache, even for the final upgrade epoch. Why? Reverts. This
-		// can save us a _lot_ of time because very few actors will have changed if we
-		// do a small revert then need to re-run the migration.
-		u.cache.Update(tmpCache)
-		log.Warnw("COMPLETED migration",
-			"height", height,
-			"duration", time.Since(startTime),
-		)
 	}

 	return retCid, nil
@@ -288,109 +172,6 @@ func (sm *StateManager) hasExpensiveFork(ctx context.Context, height abi.ChainEp
 	return ok
 }

-func runPreMigration(ctx context.Context, sm *StateManager, fn PreMigrationFunc, cache *nv10.MemMigrationCache, ts *types.TipSet) {
-	height := ts.Height()
-	parent := ts.ParentState()
-
-	startTime := time.Now()
-
-	log.Warn("STARTING pre-migration")
-	// Clone the cache so we don't actually _update_ it
-	// till we're done. Otherwise, if we fail, the next
-	// migration to use the cache may assume that
-	// certain blocks exist, even if they don't.
-	tmpCache := cache.Clone()
-	err := fn(ctx, sm, tmpCache, parent, height, ts)
-	if err != nil {
-		log.Errorw("FAILED pre-migration", "error", err)
-		return
-	}
-	// Finally, if everything worked, update the cache.
-	cache.Update(tmpCache)
-	log.Warnw("COMPLETED pre-migration", "duration", time.Since(startTime))
-}
-
-func (sm *StateManager) preMigrationWorker(ctx context.Context) {
-	defer close(sm.shutdown)
-
-	ctx, cancel := context.WithCancel(ctx)
-	defer cancel()
-
-	type op struct {
-		after    abi.ChainEpoch
-		notAfter abi.ChainEpoch
-		run      func(ts *types.TipSet)
-	}
-
-	var wg sync.WaitGroup
-	defer wg.Wait()
-
-	// Turn each pre-migration into an operation in a schedule.
-	var schedule []op
-	for upgradeEpoch, migration := range sm.stateMigrations {
-		cache := migration.cache
-		for _, prem := range migration.preMigrations {
-			preCtx, preCancel := context.WithCancel(ctx)
-			migrationFunc := prem.PreMigration
-
-			afterEpoch := upgradeEpoch - prem.StartWithin
-			notAfterEpoch := upgradeEpoch - prem.DontStartWithin
-			stopEpoch := upgradeEpoch - prem.StopWithin
-			// We can't start after we stop.
-			if notAfterEpoch > stopEpoch {
-				notAfterEpoch = stopEpoch - 1
-			}
-
-			// Add an op to start a pre-migration.
-			schedule = append(schedule, op{
-				after:    afterEpoch,
-				notAfter: notAfterEpoch,
-
-				// TODO: are these values correct?
-				run: func(ts *types.TipSet) {
-					wg.Add(1)
-					go func() {
-						defer wg.Done()
-						runPreMigration(preCtx, sm, migrationFunc, cache, ts)
-					}()
-				},
-			})
-
-			// Add an op to cancel the pre-migration if it's still running.
-			schedule = append(schedule, op{
-				after:    stopEpoch,
-				notAfter: -1,
-				run:      func(ts *types.TipSet) { preCancel() },
-			})
-		}
-	}
-
-	// Then sort by epoch.
-	sort.Slice(schedule, func(i, j int) bool {
-		return schedule[i].after < schedule[j].after
-	})
-
-	// Finally, when the head changes, see if there's anything we need to do.
-	//
-	// We're intentionally ignoring reorgs as they don't matter for our purposes.
-	for change := range sm.cs.SubHeadChanges(ctx) {
-		for _, head := range change {
-			for len(schedule) > 0 {
-				op := &schedule[0]
-				if head.Val.Height() < op.after {
-					break
-				}
-
-				// If we haven't passed the pre-migration height...
-				if op.notAfter < 0 || head.Val.Height() < op.notAfter {
-					op.run(head.Val)
-				}
-				schedule = schedule[1:]
-			}
-		}
-	}
-}
-
 func doTransfer(tree types.StateTree, from, to address.Address, amt abi.TokenAmount, cb func(trace types.ExecutionTrace)) error {
 	fromAct, err := tree.GetActor(from)
 	if err != nil {
@@ -444,7 +225,7 @@ func doTransfer(tree types.StateTree, from, to address.Address, amt abi.TokenAmo
 	return nil
 }

-func UpgradeFaucetBurnRecovery(ctx context.Context, sm *StateManager, _ MigrationCache, cb ExecCallback, root cid.Cid, epoch abi.ChainEpoch, ts *types.TipSet) (cid.Cid, error) {
+func UpgradeFaucetBurnRecovery(ctx context.Context, sm *StateManager, cb ExecCallback, root cid.Cid, epoch abi.ChainEpoch, ts *types.TipSet) (cid.Cid, error) {
 	// Some initial parameters
 	FundsForMiners := types.FromFil(1_000_000)
 	LookbackEpoch := abi.ChainEpoch(32000)
@@ -730,7 +511,7 @@ func UpgradeFaucetBurnRecovery(ctx context.Context, sm *StateManager, _ Migratio
 	return tree.Flush(ctx)
 }

-func UpgradeIgnition(ctx context.Context, sm *StateManager, _ MigrationCache, cb ExecCallback, root cid.Cid, epoch abi.ChainEpoch, ts *types.TipSet) (cid.Cid, error) {
+func UpgradeIgnition(ctx context.Context, sm *StateManager, cb ExecCallback, root cid.Cid, epoch abi.ChainEpoch, ts *types.TipSet) (cid.Cid, error) {
 	store := sm.cs.Store(ctx)

 	if build.UpgradeLiftoffHeight <= epoch {
@@ -785,7 +566,7 @@ func UpgradeIgnition(ctx context.Context, sm *StateManager, _ MigrationCache, cb
 	return tree.Flush(ctx)
 }

-func UpgradeRefuel(ctx context.Context, sm *StateManager, _ MigrationCache, cb ExecCallback, root cid.Cid, epoch abi.ChainEpoch, ts *types.TipSet) (cid.Cid, error) {
+func UpgradeRefuel(ctx context.Context, sm *StateManager, cb ExecCallback, root cid.Cid, epoch abi.ChainEpoch, ts *types.TipSet) (cid.Cid, error) {

 	store := sm.cs.Store(ctx)
 	tree, err := sm.StateTree(root)
@@ -811,7 +592,7 @@ func UpgradeRefuel(ctx context.Context, sm *StateManager, _ MigrationCache, cb E
 	return tree.Flush(ctx)
 }

-func UpgradeActorsV2(ctx context.Context, sm *StateManager, _ MigrationCache, cb ExecCallback, root cid.Cid, epoch abi.ChainEpoch, ts *types.TipSet) (cid.Cid, error) {
+func UpgradeActorsV2(ctx context.Context, sm *StateManager, cb ExecCallback, root cid.Cid, epoch abi.ChainEpoch, ts *types.TipSet) (cid.Cid, error) {
 	buf := bufbstore.NewTieredBstore(sm.cs.Blockstore(), bstore.NewTemporarySync())
 	store := store.ActorStore(ctx, buf)

@@ -820,7 +601,7 @@ func UpgradeActorsV2(ctx context.Context, sm *StateManager, _ MigrationCache, cb
 		return cid.Undef, xerrors.Errorf("failed to create new state info for actors v2: %w", err)
 	}

-	newHamtRoot, err := nv4.MigrateStateTree(ctx, store, root, epoch, nv4.DefaultConfig())
+	newHamtRoot, err := m2.MigrateStateTree(ctx, store, root, epoch, m2.DefaultConfig())
 	if err != nil {
 		return cid.Undef, xerrors.Errorf("upgrading to actors v2: %w", err)
 	}
@@ -857,7 +638,7 @@ func UpgradeActorsV2(ctx context.Context, sm *StateManager, _ MigrationCache, cb
 	return newRoot, nil
 }

-func UpgradeLiftoff(ctx context.Context, sm *StateManager, _ MigrationCache, cb ExecCallback, root cid.Cid, epoch abi.ChainEpoch, ts *types.TipSet) (cid.Cid, error) {
+func UpgradeLiftoff(ctx context.Context, sm *StateManager, cb ExecCallback, root cid.Cid, epoch abi.ChainEpoch, ts *types.TipSet) (cid.Cid, error) {
 	tree, err := sm.StateTree(root)
 	if err != nil {
 		return cid.Undef, xerrors.Errorf("getting state tree: %w", err)
@@ -871,140 +652,6 @@ func UpgradeLiftoff(ctx context.Context, sm *StateManager, _ MigrationCache, cb
 	return tree.Flush(ctx)
 }

-func UpgradeCalico(ctx context.Context, sm *StateManager, _ MigrationCache, cb ExecCallback, root cid.Cid, epoch abi.ChainEpoch, ts *types.TipSet) (cid.Cid, error) {
-	store := sm.cs.Store(ctx)
-	var stateRoot types.StateRoot
-	if err := store.Get(ctx, root, &stateRoot); err != nil {
-		return cid.Undef, xerrors.Errorf("failed to decode state root: %w", err)
-	}
-
-	if stateRoot.Version != types.StateTreeVersion1 {
-		return cid.Undef, xerrors.Errorf(
-			"expected state root version 1 for calico upgrade, got %d",
-			stateRoot.Version,
-		)
-	}
-
-	newHamtRoot, err := nv7.MigrateStateTree(ctx, store, stateRoot.Actors, epoch, nv7.DefaultConfig())
-	if err != nil {
-		return cid.Undef, xerrors.Errorf("running nv7 migration: %w", err)
-	}
-
-	newRoot, err := store.Put(ctx, &types.StateRoot{
-		Version: stateRoot.Version,
-		Actors:  newHamtRoot,
-		Info:    stateRoot.Info,
-	})
-	if err != nil {
-		return cid.Undef, xerrors.Errorf("failed to persist new state root: %w", err)
-	}
-
-	// perform some basic sanity checks to make sure everything still works.
-	if newSm, err := state.LoadStateTree(store, newRoot); err != nil {
-		return cid.Undef, xerrors.Errorf("state tree sanity load failed: %w", err)
-	} else if newRoot2, err := newSm.Flush(ctx); err != nil {
-		return cid.Undef, xerrors.Errorf("state tree sanity flush failed: %w", err)
-	} else if newRoot2 != newRoot {
-		return cid.Undef, xerrors.Errorf("state-root mismatch: %s != %s", newRoot, newRoot2)
-	} else if _, err := newSm.GetActor(builtin0.InitActorAddr); err != nil {
-		return cid.Undef, xerrors.Errorf("failed to load init actor after upgrade: %w", err)
-	}
-
-	return newRoot, nil
-}
-
-func UpgradeActorsV3(ctx context.Context, sm *StateManager, cache MigrationCache, cb ExecCallback, root cid.Cid, epoch abi.ChainEpoch, ts *types.TipSet) (cid.Cid, error) {
-	// Use all the CPUs except 3.
-	workerCount := runtime.NumCPU() - 3
-	if workerCount <= 0 {
-		workerCount = 1
-	}
-
-	config := nv10.Config{MaxWorkers: uint(workerCount)}
-	newRoot, err := upgradeActorsV3Common(ctx, sm, cache, root, epoch, ts, config)
-	if err != nil {
-		return cid.Undef, xerrors.Errorf("migrating actors v3 state: %w", err)
-	}
-
-	// perform some basic sanity checks to make sure everything still works.
-	store := store.ActorStore(ctx, sm.ChainStore().Blockstore())
-	if newSm, err := state.LoadStateTree(store, newRoot); err != nil {
-		return cid.Undef, xerrors.Errorf("state tree sanity load failed: %w", err)
-	} else if newRoot2, err := newSm.Flush(ctx); err != nil {
-		return cid.Undef, xerrors.Errorf("state tree sanity flush failed: %w", err)
-	} else if newRoot2 != newRoot {
-		return cid.Undef, xerrors.Errorf("state-root mismatch: %s != %s", newRoot, newRoot2)
-	} else if _, err := newSm.GetActor(init_.Address); err != nil {
-		return cid.Undef, xerrors.Errorf("failed to load init actor after upgrade: %w", err)
-	}
-
-	return newRoot, nil
-}
-
-func PreUpgradeActorsV3(ctx context.Context, sm *StateManager, cache MigrationCache, root cid.Cid, epoch abi.ChainEpoch, ts *types.TipSet) error {
-	// Use half the CPUs for pre-migration, but leave at least 3.
-	workerCount := runtime.NumCPU()
-	if workerCount <= 4 {
-		workerCount = 1
-	} else {
-		workerCount /= 2
-	}
-	config := nv10.Config{MaxWorkers: uint(workerCount)}
-	_, err := upgradeActorsV3Common(ctx, sm, cache, root, epoch, ts, config)
-	return err
-}
-
-func upgradeActorsV3Common(
-	ctx context.Context, sm *StateManager, cache MigrationCache,
-	root cid.Cid, epoch abi.ChainEpoch, ts *types.TipSet,
-	config nv10.Config,
-) (cid.Cid, error) {
-	buf := bufbstore.NewTieredBstore(sm.cs.Blockstore(), bstore.NewTemporarySync())
-	store := store.ActorStore(ctx, buf)
-
-	// Load the state root.
-	var stateRoot types.StateRoot
-	if err := store.Get(ctx, root, &stateRoot); err != nil {
-		return cid.Undef, xerrors.Errorf("failed to decode state root: %w", err)
-	}
-
-	if stateRoot.Version != types.StateTreeVersion1 {
-		return cid.Undef, xerrors.Errorf(
-			"expected state root version 1 for actors v3 upgrade, got %d",
-			stateRoot.Version,
-		)
-	}
-
-	// Perform the migration
-	newHamtRoot, err := nv10.MigrateStateTree(ctx, store, stateRoot.Actors, epoch, config, migrationLogger{}, cache)
-	if err != nil {
-		return cid.Undef, xerrors.Errorf("upgrading to actors v2: %w", err)
-	}
-
-	// Persist the result.
-	newRoot, err := store.Put(ctx, &types.StateRoot{
-		Version: types.StateTreeVersion2,
-		Actors:  newHamtRoot,
-		Info:    stateRoot.Info,
-	})
-	if err != nil {
-		return cid.Undef, xerrors.Errorf("failed to persist new state root: %w", err)
-	}
-
-	// Persist the new tree.
-
-	{
-		from := buf
-		to := buf.Read()
-
-		if err := vm.Copy(ctx, from, to, newRoot); err != nil {
-			return cid.Undef, xerrors.Errorf("copying migrated tree: %w", err)
-		}
-	}
-
-	return newRoot, nil
-}
-
 func setNetworkName(ctx context.Context, store adt.Store, tree *state.StateTree, name string) error {
 	ia, err := tree.GetActor(builtin0.InitActorAddr)
 	if err != nil {
@@ -4,7 +4,6 @@ import (
 	"context"
 	"fmt"
 	"io"
-	"sync"
 	"testing"

 	"github.com/ipfs/go-cid"
@@ -123,7 +122,7 @@ func TestForkHeightTriggers(t *testing.T) {
 		cg.ChainStore(), UpgradeSchedule{{
 			Network: 1,
 			Height:  testForkHeight,
-			Migration: func(ctx context.Context, sm *StateManager, cache MigrationCache, cb ExecCallback,
+			Migration: func(ctx context.Context, sm *StateManager, cb ExecCallback,
 				root cid.Cid, height abi.ChainEpoch, ts *types.TipSet) (cid.Cid, error) {
 				cst := ipldcbor.NewCborStore(sm.ChainStore().Blockstore())

@@ -253,7 +252,7 @@ func TestForkRefuseCall(t *testing.T) {
 			Network:   1,
 			Expensive: true,
 			Height:    testForkHeight,
-			Migration: func(ctx context.Context, sm *StateManager, cache MigrationCache, cb ExecCallback,
+			Migration: func(ctx context.Context, sm *StateManager, cb ExecCallback,
 				root cid.Cid, height abi.ChainEpoch, ts *types.TipSet) (cid.Cid, error) {
 				return root, nil
 			}}})
@@ -318,166 +317,3 @@ func TestForkRefuseCall(t *testing.T) {
 		}
 	}
 }
-
-func TestForkPreMigration(t *testing.T) {
-	logging.SetAllLoggers(logging.LevelInfo)
-
-	cg, err := gen.NewGenerator()
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	fooCid, err := abi.CidBuilder.Sum([]byte("foo"))
-	require.NoError(t, err)
-
-	barCid, err := abi.CidBuilder.Sum([]byte("bar"))
-	require.NoError(t, err)
-
-	failCid, err := abi.CidBuilder.Sum([]byte("fail"))
-	require.NoError(t, err)
-
-	var wait20 sync.WaitGroup
-	wait20.Add(3)
-
-	wasCanceled := make(chan struct{})
-
-	checkCache := func(t *testing.T, cache MigrationCache) {
-		found, value, err := cache.Read("foo")
-		require.NoError(t, err)
-		require.True(t, found)
-		require.Equal(t, fooCid, value)
-
-		found, value, err = cache.Read("bar")
-		require.NoError(t, err)
-		require.True(t, found)
-		require.Equal(t, barCid, value)
-
-		found, _, err = cache.Read("fail")
-		require.NoError(t, err)
-		require.False(t, found)
-	}
-
-	counter := make(chan struct{}, 10)
-
-	sm, err := NewStateManagerWithUpgradeSchedule(
-		cg.ChainStore(), UpgradeSchedule{{
-			Network: 1,
-			Height:  testForkHeight,
-			Migration: func(ctx context.Context, sm *StateManager, cache MigrationCache, cb ExecCallback,
-				root cid.Cid, height abi.ChainEpoch, ts *types.TipSet) (cid.Cid, error) {
-
-				// Make sure the test that should be canceled, is canceled.
-				select {
-				case <-wasCanceled:
-				case <-ctx.Done():
-					return cid.Undef, ctx.Err()
-				}
-
-				// the cache should be setup correctly.
-				checkCache(t, cache)
-
-				counter <- struct{}{}
-
-				return root, nil
-			},
-			PreMigrations: []PreMigration{{
-				StartWithin: 20,
-				PreMigration: func(ctx context.Context, _ *StateManager, cache MigrationCache,
-					_ cid.Cid, _ abi.ChainEpoch, _ *types.TipSet) error {
-					wait20.Done()
-					wait20.Wait()
-
-					err := cache.Write("foo", fooCid)
-					require.NoError(t, err)
-
-					counter <- struct{}{}
-
-					return nil
-				},
-			}, {
-				StartWithin: 20,
-				PreMigration: func(ctx context.Context, _ *StateManager, cache MigrationCache,
-					_ cid.Cid, _ abi.ChainEpoch, _ *types.TipSet) error {
-					wait20.Done()
-					wait20.Wait()
-
-					err := cache.Write("bar", barCid)
-					require.NoError(t, err)
-
-					counter <- struct{}{}
-
-					return nil
-				},
-			}, {
-				StartWithin: 20,
-				PreMigration: func(ctx context.Context, _ *StateManager, cache MigrationCache,
-					_ cid.Cid, _ abi.ChainEpoch, _ *types.TipSet) error {
-					wait20.Done()
-					wait20.Wait()
-
-					err := cache.Write("fail", failCid)
-					require.NoError(t, err)
-
-					counter <- struct{}{}
-
-					// Fail this migration. The cached entry should not be persisted.
-					return fmt.Errorf("failed")
-				},
-			}, {
-				StartWithin: 15,
-				StopWithin:  5,
-				PreMigration: func(ctx context.Context, _ *StateManager, cache MigrationCache,
-					_ cid.Cid, _ abi.ChainEpoch, _ *types.TipSet) error {
-
-					<-ctx.Done()
-					close(wasCanceled)
-
-					counter <- struct{}{}
-
-					return nil
-				},
-			}, {
-				StartWithin: 10,
-				PreMigration: func(ctx context.Context, _ *StateManager, cache MigrationCache,
-					_ cid.Cid, _ abi.ChainEpoch, _ *types.TipSet) error {
-
-					checkCache(t, cache)
-
-					counter <- struct{}{}
-
-					return nil
-				},
-			}}},
-		})
-	if err != nil {
-		t.Fatal(err)
-	}
-	require.NoError(t, sm.Start(context.Background()))
-	defer func() {
-		require.NoError(t, sm.Stop(context.Background()))
-	}()
-
-	inv := vm.NewActorRegistry()
-	inv.Register(nil, testActor{})
-
-	sm.SetVMConstructor(func(ctx context.Context, vmopt *vm.VMOpts) (*vm.VM, error) {
-		nvm, err := vm.NewVM(ctx, vmopt)
-		if err != nil {
-			return nil, err
-		}
-		nvm.SetInvoker(inv)
-		return nvm, nil
-	})
-
-	cg.SetStateManager(sm)
-
-	for i := 0; i < 50; i++ {
-		_, err := cg.NextTipSet()
-		if err != nil {
-			t.Fatal(err)
-		}
-	}
-	// We have 5 pre-migration steps, and the migration. They should all have written something
-	// to this channel.
-	require.Equal(t, 6, len(counter))
-}
@@ -20,10 +20,6 @@ import (

 	// Used for genesis.
 	msig0 "github.com/filecoin-project/specs-actors/actors/builtin/multisig"
-	"github.com/filecoin-project/specs-actors/v3/actors/migration/nv10"
-
-	// we use the same adt for all receipts
-	blockadt "github.com/filecoin-project/specs-actors/actors/util/adt"

 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/build"
@@ -46,7 +42,6 @@ import (
 )

 const LookbackNoLimit = abi.ChainEpoch(-1)
-const ReceiptAmtBitwidth = 3

 var log = logging.Logger("statemgr")

@@ -63,40 +58,27 @@ type versionSpec struct {
 	atOrBelow      abi.ChainEpoch
 }

-type migration struct {
-	upgrade       MigrationFunc
-	preMigrations []PreMigration
-	cache         *nv10.MemMigrationCache
-}
-
 type StateManager struct {
 	cs *store.ChainStore

-	cancel   context.CancelFunc
-	shutdown chan struct{}
-
 	// Determines the network version at any given epoch.
 	networkVersions []versionSpec
 	latestVersion   network.Version

-	// Maps chain epochs to migrations.
-	stateMigrations map[abi.ChainEpoch]*migration
+	// Maps chain epochs to upgrade functions.
+	stateMigrations map[abi.ChainEpoch]UpgradeFunc
 	// A set of potentially expensive/time consuming upgrades. Explicit
 	// calls for, e.g., gas estimation fail against this epoch with
 	// ErrExpensiveFork.
 	expensiveUpgrades map[abi.ChainEpoch]struct{}

-	stCache             map[string][]cid.Cid
-	compWait            map[string]chan struct{}
-	stlk                sync.Mutex
-	genesisMsigLk       sync.Mutex
-	newVM               func(context.Context, *vm.VMOpts) (*vm.VM, error)
-	preIgnitionVesting  []msig0.State
-	postIgnitionVesting []msig0.State
-	postCalicoVesting   []msig0.State
-
-	genesisPledge      abi.TokenAmount
-	genesisMarketFunds abi.TokenAmount
+	stCache              map[string][]cid.Cid
+	compWait             map[string]chan struct{}
+	stlk                 sync.Mutex
+	genesisMsigLk        sync.Mutex
+	newVM                func(context.Context, *vm.VMOpts) (*vm.VM, error)
+	preIgnitionGenInfos  *genesisInfo
+	postIgnitionGenInfos *genesisInfo
 }

 func NewStateManager(cs *store.ChainStore) *StateManager {
@@ -113,7 +95,7 @@ func NewStateManagerWithUpgradeSchedule(cs *store.ChainStore, us UpgradeSchedule
 		return nil, err
 	}

-	stateMigrations := make(map[abi.ChainEpoch]*migration, len(us))
+	stateMigrations := make(map[abi.ChainEpoch]UpgradeFunc, len(us))
 	expensiveUpgrades := make(map[abi.ChainEpoch]struct{}, len(us))
 	var networkVersions []versionSpec
 	lastVersion := network.Version0
@@ -121,13 +103,8 @@ func NewStateManagerWithUpgradeSchedule(cs *store.ChainStore, us UpgradeSchedule
 		// If we have any upgrades, process them and create a version
 		// schedule.
 		for _, upgrade := range us {
-			if upgrade.Migration != nil || upgrade.PreMigrations != nil {
-				migration := &migration{
-					upgrade:       upgrade.Migration,
-					preMigrations: upgrade.PreMigrations,
-					cache:         nv10.NewMemMigrationCache(),
-				}
-				stateMigrations[upgrade.Height] = migration
+			if upgrade.Migration != nil {
+				stateMigrations[upgrade.Height] = upgrade.Migration
 			}
 			if upgrade.Expensive {
 				expensiveUpgrades[upgrade.Height] = struct{}{}
@@ -163,33 +140,6 @@ func cidsToKey(cids []cid.Cid) string {
 	return out
 }

-// Start starts the state manager's optional background processes. At the moment, this schedules
-// pre-migration functions to run ahead of network upgrades.
-//
-// This method is not safe to invoke from multiple threads or concurrently with Stop.
-func (sm *StateManager) Start(context.Context) error {
-	var ctx context.Context
-	ctx, sm.cancel = context.WithCancel(context.Background())
-	sm.shutdown = make(chan struct{})
-	go sm.preMigrationWorker(ctx)
-	return nil
-}
-
-// Stop starts the state manager's background processes.
-//
-// This method is not safe to invoke concurrently with Start.
-func (sm *StateManager) Stop(ctx context.Context) error {
-	if sm.cancel != nil {
-		sm.cancel()
-		select {
-		case <-sm.shutdown:
-		case <-ctx.Done():
-			return ctx.Err()
-		}
-	}
-	return nil
-}
-
 func (sm *StateManager) TipSetState(ctx context.Context, ts *types.TipSet) (st cid.Cid, rec cid.Cid, err error) {
 	ctx, span := trace.StartSpan(ctx, "tipSetState")
 	defer span.End()
@@ -430,7 +380,11 @@ func (sm *StateManager) ApplyBlocks(ctx context.Context, parentEpoch abi.ChainEp
 		return cid.Cid{}, cid.Cid{}, err
 	}

-	rectarr := blockadt.MakeEmptyArray(sm.cs.Store(ctx))
+	// XXX: Is the height correct? Or should it be epoch-1?
+	rectarr, err := adt.NewArray(sm.cs.Store(ctx), actors.VersionForNetwork(sm.GetNtwkVersion(ctx, epoch)))
+	if err != nil {
+		return cid.Undef, cid.Undef, xerrors.Errorf("failed to create receipts amt: %w", err)
+	}
 	for i, receipt := range receipts {
 		if err := rectarr.Set(uint64(i), receipt); err != nil {
 			return cid.Undef, cid.Undef, xerrors.Errorf("failed to build receipts amt: %w", err)
@@ -515,26 +469,13 @@ func (sm *StateManager) ResolveToKeyAddress(ctx context.Context, addr address.Ad
 		ts = sm.cs.GetHeaviestTipSet()
 	}

-	cst := cbor.NewCborStore(sm.cs.Blockstore())
-
-	// First try to resolve the actor in the parent state, so we don't have to compute anything.
-	tree, err := state.LoadStateTree(cst, ts.ParentState())
-	if err != nil {
-		return address.Undef, xerrors.Errorf("failed to load parent state tree: %w", err)
-	}
-
-	resolved, err := vm.ResolveToKeyAddr(tree, cst, addr)
-	if err == nil {
-		return resolved, nil
-	}
-
-	// If that fails, compute the tip-set and try again.
 	st, _, err := sm.TipSetState(ctx, ts)
 	if err != nil {
 		return address.Undef, xerrors.Errorf("resolve address failed to get tipset state: %w", err)
 	}

-	tree, err = state.LoadStateTree(cst, st)
+	cst := cbor.NewCborStore(sm.cs.Blockstore())
+	tree, err := state.LoadStateTree(cst, st)
 	if err != nil {
 		return address.Undef, xerrors.Errorf("failed to load state tree")
 	}
@@ -694,7 +635,7 @@ func (sm *StateManager) WaitForMessage(ctx context.Context, mcid cid.Cid, confid
 	}
 }

-func (sm *StateManager) SearchForMessage(ctx context.Context, mcid cid.Cid, lookbackLimit abi.ChainEpoch) (*types.TipSet, *types.MessageReceipt, cid.Cid, error) {
+func (sm *StateManager) SearchForMessage(ctx context.Context, mcid cid.Cid) (*types.TipSet, *types.MessageReceipt, cid.Cid, error) {
 	msg, err := sm.cs.GetCMessage(mcid)
 	if err != nil {
 		return nil, nil, cid.Undef, fmt.Errorf("failed to load message: %w", err)
@@ -711,7 +652,7 @@ func (sm *StateManager) SearchForMessage(ctx context.Context, mcid cid.Cid, look
 		return head, r, foundMsg, nil
 	}

-	fts, r, foundMsg, err := sm.searchBackForMsg(ctx, head, msg, lookbackLimit)
+	fts, r, foundMsg, err := sm.searchBackForMsg(ctx, head, msg, LookbackNoLimit)

 	if err != nil {
 		log.Warnf("failed to look back through chain for message %s", mcid)
@@ -948,8 +889,23 @@ func (sm *StateManager) SetVMConstructor(nvm func(context.Context, *vm.VMOpts) (
 	sm.newVM = nvm
 }

-// sets up information about the vesting schedule
-func (sm *StateManager) setupGenesisVestingSchedule(ctx context.Context) error {
+type genesisInfo struct {
+	genesisMsigs []msig0.State
+	// info about the Accounts in the genesis state
+	genesisActors      []genesisActor
+	genesisPledge      abi.TokenAmount
+	genesisMarketFunds abi.TokenAmount
+}
+
+type genesisActor struct {
+	addr    address.Address
+	initBal abi.TokenAmount
+}
+
+// sets up information about the actors in the genesis state
+func (sm *StateManager) setupGenesisActors(ctx context.Context) error {
+
+	gi := genesisInfo{}

 	gb, err := sm.cs.GetGenesis()
 	if err != nil {
@@ -972,58 +928,127 @@ func (sm *StateManager) setupGenesisVestingSchedule(ctx context.Context) error {
 		return xerrors.Errorf("loading state tree: %w", err)
 	}

-	gmf, err := getFilMarketLocked(ctx, sTree)
+	gi.genesisMarketFunds, err = getFilMarketLocked(ctx, sTree)
 	if err != nil {
 		return xerrors.Errorf("setting up genesis market funds: %w", err)
 	}

-	gp, err := getFilPowerLocked(ctx, sTree)
+	gi.genesisPledge, err = getFilPowerLocked(ctx, sTree)
 	if err != nil {
 		return xerrors.Errorf("setting up genesis pledge: %w", err)
 	}

-	sm.genesisMarketFunds = gmf
-	sm.genesisPledge = gp
-
 	totalsByEpoch := make(map[abi.ChainEpoch]abi.TokenAmount)
+	err = sTree.ForEach(func(kaddr address.Address, act *types.Actor) error {
+		if builtin.IsMultisigActor(act.Code) {
+			s, err := multisig.Load(sm.cs.Store(ctx), act)
+			if err != nil {
+				return err
+			}

-	// 6 months
-	sixMonths := abi.ChainEpoch(183 * builtin.EpochsInDay)
-	totalsByEpoch[sixMonths] = big.NewInt(49_929_341)
-	totalsByEpoch[sixMonths] = big.Add(totalsByEpoch[sixMonths], big.NewInt(32_787_700))
+			se, err := s.StartEpoch()
+			if err != nil {
+				return err
+			}

-	// 1 year
-	oneYear := abi.ChainEpoch(365 * builtin.EpochsInDay)
-	totalsByEpoch[oneYear] = big.NewInt(22_421_712)
+			if se != 0 {
+				return xerrors.New("genesis multisig doesn't start vesting at epoch 0!")
+			}

-	// 2 years
-	twoYears := abi.ChainEpoch(2 * 365 * builtin.EpochsInDay)
-	totalsByEpoch[twoYears] = big.NewInt(7_223_364)
+			ud, err := s.UnlockDuration()
+			if err != nil {
+				return err
+			}

-	// 3 years
-	threeYears := abi.ChainEpoch(3 * 365 * builtin.EpochsInDay)
-	totalsByEpoch[threeYears] = big.NewInt(87_637_883)
+			ib, err := s.InitialBalance()
+			if err != nil {
+				return err
+			}

-	// 6 years
-	sixYears := abi.ChainEpoch(6 * 365 * builtin.EpochsInDay)
-	totalsByEpoch[sixYears] = big.NewInt(100_000_000)
-	totalsByEpoch[sixYears] = big.Add(totalsByEpoch[sixYears], big.NewInt(300_000_000))
+			ot, f := totalsByEpoch[ud]
+			if f {
+				totalsByEpoch[ud] = big.Add(ot, ib)
+			} else {
+				totalsByEpoch[ud] = ib
+			}

-	sm.preIgnitionVesting = make([]msig0.State, 0, len(totalsByEpoch))
+		} else if builtin.IsAccountActor(act.Code) {
+			// should exclude burnt funds actor and "remainder account actor"
+			// should only ever be "faucet" accounts in testnets
+			if kaddr == builtin.BurntFundsActorAddr {
+				return nil
+			}
+
+			kid, err := sTree.LookupID(kaddr)
+			if err != nil {
+				return xerrors.Errorf("resolving address: %w", err)
+			}
+
+			gi.genesisActors = append(gi.genesisActors, genesisActor{
+				addr:    kid,
+				initBal: act.Balance,
+			})
+		}
+		return nil
+	})
+
+	if err != nil {
+		return xerrors.Errorf("error setting up genesis infos: %w", err)
+	}
+
+	// TODO: use network upgrade abstractions or always start at actors v0?
+	gi.genesisMsigs = make([]msig0.State, 0, len(totalsByEpoch))
 	for k, v := range totalsByEpoch {
 		ns := msig0.State{
 			InitialBalance: v,
 			UnlockDuration: k,
 			PendingTxns:    cid.Undef,
 		}
-		sm.preIgnitionVesting = append(sm.preIgnitionVesting, ns)
+		gi.genesisMsigs = append(gi.genesisMsigs, ns)
 	}

+	sm.preIgnitionGenInfos = &gi
+
 	return nil
 }

-// sets up information about the vesting schedule post the ignition upgrade
-func (sm *StateManager) setupPostIgnitionVesting(ctx context.Context) error {
+// sets up information about the actors in the genesis state
+// For testnet we use a hardcoded set of multisig states, instead of what's actually in the genesis multisigs
+// We also do not consider ANY account actors (including the faucet)
+func (sm *StateManager) setupPreIgnitionGenesisActorsTestnet(ctx context.Context) error {
+
+	gi := genesisInfo{}
+
+	gb, err := sm.cs.GetGenesis()
+	if err != nil {
+		return xerrors.Errorf("getting genesis block: %w", err)
+	}
+
+	gts, err := types.NewTipSet([]*types.BlockHeader{gb})
+	if err != nil {
+		return xerrors.Errorf("getting genesis tipset: %w", err)
+	}
+
+	st, _, err := sm.TipSetState(ctx, gts)
+	if err != nil {
+		return xerrors.Errorf("getting genesis tipset state: %w", err)
+	}
+
+	cst := cbor.NewCborStore(sm.cs.Blockstore())
+	sTree, err := state.LoadStateTree(cst, st)
+	if err != nil {
+		return xerrors.Errorf("loading state tree: %w", err)
+	}
+
+	gi.genesisMarketFunds, err = getFilMarketLocked(ctx, sTree)
+	if err != nil {
+		return xerrors.Errorf("setting up genesis market funds: %w", err)
+	}
+
+	gi.genesisPledge, err = getFilPowerLocked(ctx, sTree)
+	if err != nil {
+		return xerrors.Errorf("setting up genesis pledge: %w", err)
+	}

 	totalsByEpoch := make(map[abi.ChainEpoch]abi.TokenAmount)

@@ -1049,7 +1074,84 @@ func (sm *StateManager) setupPostIgnitionVesting(ctx context.Context) error {
 	totalsByEpoch[sixYears] = big.NewInt(100_000_000)
 	totalsByEpoch[sixYears] = big.Add(totalsByEpoch[sixYears], big.NewInt(300_000_000))

-	sm.postIgnitionVesting = make([]msig0.State, 0, len(totalsByEpoch))
+	gi.genesisMsigs = make([]msig0.State, 0, len(totalsByEpoch))
+	for k, v := range totalsByEpoch {
+		ns := msig0.State{
+			InitialBalance: v,
+			UnlockDuration: k,
+			PendingTxns:    cid.Undef,
+		}
+		gi.genesisMsigs = append(gi.genesisMsigs, ns)
+	}
+
+	sm.preIgnitionGenInfos = &gi
+
+	return nil
+}
+
+// sets up information about the actors in the genesis state, post the ignition fork
+func (sm *StateManager) setupPostIgnitionGenesisActors(ctx context.Context) error {
+
+	gi := genesisInfo{}
+
+	gb, err := sm.cs.GetGenesis()
+	if err != nil {
+		return xerrors.Errorf("getting genesis block: %w", err)
+	}
+
+	gts, err := types.NewTipSet([]*types.BlockHeader{gb})
+	if err != nil {
+		return xerrors.Errorf("getting genesis tipset: %w", err)
+	}
+
+	st, _, err := sm.TipSetState(ctx, gts)
+	if err != nil {
+		return xerrors.Errorf("getting genesis tipset state: %w", err)
+	}
+
+	cst := cbor.NewCborStore(sm.cs.Blockstore())
+	sTree, err := state.LoadStateTree(cst, st)
+	if err != nil {
+		return xerrors.Errorf("loading state tree: %w", err)
+	}
+
+	// Unnecessary, should be removed
+	gi.genesisMarketFunds, err = getFilMarketLocked(ctx, sTree)
+	if err != nil {
+		return xerrors.Errorf("setting up genesis market funds: %w", err)
+	}
+
+	// Unnecessary, should be removed
+	gi.genesisPledge, err = getFilPowerLocked(ctx, sTree)
+	if err != nil {
+		return xerrors.Errorf("setting up genesis pledge: %w", err)
+	}
+
+	totalsByEpoch := make(map[abi.ChainEpoch]abi.TokenAmount)
+
+	// 6 months
+	sixMonths := abi.ChainEpoch(183 * builtin.EpochsInDay)
+	totalsByEpoch[sixMonths] = big.NewInt(49_929_341)
+	totalsByEpoch[sixMonths] = big.Add(totalsByEpoch[sixMonths], big.NewInt(32_787_700))
+
+	// 1 year
+	oneYear := abi.ChainEpoch(365 * builtin.EpochsInDay)
+	totalsByEpoch[oneYear] = big.NewInt(22_421_712)
+
+	// 2 years
+	twoYears := abi.ChainEpoch(2 * 365 * builtin.EpochsInDay)
+	totalsByEpoch[twoYears] = big.NewInt(7_223_364)
+
+	// 3 years
+	threeYears := abi.ChainEpoch(3 * 365 * builtin.EpochsInDay)
+	totalsByEpoch[threeYears] = big.NewInt(87_637_883)
+
+	// 6 years
+	sixYears := abi.ChainEpoch(6 * 365 * builtin.EpochsInDay)
+	totalsByEpoch[sixYears] = big.NewInt(100_000_000)
+	totalsByEpoch[sixYears] = big.Add(totalsByEpoch[sixYears], big.NewInt(300_000_000))
+
+	gi.genesisMsigs = make([]msig0.State, 0, len(totalsByEpoch))
 	for k, v := range totalsByEpoch {
 		ns := msig0.State{
 			// In the pre-ignition logic, we incorrectly set this value in Fil, not attoFil, an off-by-10^18 error
@@ -1059,56 +1161,10 @@ func (sm *StateManager) setupPostIgnitionVesting(ctx context.Context) error {
 			// In the pre-ignition logic, the start epoch was 0. This changes in the fork logic of the Ignition upgrade itself.
 			StartEpoch: build.UpgradeLiftoffHeight,
 		}
-		sm.postIgnitionVesting = append(sm.postIgnitionVesting, ns)
+		gi.genesisMsigs = append(gi.genesisMsigs, ns)
 	}

-	return nil
-}
-
-// sets up information about the vesting schedule post the calico upgrade
-func (sm *StateManager) setupPostCalicoVesting(ctx context.Context) error {
-
-	totalsByEpoch := make(map[abi.ChainEpoch]abi.TokenAmount)
-
-	// 0 days
-	zeroDays := abi.ChainEpoch(0)
-	totalsByEpoch[zeroDays] = big.NewInt(10_632_000)
-
-	// 6 months
-	sixMonths := abi.ChainEpoch(183 * builtin.EpochsInDay)
-	totalsByEpoch[sixMonths] = big.NewInt(19_015_887)
-	totalsByEpoch[sixMonths] = big.Add(totalsByEpoch[sixMonths], big.NewInt(32_787_700))
-
-	// 1 year
-	oneYear := abi.ChainEpoch(365 * builtin.EpochsInDay)
-	totalsByEpoch[oneYear] = big.NewInt(22_421_712)
-	totalsByEpoch[oneYear] = big.Add(totalsByEpoch[oneYear], big.NewInt(9_400_000))
-
-	// 2 years
-	twoYears := abi.ChainEpoch(2 * 365 * builtin.EpochsInDay)
-	totalsByEpoch[twoYears] = big.NewInt(7_223_364)
-
-	// 3 years
-	threeYears := abi.ChainEpoch(3 * 365 * builtin.EpochsInDay)
-	totalsByEpoch[threeYears] = big.NewInt(87_637_883)
-	totalsByEpoch[threeYears] = big.Add(totalsByEpoch[threeYears], big.NewInt(898_958))
-
-	// 6 years
-	sixYears := abi.ChainEpoch(6 * 365 * builtin.EpochsInDay)
-	totalsByEpoch[sixYears] = big.NewInt(100_000_000)
-	totalsByEpoch[sixYears] = big.Add(totalsByEpoch[sixYears], big.NewInt(300_000_000))
-	totalsByEpoch[sixYears] = big.Add(totalsByEpoch[sixYears], big.NewInt(9_805_053))
-
-	sm.postCalicoVesting = make([]msig0.State, 0, len(totalsByEpoch))
-	for k, v := range totalsByEpoch {
-		ns := msig0.State{
-			InitialBalance: big.Mul(v, big.NewInt(int64(build.FilecoinPrecision))),
-			UnlockDuration: k,
-			PendingTxns:    cid.Undef,
-			StartEpoch:     build.UpgradeLiftoffHeight,
-		}
-		sm.postCalicoVesting = append(sm.postCalicoVesting, ns)
-	}
+	sm.postIgnitionGenInfos = &gi

 	return nil
 }
@@ -1119,19 +1175,12 @@ func (sm *StateManager) setupPostCalicoVesting(ctx context.Context) error {
 func (sm *StateManager) GetFilVested(ctx context.Context, height abi.ChainEpoch, st *state.StateTree) (abi.TokenAmount, error) {
 	vf := big.Zero()
 	if height <= build.UpgradeIgnitionHeight {
-		for _, v := range sm.preIgnitionVesting {
+		for _, v := range sm.preIgnitionGenInfos.genesisMsigs {
 			au := big.Sub(v.InitialBalance, v.AmountLocked(height))
 			vf = big.Add(vf, au)
 		}
-	} else if height <= build.UpgradeCalicoHeight {
-		for _, v := range sm.postIgnitionVesting {
-			// In the pre-ignition logic, we simply called AmountLocked(height), assuming startEpoch was 0.
-			// The start epoch changed in the Ignition upgrade.
-			au := big.Sub(v.InitialBalance, v.AmountLocked(height-v.StartEpoch))
-			vf = big.Add(vf, au)
-		}
 	} else {
-		for _, v := range sm.postCalicoVesting {
+		for _, v := range sm.postIgnitionGenInfos.genesisMsigs {
 			// In the pre-ignition logic, we simply called AmountLocked(height), assuming startEpoch was 0.
 			// The start epoch changed in the Ignition upgrade.
 			au := big.Sub(v.InitialBalance, v.AmountLocked(height-v.StartEpoch))
@@ -1139,12 +1188,26 @@ func (sm *StateManager) GetFilVested(ctx context.Context, height abi.ChainEpoch,
 		}
 	}

+	// there should not be any such accounts in testnet (and also none in mainnet?)
+	// continue to use preIgnitionGenInfos, nothing changed at the Ignition epoch
+	for _, v := range sm.preIgnitionGenInfos.genesisActors {
+		act, err := st.GetActor(v.addr)
+		if err != nil {
+			return big.Zero(), xerrors.Errorf("failed to get actor: %w", err)
+		}
+
+		diff := big.Sub(v.initBal, act.Balance)
+		if diff.GreaterThan(big.Zero()) {
+			vf = big.Add(vf, diff)
+		}
+	}
+
 	// After UpgradeActorsV2Height these funds are accounted for in GetFilReserveDisbursed
 	if height <= build.UpgradeActorsV2Height {
 		// continue to use preIgnitionGenInfos, nothing changed at the Ignition epoch
-		vf = big.Add(vf, sm.genesisPledge)
+		vf = big.Add(vf, sm.preIgnitionGenInfos.genesisPledge)
 		// continue to use preIgnitionGenInfos, nothing changed at the Ignition epoch
-		vf = big.Add(vf, sm.genesisMarketFunds)
+		vf = big.Add(vf, sm.preIgnitionGenInfos.genesisMarketFunds)
 	}

 	return vf, nil
@@ -1238,22 +1301,16 @@ func (sm *StateManager) GetVMCirculatingSupply(ctx context.Context, height abi.C
 func (sm *StateManager) GetVMCirculatingSupplyDetailed(ctx context.Context, height abi.ChainEpoch, st *state.StateTree) (api.CirculatingSupply, error) {
 	sm.genesisMsigLk.Lock()
 	defer sm.genesisMsigLk.Unlock()
-	if sm.preIgnitionVesting == nil || sm.genesisPledge.IsZero() || sm.genesisMarketFunds.IsZero() {
-		err := sm.setupGenesisVestingSchedule(ctx)
+	if sm.preIgnitionGenInfos == nil {
+		err := sm.setupPreIgnitionGenesisActorsTestnet(ctx)
 		if err != nil {
-			return api.CirculatingSupply{}, xerrors.Errorf("failed to setup pre-ignition vesting schedule: %w", err)
+			return api.CirculatingSupply{}, xerrors.Errorf("failed to setup pre-ignition genesis information: %w", err)
 		}
 	}
-	if sm.postIgnitionVesting == nil {
-		err := sm.setupPostIgnitionVesting(ctx)
+	if sm.postIgnitionGenInfos == nil {
+		err := sm.setupPostIgnitionGenesisActors(ctx)
 		if err != nil {
-			return api.CirculatingSupply{}, xerrors.Errorf("failed to setup post-ignition vesting schedule: %w", err)
-		}
-	}
-	if sm.postCalicoVesting == nil {
-		err := sm.setupPostCalicoVesting(ctx)
-		if err != nil {
-			return api.CirculatingSupply{}, xerrors.Errorf("failed to setup post-calico vesting schedule: %w", err)
+			return api.CirculatingSupply{}, xerrors.Errorf("failed to setup post-ignition genesis information: %w", err)
 		}
 	}

@@ -25,7 +25,6 @@ import (

 	exported0 "github.com/filecoin-project/specs-actors/actors/builtin/exported"
 	exported2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/exported"
-	exported3 "github.com/filecoin-project/specs-actors/v3/actors/builtin/exported"

 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/chain/actors/builtin"
@@ -159,7 +158,7 @@ func GetMinerSectorSet(ctx context.Context, sm *StateManager, ts *types.TipSet,
 	return mas.LoadSectors(snos)
 }

-func GetSectorsForWinningPoSt(ctx context.Context, nv network.Version, pv ffiwrapper.Verifier, sm *StateManager, st cid.Cid, maddr address.Address, rand abi.PoStRandomness) ([]builtin.SectorInfo, error) {
+func GetSectorsForWinningPoSt(ctx context.Context, pv ffiwrapper.Verifier, sm *StateManager, st cid.Cid, maddr address.Address, rand abi.PoStRandomness) ([]builtin.SectorInfo, error) {
 	act, err := sm.LoadActorRaw(ctx, maddr, st)
 	if err != nil {
 		return nil, xerrors.Errorf("failed to load miner actor: %w", err)
@@ -170,27 +169,21 @@ func GetSectorsForWinningPoSt(ctx context.Context, nv network.Version, pv ffiwra
 		return nil, xerrors.Errorf("failed to load miner actor state: %w", err)
 	}

-	var provingSectors bitfield.BitField
-	if nv < network.Version7 {
-		allSectors, err := miner.AllPartSectors(mas, miner.Partition.AllSectors)
-		if err != nil {
-			return nil, xerrors.Errorf("get all sectors: %w", err)
-		}
+	// TODO (!!): Actor Update: Make this active sectors

-		faultySectors, err := miner.AllPartSectors(mas, miner.Partition.FaultySectors)
-		if err != nil {
-			return nil, xerrors.Errorf("get faulty sectors: %w", err)
-		}
+	allSectors, err := miner.AllPartSectors(mas, miner.Partition.AllSectors)
+	if err != nil {
+		return nil, xerrors.Errorf("get all sectors: %w", err)
+	}

-		provingSectors, err = bitfield.SubtractBitField(allSectors, faultySectors)
-		if err != nil {
-			return nil, xerrors.Errorf("calc proving sectors: %w", err)
-		}
-	} else {
-		provingSectors, err = miner.AllPartSectors(mas, miner.Partition.ActiveSectors)
-		if err != nil {
-			return nil, xerrors.Errorf("get active sectors sectors: %w", err)
-		}
+	faultySectors, err := miner.AllPartSectors(mas, miner.Partition.FaultySectors)
+	if err != nil {
+		return nil, xerrors.Errorf("get faulty sectors: %w", err)
+	}
+
+	provingSectors, err := bitfield.SubtractBitField(allSectors, faultySectors) // TODO: This is wrong, as it can contain faaults, change to just ActiveSectors in an upgrade
+	if err != nil {
+		return nil, xerrors.Errorf("calc proving sectors: %w", err)
 	}

 	numProvSect, err := provingSectors.Count()
@@ -208,17 +201,22 @@ func GetSectorsForWinningPoSt(ctx context.Context, nv network.Version, pv ffiwra
 		return nil, xerrors.Errorf("getting miner info: %w", err)
 	}

+	spt, err := ffiwrapper.SealProofTypeFromSectorSize(info.SectorSize)
+	if err != nil {
+		return nil, xerrors.Errorf("getting seal proof type: %w", err)
+	}
+
+	wpt, err := spt.RegisteredWinningPoStProof()
+	if err != nil {
+		return nil, xerrors.Errorf("getting window proof type: %w", err)
+	}
+
 	mid, err := address.IDFromAddress(maddr)
 	if err != nil {
 		return nil, xerrors.Errorf("getting miner ID: %w", err)
 	}

-	proofType, err := miner.WinningPoStProofTypeFromWindowPoStProofType(nv, info.WindowPoStProofType)
-	if err != nil {
-		return nil, xerrors.Errorf("determining winning post proof type: %w", err)
-	}
-
-	ids, err := pv.GenerateWinningPoStSectorChallenge(ctx, proofType, abi.ActorID(mid), rand, numProvSect)
+	ids, err := pv.GenerateWinningPoStSectorChallenge(ctx, wpt, abi.ActorID(mid), rand, numProvSect)
 	if err != nil {
 		return nil, xerrors.Errorf("generating winning post challenges: %w", err)
 	}
@@ -248,7 +246,7 @@ func GetSectorsForWinningPoSt(ctx context.Context, nv network.Version, pv ffiwra
 	out := make([]builtin.SectorInfo, len(sectors))
 	for i, sinfo := range sectors {
 		out[i] = builtin.SectorInfo{
-			SealProof:    sinfo.SealProof,
+			SealProof:    spt,
 			SectorNumber: sinfo.SectorNumber,
 			SealedCID:    sinfo.SealedCID,
 		}
@@ -301,11 +299,7 @@ func GetStorageDeal(ctx context.Context, sm *StateManager, dealID abi.DealID, ts
 	if err != nil {
 		return nil, err
 	} else if !found {
-		return nil, xerrors.Errorf(
-			"deal %d not found "+
-				"- deal may not have completed sealing before deal proposal "+
-				"start epoch, or deal may have been slashed",
-			dealID)
+		return nil, xerrors.Errorf("deal %d not found", dealID)
 	}

 	states, err := state.States()
@@ -503,9 +497,7 @@ func MinerGetBaseInfo(ctx context.Context, sm *StateManager, bcs beacon.Schedule
 		return nil, xerrors.Errorf("failed to get randomness for winning post: %w", err)
 	}

-	nv := sm.GetNtwkVersion(ctx, ts.Height())
-
-	sectors, err := GetSectorsForWinningPoSt(ctx, nv, pv, sm, lbst, maddr, prand)
+	sectors, err := GetSectorsForWinningPoSt(ctx, pv, sm, lbst, maddr, prand)
 	if err != nil {
 		return nil, xerrors.Errorf("getting winning post proving set: %w", err)
 	}
@@ -561,7 +553,6 @@ func init() {
 	var actors []rt.VMActor
 	actors = append(actors, exported0.BuiltinActors()...)
 	actors = append(actors, exported2.BuiltinActors()...)
-	actors = append(actors, exported3.BuiltinActors()...)

 	for _, actor := range actors {
 		exports := actor.Exports()
@@ -32,7 +32,6 @@ func TestIndexSeeks(t *testing.T) {

 	nbs := blockstore.NewTemporarySync()
 	cs := store.NewChainStore(nbs, nbs, syncds.MutexWrap(datastore.NewMapDatastore()), nil, nil)
-	defer cs.Close() //nolint:errcheck

 	_, err = cs.Import(bytes.NewReader(gencar))
 	if err != nil {
@@ -134,30 +134,24 @@ type ChainStore struct {

 	evtTypes [1]journal.EventType
 	journal  journal.Journal
-
-	cancelFn context.CancelFunc
-	wg       sync.WaitGroup
 }

 // localbs is guaranteed to fail Get* if requested block isn't stored locally
 func NewChainStore(bs bstore.Blockstore, localbs bstore.Blockstore, ds dstore.Batching, vmcalls vm.SyscallBuilder, j journal.Journal) *ChainStore {
-	mmCache, _ := lru.NewARC(DefaultMsgMetaCacheSize)
-	tsCache, _ := lru.NewARC(DefaultTipSetCacheSize)
+	c, _ := lru.NewARC(DefaultMsgMetaCacheSize)
+	tsc, _ := lru.NewARC(DefaultTipSetCacheSize)
 	if j == nil {
 		j = journal.NilJournal()
 	}
-
-	ctx, cancel := context.WithCancel(context.Background())
 	cs := &ChainStore{
 		bs:       bs,
 		localbs:  localbs,
 		ds:       ds,
 		bestTips: pubsub.New(64),
 		tipsets:  make(map[abi.ChainEpoch][]cid.Cid),
-		mmCache:  mmCache,
-		tsCache:  tsCache,
+		mmCache:  c,
+		tsCache:  tsc,
 		vmcalls:  vmcalls,
-		cancelFn: cancel,
 		journal:  j,
 	}

@@ -197,24 +191,19 @@ func NewChainStore(bs bstore.Blockstore, localbs bstore.Blockstore, ds dstore.Ba
 	}

 	hcmetric := func(rev, app []*types.TipSet) error {
+		ctx := context.Background()
 		for _, r := range app {
-			stats.Record(context.Background(), metrics.ChainNodeHeight.M(int64(r.Height())))
+			stats.Record(ctx, metrics.ChainNodeHeight.M(int64(r.Height())))
 		}
 		return nil
 	}

 	cs.reorgNotifeeCh = make(chan ReorgNotifee)
-	cs.reorgCh = cs.reorgWorker(ctx, []ReorgNotifee{hcnf, hcmetric})
+	cs.reorgCh = cs.reorgWorker(context.TODO(), []ReorgNotifee{hcnf, hcmetric})

 	return cs
 }

-func (cs *ChainStore) Close() error {
-	cs.cancelFn()
-	cs.wg.Wait()
-	return nil
-}
-
 func (cs *ChainStore) Load() error {
 	head, err := cs.ds.Get(chainHeadKey)
 	if err == dstore.ErrNotFound {
@@ -363,7 +352,7 @@ func (cs *ChainStore) PutTipSet(ctx context.Context, ts *types.TipSet) error {

 // MaybeTakeHeavierTipSet evaluates the incoming tipset and locks it in our
 // internal state as our new head, if and only if it is heavier than the current
-// head and does not exceed the maximum fork length.
+// head.
 func (cs *ChainStore) MaybeTakeHeavierTipSet(ctx context.Context, ts *types.TipSet) error {
 	cs.heaviestLk.Lock()
 	defer cs.heaviestLk.Unlock()
@@ -380,15 +369,6 @@ func (cs *ChainStore) MaybeTakeHeavierTipSet(ctx context.Context, ts *types.TipS
 		// TODO: don't do this for initial sync. Now that we don't have a
 		// difference between 'bootstrap sync' and 'caught up' sync, we need
 		// some other heuristic.
-
-		exceeds, err := cs.exceedsForkLength(cs.heaviest, ts)
-		if err != nil {
-			return err
-		}
-		if exceeds {
-			return nil
-		}
-
 		return cs.takeHeaviestTipSet(ctx, ts)
 	} else if w.Equals(heaviestW) && !ts.Equals(cs.heaviest) {
 		log.Errorw("weight draw", "currTs", cs.heaviest, "ts", ts)
@@ -396,67 +376,6 @@ func (cs *ChainStore) MaybeTakeHeavierTipSet(ctx context.Context, ts *types.TipS
 	return nil
 }

-// Check if the two tipsets have a fork length above `ForkLengthThreshold`.
-// `synced` is the head of the chain we are currently synced to and `external`
-// is the incoming tipset potentially belonging to a forked chain. It assumes
-// the external chain has already been validated and available in the ChainStore.
-// The "fast forward" case is covered in this logic as a valid fork of length 0.
-//
-// FIXME: We may want to replace some of the logic in `syncFork()` with this.
-//  `syncFork()` counts the length on both sides of the fork at the moment (we
-//  need to settle on that) but here we just enforce it on the `synced` side.
-func (cs *ChainStore) exceedsForkLength(synced, external *types.TipSet) (bool, error) {
-	if synced == nil || external == nil {
-		// FIXME: If `cs.heaviest` is nil we should just bypass the entire
-		//  `MaybeTakeHeavierTipSet` logic (instead of each of the called
-		//  functions having to handle the nil case on their own).
-		return false, nil
-	}
-
-	var err error
-	// `forkLength`: number of tipsets we need to walk back from the our `synced`
-	// chain to the common ancestor with the new `external` head in order to
-	// adopt the fork.
-	for forkLength := 0; forkLength < int(build.ForkLengthThreshold); forkLength++ {
-		// First walk back as many tipsets in the external chain to match the
-		// `synced` height to compare them. If we go past the `synced` height
-		// the subsequent match will fail but it will still be useful to get
-		// closer to the `synced` head parent's height in the next loop.
-		for external.Height() > synced.Height() {
-			if external.Height() == 0 {
-				// We reached the genesis of the external chain without a match;
-				// this is considered a fork outside the allowed limit (of "infinite"
-				// length).
-				return true, nil
-			}
-			external, err = cs.LoadTipSet(external.Parents())
-			if err != nil {
-				return false, xerrors.Errorf("failed to load parent tipset in external chain: %w", err)
-			}
-		}
-
-		// Now check if we arrived at the common ancestor.
-		if synced.Equals(external) {
-			return false, nil
-		}
-
-		// If we didn't, go back *one* tipset on the `synced` side (incrementing
-		// the `forkLength`).
-		if synced.Height() == 0 {
-			// Same check as the `external` side, if we reach the start (genesis)
-			// there is no common ancestor.
-			return true, nil
-		}
-		synced, err = cs.LoadTipSet(synced.Parents())
-		if err != nil {
-			return false, xerrors.Errorf("failed to load parent tipset in synced chain: %w", err)
-		}
-	}
-
-	// We traversed the fork length allowed without finding a common ancestor.
-	return true, nil
-}
-
 // ForceHeadSilent forces a chain head tipset without triggering a reorg
 // operation.
 //
@@ -464,7 +383,7 @@ func (cs *ChainStore) exceedsForkLength(synced, external *types.TipSet) (bool, e
 // particular tipset to carry out a benchmark, verification, etc. on a chain
 // segment.
 func (cs *ChainStore) ForceHeadSilent(_ context.Context, ts *types.TipSet) error {
-	log.Warnf("(!!!) forcing a new head silently; new head: %s", ts)
+	log.Warnf("(!!!) forcing a new head silently; only use this only for testing; new head: %s", ts)

 	cs.heaviestLk.Lock()
 	defer cs.heaviestLk.Unlock()
@@ -487,9 +406,7 @@ func (cs *ChainStore) reorgWorker(ctx context.Context, initialNotifees []ReorgNo
 	notifees := make([]ReorgNotifee, len(initialNotifees))
 	copy(notifees, initialNotifees)

-	cs.wg.Add(1)
 	go func() {
-		defer cs.wg.Done()
 		defer log.Warn("reorgWorker quit")

 		for {
@@ -594,13 +511,9 @@ func (cs *ChainStore) takeHeaviestTipSet(ctx context.Context, ts *types.TipSet)
 // FlushValidationCache removes all results of block validation from the
 // chain metadata store. Usually the first step after a new chain import.
 func (cs *ChainStore) FlushValidationCache() error {
-	return FlushValidationCache(cs.ds)
-}
-
-func FlushValidationCache(ds datastore.Batching) error {
 	log.Infof("clearing block validation cache...")

-	dsWalk, err := ds.Query(query.Query{
+	dsWalk, err := cs.ds.Query(query.Query{
 		// Potential TODO: the validation cache is not a namespace on its own
 		// but is rather constructed as prefixed-key `foo:bar` via .Instance(), which
 		// in turn does not work with the filter, which can match only on `foo/bar`
@@ -620,7 +533,7 @@ func FlushValidationCache(ds datastore.Batching) error {
 		return xerrors.Errorf("failed to run key listing query: %w", err)
 	}

-	batch, err := ds.Batch()
+	batch, err := cs.ds.Batch()
 	if err != nil {
 		return xerrors.Errorf("failed to open a DS batch: %w", err)
 	}
@@ -800,32 +713,12 @@ func (cs *ChainStore) AddToTipSetTracker(b *types.BlockHeader) error {
 			log.Debug("tried to add block to tipset tracker that was already there")
 			return nil
 		}
-		h, err := cs.GetBlock(oc)
-		if err == nil && h != nil {
-			if h.Miner == b.Miner {
-				log.Warnf("Have multiple blocks from miner %s at height %d in our tipset cache %s-%s", b.Miner, b.Height, b.Cid(), h.Cid())
-			}
-		}
-	}
-	// This function is called 5 times per epoch on average
-	// It is also called with tipsets that are done with initial validation
-	// so they cannot be from the future.
-	// We are guaranteed not to use tipsets older than 900 epochs (fork limit)
-	// This means that we ideally want to keep only most recent 900 epochs in here
-	// Golang's map iteration starts at a random point in a map.
-	// With 5 tries per epoch, and 900 entries to keep, on average we will have
-	// ~136 garbage entires in the `cs.tipsets` map. (solve for 1-(1-x/(900+x))^5 == 0.5)
-	// Seems good enough to me
-
-	for height := range cs.tipsets {
-		if height < b.Height-build.Finality {
-			delete(cs.tipsets, height)
-		}
-		break
 	}

 	cs.tipsets[b.Height] = append(tss, b.Cid())

+	// TODO: do we want to look for slashable submissions here? might as well...
+
 	return nil
 }

@@ -891,7 +784,7 @@ func (cs *ChainStore) expandTipset(b *types.BlockHeader) (*types.TipSet, error)
 		return types.NewTipSet(all)
 	}

-	inclMiners := map[address.Address]cid.Cid{b.Miner: b.Cid()}
+	inclMiners := map[address.Address]bool{b.Miner: true}
 	for _, bhc := range tsets {
 		if bhc == b.Cid() {
 			continue
@@ -902,14 +795,14 @@ func (cs *ChainStore) expandTipset(b *types.BlockHeader) (*types.TipSet, error)
 			return nil, xerrors.Errorf("failed to load block (%s) for tipset expansion: %w", bhc, err)
 		}

-		if cid, found := inclMiners[h.Miner]; found {
-			log.Warnf("Have multiple blocks from miner %s at height %d in our tipset cache %s-%s", h.Miner, h.Height, h.Cid(), cid)
+		if inclMiners[h.Miner] {
+			log.Warnf("Have multiple blocks from miner %s at height %d in our tipset cache", h.Miner, h.Height)
 			continue
 		}

 		if types.CidArrsEqual(h.Parents, b.Parents) {
 			all = append(all, h)
-			inclMiners[h.Miner] = bhc
+			inclMiners[h.Miner] = true
 		}
 	}

@@ -71,7 +71,6 @@ func BenchmarkGetRandomness(b *testing.B) {
 	}

 	cs := store.NewChainStore(bs, bs, mds, nil, nil)
-	defer cs.Close() //nolint:errcheck

 	b.ResetTimer()

@@ -106,7 +105,6 @@ func TestChainExportImport(t *testing.T) {

 	nbs := blockstore.NewTemporary()
 	cs := store.NewChainStore(nbs, nbs, datastore.NewMapDatastore(), nil, nil)
-	defer cs.Close() //nolint:errcheck

 	root, err := cs.Import(buf)
 	if err != nil {
@@ -141,8 +139,6 @@ func TestChainExportImportFull(t *testing.T) {

 	nbs := blockstore.NewTemporary()
 	cs := store.NewChainStore(nbs, nbs, datastore.NewMapDatastore(), nil, nil)
-	defer cs.Close() //nolint:errcheck
-
 	root, err := cs.Import(buf)
 	if err != nil {
 		t.Fatal(err)
@@ -6,18 +6,9 @@ import (
 	"fmt"
 	"time"

+	"golang.org/x/xerrors"
+
 	address "github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/lotus/build"
-	"github.com/filecoin-project/lotus/chain"
-	"github.com/filecoin-project/lotus/chain/messagepool"
-	"github.com/filecoin-project/lotus/chain/stmgr"
-	"github.com/filecoin-project/lotus/chain/store"
-	"github.com/filecoin-project/lotus/chain/types"
-	"github.com/filecoin-project/lotus/lib/blockstore"
-	"github.com/filecoin-project/lotus/lib/sigs"
-	"github.com/filecoin-project/lotus/metrics"
-	"github.com/filecoin-project/lotus/node/impl/client"
-	blockadt "github.com/filecoin-project/specs-actors/actors/util/adt"
 	lru "github.com/hashicorp/golang-lru"
 	blocks "github.com/ipfs/go-block-format"
 	bserv "github.com/ipfs/go-blockservice"
@@ -30,7 +21,19 @@ import (
 	cbg "github.com/whyrusleeping/cbor-gen"
 	"go.opencensus.io/stats"
 	"go.opencensus.io/tag"
-	"golang.org/x/xerrors"
+
+	blockadt "github.com/filecoin-project/specs-actors/actors/util/adt"
+
+	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain"
+	"github.com/filecoin-project/lotus/chain/messagepool"
+	"github.com/filecoin-project/lotus/chain/stmgr"
+	"github.com/filecoin-project/lotus/chain/store"
+	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/lib/blockstore"
+	"github.com/filecoin-project/lotus/lib/sigs"
+	"github.com/filecoin-project/lotus/metrics"
+	"github.com/filecoin-project/lotus/node/impl/client"
 )

 var log = logging.Logger("sub")
@@ -97,10 +100,6 @@ func HandleIncomingBlocks(ctx context.Context, bsub *pubsub.Subscription, s *cha
 				log.Warnw("Slow msg fetch", "cid", blk.Header.Cid(), "source", msg.GetFrom(), "msgfetch", took)
 			}
 			if delay := build.Clock.Now().Unix() - int64(blk.Header.Timestamp); delay > 5 {
-				_ = stats.RecordWithTags(ctx,
-					[]tag.Mutator{tag.Insert(metrics.MinerID, blk.Header.Miner.String())},
-					metrics.BlockDelay.M(delay),
-				)
 				log.Warnf("Received block with large delay %d from miner %s", delay, blk.Header.Miner)
 			}

@@ -341,16 +340,11 @@ func (bv *BlockValidator) Validate(ctx context.Context, pid peer.ID, msg *pubsub
 func (bv *BlockValidator) validateLocalBlock(ctx context.Context, msg *pubsub.Message) pubsub.ValidationResult {
 	stats.Record(ctx, metrics.BlockPublished.M(1))

-	if size := msg.Size(); size > 1<<20-1<<15 {
-		log.Errorf("ignoring oversize block (%dB)", size)
-		recordFailure(ctx, metrics.BlockValidationFailure, "oversize_block")
-		return pubsub.ValidationIgnore
-	}
-
 	blk, what, err := bv.decodeAndCheckBlock(msg)
 	if err != nil {
 		log.Errorf("got invalid local block: %s", err)
-		recordFailure(ctx, metrics.BlockValidationFailure, what)
+		ctx, _ = tag.New(ctx, tag.Insert(metrics.FailureType, what))
+		stats.Record(ctx, metrics.BlockValidationFailure.M(1))
 		return pubsub.ValidationIgnore
 	}

--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Aayush Rajasekaran	d6c424add6	Merge branch 'master' into ntwk-calibration	2020-11-13 19:01:44 -05:00
Travis Person	4c33155a06	New calibration genesis	2020-11-07 21:34:59 -05:00
Travis Person	9a254086b2	New calibration network info	2020-11-07 21:34:59 -05:00