Merge pull request #3855 from filecoin-project/feat/well-targetted-nerpa-v0.7.x

Feat/well targetted nerpa v0.7.x
Nerpa v0.7.x
2020-09-15 13:18:15 -07:00 · 2020-09-15 13:59:44 +02:00 · 2020-09-15 13:59:30 +02:00 · 2020-09-15 13:59:03 +02:00 · 2020-08-28 13:00:22 -07:00 · 2020-08-28 22:32:28 +03:00
678 changed files with 15710 additions and 79565 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:
@@ -35,7 +34,7 @@ commands:
          condition: << parameters.linux >>
          steps:
            - run: sudo apt-get update
-            - run: sudo apt-get install ocl-icd-opencl-dev libhwloc-dev
+            - run: sudo apt-get install ocl-icd-opencl-dev
      - run: git submodule sync
      - run: git submodule update --init
  download-params:
@@ -189,22 +188,10 @@ jobs:
                command: |
                  bash <(curl -s https://codecov.io/bash)

-  test-chain:
-    <<: *test
-  test-node:
-    <<: *test
-  test-storage:
-    <<: *test
-  test-cli:
-    <<: *test
  test-short:
    <<: *test
  test-window-post:
    <<: *test
-  test-window-post-dispute:
-    <<: *test
-  test-terminate:
-    <<: *test
  test-conformance:
    description: |
      Run tests using a corpus of interoperable test vectors for Filecoin 
@@ -267,57 +254,6 @@ 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
-    parameters:
-      <<: *test-params
-    executor: << parameters.executor >>
-    steps:
-      - install-deps
-      - prepare
-      - run: cd extern/filecoin-ffi && make
-      - 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
-

  build-macos:
    description: build darwin lotus binary
@@ -331,8 +267,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
@@ -396,7 +332,6 @@ jobs:
    steps:
      - install-deps
      - prepare
-      - run: make deps
      - run: make docsgen
      - run: git --no-pager diff
      - run: git --no-pager diff --quiet
@@ -460,121 +395,12 @@ 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
  ci:
    jobs:
-      - lint-all:
-          concurrency: "16"   # expend all docker 2xlarge CPUs.
+      - lint-all
      - mod-tidy-check
      - gofmt
      - cbor-gen-check
@@ -582,37 +408,10 @@ workflows:
      - test:
          codecov-upload: true
          test-suite-name: full
-      - test-chain:
-          codecov-upload: true
-          test-suite-name: chain
-          packages: "./chain/..."
-      - test-node:
-          codecov-upload: true
-          test-suite-name: node
-          packages: "./node/..."
-      - test-storage:
-          codecov-upload: true
-          test-suite-name: storage
-          packages: "./storage/... ./extern/..."
-      - test-cli:
-          codecov-upload: true
-          test-suite-name: cli
-          packages: "./cli/... ./cmd/... ./api/..."
      - test-window-post:
-          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 +427,6 @@ 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 +456,3 @@ workflows:
            tags:
              only:
                - /^v\d+\.\d+\.\d+$/
-      - build-and-push-image:
-          dockerfile: Dockerfile.lotus
-          path: .
-          repo: lotus-dev
-          tag: '${CIRCLE_SHA1:0:8}'
@@ -1,19 +1,5 @@
 comment: off
 ignore:
-  - "**/cbor_gen.go"
-  - "api/test/**/*"
-  - "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/*"
+  - "cbor_gen.go"
 github_checks:
  annotations: false
@@ -13,4 +13,3 @@
 ### Conformance testing.
 conformance/            @raulk
 extern/test-vectors     @raulk
-cmd/tvx                 @raulk
@@ -10,10 +10,6 @@
 /lotus-fountain
 /lotus-stats
 /lotus-bench
-/lotus-gateway
-/lotus-pcr
-/lotus-wallet
-/lotus-keygen
 /bench.json
 /lotuspond/front/node_modules
 /lotuspond/front/build
@@ -1,9 +1,10 @@
 [submodule "extern/filecoin-ffi"]
 	path = extern/filecoin-ffi
 	url = https://github.com/filecoin-project/filecoin-ffi.git
+	branch = master
 [submodule "extern/serialization-vectors"]
 	path = extern/serialization-vectors
-	url = https://github.com/filecoin-project/serialization-vectors.git
+	url = https://github.com/filecoin-project/serialization-vectors
 [submodule "extern/test-vectors"]
 	path = extern/test-vectors
 	url = https://github.com/filecoin-project/test-vectors.git
@@ -1,829 +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.
-
-## Highlights
-
- Refactored much of the miner code (https://github.com/filecoin-project/lotus/pull/3618), improving its recovery from restarts and overall sector success rate
- Updated [proofs](https://github.com/filecoin-project/rust-fil-proofs) to v5.3.0, which brings significant performance improvements
- Updated [markets](https://github.com/filecoin-project/go-fil-markets/releases/tag/v1.0.4) to v1.0.4, which reduces failures due to reorgs (https://github.com/filecoin-project/lotus/pull/4730) and uses the newly refactored fund manager (https://github.com/filecoin-project/lotus/pull/4736)
-
-## Changes
-
-#### Core Lotus
-
- polish: add Equals method to MinerInfo shim (https://github.com/filecoin-project/lotus/pull/4604)
- Fix messagepool accounting (https://github.com/filecoin-project/lotus/pull/4668)
- Prep for gas balancing (https://github.com/filecoin-project/lotus/pull/4651)
- Reduce badger ValueThreshold to 128 (https://github.com/filecoin-project/lotus/pull/4629)
- Config for default max gas fee (https://github.com/filecoin-project/lotus/pull/4652)
- bootstrap: don't return early when one drand resolution fails (https://github.com/filecoin-project/lotus/pull/4626)
- polish: add ClaimsChanged and DiffClaims method to power shim (https://github.com/filecoin-project/lotus/pull/4628)
- Simplify chain event Called API (https://github.com/filecoin-project/lotus/pull/4664)
- Cache deal states for most recent old/new tipset (https://github.com/filecoin-project/lotus/pull/4623)
- Add miner available balance and power info to state miner info (https://github.com/filecoin-project/lotus/pull/4618)
- Call GetHeaviestTipSet() only once when syncing (https://github.com/filecoin-project/lotus/pull/4696)
- modify runtime gasUsed printf (https://github.com/filecoin-project/lotus/pull/4704)
- Rename builtin actor generators (https://github.com/filecoin-project/lotus/pull/4697)
- Move gas multiplier as property of pricelist (https://github.com/filecoin-project/lotus/pull/4728)
- polish: add msig pendingtxn diffing and comp (https://github.com/filecoin-project/lotus/pull/4719)
- Optional chain Bitswap (https://github.com/filecoin-project/lotus/pull/4717)
- rewrite sync manager (https://github.com/filecoin-project/lotus/pull/4599)
- async connect to bootstrappers (https://github.com/filecoin-project/lotus/pull/4785)
- head change coalescer (https://github.com/filecoin-project/lotus/pull/4688)
- move to native badger blockstore; leverage zero-copy View() to deserialize in-place (https://github.com/filecoin-project/lotus/pull/4681)
- badger blockstore: minor improvements (https://github.com/filecoin-project/lotus/pull/4811)
- Do not fail wallet delete because of pre-existing trashed key (https://github.com/filecoin-project/lotus/pull/4589)
- Correctly delete the default wallet address (https://github.com/filecoin-project/lotus/pull/4705)
- Reduce badger ValueTreshold to 128 (https://github.com/filecoin-project/lotus/pull/4629)
- predicates: Fast StateGetActor wrapper (https://github.com/filecoin-project/lotus/pull/4835)
-
-#### Mining
-
- worker key should change when set sender found key not equal with the value on chain (https://github.com/filecoin-project/lotus/pull/4595)
- extern/sector-storage: fix GPU usage overwrite bug (https://github.com/filecoin-project/lotus/pull/4627)
- sectorstorage: Fix manager restart edge-case (https://github.com/filecoin-project/lotus/pull/4645)
- storagefsm: Fix GetTicket loop when the sector is already precommitted (https://github.com/filecoin-project/lotus/pull/4643)
- Debug flag to force running sealing scheduler (https://github.com/filecoin-project/lotus/pull/4662)
- Fix worker reenabling, handle multiple restarts in worker (https://github.com/filecoin-project/lotus/pull/4666)
- keep retrying the proof until we run out of sectors to skip (https://github.com/filecoin-project/lotus/pull/4633)
- worker: Commands to pause/resume task processing (https://github.com/filecoin-project/lotus/pull/4615)
- struct name incorrect (https://github.com/filecoin-project/lotus/pull/4699)
- optimize code replace strings with constants (https://github.com/filecoin-project/lotus/pull/4769)
- optimize pledge sector (https://github.com/filecoin-project/lotus/pull/4765)
- Track sealing processes across lotus-miner restarts (https://github.com/filecoin-project/lotus/pull/3618)
- Fix scheduler lockups after storage is freed (https://github.com/filecoin-project/lotus/pull/4778)
- storage: Track worker hostnames with work (https://github.com/filecoin-project/lotus/pull/4779)
- Expand sched-diag; Command to abort sealing calls (https://github.com/filecoin-project/lotus/pull/4804)
- miner: Winning PoSt Warmup (https://github.com/filecoin-project/lotus/pull/4824)
- docsgen: Support miner/worker (https://github.com/filecoin-project/lotus/pull/4817)
- miner: Basic storage cleanup command (https://github.com/filecoin-project/lotus/pull/4834)
-
-#### Markets and Data Transfer
-
- Flesh out data transfer features (https://github.com/filecoin-project/lotus/pull/4572)
- Fix memory leaks in data transfer (https://github.com/filecoin-project/lotus/pull/4619)
- Handle deal id changes in OnDealSectorCommitted (https://github.com/filecoin-project/lotus/pull/4730)
- Refactor FundManager (https://github.com/filecoin-project/lotus/pull/4736)
- refactor: integrate new FundManager (https://github.com/filecoin-project/lotus/pull/4787)
- Fix race in paych manager when req context is cancelled (https://github.com/filecoin-project/lotus/pull/4803)
- fix race in paych manager add funds (https://github.com/filecoin-project/lotus/pull/4597)
- Fix panic in FundManager (https://github.com/filecoin-project/lotus/pull/4808)
- Fix: dont crash on startup if funds migration fails (https://github.com/filecoin-project/lotus/pull/4827)
-
-#### UX
-
- Make EarlyExpiration in sectors list less scary (https://github.com/filecoin-project/lotus/pull/4600)
- Add commands to change the worker key (https://github.com/filecoin-project/lotus/pull/4513)
- Expose ClientDealSize via CLI (https://github.com/filecoin-project/lotus/pull/4569)
- client deal: Cache CommD when creating multiple deals (https://github.com/filecoin-project/lotus/pull/4535)
- miner sectors list: flags for events/seal time (https://github.com/filecoin-project/lotus/pull/4649)
- make IPFS online mode configurable (https://github.com/filecoin-project/lotus/pull/4650)
- Add sync status to miner info command (https://github.com/filecoin-project/lotus/pull/4669)
- Add a StateDecodeParams method (https://github.com/filecoin-project/lotus/pull/4105)
- sched: Interactive RPC Shell (https://github.com/filecoin-project/lotus/pull/4692)
- Add api for getting status given a code (https://github.com/filecoin-project/lotus/pull/4210)
- Update lotus-stats with a richer cli (https://github.com/filecoin-project/lotus/pull/4718)
- Use TSK passed to GasEstimateGasLimit (https://github.com/filecoin-project/lotus/pull/4739)
- match data type for reward state api (https://github.com/filecoin-project/lotus/pull/4745)
- Add `termination-estimate` to get an estimation for how much a termination penalty will be (https://github.com/filecoin-project/lotus/pull/4617)
- Restrict `ParseFIL` input length (https://github.com/filecoin-project/lotus/pull/4780)
- cmd sectors commitIDs len debug (https://github.com/filecoin-project/lotus/pull/4786)
- Add client deal-stats CLI (https://github.com/filecoin-project/lotus/pull/4788)
- Modify printf format (https://github.com/filecoin-project/lotus/pull/4795)
- Updated msig inspect (https://github.com/filecoin-project/lotus/pull/4533)
- Delete the duplicate output (https://github.com/filecoin-project/lotus/pull/4819)
- miner: Storage list sectors command (https://github.com/filecoin-project/lotus/pull/4831)
- drop a few logs down to debug (https://github.com/filecoin-project/lotus/pull/4832)
-
-#### Testing and Tooling
-
- refactor: share code between CLI tests (https://github.com/filecoin-project/lotus/pull/4598)
- Fix flaky TestCLIDealFlow (https://github.com/filecoin-project/lotus/pull/4608)
- Fix flaky testMiningReal (https://github.com/filecoin-project/lotus/pull/4609)
- Add election run-dummy command (https://github.com/filecoin-project/lotus/pull/4498)
- Fix .gitmodules (https://github.com/filecoin-project/lotus/pull/4713)
- fix metrics wiring.(https://github.com/filecoin-project/lotus/pull/4691)
- shed: Util for creating ID CIDs (https://github.com/filecoin-project/lotus/pull/4726)
- Run kumquat upgrade on devnets (https://github.com/filecoin-project/lotus/pull/4734)
- Make pond work again (https://github.com/filecoin-project/lotus/pull/4775)
- lotus-stats: fix influx flags (https://github.com/filecoin-project/lotus/pull/4810)
- 2k sync BootstrapPeerThreshold (https://github.com/filecoin-project/lotus/pull/4797)
- test for FundManager panic to ensure it is fixed (https://github.com/filecoin-project/lotus/pull/4825)
- Stop mining at the end of tests (https://github.com/filecoin-project/lotus/pull/4826)
- Make some logs quieter (https://github.com/filecoin-project/lotus/pull/4709)
-
-#### Dependencies
-
- update filecoin-ffi in go mod (https://github.com/filecoin-project/lotus/pull/4584)
- Update FFI (https://github.com/filecoin-project/lotus/pull/4613)
- feat: integrate new optional blst backend and verification optimizations from proofs (https://github.com/filecoin-project/lotus/pull/4630)
- Use https for blst submodule (https://github.com/filecoin-project/lotus/pull/4710)
- Update go-bitfield (https://github.com/filecoin-project/lotus/pull/4756)
- Update Yamux (https://github.com/filecoin-project/lotus/pull/4758)
- Update to latest go-bitfield (https://github.com/filecoin-project/lotus/pull/4793)
- Update to latest go-address (https://github.com/filecoin-project/lotus/pull/4798)
- update libp2p for stream interface changes (https://github.com/filecoin-project/lotus/pull/4814)
-
-# 1.1.2 / 2020-10-24
-
-This is a patch release of Lotus that builds on the fixes involving worker keys that was introduced in v1.1.1. Miners and node operators should update to this release as soon as possible in order to ensure their blocks are propagated and validated.
-
-## Changes 
-
- Handle worker key changes correctly in runtime (https://github.com/filecoin-project/lotus/pull/4579)
-
-# 1.1.1 / 2020-10-24
-
-This is a patch release of Lotus that addresses some issues caused by when miners change their worker keys. Miners and node operators should update to this release as soon as possible, especially any miner who has changed their worker key recently.
-
-## Changes
-
- Miner finder for interactive client deal CLI (https://github.com/filecoin-project/lotus/pull/4504)
- Disable blockstore bloom filter (https://github.com/filecoin-project/lotus/pull/4512)
- Add api for getting status given a code (https://github.com/filecoin-project/lotus/pull/4210)
- add batch api for push messages (https://github.com/filecoin-project/lotus/pull/4236)
- add measure datastore wrapper around bench chain datastore (https://github.com/filecoin-project/lotus/pull/4302)
- Look at block base fee for PCR (https://github.com/filecoin-project/lotus/pull/4313)
- Add a shed util to determine % of power that has won a block (https://github.com/filecoin-project/lotus/pull/4318)
- Shed/borked cmd (https://github.com/filecoin-project/lotus/pull/4339)
- optimize mining code (https://github.com/filecoin-project/lotus/pull/4379)
- heaviestTipSet reurning nil is a ok (https://github.com/filecoin-project/lotus/pull/4523)
- Remove most v0 actor imports (https://github.com/filecoin-project/lotus/pull/4383)
- Small chain export optimization (https://github.com/filecoin-project/lotus/pull/4536)
- Add block list to pcr (https://github.com/filecoin-project/lotus/pull/4314)
- Fix circ supply default in conformance (https://github.com/filecoin-project/lotus/pull/4449)
- miner: fix init --create-worker-key (https://github.com/filecoin-project/lotus/pull/4475)
- make push and addLocal atomic (https://github.com/filecoin-project/lotus/pull/4500)
- add some methods that oni needs (https://github.com/filecoin-project/lotus/pull/4501)
- MinerGetBaseInfo: if miner is not found in lookback, check current (https://github.com/filecoin-project/lotus/pull/4508)
- Delete wallet from local wallet cache (https://github.com/filecoin-project/lotus/pull/4526)
- Fix lotus-shed ledger list (https://github.com/filecoin-project/lotus/pull/4521)
- Manage sectors by size instead of proof type (https://github.com/filecoin-project/lotus/pull/4511)
- Feat/api request metrics wrapper (https://github.com/filecoin-project/lotus/pull/4516)
- Fix chain sync stopping to sync (https://github.com/filecoin-project/lotus/pull/4541)
- Use the correct lookback for the worker key when creating blocks (https://github.com/filecoin-project/lotus/pull/4539)
- Cleanup test initialization and always validate VRFs in tests (https://github.com/filecoin-project/lotus/pull/4538)
- Add a market WithdrawBalance CLI (https://github.com/filecoin-project/lotus/pull/4524)
- wallet list: Add market balance and ID address flags (https://github.com/filecoin-project/lotus/pull/4555)
- tvx simulate command; tvx extract --ignore-sanity-checks (https://github.com/filecoin-project/lotus/pull/4554)
- lotus-lite: CLI tests for `lotus client` commands (https://github.com/filecoin-project/lotus/pull/4497)
- lite-mode - market storage and retrieval clients (https://github.com/filecoin-project/lotus/pull/4263)
- Chore: update drand to v1.2.0 (https://github.com/filecoin-project/lotus/pull/4420)
- Fix random test failures (https://github.com/filecoin-project/lotus/pull/4559)
- Fix flaky TestTimedBSSimple (https://github.com/filecoin-project/lotus/pull/4561)
- Make wallet market withdraw usable with miner addresses (https://github.com/filecoin-project/lotus/pull/4556)
- Fix flaky TestChainExportImportFull (https://github.com/filecoin-project/lotus/pull/4564)
- Use older randomness for the PoSt commit on specs-actors version 2 (https://github.com/filecoin-project/lotus/pull/4563)
- shed: Commad to decode messages (https://github.com/filecoin-project/lotus/pull/4565)
- Fetch worker key from correct block on sync (https://github.com/filecoin-project/lotus/pull/4573)
-
-# 1.1.0 / 2020-10-20
-
-This is a mandatory release that introduces the first post-liftoff upgrade to the Filecoin network. The changes that break consensus are an upgrade to specs-actors v2.2.0 at epoch 170000.
-
-## Changes
-
- Introduce Network version 6 (https://github.com/filecoin-project/lotus/pull/4506)
- Update markets v1.0.0 (https://github.com/filecoin-project/lotus/pull/4505)
- Add some extra logging to try and debug sync issues (https://github.com/filecoin-project/lotus/pull/4486)
- Circle: Run tests for some subsystems separately (https://github.com/filecoin-project/lotus/pull/4496)
- Add a terminate sectors command to lotus-shed (https://github.com/filecoin-project/lotus/pull/4507)
- Add a comment to BlockMessages to address #4446 (https://github.com/filecoin-project/lotus/pull/4491)
-
-# 1.0.0 / 2020-10-19
-
-It's 1.0.0! This is an optional release of Lotus that introduces some UX improvements to the 0.10 series.
-
-This very small release is largely cosmetic, and intended to flag the code that the Filecoin mainnet was launched with.
-
-## API changes
-
- `StateMsgGasCost` has been removed. The equivalent information can be gained by calling `StateReplay`.
- A `GasCost` field has been added to the `InvocResult` type, meaning detailed gas costs will be returned when calling `StateReplay`, `StateCompute`, and `StateCall`.
- The behaviour of `StateReplay` in response to an empty tipset key has been changed. Instead of simply using the heaviest tipset (which is almost guaranteed to be an unsuccessful replay), we search now search the chain for the tipset that included the message, and replay the message in that tipset (we fail if no such tipset is found).
-
-## Changes
-
- Increase code coverage! (https://github.com/filecoin-project/lotus/pull/4410)
- Mpool: Don't block node startup loading messages (https://github.com/filecoin-project/lotus/pull/4411)
- Improve the UX of multisig approves (https://github.com/filecoin-project/lotus/pull/4398)
- Use build.BlockDelaySecs for deal start buffer (https://github.com/filecoin-project/lotus/pull/4415)
- Conformance: support multiple protocol versions (https://github.com/filecoin-project/lotus/pull/4393)
- Ensure msig inspect cli works with lotus-lite (https://github.com/filecoin-project/lotus/pull/4421)
- Add command to (slowly) prune lotus chain datastore (https://github.com/filecoin-project/lotus/pull/3876)
- Add WalletVerify to lotus-gateway (https://github.com/filecoin-project/lotus/pull/4373)
- Improve StateMsg APIs (https://github.com/filecoin-project/lotus/pull/4429)
- Add endpoints needed by spacegap (https://github.com/filecoin-project/lotus/pull/4426)
- Make audit balances capable of printing robust addresses (https://github.com/filecoin-project/lotus/pull/4423)
- Custom filters for retrieval deals (https://github.com/filecoin-project/lotus/pull/4424)
- Fix message list api (https://github.com/filecoin-project/lotus/pull/4422)
- Replace bootstrap peers (https://github.com/filecoin-project/lotus/pull/4447)
- Don't overwrite previously-configured maxPieceSize for a persisted ask (https://github.com/filecoin-project/lotus/pull/4480)
- State: optimize state snapshot address cache (https://github.com/filecoin-project/lotus/pull/4481)
-
-# 0.10.2 / 2020-10-14
-
-This is an optional release of Lotus that updates markets to 0.9.1, which fixes an issue affecting deals that were mid-transfer when the node was upgraded to 0.9.0. This release also includes some tweaks to default gas values and minor performance improvements.
-
-## Changes
-
- Use updated stored ask API (https://github.com/filecoin-project/lotus/pull/4384)
- tvx: trace puts to blockstore for inclusion in CAR. (https://github.com/filecoin-project/lotus/pull/4278)
- Add propose remove (https://github.com/filecoin-project/lotus/pull/4311)
- Update to 0.9.1 bugfix release (https://github.com/filecoin-project/lotus/pull/4402)
- Update drand endpoints (https://github.com/filecoin-project/lotus/pull/4125)
- fix: return true when deadlines changed (https://github.com/filecoin-project/lotus/pull/4403)
- sync wait --watch (https://github.com/filecoin-project/lotus/pull/4396)
- reduce garbage in blockstore (https://github.com/filecoin-project/lotus/pull/4406)
- give the TimeCacheBS tests a bit more time (https://github.com/filecoin-project/lotus/pull/4407)
- Improve gas defaults (https://github.com/filecoin-project/lotus/pull/4408)
- Change default gas premium to for 10 block inclusion (https://github.com/filecoin-project/lotus/pull/4222)
-
-# 0.10.1 / 2020-10-14
-
-This is an optional release of Lotus that updates markets to 0.9.0, which adds the ability to restart data transfers. This release also introduces Ledger support, and various UX improvements.
-
-## Changes
-
- Test the tape upgrade (https://github.com/filecoin-project/lotus/pull/4328)
- Adding in Ledger support (https://github.com/filecoin-project/lotus/pull/4290)
- Improve the UX for lotus-miner sealing workers (https://github.com/filecoin-project/lotus/pull/4329)
- Add a CLI tool for miner's to repay debt (https://github.com/filecoin-project/lotus/pull/4319)
- Rename params_testnet to params_mainnet (https://github.com/filecoin-project/lotus/pull/4336)
- Use seal-duration in calculating the earliest StartEpoch (https://github.com/filecoin-project/lotus/pull/4337)
- Reject deals that are > 7 days in the future in the BasicDealFilter (https://github.com/filecoin-project/lotus/pull/4173)
- Add an API endpoint to calculate the exact circulating supply (https://github.com/filecoin-project/lotus/pull/4148)
- lotus-pcr: ignore all other market messages (https://github.com/filecoin-project/lotus/pull/4341)
- Add message CID to InvocResult (https://github.com/filecoin-project/lotus/pull/4382)
- types: Add CID fields to messages in json marshalers (https://github.com/filecoin-project/lotus/pull/4338)
- fix(sync state): set state height to actual tipset height (https://github.com/filecoin-project/lotus/pull/4347)
- Fix off by one tipset in searchBackForMsg (https://github.com/filecoin-project/lotus/pull/4367)
- fix a panic on startup when we fail to load the tipset (https://github.com/filecoin-project/lotus/pull/4376)
- Avoid having the same message CID show up in execution traces (https://github.com/filecoin-project/lotus/pull/4350)
- feat(markets): update markets 0.9.0 and add data transfer restart (https://github.com/filecoin-project/lotus/pull/4363)
-
-# 0.10.0 / 2020-10-12
-
-This is a consensus-breaking hotfix that addresses an issue in specs-actors v2.0.3 that made it impossible to pledge new 32GiB sectors. The change in Lotus is to update to actors v2.1.0, behind the new network version 5.
-
-## Changes
-
- make pledge test pass with the race detector (https://github.com/filecoin-project/lotus/pull/4291)
- fix a race in tipset cache usage (https://github.com/filecoin-project/lotus/pull/4282)
- add an api for removing multisig signers (https://github.com/filecoin-project/lotus/pull/4274)
- cli: Don't output errors to stdout (https://github.com/filecoin-project/lotus/pull/4298)
- Fix panic in wallet export when key is not found (https://github.com/filecoin-project/lotus/pull/4299)
- Dump the block validation cache whenever we perform an import (https://github.com/filecoin-project/lotus/pull/4287)
- Fix two races (https://github.com/filecoin-project/lotus/pull/4301)
- sync unmark-bad --all (https://github.com/filecoin-project/lotus/pull/4296)
- decode parameters for multisig transactions in inspect (https://github.com/filecoin-project/lotus/pull/4312)
- Chain is love (https://github.com/filecoin-project/lotus/pull/4321)
- lotus-stats: optmize getting miner power (https://github.com/filecoin-project/lotus/pull/4315)
- implement tape upgrade (https://github.com/filecoin-project/lotus/pull/4322)
-
-# 0.9.1 / 2020-10-10
-
-This release fixes an issue which may cause the actors v2 migration to compute the state incorrectly when more than one migration is running in parallel.
-
-## Changes
-
- Make concurrent actor migrations safe (https://github.com/filecoin-project/lotus/pull/4293)
- Remote wallet backends (https://github.com/filecoin-project/lotus/pull/3583)
- Track funds in FundMgr correctly in case of AddFunds failing (https://github.com/filecoin-project/lotus/pull/4273)
- Partial lite-node mode (https://github.com/filecoin-project/lotus/pull/4095)
- Fix potential infinite loop in GetBestMiningCandidate (https://github.com/filecoin-project/lotus/pull/3444)
- sync wait: Handle processed message offset (https://github.com/filecoin-project/lotus/pull/4253)
- Add some new endpoints for querying Msig info (https://github.com/filecoin-project/lotus/pull/4250)
- Update markets v0.7.1 (https://github.com/filecoin-project/lotus/pull/4254)
- Optimize SearchForMessage and GetReceipt (https://github.com/filecoin-project/lotus/pull/4246)
- Use FIL instead of attoFIL in CLI more consistently (https://github.com/filecoin-project/lotus/pull/4249)
- fix: clash between daemon --api flag and cli tests (https://github.com/filecoin-project/lotus/pull/4241)
- add more info to chain sync lookback failure (https://github.com/filecoin-project/lotus/pull/4245)
- Add message counts to inspect chain output (https://github.com/filecoin-project/lotus/pull/4230)
-
-# 0.9.0 / 2020-10-07
-
-This consensus-breaking release of Lotus upgrades the actors version to v2.0.0. This requires migrating actor state from v0 to v2. The changes that break consensus are:
-
- Introducing v2 actors and its migration (https://github.com/filecoin-project/lotus/pull/3936)
- Runtime's Receiver() should only return ID addresses  (https://github.com/filecoin-project/lotus/pull/3589)
- Update miner eligibility checks for v2 actors (https://github.com/filecoin-project/lotus/pull/4188)
- Add funds that have left FilReserve to circ supply (https://github.com/filecoin-project/lotus/pull/4160)
- Set WinningPoStSectorSetLookback to finality post-v2 actors (https://github.com/filecoin-project/lotus/pull/4190)
- fix: error when actor panics directly (https://github.com/filecoin-project/lotus/pull/3697)
-
-## Changes
-
-#### Dependencies
-
- Update go-bitfield (https://github.com/filecoin-project/lotus/pull/4171)
- update the AMT implementation (https://github.com/filecoin-project/lotus/pull/4194)
- Update to actors v0.2.1 (https://github.com/filecoin-project/lotus/pull/4199)
-
-#### Core Lotus
-
- Paych: fix voucher amount verification (https://github.com/filecoin-project/lotus/pull/3821)
- Cap market provider messages (https://github.com/filecoin-project/lotus/pull/4141)
- Run fork function after cron for null block safety (https://github.com/filecoin-project/lotus/pull/4114)
- use bitswap sessions when fetching messages, and cancel them (https://github.com/filecoin-project/lotus/pull/4142)
- relax pubsub IPColocationFactorThreshold to 5 (https://github.com/filecoin-project/lotus/pull/4183)
- Support addresses with mainnet prefixes (https://github.com/filecoin-project/lotus/pull/4186)
- fix: make message signer nonce generation transactional (https://github.com/filecoin-project/lotus/pull/4165)
- build: Env var to keep test address output (https://github.com/filecoin-project/lotus/pull/4213)
- make vm.EnableGasTracing public (https://github.com/filecoin-project/lotus/pull/4214)
- introduce separate state-tree versions (https://github.com/filecoin-project/lotus/pull/4197)
- reject explicit "calls" at the upgrade height (https://github.com/filecoin-project/lotus/pull/4231)
- return an illegal actor error when we see an unsupported actor version (https://github.com/filecoin-project/lotus/pull/4232)
- Set head should unmark blocks as valid (https://gist.github.com/travisperson/3c7cddd77a33979a519ccef4e6515f20)
-
-#### Mining
-
- Increased ExpectedSealDuration and and WaitDealsDelay (https://github.com/filecoin-project/lotus/pull/3743)
- Miner backup/restore commands (https://github.com/filecoin-project/lotus/pull/4133)
- lotus-miner: add more help text to storage / attach (https://github.com/filecoin-project/lotus/pull/3961)
- Reject deals that are > 7 days in the future in the BasicDealFilter (https://github.com/filecoin-project/lotus/pull/4173)
- feat(miner): add miner deadline diffing logic (https://github.com/filecoin-project/lotus/pull/4178)
-
-#### UX
-
- Improve the UX for replacing messages (https://github.com/filecoin-project/lotus/pull/4134)
- Add verified flag to interactive deal creation (https://github.com/filecoin-project/lotus/pull/4145)
- Add command to (slowly) prune lotus chain datastore (https://github.com/filecoin-project/lotus/pull/3876)
- Some helpers for verifreg work (https://github.com/filecoin-project/lotus/pull/4124)
- Always use default 720h for setask duration and hide the duration param option (https://github.com/filecoin-project/lotus/pull/4077)
- Convert ID addresses to key addresses before checking wallet (https://github.com/filecoin-project/lotus/pull/4122)
- add a command to view block space utilization (https://github.com/filecoin-project/lotus/pull/4176)
- allow usage inspection on a chain segment (https://github.com/filecoin-project/lotus/pull/4177)
- Add mpool stats for base fee (https://github.com/filecoin-project/lotus/pull/4170)
- Add verified status to api.DealInfo (https://github.com/filecoin-project/lotus/pull/4153)
- Add a CLI command to set a miner's owner address (https://github.com/filecoin-project/lotus/pull/4189)
-
-#### Tooling and validation
-
- Lotus-pcr: add recover-miners command (https://github.com/filecoin-project/lotus/pull/3714)
- MpoolPushUntrusted API for gateway (https://github.com/filecoin-project/lotus/pull/3915)
- Test lotus-miner info all (https://github.com/filecoin-project/lotus/pull/4166)
- chain export: Error with unfinished exports (https://github.com/filecoin-project/lotus/pull/4179)
- add printf in TestWindowPost (https://github.com/filecoin-project/lotus/pull/4043)
- add trace wdpost (https://github.com/filecoin-project/lotus/pull/4020)
- Fix noncefix (https://github.com/filecoin-project/lotus/pull/4202)
- Lotus-pcr: Limit the fee cap of messages we will process, refund gas fees for windowed post and storage deals (https://github.com/filecoin-project/lotus/pull/4198)
- Fix pond (https://github.com/filecoin-project/lotus/pull/4203)
- allow manual setting of noncefix fee cap (https://github.com/filecoin-project/lotus/pull/4205)
- implement command to get execution traces of any message (https://github.com/filecoin-project/lotus/pull/4200)
- conformance: minor driver refactors (https://github.com/filecoin-project/lotus/pull/4211) 
- lotus-pcr: ignore all other messages (https://github.com/filecoin-project/lotus/pull/4218)
- lotus-pcr: zero refund (https://github.com/filecoin-project/lotus/pull/4229)
-
-## Contributors
-
-The following contributors had 5 or more commits go into this release.
-We are grateful for every contribution!
-
-| Contributor        | Commits | Lines ±       |
-|--------------------|---------|---------------|
-| Stebalien          | 84       | +3425/-2287  |
-| magik6k            | 41       | +2121/-506   |
-| arajasek           | 39       | +2467/-424   |
-| Kubuxu             | 25       | +2344/-775   |
-| raulk              | 21       | +287/-196    |
-| whyrusleeping      | 13       | +727/-71     |
-| hsanjuan           | 13       | +5886/-7956  |
-| dirkmc             | 11       | +2634/-576   | 
-| travisperson       | 8        | +923/-202    |
-| ribasushi          | 6        | +188/-128    |
-| zgfzgf             | 5        | +21/-17      |
-
-# 0.8.1 / 2020-09-30
-
-This optional release of Lotus introduces a new version of markets which switches to CBOR-map encodings, and allows datastore migrations. The release also introduces several improvements to the mining process, a few performance optimizations, and a battery of UX additions and enhancements.
-
-## Changes 
-
-#### Dependencies
-
- Markets 0.7.0 with updated data stores (https://github.com/filecoin-project/lotus/pull/4089)
- Update ffi to code with blst fixes (https://github.com/filecoin-project/lotus/pull/3998)
-
-#### Core Lotus
-
- Fix GetPower with no miner address (https://github.com/filecoin-project/lotus/pull/4049)
- Refactor: Move nonce generation out of mpool (https://github.com/filecoin-project/lotus/pull/3970)
-
-#### Performance
-
- Implement caching syscalls for import-bench (https://github.com/filecoin-project/lotus/pull/3888)
- Fetch tipset blocks in parallel (https://github.com/filecoin-project/lotus/pull/4074)
- Optimize Tipset equals() (https://github.com/filecoin-project/lotus/pull/4056)
- Make state transition in validation async (https://github.com/filecoin-project/lotus/pull/3868)
-
-#### Mining
-
- Add trace window post (https://github.com/filecoin-project/lotus/pull/4020)
- Use abstract types for Dont recompute post on revert (https://github.com/filecoin-project/lotus/pull/4022)
- Fix injectNulls logic in test miner (https://github.com/filecoin-project/lotus/pull/4058)
- Fix potential panic in FinalizeSector (https://github.com/filecoin-project/lotus/pull/4092)
- Don't recompute post on revert (https://github.com/filecoin-project/lotus/pull/3924)
- Fix some failed precommit handling (https://github.com/filecoin-project/lotus/pull/3445)
- Add --no-swap flag for worker (https://github.com/filecoin-project/lotus/pull/4107)
- Allow some single-thread tasks to run in parallel with PC2/C2 (https://github.com/filecoin-project/lotus/pull/4116)
-
-#### UX
-
- Add an envvar to set address network version (https://github.com/filecoin-project/lotus/pull/4028)
- Add logging to chain export (https://github.com/filecoin-project/lotus/pull/4030)
- Add JSON output to state compute (https://github.com/filecoin-project/lotus/pull/4038)
- Wallet list CLI: Print balances/nonces (https://github.com/filecoin-project/lotus/pull/4088)
- Added an option to show or not show sector info for `lotus-miner info` (https://github.com/filecoin-project/lotus/pull/4003)
- Add a command to import an ipld object into the chainstore (https://github.com/filecoin-project/lotus/pull/3434)
- Improve the lotus-shed dealtracker (https://github.com/filecoin-project/lotus/pull/4051)
- Docs review and re-organization (https://github.com/filecoin-project/lotus/pull/3431)
- Fix wallet list (https://github.com/filecoin-project/lotus/pull/4104)
- Add an endpoint to validate whether a string is a well-formed address (https://github.com/filecoin-project/lotus/pull/4106)
- Add an option to set config path (https://github.com/filecoin-project/lotus/pull/4103)
- Add printf in TestWindowPost (https://github.com/filecoin-project/lotus/pull/4043)
- Improve miner sectors list UX (https://github.com/filecoin-project/lotus/pull/4108)
-
-#### Tooling
-
- Move policy change to seal bench (https://github.com/filecoin-project/lotus/pull/4032)
- Add back network power to stats (https://github.com/filecoin-project/lotus/pull/4050)
- Conformance: Record and feed circulating supply (https://github.com/filecoin-project/lotus/pull/4078)
- Snapshot import progress bar, add HTTP support (https://github.com/filecoin-project/lotus/pull/4070)
- Add lotus shed util to validate a tipset (https://github.com/filecoin-project/lotus/pull/4065)
- tvx: a test vector extraction and execution tool (https://github.com/filecoin-project/lotus/pull/4064)
-
-#### Bootstrap
-
- Add new bootstrappers (https://github.com/filecoin-project/lotus/pull/4007)
- Add Glif node to bootstrap peers (https://github.com/filecoin-project/lotus/pull/4004)
- Add one more node located in China (https://github.com/filecoin-project/lotus/pull/4041)
- Add ipfsmain bootstrapper (https://github.com/filecoin-project/lotus/pull/4067)
-
-# 0.8.0 / 2020-09-26
-
-This consensus-breaking release of Lotus introduces an upgrade to the network. The changes that break consensus are:
-
- Upgrading to specs-actors v0.9.11, which reduces WindowPoSt faults per [FIP 0002](https://github.com/filecoin-project/FIPs/blob/master/FIPS/fip-0002.md) to reduce cost for honest miners with occasional faults (see https://github.com/filecoin-project/specs-actors/pull/1181)
- Revisions to some cryptoeconomics and network params
-
-This release also updates go-fil-markets to fix an incompatibility issue between v0.7.2 and earlier versions.
-
-## Changes 
-
-#### Dependencies
-
- Update spec actors to 0.9.11 (https://github.com/filecoin-project/lotus/pull/4039)
- Update markets to 0.6.3 (https://github.com/filecoin-project/lotus/pull/4013)
-
-#### Core Lotus
-
- Network upgrade (https://github.com/filecoin-project/lotus/pull/4039)
- Fix AddSupportedProofTypes (https://github.com/filecoin-project/lotus/pull/4033)
- Return an error when we fail to find a sector when checking sector expiration (https://github.com/filecoin-project/lotus/pull/4026)
- Batch blockstore copies after block validation (https://github.com/filecoin-project/lotus/pull/3980)
- Remove a misleading miner actor abstraction (https://github.com/filecoin-project/lotus/pull/3977)
- Fix out-of-bounds when loading all sector infos (https://github.com/filecoin-project/lotus/pull/3976)
- Fix break condition in the miner (https://github.com/filecoin-project/lotus/pull/3953)
-
-#### UX
-
- Correct helptext around miners setting ask (https://github.com/filecoin-project/lotus/pull/4009)
- Make sync wait nicer (https://github.com/filecoin-project/lotus/pull/3991)
-
-#### Tooling and validation
-
- Small adjustments following network upgradability changes (https://github.com/filecoin-project/lotus/pull/3996)
- Add some more big pictures stats to stateroot stat (https://github.com/filecoin-project/lotus/pull/3995)
- Add some actors policy setters for testing (https://github.com/filecoin-project/lotus/pull/3975)
-
-## Contributors
-
-The following contributors had 5 or more commits go into this release.
-We are grateful for every contribution!
-
-| Contributor        | Commits | Lines ±       |
-|--------------------|---------|---------------|
-| arajasek           | 66       | +3140/-1261  |
-| Stebalien          | 64       | +3797/-3434  |
-| magik6k            | 48       | +1892/-976   |
-| raulk              | 40       | +2412/-1549  |
-| vyzo               | 22       | +287/-196    |
-| alanshaw           | 15       | +761/-146    |
-| whyrusleeping      | 15       | +736/-52     |
-| hannahhoward       | 14       | +1237/-837   | 
-| anton              | 6        | +32/-8       |
-| travisperson       | 5        | +502/-6      |
-| Frank              | 5        | +78/-39      |
-| Jennifer           | 5        | +148/-41     |
-
-# 0.7.2 / 2020-09-23
-
-This optional release of Lotus introduces a major refactor around how a Lotus node interacts with code from the specs-actors repo. We now use interfaces to read the state of actors, which is required to be able to reason about different versions of actors code at the same time.
-
-Additionally, this release introduces various improvements to the sync process, as well as changes to better the overall UX experience.
-
-## Changes
-
-#### Core Lotus
-
- Network upgrade support (https://github.com/filecoin-project/lotus/pull/3781)
- Upgrade markets to `v0.6.2` (https://github.com/filecoin-project/lotus/pull/3974)
- Validate chain sync response indices when fetching messages (https://github.com/filecoin-project/lotus/pull/3939)
- Add height diff to sync wait (https://github.com/filecoin-project/lotus/pull/3926)
- Replace Requires with Wants (https://github.com/filecoin-project/lotus/pull/3898)
- Update state diffing for market actor (https://github.com/filecoin-project/lotus/pull/3889)
- Parallel fetch for sync (https://github.com/filecoin-project/lotus/pull/3887)
- Fix SectorState (https://github.com/filecoin-project/lotus/pull/3881)
-
-#### User Experience
-
- Add basic deal stats api server for spacerace slingshot (https://github.com/filecoin-project/lotus/pull/3963)
- When doing `sectors update-state`, show a list of existing states if user inputs an invalid one (https://github.com/filecoin-project/lotus/pull/3944)
- Fix `lotus-miner storage find` error (https://github.com/filecoin-project/lotus/pull/3927)
- Log shutdown method for lotus daemon and miner (https://github.com/filecoin-project/lotus/pull/3925)
- Update build and setup instruction link (https://github.com/filecoin-project/lotus/pull/3919)
- Add an option to hide removed sectors from `sectors list` output (https://github.com/filecoin-project/lotus/pull/3903)
-
-#### Testing and validation
-
- Add init.State#Remove() for testing (https://github.com/filecoin-project/lotus/pull/3971)
- lotus-shed: add consensus check command (https://github.com/filecoin-project/lotus/pull/3933)
- Add keyinfo verify and jwt token command to lotus-shed (https://github.com/filecoin-project/lotus/pull/3914)
- Fix conformance gen (https://github.com/filecoin-project/lotus/pull/3892)
-
-# 0.7.1 / 2020-09-17
-
-This optional release of Lotus introduces some critical fixes to the window PoSt process. It also upgrades some core dependencies, and introduces many improvements to the mining process, deal-making cycle, and overall User Experience.
-
-## Changes
-
-#### Some notable improvements: 
-
- Correctly construct params for `SubmitWindowedPoSt` messages (https://github.com/filecoin-project/lotus/pull/3909)
- Skip sectors correctly for Window PoSt (https://github.com/filecoin-project/lotus/pull/3839)
- Split window PoST submission into multiple messages (https://github.com/filecoin-project/lotus/pull/3689)
- Improve journal coverage (https://github.com/filecoin-project/lotus/pull/2455)
- Allow retrievals while sealing (https://github.com/filecoin-project/lotus/pull/3778)
- Don't prune locally published messages (https://github.com/filecoin-project/lotus/pull/3772)
- Add get-ask, set-ask retrieval commands (https://github.com/filecoin-project/lotus/pull/3886)
- Consistently name winning and window post in logs (https://github.com/filecoin-project/lotus/pull/3873))
- Add auto flag to mpool replace (https://github.com/filecoin-project/lotus/pull/3752))
-
-#### Dependencies
-
- Upgrade markets to `v0.6.1` (https://github.com/filecoin-project/lotus/pull/3906)
- Upgrade specs-actors to `v0.9.10` (https://github.com/filecoin-project/lotus/pull/3846)
- Upgrade badger (https://github.com/filecoin-project/lotus/pull/3739)
-
 # 0.7.0 / 2020-09-10

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

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

 lotus-pond: 2k
 	go build -o lotus-pond ./lotuspond
+	(cd lotuspond/front && npm i && CI=false npm run build)
 .PHONY: lotus-pond
 BINS+=lotus-pond

-lotus-pond-front:
-	(cd lotuspond/front && npm i && CI=false npm run build)
-.PHONY: lotus-pond-front
-
-lotus-pond-app: lotus-pond-front lotus-pond
-.PHONY: lotus-pond-app
-
 lotus-townhall:
 	rm -f lotus-townhall
 	go build -o lotus-townhall ./cmd/lotus-townhall
+	(cd ./cmd/lotus-townhall/townhall && npm i && npm run build)
+	go run github.com/GeertJohan/go.rice/rice append --exec lotus-townhall -i ./cmd/lotus-townhall -i ./build
 .PHONY: lotus-townhall
 BINS+=lotus-townhall

-lotus-townhall-front:
-	(cd ./cmd/lotus-townhall/townhall && npm i && npm run build)
-.PHONY: lotus-townhall-front
-
-lotus-townhall-app: lotus-touch lotus-townhall-front
-	go run github.com/GeertJohan/go.rice/rice append --exec lotus-townhall -i ./cmd/lotus-townhall -i ./build
-.PHONY: lotus-townhall-app
-
 lotus-fountain:
 	rm -f lotus-fountain
 	go build -o lotus-fountain ./cmd/lotus-fountain
@@ -182,7 +161,7 @@ BINS+=lotus-bench

 lotus-stats:
 	rm -f lotus-stats
-	go build $(GOFLAGS) -o lotus-stats ./cmd/lotus-stats
+	go build -o lotus-stats ./cmd/lotus-stats
 	go run github.com/GeertJohan/go.rice/rice append --exec lotus-stats -i ./build
 .PHONY: lotus-stats
 BINS+=lotus-stats
@@ -201,18 +180,6 @@ lotus-health:
 .PHONY: lotus-health
 BINS+=lotus-health

-lotus-wallet:
-	rm -f lotus-wallet
-	go build -o lotus-wallet ./cmd/lotus-wallet
-.PHONY: lotus-wallet
-BINS+=lotus-wallet
-
-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
@@ -313,9 +280,7 @@ method-gen:
 gen: type-gen method-gen

 docsgen:
-	go run ./api/docgen "api/api_full.go" "FullNode" > documentation/en/api-methods.md
-	go run ./api/docgen "api/api_storage.go" "StorageMiner" > documentation/en/api-methods-miner.md
-	go run ./api/docgen "api/api_worker.go" "WorkerAPI" > documentation/en/api-methods-worker.md
+	go run ./api/docgen > documentation/en/api-methods.md

 print-%:
 	@echo $*=$($*)
@@ -1,5 +1,5 @@
 <p align="center">
-  <a href="https://docs.filecoin.io/" title="Filecoin Docs">
+  <a href="https://lotu.sh/" title="Lotus Docs">
    <img src="documentation/images/lotus_logo_h.png" alt="Project Lotus Logo" width="244" />
  </a>
 </p>
@@ -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>

@@ -18,37 +18,30 @@ Lotus is an implementation of the Filecoin Distributed Storage Network. For more

 ## Building & Documentation

-For instructions on how to build, install and setup lotus, please visit [https://docs.filecoin.io/get-started/lotus](https://docs.filecoin.io/get-started/lotus/).
+For instructions on how to build lotus from source, please visit [https://lotu.sh](https://lotu.sh) or read the source [here](https://github.com/filecoin-project/lotus/tree/master/documentation).

 ## Reporting a Vulnerability

 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,13 @@

 ## 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 send an email to security@filecoin.org.
+
+The bug reporting process differs between bugs that are critical and may crash the network, and others that are unlikely to cause problems if malicious parties know about it. For non-critical bugs, please simply file a GitHub [issue](https://github.com/filecoin-project/lotus/issues/new?template=bug_report.md). 

 Please try to provide a clear description of any bugs reported, along with how to reproduce the bug if possible. More detailed bug reports (especially those with a PoC included) will help us move forward much faster. Additionally, please avoid reporting bugs that already have open issues. Take a moment to search the issue list of the related GitHub repositories before writing up a new report.

-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 +18,12 @@ 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
+## Supported Versions

-For non-security bugs, please simply file a GitHub [issue](https://github.com/filecoin-project/lotus/issues/new?template=bug_report.md). 
+* TODO: This should be defined and set up by Mainnet launch.
+
+| Version | Supported          |
+| ------- | ------------------ |
+| Testnet | :white_check_mark: |
@@ -4,8 +4,6 @@ import (
 	"context"
 	"fmt"

-	"github.com/google/uuid"
-
 	"github.com/filecoin-project/go-jsonrpc/auth"
 	metrics "github.com/libp2p/go-libp2p-core/metrics"
 	"github.com/libp2p/go-libp2p-core/network"
@@ -46,11 +44,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
@@ -65,9 +58,6 @@ type Common interface {
 	// trigger graceful shutdown
 	Shutdown(context.Context) error

-	// Session returns a random UUID of api provider session
-	Session(context.Context) (uuid.UUID, error)
-
 	Closing(context.Context) (<-chan struct{}, error)
 }

@@ -2,12 +2,12 @@ package api

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

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

 	"github.com/ipfs/go-cid"
 	"github.com/libp2p/go-libp2p-core/peer"
@@ -20,13 +20,12 @@ 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/go-state-types/dline"
-	"github.com/filecoin-project/lotus/chain/actors/builtin/market"
-	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
-	"github.com/filecoin-project/lotus/chain/actors/builtin/paych"
+	"github.com/filecoin-project/specs-actors/actors/builtin/market"
+	"github.com/filecoin-project/specs-actors/actors/builtin/miner"
+	"github.com/filecoin-project/specs-actors/actors/builtin/paych"
+	"github.com/filecoin-project/specs-actors/actors/builtin/power"
+	"github.com/filecoin-project/specs-actors/actors/builtin/verifreg"

-	"github.com/filecoin-project/lotus/chain/actors/builtin"
-	"github.com/filecoin-project/lotus/chain/actors/builtin/power"
 	"github.com/filecoin-project/lotus/chain/types"
 	marketevents "github.com/filecoin-project/lotus/markets/loggers"
 	"github.com/filecoin-project/lotus/node/modules/dtypes"
@@ -78,9 +77,6 @@ type FullNode interface {
 	// blockstore and returns raw bytes.
 	ChainReadObj(context.Context, cid.Cid) ([]byte, error)

-	// ChainDeleteObj deletes node referenced by the given CID
-	ChainDeleteObj(context.Context, cid.Cid) error
-
 	// ChainHasObj checks if a given CID exists in the chain blockstore.
 	ChainHasObj(context.Context, cid.Cid) (bool, error)

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

 	// MethodGroup: Beacon
 	// The Beacon method group contains methods for interacting with the random beacon (DRAND)
@@ -174,16 +169,10 @@ type FullNode interface {
 	// SyncUnmarkBad unmarks a blocks as bad, making it possible to be validated and synced again.
 	SyncUnmarkBad(ctx context.Context, bcid cid.Cid) error

-	// SyncUnmarkAllBad purges bad block cache, making it possible to sync to chains previously marked as bad
-	SyncUnmarkAllBad(ctx context.Context) error
-
 	// SyncCheckBad checks if a block was marked as bad, and if it was, returns
 	// the reason.
 	SyncCheckBad(ctx context.Context, bcid cid.Cid) (string, error)

-	// SyncValidateTipset indicates whether the provided tipset is valid or not
-	SyncValidateTipset(ctx context.Context, tsk types.TipSetKey) (bool, error)
-
 	// MethodGroup: Mpool
 	// The Mpool methods are for interacting with the message pool. The message pool
 	// manages all incoming and outgoing 'messages' going over the network.
@@ -197,9 +186,6 @@ type FullNode interface {
 	// MpoolPush pushes a signed message to mempool.
 	MpoolPush(context.Context, *types.SignedMessage) (cid.Cid, error)

-	// MpoolPushUntrusted pushes a signed message to mempool from untrusted sources.
-	MpoolPushUntrusted(context.Context, *types.SignedMessage) (cid.Cid, error)
-
 	// MpoolPushMessage atomically assigns a nonce, signs, and pushes a message
 	// to mempool.
 	// maxFee is only used when GasFeeCap/GasPremium fields aren't specified
@@ -208,15 +194,6 @@ type FullNode interface {
 	// based on current chain conditions
 	MpoolPushMessage(ctx context.Context, msg *types.Message, spec *MessageSendSpec) (*types.SignedMessage, error)

-	// MpoolBatchPush batch pushes a signed message to mempool.
-	MpoolBatchPush(context.Context, []*types.SignedMessage) ([]cid.Cid, error)
-
-	// MpoolBatchPushUntrusted batch pushes a signed message to mempool from untrusted sources.
-	MpoolBatchPushUntrusted(context.Context, []*types.SignedMessage) ([]cid.Cid, error)
-
-	// MpoolBatchPushMessage batch pushes a unsigned message to mempool.
-	MpoolBatchPushMessage(context.Context, []*types.Message, *MessageSendSpec) ([]*types.SignedMessage, error)
-
 	// MpoolGetNonce gets next nonce for the specified sender.
 	// Note that this method may not be atomic. Use MpoolPushMessage instead.
 	MpoolGetNonce(context.Context, address.Address) (uint64, error)
@@ -240,9 +217,7 @@ type FullNode interface {
 	// MethodGroup: Wallet

 	// WalletNew creates a new address in the wallet with the given sigType.
-	// Available key types: bls, secp256k1, secp256k1-ledger
-	// Support for numerical types: 1 - secp256k1, 2 - BLS is deprecated
-	WalletNew(context.Context, types.KeyType) (address.Address, error)
+	WalletNew(context.Context, crypto.SigType) (address.Address, error)
 	// WalletHas indicates whether the given address is in the wallet.
 	WalletHas(context.Context, address.Address) (bool, error)
 	// WalletList lists all the addresses in the wallet.
@@ -255,7 +230,7 @@ type FullNode interface {
 	WalletSignMessage(context.Context, address.Address, *types.Message) (*types.SignedMessage, error)
 	// WalletVerify takes an address, a signature, and some bytes, and indicates whether the signature is valid.
 	// The address does not have to be in the wallet.
-	WalletVerify(context.Context, address.Address, []byte, *crypto.Signature) (bool, error)
+	WalletVerify(context.Context, address.Address, []byte, *crypto.Signature) bool
 	// WalletDefaultAddress returns the address marked as default in the wallet.
 	WalletDefaultAddress(context.Context) (address.Address, error)
 	// WalletSetDefault marks the given address as as the default one.
@@ -266,8 +241,6 @@ type FullNode interface {
 	WalletImport(context.Context, *types.KeyInfo) (address.Address, error)
 	// WalletDelete deletes an address from the wallet.
 	WalletDelete(context.Context, address.Address) error
-	// WalletValidateAddress validates whether a given string can be decoded as a well-formed address
-	WalletValidateAddress(context.Context, string) (address.Address, error)

 	// Other

@@ -287,8 +260,6 @@ type FullNode interface {
 	ClientListDeals(ctx context.Context) ([]DealInfo, error)
 	// ClientGetDealUpdates returns the status of updated deals
 	ClientGetDealUpdates(ctx context.Context) (<-chan DealInfo, error)
-	// ClientGetDealStatus returns status given a code
-	ClientGetDealStatus(ctx context.Context, statusCode uint64) (string, error)
 	// ClientHasLocal indicates whether a certain CID is locally stored.
 	ClientHasLocal(ctx context.Context, root cid.Cid) (bool, error)
 	// ClientFindData identifies peers that have a certain file, and returns QueryOffers (one per peer).
@@ -301,9 +272,7 @@ type FullNode interface {
 	// of status updates.
 	ClientRetrieveWithEvents(ctx context.Context, order RetrievalOrder, ref *FileRef) (<-chan marketevents.RetrievalEvent, error)
 	// ClientQueryAsk returns a signed StorageAsk from the specified miner.
-	ClientQueryAsk(ctx context.Context, p peer.ID, miner address.Address) (*storagemarket.StorageAsk, error)
-	// ClientCalcCommP calculates the CommP and data size of the specified CID
-	ClientDealPieceCID(ctx context.Context, root cid.Cid) (DataCIDSize, error)
+	ClientQueryAsk(ctx context.Context, p peer.ID, miner address.Address) (*storagemarket.SignedStorageAsk, error)
 	// ClientCalcCommP calculates the CommP for a specified file
 	ClientCalcCommP(ctx context.Context, inpath string) (*CommPRet, error)
 	// ClientGenCar generates a CAR file for the specified file.
@@ -313,10 +282,6 @@ type FullNode interface {
 	// ClientListTransfers returns the status of all ongoing transfers of data
 	ClientListDataTransfers(ctx context.Context) ([]DataTransferChannel, error)
 	ClientDataTransferUpdates(ctx context.Context) (<-chan DataTransferChannel, error)
-	// ClientRestartDataTransfer attempts to restart a data transfer with the given transfer ID and other peer
-	ClientRestartDataTransfer(ctx context.Context, transferID datatransfer.TransferID, otherPeer peer.ID, isInitiator bool) error
-	// ClientCancelDataTransfer cancels a data transfer with the given transfer ID and other peer
-	ClientCancelDataTransfer(ctx context.Context, transferID datatransfer.TransferID, otherPeer peer.ID, isInitiator bool) error
 	// ClientRetrieveTryRestartInsufficientFunds attempts to restart stalled retrievals on a given payment channel
 	// which are stuck due to insufficient funds
 	ClientRetrieveTryRestartInsufficientFunds(ctx context.Context, paymentChannel address.Address) error
@@ -331,40 +296,39 @@ type FullNode interface {

 	// MethodGroup: State
 	// The State methods are used to query, inspect, and interact with chain state.
-	// Most methods take a TipSetKey as a parameter. The state looked up is the state at that tipset.
+	// All methods take a TipSetKey as a parameter. The state looked up is the state at that tipset.
 	// A nil TipSetKey can be provided as a param, this will cause the heaviest tipset in the chain to be used.

 	// StateCall runs the given message and returns its result without any persisted changes.
 	StateCall(context.Context, *types.Message, types.TipSetKey) (*InvocResult, error)
-	// StateReplay replays a given message, assuming it was included in a block in the specified tipset.
-	// If no tipset key is provided, the appropriate tipset is looked up.
+	// StateReplay returns the result of executing the indicated message, assuming it was executed in the indicated tipset.
 	StateReplay(context.Context, types.TipSetKey, cid.Cid) (*InvocResult, error)
 	// StateGetActor returns the indicated actor's nonce and balance.
 	StateGetActor(ctx context.Context, actor address.Address, tsk types.TipSetKey) (*types.Actor, error)
 	// StateReadState returns the indicated actor's state.
 	StateReadState(ctx context.Context, actor address.Address, tsk types.TipSetKey) (*ActorState, error)
 	// StateListMessages looks back and returns all messages with a matching to or from address, stopping at the given height.
-	StateListMessages(ctx context.Context, match *MessageMatch, tsk types.TipSetKey, toht abi.ChainEpoch) ([]cid.Cid, error)
-	// StateDecodeParams attempts to decode the provided params, based on the recipient actor address and method number.
-	StateDecodeParams(ctx context.Context, toAddr address.Address, method abi.MethodNum, params []byte, tsk types.TipSetKey) (interface{}, error)
+	StateListMessages(ctx context.Context, match *types.Message, tsk types.TipSetKey, toht abi.ChainEpoch) ([]cid.Cid, error)

 	// StateNetworkName returns the name of the network the node is synced to
 	StateNetworkName(context.Context) (dtypes.NetworkName, error)
 	// StateMinerSectors returns info about the given miner's sectors. If the filter bitfield is nil, all sectors are included.
-	StateMinerSectors(context.Context, address.Address, *bitfield.BitField, types.TipSetKey) ([]*miner.SectorOnChainInfo, error)
+	// If the filterOut boolean is set to true, any sectors in the filter are excluded.
+	// If false, only those sectors in the filter are included.
+	StateMinerSectors(context.Context, address.Address, *bitfield.BitField, bool, types.TipSetKey) ([]*ChainSectorInfo, error)
 	// StateMinerActiveSectors returns info about sectors that a given miner is actively proving.
-	StateMinerActiveSectors(context.Context, address.Address, types.TipSetKey) ([]*miner.SectorOnChainInfo, error)
+	StateMinerActiveSectors(context.Context, address.Address, types.TipSetKey) ([]*ChainSectorInfo, error)
 	// StateMinerProvingDeadline calculates the deadline at some epoch for a proving period
 	// and returns the deadline-related calculations.
 	StateMinerProvingDeadline(context.Context, address.Address, types.TipSetKey) (*dline.Info, error)
 	// StateMinerPower returns the power of the indicated miner
 	StateMinerPower(context.Context, address.Address, types.TipSetKey) (*MinerPower, error)
 	// StateMinerInfo returns info about the indicated miner
-	StateMinerInfo(context.Context, address.Address, types.TipSetKey) (miner.MinerInfo, error)
+	StateMinerInfo(context.Context, address.Address, types.TipSetKey) (MinerInfo, error)
 	// StateMinerDeadlines returns all the proving deadlines for the given miner
-	StateMinerDeadlines(context.Context, address.Address, types.TipSetKey) ([]Deadline, error)
-	// StateMinerPartitions returns all partitions in the specified deadline
-	StateMinerPartitions(ctx context.Context, m address.Address, dlIdx uint64, tsk types.TipSetKey) ([]Partition, error)
+	StateMinerDeadlines(context.Context, address.Address, types.TipSetKey) ([]*miner.Deadline, error)
+	// StateMinerPartitions loads miner partitions for the specified miner/deadline
+	StateMinerPartitions(context.Context, address.Address, uint64, types.TipSetKey) ([]*miner.Partition, error)
 	// StateMinerFaults returns a bitfield indicating the faulty sectors of the given miner
 	StateMinerFaults(context.Context, address.Address, types.TipSetKey) (bitfield.BitField, error)
 	// StateAllMinerFaults returns all non-expired Faults that occur within lookback epochs of the given tipset
@@ -377,8 +341,6 @@ type FullNode interface {
 	StateMinerInitialPledgeCollateral(context.Context, address.Address, miner.SectorPreCommitInfo, types.TipSetKey) (types.BigInt, error)
 	// StateMinerAvailableBalance returns the portion of a miner's balance that can be withdrawn or spent
 	StateMinerAvailableBalance(context.Context, address.Address, types.TipSetKey) (types.BigInt, error)
-	// StateMinerSectorAllocated checks if a sector is allocated
-	StateMinerSectorAllocated(context.Context, address.Address, abi.SectorNumber, types.TipSetKey) (bool, error)
 	// StateSectorPreCommitInfo returns the PreCommit info for the specified miner's sector
 	StateSectorPreCommitInfo(context.Context, address.Address, abi.SectorNumber, types.TipSetKey) (miner.SectorPreCommitOnChainInfo, error)
 	// StateSectorGetInfo returns the on-chain info for the specified miner's sector. Returns null in case the sector info isn't found
@@ -386,20 +348,14 @@ type FullNode interface {
 	// expiration epoch
 	StateSectorGetInfo(context.Context, address.Address, abi.SectorNumber, types.TipSetKey) (*miner.SectorOnChainInfo, error)
 	// StateSectorExpiration returns epoch at which given sector will expire
-	StateSectorExpiration(context.Context, address.Address, abi.SectorNumber, types.TipSetKey) (*miner.SectorExpiration, error)
+	StateSectorExpiration(context.Context, address.Address, abi.SectorNumber, types.TipSetKey) (*SectorExpiration, error)
 	// StateSectorPartition finds deadline/partition with the specified sector
-	StateSectorPartition(ctx context.Context, maddr address.Address, sectorNumber abi.SectorNumber, tok types.TipSetKey) (*miner.SectorLocation, error)
+	StateSectorPartition(ctx context.Context, maddr address.Address, sectorNumber abi.SectorNumber, tok types.TipSetKey) (*SectorLocation, error)
 	// StateSearchMsg searches for a message in the chain, and returns its receipt and the tipset where it was executed
 	StateSearchMsg(context.Context, cid.Cid) (*MsgLookup, error)
-	// 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)
-	// StateWaitMsgLimited looks back up to limit epochs in the chain for a message.
-	// If not found, it blocks until the message arrives on chain, and gets to the
-	// indicated confidence depth.
-	StateWaitMsgLimited(ctx context.Context, cid cid.Cid, confidence uint64, limit abi.ChainEpoch) (*MsgLookup, error)
 	// StateListMiners returns the addresses of every miner that has claimed power in the Power Actor
 	StateListMiners(context.Context, types.TipSetKey) ([]address.Address, error)
 	// StateListActors returns the addresses of every actor in the state
@@ -426,28 +382,16 @@ type FullNode interface {
 	// StateCompute is a flexible command that applies the given messages on the given tipset.
 	// The messages are run as though the VM were at the provided height.
 	StateCompute(context.Context, abi.ChainEpoch, []*types.Message, types.TipSetKey) (*ComputeStateOutput, error)
-	// StateVerifierStatus returns the data cap for the given address.
-	// Returns nil if there is no entry in the data cap table for the
-	// address.
-	StateVerifierStatus(ctx context.Context, addr address.Address, tsk types.TipSetKey) (*abi.StoragePower, error)
 	// StateVerifiedClientStatus returns the data cap for the given address.
 	// Returns nil if there is no entry in the data cap table for the
 	// address.
-	StateVerifiedClientStatus(ctx context.Context, addr address.Address, tsk types.TipSetKey) (*abi.StoragePower, error)
-	// StateVerifiedClientStatus returns the address of the Verified Registry's root key
-	StateVerifiedRegistryRootKey(ctx context.Context, tsk types.TipSetKey) (address.Address, error)
+	StateVerifiedClientStatus(ctx context.Context, addr address.Address, tsk types.TipSetKey) (*verifreg.DataCap, error)
 	// StateDealProviderCollateralBounds returns the min and max collateral a storage provider
 	// can issue. It takes the deal size and verified status as parameters.
 	StateDealProviderCollateralBounds(context.Context, abi.PaddedPieceSize, bool, types.TipSetKey) (DealCollateralBounds, error)

-	// StateCirculatingSupply returns the exact circulating supply of Filecoin at the given tipset.
-	// This is not used anywhere in the protocol itself, and is only for external consumption.
-	StateCirculatingSupply(context.Context, types.TipSetKey) (abi.TokenAmount, error)
-	// StateVMCirculatingSupplyInternal returns an approximation of the circulating supply of Filecoin at the given tipset.
-	// This is the value reported by the runtime interface to actors code.
-	StateVMCirculatingSupplyInternal(context.Context, types.TipSetKey) (CirculatingSupply, error)
-	// StateNetworkVersion returns the network version at the given tipset
-	StateNetworkVersion(context.Context, types.TipSetKey) (network.Version, error)
+	// StateCirculatingSupply returns the circulating supply of Filecoin at the given tipset
+	StateCirculatingSupply(context.Context, types.TipSetKey) (CirculatingSupply, error)

 	// MethodGroup: Msig
 	// The Msig methods are used to interact with multisig wallets on the
@@ -455,8 +399,6 @@ type FullNode interface {

 	// MsigGetAvailableBalance returns the portion of a multisig's balance that can be withdrawn or spent
 	MsigGetAvailableBalance(context.Context, address.Address, types.TipSetKey) (types.BigInt, error)
-	// MsigGetVestingSchedule returns the vesting details of a given multisig.
-	MsigGetVestingSchedule(context.Context, address.Address, types.TipSetKey) (MsigVesting, error)
 	// MsigGetVested returns the amount of FIL that vested in a multisig in a certain period.
 	// It takes the following params: <multisig address>, <start epoch>, <end epoch>
 	MsigGetVested(context.Context, address.Address, types.TipSetKey, types.TipSetKey) (types.BigInt, error)
@@ -468,21 +410,12 @@ type FullNode interface {
 	// It takes the following params: <multisig address>, <recipient address>, <value to transfer>,
 	// <sender address of the propose msg>, <method to call in the proposed message>, <params to include in the proposed message>
 	MsigPropose(context.Context, address.Address, address.Address, types.BigInt, address.Address, uint64, []byte) (cid.Cid, error)
-
-	// MsigApprove approves a previously-proposed multisig message by transaction ID
-	// It takes the following params: <multisig address>, <proposed transaction ID> <signer address>
-	MsigApprove(context.Context, address.Address, uint64, address.Address) (cid.Cid, error)
-
-	// MsigApproveTxnHash approves a previously-proposed multisig message, specified
-	// using both transaction ID and a hash of the parameters used in the
-	// proposal. This method of approval can be used to ensure you only approve
-	// exactly the transaction you think you are.
+	// MsigApprove approves a previously-proposed multisig message
 	// It takes the following params: <multisig address>, <proposed message ID>, <proposer address>, <recipient address>, <value to transfer>,
 	// <sender address of the approve msg>, <method to call in the proposed message>, <params to include in the proposed message>
-	MsigApproveTxnHash(context.Context, address.Address, uint64, address.Address, address.Address, types.BigInt, address.Address, uint64, []byte) (cid.Cid, error)
-
+	MsigApprove(context.Context, address.Address, uint64, address.Address, address.Address, types.BigInt, address.Address, uint64, []byte) (cid.Cid, error)
 	// MsigCancel cancels a previously-proposed multisig message
-	// It takes the following params: <multisig address>, <proposed transaction ID>, <recipient address>, <value to transfer>,
+	// It takes the following params: <multisig address>, <proposed message ID>, <recipient address>, <value to transfer>,
 	// <sender address of the cancel msg>, <method to call in the proposed message>, <params to include in the proposed message>
 	MsigCancel(context.Context, address.Address, uint64, address.Address, types.BigInt, address.Address, uint64, []byte) (cid.Cid, error)
 	// MsigAddPropose proposes adding a signer in the multisig
@@ -510,31 +443,16 @@ type FullNode interface {
 	// <old signer>, <new signer>
 	MsigSwapCancel(context.Context, address.Address, address.Address, uint64, address.Address, address.Address) (cid.Cid, error)

-	// MsigRemoveSigner proposes the removal of a signer from the multisig.
-	// It accepts the multisig to make the change on, the proposer address to
-	// send the message from, the address to be removed, and a boolean
-	// indicating whether or not the signing threshold should be lowered by one
-	// along with the address removal.
-	MsigRemoveSigner(ctx context.Context, msig address.Address, proposer address.Address, toRemove address.Address, decrease bool) (cid.Cid, error)
-
-	// 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)
+	MarketEnsureAvailable(context.Context, address.Address, address.Address, types.BigInt) (cid.Cid, error)
+	// MarketFreeBalance

 	// MethodGroup: Paych
 	// The Paych methods are for interacting with and managing payment channels

 	PaychGet(ctx context.Context, from, to address.Address, amt types.BigInt) (*ChannelInfo, error)
 	PaychGetWaitReady(context.Context, cid.Cid) (address.Address, error)
-	PaychAvailableFunds(ctx context.Context, ch address.Address) (*ChannelAvailableFunds, error)
-	PaychAvailableFundsByFromTo(ctx context.Context, from, to address.Address) (*ChannelAvailableFunds, error)
+	PaychAvailableFunds(ch address.Address) (*ChannelAvailableFunds, error)
+	PaychAvailableFundsByFromTo(from, to address.Address) (*ChannelAvailableFunds, error)
 	PaychList(context.Context) ([]address.Address, error)
 	PaychStatus(context.Context, address.Address) (*PaychStatus, error)
 	PaychSettle(context.Context, address.Address) (cid.Cid, error)
@@ -547,12 +465,6 @@ type FullNode interface {
 	PaychVoucherAdd(context.Context, address.Address, *paych.SignedVoucher, []byte, types.BigInt) (types.BigInt, error)
 	PaychVoucherList(context.Context, address.Address) ([]*paych.SignedVoucher, error)
 	PaychVoucherSubmit(context.Context, address.Address, *paych.SignedVoucher, []byte, []byte) (cid.Cid, error)
-
-	// CreateBackup creates node backup onder the specified file name. The
-	// method requires that the lotus daemon is running with the
-	// LOTUS_BACKUP_BASE_PATH environment variable set to some path, and that
-	// the path specified when calling CreateBackup is within the base path
-	CreateBackup(ctx context.Context, fpath string) error
 }

 type FileRef struct {
@@ -561,12 +473,21 @@ type FileRef struct {
 }

 type MinerSectors struct {
-	// Live sectors that should be proven.
-	Live uint64
-	// Sectors actively contributing to power.
-	Active uint64
-	// Sectors with failed proofs.
-	Faulty uint64
+	Sectors uint64
+	Active  uint64
+}
+
+type SectorExpiration struct {
+	OnTime abi.ChainEpoch
+
+	// non-zero if sector is faulty, epoch at which it will be permanently
+	// removed if it doesn't recover
+	Early abi.ChainEpoch
+}
+
+type SectorLocation struct {
+	Deadline  uint64
+	Partition uint64
 }

 type ImportRes struct {
@@ -599,10 +520,6 @@ type DealInfo struct {
 	DealID abi.DealID

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

 type MsgLookup struct {
@@ -613,19 +530,6 @@ type MsgLookup struct {
 	Height    abi.ChainEpoch
 }

-type MsgGasCost struct {
-	Message            cid.Cid // Can be different than requested, in case it was replaced, but only gas values changed
-	GasUsed            abi.TokenAmount
-	BaseFeeBurn        abi.TokenAmount
-	OverEstimationBurn abi.TokenAmount
-	MinerPenalty       abi.TokenAmount
-	MinerTip           abi.TokenAmount
-	Refund             abi.TokenAmount
-	TotalCost          abi.TokenAmount
-}
-
-// BlsMessages[x].cid = Cids[x]
-// SecpkMessages[y].cid = Cids[BlsMessages.length + y]
 type BlockMessages struct {
 	BlsMessages   []*types.Message
 	SecpkMessages []*types.SignedMessage
@@ -638,6 +542,11 @@ type Message struct {
 	Message *types.Message
 }

+type ChainSectorInfo struct {
+	Info miner.SectorOnChainInfo
+	ID   abi.SectorNumber
+}
+
 type ActorState struct {
 	Balance types.BigInt
 	State   interface{}
@@ -709,9 +618,8 @@ type VoucherCreateResult struct {
 }

 type MinerPower struct {
-	MinerPower  power.Claim
-	TotalPower  power.Claim
-	HasMinPower bool
+	MinerPower power.Claim
+	TotalPower power.Claim
 }

 type QueryOffer struct {
@@ -771,10 +679,8 @@ type RetrievalOrder struct {
 }

 type InvocResult struct {
-	MsgCid         cid.Cid
 	Msg            *types.Message
 	MsgRct         *types.MessageReceipt
-	GasCost        MsgGasCost
 	ExecutionTrace types.ExecutionTrace
 	Error          string
 	Duration       time.Duration
@@ -797,31 +703,14 @@ 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{}
 }

 type ActiveSync struct {
-	WorkerID uint64
-	Base     *types.TipSet
-	Target   *types.TipSet
+	Base   *types.TipSet
+	Target *types.TipSet

 	Stage  SyncStateStage
 	Height abi.ChainEpoch
@@ -833,8 +722,6 @@ type ActiveSync struct {

 type SyncState struct {
 	ActiveSyncs []ActiveSync
-
-	VMApplied uint64
 }

 type SyncStateStage int
@@ -899,14 +786,14 @@ type CirculatingSupply struct {
 }

 type MiningBaseInfo struct {
-	MinerPower        types.BigInt
-	NetworkPower      types.BigInt
-	Sectors           []builtin.SectorInfo
-	WorkerKey         address.Address
-	SectorSize        abi.SectorSize
-	PrevBeaconEntry   types.BeaconEntry
-	BeaconEntries     []types.BeaconEntry
-	EligibleForMining bool
+	MinerPower      types.BigInt
+	NetworkPower    types.BigInt
+	Sectors         []proof.SectorInfo
+	WorkerKey       address.Address
+	SectorSize      abi.SectorSize
+	PrevBeaconEntry types.BeaconEntry
+	BeaconEntries   []types.BeaconEntry
+	HasMinPower     bool
 }

 type BlockTemplate struct {
@@ -918,7 +805,7 @@ type BlockTemplate struct {
 	Messages         []*types.SignedMessage
 	Epoch            abi.ChainEpoch
 	Timestamp        uint64
-	WinningPoStProof []builtin.PoStProof
+	WinningPoStProof []proof.PoStProof
 }

 type DataSize struct {
@@ -926,12 +813,6 @@ type DataSize struct {
 	PieceSize   abi.PaddedPieceSize
 }

-type DataCIDSize struct {
-	PayloadSize int64
-	PieceSize   abi.PaddedPieceSize
-	PieceCID    cid.Cid
-}
-
 type CommPRet struct {
 	Root cid.Cid
 	Size abi.UnpaddedPieceSize
@@ -948,37 +829,7 @@ const (
 	MsigCancel
 )

-type Deadline struct {
-	PostSubmissions      bitfield.BitField
-	DisputableProofCount uint64
-}
-
-type Partition struct {
-	AllSectors        bitfield.BitField
-	FaultySectors     bitfield.BitField
-	RecoveringSectors bitfield.BitField
-	LiveSectors       bitfield.BitField
-	ActiveSectors     bitfield.BitField
-}
-
 type Fault struct {
 	Miner address.Address
 	Epoch abi.ChainEpoch
 }
-
-var EmptyVesting = MsigVesting{
-	InitialBalance: types.EmptyInt,
-	StartEpoch:     -1,
-	UnlockDuration: -1,
-}
-
-type MsigVesting struct {
-	InitialBalance abi.TokenAmount
-	StartEpoch     abi.ChainEpoch
-	UnlockDuration abi.ChainEpoch
-}
-
-type MessageMatch struct {
-	To   address.Address
-	From address.Address
-}
@@ -1,46 +0,0 @@
-package api
-
-import (
-	"context"
-
-	"github.com/ipfs/go-cid"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/go-state-types/dline"
-	"github.com/filecoin-project/go-state-types/network"
-
-	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
-	"github.com/filecoin-project/lotus/chain/types"
-)
-
-type GatewayAPI interface {
-	ChainHasObj(context.Context, cid.Cid) (bool, error)
-	ChainHead(ctx context.Context) (*types.TipSet, error)
-	ChainGetBlockMessages(context.Context, cid.Cid) (*BlockMessages, error)
-	ChainGetMessage(ctx context.Context, mc cid.Cid) (*types.Message, error)
-	ChainGetTipSet(ctx context.Context, tsk types.TipSetKey) (*types.TipSet, error)
-	ChainGetTipSetByHeight(ctx context.Context, h abi.ChainEpoch, tsk types.TipSetKey) (*types.TipSet, error)
-	ChainNotify(context.Context) (<-chan []*HeadChange, error)
-	ChainReadObj(context.Context, cid.Cid) ([]byte, error)
-	GasEstimateMessageGas(ctx context.Context, msg *types.Message, spec *MessageSendSpec, tsk types.TipSetKey) (*types.Message, error)
-	MpoolPush(ctx context.Context, sm *types.SignedMessage) (cid.Cid, error)
-	MsigGetAvailableBalance(ctx context.Context, addr address.Address, tsk types.TipSetKey) (types.BigInt, error)
-	MsigGetVested(ctx context.Context, addr address.Address, start types.TipSetKey, end types.TipSetKey) (types.BigInt, error)
-	StateAccountKey(ctx context.Context, addr address.Address, tsk types.TipSetKey) (address.Address, error)
-	StateDealProviderCollateralBounds(ctx context.Context, size abi.PaddedPieceSize, verified bool, tsk types.TipSetKey) (DealCollateralBounds, error)
-	StateGetActor(ctx context.Context, actor address.Address, ts types.TipSetKey) (*types.Actor, error)
-	StateGetReceipt(context.Context, cid.Cid, types.TipSetKey) (*types.MessageReceipt, error)
-	StateListMiners(ctx context.Context, tsk types.TipSetKey) ([]address.Address, error)
-	StateLookupID(ctx context.Context, addr address.Address, tsk types.TipSetKey) (address.Address, error)
-	StateMarketBalance(ctx context.Context, addr address.Address, tsk types.TipSetKey) (MarketBalance, error)
-	StateMarketStorageDeal(ctx context.Context, dealId abi.DealID, tsk types.TipSetKey) (*MarketDeal, error)
-	StateMinerInfo(ctx context.Context, actor address.Address, tsk types.TipSetKey) (miner.MinerInfo, error)
-	StateMinerProvingDeadline(ctx context.Context, addr address.Address, tsk types.TipSetKey) (*dline.Info, error)
-	StateMinerPower(context.Context, address.Address, types.TipSetKey) (*MinerPower, error)
-	StateNetworkVersion(context.Context, types.TipSetKey) (network.Version, error)
-	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,13 @@ import (
 	"context"
 	"time"

-	"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 +25,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 +37,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 +53,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)
@@ -84,18 +62,16 @@ type StorageMiner interface {

 	// WorkerConnect tells the node to connect to workers RPC
 	WorkerConnect(context.Context, string) error
-	WorkerStats(context.Context) (map[uuid.UUID]storiface.WorkerStats, error)
-	WorkerJobs(context.Context) (map[uuid.UUID][]storiface.WorkerJob, error)
-	storiface.WorkerReturn
+	WorkerStats(context.Context) (map[uint64]storiface.WorkerStats, error)
+	WorkerJobs(context.Context) (map[uint64][]storiface.WorkerJob, error)

 	// SealingSchedDiag dumps internal sealing scheduler state
-	SealingSchedDiag(ctx context.Context, doSched bool) (interface{}, error)
-	SealingAbort(ctx context.Context, call storiface.CallID) error
+	SealingSchedDiag(context.Context) (interface{}, error)

 	stores.SectorIndex

 	MarketImportDealData(ctx context.Context, propcid cid.Cid, path string) error
-	MarketListDeals(ctx context.Context) ([]MarketDeal, error)
+	MarketListDeals(ctx context.Context) ([]storagemarket.StorageDeal, error)
 	MarketListRetrievalDeals(ctx context.Context) ([]retrievalmarket.ProviderDealState, error)
 	MarketGetDealUpdates(ctx context.Context) (<-chan storagemarket.MinerDeal, error)
 	MarketListIncompleteDeals(ctx context.Context) ([]storagemarket.MinerDeal, error)
@@ -105,13 +81,9 @@ type StorageMiner interface {
 	MarketGetRetrievalAsk(ctx context.Context) (*retrievalmarket.Ask, error)
 	MarketListDataTransfers(ctx context.Context) ([]DataTransferChannel, error)
 	MarketDataTransferUpdates(ctx context.Context) (<-chan DataTransferChannel, error)
-	// MinerRestartDataTransfer attempts to restart a data transfer with the given transfer ID and other peer
-	MarketRestartDataTransfer(ctx context.Context, transferID datatransfer.TransferID, otherPeer peer.ID, isInitiator bool) error
-	// ClientCancelDataTransfer cancels a data transfer with the given transfer ID and other peer
-	MarketCancelDataTransfer(ctx context.Context, transferID datatransfer.TransferID, otherPeer peer.ID, isInitiator bool) error

 	DealsImportData(ctx context.Context, dealPropCid cid.Cid, file string) error
-	DealsList(ctx context.Context) ([]MarketDeal, error)
+	DealsList(ctx context.Context) ([]storagemarket.StorageDeal, error)
 	DealsConsiderOnlineStorageDeals(context.Context) (bool, error)
 	DealsSetConsiderOnlineStorageDeals(context.Context, bool) error
 	DealsConsiderOnlineRetrievalDeals(context.Context) (bool, error)
@@ -122,10 +94,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

@@ -133,14 +101,6 @@ type StorageMiner interface {
 	PiecesListCidInfos(ctx context.Context) ([]cid.Cid, error)
 	PiecesGetPieceInfo(ctx context.Context, pieceCid cid.Cid) (*piecestore.PieceInfo, error)
 	PiecesGetCIDInfo(ctx context.Context, payloadCid cid.Cid) (*piecestore.CIDInfo, error)
-
-	// CreateBackup creates node backup onder the specified file name. The
-	// method requires that the lotus-miner is running with the
-	// LOTUS_BACKUP_BASE_PATH environment variable set to some path, and that
-	// the path specified when calling CreateBackup is within the base path
-	CreateBackup(ctx context.Context, fpath string) error
-
-	CheckProvable(ctx context.Context, pp abi.RegisteredPoStProof, sectors []storage.SectorRef, expensive bool) (map[abi.SectorNumber]string, error)
 }

 type SealRes struct {
@@ -220,19 +180,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
-}
@@ -1,16 +1,12 @@
 package api

 import (
-	"encoding/json"
 	"os"
 	"os/exec"
 	"path/filepath"
-	"reflect"
 	"runtime"
 	"strings"
 	"testing"
-
-	"github.com/stretchr/testify/require"
 )

 func goCmd() string {
@@ -36,68 +32,3 @@ func TestDoesntDependOnFFI(t *testing.T) {
 		}
 	}
 }
-
-func TestReturnTypes(t *testing.T) {
-	errType := reflect.TypeOf(new(error)).Elem()
-	bareIface := reflect.TypeOf(new(interface{})).Elem()
-	jmarsh := reflect.TypeOf(new(json.Marshaler)).Elem()
-
-	tst := func(api interface{}) func(t *testing.T) {
-		return func(t *testing.T) {
-			ra := reflect.TypeOf(api).Elem()
-			for i := 0; i < ra.NumMethod(); i++ {
-				m := ra.Method(i)
-				switch m.Type.NumOut() {
-				case 1: // if 1 return value, it must be an error
-					require.Equal(t, errType, m.Type.Out(0), m.Name)
-
-				case 2: // if 2 return values, first cant be an interface/function, second must be an error
-					seen := map[reflect.Type]struct{}{}
-					todo := []reflect.Type{m.Type.Out(0)}
-					for len(todo) > 0 {
-						typ := todo[len(todo)-1]
-						todo = todo[:len(todo)-1]
-
-						if _, ok := seen[typ]; ok {
-							continue
-						}
-						seen[typ] = struct{}{}
-
-						if typ.Kind() == reflect.Interface && typ != bareIface && !typ.Implements(jmarsh) {
-							t.Error("methods can't return interfaces", m.Name)
-						}
-
-						switch typ.Kind() {
-						case reflect.Ptr:
-							fallthrough
-						case reflect.Array:
-							fallthrough
-						case reflect.Slice:
-							fallthrough
-						case reflect.Chan:
-							todo = append(todo, typ.Elem())
-						case reflect.Map:
-							todo = append(todo, typ.Elem())
-							todo = append(todo, typ.Key())
-						case reflect.Struct:
-							for i := 0; i < typ.NumField(); i++ {
-								todo = append(todo, typ.Field(i).Type)
-							}
-						}
-					}
-
-					require.NotEqual(t, reflect.Func.String(), m.Type.Out(0).Kind().String(), m.Name)
-					require.Equal(t, errType, m.Type.Out(1), m.Name)
-
-				default:
-					t.Error("methods can only have 1 or 2 return values", m.Name)
-				}
-			}
-		}
-	}
-
-	t.Run("common", tst(new(Common)))
-	t.Run("full", tst(new(FullNode)))
-	t.Run("miner", tst(new(StorageMiner)))
-	t.Run("worker", tst(new(WorkerAPI)))
-}
@@ -1,47 +0,0 @@
-package api
-
-import (
-	"context"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/crypto"
-
-	"github.com/filecoin-project/lotus/chain/types"
-)
-
-type MsgType string
-
-const (
-	MTUnknown = "unknown"
-
-	// Signing message CID. MsgMeta.Extra contains raw cbor message bytes
-	MTChainMsg = "message"
-
-	// Signing a blockheader. signing raw cbor block bytes (MsgMeta.Extra is empty)
-	MTBlock = "block"
-
-	// Signing a deal proposal. signing raw cbor proposal bytes (MsgMeta.Extra is empty)
-	MTDealProposal = "dealproposal"
-
-	// TODO: Deals, Vouchers, VRF
-)
-
-type MsgMeta struct {
-	Type MsgType
-
-	// Additional data related to what is signed. Should be verifiable with the
-	// signed bytes (e.g. CID(Extra).Bytes() == toSign)
-	Extra []byte
-}
-
-type WalletAPI interface {
-	WalletNew(context.Context, types.KeyType) (address.Address, error)
-	WalletHas(context.Context, address.Address) (bool, error)
-	WalletList(context.Context) ([]address.Address, error)
-
-	WalletSign(ctx context.Context, signer address.Address, toSign []byte, meta MsgMeta) (*crypto.Signature, error)
-
-	WalletExport(context.Context, address.Address) (*types.KeyInfo, error)
-	WalletImport(context.Context, *types.KeyInfo) (address.Address, error)
-	WalletDelete(context.Context, address.Address) error
-}
@@ -2,13 +2,15 @@ package api

 import (
 	"context"
+	"io"

-	"github.com/google/uuid"
+	"github.com/ipfs/go-cid"

 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/lotus/extern/sector-storage/sealtasks"
 	"github.com/filecoin-project/lotus/extern/sector-storage/stores"
 	"github.com/filecoin-project/lotus/extern/sector-storage/storiface"
+	"github.com/filecoin-project/specs-storage/storage"

 	"github.com/filecoin-project/lotus/build"
 )
@@ -21,29 +23,18 @@ type WorkerAPI interface {
 	Paths(context.Context) ([]stores.StoragePath, error)
 	Info(context.Context) (storiface.WorkerInfo, error)

-	storiface.WorkerCalls
+	AddPiece(ctx context.Context, sector abi.SectorID, pieceSizes []abi.UnpaddedPieceSize, newPieceSize abi.UnpaddedPieceSize, pieceData storage.Data) (abi.PieceInfo, error)

-	TaskDisable(ctx context.Context, tt sealtasks.TaskType) error
-	TaskEnable(ctx context.Context, tt sealtasks.TaskType) error
+	storage.Sealer

-	// Storage / Other
-	Remove(ctx context.Context, sector abi.SectorID) error
+	MoveStorage(ctx context.Context, sector abi.SectorID, types stores.SectorFileType) error
+
+	UnsealPiece(context.Context, abi.SectorID, storiface.UnpaddedByteIndex, abi.UnpaddedPieceSize, abi.SealRandomness, cid.Cid) error
+	ReadPiece(context.Context, io.Writer, abi.SectorID, storiface.UnpaddedByteIndex, abi.UnpaddedPieceSize) (bool, error)

 	StorageAddLocal(ctx context.Context, path string) error

-	// SetEnabled marks the worker as enabled/disabled. Not that this setting
-	// may take a few seconds to propagate to task scheduler
-	SetEnabled(ctx context.Context, enabled bool) error
+	Fetch(context.Context, abi.SectorID, stores.SectorFileType, stores.PathType, stores.AcquireMode) error

-	Enabled(ctx context.Context) (bool, error)
-
-	// WaitQuiet blocks until there are no tasks running
-	WaitQuiet(ctx context.Context) error
-
-	// returns a random UUID of worker session, generated randomly when worker
-	// process starts
-	ProcessSession(context.Context) (uuid.UUID, error)
-
-	// Like ProcessSession, but returns an error when worker is disabled
-	Session(context.Context) (uuid.UUID, error)
+	Closing(context.Context) (<-chan struct{}, error)
 }
@@ -36,9 +36,3 @@ func PermissionedWorkerAPI(a api.WorkerAPI) api.WorkerAPI {
 	auth.PermissionedProxy(AllPermissions, DefaultPerms, a, &out.Internal)
 	return &out
 }
-
-func PermissionedWalletAPI(a api.WalletAPI) api.WalletAPI {
-	var out WalletStruct
-	auth.PermissionedProxy(AllPermissions, DefaultPerms, a, &out.Internal)
-	return &out
-}
@@ -82,29 +82,3 @@ func NewWorkerRPC(ctx context.Context, addr string, requestHeader http.Header) (

 	return &res, closer, err
 }
-
-// NewGatewayRPC creates a new http jsonrpc client for a gateway node.
-func NewGatewayRPC(ctx context.Context, addr string, requestHeader http.Header, opts ...jsonrpc.Option) (api.GatewayAPI, jsonrpc.ClientCloser, error) {
-	var res apistruct.GatewayStruct
-	closer, err := jsonrpc.NewMergeClient(ctx, addr, "Filecoin",
-		[]interface{}{
-			&res.Internal,
-		},
-		requestHeader,
-		opts...,
-	)
-
-	return &res, closer, err
-}
-
-func NewWalletRPC(ctx context.Context, addr string, requestHeader http.Header) (api.WalletAPI, jsonrpc.ClientCloser, error) {
-	var res apistruct.WalletStruct
-	closer, err := jsonrpc.NewMergeClient(ctx, addr, "Filecoin",
-		[]interface{}{
-			&res.Internal,
-		},
-		requestHeader,
-	)
-
-	return &res, closer, err
-}
@@ -6,14 +6,12 @@ import (
 	"go/ast"
 	"go/parser"
 	"go/token"
-	"os"
 	"reflect"
 	"sort"
 	"strings"
 	"time"
 	"unicode"

-	"github.com/google/uuid"
 	"github.com/ipfs/go-cid"
 	"github.com/ipfs/go-filestore"
 	metrics "github.com/libp2p/go-libp2p-core/metrics"
@@ -26,7 +24,6 @@ import (
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-bitfield"
 	datatransfer "github.com/filecoin-project/go-data-transfer"
-	filestore2 "github.com/filecoin-project/go-fil-markets/filestore"
 	"github.com/filecoin-project/go-fil-markets/retrievalmarket"
 	"github.com/filecoin-project/go-jsonrpc/auth"
 	"github.com/filecoin-project/go-multistore"
@@ -39,10 +36,6 @@ import (
 	"github.com/filecoin-project/lotus/api/apistruct"
 	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain/types"
-	"github.com/filecoin-project/lotus/extern/sector-storage/sealtasks"
-	"github.com/filecoin-project/lotus/extern/sector-storage/stores"
-	"github.com/filecoin-project/lotus/extern/sector-storage/storiface"
-	sealing "github.com/filecoin-project/lotus/extern/storage-sealing"
 	"github.com/filecoin-project/lotus/node/modules/dtypes"
 )

@@ -90,11 +83,10 @@ 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)
-	addExample(types.KTBLS)
 	addExample(int64(9))
 	addExample(12.3)
 	addExample(123)
@@ -122,19 +114,18 @@ func init() {
 	addExample(retrievalmarket.ClientEventDealAccepted)
 	addExample(retrievalmarket.DealStatusNew)
 	addExample(network.ReachabilityPublic)
-	addExample(build.NewestNetworkVersion)
 	addExample(&types.ExecutionTrace{
-		Msg:    exampleValue("init", reflect.TypeOf(&types.Message{}), nil).(*types.Message),
-		MsgRct: exampleValue("init", reflect.TypeOf(&types.MessageReceipt{}), nil).(*types.MessageReceipt),
+		Msg:    exampleValue(reflect.TypeOf(&types.Message{}), nil).(*types.Message),
+		MsgRct: exampleValue(reflect.TypeOf(&types.MessageReceipt{}), nil).(*types.MessageReceipt),
 	})
 	addExample(map[string]types.Actor{
-		"t01236": exampleValue("init", reflect.TypeOf(types.Actor{}), nil).(types.Actor),
+		"t01236": exampleValue(reflect.TypeOf(types.Actor{}), nil).(types.Actor),
 	})
 	addExample(map[string]api.MarketDeal{
-		"t026363": exampleValue("init", reflect.TypeOf(api.MarketDeal{}), nil).(api.MarketDeal),
+		"t026363": exampleValue(reflect.TypeOf(api.MarketDeal{}), nil).(api.MarketDeal),
 	})
 	addExample(map[string]api.MarketBalance{
-		"t026363": exampleValue("init", reflect.TypeOf(api.MarketBalance{}), nil).(api.MarketBalance),
+		"t026363": exampleValue(reflect.TypeOf(api.MarketBalance{}), nil).(api.MarketBalance),
 	})
 	addExample(map[string]*pubsub.TopicScoreSnapshot{
 		"/blocks": {
@@ -169,89 +160,9 @@ func init() {
 	// because reflect.TypeOf(maddr) returns the concrete type...
 	ExampleValues[reflect.TypeOf(struct{ A multiaddr.Multiaddr }{}).Field(0).Type] = maddr

-	// miner specific
-	addExample(filestore2.Path(".lotusminer/fstmp123"))
-	si := multistore.StoreID(12)
-	addExample(&si)
-	addExample(retrievalmarket.DealID(5))
-	addExample(abi.ActorID(1000))
-	addExample(map[string][]api.SealedRef{
-		"98000": {
-			api.SealedRef{
-				SectorID: 100,
-				Offset:   10 << 20,
-				Size:     1 << 20,
-			},
-		},
-	})
-	addExample(api.SectorState(sealing.Proving))
-	addExample(stores.ID("76f1988b-ef30-4d7e-b3ec-9a627f4ba5a8"))
-	addExample(storiface.FTUnsealed)
-	addExample(storiface.PathSealing)
-	addExample(map[stores.ID][]stores.Decl{
-		"76f1988b-ef30-4d7e-b3ec-9a627f4ba5a8": {
-			{
-				SectorID:       abi.SectorID{Miner: 1000, Number: 100},
-				SectorFileType: storiface.FTSealed,
-			},
-		},
-	})
-	addExample(map[stores.ID]string{
-		"76f1988b-ef30-4d7e-b3ec-9a627f4ba5a8": "/data/path",
-	})
-	addExample(map[uuid.UUID][]storiface.WorkerJob{
-		uuid.MustParse("ef8d99a2-6865-4189-8ffa-9fef0f806eee"): {
-			{
-				ID: storiface.CallID{
-					Sector: abi.SectorID{Miner: 1000, Number: 100},
-					ID:     uuid.MustParse("76081ba0-61bd-45a5-bc08-af05f1c26e5d"),
-				},
-				Sector:   abi.SectorID{Miner: 1000, Number: 100},
-				Task:     sealtasks.TTPreCommit2,
-				RunWait:  0,
-				Start:    time.Unix(1605172927, 0).UTC(),
-				Hostname: "host",
-			},
-		},
-	})
-	addExample(map[uuid.UUID]storiface.WorkerStats{
-		uuid.MustParse("ef8d99a2-6865-4189-8ffa-9fef0f806eee"): {
-			Info: storiface.WorkerInfo{
-				Hostname: "host",
-				Resources: storiface.WorkerResources{
-					MemPhysical: 256 << 30,
-					MemSwap:     120 << 30,
-					MemReserved: 2 << 30,
-					CPUs:        64,
-					GPUs:        []string{"aGPU 1337"},
-				},
-			},
-			Enabled:    true,
-			MemUsedMin: 0,
-			MemUsedMax: 0,
-			GpuUsed:    false,
-			CpuUse:     0,
-		},
-	})
-	addExample(storiface.ErrorCode(0))
-	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)
-	addExample(storiface.UnpaddedByteIndex(abi.PaddedPieceSize(1 << 20).Unpadded()))
-	addExample(map[sealtasks.TaskType]struct{}{
-		sealtasks.TTPreCommit2: {},
-	})
-	addExample(sealtasks.TTCommit2)
 }

-func exampleValue(method string, t, parent reflect.Type) interface{} {
+func exampleValue(t, parent reflect.Type) interface{} {
 	v, ok := ExampleValues[t]
 	if ok {
 		return v
@@ -260,25 +171,25 @@ func exampleValue(method string, t, parent reflect.Type) interface{} {
 	switch t.Kind() {
 	case reflect.Slice:
 		out := reflect.New(t).Elem()
-		reflect.Append(out, reflect.ValueOf(exampleValue(method, t.Elem(), t)))
+		reflect.Append(out, reflect.ValueOf(exampleValue(t.Elem(), t)))
 		return out.Interface()
 	case reflect.Chan:
-		return exampleValue(method, t.Elem(), nil)
+		return exampleValue(t.Elem(), nil)
 	case reflect.Struct:
-		es := exampleStruct(method, t, parent)
+		es := exampleStruct(t, parent)
 		v := reflect.ValueOf(es).Elem().Interface()
 		ExampleValues[t] = v
 		return v
 	case reflect.Array:
 		out := reflect.New(t).Elem()
 		for i := 0; i < t.Len(); i++ {
-			out.Index(i).Set(reflect.ValueOf(exampleValue(method, t.Elem(), t)))
+			out.Index(i).Set(reflect.ValueOf(exampleValue(t.Elem(), t)))
 		}
 		return out.Interface()

 	case reflect.Ptr:
 		if t.Elem().Kind() == reflect.Struct {
-			es := exampleStruct(method, t.Elem(), t)
+			es := exampleStruct(t.Elem(), t)
 			//ExampleValues[t] = es
 			return es
 		}
@@ -286,10 +197,10 @@ func exampleValue(method string, t, parent reflect.Type) interface{} {
 		return struct{}{}
 	}

-	panic(fmt.Sprintf("No example value for type: %s (method '%s')", t, method))
+	panic(fmt.Sprintf("No example value for type: %s", t))
 }

-func exampleStruct(method string, t, parent reflect.Type) interface{} {
+func exampleStruct(t, parent reflect.Type) interface{} {
 	ns := reflect.New(t)
 	for i := 0; i < t.NumField(); i++ {
 		f := t.Field(i)
@@ -297,7 +208,7 @@ func exampleStruct(method string, t, parent reflect.Type) interface{} {
 			continue
 		}
 		if strings.Title(f.Name) == f.Name {
-			ns.Elem().Field(i).Set(reflect.ValueOf(exampleValue(method, f.Type, t)))
+			ns.Elem().Field(i).Set(reflect.ValueOf(exampleValue(f.Type, t)))
 		}
 	}

@@ -305,7 +216,6 @@ func exampleStruct(method string, t, parent reflect.Type) interface{} {
 }

 type Visitor struct {
-	Root    string
 	Methods map[string]ast.Node
 }

@@ -315,7 +225,7 @@ func (v *Visitor) Visit(node ast.Node) ast.Visitor {
 		return v
 	}

-	if st.Name.Name != v.Root {
+	if st.Name.Name != "FullNode" {
 		return nil
 	}

@@ -331,7 +241,7 @@ func (v *Visitor) Visit(node ast.Node) ast.Visitor {

 const noComment = "There are not yet any comments for this method."

-func parseApiASTInfo(apiFile, iface string) (map[string]string, map[string]string) { //nolint:golint
+func parseApiASTInfo() (map[string]string, map[string]string) { //nolint:golint
 	fset := token.NewFileSet()
 	pkgs, err := parser.ParseDir(fset, "./api", nil, parser.AllErrors|parser.ParseComments)
 	if err != nil {
@@ -340,11 +250,11 @@ func parseApiASTInfo(apiFile, iface string) (map[string]string, map[string]strin

 	ap := pkgs["api"]

-	f := ap.Files[apiFile]
+	f := ap.Files["api/api_full.go"]

 	cmap := ast.NewCommentMap(fset, f, f.Comments)

-	v := &Visitor{iface, make(map[string]ast.Node)}
+	v := &Visitor{make(map[string]ast.Node)}
 	ast.Walk(v, pkgs["api"])

 	groupDocs := make(map[string]string)
@@ -400,30 +310,13 @@ func methodGroupFromName(mn string) string {
 }

 func main() {
-	comments, groupComments := parseApiASTInfo(os.Args[1], os.Args[2])
+
+	comments, groupComments := parseApiASTInfo()

 	groups := make(map[string]*MethodGroup)

-	var t reflect.Type
-	var permStruct, commonPermStruct reflect.Type
-
-	switch os.Args[2] {
-	case "FullNode":
-		t = reflect.TypeOf(new(struct{ api.FullNode })).Elem()
-		permStruct = reflect.TypeOf(apistruct.FullNodeStruct{}.Internal)
-		commonPermStruct = reflect.TypeOf(apistruct.CommonStruct{}.Internal)
-	case "StorageMiner":
-		t = reflect.TypeOf(new(struct{ api.StorageMiner })).Elem()
-		permStruct = reflect.TypeOf(apistruct.StorageMinerStruct{}.Internal)
-		commonPermStruct = reflect.TypeOf(apistruct.CommonStruct{}.Internal)
-	case "WorkerAPI":
-		t = reflect.TypeOf(new(struct{ api.WorkerAPI })).Elem()
-		permStruct = reflect.TypeOf(apistruct.WorkerStruct{}.Internal)
-		commonPermStruct = reflect.TypeOf(apistruct.WorkerStruct{}.Internal)
-	default:
-		panic("unknown type")
-	}
-
+	var api struct{ api.FullNode }
+	t := reflect.TypeOf(api)
 	for i := 0; i < t.NumMethod(); i++ {
 		m := t.Method(i)

@@ -441,7 +334,7 @@ func main() {
 		ft := m.Func.Type()
 		for j := 2; j < ft.NumIn(); j++ {
 			inp := ft.In(j)
-			args = append(args, exampleValue(m.Name, inp, nil))
+			args = append(args, exampleValue(inp, nil))
 		}

 		v, err := json.MarshalIndent(args, "", "  ")
@@ -449,7 +342,7 @@ func main() {
 			panic(err)
 		}

-		outv := exampleValue(m.Name, ft.Out(0), nil)
+		outv := exampleValue(ft.Out(0), nil)

 		ov, err := json.MarshalIndent(outv, "", "  ")
 		if err != nil {
@@ -482,6 +375,9 @@ func main() {
 		}
 	}

+	permStruct := reflect.TypeOf(apistruct.FullNodeStruct{}.Internal)
+	commonPermStruct := reflect.TypeOf(apistruct.CommonStruct{}.Internal)
+
 	for _, g := range groupslice {
 		g := g
 		fmt.Printf("## %s\n", g.GroupName)
@@ -37,12 +37,7 @@ func (bm *BlockMiner) MineBlocks() {
 	go func() {
 		defer close(bm.done)
 		for atomic.LoadInt64(&bm.mine) == 1 {
-			select {
-			case <-bm.ctx.Done():
-				return
-			case <-time.After(bm.blocktime):
-			}
-
+			time.Sleep(bm.blocktime)
 			nulls := atomic.SwapInt64(&bm.nulls, 0)
 			if err := bm.miner.MineOne(bm.ctx, miner.MineReq{
 				InjectNulls: abi.ChainEpoch(nulls),
@@ -3,6 +3,7 @@ package test
 import (
 	"context"
 	"fmt"
+	"os"
 	"sync/atomic"
 	"testing"
 	"time"
@@ -16,22 +17,10 @@ import (
 )

 func TestCCUpgrade(t *testing.T, b APIBuilder, blocktime time.Duration) {
-	for _, height := range []abi.ChainEpoch{
-		2,    // before
-		162,  // while sealing
-		530,  // after upgrade deal
-		5000, // after
-	} {
-		height := height // make linters happy by copying
-		t.Run(fmt.Sprintf("upgrade-%d", height), func(t *testing.T) {
-			testCCUpgrade(t, b, blocktime, height)
-		})
-	}
-}
+	_ = os.Setenv("BELLMAN_NO_GPU", "1")

-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, 1, OneMiner)
 	client := n[0].FullNode.(*impl.FullNodeAPI)
 	miner := sn[0]

@@ -89,14 +78,13 @@ 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

 	{
 		exp, err := client.StateSectorExpiration(ctx, maddr, CC, types.EmptyTSK)
 		require.NoError(t, err)
-		require.NotNil(t, exp)
 		require.Greater(t, 50000, int(exp.OnTime))
 	}
 	{
@@ -105,22 +93,6 @@ func testCCUpgrade(t *testing.T, b APIBuilder, blocktime time.Duration, upgradeH
 		require.Less(t, 50000, int(exp.OnTime))
 	}

-	dlInfo, err := client.StateMinerProvingDeadline(ctx, maddr, types.EmptyTSK)
-	require.NoError(t, err)
-
-	// Sector should expire.
-	for {
-		// Wait for the sector to expire.
-		status, err := miner.SectorsStatus(ctx, CC, true)
-		require.NoError(t, err)
-		if status.OnTime == 0 && status.Early == 0 {
-			break
-		}
-		t.Log("waiting for sector to expire")
-		// wait one deadline per loop.
-		time.Sleep(time.Duration(dlInfo.WPoStChallengeWindow) * blocktime)
-	}
-
 	fmt.Println("shutting down mining")
 	atomic.AddInt64(&mine, -1)
 	<-done
@@ -8,52 +8,131 @@ 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"
+	logging "github.com/ipfs/go-log/v2"
 	"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"
+	"github.com/filecoin-project/lotus/miner"
 	dag "github.com/ipfs/go-merkledag"
 	dstest "github.com/ipfs/go-merkledag/test"
 	unixfile "github.com/ipfs/go-unixfs/file"
+
+	"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()
-
-	MakeDeal(t, s.ctx, 6, s.client, s.miner, carExport, fastRet, startEpoch)
+var MineNext = miner.MineReq{
+	InjectNulls: 0,
+	Done:        func(bool, abi.ChainEpoch, error) {},
 }

-func TestDoubleDealFlow(t *testing.T, b APIBuilder, blocktime time.Duration, startEpoch abi.ChainEpoch) {
-	s := setupOneClientOneMiner(t, b, blocktime)
-	defer s.blockMiner.Stop()
-
-	MakeDeal(t, s.ctx, 6, s.client, s.miner, false, false, startEpoch)
-	MakeDeal(t, s.ctx, 7, s.client, s.miner, false, false, startEpoch)
+func init() {
+	logging.SetAllLoggers(logging.LevelInfo)
+	build.InsecurePoStValidation = true
 }

-func MakeDeal(t *testing.T, ctx context.Context, rseed int, client api.FullNode, miner TestStorageNode, carExport, fastRet bool, startEpoch abi.ChainEpoch) {
-	res, data, err := CreateClientFile(ctx, client, rseed)
+func TestDealFlow(t *testing.T, b APIBuilder, blocktime time.Duration, carExport, fastRet bool) {
+	_ = os.Setenv("BELLMAN_NO_GPU", "1")
+
+	ctx := context.Background()
+	n, sn := b(t, 1, OneMiner)
+	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) {
+	_ = os.Setenv("BELLMAN_NO_GPU", "1")
+
+	ctx := context.Background()
+	n, sn := b(t, 1, 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 *impl.FullNodeAPI, miner TestStorageNode, carExport, fastRet bool) {
+	data := make([]byte, 1600)
+	rand.New(rand.NewSource(int64(rseed))).Read(data)
+
+	r := bytes.NewReader(data)
+	fcid, err := client.ClientImportLocal(ctx, r)
 	if err != nil {
 		t.Fatal(err)
 	}

-	fcid := res.Root
 	fmt.Println("FILE CID: ", fcid)

-	deal := startDeal(t, ctx, miner, client, fcid, fastRet, 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)
@@ -66,64 +145,98 @@ func MakeDeal(t *testing.T, ctx context.Context, rseed int, client api.FullNode,
 	testRetrieval(t, ctx, client, fcid, &info.PieceCID, carExport, data)
 }

-func CreateClientFile(ctx context.Context, client api.FullNode, rseed int) (*api.ImportRes, []byte, error) {
-	data := make([]byte, 1600)
-	rand.New(rand.NewSource(int64(rseed))).Read(data)
+func TestFastRetrievalDealFlow(t *testing.T, b APIBuilder, blocktime time.Duration) {
+	_ = os.Setenv("BELLMAN_NO_GPU", "1")

-	dir, err := ioutil.TempDir(os.TempDir(), "test-make-deal-")
+	ctx := context.Background()
+	n, sn := b(t, 1, OneMiner)
+	client := n[0].FullNode.(*impl.FullNodeAPI)
+	miner := sn[0]
+
+	addrinfo, err := client.NetAddrsListen(ctx)
 	if err != nil {
-		return nil, nil, err
+		t.Fatal(err)
 	}

-	path := filepath.Join(dir, "sourcefile.dat")
-	err = ioutil.WriteFile(path, data, 0644)
-	if err != nil {
-		return nil, nil, err
+	if err := miner.NetConnect(ctx, addrinfo); err != nil {
+		t.Fatal(err)
 	}
+	time.Sleep(time.Second)

-	res, err := client.ClientImport(ctx, api.FileRef{Path: path})
-	if err != nil {
-		return nil, nil, err
-	}
-	return res, data, nil
-}
-
-func TestFastRetrievalDealFlow(t *testing.T, b APIBuilder, blocktime time.Duration, startEpoch abi.ChainEpoch) {
-	s := setupOneClientOneMiner(t, b, blocktime)
-	defer s.blockMiner.Stop()
+	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) {
+	_ = os.Setenv("BELLMAN_NO_GPU", "1")
+
+	ctx := context.Background()
+	n, sn := b(t, 1, 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 +245,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 *impl.FullNodeAPI, fcid cid.Cid, fastRet bool) *cid.Cid {
 	maddr, err := miner.ActorAddress(ctx)
 	if err != nil {
 		t.Fatal(err)
@@ -177,7 +294,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,
 	})
@@ -187,7 +303,7 @@ func startDeal(t *testing.T, ctx context.Context, miner TestStorageNode, client
 	return deal
 }

-func waitDealSealed(t *testing.T, ctx context.Context, miner TestStorageNode, client api.FullNode, deal *cid.Cid, noseal bool) {
+func waitDealSealed(t *testing.T, ctx context.Context, miner TestStorageNode, client *impl.FullNodeAPI, deal *cid.Cid, noseal bool) {
 loop:
 	for {
 		di, err := client.ClientGetDealInfo(ctx, *deal)
@@ -195,7 +311,7 @@ loop:
 			t.Fatal(err)
 		}
 		switch di.State {
-		case storagemarket.StorageDealAwaitingPreCommit, storagemarket.StorageDealSealing:
+		case storagemarket.StorageDealSealing:
 			if noseal {
 				return
 			}
@@ -235,7 +351,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
 				}
@@ -260,7 +376,7 @@ func startSealingWaiting(t *testing.T, ctx context.Context, miner TestStorageNod
 	}
 }

-func testRetrieval(t *testing.T, ctx context.Context, client api.FullNode, fcid cid.Cid, piece *cid.Cid, carExport bool, data []byte) {
+func testRetrieval(t *testing.T, ctx context.Context, client *impl.FullNodeAPI, fcid cid.Cid, piece *cid.Cid, carExport bool, data []byte) {
 	offers, err := client.ClientFindData(ctx, fcid, piece)
 	if err != nil {
 		t.Fatal(err)
@@ -286,12 +402,9 @@ func testRetrieval(t *testing.T, ctx context.Context, client api.FullNode, fcid
 		IsCAR: carExport,
 	}
 	updates, err := client.ClientRetrieveWithEvents(ctx, offers[0].Order(caddr), ref)
-	if err != nil {
-		t.Fatal(err)
-	}
 	for update := range updates {
 		if update.Err != "" {
-			t.Fatalf("retrieval failed: %s", update.Err)
+			t.Fatalf("%v", err)
 		}
 	}

@@ -338,40 +451,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,
-	}
-}
@@ -5,6 +5,7 @@ import (
 	"context"
 	"fmt"
 	"math/rand"
+	"os"
 	"sync/atomic"
 	"testing"
 	"time"
@@ -24,7 +25,7 @@ var log = logging.Logger("apitest")

 func (ts *testSuite) testMining(t *testing.T) {
 	ctx := context.Background()
-	apis, sn := ts.makeNodes(t, OneFull, OneMiner)
+	apis, sn := ts.makeNodes(t, 1, OneMiner)
 	api := apis[0]

 	newHeads, err := api.ChainNotify(ctx)
@@ -53,16 +54,19 @@ func (ts *testSuite) testMiningReal(t *testing.T) {
 	}()

 	ctx := context.Background()
-	apis, sn := ts.makeNodes(t, OneFull, OneMiner)
+	apis, sn := ts.makeNodes(t, 1, OneMiner)
 	api := apis[0]

 	newHeads, err := api.ChainNotify(ctx)
 	require.NoError(t, err)
-	at := (<-newHeads)[0].Val.Height()
+	initHead := (<-newHeads)[0]
+	if initHead.Val.Height() != 2 {
+		<-newHeads
+	}

 	h1, err := api.ChainHead(ctx)
 	require.NoError(t, err)
-	require.Equal(t, int64(at), int64(h1.Height()))
+	require.Equal(t, abi.ChainEpoch(2), h1.Height())

 	MineUntilBlock(ctx, t, apis[0], sn[0], nil)
 	require.NoError(t, err)
@@ -71,23 +75,25 @@ func (ts *testSuite) testMiningReal(t *testing.T) {

 	h2, err := api.ChainHead(ctx)
 	require.NoError(t, err)
-	require.Greater(t, int64(h2.Height()), int64(h1.Height()))
+	require.Equal(t, abi.ChainEpoch(3), h2.Height())

 	MineUntilBlock(ctx, t, apis[0], sn[0], nil)
 	require.NoError(t, err)

 	<-newHeads

-	h3, err := api.ChainHead(ctx)
+	h2, err = api.ChainHead(ctx)
 	require.NoError(t, err)
-	require.Greater(t, int64(h3.Height()), int64(h2.Height()))
+	require.Equal(t, abi.ChainEpoch(4), h2.Height())
 }

 func TestDealMining(t *testing.T, b APIBuilder, blocktime time.Duration, carExport bool) {
+	_ = os.Setenv("BELLMAN_NO_GPU", "1")
+
 	// test making a deal with a fresh miner, and see if it starts to mine

 	ctx := context.Background()
-	n, sn := b(t, OneFull, []StorageMiner{
+	n, sn := b(t, 1, []StorageMiner{
 		{Full: 0, Preseal: PresealGenesis},
 		{Full: 0, Preseal: 0}, // TODO: Add support for miners on non-first full node
 	})
@@ -186,7 +192,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)
@@ -3,32 +3,33 @@ package test
 import (
 	"context"
 	"fmt"
+	"os"
 	"sync/atomic"
 	"testing"
 	"time"

+	"github.com/filecoin-project/specs-actors/actors/builtin"
+
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/big"
+	"github.com/filecoin-project/specs-actors/actors/builtin/paych"
 	"github.com/ipfs/go-cid"

 	"github.com/filecoin-project/go-address"
-	cbor "github.com/ipfs/go-ipld-cbor"

 	"github.com/filecoin-project/lotus/api"
-	"github.com/filecoin-project/lotus/api/apibstore"
 	"github.com/filecoin-project/lotus/build"
-	"github.com/filecoin-project/lotus/chain/actors/adt"
-	"github.com/filecoin-project/lotus/chain/actors/builtin"
-	"github.com/filecoin-project/lotus/chain/actors/builtin/paych"
-	"github.com/filecoin-project/lotus/chain/actors/policy"
 	"github.com/filecoin-project/lotus/chain/events"
 	"github.com/filecoin-project/lotus/chain/events/state"
 	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/chain/wallet"
 )

 func TestPaymentChannels(t *testing.T, b APIBuilder, blocktime time.Duration) {
+	_ = os.Setenv("BELLMAN_NO_GPU", "1")
+
 	ctx := context.Background()
-	n, sn := b(t, TwoFull, OneMiner)
+	n, sn := b(t, 2, OneMiner)

 	paymentCreator := n[0]
 	paymentReceiver := n[1]
@@ -53,7 +54,7 @@ func TestPaymentChannels(t *testing.T, b APIBuilder, blocktime time.Duration) {
 	bm.MineBlocks()

 	// send some funds to register the receiver
-	receiverAddr, err := paymentReceiver.WalletNew(ctx, types.KTSecp256k1)
+	receiverAddr, err := paymentReceiver.WalletNew(ctx, wallet.ActSigType("secp256k1"))
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -66,7 +67,7 @@ func TestPaymentChannels(t *testing.T, b APIBuilder, blocktime time.Duration) {
 		t.Fatal(err)
 	}

-	channelAmt := int64(7000)
+	channelAmt := int64(100000)
 	channelInfo, err := paymentCreator.PaychGet(ctx, createrAddr, receiverAddr, abi.NewTokenAmount(channelAmt))
 	if err != nil {
 		t.Fatal(err)
@@ -132,26 +133,17 @@ func TestPaymentChannels(t *testing.T, b APIBuilder, blocktime time.Duration) {
 		t.Fatal("Unable to settle payment channel")
 	}

-	creatorStore := adt.WrapStore(ctx, cbor.NewCborStore(apibstore.NewAPIBlockstore(paymentCreator)))
-
 	// wait for the receiver to submit their vouchers
 	ev := events.NewEvents(ctx, paymentCreator)
 	preds := state.NewStatePredicates(paymentCreator)
 	finished := make(chan struct{})
 	err = ev.StateChanged(func(ts *types.TipSet) (done bool, more bool, err error) {
-		act, err := paymentCreator.StateGetActor(ctx, channel, ts.Key())
+		act, err := paymentCreator.StateReadState(ctx, channel, ts.Key())
 		if err != nil {
 			return false, false, err
 		}
-		state, err := paych.Load(creatorStore, act)
-		if err != nil {
-			return false, false, err
-		}
-		toSend, err := state.ToSend()
-		if err != nil {
-			return false, false, err
-		}
-		if toSend.GreaterThanEqual(abi.NewTokenAmount(6000)) {
+		state := act.State.(paych.State)
+		if state.ToSend.GreaterThanEqual(abi.NewTokenAmount(6000)) {
 			return true, false, nil
 		}
 		return false, true, nil
@@ -164,7 +156,7 @@ func TestPaymentChannels(t *testing.T, b APIBuilder, blocktime time.Duration) {
 		return true, nil
 	}, func(ctx context.Context, ts *types.TipSet) error {
 		return nil
-	}, int(build.MessageConfidence)+1, build.Finality, func(oldTs, newTs *types.TipSet) (bool, events.StateChange, error) {
+	}, int(build.MessageConfidence)+1, build.SealRandomnessLookbackLimit, func(oldTs, newTs *types.TipSet) (bool, events.StateChange, error) {
 		return preds.OnPaymentChannelActorChanged(channel, preds.OnToSendAmountChanges())(ctx, oldTs.Key(), newTs.Key())
 	})
 	if err != nil {
@@ -177,53 +169,8 @@ func TestPaymentChannels(t *testing.T, b APIBuilder, blocktime time.Duration) {
 		t.Fatal("Timed out waiting for receiver to submit vouchers")
 	}

-	// Create a new voucher now that some vouchers have already been submitted
-	vouchRes, err := paymentCreator.PaychVoucherCreate(ctx, channel, abi.NewTokenAmount(1000), 3)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if vouchRes.Voucher == nil {
-		t.Fatal(fmt.Errorf("Not enough funds to create voucher: missing %d", vouchRes.Shortfall))
-	}
-	vdelta, err := paymentReceiver.PaychVoucherAdd(ctx, channel, vouchRes.Voucher, nil, abi.NewTokenAmount(1000))
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !vdelta.Equals(abi.NewTokenAmount(1000)) {
-		t.Fatal("voucher didn't have the right amount")
-	}
-
-	// Create a new voucher whose value would exceed the channel balance
-	excessAmt := abi.NewTokenAmount(1000)
-	vouchRes, err = paymentCreator.PaychVoucherCreate(ctx, channel, excessAmt, 4)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if vouchRes.Voucher != nil {
-		t.Fatal("Expected not to be able to create voucher whose value would exceed channel balance")
-	}
-	if !vouchRes.Shortfall.Equals(excessAmt) {
-		t.Fatal(fmt.Errorf("Expected voucher shortfall of %d, got %d", excessAmt, vouchRes.Shortfall))
-	}
-
-	// Add a voucher whose value would exceed the channel balance
-	vouch := &paych.SignedVoucher{ChannelAddr: channel, Amount: excessAmt, Lane: 4, Nonce: 1}
-	vb, err := vouch.SigningBytes()
-	if err != nil {
-		t.Fatal(err)
-	}
-	sig, err := paymentCreator.WalletSign(ctx, createrAddr, vb)
-	if err != nil {
-		t.Fatal(err)
-	}
-	vouch.Signature = sig
-	_, err = paymentReceiver.PaychVoucherAdd(ctx, channel, vouch, nil, abi.NewTokenAmount(1000))
-	if err == nil {
-		t.Fatal(fmt.Errorf("Expected shortfall error of %d", excessAmt))
-	}
-
 	// wait for the settlement period to pass before collecting
-	waitForBlocks(ctx, t, bm, paymentReceiver, receiverAddr, policy.PaychSettleDelay)
+	waitForBlocks(ctx, t, bm, paymentReceiver, receiverAddr, paych.SettleDelay)

 	creatorPreCollectBalance, err := paymentCreator.WalletBalance(ctx, createrAddr)
 	if err != nil {
@@ -1,114 +0,0 @@
-package test
-
-import (
-	"context"
-	"fmt"
-	"testing"
-	"time"
-
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/go-state-types/network"
-	"github.com/filecoin-project/lotus/api"
-	"github.com/filecoin-project/lotus/build"
-	"github.com/filecoin-project/lotus/chain/stmgr"
-	sealing "github.com/filecoin-project/lotus/extern/storage-sealing"
-	"github.com/filecoin-project/lotus/node"
-	"github.com/filecoin-project/lotus/node/impl"
-	"github.com/stretchr/testify/require"
-)
-
-func TestTapeFix(t *testing.T, b APIBuilder, blocktime time.Duration) {
-	t.Run("before", func(t *testing.T) { testTapeFix(t, b, blocktime, false) })
-	t.Run("after", func(t *testing.T) { testTapeFix(t, b, blocktime, true) })
-}
-func testTapeFix(t *testing.T, b APIBuilder, blocktime time.Duration, after bool) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	upgradeSchedule := stmgr.UpgradeSchedule{{
-		Network:   build.ActorUpgradeNetworkVersion,
-		Height:    1,
-		Migration: stmgr.UpgradeActorsV2,
-	}}
-	if after {
-		upgradeSchedule = append(upgradeSchedule, stmgr.Upgrade{
-			Network: network.Version5,
-			Height:  2,
-		})
-	}
-
-	n, sn := b(t, []FullNodeOpts{{Opts: func(_ []TestNode) node.Option {
-		return node.Override(new(stmgr.UpgradeSchedule), upgradeSchedule)
-	}}}, OneMiner)
-
-	client := n[0].FullNode.(*impl.FullNodeAPI)
-	miner := sn[0]
-
-	addrinfo, err := client.NetAddrsListen(ctx)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if err := miner.NetConnect(ctx, addrinfo); err != nil {
-		t.Fatal(err)
-	}
-	build.Clock.Sleep(time.Second)
-
-	done := make(chan struct{})
-	go func() {
-		defer close(done)
-		for ctx.Err() == nil {
-			build.Clock.Sleep(blocktime)
-			if err := sn[0].MineOne(ctx, MineNext); err != nil {
-				if ctx.Err() != nil {
-					// context was canceled, ignore the error.
-					return
-				}
-				t.Error(err)
-			}
-		}
-	}()
-	defer func() {
-		cancel()
-		<-done
-	}()
-
-	err = miner.PledgeSector(ctx)
-	require.NoError(t, err)
-
-	// Wait till done.
-	var sectorNo abi.SectorNumber
-	for {
-		s, err := miner.SectorsList(ctx) // Note - the test builder doesn't import genesis sectors into FSM
-		require.NoError(t, err)
-		fmt.Printf("Sectors: %d\n", len(s))
-		if len(s) == 1 {
-			sectorNo = s[0]
-			break
-		}
-
-		build.Clock.Sleep(100 * time.Millisecond)
-	}
-
-	fmt.Printf("All sectors is fsm\n")
-
-	// If before, we expect the precommit to fail
-	successState := api.SectorState(sealing.CommitFailed)
-	failureState := api.SectorState(sealing.Proving)
-	if after {
-		// otherwise, it should succeed.
-		successState, failureState = failureState, successState
-	}
-
-	for {
-		st, err := miner.SectorsStatus(ctx, sectorNo, false)
-		require.NoError(t, err)
-		if st.State == successState {
-			break
-		}
-		require.NotEqual(t, failureState, st.State)
-		build.Clock.Sleep(100 * time.Millisecond)
-		fmt.Println("WaitSeal")
-	}
-
-}
@@ -2,39 +2,18 @@ package test

 import (
 	"context"
-	"fmt"
-	"os"
-	"strings"
 	"testing"
-	"time"

-	"github.com/filecoin-project/lotus/chain/stmgr"
-	"github.com/filecoin-project/lotus/chain/types"
-
-	logging "github.com/ipfs/go-log/v2"
 	"github.com/multiformats/go-multiaddr"

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

-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/go-state-types/big"
-	"github.com/filecoin-project/go-state-types/network"
 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/miner"
-	"github.com/filecoin-project/lotus/node"
 )

-func init() {
-	logging.SetAllLoggers(logging.LevelInfo)
-	err := os.Setenv("BELLMAN_NO_GPU", "1")
-	if err != nil {
-		panic(fmt.Sprintf("failed to set BELLMAN_NO_GPU env variable: %s", err))
-	}
-	build.InsecurePoStValidation = true
-}
-
 type TestNode struct {
 	api.FullNode
 	// ListenAddr is the address on which an API server is listening, if an
@@ -49,34 +28,23 @@ type TestStorageNode struct {
 	ListenAddr multiaddr.Multiaddr

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

 var PresealGenesis = -1

 const GenesisPreseals = 2

-// Options for setting up a mock storage miner
 type StorageMiner struct {
 	Full    int
 	Preseal int
 }

-type OptionGenerator func([]TestNode) node.Option
-
-// Options for setting up a mock full node
-type FullNodeOpts struct {
-	Lite bool            // run node in "lite" mode
-	Opts OptionGenerator // generate dependency injection options
-}
-
 // APIBuilder is a function which is invoked in test suite to provide
 // test nodes and networks
 //
-// fullOpts array defines options for each full node
 // storage array defines storage nodes, numbers in the array specify full node
 // index the storage node 'belongs' to
-type APIBuilder func(t *testing.T, full []FullNodeOpts, storage []StorageMiner) ([]TestNode, []TestStorageNode)
+type APIBuilder func(t *testing.T, nFull int, storage []StorageMiner) ([]TestNode, []TestStorageNode)
 type testSuite struct {
 	makeNodes APIBuilder
 }
@@ -92,131 +60,27 @@ func TestApis(t *testing.T, b APIBuilder) {
 	t.Run("testConnectTwo", ts.testConnectTwo)
 	t.Run("testMining", ts.testMining)
 	t.Run("testMiningReal", ts.testMiningReal)
-	t.Run("testSearchMsg", ts.testSearchMsg)
-}
-
-func DefaultFullOpts(nFull int) []FullNodeOpts {
-	full := make([]FullNodeOpts, nFull)
-	for i := range full {
-		full[i] = FullNodeOpts{
-			Opts: func(nodes []TestNode) node.Option {
-				return node.Options()
-			},
-		}
-	}
-	return full
 }

 var OneMiner = []StorageMiner{{Full: 0, Preseal: PresealGenesis}}
-var OneFull = DefaultFullOpts(1)
-var TwoFull = DefaultFullOpts(2)
-
-var FullNodeWithActorsV3At = 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,
-				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,
-			}})
-		},
-	}
-}
-
-var MineNext = miner.MineReq{
-	InjectNulls: 0,
-	Done:        func(bool, abi.ChainEpoch, error) {},
-}

 func (ts *testSuite) testVersion(t *testing.T) {
 	build.RunningNodeType = build.NodeFull

 	ctx := context.Background()
-	apis, _ := ts.makeNodes(t, OneFull, OneMiner)
+	apis, _ := ts.makeNodes(t, 1, OneMiner)
 	api := apis[0]

 	v, err := api.Version(ctx)
 	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)
-}
-
-func (ts *testSuite) testSearchMsg(t *testing.T) {
-	apis, miners := ts.makeNodes(t, OneFull, OneMiner)
-
-	api := apis[0]
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	senderAddr, err := api.WalletDefaultAddress(ctx)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	msg := &types.Message{
-		From:  senderAddr,
-		To:    senderAddr,
-		Value: big.Zero(),
-	}
-	bm := NewBlockMiner(ctx, t, miners[0], 100*time.Millisecond)
-	bm.MineBlocks()
-	defer bm.Stop()
-
-	sm, err := api.MpoolPushMessage(ctx, msg, nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-	res, err := api.StateWaitMsg(ctx, sm.Cid(), 1)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if res.Receipt.ExitCode != 0 {
-		t.Fatal("did not successfully send message")
-	}
-
-	searchRes, err := api.StateSearchMsg(ctx, sm.Cid())
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if searchRes.TipSet != res.TipSet {
-		t.Fatalf("search ts: %s, different from wait ts: %s", searchRes.TipSet, res.TipSet)
-	}
-
+	require.Equal(t, v.Version, build.BuildVersion)
 }

 func (ts *testSuite) testID(t *testing.T) {
 	ctx := context.Background()
-	apis, _ := ts.makeNodes(t, OneFull, OneMiner)
+	apis, _ := ts.makeNodes(t, 1, OneMiner)
 	api := apis[0]

 	id, err := api.ID(ctx)
@@ -228,7 +92,7 @@ func (ts *testSuite) testID(t *testing.T) {

 func (ts *testSuite) testConnectTwo(t *testing.T) {
 	ctx := context.Background()
-	apis, _ := ts.makeNodes(t, TwoFull, OneMiner)
+	apis, _ := ts.makeNodes(t, 2, OneMiner)

 	p, err := apis[0].NetPeers(ctx)
 	if err != nil {
@@ -3,125 +3,37 @@ package test
 import (
 	"context"
 	"fmt"
-	"sort"
-	"sync/atomic"

+	"os"
 	"strings"
 	"testing"
 	"time"

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

 	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-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"
+	miner2 "github.com/filecoin-project/specs-actors/actors/builtin/miner"

 	"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)
+func init() {
+	err := os.Setenv("BELLMAN_NO_GPU", "1")
 	if err != nil {
-		t.Fatal(err)
+		panic(fmt.Sprintf("failed to set BELLMAN_NO_GPU env variable: %s", 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()
-
-	n, sn := b(t, OneFull, OneMiner)
+	ctx := context.Background()
+	n, sn := b(t, 1, OneMiner)
 	client := n[0].FullNode.(*impl.FullNodeAPI)
 	miner := sn[0]

@@ -135,11 +47,11 @@ func TestPledgeSector(t *testing.T, b APIBuilder, blocktime time.Duration, nSect
 	}
 	build.Clock.Sleep(time.Second)

-	mine := int64(1)
+	mine := true
 	done := make(chan struct{})
 	go func() {
 		defer close(done)
-		for atomic.LoadInt64(&mine) != 0 {
+		for mine {
 			build.Clock.Sleep(blocktime)
 			if err := sn[0].MineOne(ctx, bminer.MineReq{Done: func(bool, abi.ChainEpoch, error) {

@@ -151,19 +63,17 @@ func TestPledgeSector(t *testing.T, b APIBuilder, blocktime time.Duration, nSect

 	pledgeSectors(t, ctx, miner, nSectors, 0, nil)

-	atomic.StoreInt64(&mine, 0)
+	mine = false
 	<-done
 }

 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 {
@@ -205,26 +115,8 @@ 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
-		162,  // while sealing
-		5000, // while proving
-	} {
-		height := height // copy to satisfy lints
-		t.Run(fmt.Sprintf("upgrade-%d", height), func(t *testing.T) {
-			testWindowPostUpgrade(t, b, blocktime, nSectors, height)
-		})
-	}
-
-}
-
-func testWindowPostUpgrade(t *testing.T, b APIBuilder, blocktime time.Duration, nSectors int,
-	upgradeHeight abi.ChainEpoch) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	n, sn := b(t, []FullNodeOpts{FullNodeWithActorsV3At(upgradeHeight)}, OneMiner)
-
+	ctx := context.Background()
+	n, sn := b(t, 1, OneMiner)
 	client := n[0].FullNode.(*impl.FullNodeAPI)
 	miner := sn[0]

@@ -238,24 +130,17 @@ func testWindowPostUpgrade(t *testing.T, b APIBuilder, blocktime time.Duration,
 	}
 	build.Clock.Sleep(time.Second)

+	mine := true
 	done := make(chan struct{})
 	go func() {
 		defer close(done)
-		for ctx.Err() == nil {
+		for mine {
 			build.Clock.Sleep(blocktime)
 			if err := sn[0].MineOne(ctx, MineNext); err != nil {
-				if ctx.Err() != nil {
-					// context was canceled, ignore the error.
-					return
-				}
 				t.Error(err)
 			}
 		}
 	}()
-	defer func() {
-		cancel()
-		<-done
-	}()

 	pledgeSectors(t, ctx, miner, nSectors, 0, nil)

@@ -269,16 +154,18 @@ func testWindowPostUpgrade(t *testing.T, b APIBuilder, blocktime time.Duration,
 	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())
+		if head.Height() > di.PeriodStart+(miner2.WPoStProvingPeriod)+2 {
 			break
 		}
+
+		if head.Height()%100 == 0 {
+			fmt.Printf("@%d\n", head.Height())
+		}
 		build.Clock.Sleep(blocktime)
 	}

@@ -299,24 +186,21 @@ func testWindowPostUpgrade(t *testing.T, b APIBuilder, blocktime time.Duration,
 		require.NoError(t, err)
 		require.Greater(t, len(parts), 0)

-		secs := parts[0].AllSectors
-		n, err := secs.Count()
+		n, err := parts[0].Sectors.Count()
 		require.NoError(t, err)
 		require.Equal(t, uint64(2), n)

 		// Drop the partition
-		err = secs.ForEach(func(sid uint64) error {
-			return miner.StorageMiner.(*impl.StorageMinerAPI).IStorageMgr.(*mock.SectorMgr).MarkCorrupted(storage.SectorRef{
-				ID: abi.SectorID{
-					Miner:  abi.ActorID(mid),
-					Number: abi.SectorNumber(sid),
-				},
+		err = parts[0].Sectors.ForEach(func(sid uint64) error {
+			return miner.StorageMiner.(*impl.StorageMinerAPI).IStorageMgr.(*mock.SectorMgr).MarkFailed(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
 	{
@@ -324,24 +208,21 @@ func testWindowPostUpgrade(t *testing.T, b APIBuilder, blocktime time.Duration,
 		require.NoError(t, err)
 		require.Greater(t, len(parts), 0)

-		secs := parts[0].AllSectors
-		n, err := secs.Count()
+		n, err := parts[0].Sectors.Count()
 		require.NoError(t, err)
 		require.Equal(t, uint64(2), n)

 		// Drop the sector
-		sn, err := secs.First()
+		sn, err := parts[0].Sectors.First()
 		require.NoError(t, err)

-		all, err := secs.All(2)
+		all, err := parts[0].Sectors.All(2)
 		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)
@@ -352,17 +233,18 @@ func testWindowPostUpgrade(t *testing.T, b APIBuilder, blocktime time.Duration,
 	require.NoError(t, err)

 	fmt.Printf("Go through another PP, wait for sectors to become faulty\n")
-	fmt.Printf("End for head.Height > %d\n", di.PeriodStart+di.WPoStProvingPeriod+2)

 	for {
 		head, err := client.ChainHead(ctx)
 		require.NoError(t, err)

-		if head.Height() > di.PeriodStart+(di.WPoStProvingPeriod)+2 {
-			fmt.Printf("Now head.Height = %d\n", head.Height())
+		if head.Height() > di.PeriodStart+(miner2.WPoStProvingPeriod)+2 {
 			break
 		}

+		if head.Height()%100 == 0 {
+			fmt.Printf("@%d\n", head.Height())
+		}
 		build.Clock.Sleep(blocktime)
 	}

@@ -382,17 +264,17 @@ func testWindowPostUpgrade(t *testing.T, b APIBuilder, blocktime time.Duration,
 	di, err = client.StateMinerProvingDeadline(ctx, maddr, types.EmptyTSK)
 	require.NoError(t, err)

-	fmt.Printf("End for head.Height > %d\n", di.PeriodStart+di.WPoStProvingPeriod+2)
-
 	for {
 		head, err := client.ChainHead(ctx)
 		require.NoError(t, err)

-		if head.Height() > di.PeriodStart+di.WPoStProvingPeriod+2 {
-			fmt.Printf("Now head.Height = %d\n", head.Height())
+		if head.Height() > di.PeriodStart+(miner2.WPoStProvingPeriod)+2 {
 			break
 		}

+		if head.Height()%100 == 0 {
+			fmt.Printf("@%d\n", head.Height())
+		}
 		build.Clock.Sleep(blocktime)
 	}

@@ -409,19 +291,18 @@ func testWindowPostUpgrade(t *testing.T, b APIBuilder, blocktime time.Duration,
 	pledgeSectors(t, ctx, miner, 1, nSectors, nil)

 	{
-		// Wait until proven.
-		di, err = client.StateMinerProvingDeadline(ctx, maddr, types.EmptyTSK)
+		// wait a bit more
+
+		head, err := client.ChainHead(ctx)
 		require.NoError(t, err)

-		waitUntil := di.PeriodStart + di.WPoStProvingPeriod + 2
-		fmt.Printf("End for head.Height > %d\n", waitUntil)
+		waitUntil := head.Height() + 10

 		for {
 			head, err := client.ChainHead(ctx)
 			require.NoError(t, err)

 			if head.Height() > waitUntil {
-				fmt.Printf("Now head.Height = %d\n", head.Height())
 				break
 			}
 		}
@@ -434,593 +315,7 @@ 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)")
-	}
+	mine = false
+	<-done
 }
@@ -4,8 +4,11 @@ import (
 	"encoding/json"
 	"fmt"

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

 	"github.com/libp2p/go-libp2p-core/peer"
@@ -46,10 +49,65 @@ type PubsubScore struct {
 	Score *pubsub.PeerScoreSnapshot
 }

+type MinerInfo struct {
+	Owner                      address.Address   // Must be an ID-address.
+	Worker                     address.Address   // Must be an ID-address.
+	NewWorker                  address.Address   // Must be an ID-address.
+	ControlAddresses           []address.Address // Must be an ID-addresses.
+	WorkerChangeEpoch          abi.ChainEpoch
+	PeerId                     *peer.ID
+	Multiaddrs                 []abi.Multiaddrs
+	SealProofType              abi.RegisteredSealProof
+	SectorSize                 abi.SectorSize
+	WindowPoStPartitionSectors uint64
+}
+
+func NewApiMinerInfo(info *miner.MinerInfo) MinerInfo {
+	var pid *peer.ID
+	if peerID, err := peer.IDFromBytes(info.PeerId); err == nil {
+		pid = &peerID
+	}
+
+	mi := MinerInfo{
+		Owner:            info.Owner,
+		Worker:           info.Worker,
+		ControlAddresses: info.ControlAddresses,
+
+		NewWorker:         address.Undef,
+		WorkerChangeEpoch: -1,
+
+		PeerId:                     pid,
+		Multiaddrs:                 info.Multiaddrs,
+		SealProofType:              info.SealProofType,
+		SectorSize:                 info.SectorSize,
+		WindowPoStPartitionSectors: info.WindowPoStPartitionSectors,
+	}
+
+	if info.PendingWorkerKey != nil {
+		mi.NewWorker = info.PendingWorkerKey.NewWorker
+		mi.WorkerChangeEpoch = info.PendingWorkerKey.EffectiveAt
+	}
+
+	return mi
+}
+
 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 +151,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
 }
@@ -0,0 +1,4 @@
+/dns4/bootstrap-0.nerpa.interplanetary.dev/tcp/1347/p2p/12D3KooWH18xUp3ywhrxdt1NKPKdKJN9PUUoWVvghf7SHig7tabB
+/dns4/bootstrap-1.nerpa.interplanetary.dev/tcp/1347/p2p/12D3KooWPPYqe8dNkcvqDbdFUZkq6FAgjUYgZ5UCb8JEXVpvYpeW
+/dns4/bootstrap-2.nerpa.interplanetary.dev/tcp/1347/p2p/12D3KooWANTw75WxNzbM699kNPSjoV7P9T82nX5Mk9cb2Phxx7U1
+/dns4/bootstrap-3.nerpa.interplanetary.dev/tcp/1347/p2p/12D3KooWBxkzgLoqiXrNaCcHf3NW3LCrQfwp41GVK288cric8MvC
@@ -1,4 +0,0 @@
-/dns4/bootstrap-0.calibration.fildev.network/tcp/1347/p2p/12D3KooWK1QYsm6iqyhgH7vqsbeoNoKHbT368h1JLHS1qYN36oyc
-/dns4/bootstrap-1.calibration.fildev.network/tcp/1347/p2p/12D3KooWKDyJZoPsNak1iYNN1GGmvGnvhyVbWBL6iusYfP3RpgYs
-/dns4/bootstrap-2.calibration.fildev.network/tcp/1347/p2p/12D3KooWJRSTnzABB6MYYEBbSTT52phQntVD1PpRTMh1xt9mh6yH
-/dns4/bootstrap-3.calibration.fildev.network/tcp/1347/p2p/12D3KooWQLi3kY6HnMYLUtwCe26zWMdNhniFgHVNn1DioQc7NiWv
@@ -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
@@ -35,7 +35,6 @@ var DrandConfigs = map[DrandEnum]dtypes.DrandConfig{
 			"https://api.drand.sh",
 			"https://api2.drand.sh",
 			"https://api3.drand.sh",
-			"https://drand.cloudflare.com",
 		},
 		Relays: []string{
 			"/dnsaddr/api.drand.sh/",
@@ -69,6 +68,16 @@ var DrandConfigs = map[DrandEnum]dtypes.DrandConfig{
 		ChainInfoJSON: `{"public_key":"8cda589f88914aa728fd183f383980b35789ce81b274e5daee1f338b77d02566ef4d3fb0098af1f844f10f9c803c1827","period":25,"genesis_time":1595348225,"hash":"e73b7dc3c4f6a236378220c0dd6aa110eb16eed26c11259606e07ee122838d4f","groupHash":"567d4785122a5a3e75a9bc9911d7ea807dd85ff76b78dc4ff06b075712898607"}`,
 	},
 	DrandIncentinet: {
+		Servers: []string{
+			"https://pl-eu.incentinet.drand.sh",
+			"https://pl-us.incentinet.drand.sh",
+			"https://pl-sin.incentinet.drand.sh",
+		},
+		Relays: []string{
+			"/dnsaddr/pl-eu.incentinet.drand.sh/",
+			"/dnsaddr/pl-us.incentinet.drand.sh/",
+			"/dnsaddr/pl-sin.incentinet.drand.sh/",
+		},
 		ChainInfoJSON: `{"public_key":"8cad0c72c606ab27d36ee06de1d5b2db1faf92e447025ca37575ab3a8aac2eaae83192f846fc9e158bc738423753d000","period":30,"genesis_time":1595873820,"hash":"80c8b872c714f4c00fdd3daa465d5514049f457f01f85a4caf68cdcd394ba039","groupHash":"d9406aaed487f7af71851b4399448e311f2328923d454e971536c05398ce2d9b"}`,
 	},
 }
@@ -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
-}
@@ -4,44 +4,32 @@ package build

 import (
 	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/lotus/chain/actors/policy"
+	"github.com/filecoin-project/go-state-types/big"
+	"github.com/filecoin-project/specs-actors/actors/builtin/miner"
+	"github.com/filecoin-project/specs-actors/actors/builtin/power"
+	"github.com/filecoin-project/specs-actors/actors/builtin/verifreg"
 )

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

 const UpgradeSmokeHeight = -1
-const UpgradeIgnitionHeight = -2
-const UpgradeRefuelHeight = -3
-const UpgradeTapeHeight = -4
-
-const UpgradeActorsV2Height = 10
-const UpgradeLiftoffHeight = -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,
 }

 func init() {
-	policy.SetSupportedProofTypes(abi.RegisteredSealProof_StackedDrg2KiBV1)
-	policy.SetConsensusMinerMinPower(abi.NewStoragePower(2048))
-	policy.SetMinVerifiedDealSize(abi.NewStoragePower(256))
+	power.ConsensusMinerMinPower = big.NewInt(2048)
+	miner.SupportedProofTypes = map[abi.RegisteredSealProof]struct{}{
+		abi.RegisteredSealProof_StackedDrg2KiBV1: {},
+	}
+	verifreg.MinVerifiedDealSize = big.NewInt(256)

 	BuildType |= Build2k
 }

-const BlockDelaySecs = uint64(4)
+const BlockDelaySecs = uint64(30)

 const PropagationDelaySecs = uint64(1)

@@ -53,5 +41,3 @@ const SlashablePowerDelay = 20

 // Epochs
 const InteractivePoRepConfidence = 6
-
-const BootstrapPeerThreshold = 1
@@ -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-28T03:00:00Z
-const UpgradeActorsV3Height = 280426
-
-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,73 +0,0 @@
-// +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"
-	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
-)
-
-var DrandSchedule = map[abi.ChainEpoch]DrandEnum{
-	0:                  DrandIncentinet,
-	UpgradeSmokeHeight: DrandMainnet,
-}
-
-const BootstrappersFile = "mainnet.pi"
-const GenesisFile = "mainnet.car"
-
-const UpgradeBreezeHeight = 41280
-
-const BreezeGasTampingDuration = 120
-
-const UpgradeSmokeHeight = 51000
-
-const UpgradeIgnitionHeight = 94000
-const UpgradeRefuelHeight = 130800
-
-const UpgradeActorsV2Height = 138720
-
-const UpgradeTapeHeight = 140760
-
-// This signals our tentative epoch for mainnet launch. Can make it later, but not earlier.
-// Miners, clients, developers, custodians all need time to prepare.
-// We still have upgrades and state changes to do, but can happen after signaling timing here.
-const UpgradeLiftoffHeight = 148888
-
-const UpgradeKumquatHeight = 170000
-
-const UpgradeCalicoHeight = 265200
-const UpgradePersianHeight = UpgradeCalicoHeight + (builtin2.EpochsInHour * 60)
-
-const UpgradeOrangeHeight = 336458
-
-// 2020-12-22T02:00:00Z
-const UpgradeClausHeight = 343200
-
-// TODO
-const UpgradeActorsV3Height = 999999999
-
-func init() {
-	policy.SetConsensusMinerMinPower(abi.NewStoragePower(10 << 40))
-
-	if os.Getenv("LOTUS_USE_TEST_ADDRESSES") != "1" {
-		SetAddressNetwork(address.Mainnet)
-	}
-
-	Devnet = false
-
-	BuildType = BuildMainnet
-}
-
-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,34 @@
 package build

 import (
-	"github.com/filecoin-project/go-address"
+	"sort"

 	"github.com/libp2p/go-libp2p-core/protocol"

+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/specs-actors/actors/builtin/miner"
+
 	"github.com/filecoin-project/lotus/node/modules/dtypes"
 )

+func DefaultSectorSize() abi.SectorSize {
+	szs := make([]abi.SectorSize, 0, len(miner.SupportedProofTypes))
+	for spt := range miner.SupportedProofTypes {
+		ss, err := spt.SectorSize()
+		if err != nil {
+			panic(err)
+		}
+
+		szs = append(szs, ss)
+	}
+
+	sort.Slice(szs, func(i, j int) bool {
+		return szs[i] < szs[j]
+	})
+
+	return szs[0]
+}
+
 // Core network constants

 func BlocksTopic(netName dtypes.NetworkName) string   { return "/fil/blocks/" + string(netName) }
@@ -16,15 +37,10 @@ func DhtProtocolName(netName dtypes.NetworkName) protocol.ID {
 	return protocol.ID("/fil/kad/" + string(netName))
 }

-func SetAddressNetwork(n address.Network) {
-	address.CurrentNetwork = n
-}
-
-func MustParseAddress(addr string) address.Address {
-	ret, err := address.NewFromString(addr)
-	if err != nil {
-		panic(err)
+func UseNewestNetwork() bool {
+	// TODO: Put these in a container we can iterate over
+	if UpgradeBreezeHeight <= 0 && UpgradeSmokeHeight <= 0 {
+		return true
 	}
-
-	return ret
+	return false
 }
@@ -4,15 +4,12 @@ package build

 import (
 	"math/big"
-	"os"

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

-	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
-
-	"github.com/filecoin-project/lotus/chain/actors/policy"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/specs-actors/actors/builtin"
+	"github.com/filecoin-project/specs-actors/actors/builtin/miner"
 )

 // /////
@@ -25,17 +22,16 @@ const UnixfsLinksPerLevel = 1024
 // Consensus / Network

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

 // Epochs
 const ForkLengthThreshold = Finality

 // Blocks (e)
-var BlocksPerEpoch = uint64(builtin2.ExpectedLeadersPerEpoch)
+var BlocksPerEpoch = uint64(builtin.ExpectedLeadersPerEpoch)

 // Epochs
-const Finality = policy.ChainFinality
+const Finality = miner.ChainFinality
 const MessageConfidence = uint64(5)

 // constants for Weight calculation
@@ -47,8 +43,13 @@ const WRatioDen = uint64(2)
 // Proofs

 // Epochs
-// TODO: unused
-const SealRandomnessLookback = policy.SealRandomnessLookback
+const SealRandomnessLookback = Finality
+
+// Epochs
+const SealRandomnessLookbackLimit = SealRandomnessLookback + 2000 // TODO: Get from spec specs-actors
+
+// Maximum lookback that randomness can be sourced from for a seal proof submission
+const MaxSealLookback = SealRandomnessLookbackLimit + 2000 // TODO: Get from specs-actors

 // /////
 // Mining
@@ -56,40 +57,23 @@ const SealRandomnessLookback = policy.SealRandomnessLookback
 // Epochs
 const TicketRandomnessLookback = abi.ChainEpoch(1)

-// /////
-// Address
-
-const AddressMainnetEnvVar = "_mainnet_"
-
-// the 'f' prefix doesn't matter
-var ZeroAddress = MustParseAddress("f3yaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaby2smx7a")
+const WinningPoStSectorSetLookback = abi.ChainEpoch(10)

 // /////
 // Devnet settings

-var Devnet = true
-
 const FilBase = uint64(2_000_000_000)
 const FilAllocStorageMining = uint64(1_100_000_000)

 const FilecoinPrecision = uint64(1_000_000_000_000_000_000)
-const FilReserved = uint64(300_000_000)

 var InitialRewardBalance *big.Int
-var InitialFilReserved *big.Int

 // TODO: Move other important consts here

 func init() {
 	InitialRewardBalance = big.NewInt(int64(FilAllocStorageMining))
 	InitialRewardBalance = InitialRewardBalance.Mul(InitialRewardBalance, big.NewInt(int64(FilecoinPrecision)))
-
-	InitialFilReserved = big.NewInt(int64(FilReserved))
-	InitialFilReserved = InitialFilReserved.Mul(InitialFilReserved, big.NewInt(int64(FilecoinPrecision)))
-
-	if os.Getenv("LOTUS_ADDRESS_TYPE") == AddressMainnetEnvVar {
-		SetAddressNetwork(address.Mainnet)
-	}
 }

 // Sync
@@ -119,4 +103,4 @@ const PackingEfficiencyDenom = 5

 // Actor consts
 // TODO: Pull from actors when its made not private
-var MinDealDuration = abi.ChainEpoch(180 * builtin2.EpochsInDay)
+var MinDealDuration = abi.ChainEpoch(180 * builtin.EpochsInDay)
@@ -12,29 +12,27 @@ import (

 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/network"
-
-	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
-
-	"github.com/filecoin-project/lotus/chain/actors/policy"
+	"github.com/filecoin-project/specs-actors/actors/builtin"
+	"github.com/filecoin-project/specs-actors/actors/builtin/miner"
 )

 var (
 	UnixfsChunkSize     = uint64(1 << 20)
 	UnixfsLinksPerLevel = 1024

-	BlocksPerEpoch        = uint64(builtin2.ExpectedLeadersPerEpoch)
+	BlocksPerEpoch        = uint64(builtin.ExpectedLeadersPerEpoch)
 	BlockMessageLimit     = 512
 	BlockGasLimit         = int64(100_000_000_000)
 	BlockGasTarget        = int64(BlockGasLimit / 2)
 	BaseFeeMaxChangeDenom = int64(8) // 12.5%
 	InitialBaseFee        = int64(100e6)
 	MinimumBaseFee        = int64(100)
-	BlockDelaySecs        = uint64(builtin2.EpochDurationSeconds)
+	BlockDelaySecs        = uint64(builtin.EpochDurationSeconds)
 	PropagationDelaySecs  = uint64(6)

 	AllowableClockDriftSecs = uint64(1)

-	Finality            = policy.ChainFinality
+	Finality            = miner.ChainFinality
 	ForkLengthThreshold = Finality

 	SlashablePowerDelay        = 20
@@ -49,13 +47,15 @@ var (
 	BlsSignatureCacheSize = 40000
 	VerifSigCacheSize     = 32000

-	SealRandomnessLookback = policy.SealRandomnessLookback
+	SealRandomnessLookback      = Finality
+	SealRandomnessLookbackLimit = SealRandomnessLookback + 2000
+	MaxSealLookback             = SealRandomnessLookbackLimit + 2000

-	TicketRandomnessLookback = abi.ChainEpoch(1)
+	TicketRandomnessLookback     = abi.ChainEpoch(1)
+	WinningPoStSectorSetLookback = abi.ChainEpoch(10)

 	FilBase               uint64 = 2_000_000_000
 	FilAllocStorageMining uint64 = 1_400_000_000
-	FilReserved           uint64 = 300_000_000

 	FilecoinPrecision uint64 = 1_000_000_000_000_000_000

@@ -64,16 +64,9 @@ var (
 		v = v.Mul(v, big.NewInt(int64(FilecoinPrecision)))
 		return v
 	}()
-
-	InitialFilReserved = func() *big.Int {
-		v := big.NewInt(int64(FilReserved))
-		v = v.Mul(v, big.NewInt(int64(FilecoinPrecision)))
-		return v
-	}()
-
 	// Actor consts
 	// TODO: Pull from actors when its made not private
-	MinDealDuration = abi.ChainEpoch(180 * builtin2.EpochsInDay)
+	MinDealDuration = abi.ChainEpoch(180 * builtin.EpochsInDay)

 	PackingEfficiencyNum   int64 = 4
 	PackingEfficiencyDenom int64 = 5
@@ -81,31 +74,11 @@ var (
 	UpgradeBreezeHeight      abi.ChainEpoch = -1
 	BreezeGasTampingDuration abi.ChainEpoch = 0

-	UpgradeSmokeHeight    abi.ChainEpoch = -1
-	UpgradeIgnitionHeight abi.ChainEpoch = -2
-	UpgradeRefuelHeight   abi.ChainEpoch = -3
-	UpgradeTapeHeight     abi.ChainEpoch = -4
-	UpgradeActorsV2Height abi.ChainEpoch = 10
-	UpgradeLiftoffHeight  abi.ChainEpoch = -5
-	UpgradeKumquatHeight  abi.ChainEpoch = -6
-	UpgradeCalicoHeight   abi.ChainEpoch = -7
-	UpgradePersianHeight  abi.ChainEpoch = -8
-	UpgradeOrangeHeight   abi.ChainEpoch = -9
-	UpgradeClausHeight    abi.ChainEpoch = -10
-	UpgradeActorsV3Height abi.ChainEpoch = -11
+	UpgradeSmokeHeight abi.ChainEpoch = -1

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

-	NewestNetworkVersion       = network.Version9
-	ActorUpgradeNetworkVersion = network.Version4
-
-	Devnet      = true
-	ZeroAddress = MustParseAddress("f3yaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaby2smx7a")
-
-	BootstrappersFile = ""
-	GenesisFile       = ""
+	NewestNetworkVersion = network.Version2
 )
-
-const BootstrapPeerThreshold = 1
@@ -0,0 +1,42 @@
+// +build !debug
+// +build !2k
+// +build !testground
+
+package build
+
+import (
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/big"
+	"github.com/filecoin-project/specs-actors/actors/builtin"
+	"github.com/filecoin-project/specs-actors/actors/builtin/miner"
+	"github.com/filecoin-project/specs-actors/actors/builtin/power"
+)
+
+var DrandSchedule = map[abi.ChainEpoch]DrandEnum{
+	0: DrandMainnet,
+}
+
+const UpgradeBreezeHeight = -1
+const BreezeGasTampingDuration = 120
+
+const UpgradeSmokeHeight = -1
+
+func init() {
+	// Minimum block production power is set to 4 TiB
+	// Rationale is to discourage small-scale miners from trying to take over the network
+	// One needs to invest in ~2.3x the compute to break consensus, making it not worth it
+	//
+	// DOWNSIDE: the fake-seals need to be kept alive/protected, otherwise network will seize
+	//
+	power.ConsensusMinerMinPower = big.NewInt(4 << 40)
+	miner.SupportedProofTypes = map[abi.RegisteredSealProof]struct{}{
+		abi.RegisteredSealProof_StackedDrg512MiBV1: {},
+		abi.RegisteredSealProof_StackedDrg32GiBV1:  {},
+		abi.RegisteredSealProof_StackedDrg64GiBV1:  {},
+	}
+	miner.PreCommitChallengeDelay = abi.ChainEpoch(10)
+}
+
+const BlockDelaySecs = uint64(builtin.EpochDurationSeconds)
+
+const PropagationDelaySecs = uint64(6)
@@ -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 = "0.7.0"

 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, 14, 0)
+	MinerAPIVersion  = newVer(0, 14, 0)
+	WorkerAPIVersion = newVer(0, 14, 0)
 )

 //nolint:varcheck,deadcode
@@ -1,29 +0,0 @@
-package adt
-
-import (
-	"github.com/ipfs/go-cid"
-
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/go-state-types/cbor"
-)
-
-type Map interface {
-	Root() (cid.Cid, error)
-
-	Put(k abi.Keyer, v cbor.Marshaler) error
-	Get(k abi.Keyer, v cbor.Unmarshaler) (bool, error)
-	Delete(k abi.Keyer) error
-
-	ForEach(v cbor.Unmarshaler, fn func(key string) error) error
-}
-
-type Array interface {
-	Root() (cid.Cid, error)
-
-	Set(idx uint64, v cbor.Marshaler) error
-	Get(idx uint64, v cbor.Unmarshaler) (bool, error)
-	Delete(idx uint64) error
-	Length() uint64
-
-	ForEach(v cbor.Unmarshaler, fn func(idx int64) error) error
-}
@@ -1,17 +0,0 @@
-package adt
-
-import (
-	"context"
-
-	adt "github.com/filecoin-project/specs-actors/actors/util/adt"
-	cbor "github.com/ipfs/go-ipld-cbor"
-)
-
-type Store interface {
-	Context() context.Context
-	cbor.IpldStore
-}
-
-func WrapStore(ctx context.Context, store cbor.IpldStore) Store {
-	return adt.WrapStore(ctx, store)
-}
@@ -1,29 +0,0 @@
-# Actors
-
-This package contains shims for abstracting over different actor versions.
-
-## Design
-
-Shims in this package follow a few common design principles.
-
-### Structure Agnostic
-
-Shims interfaces defined in this package should (ideally) not change even if the
-structure of the underlying data changes. For example:
-
-* All shims store an internal "store" object. That way, state can be moved into
-  a separate object without needing to add a store to the function signature.
-* All functions must return an error, even if unused for now.
-
-### Minimal
-
-These interfaces should be expanded only as necessary to reduce maintenance burden.
-
-### Queries, not field assessors.
-
-When possible, functions should query the state instead of simply acting as
-field assessors. These queries are more likely to remain stable across
-specs-actor upgrades than specific state fields.
-
-Note: there is a trade-off here. Avoid implementing _complicated_ query logic
-inside these shims, as it will need to be replicated in every shim.
@@ -1,49 +0,0 @@
-package account
-
-import (
-	"golang.org/x/xerrors"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/cbor"
-	"github.com/ipfs/go-cid"
-
-	"github.com/filecoin-project/lotus/chain/actors/adt"
-	"github.com/filecoin-project/lotus/chain/actors/builtin"
-	"github.com/filecoin-project/lotus/chain/types"
-
-	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
-	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
-	builtin3 "github.com/filecoin-project/specs-actors/v3/actors/builtin"
-)
-
-func init() {
-	builtin.RegisterActorState(builtin0.AccountActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
-		return load0(store, root)
-	})
-	builtin.RegisterActorState(builtin2.AccountActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
-		return load2(store, root)
-	})
-	builtin.RegisterActorState(builtin3.AccountActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
-		return load3(store, root)
-	})
-}
-
-var Methods = builtin3.MethodsAccount
-
-func Load(store adt.Store, act *types.Actor) (State, error) {
-	switch act.Code {
-	case builtin0.AccountActorCodeID:
-		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)
-}
-
-type State interface {
-	cbor.Marshaler
-
-	PubkeyAddress() (address.Address, error)
-}
@@ -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"
-
-	account0 "github.com/filecoin-project/specs-actors/actors/builtin/account"
-)
-
-var _ State = (*state0)(nil)
-
-func load0(store adt.Store, root cid.Cid) (State, error) {
-	out := state0{store: store}
-	err := store.Get(store.Context(), root, &out)
-	if err != nil {
-		return nil, err
-	}
-	return &out, nil
-}
-
-type state0 struct {
-	account0.State
-	store adt.Store
-}
-
-func (s *state0) PubkeyAddress() (address.Address, error) {
-	return s.Address, nil
-}
@@ -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"
-
-	account2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/account"
-)
-
-var _ State = (*state2)(nil)
-
-func load2(store adt.Store, root cid.Cid) (State, error) {
-	out := state2{store: store}
-	err := store.Get(store.Context(), root, &out)
-	if err != nil {
-		return nil, err
-	}
-	return &out, nil
-}
-
-type state2 struct {
-	account2.State
-	store adt.Store
-}
-
-func (s *state2) PubkeyAddress() (address.Address, error) {
-	return s.Address, nil
-}
@@ -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
-}
@@ -1,138 +0,0 @@
-package builtin
-
-import (
-	"github.com/filecoin-project/go-address"
-	"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"
-
-	"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"
-)
-
-var SystemActorAddr = builtin0.SystemActorAddr
-var BurntFundsActorAddr = builtin0.BurntFundsActorAddr
-var CronActorAddr = builtin0.CronActorAddr
-var SaftAddress = makeAddress("t0122")
-var ReserveAddress = makeAddress("t090")
-var RootVerifierAddress = makeAddress("t080")
-
-var (
-	ExpectedLeadersPerEpoch = builtin0.ExpectedLeadersPerEpoch
-)
-
-const (
-	EpochDurationSeconds = builtin0.EpochDurationSeconds
-	EpochsInDay          = builtin0.EpochsInDay
-	SecondsInDay         = builtin0.SecondsInDay
-)
-
-const (
-	MethodSend        = builtin3.MethodSend
-	MethodConstructor = builtin3.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.
-type SectorInfo = proof0.SectorInfo
-type PoStProof = proof0.PoStProof
-type FilterEstimate = smoothing0.FilterEstimate
-
-func FromV0FilterEstimate(v0 smoothing0.FilterEstimate) FilterEstimate {
-	return (FilterEstimate)(v0)
-}
-
-// Doesn't change between actors v0, v2, and v3.
-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)
-}
-
-type ActorStateLoader func(store adt.Store, root cid.Cid) (cbor.Marshaler, error)
-
-var ActorStateLoaders = make(map[cid.Cid]ActorStateLoader)
-
-func RegisterActorState(code cid.Cid, loader ActorStateLoader) {
-	ActorStateLoaders[code] = loader
-}
-
-func Load(store adt.Store, act *types.Actor) (cbor.Marshaler, error) {
-	loader, found := ActorStateLoaders[act.Code]
-	if !found {
-		return nil, xerrors.Errorf("unknown actor code %s", act.Code)
-	}
-	return loader(store, act.Head)
-}
-
-func ActorNameByCode(c cid.Cid) string {
-	switch {
-	case builtin0.IsBuiltinActor(c):
-		return builtin0.ActorNameByCode(c)
-	case builtin2.IsBuiltinActor(c):
-		return builtin2.ActorNameByCode(c)
-	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)
-}
-
-func IsAccountActor(c cid.Cid) bool {
-	return c == builtin0.AccountActorCodeID ||
-		c == builtin2.AccountActorCodeID ||
-		c == builtin3.AccountActorCodeID
-}
-
-func IsStorageMinerActor(c cid.Cid) bool {
-	return c == builtin0.StorageMinerActorCodeID ||
-		c == builtin2.StorageMinerActorCodeID ||
-		c == builtin3.StorageMinerActorCodeID
-}
-
-func IsMultisigActor(c cid.Cid) bool {
-	return c == builtin0.MultisigActorCodeID ||
-		c == builtin2.MultisigActorCodeID ||
-		c == builtin3.MultisigActorCodeID
-
-}
-
-func IsPaymentChannelActor(c cid.Cid) bool {
-	return c == builtin0.PaymentChannelActorCodeID ||
-		c == builtin2.PaymentChannelActorCodeID ||
-		c == builtin3.PaymentChannelActorCodeID
-}
-
-func makeAddress(addr string) address.Address {
-	ret, err := address.NewFromString(addr)
-	if err != nil {
-		panic(err)
-	}
-
-	return ret
-}
@@ -1,10 +0,0 @@
-package cron
-
-import (
-	builtin3 "github.com/filecoin-project/specs-actors/v3/actors/builtin"
-)
-
-var (
-	Address = builtin3.CronActorAddr
-	Methods = builtin3.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
-}
@@ -1,68 +0,0 @@
-package init
-
-import (
-	"golang.org/x/xerrors"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/go-state-types/cbor"
-	"github.com/ipfs/go-cid"
-
-	"github.com/filecoin-project/lotus/chain/actors/adt"
-	"github.com/filecoin-project/lotus/chain/actors/builtin"
-	"github.com/filecoin-project/lotus/chain/types"
-	"github.com/filecoin-project/lotus/node/modules/dtypes"
-
-	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
-	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
-	builtin3 "github.com/filecoin-project/specs-actors/v3/actors/builtin"
-)
-
-func init() {
-	builtin.RegisterActorState(builtin0.InitActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
-		return load0(store, root)
-	})
-	builtin.RegisterActorState(builtin2.InitActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
-		return load2(store, root)
-	})
-	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
-)
-
-func Load(store adt.Store, act *types.Actor) (State, error) {
-	switch act.Code {
-	case builtin0.InitActorCodeID:
-		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)
-}
-
-type State interface {
-	cbor.Marshaler
-
-	ResolveAddress(address address.Address) (address.Address, bool, error)
-	MapAddressToNewID(address address.Address) (address.Address, error)
-	NetworkName() (dtypes.NetworkName, error)
-
-	ForEachActor(func(id abi.ActorID, address address.Address) error) error
-
-	// Remove exists to support tooling that manipulates state for testing.
-	// It should not be used in production code, as init actor entries are
-	// immutable.
-	Remove(addrs ...address.Address) error
-
-	// Sets the network's name. This should only be used on upgrade/fork.
-	SetNetworkName(name string) error
-
-	addressMap() (adt.Map, error)
-}
@@ -1,85 +0,0 @@
-package init
-
-import (
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/ipfs/go-cid"
-	cbg "github.com/whyrusleeping/cbor-gen"
-	"golang.org/x/xerrors"
-
-	"github.com/filecoin-project/lotus/chain/actors/adt"
-	"github.com/filecoin-project/lotus/node/modules/dtypes"
-
-	init0 "github.com/filecoin-project/specs-actors/actors/builtin/init"
-	adt0 "github.com/filecoin-project/specs-actors/actors/util/adt"
-)
-
-var _ State = (*state0)(nil)
-
-func load0(store adt.Store, root cid.Cid) (State, error) {
-	out := state0{store: store}
-	err := store.Get(store.Context(), root, &out)
-	if err != nil {
-		return nil, err
-	}
-	return &out, nil
-}
-
-type state0 struct {
-	init0.State
-	store adt.Store
-}
-
-func (s *state0) ResolveAddress(address address.Address) (address.Address, bool, error) {
-	return s.State.ResolveAddress(s.store, address)
-}
-
-func (s *state0) MapAddressToNewID(address address.Address) (address.Address, error) {
-	return s.State.MapAddressToNewID(s.store, address)
-}
-
-func (s *state0) ForEachActor(cb func(id abi.ActorID, address address.Address) error) error {
-	addrs, err := adt0.AsMap(s.store, s.State.AddressMap)
-	if err != nil {
-		return err
-	}
-	var actorID cbg.CborInt
-	return addrs.ForEach(&actorID, func(key string) error {
-		addr, err := address.NewFromBytes([]byte(key))
-		if err != nil {
-			return err
-		}
-		return cb(abi.ActorID(actorID), addr)
-	})
-}
-
-func (s *state0) NetworkName() (dtypes.NetworkName, error) {
-	return dtypes.NetworkName(s.State.NetworkName), nil
-}
-
-func (s *state0) SetNetworkName(name string) error {
-	s.State.NetworkName = name
-	return nil
-}
-
-func (s *state0) Remove(addrs ...address.Address) (err error) {
-	m, err := adt0.AsMap(s.store, s.State.AddressMap)
-	if err != nil {
-		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 *state0) addressMap() (adt.Map, error) {
-	return adt0.AsMap(s.store, s.AddressMap)
-}
@@ -1,85 +0,0 @@
-package init
-
-import (
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/ipfs/go-cid"
-	cbg "github.com/whyrusleeping/cbor-gen"
-	"golang.org/x/xerrors"
-
-	"github.com/filecoin-project/lotus/chain/actors/adt"
-	"github.com/filecoin-project/lotus/node/modules/dtypes"
-
-	init2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/init"
-	adt2 "github.com/filecoin-project/specs-actors/v2/actors/util/adt"
-)
-
-var _ State = (*state2)(nil)
-
-func load2(store adt.Store, root cid.Cid) (State, error) {
-	out := state2{store: store}
-	err := store.Get(store.Context(), root, &out)
-	if err != nil {
-		return nil, err
-	}
-	return &out, nil
-}
-
-type state2 struct {
-	init2.State
-	store adt.Store
-}
-
-func (s *state2) ResolveAddress(address address.Address) (address.Address, bool, error) {
-	return s.State.ResolveAddress(s.store, address)
-}
-
-func (s *state2) MapAddressToNewID(address address.Address) (address.Address, error) {
-	return s.State.MapAddressToNewID(s.store, address)
-}
-
-func (s *state2) ForEachActor(cb func(id abi.ActorID, address address.Address) error) error {
-	addrs, err := adt2.AsMap(s.store, s.State.AddressMap)
-	if err != nil {
-		return err
-	}
-	var actorID cbg.CborInt
-	return addrs.ForEach(&actorID, func(key string) error {
-		addr, err := address.NewFromBytes([]byte(key))
-		if err != nil {
-			return err
-		}
-		return cb(abi.ActorID(actorID), addr)
-	})
-}
-
-func (s *state2) NetworkName() (dtypes.NetworkName, error) {
-	return dtypes.NetworkName(s.State.NetworkName), nil
-}
-
-func (s *state2) SetNetworkName(name string) error {
-	s.State.NetworkName = name
-	return nil
-}
-
-func (s *state2) Remove(addrs ...address.Address) (err error) {
-	m, err := adt2.AsMap(s.store, s.State.AddressMap)
-	if err != nil {
-		return err
-	}
-	for _, addr := range addrs {
-		if err = m.Delete(abi.AddrKey(addr)); err != nil {
-			return xerrors.Errorf("failed to delete entry for address: %s; err: %w", addr, err)
-		}
-	}
-	amr, err := m.Root()
-	if err != nil {
-		return xerrors.Errorf("failed to get address map root: %w", err)
-	}
-	s.State.AddressMap = amr
-	return nil
-}
-
-func (s *state2) addressMap() (adt.Map, error) {
-	return adt2.AsMap(s.store, s.AddressMap)
-}
@@ -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)
-}
@@ -1,91 +0,0 @@
-package market
-
-import (
-	"fmt"
-
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/lotus/chain/actors/adt"
-	cbg "github.com/whyrusleeping/cbor-gen"
-)
-
-func DiffDealProposals(pre, cur DealProposals) (*DealProposalChanges, error) {
-	results := new(DealProposalChanges)
-	if err := adt.DiffAdtArray(pre.array(), cur.array(), &marketProposalsDiffer{results, pre, cur}); err != nil {
-		return nil, fmt.Errorf("diffing deal states: %w", err)
-	}
-	return results, nil
-}
-
-type marketProposalsDiffer struct {
-	Results  *DealProposalChanges
-	pre, cur DealProposals
-}
-
-func (d *marketProposalsDiffer) Add(key uint64, val *cbg.Deferred) error {
-	dp, err := d.cur.decode(val)
-	if err != nil {
-		return err
-	}
-	d.Results.Added = append(d.Results.Added, ProposalIDState{abi.DealID(key), *dp})
-	return nil
-}
-
-func (d *marketProposalsDiffer) Modify(key uint64, from, to *cbg.Deferred) error {
-	// short circuit, DealProposals are static
-	return nil
-}
-
-func (d *marketProposalsDiffer) Remove(key uint64, val *cbg.Deferred) error {
-	dp, err := d.pre.decode(val)
-	if err != nil {
-		return err
-	}
-	d.Results.Removed = append(d.Results.Removed, ProposalIDState{abi.DealID(key), *dp})
-	return nil
-}
-
-func DiffDealStates(pre, cur DealStates) (*DealStateChanges, error) {
-	results := new(DealStateChanges)
-	if err := adt.DiffAdtArray(pre.array(), cur.array(), &marketStatesDiffer{results, pre, cur}); err != nil {
-		return nil, fmt.Errorf("diffing deal states: %w", err)
-	}
-	return results, nil
-}
-
-type marketStatesDiffer struct {
-	Results  *DealStateChanges
-	pre, cur DealStates
-}
-
-func (d *marketStatesDiffer) Add(key uint64, val *cbg.Deferred) error {
-	ds, err := d.cur.decode(val)
-	if err != nil {
-		return err
-	}
-	d.Results.Added = append(d.Results.Added, DealIDState{abi.DealID(key), *ds})
-	return nil
-}
-
-func (d *marketStatesDiffer) Modify(key uint64, from, to *cbg.Deferred) error {
-	dsFrom, err := d.pre.decode(from)
-	if err != nil {
-		return err
-	}
-	dsTo, err := d.cur.decode(to)
-	if err != nil {
-		return err
-	}
-	if *dsFrom != *dsTo {
-		d.Results.Modified = append(d.Results.Modified, DealStateChange{abi.DealID(key), dsFrom, dsTo})
-	}
-	return nil
-}
-
-func (d *marketStatesDiffer) Remove(key uint64, val *cbg.Deferred) error {
-	ds, err := d.pre.decode(val)
-	if err != nil {
-		return err
-	}
-	d.Results.Removed = append(d.Results.Removed, DealIDState{abi.DealID(key), *ds})
-	return nil
-}
@@ -1,148 +0,0 @@
-package market
-
-import (
-	"golang.org/x/xerrors"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/go-state-types/cbor"
-	"github.com/ipfs/go-cid"
-	cbg "github.com/whyrusleeping/cbor-gen"
-
-	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
-	market0 "github.com/filecoin-project/specs-actors/actors/builtin/market"
-	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
-	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"
-	"github.com/filecoin-project/lotus/chain/types"
-)
-
-func init() {
-	builtin.RegisterActorState(builtin0.StorageMarketActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
-		return load0(store, root)
-	})
-	builtin.RegisterActorState(builtin2.StorageMarketActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
-		return load2(store, root)
-	})
-	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
-)
-
-func Load(store adt.Store, act *types.Actor) (st State, err error) {
-	switch act.Code {
-	case builtin0.StorageMarketActorCodeID:
-		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)
-}
-
-type State interface {
-	cbor.Marshaler
-	BalancesChanged(State) (bool, error)
-	EscrowTable() (BalanceTable, error)
-	LockedTable() (BalanceTable, error)
-	TotalLocked() (abi.TokenAmount, error)
-	StatesChanged(State) (bool, error)
-	States() (DealStates, error)
-	ProposalsChanged(State) (bool, error)
-	Proposals() (DealProposals, error)
-	VerifyDealsForActivation(
-		minerAddr address.Address, deals []abi.DealID, currEpoch, sectorExpiry abi.ChainEpoch,
-	) (weight, verifiedWeight abi.DealWeight, err error)
-}
-
-type BalanceTable interface {
-	ForEach(cb func(address.Address, abi.TokenAmount) error) error
-	Get(key address.Address) (abi.TokenAmount, error)
-}
-
-type DealStates interface {
-	ForEach(cb func(id abi.DealID, ds DealState) error) error
-	Get(id abi.DealID) (*DealState, bool, error)
-
-	array() adt.Array
-	decode(*cbg.Deferred) (*DealState, error)
-}
-
-type DealProposals interface {
-	ForEach(cb func(id abi.DealID, dp DealProposal) error) error
-	Get(id abi.DealID) (*DealProposal, bool, error)
-
-	array() adt.Array
-	decode(*cbg.Deferred) (*DealProposal, error)
-}
-
-type PublishStorageDealsParams = market0.PublishStorageDealsParams
-type PublishStorageDealsReturn = market0.PublishStorageDealsReturn
-type VerifyDealsForActivationParams = market0.VerifyDealsForActivationParams
-type WithdrawBalanceParams = market0.WithdrawBalanceParams
-
-type ClientDealProposal = market0.ClientDealProposal
-
-type DealState struct {
-	SectorStartEpoch abi.ChainEpoch // -1 if not yet included in proven sector
-	LastUpdatedEpoch abi.ChainEpoch // -1 if deal state never updated
-	SlashEpoch       abi.ChainEpoch // -1 if deal never slashed
-}
-
-type DealProposal struct {
-	PieceCID             cid.Cid
-	PieceSize            abi.PaddedPieceSize
-	VerifiedDeal         bool
-	Client               address.Address
-	Provider             address.Address
-	Label                string
-	StartEpoch           abi.ChainEpoch
-	EndEpoch             abi.ChainEpoch
-	StoragePricePerEpoch abi.TokenAmount
-	ProviderCollateral   abi.TokenAmount
-	ClientCollateral     abi.TokenAmount
-}
-
-type DealStateChanges struct {
-	Added    []DealIDState
-	Modified []DealStateChange
-	Removed  []DealIDState
-}
-
-type DealIDState struct {
-	ID   abi.DealID
-	Deal DealState
-}
-
-// DealStateChange is a change in deal state from -> to
-type DealStateChange struct {
-	ID   abi.DealID
-	From *DealState
-	To   *DealState
-}
-
-type DealProposalChanges struct {
-	Added   []ProposalIDState
-	Removed []ProposalIDState
-}
-
-type ProposalIDState struct {
-	ID       abi.DealID
-	Proposal DealProposal
-}
-
-func EmptyDealState() *DealState {
-	return &DealState{
-		SectorStartEpoch: -1,
-		SlashEpoch:       -1,
-		LastUpdatedEpoch: -1,
-	}
-}
@@ -1,204 +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"
-
-	market0 "github.com/filecoin-project/specs-actors/actors/builtin/market"
-	adt0 "github.com/filecoin-project/specs-actors/actors/util/adt"
-)
-
-var _ State = (*state0)(nil)
-
-func load0(store adt.Store, root cid.Cid) (State, error) {
-	out := state0{store: store}
-	err := store.Get(store.Context(), root, &out)
-	if err != nil {
-		return nil, err
-	}
-	return &out, nil
-}
-
-type state0 struct {
-	market0.State
-	store adt.Store
-}
-
-func (s *state0) TotalLocked() (abi.TokenAmount, error) {
-	fml := types.BigAdd(s.TotalClientLockedCollateral, s.TotalProviderLockedCollateral)
-	fml = types.BigAdd(fml, s.TotalClientStorageFee)
-	return fml, nil
-}
-
-func (s *state0) BalancesChanged(otherState State) (bool, error) {
-	otherState0, ok := otherState.(*state0)
-	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(otherState0.State.EscrowTable) || !s.State.LockedTable.Equals(otherState0.State.LockedTable), nil
-}
-
-func (s *state0) StatesChanged(otherState State) (bool, error) {
-	otherState0, ok := otherState.(*state0)
-	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(otherState0.State.States), nil
-}
-
-func (s *state0) States() (DealStates, error) {
-	stateArray, err := adt0.AsArray(s.store, s.State.States)
-	if err != nil {
-		return nil, err
-	}
-	return &dealStates0{stateArray}, nil
-}
-
-func (s *state0) ProposalsChanged(otherState State) (bool, error) {
-	otherState0, ok := otherState.(*state0)
-	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(otherState0.State.Proposals), nil
-}
-
-func (s *state0) Proposals() (DealProposals, error) {
-	proposalArray, err := adt0.AsArray(s.store, s.State.Proposals)
-	if err != nil {
-		return nil, err
-	}
-	return &dealProposals0{proposalArray}, nil
-}
-
-func (s *state0) EscrowTable() (BalanceTable, error) {
-	bt, err := adt0.AsBalanceTable(s.store, s.State.EscrowTable)
-	if err != nil {
-		return nil, err
-	}
-	return &balanceTable0{bt}, nil
-}
-
-func (s *state0) LockedTable() (BalanceTable, error) {
-	bt, err := adt0.AsBalanceTable(s.store, s.State.LockedTable)
-	if err != nil {
-		return nil, err
-	}
-	return &balanceTable0{bt}, nil
-}
-
-func (s *state0) VerifyDealsForActivation(
-	minerAddr address.Address, deals []abi.DealID, currEpoch, sectorExpiry abi.ChainEpoch,
-) (weight, verifiedWeight abi.DealWeight, err error) {
-	return market0.ValidateDealsForActivation(&s.State, s.store, deals, minerAddr, sectorExpiry, currEpoch)
-}
-
-type balanceTable0 struct {
-	*adt0.BalanceTable
-}
-
-func (bt *balanceTable0) ForEach(cb func(address.Address, abi.TokenAmount) error) error {
-	asMap := (*adt0.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 dealStates0 struct {
-	adt.Array
-}
-
-func (s *dealStates0) Get(dealID abi.DealID) (*DealState, bool, error) {
-	var deal0 market0.DealState
-	found, err := s.Array.Get(uint64(dealID), &deal0)
-	if err != nil {
-		return nil, false, err
-	}
-	if !found {
-		return nil, false, nil
-	}
-	deal := fromV0DealState(deal0)
-	return &deal, true, nil
-}
-
-func (s *dealStates0) ForEach(cb func(dealID abi.DealID, ds DealState) error) error {
-	var ds0 market0.DealState
-	return s.Array.ForEach(&ds0, func(idx int64) error {
-		return cb(abi.DealID(idx), fromV0DealState(ds0))
-	})
-}
-
-func (s *dealStates0) decode(val *cbg.Deferred) (*DealState, error) {
-	var ds0 market0.DealState
-	if err := ds0.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil {
-		return nil, err
-	}
-	ds := fromV0DealState(ds0)
-	return &ds, nil
-}
-
-func (s *dealStates0) array() adt.Array {
-	return s.Array
-}
-
-func fromV0DealState(v0 market0.DealState) DealState {
-	return (DealState)(v0)
-}
-
-type dealProposals0 struct {
-	adt.Array
-}
-
-func (s *dealProposals0) Get(dealID abi.DealID) (*DealProposal, bool, error) {
-	var proposal0 market0.DealProposal
-	found, err := s.Array.Get(uint64(dealID), &proposal0)
-	if err != nil {
-		return nil, false, err
-	}
-	if !found {
-		return nil, false, nil
-	}
-	proposal := fromV0DealProposal(proposal0)
-	return &proposal, true, nil
-}
-
-func (s *dealProposals0) ForEach(cb func(dealID abi.DealID, dp DealProposal) error) error {
-	var dp0 market0.DealProposal
-	return s.Array.ForEach(&dp0, func(idx int64) error {
-		return cb(abi.DealID(idx), fromV0DealProposal(dp0))
-	})
-}
-
-func (s *dealProposals0) decode(val *cbg.Deferred) (*DealProposal, error) {
-	var dp0 market0.DealProposal
-	if err := dp0.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil {
-		return nil, err
-	}
-	dp := fromV0DealProposal(dp0)
-	return &dp, nil
-}
-
-func (s *dealProposals0) array() adt.Array {
-	return s.Array
-}
-
-func fromV0DealProposal(v0 market0.DealProposal) DealProposal {
-	return (DealProposal)(v0)
-}
@@ -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"
-
-	market2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/market"
-	adt2 "github.com/filecoin-project/specs-actors/v2/actors/util/adt"
-)
-
-var _ State = (*state2)(nil)
-
-func load2(store adt.Store, root cid.Cid) (State, error) {
-	out := state2{store: store}
-	err := store.Get(store.Context(), root, &out)
-	if err != nil {
-		return nil, err
-	}
-	return &out, nil
-}
-
-type state2 struct {
-	market2.State
-	store adt.Store
-}
-
-func (s *state2) TotalLocked() (abi.TokenAmount, error) {
-	fml := types.BigAdd(s.TotalClientLockedCollateral, s.TotalProviderLockedCollateral)
-	fml = types.BigAdd(fml, s.TotalClientStorageFee)
-	return fml, nil
-}
-
-func (s *state2) BalancesChanged(otherState State) (bool, error) {
-	otherState2, ok := otherState.(*state2)
-	if !ok {
-		// there's no way to compare different versions of the state, so let's
-		// just say that means the state of balances has changed
-		return true, nil
-	}
-	return !s.State.EscrowTable.Equals(otherState2.State.EscrowTable) || !s.State.LockedTable.Equals(otherState2.State.LockedTable), nil
-}
-
-func (s *state2) StatesChanged(otherState State) (bool, error) {
-	otherState2, ok := otherState.(*state2)
-	if !ok {
-		// there's no way to compare different versions of the state, so let's
-		// just say that means the state of balances has changed
-		return true, nil
-	}
-	return !s.State.States.Equals(otherState2.State.States), nil
-}
-
-func (s *state2) States() (DealStates, error) {
-	stateArray, err := adt2.AsArray(s.store, s.State.States)
-	if err != nil {
-		return nil, err
-	}
-	return &dealStates2{stateArray}, nil
-}
-
-func (s *state2) ProposalsChanged(otherState State) (bool, error) {
-	otherState2, ok := otherState.(*state2)
-	if !ok {
-		// there's no way to compare different versions of the state, so let's
-		// just say that means the state of balances has changed
-		return true, nil
-	}
-	return !s.State.Proposals.Equals(otherState2.State.Proposals), nil
-}
-
-func (s *state2) Proposals() (DealProposals, error) {
-	proposalArray, err := adt2.AsArray(s.store, s.State.Proposals)
-	if err != nil {
-		return nil, err
-	}
-	return &dealProposals2{proposalArray}, nil
-}
-
-func (s *state2) EscrowTable() (BalanceTable, error) {
-	bt, err := adt2.AsBalanceTable(s.store, s.State.EscrowTable)
-	if err != nil {
-		return nil, err
-	}
-	return &balanceTable2{bt}, nil
-}
-
-func (s *state2) LockedTable() (BalanceTable, error) {
-	bt, err := adt2.AsBalanceTable(s.store, s.State.LockedTable)
-	if err != nil {
-		return nil, err
-	}
-	return &balanceTable2{bt}, nil
-}
-
-func (s *state2) VerifyDealsForActivation(
-	minerAddr address.Address, deals []abi.DealID, currEpoch, sectorExpiry abi.ChainEpoch,
-) (weight, verifiedWeight abi.DealWeight, err error) {
-	w, vw, _, err := market2.ValidateDealsForActivation(&s.State, s.store, deals, minerAddr, sectorExpiry, currEpoch)
-	return w, vw, err
-}
-
-type balanceTable2 struct {
-	*adt2.BalanceTable
-}
-
-func (bt *balanceTable2) ForEach(cb func(address.Address, abi.TokenAmount) error) error {
-	asMap := (*adt2.Map)(bt.BalanceTable)
-	var ta abi.TokenAmount
-	return asMap.ForEach(&ta, func(key string) error {
-		a, err := address.NewFromBytes([]byte(key))
-		if err != nil {
-			return err
-		}
-		return cb(a, ta)
-	})
-}
-
-type dealStates2 struct {
-	adt.Array
-}
-
-func (s *dealStates2) Get(dealID abi.DealID) (*DealState, bool, error) {
-	var deal2 market2.DealState
-	found, err := s.Array.Get(uint64(dealID), &deal2)
-	if err != nil {
-		return nil, false, err
-	}
-	if !found {
-		return nil, false, nil
-	}
-	deal := fromV2DealState(deal2)
-	return &deal, true, nil
-}
-
-func (s *dealStates2) ForEach(cb func(dealID abi.DealID, ds DealState) error) error {
-	var ds1 market2.DealState
-	return s.Array.ForEach(&ds1, func(idx int64) error {
-		return cb(abi.DealID(idx), fromV2DealState(ds1))
-	})
-}
-
-func (s *dealStates2) decode(val *cbg.Deferred) (*DealState, error) {
-	var ds1 market2.DealState
-	if err := ds1.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil {
-		return nil, err
-	}
-	ds := fromV2DealState(ds1)
-	return &ds, nil
-}
-
-func (s *dealStates2) array() adt.Array {
-	return s.Array
-}
-
-func fromV2DealState(v1 market2.DealState) DealState {
-	return (DealState)(v1)
-}
-
-type dealProposals2 struct {
-	adt.Array
-}
-
-func (s *dealProposals2) Get(dealID abi.DealID) (*DealProposal, bool, error) {
-	var proposal2 market2.DealProposal
-	found, err := s.Array.Get(uint64(dealID), &proposal2)
-	if err != nil {
-		return nil, false, err
-	}
-	if !found {
-		return nil, false, nil
-	}
-	proposal := fromV2DealProposal(proposal2)
-	return &proposal, true, nil
-}
-
-func (s *dealProposals2) ForEach(cb func(dealID abi.DealID, dp DealProposal) error) error {
-	var dp1 market2.DealProposal
-	return s.Array.ForEach(&dp1, func(idx int64) error {
-		return cb(abi.DealID(idx), fromV2DealProposal(dp1))
-	})
-}
-
-func (s *dealProposals2) decode(val *cbg.Deferred) (*DealProposal, error) {
-	var dp1 market2.DealProposal
-	if err := dp1.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil {
-		return nil, err
-	}
-	dp := fromV2DealProposal(dp1)
-	return &dp, nil
-}
-
-func (s *dealProposals2) array() adt.Array {
-	return s.Array
-}
-
-func fromV2DealProposal(v1 market2.DealProposal) DealProposal {
-	return (DealProposal)(v1)
-}
@@ -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)
-}
@@ -1,127 +0,0 @@
-package miner
-
-import (
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/lotus/chain/actors/adt"
-	cbg "github.com/whyrusleeping/cbor-gen"
-)
-
-func DiffPreCommits(pre, cur State) (*PreCommitChanges, error) {
-	results := new(PreCommitChanges)
-
-	prep, err := pre.precommits()
-	if err != nil {
-		return nil, err
-	}
-
-	curp, err := cur.precommits()
-	if err != nil {
-		return nil, err
-	}
-
-	err = adt.DiffAdtMap(prep, curp, &preCommitDiffer{results, pre, cur})
-	if err != nil {
-		return nil, err
-	}
-
-	return results, nil
-}
-
-type preCommitDiffer struct {
-	Results    *PreCommitChanges
-	pre, after State
-}
-
-func (m *preCommitDiffer) AsKey(key string) (abi.Keyer, error) {
-	sector, err := abi.ParseUIntKey(key)
-	if err != nil {
-		return nil, err
-	}
-	return abi.UIntKey(sector), nil
-}
-
-func (m *preCommitDiffer) Add(key string, val *cbg.Deferred) error {
-	sp, err := m.after.decodeSectorPreCommitOnChainInfo(val)
-	if err != nil {
-		return err
-	}
-	m.Results.Added = append(m.Results.Added, sp)
-	return nil
-}
-
-func (m *preCommitDiffer) Modify(key string, from, to *cbg.Deferred) error {
-	return nil
-}
-
-func (m *preCommitDiffer) Remove(key string, val *cbg.Deferred) error {
-	sp, err := m.pre.decodeSectorPreCommitOnChainInfo(val)
-	if err != nil {
-		return err
-	}
-	m.Results.Removed = append(m.Results.Removed, sp)
-	return nil
-}
-
-func DiffSectors(pre, cur State) (*SectorChanges, error) {
-	results := new(SectorChanges)
-
-	pres, err := pre.sectors()
-	if err != nil {
-		return nil, err
-	}
-
-	curs, err := cur.sectors()
-	if err != nil {
-		return nil, err
-	}
-
-	err = adt.DiffAdtArray(pres, curs, &sectorDiffer{results, pre, cur})
-	if err != nil {
-		return nil, err
-	}
-
-	return results, nil
-}
-
-type sectorDiffer struct {
-	Results    *SectorChanges
-	pre, after State
-}
-
-func (m *sectorDiffer) Add(key uint64, val *cbg.Deferred) error {
-	si, err := m.after.decodeSectorOnChainInfo(val)
-	if err != nil {
-		return err
-	}
-	m.Results.Added = append(m.Results.Added, si)
-	return nil
-}
-
-func (m *sectorDiffer) Modify(key uint64, from, to *cbg.Deferred) error {
-	siFrom, err := m.pre.decodeSectorOnChainInfo(from)
-	if err != nil {
-		return err
-	}
-
-	siTo, err := m.after.decodeSectorOnChainInfo(to)
-	if err != nil {
-		return err
-	}
-
-	if siFrom.Expiration != siTo.Expiration {
-		m.Results.Extended = append(m.Results.Extended, SectorExtensions{
-			From: siFrom,
-			To:   siTo,
-		})
-	}
-	return nil
-}
-
-func (m *sectorDiffer) Remove(key uint64, val *cbg.Deferred) error {
-	si, err := m.pre.decodeSectorOnChainInfo(val)
-	if err != nil {
-		return err
-	}
-	m.Results.Removed = append(m.Results.Removed, si)
-	return nil
-}
@@ -1,176 +0,0 @@
-package miner
-
-import (
-	"errors"
-
-	"github.com/filecoin-project/go-bitfield"
-	"github.com/filecoin-project/go-state-types/exitcode"
-)
-
-type DeadlinesDiff map[uint64]DeadlineDiff
-
-func DiffDeadlines(pre, cur State) (DeadlinesDiff, error) {
-	changed, err := pre.DeadlinesChanged(cur)
-	if err != nil {
-		return nil, err
-	}
-	if !changed {
-		return nil, nil
-	}
-
-	dlDiff := make(DeadlinesDiff)
-	if err := pre.ForEachDeadline(func(idx uint64, preDl Deadline) error {
-		curDl, err := cur.LoadDeadline(idx)
-		if err != nil {
-			return err
-		}
-
-		diff, err := DiffDeadline(preDl, curDl)
-		if err != nil {
-			return err
-		}
-
-		dlDiff[idx] = diff
-		return nil
-	}); err != nil {
-		return nil, err
-	}
-	return dlDiff, nil
-}
-
-type DeadlineDiff map[uint64]*PartitionDiff
-
-func DiffDeadline(pre, cur Deadline) (DeadlineDiff, error) {
-	changed, err := pre.PartitionsChanged(cur)
-	if err != nil {
-		return nil, err
-	}
-	if !changed {
-		return nil, nil
-	}
-
-	partDiff := make(DeadlineDiff)
-	if err := pre.ForEachPartition(func(idx uint64, prePart Partition) error {
-		// try loading current partition at this index
-		curPart, err := cur.LoadPartition(idx)
-		if err != nil {
-			if errors.Is(err, exitcode.ErrNotFound) {
-				// TODO correctness?
-				return nil // the partition was removed.
-			}
-			return err
-		}
-
-		// compare it with the previous partition
-		diff, err := DiffPartition(prePart, curPart)
-		if err != nil {
-			return err
-		}
-
-		partDiff[idx] = diff
-		return nil
-	}); err != nil {
-		return nil, err
-	}
-
-	// all previous partitions have been walked.
-	// all partitions in cur and not in prev are new... can they be faulty already?
-	// TODO is this correct?
-	if err := cur.ForEachPartition(func(idx uint64, curPart Partition) error {
-		if _, found := partDiff[idx]; found {
-			return nil
-		}
-		faults, err := curPart.FaultySectors()
-		if err != nil {
-			return err
-		}
-		recovering, err := curPart.RecoveringSectors()
-		if err != nil {
-			return err
-		}
-		partDiff[idx] = &PartitionDiff{
-			Removed:    bitfield.New(),
-			Recovered:  bitfield.New(),
-			Faulted:    faults,
-			Recovering: recovering,
-		}
-
-		return nil
-	}); err != nil {
-		return nil, err
-	}
-
-	return partDiff, nil
-}
-
-type PartitionDiff struct {
-	Removed    bitfield.BitField
-	Recovered  bitfield.BitField
-	Faulted    bitfield.BitField
-	Recovering bitfield.BitField
-}
-
-func DiffPartition(pre, cur Partition) (*PartitionDiff, error) {
-	prevLiveSectors, err := pre.LiveSectors()
-	if err != nil {
-		return nil, err
-	}
-	curLiveSectors, err := cur.LiveSectors()
-	if err != nil {
-		return nil, err
-	}
-
-	removed, err := bitfield.SubtractBitField(prevLiveSectors, curLiveSectors)
-	if err != nil {
-		return nil, err
-	}
-
-	prevRecoveries, err := pre.RecoveringSectors()
-	if err != nil {
-		return nil, err
-	}
-
-	curRecoveries, err := cur.RecoveringSectors()
-	if err != nil {
-		return nil, err
-	}
-
-	recovering, err := bitfield.SubtractBitField(curRecoveries, prevRecoveries)
-	if err != nil {
-		return nil, err
-	}
-
-	prevFaults, err := pre.FaultySectors()
-	if err != nil {
-		return nil, err
-	}
-
-	curFaults, err := cur.FaultySectors()
-	if err != nil {
-		return nil, err
-	}
-
-	faulted, err := bitfield.SubtractBitField(curFaults, prevFaults)
-	if err != nil {
-		return nil, err
-	}
-
-	// all current good sectors
-	curActiveSectors, err := cur.ActiveSectors()
-	if err != nil {
-		return nil, err
-	}
-
-	// sectors that were previously fault and are now currently active are considered recovered.
-	recovered, err := bitfield.IntersectBitField(prevFaults, curActiveSectors)
-	if err != nil {
-		return nil, err
-	}
-
-	return &PartitionDiff{
-		Removed:    removed,
-		Recovered:  recovered,
-		Faulted:    faulted,
-		Recovering: recovering,
-	}, nil
-}
@@ -1,274 +0,0 @@
-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"
-	"golang.org/x/xerrors"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-bitfield"
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/go-state-types/cbor"
-	"github.com/filecoin-project/go-state-types/dline"
-
-	"github.com/filecoin-project/lotus/chain/actors/adt"
-	"github.com/filecoin-project/lotus/chain/actors/builtin"
-	"github.com/filecoin-project/lotus/chain/types"
-
-	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
-	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
-	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
-	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() {
-	builtin.RegisterActorState(builtin0.StorageMinerActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
-		return load0(store, root)
-	})
-	builtin.RegisterActorState(builtin2.StorageMinerActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
-		return load2(store, root)
-	})
-	builtin.RegisterActorState(builtin3.StorageMinerActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
-		return load3(store, root)
-	})
-}
-
-var Methods = builtin3.MethodsMiner
-
-// Unchanged between v0, v2, and v3 actors
-var WPoStProvingPeriod = miner0.WPoStProvingPeriod
-var WPoStPeriodDeadlines = miner0.WPoStPeriodDeadlines
-var WPoStChallengeWindow = miner0.WPoStChallengeWindow
-var WPoStChallengeLookback = miner0.WPoStChallengeLookback
-var FaultDeclarationCutoff = miner0.FaultDeclarationCutoff
-
-const MinSectorExpiration = miner0.MinSectorExpiration
-
-// 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)
-}
-
-type State interface {
-	cbor.Marshaler
-
-	// Total available balance to spend.
-	AvailableBalance(abi.TokenAmount) (abi.TokenAmount, error)
-	// Funds that will vest by the given epoch.
-	VestedFunds(abi.ChainEpoch) (abi.TokenAmount, error)
-	// Funds locked for various reasons.
-	LockedFunds() (LockedFunds, error)
-	FeeDebt() (abi.TokenAmount, error)
-
-	GetSector(abi.SectorNumber) (*SectorOnChainInfo, error)
-	FindSector(abi.SectorNumber) (*SectorLocation, error)
-	GetSectorExpiration(abi.SectorNumber) (*SectorExpiration, error)
-	GetPrecommittedSector(abi.SectorNumber) (*SectorPreCommitOnChainInfo, error)
-	LoadSectors(sectorNos *bitfield.BitField) ([]*SectorOnChainInfo, error)
-	NumLiveSectors() (uint64, error)
-	IsAllocated(abi.SectorNumber) (bool, error)
-
-	LoadDeadline(idx uint64) (Deadline, error)
-	ForEachDeadline(cb func(idx uint64, dl Deadline) error) error
-	NumDeadlines() (uint64, error)
-	DeadlinesChanged(State) (bool, error)
-
-	Info() (MinerInfo, error)
-	MinerInfoChanged(State) (bool, error)
-
-	DeadlineInfo(epoch abi.ChainEpoch) (*dline.Info, error)
-
-	// Diff helpers. Used by Diff* functions internally.
-	sectors() (adt.Array, error)
-	decodeSectorOnChainInfo(*cbg.Deferred) (SectorOnChainInfo, error)
-	precommits() (adt.Map, error)
-	decodeSectorPreCommitOnChainInfo(*cbg.Deferred) (SectorPreCommitOnChainInfo, error)
-}
-
-type Deadline interface {
-	LoadPartition(idx uint64) (Partition, error)
-	ForEachPartition(cb func(idx uint64, part Partition) error) error
-	PartitionsPoSted() (bitfield.BitField, error)
-
-	PartitionsChanged(Deadline) (bool, error)
-	DisputableProofCount() (uint64, error)
-}
-
-type Partition interface {
-	AllSectors() (bitfield.BitField, error)
-	FaultySectors() (bitfield.BitField, error)
-	RecoveringSectors() (bitfield.BitField, error)
-	LiveSectors() (bitfield.BitField, error)
-	ActiveSectors() (bitfield.BitField, error)
-}
-
-type SectorOnChainInfo struct {
-	SectorNumber          abi.SectorNumber
-	SealProof             abi.RegisteredSealProof
-	SealedCID             cid.Cid
-	DealIDs               []abi.DealID
-	Activation            abi.ChainEpoch
-	Expiration            abi.ChainEpoch
-	DealWeight            abi.DealWeight
-	VerifiedDealWeight    abi.DealWeight
-	InitialPledge         abi.TokenAmount
-	ExpectedDayReward     abi.TokenAmount
-	ExpectedStoragePledge abi.TokenAmount
-}
-
-type SectorPreCommitInfo = miner0.SectorPreCommitInfo
-
-type SectorPreCommitOnChainInfo struct {
-	Info               SectorPreCommitInfo
-	PreCommitDeposit   abi.TokenAmount
-	PreCommitEpoch     abi.ChainEpoch
-	DealWeight         abi.DealWeight
-	VerifiedDealWeight abi.DealWeight
-}
-
-type PoStPartition = miner0.PoStPartition
-type RecoveryDeclaration = miner0.RecoveryDeclaration
-type FaultDeclaration = miner0.FaultDeclaration
-
-// Params
-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.
-	Worker                     address.Address   // Must be an ID-address.
-	NewWorker                  address.Address   // Must be an ID-address.
-	ControlAddresses           []address.Address // Must be an ID-addresses.
-	WorkerChangeEpoch          abi.ChainEpoch
-	PeerId                     *peer.ID
-	Multiaddrs                 []abi.Multiaddrs
-	WindowPoStProofType        abi.RegisteredPoStProof
-	SectorSize                 abi.SectorSize
-	WindowPoStPartitionSectors uint64
-	ConsensusFaultElapsed      abi.ChainEpoch
-}
-
-func (mi MinerInfo) IsController(addr address.Address) bool {
-	if addr == mi.Owner || addr == mi.Worker {
-		return true
-	}
-
-	for _, ca := range mi.ControlAddresses {
-		if addr == ca {
-			return true
-		}
-	}
-
-	return false
-}
-
-type SectorExpiration struct {
-	OnTime abi.ChainEpoch
-
-	// non-zero if sector is faulty, epoch at which it will be permanently
-	// removed if it doesn't recover
-	Early abi.ChainEpoch
-}
-
-type SectorLocation struct {
-	Deadline  uint64
-	Partition uint64
-}
-
-type SectorChanges struct {
-	Added    []SectorOnChainInfo
-	Extended []SectorExtensions
-	Removed  []SectorOnChainInfo
-}
-
-type SectorExtensions struct {
-	From SectorOnChainInfo
-	To   SectorOnChainInfo
-}
-
-type PreCommitChanges struct {
-	Added   []SectorPreCommitOnChainInfo
-	Removed []SectorPreCommitOnChainInfo
-}
-
-type LockedFunds struct {
-	VestingFunds             abi.TokenAmount
-	InitialPledgeRequirement abi.TokenAmount
-	PreCommitDeposits        abi.TokenAmount
-}
-
-func (lf LockedFunds) TotalLockedFunds() abi.TokenAmount {
-	return big.Add(lf.VestingFunds, big.Add(lf.InitialPledgeRequirement, lf.PreCommitDeposits))
-}
@@ -1,69 +0,0 @@
-package miner
-
-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) {
-	var parts []bitfield.BitField
-
-	err := mas.ForEachDeadline(func(dlidx uint64, dl Deadline) error {
-		return dl.ForEachPartition(func(partidx uint64, part Partition) error {
-			s, err := sget(part)
-			if err != nil {
-				return xerrors.Errorf("getting sector list (dl: %d, part %d): %w", dlidx, partidx, err)
-			}
-
-			parts = append(parts, s)
-			return nil
-		})
-	})
-	if err != nil {
-		return bitfield.BitField{}, err
-	}
-
-	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")
-}
@@ -1,417 +0,0 @@
-package miner
-
-import (
-	"bytes"
-	"errors"
-
-	"github.com/filecoin-project/go-state-types/big"
-
-	"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"
-
-	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
-	adt0 "github.com/filecoin-project/specs-actors/actors/util/adt"
-)
-
-var _ State = (*state0)(nil)
-
-func load0(store adt.Store, root cid.Cid) (State, error) {
-	out := state0{store: store}
-	err := store.Get(store.Context(), root, &out)
-	if err != nil {
-		return nil, err
-	}
-	return &out, nil
-}
-
-type state0 struct {
-	miner0.State
-	store adt.Store
-}
-
-type deadline0 struct {
-	miner0.Deadline
-	store adt.Store
-}
-
-type partition0 struct {
-	miner0.Partition
-	store adt.Store
-}
-
-func (s *state0) 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 = s.GetAvailableBalance(bal)
-	return available, err
-}
-
-func (s *state0) VestedFunds(epoch abi.ChainEpoch) (abi.TokenAmount, error) {
-	return s.CheckVestedFunds(s.store, epoch)
-}
-
-func (s *state0) LockedFunds() (LockedFunds, error) {
-	return LockedFunds{
-		VestingFunds:             s.State.LockedFunds,
-		InitialPledgeRequirement: s.State.InitialPledgeRequirement,
-		PreCommitDeposits:        s.State.PreCommitDeposits,
-	}, nil
-}
-
-func (s *state0) FeeDebt() (abi.TokenAmount, error) {
-	return big.Zero(), nil
-}
-
-func (s *state0) InitialPledge() (abi.TokenAmount, error) {
-	return s.State.InitialPledgeRequirement, nil
-}
-
-func (s *state0) PreCommitDeposits() (abi.TokenAmount, error) {
-	return s.State.PreCommitDeposits, nil
-}
-
-func (s *state0) GetSector(num abi.SectorNumber) (*SectorOnChainInfo, error) {
-	info, ok, err := s.State.GetSector(s.store, num)
-	if !ok || err != nil {
-		return nil, err
-	}
-
-	ret := fromV0SectorOnChainInfo(*info)
-	return &ret, nil
-}
-
-func (s *state0) 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 *state0) NumLiveSectors() (uint64, error) {
-	dls, err := s.State.LoadDeadlines(s.store)
-	if err != nil {
-		return 0, err
-	}
-	var total uint64
-	if err := dls.ForEach(s.store, func(dlIdx uint64, dl *miner0.Deadline) error {
-		total += dl.LiveSectors
-		return nil
-	}); err != nil {
-		return 0, err
-	}
-	return total, nil
-}
-
-// GetSectorExpiration returns the effective expiration of the given sector.
-//
-// If the sector does not expire early, the Early expiration field is 0.
-func (s *state0) GetSectorExpiration(num abi.SectorNumber) (*SectorExpiration, error) {
-	dls, err := s.State.LoadDeadlines(s.store)
-	if err != nil {
-		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 *miner0.Deadline) error {
-		partitions, err := dl.PartitionsArray(s.store)
-		if err != nil {
-			return err
-		}
-		quant := s.State.QuantSpecForDeadline(dlIdx)
-		var part miner0.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 := miner0.LoadExpirationQueue(s.store, part.ExpirationsEpochs, quant)
-			if err != nil {
-				return err
-			}
-			var exp miner0.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 *state0) GetPrecommittedSector(num abi.SectorNumber) (*SectorPreCommitOnChainInfo, error) {
-	info, ok, err := s.State.GetPrecommittedSector(s.store, num)
-	if !ok || err != nil {
-		return nil, err
-	}
-
-	ret := fromV0SectorPreCommitOnChainInfo(*info)
-	return &ret, nil
-}
-
-func (s *state0) LoadSectors(snos *bitfield.BitField) ([]*SectorOnChainInfo, error) {
-	sectors, err := miner0.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 info0 miner0.SectorOnChainInfo
-		if err := sectors.ForEach(&info0, func(_ int64) error {
-			info := fromV0SectorOnChainInfo(info0)
-			infos = append(infos, &info)
-			return nil
-		}); err != nil {
-			return nil, err
-		}
-		return infos, nil
-	}
-
-	// Otherwise, load selected.
-	infos0, err := sectors.Load(*snos)
-	if err != nil {
-		return nil, err
-	}
-	infos := make([]*SectorOnChainInfo, len(infos0))
-	for i, info0 := range infos0 {
-		info := fromV0SectorOnChainInfo(*info0)
-		infos[i] = &info
-	}
-	return infos, nil
-}
-
-func (s *state0) IsAllocated(num abi.SectorNumber) (bool, error) {
-	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 *state0) 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 &deadline0{*dl, s.store}, nil
-}
-
-func (s *state0) 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 *miner0.Deadline) error {
-		return cb(i, &deadline0{*dl, s.store})
-	})
-}
-
-func (s *state0) NumDeadlines() (uint64, error) {
-	return miner0.WPoStPeriodDeadlines, nil
-}
-
-func (s *state0) DeadlinesChanged(other State) (bool, error) {
-	other0, ok := other.(*state0)
-	if !ok {
-		// treat an upgrade as a change, always
-		return true, nil
-	}
-
-	return !s.State.Deadlines.Equals(other0.Deadlines), nil
-}
-
-func (s *state0) MinerInfoChanged(other State) (bool, error) {
-	other0, ok := other.(*state0)
-	if !ok {
-		// treat an upgrade as a change, always
-		return true, nil
-	}
-	return !s.State.Info.Equals(other0.State.Info), nil
-}
-
-func (s *state0) Info() (MinerInfo, error) {
-	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
-	}
-
-	wpp, err := info.SealProofType.RegisteredWindowPoStProof()
-	if err != nil {
-		return MinerInfo{}, err
-	}
-
-	mi := MinerInfo{
-		Owner:            info.Owner,
-		Worker:           info.Worker,
-		ControlAddresses: info.ControlAddresses,
-
-		NewWorker:         address.Undef,
-		WorkerChangeEpoch: -1,
-
-		PeerId:                     pid,
-		Multiaddrs:                 info.Multiaddrs,
-		WindowPoStProofType:        wpp,
-		SectorSize:                 info.SectorSize,
-		WindowPoStPartitionSectors: info.WindowPoStPartitionSectors,
-		ConsensusFaultElapsed:      -1,
-	}
-
-	if info.PendingWorkerKey != nil {
-		mi.NewWorker = info.PendingWorkerKey.NewWorker
-		mi.WorkerChangeEpoch = info.PendingWorkerKey.EffectiveAt
-	}
-
-	return mi, nil
-}
-
-func (s *state0) DeadlineInfo(epoch abi.ChainEpoch) (*dline.Info, error) {
-	return s.State.DeadlineInfo(epoch), nil
-}
-
-func (s *state0) sectors() (adt.Array, error) {
-	return adt0.AsArray(s.store, s.Sectors)
-}
-
-func (s *state0) decodeSectorOnChainInfo(val *cbg.Deferred) (SectorOnChainInfo, error) {
-	var si miner0.SectorOnChainInfo
-	err := si.UnmarshalCBOR(bytes.NewReader(val.Raw))
-	if err != nil {
-		return SectorOnChainInfo{}, err
-	}
-
-	return fromV0SectorOnChainInfo(si), nil
-}
-
-func (s *state0) precommits() (adt.Map, error) {
-	return adt0.AsMap(s.store, s.PreCommittedSectors)
-}
-
-func (s *state0) decodeSectorPreCommitOnChainInfo(val *cbg.Deferred) (SectorPreCommitOnChainInfo, error) {
-	var sp miner0.SectorPreCommitOnChainInfo
-	err := sp.UnmarshalCBOR(bytes.NewReader(val.Raw))
-	if err != nil {
-		return SectorPreCommitOnChainInfo{}, err
-	}
-
-	return fromV0SectorPreCommitOnChainInfo(sp), nil
-}
-
-func (d *deadline0) LoadPartition(idx uint64) (Partition, error) {
-	p, err := d.Deadline.LoadPartition(d.store, idx)
-	if err != nil {
-		return nil, err
-	}
-	return &partition0{*p, d.store}, nil
-}
-
-func (d *deadline0) ForEachPartition(cb func(uint64, Partition) error) error {
-	ps, err := d.Deadline.PartitionsArray(d.store)
-	if err != nil {
-		return err
-	}
-	var part miner0.Partition
-	return ps.ForEach(&part, func(i int64) error {
-		return cb(uint64(i), &partition0{part, d.store})
-	})
-}
-
-func (d *deadline0) PartitionsChanged(other Deadline) (bool, error) {
-	other0, ok := other.(*deadline0)
-	if !ok {
-		// treat an upgrade as a change, always
-		return true, nil
-	}
-
-	return !d.Deadline.Partitions.Equals(other0.Deadline.Partitions), nil
-}
-
-func (d *deadline0) PartitionsPoSted() (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
-}
-
-func (p *partition0) FaultySectors() (bitfield.BitField, error) {
-	return p.Partition.Faults, nil
-}
-
-func (p *partition0) RecoveringSectors() (bitfield.BitField, error) {
-	return p.Partition.Recoveries, nil
-}
-
-func fromV0SectorOnChainInfo(v0 miner0.SectorOnChainInfo) SectorOnChainInfo {
-	return (SectorOnChainInfo)(v0)
-}
-
-func fromV0SectorPreCommitOnChainInfo(v0 miner0.SectorPreCommitOnChainInfo) SectorPreCommitOnChainInfo {
-	return (SectorPreCommitOnChainInfo)(v0)
-}
@@ -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"
-
-	miner2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/miner"
-	adt2 "github.com/filecoin-project/specs-actors/v2/actors/util/adt"
-)
-
-var _ State = (*state2)(nil)
-
-func load2(store adt.Store, root cid.Cid) (State, error) {
-	out := state2{store: store}
-	err := store.Get(store.Context(), root, &out)
-	if err != nil {
-		return nil, err
-	}
-	return &out, nil
-}
-
-type state2 struct {
-	miner2.State
-	store adt.Store
-}
-
-type deadline2 struct {
-	miner2.Deadline
-	store adt.Store
-}
-
-type partition2 struct {
-	miner2.Partition
-	store adt.Store
-}
-
-func (s *state2) AvailableBalance(bal abi.TokenAmount) (available abi.TokenAmount, err error) {
-	defer func() {
-		if r := recover(); r != nil {
-			err = xerrors.Errorf("failed to get available balance: %w", r)
-			available = abi.NewTokenAmount(0)
-		}
-	}()
-	// this panics if the miner doesnt have enough funds to cover their locked pledge
-	available, err = s.GetAvailableBalance(bal)
-	return available, err
-}
-
-func (s *state2) VestedFunds(epoch abi.ChainEpoch) (abi.TokenAmount, error) {
-	return s.CheckVestedFunds(s.store, epoch)
-}
-
-func (s *state2) LockedFunds() (LockedFunds, error) {
-	return LockedFunds{
-		VestingFunds:             s.State.LockedFunds,
-		InitialPledgeRequirement: s.State.InitialPledge,
-		PreCommitDeposits:        s.State.PreCommitDeposits,
-	}, nil
-}
-
-func (s *state2) FeeDebt() (abi.TokenAmount, error) {
-	return s.State.FeeDebt, nil
-}
-
-func (s *state2) InitialPledge() (abi.TokenAmount, error) {
-	return s.State.InitialPledge, nil
-}
-
-func (s *state2) PreCommitDeposits() (abi.TokenAmount, error) {
-	return s.State.PreCommitDeposits, nil
-}
-
-func (s *state2) GetSector(num abi.SectorNumber) (*SectorOnChainInfo, error) {
-	info, ok, err := s.State.GetSector(s.store, num)
-	if !ok || err != nil {
-		return nil, err
-	}
-
-	ret := fromV2SectorOnChainInfo(*info)
-	return &ret, nil
-}
-
-func (s *state2) FindSector(num abi.SectorNumber) (*SectorLocation, error) {
-	dlIdx, partIdx, err := s.State.FindSector(s.store, num)
-	if err != nil {
-		return nil, err
-	}
-	return &SectorLocation{
-		Deadline:  dlIdx,
-		Partition: partIdx,
-	}, nil
-}
-
-func (s *state2) NumLiveSectors() (uint64, error) {
-	dls, err := s.State.LoadDeadlines(s.store)
-	if err != nil {
-		return 0, err
-	}
-	var total uint64
-	if err := dls.ForEach(s.store, func(dlIdx uint64, dl *miner2.Deadline) error {
-		total += dl.LiveSectors
-		return nil
-	}); err != nil {
-		return 0, err
-	}
-	return total, nil
-}
-
-// GetSectorExpiration returns the effective expiration of the given sector.
-//
-// If the sector does not expire early, the Early expiration field is 0.
-func (s *state2) GetSectorExpiration(num abi.SectorNumber) (*SectorExpiration, error) {
-	dls, err := s.State.LoadDeadlines(s.store)
-	if err != nil {
-		return nil, err
-	}
-	// NOTE: this can be optimized significantly.
-	// 1. If the sector is non-faulty, it will either expire on-time (can be
-	// learned from the sector info), or in the next quantized expiration
-	// epoch (i.e., the first element in the partition's expiration queue.
-	// 2. If it's faulty, it will expire early within the first 14 entries
-	// of the expiration queue.
-	stopErr := errors.New("stop")
-	out := SectorExpiration{}
-	err = dls.ForEach(s.store, func(dlIdx uint64, dl *miner2.Deadline) error {
-		partitions, err := dl.PartitionsArray(s.store)
-		if err != nil {
-			return err
-		}
-		quant := s.State.QuantSpecForDeadline(dlIdx)
-		var part miner2.Partition
-		return partitions.ForEach(&part, func(partIdx int64) error {
-			if found, err := part.Sectors.IsSet(uint64(num)); err != nil {
-				return err
-			} else if !found {
-				return nil
-			}
-			if found, err := part.Terminated.IsSet(uint64(num)); err != nil {
-				return err
-			} else if found {
-				// already terminated
-				return stopErr
-			}
-
-			q, err := miner2.LoadExpirationQueue(s.store, part.ExpirationsEpochs, quant)
-			if err != nil {
-				return err
-			}
-			var exp miner2.ExpirationSet
-			return q.ForEach(&exp, func(epoch int64) error {
-				if early, err := exp.EarlySectors.IsSet(uint64(num)); err != nil {
-					return err
-				} else if early {
-					out.Early = abi.ChainEpoch(epoch)
-					return nil
-				}
-				if onTime, err := exp.OnTimeSectors.IsSet(uint64(num)); err != nil {
-					return err
-				} else if onTime {
-					out.OnTime = abi.ChainEpoch(epoch)
-					return stopErr
-				}
-				return nil
-			})
-		})
-	})
-	if err == stopErr {
-		err = nil
-	}
-	if err != nil {
-		return nil, err
-	}
-	if out.Early == 0 && out.OnTime == 0 {
-		return nil, xerrors.Errorf("failed to find sector %d", num)
-	}
-	return &out, nil
-}
-
-func (s *state2) GetPrecommittedSector(num abi.SectorNumber) (*SectorPreCommitOnChainInfo, error) {
-	info, ok, err := s.State.GetPrecommittedSector(s.store, num)
-	if !ok || err != nil {
-		return nil, err
-	}
-
-	ret := fromV2SectorPreCommitOnChainInfo(*info)
-
-	return &ret, nil
-}
-
-func (s *state2) LoadSectors(snos *bitfield.BitField) ([]*SectorOnChainInfo, error) {
-	sectors, err := miner2.LoadSectors(s.store, s.State.Sectors)
-	if err != nil {
-		return nil, err
-	}
-
-	// If no sector numbers are specified, load all.
-	if snos == nil {
-		infos := make([]*SectorOnChainInfo, 0, sectors.Length())
-		var info2 miner2.SectorOnChainInfo
-		if err := sectors.ForEach(&info2, func(_ int64) error {
-			info := fromV2SectorOnChainInfo(info2)
-			infos = append(infos, &info)
-			return nil
-		}); err != nil {
-			return nil, err
-		}
-		return infos, nil
-	}
-
-	// Otherwise, load selected.
-	infos2, err := sectors.Load(*snos)
-	if err != nil {
-		return nil, err
-	}
-	infos := make([]*SectorOnChainInfo, len(infos2))
-	for i, info2 := range infos2 {
-		info := fromV2SectorOnChainInfo(*info2)
-		infos[i] = &info
-	}
-	return infos, nil
-}
-
-func (s *state2) IsAllocated(num abi.SectorNumber) (bool, error) {
-	var allocatedSectors bitfield.BitField
-	if err := s.store.Get(s.store.Context(), s.State.AllocatedSectors, &allocatedSectors); err != nil {
-		return false, err
-	}
-
-	return allocatedSectors.IsSet(uint64(num))
-}
-
-func (s *state2) LoadDeadline(idx uint64) (Deadline, error) {
-	dls, err := s.State.LoadDeadlines(s.store)
-	if err != nil {
-		return nil, err
-	}
-	dl, err := dls.LoadDeadline(s.store, idx)
-	if err != nil {
-		return nil, err
-	}
-	return &deadline2{*dl, s.store}, nil
-}
-
-func (s *state2) ForEachDeadline(cb func(uint64, Deadline) error) error {
-	dls, err := s.State.LoadDeadlines(s.store)
-	if err != nil {
-		return err
-	}
-	return dls.ForEach(s.store, func(i uint64, dl *miner2.Deadline) error {
-		return cb(i, &deadline2{*dl, s.store})
-	})
-}
-
-func (s *state2) NumDeadlines() (uint64, error) {
-	return miner2.WPoStPeriodDeadlines, nil
-}
-
-func (s *state2) DeadlinesChanged(other State) (bool, error) {
-	other2, ok := other.(*state2)
-	if !ok {
-		// treat an upgrade as a change, always
-		return true, nil
-	}
-
-	return !s.State.Deadlines.Equals(other2.Deadlines), nil
-}
-
-func (s *state2) MinerInfoChanged(other State) (bool, error) {
-	other0, ok := other.(*state2)
-	if !ok {
-		// treat an upgrade as a change, always
-		return true, nil
-	}
-	return !s.State.Info.Equals(other0.State.Info), nil
-}
-
-func (s *state2) Info() (MinerInfo, error) {
-	info, err := s.State.GetInfo(s.store)
-	if err != nil {
-		return MinerInfo{}, err
-	}
-
-	var pid *peer.ID
-	if peerID, err := peer.IDFromBytes(info.PeerId); err == nil {
-		pid = &peerID
-	}
-
-	wpp, err := info.SealProofType.RegisteredWindowPoStProof()
-	if err != nil {
-		return MinerInfo{}, err
-	}
-
-	mi := MinerInfo{
-		Owner:            info.Owner,
-		Worker:           info.Worker,
-		ControlAddresses: info.ControlAddresses,
-
-		NewWorker:         address.Undef,
-		WorkerChangeEpoch: -1,
-
-		PeerId:                     pid,
-		Multiaddrs:                 info.Multiaddrs,
-		WindowPoStProofType:        wpp,
-		SectorSize:                 info.SectorSize,
-		WindowPoStPartitionSectors: info.WindowPoStPartitionSectors,
-		ConsensusFaultElapsed:      info.ConsensusFaultElapsed,
-	}
-
-	if info.PendingWorkerKey != nil {
-		mi.NewWorker = info.PendingWorkerKey.NewWorker
-		mi.WorkerChangeEpoch = info.PendingWorkerKey.EffectiveAt
-	}
-
-	return mi, nil
-}
-
-func (s *state2) DeadlineInfo(epoch abi.ChainEpoch) (*dline.Info, error) {
-	return s.State.DeadlineInfo(epoch), nil
-}
-
-func (s *state2) sectors() (adt.Array, error) {
-	return adt2.AsArray(s.store, s.Sectors)
-}
-
-func (s *state2) decodeSectorOnChainInfo(val *cbg.Deferred) (SectorOnChainInfo, error) {
-	var si miner2.SectorOnChainInfo
-	err := si.UnmarshalCBOR(bytes.NewReader(val.Raw))
-	if err != nil {
-		return SectorOnChainInfo{}, err
-	}
-
-	return fromV2SectorOnChainInfo(si), nil
-}
-
-func (s *state2) precommits() (adt.Map, error) {
-	return adt2.AsMap(s.store, s.PreCommittedSectors)
-}
-
-func (s *state2) decodeSectorPreCommitOnChainInfo(val *cbg.Deferred) (SectorPreCommitOnChainInfo, error) {
-	var sp miner2.SectorPreCommitOnChainInfo
-	err := sp.UnmarshalCBOR(bytes.NewReader(val.Raw))
-	if err != nil {
-		return SectorPreCommitOnChainInfo{}, err
-	}
-
-	return fromV2SectorPreCommitOnChainInfo(sp), nil
-}
-
-func (d *deadline2) LoadPartition(idx uint64) (Partition, error) {
-	p, err := d.Deadline.LoadPartition(d.store, idx)
-	if err != nil {
-		return nil, err
-	}
-	return &partition2{*p, d.store}, nil
-}
-
-func (d *deadline2) ForEachPartition(cb func(uint64, Partition) error) error {
-	ps, err := d.Deadline.PartitionsArray(d.store)
-	if err != nil {
-		return err
-	}
-	var part miner2.Partition
-	return ps.ForEach(&part, func(i int64) error {
-		return cb(uint64(i), &partition2{part, d.store})
-	})
-}
-
-func (d *deadline2) PartitionsChanged(other Deadline) (bool, error) {
-	other2, ok := other.(*deadline2)
-	if !ok {
-		// treat an upgrade as a change, always
-		return true, nil
-	}
-
-	return !d.Deadline.Partitions.Equals(other2.Deadline.Partitions), nil
-}
-
-func (d *deadline2) PartitionsPoSted() (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
-}
-
-func (p *partition2) FaultySectors() (bitfield.BitField, error) {
-	return p.Partition.Faults, nil
-}
-
-func (p *partition2) RecoveringSectors() (bitfield.BitField, error) {
-	return p.Partition.Recoveries, nil
-}
-
-func fromV2SectorOnChainInfo(v2 miner2.SectorOnChainInfo) SectorOnChainInfo {
-	return SectorOnChainInfo{
-		SectorNumber:          v2.SectorNumber,
-		SealProof:             v2.SealProof,
-		SealedCID:             v2.SealedCID,
-		DealIDs:               v2.DealIDs,
-		Activation:            v2.Activation,
-		Expiration:            v2.Expiration,
-		DealWeight:            v2.DealWeight,
-		VerifiedDealWeight:    v2.VerifiedDealWeight,
-		InitialPledge:         v2.InitialPledge,
-		ExpectedDayReward:     v2.ExpectedDayReward,
-		ExpectedStoragePledge: v2.ExpectedStoragePledge,
-	}
-}
-
-func fromV2SectorPreCommitOnChainInfo(v2 miner2.SectorPreCommitOnChainInfo) SectorPreCommitOnChainInfo {
-	return SectorPreCommitOnChainInfo{
-		Info:               (SectorPreCommitInfo)(v2.Info),
-		PreCommitDeposit:   v2.PreCommitDeposit,
-		PreCommitEpoch:     v2.PreCommitEpoch,
-		DealWeight:         v2.DealWeight,
-		VerifiedDealWeight: v2.VerifiedDealWeight,
-	}
-}
@@ -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,
-	}
-}
@@ -1,134 +0,0 @@
-package multisig
-
-import (
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/abi"
-	cbg "github.com/whyrusleeping/cbor-gen"
-
-	"github.com/filecoin-project/lotus/chain/actors/adt"
-)
-
-type PendingTransactionChanges struct {
-	Added    []TransactionChange
-	Modified []TransactionModification
-	Removed  []TransactionChange
-}
-
-type TransactionChange struct {
-	TxID int64
-	Tx   Transaction
-}
-
-type TransactionModification struct {
-	TxID int64
-	From Transaction
-	To   Transaction
-}
-
-func DiffPendingTransactions(pre, cur State) (*PendingTransactionChanges, error) {
-	results := new(PendingTransactionChanges)
-	if changed, err := pre.PendingTxnChanged(cur); err != nil {
-		return nil, err
-	} else if !changed { // if nothing has changed then return an empty result and bail.
-		return results, nil
-	}
-
-	pret, err := pre.transactions()
-	if err != nil {
-		return nil, err
-	}
-
-	curt, err := cur.transactions()
-	if err != nil {
-		return nil, err
-	}
-
-	if err := adt.DiffAdtMap(pret, curt, &transactionDiffer{results, pre, cur}); err != nil {
-		return nil, err
-	}
-	return results, nil
-}
-
-type transactionDiffer struct {
-	Results    *PendingTransactionChanges
-	pre, after State
-}
-
-func (t *transactionDiffer) AsKey(key string) (abi.Keyer, error) {
-	txID, err := abi.ParseIntKey(key)
-	if err != nil {
-		return nil, err
-	}
-	return abi.IntKey(txID), nil
-}
-
-func (t *transactionDiffer) Add(key string, val *cbg.Deferred) error {
-	txID, err := abi.ParseIntKey(key)
-	if err != nil {
-		return err
-	}
-	tx, err := t.after.decodeTransaction(val)
-	if err != nil {
-		return err
-	}
-	t.Results.Added = append(t.Results.Added, TransactionChange{
-		TxID: txID,
-		Tx:   tx,
-	})
-	return nil
-}
-
-func (t *transactionDiffer) Modify(key string, from, to *cbg.Deferred) error {
-	txID, err := abi.ParseIntKey(key)
-	if err != nil {
-		return err
-	}
-
-	txFrom, err := t.pre.decodeTransaction(from)
-	if err != nil {
-		return err
-	}
-
-	txTo, err := t.after.decodeTransaction(to)
-	if err != nil {
-		return err
-	}
-
-	if approvalsChanged(txFrom.Approved, txTo.Approved) {
-		t.Results.Modified = append(t.Results.Modified, TransactionModification{
-			TxID: txID,
-			From: txFrom,
-			To:   txTo,
-		})
-	}
-
-	return nil
-}
-
-func approvalsChanged(from, to []address.Address) bool {
-	if len(from) != len(to) {
-		return true
-	}
-	for idx := range from {
-		if from[idx] != to[idx] {
-			return true
-		}
-	}
-	return false
-}
-
-func (t *transactionDiffer) Remove(key string, val *cbg.Deferred) error {
-	txID, err := abi.ParseIntKey(key)
-	if err != nil {
-		return err
-	}
-	tx, err := t.pre.decodeTransaction(val)
-	if err != nil {
-		return err
-	}
-	t.Results.Removed = append(t.Results.Removed, TransactionChange{
-		TxID: txID,
-		Tx:   tx,
-	})
-	return nil
-}
@@ -1,76 +0,0 @@
-package multisig
-
-import (
-	"fmt"
-
-	"github.com/minio/blake2b-simd"
-	"golang.org/x/xerrors"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/abi"
-
-	builtin3 "github.com/filecoin-project/specs-actors/v3/actors/builtin"
-	multisig3 "github.com/filecoin-project/specs-actors/v3/actors/builtin/multisig"
-
-	"github.com/filecoin-project/lotus/chain/actors"
-	"github.com/filecoin-project/lotus/chain/types"
-)
-
-var Methods = builtin3.MethodsMultisig
-
-func Message(version actors.Version, from address.Address) MessageBuilder {
-	switch version {
-	case actors.Version0:
-		return message0{from}
-	case actors.Version2:
-		return message2{message0{from}}
-	case actors.Version3:
-		return message3{message0{from}}
-	default:
-		panic(fmt.Sprintf("unsupported actors version: %d", version))
-	}
-}
-
-type MessageBuilder interface {
-	// Create a new multisig with the specified parameters.
-	Create(signers []address.Address, threshold uint64,
-		vestingStart, vestingDuration abi.ChainEpoch,
-		initialAmount abi.TokenAmount) (*types.Message, error)
-
-	// Propose a transaction to the given multisig.
-	Propose(msig, target address.Address, amt abi.TokenAmount,
-		method abi.MethodNum, params []byte) (*types.Message, error)
-
-	// Approve a multisig transaction. The "hash" is optional.
-	Approve(msig address.Address, txID uint64, hash *ProposalHashData) (*types.Message, error)
-
-	// Cancel a multisig transaction. The "hash" is optional.
-	Cancel(msig address.Address, txID uint64, hash *ProposalHashData) (*types.Message, error)
-}
-
-// this type is the same between v0 and v2
-type ProposalHashData = multisig3.ProposalHashData
-type ProposeReturn = multisig3.ProposeReturn
-
-func txnParams(id uint64, data *ProposalHashData) ([]byte, error) {
-	params := multisig3.TxnIDParams{ID: multisig3.TxnID(id)}
-	if data != nil {
-		if data.Requester.Protocol() != address.ID {
-			return nil, xerrors.Errorf("proposer address must be an ID address, was %s", data.Requester)
-		}
-		if data.Value.Sign() == -1 {
-			return nil, xerrors.Errorf("proposal value must be non-negative, was %s", data.Value)
-		}
-		if data.To == address.Undef {
-			return nil, xerrors.Errorf("proposed destination address must be set")
-		}
-		pser, err := data.Serialize()
-		if err != nil {
-			return nil, err
-		}
-		hash := blake2b.Sum256(pser)
-		params.ProposalHash = hash[:]
-	}
-
-	return actors.SerializeParams(&params)
-}
@@ -1,142 +0,0 @@
-package multisig
-
-import (
-	"golang.org/x/xerrors"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/abi"
-
-	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
-	init0 "github.com/filecoin-project/specs-actors/actors/builtin/init"
-	multisig0 "github.com/filecoin-project/specs-actors/actors/builtin/multisig"
-
-	"github.com/filecoin-project/lotus/chain/actors"
-	init_ "github.com/filecoin-project/lotus/chain/actors/builtin/init"
-	"github.com/filecoin-project/lotus/chain/types"
-)
-
-type message0 struct{ from address.Address }
-
-func (m message0) Create(
-	signers []address.Address, threshold uint64,
-	unlockStart, unlockDuration abi.ChainEpoch,
-	initialAmount abi.TokenAmount,
-) (*types.Message, error) {
-
-	lenAddrs := uint64(len(signers))
-
-	if lenAddrs < threshold {
-		return nil, xerrors.Errorf("cannot require signing of more addresses than provided for multisig")
-	}
-
-	if threshold == 0 {
-		threshold = lenAddrs
-	}
-
-	if m.from == address.Undef {
-		return nil, xerrors.Errorf("must provide source address")
-	}
-
-	if unlockStart != 0 {
-		return nil, xerrors.Errorf("actors v0 does not support a non-zero vesting start time")
-	}
-
-	// Set up constructor parameters for multisig
-	msigParams := &multisig0.ConstructorParams{
-		Signers:               signers,
-		NumApprovalsThreshold: threshold,
-		UnlockDuration:        unlockDuration,
-	}
-
-	enc, actErr := actors.SerializeParams(msigParams)
-	if actErr != nil {
-		return nil, actErr
-	}
-
-	// new actors are created by invoking 'exec' on the init actor with the constructor params
-	execParams := &init0.ExecParams{
-		CodeCID:           builtin0.MultisigActorCodeID,
-		ConstructorParams: enc,
-	}
-
-	enc, actErr = actors.SerializeParams(execParams)
-	if actErr != nil {
-		return nil, actErr
-	}
-
-	return &types.Message{
-		To:     init_.Address,
-		From:   m.from,
-		Method: builtin0.MethodsInit.Exec,
-		Params: enc,
-		Value:  initialAmount,
-	}, nil
-}
-
-func (m message0) Propose(msig, to address.Address, amt abi.TokenAmount,
-	method abi.MethodNum, params []byte) (*types.Message, error) {
-
-	if msig == address.Undef {
-		return nil, xerrors.Errorf("must provide a multisig address for proposal")
-	}
-
-	if to == address.Undef {
-		return nil, xerrors.Errorf("must provide a target address for proposal")
-	}
-
-	if amt.Sign() == -1 {
-		return nil, xerrors.Errorf("must provide a non-negative amount for proposed send")
-	}
-
-	if m.from == address.Undef {
-		return nil, xerrors.Errorf("must provide source address")
-	}
-
-	enc, actErr := actors.SerializeParams(&multisig0.ProposeParams{
-		To:     to,
-		Value:  amt,
-		Method: method,
-		Params: params,
-	})
-	if actErr != nil {
-		return nil, xerrors.Errorf("failed to serialize parameters: %w", actErr)
-	}
-
-	return &types.Message{
-		To:     msig,
-		From:   m.from,
-		Value:  abi.NewTokenAmount(0),
-		Method: builtin0.MethodsMultisig.Propose,
-		Params: enc,
-	}, nil
-}
-
-func (m message0) Approve(msig address.Address, txID uint64, hashData *ProposalHashData) (*types.Message, error) {
-	enc, err := txnParams(txID, hashData)
-	if err != nil {
-		return nil, err
-	}
-
-	return &types.Message{
-		To:     msig,
-		From:   m.from,
-		Value:  types.NewInt(0),
-		Method: builtin0.MethodsMultisig.Approve,
-		Params: enc,
-	}, nil
-}
-
-func (m message0) Cancel(msig address.Address, txID uint64, hashData *ProposalHashData) (*types.Message, error) {
-	enc, err := txnParams(txID, hashData)
-	if err != nil {
-		return nil, err
-	}
-
-	return &types.Message{
-		To:     msig,
-		From:   m.from,
-		Value:  types.NewInt(0),
-		Method: builtin0.MethodsMultisig.Cancel,
-		Params: enc,
-	}, nil
-}
@@ -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"
-
-	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
-	init2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/init"
-	multisig2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/multisig"
-
-	"github.com/filecoin-project/lotus/chain/actors"
-	init_ "github.com/filecoin-project/lotus/chain/actors/builtin/init"
-	"github.com/filecoin-project/lotus/chain/types"
-)
-
-type message2 struct{ message0 }
-
-func (m message2) Create(
-	signers []address.Address, threshold uint64,
-	unlockStart, unlockDuration abi.ChainEpoch,
-	initialAmount abi.TokenAmount,
-) (*types.Message, error) {
-
-	lenAddrs := uint64(len(signers))
-
-	if lenAddrs < threshold {
-		return nil, xerrors.Errorf("cannot require signing of more addresses than provided for multisig")
-	}
-
-	if threshold == 0 {
-		threshold = lenAddrs
-	}
-
-	if m.from == address.Undef {
-		return nil, xerrors.Errorf("must provide source address")
-	}
-
-	// Set up constructor parameters for multisig
-	msigParams := &multisig2.ConstructorParams{
-		Signers:               signers,
-		NumApprovalsThreshold: threshold,
-		UnlockDuration:        unlockDuration,
-		StartEpoch:            unlockStart,
-	}
-
-	enc, actErr := actors.SerializeParams(msigParams)
-	if actErr != nil {
-		return nil, actErr
-	}
-
-	// new actors are created by invoking 'exec' on the init actor with the constructor params
-	execParams := &init2.ExecParams{
-		CodeCID:           builtin2.MultisigActorCodeID,
-		ConstructorParams: enc,
-	}
-
-	enc, actErr = actors.SerializeParams(execParams)
-	if actErr != nil {
-		return nil, actErr
-	}
-
-	return &types.Message{
-		To:     init_.Address,
-		From:   m.from,
-		Method: builtin2.MethodsInit.Exec,
-		Params: enc,
-		Value:  initialAmount,
-	}, nil
-}
@@ -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
-}
@@ -1,63 +0,0 @@
-package multisig
-
-import (
-	cbg "github.com/whyrusleeping/cbor-gen"
-	"golang.org/x/xerrors"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/go-state-types/cbor"
-	"github.com/ipfs/go-cid"
-
-	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
-	msig0 "github.com/filecoin-project/specs-actors/actors/builtin/multisig"
-	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
-	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"
-	"github.com/filecoin-project/lotus/chain/types"
-)
-
-func init() {
-	builtin.RegisterActorState(builtin0.MultisigActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
-		return load0(store, root)
-	})
-	builtin.RegisterActorState(builtin2.MultisigActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
-		return load2(store, root)
-	})
-	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) {
-	switch act.Code {
-	case builtin0.MultisigActorCodeID:
-		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)
-}
-
-type State interface {
-	cbor.Marshaler
-
-	LockedBalance(epoch abi.ChainEpoch) (abi.TokenAmount, error)
-	StartEpoch() (abi.ChainEpoch, error)
-	UnlockDuration() (abi.ChainEpoch, error)
-	InitialBalance() (abi.TokenAmount, error)
-	Threshold() (uint64, error)
-	Signers() ([]address.Address, error)
-
-	ForEachPendingTxn(func(id int64, txn Transaction) error) error
-	PendingTxnChanged(State) (bool, error)
-
-	transactions() (adt.Map, error)
-	decodeTransaction(val *cbg.Deferred) (Transaction, error)
-}
-
-type Transaction = msig0.Transaction
@@ -1,94 +0,0 @@
-package multisig
-
-import (
-	"bytes"
-	"encoding/binary"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/ipfs/go-cid"
-	cbg "github.com/whyrusleeping/cbor-gen"
-	"golang.org/x/xerrors"
-
-	"github.com/filecoin-project/lotus/chain/actors/adt"
-
-	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"
-)
-
-var _ State = (*state0)(nil)
-
-func load0(store adt.Store, root cid.Cid) (State, error) {
-	out := state0{store: store}
-	err := store.Get(store.Context(), root, &out)
-	if err != nil {
-		return nil, err
-	}
-	return &out, nil
-}
-
-type state0 struct {
-	msig0.State
-	store adt.Store
-}
-
-func (s *state0) LockedBalance(currEpoch abi.ChainEpoch) (abi.TokenAmount, error) {
-	return s.State.AmountLocked(currEpoch - s.State.StartEpoch), nil
-}
-
-func (s *state0) StartEpoch() (abi.ChainEpoch, error) {
-	return s.State.StartEpoch, nil
-}
-
-func (s *state0) UnlockDuration() (abi.ChainEpoch, error) {
-	return s.State.UnlockDuration, nil
-}
-
-func (s *state0) InitialBalance() (abi.TokenAmount, error) {
-	return s.State.InitialBalance, nil
-}
-
-func (s *state0) Threshold() (uint64, error) {
-	return s.State.NumApprovalsThreshold, nil
-}
-
-func (s *state0) Signers() ([]address.Address, error) {
-	return s.State.Signers, nil
-}
-
-func (s *state0) ForEachPendingTxn(cb func(id int64, txn Transaction) error) error {
-	arr, err := adt0.AsMap(s.store, s.State.PendingTxns)
-	if err != nil {
-		return err
-	}
-	var out msig0.Transaction
-	return arr.ForEach(&out, func(key string) error {
-		txid, n := binary.Varint([]byte(key))
-		if n <= 0 {
-			return xerrors.Errorf("invalid pending transaction key: %v", key)
-		}
-		return cb(txid, (Transaction)(out))
-	})
-}
-
-func (s *state0) PendingTxnChanged(other State) (bool, error) {
-	other0, ok := other.(*state0)
-	if !ok {
-		// treat an upgrade as a change, always
-		return true, nil
-	}
-	return !s.State.PendingTxns.Equals(other0.PendingTxns), nil
-}
-
-func (s *state0) transactions() (adt.Map, error) {
-	return adt0.AsMap(s.store, s.PendingTxns)
-}
-
-func (s *state0) decodeTransaction(val *cbg.Deferred) (Transaction, error) {
-	var tx multisig0.Transaction
-	if err := tx.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil {
-		return Transaction{}, err
-	}
-	return tx, nil
-}
@@ -1,93 +0,0 @@
-package multisig
-
-import (
-	"bytes"
-	"encoding/binary"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/ipfs/go-cid"
-	cbg "github.com/whyrusleeping/cbor-gen"
-	"golang.org/x/xerrors"
-
-	"github.com/filecoin-project/lotus/chain/actors/adt"
-
-	msig2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/multisig"
-	adt2 "github.com/filecoin-project/specs-actors/v2/actors/util/adt"
-)
-
-var _ State = (*state2)(nil)
-
-func load2(store adt.Store, root cid.Cid) (State, error) {
-	out := state2{store: store}
-	err := store.Get(store.Context(), root, &out)
-	if err != nil {
-		return nil, err
-	}
-	return &out, nil
-}
-
-type state2 struct {
-	msig2.State
-	store adt.Store
-}
-
-func (s *state2) LockedBalance(currEpoch abi.ChainEpoch) (abi.TokenAmount, error) {
-	return s.State.AmountLocked(currEpoch - s.State.StartEpoch), nil
-}
-
-func (s *state2) StartEpoch() (abi.ChainEpoch, error) {
-	return s.State.StartEpoch, nil
-}
-
-func (s *state2) UnlockDuration() (abi.ChainEpoch, error) {
-	return s.State.UnlockDuration, nil
-}
-
-func (s *state2) InitialBalance() (abi.TokenAmount, error) {
-	return s.State.InitialBalance, nil
-}
-
-func (s *state2) Threshold() (uint64, error) {
-	return s.State.NumApprovalsThreshold, nil
-}
-
-func (s *state2) Signers() ([]address.Address, error) {
-	return s.State.Signers, nil
-}
-
-func (s *state2) ForEachPendingTxn(cb func(id int64, txn Transaction) error) error {
-	arr, err := adt2.AsMap(s.store, s.State.PendingTxns)
-	if err != nil {
-		return err
-	}
-	var out msig2.Transaction
-	return arr.ForEach(&out, func(key string) error {
-		txid, n := binary.Varint([]byte(key))
-		if n <= 0 {
-			return xerrors.Errorf("invalid pending transaction key: %v", key)
-		}
-		return cb(txid, (Transaction)(out))
-	})
-}
-
-func (s *state2) PendingTxnChanged(other State) (bool, error) {
-	other2, ok := other.(*state2)
-	if !ok {
-		// treat an upgrade as a change, always
-		return true, nil
-	}
-	return !s.State.PendingTxns.Equals(other2.PendingTxns), nil
-}
-
-func (s *state2) transactions() (adt.Map, error) {
-	return adt2.AsMap(s.store, s.PendingTxns)
-}
-
-func (s *state2) decodeTransaction(val *cbg.Deferred) (Transaction, error) {
-	var tx msig2.Transaction
-	if err := tx.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil {
-		return Transaction{}, err
-	}
-	return tx, nil
-}
@@ -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
-}
@@ -1,34 +0,0 @@
-package paych
-
-import (
-	"fmt"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/lotus/chain/actors"
-	"github.com/filecoin-project/lotus/chain/types"
-
-	builtin3 "github.com/filecoin-project/specs-actors/v3/actors/builtin"
-)
-
-var Methods = builtin3.MethodsPaych
-
-func Message(version actors.Version, from address.Address) MessageBuilder {
-	switch version {
-	case actors.Version0:
-		return message0{from}
-	case actors.Version2:
-		return message2{from}
-	case actors.Version3:
-		return message3{from}
-	default:
-		panic(fmt.Sprintf("unsupported actors version: %d", version))
-	}
-}
-
-type MessageBuilder interface {
-	Create(to address.Address, initialAmount abi.TokenAmount) (*types.Message, error)
-	Update(paych address.Address, voucher *SignedVoucher, secret []byte) (*types.Message, error)
-	Settle(paych address.Address) (*types.Message, error)
-	Collect(paych address.Address) (*types.Message, error)
-}
@@ -1,74 +0,0 @@
-package paych
-
-import (
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/abi"
-
-	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
-	init0 "github.com/filecoin-project/specs-actors/actors/builtin/init"
-	paych0 "github.com/filecoin-project/specs-actors/actors/builtin/paych"
-
-	"github.com/filecoin-project/lotus/chain/actors"
-	init_ "github.com/filecoin-project/lotus/chain/actors/builtin/init"
-	"github.com/filecoin-project/lotus/chain/types"
-)
-
-type message0 struct{ from address.Address }
-
-func (m message0) Create(to address.Address, initialAmount abi.TokenAmount) (*types.Message, error) {
-	params, aerr := actors.SerializeParams(&paych0.ConstructorParams{From: m.from, To: to})
-	if aerr != nil {
-		return nil, aerr
-	}
-	enc, aerr := actors.SerializeParams(&init0.ExecParams{
-		CodeCID:           builtin0.PaymentChannelActorCodeID,
-		ConstructorParams: params,
-	})
-	if aerr != nil {
-		return nil, aerr
-	}
-
-	return &types.Message{
-		To:     init_.Address,
-		From:   m.from,
-		Value:  initialAmount,
-		Method: builtin0.MethodsInit.Exec,
-		Params: enc,
-	}, nil
-}
-
-func (m message0) Update(paych address.Address, sv *SignedVoucher, secret []byte) (*types.Message, error) {
-	params, aerr := actors.SerializeParams(&paych0.UpdateChannelStateParams{
-		Sv:     *sv,
-		Secret: secret,
-	})
-	if aerr != nil {
-		return nil, aerr
-	}
-
-	return &types.Message{
-		To:     paych,
-		From:   m.from,
-		Value:  abi.NewTokenAmount(0),
-		Method: builtin0.MethodsPaych.UpdateChannelState,
-		Params: params,
-	}, nil
-}
-
-func (m message0) Settle(paych address.Address) (*types.Message, error) {
-	return &types.Message{
-		To:     paych,
-		From:   m.from,
-		Value:  abi.NewTokenAmount(0),
-		Method: builtin0.MethodsPaych.Settle,
-	}, nil
-}
-
-func (m message0) Collect(paych address.Address) (*types.Message, error) {
-	return &types.Message{
-		To:     paych,
-		From:   m.from,
-		Value:  abi.NewTokenAmount(0),
-		Method: builtin0.MethodsPaych.Collect,
-	}, nil
-}
@@ -1,74 +0,0 @@
-package paych
-
-import (
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/abi"
-
-	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
-	init2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/init"
-	paych2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/paych"
-
-	"github.com/filecoin-project/lotus/chain/actors"
-	init_ "github.com/filecoin-project/lotus/chain/actors/builtin/init"
-	"github.com/filecoin-project/lotus/chain/types"
-)
-
-type message2 struct{ from address.Address }
-
-func (m message2) Create(to address.Address, initialAmount abi.TokenAmount) (*types.Message, error) {
-	params, aerr := actors.SerializeParams(&paych2.ConstructorParams{From: m.from, To: to})
-	if aerr != nil {
-		return nil, aerr
-	}
-	enc, aerr := actors.SerializeParams(&init2.ExecParams{
-		CodeCID:           builtin2.PaymentChannelActorCodeID,
-		ConstructorParams: params,
-	})
-	if aerr != nil {
-		return nil, aerr
-	}
-
-	return &types.Message{
-		To:     init_.Address,
-		From:   m.from,
-		Value:  initialAmount,
-		Method: builtin2.MethodsInit.Exec,
-		Params: enc,
-	}, nil
-}
-
-func (m message2) Update(paych address.Address, sv *SignedVoucher, secret []byte) (*types.Message, error) {
-	params, aerr := actors.SerializeParams(&paych2.UpdateChannelStateParams{
-		Sv:     *sv,
-		Secret: secret,
-	})
-	if aerr != nil {
-		return nil, aerr
-	}
-
-	return &types.Message{
-		To:     paych,
-		From:   m.from,
-		Value:  abi.NewTokenAmount(0),
-		Method: builtin2.MethodsPaych.UpdateChannelState,
-		Params: params,
-	}, nil
-}
-
-func (m message2) Settle(paych address.Address) (*types.Message, error) {
-	return &types.Message{
-		To:     paych,
-		From:   m.from,
-		Value:  abi.NewTokenAmount(0),
-		Method: builtin2.MethodsPaych.Settle,
-	}, nil
-}
-
-func (m message2) Collect(paych address.Address) (*types.Message, error) {
-	return &types.Message{
-		To:     paych,
-		From:   m.from,
-		Value:  abi.NewTokenAmount(0),
-		Method: builtin2.MethodsPaych.Collect,
-	}, nil
-}
@@ -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
-}
@@ -1,88 +0,0 @@
-package mock
-
-import (
-	"io"
-
-	"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/builtin/paych"
-)
-
-type mockState struct {
-	from       address.Address
-	to         address.Address
-	settlingAt abi.ChainEpoch
-	toSend     abi.TokenAmount
-	lanes      map[uint64]paych.LaneState
-}
-
-type mockLaneState struct {
-	redeemed big.Int
-	nonce    uint64
-}
-
-// NewMockPayChState constructs a state for a payment channel with the set fixed values
-// that satisfies the paych.State interface.
-func NewMockPayChState(from address.Address,
-	to address.Address,
-	settlingAt abi.ChainEpoch,
-	lanes map[uint64]paych.LaneState,
-) paych.State {
-	return &mockState{from: from, to: to, settlingAt: settlingAt, toSend: big.NewInt(0), lanes: lanes}
-}
-
-// NewMockLaneState constructs a state for a payment channel lane with the set fixed values
-// that satisfies the paych.LaneState interface. Useful for populating lanes when
-// calling NewMockPayChState
-func NewMockLaneState(redeemed big.Int, nonce uint64) paych.LaneState {
-	return &mockLaneState{redeemed, nonce}
-}
-
-func (ms *mockState) MarshalCBOR(io.Writer) error {
-	panic("not implemented")
-}
-
-// Channel owner, who has funded the actor
-func (ms *mockState) From() (address.Address, error) {
-	return ms.from, nil
-}
-
-// Recipient of payouts from channel
-func (ms *mockState) To() (address.Address, error) {
-	return ms.to, nil
-}
-
-// Height at which the channel can be `Collected`
-func (ms *mockState) SettlingAt() (abi.ChainEpoch, error) {
-	return ms.settlingAt, nil
-}
-
-// Amount successfully redeemed through the payment channel, paid out on `Collect()`
-func (ms *mockState) ToSend() (abi.TokenAmount, error) {
-	return ms.toSend, nil
-}
-
-// Get total number of lanes
-func (ms *mockState) LaneCount() (uint64, error) {
-	return uint64(len(ms.lanes)), nil
-}
-
-// Iterate lane states
-func (ms *mockState) ForEachLaneState(cb func(idx uint64, dl paych.LaneState) error) error {
-	var lastErr error
-	for lane, state := range ms.lanes {
-		if err := cb(lane, state); err != nil {
-			lastErr = err
-		}
-	}
-	return lastErr
-}
-
-func (mls *mockLaneState) Redeemed() (big.Int, error) {
-	return mls.redeemed, nil
-}
-
-func (mls *mockLaneState) Nonce() (uint64, error) {
-	return mls.nonce, nil
-}
@@ -1,94 +0,0 @@
-package paych
-
-import (
-	"encoding/base64"
-
-	"golang.org/x/xerrors"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/abi"
-	big "github.com/filecoin-project/go-state-types/big"
-	"github.com/filecoin-project/go-state-types/cbor"
-	"github.com/ipfs/go-cid"
-	ipldcbor "github.com/ipfs/go-ipld-cbor"
-
-	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
-	paych0 "github.com/filecoin-project/specs-actors/actors/builtin/paych"
-	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
-	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"
-	"github.com/filecoin-project/lotus/chain/types"
-)
-
-func init() {
-	builtin.RegisterActorState(builtin0.PaymentChannelActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
-		return load0(store, root)
-	})
-	builtin.RegisterActorState(builtin2.PaymentChannelActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
-		return load2(store, root)
-	})
-	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
-func Load(store adt.Store, act *types.Actor) (State, error) {
-	switch act.Code {
-	case builtin0.PaymentChannelActorCodeID:
-		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)
-}
-
-// State is an abstract version of payment channel state that works across
-// versions
-type State interface {
-	cbor.Marshaler
-	// Channel owner, who has funded the actor
-	From() (address.Address, error)
-	// Recipient of payouts from channel
-	To() (address.Address, error)
-
-	// Height at which the channel can be `Collected`
-	SettlingAt() (abi.ChainEpoch, error)
-
-	// Amount successfully redeemed through the payment channel, paid out on `Collect()`
-	ToSend() (abi.TokenAmount, error)
-
-	// Get total number of lanes
-	LaneCount() (uint64, error)
-
-	// Iterate lane states
-	ForEachLaneState(cb func(idx uint64, dl LaneState) error) error
-}
-
-// LaneState is an abstract copy of the state of a single lane
-type LaneState interface {
-	Redeemed() (big.Int, error)
-	Nonce() (uint64, error)
-}
-
-type SignedVoucher = paych0.SignedVoucher
-type ModVerifyParams = paych0.ModVerifyParams
-
-// DecodeSignedVoucher decodes base64 encoded signed voucher.
-func DecodeSignedVoucher(s string) (*SignedVoucher, error) {
-	data, err := base64.RawURLEncoding.DecodeString(s)
-	if err != nil {
-		return nil, err
-	}
-
-	var sv SignedVoucher
-	if err := ipldcbor.DecodeInto(data, &sv); err != nil {
-		return nil, err
-	}
-
-	return &sv, nil
-}
@@ -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"
-
-	paych0 "github.com/filecoin-project/specs-actors/actors/builtin/paych"
-	adt0 "github.com/filecoin-project/specs-actors/actors/util/adt"
-)
-
-var _ State = (*state0)(nil)
-
-func load0(store adt.Store, root cid.Cid) (State, error) {
-	out := state0{store: store}
-	err := store.Get(store.Context(), root, &out)
-	if err != nil {
-		return nil, err
-	}
-	return &out, nil
-}
-
-type state0 struct {
-	paych0.State
-	store adt.Store
-	lsAmt *adt0.Array
-}
-
-// Channel owner, who has funded the actor
-func (s *state0) From() (address.Address, error) {
-	return s.State.From, nil
-}
-
-// Recipient of payouts from channel
-func (s *state0) To() (address.Address, error) {
-	return s.State.To, nil
-}
-
-// Height at which the channel can be `Collected`
-func (s *state0) SettlingAt() (abi.ChainEpoch, error) {
-	return s.State.SettlingAt, nil
-}
-
-// Amount successfully redeemed through the payment channel, paid out on `Collect()`
-func (s *state0) ToSend() (abi.TokenAmount, error) {
-	return s.State.ToSend, nil
-}
-
-func (s *state0) getOrLoadLsAmt() (*adt0.Array, error) {
-	if s.lsAmt != nil {
-		return s.lsAmt, nil
-	}
-
-	// Get the lane state from the chain
-	lsamt, err := adt0.AsArray(s.store, s.State.LaneStates)
-	if err != nil {
-		return nil, err
-	}
-
-	s.lsAmt = lsamt
-	return lsamt, nil
-}
-
-// Get total number of lanes
-func (s *state0) LaneCount() (uint64, error) {
-	lsamt, err := s.getOrLoadLsAmt()
-	if err != nil {
-		return 0, err
-	}
-	return lsamt.Length(), nil
-}
-
-// Iterate lane states
-func (s *state0) 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 paych0.LaneState
-	return lsamt.ForEach(&ls, func(i int64) error {
-		return cb(uint64(i), &laneState0{ls})
-	})
-}
-
-type laneState0 struct {
-	paych0.LaneState
-}
-
-func (ls *laneState0) Redeemed() (big.Int, error) {
-	return ls.LaneState.Redeemed, nil
-}
-
-func (ls *laneState0) Nonce() (uint64, error) {
-	return ls.LaneState.Nonce, nil
-}
@@ -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"
-
-	paych2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/paych"
-	adt2 "github.com/filecoin-project/specs-actors/v2/actors/util/adt"
-)
-
-var _ State = (*state2)(nil)
-
-func load2(store adt.Store, root cid.Cid) (State, error) {
-	out := state2{store: store}
-	err := store.Get(store.Context(), root, &out)
-	if err != nil {
-		return nil, err
-	}
-	return &out, nil
-}
-
-type state2 struct {
-	paych2.State
-	store adt.Store
-	lsAmt *adt2.Array
-}
-
-// Channel owner, who has funded the actor
-func (s *state2) From() (address.Address, error) {
-	return s.State.From, nil
-}
-
-// Recipient of payouts from channel
-func (s *state2) To() (address.Address, error) {
-	return s.State.To, nil
-}
-
-// Height at which the channel can be `Collected`
-func (s *state2) SettlingAt() (abi.ChainEpoch, error) {
-	return s.State.SettlingAt, nil
-}
-
-// Amount successfully redeemed through the payment channel, paid out on `Collect()`
-func (s *state2) ToSend() (abi.TokenAmount, error) {
-	return s.State.ToSend, nil
-}
-
-func (s *state2) getOrLoadLsAmt() (*adt2.Array, error) {
-	if s.lsAmt != nil {
-		return s.lsAmt, nil
-	}
-
-	// Get the lane state from the chain
-	lsamt, err := adt2.AsArray(s.store, s.State.LaneStates)
-	if err != nil {
-		return nil, err
-	}
-
-	s.lsAmt = lsamt
-	return lsamt, nil
-}
-
-// Get total number of lanes
-func (s *state2) LaneCount() (uint64, error) {
-	lsamt, err := s.getOrLoadLsAmt()
-	if err != nil {
-		return 0, err
-	}
-	return lsamt.Length(), nil
-}
-
-// Iterate lane states
-func (s *state2) ForEachLaneState(cb func(idx uint64, dl LaneState) error) error {
-	// Get the lane state from the chain
-	lsamt, err := s.getOrLoadLsAmt()
-	if err != nil {
-		return err
-	}
-
-	// Note: we use a map instead of an array to store laneStates because the
-	// client sets the lane ID (the index) and potentially they could use a
-	// very large index.
-	var ls paych2.LaneState
-	return lsamt.ForEach(&ls, func(i int64) error {
-		return cb(uint64(i), &laneState2{ls})
-	})
-}
-
-type laneState2 struct {
-	paych2.LaneState
-}
-
-func (ls *laneState2) Redeemed() (big.Int, error) {
-	return ls.LaneState.Redeemed, nil
-}
-
-func (ls *laneState2) Nonce() (uint64, error) {
-	return ls.LaneState.Nonce, nil
-}
@@ -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
-}
@@ -1,117 +0,0 @@
-package power
-
-import (
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/abi"
-	cbg "github.com/whyrusleeping/cbor-gen"
-
-	"github.com/filecoin-project/lotus/chain/actors/adt"
-)
-
-type ClaimChanges struct {
-	Added    []ClaimInfo
-	Modified []ClaimModification
-	Removed  []ClaimInfo
-}
-
-type ClaimModification struct {
-	Miner address.Address
-	From  Claim
-	To    Claim
-}
-
-type ClaimInfo struct {
-	Miner address.Address
-	Claim Claim
-}
-
-func DiffClaims(pre, cur State) (*ClaimChanges, error) {
-	results := new(ClaimChanges)
-
-	prec, err := pre.claims()
-	if err != nil {
-		return nil, err
-	}
-
-	curc, err := cur.claims()
-	if err != nil {
-		return nil, err
-	}
-
-	if err := adt.DiffAdtMap(prec, curc, &claimDiffer{results, pre, cur}); err != nil {
-		return nil, err
-	}
-
-	return results, nil
-}
-
-type claimDiffer struct {
-	Results    *ClaimChanges
-	pre, after State
-}
-
-func (c *claimDiffer) AsKey(key string) (abi.Keyer, error) {
-	addr, err := address.NewFromBytes([]byte(key))
-	if err != nil {
-		return nil, err
-	}
-	return abi.AddrKey(addr), nil
-}
-
-func (c *claimDiffer) Add(key string, val *cbg.Deferred) error {
-	ci, err := c.after.decodeClaim(val)
-	if err != nil {
-		return err
-	}
-	addr, err := address.NewFromBytes([]byte(key))
-	if err != nil {
-		return err
-	}
-	c.Results.Added = append(c.Results.Added, ClaimInfo{
-		Miner: addr,
-		Claim: ci,
-	})
-	return nil
-}
-
-func (c *claimDiffer) Modify(key string, from, to *cbg.Deferred) error {
-	ciFrom, err := c.pre.decodeClaim(from)
-	if err != nil {
-		return err
-	}
-
-	ciTo, err := c.after.decodeClaim(to)
-	if err != nil {
-		return err
-	}
-
-	addr, err := address.NewFromBytes([]byte(key))
-	if err != nil {
-		return err
-	}
-
-	if ciFrom != ciTo {
-		c.Results.Modified = append(c.Results.Modified, ClaimModification{
-			Miner: addr,
-			From:  ciFrom,
-			To:    ciTo,
-		})
-	}
-	return nil
-}
-
-func (c *claimDiffer) Remove(key string, val *cbg.Deferred) error {
-	ci, err := c.after.decodeClaim(val)
-	if err != nil {
-		return err
-	}
-	addr, err := address.NewFromBytes([]byte(key))
-	if err != nil {
-		return err
-	}
-	c.Results.Removed = append(c.Results.Removed, ClaimInfo{
-		Miner: addr,
-		Claim: ci,
-	})
-	return nil
-}
@@ -1,86 +0,0 @@
-package power
-
-import (
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/big"
-	"github.com/ipfs/go-cid"
-	cbg "github.com/whyrusleeping/cbor-gen"
-	"golang.org/x/xerrors"
-
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/go-state-types/cbor"
-
-	"github.com/filecoin-project/lotus/chain/actors/adt"
-	"github.com/filecoin-project/lotus/chain/actors/builtin"
-	"github.com/filecoin-project/lotus/chain/types"
-
-	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
-	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
-	builtin3 "github.com/filecoin-project/specs-actors/v3/actors/builtin"
-)
-
-func init() {
-	builtin.RegisterActorState(builtin0.StoragePowerActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
-		return load0(store, root)
-	})
-	builtin.RegisterActorState(builtin2.StoragePowerActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
-		return load2(store, root)
-	})
-	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
-)
-
-func Load(store adt.Store, act *types.Actor) (st State, err error) {
-	switch act.Code {
-	case builtin0.StoragePowerActorCodeID:
-		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)
-}
-
-type State interface {
-	cbor.Marshaler
-
-	TotalLocked() (abi.TokenAmount, error)
-	TotalPower() (Claim, error)
-	TotalCommitted() (Claim, error)
-	TotalPowerSmoothed() (builtin.FilterEstimate, error)
-
-	// MinerCounts returns the number of miners. Participating is the number
-	// with power above the minimum miner threshold.
-	MinerCounts() (participating, total uint64, err error)
-	MinerPower(address.Address) (Claim, bool, error)
-	MinerNominalPowerMeetsConsensusMinimum(address.Address) (bool, error)
-	ListAllMiners() ([]address.Address, error)
-	ForEachClaim(func(miner address.Address, claim Claim) error) error
-	ClaimsChanged(State) (bool, error)
-
-	// Diff helpers. Used by Diff* functions internally.
-	claims() (adt.Map, error)
-	decodeClaim(*cbg.Deferred) (Claim, error)
-}
-
-type Claim struct {
-	// Sum of raw byte power for a miner's sectors.
-	RawBytePower abi.StoragePower
-
-	// Sum of quality adjusted power for a miner's sectors.
-	QualityAdjPower abi.StoragePower
-}
-
-func AddClaims(a Claim, b Claim) Claim {
-	return Claim{
-		RawBytePower:    big.Add(a.RawBytePower, b.RawBytePower),
-		QualityAdjPower: big.Add(a.QualityAdjPower, b.QualityAdjPower),
-	}
-}
@@ -1,145 +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"
-
-	power0 "github.com/filecoin-project/specs-actors/actors/builtin/power"
-	adt0 "github.com/filecoin-project/specs-actors/actors/util/adt"
-)
-
-var _ State = (*state0)(nil)
-
-func load0(store adt.Store, root cid.Cid) (State, error) {
-	out := state0{store: store}
-	err := store.Get(store.Context(), root, &out)
-	if err != nil {
-		return nil, err
-	}
-	return &out, nil
-}
-
-type state0 struct {
-	power0.State
-	store adt.Store
-}
-
-func (s *state0) TotalLocked() (abi.TokenAmount, error) {
-	return s.TotalPledgeCollateral, nil
-}
-
-func (s *state0) 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 *state0) TotalCommitted() (Claim, error) {
-	return Claim{
-		RawBytePower:    s.TotalBytesCommitted,
-		QualityAdjPower: s.TotalQABytesCommitted,
-	}, nil
-}
-
-func (s *state0) MinerPower(addr address.Address) (Claim, bool, error) {
-	claims, err := adt0.AsMap(s.store, s.Claims)
-	if err != nil {
-		return Claim{}, false, err
-	}
-	var claim power0.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 *state0) MinerNominalPowerMeetsConsensusMinimum(a address.Address) (bool, error) {
-	return s.State.MinerNominalPowerMeetsConsensusMinimum(s.store, a)
-}
-
-func (s *state0) TotalPowerSmoothed() (builtin.FilterEstimate, error) {
-	return builtin.FromV0FilterEstimate(*s.State.ThisEpochQAPowerSmoothed), nil
-}
-
-func (s *state0) MinerCounts() (uint64, uint64, error) {
-	return uint64(s.State.MinerAboveMinPowerCount), uint64(s.State.MinerCount), nil
-}
-
-func (s *state0) ListAllMiners() ([]address.Address, error) {
-	claims, err := adt0.AsMap(s.store, s.Claims)
-	if err != nil {
-		return nil, err
-	}
-
-	var miners []address.Address
-	err = claims.ForEach(nil, func(k string) error {
-		a, err := address.NewFromBytes([]byte(k))
-		if err != nil {
-			return err
-		}
-		miners = append(miners, a)
-		return nil
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	return miners, nil
-}
-
-func (s *state0) ForEachClaim(cb func(miner address.Address, claim Claim) error) error {
-	claims, err := adt0.AsMap(s.store, s.Claims)
-	if err != nil {
-		return err
-	}
-
-	var claim power0.Claim
-	return claims.ForEach(&claim, func(k string) error {
-		a, err := address.NewFromBytes([]byte(k))
-		if err != nil {
-			return err
-		}
-		return cb(a, Claim{
-			RawBytePower:    claim.RawBytePower,
-			QualityAdjPower: claim.QualityAdjPower,
-		})
-	})
-}
-
-func (s *state0) ClaimsChanged(other State) (bool, error) {
-	other0, ok := other.(*state0)
-	if !ok {
-		// treat an upgrade as a change, always
-		return true, nil
-	}
-	return !s.State.Claims.Equals(other0.State.Claims), nil
-}
-
-func (s *state0) claims() (adt.Map, error) {
-	return adt0.AsMap(s.store, s.Claims)
-}
-
-func (s *state0) decodeClaim(val *cbg.Deferred) (Claim, error) {
-	var ci power0.Claim
-	if err := ci.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil {
-		return Claim{}, err
-	}
-	return fromV0Claim(ci), nil
-}
-
-func fromV0Claim(v0 power0.Claim) Claim {
-	return (Claim)(v0)
-}
@@ -1,148 +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"
-
-	power2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/power"
-	adt2 "github.com/filecoin-project/specs-actors/v2/actors/util/adt"
-)
-
-var _ State = (*state2)(nil)
-
-func load2(store adt.Store, root cid.Cid) (State, error) {
-	out := state2{store: store}
-	err := store.Get(store.Context(), root, &out)
-	if err != nil {
-		return nil, err
-	}
-	return &out, nil
-}
-
-type state2 struct {
-	power2.State
-	store adt.Store
-}
-
-func (s *state2) TotalLocked() (abi.TokenAmount, error) {
-	return s.TotalPledgeCollateral, nil
-}
-
-func (s *state2) TotalPower() (Claim, error) {
-	return Claim{
-		RawBytePower:    s.TotalRawBytePower,
-		QualityAdjPower: s.TotalQualityAdjPower,
-	}, nil
-}
-
-// Committed power to the network. Includes miners below the minimum threshold.
-func (s *state2) TotalCommitted() (Claim, error) {
-	return Claim{
-		RawBytePower:    s.TotalBytesCommitted,
-		QualityAdjPower: s.TotalQABytesCommitted,
-	}, nil
-}
-
-func (s *state2) MinerPower(addr address.Address) (Claim, bool, error) {
-	claims, err := adt2.AsMap(s.store, s.Claims)
-	if err != nil {
-		return Claim{}, false, err
-	}
-	var claim power2.Claim
-	ok, err := claims.Get(abi.AddrKey(addr), &claim)
-	if err != nil {
-		return Claim{}, false, err
-	}
-	return Claim{
-		RawBytePower:    claim.RawBytePower,
-		QualityAdjPower: claim.QualityAdjPower,
-	}, ok, nil
-}
-
-func (s *state2) MinerNominalPowerMeetsConsensusMinimum(a address.Address) (bool, error) {
-	return s.State.MinerNominalPowerMeetsConsensusMinimum(s.store, a)
-}
-
-func (s *state2) TotalPowerSmoothed() (builtin.FilterEstimate, error) {
-	return builtin.FromV2FilterEstimate(s.State.ThisEpochQAPowerSmoothed), nil
-}
-
-func (s *state2) MinerCounts() (uint64, uint64, error) {
-	return uint64(s.State.MinerAboveMinPowerCount), uint64(s.State.MinerCount), nil
-}
-
-func (s *state2) ListAllMiners() ([]address.Address, error) {
-	claims, err := adt2.AsMap(s.store, s.Claims)
-	if err != nil {
-		return nil, err
-	}
-
-	var miners []address.Address
-	err = claims.ForEach(nil, func(k string) error {
-		a, err := address.NewFromBytes([]byte(k))
-		if err != nil {
-			return err
-		}
-		miners = append(miners, a)
-		return nil
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	return miners, nil
-}
-
-func (s *state2) ForEachClaim(cb func(miner address.Address, claim Claim) error) error {
-	claims, err := adt2.AsMap(s.store, s.Claims)
-	if err != nil {
-		return err
-	}
-
-	var claim power2.Claim
-	return claims.ForEach(&claim, func(k string) error {
-		a, err := address.NewFromBytes([]byte(k))
-		if err != nil {
-			return err
-		}
-		return cb(a, Claim{
-			RawBytePower:    claim.RawBytePower,
-			QualityAdjPower: claim.QualityAdjPower,
-		})
-	})
-}
-
-func (s *state2) ClaimsChanged(other State) (bool, error) {
-	other2, ok := other.(*state2)
-	if !ok {
-		// treat an upgrade as a change, always
-		return true, nil
-	}
-	return !s.State.Claims.Equals(other2.State.Claims), nil
-}
-
-func (s *state2) claims() (adt.Map, error) {
-	return adt2.AsMap(s.store, s.Claims)
-}
-
-func (s *state2) decodeClaim(val *cbg.Deferred) (Claim, error) {
-	var ci power2.Claim
-	if err := ci.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil {
-		return Claim{}, err
-	}
-	return fromV2Claim(ci), nil
-}
-
-func fromV2Claim(v2 power2.Claim) Claim {
-	return Claim{
-		RawBytePower:    v2.RawBytePower,
-		QualityAdjPower: v2.QualityAdjPower,
-	}
-}
@@ -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,
-	}
-}
@@ -1,67 +0,0 @@
-package reward
-
-import (
-	"github.com/filecoin-project/go-state-types/abi"
-	reward0 "github.com/filecoin-project/specs-actors/actors/builtin/reward"
-	"github.com/ipfs/go-cid"
-	"golang.org/x/xerrors"
-
-	"github.com/filecoin-project/go-state-types/cbor"
-	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
-	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
-	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"
-	"github.com/filecoin-project/lotus/chain/types"
-)
-
-func init() {
-	builtin.RegisterActorState(builtin0.RewardActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
-		return load0(store, root)
-	})
-	builtin.RegisterActorState(builtin2.RewardActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
-		return load2(store, root)
-	})
-	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
-)
-
-func Load(store adt.Store, act *types.Actor) (st State, err error) {
-	switch act.Code {
-	case builtin0.RewardActorCodeID:
-		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)
-}
-
-type State interface {
-	cbor.Marshaler
-
-	ThisEpochBaselinePower() (abi.StoragePower, error)
-	ThisEpochReward() (abi.StoragePower, error)
-	ThisEpochRewardSmoothed() (builtin.FilterEstimate, error)
-
-	EffectiveBaselinePower() (abi.StoragePower, error)
-	EffectiveNetworkTime() (abi.ChainEpoch, error)
-
-	TotalStoragePowerReward() (abi.TokenAmount, error)
-
-	CumsumBaseline() (abi.StoragePower, error)
-	CumsumRealized() (abi.StoragePower, error)
-
-	InitialPledgeForPower(abi.StoragePower, abi.TokenAmount, *builtin.FilterEstimate, abi.TokenAmount) (abi.TokenAmount, error)
-	PreCommitDepositForPower(builtin.FilterEstimate, abi.StoragePower) (abi.TokenAmount, error)
-}
-
-type AwardBlockRewardParams = reward0.AwardBlockRewardParams
@@ -1,83 +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"
-
-	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
-	reward0 "github.com/filecoin-project/specs-actors/actors/builtin/reward"
-	smoothing0 "github.com/filecoin-project/specs-actors/actors/util/smoothing"
-)
-
-var _ State = (*state0)(nil)
-
-func load0(store adt.Store, root cid.Cid) (State, error) {
-	out := state0{store: store}
-	err := store.Get(store.Context(), root, &out)
-	if err != nil {
-		return nil, err
-	}
-	return &out, nil
-}
-
-type state0 struct {
-	reward0.State
-	store adt.Store
-}
-
-func (s *state0) ThisEpochReward() (abi.StoragePower, error) {
-	return s.State.ThisEpochReward, nil
-}
-
-func (s *state0) ThisEpochRewardSmoothed() (builtin.FilterEstimate, error) {
-	return builtin.FromV0FilterEstimate(*s.State.ThisEpochRewardSmoothed), nil
-}
-
-func (s *state0) ThisEpochBaselinePower() (abi.StoragePower, error) {
-	return s.State.ThisEpochBaselinePower, nil
-}
-
-func (s *state0) TotalStoragePowerReward() (abi.TokenAmount, error) {
-	return s.State.TotalMined, nil
-}
-
-func (s *state0) EffectiveBaselinePower() (abi.StoragePower, error) {
-	return s.State.EffectiveBaselinePower, nil
-}
-
-func (s *state0) EffectiveNetworkTime() (abi.ChainEpoch, error) {
-	return s.State.EffectiveNetworkTime, nil
-}
-
-func (s *state0) CumsumBaseline() (abi.StoragePower, error) {
-	return s.State.CumsumBaseline, nil
-}
-
-func (s *state0) CumsumRealized() (abi.StoragePower, error) {
-	return s.State.CumsumRealized, nil
-}
-
-func (s *state0) InitialPledgeForPower(sectorWeight abi.StoragePower, networkTotalPledge abi.TokenAmount, networkQAPower *builtin.FilterEstimate, circSupply abi.TokenAmount) (abi.TokenAmount, error) {
-	return miner0.InitialPledgeForPower(
-		sectorWeight,
-		s.State.ThisEpochBaselinePower,
-		networkTotalPledge,
-		s.State.ThisEpochRewardSmoothed,
-		&smoothing0.FilterEstimate{
-			PositionEstimate: networkQAPower.PositionEstimate,
-			VelocityEstimate: networkQAPower.VelocityEstimate,
-		},
-		circSupply), nil
-}
-
-func (s *state0) PreCommitDepositForPower(networkQAPower builtin.FilterEstimate, sectorWeight abi.StoragePower) (abi.TokenAmount, error) {
-	return miner0.PreCommitDepositForPower(s.State.ThisEpochRewardSmoothed,
-		&smoothing0.FilterEstimate{
-			PositionEstimate: networkQAPower.PositionEstimate,
-			VelocityEstimate: networkQAPower.VelocityEstimate,
-		},
-		sectorWeight), nil
-}
@@ -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"
-
-	miner2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/miner"
-	reward2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/reward"
-	smoothing2 "github.com/filecoin-project/specs-actors/v2/actors/util/smoothing"
-)
-
-var _ State = (*state2)(nil)
-
-func load2(store adt.Store, root cid.Cid) (State, error) {
-	out := state2{store: store}
-	err := store.Get(store.Context(), root, &out)
-	if err != nil {
-		return nil, err
-	}
-	return &out, nil
-}
-
-type state2 struct {
-	reward2.State
-	store adt.Store
-}
-
-func (s *state2) ThisEpochReward() (abi.TokenAmount, error) {
-	return s.State.ThisEpochReward, nil
-}
-
-func (s *state2) ThisEpochRewardSmoothed() (builtin.FilterEstimate, error) {
-	return builtin.FilterEstimate{
-		PositionEstimate: s.State.ThisEpochRewardSmoothed.PositionEstimate,
-		VelocityEstimate: s.State.ThisEpochRewardSmoothed.VelocityEstimate,
-	}, nil
-}
-
-func (s *state2) ThisEpochBaselinePower() (abi.StoragePower, error) {
-	return s.State.ThisEpochBaselinePower, nil
-}
-
-func (s *state2) TotalStoragePowerReward() (abi.TokenAmount, error) {
-	return s.State.TotalStoragePowerReward, nil
-}
-
-func (s *state2) EffectiveBaselinePower() (abi.StoragePower, error) {
-	return s.State.EffectiveBaselinePower, nil
-}
-
-func (s *state2) EffectiveNetworkTime() (abi.ChainEpoch, error) {
-	return s.State.EffectiveNetworkTime, nil
-}
-
-func (s *state2) CumsumBaseline() (reward2.Spacetime, error) {
-	return s.State.CumsumBaseline, nil
-}
-
-func (s *state2) CumsumRealized() (reward2.Spacetime, error) {
-	return s.State.CumsumRealized, nil
-}
-
-func (s *state2) InitialPledgeForPower(qaPower abi.StoragePower, networkTotalPledge abi.TokenAmount, networkQAPower *builtin.FilterEstimate, circSupply abi.TokenAmount) (abi.TokenAmount, error) {
-	return miner2.InitialPledgeForPower(
-		qaPower,
-		s.State.ThisEpochBaselinePower,
-		s.State.ThisEpochRewardSmoothed,
-		smoothing2.FilterEstimate{
-			PositionEstimate: networkQAPower.PositionEstimate,
-			VelocityEstimate: networkQAPower.VelocityEstimate,
-		},
-		circSupply,
-	), nil
-}
-
-func (s *state2) PreCommitDepositForPower(networkQAPower builtin.FilterEstimate, sectorWeight abi.StoragePower) (abi.TokenAmount, error) {
-	return miner2.PreCommitDepositForPower(s.State.ThisEpochRewardSmoothed,
-		smoothing2.FilterEstimate{
-			PositionEstimate: networkQAPower.PositionEstimate,
-			VelocityEstimate: networkQAPower.VelocityEstimate,
-		},
-		sectorWeight), nil
-}
@@ -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
-}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Travis Person	992073d263	Merge pull request #3855 from filecoin-project/feat/well-targetted-nerpa-v0.7.x Feat/well targetted nerpa v0.7.x	2020-09-15 13:18:15 -07:00
Liviu Damian	9f12eace4b	Nerpa v0.7.x	2020-09-15 13:59:44 +02:00
Peter Rabbitson	700e35969a	Nerpa-specific consensus adjustments	2020-09-15 13:59:30 +02:00
Peter Rabbitson	e0422aa414	Reset ntwk-nerpa to v0.7.0	2020-09-15 13:59:03 +02:00
Travis Person	9d8af87ecf	Merge pull request #3365 from Digital-MOB-Filecoin/ntwk-nerpa-202008271 Nerpa genesis 20200827 v0.5.4	2020-08-28 13:00:22 -07:00
Liviu Damian	d7633c2bd9	Nerpa genesis 20200828 v0.5.4	2020-08-28 22:32:28 +03:00
Liviu Damian	975cbbdaa4	Nerpa genesis 20200827 v0.5.4	2020-08-27 22:17:40 +03:00