diff --git a/.circleci/config.yml b/.circleci/config.yml
index 9bcd6e8d8..acd447f69 100644
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@@ -1,12 +1,15 @@
 version: 2.1
 orbs:
-  go: gotest/tools@0.0.9
+  go: gotest/tools@0.0.13
 
 executors:
   golang:
     docker:
-      - image: circleci/golang:1.13
+      - image: circleci/golang:1.14.6
     resource_class: 2xlarge
+  ubuntu:
+    docker:
+      - image: ubuntu:19.10
 
 commands:
   install-deps:
@@ -24,6 +27,8 @@ commands:
         description: is a darwin build environment?
         type: boolean
     steps:
+      - checkout
+      - git_fetch_all_tags
       - checkout
       - when:
           condition: << parameters.linux >>
@@ -37,16 +42,36 @@ commands:
       - restore_cache:
           name: Restore parameters cache
           keys:
-            - 'v20-1k-lotus-params'
+            - 'v25-2k-lotus-params'
           paths:
             - /var/tmp/filecoin-proof-parameters/
-      - run:  ./lotus fetch-params --proving-params 1024
+      - run:  ./lotus fetch-params 2048
       - save_cache:
           name: Save parameters cache
-          key: 'v20-1k-lotus-params'
+          key: 'v25-2k-lotus-params'
           paths:
             - /var/tmp/filecoin-proof-parameters/
-
+  install_ipfs:
+    steps:
+      - run: |
+          apt update
+          apt install -y wget
+          wget https://github.com/ipfs/go-ipfs/releases/download/v0.4.22/go-ipfs_v0.4.22_linux-amd64.tar.gz
+          wget https://github.com/ipfs/go-ipfs/releases/download/v0.4.22/go-ipfs_v0.4.22_linux-amd64.tar.gz.sha512
+          if [ "$(sha512sum go-ipfs_v0.4.22_linux-amd64.tar.gz)" != "$(cat go-ipfs_v0.4.22_linux-amd64.tar.gz.sha512)" ]
+          then
+            echo "ipfs failed checksum check"
+            exit 1
+          fi
+          tar -xf go-ipfs_v0.4.22_linux-amd64.tar.gz
+          mv go-ipfs/ipfs /usr/local/bin/ipfs
+          chmod +x /usr/local/bin/ipfs
+  git_fetch_all_tags:
+    steps:
+      - run:
+          name: fetch all tags
+          command: |
+            git fetch --all
 
 jobs:
   mod-tidy-check:
@@ -54,7 +79,6 @@ jobs:
     steps:
       - install-deps
       - prepare
-      - go/mod-download
       - go/mod-tidy-check
 
   build-all:
@@ -62,23 +86,34 @@ jobs:
     steps:
       - install-deps
       - prepare
-      - go/mod-download
       - run: sudo apt-get update
       - run: sudo apt-get install npm
-      - restore_cache:
-          name: restore go mod cache
-          key: v1-go-deps-{{ arch }}-{{ checksum "/home/circleci/project/go.mod" }}
       - run:
           command: make buildall
       - store_artifacts:
           path: lotus
       - store_artifacts:
-          path: lotus-storage-miner
+          path: lotus-miner
+      - store_artifacts:
+          path: lotus-worker
+      - run: mkdir linux && mv lotus lotus-miner lotus-worker linux/
+      - persist_to_workspace:
+          root: "."
+          paths:
+            - linux
+
+  build-debug:
+    executor: golang
+    steps:
+      - install-deps
+      - prepare
+      - run:
+          command: make debug
 
   test: &test
     description: |
       Run tests with gotestsum.
-    parameters:
+    parameters: &test-params
       executor:
         type: executor
         default: golang
@@ -90,13 +125,16 @@ jobs:
         type: string
         default: "./..."
         description: Import paths of packages to be tested.
+      winpost-test:
+        type: string
+        default: "0"
       test-suite-name:
         type: string
         default: unit
         description: Test suite name to report to CircleCI.
       gotestsum-format:
         type: string
-        default: short
+        default: pkgname-and-test-fails
         description: gotestsum format. https://github.com/gotestyourself/gotestsum#format
       coverage:
         type: string
@@ -112,30 +150,34 @@ jobs:
     steps:
       - install-deps
       - prepare
-      - go/mod-download
-      - restore_cache:
-          name: restore go mod cache
-          key: v1-go-deps-{{ arch }}-{{ checksum "/home/circleci/project/go.mod" }}
       - run:
           command: make deps lotus
           no_output_timeout: 30m
       - download-params
       - go/install-gotestsum:
           gobin: $HOME/.local/bin
+          version: 0.5.2
       - run:
           name: go test
           environment:
-            GOTESTSUM_JUNITFILE: /tmp/test-reports/<< parameters.test-suite-name >>/junit.xml
-            GOTESTSUM_FORMAT: << parameters.gotestsum-format >>
+            LOTUS_TEST_WINDOW_POST: << parameters.winpost-test >>
+            SKIP_CONFORMANCE: "1"
           command: |
             mkdir -p /tmp/test-reports/<< parameters.test-suite-name >>
-            gotestsum -- \
+            mkdir -p /tmp/test-artifacts
+            gotestsum \
+              --format << parameters.gotestsum-format >> \
+              --junitfile /tmp/test-reports/<< parameters.test-suite-name >>/junit.xml \
+              --jsonfile /tmp/test-artifacts/<< parameters.test-suite-name >>.json \
+              -- \
               << parameters.coverage >> \
               << parameters.go-test-flags >> \
               << parameters.packages >>
           no_output_timeout: 30m
       - store_test_results:
           path: /tmp/test-reports
+      - store_artifacts:
+          path: /tmp/test-artifacts/<< parameters.test-suite-name >>.json
       - when:
           condition: << parameters.codecov-upload >>
           steps:
@@ -145,16 +187,92 @@ jobs:
                 shell: /bin/bash -eo pipefail
                 command: |
                   bash <(curl -s https://codecov.io/bash)
-      - save_cache:
-          name: save go mod cache
-          key: v1-go-deps-{{ arch }}-{{ checksum "/home/circleci/project/go.mod" }}
-          paths:
-            - "~/go/pkg"
-            - "~/go/src/github.com"
-            - "~/go/src/golang.org"
 
-  test-short: 
+  test-short:
     <<: *test
+  test-window-post:
+    <<: *test
+  test-conformance:
+    description: |
+      Run tests using a corpus of interoperable test vectors for Filecoin 
+      implementations to test their correctness and compliance with the Filecoin
+      specifications.
+    parameters:
+      <<: *test-params
+      vectors-branch:
+        type: string
+        default: ""
+        description: |
+          Branch on github.com/filecoin-project/test-vectors to checkout and
+          test with. If empty (the default) the commit defined by the git
+          submodule is used.
+    executor: << parameters.executor >>
+    steps:
+      - install-deps
+      - prepare
+      - run:
+          command: make deps lotus
+          no_output_timeout: 30m
+      - download-params
+      - when:
+          condition:
+            not:
+              equal: [ "", << parameters.vectors-branch >> ]
+          steps:
+            - run:
+                name: checkout vectors branch
+                command: |
+                  cd extern/test-vectors
+                  git fetch
+                  git checkout origin/<< parameters.vectors-branch >>
+      - go/install-gotestsum:
+          gobin: $HOME/.local/bin
+          version: 0.5.2
+      - run:
+          name: install statediff globally
+          command: |
+            ## statediff is optional; we succeed even if compilation fails.
+            mkdir -p /tmp/statediff
+            git clone https://github.com/filecoin-project/statediff.git /tmp/statediff
+            cd /tmp/statediff
+            go install ./cmd/statediff || exit 0
+      - run:
+          name: go test
+          environment:
+            SKIP_CONFORMANCE: "0"
+          command: |
+            mkdir -p /tmp/test-reports
+            mkdir -p /tmp/test-artifacts
+            gotestsum \
+              --format pkgname-and-test-fails \
+              --junitfile /tmp/test-reports/junit.xml \
+              -- \
+              -v -coverpkg ./chain/vm/,github.com/filecoin-project/specs-actors/... -coverprofile=/tmp/conformance.out ./conformance/
+            go tool cover -html=/tmp/conformance.out -o /tmp/test-artifacts/conformance-coverage.html
+          no_output_timeout: 30m
+      - store_test_results:
+          path: /tmp/test-reports
+      - store_artifacts:
+          path: /tmp/test-artifacts/conformance-coverage.html
+  build-lotus-soup:
+    description: |
+      Compile `lotus-soup` Testground test plan using the current version of Lotus.
+    parameters:
+      <<: *test-params
+    executor: << parameters.executor >>
+    steps:
+      - install-deps
+      - prepare
+      - run: cd extern/oni && git submodule sync
+      - run: cd extern/oni && git submodule update --init
+      - run: cd extern/filecoin-ffi && make
+      - run:
+          name: "replace lotus, filecoin-ffi, blst and fil-blst deps"
+          command: cd extern/oni/lotus-soup && go mod edit -replace github.com/filecoin-project/lotus=../../../ && go mod edit -replace github.com/filecoin-project/filecoin-ffi=../../filecoin-ffi && go mod edit -replace github.com/supranational/blst=../../fil-blst/blst && go mod edit -replace github.com/filecoin-project/fil-blst=../../fil-blst
+      - run:
+          name: "build lotus-soup testplan"
+          command: pushd extern/oni/lotus-soup && go build -tags=testground .
+
 
   build-macos:
     description: build darwin lotus binary
@@ -168,8 +286,8 @@ jobs:
       - run:
           name: Install go
           command: |
-            curl -O https://dl.google.com/go/go1.13.4.darwin-amd64.pkg && \
-            sudo installer -pkg go1.13.4.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
@@ -181,21 +299,26 @@ jobs:
       - run:
           name: Install jq
           command: |
-            mkdir $HOME/.bin
-            curl --location https://github.com/stedolan/jq/releases/download/jq-1.6/jq-osx-amd64 --output $HOME/.bin/jq
-            chmod +x $HOME/.bin/jq
+            curl --location https://github.com/stedolan/jq/releases/download/jq-1.6/jq-osx-amd64 --output /usr/local/bin/jq
+            chmod +x /usr/local/bin/jq
       - restore_cache:
-          name: restore go mod and cargo cache
+          name: restore cargo cache
           key: v3-go-deps-{{ arch }}-{{ checksum "~/go/src/github.com/filecoin-project/lotus/go.sum" }}
       - install-deps
-      - go/mod-download
       - run:
           command: make build
           no_output_timeout: 30m
       - store_artifacts:
           path: lotus
       - store_artifacts:
-          path: lotus-storage-miner
+          path: lotus-miner
+      - store_artifacts:
+          path: lotus-worker
+      - run: mkdir darwin && mv lotus lotus-miner lotus-worker darwin/
+      - persist_to_workspace:
+          root: "."
+          paths:
+            - darwin
       - save_cache:
           name: save cargo cache
           key: v3-go-deps-{{ arch }}-{{ checksum "~/go/src/github.com/filecoin-project/lotus/go.sum" }}
@@ -203,6 +326,35 @@ jobs:
             - "~/.rustup"
             - "~/.cargo"
 
+  gofmt:
+    executor: golang
+    steps:
+      - install-deps
+      - prepare
+      - run:
+          command: "! go fmt ./... 2>&1 | read"
+
+  cbor-gen-check:
+    executor: golang
+    steps:
+      - install-deps
+      - prepare
+      - run: make deps
+      - run: go install golang.org/x/tools/cmd/goimports
+      - run: go install github.com/hannahhoward/cbor-gen-for
+      - run: go generate ./...
+      - run: git --no-pager diff
+      - run: git --no-pager diff --quiet
+
+  docs-check:
+    executor: golang
+    steps:
+      - install-deps
+      - prepare
+      - run: make docsgen
+      - run: git --no-pager diff
+      - run: git --no-pager diff --quiet
+
   lint: &lint
     description: |
       Run golangci-lint.
@@ -212,7 +364,7 @@ jobs:
         default: golang
       golangci-lint-version:
         type: string
-        default: 1.17.1
+        default: 1.27.0
       concurrency:
         type: string
         default: '2'
@@ -228,7 +380,6 @@ jobs:
     steps:
       - install-deps
       - prepare
-      - go/mod-download
       - run:
           command: make deps
           no_output_timeout: 30m
@@ -238,25 +389,91 @@ jobs:
       - run:
           name: Lint
           command: |
-            $HOME/.local/bin/golangci-lint run -v \
+            $HOME/.local/bin/golangci-lint run -v --timeout 2m \
               --concurrency << parameters.concurrency >> << parameters.args >>
-  lint-changes:
-    <<: *lint
-
   lint-all:
     <<: *lint
 
+  publish:
+    description: publish binary artifacts
+    executor: ubuntu
+    steps:
+      - run:
+          name: Install git jq curl
+          command: apt update && apt install -y git jq curl
+      - checkout
+      - git_fetch_all_tags
+      - checkout
+      - install_ipfs
+      - attach_workspace:
+          at: "."
+      - run:
+          name: Create bundles
+          command: ./scripts/build-bundle.sh
+      - run:
+          name: Publish release
+          command: ./scripts/publish-release.sh
+
 
 workflows:
   version: 2.1
   ci:
     jobs:
-      - lint-changes:
-          args: "--new-from-rev origin/master"
+      - lint-all:
+          concurrency: "16"   # expend all docker 2xlarge CPUs.
+      - mod-tidy-check
+      - gofmt
+      - cbor-gen-check
+      - docs-check
       - test:
           codecov-upload: true
+          test-suite-name: full
+      - test-window-post:
+          go-test-flags: "-run=TestWindowedPost"
+          winpost-test: "1"
+          test-suite-name: window-post
       - test-short:
           go-test-flags: "--timeout 10m --short"
-      - mod-tidy-check
-      - build-all
-      - build-macos
+          test-suite-name: short
+          filters:
+            tags:
+              only:
+                - /^v\d+\.\d+\.\d+$/
+      - test-conformance:
+          test-suite-name: conformance
+          packages: "./conformance"
+      - test-conformance:
+          name: test-conformance-bleeding-edge
+          test-suite-name: conformance-bleeding-edge
+          packages: "./conformance"
+          vectors-branch: master
+      - build-lotus-soup
+      - build-debug
+      - build-all:
+          requires:
+            - test-short
+          filters:
+            tags:
+              only:
+                - /^v\d+\.\d+\.\d+$/
+      - build-macos:
+          requires:
+            - test-short
+          filters:
+            branches:
+              ignore:
+                - /.*/
+            tags:
+              only:
+                - /^v\d+\.\d+\.\d+$/
+      - publish:
+          requires:
+            - build-all
+            - build-macos
+          filters:
+            branches:
+              ignore:
+                - /.*/
+            tags:
+              only:
+                - /^v\d+\.\d+\.\d+$/
diff --git a/.codecov.yml b/.codecov.yml
index cf409a6b6..1551f2276 100644
--- a/.codecov.yml
+++ b/.codecov.yml
@@ -1,3 +1,5 @@
 comment: off
 ignore:
   - "cbor_gen.go"
+github_checks:
+  annotations: false
diff --git a/.dockerignore b/.dockerignore
new file mode 120000
index 000000000..3e4e48b0b
--- /dev/null
+++ b/.dockerignore
@@ -0,0 +1 @@
+.gitignore
\ No newline at end of file
diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
new file mode 100644
index 000000000..49e461d00
--- /dev/null
+++ b/.github/CODEOWNERS
@@ -0,0 +1,15 @@
+## filecoin-project/lotus CODEOWNERS
+## Refer to https://docs.github.com/en/github/creating-cloning-and-archiving-repositories/about-code-owners.
+##
+## These users or groups will be automatically assigned as reviewers every time
+## a PR is submitted that modifies code in the specified locations.
+##
+## The Lotus repo configuration requires that at least ONE codeowner approves
+## the PR before merging.
+
+### Global owners.
+*                       @magik6k @whyrusleeping @Kubuxu
+
+### Conformance testing.
+conformance/            @raulk
+extern/test-vectors     @raulk
diff --git a/.github/ISSUE_TEMPLATE/bug_report.md b/.github/ISSUE_TEMPLATE/bug_report.md
index a1baede0d..1ded8c36b 100644
--- a/.github/ISSUE_TEMPLATE/bug_report.md
+++ b/.github/ISSUE_TEMPLATE/bug_report.md
@@ -21,7 +21,7 @@ A clear and concise description of what you expected to happen.
 **Screenshots**
 If applicable, add screenshots to help explain your problem.
 
-**Version (run `lotus --version`):**
+**Version (run `lotus version`):**
 
 **Additional context**
 Add any other context about the problem here.
diff --git a/.github/ISSUE_TEMPLATE/sealingfailed.md b/.github/ISSUE_TEMPLATE/sealingfailed.md
new file mode 100644
index 000000000..ae14c3262
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/sealingfailed.md
@@ -0,0 +1,43 @@
+---
+name: Sealing Issues
+about: Create a report for help with sealing (commit) failures.
+title: ''
+labels: 'sealing'
+assignees: ''
+
+---
+
+Please provide all the information requested here to help us troubleshoot "commit failed" issues.
+If the information requested is missing, we will probably have to just ask you to provide it anyway,
+before we can help debug.
+
+**Describe the problem**
+
+A brief description of the problem you encountered while proving (sealing) a sector.
+
+Including what commands you ran, and a description of your setup, is very helpful.
+
+**Sectors status**
+
+The output of `lotus-miner sectors status --log <sectorId>` for the failed sector(s).
+
+**Lotus miner logs**
+
+Please go through the logs of your miner, and include screenshots of any error-like messages you find.
+
+Alternatively please upload full log files and share a link here
+
+**Lotus miner diagnostic info**
+
+Please collect the following diagnostic information, and share a link here
+
+* lotus-miner diagnostic info `lotus-miner info all > allinfo`
+
+** Code modifications **
+
+If you have modified parts of lotus, please describe which areas were modified,
+and the scope of those modifications
+
+**Version**
+
+The output of `lotus --version`.
diff --git a/.github/labels.yml b/.github/labels.yml
new file mode 100644
index 000000000..7102f1311
--- /dev/null
+++ b/.github/labels.yml
@@ -0,0 +1,248 @@
+###
+### Special magic GitHub labels
+### https://help.github.com/en/github/building-a-strong-community/encouraging-helpful-contributions-to-your-project-with-labels
+#
+- name: "good first issue"
+  color: 7057ff
+  description: "Good for newcomers"
+- name: "help wanted"
+  color: 008672
+  description: "Extra attention is needed"
+
+###
+### Goals
+#
+- name: goal/incentives
+  color: ff004d
+  description: "Incentinet"
+
+###
+### Areas
+#
+- name: area/ux
+  color: 00A4E0
+  description: "Area: UX"
+- name: area/chain/vm
+  color: 00A4E2
+  description: "Area: Chain/VM"
+- name: area/chain/sync
+  color: 00A4E4
+  description: "Area: Chain/Sync"
+- name: area/chain/misc
+  color: 00A4E6
+  description: "Area: Chain/Misc"
+- name: area/markets
+  color: 00A4E8
+  description: "Area: Markets"  
+- name: area/sealing/fsm
+  color: 0bb1ed
+  description: "Area: Sealing/FSM"
+- name: area/sealing/storage
+  color: 0EB4F0
+  description: "Area: Sealing/Storage"
+- name: area/proving
+  color: 0EB4F0
+  description: "Area: Proving"
+- name: area/mining
+  color: 10B6F2
+  description: "Area: Mining"
+- name: area/client/storage
+  color: 13B9F5
+  description: "Area: Client/Storage"
+- name: area/client/retrieval
+  color: 15BBF7
+  description: "Area: Client/Retrieval"
+- name: area/wallet
+  color: 15BBF7
+  description: "Area: Wallet"
+- name: area/payment-channel
+  color: ff6767
+  description: "Area: Payment Channel"
+- name: area/multisig
+  color: fff0ff
+  description: "Area: Multisig"
+- name: area/networking
+  color: 273f8a
+  description: "Area: Networking"
+
+###
+### Kinds
+#
+- name: kind/bug
+  color: c92712
+  description: "Kind: Bug"
+- name: kind/chore
+  color: fcf0b5
+  description: "Kind: Chore"
+- name: kind/feature
+  color: FFF3B8
+  description: "Kind: Feature"
+- name: kind/improvement
+  color: FFF5BA
+  description: "Kind: Improvement"
+- name: kind/test
+  color: FFF8BD
+  description: "Kind: Test"
+- name: kind/question
+  color: FFFDC2
+  description: "Kind: Question"
+- name: kind/enhancement
+  color: FFFFC5
+  description: "Kind: Enhancement"
+- name: kind/discussion
+  color: FFFFC7
+  description: "Kind: Discussion"
+
+###
+### Difficulties
+#
+- name: dif/trivial
+  color: b2b7ff
+  description: "Can be confidently tackled by newcomers, who are widely unfamiliar with lotus"
+- name: dif/easy
+  color: 7886d7
+  description: "An existing lotus user should be able to pick this up"
+- name: dif/medium
+  color: 6574cd
+  description: "Prior development experience with lotus is likely helpful"
+- name: dif/hard
+  color: 5661b3
+  description: "Suggests that having worked on the specific component affected by this issue is important"
+- name: dif/expert
+  color: 2f365f
+  description: "Requires extensive knowledge of the history, implications, ramifications of the issue"
+
+###
+### Efforts
+#
+- name: effort/minutes
+  color: e8fffe
+  description: "Effort: Minutes"
+- name: effort/hours
+  color: a0f0ed
+  description: "Effort: Hours"
+- name: effort/day
+  color: 64d5ca
+  description: "Effort: One Day"
+- name: effort/days
+  color: 4dc0b5
+  description: "Effort: Multiple Days"
+- name: effort/week
+  color: 38a89d
+  description: "Effort: One Week"
+- name: effort/weeks
+  color: 20504f
+  description: "Effort: Multiple Weeks"
+
+###
+### Impacts
+#
+- name: impact/regression
+  color: f1f5f8
+  description: "Impact: Regression"
+- name: impact/api-breakage
+  color: ECF0F3
+  description: "Impact: API Breakage"
+- name: impact/quality
+  color: E7EBEE
+  description: "Impact: Quality"
+- name: impact/dx
+  color: E2E6E9
+  description: "Impact: Developer Experience"
+- name: impact/test-flakiness
+  color: DDE1E4
+  description: "Impact: Test Flakiness"
+- name: impact/consensus
+  color: b20014
+  description: "Impact: Consensus"
+
+###
+### Topics
+#
+- name: topic/interoperability
+  color: bf0f73
+  description: "Topic: Interoperability"
+- name: topic/specs
+  color: CC1C80
+  description: "Topic: Specs"
+- name: topic/docs
+  color: D9298D
+  description: "Topic: Documentation"
+- name: topic/architecture
+  color: E53599
+  description: "Topic: Architecture"
+
+###
+### Priorities
+###
+- name: P0
+  color: dd362a
+  description: "P0: Critical Blocker"
+- name: P1
+  color: ce8048
+  description: "P1: Must be resolved"
+- name: P2
+  color: dbd81a
+  description: "P2: Should be resolved"
+- name: P3
+  color: 9fea8f
+  description: "P3: Might get resolved"
+
+###
+### Hints
+#
+#- name: hint/good-first-issue
+#  color: 7057ff
+#  description: "Hint: Good First Issue"
+#- name: hint/help-wanted
+#  color: 008672
+#  description: "Hint: Help Wanted"
+- name: hint/needs-decision
+  color: 33B9A5
+  description: "Hint: Needs Decision"
+- name: hint/needs-triage
+  color: 1AA08C
+  description: "Hint: Needs Triage"
+- name: hint/needs-analysis
+  color: 26AC98
+  description: "Hint: Needs Analysis"
+- name: hint/needs-author-input
+  color: 33B9A5
+  description: "Hint: Needs Author Input"
+- name: hint/needs-team-input
+  color: 40C6B2
+  description: "Hint: Needs Team Input"
+- name: hint/needs-community-input
+  color: 4DD3BF
+  description: "Hint: Needs Community Input"
+- name: hint/needs-review
+  color: 5AE0CC
+  description: "Hint: Needs Review"
+
+###
+### Statuses
+#
+- name: status/done
+  color: edb3a6
+  description: "Status: Done"
+- name: status/deferred
+  color: E0A699
+  description: "Status: Deferred"
+- name: status/in-progress
+  color: D49A8D
+  description: "Status: In Progress"
+- name: status/blocked
+  color: C78D80
+  description: "Status: Blocked"
+- name: status/inactive
+  color: BA8073
+  description: "Status: Inactive"
+- name: status/waiting
+  color: AD7366
+  description: "Status: Waiting"
+- name: status/rotten
+  color: 7A4033
+  description: "Status: Rotten"
+- name: status/discarded
+  color: 6D3326
+  description: "Status: Discarded / Won't fix"
diff --git a/.github/workflows/label-syncer.yml b/.github/workflows/label-syncer.yml
new file mode 100644
index 000000000..a94b0edb6
--- /dev/null
+++ b/.github/workflows/label-syncer.yml
@@ -0,0 +1,17 @@
+
+name: Label syncer
+on:
+  push:
+    paths:
+      - '.github/labels.yml'
+    branches:
+      - master
+jobs:
+  build:
+    name: Sync labels
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@1.0.0
+      - uses: micnncim/action-label-syncer@v1.0.0
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
diff --git a/.gitignore b/.gitignore
index ce84e704d..05f762d8d 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,19 +1,24 @@
 /lotus
-/lotus-storage-miner
-/lotus-seal-worker
+/lotus-miner
+/lotus-worker
 /lotus-seed
-/pond
-/townhall
-/fountain
-/stats
-/bench
+/lotus-health
+/lotus-chainwatch
+/lotus-shed
+/lotus-pond
+/lotus-townhall
+/lotus-fountain
+/lotus-stats
+/lotus-bench
+/lotus-gateway
+/lotus-pcr
 /bench.json
 /lotuspond/front/node_modules
 /lotuspond/front/build
 /cmd/lotus-townhall/townhall/node_modules
 /cmd/lotus-townhall/townhall/build
+/cmd/lotus-townhall/townhall/package-lock.json
 extern/filecoin-ffi/rust/target
-**/*.h
 **/*.a
 **/*.pc
 /**/*/.DS_STORE
@@ -23,11 +28,14 @@ build/paramfetch.sh
 /vendor
 /blocks.dot
 /blocks.svg
-/chainwatch
 /chainwatch.db
+/bundle
+/darwin
+/linux
 
 *-fuzz.zip
 /chain/types/work_msg/
 bin/ipget
 bin/tmp/*
 .idea
+scratchpad
diff --git a/.gitmodules b/.gitmodules
index a655f05b9..35f5a3d3f 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -2,3 +2,15 @@
 	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
+[submodule "extern/test-vectors"]
+	path = extern/test-vectors
+	url = https://github.com/filecoin-project/test-vectors.git
+[submodule "extern/fil-blst"]
+	path = extern/fil-blst
+	url = https://github.com/filecoin-project/fil-blst.git
+[submodule "extern/oni"]
+	path = extern/oni
+	url = https://github.com/filecoin-project/oni
diff --git a/.golangci.yml b/.golangci.yml
index f873557aa..8bdba64f0 100644
--- a/.golangci.yml
+++ b/.golangci.yml
@@ -1,7 +1,8 @@
 linters:
   disable-all: true
   enable:
-    - vet
+    - gofmt
+    - govet
     - goimports
     - misspell
     - goconst
@@ -21,16 +22,51 @@ issues:
     - "func name will be used as test\\.Test.* by other packages, and that stutters; consider calling this"
     - "Potential file inclusion via variable"
     - "should have( a package)? comment"
+    - "Error return value of `logging.SetLogLevel` is not checked"
+    - "comment on exported"
+    - "(func|method) \\w+ should be \\w+"
+    - "(type|var|struct field|(method|func) parameter) `\\w+` should be `\\w+`"
+    - "(G306|G301|G307|G108|G302|G204|G104)"
+    - "don't use ALL_CAPS in Go names"
+    - "string .* has .* occurrences, make it a constant"
+    - "a blank import should be only in a main or test package, or have a comment justifying it"
+    - "package comment should be of the form"
 
   exclude-use-default: false
   exclude-rules:
+    - path: lotuspond
+      linters:
+        - errcheck
+
     - path: node/modules/lp2p
       linters:
         - golint
-    - path: ".*_test.go"
+
+    - path: build/params_.*\.go
+      linters:
+        - golint
+          
+    - path: api/apistruct/struct.go
+      linters:
+        - golint
+
+    - path: .*_test.go
       linters:
         - gosec
 
+    - path: chain/vectors/gen/.*
+      linters:
+        - gosec
+
+    - path: cmd/lotus-bench/.*
+      linters:
+        - gosec
+
+    - path: api/test/.*
+      text: "context.Context should be the first parameter"
+      linters:
+        - golint
+
 linters-settings:
   goconst:
     min-occurrences: 6
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 6ba83a258..ac687675e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,7 +1,569 @@
-# lotus changelog
+# Lotus changelog
 
-## 0.1.0 / 2019-12-11
+# 0.8.0 / 2020-09-26
 
-We are very excited to release **lotus** 0.1.0. This is our testnet release. To install lotus and join the testnet, please visit [docs.lotu.sh](docs.lotu.sh). Please file bug reports as [issues](https://github.com/filecoin-project/lotus/issues).
+This consensus-breaking release of Lotus introduces an upgrade to the network. The changes that break consensus are:
 
-A huge thank you to all contributors for this testnet release!
\ No newline at end of file
+- 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:
+
+- Upgrading the Drand network used from the test Drand network to the League of Entropy main drand network. This is the same Drand network that will be used in the Filecoin mainnet.
+- Upgrading to specs-actors v0.9.8, which adds a new method to the Multisig actor.
+
+## Changes
+
+#### Core Lotus
+
+- Fix IsAncestorOf (https://github.com/filecoin-project/lotus/pull/3717)
+- Update to specs-actors v0.9.8 (https://github.com/filecoin-project/lotus/pull/3725)
+- Increase chain throughput by 20% (https://github.com/filecoin-project/lotus/pull/3732)
+- Updare to go-libp2p-pubsub `master` (https://github.com/filecoin-project/lotus/pull/3735)
+- Drand upgrade (https://github.com/filecoin-project/lotus/pull/3670)
+- Multisig API additions (https://github.com/filecoin-project/lotus/pull/3590)
+
+#### Storage Miner 
+
+- Increase the number of times precommit2 is attempted before moving back to precommit1 (https://github.com/filecoin-project/lotus/pull/3720)
+
+#### Message pool
+
+- Relax mpool add strictness checks for local pushes (https://github.com/filecoin-project/lotus/pull/3724)
+
+
+#### Maintenance
+
+- Fix devnets (https://github.com/filecoin-project/lotus/pull/3712)
+- Fix(chainwatch): compare prev miner with cur miner (https://github.com/filecoin-project/lotus/pull/3715)
+- CI: fix statediff build; make optional (https://github.com/filecoin-project/lotus/pull/3729)
+- Feat: Chaos abort (https://github.com/filecoin-project/lotus/pull/3733)
+
+## Contributors
+
+The following contributors had commits go into this release.
+We are grateful for every contribution!
+
+| Contributor        | Commits | Lines ±       |
+|--------------------|---------|---------------|
+| arajasek           | 28      | +1144/-239    |
+| Kubuxu             | 19      | +452/-261     |
+| whyrusleeping      | 13      | +456/-87      |
+| vyzo               | 11      | +318/-20      |
+| raulk              | 10      | +1289/-350    |
+| magik6k            | 6       | +188/-55      |
+| dirkmc             | 3       | +31/-8        |
+| alanshaw           | 3       | +176/-37      |
+| Stebalien          | 2       | +9/-12        |
+| lanzafame          | 1       | +1/-1         |
+| frrist             | 1       | +1/-1         |
+| mishmosh           | 1       | +1/-1         |
+| nonsense           | 1       | +1/-0         |
+
+# 0.6.2 / 2020-09-09
+
+This release introduces some critical fixes to message selection and gas estimation logic. It also adds the ability for nodes to mark a certain tipset as checkpointed, as well as various minor improvements and bugfixes.
+
+## Changes
+
+#### Messagepool 
+
+- Warn when optimal selection fails to pack a block and we fall back to random selection (https://github.com/filecoin-project/lotus/pull/3708)
+- Add basic command for printing gas performance of messages in the mpool (https://github.com/filecoin-project/lotus/pull/3701)
+- Adjust optimal selection to always try to fill blocks (https://github.com/filecoin-project/lotus/pull/3685)
+- Fix very minor bug in repub baseFeeLowerBound (https://github.com/filecoin-project/lotus/pull/3663)
+- Add an auto flag to mpool replace (https://github.com/filecoin-project/lotus/pull/3676)
+- Fix mpool optimal selection packing failure (https://github.com/filecoin-project/lotus/pull/3698)
+
+#### Core Lotus
+
+- Don't use latency as initital estimate for blocksync (https://github.com/filecoin-project/lotus/pull/3648)
+- Add niceSleep 1 second when drand errors (https://github.com/filecoin-project/lotus/pull/3664)
+- Fix isChainNearSync check in block validator (https://github.com/filecoin-project/lotus/pull/3650)
+- Add peer to peer manager before fetching the tipset (https://github.com/filecoin-project/lotus/pull/3667)
+- Add StageFetchingMessages to sync status (https://github.com/filecoin-project/lotus/pull/3668)
+- Pass tipset through upgrade logic (https://github.com/filecoin-project/lotus/pull/3673)
+- Allow nodes to mark tipsets as checkpointed (https://github.com/filecoin-project/lotus/pull/3680)
+- Remove hard-coded late-fee in window PoSt (https://github.com/filecoin-project/lotus/pull/3702)
+- Gas: Fix median calc (https://github.com/filecoin-project/lotus/pull/3686)
+
+#### Storage
+
+- Storage manager: bail out with an error if unsealed cid is undefined (https://github.com/filecoin-project/lotus/pull/3655)
+- Storage: return true from Sealer.ReadPiece() on success (https://github.com/filecoin-project/lotus/pull/3657)
+
+#### Maintenance
+
+- Resolve lotus, test-vectors, statediff dependency cycle (https://github.com/filecoin-project/lotus/pull/3688)
+- Paych: add docs on how to use paych status (https://github.com/filecoin-project/lotus/pull/3690)
+- Initial CODEOWNERS (https://github.com/filecoin-project/lotus/pull/3691)
+
+# 0.6.1 / 2020-09-08
+
+This optional release introduces a minor improvement to the sync process, ensuring nodes don't fall behind and then resync.
+
+## Changes
+
+- Update `test-vectors` (https://github.com/filecoin-project/lotus/pull/3645)
+- Revert "only subscribe to pubsub topics once we are synced" (https://github.com/filecoin-project/lotus/pull/3643)
+
+# 0.6.0 / 2020-09-07
+
+This consensus-breaking release of Lotus is designed to test a network upgrade on the space race testnet. The changes that break consensus are:
+
+- Tweaking of some cryptoecon parameters in specs-actors 0.9.7 (https://github.com/filecoin-project/specs-actors/releases/tag/v0.9.7)
+- Rebalancing FIL distribution to make testnet FIL scarce, which prevents base fee spikes and sets better expectations for mainnet
+
+This release also introduces many improvements to Lotus! Among them are a new version of go-fil-markets that supports non-blocking retrieval, various spam reduction measures in the messagepool and p2p logic, and UX improvements to payment channels, dealmaking, and state inspection.
+
+## Changes
+
+#### Core Lotus and dependencies
+
+- Implement faucet funds reallocation logic (https://github.com/filecoin-project/lotus/pull/3632)
+- Network upgrade: Upgrade to correct fork threshold (https://github.com/filecoin-project/lotus/pull/3628)
+- Update to specs 0.9.7 and markets 0.6.0 (https://github.com/filecoin-project/lotus/pull/3627)
+- Network upgrade: Perform base fee tamping (https://github.com/filecoin-project/lotus/pull/3623)
+- Chain events: if cache best() is nil, return chain head (https://github.com/filecoin-project/lotus/pull/3611)
+- Update to specs actors v0.9.6 (https://github.com/filecoin-project/lotus/pull/3603)
+
+#### Messagepool
+
+- Temporarily allow negative chains (https://github.com/filecoin-project/lotus/pull/3625)
+- Improve publish/republish logic (https://github.com/filecoin-project/lotus/pull/3592)
+- Fix selection bug; priority messages were not included if other chains were negative (https://github.com/filecoin-project/lotus/pull/3580)
+- Add defensive check for minimum GasFeeCap for inclusion within the next 20 blocks (https://github.com/filecoin-project/lotus/pull/3579)
+- Add additional info about gas premium (https://github.com/filecoin-project/lotus/pull/3578)
+- Fix GasPremium capping logic  (https://github.com/filecoin-project/lotus/pull/3552)
+
+#### Payment channels 
+
+- Get available funds by address or by from/to (https://github.com/filecoin-project/lotus/pull/3547)
+- Create `lotus paych status` command (https://github.com/filecoin-project/lotus/pull/3523)
+- Rename CLI command from "paych get" to "paych add-funds" (https://github.com/filecoin-project/lotus/pull/3520)
+
+#### Peer-to-peer
+
+- Only subscribe to pubsub topics once we are synced (https://github.com/filecoin-project/lotus/pull/3602)
+- Reduce mpool add failure log spam (https://github.com/filecoin-project/lotus/pull/3562)
+- Republish messages even if the chains have negative performance(https://github.com/filecoin-project/lotus/pull/3557)
+- Adjust gossipsub gossip factor (https://github.com/filecoin-project/lotus/pull/3556)
+- Integrate pubsub Random Early Drop (https://github.com/filecoin-project/lotus/pull/3518)
+
+#### Miscellaneous
+
+- Fix panic in OnDealExpiredSlashed (https://github.com/filecoin-project/lotus/pull/3553)
+- Robustify state manager against holes in actor method numbers (https://github.com/filecoin-project/lotus/pull/3538)
+
+#### UX
+
+- VM: Fix an error message (https://github.com/filecoin-project/lotus/pull/3608)
+- Documentation: Batch replacement,update lotus-storage-miner to lotus-miner (https://github.com/filecoin-project/lotus/pull/3571)
+- CLI: Robust actor lookup (https://github.com/filecoin-project/lotus/pull/3535)
+- Add agent flag to net peers (https://github.com/filecoin-project/lotus/pull/3534)
+- Add watch option to storage-deals list (https://github.com/filecoin-project/lotus/pull/3527)
+
+#### Testing & tooling
+
+- Decommission chain-validation (https://github.com/filecoin-project/lotus/pull/3606)
+- Metrics: add expected height metric (https://github.com/filecoin-project/lotus/pull/3586)
+- PCR: Use current tipset during refund (https://github.com/filecoin-project/lotus/pull/3570)
+- Lotus-shed: Add math command (https://github.com/filecoin-project/lotus/pull/3568)
+- PCR: Add tipset aggergation (https://github.com/filecoin-project/lotus/pull/3565)- Fix broken paych tests (https://github.com/filecoin-project/lotus/pull/3551)
+- Make chain export ~1000x times faster (https://github.com/filecoin-project/lotus/pull/3533)
+- Chainwatch: Stop SyncIncomingBlocks from leaking into chainwatch processing; No panics during processing (https://github.com/filecoin-project/lotus/pull/3526)
+- Conformance: various changes (https://github.com/filecoin-project/lotus/pull/3521)
+
+# 0.5.10 / 2020-09-03
+
+This patch includes a crucial fix to the message pool selection logic, strongly disfavouring messages that might cause a miner penalty.
+
+## Changes
+
+- Fix calculation of GasReward in messagepool (https://github.com/filecoin-project/lotus/pull/3528)
+
+# 0.5.9 / 2020-09-03
+
+This patch includes a hotfix to the `GasEstimateFeeCap` method, capping the estimated fee to a reasonable level by default.
+
+## Changes 
+
+- Added target height to sync wait (https://github.com/filecoin-project/lotus/pull/3502)
+- Disable codecov annotations (https://github.com/filecoin-project/lotus/pull/3514)
+- Cap fees to reasonable level by default (https://github.com/filecoin-project/lotus/pull/3516)
+- Add APIs and command to inspect bandwidth usage (https://github.com/filecoin-project/lotus/pull/3497)
+- Track expected nonce in mpool, ignore messages with large nonce gaps (https://github.com/filecoin-project/lotus/pull/3450)
+
+# 0.5.8 / 2020-09-02
+
+This patch includes some bugfixes to the sector sealing process, and updates go-fil-markets. It also improves the performance of blocksync, adds a method to export chain state trees, and improves chainwatch.
+
+## Changes
+
+- Upgrade markets to v0.5.9 (https://github.com/filecoin-project/lotus/pull/3496)
+- Improve blocksync to load fewer messages: (https://github.com/filecoin-project/lotus/pull/3494)
+- Fix a panic in the ffi-wrapper's `ReadPiece` (https://github.com/filecoin-project/lotus/pull/3492/files)
+- Fix a deadlock in the sealing scheduler (https://github.com/filecoin-project/lotus/pull/3489)
+- Add test vectors for tipset tests (https://github.com/filecoin-project/lotus/pull/3485/files)
+- Improve the advance-block debug command (https://github.com/filecoin-project/lotus/pull/3476)
+- Add toggle for message processing to Lotus PCR (https://github.com/filecoin-project/lotus/pull/3470)
+- Allow exporting recent chain state trees (https://github.com/filecoin-project/lotus/pull/3463)
+- Remove height from chain rand (https://github.com/filecoin-project/lotus/pull/3458)
+- Disable GC on chain badger datastore (https://github.com/filecoin-project/lotus/pull/3457)
+- Account for `GasPremium` in `GasEstimateFeeCap` (https://github.com/filecoin-project/lotus/pull/3456)
+- Update go-libp2p-pubsub to `master` (https://github.com/filecoin-project/lotus/pull/3455)
+- Chainwatch improvements (https://github.com/filecoin-project/lotus/pull/3442)
+
+# 0.5.7 / 2020-08-31
+
+This patch release includes some bugfixes and enhancements to the sector lifecycle and message pool logic. 
+
+## Changes
+
+- Rebuild unsealed infos on miner restart (https://github.com/filecoin-project/lotus/pull/3401)
+- CLI to attach storage paths to workers (https://github.com/filecoin-project/lotus/pull/3405)
+- Do not select negative performing message chains for inclusion (https://github.com/filecoin-project/lotus/pull/3392)
+- Remove a redundant error-check (https://github.com/filecoin-project/lotus/pull/3421)
+- Correctly move unsealed sectors in `FinalizeSectors` (https://github.com/filecoin-project/lotus/pull/3424)
+- Improve worker selection logic (https://github.com/filecoin-project/lotus/pull/3425)
+- Don't use context to close bitswap (https://github.com/filecoin-project/lotus/pull/3430)
+- Correctly estimate gas premium when there is only one message on chain (https://github.com/filecoin-project/lotus/pull/3428)
+
+# 0.5.6 / 2020-08-29
+
+Hotfix release that fixes a panic in the sealing scheduler (https://github.com/filecoin-project/lotus/pull/3389).
+
+# 0.5.5
+
+This patch release introduces a large number of improvements to the sealing process.
+It also updates go-fil-markets to 
+[version 0.5.8](https://github.com/filecoin-project/go-fil-markets/releases/tag/v0.5.8),
+and go-libp2p-pubsub to [v0.3.5](https://github.com/libp2p/go-libp2p-pubsub/releases/tag/v0.3.5).
+
+#### Downstream upgrades
+
+- Upgrades markets to v0.5.8 (https://github.com/filecoin-project/lotus/pull/3384)
+- Upgrades go-libp2p-pubsub to v0.3.5 (https://github.com/filecoin-project/lotus/pull/3305)
+
+#### Sector sealing
+
+- The following improvements were introduced in https://github.com/filecoin-project/lotus/pull/3350.
+
+    - Allow `lotus-miner sectors remove` to remove a sector in any state.
+    - Create a separate state in the storage FSM dedicated to submitting the Commit message.
+    - Recovery for when the Deal IDs of deals in a sector get changed in a reorg.
+    - Auto-retry sending Precommit and Commit messages if they run out of gas
+    - Auto-retry sector remove tasks when they fail
+    - Compact worker windows, and allow their tasks to be executed in any order
+
+- Don't simply skip PoSt for bad sectors (https://github.com/filecoin-project/lotus/pull/3323)
+
+#### Message Pool 
+
+- Spam Protection: Track required funds for pending messages (https://github.com/filecoin-project/lotus/pull/3313)
+
+#### Chainwatch
+
+- Add more power and reward metrics (https://github.com/filecoin-project/lotus/pull/3367)
+- Fix raciness in sector deal table (https://github.com/filecoin-project/lotus/pull/3275)
+- Parallelize miner processing (https://github.com/filecoin-project/lotus/pull/3380)
+- Accept Lotus API and token (https://github.com/filecoin-project/lotus/pull/3337)
+
+# 0.5.4
+
+A patch release, containing a few nice bugfixes and improvements:
+
+- Fix parsing of peer ID in `lotus-miner actor set-peer-id` (@whyrusleeping)
+- Update dependencies, fixing several bugs (@Stebalien)
+- Fix remaining linter warnings (@Stebalien)
+- Use safe string truncation (@Ingar)
+- Allow tweaking of blocksync message window size (@whyrusleeping)
+- Add some additional gas stats to metrics (@Kubuxu)
+- Fix an edge case bug in message selection, add many tests (@vyzo)
+
+# 0.5.3
+
+Yet another hotfix release. 
+A lesson for readers, having people who have been awake for 12+ hours review
+your hotfix PR is not a good idea. Find someone who has enough slept recently
+enough to give you good code review, otherwise you'll end up quickly bumping
+versions again.
+
+- Fixed a bug in the mempool that was introduced in v0.5.2
+
+# 0.5.2 / 2020-08-24
+
+This is a hotfix release.
+
+- Fix message selection to not include messages that are invalid for block
+  inclusion.
+- Improve SelectMessage handling of the case where the message pools tipset
+  differs from our mining base.
+
+# 0.5.1 / 2020-08-24
+
+The Space Race release! 
+This release contains the genesis car file and bootstrap peers for the space
+race network. 
+
+Additionally, we included two small fixes to genesis creation:
+- Randomize ticket value in genesis generation
+- Correctly set t099 (burnt funds actor) to have valid account actor state
+
+# 0.5.0 / 2020-08-20
+
+This version of Lotus will be used for the incentivized testnet Space Race competition,
+and can be considered mainnet-ready code. It includes some protocol
+changes, upgrades of core dependencies, and various bugfixes and UX/performance improvements.
+
+## Highlights
+
+Among the highlights included in this release are:
+
+- Gas changes: We implemented EIP-1559 and introduced real gas values.
+- Deal-making: We now support "Committed Capacity" sectors, "fast-retrieval" deals,
+and the packing of multiple deals into a single sector.
+- Renamed features: We renamed some of the binaries, environment variables, and default
+paths associated with a Lotus node.
+
+### Gas changes
+
+We made some significant changes to the mechanics of gas in this release.
+
+#### Network fee
+
+We implemented something similar to 
+[Ethereum's EIP-1559](https://github.com/ethereum/EIPs/blob/master/EIPS/eip-1559.md).
+The `Message` structure had three changes:
+- The `GasPrice` field has been removed
+- A new `GasFeeCap` field has been added, which controls the maximum cost
+the sender incurs for the message
+- A new `GasPremium` field has been added, which controls the reward a miner
+earns for including the message
+
+A sender will never be charged more than `GasFeeCap * GasLimit`. 
+A miner will typically earn `GasPremium * GasLimit` as a reward.
+
+The `Blockheader` structure has one new field, called `ParentBaseFee`. 
+Informally speaking,the `ParentBaseFee`
+is increased when blocks are densely packed with messages, and decreased otherwise.
+
+The `ParentBaseFee` is used when calculating how much a sender burns when executing a message. _Burning_ simply refers to sending attoFIL to a dedicated, unreachable account.
+A message causes `ParentBaseFee * GasUsed` attoFIL to be burnt.
+
+#### Real gas values
+
+This release also includes our first "real" gas costs for primitive operations.
+The costs were designed to account for both the _time_ that message execution takes,
+as well as the _space_ a message adds to the state tree.
+
+## Deal-making changes
+
+There are three key changes to the deal-making process.
+
+#### Committed Capacity sectors
+
+Miners can now pledge "Committed Capacity" (CC) sectors, which are explicitly
+stated as containing junk data, and must not include any deals. Miners can do this
+to increase their storage power, and win block rewards from this pledged storage.
+
+They can mark these sectors as "upgradable" with `lotus-miner sectors mark-for-upgrade`.
+If the miner receives and accepts one or more storage deals, the sector that includes
+those deals will _replace_ the CC sector. This is intended to maximize the amount of useful
+storage on the Filecoin network.
+
+#### Fast-retrieval deals
+
+Clients can now include a `fast-retrieval` flag when proposing deals with storage miners.
+If set to true, the miner will include an extra copy of the deal data. This
+data can be quickly served in a retrieval deal, since it will not need to be unsealed.
+
+#### Multiple deals per sector
+
+Miners can now pack multiple deals into a single sector, so long as all the deals
+fit into the sector capacity. This should increase the packing efficiency of miners.
+
+### Renamed features
+
+To improve the user experience, we updated several names to mainatin
+standard prefixing, and to better reflect the meaning of the features being referenced.
+
+In particular, the Lotus miner binary is now called `lotus-miner`, the default
+path for miner data is now `~/.lotusminer`, and the environment variable
+that sets the path for miner data is now `$LOTUS_MINER_PATH`. A full list of renamed
+features can be found [here](https://github.com/filecoin-project/lotus/issues/2304).
+
+## Changelog
+
+#### Downstream upgrades
+- Upgrades markets to v0.5.6 (https://github.com/filecoin-project/lotus/pull/3058)
+- Upgrades specs-actors to v0.9.3 (https://github.com/filecoin-project/lotus/pull/3151)
+
+#### Core protocol
+- Introduces gas values, replacing placeholders (https://github.com/filecoin-project/lotus/pull/2343)
+- Implements EIP-1559, introducing a network base fee, message gas fee cap, and message gas fee premium (https://github.com/filecoin-project/lotus/pull/2874)
+- Implements Poisson Sortition for elections (https://github.com/filecoin-project/lotus/pull/2084)
+
+#### Deal-making lifecycle
+- Introduces "Committed Capacity" sectors (https://github.com/filecoin-project/lotus/pull/2220)
+- Introduces "fast-retrieval" flag for deals (https://github.com/filecoin-project/lotus/pull/2323
+- Supports packing multiple deals into one sector (https://github.com/filecoin-project/storage-fsm/pull/38)
+
+#### Enhancements
+
+- Optimized message pool selection logic (https://github.com/filecoin-project/lotus/pull/2838)
+- Window-based scheduling of sealing tasks (https://github.com/filecoin-project/sector-storage/pull/67)
+- Faster window PoSt (https://github.com/filecoin-project/lotus/pull/2209/files)
+- Refactors the payment channel manager (https://github.com/filecoin-project/lotus/pull/2640)
+- Refactors blocksync (https://github.com/filecoin-project/lotus/pull/2715/files)
+
+#### UX
+
+- Provide status updates for data-transfer (https://github.com/filecoin-project/lotus/pull/3162, https://github.com/filecoin-project/lotus/pull/3191)
+- Miners can customise asks (https://github.com/filecoin-project/lotus/pull/2046)
+- Miners can toggle auto-acceptance of deals (https://github.com/filecoin-project/lotus/pull/1994)
+- Miners can maintain a blocklist of piece CIDs (https://github.com/filecoin-project/lotus/pull/2069)
+
+## Contributors
+
+The following contributors had 10 or more commits go into this release.
+We are grateful for every contribution!
+
+| Contributor        | Commits | Lines ±       |
+|--------------------|---------|---------------|
+| magik6k            | 361     | +13197/-6136  |
+| Kubuxu             | 227     | +5670/-2587   |
+| arajasek           | 120     | +2916/-1264   |
+| whyrusleeping      | 112     | +3979/-1089   |
+| vyzo               | 99      | +3343/-1305   |
+| dirkmc             | 68      | +8732/-3621   |
+| laser              | 45      | +1489/-501    |
+| hannahhoward       | 43      | +2654/-990    |
+| frrist             | 37      | +6630/-4338   |
+| schomatis          | 28      | +3016/-1368   |
+| placer14           | 27      | +824/-350     |
+| raulk              | 25      | +28718/-29849 |
+| mrsmkl             | 22      | +560/-368     |
+| travisperson       | 18      | +1354/-314    |
+| nonsense           | 16      | +2956/-2842   |
+| ingar              | 13      | +331/-123     |
+| daviddias          | 11      | +311/-11      |
+| Stebalien          | 11      | +1204/-980    |
+| RobQuistNL         | 10      | +69/-74       |
+
+# 0.1.0 / 2019-12-11
+
+We are very excited to release **lotus** 0.1.0. This is our testnet release. To install lotus and join the testnet, please visit [lotu.sh](lotu.sh). Please file bug reports as [issues](https://github.com/filecoin-project/lotus/issues).
+
+A huge thank you to all contributors for this testnet release!
diff --git a/Makefile b/Makefile
index 083a15d70..56ab361ec 100644
--- a/Makefile
+++ b/Makefile
@@ -3,8 +3,10 @@ SHELL=/usr/bin/env bash
 all: build
 .PHONY: all
 
+unexport GOFLAGS
+
 GOVERSION:=$(shell go version | cut -d' ' -f 3 | cut -d. -f 2)
-ifeq ($(shell expr $(GOVERSION) \< 13), 1)
+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
@@ -14,12 +16,19 @@ MODULES:=
 
 CLEAN:=
 BINS:=
-GOFLAGS+=-ldflags="-X "github.com/filecoin-project/lotus/build".CurrentCommit=+git$(subst -,.,$(shell git describe --always --match=NeVeRmAtCh --dirty 2>/dev/null || git rev-parse --short HEAD 2>/dev/null))"
+
+ldflags=-X=github.com/filecoin-project/lotus/build.CurrentCommit=+git.$(subst -,.,$(shell git describe --always --match=NeVeRmAtCh --dirty 2>/dev/null || git rev-parse --short HEAD 2>/dev/null))
+ifneq ($(strip $(LDFLAGS)),)
+	ldflags+=-extldflags=$(LDFLAGS)
+endif
+
+GOFLAGS+=-ldflags="$(ldflags)"
+
 
 ## FFI
 
 FFI_PATH:=extern/filecoin-ffi/
-FFI_DEPS:=libfilecoin.a filecoin.pc filecoin.h
+FFI_DEPS:=.install-filcrypto
 FFI_DEPS:=$(addprefix $(FFI_PATH),$(FFI_DEPS))
 
 $(FFI_DEPS): build/.filecoin-install ;
@@ -49,7 +58,10 @@ deps: $(BUILD_DEPS)
 .PHONY: deps
 
 debug: GOFLAGS+=-tags=debug
-debug: lotus lotus-storage-miner lotus-seal-worker lotus-seed
+debug: lotus lotus-miner lotus-worker lotus-seed
+
+2k: GOFLAGS+=-tags=2k
+2k: lotus lotus-miner lotus-worker lotus-seed
 
 lotus: $(BUILD_DEPS)
 	rm -f lotus
@@ -59,36 +71,49 @@ lotus: $(BUILD_DEPS)
 .PHONY: lotus
 BINS+=lotus
 
-lotus-storage-miner: $(BUILD_DEPS)
-	rm -f lotus-storage-miner
-	go build $(GOFLAGS) -o lotus-storage-miner ./cmd/lotus-storage-miner
-	go run github.com/GeertJohan/go.rice/rice append --exec lotus-storage-miner -i ./build
-.PHONY: lotus-storage-miner
-BINS+=lotus-storage-miner
+lotus-miner: $(BUILD_DEPS)
+	rm -f lotus-miner
+	go build $(GOFLAGS) -o lotus-miner ./cmd/lotus-storage-miner
+	go run github.com/GeertJohan/go.rice/rice append --exec lotus-miner -i ./build
+.PHONY: lotus-miner
+BINS+=lotus-miner
 
-lotus-seal-worker: $(BUILD_DEPS)
-	rm -f lotus-seal-worker
-	go build $(GOFLAGS) -o lotus-seal-worker ./cmd/lotus-seal-worker
-	go run github.com/GeertJohan/go.rice/rice append --exec lotus-seal-worker -i ./build
-.PHONY: lotus-seal-worker
-BINS+=lotus-seal-worker
+lotus-worker: $(BUILD_DEPS)
+	rm -f lotus-worker
+	go build $(GOFLAGS) -o lotus-worker ./cmd/lotus-seal-worker
+	go run github.com/GeertJohan/go.rice/rice append --exec lotus-worker -i ./build
+.PHONY: lotus-worker
+BINS+=lotus-worker
 
 lotus-shed: $(BUILD_DEPS)
 	rm -f lotus-shed
 	go build $(GOFLAGS) -o lotus-shed ./cmd/lotus-shed
-.PHONY: lotus-seal-worker
-BINS+=lotus-seal-worker
+	go run github.com/GeertJohan/go.rice/rice append --exec lotus-shed -i ./build
+.PHONY: lotus-shed
+BINS+=lotus-shed
 
-build: lotus lotus-storage-miner lotus-seal-worker
+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
 
 .PHONY: build
 
-install:
+install: install-daemon install-miner install-worker
+
+install-daemon:
 	install -C ./lotus /usr/local/bin/lotus
-	install -C ./lotus-storage-miner /usr/local/bin/lotus-storage-miner
-	install -C ./lotus-seal-worker /usr/local/bin/lotus-seal-worker
+
+install-miner:
+	install -C ./lotus-miner /usr/local/bin/lotus-miner
+
+install-worker:
+	install -C ./lotus-worker /usr/local/bin/lotus-worker
 
 # TOOLS
 
@@ -106,51 +131,141 @@ benchmarks:
 	@curl -X POST 'http://benchmark.kittyhawk.wtf/benchmark' -d '@bench.json' -u "${benchmark_http_cred}"
 .PHONY: benchmarks
 
-pond: build
-	go build -o pond ./lotuspond
+lotus-pond: 2k
+	go build -o lotus-pond ./lotuspond
 	(cd lotuspond/front && npm i && CI=false npm run build)
-.PHONY: pond
-BINS+=pond
+.PHONY: lotus-pond
+BINS+=lotus-pond
 
-townhall:
-	rm -f townhall
-	go build -o townhall ./cmd/lotus-townhall
+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 townhall -i ./cmd/lotus-townhall -i ./build
-.PHONY: townhall
-BINS+=townhall
+	go run github.com/GeertJohan/go.rice/rice append --exec lotus-townhall -i ./cmd/lotus-townhall -i ./build
+.PHONY: lotus-townhall
+BINS+=lotus-townhall
 
-fountain:
-	rm -f fountain
-	go build -o fountain ./cmd/lotus-fountain
-	go run github.com/GeertJohan/go.rice/rice append --exec fountain -i ./cmd/lotus-fountain
-.PHONY: fountain
-BINS+=fountain
+lotus-fountain:
+	rm -f lotus-fountain
+	go build -o lotus-fountain ./cmd/lotus-fountain
+	go run github.com/GeertJohan/go.rice/rice append --exec lotus-fountain -i ./cmd/lotus-fountain -i ./build
+.PHONY: lotus-fountain
+BINS+=lotus-fountain
 
-chainwatch:
-	rm -f chainwatch
-	go build -o chainwatch ./cmd/lotus-chainwatch
-	go run github.com/GeertJohan/go.rice/rice append --exec chainwatch -i ./cmd/lotus-chainwatch
-.PHONY: chainwatch
-BINS+=chainwatch
+lotus-chainwatch:
+	rm -f lotus-chainwatch
+	go build $(GOFLAGS) -o lotus-chainwatch ./cmd/lotus-chainwatch
+.PHONY: lotus-chainwatch
+BINS+=lotus-chainwatch
 
-bench:
-	rm -f bench
-	go build -o bench ./cmd/lotus-bench
-	go run github.com/GeertJohan/go.rice/rice append --exec bench -i ./build
-.PHONY: bench
-BINS+=bench
+lotus-bench:
+	rm -f lotus-bench
+	go build -o lotus-bench ./cmd/lotus-bench
+	go run github.com/GeertJohan/go.rice/rice append --exec lotus-bench -i ./build
+.PHONY: lotus-bench
+BINS+=lotus-bench
 
-stats:
-	rm -f stats
-	go build -o stats ./tools/stats
-.PHONY: stats
-BINS+=stats
+lotus-stats:
+	rm -f 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
+
+lotus-pcr:
+	rm -f lotus-pcr
+	go build $(GOFLAGS) -o lotus-pcr ./cmd/lotus-pcr
+	go run github.com/GeertJohan/go.rice/rice append --exec lotus-pcr -i ./build
+.PHONY: lotus-pcr
+BINS+=lotus-pcr
+
+lotus-health:
+	rm -f lotus-health
+	go build -o lotus-health ./cmd/lotus-health
+	go run github.com/GeertJohan/go.rice/rice append --exec lotus-health -i ./build
+.PHONY: lotus-health
+BINS+=lotus-health
+
+testground:
+	go build -tags testground -o /dev/null ./cmd/lotus
+.PHONY: testground
+BINS+=testground
+
+install-chainwatch: lotus-chainwatch
+	install -C ./lotus-chainwatch /usr/local/bin/lotus-chainwatch
+
+# SYSTEMD
+
+install-daemon-service: install-daemon
+	mkdir -p /etc/systemd/system
+	mkdir -p /var/log/lotus
+	install -C -m 0644 ./scripts/lotus-daemon.service /etc/systemd/system/lotus-daemon.service
+	systemctl daemon-reload
+	@echo
+	@echo "lotus-daemon service installed. Don't forget to run 'sudo systemctl start lotus-daemon' to start it and 'sudo systemctl enable lotus-daemon' for it to be enabled on startup."
+
+install-miner-service: install-miner install-daemon-service
+	mkdir -p /etc/systemd/system
+	mkdir -p /var/log/lotus
+	install -C -m 0644 ./scripts/lotus-miner.service /etc/systemd/system/lotus-miner.service
+	systemctl daemon-reload
+	@echo
+	@echo "lotus-miner service installed. Don't forget to run 'sudo systemctl start lotus-miner' to start it and 'sudo systemctl enable lotus-miner' for it to be enabled on startup."
+
+install-chainwatch-service: install-chainwatch install-daemon-service
+	mkdir -p /etc/systemd/system
+	mkdir -p /var/log/lotus
+	install -C -m 0644 ./scripts/lotus-chainwatch.service /etc/systemd/system/lotus-chainwatch.service
+	systemctl daemon-reload
+	@echo
+	@echo "chainwatch service installed. Don't forget to run 'sudo systemctl start lotus-chainwatch' to start it and 'sudo systemctl enable lotus-chainwatch' for it to be enabled on startup."
+
+install-main-services: install-miner-service
+
+install-all-services: install-main-services install-chainwatch-service
+
+install-services: install-main-services
+
+clean-daemon-service: clean-miner-service clean-chainwatch-service
+	-systemctl stop lotus-daemon
+	-systemctl disable lotus-daemon
+	rm -f /etc/systemd/system/lotus-daemon.service
+	systemctl daemon-reload
+
+clean-miner-service:
+	-systemctl stop lotus-miner
+	-systemctl disable lotus-miner
+	rm -f /etc/systemd/system/lotus-miner.service
+	systemctl daemon-reload
+
+clean-chainwatch-service:
+	-systemctl stop lotus-chainwatch
+	-systemctl disable lotus-chainwatch
+	rm -f /etc/systemd/system/lotus-chainwatch.service
+	systemctl daemon-reload
+
+clean-main-services: clean-daemon-service
+
+clean-all-services: clean-main-services
+
+clean-services: clean-all-services
 
 # MISC
 
 buildall: $(BINS)
 
+completions:
+	./scripts/make-completions.sh lotus
+	./scripts/make-completions.sh lotus-miner
+.PHONY: completions
+
+install-completions:
+	mkdir -p /usr/share/bash-completion/completions /usr/local/share/zsh/site-functions/
+	install -C ./scripts/bash-completion/lotus /usr/share/bash-completion/completions/lotus
+	install -C ./scripts/bash-completion/lotus-miner /usr/share/bash-completion/completions/lotus-miner
+	install -C ./scripts/zsh-completion/lotus /usr/local/share/zsh/site-functions/_lotus
+	install -C ./scripts/zsh-completion/lotus-miner /usr/local/share/zsh/site-functions/_lotus-miner
+
 clean:
 	rm -rf $(CLEAN) $(BINS)
 	-$(MAKE) -C $(FFI_PATH) clean
@@ -163,6 +278,15 @@ dist-clean:
 
 type-gen:
 	go run ./gen/main.go
+	go generate ./...
+
+method-gen:
+	(cd ./lotuspond/front/src/chain && go run ./methodgen.go)
+
+gen: type-gen method-gen
+
+docsgen:
+	go run ./api/docgen > documentation/en/api-methods.md
 
 print-%:
 	@echo $*=$($*)
diff --git a/README.md b/README.md
index b89849496..766317e4f 100644
--- a/README.md
+++ b/README.md
@@ -1,16 +1,47 @@
-![Lotus](documentation/images/lotus_logo_h.png)
+<p align="center">
+  <a href="https://lotu.sh/" title="Lotus Docs">
+    <img src="documentation/images/lotus_logo_h.png" alt="Project Lotus Logo" width="244" />
+  </a>
+</p>
 
-# Project Lotus - 莲
+<h1 align="center">Project Lotus - 莲</h1>
 
-Lotus is an experimental implementation of the Filecoin Distributed Storage Network. For more details about Filecoin, check out the [Filecoin Spec](https://github.com/filecoin-project/specs).
+<p align="center">
+  <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.14.7-blue.svg" /></a>
+  <br>
+</p>
 
-## Development
-
-All work is tracked via issues. An attempt at keeping an up-to-date view on remaining work is in the [lotus testnet github project board](https://github.com/filecoin-project/lotus/projects/1).
+Lotus is an implementation of the Filecoin Distributed Storage Network. For more details about Filecoin, check out the [Filecoin Spec](https://spec.filecoin.io).
 
 ## Building & Documentation
 
-For instructions on how to build lotus from source, please visit [https://docs.lotu.sh](https://docs.lotu.sh) or read the source [here](https://github.com/filecoin-project/lotus/tree/master/documentation).
+For instructions on how to build lotus from source, please visit [Lotus build and setup instruction](https://docs.filecoin.io/get-started/lotus/installation/#minimal-requirements) or read the source [here](https://github.com/filecoin-project/lotus/tree/master/documentation).
+
+## Reporting a Vulnerability
+
+Please send an email to security@filecoin.org. See our [security policy](SECURITY.md) for more details.
+
+## Development
+
+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)
+- [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
 
diff --git a/SECURITY.md b/SECURITY.md
new file mode 100644
index 000000000..ecb600deb
--- /dev/null
+++ b/SECURITY.md
@@ -0,0 +1,29 @@
+# Security Policy
+
+## Reporting a Vulnerability
+
+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 '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.
+* If you can maintain power without submitting windowed posts regularly.
+* If you can craft a message that causes lotus nodes to panic.
+* If you can cause your miner to win significantly more blocks than it should.
+* 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 'critical'.
+
+## Supported Versions
+
+* TODO: This should be defined and set up by Mainnet launch.
+
+| Version | Supported          |
+| ------- | ------------------ |
+| Testnet | :white_check_mark: |
diff --git a/api/api_common.go b/api/api_common.go
index 81608c59e..f8fcbe8c5 100644
--- a/api/api_common.go
+++ b/api/api_common.go
@@ -4,31 +4,61 @@ import (
 	"context"
 	"fmt"
 
-	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/go-jsonrpc/auth"
+	metrics "github.com/libp2p/go-libp2p-core/metrics"
 	"github.com/libp2p/go-libp2p-core/network"
 	"github.com/libp2p/go-libp2p-core/peer"
+	protocol "github.com/libp2p/go-libp2p-core/protocol"
+
+	"github.com/filecoin-project/lotus/build"
 )
 
-type Permission = string
-
 type Common interface {
-	// Auth
-	AuthVerify(ctx context.Context, token string) ([]Permission, error)
-	AuthNew(ctx context.Context, perms []Permission) ([]byte, error)
 
-	// network
+	// MethodGroup: Auth
+
+	AuthVerify(ctx context.Context, token string) ([]auth.Permission, error)
+	AuthNew(ctx context.Context, perms []auth.Permission) ([]byte, error)
+
+	// MethodGroup: Net
 
 	NetConnectedness(context.Context, peer.ID) (network.Connectedness, error)
 	NetPeers(context.Context) ([]peer.AddrInfo, error)
 	NetConnect(context.Context, peer.AddrInfo) error
 	NetAddrsListen(context.Context) (peer.AddrInfo, error)
 	NetDisconnect(context.Context, peer.ID) error
+	NetFindPeer(context.Context, peer.ID) (peer.AddrInfo, error)
+	NetPubsubScores(context.Context) ([]PubsubScore, error)
+	NetAutoNatStatus(context.Context) (NatInfo, error)
+	NetAgentVersion(ctx context.Context, p peer.ID) (string, error)
+
+	// NetBandwidthStats returns statistics about the nodes total bandwidth
+	// usage and current rate across all peers and protocols.
+	NetBandwidthStats(ctx context.Context) (metrics.Stats, error)
+
+	// NetBandwidthStatsByPeer returns statistics about the nodes bandwidth
+	// usage and current rate per peer
+	NetBandwidthStatsByPeer(ctx context.Context) (map[string]metrics.Stats, error)
+
+	// NetBandwidthStatsByProtocol returns statistics about the nodes bandwidth
+	// usage and current rate per protocol
+	NetBandwidthStatsByProtocol(ctx context.Context) (map[protocol.ID]metrics.Stats, error)
+
+	// MethodGroup: Common
 
 	// ID returns peerID of libp2p node backing this API
 	ID(context.Context) (peer.ID, error)
 
 	// Version provides information about API provider
 	Version(context.Context) (Version, error)
+
+	LogList(context.Context) ([]string, error)
+	LogSetLevel(context.Context, string, string) error
+
+	// trigger graceful shutdown
+	Shutdown(context.Context) error
+
+	Closing(context.Context) (<-chan struct{}, error)
 }
 
 // Version provides various build-time information
@@ -50,3 +80,8 @@ type Version struct {
 func (v Version) String() string {
 	return fmt.Sprintf("%s+api%s", v.Version, v.APIVersion.String())
 }
+
+type NatInfo struct {
+	Reachability network.Reachability
+	PublicAddr   string
+}
diff --git a/api/api_full.go b/api/api_full.go
index 996d4abbe..6d2d0c7b5 100644
--- a/api/api_full.go
+++ b/api/api_full.go
@@ -2,87 +2,292 @@ package api
 
 import (
 	"context"
+	"fmt"
 	"time"
 
+	"github.com/filecoin-project/go-state-types/network"
+
 	"github.com/ipfs/go-cid"
-	"github.com/ipfs/go-filestore"
 	"github.com/libp2p/go-libp2p-core/peer"
 
 	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/lotus/chain/actors"
-	"github.com/filecoin-project/lotus/chain/store"
+	"github.com/filecoin-project/go-bitfield"
+	"github.com/filecoin-project/go-fil-markets/retrievalmarket"
+	"github.com/filecoin-project/go-fil-markets/storagemarket"
+	"github.com/filecoin-project/go-multistore"
+	"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/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"
 )
 
 // FullNode API is a low-level interface to the Filecoin network full node
 type FullNode interface {
 	Common
 
-	// chain
+	// MethodGroup: Chain
+	// The Chain method group contains methods for interacting with the
+	// blockchain, but that do not require any form of state computation.
 
-	// ChainNotify returns channel with chain head updates
-	// First message is guaranteed to be of len == 1, and type == 'current'
-	ChainNotify(context.Context) (<-chan []*store.HeadChange, error)
+	// ChainNotify returns channel with chain head updates.
+	// First message is guaranteed to be of len == 1, and type == 'current'.
+	ChainNotify(context.Context) (<-chan []*HeadChange, error)
+
+	// ChainHead returns the current head of the chain.
 	ChainHead(context.Context) (*types.TipSet, error)
-	ChainGetRandomness(context.Context, types.TipSetKey, int64) ([]byte, error)
+
+	// ChainGetRandomnessFromTickets is used to sample the chain for randomness.
+	ChainGetRandomnessFromTickets(ctx context.Context, tsk types.TipSetKey, personalization crypto.DomainSeparationTag, randEpoch abi.ChainEpoch, entropy []byte) (abi.Randomness, error)
+
+	// ChainGetRandomnessFromBeacon is used to sample the beacon for randomness.
+	ChainGetRandomnessFromBeacon(ctx context.Context, tsk types.TipSetKey, personalization crypto.DomainSeparationTag, randEpoch abi.ChainEpoch, entropy []byte) (abi.Randomness, error)
+
+	// ChainGetBlock returns the block specified by the given CID.
 	ChainGetBlock(context.Context, cid.Cid) (*types.BlockHeader, error)
+	// ChainGetTipSet returns the tipset specified by the given TipSetKey.
 	ChainGetTipSet(context.Context, types.TipSetKey) (*types.TipSet, error)
-	ChainGetBlockMessages(context.Context, cid.Cid) (*BlockMessages, error)
-	ChainGetParentReceipts(context.Context, cid.Cid) ([]*types.MessageReceipt, error)
-	ChainGetParentMessages(context.Context, cid.Cid) ([]Message, error)
-	ChainGetTipSetByHeight(context.Context, uint64, *types.TipSet) (*types.TipSet, error)
+
+	// ChainGetBlockMessages returns messages stored in the specified block.
+	ChainGetBlockMessages(ctx context.Context, blockCid cid.Cid) (*BlockMessages, error)
+
+	// ChainGetParentReceipts returns receipts for messages in parent tipset of
+	// the specified block.
+	ChainGetParentReceipts(ctx context.Context, blockCid cid.Cid) ([]*types.MessageReceipt, error)
+
+	// ChainGetParentMessages returns messages stored in parent tipset of the
+	// specified block.
+	ChainGetParentMessages(ctx context.Context, blockCid cid.Cid) ([]Message, error)
+
+	// ChainGetTipSetByHeight looks back for a tipset at the specified epoch.
+	// If there are no blocks at the specified epoch, a tipset at an earlier epoch
+	// will be returned.
+	ChainGetTipSetByHeight(context.Context, abi.ChainEpoch, types.TipSetKey) (*types.TipSet, error)
+
+	// ChainReadObj reads ipld nodes referenced by the specified CID from chain
+	// blockstore and returns raw bytes.
 	ChainReadObj(context.Context, cid.Cid) ([]byte, error)
-	ChainSetHead(context.Context, *types.TipSet) 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)
+
+	// ChainStatObj returns statistics about the graph referenced by 'obj'.
+	// If 'base' is also specified, then the returned stat will be a diff
+	// between the two objects.
+	ChainStatObj(ctx context.Context, obj cid.Cid, base cid.Cid) (ObjStat, error)
+
+	// ChainSetHead forcefully sets current chain head. Use with caution.
+	ChainSetHead(context.Context, types.TipSetKey) error
+
+	// ChainGetGenesis returns the genesis tipset.
 	ChainGetGenesis(context.Context) (*types.TipSet, error)
-	ChainTipSetWeight(context.Context, *types.TipSet) (types.BigInt, error)
-	ChainGetNode(ctx context.Context, p string) (interface{}, error)
+
+	// ChainTipSetWeight computes weight for the specified tipset.
+	ChainTipSetWeight(context.Context, types.TipSetKey) (types.BigInt, error)
+	ChainGetNode(ctx context.Context, p string) (*IpldObject, error)
+
+	// ChainGetMessage reads a message referenced by the specified CID from the
+	// chain blockstore.
 	ChainGetMessage(context.Context, cid.Cid) (*types.Message, error)
 
-	// syncer
+	// ChainGetPath returns a set of revert/apply operations needed to get from
+	// one tipset to another, for example:
+	//```
+	//        to
+	//         ^
+	// from   tAA
+	//   ^     ^
+	// tBA    tAB
+	//  ^---*--^
+	//      ^
+	//     tRR
+	//```
+	// Would return `[revert(tBA), apply(tAB), apply(tAA)]`
+	ChainGetPath(ctx context.Context, from types.TipSetKey, to types.TipSetKey) ([]*HeadChange, error)
+
+	// ChainExport returns a stream of bytes with CAR dump of chain data.
+	// 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)
+
+	// MethodGroup: Beacon
+	// The Beacon method group contains methods for interacting with the random beacon (DRAND)
+
+	// BeaconGetEntry returns the beacon entry for the given filecoin epoch. If
+	// the entry has not yet been produced, the call will block until the entry
+	// becomes available
+	BeaconGetEntry(ctx context.Context, epoch abi.ChainEpoch) (*types.BeaconEntry, error)
+
+	// GasEstimateFeeCap estimates gas fee cap
+	GasEstimateFeeCap(context.Context, *types.Message, int64, types.TipSetKey) (types.BigInt, error)
+
+	// GasEstimateGasLimit estimates gas used by the message and returns it.
+	// It fails if message fails to execute.
+	GasEstimateGasLimit(context.Context, *types.Message, types.TipSetKey) (int64, error)
+
+	// GasEstimateGasPremium estimates what gas price should be used for a
+	// message to have high likelihood of inclusion in `nblocksincl` epochs.
+
+	GasEstimateGasPremium(_ context.Context, nblocksincl uint64,
+		sender address.Address, gaslimit int64, tsk types.TipSetKey) (types.BigInt, error)
+
+	// GasEstimateMessageGas estimates gas values for unset message gas fields
+	GasEstimateMessageGas(context.Context, *types.Message, *MessageSendSpec, types.TipSetKey) (*types.Message, error)
+
+	// MethodGroup: Sync
+	// The Sync method group contains methods for interacting with and
+	// observing the lotus sync service.
+
+	// SyncState returns the current status of the lotus sync system.
 	SyncState(context.Context) (*SyncState, error)
+
+	// SyncSubmitBlock can be used to submit a newly created block to the.
+	// network through this node
 	SyncSubmitBlock(ctx context.Context, blk *types.BlockMsg) error
+
+	// SyncIncomingBlocks returns a channel streaming incoming, potentially not
+	// yet synced block headers.
 	SyncIncomingBlocks(ctx context.Context) (<-chan *types.BlockHeader, error)
+
+	// SyncCheckpoint marks a blocks as checkpointed, meaning that it won't ever fork away from it.
+	SyncCheckpoint(ctx context.Context, tsk types.TipSetKey) error
+
+	// SyncMarkBad marks a blocks as bad, meaning that it won't ever by synced.
+	// Use with extreme caution.
 	SyncMarkBad(ctx context.Context, bcid cid.Cid) error
 
-	// messages
-	MpoolPending(context.Context, *types.TipSet) ([]*types.SignedMessage, error)
+	// SyncUnmarkBad unmarks a blocks as bad, making it possible to be validated and synced again.
+	SyncUnmarkBad(ctx context.Context, bcid cid.Cid) error
+
+	// SyncCheckBad checks if a block was marked as bad, and if it was, returns
+	// the reason.
+	SyncCheckBad(ctx context.Context, bcid cid.Cid) (string, error)
+
+	// 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.
+
+	// MpoolPending returns pending mempool messages.
+	MpoolPending(context.Context, types.TipSetKey) ([]*types.SignedMessage, error)
+
+	// MpoolSelect returns a list of pending messages for inclusion in the next block
+	MpoolSelect(context.Context, types.TipSetKey, float64) ([]*types.SignedMessage, error)
+
+	// MpoolPush pushes a signed message to mempool.
 	MpoolPush(context.Context, *types.SignedMessage) (cid.Cid, error)
-	MpoolPushMessage(context.Context, *types.Message) (*types.SignedMessage, error) // get nonce, sign, push
+
+	// MpoolPushMessage atomically assigns a nonce, signs, and pushes a message
+	// to mempool.
+	// maxFee is only used when GasFeeCap/GasPremium fields aren't specified
+	//
+	// When maxFee is set to 0, MpoolPushMessage will guess appropriate fee
+	// based on current chain conditions
+	MpoolPushMessage(ctx context.Context, msg *types.Message, spec *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)
 	MpoolSub(context.Context) (<-chan MpoolUpdate, error)
 
-	// FullNodeStruct
+	// MpoolClear clears pending messages from the mpool
+	MpoolClear(context.Context, bool) error
 
-	// miner
+	// MpoolGetConfig returns (a copy of) the current mpool config
+	MpoolGetConfig(context.Context) (*types.MpoolConfig, error)
+	// MpoolSetConfig sets the mpool config to (a copy of) the supplied config
+	MpoolSetConfig(context.Context, *types.MpoolConfig) error
 
-	MinerCreateBlock(context.Context, address.Address, *types.TipSet, *types.Ticket, *types.EPostProof, []*types.SignedMessage, uint64, uint64) (*types.BlockMsg, error)
+	// MethodGroup: Miner
+
+	MinerGetBaseInfo(context.Context, address.Address, abi.ChainEpoch, types.TipSetKey) (*MiningBaseInfo, error)
+	MinerCreateBlock(context.Context, *BlockTemplate) (*types.BlockMsg, error)
 
 	// // UX ?
 
-	// wallet
+	// MethodGroup: Wallet
 
-	WalletNew(context.Context, string) (address.Address, error)
+	// WalletNew creates a new address in the wallet with the given sigType.
+	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.
 	WalletList(context.Context) ([]address.Address, error)
+	// WalletBalance returns the balance of the given address at the current head of the chain.
 	WalletBalance(context.Context, address.Address) (types.BigInt, error)
-	WalletSign(context.Context, address.Address, []byte) (*types.Signature, error)
+	// WalletSign signs the given bytes using the given address.
+	WalletSign(context.Context, address.Address, []byte) (*crypto.Signature, error)
+	// WalletSignMessage signs the given message using the given address.
 	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)
+	// 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.
 	WalletSetDefault(context.Context, address.Address) error
+	// WalletExport returns the private key of an address in the wallet.
 	WalletExport(context.Context, address.Address) (*types.KeyInfo, error)
+	// WalletImport receives a KeyInfo, which includes a private key, and imports it into the wallet.
 	WalletImport(context.Context, *types.KeyInfo) (address.Address, error)
+	// WalletDelete deletes an address from the wallet.
+	WalletDelete(context.Context, address.Address) error
 
 	// Other
 
-	// ClientImport imports file under the specified path into filestore
-	ClientImport(ctx context.Context, path string) (cid.Cid, error)
-	ClientStartDeal(ctx context.Context, data cid.Cid, addr address.Address, miner address.Address, epochPrice types.BigInt, blocksDuration uint64) (*cid.Cid, error)
+	// MethodGroup: Client
+	// The Client methods all have to do with interacting with the storage and
+	// retrieval markets as a client
+
+	// ClientImport imports file under the specified path into filestore.
+	ClientImport(ctx context.Context, ref FileRef) (*ImportRes, error)
+	// ClientRemoveImport removes file import
+	ClientRemoveImport(ctx context.Context, importID multistore.StoreID) error
+	// ClientStartDeal proposes a deal with a miner.
+	ClientStartDeal(ctx context.Context, params *StartDealParams) (*cid.Cid, error)
+	// ClientGetDealInfo returns the latest information about a given deal.
 	ClientGetDealInfo(context.Context, cid.Cid) (*DealInfo, error)
+	// ClientListDeals returns information about the deals made by the local client.
 	ClientListDeals(ctx context.Context) ([]DealInfo, error)
+	// ClientGetDealUpdates returns the status of updated deals
+	ClientGetDealUpdates(ctx context.Context) (<-chan DealInfo, error)
+	// ClientHasLocal indicates whether a certain CID is locally stored.
 	ClientHasLocal(ctx context.Context, root cid.Cid) (bool, error)
-	ClientFindData(ctx context.Context, root cid.Cid) ([]QueryOffer, error)
-	ClientRetrieve(ctx context.Context, order RetrievalOrder, path string) error
-	ClientQueryAsk(ctx context.Context, p peer.ID, miner address.Address) (*types.SignedStorageAsk, error)
+	// ClientFindData identifies peers that have a certain file, and returns QueryOffers (one per peer).
+	ClientFindData(ctx context.Context, root cid.Cid, piece *cid.Cid) ([]QueryOffer, error)
+	// ClientMinerQueryOffer returns a QueryOffer for the specific miner and file.
+	ClientMinerQueryOffer(ctx context.Context, miner address.Address, root cid.Cid, piece *cid.Cid) (QueryOffer, error)
+	// ClientRetrieve initiates the retrieval of a file, as specified in the order.
+	ClientRetrieve(ctx context.Context, order RetrievalOrder, ref *FileRef) error
+	// ClientRetrieveWithEvents initiates the retrieval of a file, as specified in the order, and provides a channel
+	// of status updates.
+	ClientRetrieveWithEvents(ctx context.Context, order RetrievalOrder, ref *FileRef) (<-chan marketevents.RetrievalEvent, error)
+	// ClientQueryAsk returns a signed StorageAsk from the specified miner.
+	ClientQueryAsk(ctx context.Context, p peer.ID, miner address.Address) (*storagemarket.SignedStorageAsk, error)
+	// 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.
+	ClientGenCar(ctx context.Context, ref FileRef, outpath string) error
+	// ClientDealSize calculates real deal data size
+	ClientDealSize(ctx context.Context, root cid.Cid) (DataSize, error)
+	// ClientListTransfers returns the status of all ongoing transfers of data
+	ClientListDataTransfers(ctx context.Context) ([]DataTransferChannel, error)
+	ClientDataTransferUpdates(ctx context.Context) (<-chan DataTransferChannel, 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
 
 	// ClientUnimport removes references to the specified file from filestore
 	//ClientUnimport(path string)
@@ -92,77 +297,244 @@ type FullNode interface {
 
 	//ClientListAsks() []Ask
 
-	// if tipset is nil, we'll use heaviest
-	StateCall(context.Context, *types.Message, *types.TipSet) (*types.MessageReceipt, error)
-	StateReplay(context.Context, *types.TipSet, cid.Cid) (*ReplayResults, error)
-	StateGetActor(ctx context.Context, actor address.Address, ts *types.TipSet) (*types.Actor, error)
-	StateReadState(ctx context.Context, act *types.Actor, ts *types.TipSet) (*ActorState, error)
-	StateListMessages(ctx context.Context, match *types.Message, ts *types.TipSet, toht uint64) ([]cid.Cid, error)
+	// MethodGroup: State
+	// The State methods are used to query, inspect, and interact with chain state.
+	// All methods take a TipSetKey as a parameter. The state looked up is the state at that tipset.
+	// A nil TipSetKey can be provided as a param, this will cause the heaviest tipset in the chain to be used.
 
-	StateMinerSectors(context.Context, address.Address, *types.TipSet) ([]*ChainSectorInfo, error)
-	StateMinerProvingSet(context.Context, address.Address, *types.TipSet) ([]*ChainSectorInfo, error)
-	StateMinerPower(context.Context, address.Address, *types.TipSet) (MinerPower, error)
-	StateMinerWorker(context.Context, address.Address, *types.TipSet) (address.Address, error)
-	StateMinerPeerID(ctx context.Context, m address.Address, ts *types.TipSet) (peer.ID, error)
-	StateMinerElectionPeriodStart(ctx context.Context, actor address.Address, ts *types.TipSet) (uint64, error)
-	StateMinerSectorSize(context.Context, address.Address, *types.TipSet) (uint64, error)
-	StatePledgeCollateral(context.Context, *types.TipSet) (types.BigInt, error)
-	StateWaitMsg(context.Context, cid.Cid) (*MsgWait, error)
-	StateListMiners(context.Context, *types.TipSet) ([]address.Address, error)
-	StateListActors(context.Context, *types.TipSet) ([]address.Address, error)
-	StateMarketBalance(context.Context, address.Address, *types.TipSet) (actors.StorageParticipantBalance, error)
-	StateMarketParticipants(context.Context, *types.TipSet) (map[string]actors.StorageParticipantBalance, error)
-	StateMarketDeals(context.Context, *types.TipSet) (map[string]actors.OnChainDeal, error)
-	StateMarketStorageDeal(context.Context, uint64, *types.TipSet) (*actors.OnChainDeal, error)
-	StateLookupID(context.Context, address.Address, *types.TipSet) (address.Address, error)
+	// StateCall runs the given message and returns its result without any persisted changes.
+	StateCall(context.Context, *types.Message, types.TipSetKey) (*InvocResult, error)
+	// StateReplay returns the result of executing the indicated message, assuming it was executed in the indicated tipset.
+	StateReplay(context.Context, types.TipSetKey, cid.Cid) (*InvocResult, error)
+	// StateGetActor returns the indicated actor's nonce and balance.
+	StateGetActor(ctx context.Context, actor address.Address, tsk types.TipSetKey) (*types.Actor, error)
+	// StateReadState returns the indicated actor's state.
+	StateReadState(ctx context.Context, actor address.Address, tsk types.TipSetKey) (*ActorState, error)
+	// StateListMessages looks back and returns all messages with a matching to or from address, stopping at the given height.
+	StateListMessages(ctx context.Context, match *types.Message, tsk types.TipSetKey, toht abi.ChainEpoch) ([]cid.Cid, error)
+
+	// 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)
+	// StateMinerActiveSectors returns info about sectors that a given miner is actively proving.
+	StateMinerActiveSectors(context.Context, address.Address, types.TipSetKey) ([]*miner.SectorOnChainInfo, error)
+	// StateMinerProvingDeadline calculates the deadline at some epoch for a proving period
+	// and returns the deadline-related calculations.
+	StateMinerProvingDeadline(context.Context, address.Address, types.TipSetKey) (*dline.Info, error)
+	// 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)
+	// 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)
+	// 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
+	StateAllMinerFaults(ctx context.Context, lookback abi.ChainEpoch, ts types.TipSetKey) ([]*Fault, error)
+	// StateMinerRecoveries returns a bitfield indicating the recovering sectors of the given miner
+	StateMinerRecoveries(context.Context, address.Address, types.TipSetKey) (bitfield.BitField, error)
+	// StateMinerInitialPledgeCollateral returns the precommit deposit for the specified miner's sector
+	StateMinerPreCommitDepositForPower(context.Context, address.Address, miner.SectorPreCommitInfo, types.TipSetKey) (types.BigInt, error)
+	// StateMinerInitialPledgeCollateral returns the initial pledge collateral for the specified miner's sector
+	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)
+	// 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
+	// NOTE: returned info.Expiration may not be accurate in some cases, use StateSectorExpiration to get accurate
+	// 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)
+	// StateSectorPartition finds deadline/partition with the specified sector
+	StateSectorPartition(ctx context.Context, maddr address.Address, sectorNumber abi.SectorNumber, tok types.TipSetKey) (*miner.SectorLocation, error)
+	// StateSearchMsg searches for a message in the chain, and returns its receipt and the tipset where it was executed
+	StateSearchMsg(context.Context, cid.Cid) (*MsgLookup, error)
+	// StateMsgGasCost searches for a message in the chain, and returns details of the messages gas costs, including the penalty and miner tip
+	StateMsgGasCost(context.Context, cid.Cid, types.TipSetKey) (*MsgGasCost, error)
+	// StateWaitMsg looks back in the chain for a message. If not found, it blocks until the
+	// message arrives on chain, and gets to the indicated confidence depth.
+	StateWaitMsg(ctx context.Context, cid cid.Cid, confidence uint64) (*MsgLookup, error)
+	// 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
+	StateListActors(context.Context, types.TipSetKey) ([]address.Address, error)
+	// StateMarketBalance looks up the Escrow and Locked balances of the given address in the Storage Market
+	StateMarketBalance(context.Context, address.Address, types.TipSetKey) (MarketBalance, error)
+	// StateMarketParticipants returns the Escrow and Locked balances of every participant in the Storage Market
+	StateMarketParticipants(context.Context, types.TipSetKey) (map[string]MarketBalance, error)
+	// StateMarketDeals returns information about every deal in the Storage Market
+	StateMarketDeals(context.Context, types.TipSetKey) (map[string]MarketDeal, error)
+	// StateMarketStorageDeal returns information about the indicated deal
+	StateMarketStorageDeal(context.Context, abi.DealID, types.TipSetKey) (*MarketDeal, error)
+	// StateLookupID retrieves the ID address of the given address
+	StateLookupID(context.Context, address.Address, types.TipSetKey) (address.Address, error)
+	// StateAccountKey returns the public key address of the given ID address
+	StateAccountKey(context.Context, address.Address, types.TipSetKey) (address.Address, error)
+	// StateChangedActors returns all the actors whose states change between the two given state CIDs
+	// TODO: Should this take tipset keys instead?
 	StateChangedActors(context.Context, cid.Cid, cid.Cid) (map[string]types.Actor, error)
-	StateGetReceipt(context.Context, cid.Cid, *types.TipSet) (*types.MessageReceipt, error)
-	StateMinerSectorCount(context.Context, address.Address, *types.TipSet) (MinerSectors, error)
+	// StateGetReceipt returns the message receipt for the given message
+	StateGetReceipt(context.Context, cid.Cid, types.TipSetKey) (*types.MessageReceipt, error)
+	// StateMinerSectorCount returns the number of sectors in a miner's sector set and proving set
+	StateMinerSectorCount(context.Context, address.Address, types.TipSetKey) (MinerSectors, error)
+	// 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)
+	// 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)
+	// 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)
 
-	MarketEnsureAvailable(context.Context, address.Address, types.BigInt) error
+	// StateCirculatingSupply returns the circulating supply of Filecoin at the given tipset
+	StateCirculatingSupply(context.Context, types.TipSetKey) (CirculatingSupply, error)
+	// StateNetworkVersion returns the network version at the given tipset
+	StateNetworkVersion(context.Context, types.TipSetKey) (network.Version, error)
+
+	// MethodGroup: Msig
+	// The Msig methods are used to interact with multisig wallets on the
+	// filecoin network
+
+	// MsigGetAvailableBalance returns the portion of a multisig's balance that can be withdrawn or spent
+	MsigGetAvailableBalance(context.Context, address.Address, types.TipSetKey) (types.BigInt, error)
+	// MsigGetVested returns the amount of FIL that vested in a multisig in a certain period.
+	// It takes the following params: <multisig address>, <start epoch>, <end epoch>
+	MsigGetVested(context.Context, address.Address, types.TipSetKey, types.TipSetKey) (types.BigInt, error)
+	// MsigCreate creates a multisig wallet
+	// It takes the following params: <required number of senders>, <approving addresses>, <unlock duration>
+	//<initial balance>, <sender address of the create msg>, <gas price>
+	MsigCreate(context.Context, uint64, []address.Address, abi.ChainEpoch, types.BigInt, address.Address, types.BigInt) (cid.Cid, error)
+	// MsigPropose proposes a multisig message
+	// 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
+	// It takes the following params: <multisig address>, <proposed message ID>, <proposer address>, <recipient address>, <value to transfer>,
+	// <sender address of the approve msg>, <method to call in the proposed message>, <params to include in the proposed message>
+	MsigApprove(context.Context, address.Address, uint64, address.Address, address.Address, types.BigInt, address.Address, uint64, []byte) (cid.Cid, error)
+	// MsigCancel cancels a previously-proposed multisig message
+	// It takes the following params: <multisig address>, <proposed message ID>, <recipient address>, <value to transfer>,
+	// <sender address of the cancel msg>, <method to call in the proposed message>, <params to include in the proposed message>
+	MsigCancel(context.Context, address.Address, uint64, address.Address, types.BigInt, address.Address, uint64, []byte) (cid.Cid, error)
+	// MsigAddPropose proposes adding a signer in the multisig
+	// It takes the following params: <multisig address>, <sender address of the propose msg>,
+	// <new signer>, <whether the number of required signers should be increased>
+	MsigAddPropose(context.Context, address.Address, address.Address, address.Address, bool) (cid.Cid, error)
+	// MsigAddApprove approves a previously proposed AddSigner message
+	// It takes the following params: <multisig address>, <sender address of the approve msg>, <proposed message ID>,
+	// <proposer address>, <new signer>, <whether the number of required signers should be increased>
+	MsigAddApprove(context.Context, address.Address, address.Address, uint64, address.Address, address.Address, bool) (cid.Cid, error)
+	// MsigAddCancel cancels a previously proposed AddSigner message
+	// It takes the following params: <multisig address>, <sender address of the cancel msg>, <proposed message ID>,
+	// <new signer>, <whether the number of required signers should be increased>
+	MsigAddCancel(context.Context, address.Address, address.Address, uint64, address.Address, bool) (cid.Cid, error)
+	// MsigSwapPropose proposes swapping 2 signers in the multisig
+	// It takes the following params: <multisig address>, <sender address of the propose msg>,
+	// <old signer>, <new signer>
+	MsigSwapPropose(context.Context, address.Address, address.Address, address.Address, address.Address) (cid.Cid, error)
+	// MsigSwapApprove approves a previously proposed SwapSigner
+	// It takes the following params: <multisig address>, <sender address of the approve msg>, <proposed message ID>,
+	// <proposer address>, <old signer>, <new signer>
+	MsigSwapApprove(context.Context, address.Address, address.Address, uint64, address.Address, address.Address, address.Address) (cid.Cid, error)
+	// MsigSwapCancel cancels a previously proposed SwapSigner message
+	// It takes the following params: <multisig address>, <sender address of the cancel msg>, <proposed message ID>,
+	// <old signer>, <new signer>
+	MsigSwapCancel(context.Context, address.Address, address.Address, uint64, address.Address, address.Address) (cid.Cid, error)
+
+	MarketEnsureAvailable(context.Context, address.Address, address.Address, types.BigInt) (cid.Cid, error)
 	// MarketFreeBalance
 
-	PaychGet(ctx context.Context, from, to address.Address, ensureFunds types.BigInt) (*ChannelInfo, error)
+	// 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)
 	PaychList(context.Context) ([]address.Address, error)
 	PaychStatus(context.Context, address.Address) (*PaychStatus, error)
-	PaychClose(context.Context, address.Address) (cid.Cid, error)
+	PaychSettle(context.Context, address.Address) (cid.Cid, error)
+	PaychCollect(context.Context, address.Address) (cid.Cid, error)
 	PaychAllocateLane(ctx context.Context, ch address.Address) (uint64, error)
 	PaychNewPayment(ctx context.Context, from, to address.Address, vouchers []VoucherSpec) (*PaymentInfo, error)
-	PaychVoucherCheckValid(context.Context, address.Address, *types.SignedVoucher) error
-	PaychVoucherCheckSpendable(context.Context, address.Address, *types.SignedVoucher, []byte, []byte) (bool, error)
-	PaychVoucherCreate(context.Context, address.Address, types.BigInt, uint64) (*types.SignedVoucher, error)
-	PaychVoucherAdd(context.Context, address.Address, *types.SignedVoucher, []byte, types.BigInt) (types.BigInt, error)
-	PaychVoucherList(context.Context, address.Address) ([]*types.SignedVoucher, error)
-	PaychVoucherSubmit(context.Context, address.Address, *types.SignedVoucher) (cid.Cid, error)
+	PaychVoucherCheckValid(context.Context, address.Address, *paych.SignedVoucher) error
+	PaychVoucherCheckSpendable(context.Context, address.Address, *paych.SignedVoucher, []byte, []byte) (bool, error)
+	PaychVoucherCreate(context.Context, address.Address, types.BigInt, uint64) (*VoucherCreateResult, error)
+	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)
+}
+
+type FileRef struct {
+	Path  string
+	IsCAR bool
 }
 
 type MinerSectors struct {
-	Pset uint64
-	Sset uint64
+	// Live sectors that should be proven.
+	Live uint64
+	// Sectors actively contributing to power.
+	Active uint64
+	// Sectors with failed proofs.
+	Faulty uint64
+}
+
+type ImportRes struct {
+	Root     cid.Cid
+	ImportID multistore.StoreID
 }
 
 type Import struct {
-	Status   filestore.Status
-	Key      cid.Cid
+	Key multistore.StoreID
+	Err string
+
+	Root     *cid.Cid
+	Source   string
 	FilePath string
-	Size     uint64
 }
 
 type DealInfo struct {
 	ProposalCid cid.Cid
-	State       DealState
+	State       storagemarket.StorageDealStatus
+	Message     string // more information about deal state, particularly errors
 	Provider    address.Address
 
-	PieceRef []byte // cid bytes
+	DataRef  *storagemarket.DataRef
+	PieceCID cid.Cid
 	Size     uint64
 
 	PricePerEpoch types.BigInt
 	Duration      uint64
+
+	DealID abi.DealID
+
+	CreationTime time.Time
 }
 
-type MsgWait struct {
-	Receipt types.MessageReceipt
-	TipSet  *types.TipSet
+type MsgLookup struct {
+	Message   cid.Cid // Can be different than requested, in case it was replaced, but only gas values changed
+	Receipt   types.MessageReceipt
+	ReturnDec interface{}
+	TipSet    types.TipSetKey
+	Height    abi.ChainEpoch
+}
+
+type MsgGasCost struct {
+	Message            cid.Cid // Can be different than requested, in case it was replaced, but only gas values changed
+	GasUsed            abi.TokenAmount
+	BaseFeeBurn        abi.TokenAmount
+	OverEstimationBurn abi.TokenAmount
+	MinerPenalty       abi.TokenAmount
+	MinerTip           abi.TokenAmount
+	Refund             abi.TokenAmount
+	TotalCost          abi.TokenAmount
 }
 
 type BlockMessages struct {
@@ -177,12 +549,6 @@ type Message struct {
 	Message *types.Message
 }
 
-type ChainSectorInfo struct {
-	SectorID uint64
-	CommD    []byte
-	CommR    []byte
-}
-
 type ActorState struct {
 	Balance types.BigInt
 	State   interface{}
@@ -202,70 +568,147 @@ type PaychStatus struct {
 }
 
 type ChannelInfo struct {
-	Channel        address.Address
-	ChannelMessage cid.Cid
+	Channel      address.Address
+	WaitSentinel cid.Cid
+}
+
+type ChannelAvailableFunds struct {
+	// Channel is the address of the channel
+	Channel *address.Address
+	// From is the from address of the channel (channel creator)
+	From address.Address
+	// To is the to address of the channel
+	To address.Address
+	// ConfirmedAmt is the amount of funds that have been confirmed on-chain
+	// for the channel
+	ConfirmedAmt types.BigInt
+	// PendingAmt is the amount of funds that are pending confirmation on-chain
+	PendingAmt types.BigInt
+	// PendingWaitSentinel can be used with PaychGetWaitReady to wait for
+	// confirmation of pending funds
+	PendingWaitSentinel *cid.Cid
+	// QueuedAmt is the amount that is queued up behind a pending request
+	QueuedAmt types.BigInt
+	// VoucherRedeemedAmt is the amount that is redeemed by vouchers on-chain
+	// and in the local datastore
+	VoucherReedeemedAmt types.BigInt
 }
 
 type PaymentInfo struct {
-	Channel        address.Address
-	ChannelMessage *cid.Cid
-	Vouchers       []*types.SignedVoucher
+	Channel      address.Address
+	WaitSentinel cid.Cid
+	Vouchers     []*paych.SignedVoucher
 }
 
 type VoucherSpec struct {
-	Amount   types.BigInt
-	TimeLock uint64
-	MinClose uint64
+	Amount      types.BigInt
+	TimeLockMin abi.ChainEpoch
+	TimeLockMax abi.ChainEpoch
+	MinSettle   abi.ChainEpoch
 
-	Extra *types.ModVerifyParams
+	Extra *paych.ModVerifyParams
+}
+
+// VoucherCreateResult is the response to calling PaychVoucherCreate
+type VoucherCreateResult struct {
+	// Voucher that was created, or nil if there was an error or if there
+	// were insufficient funds in the channel
+	Voucher *paych.SignedVoucher
+	// Shortfall is the additional amount that would be needed in the channel
+	// in order to be able to create the voucher
+	Shortfall types.BigInt
 }
 
 type MinerPower struct {
-	MinerPower types.BigInt
-	TotalPower types.BigInt
+	MinerPower  power.Claim
+	TotalPower  power.Claim
+	HasMinPower bool
 }
 
 type QueryOffer struct {
 	Err string
 
-	Root cid.Cid
+	Root  cid.Cid
+	Piece *cid.Cid
 
-	Size     uint64
-	MinPrice types.BigInt
-
-	Miner       address.Address
-	MinerPeerID peer.ID
+	Size                    uint64
+	MinPrice                types.BigInt
+	UnsealPrice             types.BigInt
+	PaymentInterval         uint64
+	PaymentIntervalIncrease uint64
+	Miner                   address.Address
+	MinerPeer               retrievalmarket.RetrievalPeer
 }
 
 func (o *QueryOffer) Order(client address.Address) RetrievalOrder {
 	return RetrievalOrder{
-		Root:  o.Root,
-		Size:  o.Size,
-		Total: o.MinPrice,
+		Root:                    o.Root,
+		Piece:                   o.Piece,
+		Size:                    o.Size,
+		Total:                   o.MinPrice,
+		UnsealPrice:             o.UnsealPrice,
+		PaymentInterval:         o.PaymentInterval,
+		PaymentIntervalIncrease: o.PaymentIntervalIncrease,
+		Client:                  client,
 
-		Client: client,
-
-		Miner:       o.Miner,
-		MinerPeerID: o.MinerPeerID,
+		Miner:     o.Miner,
+		MinerPeer: o.MinerPeer,
 	}
 }
 
+type MarketBalance struct {
+	Escrow big.Int
+	Locked big.Int
+}
+
+type MarketDeal struct {
+	Proposal market.DealProposal
+	State    market.DealState
+}
+
 type RetrievalOrder struct {
 	// TODO: make this less unixfs specific
-	Root cid.Cid
-	Size uint64
+	Root  cid.Cid
+	Piece *cid.Cid
+	Size  uint64
 	// TODO: support offset
-	Total types.BigInt
-
-	Client      address.Address
-	Miner       address.Address
-	MinerPeerID peer.ID
+	Total                   types.BigInt
+	UnsealPrice             types.BigInt
+	PaymentInterval         uint64
+	PaymentIntervalIncrease uint64
+	Client                  address.Address
+	Miner                   address.Address
+	MinerPeer               retrievalmarket.RetrievalPeer
 }
 
-type ReplayResults struct {
-	Msg     *types.Message
-	Receipt *types.MessageReceipt
-	Error   string
+type InvocResult struct {
+	Msg            *types.Message
+	MsgRct         *types.MessageReceipt
+	ExecutionTrace types.ExecutionTrace
+	Error          string
+	Duration       time.Duration
+}
+
+type MethodCall struct {
+	types.MessageReceipt
+	Error string
+}
+
+type StartDealParams struct {
+	Data               *storagemarket.DataRef
+	Wallet             address.Address
+	Miner              address.Address
+	EpochPrice         types.BigInt
+	MinBlocksDuration  uint64
+	ProviderCollateral big.Int
+	DealStartEpoch     abi.ChainEpoch
+	FastRetrieval      bool
+	VerifiedDeal       bool
+}
+
+type IpldObject struct {
+	Cid cid.Cid
+	Obj interface{}
 }
 
 type ActiveSync struct {
@@ -273,7 +716,7 @@ type ActiveSync struct {
 	Target *types.TipSet
 
 	Stage  SyncStateStage
-	Height uint64
+	Height abi.ChainEpoch
 
 	Start   time.Time
 	End     time.Time
@@ -282,6 +725,8 @@ type ActiveSync struct {
 
 type SyncState struct {
 	ActiveSyncs []ActiveSync
+
+	VMApplied uint64
 }
 
 type SyncStateStage int
@@ -293,8 +738,28 @@ const (
 	StageMessages
 	StageSyncComplete
 	StageSyncErrored
+	StageFetchingMessages
 )
 
+func (v SyncStateStage) String() string {
+	switch v {
+	case StageHeaders:
+		return "header sync"
+	case StagePersistHeaders:
+		return "persisting headers"
+	case StageMessages:
+		return "message sync"
+	case StageSyncComplete:
+		return "complete"
+	case StageSyncErrored:
+		return "error"
+	case StageFetchingMessages:
+		return "fetching messages"
+	default:
+		return fmt.Sprintf("<unknown: %d>", v)
+	}
+}
+
 type MpoolChange int
 
 const (
@@ -306,3 +771,82 @@ type MpoolUpdate struct {
 	Type    MpoolChange
 	Message *types.SignedMessage
 }
+
+type ComputeStateOutput struct {
+	Root  cid.Cid
+	Trace []*InvocResult
+}
+
+type DealCollateralBounds struct {
+	Min abi.TokenAmount
+	Max abi.TokenAmount
+}
+
+type CirculatingSupply struct {
+	FilVested      abi.TokenAmount
+	FilMined       abi.TokenAmount
+	FilBurnt       abi.TokenAmount
+	FilLocked      abi.TokenAmount
+	FilCirculating abi.TokenAmount
+}
+
+type MiningBaseInfo struct {
+	MinerPower      types.BigInt
+	NetworkPower    types.BigInt
+	Sectors         []builtin.SectorInfo
+	WorkerKey       address.Address
+	SectorSize      abi.SectorSize
+	PrevBeaconEntry types.BeaconEntry
+	BeaconEntries   []types.BeaconEntry
+	HasMinPower     bool
+}
+
+type BlockTemplate struct {
+	Miner            address.Address
+	Parents          types.TipSetKey
+	Ticket           *types.Ticket
+	Eproof           *types.ElectionProof
+	BeaconValues     []types.BeaconEntry
+	Messages         []*types.SignedMessage
+	Epoch            abi.ChainEpoch
+	Timestamp        uint64
+	WinningPoStProof []builtin.PoStProof
+}
+
+type DataSize struct {
+	PayloadSize int64
+	PieceSize   abi.PaddedPieceSize
+}
+
+type CommPRet struct {
+	Root cid.Cid
+	Size abi.UnpaddedPieceSize
+}
+type HeadChange struct {
+	Type string
+	Val  *types.TipSet
+}
+
+type MsigProposeResponse int
+
+const (
+	MsigApprove MsigProposeResponse = iota
+	MsigCancel
+)
+
+type Deadline struct {
+	PostSubmissions bitfield.BitField
+}
+
+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
+}
diff --git a/api/api_storage.go b/api/api_storage.go
index 8d0c39038..824772181 100644
--- a/api/api_storage.go
+++ b/api/api_storage.go
@@ -1,112 +1,182 @@
 package api
 
 import (
+	"bytes"
 	"context"
+	"time"
+
+	"github.com/ipfs/go-cid"
 
 	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-sectorbuilder"
+	"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/lotus/chain/types"
+	"github.com/filecoin-project/lotus/extern/sector-storage/fsutil"
+	"github.com/filecoin-project/lotus/extern/sector-storage/stores"
+	"github.com/filecoin-project/lotus/extern/sector-storage/storiface"
 )
 
-// alias because cbor-gen doesn't like non-alias types
-type SectorState = uint64
-
-const (
-	UndefinedSectorState SectorState = iota
-
-	Empty   // TODO: Is this useful
-	Packing // sector not in sealStore, and not on chain
-
-	Unsealed      // sealing / queued
-	PreCommitting // on chain pre-commit
-	PreCommitted  // waiting for seed
-	Committing
-	CommitWait // waiting for message to land on chain
-	Proving
-
-	SealFailed
-	PreCommitFailed
-	SealCommitFailed
-	CommitFailed
-
-	FailedUnrecoverable
-
-	Faulty        // sector is corrupted or gone for some reason
-	FaultReported // sector has been declared as a fault on chain
-	FaultedFinal  // fault declared on chain
-)
-
-var SectorStates = []string{
-	UndefinedSectorState: "UndefinedSectorState",
-	Empty:                "Empty",
-	Packing:              "Packing",
-	Unsealed:             "Unsealed",
-	PreCommitting:        "PreCommitting",
-	PreCommitted:         "PreCommitted",
-	Committing:           "Committing",
-	CommitWait:           "CommitWait",
-	Proving:              "Proving",
-
-	SealFailed:       "SealFailed",
-	PreCommitFailed:  "PreCommitFailed",
-	SealCommitFailed: "SealCommitFailed",
-	CommitFailed:     "CommitFailed",
-
-	FailedUnrecoverable: "FailedUnrecoverable",
-
-	Faulty:        "Faulty",
-	FaultReported: "FaultReported",
-	FaultedFinal:  "FaultedFinal",
-}
-
 // StorageMiner is a low-level interface to the Filecoin network storage miner node
 type StorageMiner interface {
 	Common
 
 	ActorAddress(context.Context) (address.Address, error)
 
-	ActorSectorSize(context.Context, address.Address) (uint64, error)
+	ActorSectorSize(context.Context, address.Address) (abi.SectorSize, error)
+
+	MiningBase(context.Context) (*types.TipSet, error)
 
 	// Temp api for testing
 	PledgeSector(context.Context) error
 
 	// Get the status of a given sector by ID
-	SectorsStatus(context.Context, uint64) (SectorInfo, error)
+	SectorsStatus(ctx context.Context, sid abi.SectorNumber, showOnChainInfo bool) (SectorInfo, error)
 
 	// List all staged sectors
-	SectorsList(context.Context) ([]uint64, error)
+	SectorsList(context.Context) ([]abi.SectorNumber, error)
 
 	SectorsRefs(context.Context) (map[string][]SealedRef, error)
 
-	SectorsUpdate(context.Context, uint64, SectorState) error
+	// SectorStartSealing can be called on sectors in Empty or WaitDeals states
+	// to trigger sealing early
+	SectorStartSealing(context.Context, abi.SectorNumber) error
+	// SectorSetSealDelay sets the time that a newly-created sector
+	// waits for more deals before it starts sealing
+	SectorSetSealDelay(context.Context, time.Duration) error
+	// SectorGetSealDelay gets the time that a newly-created sector
+	// waits for more deals before it starts sealing
+	SectorGetSealDelay(context.Context) (time.Duration, error)
+	// SectorSetExpectedSealDuration sets the expected time for a sector to seal
+	SectorSetExpectedSealDuration(context.Context, time.Duration) error
+	// SectorGetExpectedSealDuration gets the expected time for a sector to seal
+	SectorGetExpectedSealDuration(context.Context) (time.Duration, error)
+	SectorsUpdate(context.Context, abi.SectorNumber, SectorState) error
+	SectorRemove(context.Context, abi.SectorNumber) error
+	SectorMarkForUpgrade(ctx context.Context, id abi.SectorNumber) error
 
-	WorkerStats(context.Context) (sectorbuilder.WorkerStats, error)
+	StorageList(ctx context.Context) (map[stores.ID][]stores.Decl, error)
+	StorageLocal(ctx context.Context) (map[stores.ID]string, error)
+	StorageStat(ctx context.Context, id stores.ID) (fsutil.FsStat, error)
 
-	// WorkerQueue registers a remote worker
-	WorkerQueue(context.Context, sectorbuilder.WorkerCfg) (<-chan sectorbuilder.WorkerTask, error)
+	// WorkerConnect tells the node to connect to workers RPC
+	WorkerConnect(context.Context, string) error
+	WorkerStats(context.Context) (map[uint64]storiface.WorkerStats, error)
+	WorkerJobs(context.Context) (map[uint64][]storiface.WorkerJob, error)
 
-	WorkerDone(ctx context.Context, task uint64, res sectorbuilder.SealRes) error
+	// SealingSchedDiag dumps internal sealing scheduler state
+	SealingSchedDiag(context.Context) (interface{}, error)
+
+	stores.SectorIndex
+
+	MarketImportDealData(ctx context.Context, propcid cid.Cid, path string) error
+	MarketListDeals(ctx context.Context) ([]MarketDeal, error)
+	MarketListRetrievalDeals(ctx context.Context) ([]retrievalmarket.ProviderDealState, error)
+	MarketGetDealUpdates(ctx context.Context) (<-chan storagemarket.MinerDeal, error)
+	MarketListIncompleteDeals(ctx context.Context) ([]storagemarket.MinerDeal, error)
+	MarketSetAsk(ctx context.Context, price types.BigInt, verifiedPrice types.BigInt, duration abi.ChainEpoch, minPieceSize abi.PaddedPieceSize, maxPieceSize abi.PaddedPieceSize) error
+	MarketGetAsk(ctx context.Context) (*storagemarket.SignedStorageAsk, error)
+	MarketSetRetrievalAsk(ctx context.Context, rask *retrievalmarket.Ask) error
+	MarketGetRetrievalAsk(ctx context.Context) (*retrievalmarket.Ask, error)
+	MarketListDataTransfers(ctx context.Context) ([]DataTransferChannel, error)
+	MarketDataTransferUpdates(ctx context.Context) (<-chan DataTransferChannel, error)
+
+	DealsImportData(ctx context.Context, dealPropCid cid.Cid, file string) error
+	DealsList(ctx context.Context) ([]MarketDeal, error)
+	DealsConsiderOnlineStorageDeals(context.Context) (bool, error)
+	DealsSetConsiderOnlineStorageDeals(context.Context, bool) error
+	DealsConsiderOnlineRetrievalDeals(context.Context) (bool, error)
+	DealsSetConsiderOnlineRetrievalDeals(context.Context, bool) error
+	DealsPieceCidBlocklist(context.Context) ([]cid.Cid, error)
+	DealsSetPieceCidBlocklist(context.Context, []cid.Cid) error
+	DealsConsiderOfflineStorageDeals(context.Context) (bool, error)
+	DealsSetConsiderOfflineStorageDeals(context.Context, bool) error
+	DealsConsiderOfflineRetrievalDeals(context.Context) (bool, error)
+	DealsSetConsiderOfflineRetrievalDeals(context.Context, bool) error
+
+	StorageAddLocal(ctx context.Context, path string) error
+
+	PiecesListPieces(ctx context.Context) ([]cid.Cid, error)
+	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)
+}
+
+type SealRes struct {
+	Err   string
+	GoErr error `json:"-"`
+
+	Proof []byte
+}
+
+type SectorLog struct {
+	Kind      string
+	Timestamp uint64
+
+	Trace string
+
+	Message string
 }
 
 type SectorInfo struct {
-	SectorID uint64
-	State    SectorState
-	CommD    []byte
-	CommR    []byte
-	Proof    []byte
-	Deals    []uint64
-	Ticket   sectorbuilder.SealTicket
-	Seed     sectorbuilder.SealSeed
-	Retries  uint64
+	SectorID     abi.SectorNumber
+	State        SectorState
+	CommD        *cid.Cid
+	CommR        *cid.Cid
+	Proof        []byte
+	Deals        []abi.DealID
+	Ticket       SealTicket
+	Seed         SealSeed
+	PreCommitMsg *cid.Cid
+	CommitMsg    *cid.Cid
+	Retries      uint64
+	ToUpgrade    bool
 
 	LastErr string
+
+	Log []SectorLog
+
+	// On Chain Info
+	SealProof          abi.RegisteredSealProof // The seal proof type implies the PoSt proof/s
+	Activation         abi.ChainEpoch          // Epoch during which the sector proof was accepted
+	Expiration         abi.ChainEpoch          // Epoch during which the sector expires
+	DealWeight         abi.DealWeight          // Integral of active deals over sector lifetime
+	VerifiedDealWeight abi.DealWeight          // Integral of active verified deals over sector lifetime
+	InitialPledge      abi.TokenAmount         // Pledge collected to commit this sector
+	// Expiration Info
+	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 SealedRef struct {
-	SectorID uint64
-	Offset   uint64
-	Size     uint64
+	SectorID abi.SectorNumber
+	Offset   abi.PaddedPieceSize
+	Size     abi.UnpaddedPieceSize
 }
 
 type SealedRefs struct {
 	Refs []SealedRef
 }
+
+type SealTicket struct {
+	Value abi.SealRandomness
+	Epoch abi.ChainEpoch
+}
+
+type SealSeed struct {
+	Value abi.InteractiveSealRandomness
+	Epoch abi.ChainEpoch
+}
+
+func (st *SealTicket) Equals(ost *SealTicket) bool {
+	return bytes.Equal(st.Value, ost.Value) && st.Epoch == ost.Epoch
+}
+
+func (st *SealSeed) Equals(ost *SealSeed) bool {
+	return bytes.Equal(st.Value, ost.Value) && st.Epoch == ost.Epoch
+}
+
+type SectorState string
diff --git a/api/api_test.go b/api/api_test.go
new file mode 100644
index 000000000..34c47f432
--- /dev/null
+++ b/api/api_test.go
@@ -0,0 +1,103 @@
+package api
+
+import (
+	"encoding/json"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func goCmd() string {
+	var exeSuffix string
+	if runtime.GOOS == "windows" {
+		exeSuffix = ".exe"
+	}
+	path := filepath.Join(runtime.GOROOT(), "bin", "go"+exeSuffix)
+	if _, err := os.Stat(path); err == nil {
+		return path
+	}
+	return "go"
+}
+
+func TestDoesntDependOnFFI(t *testing.T) {
+	deps, err := exec.Command(goCmd(), "list", "-deps", "github.com/filecoin-project/lotus/api").Output()
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, pkg := range strings.Fields(string(deps)) {
+		if pkg == "github.com/filecoin-project/filecoin-ffi" {
+			t.Fatal("api depends on filecoin-ffi")
+		}
+	}
+}
+
+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)))
+}
diff --git a/api/api_worker.go b/api/api_worker.go
new file mode 100644
index 000000000..ac1446fdd
--- /dev/null
+++ b/api/api_worker.go
@@ -0,0 +1,40 @@
+package api
+
+import (
+	"context"
+	"io"
+
+	"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"
+)
+
+type WorkerAPI interface {
+	Version(context.Context) (build.Version, error)
+	// TODO: Info() (name, ...) ?
+
+	TaskTypes(context.Context) (map[sealtasks.TaskType]struct{}, error) // TaskType -> Weight
+	Paths(context.Context) ([]stores.StoragePath, error)
+	Info(context.Context) (storiface.WorkerInfo, error)
+
+	AddPiece(ctx context.Context, sector abi.SectorID, pieceSizes []abi.UnpaddedPieceSize, newPieceSize abi.UnpaddedPieceSize, pieceData storage.Data) (abi.PieceInfo, error)
+
+	storage.Sealer
+
+	MoveStorage(ctx context.Context, sector abi.SectorID, types stores.SectorFileType) error
+
+	UnsealPiece(context.Context, abi.SectorID, storiface.UnpaddedByteIndex, abi.UnpaddedPieceSize, abi.SealRandomness, cid.Cid) error
+	ReadPiece(context.Context, io.Writer, abi.SectorID, storiface.UnpaddedByteIndex, abi.UnpaddedPieceSize) (bool, error)
+
+	StorageAddLocal(ctx context.Context, path string) error
+
+	Fetch(context.Context, abi.SectorID, stores.SectorFileType, stores.PathType, stores.AcquireMode) error
+
+	Closing(context.Context) (<-chan struct{}, error)
+}
diff --git a/api/apibstore/apibstore.go b/api/apibstore/apibstore.go
new file mode 100644
index 000000000..cf9f4f24c
--- /dev/null
+++ b/api/apibstore/apibstore.go
@@ -0,0 +1,68 @@
+package apibstore
+
+import (
+	"context"
+
+	blocks "github.com/ipfs/go-block-format"
+	"github.com/ipfs/go-cid"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/lotus/lib/blockstore"
+)
+
+type ChainIO interface {
+	ChainReadObj(context.Context, cid.Cid) ([]byte, error)
+	ChainHasObj(context.Context, cid.Cid) (bool, error)
+}
+
+type apiBStore struct {
+	api ChainIO
+}
+
+func NewAPIBlockstore(cio ChainIO) blockstore.Blockstore {
+	return &apiBStore{
+		api: cio,
+	}
+}
+
+func (a *apiBStore) DeleteBlock(cid.Cid) error {
+	return xerrors.New("not supported")
+}
+
+func (a *apiBStore) Has(c cid.Cid) (bool, error) {
+	return a.api.ChainHasObj(context.TODO(), c)
+}
+
+func (a *apiBStore) Get(c cid.Cid) (blocks.Block, error) {
+	bb, err := a.api.ChainReadObj(context.TODO(), c)
+	if err != nil {
+		return nil, err
+	}
+	return blocks.NewBlockWithCid(bb, c)
+}
+
+func (a *apiBStore) GetSize(c cid.Cid) (int, error) {
+	bb, err := a.api.ChainReadObj(context.TODO(), c)
+	if err != nil {
+		return 0, err
+	}
+	return len(bb), nil
+}
+
+func (a *apiBStore) Put(blocks.Block) error {
+	return xerrors.New("not supported")
+}
+
+func (a *apiBStore) PutMany([]blocks.Block) error {
+	return xerrors.New("not supported")
+}
+
+func (a *apiBStore) AllKeysChan(ctx context.Context) (<-chan cid.Cid, error) {
+	return nil, xerrors.New("not supported")
+}
+
+func (a *apiBStore) HashOnRead(enabled bool) {
+	return
+}
+
+var _ blockstore.Blockstore = &apiBStore{}
diff --git a/api/apistruct/permissioned.go b/api/apistruct/permissioned.go
index 4c29f6688..c93662733 100644
--- a/api/apistruct/permissioned.go
+++ b/api/apistruct/permissioned.go
@@ -1,105 +1,38 @@
 package apistruct
 
 import (
-	"context"
-	"reflect"
-
-	"golang.org/x/xerrors"
-
+	"github.com/filecoin-project/go-jsonrpc/auth"
 	"github.com/filecoin-project/lotus/api"
 )
 
-type permKey int
-
-var permCtxKey permKey
-
 const (
 	// When changing these, update docs/API.md too
 
-	PermRead  api.Permission = "read" // default
-	PermWrite api.Permission = "write"
-	PermSign  api.Permission = "sign"  // Use wallet keys for signing
-	PermAdmin api.Permission = "admin" // Manage permissions
+	PermRead  auth.Permission = "read" // default
+	PermWrite auth.Permission = "write"
+	PermSign  auth.Permission = "sign"  // Use wallet keys for signing
+	PermAdmin auth.Permission = "admin" // Manage permissions
 )
 
-var AllPermissions = []api.Permission{PermRead, PermWrite, PermSign, PermAdmin}
-var defaultPerms = []api.Permission{PermRead}
-
-func WithPerm(ctx context.Context, perms []api.Permission) context.Context {
-	return context.WithValue(ctx, permCtxKey, perms)
-}
+var AllPermissions = []auth.Permission{PermRead, PermWrite, PermSign, PermAdmin}
+var DefaultPerms = []auth.Permission{PermRead}
 
 func PermissionedStorMinerAPI(a api.StorageMiner) api.StorageMiner {
 	var out StorageMinerStruct
-	permissionedAny(a, &out.Internal)
-	permissionedAny(a, &out.CommonStruct.Internal)
+	auth.PermissionedProxy(AllPermissions, DefaultPerms, a, &out.Internal)
+	auth.PermissionedProxy(AllPermissions, DefaultPerms, a, &out.CommonStruct.Internal)
 	return &out
 }
 
 func PermissionedFullAPI(a api.FullNode) api.FullNode {
 	var out FullNodeStruct
-	permissionedAny(a, &out.Internal)
-	permissionedAny(a, &out.CommonStruct.Internal)
+	auth.PermissionedProxy(AllPermissions, DefaultPerms, a, &out.Internal)
+	auth.PermissionedProxy(AllPermissions, DefaultPerms, a, &out.CommonStruct.Internal)
 	return &out
 }
 
-func HasPerm(ctx context.Context, perm api.Permission) bool {
-	callerPerms, ok := ctx.Value(permCtxKey).([]api.Permission)
-	if !ok {
-		callerPerms = defaultPerms
-	}
-
-	for _, callerPerm := range callerPerms {
-		if callerPerm == perm {
-			return true
-		}
-	}
-	return false
-}
-
-func permissionedAny(in interface{}, out interface{}) {
-	rint := reflect.ValueOf(out).Elem()
-	ra := reflect.ValueOf(in)
-
-	for f := 0; f < rint.NumField(); f++ {
-		field := rint.Type().Field(f)
-		requiredPerm := api.Permission(field.Tag.Get("perm"))
-		if requiredPerm == "" {
-			panic("missing 'perm' tag on " + field.Name) // ok
-		}
-
-		// Validate perm tag
-		ok := false
-		for _, perm := range AllPermissions {
-			if requiredPerm == perm {
-				ok = true
-				break
-			}
-		}
-		if !ok {
-			panic("unknown 'perm' tag on " + field.Name) // ok
-		}
-
-		fn := ra.MethodByName(field.Name)
-
-		rint.Field(f).Set(reflect.MakeFunc(field.Type, func(args []reflect.Value) (results []reflect.Value) {
-			ctx := args[0].Interface().(context.Context)
-			if HasPerm(ctx, requiredPerm) {
-				return fn.Call(args)
-			}
-
-			err := xerrors.Errorf("missing permission to invoke '%s' (need '%s')", field.Name, requiredPerm)
-			rerr := reflect.ValueOf(&err).Elem()
-
-			if field.Type.NumOut() == 2 {
-				return []reflect.Value{
-					reflect.Zero(field.Type.Out(0)),
-					rerr,
-				}
-			} else {
-				return []reflect.Value{rerr}
-			}
-		}))
-
-	}
+func PermissionedWorkerAPI(a api.WorkerAPI) api.WorkerAPI {
+	var out WorkerStruct
+	auth.PermissionedProxy(AllPermissions, DefaultPerms, a, &out.Internal)
+	return &out
 }
diff --git a/api/apistruct/struct.go b/api/apistruct/struct.go
index fbaff4b66..d5b6950ad 100644
--- a/api/apistruct/struct.go
+++ b/api/apistruct/struct.go
@@ -2,18 +2,41 @@ package apistruct
 
 import (
 	"context"
+	"io"
+	"time"
 
-	sectorbuilder "github.com/filecoin-project/go-sectorbuilder"
+	stnetwork "github.com/filecoin-project/go-state-types/network"
 
 	"github.com/ipfs/go-cid"
+	metrics "github.com/libp2p/go-libp2p-core/metrics"
 	"github.com/libp2p/go-libp2p-core/network"
 	"github.com/libp2p/go-libp2p-core/peer"
+	protocol "github.com/libp2p/go-libp2p-core/protocol"
 
 	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-bitfield"
+	"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-jsonrpc/auth"
+	"github.com/filecoin-project/go-multistore"
+	"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/extern/sector-storage/fsutil"
+	"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"
+	marketevents "github.com/filecoin-project/lotus/markets/loggers"
+	"github.com/filecoin-project/specs-storage/storage"
+
 	"github.com/filecoin-project/lotus/api"
-	"github.com/filecoin-project/lotus/chain/actors"
-	"github.com/filecoin-project/lotus/chain/store"
+	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/paych"
 	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/node/modules/dtypes"
 )
 
 // All permissions are listed in permissioned.go
@@ -21,17 +44,30 @@ var _ = AllPermissions
 
 type CommonStruct struct {
 	Internal struct {
-		AuthVerify func(ctx context.Context, token string) ([]api.Permission, error) `perm:"read"`
-		AuthNew    func(ctx context.Context, perms []api.Permission) ([]byte, error) `perm:"admin"`
+		AuthVerify func(ctx context.Context, token string) ([]auth.Permission, error) `perm:"read"`
+		AuthNew    func(ctx context.Context, perms []auth.Permission) ([]byte, error) `perm:"admin"`
 
-		NetConnectedness func(context.Context, peer.ID) (network.Connectedness, error) `perm:"read"`
-		NetPeers         func(context.Context) ([]peer.AddrInfo, error)                `perm:"read"`
-		NetConnect       func(context.Context, peer.AddrInfo) error                    `perm:"write"`
-		NetAddrsListen   func(context.Context) (peer.AddrInfo, error)                  `perm:"read"`
-		NetDisconnect    func(context.Context, peer.ID) error                          `perm:"write"`
+		NetConnectedness            func(context.Context, peer.ID) (network.Connectedness, error)    `perm:"read"`
+		NetPeers                    func(context.Context) ([]peer.AddrInfo, error)                   `perm:"read"`
+		NetConnect                  func(context.Context, peer.AddrInfo) error                       `perm:"write"`
+		NetAddrsListen              func(context.Context) (peer.AddrInfo, error)                     `perm:"read"`
+		NetDisconnect               func(context.Context, peer.ID) error                             `perm:"write"`
+		NetFindPeer                 func(context.Context, peer.ID) (peer.AddrInfo, error)            `perm:"read"`
+		NetPubsubScores             func(context.Context) ([]api.PubsubScore, error)                 `perm:"read"`
+		NetAutoNatStatus            func(context.Context) (api.NatInfo, error)                       `perm:"read"`
+		NetBandwidthStats           func(ctx context.Context) (metrics.Stats, error)                 `perm:"read"`
+		NetBandwidthStatsByPeer     func(ctx context.Context) (map[string]metrics.Stats, error)      `perm:"read"`
+		NetBandwidthStatsByProtocol func(ctx context.Context) (map[protocol.ID]metrics.Stats, error) `perm:"read"`
+		NetAgentVersion             func(ctx context.Context, p peer.ID) (string, error)             `perm:"read"`
 
 		ID      func(context.Context) (peer.ID, error)     `perm:"read"`
 		Version func(context.Context) (api.Version, error) `perm:"read"`
+
+		LogList     func(context.Context) ([]string, error)     `perm:"write"`
+		LogSetLevel func(context.Context, string, string) error `perm:"write"`
+
+		Shutdown func(context.Context) error                    `perm:"admin"`
+		Closing  func(context.Context) (<-chan struct{}, error) `perm:"read"`
 	}
 }
 
@@ -40,132 +76,294 @@ type FullNodeStruct struct {
 	CommonStruct
 
 	Internal struct {
-		ChainNotify            func(context.Context) (<-chan []*store.HeadChange, error)           `perm:"read"`
-		ChainHead              func(context.Context) (*types.TipSet, error)                        `perm:"read"`
-		ChainGetRandomness     func(context.Context, types.TipSetKey, int64) ([]byte, error)       `perm:"read"`
-		ChainGetBlock          func(context.Context, cid.Cid) (*types.BlockHeader, error)          `perm:"read"`
-		ChainGetTipSet         func(context.Context, types.TipSetKey) (*types.TipSet, error)       `perm:"read"`
-		ChainGetBlockMessages  func(context.Context, cid.Cid) (*api.BlockMessages, error)          `perm:"read"`
-		ChainGetParentReceipts func(context.Context, cid.Cid) ([]*types.MessageReceipt, error)     `perm:"read"`
-		ChainGetParentMessages func(context.Context, cid.Cid) ([]api.Message, error)               `perm:"read"`
-		ChainGetTipSetByHeight func(context.Context, uint64, *types.TipSet) (*types.TipSet, error) `perm:"read"`
-		ChainReadObj           func(context.Context, cid.Cid) ([]byte, error)                      `perm:"read"`
-		ChainSetHead           func(context.Context, *types.TipSet) error                          `perm:"admin"`
-		ChainGetGenesis        func(context.Context) (*types.TipSet, error)                        `perm:"read"`
-		ChainTipSetWeight      func(context.Context, *types.TipSet) (types.BigInt, error)          `perm:"read"`
-		ChainGetNode           func(ctx context.Context, p string) (interface{}, error)            `perm:"read"`
-		ChainGetMessage        func(context.Context, cid.Cid) (*types.Message, error)              `perm:"read"`
+		ChainNotify                   func(context.Context) (<-chan []*api.HeadChange, error)                                                            `perm:"read"`
+		ChainHead                     func(context.Context) (*types.TipSet, error)                                                                       `perm:"read"`
+		ChainGetRandomnessFromTickets func(context.Context, types.TipSetKey, crypto.DomainSeparationTag, abi.ChainEpoch, []byte) (abi.Randomness, error) `perm:"read"`
+		ChainGetRandomnessFromBeacon  func(context.Context, types.TipSetKey, crypto.DomainSeparationTag, abi.ChainEpoch, []byte) (abi.Randomness, error) `perm:"read"`
+		ChainGetBlock                 func(context.Context, cid.Cid) (*types.BlockHeader, error)                                                         `perm:"read"`
+		ChainGetTipSet                func(context.Context, types.TipSetKey) (*types.TipSet, error)                                                      `perm:"read"`
+		ChainGetBlockMessages         func(context.Context, cid.Cid) (*api.BlockMessages, error)                                                         `perm:"read"`
+		ChainGetParentReceipts        func(context.Context, cid.Cid) ([]*types.MessageReceipt, error)                                                    `perm:"read"`
+		ChainGetParentMessages        func(context.Context, cid.Cid) ([]api.Message, error)                                                              `perm:"read"`
+		ChainGetTipSetByHeight        func(context.Context, abi.ChainEpoch, types.TipSetKey) (*types.TipSet, error)                                      `perm:"read"`
+		ChainReadObj                  func(context.Context, cid.Cid) ([]byte, error)                                                                     `perm:"read"`
+		ChainDeleteObj                func(context.Context, cid.Cid) error                                                                               `perm:"admin"`
+		ChainHasObj                   func(context.Context, cid.Cid) (bool, error)                                                                       `perm:"read"`
+		ChainStatObj                  func(context.Context, cid.Cid, cid.Cid) (api.ObjStat, error)                                                       `perm:"read"`
+		ChainSetHead                  func(context.Context, types.TipSetKey) error                                                                       `perm:"admin"`
+		ChainGetGenesis               func(context.Context) (*types.TipSet, error)                                                                       `perm:"read"`
+		ChainTipSetWeight             func(context.Context, types.TipSetKey) (types.BigInt, error)                                                       `perm:"read"`
+		ChainGetNode                  func(ctx context.Context, p string) (*api.IpldObject, error)                                                       `perm:"read"`
+		ChainGetMessage               func(context.Context, cid.Cid) (*types.Message, error)                                                             `perm:"read"`
+		ChainGetPath                  func(context.Context, types.TipSetKey, types.TipSetKey) ([]*api.HeadChange, error)                                 `perm:"read"`
+		ChainExport                   func(context.Context, abi.ChainEpoch, bool, types.TipSetKey) (<-chan []byte, error)                                `perm:"read"`
+
+		BeaconGetEntry func(ctx context.Context, epoch abi.ChainEpoch) (*types.BeaconEntry, error) `perm:"read"`
+
+		GasEstimateGasPremium func(context.Context, uint64, address.Address, int64, types.TipSetKey) (types.BigInt, error)         `perm:"read"`
+		GasEstimateGasLimit   func(context.Context, *types.Message, types.TipSetKey) (int64, error)                                `perm:"read"`
+		GasEstimateFeeCap     func(context.Context, *types.Message, int64, types.TipSetKey) (types.BigInt, error)                  `perm:"read"`
+		GasEstimateMessageGas func(context.Context, *types.Message, *api.MessageSendSpec, types.TipSetKey) (*types.Message, error) `perm:"read"`
 
 		SyncState          func(context.Context) (*api.SyncState, error)                `perm:"read"`
 		SyncSubmitBlock    func(ctx context.Context, blk *types.BlockMsg) error         `perm:"write"`
 		SyncIncomingBlocks func(ctx context.Context) (<-chan *types.BlockHeader, error) `perm:"read"`
+		SyncCheckpoint     func(ctx context.Context, key types.TipSetKey) error         `perm:"admin"`
 		SyncMarkBad        func(ctx context.Context, bcid cid.Cid) error                `perm:"admin"`
+		SyncUnmarkBad      func(ctx context.Context, bcid cid.Cid) error                `perm:"admin"`
+		SyncCheckBad       func(ctx context.Context, bcid cid.Cid) (string, error)      `perm:"read"`
 
-		MpoolPending     func(context.Context, *types.TipSet) ([]*types.SignedMessage, error) `perm:"read"`
-		MpoolPush        func(context.Context, *types.SignedMessage) (cid.Cid, error)         `perm:"write"`
-		MpoolPushMessage func(context.Context, *types.Message) (*types.SignedMessage, error)  `perm:"sign"`
-		MpoolGetNonce    func(context.Context, address.Address) (uint64, error)               `perm:"read"`
-		MpoolSub         func(context.Context) (<-chan api.MpoolUpdate, error)                `perm:"read"`
+		MpoolGetConfig func(context.Context) (*types.MpoolConfig, error) `perm:"read"`
+		MpoolSetConfig func(context.Context, *types.MpoolConfig) error   `perm:"write"`
 
-		MinerCreateBlock func(context.Context, address.Address, *types.TipSet, *types.Ticket, *types.EPostProof, []*types.SignedMessage, uint64, uint64) (*types.BlockMsg, error) `perm:"write"`
+		MpoolSelect func(context.Context, types.TipSetKey, float64) ([]*types.SignedMessage, error) `perm:"read"`
 
-		WalletNew            func(context.Context, string) (address.Address, error)                               `perm:"write"`
+		MpoolPending func(context.Context, types.TipSetKey) ([]*types.SignedMessage, error) `perm:"read"`
+		MpoolClear   func(context.Context, bool) error                                      `perm:"write"`
+
+		MpoolPush        func(context.Context, *types.SignedMessage) (cid.Cid, error)                              `perm:"write"`
+		MpoolPushMessage func(context.Context, *types.Message, *api.MessageSendSpec) (*types.SignedMessage, error) `perm:"sign"`
+		MpoolGetNonce    func(context.Context, address.Address) (uint64, error)                                    `perm:"read"`
+		MpoolSub         func(context.Context) (<-chan api.MpoolUpdate, error)                                     `perm:"read"`
+
+		MinerGetBaseInfo func(context.Context, address.Address, abi.ChainEpoch, types.TipSetKey) (*api.MiningBaseInfo, error) `perm:"read"`
+		MinerCreateBlock func(context.Context, *api.BlockTemplate) (*types.BlockMsg, error)                                   `perm:"write"`
+
+		WalletNew            func(context.Context, crypto.SigType) (address.Address, error)                       `perm:"write"`
 		WalletHas            func(context.Context, address.Address) (bool, error)                                 `perm:"write"`
 		WalletList           func(context.Context) ([]address.Address, error)                                     `perm:"write"`
 		WalletBalance        func(context.Context, address.Address) (types.BigInt, error)                         `perm:"read"`
-		WalletSign           func(context.Context, address.Address, []byte) (*types.Signature, error)             `perm:"sign"`
+		WalletSign           func(context.Context, address.Address, []byte) (*crypto.Signature, error)            `perm:"sign"`
 		WalletSignMessage    func(context.Context, address.Address, *types.Message) (*types.SignedMessage, error) `perm:"sign"`
+		WalletVerify         func(context.Context, address.Address, []byte, *crypto.Signature) (bool, error)      `perm:"read"`
 		WalletDefaultAddress func(context.Context) (address.Address, error)                                       `perm:"write"`
 		WalletSetDefault     func(context.Context, address.Address) error                                         `perm:"admin"`
 		WalletExport         func(context.Context, address.Address) (*types.KeyInfo, error)                       `perm:"admin"`
 		WalletImport         func(context.Context, *types.KeyInfo) (address.Address, error)                       `perm:"admin"`
+		WalletDelete         func(context.Context, address.Address) error                                         `perm:"write"`
 
-		ClientImport      func(ctx context.Context, path string) (cid.Cid, error)                                                                                           `perm:"admin"`
-		ClientListImports func(ctx context.Context) ([]api.Import, error)                                                                                                   `perm:"write"`
-		ClientHasLocal    func(ctx context.Context, root cid.Cid) (bool, error)                                                                                             `perm:"write"`
-		ClientFindData    func(ctx context.Context, root cid.Cid) ([]api.QueryOffer, error)                                                                                 `perm:"read"`
-		ClientStartDeal   func(ctx context.Context, data cid.Cid, addr address.Address, miner address.Address, price types.BigInt, blocksDuration uint64) (*cid.Cid, error) `perm:"admin"`
-		ClientGetDealInfo func(context.Context, cid.Cid) (*api.DealInfo, error)                                                                                             `perm:"read"`
-		ClientListDeals   func(ctx context.Context) ([]api.DealInfo, error)                                                                                                 `perm:"write"`
-		ClientRetrieve    func(ctx context.Context, order api.RetrievalOrder, path string) error                                                                            `perm:"admin"`
-		ClientQueryAsk    func(ctx context.Context, p peer.ID, miner address.Address) (*types.SignedStorageAsk, error)                                                      `perm:"read"`
+		ClientImport                              func(ctx context.Context, ref api.FileRef) (*api.ImportRes, error)                                                `perm:"admin"`
+		ClientListImports                         func(ctx context.Context) ([]api.Import, error)                                                                   `perm:"write"`
+		ClientRemoveImport                        func(ctx context.Context, importID multistore.StoreID) error                                                      `perm:"admin"`
+		ClientHasLocal                            func(ctx context.Context, root cid.Cid) (bool, error)                                                             `perm:"write"`
+		ClientFindData                            func(ctx context.Context, root cid.Cid, piece *cid.Cid) ([]api.QueryOffer, error)                                 `perm:"read"`
+		ClientMinerQueryOffer                     func(ctx context.Context, miner address.Address, root cid.Cid, piece *cid.Cid) (api.QueryOffer, error)            `perm:"read"`
+		ClientStartDeal                           func(ctx context.Context, params *api.StartDealParams) (*cid.Cid, error)                                          `perm:"admin"`
+		ClientGetDealInfo                         func(context.Context, cid.Cid) (*api.DealInfo, error)                                                             `perm:"read"`
+		ClientListDeals                           func(ctx context.Context) ([]api.DealInfo, error)                                                                 `perm:"write"`
+		ClientGetDealUpdates                      func(ctx context.Context) (<-chan api.DealInfo, error)                                                            `perm:"read"`
+		ClientRetrieve                            func(ctx context.Context, order api.RetrievalOrder, ref *api.FileRef) error                                       `perm:"admin"`
+		ClientRetrieveWithEvents                  func(ctx context.Context, order api.RetrievalOrder, ref *api.FileRef) (<-chan marketevents.RetrievalEvent, error) `perm:"admin"`
+		ClientQueryAsk                            func(ctx context.Context, p peer.ID, miner address.Address) (*storagemarket.SignedStorageAsk, error)              `perm:"read"`
+		ClientCalcCommP                           func(ctx context.Context, inpath string) (*api.CommPRet, error)                                                   `perm:"read"`
+		ClientGenCar                              func(ctx context.Context, ref api.FileRef, outpath string) error                                                  `perm:"write"`
+		ClientDealSize                            func(ctx context.Context, root cid.Cid) (api.DataSize, error)                                                     `perm:"read"`
+		ClientListDataTransfers                   func(ctx context.Context) ([]api.DataTransferChannel, error)                                                      `perm:"write"`
+		ClientDataTransferUpdates                 func(ctx context.Context) (<-chan api.DataTransferChannel, error)                                                 `perm:"write"`
+		ClientRetrieveTryRestartInsufficientFunds func(ctx context.Context, paymentChannel address.Address) error                                                   `perm:"write"`
 
-		StateMinerSectors             func(context.Context, address.Address, *types.TipSet) ([]*api.ChainSectorInfo, error)             `perm:"read"`
-		StateMinerProvingSet          func(context.Context, address.Address, *types.TipSet) ([]*api.ChainSectorInfo, error)             `perm:"read"`
-		StateMinerPower               func(context.Context, address.Address, *types.TipSet) (api.MinerPower, error)                     `perm:"read"`
-		StateMinerWorker              func(context.Context, address.Address, *types.TipSet) (address.Address, error)                    `perm:"read"`
-		StateMinerPeerID              func(ctx context.Context, m address.Address, ts *types.TipSet) (peer.ID, error)                   `perm:"read"`
-		StateMinerElectionPeriodStart func(ctx context.Context, actor address.Address, ts *types.TipSet) (uint64, error)                `perm:"read"`
-		StateMinerSectorSize          func(context.Context, address.Address, *types.TipSet) (uint64, error)                             `perm:"read"`
-		StateCall                     func(context.Context, *types.Message, *types.TipSet) (*types.MessageReceipt, error)               `perm:"read"`
-		StateReplay                   func(context.Context, *types.TipSet, cid.Cid) (*api.ReplayResults, error)                         `perm:"read"`
-		StateGetActor                 func(context.Context, address.Address, *types.TipSet) (*types.Actor, error)                       `perm:"read"`
-		StateReadState                func(context.Context, *types.Actor, *types.TipSet) (*api.ActorState, error)                       `perm:"read"`
-		StatePledgeCollateral         func(context.Context, *types.TipSet) (types.BigInt, error)                                        `perm:"read"`
-		StateWaitMsg                  func(context.Context, cid.Cid) (*api.MsgWait, error)                                              `perm:"read"`
-		StateListMiners               func(context.Context, *types.TipSet) ([]address.Address, error)                                   `perm:"read"`
-		StateListActors               func(context.Context, *types.TipSet) ([]address.Address, error)                                   `perm:"read"`
-		StateMarketBalance            func(context.Context, address.Address, *types.TipSet) (actors.StorageParticipantBalance, error)   `perm:"read"`
-		StateMarketParticipants       func(context.Context, *types.TipSet) (map[string]actors.StorageParticipantBalance, error)         `perm:"read"`
-		StateMarketDeals              func(context.Context, *types.TipSet) (map[string]actors.OnChainDeal, error)                       `perm:"read"`
-		StateMarketStorageDeal        func(context.Context, uint64, *types.TipSet) (*actors.OnChainDeal, error)                         `perm:"read"`
-		StateLookupID                 func(ctx context.Context, addr address.Address, ts *types.TipSet) (address.Address, error)        `perm:"read"`
-		StateChangedActors            func(context.Context, cid.Cid, cid.Cid) (map[string]types.Actor, error)                           `perm:"read"`
-		StateGetReceipt               func(context.Context, cid.Cid, *types.TipSet) (*types.MessageReceipt, error)                      `perm:"read"`
-		StateMinerSectorCount         func(context.Context, address.Address, *types.TipSet) (api.MinerSectors, error)                   `perm:"read"`
-		StateListMessages             func(ctx context.Context, match *types.Message, ts *types.TipSet, toht uint64) ([]cid.Cid, error) `perm:"read"`
+		StateNetworkName                   func(context.Context) (dtypes.NetworkName, error)                                                                   `perm:"read"`
+		StateMinerSectors                  func(context.Context, address.Address, *bitfield.BitField, types.TipSetKey) ([]*miner.SectorOnChainInfo, error)     `perm:"read"`
+		StateMinerActiveSectors            func(context.Context, address.Address, types.TipSetKey) ([]*miner.SectorOnChainInfo, error)                         `perm:"read"`
+		StateMinerProvingDeadline          func(context.Context, address.Address, types.TipSetKey) (*dline.Info, error)                                        `perm:"read"`
+		StateMinerPower                    func(context.Context, address.Address, types.TipSetKey) (*api.MinerPower, error)                                    `perm:"read"`
+		StateMinerInfo                     func(context.Context, address.Address, types.TipSetKey) (miner.MinerInfo, error)                                    `perm:"read"`
+		StateMinerDeadlines                func(context.Context, address.Address, types.TipSetKey) ([]api.Deadline, error)                                     `perm:"read"`
+		StateMinerPartitions               func(ctx context.Context, m address.Address, dlIdx uint64, tsk types.TipSetKey) ([]api.Partition, error)            `perm:"read"`
+		StateMinerFaults                   func(context.Context, address.Address, types.TipSetKey) (bitfield.BitField, error)                                  `perm:"read"`
+		StateAllMinerFaults                func(context.Context, abi.ChainEpoch, types.TipSetKey) ([]*api.Fault, error)                                        `perm:"read"`
+		StateMinerRecoveries               func(context.Context, address.Address, types.TipSetKey) (bitfield.BitField, error)                                  `perm:"read"`
+		StateMinerPreCommitDepositForPower func(context.Context, address.Address, miner.SectorPreCommitInfo, types.TipSetKey) (types.BigInt, error)            `perm:"read"`
+		StateMinerInitialPledgeCollateral  func(context.Context, address.Address, miner.SectorPreCommitInfo, types.TipSetKey) (types.BigInt, error)            `perm:"read"`
+		StateMinerAvailableBalance         func(context.Context, address.Address, types.TipSetKey) (types.BigInt, error)                                       `perm:"read"`
+		StateSectorPreCommitInfo           func(context.Context, address.Address, abi.SectorNumber, types.TipSetKey) (miner.SectorPreCommitOnChainInfo, error) `perm:"read"`
+		StateSectorGetInfo                 func(context.Context, address.Address, abi.SectorNumber, types.TipSetKey) (*miner.SectorOnChainInfo, error)         `perm:"read"`
+		StateSectorExpiration              func(context.Context, address.Address, abi.SectorNumber, types.TipSetKey) (*miner.SectorExpiration, error)          `perm:"read"`
+		StateSectorPartition               func(context.Context, address.Address, abi.SectorNumber, types.TipSetKey) (*miner.SectorLocation, error)            `perm:"read"`
+		StateCall                          func(context.Context, *types.Message, types.TipSetKey) (*api.InvocResult, error)                                    `perm:"read"`
+		StateReplay                        func(context.Context, types.TipSetKey, cid.Cid) (*api.InvocResult, error)                                           `perm:"read"`
+		StateGetActor                      func(context.Context, address.Address, types.TipSetKey) (*types.Actor, error)                                       `perm:"read"`
+		StateReadState                     func(context.Context, address.Address, types.TipSetKey) (*api.ActorState, error)                                    `perm:"read"`
+		StateMsgGasCost                    func(context.Context, cid.Cid, types.TipSetKey) (*api.MsgGasCost, error)                                            `perm:"read"`
+		StateWaitMsg                       func(ctx context.Context, cid cid.Cid, confidence uint64) (*api.MsgLookup, error)                                   `perm:"read"`
+		StateSearchMsg                     func(context.Context, cid.Cid) (*api.MsgLookup, error)                                                              `perm:"read"`
+		StateListMiners                    func(context.Context, types.TipSetKey) ([]address.Address, error)                                                   `perm:"read"`
+		StateListActors                    func(context.Context, types.TipSetKey) ([]address.Address, error)                                                   `perm:"read"`
+		StateMarketBalance                 func(context.Context, address.Address, types.TipSetKey) (api.MarketBalance, error)                                  `perm:"read"`
+		StateMarketParticipants            func(context.Context, types.TipSetKey) (map[string]api.MarketBalance, error)                                        `perm:"read"`
+		StateMarketDeals                   func(context.Context, types.TipSetKey) (map[string]api.MarketDeal, error)                                           `perm:"read"`
+		StateMarketStorageDeal             func(context.Context, abi.DealID, types.TipSetKey) (*api.MarketDeal, error)                                         `perm:"read"`
+		StateLookupID                      func(ctx context.Context, addr address.Address, tsk types.TipSetKey) (address.Address, error)                       `perm:"read"`
+		StateAccountKey                    func(context.Context, address.Address, types.TipSetKey) (address.Address, error)                                    `perm:"read"`
+		StateChangedActors                 func(context.Context, cid.Cid, cid.Cid) (map[string]types.Actor, error)                                             `perm:"read"`
+		StateGetReceipt                    func(context.Context, cid.Cid, types.TipSetKey) (*types.MessageReceipt, error)                                      `perm:"read"`
+		StateMinerSectorCount              func(context.Context, address.Address, types.TipSetKey) (api.MinerSectors, error)                                   `perm:"read"`
+		StateListMessages                  func(ctx context.Context, match *types.Message, tsk types.TipSetKey, toht abi.ChainEpoch) ([]cid.Cid, error)        `perm:"read"`
+		StateCompute                       func(context.Context, abi.ChainEpoch, []*types.Message, types.TipSetKey) (*api.ComputeStateOutput, error)           `perm:"read"`
+		StateVerifiedClientStatus          func(context.Context, address.Address, types.TipSetKey) (*abi.StoragePower, error)                                  `perm:"read"`
+		StateDealProviderCollateralBounds  func(context.Context, abi.PaddedPieceSize, bool, types.TipSetKey) (api.DealCollateralBounds, error)                 `perm:"read"`
+		StateCirculatingSupply             func(context.Context, types.TipSetKey) (api.CirculatingSupply, error)                                               `perm:"read"`
+		StateNetworkVersion                func(context.Context, types.TipSetKey) (stnetwork.Version, error)                                                   `perm:"read"`
 
-		MarketEnsureAvailable func(context.Context, address.Address, types.BigInt) error `perm:"sign"`
+		MsigGetAvailableBalance func(context.Context, address.Address, types.TipSetKey) (types.BigInt, error)                                                                    `perm:"read"`
+		MsigGetVested           func(context.Context, address.Address, types.TipSetKey, types.TipSetKey) (types.BigInt, error)                                                   `perm:"read"`
+		MsigCreate              func(context.Context, uint64, []address.Address, abi.ChainEpoch, types.BigInt, address.Address, types.BigInt) (cid.Cid, error)                   `perm:"sign"`
+		MsigPropose             func(context.Context, address.Address, address.Address, types.BigInt, address.Address, uint64, []byte) (cid.Cid, error)                          `perm:"sign"`
+		MsigApprove             func(context.Context, address.Address, uint64, address.Address, address.Address, types.BigInt, address.Address, uint64, []byte) (cid.Cid, error) `perm:"sign"`
+		MsigCancel              func(context.Context, address.Address, uint64, address.Address, types.BigInt, address.Address, uint64, []byte) (cid.Cid, error)                  `perm:"sign"`
+		MsigAddPropose          func(context.Context, address.Address, address.Address, address.Address, bool) (cid.Cid, error)                                                  `perm:"sign"`
+		MsigAddApprove          func(context.Context, address.Address, address.Address, uint64, address.Address, address.Address, bool) (cid.Cid, error)                         `perm:"sign"`
+		MsigAddCancel           func(context.Context, address.Address, address.Address, uint64, address.Address, bool) (cid.Cid, error)                                          `perm:"sign"`
+		MsigSwapPropose         func(context.Context, address.Address, address.Address, address.Address, address.Address) (cid.Cid, error)                                       `perm:"sign"`
+		MsigSwapApprove         func(context.Context, address.Address, address.Address, uint64, address.Address, address.Address, address.Address) (cid.Cid, error)              `perm:"sign"`
+		MsigSwapCancel          func(context.Context, address.Address, address.Address, uint64, address.Address, address.Address) (cid.Cid, error)                               `perm:"sign"`
 
-		PaychGet                   func(ctx context.Context, from, to address.Address, ensureFunds types.BigInt) (*api.ChannelInfo, error)   `perm:"sign"`
-		PaychList                  func(context.Context) ([]address.Address, error)                                                          `perm:"read"`
-		PaychStatus                func(context.Context, address.Address) (*api.PaychStatus, error)                                          `perm:"read"`
-		PaychClose                 func(context.Context, address.Address) (cid.Cid, error)                                                   `perm:"sign"`
-		PaychAllocateLane          func(context.Context, address.Address) (uint64, error)                                                    `perm:"sign"`
-		PaychNewPayment            func(ctx context.Context, from, to address.Address, vouchers []api.VoucherSpec) (*api.PaymentInfo, error) `perm:"sign"`
-		PaychVoucherCheck          func(context.Context, *types.SignedVoucher) error                                                         `perm:"read"`
-		PaychVoucherCheckValid     func(context.Context, address.Address, *types.SignedVoucher) error                                        `perm:"read"`
-		PaychVoucherCheckSpendable func(context.Context, address.Address, *types.SignedVoucher, []byte, []byte) (bool, error)                `perm:"read"`
-		PaychVoucherAdd            func(context.Context, address.Address, *types.SignedVoucher, []byte, types.BigInt) (types.BigInt, error)  `perm:"write"`
-		PaychVoucherCreate         func(context.Context, address.Address, types.BigInt, uint64) (*types.SignedVoucher, error)                `perm:"sign"`
-		PaychVoucherList           func(context.Context, address.Address) ([]*types.SignedVoucher, error)                                    `perm:"write"`
-		PaychVoucherSubmit         func(context.Context, address.Address, *types.SignedVoucher) (cid.Cid, error)                             `perm:"sign"`
+		MarketEnsureAvailable func(context.Context, address.Address, address.Address, types.BigInt) (cid.Cid, error) `perm:"sign"`
+
+		PaychGet                    func(ctx context.Context, from, to address.Address, amt types.BigInt) (*api.ChannelInfo, error)           `perm:"sign"`
+		PaychGetWaitReady           func(context.Context, cid.Cid) (address.Address, error)                                                   `perm:"sign"`
+		PaychAvailableFunds         func(context.Context, address.Address) (*api.ChannelAvailableFunds, error)                                `perm:"sign"`
+		PaychAvailableFundsByFromTo func(context.Context, address.Address, address.Address) (*api.ChannelAvailableFunds, error)               `perm:"sign"`
+		PaychList                   func(context.Context) ([]address.Address, error)                                                          `perm:"read"`
+		PaychStatus                 func(context.Context, address.Address) (*api.PaychStatus, error)                                          `perm:"read"`
+		PaychSettle                 func(context.Context, address.Address) (cid.Cid, error)                                                   `perm:"sign"`
+		PaychCollect                func(context.Context, address.Address) (cid.Cid, error)                                                   `perm:"sign"`
+		PaychAllocateLane           func(context.Context, address.Address) (uint64, error)                                                    `perm:"sign"`
+		PaychNewPayment             func(ctx context.Context, from, to address.Address, vouchers []api.VoucherSpec) (*api.PaymentInfo, error) `perm:"sign"`
+		PaychVoucherCheck           func(context.Context, *paych.SignedVoucher) error                                                         `perm:"read"`
+		PaychVoucherCheckValid      func(context.Context, address.Address, *paych.SignedVoucher) error                                        `perm:"read"`
+		PaychVoucherCheckSpendable  func(context.Context, address.Address, *paych.SignedVoucher, []byte, []byte) (bool, error)                `perm:"read"`
+		PaychVoucherAdd             func(context.Context, address.Address, *paych.SignedVoucher, []byte, types.BigInt) (types.BigInt, error)  `perm:"write"`
+		PaychVoucherCreate          func(context.Context, address.Address, big.Int, uint64) (*api.VoucherCreateResult, error)                 `perm:"sign"`
+		PaychVoucherList            func(context.Context, address.Address) ([]*paych.SignedVoucher, error)                                    `perm:"write"`
+		PaychVoucherSubmit          func(context.Context, address.Address, *paych.SignedVoucher, []byte, []byte) (cid.Cid, error)             `perm:"sign"`
 	}
 }
 
-func (c *FullNodeStruct) StateMinerSectorCount(ctx context.Context, addr address.Address, ts *types.TipSet) (api.MinerSectors, error) {
-	return c.Internal.StateMinerSectorCount(ctx, addr, ts)
+func (c *FullNodeStruct) StateMinerSectorCount(ctx context.Context, addr address.Address, tsk types.TipSetKey) (api.MinerSectors, error) {
+	return c.Internal.StateMinerSectorCount(ctx, addr, tsk)
 }
 
 type StorageMinerStruct struct {
 	CommonStruct
 
 	Internal struct {
-		ActorAddress    func(context.Context) (address.Address, error)         `perm:"read"`
-		ActorSectorSize func(context.Context, address.Address) (uint64, error) `perm:"read"`
+		ActorAddress    func(context.Context) (address.Address, error)                 `perm:"read"`
+		ActorSectorSize func(context.Context, address.Address) (abi.SectorSize, error) `perm:"read"`
+
+		MiningBase func(context.Context) (*types.TipSet, error) `perm:"read"`
+
+		MarketImportDealData      func(context.Context, cid.Cid, string) error                                                                                                                                 `perm:"write"`
+		MarketListDeals           func(ctx context.Context) ([]api.MarketDeal, error)                                                                                                                          `perm:"read"`
+		MarketListRetrievalDeals  func(ctx context.Context) ([]retrievalmarket.ProviderDealState, error)                                                                                                       `perm:"read"`
+		MarketGetDealUpdates      func(ctx context.Context) (<-chan storagemarket.MinerDeal, error)                                                                                                            `perm:"read"`
+		MarketListIncompleteDeals func(ctx context.Context) ([]storagemarket.MinerDeal, error)                                                                                                                 `perm:"read"`
+		MarketSetAsk              func(ctx context.Context, price types.BigInt, verifiedPrice types.BigInt, duration abi.ChainEpoch, minPieceSize abi.PaddedPieceSize, maxPieceSize abi.PaddedPieceSize) error `perm:"admin"`
+		MarketGetAsk              func(ctx context.Context) (*storagemarket.SignedStorageAsk, error)                                                                                                           `perm:"read"`
+		MarketSetRetrievalAsk     func(ctx context.Context, rask *retrievalmarket.Ask) error                                                                                                                   `perm:"admin"`
+		MarketGetRetrievalAsk     func(ctx context.Context) (*retrievalmarket.Ask, error)                                                                                                                      `perm:"read"`
+		MarketListDataTransfers   func(ctx context.Context) ([]api.DataTransferChannel, error)                                                                                                                 `perm:"write"`
+		MarketDataTransferUpdates func(ctx context.Context) (<-chan api.DataTransferChannel, error)                                                                                                            `perm:"write"`
 
 		PledgeSector func(context.Context) error `perm:"write"`
 
-		SectorsStatus func(context.Context, uint64) (api.SectorInfo, error)     `perm:"read"`
-		SectorsList   func(context.Context) ([]uint64, error)                   `perm:"read"`
-		SectorsRefs   func(context.Context) (map[string][]api.SealedRef, error) `perm:"read"`
-		SectorsUpdate func(context.Context, uint64, api.SectorState) error      `perm:"write"`
+		SectorsStatus                 func(ctx context.Context, sid abi.SectorNumber, showOnChainInfo bool) (api.SectorInfo, error) `perm:"read"`
+		SectorsList                   func(context.Context) ([]abi.SectorNumber, error)                                             `perm:"read"`
+		SectorsRefs                   func(context.Context) (map[string][]api.SealedRef, error)                                     `perm:"read"`
+		SectorStartSealing            func(context.Context, abi.SectorNumber) error                                                 `perm:"write"`
+		SectorSetSealDelay            func(context.Context, time.Duration) error                                                    `perm:"write"`
+		SectorGetSealDelay            func(context.Context) (time.Duration, error)                                                  `perm:"read"`
+		SectorSetExpectedSealDuration func(context.Context, time.Duration) error                                                    `perm:"write"`
+		SectorGetExpectedSealDuration func(context.Context) (time.Duration, error)                                                  `perm:"read"`
+		SectorsUpdate                 func(context.Context, abi.SectorNumber, api.SectorState) error                                `perm:"admin"`
+		SectorRemove                  func(context.Context, abi.SectorNumber) error                                                 `perm:"admin"`
+		SectorMarkForUpgrade          func(ctx context.Context, id abi.SectorNumber) error                                          `perm:"admin"`
 
-		WorkerStats func(context.Context) (sectorbuilder.WorkerStats, error) `perm:"read"`
+		WorkerConnect func(context.Context, string) error                             `perm:"admin"` // TODO: worker perm
+		WorkerStats   func(context.Context) (map[uint64]storiface.WorkerStats, error) `perm:"admin"`
+		WorkerJobs    func(context.Context) (map[uint64][]storiface.WorkerJob, error) `perm:"admin"`
 
-		WorkerQueue func(ctx context.Context, cfg sectorbuilder.WorkerCfg) (<-chan sectorbuilder.WorkerTask, error) `perm:"admin"` // TODO: worker perm
-		WorkerDone  func(ctx context.Context, task uint64, res sectorbuilder.SealRes) error                         `perm:"admin"`
+		SealingSchedDiag func(context.Context) (interface{}, error) `perm:"admin"`
+
+		StorageList          func(context.Context) (map[stores.ID][]stores.Decl, error)                                                                                    `perm:"admin"`
+		StorageLocal         func(context.Context) (map[stores.ID]string, error)                                                                                           `perm:"admin"`
+		StorageStat          func(context.Context, stores.ID) (fsutil.FsStat, error)                                                                                       `perm:"admin"`
+		StorageAttach        func(context.Context, stores.StorageInfo, fsutil.FsStat) error                                                                                `perm:"admin"`
+		StorageDeclareSector func(context.Context, stores.ID, abi.SectorID, stores.SectorFileType, bool) error                                                             `perm:"admin"`
+		StorageDropSector    func(context.Context, stores.ID, abi.SectorID, stores.SectorFileType) error                                                                   `perm:"admin"`
+		StorageFindSector    func(context.Context, abi.SectorID, stores.SectorFileType, abi.RegisteredSealProof, bool) ([]stores.SectorStorageInfo, error)                 `perm:"admin"`
+		StorageInfo          func(context.Context, stores.ID) (stores.StorageInfo, error)                                                                                  `perm:"admin"`
+		StorageBestAlloc     func(ctx context.Context, allocate stores.SectorFileType, spt abi.RegisteredSealProof, sealing stores.PathType) ([]stores.StorageInfo, error) `perm:"admin"`
+		StorageReportHealth  func(ctx context.Context, id stores.ID, report stores.HealthReport) error                                                                     `perm:"admin"`
+		StorageLock          func(ctx context.Context, sector abi.SectorID, read stores.SectorFileType, write stores.SectorFileType) error                                 `perm:"admin"`
+		StorageTryLock       func(ctx context.Context, sector abi.SectorID, read stores.SectorFileType, write stores.SectorFileType) (bool, error)                         `perm:"admin"`
+
+		DealsImportData                       func(ctx context.Context, dealPropCid cid.Cid, file string) error `perm:"write"`
+		DealsList                             func(ctx context.Context) ([]api.MarketDeal, error)               `perm:"read"`
+		DealsConsiderOnlineStorageDeals       func(context.Context) (bool, error)                               `perm:"read"`
+		DealsSetConsiderOnlineStorageDeals    func(context.Context, bool) error                                 `perm:"admin"`
+		DealsConsiderOnlineRetrievalDeals     func(context.Context) (bool, error)                               `perm:"read"`
+		DealsSetConsiderOnlineRetrievalDeals  func(context.Context, bool) error                                 `perm:"admin"`
+		DealsConsiderOfflineStorageDeals      func(context.Context) (bool, error)                               `perm:"read"`
+		DealsSetConsiderOfflineStorageDeals   func(context.Context, bool) error                                 `perm:"admin"`
+		DealsConsiderOfflineRetrievalDeals    func(context.Context) (bool, error)                               `perm:"read"`
+		DealsSetConsiderOfflineRetrievalDeals func(context.Context, bool) error                                 `perm:"admin"`
+		DealsPieceCidBlocklist                func(context.Context) ([]cid.Cid, error)                          `perm:"read"`
+		DealsSetPieceCidBlocklist             func(context.Context, []cid.Cid) error                            `perm:"admin"`
+
+		StorageAddLocal func(ctx context.Context, path string) error `perm:"admin"`
+
+		PiecesListPieces   func(ctx context.Context) ([]cid.Cid, error)                               `perm:"read"`
+		PiecesListCidInfos func(ctx context.Context) ([]cid.Cid, error)                               `perm:"read"`
+		PiecesGetPieceInfo func(ctx context.Context, pieceCid cid.Cid) (*piecestore.PieceInfo, error) `perm:"read"`
+		PiecesGetCIDInfo   func(ctx context.Context, payloadCid cid.Cid) (*piecestore.CIDInfo, error) `perm:"read"`
 	}
 }
 
-func (c *CommonStruct) AuthVerify(ctx context.Context, token string) ([]api.Permission, error) {
+type WorkerStruct struct {
+	Internal struct {
+		// TODO: lower perms
+
+		Version func(context.Context) (build.Version, error) `perm:"admin"`
+
+		TaskTypes func(context.Context) (map[sealtasks.TaskType]struct{}, error) `perm:"admin"`
+		Paths     func(context.Context) ([]stores.StoragePath, error)            `perm:"admin"`
+		Info      func(context.Context) (storiface.WorkerInfo, error)            `perm:"admin"`
+
+		AddPiece        func(ctx context.Context, sector abi.SectorID, pieceSizes []abi.UnpaddedPieceSize, newPieceSize abi.UnpaddedPieceSize, pieceData storage.Data) (abi.PieceInfo, error)                      `perm:"admin"`
+		SealPreCommit1  func(ctx context.Context, sector abi.SectorID, ticket abi.SealRandomness, pieces []abi.PieceInfo) (storage.PreCommit1Out, error)                                                           `perm:"admin"`
+		SealPreCommit2  func(context.Context, abi.SectorID, storage.PreCommit1Out) (cids storage.SectorCids, err error)                                                                                            `perm:"admin"`
+		SealCommit1     func(ctx context.Context, sector abi.SectorID, ticket abi.SealRandomness, seed abi.InteractiveSealRandomness, pieces []abi.PieceInfo, cids storage.SectorCids) (storage.Commit1Out, error) `perm:"admin"`
+		SealCommit2     func(context.Context, abi.SectorID, storage.Commit1Out) (storage.Proof, error)                                                                                                             `perm:"admin"`
+		FinalizeSector  func(context.Context, abi.SectorID, []storage.Range) error                                                                                                                                 `perm:"admin"`
+		ReleaseUnsealed func(ctx context.Context, sector abi.SectorID, safeToFree []storage.Range) error                                                                                                           `perm:"admin"`
+		Remove          func(ctx context.Context, sector abi.SectorID) error                                                                                                                                       `perm:"admin"`
+		MoveStorage     func(ctx context.Context, sector abi.SectorID, types stores.SectorFileType) error                                                                                                          `perm:"admin"`
+		StorageAddLocal func(ctx context.Context, path string) error                                                                                                                                               `perm:"admin"`
+
+		UnsealPiece func(context.Context, abi.SectorID, storiface.UnpaddedByteIndex, abi.UnpaddedPieceSize, abi.SealRandomness, cid.Cid) error `perm:"admin"`
+		ReadPiece   func(context.Context, io.Writer, abi.SectorID, storiface.UnpaddedByteIndex, abi.UnpaddedPieceSize) (bool, error)           `perm:"admin"`
+
+		Fetch func(context.Context, abi.SectorID, stores.SectorFileType, stores.PathType, stores.AcquireMode) error `perm:"admin"`
+
+		Closing func(context.Context) (<-chan struct{}, error) `perm:"admin"`
+	}
+}
+
+// CommonStruct
+
+func (c *CommonStruct) AuthVerify(ctx context.Context, token string) ([]auth.Permission, error) {
 	return c.Internal.AuthVerify(ctx, token)
 }
 
-func (c *CommonStruct) AuthNew(ctx context.Context, perms []api.Permission) ([]byte, error) {
+func (c *CommonStruct) AuthNew(ctx context.Context, perms []auth.Permission) ([]byte, error) {
 	return c.Internal.AuthNew(ctx, perms)
 }
 
+func (c *CommonStruct) NetPubsubScores(ctx context.Context) ([]api.PubsubScore, error) {
+	return c.Internal.NetPubsubScores(ctx)
+}
+
 func (c *CommonStruct) NetConnectedness(ctx context.Context, pid peer.ID) (network.Connectedness, error) {
 	return c.Internal.NetConnectedness(ctx, pid)
 }
@@ -186,6 +384,30 @@ func (c *CommonStruct) NetDisconnect(ctx context.Context, p peer.ID) error {
 	return c.Internal.NetDisconnect(ctx, p)
 }
 
+func (c *CommonStruct) NetFindPeer(ctx context.Context, p peer.ID) (peer.AddrInfo, error) {
+	return c.Internal.NetFindPeer(ctx, p)
+}
+
+func (c *CommonStruct) NetAutoNatStatus(ctx context.Context) (api.NatInfo, error) {
+	return c.Internal.NetAutoNatStatus(ctx)
+}
+
+func (c *CommonStruct) NetBandwidthStats(ctx context.Context) (metrics.Stats, error) {
+	return c.Internal.NetBandwidthStats(ctx)
+}
+
+func (c *CommonStruct) NetBandwidthStatsByPeer(ctx context.Context) (map[string]metrics.Stats, error) {
+	return c.Internal.NetBandwidthStatsByPeer(ctx)
+}
+
+func (c *CommonStruct) NetBandwidthStatsByProtocol(ctx context.Context) (map[protocol.ID]metrics.Stats, error) {
+	return c.Internal.NetBandwidthStatsByProtocol(ctx)
+}
+
+func (c *CommonStruct) NetAgentVersion(ctx context.Context, p peer.ID) (string, error) {
+	return c.Internal.NetAgentVersion(ctx, p)
+}
+
 // ID implements API.ID
 func (c *CommonStruct) ID(ctx context.Context) (peer.ID, error) {
 	return c.Internal.ID(ctx)
@@ -196,25 +418,52 @@ func (c *CommonStruct) Version(ctx context.Context) (api.Version, error) {
 	return c.Internal.Version(ctx)
 }
 
+func (c *CommonStruct) LogList(ctx context.Context) ([]string, error) {
+	return c.Internal.LogList(ctx)
+}
+
+func (c *CommonStruct) LogSetLevel(ctx context.Context, group, level string) error {
+	return c.Internal.LogSetLevel(ctx, group, level)
+}
+
+func (c *CommonStruct) Shutdown(ctx context.Context) error {
+	return c.Internal.Shutdown(ctx)
+}
+
+func (c *CommonStruct) Closing(ctx context.Context) (<-chan struct{}, error) {
+	return c.Internal.Closing(ctx)
+}
+
+// FullNodeStruct
+
 func (c *FullNodeStruct) ClientListImports(ctx context.Context) ([]api.Import, error) {
 	return c.Internal.ClientListImports(ctx)
 }
 
-func (c *FullNodeStruct) ClientImport(ctx context.Context, path string) (cid.Cid, error) {
-	return c.Internal.ClientImport(ctx, path)
+func (c *FullNodeStruct) ClientRemoveImport(ctx context.Context, importID multistore.StoreID) error {
+	return c.Internal.ClientRemoveImport(ctx, importID)
+}
+
+func (c *FullNodeStruct) ClientImport(ctx context.Context, ref api.FileRef) (*api.ImportRes, error) {
+	return c.Internal.ClientImport(ctx, ref)
 }
 
 func (c *FullNodeStruct) ClientHasLocal(ctx context.Context, root cid.Cid) (bool, error) {
 	return c.Internal.ClientHasLocal(ctx, root)
 }
 
-func (c *FullNodeStruct) ClientFindData(ctx context.Context, root cid.Cid) ([]api.QueryOffer, error) {
-	return c.Internal.ClientFindData(ctx, root)
+func (c *FullNodeStruct) ClientFindData(ctx context.Context, root cid.Cid, piece *cid.Cid) ([]api.QueryOffer, error) {
+	return c.Internal.ClientFindData(ctx, root, piece)
 }
 
-func (c *FullNodeStruct) ClientStartDeal(ctx context.Context, data cid.Cid, addr address.Address, miner address.Address, price types.BigInt, blocksDuration uint64) (*cid.Cid, error) {
-	return c.Internal.ClientStartDeal(ctx, data, addr, miner, price, blocksDuration)
+func (c *FullNodeStruct) ClientMinerQueryOffer(ctx context.Context, miner address.Address, root cid.Cid, piece *cid.Cid) (api.QueryOffer, error) {
+	return c.Internal.ClientMinerQueryOffer(ctx, miner, root, piece)
 }
+
+func (c *FullNodeStruct) ClientStartDeal(ctx context.Context, params *api.StartDealParams) (*cid.Cid, error) {
+	return c.Internal.ClientStartDeal(ctx, params)
+}
+
 func (c *FullNodeStruct) ClientGetDealInfo(ctx context.Context, deal cid.Cid) (*api.DealInfo, error) {
 	return c.Internal.ClientGetDealInfo(ctx, deal)
 }
@@ -223,47 +472,118 @@ func (c *FullNodeStruct) ClientListDeals(ctx context.Context) ([]api.DealInfo, e
 	return c.Internal.ClientListDeals(ctx)
 }
 
-func (c *FullNodeStruct) ClientRetrieve(ctx context.Context, order api.RetrievalOrder, path string) error {
-	return c.Internal.ClientRetrieve(ctx, order, path)
+func (c *FullNodeStruct) ClientGetDealUpdates(ctx context.Context) (<-chan api.DealInfo, error) {
+	return c.Internal.ClientGetDealUpdates(ctx)
 }
 
-func (c *FullNodeStruct) ClientQueryAsk(ctx context.Context, p peer.ID, miner address.Address) (*types.SignedStorageAsk, error) {
+func (c *FullNodeStruct) ClientRetrieve(ctx context.Context, order api.RetrievalOrder, ref *api.FileRef) error {
+	return c.Internal.ClientRetrieve(ctx, order, ref)
+}
+
+func (c *FullNodeStruct) ClientRetrieveWithEvents(ctx context.Context, order api.RetrievalOrder, ref *api.FileRef) (<-chan marketevents.RetrievalEvent, error) {
+	return c.Internal.ClientRetrieveWithEvents(ctx, order, ref)
+}
+
+func (c *FullNodeStruct) ClientQueryAsk(ctx context.Context, p peer.ID, miner address.Address) (*storagemarket.SignedStorageAsk, error) {
 	return c.Internal.ClientQueryAsk(ctx, p, miner)
 }
+func (c *FullNodeStruct) ClientCalcCommP(ctx context.Context, inpath string) (*api.CommPRet, error) {
+	return c.Internal.ClientCalcCommP(ctx, inpath)
+}
 
-func (c *FullNodeStruct) MpoolPending(ctx context.Context, ts *types.TipSet) ([]*types.SignedMessage, error) {
-	return c.Internal.MpoolPending(ctx, ts)
+func (c *FullNodeStruct) ClientGenCar(ctx context.Context, ref api.FileRef, outpath string) error {
+	return c.Internal.ClientGenCar(ctx, ref, outpath)
+}
+
+func (c *FullNodeStruct) ClientDealSize(ctx context.Context, root cid.Cid) (api.DataSize, error) {
+	return c.Internal.ClientDealSize(ctx, root)
+}
+
+func (c *FullNodeStruct) ClientListDataTransfers(ctx context.Context) ([]api.DataTransferChannel, error) {
+	return c.Internal.ClientListDataTransfers(ctx)
+}
+
+func (c *FullNodeStruct) ClientDataTransferUpdates(ctx context.Context) (<-chan api.DataTransferChannel, error) {
+	return c.Internal.ClientDataTransferUpdates(ctx)
+}
+
+func (c *FullNodeStruct) ClientRetrieveTryRestartInsufficientFunds(ctx context.Context, paymentChannel address.Address) error {
+	return c.Internal.ClientRetrieveTryRestartInsufficientFunds(ctx, paymentChannel)
+}
+
+func (c *FullNodeStruct) GasEstimateGasPremium(ctx context.Context, nblocksincl uint64, sender address.Address, gaslimit int64, tsk types.TipSetKey) (types.BigInt, error) {
+	return c.Internal.GasEstimateGasPremium(ctx, nblocksincl, sender, gaslimit, tsk)
+}
+
+func (c *FullNodeStruct) GasEstimateFeeCap(ctx context.Context, msg *types.Message, maxqueueblks int64, tsk types.TipSetKey) (types.BigInt, error) {
+	return c.Internal.GasEstimateFeeCap(ctx, msg, maxqueueblks, tsk)
+}
+
+func (c *FullNodeStruct) GasEstimateMessageGas(ctx context.Context, msg *types.Message, spec *api.MessageSendSpec, tsk types.TipSetKey) (*types.Message, error) {
+	return c.Internal.GasEstimateMessageGas(ctx, msg, spec, tsk)
+}
+
+func (c *FullNodeStruct) GasEstimateGasLimit(ctx context.Context, msg *types.Message, tsk types.TipSetKey) (int64, error) {
+	return c.Internal.GasEstimateGasLimit(ctx, msg, tsk)
+}
+
+func (c *FullNodeStruct) MpoolGetConfig(ctx context.Context) (*types.MpoolConfig, error) {
+	return c.Internal.MpoolGetConfig(ctx)
+}
+
+func (c *FullNodeStruct) MpoolSetConfig(ctx context.Context, cfg *types.MpoolConfig) error {
+	return c.Internal.MpoolSetConfig(ctx, cfg)
+}
+
+func (c *FullNodeStruct) MpoolSelect(ctx context.Context, tsk types.TipSetKey, tq float64) ([]*types.SignedMessage, error) {
+	return c.Internal.MpoolSelect(ctx, tsk, tq)
+}
+
+func (c *FullNodeStruct) MpoolPending(ctx context.Context, tsk types.TipSetKey) ([]*types.SignedMessage, error) {
+	return c.Internal.MpoolPending(ctx, tsk)
+}
+
+func (c *FullNodeStruct) MpoolClear(ctx context.Context, local bool) error {
+	return c.Internal.MpoolClear(ctx, local)
 }
 
 func (c *FullNodeStruct) MpoolPush(ctx context.Context, smsg *types.SignedMessage) (cid.Cid, error) {
 	return c.Internal.MpoolPush(ctx, smsg)
 }
 
-func (c *FullNodeStruct) MpoolPushMessage(ctx context.Context, msg *types.Message) (*types.SignedMessage, error) {
-	return c.Internal.MpoolPushMessage(ctx, msg)
+func (c *FullNodeStruct) MpoolPushMessage(ctx context.Context, msg *types.Message, spec *api.MessageSendSpec) (*types.SignedMessage, error) {
+	return c.Internal.MpoolPushMessage(ctx, msg, spec)
 }
 
 func (c *FullNodeStruct) MpoolSub(ctx context.Context) (<-chan api.MpoolUpdate, error) {
 	return c.Internal.MpoolSub(ctx)
 }
 
-func (c *FullNodeStruct) MinerCreateBlock(ctx context.Context, addr address.Address, base *types.TipSet, ticket *types.Ticket, eproof *types.EPostProof, msgs []*types.SignedMessage, height, ts uint64) (*types.BlockMsg, error) {
-	return c.Internal.MinerCreateBlock(ctx, addr, base, ticket, eproof, msgs, height, ts)
+func (c *FullNodeStruct) MinerGetBaseInfo(ctx context.Context, maddr address.Address, epoch abi.ChainEpoch, tsk types.TipSetKey) (*api.MiningBaseInfo, error) {
+	return c.Internal.MinerGetBaseInfo(ctx, maddr, epoch, tsk)
+}
+
+func (c *FullNodeStruct) MinerCreateBlock(ctx context.Context, bt *api.BlockTemplate) (*types.BlockMsg, error) {
+	return c.Internal.MinerCreateBlock(ctx, bt)
 }
 
 func (c *FullNodeStruct) ChainHead(ctx context.Context) (*types.TipSet, error) {
 	return c.Internal.ChainHead(ctx)
 }
 
-func (c *FullNodeStruct) ChainGetRandomness(ctx context.Context, pts types.TipSetKey, round int64) ([]byte, error) {
-	return c.Internal.ChainGetRandomness(ctx, pts, round)
+func (c *FullNodeStruct) ChainGetRandomnessFromTickets(ctx context.Context, tsk types.TipSetKey, personalization crypto.DomainSeparationTag, randEpoch abi.ChainEpoch, entropy []byte) (abi.Randomness, error) {
+	return c.Internal.ChainGetRandomnessFromTickets(ctx, tsk, personalization, randEpoch, entropy)
 }
 
-func (c *FullNodeStruct) ChainGetTipSetByHeight(ctx context.Context, h uint64, ts *types.TipSet) (*types.TipSet, error) {
-	return c.Internal.ChainGetTipSetByHeight(ctx, h, ts)
+func (c *FullNodeStruct) ChainGetRandomnessFromBeacon(ctx context.Context, tsk types.TipSetKey, personalization crypto.DomainSeparationTag, randEpoch abi.ChainEpoch, entropy []byte) (abi.Randomness, error) {
+	return c.Internal.ChainGetRandomnessFromBeacon(ctx, tsk, personalization, randEpoch, entropy)
 }
 
-func (c *FullNodeStruct) WalletNew(ctx context.Context, typ string) (address.Address, error) {
+func (c *FullNodeStruct) ChainGetTipSetByHeight(ctx context.Context, h abi.ChainEpoch, tsk types.TipSetKey) (*types.TipSet, error) {
+	return c.Internal.ChainGetTipSetByHeight(ctx, h, tsk)
+}
+
+func (c *FullNodeStruct) WalletNew(ctx context.Context, typ crypto.SigType) (address.Address, error) {
 	return c.Internal.WalletNew(ctx, typ)
 }
 
@@ -279,7 +599,7 @@ func (c *FullNodeStruct) WalletBalance(ctx context.Context, a address.Address) (
 	return c.Internal.WalletBalance(ctx, a)
 }
 
-func (c *FullNodeStruct) WalletSign(ctx context.Context, k address.Address, msg []byte) (*types.Signature, error) {
+func (c *FullNodeStruct) WalletSign(ctx context.Context, k address.Address, msg []byte) (*crypto.Signature, error) {
 	return c.Internal.WalletSign(ctx, k, msg)
 }
 
@@ -287,6 +607,10 @@ func (c *FullNodeStruct) WalletSignMessage(ctx context.Context, k address.Addres
 	return c.Internal.WalletSignMessage(ctx, k, msg)
 }
 
+func (c *FullNodeStruct) WalletVerify(ctx context.Context, k address.Address, msg []byte, sig *crypto.Signature) (bool, error) {
+	return c.Internal.WalletVerify(ctx, k, msg, sig)
+}
+
 func (c *FullNodeStruct) WalletDefaultAddress(ctx context.Context) (address.Address, error) {
 	return c.Internal.WalletDefaultAddress(ctx)
 }
@@ -303,6 +627,10 @@ func (c *FullNodeStruct) WalletImport(ctx context.Context, ki *types.KeyInfo) (a
 	return c.Internal.WalletImport(ctx, ki)
 }
 
+func (c *FullNodeStruct) WalletDelete(ctx context.Context, addr address.Address) error {
+	return c.Internal.WalletDelete(ctx, addr)
+}
+
 func (c *FullNodeStruct) MpoolGetNonce(ctx context.Context, addr address.Address) (uint64, error) {
 	return c.Internal.MpoolGetNonce(ctx, addr)
 }
@@ -327,7 +655,7 @@ func (c *FullNodeStruct) ChainGetParentMessages(ctx context.Context, b cid.Cid)
 	return c.Internal.ChainGetParentMessages(ctx, b)
 }
 
-func (c *FullNodeStruct) ChainNotify(ctx context.Context) (<-chan []*store.HeadChange, error) {
+func (c *FullNodeStruct) ChainNotify(ctx context.Context) (<-chan []*api.HeadChange, error) {
 	return c.Internal.ChainNotify(ctx)
 }
 
@@ -335,19 +663,31 @@ func (c *FullNodeStruct) ChainReadObj(ctx context.Context, obj cid.Cid) ([]byte,
 	return c.Internal.ChainReadObj(ctx, obj)
 }
 
-func (c *FullNodeStruct) ChainSetHead(ctx context.Context, ts *types.TipSet) error {
-	return c.Internal.ChainSetHead(ctx, ts)
+func (c *FullNodeStruct) ChainDeleteObj(ctx context.Context, obj cid.Cid) error {
+	return c.Internal.ChainDeleteObj(ctx, obj)
+}
+
+func (c *FullNodeStruct) ChainHasObj(ctx context.Context, o cid.Cid) (bool, error) {
+	return c.Internal.ChainHasObj(ctx, o)
+}
+
+func (c *FullNodeStruct) ChainStatObj(ctx context.Context, obj, base cid.Cid) (api.ObjStat, error) {
+	return c.Internal.ChainStatObj(ctx, obj, base)
+}
+
+func (c *FullNodeStruct) ChainSetHead(ctx context.Context, tsk types.TipSetKey) error {
+	return c.Internal.ChainSetHead(ctx, tsk)
 }
 
 func (c *FullNodeStruct) ChainGetGenesis(ctx context.Context) (*types.TipSet, error) {
 	return c.Internal.ChainGetGenesis(ctx)
 }
 
-func (c *FullNodeStruct) ChainTipSetWeight(ctx context.Context, ts *types.TipSet) (types.BigInt, error) {
-	return c.Internal.ChainTipSetWeight(ctx, ts)
+func (c *FullNodeStruct) ChainTipSetWeight(ctx context.Context, tsk types.TipSetKey) (types.BigInt, error) {
+	return c.Internal.ChainTipSetWeight(ctx, tsk)
 }
 
-func (c *FullNodeStruct) ChainGetNode(ctx context.Context, p string) (interface{}, error) {
+func (c *FullNodeStruct) ChainGetNode(ctx context.Context, p string) (*api.IpldObject, error) {
 	return c.Internal.ChainGetNode(ctx, p)
 }
 
@@ -355,6 +695,18 @@ func (c *FullNodeStruct) ChainGetMessage(ctx context.Context, mc cid.Cid) (*type
 	return c.Internal.ChainGetMessage(ctx, mc)
 }
 
+func (c *FullNodeStruct) ChainGetPath(ctx context.Context, from types.TipSetKey, to types.TipSetKey) ([]*api.HeadChange, error) {
+	return c.Internal.ChainGetPath(ctx, from, to)
+}
+
+func (c *FullNodeStruct) ChainExport(ctx context.Context, nroots abi.ChainEpoch, iom bool, tsk types.TipSetKey) (<-chan []byte, error) {
+	return c.Internal.ChainExport(ctx, nroots, iom, tsk)
+}
+
+func (c *FullNodeStruct) BeaconGetEntry(ctx context.Context, epoch abi.ChainEpoch) (*types.BeaconEntry, error) {
+	return c.Internal.BeaconGetEntry(ctx, epoch)
+}
+
 func (c *FullNodeStruct) SyncState(ctx context.Context) (*api.SyncState, error) {
 	return c.Internal.SyncState(ctx)
 }
@@ -367,107 +719,252 @@ func (c *FullNodeStruct) SyncIncomingBlocks(ctx context.Context) (<-chan *types.
 	return c.Internal.SyncIncomingBlocks(ctx)
 }
 
+func (c *FullNodeStruct) SyncCheckpoint(ctx context.Context, tsk types.TipSetKey) error {
+	return c.Internal.SyncCheckpoint(ctx, tsk)
+}
+
 func (c *FullNodeStruct) SyncMarkBad(ctx context.Context, bcid cid.Cid) error {
 	return c.Internal.SyncMarkBad(ctx, bcid)
 }
 
-func (c *FullNodeStruct) StateMinerSectors(ctx context.Context, addr address.Address, ts *types.TipSet) ([]*api.ChainSectorInfo, error) {
-	return c.Internal.StateMinerSectors(ctx, addr, ts)
+func (c *FullNodeStruct) SyncUnmarkBad(ctx context.Context, bcid cid.Cid) error {
+	return c.Internal.SyncUnmarkBad(ctx, bcid)
 }
 
-func (c *FullNodeStruct) StateMinerProvingSet(ctx context.Context, addr address.Address, ts *types.TipSet) ([]*api.ChainSectorInfo, error) {
-	return c.Internal.StateMinerProvingSet(ctx, addr, ts)
+func (c *FullNodeStruct) SyncCheckBad(ctx context.Context, bcid cid.Cid) (string, error) {
+	return c.Internal.SyncCheckBad(ctx, bcid)
 }
 
-func (c *FullNodeStruct) StateMinerPower(ctx context.Context, a address.Address, ts *types.TipSet) (api.MinerPower, error) {
-	return c.Internal.StateMinerPower(ctx, a, ts)
+func (c *FullNodeStruct) StateNetworkName(ctx context.Context) (dtypes.NetworkName, error) {
+	return c.Internal.StateNetworkName(ctx)
 }
 
-func (c *FullNodeStruct) StateMinerWorker(ctx context.Context, m address.Address, ts *types.TipSet) (address.Address, error) {
-	return c.Internal.StateMinerWorker(ctx, m, ts)
+func (c *FullNodeStruct) StateMinerSectors(ctx context.Context, addr address.Address, sectorNos *bitfield.BitField, tsk types.TipSetKey) ([]*miner.SectorOnChainInfo, error) {
+	return c.Internal.StateMinerSectors(ctx, addr, sectorNos, tsk)
 }
 
-func (c *FullNodeStruct) StateMinerPeerID(ctx context.Context, m address.Address, ts *types.TipSet) (peer.ID, error) {
-	return c.Internal.StateMinerPeerID(ctx, m, ts)
+func (c *FullNodeStruct) StateMinerActiveSectors(ctx context.Context, addr address.Address, tsk types.TipSetKey) ([]*miner.SectorOnChainInfo, error) {
+	return c.Internal.StateMinerActiveSectors(ctx, addr, tsk)
 }
 
-func (c *FullNodeStruct) StateMinerElectionPeriodStart(ctx context.Context, actor address.Address, ts *types.TipSet) (uint64, error) {
-	return c.Internal.StateMinerElectionPeriodStart(ctx, actor, ts)
+func (c *FullNodeStruct) StateMinerProvingDeadline(ctx context.Context, addr address.Address, tsk types.TipSetKey) (*dline.Info, error) {
+	return c.Internal.StateMinerProvingDeadline(ctx, addr, tsk)
 }
 
-func (c *FullNodeStruct) StateMinerSectorSize(ctx context.Context, actor address.Address, ts *types.TipSet) (uint64, error) {
-	return c.Internal.StateMinerSectorSize(ctx, actor, ts)
+func (c *FullNodeStruct) StateMinerPower(ctx context.Context, a address.Address, tsk types.TipSetKey) (*api.MinerPower, error) {
+	return c.Internal.StateMinerPower(ctx, a, tsk)
 }
 
-func (c *FullNodeStruct) StateCall(ctx context.Context, msg *types.Message, ts *types.TipSet) (*types.MessageReceipt, error) {
-	return c.Internal.StateCall(ctx, msg, ts)
+func (c *FullNodeStruct) StateMinerInfo(ctx context.Context, actor address.Address, tsk types.TipSetKey) (miner.MinerInfo, error) {
+	return c.Internal.StateMinerInfo(ctx, actor, tsk)
 }
 
-func (c *FullNodeStruct) StateReplay(ctx context.Context, ts *types.TipSet, mc cid.Cid) (*api.ReplayResults, error) {
-	return c.Internal.StateReplay(ctx, ts, mc)
+func (c *FullNodeStruct) StateMinerDeadlines(ctx context.Context, actor address.Address, tsk types.TipSetKey) ([]api.Deadline, error) {
+	return c.Internal.StateMinerDeadlines(ctx, actor, tsk)
 }
 
-func (c *FullNodeStruct) StateGetActor(ctx context.Context, actor address.Address, ts *types.TipSet) (*types.Actor, error) {
-	return c.Internal.StateGetActor(ctx, actor, ts)
+func (c *FullNodeStruct) StateMinerPartitions(ctx context.Context, m address.Address, dlIdx uint64, tsk types.TipSetKey) ([]api.Partition, error) {
+	return c.Internal.StateMinerPartitions(ctx, m, dlIdx, tsk)
 }
 
-func (c *FullNodeStruct) StateReadState(ctx context.Context, act *types.Actor, ts *types.TipSet) (*api.ActorState, error) {
-	return c.Internal.StateReadState(ctx, act, ts)
+func (c *FullNodeStruct) StateMinerFaults(ctx context.Context, actor address.Address, tsk types.TipSetKey) (bitfield.BitField, error) {
+	return c.Internal.StateMinerFaults(ctx, actor, tsk)
 }
 
-func (c *FullNodeStruct) StatePledgeCollateral(ctx context.Context, ts *types.TipSet) (types.BigInt, error) {
-	return c.Internal.StatePledgeCollateral(ctx, ts)
+func (c *FullNodeStruct) StateAllMinerFaults(ctx context.Context, cutoff abi.ChainEpoch, endTsk types.TipSetKey) ([]*api.Fault, error) {
+	return c.Internal.StateAllMinerFaults(ctx, cutoff, endTsk)
 }
 
-func (c *FullNodeStruct) StateWaitMsg(ctx context.Context, msgc cid.Cid) (*api.MsgWait, error) {
-	return c.Internal.StateWaitMsg(ctx, msgc)
-}
-func (c *FullNodeStruct) StateListMiners(ctx context.Context, ts *types.TipSet) ([]address.Address, error) {
-	return c.Internal.StateListMiners(ctx, ts)
+func (c *FullNodeStruct) StateMinerRecoveries(ctx context.Context, actor address.Address, tsk types.TipSetKey) (bitfield.BitField, error) {
+	return c.Internal.StateMinerRecoveries(ctx, actor, tsk)
 }
 
-func (c *FullNodeStruct) StateListActors(ctx context.Context, ts *types.TipSet) ([]address.Address, error) {
-	return c.Internal.StateListActors(ctx, ts)
+func (c *FullNodeStruct) StateMinerPreCommitDepositForPower(ctx context.Context, maddr address.Address, pci miner.SectorPreCommitInfo, tsk types.TipSetKey) (types.BigInt, error) {
+	return c.Internal.StateMinerPreCommitDepositForPower(ctx, maddr, pci, tsk)
 }
 
-func (c *FullNodeStruct) StateMarketBalance(ctx context.Context, addr address.Address, ts *types.TipSet) (actors.StorageParticipantBalance, error) {
-	return c.Internal.StateMarketBalance(ctx, addr, ts)
+func (c *FullNodeStruct) StateMinerInitialPledgeCollateral(ctx context.Context, maddr address.Address, pci miner.SectorPreCommitInfo, tsk types.TipSetKey) (types.BigInt, error) {
+	return c.Internal.StateMinerInitialPledgeCollateral(ctx, maddr, pci, tsk)
 }
 
-func (c *FullNodeStruct) StateMarketParticipants(ctx context.Context, ts *types.TipSet) (map[string]actors.StorageParticipantBalance, error) {
-	return c.Internal.StateMarketParticipants(ctx, ts)
+func (c *FullNodeStruct) StateMinerAvailableBalance(ctx context.Context, maddr address.Address, tsk types.TipSetKey) (types.BigInt, error) {
+	return c.Internal.StateMinerAvailableBalance(ctx, maddr, tsk)
 }
 
-func (c *FullNodeStruct) StateMarketDeals(ctx context.Context, ts *types.TipSet) (map[string]actors.OnChainDeal, error) {
-	return c.Internal.StateMarketDeals(ctx, ts)
+func (c *FullNodeStruct) StateSectorPreCommitInfo(ctx context.Context, maddr address.Address, n abi.SectorNumber, tsk types.TipSetKey) (miner.SectorPreCommitOnChainInfo, error) {
+	return c.Internal.StateSectorPreCommitInfo(ctx, maddr, n, tsk)
 }
 
-func (c *FullNodeStruct) StateMarketStorageDeal(ctx context.Context, dealid uint64, ts *types.TipSet) (*actors.OnChainDeal, error) {
-	return c.Internal.StateMarketStorageDeal(ctx, dealid, ts)
+func (c *FullNodeStruct) StateSectorGetInfo(ctx context.Context, maddr address.Address, n abi.SectorNumber, tsk types.TipSetKey) (*miner.SectorOnChainInfo, error) {
+	return c.Internal.StateSectorGetInfo(ctx, maddr, n, tsk)
 }
 
-func (c *FullNodeStruct) StateLookupID(ctx context.Context, addr address.Address, ts *types.TipSet) (address.Address, error) {
-	return c.Internal.StateLookupID(ctx, addr, ts)
+func (c *FullNodeStruct) StateSectorExpiration(ctx context.Context, maddr address.Address, n abi.SectorNumber, tsk types.TipSetKey) (*miner.SectorExpiration, error) {
+	return c.Internal.StateSectorExpiration(ctx, maddr, n, tsk)
+}
+
+func (c *FullNodeStruct) StateSectorPartition(ctx context.Context, maddr address.Address, sectorNumber abi.SectorNumber, tok types.TipSetKey) (*miner.SectorLocation, error) {
+	return c.Internal.StateSectorPartition(ctx, maddr, sectorNumber, tok)
+}
+
+func (c *FullNodeStruct) StateCall(ctx context.Context, msg *types.Message, tsk types.TipSetKey) (*api.InvocResult, error) {
+	return c.Internal.StateCall(ctx, msg, tsk)
+}
+
+func (c *FullNodeStruct) StateReplay(ctx context.Context, tsk types.TipSetKey, mc cid.Cid) (*api.InvocResult, error) {
+	return c.Internal.StateReplay(ctx, tsk, mc)
+}
+
+func (c *FullNodeStruct) StateGetActor(ctx context.Context, actor address.Address, tsk types.TipSetKey) (*types.Actor, error) {
+	return c.Internal.StateGetActor(ctx, actor, tsk)
+}
+
+func (c *FullNodeStruct) StateReadState(ctx context.Context, addr address.Address, tsk types.TipSetKey) (*api.ActorState, error) {
+	return c.Internal.StateReadState(ctx, addr, tsk)
+}
+
+func (c *FullNodeStruct) StateMsgGasCost(ctx context.Context, msgc cid.Cid, tsk types.TipSetKey) (*api.MsgGasCost, error) {
+	return c.Internal.StateMsgGasCost(ctx, msgc, tsk)
+}
+
+func (c *FullNodeStruct) StateWaitMsg(ctx context.Context, msgc cid.Cid, confidence uint64) (*api.MsgLookup, error) {
+	return c.Internal.StateWaitMsg(ctx, msgc, confidence)
+}
+
+func (c *FullNodeStruct) StateSearchMsg(ctx context.Context, msgc cid.Cid) (*api.MsgLookup, error) {
+	return c.Internal.StateSearchMsg(ctx, msgc)
+}
+
+func (c *FullNodeStruct) StateListMiners(ctx context.Context, tsk types.TipSetKey) ([]address.Address, error) {
+	return c.Internal.StateListMiners(ctx, tsk)
+}
+
+func (c *FullNodeStruct) StateListActors(ctx context.Context, tsk types.TipSetKey) ([]address.Address, error) {
+	return c.Internal.StateListActors(ctx, tsk)
+}
+
+func (c *FullNodeStruct) StateMarketBalance(ctx context.Context, addr address.Address, tsk types.TipSetKey) (api.MarketBalance, error) {
+	return c.Internal.StateMarketBalance(ctx, addr, tsk)
+}
+
+func (c *FullNodeStruct) StateMarketParticipants(ctx context.Context, tsk types.TipSetKey) (map[string]api.MarketBalance, error) {
+	return c.Internal.StateMarketParticipants(ctx, tsk)
+}
+
+func (c *FullNodeStruct) StateMarketDeals(ctx context.Context, tsk types.TipSetKey) (map[string]api.MarketDeal, error) {
+	return c.Internal.StateMarketDeals(ctx, tsk)
+}
+
+func (c *FullNodeStruct) StateMarketStorageDeal(ctx context.Context, dealid abi.DealID, tsk types.TipSetKey) (*api.MarketDeal, error) {
+	return c.Internal.StateMarketStorageDeal(ctx, dealid, tsk)
+}
+
+func (c *FullNodeStruct) StateLookupID(ctx context.Context, addr address.Address, tsk types.TipSetKey) (address.Address, error) {
+	return c.Internal.StateLookupID(ctx, addr, tsk)
+}
+
+func (c *FullNodeStruct) StateAccountKey(ctx context.Context, addr address.Address, tsk types.TipSetKey) (address.Address, error) {
+	return c.Internal.StateAccountKey(ctx, addr, tsk)
 }
 
 func (c *FullNodeStruct) StateChangedActors(ctx context.Context, olnstate cid.Cid, newstate cid.Cid) (map[string]types.Actor, error) {
 	return c.Internal.StateChangedActors(ctx, olnstate, newstate)
 }
 
-func (c *FullNodeStruct) StateGetReceipt(ctx context.Context, msg cid.Cid, ts *types.TipSet) (*types.MessageReceipt, error) {
-	return c.Internal.StateGetReceipt(ctx, msg, ts)
+func (c *FullNodeStruct) StateGetReceipt(ctx context.Context, msg cid.Cid, tsk types.TipSetKey) (*types.MessageReceipt, error) {
+	return c.Internal.StateGetReceipt(ctx, msg, tsk)
 }
 
-func (c *FullNodeStruct) StateListMessages(ctx context.Context, match *types.Message, ts *types.TipSet, toht uint64) ([]cid.Cid, error) {
-	return c.Internal.StateListMessages(ctx, match, ts, toht)
+func (c *FullNodeStruct) StateListMessages(ctx context.Context, match *types.Message, tsk types.TipSetKey, toht abi.ChainEpoch) ([]cid.Cid, error) {
+	return c.Internal.StateListMessages(ctx, match, tsk, toht)
 }
 
-func (c *FullNodeStruct) MarketEnsureAvailable(ctx context.Context, addr address.Address, amt types.BigInt) error {
-	return c.Internal.MarketEnsureAvailable(ctx, addr, amt)
+func (c *FullNodeStruct) StateCompute(ctx context.Context, height abi.ChainEpoch, msgs []*types.Message, tsk types.TipSetKey) (*api.ComputeStateOutput, error) {
+	return c.Internal.StateCompute(ctx, height, msgs, tsk)
 }
 
-func (c *FullNodeStruct) PaychGet(ctx context.Context, from, to address.Address, ensureFunds types.BigInt) (*api.ChannelInfo, error) {
-	return c.Internal.PaychGet(ctx, from, to, ensureFunds)
+func (c *FullNodeStruct) StateVerifiedClientStatus(ctx context.Context, addr address.Address, tsk types.TipSetKey) (*abi.StoragePower, error) {
+	return c.Internal.StateVerifiedClientStatus(ctx, addr, tsk)
+}
+
+func (c *FullNodeStruct) StateDealProviderCollateralBounds(ctx context.Context, size abi.PaddedPieceSize, verified bool, tsk types.TipSetKey) (api.DealCollateralBounds, error) {
+	return c.Internal.StateDealProviderCollateralBounds(ctx, size, verified, tsk)
+}
+
+func (c *FullNodeStruct) StateCirculatingSupply(ctx context.Context, tsk types.TipSetKey) (api.CirculatingSupply, error) {
+	return c.Internal.StateCirculatingSupply(ctx, tsk)
+}
+
+func (c *FullNodeStruct) StateNetworkVersion(ctx context.Context, tsk types.TipSetKey) (stnetwork.Version, error) {
+	return c.Internal.StateNetworkVersion(ctx, tsk)
+}
+
+func (c *FullNodeStruct) MsigGetAvailableBalance(ctx context.Context, a address.Address, tsk types.TipSetKey) (types.BigInt, error) {
+	return c.Internal.MsigGetAvailableBalance(ctx, a, tsk)
+}
+
+func (c *FullNodeStruct) MsigGetVested(ctx context.Context, a address.Address, sTsk types.TipSetKey, eTsk types.TipSetKey) (types.BigInt, error) {
+	return c.Internal.MsigGetVested(ctx, a, sTsk, eTsk)
+}
+
+func (c *FullNodeStruct) MsigCreate(ctx context.Context, req uint64, addrs []address.Address, duration abi.ChainEpoch, val types.BigInt, src address.Address, gp types.BigInt) (cid.Cid, error) {
+	return c.Internal.MsigCreate(ctx, req, addrs, duration, val, src, gp)
+}
+
+func (c *FullNodeStruct) MsigPropose(ctx context.Context, msig address.Address, to address.Address, amt types.BigInt, src address.Address, method uint64, params []byte) (cid.Cid, error) {
+	return c.Internal.MsigPropose(ctx, msig, to, amt, src, method, params)
+}
+
+func (c *FullNodeStruct) MsigApprove(ctx context.Context, msig address.Address, txID uint64, proposer address.Address, to address.Address, amt types.BigInt, src address.Address, method uint64, params []byte) (cid.Cid, error) {
+	return c.Internal.MsigApprove(ctx, msig, txID, proposer, to, amt, src, method, params)
+}
+
+func (c *FullNodeStruct) MsigCancel(ctx context.Context, msig address.Address, txID uint64, to address.Address, amt types.BigInt, src address.Address, method uint64, params []byte) (cid.Cid, error) {
+	return c.Internal.MsigCancel(ctx, msig, txID, to, amt, src, method, params)
+}
+
+func (c *FullNodeStruct) MsigAddPropose(ctx context.Context, msig address.Address, src address.Address, newAdd address.Address, inc bool) (cid.Cid, error) {
+	return c.Internal.MsigAddPropose(ctx, msig, src, newAdd, inc)
+}
+
+func (c *FullNodeStruct) MsigAddApprove(ctx context.Context, msig address.Address, src address.Address, txID uint64, proposer address.Address, newAdd address.Address, inc bool) (cid.Cid, error) {
+	return c.Internal.MsigAddApprove(ctx, msig, src, txID, proposer, newAdd, inc)
+}
+
+func (c *FullNodeStruct) MsigAddCancel(ctx context.Context, msig address.Address, src address.Address, txID uint64, newAdd address.Address, inc bool) (cid.Cid, error) {
+	return c.Internal.MsigAddCancel(ctx, msig, src, txID, newAdd, inc)
+}
+
+func (c *FullNodeStruct) MsigSwapPropose(ctx context.Context, msig address.Address, src address.Address, oldAdd address.Address, newAdd address.Address) (cid.Cid, error) {
+	return c.Internal.MsigSwapPropose(ctx, msig, src, oldAdd, newAdd)
+}
+
+func (c *FullNodeStruct) MsigSwapApprove(ctx context.Context, msig address.Address, src address.Address, txID uint64, proposer address.Address, oldAdd address.Address, newAdd address.Address) (cid.Cid, error) {
+	return c.Internal.MsigSwapApprove(ctx, msig, src, txID, proposer, oldAdd, newAdd)
+}
+
+func (c *FullNodeStruct) MsigSwapCancel(ctx context.Context, msig address.Address, src address.Address, txID uint64, oldAdd address.Address, newAdd address.Address) (cid.Cid, error) {
+	return c.Internal.MsigSwapCancel(ctx, msig, src, txID, oldAdd, newAdd)
+}
+
+func (c *FullNodeStruct) MarketEnsureAvailable(ctx context.Context, addr, wallet address.Address, amt types.BigInt) (cid.Cid, error) {
+	return c.Internal.MarketEnsureAvailable(ctx, addr, wallet, amt)
+}
+
+func (c *FullNodeStruct) PaychGet(ctx context.Context, from, to address.Address, amt types.BigInt) (*api.ChannelInfo, error) {
+	return c.Internal.PaychGet(ctx, from, to, amt)
+}
+
+func (c *FullNodeStruct) PaychGetWaitReady(ctx context.Context, sentinel cid.Cid) (address.Address, error) {
+	return c.Internal.PaychGetWaitReady(ctx, sentinel)
+}
+
+func (c *FullNodeStruct) PaychAvailableFunds(ctx context.Context, ch address.Address) (*api.ChannelAvailableFunds, error) {
+	return c.Internal.PaychAvailableFunds(ctx, ch)
+}
+
+func (c *FullNodeStruct) PaychAvailableFundsByFromTo(ctx context.Context, from, to address.Address) (*api.ChannelAvailableFunds, error) {
+	return c.Internal.PaychAvailableFundsByFromTo(ctx, from, to)
 }
 
 func (c *FullNodeStruct) PaychList(ctx context.Context) ([]address.Address, error) {
@@ -478,28 +975,32 @@ func (c *FullNodeStruct) PaychStatus(ctx context.Context, pch address.Address) (
 	return c.Internal.PaychStatus(ctx, pch)
 }
 
-func (c *FullNodeStruct) PaychVoucherCheckValid(ctx context.Context, addr address.Address, sv *types.SignedVoucher) error {
+func (c *FullNodeStruct) PaychVoucherCheckValid(ctx context.Context, addr address.Address, sv *paych.SignedVoucher) error {
 	return c.Internal.PaychVoucherCheckValid(ctx, addr, sv)
 }
 
-func (c *FullNodeStruct) PaychVoucherCheckSpendable(ctx context.Context, addr address.Address, sv *types.SignedVoucher, secret []byte, proof []byte) (bool, error) {
+func (c *FullNodeStruct) PaychVoucherCheckSpendable(ctx context.Context, addr address.Address, sv *paych.SignedVoucher, secret []byte, proof []byte) (bool, error) {
 	return c.Internal.PaychVoucherCheckSpendable(ctx, addr, sv, secret, proof)
 }
 
-func (c *FullNodeStruct) PaychVoucherAdd(ctx context.Context, addr address.Address, sv *types.SignedVoucher, proof []byte, minDelta types.BigInt) (types.BigInt, error) {
+func (c *FullNodeStruct) PaychVoucherAdd(ctx context.Context, addr address.Address, sv *paych.SignedVoucher, proof []byte, minDelta types.BigInt) (types.BigInt, error) {
 	return c.Internal.PaychVoucherAdd(ctx, addr, sv, proof, minDelta)
 }
 
-func (c *FullNodeStruct) PaychVoucherCreate(ctx context.Context, pch address.Address, amt types.BigInt, lane uint64) (*types.SignedVoucher, error) {
+func (c *FullNodeStruct) PaychVoucherCreate(ctx context.Context, pch address.Address, amt types.BigInt, lane uint64) (*api.VoucherCreateResult, error) {
 	return c.Internal.PaychVoucherCreate(ctx, pch, amt, lane)
 }
 
-func (c *FullNodeStruct) PaychVoucherList(ctx context.Context, pch address.Address) ([]*types.SignedVoucher, error) {
+func (c *FullNodeStruct) PaychVoucherList(ctx context.Context, pch address.Address) ([]*paych.SignedVoucher, error) {
 	return c.Internal.PaychVoucherList(ctx, pch)
 }
 
-func (c *FullNodeStruct) PaychClose(ctx context.Context, a address.Address) (cid.Cid, error) {
-	return c.Internal.PaychClose(ctx, a)
+func (c *FullNodeStruct) PaychSettle(ctx context.Context, a address.Address) (cid.Cid, error) {
+	return c.Internal.PaychSettle(ctx, a)
+}
+
+func (c *FullNodeStruct) PaychCollect(ctx context.Context, a address.Address) (cid.Cid, error) {
+	return c.Internal.PaychCollect(ctx, a)
 }
 
 func (c *FullNodeStruct) PaychAllocateLane(ctx context.Context, ch address.Address) (uint64, error) {
@@ -510,15 +1011,21 @@ func (c *FullNodeStruct) PaychNewPayment(ctx context.Context, from, to address.A
 	return c.Internal.PaychNewPayment(ctx, from, to, vouchers)
 }
 
-func (c *FullNodeStruct) PaychVoucherSubmit(ctx context.Context, ch address.Address, sv *types.SignedVoucher) (cid.Cid, error) {
-	return c.Internal.PaychVoucherSubmit(ctx, ch, sv)
+func (c *FullNodeStruct) PaychVoucherSubmit(ctx context.Context, ch address.Address, sv *paych.SignedVoucher, secret []byte, proof []byte) (cid.Cid, error) {
+	return c.Internal.PaychVoucherSubmit(ctx, ch, sv, secret, proof)
 }
 
+// StorageMinerStruct
+
 func (c *StorageMinerStruct) ActorAddress(ctx context.Context) (address.Address, error) {
 	return c.Internal.ActorAddress(ctx)
 }
 
-func (c *StorageMinerStruct) ActorSectorSize(ctx context.Context, addr address.Address) (uint64, error) {
+func (c *StorageMinerStruct) MiningBase(ctx context.Context) (*types.TipSet, error) {
+	return c.Internal.MiningBase(ctx)
+}
+
+func (c *StorageMinerStruct) ActorSectorSize(ctx context.Context, addr address.Address) (abi.SectorSize, error) {
 	return c.Internal.ActorSectorSize(ctx, addr)
 }
 
@@ -527,12 +1034,12 @@ func (c *StorageMinerStruct) PledgeSector(ctx context.Context) error {
 }
 
 // Get the status of a given sector by ID
-func (c *StorageMinerStruct) SectorsStatus(ctx context.Context, sid uint64) (api.SectorInfo, error) {
-	return c.Internal.SectorsStatus(ctx, sid)
+func (c *StorageMinerStruct) SectorsStatus(ctx context.Context, sid abi.SectorNumber, showOnChainInfo bool) (api.SectorInfo, error) {
+	return c.Internal.SectorsStatus(ctx, sid, showOnChainInfo)
 }
 
 // List all staged sectors
-func (c *StorageMinerStruct) SectorsList(ctx context.Context) ([]uint64, error) {
+func (c *StorageMinerStruct) SectorsList(ctx context.Context) ([]abi.SectorNumber, error) {
 	return c.Internal.SectorsList(ctx)
 }
 
@@ -540,22 +1047,289 @@ func (c *StorageMinerStruct) SectorsRefs(ctx context.Context) (map[string][]api.
 	return c.Internal.SectorsRefs(ctx)
 }
 
-func (c *StorageMinerStruct) SectorsUpdate(ctx context.Context, id uint64, state api.SectorState) error {
+func (c *StorageMinerStruct) SectorStartSealing(ctx context.Context, number abi.SectorNumber) error {
+	return c.Internal.SectorStartSealing(ctx, number)
+}
+
+func (c *StorageMinerStruct) SectorSetSealDelay(ctx context.Context, delay time.Duration) error {
+	return c.Internal.SectorSetSealDelay(ctx, delay)
+}
+
+func (c *StorageMinerStruct) SectorGetSealDelay(ctx context.Context) (time.Duration, error) {
+	return c.Internal.SectorGetSealDelay(ctx)
+}
+
+func (c *StorageMinerStruct) SectorSetExpectedSealDuration(ctx context.Context, delay time.Duration) error {
+	return c.Internal.SectorSetExpectedSealDuration(ctx, delay)
+}
+
+func (c *StorageMinerStruct) SectorGetExpectedSealDuration(ctx context.Context) (time.Duration, error) {
+	return c.Internal.SectorGetExpectedSealDuration(ctx)
+}
+
+func (c *StorageMinerStruct) SectorsUpdate(ctx context.Context, id abi.SectorNumber, state api.SectorState) error {
 	return c.Internal.SectorsUpdate(ctx, id, state)
 }
 
-func (c *StorageMinerStruct) WorkerStats(ctx context.Context) (sectorbuilder.WorkerStats, error) {
+func (c *StorageMinerStruct) SectorRemove(ctx context.Context, number abi.SectorNumber) error {
+	return c.Internal.SectorRemove(ctx, number)
+}
+
+func (c *StorageMinerStruct) SectorMarkForUpgrade(ctx context.Context, number abi.SectorNumber) error {
+	return c.Internal.SectorMarkForUpgrade(ctx, number)
+}
+
+func (c *StorageMinerStruct) WorkerConnect(ctx context.Context, url string) error {
+	return c.Internal.WorkerConnect(ctx, url)
+}
+
+func (c *StorageMinerStruct) WorkerStats(ctx context.Context) (map[uint64]storiface.WorkerStats, error) {
 	return c.Internal.WorkerStats(ctx)
 }
 
-func (c *StorageMinerStruct) WorkerQueue(ctx context.Context, cfg sectorbuilder.WorkerCfg) (<-chan sectorbuilder.WorkerTask, error) {
-	return c.Internal.WorkerQueue(ctx, cfg)
+func (c *StorageMinerStruct) WorkerJobs(ctx context.Context) (map[uint64][]storiface.WorkerJob, error) {
+	return c.Internal.WorkerJobs(ctx)
 }
 
-func (c *StorageMinerStruct) WorkerDone(ctx context.Context, task uint64, res sectorbuilder.SealRes) error {
-	return c.Internal.WorkerDone(ctx, task, res)
+func (c *StorageMinerStruct) SealingSchedDiag(ctx context.Context) (interface{}, error) {
+	return c.Internal.SealingSchedDiag(ctx)
+}
+
+func (c *StorageMinerStruct) StorageAttach(ctx context.Context, si stores.StorageInfo, st fsutil.FsStat) error {
+	return c.Internal.StorageAttach(ctx, si, st)
+}
+
+func (c *StorageMinerStruct) StorageDeclareSector(ctx context.Context, storageId stores.ID, s abi.SectorID, ft stores.SectorFileType, primary bool) error {
+	return c.Internal.StorageDeclareSector(ctx, storageId, s, ft, primary)
+}
+
+func (c *StorageMinerStruct) StorageDropSector(ctx context.Context, storageId stores.ID, s abi.SectorID, ft stores.SectorFileType) error {
+	return c.Internal.StorageDropSector(ctx, storageId, s, ft)
+}
+
+func (c *StorageMinerStruct) StorageFindSector(ctx context.Context, si abi.SectorID, types stores.SectorFileType, spt abi.RegisteredSealProof, allowFetch bool) ([]stores.SectorStorageInfo, error) {
+	return c.Internal.StorageFindSector(ctx, si, types, spt, allowFetch)
+}
+
+func (c *StorageMinerStruct) StorageList(ctx context.Context) (map[stores.ID][]stores.Decl, error) {
+	return c.Internal.StorageList(ctx)
+}
+
+func (c *StorageMinerStruct) StorageLocal(ctx context.Context) (map[stores.ID]string, error) {
+	return c.Internal.StorageLocal(ctx)
+}
+
+func (c *StorageMinerStruct) StorageStat(ctx context.Context, id stores.ID) (fsutil.FsStat, error) {
+	return c.Internal.StorageStat(ctx, id)
+}
+
+func (c *StorageMinerStruct) StorageInfo(ctx context.Context, id stores.ID) (stores.StorageInfo, error) {
+	return c.Internal.StorageInfo(ctx, id)
+}
+
+func (c *StorageMinerStruct) StorageBestAlloc(ctx context.Context, allocate stores.SectorFileType, spt abi.RegisteredSealProof, pt stores.PathType) ([]stores.StorageInfo, error) {
+	return c.Internal.StorageBestAlloc(ctx, allocate, spt, pt)
+}
+
+func (c *StorageMinerStruct) StorageReportHealth(ctx context.Context, id stores.ID, report stores.HealthReport) error {
+	return c.Internal.StorageReportHealth(ctx, id, report)
+}
+
+func (c *StorageMinerStruct) StorageLock(ctx context.Context, sector abi.SectorID, read stores.SectorFileType, write stores.SectorFileType) error {
+	return c.Internal.StorageLock(ctx, sector, read, write)
+}
+
+func (c *StorageMinerStruct) StorageTryLock(ctx context.Context, sector abi.SectorID, read stores.SectorFileType, write stores.SectorFileType) (bool, error) {
+	return c.Internal.StorageTryLock(ctx, sector, read, write)
+}
+
+func (c *StorageMinerStruct) MarketImportDealData(ctx context.Context, propcid cid.Cid, path string) error {
+	return c.Internal.MarketImportDealData(ctx, propcid, path)
+}
+
+func (c *StorageMinerStruct) MarketListDeals(ctx context.Context) ([]api.MarketDeal, error) {
+	return c.Internal.MarketListDeals(ctx)
+}
+
+func (c *StorageMinerStruct) MarketListRetrievalDeals(ctx context.Context) ([]retrievalmarket.ProviderDealState, error) {
+	return c.Internal.MarketListRetrievalDeals(ctx)
+}
+
+func (c *StorageMinerStruct) MarketGetDealUpdates(ctx context.Context) (<-chan storagemarket.MinerDeal, error) {
+	return c.Internal.MarketGetDealUpdates(ctx)
+}
+
+func (c *StorageMinerStruct) MarketListIncompleteDeals(ctx context.Context) ([]storagemarket.MinerDeal, error) {
+	return c.Internal.MarketListIncompleteDeals(ctx)
+}
+
+func (c *StorageMinerStruct) MarketSetAsk(ctx context.Context, price types.BigInt, verifiedPrice types.BigInt, duration abi.ChainEpoch, minPieceSize abi.PaddedPieceSize, maxPieceSize abi.PaddedPieceSize) error {
+	return c.Internal.MarketSetAsk(ctx, price, verifiedPrice, duration, minPieceSize, maxPieceSize)
+}
+
+func (c *StorageMinerStruct) MarketGetAsk(ctx context.Context) (*storagemarket.SignedStorageAsk, error) {
+	return c.Internal.MarketGetAsk(ctx)
+}
+
+func (c *StorageMinerStruct) MarketSetRetrievalAsk(ctx context.Context, rask *retrievalmarket.Ask) error {
+	return c.Internal.MarketSetRetrievalAsk(ctx, rask)
+}
+
+func (c *StorageMinerStruct) MarketGetRetrievalAsk(ctx context.Context) (*retrievalmarket.Ask, error) {
+	return c.Internal.MarketGetRetrievalAsk(ctx)
+}
+
+func (c *StorageMinerStruct) MarketListDataTransfers(ctx context.Context) ([]api.DataTransferChannel, error) {
+	return c.Internal.MarketListDataTransfers(ctx)
+}
+
+func (c *StorageMinerStruct) MarketDataTransferUpdates(ctx context.Context) (<-chan api.DataTransferChannel, error) {
+	return c.Internal.MarketDataTransferUpdates(ctx)
+}
+
+func (c *StorageMinerStruct) DealsImportData(ctx context.Context, dealPropCid cid.Cid, file string) error {
+	return c.Internal.DealsImportData(ctx, dealPropCid, file)
+}
+
+func (c *StorageMinerStruct) DealsList(ctx context.Context) ([]api.MarketDeal, error) {
+	return c.Internal.DealsList(ctx)
+}
+
+func (c *StorageMinerStruct) DealsConsiderOnlineStorageDeals(ctx context.Context) (bool, error) {
+	return c.Internal.DealsConsiderOnlineStorageDeals(ctx)
+}
+
+func (c *StorageMinerStruct) DealsSetConsiderOnlineStorageDeals(ctx context.Context, b bool) error {
+	return c.Internal.DealsSetConsiderOnlineStorageDeals(ctx, b)
+}
+
+func (c *StorageMinerStruct) DealsConsiderOnlineRetrievalDeals(ctx context.Context) (bool, error) {
+	return c.Internal.DealsConsiderOnlineRetrievalDeals(ctx)
+}
+
+func (c *StorageMinerStruct) DealsSetConsiderOnlineRetrievalDeals(ctx context.Context, b bool) error {
+	return c.Internal.DealsSetConsiderOnlineRetrievalDeals(ctx, b)
+}
+
+func (c *StorageMinerStruct) DealsPieceCidBlocklist(ctx context.Context) ([]cid.Cid, error) {
+	return c.Internal.DealsPieceCidBlocklist(ctx)
+}
+
+func (c *StorageMinerStruct) DealsSetPieceCidBlocklist(ctx context.Context, cids []cid.Cid) error {
+	return c.Internal.DealsSetPieceCidBlocklist(ctx, cids)
+}
+
+func (c *StorageMinerStruct) DealsConsiderOfflineStorageDeals(ctx context.Context) (bool, error) {
+	return c.Internal.DealsConsiderOfflineStorageDeals(ctx)
+}
+
+func (c *StorageMinerStruct) DealsSetConsiderOfflineStorageDeals(ctx context.Context, b bool) error {
+	return c.Internal.DealsSetConsiderOfflineStorageDeals(ctx, b)
+}
+
+func (c *StorageMinerStruct) DealsConsiderOfflineRetrievalDeals(ctx context.Context) (bool, error) {
+	return c.Internal.DealsConsiderOfflineRetrievalDeals(ctx)
+}
+
+func (c *StorageMinerStruct) DealsSetConsiderOfflineRetrievalDeals(ctx context.Context, b bool) error {
+	return c.Internal.DealsSetConsiderOfflineRetrievalDeals(ctx, b)
+}
+
+func (c *StorageMinerStruct) StorageAddLocal(ctx context.Context, path string) error {
+	return c.Internal.StorageAddLocal(ctx, path)
+}
+
+func (c *StorageMinerStruct) PiecesListPieces(ctx context.Context) ([]cid.Cid, error) {
+	return c.Internal.PiecesListPieces(ctx)
+}
+
+func (c *StorageMinerStruct) PiecesListCidInfos(ctx context.Context) ([]cid.Cid, error) {
+	return c.Internal.PiecesListCidInfos(ctx)
+}
+
+func (c *StorageMinerStruct) PiecesGetPieceInfo(ctx context.Context, pieceCid cid.Cid) (*piecestore.PieceInfo, error) {
+	return c.Internal.PiecesGetPieceInfo(ctx, pieceCid)
+}
+
+func (c *StorageMinerStruct) PiecesGetCIDInfo(ctx context.Context, payloadCid cid.Cid) (*piecestore.CIDInfo, error) {
+	return c.Internal.PiecesGetCIDInfo(ctx, payloadCid)
+}
+
+// WorkerStruct
+
+func (w *WorkerStruct) Version(ctx context.Context) (build.Version, error) {
+	return w.Internal.Version(ctx)
+}
+
+func (w *WorkerStruct) TaskTypes(ctx context.Context) (map[sealtasks.TaskType]struct{}, error) {
+	return w.Internal.TaskTypes(ctx)
+}
+
+func (w *WorkerStruct) Paths(ctx context.Context) ([]stores.StoragePath, error) {
+	return w.Internal.Paths(ctx)
+}
+
+func (w *WorkerStruct) Info(ctx context.Context) (storiface.WorkerInfo, error) {
+	return w.Internal.Info(ctx)
+}
+
+func (w *WorkerStruct) AddPiece(ctx context.Context, sector abi.SectorID, pieceSizes []abi.UnpaddedPieceSize, newPieceSize abi.UnpaddedPieceSize, pieceData storage.Data) (abi.PieceInfo, error) {
+	return w.Internal.AddPiece(ctx, sector, pieceSizes, newPieceSize, pieceData)
+}
+
+func (w *WorkerStruct) SealPreCommit1(ctx context.Context, sector abi.SectorID, ticket abi.SealRandomness, pieces []abi.PieceInfo) (storage.PreCommit1Out, error) {
+	return w.Internal.SealPreCommit1(ctx, sector, ticket, pieces)
+}
+
+func (w *WorkerStruct) SealPreCommit2(ctx context.Context, sector abi.SectorID, p1o storage.PreCommit1Out) (storage.SectorCids, error) {
+	return w.Internal.SealPreCommit2(ctx, sector, p1o)
+}
+
+func (w *WorkerStruct) SealCommit1(ctx context.Context, sector abi.SectorID, ticket abi.SealRandomness, seed abi.InteractiveSealRandomness, pieces []abi.PieceInfo, cids storage.SectorCids) (storage.Commit1Out, error) {
+	return w.Internal.SealCommit1(ctx, sector, ticket, seed, pieces, cids)
+}
+
+func (w *WorkerStruct) SealCommit2(ctx context.Context, sector abi.SectorID, c1o storage.Commit1Out) (storage.Proof, error) {
+	return w.Internal.SealCommit2(ctx, sector, c1o)
+}
+
+func (w *WorkerStruct) FinalizeSector(ctx context.Context, sector abi.SectorID, keepUnsealed []storage.Range) error {
+	return w.Internal.FinalizeSector(ctx, sector, keepUnsealed)
+}
+
+func (w *WorkerStruct) ReleaseUnsealed(ctx context.Context, sector abi.SectorID, safeToFree []storage.Range) error {
+	return w.Internal.ReleaseUnsealed(ctx, sector, safeToFree)
+}
+
+func (w *WorkerStruct) Remove(ctx context.Context, sector abi.SectorID) error {
+	return w.Internal.Remove(ctx, sector)
+}
+
+func (w *WorkerStruct) MoveStorage(ctx context.Context, sector abi.SectorID, types stores.SectorFileType) error {
+	return w.Internal.MoveStorage(ctx, sector, types)
+}
+
+func (w *WorkerStruct) StorageAddLocal(ctx context.Context, path string) error {
+	return w.Internal.StorageAddLocal(ctx, path)
+}
+
+func (w *WorkerStruct) UnsealPiece(ctx context.Context, id abi.SectorID, index storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize, randomness abi.SealRandomness, c cid.Cid) error {
+	return w.Internal.UnsealPiece(ctx, id, index, size, randomness, c)
+}
+
+func (w *WorkerStruct) ReadPiece(ctx context.Context, writer io.Writer, id abi.SectorID, index storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize) (bool, error) {
+	return w.Internal.ReadPiece(ctx, writer, id, index, size)
+}
+
+func (w *WorkerStruct) Fetch(ctx context.Context, id abi.SectorID, fileType stores.SectorFileType, ptype stores.PathType, am stores.AcquireMode) error {
+	return w.Internal.Fetch(ctx, id, fileType, ptype, am)
+}
+
+func (w *WorkerStruct) Closing(ctx context.Context) (<-chan struct{}, error) {
+	return w.Internal.Closing(ctx)
 }
 
 var _ api.Common = &CommonStruct{}
 var _ api.FullNode = &FullNodeStruct{}
 var _ api.StorageMiner = &StorageMinerStruct{}
+var _ api.WorkerAPI = &WorkerStruct{}
diff --git a/api/apistruct/struct_test.go b/api/apistruct/struct_test.go
new file mode 100644
index 000000000..9f5f58360
--- /dev/null
+++ b/api/apistruct/struct_test.go
@@ -0,0 +1,9 @@
+package apistruct
+
+import "testing"
+
+func TestPermTags(t *testing.T) {
+	_ = PermissionedFullAPI(&FullNodeStruct{})
+	_ = PermissionedStorMinerAPI(&StorageMinerStruct{})
+	_ = PermissionedWorkerAPI(&WorkerStruct{})
+}
diff --git a/api/cbor_gen.go b/api/cbor_gen.go
index 8d309a6cc..7ab575b28 100644
--- a/api/cbor_gen.go
+++ b/api/cbor_gen.go
@@ -1,16 +1,17 @@
+// Code generated by github.com/whyrusleeping/cbor-gen. DO NOT EDIT.
+
 package api
 
 import (
 	"fmt"
 	"io"
 
-	"github.com/filecoin-project/lotus/chain/types"
+	abi "github.com/filecoin-project/go-state-types/abi"
+	paych "github.com/filecoin-project/specs-actors/actors/builtin/paych"
 	cbg "github.com/whyrusleeping/cbor-gen"
 	xerrors "golang.org/x/xerrors"
 )
 
-// Code generated by github.com/whyrusleeping/cbor-gen. DO NOT EDIT.
-
 var _ = xerrors.Errorf
 
 func (t *PaymentInfo) MarshalCBOR(w io.Writer) error {
@@ -22,11 +23,17 @@ func (t *PaymentInfo) MarshalCBOR(w io.Writer) error {
 		return err
 	}
 
+	scratch := make([]byte, 9)
+
 	// t.Channel (address.Address) (struct)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len("Channel")))); err != nil {
+	if len("Channel") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"Channel\" was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("Channel"))); err != nil {
 		return err
 	}
-	if _, err := w.Write([]byte("Channel")); err != nil {
+	if _, err := io.WriteString(w, string("Channel")); err != nil {
 		return err
 	}
 
@@ -34,33 +41,39 @@ func (t *PaymentInfo) MarshalCBOR(w io.Writer) error {
 		return err
 	}
 
-	// t.ChannelMessage (cid.Cid) (struct)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len("ChannelMessage")))); err != nil {
+	// t.WaitSentinel (cid.Cid) (struct)
+	if len("WaitSentinel") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"WaitSentinel\" was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("WaitSentinel"))); err != nil {
 		return err
 	}
-	if _, err := w.Write([]byte("ChannelMessage")); err != nil {
+	if _, err := io.WriteString(w, string("WaitSentinel")); err != nil {
 		return err
 	}
 
-	if t.ChannelMessage == nil {
-		if _, err := w.Write(cbg.CborNull); err != nil {
-			return err
-		}
-	} else {
-		if err := cbg.WriteCid(w, *t.ChannelMessage); err != nil {
-			return xerrors.Errorf("failed to write cid field t.ChannelMessage: %w", err)
-		}
+	if err := cbg.WriteCidBuf(scratch, w, t.WaitSentinel); err != nil {
+		return xerrors.Errorf("failed to write cid field t.WaitSentinel: %w", err)
 	}
 
-	// t.Vouchers ([]*types.SignedVoucher) (slice)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len("Vouchers")))); err != nil {
+	// t.Vouchers ([]*paych.SignedVoucher) (slice)
+	if len("Vouchers") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"Vouchers\" was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("Vouchers"))); err != nil {
 		return err
 	}
-	if _, err := w.Write([]byte("Vouchers")); err != nil {
+	if _, err := io.WriteString(w, string("Vouchers")); err != nil {
 		return err
 	}
 
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajArray, uint64(len(t.Vouchers)))); err != nil {
+	if len(t.Vouchers) > cbg.MaxLength {
+		return xerrors.Errorf("Slice value in field t.Vouchers was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajArray, uint64(len(t.Vouchers))); err != nil {
 		return err
 	}
 	for _, v := range t.Vouchers {
@@ -72,9 +85,12 @@ func (t *PaymentInfo) MarshalCBOR(w io.Writer) error {
 }
 
 func (t *PaymentInfo) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
+	*t = PaymentInfo{}
 
-	maj, extra, err := cbg.CborReadHeader(br)
+	br := cbg.GetPeeker(r)
+	scratch := make([]byte, 8)
+
+	maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
 	if err != nil {
 		return err
 	}
@@ -82,114 +98,85 @@ func (t *PaymentInfo) UnmarshalCBOR(r io.Reader) error {
 		return fmt.Errorf("cbor input should be of type map")
 	}
 
-	if extra != 3 {
-		return fmt.Errorf("cbor input had wrong number of fields")
+	if extra > cbg.MaxLength {
+		return fmt.Errorf("PaymentInfo: map struct too large (%d)", extra)
 	}
 
 	var name string
+	n := extra
 
-	// t.Channel (address.Address) (struct)
+	for i := uint64(0); i < n; i++ {
 
-	{
-		sval, err := cbg.ReadString(br)
-		if err != nil {
-			return err
-		}
-
-		name = string(sval)
-	}
-
-	if name != "Channel" {
-		return fmt.Errorf("expected struct map entry %s to be Channel", name)
-	}
-
-	{
-
-		if err := t.Channel.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-	}
-	// t.ChannelMessage (cid.Cid) (struct)
-
-	{
-		sval, err := cbg.ReadString(br)
-		if err != nil {
-			return err
-		}
-
-		name = string(sval)
-	}
-
-	if name != "ChannelMessage" {
-		return fmt.Errorf("expected struct map entry %s to be ChannelMessage", name)
-	}
-
-	{
-
-		pb, err := br.PeekByte()
-		if err != nil {
-			return err
-		}
-		if pb == cbg.CborNull[0] {
-			var nbuf [1]byte
-			if _, err := br.Read(nbuf[:]); err != nil {
+		{
+			sval, err := cbg.ReadStringBuf(br, scratch)
+			if err != nil {
 				return err
 			}
-		} else {
 
-			c, err := cbg.ReadCid(br)
+			name = string(sval)
+		}
+
+		switch name {
+		// t.Channel (address.Address) (struct)
+		case "Channel":
+
+			{
+
+				if err := t.Channel.UnmarshalCBOR(br); err != nil {
+					return xerrors.Errorf("unmarshaling t.Channel: %w", err)
+				}
+
+			}
+			// t.WaitSentinel (cid.Cid) (struct)
+		case "WaitSentinel":
+
+			{
+
+				c, err := cbg.ReadCid(br)
+				if err != nil {
+					return xerrors.Errorf("failed to read cid field t.WaitSentinel: %w", err)
+				}
+
+				t.WaitSentinel = c
+
+			}
+			// t.Vouchers ([]*paych.SignedVoucher) (slice)
+		case "Vouchers":
+
+			maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
 			if err != nil {
-				return xerrors.Errorf("failed to read cid field t.ChannelMessage: %w", err)
+				return err
 			}
 
-			t.ChannelMessage = &c
+			if extra > cbg.MaxLength {
+				return fmt.Errorf("t.Vouchers: array too large (%d)", extra)
+			}
+
+			if maj != cbg.MajArray {
+				return fmt.Errorf("expected cbor array")
+			}
+
+			if extra > 0 {
+				t.Vouchers = make([]*paych.SignedVoucher, extra)
+			}
+
+			for i := 0; i < int(extra); i++ {
+
+				var v paych.SignedVoucher
+				if err := v.UnmarshalCBOR(br); err != nil {
+					return err
+				}
+
+				t.Vouchers[i] = &v
+			}
+
+		default:
+			return fmt.Errorf("unknown struct field %d: '%s'", i, name)
 		}
-
-	}
-	// t.Vouchers ([]*types.SignedVoucher) (slice)
-
-	{
-		sval, err := cbg.ReadString(br)
-		if err != nil {
-			return err
-		}
-
-		name = string(sval)
-	}
-
-	if name != "Vouchers" {
-		return fmt.Errorf("expected struct map entry %s to be Vouchers", name)
-	}
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-
-	if extra > cbg.MaxLength {
-		return fmt.Errorf("t.Vouchers: array too large (%d)", extra)
-	}
-
-	if maj != cbg.MajArray {
-		return fmt.Errorf("expected cbor array")
-	}
-	if extra > 0 {
-		t.Vouchers = make([]*types.SignedVoucher, extra)
-	}
-	for i := 0; i < int(extra); i++ {
-
-		var v types.SignedVoucher
-		if err := v.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-		t.Vouchers[i] = &v
 	}
 
 	return nil
 }
-
 func (t *SealedRef) MarshalCBOR(w io.Writer) error {
 	if t == nil {
 		_, err := w.Write(cbg.CborNull)
@@ -199,48 +186,66 @@ func (t *SealedRef) MarshalCBOR(w io.Writer) error {
 		return err
 	}
 
-	// t.SectorID (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len("SectorID")))); err != nil {
+	scratch := make([]byte, 9)
+
+	// t.SectorID (abi.SectorNumber) (uint64)
+	if len("SectorID") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"SectorID\" was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("SectorID"))); err != nil {
 		return err
 	}
-	if _, err := w.Write([]byte("SectorID")); err != nil {
+	if _, err := io.WriteString(w, string("SectorID")); err != nil {
 		return err
 	}
 
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.SectorID))); err != nil {
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.SectorID)); err != nil {
 		return err
 	}
 
-	// t.Offset (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len("Offset")))); err != nil {
+	// t.Offset (abi.PaddedPieceSize) (uint64)
+	if len("Offset") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"Offset\" was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("Offset"))); err != nil {
 		return err
 	}
-	if _, err := w.Write([]byte("Offset")); err != nil {
+	if _, err := io.WriteString(w, string("Offset")); err != nil {
 		return err
 	}
 
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.Offset))); err != nil {
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.Offset)); err != nil {
 		return err
 	}
 
-	// t.Size (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len("Size")))); err != nil {
+	// t.Size (abi.UnpaddedPieceSize) (uint64)
+	if len("Size") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"Size\" was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("Size"))); err != nil {
 		return err
 	}
-	if _, err := w.Write([]byte("Size")); err != nil {
+	if _, err := io.WriteString(w, string("Size")); err != nil {
 		return err
 	}
 
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.Size))); err != nil {
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.Size)); err != nil {
 		return err
 	}
+
 	return nil
 }
 
 func (t *SealedRef) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
+	*t = SealedRef{}
 
-	maj, extra, err := cbg.CborReadHeader(br)
+	br := cbg.GetPeeker(r)
+	scratch := make([]byte, 8)
+
+	maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
 	if err != nil {
 		return err
 	}
@@ -248,84 +253,78 @@ func (t *SealedRef) UnmarshalCBOR(r io.Reader) error {
 		return fmt.Errorf("cbor input should be of type map")
 	}
 
-	if extra != 3 {
-		return fmt.Errorf("cbor input had wrong number of fields")
+	if extra > cbg.MaxLength {
+		return fmt.Errorf("SealedRef: map struct too large (%d)", extra)
 	}
 
 	var name string
+	n := extra
 
-	// t.SectorID (uint64) (uint64)
+	for i := uint64(0); i < n; i++ {
 
-	{
-		sval, err := cbg.ReadString(br)
-		if err != nil {
-			return err
+		{
+			sval, err := cbg.ReadStringBuf(br, scratch)
+			if err != nil {
+				return err
+			}
+
+			name = string(sval)
 		}
 
-		name = string(sval)
-	}
+		switch name {
+		// t.SectorID (abi.SectorNumber) (uint64)
+		case "SectorID":
 
-	if name != "SectorID" {
-		return fmt.Errorf("expected struct map entry %s to be SectorID", name)
-	}
+			{
 
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.SectorID = uint64(extra)
-	// t.Offset (uint64) (uint64)
+				maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
+				if err != nil {
+					return err
+				}
+				if maj != cbg.MajUnsignedInt {
+					return fmt.Errorf("wrong type for uint64 field")
+				}
+				t.SectorID = abi.SectorNumber(extra)
 
-	{
-		sval, err := cbg.ReadString(br)
-		if err != nil {
-			return err
+			}
+			// t.Offset (abi.PaddedPieceSize) (uint64)
+		case "Offset":
+
+			{
+
+				maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
+				if err != nil {
+					return err
+				}
+				if maj != cbg.MajUnsignedInt {
+					return fmt.Errorf("wrong type for uint64 field")
+				}
+				t.Offset = abi.PaddedPieceSize(extra)
+
+			}
+			// t.Size (abi.UnpaddedPieceSize) (uint64)
+		case "Size":
+
+			{
+
+				maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
+				if err != nil {
+					return err
+				}
+				if maj != cbg.MajUnsignedInt {
+					return fmt.Errorf("wrong type for uint64 field")
+				}
+				t.Size = abi.UnpaddedPieceSize(extra)
+
+			}
+
+		default:
+			return fmt.Errorf("unknown struct field %d: '%s'", i, name)
 		}
-
-		name = string(sval)
 	}
 
-	if name != "Offset" {
-		return fmt.Errorf("expected struct map entry %s to be Offset", name)
-	}
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.Offset = uint64(extra)
-	// t.Size (uint64) (uint64)
-
-	{
-		sval, err := cbg.ReadString(br)
-		if err != nil {
-			return err
-		}
-
-		name = string(sval)
-	}
-
-	if name != "Size" {
-		return fmt.Errorf("expected struct map entry %s to be Size", name)
-	}
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.Size = uint64(extra)
 	return nil
 }
-
 func (t *SealedRefs) MarshalCBOR(w io.Writer) error {
 	if t == nil {
 		_, err := w.Write(cbg.CborNull)
@@ -335,15 +334,25 @@ func (t *SealedRefs) MarshalCBOR(w io.Writer) error {
 		return err
 	}
 
+	scratch := make([]byte, 9)
+
 	// t.Refs ([]api.SealedRef) (slice)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len("Refs")))); err != nil {
+	if len("Refs") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"Refs\" was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("Refs"))); err != nil {
 		return err
 	}
-	if _, err := w.Write([]byte("Refs")); err != nil {
+	if _, err := io.WriteString(w, string("Refs")); err != nil {
 		return err
 	}
 
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajArray, uint64(len(t.Refs)))); err != nil {
+	if len(t.Refs) > cbg.MaxLength {
+		return xerrors.Errorf("Slice value in field t.Refs was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajArray, uint64(len(t.Refs))); err != nil {
 		return err
 	}
 	for _, v := range t.Refs {
@@ -355,9 +364,12 @@ func (t *SealedRefs) MarshalCBOR(w io.Writer) error {
 }
 
 func (t *SealedRefs) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
+	*t = SealedRefs{}
 
-	maj, extra, err := cbg.CborReadHeader(br)
+	br := cbg.GetPeeker(r)
+	scratch := make([]byte, 8)
+
+	maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
 	if err != nil {
 		return err
 	}
@@ -365,50 +377,354 @@ func (t *SealedRefs) UnmarshalCBOR(r io.Reader) error {
 		return fmt.Errorf("cbor input should be of type map")
 	}
 
-	if extra != 1 {
-		return fmt.Errorf("cbor input had wrong number of fields")
+	if extra > cbg.MaxLength {
+		return fmt.Errorf("SealedRefs: map struct too large (%d)", extra)
 	}
 
 	var name string
+	n := extra
 
-	// t.Refs ([]api.SealedRef) (slice)
+	for i := uint64(0); i < n; i++ {
 
-	{
-		sval, err := cbg.ReadString(br)
-		if err != nil {
-			return err
+		{
+			sval, err := cbg.ReadStringBuf(br, scratch)
+			if err != nil {
+				return err
+			}
+
+			name = string(sval)
 		}
 
-		name = string(sval)
-	}
+		switch name {
+		// t.Refs ([]api.SealedRef) (slice)
+		case "Refs":
 
-	if name != "Refs" {
-		return fmt.Errorf("expected struct map entry %s to be Refs", name)
-	}
+			maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
+			if err != nil {
+				return err
+			}
 
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
+			if extra > cbg.MaxLength {
+				return fmt.Errorf("t.Refs: array too large (%d)", extra)
+			}
 
-	if extra > cbg.MaxLength {
-		return fmt.Errorf("t.Refs: array too large (%d)", extra)
-	}
+			if maj != cbg.MajArray {
+				return fmt.Errorf("expected cbor array")
+			}
 
-	if maj != cbg.MajArray {
-		return fmt.Errorf("expected cbor array")
-	}
-	if extra > 0 {
-		t.Refs = make([]SealedRef, extra)
-	}
-	for i := 0; i < int(extra); i++ {
+			if extra > 0 {
+				t.Refs = make([]SealedRef, extra)
+			}
 
-		var v SealedRef
-		if err := v.UnmarshalCBOR(br); err != nil {
-			return err
+			for i := 0; i < int(extra); i++ {
+
+				var v SealedRef
+				if err := v.UnmarshalCBOR(br); err != nil {
+					return err
+				}
+
+				t.Refs[i] = v
+			}
+
+		default:
+			return fmt.Errorf("unknown struct field %d: '%s'", i, name)
+		}
+	}
+
+	return nil
+}
+func (t *SealTicket) MarshalCBOR(w io.Writer) error {
+	if t == nil {
+		_, err := w.Write(cbg.CborNull)
+		return err
+	}
+	if _, err := w.Write([]byte{162}); err != nil {
+		return err
+	}
+
+	scratch := make([]byte, 9)
+
+	// t.Value (abi.SealRandomness) (slice)
+	if len("Value") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"Value\" was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("Value"))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string("Value")); err != nil {
+		return err
+	}
+
+	if len(t.Value) > cbg.ByteArrayMaxLen {
+		return xerrors.Errorf("Byte array in field t.Value was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajByteString, uint64(len(t.Value))); err != nil {
+		return err
+	}
+
+	if _, err := w.Write(t.Value[:]); err != nil {
+		return err
+	}
+
+	// t.Epoch (abi.ChainEpoch) (int64)
+	if len("Epoch") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"Epoch\" was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("Epoch"))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string("Epoch")); err != nil {
+		return err
+	}
+
+	if t.Epoch >= 0 {
+		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.Epoch)); err != nil {
+			return err
+		}
+	} else {
+		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajNegativeInt, uint64(-t.Epoch-1)); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (t *SealTicket) UnmarshalCBOR(r io.Reader) error {
+	*t = SealTicket{}
+
+	br := cbg.GetPeeker(r)
+	scratch := make([]byte, 8)
+
+	maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
+	if err != nil {
+		return err
+	}
+	if maj != cbg.MajMap {
+		return fmt.Errorf("cbor input should be of type map")
+	}
+
+	if extra > cbg.MaxLength {
+		return fmt.Errorf("SealTicket: map struct too large (%d)", extra)
+	}
+
+	var name string
+	n := extra
+
+	for i := uint64(0); i < n; i++ {
+
+		{
+			sval, err := cbg.ReadStringBuf(br, scratch)
+			if err != nil {
+				return err
+			}
+
+			name = string(sval)
+		}
+
+		switch name {
+		// t.Value (abi.SealRandomness) (slice)
+		case "Value":
+
+			maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
+			if err != nil {
+				return err
+			}
+
+			if extra > cbg.ByteArrayMaxLen {
+				return fmt.Errorf("t.Value: byte array too large (%d)", extra)
+			}
+			if maj != cbg.MajByteString {
+				return fmt.Errorf("expected byte array")
+			}
+
+			if extra > 0 {
+				t.Value = make([]uint8, extra)
+			}
+
+			if _, err := io.ReadFull(br, t.Value[:]); err != nil {
+				return err
+			}
+			// t.Epoch (abi.ChainEpoch) (int64)
+		case "Epoch":
+			{
+				maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
+				var extraI int64
+				if err != nil {
+					return err
+				}
+				switch maj {
+				case cbg.MajUnsignedInt:
+					extraI = int64(extra)
+					if extraI < 0 {
+						return fmt.Errorf("int64 positive overflow")
+					}
+				case cbg.MajNegativeInt:
+					extraI = int64(extra)
+					if extraI < 0 {
+						return fmt.Errorf("int64 negative oveflow")
+					}
+					extraI = -1 - extraI
+				default:
+					return fmt.Errorf("wrong type for int64 field: %d", maj)
+				}
+
+				t.Epoch = abi.ChainEpoch(extraI)
+			}
+
+		default:
+			return fmt.Errorf("unknown struct field %d: '%s'", i, name)
+		}
+	}
+
+	return nil
+}
+func (t *SealSeed) MarshalCBOR(w io.Writer) error {
+	if t == nil {
+		_, err := w.Write(cbg.CborNull)
+		return err
+	}
+	if _, err := w.Write([]byte{162}); err != nil {
+		return err
+	}
+
+	scratch := make([]byte, 9)
+
+	// t.Value (abi.InteractiveSealRandomness) (slice)
+	if len("Value") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"Value\" was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("Value"))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string("Value")); err != nil {
+		return err
+	}
+
+	if len(t.Value) > cbg.ByteArrayMaxLen {
+		return xerrors.Errorf("Byte array in field t.Value was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajByteString, uint64(len(t.Value))); err != nil {
+		return err
+	}
+
+	if _, err := w.Write(t.Value[:]); err != nil {
+		return err
+	}
+
+	// t.Epoch (abi.ChainEpoch) (int64)
+	if len("Epoch") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"Epoch\" was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("Epoch"))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string("Epoch")); err != nil {
+		return err
+	}
+
+	if t.Epoch >= 0 {
+		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.Epoch)); err != nil {
+			return err
+		}
+	} else {
+		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajNegativeInt, uint64(-t.Epoch-1)); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (t *SealSeed) UnmarshalCBOR(r io.Reader) error {
+	*t = SealSeed{}
+
+	br := cbg.GetPeeker(r)
+	scratch := make([]byte, 8)
+
+	maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
+	if err != nil {
+		return err
+	}
+	if maj != cbg.MajMap {
+		return fmt.Errorf("cbor input should be of type map")
+	}
+
+	if extra > cbg.MaxLength {
+		return fmt.Errorf("SealSeed: map struct too large (%d)", extra)
+	}
+
+	var name string
+	n := extra
+
+	for i := uint64(0); i < n; i++ {
+
+		{
+			sval, err := cbg.ReadStringBuf(br, scratch)
+			if err != nil {
+				return err
+			}
+
+			name = string(sval)
+		}
+
+		switch name {
+		// t.Value (abi.InteractiveSealRandomness) (slice)
+		case "Value":
+
+			maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
+			if err != nil {
+				return err
+			}
+
+			if extra > cbg.ByteArrayMaxLen {
+				return fmt.Errorf("t.Value: byte array too large (%d)", extra)
+			}
+			if maj != cbg.MajByteString {
+				return fmt.Errorf("expected byte array")
+			}
+
+			if extra > 0 {
+				t.Value = make([]uint8, extra)
+			}
+
+			if _, err := io.ReadFull(br, t.Value[:]); err != nil {
+				return err
+			}
+			// t.Epoch (abi.ChainEpoch) (int64)
+		case "Epoch":
+			{
+				maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
+				var extraI int64
+				if err != nil {
+					return err
+				}
+				switch maj {
+				case cbg.MajUnsignedInt:
+					extraI = int64(extra)
+					if extraI < 0 {
+						return fmt.Errorf("int64 positive overflow")
+					}
+				case cbg.MajNegativeInt:
+					extraI = int64(extra)
+					if extraI < 0 {
+						return fmt.Errorf("int64 negative oveflow")
+					}
+					extraI = -1 - extraI
+				default:
+					return fmt.Errorf("wrong type for int64 field: %d", maj)
+				}
+
+				t.Epoch = abi.ChainEpoch(extraI)
+			}
+
+		default:
+			return fmt.Errorf("unknown struct field %d: '%s'", i, name)
 		}
-
-		t.Refs[i] = v
 	}
 
 	return nil
diff --git a/api/client/client.go b/api/client/client.go
index 0e19f65c2..cd915acf0 100644
--- a/api/client/client.go
+++ b/api/client/client.go
@@ -1,28 +1,36 @@
 package client
 
 import (
-	"github.com/filecoin-project/lotus/api/apistruct"
+	"context"
 	"net/http"
+	"net/url"
+	"path"
+	"time"
+
+	"github.com/filecoin-project/go-jsonrpc"
 
 	"github.com/filecoin-project/lotus/api"
-	"github.com/filecoin-project/lotus/lib/jsonrpc"
+	"github.com/filecoin-project/lotus/api/apistruct"
+	"github.com/filecoin-project/lotus/lib/rpcenc"
 )
 
 // NewCommonRPC creates a new http jsonrpc client.
-func NewCommonRPC(addr string, requestHeader http.Header) (api.Common, jsonrpc.ClientCloser, error) {
+func NewCommonRPC(ctx context.Context, addr string, requestHeader http.Header) (api.Common, jsonrpc.ClientCloser, error) {
 	var res apistruct.CommonStruct
-	closer, err := jsonrpc.NewMergeClient(addr, "Filecoin",
+	closer, err := jsonrpc.NewMergeClient(ctx, addr, "Filecoin",
 		[]interface{}{
 			&res.Internal,
-		}, requestHeader)
+		},
+		requestHeader,
+	)
 
 	return &res, closer, err
 }
 
 // NewFullNodeRPC creates a new http jsonrpc client.
-func NewFullNodeRPC(addr string, requestHeader http.Header) (api.FullNode, jsonrpc.ClientCloser, error) {
+func NewFullNodeRPC(ctx context.Context, addr string, requestHeader http.Header) (api.FullNode, jsonrpc.ClientCloser, error) {
 	var res apistruct.FullNodeStruct
-	closer, err := jsonrpc.NewMergeClient(addr, "Filecoin",
+	closer, err := jsonrpc.NewMergeClient(ctx, addr, "Filecoin",
 		[]interface{}{
 			&res.CommonStruct.Internal,
 			&res.Internal,
@@ -31,14 +39,46 @@ func NewFullNodeRPC(addr string, requestHeader http.Header) (api.FullNode, jsonr
 	return &res, closer, err
 }
 
-// NewStorageMinerRPC creates a new http jsonrpc client for storage miner
-func NewStorageMinerRPC(addr string, requestHeader http.Header) (api.StorageMiner, jsonrpc.ClientCloser, error) {
+// NewStorageMinerRPC creates a new http jsonrpc client for miner
+func NewStorageMinerRPC(ctx context.Context, addr string, requestHeader http.Header, opts ...jsonrpc.Option) (api.StorageMiner, jsonrpc.ClientCloser, error) {
 	var res apistruct.StorageMinerStruct
-	closer, err := jsonrpc.NewMergeClient(addr, "Filecoin",
+	closer, err := jsonrpc.NewMergeClient(ctx, addr, "Filecoin",
 		[]interface{}{
 			&res.CommonStruct.Internal,
 			&res.Internal,
-		}, requestHeader)
+		},
+		requestHeader,
+		opts...,
+	)
+
+	return &res, closer, err
+}
+
+func NewWorkerRPC(ctx context.Context, addr string, requestHeader http.Header) (api.WorkerAPI, jsonrpc.ClientCloser, error) {
+	u, err := url.Parse(addr)
+	if err != nil {
+		return nil, nil, err
+	}
+	switch u.Scheme {
+	case "ws":
+		u.Scheme = "http"
+	case "wss":
+		u.Scheme = "https"
+	}
+	///rpc/v0 -> /rpc/streams/v0/push
+
+	u.Path = path.Join(u.Path, "../streams/v0/push")
+
+	var res apistruct.WorkerStruct
+	closer, err := jsonrpc.NewMergeClient(ctx, addr, "Filecoin",
+		[]interface{}{
+			&res.Internal,
+		},
+		requestHeader,
+		rpcenc.ReaderParamEncoder(u.String()),
+		jsonrpc.WithNoReconnect(),
+		jsonrpc.WithTimeout(30*time.Second),
+	)
 
 	return &res, closer, err
 }
diff --git a/api/docgen/docgen.go b/api/docgen/docgen.go
new file mode 100644
index 000000000..ced536cc3
--- /dev/null
+++ b/api/docgen/docgen.go
@@ -0,0 +1,420 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"reflect"
+	"sort"
+	"strings"
+	"time"
+	"unicode"
+
+	"github.com/ipfs/go-cid"
+	"github.com/ipfs/go-filestore"
+	metrics "github.com/libp2p/go-libp2p-core/metrics"
+	"github.com/libp2p/go-libp2p-core/network"
+	"github.com/libp2p/go-libp2p-core/peer"
+	protocol "github.com/libp2p/go-libp2p-core/protocol"
+	pubsub "github.com/libp2p/go-libp2p-pubsub"
+	"github.com/multiformats/go-multiaddr"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-bitfield"
+	datatransfer "github.com/filecoin-project/go-data-transfer"
+	"github.com/filecoin-project/go-fil-markets/retrievalmarket"
+	"github.com/filecoin-project/go-jsonrpc/auth"
+	"github.com/filecoin-project/go-multistore"
+
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/crypto"
+	"github.com/filecoin-project/go-state-types/exitcode"
+
+	"github.com/filecoin-project/lotus/api"
+	"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/node/modules/dtypes"
+)
+
+var ExampleValues = map[reflect.Type]interface{}{
+	reflect.TypeOf(auth.Permission("")): auth.Permission("write"),
+	reflect.TypeOf(""):                  "string value",
+	reflect.TypeOf(uint64(42)):          uint64(42),
+	reflect.TypeOf(byte(7)):             byte(7),
+	reflect.TypeOf([]byte{}):            []byte("byte array"),
+}
+
+func addExample(v interface{}) {
+	ExampleValues[reflect.TypeOf(v)] = v
+}
+
+func init() {
+	c, err := cid.Decode("bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4")
+	if err != nil {
+		panic(err)
+	}
+
+	ExampleValues[reflect.TypeOf(c)] = c
+
+	c2, err := cid.Decode("bafy2bzacebp3shtrn43k7g3unredz7fxn4gj533d3o43tqn2p2ipxxhrvchve")
+	if err != nil {
+		panic(err)
+	}
+
+	tsk := types.NewTipSetKey(c, c2)
+
+	ExampleValues[reflect.TypeOf(tsk)] = tsk
+
+	addr, err := address.NewIDAddress(1234)
+	if err != nil {
+		panic(err)
+	}
+
+	ExampleValues[reflect.TypeOf(addr)] = addr
+
+	pid, err := peer.Decode("12D3KooWGzxzKZYveHXtpG6AsrUJBcWxHBFS2HsEoGTxrMLvKXtf")
+	if err != nil {
+		panic(err)
+	}
+	addExample(pid)
+	addExample(&pid)
+
+	addExample(bitfield.NewFromSet([]uint64{5}))
+	addExample(abi.RegisteredSealProof_StackedDrg32GiBV1)
+	addExample(abi.RegisteredPoStProof_StackedDrgWindow32GiBV1)
+	addExample(abi.ChainEpoch(10101))
+	addExample(crypto.SigTypeBLS)
+	addExample(int64(9))
+	addExample(12.3)
+	addExample(123)
+	addExample(uintptr(0))
+	addExample(abi.MethodNum(1))
+	addExample(exitcode.ExitCode(0))
+	addExample(crypto.DomainSeparationTag_ElectionProofProduction)
+	addExample(true)
+	addExample(abi.UnpaddedPieceSize(1024))
+	addExample(abi.UnpaddedPieceSize(1024).Padded())
+	addExample(abi.DealID(5432))
+	addExample(filestore.StatusFileChanged)
+	addExample(abi.SectorNumber(9))
+	addExample(abi.SectorSize(32 * 1024 * 1024 * 1024))
+	addExample(api.MpoolChange(0))
+	addExample(network.Connected)
+	addExample(dtypes.NetworkName("lotus"))
+	addExample(api.SyncStateStage(1))
+	addExample(build.FullAPIVersion)
+	addExample(api.PCHInbound)
+	addExample(time.Minute)
+	addExample(datatransfer.TransferID(3))
+	addExample(datatransfer.Ongoing)
+	addExample(multistore.StoreID(50))
+	addExample(retrievalmarket.ClientEventDealAccepted)
+	addExample(retrievalmarket.DealStatusNew)
+	addExample(network.ReachabilityPublic)
+	addExample(build.NewestNetworkVersion)
+	addExample(&types.ExecutionTrace{
+		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(reflect.TypeOf(types.Actor{}), nil).(types.Actor),
+	})
+	addExample(map[string]api.MarketDeal{
+		"t026363": exampleValue(reflect.TypeOf(api.MarketDeal{}), nil).(api.MarketDeal),
+	})
+	addExample(map[string]api.MarketBalance{
+		"t026363": exampleValue(reflect.TypeOf(api.MarketBalance{}), nil).(api.MarketBalance),
+	})
+	addExample(map[string]*pubsub.TopicScoreSnapshot{
+		"/blocks": {
+			TimeInMesh:               time.Minute,
+			FirstMessageDeliveries:   122,
+			MeshMessageDeliveries:    1234,
+			InvalidMessageDeliveries: 3,
+		},
+	})
+	addExample(map[string]metrics.Stats{
+		"12D3KooWSXmXLJmBR1M7i9RW9GQPNUhZSzXKzxDHWtAgNuJAbyEJ": {
+			RateIn:   100,
+			RateOut:  50,
+			TotalIn:  174000,
+			TotalOut: 12500,
+		},
+	})
+	addExample(map[protocol.ID]metrics.Stats{
+		"/fil/hello/1.0.0": {
+			RateIn:   100,
+			RateOut:  50,
+			TotalIn:  174000,
+			TotalOut: 12500,
+		},
+	})
+
+	maddr, err := multiaddr.NewMultiaddr("/ip4/52.36.61.156/tcp/1347/p2p/12D3KooWFETiESTf1v4PGUvtnxMAcEFMzLZbJGg4tjWfGEimYior")
+	if err != nil {
+		panic(err)
+	}
+
+	// because reflect.TypeOf(maddr) returns the concrete type...
+	ExampleValues[reflect.TypeOf(struct{ A multiaddr.Multiaddr }{}).Field(0).Type] = maddr
+
+}
+
+func exampleValue(t, parent reflect.Type) interface{} {
+	v, ok := ExampleValues[t]
+	if ok {
+		return v
+	}
+
+	switch t.Kind() {
+	case reflect.Slice:
+		out := reflect.New(t).Elem()
+		reflect.Append(out, reflect.ValueOf(exampleValue(t.Elem(), t)))
+		return out.Interface()
+	case reflect.Chan:
+		return exampleValue(t.Elem(), nil)
+	case reflect.Struct:
+		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(t.Elem(), t)))
+		}
+		return out.Interface()
+
+	case reflect.Ptr:
+		if t.Elem().Kind() == reflect.Struct {
+			es := exampleStruct(t.Elem(), t)
+			//ExampleValues[t] = es
+			return es
+		}
+	case reflect.Interface:
+		return struct{}{}
+	}
+
+	panic(fmt.Sprintf("No example value for type: %s", t))
+}
+
+func exampleStruct(t, parent reflect.Type) interface{} {
+	ns := reflect.New(t)
+	for i := 0; i < t.NumField(); i++ {
+		f := t.Field(i)
+		if f.Type == parent {
+			continue
+		}
+		if strings.Title(f.Name) == f.Name {
+			ns.Elem().Field(i).Set(reflect.ValueOf(exampleValue(f.Type, t)))
+		}
+	}
+
+	return ns.Interface()
+}
+
+type Visitor struct {
+	Methods map[string]ast.Node
+}
+
+func (v *Visitor) Visit(node ast.Node) ast.Visitor {
+	st, ok := node.(*ast.TypeSpec)
+	if !ok {
+		return v
+	}
+
+	if st.Name.Name != "FullNode" {
+		return nil
+	}
+
+	iface := st.Type.(*ast.InterfaceType)
+	for _, m := range iface.Methods.List {
+		if len(m.Names) > 0 {
+			v.Methods[m.Names[0].Name] = m
+		}
+	}
+
+	return v
+}
+
+const noComment = "There are not yet any comments for this method."
+
+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 {
+		fmt.Println("parse error: ", err)
+	}
+
+	ap := pkgs["api"]
+
+	f := ap.Files["api/api_full.go"]
+
+	cmap := ast.NewCommentMap(fset, f, f.Comments)
+
+	v := &Visitor{make(map[string]ast.Node)}
+	ast.Walk(v, pkgs["api"])
+
+	groupDocs := make(map[string]string)
+	out := make(map[string]string)
+	for mn, node := range v.Methods {
+		cs := cmap.Filter(node).Comments()
+		if len(cs) == 0 {
+			out[mn] = noComment
+		} else {
+			for _, c := range cs {
+				if strings.HasPrefix(c.Text(), "MethodGroup:") {
+					parts := strings.Split(c.Text(), "\n")
+					groupName := strings.TrimSpace(parts[0][12:])
+					comment := strings.Join(parts[1:], "\n")
+					groupDocs[groupName] = comment
+
+					break
+				}
+			}
+
+			last := cs[len(cs)-1].Text()
+			if !strings.HasPrefix(last, "MethodGroup:") {
+				out[mn] = last
+			} else {
+				out[mn] = noComment
+			}
+		}
+	}
+	return out, groupDocs
+}
+
+type MethodGroup struct {
+	GroupName string
+	Header    string
+	Methods   []*Method
+}
+
+type Method struct {
+	Comment         string
+	Name            string
+	InputExample    string
+	ResponseExample string
+}
+
+func methodGroupFromName(mn string) string {
+	i := strings.IndexFunc(mn[1:], func(r rune) bool {
+		return unicode.IsUpper(r)
+	})
+	if i < 0 {
+		return ""
+	}
+	return mn[:i+1]
+}
+
+func main() {
+
+	comments, groupComments := parseApiASTInfo()
+
+	groups := make(map[string]*MethodGroup)
+
+	var api struct{ api.FullNode }
+	t := reflect.TypeOf(api)
+	for i := 0; i < t.NumMethod(); i++ {
+		m := t.Method(i)
+
+		groupName := methodGroupFromName(m.Name)
+
+		g, ok := groups[groupName]
+		if !ok {
+			g = new(MethodGroup)
+			g.Header = groupComments[groupName]
+			g.GroupName = groupName
+			groups[groupName] = g
+		}
+
+		var args []interface{}
+		ft := m.Func.Type()
+		for j := 2; j < ft.NumIn(); j++ {
+			inp := ft.In(j)
+			args = append(args, exampleValue(inp, nil))
+		}
+
+		v, err := json.MarshalIndent(args, "", "  ")
+		if err != nil {
+			panic(err)
+		}
+
+		outv := exampleValue(ft.Out(0), nil)
+
+		ov, err := json.MarshalIndent(outv, "", "  ")
+		if err != nil {
+			panic(err)
+		}
+
+		g.Methods = append(g.Methods, &Method{
+			Name:            m.Name,
+			Comment:         comments[m.Name],
+			InputExample:    string(v),
+			ResponseExample: string(ov),
+		})
+	}
+
+	var groupslice []*MethodGroup
+	for _, g := range groups {
+		groupslice = append(groupslice, g)
+	}
+
+	sort.Slice(groupslice, func(i, j int) bool {
+		return groupslice[i].GroupName < groupslice[j].GroupName
+	})
+
+	fmt.Printf("# Groups\n")
+
+	for _, g := range groupslice {
+		fmt.Printf("* [%s](#%s)\n", g.GroupName, g.GroupName)
+		for _, method := range g.Methods {
+			fmt.Printf("  * [%s](#%s)\n", method.Name, method.Name)
+		}
+	}
+
+	permStruct := reflect.TypeOf(apistruct.FullNodeStruct{}.Internal)
+	commonPermStruct := reflect.TypeOf(apistruct.CommonStruct{}.Internal)
+
+	for _, g := range groupslice {
+		g := g
+		fmt.Printf("## %s\n", g.GroupName)
+		fmt.Printf("%s\n\n", g.Header)
+
+		sort.Slice(g.Methods, func(i, j int) bool {
+			return g.Methods[i].Name < g.Methods[j].Name
+		})
+
+		for _, m := range g.Methods {
+			fmt.Printf("### %s\n", m.Name)
+			fmt.Printf("%s\n\n", m.Comment)
+
+			meth, ok := permStruct.FieldByName(m.Name)
+			if !ok {
+				meth, ok = commonPermStruct.FieldByName(m.Name)
+				if !ok {
+					panic("no perms for method: " + m.Name)
+				}
+			}
+
+			perms := meth.Tag.Get("perm")
+
+			fmt.Printf("Perms: %s\n\n", perms)
+
+			if strings.Count(m.InputExample, "\n") > 0 {
+				fmt.Printf("Inputs:\n```json\n%s\n```\n\n", m.InputExample)
+			} else {
+				fmt.Printf("Inputs: `%s`\n\n", m.InputExample)
+			}
+
+			if strings.Count(m.ResponseExample, "\n") > 0 {
+				fmt.Printf("Response:\n```json\n%s\n```\n\n", m.ResponseExample)
+			} else {
+				fmt.Printf("Response: `%s`\n\n", m.ResponseExample)
+			}
+		}
+	}
+}
diff --git a/api/test/blockminer.go b/api/test/blockminer.go
new file mode 100644
index 000000000..6b28a5794
--- /dev/null
+++ b/api/test/blockminer.go
@@ -0,0 +1,56 @@
+package test
+
+import (
+	"context"
+	"fmt"
+	"sync/atomic"
+	"testing"
+	"time"
+
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/lotus/miner"
+)
+
+type BlockMiner struct {
+	ctx       context.Context
+	t         *testing.T
+	miner     TestStorageNode
+	blocktime time.Duration
+	mine      int64
+	nulls     int64
+	done      chan struct{}
+}
+
+func NewBlockMiner(ctx context.Context, t *testing.T, miner TestStorageNode, blocktime time.Duration) *BlockMiner {
+	return &BlockMiner{
+		ctx:       ctx,
+		t:         t,
+		miner:     miner,
+		blocktime: blocktime,
+		mine:      int64(1),
+		done:      make(chan struct{}),
+	}
+}
+
+func (bm *BlockMiner) MineBlocks() {
+	time.Sleep(time.Second)
+	go func() {
+		defer close(bm.done)
+		for atomic.LoadInt64(&bm.mine) == 1 {
+			time.Sleep(bm.blocktime)
+			nulls := atomic.SwapInt64(&bm.nulls, 0)
+			if err := bm.miner.MineOne(bm.ctx, miner.MineReq{
+				InjectNulls: abi.ChainEpoch(nulls),
+				Done:        func(bool, abi.ChainEpoch, error) {},
+			}); err != nil {
+				bm.t.Error(err)
+			}
+		}
+	}()
+}
+
+func (bm *BlockMiner) Stop() {
+	atomic.AddInt64(&bm.mine, -1)
+	fmt.Println("shutting down mining")
+	<-bm.done
+}
diff --git a/api/test/ccupgrade.go b/api/test/ccupgrade.go
new file mode 100644
index 000000000..f58f1ff6e
--- /dev/null
+++ b/api/test/ccupgrade.go
@@ -0,0 +1,116 @@
+package test
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"sync/atomic"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/filecoin-project/go-state-types/abi"
+
+	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/node/impl"
+)
+
+func TestCCUpgrade(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)
+			}
+		}
+	}()
+
+	maddr, err := miner.ActorAddress(ctx)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	CC := abi.SectorNumber(GenesisPreseals + 1)
+	Upgraded := CC + 1
+
+	pledgeSectors(t, ctx, miner, 1, 0, nil)
+
+	sl, err := miner.SectorsList(ctx)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(sl) != 1 {
+		t.Fatal("expected 1 sector")
+	}
+
+	if sl[0] != CC {
+		t.Fatal("bad")
+	}
+
+	{
+		si, err := client.StateSectorGetInfo(ctx, maddr, CC, types.EmptyTSK)
+		require.NoError(t, err)
+		require.Less(t, 50000, int(si.Expiration))
+	}
+
+	if err := miner.SectorMarkForUpgrade(ctx, sl[0]); err != nil {
+		t.Fatal(err)
+	}
+
+	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))
+	}
+	{
+		exp, err := client.StateSectorExpiration(ctx, maddr, Upgraded, types.EmptyTSK)
+		require.NoError(t, err)
+		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
+}
diff --git a/api/test/deals.go b/api/test/deals.go
index b9ff2611f..12cd0607a 100644
--- a/api/test/deals.go
+++ b/api/test/deals.go
@@ -8,27 +8,47 @@ import (
 	"math/rand"
 	"os"
 	"path/filepath"
+	"sync/atomic"
 	"testing"
 	"time"
 
-	logging "github.com/ipfs/go-log"
+	"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/filecoin-project/go-fil-markets/storagemarket"
+	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/build"
+	sealing "github.com/filecoin-project/lotus/extern/storage-sealing"
+	"github.com/filecoin-project/lotus/miner"
+	dag "github.com/ipfs/go-merkledag"
+	dstest "github.com/ipfs/go-merkledag/test"
+	unixfile "github.com/ipfs/go-unixfs/file"
+
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/node/impl"
+	ipld "github.com/ipfs/go-ipld-format"
 )
 
+var MineNext = miner.MineReq{
+	InjectNulls: 0,
+	Done:        func(bool, abi.ChainEpoch, error) {},
+}
+
 func init() {
 	logging.SetAllLoggers(logging.LevelInfo)
 	build.InsecurePoStValidation = true
 }
 
-func TestDealFlow(t *testing.T, b APIBuilder) {
-	os.Setenv("BELLMAN_NO_GPU", "1")
+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, []int{0})
+	n, sn := b(t, 1, OneMiner)
 	client := n[0].FullNode.(*impl.FullNodeAPI)
 	miner := sn[0]
 
@@ -42,8 +62,67 @@ func TestDealFlow(t *testing.T, b APIBuilder) {
 	}
 	time.Sleep(time.Second)
 
-	data := make([]byte, 1000)
-	rand.New(rand.NewSource(5)).Read(data)
+	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)
@@ -51,37 +130,180 @@ func TestDealFlow(t *testing.T, b APIBuilder) {
 		t.Fatal(err)
 	}
 
-	maddr, err := miner.ActorAddress(ctx)
+	fmt.Println("FILE CID: ", fcid)
+
+	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)
+	waitDealSealed(t, ctx, miner, client, deal, false)
+
+	// Retrieval
+	info, err := client.ClientGetDealInfo(ctx, *deal)
+	require.NoError(t, err)
+
+	testRetrieval(t, ctx, client, fcid, &info.PieceCID, carExport, data)
+}
+
+func TestFastRetrievalDealFlow(t *testing.T, b APIBuilder, blocktime time.Duration) {
+	_ = os.Setenv("BELLMAN_NO_GPU", "1")
+
+	ctx := context.Background()
+	n, sn := b(t, 1, OneMiner)
+	client := n[0].FullNode.(*impl.FullNodeAPI)
+	miner := sn[0]
+
+	addrinfo, err := client.NetAddrsListen(ctx)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if err := miner.NetConnect(ctx, addrinfo); err != nil {
+		t.Fatal(err)
+	}
+	time.Sleep(time.Second)
+
+	mine := int64(1)
+	done := make(chan struct{})
+	go func() {
+		defer close(done)
+		for atomic.LoadInt64(&mine) == 1 {
+			time.Sleep(blocktime)
+			if err := sn[0].MineOne(ctx, MineNext); err != nil {
+				t.Error(err)
+			}
+		}
+	}()
+
+	data := make([]byte, 1600)
+	rand.New(rand.NewSource(int64(8))).Read(data)
+
+	r := bytes.NewReader(data)
+	fcid, err := client.ClientImportLocal(ctx, r)
 	if err != nil {
 		t.Fatal(err)
 	}
 
 	fmt.Println("FILE CID: ", fcid)
 
-	mine := true
+	deal := startDeal(t, ctx, miner, client, fcid, true)
+
+	waitDealPublished(t, ctx, miner, deal)
+	fmt.Println("deal published, retrieving")
+	// Retrieval
+	info, err := client.ClientGetDealInfo(ctx, *deal)
+	require.NoError(t, err)
+
+	testRetrieval(t, ctx, client, fcid, &info.PieceCID, false, data)
+	atomic.AddInt64(&mine, -1)
+	fmt.Println("shutting down mining")
+	<-done
+}
+
+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 mine {
-			time.Sleep(time.Second)
-			fmt.Println("mining a block now")
-			if err := sn[0].MineOne(ctx); err != nil {
+		for atomic.LoadInt64(&mine) == 1 {
+			time.Sleep(blocktime)
+			if err := sn[0].MineOne(ctx, MineNext); err != nil {
 				t.Error(err)
 			}
 		}
 	}()
-	addr, err := client.WalletDefaultAddress(ctx)
-	if err != nil {
-		t.Fatal(err)
+
+	{
+		data1 := make([]byte, 800)
+		rand.New(rand.NewSource(int64(3))).Read(data1)
+		r := bytes.NewReader(data1)
+
+		fcid1, err := client.ClientImportLocal(ctx, r)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		data2 := make([]byte, 800)
+		rand.New(rand.NewSource(int64(9))).Read(data2)
+		r2 := bytes.NewReader(data2)
+
+		fcid2, err := client.ClientImportLocal(ctx, r2)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		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, ctx, miner, client, deal1, true)
+
+		deal2 := startDeal(t, ctx, miner, client, fcid2, true)
+
+		time.Sleep(time.Second)
+		waitDealSealed(t, ctx, miner, client, deal2, false)
+
+		// Retrieval
+		info, err := client.ClientGetDealInfo(ctx, *deal2)
+		require.NoError(t, err)
+
+		rf, _ := miner.SectorsRefs(ctx)
+		fmt.Printf("refs: %+v\n", rf)
+
+		testRetrieval(t, ctx, client, fcid2, &info.PieceCID, false, data2)
 	}
-	deal, err := client.ClientStartDeal(ctx, fcid, addr, maddr, types.NewInt(40000000), 100)
+
+	atomic.AddInt64(&mine, -1)
+	fmt.Println("shutting down mining")
+	<-done
+}
+
+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)
 	}
 
-	// TODO: this sleep is only necessary because deals don't immediately get logged in the dealstore, we should fix this
-	time.Sleep(time.Second)
+	addr, err := client.WalletDefaultAddress(ctx)
+	if err != nil {
+		t.Fatal(err)
+	}
+	deal, err := client.ClientStartDeal(ctx, &api.StartDealParams{
+		Data: &storagemarket.DataRef{
+			TransferType: storagemarket.TTGraphsync,
+			Root:         fcid,
+		},
+		Wallet:            addr,
+		Miner:             maddr,
+		EpochPrice:        types.NewInt(1000000),
+		MinBlocksDuration: uint64(build.MinDealDuration),
+		FastRetrieval:     fastRet,
+	})
+	if err != nil {
+		t.Fatalf("%+v", err)
+	}
+	return deal
+}
+
+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)
@@ -89,23 +311,73 @@ loop:
 			t.Fatal(err)
 		}
 		switch di.State {
-		case api.DealRejected:
+		case storagemarket.StorageDealSealing:
+			if noseal {
+				return
+			}
+			startSealingWaiting(t, ctx, miner)
+		case storagemarket.StorageDealProposalRejected:
 			t.Fatal("deal rejected")
-		case api.DealFailed:
+		case storagemarket.StorageDealFailing:
 			t.Fatal("deal failed")
-		case api.DealError:
-			t.Fatal("deal errored")
-		case api.DealComplete:
+		case storagemarket.StorageDealError:
+			t.Fatal("deal errored", di.Message)
+		case storagemarket.StorageDealActive:
 			fmt.Println("COMPLETE", di)
 			break loop
 		}
-		fmt.Println("Deal state: ", api.DealStates[di.State])
+		fmt.Println("Deal state: ", storagemarket.DealStates[di.State])
 		time.Sleep(time.Second / 2)
 	}
+}
 
-	// Retrieval
+func waitDealPublished(t *testing.T, ctx context.Context, miner TestStorageNode, deal *cid.Cid) {
+	subCtx, cancel := context.WithCancel(ctx)
+	defer cancel()
+	updates, err := miner.MarketGetDealUpdates(subCtx)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for {
+		select {
+		case <-ctx.Done():
+			t.Fatal("context timeout")
+		case di := <-updates:
+			if deal.Equals(di.ProposalCid) {
+				switch di.State {
+				case storagemarket.StorageDealProposalRejected:
+					t.Fatal("deal rejected")
+				case storagemarket.StorageDealFailing:
+					t.Fatal("deal failed")
+				case storagemarket.StorageDealError:
+					t.Fatal("deal errored", di.Message)
+				case storagemarket.StorageDealFinalizing, storagemarket.StorageDealSealing, storagemarket.StorageDealActive:
+					fmt.Println("COMPLETE", di)
+					return
+				}
+				fmt.Println("Deal state: ", storagemarket.DealStates[di.State])
+			}
+		}
+	}
+}
 
-	offers, err := client.ClientFindData(ctx, fcid)
+func startSealingWaiting(t *testing.T, ctx context.Context, miner TestStorageNode) {
+	snums, err := miner.SectorsList(ctx)
+	require.NoError(t, err)
+
+	for _, snum := range snums {
+		si, err := miner.SectorsStatus(ctx, snum, false)
+		require.NoError(t, err)
+
+		t.Logf("Sector state: %s", si.State)
+		if si.State == api.SectorState(sealing.WaitDeals) {
+			require.NoError(t, miner.SectorStartSealing(ctx, snum))
+		}
+	}
+}
+
+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)
 	}
@@ -118,16 +390,22 @@ loop:
 	if err != nil {
 		t.Fatal(err)
 	}
-	defer os.RemoveAll(rpath)
+	defer os.RemoveAll(rpath) //nolint:errcheck
 
 	caddr, err := client.WalletDefaultAddress(ctx)
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	err = client.ClientRetrieve(ctx, offers[0].Order(caddr), filepath.Join(rpath, "ret"))
-	if err != nil {
-		t.Fatalf("%+v", err)
+	ref := &api.FileRef{
+		Path:  filepath.Join(rpath, "ret"),
+		IsCAR: carExport,
+	}
+	updates, err := client.ClientRetrieveWithEvents(ctx, offers[0].Order(caddr), ref)
+	for update := range updates {
+		if update.Err != "" {
+			t.Fatalf("%v", err)
+		}
 	}
 
 	rdata, err := ioutil.ReadFile(filepath.Join(rpath, "ret"))
@@ -135,11 +413,41 @@ loop:
 		t.Fatal(err)
 	}
 
+	if carExport {
+		rdata = extractCarData(t, ctx, rdata, rpath)
+	}
+
 	if !bytes.Equal(rdata, data) {
 		t.Fatal("wrong data retrieved")
 	}
-
-	mine = false
-	fmt.Println("shutting down mining")
-	<-done
+}
+
+func extractCarData(t *testing.T, ctx context.Context, rdata []byte, rpath string) []byte {
+	bserv := dstest.Bserv()
+	ch, err := car.LoadCar(bserv.Blockstore(), bytes.NewReader(rdata))
+	if err != nil {
+		t.Fatal(err)
+	}
+	b, err := bserv.GetBlock(ctx, ch.Roots[0])
+	if err != nil {
+		t.Fatal(err)
+	}
+	nd, err := ipld.Decode(b)
+	if err != nil {
+		t.Fatal(err)
+	}
+	dserv := dag.NewDAGService(bserv)
+	fil, err := unixfile.NewUnixfsFile(ctx, dserv, nd)
+	if err != nil {
+		t.Fatal(err)
+	}
+	outPath := filepath.Join(rpath, "retLoadedCAR")
+	if err := files.WriteTo(fil, outPath); err != nil {
+		t.Fatal(err)
+	}
+	rdata, err = ioutil.ReadFile(outPath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return rdata
 }
diff --git a/api/test/mining.go b/api/test/mining.go
index 77f4ec6c3..e19774a76 100644
--- a/api/test/mining.go
+++ b/api/test/mining.go
@@ -1,31 +1,207 @@
 package test
 
 import (
+	"bytes"
 	"context"
+	"fmt"
+	"math/rand"
+	"os"
+	"sync/atomic"
 	"testing"
+	"time"
 
+	logging "github.com/ipfs/go-log/v2"
+
+	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/stretchr/testify/require"
+
+	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/miner"
+	"github.com/filecoin-project/lotus/node/impl"
 )
 
+//nolint:deadcode,varcheck
+var log = logging.Logger("apitest")
+
 func (ts *testSuite) testMining(t *testing.T) {
 	ctx := context.Background()
-	apis, sn := ts.makeNodes(t, 1, []int{0})
+	apis, sn := ts.makeNodes(t, 1, OneMiner)
 	api := apis[0]
 
-	h1, err := api.ChainHead(ctx)
-	require.NoError(t, err)
-	require.Equal(t, uint64(0), h1.Height())
-
 	newHeads, err := api.ChainNotify(ctx)
 	require.NoError(t, err)
-	<-newHeads
+	initHead := (<-newHeads)[0]
+	baseHeight := initHead.Val.Height()
 
-	err = sn[0].MineOne(ctx)
+	h1, err := api.ChainHead(ctx)
+	require.NoError(t, err)
+	require.Equal(t, int64(h1.Height()), int64(baseHeight))
+
+	MineUntilBlock(ctx, t, apis[0], sn[0], nil)
 	require.NoError(t, err)
 
 	<-newHeads
 
 	h2, err := api.ChainHead(ctx)
 	require.NoError(t, err)
-	require.Equal(t, uint64(1), h2.Height())
+	require.Greater(t, int64(h2.Height()), int64(h1.Height()))
+}
+
+func (ts *testSuite) testMiningReal(t *testing.T) {
+	build.InsecurePoStValidation = false
+	defer func() {
+		build.InsecurePoStValidation = true
+	}()
+
+	ctx := context.Background()
+	apis, sn := ts.makeNodes(t, 1, OneMiner)
+	api := apis[0]
+
+	newHeads, err := api.ChainNotify(ctx)
+	require.NoError(t, err)
+	initHead := (<-newHeads)[0]
+	if initHead.Val.Height() != 2 {
+		<-newHeads
+	}
+
+	h1, err := api.ChainHead(ctx)
+	require.NoError(t, err)
+	require.Equal(t, abi.ChainEpoch(2), h1.Height())
+
+	MineUntilBlock(ctx, t, apis[0], sn[0], nil)
+	require.NoError(t, err)
+
+	<-newHeads
+
+	h2, err := api.ChainHead(ctx)
+	require.NoError(t, err)
+	require.Equal(t, abi.ChainEpoch(3), h2.Height())
+
+	MineUntilBlock(ctx, t, apis[0], sn[0], nil)
+	require.NoError(t, err)
+
+	<-newHeads
+
+	h2, err = api.ChainHead(ctx)
+	require.NoError(t, err)
+	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, 1, []StorageMiner{
+		{Full: 0, Preseal: PresealGenesis},
+		{Full: 0, Preseal: 0}, // TODO: Add support for miners on non-first full node
+	})
+	client := n[0].FullNode.(*impl.FullNodeAPI)
+	provider := sn[1]
+	genesisMiner := sn[0]
+
+	addrinfo, err := client.NetAddrsListen(ctx)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if err := provider.NetConnect(ctx, addrinfo); err != nil {
+		t.Fatal(err)
+	}
+
+	if err := genesisMiner.NetConnect(ctx, addrinfo); err != nil {
+		t.Fatal(err)
+	}
+
+	time.Sleep(time.Second)
+
+	data := make([]byte, 600)
+	rand.New(rand.NewSource(5)).Read(data)
+
+	r := bytes.NewReader(data)
+	fcid, err := client.ClientImportLocal(ctx, r)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	fmt.Println("FILE CID: ", fcid)
+
+	var mine int32 = 1
+	done := make(chan struct{})
+	minedTwo := make(chan struct{})
+
+	m2addr, err := sn[1].ActorAddress(context.TODO())
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	go func() {
+		defer close(done)
+
+		complChan := minedTwo
+		for atomic.LoadInt32(&mine) != 0 {
+			wait := make(chan int)
+			mdone := func(mined bool, _ abi.ChainEpoch, err error) {
+				n := 0
+				if mined {
+					n = 1
+				}
+				wait <- n
+			}
+
+			if err := sn[0].MineOne(ctx, miner.MineReq{Done: mdone}); err != nil {
+				t.Error(err)
+			}
+
+			if err := sn[1].MineOne(ctx, miner.MineReq{Done: mdone}); err != nil {
+				t.Error(err)
+			}
+
+			expect := <-wait
+			expect += <-wait
+
+			time.Sleep(blocktime)
+			if expect == 0 {
+				// null block
+				continue
+			}
+
+			var nodeOneMined bool
+			for _, node := range sn {
+				mb, err := node.MiningBase(ctx)
+				if err != nil {
+					t.Error(err)
+					return
+				}
+
+				for _, b := range mb.Blocks() {
+					if b.Miner == m2addr {
+						nodeOneMined = true
+						break
+					}
+				}
+
+			}
+
+			if nodeOneMined && complChan != nil {
+				close(complChan)
+				complChan = nil
+			}
+
+		}
+	}()
+
+	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)
+
+	waitDealSealed(t, ctx, provider, client, deal, false)
+
+	<-minedTwo
+
+	atomic.StoreInt32(&mine, 0)
+	fmt.Println("shutting down mining")
+	<-done
 }
diff --git a/api/test/paych.go b/api/test/paych.go
new file mode 100644
index 000000000..36eb2c256
--- /dev/null
+++ b/api/test/paych.go
@@ -0,0 +1,259 @@
+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"
+
+	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/events"
+	"github.com/filecoin-project/lotus/chain/events/state"
+	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/chain/wallet"
+)
+
+func TestPaymentChannels(t *testing.T, b APIBuilder, blocktime time.Duration) {
+	_ = os.Setenv("BELLMAN_NO_GPU", "1")
+
+	ctx := context.Background()
+	n, sn := b(t, 2, OneMiner)
+
+	paymentCreator := n[0]
+	paymentReceiver := n[1]
+	miner := sn[0]
+
+	// get everyone connected
+	addrs, err := paymentCreator.NetAddrsListen(ctx)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if err := paymentReceiver.NetConnect(ctx, addrs); err != nil {
+		t.Fatal(err)
+	}
+
+	if err := miner.NetConnect(ctx, addrs); err != nil {
+		t.Fatal(err)
+	}
+
+	// start mining blocks
+	bm := NewBlockMiner(ctx, t, miner, blocktime)
+	bm.MineBlocks()
+
+	// send some funds to register the receiver
+	receiverAddr, err := paymentReceiver.WalletNew(ctx, wallet.ActSigType("secp256k1"))
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	SendFunds(ctx, t, paymentCreator, receiverAddr, abi.NewTokenAmount(1e18))
+
+	// setup the payment channel
+	createrAddr, err := paymentCreator.WalletDefaultAddress(ctx)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	channelAmt := int64(100000)
+	channelInfo, err := paymentCreator.PaychGet(ctx, createrAddr, receiverAddr, abi.NewTokenAmount(channelAmt))
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	channel, err := paymentCreator.PaychGetWaitReady(ctx, channelInfo.WaitSentinel)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// allocate three lanes
+	var lanes []uint64
+	for i := 0; i < 3; i++ {
+		lane, err := paymentCreator.PaychAllocateLane(ctx, channel)
+		if err != nil {
+			t.Fatal(err)
+		}
+		lanes = append(lanes, lane)
+	}
+
+	// Make two vouchers each for each lane, then save on the other side
+	// Note that the voucher with a value of 2000 has a higher nonce, so it
+	// supersedes the voucher with a value of 1000
+	for _, lane := range lanes {
+		vouch1, err := paymentCreator.PaychVoucherCreate(ctx, channel, abi.NewTokenAmount(1000), lane)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if vouch1.Voucher == nil {
+			t.Fatal(fmt.Errorf("Not enough funds to create voucher: missing %d", vouch1.Shortfall))
+		}
+		vouch2, err := paymentCreator.PaychVoucherCreate(ctx, channel, abi.NewTokenAmount(2000), lane)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if vouch2.Voucher == nil {
+			t.Fatal(fmt.Errorf("Not enough funds to create voucher: missing %d", vouch2.Shortfall))
+		}
+		delta1, err := paymentReceiver.PaychVoucherAdd(ctx, channel, vouch1.Voucher, nil, abi.NewTokenAmount(1000))
+		if err != nil {
+			t.Fatal(err)
+		}
+		if !delta1.Equals(abi.NewTokenAmount(1000)) {
+			t.Fatal("voucher didn't have the right amount")
+		}
+		delta2, err := paymentReceiver.PaychVoucherAdd(ctx, channel, vouch2.Voucher, nil, abi.NewTokenAmount(1000))
+		if err != nil {
+			t.Fatal(err)
+		}
+		if !delta2.Equals(abi.NewTokenAmount(1000)) {
+			t.Fatal("voucher didn't have the right amount")
+		}
+	}
+
+	// settle the payment channel
+	settleMsgCid, err := paymentCreator.PaychSettle(ctx, channel)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	res := waitForMessage(ctx, t, paymentCreator, settleMsgCid, time.Second*10, "settle")
+	if res.Receipt.ExitCode != 0 {
+		t.Fatal("Unable to settle payment channel")
+	}
+
+	// wait for the receiver to submit their vouchers
+	ev := events.NewEvents(ctx, paymentCreator)
+	preds := state.NewStatePredicates(paymentCreator)
+	finished := make(chan struct{})
+	err = ev.StateChanged(func(ts *types.TipSet) (done bool, more bool, err error) {
+		act, err := paymentCreator.StateReadState(ctx, channel, ts.Key())
+		if err != nil {
+			return false, false, err
+		}
+		state := act.State.(paych.State)
+		if state.ToSend.GreaterThanEqual(abi.NewTokenAmount(6000)) {
+			return true, false, nil
+		}
+		return false, true, nil
+	}, func(oldTs, newTs *types.TipSet, states events.StateChange, curH abi.ChainEpoch) (more bool, err error) {
+		toSendChange := states.(*state.PayChToSendChange)
+		if toSendChange.NewToSend.GreaterThanEqual(abi.NewTokenAmount(6000)) {
+			close(finished)
+			return false, nil
+		}
+		return true, nil
+	}, func(ctx context.Context, ts *types.TipSet) error {
+		return nil
+	}, int(build.MessageConfidence)+1, build.SealRandomnessLookbackLimit, func(oldTs, newTs *types.TipSet) (bool, events.StateChange, error) {
+		return preds.OnPaymentChannelActorChanged(channel, preds.OnToSendAmountChanges())(ctx, oldTs.Key(), newTs.Key())
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	select {
+	case <-finished:
+	case <-time.After(time.Second):
+		t.Fatal("Timed out waiting for receiver to submit vouchers")
+	}
+
+	// wait for the settlement period to pass before collecting
+	waitForBlocks(ctx, t, bm, paymentReceiver, receiverAddr, paych.SettleDelay)
+
+	creatorPreCollectBalance, err := paymentCreator.WalletBalance(ctx, createrAddr)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// collect funds (from receiver, though either party can do it)
+	collectMsg, err := paymentReceiver.PaychCollect(ctx, channel)
+	if err != nil {
+		t.Fatal(err)
+	}
+	res, err = paymentReceiver.StateWaitMsg(ctx, collectMsg, 3)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if res.Receipt.ExitCode != 0 {
+		t.Fatal("unable to collect on payment channel")
+	}
+
+	// Finally, check the balance for the creator
+	currentCreatorBalance, err := paymentCreator.WalletBalance(ctx, createrAddr)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// The highest nonce voucher that the creator sent on each lane is 2000
+	totalVouchers := int64(len(lanes) * 2000)
+
+	// When receiver submits the tokens to the chain, creator should get a
+	// refund on the remaining balance, which is
+	// channel amount - total voucher value
+	expectedRefund := channelAmt - totalVouchers
+	delta := big.Sub(currentCreatorBalance, creatorPreCollectBalance)
+	if !delta.Equals(abi.NewTokenAmount(expectedRefund)) {
+		t.Fatalf("did not send correct funds from creator: expected %d, got %d", expectedRefund, delta)
+	}
+
+	// shut down mining
+	bm.Stop()
+}
+
+func waitForBlocks(ctx context.Context, t *testing.T, bm *BlockMiner, paymentReceiver TestNode, receiverAddr address.Address, count int) {
+	// We need to add null blocks in batches, if we add too many the chain can't sync
+	batchSize := 60
+	for i := 0; i < count; i += batchSize {
+		size := batchSize
+		if i > count {
+			size = count - i
+		}
+
+		// Add a batch of null blocks
+		atomic.StoreInt64(&bm.nulls, int64(size-1))
+
+		// Add a real block
+		m, err := paymentReceiver.MpoolPushMessage(ctx, &types.Message{
+			To:    builtin.BurntFundsActorAddr,
+			From:  receiverAddr,
+			Value: types.NewInt(0),
+		}, nil)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		_, err = paymentReceiver.StateWaitMsg(ctx, m.Cid(), 1)
+		if err != nil {
+			t.Fatal(err)
+		}
+	}
+}
+
+func waitForMessage(ctx context.Context, t *testing.T, paymentCreator TestNode, msgCid cid.Cid, duration time.Duration, desc string) *api.MsgLookup {
+	ctx, cancel := context.WithTimeout(ctx, duration)
+	defer cancel()
+
+	fmt.Println("Waiting for", desc)
+	res, err := paymentCreator.StateWaitMsg(ctx, msgCid, 1)
+	if err != nil {
+		fmt.Println("Error waiting for", desc, err)
+		t.Fatal(err)
+	}
+	if res.Receipt.ExitCode != 0 {
+		t.Fatalf("did not successfully send %s", desc)
+	}
+	fmt.Println("Confirmed", desc)
+	return res
+}
diff --git a/api/test/test.go b/api/test/test.go
index 7925300be..409274ff1 100644
--- a/api/test/test.go
+++ b/api/test/test.go
@@ -4,19 +4,39 @@ import (
 	"context"
 	"testing"
 
+	"github.com/multiformats/go-multiaddr"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/build"
-	"github.com/stretchr/testify/assert"
+	"github.com/filecoin-project/lotus/miner"
 )
 
 type TestNode struct {
 	api.FullNode
+	// ListenAddr is the address on which an API server is listening, if an
+	// API server is created for this Node
+	ListenAddr multiaddr.Multiaddr
 }
 
 type TestStorageNode struct {
 	api.StorageMiner
+	// ListenAddr is the address on which an API server is listening, if an
+	// API server is created for this Node
+	ListenAddr multiaddr.Multiaddr
 
-	MineOne func(context.Context) error
+	MineOne func(context.Context, miner.MineReq) error
+}
+
+var PresealGenesis = -1
+
+const GenesisPreseals = 2
+
+type StorageMiner struct {
+	Full    int
+	Preseal int
 }
 
 // APIBuilder is a function which is invoked in test suite to provide
@@ -24,7 +44,7 @@ type TestStorageNode struct {
 //
 // storage array defines storage nodes, numbers in the array specify full node
 // index the storage node 'belongs' to
-type APIBuilder func(t *testing.T, nFull int, storage []int) ([]TestNode, []TestStorageNode)
+type APIBuilder func(t *testing.T, nFull int, storage []StorageMiner) ([]TestNode, []TestStorageNode)
 type testSuite struct {
 	makeNodes APIBuilder
 }
@@ -39,25 +59,28 @@ func TestApis(t *testing.T, b APIBuilder) {
 	t.Run("id", ts.testID)
 	t.Run("testConnectTwo", ts.testConnectTwo)
 	t.Run("testMining", ts.testMining)
+	t.Run("testMiningReal", ts.testMiningReal)
 }
 
+var OneMiner = []StorageMiner{{Full: 0, Preseal: PresealGenesis}}
+
 func (ts *testSuite) testVersion(t *testing.T) {
+	build.RunningNodeType = build.NodeFull
+
 	ctx := context.Background()
-	apis, _ := ts.makeNodes(t, 1, []int{0})
+	apis, _ := ts.makeNodes(t, 1, OneMiner)
 	api := apis[0]
 
 	v, err := api.Version(ctx)
 	if err != nil {
 		t.Fatal(err)
 	}
-	if v.Version != build.BuildVersion {
-		t.Error("Version didn't work properly")
-	}
+	require.Equal(t, v.Version, build.BuildVersion)
 }
 
 func (ts *testSuite) testID(t *testing.T) {
 	ctx := context.Background()
-	apis, _ := ts.makeNodes(t, 1, []int{0})
+	apis, _ := ts.makeNodes(t, 1, OneMiner)
 	api := apis[0]
 
 	id, err := api.ID(ctx)
@@ -69,7 +92,7 @@ func (ts *testSuite) testID(t *testing.T) {
 
 func (ts *testSuite) testConnectTwo(t *testing.T) {
 	ctx := context.Background()
-	apis, _ := ts.makeNodes(t, 2, []int{0})
+	apis, _ := ts.makeNodes(t, 2, OneMiner)
 
 	p, err := apis[0].NetPeers(ctx)
 	if err != nil {
diff --git a/api/test/util.go b/api/test/util.go
new file mode 100644
index 000000000..8695e2e2e
--- /dev/null
+++ b/api/test/util.go
@@ -0,0 +1,86 @@
+package test
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/filecoin-project/go-state-types/abi"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/miner"
+)
+
+func SendFunds(ctx context.Context, t *testing.T, sender TestNode, addr address.Address, amount abi.TokenAmount) {
+	senderAddr, err := sender.WalletDefaultAddress(ctx)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	msg := &types.Message{
+		From:  senderAddr,
+		To:    addr,
+		Value: amount,
+	}
+
+	sm, err := sender.MpoolPushMessage(ctx, msg, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	res, err := sender.StateWaitMsg(ctx, sm.Cid(), 1)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if res.Receipt.ExitCode != 0 {
+		t.Fatal("did not successfully send money")
+	}
+}
+
+func MineUntilBlock(ctx context.Context, t *testing.T, fn TestNode, sn TestStorageNode, cb func(abi.ChainEpoch)) {
+	for i := 0; i < 1000; i++ {
+		var success bool
+		var err error
+		var epoch abi.ChainEpoch
+		wait := make(chan struct{})
+		mineErr := sn.MineOne(ctx, miner.MineReq{
+			Done: func(win bool, ep abi.ChainEpoch, e error) {
+				success = win
+				err = e
+				epoch = ep
+				wait <- struct{}{}
+			},
+		})
+		if mineErr != nil {
+			t.Fatal(mineErr)
+		}
+		<-wait
+		if err != nil {
+			t.Fatal(err)
+		}
+		if success {
+			// Wait until it shows up on the given full nodes ChainHead
+			nloops := 50
+			for i := 0; i < nloops; i++ {
+				ts, err := fn.ChainHead(ctx)
+				if err != nil {
+					t.Fatal(err)
+				}
+				if ts.Height() == epoch {
+					break
+				}
+				if i == nloops-1 {
+					t.Fatal("block never managed to sync to node")
+				}
+				time.Sleep(time.Millisecond * 10)
+			}
+
+			if cb != nil {
+				cb(epoch)
+			}
+			return
+		}
+		t.Log("did not mine block, trying again", i)
+	}
+	t.Fatal("failed to mine 1000 times in a row...")
+}
diff --git a/api/test/window_post.go b/api/test/window_post.go
new file mode 100644
index 000000000..683489a91
--- /dev/null
+++ b/api/test/window_post.go
@@ -0,0 +1,324 @@
+package test
+
+import (
+	"context"
+	"fmt"
+
+	"os"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/lotus/extern/sector-storage/mock"
+	sealing "github.com/filecoin-project/lotus/extern/storage-sealing"
+
+	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/types"
+	bminer "github.com/filecoin-project/lotus/miner"
+	"github.com/filecoin-project/lotus/node/impl"
+)
+
+func init() {
+	err := os.Setenv("BELLMAN_NO_GPU", "1")
+	if err != nil {
+		panic(fmt.Sprintf("failed to set BELLMAN_NO_GPU env variable: %s", err))
+	}
+}
+
+func TestPledgeSector(t *testing.T, b APIBuilder, blocktime time.Duration, nSectors int) {
+	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)
+	}
+	build.Clock.Sleep(time.Second)
+
+	mine := true
+	done := make(chan struct{})
+	go func() {
+		defer close(done)
+		for mine {
+			build.Clock.Sleep(blocktime)
+			if err := sn[0].MineOne(ctx, bminer.MineReq{Done: func(bool, abi.ChainEpoch, error) {
+
+			}}); err != nil {
+				t.Error(err)
+			}
+		}
+	}()
+
+	pledgeSectors(t, ctx, miner, nSectors, 0, nil)
+
+	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++ {
+		err := miner.PledgeSector(ctx)
+		require.NoError(t, err)
+		if i%3 == 0 && blockNotif != nil {
+			<-blockNotif
+		}
+	}
+
+	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) >= n+existing {
+			break
+		}
+
+		build.Clock.Sleep(100 * time.Millisecond)
+	}
+
+	fmt.Printf("All sectors is fsm\n")
+
+	s, err := miner.SectorsList(ctx)
+	require.NoError(t, err)
+
+	toCheck := map[abi.SectorNumber]struct{}{}
+	for _, number := range s {
+		toCheck[number] = struct{}{}
+	}
+
+	for len(toCheck) > 0 {
+		for n := range toCheck {
+			st, err := miner.SectorsStatus(ctx, n, false)
+			require.NoError(t, err)
+			if st.State == api.SectorState(sealing.Proving) {
+				delete(toCheck, n)
+			}
+			if strings.Contains(string(st.State), "Fail") {
+				t.Fatal("sector in a failed state", st.State)
+			}
+		}
+
+		build.Clock.Sleep(100 * time.Millisecond)
+		fmt.Printf("WaitSeal: %d\n", len(s))
+	}
+}
+
+func TestWindowPost(t *testing.T, b APIBuilder, blocktime time.Duration, nSectors int) {
+	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)
+	}
+	build.Clock.Sleep(time.Second)
+
+	mine := true
+	done := make(chan struct{})
+	go func() {
+		defer close(done)
+		for mine {
+			build.Clock.Sleep(blocktime)
+			if err := sn[0].MineOne(ctx, MineNext); err != nil {
+				t.Error(err)
+			}
+		}
+	}()
+
+	pledgeSectors(t, ctx, miner, nSectors, 0, nil)
+
+	maddr, err := miner.ActorAddress(ctx)
+	require.NoError(t, err)
+
+	di, err := client.StateMinerProvingDeadline(ctx, maddr, types.EmptyTSK)
+	require.NoError(t, err)
+
+	mid, err := address.IDFromAddress(maddr)
+	require.NoError(t, err)
+
+	fmt.Printf("Running one proving period\n")
+
+	for {
+		head, err := client.ChainHead(ctx)
+		require.NoError(t, err)
+
+		if head.Height() > di.PeriodStart+(di.WPoStProvingPeriod)+2 {
+			break
+		}
+
+		if head.Height()%100 == 0 {
+			fmt.Printf("@%d\n", head.Height())
+		}
+		build.Clock.Sleep(blocktime)
+	}
+
+	p, err := client.StateMinerPower(ctx, maddr, types.EmptyTSK)
+	require.NoError(t, err)
+
+	ssz, err := miner.ActorSectorSize(ctx, maddr)
+	require.NoError(t, err)
+
+	require.Equal(t, p.MinerPower, p.TotalPower)
+	require.Equal(t, p.MinerPower.RawBytePower, types.NewInt(uint64(ssz)*uint64(nSectors+GenesisPreseals)))
+
+	fmt.Printf("Drop some sectors\n")
+
+	// Drop 2 sectors from deadline 2 partition 0 (full partition / deadline)
+	{
+		parts, err := client.StateMinerPartitions(ctx, maddr, 2, types.EmptyTSK)
+		require.NoError(t, err)
+		require.Greater(t, len(parts), 0)
+
+		secs := parts[0].AllSectors
+		require.NoError(t, err)
+		n, err := secs.Count()
+		require.NoError(t, err)
+		require.Equal(t, uint64(2), n)
+
+		// Drop the partition
+		err = secs.ForEach(func(sid uint64) error {
+			return miner.StorageMiner.(*impl.StorageMinerAPI).IStorageMgr.(*mock.SectorMgr).MarkCorrupted(abi.SectorID{
+				Miner:  abi.ActorID(mid),
+				Number: abi.SectorNumber(sid),
+			}, true)
+		})
+		require.NoError(t, err)
+	}
+
+	var s abi.SectorID
+
+	// Drop 1 sectors from deadline 3 partition 0
+	{
+		parts, err := client.StateMinerPartitions(ctx, maddr, 3, types.EmptyTSK)
+		require.NoError(t, err)
+		require.Greater(t, len(parts), 0)
+
+		secs := parts[0].AllSectors
+		require.NoError(t, err)
+		n, err := secs.Count()
+		require.NoError(t, err)
+		require.Equal(t, uint64(2), n)
+
+		// Drop the sector
+		sn, err := secs.First()
+		require.NoError(t, err)
+
+		all, err := secs.All(2)
+		require.NoError(t, err)
+		fmt.Println("the sectors", all)
+
+		s = abi.SectorID{
+			Miner:  abi.ActorID(mid),
+			Number: abi.SectorNumber(sn),
+		}
+
+		err = miner.StorageMiner.(*impl.StorageMinerAPI).IStorageMgr.(*mock.SectorMgr).MarkFailed(s, true)
+		require.NoError(t, err)
+	}
+
+	di, err = client.StateMinerProvingDeadline(ctx, maddr, types.EmptyTSK)
+	require.NoError(t, err)
+
+	fmt.Printf("Go through another PP, wait for sectors to become faulty\n")
+
+	for {
+		head, err := client.ChainHead(ctx)
+		require.NoError(t, err)
+
+		if head.Height() > di.PeriodStart+(di.WPoStProvingPeriod)+2 {
+			break
+		}
+
+		if head.Height()%100 == 0 {
+			fmt.Printf("@%d\n", head.Height())
+		}
+		build.Clock.Sleep(blocktime)
+	}
+
+	p, err = client.StateMinerPower(ctx, maddr, types.EmptyTSK)
+	require.NoError(t, err)
+
+	require.Equal(t, p.MinerPower, p.TotalPower)
+
+	sectors := p.MinerPower.RawBytePower.Uint64() / uint64(ssz)
+	require.Equal(t, nSectors+GenesisPreseals-3, int(sectors)) // -3 just removed sectors
+
+	fmt.Printf("Recover one sector\n")
+
+	err = miner.StorageMiner.(*impl.StorageMinerAPI).IStorageMgr.(*mock.SectorMgr).MarkFailed(s, false)
+	require.NoError(t, err)
+
+	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 {
+			break
+		}
+
+		if head.Height()%100 == 0 {
+			fmt.Printf("@%d\n", head.Height())
+		}
+		build.Clock.Sleep(blocktime)
+	}
+
+	p, err = client.StateMinerPower(ctx, maddr, types.EmptyTSK)
+	require.NoError(t, err)
+
+	require.Equal(t, p.MinerPower, p.TotalPower)
+
+	sectors = p.MinerPower.RawBytePower.Uint64() / uint64(ssz)
+	require.Equal(t, nSectors+GenesisPreseals-2, int(sectors)) // -2 not recovered sectors
+
+	// pledge a sector after recovery
+
+	pledgeSectors(t, ctx, miner, 1, nSectors, nil)
+
+	{
+		// wait a bit more
+
+		head, err := client.ChainHead(ctx)
+		require.NoError(t, err)
+
+		waitUntil := head.Height() + 10
+
+		for {
+			head, err := client.ChainHead(ctx)
+			require.NoError(t, err)
+
+			if head.Height() > waitUntil {
+				break
+			}
+		}
+	}
+
+	p, err = client.StateMinerPower(ctx, maddr, types.EmptyTSK)
+	require.NoError(t, err)
+
+	require.Equal(t, p.MinerPower, p.TotalPower)
+
+	sectors = p.MinerPower.RawBytePower.Uint64() / uint64(ssz)
+	require.Equal(t, nSectors+GenesisPreseals-2+1, int(sectors)) // -2 not recovered sectors + 1 just pledged
+
+	mine = false
+	<-done
+}
diff --git a/api/types.go b/api/types.go
index cd2717bbd..a69aa28d9 100644
--- a/api/types.go
+++ b/api/types.go
@@ -2,41 +2,20 @@ package api
 
 import (
 	"encoding/json"
+	"fmt"
 
+	datatransfer "github.com/filecoin-project/go-data-transfer"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/lotus/build"
+	"github.com/ipfs/go-cid"
+
+	"github.com/libp2p/go-libp2p-core/peer"
+	pubsub "github.com/libp2p/go-libp2p-pubsub"
 	ma "github.com/multiformats/go-multiaddr"
 )
 
-type DealState = uint64
-
-const (
-	DealUnknown  = DealState(iota)
-	DealRejected // Provider didn't like the proposal
-	DealAccepted // Proposal accepted, data moved
-	DealStaged   // Data put into the sector
-	DealSealing  // Data in process of being sealed
-
-	DealFailed
-	DealComplete
-
-	// Internal
-
-	DealError // deal failed with an unexpected error
-
-	DealNoUpdate = DealUnknown
-)
-
-var DealStates = []string{
-	"DealUnknown",
-	"DealRejected",
-	"DealAccepted",
-	"DealStaged",
-	"DealSealing",
-	"DealFailed",
-	"DealComplete",
-	"DealError",
-}
-
 // TODO: check if this exists anywhere else
+
 type MultiaddrSlice []ma.Multiaddr
 
 func (m *MultiaddrSlice) UnmarshalJSON(raw []byte) (err error) {
@@ -57,3 +36,74 @@ func (m *MultiaddrSlice) UnmarshalJSON(raw []byte) (err error) {
 }
 
 var _ json.Unmarshaler = new(MultiaddrSlice)
+
+type ObjStat struct {
+	Size  uint64
+	Links uint64
+}
+
+type PubsubScore struct {
+	ID    peer.ID
+	Score *pubsub.PeerScoreSnapshot
+}
+
+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
+	BaseCID     cid.Cid
+	IsInitiator bool
+	IsSender    bool
+	Voucher     string
+	Message     string
+	OtherPeer   peer.ID
+	Transferred uint64
+}
+
+// NewDataTransferChannel constructs an API DataTransferChannel type from full channel state snapshot and a host id
+func NewDataTransferChannel(hostID peer.ID, channelState datatransfer.ChannelState) DataTransferChannel {
+	channel := DataTransferChannel{
+		TransferID: channelState.TransferID(),
+		Status:     channelState.Status(),
+		BaseCID:    channelState.BaseCID(),
+		IsSender:   channelState.Sender() == hostID,
+		Message:    channelState.Message(),
+	}
+	stringer, ok := channelState.Voucher().(fmt.Stringer)
+	if ok {
+		channel.Voucher = stringer.String()
+	} else {
+		voucherJSON, err := json.Marshal(channelState.Voucher())
+		if err != nil {
+			channel.Voucher = fmt.Errorf("Voucher Serialization: %w", err).Error()
+		} else {
+			channel.Voucher = string(voucherJSON)
+		}
+	}
+	if channel.IsSender {
+		channel.IsInitiator = !channelState.IsPull()
+		channel.Transferred = channelState.Sent()
+		channel.OtherPeer = channelState.Recipient()
+	} else {
+		channel.IsInitiator = channelState.IsPull()
+		channel.Transferred = channelState.Received()
+		channel.OtherPeer = channelState.Sender()
+	}
+	return channel
+}
diff --git a/api/utils.go b/api/utils.go
index 0576ad1d4..a9d02c31b 100644
--- a/api/utils.go
+++ b/api/utils.go
@@ -4,12 +4,12 @@ import (
 	"context"
 
 	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/go-state-types/crypto"
 )
 
-type SignFunc = func(context.Context, []byte) (*types.Signature, error)
+type SignFunc = func(context.Context, []byte) (*crypto.Signature, error)
 
-type Signer func(context.Context, address.Address, []byte) (*types.Signature, error)
+type Signer func(context.Context, address.Address, []byte) (*crypto.Signature, error)
 
 type Signable interface {
 	Sign(context.Context, SignFunc) error
@@ -17,7 +17,7 @@ type Signable interface {
 
 func SignWith(ctx context.Context, signer Signer, addr address.Address, signable ...Signable) error {
 	for _, s := range signable {
-		err := s.Sign(ctx, func(ctx context.Context, b []byte) (*types.Signature, error) {
+		err := s.Sign(ctx, func(ctx context.Context, b []byte) (*crypto.Signature, error) {
 			return signer(ctx, addr, b)
 		})
 		if err != nil {
diff --git a/bin/dist_get b/bin/dist_get
deleted file mode 100755
index 39320443a..000000000
--- a/bin/dist_get
+++ /dev/null
@@ -1,177 +0,0 @@
-#!/bin/sh
-
-GOCC=${GOCC=go}
-
-die() {
-	echo "$@" >&2
-	exit 1
-}
-
-have_binary() {
-	type "$1" > /dev/null 2> /dev/null
-}
-
-check_writable() {
-	printf "" > "$1" && rm "$1"
-}
-
-try_download() {
-	url="$1"
-	output="$2"
-	command="$3"
-	util_name="$(set -- $command; echo "$1")"
-
-	if ! have_binary "$util_name"; then
-		return 1
-	fi
-
-	printf '==> Using %s to download "%s" to "%s"\n' "$util_name" "$url" "$output"
-	if eval "$command"; then
-		echo "==> Download complete!"
-		return
-	else
-		echo "error: couldn't download with $util_name ($?)"
-		return 1
-	fi
-}
-
-download() {
-	dl_url="$1"
-	dl_output="$2"
-
-	test "$#" -eq "2" || die "download requires exactly two arguments, was given $@"
-
-	if ! check_writable "$dl_output"; then
-		die "download error: cannot write to $dl_output"
-	fi
-
-	try_download "$dl_url" "$dl_output" "wget '$dl_url' -O '$dl_output'" && return
-	try_download "$dl_url" "$dl_output" "curl --silent --fail --output '$dl_output' '$dl_url'" && return
-	try_download "$dl_url" "$dl_output" "fetch '$dl_url' -o '$dl_output'" && return
-	try_download "$dl_url" "$dl_output" "http '$dl_url' > '$dl_output'" && return
-	try_download "$dl_url" "$dl_output" "ftp -o '$dl_output' '$dl_url'" && return
-
-	die "Unable to download $dl_url. exiting."
-}
-
-unarchive() {
-	ua_archivetype="$1"
-	ua_infile="$2"
-	ua_outfile="$3"
-	ua_distname="$4"
-	ua_binpostfix=""
-	ua_os=$(uname -o)
-
-	if [ "$ua_os" = "Msys" ] || [ "$ua_os" = "Cygwin" ] ; then
-	    ua_binpostfix=".exe"
-	fi
-	ua_outfile="$ua_outfile$ua_binpostfix"
-
-	if ! check_writable "$ua_outfile"; then
-		die "unarchive error: cannot write to $ua_outfile"
-	fi
-
-	case "$ua_archivetype" in
-		tar.gz)
-			if have_binary tar; then
-				echo "==> using 'tar' to extract binary from archive"
-				< "$ua_infile" tar -Ozxf - "$ua_distname/$ua_distname$ua_binpostfix" > "$ua_outfile" \
-					|| die "tar has failed"
-			else
-				die "no binary on system for extracting tar files"
-			fi
-			;;
-		zip)
-			if have_binary unzip; then
-				echo "==> using 'unzip' to extract binary from archive"
-				unzip -p "$ua_infile" "$ua_distname/$ua_distname$ua_binpostfix" > "$ua_outfile" \
-					|| die "unzip has failed"
-			else
-				die "no installed method for extracting .zip archives"
-			fi
-			;;
-		*)
-			die "unrecognized archive type '$ua_archivetype'"
-	esac
-
-	chmod +x "$ua_outfile" || die "chmod has failed"
-}
-
-get_go_vars() {
-	if [ ! -z "$GOOS" ] && [ ! -z "$GOARCH" ]; then
-		printf "%s-%s" "$GOOS" "$GOARCH"
-	elif have_binary go; then
-		printf "%s-%s" "$($GOCC env GOOS)" "$($GOCC env GOARCH)"
-	else
-		die "no way of determining system GOOS and GOARCH\nPlease manually set GOOS and GOARCH then retry."
-	fi
-}
-
-mkurl() {
-	m_root="$1"
-	m_name="$2"
-	m_vers="$3"
-	m_archive="$4"
-	m_govars=$(get_go_vars) || die "could not get go env vars"
-
-	echo "https://ipfs.io$m_root/$m_name/$m_vers/${m_name}_${m_vers}_$m_govars.$m_archive"
-}
-
-distroot="$1"
-distname="$2"
-outpath="$3"
-version="$4"
-
-if [ -z "$distroot" ] || [ -z "$distname" ] || [ -z "$outpath" ] || [ -z "$version" ]; then
-	die "usage: dist_get <distroot> <distname> <outpath> <version>"
-fi
-
-case $version in
-	v*)
-		# correct input
-		;;
-	*)
-		echo "invalid version '$version'" >&2
-		die "versions must begin with 'v', for example: v0.4.0"
-		;;
-esac
-
-# TODO: don't depend on the go tool being installed to detect this
-goenv=$(get_go_vars) || die "could not get go env vars"
-
-case $goenv in
-	linux-*)
-		archive="tar.gz"
-		;;
-	darwin-*)
-		archive="tar.gz"
-		;;
-	windows-*)
-		archive="zip"
-		;;
-	freebsd-*)
-		archive="tar.gz"
-		;;
-	openbsd-*)
-		archive="tar.gz"
-		;;
-	*)
-		echo "unrecognized system environment: $goenv" >&2
-		die "currently only linux, darwin, windows and freebsd are supported by this script"
-esac
-
-
-mkdir -p bin/tmp
-
-url=$(mkurl "$distroot" "$distname" "$version" "$archive")
-tmpfi="bin/tmp/$distname.$archive"
-
-download "$url" "$tmpfi"
-if [ $? -ne 0 ]; then
-	die "failed to download $url to $tmpfi"
-fi
-
-unarchive "$archive" "$tmpfi" "$outpath" "$distname"
-if [ $? -ne 0 ]; then
-	die "failed to extract archive $tmpfi"
-fi
diff --git a/build/bootstrap.go b/build/bootstrap.go
index ca6cc26ce..80c1529ff 100644
--- a/build/bootstrap.go
+++ b/build/bootstrap.go
@@ -13,6 +13,10 @@ import (
 )
 
 func BuiltinBootstrap() ([]peer.AddrInfo, error) {
+	if DisableBuiltinAssets {
+		return nil, nil
+	}
+
 	var out []peer.AddrInfo
 
 	b := rice.MustFindBox("bootstrap")
diff --git a/build/bootstrap/bootstrappers.pi b/build/bootstrap/bootstrappers.pi
index 802f1471a..9b05a821c 100644
--- a/build/bootstrap/bootstrappers.pi
+++ b/build/bootstrap/bootstrappers.pi
@@ -1,8 +1,9 @@
-/dns4/lotus-bootstrap-0.dfw.fil-test.net/tcp/1347/p2p/12D3KooWHwGBSiLR5ts7KW9MgH4BMzC2iXe18kwAQ8Ee3LUd1jeR
-/dns4/lotus-bootstrap-1.dfw.fil-test.net/tcp/1347/p2p/12D3KooWCLFaawdhLGcSpiqg43DtZ9QzPQ6HcB8Vvyu2Cnta8UWc
-/dns4/lotus-bootstrap-0.fra.fil-test.net/tcp/1347/p2p/12D3KooWMmaL7eaUCF6tVAghVmgozxz4uztbuFUQv6dyFpHRarHR
-/dns4/lotus-bootstrap-1.fra.fil-test.net/tcp/1347/p2p/12D3KooWLLpNYoKdf9NgcWudBhXLdTcXncqAsTzozw1scMMu6nS5
-/dns4/lotus-bootstrap-0.sin.fil-test.net/tcp/1347/p2p/12D3KooWCNL9vXaXwNs3Bu8uRAJK4pxpCyPeM7jZLSDpJma1wrV8
-/dns4/lotus-bootstrap-1.sin.fil-test.net/tcp/1347/p2p/12D3KooWNGGxFda1eC5U2YKAgs4ypoFHn3Z3xHCsjmFdrCcytoxm
+/dns4/bootstrap-0.testnet.fildev.network/tcp/1347/p2p/12D3KooWJTUBUjtzWJGWU1XSiY21CwmHaCNLNYn2E7jqHEHyZaP7
+/dns4/bootstrap-1.testnet.fildev.network/tcp/1347/p2p/12D3KooW9yeKXha4hdrJKq74zEo99T8DhriQdWNoojWnnQbsgB3v
+/dns4/bootstrap-2.testnet.fildev.network/tcp/1347/p2p/12D3KooWCrx8yVG9U9Kf7w8KLN3Edkj5ZKDhgCaeMqQbcQUoB6CT
+/dns4/bootstrap-4.testnet.fildev.network/tcp/1347/p2p/12D3KooWPkL9LrKRQgHtq7kn9ecNhGU9QaziG8R5tX8v9v7t3h34
+/dns4/bootstrap-3.testnet.fildev.network/tcp/1347/p2p/12D3KooWKYSsbpgZ3HAjax5M1BXCwXLa6gVkUARciz7uN3FNtr7T
+/dns4/bootstrap-5.testnet.fildev.network/tcp/1347/p2p/12D3KooWQYzqnLASJAabyMpPb1GcWZvNSe7JDcRuhdRqonFoiK9W
+/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/bootstrap-1.starpool.in/tcp/12757/p2p/12D3KooWQZrGH1PxSNZPum99M1zNvjNFM33d1AAu5DcvdHptuU7u
\ No newline at end of file
diff --git a/build/clock.go b/build/clock.go
new file mode 100644
index 000000000..a3943897d
--- /dev/null
+++ b/build/clock.go
@@ -0,0 +1,10 @@
+package build
+
+import "github.com/raulk/clock"
+
+// Clock is the global clock for the system. In standard builds,
+// we use a real-time clock, which maps to the `time` package.
+//
+// Tests that need control of time can replace this variable with
+// clock.NewMock(). Always use real time for socket/stream deadlines.
+var Clock = clock.New()
diff --git a/build/drand.go b/build/drand.go
new file mode 100644
index 000000000..73299249a
--- /dev/null
+++ b/build/drand.go
@@ -0,0 +1,83 @@
+package build
+
+import (
+	"sort"
+
+	"github.com/filecoin-project/lotus/node/modules/dtypes"
+)
+
+type DrandEnum int
+
+func DrandConfigSchedule() dtypes.DrandSchedule {
+	out := dtypes.DrandSchedule{}
+	for start, config := range DrandSchedule {
+		out = append(out, dtypes.DrandPoint{Start: start, Config: DrandConfigs[config]})
+	}
+
+	sort.Slice(out, func(i, j int) bool {
+		return out[i].Start < out[j].Start
+	})
+
+	return out
+}
+
+const (
+	DrandMainnet DrandEnum = iota + 1
+	DrandTestnet
+	DrandDevnet
+	DrandLocalnet
+	DrandIncentinet
+)
+
+var DrandConfigs = map[DrandEnum]dtypes.DrandConfig{
+	DrandMainnet: {
+		Servers: []string{
+			"https://api.drand.sh",
+			"https://api2.drand.sh",
+			"https://api3.drand.sh",
+		},
+		Relays: []string{
+			"/dnsaddr/api.drand.sh/",
+			"/dnsaddr/api2.drand.sh/",
+			"/dnsaddr/api3.drand.sh/",
+		},
+		ChainInfoJSON: `{"public_key":"868f005eb8e6e4ca0a47c8a77ceaa5309a47978a7c71bc5cce96366b5d7a569937c529eeda66c7293784a9402801af31","period":30,"genesis_time":1595431050,"hash":"8990e7a9aaed2ffed73dbd7092123d6f289930540d7651336225dc172e51b2ce","groupHash":"176f93498eac9ca337150b46d21dd58673ea4e3581185f869672e59fa4cb390a"}`,
+	},
+	DrandTestnet: {
+		Servers: []string{
+			"https://pl-eu.testnet.drand.sh",
+			"https://pl-us.testnet.drand.sh",
+			"https://pl-sin.testnet.drand.sh",
+		},
+		Relays: []string{
+			"/dnsaddr/pl-eu.testnet.drand.sh/",
+			"/dnsaddr/pl-us.testnet.drand.sh/",
+			"/dnsaddr/pl-sin.testnet.drand.sh/",
+		},
+		ChainInfoJSON: `{"public_key":"922a2e93828ff83345bae533f5172669a26c02dc76d6bf59c80892e12ab1455c229211886f35bb56af6d5bea981024df","period":25,"genesis_time":1590445175,"hash":"84b2234fb34e835dccd048255d7ad3194b81af7d978c3bf157e3469592ae4e02","groupHash":"4dd408e5fdff9323c76a9b6f087ba8fdc5a6da907bd9217d9d10f2287d081957"}`,
+	},
+	DrandDevnet: {
+		Servers: []string{
+			"https://dev1.drand.sh",
+			"https://dev2.drand.sh",
+		},
+		Relays: []string{
+			"/dnsaddr/dev1.drand.sh/",
+			"/dnsaddr/dev2.drand.sh/",
+		},
+		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"}`,
+	},
+}
diff --git a/build/flags.go b/build/flags.go
new file mode 100644
index 000000000..33e9f6ede
--- /dev/null
+++ b/build/flags.go
@@ -0,0 +1,15 @@
+package build
+
+// DisableBuiltinAssets disables the resolution of go.rice boxes that store
+// built-in assets, such as proof parameters, bootstrap peers, genesis blocks,
+// etc.
+//
+// When this value is set to true, it is expected that the user will
+// provide any such configurations through the Lotus API itself.
+//
+// This is useful when you're using Lotus as a library, such as to orchestrate
+// test scenarios, or for other purposes where you don't need to use the
+// defaults shipped with the binary.
+//
+// For this flag to be effective, it must be enabled _before_ instantiating Lotus.
+var DisableBuiltinAssets = false
diff --git a/build/forks.go b/build/forks.go
index 8e8f53abe..5c93a9353 100644
--- a/build/forks.go
+++ b/build/forks.go
@@ -1,4 +1 @@
 package build
-
-const ForkCCM = 1750
-const ForkNoPowerEPSUpdates = 16450
diff --git a/build/genesis.go b/build/genesis.go
index cdcf0402e..dc4ded273 100644
--- a/build/genesis.go
+++ b/build/genesis.go
@@ -2,7 +2,7 @@ package build
 
 import (
 	rice "github.com/GeertJohan/go.rice"
-	logging "github.com/ipfs/go-log"
+	logging "github.com/ipfs/go-log/v2"
 )
 
 // moved from now-defunct build/paramfetch.go
@@ -11,12 +11,12 @@ var log = logging.Logger("build")
 func MaybeGenesis() []byte {
 	builtinGen, err := rice.FindBox("genesis")
 	if err != nil {
-		log.Warn("loading built-in genesis: %s", err)
+		log.Warnf("loading built-in genesis: %s", err)
 		return nil
 	}
 	genBytes, err := builtinGen.Bytes("devnet.car")
 	if err != nil {
-		log.Warn("loading built-in genesis: %s", err)
+		log.Warnf("loading built-in genesis: %s", err)
 	}
 
 	return genBytes
diff --git a/build/genesis/devnet.car b/build/genesis/devnet.car
index d0aef2486..f1b3f342a 100644
Binary files a/build/genesis/devnet.car and b/build/genesis/devnet.car differ
diff --git a/build/parameters.go b/build/parameters.go
index 433fa497b..7d34a7831 100644
--- a/build/parameters.go
+++ b/build/parameters.go
@@ -2,4 +2,6 @@ package build
 
 import rice "github.com/GeertJohan/go.rice"
 
-var ParametersJson = rice.MustFindBox("proof-params").MustBytes("parameters.json")
+func ParametersJSON() []byte {
+	return rice.MustFindBox("proof-params").MustBytes("parameters.json")
+}
diff --git a/build/params_2k.go b/build/params_2k.go
new file mode 100644
index 000000000..3682f7be1
--- /dev/null
+++ b/build/params_2k.go
@@ -0,0 +1,41 @@
+// +build debug 2k
+
+package build
+
+import (
+	"github.com/filecoin-project/go-state-types/abi"
+
+	"github.com/filecoin-project/lotus/chain/actors/policy"
+)
+
+const UpgradeBreezeHeight = -1
+const BreezeGasTampingDuration = 0
+
+const UpgradeSmokeHeight = -1
+const UpgradeIgnitionHeight = -2
+const UpgradeLiftoffHeight = -3
+
+var DrandSchedule = map[abi.ChainEpoch]DrandEnum{
+	0: DrandMainnet,
+}
+
+func init() {
+	policy.SetSupportedProofTypes(abi.RegisteredSealProof_StackedDrg2KiBV1)
+	policy.SetConsensusMinerMinPower(abi.NewStoragePower(2048))
+	policy.SetMinVerifiedDealSize(abi.NewStoragePower(256))
+
+	BuildType |= Build2k
+}
+
+const BlockDelaySecs = uint64(4)
+
+const PropagationDelaySecs = uint64(1)
+
+// SlashablePowerDelay is the number of epochs after ElectionPeriodStart, after
+// which the miner is slashed
+//
+// Epochs
+const SlashablePowerDelay = 20
+
+// Epochs
+const InteractivePoRepConfidence = 6
diff --git a/build/params_debug.go b/build/params_debug.go
index 938b03925..f679c9178 100644
--- a/build/params_debug.go
+++ b/build/params_debug.go
@@ -2,36 +2,9 @@
 
 package build
 
-import "os"
-
-var SectorSizes = []uint64{1024}
-
-// Seconds
-const BlockDelay = 6
-
-const PropagationDelay = 3
-
-// FallbackPoStDelay is the number of epochs the miner needs to wait after
-//  ElectionPeriodStart before starting fallback post computation
-//
-// Epochs
-const FallbackPoStDelay = 10
-
-// SlashablePowerDelay is the number of epochs after ElectionPeriodStart, after
-// which the miner is slashed
-//
-// Epochs
-const SlashablePowerDelay = 20
-
-// Epochs
-const InteractivePoRepDelay = 2
-
-// Epochs
-const InteractivePoRepConfidence = 6
-
-// Bytes
-var MinimumMinerPower uint64 = 2 << 10 // 2KiB
-
 func init() {
-	os.Setenv("TRUST_PARAMS", "1")
+	InsecurePoStValidation = true
+	BuildType |= BuildDebug
 }
+
+// NOTE: Also includes settings from params_2k
diff --git a/build/params_shared.go b/build/params_shared.go
deleted file mode 100644
index ec4982cc1..000000000
--- a/build/params_shared.go
+++ /dev/null
@@ -1,99 +0,0 @@
-package build
-
-import (
-	"math/big"
-)
-
-// Core network constants
-
-// /////
-// Storage
-
-const UnixfsChunkSize uint64 = 1 << 20
-const UnixfsLinksPerLevel = 1024
-
-func SupportedSectorSize(ssize uint64) bool {
-	for _, ss := range SectorSizes {
-		if ssize == ss {
-			return true
-		}
-	}
-	return false
-}
-
-// /////
-// Payments
-
-// Epochs
-const PaymentChannelClosingDelay = 6 * 60 * 60 / BlockDelay // six hours
-
-// /////
-// Consensus / Network
-
-// Seconds
-const AllowableClockDrift = 1
-
-// Epochs
-const ForkLengthThreshold = Finality
-
-// Blocks (e)
-const BlocksPerEpoch = 5
-
-// Epochs
-const Finality = 500
-
-// constants for Weight calculation
-// The ratio of weight contributed by short-term vs long-term factors in a given round
-const WRatioNum = int64(1)
-const WRatioDen = 2
-
-// /////
-// Proofs
-
-// Epochs
-const SealRandomnessLookback = Finality
-
-// Epochs
-const SealRandomnessLookbackLimit = SealRandomnessLookback + 2000
-
-// /////
-// Mining
-
-// Epochs
-const EcRandomnessLookback = 300
-
-const PowerCollateralProportion = 5
-const PerCapitaCollateralProportion = 1
-const CollateralPrecision = 1000
-
-// /////
-// Devnet settings
-
-const TotalFilecoin = 2_000_000_000
-const MiningRewardTotal = 1_400_000_000
-
-const InitialRewardStr = "153856861913558700202"
-
-var InitialReward *big.Int
-
-const FilecoinPrecision = 1_000_000_000_000_000_000
-
-// TODO: Move other important consts here
-
-func init() {
-	InitialReward = new(big.Int)
-
-	var ok bool
-	InitialReward, ok = InitialReward.
-		SetString(InitialRewardStr, 10)
-	if !ok {
-		panic("could not parse InitialRewardStr")
-	}
-}
-
-// Sync
-const BadBlockCacheSize = 1 << 15
-
-// assuming 4000 messages per round, this lets us not lose any messages across a
-// 10 block reorg.
-const BlsSignatureCacheSize = 40000
diff --git a/build/params_shared_funcs.go b/build/params_shared_funcs.go
new file mode 100644
index 000000000..28567d3d1
--- /dev/null
+++ b/build/params_shared_funcs.go
@@ -0,0 +1,52 @@
+package build
+
+import (
+	"sort"
+
+	"github.com/filecoin-project/go-address"
+
+	"github.com/libp2p/go-libp2p-core/protocol"
+
+	"github.com/filecoin-project/go-state-types/abi"
+	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
+
+	"github.com/filecoin-project/lotus/node/modules/dtypes"
+)
+
+func DefaultSectorSize() abi.SectorSize {
+	szs := make([]abi.SectorSize, 0, len(miner0.SupportedProofTypes))
+	for spt := range miner0.SupportedProofTypes {
+		ss, err := spt.SectorSize()
+		if err != nil {
+			panic(err)
+		}
+
+		szs = append(szs, ss)
+	}
+
+	sort.Slice(szs, func(i, j int) bool {
+		return szs[i] < szs[j]
+	})
+
+	return szs[0]
+}
+
+// Core network constants
+
+func BlocksTopic(netName dtypes.NetworkName) string   { return "/fil/blocks/" + string(netName) }
+func MessagesTopic(netName dtypes.NetworkName) string { return "/fil/msgs/" + string(netName) }
+func DhtProtocolName(netName dtypes.NetworkName) protocol.ID {
+	return protocol.ID("/fil/kad/" + string(netName))
+}
+
+func UseNewestNetwork() bool {
+	// TODO: Put these in a container we can iterate over
+	if UpgradeBreezeHeight <= 0 && UpgradeSmokeHeight <= 0 {
+		return true
+	}
+	return false
+}
+
+func SetAddressNetwork(n address.Network) {
+	address.CurrentNetwork = n
+}
diff --git a/build/params_shared_vals.go b/build/params_shared_vals.go
new file mode 100644
index 000000000..33828f954
--- /dev/null
+++ b/build/params_shared_vals.go
@@ -0,0 +1,121 @@
+// +build !testground
+
+package build
+
+import (
+	"math/big"
+	"os"
+
+	"github.com/filecoin-project/go-address"
+
+	"github.com/filecoin-project/go-state-types/network"
+
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/specs-actors/actors/builtin"
+	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
+)
+
+// /////
+// Storage
+
+const UnixfsChunkSize uint64 = 1 << 20
+const UnixfsLinksPerLevel = 1024
+
+// /////
+// Consensus / Network
+
+const AllowableClockDriftSecs = uint64(1)
+const NewestNetworkVersion = network.Version3
+const ActorUpgradeNetworkVersion = network.Version4
+
+// Epochs
+const ForkLengthThreshold = Finality
+
+// Blocks (e)
+var BlocksPerEpoch = uint64(builtin.ExpectedLeadersPerEpoch)
+
+// Epochs
+const Finality = miner0.ChainFinality
+const MessageConfidence = uint64(5)
+
+// constants for Weight calculation
+// The ratio of weight contributed by short-term vs long-term factors in a given round
+const WRatioNum = int64(1)
+const WRatioDen = uint64(2)
+
+// /////
+// Proofs
+
+// Epochs
+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
+
+// Epochs
+const TicketRandomnessLookback = abi.ChainEpoch(1)
+
+const WinningPoStSectorSetLookback = abi.ChainEpoch(10)
+
+// /////
+// Address
+
+const AddressMainnetEnvVar = "_mainnet_"
+
+// /////
+// 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)
+
+var InitialRewardBalance *big.Int
+
+// TODO: Move other important consts here
+
+func init() {
+	InitialRewardBalance = big.NewInt(int64(FilAllocStorageMining))
+	InitialRewardBalance = InitialRewardBalance.Mul(InitialRewardBalance, big.NewInt(int64(FilecoinPrecision)))
+
+	if os.Getenv("LOTUS_ADDRESS_TYPE") == AddressMainnetEnvVar {
+		SetAddressNetwork(address.Mainnet)
+	}
+}
+
+// Sync
+const BadBlockCacheSize = 1 << 15
+
+// assuming 4000 messages per round, this lets us not lose any messages across a
+// 10 block reorg.
+const BlsSignatureCacheSize = 40000
+
+// Size of signature verification cache
+// 32k keeps the cache around 10MB in size, max
+const VerifSigCacheSize = 32000
+
+// ///////
+// Limits
+
+// TODO: If this is gonna stay, it should move to specs-actors
+const BlockMessageLimit = 10000
+
+const BlockGasLimit = 10_000_000_000
+const BlockGasTarget = BlockGasLimit / 2
+const BaseFeeMaxChangeDenom = 8 // 12.5%
+const InitialBaseFee = 100e6
+const MinimumBaseFee = 100
+const PackingEfficiencyNum = 4
+const PackingEfficiencyDenom = 5
+
+// Actor consts
+// TODO: Pull from actors when its made not private
+var MinDealDuration = abi.ChainEpoch(180 * builtin.EpochsInDay)
diff --git a/build/params_testground.go b/build/params_testground.go
new file mode 100644
index 000000000..07cc88688
--- /dev/null
+++ b/build/params_testground.go
@@ -0,0 +1,89 @@
+// +build testground
+
+// This file makes hardcoded parameters (const) configurable as vars.
+//
+// Its purpose is to unlock various degrees of flexibility and parametrization
+// when writing Testground plans for Lotus.
+//
+package build
+
+import (
+	"math/big"
+
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/network"
+	"github.com/filecoin-project/specs-actors/actors/builtin"
+	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
+)
+
+var (
+	UnixfsChunkSize     = uint64(1 << 20)
+	UnixfsLinksPerLevel = 1024
+
+	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(builtin.EpochDurationSeconds)
+	PropagationDelaySecs  = uint64(6)
+
+	AllowableClockDriftSecs = uint64(1)
+
+	Finality            = miner0.ChainFinality
+	ForkLengthThreshold = Finality
+
+	SlashablePowerDelay        = 20
+	InteractivePoRepConfidence = 6
+
+	MessageConfidence uint64 = 5
+
+	WRatioNum = int64(1)
+	WRatioDen = uint64(2)
+
+	BadBlockCacheSize     = 1 << 15
+	BlsSignatureCacheSize = 40000
+	VerifSigCacheSize     = 32000
+
+	SealRandomnessLookback      = Finality
+	SealRandomnessLookbackLimit = SealRandomnessLookback + 2000
+	MaxSealLookback             = SealRandomnessLookbackLimit + 2000
+
+	TicketRandomnessLookback     = abi.ChainEpoch(1)
+	WinningPoStSectorSetLookback = abi.ChainEpoch(10)
+
+	FilBase               uint64 = 2_000_000_000
+	FilAllocStorageMining uint64 = 1_400_000_000
+
+	FilecoinPrecision uint64 = 1_000_000_000_000_000_000
+
+	InitialRewardBalance = func() *big.Int {
+		v := big.NewInt(int64(FilAllocStorageMining))
+		v = v.Mul(v, big.NewInt(int64(FilecoinPrecision)))
+		return v
+	}()
+	// Actor consts
+	// TODO: Pull from actors when its made not private
+	MinDealDuration = abi.ChainEpoch(180 * builtin.EpochsInDay)
+
+	PackingEfficiencyNum   int64 = 4
+	PackingEfficiencyDenom int64 = 5
+
+	UpgradeBreezeHeight      abi.ChainEpoch = -1
+	BreezeGasTampingDuration abi.ChainEpoch = 0
+
+	UpgradeSmokeHeight    abi.ChainEpoch = -1
+	UpgradeIgnitionHeight abi.ChainEpoch = -2
+	UpgradeLiftoffHeight  abi.ChainEpoch = -3
+
+	DrandSchedule = map[abi.ChainEpoch]DrandEnum{
+		0: DrandMainnet,
+	}
+
+	NewestNetworkVersion       = network.Version2
+	ActorUpgradeNetworkVersion = network.Version3
+
+	Devnet = true
+)
diff --git a/build/params_testnet.go b/build/params_testnet.go
index aa75ebcd7..960f3a9b6 100644
--- a/build/params_testnet.go
+++ b/build/params_testnet.go
@@ -1,34 +1,42 @@
 // +build !debug
+// +build !2k
+// +build !testground
 
 package build
 
-var SectorSizes = []uint64{
-	1 << 30,
-	32 << 30,
+import (
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/lotus/chain/actors/policy"
+
+	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
+)
+
+var DrandSchedule = map[abi.ChainEpoch]DrandEnum{
+	0:                  DrandIncentinet,
+	UpgradeSmokeHeight: DrandMainnet,
 }
 
-// Seconds
-const BlockDelay = 45
+const UpgradeBreezeHeight = 41280
+const BreezeGasTampingDuration = 120
 
-const PropagationDelay = 6
+const UpgradeSmokeHeight = 51000
 
-// FallbackPoStDelay is the number of epochs the miner needs to wait after
-//  ElectionPeriodStart before starting fallback post computation
-//
-// Epochs
-const FallbackPoStDelay = 30
+const UpgradeIgnitionHeight = 94000
 
-// SlashablePowerDelay is the number of epochs after ElectionPeriodStart, after
-// which the miner is slashed
-//
-// Epochs
-const SlashablePowerDelay = 200
+// 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
 
-// Epochs
-const InteractivePoRepDelay = 8
+func init() {
+	policy.SetConsensusMinerMinPower(abi.NewStoragePower(10 << 40))
+	policy.SetSupportedProofTypes(
+		abi.RegisteredSealProof_StackedDrg32GiBV1,
+		abi.RegisteredSealProof_StackedDrg64GiBV1,
+	)
+	Devnet = false
+}
 
-// Epochs
-const InteractivePoRepConfidence = 6
+const BlockDelaySecs = uint64(builtin0.EpochDurationSeconds)
 
-// Bytes
-var MinimumMinerPower uint64 = 512 << 30 // 512GB
+const PropagationDelaySecs = uint64(6)
diff --git a/build/proof-params/parameters.json b/build/proof-params/parameters.json
index 7e1988a41..1d4584454 100644
--- a/build/proof-params/parameters.json
+++ b/build/proof-params/parameters.json
@@ -1,103 +1,152 @@
 {
-  "v20-proof-of-spacetime-election-5f585aca354eb68e411c8582ed0efd800792430e4e76d73468c4fc03f1a8d6d2.params": {
-    "cid": "QmX7tYeNPWae2fjZ3Am6GB9dmHvLqvoz8dKo3PR98VYxH9",
-    "digest": "39a9edec3355516674f0d12b926be493",
+  "v28-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-0-0-0170db1f394b35d995252228ee359194b13199d259380541dc529fb0099096b0.params": {
+    "cid": "QmVxjFRyhmyQaZEtCh7nk2abc7LhFkzhnRX4rcHqCCpikR",
+    "digest": "7610b9f82bfc88405b7a832b651ce2f6",
+    "sector_size": 2048
+  },
+  "v28-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-0-0-0170db1f394b35d995252228ee359194b13199d259380541dc529fb0099096b0.vk": {
+    "cid": "QmcS5JZs8X3TdtkEBpHAdUYjdNDqcL7fWQFtQz69mpnu2X",
+    "digest": "0e0958009936b9d5e515ec97b8cb792d",
+    "sector_size": 2048
+  },
+  "v28-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-0-0-0cfb4f178bbb71cf2ecfcd42accce558b27199ab4fb59cb78f2483fe21ef36d9.params": {
+    "cid": "QmUiRx71uxfmUE8V3H9sWAsAXoM88KR4eo1ByvvcFNeTLR",
+    "digest": "1a7d4a9c8a502a497ed92a54366af33f",
+    "sector_size": 536870912
+  },
+  "v28-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-0-0-0cfb4f178bbb71cf2ecfcd42accce558b27199ab4fb59cb78f2483fe21ef36d9.vk": {
+    "cid": "QmfCeddjFpWtavzfEzZpJfzSajGNwfL4RjFXWAvA9TSnTV",
+    "digest": "4dae975de4f011f101f5a2f86d1daaba",
+    "sector_size": 536870912
+  },
+  "v28-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-0-0-3ea05428c9d11689f23529cde32fd30aabd50f7d2c93657c1d3650bca3e8ea9e.params": {
+    "cid": "QmcSTqDcFVLGGVYz1njhUZ7B6fkKtBumsLUwx4nkh22TzS",
+    "digest": "82c88066be968bb550a05e30ff6c2413",
+    "sector_size": 2048
+  },
+  "v28-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-0-0-3ea05428c9d11689f23529cde32fd30aabd50f7d2c93657c1d3650bca3e8ea9e.vk": {
+    "cid": "QmSTCXF2ipGA3f6muVo6kHc2URSx6PzZxGUqu7uykaH5KU",
+    "digest": "ffd79788d614d27919ae5bd2d94eacb6",
+    "sector_size": 2048
+  },
+  "v28-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-0-0-50c7368dea9593ed0989e70974d28024efa9d156d585b7eea1be22b2e753f331.params": {
+    "cid": "QmU9SBzJNrcjRFDiFc4GcApqdApN6z9X7MpUr66mJ2kAJP",
+    "digest": "700171ecf7334e3199437c930676af82",
+    "sector_size": 8388608
+  },
+  "v28-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-0-0-50c7368dea9593ed0989e70974d28024efa9d156d585b7eea1be22b2e753f331.vk": {
+    "cid": "QmbmUMa3TbbW3X5kFhExs6WgC4KeWT18YivaVmXDkB6ANG",
+    "digest": "79ebb55f56fda427743e35053edad8fc",
+    "sector_size": 8388608
+  },
+  "v28-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-0-0-5294475db5237a2e83c3e52fd6c2b03859a1831d45ed08c4f35dbf9a803165a9.params": {
+    "cid": "QmdNEL2RtqL52GQNuj8uz6mVj5Z34NVnbaJ1yMyh1oXtBx",
+    "digest": "c49499bb76a0762884896f9683403f55",
+    "sector_size": 8388608
+  },
+  "v28-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-0-0-5294475db5237a2e83c3e52fd6c2b03859a1831d45ed08c4f35dbf9a803165a9.vk": {
+    "cid": "QmUiVYCQUgr6Y13pZFr8acWpSM4xvTXUdcvGmxyuHbKhsc",
+    "digest": "34d4feeacd9abf788d69ef1bb4d8fd00",
+    "sector_size": 8388608
+  },
+  "v28-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-0-0-7d739b8cf60f1b0709eeebee7730e297683552e4b69cab6984ec0285663c5781.params": {
+    "cid": "QmVgCsJFRXKLuuUhT3aMYwKVGNA9rDeR6DCrs7cAe8riBT",
+    "digest": "827359440349fe8f5a016e7598993b79",
+    "sector_size": 536870912
+  },
+  "v28-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-0-0-7d739b8cf60f1b0709eeebee7730e297683552e4b69cab6984ec0285663c5781.vk": {
+    "cid": "QmfA31fbCWojSmhSGvvfxmxaYCpMoXP95zEQ9sLvBGHNaN",
+    "digest": "bd2cd62f65c1ab84f19ca27e97b7c731",
+    "sector_size": 536870912
+  },
+  "v28-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-8-0-0377ded656c6f524f1618760bffe4e0a1c51d5a70c4509eedae8a27555733edc.params": {
+    "cid": "QmaUmfcJt6pozn8ndq1JVBzLRjRJdHMTPd4foa8iw5sjBZ",
+    "digest": "2cf49eb26f1fee94c85781a390ddb4c8",
     "sector_size": 34359738368
   },
-  "v20-proof-of-spacetime-election-5f585aca354eb68e411c8582ed0efd800792430e4e76d73468c4fc03f1a8d6d2.vk": {
-    "cid": "QmbNGx7pNbGiEr8ykoHxVXHW2LNSmGdsxKtj1onZCyguCX",
-    "digest": "0227ae7df4f2affe529ebafbbc7540ee",
+  "v28-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-8-0-0377ded656c6f524f1618760bffe4e0a1c51d5a70c4509eedae8a27555733edc.vk": {
+    "cid": "QmR9i9KL3vhhAqTBGj1bPPC7LvkptxrH9RvxJxLN1vvsBE",
+    "digest": "0f8ec542485568fa3468c066e9fed82b",
     "sector_size": 34359738368
   },
-  "v20-proof-of-spacetime-election-a4e18190d4b4657ba1b4d08a341871b2a6f398e327cb9951b28ab141fbdbf49d.params": {
-    "cid": "QmRGZsNp4mp1cZshcXqt3VMuWscAEsiMa2iepF4CsWWoiv",
-    "digest": "991041a354b12c280542741f58c7f2ca",
-    "sector_size": 1024
-  },
-  "v20-proof-of-spacetime-election-a4e18190d4b4657ba1b4d08a341871b2a6f398e327cb9951b28ab141fbdbf49d.vk": {
-    "cid": "QmWpmrhCGVcfqLyqp5oGAnhPmCE5hGTPaauHi25mpQwRSU",
-    "digest": "91fac550e1f9bccab213830bb0c85bd6",
-    "sector_size": 1024
-  },
-  "v20-proof-of-spacetime-election-a9eb6d90b896a282ec2d3a875c6143e3fcff778f0da1460709e051833651559b.params": {
-    "cid": "QmenSZXh1EsSyHiSRvA6wb8yaPhYBTjrKehJw96Px5HnN4",
-    "digest": "6322eacd2773163ddd51f9ca7d645fc4",
-    "sector_size": 1073741824
-  },
-  "v20-proof-of-spacetime-election-a9eb6d90b896a282ec2d3a875c6143e3fcff778f0da1460709e051833651559b.vk": {
-    "cid": "QmPvZoMKofw6eDhDg5ESJA2QAZP8HvM6qMQk7fw4pq9bQf",
-    "digest": "0df62745fceac922e3e70847cfc70b52",
-    "sector_size": 1073741824
-  },
-  "v20-proof-of-spacetime-election-bf872523641b1de33553db2a177df13e412d7b3b0103e6696ae0a1cf5d525259.params": {
-    "cid": "QmVibFqzkZoL8cwQmzj8njPokCQGCCx4pBcUH77bzgJgV9",
-    "digest": "de9d71e672f286706a1673bd57abdaac",
-    "sector_size": 16777216
-  },
-  "v20-proof-of-spacetime-election-bf872523641b1de33553db2a177df13e412d7b3b0103e6696ae0a1cf5d525259.vk": {
-    "cid": "QmZa5FX27XyiEXQQLQpHqtMJKLzrcY8wMuj3pxzmSimSyu",
-    "digest": "7f796d3a0f13499181e44b5eee0cc744",
-    "sector_size": 16777216
-  },
-  "v20-proof-of-spacetime-election-ffc3fb192364238b60977839d14e3154d4a98313e30d46694a12af54b6874975.params": {
-    "cid": "Qmbt2SWWAmMcYoY3DAiRDXA8fAuqdqRLWucJMSxYmzBCmN",
-    "digest": "151ae0ae183fc141e8c2bebc28e5cc10",
-    "sector_size": 268435456
-  },
-  "v20-proof-of-spacetime-election-ffc3fb192364238b60977839d14e3154d4a98313e30d46694a12af54b6874975.vk": {
-    "cid": "QmUxvPu4xdVmjMFihUKoYyEdXBqxsXkvmxRweU7KouWHji",
-    "digest": "95eb89588e9d1832aca044c3a13178af",
-    "sector_size": 268435456
-  },
-  "v20-stacked-proof-of-replication-117839dacd1ef31e5968a6fd13bcd6fa86638d85c40c9241a1d07c2a954eb89b.params": {
-    "cid": "QmQZe8eLo2xXbhSDxtyYZNqEjqjdcWGdADywECRvNEZQdX",
-    "digest": "fcd50e2e08a8560a6bb3418e883567ed",
-    "sector_size": 268435456
-  },
-  "v20-stacked-proof-of-replication-117839dacd1ef31e5968a6fd13bcd6fa86638d85c40c9241a1d07c2a954eb89b.vk": {
-    "cid": "Qme1hn6QT1covfoUFGDZkqoE1pMTax9FNW3nWWmTNqFe7y",
-    "digest": "872e244d86499fd659082e3bcf3f13e7",
-    "sector_size": 268435456
-  },
-  "v20-stacked-proof-of-replication-b46f3a1051afbb67f70aae7082da95def62eee943662f3e1bf69837fb08aaae4.params": {
-    "cid": "QmSfrPDC9jwY4MKrjzhCqDBBAG44wSDM8oE5NuDwWSh2xN",
-    "digest": "0a338b941c5f17946340de5fc95cab30",
+  "v28-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-8-0-559e581f022bb4e4ec6e719e563bf0e026ad6de42e56c18714a2c692b1b88d7e.params": {
+    "cid": "Qmdtczp7p4wrbDofmHdGhiixn9irAcN77mV9AEHZBaTt1i",
+    "digest": "d84f79a16fe40e9e25a36e2107bb1ba0",
     "sector_size": 34359738368
   },
-  "v20-stacked-proof-of-replication-b46f3a1051afbb67f70aae7082da95def62eee943662f3e1bf69837fb08aaae4.vk": {
-    "cid": "QmTDGynCmnbaZNBP3Bv3F3duC3ecKRubCKeMUiQQZYbGpF",
-    "digest": "c752e070a6b7aa8b79aa661a6b600b55",
+  "v28-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-8-0-559e581f022bb4e4ec6e719e563bf0e026ad6de42e56c18714a2c692b1b88d7e.vk": {
+    "cid": "QmZCvxKcKP97vDAk8Nxs9R1fWtqpjQrAhhfXPoCi1nkDoF",
+    "digest": "fc02943678dd119e69e7fab8420e8819",
     "sector_size": 34359738368
   },
-  "v20-stacked-proof-of-replication-e71093863cadc71de61f38311ee45816633973bbf34849316b147f8d2e66f199.params": {
-    "cid": "QmXjSSnMUnc7EjQBYtTHhvLU3kXJTbUyhVhJRSTRehh186",
-    "digest": "efa407fd09202dffd15799a8518e73d3",
-    "sector_size": 1024
+  "v28-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-8-2-2627e4006b67f99cef990c0a47d5426cb7ab0a0ad58fc1061547bf2d28b09def.params": {
+    "cid": "QmeAN4vuANhXsF8xP2Lx5j2L6yMSdogLzpcvqCJThRGK1V",
+    "digest": "3810b7780ac0e299b22ae70f1f94c9bc",
+    "sector_size": 68719476736
   },
-  "v20-stacked-proof-of-replication-e71093863cadc71de61f38311ee45816633973bbf34849316b147f8d2e66f199.vk": {
-    "cid": "QmYHW3zhQouDP4okFbXSsRMcZ8bokKGvzxqbv7ZrunPMiG",
-    "digest": "b2f09a0ccb62da28c890d5b881c8dcd2",
-    "sector_size": 1024
+  "v28-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-8-2-2627e4006b67f99cef990c0a47d5426cb7ab0a0ad58fc1061547bf2d28b09def.vk": {
+    "cid": "QmWV8rqZLxs1oQN9jxNWmnT1YdgLwCcscv94VARrhHf1T7",
+    "digest": "59d2bf1857adc59a4f08fcf2afaa916b",
+    "sector_size": 68719476736
   },
-  "v20-stacked-proof-of-replication-e99a585174b6a45b254ba4780d72c89ad808c305c6d11711009ade4f39dba8e9.params": {
-    "cid": "QmUhyfNeLb32LfSkjsUwTFYLXQGMj6JQ8daff4DdVMt79q",
-    "digest": "b53c1916a63839ec345aa2224e9198b7",
-    "sector_size": 1073741824
+  "v28-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-8-2-b62098629d07946e9028127e70295ed996fe3ed25b0f9f88eb610a0ab4385a3c.params": {
+    "cid": "QmVkrXc1SLcpgcudK5J25HH93QvR9tNsVhVTYHm5UymXAz",
+    "digest": "2170a91ad5bae22ea61f2ea766630322",
+    "sector_size": 68719476736
   },
-  "v20-stacked-proof-of-replication-e99a585174b6a45b254ba4780d72c89ad808c305c6d11711009ade4f39dba8e9.vk": {
-    "cid": "QmWReGfbuoozNErbskmFvqV4q36BY6F2WWb4cVFc3zoYkA",
-    "digest": "20d58a3fae7343481f8298a2dd493dd7",
-    "sector_size": 1073741824
+  "v28-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-8-2-b62098629d07946e9028127e70295ed996fe3ed25b0f9f88eb610a0ab4385a3c.vk": {
+    "cid": "QmbfQjPD7EpzjhWGmvWAsyN2mAZ4PcYhsf3ujuhU9CSuBm",
+    "digest": "6d3789148fb6466d07ee1e24d6292fd6",
+    "sector_size": 68719476736
   },
-  "v20-stacked-proof-of-replication-f571ee2386f4c65a68e802747f2d78691006fc81a67971c4d9641403fffece16.params": {
-    "cid": "QmSAHu14Pe8iav6BYCt9XkpHJ73XM7tcpY4d9JK9BST9HU",
-    "digest": "7698426202c7e07b26ef056d31485b3a",
-    "sector_size": 16777216
+  "v28-stacked-proof-of-replication-merkletree-poseidon_hasher-8-0-0-sha256_hasher-032d3138d22506ec0082ed72b2dcba18df18477904e35bafee82b3793b06832f.params": {
+    "cid": "QmWceMgnWYLopMuM4AoGMvGEau7tNe5UK83XFjH5V9B17h",
+    "digest": "434fb1338ecfaf0f59256f30dde4968f",
+    "sector_size": 2048
   },
-  "v20-stacked-proof-of-replication-f571ee2386f4c65a68e802747f2d78691006fc81a67971c4d9641403fffece16.vk": {
-    "cid": "QmaKtFLShnhMGVn7P9UsHjkgqtqRFSwCStqqykBN7u8dax",
-    "digest": "834408e5c3fce6ec5d1bf64e64cee94e",
-    "sector_size": 16777216
+  "v28-stacked-proof-of-replication-merkletree-poseidon_hasher-8-0-0-sha256_hasher-032d3138d22506ec0082ed72b2dcba18df18477904e35bafee82b3793b06832f.vk": {
+    "cid": "QmamahpFCstMUqHi2qGtVoDnRrsXhid86qsfvoyCTKJqHr",
+    "digest": "dc1ade9929ade1708238f155343044ac",
+    "sector_size": 2048
+  },
+  "v28-stacked-proof-of-replication-merkletree-poseidon_hasher-8-0-0-sha256_hasher-6babf46ce344ae495d558e7770a585b2382d54f225af8ed0397b8be7c3fcd472.params": {
+    "cid": "QmYBpTt7LWNAWr1JXThV5VxX7wsQFLd1PHrGYVbrU1EZjC",
+    "digest": "6c77597eb91ab936c1cef4cf19eba1b3",
+    "sector_size": 536870912
+  },
+  "v28-stacked-proof-of-replication-merkletree-poseidon_hasher-8-0-0-sha256_hasher-6babf46ce344ae495d558e7770a585b2382d54f225af8ed0397b8be7c3fcd472.vk": {
+    "cid": "QmWionkqH2B6TXivzBSQeSyBxojaiAFbzhjtwYRrfwd8nH",
+    "digest": "065179da19fbe515507267677f02823e",
+    "sector_size": 536870912
+  },
+  "v28-stacked-proof-of-replication-merkletree-poseidon_hasher-8-0-0-sha256_hasher-ecd683648512ab1765faa2a5f14bab48f676e633467f0aa8aad4b55dcb0652bb.params": {
+    "cid": "QmPXAPPuQtuQz7Zz3MHMAMEtsYwqM1o9H1csPLeiMUQwZH",
+    "digest": "09e612e4eeb7a0eb95679a88404f960c",
+    "sector_size": 8388608
+  },
+  "v28-stacked-proof-of-replication-merkletree-poseidon_hasher-8-0-0-sha256_hasher-ecd683648512ab1765faa2a5f14bab48f676e633467f0aa8aad4b55dcb0652bb.vk": {
+    "cid": "QmYCuipFyvVW1GojdMrjK1JnMobXtT4zRCZs1CGxjizs99",
+    "digest": "b687beb9adbd9dabe265a7e3620813e4",
+    "sector_size": 8388608
+  },
+  "v28-stacked-proof-of-replication-merkletree-poseidon_hasher-8-8-0-sha256_hasher-82a357d2f2ca81dc61bb45f4a762807aedee1b0a53fd6c4e77b46a01bfef7820.params": {
+    "cid": "QmengpM684XLQfG8754ToonszgEg2bQeAGUan5uXTHUQzJ",
+    "digest": "6a388072a518cf46ebd661f5cc46900a",
+    "sector_size": 34359738368
+  },
+  "v28-stacked-proof-of-replication-merkletree-poseidon_hasher-8-8-0-sha256_hasher-82a357d2f2ca81dc61bb45f4a762807aedee1b0a53fd6c4e77b46a01bfef7820.vk": {
+    "cid": "Qmf93EMrADXAK6CyiSfE8xx45fkMfR3uzKEPCvZC1n2kzb",
+    "digest": "0c7b4aac1c40fdb7eb82bc355b41addf",
+    "sector_size": 34359738368
+  },
+  "v28-stacked-proof-of-replication-merkletree-poseidon_hasher-8-8-2-sha256_hasher-96f1b4a04c5c51e4759bbf224bbc2ef5a42c7100f16ec0637123f16a845ddfb2.params": {
+    "cid": "QmS7ye6Ri2MfFzCkcUJ7FQ6zxDKuJ6J6B8k5PN7wzSR9sX",
+    "digest": "1801f8a6e1b00bceb00cc27314bb5ce3",
+    "sector_size": 68719476736
+  },
+  "v28-stacked-proof-of-replication-merkletree-poseidon_hasher-8-8-2-sha256_hasher-96f1b4a04c5c51e4759bbf224bbc2ef5a42c7100f16ec0637123f16a845ddfb2.vk": {
+    "cid": "QmehSmC6BhrgRZakPDta2ewoH9nosNzdjCqQRXsNFNUkLN",
+    "digest": "a89884252c04c298d0b3c81bfd884164",
+    "sector_size": 68719476736
   }
 }
-
diff --git a/build/version.go b/build/version.go
index b1fd8b63d..77b98f008 100644
--- a/build/version.go
+++ b/build/version.go
@@ -1,13 +1,39 @@
 package build
 
-import "fmt"
+import (
+	"fmt"
+
+	"golang.org/x/xerrors"
+)
 
 var CurrentCommit string
+var BuildType int
+
+const (
+	BuildDefault = 0
+	Build2k      = 0x1
+	BuildDebug   = 0x3
+)
+
+func buildType() string {
+	switch BuildType {
+	case BuildDefault:
+		return ""
+	case BuildDebug:
+		return "+debug"
+	case Build2k:
+		return "+2k"
+	default:
+		return "+huh?"
+	}
+}
 
 // BuildVersion is the local build version, set by build system
-const BuildVersion = "0.1.6"
+const BuildVersion = "0.8.0"
 
-var UserVersion = BuildVersion + CurrentCommit
+func UserVersion() string {
+	return BuildVersion + buildType() + CurrentCommit
+}
 
 type Version uint32
 
@@ -30,9 +56,39 @@ func (ve Version) EqMajorMinor(v2 Version) bool {
 	return ve&minorMask == v2&minorMask
 }
 
-// APIVersion is a semver version of the rpc api exposed
-var APIVersion Version = newVer(0, 1, 6)
+type NodeType int
 
+const (
+	NodeUnknown NodeType = iota
+
+	NodeFull
+	NodeMiner
+	NodeWorker
+)
+
+var RunningNodeType NodeType
+
+func VersionForType(nodeType NodeType) (Version, error) {
+	switch nodeType {
+	case NodeFull:
+		return FullAPIVersion, nil
+	case NodeMiner:
+		return MinerAPIVersion, nil
+	case NodeWorker:
+		return WorkerAPIVersion, nil
+	default:
+		return Version(0), xerrors.Errorf("unknown node type %d", nodeType)
+	}
+}
+
+// semver versions of the rpc api exposed
+var (
+	FullAPIVersion   = newVer(0, 16, 0)
+	MinerAPIVersion  = newVer(0, 15, 0)
+	WorkerAPIVersion = newVer(0, 15, 0)
+)
+
+//nolint:varcheck,deadcode
 const (
 	majorMask = 0xff0000
 	minorMask = 0xffff00
diff --git a/chain/actors/actor_cron.go b/chain/actors/actor_cron.go
deleted file mode 100644
index f0be6a439..000000000
--- a/chain/actors/actor_cron.go
+++ /dev/null
@@ -1,48 +0,0 @@
-package actors
-
-import (
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/lotus/chain/actors/aerrors"
-	"github.com/filecoin-project/lotus/chain/types"
-)
-
-type CronActor struct{}
-
-type callTuple struct {
-	addr   address.Address
-	method uint64
-}
-
-var CronActors = []callTuple{
-	{StoragePowerAddress, SPAMethods.CheckProofSubmissions},
-}
-
-type CronActorState struct{}
-
-type cAMethods struct {
-	EpochTick uint64
-}
-
-var CAMethods = cAMethods{2}
-
-func (ca CronActor) Exports() []interface{} {
-	return []interface{}{
-		1: nil,
-		2: ca.EpochTick,
-	}
-}
-
-func (ca CronActor) EpochTick(act *types.Actor, vmctx types.VMContext, params *struct{}) ([]byte, ActorError) {
-	if vmctx.Message().From != CronAddress {
-		return nil, aerrors.New(1, "EpochTick is only callable as a part of tipset state computation")
-	}
-
-	for _, call := range CronActors {
-		_, err := vmctx.Send(call.addr, call.method, types.NewInt(0), nil)
-		if err != nil {
-			return nil, err // todo: this very bad?
-		}
-	}
-
-	return nil, nil
-}
diff --git a/chain/actors/actor_init.go b/chain/actors/actor_init.go
deleted file mode 100644
index 45da1401e..000000000
--- a/chain/actors/actor_init.go
+++ /dev/null
@@ -1,242 +0,0 @@
-package actors
-
-import (
-	"bytes"
-	"context"
-	"encoding/binary"
-	"fmt"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/lotus/chain/actors/aerrors"
-	"github.com/filecoin-project/lotus/chain/types"
-	cbg "github.com/whyrusleeping/cbor-gen"
-	"golang.org/x/xerrors"
-
-	"github.com/ipfs/go-cid"
-	"github.com/ipfs/go-hamt-ipld"
-	cbor "github.com/ipfs/go-ipld-cbor"
-	logging "github.com/ipfs/go-log"
-	mh "github.com/multiformats/go-multihash"
-)
-
-var log = logging.Logger("actors")
-
-var EmptyCBOR cid.Cid
-
-const (
-	GasCreateActor = 100
-)
-
-func init() {
-
-	n, err := cbor.WrapObject(map[string]string{}, mh.SHA2_256, -1)
-	if err != nil {
-		panic(err) // ok
-	}
-
-	EmptyCBOR = n.Cid()
-}
-
-type InitActor struct{}
-
-type InitActorState struct {
-	AddressMap cid.Cid
-
-	NextID uint64
-}
-
-type iAMethods struct {
-	Exec uint64
-}
-
-var IAMethods = iAMethods{2}
-
-func (ia InitActor) Exports() []interface{} {
-	return []interface{}{
-		1: nil,
-		2: ia.Exec,
-	}
-}
-
-type ExecParams struct {
-	Code   cid.Cid
-	Params []byte
-}
-
-func CreateExecParams(act cid.Cid, obj cbg.CBORMarshaler) ([]byte, aerrors.ActorError) {
-	encparams, err := SerializeParams(obj)
-	if err != nil {
-		return nil, aerrors.Wrap(err, "creating ExecParams")
-	}
-
-	return SerializeParams(&ExecParams{
-		Code:   act,
-		Params: encparams,
-	})
-}
-
-func (ia InitActor) Exec(act *types.Actor, vmctx types.VMContext, p *ExecParams) ([]byte, aerrors.ActorError) {
-	beginState := vmctx.Storage().GetHead()
-
-	var self InitActorState
-	if err := vmctx.Storage().Get(beginState, &self); err != nil {
-		return nil, err
-	}
-
-	if err := vmctx.ChargeGas(GasCreateActor); err != nil {
-		return nil, aerrors.Wrap(err, "run out of gas")
-	}
-
-	// Make sure that only the actors defined in the spec can be launched.
-	if !IsBuiltinActor(p.Code) {
-		return nil, aerrors.New(1,
-			"cannot launch actor instance that is not a builtin actor")
-	}
-
-	// Ensure that singletons can be only launched once.
-	// TODO: do we want to enforce this? If so how should actors be marked as such?
-	if IsSingletonActor(p.Code) {
-		return nil, aerrors.New(1, "cannot launch another actor of this type")
-	}
-
-	// This generates a unique address for this actor that is stable across message
-	// reordering
-	creator := vmctx.Message().From
-	nonce := vmctx.Message().Nonce
-	addr, err := ComputeActorAddress(creator, nonce)
-	if err != nil {
-		return nil, err
-	}
-
-	// Set up the actor itself
-	actor := types.Actor{
-		Code:    p.Code,
-		Balance: types.NewInt(0),
-		Head:    EmptyCBOR,
-		Nonce:   0,
-	}
-
-	// The call to the actors constructor will set up the initial state
-	// from the given parameters, setting `actor.Head` to a new value when successful.
-	// TODO: can constructors fail?
-	//actor.Constructor(p.Params)
-
-	// Store the mapping of address to actor ID.
-	idAddr, nerr := self.AddActor(vmctx.Ipld(), addr)
-	if nerr != nil {
-		return nil, aerrors.Escalate(err, "adding new actor mapping")
-	}
-
-	// NOTE: This is a privileged call that only the init actor is allowed to make
-	// FIXME: Had to comment this  because state is not in interface
-	state, err := vmctx.StateTree()
-	if err != nil {
-		return nil, err
-	}
-
-	if err := state.SetActor(idAddr, &actor); err != nil {
-		if xerrors.Is(err, types.ErrActorNotFound) {
-			return nil, aerrors.Absorb(err, 1, "SetActor, actor not found")
-		}
-		return nil, aerrors.Escalate(err, "inserting new actor into state tree")
-	}
-
-	// '1' is reserved for constructor methods
-	_, err = vmctx.Send(idAddr, 1, vmctx.Message().Value, p.Params)
-	if err != nil {
-		return nil, err
-	}
-
-	c, err := vmctx.Storage().Put(&self)
-	if err != nil {
-		return nil, err
-	}
-
-	if err := vmctx.Storage().Commit(beginState, c); err != nil {
-		return nil, err
-	}
-
-	return idAddr.Bytes(), nil
-}
-
-func IsBuiltinActor(code cid.Cid) bool {
-	switch code {
-	case StorageMarketCodeCid, StoragePowerCodeCid, StorageMinerCodeCid, AccountCodeCid, InitCodeCid, MultisigCodeCid, PaymentChannelCodeCid:
-		return true
-	default:
-		return false
-	}
-}
-
-func IsSingletonActor(code cid.Cid) bool {
-	return code == StoragePowerCodeCid || code == StorageMarketCodeCid || code == InitCodeCid || code == CronCodeCid
-}
-
-func (ias *InitActorState) AddActor(cst *hamt.CborIpldStore, addr address.Address) (address.Address, error) {
-	nid := ias.NextID
-
-	amap, err := hamt.LoadNode(context.TODO(), cst, ias.AddressMap)
-	if err != nil {
-		return address.Undef, err
-	}
-
-	if err := amap.Set(context.TODO(), string(addr.Bytes()), nid); err != nil {
-		return address.Undef, err
-	}
-
-	if err := amap.Flush(context.TODO()); err != nil {
-		return address.Undef, err
-	}
-
-	ncid, err := cst.Put(context.TODO(), amap)
-	if err != nil {
-		return address.Undef, err
-	}
-	ias.AddressMap = ncid
-	ias.NextID++
-
-	return NewIDAddress(nid)
-}
-
-func (ias *InitActorState) Lookup(cst *hamt.CborIpldStore, addr address.Address) (address.Address, error) {
-	amap, err := hamt.LoadNode(context.TODO(), cst, ias.AddressMap)
-	if err != nil {
-		return address.Undef, xerrors.Errorf("ias lookup failed loading hamt node: %w", err)
-	}
-
-	var val interface{}
-	err = amap.Find(context.TODO(), string(addr.Bytes()), &val)
-	if err != nil {
-		return address.Undef, xerrors.Errorf("ias lookup failed to do find: %w", err)
-	}
-
-	ival, ok := val.(uint64)
-	if !ok {
-		return address.Undef, fmt.Errorf("invalid value in init actor state, expected uint64, got %T", val)
-	}
-
-	return address.NewIDAddress(ival)
-}
-
-type AccountActorState struct {
-	Address address.Address
-}
-
-func ComputeActorAddress(creator address.Address, nonce uint64) (address.Address, ActorError) {
-	buf := new(bytes.Buffer)
-	_, err := buf.Write(creator.Bytes())
-	if err != nil {
-		return address.Undef, aerrors.Escalate(err, "could not write address")
-	}
-
-	err = binary.Write(buf, binary.BigEndian, nonce)
-	if err != nil {
-		return address.Undef, aerrors.Escalate(err, "could not write nonce")
-	}
-
-	addr, err := address.NewActorAddress(buf.Bytes())
-	if err != nil {
-		return address.Undef, aerrors.Escalate(err, "could not create address")
-	}
-	return addr, nil
-}
diff --git a/chain/actors/actor_miner.go b/chain/actors/actor_miner.go
deleted file mode 100644
index 4e3e33096..000000000
--- a/chain/actors/actor_miner.go
+++ /dev/null
@@ -1,1248 +0,0 @@
-package actors
-
-import (
-	"bytes"
-	"context"
-	"encoding/binary"
-	"fmt"
-
-	ffi "github.com/filecoin-project/filecoin-ffi"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-sectorbuilder"
-	"github.com/filecoin-project/lotus/build"
-	"github.com/filecoin-project/lotus/chain/actors/aerrors"
-	"github.com/filecoin-project/lotus/chain/types"
-
-	"github.com/filecoin-project/go-amt-ipld"
-	"github.com/ipfs/go-cid"
-	cbor "github.com/ipfs/go-ipld-cbor"
-	"github.com/libp2p/go-libp2p-core/peer"
-	cbg "github.com/whyrusleeping/cbor-gen"
-	"go.opencensus.io/trace"
-	"golang.org/x/xerrors"
-)
-
-const MaxSectors = 1 << 48
-const RLEMax = 100e3
-
-type StorageMinerActor struct{}
-
-type StorageMinerActorState struct {
-	// PreCommittedSectors is the set of sectors that have been committed to but not
-	// yet had their proofs submitted
-	PreCommittedSectors map[string]*PreCommittedSector
-
-	// All sectors this miner has committed.
-	//
-	// AMT[sectorID]ffi.PublicSectorInfo
-	Sectors cid.Cid
-
-	// TODO: Spec says 'StagedCommittedSectors', which one is it?
-
-	// Sectors this miner is currently mining. It is only updated
-	// when a PoSt is submitted (not as each new sector commitment is added).
-	//
-	// AMT[sectorID]ffi.PublicSectorInfo
-	ProvingSet cid.Cid
-
-	// TODO: these:
-	//    SectorTable
-	//    SectorExpirationQueue
-	//    ChallengeStatus
-
-	// Contains mostly static info about this miner
-	Info cid.Cid
-
-	// Faulty sectors reported since last SubmitPost
-	FaultSet types.BitField
-
-	LastFaultSubmission uint64
-
-	// Amount of power this miner has.
-	Power types.BigInt
-
-	// Active is set to true after the miner has submitted their first PoSt
-	Active bool
-
-	// The height at which this miner was slashed at.
-	SlashedAt uint64
-
-	ElectionPeriodStart uint64
-}
-
-type MinerInfo struct {
-	// Account that owns this miner.
-	// - Income and returned collateral are paid to this address.
-	// - This address is also allowed to change the worker address for the miner.
-	Owner address.Address
-
-	// Worker account for this miner.
-	// This will be the key that is used to sign blocks created by this miner, and
-	// sign messages sent on behalf of this miner to commit sectors, submit PoSts, and
-	// other day to day miner activities.
-	Worker address.Address
-
-	// Libp2p identity that should be used when connecting to this miner.
-	PeerID peer.ID
-
-	// Amount of space in each sector committed to the network by this miner.
-	SectorSize uint64
-
-	// SubsectorCount
-}
-
-type PreCommittedSector struct {
-	Info          SectorPreCommitInfo
-	ReceivedEpoch uint64
-}
-
-type StorageMinerConstructorParams struct {
-	Owner      address.Address
-	Worker     address.Address
-	SectorSize uint64
-	PeerID     peer.ID
-}
-
-type SectorPreCommitInfo struct {
-	SectorNumber uint64
-
-	CommR     []byte // TODO: Spec says CID
-	SealEpoch uint64
-	DealIDs   []uint64
-}
-
-type maMethods struct {
-	Constructor          uint64
-	PreCommitSector      uint64
-	ProveCommitSector    uint64
-	SubmitFallbackPoSt   uint64
-	SlashStorageFault    uint64
-	GetCurrentProvingSet uint64
-	ArbitrateDeal        uint64
-	DePledge             uint64
-	GetOwner             uint64
-	GetWorkerAddr        uint64
-	GetPower             uint64
-	GetPeerID            uint64
-	GetSectorSize        uint64
-	UpdatePeerID         uint64
-	ChangeWorker         uint64
-	IsSlashed            uint64
-	CheckMiner           uint64
-	DeclareFaults        uint64
-	SlashConsensusFault  uint64
-	SubmitElectionPoSt   uint64
-}
-
-var MAMethods = maMethods{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20}
-
-func (sma StorageMinerActor) Exports() []interface{} {
-	return []interface{}{
-		1: sma.StorageMinerConstructor,
-		2: sma.PreCommitSector,
-		3: withUpdates(
-			update{start: 0, method: sma.ProveCommitSectorV0},
-			update{start: build.ForkNoPowerEPSUpdates, method: sma.ProveCommitSectorV1},
-		),
-		4: sma.SubmitFallbackPoSt,
-		//5: sma.SlashStorageFault,
-		//6: sma.GetCurrentProvingSet,
-		//7:  sma.ArbitrateDeal,
-		//8:  sma.DePledge,
-		9:  sma.GetOwner,
-		10: sma.GetWorkerAddr,
-		11: sma.GetPower, // TODO: Remove
-		12: sma.GetPeerID,
-		13: sma.GetSectorSize,
-		14: sma.UpdatePeerID,
-		//15: sma.ChangeWorker,
-		16: sma.IsSlashed,
-		17: sma.CheckMiner,
-		18: withUpdates(
-			update{start: 0, method: sma.DeclareFaultsV0},
-			update{start: build.ForkNoPowerEPSUpdates, method: sma.DeclareFaultsV1},
-		),
-		19: sma.SlashConsensusFault,
-		20: sma.SubmitElectionPoSt,
-	}
-}
-
-func loadState(vmctx types.VMContext) (cid.Cid, *StorageMinerActorState, ActorError) {
-	var self StorageMinerActorState
-	oldstate := vmctx.Storage().GetHead()
-	if err := vmctx.Storage().Get(oldstate, &self); err != nil {
-		return cid.Undef, nil, err
-	}
-
-	return oldstate, &self, nil
-}
-
-func loadMinerInfo(vmctx types.VMContext, m *StorageMinerActorState) (*MinerInfo, ActorError) {
-	var mi MinerInfo
-	if err := vmctx.Storage().Get(m.Info, &mi); err != nil {
-		return nil, err
-	}
-
-	return &mi, nil
-}
-
-func (sma StorageMinerActor) StorageMinerConstructor(act *types.Actor, vmctx types.VMContext, params *StorageMinerConstructorParams) ([]byte, ActorError) {
-	minerInfo := &MinerInfo{
-		Owner:      params.Owner,
-		Worker:     params.Worker,
-		PeerID:     params.PeerID,
-		SectorSize: params.SectorSize,
-	}
-
-	minfocid, err := vmctx.Storage().Put(minerInfo)
-	if err != nil {
-		return nil, err
-	}
-
-	var self StorageMinerActorState
-	sectors := amt.NewAMT(types.WrapStorage(vmctx.Storage()))
-	scid, serr := sectors.Flush()
-	if serr != nil {
-		return nil, aerrors.HandleExternalError(serr, "initializing AMT")
-	}
-
-	self.Sectors = scid
-	self.ProvingSet = scid
-	self.Info = minfocid
-
-	storage := vmctx.Storage()
-	c, err := storage.Put(&self)
-	if err != nil {
-		return nil, err
-	}
-
-	if err := storage.Commit(EmptyCBOR, c); err != nil {
-		return nil, err
-	}
-
-	return nil, nil
-}
-
-func (sma StorageMinerActor) PreCommitSector(act *types.Actor, vmctx types.VMContext, params *SectorPreCommitInfo) ([]byte, ActorError) {
-	ctx := vmctx.Context()
-	oldstate, self, err := loadState(vmctx)
-	if err != nil {
-		return nil, err
-	}
-
-	if params.SealEpoch >= vmctx.BlockHeight()+build.SealRandomnessLookback {
-		return nil, aerrors.Newf(1, "sector commitment must be based off past randomness (%d >= %d)", params.SealEpoch, vmctx.BlockHeight()+build.SealRandomnessLookback)
-	}
-
-	if vmctx.BlockHeight()-params.SealEpoch+build.SealRandomnessLookback > build.SealRandomnessLookbackLimit {
-		return nil, aerrors.Newf(2, "sector commitment must be recent enough (was %d)", vmctx.BlockHeight()-params.SealEpoch+build.SealRandomnessLookback)
-	}
-
-	mi, err := loadMinerInfo(vmctx, self)
-	if err != nil {
-		return nil, err
-	}
-
-	if vmctx.Message().From != mi.Worker {
-		return nil, aerrors.New(1, "not authorized to precommit sector for miner")
-	}
-
-	// make sure the miner isnt trying to submit a pre-existing sector
-	unique, err := SectorIsUnique(ctx, vmctx.Storage(), self.Sectors, params.SectorNumber)
-	if err != nil {
-		return nil, err
-	}
-	if !unique {
-		return nil, aerrors.New(3, "sector already committed!")
-	}
-
-	// Power of the miner after adding this sector
-	futurePower := types.BigAdd(self.Power, types.NewInt(mi.SectorSize))
-	collateralRequired := CollateralForPower(futurePower)
-
-	// TODO: grab from market?
-	if act.Balance.LessThan(collateralRequired) {
-		return nil, aerrors.New(4, "not enough collateral")
-	}
-
-	self.PreCommittedSectors[uintToStringKey(params.SectorNumber)] = &PreCommittedSector{
-		Info:          *params,
-		ReceivedEpoch: vmctx.BlockHeight(),
-	}
-
-	if len(self.PreCommittedSectors) > 4096 {
-		return nil, aerrors.New(5, "too many precommitted sectors")
-	}
-
-	nstate, err := vmctx.Storage().Put(self)
-	if err != nil {
-		return nil, err
-	}
-	if err := vmctx.Storage().Commit(oldstate, nstate); err != nil {
-		return nil, err
-	}
-
-	return nil, nil
-}
-
-func uintToStringKey(i uint64) string {
-	buf := make([]byte, 10)
-	n := binary.PutUvarint(buf, i)
-	return string(buf[:n])
-}
-
-type SectorProveCommitInfo struct {
-	Proof    []byte
-	SectorID uint64
-	DealIDs  []uint64
-}
-
-func (sma StorageMinerActor) ProveCommitSectorV0(act *types.Actor, vmctx types.VMContext, params *SectorProveCommitInfo) ([]byte, ActorError) {
-	ctx := vmctx.Context()
-	oldstate, self, err := loadState(vmctx)
-	if err != nil {
-		return nil, err
-	}
-
-	mi, err := loadMinerInfo(vmctx, self)
-	if err != nil {
-		return nil, err
-	}
-
-	us, ok := self.PreCommittedSectors[uintToStringKey(params.SectorID)]
-	if !ok {
-		return nil, aerrors.New(1, "no pre-commitment found for sector")
-	}
-
-	if us.ReceivedEpoch+build.InteractivePoRepDelay >= vmctx.BlockHeight() {
-		return nil, aerrors.New(2, "too early for proof submission")
-	}
-
-	delete(self.PreCommittedSectors, uintToStringKey(params.SectorID))
-
-	// TODO: ensure normalization to ID address
-	maddr := vmctx.Message().To
-
-	ticket, err := vmctx.GetRandomness(us.Info.SealEpoch - build.SealRandomnessLookback)
-	if err != nil {
-		return nil, aerrors.Wrap(err, "failed to get ticket randomness")
-	}
-
-	seed, err := vmctx.GetRandomness(us.ReceivedEpoch + build.InteractivePoRepDelay)
-	if err != nil {
-		return nil, aerrors.Wrap(err, "failed to get randomness for prove sector commitment")
-	}
-
-	enc, err := SerializeParams(&ComputeDataCommitmentParams{
-		DealIDs:    params.DealIDs,
-		SectorSize: mi.SectorSize,
-	})
-	if err != nil {
-		return nil, aerrors.Wrap(err, "failed to serialize ComputeDataCommitmentParams")
-	}
-
-	commD, err := vmctx.Send(StorageMarketAddress, SMAMethods.ComputeDataCommitment, types.NewInt(0), enc)
-	if err != nil {
-		return nil, aerrors.Wrapf(err, "failed to compute data commitment (sector %d, deals: %v)", params.SectorID, params.DealIDs)
-	}
-
-	if ok, err := vmctx.Sys().ValidatePoRep(ctx, maddr, mi.SectorSize, commD, us.Info.CommR, ticket, params.Proof, seed, params.SectorID); err != nil {
-		return nil, err
-	} else if !ok {
-		return nil, aerrors.Newf(2, "porep proof was invalid (t:%x; s:%x(%d); p:%s)", ticket, seed, us.ReceivedEpoch+build.InteractivePoRepDelay, truncateHexPrint(params.Proof))
-	}
-
-	// Note: There must exist a unique index in the miner's sector set for each
-	// sector ID. The `faults`, `recovered`, and `done` parameters of the
-	// SubmitPoSt method express indices into this sector set.
-	nssroot, err := AddToSectorSet(ctx, types.WrapStorage(vmctx.Storage()), self.Sectors, params.SectorID, us.Info.CommR, commD)
-	if err != nil {
-		return nil, err
-	}
-	self.Sectors = nssroot
-
-	// if miner is not mining, start their proving period now
-	// Note: As written here, every miners first PoSt will only be over one sector.
-	// We could set up a 'grace period' for starting mining that would allow miners
-	// to submit several sectors for their first proving period. Alternatively, we
-	// could simply make the 'PreCommitSector' call take multiple sectors at a time.
-	//
-	// Note: Proving period is a function of sector size; small sectors take less
-	// time to prove than large sectors do. Sector size is selected when pledging.
-	pss, lerr := amt.LoadAMT(types.WrapStorage(vmctx.Storage()), self.ProvingSet)
-	if lerr != nil {
-		return nil, aerrors.HandleExternalError(lerr, "could not load proving set node")
-	}
-
-	if pss.Count == 0 {
-		self.ProvingSet = self.Sectors
-		// TODO: probably want to wait until the miner is above a certain
-		//  threshold before starting this
-		self.ElectionPeriodStart = vmctx.BlockHeight()
-	}
-
-	nstate, err := vmctx.Storage().Put(self)
-	if err != nil {
-		return nil, err
-	}
-	if err := vmctx.Storage().Commit(oldstate, nstate); err != nil {
-		return nil, err
-	}
-
-	activateParams, err := SerializeParams(&ActivateStorageDealsParams{
-		Deals: params.DealIDs,
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	_, err = vmctx.Send(StorageMarketAddress, SMAMethods.ActivateStorageDeals, types.NewInt(0), activateParams)
-	return nil, aerrors.Wrapf(err, "calling ActivateStorageDeals failed")
-}
-
-func (sma StorageMinerActor) ProveCommitSectorV1(act *types.Actor, vmctx types.VMContext, params *SectorProveCommitInfo) ([]byte, ActorError) {
-	ctx := vmctx.Context()
-	oldstate, self, err := loadState(vmctx)
-	if err != nil {
-		return nil, err
-	}
-
-	mi, err := loadMinerInfo(vmctx, self)
-	if err != nil {
-		return nil, err
-	}
-
-	if vmctx.Message().From != mi.Worker {
-		return nil, aerrors.New(1, "not authorized to submit sector proof for miner")
-	}
-
-	us, ok := self.PreCommittedSectors[uintToStringKey(params.SectorID)]
-	if !ok {
-		return nil, aerrors.New(1, "no pre-commitment found for sector")
-	}
-
-	if us.ReceivedEpoch+build.InteractivePoRepDelay >= vmctx.BlockHeight() {
-		return nil, aerrors.New(2, "too early for proof submission")
-	}
-
-	delete(self.PreCommittedSectors, uintToStringKey(params.SectorID))
-
-	// TODO: ensure normalization to ID address
-	maddr := vmctx.Message().To
-
-	ticket, err := vmctx.GetRandomness(us.Info.SealEpoch - build.SealRandomnessLookback)
-	if err != nil {
-		return nil, aerrors.Wrap(err, "failed to get ticket randomness")
-	}
-
-	seed, err := vmctx.GetRandomness(us.ReceivedEpoch + build.InteractivePoRepDelay)
-	if err != nil {
-		return nil, aerrors.Wrap(err, "failed to get randomness for prove sector commitment")
-	}
-
-	enc, err := SerializeParams(&ComputeDataCommitmentParams{
-		DealIDs:    params.DealIDs,
-		SectorSize: mi.SectorSize,
-	})
-	if err != nil {
-		return nil, aerrors.Wrap(err, "failed to serialize ComputeDataCommitmentParams")
-	}
-
-	commD, err := vmctx.Send(StorageMarketAddress, SMAMethods.ComputeDataCommitment, types.NewInt(0), enc)
-	if err != nil {
-		return nil, aerrors.Wrapf(err, "failed to compute data commitment (sector %d, deals: %v)", params.SectorID, params.DealIDs)
-	}
-
-	if ok, err := vmctx.Sys().ValidatePoRep(ctx, maddr, mi.SectorSize, commD, us.Info.CommR, ticket, params.Proof, seed, params.SectorID); err != nil {
-		return nil, err
-	} else if !ok {
-		return nil, aerrors.Newf(2, "porep proof was invalid (t:%x; s:%x(%d); p:%s)", ticket, seed, us.ReceivedEpoch+build.InteractivePoRepDelay, truncateHexPrint(params.Proof))
-	}
-
-	// Note: There must exist a unique index in the miner's sector set for each
-	// sector ID. The `faults`, `recovered`, and `done` parameters of the
-	// SubmitPoSt method express indices into this sector set.
-	nssroot, err := AddToSectorSet(ctx, types.WrapStorage(vmctx.Storage()), self.Sectors, params.SectorID, us.Info.CommR, commD)
-	if err != nil {
-		return nil, err
-	}
-	self.Sectors = nssroot
-
-	// if miner is not mining, start their proving period now
-	// Note: As written here, every miners first PoSt will only be over one sector.
-	// We could set up a 'grace period' for starting mining that would allow miners
-	// to submit several sectors for their first proving period. Alternatively, we
-	// could simply make the 'PreCommitSector' call take multiple sectors at a time.
-	//
-	// Note: Proving period is a function of sector size; small sectors take less
-	// time to prove than large sectors do. Sector size is selected when pledging.
-	pss, lerr := amt.LoadAMT(types.WrapStorage(vmctx.Storage()), self.ProvingSet)
-	if lerr != nil {
-		return nil, aerrors.HandleExternalError(lerr, "could not load proving set node")
-	}
-
-	if pss.Count == 0 && !self.Active {
-		self.ProvingSet = self.Sectors
-		// TODO: probably want to wait until the miner is above a certain
-		//  threshold before starting this
-		self.ElectionPeriodStart = vmctx.BlockHeight()
-	}
-
-	nstate, err := vmctx.Storage().Put(self)
-	if err != nil {
-		return nil, err
-	}
-	if err := vmctx.Storage().Commit(oldstate, nstate); err != nil {
-		return nil, err
-	}
-
-	activateParams, err := SerializeParams(&ActivateStorageDealsParams{
-		Deals: params.DealIDs,
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	_, err = vmctx.Send(StorageMarketAddress, SMAMethods.ActivateStorageDeals, types.NewInt(0), activateParams)
-	return nil, aerrors.Wrapf(err, "calling ActivateStorageDeals failed")
-}
-
-func truncateHexPrint(b []byte) string {
-	s := fmt.Sprintf("%x", b)
-	if len(s) > 60 {
-		return s[:20] + "..." + s[len(s)-20:]
-	}
-	return s
-}
-
-type SubmitFallbackPoStParams struct {
-	Proof      []byte
-	Candidates []types.EPostTicket
-}
-
-func (sma StorageMinerActor) SubmitFallbackPoSt(act *types.Actor, vmctx types.VMContext, params *SubmitFallbackPoStParams) ([]byte, ActorError) {
-	oldstate, self, err := loadState(vmctx)
-	if err != nil {
-		return nil, err
-	}
-
-	mi, err := loadMinerInfo(vmctx, self)
-	if err != nil {
-		return nil, err
-	}
-
-	if vmctx.Message().From != mi.Worker {
-		return nil, aerrors.New(1, "not authorized to submit post for miner")
-	}
-
-	/*
-		// TODO: handle fees
-		msgVal := vmctx.Message().Value
-		if msgVal.LessThan(feesRequired) {
-			return nil, aerrors.New(2, "not enough funds to pay post submission fees")
-		}
-
-		if msgVal.GreaterThan(feesRequired) {
-			_, err := vmctx.Send(vmctx.Message().From, 0,
-				types.BigSub(msgVal, feesRequired), nil)
-			if err != nil {
-				return nil, aerrors.Wrap(err, "could not refund excess fees")
-			}
-		}
-	*/
-
-	var seed [sectorbuilder.CommLen]byte
-	{
-		randHeight := self.ElectionPeriodStart + build.FallbackPoStDelay
-		if vmctx.BlockHeight() <= randHeight {
-			// TODO: spec, retcode
-			return nil, aerrors.Newf(1, "submit fallback PoSt called too early (%d < %d)", vmctx.BlockHeight(), randHeight)
-		}
-
-		rand, err := vmctx.GetRandomness(randHeight)
-
-		if err != nil {
-			return nil, aerrors.Wrap(err, "could not get randomness for PoST")
-		}
-		if len(rand) < len(seed) {
-			return nil, aerrors.Escalate(fmt.Errorf("randomness too small (%d < %d)",
-				len(rand), len(seed)), "improper randomness")
-		}
-		copy(seed[:], rand)
-	}
-
-	pss, lerr := amt.LoadAMT(types.WrapStorage(vmctx.Storage()), self.ProvingSet)
-	if lerr != nil {
-		return nil, aerrors.HandleExternalError(lerr, "could not load proving set node")
-	}
-
-	{
-		c, nerr := self.FaultSet.Count()
-		if nerr != nil {
-			return nil, aerrors.Absorb(nerr, 6, "invalid bitfield")
-		}
-
-		if c > RLEMax {
-			return nil, aerrors.Newf(7, "too many items in bitfield: %d", c)
-		}
-	}
-
-	faults, nerr := self.FaultSet.AllMap()
-	if nerr != nil {
-		return nil, aerrors.Absorb(err, 5, "RLE+ invalid")
-	}
-
-	var sectorInfos []ffi.PublicSectorInfo
-	if err := pss.ForEach(func(id uint64, v *cbg.Deferred) error {
-		if faults[id] {
-			return nil
-		}
-
-		var comms [][]byte
-		if err := cbor.DecodeInto(v.Raw, &comms); err != nil {
-			return xerrors.New("could not decode comms")
-		}
-		si := ffi.PublicSectorInfo{
-			SectorID: id,
-		}
-		commR := comms[0]
-		if len(commR) != len(si.CommR) {
-			return xerrors.Errorf("commR length is wrong: %d", len(commR))
-		}
-		copy(si.CommR[:], commR)
-
-		sectorInfos = append(sectorInfos, si)
-
-		return nil
-	}); err != nil {
-		return nil, aerrors.Absorb(err, 3, "could not decode sectorset")
-	}
-
-	proverID := vmctx.Message().To // TODO: normalize to ID address
-
-	var candidates []sectorbuilder.EPostCandidate
-	for _, t := range params.Candidates {
-		var partial [32]byte
-		copy(partial[:], t.Partial)
-		candidates = append(candidates, sectorbuilder.EPostCandidate{
-			PartialTicket:        partial,
-			SectorID:             t.SectorID,
-			SectorChallengeIndex: t.ChallengeIndex,
-		})
-	}
-
-	if ok, lerr := sectorbuilder.VerifyFallbackPost(vmctx.Context(), mi.SectorSize,
-		sectorbuilder.NewSortedPublicSectorInfo(sectorInfos), seed[:], params.Proof, candidates, proverID, 0); !ok || lerr != nil { // TODO: FORK - set faults to len(faults)
-		if lerr != nil {
-			// TODO: study PoST errors
-			return nil, aerrors.Absorb(lerr, 4, "PoST error")
-		}
-		if !ok {
-			return nil, aerrors.New(4, "PoST invalid")
-		}
-	}
-
-	// Post submission is successful!
-	if err := onSuccessfulPoSt(self, vmctx); err != nil {
-		return nil, err
-	}
-
-	c, err := vmctx.Storage().Put(self)
-	if err != nil {
-		return nil, err
-	}
-
-	if err := vmctx.Storage().Commit(oldstate, c); err != nil {
-		return nil, err
-	}
-
-	return nil, nil
-}
-
-func (sma StorageMinerActor) GetPower(act *types.Actor, vmctx types.VMContext, params *struct{}) ([]byte, ActorError) {
-	_, self, err := loadState(vmctx)
-	if err != nil {
-		return nil, err
-	}
-	return self.Power.Bytes(), nil
-}
-
-func SectorIsUnique(ctx context.Context, s types.Storage, sroot cid.Cid, sid uint64) (bool, ActorError) {
-	found, _, _, err := GetFromSectorSet(ctx, s, sroot, sid)
-	if err != nil {
-		return false, err
-	}
-
-	return !found, nil
-}
-
-func AddToSectorSet(ctx context.Context, blks amt.Blocks, ss cid.Cid, sectorID uint64, commR, commD []byte) (cid.Cid, ActorError) {
-	if sectorID >= MaxSectors {
-		return cid.Undef, aerrors.Newf(25, "sector ID out of range: %d", sectorID)
-	}
-	ssr, err := amt.LoadAMT(blks, ss)
-	if err != nil {
-		return cid.Undef, aerrors.HandleExternalError(err, "could not load sector set node")
-	}
-
-	// TODO: Spec says to use SealCommitment, and construct commD from deals each time,
-	//  but that would make SubmitPoSt way, way more expensive
-	if err := ssr.Set(sectorID, [][]byte{commR, commD}); err != nil {
-		return cid.Undef, aerrors.HandleExternalError(err, "failed to set commitment in sector set")
-	}
-
-	ncid, err := ssr.Flush()
-	if err != nil {
-		return cid.Undef, aerrors.HandleExternalError(err, "failed to flush sector set")
-	}
-
-	return ncid, nil
-}
-
-func GetFromSectorSet(ctx context.Context, s types.Storage, ss cid.Cid, sectorID uint64) (bool, []byte, []byte, ActorError) {
-	if sectorID >= MaxSectors {
-		return false, nil, nil, aerrors.Newf(25, "sector ID out of range: %d", sectorID)
-	}
-
-	ssr, err := amt.LoadAMT(types.WrapStorage(s), ss)
-	if err != nil {
-		return false, nil, nil, aerrors.HandleExternalError(err, "could not load sector set node")
-	}
-
-	var comms [][]byte
-	err = ssr.Get(sectorID, &comms)
-	if err != nil {
-		if _, ok := err.(*amt.ErrNotFound); ok {
-			return false, nil, nil, nil
-		}
-		return false, nil, nil, aerrors.HandleExternalError(err, "failed to find sector in sector set")
-	}
-
-	if len(comms) != 2 {
-		return false, nil, nil, aerrors.Newf(20, "sector set entry should only have 2 elements")
-	}
-
-	return true, comms[0], comms[1], nil
-}
-
-func RemoveFromSectorSet(ctx context.Context, s types.Storage, ss cid.Cid, ids []uint64) (cid.Cid, aerrors.ActorError) {
-
-	ssr, err := amt.LoadAMT(types.WrapStorage(s), ss)
-	if err != nil {
-		return cid.Undef, aerrors.HandleExternalError(err, "could not load sector set node")
-	}
-
-	for _, id := range ids {
-		if err := ssr.Delete(id); err != nil {
-			log.Warnf("failed to delete sector %d from set: %s", id, err)
-		}
-	}
-
-	ncid, err := ssr.Flush()
-	if err != nil {
-		return cid.Undef, aerrors.HandleExternalError(err, "failed to flush sector set")
-	}
-
-	return ncid, nil
-}
-
-func ValidatePoRep(ctx context.Context, maddr address.Address, ssize uint64, commD, commR, ticket, proof, seed []byte, sectorID uint64) (bool, ActorError) {
-	_, span := trace.StartSpan(ctx, "ValidatePoRep")
-	defer span.End()
-	ok, err := sectorbuilder.VerifySeal(ssize, commR, commD, maddr, ticket, seed, sectorID, proof)
-	if err != nil {
-		return false, aerrors.Absorb(err, 25, "verify seal failed")
-	}
-
-	return ok, nil
-}
-
-func CollateralForPower(power types.BigInt) types.BigInt {
-	return types.BigMul(power, types.NewInt(10))
-	/* TODO: this
-	availableFil = FakeGlobalMethods.GetAvailableFil()
-	totalNetworkPower = StorageMinerActor.GetTotalStorage()
-	numMiners = StorageMarket.GetMinerCount()
-	powerCollateral = availableFil * NetworkConstants.POWER_COLLATERAL_PROPORTION * power / totalNetworkPower
-	perCapitaCollateral = availableFil * NetworkConstants.PER_CAPITA_COLLATERAL_PROPORTION / numMiners
-	collateralRequired = math.Ceil(minerPowerCollateral + minerPerCapitaCollateral)
-	return collateralRequired
-	*/
-}
-
-func (sma StorageMinerActor) GetWorkerAddr(act *types.Actor, vmctx types.VMContext, params *struct{}) ([]byte, ActorError) {
-	_, self, err := loadState(vmctx)
-	if err != nil {
-		return nil, err
-	}
-
-	mi, err := loadMinerInfo(vmctx, self)
-	if err != nil {
-		return nil, err
-	}
-
-	return mi.Worker.Bytes(), nil
-}
-
-func (sma StorageMinerActor) GetOwner(act *types.Actor, vmctx types.VMContext, params *struct{}) ([]byte, ActorError) {
-	_, self, err := loadState(vmctx)
-	if err != nil {
-		return nil, err
-	}
-
-	mi, err := loadMinerInfo(vmctx, self)
-	if err != nil {
-		return nil, err
-	}
-
-	return mi.Owner.Bytes(), nil
-}
-
-func (sma StorageMinerActor) GetPeerID(act *types.Actor, vmctx types.VMContext, params *struct{}) ([]byte, ActorError) {
-	_, self, err := loadState(vmctx)
-	if err != nil {
-		return nil, err
-	}
-
-	mi, err := loadMinerInfo(vmctx, self)
-	if err != nil {
-		return nil, err
-	}
-
-	return []byte(mi.PeerID), nil
-}
-
-type UpdatePeerIDParams struct {
-	PeerID peer.ID
-}
-
-func (sma StorageMinerActor) UpdatePeerID(act *types.Actor, vmctx types.VMContext, params *UpdatePeerIDParams) ([]byte, ActorError) {
-	oldstate, self, err := loadState(vmctx)
-	if err != nil {
-		return nil, err
-	}
-
-	mi, err := loadMinerInfo(vmctx, self)
-	if err != nil {
-		return nil, err
-	}
-
-	if vmctx.Message().From != mi.Worker {
-		return nil, aerrors.New(2, "only the mine worker may update the peer ID")
-	}
-
-	mi.PeerID = params.PeerID
-
-	mic, err := vmctx.Storage().Put(mi)
-	if err != nil {
-		return nil, err
-	}
-
-	self.Info = mic
-
-	c, err := vmctx.Storage().Put(self)
-	if err != nil {
-		return nil, err
-	}
-
-	if err := vmctx.Storage().Commit(oldstate, c); err != nil {
-		return nil, err
-	}
-
-	return nil, nil
-}
-
-func (sma StorageMinerActor) GetSectorSize(act *types.Actor, vmctx types.VMContext, params *struct{}) ([]byte, ActorError) {
-	_, self, err := loadState(vmctx)
-	if err != nil {
-		return nil, err
-	}
-
-	mi, err := loadMinerInfo(vmctx, self)
-	if err != nil {
-		return nil, err
-	}
-
-	return types.NewInt(mi.SectorSize).Bytes(), nil
-}
-
-func isLate(height uint64, self *StorageMinerActorState) bool {
-	return self.ElectionPeriodStart > 0 && height >= self.ElectionPeriodStart+build.SlashablePowerDelay
-}
-
-func (sma StorageMinerActor) IsSlashed(act *types.Actor, vmctx types.VMContext, params *struct{}) ([]byte, ActorError) {
-	_, self, err := loadState(vmctx)
-	if err != nil {
-		return nil, err
-	}
-
-	return cbg.EncodeBool(self.SlashedAt != 0), nil
-}
-
-type CheckMinerParams struct {
-	NetworkPower types.BigInt
-}
-
-// TODO: better name
-func (sma StorageMinerActor) CheckMiner(act *types.Actor, vmctx types.VMContext, params *CheckMinerParams) ([]byte, ActorError) {
-	if vmctx.Message().From != StoragePowerAddress {
-		return nil, aerrors.New(2, "only the storage power actor can check miner")
-	}
-
-	oldstate, self, err := loadState(vmctx)
-	if err != nil {
-		return nil, err
-	}
-
-	if !isLate(vmctx.BlockHeight(), self) {
-		// Everything's fine
-		return nil, nil
-	}
-
-	if self.SlashedAt != 0 {
-		// Don't slash more than necessary
-		return nil, nil
-	}
-
-	if params.NetworkPower.Equals(self.Power) {
-		// Don't break the network when there's only one miner left
-
-		log.Warnf("can't slash miner %s for missed PoSt, no power would be left in the network", vmctx.Message().To)
-		return nil, nil
-	}
-
-	// Slash for being late
-
-	self.SlashedAt = vmctx.BlockHeight()
-
-	nstate, err := vmctx.Storage().Put(self)
-	if err != nil {
-		return nil, err
-	}
-	if err := vmctx.Storage().Commit(oldstate, nstate); err != nil {
-		return nil, err
-	}
-
-	var out bytes.Buffer
-	if err := self.Power.MarshalCBOR(&out); err != nil {
-		return nil, aerrors.HandleExternalError(err, "marshaling return value")
-	}
-	return out.Bytes(), nil
-}
-
-type DeclareFaultsParams struct {
-	Faults types.BitField
-}
-
-func (sma StorageMinerActor) DeclareFaultsV0(act *types.Actor, vmctx types.VMContext, params *DeclareFaultsParams) ([]byte, ActorError) {
-	oldstate, self, aerr := loadState(vmctx)
-	if aerr != nil {
-		return nil, aerr
-	}
-
-	nfaults, err := types.MergeBitFields(params.Faults, self.FaultSet)
-	if err != nil {
-		return nil, aerrors.Absorb(err, 1, "failed to merge bitfields")
-	}
-
-	self.FaultSet = nfaults
-
-	self.LastFaultSubmission = vmctx.BlockHeight()
-
-	nstate, aerr := vmctx.Storage().Put(self)
-	if err != nil { // TODO: FORK: should be aerr
-		return nil, aerr
-	}
-	if err := vmctx.Storage().Commit(oldstate, nstate); err != nil {
-		return nil, err
-	}
-
-	return nil, nil
-}
-
-func (sma StorageMinerActor) DeclareFaultsV1(act *types.Actor, vmctx types.VMContext, params *DeclareFaultsParams) ([]byte, ActorError) {
-	oldstate, self, aerr := loadState(vmctx)
-	if aerr != nil {
-		return nil, aerr
-	}
-
-	mi, aerr := loadMinerInfo(vmctx, self)
-	if aerr != nil {
-		return nil, aerr
-	}
-
-	if vmctx.Message().From != mi.Worker {
-		return nil, aerrors.New(1, "not authorized to declare faults for miner")
-	}
-
-	nfaults, err := types.MergeBitFields(params.Faults, self.FaultSet)
-	if err != nil {
-		return nil, aerrors.Absorb(err, 1, "failed to merge bitfields")
-	}
-
-	self.FaultSet = nfaults
-
-	self.LastFaultSubmission = vmctx.BlockHeight()
-
-	nstate, aerr := vmctx.Storage().Put(self)
-	if aerr != nil {
-		return nil, aerr
-	}
-	if err := vmctx.Storage().Commit(oldstate, nstate); err != nil {
-		return nil, err
-	}
-
-	return nil, nil
-}
-
-type MinerSlashConsensusFault struct {
-	Slasher           address.Address
-	AtHeight          uint64
-	SlashedCollateral types.BigInt
-}
-
-func (sma StorageMinerActor) SlashConsensusFault(act *types.Actor, vmctx types.VMContext, params *MinerSlashConsensusFault) ([]byte, ActorError) {
-	if vmctx.Message().From != StoragePowerAddress {
-		return nil, aerrors.New(1, "SlashConsensusFault may only be called by the storage market actor")
-	}
-
-	slashedCollateral := params.SlashedCollateral
-	if slashedCollateral.LessThan(act.Balance) {
-		slashedCollateral = act.Balance
-	}
-
-	// Some of the slashed collateral should be paid to the slasher
-	// GROWTH_RATE determines how fast the slasher share of slashed collateral will increase as block elapses
-	// current GROWTH_RATE results in SLASHER_SHARE reaches 1 after 30 blocks
-	// TODO: define arithmetic precision and rounding for this operation
-	blockElapsed := vmctx.BlockHeight() - params.AtHeight
-
-	slasherShare := slasherShare(params.SlashedCollateral, blockElapsed)
-
-	burnPortion := types.BigSub(slashedCollateral, slasherShare)
-
-	_, err := vmctx.Send(vmctx.Message().From, 0, slasherShare, nil)
-	if err != nil {
-		return nil, aerrors.Wrap(err, "failed to pay slasher")
-	}
-
-	_, err = vmctx.Send(BurntFundsAddress, 0, burnPortion, nil)
-	if err != nil {
-		return nil, aerrors.Wrap(err, "failed to burn funds")
-	}
-
-	// TODO: this still allows the miner to commit sectors and submit posts,
-	// their users could potentially be unaffected, but the miner will never be
-	// able to mine a block again
-	// One potential issue: the miner will have to pay back the slashed
-	// collateral to continue submitting PoSts, which includes pledge
-	// collateral that they no longer really 'need'
-
-	return nil, nil
-}
-
-func (sma StorageMinerActor) SubmitElectionPoSt(act *types.Actor, vmctx types.VMContext, params *struct{}) ([]byte, aerrors.ActorError) {
-	if vmctx.Message().From != NetworkAddress {
-		return nil, aerrors.Newf(1, "submit election post can only be called by the storage power actor")
-	}
-
-	oldstate, self, aerr := loadState(vmctx)
-	if aerr != nil {
-		return nil, aerr
-	}
-
-	if self.SlashedAt != 0 {
-		return nil, aerrors.New(1, "slashed miners can't perform election PoSt")
-	}
-
-	if err := onSuccessfulPoSt(self, vmctx); err != nil {
-		return nil, err
-	}
-
-	ncid, err := vmctx.Storage().Put(self)
-	if err != nil {
-		return nil, err
-	}
-	if err := vmctx.Storage().Commit(oldstate, ncid); err != nil {
-		return nil, err
-	}
-
-	return nil, nil
-}
-
-func onSuccessfulPoSt(self *StorageMinerActorState, vmctx types.VMContext) aerrors.ActorError {
-	if vmctx.BlockHeight() >= build.ForkNoPowerEPSUpdates {
-		return onSuccessfulPoStV1(self, vmctx)
-	}
-
-	return onSuccessfulPoStV0(self, vmctx)
-}
-
-func onSuccessfulPoStV0(self *StorageMinerActorState, vmctx types.VMContext) aerrors.ActorError {
-	var mi MinerInfo
-	if err := vmctx.Storage().Get(self.Info, &mi); err != nil {
-		return err
-	}
-
-	pss, nerr := amt.LoadAMT(types.WrapStorage(vmctx.Storage()), self.ProvingSet)
-	if nerr != nil {
-		return aerrors.HandleExternalError(nerr, "failed to load proving set")
-	}
-
-	faults, nerr := self.FaultSet.All()
-	if nerr != nil {
-		return aerrors.Absorb(nerr, 1, "invalid bitfield (fatal?)")
-	}
-
-	self.FaultSet = types.NewBitField()
-
-	oldPower := self.Power
-	newPower := types.BigMul(types.NewInt(pss.Count-uint64(len(faults))), types.NewInt(mi.SectorSize))
-
-	// If below the minimum size requirement, miners have zero power
-	if newPower.LessThan(types.NewInt(build.MinimumMinerPower)) {
-		newPower = types.NewInt(0)
-	}
-
-	self.Power = newPower
-
-	delta := types.BigSub(self.Power, oldPower)
-	if self.SlashedAt != 0 {
-		self.SlashedAt = 0
-		delta = self.Power
-	}
-
-	prevSlashingDeadline := self.ElectionPeriodStart + build.SlashablePowerDelay
-	if !self.Active && newPower.GreaterThan(types.NewInt(0)) {
-		self.Active = true
-		prevSlashingDeadline = 0
-	}
-
-	if !(oldPower.IsZero() && newPower.IsZero()) {
-		enc, err := SerializeParams(&UpdateStorageParams{
-			Delta:                 delta,
-			NextSlashDeadline:     vmctx.BlockHeight() + build.SlashablePowerDelay,
-			PreviousSlashDeadline: prevSlashingDeadline,
-		})
-		if err != nil {
-			return err
-		}
-
-		_, err = vmctx.Send(StoragePowerAddress, SPAMethods.UpdateStorage, types.NewInt(0), enc)
-		if err != nil {
-			return aerrors.Wrap(err, "updating storage failed")
-		}
-	}
-
-	ncid, err := RemoveFromSectorSet(vmctx.Context(), vmctx.Storage(), self.Sectors, faults)
-	if err != nil {
-		return err
-	}
-
-	self.Sectors = ncid
-	self.ProvingSet = ncid
-	self.ElectionPeriodStart = vmctx.BlockHeight()
-	return nil
-}
-
-func onSuccessfulPoStV1(self *StorageMinerActorState, vmctx types.VMContext) aerrors.ActorError {
-	// TODO: some sector upkeep stuff that is very haphazard and unclear in the spec
-
-	var mi MinerInfo
-	if err := vmctx.Storage().Get(self.Info, &mi); err != nil {
-		return err
-	}
-
-	pss, nerr := amt.LoadAMT(types.WrapStorage(vmctx.Storage()), self.ProvingSet)
-	if nerr != nil {
-		return aerrors.HandleExternalError(nerr, "failed to load proving set")
-	}
-
-	{
-		c, nerr := self.FaultSet.Count()
-		if nerr != nil {
-			return aerrors.Absorb(nerr, 2, "invalid bitfield")
-		}
-		if c > RLEMax {
-			return aerrors.Newf(3, "too many items in bitfield: %d", c)
-		}
-	}
-
-	faults, nerr := self.FaultSet.All()
-	if nerr != nil {
-		return aerrors.Absorb(nerr, 1, "invalid bitfield (fatal?)")
-	}
-
-	self.FaultSet = types.NewBitField()
-
-	oldPower := self.Power
-	newPower := types.BigMul(types.NewInt(pss.Count-uint64(len(faults))), types.NewInt(mi.SectorSize))
-
-	// If below the minimum size requirement, miners have zero power
-	if newPower.LessThan(types.NewInt(build.MinimumMinerPower)) {
-		newPower = types.NewInt(0)
-	}
-
-	self.Power = newPower
-
-	delta := types.BigSub(self.Power, oldPower)
-	if self.SlashedAt != 0 {
-		self.SlashedAt = 0
-		delta = self.Power
-	}
-
-	prevSlashingDeadline := self.ElectionPeriodStart + build.SlashablePowerDelay
-	if !self.Active && newPower.GreaterThan(types.NewInt(0)) {
-		self.Active = true
-		prevSlashingDeadline = 0
-	}
-
-	if !(oldPower.IsZero() && newPower.IsZero()) {
-		enc, err := SerializeParams(&UpdateStorageParams{
-			Delta:                 delta,
-			NextSlashDeadline:     vmctx.BlockHeight() + build.SlashablePowerDelay,
-			PreviousSlashDeadline: prevSlashingDeadline,
-		})
-		if err != nil {
-			return err
-		}
-
-		_, err = vmctx.Send(StoragePowerAddress, SPAMethods.UpdateStorage, types.NewInt(0), enc)
-		if err != nil {
-			return aerrors.Wrap(err, "updating storage failed")
-		}
-
-		self.ElectionPeriodStart = vmctx.BlockHeight()
-	}
-
-	ncid, err := RemoveFromSectorSet(vmctx.Context(), vmctx.Storage(), self.Sectors, faults)
-	if err != nil {
-		return err
-	}
-
-	self.Sectors = ncid
-	self.ProvingSet = ncid
-	return nil
-}
-
-func slasherShare(total types.BigInt, elapsed uint64) types.BigInt {
-	// [int(pow(1.26, n) * 10) for n in range(30)]
-	fracs := []uint64{10, 12, 15, 20, 25, 31, 40, 50, 63, 80, 100, 127, 160, 201, 254, 320, 403, 508, 640, 807, 1017, 1281, 1614, 2034, 2563, 3230, 4070, 5128, 6462, 8142}
-	const precision = 10000
-
-	var frac uint64
-	if elapsed >= uint64(len(fracs)) {
-		return total
-	} else {
-		frac = fracs[elapsed]
-	}
-
-	return types.BigDiv(
-		types.BigMul(
-			types.NewInt(frac),
-			total,
-		),
-		types.NewInt(precision),
-	)
-}
diff --git a/chain/actors/actor_miner_test.go b/chain/actors/actor_miner_test.go
deleted file mode 100644
index a522fe349..000000000
--- a/chain/actors/actor_miner_test.go
+++ /dev/null
@@ -1,222 +0,0 @@
-package actors_test
-
-import (
-	"bytes"
-	"context"
-	"math/rand"
-	"testing"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-sectorbuilder"
-	"github.com/filecoin-project/lotus/api"
-	"github.com/filecoin-project/lotus/chain/actors"
-	"github.com/filecoin-project/lotus/chain/actors/aerrors"
-	"github.com/filecoin-project/lotus/chain/stmgr"
-	"github.com/filecoin-project/lotus/chain/types"
-	hamt "github.com/ipfs/go-hamt-ipld"
-	blockstore "github.com/ipfs/go-ipfs-blockstore"
-	cbg "github.com/whyrusleeping/cbor-gen"
-)
-
-func TestMinerCommitSectors(t *testing.T) {
-	var worker, client address.Address
-	var minerAddr address.Address
-	opts := []HarnessOpt{
-		HarnessAddr(&worker, 1000000),
-		HarnessAddr(&client, 1000000),
-		HarnessActor(&minerAddr, &worker, actors.StorageMinerCodeCid,
-			func() cbg.CBORMarshaler {
-				return &actors.StorageMinerConstructorParams{
-					Owner:      worker,
-					Worker:     worker,
-					SectorSize: 1024,
-					PeerID:     "fakepeerid",
-				}
-			}),
-	}
-
-	h := NewHarness(t, opts...)
-	h.vm.Syscalls.ValidatePoRep = func(ctx context.Context, maddr address.Address, ssize uint64, commD, commR, ticket, proof, seed []byte, sectorID uint64) (bool, aerrors.ActorError) {
-		// all proofs are valid
-		return true, nil
-	}
-
-	ret, _ := h.SendFunds(t, worker, minerAddr, types.NewInt(100000))
-	ApplyOK(t, ret)
-
-	ret, _ = h.InvokeWithValue(t, client, actors.StorageMarketAddress, actors.SMAMethods.AddBalance, types.NewInt(2000), nil)
-	ApplyOK(t, ret)
-
-	addSectorToMiner(h, t, minerAddr, worker, client, 1)
-
-	assertSectorIDs(h, t, minerAddr, []uint64{1})
-}
-
-func TestMinerSubmitBadFault(t *testing.T) {
-	var worker, client address.Address
-	var minerAddr address.Address
-	opts := []HarnessOpt{
-		HarnessAddr(&worker, 1000000),
-		HarnessAddr(&client, 1000000),
-		HarnessActor(&minerAddr, &worker, actors.StorageMinerCodeCid,
-			func() cbg.CBORMarshaler {
-				return &actors.StorageMinerConstructorParams{
-					Owner:      worker,
-					Worker:     worker,
-					SectorSize: 1024,
-					PeerID:     "fakepeerid",
-				}
-			}),
-	}
-
-	h := NewHarness(t, opts...)
-	h.vm.Syscalls.ValidatePoRep = func(ctx context.Context, maddr address.Address, ssize uint64, commD, commR, ticket, proof, seed []byte, sectorID uint64) (bool, aerrors.ActorError) {
-		// all proofs are valid
-		return true, nil
-	}
-
-	ret, _ := h.SendFunds(t, worker, minerAddr, types.NewInt(100000))
-	ApplyOK(t, ret)
-
-	ret, _ = h.InvokeWithValue(t, client, actors.StorageMarketAddress, actors.SMAMethods.AddBalance, types.NewInt(2000), nil)
-	ApplyOK(t, ret)
-
-	addSectorToMiner(h, t, minerAddr, worker, client, 1)
-
-	assertSectorIDs(h, t, minerAddr, []uint64{1})
-
-	bf := types.NewBitField()
-	bf.Set(6)
-	ret, _ = h.Invoke(t, worker, minerAddr, actors.MAMethods.DeclareFaults, &actors.DeclareFaultsParams{bf})
-	ApplyOK(t, ret)
-
-	ret, _ = h.Invoke(t, actors.NetworkAddress, minerAddr, actors.MAMethods.SubmitElectionPoSt, nil)
-	ApplyOK(t, ret)
-
-	assertSectorIDs(h, t, minerAddr, []uint64{1})
-
-	badnum := uint64(0)
-	badnum--
-	bf = types.NewBitField()
-	bf.Set(badnum)
-	ret, _ = h.Invoke(t, worker, minerAddr, actors.MAMethods.DeclareFaults, &actors.DeclareFaultsParams{bf})
-	ApplyOK(t, ret)
-
-	ret, _ = h.Invoke(t, actors.NetworkAddress, minerAddr, actors.MAMethods.SubmitElectionPoSt, nil)
-	ApplyOK(t, ret)
-
-	bf = types.NewBitField()
-	bf.Set(1)
-	ret, _ = h.Invoke(t, worker, minerAddr, actors.MAMethods.DeclareFaults, &actors.DeclareFaultsParams{bf})
-	ApplyOK(t, ret)
-
-	ret, _ = h.Invoke(t, actors.NetworkAddress, minerAddr, actors.MAMethods.SubmitElectionPoSt, nil)
-	ApplyOK(t, ret)
-
-	assertSectorIDs(h, t, minerAddr, []uint64{})
-
-}
-
-func addSectorToMiner(h *Harness, t *testing.T, minerAddr, worker, client address.Address, sid uint64) {
-	t.Helper()
-	s := sectorbuilder.UserBytesForSectorSize(1024)
-	deal := h.makeFakeDeal(t, minerAddr, worker, client, s)
-	ret, _ := h.Invoke(t, worker, actors.StorageMarketAddress, actors.SMAMethods.PublishStorageDeals,
-		&actors.PublishStorageDealsParams{
-			Deals: []actors.StorageDealProposal{*deal},
-		})
-	ApplyOK(t, ret)
-	var dealIds actors.PublishStorageDealResponse
-	if err := dealIds.UnmarshalCBOR(bytes.NewReader(ret.Return)); err != nil {
-		t.Fatal(err)
-	}
-
-	dealid := dealIds.DealIDs[0]
-
-	ret, _ = h.Invoke(t, worker, minerAddr, actors.MAMethods.PreCommitSector,
-		&actors.SectorPreCommitInfo{
-			SectorNumber: sid,
-			CommR:        []byte("cats"),
-			SealEpoch:    10,
-			DealIDs:      []uint64{dealid},
-		})
-	ApplyOK(t, ret)
-
-	h.BlockHeight += 100
-	ret, _ = h.Invoke(t, worker, minerAddr, actors.MAMethods.ProveCommitSector,
-		&actors.SectorProveCommitInfo{
-			Proof:    []byte("prooofy"),
-			SectorID: sid,
-			DealIDs:  []uint64{dealid}, // TODO: weird that i have to pass this again
-		})
-	ApplyOK(t, ret)
-}
-
-func assertSectorIDs(h *Harness, t *testing.T, maddr address.Address, ids []uint64) {
-	t.Helper()
-	sectors, err := getMinerSectorSet(context.TODO(), h.vm.StateTree(), h.bs, maddr)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if len(sectors) != len(ids) {
-		t.Fatal("miner has wrong number of sectors in their sector set")
-	}
-
-	all := make(map[uint64]bool)
-	for _, s := range sectors {
-		all[s.SectorID] = true
-	}
-
-	for _, id := range ids {
-		if !all[id] {
-			t.Fatal("expected to find sector ID: ", id)
-		}
-	}
-}
-
-func getMinerSectorSet(ctx context.Context, st types.StateTree, bs blockstore.Blockstore, maddr address.Address) ([]*api.ChainSectorInfo, error) {
-	mact, err := st.GetActor(maddr)
-	if err != nil {
-		return nil, err
-	}
-
-	cst := hamt.CSTFromBstore(bs)
-
-	var mstate actors.StorageMinerActorState
-	if err := cst.Get(ctx, mact.Head, &mstate); err != nil {
-		return nil, err
-	}
-
-	return stmgr.LoadSectorsFromSet(ctx, bs, mstate.Sectors)
-}
-
-func (h *Harness) makeFakeDeal(t *testing.T, miner, worker, client address.Address, size uint64) *actors.StorageDealProposal {
-	data := make([]byte, size)
-	rand.Read(data)
-	commP, err := sectorbuilder.GeneratePieceCommitment(bytes.NewReader(data), size)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	prop := actors.StorageDealProposal{
-		PieceRef:  commP[:],
-		PieceSize: size,
-		//PieceSerialization SerializationMode // Needs to be here as it tells how data in the sector maps to PieceRef cid
-
-		Client:   client,
-		Provider: miner,
-
-		ProposalExpiration: 10000,
-		Duration:           150,
-
-		StoragePricePerEpoch: types.NewInt(1),
-		StorageCollateral:    types.NewInt(0),
-	}
-
-	if err := api.SignWith(context.TODO(), h.w.Sign, client, &prop); err != nil {
-		t.Fatal(err)
-	}
-
-	return &prop
-}
diff --git a/chain/actors/actor_multisig.go b/chain/actors/actor_multisig.go
deleted file mode 100644
index 4cff548ad..000000000
--- a/chain/actors/actor_multisig.go
+++ /dev/null
@@ -1,431 +0,0 @@
-package actors
-
-import (
-	"github.com/ipfs/go-cid"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/lotus/chain/actors/aerrors"
-	"github.com/filecoin-project/lotus/chain/types"
-
-	cbg "github.com/whyrusleeping/cbor-gen"
-)
-
-type MultiSigActor struct{}
-type MultiSigActorState struct {
-	Signers  []address.Address
-	Required uint64
-	NextTxID uint64
-
-	InitialBalance types.BigInt
-	StartingBlock  uint64
-	UnlockDuration uint64
-
-	//TODO: make this map/sharray/whatever
-	Transactions []MTransaction
-}
-
-func (msas MultiSigActorState) canSpend(act *types.Actor, amnt types.BigInt, height uint64) bool {
-	if msas.UnlockDuration == 0 {
-		return true
-	}
-
-	offset := height - msas.StartingBlock
-	if offset > msas.UnlockDuration {
-		return true
-	}
-
-	minBalance := types.BigDiv(msas.InitialBalance, types.NewInt(msas.UnlockDuration))
-	minBalance = types.BigMul(minBalance, types.NewInt(offset))
-	return !minBalance.LessThan(types.BigSub(act.Balance, amnt))
-}
-
-func (msas MultiSigActorState) isSigner(addr address.Address) bool {
-	for _, s := range msas.Signers {
-		if s == addr {
-			return true
-		}
-	}
-	return false
-}
-
-func (msas MultiSigActorState) getTransaction(txid uint64) (*MTransaction, ActorError) {
-	if txid >= uint64(len(msas.Transactions)) {
-		return nil, aerrors.Newf(1, "could not get transaction (numbers of tx %d,want to get txid %d)", len(msas.Transactions), txid)
-	}
-	return &msas.Transactions[txid], nil
-}
-
-type MTransaction struct {
-	Created uint64 // NOT USED ??
-	TxID    uint64
-
-	To     address.Address
-	Value  types.BigInt
-	Method uint64
-	Params []byte
-
-	Approved []address.Address
-	Complete bool
-	Canceled bool
-	RetCode  uint64
-}
-
-func (tx MTransaction) Active() ActorError {
-	if tx.Complete {
-		return aerrors.New(2, "transaction already completed")
-	}
-	if tx.Canceled {
-		return aerrors.New(3, "transaction canceled")
-	}
-	return nil
-}
-
-type musigMethods struct {
-	MultiSigConstructor uint64
-	Propose             uint64
-	Approve             uint64
-	Cancel              uint64
-	ClearCompleted      uint64
-	AddSigner           uint64
-	RemoveSigner        uint64
-	SwapSigner          uint64
-	ChangeRequirement   uint64
-}
-
-var MultiSigMethods = musigMethods{1, 2, 3, 4, 5, 6, 7, 8, 9}
-
-func (msa MultiSigActor) Exports() []interface{} {
-	return []interface{}{
-		1: msa.MultiSigConstructor,
-		2: msa.Propose,
-		3: msa.Approve,
-		4: msa.Cancel,
-		//5: msa.ClearCompleted,
-		6: msa.AddSigner,
-		7: msa.RemoveSigner,
-		8: msa.SwapSigner,
-		9: msa.ChangeRequirement,
-	}
-}
-
-type MultiSigConstructorParams struct {
-	Signers        []address.Address
-	Required       uint64
-	UnlockDuration uint64
-}
-
-func (MultiSigActor) MultiSigConstructor(act *types.Actor, vmctx types.VMContext,
-	params *MultiSigConstructorParams) ([]byte, ActorError) {
-	self := &MultiSigActorState{
-		Signers:  params.Signers,
-		Required: params.Required,
-	}
-
-	if params.UnlockDuration != 0 {
-		self.InitialBalance = vmctx.Message().Value
-		self.UnlockDuration = params.UnlockDuration
-		self.StartingBlock = vmctx.BlockHeight()
-	}
-
-	head, err := vmctx.Storage().Put(self)
-	if err != nil {
-		return nil, aerrors.Wrap(err, "could not put new head")
-	}
-	err = vmctx.Storage().Commit(EmptyCBOR, head)
-	if err != nil {
-		return nil, aerrors.Wrap(err, "could not commit new head")
-	}
-	return nil, nil
-}
-
-type MultiSigProposeParams struct {
-	To     address.Address
-	Value  types.BigInt
-	Method uint64
-	Params []byte
-}
-
-func (MultiSigActor) load(vmctx types.VMContext) (cid.Cid, *MultiSigActorState, ActorError) {
-	var self MultiSigActorState
-	head := vmctx.Storage().GetHead()
-
-	err := vmctx.Storage().Get(head, &self)
-	if err != nil {
-		return cid.Undef, nil, aerrors.Wrap(err, "could not get self")
-	}
-	return head, &self, nil
-}
-
-func (msa MultiSigActor) loadAndVerify(vmctx types.VMContext) (cid.Cid, *MultiSigActorState, ActorError) {
-	head, self, err := msa.load(vmctx)
-	if err != nil {
-		return cid.Undef, nil, err
-	}
-
-	if !self.isSigner(vmctx.Message().From) {
-		return cid.Undef, nil, aerrors.New(1, "not authorized")
-	}
-	return head, self, nil
-}
-
-func (MultiSigActor) save(vmctx types.VMContext, oldHead cid.Cid, self *MultiSigActorState) ActorError {
-	newHead, err := vmctx.Storage().Put(self)
-	if err != nil {
-		return aerrors.Wrap(err, "could not put new head")
-	}
-	err = vmctx.Storage().Commit(oldHead, newHead)
-	if err != nil {
-		return aerrors.Wrap(err, "could not commit new head")
-	}
-	return nil
-
-}
-
-func (msa MultiSigActor) Propose(act *types.Actor, vmctx types.VMContext,
-	params *MultiSigProposeParams) ([]byte, ActorError) {
-
-	head, self, err := msa.loadAndVerify(vmctx)
-	if err != nil {
-		return nil, err
-	}
-
-	txid := self.NextTxID
-	self.NextTxID++
-
-	{
-		tx := MTransaction{
-			TxID:     txid,
-			To:       params.To,
-			Value:    params.Value,
-			Method:   params.Method,
-			Params:   params.Params,
-			Approved: []address.Address{vmctx.Message().From},
-		}
-		self.Transactions = append(self.Transactions, tx)
-	}
-
-	tx, err := self.getTransaction(txid)
-	if err != nil {
-		return nil, err
-	}
-
-	if self.Required == 1 {
-		if !self.canSpend(act, tx.Value, vmctx.BlockHeight()) {
-			return nil, aerrors.New(100, "transaction amount exceeds available")
-		}
-		_, err := vmctx.Send(tx.To, tx.Method, tx.Value, tx.Params)
-		if aerrors.IsFatal(err) {
-			return nil, err
-		}
-		tx.RetCode = uint64(aerrors.RetCode(err))
-		tx.Complete = true
-	}
-
-	err = msa.save(vmctx, head, self)
-	if err != nil {
-		return nil, aerrors.Wrap(err, "saving state")
-	}
-
-	// REVIEW: On one hand, I like being very explicit about how we're doing the serialization
-	// on the other, maybe we shouldnt do direct calls to underlying serialization libs?
-	return cbg.CborEncodeMajorType(cbg.MajUnsignedInt, tx.TxID), nil
-}
-
-type MultiSigTxID struct {
-	TxID uint64
-}
-
-func (msa MultiSigActor) Approve(act *types.Actor, vmctx types.VMContext,
-	params *MultiSigTxID) ([]byte, ActorError) {
-
-	head, self, err := msa.loadAndVerify(vmctx)
-	if err != nil {
-		return nil, err
-	}
-
-	tx, err := self.getTransaction(params.TxID)
-	if err != nil {
-		return nil, err
-	}
-
-	if err := tx.Active(); err != nil {
-		return nil, aerrors.Wrap(err, "could not approve")
-	}
-
-	for _, signer := range tx.Approved {
-		if signer == vmctx.Message().From {
-			return nil, aerrors.New(4, "already signed this message")
-		}
-	}
-	tx.Approved = append(tx.Approved, vmctx.Message().From)
-	if uint64(len(tx.Approved)) >= self.Required {
-		if !self.canSpend(act, tx.Value, vmctx.BlockHeight()) {
-			return nil, aerrors.New(100, "transaction amount exceeds available")
-		}
-		_, err := vmctx.Send(tx.To, tx.Method, tx.Value, tx.Params)
-		if aerrors.IsFatal(err) {
-			return nil, err
-		}
-		tx.RetCode = uint64(aerrors.RetCode(err))
-		tx.Complete = true
-	}
-
-	return nil, msa.save(vmctx, head, self)
-}
-
-func (msa MultiSigActor) Cancel(act *types.Actor, vmctx types.VMContext,
-	params *MultiSigTxID) ([]byte, ActorError) {
-
-	head, self, err := msa.loadAndVerify(vmctx)
-	if err != nil {
-		return nil, err
-	}
-
-	tx, err := self.getTransaction(params.TxID)
-	if err != nil {
-		return nil, err
-	}
-
-	if err := tx.Active(); err != nil {
-		return nil, aerrors.Wrap(err, "could not cancel")
-	}
-
-	proposer := tx.Approved[0]
-	if proposer != vmctx.Message().From && self.isSigner(proposer) {
-		return nil, aerrors.New(4, "cannot cancel another signers transaction")
-	}
-	tx.Canceled = true
-
-	return nil, msa.save(vmctx, head, self)
-}
-
-type MultiSigAddSignerParam struct {
-	Signer   address.Address
-	Increase bool
-}
-
-func (msa MultiSigActor) AddSigner(act *types.Actor, vmctx types.VMContext,
-	params *MultiSigAddSignerParam) ([]byte, ActorError) {
-
-	head, self, err := msa.load(vmctx)
-	if err != nil {
-		return nil, err
-	}
-
-	msg := vmctx.Message()
-	if msg.From != msg.To {
-		return nil, aerrors.New(4, "add signer must be called by wallet itself")
-	}
-	if self.isSigner(params.Signer) {
-		return nil, aerrors.New(5, "new address is already a signer")
-	}
-
-	self.Signers = append(self.Signers, params.Signer)
-	if params.Increase {
-		self.Required = self.Required + 1
-	}
-
-	return nil, msa.save(vmctx, head, self)
-}
-
-type MultiSigRemoveSignerParam struct {
-	Signer   address.Address
-	Decrease bool
-}
-
-func (msa MultiSigActor) RemoveSigner(act *types.Actor, vmctx types.VMContext,
-	params *MultiSigRemoveSignerParam) ([]byte, ActorError) {
-
-	head, self, err := msa.load(vmctx)
-	if err != nil {
-		return nil, err
-	}
-
-	msg := vmctx.Message()
-	if msg.From != msg.To {
-		return nil, aerrors.New(4, "remove signer must be called by wallet itself")
-	}
-	if !self.isSigner(params.Signer) {
-		return nil, aerrors.New(5, "given address was not a signer")
-	}
-
-	newSigners := make([]address.Address, 0, len(self.Signers)-1)
-	for _, s := range self.Signers {
-		if s != params.Signer {
-			newSigners = append(newSigners, s)
-		}
-	}
-	if params.Decrease || uint64(len(self.Signers)-1) < self.Required {
-		self.Required = self.Required - 1
-	}
-
-	self.Signers = newSigners
-
-	return nil, msa.save(vmctx, head, self)
-}
-
-type MultiSigSwapSignerParams struct {
-	From address.Address
-	To   address.Address
-}
-
-func (msa MultiSigActor) SwapSigner(act *types.Actor, vmctx types.VMContext,
-	params *MultiSigSwapSignerParams) ([]byte, ActorError) {
-
-	head, self, err := msa.load(vmctx)
-	if err != nil {
-		return nil, err
-	}
-
-	msg := vmctx.Message()
-	if msg.From != msg.To {
-		return nil, aerrors.New(4, "swap signer must be called by wallet itself")
-	}
-
-	if !self.isSigner(params.From) {
-		return nil, aerrors.New(5, "given old address was not a signer")
-	}
-	if self.isSigner(params.To) {
-		return nil, aerrors.New(6, "given new address was already a signer")
-	}
-
-	newSigners := make([]address.Address, 0, len(self.Signers))
-	for _, s := range self.Signers {
-		if s != params.From {
-			newSigners = append(newSigners, s)
-		}
-	}
-	newSigners = append(newSigners, params.To)
-	self.Signers = newSigners
-
-	return nil, msa.save(vmctx, head, self)
-}
-
-type MultiSigChangeReqParams struct {
-	Req uint64
-}
-
-func (msa MultiSigActor) ChangeRequirement(act *types.Actor, vmctx types.VMContext,
-	params *MultiSigChangeReqParams) ([]byte, ActorError) {
-
-	head, self, err := msa.load(vmctx)
-	if err != nil {
-		return nil, err
-	}
-
-	msg := vmctx.Message()
-	if msg.From != msg.To {
-		return nil, aerrors.New(4, "change requirement must be called by wallet itself")
-	}
-
-	if params.Req < 1 {
-		return nil, aerrors.New(5, "requirement must be at least 1")
-	}
-
-	if params.Req > uint64(len(self.Signers)) {
-		return nil, aerrors.New(6, "requirement must be at most the numbers of signers")
-	}
-
-	self.Required = params.Req
-	return nil, msa.save(vmctx, head, self)
-}
diff --git a/chain/actors/actor_multisig_test.go b/chain/actors/actor_multisig_test.go
deleted file mode 100644
index 5ed76265c..000000000
--- a/chain/actors/actor_multisig_test.go
+++ /dev/null
@@ -1,97 +0,0 @@
-package actors_test
-
-import (
-	"testing"
-
-	cbor "github.com/ipfs/go-ipld-cbor"
-	"github.com/stretchr/testify/assert"
-	cbg "github.com/whyrusleeping/cbor-gen"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/lotus/chain/actors"
-	"github.com/filecoin-project/lotus/chain/types"
-	"github.com/filecoin-project/lotus/chain/vm"
-)
-
-func TestMultiSigCreate(t *testing.T) {
-	var creatorAddr, sig1Addr, sig2Addr, outsideAddr address.Address
-	opts := []HarnessOpt{
-		HarnessAddr(&creatorAddr, 100000),
-		HarnessAddr(&sig1Addr, 100000),
-		HarnessAddr(&sig2Addr, 100000),
-		HarnessAddr(&outsideAddr, 100000),
-	}
-
-	h := NewHarness(t, opts...)
-	ret, _ := h.CreateActor(t, creatorAddr, actors.MultisigCodeCid,
-		&actors.MultiSigConstructorParams{
-			Signers:  []address.Address{creatorAddr, sig1Addr, sig2Addr},
-			Required: 2,
-		})
-	ApplyOK(t, ret)
-}
-
-func ApplyOK(t testing.TB, ret *vm.ApplyRet) {
-	t.Helper()
-	if ret.ExitCode != 0 {
-		t.Fatalf("exit code should be 0, got %d, actorErr: %+v", ret.ExitCode, ret.ActorErr)
-	}
-	if ret.ActorErr != nil {
-		t.Fatalf("somehow got an error with exit == 0: %s", ret.ActorErr)
-	}
-}
-
-func TestMultiSigOps(t *testing.T) {
-	var creatorAddr, sig1Addr, sig2Addr, outsideAddr address.Address
-	var multSigAddr address.Address
-	opts := []HarnessOpt{
-		HarnessAddr(&creatorAddr, 100000),
-		HarnessAddr(&sig1Addr, 100000),
-		HarnessAddr(&sig2Addr, 100000),
-		HarnessAddr(&outsideAddr, 100000),
-		HarnessActor(&multSigAddr, &creatorAddr, actors.MultisigCodeCid,
-			func() cbg.CBORMarshaler {
-				return &actors.MultiSigConstructorParams{
-					Signers:  []address.Address{creatorAddr, sig1Addr, sig2Addr},
-					Required: 2,
-				}
-			}),
-	}
-
-	h := NewHarness(t, opts...)
-	{
-		const chargeVal = 2000
-		// Send funds into the multisig
-		ret, _ := h.SendFunds(t, creatorAddr, multSigAddr, types.NewInt(chargeVal))
-		ApplyOK(t, ret)
-		h.AssertBalanceChange(t, creatorAddr, -chargeVal)
-		h.AssertBalanceChange(t, multSigAddr, chargeVal)
-	}
-
-	{
-		// Transfer funds outside of multsig
-		const sendVal = 1000
-		ret, _ := h.Invoke(t, creatorAddr, multSigAddr, actors.MultiSigMethods.Propose,
-			&actors.MultiSigProposeParams{
-				To:    outsideAddr,
-				Value: types.NewInt(sendVal),
-			})
-		ApplyOK(t, ret)
-		var txIDParam actors.MultiSigTxID
-		err := cbor.DecodeInto(ret.Return, &txIDParam.TxID)
-		assert.NoError(t, err, "decoding txid")
-
-		ret, _ = h.Invoke(t, outsideAddr, multSigAddr, actors.MultiSigMethods.Approve,
-			&txIDParam)
-		assert.Equal(t, uint8(1), ret.ExitCode, "outsideAddr should not approve")
-		h.AssertBalanceChange(t, multSigAddr, 0)
-
-		ret2, _ := h.Invoke(t, sig1Addr, multSigAddr, actors.MultiSigMethods.Approve,
-			&txIDParam)
-		ApplyOK(t, ret2)
-
-		h.AssertBalanceChange(t, outsideAddr, sendVal)
-		h.AssertBalanceChange(t, multSigAddr, -sendVal)
-	}
-
-}
diff --git a/chain/actors/actor_paych.go b/chain/actors/actor_paych.go
deleted file mode 100644
index 32181e592..000000000
--- a/chain/actors/actor_paych.go
+++ /dev/null
@@ -1,302 +0,0 @@
-package actors
-
-import (
-	"bytes"
-	"fmt"
-
-	"github.com/ipfs/go-cid"
-	"github.com/minio/blake2b-simd"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/lotus/build"
-	"github.com/filecoin-project/lotus/chain/actors/aerrors"
-	"github.com/filecoin-project/lotus/chain/types"
-)
-
-type PaymentChannelActor struct{}
-
-type PaymentInfo struct {
-	PayChActor     address.Address
-	Payer          address.Address
-	ChannelMessage *cid.Cid
-
-	Vouchers []*types.SignedVoucher
-}
-
-type LaneState struct {
-	Closed   bool
-	Redeemed types.BigInt
-	Nonce    uint64
-}
-
-type PaymentChannelActorState struct {
-	From address.Address
-	To   address.Address
-
-	ToSend types.BigInt
-
-	ClosingAt      uint64
-	MinCloseHeight uint64
-
-	// TODO: needs to be map[uint64]*laneState
-	// waiting on refmt#35 to be fixed
-	LaneStates map[string]*LaneState
-}
-
-func (pca PaymentChannelActor) Exports() []interface{} {
-	return []interface{}{
-		1: pca.Constructor,
-		2: pca.UpdateChannelState,
-		3: pca.Close,
-		4: pca.Collect,
-		5: pca.GetOwner,
-		6: pca.GetToSend,
-	}
-}
-
-type pcaMethods struct {
-	Constructor        uint64
-	UpdateChannelState uint64
-	Close              uint64
-	Collect            uint64
-	GetOwner           uint64
-	GetToSend          uint64
-}
-
-var PCAMethods = pcaMethods{1, 2, 3, 4, 5, 6}
-
-type PCAConstructorParams struct {
-	To address.Address
-}
-
-func (pca PaymentChannelActor) Constructor(act *types.Actor, vmctx types.VMContext, params *PCAConstructorParams) ([]byte, ActorError) {
-	var self PaymentChannelActorState
-	self.From = vmctx.Origin()
-	self.To = params.To
-	self.LaneStates = make(map[string]*LaneState)
-
-	storage := vmctx.Storage()
-	c, err := storage.Put(&self)
-	if err != nil {
-		return nil, err
-	}
-
-	if err := storage.Commit(EmptyCBOR, c); err != nil {
-		return nil, err
-	}
-
-	return nil, nil
-}
-
-type PCAUpdateChannelStateParams struct {
-	Sv     types.SignedVoucher
-	Secret []byte
-	Proof  []byte
-}
-
-func hash(b []byte) []byte {
-	s := blake2b.Sum256(b)
-	return s[:]
-}
-
-type PaymentVerifyParams struct {
-	Extra []byte
-	Proof []byte
-}
-
-func (pca PaymentChannelActor) UpdateChannelState(act *types.Actor, vmctx types.VMContext, params *PCAUpdateChannelStateParams) ([]byte, ActorError) {
-	var self PaymentChannelActorState
-	oldstate := vmctx.Storage().GetHead()
-	storage := vmctx.Storage()
-	if err := storage.Get(oldstate, &self); err != nil {
-		return nil, err
-	}
-
-	sv := params.Sv
-
-	vb, nerr := sv.SigningBytes()
-	if nerr != nil {
-		return nil, aerrors.Escalate(nerr, "failed to serialize signedvoucher")
-	}
-
-	if err := vmctx.VerifySignature(sv.Signature, self.From, vb); err != nil {
-		return nil, err
-	}
-
-	if vmctx.BlockHeight() < sv.TimeLock {
-		return nil, aerrors.New(2, "cannot use this voucher yet!")
-	}
-
-	if len(sv.SecretPreimage) > 0 {
-		if !bytes.Equal(hash(params.Secret), sv.SecretPreimage) {
-			return nil, aerrors.New(3, "incorrect secret!")
-		}
-	}
-
-	if sv.Extra != nil {
-		encoded, err := SerializeParams(&PaymentVerifyParams{sv.Extra.Data, params.Proof})
-		if err != nil {
-			return nil, err
-		}
-
-		_, err = vmctx.Send(sv.Extra.Actor, sv.Extra.Method, types.NewInt(0), encoded)
-		if err != nil {
-			return nil, aerrors.Newf(4, "spend voucher verification failed: %s", err)
-		}
-	}
-
-	ls, ok := self.LaneStates[fmt.Sprint(sv.Lane)]
-	if !ok {
-		ls = new(LaneState)
-		ls.Redeemed = types.NewInt(0) // TODO: kinda annoying that this doesnt default to a usable value
-		self.LaneStates[fmt.Sprint(sv.Lane)] = ls
-	}
-	if ls.Closed {
-		return nil, aerrors.New(5, "cannot redeem a voucher on a closed lane")
-	}
-
-	if ls.Nonce > sv.Nonce {
-		return nil, aerrors.New(6, "voucher has an outdated nonce, cannot redeem")
-	}
-
-	mergeValue := types.NewInt(0)
-	for _, merge := range sv.Merges {
-		if merge.Lane == sv.Lane {
-			return nil, aerrors.New(7, "voucher cannot merge its own lane")
-		}
-
-		ols := self.LaneStates[fmt.Sprint(merge.Lane)]
-
-		if ols.Nonce >= merge.Nonce {
-			return nil, aerrors.New(8, "merge in voucher has outdated nonce, cannot redeem")
-		}
-
-		mergeValue = types.BigAdd(mergeValue, ols.Redeemed)
-		ols.Nonce = merge.Nonce
-	}
-
-	ls.Nonce = sv.Nonce
-	balanceDelta := types.BigSub(sv.Amount, types.BigAdd(mergeValue, ls.Redeemed))
-	ls.Redeemed = sv.Amount
-
-	newSendBalance := types.BigAdd(self.ToSend, balanceDelta)
-	if newSendBalance.LessThan(types.NewInt(0)) {
-		// TODO: is this impossible?
-		return nil, aerrors.New(9, "voucher would leave channel balance negative")
-	}
-
-	if newSendBalance.GreaterThan(act.Balance) {
-		return nil, aerrors.New(10, "not enough funds in channel to cover voucher")
-	}
-
-	log.Info("vals: ", newSendBalance, sv.Amount, balanceDelta, mergeValue, ls.Redeemed)
-	self.ToSend = newSendBalance
-
-	if sv.MinCloseHeight != 0 {
-		if self.ClosingAt != 0 && self.ClosingAt < sv.MinCloseHeight {
-			self.ClosingAt = sv.MinCloseHeight
-		}
-		if self.MinCloseHeight < sv.MinCloseHeight {
-			self.MinCloseHeight = sv.MinCloseHeight
-		}
-	}
-
-	ncid, err := storage.Put(&self)
-	if err != nil {
-		return nil, err
-	}
-	if err := storage.Commit(oldstate, ncid); err != nil {
-		return nil, err
-	}
-
-	return nil, nil
-}
-
-func (pca PaymentChannelActor) Close(act *types.Actor, vmctx types.VMContext, params *struct{}) ([]byte, aerrors.ActorError) {
-	var self PaymentChannelActorState
-	storage := vmctx.Storage()
-	oldstate := storage.GetHead()
-	if err := storage.Get(oldstate, &self); err != nil {
-		return nil, err
-	}
-
-	if vmctx.Message().From != self.From && vmctx.Message().From != self.To {
-		return nil, aerrors.New(1, "not authorized to close channel")
-	}
-
-	if self.ClosingAt != 0 {
-		return nil, aerrors.New(2, "channel already closing")
-	}
-
-	self.ClosingAt = vmctx.BlockHeight() + build.PaymentChannelClosingDelay
-	if self.ClosingAt < self.MinCloseHeight {
-		self.ClosingAt = self.MinCloseHeight
-	}
-
-	ncid, err := storage.Put(&self)
-	if err != nil {
-		return nil, err
-	}
-	if err := storage.Commit(oldstate, ncid); err != nil {
-		return nil, err
-	}
-
-	return nil, nil
-}
-
-func (pca PaymentChannelActor) Collect(act *types.Actor, vmctx types.VMContext, params *struct{}) ([]byte, aerrors.ActorError) {
-	var self PaymentChannelActorState
-	storage := vmctx.Storage()
-	oldstate := storage.GetHead()
-	if err := storage.Get(oldstate, &self); err != nil {
-		return nil, err
-	}
-
-	if self.ClosingAt == 0 {
-		return nil, aerrors.New(1, "payment channel not closing or closed")
-	}
-
-	if vmctx.BlockHeight() < self.ClosingAt {
-		return nil, aerrors.New(2, "payment channel not closed yet")
-	}
-	_, err := vmctx.Send(self.From, 0, types.BigSub(act.Balance, self.ToSend), nil)
-	if err != nil {
-		return nil, err
-	}
-	_, err = vmctx.Send(self.To, 0, self.ToSend, nil)
-	if err != nil {
-		return nil, err
-	}
-
-	self.ToSend = types.NewInt(0)
-
-	ncid, err := storage.Put(&self)
-	if err != nil {
-		return nil, err
-	}
-	if err := storage.Commit(oldstate, ncid); err != nil {
-		return nil, err
-	}
-
-	return nil, nil
-}
-
-func (pca PaymentChannelActor) GetOwner(act *types.Actor, vmctx types.VMContext, params *struct{}) ([]byte, aerrors.ActorError) {
-	var self PaymentChannelActorState
-	storage := vmctx.Storage()
-	if err := storage.Get(storage.GetHead(), &self); err != nil {
-		return nil, err
-	}
-
-	return self.From.Bytes(), nil
-}
-
-func (pca PaymentChannelActor) GetToSend(act *types.Actor, vmctx types.VMContext, params *struct{}) ([]byte, aerrors.ActorError) {
-	var self PaymentChannelActorState
-	storage := vmctx.Storage()
-	if err := storage.Get(storage.GetHead(), &self); err != nil {
-		return nil, err
-	}
-
-	return self.ToSend.Bytes(), nil
-}
diff --git a/chain/actors/actor_paych_test.go b/chain/actors/actor_paych_test.go
deleted file mode 100644
index 226f147c5..000000000
--- a/chain/actors/actor_paych_test.go
+++ /dev/null
@@ -1,93 +0,0 @@
-package actors_test
-
-import (
-	"context"
-	"testing"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/lotus/chain/actors"
-	"github.com/filecoin-project/lotus/chain/types"
-	"github.com/filecoin-project/lotus/chain/wallet"
-)
-
-func TestPaychCreate(t *testing.T) {
-	var creatorAddr, targetAddr address.Address
-	opts := []HarnessOpt{
-		HarnessAddr(&creatorAddr, 100000),
-		HarnessAddr(&targetAddr, 100000),
-	}
-
-	h := NewHarness(t, opts...)
-	ret, _ := h.CreateActor(t, creatorAddr, actors.PaymentChannelCodeCid,
-		&actors.PCAConstructorParams{
-			To: targetAddr,
-		})
-	ApplyOK(t, ret)
-}
-
-func signVoucher(t *testing.T, w *wallet.Wallet, addr address.Address, sv *types.SignedVoucher) {
-	vb, err := sv.SigningBytes()
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	sig, err := w.Sign(context.TODO(), addr, vb)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	sv.Signature = sig
-}
-
-func TestPaychUpdate(t *testing.T) {
-	var creatorAddr, targetAddr address.Address
-	opts := []HarnessOpt{
-		HarnessAddr(&creatorAddr, 100000),
-		HarnessAddr(&targetAddr, 100000),
-	}
-
-	h := NewHarness(t, opts...)
-	ret, _ := h.CreateActor(t, creatorAddr, actors.PaymentChannelCodeCid,
-		&actors.PCAConstructorParams{
-			To: targetAddr,
-		})
-	ApplyOK(t, ret)
-	pch, err := address.NewFromBytes(ret.Return)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	ret, _ = h.SendFunds(t, creatorAddr, pch, types.NewInt(5000))
-	ApplyOK(t, ret)
-
-	sv := &types.SignedVoucher{
-		Amount: types.NewInt(100),
-		Nonce:  1,
-	}
-	signVoucher(t, h.w, creatorAddr, sv)
-
-	ret, _ = h.Invoke(t, targetAddr, pch, actors.PCAMethods.UpdateChannelState, &actors.PCAUpdateChannelStateParams{
-		Sv: *sv,
-	})
-	ApplyOK(t, ret)
-
-	ret, _ = h.Invoke(t, targetAddr, pch, actors.PCAMethods.GetToSend, nil)
-	ApplyOK(t, ret)
-
-	bi := types.BigFromBytes(ret.Return)
-	if bi.String() != "100" {
-		t.Fatal("toSend amount was wrong: ", bi.String())
-	}
-
-	ret, _ = h.Invoke(t, targetAddr, pch, actors.PCAMethods.Close, nil)
-	ApplyOK(t, ret)
-
-	// now we have to 'wait' for the chain to advance.
-	h.BlockHeight = 1000
-
-	ret, _ = h.Invoke(t, targetAddr, pch, actors.PCAMethods.Collect, nil)
-	ApplyOK(t, ret)
-
-	h.AssertBalanceChange(t, targetAddr, 100)
-	h.AssertBalanceChange(t, creatorAddr, -100)
-}
diff --git a/chain/actors/actor_storagemarket.go b/chain/actors/actor_storagemarket.go
deleted file mode 100644
index e4ad58cb5..000000000
--- a/chain/actors/actor_storagemarket.go
+++ /dev/null
@@ -1,670 +0,0 @@
-package actors
-
-import (
-	"bytes"
-	"context"
-	"sort"
-
-	"go.opencensus.io/trace"
-	"golang.org/x/xerrors"
-
-	"github.com/filecoin-project/go-amt-ipld"
-	"github.com/ipfs/go-cid"
-	"github.com/ipfs/go-hamt-ipld"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-cbor-util"
-	"github.com/filecoin-project/go-sectorbuilder"
-	"github.com/filecoin-project/lotus/build"
-	"github.com/filecoin-project/lotus/chain/actors/aerrors"
-	"github.com/filecoin-project/lotus/chain/types"
-)
-
-type StorageMarketActor struct{}
-
-type smaMethods struct {
-	Constructor                  uint64
-	WithdrawBalance              uint64
-	AddBalance                   uint64
-	CheckLockedBalance           uint64
-	PublishStorageDeals          uint64
-	HandleCronAction             uint64
-	SettleExpiredDeals           uint64
-	ProcessStorageDealsPayment   uint64
-	SlashStorageDealCollateral   uint64
-	GetLastExpirationFromDealIDs uint64
-	ActivateStorageDeals         uint64
-	ComputeDataCommitment        uint64
-}
-
-var SMAMethods = smaMethods{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}
-
-func (sma StorageMarketActor) Exports() []interface{} {
-	return []interface{}{
-		2: sma.WithdrawBalance,
-		3: sma.AddBalance,
-		// 4: sma.CheckLockedBalance,
-		5: sma.PublishStorageDeals,
-		// 6: sma.HandleCronAction,
-		// 7: sma.SettleExpiredDeals,
-		// 8: sma.ProcessStorageDealsPayment,
-		// 9: sma.SlashStorageDealCollateral,
-		// 10: sma.GetLastExpirationFromDealIDs,
-		11: sma.ActivateStorageDeals, // TODO: move under PublishStorageDeals after specs team approves
-		12: sma.ComputeDataCommitment,
-	}
-}
-
-type StorageParticipantBalance struct {
-	Locked    types.BigInt
-	Available types.BigInt
-}
-
-type StorageMarketState struct {
-	Balances cid.Cid // hamt<addr, StorageParticipantBalance>
-	Deals    cid.Cid // amt<StorageDeal>
-
-	NextDealID uint64 // TODO: spec
-}
-
-// TODO: Drop in favour of car storage
-type SerializationMode = uint64
-
-const (
-	SerializationUnixFSv0 = iota
-	// IPLD / car
-)
-
-type StorageDealProposal struct {
-	PieceRef  []byte // cid bytes // TODO: spec says to use cid.Cid, probably not a good idea
-	PieceSize uint64
-
-	Client   address.Address
-	Provider address.Address
-
-	ProposalExpiration uint64
-	Duration           uint64 // TODO: spec
-
-	StoragePricePerEpoch types.BigInt
-	StorageCollateral    types.BigInt
-
-	ProposerSignature *types.Signature
-}
-
-func (sdp *StorageDealProposal) TotalStoragePrice() types.BigInt {
-	return types.BigMul(sdp.StoragePricePerEpoch, types.NewInt(sdp.Duration))
-}
-
-type SignFunc = func(context.Context, []byte) (*types.Signature, error)
-
-func (sdp *StorageDealProposal) Sign(ctx context.Context, sign SignFunc) error {
-	if sdp.ProposerSignature != nil {
-		return xerrors.New("signature already present in StorageDealProposal")
-	}
-	var buf bytes.Buffer
-	if err := sdp.MarshalCBOR(&buf); err != nil {
-		return err
-	}
-	sig, err := sign(ctx, buf.Bytes())
-	if err != nil {
-		return err
-	}
-	sdp.ProposerSignature = sig
-	return nil
-}
-
-func (sdp *StorageDealProposal) Cid() (cid.Cid, error) {
-	nd, err := cborutil.AsIpld(sdp)
-	if err != nil {
-		return cid.Undef, err
-	}
-
-	return nd.Cid(), nil
-}
-
-func (sdp *StorageDealProposal) Verify() error {
-	unsigned := *sdp
-	unsigned.ProposerSignature = nil
-	var buf bytes.Buffer
-	if err := unsigned.MarshalCBOR(&buf); err != nil {
-		return err
-	}
-
-	return sdp.ProposerSignature.Verify(sdp.Client, buf.Bytes())
-}
-
-type OnChainDeal struct {
-	PieceRef  []byte // cid bytes // TODO: spec says to use cid.Cid, probably not a good idea
-	PieceSize uint64
-
-	Client   address.Address
-	Provider address.Address
-
-	ProposalExpiration uint64
-	Duration           uint64 // TODO: spec
-
-	StoragePricePerEpoch types.BigInt
-	StorageCollateral    types.BigInt
-	ActivationEpoch      uint64 // 0 = inactive
-}
-
-type WithdrawBalanceParams struct {
-	Balance types.BigInt
-}
-
-func (sma StorageMarketActor) WithdrawBalance(act *types.Actor, vmctx types.VMContext, params *WithdrawBalanceParams) ([]byte, ActorError) {
-	// TODO: (spec) this should be 2-stage
-
-	var self StorageMarketState
-	old := vmctx.Storage().GetHead()
-	if err := vmctx.Storage().Get(old, &self); err != nil {
-		return nil, err
-	}
-
-	b, bnd, err := GetMarketBalances(vmctx.Context(), vmctx.Ipld(), self.Balances, vmctx.Message().From)
-	if err != nil {
-		return nil, aerrors.Wrap(err, "could not get balance")
-	}
-
-	balance := b[0]
-
-	if balance.Available.LessThan(params.Balance) {
-		return nil, aerrors.Newf(1, "can not withdraw more funds than available: %s > %s", params.Balance, b[0].Available)
-	}
-
-	balance.Available = types.BigSub(balance.Available, params.Balance)
-
-	_, err = vmctx.Send(vmctx.Message().From, 0, params.Balance, nil)
-	if err != nil {
-		return nil, aerrors.Wrap(err, "sending funds failed")
-	}
-
-	bcid, err := setMarketBalances(vmctx, bnd, map[address.Address]StorageParticipantBalance{
-		vmctx.Message().From: balance,
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	self.Balances = bcid
-
-	nroot, err := vmctx.Storage().Put(&self)
-	if err != nil {
-		return nil, err
-	}
-
-	return nil, vmctx.Storage().Commit(old, nroot)
-}
-
-func (sma StorageMarketActor) AddBalance(act *types.Actor, vmctx types.VMContext, params *struct{}) ([]byte, ActorError) {
-	var self StorageMarketState
-	old := vmctx.Storage().GetHead()
-	if err := vmctx.Storage().Get(old, &self); err != nil {
-		return nil, err
-	}
-
-	b, bnd, err := GetMarketBalances(vmctx.Context(), vmctx.Ipld(), self.Balances, vmctx.Message().From)
-	if err != nil {
-		return nil, aerrors.Wrap(err, "could not get balance")
-	}
-
-	balance := b[0]
-
-	balance.Available = types.BigAdd(balance.Available, vmctx.Message().Value)
-
-	bcid, err := setMarketBalances(vmctx, bnd, map[address.Address]StorageParticipantBalance{
-		vmctx.Message().From: balance,
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	self.Balances = bcid
-
-	nroot, err := vmctx.Storage().Put(&self)
-	if err != nil {
-		return nil, err
-	}
-
-	return nil, vmctx.Storage().Commit(old, nroot)
-}
-
-func setMarketBalances(vmctx types.VMContext, nd *hamt.Node, set map[address.Address]StorageParticipantBalance) (cid.Cid, ActorError) {
-	keys := make([]address.Address, 0, len(set))
-	for k := range set {
-		keys = append(keys, k)
-	}
-	sort.Slice(keys, func(i, j int) bool {
-		return bytes.Compare(keys[i].Bytes(), keys[j].Bytes()) < 0
-	})
-	for _, addr := range keys {
-		balance := set[addr]
-		if err := nd.Set(vmctx.Context(), string(addr.Bytes()), &balance); err != nil {
-			return cid.Undef, aerrors.HandleExternalError(err, "setting new balance")
-		}
-	}
-	if err := nd.Flush(vmctx.Context()); err != nil {
-		return cid.Undef, aerrors.HandleExternalError(err, "flushing balance hamt")
-	}
-
-	c, err := vmctx.Ipld().Put(vmctx.Context(), nd)
-	if err != nil {
-		return cid.Undef, aerrors.HandleExternalError(err, "failed to balances storage")
-	}
-	return c, nil
-}
-
-func GetMarketBalances(ctx context.Context, store *hamt.CborIpldStore, rcid cid.Cid, addrs ...address.Address) ([]StorageParticipantBalance, *hamt.Node, ActorError) {
-	ctx, span := trace.StartSpan(ctx, "GetMarketBalances")
-	defer span.End()
-
-	nd, err := hamt.LoadNode(ctx, store, rcid)
-	if err != nil {
-		return nil, nil, aerrors.HandleExternalError(err, "failed to load miner set")
-	}
-
-	out := make([]StorageParticipantBalance, len(addrs))
-
-	for i, a := range addrs {
-		var balance StorageParticipantBalance
-		err = nd.Find(ctx, string(a.Bytes()), &balance)
-		switch err {
-		case hamt.ErrNotFound:
-			out[i] = StorageParticipantBalance{
-				Locked:    types.NewInt(0),
-				Available: types.NewInt(0),
-			}
-		case nil:
-			out[i] = balance
-		default:
-			return nil, nil, aerrors.HandleExternalError(err, "failed to do set lookup")
-		}
-
-	}
-
-	return out, nd, nil
-}
-
-/*
-func (sma StorageMarketActor) CheckLockedBalance(act *types.Actor, vmctx types.VMContext, params *struct{}) ([]byte, ActorError) {
-
-}
-*/
-
-type PublishStorageDealsParams struct {
-	Deals []StorageDealProposal
-}
-
-type PublishStorageDealResponse struct {
-	DealIDs []uint64
-}
-
-func (sma StorageMarketActor) PublishStorageDeals(act *types.Actor, vmctx types.VMContext, params *PublishStorageDealsParams) ([]byte, ActorError) {
-	var self StorageMarketState
-	old := vmctx.Storage().GetHead()
-	if err := vmctx.Storage().Get(old, &self); err != nil {
-		return nil, err
-	}
-
-	deals, err := amt.LoadAMT(types.WrapStorage(vmctx.Storage()), self.Deals)
-	if err != nil {
-		return nil, aerrors.HandleExternalError(err, "loading deals amt")
-	}
-
-	// todo: handle duplicate deals
-
-	if len(params.Deals) == 0 {
-		return nil, aerrors.New(1, "no storage deals in params.Deals")
-	}
-
-	out := PublishStorageDealResponse{
-		DealIDs: make([]uint64, len(params.Deals)),
-	}
-
-	workerBytes, aerr := vmctx.Send(params.Deals[0].Provider, MAMethods.GetWorkerAddr, types.NewInt(0), nil)
-	if aerr != nil {
-		return nil, aerr
-	}
-	providerWorker, err := address.NewFromBytes(workerBytes)
-	if err != nil {
-		return nil, aerrors.HandleExternalError(err, "parsing provider worker address bytes")
-	}
-
-	// TODO: REVIEW: Do we want to check if provider exists in the power actor?
-
-	for i, deal := range params.Deals {
-		if err := self.validateDeal(vmctx, deal, providerWorker); err != nil {
-			return nil, err
-		}
-
-		err := deals.Set(self.NextDealID, &OnChainDeal{
-			PieceRef:  deal.PieceRef,
-			PieceSize: deal.PieceSize,
-
-			Client:   deal.Client,
-			Provider: deal.Provider,
-
-			ProposalExpiration: deal.ProposalExpiration,
-			Duration:           deal.Duration,
-
-			StoragePricePerEpoch: deal.StoragePricePerEpoch,
-			StorageCollateral:    deal.StorageCollateral,
-			ActivationEpoch:      0,
-		})
-		if err != nil {
-			return nil, aerrors.HandleExternalError(err, "setting deal in deal AMT")
-		}
-		out.DealIDs[i] = self.NextDealID
-
-		self.NextDealID++
-	}
-
-	dealsCid, err := deals.Flush()
-	if err != nil {
-		return nil, aerrors.HandleExternalError(err, "saving deals AMT")
-	}
-
-	self.Deals = dealsCid
-
-	nroot, err := vmctx.Storage().Put(&self)
-	if err != nil {
-		return nil, aerrors.HandleExternalError(err, "storing state failed")
-	}
-
-	aerr = vmctx.Storage().Commit(old, nroot)
-	if aerr != nil {
-		return nil, aerr
-	}
-
-	var outBuf bytes.Buffer
-	if err := out.MarshalCBOR(&outBuf); err != nil {
-		return nil, aerrors.HandleExternalError(err, "serialising output")
-	}
-
-	return outBuf.Bytes(), nil
-}
-
-func (st *StorageMarketState) validateDeal(vmctx types.VMContext, deal StorageDealProposal, providerWorker address.Address) aerrors.ActorError {
-	ctx, span := trace.StartSpan(vmctx.Context(), "validateDeal")
-	defer span.End()
-
-	if vmctx.BlockHeight() > deal.ProposalExpiration {
-		return aerrors.New(1, "deal proposal already expired")
-	}
-
-	if vmctx.Message().From != providerWorker {
-		return aerrors.New(2, "Deals must be submitted by the miner worker")
-	}
-
-	if err := deal.Verify(); err != nil {
-		return aerrors.Absorb(err, 3, "verifying proposer signature")
-	}
-
-	// TODO: do some caching (changes gas so needs to be in spec too)
-	b, bnd, aerr := GetMarketBalances(ctx, vmctx.Ipld(), st.Balances, deal.Client, providerWorker)
-	if aerr != nil {
-		return aerrors.Wrap(aerr, "getting client, and provider balances")
-	}
-	clientBalance := b[0]
-	providerBalance := b[1]
-
-	totalPrice := deal.TotalStoragePrice()
-
-	if clientBalance.Available.LessThan(totalPrice) {
-		return aerrors.Newf(5, "client doesn't have enough available funds to cover storage price; %d < %d", clientBalance.Available, totalPrice)
-	}
-
-	clientBalance = lockFunds(clientBalance, totalPrice)
-
-	// TODO: REVIEW: Not clear who pays for this
-	if providerBalance.Available.LessThan(deal.StorageCollateral) {
-		return aerrors.Newf(6, "provider doesn't have enough available funds to cover StorageCollateral; %d < %d", providerBalance.Available, deal.StorageCollateral)
-	}
-
-	providerBalance = lockFunds(providerBalance, deal.StorageCollateral)
-
-	// TODO: piece checks (e.g. size > sectorSize)?
-
-	bcid, aerr := setMarketBalances(vmctx, bnd, map[address.Address]StorageParticipantBalance{
-		deal.Client:    clientBalance,
-		providerWorker: providerBalance,
-	})
-	if aerr != nil {
-		return aerr
-	}
-
-	st.Balances = bcid
-
-	return nil
-}
-
-type ActivateStorageDealsParams struct {
-	Deals []uint64
-}
-
-func (sma StorageMarketActor) ActivateStorageDeals(act *types.Actor, vmctx types.VMContext, params *ActivateStorageDealsParams) ([]byte, ActorError) {
-	var self StorageMarketState
-	old := vmctx.Storage().GetHead()
-	if err := vmctx.Storage().Get(old, &self); err != nil {
-		return nil, err
-	}
-
-	deals, err := amt.LoadAMT(types.WrapStorage(vmctx.Storage()), self.Deals)
-	if err != nil {
-		return nil, aerrors.HandleExternalError(err, "loading deals amt")
-	}
-
-	for _, deal := range params.Deals {
-		var dealInfo OnChainDeal
-		if err := deals.Get(deal, &dealInfo); err != nil {
-			if _, is := err.(*amt.ErrNotFound); is {
-				return nil, aerrors.New(3, "deal not found")
-			}
-			return nil, aerrors.HandleExternalError(err, "getting deal info failed")
-		}
-
-		if vmctx.Message().From != dealInfo.Provider {
-			return nil, aerrors.New(1, "ActivateStorageDeals can only be called by the deal provider")
-		}
-
-		if vmctx.BlockHeight() > dealInfo.ProposalExpiration {
-			return nil, aerrors.New(2, "deal cannot be activated: proposal expired")
-		}
-
-		if dealInfo.ActivationEpoch > 0 {
-			// this probably can't happen in practice
-			return nil, aerrors.New(3, "deal already active")
-		}
-
-		dealInfo.ActivationEpoch = vmctx.BlockHeight()
-
-		if err := deals.Set(deal, &dealInfo); err != nil {
-			return nil, aerrors.HandleExternalError(err, "setting deal info in AMT failed")
-		}
-	}
-
-	dealsCid, err := deals.Flush()
-	if err != nil {
-		return nil, aerrors.HandleExternalError(err, "saving deals AMT")
-	}
-
-	self.Deals = dealsCid
-
-	nroot, err := vmctx.Storage().Put(&self)
-	if err != nil {
-		return nil, aerrors.HandleExternalError(err, "storing state failed")
-	}
-
-	aerr := vmctx.Storage().Commit(old, nroot)
-	if aerr != nil {
-		return nil, aerr
-	}
-
-	return nil, nil
-}
-
-type ProcessStorageDealsPaymentParams struct {
-	DealIDs []uint64
-}
-
-func (sma StorageMarketActor) ProcessStorageDealsPayment(act *types.Actor, vmctx types.VMContext, params *ProcessStorageDealsPaymentParams) ([]byte, ActorError) {
-	var self StorageMarketState
-	old := vmctx.Storage().GetHead()
-	if err := vmctx.Storage().Get(old, &self); err != nil {
-		return nil, err
-	}
-
-	deals, err := amt.LoadAMT(types.WrapStorage(vmctx.Storage()), self.Deals)
-	if err != nil {
-		return nil, aerrors.HandleExternalError(err, "loading deals amt")
-	}
-
-	// TODO: Would be nice if send could assert actor type
-	workerBytes, aerr := vmctx.Send(vmctx.Message().From, MAMethods.GetWorkerAddr, types.NewInt(0), nil)
-	if aerr != nil {
-		return nil, aerr
-	}
-	providerWorker, err := address.NewFromBytes(workerBytes)
-	if err != nil {
-		return nil, aerrors.HandleExternalError(err, "parsing provider worker address bytes")
-	}
-
-	for _, deal := range params.DealIDs {
-		var dealInfo OnChainDeal
-		if err := deals.Get(deal, &dealInfo); err != nil {
-			if _, is := err.(*amt.ErrNotFound); is {
-				return nil, aerrors.New(2, "deal not found")
-			}
-			return nil, aerrors.HandleExternalError(err, "getting deal info failed")
-		}
-
-		if dealInfo.Provider != vmctx.Message().From {
-			return nil, aerrors.New(3, "ProcessStorageDealsPayment can only be called by deal provider")
-		}
-
-		if vmctx.BlockHeight() < dealInfo.ActivationEpoch {
-			// TODO: This is probably fatal
-			return nil, aerrors.New(4, "ActivationEpoch lower than block height")
-		}
-
-		if vmctx.BlockHeight() > dealInfo.ActivationEpoch+dealInfo.Duration {
-			// Deal expired, miner should drop it
-			// TODO: process payment for the remainder of last proving period
-			return nil, nil
-		}
-
-		toPay := types.BigMul(dealInfo.StoragePricePerEpoch, types.NewInt(build.SlashablePowerDelay))
-
-		b, bnd, aerr := GetMarketBalances(vmctx.Context(), vmctx.Ipld(), self.Balances, dealInfo.Client, providerWorker)
-		if aerr != nil {
-			return nil, aerr
-		}
-		clientBal := b[0]
-		providerBal := b[1]
-
-		clientBal.Locked, providerBal.Available = transferFunds(clientBal.Locked, providerBal.Available, toPay)
-
-		// TODO: call set once
-		bcid, aerr := setMarketBalances(vmctx, bnd, map[address.Address]StorageParticipantBalance{
-			dealInfo.Client: clientBal,
-			providerWorker:  providerBal,
-		})
-		if aerr != nil {
-			return nil, aerr
-		}
-
-		self.Balances = bcid
-	}
-
-	nroot, err := vmctx.Storage().Put(&self)
-	if err != nil {
-		return nil, aerrors.HandleExternalError(err, "storing state failed")
-	}
-
-	aerr = vmctx.Storage().Commit(old, nroot)
-	if aerr != nil {
-		return nil, aerr
-	}
-
-	return nil, nil
-}
-
-func lockFunds(p StorageParticipantBalance, amt types.BigInt) StorageParticipantBalance {
-	p.Available, p.Locked = transferFunds(p.Available, p.Locked, amt)
-	return p
-}
-
-func transferFunds(from, to, amt types.BigInt) (types.BigInt, types.BigInt) {
-	// TODO: some asserts
-	return types.BigSub(from, amt), types.BigAdd(to, amt)
-}
-
-type ComputeDataCommitmentParams struct {
-	DealIDs    []uint64
-	SectorSize uint64
-}
-
-func (sma StorageMarketActor) ComputeDataCommitment(act *types.Actor, vmctx types.VMContext, params *ComputeDataCommitmentParams) ([]byte, ActorError) {
-	var self StorageMarketState
-	old := vmctx.Storage().GetHead()
-	if err := vmctx.Storage().Get(old, &self); err != nil {
-		return nil, err
-	}
-
-	deals, err := amt.LoadAMT(types.WrapStorage(vmctx.Storage()), self.Deals)
-	if err != nil {
-		return nil, aerrors.HandleExternalError(err, "loading deals amt")
-	}
-
-	if len(params.DealIDs) == 0 {
-		return nil, aerrors.New(3, "no deal IDs")
-	}
-
-	var pieces []sectorbuilder.PublicPieceInfo
-	for _, deal := range params.DealIDs {
-		var dealInfo OnChainDeal
-		if err := deals.Get(deal, &dealInfo); err != nil {
-			if _, is := err.(*amt.ErrNotFound); is {
-				return nil, aerrors.New(4, "deal not found")
-			}
-			return nil, aerrors.HandleExternalError(err, "getting deal info failed")
-		}
-
-		if dealInfo.Provider != vmctx.Message().From {
-			return nil, aerrors.New(5, "referenced deal was not from caller")
-		}
-
-		var commP [32]byte
-		copy(commP[:], dealInfo.PieceRef)
-
-		pieces = append(pieces, sectorbuilder.PublicPieceInfo{
-			Size:  dealInfo.PieceSize,
-			CommP: commP,
-		})
-	}
-
-	commd, err := sectorbuilder.GenerateDataCommitment(params.SectorSize, pieces)
-	if err != nil {
-		return nil, aerrors.Absorb(err, 6, "failed to generate data commitment from pieces")
-	}
-
-	return commd[:], nil
-}
-
-/*
-func (sma StorageMarketActor) HandleCronAction(act *types.Actor, vmctx types.VMContext, params *struct{}) ([]byte, ActorError) {
-
-}
-
-func (sma StorageMarketActor) SettleExpiredDeals(act *types.Actor, vmctx types.VMContext, params *struct{}) ([]byte, ActorError) {
-
-}
-
-func (sma StorageMarketActor) SlashStorageDealCollateral(act *types.Actor, vmctx types.VMContext, params *struct{}) ([]byte, ActorError) {
-
-}
-
-func (sma StorageMarketActor) GetLastExpirationFromDealIDs(act *types.Actor, vmctx types.VMContext, params *struct{}) ([]byte, ActorError) {
-
-}
-*/
diff --git a/chain/actors/actor_storagepower.go b/chain/actors/actor_storagepower.go
deleted file mode 100644
index 09a3eb30a..000000000
--- a/chain/actors/actor_storagepower.go
+++ /dev/null
@@ -1,797 +0,0 @@
-package actors
-
-import (
-	"bytes"
-	"context"
-	"io"
-
-	"github.com/filecoin-project/go-amt-ipld"
-	cid "github.com/ipfs/go-cid"
-	hamt "github.com/ipfs/go-hamt-ipld"
-	"github.com/libp2p/go-libp2p-core/peer"
-	cbg "github.com/whyrusleeping/cbor-gen"
-	"go.opencensus.io/trace"
-	xerrors "golang.org/x/xerrors"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/lotus/build"
-	"github.com/filecoin-project/lotus/chain/actors/aerrors"
-	"github.com/filecoin-project/lotus/chain/types"
-)
-
-type StoragePowerActor struct{}
-
-type spaMethods struct {
-	Constructor             uint64
-	CreateStorageMiner      uint64
-	ArbitrateConsensusFault uint64
-	UpdateStorage           uint64
-	GetTotalStorage         uint64
-	PowerLookup             uint64
-	IsValidMiner            uint64
-	PledgeCollateralForSize uint64
-	CheckProofSubmissions   uint64
-}
-
-var SPAMethods = spaMethods{1, 2, 3, 4, 5, 6, 7, 8, 9}
-
-func (spa StoragePowerActor) Exports() []interface{} {
-	return []interface{}{
-		//1: spa.StoragePowerConstructor,
-		2: spa.CreateStorageMiner,
-		3: spa.ArbitrateConsensusFault,
-		4: spa.UpdateStorage,
-		5: spa.GetTotalStorage,
-		6: spa.PowerLookup,
-		7: spa.IsValidMiner,
-		8: spa.PledgeCollateralForSize,
-		9: spa.CheckProofSubmissions,
-	}
-}
-
-type StoragePowerState struct {
-	Miners         cid.Cid
-	ProvingBuckets cid.Cid // amt[ProvingPeriodBucket]hamt[minerAddress]struct{}
-	MinerCount     uint64
-	LastMinerCheck uint64
-
-	TotalStorage types.BigInt
-}
-
-type CreateStorageMinerParams struct {
-	Owner      address.Address
-	Worker     address.Address
-	SectorSize uint64
-	PeerID     peer.ID
-}
-
-func (spa StoragePowerActor) CreateStorageMiner(act *types.Actor, vmctx types.VMContext, params *CreateStorageMinerParams) ([]byte, ActorError) {
-	if !build.SupportedSectorSize(params.SectorSize) {
-		return nil, aerrors.New(1, "Unsupported sector size")
-	}
-
-	var self StoragePowerState
-	old := vmctx.Storage().GetHead()
-	if err := vmctx.Storage().Get(old, &self); err != nil {
-		return nil, err
-	}
-
-	reqColl, err := pledgeCollateralForSize(vmctx, types.NewInt(0), self.TotalStorage, self.MinerCount+1)
-	if err != nil {
-		return nil, err
-	}
-
-	if vmctx.Message().Value.LessThan(reqColl) {
-		return nil, aerrors.Newf(1, "not enough funds passed to cover required miner collateral (needed %s, got %s)", reqColl, vmctx.Message().Value)
-	}
-
-	encoded, err := CreateExecParams(StorageMinerCodeCid, &StorageMinerConstructorParams{
-		Owner:      params.Owner,
-		Worker:     params.Worker,
-		SectorSize: params.SectorSize,
-		PeerID:     params.PeerID,
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	ret, err := vmctx.Send(InitAddress, IAMethods.Exec, vmctx.Message().Value, encoded)
-	if err != nil {
-		return nil, err
-	}
-
-	naddr, nerr := address.NewFromBytes(ret)
-	if nerr != nil {
-		return nil, aerrors.Absorb(nerr, 2, "could not read address of new actor")
-	}
-
-	ncid, err := MinerSetAdd(context.TODO(), vmctx, self.Miners, naddr)
-	if err != nil {
-		return nil, err
-	}
-	self.Miners = ncid
-	self.MinerCount++
-
-	nroot, err := vmctx.Storage().Put(&self)
-	if err != nil {
-		return nil, err
-	}
-
-	if err := vmctx.Storage().Commit(old, nroot); err != nil {
-		return nil, err
-	}
-
-	return naddr.Bytes(), nil
-}
-
-type ArbitrateConsensusFaultParams struct {
-	Block1 *types.BlockHeader
-	Block2 *types.BlockHeader
-}
-
-func (spa StoragePowerActor) ArbitrateConsensusFault(act *types.Actor, vmctx types.VMContext, params *ArbitrateConsensusFaultParams) ([]byte, ActorError) {
-	if params.Block1.Miner != params.Block2.Miner {
-		return nil, aerrors.New(2, "blocks must be from the same miner")
-	}
-
-	rval, err := vmctx.Send(params.Block1.Miner, MAMethods.GetWorkerAddr, types.NewInt(0), nil)
-	if err != nil {
-		return nil, aerrors.Wrap(err, "failed to get miner worker")
-	}
-
-	worker, oerr := address.NewFromBytes(rval)
-	if oerr != nil {
-		// REVIEW: should this be fatal? i can't think of a real situation that would get us here
-		return nil, aerrors.Absorb(oerr, 3, "response from 'GetWorkerAddr' was not a valid address")
-	}
-
-	if err := params.Block1.CheckBlockSignature(vmctx.Context(), worker); err != nil {
-		return nil, aerrors.Absorb(err, 4, "block1 did not have valid signature")
-	}
-
-	if err := params.Block2.CheckBlockSignature(vmctx.Context(), worker); err != nil {
-		return nil, aerrors.Absorb(err, 5, "block2 did not have valid signature")
-	}
-
-	// see the "Consensus Faults" section of the faults spec (faults.md)
-	// for details on these slashing conditions.
-	if !shouldSlash(params.Block1, params.Block2) {
-		return nil, aerrors.New(6, "blocks do not prove a slashable offense")
-	}
-
-	var self StoragePowerState
-	old := vmctx.Storage().GetHead()
-	if err := vmctx.Storage().Get(old, &self); err != nil {
-		return nil, err
-	}
-
-	if types.BigCmp(self.TotalStorage, types.NewInt(0)) == 0 {
-		return nil, aerrors.Fatal("invalid state, storage power actor has zero total storage")
-	}
-
-	miner := params.Block1.Miner
-	if has, err := MinerSetHas(vmctx, self.Miners, miner); err != nil {
-		return nil, aerrors.Wrapf(err, "failed to check miner in set")
-	} else if !has {
-		return nil, aerrors.New(7, "either already slashed or not a miner")
-	}
-
-	minerPower, err := powerLookup(context.TODO(), vmctx, &self, miner)
-	if err != nil {
-		return nil, err
-	}
-
-	slashedCollateral, err := pledgeCollateralForSize(vmctx, minerPower, self.TotalStorage, self.MinerCount)
-	if err != nil {
-		return nil, err
-	}
-
-	enc, err := SerializeParams(&MinerSlashConsensusFault{
-		Slasher:           vmctx.Message().From,
-		AtHeight:          params.Block1.Height,
-		SlashedCollateral: slashedCollateral,
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	_, err = vmctx.Send(miner, MAMethods.SlashConsensusFault, types.NewInt(0), enc)
-	if err != nil {
-		return nil, err
-	}
-
-	// Remove the miner from the list of network miners
-	ncid, err := MinerSetRemove(context.TODO(), vmctx, self.Miners, miner)
-	if err != nil {
-		return nil, err
-	}
-	self.Miners = ncid
-	self.MinerCount--
-
-	self.TotalStorage = types.BigSub(self.TotalStorage, minerPower)
-
-	nroot, err := vmctx.Storage().Put(&self)
-	if err != nil {
-		return nil, err
-	}
-
-	if err := vmctx.Storage().Commit(old, nroot); err != nil {
-		return nil, err
-	}
-
-	return nil, nil
-}
-
-func cidArrContains(a []cid.Cid, b cid.Cid) bool {
-	for _, c := range a {
-		if b == c {
-			return true
-		}
-	}
-
-	return false
-}
-
-func shouldSlash(block1, block2 *types.BlockHeader) bool {
-	// First slashing condition, blocks have the same ticket round
-	if block1.Height == block2.Height {
-		return true
-	}
-
-	/* Second slashing condition requires having access to the parent tipset blocks
-	// This might not always be available, needs some thought on the best way to deal with this
-
-
-	// Second slashing condition, miner ignored own block when mining
-	// Case A: block2 could have been in block1's parent set but is not
-	b1ParentHeight := block1.Height - len(block1.Tickets)
-
-	block1ParentTipSet := block1.Parents
-	if !cidArrContains(block1.Parents, block2.Cid()) &&
-		b1ParentHeight == block2.Height &&
-		block1ParentTipSet.ParentCids == block2.ParentCids {
-		return true
-	}
-
-	// Case B: block1 could have been in block2's parent set but is not
-	block2ParentTipSet := parentOf(block2)
-	if !block2Parent.contains(block1) &&
-		block2ParentTipSet.Height == block1.Height &&
-		block2ParentTipSet.ParentCids == block1.ParentCids {
-		return true
-	}
-
-	*/
-
-	return false
-}
-
-type UpdateStorageParams struct {
-	Delta                 types.BigInt
-	NextSlashDeadline     uint64
-	PreviousSlashDeadline uint64
-}
-
-func (spa StoragePowerActor) UpdateStorage(act *types.Actor, vmctx types.VMContext, params *UpdateStorageParams) ([]byte, ActorError) {
-	var self StoragePowerState
-	old := vmctx.Storage().GetHead()
-	if err := vmctx.Storage().Get(old, &self); err != nil {
-		return nil, err
-	}
-
-	has, err := MinerSetHas(vmctx, self.Miners, vmctx.Message().From)
-	if err != nil {
-		return nil, err
-	}
-	if !has {
-		return nil, aerrors.New(1, "update storage must only be called by a miner actor")
-	}
-
-	self.TotalStorage = types.BigAdd(self.TotalStorage, params.Delta)
-
-	previousBucket := params.PreviousSlashDeadline % build.SlashablePowerDelay
-	nextBucket := params.NextSlashDeadline % build.SlashablePowerDelay
-
-	if previousBucket == nextBucket && params.PreviousSlashDeadline != 0 {
-		nroot, err := vmctx.Storage().Put(&self)
-		if err != nil {
-			return nil, err
-		}
-
-		if err := vmctx.Storage().Commit(old, nroot); err != nil {
-			return nil, err
-		}
-
-		return nil, nil // Nothing to do
-	}
-
-	buckets, eerr := amt.LoadAMT(types.WrapStorage(vmctx.Storage()), self.ProvingBuckets)
-	if eerr != nil {
-		return nil, aerrors.HandleExternalError(eerr, "loading proving buckets amt")
-	}
-
-	if params.PreviousSlashDeadline != 0 { // delete from previous bucket
-		err := deleteMinerFromBucket(vmctx, buckets, previousBucket)
-		if err != nil {
-			return nil, aerrors.Wrapf(err, "delete from bucket %d, next %d", previousBucket, nextBucket)
-		}
-	}
-
-	err = addMinerToBucket(vmctx, buckets, nextBucket)
-	if err != nil {
-		return nil, err
-	}
-
-	self.ProvingBuckets, eerr = buckets.Flush()
-	if eerr != nil {
-		return nil, aerrors.HandleExternalError(eerr, "flushing proving buckets")
-	}
-
-	nroot, err := vmctx.Storage().Put(&self)
-	if err != nil {
-		return nil, err
-	}
-
-	if err := vmctx.Storage().Commit(old, nroot); err != nil {
-		return nil, err
-	}
-
-	return nil, nil
-}
-
-func deleteMinerFromBucket(vmctx types.VMContext, buckets *amt.Root, previousBucket uint64) aerrors.ActorError {
-	var bucket cid.Cid
-	err := buckets.Get(previousBucket, &bucket)
-	switch err.(type) {
-	case *amt.ErrNotFound:
-		return aerrors.HandleExternalError(err, "proving bucket missing")
-	case nil: // noop
-	default:
-		return aerrors.HandleExternalError(err, "getting proving bucket")
-	}
-
-	bhamt, err := hamt.LoadNode(vmctx.Context(), vmctx.Ipld(), bucket)
-	if err != nil {
-		return aerrors.HandleExternalError(err, "failed to load proving bucket")
-	}
-	err = bhamt.Delete(vmctx.Context(), string(vmctx.Message().From.Bytes()))
-	if err != nil {
-		return aerrors.HandleExternalError(err, "deleting miner from proving bucket")
-	}
-
-	err = bhamt.Flush(vmctx.Context())
-	if err != nil {
-		return aerrors.HandleExternalError(err, "flushing previous proving bucket")
-	}
-
-	bucket, err = vmctx.Ipld().Put(vmctx.Context(), bhamt)
-	if err != nil {
-		return aerrors.HandleExternalError(err, "putting previous proving bucket hamt")
-	}
-
-	err = buckets.Set(previousBucket, bucket)
-	if err != nil {
-		return aerrors.HandleExternalError(err, "setting previous proving bucket cid in amt")
-	}
-
-	return nil
-}
-
-func addMinerToBucket(vmctx types.VMContext, buckets *amt.Root, nextBucket uint64) aerrors.ActorError {
-	var bhamt *hamt.Node
-	var bucket cid.Cid
-	err := buckets.Get(nextBucket, &bucket)
-	switch err.(type) {
-	case *amt.ErrNotFound:
-		bhamt = hamt.NewNode(vmctx.Ipld())
-	case nil:
-		bhamt, err = hamt.LoadNode(vmctx.Context(), vmctx.Ipld(), bucket)
-		if err != nil {
-			return aerrors.HandleExternalError(err, "failed to load proving bucket")
-		}
-	default:
-		return aerrors.HandleExternalError(err, "getting proving bucket")
-	}
-
-	err = bhamt.Set(vmctx.Context(), string(vmctx.Message().From.Bytes()), CborNull)
-	if err != nil {
-		return aerrors.HandleExternalError(err, "setting miner in proving bucket")
-	}
-
-	err = bhamt.Flush(vmctx.Context())
-	if err != nil {
-		return aerrors.HandleExternalError(err, "flushing previous proving bucket")
-	}
-
-	bucket, err = vmctx.Ipld().Put(vmctx.Context(), bhamt)
-	if err != nil {
-		return aerrors.HandleExternalError(err, "putting previous proving bucket hamt")
-	}
-
-	err = buckets.Set(nextBucket, bucket)
-	if err != nil {
-		return aerrors.HandleExternalError(err, "setting previous proving bucket cid in amt")
-	}
-	return nil
-}
-
-func (spa StoragePowerActor) GetTotalStorage(act *types.Actor, vmctx types.VMContext, params *struct{}) ([]byte, ActorError) {
-	var self StoragePowerState
-	if err := vmctx.Storage().Get(vmctx.Storage().GetHead(), &self); err != nil {
-		return nil, err
-	}
-
-	return self.TotalStorage.Bytes(), nil
-}
-
-type PowerLookupParams struct {
-	Miner address.Address
-}
-
-func (spa StoragePowerActor) PowerLookup(act *types.Actor, vmctx types.VMContext, params *PowerLookupParams) ([]byte, ActorError) {
-	var self StoragePowerState
-	if err := vmctx.Storage().Get(vmctx.Storage().GetHead(), &self); err != nil {
-		return nil, aerrors.Wrap(err, "getting head")
-	}
-
-	pow, err := powerLookup(context.TODO(), vmctx, &self, params.Miner)
-	if err != nil {
-		return nil, err
-	}
-
-	return pow.Bytes(), nil
-}
-
-func powerLookup(ctx context.Context, vmctx types.VMContext, self *StoragePowerState, miner address.Address) (types.BigInt, ActorError) {
-	has, err := MinerSetHas(vmctx, self.Miners, miner)
-	if err != nil {
-		return types.EmptyInt, err
-	}
-
-	if !has {
-		return types.EmptyInt, aerrors.New(1, "miner not registered with storage power actor")
-	}
-
-	// TODO: Use local amt
-	ret, err := vmctx.Send(miner, MAMethods.GetPower, types.NewInt(0), nil)
-	if err != nil {
-		return types.EmptyInt, aerrors.Wrap(err, "invoke Miner.GetPower")
-	}
-
-	return types.BigFromBytes(ret), nil
-}
-
-type IsValidMinerParam struct {
-	Addr address.Address
-}
-
-func (spa StoragePowerActor) IsValidMiner(act *types.Actor, vmctx types.VMContext, param *IsValidMinerParam) ([]byte, ActorError) {
-	var self StoragePowerState
-	if err := vmctx.Storage().Get(vmctx.Storage().GetHead(), &self); err != nil {
-		return nil, err
-	}
-
-	has, err := MinerSetHas(vmctx, self.Miners, param.Addr)
-	if err != nil {
-		return nil, err
-	}
-
-	if !has {
-		log.Warnf("Miner INVALID: not in set: %s", param.Addr)
-
-		return cbg.CborBoolFalse, nil
-	}
-
-	ret, err := vmctx.Send(param.Addr, MAMethods.IsSlashed, types.NewInt(0), nil)
-	if err != nil {
-		return nil, err
-	}
-
-	slashed := bytes.Equal(ret, cbg.CborBoolTrue)
-
-	if slashed {
-		log.Warnf("Miner INVALID: /SLASHED/ : %s", param.Addr)
-	}
-
-	return cbg.EncodeBool(!slashed), nil
-}
-
-type PledgeCollateralParams struct {
-	Size types.BigInt
-}
-
-func (spa StoragePowerActor) PledgeCollateralForSize(act *types.Actor, vmctx types.VMContext, param *PledgeCollateralParams) ([]byte, ActorError) {
-	var self StoragePowerState
-	if err := vmctx.Storage().Get(vmctx.Storage().GetHead(), &self); err != nil {
-		return nil, err
-	}
-
-	totalCollateral, err := pledgeCollateralForSize(vmctx, param.Size, self.TotalStorage, self.MinerCount)
-	if err != nil {
-		return nil, err
-	}
-
-	return totalCollateral.Bytes(), nil
-}
-
-func pledgeCollateralForSize(vmctx types.VMContext, size, totalStorage types.BigInt, minerCount uint64) (types.BigInt, aerrors.ActorError) {
-	netBalance, err := vmctx.GetBalance(NetworkAddress)
-	if err != nil {
-		return types.EmptyInt, err
-	}
-
-	// TODO: the spec says to also grab 'total vested filecoin' and include it as available
-	// If we don't factor that in, we effectively assume all of the locked up filecoin is 'available'
-	// the blocker on that right now is that its hard to tell how much filecoin is unlocked
-
-	availableFilecoin := types.BigSub(
-		types.BigMul(types.NewInt(build.TotalFilecoin), types.NewInt(build.FilecoinPrecision)),
-		netBalance,
-	)
-
-	totalPowerCollateral := types.BigDiv(
-		types.BigMul(
-			availableFilecoin,
-			types.NewInt(build.PowerCollateralProportion),
-		),
-		types.NewInt(build.CollateralPrecision),
-	)
-
-	totalPerCapitaCollateral := types.BigDiv(
-		types.BigMul(
-			availableFilecoin,
-			types.NewInt(build.PerCapitaCollateralProportion),
-		),
-		types.NewInt(build.CollateralPrecision),
-	)
-
-	// REVIEW: for bootstrapping purposes, we skip the power portion of the
-	// collateral if there is no collateral in the network yet
-	powerCollateral := types.NewInt(0)
-	if types.BigCmp(totalStorage, types.NewInt(0)) != 0 {
-		powerCollateral = types.BigDiv(
-			types.BigMul(
-				totalPowerCollateral,
-				size,
-			),
-			totalStorage,
-		)
-	}
-
-	perCapCollateral := types.BigDiv(
-		totalPerCapitaCollateral,
-		types.NewInt(minerCount),
-	)
-
-	return types.BigAdd(powerCollateral, perCapCollateral), nil
-}
-
-func (spa StoragePowerActor) CheckProofSubmissions(act *types.Actor, vmctx types.VMContext, param *struct{}) ([]byte, ActorError) {
-	if vmctx.Message().From != CronAddress {
-		return nil, aerrors.New(1, "CheckProofSubmissions is only callable from the cron actor")
-	}
-
-	var self StoragePowerState
-	old := vmctx.Storage().GetHead()
-	if err := vmctx.Storage().Get(old, &self); err != nil {
-		return nil, err
-	}
-
-	for i := self.LastMinerCheck; i < vmctx.BlockHeight(); i++ {
-		height := i + 1
-
-		err := checkProofSubmissionsAtH(vmctx, &self, height)
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	self.LastMinerCheck = vmctx.BlockHeight()
-
-	nroot, aerr := vmctx.Storage().Put(&self)
-	if aerr != nil {
-		return nil, aerr
-	}
-
-	if err := vmctx.Storage().Commit(old, nroot); err != nil {
-		return nil, err
-	}
-
-	return nil, nil
-}
-
-func checkProofSubmissionsAtH(vmctx types.VMContext, self *StoragePowerState, height uint64) aerrors.ActorError {
-	bucketID := height % build.SlashablePowerDelay
-
-	buckets, eerr := amt.LoadAMT(types.WrapStorage(vmctx.Storage()), self.ProvingBuckets)
-	if eerr != nil {
-		return aerrors.HandleExternalError(eerr, "loading proving buckets amt")
-	}
-
-	var bucket cid.Cid
-	err := buckets.Get(bucketID, &bucket)
-	switch err.(type) {
-	case *amt.ErrNotFound:
-		return nil // nothing to do
-	case nil:
-	default:
-		return aerrors.HandleExternalError(err, "getting proving bucket")
-	}
-
-	bhamt, err := hamt.LoadNode(vmctx.Context(), vmctx.Ipld(), bucket)
-	if err != nil {
-		return aerrors.HandleExternalError(err, "failed to load proving bucket")
-	}
-
-	err = bhamt.ForEach(vmctx.Context(), func(k string, val interface{}) error {
-		_, span := trace.StartSpan(vmctx.Context(), "StoragePowerActor.CheckProofSubmissions.loop")
-		defer span.End()
-
-		maddr, err := address.NewFromBytes([]byte(k))
-		if err != nil {
-			return aerrors.Escalate(err, "parsing miner address")
-		}
-
-		span.AddAttributes(trace.StringAttribute("miner", maddr.String()))
-
-		params, err := SerializeParams(&CheckMinerParams{NetworkPower: self.TotalStorage})
-		if err != nil {
-			return err
-		}
-
-		ret, err := vmctx.Send(maddr, MAMethods.CheckMiner, types.NewInt(0), params)
-		if err != nil {
-			return err
-		}
-
-		if len(ret) == 0 {
-			return nil // miner is fine
-		}
-
-		var power types.BigInt
-		if err := power.UnmarshalCBOR(bytes.NewReader(ret)); err != nil {
-			return xerrors.Errorf("unmarshaling CheckMiner response (%x): %w", ret, err)
-		}
-
-		if power.GreaterThan(types.NewInt(0)) {
-			log.Warnf("slashing miner %s for missed PoSt (%s B, H: %d, Bucket: %d)", maddr, power, height, bucketID)
-
-			self.TotalStorage = types.BigSub(self.TotalStorage, power)
-		}
-		return nil
-	})
-
-	if err != nil {
-		return aerrors.HandleExternalError(err, "iterating miners in proving bucket")
-	}
-
-	return nil
-}
-
-func MinerSetHas(vmctx types.VMContext, rcid cid.Cid, maddr address.Address) (bool, aerrors.ActorError) {
-	nd, err := hamt.LoadNode(vmctx.Context(), vmctx.Ipld(), rcid)
-	if err != nil {
-		return false, aerrors.HandleExternalError(err, "failed to load miner set")
-	}
-
-	err = nd.Find(vmctx.Context(), string(maddr.Bytes()), nil)
-	switch err {
-	case hamt.ErrNotFound:
-		return false, nil
-	case nil:
-		return true, nil
-	default:
-		return false, aerrors.HandleExternalError(err, "failed to do set lookup")
-	}
-}
-
-func MinerSetList(ctx context.Context, cst *hamt.CborIpldStore, rcid cid.Cid) ([]address.Address, error) {
-	nd, err := hamt.LoadNode(ctx, cst, rcid)
-	if err != nil {
-		return nil, xerrors.Errorf("failed to load miner set: %w", err)
-	}
-
-	var out []address.Address
-	err = nd.ForEach(ctx, func(k string, val interface{}) error {
-		addr, err := address.NewFromBytes([]byte(k))
-		if err != nil {
-			return err
-		}
-		out = append(out, addr)
-		return nil
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	return out, nil
-}
-
-func MinerSetAdd(ctx context.Context, vmctx types.VMContext, rcid cid.Cid, maddr address.Address) (cid.Cid, aerrors.ActorError) {
-	nd, err := hamt.LoadNode(ctx, vmctx.Ipld(), rcid)
-	if err != nil {
-		return cid.Undef, aerrors.HandleExternalError(err, "failed to load miner set")
-	}
-
-	mkey := string(maddr.Bytes())
-	err = nd.Find(ctx, mkey, nil)
-	if err == nil {
-		return cid.Undef, aerrors.New(20, "miner already in set")
-	}
-
-	if !xerrors.Is(err, hamt.ErrNotFound) {
-		return cid.Undef, aerrors.HandleExternalError(err, "failed to do miner set check")
-	}
-
-	if err := nd.Set(ctx, mkey, uint64(1)); err != nil {
-		return cid.Undef, aerrors.HandleExternalError(err, "adding miner address to set failed")
-	}
-
-	if err := nd.Flush(ctx); err != nil {
-		return cid.Undef, aerrors.HandleExternalError(err, "failed to flush miner set")
-	}
-
-	c, err := vmctx.Ipld().Put(ctx, nd)
-	if err != nil {
-		return cid.Undef, aerrors.HandleExternalError(err, "failed to persist miner set to storage")
-	}
-
-	return c, nil
-}
-
-func MinerSetRemove(ctx context.Context, vmctx types.VMContext, rcid cid.Cid, maddr address.Address) (cid.Cid, aerrors.ActorError) {
-	nd, err := hamt.LoadNode(ctx, vmctx.Ipld(), rcid)
-	if err != nil {
-		return cid.Undef, aerrors.HandleExternalError(err, "failed to load miner set")
-	}
-
-	mkey := string(maddr.Bytes())
-	switch nd.Delete(ctx, mkey) {
-	default:
-		return cid.Undef, aerrors.HandleExternalError(err, "failed to delete miner from set")
-	case hamt.ErrNotFound:
-		return cid.Undef, aerrors.New(1, "miner not found in set on delete")
-	case nil:
-	}
-
-	if err := nd.Flush(ctx); err != nil {
-		return cid.Undef, aerrors.HandleExternalError(err, "failed to flush miner set")
-	}
-
-	c, err := vmctx.Ipld().Put(ctx, nd)
-	if err != nil {
-		return cid.Undef, aerrors.HandleExternalError(err, "failed to persist miner set to storage")
-	}
-
-	return c, nil
-}
-
-type cbgNull struct{}
-
-var CborNull = &cbgNull{}
-
-func (cbgNull) MarshalCBOR(w io.Writer) error {
-	n, err := w.Write(cbg.CborNull)
-	if err != nil {
-		return err
-	}
-	if n != 1 {
-		return xerrors.New("expected to write 1 byte")
-	}
-	return nil
-}
-
-func (cbgNull) UnmarshalCBOR(r io.Reader) error {
-	b := [1]byte{}
-	n, err := r.Read(b[:])
-	if err != nil {
-		return err
-	}
-	if n != 1 {
-		return xerrors.New("expected 1 byte")
-	}
-	if !bytes.Equal(b[:], cbg.CborNull) {
-		return xerrors.New("expected cbor null")
-	}
-	return nil
-}
diff --git a/chain/actors/actor_storagepower_test.go b/chain/actors/actor_storagepower_test.go
deleted file mode 100644
index 3e6f47f29..000000000
--- a/chain/actors/actor_storagepower_test.go
+++ /dev/null
@@ -1,174 +0,0 @@
-package actors_test
-
-import (
-	"context"
-	"fmt"
-	"testing"
-
-	"github.com/filecoin-project/lotus/build"
-	cbg "github.com/whyrusleeping/cbor-gen"
-
-	"github.com/filecoin-project/go-address"
-	. "github.com/filecoin-project/lotus/chain/actors"
-	"github.com/filecoin-project/lotus/chain/types"
-	"github.com/filecoin-project/lotus/chain/vm"
-	"github.com/filecoin-project/lotus/chain/wallet"
-
-	cid "github.com/ipfs/go-cid"
-	hamt "github.com/ipfs/go-hamt-ipld"
-	bstore "github.com/ipfs/go-ipfs-blockstore"
-	cbor "github.com/ipfs/go-ipld-cbor"
-	mh "github.com/multiformats/go-multihash"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestStorageMarketCreateAndSlashMiner(t *testing.T) {
-	var ownerAddr, workerAddr address.Address
-
-	opts := []HarnessOpt{
-		HarnessAddr(&ownerAddr, 1000000),
-		HarnessAddr(&workerAddr, 100000),
-	}
-
-	h := NewHarness(t, opts...)
-
-	var minerAddr address.Address
-	{
-		// cheating the bootstrapping problem
-		cheatStorageMarketTotal(t, h.vm, h.cs.Blockstore())
-
-		ret, _ := h.InvokeWithValue(t, ownerAddr, StoragePowerAddress, SPAMethods.CreateStorageMiner,
-			types.NewInt(500000),
-			&CreateStorageMinerParams{
-				Owner:      ownerAddr,
-				Worker:     workerAddr,
-				SectorSize: build.SectorSizes[0],
-				PeerID:     "fakepeerid",
-			})
-		ApplyOK(t, ret)
-		var err error
-		minerAddr, err = address.NewFromBytes(ret.Return)
-		assert.NoError(t, err)
-	}
-
-	{
-		ret, _ := h.Invoke(t, ownerAddr, StoragePowerAddress, SPAMethods.IsValidMiner,
-			&IsValidMinerParam{Addr: minerAddr})
-		ApplyOK(t, ret)
-
-		var output bool
-		err := cbor.DecodeInto(ret.Return, &output)
-		if err != nil {
-			t.Fatalf("error decoding: %+v", err)
-		}
-
-		if !output {
-			t.Fatalf("%s is miner but IsValidMiner call returned false", minerAddr)
-		}
-	}
-
-	{
-		ret, _ := h.Invoke(t, ownerAddr, StoragePowerAddress, SPAMethods.PowerLookup,
-			&PowerLookupParams{Miner: minerAddr})
-		ApplyOK(t, ret)
-		power := types.BigFromBytes(ret.Return)
-
-		if types.BigCmp(power, types.NewInt(0)) != 0 {
-			t.Fatalf("power should be zero, is: %s", power)
-		}
-	}
-
-	{
-		ret, _ := h.Invoke(t, ownerAddr, minerAddr, MAMethods.GetOwner, nil)
-		ApplyOK(t, ret)
-		oA, err := address.NewFromBytes(ret.Return)
-		assert.NoError(t, err)
-		assert.Equal(t, ownerAddr, oA, "return from GetOwner should be equal to the owner")
-	}
-
-	{
-		b1 := fakeBlock(t, minerAddr, 100)
-		b2 := fakeBlock(t, minerAddr, 101)
-
-		signBlock(t, h.w, workerAddr, b1)
-		signBlock(t, h.w, workerAddr, b2)
-
-		ret, _ := h.Invoke(t, ownerAddr, StoragePowerAddress, SPAMethods.ArbitrateConsensusFault,
-			&ArbitrateConsensusFaultParams{
-				Block1: b1,
-				Block2: b2,
-			})
-		ApplyOK(t, ret)
-	}
-
-	{
-		ret, _ := h.Invoke(t, ownerAddr, StoragePowerAddress, SPAMethods.PowerLookup,
-			&PowerLookupParams{Miner: minerAddr})
-		assert.Equal(t, ret.ExitCode, byte(1))
-	}
-
-	{
-		ret, _ := h.Invoke(t, ownerAddr, StoragePowerAddress, SPAMethods.IsValidMiner, &IsValidMinerParam{minerAddr})
-		ApplyOK(t, ret)
-		assert.Equal(t, ret.Return, cbg.CborBoolFalse)
-	}
-}
-
-func cheatStorageMarketTotal(t *testing.T, vm *vm.VM, bs bstore.Blockstore) {
-	t.Helper()
-
-	sma, err := vm.StateTree().GetActor(StoragePowerAddress)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	cst := hamt.CSTFromBstore(bs)
-
-	var smastate StoragePowerState
-	if err := cst.Get(context.TODO(), sma.Head, &smastate); err != nil {
-		t.Fatal(err)
-	}
-
-	smastate.TotalStorage = types.NewInt(10000)
-
-	c, err := cst.Put(context.TODO(), &smastate)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	sma.Head = c
-
-	if err := vm.StateTree().SetActor(StoragePowerAddress, sma); err != nil {
-		t.Fatal(err)
-	}
-}
-
-func fakeBlock(t *testing.T, minerAddr address.Address, ts uint64) *types.BlockHeader {
-	c := fakeCid(t, 1)
-	return &types.BlockHeader{Height: 5, Miner: minerAddr, Timestamp: ts, ParentStateRoot: c, Messages: c, ParentMessageReceipts: c, BLSAggregate: types.Signature{Type: types.KTBLS}}
-}
-
-func fakeCid(t *testing.T, s int) cid.Cid {
-	t.Helper()
-	c, err := cid.NewPrefixV1(cid.Raw, mh.IDENTITY).Sum([]byte(fmt.Sprintf("%d", s)))
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	return c
-}
-
-func signBlock(t *testing.T, w *wallet.Wallet, worker address.Address, blk *types.BlockHeader) {
-	t.Helper()
-	sb, err := blk.SigningBytes()
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	sig, err := w.Sign(context.TODO(), worker, sb)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	blk.BlockSig = sig
-}
diff --git a/chain/actors/actors.go b/chain/actors/actors.go
deleted file mode 100644
index 44c790fb2..000000000
--- a/chain/actors/actors.go
+++ /dev/null
@@ -1,52 +0,0 @@
-package actors
-
-import (
-	"github.com/filecoin-project/go-address"
-
-	"github.com/ipfs/go-cid"
-	mh "github.com/multiformats/go-multihash"
-)
-
-var AccountCodeCid cid.Cid
-var CronCodeCid cid.Cid
-var StoragePowerCodeCid cid.Cid
-var StorageMarketCodeCid cid.Cid
-var StorageMinerCodeCid cid.Cid
-var MultisigCodeCid cid.Cid
-var InitCodeCid cid.Cid
-var PaymentChannelCodeCid cid.Cid
-
-var InitAddress = mustIDAddress(0)
-var NetworkAddress = mustIDAddress(1)
-var StoragePowerAddress = mustIDAddress(2)
-var StorageMarketAddress = mustIDAddress(3) // TODO: missing from spec
-var CronAddress = mustIDAddress(4)
-var BurntFundsAddress = mustIDAddress(99)
-
-func mustIDAddress(i uint64) address.Address {
-	a, err := address.NewIDAddress(i)
-	if err != nil {
-		panic(err) // ok
-	}
-	return a
-}
-
-func init() {
-	pref := cid.NewPrefixV1(cid.Raw, mh.IDENTITY)
-	mustSum := func(s string) cid.Cid {
-		c, err := pref.Sum([]byte(s))
-		if err != nil {
-			panic(err) // ok
-		}
-		return c
-	}
-
-	AccountCodeCid = mustSum("fil/1/account") // TODO: spec
-	CronCodeCid = mustSum("fil/1/cron")
-	StoragePowerCodeCid = mustSum("fil/1/power")
-	StorageMarketCodeCid = mustSum("fil/1/market")
-	StorageMinerCodeCid = mustSum("fil/1/miner")
-	MultisigCodeCid = mustSum("fil/1/multisig")
-	InitCodeCid = mustSum("fil/1/init")
-	PaymentChannelCodeCid = mustSum("fil/1/paych")
-}
diff --git a/chain/actors/actors_test.go b/chain/actors/actors_test.go
deleted file mode 100644
index 64207b422..000000000
--- a/chain/actors/actors_test.go
+++ /dev/null
@@ -1,158 +0,0 @@
-package actors_test
-
-import (
-	"context"
-	"encoding/binary"
-	"fmt"
-	"testing"
-
-	"github.com/filecoin-project/lotus/build"
-
-	"github.com/filecoin-project/go-address"
-	. "github.com/filecoin-project/lotus/chain/actors"
-	"github.com/filecoin-project/lotus/chain/gen"
-	"github.com/filecoin-project/lotus/chain/store"
-	"github.com/filecoin-project/lotus/chain/types"
-	"github.com/filecoin-project/lotus/chain/vm"
-	dstore "github.com/ipfs/go-datastore"
-	bstore "github.com/ipfs/go-ipfs-blockstore"
-)
-
-func blsaddr(n uint64) address.Address {
-	buf := make([]byte, 48)
-	binary.PutUvarint(buf, n)
-
-	addr, err := address.NewBLSAddress(buf)
-	if err != nil {
-		panic(err) // ok
-	}
-
-	return addr
-}
-
-func setupVMTestEnv(t *testing.T) (*vm.VM, []address.Address, bstore.Blockstore) {
-	bs := bstore.NewBlockstore(dstore.NewMapDatastore())
-
-	from := blsaddr(0)
-	maddr := blsaddr(1)
-
-	actors := map[address.Address]types.BigInt{
-		from:  types.NewInt(1000000),
-		maddr: types.NewInt(0),
-	}
-	st, err := gen.MakeInitialStateTree(bs, actors)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	stateroot, err := st.Flush()
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	cs := store.NewChainStore(bs, nil)
-
-	// TODO: should probabaly mock out the randomness bit, nil works for now
-	vm, err := vm.NewVM(stateroot, 1, nil, maddr, cs.Blockstore())
-	if err != nil {
-		t.Fatal(err)
-	}
-	return vm, []address.Address{from, maddr}, bs
-}
-
-func TestVMInvokeMethod(t *testing.T) {
-	vm, addrs, _ := setupVMTestEnv(t)
-	from := addrs[0]
-
-	var err error
-	cenc, err := SerializeParams(&StorageMinerConstructorParams{Owner: from, Worker: from})
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	execparams := &ExecParams{
-		Code:   StorageMinerCodeCid,
-		Params: cenc,
-	}
-	enc, err := SerializeParams(execparams)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	msg := &types.Message{
-		To:       InitAddress,
-		From:     from,
-		Method:   IAMethods.Exec,
-		Params:   enc,
-		GasPrice: types.NewInt(1),
-		GasLimit: types.NewInt(10000),
-		Value:    types.NewInt(0),
-	}
-
-	ret, err := vm.ApplyMessage(context.TODO(), msg)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if ret.ExitCode != 0 {
-		t.Fatal("invocation failed")
-	}
-
-	outaddr, err := address.NewFromBytes(ret.Return)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if outaddr.String() != "t0102" {
-		t.Fatal("hold up")
-	}
-}
-
-func TestStorageMarketActorCreateMiner(t *testing.T) {
-	vm, addrs, bs := setupVMTestEnv(t)
-	from := addrs[0]
-	maddr := addrs[1]
-
-	cheatStorageMarketTotal(t, vm, bs)
-
-	params := &StorageMinerConstructorParams{
-		Owner:      maddr,
-		Worker:     maddr,
-		SectorSize: build.SectorSizes[0],
-		PeerID:     "fakepeerid",
-	}
-	var err error
-	enc, err := SerializeParams(params)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	msg := &types.Message{
-		To:       StoragePowerAddress,
-		From:     from,
-		Method:   SPAMethods.CreateStorageMiner,
-		Params:   enc,
-		GasPrice: types.NewInt(1),
-		GasLimit: types.NewInt(10000),
-		Value:    types.NewInt(50000),
-	}
-
-	ret, err := vm.ApplyMessage(context.TODO(), msg)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if ret.ExitCode != 0 {
-		fmt.Println(ret.ActorErr)
-		t.Fatal("invocation failed: ", ret.ExitCode)
-	}
-
-	outaddr, err := address.NewFromBytes(ret.Return)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if outaddr.String() != "t0102" {
-		t.Fatal("hold up")
-	}
-}
diff --git a/chain/actors/address.go b/chain/actors/address.go
deleted file mode 100644
index eb3bcbff3..000000000
--- a/chain/actors/address.go
+++ /dev/null
@@ -1,14 +0,0 @@
-package actors
-
-import (
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/lotus/chain/actors/aerrors"
-)
-
-func NewIDAddress(id uint64) (address.Address, ActorError) {
-	a, err := address.NewIDAddress(id)
-	if err != nil {
-		return address.Undef, aerrors.Escalate(err, "could not create ID Address")
-	}
-	return a, nil
-}
diff --git a/chain/actors/adt/adt.go b/chain/actors/adt/adt.go
new file mode 100644
index 000000000..39dd5cebc
--- /dev/null
+++ b/chain/actors/adt/adt.go
@@ -0,0 +1,65 @@
+package adt
+
+import (
+	"github.com/ipfs/go-cid"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/cbor"
+	"github.com/filecoin-project/go-state-types/network"
+	"github.com/filecoin-project/lotus/chain/actors/builtin"
+	adt0 "github.com/filecoin-project/specs-actors/actors/util/adt"
+)
+
+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
+}
+
+func AsMap(store Store, root cid.Cid, version builtin.Version) (Map, error) {
+	switch version {
+	case builtin.Version0:
+		return adt0.AsMap(store, root)
+	}
+	return nil, xerrors.Errorf("unknown network version: %d", version)
+}
+
+func NewMap(store Store, version builtin.Version) (Map, error) {
+	switch version {
+	case builtin.Version0:
+		return adt0.MakeEmptyMap(store), nil
+	}
+	return nil, xerrors.Errorf("unknown network version: %d", version)
+}
+
+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
+}
+
+func AsArray(store Store, root cid.Cid, version network.Version) (Array, error) {
+	switch builtin.VersionForNetwork(version) {
+	case builtin.Version0:
+		return adt0.AsArray(store, root)
+	}
+	return nil, xerrors.Errorf("unknown network version: %d", version)
+}
+
+func NewArray(store Store, version builtin.Version) (Array, error) {
+	switch version {
+	case builtin.Version0:
+		return adt0.MakeEmptyArray(store), nil
+	}
+	return nil, xerrors.Errorf("unknown network version: %d", version)
+}
diff --git a/chain/actors/adt/diff_adt.go b/chain/actors/adt/diff_adt.go
new file mode 100644
index 000000000..160e12e19
--- /dev/null
+++ b/chain/actors/adt/diff_adt.go
@@ -0,0 +1,122 @@
+package adt
+
+import (
+	"bytes"
+
+	"github.com/filecoin-project/go-state-types/abi"
+	typegen "github.com/whyrusleeping/cbor-gen"
+)
+
+// AdtArrayDiff generalizes adt.Array diffing by accepting a Deferred type that can unmarshalled to its corresponding struct
+// in an interface implantation.
+// Add should be called when a new k,v is added to the array
+// Modify should be called when a value is modified in the array
+// Remove should be called when a value is removed from the array
+type AdtArrayDiff interface {
+	Add(key uint64, val *typegen.Deferred) error
+	Modify(key uint64, from, to *typegen.Deferred) error
+	Remove(key uint64, val *typegen.Deferred) error
+}
+
+// TODO Performance can be improved by diffing the underlying IPLD graph, e.g. https://github.com/ipfs/go-merkledag/blob/749fd8717d46b4f34c9ce08253070079c89bc56d/dagutils/diff.go#L104
+// CBOR Marshaling will likely be the largest performance bottleneck here.
+
+// DiffAdtArray accepts two *adt.Array's and an AdtArrayDiff implementation. It does the following:
+// - All values that exist in preArr and not in curArr are passed to AdtArrayDiff.Remove()
+// - All values that exist in curArr nnd not in prevArr are passed to adtArrayDiff.Add()
+// - All values that exist in preArr and in curArr are passed to AdtArrayDiff.Modify()
+//  - It is the responsibility of AdtArrayDiff.Modify() to determine if the values it was passed have been modified.
+func DiffAdtArray(preArr, curArr Array, out AdtArrayDiff) error {
+	notNew := make(map[int64]struct{}, curArr.Length())
+	prevVal := new(typegen.Deferred)
+	if err := preArr.ForEach(prevVal, func(i int64) error {
+		curVal := new(typegen.Deferred)
+		found, err := curArr.Get(uint64(i), curVal)
+		if err != nil {
+			return err
+		}
+		if !found {
+			if err := out.Remove(uint64(i), prevVal); err != nil {
+				return err
+			}
+			return nil
+		}
+
+		// no modification
+		if !bytes.Equal(prevVal.Raw, curVal.Raw) {
+			if err := out.Modify(uint64(i), prevVal, curVal); err != nil {
+				return err
+			}
+		}
+		notNew[i] = struct{}{}
+		return nil
+	}); err != nil {
+		return err
+	}
+
+	curVal := new(typegen.Deferred)
+	return curArr.ForEach(curVal, func(i int64) error {
+		if _, ok := notNew[i]; ok {
+			return nil
+		}
+		return out.Add(uint64(i), curVal)
+	})
+}
+
+// TODO Performance can be improved by diffing the underlying IPLD graph, e.g. https://github.com/ipfs/go-merkledag/blob/749fd8717d46b4f34c9ce08253070079c89bc56d/dagutils/diff.go#L104
+// CBOR Marshaling will likely be the largest performance bottleneck here.
+
+// AdtMapDiff generalizes adt.Map diffing by accepting a Deferred type that can unmarshalled to its corresponding struct
+// in an interface implantation.
+// AsKey should return the Keyer implementation specific to the map
+// Add should be called when a new k,v is added to the map
+// Modify should be called when a value is modified in the map
+// Remove should be called when a value is removed from the map
+type AdtMapDiff interface {
+	AsKey(key string) (abi.Keyer, error)
+	Add(key string, val *typegen.Deferred) error
+	Modify(key string, from, to *typegen.Deferred) error
+	Remove(key string, val *typegen.Deferred) error
+}
+
+func DiffAdtMap(preMap, curMap Map, out AdtMapDiff) error {
+	notNew := make(map[string]struct{})
+	prevVal := new(typegen.Deferred)
+	if err := preMap.ForEach(prevVal, func(key string) error {
+		curVal := new(typegen.Deferred)
+		k, err := out.AsKey(key)
+		if err != nil {
+			return err
+		}
+
+		found, err := curMap.Get(k, curVal)
+		if err != nil {
+			return err
+		}
+		if !found {
+			if err := out.Remove(key, prevVal); err != nil {
+				return err
+			}
+			return nil
+		}
+
+		// no modification
+		if !bytes.Equal(prevVal.Raw, curVal.Raw) {
+			if err := out.Modify(key, prevVal, curVal); err != nil {
+				return err
+			}
+		}
+		notNew[key] = struct{}{}
+		return nil
+	}); err != nil {
+		return err
+	}
+
+	curVal := new(typegen.Deferred)
+	return curMap.ForEach(curVal, func(key string) error {
+		if _, ok := notNew[key]; ok {
+			return nil
+		}
+		return out.Add(key, curVal)
+	})
+}
diff --git a/chain/actors/adt/diff_adt_test.go b/chain/actors/adt/diff_adt_test.go
new file mode 100644
index 000000000..1c0726003
--- /dev/null
+++ b/chain/actors/adt/diff_adt_test.go
@@ -0,0 +1,300 @@
+package adt
+
+import (
+	"bytes"
+	"context"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	cbornode "github.com/ipfs/go-ipld-cbor"
+	typegen "github.com/whyrusleeping/cbor-gen"
+
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/specs-actors/actors/runtime"
+	adt0 "github.com/filecoin-project/specs-actors/actors/util/adt"
+
+	bstore "github.com/filecoin-project/lotus/lib/blockstore"
+)
+
+func TestDiffAdtArray(t *testing.T) {
+	ctxstoreA := newContextStore()
+	ctxstoreB := newContextStore()
+
+	arrA := adt0.MakeEmptyArray(ctxstoreA)
+	arrB := adt0.MakeEmptyArray(ctxstoreB)
+
+	require.NoError(t, arrA.Set(0, runtime.CBORBytes([]byte{0}))) // delete
+
+	require.NoError(t, arrA.Set(1, runtime.CBORBytes([]byte{0}))) // modify
+	require.NoError(t, arrB.Set(1, runtime.CBORBytes([]byte{1})))
+
+	require.NoError(t, arrA.Set(2, runtime.CBORBytes([]byte{1}))) // delete
+
+	require.NoError(t, arrA.Set(3, runtime.CBORBytes([]byte{0}))) // noop
+	require.NoError(t, arrB.Set(3, runtime.CBORBytes([]byte{0})))
+
+	require.NoError(t, arrA.Set(4, runtime.CBORBytes([]byte{0}))) // modify
+	require.NoError(t, arrB.Set(4, runtime.CBORBytes([]byte{6})))
+
+	require.NoError(t, arrB.Set(5, runtime.CBORBytes{8})) // add
+	require.NoError(t, arrB.Set(6, runtime.CBORBytes{9})) // add
+
+	changes := new(TestDiffArray)
+
+	assert.NoError(t, DiffAdtArray(arrA, arrB, changes))
+	assert.NotNil(t, changes)
+
+	assert.Equal(t, 2, len(changes.Added))
+	// keys 5 and 6 were added
+	assert.EqualValues(t, uint64(5), changes.Added[0].key)
+	assert.EqualValues(t, []byte{8}, changes.Added[0].val)
+	assert.EqualValues(t, uint64(6), changes.Added[1].key)
+	assert.EqualValues(t, []byte{9}, changes.Added[1].val)
+
+	assert.Equal(t, 2, len(changes.Modified))
+	// keys 1 and 4 were modified
+	assert.EqualValues(t, uint64(1), changes.Modified[0].From.key)
+	assert.EqualValues(t, []byte{0}, changes.Modified[0].From.val)
+	assert.EqualValues(t, uint64(1), changes.Modified[0].To.key)
+	assert.EqualValues(t, []byte{1}, changes.Modified[0].To.val)
+	assert.EqualValues(t, uint64(4), changes.Modified[1].From.key)
+	assert.EqualValues(t, []byte{0}, changes.Modified[1].From.val)
+	assert.EqualValues(t, uint64(4), changes.Modified[1].To.key)
+	assert.EqualValues(t, []byte{6}, changes.Modified[1].To.val)
+
+	assert.Equal(t, 2, len(changes.Removed))
+	// keys 0 and 2 were deleted
+	assert.EqualValues(t, uint64(0), changes.Removed[0].key)
+	assert.EqualValues(t, []byte{0}, changes.Removed[0].val)
+	assert.EqualValues(t, uint64(2), changes.Removed[1].key)
+	assert.EqualValues(t, []byte{1}, changes.Removed[1].val)
+}
+
+func TestDiffAdtMap(t *testing.T) {
+	ctxstoreA := newContextStore()
+	ctxstoreB := newContextStore()
+
+	mapA := adt0.MakeEmptyMap(ctxstoreA)
+	mapB := adt0.MakeEmptyMap(ctxstoreB)
+
+	require.NoError(t, mapA.Put(abi.UIntKey(0), runtime.CBORBytes([]byte{0}))) // delete
+
+	require.NoError(t, mapA.Put(abi.UIntKey(1), runtime.CBORBytes([]byte{0}))) // modify
+	require.NoError(t, mapB.Put(abi.UIntKey(1), runtime.CBORBytes([]byte{1})))
+
+	require.NoError(t, mapA.Put(abi.UIntKey(2), runtime.CBORBytes([]byte{1}))) // delete
+
+	require.NoError(t, mapA.Put(abi.UIntKey(3), runtime.CBORBytes([]byte{0}))) // noop
+	require.NoError(t, mapB.Put(abi.UIntKey(3), runtime.CBORBytes([]byte{0})))
+
+	require.NoError(t, mapA.Put(abi.UIntKey(4), runtime.CBORBytes([]byte{0}))) // modify
+	require.NoError(t, mapB.Put(abi.UIntKey(4), runtime.CBORBytes([]byte{6})))
+
+	require.NoError(t, mapB.Put(abi.UIntKey(5), runtime.CBORBytes{8})) // add
+	require.NoError(t, mapB.Put(abi.UIntKey(6), runtime.CBORBytes{9})) // add
+
+	changes := new(TestDiffMap)
+
+	assert.NoError(t, DiffAdtMap(mapA, mapB, changes))
+	assert.NotNil(t, changes)
+
+	assert.Equal(t, 2, len(changes.Added))
+	// keys 5 and 6 were added
+	assert.EqualValues(t, uint64(6), changes.Added[0].key)
+	assert.EqualValues(t, []byte{9}, changes.Added[0].val)
+	assert.EqualValues(t, uint64(5), changes.Added[1].key)
+	assert.EqualValues(t, []byte{8}, changes.Added[1].val)
+
+	assert.Equal(t, 2, len(changes.Modified))
+	// keys 1 and 4 were modified
+	assert.EqualValues(t, uint64(1), changes.Modified[0].From.key)
+	assert.EqualValues(t, []byte{0}, changes.Modified[0].From.val)
+	assert.EqualValues(t, uint64(1), changes.Modified[0].To.key)
+	assert.EqualValues(t, []byte{1}, changes.Modified[0].To.val)
+	assert.EqualValues(t, uint64(4), changes.Modified[1].From.key)
+	assert.EqualValues(t, []byte{0}, changes.Modified[1].From.val)
+	assert.EqualValues(t, uint64(4), changes.Modified[1].To.key)
+	assert.EqualValues(t, []byte{6}, changes.Modified[1].To.val)
+
+	assert.Equal(t, 2, len(changes.Removed))
+	// keys 0 and 2 were deleted
+	assert.EqualValues(t, uint64(0), changes.Removed[0].key)
+	assert.EqualValues(t, []byte{0}, changes.Removed[0].val)
+	assert.EqualValues(t, uint64(2), changes.Removed[1].key)
+	assert.EqualValues(t, []byte{1}, changes.Removed[1].val)
+
+}
+
+type TestDiffMap struct {
+	Added    []adtMapDiffResult
+	Modified []TestAdtMapDiffModified
+	Removed  []adtMapDiffResult
+}
+
+var _ AdtMapDiff = &TestDiffMap{}
+
+func (t *TestDiffMap) AsKey(key string) (abi.Keyer, error) {
+	k, err := abi.ParseUIntKey(key)
+	if err != nil {
+		return nil, err
+	}
+	return abi.UIntKey(k), nil
+}
+
+func (t *TestDiffMap) Add(key string, val *typegen.Deferred) error {
+	v := new(runtime.CBORBytes)
+	err := v.UnmarshalCBOR(bytes.NewReader(val.Raw))
+	if err != nil {
+		return err
+	}
+	k, err := abi.ParseUIntKey(key)
+	if err != nil {
+		return err
+	}
+	t.Added = append(t.Added, adtMapDiffResult{
+		key: k,
+		val: *v,
+	})
+	return nil
+}
+
+func (t *TestDiffMap) Modify(key string, from, to *typegen.Deferred) error {
+	vFrom := new(runtime.CBORBytes)
+	err := vFrom.UnmarshalCBOR(bytes.NewReader(from.Raw))
+	if err != nil {
+		return err
+	}
+
+	vTo := new(runtime.CBORBytes)
+	err = vTo.UnmarshalCBOR(bytes.NewReader(to.Raw))
+	if err != nil {
+		return err
+	}
+
+	k, err := abi.ParseUIntKey(key)
+	if err != nil {
+		return err
+	}
+
+	if !bytes.Equal(*vFrom, *vTo) {
+		t.Modified = append(t.Modified, TestAdtMapDiffModified{
+			From: adtMapDiffResult{
+				key: k,
+				val: *vFrom,
+			},
+			To: adtMapDiffResult{
+				key: k,
+				val: *vTo,
+			},
+		})
+	}
+	return nil
+}
+
+func (t *TestDiffMap) Remove(key string, val *typegen.Deferred) error {
+	v := new(runtime.CBORBytes)
+	err := v.UnmarshalCBOR(bytes.NewReader(val.Raw))
+	if err != nil {
+		return err
+	}
+	k, err := abi.ParseUIntKey(key)
+	if err != nil {
+		return err
+	}
+	t.Removed = append(t.Removed, adtMapDiffResult{
+		key: k,
+		val: *v,
+	})
+	return nil
+}
+
+type adtMapDiffResult struct {
+	key uint64
+	val runtime.CBORBytes
+}
+
+type TestAdtMapDiffModified struct {
+	From adtMapDiffResult
+	To   adtMapDiffResult
+}
+
+type adtArrayDiffResult struct {
+	key uint64
+	val runtime.CBORBytes
+}
+
+type TestDiffArray struct {
+	Added    []adtArrayDiffResult
+	Modified []TestAdtArrayDiffModified
+	Removed  []adtArrayDiffResult
+}
+
+var _ AdtArrayDiff = &TestDiffArray{}
+
+type TestAdtArrayDiffModified struct {
+	From adtArrayDiffResult
+	To   adtArrayDiffResult
+}
+
+func (t *TestDiffArray) Add(key uint64, val *typegen.Deferred) error {
+	v := new(runtime.CBORBytes)
+	err := v.UnmarshalCBOR(bytes.NewReader(val.Raw))
+	if err != nil {
+		return err
+	}
+	t.Added = append(t.Added, adtArrayDiffResult{
+		key: key,
+		val: *v,
+	})
+	return nil
+}
+
+func (t *TestDiffArray) Modify(key uint64, from, to *typegen.Deferred) error {
+	vFrom := new(runtime.CBORBytes)
+	err := vFrom.UnmarshalCBOR(bytes.NewReader(from.Raw))
+	if err != nil {
+		return err
+	}
+
+	vTo := new(runtime.CBORBytes)
+	err = vTo.UnmarshalCBOR(bytes.NewReader(to.Raw))
+	if err != nil {
+		return err
+	}
+
+	if !bytes.Equal(*vFrom, *vTo) {
+		t.Modified = append(t.Modified, TestAdtArrayDiffModified{
+			From: adtArrayDiffResult{
+				key: key,
+				val: *vFrom,
+			},
+			To: adtArrayDiffResult{
+				key: key,
+				val: *vTo,
+			},
+		})
+	}
+	return nil
+}
+
+func (t *TestDiffArray) Remove(key uint64, val *typegen.Deferred) error {
+	v := new(runtime.CBORBytes)
+	err := v.UnmarshalCBOR(bytes.NewReader(val.Raw))
+	if err != nil {
+		return err
+	}
+	t.Removed = append(t.Removed, adtArrayDiffResult{
+		key: key,
+		val: *v,
+	})
+	return nil
+}
+
+func newContextStore() Store {
+	ctx := context.Background()
+	bs := bstore.NewTemporarySync()
+	store := cbornode.NewCborStore(bs)
+	return WrapStore(ctx, store)
+}
diff --git a/chain/actors/adt/store.go b/chain/actors/adt/store.go
new file mode 100644
index 000000000..8dd9841a1
--- /dev/null
+++ b/chain/actors/adt/store.go
@@ -0,0 +1,17 @@
+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)
+}
diff --git a/chain/actors/aerrors/error.go b/chain/actors/aerrors/error.go
index ca545e366..12f802c8f 100644
--- a/chain/actors/aerrors/error.go
+++ b/chain/actors/aerrors/error.go
@@ -3,13 +3,14 @@ package aerrors
 import (
 	"fmt"
 
+	"github.com/filecoin-project/go-state-types/exitcode"
 	"golang.org/x/xerrors"
 )
 
 func IsFatal(err ActorError) bool {
 	return err != nil && err.IsFatal()
 }
-func RetCode(err ActorError) uint8 {
+func RetCode(err ActorError) exitcode.ExitCode {
 	if err == nil {
 		return 0
 	}
@@ -25,12 +26,12 @@ type internalActorError interface {
 type ActorError interface {
 	error
 	IsFatal() bool
-	RetCode() uint8
+	RetCode() exitcode.ExitCode
 }
 
 type actorError struct {
 	fatal   bool
-	retCode uint8
+	retCode exitcode.ExitCode
 
 	msg   string
 	frame xerrors.Frame
@@ -41,7 +42,7 @@ func (e *actorError) IsFatal() bool {
 	return e.fatal
 }
 
-func (e *actorError) RetCode() uint8 {
+func (e *actorError) RetCode() exitcode.ExitCode {
 	return e.retCode
 }
 
diff --git a/chain/actors/aerrors/error_test.go b/chain/actors/aerrors/error_test.go
index 242874a06..3bfd3d042 100644
--- a/chain/actors/aerrors/error_test.go
+++ b/chain/actors/aerrors/error_test.go
@@ -3,6 +3,7 @@ package aerrors_test
 import (
 	"testing"
 
+	"github.com/filecoin-project/go-state-types/exitcode"
 	. "github.com/filecoin-project/lotus/chain/actors/aerrors"
 
 	"github.com/stretchr/testify/assert"
@@ -31,5 +32,5 @@ func TestAbsorbeError(t *testing.T) {
 	aw3 := Wrap(aw2, "creating miner in storage market")
 	t.Logf("Verbose error: %+v", aw3)
 	t.Logf("Normal error: %v", aw3)
-	assert.Equal(t, uint8(35), RetCode(aw3))
+	assert.Equal(t, exitcode.ExitCode(35), RetCode(aw3))
 }
diff --git a/chain/actors/aerrors/wrap.go b/chain/actors/aerrors/wrap.go
index da12cb7c6..0552829f9 100644
--- a/chain/actors/aerrors/wrap.go
+++ b/chain/actors/aerrors/wrap.go
@@ -4,12 +4,13 @@ import (
 	"errors"
 	"fmt"
 
-	hamt "github.com/ipfs/go-hamt-ipld"
+	"github.com/filecoin-project/go-state-types/exitcode"
+	cbor "github.com/ipfs/go-ipld-cbor"
 	"golang.org/x/xerrors"
 )
 
 // New creates a new non-fatal error
-func New(retCode uint8, message string) ActorError {
+func New(retCode exitcode.ExitCode, message string) ActorError {
 	if retCode == 0 {
 		return &actorError{
 			fatal:   true,
@@ -29,7 +30,7 @@ func New(retCode uint8, message string) ActorError {
 }
 
 // Newf creates a new non-fatal error
-func Newf(retCode uint8, format string, args ...interface{}) ActorError {
+func Newf(retCode exitcode.ExitCode, format string, args ...interface{}) ActorError {
 	if retCode == 0 {
 		return &actorError{
 			fatal:   true,
@@ -48,6 +49,27 @@ func Newf(retCode uint8, format string, args ...interface{}) ActorError {
 	}
 }
 
+// todo: bit hacky
+
+func NewfSkip(skip int, retCode exitcode.ExitCode, format string, args ...interface{}) ActorError {
+	if retCode == 0 {
+		return &actorError{
+			fatal:   true,
+			retCode: 0,
+
+			msg:   "tried creating an error and setting RetCode to 0",
+			frame: xerrors.Caller(skip),
+			err:   fmt.Errorf(format, args...),
+		}
+	}
+	return &actorError{
+		retCode: retCode,
+
+		msg:   fmt.Sprintf(format, args...),
+		frame: xerrors.Caller(skip),
+	}
+}
+
 func Fatal(message string, args ...interface{}) ActorError {
 	return &actorError{
 		fatal: true,
@@ -95,7 +117,7 @@ func Wrapf(err ActorError, format string, args ...interface{}) ActorError {
 }
 
 // Absorb takes and error and makes in not fatal ActorError
-func Absorb(err error, retCode uint8, msg string) ActorError {
+func Absorb(err error, retCode exitcode.ExitCode, msg string) ActorError {
 	if err == nil {
 		return nil
 	}
@@ -160,7 +182,7 @@ func HandleExternalError(err error, msg string) ActorError {
 		}
 	}
 
-	if xerrors.Is(err, &hamt.SerializationError{}) {
+	if xerrors.Is(err, &cbor.SerializationError{}) {
 		return &actorError{
 			fatal:   false,
 			retCode: 253,
@@ -171,7 +193,8 @@ func HandleExternalError(err error, msg string) ActorError {
 	}
 
 	return &actorError{
-		fatal: true,
+		fatal:   false,
+		retCode: 219,
 
 		msg:   msg,
 		frame: xerrors.Caller(1),
diff --git a/chain/actors/builtin/README.md b/chain/actors/builtin/README.md
new file mode 100644
index 000000000..21b3fd38f
--- /dev/null
+++ b/chain/actors/builtin/README.md
@@ -0,0 +1,29 @@
+# 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.
diff --git a/chain/actors/builtin/account/account.go b/chain/actors/builtin/account/account.go
new file mode 100644
index 000000000..5b90580ec
--- /dev/null
+++ b/chain/actors/builtin/account/account.go
@@ -0,0 +1,31 @@
+package account
+
+import (
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/cbor"
+	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
+
+	"github.com/filecoin-project/lotus/chain/actors/adt"
+	"github.com/filecoin-project/lotus/chain/types"
+)
+
+func Load(store adt.Store, act *types.Actor) (State, error) {
+	switch act.Code {
+	case builtin0.AccountActorCodeID:
+		out := state0{store: store}
+		err := store.Get(store.Context(), act.Head, &out)
+		if err != nil {
+			return nil, err
+		}
+		return &out, nil
+	}
+	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
+}
+
+type State interface {
+	cbor.Marshaler
+
+	PubkeyAddress() (address.Address, error)
+}
diff --git a/chain/actors/builtin/account/v0.go b/chain/actors/builtin/account/v0.go
new file mode 100644
index 000000000..30bafbfd3
--- /dev/null
+++ b/chain/actors/builtin/account/v0.go
@@ -0,0 +1,18 @@
+package account
+
+import (
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/lotus/chain/actors/adt"
+	"github.com/filecoin-project/specs-actors/actors/builtin/account"
+)
+
+var _ State = (*state0)(nil)
+
+type state0 struct {
+	account.State
+	store adt.Store
+}
+
+func (s *state0) PubkeyAddress() (address.Address, error) {
+	return s.Address, nil
+}
diff --git a/chain/actors/builtin/builtin.go b/chain/actors/builtin/builtin.go
new file mode 100644
index 000000000..a85b4da65
--- /dev/null
+++ b/chain/actors/builtin/builtin.go
@@ -0,0 +1,43 @@
+package builtin
+
+import (
+	"fmt"
+
+	"github.com/filecoin-project/go-state-types/abi"
+	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
+	proof0 "github.com/filecoin-project/specs-actors/actors/runtime/proof"
+
+	smoothing0 "github.com/filecoin-project/specs-actors/actors/util/smoothing"
+
+	"github.com/filecoin-project/go-state-types/network"
+)
+
+type Version int
+
+const (
+	Version0 = iota
+)
+
+// Converts a network version into a specs-actors version.
+func VersionForNetwork(version network.Version) Version {
+	switch version {
+	case network.Version0, network.Version1, network.Version2, network.Version3:
+		return Version0
+	default:
+		panic(fmt.Sprintf("unsupported network version %d", version))
+	}
+}
+
+// TODO: Why does actors have 2 different versions of this?
+type SectorInfo = proof0.SectorInfo
+type PoStProof = proof0.PoStProof
+type FilterEstimate = smoothing0.FilterEstimate
+
+func FromV0FilterEstimate(v0 smoothing0.FilterEstimate) FilterEstimate {
+	return (FilterEstimate)(v0)
+}
+
+// Doesn't change between actors v0 and v1
+func QAPowerForWeight(size abi.SectorSize, duration abi.ChainEpoch, dealWeight, verifiedWeight abi.DealWeight) abi.StoragePower {
+	return miner0.QAPowerForWeight(size, duration, dealWeight, verifiedWeight)
+}
diff --git a/chain/actors/builtin/init/init.go b/chain/actors/builtin/init/init.go
new file mode 100644
index 000000000..f235450c2
--- /dev/null
+++ b/chain/actors/builtin/init/init.go
@@ -0,0 +1,44 @@
+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"
+	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
+
+	"github.com/filecoin-project/lotus/chain/actors/adt"
+	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/node/modules/dtypes"
+)
+
+var Address = builtin0.InitActorAddr
+
+func Load(store adt.Store, act *types.Actor) (State, error) {
+	switch act.Code {
+	case builtin0.InitActorCodeID:
+		out := state0{store: store}
+		err := store.Get(store.Context(), act.Head, &out)
+		if err != nil {
+			return nil, err
+		}
+		return &out, nil
+	}
+	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
+}
diff --git a/chain/actors/builtin/init/v0.go b/chain/actors/builtin/init/v0.go
new file mode 100644
index 000000000..425ba654c
--- /dev/null
+++ b/chain/actors/builtin/init/v0.go
@@ -0,0 +1,67 @@
+package init
+
+import (
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/abi"
+	cbg "github.com/whyrusleeping/cbor-gen"
+	"golang.org/x/xerrors"
+
+	init_ "github.com/filecoin-project/specs-actors/actors/builtin/init"
+
+	"github.com/filecoin-project/lotus/chain/actors/adt"
+	"github.com/filecoin-project/lotus/node/modules/dtypes"
+
+	adt0 "github.com/filecoin-project/specs-actors/actors/util/adt"
+)
+
+var _ State = (*state0)(nil)
+
+type state0 struct {
+	init_.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) 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
+}
diff --git a/chain/actors/builtin/market/diff.go b/chain/actors/builtin/market/diff.go
new file mode 100644
index 000000000..d0b4a2fd3
--- /dev/null
+++ b/chain/actors/builtin/market/diff.go
@@ -0,0 +1,91 @@
+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
+}
diff --git a/chain/actors/builtin/market/market.go b/chain/actors/builtin/market/market.go
new file mode 100644
index 000000000..fef0c03f9
--- /dev/null
+++ b/chain/actors/builtin/market/market.go
@@ -0,0 +1,129 @@
+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"
+	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
+	market0 "github.com/filecoin-project/specs-actors/actors/builtin/market"
+	"github.com/ipfs/go-cid"
+	cbg "github.com/whyrusleeping/cbor-gen"
+
+	"github.com/filecoin-project/lotus/chain/actors/adt"
+	"github.com/filecoin-project/lotus/chain/types"
+)
+
+var Address = builtin0.StorageMarketActorAddr
+
+func Load(store adt.Store, act *types.Actor) (st State, err error) {
+	switch act.Code {
+	case builtin0.StorageMarketActorCodeID:
+		out := state0{store: store}
+		err := store.Get(store.Context(), act.Head, &out)
+		if err != nil {
+			return nil, err
+		}
+		return &out, nil
+	}
+	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 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,
+	}
+}
diff --git a/chain/actors/builtin/market/v0.go b/chain/actors/builtin/market/v0.go
new file mode 100644
index 000000000..2727f513d
--- /dev/null
+++ b/chain/actors/builtin/market/v0.go
@@ -0,0 +1,192 @@
+package market
+
+import (
+	"bytes"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/lotus/chain/actors/adt"
+	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/specs-actors/actors/builtin/market"
+	adt0 "github.com/filecoin-project/specs-actors/actors/util/adt"
+	cbg "github.com/whyrusleeping/cbor-gen"
+)
+
+var _ State = (*state0)(nil)
+
+type state0 struct {
+	market.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 market.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 market.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 market.DealState
+	return s.Array.ForEach(&ds0, func(idx int64) error {
+		return cb(abi.DealID(idx), fromV0DealState(ds0))
+	})
+}
+
+func (s *dealStates0) decode(val *cbg.Deferred) (*DealState, error) {
+	var ds0 market.DealState
+	if err := ds0.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil {
+		return nil, err
+	}
+	ds := fromV0DealState(ds0)
+	return &ds, nil
+}
+
+func (s *dealStates0) array() adt.Array {
+	return s.Array
+}
+
+func fromV0DealState(v0 market.DealState) DealState {
+	return (DealState)(v0)
+}
+
+type dealProposals0 struct {
+	adt.Array
+}
+
+func (s *dealProposals0) Get(dealID abi.DealID) (*DealProposal, bool, error) {
+	var proposal0 market.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 market.DealProposal
+	return s.Array.ForEach(&dp0, func(idx int64) error {
+		return cb(abi.DealID(idx), fromV0DealProposal(dp0))
+	})
+}
+
+func (s *dealProposals0) decode(val *cbg.Deferred) (*DealProposal, error) {
+	var dp0 market.DealProposal
+	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 market.DealProposal) DealProposal {
+	return (DealProposal)(v0)
+}
diff --git a/chain/actors/builtin/miner/diff.go b/chain/actors/builtin/miner/diff.go
new file mode 100644
index 000000000..dde4db890
--- /dev/null
+++ b/chain/actors/builtin/miner/diff.go
@@ -0,0 +1,127 @@
+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
+}
diff --git a/chain/actors/builtin/miner/miner.go b/chain/actors/builtin/miner/miner.go
new file mode 100644
index 000000000..1a4c466b9
--- /dev/null
+++ b/chain/actors/builtin/miner/miner.go
@@ -0,0 +1,169 @@
+package miner
+
+import (
+	"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"
+	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
+	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
+
+	"github.com/filecoin-project/lotus/chain/actors/adt"
+	"github.com/filecoin-project/lotus/chain/types"
+)
+
+// Unchanged between v0 and v1 actors
+var WPoStProvingPeriod = miner0.WPoStProvingPeriod
+
+const MinSectorExpiration = miner0.MinSectorExpiration
+
+func Load(store adt.Store, act *types.Actor) (st State, err error) {
+	switch act.Code {
+	case builtin0.StorageMinerActorCodeID:
+		out := state0{store: store}
+		err := store.Get(store.Context(), act.Head, &out)
+		if err != nil {
+			return nil, err
+		}
+		return &out, nil
+	}
+	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)
+
+	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)
+
+	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
+	PostSubmissions() (bitfield.BitField, error)
+
+	PartitionsChanged(Deadline) (bool, 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 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
+}
+
+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
+}
diff --git a/chain/actors/builtin/miner/utils.go b/chain/actors/builtin/miner/utils.go
new file mode 100644
index 000000000..f9c6b3da3
--- /dev/null
+++ b/chain/actors/builtin/miner/utils.go
@@ -0,0 +1,28 @@
+package miner
+
+import (
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-bitfield"
+)
+
+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...)
+}
diff --git a/chain/actors/builtin/miner/v0.go b/chain/actors/builtin/miner/v0.go
new file mode 100644
index 000000000..f5aa7849d
--- /dev/null
+++ b/chain/actors/builtin/miner/v0.go
@@ -0,0 +1,373 @@
+package miner
+
+import (
+	"bytes"
+	"errors"
+
+	"github.com/libp2p/go-libp2p-core/peer"
+	cbg "github.com/whyrusleeping/cbor-gen"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-bitfield"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/dline"
+	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
+	adt0 "github.com/filecoin-project/specs-actors/actors/util/adt"
+
+	"github.com/filecoin-project/lotus/chain/actors/adt"
+)
+
+var _ State = (*state0)(nil)
+
+type state0 struct {
+	miner0.State
+	store adt.Store
+}
+
+type deadline0 struct {
+	miner0.Deadline
+	store adt.Store
+}
+
+type partition0 struct {
+	miner0.Partition
+	store adt.Store
+}
+
+func (s *state0) AvailableBalance(bal abi.TokenAmount) (abi.TokenAmount, error) {
+	return s.GetAvailableBalance(bal), nil
+}
+
+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) 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) Info() (MinerInfo, error) {
+	info, err := s.State.GetInfo(s.store)
+	if err != nil {
+		return MinerInfo{}, err
+	}
+
+	var pid *peer.ID
+	if peerID, err := peer.IDFromBytes(info.PeerId); err == nil {
+		pid = &peerID
+	}
+
+	mi := MinerInfo{
+		Owner:            info.Owner,
+		Worker:           info.Worker,
+		ControlAddresses: info.ControlAddresses,
+
+		NewWorker:         address.Undef,
+		WorkerChangeEpoch: -1,
+
+		PeerId:                     pid,
+		Multiaddrs:                 info.Multiaddrs,
+		SealProofType:              info.SealProofType,
+		SectorSize:                 info.SectorSize,
+		WindowPoStPartitionSectors: info.WindowPoStPartitionSectors,
+	}
+
+	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) PostSubmissions() (bitfield.BitField, error) {
+	return d.Deadline.PostSubmissions, 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)
+}
diff --git a/chain/actors/builtin/multisig/multisig.go b/chain/actors/builtin/multisig/multisig.go
new file mode 100644
index 000000000..884b6f493
--- /dev/null
+++ b/chain/actors/builtin/multisig/multisig.go
@@ -0,0 +1,43 @@
+package multisig
+
+import (
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/cbor"
+
+	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
+	msig0 "github.com/filecoin-project/specs-actors/actors/builtin/multisig"
+
+	"github.com/filecoin-project/lotus/chain/actors/adt"
+	"github.com/filecoin-project/lotus/chain/types"
+)
+
+func Load(store adt.Store, act *types.Actor) (State, error) {
+	switch act.Code {
+	case builtin0.MultisigActorCodeID:
+		out := state0{store: store}
+		err := store.Get(store.Context(), act.Head, &out)
+		if err != nil {
+			return nil, err
+		}
+		return &out, nil
+	}
+	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
+}
+
+type Transaction = msig0.Transaction
diff --git a/chain/actors/builtin/multisig/v0.go b/chain/actors/builtin/multisig/v0.go
new file mode 100644
index 000000000..ae0a7ac0e
--- /dev/null
+++ b/chain/actors/builtin/multisig/v0.go
@@ -0,0 +1,59 @@
+package multisig
+
+import (
+	"encoding/binary"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/lotus/chain/actors/adt"
+	"golang.org/x/xerrors"
+
+	msig0 "github.com/filecoin-project/specs-actors/actors/builtin/multisig"
+	adt0 "github.com/filecoin-project/specs-actors/actors/util/adt"
+)
+
+var _ State = (*state0)(nil)
+
+type state0 struct {
+	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))
+	})
+}
diff --git a/chain/actors/builtin/paych/mock/mock.go b/chain/actors/builtin/paych/mock/mock.go
new file mode 100644
index 000000000..c4903f3ac
--- /dev/null
+++ b/chain/actors/builtin/paych/mock/mock.go
@@ -0,0 +1,89 @@
+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,
+	toSend abi.TokenAmount,
+	lanes map[uint64]paych.LaneState,
+) paych.State {
+	return &mockState{from, to, settlingAt, toSend, 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
+}
diff --git a/chain/actors/builtin/paych/paych.go b/chain/actors/builtin/paych/paych.go
new file mode 100644
index 000000000..dad54163f
--- /dev/null
+++ b/chain/actors/builtin/paych/paych.go
@@ -0,0 +1,60 @@
+package paych
+
+import (
+	"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"
+	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
+	paych0 "github.com/filecoin-project/specs-actors/actors/builtin/paych"
+
+	"github.com/filecoin-project/lotus/chain/actors/adt"
+	"github.com/filecoin-project/lotus/chain/types"
+)
+
+// Load returns an abstract copy of payment channel state, irregardless of actor version
+func Load(store adt.Store, act *types.Actor) (State, error) {
+	switch act.Code {
+	case builtin0.PaymentChannelActorCodeID:
+		out := state0{store: store}
+		err := store.Get(store.Context(), act.Head, &out)
+		if err != nil {
+			return nil, err
+		}
+		return &out, nil
+	}
+	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
diff --git a/chain/actors/builtin/paych/v0.go b/chain/actors/builtin/paych/v0.go
new file mode 100644
index 000000000..c0eea1000
--- /dev/null
+++ b/chain/actors/builtin/paych/v0.go
@@ -0,0 +1,91 @@
+package paych
+
+import (
+	"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/lotus/chain/actors/adt"
+	"github.com/filecoin-project/specs-actors/actors/builtin/paych"
+	adt0 "github.com/filecoin-project/specs-actors/actors/util/adt"
+)
+
+var _ State = (*state0)(nil)
+
+type state0 struct {
+	paych.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 paych.LaneState
+	return lsamt.ForEach(&ls, func(i int64) error {
+		return cb(uint64(i), &laneState0{ls})
+	})
+}
+
+type laneState0 struct {
+	paych.LaneState
+}
+
+func (ls *laneState0) Redeemed() (big.Int, error) {
+	return ls.LaneState.Redeemed, nil
+}
+
+func (ls *laneState0) Nonce() (uint64, error) {
+	return ls.LaneState.Nonce, nil
+}
diff --git a/chain/actors/builtin/power/power.go b/chain/actors/builtin/power/power.go
new file mode 100644
index 000000000..e4bb52d44
--- /dev/null
+++ b/chain/actors/builtin/power/power.go
@@ -0,0 +1,53 @@
+package power
+
+import (
+	"github.com/filecoin-project/go-address"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/cbor"
+	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
+
+	"github.com/filecoin-project/lotus/chain/actors/adt"
+	"github.com/filecoin-project/lotus/chain/actors/builtin"
+	"github.com/filecoin-project/lotus/chain/types"
+)
+
+var Address = builtin0.StoragePowerActorAddr
+
+func Load(store adt.Store, act *types.Actor) (st State, err error) {
+	switch act.Code {
+	case builtin0.StoragePowerActorCodeID:
+		out := state0{store: store}
+		err := store.Get(store.Context(), act.Head, &out)
+		if err != nil {
+			return nil, err
+		}
+		return &out, nil
+	}
+	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)
+}
+
+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
+}
diff --git a/chain/actors/builtin/power/v0.go b/chain/actors/builtin/power/v0.go
new file mode 100644
index 000000000..f2fe96dad
--- /dev/null
+++ b/chain/actors/builtin/power/v0.go
@@ -0,0 +1,85 @@
+package power
+
+import (
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/lotus/chain/actors/builtin"
+	power0 "github.com/filecoin-project/specs-actors/actors/builtin/power"
+	"github.com/filecoin-project/specs-actors/actors/util/adt"
+)
+
+var _ State = (*state0)(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 := adt.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 := adt.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
+}
diff --git a/chain/actors/builtin/reward/reward.go b/chain/actors/builtin/reward/reward.go
new file mode 100644
index 000000000..cfa82c774
--- /dev/null
+++ b/chain/actors/builtin/reward/reward.go
@@ -0,0 +1,50 @@
+package reward
+
+import (
+	"github.com/filecoin-project/go-state-types/abi"
+	reward0 "github.com/filecoin-project/specs-actors/actors/builtin/reward"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-state-types/cbor"
+	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
+
+	"github.com/filecoin-project/lotus/chain/actors/adt"
+	"github.com/filecoin-project/lotus/chain/actors/builtin"
+	"github.com/filecoin-project/lotus/chain/types"
+)
+
+var Address = builtin0.RewardActorAddr
+
+func Load(store adt.Store, act *types.Actor) (st State, err error) {
+	switch act.Code {
+	case builtin0.RewardActorCodeID:
+		out := state0{store: store}
+		err := store.Get(store.Context(), act.Head, &out)
+		if err != nil {
+			return nil, err
+		}
+		return &out, nil
+	}
+	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
diff --git a/chain/actors/builtin/reward/v0.go b/chain/actors/builtin/reward/v0.go
new file mode 100644
index 000000000..df7117b67
--- /dev/null
+++ b/chain/actors/builtin/reward/v0.go
@@ -0,0 +1,71 @@
+package reward
+
+import (
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/lotus/chain/actors/builtin"
+	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
+	"github.com/filecoin-project/specs-actors/actors/builtin/reward"
+	"github.com/filecoin-project/specs-actors/actors/util/adt"
+	"github.com/filecoin-project/specs-actors/actors/util/smoothing"
+)
+
+var _ State = (*state0)(nil)
+
+type state0 struct {
+	reward.State
+	store adt.Store
+}
+
+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.CumsumBaseline, nil
+}
+
+func (s *state0) InitialPledgeForPower(sectorWeight abi.StoragePower, networkTotalPledge abi.TokenAmount, networkQAPower *builtin.FilterEstimate, circSupply abi.TokenAmount) (abi.TokenAmount, error) {
+	return miner0.InitialPledgeForPower(
+		sectorWeight,
+		s.State.ThisEpochBaselinePower,
+		networkTotalPledge,
+		s.State.ThisEpochRewardSmoothed,
+		&smoothing.FilterEstimate{
+			PositionEstimate: networkQAPower.PositionEstimate,
+			VelocityEstimate: networkQAPower.VelocityEstimate,
+		},
+		circSupply), nil
+}
+
+func (s *state0) PreCommitDepositForPower(networkQAPower builtin.FilterEstimate, sectorWeight abi.StoragePower) (abi.TokenAmount, error) {
+	return miner0.PreCommitDepositForPower(s.State.ThisEpochRewardSmoothed,
+		&smoothing.FilterEstimate{
+			PositionEstimate: networkQAPower.PositionEstimate,
+			VelocityEstimate: networkQAPower.VelocityEstimate,
+		},
+		sectorWeight), nil
+}
diff --git a/chain/actors/builtin/verifreg/v0.go b/chain/actors/builtin/verifreg/v0.go
new file mode 100644
index 000000000..c59a58811
--- /dev/null
+++ b/chain/actors/builtin/verifreg/v0.go
@@ -0,0 +1,71 @@
+package verifreg
+
+import (
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/big"
+	verifreg0 "github.com/filecoin-project/specs-actors/actors/builtin/verifreg"
+	adt0 "github.com/filecoin-project/specs-actors/actors/util/adt"
+	"github.com/ipfs/go-cid"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/lotus/chain/actors/adt"
+)
+
+var _ State = (*state0)(nil)
+
+type state0 struct {
+	verifreg0.State
+	store adt.Store
+}
+
+func getDataCap(store adt.Store, root cid.Cid, addr address.Address) (bool, abi.StoragePower, error) {
+	if addr.Protocol() != address.ID {
+		return false, big.Zero(), xerrors.Errorf("can only look up ID addresses")
+	}
+
+	vh, err := adt0.AsMap(store, root)
+	if err != nil {
+		return false, big.Zero(), xerrors.Errorf("loading verifreg: %w", err)
+	}
+
+	var dcap abi.StoragePower
+	if found, err := vh.Get(abi.AddrKey(addr), &dcap); err != nil {
+		return false, big.Zero(), xerrors.Errorf("looking up addr: %w", err)
+	} else if !found {
+		return false, big.Zero(), nil
+	}
+
+	return true, dcap, nil
+}
+
+func (s *state0) VerifiedClientDataCap(addr address.Address) (bool, abi.StoragePower, error) {
+	return getDataCap(s.store, s.State.VerifiedClients, addr)
+}
+
+func (s *state0) VerifierDataCap(addr address.Address) (bool, abi.StoragePower, error) {
+	return getDataCap(s.store, s.State.Verifiers, addr)
+}
+
+func forEachCap(store adt.Store, root cid.Cid, cb func(addr address.Address, dcap abi.StoragePower) error) error {
+	vh, err := adt0.AsMap(store, root)
+	if err != nil {
+		return xerrors.Errorf("loading verified clients: %w", err)
+	}
+	var dcap abi.StoragePower
+	return vh.ForEach(&dcap, func(key string) error {
+		a, err := address.NewFromBytes([]byte(key))
+		if err != nil {
+			return err
+		}
+		return cb(a, dcap)
+	})
+}
+
+func (s *state0) ForEachVerifier(cb func(addr address.Address, dcap abi.StoragePower) error) error {
+	return forEachCap(s.store, s.State.Verifiers, cb)
+}
+
+func (s *state0) ForEachClient(cb func(addr address.Address, dcap abi.StoragePower) error) error {
+	return forEachCap(s.store, s.State.VerifiedClients, cb)
+}
diff --git a/chain/actors/builtin/verifreg/verifreg.go b/chain/actors/builtin/verifreg/verifreg.go
new file mode 100644
index 000000000..c861f862f
--- /dev/null
+++ b/chain/actors/builtin/verifreg/verifreg.go
@@ -0,0 +1,37 @@
+package verifreg
+
+import (
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/abi"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-state-types/cbor"
+	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
+
+	"github.com/filecoin-project/lotus/chain/actors/adt"
+	"github.com/filecoin-project/lotus/chain/types"
+)
+
+var Address = builtin0.VerifiedRegistryActorAddr
+
+func Load(store adt.Store, act *types.Actor) (State, error) {
+	switch act.Code {
+	case builtin0.VerifiedRegistryActorCodeID:
+		out := state0{store: store}
+		err := store.Get(store.Context(), act.Head, &out)
+		if err != nil {
+			return nil, err
+		}
+		return &out, nil
+	}
+	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
+}
+
+type State interface {
+	cbor.Marshaler
+
+	VerifiedClientDataCap(address.Address) (bool, abi.StoragePower, error)
+	VerifierDataCap(address.Address) (bool, abi.StoragePower, error)
+	ForEachVerifier(func(addr address.Address, dcap abi.StoragePower) error) error
+	ForEachClient(func(addr address.Address, dcap abi.StoragePower) error) error
+}
diff --git a/chain/actors/cbor_gen.go b/chain/actors/cbor_gen.go
deleted file mode 100644
index 73a3512a0..000000000
--- a/chain/actors/cbor_gen.go
+++ /dev/null
@@ -1,4232 +0,0 @@
-package actors
-
-import (
-	"fmt"
-	"io"
-	"sort"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/lotus/chain/types"
-	"github.com/libp2p/go-libp2p-core/peer"
-	cbg "github.com/whyrusleeping/cbor-gen"
-	xerrors "golang.org/x/xerrors"
-)
-
-// Code generated by github.com/whyrusleeping/cbor-gen. DO NOT EDIT.
-
-var _ = xerrors.Errorf
-
-func (t *InitActorState) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{130}); err != nil {
-		return err
-	}
-
-	// t.AddressMap (cid.Cid) (struct)
-
-	if err := cbg.WriteCid(w, t.AddressMap); err != nil {
-		return xerrors.Errorf("failed to write cid field t.AddressMap: %w", err)
-	}
-
-	// t.NextID (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.NextID))); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *InitActorState) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 2 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	// t.AddressMap (cid.Cid) (struct)
-
-	{
-
-		c, err := cbg.ReadCid(br)
-		if err != nil {
-			return xerrors.Errorf("failed to read cid field t.AddressMap: %w", err)
-		}
-
-		t.AddressMap = c
-
-	}
-	// t.NextID (uint64) (uint64)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.NextID = uint64(extra)
-	return nil
-}
-
-func (t *ExecParams) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{130}); err != nil {
-		return err
-	}
-
-	// t.Code (cid.Cid) (struct)
-
-	if err := cbg.WriteCid(w, t.Code); err != nil {
-		return xerrors.Errorf("failed to write cid field t.Code: %w", err)
-	}
-
-	// t.Params ([]uint8) (slice)
-	if len(t.Params) > cbg.ByteArrayMaxLen {
-		return xerrors.Errorf("Byte array in field t.Params was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajByteString, uint64(len(t.Params)))); err != nil {
-		return err
-	}
-	if _, err := w.Write(t.Params); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *ExecParams) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 2 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	// t.Code (cid.Cid) (struct)
-
-	{
-
-		c, err := cbg.ReadCid(br)
-		if err != nil {
-			return xerrors.Errorf("failed to read cid field t.Code: %w", err)
-		}
-
-		t.Code = c
-
-	}
-	// t.Params ([]uint8) (slice)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-
-	if extra > cbg.ByteArrayMaxLen {
-		return fmt.Errorf("t.Params: byte array too large (%d)", extra)
-	}
-	if maj != cbg.MajByteString {
-		return fmt.Errorf("expected byte array")
-	}
-	t.Params = make([]byte, extra)
-	if _, err := io.ReadFull(br, t.Params); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *AccountActorState) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{129}); err != nil {
-		return err
-	}
-
-	// t.Address (address.Address) (struct)
-	if err := t.Address.MarshalCBOR(w); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *AccountActorState) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 1 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	// t.Address (address.Address) (struct)
-
-	{
-
-		if err := t.Address.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-	}
-	return nil
-}
-
-func (t *StorageMinerActorState) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{138}); err != nil {
-		return err
-	}
-
-	// t.PreCommittedSectors (map[string]*actors.PreCommittedSector) (map)
-	{
-		if len(t.PreCommittedSectors) > 4096 {
-			return xerrors.Errorf("cannot marshal t.PreCommittedSectors map too large")
-		}
-
-		if err := cbg.CborWriteHeader(w, cbg.MajMap, uint64(len(t.PreCommittedSectors))); err != nil {
-			return err
-		}
-
-		keys := make([]string, 0, len(t.PreCommittedSectors))
-		for k := range t.PreCommittedSectors {
-			keys = append(keys, k)
-		}
-		sort.Strings(keys)
-		for _, k := range keys {
-			v := t.PreCommittedSectors[k]
-
-			if len(k) > cbg.MaxLength {
-				return xerrors.Errorf("Value in field k was too long")
-			}
-
-			if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len(k)))); err != nil {
-				return err
-			}
-			if _, err := w.Write([]byte(k)); err != nil {
-				return err
-			}
-
-			if err := v.MarshalCBOR(w); err != nil {
-				return err
-			}
-
-		}
-	}
-
-	// t.Sectors (cid.Cid) (struct)
-
-	if err := cbg.WriteCid(w, t.Sectors); err != nil {
-		return xerrors.Errorf("failed to write cid field t.Sectors: %w", err)
-	}
-
-	// t.ProvingSet (cid.Cid) (struct)
-
-	if err := cbg.WriteCid(w, t.ProvingSet); err != nil {
-		return xerrors.Errorf("failed to write cid field t.ProvingSet: %w", err)
-	}
-
-	// t.Info (cid.Cid) (struct)
-
-	if err := cbg.WriteCid(w, t.Info); err != nil {
-		return xerrors.Errorf("failed to write cid field t.Info: %w", err)
-	}
-
-	// t.FaultSet (types.BitField) (struct)
-	if err := t.FaultSet.MarshalCBOR(w); err != nil {
-		return err
-	}
-
-	// t.LastFaultSubmission (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.LastFaultSubmission))); err != nil {
-		return err
-	}
-
-	// t.Power (types.BigInt) (struct)
-	if err := t.Power.MarshalCBOR(w); err != nil {
-		return err
-	}
-
-	// t.Active (bool) (bool)
-	if err := cbg.WriteBool(w, t.Active); err != nil {
-		return err
-	}
-
-	// t.SlashedAt (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.SlashedAt))); err != nil {
-		return err
-	}
-
-	// t.ElectionPeriodStart (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.ElectionPeriodStart))); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *StorageMinerActorState) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 10 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	// t.PreCommittedSectors (map[string]*actors.PreCommittedSector) (map)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajMap {
-		return fmt.Errorf("expected a map (major type 5)")
-	}
-	if extra > 4096 {
-		return fmt.Errorf("t.PreCommittedSectors: map too large")
-	}
-
-	t.PreCommittedSectors = make(map[string]*PreCommittedSector, extra)
-
-	for i, l := 0, int(extra); i < l; i++ {
-
-		var k string
-
-		{
-			sval, err := cbg.ReadString(br)
-			if err != nil {
-				return err
-			}
-
-			k = string(sval)
-		}
-
-		var v *PreCommittedSector
-
-		{
-
-			pb, err := br.PeekByte()
-			if err != nil {
-				return err
-			}
-			if pb == cbg.CborNull[0] {
-				var nbuf [1]byte
-				if _, err := br.Read(nbuf[:]); err != nil {
-					return err
-				}
-			} else {
-				v = new(PreCommittedSector)
-				if err := v.UnmarshalCBOR(br); err != nil {
-					return err
-				}
-			}
-
-		}
-
-		t.PreCommittedSectors[k] = v
-
-	}
-	// t.Sectors (cid.Cid) (struct)
-
-	{
-
-		c, err := cbg.ReadCid(br)
-		if err != nil {
-			return xerrors.Errorf("failed to read cid field t.Sectors: %w", err)
-		}
-
-		t.Sectors = c
-
-	}
-	// t.ProvingSet (cid.Cid) (struct)
-
-	{
-
-		c, err := cbg.ReadCid(br)
-		if err != nil {
-			return xerrors.Errorf("failed to read cid field t.ProvingSet: %w", err)
-		}
-
-		t.ProvingSet = c
-
-	}
-	// t.Info (cid.Cid) (struct)
-
-	{
-
-		c, err := cbg.ReadCid(br)
-		if err != nil {
-			return xerrors.Errorf("failed to read cid field t.Info: %w", err)
-		}
-
-		t.Info = c
-
-	}
-	// t.FaultSet (types.BitField) (struct)
-
-	{
-
-		if err := t.FaultSet.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-	}
-	// t.LastFaultSubmission (uint64) (uint64)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.LastFaultSubmission = uint64(extra)
-	// t.Power (types.BigInt) (struct)
-
-	{
-
-		if err := t.Power.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-	}
-	// t.Active (bool) (bool)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajOther {
-		return fmt.Errorf("booleans must be major type 7")
-	}
-	switch extra {
-	case 20:
-		t.Active = false
-	case 21:
-		t.Active = true
-	default:
-		return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
-	}
-	// t.SlashedAt (uint64) (uint64)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.SlashedAt = uint64(extra)
-	// t.ElectionPeriodStart (uint64) (uint64)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.ElectionPeriodStart = uint64(extra)
-	return nil
-}
-
-func (t *StorageMinerConstructorParams) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{132}); err != nil {
-		return err
-	}
-
-	// t.Owner (address.Address) (struct)
-	if err := t.Owner.MarshalCBOR(w); err != nil {
-		return err
-	}
-
-	// t.Worker (address.Address) (struct)
-	if err := t.Worker.MarshalCBOR(w); err != nil {
-		return err
-	}
-
-	// t.SectorSize (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.SectorSize))); err != nil {
-		return err
-	}
-
-	// t.PeerID (peer.ID) (string)
-	if len(t.PeerID) > cbg.MaxLength {
-		return xerrors.Errorf("Value in field t.PeerID was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len(t.PeerID)))); err != nil {
-		return err
-	}
-	if _, err := w.Write([]byte(t.PeerID)); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *StorageMinerConstructorParams) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 4 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	// t.Owner (address.Address) (struct)
-
-	{
-
-		if err := t.Owner.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-	}
-	// t.Worker (address.Address) (struct)
-
-	{
-
-		if err := t.Worker.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-	}
-	// t.SectorSize (uint64) (uint64)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.SectorSize = uint64(extra)
-	// t.PeerID (peer.ID) (string)
-
-	{
-		sval, err := cbg.ReadString(br)
-		if err != nil {
-			return err
-		}
-
-		t.PeerID = peer.ID(sval)
-	}
-	return nil
-}
-
-func (t *SectorPreCommitInfo) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{132}); err != nil {
-		return err
-	}
-
-	// t.SectorNumber (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.SectorNumber))); err != nil {
-		return err
-	}
-
-	// t.CommR ([]uint8) (slice)
-	if len(t.CommR) > cbg.ByteArrayMaxLen {
-		return xerrors.Errorf("Byte array in field t.CommR was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajByteString, uint64(len(t.CommR)))); err != nil {
-		return err
-	}
-	if _, err := w.Write(t.CommR); err != nil {
-		return err
-	}
-
-	// t.SealEpoch (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.SealEpoch))); err != nil {
-		return err
-	}
-
-	// t.DealIDs ([]uint64) (slice)
-	if len(t.DealIDs) > cbg.MaxLength {
-		return xerrors.Errorf("Slice value in field t.DealIDs was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajArray, uint64(len(t.DealIDs)))); err != nil {
-		return err
-	}
-	for _, v := range t.DealIDs {
-		if err := cbg.CborWriteHeader(w, cbg.MajUnsignedInt, v); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func (t *SectorPreCommitInfo) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 4 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	// t.SectorNumber (uint64) (uint64)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.SectorNumber = uint64(extra)
-	// t.CommR ([]uint8) (slice)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-
-	if extra > cbg.ByteArrayMaxLen {
-		return fmt.Errorf("t.CommR: byte array too large (%d)", extra)
-	}
-	if maj != cbg.MajByteString {
-		return fmt.Errorf("expected byte array")
-	}
-	t.CommR = make([]byte, extra)
-	if _, err := io.ReadFull(br, t.CommR); err != nil {
-		return err
-	}
-	// t.SealEpoch (uint64) (uint64)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.SealEpoch = uint64(extra)
-	// t.DealIDs ([]uint64) (slice)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-
-	if extra > cbg.MaxLength {
-		return fmt.Errorf("t.DealIDs: array too large (%d)", extra)
-	}
-
-	if maj != cbg.MajArray {
-		return fmt.Errorf("expected cbor array")
-	}
-	if extra > 0 {
-		t.DealIDs = make([]uint64, extra)
-	}
-	for i := 0; i < int(extra); i++ {
-
-		maj, val, err := cbg.CborReadHeader(br)
-		if err != nil {
-			return xerrors.Errorf("failed to read uint64 for t.DealIDs slice: %w", err)
-		}
-
-		if maj != cbg.MajUnsignedInt {
-			return xerrors.Errorf("value read for array t.DealIDs was not a uint, instead got %d", maj)
-		}
-
-		t.DealIDs[i] = val
-	}
-
-	return nil
-}
-
-func (t *PreCommittedSector) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{130}); err != nil {
-		return err
-	}
-
-	// t.Info (actors.SectorPreCommitInfo) (struct)
-	if err := t.Info.MarshalCBOR(w); err != nil {
-		return err
-	}
-
-	// t.ReceivedEpoch (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.ReceivedEpoch))); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *PreCommittedSector) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 2 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	// t.Info (actors.SectorPreCommitInfo) (struct)
-
-	{
-
-		if err := t.Info.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-	}
-	// t.ReceivedEpoch (uint64) (uint64)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.ReceivedEpoch = uint64(extra)
-	return nil
-}
-
-func (t *MinerInfo) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{132}); err != nil {
-		return err
-	}
-
-	// t.Owner (address.Address) (struct)
-	if err := t.Owner.MarshalCBOR(w); err != nil {
-		return err
-	}
-
-	// t.Worker (address.Address) (struct)
-	if err := t.Worker.MarshalCBOR(w); err != nil {
-		return err
-	}
-
-	// t.PeerID (peer.ID) (string)
-	if len(t.PeerID) > cbg.MaxLength {
-		return xerrors.Errorf("Value in field t.PeerID was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len(t.PeerID)))); err != nil {
-		return err
-	}
-	if _, err := w.Write([]byte(t.PeerID)); err != nil {
-		return err
-	}
-
-	// t.SectorSize (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.SectorSize))); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *MinerInfo) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 4 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	// t.Owner (address.Address) (struct)
-
-	{
-
-		if err := t.Owner.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-	}
-	// t.Worker (address.Address) (struct)
-
-	{
-
-		if err := t.Worker.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-	}
-	// t.PeerID (peer.ID) (string)
-
-	{
-		sval, err := cbg.ReadString(br)
-		if err != nil {
-			return err
-		}
-
-		t.PeerID = peer.ID(sval)
-	}
-	// t.SectorSize (uint64) (uint64)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.SectorSize = uint64(extra)
-	return nil
-}
-
-func (t *SubmitFallbackPoStParams) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{130}); err != nil {
-		return err
-	}
-
-	// t.Proof ([]uint8) (slice)
-	if len(t.Proof) > cbg.ByteArrayMaxLen {
-		return xerrors.Errorf("Byte array in field t.Proof was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajByteString, uint64(len(t.Proof)))); err != nil {
-		return err
-	}
-	if _, err := w.Write(t.Proof); err != nil {
-		return err
-	}
-
-	// t.Candidates ([]types.EPostTicket) (slice)
-	if len(t.Candidates) > cbg.MaxLength {
-		return xerrors.Errorf("Slice value in field t.Candidates was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajArray, uint64(len(t.Candidates)))); err != nil {
-		return err
-	}
-	for _, v := range t.Candidates {
-		if err := v.MarshalCBOR(w); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func (t *SubmitFallbackPoStParams) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 2 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	// t.Proof ([]uint8) (slice)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-
-	if extra > cbg.ByteArrayMaxLen {
-		return fmt.Errorf("t.Proof: byte array too large (%d)", extra)
-	}
-	if maj != cbg.MajByteString {
-		return fmt.Errorf("expected byte array")
-	}
-	t.Proof = make([]byte, extra)
-	if _, err := io.ReadFull(br, t.Proof); err != nil {
-		return err
-	}
-	// t.Candidates ([]types.EPostTicket) (slice)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-
-	if extra > cbg.MaxLength {
-		return fmt.Errorf("t.Candidates: array too large (%d)", extra)
-	}
-
-	if maj != cbg.MajArray {
-		return fmt.Errorf("expected cbor array")
-	}
-	if extra > 0 {
-		t.Candidates = make([]types.EPostTicket, extra)
-	}
-	for i := 0; i < int(extra); i++ {
-
-		var v types.EPostTicket
-		if err := v.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-		t.Candidates[i] = v
-	}
-
-	return nil
-}
-
-func (t *PaymentVerifyParams) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{130}); err != nil {
-		return err
-	}
-
-	// t.Extra ([]uint8) (slice)
-	if len(t.Extra) > cbg.ByteArrayMaxLen {
-		return xerrors.Errorf("Byte array in field t.Extra was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajByteString, uint64(len(t.Extra)))); err != nil {
-		return err
-	}
-	if _, err := w.Write(t.Extra); err != nil {
-		return err
-	}
-
-	// t.Proof ([]uint8) (slice)
-	if len(t.Proof) > cbg.ByteArrayMaxLen {
-		return xerrors.Errorf("Byte array in field t.Proof was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajByteString, uint64(len(t.Proof)))); err != nil {
-		return err
-	}
-	if _, err := w.Write(t.Proof); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *PaymentVerifyParams) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 2 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	// t.Extra ([]uint8) (slice)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-
-	if extra > cbg.ByteArrayMaxLen {
-		return fmt.Errorf("t.Extra: byte array too large (%d)", extra)
-	}
-	if maj != cbg.MajByteString {
-		return fmt.Errorf("expected byte array")
-	}
-	t.Extra = make([]byte, extra)
-	if _, err := io.ReadFull(br, t.Extra); err != nil {
-		return err
-	}
-	// t.Proof ([]uint8) (slice)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-
-	if extra > cbg.ByteArrayMaxLen {
-		return fmt.Errorf("t.Proof: byte array too large (%d)", extra)
-	}
-	if maj != cbg.MajByteString {
-		return fmt.Errorf("expected byte array")
-	}
-	t.Proof = make([]byte, extra)
-	if _, err := io.ReadFull(br, t.Proof); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *UpdatePeerIDParams) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{129}); err != nil {
-		return err
-	}
-
-	// t.PeerID (peer.ID) (string)
-	if len(t.PeerID) > cbg.MaxLength {
-		return xerrors.Errorf("Value in field t.PeerID was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len(t.PeerID)))); err != nil {
-		return err
-	}
-	if _, err := w.Write([]byte(t.PeerID)); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *UpdatePeerIDParams) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 1 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	// t.PeerID (peer.ID) (string)
-
-	{
-		sval, err := cbg.ReadString(br)
-		if err != nil {
-			return err
-		}
-
-		t.PeerID = peer.ID(sval)
-	}
-	return nil
-}
-
-func (t *DeclareFaultsParams) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{129}); err != nil {
-		return err
-	}
-
-	// t.Faults (types.BitField) (struct)
-	if err := t.Faults.MarshalCBOR(w); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *DeclareFaultsParams) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 1 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	// t.Faults (types.BitField) (struct)
-
-	{
-
-		if err := t.Faults.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-	}
-	return nil
-}
-
-func (t *MultiSigActorState) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{135}); err != nil {
-		return err
-	}
-
-	// t.Signers ([]address.Address) (slice)
-	if len(t.Signers) > cbg.MaxLength {
-		return xerrors.Errorf("Slice value in field t.Signers was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajArray, uint64(len(t.Signers)))); err != nil {
-		return err
-	}
-	for _, v := range t.Signers {
-		if err := v.MarshalCBOR(w); err != nil {
-			return err
-		}
-	}
-
-	// t.Required (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.Required))); err != nil {
-		return err
-	}
-
-	// t.NextTxID (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.NextTxID))); err != nil {
-		return err
-	}
-
-	// t.InitialBalance (types.BigInt) (struct)
-	if err := t.InitialBalance.MarshalCBOR(w); err != nil {
-		return err
-	}
-
-	// t.StartingBlock (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.StartingBlock))); err != nil {
-		return err
-	}
-
-	// t.UnlockDuration (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.UnlockDuration))); err != nil {
-		return err
-	}
-
-	// t.Transactions ([]actors.MTransaction) (slice)
-	if len(t.Transactions) > cbg.MaxLength {
-		return xerrors.Errorf("Slice value in field t.Transactions was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajArray, uint64(len(t.Transactions)))); err != nil {
-		return err
-	}
-	for _, v := range t.Transactions {
-		if err := v.MarshalCBOR(w); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func (t *MultiSigActorState) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 7 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	// t.Signers ([]address.Address) (slice)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-
-	if extra > cbg.MaxLength {
-		return fmt.Errorf("t.Signers: array too large (%d)", extra)
-	}
-
-	if maj != cbg.MajArray {
-		return fmt.Errorf("expected cbor array")
-	}
-	if extra > 0 {
-		t.Signers = make([]address.Address, extra)
-	}
-	for i := 0; i < int(extra); i++ {
-
-		var v address.Address
-		if err := v.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-		t.Signers[i] = v
-	}
-
-	// t.Required (uint64) (uint64)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.Required = uint64(extra)
-	// t.NextTxID (uint64) (uint64)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.NextTxID = uint64(extra)
-	// t.InitialBalance (types.BigInt) (struct)
-
-	{
-
-		if err := t.InitialBalance.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-	}
-	// t.StartingBlock (uint64) (uint64)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.StartingBlock = uint64(extra)
-	// t.UnlockDuration (uint64) (uint64)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.UnlockDuration = uint64(extra)
-	// t.Transactions ([]actors.MTransaction) (slice)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-
-	if extra > cbg.MaxLength {
-		return fmt.Errorf("t.Transactions: array too large (%d)", extra)
-	}
-
-	if maj != cbg.MajArray {
-		return fmt.Errorf("expected cbor array")
-	}
-	if extra > 0 {
-		t.Transactions = make([]MTransaction, extra)
-	}
-	for i := 0; i < int(extra); i++ {
-
-		var v MTransaction
-		if err := v.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-		t.Transactions[i] = v
-	}
-
-	return nil
-}
-
-func (t *MultiSigConstructorParams) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{131}); err != nil {
-		return err
-	}
-
-	// t.Signers ([]address.Address) (slice)
-	if len(t.Signers) > cbg.MaxLength {
-		return xerrors.Errorf("Slice value in field t.Signers was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajArray, uint64(len(t.Signers)))); err != nil {
-		return err
-	}
-	for _, v := range t.Signers {
-		if err := v.MarshalCBOR(w); err != nil {
-			return err
-		}
-	}
-
-	// t.Required (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.Required))); err != nil {
-		return err
-	}
-
-	// t.UnlockDuration (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.UnlockDuration))); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *MultiSigConstructorParams) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 3 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	// t.Signers ([]address.Address) (slice)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-
-	if extra > cbg.MaxLength {
-		return fmt.Errorf("t.Signers: array too large (%d)", extra)
-	}
-
-	if maj != cbg.MajArray {
-		return fmt.Errorf("expected cbor array")
-	}
-	if extra > 0 {
-		t.Signers = make([]address.Address, extra)
-	}
-	for i := 0; i < int(extra); i++ {
-
-		var v address.Address
-		if err := v.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-		t.Signers[i] = v
-	}
-
-	// t.Required (uint64) (uint64)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.Required = uint64(extra)
-	// t.UnlockDuration (uint64) (uint64)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.UnlockDuration = uint64(extra)
-	return nil
-}
-
-func (t *MultiSigProposeParams) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{132}); err != nil {
-		return err
-	}
-
-	// t.To (address.Address) (struct)
-	if err := t.To.MarshalCBOR(w); err != nil {
-		return err
-	}
-
-	// t.Value (types.BigInt) (struct)
-	if err := t.Value.MarshalCBOR(w); err != nil {
-		return err
-	}
-
-	// t.Method (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.Method))); err != nil {
-		return err
-	}
-
-	// t.Params ([]uint8) (slice)
-	if len(t.Params) > cbg.ByteArrayMaxLen {
-		return xerrors.Errorf("Byte array in field t.Params was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajByteString, uint64(len(t.Params)))); err != nil {
-		return err
-	}
-	if _, err := w.Write(t.Params); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *MultiSigProposeParams) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 4 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	// t.To (address.Address) (struct)
-
-	{
-
-		if err := t.To.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-	}
-	// t.Value (types.BigInt) (struct)
-
-	{
-
-		if err := t.Value.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-	}
-	// t.Method (uint64) (uint64)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.Method = uint64(extra)
-	// t.Params ([]uint8) (slice)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-
-	if extra > cbg.ByteArrayMaxLen {
-		return fmt.Errorf("t.Params: byte array too large (%d)", extra)
-	}
-	if maj != cbg.MajByteString {
-		return fmt.Errorf("expected byte array")
-	}
-	t.Params = make([]byte, extra)
-	if _, err := io.ReadFull(br, t.Params); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *MultiSigTxID) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{129}); err != nil {
-		return err
-	}
-
-	// t.TxID (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.TxID))); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *MultiSigTxID) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 1 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	// t.TxID (uint64) (uint64)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.TxID = uint64(extra)
-	return nil
-}
-
-func (t *MultiSigSwapSignerParams) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{130}); err != nil {
-		return err
-	}
-
-	// t.From (address.Address) (struct)
-	if err := t.From.MarshalCBOR(w); err != nil {
-		return err
-	}
-
-	// t.To (address.Address) (struct)
-	if err := t.To.MarshalCBOR(w); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *MultiSigSwapSignerParams) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 2 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	// t.From (address.Address) (struct)
-
-	{
-
-		if err := t.From.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-	}
-	// t.To (address.Address) (struct)
-
-	{
-
-		if err := t.To.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-	}
-	return nil
-}
-
-func (t *MultiSigChangeReqParams) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{129}); err != nil {
-		return err
-	}
-
-	// t.Req (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.Req))); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *MultiSigChangeReqParams) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 1 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	// t.Req (uint64) (uint64)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.Req = uint64(extra)
-	return nil
-}
-
-func (t *MTransaction) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{138}); err != nil {
-		return err
-	}
-
-	// t.Created (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.Created))); err != nil {
-		return err
-	}
-
-	// t.TxID (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.TxID))); err != nil {
-		return err
-	}
-
-	// t.To (address.Address) (struct)
-	if err := t.To.MarshalCBOR(w); err != nil {
-		return err
-	}
-
-	// t.Value (types.BigInt) (struct)
-	if err := t.Value.MarshalCBOR(w); err != nil {
-		return err
-	}
-
-	// t.Method (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.Method))); err != nil {
-		return err
-	}
-
-	// t.Params ([]uint8) (slice)
-	if len(t.Params) > cbg.ByteArrayMaxLen {
-		return xerrors.Errorf("Byte array in field t.Params was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajByteString, uint64(len(t.Params)))); err != nil {
-		return err
-	}
-	if _, err := w.Write(t.Params); err != nil {
-		return err
-	}
-
-	// t.Approved ([]address.Address) (slice)
-	if len(t.Approved) > cbg.MaxLength {
-		return xerrors.Errorf("Slice value in field t.Approved was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajArray, uint64(len(t.Approved)))); err != nil {
-		return err
-	}
-	for _, v := range t.Approved {
-		if err := v.MarshalCBOR(w); err != nil {
-			return err
-		}
-	}
-
-	// t.Complete (bool) (bool)
-	if err := cbg.WriteBool(w, t.Complete); err != nil {
-		return err
-	}
-
-	// t.Canceled (bool) (bool)
-	if err := cbg.WriteBool(w, t.Canceled); err != nil {
-		return err
-	}
-
-	// t.RetCode (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.RetCode))); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *MTransaction) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 10 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	// t.Created (uint64) (uint64)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.Created = uint64(extra)
-	// t.TxID (uint64) (uint64)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.TxID = uint64(extra)
-	// t.To (address.Address) (struct)
-
-	{
-
-		if err := t.To.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-	}
-	// t.Value (types.BigInt) (struct)
-
-	{
-
-		if err := t.Value.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-	}
-	// t.Method (uint64) (uint64)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.Method = uint64(extra)
-	// t.Params ([]uint8) (slice)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-
-	if extra > cbg.ByteArrayMaxLen {
-		return fmt.Errorf("t.Params: byte array too large (%d)", extra)
-	}
-	if maj != cbg.MajByteString {
-		return fmt.Errorf("expected byte array")
-	}
-	t.Params = make([]byte, extra)
-	if _, err := io.ReadFull(br, t.Params); err != nil {
-		return err
-	}
-	// t.Approved ([]address.Address) (slice)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-
-	if extra > cbg.MaxLength {
-		return fmt.Errorf("t.Approved: array too large (%d)", extra)
-	}
-
-	if maj != cbg.MajArray {
-		return fmt.Errorf("expected cbor array")
-	}
-	if extra > 0 {
-		t.Approved = make([]address.Address, extra)
-	}
-	for i := 0; i < int(extra); i++ {
-
-		var v address.Address
-		if err := v.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-		t.Approved[i] = v
-	}
-
-	// t.Complete (bool) (bool)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajOther {
-		return fmt.Errorf("booleans must be major type 7")
-	}
-	switch extra {
-	case 20:
-		t.Complete = false
-	case 21:
-		t.Complete = true
-	default:
-		return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
-	}
-	// t.Canceled (bool) (bool)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajOther {
-		return fmt.Errorf("booleans must be major type 7")
-	}
-	switch extra {
-	case 20:
-		t.Canceled = false
-	case 21:
-		t.Canceled = true
-	default:
-		return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
-	}
-	// t.RetCode (uint64) (uint64)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.RetCode = uint64(extra)
-	return nil
-}
-
-func (t *MultiSigRemoveSignerParam) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{130}); err != nil {
-		return err
-	}
-
-	// t.Signer (address.Address) (struct)
-	if err := t.Signer.MarshalCBOR(w); err != nil {
-		return err
-	}
-
-	// t.Decrease (bool) (bool)
-	if err := cbg.WriteBool(w, t.Decrease); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *MultiSigRemoveSignerParam) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 2 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	// t.Signer (address.Address) (struct)
-
-	{
-
-		if err := t.Signer.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-	}
-	// t.Decrease (bool) (bool)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajOther {
-		return fmt.Errorf("booleans must be major type 7")
-	}
-	switch extra {
-	case 20:
-		t.Decrease = false
-	case 21:
-		t.Decrease = true
-	default:
-		return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
-	}
-	return nil
-}
-
-func (t *MultiSigAddSignerParam) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{130}); err != nil {
-		return err
-	}
-
-	// t.Signer (address.Address) (struct)
-	if err := t.Signer.MarshalCBOR(w); err != nil {
-		return err
-	}
-
-	// t.Increase (bool) (bool)
-	if err := cbg.WriteBool(w, t.Increase); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *MultiSigAddSignerParam) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 2 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	// t.Signer (address.Address) (struct)
-
-	{
-
-		if err := t.Signer.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-	}
-	// t.Increase (bool) (bool)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajOther {
-		return fmt.Errorf("booleans must be major type 7")
-	}
-	switch extra {
-	case 20:
-		t.Increase = false
-	case 21:
-		t.Increase = true
-	default:
-		return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
-	}
-	return nil
-}
-
-func (t *PaymentChannelActorState) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{134}); err != nil {
-		return err
-	}
-
-	// t.From (address.Address) (struct)
-	if err := t.From.MarshalCBOR(w); err != nil {
-		return err
-	}
-
-	// t.To (address.Address) (struct)
-	if err := t.To.MarshalCBOR(w); err != nil {
-		return err
-	}
-
-	// t.ToSend (types.BigInt) (struct)
-	if err := t.ToSend.MarshalCBOR(w); err != nil {
-		return err
-	}
-
-	// t.ClosingAt (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.ClosingAt))); err != nil {
-		return err
-	}
-
-	// t.MinCloseHeight (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.MinCloseHeight))); err != nil {
-		return err
-	}
-
-	// t.LaneStates (map[string]*actors.LaneState) (map)
-	{
-		if len(t.LaneStates) > 4096 {
-			return xerrors.Errorf("cannot marshal t.LaneStates map too large")
-		}
-
-		if err := cbg.CborWriteHeader(w, cbg.MajMap, uint64(len(t.LaneStates))); err != nil {
-			return err
-		}
-
-		keys := make([]string, 0, len(t.LaneStates))
-		for k := range t.LaneStates {
-			keys = append(keys, k)
-		}
-		sort.Strings(keys)
-		for _, k := range keys {
-			v := t.LaneStates[k]
-
-			if len(k) > cbg.MaxLength {
-				return xerrors.Errorf("Value in field k was too long")
-			}
-
-			if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len(k)))); err != nil {
-				return err
-			}
-			if _, err := w.Write([]byte(k)); err != nil {
-				return err
-			}
-
-			if err := v.MarshalCBOR(w); err != nil {
-				return err
-			}
-
-		}
-	}
-	return nil
-}
-
-func (t *PaymentChannelActorState) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 6 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	// t.From (address.Address) (struct)
-
-	{
-
-		if err := t.From.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-	}
-	// t.To (address.Address) (struct)
-
-	{
-
-		if err := t.To.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-	}
-	// t.ToSend (types.BigInt) (struct)
-
-	{
-
-		if err := t.ToSend.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-	}
-	// t.ClosingAt (uint64) (uint64)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.ClosingAt = uint64(extra)
-	// t.MinCloseHeight (uint64) (uint64)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.MinCloseHeight = uint64(extra)
-	// t.LaneStates (map[string]*actors.LaneState) (map)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajMap {
-		return fmt.Errorf("expected a map (major type 5)")
-	}
-	if extra > 4096 {
-		return fmt.Errorf("t.LaneStates: map too large")
-	}
-
-	t.LaneStates = make(map[string]*LaneState, extra)
-
-	for i, l := 0, int(extra); i < l; i++ {
-
-		var k string
-
-		{
-			sval, err := cbg.ReadString(br)
-			if err != nil {
-				return err
-			}
-
-			k = string(sval)
-		}
-
-		var v *LaneState
-
-		{
-
-			pb, err := br.PeekByte()
-			if err != nil {
-				return err
-			}
-			if pb == cbg.CborNull[0] {
-				var nbuf [1]byte
-				if _, err := br.Read(nbuf[:]); err != nil {
-					return err
-				}
-			} else {
-				v = new(LaneState)
-				if err := v.UnmarshalCBOR(br); err != nil {
-					return err
-				}
-			}
-
-		}
-
-		t.LaneStates[k] = v
-
-	}
-	return nil
-}
-
-func (t *PCAConstructorParams) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{129}); err != nil {
-		return err
-	}
-
-	// t.To (address.Address) (struct)
-	if err := t.To.MarshalCBOR(w); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *PCAConstructorParams) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 1 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	// t.To (address.Address) (struct)
-
-	{
-
-		if err := t.To.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-	}
-	return nil
-}
-
-func (t *LaneState) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{131}); err != nil {
-		return err
-	}
-
-	// t.Closed (bool) (bool)
-	if err := cbg.WriteBool(w, t.Closed); err != nil {
-		return err
-	}
-
-	// t.Redeemed (types.BigInt) (struct)
-	if err := t.Redeemed.MarshalCBOR(w); err != nil {
-		return err
-	}
-
-	// t.Nonce (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.Nonce))); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *LaneState) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 3 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	// t.Closed (bool) (bool)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajOther {
-		return fmt.Errorf("booleans must be major type 7")
-	}
-	switch extra {
-	case 20:
-		t.Closed = false
-	case 21:
-		t.Closed = true
-	default:
-		return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
-	}
-	// t.Redeemed (types.BigInt) (struct)
-
-	{
-
-		if err := t.Redeemed.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-	}
-	// t.Nonce (uint64) (uint64)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.Nonce = uint64(extra)
-	return nil
-}
-
-func (t *PCAUpdateChannelStateParams) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{131}); err != nil {
-		return err
-	}
-
-	// t.Sv (types.SignedVoucher) (struct)
-	if err := t.Sv.MarshalCBOR(w); err != nil {
-		return err
-	}
-
-	// t.Secret ([]uint8) (slice)
-	if len(t.Secret) > cbg.ByteArrayMaxLen {
-		return xerrors.Errorf("Byte array in field t.Secret was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajByteString, uint64(len(t.Secret)))); err != nil {
-		return err
-	}
-	if _, err := w.Write(t.Secret); err != nil {
-		return err
-	}
-
-	// t.Proof ([]uint8) (slice)
-	if len(t.Proof) > cbg.ByteArrayMaxLen {
-		return xerrors.Errorf("Byte array in field t.Proof was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajByteString, uint64(len(t.Proof)))); err != nil {
-		return err
-	}
-	if _, err := w.Write(t.Proof); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *PCAUpdateChannelStateParams) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 3 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	// t.Sv (types.SignedVoucher) (struct)
-
-	{
-
-		if err := t.Sv.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-	}
-	// t.Secret ([]uint8) (slice)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-
-	if extra > cbg.ByteArrayMaxLen {
-		return fmt.Errorf("t.Secret: byte array too large (%d)", extra)
-	}
-	if maj != cbg.MajByteString {
-		return fmt.Errorf("expected byte array")
-	}
-	t.Secret = make([]byte, extra)
-	if _, err := io.ReadFull(br, t.Secret); err != nil {
-		return err
-	}
-	// t.Proof ([]uint8) (slice)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-
-	if extra > cbg.ByteArrayMaxLen {
-		return fmt.Errorf("t.Proof: byte array too large (%d)", extra)
-	}
-	if maj != cbg.MajByteString {
-		return fmt.Errorf("expected byte array")
-	}
-	t.Proof = make([]byte, extra)
-	if _, err := io.ReadFull(br, t.Proof); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *PaymentInfo) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{132}); err != nil {
-		return err
-	}
-
-	// t.PayChActor (address.Address) (struct)
-	if err := t.PayChActor.MarshalCBOR(w); err != nil {
-		return err
-	}
-
-	// t.Payer (address.Address) (struct)
-	if err := t.Payer.MarshalCBOR(w); err != nil {
-		return err
-	}
-
-	// t.ChannelMessage (cid.Cid) (struct)
-
-	if t.ChannelMessage == nil {
-		if _, err := w.Write(cbg.CborNull); err != nil {
-			return err
-		}
-	} else {
-		if err := cbg.WriteCid(w, *t.ChannelMessage); err != nil {
-			return xerrors.Errorf("failed to write cid field t.ChannelMessage: %w", err)
-		}
-	}
-
-	// t.Vouchers ([]*types.SignedVoucher) (slice)
-	if len(t.Vouchers) > cbg.MaxLength {
-		return xerrors.Errorf("Slice value in field t.Vouchers was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajArray, uint64(len(t.Vouchers)))); err != nil {
-		return err
-	}
-	for _, v := range t.Vouchers {
-		if err := v.MarshalCBOR(w); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func (t *PaymentInfo) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 4 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	// t.PayChActor (address.Address) (struct)
-
-	{
-
-		if err := t.PayChActor.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-	}
-	// t.Payer (address.Address) (struct)
-
-	{
-
-		if err := t.Payer.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-	}
-	// t.ChannelMessage (cid.Cid) (struct)
-
-	{
-
-		pb, err := br.PeekByte()
-		if err != nil {
-			return err
-		}
-		if pb == cbg.CborNull[0] {
-			var nbuf [1]byte
-			if _, err := br.Read(nbuf[:]); err != nil {
-				return err
-			}
-		} else {
-
-			c, err := cbg.ReadCid(br)
-			if err != nil {
-				return xerrors.Errorf("failed to read cid field t.ChannelMessage: %w", err)
-			}
-
-			t.ChannelMessage = &c
-		}
-
-	}
-	// t.Vouchers ([]*types.SignedVoucher) (slice)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-
-	if extra > cbg.MaxLength {
-		return fmt.Errorf("t.Vouchers: array too large (%d)", extra)
-	}
-
-	if maj != cbg.MajArray {
-		return fmt.Errorf("expected cbor array")
-	}
-	if extra > 0 {
-		t.Vouchers = make([]*types.SignedVoucher, extra)
-	}
-	for i := 0; i < int(extra); i++ {
-
-		var v types.SignedVoucher
-		if err := v.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-		t.Vouchers[i] = &v
-	}
-
-	return nil
-}
-
-func (t *StoragePowerState) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{133}); err != nil {
-		return err
-	}
-
-	// t.Miners (cid.Cid) (struct)
-
-	if err := cbg.WriteCid(w, t.Miners); err != nil {
-		return xerrors.Errorf("failed to write cid field t.Miners: %w", err)
-	}
-
-	// t.ProvingBuckets (cid.Cid) (struct)
-
-	if err := cbg.WriteCid(w, t.ProvingBuckets); err != nil {
-		return xerrors.Errorf("failed to write cid field t.ProvingBuckets: %w", err)
-	}
-
-	// t.MinerCount (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.MinerCount))); err != nil {
-		return err
-	}
-
-	// t.LastMinerCheck (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.LastMinerCheck))); err != nil {
-		return err
-	}
-
-	// t.TotalStorage (types.BigInt) (struct)
-	if err := t.TotalStorage.MarshalCBOR(w); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *StoragePowerState) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 5 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	// t.Miners (cid.Cid) (struct)
-
-	{
-
-		c, err := cbg.ReadCid(br)
-		if err != nil {
-			return xerrors.Errorf("failed to read cid field t.Miners: %w", err)
-		}
-
-		t.Miners = c
-
-	}
-	// t.ProvingBuckets (cid.Cid) (struct)
-
-	{
-
-		c, err := cbg.ReadCid(br)
-		if err != nil {
-			return xerrors.Errorf("failed to read cid field t.ProvingBuckets: %w", err)
-		}
-
-		t.ProvingBuckets = c
-
-	}
-	// t.MinerCount (uint64) (uint64)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.MinerCount = uint64(extra)
-	// t.LastMinerCheck (uint64) (uint64)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.LastMinerCheck = uint64(extra)
-	// t.TotalStorage (types.BigInt) (struct)
-
-	{
-
-		if err := t.TotalStorage.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-	}
-	return nil
-}
-
-func (t *CreateStorageMinerParams) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{132}); err != nil {
-		return err
-	}
-
-	// t.Owner (address.Address) (struct)
-	if err := t.Owner.MarshalCBOR(w); err != nil {
-		return err
-	}
-
-	// t.Worker (address.Address) (struct)
-	if err := t.Worker.MarshalCBOR(w); err != nil {
-		return err
-	}
-
-	// t.SectorSize (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.SectorSize))); err != nil {
-		return err
-	}
-
-	// t.PeerID (peer.ID) (string)
-	if len(t.PeerID) > cbg.MaxLength {
-		return xerrors.Errorf("Value in field t.PeerID was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len(t.PeerID)))); err != nil {
-		return err
-	}
-	if _, err := w.Write([]byte(t.PeerID)); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *CreateStorageMinerParams) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 4 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	// t.Owner (address.Address) (struct)
-
-	{
-
-		if err := t.Owner.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-	}
-	// t.Worker (address.Address) (struct)
-
-	{
-
-		if err := t.Worker.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-	}
-	// t.SectorSize (uint64) (uint64)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.SectorSize = uint64(extra)
-	// t.PeerID (peer.ID) (string)
-
-	{
-		sval, err := cbg.ReadString(br)
-		if err != nil {
-			return err
-		}
-
-		t.PeerID = peer.ID(sval)
-	}
-	return nil
-}
-
-func (t *IsValidMinerParam) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{129}); err != nil {
-		return err
-	}
-
-	// t.Addr (address.Address) (struct)
-	if err := t.Addr.MarshalCBOR(w); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *IsValidMinerParam) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 1 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	// t.Addr (address.Address) (struct)
-
-	{
-
-		if err := t.Addr.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-	}
-	return nil
-}
-
-func (t *PowerLookupParams) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{129}); err != nil {
-		return err
-	}
-
-	// t.Miner (address.Address) (struct)
-	if err := t.Miner.MarshalCBOR(w); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *PowerLookupParams) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 1 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	// t.Miner (address.Address) (struct)
-
-	{
-
-		if err := t.Miner.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-	}
-	return nil
-}
-
-func (t *UpdateStorageParams) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{131}); err != nil {
-		return err
-	}
-
-	// t.Delta (types.BigInt) (struct)
-	if err := t.Delta.MarshalCBOR(w); err != nil {
-		return err
-	}
-
-	// t.NextSlashDeadline (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.NextSlashDeadline))); err != nil {
-		return err
-	}
-
-	// t.PreviousSlashDeadline (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.PreviousSlashDeadline))); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *UpdateStorageParams) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 3 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	// t.Delta (types.BigInt) (struct)
-
-	{
-
-		if err := t.Delta.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-	}
-	// t.NextSlashDeadline (uint64) (uint64)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.NextSlashDeadline = uint64(extra)
-	// t.PreviousSlashDeadline (uint64) (uint64)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.PreviousSlashDeadline = uint64(extra)
-	return nil
-}
-
-func (t *ArbitrateConsensusFaultParams) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{130}); err != nil {
-		return err
-	}
-
-	// t.Block1 (types.BlockHeader) (struct)
-	if err := t.Block1.MarshalCBOR(w); err != nil {
-		return err
-	}
-
-	// t.Block2 (types.BlockHeader) (struct)
-	if err := t.Block2.MarshalCBOR(w); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *ArbitrateConsensusFaultParams) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 2 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	// t.Block1 (types.BlockHeader) (struct)
-
-	{
-
-		pb, err := br.PeekByte()
-		if err != nil {
-			return err
-		}
-		if pb == cbg.CborNull[0] {
-			var nbuf [1]byte
-			if _, err := br.Read(nbuf[:]); err != nil {
-				return err
-			}
-		} else {
-			t.Block1 = new(types.BlockHeader)
-			if err := t.Block1.UnmarshalCBOR(br); err != nil {
-				return err
-			}
-		}
-
-	}
-	// t.Block2 (types.BlockHeader) (struct)
-
-	{
-
-		pb, err := br.PeekByte()
-		if err != nil {
-			return err
-		}
-		if pb == cbg.CborNull[0] {
-			var nbuf [1]byte
-			if _, err := br.Read(nbuf[:]); err != nil {
-				return err
-			}
-		} else {
-			t.Block2 = new(types.BlockHeader)
-			if err := t.Block2.UnmarshalCBOR(br); err != nil {
-				return err
-			}
-		}
-
-	}
-	return nil
-}
-
-func (t *PledgeCollateralParams) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{129}); err != nil {
-		return err
-	}
-
-	// t.Size (types.BigInt) (struct)
-	if err := t.Size.MarshalCBOR(w); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *PledgeCollateralParams) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 1 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	// t.Size (types.BigInt) (struct)
-
-	{
-
-		if err := t.Size.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-	}
-	return nil
-}
-
-func (t *MinerSlashConsensusFault) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{131}); err != nil {
-		return err
-	}
-
-	// t.Slasher (address.Address) (struct)
-	if err := t.Slasher.MarshalCBOR(w); err != nil {
-		return err
-	}
-
-	// t.AtHeight (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.AtHeight))); err != nil {
-		return err
-	}
-
-	// t.SlashedCollateral (types.BigInt) (struct)
-	if err := t.SlashedCollateral.MarshalCBOR(w); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *MinerSlashConsensusFault) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 3 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	// t.Slasher (address.Address) (struct)
-
-	{
-
-		if err := t.Slasher.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-	}
-	// t.AtHeight (uint64) (uint64)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.AtHeight = uint64(extra)
-	// t.SlashedCollateral (types.BigInt) (struct)
-
-	{
-
-		if err := t.SlashedCollateral.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-	}
-	return nil
-}
-
-func (t *StorageParticipantBalance) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{130}); err != nil {
-		return err
-	}
-
-	// t.Locked (types.BigInt) (struct)
-	if err := t.Locked.MarshalCBOR(w); err != nil {
-		return err
-	}
-
-	// t.Available (types.BigInt) (struct)
-	if err := t.Available.MarshalCBOR(w); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *StorageParticipantBalance) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 2 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	// t.Locked (types.BigInt) (struct)
-
-	{
-
-		if err := t.Locked.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-	}
-	// t.Available (types.BigInt) (struct)
-
-	{
-
-		if err := t.Available.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-	}
-	return nil
-}
-
-func (t *StorageMarketState) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{131}); err != nil {
-		return err
-	}
-
-	// t.Balances (cid.Cid) (struct)
-
-	if err := cbg.WriteCid(w, t.Balances); err != nil {
-		return xerrors.Errorf("failed to write cid field t.Balances: %w", err)
-	}
-
-	// t.Deals (cid.Cid) (struct)
-
-	if err := cbg.WriteCid(w, t.Deals); err != nil {
-		return xerrors.Errorf("failed to write cid field t.Deals: %w", err)
-	}
-
-	// t.NextDealID (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.NextDealID))); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *StorageMarketState) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 3 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	// t.Balances (cid.Cid) (struct)
-
-	{
-
-		c, err := cbg.ReadCid(br)
-		if err != nil {
-			return xerrors.Errorf("failed to read cid field t.Balances: %w", err)
-		}
-
-		t.Balances = c
-
-	}
-	// t.Deals (cid.Cid) (struct)
-
-	{
-
-		c, err := cbg.ReadCid(br)
-		if err != nil {
-			return xerrors.Errorf("failed to read cid field t.Deals: %w", err)
-		}
-
-		t.Deals = c
-
-	}
-	// t.NextDealID (uint64) (uint64)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.NextDealID = uint64(extra)
-	return nil
-}
-
-func (t *WithdrawBalanceParams) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{129}); err != nil {
-		return err
-	}
-
-	// t.Balance (types.BigInt) (struct)
-	if err := t.Balance.MarshalCBOR(w); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *WithdrawBalanceParams) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 1 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	// t.Balance (types.BigInt) (struct)
-
-	{
-
-		if err := t.Balance.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-	}
-	return nil
-}
-
-func (t *StorageDealProposal) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{137}); err != nil {
-		return err
-	}
-
-	// t.PieceRef ([]uint8) (slice)
-	if len(t.PieceRef) > cbg.ByteArrayMaxLen {
-		return xerrors.Errorf("Byte array in field t.PieceRef was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajByteString, uint64(len(t.PieceRef)))); err != nil {
-		return err
-	}
-	if _, err := w.Write(t.PieceRef); err != nil {
-		return err
-	}
-
-	// t.PieceSize (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.PieceSize))); err != nil {
-		return err
-	}
-
-	// t.Client (address.Address) (struct)
-	if err := t.Client.MarshalCBOR(w); err != nil {
-		return err
-	}
-
-	// t.Provider (address.Address) (struct)
-	if err := t.Provider.MarshalCBOR(w); err != nil {
-		return err
-	}
-
-	// t.ProposalExpiration (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.ProposalExpiration))); err != nil {
-		return err
-	}
-
-	// t.Duration (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.Duration))); err != nil {
-		return err
-	}
-
-	// t.StoragePricePerEpoch (types.BigInt) (struct)
-	if err := t.StoragePricePerEpoch.MarshalCBOR(w); err != nil {
-		return err
-	}
-
-	// t.StorageCollateral (types.BigInt) (struct)
-	if err := t.StorageCollateral.MarshalCBOR(w); err != nil {
-		return err
-	}
-
-	// t.ProposerSignature (types.Signature) (struct)
-	if err := t.ProposerSignature.MarshalCBOR(w); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *StorageDealProposal) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 9 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	// t.PieceRef ([]uint8) (slice)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-
-	if extra > cbg.ByteArrayMaxLen {
-		return fmt.Errorf("t.PieceRef: byte array too large (%d)", extra)
-	}
-	if maj != cbg.MajByteString {
-		return fmt.Errorf("expected byte array")
-	}
-	t.PieceRef = make([]byte, extra)
-	if _, err := io.ReadFull(br, t.PieceRef); err != nil {
-		return err
-	}
-	// t.PieceSize (uint64) (uint64)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.PieceSize = uint64(extra)
-	// t.Client (address.Address) (struct)
-
-	{
-
-		if err := t.Client.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-	}
-	// t.Provider (address.Address) (struct)
-
-	{
-
-		if err := t.Provider.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-	}
-	// t.ProposalExpiration (uint64) (uint64)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.ProposalExpiration = uint64(extra)
-	// t.Duration (uint64) (uint64)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.Duration = uint64(extra)
-	// t.StoragePricePerEpoch (types.BigInt) (struct)
-
-	{
-
-		if err := t.StoragePricePerEpoch.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-	}
-	// t.StorageCollateral (types.BigInt) (struct)
-
-	{
-
-		if err := t.StorageCollateral.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-	}
-	// t.ProposerSignature (types.Signature) (struct)
-
-	{
-
-		pb, err := br.PeekByte()
-		if err != nil {
-			return err
-		}
-		if pb == cbg.CborNull[0] {
-			var nbuf [1]byte
-			if _, err := br.Read(nbuf[:]); err != nil {
-				return err
-			}
-		} else {
-			t.ProposerSignature = new(types.Signature)
-			if err := t.ProposerSignature.UnmarshalCBOR(br); err != nil {
-				return err
-			}
-		}
-
-	}
-	return nil
-}
-
-func (t *PublishStorageDealsParams) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{129}); err != nil {
-		return err
-	}
-
-	// t.Deals ([]actors.StorageDealProposal) (slice)
-	if len(t.Deals) > cbg.MaxLength {
-		return xerrors.Errorf("Slice value in field t.Deals was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajArray, uint64(len(t.Deals)))); err != nil {
-		return err
-	}
-	for _, v := range t.Deals {
-		if err := v.MarshalCBOR(w); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func (t *PublishStorageDealsParams) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 1 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	// t.Deals ([]actors.StorageDealProposal) (slice)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-
-	if extra > cbg.MaxLength {
-		return fmt.Errorf("t.Deals: array too large (%d)", extra)
-	}
-
-	if maj != cbg.MajArray {
-		return fmt.Errorf("expected cbor array")
-	}
-	if extra > 0 {
-		t.Deals = make([]StorageDealProposal, extra)
-	}
-	for i := 0; i < int(extra); i++ {
-
-		var v StorageDealProposal
-		if err := v.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-		t.Deals[i] = v
-	}
-
-	return nil
-}
-
-func (t *PublishStorageDealResponse) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{129}); err != nil {
-		return err
-	}
-
-	// t.DealIDs ([]uint64) (slice)
-	if len(t.DealIDs) > cbg.MaxLength {
-		return xerrors.Errorf("Slice value in field t.DealIDs was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajArray, uint64(len(t.DealIDs)))); err != nil {
-		return err
-	}
-	for _, v := range t.DealIDs {
-		if err := cbg.CborWriteHeader(w, cbg.MajUnsignedInt, v); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func (t *PublishStorageDealResponse) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 1 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	// t.DealIDs ([]uint64) (slice)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-
-	if extra > cbg.MaxLength {
-		return fmt.Errorf("t.DealIDs: array too large (%d)", extra)
-	}
-
-	if maj != cbg.MajArray {
-		return fmt.Errorf("expected cbor array")
-	}
-	if extra > 0 {
-		t.DealIDs = make([]uint64, extra)
-	}
-	for i := 0; i < int(extra); i++ {
-
-		maj, val, err := cbg.CborReadHeader(br)
-		if err != nil {
-			return xerrors.Errorf("failed to read uint64 for t.DealIDs slice: %w", err)
-		}
-
-		if maj != cbg.MajUnsignedInt {
-			return xerrors.Errorf("value read for array t.DealIDs was not a uint, instead got %d", maj)
-		}
-
-		t.DealIDs[i] = val
-	}
-
-	return nil
-}
-
-func (t *ActivateStorageDealsParams) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{129}); err != nil {
-		return err
-	}
-
-	// t.Deals ([]uint64) (slice)
-	if len(t.Deals) > cbg.MaxLength {
-		return xerrors.Errorf("Slice value in field t.Deals was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajArray, uint64(len(t.Deals)))); err != nil {
-		return err
-	}
-	for _, v := range t.Deals {
-		if err := cbg.CborWriteHeader(w, cbg.MajUnsignedInt, v); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func (t *ActivateStorageDealsParams) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 1 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	// t.Deals ([]uint64) (slice)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-
-	if extra > cbg.MaxLength {
-		return fmt.Errorf("t.Deals: array too large (%d)", extra)
-	}
-
-	if maj != cbg.MajArray {
-		return fmt.Errorf("expected cbor array")
-	}
-	if extra > 0 {
-		t.Deals = make([]uint64, extra)
-	}
-	for i := 0; i < int(extra); i++ {
-
-		maj, val, err := cbg.CborReadHeader(br)
-		if err != nil {
-			return xerrors.Errorf("failed to read uint64 for t.Deals slice: %w", err)
-		}
-
-		if maj != cbg.MajUnsignedInt {
-			return xerrors.Errorf("value read for array t.Deals was not a uint, instead got %d", maj)
-		}
-
-		t.Deals[i] = val
-	}
-
-	return nil
-}
-
-func (t *ProcessStorageDealsPaymentParams) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{129}); err != nil {
-		return err
-	}
-
-	// t.DealIDs ([]uint64) (slice)
-	if len(t.DealIDs) > cbg.MaxLength {
-		return xerrors.Errorf("Slice value in field t.DealIDs was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajArray, uint64(len(t.DealIDs)))); err != nil {
-		return err
-	}
-	for _, v := range t.DealIDs {
-		if err := cbg.CborWriteHeader(w, cbg.MajUnsignedInt, v); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func (t *ProcessStorageDealsPaymentParams) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 1 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	// t.DealIDs ([]uint64) (slice)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-
-	if extra > cbg.MaxLength {
-		return fmt.Errorf("t.DealIDs: array too large (%d)", extra)
-	}
-
-	if maj != cbg.MajArray {
-		return fmt.Errorf("expected cbor array")
-	}
-	if extra > 0 {
-		t.DealIDs = make([]uint64, extra)
-	}
-	for i := 0; i < int(extra); i++ {
-
-		maj, val, err := cbg.CborReadHeader(br)
-		if err != nil {
-			return xerrors.Errorf("failed to read uint64 for t.DealIDs slice: %w", err)
-		}
-
-		if maj != cbg.MajUnsignedInt {
-			return xerrors.Errorf("value read for array t.DealIDs was not a uint, instead got %d", maj)
-		}
-
-		t.DealIDs[i] = val
-	}
-
-	return nil
-}
-
-func (t *OnChainDeal) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{137}); err != nil {
-		return err
-	}
-
-	// t.PieceRef ([]uint8) (slice)
-	if len(t.PieceRef) > cbg.ByteArrayMaxLen {
-		return xerrors.Errorf("Byte array in field t.PieceRef was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajByteString, uint64(len(t.PieceRef)))); err != nil {
-		return err
-	}
-	if _, err := w.Write(t.PieceRef); err != nil {
-		return err
-	}
-
-	// t.PieceSize (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.PieceSize))); err != nil {
-		return err
-	}
-
-	// t.Client (address.Address) (struct)
-	if err := t.Client.MarshalCBOR(w); err != nil {
-		return err
-	}
-
-	// t.Provider (address.Address) (struct)
-	if err := t.Provider.MarshalCBOR(w); err != nil {
-		return err
-	}
-
-	// t.ProposalExpiration (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.ProposalExpiration))); err != nil {
-		return err
-	}
-
-	// t.Duration (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.Duration))); err != nil {
-		return err
-	}
-
-	// t.StoragePricePerEpoch (types.BigInt) (struct)
-	if err := t.StoragePricePerEpoch.MarshalCBOR(w); err != nil {
-		return err
-	}
-
-	// t.StorageCollateral (types.BigInt) (struct)
-	if err := t.StorageCollateral.MarshalCBOR(w); err != nil {
-		return err
-	}
-
-	// t.ActivationEpoch (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.ActivationEpoch))); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *OnChainDeal) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 9 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	// t.PieceRef ([]uint8) (slice)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-
-	if extra > cbg.ByteArrayMaxLen {
-		return fmt.Errorf("t.PieceRef: byte array too large (%d)", extra)
-	}
-	if maj != cbg.MajByteString {
-		return fmt.Errorf("expected byte array")
-	}
-	t.PieceRef = make([]byte, extra)
-	if _, err := io.ReadFull(br, t.PieceRef); err != nil {
-		return err
-	}
-	// t.PieceSize (uint64) (uint64)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.PieceSize = uint64(extra)
-	// t.Client (address.Address) (struct)
-
-	{
-
-		if err := t.Client.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-	}
-	// t.Provider (address.Address) (struct)
-
-	{
-
-		if err := t.Provider.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-	}
-	// t.ProposalExpiration (uint64) (uint64)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.ProposalExpiration = uint64(extra)
-	// t.Duration (uint64) (uint64)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.Duration = uint64(extra)
-	// t.StoragePricePerEpoch (types.BigInt) (struct)
-
-	{
-
-		if err := t.StoragePricePerEpoch.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-	}
-	// t.StorageCollateral (types.BigInt) (struct)
-
-	{
-
-		if err := t.StorageCollateral.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-	}
-	// t.ActivationEpoch (uint64) (uint64)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.ActivationEpoch = uint64(extra)
-	return nil
-}
-
-func (t *ComputeDataCommitmentParams) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{130}); err != nil {
-		return err
-	}
-
-	// t.DealIDs ([]uint64) (slice)
-	if len(t.DealIDs) > cbg.MaxLength {
-		return xerrors.Errorf("Slice value in field t.DealIDs was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajArray, uint64(len(t.DealIDs)))); err != nil {
-		return err
-	}
-	for _, v := range t.DealIDs {
-		if err := cbg.CborWriteHeader(w, cbg.MajUnsignedInt, v); err != nil {
-			return err
-		}
-	}
-
-	// t.SectorSize (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.SectorSize))); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *ComputeDataCommitmentParams) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 2 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	// t.DealIDs ([]uint64) (slice)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-
-	if extra > cbg.MaxLength {
-		return fmt.Errorf("t.DealIDs: array too large (%d)", extra)
-	}
-
-	if maj != cbg.MajArray {
-		return fmt.Errorf("expected cbor array")
-	}
-	if extra > 0 {
-		t.DealIDs = make([]uint64, extra)
-	}
-	for i := 0; i < int(extra); i++ {
-
-		maj, val, err := cbg.CborReadHeader(br)
-		if err != nil {
-			return xerrors.Errorf("failed to read uint64 for t.DealIDs slice: %w", err)
-		}
-
-		if maj != cbg.MajUnsignedInt {
-			return xerrors.Errorf("value read for array t.DealIDs was not a uint, instead got %d", maj)
-		}
-
-		t.DealIDs[i] = val
-	}
-
-	// t.SectorSize (uint64) (uint64)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.SectorSize = uint64(extra)
-	return nil
-}
-
-func (t *SectorProveCommitInfo) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{131}); err != nil {
-		return err
-	}
-
-	// t.Proof ([]uint8) (slice)
-	if len(t.Proof) > cbg.ByteArrayMaxLen {
-		return xerrors.Errorf("Byte array in field t.Proof was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajByteString, uint64(len(t.Proof)))); err != nil {
-		return err
-	}
-	if _, err := w.Write(t.Proof); err != nil {
-		return err
-	}
-
-	// t.SectorID (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.SectorID))); err != nil {
-		return err
-	}
-
-	// t.DealIDs ([]uint64) (slice)
-	if len(t.DealIDs) > cbg.MaxLength {
-		return xerrors.Errorf("Slice value in field t.DealIDs was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajArray, uint64(len(t.DealIDs)))); err != nil {
-		return err
-	}
-	for _, v := range t.DealIDs {
-		if err := cbg.CborWriteHeader(w, cbg.MajUnsignedInt, v); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func (t *SectorProveCommitInfo) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 3 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	// t.Proof ([]uint8) (slice)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-
-	if extra > cbg.ByteArrayMaxLen {
-		return fmt.Errorf("t.Proof: byte array too large (%d)", extra)
-	}
-	if maj != cbg.MajByteString {
-		return fmt.Errorf("expected byte array")
-	}
-	t.Proof = make([]byte, extra)
-	if _, err := io.ReadFull(br, t.Proof); err != nil {
-		return err
-	}
-	// t.SectorID (uint64) (uint64)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.SectorID = uint64(extra)
-	// t.DealIDs ([]uint64) (slice)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-
-	if extra > cbg.MaxLength {
-		return fmt.Errorf("t.DealIDs: array too large (%d)", extra)
-	}
-
-	if maj != cbg.MajArray {
-		return fmt.Errorf("expected cbor array")
-	}
-	if extra > 0 {
-		t.DealIDs = make([]uint64, extra)
-	}
-	for i := 0; i < int(extra); i++ {
-
-		maj, val, err := cbg.CborReadHeader(br)
-		if err != nil {
-			return xerrors.Errorf("failed to read uint64 for t.DealIDs slice: %w", err)
-		}
-
-		if maj != cbg.MajUnsignedInt {
-			return xerrors.Errorf("value read for array t.DealIDs was not a uint, instead got %d", maj)
-		}
-
-		t.DealIDs[i] = val
-	}
-
-	return nil
-}
-
-func (t *CheckMinerParams) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{129}); err != nil {
-		return err
-	}
-
-	// t.NetworkPower (types.BigInt) (struct)
-	if err := t.NetworkPower.MarshalCBOR(w); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *CheckMinerParams) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 1 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	// t.NetworkPower (types.BigInt) (struct)
-
-	{
-
-		if err := t.NetworkPower.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-	}
-	return nil
-}
-
-func (t *CronActorState) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{128}); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *CronActorState) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 0 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	return nil
-}
diff --git a/chain/actors/error.go b/chain/actors/error.go
deleted file mode 100644
index a24f952da..000000000
--- a/chain/actors/error.go
+++ /dev/null
@@ -1,5 +0,0 @@
-package actors
-
-import "github.com/filecoin-project/lotus/chain/actors/aerrors"
-
-type ActorError = aerrors.ActorError
diff --git a/chain/actors/forks.go b/chain/actors/forks.go
deleted file mode 100644
index 46f8cafd8..000000000
--- a/chain/actors/forks.go
+++ /dev/null
@@ -1,46 +0,0 @@
-package actors
-
-import (
-	"reflect"
-	"sort"
-
-	"github.com/filecoin-project/lotus/chain/actors/aerrors"
-	"github.com/filecoin-project/lotus/chain/types"
-)
-
-type update struct {
-	start  uint64
-	method interface{}
-}
-
-func withUpdates(updates ...update) interface{} {
-	sort.Slice(updates, func(i, j int) bool { // so we iterate from newest below
-		return updates[i].start > updates[j].start
-	})
-
-	// <script type="application/javascript">
-
-	typ := reflect.TypeOf(updates[0].method)
-
-	out := reflect.MakeFunc(typ, func(args []reflect.Value) (results []reflect.Value) {
-		vmctx := args[1].Interface().(types.VMContext)
-
-		for _, u := range updates {
-			if vmctx.BlockHeight() >= u.start {
-				return reflect.ValueOf(u.method).Call(args)
-			}
-		}
-
-		return reflect.ValueOf(notFound(vmctx)).Call([]reflect.Value{})
-	})
-
-	return out.Interface()
-
-	// </script>
-}
-
-func notFound(vmctx types.VMContext) func() ([]byte, ActorError) {
-	return func() ([]byte, ActorError) {
-		return nil, aerrors.Fatal("no code for method %d at height %d", vmctx.Message().Method, vmctx.BlockHeight())
-	}
-}
diff --git a/chain/actors/harness2_test.go b/chain/actors/harness2_test.go
deleted file mode 100644
index d5d34795b..000000000
--- a/chain/actors/harness2_test.go
+++ /dev/null
@@ -1,337 +0,0 @@
-package actors_test
-
-import (
-	"bytes"
-	"context"
-	"math/rand"
-	"testing"
-
-	"github.com/ipfs/go-cid"
-	dstore "github.com/ipfs/go-datastore"
-	hamt "github.com/ipfs/go-hamt-ipld"
-	blockstore "github.com/ipfs/go-ipfs-blockstore"
-	bstore "github.com/ipfs/go-ipfs-blockstore"
-	cbg "github.com/whyrusleeping/cbor-gen"
-	"golang.org/x/xerrors"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/lotus/chain/actors"
-	"github.com/filecoin-project/lotus/chain/gen"
-	"github.com/filecoin-project/lotus/chain/state"
-	"github.com/filecoin-project/lotus/chain/store"
-	"github.com/filecoin-project/lotus/chain/types"
-	"github.com/filecoin-project/lotus/chain/vm"
-	"github.com/filecoin-project/lotus/chain/wallet"
-)
-
-const testGasLimit = 10000
-
-type HarnessInit struct {
-	NAddrs uint64
-	Addrs  map[address.Address]types.BigInt
-	Miner  address.Address
-}
-
-type HarnessStage int
-
-const (
-	HarnessPreInit HarnessStage = iota
-	HarnessPostInit
-)
-
-type HarnessOpt func(testing.TB, *Harness) error
-
-type Harness struct {
-	HI          HarnessInit
-	Stage       HarnessStage
-	Nonces      map[address.Address]uint64
-	GasCharges  map[address.Address]types.BigInt
-	Rand        vm.Rand
-	BlockHeight uint64
-
-	lastBalanceCheck map[address.Address]types.BigInt
-
-	ctx context.Context
-	bs  blockstore.Blockstore
-	vm  *vm.VM
-	cs  *store.ChainStore
-	w   *wallet.Wallet
-}
-
-var HarnessMinerFunds = types.NewInt(1000000)
-
-func HarnessAddr(addr *address.Address, value uint64) HarnessOpt {
-	return func(t testing.TB, h *Harness) error {
-		if h.Stage != HarnessPreInit {
-			return nil
-		}
-		hi := &h.HI
-		if addr.Empty() {
-			k, err := h.w.GenerateKey(types.KTSecp256k1)
-			if err != nil {
-				t.Fatal(err)
-			}
-
-			*addr = k
-		}
-		hi.Addrs[*addr] = types.NewInt(value)
-		return nil
-	}
-}
-
-func HarnessMiner(addr *address.Address) HarnessOpt {
-	return func(_ testing.TB, h *Harness) error {
-		if h.Stage != HarnessPreInit {
-			return nil
-		}
-		hi := &h.HI
-		if addr.Empty() {
-			*addr = hi.Miner
-			return nil
-		}
-		delete(hi.Addrs, hi.Miner)
-		hi.Miner = *addr
-		return nil
-	}
-}
-
-func HarnessActor(actor *address.Address, creator *address.Address, code cid.Cid, params func() cbg.CBORMarshaler) HarnessOpt {
-	return func(t testing.TB, h *Harness) error {
-		if h.Stage != HarnessPostInit {
-			return nil
-		}
-		if !actor.Empty() {
-			return xerrors.New("actor address should be empty")
-		}
-
-		ret, _ := h.CreateActor(t, *creator, code, params())
-		if ret.ExitCode != 0 {
-			return xerrors.Errorf("creating actor: %w", ret.ActorErr)
-		}
-		var err error
-		*actor, err = address.NewFromBytes(ret.Return)
-		return err
-	}
-
-}
-
-func HarnessCtx(ctx context.Context) HarnessOpt {
-	return func(t testing.TB, h *Harness) error {
-		h.ctx = ctx
-		return nil
-	}
-}
-
-func NewHarness(t *testing.T, options ...HarnessOpt) *Harness {
-	w, err := wallet.NewWallet(wallet.NewMemKeyStore())
-	if err != nil {
-		t.Fatal(err)
-	}
-	h := &Harness{
-		Stage:  HarnessPreInit,
-		Nonces: make(map[address.Address]uint64),
-		Rand:   &fakeRand{},
-		HI: HarnessInit{
-			NAddrs: 1,
-			Miner:  blsaddr(0),
-			Addrs: map[address.Address]types.BigInt{
-				blsaddr(0): HarnessMinerFunds,
-			},
-		},
-		GasCharges: make(map[address.Address]types.BigInt),
-
-		lastBalanceCheck: make(map[address.Address]types.BigInt),
-		w:                w,
-		ctx:              context.Background(),
-		bs:               bstore.NewBlockstore(dstore.NewMapDatastore()),
-		BlockHeight:      0,
-	}
-	for _, opt := range options {
-		err := opt(t, h)
-		if err != nil {
-			t.Fatalf("Applying options: %v", err)
-		}
-	}
-
-	st, err := gen.MakeInitialStateTree(h.bs, h.HI.Addrs)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	stateroot, err := st.Flush()
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	stateroot, err = gen.SetupStorageMarketActor(h.bs, stateroot, nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	h.cs = store.NewChainStore(h.bs, nil)
-	h.vm, err = vm.NewVM(stateroot, 1, h.Rand, h.HI.Miner, h.cs.Blockstore())
-	if err != nil {
-		t.Fatal(err)
-	}
-	h.Stage = HarnessPostInit
-	for _, opt := range options {
-		err := opt(t, h)
-		if err != nil {
-			t.Fatalf("Applying options: %v", err)
-		}
-	}
-
-	return h
-}
-
-func (h *Harness) Apply(t testing.TB, msg types.Message) (*vm.ApplyRet, *state.StateTree) {
-	t.Helper()
-	if msg.Nonce == 0 {
-		msg.Nonce, _ = h.Nonces[msg.From]
-		h.Nonces[msg.From] = msg.Nonce + 1
-	}
-
-	ret, err := h.vm.ApplyMessage(h.ctx, &msg)
-	if err != nil {
-		t.Fatalf("Applying message: %+v", err)
-	}
-
-	if ret != nil {
-		if prev, ok := h.GasCharges[msg.From]; ok {
-			h.GasCharges[msg.From] = types.BigAdd(prev, ret.GasUsed)
-		} else {
-			h.GasCharges[msg.From] = ret.GasUsed
-		}
-	}
-
-	stateroot, err := h.vm.Flush(context.TODO())
-	if err != nil {
-		t.Fatalf("Flushing VM: %+v", err)
-	}
-	cst := hamt.CSTFromBstore(h.bs)
-	state, err := state.LoadStateTree(cst, stateroot)
-	if err != nil {
-		t.Fatalf("Loading state tree: %+v", err)
-	}
-	return ret, state
-}
-
-func (h *Harness) CreateActor(t testing.TB, from address.Address,
-	code cid.Cid, params cbg.CBORMarshaler) (*vm.ApplyRet, *state.StateTree) {
-	t.Helper()
-
-	return h.Apply(t, types.Message{
-		To:     actors.InitAddress,
-		From:   from,
-		Method: actors.IAMethods.Exec,
-		Params: DumpObject(t,
-			&actors.ExecParams{
-				Code:   code,
-				Params: DumpObject(t, params),
-			}),
-		GasPrice: types.NewInt(1),
-		GasLimit: types.NewInt(testGasLimit),
-		Value:    types.NewInt(0),
-	})
-}
-
-func (h *Harness) SendFunds(t testing.TB, from address.Address, to address.Address,
-	value types.BigInt) (*vm.ApplyRet, *state.StateTree) {
-	t.Helper()
-	return h.Apply(t, types.Message{
-		To:       to,
-		From:     from,
-		Method:   0,
-		Value:    value,
-		GasPrice: types.NewInt(1),
-		GasLimit: types.NewInt(testGasLimit),
-	})
-}
-
-func (h *Harness) Invoke(t testing.TB, from address.Address, to address.Address,
-	method uint64, params cbg.CBORMarshaler) (*vm.ApplyRet, *state.StateTree) {
-	t.Helper()
-	return h.InvokeWithValue(t, from, to, method, types.NewInt(0), params)
-}
-
-func (h *Harness) InvokeWithValue(t testing.TB, from address.Address, to address.Address,
-	method uint64, value types.BigInt, params cbg.CBORMarshaler) (*vm.ApplyRet, *state.StateTree) {
-	t.Helper()
-	h.vm.SetBlockHeight(h.BlockHeight)
-	return h.Apply(t, types.Message{
-		To:       to,
-		From:     from,
-		Method:   method,
-		Value:    value,
-		Params:   DumpObject(t, params),
-		GasPrice: types.NewInt(1),
-		GasLimit: types.NewInt(testGasLimit),
-	})
-}
-
-func (h *Harness) AssertBalance(t testing.TB, addr address.Address, amt uint64) {
-	t.Helper()
-
-	b, err := h.vm.ActorBalance(addr)
-	if err != nil {
-		t.Fatalf("%+v", err)
-	}
-
-	if types.BigCmp(types.NewInt(amt), b) != 0 {
-		t.Errorf("expected %s to have balanced of %d. Instead has %s", addr, amt, b)
-	}
-}
-
-func (h *Harness) AssertBalanceChange(t testing.TB, addr address.Address, amt int64) {
-	t.Helper()
-	lastBalance, ok := h.lastBalanceCheck[addr]
-	if !ok {
-		lastBalance, ok = h.HI.Addrs[addr]
-		if !ok {
-			lastBalance = types.NewInt(0)
-		}
-	}
-
-	var expected types.BigInt
-
-	if amt >= 0 {
-		expected = types.BigAdd(lastBalance, types.NewInt(uint64(amt)))
-	} else {
-		expected = types.BigSub(lastBalance, types.NewInt(uint64(-amt)))
-	}
-
-	h.lastBalanceCheck[addr] = expected
-
-	if gasUsed, ok := h.GasCharges[addr]; ok {
-		expected = types.BigSub(expected, gasUsed)
-	}
-
-	b, err := h.vm.ActorBalance(addr)
-	if err != nil {
-		t.Fatalf("%+v", err)
-	}
-
-	if types.BigCmp(expected, b) != 0 {
-		t.Errorf("expected %s to have balanced of %d. Instead has %s", addr, amt, b)
-	}
-}
-
-func DumpObject(t testing.TB, obj cbg.CBORMarshaler) []byte {
-	if obj == nil {
-		return nil
-	}
-	t.Helper()
-	b := new(bytes.Buffer)
-	if err := obj.MarshalCBOR(b); err != nil {
-		t.Fatalf("dumping params: %+v", err)
-	}
-	return b.Bytes()
-}
-
-type fakeRand struct{}
-
-func (fr *fakeRand) GetRandomness(ctx context.Context, h int64) ([]byte, error) {
-	out := make([]byte, 32)
-	rand.New(rand.NewSource(h)).Read(out)
-	return out, nil
-}
diff --git a/chain/actors/params.go b/chain/actors/params.go
index c713167ce..e14dcafc9 100644
--- a/chain/actors/params.go
+++ b/chain/actors/params.go
@@ -7,10 +7,6 @@ import (
 	cbg "github.com/whyrusleeping/cbor-gen"
 )
 
-var (
-	EmptyStructCBOR = []byte{0xa0}
-)
-
 func SerializeParams(i cbg.CBORMarshaler) ([]byte, aerrors.ActorError) {
 	buf := new(bytes.Buffer)
 	if err := i.MarshalCBOR(buf); err != nil {
diff --git a/chain/actors/policy/policy.go b/chain/actors/policy/policy.go
new file mode 100644
index 000000000..b8205177e
--- /dev/null
+++ b/chain/actors/policy/policy.go
@@ -0,0 +1,54 @@
+package policy
+
+import (
+	"github.com/filecoin-project/go-state-types/abi"
+
+	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
+	power0 "github.com/filecoin-project/specs-actors/actors/builtin/power"
+	verifreg0 "github.com/filecoin-project/specs-actors/actors/builtin/verifreg"
+)
+
+// SetSupportedProofTypes sets supported proof types, across all actor versions.
+// This should only be used for testing.
+func SetSupportedProofTypes(types ...abi.RegisteredSealProof) {
+	newTypes := make(map[abi.RegisteredSealProof]struct{}, len(types))
+	for _, t := range types {
+		newTypes[t] = struct{}{}
+	}
+	// Set for all miner versions.
+	miner0.SupportedProofTypes = newTypes
+}
+
+// AddSupportedProofTypes sets supported proof types, across all actor versions.
+// This should only be used for testing.
+func AddSupportedProofTypes(types ...abi.RegisteredSealProof) {
+	for _, t := range types {
+		// Set for all miner versions.
+		miner0.SupportedProofTypes[t] = struct{}{}
+	}
+}
+
+// SetPreCommitChallengeDelay sets the pre-commit challenge delay across all
+// actors versions. Use for testing.
+func SetPreCommitChallengeDelay(delay abi.ChainEpoch) {
+	// Set for all miner versions.
+	miner0.PreCommitChallengeDelay = delay
+}
+
+// TODO: this function shouldn't really exist. Instead, the API should expose the precommit delay.
+func GetPreCommitChallengeDelay() abi.ChainEpoch {
+	return miner0.PreCommitChallengeDelay
+}
+
+// SetConsensusMinerMinPower sets the minimum power of an individual miner must
+// meet for leader election, across all actor versions. This should only be used
+// for testing.
+func SetConsensusMinerMinPower(p abi.StoragePower) {
+	power0.ConsensusMinerMinPower = p
+}
+
+// SetMinVerifiedDealSize sets the minimum size of a verified deal. This should
+// only be used for testing.
+func SetMinVerifiedDealSize(size abi.StoragePower) {
+	verifreg0.MinVerifiedDealSize = size
+}
diff --git a/chain/actors/policy/policy_test.go b/chain/actors/policy/policy_test.go
new file mode 100644
index 000000000..be64362a2
--- /dev/null
+++ b/chain/actors/policy/policy_test.go
@@ -0,0 +1,36 @@
+package policy
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/filecoin-project/go-state-types/abi"
+	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
+)
+
+func TestSupportedProofTypes(t *testing.T) {
+	var oldTypes []abi.RegisteredSealProof
+	for t := range miner0.SupportedProofTypes {
+		oldTypes = append(oldTypes, t)
+	}
+	t.Cleanup(func() {
+		SetSupportedProofTypes(oldTypes...)
+	})
+
+	SetSupportedProofTypes(abi.RegisteredSealProof_StackedDrg2KiBV1)
+	require.EqualValues(t,
+		miner0.SupportedProofTypes,
+		map[abi.RegisteredSealProof]struct{}{
+			abi.RegisteredSealProof_StackedDrg2KiBV1: {},
+		},
+	)
+	AddSupportedProofTypes(abi.RegisteredSealProof_StackedDrg8MiBV1)
+	require.EqualValues(t,
+		miner0.SupportedProofTypes,
+		map[abi.RegisteredSealProof]struct{}{
+			abi.RegisteredSealProof_StackedDrg2KiBV1: {},
+			abi.RegisteredSealProof_StackedDrg8MiBV1: {},
+		},
+	)
+}
diff --git a/chain/badtscache.go b/chain/badtscache.go
index 070375062..3c5bf05ef 100644
--- a/chain/badtscache.go
+++ b/chain/badtscache.go
@@ -1,6 +1,8 @@
 package chain
 
 import (
+	"fmt"
+
 	"github.com/filecoin-project/lotus/build"
 	lru "github.com/hashicorp/golang-lru"
 	"github.com/ipfs/go-cid"
@@ -10,6 +12,35 @@ type BadBlockCache struct {
 	badBlocks *lru.ARCCache
 }
 
+type BadBlockReason struct {
+	Reason         string
+	TipSet         []cid.Cid
+	OriginalReason *BadBlockReason
+}
+
+func NewBadBlockReason(cid []cid.Cid, format string, i ...interface{}) BadBlockReason {
+	return BadBlockReason{
+		TipSet: cid,
+		Reason: fmt.Sprintf(format, i...),
+	}
+}
+
+func (bbr BadBlockReason) Linked(reason string, i ...interface{}) BadBlockReason {
+	or := &bbr
+	if bbr.OriginalReason != nil {
+		or = bbr.OriginalReason
+	}
+	return BadBlockReason{Reason: fmt.Sprintf(reason, i...), OriginalReason: or}
+}
+
+func (bbr BadBlockReason) String() string {
+	res := bbr.Reason
+	if bbr.OriginalReason != nil {
+		res += " caused by: " + fmt.Sprintf("%s %s", bbr.OriginalReason.TipSet, bbr.OriginalReason.String())
+	}
+	return res
+}
+
 func NewBadBlockCache() *BadBlockCache {
 	cache, err := lru.NewARC(build.BadBlockCacheSize)
 	if err != nil {
@@ -21,10 +52,19 @@ func NewBadBlockCache() *BadBlockCache {
 	}
 }
 
-func (bts *BadBlockCache) Add(c cid.Cid) {
-	bts.badBlocks.Add(c, nil)
+func (bts *BadBlockCache) Add(c cid.Cid, bbr BadBlockReason) {
+	bts.badBlocks.Add(c, bbr)
 }
 
-func (bts *BadBlockCache) Has(c cid.Cid) bool {
-	return bts.badBlocks.Contains(c)
+func (bts *BadBlockCache) Remove(c cid.Cid) {
+	bts.badBlocks.Remove(c)
+}
+
+func (bts *BadBlockCache) Has(c cid.Cid) (BadBlockReason, bool) {
+	rval, ok := bts.badBlocks.Get(c)
+	if !ok {
+		return BadBlockReason{}, false
+	}
+
+	return rval.(BadBlockReason), true
 }
diff --git a/chain/beacon/beacon.go b/chain/beacon/beacon.go
new file mode 100644
index 000000000..9543bec54
--- /dev/null
+++ b/chain/beacon/beacon.go
@@ -0,0 +1,159 @@
+package beacon
+
+import (
+	"context"
+
+	"github.com/filecoin-project/go-state-types/abi"
+	logging "github.com/ipfs/go-log"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/types"
+)
+
+var log = logging.Logger("beacon")
+
+type Response struct {
+	Entry types.BeaconEntry
+	Err   error
+}
+
+type Schedule []BeaconPoint
+
+func (bs Schedule) BeaconForEpoch(e abi.ChainEpoch) RandomBeacon {
+	for i := len(bs) - 1; i >= 0; i-- {
+		bp := bs[i]
+		if e >= bp.Start {
+			return bp.Beacon
+		}
+	}
+	return bs[0].Beacon
+}
+
+type BeaconPoint struct {
+	Start  abi.ChainEpoch
+	Beacon RandomBeacon
+}
+
+// RandomBeacon represents a system that provides randomness to Lotus.
+// Other components interrogate the RandomBeacon to acquire randomness that's
+// valid for a specific chain epoch. Also to verify beacon entries that have
+// been posted on chain.
+type RandomBeacon interface {
+	Entry(context.Context, uint64) <-chan Response
+	VerifyEntry(types.BeaconEntry, types.BeaconEntry) error
+	MaxBeaconRoundForEpoch(abi.ChainEpoch) uint64
+}
+
+func ValidateBlockValues(bSchedule Schedule, h *types.BlockHeader, parentEpoch abi.ChainEpoch,
+	prevEntry types.BeaconEntry) error {
+	{
+		parentBeacon := bSchedule.BeaconForEpoch(parentEpoch)
+		currBeacon := bSchedule.BeaconForEpoch(h.Height)
+		if parentBeacon != currBeacon {
+			if len(h.BeaconEntries) != 2 {
+				return xerrors.Errorf("expected two beacon entries at beacon fork, got %d", len(h.BeaconEntries))
+			}
+			err := currBeacon.VerifyEntry(h.BeaconEntries[1], h.BeaconEntries[0])
+			if err != nil {
+				return xerrors.Errorf("beacon at fork point invalid: (%v, %v): %w",
+					h.BeaconEntries[1], h.BeaconEntries[0], err)
+			}
+			return nil
+		}
+	}
+
+	// TODO: fork logic
+	b := bSchedule.BeaconForEpoch(h.Height)
+	maxRound := b.MaxBeaconRoundForEpoch(h.Height)
+	if maxRound == prevEntry.Round {
+		if len(h.BeaconEntries) != 0 {
+			return xerrors.Errorf("expected not to have any beacon entries in this block, got %d", len(h.BeaconEntries))
+		}
+		return nil
+	}
+
+	if len(h.BeaconEntries) == 0 {
+		return xerrors.Errorf("expected to have beacon entries in this block, but didn't find any")
+	}
+
+	last := h.BeaconEntries[len(h.BeaconEntries)-1]
+	if last.Round != maxRound {
+		return xerrors.Errorf("expected final beacon entry in block to be at round %d, got %d", maxRound, last.Round)
+	}
+
+	for i, e := range h.BeaconEntries {
+		if err := b.VerifyEntry(e, prevEntry); err != nil {
+			return xerrors.Errorf("beacon entry %d (%d - %x (%d)) was invalid: %w", i, e.Round, e.Data, len(e.Data), err)
+		}
+		prevEntry = e
+	}
+
+	return nil
+}
+
+func BeaconEntriesForBlock(ctx context.Context, bSchedule Schedule, epoch abi.ChainEpoch, parentEpoch abi.ChainEpoch, prev types.BeaconEntry) ([]types.BeaconEntry, error) {
+	{
+		parentBeacon := bSchedule.BeaconForEpoch(parentEpoch)
+		currBeacon := bSchedule.BeaconForEpoch(epoch)
+		if parentBeacon != currBeacon {
+			// Fork logic
+			round := currBeacon.MaxBeaconRoundForEpoch(epoch)
+			out := make([]types.BeaconEntry, 2)
+			rch := currBeacon.Entry(ctx, round-1)
+			res := <-rch
+			if res.Err != nil {
+				return nil, xerrors.Errorf("getting entry %d returned error: %w", round-1, res.Err)
+			}
+			out[0] = res.Entry
+			rch = currBeacon.Entry(ctx, round)
+			res = <-rch
+			if res.Err != nil {
+				return nil, xerrors.Errorf("getting entry %d returned error: %w", round, res.Err)
+			}
+			out[1] = res.Entry
+			return out, nil
+		}
+	}
+
+	beacon := bSchedule.BeaconForEpoch(epoch)
+
+	start := build.Clock.Now()
+
+	maxRound := beacon.MaxBeaconRoundForEpoch(epoch)
+	if maxRound == prev.Round {
+		return nil, nil
+	}
+
+	// TODO: this is a sketchy way to handle the genesis block not having a beacon entry
+	if prev.Round == 0 {
+		prev.Round = maxRound - 1
+	}
+
+	cur := maxRound
+	var out []types.BeaconEntry
+	for cur > prev.Round {
+		rch := beacon.Entry(ctx, cur)
+		select {
+		case resp := <-rch:
+			if resp.Err != nil {
+				return nil, xerrors.Errorf("beacon entry request returned error: %w", resp.Err)
+			}
+
+			out = append(out, resp.Entry)
+			cur = resp.Entry.Round - 1
+		case <-ctx.Done():
+			return nil, xerrors.Errorf("context timed out waiting on beacon entry to come back for epoch %d: %w", epoch, ctx.Err())
+		}
+	}
+
+	log.Debugw("fetching beacon entries", "took", build.Clock.Since(start), "numEntries", len(out))
+	reverse(out)
+	return out, nil
+}
+
+func reverse(arr []types.BeaconEntry) {
+	for i := 0; i < len(arr)/2; i++ {
+		arr[i], arr[len(arr)-(1+i)] = arr[len(arr)-(1+i)], arr[i]
+	}
+}
diff --git a/chain/beacon/drand/drand.go b/chain/beacon/drand/drand.go
new file mode 100644
index 000000000..6e8e83a20
--- /dev/null
+++ b/chain/beacon/drand/drand.go
@@ -0,0 +1,197 @@
+package drand
+
+import (
+	"bytes"
+	"context"
+	"sync"
+	"time"
+
+	dchain "github.com/drand/drand/chain"
+	dclient "github.com/drand/drand/client"
+	hclient "github.com/drand/drand/client/http"
+	dlog "github.com/drand/drand/log"
+	gclient "github.com/drand/drand/lp2p/client"
+	"github.com/drand/kyber"
+	kzap "github.com/go-kit/kit/log/zap"
+	"go.uber.org/zap/zapcore"
+	"golang.org/x/xerrors"
+
+	logging "github.com/ipfs/go-log"
+	pubsub "github.com/libp2p/go-libp2p-pubsub"
+
+	"github.com/filecoin-project/go-state-types/abi"
+
+	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/beacon"
+	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/node/modules/dtypes"
+)
+
+var log = logging.Logger("drand")
+
+type drandPeer struct {
+	addr string
+	tls  bool
+}
+
+func (dp *drandPeer) Address() string {
+	return dp.addr
+}
+
+func (dp *drandPeer) IsTLS() bool {
+	return dp.tls
+}
+
+// DrandBeacon connects Lotus with a drand network in order to provide
+// randomness to the system in a way that's aligned with Filecoin rounds/epochs.
+//
+// We connect to drand peers via their public HTTP endpoints. The peers are
+// enumerated in the drandServers variable.
+//
+// The root trust for the Drand chain is configured from build.DrandChain.
+type DrandBeacon struct {
+	client dclient.Client
+
+	pubkey kyber.Point
+
+	// seconds
+	interval time.Duration
+
+	drandGenTime uint64
+	filGenTime   uint64
+	filRoundTime uint64
+
+	cacheLk    sync.Mutex
+	localCache map[uint64]types.BeaconEntry
+}
+
+func NewDrandBeacon(genesisTs, interval uint64, ps *pubsub.PubSub, config dtypes.DrandConfig) (*DrandBeacon, error) {
+	if genesisTs == 0 {
+		panic("what are you doing this cant be zero")
+	}
+
+	drandChain, err := dchain.InfoFromJSON(bytes.NewReader([]byte(config.ChainInfoJSON)))
+	if err != nil {
+		return nil, xerrors.Errorf("unable to unmarshal drand chain info: %w", err)
+	}
+
+	dlogger := dlog.NewKitLoggerFrom(kzap.NewZapSugarLogger(
+		log.SugaredLogger.Desugar(), zapcore.InfoLevel))
+
+	var clients []dclient.Client
+	for _, url := range config.Servers {
+		hc, err := hclient.NewWithInfo(url, drandChain, nil)
+		if err != nil {
+			return nil, xerrors.Errorf("could not create http drand client: %w", err)
+		}
+		clients = append(clients, hc)
+
+	}
+
+	opts := []dclient.Option{
+		dclient.WithChainInfo(drandChain),
+		dclient.WithCacheSize(1024),
+		dclient.WithLogger(dlogger),
+		dclient.WithAutoWatch(),
+	}
+
+	if ps != nil {
+		opts = append(opts, gclient.WithPubsub(ps))
+	} else {
+		log.Info("drand beacon without pubsub")
+	}
+
+	client, err := dclient.Wrap(clients, opts...)
+	if err != nil {
+		return nil, xerrors.Errorf("creating drand client")
+	}
+
+	db := &DrandBeacon{
+		client:     client,
+		localCache: make(map[uint64]types.BeaconEntry),
+	}
+
+	db.pubkey = drandChain.PublicKey
+	db.interval = drandChain.Period
+	db.drandGenTime = uint64(drandChain.GenesisTime)
+	db.filRoundTime = interval
+	db.filGenTime = genesisTs
+
+	return db, nil
+}
+
+func (db *DrandBeacon) Entry(ctx context.Context, round uint64) <-chan beacon.Response {
+	out := make(chan beacon.Response, 1)
+	if round != 0 {
+		be := db.getCachedValue(round)
+		if be != nil {
+			out <- beacon.Response{Entry: *be}
+			close(out)
+			return out
+		}
+	}
+
+	go func() {
+		start := build.Clock.Now()
+		log.Infow("start fetching randomness", "round", round)
+		resp, err := db.client.Get(ctx, round)
+
+		var br beacon.Response
+		if err != nil {
+			br.Err = xerrors.Errorf("drand failed Get request: %w", err)
+		} else {
+			br.Entry.Round = resp.Round()
+			br.Entry.Data = resp.Signature()
+		}
+		log.Infow("done fetching randomness", "round", round, "took", build.Clock.Since(start))
+		out <- br
+		close(out)
+	}()
+
+	return out
+}
+func (db *DrandBeacon) cacheValue(e types.BeaconEntry) {
+	db.cacheLk.Lock()
+	defer db.cacheLk.Unlock()
+	db.localCache[e.Round] = e
+}
+
+func (db *DrandBeacon) getCachedValue(round uint64) *types.BeaconEntry {
+	db.cacheLk.Lock()
+	defer db.cacheLk.Unlock()
+	v, ok := db.localCache[round]
+	if !ok {
+		return nil
+	}
+	return &v
+}
+
+func (db *DrandBeacon) VerifyEntry(curr types.BeaconEntry, prev types.BeaconEntry) error {
+	if prev.Round == 0 {
+		// TODO handle genesis better
+		return nil
+	}
+	if be := db.getCachedValue(curr.Round); be != nil {
+		// return no error if the value is in the cache already
+		return nil
+	}
+	b := &dchain.Beacon{
+		PreviousSig: prev.Data,
+		Round:       curr.Round,
+		Signature:   curr.Data,
+	}
+	err := dchain.VerifyBeacon(db.pubkey, b)
+	if err == nil {
+		db.cacheValue(curr)
+	}
+	return err
+}
+
+func (db *DrandBeacon) MaxBeaconRoundForEpoch(filEpoch abi.ChainEpoch) uint64 {
+	// TODO: sometimes the genesis time for filecoin is zero and this goes negative
+	latestTs := ((uint64(filEpoch) * db.filRoundTime) + db.filGenTime) - db.filRoundTime
+	dround := (latestTs - db.drandGenTime) / uint64(db.interval.Seconds())
+	return dround
+}
+
+var _ beacon.RandomBeacon = (*DrandBeacon)(nil)
diff --git a/chain/beacon/drand/drand_test.go b/chain/beacon/drand/drand_test.go
new file mode 100644
index 000000000..0cb9c2ba8
--- /dev/null
+++ b/chain/beacon/drand/drand_test.go
@@ -0,0 +1,25 @@
+package drand
+
+import (
+	"os"
+	"testing"
+
+	dchain "github.com/drand/drand/chain"
+	hclient "github.com/drand/drand/client/http"
+	"github.com/stretchr/testify/assert"
+
+	"github.com/filecoin-project/lotus/build"
+)
+
+func TestPrintGroupInfo(t *testing.T) {
+	server := build.DrandConfigs[build.DrandIncentinet].Servers[0]
+	c, err := hclient.New(server, nil, nil)
+	assert.NoError(t, err)
+	cg := c.(interface {
+		FetchChainInfo(groupHash []byte) (*dchain.Info, error)
+	})
+	chain, err := cg.FetchChainInfo(nil)
+	assert.NoError(t, err)
+	err = chain.ToJSON(os.Stdout)
+	assert.NoError(t, err)
+}
diff --git a/chain/beacon/mock.go b/chain/beacon/mock.go
new file mode 100644
index 000000000..502ff2ba5
--- /dev/null
+++ b/chain/beacon/mock.go
@@ -0,0 +1,60 @@
+package beacon
+
+import (
+	"bytes"
+	"context"
+	"encoding/binary"
+	"time"
+
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/minio/blake2b-simd"
+	"golang.org/x/xerrors"
+)
+
+// Mock beacon assumes that filecoin rounds are 1:1 mapped with the beacon rounds
+type mockBeacon struct {
+	interval time.Duration
+}
+
+func NewMockBeacon(interval time.Duration) RandomBeacon {
+	mb := &mockBeacon{interval: interval}
+
+	return mb
+}
+
+func (mb *mockBeacon) RoundTime() time.Duration {
+	return mb.interval
+}
+
+func (mb *mockBeacon) entryForIndex(index uint64) types.BeaconEntry {
+	buf := make([]byte, 8)
+	binary.BigEndian.PutUint64(buf, index)
+	rval := blake2b.Sum256(buf)
+	return types.BeaconEntry{
+		Round: index,
+		Data:  rval[:],
+	}
+}
+
+func (mb *mockBeacon) Entry(ctx context.Context, index uint64) <-chan Response {
+	e := mb.entryForIndex(index)
+	out := make(chan Response, 1)
+	out <- Response{Entry: e}
+	return out
+}
+
+func (mb *mockBeacon) VerifyEntry(from types.BeaconEntry, to types.BeaconEntry) error {
+	// TODO: cache this, especially for bls
+	oe := mb.entryForIndex(from.Round)
+	if !bytes.Equal(from.Data, oe.Data) {
+		return xerrors.Errorf("mock beacon entry was invalid!")
+	}
+	return nil
+}
+
+func (mb *mockBeacon) MaxBeaconRoundForEpoch(epoch abi.ChainEpoch) uint64 {
+	return uint64(epoch)
+}
+
+var _ RandomBeacon = (*mockBeacon)(nil)
diff --git a/chain/block_receipt_tracker.go b/chain/block_receipt_tracker.go
index f182fd180..a4a6743d1 100644
--- a/chain/block_receipt_tracker.go
+++ b/chain/block_receipt_tracker.go
@@ -5,9 +5,10 @@ import (
 	"sync"
 	"time"
 
+	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain/types"
-	"github.com/hashicorp/golang-lru"
-	peer "github.com/libp2p/go-libp2p-core/peer"
+	lru "github.com/hashicorp/golang-lru"
+	"github.com/libp2p/go-libp2p-core/peer"
 )
 
 type blockReceiptTracker struct {
@@ -37,14 +38,14 @@ func (brt *blockReceiptTracker) Add(p peer.ID, ts *types.TipSet) {
 	if !ok {
 		pset := &peerSet{
 			peers: map[peer.ID]time.Time{
-				p: time.Now(),
+				p: build.Clock.Now(),
 			},
 		}
 		brt.cache.Add(ts.Key(), pset)
 		return
 	}
 
-	val.(*peerSet).peers[p] = time.Now()
+	val.(*peerSet).peers[p] = build.Clock.Now()
 }
 
 func (brt *blockReceiptTracker) GetPeers(ts *types.TipSet) []peer.ID {
diff --git a/chain/blocksync/blocksync.go b/chain/blocksync/blocksync.go
deleted file mode 100644
index 429ad2ce1..000000000
--- a/chain/blocksync/blocksync.go
+++ /dev/null
@@ -1,238 +0,0 @@
-package blocksync
-
-import (
-	"bufio"
-	"context"
-
-	"github.com/libp2p/go-libp2p-core/protocol"
-	"go.opencensus.io/trace"
-	"golang.org/x/xerrors"
-
-	"github.com/filecoin-project/go-cbor-util"
-	"github.com/filecoin-project/lotus/chain/store"
-	"github.com/filecoin-project/lotus/chain/types"
-
-	"github.com/ipfs/go-cid"
-	cbor "github.com/ipfs/go-ipld-cbor"
-	logging "github.com/ipfs/go-log"
-	inet "github.com/libp2p/go-libp2p-core/network"
-	"github.com/libp2p/go-libp2p-core/peer"
-)
-
-var log = logging.Logger("blocksync")
-
-type NewStreamFunc func(context.Context, peer.ID, ...protocol.ID) (inet.Stream, error)
-
-const BlockSyncProtocolID = "/fil/sync/blk/0.0.1"
-
-func init() {
-	cbor.RegisterCborType(BlockSyncRequest{})
-	cbor.RegisterCborType(BlockSyncResponse{})
-	cbor.RegisterCborType(BSTipSet{})
-}
-
-type BlockSyncService struct {
-	cs *store.ChainStore
-}
-
-type BlockSyncRequest struct {
-	Start         []cid.Cid
-	RequestLength uint64
-
-	Options uint64
-}
-
-type BSOptions struct {
-	IncludeBlocks   bool
-	IncludeMessages bool
-}
-
-func ParseBSOptions(optfield uint64) *BSOptions {
-	return &BSOptions{
-		IncludeBlocks:   optfield&(BSOptBlocks) != 0,
-		IncludeMessages: optfield&(BSOptMessages) != 0,
-	}
-}
-
-const (
-	BSOptBlocks   = 1 << 0
-	BSOptMessages = 1 << 1
-)
-
-type BlockSyncResponse struct {
-	Chain []*BSTipSet
-
-	Status  uint64
-	Message string
-}
-
-type BSTipSet struct {
-	Blocks []*types.BlockHeader
-
-	BlsMessages    []*types.Message
-	BlsMsgIncludes [][]uint64
-
-	SecpkMessages    []*types.SignedMessage
-	SecpkMsgIncludes [][]uint64
-}
-
-func NewBlockSyncService(cs *store.ChainStore) *BlockSyncService {
-	return &BlockSyncService{
-		cs: cs,
-	}
-}
-
-func (bss *BlockSyncService) HandleStream(s inet.Stream) {
-	ctx, span := trace.StartSpan(context.Background(), "blocksync.HandleStream")
-	defer span.End()
-
-	defer s.Close()
-
-	var req BlockSyncRequest
-	if err := cborutil.ReadCborRPC(bufio.NewReader(s), &req); err != nil {
-		log.Warnf("failed to read block sync request: %s", err)
-		return
-	}
-	log.Infof("block sync request for: %s %d", req.Start, req.RequestLength)
-
-	resp, err := bss.processRequest(ctx, &req)
-	if err != nil {
-		log.Warn("failed to process block sync request: ", err)
-		return
-	}
-
-	if err := cborutil.WriteCborRPC(s, resp); err != nil {
-		log.Warn("failed to write back response for handle stream: ", err)
-		return
-	}
-}
-
-func (bss *BlockSyncService) processRequest(ctx context.Context, req *BlockSyncRequest) (*BlockSyncResponse, error) {
-	_, span := trace.StartSpan(ctx, "blocksync.ProcessRequest")
-	defer span.End()
-
-	opts := ParseBSOptions(req.Options)
-	if len(req.Start) == 0 {
-		return &BlockSyncResponse{
-			Status:  204,
-			Message: "no cids given in blocksync request",
-		}, nil
-	}
-
-	span.AddAttributes(
-		trace.BoolAttribute("blocks", opts.IncludeBlocks),
-		trace.BoolAttribute("messages", opts.IncludeMessages),
-	)
-
-	chain, err := bss.collectChainSegment(types.NewTipSetKey(req.Start...), req.RequestLength, opts)
-	if err != nil {
-		log.Warn("encountered error while responding to block sync request: ", err)
-		return &BlockSyncResponse{
-			Status:  203,
-			Message: err.Error(),
-		}, nil
-	}
-
-	return &BlockSyncResponse{
-		Chain:  chain,
-		Status: 0,
-	}, nil
-}
-
-func (bss *BlockSyncService) collectChainSegment(start types.TipSetKey, length uint64, opts *BSOptions) ([]*BSTipSet, error) {
-	var bstips []*BSTipSet
-	cur := start
-	for {
-		var bst BSTipSet
-		ts, err := bss.cs.LoadTipSet(cur)
-		if err != nil {
-			return nil, xerrors.Errorf("failed loading tipset %s: %w", cur, err)
-		}
-
-		if opts.IncludeMessages {
-			bmsgs, bmincl, smsgs, smincl, err := bss.gatherMessages(ts)
-			if err != nil {
-				return nil, xerrors.Errorf("gather messages failed: %w", err)
-			}
-
-			bst.BlsMessages = bmsgs
-			bst.BlsMsgIncludes = bmincl
-			bst.SecpkMessages = smsgs
-			bst.SecpkMsgIncludes = smincl
-		}
-
-		if opts.IncludeBlocks {
-			bst.Blocks = ts.Blocks()
-		}
-
-		bstips = append(bstips, &bst)
-
-		if uint64(len(bstips)) >= length || ts.Height() == 0 {
-			return bstips, nil
-		}
-
-		cur = ts.Parents()
-	}
-}
-
-func (bss *BlockSyncService) gatherMessages(ts *types.TipSet) ([]*types.Message, [][]uint64, []*types.SignedMessage, [][]uint64, error) {
-	blsmsgmap := make(map[cid.Cid]uint64)
-	secpkmsgmap := make(map[cid.Cid]uint64)
-	var secpkmsgs []*types.SignedMessage
-	var blsmsgs []*types.Message
-	var secpkincl, blsincl [][]uint64
-
-	for _, b := range ts.Blocks() {
-		bmsgs, smsgs, err := bss.cs.MessagesForBlock(b)
-		if err != nil {
-			return nil, nil, nil, nil, err
-		}
-
-		bmi := make([]uint64, 0, len(bmsgs))
-		for _, m := range bmsgs {
-			i, ok := blsmsgmap[m.Cid()]
-			if !ok {
-				i = uint64(len(blsmsgs))
-				blsmsgs = append(blsmsgs, m)
-				blsmsgmap[m.Cid()] = i
-			}
-
-			bmi = append(bmi, i)
-		}
-		blsincl = append(blsincl, bmi)
-
-		smi := make([]uint64, 0, len(smsgs))
-		for _, m := range smsgs {
-			i, ok := secpkmsgmap[m.Cid()]
-			if !ok {
-				i = uint64(len(secpkmsgs))
-				secpkmsgs = append(secpkmsgs, m)
-				secpkmsgmap[m.Cid()] = i
-			}
-
-			smi = append(smi, i)
-		}
-		secpkincl = append(secpkincl, smi)
-	}
-
-	return blsmsgs, blsincl, secpkmsgs, secpkincl, nil
-}
-
-func bstsToFullTipSet(bts *BSTipSet) (*store.FullTipSet, error) {
-	fts := &store.FullTipSet{}
-	for i, b := range bts.Blocks {
-		fb := &types.FullBlock{
-			Header: b,
-		}
-		for _, mi := range bts.BlsMsgIncludes[i] {
-			fb.BlsMessages = append(fb.BlsMessages, bts.BlsMessages[mi])
-		}
-		for _, mi := range bts.SecpkMsgIncludes[i] {
-			fb.SecpkMessages = append(fb.SecpkMessages, bts.SecpkMessages[mi])
-		}
-
-		fts.Blocks = append(fts.Blocks, fb)
-	}
-
-	return fts, nil
-}
diff --git a/chain/blocksync/blocksync_client.go b/chain/blocksync/blocksync_client.go
deleted file mode 100644
index ef5e370c8..000000000
--- a/chain/blocksync/blocksync_client.go
+++ /dev/null
@@ -1,547 +0,0 @@
-package blocksync
-
-import (
-	"bufio"
-	"context"
-	"fmt"
-	"math/rand"
-	"sort"
-	"sync"
-	"time"
-
-	blocks "github.com/ipfs/go-block-format"
-	bserv "github.com/ipfs/go-blockservice"
-	"github.com/ipfs/go-cid"
-	host "github.com/libp2p/go-libp2p-core/host"
-	inet "github.com/libp2p/go-libp2p-core/network"
-	"github.com/libp2p/go-libp2p-core/peer"
-	"go.opencensus.io/trace"
-	"golang.org/x/xerrors"
-
-	"github.com/filecoin-project/go-cbor-util"
-	"github.com/filecoin-project/lotus/chain/store"
-	"github.com/filecoin-project/lotus/chain/types"
-	"github.com/filecoin-project/lotus/node/modules/dtypes"
-	"github.com/filecoin-project/lotus/peermgr"
-)
-
-type BlockSync struct {
-	bserv bserv.BlockService
-	host  host.Host
-
-	syncPeers *bsPeerTracker
-	peerMgr   *peermgr.PeerMgr
-}
-
-func NewBlockSyncClient(bserv dtypes.ChainBlockService, h host.Host, pmgr peermgr.MaybePeerMgr) *BlockSync {
-	return &BlockSync{
-		bserv:     bserv,
-		host:      h,
-		syncPeers: newPeerTracker(pmgr.Mgr),
-		peerMgr:   pmgr.Mgr,
-	}
-}
-
-func (bs *BlockSync) processStatus(req *BlockSyncRequest, res *BlockSyncResponse) error {
-	switch res.Status {
-	case 101: // Partial Response
-		return xerrors.Errorf("not handling partial blocksync responses yet")
-	case 201: // req.Start not found
-		return xerrors.Errorf("not found")
-	case 202: // Go Away
-		return xerrors.Errorf("not handling 'go away' blocksync responses yet")
-	case 203: // Internal Error
-		return xerrors.Errorf("block sync peer errored: %s", res.Message)
-	case 204:
-		return xerrors.Errorf("block sync request invalid: %s", res.Message)
-	default:
-		return xerrors.Errorf("unrecognized response code: %d", res.Status)
-	}
-}
-
-func (bs *BlockSync) GetBlocks(ctx context.Context, tsk types.TipSetKey, count int) ([]*types.TipSet, error) {
-	ctx, span := trace.StartSpan(ctx, "bsync.GetBlocks")
-	defer span.End()
-	if span.IsRecordingEvents() {
-		span.AddAttributes(
-			trace.StringAttribute("tipset", fmt.Sprint(tsk.Cids())),
-			trace.Int64Attribute("count", int64(count)),
-		)
-	}
-
-	req := &BlockSyncRequest{
-		Start:         tsk.Cids(),
-		RequestLength: uint64(count),
-		Options:       BSOptBlocks,
-	}
-
-	peers := bs.getPeers()
-	// randomize the first few peers so we don't always pick the same peer
-	shufflePrefix(peers)
-
-	start := time.Now()
-	var oerr error
-
-	for _, p := range peers {
-		// TODO: doing this synchronously isnt great, but fetching in parallel
-		// may not be a good idea either. think about this more
-		select {
-		case <-ctx.Done():
-			return nil, xerrors.Errorf("blocksync getblocks failed: %w", ctx.Err())
-		default:
-		}
-
-		res, err := bs.sendRequestToPeer(ctx, p, req)
-		if err != nil {
-			oerr = err
-			if !xerrors.Is(err, inet.ErrNoConn) {
-				log.Warnf("BlockSync request failed for peer %s: %s", p.String(), err)
-			}
-			continue
-		}
-
-		if res.Status == 0 {
-			resp, err := bs.processBlocksResponse(req, res)
-			if err != nil {
-				return nil, xerrors.Errorf("success response from peer failed to process: %w", err)
-			}
-			bs.syncPeers.logGlobalSuccess(time.Since(start))
-			bs.host.ConnManager().TagPeer(p, "bsync", 25)
-			return resp, nil
-		}
-		oerr = bs.processStatus(req, res)
-		if oerr != nil {
-			log.Warnf("BlockSync peer %s response was an error: %s", p.String(), oerr)
-		}
-	}
-	return nil, xerrors.Errorf("GetBlocks failed with all peers: %w", oerr)
-}
-
-func (bs *BlockSync) GetFullTipSet(ctx context.Context, p peer.ID, tsk types.TipSetKey) (*store.FullTipSet, error) {
-	// TODO: round robin through these peers on error
-
-	req := &BlockSyncRequest{
-		Start:         tsk.Cids(),
-		RequestLength: 1,
-		Options:       BSOptBlocks | BSOptMessages,
-	}
-
-	res, err := bs.sendRequestToPeer(ctx, p, req)
-	if err != nil {
-		return nil, err
-	}
-
-	switch res.Status {
-	case 0: // Success
-		if len(res.Chain) == 0 {
-			return nil, fmt.Errorf("got zero length chain response")
-		}
-		bts := res.Chain[0]
-
-		return bstsToFullTipSet(bts)
-	case 101: // Partial Response
-		return nil, xerrors.Errorf("partial responses are not handled")
-	case 201: // req.Start not found
-		return nil, fmt.Errorf("not found")
-	case 202: // Go Away
-		return nil, xerrors.Errorf("received 'go away' response peer")
-	case 203: // Internal Error
-		return nil, fmt.Errorf("block sync peer errored: %q", res.Message)
-	case 204: // Invalid Request
-		return nil, fmt.Errorf("block sync request invalid: %q", res.Message)
-	default:
-		return nil, fmt.Errorf("unrecognized response code")
-	}
-}
-
-func shufflePrefix(peers []peer.ID) {
-	pref := 5
-	if len(peers) < pref {
-		pref = len(peers)
-	}
-
-	buf := make([]peer.ID, pref)
-	perm := rand.Perm(pref)
-	for i, v := range perm {
-		buf[i] = peers[v]
-	}
-
-	copy(peers, buf)
-}
-
-func (bs *BlockSync) GetChainMessages(ctx context.Context, h *types.TipSet, count uint64) ([]*BSTipSet, error) {
-	ctx, span := trace.StartSpan(ctx, "GetChainMessages")
-	defer span.End()
-
-	peers := bs.getPeers()
-	// randomize the first few peers so we don't always pick the same peer
-	shufflePrefix(peers)
-
-	req := &BlockSyncRequest{
-		Start:         h.Cids(),
-		RequestLength: count,
-		Options:       BSOptMessages | BSOptBlocks,
-	}
-
-	var err error
-	start := time.Now()
-
-	for _, p := range peers {
-		res, rerr := bs.sendRequestToPeer(ctx, p, req)
-		if rerr != nil {
-			err = rerr
-			log.Warnf("BlockSync request failed for peer %s: %s", p.String(), err)
-			continue
-		}
-
-		if res.Status == 0 {
-			bs.syncPeers.logGlobalSuccess(time.Since(start))
-			return res.Chain, nil
-		}
-
-		err = bs.processStatus(req, res)
-		if err != nil {
-			log.Warnf("BlockSync peer %s response was an error: %s", p.String(), err)
-		}
-	}
-
-	if err == nil {
-		return nil, xerrors.Errorf("GetChainMessages failed, no peers connected")
-	}
-
-	// TODO: What if we have no peers (and err is nil)?
-	return nil, xerrors.Errorf("GetChainMessages failed with all peers(%d): %w", len(peers), err)
-}
-
-func (bs *BlockSync) sendRequestToPeer(ctx context.Context, p peer.ID, req *BlockSyncRequest) (_ *BlockSyncResponse, err error) {
-	ctx, span := trace.StartSpan(ctx, "sendRequestToPeer")
-	defer span.End()
-
-	defer func() {
-		if err != nil {
-			if span.IsRecordingEvents() {
-				span.SetStatus(trace.Status{
-					Code:    5,
-					Message: err.Error(),
-				})
-			}
-		}
-	}()
-
-	start := time.Now()
-
-	if span.IsRecordingEvents() {
-		span.AddAttributes(
-			trace.StringAttribute("peer", p.Pretty()),
-		)
-	}
-
-	s, err := bs.host.NewStream(inet.WithNoDial(ctx, "should already have connection"), p, BlockSyncProtocolID)
-	if err != nil {
-		bs.RemovePeer(p)
-		return nil, xerrors.Errorf("failed to open stream to peer: %w", err)
-	}
-	s.SetDeadline(time.Now().Add(10 * time.Second))
-	defer s.SetDeadline(time.Time{})
-
-	if err := cborutil.WriteCborRPC(s, req); err != nil {
-		bs.syncPeers.logFailure(p, time.Since(start))
-		return nil, err
-	}
-
-	var res BlockSyncResponse
-	if err := cborutil.ReadCborRPC(bufio.NewReader(s), &res); err != nil {
-		bs.syncPeers.logFailure(p, time.Since(start))
-		return nil, err
-	}
-
-	if span.IsRecordingEvents() {
-		span.AddAttributes(
-			trace.Int64Attribute("resp_status", int64(res.Status)),
-			trace.StringAttribute("msg", res.Message),
-			trace.Int64Attribute("chain_len", int64(len(res.Chain))),
-		)
-	}
-
-	bs.syncPeers.logSuccess(p, time.Since(start))
-
-	return &res, nil
-}
-
-func (bs *BlockSync) processBlocksResponse(req *BlockSyncRequest, res *BlockSyncResponse) ([]*types.TipSet, error) {
-	if len(res.Chain) == 0 {
-		return nil, xerrors.Errorf("got no blocks in successful blocksync response")
-	}
-
-	cur, err := types.NewTipSet(res.Chain[0].Blocks)
-	if err != nil {
-		return nil, err
-	}
-
-	out := []*types.TipSet{cur}
-	for bi := 1; bi < len(res.Chain); bi++ {
-		next := res.Chain[bi].Blocks
-		nts, err := types.NewTipSet(next)
-		if err != nil {
-			return nil, err
-		}
-
-		if !types.CidArrsEqual(cur.Parents().Cids(), nts.Cids()) {
-			return nil, fmt.Errorf("parents of tipset[%d] were not tipset[%d]", bi-1, bi)
-		}
-
-		out = append(out, nts)
-		cur = nts
-	}
-	return out, nil
-}
-
-func (bs *BlockSync) GetBlock(ctx context.Context, c cid.Cid) (*types.BlockHeader, error) {
-	sb, err := bs.bserv.GetBlock(ctx, c)
-	if err != nil {
-		return nil, err
-	}
-
-	return types.DecodeBlock(sb.RawData())
-}
-
-func (bs *BlockSync) AddPeer(p peer.ID) {
-	bs.syncPeers.addPeer(p)
-}
-
-func (bs *BlockSync) RemovePeer(p peer.ID) {
-	bs.syncPeers.removePeer(p)
-}
-
-func (bs *BlockSync) getPeers() []peer.ID {
-	return bs.syncPeers.prefSortedPeers()
-}
-
-func (bs *BlockSync) FetchMessagesByCids(ctx context.Context, cids []cid.Cid) ([]*types.Message, error) {
-	out := make([]*types.Message, len(cids))
-
-	err := bs.fetchCids(ctx, cids, func(i int, b blocks.Block) error {
-		msg, err := types.DecodeMessage(b.RawData())
-		if err != nil {
-			return err
-		}
-
-		if out[i] != nil {
-			return fmt.Errorf("received duplicate message")
-		}
-
-		out[i] = msg
-		return nil
-	})
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-func (bs *BlockSync) FetchSignedMessagesByCids(ctx context.Context, cids []cid.Cid) ([]*types.SignedMessage, error) {
-	out := make([]*types.SignedMessage, len(cids))
-
-	err := bs.fetchCids(ctx, cids, func(i int, b blocks.Block) error {
-		smsg, err := types.DecodeSignedMessage(b.RawData())
-		if err != nil {
-			return err
-		}
-
-		if out[i] != nil {
-			return fmt.Errorf("received duplicate message")
-		}
-
-		out[i] = smsg
-		return nil
-	})
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-func (bs *BlockSync) fetchCids(ctx context.Context, cids []cid.Cid, cb func(int, blocks.Block) error) error {
-	resp := bs.bserv.GetBlocks(context.TODO(), cids)
-
-	m := make(map[cid.Cid]int)
-	for i, c := range cids {
-		m[c] = i
-	}
-
-	for i := 0; i < len(cids); i++ {
-		select {
-		case v, ok := <-resp:
-			if !ok {
-				if i == len(cids)-1 {
-					break
-				}
-
-				return fmt.Errorf("failed to fetch all messages")
-			}
-
-			ix, ok := m[v.Cid()]
-			if !ok {
-				return fmt.Errorf("received message we didnt ask for")
-			}
-
-			if err := cb(ix, v); err != nil {
-				return err
-			}
-		}
-	}
-
-	return nil
-}
-
-type peerStats struct {
-	successes   int
-	failures    int
-	firstSeen   time.Time
-	averageTime time.Duration
-}
-
-type bsPeerTracker struct {
-	lk sync.Mutex
-
-	peers         map[peer.ID]*peerStats
-	avgGlobalTime time.Duration
-
-	pmgr *peermgr.PeerMgr
-}
-
-func newPeerTracker(pmgr *peermgr.PeerMgr) *bsPeerTracker {
-	return &bsPeerTracker{
-		peers: make(map[peer.ID]*peerStats),
-		pmgr:  pmgr,
-	}
-}
-
-func (bpt *bsPeerTracker) addPeer(p peer.ID) {
-	bpt.lk.Lock()
-	defer bpt.lk.Unlock()
-	if _, ok := bpt.peers[p]; ok {
-		return
-	}
-	bpt.peers[p] = &peerStats{
-		firstSeen: time.Now(),
-	}
-
-}
-
-const (
-	// newPeerMul is how much better than average is the new peer assumed to be
-	// less than one to encourouge trying new peers
-	newPeerMul = 0.9
-)
-
-func (bpt *bsPeerTracker) prefSortedPeers() []peer.ID {
-	// TODO: this could probably be cached, but as long as its not too many peers, fine for now
-	bpt.lk.Lock()
-	defer bpt.lk.Unlock()
-	out := make([]peer.ID, 0, len(bpt.peers))
-	for p := range bpt.peers {
-		out = append(out, p)
-	}
-
-	// sort by 'expected cost' of requesting data from that peer
-	// additionally handle edge cases where not enough data is available
-	sort.Slice(out, func(i, j int) bool {
-		pi := bpt.peers[out[i]]
-		pj := bpt.peers[out[j]]
-
-		var costI, costJ float64
-
-		getPeerInitLat := func(p peer.ID) float64 {
-			var res float64
-			if bpt.pmgr != nil {
-				if lat, ok := bpt.pmgr.GetPeerLatency(out[i]); ok {
-					res = float64(lat)
-				}
-			}
-			if res == 0 {
-				res = float64(bpt.avgGlobalTime)
-			}
-			return res * newPeerMul
-		}
-
-		if pi.successes+pi.failures > 0 {
-			failRateI := float64(pi.failures) / float64(pi.failures+pi.successes)
-			costI = float64(pi.averageTime) + failRateI*float64(bpt.avgGlobalTime)
-		} else {
-			costI = getPeerInitLat(out[i])
-		}
-
-		if pj.successes+pj.failures > 0 {
-			failRateJ := float64(pj.failures) / float64(pj.failures+pj.successes)
-			costJ = float64(pj.averageTime) + failRateJ*float64(bpt.avgGlobalTime)
-		} else {
-			costI = getPeerInitLat(out[i])
-		}
-
-		return costI < costJ
-	})
-
-	return out
-}
-
-const (
-	// xInvAlpha = (N+1)/2
-
-	localInvAlpha  = 5  // 86% of the value is the last 9
-	globalInvAlpha = 20 // 86% of the value is the last 39
-)
-
-func (bpt *bsPeerTracker) logGlobalSuccess(dur time.Duration) {
-	bpt.lk.Lock()
-	defer bpt.lk.Unlock()
-
-	if bpt.avgGlobalTime == 0 {
-		bpt.avgGlobalTime = dur
-		return
-	}
-	delta := (dur - bpt.avgGlobalTime) / globalInvAlpha
-	bpt.avgGlobalTime += delta
-}
-
-func logTime(pi *peerStats, dur time.Duration) {
-	if pi.averageTime == 0 {
-		pi.averageTime = dur
-		return
-	}
-	delta := (dur - pi.averageTime) / localInvAlpha
-	pi.averageTime += delta
-
-}
-
-func (bpt *bsPeerTracker) logSuccess(p peer.ID, dur time.Duration) {
-	bpt.lk.Lock()
-	defer bpt.lk.Unlock()
-
-	if pi, ok := bpt.peers[p]; !ok {
-		log.Warnw("log success called on peer not in tracker", "peerid", p.String())
-		return
-	} else {
-		pi.successes++
-
-		logTime(pi, dur)
-	}
-}
-
-func (bpt *bsPeerTracker) logFailure(p peer.ID, dur time.Duration) {
-	bpt.lk.Lock()
-	defer bpt.lk.Unlock()
-	if pi, ok := bpt.peers[p]; !ok {
-		log.Warn("log failure called on peer not in tracker", "peerid", p.String())
-		return
-	} else {
-		pi.failures++
-		logTime(pi, dur)
-	}
-}
-
-func (bpt *bsPeerTracker) removePeer(p peer.ID) {
-	bpt.lk.Lock()
-	defer bpt.lk.Unlock()
-	delete(bpt.peers, p)
-}
diff --git a/chain/blocksync/cbor_gen.go b/chain/blocksync/cbor_gen.go
deleted file mode 100644
index 896d8f961..000000000
--- a/chain/blocksync/cbor_gen.go
+++ /dev/null
@@ -1,529 +0,0 @@
-package blocksync
-
-import (
-	"fmt"
-	"io"
-
-	"github.com/filecoin-project/lotus/chain/types"
-	cid "github.com/ipfs/go-cid"
-	cbg "github.com/whyrusleeping/cbor-gen"
-	xerrors "golang.org/x/xerrors"
-)
-
-// Code generated by github.com/whyrusleeping/cbor-gen. DO NOT EDIT.
-
-var _ = xerrors.Errorf
-
-func (t *BlockSyncRequest) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{131}); err != nil {
-		return err
-	}
-
-	// t.Start ([]cid.Cid) (slice)
-	if len(t.Start) > cbg.MaxLength {
-		return xerrors.Errorf("Slice value in field t.Start was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajArray, uint64(len(t.Start)))); err != nil {
-		return err
-	}
-	for _, v := range t.Start {
-		if err := cbg.WriteCid(w, v); err != nil {
-			return xerrors.Errorf("failed writing cid field t.Start: %w", err)
-		}
-	}
-
-	// t.RequestLength (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.RequestLength))); err != nil {
-		return err
-	}
-
-	// t.Options (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.Options))); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *BlockSyncRequest) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 3 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	// t.Start ([]cid.Cid) (slice)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-
-	if extra > cbg.MaxLength {
-		return fmt.Errorf("t.Start: array too large (%d)", extra)
-	}
-
-	if maj != cbg.MajArray {
-		return fmt.Errorf("expected cbor array")
-	}
-	if extra > 0 {
-		t.Start = make([]cid.Cid, extra)
-	}
-	for i := 0; i < int(extra); i++ {
-
-		c, err := cbg.ReadCid(br)
-		if err != nil {
-			return xerrors.Errorf("reading cid field t.Start failed: %w", err)
-		}
-		t.Start[i] = c
-	}
-
-	// t.RequestLength (uint64) (uint64)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.RequestLength = uint64(extra)
-	// t.Options (uint64) (uint64)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.Options = uint64(extra)
-	return nil
-}
-
-func (t *BlockSyncResponse) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{131}); err != nil {
-		return err
-	}
-
-	// t.Chain ([]*blocksync.BSTipSet) (slice)
-	if len(t.Chain) > cbg.MaxLength {
-		return xerrors.Errorf("Slice value in field t.Chain was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajArray, uint64(len(t.Chain)))); err != nil {
-		return err
-	}
-	for _, v := range t.Chain {
-		if err := v.MarshalCBOR(w); err != nil {
-			return err
-		}
-	}
-
-	// t.Status (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.Status))); err != nil {
-		return err
-	}
-
-	// t.Message (string) (string)
-	if len(t.Message) > cbg.MaxLength {
-		return xerrors.Errorf("Value in field t.Message was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len(t.Message)))); err != nil {
-		return err
-	}
-	if _, err := w.Write([]byte(t.Message)); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *BlockSyncResponse) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 3 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	// t.Chain ([]*blocksync.BSTipSet) (slice)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-
-	if extra > cbg.MaxLength {
-		return fmt.Errorf("t.Chain: array too large (%d)", extra)
-	}
-
-	if maj != cbg.MajArray {
-		return fmt.Errorf("expected cbor array")
-	}
-	if extra > 0 {
-		t.Chain = make([]*BSTipSet, extra)
-	}
-	for i := 0; i < int(extra); i++ {
-
-		var v BSTipSet
-		if err := v.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-		t.Chain[i] = &v
-	}
-
-	// t.Status (uint64) (uint64)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.Status = uint64(extra)
-	// t.Message (string) (string)
-
-	{
-		sval, err := cbg.ReadString(br)
-		if err != nil {
-			return err
-		}
-
-		t.Message = string(sval)
-	}
-	return nil
-}
-
-func (t *BSTipSet) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{133}); err != nil {
-		return err
-	}
-
-	// t.Blocks ([]*types.BlockHeader) (slice)
-	if len(t.Blocks) > cbg.MaxLength {
-		return xerrors.Errorf("Slice value in field t.Blocks was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajArray, uint64(len(t.Blocks)))); err != nil {
-		return err
-	}
-	for _, v := range t.Blocks {
-		if err := v.MarshalCBOR(w); err != nil {
-			return err
-		}
-	}
-
-	// t.BlsMessages ([]*types.Message) (slice)
-	if len(t.BlsMessages) > cbg.MaxLength {
-		return xerrors.Errorf("Slice value in field t.BlsMessages was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajArray, uint64(len(t.BlsMessages)))); err != nil {
-		return err
-	}
-	for _, v := range t.BlsMessages {
-		if err := v.MarshalCBOR(w); err != nil {
-			return err
-		}
-	}
-
-	// t.BlsMsgIncludes ([][]uint64) (slice)
-	if len(t.BlsMsgIncludes) > cbg.MaxLength {
-		return xerrors.Errorf("Slice value in field t.BlsMsgIncludes was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajArray, uint64(len(t.BlsMsgIncludes)))); err != nil {
-		return err
-	}
-	for _, v := range t.BlsMsgIncludes {
-		if len(v) > cbg.MaxLength {
-			return xerrors.Errorf("Slice value in field v was too long")
-		}
-
-		if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajArray, uint64(len(v)))); err != nil {
-			return err
-		}
-		for _, v := range v {
-			if err := cbg.CborWriteHeader(w, cbg.MajUnsignedInt, v); err != nil {
-				return err
-			}
-		}
-	}
-
-	// t.SecpkMessages ([]*types.SignedMessage) (slice)
-	if len(t.SecpkMessages) > cbg.MaxLength {
-		return xerrors.Errorf("Slice value in field t.SecpkMessages was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajArray, uint64(len(t.SecpkMessages)))); err != nil {
-		return err
-	}
-	for _, v := range t.SecpkMessages {
-		if err := v.MarshalCBOR(w); err != nil {
-			return err
-		}
-	}
-
-	// t.SecpkMsgIncludes ([][]uint64) (slice)
-	if len(t.SecpkMsgIncludes) > cbg.MaxLength {
-		return xerrors.Errorf("Slice value in field t.SecpkMsgIncludes was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajArray, uint64(len(t.SecpkMsgIncludes)))); err != nil {
-		return err
-	}
-	for _, v := range t.SecpkMsgIncludes {
-		if len(v) > cbg.MaxLength {
-			return xerrors.Errorf("Slice value in field v was too long")
-		}
-
-		if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajArray, uint64(len(v)))); err != nil {
-			return err
-		}
-		for _, v := range v {
-			if err := cbg.CborWriteHeader(w, cbg.MajUnsignedInt, v); err != nil {
-				return err
-			}
-		}
-	}
-	return nil
-}
-
-func (t *BSTipSet) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 5 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	// t.Blocks ([]*types.BlockHeader) (slice)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-
-	if extra > cbg.MaxLength {
-		return fmt.Errorf("t.Blocks: array too large (%d)", extra)
-	}
-
-	if maj != cbg.MajArray {
-		return fmt.Errorf("expected cbor array")
-	}
-	if extra > 0 {
-		t.Blocks = make([]*types.BlockHeader, extra)
-	}
-	for i := 0; i < int(extra); i++ {
-
-		var v types.BlockHeader
-		if err := v.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-		t.Blocks[i] = &v
-	}
-
-	// t.BlsMessages ([]*types.Message) (slice)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-
-	if extra > cbg.MaxLength {
-		return fmt.Errorf("t.BlsMessages: array too large (%d)", extra)
-	}
-
-	if maj != cbg.MajArray {
-		return fmt.Errorf("expected cbor array")
-	}
-	if extra > 0 {
-		t.BlsMessages = make([]*types.Message, extra)
-	}
-	for i := 0; i < int(extra); i++ {
-
-		var v types.Message
-		if err := v.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-		t.BlsMessages[i] = &v
-	}
-
-	// t.BlsMsgIncludes ([][]uint64) (slice)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-
-	if extra > cbg.MaxLength {
-		return fmt.Errorf("t.BlsMsgIncludes: array too large (%d)", extra)
-	}
-
-	if maj != cbg.MajArray {
-		return fmt.Errorf("expected cbor array")
-	}
-	if extra > 0 {
-		t.BlsMsgIncludes = make([][]uint64, extra)
-	}
-	for i := 0; i < int(extra); i++ {
-		{
-			var maj byte
-			var extra uint64
-			var err error
-
-			maj, extra, err = cbg.CborReadHeader(br)
-			if err != nil {
-				return err
-			}
-
-			if extra > cbg.MaxLength {
-				return fmt.Errorf("t.BlsMsgIncludes[i]: array too large (%d)", extra)
-			}
-
-			if maj != cbg.MajArray {
-				return fmt.Errorf("expected cbor array")
-			}
-			if extra > 0 {
-				t.BlsMsgIncludes[i] = make([]uint64, extra)
-			}
-			for j := 0; j < int(extra); j++ {
-
-				maj, val, err := cbg.CborReadHeader(br)
-				if err != nil {
-					return xerrors.Errorf("failed to read uint64 for t.BlsMsgIncludes[i] slice: %w", err)
-				}
-
-				if maj != cbg.MajUnsignedInt {
-					return xerrors.Errorf("value read for array t.BlsMsgIncludes[i] was not a uint, instead got %d", maj)
-				}
-
-				t.BlsMsgIncludes[i][j] = val
-			}
-
-		}
-	}
-
-	// t.SecpkMessages ([]*types.SignedMessage) (slice)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-
-	if extra > cbg.MaxLength {
-		return fmt.Errorf("t.SecpkMessages: array too large (%d)", extra)
-	}
-
-	if maj != cbg.MajArray {
-		return fmt.Errorf("expected cbor array")
-	}
-	if extra > 0 {
-		t.SecpkMessages = make([]*types.SignedMessage, extra)
-	}
-	for i := 0; i < int(extra); i++ {
-
-		var v types.SignedMessage
-		if err := v.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-		t.SecpkMessages[i] = &v
-	}
-
-	// t.SecpkMsgIncludes ([][]uint64) (slice)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-
-	if extra > cbg.MaxLength {
-		return fmt.Errorf("t.SecpkMsgIncludes: array too large (%d)", extra)
-	}
-
-	if maj != cbg.MajArray {
-		return fmt.Errorf("expected cbor array")
-	}
-	if extra > 0 {
-		t.SecpkMsgIncludes = make([][]uint64, extra)
-	}
-	for i := 0; i < int(extra); i++ {
-		{
-			var maj byte
-			var extra uint64
-			var err error
-
-			maj, extra, err = cbg.CborReadHeader(br)
-			if err != nil {
-				return err
-			}
-
-			if extra > cbg.MaxLength {
-				return fmt.Errorf("t.SecpkMsgIncludes[i]: array too large (%d)", extra)
-			}
-
-			if maj != cbg.MajArray {
-				return fmt.Errorf("expected cbor array")
-			}
-			if extra > 0 {
-				t.SecpkMsgIncludes[i] = make([]uint64, extra)
-			}
-			for j := 0; j < int(extra); j++ {
-
-				maj, val, err := cbg.CborReadHeader(br)
-				if err != nil {
-					return xerrors.Errorf("failed to read uint64 for t.SecpkMsgIncludes[i] slice: %w", err)
-				}
-
-				if maj != cbg.MajUnsignedInt {
-					return xerrors.Errorf("value read for array t.SecpkMsgIncludes[i] was not a uint, instead got %d", maj)
-				}
-
-				t.SecpkMsgIncludes[i][j] = val
-			}
-
-		}
-	}
-
-	return nil
-}
diff --git a/chain/checkpoint.go b/chain/checkpoint.go
new file mode 100644
index 000000000..8f99d73e4
--- /dev/null
+++ b/chain/checkpoint.go
@@ -0,0 +1,81 @@
+package chain
+
+import (
+	"encoding/json"
+
+	"github.com/filecoin-project/lotus/chain/types"
+
+	"github.com/filecoin-project/lotus/node/modules/dtypes"
+	"github.com/ipfs/go-datastore"
+	"golang.org/x/xerrors"
+)
+
+var CheckpointKey = datastore.NewKey("/chain/checks")
+
+func loadCheckpoint(ds dtypes.MetadataDS) (types.TipSetKey, error) {
+	haveChks, err := ds.Has(CheckpointKey)
+	if err != nil {
+		return types.EmptyTSK, err
+	}
+
+	if !haveChks {
+		return types.EmptyTSK, nil
+	}
+
+	tskBytes, err := ds.Get(CheckpointKey)
+	if err != nil {
+		return types.EmptyTSK, err
+	}
+
+	var tsk types.TipSetKey
+	err = json.Unmarshal(tskBytes, &tsk)
+	if err != nil {
+		return types.EmptyTSK, err
+	}
+
+	return tsk, err
+}
+
+func (syncer *Syncer) SetCheckpoint(tsk types.TipSetKey) error {
+	if tsk == types.EmptyTSK {
+		return xerrors.Errorf("called with empty tsk")
+	}
+
+	syncer.checkptLk.Lock()
+	defer syncer.checkptLk.Unlock()
+
+	ts, err := syncer.ChainStore().LoadTipSet(tsk)
+	if err != nil {
+		return xerrors.Errorf("cannot find tipset: %w", err)
+	}
+
+	hts := syncer.ChainStore().GetHeaviestTipSet()
+	anc, err := syncer.ChainStore().IsAncestorOf(ts, hts)
+	if err != nil {
+		return xerrors.Errorf("cannot determine whether checkpoint tipset is in main-chain: %w", err)
+	}
+
+	if !hts.Equals(ts) && !anc {
+		return xerrors.Errorf("cannot mark tipset as checkpoint, since it isn't in the main-chain: %w", err)
+	}
+
+	tskBytes, err := json.Marshal(tsk)
+	if err != nil {
+		return err
+	}
+
+	err = syncer.ds.Put(CheckpointKey, tskBytes)
+	if err != nil {
+		return err
+	}
+
+	syncer.checkpt = tsk
+
+	return nil
+}
+
+func (syncer *Syncer) GetCheckpoint() types.TipSetKey {
+	syncer.checkptLk.Lock()
+	defer syncer.checkptLk.Unlock()
+	return syncer.checkpt
+}
diff --git a/chain/deals/cbor_gen.go b/chain/deals/cbor_gen.go
deleted file mode 100644
index 2a5f1f8a9..000000000
--- a/chain/deals/cbor_gen.go
+++ /dev/null
@@ -1,883 +0,0 @@
-package deals
-
-import (
-	"fmt"
-	"io"
-
-	"github.com/filecoin-project/lotus/chain/actors"
-	"github.com/filecoin-project/lotus/chain/types"
-	"github.com/libp2p/go-libp2p-core/peer"
-	cbg "github.com/whyrusleeping/cbor-gen"
-	xerrors "golang.org/x/xerrors"
-)
-
-// Code generated by github.com/whyrusleeping/cbor-gen. DO NOT EDIT.
-
-var _ = xerrors.Errorf
-
-func (t *AskRequest) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{129}); err != nil {
-		return err
-	}
-
-	// t.Miner (address.Address) (struct)
-	if err := t.Miner.MarshalCBOR(w); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *AskRequest) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 1 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	// t.Miner (address.Address) (struct)
-
-	{
-
-		if err := t.Miner.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-	}
-	return nil
-}
-
-func (t *AskResponse) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{129}); err != nil {
-		return err
-	}
-
-	// t.Ask (types.SignedStorageAsk) (struct)
-	if err := t.Ask.MarshalCBOR(w); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *AskResponse) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 1 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	// t.Ask (types.SignedStorageAsk) (struct)
-
-	{
-
-		pb, err := br.PeekByte()
-		if err != nil {
-			return err
-		}
-		if pb == cbg.CborNull[0] {
-			var nbuf [1]byte
-			if _, err := br.Read(nbuf[:]); err != nil {
-				return err
-			}
-		} else {
-			t.Ask = new(types.SignedStorageAsk)
-			if err := t.Ask.UnmarshalCBOR(br); err != nil {
-				return err
-			}
-		}
-
-	}
-	return nil
-}
-
-func (t *Proposal) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{130}); err != nil {
-		return err
-	}
-
-	// t.DealProposal (actors.StorageDealProposal) (struct)
-	if err := t.DealProposal.MarshalCBOR(w); err != nil {
-		return err
-	}
-
-	// t.Piece (cid.Cid) (struct)
-
-	if err := cbg.WriteCid(w, t.Piece); err != nil {
-		return xerrors.Errorf("failed to write cid field t.Piece: %w", err)
-	}
-
-	return nil
-}
-
-func (t *Proposal) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 2 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	// t.DealProposal (actors.StorageDealProposal) (struct)
-
-	{
-
-		pb, err := br.PeekByte()
-		if err != nil {
-			return err
-		}
-		if pb == cbg.CborNull[0] {
-			var nbuf [1]byte
-			if _, err := br.Read(nbuf[:]); err != nil {
-				return err
-			}
-		} else {
-			t.DealProposal = new(actors.StorageDealProposal)
-			if err := t.DealProposal.UnmarshalCBOR(br); err != nil {
-				return err
-			}
-		}
-
-	}
-	// t.Piece (cid.Cid) (struct)
-
-	{
-
-		c, err := cbg.ReadCid(br)
-		if err != nil {
-			return xerrors.Errorf("failed to read cid field t.Piece: %w", err)
-		}
-
-		t.Piece = c
-
-	}
-	return nil
-}
-
-func (t *Response) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{132}); err != nil {
-		return err
-	}
-
-	// t.State (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.State))); err != nil {
-		return err
-	}
-
-	// t.Message (string) (string)
-	if len(t.Message) > cbg.MaxLength {
-		return xerrors.Errorf("Value in field t.Message was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len(t.Message)))); err != nil {
-		return err
-	}
-	if _, err := w.Write([]byte(t.Message)); err != nil {
-		return err
-	}
-
-	// t.Proposal (cid.Cid) (struct)
-
-	if err := cbg.WriteCid(w, t.Proposal); err != nil {
-		return xerrors.Errorf("failed to write cid field t.Proposal: %w", err)
-	}
-
-	// t.StorageDealSubmission (types.SignedMessage) (struct)
-	if err := t.StorageDealSubmission.MarshalCBOR(w); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *Response) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 4 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	// t.State (uint64) (uint64)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.State = uint64(extra)
-	// t.Message (string) (string)
-
-	{
-		sval, err := cbg.ReadString(br)
-		if err != nil {
-			return err
-		}
-
-		t.Message = string(sval)
-	}
-	// t.Proposal (cid.Cid) (struct)
-
-	{
-
-		c, err := cbg.ReadCid(br)
-		if err != nil {
-			return xerrors.Errorf("failed to read cid field t.Proposal: %w", err)
-		}
-
-		t.Proposal = c
-
-	}
-	// t.StorageDealSubmission (types.SignedMessage) (struct)
-
-	{
-
-		pb, err := br.PeekByte()
-		if err != nil {
-			return err
-		}
-		if pb == cbg.CborNull[0] {
-			var nbuf [1]byte
-			if _, err := br.Read(nbuf[:]); err != nil {
-				return err
-			}
-		} else {
-			t.StorageDealSubmission = new(types.SignedMessage)
-			if err := t.StorageDealSubmission.UnmarshalCBOR(br); err != nil {
-				return err
-			}
-		}
-
-	}
-	return nil
-}
-
-func (t *SignedResponse) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{130}); err != nil {
-		return err
-	}
-
-	// t.Response (deals.Response) (struct)
-	if err := t.Response.MarshalCBOR(w); err != nil {
-		return err
-	}
-
-	// t.Signature (types.Signature) (struct)
-	if err := t.Signature.MarshalCBOR(w); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *SignedResponse) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 2 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	// t.Response (deals.Response) (struct)
-
-	{
-
-		if err := t.Response.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-	}
-	// t.Signature (types.Signature) (struct)
-
-	{
-
-		pb, err := br.PeekByte()
-		if err != nil {
-			return err
-		}
-		if pb == cbg.CborNull[0] {
-			var nbuf [1]byte
-			if _, err := br.Read(nbuf[:]); err != nil {
-				return err
-			}
-		} else {
-			t.Signature = new(types.Signature)
-			if err := t.Signature.UnmarshalCBOR(br); err != nil {
-				return err
-			}
-		}
-
-	}
-	return nil
-}
-
-func (t *ClientDealProposal) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{136}); err != nil {
-		return err
-	}
-
-	// t.Data (cid.Cid) (struct)
-
-	if err := cbg.WriteCid(w, t.Data); err != nil {
-		return xerrors.Errorf("failed to write cid field t.Data: %w", err)
-	}
-
-	// t.PricePerEpoch (types.BigInt) (struct)
-	if err := t.PricePerEpoch.MarshalCBOR(w); err != nil {
-		return err
-	}
-
-	// t.ProposalExpiration (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.ProposalExpiration))); err != nil {
-		return err
-	}
-
-	// t.Duration (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.Duration))); err != nil {
-		return err
-	}
-
-	// t.ProviderAddress (address.Address) (struct)
-	if err := t.ProviderAddress.MarshalCBOR(w); err != nil {
-		return err
-	}
-
-	// t.Client (address.Address) (struct)
-	if err := t.Client.MarshalCBOR(w); err != nil {
-		return err
-	}
-
-	// t.MinerWorker (address.Address) (struct)
-	if err := t.MinerWorker.MarshalCBOR(w); err != nil {
-		return err
-	}
-
-	// t.MinerID (peer.ID) (string)
-	if len(t.MinerID) > cbg.MaxLength {
-		return xerrors.Errorf("Value in field t.MinerID was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len(t.MinerID)))); err != nil {
-		return err
-	}
-	if _, err := w.Write([]byte(t.MinerID)); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *ClientDealProposal) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 8 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	// t.Data (cid.Cid) (struct)
-
-	{
-
-		c, err := cbg.ReadCid(br)
-		if err != nil {
-			return xerrors.Errorf("failed to read cid field t.Data: %w", err)
-		}
-
-		t.Data = c
-
-	}
-	// t.PricePerEpoch (types.BigInt) (struct)
-
-	{
-
-		if err := t.PricePerEpoch.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-	}
-	// t.ProposalExpiration (uint64) (uint64)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.ProposalExpiration = uint64(extra)
-	// t.Duration (uint64) (uint64)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.Duration = uint64(extra)
-	// t.ProviderAddress (address.Address) (struct)
-
-	{
-
-		if err := t.ProviderAddress.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-	}
-	// t.Client (address.Address) (struct)
-
-	{
-
-		if err := t.Client.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-	}
-	// t.MinerWorker (address.Address) (struct)
-
-	{
-
-		if err := t.MinerWorker.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-	}
-	// t.MinerID (peer.ID) (string)
-
-	{
-		sval, err := cbg.ReadString(br)
-		if err != nil {
-			return err
-		}
-
-		t.MinerID = peer.ID(sval)
-	}
-	return nil
-}
-
-func (t *ClientDeal) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{135}); err != nil {
-		return err
-	}
-
-	// t.ProposalCid (cid.Cid) (struct)
-
-	if err := cbg.WriteCid(w, t.ProposalCid); err != nil {
-		return xerrors.Errorf("failed to write cid field t.ProposalCid: %w", err)
-	}
-
-	// t.Proposal (actors.StorageDealProposal) (struct)
-	if err := t.Proposal.MarshalCBOR(w); err != nil {
-		return err
-	}
-
-	// t.State (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.State))); err != nil {
-		return err
-	}
-
-	// t.Miner (peer.ID) (string)
-	if len(t.Miner) > cbg.MaxLength {
-		return xerrors.Errorf("Value in field t.Miner was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len(t.Miner)))); err != nil {
-		return err
-	}
-	if _, err := w.Write([]byte(t.Miner)); err != nil {
-		return err
-	}
-
-	// t.MinerWorker (address.Address) (struct)
-	if err := t.MinerWorker.MarshalCBOR(w); err != nil {
-		return err
-	}
-
-	// t.DealID (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.DealID))); err != nil {
-		return err
-	}
-
-	// t.PublishMessage (types.SignedMessage) (struct)
-	if err := t.PublishMessage.MarshalCBOR(w); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *ClientDeal) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 7 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	// t.ProposalCid (cid.Cid) (struct)
-
-	{
-
-		c, err := cbg.ReadCid(br)
-		if err != nil {
-			return xerrors.Errorf("failed to read cid field t.ProposalCid: %w", err)
-		}
-
-		t.ProposalCid = c
-
-	}
-	// t.Proposal (actors.StorageDealProposal) (struct)
-
-	{
-
-		if err := t.Proposal.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-	}
-	// t.State (uint64) (uint64)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.State = uint64(extra)
-	// t.Miner (peer.ID) (string)
-
-	{
-		sval, err := cbg.ReadString(br)
-		if err != nil {
-			return err
-		}
-
-		t.Miner = peer.ID(sval)
-	}
-	// t.MinerWorker (address.Address) (struct)
-
-	{
-
-		if err := t.MinerWorker.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-	}
-	// t.DealID (uint64) (uint64)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.DealID = uint64(extra)
-	// t.PublishMessage (types.SignedMessage) (struct)
-
-	{
-
-		pb, err := br.PeekByte()
-		if err != nil {
-			return err
-		}
-		if pb == cbg.CborNull[0] {
-			var nbuf [1]byte
-			if _, err := br.Read(nbuf[:]); err != nil {
-				return err
-			}
-		} else {
-			t.PublishMessage = new(types.SignedMessage)
-			if err := t.PublishMessage.UnmarshalCBOR(br); err != nil {
-				return err
-			}
-		}
-
-	}
-	return nil
-}
-
-func (t *MinerDeal) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{135}); err != nil {
-		return err
-	}
-
-	// t.Client (peer.ID) (string)
-	if len(t.Client) > cbg.MaxLength {
-		return xerrors.Errorf("Value in field t.Client was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len(t.Client)))); err != nil {
-		return err
-	}
-	if _, err := w.Write([]byte(t.Client)); err != nil {
-		return err
-	}
-
-	// t.Proposal (actors.StorageDealProposal) (struct)
-	if err := t.Proposal.MarshalCBOR(w); err != nil {
-		return err
-	}
-
-	// t.ProposalCid (cid.Cid) (struct)
-
-	if err := cbg.WriteCid(w, t.ProposalCid); err != nil {
-		return xerrors.Errorf("failed to write cid field t.ProposalCid: %w", err)
-	}
-
-	// t.State (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.State))); err != nil {
-		return err
-	}
-
-	// t.Ref (cid.Cid) (struct)
-
-	if err := cbg.WriteCid(w, t.Ref); err != nil {
-		return xerrors.Errorf("failed to write cid field t.Ref: %w", err)
-	}
-
-	// t.DealID (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.DealID))); err != nil {
-		return err
-	}
-
-	// t.SectorID (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.SectorID))); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *MinerDeal) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 7 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	// t.Client (peer.ID) (string)
-
-	{
-		sval, err := cbg.ReadString(br)
-		if err != nil {
-			return err
-		}
-
-		t.Client = peer.ID(sval)
-	}
-	// t.Proposal (actors.StorageDealProposal) (struct)
-
-	{
-
-		if err := t.Proposal.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-	}
-	// t.ProposalCid (cid.Cid) (struct)
-
-	{
-
-		c, err := cbg.ReadCid(br)
-		if err != nil {
-			return xerrors.Errorf("failed to read cid field t.ProposalCid: %w", err)
-		}
-
-		t.ProposalCid = c
-
-	}
-	// t.State (uint64) (uint64)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.State = uint64(extra)
-	// t.Ref (cid.Cid) (struct)
-
-	{
-
-		c, err := cbg.ReadCid(br)
-		if err != nil {
-			return xerrors.Errorf("failed to read cid field t.Ref: %w", err)
-		}
-
-		t.Ref = c
-
-	}
-	// t.DealID (uint64) (uint64)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.DealID = uint64(extra)
-	// t.SectorID (uint64) (uint64)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.SectorID = uint64(extra)
-	return nil
-}
-
-func (t *StorageDataTransferVoucher) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{130}); err != nil {
-		return err
-	}
-
-	// t.Proposal (cid.Cid) (struct)
-
-	if err := cbg.WriteCid(w, t.Proposal); err != nil {
-		return xerrors.Errorf("failed to write cid field t.Proposal: %w", err)
-	}
-
-	// t.DealID (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.DealID))); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *StorageDataTransferVoucher) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 2 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	// t.Proposal (cid.Cid) (struct)
-
-	{
-
-		c, err := cbg.ReadCid(br)
-		if err != nil {
-			return xerrors.Errorf("failed to read cid field t.Proposal: %w", err)
-		}
-
-		t.Proposal = c
-
-	}
-	// t.DealID (uint64) (uint64)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.DealID = uint64(extra)
-	return nil
-}
diff --git a/chain/deals/client.go b/chain/deals/client.go
deleted file mode 100644
index 709432f63..000000000
--- a/chain/deals/client.go
+++ /dev/null
@@ -1,311 +0,0 @@
-package deals
-
-import (
-	"context"
-
-	"github.com/ipfs/go-cid"
-	logging "github.com/ipfs/go-log"
-	"github.com/libp2p/go-libp2p-core/host"
-	inet "github.com/libp2p/go-libp2p-core/network"
-	"github.com/libp2p/go-libp2p-core/peer"
-	"golang.org/x/xerrors"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-cbor-util"
-	"github.com/filecoin-project/go-statestore"
-	"github.com/filecoin-project/lotus/api"
-	"github.com/filecoin-project/lotus/chain/actors"
-	"github.com/filecoin-project/lotus/chain/events"
-	"github.com/filecoin-project/lotus/chain/market"
-	"github.com/filecoin-project/lotus/chain/stmgr"
-	"github.com/filecoin-project/lotus/chain/store"
-	"github.com/filecoin-project/lotus/chain/types"
-	"github.com/filecoin-project/lotus/chain/wallet"
-	"github.com/filecoin-project/lotus/node/impl/full"
-	"github.com/filecoin-project/lotus/node/modules/dtypes"
-	"github.com/filecoin-project/lotus/retrieval/discovery"
-)
-
-var log = logging.Logger("deals")
-
-type ClientDeal struct {
-	ProposalCid cid.Cid
-	Proposal    actors.StorageDealProposal
-	State       api.DealState
-	Miner       peer.ID
-	MinerWorker address.Address
-	DealID      uint64
-
-	PublishMessage *types.SignedMessage
-
-	s inet.Stream
-}
-
-type Client struct {
-	sm    *stmgr.StateManager
-	chain *store.ChainStore
-	h     host.Host
-	w     *wallet.Wallet
-	// dataTransfer
-	// TODO: once the data transfer module is complete, the
-	// client will listen to events on the data transfer module
-	// Because we are using only a fake DAGService
-	// implementation, there's no validation or events on the client side
-	dataTransfer dtypes.ClientDataTransfer
-	dag          dtypes.ClientDAG
-	discovery    *discovery.Local
-	events       *events.Events
-	fm           *market.FundMgr
-
-	deals *statestore.StateStore
-	conns map[cid.Cid]inet.Stream
-
-	incoming chan *ClientDeal
-	updated  chan clientDealUpdate
-
-	stop    chan struct{}
-	stopped chan struct{}
-}
-
-type clientDealUpdate struct {
-	newState api.DealState
-	id       cid.Cid
-	err      error
-	mut      func(*ClientDeal)
-}
-
-type clientApi struct {
-	full.ChainAPI
-	full.StateAPI
-}
-
-func NewClient(sm *stmgr.StateManager, chain *store.ChainStore, h host.Host, w *wallet.Wallet, dag dtypes.ClientDAG, dataTransfer dtypes.ClientDataTransfer, discovery *discovery.Local, fm *market.FundMgr, deals dtypes.ClientDealStore, chainapi full.ChainAPI, stateapi full.StateAPI) *Client {
-	c := &Client{
-		sm:           sm,
-		chain:        chain,
-		h:            h,
-		w:            w,
-		dataTransfer: dataTransfer,
-		dag:          dag,
-		discovery:    discovery,
-		fm:           fm,
-		events:       events.NewEvents(context.TODO(), &clientApi{chainapi, stateapi}),
-
-		deals: deals,
-		conns: map[cid.Cid]inet.Stream{},
-
-		incoming: make(chan *ClientDeal, 16),
-		updated:  make(chan clientDealUpdate, 16),
-
-		stop:    make(chan struct{}),
-		stopped: make(chan struct{}),
-	}
-
-	return c
-}
-
-func (c *Client) Run(ctx context.Context) {
-	go func() {
-		defer close(c.stopped)
-
-		for {
-			select {
-			case deal := <-c.incoming:
-				c.onIncoming(deal)
-			case update := <-c.updated:
-				c.onUpdated(ctx, update)
-			case <-c.stop:
-				return
-			}
-		}
-	}()
-}
-
-func (c *Client) onIncoming(deal *ClientDeal) {
-	log.Info("incoming deal")
-
-	if _, ok := c.conns[deal.ProposalCid]; ok {
-		log.Errorf("tracking deal connection: already tracking connection for deal %s", deal.ProposalCid)
-		return
-	}
-	c.conns[deal.ProposalCid] = deal.s
-
-	if err := c.deals.Begin(deal.ProposalCid, deal); err != nil {
-		// We may have re-sent the proposal
-		log.Errorf("deal tracking failed: %s", err)
-		c.failDeal(deal.ProposalCid, err)
-		return
-	}
-
-	go func() {
-		c.updated <- clientDealUpdate{
-			newState: api.DealUnknown,
-			id:       deal.ProposalCid,
-			err:      nil,
-		}
-	}()
-}
-
-func (c *Client) onUpdated(ctx context.Context, update clientDealUpdate) {
-	log.Infof("Client deal %s updated state to %s", update.id, api.DealStates[update.newState])
-	var deal ClientDeal
-	err := c.deals.Mutate(update.id, func(d *ClientDeal) error {
-		d.State = update.newState
-		if update.mut != nil {
-			update.mut(d)
-		}
-		deal = *d
-		return nil
-	})
-	if update.err != nil {
-		log.Errorf("deal %s failed: %s", update.id, update.err)
-		c.failDeal(update.id, update.err)
-		return
-	}
-	if err != nil {
-		c.failDeal(update.id, err)
-		return
-	}
-
-	switch update.newState {
-	case api.DealUnknown: // new
-		c.handle(ctx, deal, c.new, api.DealAccepted)
-	case api.DealAccepted:
-		c.handle(ctx, deal, c.accepted, api.DealStaged)
-	case api.DealStaged:
-		c.handle(ctx, deal, c.staged, api.DealSealing)
-	case api.DealSealing:
-		c.handle(ctx, deal, c.sealing, api.DealNoUpdate)
-		// TODO: DealComplete -> watch for faults, expiration, etc.
-	}
-}
-
-type ClientDealProposal struct {
-	Data cid.Cid
-
-	PricePerEpoch      types.BigInt
-	ProposalExpiration uint64
-	Duration           uint64
-
-	ProviderAddress address.Address
-	Client          address.Address
-	MinerWorker     address.Address
-	MinerID         peer.ID
-}
-
-func (c *Client) Start(ctx context.Context, p ClientDealProposal) (cid.Cid, error) {
-	if err := c.fm.EnsureAvailable(ctx, p.Client, types.BigMul(p.PricePerEpoch, types.NewInt(p.Duration))); err != nil {
-		return cid.Undef, xerrors.Errorf("adding market funds failed: %w", err)
-	}
-
-	commP, pieceSize, err := c.commP(ctx, p.Data)
-	if err != nil {
-		return cid.Undef, xerrors.Errorf("computing commP failed: %w", err)
-	}
-
-	dealProposal := &actors.StorageDealProposal{
-		PieceRef:             commP,
-		PieceSize:            uint64(pieceSize),
-		Client:               p.Client,
-		Provider:             p.ProviderAddress,
-		ProposalExpiration:   p.ProposalExpiration,
-		Duration:             p.Duration,
-		StoragePricePerEpoch: p.PricePerEpoch,
-		StorageCollateral:    types.NewInt(uint64(pieceSize)), // TODO: real calc
-	}
-
-	if err := api.SignWith(ctx, c.w.Sign, p.Client, dealProposal); err != nil {
-		return cid.Undef, xerrors.Errorf("signing deal proposal failed: %w", err)
-	}
-
-	proposalNd, err := cborutil.AsIpld(dealProposal)
-	if err != nil {
-		return cid.Undef, xerrors.Errorf("getting proposal node failed: %w", err)
-	}
-
-	s, err := c.h.NewStream(ctx, p.MinerID, DealProtocolID)
-	if err != nil {
-		return cid.Undef, xerrors.Errorf("connecting to storage provider failed: %w", err)
-	}
-
-	proposal := &Proposal{
-		DealProposal: dealProposal,
-		Piece:        p.Data,
-	}
-
-	if err := cborutil.WriteCborRPC(s, proposal); err != nil {
-		s.Reset()
-		return cid.Undef, xerrors.Errorf("sending proposal to storage provider failed: %w", err)
-	}
-
-	deal := &ClientDeal{
-		ProposalCid: proposalNd.Cid(),
-		Proposal:    *dealProposal,
-		State:       api.DealUnknown,
-		Miner:       p.MinerID,
-		MinerWorker: p.MinerWorker,
-
-		s: s,
-	}
-
-	c.incoming <- deal
-
-	return deal.ProposalCid, c.discovery.AddPeer(p.Data, discovery.RetrievalPeer{
-		Address: dealProposal.Provider,
-		ID:      deal.Miner,
-	})
-}
-
-func (c *Client) QueryAsk(ctx context.Context, p peer.ID, a address.Address) (*types.SignedStorageAsk, error) {
-	s, err := c.h.NewStream(ctx, p, AskProtocolID)
-	if err != nil {
-		return nil, xerrors.Errorf("failed to open stream to miner: %w", err)
-	}
-
-	req := &AskRequest{
-		Miner: a,
-	}
-	if err := cborutil.WriteCborRPC(s, req); err != nil {
-		return nil, xerrors.Errorf("failed to send ask request: %w", err)
-	}
-
-	var out AskResponse
-	if err := cborutil.ReadCborRPC(s, &out); err != nil {
-		return nil, xerrors.Errorf("failed to read ask response: %w", err)
-	}
-
-	if out.Ask == nil {
-		return nil, xerrors.Errorf("got no ask back")
-	}
-
-	if out.Ask.Ask.Miner != a {
-		return nil, xerrors.Errorf("got back ask for wrong miner")
-	}
-
-	if err := c.checkAskSignature(out.Ask); err != nil {
-		return nil, xerrors.Errorf("ask was not properly signed")
-	}
-
-	return out.Ask, nil
-}
-
-func (c *Client) List() ([]ClientDeal, error) {
-	var out []ClientDeal
-	if err := c.deals.List(&out); err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-func (c *Client) GetDeal(d cid.Cid) (*ClientDeal, error) {
-	var out ClientDeal
-	if err := c.deals.Get(d, &out); err != nil {
-		return nil, err
-	}
-	return &out, nil
-}
-
-func (c *Client) Stop() {
-	close(c.stop)
-	<-c.stopped
-}
diff --git a/chain/deals/client_states.go b/chain/deals/client_states.go
deleted file mode 100644
index d19765f60..000000000
--- a/chain/deals/client_states.go
+++ /dev/null
@@ -1,233 +0,0 @@
-package deals
-
-import (
-	"bytes"
-	"context"
-
-	"golang.org/x/xerrors"
-
-	"github.com/filecoin-project/go-cbor-util"
-	"github.com/filecoin-project/lotus/api"
-	"github.com/filecoin-project/lotus/build"
-	"github.com/filecoin-project/lotus/chain/actors"
-	"github.com/filecoin-project/lotus/chain/stmgr"
-	"github.com/filecoin-project/lotus/chain/types"
-)
-
-type clientHandlerFunc func(ctx context.Context, deal ClientDeal) (func(*ClientDeal), error)
-
-func (c *Client) handle(ctx context.Context, deal ClientDeal, cb clientHandlerFunc, next api.DealState) {
-	go func() {
-		mut, err := cb(ctx, deal)
-		if err != nil {
-			next = api.DealError
-		}
-
-		if err == nil && next == api.DealNoUpdate {
-			return
-		}
-
-		select {
-		case c.updated <- clientDealUpdate{
-			newState: next,
-			id:       deal.ProposalCid,
-			err:      err,
-			mut:      mut,
-		}:
-		case <-c.stop:
-		}
-	}()
-}
-
-func (c *Client) new(ctx context.Context, deal ClientDeal) (func(*ClientDeal), error) {
-	resp, err := c.readStorageDealResp(deal)
-	if err != nil {
-		return nil, err
-	}
-
-	// TODO: verify StorageDealSubmission
-
-	if err := c.disconnect(deal); err != nil {
-		return nil, err
-	}
-
-	/* data transfer happens */
-	if resp.State != api.DealAccepted {
-		return nil, xerrors.Errorf("deal wasn't accepted (State=%d)", resp.State)
-	}
-
-	return func(info *ClientDeal) {
-		info.PublishMessage = resp.StorageDealSubmission
-	}, nil
-}
-
-func (c *Client) accepted(ctx context.Context, deal ClientDeal) (func(*ClientDeal), error) {
-	log.Infow("DEAL ACCEPTED!")
-
-	pubmsg := deal.PublishMessage.Message
-	pw, err := stmgr.GetMinerWorker(ctx, c.sm, nil, deal.Proposal.Provider)
-	if err != nil {
-		return nil, xerrors.Errorf("getting miner worker failed: %w", err)
-	}
-
-	if pubmsg.From != pw {
-		return nil, xerrors.Errorf("deal wasn't published by storage provider: from=%s, provider=%s", pubmsg.From, deal.Proposal.Provider)
-	}
-
-	if pubmsg.To != actors.StorageMarketAddress {
-		return nil, xerrors.Errorf("deal publish message wasn't set to StorageMarket actor (to=%s)", pubmsg.To)
-	}
-
-	if pubmsg.Method != actors.SMAMethods.PublishStorageDeals {
-		return nil, xerrors.Errorf("deal publish message called incorrect method (method=%s)", pubmsg.Method)
-	}
-
-	var params actors.PublishStorageDealsParams
-	if err := params.UnmarshalCBOR(bytes.NewReader(pubmsg.Params)); err != nil {
-		return nil, err
-	}
-
-	dealIdx := -1
-	for i, storageDeal := range params.Deals {
-		// TODO: make it less hacky
-		sd := storageDeal
-		eq, err := cborutil.Equals(&deal.Proposal, &sd)
-		if err != nil {
-			return nil, err
-		}
-		if eq {
-			dealIdx = i
-			break
-		}
-	}
-
-	if dealIdx == -1 {
-		return nil, xerrors.Errorf("deal publish didn't contain our deal (message cid: %s)", deal.PublishMessage.Cid())
-	}
-
-	// TODO: timeout
-	_, ret, err := c.sm.WaitForMessage(ctx, deal.PublishMessage.Cid())
-	if err != nil {
-		return nil, xerrors.Errorf("waiting for deal publish message: %w", err)
-	}
-	if ret.ExitCode != 0 {
-		return nil, xerrors.Errorf("deal publish failed: exit=%d", ret.ExitCode)
-	}
-
-	var res actors.PublishStorageDealResponse
-	if err := res.UnmarshalCBOR(bytes.NewReader(ret.Return)); err != nil {
-		return nil, err
-	}
-
-	return func(info *ClientDeal) {
-		info.DealID = res.DealIDs[dealIdx]
-	}, nil
-}
-
-func (c *Client) staged(ctx context.Context, deal ClientDeal) (func(*ClientDeal), error) {
-	// TODO: Maybe wait for pre-commit
-
-	return nil, nil
-}
-
-func (c *Client) sealing(ctx context.Context, deal ClientDeal) (func(*ClientDeal), error) {
-	checkFunc := func(ts *types.TipSet) (done bool, more bool, err error) {
-		sd, err := stmgr.GetStorageDeal(ctx, c.sm, deal.DealID, ts)
-		if err != nil {
-			// TODO: This may be fine for some errors
-			return false, false, xerrors.Errorf("failed to look up deal on chain: %w", err)
-		}
-
-		if sd.ActivationEpoch > 0 {
-			select {
-			case c.updated <- clientDealUpdate{
-				newState: api.DealComplete,
-				id:       deal.ProposalCid,
-			}:
-			case <-c.stop:
-			}
-
-			return true, false, nil
-		}
-
-		return false, true, nil
-	}
-
-	called := func(msg *types.Message, rec *types.MessageReceipt, ts *types.TipSet, curH uint64) (more bool, err error) {
-		defer func() {
-			if err != nil {
-				select {
-				case c.updated <- clientDealUpdate{
-					newState: api.DealComplete,
-					id:       deal.ProposalCid,
-					err:      xerrors.Errorf("handling applied event: %w", err),
-				}:
-				case <-c.stop:
-				}
-			}
-		}()
-
-		if msg == nil {
-			log.Error("timed out waiting for deal activation... what now?")
-			return false, nil
-		}
-
-		sd, err := stmgr.GetStorageDeal(ctx, c.sm, deal.DealID, ts)
-		if err != nil {
-			return false, xerrors.Errorf("failed to look up deal on chain: %w", err)
-		}
-
-		if sd.ActivationEpoch == 0 {
-			return false, xerrors.Errorf("deal wasn't active: deal=%d, parentState=%s, h=%d", deal.DealID, ts.ParentState(), ts.Height())
-		}
-
-		log.Infof("Storage deal %d activated at epoch %d", deal.DealID, sd.ActivationEpoch)
-
-		select {
-		case c.updated <- clientDealUpdate{
-			newState: api.DealComplete,
-			id:       deal.ProposalCid,
-		}:
-		case <-c.stop:
-		}
-
-		return false, nil
-	}
-
-	revert := func(ctx context.Context, ts *types.TipSet) error {
-		log.Warn("deal activation reverted; TODO: actually handle this!")
-		// TODO: Just go back to DealSealing?
-		return nil
-	}
-
-	matchEvent := func(msg *types.Message) (bool, error) {
-		if msg.To != deal.Proposal.Provider {
-			return false, nil
-		}
-
-		if msg.Method != actors.MAMethods.ProveCommitSector {
-			return false, nil
-		}
-
-		var params actors.SectorProveCommitInfo
-		if err := params.UnmarshalCBOR(bytes.NewReader(msg.Params)); err != nil {
-			return false, err
-		}
-
-		var found bool
-		for _, dealID := range params.DealIDs {
-			if dealID == deal.DealID {
-				found = true
-				break
-			}
-		}
-
-		return found, nil
-	}
-
-	if err := c.events.Called(checkFunc, called, revert, 3, build.SealRandomnessLookbackLimit, matchEvent); err != nil {
-		return nil, xerrors.Errorf("failed to set up called handler")
-	}
-
-	return nil, nil
-}
diff --git a/chain/deals/client_utils.go b/chain/deals/client_utils.go
deleted file mode 100644
index 944846ed0..000000000
--- a/chain/deals/client_utils.go
+++ /dev/null
@@ -1,171 +0,0 @@
-package deals
-
-import (
-	"bytes"
-	"context"
-	"runtime"
-
-	sectorbuilder "github.com/filecoin-project/go-sectorbuilder"
-	"github.com/ipfs/go-cid"
-	files "github.com/ipfs/go-ipfs-files"
-	unixfile "github.com/ipfs/go-unixfs/file"
-	"github.com/ipld/go-ipld-prime"
-	"github.com/libp2p/go-libp2p-core/peer"
-	"golang.org/x/xerrors"
-
-	cborutil "github.com/filecoin-project/go-cbor-util"
-	"github.com/filecoin-project/go-statestore"
-
-	"github.com/filecoin-project/lotus/datatransfer"
-	"github.com/filecoin-project/lotus/lib/padreader"
-	"github.com/filecoin-project/lotus/node/modules/dtypes"
-)
-
-func (c *Client) failDeal(id cid.Cid, cerr error) {
-	if cerr == nil {
-		_, f, l, _ := runtime.Caller(1)
-		cerr = xerrors.Errorf("unknown error (fail called at %s:%d)", f, l)
-	}
-
-	s, ok := c.conns[id]
-	if ok {
-		_ = s.Reset()
-		delete(c.conns, id)
-	}
-
-	// TODO: store in some sort of audit log
-	log.Errorf("deal %s failed: %+v", id, cerr)
-}
-
-func (c *Client) commP(ctx context.Context, data cid.Cid) ([]byte, uint64, error) {
-	root, err := c.dag.Get(ctx, data)
-	if err != nil {
-		log.Errorf("failed to get file root for deal: %s", err)
-		return nil, 0, err
-	}
-
-	n, err := unixfile.NewUnixfsFile(ctx, c.dag, root)
-	if err != nil {
-		log.Errorf("cannot open unixfs file: %s", err)
-		return nil, 0, err
-	}
-
-	uf, ok := n.(files.File)
-	if !ok {
-		// TODO: we probably got directory, how should we handle this in unixfs mode?
-		return nil, 0, xerrors.New("unsupported unixfs type")
-	}
-
-	s, err := uf.Size()
-	if err != nil {
-		return nil, 0, err
-	}
-
-	pr, psize := padreader.New(uf, uint64(s))
-
-	commp, err := sectorbuilder.GeneratePieceCommitment(pr, psize)
-	if err != nil {
-		return nil, 0, xerrors.Errorf("generating CommP: %w", err)
-	}
-
-	return commp[:], psize, nil
-}
-
-func (c *Client) readStorageDealResp(deal ClientDeal) (*Response, error) {
-	s, ok := c.conns[deal.ProposalCid]
-	if !ok {
-		// TODO: Try to re-establish the connection using query protocol
-		return nil, xerrors.Errorf("no connection to miner")
-	}
-
-	var resp SignedResponse
-	if err := cborutil.ReadCborRPC(s, &resp); err != nil {
-		log.Errorw("failed to read Response message", "error", err)
-		return nil, err
-	}
-
-	if err := resp.Verify(deal.MinerWorker); err != nil {
-		return nil, xerrors.Errorf("verifying response signature failed", err)
-	}
-
-	if resp.Response.Proposal != deal.ProposalCid {
-		return nil, xerrors.Errorf("miner responded to a wrong proposal: %s != %s", resp.Response.Proposal, deal.ProposalCid)
-	}
-
-	return &resp.Response, nil
-}
-
-func (c *Client) disconnect(deal ClientDeal) error {
-	s, ok := c.conns[deal.ProposalCid]
-	if !ok {
-		return nil
-	}
-
-	err := s.Close()
-	delete(c.conns, deal.ProposalCid)
-	return err
-}
-
-var _ datatransfer.RequestValidator = &ClientRequestValidator{}
-
-// ClientRequestValidator validates data transfer requests for the client
-// in a storage market
-type ClientRequestValidator struct {
-	deals *statestore.StateStore
-}
-
-// NewClientRequestValidator returns a new client request validator for the
-// given datastore
-func NewClientRequestValidator(deals dtypes.ClientDealStore) *ClientRequestValidator {
-	crv := &ClientRequestValidator{
-		deals: deals,
-	}
-	return crv
-}
-
-// ValidatePush validates a push request received from the peer that will send data
-// Will always error because clients should not accept push requests from a provider
-// in a storage deal (i.e. send data to client).
-func (c *ClientRequestValidator) ValidatePush(
-	sender peer.ID,
-	voucher datatransfer.Voucher,
-	baseCid cid.Cid,
-	Selector ipld.Node) error {
-	return ErrNoPushAccepted
-}
-
-// ValidatePull validates a pull request received from the peer that will receive data
-// Will succeed only if:
-// - voucher has correct type
-// - voucher references an active deal
-// - referenced deal matches the receiver (miner)
-// - referenced deal matches the given base CID
-// - referenced deal is in an acceptable state
-func (c *ClientRequestValidator) ValidatePull(
-	receiver peer.ID,
-	voucher datatransfer.Voucher,
-	baseCid cid.Cid,
-	Selector ipld.Node) error {
-	dealVoucher, ok := voucher.(*StorageDataTransferVoucher)
-	if !ok {
-		return xerrors.Errorf("voucher type %s: %w", voucher.Identifier(), ErrWrongVoucherType)
-	}
-
-	var deal ClientDeal
-	err := c.deals.Get(dealVoucher.Proposal, &deal)
-	if err != nil {
-		return xerrors.Errorf("Proposal CID %s: %w", dealVoucher.Proposal.String(), ErrNoDeal)
-	}
-	if deal.Miner != receiver {
-		return xerrors.Errorf("Deal Peer %s, Data Transfer Peer %s: %w", deal.Miner.String(), receiver.String(), ErrWrongPeer)
-	}
-	if !bytes.Equal(deal.Proposal.PieceRef, baseCid.Bytes()) {
-		return xerrors.Errorf("Deal Payload CID %s, Data Transfer CID %s: %w", string(deal.Proposal.PieceRef), baseCid.String(), ErrWrongPiece)
-	}
-	for _, state := range DataTransferStates {
-		if deal.State == state {
-			return nil
-		}
-	}
-	return xerrors.Errorf("Deal State %s: %w", deal.State, ErrInacceptableDealState)
-}
diff --git a/chain/deals/provider.go b/chain/deals/provider.go
deleted file mode 100644
index 9e45ef8b2..000000000
--- a/chain/deals/provider.go
+++ /dev/null
@@ -1,294 +0,0 @@
-package deals
-
-import (
-	"context"
-	"errors"
-	"sync"
-
-	cid "github.com/ipfs/go-cid"
-	datastore "github.com/ipfs/go-datastore"
-	"github.com/ipfs/go-datastore/namespace"
-	inet "github.com/libp2p/go-libp2p-core/network"
-	"github.com/libp2p/go-libp2p-core/peer"
-	"golang.org/x/xerrors"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-cbor-util"
-	"github.com/filecoin-project/go-statestore"
-	"github.com/filecoin-project/lotus/api"
-	"github.com/filecoin-project/lotus/chain/actors"
-	"github.com/filecoin-project/lotus/chain/types"
-	"github.com/filecoin-project/lotus/datatransfer"
-	"github.com/filecoin-project/lotus/node/modules/dtypes"
-	"github.com/filecoin-project/lotus/storage"
-	"github.com/filecoin-project/lotus/storage/sectorblocks"
-)
-
-var ProviderDsPrefix = "/deals/provider"
-
-type MinerDeal struct {
-	Client      peer.ID
-	Proposal    actors.StorageDealProposal
-	ProposalCid cid.Cid
-	State       api.DealState
-
-	Ref cid.Cid
-
-	DealID   uint64
-	SectorID uint64 // Set when State >= DealStaged
-
-	s inet.Stream
-}
-
-type Provider struct {
-	pricePerByteBlock types.BigInt // how much we want for storing one byte for one block
-	minPieceSize      uint64
-
-	ask   *types.SignedStorageAsk
-	askLk sync.Mutex
-
-	secb   *sectorblocks.SectorBlocks
-	sminer *storage.Miner
-	full   api.FullNode
-
-	// TODO: This will go away once storage market module + CAR
-	// is implemented
-	dag dtypes.StagingDAG
-
-	// dataTransfer is the manager of data transfers used by this storage provider
-	dataTransfer dtypes.ProviderDataTransfer
-
-	deals *statestore.StateStore
-	ds    dtypes.MetadataDS
-
-	conns map[cid.Cid]inet.Stream
-
-	actor address.Address
-
-	incoming chan MinerDeal
-	updated  chan minerDealUpdate
-	stop     chan struct{}
-	stopped  chan struct{}
-}
-
-type minerDealUpdate struct {
-	newState api.DealState
-	id       cid.Cid
-	err      error
-	mut      func(*MinerDeal)
-}
-
-var (
-	// ErrDataTransferFailed means a data transfer for a deal failed
-	ErrDataTransferFailed = errors.New("deal data transfer failed")
-)
-
-func NewProvider(ds dtypes.MetadataDS, sminer *storage.Miner, secb *sectorblocks.SectorBlocks, dag dtypes.StagingDAG, dataTransfer dtypes.ProviderDataTransfer, fullNode api.FullNode) (*Provider, error) {
-	addr, err := ds.Get(datastore.NewKey("miner-address"))
-	if err != nil {
-		return nil, err
-	}
-	minerAddress, err := address.NewFromBytes(addr)
-	if err != nil {
-		return nil, err
-	}
-
-	h := &Provider{
-		sminer:       sminer,
-		dag:          dag,
-		dataTransfer: dataTransfer,
-		full:         fullNode,
-		secb:         secb,
-
-		pricePerByteBlock: types.NewInt(3), // TODO: allow setting
-		minPieceSize:      256,             // TODO: allow setting (BUT KEEP MIN 256! (because of how we fill sectors up))
-
-		conns: map[cid.Cid]inet.Stream{},
-
-		incoming: make(chan MinerDeal),
-		updated:  make(chan minerDealUpdate),
-		stop:     make(chan struct{}),
-		stopped:  make(chan struct{}),
-
-		actor: minerAddress,
-
-		deals: statestore.New(namespace.Wrap(ds, datastore.NewKey(ProviderDsPrefix))),
-		ds:    ds,
-	}
-
-	if err := h.tryLoadAsk(); err != nil {
-		return nil, err
-	}
-
-	if h.ask == nil {
-		// TODO: we should be fine with this state, and just say it means 'not actively accepting deals'
-		// for now... lets just set a price
-		if err := h.SetPrice(types.NewInt(500_000_000), 1000000); err != nil {
-			return nil, xerrors.Errorf("failed setting a default price: %w", err)
-		}
-	}
-
-	// register a data transfer event handler -- this will move deals from
-	// accepted to staged
-	h.dataTransfer.SubscribeToEvents(h.onDataTransferEvent)
-
-	return h, nil
-}
-
-func (p *Provider) Run(ctx context.Context) {
-	// TODO: restore state
-
-	go func() {
-		defer log.Warn("quitting deal provider loop")
-		defer close(p.stopped)
-
-		for {
-			select {
-			case deal := <-p.incoming: // DealAccepted
-				p.onIncoming(deal)
-			case update := <-p.updated: // DealStaged
-				p.onUpdated(ctx, update)
-			case <-p.stop:
-				return
-			}
-		}
-	}()
-}
-
-func (p *Provider) onIncoming(deal MinerDeal) {
-	log.Info("incoming deal")
-
-	p.conns[deal.ProposalCid] = deal.s
-
-	if err := p.deals.Begin(deal.ProposalCid, &deal); err != nil {
-		// This can happen when client re-sends proposal
-		p.failDeal(deal.ProposalCid, err)
-		log.Errorf("deal tracking failed: %s", err)
-		return
-	}
-
-	go func() {
-		p.updated <- minerDealUpdate{
-			newState: api.DealAccepted,
-			id:       deal.ProposalCid,
-			err:      nil,
-		}
-	}()
-}
-
-func (p *Provider) onUpdated(ctx context.Context, update minerDealUpdate) {
-	log.Infof("Deal %s updated state to %s", update.id, api.DealStates[update.newState])
-	if update.err != nil {
-		log.Errorf("deal %s (newSt: %d) failed: %+v", update.id, update.newState, update.err)
-		p.failDeal(update.id, update.err)
-		return
-	}
-	var deal MinerDeal
-	err := p.deals.Mutate(update.id, func(d *MinerDeal) error {
-		d.State = update.newState
-		if update.mut != nil {
-			update.mut(d)
-		}
-		deal = *d
-		return nil
-	})
-	if err != nil {
-		p.failDeal(update.id, err)
-		return
-	}
-
-	switch update.newState {
-	case api.DealAccepted:
-		p.handle(ctx, deal, p.accept, api.DealNoUpdate)
-	case api.DealStaged:
-		p.handle(ctx, deal, p.staged, api.DealSealing)
-	case api.DealSealing:
-		p.handle(ctx, deal, p.sealing, api.DealComplete)
-	case api.DealComplete:
-		p.handle(ctx, deal, p.complete, api.DealNoUpdate)
-	}
-}
-
-// onDataTransferEvent is the function called when an event occurs in a data
-// transfer -- it reads the voucher to verify this even occurred in a storage
-// market deal, then, based on the data transfer event that occurred, it generates
-// and update message for the deal -- either moving to staged for a completion
-// event or moving to error if a data transfer error occurs
-func (p *Provider) onDataTransferEvent(event datatransfer.Event, channelState datatransfer.ChannelState) {
-	voucher, ok := channelState.Voucher().(*StorageDataTransferVoucher)
-	// if this event is for a transfer not related to storage, ignore
-	if !ok {
-		return
-	}
-
-	// data transfer events for opening and progress do not affect deal state
-	var next api.DealState
-	var err error
-	var mut func(*MinerDeal)
-	switch event {
-	case datatransfer.Complete:
-		next = api.DealStaged
-		mut = func(deal *MinerDeal) {
-			deal.DealID = voucher.DealID
-		}
-	case datatransfer.Error:
-		next = api.DealFailed
-		err = ErrDataTransferFailed
-	default:
-		// the only events we care about are complete and error
-		return
-	}
-
-	select {
-	case p.updated <- minerDealUpdate{
-		newState: next,
-		id:       voucher.Proposal,
-		err:      err,
-		mut:      mut,
-	}:
-	case <-p.stop:
-	}
-}
-
-func (p *Provider) newDeal(s inet.Stream, proposal Proposal) (MinerDeal, error) {
-	proposalNd, err := cborutil.AsIpld(proposal.DealProposal)
-	if err != nil {
-		return MinerDeal{}, err
-	}
-
-	return MinerDeal{
-		Client:      s.Conn().RemotePeer(),
-		Proposal:    *proposal.DealProposal,
-		ProposalCid: proposalNd.Cid(),
-		State:       api.DealUnknown,
-
-		Ref: proposal.Piece,
-
-		s: s,
-	}, nil
-}
-
-func (p *Provider) HandleStream(s inet.Stream) {
-	log.Info("Handling storage deal proposal!")
-
-	proposal, err := p.readProposal(s)
-	if err != nil {
-		log.Error(err)
-		s.Close()
-		return
-	}
-
-	deal, err := p.newDeal(s, proposal)
-	if err != nil {
-		log.Errorf("%+v", err)
-		s.Close()
-		return
-	}
-
-	p.incoming <- deal
-}
-
-func (p *Provider) Stop() {
-	close(p.stop)
-	<-p.stopped
-}
diff --git a/chain/deals/provider_asks.go b/chain/deals/provider_asks.go
deleted file mode 100644
index 1170eb28b..000000000
--- a/chain/deals/provider_asks.go
+++ /dev/null
@@ -1,160 +0,0 @@
-package deals
-
-import (
-	"bytes"
-	"context"
-	"time"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-cbor-util"
-	"github.com/filecoin-project/lotus/chain/stmgr"
-	"github.com/filecoin-project/lotus/chain/types"
-	datastore "github.com/ipfs/go-datastore"
-	inet "github.com/libp2p/go-libp2p-core/network"
-	"golang.org/x/xerrors"
-)
-
-func (p *Provider) SetPrice(price types.BigInt, ttlsecs int64) error {
-	p.askLk.Lock()
-	defer p.askLk.Unlock()
-
-	var seqno uint64
-	if p.ask != nil {
-		seqno = p.ask.Ask.SeqNo + 1
-	}
-
-	now := time.Now().Unix()
-	ask := &types.StorageAsk{
-		Price:        price,
-		Timestamp:    uint64(now),
-		Expiry:       uint64(now + ttlsecs),
-		Miner:        p.actor,
-		SeqNo:        seqno,
-		MinPieceSize: p.minPieceSize,
-	}
-
-	ssa, err := p.signAsk(ask)
-	if err != nil {
-		return err
-	}
-
-	return p.saveAsk(ssa)
-}
-
-func (p *Provider) getAsk(m address.Address) *types.SignedStorageAsk {
-	p.askLk.Lock()
-	defer p.askLk.Unlock()
-	if m != p.actor {
-		return nil
-	}
-
-	return p.ask
-}
-
-func (p *Provider) HandleAskStream(s inet.Stream) {
-	defer s.Close()
-	var ar AskRequest
-	if err := cborutil.ReadCborRPC(s, &ar); err != nil {
-		log.Errorf("failed to read AskRequest from incoming stream: %s", err)
-		return
-	}
-
-	resp := p.processAskRequest(&ar)
-
-	if err := cborutil.WriteCborRPC(s, resp); err != nil {
-		log.Errorf("failed to write ask response: %s", err)
-		return
-	}
-}
-
-func (p *Provider) processAskRequest(ar *AskRequest) *AskResponse {
-	return &AskResponse{
-		Ask: p.getAsk(ar.Miner),
-	}
-}
-
-var bestAskKey = datastore.NewKey("latest-ask")
-
-func (p *Provider) tryLoadAsk() error {
-	p.askLk.Lock()
-	defer p.askLk.Unlock()
-
-	err := p.loadAsk()
-	if err != nil {
-		if xerrors.Is(err, datastore.ErrNotFound) {
-			log.Warn("no previous ask found, miner will not accept deals until a price is set")
-			return nil
-		}
-		return err
-	}
-
-	return nil
-}
-
-func (p *Provider) loadAsk() error {
-	askb, err := p.ds.Get(datastore.NewKey("latest-ask"))
-	if err != nil {
-		return xerrors.Errorf("failed to load most recent ask from disk: %w", err)
-	}
-
-	var ssa types.SignedStorageAsk
-	if err := cborutil.ReadCborRPC(bytes.NewReader(askb), &ssa); err != nil {
-		return err
-	}
-
-	p.ask = &ssa
-	return nil
-}
-
-func (p *Provider) signAsk(a *types.StorageAsk) (*types.SignedStorageAsk, error) {
-	b, err := cborutil.Dump(a)
-	if err != nil {
-		return nil, err
-	}
-
-	worker, err := p.getWorker(p.actor)
-	if err != nil {
-		return nil, xerrors.Errorf("failed to get worker to sign ask: %w", err)
-	}
-
-	sig, err := p.full.WalletSign(context.TODO(), worker, b)
-	if err != nil {
-		return nil, err
-	}
-
-	return &types.SignedStorageAsk{
-		Ask:       a,
-		Signature: sig,
-	}, nil
-}
-
-func (p *Provider) saveAsk(a *types.SignedStorageAsk) error {
-	b, err := cborutil.Dump(a)
-	if err != nil {
-		return err
-	}
-
-	if err := p.ds.Put(bestAskKey, b); err != nil {
-		return err
-	}
-
-	p.ask = a
-	return nil
-}
-
-func (c *Client) checkAskSignature(ask *types.SignedStorageAsk) error {
-	tss := c.sm.ChainStore().GetHeaviestTipSet().ParentState()
-
-	w, err := stmgr.GetMinerWorkerRaw(context.TODO(), c.sm, tss, ask.Ask.Miner)
-	if err != nil {
-		return xerrors.Errorf("failed to get worker for miner in ask", err)
-	}
-
-	sigb, err := cborutil.Dump(ask.Ask)
-	if err != nil {
-		return xerrors.Errorf("failed to re-serialize ask")
-	}
-
-	return ask.Signature.Verify(w, sigb)
-
-}
diff --git a/chain/deals/provider_states.go b/chain/deals/provider_states.go
deleted file mode 100644
index 4faa44973..000000000
--- a/chain/deals/provider_states.go
+++ /dev/null
@@ -1,215 +0,0 @@
-package deals
-
-import (
-	"bytes"
-	"context"
-
-	ipldfree "github.com/ipld/go-ipld-prime/impl/free"
-	"github.com/ipld/go-ipld-prime/traversal/selector"
-	"github.com/ipld/go-ipld-prime/traversal/selector/builder"
-
-	unixfile "github.com/ipfs/go-unixfs/file"
-	"golang.org/x/xerrors"
-
-	"github.com/filecoin-project/lotus/api"
-	"github.com/filecoin-project/lotus/chain/actors"
-	"github.com/filecoin-project/lotus/chain/types"
-	"github.com/filecoin-project/lotus/lib/padreader"
-	"github.com/filecoin-project/lotus/storage/sectorblocks"
-)
-
-type providerHandlerFunc func(ctx context.Context, deal MinerDeal) (func(*MinerDeal), error)
-
-func (p *Provider) handle(ctx context.Context, deal MinerDeal, cb providerHandlerFunc, next api.DealState) {
-	go func() {
-		mut, err := cb(ctx, deal)
-
-		if err == nil && next == api.DealNoUpdate {
-			return
-		}
-
-		select {
-		case p.updated <- minerDealUpdate{
-			newState: next,
-			id:       deal.ProposalCid,
-			err:      err,
-			mut:      mut,
-		}:
-		case <-p.stop:
-		}
-	}()
-}
-
-// ACCEPTED
-func (p *Provider) accept(ctx context.Context, deal MinerDeal) (func(*MinerDeal), error) {
-
-	head, err := p.full.ChainHead(ctx)
-	if err != nil {
-		return nil, err
-	}
-	if head.Height() >= deal.Proposal.ProposalExpiration {
-		return nil, xerrors.Errorf("deal proposal already expired")
-	}
-
-	// TODO: check StorageCollateral
-
-	minPrice := types.BigDiv(types.BigMul(p.ask.Ask.Price, types.NewInt(deal.Proposal.PieceSize)), types.NewInt(1<<30))
-	if deal.Proposal.StoragePricePerEpoch.LessThan(minPrice) {
-		return nil, xerrors.Errorf("storage price per epoch less than asking price: %s < %s", deal.Proposal.StoragePricePerEpoch, minPrice)
-	}
-
-	if deal.Proposal.PieceSize < p.ask.Ask.MinPieceSize {
-		return nil, xerrors.Errorf("piece size less than minimum required size: %d < %d", deal.Proposal.PieceSize, p.ask.Ask.MinPieceSize)
-	}
-
-	// check market funds
-	clientMarketBalance, err := p.full.StateMarketBalance(ctx, deal.Proposal.Client, nil)
-	if err != nil {
-		return nil, xerrors.Errorf("getting client market balance failed: %w", err)
-	}
-
-	// This doesn't guarantee that the client won't withdraw / lock those funds
-	// but it's a decent first filter
-	if clientMarketBalance.Available.LessThan(deal.Proposal.TotalStoragePrice()) {
-		return nil, xerrors.New("clientMarketBalance.Available too small")
-	}
-
-	waddr, err := p.full.StateMinerWorker(ctx, deal.Proposal.Provider, nil)
-	if err != nil {
-		return nil, err
-	}
-
-	// TODO: check StorageCollateral (may be too large (or too small))
-	if err := p.full.MarketEnsureAvailable(ctx, waddr, deal.Proposal.StorageCollateral); err != nil {
-		return nil, err
-	}
-
-	log.Info("publishing deal")
-
-	params, err := actors.SerializeParams(&actors.PublishStorageDealsParams{
-		Deals: []actors.StorageDealProposal{deal.Proposal},
-	})
-	if err != nil {
-		return nil, xerrors.Errorf("serializing PublishStorageDeals params failed: ", err)
-	}
-
-	// TODO: We may want this to happen after fetching data
-	smsg, err := p.full.MpoolPushMessage(ctx, &types.Message{
-		To:       actors.StorageMarketAddress,
-		From:     waddr,
-		Value:    types.NewInt(0),
-		GasPrice: types.NewInt(0),
-		GasLimit: types.NewInt(1000000),
-		Method:   actors.SMAMethods.PublishStorageDeals,
-		Params:   params,
-	})
-	if err != nil {
-		return nil, err
-	}
-	r, err := p.full.StateWaitMsg(ctx, smsg.Cid())
-	if err != nil {
-		return nil, err
-	}
-	if r.Receipt.ExitCode != 0 {
-		return nil, xerrors.Errorf("publishing deal failed: exit %d", r.Receipt.ExitCode)
-	}
-	var resp actors.PublishStorageDealResponse
-	if err := resp.UnmarshalCBOR(bytes.NewReader(r.Receipt.Return)); err != nil {
-		return nil, err
-	}
-	if len(resp.DealIDs) != 1 {
-		return nil, xerrors.Errorf("got unexpected number of DealIDs from SMA")
-	}
-
-	log.Infof("fetching data for a deal %d", resp.DealIDs[0])
-	err = p.sendSignedResponse(&Response{
-		State: api.DealAccepted,
-
-		Proposal:              deal.ProposalCid,
-		StorageDealSubmission: smsg,
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	if err := p.disconnect(deal); err != nil {
-		log.Warnf("closing client connection: %+v", err)
-	}
-
-	ssb := builder.NewSelectorSpecBuilder(ipldfree.NodeBuilder())
-
-	// this is the selector for "get the whole DAG"
-	// TODO: support storage deals with custom payload selectors
-	allSelector := ssb.ExploreRecursive(selector.RecursionLimitNone(),
-		ssb.ExploreAll(ssb.ExploreRecursiveEdge())).Node()
-
-	// initiate a pull data transfer. This will complete asynchronously and the
-	// completion of the data transfer will trigger a change in deal state
-	// (see onDataTransferEvent)
-	_, err = p.dataTransfer.OpenPullDataChannel(ctx,
-		deal.Client,
-		&StorageDataTransferVoucher{Proposal: deal.ProposalCid, DealID: resp.DealIDs[0]},
-		deal.Ref,
-		allSelector,
-	)
-	if err != nil {
-		return nil, xerrors.Errorf("failed to open pull data channel: %w", err)
-	}
-
-	return nil, nil
-}
-
-// STAGED
-
-func (p *Provider) staged(ctx context.Context, deal MinerDeal) (func(*MinerDeal), error) {
-	root, err := p.dag.Get(ctx, deal.Ref)
-	if err != nil {
-		return nil, xerrors.Errorf("failed to get file root for deal: %s", err)
-	}
-
-	// TODO: abstract this away into ReadSizeCloser + implement different modes
-	n, err := unixfile.NewUnixfsFile(ctx, p.dag, root)
-	if err != nil {
-		return nil, xerrors.Errorf("cannot open unixfs file: %s", err)
-	}
-
-	uf, ok := n.(sectorblocks.UnixfsReader)
-	if !ok {
-		// we probably got directory, unsupported for now
-		return nil, xerrors.Errorf("unsupported unixfs file type")
-	}
-
-	// TODO: uf.Size() is user input, not trusted
-	// This won't be useful / here after we migrate to putting CARs into sectors
-	size, err := uf.Size()
-	if err != nil {
-		return nil, xerrors.Errorf("getting unixfs file size: %w", err)
-	}
-	if padreader.PaddedSize(uint64(size)) != deal.Proposal.PieceSize {
-		return nil, xerrors.Errorf("deal.Proposal.PieceSize didn't match padded unixfs file size")
-	}
-
-	sectorID, err := p.secb.AddUnixfsPiece(ctx, uf, deal.DealID)
-	if err != nil {
-		return nil, xerrors.Errorf("AddPiece failed: %s", err)
-	}
-	log.Warnf("New Sector: %d (deal %d)", sectorID, deal.DealID)
-
-	return func(deal *MinerDeal) {
-		deal.SectorID = sectorID
-	}, nil
-}
-
-// SEALING
-
-func (p *Provider) sealing(ctx context.Context, deal MinerDeal) (func(*MinerDeal), error) {
-	// TODO: consider waiting for seal to happen
-
-	return nil, nil
-}
-
-func (p *Provider) complete(ctx context.Context, deal MinerDeal) (func(*MinerDeal), error) {
-	// TODO: observe sector lifecycle, status, expiration..
-
-	return nil, nil
-}
diff --git a/chain/deals/provider_utils.go b/chain/deals/provider_utils.go
deleted file mode 100644
index e1fcfcf32..000000000
--- a/chain/deals/provider_utils.go
+++ /dev/null
@@ -1,198 +0,0 @@
-package deals
-
-import (
-	"bytes"
-	"context"
-	"runtime"
-
-	"github.com/filecoin-project/lotus/api"
-	"github.com/filecoin-project/lotus/datatransfer"
-	"github.com/filecoin-project/lotus/node/modules/dtypes"
-	"github.com/ipld/go-ipld-prime"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-cbor-util"
-	"github.com/filecoin-project/go-statestore"
-	"github.com/filecoin-project/lotus/chain/actors"
-	"github.com/filecoin-project/lotus/chain/types"
-
-	"github.com/ipfs/go-cid"
-	inet "github.com/libp2p/go-libp2p-core/network"
-	"github.com/libp2p/go-libp2p-core/peer"
-	"golang.org/x/xerrors"
-)
-
-func (p *Provider) failDeal(id cid.Cid, cerr error) {
-	if err := p.deals.End(id); err != nil {
-		log.Warnf("deals.End: %s", err)
-	}
-
-	if cerr == nil {
-		_, f, l, _ := runtime.Caller(1)
-		cerr = xerrors.Errorf("unknown error (fail called at %s:%d)", f, l)
-	}
-
-	log.Warnf("deal %s failed: %s", id, cerr)
-
-	err := p.sendSignedResponse(&Response{
-		State:    api.DealFailed,
-		Message:  cerr.Error(),
-		Proposal: id,
-	})
-
-	s, ok := p.conns[id]
-	if ok {
-		_ = s.Reset()
-		delete(p.conns, id)
-	}
-
-	if err != nil {
-		log.Warnf("notifying client about deal failure: %s", err)
-	}
-}
-
-func (p *Provider) readProposal(s inet.Stream) (proposal Proposal, err error) {
-	if err := cborutil.ReadCborRPC(s, &proposal); err != nil {
-		log.Errorw("failed to read proposal message", "error", err)
-		return proposal, err
-	}
-
-	if err := proposal.DealProposal.Verify(); err != nil {
-		return proposal, xerrors.Errorf("verifying StorageDealProposal: %w", err)
-	}
-
-	if proposal.DealProposal.Provider != p.actor {
-		log.Errorf("proposal with wrong ProviderAddress: %s", proposal.DealProposal.Provider)
-		return proposal, err
-	}
-
-	return
-}
-
-func (p *Provider) sendSignedResponse(resp *Response) error {
-	s, ok := p.conns[resp.Proposal]
-	if !ok {
-		return xerrors.New("couldn't send response: not connected")
-	}
-
-	msg, err := cborutil.Dump(resp)
-	if err != nil {
-		return xerrors.Errorf("serializing response: %w", err)
-	}
-
-	worker, err := p.getWorker(p.actor)
-	if err != nil {
-		return err
-	}
-
-	sig, err := p.full.WalletSign(context.TODO(), worker, msg)
-	if err != nil {
-		return xerrors.Errorf("failed to sign response message: %w", err)
-	}
-
-	signedResponse := &SignedResponse{
-		Response:  *resp,
-		Signature: sig,
-	}
-
-	err = cborutil.WriteCborRPC(s, signedResponse)
-	if err != nil {
-		// Assume client disconnected
-		s.Close()
-		delete(p.conns, resp.Proposal)
-	}
-	return err
-}
-
-func (p *Provider) disconnect(deal MinerDeal) error {
-	s, ok := p.conns[deal.ProposalCid]
-	if !ok {
-		return nil
-	}
-
-	err := s.Close()
-	delete(p.conns, deal.ProposalCid)
-	return err
-}
-
-func (p *Provider) getWorker(miner address.Address) (address.Address, error) {
-	getworker := &types.Message{
-		To:     miner,
-		From:   miner,
-		Method: actors.MAMethods.GetWorkerAddr,
-	}
-	r, err := p.full.StateCall(context.TODO(), getworker, nil)
-	if err != nil {
-		return address.Undef, xerrors.Errorf("getting worker address: %w", err)
-	}
-
-	if r.ExitCode != 0 {
-		return address.Undef, xerrors.Errorf("getWorker call failed: %d", r.ExitCode)
-	}
-
-	return address.NewFromBytes(r.Return)
-}
-
-var _ datatransfer.RequestValidator = &ProviderRequestValidator{}
-
-// ProviderRequestValidator validates data transfer requests for the provider
-// in a storage market
-type ProviderRequestValidator struct {
-	deals *statestore.StateStore
-}
-
-// NewProviderRequestValidator returns a new client request validator for the
-// given datastore
-func NewProviderRequestValidator(deals dtypes.ProviderDealStore) *ProviderRequestValidator {
-	return &ProviderRequestValidator{
-		deals: deals,
-	}
-}
-
-// ValidatePush validates a push request received from the peer that will send data
-// Will succeed only if:
-// - voucher has correct type
-// - voucher references an active deal
-// - referenced deal matches the client
-// - referenced deal matches the given base CID
-// - referenced deal is in an acceptable state
-func (m *ProviderRequestValidator) ValidatePush(
-	sender peer.ID,
-	voucher datatransfer.Voucher,
-	baseCid cid.Cid,
-	Selector ipld.Node) error {
-	dealVoucher, ok := voucher.(*StorageDataTransferVoucher)
-	if !ok {
-		return xerrors.Errorf("voucher type %s: %w", voucher.Identifier(), ErrWrongVoucherType)
-	}
-
-	var deal MinerDeal
-	err := m.deals.Get(dealVoucher.Proposal, &deal)
-	if err != nil {
-		return xerrors.Errorf("Proposal CID %s: %w", dealVoucher.Proposal.String(), ErrNoDeal)
-	}
-	if deal.Client != sender {
-		return xerrors.Errorf("Deal Peer %s, Data Transfer Peer %s: %w", deal.Client.String(), sender.String(), ErrWrongPeer)
-	}
-
-	if !bytes.Equal(deal.Proposal.PieceRef, baseCid.Bytes()) {
-		return xerrors.Errorf("Deal Payload CID %s, Data Transfer CID %s: %w", string(deal.Proposal.PieceRef), baseCid.String(), ErrWrongPiece)
-	}
-	for _, state := range DataTransferStates {
-		if deal.State == state {
-			return nil
-		}
-	}
-	return xerrors.Errorf("Deal State %s: %w", deal.State, ErrInacceptableDealState)
-}
-
-// ValidatePull validates a pull request received from the peer that will receive data.
-// Will always error because providers should not accept pull requests from a client
-// in a storage deal (i.e. send data to client).
-func (m *ProviderRequestValidator) ValidatePull(
-	receiver peer.ID,
-	voucher datatransfer.Voucher,
-	baseCid cid.Cid,
-	Selector ipld.Node) error {
-	return ErrNoPullAccepted
-}
diff --git a/chain/deals/request_validation_test.go b/chain/deals/request_validation_test.go
deleted file mode 100644
index 6da68d219..000000000
--- a/chain/deals/request_validation_test.go
+++ /dev/null
@@ -1,291 +0,0 @@
-package deals_test
-
-import (
-	"fmt"
-	"math/rand"
-	"testing"
-
-	"github.com/ipfs/go-cid"
-	"github.com/ipfs/go-datastore"
-	"github.com/ipfs/go-datastore/namespace"
-	dss "github.com/ipfs/go-datastore/sync"
-	blocksutil "github.com/ipfs/go-ipfs-blocksutil"
-	"github.com/libp2p/go-libp2p-core/peer"
-	xerrors "golang.org/x/xerrors"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-cbor-util"
-	"github.com/filecoin-project/go-statestore"
-	"github.com/filecoin-project/lotus/api"
-	"github.com/filecoin-project/lotus/chain/actors"
-	"github.com/filecoin-project/lotus/chain/deals"
-	"github.com/filecoin-project/lotus/chain/types"
-)
-
-var blockGenerator = blocksutil.NewBlockGenerator()
-
-type wrongDTType struct {
-}
-
-func (wrongDTType) ToBytes() ([]byte, error) {
-	return []byte{}, nil
-}
-
-func (wrongDTType) FromBytes([]byte) error {
-	return fmt.Errorf("not implemented")
-}
-
-func (wrongDTType) Identifier() string {
-	return "WrongDTTYPE"
-}
-
-func uniqueStorageDealProposal() (actors.StorageDealProposal, error) {
-	clientAddr, err := address.NewIDAddress(uint64(rand.Int()))
-	if err != nil {
-		return actors.StorageDealProposal{}, err
-	}
-	providerAddr, err := address.NewIDAddress(uint64(rand.Int()))
-	if err != nil {
-		return actors.StorageDealProposal{}, err
-	}
-	return actors.StorageDealProposal{
-		PieceRef: blockGenerator.Next().Cid().Bytes(),
-		Client:   clientAddr,
-		Provider: providerAddr,
-		ProposerSignature: &types.Signature{
-			Data: []byte("foo bar cat dog"),
-			Type: types.KTBLS,
-		},
-	}, nil
-}
-
-func newClientDeal(minerID peer.ID, state api.DealState) (deals.ClientDeal, error) {
-	newProposal, err := uniqueStorageDealProposal()
-	if err != nil {
-		return deals.ClientDeal{}, err
-	}
-	proposalNd, err := cborutil.AsIpld(&newProposal)
-	if err != nil {
-		return deals.ClientDeal{}, err
-	}
-	minerAddr, err := address.NewIDAddress(uint64(rand.Int()))
-	if err != nil {
-		return deals.ClientDeal{}, err
-	}
-
-	return deals.ClientDeal{
-		Proposal:    newProposal,
-		ProposalCid: proposalNd.Cid(),
-		Miner:       minerID,
-		MinerWorker: minerAddr,
-		State:       state,
-	}, nil
-}
-
-func newMinerDeal(clientID peer.ID, state api.DealState) (deals.MinerDeal, error) {
-	newProposal, err := uniqueStorageDealProposal()
-	if err != nil {
-		return deals.MinerDeal{}, err
-	}
-	proposalNd, err := cborutil.AsIpld(&newProposal)
-	if err != nil {
-		return deals.MinerDeal{}, err
-	}
-	ref, err := cid.Cast(newProposal.PieceRef)
-	if err != nil {
-		return deals.MinerDeal{}, err
-	}
-
-	return deals.MinerDeal{
-		Proposal:    newProposal,
-		ProposalCid: proposalNd.Cid(),
-		Client:      clientID,
-		State:       state,
-		Ref:         ref,
-	}, nil
-}
-
-func TestClientRequestValidation(t *testing.T) {
-	ds := dss.MutexWrap(datastore.NewMapDatastore())
-	state := statestore.New(namespace.Wrap(ds, datastore.NewKey("/deals/client")))
-
-	crv := deals.NewClientRequestValidator(state)
-	minerID := peer.ID("fakepeerid")
-	block := blockGenerator.Next()
-	t.Run("ValidatePush fails", func(t *testing.T) {
-		if !xerrors.Is(crv.ValidatePush(minerID, wrongDTType{}, block.Cid(), nil), deals.ErrNoPushAccepted) {
-			t.Fatal("Push should fail for the client request validator for storage deals")
-		}
-	})
-	t.Run("ValidatePull fails deal not found", func(t *testing.T) {
-		proposal, err := uniqueStorageDealProposal()
-		if err != nil {
-			t.Fatal("error creating proposal")
-		}
-		proposalNd, err := cborutil.AsIpld(&proposal)
-		if err != nil {
-			t.Fatal("error serializing proposal")
-		}
-		pieceRef, err := cid.Cast(proposal.PieceRef)
-		if err != nil {
-			t.Fatal("unable to construct piece cid")
-		}
-		if !xerrors.Is(crv.ValidatePull(minerID, &deals.StorageDataTransferVoucher{proposalNd.Cid(), 1}, pieceRef, nil), deals.ErrNoDeal) {
-			t.Fatal("Pull should fail if there is no deal stored")
-		}
-	})
-	t.Run("ValidatePull fails wrong client", func(t *testing.T) {
-		otherMiner := peer.ID("otherminer")
-		clientDeal, err := newClientDeal(otherMiner, api.DealAccepted)
-		if err != nil {
-			t.Fatal("error creating client deal")
-		}
-		if err := state.Begin(clientDeal.ProposalCid, &clientDeal); err != nil {
-			t.Fatal("deal tracking failed")
-		}
-		pieceRef, err := cid.Cast(clientDeal.Proposal.PieceRef)
-		if err != nil {
-			t.Fatal("unable to construct piece cid")
-		}
-		if !xerrors.Is(crv.ValidatePull(minerID, &deals.StorageDataTransferVoucher{clientDeal.ProposalCid, 1}, pieceRef, nil), deals.ErrWrongPeer) {
-			t.Fatal("Pull should fail if miner address is incorrect")
-		}
-	})
-	t.Run("ValidatePull fails wrong piece ref", func(t *testing.T) {
-		clientDeal, err := newClientDeal(minerID, api.DealAccepted)
-		if err != nil {
-			t.Fatal("error creating client deal")
-		}
-		if err := state.Begin(clientDeal.ProposalCid, &clientDeal); err != nil {
-			t.Fatal("deal tracking failed")
-		}
-		if !xerrors.Is(crv.ValidatePull(minerID, &deals.StorageDataTransferVoucher{clientDeal.ProposalCid, 1}, blockGenerator.Next().Cid(), nil), deals.ErrWrongPiece) {
-			t.Fatal("Pull should fail if piece ref is incorrect")
-		}
-	})
-	t.Run("ValidatePull fails wrong deal state", func(t *testing.T) {
-		clientDeal, err := newClientDeal(minerID, api.DealComplete)
-		if err != nil {
-			t.Fatal("error creating client deal")
-		}
-		if err := state.Begin(clientDeal.ProposalCid, &clientDeal); err != nil {
-			t.Fatal("deal tracking failed")
-		}
-		pieceRef, err := cid.Cast(clientDeal.Proposal.PieceRef)
-		if err != nil {
-			t.Fatal("unable to construct piece cid")
-		}
-		if !xerrors.Is(crv.ValidatePull(minerID, &deals.StorageDataTransferVoucher{clientDeal.ProposalCid, 1}, pieceRef, nil), deals.ErrInacceptableDealState) {
-			t.Fatal("Pull should fail if deal is in a state that cannot be data transferred")
-		}
-	})
-	t.Run("ValidatePull succeeds", func(t *testing.T) {
-		clientDeal, err := newClientDeal(minerID, api.DealAccepted)
-		if err != nil {
-			t.Fatal("error creating client deal")
-		}
-		if err := state.Begin(clientDeal.ProposalCid, &clientDeal); err != nil {
-			t.Fatal("deal tracking failed")
-		}
-		pieceRef, err := cid.Cast(clientDeal.Proposal.PieceRef)
-		if err != nil {
-			t.Fatal("unable to construct piece cid")
-		}
-		if crv.ValidatePull(minerID, &deals.StorageDataTransferVoucher{clientDeal.ProposalCid, 1}, pieceRef, nil) != nil {
-			t.Fatal("Pull should should succeed when all parameters are correct")
-		}
-	})
-}
-
-func TestProviderRequestValidation(t *testing.T) {
-	ds := dss.MutexWrap(datastore.NewMapDatastore())
-	state := statestore.New(namespace.Wrap(ds, datastore.NewKey("/deals/client")))
-
-	mrv := deals.NewProviderRequestValidator(state)
-	clientID := peer.ID("fakepeerid")
-	block := blockGenerator.Next()
-	t.Run("ValidatePull fails", func(t *testing.T) {
-		if !xerrors.Is(mrv.ValidatePull(clientID, wrongDTType{}, block.Cid(), nil), deals.ErrNoPullAccepted) {
-			t.Fatal("Pull should fail for the provider request validator for storage deals")
-		}
-	})
-
-	t.Run("ValidatePush fails deal not found", func(t *testing.T) {
-		proposal, err := uniqueStorageDealProposal()
-		if err != nil {
-			t.Fatal("error creating proposal")
-		}
-		proposalNd, err := cborutil.AsIpld(&proposal)
-		if err != nil {
-			t.Fatal("error serializing proposal")
-		}
-		pieceRef, err := cid.Cast(proposal.PieceRef)
-		if err != nil {
-			t.Fatal("unable to construct piece cid")
-		}
-		if !xerrors.Is(mrv.ValidatePush(clientID, &deals.StorageDataTransferVoucher{proposalNd.Cid(), 1}, pieceRef, nil), deals.ErrNoDeal) {
-			t.Fatal("Push should fail if there is no deal stored")
-		}
-	})
-	t.Run("ValidatePush fails wrong miner", func(t *testing.T) {
-		otherClient := peer.ID("otherclient")
-		minerDeal, err := newMinerDeal(otherClient, api.DealAccepted)
-		if err != nil {
-			t.Fatal("error creating client deal")
-		}
-		if err := state.Begin(minerDeal.ProposalCid, &minerDeal); err != nil {
-			t.Fatal("deal tracking failed")
-		}
-		pieceRef, err := cid.Cast(minerDeal.Proposal.PieceRef)
-		if err != nil {
-			t.Fatal("unable to construct piece cid")
-		}
-		if !xerrors.Is(mrv.ValidatePush(clientID, &deals.StorageDataTransferVoucher{minerDeal.ProposalCid, 1}, pieceRef, nil), deals.ErrWrongPeer) {
-			t.Fatal("Push should fail if miner address is incorrect")
-		}
-	})
-	t.Run("ValidatePush fails wrong piece ref", func(t *testing.T) {
-		minerDeal, err := newMinerDeal(clientID, api.DealAccepted)
-		if err != nil {
-			t.Fatal("error creating client deal")
-		}
-		if err := state.Begin(minerDeal.ProposalCid, &minerDeal); err != nil {
-			t.Fatal("deal tracking failed")
-		}
-		if !xerrors.Is(mrv.ValidatePush(clientID, &deals.StorageDataTransferVoucher{minerDeal.ProposalCid, 1}, blockGenerator.Next().Cid(), nil), deals.ErrWrongPiece) {
-			t.Fatal("Push should fail if piece ref is incorrect")
-		}
-	})
-	t.Run("ValidatePush fails wrong deal state", func(t *testing.T) {
-		minerDeal, err := newMinerDeal(clientID, api.DealComplete)
-		if err != nil {
-			t.Fatal("error creating client deal")
-		}
-		if err := state.Begin(minerDeal.ProposalCid, &minerDeal); err != nil {
-			t.Fatal("deal tracking failed")
-		}
-		pieceRef, err := cid.Cast(minerDeal.Proposal.PieceRef)
-		if err != nil {
-			t.Fatal("unable to construct piece cid")
-		}
-		if !xerrors.Is(mrv.ValidatePush(clientID, &deals.StorageDataTransferVoucher{minerDeal.ProposalCid, 1}, pieceRef, nil), deals.ErrInacceptableDealState) {
-			t.Fatal("Push should fail if deal is in a state that cannot be data transferred")
-		}
-	})
-	t.Run("ValidatePush succeeds", func(t *testing.T) {
-		minerDeal, err := newMinerDeal(clientID, api.DealAccepted)
-		if err != nil {
-			t.Fatal("error creating client deal")
-		}
-		if err := state.Begin(minerDeal.ProposalCid, &minerDeal); err != nil {
-			t.Fatal("deal tracking failed")
-		}
-		pieceRef, err := cid.Cast(minerDeal.Proposal.PieceRef)
-		if err != nil {
-			t.Fatal("unable to construct piece cid")
-		}
-		if mrv.ValidatePush(clientID, &deals.StorageDataTransferVoucher{minerDeal.ProposalCid, 1}, pieceRef, nil) != nil {
-			t.Fatal("Push should should succeed when all parameters are correct")
-		}
-	})
-}
diff --git a/chain/deals/types.go b/chain/deals/types.go
deleted file mode 100644
index 8a368e80d..000000000
--- a/chain/deals/types.go
+++ /dev/null
@@ -1,114 +0,0 @@
-package deals
-
-import (
-	"bytes"
-	"errors"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-cbor-util"
-	"github.com/filecoin-project/lotus/api"
-	"github.com/filecoin-project/lotus/chain/actors"
-	"github.com/filecoin-project/lotus/chain/types"
-	"github.com/ipfs/go-cid"
-)
-
-var (
-	// ErrWrongVoucherType means the voucher was not the correct type can validate against
-	ErrWrongVoucherType = errors.New("cannot validate voucher type.")
-
-	// ErrNoPushAccepted just means clients do not accept pushes for storage deals
-	ErrNoPushAccepted = errors.New("client should not receive data for a storage deal.")
-
-	// ErrNoPullAccepted just means providers do not accept pulls for storage deals
-	ErrNoPullAccepted = errors.New("provider should not send data for a storage deal.")
-
-	// ErrNoDeal means no active deal was found for this vouchers proposal cid
-	ErrNoDeal = errors.New("no deal found for this proposal.")
-
-	// ErrWrongPeer means that the other peer for this data transfer request does not match
-	// the other peer for the deal
-	ErrWrongPeer = errors.New("data Transfer peer id and Deal peer id do not match.")
-
-	// ErrWrongPiece means that the pieceref for this data transfer request does not match
-	// the one specified in the deal
-	ErrWrongPiece = errors.New("base CID for deal does not match CID for piece.")
-
-	// ErrInacceptableDealState means the deal for this transfer is not in a deal state
-	// where transfer can be performed
-	ErrInacceptableDealState = errors.New("deal is not a in a state where deals are accepted.")
-
-	// DataTransferStates are the states in which it would make sense to actually start a data transfer
-	DataTransferStates = []api.DealState{api.DealAccepted, api.DealUnknown}
-)
-
-const DealProtocolID = "/fil/storage/mk/1.0.1"
-const AskProtocolID = "/fil/storage/ask/1.0.1"
-
-type Proposal struct {
-	DealProposal *actors.StorageDealProposal
-
-	Piece cid.Cid // Used for retrieving from the client
-}
-
-type Response struct {
-	State api.DealState
-
-	// DealProposalRejected
-	Message  string
-	Proposal cid.Cid
-
-	// DealAccepted
-	StorageDealSubmission *types.SignedMessage
-}
-
-// TODO: Do we actually need this to be signed?
-type SignedResponse struct {
-	Response Response
-
-	Signature *types.Signature
-}
-
-func (r *SignedResponse) Verify(addr address.Address) error {
-	b, err := cborutil.Dump(&r.Response)
-	if err != nil {
-		return err
-	}
-
-	return r.Signature.Verify(addr, b)
-}
-
-type AskRequest struct {
-	Miner address.Address
-}
-
-type AskResponse struct {
-	Ask *types.SignedStorageAsk
-}
-
-// StorageDataTransferVoucher is the voucher type for data transfers
-// used by the storage market
-type StorageDataTransferVoucher struct {
-	Proposal cid.Cid
-	DealID   uint64
-}
-
-// ToBytes converts the StorageDataTransferVoucher to raw bytes
-func (dv *StorageDataTransferVoucher) ToBytes() ([]byte, error) {
-	var buf bytes.Buffer
-	err := dv.MarshalCBOR(&buf)
-	if err != nil {
-		return nil, err
-	}
-	return buf.Bytes(), nil
-}
-
-// FromBytes converts the StorageDataTransferVoucher to raw bytes
-func (dv *StorageDataTransferVoucher) FromBytes(raw []byte) error {
-	r := bytes.NewReader(raw)
-	return dv.UnmarshalCBOR(r)
-}
-
-// Identifier is the unique string identifier for a StorageDataTransferVoucher
-func (dv *StorageDataTransferVoucher) Identifier() string {
-	return "StorageDataTransferVoucher"
-}
diff --git a/chain/events/events.go b/chain/events/events.go
index 683dab5db..e35e91366 100644
--- a/chain/events/events.go
+++ b/chain/events/events.go
@@ -5,8 +5,9 @@ import (
 	"sync"
 	"time"
 
+	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/ipfs/go-cid"
-	logging "github.com/ipfs/go-log"
+	logging "github.com/ipfs/go-log/v2"
 	"golang.org/x/xerrors"
 
 	"github.com/filecoin-project/go-address"
@@ -18,8 +19,8 @@ import (
 
 var log = logging.Logger("events")
 
-// `curH`-`ts.Height` = `confidence`
-type HeightHandler func(ctx context.Context, ts *types.TipSet, curH uint64) error
+// HeightHandler `curH`-`ts.Height` = `confidence`
+type HeightHandler func(ctx context.Context, ts *types.TipSet, curH abi.ChainEpoch) error
 type RevertHandler func(ctx context.Context, ts *types.TipSet) error
 
 type heightHandler struct {
@@ -30,17 +31,19 @@ type heightHandler struct {
 	revert RevertHandler
 }
 
-type eventApi interface {
-	ChainNotify(context.Context) (<-chan []*store.HeadChange, error)
+type eventAPI interface {
+	ChainNotify(context.Context) (<-chan []*api.HeadChange, error)
 	ChainGetBlockMessages(context.Context, cid.Cid) (*api.BlockMessages, error)
-	ChainGetTipSetByHeight(context.Context, uint64, *types.TipSet) (*types.TipSet, error)
-	StateGetReceipt(context.Context, cid.Cid, *types.TipSet) (*types.MessageReceipt, error)
+	ChainGetTipSetByHeight(context.Context, abi.ChainEpoch, types.TipSetKey) (*types.TipSet, error)
+	ChainHead(context.Context) (*types.TipSet, error)
+	StateGetReceipt(context.Context, cid.Cid, types.TipSetKey) (*types.MessageReceipt, error)
+	ChainGetTipSet(context.Context, types.TipSetKey) (*types.TipSet, error)
 
-	StateGetActor(ctx context.Context, actor address.Address, ts *types.TipSet) (*types.Actor, error) // optional / for CalledMsg
+	StateGetActor(ctx context.Context, actor address.Address, tsk types.TipSetKey) (*types.Actor, error) // optional / for CalledMsg
 }
 
 type Events struct {
-	api eventApi
+	api eventAPI
 
 	tsc *tipSetCache
 	lk  sync.Mutex
@@ -49,13 +52,13 @@ type Events struct {
 	readyOnce sync.Once
 
 	heightEvents
-	calledEvents
+	*hcEvents
 }
 
-func NewEvents(ctx context.Context, api eventApi) *Events {
+func NewEvents(ctx context.Context, api eventAPI) *Events {
 	gcConfidence := 2 * build.ForkLengthThreshold
 
-	tsc := newTSCache(gcConfidence, api.ChainGetTipSetByHeight)
+	tsc := newTSCache(gcConfidence, api)
 
 	e := &Events{
 		api: api,
@@ -65,25 +68,14 @@ func NewEvents(ctx context.Context, api eventApi) *Events {
 		heightEvents: heightEvents{
 			tsc:          tsc,
 			ctx:          ctx,
-			gcConfidence: uint64(gcConfidence),
+			gcConfidence: gcConfidence,
 
 			heightTriggers:   map[uint64]*heightHandler{},
-			htTriggerHeights: map[uint64][]uint64{},
-			htHeights:        map[uint64][]uint64{},
+			htTriggerHeights: map[abi.ChainEpoch][]uint64{},
+			htHeights:        map[abi.ChainEpoch][]uint64{},
 		},
 
-		calledEvents: calledEvents{
-			cs:           api,
-			tsc:          tsc,
-			ctx:          ctx,
-			gcConfidence: uint64(gcConfidence),
-
-			confQueue:   map[triggerH]map[msgH][]*queuedEvent{},
-			revertQueue: map[msgH][]triggerH{},
-			triggers:    map[triggerId]*callHandler{},
-			matchers:    map[triggerId][]MatchFunc{},
-			timeouts:    map[uint64]map[triggerId]int{},
-		},
+		hcEvents: newHCEvents(ctx, api, tsc, uint64(gcConfidence)),
 	}
 
 	e.ready.Add(1)
@@ -108,7 +100,7 @@ func (e *Events) listenHeadChanges(ctx context.Context) {
 			log.Warnf("not restarting listenHeadChanges: context error: %s", ctx.Err())
 			return
 		}
-		time.Sleep(time.Second)
+		build.Clock.Sleep(time.Second)
 		log.Info("restarting listenHeadChanges")
 	}
 }
@@ -141,6 +133,8 @@ func (e *Events) listenHeadChangesOnce(ctx context.Context) error {
 	}
 
 	e.readyOnce.Do(func() {
+		e.lastTs = cur[0].Val
+
 		e.ready.Done()
 	})
 
@@ -160,6 +154,11 @@ func (e *Events) listenHeadChangesOnce(ctx context.Context) error {
 		if err := e.headChange(rev, app); err != nil {
 			log.Warnf("headChange failed: %s", err)
 		}
+
+		// sync with fake chainstore (for tests)
+		if fcs, ok := e.api.(interface{ notifDone() }); ok {
+			fcs.notifDone()
+		}
 	}
 
 	return nil
@@ -177,5 +176,5 @@ func (e *Events) headChange(rev, app []*types.TipSet) error {
 		return err
 	}
 
-	return e.headChangeCalled(rev, app)
+	return e.processHeadChangeEvent(rev, app)
 }
diff --git a/chain/events/events_called.go b/chain/events/events_called.go
index 106251b81..753206093 100644
--- a/chain/events/events_called.go
+++ b/chain/events/events_called.go
@@ -5,69 +5,79 @@ import (
 	"math"
 	"sync"
 
+	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/ipfs/go-cid"
 	"golang.org/x/xerrors"
 
-	"github.com/filecoin-project/lotus/chain/store"
 	"github.com/filecoin-project/lotus/chain/types"
 )
 
-const NoTimeout = math.MaxUint64
+const NoTimeout = math.MaxInt64
+const NoHeight = abi.ChainEpoch(-1)
 
-type triggerId = uint64
+type triggerID = uint64
 
 // msgH is the block height at which a message was present / event has happened
-type msgH = uint64
+type msgH = abi.ChainEpoch
 
 // triggerH is the block height at which the listener will be notified about the
 //  message (msgH+confidence)
-type triggerH = uint64
+type triggerH = abi.ChainEpoch
 
-// `ts` is the tipset, in which the `msg` is included.
+type eventData interface{}
+
+// EventHandler arguments:
+// `prevTs` is the previous tipset, eg the "from" tipset for a state change.
+// `ts` is the event tipset, eg the tipset in which the `msg` is included.
 // `curH`-`ts.Height` = `confidence`
-type CalledHandler func(msg *types.Message, rec *types.MessageReceipt, ts *types.TipSet, curH uint64) (more bool, err error)
+type EventHandler func(data eventData, prevTs, ts *types.TipSet, curH abi.ChainEpoch) (more bool, err error)
 
 // CheckFunc is used for atomicity guarantees. If the condition the callbacks
 // wait for has already happened in tipset `ts`
 //
 // If `done` is true, timeout won't be triggered
-// If `more` is false, no messages will be sent to CalledHandler (RevertHandler
+// If `more` is false, no messages will be sent to EventHandler (RevertHandler
 //  may still be called)
 type CheckFunc func(ts *types.TipSet) (done bool, more bool, err error)
 
-type MatchFunc func(msg *types.Message) (bool, error)
-
-type callHandler struct {
+// Keep track of information for an event handler
+type handlerInfo struct {
 	confidence int
-	timeout    uint64
+	timeout    abi.ChainEpoch
 
 	disabled bool // TODO: GC after gcConfidence reached
 
-	handle CalledHandler
+	handle EventHandler
 	revert RevertHandler
 }
 
+// When a change occurs, a queuedEvent is created and put into a queue
+// until the required confidence is reached
 type queuedEvent struct {
-	trigger triggerId
+	trigger triggerID
 
-	h   uint64
-	msg *types.Message
+	prevH abi.ChainEpoch
+	h     abi.ChainEpoch
+	data  eventData
 
 	called bool
 }
 
-type calledEvents struct {
-	cs           eventApi
+// Manages chain head change events, which may be forward (new tipset added to
+// chain) or backward (chain branch discarded in favour of heavier branch)
+type hcEvents struct {
+	cs           eventAPI
 	tsc          *tipSetCache
 	ctx          context.Context
 	gcConfidence uint64
 
+	lastTs *types.TipSet
+
 	lk sync.Mutex
 
-	ctr triggerId
+	ctr triggerID
 
-	triggers map[triggerId]*callHandler
-	matchers map[triggerId][]MatchFunc
+	triggers map[triggerID]*handlerInfo
 
 	// maps block heights to events
 	// [triggerH][msgH][event]
@@ -76,27 +86,81 @@ type calledEvents struct {
 	// [msgH][triggerH]
 	revertQueue map[msgH][]triggerH
 
-	// [timeoutH+confidence][triggerId]{calls}
-	timeouts map[uint64]map[triggerId]int
+	// [timeoutH+confidence][triggerID]{calls}
+	timeouts map[abi.ChainEpoch]map[triggerID]int
+
+	messageEvents
+	watcherEvents
 }
 
-func (e *calledEvents) headChangeCalled(rev, app []*types.TipSet) error {
+func newHCEvents(ctx context.Context, cs eventAPI, tsc *tipSetCache, gcConfidence uint64) *hcEvents {
+	e := hcEvents{
+		ctx:          ctx,
+		cs:           cs,
+		tsc:          tsc,
+		gcConfidence: gcConfidence,
+
+		confQueue:   map[triggerH]map[msgH][]*queuedEvent{},
+		revertQueue: map[msgH][]triggerH{},
+		triggers:    map[triggerID]*handlerInfo{},
+		timeouts:    map[abi.ChainEpoch]map[triggerID]int{},
+	}
+
+	e.messageEvents = newMessageEvents(ctx, &e, cs)
+	e.watcherEvents = newWatcherEvents(ctx, &e, cs)
+
+	return &e
+}
+
+// Called when there is a change to the head with tipsets to be
+// reverted / applied
+func (e *hcEvents) processHeadChangeEvent(rev, app []*types.TipSet) error {
+	e.lk.Lock()
+	defer e.lk.Unlock()
+
 	for _, ts := range rev {
 		e.handleReverts(ts)
+		e.lastTs = ts
 	}
 
 	for _, ts := range app {
-		// called triggers
+		// Check if the head change caused any state changes that we were
+		// waiting for
+		stateChanges := e.watcherEvents.checkStateChanges(e.lastTs, ts)
 
-		e.checkNewCalls(ts)
-		e.applyWithConfidence(ts)
-		e.applyTimeouts(ts)
+		// Queue up calls until there have been enough blocks to reach
+		// confidence on the state changes
+		for tid, data := range stateChanges {
+			e.queueForConfidence(tid, data, e.lastTs, ts)
+		}
+
+		// Check if the head change included any new message calls
+		newCalls, err := e.messageEvents.checkNewCalls(ts)
+		if err != nil {
+			return err
+		}
+
+		// Queue up calls until there have been enough blocks to reach
+		// confidence on the message calls
+		for tid, data := range newCalls {
+			e.queueForConfidence(tid, data, nil, ts)
+		}
+
+		for at := e.lastTs.Height(); at <= ts.Height(); at++ {
+			// Apply any queued events and timeouts that were targeted at the
+			// current chain height
+			e.applyWithConfidence(ts, at)
+			e.applyTimeouts(ts)
+		}
+
+		// Update the latest known tipset
+		e.lastTs = ts
 	}
 
 	return nil
 }
 
-func (e *calledEvents) handleReverts(ts *types.TipSet) {
+func (e *hcEvents) handleReverts(ts *types.TipSet) {
 	reverts, ok := e.revertQueue[ts.Height()]
 	if !ok {
 		return // nothing to do
@@ -112,7 +176,7 @@ func (e *calledEvents) handleReverts(ts *types.TipSet) {
 			trigger := e.triggers[event.trigger]
 
 			if err := trigger.revert(e.ctx, ts); err != nil {
-				log.Errorf("reverting chain trigger (call %s.%d() @H %d, called @ %d) failed: %s", event.msg.To, event.msg.Method, ts.Height(), triggerH, err)
+				log.Errorf("reverting chain trigger (@H %d, triggered @ %d) failed: %s", ts.Height(), triggerH, err)
 			}
 		}
 		delete(e.confQueue[triggerH], ts.Height())
@@ -120,66 +184,46 @@ func (e *calledEvents) handleReverts(ts *types.TipSet) {
 	delete(e.revertQueue, ts.Height())
 }
 
-func (e *calledEvents) checkNewCalls(ts *types.TipSet) {
-	e.messagesForTs(ts, func(msg *types.Message) {
-		// TODO: provide receipts
+// Queue up events until the chain has reached a height that reflects the
+// desired confidence
+func (e *hcEvents) queueForConfidence(trigID uint64, data eventData, prevTs, ts *types.TipSet) {
+	trigger := e.triggers[trigID]
 
-		for tid, matchFns := range e.matchers {
-			var matched bool
-			for _, matchFn := range matchFns {
-				ok, err := matchFn(msg)
-				if err != nil {
-					log.Warnf("event matcher failed: %s")
-					continue
-				}
-				matched = ok
+	prevH := NoHeight
+	if prevTs != nil {
+		prevH = prevTs.Height()
+	}
+	appliedH := ts.Height()
 
-				if matched {
-					break
-				}
-			}
-
-			if matched {
-				e.queueForConfidence(tid, msg, ts)
-				break
-			}
-		}
-	})
-}
-
-func (e *calledEvents) queueForConfidence(triggerId uint64, msg *types.Message, ts *types.TipSet) {
-	trigger := e.triggers[triggerId]
-
-	// messages are not applied in the tipset they are included in
-	appliedH := ts.Height() + 1
-
-	triggerH := appliedH + uint64(trigger.confidence)
+	triggerH := appliedH + abi.ChainEpoch(trigger.confidence)
 
 	byOrigH, ok := e.confQueue[triggerH]
 	if !ok {
-		byOrigH = map[uint64][]*queuedEvent{}
+		byOrigH = map[abi.ChainEpoch][]*queuedEvent{}
 		e.confQueue[triggerH] = byOrigH
 	}
 
 	byOrigH[appliedH] = append(byOrigH[appliedH], &queuedEvent{
-		trigger: triggerId,
+		trigger: trigID,
+		prevH:   prevH,
 		h:       appliedH,
-		msg:     msg,
+		data:    data,
 	})
 
 	e.revertQueue[appliedH] = append(e.revertQueue[appliedH], triggerH)
 }
 
-func (e *calledEvents) applyWithConfidence(ts *types.TipSet) {
-	byOrigH, ok := e.confQueue[ts.Height()]
+// Apply any events that were waiting for this chain height for confidence
+func (e *hcEvents) applyWithConfidence(ts *types.TipSet, height abi.ChainEpoch) {
+	byOrigH, ok := e.confQueue[height]
 	if !ok {
-		return // no triggers at thin height
+		return // no triggers at this height
 	}
 
 	for origH, events := range byOrigH {
 		triggerTs, err := e.tsc.get(origH)
 		if err != nil {
-			log.Errorf("events: applyWithConfidence didn't find tipset for event; wanted %d; current %d", origH, ts.Height())
+			log.Errorf("events: applyWithConfidence didn't find tipset for event; wanted %d; current %d", origH, height)
 		}
 
 		for _, event := range events {
@@ -192,15 +236,20 @@ func (e *calledEvents) applyWithConfidence(ts *types.TipSet) {
 				continue
 			}
 
-			rec, err := e.cs.StateGetReceipt(e.ctx, event.msg.Cid(), ts)
-			if err != nil {
-				log.Error(err)
-				return
+			// Previous tipset - this is relevant for example in a state change
+			// from one tipset to another
+			var prevTs *types.TipSet
+			if event.prevH != NoHeight {
+				prevTs, err = e.tsc.get(event.prevH)
+				if err != nil {
+					log.Errorf("events: applyWithConfidence didn't find tipset for previous event; wanted %d; current %d", event.prevH, height)
+					continue
+				}
 			}
 
-			more, err := trigger.handle(event.msg, rec, triggerTs, ts.Height())
+			more, err := trigger.handle(event.data, prevTs, triggerTs, height)
 			if err != nil {
-				log.Errorf("chain trigger (call %s.%d() @H %d, called @ %d) failed: %s", event.msg.To, event.msg.Method, origH, ts.Height(), err)
+				log.Errorf("chain trigger (@H %d, triggered @ %d) failed: %s", origH, height, err)
 				continue // don't revert failed calls
 			}
 
@@ -216,24 +265,25 @@ func (e *calledEvents) applyWithConfidence(ts *types.TipSet) {
 	}
 }
 
-func (e *calledEvents) applyTimeouts(ts *types.TipSet) {
+// Apply any timeouts that expire at this height
+func (e *hcEvents) applyTimeouts(ts *types.TipSet) {
 	triggers, ok := e.timeouts[ts.Height()]
 	if !ok {
 		return // nothing to do
 	}
 
-	for triggerId, calls := range triggers {
+	for triggerID, calls := range triggers {
 		if calls > 0 {
 			continue // don't timeout if the method was called
 		}
-		trigger := e.triggers[triggerId]
+		trigger := e.triggers[triggerID]
 		if trigger.disabled {
 			continue
 		}
 
-		timeoutTs, err := e.tsc.get(ts.Height() - uint64(trigger.confidence))
+		timeoutTs, err := e.tsc.get(ts.Height() - abi.ChainEpoch(trigger.confidence))
 		if err != nil {
-			log.Errorf("events: applyTimeouts didn't find tipset for event; wanted %d; current %d", ts.Height()-uint64(trigger.confidence), ts.Height())
+			log.Errorf("events: applyTimeouts didn't find tipset for event; wanted %d; current %d", ts.Height()-abi.ChainEpoch(trigger.confidence), ts.Height())
 		}
 
 		more, err := trigger.handle(nil, nil, timeoutTs, ts.Height())
@@ -246,12 +296,232 @@ func (e *calledEvents) applyTimeouts(ts *types.TipSet) {
 	}
 }
 
-func (e *calledEvents) messagesForTs(ts *types.TipSet, consume func(*types.Message)) {
+// Listen for an event
+// - CheckFunc: immediately checks if the event already occurred
+// - EventHandler: called when the event has occurred, after confidence tipsets
+// - RevertHandler: called if the chain head changes causing the event to revert
+// - confidence: wait this many tipsets before calling EventHandler
+// - timeout: at this chain height, timeout on waiting for this event
+func (e *hcEvents) onHeadChanged(check CheckFunc, hnd EventHandler, rev RevertHandler, confidence int, timeout abi.ChainEpoch) (triggerID, error) {
+	e.lk.Lock()
+	defer e.lk.Unlock()
+
+	// Check if the event has already occurred
+	ts, err := e.tsc.best()
+	if err != nil {
+		return 0, xerrors.Errorf("error getting best tipset: %w", err)
+	}
+	done, more, err := check(ts)
+	if err != nil {
+		return 0, xerrors.Errorf("called check error (h: %d): %w", ts.Height(), err)
+	}
+	if done {
+		timeout = NoTimeout
+	}
+
+	// Create a trigger for the event
+	id := e.ctr
+	e.ctr++
+
+	e.triggers[id] = &handlerInfo{
+		confidence: confidence,
+		timeout:    timeout + abi.ChainEpoch(confidence),
+
+		disabled: !more,
+
+		handle: hnd,
+		revert: rev,
+	}
+
+	// If there's a timeout, set up a timeout check at that height
+	if timeout != NoTimeout {
+		if e.timeouts[timeout+abi.ChainEpoch(confidence)] == nil {
+			e.timeouts[timeout+abi.ChainEpoch(confidence)] = map[uint64]int{}
+		}
+		e.timeouts[timeout+abi.ChainEpoch(confidence)][id] = 0
+	}
+
+	return id, nil
+}
+
+// headChangeAPI is used to allow the composed event APIs to call back to hcEvents
+// to listen for changes
+type headChangeAPI interface {
+	onHeadChanged(check CheckFunc, hnd EventHandler, rev RevertHandler, confidence int, timeout abi.ChainEpoch) (triggerID, error)
+}
+
+// watcherEvents watches for a state change
+type watcherEvents struct {
+	ctx   context.Context
+	cs    eventAPI
+	hcAPI headChangeAPI
+
+	lk       sync.RWMutex
+	matchers map[triggerID]StateMatchFunc
+}
+
+func newWatcherEvents(ctx context.Context, hcAPI headChangeAPI, cs eventAPI) watcherEvents {
+	return watcherEvents{
+		ctx:      ctx,
+		cs:       cs,
+		hcAPI:    hcAPI,
+		matchers: make(map[triggerID]StateMatchFunc),
+	}
+}
+
+// Run each of the matchers against the previous and current state to see if
+// there's a change
+func (we *watcherEvents) checkStateChanges(oldState, newState *types.TipSet) map[triggerID]eventData {
+	we.lk.RLock()
+	defer we.lk.RUnlock()
+
+	res := make(map[triggerID]eventData)
+	for tid, matchFn := range we.matchers {
+		ok, data, err := matchFn(oldState, newState)
+		if err != nil {
+			log.Errorf("event diff fn failed: %s", err)
+			continue
+		}
+
+		if ok {
+			res[tid] = data
+		}
+	}
+	return res
+}
+
+// StateChange represents a change in state
+type StateChange interface{}
+
+// StateChangeHandler arguments:
+// `oldTs` is the state "from" tipset
+// `newTs` is the state "to" tipset
+// `states` is the change in state
+// `curH`-`ts.Height` = `confidence`
+type StateChangeHandler func(oldTs, newTs *types.TipSet, states StateChange, curH abi.ChainEpoch) (more bool, err error)
+
+type StateMatchFunc func(oldTs, newTs *types.TipSet) (bool, StateChange, error)
+
+// StateChanged registers a callback which is triggered when a specified state
+// change occurs or a timeout is reached.
+//
+// * `CheckFunc` callback is invoked immediately with a recent tipset, it
+//    returns two booleans - `done`, and `more`.
+//
+//   * `done` should be true when some on-chain state change we are waiting
+//     for has happened. When `done` is set to true, timeout trigger is disabled.
+//
+//   * `more` should be false when we don't want to receive new notifications
+//     through StateChangeHandler. Note that notifications may still be delivered to
+//     RevertHandler
+//
+// * `StateChangeHandler` is called when the specified state change was observed
+//    on-chain, and a confidence threshold was reached, or the specified `timeout`
+//    height was reached with no state change observed. When this callback is
+//    invoked on a timeout, `oldState` and `newState` are set to nil.
+//    This callback returns a boolean specifying whether further notifications
+//    should be sent, like `more` return param from `CheckFunc` above.
+//
+// * `RevertHandler` is called after apply handler, when we drop the tipset
+//    containing the message. The tipset passed as the argument is the tipset
+//    that is being dropped. Note that the event dropped may be re-applied
+//    in a different tipset in small amount of time.
+//
+// * `StateMatchFunc` is called against each tipset state. If there is a match,
+//   the state change is queued up until the confidence interval has elapsed (and
+//   `StateChangeHandler` is called)
+func (we *watcherEvents) StateChanged(check CheckFunc, scHnd StateChangeHandler, rev RevertHandler, confidence int, timeout abi.ChainEpoch, mf StateMatchFunc) error {
+	hnd := func(data eventData, prevTs, ts *types.TipSet, height abi.ChainEpoch) (bool, error) {
+		states, ok := data.(StateChange)
+		if data != nil && !ok {
+			panic("expected StateChange")
+		}
+
+		return scHnd(prevTs, ts, states, height)
+	}
+
+	id, err := we.hcAPI.onHeadChanged(check, hnd, rev, confidence, timeout)
+	if err != nil {
+		return err
+	}
+
+	we.lk.Lock()
+	defer we.lk.Unlock()
+	we.matchers[id] = mf
+
+	return nil
+}
+
+// messageEvents watches for message calls to actors
+type messageEvents struct {
+	ctx   context.Context
+	cs    eventAPI
+	hcAPI headChangeAPI
+
+	lk       sync.RWMutex
+	matchers map[triggerID][]MsgMatchFunc
+}
+
+func newMessageEvents(ctx context.Context, hcAPI headChangeAPI, cs eventAPI) messageEvents {
+	return messageEvents{
+		ctx:      ctx,
+		cs:       cs,
+		hcAPI:    hcAPI,
+		matchers: map[triggerID][]MsgMatchFunc{},
+	}
+}
+
+// Check if there are any new actor calls
+func (me *messageEvents) checkNewCalls(ts *types.TipSet) (map[triggerID]eventData, error) {
+	pts, err := me.cs.ChainGetTipSet(me.ctx, ts.Parents()) // we actually care about messages in the parent tipset here
+	if err != nil {
+		log.Errorf("getting parent tipset in checkNewCalls: %s", err)
+		return nil, err
+	}
+
+	me.lk.RLock()
+	defer me.lk.RUnlock()
+
+	res := make(map[triggerID]eventData)
+	me.messagesForTs(pts, func(msg *types.Message) {
+		// TODO: provide receipts
+
+		for tid, matchFns := range me.matchers {
+			var matched bool
+			var once bool
+			for _, matchFn := range matchFns {
+				matchOne, ok, err := matchFn(msg)
+				if err != nil {
+					log.Errorf("event matcher failed: %s", err)
+					continue
+				}
+				matched = ok
+				once = matchOne
+
+				if matched {
+					break
+				}
+			}
+
+			if matched {
+				res[tid] = msg
+				if once {
+					break
+				}
+			}
+		}
+	})
+
+	return res, nil
+}
+
+// Get the messages in a tipset
+func (me *messageEvents) messagesForTs(ts *types.TipSet, consume func(*types.Message)) {
 	seen := map[cid.Cid]struct{}{}
 
 	for _, tsb := range ts.Blocks() {
 
-		msgs, err := e.cs.ChainGetBlockMessages(context.TODO(), tsb.Cid())
+		msgs, err := me.cs.ChainGetBlockMessages(context.TODO(), tsb.Cid())
 		if err != nil {
 			log.Errorf("messagesForTs MessagesForBlock failed (ts.H=%d, Bcid:%s, B.Mcid:%s): %s", ts.Height(), tsb.Cid(), tsb.Messages, err)
 			// this is quite bad, but probably better than missing all the other updates
@@ -280,20 +550,27 @@ func (e *calledEvents) messagesForTs(ts *types.TipSet, consume func(*types.Messa
 	}
 }
 
-// Called registers a callbacks which are triggered when a specified method is
+// MsgHandler arguments:
+// `ts` is the tipset, in which the `msg` is included.
+// `curH`-`ts.Height` = `confidence`
+type MsgHandler func(msg *types.Message, rec *types.MessageReceipt, ts *types.TipSet, curH abi.ChainEpoch) (more bool, err error)
+
+type MsgMatchFunc func(msg *types.Message) (matchOnce bool, matched bool, err error)
+
+// Called registers a callback which is triggered when a specified method is
 //  called on an actor, or a timeout is reached.
 //
 // * `CheckFunc` callback is invoked immediately with a recent tipset, it
 //    returns two booleans - `done`, and `more`.
 //
-//  * `done` should be true when some on-chain action we are waiting for has
-//    happened. When `done` is set to true, timeout trigger is disabled.
+//   * `done` should be true when some on-chain action we are waiting for has
+//     happened. When `done` is set to true, timeout trigger is disabled.
 //
-//  * `more` should be false when we don't want to receive new notifications
-//    through CalledHandler. Note that notifications may still be delivered to
-//    RevertHandler
+//   * `more` should be false when we don't want to receive new notifications
+//     through MsgHandler. Note that notifications may still be delivered to
+//     RevertHandler
 //
-// * `CalledHandler` is called when the specified event was observed on-chain,
+// * `MsgHandler` is called when the specified event was observed on-chain,
 //    and a confidence threshold was reached, or the specified `timeout` height
 //    was reached with no events observed. When this callback is invoked on a
 //    timeout, `msg` is set to nil. This callback returns a boolean specifying
@@ -304,44 +581,38 @@ func (e *calledEvents) messagesForTs(ts *types.TipSet, consume func(*types.Messa
 //    containing the message. The tipset passed as the argument is the tipset
 //    that is being dropped. Note that the message dropped may be re-applied
 //    in a different tipset in small amount of time.
-func (e *calledEvents) Called(check CheckFunc, hnd CalledHandler, rev RevertHandler, confidence int, timeout uint64, mf MatchFunc) error {
-	e.lk.Lock()
-	defer e.lk.Unlock()
-
-	ts := e.tsc.best()
-	done, more, err := check(ts)
-	if err != nil {
-		return xerrors.Errorf("called check error (h: %d): %w", ts.Height(), err)
-	}
-	if done {
-		timeout = NoTimeout
-	}
-
-	id := e.ctr
-	e.ctr++
-
-	e.triggers[id] = &callHandler{
-		confidence: confidence,
-		timeout:    timeout + uint64(confidence),
-
-		disabled: !more,
-
-		handle: hnd,
-		revert: rev,
-	}
-
-	e.matchers[id] = append(e.matchers[id], mf)
-
-	if timeout != NoTimeout {
-		if e.timeouts[timeout+uint64(confidence)] == nil {
-			e.timeouts[timeout+uint64(confidence)] = map[uint64]int{}
+//
+// * `MsgMatchFunc` is called against each message. If there is a match, the
+//   message is queued up until the confidence interval has elapsed (and
+//   `MsgHandler` is called)
+func (me *messageEvents) Called(check CheckFunc, msgHnd MsgHandler, rev RevertHandler, confidence int, timeout abi.ChainEpoch, mf MsgMatchFunc) error {
+	hnd := func(data eventData, prevTs, ts *types.TipSet, height abi.ChainEpoch) (bool, error) {
+		msg, ok := data.(*types.Message)
+		if data != nil && !ok {
+			panic("expected msg")
 		}
-		e.timeouts[timeout+uint64(confidence)][id] = 0
+
+		rec, err := me.cs.StateGetReceipt(me.ctx, msg.Cid(), ts.Key())
+		if err != nil {
+			return false, err
+		}
+
+		return msgHnd(msg, rec, ts, height)
 	}
 
+	id, err := me.hcAPI.onHeadChanged(check, hnd, rev, confidence, timeout)
+	if err != nil {
+		return err
+	}
+
+	me.lk.Lock()
+	defer me.lk.Unlock()
+	me.matchers[id] = append(me.matchers[id], mf)
+
 	return nil
 }
 
-func (e *calledEvents) CalledMsg(ctx context.Context, hnd CalledHandler, rev RevertHandler, confidence int, timeout uint64, msg store.ChainMsg) error {
-	return e.Called(e.CheckMsg(ctx, msg, hnd), hnd, rev, confidence, timeout, e.MatchMsg(msg.VMMessage()))
+// Convenience function for checking and matching messages
+func (me *messageEvents) CalledMsg(ctx context.Context, hnd MsgHandler, rev RevertHandler, confidence int, timeout abi.ChainEpoch, msg types.ChainMsg) error {
+	return me.Called(me.CheckMsg(ctx, msg, hnd), hnd, rev, confidence, timeout, me.MatchMsg(msg.VMMessage()))
 }
diff --git a/chain/events/events_height.go b/chain/events/events_height.go
index a407d167a..c8dd905d9 100644
--- a/chain/events/events_height.go
+++ b/chain/events/events_height.go
@@ -4,7 +4,9 @@ import (
 	"context"
 	"sync"
 
+	"github.com/filecoin-project/go-state-types/abi"
 	"go.opencensus.io/trace"
+	"golang.org/x/xerrors"
 
 	"github.com/filecoin-project/lotus/chain/types"
 )
@@ -12,14 +14,14 @@ import (
 type heightEvents struct {
 	lk           sync.Mutex
 	tsc          *tipSetCache
-	gcConfidence uint64
+	gcConfidence abi.ChainEpoch
 
-	ctr triggerId
+	ctr triggerID
 
-	heightTriggers map[triggerId]*heightHandler
+	heightTriggers map[triggerID]*heightHandler
 
-	htTriggerHeights map[triggerH][]triggerId
-	htHeights        map[msgH][]triggerId
+	htTriggerHeights map[triggerH][]triggerID
+	htHeights        map[msgH][]triggerID
 
 	ctx context.Context
 }
@@ -31,15 +33,20 @@ func (e *heightEvents) headChangeAt(rev, app []*types.TipSet) error {
 	span.AddAttributes(trace.Int64Attribute("reverts", int64(len(rev))))
 	span.AddAttributes(trace.Int64Attribute("applies", int64(len(app))))
 
+	e.lk.Lock()
+	defer e.lk.Unlock()
 	for _, ts := range rev {
 		// TODO: log error if h below gcconfidence
 		// revert height-based triggers
 
-		revert := func(h uint64, ts *types.TipSet) {
+		revert := func(h abi.ChainEpoch, ts *types.TipSet) {
 			for _, tid := range e.htHeights[h] {
 				ctx, span := trace.StartSpan(ctx, "events.HeightRevert")
 
-				err := e.heightTriggers[tid].revert(ctx, ts)
+				rev := e.heightTriggers[tid].revert
+				e.lk.Unlock()
+				err := rev(ctx, ts)
+				e.lk.Lock()
 				e.heightTriggers[tid].called = false
 
 				span.End()
@@ -80,15 +87,14 @@ func (e *heightEvents) headChangeAt(rev, app []*types.TipSet) error {
 
 		// height triggers
 
-		apply := func(h uint64, ts *types.TipSet) error {
+		apply := func(h abi.ChainEpoch, ts *types.TipSet) error {
 			for _, tid := range e.htTriggerHeights[h] {
 				hnd := e.heightTriggers[tid]
 				if hnd.called {
 					return nil
 				}
-				hnd.called = true
 
-				triggerH := h - uint64(hnd.confidence)
+				triggerH := h - abi.ChainEpoch(hnd.confidence)
 
 				incTs, err := e.tsc.getNonNull(triggerH)
 				if err != nil {
@@ -97,8 +103,11 @@ func (e *heightEvents) headChangeAt(rev, app []*types.TipSet) error {
 
 				ctx, span := trace.StartSpan(ctx, "events.HeightApply")
 				span.AddAttributes(trace.BoolAttribute("immediate", false))
-
-				err = hnd.handle(ctx, incTs, h)
+				handle := hnd.handle
+				e.lk.Unlock()
+				err = handle(ctx, incTs, h)
+				e.lk.Lock()
+				hnd.called = true
 				span.End()
 
 				if err != nil {
@@ -135,17 +144,20 @@ func (e *heightEvents) headChangeAt(rev, app []*types.TipSet) error {
 }
 
 // ChainAt invokes the specified `HeightHandler` when the chain reaches the
-//  specified height+confidence threshold. If the chain is rolled-back under the
-//  specified height, `RevertHandler` will be called.
+// specified height+confidence threshold. If the chain is rolled-back under the
+// specified height, `RevertHandler` will be called.
 //
 // ts passed to handlers is the tipset at the specified, or above, if lower tipsets were null
-func (e *heightEvents) ChainAt(hnd HeightHandler, rev RevertHandler, confidence int, h uint64) error {
-
+func (e *heightEvents) ChainAt(hnd HeightHandler, rev RevertHandler, confidence int, h abi.ChainEpoch) error {
 	e.lk.Lock() // Tricky locking, check your locks if you modify this function!
 
-	bestH := e.tsc.best().Height()
+	best, err := e.tsc.best()
+	if err != nil {
+		return xerrors.Errorf("error getting best tipset: %w", err)
+	}
 
-	if bestH >= h+uint64(confidence) {
+	bestH := best.Height()
+	if bestH >= h+abi.ChainEpoch(confidence) {
 		ts, err := e.tsc.getNonNull(h)
 		if err != nil {
 			log.Warnf("events.ChainAt: calling HandleFunc with nil tipset, not found in cache: %s", err)
@@ -163,16 +175,20 @@ func (e *heightEvents) ChainAt(hnd HeightHandler, rev RevertHandler, confidence
 		}
 
 		e.lk.Lock()
-		bestH = e.tsc.best().Height()
+		best, err = e.tsc.best()
+		if err != nil {
+			return xerrors.Errorf("error getting best tipset: %w", err)
+		}
+		bestH = best.Height()
 	}
 
 	defer e.lk.Unlock()
 
-	if bestH >= h+uint64(confidence)+e.gcConfidence {
+	if bestH >= h+abi.ChainEpoch(confidence)+e.gcConfidence {
 		return nil
 	}
 
-	triggerAt := h + uint64(confidence)
+	triggerAt := h + abi.ChainEpoch(confidence)
 
 	id := e.ctr
 	e.ctr++
diff --git a/chain/events/events_test.go b/chain/events/events_test.go
index a18c916e2..0e4fd34b2 100644
--- a/chain/events/events_test.go
+++ b/chain/events/events_test.go
@@ -3,18 +3,20 @@ package events
 import (
 	"context"
 	"fmt"
+	"sync"
 	"testing"
-	"time"
-
-	"github.com/filecoin-project/lotus/api"
-	"github.com/filecoin-project/lotus/chain/store"
 
 	"github.com/ipfs/go-cid"
 	"github.com/multiformats/go-multihash"
 	"github.com/stretchr/testify/require"
 
 	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/crypto"
+
+	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/store"
 	"github.com/filecoin-project/lotus/chain/types"
 )
 
@@ -31,28 +33,40 @@ type fakeMsg struct {
 
 type fakeCS struct {
 	t   *testing.T
-	h   uint64
+	h   abi.ChainEpoch
 	tsc *tipSetCache
 
 	msgs    map[cid.Cid]fakeMsg
 	blkMsgs map[cid.Cid]cid.Cid
 
+	sync sync.Mutex
+
+	tipsets map[types.TipSetKey]*types.TipSet
+
 	sub func(rev, app []*types.TipSet)
 }
 
-func (fcs *fakeCS) StateGetReceipt(context.Context, cid.Cid, *types.TipSet) (*types.MessageReceipt, error) {
+func (fcs *fakeCS) ChainHead(ctx context.Context) (*types.TipSet, error) {
+	panic("implement me")
+}
+
+func (fcs *fakeCS) ChainGetTipSet(ctx context.Context, key types.TipSetKey) (*types.TipSet, error) {
+	return fcs.tipsets[key], nil
+}
+
+func (fcs *fakeCS) StateGetReceipt(context.Context, cid.Cid, types.TipSetKey) (*types.MessageReceipt, error) {
 	return nil, nil
 }
 
-func (fcs *fakeCS) StateGetActor(ctx context.Context, actor address.Address, ts *types.TipSet) (*types.Actor, error) {
+func (fcs *fakeCS) StateGetActor(ctx context.Context, actor address.Address, tsk types.TipSetKey) (*types.Actor, error) {
 	panic("Not Implemented")
 }
 
-func (fcs *fakeCS) ChainGetTipSetByHeight(context.Context, uint64, *types.TipSet) (*types.TipSet, error) {
+func (fcs *fakeCS) ChainGetTipSetByHeight(context.Context, abi.ChainEpoch, types.TipSetKey) (*types.TipSet, error) {
 	panic("Not Implemented")
 }
 
-func makeTs(t *testing.T, h uint64, msgcid cid.Cid) *types.TipSet {
+func (fcs *fakeCS) makeTs(t *testing.T, parents []cid.Cid, h abi.ChainEpoch, msgcid cid.Cid) *types.TipSet {
 	a, _ := address.NewFromString("t00")
 	b, _ := address.NewFromString("t02")
 	var ts, err = types.NewTipSet([]*types.BlockHeader{
@@ -60,50 +74,63 @@ func makeTs(t *testing.T, h uint64, msgcid cid.Cid) *types.TipSet {
 			Height: h,
 			Miner:  a,
 
+			Parents: parents,
+
 			Ticket: &types.Ticket{VRFProof: []byte{byte(h % 2)}},
 
 			ParentStateRoot:       dummyCid,
 			Messages:              msgcid,
 			ParentMessageReceipts: dummyCid,
 
-			BlockSig:     &types.Signature{Type: types.KTBLS},
-			BLSAggregate: types.Signature{Type: types.KTBLS},
+			BlockSig:     &crypto.Signature{Type: crypto.SigTypeBLS},
+			BLSAggregate: &crypto.Signature{Type: crypto.SigTypeBLS},
 		},
 		{
 			Height: h,
 			Miner:  b,
 
+			Parents: parents,
+
 			Ticket: &types.Ticket{VRFProof: []byte{byte((h + 1) % 2)}},
 
 			ParentStateRoot:       dummyCid,
 			Messages:              msgcid,
 			ParentMessageReceipts: dummyCid,
 
-			BlockSig:     &types.Signature{Type: types.KTBLS},
-			BLSAggregate: types.Signature{Type: types.KTBLS},
+			BlockSig:     &crypto.Signature{Type: crypto.SigTypeBLS},
+			BLSAggregate: &crypto.Signature{Type: crypto.SigTypeBLS},
 		},
 	})
 
+	if fcs.tipsets == nil {
+		fcs.tipsets = map[types.TipSetKey]*types.TipSet{}
+	}
+	fcs.tipsets[ts.Key()] = ts
+
 	require.NoError(t, err)
 
 	return ts
 }
 
-func (fcs *fakeCS) ChainNotify(context.Context) (<-chan []*store.HeadChange, error) {
-	out := make(chan []*store.HeadChange, 1)
-	out <- []*store.HeadChange{{Type: store.HCCurrent, Val: fcs.tsc.best()}}
+func (fcs *fakeCS) ChainNotify(context.Context) (<-chan []*api.HeadChange, error) {
+	out := make(chan []*api.HeadChange, 1)
+	best, err := fcs.tsc.best()
+	if err != nil {
+		return nil, err
+	}
+	out <- []*api.HeadChange{{Type: store.HCCurrent, Val: best}}
 
 	fcs.sub = func(rev, app []*types.TipSet) {
-		notif := make([]*store.HeadChange, len(rev)+len(app))
+		notif := make([]*api.HeadChange, len(rev)+len(app))
 
 		for i, r := range rev {
-			notif[i] = &store.HeadChange{
+			notif[i] = &api.HeadChange{
 				Type: store.HCRevert,
 				Val:  r,
 			}
 		}
 		for i, r := range app {
-			notif[i+len(rev)] = &store.HeadChange{
+			notif[i+len(rev)] = &api.HeadChange{
 				Type: store.HCApply,
 				Val:  r,
 			}
@@ -155,7 +182,8 @@ func (fcs *fakeCS) advance(rev, app int, msgs map[int]cid.Cid, nulls ...int) { /
 
 	var revs []*types.TipSet
 	for i := 0; i < rev; i++ {
-		ts := fcs.tsc.best()
+		ts, err := fcs.tsc.best()
+		require.NoError(fcs.t, err)
 
 		if _, ok := nullm[int(ts.Height())]; !ok {
 			revs = append(revs, ts)
@@ -177,7 +205,9 @@ func (fcs *fakeCS) advance(rev, app int, msgs map[int]cid.Cid, nulls ...int) { /
 			continue
 		}
 
-		ts := makeTs(fcs.t, fcs.h, mc)
+		best, err := fcs.tsc.best()
+		require.NoError(fcs.t, err)
+		ts := fcs.makeTs(fcs.t, best.Key().Cids(), fcs.h, mc)
 		require.NoError(fcs.t, fcs.tsc.add(ts))
 
 		if hasMsgs {
@@ -187,11 +217,19 @@ func (fcs *fakeCS) advance(rev, app int, msgs map[int]cid.Cid, nulls ...int) { /
 		apps = append(apps, ts)
 	}
 
+	fcs.sync.Lock()
+
 	fcs.sub(revs, apps)
-	time.Sleep(100 * time.Millisecond) // TODO: :c
+
+	fcs.sync.Lock()
+	fcs.sync.Unlock() //nolint:staticcheck
 }
 
-var _ eventApi = &fakeCS{}
+func (fcs *fakeCS) notifDone() {
+	fcs.sync.Unlock()
+}
+
+var _ eventAPI = &fakeCS{}
 
 func TestAt(t *testing.T) {
 	fcs := &fakeCS{
@@ -199,14 +237,14 @@ func TestAt(t *testing.T) {
 		h:   1,
 		tsc: newTSCache(2*build.ForkLengthThreshold, nil),
 	}
-	require.NoError(t, fcs.tsc.add(makeTs(t, 1, dummyCid)))
+	require.NoError(t, fcs.tsc.add(fcs.makeTs(t, nil, 1, dummyCid)))
 
 	events := NewEvents(context.Background(), fcs)
 
 	var applied bool
 	var reverted bool
 
-	err := events.ChainAt(func(_ context.Context, ts *types.TipSet, curH uint64) error {
+	err := events.ChainAt(func(_ context.Context, ts *types.TipSet, curH abi.ChainEpoch) error {
 		require.Equal(t, 5, int(ts.Height()))
 		require.Equal(t, 8, int(curH))
 		applied = true
@@ -264,14 +302,14 @@ func TestAtDoubleTrigger(t *testing.T) {
 		h:   1,
 		tsc: newTSCache(2*build.ForkLengthThreshold, nil),
 	}
-	require.NoError(t, fcs.tsc.add(makeTs(t, 1, dummyCid)))
+	require.NoError(t, fcs.tsc.add(fcs.makeTs(t, nil, 1, dummyCid)))
 
 	events := NewEvents(context.Background(), fcs)
 
 	var applied bool
 	var reverted bool
 
-	err := events.ChainAt(func(_ context.Context, ts *types.TipSet, curH uint64) error {
+	err := events.ChainAt(func(_ context.Context, ts *types.TipSet, curH abi.ChainEpoch) error {
 		require.Equal(t, 5, int(ts.Height()))
 		require.Equal(t, 8, int(curH))
 		applied = true
@@ -306,15 +344,15 @@ func TestAtNullTrigger(t *testing.T) {
 		h:   1,
 		tsc: newTSCache(2*build.ForkLengthThreshold, nil),
 	}
-	require.NoError(t, fcs.tsc.add(makeTs(t, 1, dummyCid)))
+	require.NoError(t, fcs.tsc.add(fcs.makeTs(t, nil, 1, dummyCid)))
 
 	events := NewEvents(context.Background(), fcs)
 
 	var applied bool
 	var reverted bool
 
-	err := events.ChainAt(func(_ context.Context, ts *types.TipSet, curH uint64) error {
-		require.Equal(t, uint64(6), ts.Height())
+	err := events.ChainAt(func(_ context.Context, ts *types.TipSet, curH abi.ChainEpoch) error {
+		require.Equal(t, abi.ChainEpoch(6), ts.Height())
 		require.Equal(t, 8, int(curH))
 		applied = true
 		return nil
@@ -340,14 +378,14 @@ func TestAtNullConf(t *testing.T) {
 		h:   1,
 		tsc: newTSCache(2*build.ForkLengthThreshold, nil),
 	}
-	require.NoError(t, fcs.tsc.add(makeTs(t, 1, dummyCid)))
+	require.NoError(t, fcs.tsc.add(fcs.makeTs(t, nil, 1, dummyCid)))
 
 	events := NewEvents(context.Background(), fcs)
 
 	var applied bool
 	var reverted bool
 
-	err := events.ChainAt(func(_ context.Context, ts *types.TipSet, curH uint64) error {
+	err := events.ChainAt(func(_ context.Context, ts *types.TipSet, curH abi.ChainEpoch) error {
 		require.Equal(t, 5, int(ts.Height()))
 		require.Equal(t, 8, int(curH))
 		applied = true
@@ -379,7 +417,7 @@ func TestAtStart(t *testing.T) {
 		h:   1,
 		tsc: newTSCache(2*build.ForkLengthThreshold, nil),
 	}
-	require.NoError(t, fcs.tsc.add(makeTs(t, 1, dummyCid)))
+	require.NoError(t, fcs.tsc.add(fcs.makeTs(t, nil, 1, dummyCid)))
 
 	events := NewEvents(context.Background(), fcs)
 
@@ -388,7 +426,7 @@ func TestAtStart(t *testing.T) {
 	var applied bool
 	var reverted bool
 
-	err := events.ChainAt(func(_ context.Context, ts *types.TipSet, curH uint64) error {
+	err := events.ChainAt(func(_ context.Context, ts *types.TipSet, curH abi.ChainEpoch) error {
 		require.Equal(t, 5, int(ts.Height()))
 		require.Equal(t, 8, int(curH))
 		applied = true
@@ -413,7 +451,7 @@ func TestAtStartConfidence(t *testing.T) {
 		h:   1,
 		tsc: newTSCache(2*build.ForkLengthThreshold, nil),
 	}
-	require.NoError(t, fcs.tsc.add(makeTs(t, 1, dummyCid)))
+	require.NoError(t, fcs.tsc.add(fcs.makeTs(t, nil, 1, dummyCid)))
 
 	events := NewEvents(context.Background(), fcs)
 
@@ -422,7 +460,7 @@ func TestAtStartConfidence(t *testing.T) {
 	var applied bool
 	var reverted bool
 
-	err := events.ChainAt(func(_ context.Context, ts *types.TipSet, curH uint64) error {
+	err := events.ChainAt(func(_ context.Context, ts *types.TipSet, curH abi.ChainEpoch) error {
 		require.Equal(t, 5, int(ts.Height()))
 		require.Equal(t, 11, int(curH))
 		applied = true
@@ -443,15 +481,15 @@ func TestAtChained(t *testing.T) {
 		h:   1,
 		tsc: newTSCache(2*build.ForkLengthThreshold, nil),
 	}
-	require.NoError(t, fcs.tsc.add(makeTs(t, 1, dummyCid)))
+	require.NoError(t, fcs.tsc.add(fcs.makeTs(t, nil, 1, dummyCid)))
 
 	events := NewEvents(context.Background(), fcs)
 
 	var applied bool
 	var reverted bool
 
-	err := events.ChainAt(func(_ context.Context, ts *types.TipSet, curH uint64) error {
-		return events.ChainAt(func(_ context.Context, ts *types.TipSet, curH uint64) error {
+	err := events.ChainAt(func(_ context.Context, ts *types.TipSet, curH abi.ChainEpoch) error {
+		return events.ChainAt(func(_ context.Context, ts *types.TipSet, curH abi.ChainEpoch) error {
 			require.Equal(t, 10, int(ts.Height()))
 			applied = true
 			return nil
@@ -477,7 +515,7 @@ func TestAtChainedConfidence(t *testing.T) {
 		h:   1,
 		tsc: newTSCache(2*build.ForkLengthThreshold, nil),
 	}
-	require.NoError(t, fcs.tsc.add(makeTs(t, 1, dummyCid)))
+	require.NoError(t, fcs.tsc.add(fcs.makeTs(t, nil, 1, dummyCid)))
 
 	events := NewEvents(context.Background(), fcs)
 
@@ -486,8 +524,8 @@ func TestAtChainedConfidence(t *testing.T) {
 	var applied bool
 	var reverted bool
 
-	err := events.ChainAt(func(_ context.Context, ts *types.TipSet, curH uint64) error {
-		return events.ChainAt(func(_ context.Context, ts *types.TipSet, curH uint64) error {
+	err := events.ChainAt(func(_ context.Context, ts *types.TipSet, curH abi.ChainEpoch) error {
+		return events.ChainAt(func(_ context.Context, ts *types.TipSet, curH abi.ChainEpoch) error {
 			require.Equal(t, 10, int(ts.Height()))
 			applied = true
 			return nil
@@ -511,7 +549,7 @@ func TestAtChainedConfidenceNull(t *testing.T) {
 		h:   1,
 		tsc: newTSCache(2*build.ForkLengthThreshold, nil),
 	}
-	require.NoError(t, fcs.tsc.add(makeTs(t, 1, dummyCid)))
+	require.NoError(t, fcs.tsc.add(fcs.makeTs(t, nil, 1, dummyCid)))
 
 	events := NewEvents(context.Background(), fcs)
 
@@ -520,7 +558,7 @@ func TestAtChainedConfidenceNull(t *testing.T) {
 	var applied bool
 	var reverted bool
 
-	err := events.ChainAt(func(_ context.Context, ts *types.TipSet, curH uint64) error {
+	err := events.ChainAt(func(_ context.Context, ts *types.TipSet, curH abi.ChainEpoch) error {
 		applied = true
 		require.Equal(t, 6, int(ts.Height()))
 		return nil
@@ -534,9 +572,9 @@ func TestAtChainedConfidenceNull(t *testing.T) {
 	require.Equal(t, false, reverted)
 }
 
-func matchAddrMethod(to address.Address, m uint64) func(msg *types.Message) (bool, error) {
-	return func(msg *types.Message) (bool, error) {
-		return to == msg.To && m == msg.Method, nil
+func matchAddrMethod(to address.Address, m abi.MethodNum) func(msg *types.Message) (matchOnce bool, matched bool, err error) {
+	return func(msg *types.Message) (matchOnce bool, matched bool, err error) {
+		return true, to == msg.To && m == msg.Method, nil
 	}
 }
 
@@ -549,7 +587,7 @@ func TestCalled(t *testing.T) {
 		blkMsgs: map[cid.Cid]cid.Cid{},
 		tsc:     newTSCache(2*build.ForkLengthThreshold, nil),
 	}
-	require.NoError(t, fcs.tsc.add(makeTs(t, 1, dummyCid)))
+	require.NoError(t, fcs.tsc.add(fcs.makeTs(t, nil, 1, dummyCid)))
 
 	events := NewEvents(context.Background(), fcs)
 
@@ -560,11 +598,11 @@ func TestCalled(t *testing.T) {
 	var applied, reverted bool
 	var appliedMsg *types.Message
 	var appliedTs *types.TipSet
-	var appliedH uint64
+	var appliedH abi.ChainEpoch
 
 	err = events.Called(func(ts *types.TipSet) (d bool, m bool, e error) {
 		return false, true, nil
-	}, func(msg *types.Message, rec *types.MessageReceipt, ts *types.TipSet, curH uint64) (bool, error) {
+	}, func(msg *types.Message, rec *types.MessageReceipt, ts *types.TipSet, curH abi.ChainEpoch) (bool, error) {
 		require.Equal(t, false, applied)
 		applied = true
 		appliedMsg = msg
@@ -610,12 +648,12 @@ func TestCalled(t *testing.T) {
 	require.Equal(t, false, applied)
 	require.Equal(t, false, reverted)
 
-	require.Equal(t, uint64(7), appliedTs.Height())
+	require.Equal(t, abi.ChainEpoch(7), appliedTs.Height())
 	require.Equal(t, "bafkqaaa", appliedTs.Blocks()[0].Messages.String())
-	require.Equal(t, uint64(10), appliedH)
+	require.Equal(t, abi.ChainEpoch(10), appliedH)
 	require.Equal(t, t0123, appliedMsg.To)
 	require.Equal(t, uint64(1), appliedMsg.Nonce)
-	require.Equal(t, uint64(5), appliedMsg.Method)
+	require.Equal(t, abi.MethodNum(5), appliedMsg.Method)
 
 	// revert some blocks, keep the message
 
@@ -625,7 +663,7 @@ func TestCalled(t *testing.T) {
 
 	// revert the message
 
-	fcs.advance(2, 1, nil) // H=7, we reverted ts with the msg
+	fcs.advance(2, 1, nil) // H=7, we reverted ts with the msg execution, but not the msg itself
 
 	require.Equal(t, false, applied)
 	require.Equal(t, true, reverted)
@@ -639,24 +677,31 @@ func TestCalled(t *testing.T) {
 		},
 	})
 
-	fcs.advance(0, 5, map[int]cid.Cid{ // (confidence=3)
+	fcs.advance(0, 3, map[int]cid.Cid{ // (n2msg confidence=1)
 		0: n2msg,
 	})
 
+	require.Equal(t, true, applied) // msg from H=7, which had reverted execution
+	require.Equal(t, false, reverted)
+	require.Equal(t, abi.ChainEpoch(10), appliedH)
+	applied = false
+
+	fcs.advance(0, 2, nil) // (confidence=3)
+
 	require.Equal(t, true, applied)
 	require.Equal(t, false, reverted)
 	applied = false
 
-	require.Equal(t, uint64(9), appliedTs.Height())
+	require.Equal(t, abi.ChainEpoch(9), appliedTs.Height())
 	require.Equal(t, "bafkqaaa", appliedTs.Blocks()[0].Messages.String())
-	require.Equal(t, uint64(12), appliedH)
+	require.Equal(t, abi.ChainEpoch(12), appliedH)
 	require.Equal(t, t0123, appliedMsg.To)
 	require.Equal(t, uint64(2), appliedMsg.Nonce)
-	require.Equal(t, uint64(5), appliedMsg.Method)
+	require.Equal(t, abi.MethodNum(5), appliedMsg.Method)
 
 	// revert and apply at different height
 
-	fcs.advance(4, 6, map[int]cid.Cid{ // (confidence=3)
+	fcs.advance(8, 6, map[int]cid.Cid{ // (confidence=3)
 		1: n2msg,
 	})
 
@@ -668,12 +713,12 @@ func TestCalled(t *testing.T) {
 	reverted = false
 	applied = false
 
-	require.Equal(t, uint64(11), appliedTs.Height())
+	require.Equal(t, abi.ChainEpoch(7), appliedTs.Height())
 	require.Equal(t, "bafkqaaa", appliedTs.Blocks()[0].Messages.String())
-	require.Equal(t, uint64(14), appliedH)
+	require.Equal(t, abi.ChainEpoch(10), appliedH)
 	require.Equal(t, t0123, appliedMsg.To)
 	require.Equal(t, uint64(2), appliedMsg.Nonce)
-	require.Equal(t, uint64(5), appliedMsg.Method)
+	require.Equal(t, abi.MethodNum(5), appliedMsg.Method)
 
 	// call method again
 
@@ -694,7 +739,7 @@ func TestCalled(t *testing.T) {
 		}),
 	})
 
-	fcs.advance(1, 4, nil) // H=19, but message reverted
+	fcs.advance(2, 5, nil) // H=19, but message reverted
 
 	require.Equal(t, false, applied)
 	require.Equal(t, false, reverted)
@@ -754,7 +799,7 @@ func TestCalledTimeout(t *testing.T) {
 		blkMsgs: map[cid.Cid]cid.Cid{},
 		tsc:     newTSCache(2*build.ForkLengthThreshold, nil),
 	}
-	require.NoError(t, fcs.tsc.add(makeTs(t, 1, dummyCid)))
+	require.NoError(t, fcs.tsc.add(fcs.makeTs(t, nil, 1, dummyCid)))
 
 	events := NewEvents(context.Background(), fcs)
 
@@ -765,11 +810,11 @@ func TestCalledTimeout(t *testing.T) {
 
 	err = events.Called(func(ts *types.TipSet) (d bool, m bool, e error) {
 		return false, true, nil
-	}, func(msg *types.Message, rec *types.MessageReceipt, ts *types.TipSet, curH uint64) (bool, error) {
+	}, func(msg *types.Message, rec *types.MessageReceipt, ts *types.TipSet, curH abi.ChainEpoch) (bool, error) {
 		called = true
 		require.Nil(t, msg)
-		require.Equal(t, uint64(20), ts.Height())
-		require.Equal(t, uint64(23), curH)
+		require.Equal(t, abi.ChainEpoch(20), ts.Height())
+		require.Equal(t, abi.ChainEpoch(23), curH)
 		return false, nil
 	}, func(_ context.Context, ts *types.TipSet) error {
 		t.Fatal("revert on timeout")
@@ -794,17 +839,17 @@ func TestCalledTimeout(t *testing.T) {
 		blkMsgs: map[cid.Cid]cid.Cid{},
 		tsc:     newTSCache(2*build.ForkLengthThreshold, nil),
 	}
-	require.NoError(t, fcs.tsc.add(makeTs(t, 1, dummyCid)))
+	require.NoError(t, fcs.tsc.add(fcs.makeTs(t, nil, 1, dummyCid)))
 
 	events = NewEvents(context.Background(), fcs)
 
 	err = events.Called(func(ts *types.TipSet) (d bool, m bool, e error) {
 		return true, true, nil
-	}, func(msg *types.Message, rec *types.MessageReceipt, ts *types.TipSet, curH uint64) (bool, error) {
+	}, func(msg *types.Message, rec *types.MessageReceipt, ts *types.TipSet, curH abi.ChainEpoch) (bool, error) {
 		called = true
 		require.Nil(t, msg)
-		require.Equal(t, uint64(20), ts.Height())
-		require.Equal(t, uint64(23), curH)
+		require.Equal(t, abi.ChainEpoch(20), ts.Height())
+		require.Equal(t, abi.ChainEpoch(23), curH)
 		return false, nil
 	}, func(_ context.Context, ts *types.TipSet) error {
 		t.Fatal("revert on timeout")
@@ -828,7 +873,7 @@ func TestCalledOrder(t *testing.T) {
 		blkMsgs: map[cid.Cid]cid.Cid{},
 		tsc:     newTSCache(2*build.ForkLengthThreshold, nil),
 	}
-	require.NoError(t, fcs.tsc.add(makeTs(t, 1, dummyCid)))
+	require.NoError(t, fcs.tsc.add(fcs.makeTs(t, nil, 1, dummyCid)))
 
 	events := NewEvents(context.Background(), fcs)
 
@@ -839,14 +884,14 @@ func TestCalledOrder(t *testing.T) {
 
 	err = events.Called(func(ts *types.TipSet) (d bool, m bool, e error) {
 		return false, true, nil
-	}, func(msg *types.Message, rec *types.MessageReceipt, ts *types.TipSet, curH uint64) (bool, error) {
+	}, func(msg *types.Message, rec *types.MessageReceipt, ts *types.TipSet, curH abi.ChainEpoch) (bool, error) {
 		switch at {
 		case 0:
 			require.Equal(t, uint64(1), msg.Nonce)
-			require.Equal(t, uint64(4), ts.Height())
+			require.Equal(t, abi.ChainEpoch(4), ts.Height())
 		case 1:
 			require.Equal(t, uint64(2), msg.Nonce)
-			require.Equal(t, uint64(5), ts.Height())
+			require.Equal(t, abi.ChainEpoch(5), ts.Height())
 		default:
 			t.Fatal("apply should only get called twice, at: ", at)
 		}
@@ -855,9 +900,9 @@ func TestCalledOrder(t *testing.T) {
 	}, func(_ context.Context, ts *types.TipSet) error {
 		switch at {
 		case 2:
-			require.Equal(t, uint64(5), ts.Height())
+			require.Equal(t, abi.ChainEpoch(5), ts.Height())
 		case 3:
-			require.Equal(t, uint64(4), ts.Height())
+			require.Equal(t, abi.ChainEpoch(4), ts.Height())
 		default:
 			t.Fatal("revert should only get called twice, at: ", at)
 		}
@@ -881,3 +926,400 @@ func TestCalledOrder(t *testing.T) {
 
 	fcs.advance(9, 1, nil)
 }
+
+func TestCalledNull(t *testing.T) {
+	fcs := &fakeCS{
+		t: t,
+		h: 1,
+
+		msgs:    map[cid.Cid]fakeMsg{},
+		blkMsgs: map[cid.Cid]cid.Cid{},
+		tsc:     newTSCache(2*build.ForkLengthThreshold, nil),
+	}
+	require.NoError(t, fcs.tsc.add(fcs.makeTs(t, nil, 1, dummyCid)))
+
+	events := NewEvents(context.Background(), fcs)
+
+	t0123, err := address.NewFromString("t0123")
+	require.NoError(t, err)
+
+	more := true
+	var applied, reverted bool
+
+	err = events.Called(func(ts *types.TipSet) (d bool, m bool, e error) {
+		return false, true, nil
+	}, func(msg *types.Message, rec *types.MessageReceipt, ts *types.TipSet, curH abi.ChainEpoch) (bool, error) {
+		require.Equal(t, false, applied)
+		applied = true
+		return more, nil
+	}, func(_ context.Context, ts *types.TipSet) error {
+		reverted = true
+		return nil
+	}, 3, 20, matchAddrMethod(t0123, 5))
+	require.NoError(t, err)
+
+	// create few blocks to make sure nothing get's randomly called
+
+	fcs.advance(0, 4, nil) // H=5
+	require.Equal(t, false, applied)
+	require.Equal(t, false, reverted)
+
+	// create blocks with message (but below confidence threshold)
+
+	fcs.advance(0, 3, map[int]cid.Cid{ // msg at H=6; H=8 (confidence=2)
+		0: fcs.fakeMsgs(fakeMsg{
+			bmsgs: []*types.Message{
+				{To: t0123, From: t0123, Method: 5, Nonce: 1},
+			},
+		}),
+	})
+
+	require.Equal(t, false, applied)
+	require.Equal(t, false, reverted)
+
+	// create additional blocks so we are above confidence threshold, but with null tipset at the height
+	// of application
+
+	fcs.advance(0, 3, nil, 10) // H=11 (confidence=3, apply)
+
+	require.Equal(t, true, applied)
+	require.Equal(t, false, reverted)
+	applied = false
+
+	fcs.advance(5, 1, nil, 10)
+
+	require.Equal(t, false, applied)
+	require.Equal(t, true, reverted)
+}
+
+func TestRemoveTriggersOnMessage(t *testing.T) {
+	fcs := &fakeCS{
+		t: t,
+		h: 1,
+
+		msgs:    map[cid.Cid]fakeMsg{},
+		blkMsgs: map[cid.Cid]cid.Cid{},
+		tsc:     newTSCache(2*build.ForkLengthThreshold, nil),
+	}
+	require.NoError(t, fcs.tsc.add(fcs.makeTs(t, nil, 1, dummyCid)))
+
+	events := NewEvents(context.Background(), fcs)
+
+	t0123, err := address.NewFromString("t0123")
+	require.NoError(t, err)
+
+	more := true
+	var applied, reverted bool
+
+	err = events.Called(func(ts *types.TipSet) (d bool, m bool, e error) {
+		return false, true, nil
+	}, func(msg *types.Message, rec *types.MessageReceipt, ts *types.TipSet, curH abi.ChainEpoch) (bool, error) {
+		require.Equal(t, false, applied)
+		applied = true
+		return more, nil
+	}, func(_ context.Context, ts *types.TipSet) error {
+		reverted = true
+		return nil
+	}, 3, 20, matchAddrMethod(t0123, 5))
+	require.NoError(t, err)
+
+	// create few blocks to make sure nothing get's randomly called
+
+	fcs.advance(0, 4, nil) // H=5
+	require.Equal(t, false, applied)
+	require.Equal(t, false, reverted)
+
+	// create blocks with message (but below confidence threshold)
+
+	fcs.advance(0, 3, map[int]cid.Cid{ // msg occurs at H=5, applied at H=6; H=8 (confidence=2)
+		0: fcs.fakeMsgs(fakeMsg{
+			bmsgs: []*types.Message{
+				{To: t0123, From: t0123, Method: 5, Nonce: 1},
+			},
+		}),
+	})
+
+	require.Equal(t, false, applied)
+	require.Equal(t, false, reverted)
+
+	// revert applied TS & message TS
+	fcs.advance(3, 1, nil) // H=6 (tipset message applied in reverted, AND message reverted)
+	require.Equal(t, false, applied)
+	require.Equal(t, false, reverted)
+
+	// create additional blocks so we are above confidence threshold, but message not applied
+	// as it was reverted
+	fcs.advance(0, 5, nil) // H=11 (confidence=3, apply)
+	require.Equal(t, false, applied)
+	require.Equal(t, false, reverted)
+
+	// create blocks with message again (but below confidence threshold)
+
+	fcs.advance(0, 3, map[int]cid.Cid{ // msg occurs at H=12, applied at H=13; H=15 (confidence=2)
+		0: fcs.fakeMsgs(fakeMsg{
+			bmsgs: []*types.Message{
+				{To: t0123, From: t0123, Method: 5, Nonce: 2},
+			},
+		}),
+	})
+	require.Equal(t, false, applied)
+	require.Equal(t, false, reverted)
+
+	// revert applied height TS, but don't remove message trigger
+	fcs.advance(2, 1, nil) // H=13 (tipset message applied in reverted, by tipset with message not reverted)
+	require.Equal(t, false, applied)
+	require.Equal(t, false, reverted)
+
+	// create additional blocks so we are above confidence threshold
+	fcs.advance(0, 4, nil) // H=18 (confidence=3, apply)
+
+	require.Equal(t, true, applied)
+	require.Equal(t, false, reverted)
+}
+
+type testStateChange struct {
+	from string
+	to   string
+}
+
+func TestStateChanged(t *testing.T) {
+	fcs := &fakeCS{
+		t: t,
+		h: 1,
+
+		msgs:    map[cid.Cid]fakeMsg{},
+		blkMsgs: map[cid.Cid]cid.Cid{},
+		tsc:     newTSCache(2*build.ForkLengthThreshold, nil),
+	}
+	require.NoError(t, fcs.tsc.add(fcs.makeTs(t, nil, 1, dummyCid)))
+
+	events := NewEvents(context.Background(), fcs)
+
+	more := true
+	var applied, reverted bool
+	var appliedData StateChange
+	var appliedOldTs *types.TipSet
+	var appliedNewTs *types.TipSet
+	var appliedH abi.ChainEpoch
+	var matchData StateChange
+
+	confidence := 3
+	timeout := abi.ChainEpoch(20)
+
+	err := events.StateChanged(func(ts *types.TipSet) (d bool, m bool, e error) {
+		return false, true, nil
+	}, func(oldTs, newTs *types.TipSet, data StateChange, curH abi.ChainEpoch) (bool, error) {
+		require.Equal(t, false, applied)
+		applied = true
+		appliedData = data
+		appliedOldTs = oldTs
+		appliedNewTs = newTs
+		appliedH = curH
+		return more, nil
+	}, func(_ context.Context, ts *types.TipSet) error {
+		reverted = true
+		return nil
+	}, confidence, timeout, func(oldTs, newTs *types.TipSet) (bool, StateChange, error) {
+		if matchData == nil {
+			return false, matchData, nil
+		}
+
+		d := matchData
+		matchData = nil
+		return true, d, nil
+	})
+	require.NoError(t, err)
+
+	// create few blocks to make sure nothing get's randomly called
+
+	fcs.advance(0, 4, nil) // H=5
+	require.Equal(t, false, applied)
+	require.Equal(t, false, reverted)
+
+	// create state change (but below confidence threshold)
+	matchData = testStateChange{from: "a", to: "b"}
+	fcs.advance(0, 3, nil)
+
+	require.Equal(t, false, applied)
+	require.Equal(t, false, reverted)
+
+	// create additional block so we are above confidence threshold
+
+	fcs.advance(0, 2, nil) // H=10 (confidence=3, apply)
+
+	require.Equal(t, true, applied)
+	require.Equal(t, false, reverted)
+	applied = false
+
+	// dip below confidence (should not apply again)
+	fcs.advance(2, 2, nil) // H=10 (confidence=3, apply)
+
+	require.Equal(t, false, applied)
+	require.Equal(t, false, reverted)
+
+	// Change happens from 5 -> 6
+	require.Equal(t, abi.ChainEpoch(5), appliedOldTs.Height())
+	require.Equal(t, abi.ChainEpoch(6), appliedNewTs.Height())
+
+	// Actually applied (with confidence) at 9
+	require.Equal(t, abi.ChainEpoch(9), appliedH)
+
+	// Make sure the state change was correctly passed through
+	rcvd := appliedData.(testStateChange)
+	require.Equal(t, "a", rcvd.from)
+	require.Equal(t, "b", rcvd.to)
+}
+
+func TestStateChangedRevert(t *testing.T) {
+	fcs := &fakeCS{
+		t: t,
+		h: 1,
+
+		msgs:    map[cid.Cid]fakeMsg{},
+		blkMsgs: map[cid.Cid]cid.Cid{},
+		tsc:     newTSCache(2*build.ForkLengthThreshold, nil),
+	}
+	require.NoError(t, fcs.tsc.add(fcs.makeTs(t, nil, 1, dummyCid)))
+
+	events := NewEvents(context.Background(), fcs)
+
+	more := true
+	var applied, reverted bool
+	var matchData StateChange
+
+	confidence := 1
+	timeout := abi.ChainEpoch(20)
+
+	err := events.StateChanged(func(ts *types.TipSet) (d bool, m bool, e error) {
+		return false, true, nil
+	}, func(oldTs, newTs *types.TipSet, data StateChange, curH abi.ChainEpoch) (bool, error) {
+		require.Equal(t, false, applied)
+		applied = true
+		return more, nil
+	}, func(_ context.Context, ts *types.TipSet) error {
+		reverted = true
+		return nil
+	}, confidence, timeout, func(oldTs, newTs *types.TipSet) (bool, StateChange, error) {
+		if matchData == nil {
+			return false, matchData, nil
+		}
+
+		d := matchData
+		matchData = nil
+		return true, d, nil
+	})
+	require.NoError(t, err)
+
+	fcs.advance(0, 2, nil) // H=3
+
+	// Make a state change from TS at height 3 to TS at height 4
+	matchData = testStateChange{from: "a", to: "b"}
+	fcs.advance(0, 1, nil) // H=4
+
+	// Haven't yet reached confidence
+	require.Equal(t, false, applied)
+	require.Equal(t, false, reverted)
+
+	// Advance to reach confidence level
+	fcs.advance(0, 1, nil) // H=5
+
+	// Should now have called the handler
+	require.Equal(t, true, applied)
+	require.Equal(t, false, reverted)
+	applied = false
+
+	// Advance 3 more TS
+	fcs.advance(0, 3, nil) // H=8
+
+	require.Equal(t, false, applied)
+	require.Equal(t, false, reverted)
+
+	// Regress but not so far as to cause a revert
+	fcs.advance(3, 1, nil) // H=6
+
+	require.Equal(t, false, applied)
+	require.Equal(t, false, reverted)
+
+	// Regress back to state where change happened
+	fcs.advance(3, 1, nil) // H=4
+
+	// Expect revert to have happened
+	require.Equal(t, false, applied)
+	require.Equal(t, true, reverted)
+}
+
+func TestStateChangedTimeout(t *testing.T) {
+	fcs := &fakeCS{
+		t: t,
+		h: 1,
+
+		msgs:    map[cid.Cid]fakeMsg{},
+		blkMsgs: map[cid.Cid]cid.Cid{},
+		tsc:     newTSCache(2*build.ForkLengthThreshold, nil),
+	}
+	require.NoError(t, fcs.tsc.add(fcs.makeTs(t, nil, 1, dummyCid)))
+
+	events := NewEvents(context.Background(), fcs)
+
+	called := false
+
+	err := events.StateChanged(func(ts *types.TipSet) (d bool, m bool, e error) {
+		return false, true, nil
+	}, func(oldTs, newTs *types.TipSet, data StateChange, curH abi.ChainEpoch) (bool, error) {
+		called = true
+		require.Nil(t, data)
+		require.Equal(t, abi.ChainEpoch(20), newTs.Height())
+		require.Equal(t, abi.ChainEpoch(23), curH)
+		return false, nil
+	}, func(_ context.Context, ts *types.TipSet) error {
+		t.Fatal("revert on timeout")
+		return nil
+	}, 3, 20, func(oldTs, newTs *types.TipSet) (bool, StateChange, error) {
+		return false, nil, nil
+	})
+
+	require.NoError(t, err)
+
+	fcs.advance(0, 21, nil)
+	require.False(t, called)
+
+	fcs.advance(0, 5, nil)
+	require.True(t, called)
+	called = false
+
+	// with check func reporting done
+
+	fcs = &fakeCS{
+		t: t,
+		h: 1,
+
+		msgs:    map[cid.Cid]fakeMsg{},
+		blkMsgs: map[cid.Cid]cid.Cid{},
+		tsc:     newTSCache(2*build.ForkLengthThreshold, nil),
+	}
+	require.NoError(t, fcs.tsc.add(fcs.makeTs(t, nil, 1, dummyCid)))
+
+	events = NewEvents(context.Background(), fcs)
+
+	err = events.StateChanged(func(ts *types.TipSet) (d bool, m bool, e error) {
+		return true, true, nil
+	}, func(oldTs, newTs *types.TipSet, data StateChange, curH abi.ChainEpoch) (bool, error) {
+		called = true
+		require.Nil(t, data)
+		require.Equal(t, abi.ChainEpoch(20), newTs.Height())
+		require.Equal(t, abi.ChainEpoch(23), curH)
+		return false, nil
+	}, func(_ context.Context, ts *types.TipSet) error {
+		t.Fatal("revert on timeout")
+		return nil
+	}, 3, 20, func(oldTs, newTs *types.TipSet) (bool, StateChange, error) {
+		return false, nil, nil
+	})
+	require.NoError(t, err)
+
+	fcs.advance(0, 21, nil)
+	require.False(t, called)
+
+	fcs.advance(0, 5, nil)
+	require.False(t, called)
+}
diff --git a/chain/events/state/ctxstore.go b/chain/events/state/ctxstore.go
new file mode 100644
index 000000000..12b45e425
--- /dev/null
+++ b/chain/events/state/ctxstore.go
@@ -0,0 +1,25 @@
+package state
+
+import (
+	"context"
+
+	"github.com/ipfs/go-cid"
+	cbor "github.com/ipfs/go-ipld-cbor"
+)
+
+type contextStore struct {
+	ctx context.Context
+	cst *cbor.BasicIpldStore
+}
+
+func (cs *contextStore) Context() context.Context {
+	return cs.ctx
+}
+
+func (cs *contextStore) Get(ctx context.Context, c cid.Cid, out interface{}) error {
+	return cs.cst.Get(ctx, c, out)
+}
+
+func (cs *contextStore) Put(ctx context.Context, v interface{}) (cid.Cid, error) {
+	return cs.cst.Put(ctx, v)
+}
diff --git a/chain/events/state/predicates.go b/chain/events/state/predicates.go
new file mode 100644
index 000000000..99b8480dc
--- /dev/null
+++ b/chain/events/state/predicates.go
@@ -0,0 +1,597 @@
+package state
+
+import (
+	"bytes"
+	"context"
+
+	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/big"
+	cbor "github.com/ipfs/go-ipld-cbor"
+	typegen "github.com/whyrusleeping/cbor-gen"
+
+	"github.com/filecoin-project/lotus/api/apibstore"
+	"github.com/filecoin-project/lotus/chain/actors/adt"
+	init_ "github.com/filecoin-project/lotus/chain/actors/builtin/init"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/market"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/paych"
+	"github.com/filecoin-project/lotus/chain/types"
+)
+
+// UserData is the data returned from the DiffTipSetKeyFunc
+type UserData interface{}
+
+// ChainAPI abstracts out calls made by this class to external APIs
+type ChainAPI interface {
+	apibstore.ChainIO
+	StateGetActor(ctx context.Context, actor address.Address, tsk types.TipSetKey) (*types.Actor, error)
+}
+
+// StatePredicates has common predicates for responding to state changes
+type StatePredicates struct {
+	api ChainAPI
+	cst *cbor.BasicIpldStore
+}
+
+func NewStatePredicates(api ChainAPI) *StatePredicates {
+	return &StatePredicates{
+		api: api,
+		cst: cbor.NewCborStore(apibstore.NewAPIBlockstore(api)),
+	}
+}
+
+// DiffTipSetKeyFunc check if there's a change form oldState to newState, and returns
+// - changed: was there a change
+// - user: user-defined data representing the state change
+// - err
+type DiffTipSetKeyFunc func(ctx context.Context, oldState, newState types.TipSetKey) (changed bool, user UserData, err error)
+
+type DiffActorStateFunc func(ctx context.Context, oldActorState *types.Actor, newActorState *types.Actor) (changed bool, user UserData, err error)
+
+// OnActorStateChanged calls diffStateFunc when the state changes for the given actor
+func (sp *StatePredicates) OnActorStateChanged(addr address.Address, diffStateFunc DiffActorStateFunc) DiffTipSetKeyFunc {
+	return func(ctx context.Context, oldState, newState types.TipSetKey) (changed bool, user UserData, err error) {
+		oldActor, err := sp.api.StateGetActor(ctx, addr, oldState)
+		if err != nil {
+			return false, nil, err
+		}
+		newActor, err := sp.api.StateGetActor(ctx, addr, newState)
+		if err != nil {
+			return false, nil, err
+		}
+
+		if oldActor.Head.Equals(newActor.Head) {
+			return false, nil, nil
+		}
+		return diffStateFunc(ctx, oldActor, newActor)
+	}
+}
+
+type DiffStorageMarketStateFunc func(ctx context.Context, oldState market.State, newState market.State) (changed bool, user UserData, err error)
+
+// OnStorageMarketActorChanged calls diffStorageMarketState when the state changes for the market actor
+func (sp *StatePredicates) OnStorageMarketActorChanged(diffStorageMarketState DiffStorageMarketStateFunc) DiffTipSetKeyFunc {
+	return sp.OnActorStateChanged(market.Address, func(ctx context.Context, oldActorState, newActorState *types.Actor) (changed bool, user UserData, err error) {
+		oldState, err := market.Load(adt.WrapStore(ctx, sp.cst), oldActorState)
+		if err != nil {
+			return false, nil, err
+		}
+		newState, err := market.Load(adt.WrapStore(ctx, sp.cst), newActorState)
+		if err != nil {
+			return false, nil, err
+		}
+		return diffStorageMarketState(ctx, oldState, newState)
+	})
+}
+
+type BalanceTables struct {
+	EscrowTable market.BalanceTable
+	LockedTable market.BalanceTable
+}
+
+// DiffBalanceTablesFunc compares two balance tables
+type DiffBalanceTablesFunc func(ctx context.Context, oldBalanceTable, newBalanceTable BalanceTables) (changed bool, user UserData, err error)
+
+// OnBalanceChanged runs when the escrow table for available balances changes
+func (sp *StatePredicates) OnBalanceChanged(diffBalances DiffBalanceTablesFunc) DiffStorageMarketStateFunc {
+	return func(ctx context.Context, oldState market.State, newState market.State) (changed bool, user UserData, err error) {
+		bc, err := oldState.BalancesChanged(newState)
+		if err != nil {
+			return false, nil, err
+		}
+
+		if !bc {
+			return false, nil, nil
+		}
+
+		oldEscrowRoot, err := oldState.EscrowTable()
+		if err != nil {
+			return false, nil, err
+		}
+
+		oldLockedRoot, err := oldState.LockedTable()
+		if err != nil {
+			return false, nil, err
+		}
+
+		newEscrowRoot, err := newState.EscrowTable()
+		if err != nil {
+			return false, nil, err
+		}
+
+		newLockedRoot, err := newState.LockedTable()
+		if err != nil {
+			return false, nil, err
+		}
+
+		return diffBalances(ctx, BalanceTables{oldEscrowRoot, oldLockedRoot}, BalanceTables{newEscrowRoot, newLockedRoot})
+	}
+}
+
+type DiffDealStatesFunc func(ctx context.Context, oldDealStateRoot, newDealStateRoot market.DealStates) (changed bool, user UserData, err error)
+type DiffDealProposalsFunc func(ctx context.Context, oldDealStateRoot, newDealStateRoot market.DealProposals) (changed bool, user UserData, err error)
+type DiffAdtArraysFunc func(ctx context.Context, oldDealStateRoot, newDealStateRoot adt.Array) (changed bool, user UserData, err error)
+
+// OnDealStateChanged calls diffDealStates when the market deal state changes
+func (sp *StatePredicates) OnDealStateChanged(diffDealStates DiffDealStatesFunc) DiffStorageMarketStateFunc {
+	return func(ctx context.Context, oldState market.State, newState market.State) (changed bool, user UserData, err error) {
+		sc, err := oldState.StatesChanged(newState)
+		if err != nil {
+			return false, nil, err
+		}
+
+		if !sc {
+			return false, nil, nil
+		}
+
+		oldRoot, err := oldState.States()
+		if err != nil {
+			return false, nil, err
+		}
+		newRoot, err := newState.States()
+		if err != nil {
+			return false, nil, err
+		}
+
+		return diffDealStates(ctx, oldRoot, newRoot)
+	}
+}
+
+// OnDealProposalChanged calls diffDealProps when the market proposal state changes
+func (sp *StatePredicates) OnDealProposalChanged(diffDealProps DiffDealProposalsFunc) DiffStorageMarketStateFunc {
+	return func(ctx context.Context, oldState market.State, newState market.State) (changed bool, user UserData, err error) {
+		pc, err := oldState.ProposalsChanged(newState)
+		if err != nil {
+			return false, nil, err
+		}
+
+		if !pc {
+			return false, nil, nil
+		}
+
+		oldRoot, err := oldState.Proposals()
+		if err != nil {
+			return false, nil, err
+		}
+		newRoot, err := newState.Proposals()
+		if err != nil {
+			return false, nil, err
+		}
+
+		return diffDealProps(ctx, oldRoot, newRoot)
+	}
+}
+
+// OnDealProposalAmtChanged detects changes in the deal proposal AMT for all deal proposals and returns a MarketProposalsChanges structure containing:
+// - Added Proposals
+// - Modified Proposals
+// - Removed Proposals
+func (sp *StatePredicates) OnDealProposalAmtChanged() DiffDealProposalsFunc {
+	return func(ctx context.Context, oldDealProps, newDealProps market.DealProposals) (changed bool, user UserData, err error) {
+		proposalChanges, err := market.DiffDealProposals(oldDealProps, newDealProps)
+		if err != nil {
+			return false, nil, err
+		}
+
+		if len(proposalChanges.Added)+len(proposalChanges.Removed) == 0 {
+			return false, nil, nil
+		}
+
+		return true, proposalChanges, nil
+	}
+}
+
+// OnDealStateAmtChanged detects changes in the deal state AMT for all deal states and returns a MarketDealStateChanges structure containing:
+// - Added Deals
+// - Modified Deals
+// - Removed Deals
+func (sp *StatePredicates) OnDealStateAmtChanged() DiffDealStatesFunc {
+	return func(ctx context.Context, oldDealStates, newDealStates market.DealStates) (changed bool, user UserData, err error) {
+		dealStateChanges, err := market.DiffDealStates(oldDealStates, newDealStates)
+		if err != nil {
+			return false, nil, err
+		}
+
+		if len(dealStateChanges.Added)+len(dealStateChanges.Modified)+len(dealStateChanges.Removed) == 0 {
+			return false, nil, nil
+		}
+
+		return true, dealStateChanges, nil
+	}
+}
+
+// ChangedDeals is a set of changes to deal state
+type ChangedDeals map[abi.DealID]market.DealStateChange
+
+// DealStateChangedForIDs detects changes in the deal state AMT for the given deal IDs
+func (sp *StatePredicates) DealStateChangedForIDs(dealIds []abi.DealID) DiffDealStatesFunc {
+	return func(ctx context.Context, oldDealStates, newDealStates market.DealStates) (changed bool, user UserData, err error) {
+		changedDeals := make(ChangedDeals)
+		for _, dealID := range dealIds {
+
+			// If the deal has been removed, we just set it to nil
+			oldDeal, oldFound, err := oldDealStates.Get(dealID)
+			if err != nil {
+				return false, nil, err
+			}
+
+			newDeal, newFound, err := newDealStates.Get(dealID)
+			if err != nil {
+				return false, nil, err
+			}
+
+			existenceChanged := oldFound != newFound
+			valueChanged := (oldFound && newFound) && *oldDeal != *newDeal
+			if existenceChanged || valueChanged {
+				changedDeals[dealID] = market.DealStateChange{ID: dealID, From: oldDeal, To: newDeal}
+			}
+		}
+		if len(changedDeals) > 0 {
+			return true, changedDeals, nil
+		}
+		return false, nil, nil
+	}
+}
+
+// ChangedBalances is a set of changes to deal state
+type ChangedBalances map[address.Address]BalanceChange
+
+// BalanceChange is a change in balance from -> to
+type BalanceChange struct {
+	From abi.TokenAmount
+	To   abi.TokenAmount
+}
+
+// AvailableBalanceChangedForAddresses detects changes in the escrow table for the given addresses
+func (sp *StatePredicates) AvailableBalanceChangedForAddresses(getAddrs func() []address.Address) DiffBalanceTablesFunc {
+	return func(ctx context.Context, oldBalances, newBalances BalanceTables) (changed bool, user UserData, err error) {
+		changedBalances := make(ChangedBalances)
+		addrs := getAddrs()
+		for _, addr := range addrs {
+			// If the deal has been removed, we just set it to nil
+			oldEscrowBalance, err := oldBalances.EscrowTable.Get(addr)
+			if err != nil {
+				return false, nil, err
+			}
+
+			oldLockedBalance, err := oldBalances.LockedTable.Get(addr)
+			if err != nil {
+				return false, nil, err
+			}
+
+			oldBalance := big.Sub(oldEscrowBalance, oldLockedBalance)
+
+			newEscrowBalance, err := newBalances.EscrowTable.Get(addr)
+			if err != nil {
+				return false, nil, err
+			}
+
+			newLockedBalance, err := newBalances.LockedTable.Get(addr)
+			if err != nil {
+				return false, nil, err
+			}
+
+			newBalance := big.Sub(newEscrowBalance, newLockedBalance)
+
+			if !oldBalance.Equals(newBalance) {
+				changedBalances[addr] = BalanceChange{oldBalance, newBalance}
+			}
+		}
+		if len(changedBalances) > 0 {
+			return true, changedBalances, nil
+		}
+		return false, nil, nil
+	}
+}
+
+type DiffMinerActorStateFunc func(ctx context.Context, oldState miner.State, newState miner.State) (changed bool, user UserData, err error)
+
+func (sp *StatePredicates) OnInitActorChange(diffInitActorState DiffInitActorStateFunc) DiffTipSetKeyFunc {
+	return sp.OnActorStateChanged(init_.Address, func(ctx context.Context, oldActorState, newActorState *types.Actor) (changed bool, user UserData, err error) {
+		oldState, err := init_.Load(adt.WrapStore(ctx, sp.cst), oldActorState)
+		if err != nil {
+			return false, nil, err
+		}
+		newState, err := init_.Load(adt.WrapStore(ctx, sp.cst), newActorState)
+		if err != nil {
+			return false, nil, err
+		}
+		return diffInitActorState(ctx, oldState, newState)
+	})
+
+}
+
+func (sp *StatePredicates) OnMinerActorChange(minerAddr address.Address, diffMinerActorState DiffMinerActorStateFunc) DiffTipSetKeyFunc {
+	return sp.OnActorStateChanged(minerAddr, func(ctx context.Context, oldActorState, newActorState *types.Actor) (changed bool, user UserData, err error) {
+		oldState, err := miner.Load(adt.WrapStore(ctx, sp.cst), oldActorState)
+		if err != nil {
+			return false, nil, err
+		}
+		newState, err := miner.Load(adt.WrapStore(ctx, sp.cst), newActorState)
+		if err != nil {
+			return false, nil, err
+		}
+		return diffMinerActorState(ctx, oldState, newState)
+	})
+}
+
+func (sp *StatePredicates) OnMinerSectorChange() DiffMinerActorStateFunc {
+	return func(ctx context.Context, oldState, newState miner.State) (changed bool, user UserData, err error) {
+		sectorChanges, err := miner.DiffSectors(oldState, newState)
+		if err != nil {
+			return false, nil, err
+		}
+		// nothing changed
+		if len(sectorChanges.Added)+len(sectorChanges.Extended)+len(sectorChanges.Removed) == 0 {
+			return false, nil, nil
+		}
+
+		return true, sectorChanges, nil
+	}
+}
+
+func (sp *StatePredicates) OnMinerPreCommitChange() DiffMinerActorStateFunc {
+	return func(ctx context.Context, oldState, newState miner.State) (changed bool, user UserData, err error) {
+		precommitChanges, err := miner.DiffPreCommits(oldState, newState)
+		if err != nil {
+			return false, nil, err
+		}
+
+		if len(precommitChanges.Added)+len(precommitChanges.Removed) == 0 {
+			return false, nil, nil
+		}
+
+		return true, precommitChanges, nil
+	}
+}
+
+// DiffPaymentChannelStateFunc is function that compares two states for the payment channel
+type DiffPaymentChannelStateFunc func(ctx context.Context, oldState paych.State, newState paych.State) (changed bool, user UserData, err error)
+
+// OnPaymentChannelActorChanged calls diffPaymentChannelState when the state changes for the the payment channel actor
+func (sp *StatePredicates) OnPaymentChannelActorChanged(paychAddr address.Address, diffPaymentChannelState DiffPaymentChannelStateFunc) DiffTipSetKeyFunc {
+	return sp.OnActorStateChanged(paychAddr, func(ctx context.Context, oldActorState, newActorState *types.Actor) (changed bool, user UserData, err error) {
+		oldState, err := paych.Load(adt.WrapStore(ctx, sp.cst), oldActorState)
+		if err != nil {
+			return false, nil, err
+		}
+		newState, err := paych.Load(adt.WrapStore(ctx, sp.cst), newActorState)
+		if err != nil {
+			return false, nil, err
+		}
+		return diffPaymentChannelState(ctx, oldState, newState)
+	})
+}
+
+// PayChToSendChange is a difference in the amount to send on a payment channel when the money is collected
+type PayChToSendChange struct {
+	OldToSend abi.TokenAmount
+	NewToSend abi.TokenAmount
+}
+
+// OnToSendAmountChanges monitors changes on the total amount to send from one party to the other on a payment channel
+func (sp *StatePredicates) OnToSendAmountChanges() DiffPaymentChannelStateFunc {
+	return func(ctx context.Context, oldState paych.State, newState paych.State) (changed bool, user UserData, err error) {
+		ots, err := oldState.ToSend()
+		if err != nil {
+			return false, nil, err
+		}
+
+		nts, err := newState.ToSend()
+		if err != nil {
+			return false, nil, err
+		}
+
+		if ots.Equals(nts) {
+			return false, nil, nil
+		}
+		return true, &PayChToSendChange{
+			OldToSend: ots,
+			NewToSend: nts,
+		}, nil
+	}
+}
+
+type AddressPair struct {
+	ID address.Address
+	PK address.Address
+}
+
+type InitActorAddressChanges struct {
+	Added    []AddressPair
+	Modified []AddressChange
+	Removed  []AddressPair
+}
+
+type AddressChange struct {
+	From AddressPair
+	To   AddressPair
+}
+
+type DiffInitActorStateFunc func(ctx context.Context, oldState init_.State, newState init_.State) (changed bool, user UserData, err error)
+
+func (i *InitActorAddressChanges) AsKey(key string) (abi.Keyer, error) {
+	addr, err := address.NewFromBytes([]byte(key))
+	if err != nil {
+		return nil, err
+	}
+	return abi.AddrKey(addr), nil
+}
+
+func (i *InitActorAddressChanges) Add(key string, val *typegen.Deferred) error {
+	pkAddr, err := address.NewFromBytes([]byte(key))
+	if err != nil {
+		return err
+	}
+	id := new(typegen.CborInt)
+	if err := id.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil {
+		return err
+	}
+	idAddr, err := address.NewIDAddress(uint64(*id))
+	if err != nil {
+		return err
+	}
+	i.Added = append(i.Added, AddressPair{
+		ID: idAddr,
+		PK: pkAddr,
+	})
+	return nil
+}
+
+func (i *InitActorAddressChanges) Modify(key string, from, to *typegen.Deferred) error {
+	pkAddr, err := address.NewFromBytes([]byte(key))
+	if err != nil {
+		return err
+	}
+
+	fromID := new(typegen.CborInt)
+	if err := fromID.UnmarshalCBOR(bytes.NewReader(from.Raw)); err != nil {
+		return err
+	}
+	fromIDAddr, err := address.NewIDAddress(uint64(*fromID))
+	if err != nil {
+		return err
+	}
+
+	toID := new(typegen.CborInt)
+	if err := toID.UnmarshalCBOR(bytes.NewReader(to.Raw)); err != nil {
+		return err
+	}
+	toIDAddr, err := address.NewIDAddress(uint64(*toID))
+	if err != nil {
+		return err
+	}
+
+	i.Modified = append(i.Modified, AddressChange{
+		From: AddressPair{
+			ID: fromIDAddr,
+			PK: pkAddr,
+		},
+		To: AddressPair{
+			ID: toIDAddr,
+			PK: pkAddr,
+		},
+	})
+	return nil
+}
+
+func (i *InitActorAddressChanges) Remove(key string, val *typegen.Deferred) error {
+	pkAddr, err := address.NewFromBytes([]byte(key))
+	if err != nil {
+		return err
+	}
+	id := new(typegen.CborInt)
+	if err := id.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil {
+		return err
+	}
+	idAddr, err := address.NewIDAddress(uint64(*id))
+	if err != nil {
+		return err
+	}
+	i.Removed = append(i.Removed, AddressPair{
+		ID: idAddr,
+		PK: pkAddr,
+	})
+	return nil
+}
+
+func (sp *StatePredicates) OnAddressMapChange() DiffInitActorStateFunc {
+	return func(ctx context.Context, oldState, newState init_.State) (changed bool, user UserData, err error) {
+		addressChanges := &InitActorAddressChanges{
+			Added:    []AddressPair{},
+			Modified: []AddressChange{},
+			Removed:  []AddressPair{},
+		}
+
+		err = oldState.ForEachActor(func(oldId abi.ActorID, oldAddress address.Address) error {
+			oldIdAddress, err := address.NewIDAddress(uint64(oldId))
+			if err != nil {
+				return err
+			}
+
+			newIdAddress, found, err := newState.ResolveAddress(oldAddress)
+			if err != nil {
+				return err
+			}
+
+			if !found {
+				addressChanges.Removed = append(addressChanges.Removed, AddressPair{
+					ID: oldIdAddress,
+					PK: oldAddress,
+				})
+			}
+
+			if oldIdAddress != newIdAddress {
+				addressChanges.Modified = append(addressChanges.Modified, AddressChange{
+					From: AddressPair{
+						ID: oldIdAddress,
+						PK: oldAddress,
+					},
+					To: AddressPair{
+						ID: newIdAddress,
+						PK: oldAddress,
+					},
+				})
+			}
+
+			return nil
+		})
+
+		if err != nil {
+			return false, nil, err
+		}
+
+		err = newState.ForEachActor(func(newId abi.ActorID, newAddress address.Address) error {
+			newIdAddress, err := address.NewIDAddress(uint64(newId))
+			if err != nil {
+				return err
+			}
+
+			_, found, err := newState.ResolveAddress(newAddress)
+			if err != nil {
+				return err
+			}
+
+			if !found {
+				addressChanges.Added = append(addressChanges.Added, AddressPair{
+					ID: newIdAddress,
+					PK: newAddress,
+				})
+			}
+
+			return nil
+		})
+
+		if err != nil {
+			return false, nil, err
+		}
+
+		if len(addressChanges.Added)+len(addressChanges.Removed)+len(addressChanges.Modified) == 0 {
+			return false, nil, nil
+		}
+
+		return true, addressChanges, nil
+	}
+}
diff --git a/chain/events/state/predicates_test.go b/chain/events/state/predicates_test.go
new file mode 100644
index 000000000..461ac4997
--- /dev/null
+++ b/chain/events/state/predicates_test.go
@@ -0,0 +1,632 @@
+package state
+
+import (
+	"context"
+	"testing"
+
+	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
+
+	"github.com/filecoin-project/go-bitfield"
+
+	"github.com/stretchr/testify/require"
+	"golang.org/x/xerrors"
+
+	"github.com/ipfs/go-cid"
+	cbornode "github.com/ipfs/go-ipld-cbor"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/big"
+	"github.com/filecoin-project/go-state-types/crypto"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/market"
+	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
+	market0 "github.com/filecoin-project/specs-actors/actors/builtin/market"
+
+	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
+	"github.com/filecoin-project/specs-actors/actors/util/adt"
+	tutils "github.com/filecoin-project/specs-actors/support/testing"
+
+	"github.com/filecoin-project/lotus/chain/types"
+	bstore "github.com/filecoin-project/lotus/lib/blockstore"
+)
+
+var dummyCid cid.Cid
+
+func init() {
+	dummyCid, _ = cid.Parse("bafkqaaa")
+}
+
+type mockAPI struct {
+	ts map[types.TipSetKey]*types.Actor
+	bs bstore.Blockstore
+}
+
+func newMockAPI(bs bstore.Blockstore) *mockAPI {
+	return &mockAPI{
+		bs: bs,
+		ts: make(map[types.TipSetKey]*types.Actor),
+	}
+}
+
+func (m mockAPI) ChainHasObj(ctx context.Context, c cid.Cid) (bool, error) {
+	return m.bs.Has(c)
+}
+
+func (m mockAPI) ChainReadObj(ctx context.Context, c cid.Cid) ([]byte, error) {
+	blk, err := m.bs.Get(c)
+	if err != nil {
+		return nil, xerrors.Errorf("blockstore get: %w", err)
+	}
+
+	return blk.RawData(), nil
+}
+
+func (m mockAPI) StateGetActor(ctx context.Context, actor address.Address, tsk types.TipSetKey) (*types.Actor, error) {
+	return m.ts[tsk], nil
+}
+
+func (m mockAPI) setActor(tsk types.TipSetKey, act *types.Actor) {
+	m.ts[tsk] = act
+}
+
+func TestMarketPredicates(t *testing.T) {
+	ctx := context.Background()
+	bs := bstore.NewTemporarySync()
+	store := adt.WrapStore(ctx, cbornode.NewCborStore(bs))
+
+	oldDeal1 := &market0.DealState{
+		SectorStartEpoch: 1,
+		LastUpdatedEpoch: 2,
+		SlashEpoch:       0,
+	}
+	oldDeal2 := &market0.DealState{
+		SectorStartEpoch: 4,
+		LastUpdatedEpoch: 5,
+		SlashEpoch:       0,
+	}
+	oldDeals := map[abi.DealID]*market0.DealState{
+		abi.DealID(1): oldDeal1,
+		abi.DealID(2): oldDeal2,
+	}
+
+	oldProp1 := &market0.DealProposal{
+		PieceCID:             dummyCid,
+		PieceSize:            0,
+		VerifiedDeal:         false,
+		Client:               tutils.NewIDAddr(t, 1),
+		Provider:             tutils.NewIDAddr(t, 1),
+		StartEpoch:           1,
+		EndEpoch:             2,
+		StoragePricePerEpoch: big.Zero(),
+		ProviderCollateral:   big.Zero(),
+		ClientCollateral:     big.Zero(),
+	}
+	oldProp2 := &market0.DealProposal{
+		PieceCID:             dummyCid,
+		PieceSize:            0,
+		VerifiedDeal:         false,
+		Client:               tutils.NewIDAddr(t, 1),
+		Provider:             tutils.NewIDAddr(t, 1),
+		StartEpoch:           2,
+		EndEpoch:             3,
+		StoragePricePerEpoch: big.Zero(),
+		ProviderCollateral:   big.Zero(),
+		ClientCollateral:     big.Zero(),
+	}
+	oldProps := map[abi.DealID]*market0.DealProposal{
+		abi.DealID(1): oldProp1,
+		abi.DealID(2): oldProp2,
+	}
+
+	oldBalances := map[address.Address]balance{
+		tutils.NewIDAddr(t, 1): {abi.NewTokenAmount(1000), abi.NewTokenAmount(1000)},
+		tutils.NewIDAddr(t, 2): {abi.NewTokenAmount(2000), abi.NewTokenAmount(500)},
+		tutils.NewIDAddr(t, 3): {abi.NewTokenAmount(3000), abi.NewTokenAmount(2000)},
+		tutils.NewIDAddr(t, 5): {abi.NewTokenAmount(3000), abi.NewTokenAmount(1000)},
+	}
+
+	oldStateC := createMarketState(ctx, t, store, oldDeals, oldProps, oldBalances)
+
+	newDeal1 := &market0.DealState{
+		SectorStartEpoch: 1,
+		LastUpdatedEpoch: 3,
+		SlashEpoch:       0,
+	}
+
+	// deal 2 removed
+
+	// added
+	newDeal3 := &market0.DealState{
+		SectorStartEpoch: 1,
+		LastUpdatedEpoch: 2,
+		SlashEpoch:       3,
+	}
+	newDeals := map[abi.DealID]*market0.DealState{
+		abi.DealID(1): newDeal1,
+		// deal 2 was removed
+		abi.DealID(3): newDeal3,
+	}
+
+	// added
+	newProp3 := &market0.DealProposal{
+		PieceCID:             dummyCid,
+		PieceSize:            0,
+		VerifiedDeal:         false,
+		Client:               tutils.NewIDAddr(t, 1),
+		Provider:             tutils.NewIDAddr(t, 1),
+		StartEpoch:           4,
+		EndEpoch:             4,
+		StoragePricePerEpoch: big.Zero(),
+		ProviderCollateral:   big.Zero(),
+		ClientCollateral:     big.Zero(),
+	}
+	newProps := map[abi.DealID]*market0.DealProposal{
+		abi.DealID(1): oldProp1, // 1 was persisted
+		// prop 2 was removed
+		abi.DealID(3): newProp3, // new
+		// NB: DealProposals cannot be modified, so don't test that case.
+	}
+	newBalances := map[address.Address]balance{
+		tutils.NewIDAddr(t, 1): {abi.NewTokenAmount(3000), abi.NewTokenAmount(0)},
+		tutils.NewIDAddr(t, 2): {abi.NewTokenAmount(2000), abi.NewTokenAmount(500)},
+		tutils.NewIDAddr(t, 4): {abi.NewTokenAmount(5000), abi.NewTokenAmount(0)},
+		tutils.NewIDAddr(t, 5): {abi.NewTokenAmount(1000), abi.NewTokenAmount(3000)},
+	}
+
+	newStateC := createMarketState(ctx, t, store, newDeals, newProps, newBalances)
+
+	minerAddr, err := address.NewFromString("t00")
+	require.NoError(t, err)
+	oldState, err := mockTipset(minerAddr, 1)
+	require.NoError(t, err)
+	newState, err := mockTipset(minerAddr, 2)
+	require.NoError(t, err)
+
+	api := newMockAPI(bs)
+	api.setActor(oldState.Key(), &types.Actor{Code: builtin0.StorageMarketActorCodeID, Head: oldStateC})
+	api.setActor(newState.Key(), &types.Actor{Code: builtin0.StorageMarketActorCodeID, Head: newStateC})
+
+	t.Run("deal ID predicate", func(t *testing.T) {
+		preds := NewStatePredicates(api)
+
+		dealIds := []abi.DealID{abi.DealID(1), abi.DealID(2)}
+		diffIDFn := preds.OnStorageMarketActorChanged(preds.OnDealStateChanged(preds.DealStateChangedForIDs(dealIds)))
+
+		// Diff a state against itself: expect no change
+		changed, _, err := diffIDFn(ctx, oldState.Key(), oldState.Key())
+		require.NoError(t, err)
+		require.False(t, changed)
+
+		// Diff old state against new state
+		changed, valIDs, err := diffIDFn(ctx, oldState.Key(), newState.Key())
+		require.NoError(t, err)
+		require.True(t, changed)
+
+		changedDealIDs, ok := valIDs.(ChangedDeals)
+		require.True(t, ok)
+		require.Len(t, changedDealIDs, 2)
+		require.Contains(t, changedDealIDs, abi.DealID(1))
+		require.Contains(t, changedDealIDs, abi.DealID(2))
+		deal1 := changedDealIDs[abi.DealID(1)]
+		if deal1.From.LastUpdatedEpoch != 2 || deal1.To.LastUpdatedEpoch != 3 {
+			t.Fatal("Unexpected change to LastUpdatedEpoch")
+		}
+		deal2 := changedDealIDs[abi.DealID(2)]
+		if deal2.From.LastUpdatedEpoch != 5 || deal2.To != nil {
+			t.Fatal("Expected To to be nil")
+		}
+
+		// Diff with non-existent deal.
+		noDeal := []abi.DealID{4}
+		diffNoDealFn := preds.OnStorageMarketActorChanged(preds.OnDealStateChanged(preds.DealStateChangedForIDs(noDeal)))
+		changed, _, err = diffNoDealFn(ctx, oldState.Key(), newState.Key())
+		require.NoError(t, err)
+		require.False(t, changed)
+
+		// Test that OnActorStateChanged does not call the callback if the state has not changed
+		mockAddr, err := address.NewFromString("t01")
+		require.NoError(t, err)
+		actorDiffFn := preds.OnActorStateChanged(mockAddr, func(context.Context, *types.Actor, *types.Actor) (bool, UserData, error) {
+			t.Fatal("No state change so this should not be called")
+			return false, nil, nil
+		})
+		changed, _, err = actorDiffFn(ctx, oldState.Key(), oldState.Key())
+		require.NoError(t, err)
+		require.False(t, changed)
+
+		// Test that OnDealStateChanged does not call the callback if the state has not changed
+		diffDealStateFn := preds.OnDealStateChanged(func(context.Context, market.DealStates, market.DealStates) (bool, UserData, error) {
+			t.Fatal("No state change so this should not be called")
+			return false, nil, nil
+		})
+		marketState0 := createEmptyMarketState(t, store)
+		marketCid, err := store.Put(ctx, marketState0)
+		require.NoError(t, err)
+		marketState, err := market.Load(store, &types.Actor{
+			Code: builtin0.StorageMarketActorCodeID,
+			Head: marketCid,
+		})
+		require.NoError(t, err)
+		changed, _, err = diffDealStateFn(ctx, marketState, marketState)
+		require.NoError(t, err)
+		require.False(t, changed)
+	})
+
+	t.Run("deal state array predicate", func(t *testing.T) {
+		preds := NewStatePredicates(api)
+		diffArrFn := preds.OnStorageMarketActorChanged(preds.OnDealStateChanged(preds.OnDealStateAmtChanged()))
+
+		changed, _, err := diffArrFn(ctx, oldState.Key(), oldState.Key())
+		require.NoError(t, err)
+		require.False(t, changed)
+
+		changed, valArr, err := diffArrFn(ctx, oldState.Key(), newState.Key())
+		require.NoError(t, err)
+		require.True(t, changed)
+
+		changedDeals, ok := valArr.(*market.DealStateChanges)
+		require.True(t, ok)
+		require.Len(t, changedDeals.Added, 1)
+		require.Equal(t, abi.DealID(3), changedDeals.Added[0].ID)
+		require.True(t, dealEquality(*newDeal3, changedDeals.Added[0].Deal))
+
+		require.Len(t, changedDeals.Removed, 1)
+
+		require.Len(t, changedDeals.Modified, 1)
+		require.Equal(t, abi.DealID(1), changedDeals.Modified[0].ID)
+		require.True(t, dealEquality(*newDeal1, *changedDeals.Modified[0].To))
+		require.True(t, dealEquality(*oldDeal1, *changedDeals.Modified[0].From))
+
+		require.Equal(t, abi.DealID(2), changedDeals.Removed[0].ID)
+	})
+
+	t.Run("deal proposal array predicate", func(t *testing.T) {
+		preds := NewStatePredicates(api)
+		diffArrFn := preds.OnStorageMarketActorChanged(preds.OnDealProposalChanged(preds.OnDealProposalAmtChanged()))
+		changed, _, err := diffArrFn(ctx, oldState.Key(), oldState.Key())
+		require.NoError(t, err)
+		require.False(t, changed)
+
+		changed, valArr, err := diffArrFn(ctx, oldState.Key(), newState.Key())
+		require.NoError(t, err)
+		require.True(t, changed)
+
+		changedProps, ok := valArr.(*market.DealProposalChanges)
+		require.True(t, ok)
+		require.Len(t, changedProps.Added, 1)
+		require.Equal(t, abi.DealID(3), changedProps.Added[0].ID)
+
+		// proposals cannot be modified -- no modified testing
+
+		require.Len(t, changedProps.Removed, 1)
+		require.Equal(t, abi.DealID(2), changedProps.Removed[0].ID)
+	})
+
+	t.Run("balances predicate", func(t *testing.T) {
+		preds := NewStatePredicates(api)
+
+		getAddresses := func() []address.Address {
+			return []address.Address{tutils.NewIDAddr(t, 1), tutils.NewIDAddr(t, 2), tutils.NewIDAddr(t, 3), tutils.NewIDAddr(t, 4)}
+		}
+		diffBalancesFn := preds.OnStorageMarketActorChanged(preds.OnBalanceChanged(preds.AvailableBalanceChangedForAddresses(getAddresses)))
+
+		// Diff a state against itself: expect no change
+		changed, _, err := diffBalancesFn(ctx, oldState.Key(), oldState.Key())
+		require.NoError(t, err)
+		require.False(t, changed)
+
+		// Diff old state against new state
+		changed, valIDs, err := diffBalancesFn(ctx, oldState.Key(), newState.Key())
+		require.NoError(t, err)
+		require.True(t, changed)
+
+		changedBalances, ok := valIDs.(ChangedBalances)
+		require.True(t, ok)
+		require.Len(t, changedBalances, 3)
+		require.Contains(t, changedBalances, tutils.NewIDAddr(t, 1))
+		require.Contains(t, changedBalances, tutils.NewIDAddr(t, 3))
+		require.Contains(t, changedBalances, tutils.NewIDAddr(t, 4))
+
+		balance1 := changedBalances[tutils.NewIDAddr(t, 1)]
+		if !balance1.From.Equals(abi.NewTokenAmount(1000)) || !balance1.To.Equals(abi.NewTokenAmount(3000)) {
+			t.Fatal("Unexpected change to balance")
+		}
+		balance3 := changedBalances[tutils.NewIDAddr(t, 3)]
+		if !balance3.From.Equals(abi.NewTokenAmount(3000)) || !balance3.To.Equals(abi.NewTokenAmount(0)) {
+			t.Fatal("Unexpected change to balance")
+		}
+		balance4 := changedBalances[tutils.NewIDAddr(t, 4)]
+		if !balance4.From.Equals(abi.NewTokenAmount(0)) || !balance4.To.Equals(abi.NewTokenAmount(5000)) {
+			t.Fatal("Unexpected change to balance")
+		}
+
+		// Diff with non-existent address.
+		getNoAddress := func() []address.Address { return []address.Address{tutils.NewIDAddr(t, 6)} }
+		diffNoAddressFn := preds.OnStorageMarketActorChanged(preds.OnBalanceChanged(preds.AvailableBalanceChangedForAddresses(getNoAddress)))
+		changed, _, err = diffNoAddressFn(ctx, oldState.Key(), newState.Key())
+		require.NoError(t, err)
+		require.False(t, changed)
+
+		// Test that OnBalanceChanged does not call the callback if the state has not changed
+		diffDealBalancesFn := preds.OnBalanceChanged(func(context.Context, BalanceTables, BalanceTables) (bool, UserData, error) {
+			t.Fatal("No state change so this should not be called")
+			return false, nil, nil
+		})
+		marketState0 := createEmptyMarketState(t, store)
+		marketCid, err := store.Put(ctx, marketState0)
+		require.NoError(t, err)
+		marketState, err := market.Load(store, &types.Actor{
+			Code: builtin0.StorageMarketActorCodeID,
+			Head: marketCid,
+		})
+		require.NoError(t, err)
+		changed, _, err = diffDealBalancesFn(ctx, marketState, marketState)
+		require.NoError(t, err)
+		require.False(t, changed)
+	})
+
+}
+
+func TestMinerSectorChange(t *testing.T) {
+	ctx := context.Background()
+	bs := bstore.NewTemporarySync()
+	store := adt.WrapStore(ctx, cbornode.NewCborStore(bs))
+
+	nextID := uint64(0)
+	nextIDAddrF := func() address.Address {
+		defer func() { nextID++ }()
+		return tutils.NewIDAddr(t, nextID)
+	}
+
+	owner, worker := nextIDAddrF(), nextIDAddrF()
+	si0 := newSectorOnChainInfo(0, tutils.MakeCID("0", &miner0.SealedCIDPrefix), big.NewInt(0), abi.ChainEpoch(0), abi.ChainEpoch(10))
+	si1 := newSectorOnChainInfo(1, tutils.MakeCID("1", &miner0.SealedCIDPrefix), big.NewInt(1), abi.ChainEpoch(1), abi.ChainEpoch(11))
+	si2 := newSectorOnChainInfo(2, tutils.MakeCID("2", &miner0.SealedCIDPrefix), big.NewInt(2), abi.ChainEpoch(2), abi.ChainEpoch(11))
+	oldMinerC := createMinerState(ctx, t, store, owner, worker, []miner.SectorOnChainInfo{si0, si1, si2})
+
+	si3 := newSectorOnChainInfo(3, tutils.MakeCID("3", &miner0.SealedCIDPrefix), big.NewInt(3), abi.ChainEpoch(3), abi.ChainEpoch(12))
+	// 0 delete
+	// 1 extend
+	// 2 same
+	// 3 added
+	si1Ext := si1
+	si1Ext.Expiration++
+	newMinerC := createMinerState(ctx, t, store, owner, worker, []miner.SectorOnChainInfo{si1Ext, si2, si3})
+
+	minerAddr := nextIDAddrF()
+	oldState, err := mockTipset(minerAddr, 1)
+	require.NoError(t, err)
+	newState, err := mockTipset(minerAddr, 2)
+	require.NoError(t, err)
+
+	api := newMockAPI(bs)
+	api.setActor(oldState.Key(), &types.Actor{Head: oldMinerC, Code: builtin0.StorageMinerActorCodeID})
+	api.setActor(newState.Key(), &types.Actor{Head: newMinerC, Code: builtin0.StorageMinerActorCodeID})
+
+	preds := NewStatePredicates(api)
+
+	minerDiffFn := preds.OnMinerActorChange(minerAddr, preds.OnMinerSectorChange())
+	change, val, err := minerDiffFn(ctx, oldState.Key(), newState.Key())
+	require.NoError(t, err)
+	require.True(t, change)
+	require.NotNil(t, val)
+
+	sectorChanges, ok := val.(*miner.SectorChanges)
+	require.True(t, ok)
+
+	require.Equal(t, len(sectorChanges.Added), 1)
+	require.Equal(t, 1, len(sectorChanges.Added))
+	require.Equal(t, si3, sectorChanges.Added[0])
+
+	require.Equal(t, 1, len(sectorChanges.Removed))
+	require.Equal(t, si0, sectorChanges.Removed[0])
+
+	require.Equal(t, 1, len(sectorChanges.Extended))
+	require.Equal(t, si1, sectorChanges.Extended[0].From)
+	require.Equal(t, si1Ext, sectorChanges.Extended[0].To)
+
+	change, val, err = minerDiffFn(ctx, oldState.Key(), oldState.Key())
+	require.NoError(t, err)
+	require.False(t, change)
+	require.Nil(t, val)
+
+	change, val, err = minerDiffFn(ctx, newState.Key(), oldState.Key())
+	require.NoError(t, err)
+	require.True(t, change)
+	require.NotNil(t, val)
+
+	sectorChanges, ok = val.(*miner.SectorChanges)
+	require.True(t, ok)
+
+	require.Equal(t, 1, len(sectorChanges.Added))
+	require.Equal(t, si0, sectorChanges.Added[0])
+
+	require.Equal(t, 1, len(sectorChanges.Removed))
+	require.Equal(t, si3, sectorChanges.Removed[0])
+
+	require.Equal(t, 1, len(sectorChanges.Extended))
+	require.Equal(t, si1, sectorChanges.Extended[0].To)
+	require.Equal(t, si1Ext, sectorChanges.Extended[0].From)
+}
+
+func mockTipset(minerAddr address.Address, timestamp uint64) (*types.TipSet, error) {
+	return types.NewTipSet([]*types.BlockHeader{{
+		Miner:                 minerAddr,
+		Height:                5,
+		ParentStateRoot:       dummyCid,
+		Messages:              dummyCid,
+		ParentMessageReceipts: dummyCid,
+		BlockSig:              &crypto.Signature{Type: crypto.SigTypeBLS},
+		BLSAggregate:          &crypto.Signature{Type: crypto.SigTypeBLS},
+		Timestamp:             timestamp,
+	}})
+}
+
+type balance struct {
+	available abi.TokenAmount
+	locked    abi.TokenAmount
+}
+
+func createMarketState(ctx context.Context, t *testing.T, store adt.Store, deals map[abi.DealID]*market0.DealState, props map[abi.DealID]*market0.DealProposal, balances map[address.Address]balance) cid.Cid {
+	dealRootCid := createDealAMT(ctx, t, store, deals)
+	propRootCid := createProposalAMT(ctx, t, store, props)
+	balancesCids := createBalanceTable(ctx, t, store, balances)
+	state := createEmptyMarketState(t, store)
+	state.States = dealRootCid
+	state.Proposals = propRootCid
+	state.EscrowTable = balancesCids[0]
+	state.LockedTable = balancesCids[1]
+
+	stateC, err := store.Put(ctx, state)
+	require.NoError(t, err)
+	return stateC
+}
+
+func createEmptyMarketState(t *testing.T, store adt.Store) *market0.State {
+	emptyArrayCid, err := adt.MakeEmptyArray(store).Root()
+	require.NoError(t, err)
+	emptyMap, err := adt.MakeEmptyMap(store).Root()
+	require.NoError(t, err)
+	return market0.ConstructState(emptyArrayCid, emptyMap, emptyMap)
+}
+
+func createDealAMT(ctx context.Context, t *testing.T, store adt.Store, deals map[abi.DealID]*market0.DealState) cid.Cid {
+	root := adt.MakeEmptyArray(store)
+	for dealID, dealState := range deals {
+		err := root.Set(uint64(dealID), dealState)
+		require.NoError(t, err)
+	}
+	rootCid, err := root.Root()
+	require.NoError(t, err)
+	return rootCid
+}
+
+func createProposalAMT(ctx context.Context, t *testing.T, store adt.Store, props map[abi.DealID]*market0.DealProposal) cid.Cid {
+	root := adt.MakeEmptyArray(store)
+	for dealID, prop := range props {
+		err := root.Set(uint64(dealID), prop)
+		require.NoError(t, err)
+	}
+	rootCid, err := root.Root()
+	require.NoError(t, err)
+	return rootCid
+}
+
+func createBalanceTable(ctx context.Context, t *testing.T, store adt.Store, balances map[address.Address]balance) [2]cid.Cid {
+	escrowMapRoot := adt.MakeEmptyMap(store)
+	escrowMapRootCid, err := escrowMapRoot.Root()
+	require.NoError(t, err)
+	escrowRoot, err := adt.AsBalanceTable(store, escrowMapRootCid)
+	require.NoError(t, err)
+	lockedMapRoot := adt.MakeEmptyMap(store)
+	lockedMapRootCid, err := lockedMapRoot.Root()
+	require.NoError(t, err)
+	lockedRoot, err := adt.AsBalanceTable(store, lockedMapRootCid)
+	require.NoError(t, err)
+
+	for addr, balance := range balances {
+		err := escrowRoot.Add(addr, big.Add(balance.available, balance.locked))
+		require.NoError(t, err)
+		err = lockedRoot.Add(addr, balance.locked)
+		require.NoError(t, err)
+
+	}
+	escrowRootCid, err := escrowRoot.Root()
+	require.NoError(t, err)
+	lockedRootCid, err := lockedRoot.Root()
+	require.NoError(t, err)
+	return [2]cid.Cid{escrowRootCid, lockedRootCid}
+}
+
+func createMinerState(ctx context.Context, t *testing.T, store adt.Store, owner, worker address.Address, sectors []miner.SectorOnChainInfo) cid.Cid {
+	rootCid := createSectorsAMT(ctx, t, store, sectors)
+
+	state := createEmptyMinerState(ctx, t, store, owner, worker)
+	state.Sectors = rootCid
+
+	stateC, err := store.Put(ctx, state)
+	require.NoError(t, err)
+	return stateC
+}
+
+func createEmptyMinerState(ctx context.Context, t *testing.T, store adt.Store, owner, worker address.Address) *miner0.State {
+	emptyArrayCid, err := adt.MakeEmptyArray(store).Root()
+	require.NoError(t, err)
+	emptyMap, err := adt.MakeEmptyMap(store).Root()
+	require.NoError(t, err)
+
+	emptyDeadline, err := store.Put(store.Context(), miner0.ConstructDeadline(emptyArrayCid))
+	require.NoError(t, err)
+
+	emptyVestingFunds := miner0.ConstructVestingFunds()
+	emptyVestingFundsCid, err := store.Put(store.Context(), emptyVestingFunds)
+	require.NoError(t, err)
+
+	emptyDeadlines := miner0.ConstructDeadlines(emptyDeadline)
+	emptyDeadlinesCid, err := store.Put(store.Context(), emptyDeadlines)
+	require.NoError(t, err)
+
+	minerInfo := emptyMap
+
+	emptyBitfield := bitfield.NewFromSet(nil)
+	emptyBitfieldCid, err := store.Put(store.Context(), emptyBitfield)
+	require.NoError(t, err)
+
+	state, err := miner0.ConstructState(minerInfo, 123, emptyBitfieldCid, emptyArrayCid, emptyMap, emptyDeadlinesCid, emptyVestingFundsCid)
+	require.NoError(t, err)
+	return state
+
+}
+
+func createSectorsAMT(ctx context.Context, t *testing.T, store adt.Store, sectors []miner.SectorOnChainInfo) cid.Cid {
+	root := adt.MakeEmptyArray(store)
+	for _, sector := range sectors {
+		sector := (miner0.SectorOnChainInfo)(sector)
+		err := root.Set(uint64(sector.SectorNumber), &sector)
+		require.NoError(t, err)
+	}
+	rootCid, err := root.Root()
+	require.NoError(t, err)
+	return rootCid
+}
+
+// returns a unique SectorOnChainInfo with each invocation with SectorNumber set to `sectorNo`.
+func newSectorOnChainInfo(sectorNo abi.SectorNumber, sealed cid.Cid, weight big.Int, activation, expiration abi.ChainEpoch) miner.SectorOnChainInfo {
+	info := newSectorPreCommitInfo(sectorNo, sealed, expiration)
+	return miner.SectorOnChainInfo{
+		SectorNumber: info.SectorNumber,
+		SealProof:    info.SealProof,
+		SealedCID:    info.SealedCID,
+		DealIDs:      info.DealIDs,
+		Expiration:   info.Expiration,
+
+		Activation:            activation,
+		DealWeight:            weight,
+		VerifiedDealWeight:    weight,
+		InitialPledge:         big.Zero(),
+		ExpectedDayReward:     big.Zero(),
+		ExpectedStoragePledge: big.Zero(),
+	}
+}
+
+const (
+	sectorSealRandEpochValue = abi.ChainEpoch(1)
+)
+
+// returns a unique SectorPreCommitInfo with each invocation with SectorNumber set to `sectorNo`.
+func newSectorPreCommitInfo(sectorNo abi.SectorNumber, sealed cid.Cid, expiration abi.ChainEpoch) *miner0.SectorPreCommitInfo {
+	return &miner0.SectorPreCommitInfo{
+		SealProof:     abi.RegisteredSealProof_StackedDrg32GiBV1,
+		SectorNumber:  sectorNo,
+		SealedCID:     sealed,
+		SealRandEpoch: sectorSealRandEpochValue,
+		DealIDs:       nil,
+		Expiration:    expiration,
+	}
+}
+
+func dealEquality(expected market0.DealState, actual market.DealState) bool {
+	return expected.LastUpdatedEpoch == actual.LastUpdatedEpoch &&
+		expected.SectorStartEpoch == actual.SectorStartEpoch &&
+		expected.SlashEpoch == actual.SlashEpoch
+}
diff --git a/chain/events/tscache.go b/chain/events/tscache.go
index 2e58a3f5b..d47c71480 100644
--- a/chain/events/tscache.go
+++ b/chain/events/tscache.go
@@ -3,12 +3,16 @@ package events
 import (
 	"context"
 
+	"github.com/filecoin-project/go-state-types/abi"
 	"golang.org/x/xerrors"
 
 	"github.com/filecoin-project/lotus/chain/types"
 )
 
-type tsByHFunc func(context.Context, uint64, *types.TipSet) (*types.TipSet, error)
+type tsCacheAPI interface {
+	ChainGetTipSetByHeight(context.Context, abi.ChainEpoch, types.TipSetKey) (*types.TipSet, error)
+	ChainHead(context.Context) (*types.TipSet, error)
+}
 
 // tipSetCache implements a simple ring-buffer cache to keep track of recent
 // tipsets
@@ -17,10 +21,10 @@ type tipSetCache struct {
 	start int
 	len   int
 
-	storage tsByHFunc
+	storage tsCacheAPI
 }
 
-func newTSCache(cap int, storage tsByHFunc) *tipSetCache {
+func newTSCache(cap abi.ChainEpoch, storage tsCacheAPI) *tipSetCache {
 	return &tipSetCache{
 		cache: make([]*types.TipSet, cap),
 		start: 0,
@@ -77,7 +81,7 @@ func (tsc *tipSetCache) revert(ts *types.TipSet) error {
 	return nil
 }
 
-func (tsc *tipSetCache) getNonNull(height uint64) (*types.TipSet, error) {
+func (tsc *tipSetCache) getNonNull(height abi.ChainEpoch) (*types.TipSet, error) {
 	for {
 		ts, err := tsc.get(height)
 		if err != nil {
@@ -90,10 +94,10 @@ func (tsc *tipSetCache) getNonNull(height uint64) (*types.TipSet, error) {
 	}
 }
 
-func (tsc *tipSetCache) get(height uint64) (*types.TipSet, error) {
+func (tsc *tipSetCache) get(height abi.ChainEpoch) (*types.TipSet, error) {
 	if tsc.len == 0 {
 		log.Warnf("tipSetCache.get: cache is empty, requesting from storage (h=%d)", height)
-		return tsc.storage(context.TODO(), height, nil)
+		return tsc.storage.ChainGetTipSetByHeight(context.TODO(), height, types.EmptyTSK)
 	}
 
 	headH := tsc.cache[tsc.start].Height()
@@ -113,14 +117,18 @@ func (tsc *tipSetCache) get(height uint64) (*types.TipSet, error) {
 
 	if height < tail.Height() {
 		log.Warnf("tipSetCache.get: requested tipset not in cache, requesting from storage (h=%d; tail=%d)", height, tail.Height())
-		return tsc.storage(context.TODO(), height, tail)
+		return tsc.storage.ChainGetTipSetByHeight(context.TODO(), height, tail.Key())
 	}
 
 	return tsc.cache[normalModulo(tsc.start-int(headH-height), clen)], nil
 }
 
-func (tsc *tipSetCache) best() *types.TipSet {
-	return tsc.cache[tsc.start]
+func (tsc *tipSetCache) best() (*types.TipSet, error) {
+	best := tsc.cache[tsc.start]
+	if best == nil {
+		return tsc.storage.ChainHead(context.TODO())
+	}
+	return best, nil
 }
 
 func normalModulo(n, m int) int {
diff --git a/chain/events/tscache_test.go b/chain/events/tscache_test.go
index 12fdb6a94..ab6336f24 100644
--- a/chain/events/tscache_test.go
+++ b/chain/events/tscache_test.go
@@ -4,6 +4,8 @@ import (
 	"context"
 	"testing"
 
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/crypto"
 	"github.com/stretchr/testify/require"
 
 	"github.com/filecoin-project/go-address"
@@ -11,12 +13,9 @@ import (
 )
 
 func TestTsCache(t *testing.T) {
-	tsc := newTSCache(50, func(context.Context, uint64, *types.TipSet) (*types.TipSet, error) {
-		t.Fatal("storage call")
-		return &types.TipSet{}, nil
-	})
+	tsc := newTSCache(50, &tsCacheAPIFailOnStorageCall{t: t})
 
-	h := uint64(75)
+	h := abi.ChainEpoch(75)
 
 	a, _ := address.NewFromString("t00")
 
@@ -27,8 +26,8 @@ func TestTsCache(t *testing.T) {
 			ParentStateRoot:       dummyCid,
 			Messages:              dummyCid,
 			ParentMessageReceipts: dummyCid,
-			BlockSig:              &types.Signature{Type: types.KTBLS},
-			BLSAggregate:          types.Signature{Type: types.KTBLS},
+			BlockSig:              &crypto.Signature{Type: crypto.SigTypeBLS},
+			BLSAggregate:          &crypto.Signature{Type: crypto.SigTypeBLS},
 		}})
 		if err != nil {
 			t.Fatal(err)
@@ -41,7 +40,12 @@ func TestTsCache(t *testing.T) {
 
 	for i := 0; i < 9000; i++ {
 		if i%90 > 60 {
-			if err := tsc.revert(tsc.best()); err != nil {
+			best, err := tsc.best()
+			if err != nil {
+				t.Fatal(err, "; i:", i)
+				return
+			}
+			if err := tsc.revert(best); err != nil {
 				t.Fatal(err, "; i:", i)
 				return
 			}
@@ -53,13 +57,23 @@ func TestTsCache(t *testing.T) {
 
 }
 
-func TestTsCacheNulls(t *testing.T) {
-	tsc := newTSCache(50, func(context.Context, uint64, *types.TipSet) (*types.TipSet, error) {
-		t.Fatal("storage call")
-		return &types.TipSet{}, nil
-	})
+type tsCacheAPIFailOnStorageCall struct {
+	t *testing.T
+}
 
-	h := uint64(75)
+func (tc *tsCacheAPIFailOnStorageCall) ChainGetTipSetByHeight(ctx context.Context, epoch abi.ChainEpoch, key types.TipSetKey) (*types.TipSet, error) {
+	tc.t.Fatal("storage call")
+	return &types.TipSet{}, nil
+}
+func (tc *tsCacheAPIFailOnStorageCall) ChainHead(ctx context.Context) (*types.TipSet, error) {
+	tc.t.Fatal("storage call")
+	return &types.TipSet{}, nil
+}
+
+func TestTsCacheNulls(t *testing.T) {
+	tsc := newTSCache(50, &tsCacheAPIFailOnStorageCall{t: t})
+
+	h := abi.ChainEpoch(75)
 
 	a, _ := address.NewFromString("t00")
 	add := func() {
@@ -69,8 +83,8 @@ func TestTsCacheNulls(t *testing.T) {
 			ParentStateRoot:       dummyCid,
 			Messages:              dummyCid,
 			ParentMessageReceipts: dummyCid,
-			BlockSig:              &types.Signature{Type: types.KTBLS},
-			BLSAggregate:          types.Signature{Type: types.KTBLS},
+			BlockSig:              &crypto.Signature{Type: crypto.SigTypeBLS},
+			BLSAggregate:          &crypto.Signature{Type: crypto.SigTypeBLS},
 		}})
 		if err != nil {
 			t.Fatal(err)
@@ -89,7 +103,9 @@ func TestTsCacheNulls(t *testing.T) {
 	add()
 	add()
 
-	require.Equal(t, h-1, tsc.best().Height())
+	best, err := tsc.best()
+	require.NoError(t, err)
+	require.Equal(t, h-1, best.Height())
 
 	ts, err := tsc.get(h - 1)
 	require.NoError(t, err)
@@ -107,9 +123,17 @@ func TestTsCacheNulls(t *testing.T) {
 	require.NoError(t, err)
 	require.Equal(t, h-8, ts.Height())
 
-	require.NoError(t, tsc.revert(tsc.best()))
-	require.NoError(t, tsc.revert(tsc.best()))
-	require.Equal(t, h-8, tsc.best().Height())
+	best, err = tsc.best()
+	require.NoError(t, err)
+	require.NoError(t, tsc.revert(best))
+
+	best, err = tsc.best()
+	require.NoError(t, err)
+	require.NoError(t, tsc.revert(best))
+
+	best, err = tsc.best()
+	require.NoError(t, err)
+	require.Equal(t, h-8, best.Height())
 
 	h += 50
 	add()
@@ -118,3 +142,27 @@ func TestTsCacheNulls(t *testing.T) {
 	require.NoError(t, err)
 	require.Equal(t, h-1, ts.Height())
 }
+
+type tsCacheAPIStorageCallCounter struct {
+	t                      *testing.T
+	chainGetTipSetByHeight int
+	chainHead              int
+}
+
+func (tc *tsCacheAPIStorageCallCounter) ChainGetTipSetByHeight(ctx context.Context, epoch abi.ChainEpoch, key types.TipSetKey) (*types.TipSet, error) {
+	tc.chainGetTipSetByHeight++
+	return &types.TipSet{}, nil
+}
+func (tc *tsCacheAPIStorageCallCounter) ChainHead(ctx context.Context) (*types.TipSet, error) {
+	tc.chainHead++
+	return &types.TipSet{}, nil
+}
+
+func TestTsCacheEmpty(t *testing.T) {
+	// Calling best on an empty cache should just call out to the chain API
+	callCounter := &tsCacheAPIStorageCallCounter{t: t}
+	tsc := newTSCache(50, callCounter)
+	_, err := tsc.best()
+	require.NoError(t, err)
+	require.Equal(t, 1, callCounter.chainHead)
+}
diff --git a/chain/events/utils.go b/chain/events/utils.go
index ba8083f9b..e50dbc6fe 100644
--- a/chain/events/utils.go
+++ b/chain/events/utils.go
@@ -5,15 +5,14 @@ import (
 
 	"golang.org/x/xerrors"
 
-	"github.com/filecoin-project/lotus/chain/store"
 	"github.com/filecoin-project/lotus/chain/types"
 )
 
-func (e *calledEvents) CheckMsg(ctx context.Context, smsg store.ChainMsg, hnd CalledHandler) CheckFunc {
+func (me *messageEvents) CheckMsg(ctx context.Context, smsg types.ChainMsg, hnd MsgHandler) CheckFunc {
 	msg := smsg.VMMessage()
 
 	return func(ts *types.TipSet) (done bool, more bool, err error) {
-		fa, err := e.cs.StateGetActor(ctx, msg.From, ts)
+		fa, err := me.cs.StateGetActor(ctx, msg.From, ts.Key())
 		if err != nil {
 			return false, true, err
 		}
@@ -23,7 +22,7 @@ func (e *calledEvents) CheckMsg(ctx context.Context, smsg store.ChainMsg, hnd Ca
 			return false, true, nil
 		}
 
-		rec, err := e.cs.StateGetReceipt(ctx, smsg.VMMessage().Cid(), ts)
+		rec, err := me.cs.StateGetReceipt(ctx, smsg.VMMessage().Cid(), ts.Key())
 		if err != nil {
 			return false, true, xerrors.Errorf("getting receipt in CheckMsg: %w", err)
 		}
@@ -34,12 +33,12 @@ func (e *calledEvents) CheckMsg(ctx context.Context, smsg store.ChainMsg, hnd Ca
 	}
 }
 
-func (e *calledEvents) MatchMsg(inmsg *types.Message) MatchFunc {
-	return func(msg *types.Message) (bool, error) {
+func (me *messageEvents) MatchMsg(inmsg *types.Message) MsgMatchFunc {
+	return func(msg *types.Message) (matchOnce bool, matched bool, err error) {
 		if msg.From == inmsg.From && msg.Nonce == inmsg.Nonce && !inmsg.Equals(msg) {
-			return false, xerrors.Errorf("matching msg %s from %s, nonce %d: got duplicate origin/nonce msg %s", inmsg.Cid(), inmsg.From, inmsg.Nonce, msg.Nonce)
+			return true, false, xerrors.Errorf("matching msg %s from %s, nonce %d: got duplicate origin/nonce msg %d", inmsg.Cid(), inmsg.From, inmsg.Nonce, msg.Nonce)
 		}
 
-		return inmsg.Equals(msg), nil
+		return true, inmsg.Equals(msg), nil
 	}
 }
diff --git a/chain/exchange/cbor_gen.go b/chain/exchange/cbor_gen.go
new file mode 100644
index 000000000..29b258081
--- /dev/null
+++ b/chain/exchange/cbor_gen.go
@@ -0,0 +1,644 @@
+// Code generated by github.com/whyrusleeping/cbor-gen. DO NOT EDIT.
+
+package exchange
+
+import (
+	"fmt"
+	"io"
+
+	types "github.com/filecoin-project/lotus/chain/types"
+	cid "github.com/ipfs/go-cid"
+	cbg "github.com/whyrusleeping/cbor-gen"
+	xerrors "golang.org/x/xerrors"
+)
+
+var _ = xerrors.Errorf
+
+var lengthBufRequest = []byte{131}
+
+func (t *Request) MarshalCBOR(w io.Writer) error {
+	if t == nil {
+		_, err := w.Write(cbg.CborNull)
+		return err
+	}
+	if _, err := w.Write(lengthBufRequest); err != nil {
+		return err
+	}
+
+	scratch := make([]byte, 9)
+
+	// t.Head ([]cid.Cid) (slice)
+	if len(t.Head) > cbg.MaxLength {
+		return xerrors.Errorf("Slice value in field t.Head was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajArray, uint64(len(t.Head))); err != nil {
+		return err
+	}
+	for _, v := range t.Head {
+		if err := cbg.WriteCidBuf(scratch, w, v); err != nil {
+			return xerrors.Errorf("failed writing cid field t.Head: %w", err)
+		}
+	}
+
+	// t.Length (uint64) (uint64)
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.Length)); err != nil {
+		return err
+	}
+
+	// t.Options (uint64) (uint64)
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.Options)); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (t *Request) UnmarshalCBOR(r io.Reader) error {
+	*t = Request{}
+
+	br := cbg.GetPeeker(r)
+	scratch := make([]byte, 8)
+
+	maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
+	if err != nil {
+		return err
+	}
+	if maj != cbg.MajArray {
+		return fmt.Errorf("cbor input should be of type array")
+	}
+
+	if extra != 3 {
+		return fmt.Errorf("cbor input had wrong number of fields")
+	}
+
+	// t.Head ([]cid.Cid) (slice)
+
+	maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
+	if err != nil {
+		return err
+	}
+
+	if extra > cbg.MaxLength {
+		return fmt.Errorf("t.Head: array too large (%d)", extra)
+	}
+
+	if maj != cbg.MajArray {
+		return fmt.Errorf("expected cbor array")
+	}
+
+	if extra > 0 {
+		t.Head = make([]cid.Cid, extra)
+	}
+
+	for i := 0; i < int(extra); i++ {
+
+		c, err := cbg.ReadCid(br)
+		if err != nil {
+			return xerrors.Errorf("reading cid field t.Head failed: %w", err)
+		}
+		t.Head[i] = c
+	}
+
+	// t.Length (uint64) (uint64)
+
+	{
+
+		maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
+		if err != nil {
+			return err
+		}
+		if maj != cbg.MajUnsignedInt {
+			return fmt.Errorf("wrong type for uint64 field")
+		}
+		t.Length = uint64(extra)
+
+	}
+	// t.Options (uint64) (uint64)
+
+	{
+
+		maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
+		if err != nil {
+			return err
+		}
+		if maj != cbg.MajUnsignedInt {
+			return fmt.Errorf("wrong type for uint64 field")
+		}
+		t.Options = uint64(extra)
+
+	}
+	return nil
+}
+
+var lengthBufResponse = []byte{131}
+
+func (t *Response) MarshalCBOR(w io.Writer) error {
+	if t == nil {
+		_, err := w.Write(cbg.CborNull)
+		return err
+	}
+	if _, err := w.Write(lengthBufResponse); err != nil {
+		return err
+	}
+
+	scratch := make([]byte, 9)
+
+	// t.Status (exchange.status) (uint64)
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.Status)); err != nil {
+		return err
+	}
+
+	// t.ErrorMessage (string) (string)
+	if len(t.ErrorMessage) > cbg.MaxLength {
+		return xerrors.Errorf("Value in field t.ErrorMessage was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len(t.ErrorMessage))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string(t.ErrorMessage)); err != nil {
+		return err
+	}
+
+	// t.Chain ([]*exchange.BSTipSet) (slice)
+	if len(t.Chain) > cbg.MaxLength {
+		return xerrors.Errorf("Slice value in field t.Chain was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajArray, uint64(len(t.Chain))); err != nil {
+		return err
+	}
+	for _, v := range t.Chain {
+		if err := v.MarshalCBOR(w); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (t *Response) UnmarshalCBOR(r io.Reader) error {
+	*t = Response{}
+
+	br := cbg.GetPeeker(r)
+	scratch := make([]byte, 8)
+
+	maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
+	if err != nil {
+		return err
+	}
+	if maj != cbg.MajArray {
+		return fmt.Errorf("cbor input should be of type array")
+	}
+
+	if extra != 3 {
+		return fmt.Errorf("cbor input had wrong number of fields")
+	}
+
+	// t.Status (exchange.status) (uint64)
+
+	{
+
+		maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
+		if err != nil {
+			return err
+		}
+		if maj != cbg.MajUnsignedInt {
+			return fmt.Errorf("wrong type for uint64 field")
+		}
+		t.Status = status(extra)
+
+	}
+	// t.ErrorMessage (string) (string)
+
+	{
+		sval, err := cbg.ReadStringBuf(br, scratch)
+		if err != nil {
+			return err
+		}
+
+		t.ErrorMessage = string(sval)
+	}
+	// t.Chain ([]*exchange.BSTipSet) (slice)
+
+	maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
+	if err != nil {
+		return err
+	}
+
+	if extra > cbg.MaxLength {
+		return fmt.Errorf("t.Chain: array too large (%d)", extra)
+	}
+
+	if maj != cbg.MajArray {
+		return fmt.Errorf("expected cbor array")
+	}
+
+	if extra > 0 {
+		t.Chain = make([]*BSTipSet, extra)
+	}
+
+	for i := 0; i < int(extra); i++ {
+
+		var v BSTipSet
+		if err := v.UnmarshalCBOR(br); err != nil {
+			return err
+		}
+
+		t.Chain[i] = &v
+	}
+
+	return nil
+}
+
+var lengthBufCompactedMessages = []byte{132}
+
+func (t *CompactedMessages) MarshalCBOR(w io.Writer) error {
+	if t == nil {
+		_, err := w.Write(cbg.CborNull)
+		return err
+	}
+	if _, err := w.Write(lengthBufCompactedMessages); err != nil {
+		return err
+	}
+
+	scratch := make([]byte, 9)
+
+	// t.Bls ([]*types.Message) (slice)
+	if len(t.Bls) > cbg.MaxLength {
+		return xerrors.Errorf("Slice value in field t.Bls was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajArray, uint64(len(t.Bls))); err != nil {
+		return err
+	}
+	for _, v := range t.Bls {
+		if err := v.MarshalCBOR(w); err != nil {
+			return err
+		}
+	}
+
+	// t.BlsIncludes ([][]uint64) (slice)
+	if len(t.BlsIncludes) > cbg.MaxLength {
+		return xerrors.Errorf("Slice value in field t.BlsIncludes was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajArray, uint64(len(t.BlsIncludes))); err != nil {
+		return err
+	}
+	for _, v := range t.BlsIncludes {
+		if len(v) > cbg.MaxLength {
+			return xerrors.Errorf("Slice value in field v was too long")
+		}
+
+		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajArray, uint64(len(v))); err != nil {
+			return err
+		}
+		for _, v := range v {
+			if err := cbg.CborWriteHeader(w, cbg.MajUnsignedInt, uint64(v)); err != nil {
+				return err
+			}
+		}
+	}
+
+	// t.Secpk ([]*types.SignedMessage) (slice)
+	if len(t.Secpk) > cbg.MaxLength {
+		return xerrors.Errorf("Slice value in field t.Secpk was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajArray, uint64(len(t.Secpk))); err != nil {
+		return err
+	}
+	for _, v := range t.Secpk {
+		if err := v.MarshalCBOR(w); err != nil {
+			return err
+		}
+	}
+
+	// t.SecpkIncludes ([][]uint64) (slice)
+	if len(t.SecpkIncludes) > cbg.MaxLength {
+		return xerrors.Errorf("Slice value in field t.SecpkIncludes was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajArray, uint64(len(t.SecpkIncludes))); err != nil {
+		return err
+	}
+	for _, v := range t.SecpkIncludes {
+		if len(v) > cbg.MaxLength {
+			return xerrors.Errorf("Slice value in field v was too long")
+		}
+
+		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajArray, uint64(len(v))); err != nil {
+			return err
+		}
+		for _, v := range v {
+			if err := cbg.CborWriteHeader(w, cbg.MajUnsignedInt, uint64(v)); err != nil {
+				return err
+			}
+		}
+	}
+	return nil
+}
+
+func (t *CompactedMessages) UnmarshalCBOR(r io.Reader) error {
+	*t = CompactedMessages{}
+
+	br := cbg.GetPeeker(r)
+	scratch := make([]byte, 8)
+
+	maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
+	if err != nil {
+		return err
+	}
+	if maj != cbg.MajArray {
+		return fmt.Errorf("cbor input should be of type array")
+	}
+
+	if extra != 4 {
+		return fmt.Errorf("cbor input had wrong number of fields")
+	}
+
+	// t.Bls ([]*types.Message) (slice)
+
+	maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
+	if err != nil {
+		return err
+	}
+
+	if extra > cbg.MaxLength {
+		return fmt.Errorf("t.Bls: array too large (%d)", extra)
+	}
+
+	if maj != cbg.MajArray {
+		return fmt.Errorf("expected cbor array")
+	}
+
+	if extra > 0 {
+		t.Bls = make([]*types.Message, extra)
+	}
+
+	for i := 0; i < int(extra); i++ {
+
+		var v types.Message
+		if err := v.UnmarshalCBOR(br); err != nil {
+			return err
+		}
+
+		t.Bls[i] = &v
+	}
+
+	// t.BlsIncludes ([][]uint64) (slice)
+
+	maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
+	if err != nil {
+		return err
+	}
+
+	if extra > cbg.MaxLength {
+		return fmt.Errorf("t.BlsIncludes: array too large (%d)", extra)
+	}
+
+	if maj != cbg.MajArray {
+		return fmt.Errorf("expected cbor array")
+	}
+
+	if extra > 0 {
+		t.BlsIncludes = make([][]uint64, extra)
+	}
+
+	for i := 0; i < int(extra); i++ {
+		{
+			var maj byte
+			var extra uint64
+			var err error
+
+			maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
+			if err != nil {
+				return err
+			}
+
+			if extra > cbg.MaxLength {
+				return fmt.Errorf("t.BlsIncludes[i]: array too large (%d)", extra)
+			}
+
+			if maj != cbg.MajArray {
+				return fmt.Errorf("expected cbor array")
+			}
+
+			if extra > 0 {
+				t.BlsIncludes[i] = make([]uint64, extra)
+			}
+
+			for j := 0; j < int(extra); j++ {
+
+				maj, val, err := cbg.CborReadHeaderBuf(br, scratch)
+				if err != nil {
+					return xerrors.Errorf("failed to read uint64 for t.BlsIncludes[i] slice: %w", err)
+				}
+
+				if maj != cbg.MajUnsignedInt {
+					return xerrors.Errorf("value read for array t.BlsIncludes[i] was not a uint, instead got %d", maj)
+				}
+
+				t.BlsIncludes[i][j] = uint64(val)
+			}
+
+		}
+	}
+
+	// t.Secpk ([]*types.SignedMessage) (slice)
+
+	maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
+	if err != nil {
+		return err
+	}
+
+	if extra > cbg.MaxLength {
+		return fmt.Errorf("t.Secpk: array too large (%d)", extra)
+	}
+
+	if maj != cbg.MajArray {
+		return fmt.Errorf("expected cbor array")
+	}
+
+	if extra > 0 {
+		t.Secpk = make([]*types.SignedMessage, extra)
+	}
+
+	for i := 0; i < int(extra); i++ {
+
+		var v types.SignedMessage
+		if err := v.UnmarshalCBOR(br); err != nil {
+			return err
+		}
+
+		t.Secpk[i] = &v
+	}
+
+	// t.SecpkIncludes ([][]uint64) (slice)
+
+	maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
+	if err != nil {
+		return err
+	}
+
+	if extra > cbg.MaxLength {
+		return fmt.Errorf("t.SecpkIncludes: array too large (%d)", extra)
+	}
+
+	if maj != cbg.MajArray {
+		return fmt.Errorf("expected cbor array")
+	}
+
+	if extra > 0 {
+		t.SecpkIncludes = make([][]uint64, extra)
+	}
+
+	for i := 0; i < int(extra); i++ {
+		{
+			var maj byte
+			var extra uint64
+			var err error
+
+			maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
+			if err != nil {
+				return err
+			}
+
+			if extra > cbg.MaxLength {
+				return fmt.Errorf("t.SecpkIncludes[i]: array too large (%d)", extra)
+			}
+
+			if maj != cbg.MajArray {
+				return fmt.Errorf("expected cbor array")
+			}
+
+			if extra > 0 {
+				t.SecpkIncludes[i] = make([]uint64, extra)
+			}
+
+			for j := 0; j < int(extra); j++ {
+
+				maj, val, err := cbg.CborReadHeaderBuf(br, scratch)
+				if err != nil {
+					return xerrors.Errorf("failed to read uint64 for t.SecpkIncludes[i] slice: %w", err)
+				}
+
+				if maj != cbg.MajUnsignedInt {
+					return xerrors.Errorf("value read for array t.SecpkIncludes[i] was not a uint, instead got %d", maj)
+				}
+
+				t.SecpkIncludes[i][j] = uint64(val)
+			}
+
+		}
+	}
+
+	return nil
+}
+
+var lengthBufBSTipSet = []byte{130}
+
+func (t *BSTipSet) MarshalCBOR(w io.Writer) error {
+	if t == nil {
+		_, err := w.Write(cbg.CborNull)
+		return err
+	}
+	if _, err := w.Write(lengthBufBSTipSet); err != nil {
+		return err
+	}
+
+	scratch := make([]byte, 9)
+
+	// t.Blocks ([]*types.BlockHeader) (slice)
+	if len(t.Blocks) > cbg.MaxLength {
+		return xerrors.Errorf("Slice value in field t.Blocks was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajArray, uint64(len(t.Blocks))); err != nil {
+		return err
+	}
+	for _, v := range t.Blocks {
+		if err := v.MarshalCBOR(w); err != nil {
+			return err
+		}
+	}
+
+	// t.Messages (exchange.CompactedMessages) (struct)
+	if err := t.Messages.MarshalCBOR(w); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (t *BSTipSet) UnmarshalCBOR(r io.Reader) error {
+	*t = BSTipSet{}
+
+	br := cbg.GetPeeker(r)
+	scratch := make([]byte, 8)
+
+	maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
+	if err != nil {
+		return err
+	}
+	if maj != cbg.MajArray {
+		return fmt.Errorf("cbor input should be of type array")
+	}
+
+	if extra != 2 {
+		return fmt.Errorf("cbor input had wrong number of fields")
+	}
+
+	// t.Blocks ([]*types.BlockHeader) (slice)
+
+	maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
+	if err != nil {
+		return err
+	}
+
+	if extra > cbg.MaxLength {
+		return fmt.Errorf("t.Blocks: array too large (%d)", extra)
+	}
+
+	if maj != cbg.MajArray {
+		return fmt.Errorf("expected cbor array")
+	}
+
+	if extra > 0 {
+		t.Blocks = make([]*types.BlockHeader, extra)
+	}
+
+	for i := 0; i < int(extra); i++ {
+
+		var v types.BlockHeader
+		if err := v.UnmarshalCBOR(br); err != nil {
+			return err
+		}
+
+		t.Blocks[i] = &v
+	}
+
+	// t.Messages (exchange.CompactedMessages) (struct)
+
+	{
+
+		b, err := br.ReadByte()
+		if err != nil {
+			return err
+		}
+		if b != cbg.CborNull[0] {
+			if err := br.UnreadByte(); err != nil {
+				return err
+			}
+			t.Messages = new(CompactedMessages)
+			if err := t.Messages.UnmarshalCBOR(br); err != nil {
+				return xerrors.Errorf("unmarshaling t.Messages pointer: %w", err)
+			}
+		}
+
+	}
+	return nil
+}
diff --git a/chain/exchange/client.go b/chain/exchange/client.go
new file mode 100644
index 000000000..371c50aed
--- /dev/null
+++ b/chain/exchange/client.go
@@ -0,0 +1,491 @@
+package exchange
+
+import (
+	"bufio"
+	"context"
+	"fmt"
+	"math/rand"
+	"time"
+
+	"github.com/libp2p/go-libp2p-core/helpers"
+	"github.com/libp2p/go-libp2p-core/host"
+	"github.com/libp2p/go-libp2p-core/network"
+	"github.com/libp2p/go-libp2p-core/peer"
+
+	"go.opencensus.io/trace"
+	"go.uber.org/fx"
+	"golang.org/x/xerrors"
+
+	cborutil "github.com/filecoin-project/go-cbor-util"
+
+	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/store"
+	"github.com/filecoin-project/lotus/chain/types"
+	incrt "github.com/filecoin-project/lotus/lib/increadtimeout"
+	"github.com/filecoin-project/lotus/lib/peermgr"
+)
+
+// client implements exchange.Client, using the libp2p ChainExchange protocol
+// as the fetching mechanism.
+type client struct {
+	// Connection manager used to contact the server.
+	// FIXME: We should have a reduced interface here, initialized
+	//  just with our protocol ID, we shouldn't be able to open *any*
+	//  connection.
+	host host.Host
+
+	peerTracker *bsPeerTracker
+}
+
+var _ Client = (*client)(nil)
+
+// NewClient creates a new libp2p-based exchange.Client that uses the libp2p
+// ChainExhange protocol as the fetching mechanism.
+func NewClient(lc fx.Lifecycle, host host.Host, pmgr peermgr.MaybePeerMgr) Client {
+	return &client{
+		host:        host,
+		peerTracker: newPeerTracker(lc, host, pmgr.Mgr),
+	}
+}
+
+// Main logic of the client request service. The provided `Request`
+// is sent to the `singlePeer` if one is indicated or to all available
+// ones otherwise. The response is processed and validated according
+// to the `Request` options. Either a `validatedResponse` is returned
+// (which can be safely accessed), or an `error` that may represent
+// either a response error status, a failed validation or an internal
+// error.
+//
+// This is the internal single point of entry for all external-facing
+// APIs, currently we have 3 very heterogeneous services exposed:
+// * GetBlocks:         Headers
+// * GetFullTipSet:     Headers | Messages
+// * GetChainMessages:            Messages
+// This function handles all the different combinations of the available
+// request options without disrupting external calls. In the future the
+// consumers should be forced to use a more standardized service and
+// adhere to a single API derived from this function.
+func (c *client) doRequest(
+	ctx context.Context,
+	req *Request,
+	singlePeer *peer.ID,
+	// In the `GetChainMessages` case, we won't request the headers but we still
+	// need them to check the integrity of the `CompactedMessages` in the response
+	// so the tipset blocks need to be provided by the caller.
+	tipsets []*types.TipSet,
+) (*validatedResponse, error) {
+	// Validate request.
+	if req.Length == 0 {
+		return nil, xerrors.Errorf("invalid request of length 0")
+	}
+	if req.Length > MaxRequestLength {
+		return nil, xerrors.Errorf("request length (%d) above maximum (%d)",
+			req.Length, MaxRequestLength)
+	}
+	if req.Options == 0 {
+		return nil, xerrors.Errorf("request with no options set")
+	}
+
+	// Generate the list of peers to be queried, either the
+	// `singlePeer` indicated or all peers available (sorted
+	// by an internal peer tracker with some randomness injected).
+	var peers []peer.ID
+	if singlePeer != nil {
+		peers = []peer.ID{*singlePeer}
+	} else {
+		peers = c.getShuffledPeers()
+		if len(peers) == 0 {
+			return nil, xerrors.Errorf("no peers available")
+		}
+	}
+
+	// Try the request for each peer in the list,
+	// return on the first successful response.
+	// FIXME: Doing this serially isn't great, but fetching in parallel
+	//  may not be a good idea either. Think about this more.
+	globalTime := build.Clock.Now()
+	// Global time used to track what is the expected time we will need to get
+	// a response if a client fails us.
+	for _, peer := range peers {
+		select {
+		case <-ctx.Done():
+			return nil, xerrors.Errorf("context cancelled: %w", ctx.Err())
+		default:
+		}
+
+		// Send request, read response.
+		res, err := c.sendRequestToPeer(ctx, peer, req)
+		if err != nil {
+			if !xerrors.Is(err, network.ErrNoConn) {
+				log.Warnf("could not connect to peer %s: %s",
+					peer.String(), err)
+			}
+			continue
+		}
+
+		// Process and validate response.
+		validRes, err := c.processResponse(req, res, tipsets)
+		if err != nil {
+			log.Warnf("processing peer %s response failed: %s",
+				peer.String(), err)
+			continue
+		}
+
+		c.peerTracker.logGlobalSuccess(build.Clock.Since(globalTime))
+		c.host.ConnManager().TagPeer(peer, "bsync", SuccessPeerTagValue)
+		return validRes, nil
+	}
+
+	errString := "doRequest failed for all peers"
+	if singlePeer != nil {
+		errString = fmt.Sprintf("doRequest failed for single peer %s", *singlePeer)
+	}
+	return nil, xerrors.Errorf(errString)
+}
+
+// Process and validate response. Check the status, the integrity of the
+// information returned, and that it matches the request. Extract the information
+// into a `validatedResponse` for the external-facing APIs to select what they
+// need.
+//
+// We are conflating in the single error returned both status and validation
+// errors. Peer penalization should happen here then, before returning, so
+// we can apply the correct penalties depending on the cause of the error.
+// FIXME: Add the `peer` as argument once we implement penalties.
+func (c *client) processResponse(req *Request, res *Response, tipsets []*types.TipSet) (*validatedResponse, error) {
+	err := res.statusToError()
+	if err != nil {
+		return nil, xerrors.Errorf("status error: %s", err)
+	}
+
+	options := parseOptions(req.Options)
+	if options.noOptionsSet() {
+		// Safety check: this shouldn't have been sent, and even if it did
+		// it should have been caught by the peer in its error status.
+		return nil, xerrors.Errorf("nothing was requested")
+	}
+
+	// Verify that the chain segment returned is in the valid range.
+	// Note that the returned length might be less than requested.
+	resLength := len(res.Chain)
+	if resLength == 0 {
+		return nil, xerrors.Errorf("got no chain in successful response")
+	}
+	if resLength > int(req.Length) {
+		return nil, xerrors.Errorf("got longer response (%d) than requested (%d)",
+			resLength, req.Length)
+	}
+	if resLength < int(req.Length) && res.Status != Partial {
+		return nil, xerrors.Errorf("got less than requested without a proper status: %d", res.Status)
+	}
+
+	validRes := &validatedResponse{}
+	if options.IncludeHeaders {
+		// Check for valid block sets and extract them into `TipSet`s.
+		validRes.tipsets = make([]*types.TipSet, resLength)
+		for i := 0; i < resLength; i++ {
+			if res.Chain[i] == nil {
+				return nil, xerrors.Errorf("response with nil tipset in pos %d", i)
+			}
+			for blockIdx, block := range res.Chain[i].Blocks {
+				if block == nil {
+					return nil, xerrors.Errorf("tipset with nil block in pos %d", blockIdx)
+					// FIXME: Maybe we should move this check to `NewTipSet`.
+				}
+			}
+
+			validRes.tipsets[i], err = types.NewTipSet(res.Chain[i].Blocks)
+			if err != nil {
+				return nil, xerrors.Errorf("invalid tipset blocks at height (head - %d): %w", i, err)
+			}
+		}
+
+		// Check that the returned head matches the one requested.
+		if !types.CidArrsEqual(validRes.tipsets[0].Cids(), req.Head) {
+			return nil, xerrors.Errorf("returned chain head does not match request")
+		}
+
+		// Check `TipSet`s are connected (valid chain).
+		for i := 0; i < len(validRes.tipsets)-1; i++ {
+			if validRes.tipsets[i].IsChildOf(validRes.tipsets[i+1]) == false {
+				return nil, fmt.Errorf("tipsets are not connected at height (head - %d)/(head - %d)",
+					i, i+1)
+				// FIXME: Maybe give more information here, like CIDs.
+			}
+		}
+	}
+
+	if options.IncludeMessages {
+		validRes.messages = make([]*CompactedMessages, resLength)
+		for i := 0; i < resLength; i++ {
+			if res.Chain[i].Messages == nil {
+				return nil, xerrors.Errorf("no messages included for tipset at height (head - %d)", i)
+			}
+			validRes.messages[i] = res.Chain[i].Messages
+		}
+
+		if options.IncludeHeaders {
+			// If the headers were also returned check that the compression
+			// indexes are valid before `toFullTipSets()` is called by the
+			// consumer.
+			err := c.validateCompressedIndices(res.Chain)
+			if err != nil {
+				return nil, err
+			}
+		} else {
+			// If we didn't request the headers they should have been provided
+			// by the caller.
+			if len(tipsets) < len(res.Chain) {
+				return nil, xerrors.Errorf("not enought tipsets provided for message response validation, needed %d, have %d", len(res.Chain), len(tipsets))
+			}
+			chain := make([]*BSTipSet, 0, resLength)
+			for i, resChain := range res.Chain {
+				next := &BSTipSet{
+					Blocks:   tipsets[i].Blocks(),
+					Messages: resChain.Messages,
+				}
+				chain = append(chain, next)
+			}
+
+			err := c.validateCompressedIndices(chain)
+			if err != nil {
+				return nil, err
+			}
+		}
+	}
+
+	return validRes, nil
+}
+
+func (c *client) validateCompressedIndices(chain []*BSTipSet) error {
+	resLength := len(chain)
+	for tipsetIdx := 0; tipsetIdx < resLength; tipsetIdx++ {
+		msgs := chain[tipsetIdx].Messages
+		blocksNum := len(chain[tipsetIdx].Blocks)
+
+		if len(msgs.BlsIncludes) != blocksNum {
+			return xerrors.Errorf("BlsIncludes (%d) does not match number of blocks (%d)",
+				len(msgs.BlsIncludes), blocksNum)
+		}
+
+		if len(msgs.SecpkIncludes) != blocksNum {
+			return xerrors.Errorf("SecpkIncludes (%d) does not match number of blocks (%d)",
+				len(msgs.SecpkIncludes), blocksNum)
+		}
+
+		for blockIdx := 0; blockIdx < blocksNum; blockIdx++ {
+			for _, mi := range msgs.BlsIncludes[blockIdx] {
+				if int(mi) >= len(msgs.Bls) {
+					return xerrors.Errorf("index in BlsIncludes (%d) exceeds number of messages (%d)",
+						mi, len(msgs.Bls))
+				}
+			}
+
+			for _, mi := range msgs.SecpkIncludes[blockIdx] {
+				if int(mi) >= len(msgs.Secpk) {
+					return xerrors.Errorf("index in SecpkIncludes (%d) exceeds number of messages (%d)",
+						mi, len(msgs.Secpk))
+				}
+			}
+		}
+	}
+
+	return nil
+}
+
+// GetBlocks implements Client.GetBlocks(). Refer to the godocs there.
+func (c *client) GetBlocks(ctx context.Context, tsk types.TipSetKey, count int) ([]*types.TipSet, error) {
+	ctx, span := trace.StartSpan(ctx, "bsync.GetBlocks")
+	defer span.End()
+	if span.IsRecordingEvents() {
+		span.AddAttributes(
+			trace.StringAttribute("tipset", fmt.Sprint(tsk.Cids())),
+			trace.Int64Attribute("count", int64(count)),
+		)
+	}
+
+	req := &Request{
+		Head:    tsk.Cids(),
+		Length:  uint64(count),
+		Options: Headers,
+	}
+
+	validRes, err := c.doRequest(ctx, req, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return validRes.tipsets, nil
+}
+
+// GetFullTipSet implements Client.GetFullTipSet(). Refer to the godocs there.
+func (c *client) GetFullTipSet(ctx context.Context, peer peer.ID, tsk types.TipSetKey) (*store.FullTipSet, error) {
+	// TODO: round robin through these peers on error
+
+	req := &Request{
+		Head:    tsk.Cids(),
+		Length:  1,
+		Options: Headers | Messages,
+	}
+
+	validRes, err := c.doRequest(ctx, req, &peer, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return validRes.toFullTipSets()[0], nil
+	// If `doRequest` didn't fail we are guaranteed to have at least
+	//  *one* tipset here, so it's safe to index directly.
+}
+
+// GetChainMessages implements Client.GetChainMessages(). Refer to the godocs there.
+func (c *client) GetChainMessages(ctx context.Context, tipsets []*types.TipSet) ([]*CompactedMessages, error) {
+	head := tipsets[0]
+	length := uint64(len(tipsets))
+
+	ctx, span := trace.StartSpan(ctx, "GetChainMessages")
+	if span.IsRecordingEvents() {
+		span.AddAttributes(
+			trace.StringAttribute("tipset", fmt.Sprint(head.Cids())),
+			trace.Int64Attribute("count", int64(length)),
+		)
+	}
+	defer span.End()
+
+	req := &Request{
+		Head:    head.Cids(),
+		Length:  length,
+		Options: Messages,
+	}
+
+	validRes, err := c.doRequest(ctx, req, nil, tipsets)
+	if err != nil {
+		return nil, err
+	}
+
+	return validRes.messages, nil
+}
+
+// Send a request to a peer. Write request in the stream and read the
+// response back. We do not do any processing of the request/response
+// here.
+func (c *client) sendRequestToPeer(ctx context.Context, peer peer.ID, req *Request) (_ *Response, err error) {
+	// Trace code.
+	ctx, span := trace.StartSpan(ctx, "sendRequestToPeer")
+	defer span.End()
+	if span.IsRecordingEvents() {
+		span.AddAttributes(
+			trace.StringAttribute("peer", peer.Pretty()),
+		)
+	}
+	defer func() {
+		if err != nil {
+			if span.IsRecordingEvents() {
+				span.SetStatus(trace.Status{
+					Code:    5,
+					Message: err.Error(),
+				})
+			}
+		}
+	}()
+	// -- TRACE --
+
+	supported, err := c.host.Peerstore().SupportsProtocols(peer, BlockSyncProtocolID, ChainExchangeProtocolID)
+	if err != nil {
+		c.RemovePeer(peer)
+		return nil, xerrors.Errorf("failed to get protocols for peer: %w", err)
+	}
+	if len(supported) == 0 || (supported[0] != BlockSyncProtocolID && supported[0] != ChainExchangeProtocolID) {
+		return nil, xerrors.Errorf("peer %s does not support protocols %s",
+			peer, []string{BlockSyncProtocolID, ChainExchangeProtocolID})
+	}
+
+	connectionStart := build.Clock.Now()
+
+	// Open stream to peer.
+	stream, err := c.host.NewStream(
+		network.WithNoDial(ctx, "should already have connection"),
+		peer,
+		ChainExchangeProtocolID, BlockSyncProtocolID)
+	if err != nil {
+		c.RemovePeer(peer)
+		return nil, xerrors.Errorf("failed to open stream to peer: %w", err)
+	}
+
+	defer func() {
+		// Note: this will become just stream.Close once we've completed the go-libp2p migration to
+		//       go-libp2p-core 0.7.0
+		go helpers.FullClose(stream) //nolint:errcheck
+	}()
+
+	// Write request.
+	_ = stream.SetWriteDeadline(time.Now().Add(WriteReqDeadline))
+	if err := cborutil.WriteCborRPC(stream, req); err != nil {
+		_ = stream.SetWriteDeadline(time.Time{})
+		c.peerTracker.logFailure(peer, build.Clock.Since(connectionStart), req.Length)
+		// FIXME: Should we also remove peer here?
+		return nil, err
+	}
+	_ = stream.SetWriteDeadline(time.Time{}) // clear deadline // FIXME: Needs
+	//  its own API (https://github.com/libp2p/go-libp2p-core/issues/162).
+
+	// Read response.
+	var res Response
+	err = cborutil.ReadCborRPC(
+		bufio.NewReader(incrt.New(stream, ReadResMinSpeed, ReadResDeadline)),
+		&res)
+	if err != nil {
+		c.peerTracker.logFailure(peer, build.Clock.Since(connectionStart), req.Length)
+		return nil, xerrors.Errorf("failed to read chainxchg response: %w", err)
+	}
+
+	// FIXME: Move all this together at the top using a defer as done elsewhere.
+	//  Maybe we need to declare `res` in the signature.
+	if span.IsRecordingEvents() {
+		span.AddAttributes(
+			trace.Int64Attribute("resp_status", int64(res.Status)),
+			trace.StringAttribute("msg", res.ErrorMessage),
+			trace.Int64Attribute("chain_len", int64(len(res.Chain))),
+		)
+	}
+
+	c.peerTracker.logSuccess(peer, build.Clock.Since(connectionStart), uint64(len(res.Chain)))
+	// FIXME: We should really log a success only after we validate the response.
+	//  It might be a bit hard to do.
+	return &res, nil
+}
+
+// AddPeer implements Client.AddPeer(). Refer to the godocs there.
+func (c *client) AddPeer(p peer.ID) {
+	c.peerTracker.addPeer(p)
+}
+
+// RemovePeer implements Client.RemovePeer(). Refer to the godocs there.
+func (c *client) RemovePeer(p peer.ID) {
+	c.peerTracker.removePeer(p)
+}
+
+// getShuffledPeers returns a preference-sorted set of peers (by latency
+// and failure counting), shuffling the first few peers so we don't always
+// pick the same peer.
+// FIXME: Consider merging with `shufflePrefix()s`.
+func (c *client) getShuffledPeers() []peer.ID {
+	peers := c.peerTracker.prefSortedPeers()
+	shufflePrefix(peers)
+	return peers
+}
+
+func shufflePrefix(peers []peer.ID) {
+	prefix := ShufflePeersPrefix
+	if len(peers) < prefix {
+		prefix = len(peers)
+	}
+
+	buf := make([]peer.ID, prefix)
+	perm := rand.Perm(prefix)
+	for i, v := range perm {
+		buf[i] = peers[v]
+	}
+
+	copy(peers, buf)
+}
diff --git a/chain/exchange/doc.go b/chain/exchange/doc.go
new file mode 100644
index 000000000..b20ee0c1f
--- /dev/null
+++ b/chain/exchange/doc.go
@@ -0,0 +1,19 @@
+// Package exchange contains the ChainExchange server and client components.
+//
+// ChainExchange is the basic chain synchronization protocol of Filecoin.
+// ChainExchange is an RPC-oriented protocol, with a single operation to
+// request blocks for now.
+//
+// A request contains a start anchor block (referred to with a CID), and a
+// amount of blocks requested beyond the anchor (including the anchor itself).
+//
+// A client can also pass options, encoded as a 64-bit bitfield. Lotus supports
+// two options at the moment:
+//
+//  - include block contents
+//  - include block messages
+//
+// The response will include a status code, an optional message, and the
+// response payload in case of success. The payload is a slice of serialized
+// tipsets.
+package exchange
diff --git a/chain/exchange/interfaces.go b/chain/exchange/interfaces.go
new file mode 100644
index 000000000..acc0854da
--- /dev/null
+++ b/chain/exchange/interfaces.go
@@ -0,0 +1,50 @@
+package exchange
+
+import (
+	"context"
+
+	"github.com/libp2p/go-libp2p-core/network"
+	"github.com/libp2p/go-libp2p-core/peer"
+
+	"github.com/filecoin-project/lotus/chain/store"
+	"github.com/filecoin-project/lotus/chain/types"
+)
+
+// Server is the responder side of the ChainExchange protocol. It accepts
+// requests from clients and services them by returning the requested
+// chain data.
+type Server interface {
+	// HandleStream is the protocol handler to be registered on a libp2p
+	// protocol router.
+	//
+	// In the current version of the protocol, streams are single-use. The
+	// server will read a single Request, and will respond with a single
+	// Response. It will dispose of the stream straight after.
+	HandleStream(stream network.Stream)
+}
+
+// Client is the requesting side of the ChainExchange protocol. It acts as
+// a proxy for other components to request chain data from peers. It is chiefly
+// used by the Syncer.
+type Client interface {
+	// GetBlocks fetches block headers from the network, from the provided
+	// tipset *backwards*, returning as many tipsets as the count parameter,
+	// or less.
+	GetBlocks(ctx context.Context, tsk types.TipSetKey, count int) ([]*types.TipSet, error)
+
+	// GetChainMessages fetches messages from the network, starting from the first provided tipset
+	// and returning messages from as many tipsets as requested or less.
+	GetChainMessages(ctx context.Context, tipsets []*types.TipSet) ([]*CompactedMessages, error)
+
+	// GetFullTipSet fetches a full tipset from a given peer. If successful,
+	// the fetched object contains block headers and all messages in full form.
+	GetFullTipSet(ctx context.Context, peer peer.ID, tsk types.TipSetKey) (*store.FullTipSet, error)
+
+	// AddPeer adds a peer to the pool of peers that the Client requests
+	// data from.
+	AddPeer(peer peer.ID)
+
+	// RemovePeer removes a peer from the pool of peers that the Client
+	// requests data from.
+	RemovePeer(peer peer.ID)
+}
diff --git a/chain/exchange/peer_tracker.go b/chain/exchange/peer_tracker.go
new file mode 100644
index 000000000..902baadce
--- /dev/null
+++ b/chain/exchange/peer_tracker.go
@@ -0,0 +1,189 @@
+package exchange
+
+// FIXME: This needs to be reviewed.
+
+import (
+	"context"
+	"sort"
+	"sync"
+	"time"
+
+	host "github.com/libp2p/go-libp2p-core/host"
+	"github.com/libp2p/go-libp2p-core/peer"
+	"go.uber.org/fx"
+
+	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/lib/peermgr"
+)
+
+type peerStats struct {
+	successes   int
+	failures    int
+	firstSeen   time.Time
+	averageTime time.Duration
+}
+
+type bsPeerTracker struct {
+	lk sync.Mutex
+
+	peers         map[peer.ID]*peerStats
+	avgGlobalTime time.Duration
+
+	pmgr *peermgr.PeerMgr
+}
+
+func newPeerTracker(lc fx.Lifecycle, h host.Host, pmgr *peermgr.PeerMgr) *bsPeerTracker {
+	bsPt := &bsPeerTracker{
+		peers: make(map[peer.ID]*peerStats),
+		pmgr:  pmgr,
+	}
+
+	sub, err := h.EventBus().Subscribe(new(peermgr.NewFilPeer))
+	if err != nil {
+		panic(err)
+	}
+
+	go func() {
+		for newPeer := range sub.Out() {
+			bsPt.addPeer(newPeer.(peermgr.NewFilPeer).Id)
+		}
+	}()
+
+	lc.Append(fx.Hook{
+		OnStop: func(ctx context.Context) error {
+			return sub.Close()
+		},
+	})
+
+	return bsPt
+}
+
+func (bpt *bsPeerTracker) addPeer(p peer.ID) {
+	bpt.lk.Lock()
+	defer bpt.lk.Unlock()
+	if _, ok := bpt.peers[p]; ok {
+		return
+	}
+	bpt.peers[p] = &peerStats{
+		firstSeen: build.Clock.Now(),
+	}
+
+}
+
+const (
+	// newPeerMul is how much better than average is the new peer assumed to be
+	// less than one to encourouge trying new peers
+	newPeerMul = 0.9
+)
+
+func (bpt *bsPeerTracker) prefSortedPeers() []peer.ID {
+	// TODO: this could probably be cached, but as long as its not too many peers, fine for now
+	bpt.lk.Lock()
+	defer bpt.lk.Unlock()
+	out := make([]peer.ID, 0, len(bpt.peers))
+	for p := range bpt.peers {
+		out = append(out, p)
+	}
+
+	// sort by 'expected cost' of requesting data from that peer
+	// additionally handle edge cases where not enough data is available
+	sort.Slice(out, func(i, j int) bool {
+		pi := bpt.peers[out[i]]
+		pj := bpt.peers[out[j]]
+
+		var costI, costJ float64
+
+		getPeerInitLat := func(p peer.ID) float64 {
+			return float64(bpt.avgGlobalTime) * newPeerMul
+		}
+
+		if pi.successes+pi.failures > 0 {
+			failRateI := float64(pi.failures) / float64(pi.failures+pi.successes)
+			costI = float64(pi.averageTime) + failRateI*float64(bpt.avgGlobalTime)
+		} else {
+			costI = getPeerInitLat(out[i])
+		}
+
+		if pj.successes+pj.failures > 0 {
+			failRateJ := float64(pj.failures) / float64(pj.failures+pj.successes)
+			costJ = float64(pj.averageTime) + failRateJ*float64(bpt.avgGlobalTime)
+		} else {
+			costJ = getPeerInitLat(out[j])
+		}
+
+		return costI < costJ
+	})
+
+	return out
+}
+
+const (
+	// xInvAlpha = (N+1)/2
+
+	localInvAlpha  = 10 // 86% of the value is the last 19
+	globalInvAlpha = 25 // 86% of the value is the last 49
+)
+
+func (bpt *bsPeerTracker) logGlobalSuccess(dur time.Duration) {
+	bpt.lk.Lock()
+	defer bpt.lk.Unlock()
+
+	if bpt.avgGlobalTime == 0 {
+		bpt.avgGlobalTime = dur
+		return
+	}
+	delta := (dur - bpt.avgGlobalTime) / globalInvAlpha
+	bpt.avgGlobalTime += delta
+}
+
+func logTime(pi *peerStats, dur time.Duration) {
+	if pi.averageTime == 0 {
+		pi.averageTime = dur
+		return
+	}
+	delta := (dur - pi.averageTime) / localInvAlpha
+	pi.averageTime += delta
+
+}
+
+func (bpt *bsPeerTracker) logSuccess(p peer.ID, dur time.Duration, reqSize uint64) {
+	bpt.lk.Lock()
+	defer bpt.lk.Unlock()
+
+	var pi *peerStats
+	var ok bool
+	if pi, ok = bpt.peers[p]; !ok {
+		log.Warnw("log success called on peer not in tracker", "peerid", p.String())
+		return
+	}
+
+	pi.successes++
+	if reqSize == 0 {
+		reqSize = 1
+	}
+	logTime(pi, dur/time.Duration(reqSize))
+}
+
+func (bpt *bsPeerTracker) logFailure(p peer.ID, dur time.Duration, reqSize uint64) {
+	bpt.lk.Lock()
+	defer bpt.lk.Unlock()
+
+	var pi *peerStats
+	var ok bool
+	if pi, ok = bpt.peers[p]; !ok {
+		log.Warn("log failure called on peer not in tracker", "peerid", p.String())
+		return
+	}
+
+	pi.failures++
+	if reqSize == 0 {
+		reqSize = 1
+	}
+	logTime(pi, dur/time.Duration(reqSize))
+}
+
+func (bpt *bsPeerTracker) removePeer(p peer.ID) {
+	bpt.lk.Lock()
+	defer bpt.lk.Unlock()
+	delete(bpt.peers, p)
+}
diff --git a/chain/exchange/protocol.go b/chain/exchange/protocol.go
new file mode 100644
index 000000000..211479335
--- /dev/null
+++ b/chain/exchange/protocol.go
@@ -0,0 +1,207 @@
+package exchange
+
+import (
+	"time"
+
+	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/store"
+
+	"github.com/ipfs/go-cid"
+	logging "github.com/ipfs/go-log"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/lotus/chain/types"
+)
+
+var log = logging.Logger("chainxchg")
+
+const (
+	// BlockSyncProtocolID is the protocol ID of the former blocksync protocol.
+	// Deprecated.
+	BlockSyncProtocolID = "/fil/sync/blk/0.0.1"
+
+	// ChainExchangeProtocolID is the protocol ID of the chain exchange
+	// protocol.
+	ChainExchangeProtocolID = "/fil/chain/xchg/0.0.1"
+)
+
+// FIXME: Bumped from original 800 to this to accommodate `syncFork()`
+//  use of `GetBlocks()`. It seems the expectation of that API is to
+//  fetch any amount of blocks leaving it to the internal logic here
+//  to partition and reassemble the requests if they go above the maximum.
+//  (Also as a consequence of this temporarily removing the `const`
+//   qualifier to avoid "const initializer [...] is not a constant" error.)
+var MaxRequestLength = uint64(build.ForkLengthThreshold)
+
+const (
+	// Extracted constants from the code.
+	// FIXME: Should be reviewed and confirmed.
+	SuccessPeerTagValue = 25
+	WriteReqDeadline    = 5 * time.Second
+	ReadResDeadline     = WriteReqDeadline
+	ReadResMinSpeed     = 50 << 10
+	ShufflePeersPrefix  = 16
+	WriteResDeadline    = 60 * time.Second
+)
+
+// FIXME: Rename. Make private.
+type Request struct {
+	// List of ordered CIDs comprising a `TipSetKey` from where to start
+	// fetching backwards.
+	// FIXME: Consider using `TipSetKey` now (introduced after the creation
+	//  of this protocol) instead of converting back and forth.
+	Head []cid.Cid
+	// Number of block sets to fetch from `Head` (inclusive, should always
+	// be in the range `[1, MaxRequestLength]`).
+	Length uint64
+	// Request options, see `Options` type for more details. Compressed
+	// in a single `uint64` to save space.
+	Options uint64
+}
+
+// `Request` processed and validated to query the tipsets needed.
+type validatedRequest struct {
+	head    types.TipSetKey
+	length  uint64
+	options *parsedOptions
+}
+
+// Request options. When fetching the chain segment we can fetch
+// either block headers, messages, or both.
+const (
+	Headers = 1 << iota
+	Messages
+)
+
+// Decompressed options into separate struct members for easy access
+// during internal processing..
+type parsedOptions struct {
+	IncludeHeaders  bool
+	IncludeMessages bool
+}
+
+func (options *parsedOptions) noOptionsSet() bool {
+	return options.IncludeHeaders == false &&
+		options.IncludeMessages == false
+}
+
+func parseOptions(optfield uint64) *parsedOptions {
+	return &parsedOptions{
+		IncludeHeaders:  optfield&(uint64(Headers)) != 0,
+		IncludeMessages: optfield&(uint64(Messages)) != 0,
+	}
+}
+
+// FIXME: Rename. Make private.
+type Response struct {
+	Status status
+	// String that complements the error status when converting to an
+	// internal error (see `statusToError()`).
+	ErrorMessage string
+
+	Chain []*BSTipSet
+}
+
+type status uint64
+
+const (
+	Ok status = 0
+	// We could not fetch all blocks requested (but at least we returned
+	// the `Head` requested). Not considered an error.
+	Partial = 101
+
+	// Errors
+	NotFound      = 201
+	GoAway        = 202
+	InternalError = 203
+	BadRequest    = 204
+)
+
+// Convert status to internal error.
+func (res *Response) statusToError() error {
+	switch res.Status {
+	case Ok, Partial:
+		return nil
+		// FIXME: Consider if we want to not process `Partial` responses
+		//  and return an error instead.
+	case NotFound:
+		return xerrors.Errorf("not found")
+	case GoAway:
+		return xerrors.Errorf("not handling 'go away' chainxchg responses yet")
+	case InternalError:
+		return xerrors.Errorf("block sync peer errored: %s", res.ErrorMessage)
+	case BadRequest:
+		return xerrors.Errorf("block sync request invalid: %s", res.ErrorMessage)
+	default:
+		return xerrors.Errorf("unrecognized response code: %d", res.Status)
+	}
+}
+
+// FIXME: Rename.
+type BSTipSet struct {
+	// List of blocks belonging to a single tipset to which the
+	// `CompactedMessages` are linked.
+	Blocks   []*types.BlockHeader
+	Messages *CompactedMessages
+}
+
+// All messages of a single tipset compacted together instead
+// of grouped by block to save space, since there are normally
+// many repeated messages per tipset in different blocks.
+//
+// `BlsIncludes`/`SecpkIncludes` matches `Bls`/`Secpk` messages
+// to blocks in the tipsets with the format:
+// `BlsIncludes[BI][MI]`
+//  * BI: block index in the tipset.
+//  * MI: message index in `Bls` list
+//
+// FIXME: The logic to decompress this structure should belong
+//  to itself, not to the consumer.
+type CompactedMessages struct {
+	Bls         []*types.Message
+	BlsIncludes [][]uint64
+
+	Secpk         []*types.SignedMessage
+	SecpkIncludes [][]uint64
+}
+
+// Response that has been validated according to the protocol
+// and can be safely accessed.
+type validatedResponse struct {
+	tipsets []*types.TipSet
+	// List of all messages per tipset (grouped by tipset,
+	// not by block, hence a single index like `tipsets`).
+	messages []*CompactedMessages
+}
+
+// Decompress messages and form full tipsets with them. The headers
+// need to have been requested as well.
+func (res *validatedResponse) toFullTipSets() []*store.FullTipSet {
+	if len(res.tipsets) == 0 || len(res.tipsets) != len(res.messages) {
+		// This decompression can only be done if both headers and
+		// messages are returned in the response. (The second check
+		// is already implied by the guarantees of `validatedResponse`,
+		// added here just for completeness.)
+		return nil
+	}
+	ftsList := make([]*store.FullTipSet, len(res.tipsets))
+	for tipsetIdx := range res.tipsets {
+		fts := &store.FullTipSet{} // FIXME: We should use the `NewFullTipSet` API.
+		msgs := res.messages[tipsetIdx]
+		for blockIdx, b := range res.tipsets[tipsetIdx].Blocks() {
+			fb := &types.FullBlock{
+				Header: b,
+			}
+			for _, mi := range msgs.BlsIncludes[blockIdx] {
+				fb.BlsMessages = append(fb.BlsMessages, msgs.Bls[mi])
+			}
+			for _, mi := range msgs.SecpkIncludes[blockIdx] {
+				fb.SecpkMessages = append(fb.SecpkMessages, msgs.Secpk[mi])
+			}
+
+			fts.Blocks = append(fts.Blocks, fb)
+		}
+		ftsList[tipsetIdx] = fts
+	}
+	return ftsList
+}
diff --git a/chain/exchange/server.go b/chain/exchange/server.go
new file mode 100644
index 000000000..dcdb5b3a5
--- /dev/null
+++ b/chain/exchange/server.go
@@ -0,0 +1,250 @@
+package exchange
+
+import (
+	"bufio"
+	"context"
+	"fmt"
+	"time"
+
+	"go.opencensus.io/trace"
+	"golang.org/x/xerrors"
+
+	cborutil "github.com/filecoin-project/go-cbor-util"
+
+	"github.com/filecoin-project/lotus/chain/store"
+	"github.com/filecoin-project/lotus/chain/types"
+
+	"github.com/ipfs/go-cid"
+	"github.com/libp2p/go-libp2p-core/helpers"
+	inet "github.com/libp2p/go-libp2p-core/network"
+)
+
+// server implements exchange.Server. It services requests for the
+// libp2p ChainExchange protocol.
+type server struct {
+	cs *store.ChainStore
+}
+
+var _ Server = (*server)(nil)
+
+// NewServer creates a new libp2p-based exchange.Server. It services requests
+// for the libp2p ChainExchange protocol.
+func NewServer(cs *store.ChainStore) Server {
+	return &server{
+		cs: cs,
+	}
+}
+
+// HandleStream implements Server.HandleStream. Refer to the godocs there.
+func (s *server) HandleStream(stream inet.Stream) {
+	ctx, span := trace.StartSpan(context.Background(), "chainxchg.HandleStream")
+	defer span.End()
+
+	// Note: this will become just stream.Close once we've completed the go-libp2p migration to
+	//       go-libp2p-core 0.7.0
+	defer helpers.FullClose(stream) //nolint:errcheck
+
+	var req Request
+	if err := cborutil.ReadCborRPC(bufio.NewReader(stream), &req); err != nil {
+		log.Warnf("failed to read block sync request: %s", err)
+		return
+	}
+	log.Infow("block sync request",
+		"start", req.Head, "len", req.Length)
+
+	resp, err := s.processRequest(ctx, &req)
+	if err != nil {
+		log.Warn("failed to process request: ", err)
+		return
+	}
+
+	_ = stream.SetDeadline(time.Now().Add(WriteResDeadline))
+	if err := cborutil.WriteCborRPC(stream, resp); err != nil {
+		_ = stream.SetDeadline(time.Time{})
+		log.Warnw("failed to write back response for handle stream",
+			"err", err, "peer", stream.Conn().RemotePeer())
+		return
+	}
+	_ = stream.SetDeadline(time.Time{})
+}
+
+// Validate and service the request. We return either a protocol
+// response or an internal error.
+func (s *server) processRequest(ctx context.Context, req *Request) (*Response, error) {
+	validReq, errResponse := validateRequest(ctx, req)
+	if errResponse != nil {
+		// The request did not pass validation, return the response
+		//  indicating it.
+		return errResponse, nil
+	}
+
+	return s.serviceRequest(ctx, validReq)
+}
+
+// Validate request. We either return a `validatedRequest`, or an error
+// `Response` indicating why we can't process it. We do not return any
+// internal errors here, we just signal protocol ones.
+func validateRequest(ctx context.Context, req *Request) (*validatedRequest, *Response) {
+	_, span := trace.StartSpan(ctx, "chainxchg.ValidateRequest")
+	defer span.End()
+
+	validReq := validatedRequest{}
+
+	validReq.options = parseOptions(req.Options)
+	if validReq.options.noOptionsSet() {
+		return nil, &Response{
+			Status:       BadRequest,
+			ErrorMessage: "no options set",
+		}
+	}
+
+	validReq.length = req.Length
+	if validReq.length > MaxRequestLength {
+		return nil, &Response{
+			Status: BadRequest,
+			ErrorMessage: fmt.Sprintf("request length over maximum allowed (%d)",
+				MaxRequestLength),
+		}
+	}
+	if validReq.length == 0 {
+		return nil, &Response{
+			Status:       BadRequest,
+			ErrorMessage: "invalid request length of zero",
+		}
+	}
+
+	if len(req.Head) == 0 {
+		return nil, &Response{
+			Status:       BadRequest,
+			ErrorMessage: "no cids in request",
+		}
+	}
+	validReq.head = types.NewTipSetKey(req.Head...)
+
+	// FIXME: Add as a defer at the start.
+	span.AddAttributes(
+		trace.BoolAttribute("blocks", validReq.options.IncludeHeaders),
+		trace.BoolAttribute("messages", validReq.options.IncludeMessages),
+		trace.Int64Attribute("reqlen", int64(validReq.length)),
+	)
+
+	return &validReq, nil
+}
+
+func (s *server) serviceRequest(ctx context.Context, req *validatedRequest) (*Response, error) {
+	_, span := trace.StartSpan(ctx, "chainxchg.ServiceRequest")
+	defer span.End()
+
+	chain, err := collectChainSegment(s.cs, req)
+	if err != nil {
+		log.Warn("block sync request: collectChainSegment failed: ", err)
+		return &Response{
+			Status:       InternalError,
+			ErrorMessage: err.Error(),
+		}, nil
+	}
+
+	status := Ok
+	if len(chain) < int(req.length) {
+		status = Partial
+	}
+
+	return &Response{
+		Chain:  chain,
+		Status: status,
+	}, nil
+}
+
+func collectChainSegment(cs *store.ChainStore, req *validatedRequest) ([]*BSTipSet, error) {
+	var bstips []*BSTipSet
+
+	cur := req.head
+	for {
+		var bst BSTipSet
+		ts, err := cs.LoadTipSet(cur)
+		if err != nil {
+			return nil, xerrors.Errorf("failed loading tipset %s: %w", cur, err)
+		}
+
+		if req.options.IncludeHeaders {
+			bst.Blocks = ts.Blocks()
+		}
+
+		if req.options.IncludeMessages {
+			bmsgs, bmincl, smsgs, smincl, err := gatherMessages(cs, ts)
+			if err != nil {
+				return nil, xerrors.Errorf("gather messages failed: %w", err)
+			}
+
+			// FIXME: Pass the response to `gatherMessages()` and set all this there.
+			bst.Messages = &CompactedMessages{}
+			bst.Messages.Bls = bmsgs
+			bst.Messages.BlsIncludes = bmincl
+			bst.Messages.Secpk = smsgs
+			bst.Messages.SecpkIncludes = smincl
+		}
+
+		bstips = append(bstips, &bst)
+
+		// If we collected the length requested or if we reached the
+		// start (genesis), then stop.
+		if uint64(len(bstips)) >= req.length || ts.Height() == 0 {
+			return bstips, nil
+		}
+
+		cur = ts.Parents()
+	}
+}
+
+func gatherMessages(cs *store.ChainStore, ts *types.TipSet) ([]*types.Message, [][]uint64, []*types.SignedMessage, [][]uint64, error) {
+	blsmsgmap := make(map[cid.Cid]uint64)
+	secpkmsgmap := make(map[cid.Cid]uint64)
+	var secpkincl, blsincl [][]uint64
+
+	var blscids, secpkcids []cid.Cid
+	for _, block := range ts.Blocks() {
+		bc, sc, err := cs.ReadMsgMetaCids(block.Messages)
+		if err != nil {
+			return nil, nil, nil, nil, err
+		}
+
+		// FIXME: DRY. Use `chain.Message` interface.
+		bmi := make([]uint64, 0, len(bc))
+		for _, m := range bc {
+			i, ok := blsmsgmap[m]
+			if !ok {
+				i = uint64(len(blscids))
+				blscids = append(blscids, m)
+				blsmsgmap[m] = i
+			}
+
+			bmi = append(bmi, i)
+		}
+		blsincl = append(blsincl, bmi)
+
+		smi := make([]uint64, 0, len(sc))
+		for _, m := range sc {
+			i, ok := secpkmsgmap[m]
+			if !ok {
+				i = uint64(len(secpkcids))
+				secpkcids = append(secpkcids, m)
+				secpkmsgmap[m] = i
+			}
+
+			smi = append(smi, i)
+		}
+		secpkincl = append(secpkincl, smi)
+	}
+
+	blsmsgs, err := cs.LoadMessagesFromCids(blscids)
+	if err != nil {
+		return nil, nil, nil, nil, err
+	}
+
+	secpkmsgs, err := cs.LoadSignedMessagesFromCids(secpkcids)
+	if err != nil {
+		return nil, nil, nil, nil, err
+	}
+
+	return blsmsgs, blsincl, secpkmsgs, secpkincl, nil
+}
diff --git a/chain/gen/gen.go b/chain/gen/gen.go
index d476a0937..d05165ab1 100644
--- a/chain/gen/gen.go
+++ b/chain/gen/gen.go
@@ -3,43 +3,54 @@ package gen
 import (
 	"bytes"
 	"context"
-	"crypto/sha256"
-	"encoding/binary"
 	"fmt"
 	"io/ioutil"
 	"sync/atomic"
+	"time"
 
-	ffi "github.com/filecoin-project/filecoin-ffi"
+	"github.com/filecoin-project/specs-actors/actors/runtime/proof"
 
-	sectorbuilder "github.com/filecoin-project/go-sectorbuilder"
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/big"
+	"github.com/filecoin-project/go-state-types/crypto"
+	block "github.com/ipfs/go-block-format"
 	"github.com/ipfs/go-blockservice"
-	"github.com/ipfs/go-car"
+	"github.com/ipfs/go-cid"
 	offline "github.com/ipfs/go-ipfs-exchange-offline"
+	format "github.com/ipfs/go-ipld-format"
+	logging "github.com/ipfs/go-log/v2"
 	"github.com/ipfs/go-merkledag"
-	peer "github.com/libp2p/go-libp2p-core/peer"
+	"github.com/ipld/go-car"
 	"go.opencensus.io/trace"
 	"golang.org/x/xerrors"
 
-	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/actors/policy"
+	"github.com/filecoin-project/lotus/chain/beacon"
+	genesis2 "github.com/filecoin-project/lotus/chain/gen/genesis"
 	"github.com/filecoin-project/lotus/chain/stmgr"
 	"github.com/filecoin-project/lotus/chain/store"
 	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/chain/vm"
 	"github.com/filecoin-project/lotus/chain/wallet"
 	"github.com/filecoin-project/lotus/cmd/lotus-seed/seed"
+	"github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper"
 	"github.com/filecoin-project/lotus/genesis"
+	"github.com/filecoin-project/lotus/lib/blockstore"
+	"github.com/filecoin-project/lotus/lib/sigs"
 	"github.com/filecoin-project/lotus/node/repo"
-
-	block "github.com/ipfs/go-block-format"
-	"github.com/ipfs/go-cid"
-	blockstore "github.com/ipfs/go-ipfs-blockstore"
-	logging "github.com/ipfs/go-log"
 )
 
+const msgsPerBlock = 20
+
+//nolint:deadcode,varcheck
 var log = logging.Logger("gen")
 
-const msgsPerBlock = 20
+var ValidWpostForTesting = []proof.PoStProof{{
+	ProofBytes: []byte("valid proof"),
+}}
 
 type ChainGen struct {
 	msgsPerBlock int
@@ -48,16 +59,20 @@ type ChainGen struct {
 
 	cs *store.ChainStore
 
+	beacon beacon.Schedule
+
 	sm *stmgr.StateManager
 
 	genesis   *types.BlockHeader
 	CurTipset *store.FullTipSet
 
-	Timestamper func(*types.TipSet, uint64) uint64
+	Timestamper func(*types.TipSet, abi.ChainEpoch) uint64
+
+	GetMessages func(*ChainGen) ([]*types.SignedMessage, error)
 
 	w *wallet.Wallet
 
-	eppProvs    map[address.Address]ElectionPoStProver
+	eppProvs    map[address.Address]WinningPoStProver
 	Miners      []address.Address
 	receivers   []address.Address
 	banker      address.Address
@@ -80,7 +95,35 @@ func (m mybs) Get(c cid.Cid) (block.Block, error) {
 	return b, nil
 }
 
-func NewGenerator() (*ChainGen, error) {
+var rootkeyMultisig = genesis.MultisigMeta{
+	Signers:         []address.Address{remAccTestKey},
+	Threshold:       1,
+	VestingDuration: 0,
+	VestingStart:    0,
+}
+
+var DefaultVerifregRootkeyActor = genesis.Actor{
+	Type:    genesis.TMultisig,
+	Balance: big.NewInt(0),
+	Meta:    rootkeyMultisig.ActorMeta(),
+}
+
+var remAccTestKey, _ = address.NewFromString("t1ceb34gnsc6qk5dt6n7xg6ycwzasjhbxm3iylkiy")
+var remAccMeta = genesis.MultisigMeta{
+	Signers:   []address.Address{remAccTestKey},
+	Threshold: 1,
+}
+
+var DefaultRemainderAccountActor = genesis.Actor{
+	Type:    genesis.TMultisig,
+	Balance: big.NewInt(0),
+	Meta:    remAccMeta.ActorMeta(),
+}
+
+func NewGeneratorWithSectors(numSectors int) (*ChainGen, error) {
+	// TODO: we really shouldn't modify a global variable here.
+	policy.SetSupportedProofTypes(abi.RegisteredSealProof_StackedDrg2KiBV1)
+
 	mr := repo.NewMemory(nil)
 	lr, err := mr.Lock(repo.StorageMiner)
 	if err != nil {
@@ -92,12 +135,12 @@ func NewGenerator() (*ChainGen, error) {
 		return nil, xerrors.Errorf("failed to get metadata datastore: %w", err)
 	}
 
-	bds, err := lr.Datastore("/blocks")
+	bds, err := lr.Datastore("/chain")
 	if err != nil {
 		return nil, xerrors.Errorf("failed to get blocks datastore: %w", err)
 	}
 
-	bs := mybs{blockstore.NewIdStore(blockstore.NewBlockstore(bds))}
+	bs := mybs{blockstore.NewBlockstore(bds)}
 
 	ks, err := lr.KeyStore()
 	if err != nil {
@@ -109,77 +152,88 @@ func NewGenerator() (*ChainGen, error) {
 		return nil, xerrors.Errorf("creating memrepo wallet failed: %w", err)
 	}
 
-	banker, err := w.GenerateKey(types.KTSecp256k1)
+	banker, err := w.GenerateKey(crypto.SigTypeSecp256k1)
 	if err != nil {
 		return nil, xerrors.Errorf("failed to generate banker key: %w", err)
 	}
 
 	receievers := make([]address.Address, msgsPerBlock)
 	for r := range receievers {
-		receievers[r], err = w.GenerateKey(types.KTBLS)
+		receievers[r], err = w.GenerateKey(crypto.SigTypeBLS)
 		if err != nil {
 			return nil, xerrors.Errorf("failed to generate receiver key: %w", err)
 		}
 	}
 
-	maddr1, err := address.NewFromString("t0300")
-	if err != nil {
-		return nil, err
-	}
+	maddr1 := genesis2.MinerAddress(0)
 
 	m1temp, err := ioutil.TempDir("", "preseal")
 	if err != nil {
 		return nil, err
 	}
 
-	genm1, err := seed.PreSeal(maddr1, 1024, 0, 1, m1temp, []byte("some randomness"))
+	genm1, k1, err := seed.PreSeal(maddr1, abi.RegisteredSealProof_StackedDrg2KiBV1, 0, numSectors, m1temp, []byte("some randomness"), nil, true)
 	if err != nil {
 		return nil, err
 	}
 
-	maddr2, err := address.NewFromString("t0301")
-	if err != nil {
-		return nil, err
-	}
+	maddr2 := genesis2.MinerAddress(1)
 
 	m2temp, err := ioutil.TempDir("", "preseal")
 	if err != nil {
 		return nil, err
 	}
 
-	genm2, err := seed.PreSeal(maddr2, 1024, 0, 1, m2temp, []byte("some randomness"))
+	genm2, k2, err := seed.PreSeal(maddr2, abi.RegisteredSealProof_StackedDrg2KiBV1, 0, numSectors, m2temp, []byte("some randomness"), nil, true)
 	if err != nil {
 		return nil, err
 	}
 
-	mk1, err := w.Import(&genm1.Key)
+	mk1, err := w.Import(k1)
 	if err != nil {
 		return nil, err
 	}
-	mk2, err := w.Import(&genm2.Key)
+	mk2, err := w.Import(k2)
 	if err != nil {
 		return nil, err
 	}
 
-	minercfg := &GenMinerCfg{
-		PeerIDs: []peer.ID{"peerID1", "peerID2"},
-		PreSeals: map[string]genesis.GenesisMiner{
-			maddr1.String(): *genm1,
-			maddr2.String(): *genm2,
+	sys := vm.Syscalls(&genFakeVerifier{})
+
+	tpl := genesis.Template{
+		Accounts: []genesis.Actor{
+			{
+				Type:    genesis.TAccount,
+				Balance: types.FromFil(20_000_000),
+				Meta:    (&genesis.AccountMeta{Owner: mk1}).ActorMeta(),
+			},
+			{
+				Type:    genesis.TAccount,
+				Balance: types.FromFil(20_000_000),
+				Meta:    (&genesis.AccountMeta{Owner: mk2}).ActorMeta(),
+			},
+			{
+				Type:    genesis.TAccount,
+				Balance: types.FromFil(50000),
+				Meta:    (&genesis.AccountMeta{Owner: banker}).ActorMeta(),
+			},
 		},
-		MinerAddrs: []address.Address{maddr1, maddr2},
+		Miners: []genesis.Miner{
+			*genm1,
+			*genm2,
+		},
+		VerifregRootKey:  DefaultVerifregRootkeyActor,
+		RemainderAccount: DefaultRemainderAccountActor,
+		NetworkName:      "",
+		Timestamp:        uint64(build.Clock.Now().Add(-500 * time.Duration(build.BlockDelaySecs) * time.Second).Unix()),
 	}
 
-	genb, err := MakeGenesisBlock(bs, map[address.Address]types.BigInt{
-		mk1:    types.FromFil(40000),
-		mk2:    types.FromFil(40000),
-		banker: types.FromFil(50000),
-	}, minercfg, 100000)
+	genb, err := genesis2.MakeGenesisBlock(context.TODO(), bs, sys, tpl)
 	if err != nil {
 		return nil, xerrors.Errorf("make genesis block failed: %w", err)
 	}
 
-	cs := store.NewChainStore(bs, ds)
+	cs := store.NewChainStore(bs, ds, sys)
 
 	genfb := &types.FullBlock{Header: genb.Genesis}
 	gents := store.NewFullTipSet([]*types.FullBlock{genfb})
@@ -188,29 +242,35 @@ func NewGenerator() (*ChainGen, error) {
 		return nil, xerrors.Errorf("set genesis failed: %w", err)
 	}
 
-	if len(minercfg.MinerAddrs) == 0 {
-		return nil, xerrors.Errorf("MakeGenesisBlock failed to set miner address")
-	}
-
-	mgen := make(map[address.Address]ElectionPoStProver)
-	for _, m := range minercfg.MinerAddrs {
-		mgen[m] = &eppProvider{}
+	mgen := make(map[address.Address]WinningPoStProver)
+	for i := range tpl.Miners {
+		mgen[genesis2.MinerAddress(uint64(i))] = &wppProvider{}
 	}
 
 	sm := stmgr.NewStateManager(cs)
 
+	miners := []address.Address{maddr1, maddr2}
+
+	beac := beacon.Schedule{{Start: 0, Beacon: beacon.NewMockBeacon(time.Second)}}
+	//beac, err := drand.NewDrandBeacon(tpl.Timestamp, build.BlockDelaySecs)
+	//if err != nil {
+	//return nil, xerrors.Errorf("creating drand beacon: %w", err)
+	//}
+
 	gen := &ChainGen{
 		bs:           bs,
 		cs:           cs,
 		sm:           sm,
 		msgsPerBlock: msgsPerBlock,
 		genesis:      genb.Genesis,
+		beacon:       beac,
 		w:            w,
 
-		Miners:    minercfg.MinerAddrs,
-		eppProvs:  mgen,
-		banker:    banker,
-		receivers: receievers,
+		GetMessages: getRandomMessages,
+		Miners:      miners,
+		eppProvs:    mgen,
+		banker:      banker,
+		receivers:   receievers,
 
 		CurTipset: gents,
 
@@ -221,6 +281,22 @@ func NewGenerator() (*ChainGen, error) {
 	return gen, nil
 }
 
+func NewGenerator() (*ChainGen, error) {
+	return NewGeneratorWithSectors(1)
+}
+
+func (cg *ChainGen) StateManager() *stmgr.StateManager {
+	return cg.sm
+}
+
+func (cg *ChainGen) SetStateManager(sm *stmgr.StateManager) {
+	cg.sm = sm
+}
+
+func (cg *ChainGen) ChainStore() *store.ChainStore {
+	return cg.cs
+}
+
 func (cg *ChainGen) Genesis() *types.BlockHeader {
 	return cg.genesis
 }
@@ -232,46 +308,77 @@ func (cg *ChainGen) GenesisCar() ([]byte, error) {
 
 	out := new(bytes.Buffer)
 
-	if err := car.WriteCar(context.TODO(), dserv, []cid.Cid{cg.Genesis().Cid()}, out); err != nil {
+	if err := car.WriteCarWithWalker(context.TODO(), dserv, []cid.Cid{cg.Genesis().Cid()}, out, CarWalkFunc); err != nil {
 		return nil, xerrors.Errorf("genesis car write car failed: %w", err)
 	}
 
 	return out.Bytes(), nil
 }
 
-func (cg *ChainGen) nextBlockProof(ctx context.Context, pts *types.TipSet, m address.Address, round int64) (*types.EPostProof, *types.Ticket, error) {
+func CarWalkFunc(nd format.Node) (out []*format.Link, err error) {
+	for _, link := range nd.Links() {
+		pref := link.Cid.Prefix()
+		if pref.Codec == cid.FilCommitmentSealed || pref.Codec == cid.FilCommitmentUnsealed {
+			continue
+		}
+		out = append(out, link)
+	}
 
-	lastTicket := pts.MinTicket()
+	return out, nil
+}
+
+func (cg *ChainGen) nextBlockProof(ctx context.Context, pts *types.TipSet, m address.Address, round abi.ChainEpoch) ([]types.BeaconEntry, *types.ElectionProof, *types.Ticket, error) {
+	mc := &mca{w: cg.w, sm: cg.sm, pv: ffiwrapper.ProofVerifier, bcn: cg.beacon}
+
+	mbi, err := mc.MinerGetBaseInfo(ctx, m, round, pts.Key())
+	if err != nil {
+		return nil, nil, nil, xerrors.Errorf("get miner base info: %w", err)
+	}
+
+	prev := mbi.PrevBeaconEntry
+
+	entries, err := beacon.BeaconEntriesForBlock(ctx, cg.beacon, round, pts.Height(), prev)
+	if err != nil {
+		return nil, nil, nil, xerrors.Errorf("get beacon entries for block: %w", err)
+	}
+
+	rbase := prev
+	if len(entries) > 0 {
+		rbase = entries[len(entries)-1]
+	}
+
+	eproof, err := IsRoundWinner(ctx, pts, round, m, rbase, mbi, mc)
+	if err != nil {
+		return nil, nil, nil, xerrors.Errorf("checking round winner failed: %w", err)
+	}
+
+	buf := new(bytes.Buffer)
+	if err := m.MarshalCBOR(buf); err != nil {
+		return nil, nil, nil, xerrors.Errorf("failed to cbor marshal address: %w", err)
+	}
+
+	if round > build.UpgradeSmokeHeight {
+		buf.Write(pts.MinTicket().VRFProof)
+	}
+
+	ticketRand, err := store.DrawRandomness(rbase.Data, crypto.DomainSeparationTag_TicketProduction, round-build.TicketRandomnessLookback, buf.Bytes())
+	if err != nil {
+		return nil, nil, nil, err
+	}
 
 	st := pts.ParentState()
 
 	worker, err := stmgr.GetMinerWorkerRaw(ctx, cg.sm, st, m)
 	if err != nil {
-		return nil, nil, xerrors.Errorf("get miner worker: %w", err)
+		return nil, nil, nil, xerrors.Errorf("get miner worker: %w", err)
 	}
 
-	vrfout, err := ComputeVRF(ctx, cg.w.Sign, worker, m, DSepTicket, lastTicket.VRFProof)
+	vrfout, err := ComputeVRF(ctx, cg.w.Sign, worker, ticketRand)
 	if err != nil {
-		return nil, nil, xerrors.Errorf("compute VRF: %w", err)
+		return nil, nil, nil, xerrors.Errorf("compute VRF: %w", err)
 	}
 
-	tick := &types.Ticket{
-		VRFProof: vrfout,
-	}
-
-	eproofin, err := IsRoundWinner(ctx, pts, round, m, cg.eppProvs[m], &mca{w: cg.w, sm: cg.sm})
-	if err != nil {
-		return nil, nil, xerrors.Errorf("checking round winner failed: %w", err)
-	}
-	if eproofin == nil {
-		return nil, tick, nil
-	}
-	eproof, err := ComputeProof(ctx, cg.eppProvs[m], eproofin)
-	if err != nil {
-		return nil, nil, xerrors.Errorf("computing proof: %w", err)
-	}
-
-	return eproof, tick, nil
+	return entries, eproof, &types.Ticket{VRFProof: vrfout}, nil
 }
 
 type MinedTipSet struct {
@@ -289,23 +396,50 @@ func (cg *ChainGen) NextTipSet() (*MinedTipSet, error) {
 	return mts, nil
 }
 
-func (cg *ChainGen) NextTipSetFromMiners(base *types.TipSet, miners []address.Address) (*MinedTipSet, error) {
-	var blks []*types.FullBlock
+func (cg *ChainGen) SetWinningPoStProver(m address.Address, wpp WinningPoStProver) {
+	cg.eppProvs[m] = wpp
+}
 
-	msgs, err := cg.getRandomMessages()
+func (cg *ChainGen) NextTipSetFromMiners(base *types.TipSet, miners []address.Address) (*MinedTipSet, error) {
+	ms, err := cg.GetMessages(cg)
 	if err != nil {
 		return nil, xerrors.Errorf("get random messages: %w", err)
 	}
 
-	for round := int64(base.Height() + 1); len(blks) == 0; round++ {
-		for _, m := range miners {
-			proof, t, err := cg.nextBlockProof(context.TODO(), base, m, round)
+	msgs := make([][]*types.SignedMessage, len(miners))
+	for i := range msgs {
+		msgs[i] = ms
+	}
+
+	fts, err := cg.NextTipSetFromMinersWithMessages(base, miners, msgs)
+	if err != nil {
+		return nil, err
+	}
+
+	return &MinedTipSet{
+		TipSet:   fts,
+		Messages: ms,
+	}, nil
+}
+
+func (cg *ChainGen) NextTipSetFromMinersWithMessages(base *types.TipSet, miners []address.Address, msgs [][]*types.SignedMessage) (*store.FullTipSet, error) {
+	var blks []*types.FullBlock
+
+	for round := base.Height() + 1; len(blks) == 0; round++ {
+		for mi, m := range miners {
+			bvals, et, ticket, err := cg.nextBlockProof(context.TODO(), base, m, round)
 			if err != nil {
 				return nil, xerrors.Errorf("next block proof: %w", err)
 			}
 
-			if proof != nil {
-				fblk, err := cg.makeBlock(base, m, proof, t, uint64(round), msgs)
+			if et != nil {
+				// TODO: maybe think about passing in more real parameters to this?
+				wpost, err := cg.eppProvs[m].ComputeProof(context.TODO(), nil, nil)
+				if err != nil {
+					return nil, err
+				}
+
+				fblk, err := cg.makeBlock(base, m, ticket, et, bvals, round, wpost, msgs[mi])
 				if err != nil {
 					return nil, xerrors.Errorf("making a block for next tipset failed: %w", err)
 				}
@@ -319,24 +453,31 @@ func (cg *ChainGen) NextTipSetFromMiners(base *types.TipSet, miners []address.Ad
 		}
 	}
 
-	fts := store.NewFullTipSet(blks)
-
-	return &MinedTipSet{
-		TipSet:   fts,
-		Messages: msgs,
-	}, nil
+	return store.NewFullTipSet(blks), nil
 }
 
-func (cg *ChainGen) makeBlock(parents *types.TipSet, m address.Address, eproof *types.EPostProof, ticket *types.Ticket, height uint64, msgs []*types.SignedMessage) (*types.FullBlock, error) {
+func (cg *ChainGen) makeBlock(parents *types.TipSet, m address.Address, vrfticket *types.Ticket,
+	eticket *types.ElectionProof, bvals []types.BeaconEntry, height abi.ChainEpoch,
+	wpost []proof.PoStProof, msgs []*types.SignedMessage) (*types.FullBlock, error) {
 
 	var ts uint64
 	if cg.Timestamper != nil {
 		ts = cg.Timestamper(parents, height-parents.Height())
 	} else {
-		ts = parents.MinTimestamp() + ((height - parents.Height()) * build.BlockDelay)
+		ts = parents.MinTimestamp() + uint64(height-parents.Height())*build.BlockDelaySecs
 	}
 
-	fblk, err := MinerCreateBlock(context.TODO(), cg.sm, cg.w, m, parents, ticket, eproof, msgs, height, ts)
+	fblk, err := MinerCreateBlock(context.TODO(), cg.sm, cg.w, &api.BlockTemplate{
+		Miner:            m,
+		Parents:          parents.Key(),
+		Ticket:           vrfticket,
+		Eproof:           eticket,
+		BeaconValues:     bvals,
+		Messages:         msgs,
+		Epoch:            height,
+		Timestamp:        ts,
+		WinningPoStProof: wpost,
+	})
 	if err != nil {
 		return nil, err
 	}
@@ -344,19 +485,31 @@ func (cg *ChainGen) makeBlock(parents *types.TipSet, m address.Address, eproof *
 	return fblk, err
 }
 
-// This function is awkward. It's used to deal with messages made when
+// ResyncBankerNonce is used for dealing with messages made when
 // simulating forks
 func (cg *ChainGen) ResyncBankerNonce(ts *types.TipSet) error {
-	act, err := cg.sm.GetActor(cg.banker, ts)
+	st, err := cg.sm.ParentState(ts)
+	if err != nil {
+		return err
+	}
+	act, err := st.GetActor(cg.banker)
 	if err != nil {
 		return err
 	}
-
 	cg.bankerNonce = act.Nonce
+
 	return nil
 }
 
-func (cg *ChainGen) getRandomMessages() ([]*types.SignedMessage, error) {
+func (cg *ChainGen) Banker() address.Address {
+	return cg.banker
+}
+
+func (cg *ChainGen) Wallet() *wallet.Wallet {
+	return cg.w
+}
+
+func getRandomMessages(cg *ChainGen) ([]*types.SignedMessage, error) {
 	msgs := make([]*types.SignedMessage, cg.msgsPerBlock)
 	for m := range msgs {
 		msg := types.Message{
@@ -369,8 +522,9 @@ func (cg *ChainGen) getRandomMessages() ([]*types.SignedMessage, error) {
 
 			Method: 0,
 
-			GasLimit: types.NewInt(10000),
-			GasPrice: types.NewInt(0),
+			GasLimit:   100_000_000,
+			GasFeeCap:  types.NewInt(0),
+			GasPremium: types.NewInt(0),
 		}
 
 		sig, err := cg.w.Sign(context.TODO(), cg.banker, msg.Cid().Bytes())
@@ -395,240 +549,137 @@ func (cg *ChainGen) YieldRepo() (repo.Repo, error) {
 }
 
 type MiningCheckAPI interface {
-	ChainGetRandomness(context.Context, types.TipSetKey, int64) ([]byte, error)
+	ChainGetRandomnessFromBeacon(ctx context.Context, tsk types.TipSetKey, personalization crypto.DomainSeparationTag, randEpoch abi.ChainEpoch, entropy []byte) (abi.Randomness, error)
+	ChainGetRandomnessFromTickets(ctx context.Context, tsk types.TipSetKey, personalization crypto.DomainSeparationTag, randEpoch abi.ChainEpoch, entropy []byte) (abi.Randomness, error)
 
-	StateMinerPower(context.Context, address.Address, *types.TipSet) (api.MinerPower, error)
+	MinerGetBaseInfo(context.Context, address.Address, abi.ChainEpoch, types.TipSetKey) (*api.MiningBaseInfo, error)
 
-	StateMinerWorker(context.Context, address.Address, *types.TipSet) (address.Address, error)
-
-	StateMinerSectorSize(context.Context, address.Address, *types.TipSet) (uint64, error)
-
-	StateMinerProvingSet(context.Context, address.Address, *types.TipSet) ([]*api.ChainSectorInfo, error)
-
-	WalletSign(context.Context, address.Address, []byte) (*types.Signature, error)
+	WalletSign(context.Context, address.Address, []byte) (*crypto.Signature, error)
 }
 
 type mca struct {
-	w  *wallet.Wallet
-	sm *stmgr.StateManager
+	w   *wallet.Wallet
+	sm  *stmgr.StateManager
+	pv  ffiwrapper.Verifier
+	bcn beacon.Schedule
 }
 
-func (mca mca) ChainGetRandomness(ctx context.Context, pts types.TipSetKey, lb int64) ([]byte, error) {
-	return mca.sm.ChainStore().GetRandomness(ctx, pts.Cids(), int64(lb))
-}
-
-func (mca mca) StateMinerPower(ctx context.Context, maddr address.Address, ts *types.TipSet) (api.MinerPower, error) {
-	mpow, tpow, err := stmgr.GetPower(ctx, mca.sm, ts, maddr)
+func (mca mca) ChainGetRandomnessFromTickets(ctx context.Context, tsk types.TipSetKey, personalization crypto.DomainSeparationTag, randEpoch abi.ChainEpoch, entropy []byte) (abi.Randomness, error) {
+	pts, err := mca.sm.ChainStore().LoadTipSet(tsk)
 	if err != nil {
-		return api.MinerPower{}, err
+		return nil, xerrors.Errorf("loading tipset key: %w", err)
 	}
 
-	return api.MinerPower{
-		MinerPower: mpow,
-		TotalPower: tpow,
-	}, err
+	return mca.sm.ChainStore().GetChainRandomness(ctx, pts.Cids(), personalization, randEpoch, entropy)
 }
 
-func (mca mca) StateMinerWorker(ctx context.Context, maddr address.Address, ts *types.TipSet) (address.Address, error) {
-	return stmgr.GetMinerWorkerRaw(ctx, mca.sm, ts.ParentState(), maddr)
+func (mca mca) ChainGetRandomnessFromBeacon(ctx context.Context, tsk types.TipSetKey, personalization crypto.DomainSeparationTag, randEpoch abi.ChainEpoch, entropy []byte) (abi.Randomness, error) {
+	pts, err := mca.sm.ChainStore().LoadTipSet(tsk)
+	if err != nil {
+		return nil, xerrors.Errorf("loading tipset key: %w", err)
+	}
+
+	return mca.sm.ChainStore().GetBeaconRandomness(ctx, pts.Cids(), personalization, randEpoch, entropy)
 }
 
-func (mca mca) StateMinerSectorSize(ctx context.Context, maddr address.Address, ts *types.TipSet) (uint64, error) {
-	return stmgr.GetMinerSectorSize(ctx, mca.sm, ts, maddr)
+func (mca mca) MinerGetBaseInfo(ctx context.Context, maddr address.Address, epoch abi.ChainEpoch, tsk types.TipSetKey) (*api.MiningBaseInfo, error) {
+	return stmgr.MinerGetBaseInfo(ctx, mca.sm, mca.bcn, tsk, epoch, maddr, mca.pv)
 }
 
-func (mca mca) StateMinerProvingSet(ctx context.Context, maddr address.Address, ts *types.TipSet) ([]*api.ChainSectorInfo, error) {
-	return stmgr.GetMinerProvingSet(ctx, mca.sm, ts, maddr)
-}
-
-func (mca mca) WalletSign(ctx context.Context, a address.Address, v []byte) (*types.Signature, error) {
+func (mca mca) WalletSign(ctx context.Context, a address.Address, v []byte) (*crypto.Signature, error) {
 	return mca.w.Sign(ctx, a, v)
 }
 
-type ElectionPoStProver interface {
-	GenerateCandidates(context.Context, sectorbuilder.SortedPublicSectorInfo, []byte) ([]sectorbuilder.EPostCandidate, error)
-	ComputeProof(context.Context, sectorbuilder.SortedPublicSectorInfo, []byte, []sectorbuilder.EPostCandidate) ([]byte, error)
+type WinningPoStProver interface {
+	GenerateCandidates(context.Context, abi.PoStRandomness, uint64) ([]uint64, error)
+	ComputeProof(context.Context, []proof.SectorInfo, abi.PoStRandomness) ([]proof.PoStProof, error)
 }
 
-type eppProvider struct{}
+type wppProvider struct{}
 
-func (epp *eppProvider) GenerateCandidates(ctx context.Context, _ sectorbuilder.SortedPublicSectorInfo, eprand []byte) ([]sectorbuilder.EPostCandidate, error) {
-	return []sectorbuilder.EPostCandidate{
-		{
-			SectorID:             1,
-			PartialTicket:        [32]byte{},
-			Ticket:               [32]byte{},
-			SectorChallengeIndex: 1,
-		},
-	}, nil
+func (wpp *wppProvider) GenerateCandidates(ctx context.Context, _ abi.PoStRandomness, _ uint64) ([]uint64, error) {
+	return []uint64{0}, nil
 }
 
-func (epp *eppProvider) ComputeProof(ctx context.Context, _ sectorbuilder.SortedPublicSectorInfo, eprand []byte, winners []sectorbuilder.EPostCandidate) ([]byte, error) {
-
-	return []byte("valid proof"), nil
+func (wpp *wppProvider) ComputeProof(context.Context, []proof.SectorInfo, abi.PoStRandomness) ([]proof.PoStProof, error) {
+	return ValidWpostForTesting, nil
 }
 
-type ProofInput struct {
-	sectors sectorbuilder.SortedPublicSectorInfo
-	hvrf    []byte
-	winners []sectorbuilder.EPostCandidate
-	vrfout  []byte
-}
+func IsRoundWinner(ctx context.Context, ts *types.TipSet, round abi.ChainEpoch,
+	miner address.Address, brand types.BeaconEntry, mbi *api.MiningBaseInfo, a MiningCheckAPI) (*types.ElectionProof, error) {
 
-func IsRoundWinner(ctx context.Context, ts *types.TipSet, round int64, miner address.Address, epp ElectionPoStProver, a MiningCheckAPI) (*ProofInput, error) {
-	r, err := a.ChainGetRandomness(ctx, ts.Key(), round-build.EcRandomnessLookback)
-	if err != nil {
-		return nil, xerrors.Errorf("chain get randomness: %w", err)
+	buf := new(bytes.Buffer)
+	if err := miner.MarshalCBOR(buf); err != nil {
+		return nil, xerrors.Errorf("failed to cbor marshal address: %w", err)
 	}
 
-	mworker, err := a.StateMinerWorker(ctx, miner, ts)
+	electionRand, err := store.DrawRandomness(brand.Data, crypto.DomainSeparationTag_ElectionProofProduction, round, buf.Bytes())
 	if err != nil {
-		return nil, xerrors.Errorf("failed to get miner worker: %w", err)
+		return nil, xerrors.Errorf("failed to draw randomness: %w", err)
 	}
 
-	vrfout, err := ComputeVRF(ctx, a.WalletSign, mworker, miner, DSepElectionPost, r)
+	vrfout, err := ComputeVRF(ctx, a.WalletSign, mbi.WorkerKey, electionRand)
 	if err != nil {
 		return nil, xerrors.Errorf("failed to compute VRF: %w", err)
 	}
 
-	pset, err := a.StateMinerProvingSet(ctx, miner, ts)
-	if err != nil {
-		return nil, xerrors.Errorf("failed to load proving set for miner: %w", err)
-	}
-	if len(pset) == 0 {
+	ep := &types.ElectionProof{VRFProof: vrfout}
+	j := ep.ComputeWinCount(mbi.MinerPower, mbi.NetworkPower)
+	ep.WinCount = j
+	if j < 1 {
 		return nil, nil
 	}
 
-	var sinfos []ffi.PublicSectorInfo
-	for _, s := range pset {
-		var commRa [32]byte
-		copy(commRa[:], s.CommR)
-		sinfos = append(sinfos, ffi.PublicSectorInfo{
-			SectorID: s.SectorID,
-			CommR:    commRa,
-		})
-	}
-	sectors := sectorbuilder.NewSortedPublicSectorInfo(sinfos)
-
-	hvrf := sha256.Sum256(vrfout)
-	candidates, err := epp.GenerateCandidates(ctx, sectors, hvrf[:])
-	if err != nil {
-		return nil, xerrors.Errorf("failed to generate electionPoSt candidates: %w", err)
-	}
-
-	pow, err := a.StateMinerPower(ctx, miner, ts)
-	if err != nil {
-		return nil, xerrors.Errorf("failed to check power: %w", err)
-	}
-
-	ssize, err := a.StateMinerSectorSize(ctx, miner, ts)
-	if err != nil {
-		return nil, xerrors.Errorf("failed to look up miners sector size: %w", err)
-	}
-
-	var winners []sectorbuilder.EPostCandidate
-	for _, c := range candidates {
-		if types.IsTicketWinner(c.PartialTicket[:], ssize, uint64(len(sinfos)), pow.TotalPower) {
-			winners = append(winners, c)
-		}
-	}
-
-	// no winners, sad
-	if len(winners) == 0 {
-		return nil, nil
-	}
-
-	return &ProofInput{
-		sectors: sectors,
-		hvrf:    hvrf[:],
-		winners: winners,
-		vrfout:  vrfout,
-	}, nil
+	return ep, nil
 }
 
-func ComputeProof(ctx context.Context, epp ElectionPoStProver, pi *ProofInput) (*types.EPostProof, error) {
-	proof, err := epp.ComputeProof(ctx, pi.sectors, pi.hvrf, pi.winners)
-	if err != nil {
-		return nil, xerrors.Errorf("failed to compute snark for election proof: %w", err)
-	}
+type SignFunc func(context.Context, address.Address, []byte) (*crypto.Signature, error)
 
-	ept := types.EPostProof{
-		Proof:    proof,
-		PostRand: pi.vrfout,
-	}
-	for _, win := range pi.winners {
-		part := make([]byte, 32)
-		copy(part, win.PartialTicket[:])
-		ept.Candidates = append(ept.Candidates, types.EPostTicket{
-			Partial:        part,
-			SectorID:       win.SectorID,
-			ChallengeIndex: win.SectorChallengeIndex,
-		})
-	}
-
-	return &ept, nil
-}
-
-type SignFunc func(context.Context, address.Address, []byte) (*types.Signature, error)
-
-const (
-	DSepTicket       = 1
-	DSepElectionPost = 2
-)
-
-func hashVRFBase(personalization uint64, miner address.Address, input []byte) ([]byte, error) {
-	if miner.Protocol() != address.ID {
-		return nil, xerrors.Errorf("miner address for compute VRF must be an ID address")
-	}
-
-	var persbuf [8]byte
-	binary.LittleEndian.PutUint64(persbuf[:], personalization)
-
-	h := sha256.New()
-	h.Write(persbuf[:])
-	h.Write([]byte{0})
-	h.Write(input)
-	h.Write([]byte{0})
-	h.Write(miner.Bytes())
-
-	return h.Sum(nil), nil
-}
-
-func VerifyVRF(ctx context.Context, worker, miner address.Address, p uint64, input, vrfproof []byte) error {
+func VerifyVRF(ctx context.Context, worker address.Address, vrfBase, vrfproof []byte) error {
 	_, span := trace.StartSpan(ctx, "VerifyVRF")
 	defer span.End()
 
-	vrfBase, err := hashVRFBase(p, miner, input)
-	if err != nil {
-		return xerrors.Errorf("computing vrf base failed: %w", err)
-	}
-
-	sig := &types.Signature{
-		Type: types.KTBLS,
+	sig := &crypto.Signature{
+		Type: crypto.SigTypeBLS,
 		Data: vrfproof,
 	}
 
-	if err := sig.Verify(worker, vrfBase); err != nil {
+	if err := sigs.Verify(sig, worker, vrfBase); err != nil {
 		return xerrors.Errorf("vrf was invalid: %w", err)
 	}
 
 	return nil
 }
 
-func ComputeVRF(ctx context.Context, sign SignFunc, worker, miner address.Address, p uint64, input []byte) ([]byte, error) {
-	sigInput, err := hashVRFBase(p, miner, input)
-	if err != nil {
-		return nil, err
-	}
-
+func ComputeVRF(ctx context.Context, sign SignFunc, worker address.Address, sigInput []byte) ([]byte, error) {
 	sig, err := sign(ctx, worker, sigInput)
 	if err != nil {
 		return nil, err
 	}
 
-	if sig.Type != types.KTBLS {
+	if sig.Type != crypto.SigTypeBLS {
 		return nil, fmt.Errorf("miner worker address was not a BLS key")
 	}
 
 	return sig.Data, nil
 }
+
+type genFakeVerifier struct{}
+
+var _ ffiwrapper.Verifier = (*genFakeVerifier)(nil)
+
+func (m genFakeVerifier) VerifySeal(svi proof.SealVerifyInfo) (bool, error) {
+	return true, nil
+}
+
+func (m genFakeVerifier) VerifyWinningPoSt(ctx context.Context, info proof.WinningPoStVerifyInfo) (bool, error) {
+	panic("not supported")
+}
+
+func (m genFakeVerifier) VerifyWindowPoSt(ctx context.Context, info proof.WindowPoStVerifyInfo) (bool, error) {
+	panic("not supported")
+}
+
+func (m genFakeVerifier) GenerateWinningPoStSectorChallenge(ctx context.Context, proof abi.RegisteredPoStProof, id abi.ActorID, randomness abi.PoStRandomness, u uint64) ([]uint64, error) {
+	panic("not supported")
+}
diff --git a/chain/gen/gen_test.go b/chain/gen/gen_test.go
index 260259869..8c38328d0 100644
--- a/chain/gen/gen_test.go
+++ b/chain/gen/gen_test.go
@@ -3,18 +3,23 @@ package gen
 import (
 	"testing"
 
-	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/go-state-types/abi"
+
+	"github.com/filecoin-project/lotus/chain/actors/policy"
+	_ "github.com/filecoin-project/lotus/lib/sigs/bls"
+	_ "github.com/filecoin-project/lotus/lib/sigs/secp"
 )
 
 func init() {
-	build.SectorSizes = []uint64{1024}
-	build.MinimumMinerPower = 1024
+	policy.SetSupportedProofTypes(abi.RegisteredSealProof_StackedDrg2KiBV1)
+	policy.SetConsensusMinerMinPower(abi.NewStoragePower(2048))
+	policy.SetMinVerifiedDealSize(abi.NewStoragePower(256))
 }
 
-func testGeneration(t testing.TB, n int, msgs int) {
-	g, err := NewGenerator()
+func testGeneration(t testing.TB, n int, msgs int, sectors int) {
+	g, err := NewGeneratorWithSectors(sectors)
 	if err != nil {
-		t.Fatal(err)
+		t.Fatalf("%+v", err)
 	}
 
 	g.msgsPerBlock = msgs
@@ -22,30 +27,31 @@ func testGeneration(t testing.TB, n int, msgs int) {
 	for i := 0; i < n; i++ {
 		mts, err := g.NextTipSet()
 		if err != nil {
-			t.Fatalf("error at H:%d, %s", i, err)
+			t.Fatalf("error at H:%d, %+v", i, err)
 		}
 		_ = mts
 	}
 }
 
 func TestChainGeneration(t *testing.T) {
-	testGeneration(t, 10, 20)
+	t.Run("10-20-1", func(t *testing.T) { testGeneration(t, 10, 20, 1) })
+	t.Run("10-20-25", func(t *testing.T) { testGeneration(t, 10, 20, 25) })
 }
 
 func BenchmarkChainGeneration(b *testing.B) {
 	b.Run("0-messages", func(b *testing.B) {
-		testGeneration(b, b.N, 0)
+		testGeneration(b, b.N, 0, 1)
 	})
 
 	b.Run("10-messages", func(b *testing.B) {
-		testGeneration(b, b.N, 10)
+		testGeneration(b, b.N, 10, 1)
 	})
 
 	b.Run("100-messages", func(b *testing.B) {
-		testGeneration(b, b.N, 100)
+		testGeneration(b, b.N, 100, 1)
 	})
 
 	b.Run("1000-messages", func(b *testing.B) {
-		testGeneration(b, b.N, 1000)
+		testGeneration(b, b.N, 1000, 1)
 	})
 }
diff --git a/chain/gen/genesis/genblock.go b/chain/gen/genesis/genblock.go
new file mode 100644
index 000000000..f26659cdf
--- /dev/null
+++ b/chain/gen/genesis/genblock.go
@@ -0,0 +1,41 @@
+package genesis
+
+import (
+	"encoding/hex"
+
+	blocks "github.com/ipfs/go-block-format"
+	"github.com/ipfs/go-cid"
+	"github.com/multiformats/go-multihash"
+)
+
+const genesisMultihashString = "1220107d821c25dc0735200249df94a8bebc9c8e489744f86a4ca8919e81f19dcd72"
+const genesisBlockHex = "a5684461746574696d6573323031372d30352d30352030313a32373a3531674e6574776f726b6846696c65636f696e65546f6b656e6846696c65636f696e6c546f6b656e416d6f756e7473a36b546f74616c537570706c796d322c3030302c3030302c303030664d696e6572736d312c3430302c3030302c3030306c50726f746f636f6c4c616273a36b446576656c6f706d656e746b3330302c3030302c3030306b46756e6472616973696e676b3230302c3030302c3030306a466f756e646174696f6e6b3130302c3030302c303030674d657373616765784854686973206973207468652047656e6573697320426c6f636b206f66207468652046696c65636f696e20446563656e7472616c697a65642053746f72616765204e6574776f726b2e"
+
+var cidBuilder = cid.V1Builder{Codec: cid.DagCBOR, MhType: multihash.SHA2_256}
+
+func expectedCid() cid.Cid {
+	mh, err := multihash.FromHexString(genesisMultihashString)
+	if err != nil {
+		panic(err)
+	}
+	return cid.NewCidV1(cidBuilder.Codec, mh)
+}
+
+func getGenesisBlock() (blocks.Block, error) {
+	genesisBlockData, err := hex.DecodeString(genesisBlockHex)
+	if err != nil {
+		return nil, err
+	}
+
+	genesisCid, err := cidBuilder.Sum(genesisBlockData)
+	if err != nil {
+		return nil, err
+	}
+
+	block, err := blocks.NewBlockWithCid(genesisBlockData, genesisCid)
+	if err != nil {
+		return nil, err
+	}
+
+	return block, nil
+}
diff --git a/chain/gen/genesis/genesis.go b/chain/gen/genesis/genesis.go
new file mode 100644
index 000000000..039e284cd
--- /dev/null
+++ b/chain/gen/genesis/genesis.go
@@ -0,0 +1,580 @@
+package genesis
+
+import (
+	"context"
+	"crypto/rand"
+	"encoding/json"
+	"fmt"
+
+	"github.com/ipfs/go-cid"
+	"github.com/ipfs/go-datastore"
+	cbor "github.com/ipfs/go-ipld-cbor"
+	logging "github.com/ipfs/go-log/v2"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-address"
+
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/big"
+	"github.com/filecoin-project/go-state-types/crypto"
+	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
+	account0 "github.com/filecoin-project/specs-actors/actors/builtin/account"
+	multisig0 "github.com/filecoin-project/specs-actors/actors/builtin/multisig"
+	verifreg0 "github.com/filecoin-project/specs-actors/actors/builtin/verifreg"
+	adt0 "github.com/filecoin-project/specs-actors/actors/util/adt"
+
+	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/actors/builtin"
+	"github.com/filecoin-project/lotus/chain/state"
+	"github.com/filecoin-project/lotus/chain/store"
+	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/chain/vm"
+	"github.com/filecoin-project/lotus/genesis"
+	bstore "github.com/filecoin-project/lotus/lib/blockstore"
+	"github.com/filecoin-project/lotus/lib/sigs"
+)
+
+const AccountStart = 100
+const MinerStart = 1000
+const MaxAccounts = MinerStart - AccountStart
+
+var log = logging.Logger("genesis")
+
+type GenesisBootstrap struct {
+	Genesis *types.BlockHeader
+}
+
+/*
+From a list of parameters, create a genesis block / initial state
+
+The process:
+- Bootstrap state (MakeInitialStateTree)
+  - Create empty state
+  - Create system actor
+  - Make init actor
+    - Create accounts mappings
+    - Set NextID to MinerStart
+  - Setup Reward (1.4B fil)
+  - Setup Cron
+  - Create empty power actor
+  - Create empty market
+  - Create verified registry
+  - Setup burnt fund address
+  - Initialize account / msig balances
+- Instantiate early vm with genesis syscalls
+  - Create miners
+    - Each:
+      - power.CreateMiner, set msg value to PowerBalance
+      - market.AddFunds with correct value
+      - market.PublishDeals for related sectors
+    - Set network power in the power actor to what we'll have after genesis creation
+	- Recreate reward actor state with the right power
+    - For each precommitted sector
+      - Get deal weight
+      - Calculate QA Power
+      - Remove fake power from the power actor
+      - Calculate pledge
+      - Precommit
+      - Confirm valid
+
+Data Types:
+
+PreSeal :{
+  CommR    CID
+  CommD    CID
+  SectorID SectorNumber
+  Deal     market.DealProposal # Start at 0, self-deal!
+}
+
+Genesis: {
+	Accounts: [ # non-miner, non-singleton actors, max len = MaxAccounts
+		{
+			Type: "account" / "multisig",
+			Value: "attofil",
+			[Meta: {msig settings, account key..}]
+		},...
+	],
+	Miners: [
+		{
+			Owner, Worker Addr # ID
+			MarketBalance, PowerBalance TokenAmount
+			SectorSize uint64
+			PreSeals []PreSeal
+		},...
+	],
+}
+
+*/
+
+func MakeInitialStateTree(ctx context.Context, bs bstore.Blockstore, template genesis.Template) (*state.StateTree, map[address.Address]address.Address, error) {
+	// Create empty state tree
+
+	cst := cbor.NewCborStore(bs)
+	_, err := cst.Put(context.TODO(), []struct{}{})
+	if err != nil {
+		return nil, nil, xerrors.Errorf("putting empty object: %w", err)
+	}
+
+	state, err := state.NewStateTree(cst, builtin.Version0)
+	if err != nil {
+		return nil, nil, xerrors.Errorf("making new state tree: %w", err)
+	}
+
+	// Create system actor
+
+	sysact, err := SetupSystemActor(bs)
+	if err != nil {
+		return nil, nil, xerrors.Errorf("setup init actor: %w", err)
+	}
+	if err := state.SetActor(builtin0.SystemActorAddr, sysact); err != nil {
+		return nil, nil, xerrors.Errorf("set init actor: %w", err)
+	}
+
+	// Create init actor
+
+	idStart, initact, keyIDs, err := SetupInitActor(bs, template.NetworkName, template.Accounts, template.VerifregRootKey)
+	if err != nil {
+		return nil, nil, xerrors.Errorf("setup init actor: %w", err)
+	}
+	if err := state.SetActor(builtin0.InitActorAddr, initact); err != nil {
+		return nil, nil, xerrors.Errorf("set init actor: %w", err)
+	}
+
+	// Setup reward
+	// RewardActor's state is overrwritten by SetupStorageMiners
+	rewact, err := SetupRewardActor(bs, big.Zero())
+	if err != nil {
+		return nil, nil, xerrors.Errorf("setup init actor: %w", err)
+	}
+
+	err = state.SetActor(builtin0.RewardActorAddr, rewact)
+	if err != nil {
+		return nil, nil, xerrors.Errorf("set network account actor: %w", err)
+	}
+
+	// Setup cron
+	cronact, err := SetupCronActor(bs)
+	if err != nil {
+		return nil, nil, xerrors.Errorf("setup cron actor: %w", err)
+	}
+	if err := state.SetActor(builtin0.CronActorAddr, cronact); err != nil {
+		return nil, nil, xerrors.Errorf("set cron actor: %w", err)
+	}
+
+	// Create empty power actor
+	spact, err := SetupStoragePowerActor(bs)
+	if err != nil {
+		return nil, nil, xerrors.Errorf("setup storage market actor: %w", err)
+	}
+	if err := state.SetActor(builtin0.StoragePowerActorAddr, spact); err != nil {
+		return nil, nil, xerrors.Errorf("set storage market actor: %w", err)
+	}
+
+	// Create empty market actor
+	marketact, err := SetupStorageMarketActor(bs)
+	if err != nil {
+		return nil, nil, xerrors.Errorf("setup storage market actor: %w", err)
+	}
+	if err := state.SetActor(builtin0.StorageMarketActorAddr, marketact); err != nil {
+		return nil, nil, xerrors.Errorf("set market actor: %w", err)
+	}
+
+	// Create verified registry
+	verifact, err := SetupVerifiedRegistryActor(bs)
+	if err != nil {
+		return nil, nil, xerrors.Errorf("setup storage market actor: %w", err)
+	}
+	if err := state.SetActor(builtin0.VerifiedRegistryActorAddr, verifact); err != nil {
+		return nil, nil, xerrors.Errorf("set market actor: %w", err)
+	}
+
+	burntRoot, err := cst.Put(ctx, &account0.State{
+		Address: builtin0.BurntFundsActorAddr,
+	})
+	if err != nil {
+		return nil, nil, xerrors.Errorf("failed to setup burnt funds actor state: %w", err)
+	}
+
+	// Setup burnt-funds
+	err = state.SetActor(builtin0.BurntFundsActorAddr, &types.Actor{
+		Code:    builtin0.AccountActorCodeID,
+		Balance: types.NewInt(0),
+		Head:    burntRoot,
+	})
+	if err != nil {
+		return nil, nil, xerrors.Errorf("set burnt funds account actor: %w", err)
+	}
+
+	// Create accounts
+	for _, info := range template.Accounts {
+
+		switch info.Type {
+		case genesis.TAccount:
+			if err := createAccountActor(ctx, cst, state, info, keyIDs); err != nil {
+				return nil, nil, xerrors.Errorf("failed to create account actor: %w", err)
+			}
+
+		case genesis.TMultisig:
+
+			ida, err := address.NewIDAddress(uint64(idStart))
+			if err != nil {
+				return nil, nil, err
+			}
+			idStart++
+
+			if err := createMultisigAccount(ctx, bs, cst, state, ida, info, keyIDs); err != nil {
+				return nil, nil, err
+			}
+		default:
+			return nil, nil, xerrors.New("unsupported account type")
+		}
+
+	}
+
+	vregroot, err := address.NewIDAddress(80)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	if err = createMultisigAccount(ctx, bs, cst, state, vregroot, template.VerifregRootKey, keyIDs); err != nil {
+		return nil, nil, xerrors.Errorf("failed to set up verified registry signer: %w", err)
+	}
+
+	// Setup the first verifier as ID-address 81
+	// TODO: remove this
+	skBytes, err := sigs.Generate(crypto.SigTypeBLS)
+	if err != nil {
+		return nil, nil, xerrors.Errorf("creating random verifier secret key: %w", err)
+	}
+
+	verifierPk, err := sigs.ToPublic(crypto.SigTypeBLS, skBytes)
+	if err != nil {
+		return nil, nil, xerrors.Errorf("creating random verifier public key: %w", err)
+	}
+
+	verifierAd, err := address.NewBLSAddress(verifierPk)
+	if err != nil {
+		return nil, nil, xerrors.Errorf("creating random verifier address: %w", err)
+	}
+
+	verifierId, err := address.NewIDAddress(81)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	verifierState, err := cst.Put(ctx, &account0.State{Address: verifierAd})
+	if err != nil {
+		return nil, nil, err
+	}
+
+	err = state.SetActor(verifierId, &types.Actor{
+		Code:    builtin0.AccountActorCodeID,
+		Balance: types.NewInt(0),
+		Head:    verifierState,
+	})
+	if err != nil {
+		return nil, nil, xerrors.Errorf("setting account from actmap: %w", err)
+	}
+
+	totalFilAllocated := big.Zero()
+
+	// flush as ForEach works on the HAMT
+	if _, err := state.Flush(ctx); err != nil {
+		return nil, nil, err
+	}
+	err = state.ForEach(func(addr address.Address, act *types.Actor) error {
+		totalFilAllocated = big.Add(totalFilAllocated, act.Balance)
+		return nil
+	})
+	if err != nil {
+		return nil, nil, xerrors.Errorf("summing account balances in state tree: %w", err)
+	}
+
+	totalFil := big.Mul(big.NewInt(int64(build.FilBase)), big.NewInt(int64(build.FilecoinPrecision)))
+	remainingFil := big.Sub(totalFil, totalFilAllocated)
+	if remainingFil.Sign() < 0 {
+		return nil, nil, xerrors.Errorf("somehow overallocated filecoin (allocated = %s)", types.FIL(totalFilAllocated))
+	}
+
+	remAccKey, err := address.NewIDAddress(90)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	template.RemainderAccount.Balance = remainingFil
+
+	if err := createMultisigAccount(ctx, bs, cst, state, remAccKey, template.RemainderAccount, keyIDs); err != nil {
+		return nil, nil, xerrors.Errorf("failed to set up remainder account: %w", err)
+	}
+
+	return state, keyIDs, nil
+}
+
+func createAccountActor(ctx context.Context, cst cbor.IpldStore, state *state.StateTree, info genesis.Actor, keyIDs map[address.Address]address.Address) error {
+	var ainfo genesis.AccountMeta
+	if err := json.Unmarshal(info.Meta, &ainfo); err != nil {
+		return xerrors.Errorf("unmarshaling account meta: %w", err)
+	}
+	st, err := cst.Put(ctx, &account0.State{Address: ainfo.Owner})
+	if err != nil {
+		return err
+	}
+
+	ida, ok := keyIDs[ainfo.Owner]
+	if !ok {
+		return fmt.Errorf("no registered ID for account actor: %s", ainfo.Owner)
+	}
+
+	err = state.SetActor(ida, &types.Actor{
+		Code:    builtin0.AccountActorCodeID,
+		Balance: info.Balance,
+		Head:    st,
+	})
+	if err != nil {
+		return xerrors.Errorf("setting account from actmap: %w", err)
+	}
+	return nil
+}
+
+func createMultisigAccount(ctx context.Context, bs bstore.Blockstore, cst cbor.IpldStore, state *state.StateTree, ida address.Address, info genesis.Actor, keyIDs map[address.Address]address.Address) error {
+	if info.Type != genesis.TMultisig {
+		return fmt.Errorf("can only call createMultisigAccount with multisig Actor info")
+	}
+	var ainfo genesis.MultisigMeta
+	if err := json.Unmarshal(info.Meta, &ainfo); err != nil {
+		return xerrors.Errorf("unmarshaling account meta: %w", err)
+	}
+	pending, err := adt0.MakeEmptyMap(adt0.WrapStore(ctx, cst)).Root()
+	if err != nil {
+		return xerrors.Errorf("failed to create empty map: %v", err)
+	}
+
+	var signers []address.Address
+
+	for _, e := range ainfo.Signers {
+		idAddress, ok := keyIDs[e]
+		if !ok {
+			return fmt.Errorf("no registered key ID for signer: %s", e)
+		}
+
+		// Check if actor already exists
+		_, err := state.GetActor(e)
+		if err == nil {
+			signers = append(signers, idAddress)
+			continue
+		}
+
+		st, err := cst.Put(ctx, &account0.State{Address: e})
+		if err != nil {
+			return err
+		}
+		err = state.SetActor(idAddress, &types.Actor{
+			Code:    builtin0.AccountActorCodeID,
+			Balance: types.NewInt(0),
+			Head:    st,
+		})
+		if err != nil {
+			return xerrors.Errorf("setting account from actmap: %w", err)
+		}
+		signers = append(signers, idAddress)
+	}
+
+	st, err := cst.Put(ctx, &multisig0.State{
+		Signers:               signers,
+		NumApprovalsThreshold: uint64(ainfo.Threshold),
+		StartEpoch:            abi.ChainEpoch(ainfo.VestingStart),
+		UnlockDuration:        abi.ChainEpoch(ainfo.VestingDuration),
+		PendingTxns:           pending,
+		InitialBalance:        info.Balance,
+	})
+	if err != nil {
+		return err
+	}
+	err = state.SetActor(ida, &types.Actor{
+		Code:    builtin0.MultisigActorCodeID,
+		Balance: info.Balance,
+		Head:    st,
+	})
+	if err != nil {
+		return xerrors.Errorf("setting account from actmap: %w", err)
+	}
+	return nil
+}
+
+func VerifyPreSealedData(ctx context.Context, cs *store.ChainStore, stateroot cid.Cid, template genesis.Template, keyIDs map[address.Address]address.Address) (cid.Cid, error) {
+	verifNeeds := make(map[address.Address]abi.PaddedPieceSize)
+	var sum abi.PaddedPieceSize
+
+	vmopt := vm.VMOpts{
+		StateBase:      stateroot,
+		Epoch:          0,
+		Rand:           &fakeRand{},
+		Bstore:         cs.Blockstore(),
+		Syscalls:       mkFakedSigSyscalls(cs.VMSys()),
+		CircSupplyCalc: nil,
+		NtwkVersion:    genesisNetworkVersion,
+		BaseFee:        types.NewInt(0),
+	}
+	vm, err := vm.NewVM(ctx, &vmopt)
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("failed to create NewVM: %w", err)
+	}
+
+	for mi, m := range template.Miners {
+		for si, s := range m.Sectors {
+			if s.Deal.Provider != m.ID {
+				return cid.Undef, xerrors.Errorf("Sector %d in miner %d in template had mismatch in provider and miner ID: %s != %s", si, mi, s.Deal.Provider, m.ID)
+			}
+
+			amt := s.Deal.PieceSize
+			verifNeeds[keyIDs[s.Deal.Client]] += amt
+			sum += amt
+		}
+	}
+
+	verifregRoot, err := address.NewIDAddress(80)
+	if err != nil {
+		return cid.Undef, err
+	}
+
+	verifier, err := address.NewIDAddress(81)
+	if err != nil {
+		return cid.Undef, err
+	}
+
+	_, err = doExecValue(ctx, vm, builtin0.VerifiedRegistryActorAddr, verifregRoot, types.NewInt(0), builtin0.MethodsVerifiedRegistry.AddVerifier, mustEnc(&verifreg0.AddVerifierParams{
+
+		Address:   verifier,
+		Allowance: abi.NewStoragePower(int64(sum)), // eh, close enough
+
+	}))
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("failed to create verifier: %w", err)
+	}
+
+	for c, amt := range verifNeeds {
+		_, err := doExecValue(ctx, vm, builtin0.VerifiedRegistryActorAddr, verifier, types.NewInt(0), builtin0.MethodsVerifiedRegistry.AddVerifiedClient, mustEnc(&verifreg0.AddVerifiedClientParams{
+			Address:   c,
+			Allowance: abi.NewStoragePower(int64(amt)),
+		}))
+		if err != nil {
+			return cid.Undef, xerrors.Errorf("failed to add verified client: %w", err)
+		}
+	}
+
+	st, err := vm.Flush(ctx)
+	if err != nil {
+		return cid.Cid{}, xerrors.Errorf("vm flush: %w", err)
+	}
+
+	return st, nil
+}
+
+func MakeGenesisBlock(ctx context.Context, bs bstore.Blockstore, sys vm.SyscallBuilder, template genesis.Template) (*GenesisBootstrap, error) {
+	st, keyIDs, err := MakeInitialStateTree(ctx, bs, template)
+	if err != nil {
+		return nil, xerrors.Errorf("make initial state tree failed: %w", err)
+	}
+
+	stateroot, err := st.Flush(ctx)
+	if err != nil {
+		return nil, xerrors.Errorf("flush state tree failed: %w", err)
+	}
+
+	// temp chainstore
+	cs := store.NewChainStore(bs, datastore.NewMapDatastore(), sys)
+
+	// Verify PreSealed Data
+	stateroot, err = VerifyPreSealedData(ctx, cs, stateroot, template, keyIDs)
+	if err != nil {
+		return nil, xerrors.Errorf("failed to verify presealed data: %w", err)
+	}
+
+	stateroot, err = SetupStorageMiners(ctx, cs, stateroot, template.Miners)
+	if err != nil {
+		return nil, xerrors.Errorf("setup miners failed: %w", err)
+	}
+
+	store := adt0.WrapStore(ctx, cbor.NewCborStore(bs))
+	emptyroot, err := adt0.MakeEmptyArray(store).Root()
+	if err != nil {
+		return nil, xerrors.Errorf("amt build failed: %w", err)
+	}
+
+	mm := &types.MsgMeta{
+		BlsMessages:   emptyroot,
+		SecpkMessages: emptyroot,
+	}
+	mmb, err := mm.ToStorageBlock()
+	if err != nil {
+		return nil, xerrors.Errorf("serializing msgmeta failed: %w", err)
+	}
+	if err := bs.Put(mmb); err != nil {
+		return nil, xerrors.Errorf("putting msgmeta block to blockstore: %w", err)
+	}
+
+	log.Infof("Empty Genesis root: %s", emptyroot)
+
+	tickBuf := make([]byte, 32)
+	_, _ = rand.Read(tickBuf)
+	genesisticket := &types.Ticket{
+		VRFProof: tickBuf,
+	}
+
+	filecoinGenesisCid, err := cid.Decode("bafyreiaqpwbbyjo4a42saasj36kkrpv4tsherf2e7bvezkert2a7dhonoi")
+	if err != nil {
+		return nil, xerrors.Errorf("failed to decode filecoin genesis block CID: %w", err)
+	}
+
+	if !expectedCid().Equals(filecoinGenesisCid) {
+		return nil, xerrors.Errorf("expectedCid != filecoinGenesisCid")
+	}
+
+	gblk, err := getGenesisBlock()
+	if err != nil {
+		return nil, xerrors.Errorf("failed to construct filecoin genesis block: %w", err)
+	}
+
+	if !filecoinGenesisCid.Equals(gblk.Cid()) {
+		return nil, xerrors.Errorf("filecoinGenesisCid != gblk.Cid")
+	}
+
+	if err := bs.Put(gblk); err != nil {
+		return nil, xerrors.Errorf("failed writing filecoin genesis block to blockstore: %w", err)
+	}
+
+	b := &types.BlockHeader{
+		Miner:                 builtin0.SystemActorAddr,
+		Ticket:                genesisticket,
+		Parents:               []cid.Cid{filecoinGenesisCid},
+		Height:                0,
+		ParentWeight:          types.NewInt(0),
+		ParentStateRoot:       stateroot,
+		Messages:              mmb.Cid(),
+		ParentMessageReceipts: emptyroot,
+		BLSAggregate:          nil,
+		BlockSig:              nil,
+		Timestamp:             template.Timestamp,
+		ElectionProof:         new(types.ElectionProof),
+		BeaconEntries: []types.BeaconEntry{
+			{
+				Round: 0,
+				Data:  make([]byte, 32),
+			},
+		},
+		ParentBaseFee: abi.NewTokenAmount(build.InitialBaseFee),
+	}
+
+	sb, err := b.ToStorageBlock()
+	if err != nil {
+		return nil, xerrors.Errorf("serializing block header failed: %w", err)
+	}
+
+	if err := bs.Put(sb); err != nil {
+		return nil, xerrors.Errorf("putting header to blockstore: %w", err)
+	}
+
+	return &GenesisBootstrap{
+		Genesis: b,
+	}, nil
+}
diff --git a/chain/gen/genesis/miners.go b/chain/gen/genesis/miners.go
new file mode 100644
index 000000000..1023e5efa
--- /dev/null
+++ b/chain/gen/genesis/miners.go
@@ -0,0 +1,411 @@
+package genesis
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"math/rand"
+
+	market0 "github.com/filecoin-project/specs-actors/actors/builtin/market"
+
+	"github.com/filecoin-project/lotus/chain/actors/builtin/power"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/reward"
+
+	"github.com/filecoin-project/lotus/chain/actors/builtin/market"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
+
+	"github.com/ipfs/go-cid"
+	cbor "github.com/ipfs/go-ipld-cbor"
+	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/big"
+	"github.com/filecoin-project/go-state-types/crypto"
+	"github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper"
+	"github.com/filecoin-project/specs-actors/actors/builtin"
+	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
+	power0 "github.com/filecoin-project/specs-actors/actors/builtin/power"
+	reward0 "github.com/filecoin-project/specs-actors/actors/builtin/reward"
+	"github.com/filecoin-project/specs-actors/actors/runtime"
+
+	"github.com/filecoin-project/lotus/chain/state"
+	"github.com/filecoin-project/lotus/chain/store"
+	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/chain/vm"
+	"github.com/filecoin-project/lotus/genesis"
+)
+
+func MinerAddress(genesisIndex uint64) address.Address {
+	maddr, err := address.NewIDAddress(MinerStart + genesisIndex)
+	if err != nil {
+		panic(err)
+	}
+
+	return maddr
+}
+
+type fakedSigSyscalls struct {
+	runtime.Syscalls
+}
+
+func (fss *fakedSigSyscalls) VerifySignature(signature crypto.Signature, signer address.Address, plaintext []byte) error {
+	return nil
+}
+
+func mkFakedSigSyscalls(base vm.SyscallBuilder) vm.SyscallBuilder {
+	return func(ctx context.Context, cstate *state.StateTree, cst cbor.IpldStore) runtime.Syscalls {
+		return &fakedSigSyscalls{
+			base(ctx, cstate, cst),
+		}
+	}
+}
+
+func SetupStorageMiners(ctx context.Context, cs *store.ChainStore, sroot cid.Cid, miners []genesis.Miner) (cid.Cid, error) {
+	csc := func(context.Context, abi.ChainEpoch, *state.StateTree) (abi.TokenAmount, error) {
+		return big.Zero(), nil
+	}
+
+	vmopt := &vm.VMOpts{
+		StateBase:      sroot,
+		Epoch:          0,
+		Rand:           &fakeRand{},
+		Bstore:         cs.Blockstore(),
+		Syscalls:       mkFakedSigSyscalls(cs.VMSys()),
+		CircSupplyCalc: csc,
+		NtwkVersion:    genesisNetworkVersion,
+		BaseFee:        types.NewInt(0),
+	}
+
+	vm, err := vm.NewVM(ctx, vmopt)
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("failed to create NewVM: %w", err)
+	}
+
+	if len(miners) == 0 {
+		return cid.Undef, xerrors.New("no genesis miners")
+	}
+
+	minerInfos := make([]struct {
+		maddr address.Address
+
+		presealExp abi.ChainEpoch
+
+		dealIDs []abi.DealID
+	}, len(miners))
+
+	for i, m := range miners {
+		// Create miner through power actor
+		i := i
+		m := m
+
+		spt, err := ffiwrapper.SealProofTypeFromSectorSize(m.SectorSize)
+		if err != nil {
+			return cid.Undef, err
+		}
+
+		{
+			constructorParams := &power0.CreateMinerParams{
+				Owner:         m.Worker,
+				Worker:        m.Worker,
+				Peer:          []byte(m.PeerId),
+				SealProofType: spt,
+			}
+
+			params := mustEnc(constructorParams)
+			rval, err := doExecValue(ctx, vm, power.Address, m.Owner, m.PowerBalance, builtin.MethodsPower.CreateMiner, params)
+			if err != nil {
+				return cid.Undef, xerrors.Errorf("failed to create genesis miner: %w", err)
+			}
+
+			var ma power0.CreateMinerReturn
+			if err := ma.UnmarshalCBOR(bytes.NewReader(rval)); err != nil {
+				return cid.Undef, xerrors.Errorf("unmarshaling CreateMinerReturn: %w", err)
+			}
+
+			expma := MinerAddress(uint64(i))
+			if ma.IDAddress != expma {
+				return cid.Undef, xerrors.Errorf("miner assigned wrong address: %s != %s", ma.IDAddress, expma)
+			}
+			minerInfos[i].maddr = ma.IDAddress
+
+			// TODO: ActorUpgrade
+			err = vm.MutateState(ctx, minerInfos[i].maddr, func(cst cbor.IpldStore, st *miner0.State) error {
+				maxPeriods := miner0.MaxSectorExpirationExtension / miner0.WPoStProvingPeriod
+				minerInfos[i].presealExp = (maxPeriods-1)*miner0.WPoStProvingPeriod + st.ProvingPeriodStart - 1
+
+				return nil
+			})
+			if err != nil {
+				return cid.Undef, xerrors.Errorf("mutating state: %w", err)
+			}
+		}
+
+		// Add market funds
+
+		if m.MarketBalance.GreaterThan(big.Zero()) {
+			params := mustEnc(&minerInfos[i].maddr)
+			_, err := doExecValue(ctx, vm, market.Address, m.Worker, m.MarketBalance, builtin.MethodsMarket.AddBalance, params)
+			if err != nil {
+				return cid.Undef, xerrors.Errorf("failed to create genesis miner (add balance): %w", err)
+			}
+		}
+
+		// Publish preseal deals
+
+		{
+			publish := func(params *market.PublishStorageDealsParams) error {
+				fmt.Printf("publishing %d storage deals on miner %s with worker %s\n", len(params.Deals), params.Deals[0].Proposal.Provider, m.Worker)
+
+				ret, err := doExecValue(ctx, vm, market.Address, m.Worker, big.Zero(), builtin.MethodsMarket.PublishStorageDeals, mustEnc(params))
+				if err != nil {
+					return xerrors.Errorf("failed to create genesis miner (publish deals): %w", err)
+				}
+				var ids market.PublishStorageDealsReturn
+				if err := ids.UnmarshalCBOR(bytes.NewReader(ret)); err != nil {
+					return xerrors.Errorf("unmarsahling publishStorageDeals result: %w", err)
+				}
+
+				minerInfos[i].dealIDs = append(minerInfos[i].dealIDs, ids.IDs...)
+				return nil
+			}
+
+			params := &market.PublishStorageDealsParams{}
+			for _, preseal := range m.Sectors {
+				preseal.Deal.VerifiedDeal = true
+				preseal.Deal.EndEpoch = minerInfos[i].presealExp
+				params.Deals = append(params.Deals, market.ClientDealProposal{
+					Proposal:        preseal.Deal,
+					ClientSignature: crypto.Signature{Type: crypto.SigTypeBLS}, // TODO: do we want to sign these? Or do we want to fake signatures for genesis setup?
+				})
+
+				if len(params.Deals) == cbg.MaxLength {
+					if err := publish(params); err != nil {
+						return cid.Undef, err
+					}
+
+					params = &market.PublishStorageDealsParams{}
+				}
+			}
+
+			if len(params.Deals) > 0 {
+				if err := publish(params); err != nil {
+					return cid.Undef, err
+				}
+			}
+		}
+	}
+
+	// adjust total network power for equal pledge per sector
+	rawPow, qaPow := big.NewInt(0), big.NewInt(0)
+	{
+		for i, m := range miners {
+			for pi := range m.Sectors {
+				rawPow = types.BigAdd(rawPow, types.NewInt(uint64(m.SectorSize)))
+
+				dweight, err := dealWeight(ctx, vm, minerInfos[i].maddr, []abi.DealID{minerInfos[i].dealIDs[pi]}, 0, minerInfos[i].presealExp)
+				if err != nil {
+					return cid.Undef, xerrors.Errorf("getting deal weight: %w", err)
+				}
+
+				sectorWeight := miner0.QAPowerForWeight(m.SectorSize, minerInfos[i].presealExp, dweight.DealWeight, dweight.VerifiedDealWeight)
+
+				qaPow = types.BigAdd(qaPow, sectorWeight)
+			}
+		}
+
+		err = vm.MutateState(ctx, power.Address, func(cst cbor.IpldStore, st *power0.State) error {
+			st.TotalQualityAdjPower = qaPow
+			st.TotalRawBytePower = rawPow
+
+			st.ThisEpochQualityAdjPower = qaPow
+			st.ThisEpochRawBytePower = rawPow
+			return nil
+		})
+		if err != nil {
+			return cid.Undef, xerrors.Errorf("mutating state: %w", err)
+		}
+
+		err = vm.MutateState(ctx, reward.Address, func(sct cbor.IpldStore, st *reward0.State) error {
+			*st = *reward0.ConstructState(qaPow)
+			return nil
+		})
+		if err != nil {
+			return cid.Undef, xerrors.Errorf("mutating state: %w", err)
+		}
+	}
+
+	for i, m := range miners {
+		// Commit sectors
+		{
+			for pi, preseal := range m.Sectors {
+				params := &miner.SectorPreCommitInfo{
+					SealProof:     preseal.ProofType,
+					SectorNumber:  preseal.SectorID,
+					SealedCID:     preseal.CommR,
+					SealRandEpoch: -1,
+					DealIDs:       []abi.DealID{minerInfos[i].dealIDs[pi]},
+					Expiration:    minerInfos[i].presealExp, // TODO: Allow setting externally!
+				}
+
+				dweight, err := dealWeight(ctx, vm, minerInfos[i].maddr, params.DealIDs, 0, minerInfos[i].presealExp)
+				if err != nil {
+					return cid.Undef, xerrors.Errorf("getting deal weight: %w", err)
+				}
+
+				sectorWeight := miner0.QAPowerForWeight(m.SectorSize, minerInfos[i].presealExp, dweight.DealWeight, dweight.VerifiedDealWeight)
+
+				// we've added fake power for this sector above, remove it now
+				err = vm.MutateState(ctx, power.Address, func(cst cbor.IpldStore, st *power0.State) error {
+					st.TotalQualityAdjPower = types.BigSub(st.TotalQualityAdjPower, sectorWeight) //nolint:scopelint
+					st.TotalRawBytePower = types.BigSub(st.TotalRawBytePower, types.NewInt(uint64(m.SectorSize)))
+					return nil
+				})
+				if err != nil {
+					return cid.Undef, xerrors.Errorf("removing fake power: %w", err)
+				}
+
+				epochReward, err := currentEpochBlockReward(ctx, vm, minerInfos[i].maddr)
+				if err != nil {
+					return cid.Undef, xerrors.Errorf("getting current epoch reward: %w", err)
+				}
+
+				tpow, err := currentTotalPower(ctx, vm, minerInfos[i].maddr)
+				if err != nil {
+					return cid.Undef, xerrors.Errorf("getting current total power: %w", err)
+				}
+
+				pcd := miner0.PreCommitDepositForPower(epochReward.ThisEpochRewardSmoothed, tpow.QualityAdjPowerSmoothed, sectorWeight)
+
+				pledge := miner0.InitialPledgeForPower(
+					sectorWeight,
+					epochReward.ThisEpochBaselinePower,
+					tpow.PledgeCollateral,
+					epochReward.ThisEpochRewardSmoothed,
+					tpow.QualityAdjPowerSmoothed,
+					circSupply(ctx, vm, minerInfos[i].maddr),
+				)
+
+				pledge = big.Add(pcd, pledge)
+
+				fmt.Println(types.FIL(pledge))
+				_, err = doExecValue(ctx, vm, minerInfos[i].maddr, m.Worker, pledge, builtin.MethodsMiner.PreCommitSector, mustEnc(params))
+				if err != nil {
+					return cid.Undef, xerrors.Errorf("failed to confirm presealed sectors: %w", err)
+				}
+
+				// Commit one-by-one, otherwise pledge math tends to explode
+				confirmParams := &builtin.ConfirmSectorProofsParams{
+					Sectors: []abi.SectorNumber{preseal.SectorID},
+				}
+
+				_, err = doExecValue(ctx, vm, minerInfos[i].maddr, power.Address, big.Zero(), builtin.MethodsMiner.ConfirmSectorProofsValid, mustEnc(confirmParams))
+				if err != nil {
+					return cid.Undef, xerrors.Errorf("failed to confirm presealed sectors: %w", err)
+				}
+			}
+		}
+	}
+
+	// Sanity-check total network power
+	err = vm.MutateState(ctx, power.Address, func(cst cbor.IpldStore, st *power0.State) error {
+		if !st.TotalRawBytePower.Equals(rawPow) {
+			return xerrors.Errorf("st.TotalRawBytePower doesn't match previously calculated rawPow")
+		}
+
+		if !st.TotalQualityAdjPower.Equals(qaPow) {
+			return xerrors.Errorf("st.TotalQualityAdjPower doesn't match previously calculated qaPow")
+		}
+
+		return nil
+	})
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("mutating state: %w", err)
+	}
+
+	// TODO: Should we re-ConstructState for the reward actor using rawPow as currRealizedPower here?
+
+	c, err := vm.Flush(ctx)
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("flushing vm: %w", err)
+	}
+	return c, nil
+}
+
+// TODO: copied from actors test harness, deduplicate or remove from here
+type fakeRand struct{}
+
+func (fr *fakeRand) GetChainRandomness(ctx context.Context, personalization crypto.DomainSeparationTag, randEpoch abi.ChainEpoch, entropy []byte) ([]byte, error) {
+	out := make([]byte, 32)
+	_, _ = rand.New(rand.NewSource(int64(randEpoch * 1000))).Read(out) //nolint
+	return out, nil
+}
+
+func (fr *fakeRand) GetBeaconRandomness(ctx context.Context, personalization crypto.DomainSeparationTag, randEpoch abi.ChainEpoch, entropy []byte) ([]byte, error) {
+	out := make([]byte, 32)
+	_, _ = rand.New(rand.NewSource(int64(randEpoch))).Read(out) //nolint
+	return out, nil
+}
+
+func currentTotalPower(ctx context.Context, vm *vm.VM, maddr address.Address) (*power0.CurrentTotalPowerReturn, error) {
+	pwret, err := doExecValue(ctx, vm, power.Address, maddr, big.Zero(), builtin.MethodsPower.CurrentTotalPower, nil)
+	if err != nil {
+		return nil, err
+	}
+	var pwr power0.CurrentTotalPowerReturn
+	if err := pwr.UnmarshalCBOR(bytes.NewReader(pwret)); err != nil {
+		return nil, err
+	}
+
+	return &pwr, nil
+}
+
+func dealWeight(ctx context.Context, vm *vm.VM, maddr address.Address, dealIDs []abi.DealID, sectorStart, sectorExpiry abi.ChainEpoch) (market0.VerifyDealsForActivationReturn, error) {
+	params := &market.VerifyDealsForActivationParams{
+		DealIDs:      dealIDs,
+		SectorStart:  sectorStart,
+		SectorExpiry: sectorExpiry,
+	}
+
+	var dealWeights market0.VerifyDealsForActivationReturn
+	ret, err := doExecValue(ctx, vm,
+		market.Address,
+		maddr,
+		abi.NewTokenAmount(0),
+		builtin.MethodsMarket.VerifyDealsForActivation,
+		mustEnc(params),
+	)
+	if err != nil {
+		return market0.VerifyDealsForActivationReturn{}, err
+	}
+	if err := dealWeights.UnmarshalCBOR(bytes.NewReader(ret)); err != nil {
+		return market0.VerifyDealsForActivationReturn{}, err
+	}
+
+	return dealWeights, nil
+}
+
+func currentEpochBlockReward(ctx context.Context, vm *vm.VM, maddr address.Address) (*reward0.ThisEpochRewardReturn, error) {
+	rwret, err := doExecValue(ctx, vm, reward.Address, maddr, big.Zero(), builtin.MethodsReward.ThisEpochReward, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	var epochReward reward0.ThisEpochRewardReturn
+	if err := epochReward.UnmarshalCBOR(bytes.NewReader(rwret)); err != nil {
+		return nil, err
+	}
+
+	return &epochReward, nil
+}
+
+func circSupply(ctx context.Context, vmi *vm.VM, maddr address.Address) abi.TokenAmount {
+	unsafeVM := &vm.UnsafeVM{VM: vmi}
+	rt := unsafeVM.MakeRuntime(ctx, &types.Message{
+		GasLimit: 1_000_000_000,
+		From:     maddr,
+	}, maddr, 0, 0, 0)
+
+	return rt.TotalFilCircSupply()
+}
diff --git a/chain/gen/genesis/t00_system.go b/chain/gen/genesis/t00_system.go
new file mode 100644
index 000000000..6e6cc976a
--- /dev/null
+++ b/chain/gen/genesis/t00_system.go
@@ -0,0 +1,31 @@
+package genesis
+
+import (
+	"context"
+
+	"github.com/filecoin-project/specs-actors/actors/builtin/system"
+
+	"github.com/filecoin-project/specs-actors/actors/builtin"
+	cbor "github.com/ipfs/go-ipld-cbor"
+
+	"github.com/filecoin-project/lotus/chain/types"
+	bstore "github.com/filecoin-project/lotus/lib/blockstore"
+)
+
+func SetupSystemActor(bs bstore.Blockstore) (*types.Actor, error) {
+	var st system.State
+
+	cst := cbor.NewCborStore(bs)
+
+	statecid, err := cst.Put(context.TODO(), &st)
+	if err != nil {
+		return nil, err
+	}
+
+	act := &types.Actor{
+		Code: builtin.SystemActorCodeID,
+		Head: statecid,
+	}
+
+	return act, nil
+}
diff --git a/chain/gen/genesis/t01_init.go b/chain/gen/genesis/t01_init.go
new file mode 100644
index 000000000..667079a6d
--- /dev/null
+++ b/chain/gen/genesis/t01_init.go
@@ -0,0 +1,144 @@
+package genesis
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/abi"
+
+	"github.com/filecoin-project/specs-actors/actors/builtin"
+	"github.com/filecoin-project/specs-actors/actors/util/adt"
+
+	init_ "github.com/filecoin-project/specs-actors/actors/builtin/init"
+	cbor "github.com/ipfs/go-ipld-cbor"
+	cbg "github.com/whyrusleeping/cbor-gen"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/genesis"
+	bstore "github.com/filecoin-project/lotus/lib/blockstore"
+)
+
+func SetupInitActor(bs bstore.Blockstore, netname string, initialActors []genesis.Actor, rootVerifier genesis.Actor) (int64, *types.Actor, map[address.Address]address.Address, error) {
+	if len(initialActors) > MaxAccounts {
+		return 0, nil, nil, xerrors.New("too many initial actors")
+	}
+
+	var ias init_.State
+	ias.NextID = MinerStart
+	ias.NetworkName = netname
+
+	store := adt.WrapStore(context.TODO(), cbor.NewCborStore(bs))
+	amap := adt.MakeEmptyMap(store)
+
+	keyToId := map[address.Address]address.Address{}
+	counter := int64(AccountStart)
+
+	for _, a := range initialActors {
+		if a.Type == genesis.TMultisig {
+			var ainfo genesis.MultisigMeta
+			if err := json.Unmarshal(a.Meta, &ainfo); err != nil {
+				return 0, nil, nil, xerrors.Errorf("unmarshaling account meta: %w", err)
+			}
+			for _, e := range ainfo.Signers {
+
+				if _, ok := keyToId[e]; ok {
+					continue
+				}
+
+				fmt.Printf("init set %s t0%d\n", e, counter)
+
+				value := cbg.CborInt(counter)
+				if err := amap.Put(abi.AddrKey(e), &value); err != nil {
+					return 0, nil, nil, err
+				}
+				counter = counter + 1
+				var err error
+				keyToId[e], err = address.NewIDAddress(uint64(value))
+				if err != nil {
+					return 0, nil, nil, err
+				}
+
+			}
+			// Need to add actors for all multisigs too
+			continue
+		}
+
+		if a.Type != genesis.TAccount {
+			return 0, nil, nil, xerrors.Errorf("unsupported account type: %s", a.Type)
+		}
+
+		var ainfo genesis.AccountMeta
+		if err := json.Unmarshal(a.Meta, &ainfo); err != nil {
+			return 0, nil, nil, xerrors.Errorf("unmarshaling account meta: %w", err)
+		}
+
+		fmt.Printf("init set %s t0%d\n", ainfo.Owner, counter)
+
+		value := cbg.CborInt(counter)
+		if err := amap.Put(abi.AddrKey(ainfo.Owner), &value); err != nil {
+			return 0, nil, nil, err
+		}
+		counter = counter + 1
+
+		var err error
+		keyToId[ainfo.Owner], err = address.NewIDAddress(uint64(value))
+		if err != nil {
+			return 0, nil, nil, err
+		}
+	}
+
+	if rootVerifier.Type == genesis.TAccount {
+		var ainfo genesis.AccountMeta
+		if err := json.Unmarshal(rootVerifier.Meta, &ainfo); err != nil {
+			return 0, nil, nil, xerrors.Errorf("unmarshaling account meta: %w", err)
+		}
+		value := cbg.CborInt(80)
+		if err := amap.Put(abi.AddrKey(ainfo.Owner), &value); err != nil {
+			return 0, nil, nil, err
+		}
+	} else if rootVerifier.Type == genesis.TMultisig {
+		var ainfo genesis.MultisigMeta
+		if err := json.Unmarshal(rootVerifier.Meta, &ainfo); err != nil {
+			return 0, nil, nil, xerrors.Errorf("unmarshaling account meta: %w", err)
+		}
+		for _, e := range ainfo.Signers {
+			if _, ok := keyToId[e]; ok {
+				continue
+			}
+			fmt.Printf("init set %s t0%d\n", e, counter)
+
+			value := cbg.CborInt(counter)
+			if err := amap.Put(abi.AddrKey(e), &value); err != nil {
+				return 0, nil, nil, err
+			}
+			counter = counter + 1
+			var err error
+			keyToId[e], err = address.NewIDAddress(uint64(value))
+			if err != nil {
+				return 0, nil, nil, err
+			}
+
+		}
+	}
+
+	amapaddr, err := amap.Root()
+	if err != nil {
+		return 0, nil, nil, err
+	}
+	ias.AddressMap = amapaddr
+
+	statecid, err := store.Put(store.Context(), &ias)
+	if err != nil {
+		return 0, nil, nil, err
+	}
+
+	act := &types.Actor{
+		Code: builtin.InitActorCodeID,
+		Head: statecid,
+	}
+
+	return counter, act, keyToId, nil
+}
diff --git a/chain/gen/genesis/t02_reward.go b/chain/gen/genesis/t02_reward.go
new file mode 100644
index 000000000..92531051b
--- /dev/null
+++ b/chain/gen/genesis/t02_reward.go
@@ -0,0 +1,32 @@
+package genesis
+
+import (
+	"context"
+
+	"github.com/filecoin-project/go-state-types/big"
+
+	"github.com/filecoin-project/specs-actors/actors/builtin"
+	reward0 "github.com/filecoin-project/specs-actors/actors/builtin/reward"
+	cbor "github.com/ipfs/go-ipld-cbor"
+
+	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/types"
+	bstore "github.com/filecoin-project/lotus/lib/blockstore"
+)
+
+func SetupRewardActor(bs bstore.Blockstore, qaPower big.Int) (*types.Actor, error) {
+	cst := cbor.NewCborStore(bs)
+
+	st := reward0.ConstructState(qaPower)
+
+	hcid, err := cst.Put(context.TODO(), st)
+	if err != nil {
+		return nil, err
+	}
+
+	return &types.Actor{
+		Code:    builtin.RewardActorCodeID,
+		Balance: types.BigInt{Int: build.InitialRewardBalance},
+		Head:    hcid,
+	}, nil
+}
diff --git a/chain/gen/genesis/t03_cron.go b/chain/gen/genesis/t03_cron.go
new file mode 100644
index 000000000..cf2c0d7a7
--- /dev/null
+++ b/chain/gen/genesis/t03_cron.go
@@ -0,0 +1,29 @@
+package genesis
+
+import (
+	"context"
+
+	"github.com/filecoin-project/specs-actors/actors/builtin"
+	"github.com/filecoin-project/specs-actors/actors/builtin/cron"
+	cbor "github.com/ipfs/go-ipld-cbor"
+
+	"github.com/filecoin-project/lotus/chain/types"
+	bstore "github.com/filecoin-project/lotus/lib/blockstore"
+)
+
+func SetupCronActor(bs bstore.Blockstore) (*types.Actor, error) {
+	cst := cbor.NewCborStore(bs)
+	cas := cron.ConstructState(cron.BuiltInEntries())
+
+	stcid, err := cst.Put(context.TODO(), cas)
+	if err != nil {
+		return nil, err
+	}
+
+	return &types.Actor{
+		Code:    builtin.CronActorCodeID,
+		Head:    stcid,
+		Nonce:   0,
+		Balance: types.NewInt(0),
+	}, nil
+}
diff --git a/chain/gen/genesis/t04_power.go b/chain/gen/genesis/t04_power.go
new file mode 100644
index 000000000..2f1303ba4
--- /dev/null
+++ b/chain/gen/genesis/t04_power.go
@@ -0,0 +1,46 @@
+package genesis
+
+import (
+	"context"
+
+	"github.com/filecoin-project/specs-actors/actors/builtin"
+	"github.com/filecoin-project/specs-actors/actors/util/adt"
+
+	power0 "github.com/filecoin-project/specs-actors/actors/builtin/power"
+	cbor "github.com/ipfs/go-ipld-cbor"
+
+	"github.com/filecoin-project/lotus/chain/types"
+	bstore "github.com/filecoin-project/lotus/lib/blockstore"
+)
+
+func SetupStoragePowerActor(bs bstore.Blockstore) (*types.Actor, error) {
+	store := adt.WrapStore(context.TODO(), cbor.NewCborStore(bs))
+	emptyMap, err := adt.MakeEmptyMap(store).Root()
+	if err != nil {
+		return nil, err
+	}
+
+	multiMap, err := adt.AsMultimap(store, emptyMap)
+	if err != nil {
+		return nil, err
+	}
+
+	emptyMultiMap, err := multiMap.Root()
+	if err != nil {
+		return nil, err
+	}
+
+	sms := power0.ConstructState(emptyMap, emptyMultiMap)
+
+	stcid, err := store.Put(store.Context(), sms)
+	if err != nil {
+		return nil, err
+	}
+
+	return &types.Actor{
+		Code:    builtin.StoragePowerActorCodeID,
+		Head:    stcid,
+		Nonce:   0,
+		Balance: types.NewInt(0),
+	}, nil
+}
diff --git a/chain/gen/genesis/t05_market.go b/chain/gen/genesis/t05_market.go
new file mode 100644
index 000000000..615e8370b
--- /dev/null
+++ b/chain/gen/genesis/t05_market.go
@@ -0,0 +1,41 @@
+package genesis
+
+import (
+	"context"
+
+	"github.com/filecoin-project/specs-actors/actors/builtin"
+	"github.com/filecoin-project/specs-actors/actors/builtin/market"
+	"github.com/filecoin-project/specs-actors/actors/util/adt"
+	cbor "github.com/ipfs/go-ipld-cbor"
+
+	"github.com/filecoin-project/lotus/chain/types"
+	bstore "github.com/filecoin-project/lotus/lib/blockstore"
+)
+
+func SetupStorageMarketActor(bs bstore.Blockstore) (*types.Actor, error) {
+	store := adt.WrapStore(context.TODO(), cbor.NewCborStore(bs))
+
+	a, err := adt.MakeEmptyArray(store).Root()
+	if err != nil {
+		return nil, err
+	}
+	h, err := adt.MakeEmptyMap(store).Root()
+	if err != nil {
+		return nil, err
+	}
+
+	sms := market.ConstructState(a, h, h)
+
+	stcid, err := store.Put(store.Context(), sms)
+	if err != nil {
+		return nil, err
+	}
+
+	act := &types.Actor{
+		Code:    builtin.StorageMarketActorCodeID,
+		Head:    stcid,
+		Balance: types.NewInt(0),
+	}
+
+	return act, nil
+}
diff --git a/chain/gen/genesis/t06_vreg.go b/chain/gen/genesis/t06_vreg.go
new file mode 100644
index 000000000..1709b205f
--- /dev/null
+++ b/chain/gen/genesis/t06_vreg.go
@@ -0,0 +1,51 @@
+package genesis
+
+import (
+	"context"
+
+	"github.com/filecoin-project/go-address"
+	cbor "github.com/ipfs/go-ipld-cbor"
+
+	"github.com/filecoin-project/specs-actors/actors/builtin"
+	verifreg0 "github.com/filecoin-project/specs-actors/actors/builtin/verifreg"
+	"github.com/filecoin-project/specs-actors/actors/util/adt"
+
+	"github.com/filecoin-project/lotus/chain/types"
+	bstore "github.com/filecoin-project/lotus/lib/blockstore"
+)
+
+var RootVerifierID address.Address
+
+func init() {
+
+	idk, err := address.NewFromString("t080")
+	if err != nil {
+		panic(err)
+	}
+
+	RootVerifierID = idk
+}
+
+func SetupVerifiedRegistryActor(bs bstore.Blockstore) (*types.Actor, error) {
+	store := adt.WrapStore(context.TODO(), cbor.NewCborStore(bs))
+
+	h, err := adt.MakeEmptyMap(store).Root()
+	if err != nil {
+		return nil, err
+	}
+
+	sms := verifreg0.ConstructState(h, RootVerifierID)
+
+	stcid, err := store.Put(store.Context(), sms)
+	if err != nil {
+		return nil, err
+	}
+
+	act := &types.Actor{
+		Code:    builtin.VerifiedRegistryActorCodeID,
+		Head:    stcid,
+		Balance: types.NewInt(0),
+	}
+
+	return act, nil
+}
diff --git a/chain/gen/genesis/util.go b/chain/gen/genesis/util.go
new file mode 100644
index 000000000..bcafb007e
--- /dev/null
+++ b/chain/gen/genesis/util.go
@@ -0,0 +1,62 @@
+package genesis
+
+import (
+	"context"
+
+	"github.com/filecoin-project/go-state-types/network"
+	"github.com/filecoin-project/lotus/build"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/abi"
+	cbg "github.com/whyrusleeping/cbor-gen"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/lotus/chain/actors"
+	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/chain/vm"
+)
+
+func mustEnc(i cbg.CBORMarshaler) []byte {
+	enc, err := actors.SerializeParams(i)
+	if err != nil {
+		panic(err) // ok
+	}
+	return enc
+}
+
+func doExecValue(ctx context.Context, vm *vm.VM, to, from address.Address, value types.BigInt, method abi.MethodNum, params []byte) ([]byte, error) {
+	act, err := vm.StateTree().GetActor(from)
+	if err != nil {
+		return nil, xerrors.Errorf("doExec failed to get from actor (%s): %w", from, err)
+	}
+
+	ret, err := vm.ApplyImplicitMessage(ctx, &types.Message{
+		To:       to,
+		From:     from,
+		Method:   method,
+		Params:   params,
+		GasLimit: 1_000_000_000_000_000,
+		Value:    value,
+		Nonce:    act.Nonce,
+	})
+	if err != nil {
+		return nil, xerrors.Errorf("doExec apply message failed: %w", err)
+	}
+
+	if ret.ExitCode != 0 {
+		return nil, xerrors.Errorf("failed to call method: %w", ret.ActorErr)
+	}
+
+	return ret.Return, nil
+}
+
+var GenesisNetworkVersion = func() network.Version { // TODO: Get from build/
+	if build.UseNewestNetwork() { // TODO: Get from build/
+		return build.NewestNetworkVersion // TODO: Get from build/
+	} // TODO: Get from build/
+	return network.Version1 // TODO: Get from build/
+}() // TODO: Get from build/
+
+func genesisNetworkVersion(context.Context, abi.ChainEpoch) network.Version { // TODO: Get from build/
+	return GenesisNetworkVersion // TODO: Get from build/
+} // TODO: Get from build/
diff --git a/chain/gen/mining.go b/chain/gen/mining.go
index dec684ec2..dd867da48 100644
--- a/chain/gen/mining.go
+++ b/chain/gen/mining.go
@@ -3,39 +3,49 @@ package gen
 import (
 	"context"
 
-	bls "github.com/filecoin-project/filecoin-ffi"
-	amt "github.com/filecoin-project/go-amt-ipld"
+	"github.com/filecoin-project/go-state-types/crypto"
+	"github.com/filecoin-project/specs-actors/actors/util/adt"
 	cid "github.com/ipfs/go-cid"
-	hamt "github.com/ipfs/go-hamt-ipld"
+	cbor "github.com/ipfs/go-ipld-cbor"
 	cbg "github.com/whyrusleeping/cbor-gen"
 	"golang.org/x/xerrors"
 
-	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/chain/state"
 	"github.com/filecoin-project/lotus/chain/stmgr"
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/chain/vm"
 	"github.com/filecoin-project/lotus/chain/wallet"
+	"github.com/filecoin-project/lotus/lib/sigs/bls"
 )
 
-func MinerCreateBlock(ctx context.Context, sm *stmgr.StateManager, w *wallet.Wallet, miner address.Address, parents *types.TipSet, ticket *types.Ticket, proof *types.EPostProof, msgs []*types.SignedMessage, height, timestamp uint64) (*types.FullBlock, error) {
-	st, recpts, err := sm.TipSetState(ctx, parents)
+func MinerCreateBlock(ctx context.Context, sm *stmgr.StateManager, w *wallet.Wallet, bt *api.BlockTemplate) (*types.FullBlock, error) {
+
+	pts, err := sm.ChainStore().LoadTipSet(bt.Parents)
+	if err != nil {
+		return nil, xerrors.Errorf("failed to load parent tipset: %w", err)
+	}
+
+	st, recpts, err := sm.TipSetState(ctx, pts)
 	if err != nil {
 		return nil, xerrors.Errorf("failed to load tipset state: %w", err)
 	}
 
-	worker, err := stmgr.GetMinerWorkerRaw(ctx, sm, st, miner)
+	worker, err := stmgr.GetMinerWorkerRaw(ctx, sm, st, bt.Miner)
 	if err != nil {
 		return nil, xerrors.Errorf("failed to get miner worker: %w", err)
 	}
 
 	next := &types.BlockHeader{
-		Miner:                 miner,
-		Parents:               parents.Cids(),
-		Ticket:                ticket,
-		Height:                height,
-		Timestamp:             timestamp,
-		EPostProof:            *proof,
+		Miner:         bt.Miner,
+		Parents:       bt.Parents.Cids(),
+		Ticket:        bt.Ticket,
+		ElectionProof: bt.Eproof,
+
+		BeaconEntries:         bt.BeaconValues,
+		Height:                bt.Epoch,
+		Timestamp:             bt.Timestamp,
+		WinPoStProof:          bt.WinningPoStProof,
 		ParentStateRoot:       st,
 		ParentMessageReceipts: recpts,
 	}
@@ -44,9 +54,9 @@ func MinerCreateBlock(ctx context.Context, sm *stmgr.StateManager, w *wallet.Wal
 	var secpkMessages []*types.SignedMessage
 
 	var blsMsgCids, secpkMsgCids []cid.Cid
-	var blsSigs []types.Signature
-	for _, msg := range msgs {
-		if msg.Signature.TypeCode() == types.IKTBLS {
+	var blsSigs []crypto.Signature
+	for _, msg := range bt.Messages {
+		if msg.Signature.Type == crypto.SigTypeBLS {
 			blsSigs = append(blsSigs, msg.Signature)
 			blsMessages = append(blsMessages, &msg.Message)
 
@@ -68,17 +78,17 @@ func MinerCreateBlock(ctx context.Context, sm *stmgr.StateManager, w *wallet.Wal
 		}
 	}
 
-	bs := amt.WrapBlockstore(sm.ChainStore().Blockstore())
-	blsmsgroot, err := amt.FromArray(bs, toIfArr(blsMsgCids))
+	store := sm.ChainStore().Store(ctx)
+	blsmsgroot, err := toArray(store, blsMsgCids)
 	if err != nil {
 		return nil, xerrors.Errorf("building bls amt: %w", err)
 	}
-	secpkmsgroot, err := amt.FromArray(bs, toIfArr(secpkMsgCids))
+	secpkmsgroot, err := toArray(store, secpkMsgCids)
 	if err != nil {
 		return nil, xerrors.Errorf("building secpk amt: %w", err)
 	}
 
-	mmcid, err := bs.Put(&types.MsgMeta{
+	mmcid, err := store.Put(store.Context(), &types.MsgMeta{
 		BlsMessages:   blsmsgroot,
 		SecpkMessages: secpkmsgroot,
 	})
@@ -93,13 +103,19 @@ func MinerCreateBlock(ctx context.Context, sm *stmgr.StateManager, w *wallet.Wal
 	}
 
 	next.BLSAggregate = aggSig
-	pweight, err := sm.ChainStore().Weight(ctx, parents)
+	pweight, err := sm.ChainStore().Weight(ctx, pts)
 	if err != nil {
 		return nil, err
 	}
 	next.ParentWeight = pweight
 
-	cst := hamt.CSTFromBstore(sm.ChainStore().Blockstore())
+	baseFee, err := sm.ChainStore().ComputeBaseFee(ctx, pts)
+	if err != nil {
+		return nil, xerrors.Errorf("computing base fee: %w", err)
+	}
+	next.ParentBaseFee = baseFee
+
+	cst := cbor.NewCborStore(sm.ChainStore().Blockstore())
 	tree, err := state.LoadStateTree(cst, st)
 	if err != nil {
 		return nil, xerrors.Errorf("failed to load state tree: %w", err)
@@ -131,26 +147,46 @@ func MinerCreateBlock(ctx context.Context, sm *stmgr.StateManager, w *wallet.Wal
 	return fullBlock, nil
 }
 
-func aggregateSignatures(sigs []types.Signature) (types.Signature, error) {
-	var blsSigs []bls.Signature
-	for _, s := range sigs {
-		var bsig bls.Signature
-		copy(bsig[:], s.Data)
-		blsSigs = append(blsSigs, bsig)
+func aggregateSignatures(sigs []crypto.Signature) (*crypto.Signature, error) {
+	sigsS := make([][]byte, len(sigs))
+	for i := 0; i < len(sigs); i++ {
+		sigsS[i] = sigs[i].Data
 	}
 
-	aggSig := bls.Aggregate(blsSigs)
-	return types.Signature{
-		Type: types.KTBLS,
-		Data: aggSig[:],
+	aggregator := new(bls.AggregateSignature).AggregateCompressed(sigsS)
+	if aggregator == nil {
+		if len(sigs) > 0 {
+			return nil, xerrors.Errorf("bls.Aggregate returned nil with %d signatures", len(sigs))
+		}
+
+		// Note: for blst this condition should not happen - nil should not
+		// be returned
+		return &crypto.Signature{
+			Type: crypto.SigTypeBLS,
+			Data: new(bls.Signature).Compress(),
+		}, nil
+	}
+	aggSigAff := aggregator.ToAffine()
+	if aggSigAff == nil {
+		return &crypto.Signature{
+			Type: crypto.SigTypeBLS,
+			Data: new(bls.Signature).Compress(),
+		}, nil
+	}
+	aggSig := aggSigAff.Compress()
+	return &crypto.Signature{
+		Type: crypto.SigTypeBLS,
+		Data: aggSig,
 	}, nil
 }
 
-func toIfArr(cids []cid.Cid) []cbg.CBORMarshaler {
-	out := make([]cbg.CBORMarshaler, 0, len(cids))
-	for _, c := range cids {
+func toArray(store adt.Store, cids []cid.Cid) (cid.Cid, error) {
+	arr := adt.MakeEmptyArray(store)
+	for i, c := range cids {
 		oc := cbg.CborCid(c)
-		out = append(out, &oc)
+		if err := arr.Set(uint64(i), &oc); err != nil {
+			return cid.Undef, err
+		}
 	}
-	return out
+	return arr.Root()
 }
diff --git a/chain/gen/slashfilter/slashfilter.go b/chain/gen/slashfilter/slashfilter.go
new file mode 100644
index 000000000..fadd3dd27
--- /dev/null
+++ b/chain/gen/slashfilter/slashfilter.go
@@ -0,0 +1,112 @@
+package slashfilter
+
+import (
+	"fmt"
+
+	"golang.org/x/xerrors"
+
+	"github.com/ipfs/go-cid"
+	ds "github.com/ipfs/go-datastore"
+	"github.com/ipfs/go-datastore/namespace"
+
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/lotus/chain/types"
+)
+
+type SlashFilter struct {
+	byEpoch   ds.Datastore // double-fork mining faults, parent-grinding fault
+	byParents ds.Datastore // time-offset mining faults
+}
+
+func New(dstore ds.Batching) *SlashFilter {
+	return &SlashFilter{
+		byEpoch:   namespace.Wrap(dstore, ds.NewKey("/slashfilter/epoch")),
+		byParents: namespace.Wrap(dstore, ds.NewKey("/slashfilter/parents")),
+	}
+}
+
+func (f *SlashFilter) MinedBlock(bh *types.BlockHeader, parentEpoch abi.ChainEpoch) error {
+	epochKey := ds.NewKey(fmt.Sprintf("/%s/%d", bh.Miner, bh.Height))
+	{
+		// double-fork mining (2 blocks at one epoch)
+		if err := checkFault(f.byEpoch, epochKey, bh, "double-fork mining faults"); err != nil {
+			return err
+		}
+	}
+
+	parentsKey := ds.NewKey(fmt.Sprintf("/%s/%x", bh.Miner, types.NewTipSetKey(bh.Parents...).Bytes()))
+	{
+		// time-offset mining faults (2 blocks with the same parents)
+		if err := checkFault(f.byParents, parentsKey, bh, "time-offset mining faults"); err != nil {
+			return err
+		}
+	}
+
+	{
+		// parent-grinding fault (didn't mine on top of our own block)
+
+		// First check if we have mined a block on the parent epoch
+		parentEpochKey := ds.NewKey(fmt.Sprintf("/%s/%d", bh.Miner, parentEpoch))
+		have, err := f.byEpoch.Has(parentEpochKey)
+		if err != nil {
+			return err
+		}
+
+		if have {
+			// If we had, make sure it's in our parent tipset
+			cidb, err := f.byEpoch.Get(parentEpochKey)
+			if err != nil {
+				return xerrors.Errorf("getting other block cid: %w", err)
+			}
+
+			_, parent, err := cid.CidFromBytes(cidb)
+			if err != nil {
+				return err
+			}
+
+			var found bool
+			for _, c := range bh.Parents {
+				if c.Equals(parent) {
+					found = true
+				}
+			}
+
+			if !found {
+				return xerrors.Errorf("produced block would trigger 'parent-grinding fault' consensus fault; miner: %s; bh: %s, expected parent: %s", bh.Miner, bh.Cid(), parent)
+			}
+		}
+	}
+
+	if err := f.byParents.Put(parentsKey, bh.Cid().Bytes()); err != nil {
+		return xerrors.Errorf("putting byEpoch entry: %w", err)
+	}
+
+	if err := f.byEpoch.Put(epochKey, bh.Cid().Bytes()); err != nil {
+		return xerrors.Errorf("putting byEpoch entry: %w", err)
+	}
+
+	return nil
+}
+
+func checkFault(t ds.Datastore, key ds.Key, bh *types.BlockHeader, faultType string) error {
+	fault, err := t.Has(key)
+	if err != nil {
+		return err
+	}
+
+	if fault {
+		cidb, err := t.Get(key)
+		if err != nil {
+			return xerrors.Errorf("getting other block cid: %w", err)
+		}
+
+		_, other, err := cid.CidFromBytes(cidb)
+		if err != nil {
+			return err
+		}
+
+		return xerrors.Errorf("produced block would trigger '%s' consensus fault; miner: %s; bh: %s, other: %s", faultType, bh.Miner, bh.Cid(), other)
+	}
+
+	return nil
+}
diff --git a/chain/gen/utils.go b/chain/gen/utils.go
deleted file mode 100644
index 3f528075e..000000000
--- a/chain/gen/utils.go
+++ /dev/null
@@ -1,677 +0,0 @@
-package gen
-
-import (
-	"bytes"
-	"context"
-	"fmt"
-
-	amt "github.com/filecoin-project/go-amt-ipld"
-	"github.com/ipfs/go-cid"
-	"github.com/ipfs/go-datastore"
-	hamt "github.com/ipfs/go-hamt-ipld"
-	blockstore "github.com/ipfs/go-ipfs-blockstore"
-	bstore "github.com/ipfs/go-ipfs-blockstore"
-	peer "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/lotus/build"
-	actors "github.com/filecoin-project/lotus/chain/actors"
-	"github.com/filecoin-project/lotus/chain/state"
-	"github.com/filecoin-project/lotus/chain/store"
-	"github.com/filecoin-project/lotus/chain/types"
-	"github.com/filecoin-project/lotus/chain/vm"
-	"github.com/filecoin-project/lotus/genesis"
-)
-
-type GenesisBootstrap struct {
-	Genesis *types.BlockHeader
-}
-
-func SetupInitActor(bs bstore.Blockstore, addrs []address.Address) (*types.Actor, error) {
-	var ias actors.InitActorState
-	ias.NextID = 100
-
-	cst := hamt.CSTFromBstore(bs)
-	amap := hamt.NewNode(cst)
-
-	for i, a := range addrs {
-		if err := amap.Set(context.TODO(), string(a.Bytes()), 100+uint64(i)); err != nil {
-			return nil, err
-		}
-	}
-
-	ias.NextID += uint64(len(addrs))
-	if err := amap.Flush(context.TODO()); err != nil {
-		return nil, err
-	}
-	amapcid, err := cst.Put(context.TODO(), amap)
-	if err != nil {
-		return nil, err
-	}
-
-	ias.AddressMap = amapcid
-
-	statecid, err := cst.Put(context.TODO(), &ias)
-	if err != nil {
-		return nil, err
-	}
-
-	act := &types.Actor{
-		Code: actors.InitCodeCid,
-		Head: statecid,
-	}
-
-	return act, nil
-}
-
-func MakeInitialStateTree(bs bstore.Blockstore, actmap map[address.Address]types.BigInt) (*state.StateTree, error) {
-	cst := hamt.CSTFromBstore(bs)
-	state, err := state.NewStateTree(cst)
-	if err != nil {
-		return nil, xerrors.Errorf("making new state tree: %w", err)
-	}
-
-	emptyobject, err := cst.Put(context.TODO(), map[string]string{})
-	if err != nil {
-		return nil, xerrors.Errorf("failed putting empty object: %w", err)
-	}
-
-	var addrs []address.Address
-	for a := range actmap {
-		addrs = append(addrs, a)
-	}
-
-	initact, err := SetupInitActor(bs, addrs)
-	if err != nil {
-		return nil, xerrors.Errorf("setup init actor: %w", err)
-	}
-
-	if err := state.SetActor(actors.InitAddress, initact); err != nil {
-		return nil, xerrors.Errorf("set init actor: %w", err)
-	}
-
-	cronact, err := SetupCronActor(bs)
-	if err != nil {
-		return nil, xerrors.Errorf("setup cron actor: %w", err)
-	}
-
-	if err := state.SetActor(actors.CronAddress, cronact); err != nil {
-		return nil, xerrors.Errorf("set cron actor: %w", err)
-	}
-
-	spact, err := SetupStoragePowerActor(bs)
-	if err != nil {
-		return nil, xerrors.Errorf("setup storage market actor: %w", err)
-	}
-
-	if err := state.SetActor(actors.StoragePowerAddress, spact); err != nil {
-		return nil, xerrors.Errorf("set storage market actor: %w", err)
-	}
-
-	netAmt := types.FromFil(build.TotalFilecoin)
-	for _, amt := range actmap {
-		netAmt = types.BigSub(netAmt, amt)
-	}
-
-	err = state.SetActor(actors.NetworkAddress, &types.Actor{
-		Code:    actors.AccountCodeCid,
-		Balance: netAmt,
-		Head:    emptyobject,
-	})
-	if err != nil {
-		return nil, xerrors.Errorf("set network account actor: %w", err)
-	}
-
-	err = state.SetActor(actors.BurntFundsAddress, &types.Actor{
-		Code:    actors.AccountCodeCid,
-		Balance: types.NewInt(0),
-		Head:    emptyobject,
-	})
-	if err != nil {
-		return nil, xerrors.Errorf("set burnt funds account actor: %w", err)
-	}
-
-	for a, v := range actmap {
-		err = state.SetActor(a, &types.Actor{
-			Code:    actors.AccountCodeCid,
-			Balance: v,
-			Head:    emptyobject,
-		})
-		if err != nil {
-			return nil, xerrors.Errorf("setting account from actmap: %w", err)
-		}
-	}
-
-	return state, nil
-}
-
-func SetupCronActor(bs bstore.Blockstore) (*types.Actor, error) {
-	cst := hamt.CSTFromBstore(bs)
-	cas := &actors.CronActorState{}
-
-	stcid, err := cst.Put(context.TODO(), cas)
-	if err != nil {
-		return nil, err
-	}
-
-	return &types.Actor{
-		Code:    actors.CronCodeCid,
-		Head:    stcid,
-		Nonce:   0,
-		Balance: types.NewInt(0),
-	}, nil
-}
-
-func SetupStoragePowerActor(bs bstore.Blockstore) (*types.Actor, error) {
-	cst := hamt.CSTFromBstore(bs)
-	nd := hamt.NewNode(cst)
-	emptyhamt, err := cst.Put(context.TODO(), nd)
-	if err != nil {
-		return nil, err
-	}
-
-	blks := amt.WrapBlockstore(bs)
-	emptyamt, err := amt.FromArray(blks, nil)
-	if err != nil {
-		return nil, xerrors.Errorf("amt build failed: %w", err)
-	}
-
-	sms := &actors.StoragePowerState{
-		Miners:         emptyhamt,
-		ProvingBuckets: emptyamt,
-		TotalStorage:   types.NewInt(0),
-	}
-
-	stcid, err := cst.Put(context.TODO(), sms)
-	if err != nil {
-		return nil, err
-	}
-
-	return &types.Actor{
-		Code:    actors.StoragePowerCodeCid,
-		Head:    stcid,
-		Nonce:   0,
-		Balance: types.NewInt(0),
-	}, nil
-}
-
-func SetupStorageMarketActor(bs bstore.Blockstore, sroot cid.Cid, deals []actors.StorageDealProposal) (cid.Cid, error) {
-	cst := hamt.CSTFromBstore(bs)
-	nd := hamt.NewNode(cst)
-	emptyHAMT, err := cst.Put(context.TODO(), nd)
-	if err != nil {
-		return cid.Undef, err
-	}
-
-	blks := amt.WrapBlockstore(bs)
-
-	cdeals := make([]cbg.CBORMarshaler, len(deals))
-	for i, deal := range deals {
-		cdeals[i] = &actors.OnChainDeal{
-			PieceRef:             deal.PieceRef,
-			PieceSize:            deal.PieceSize,
-			Client:               deal.Client,
-			Provider:             deal.Provider,
-			ProposalExpiration:   deal.ProposalExpiration,
-			Duration:             deal.Duration,
-			StoragePricePerEpoch: deal.StoragePricePerEpoch,
-			StorageCollateral:    deal.StorageCollateral,
-			ActivationEpoch:      1,
-		}
-	}
-
-	dealAmt, err := amt.FromArray(blks, cdeals)
-	if err != nil {
-		return cid.Undef, xerrors.Errorf("amt build failed: %w", err)
-	}
-
-	sms := &actors.StorageMarketState{
-		Balances:   emptyHAMT,
-		Deals:      dealAmt,
-		NextDealID: uint64(len(deals)),
-	}
-
-	stcid, err := cst.Put(context.TODO(), sms)
-	if err != nil {
-		return cid.Undef, err
-	}
-
-	act := &types.Actor{
-		Code:    actors.StorageMarketCodeCid,
-		Head:    stcid,
-		Nonce:   0,
-		Balance: types.NewInt(0),
-	}
-
-	state, err := state.LoadStateTree(cst, sroot)
-	if err != nil {
-		return cid.Undef, xerrors.Errorf("making new state tree: %w", err)
-	}
-
-	if err := state.SetActor(actors.StorageMarketAddress, act); err != nil {
-		return cid.Undef, xerrors.Errorf("set storage market actor: %w", err)
-	}
-
-	return state.Flush()
-}
-
-type GenMinerCfg struct {
-	PreSeals map[string]genesis.GenesisMiner
-
-	// The addresses of the created miner, this is set by the genesis setup
-	MinerAddrs []address.Address
-
-	PeerIDs []peer.ID
-}
-
-func mustEnc(i cbg.CBORMarshaler) []byte {
-	enc, err := actors.SerializeParams(i)
-	if err != nil {
-		panic(err) // ok
-	}
-	return enc
-}
-
-func SetupStorageMiners(ctx context.Context, cs *store.ChainStore, sroot cid.Cid, gmcfg *GenMinerCfg) (cid.Cid, []actors.StorageDealProposal, error) {
-	vm, err := vm.NewVM(sroot, 0, nil, actors.NetworkAddress, cs.Blockstore())
-	if err != nil {
-		return cid.Undef, nil, xerrors.Errorf("failed to create NewVM: %w", err)
-	}
-
-	if len(gmcfg.MinerAddrs) == 0 {
-		return cid.Undef, nil, xerrors.New("no genesis miners")
-	}
-
-	if len(gmcfg.MinerAddrs) != len(gmcfg.PreSeals) {
-		return cid.Undef, nil, xerrors.Errorf("miner address list, and preseal count doesn't match (%d != %d)", len(gmcfg.MinerAddrs), len(gmcfg.PreSeals))
-	}
-
-	var deals []actors.StorageDealProposal
-
-	for i, maddr := range gmcfg.MinerAddrs {
-		ps, psok := gmcfg.PreSeals[maddr.String()]
-		if !psok {
-			return cid.Undef, nil, xerrors.Errorf("no preseal for miner %s", maddr)
-		}
-
-		minerParams := &actors.CreateStorageMinerParams{
-			Owner:      ps.Owner,
-			Worker:     ps.Worker,
-			SectorSize: ps.SectorSize,
-			PeerID:     gmcfg.PeerIDs[i], // TODO: grab from preseal too
-		}
-
-		params := mustEnc(minerParams)
-
-		// TODO: hardcoding 6500 here is a little fragile, it changes any
-		// time anyone changes the initial account allocations
-		rval, err := doExecValue(ctx, vm, actors.StoragePowerAddress, ps.Worker, types.FromFil(6500), actors.SPAMethods.CreateStorageMiner, params)
-		if err != nil {
-			return cid.Undef, nil, xerrors.Errorf("failed to create genesis miner: %w", err)
-		}
-
-		maddrret, err := address.NewFromBytes(rval)
-		if err != nil {
-			return cid.Undef, nil, err
-		}
-
-		_, err = vm.Flush(ctx)
-		if err != nil {
-			return cid.Undef, nil, err
-		}
-
-		cst := hamt.CSTFromBstore(cs.Blockstore())
-		if err := reassignMinerActorAddress(vm, cst, maddrret, maddr); err != nil {
-			return cid.Undef, nil, err
-		}
-
-		power := types.BigMul(types.NewInt(minerParams.SectorSize), types.NewInt(uint64(len(ps.Sectors))))
-
-		params = mustEnc(&actors.UpdateStorageParams{Delta: power})
-
-		_, err = doExec(ctx, vm, actors.StoragePowerAddress, maddr, actors.SPAMethods.UpdateStorage, params)
-		if err != nil {
-			return cid.Undef, nil, xerrors.Errorf("failed to update total storage: %w", err)
-		}
-
-		// we have to flush the vm here because it buffers stuff internally for perf reasons
-		if _, err := vm.Flush(ctx); err != nil {
-			return cid.Undef, nil, xerrors.Errorf("vm.Flush failed: %w", err)
-		}
-
-		st := vm.StateTree()
-		mact, err := st.GetActor(maddr)
-		if err != nil {
-			return cid.Undef, nil, xerrors.Errorf("get miner actor failed: %w", err)
-		}
-
-		var mstate actors.StorageMinerActorState
-		if err := cst.Get(ctx, mact.Head, &mstate); err != nil {
-			return cid.Undef, nil, xerrors.Errorf("getting miner actor state failed: %w", err)
-		}
-		mstate.Power = types.BigMul(types.NewInt(ps.SectorSize), types.NewInt(uint64(len(ps.Sectors))))
-
-		blks := amt.WrapBlockstore(cs.Blockstore())
-
-		for _, s := range ps.Sectors {
-			nssroot, err := actors.AddToSectorSet(ctx, blks, mstate.Sectors, s.SectorID, s.CommR[:], s.CommD[:])
-			if err != nil {
-				return cid.Undef, nil, xerrors.Errorf("failed to add fake sector to sector set: %w", err)
-			}
-			mstate.Sectors = nssroot
-			mstate.ProvingSet = nssroot
-
-			deals = append(deals, s.Deal)
-		}
-
-		nstate, err := cst.Put(ctx, &mstate)
-		if err != nil {
-			return cid.Undef, nil, err
-		}
-
-		mact.Head = nstate
-		if err := st.SetActor(maddr, mact); err != nil {
-			return cid.Undef, nil, err
-		}
-	}
-
-	c, err := vm.Flush(ctx)
-	return c, deals, err
-}
-
-func reassignMinerActorAddress(vm *vm.VM, cst *hamt.CborIpldStore, from, to address.Address) error {
-	if from == to {
-		return nil
-	}
-	act, err := vm.StateTree().GetActor(from)
-	if err != nil {
-		return xerrors.Errorf("reassign: failed to get 'from' actor: %w", err)
-	}
-
-	_, err = vm.StateTree().GetActor(to)
-	if err == nil {
-		return xerrors.Errorf("cannot reassign actor, target address taken")
-	}
-	if err := vm.StateTree().SetActor(to, act); err != nil {
-		return xerrors.Errorf("failed to reassign actor: %w", err)
-	}
-
-	if err := adjustStorageMarketTracking(vm, cst, from, to); err != nil {
-		return xerrors.Errorf("adjusting storage market tracking: %w", err)
-	}
-
-	// Now, adjust the tracking in the init actor
-	return initActorReassign(vm, cst, from, to)
-}
-
-func adjustStorageMarketTracking(vm *vm.VM, cst *hamt.CborIpldStore, from, to address.Address) error {
-	ctx := context.TODO()
-	act, err := vm.StateTree().GetActor(actors.StoragePowerAddress)
-	if err != nil {
-		return xerrors.Errorf("loading storage power actor: %w", err)
-	}
-
-	var spst actors.StoragePowerState
-	if err := cst.Get(ctx, act.Head, &spst); err != nil {
-		return xerrors.Errorf("loading storage power actor state: %w", err)
-	}
-
-	miners, err := hamt.LoadNode(ctx, cst, spst.Miners)
-	if err != nil {
-		return xerrors.Errorf("loading miner set: %w", err)
-	}
-
-	if err := miners.Delete(ctx, string(from.Bytes())); err != nil {
-		return xerrors.Errorf("deleting from spa set: %w", err)
-	}
-
-	if err := miners.Set(ctx, string(to.Bytes()), uint64(1)); err != nil {
-		return xerrors.Errorf("failed setting miner: %w", err)
-	}
-
-	if err := miners.Flush(ctx); err != nil {
-		return err
-	}
-
-	nminerscid, err := cst.Put(ctx, miners)
-	if err != nil {
-		return err
-	}
-	spst.Miners = nminerscid
-
-	nhead, err := cst.Put(ctx, &spst)
-	if err != nil {
-		return err
-	}
-
-	act.Head = nhead
-
-	return nil
-}
-
-func initActorReassign(vm *vm.VM, cst *hamt.CborIpldStore, from, to address.Address) error {
-	ctx := context.TODO()
-	initact, err := vm.StateTree().GetActor(actors.InitAddress)
-	if err != nil {
-		return xerrors.Errorf("couldnt get init actor: %w", err)
-	}
-
-	var st actors.InitActorState
-	if err := cst.Get(ctx, initact.Head, &st); err != nil {
-		return xerrors.Errorf("reassign loading init actor state: %w", err)
-	}
-
-	amap, err := hamt.LoadNode(ctx, cst, st.AddressMap)
-	if err != nil {
-		return xerrors.Errorf("failed to load init actor map: %w", err)
-	}
-
-	target, err := address.IDFromAddress(from)
-	if err != nil {
-		return xerrors.Errorf("failed to extract ID: %w", err)
-	}
-
-	var out string
-	halt := xerrors.Errorf("halt")
-	err = amap.ForEach(ctx, func(k string, v interface{}) error {
-		_, val, err := cbg.CborReadHeader(bytes.NewReader(v.(*cbg.Deferred).Raw))
-		if err != nil {
-			return xerrors.Errorf("parsing int in map failed: %w", err)
-		}
-
-		if val == target {
-			out = k
-			return halt
-		}
-		return nil
-	})
-
-	if err == nil {
-		return xerrors.Errorf("could not find from address in init ID map")
-	}
-	if !xerrors.Is(err, halt) {
-		return xerrors.Errorf("finding address in ID map failed: %w", err)
-	}
-
-	if err := amap.Delete(ctx, out); err != nil {
-		return xerrors.Errorf("deleting 'from' entry in amap: %w", err)
-	}
-
-	if err := amap.Set(ctx, out, target); err != nil {
-		return xerrors.Errorf("setting 'to' entry in amap: %w", err)
-	}
-
-	if err := amap.Flush(ctx); err != nil {
-		return xerrors.Errorf("failed to flush amap: %w", err)
-	}
-
-	ncid, err := cst.Put(ctx, amap)
-	if err != nil {
-		return err
-	}
-
-	st.AddressMap = ncid
-
-	nacthead, err := cst.Put(ctx, &st)
-	if err != nil {
-		return err
-	}
-
-	initact.Head = nacthead
-
-	return nil
-}
-
-func doExec(ctx context.Context, vm *vm.VM, to, from address.Address, method uint64, params []byte) ([]byte, error) {
-	return doExecValue(ctx, vm, to, from, types.NewInt(0), method, params)
-}
-
-func doExecValue(ctx context.Context, vm *vm.VM, to, from address.Address, value types.BigInt, method uint64, params []byte) ([]byte, error) {
-	act, err := vm.StateTree().GetActor(from)
-	if err != nil {
-		return nil, xerrors.Errorf("doExec failed to get from actor: %w", err)
-	}
-
-	ret, err := vm.ApplyMessage(context.TODO(), &types.Message{
-		To:       to,
-		From:     from,
-		Method:   method,
-		Params:   params,
-		GasLimit: types.NewInt(1000000),
-		GasPrice: types.NewInt(0),
-		Value:    value,
-		Nonce:    act.Nonce,
-	})
-	if err != nil {
-		return nil, xerrors.Errorf("doExec apply message failed: %w", err)
-	}
-
-	if ret.ExitCode != 0 {
-		return nil, fmt.Errorf("failed to call method: %s", ret.ActorErr)
-	}
-
-	return ret.Return, nil
-}
-
-func MakeGenesisBlock(bs bstore.Blockstore, balances map[address.Address]types.BigInt, gmcfg *GenMinerCfg, ts uint64) (*GenesisBootstrap, error) {
-	ctx := context.Background()
-
-	state, err := MakeInitialStateTree(bs, balances)
-	if err != nil {
-		return nil, xerrors.Errorf("make initial state tree failed: %w", err)
-	}
-
-	stateroot, err := state.Flush()
-	if err != nil {
-		return nil, xerrors.Errorf("flush state tree failed: %w", err)
-	}
-
-	// temp chainstore
-	cs := store.NewChainStore(bs, datastore.NewMapDatastore())
-	stateroot, deals, err := SetupStorageMiners(ctx, cs, stateroot, gmcfg)
-	if err != nil {
-		return nil, xerrors.Errorf("setup storage miners failed: %w", err)
-	}
-
-	stateroot, err = SetupStorageMarketActor(bs, stateroot, deals)
-	if err != nil {
-		return nil, xerrors.Errorf("setup storage market actor: %w", err)
-	}
-
-	stateroot, err = AdjustInitActorStartID(ctx, bs, stateroot, 1000)
-	if err != nil {
-		return nil, xerrors.Errorf("failed to adjust init actor start ID: %w", err)
-	}
-
-	blks := amt.WrapBlockstore(bs)
-
-	emptyroot, err := amt.FromArray(blks, nil)
-	if err != nil {
-		return nil, xerrors.Errorf("amt build failed: %w", err)
-	}
-
-	mm := &types.MsgMeta{
-		BlsMessages:   emptyroot,
-		SecpkMessages: emptyroot,
-	}
-	mmb, err := mm.ToStorageBlock()
-	if err != nil {
-		return nil, xerrors.Errorf("serializing msgmeta failed: %w", err)
-	}
-	if err := bs.Put(mmb); err != nil {
-		return nil, xerrors.Errorf("putting msgmeta block to blockstore: %w", err)
-	}
-
-	log.Infof("Empty Genesis root: %s", emptyroot)
-
-	genesisticket := &types.Ticket{
-		VRFProof: []byte("vrf proof0000000vrf proof0000000"),
-	}
-
-	b := &types.BlockHeader{
-		Miner:  actors.InitAddress,
-		Ticket: genesisticket,
-		EPostProof: types.EPostProof{
-			Proof:    []byte("not a real proof"),
-			PostRand: []byte("i guess this is kinda random"),
-		},
-		Parents:               []cid.Cid{},
-		Height:                0,
-		ParentWeight:          types.NewInt(0),
-		ParentStateRoot:       stateroot,
-		Messages:              mmb.Cid(),
-		ParentMessageReceipts: emptyroot,
-		BLSAggregate:          types.Signature{Type: types.KTBLS, Data: []byte("signatureeee")},
-		BlockSig:              &types.Signature{Type: types.KTBLS, Data: []byte("block signatureeee")},
-		Timestamp:             ts,
-	}
-
-	sb, err := b.ToStorageBlock()
-	if err != nil {
-		return nil, xerrors.Errorf("serializing block header failed: %w", err)
-	}
-
-	if err := bs.Put(sb); err != nil {
-		return nil, xerrors.Errorf("putting header to blockstore: %w", err)
-	}
-
-	return &GenesisBootstrap{
-		Genesis: b,
-	}, nil
-}
-
-func AdjustInitActorStartID(ctx context.Context, bs blockstore.Blockstore, stateroot cid.Cid, val uint64) (cid.Cid, error) {
-	cst := hamt.CSTFromBstore(bs)
-
-	tree, err := state.LoadStateTree(cst, stateroot)
-	if err != nil {
-		return cid.Undef, err
-	}
-
-	act, err := tree.GetActor(actors.InitAddress)
-	if err != nil {
-		return cid.Undef, err
-	}
-
-	var st actors.InitActorState
-	if err := cst.Get(ctx, act.Head, &st); err != nil {
-		return cid.Undef, err
-	}
-
-	st.NextID = val
-
-	nstate, err := cst.Put(ctx, &st)
-	if err != nil {
-		return cid.Undef, err
-	}
-
-	act.Head = nstate
-
-	if err := tree.SetActor(actors.InitAddress, act); err != nil {
-		return cid.Undef, err
-	}
-
-	return tree.Flush()
-}
diff --git a/chain/market/fundmgr.go b/chain/market/fundmgr.go
index 1500a78a5..aef3b98eb 100644
--- a/chain/market/fundmgr.go
+++ b/chain/market/fundmgr.go
@@ -4,76 +4,163 @@ import (
 	"context"
 	"sync"
 
-	"golang.org/x/xerrors"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/big"
+	"go.uber.org/fx"
+
+	"github.com/filecoin-project/specs-actors/actors/builtin"
+	"github.com/ipfs/go-cid"
+	logging "github.com/ipfs/go-log"
 
 	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/chain/actors"
-	"github.com/filecoin-project/lotus/chain/stmgr"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/market"
+	"github.com/filecoin-project/lotus/chain/events"
+	"github.com/filecoin-project/lotus/chain/events/state"
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/node/impl/full"
 )
 
-type FundMgr struct {
-	sm    *stmgr.StateManager
-	mpool full.MpoolAPI
+var log = logging.Logger("market_adapter")
 
-	lk        sync.Mutex
+// API is the dependencies need to run a fund manager
+type API struct {
+	fx.In
+
+	full.ChainAPI
+	full.StateAPI
+	full.MpoolAPI
+}
+
+// FundMgr monitors available balances and adds funds when EnsureAvailable is called
+type FundMgr struct {
+	api fundMgrAPI
+
+	lk        sync.RWMutex
 	available map[address.Address]types.BigInt
 }
 
-func NewFundMgr(sm *stmgr.StateManager, mpool full.MpoolAPI) *FundMgr {
-	return &FundMgr{
-		sm:    sm,
-		mpool: mpool,
+// StartFundManager creates a new fund manager and sets up event hooks to manage state changes
+func StartFundManager(lc fx.Lifecycle, api API) *FundMgr {
+	fm := newFundMgr(&api)
+	lc.Append(fx.Hook{
+		OnStart: func(ctx context.Context) error {
+			ev := events.NewEvents(ctx, &api)
+			preds := state.NewStatePredicates(&api)
+			dealDiffFn := preds.OnStorageMarketActorChanged(preds.OnBalanceChanged(preds.AvailableBalanceChangedForAddresses(fm.getAddresses)))
+			match := func(oldTs, newTs *types.TipSet) (bool, events.StateChange, error) {
+				return dealDiffFn(ctx, oldTs.Key(), newTs.Key())
+			}
+			return ev.StateChanged(fm.checkFunc, fm.stateChanged, fm.revert, 0, events.NoTimeout, match)
+		},
+	})
+	return fm
+}
 
+type fundMgrAPI interface {
+	StateMarketBalance(context.Context, address.Address, types.TipSetKey) (api.MarketBalance, error)
+	MpoolPushMessage(context.Context, *types.Message, *api.MessageSendSpec) (*types.SignedMessage, error)
+	StateLookupID(context.Context, address.Address, types.TipSetKey) (address.Address, error)
+}
+
+func newFundMgr(api fundMgrAPI) *FundMgr {
+	return &FundMgr{
+		api:       api,
 		available: map[address.Address]types.BigInt{},
 	}
 }
 
-func (fm *FundMgr) EnsureAvailable(ctx context.Context, addr address.Address, amt types.BigInt) error {
-	fm.lk.Lock()
-	avail, ok := fm.available[addr]
-	if !ok {
-		bal, err := fm.sm.MarketBalance(ctx, addr, nil)
-		if err != nil {
-			fm.lk.Unlock()
-			return err
-		}
+// checkFunc tells the events api to simply proceed (we always want to watch)
+func (fm *FundMgr) checkFunc(ts *types.TipSet) (done bool, more bool, err error) {
+	return false, true, nil
+}
 
-		avail = bal.Available
-	}
-
-	toAdd := types.NewInt(0)
-	avail = types.BigSub(avail, amt)
-	if avail.LessThan(types.NewInt(0)) {
-		// TODO: some rules around adding more to avoid doing stuff on-chain
-		//  all the time
-		toAdd = types.BigSub(toAdd, avail)
-		avail = types.NewInt(0)
-	}
-	fm.available[addr] = avail
-
-	fm.lk.Unlock()
-
-	smsg, err := fm.mpool.MpoolPushMessage(ctx, &types.Message{
-		To:       actors.StorageMarketAddress,
-		From:     addr,
-		Value:    toAdd,
-		GasPrice: types.NewInt(0),
-		GasLimit: types.NewInt(1000000),
-		Method:   actors.SMAMethods.AddBalance,
-	})
-	if err != nil {
-		return err
-	}
-
-	_, r, err := fm.sm.WaitForMessage(ctx, smsg.Cid())
-	if err != nil {
-		return err
-	}
-
-	if r.ExitCode != 0 {
-		return xerrors.Errorf("adding funds to storage miner market actor failed: exit %d", r.ExitCode)
-	}
+// revert handles reverts to balances
+func (fm *FundMgr) revert(ctx context.Context, ts *types.TipSet) error {
+	// TODO: Is it ok to just ignore this?
+	log.Warn("balance change reverted; TODO: actually handle this!")
 	return nil
 }
+
+// stateChanged handles balance changes monitored on the chain from one tipset to the next
+func (fm *FundMgr) stateChanged(ts *types.TipSet, ts2 *types.TipSet, states events.StateChange, h abi.ChainEpoch) (more bool, err error) {
+	changedBalances, ok := states.(state.ChangedBalances)
+	if !ok {
+		panic("Expected state.ChangedBalances")
+	}
+	// overwrite our in memory cache with new values from chain (chain is canonical)
+	fm.lk.Lock()
+	for addr, balanceChange := range changedBalances {
+		if fm.available[addr].Int != nil {
+			log.Infof("State balance change recorded, prev: %s, new: %s", fm.available[addr].String(), balanceChange.To.String())
+		}
+
+		fm.available[addr] = balanceChange.To
+	}
+	fm.lk.Unlock()
+	return true, nil
+}
+
+func (fm *FundMgr) getAddresses() []address.Address {
+	fm.lk.RLock()
+	defer fm.lk.RUnlock()
+	addrs := make([]address.Address, 0, len(fm.available))
+	for addr := range fm.available {
+		addrs = append(addrs, addr)
+	}
+	return addrs
+}
+
+// EnsureAvailable looks at the available balance in escrow for a given
+// address, and if less than the passed in amount, adds the difference
+func (fm *FundMgr) EnsureAvailable(ctx context.Context, addr, wallet address.Address, amt types.BigInt) (cid.Cid, error) {
+	idAddr, err := fm.api.StateLookupID(ctx, addr, types.EmptyTSK)
+	if err != nil {
+		return cid.Undef, err
+	}
+	fm.lk.Lock()
+	bal, err := fm.api.StateMarketBalance(ctx, addr, types.EmptyTSK)
+	if err != nil {
+		fm.lk.Unlock()
+		return cid.Undef, err
+	}
+
+	stateAvail := types.BigSub(bal.Escrow, bal.Locked)
+
+	avail, ok := fm.available[idAddr]
+	if !ok {
+		avail = stateAvail
+	}
+
+	toAdd := types.BigSub(amt, avail)
+	if toAdd.LessThan(types.NewInt(0)) {
+		toAdd = types.NewInt(0)
+	}
+	fm.available[idAddr] = big.Add(avail, toAdd)
+	fm.lk.Unlock()
+
+	log.Infof("Funds operation w/ Expected Balance: %s, In State: %s, Requested: %s, Adding: %s", avail.String(), stateAvail.String(), amt.String(), toAdd.String())
+
+	if toAdd.LessThanEqual(big.Zero()) {
+		return cid.Undef, nil
+	}
+
+	params, err := actors.SerializeParams(&addr)
+	if err != nil {
+		return cid.Undef, err
+	}
+
+	smsg, err := fm.api.MpoolPushMessage(ctx, &types.Message{
+		To:     market.Address,
+		From:   wallet,
+		Value:  toAdd,
+		Method: builtin.MethodsMarket.AddBalance,
+		Params: params,
+	}, nil)
+	if err != nil {
+		return cid.Undef, err
+	}
+
+	return smsg.Cid(), nil
+}
diff --git a/chain/market/fundmgr_test.go b/chain/market/fundmgr_test.go
new file mode 100644
index 000000000..b05db55d8
--- /dev/null
+++ b/chain/market/fundmgr_test.go
@@ -0,0 +1,189 @@
+package market
+
+import (
+	"context"
+	"errors"
+	"math/rand"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/crypto"
+	"github.com/filecoin-project/specs-actors/actors/builtin"
+	tutils "github.com/filecoin-project/specs-actors/support/testing"
+
+	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/chain/actors"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/market"
+	"github.com/filecoin-project/lotus/chain/types"
+)
+
+type fakeAPI struct {
+	returnedBalance    api.MarketBalance
+	returnedBalanceErr error
+	signature          crypto.Signature
+	receivedMessage    *types.Message
+	pushMessageErr     error
+	lookupIDErr        error
+}
+
+func (fapi *fakeAPI) StateLookupID(_ context.Context, addr address.Address, _ types.TipSetKey) (address.Address, error) {
+	return addr, fapi.lookupIDErr
+}
+func (fapi *fakeAPI) StateMarketBalance(context.Context, address.Address, types.TipSetKey) (api.MarketBalance, error) {
+	return fapi.returnedBalance, fapi.returnedBalanceErr
+}
+
+func (fapi *fakeAPI) MpoolPushMessage(ctx context.Context, msg *types.Message, spec *api.MessageSendSpec) (*types.SignedMessage, error) {
+	fapi.receivedMessage = msg
+	return &types.SignedMessage{
+		Message:   *msg,
+		Signature: fapi.signature,
+	}, fapi.pushMessageErr
+}
+
+func addFundsMsg(toAdd abi.TokenAmount, addr address.Address, wallet address.Address) *types.Message {
+	params, _ := actors.SerializeParams(&addr)
+	return &types.Message{
+		To:     market.Address,
+		From:   wallet,
+		Value:  toAdd,
+		Method: builtin.MethodsMarket.AddBalance,
+		Params: params,
+	}
+}
+
+type expectedResult struct {
+	addAmt    abi.TokenAmount
+	shouldAdd bool
+	err       error
+}
+
+func TestAddFunds(t *testing.T) {
+	ctx := context.Background()
+	testCases := map[string]struct {
+		returnedBalanceErr error
+		returnedBalance    api.MarketBalance
+		addAmounts         []abi.TokenAmount
+		pushMessageErr     error
+		expectedResults    []expectedResult
+		lookupIDErr        error
+	}{
+		"succeeds, trivial case": {
+			returnedBalance: api.MarketBalance{Escrow: abi.NewTokenAmount(0), Locked: abi.NewTokenAmount(0)},
+			addAmounts:      []abi.TokenAmount{abi.NewTokenAmount(100)},
+			expectedResults: []expectedResult{
+				{
+					addAmt:    abi.NewTokenAmount(100),
+					shouldAdd: true,
+					err:       nil,
+				},
+			},
+		},
+		"succeeds, money already present": {
+			returnedBalance: api.MarketBalance{Escrow: abi.NewTokenAmount(150), Locked: abi.NewTokenAmount(50)},
+			addAmounts:      []abi.TokenAmount{abi.NewTokenAmount(100)},
+			expectedResults: []expectedResult{
+				{
+					shouldAdd: false,
+					err:       nil,
+				},
+			},
+		},
+		"succeeds, multiple adds": {
+			returnedBalance: api.MarketBalance{Escrow: abi.NewTokenAmount(150), Locked: abi.NewTokenAmount(50)},
+			addAmounts:      []abi.TokenAmount{abi.NewTokenAmount(100), abi.NewTokenAmount(200), abi.NewTokenAmount(250), abi.NewTokenAmount(250)},
+			expectedResults: []expectedResult{
+				{
+					shouldAdd: false,
+					err:       nil,
+				},
+				{
+					addAmt:    abi.NewTokenAmount(100),
+					shouldAdd: true,
+					err:       nil,
+				},
+				{
+					addAmt:    abi.NewTokenAmount(50),
+					shouldAdd: true,
+					err:       nil,
+				},
+				{
+					shouldAdd: false,
+					err:       nil,
+				},
+			},
+		},
+		"error on market balance": {
+			returnedBalanceErr: errors.New("something went wrong"),
+			addAmounts:         []abi.TokenAmount{abi.NewTokenAmount(100)},
+			expectedResults: []expectedResult{
+				{
+					err: errors.New("something went wrong"),
+				},
+			},
+		},
+		"error on push message": {
+			returnedBalance: api.MarketBalance{Escrow: abi.NewTokenAmount(0), Locked: abi.NewTokenAmount(0)},
+			pushMessageErr:  errors.New("something went wrong"),
+			addAmounts:      []abi.TokenAmount{abi.NewTokenAmount(100)},
+			expectedResults: []expectedResult{
+				{
+					err: errors.New("something went wrong"),
+				},
+			},
+		},
+		"error looking up address": {
+			lookupIDErr: errors.New("something went wrong"),
+			addAmounts:  []abi.TokenAmount{abi.NewTokenAmount(100)},
+			expectedResults: []expectedResult{
+				{
+					err: errors.New("something went wrong"),
+				},
+			},
+		},
+	}
+
+	for testCase, data := range testCases {
+		//nolint:scopelint
+		t.Run(testCase, func(t *testing.T) {
+			ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
+			defer cancel()
+			sig := make([]byte, 100)
+			_, err := rand.Read(sig)
+			require.NoError(t, err)
+			fapi := &fakeAPI{
+				returnedBalance:    data.returnedBalance,
+				returnedBalanceErr: data.returnedBalanceErr,
+				signature: crypto.Signature{
+					Type: crypto.SigTypeUnknown,
+					Data: sig,
+				},
+				pushMessageErr: data.pushMessageErr,
+				lookupIDErr:    data.lookupIDErr,
+			}
+			fundMgr := newFundMgr(fapi)
+			addr := tutils.NewIDAddr(t, uint64(rand.Uint32()))
+			wallet := tutils.NewIDAddr(t, uint64(rand.Uint32()))
+			for i, amount := range data.addAmounts {
+				fapi.receivedMessage = nil
+				_, err := fundMgr.EnsureAvailable(ctx, addr, wallet, amount)
+				expected := data.expectedResults[i]
+				if expected.err == nil {
+					require.NoError(t, err)
+					if expected.shouldAdd {
+						expectedMessage := addFundsMsg(expected.addAmt, addr, wallet)
+						require.Equal(t, expectedMessage, fapi.receivedMessage)
+					} else {
+						require.Nil(t, fapi.receivedMessage)
+					}
+				} else {
+					require.EqualError(t, err, expected.err.Error())
+				}
+			}
+		})
+	}
+}
diff --git a/chain/messagepool/block_proba.go b/chain/messagepool/block_proba.go
new file mode 100644
index 000000000..61bb018d7
--- /dev/null
+++ b/chain/messagepool/block_proba.go
@@ -0,0 +1,102 @@
+package messagepool
+
+import (
+	"math"
+	"sync"
+)
+
+var noWinnersProbCache []float64
+var noWinnersProbOnce sync.Once
+
+func noWinnersProb() []float64 {
+	noWinnersProbOnce.Do(func() {
+		poissPdf := func(x float64) float64 {
+			const Mu = 5
+			lg, _ := math.Lgamma(x + 1)
+			result := math.Exp((math.Log(Mu) * x) - lg - Mu)
+			return result
+		}
+
+		out := make([]float64, 0, MaxBlocks)
+		for i := 0; i < MaxBlocks; i++ {
+			out = append(out, poissPdf(float64(i)))
+		}
+		noWinnersProbCache = out
+	})
+	return noWinnersProbCache
+}
+
+var noWinnersProbAssumingCache []float64
+var noWinnersProbAssumingOnce sync.Once
+
+func noWinnersProbAssumingMoreThanOne() []float64 {
+	noWinnersProbAssumingOnce.Do(func() {
+		cond := math.Log(-1 + math.Exp(5))
+		poissPdf := func(x float64) float64 {
+			const Mu = 5
+			lg, _ := math.Lgamma(x + 1)
+			result := math.Exp((math.Log(Mu) * x) - lg - cond)
+			return result
+		}
+
+		out := make([]float64, 0, MaxBlocks)
+		for i := 0; i < MaxBlocks; i++ {
+			out = append(out, poissPdf(float64(i+1)))
+		}
+		noWinnersProbAssumingCache = out
+	})
+	return noWinnersProbAssumingCache
+}
+
+func binomialCoefficient(n, k float64) float64 {
+	if k > n {
+		return math.NaN()
+	}
+	r := 1.0
+	for d := 1.0; d <= k; d++ {
+		r *= n
+		r /= d
+		n--
+	}
+	return r
+}
+
+func (mp *MessagePool) blockProbabilities(tq float64) []float64 {
+	noWinners := noWinnersProbAssumingMoreThanOne()
+
+	p := 1 - tq
+	binoPdf := func(x, trials float64) float64 {
+		// based on https://github.com/atgjack/prob
+		if x > trials {
+			return 0
+		}
+		if p == 0 {
+			if x == 0 {
+				return 1.0
+			}
+			return 0.0
+		}
+		if p == 1 {
+			if x == trials {
+				return 1.0
+			}
+			return 0.0
+		}
+		coef := binomialCoefficient(trials, x)
+		pow := math.Pow(p, x) * math.Pow(1-p, trials-x)
+		if math.IsInf(coef, 0) {
+			return 0
+		}
+		return coef * pow
+	}
+
+	out := make([]float64, 0, MaxBlocks)
+	for place := 0; place < MaxBlocks; place++ {
+		var pPlace float64
+		for otherWinners, pCase := range noWinners {
+			pPlace += pCase * binoPdf(float64(place), float64(otherWinners))
+		}
+		out = append(out, pPlace)
+	}
+	return out
+}
diff --git a/chain/messagepool/block_proba_test.go b/chain/messagepool/block_proba_test.go
new file mode 100644
index 000000000..93f51e887
--- /dev/null
+++ b/chain/messagepool/block_proba_test.go
@@ -0,0 +1,43 @@
+package messagepool
+
+import (
+	"math"
+	"math/rand"
+	"testing"
+	"time"
+)
+
+func TestBlockProbability(t *testing.T) {
+	mp := &MessagePool{}
+	bp := mp.blockProbabilities(1 - 0.15)
+	t.Logf("%+v\n", bp)
+	for i := 0; i < len(bp)-1; i++ {
+		if bp[i] < bp[i+1] {
+			t.Fatalf("expected decreasing block probabilities for this quality: %d %f %f",
+				i, bp[i], bp[i+1])
+		}
+	}
+}
+
+func TestWinnerProba(t *testing.T) {
+	rand.Seed(time.Now().UnixNano())
+	const N = 1000000
+	winnerProba := noWinnersProb()
+	sum := 0
+	for i := 0; i < N; i++ {
+		minersRand := rand.Float64()
+		j := 0
+		for ; j < MaxBlocks; j++ {
+			minersRand -= winnerProba[j]
+			if minersRand < 0 {
+				break
+			}
+		}
+		sum += j
+	}
+
+	if avg := float64(sum) / N; math.Abs(avg-5) > 0.01 {
+		t.Fatalf("avg too far off: %f", avg)
+	}
+
+}
diff --git a/chain/messagepool/config.go b/chain/messagepool/config.go
new file mode 100644
index 000000000..f8f0ee985
--- /dev/null
+++ b/chain/messagepool/config.go
@@ -0,0 +1,92 @@
+package messagepool
+
+import (
+	"encoding/json"
+	"fmt"
+	"time"
+
+	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/node/modules/dtypes"
+	"github.com/ipfs/go-datastore"
+)
+
+var (
+	ReplaceByFeeRatioDefault  = 1.25
+	MemPoolSizeLimitHiDefault = 30000
+	MemPoolSizeLimitLoDefault = 20000
+	PruneCooldownDefault      = time.Minute
+	GasLimitOverestimation    = 1.25
+
+	ConfigKey = datastore.NewKey("/mpool/config")
+)
+
+func loadConfig(ds dtypes.MetadataDS) (*types.MpoolConfig, error) {
+	haveCfg, err := ds.Has(ConfigKey)
+	if err != nil {
+		return nil, err
+	}
+
+	if !haveCfg {
+		return DefaultConfig(), nil
+	}
+
+	cfgBytes, err := ds.Get(ConfigKey)
+	if err != nil {
+		return nil, err
+	}
+	cfg := new(types.MpoolConfig)
+	err = json.Unmarshal(cfgBytes, cfg)
+	return cfg, err
+}
+
+func saveConfig(cfg *types.MpoolConfig, ds dtypes.MetadataDS) error {
+	cfgBytes, err := json.Marshal(cfg)
+	if err != nil {
+		return err
+	}
+	return ds.Put(ConfigKey, cfgBytes)
+}
+
+func (mp *MessagePool) GetConfig() *types.MpoolConfig {
+	mp.cfgLk.Lock()
+	defer mp.cfgLk.Unlock()
+	return mp.cfg.Clone()
+}
+
+func validateConfg(cfg *types.MpoolConfig) error {
+	if cfg.ReplaceByFeeRatio < ReplaceByFeeRatioDefault {
+		return fmt.Errorf("'ReplaceByFeeRatio' is less than required %f < %f",
+			cfg.ReplaceByFeeRatio, ReplaceByFeeRatioDefault)
+	}
+	if cfg.GasLimitOverestimation < 1 {
+		return fmt.Errorf("'GasLimitOverestimation' cannot be less than 1")
+	}
+	return nil
+}
+
+func (mp *MessagePool) SetConfig(cfg *types.MpoolConfig) error {
+	if err := validateConfg(cfg); err != nil {
+		return err
+	}
+	cfg = cfg.Clone()
+
+	mp.cfgLk.Lock()
+	mp.cfg = cfg
+	err := saveConfig(cfg, mp.ds)
+	if err != nil {
+		log.Warnf("error persisting mpool config: %s", err)
+	}
+	mp.cfgLk.Unlock()
+
+	return nil
+}
+
+func DefaultConfig() *types.MpoolConfig {
+	return &types.MpoolConfig{
+		SizeLimitHigh:          MemPoolSizeLimitHiDefault,
+		SizeLimitLow:           MemPoolSizeLimitLoDefault,
+		ReplaceByFeeRatio:      ReplaceByFeeRatioDefault,
+		PruneCooldown:          PruneCooldownDefault,
+		GasLimitOverestimation: GasLimitOverestimation,
+	}
+}
diff --git a/chain/messagepool/gasguess/guessgas.go b/chain/messagepool/gasguess/guessgas.go
new file mode 100644
index 000000000..af58db7d2
--- /dev/null
+++ b/chain/messagepool/gasguess/guessgas.go
@@ -0,0 +1,79 @@
+package gasguess
+
+import (
+	"context"
+
+	"github.com/ipfs/go-cid"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/lotus/chain/types"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/specs-actors/actors/builtin"
+)
+
+type ActorLookup func(context.Context, address.Address, types.TipSetKey) (*types.Actor, error)
+
+const failedGasGuessRatio = 0.5
+const failedGasGuessMax = 25_000_000
+
+const MinGas = 1298450
+const MaxGas = 1600271356
+
+type CostKey struct {
+	Code cid.Cid
+	M    abi.MethodNum
+}
+
+var Costs = map[CostKey]int64{
+	{builtin.InitActorCodeID, 2}:          8916753,
+	{builtin.StorageMarketActorCodeID, 2}: 6955002,
+	{builtin.StorageMarketActorCodeID, 4}: 245436108,
+	{builtin.StorageMinerActorCodeID, 4}:  2315133,
+	{builtin.StorageMinerActorCodeID, 5}:  1600271356,
+	{builtin.StorageMinerActorCodeID, 6}:  22864493,
+	{builtin.StorageMinerActorCodeID, 7}:  142002419,
+	{builtin.StorageMinerActorCodeID, 10}: 23008274,
+	{builtin.StorageMinerActorCodeID, 11}: 19303178,
+	{builtin.StorageMinerActorCodeID, 14}: 566356835,
+	{builtin.StorageMinerActorCodeID, 16}: 5325185,
+	{builtin.StorageMinerActorCodeID, 18}: 2328637,
+	{builtin.StoragePowerActorCodeID, 2}:  23600956,
+}
+
+func failedGuess(msg *types.SignedMessage) int64 {
+	guess := int64(float64(msg.Message.GasLimit) * failedGasGuessRatio)
+	if guess > failedGasGuessMax {
+		guess = failedGasGuessMax
+	}
+	return guess
+}
+
+func GuessGasUsed(ctx context.Context, tsk types.TipSetKey, msg *types.SignedMessage, al ActorLookup) (int64, error) {
+	if msg.Message.Method == builtin.MethodSend {
+		switch msg.Message.From.Protocol() {
+		case address.BLS:
+			return 1298450, nil
+		case address.SECP256K1:
+			return 1385999, nil
+		default:
+			// who knows?
+			return 1298450, nil
+		}
+	}
+
+	to, err := al(ctx, msg.Message.To, tsk)
+	if err != nil {
+		return failedGuess(msg), xerrors.Errorf("could not lookup actor: %w", err)
+	}
+
+	guess, ok := Costs[CostKey{to.Code, msg.Message.Method}]
+	if !ok {
+		return failedGuess(msg), xerrors.Errorf("unknown code-method combo")
+	}
+	if guess > msg.Message.GasLimit {
+		guess = msg.Message.GasLimit
+	}
+	return guess, nil
+}
diff --git a/chain/messagepool/messagepool.go b/chain/messagepool/messagepool.go
index 8bbf3823a..96900925f 100644
--- a/chain/messagepool/messagepool.go
+++ b/chain/messagepool/messagepool.go
@@ -4,32 +4,60 @@ import (
 	"bytes"
 	"context"
 	"errors"
+	"fmt"
+	"math"
+	stdbig "math/big"
 	"sort"
 	"sync"
 	"time"
 
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/big"
+	"github.com/filecoin-project/go-state-types/crypto"
+	"github.com/hashicorp/go-multierror"
 	lru "github.com/hashicorp/golang-lru"
 	"github.com/ipfs/go-cid"
 	"github.com/ipfs/go-datastore"
 	"github.com/ipfs/go-datastore/namespace"
 	"github.com/ipfs/go-datastore/query"
-	logging "github.com/ipfs/go-log"
+	logging "github.com/ipfs/go-log/v2"
 	pubsub "github.com/libp2p/go-libp2p-pubsub"
 	lps "github.com/whyrusleeping/pubsub"
-	"go.uber.org/multierr"
 	"golang.org/x/xerrors"
 
 	"github.com/filecoin-project/go-address"
+
 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/build"
-	"github.com/filecoin-project/lotus/chain/stmgr"
 	"github.com/filecoin-project/lotus/chain/store"
 	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/chain/vm"
+	"github.com/filecoin-project/lotus/journal"
+	"github.com/filecoin-project/lotus/lib/sigs"
 	"github.com/filecoin-project/lotus/node/modules/dtypes"
+
+	"github.com/raulk/clock"
 )
 
 var log = logging.Logger("messagepool")
 
+var futureDebug = false
+
+var rbfNumBig = types.NewInt(uint64((ReplaceByFeeRatioDefault - 1) * RbfDenom))
+var rbfDenomBig = types.NewInt(RbfDenom)
+
+const RbfDenom = 256
+
+var RepublishInterval = time.Duration(10*build.BlockDelaySecs+build.PropagationDelaySecs) * time.Second
+
+var minimumBaseFee = types.NewInt(uint64(build.MinimumBaseFee))
+var baseFeeLowerBoundFactor = types.NewInt(10)
+var baseFeeLowerBoundFactorConservative = types.NewInt(100)
+
+var MaxActorPendingMessages = 1000
+
+var MaxNonceGap = uint64(4)
+
 var (
 	ErrMessageTooBig = errors.New("message too big")
 
@@ -37,24 +65,67 @@ var (
 
 	ErrNonceTooLow = errors.New("message nonce too low")
 
+	ErrGasFeeCapTooLow = errors.New("gas fee cap too low")
+
 	ErrNotEnoughFunds = errors.New("not enough funds to execute transaction")
 
 	ErrInvalidToAddr = errors.New("message had invalid to address")
+
+	ErrSoftValidationFailure  = errors.New("validation failure")
+	ErrRBFTooLowPremium       = errors.New("replace by fee has too low GasPremium")
+	ErrTooManyPendingMessages = errors.New("too many pending messages for actor")
+	ErrNonceGap               = errors.New("unfulfilled nonce gap")
+
+	ErrTryAgain = errors.New("state inconsistency while pushing message; please try again")
 )
 
 const (
-	msgTopic = "/fil/messages"
-
 	localMsgsDs = "/mpool/local"
 
 	localUpdates = "update"
 )
 
+// Journal event types.
+const (
+	evtTypeMpoolAdd = iota
+	evtTypeMpoolRemove
+	evtTypeMpoolRepub
+)
+
+// MessagePoolEvt is the journal entry for message pool events.
+type MessagePoolEvt struct {
+	Action   string
+	Messages []MessagePoolEvtMessage
+	Error    error `json:",omitempty"`
+}
+
+type MessagePoolEvtMessage struct {
+	types.Message
+
+	CID cid.Cid
+}
+
+func init() {
+	// if the republish interval is too short compared to the pubsub timecache, adjust it
+	minInterval := pubsub.TimeCacheDuration + time.Duration(build.PropagationDelaySecs)
+	if RepublishInterval < minInterval {
+		RepublishInterval = minInterval
+	}
+}
+
 type MessagePool struct {
 	lk sync.Mutex
 
-	closer  chan struct{}
-	repubTk *time.Ticker
+	ds dtypes.MetadataDS
+
+	addSema chan struct{}
+
+	closer chan struct{}
+
+	repubTk      *clock.Ticker
+	repubTrigger chan struct{}
+
+	republished map[cid.Cid]struct{}
 
 	localAddrs map[address.Address]struct{}
 
@@ -63,114 +134,219 @@ type MessagePool struct {
 	curTsLk sync.Mutex // DO NOT LOCK INSIDE lk
 	curTs   *types.TipSet
 
+	cfgLk sync.Mutex
+	cfg   *types.MpoolConfig
+
 	api Provider
 
 	minGasPrice types.BigInt
 
-	maxTxPoolSize int
+	currentSize int
+
+	// pruneTrigger is a channel used to trigger a mempool pruning
+	pruneTrigger chan struct{}
+
+	// pruneCooldown is a channel used to allow a cooldown time between prunes
+	pruneCooldown chan struct{}
 
 	blsSigCache *lru.TwoQueueCache
 
 	changes *lps.PubSub
 
 	localMsgs datastore.Datastore
+
+	netName dtypes.NetworkName
+
+	sigValCache *lru.TwoQueueCache
+
+	evtTypes [3]journal.EventType
 }
 
 type msgSet struct {
-	msgs      map[uint64]*types.SignedMessage
-	nextNonce uint64
+	msgs          map[uint64]*types.SignedMessage
+	nextNonce     uint64
+	requiredFunds *stdbig.Int
 }
 
-func newMsgSet() *msgSet {
+func newMsgSet(nonce uint64) *msgSet {
 	return &msgSet{
-		msgs: make(map[uint64]*types.SignedMessage),
+		msgs:          make(map[uint64]*types.SignedMessage),
+		nextNonce:     nonce,
+		requiredFunds: stdbig.NewInt(0),
 	}
 }
 
-func (ms *msgSet) add(m *types.SignedMessage) error {
-	if len(ms.msgs) == 0 || m.Message.Nonce >= ms.nextNonce {
-		ms.nextNonce = m.Message.Nonce + 1
+func ComputeMinRBF(curPrem abi.TokenAmount) abi.TokenAmount {
+	minPrice := types.BigAdd(curPrem, types.BigDiv(types.BigMul(curPrem, rbfNumBig), rbfDenomBig))
+	return types.BigAdd(minPrice, types.NewInt(1))
+}
+
+func CapGasFee(msg *types.Message, maxFee abi.TokenAmount) {
+	if maxFee.Equals(big.Zero()) {
+		maxFee = types.NewInt(build.FilecoinPrecision / 10)
 	}
-	if _, has := ms.msgs[m.Message.Nonce]; has {
-		if m.Cid() != ms.msgs[m.Message.Nonce].Cid() {
-			log.Error("Add with duplicate nonce")
-			return xerrors.Errorf("message to %s with nonce %d already in mpool")
+
+	gl := types.NewInt(uint64(msg.GasLimit))
+	totalFee := types.BigMul(msg.GasFeeCap, gl)
+
+	if totalFee.LessThanEqual(maxFee) {
+		return
+	}
+
+	msg.GasFeeCap = big.Div(maxFee, gl)
+	msg.GasPremium = big.Min(msg.GasFeeCap, msg.GasPremium) // cap premium at FeeCap
+}
+
+func (ms *msgSet) add(m *types.SignedMessage, mp *MessagePool, strict bool) (bool, error) {
+	nextNonce := ms.nextNonce
+	nonceGap := false
+	switch {
+	case m.Message.Nonce == nextNonce:
+		nextNonce++
+		// advance if we are filling a gap
+		for _, fillGap := ms.msgs[nextNonce]; fillGap; _, fillGap = ms.msgs[nextNonce] {
+			nextNonce++
 		}
+
+	case strict && m.Message.Nonce > nextNonce+MaxNonceGap:
+		return false, xerrors.Errorf("message nonce has too big a gap from expected nonce (Nonce: %d, nextNonce: %d): %w", m.Message.Nonce, nextNonce, ErrNonceGap)
+
+	case m.Message.Nonce > nextNonce:
+		nonceGap = true
 	}
+
+	exms, has := ms.msgs[m.Message.Nonce]
+	if has {
+		// refuse RBF if we have a gap
+		if strict && nonceGap {
+			return false, xerrors.Errorf("rejecting replace by fee because of nonce gap (Nonce: %d, nextNonce: %d): %w", m.Message.Nonce, nextNonce, ErrNonceGap)
+		}
+
+		if m.Cid() != exms.Cid() {
+			// check if RBF passes
+			minPrice := ComputeMinRBF(exms.Message.GasPremium)
+			if types.BigCmp(m.Message.GasPremium, minPrice) >= 0 {
+				log.Infow("add with RBF", "oldpremium", exms.Message.GasPremium,
+					"newpremium", m.Message.GasPremium, "addr", m.Message.From, "nonce", m.Message.Nonce)
+			} else {
+				log.Info("add with duplicate nonce")
+				return false, xerrors.Errorf("message from %s with nonce %d already in mpool,"+
+					" increase GasPremium to %s from %s to trigger replace by fee: %w",
+					m.Message.From, m.Message.Nonce, minPrice, m.Message.GasPremium,
+					ErrRBFTooLowPremium)
+			}
+		} else {
+			return false, xerrors.Errorf("message from %s with nonce %d already in mpool: %w",
+				m.Message.From, m.Message.Nonce, ErrSoftValidationFailure)
+		}
+
+		ms.requiredFunds.Sub(ms.requiredFunds, exms.Message.RequiredFunds().Int)
+		//ms.requiredFunds.Sub(ms.requiredFunds, exms.Message.Value.Int)
+	}
+
+	if !has && strict && len(ms.msgs) > MaxActorPendingMessages {
+		log.Errorf("too many pending messages from actor %s", m.Message.From)
+		return false, ErrTooManyPendingMessages
+	}
+
+	if strict && nonceGap {
+		log.Warnf("adding nonce-gapped message from %s (nonce: %d, nextNonce: %d)",
+			m.Message.From, m.Message.Nonce, nextNonce)
+	}
+
+	ms.nextNonce = nextNonce
 	ms.msgs[m.Message.Nonce] = m
+	ms.requiredFunds.Add(ms.requiredFunds, m.Message.RequiredFunds().Int)
+	//ms.requiredFunds.Add(ms.requiredFunds, m.Message.Value.Int)
 
-	return nil
+	return !has, nil
 }
 
-type Provider interface {
-	SubscribeHeadChanges(func(rev, app []*types.TipSet) error) *types.TipSet
-	PutMessage(m store.ChainMsg) (cid.Cid, error)
-	PubSubPublish(string, []byte) error
-	StateGetActor(address.Address, *types.TipSet) (*types.Actor, error)
-	MessagesForBlock(*types.BlockHeader) ([]*types.Message, []*types.SignedMessage, error)
-	MessagesForTipset(*types.TipSet) ([]store.ChainMsg, error)
-	LoadTipSet(tsk types.TipSetKey) (*types.TipSet, error)
+func (ms *msgSet) rm(nonce uint64, applied bool) {
+	m, has := ms.msgs[nonce]
+	if !has {
+		if applied && nonce >= ms.nextNonce {
+			// we removed a message we did not know about because it was applied
+			// we need to adjust the nonce and check if we filled a gap
+			ms.nextNonce = nonce + 1
+			for _, fillGap := ms.msgs[ms.nextNonce]; fillGap; _, fillGap = ms.msgs[ms.nextNonce] {
+				ms.nextNonce++
+			}
+		}
+		return
+	}
+
+	ms.requiredFunds.Sub(ms.requiredFunds, m.Message.RequiredFunds().Int)
+	//ms.requiredFunds.Sub(ms.requiredFunds, m.Message.Value.Int)
+	delete(ms.msgs, nonce)
+
+	// adjust next nonce
+	if applied {
+		// we removed a (known) message because it was applied in a tipset
+		// we can't possibly have filled a gap in this case
+		if nonce >= ms.nextNonce {
+			ms.nextNonce = nonce + 1
+		}
+		return
+	}
+
+	// we removed a message because it was pruned
+	// we have to adjust the nonce if it creates a gap or rewinds state
+	if nonce < ms.nextNonce {
+		ms.nextNonce = nonce
+	}
 }
 
-type mpoolProvider struct {
-	sm *stmgr.StateManager
-	ps *pubsub.PubSub
+func (ms *msgSet) getRequiredFunds(nonce uint64) types.BigInt {
+	requiredFunds := new(stdbig.Int).Set(ms.requiredFunds)
+
+	m, has := ms.msgs[nonce]
+	if has {
+		requiredFunds.Sub(requiredFunds, m.Message.RequiredFunds().Int)
+		//requiredFunds.Sub(requiredFunds, m.Message.Value.Int)
+	}
+
+	return types.BigInt{Int: requiredFunds}
 }
 
-func NewProvider(sm *stmgr.StateManager, ps *pubsub.PubSub) Provider {
-	return &mpoolProvider{sm, ps}
-}
-
-func (mpp *mpoolProvider) SubscribeHeadChanges(cb func(rev, app []*types.TipSet) error) *types.TipSet {
-	mpp.sm.ChainStore().SubscribeHeadChanges(cb)
-	return mpp.sm.ChainStore().GetHeaviestTipSet()
-}
-
-func (mpp *mpoolProvider) PutMessage(m store.ChainMsg) (cid.Cid, error) {
-	return mpp.sm.ChainStore().PutMessage(m)
-}
-
-func (mpp *mpoolProvider) PubSubPublish(k string, v []byte) error {
-	return mpp.ps.Publish(k, v)
-}
-
-func (mpp *mpoolProvider) StateGetActor(addr address.Address, ts *types.TipSet) (*types.Actor, error) {
-	return mpp.sm.GetActor(addr, ts)
-}
-
-func (mpp *mpoolProvider) MessagesForBlock(h *types.BlockHeader) ([]*types.Message, []*types.SignedMessage, error) {
-	return mpp.sm.ChainStore().MessagesForBlock(h)
-}
-
-func (mpp *mpoolProvider) MessagesForTipset(ts *types.TipSet) ([]store.ChainMsg, error) {
-	return mpp.sm.ChainStore().MessagesForTipset(ts)
-}
-
-func (mpp *mpoolProvider) LoadTipSet(tsk types.TipSetKey) (*types.TipSet, error) {
-	return mpp.sm.ChainStore().LoadTipSet(tsk)
-}
-
-func New(api Provider, ds dtypes.MetadataDS) (*MessagePool, error) {
+func New(api Provider, ds dtypes.MetadataDS, netName dtypes.NetworkName) (*MessagePool, error) {
 	cache, _ := lru.New2Q(build.BlsSignatureCacheSize)
+	verifcache, _ := lru.New2Q(build.VerifSigCacheSize)
+
+	cfg, err := loadConfig(ds)
+	if err != nil {
+		return nil, xerrors.Errorf("error loading mpool config: %w", err)
+	}
+
 	mp := &MessagePool{
+		ds:            ds,
+		addSema:       make(chan struct{}, 1),
 		closer:        make(chan struct{}),
-		repubTk:       time.NewTicker(build.BlockDelay * 10 * time.Second),
+		repubTk:       build.Clock.Ticker(RepublishInterval),
+		repubTrigger:  make(chan struct{}, 1),
 		localAddrs:    make(map[address.Address]struct{}),
 		pending:       make(map[address.Address]*msgSet),
 		minGasPrice:   types.NewInt(0),
-		maxTxPoolSize: 5000,
+		pruneTrigger:  make(chan struct{}, 1),
+		pruneCooldown: make(chan struct{}, 1),
 		blsSigCache:   cache,
+		sigValCache:   verifcache,
 		changes:       lps.New(50),
 		localMsgs:     namespace.Wrap(ds, datastore.NewKey(localMsgsDs)),
 		api:           api,
+		netName:       netName,
+		cfg:           cfg,
+		evtTypes: [...]journal.EventType{
+			evtTypeMpoolAdd:    journal.J.RegisterEventType("mpool", "add"),
+			evtTypeMpoolRemove: journal.J.RegisterEventType("mpool", "remove"),
+			evtTypeMpoolRepub:  journal.J.RegisterEventType("mpool", "repub"),
+		},
 	}
 
-	if err := mp.loadLocal(); err != nil {
-		log.Errorf("loading local messages: %+v", err)
-	}
-
-	go mp.repubLocal()
+	// enable initial prunes
+	mp.pruneCooldown <- struct{}{}
 
+	// load the current tipset and subscribe to head changes _before_ loading local messages
 	mp.curTs = api.SubscribeHeadChanges(func(rev, app []*types.TipSet) error {
 		err := mp.HeadChange(rev, app)
 		if err != nil {
@@ -179,6 +355,12 @@ func New(api Provider, ds dtypes.MetadataDS) (*MessagePool, error) {
 		return err
 	})
 
+	if err := mp.loadLocal(); err != nil {
+		log.Errorf("loading local messages: %+v", err)
+	}
+
+	go mp.runLoop()
+
 	return mp, nil
 }
 
@@ -187,70 +369,40 @@ func (mp *MessagePool) Close() error {
 	return nil
 }
 
-func (mp *MessagePool) repubLocal() {
+func (mp *MessagePool) Prune() {
+	// this magic incantation of triggering prune thrice is here to make the Prune method
+	// synchronous:
+	// so, its a single slot buffered channel. The first send fills the channel,
+	// the second send goes through when the pruning starts,
+	// and the third send goes through (and noops) after the pruning finishes
+	// and goes through the loop again
+	mp.pruneTrigger <- struct{}{}
+	mp.pruneTrigger <- struct{}{}
+	mp.pruneTrigger <- struct{}{}
+}
+
+func (mp *MessagePool) runLoop() {
 	for {
 		select {
 		case <-mp.repubTk.C:
-			mp.lk.Lock()
-
-			msgsForAddr := make(map[address.Address][]*types.SignedMessage)
-			for a := range mp.localAddrs {
-				msgsForAddr[a] = mp.pendingFor(a)
+			if err := mp.republishPendingMessages(); err != nil {
+				log.Errorf("error while republishing messages: %s", err)
+			}
+		case <-mp.repubTrigger:
+			if err := mp.republishPendingMessages(); err != nil {
+				log.Errorf("error while republishing messages: %s", err)
 			}
 
-			mp.lk.Unlock()
-
-			var errout error
-			outputMsgs := []*types.SignedMessage{}
-
-			for a, msgs := range msgsForAddr {
-				a, err := mp.api.StateGetActor(a, nil)
-				if err != nil {
-					errout = multierr.Append(errout, xerrors.Errorf("could not get actor state: %w", err))
-					continue
-				}
-
-				curNonce := a.Nonce
-				for _, m := range msgs {
-					if m.Message.Nonce < curNonce {
-						continue
-					}
-					if m.Message.Nonce != curNonce {
-						break
-					}
-					outputMsgs = append(outputMsgs, m)
-					curNonce++
-				}
-
+		case <-mp.pruneTrigger:
+			if err := mp.pruneExcessMessages(); err != nil {
+				log.Errorf("failed to prune excess messages from mempool: %s", err)
 			}
 
-			if len(outputMsgs) != 0 {
-				log.Infow("republishing local messages", "n", len(outputMsgs))
-			}
-
-			for _, msg := range outputMsgs {
-				msgb, err := msg.Serialize()
-				if err != nil {
-					errout = multierr.Append(errout, xerrors.Errorf("could not serialize: %w", err))
-					continue
-				}
-
-				err = mp.api.PubSubPublish(msgTopic, msgb)
-				if err != nil {
-					errout = multierr.Append(errout, xerrors.Errorf("could not publish: %w", err))
-					continue
-				}
-			}
-
-			if errout != nil {
-				log.Errorf("errors while republishing: %+v", errout)
-			}
 		case <-mp.closer:
 			mp.repubTk.Stop()
 			return
 		}
 	}
-
 }
 
 func (mp *MessagePool) addLocal(m *types.SignedMessage, msgb []byte) error {
@@ -263,15 +415,83 @@ func (mp *MessagePool) addLocal(m *types.SignedMessage, msgb []byte) error {
 	return nil
 }
 
+// verifyMsgBeforeAdd verifies that the message meets the minimum criteria for block inclusio
+// and whether the message has enough funds to be included in the next 20 blocks.
+// If the message is not valid for block inclusion, it returns an error.
+// For local messages, if the message can be included in the next 20 blocks, it returns true to
+// signal that it should be immediately published. If the message cannot be included in the next 20
+// blocks, it returns false so that the message doesn't immediately get published (and ignored by our
+// peers); instead it will be published through the republish loop, once the base fee has fallen
+// sufficiently.
+// For non local messages, if the message cannot be included in the next 20 blocks it returns
+// a (soft) validation error.
+func (mp *MessagePool) verifyMsgBeforeAdd(m *types.SignedMessage, curTs *types.TipSet, local bool) (bool, error) {
+	epoch := curTs.Height()
+	minGas := vm.PricelistByEpoch(epoch).OnChainMessage(m.ChainLength())
+
+	if err := m.VMMessage().ValidForBlockInclusion(minGas.Total()); err != nil {
+		return false, xerrors.Errorf("message will not be included in a block: %w", err)
+	}
+
+	// this checks if the GasFeeCap is suffisciently high for inclusion in the next 20 blocks
+	// if the GasFeeCap is too low, we soft reject the message (Ignore in pubsub) and rely
+	// on republish to push it through later, if the baseFee has fallen.
+	// this is a defensive check that stops minimum baseFee spam attacks from overloading validation
+	// queues.
+	// Note that for local messages, we always add them so that they can be accepted and republished
+	// automatically.
+	publish := local
+
+	var baseFee big.Int
+	if len(curTs.Blocks()) > 0 {
+		baseFee = curTs.Blocks()[0].ParentBaseFee
+	} else {
+		var err error
+		baseFee, err = mp.api.ChainComputeBaseFee(context.TODO(), curTs)
+		if err != nil {
+			return false, xerrors.Errorf("computing basefee: %w", err)
+		}
+	}
+
+	baseFeeLowerBound := getBaseFeeLowerBound(baseFee, baseFeeLowerBoundFactorConservative)
+	if m.Message.GasFeeCap.LessThan(baseFeeLowerBound) {
+		if local {
+			log.Warnf("local message will not be immediately published because GasFeeCap doesn't meet the lower bound for inclusion in the next 20 blocks (GasFeeCap: %s, baseFeeLowerBound: %s)",
+				m.Message.GasFeeCap, baseFeeLowerBound)
+			publish = false
+		} else {
+			return false, xerrors.Errorf("GasFeeCap doesn't meet base fee lower bound for inclusion in the next 20 blocks (GasFeeCap: %s, baseFeeLowerBound: %s): %w",
+				m.Message.GasFeeCap, baseFeeLowerBound, ErrSoftValidationFailure)
+		}
+	}
+
+	return publish, nil
+}
+
 func (mp *MessagePool) Push(m *types.SignedMessage) (cid.Cid, error) {
+	err := mp.checkMessage(m)
+	if err != nil {
+		return cid.Undef, err
+	}
+
+	// serialize push access to reduce lock contention
+	mp.addSema <- struct{}{}
+	defer func() {
+		<-mp.addSema
+	}()
+
 	msgb, err := m.Serialize()
 	if err != nil {
 		return cid.Undef, err
 	}
 
-	if err := mp.Add(m); err != nil {
+	mp.curTsLk.Lock()
+	publish, err := mp.addTs(m, mp.curTs, true)
+	if err != nil {
+		mp.curTsLk.Unlock()
 		return cid.Undef, err
 	}
+	mp.curTsLk.Unlock()
 
 	mp.lk.Lock()
 	if err := mp.addLocal(m, msgb); err != nil {
@@ -280,21 +500,24 @@ func (mp *MessagePool) Push(m *types.SignedMessage) (cid.Cid, error) {
 	}
 	mp.lk.Unlock()
 
-	return m.Cid(), mp.api.PubSubPublish(msgTopic, msgb)
+	if publish {
+		err = mp.api.PubSubPublish(build.MessagesTopic(mp.netName), msgb)
+	}
+
+	return m.Cid(), err
 }
 
-func (mp *MessagePool) Add(m *types.SignedMessage) error {
-	mp.curTsLk.Lock()
-	defer mp.curTsLk.Unlock()
-	return mp.addTs(m, mp.curTs)
-}
-
-func (mp *MessagePool) addTs(m *types.SignedMessage, curTs *types.TipSet) error {
+func (mp *MessagePool) checkMessage(m *types.SignedMessage) error {
 	// big messages are bad, anti DOS
 	if m.Size() > 32*1024 {
 		return xerrors.Errorf("mpool message too large (%dB): %w", m.Size(), ErrMessageTooBig)
 	}
 
+	// Perform syntactic validation, minGas=0 as we check the actual mingas before we add it
+	if err := m.Message.ValidForBlockInclusion(0); err != nil {
+		return xerrors.Errorf("message not valid for block inclusion: %w", err)
+	}
+
 	if m.Message.To == address.Undef {
 		return ErrInvalidToAddr
 	}
@@ -303,45 +526,171 @@ func (mp *MessagePool) addTs(m *types.SignedMessage, curTs *types.TipSet) error
 		return ErrMessageValueTooHigh
 	}
 
-	if err := m.Signature.Verify(m.Message.From, m.Message.Cid().Bytes()); err != nil {
-		log.Warnf("mpooladd signature verification failed: %s", err)
+	if m.Message.GasFeeCap.LessThan(minimumBaseFee) {
+		return ErrGasFeeCapTooLow
+	}
+
+	if err := mp.VerifyMsgSig(m); err != nil {
+		log.Warnf("signature verification failed: %s", err)
 		return err
 	}
 
+	return nil
+}
+
+func (mp *MessagePool) Add(m *types.SignedMessage) error {
+	err := mp.checkMessage(m)
+	if err != nil {
+		return err
+	}
+
+	// serialize push access to reduce lock contention
+	mp.addSema <- struct{}{}
+	defer func() {
+		<-mp.addSema
+	}()
+
+	mp.curTsLk.Lock()
+	defer mp.curTsLk.Unlock()
+
+	_, err = mp.addTs(m, mp.curTs, false)
+	return err
+}
+
+func sigCacheKey(m *types.SignedMessage) (string, error) {
+	switch m.Signature.Type {
+	case crypto.SigTypeBLS:
+		if len(m.Signature.Data) < 90 {
+			return "", fmt.Errorf("bls signature too short")
+		}
+
+		return string(m.Cid().Bytes()) + string(m.Signature.Data[64:]), nil
+	case crypto.SigTypeSecp256k1:
+		return string(m.Cid().Bytes()), nil
+	default:
+		return "", xerrors.Errorf("unrecognized signature type: %d", m.Signature.Type)
+	}
+}
+
+func (mp *MessagePool) VerifyMsgSig(m *types.SignedMessage) error {
+	sck, err := sigCacheKey(m)
+	if err != nil {
+		return err
+	}
+
+	_, ok := mp.sigValCache.Get(sck)
+	if ok {
+		// already validated, great
+		return nil
+	}
+
+	if err := sigs.Verify(&m.Signature, m.Message.From, m.Message.Cid().Bytes()); err != nil {
+		return err
+	}
+
+	mp.sigValCache.Add(sck, struct{}{})
+
+	return nil
+}
+
+func (mp *MessagePool) checkBalance(m *types.SignedMessage, curTs *types.TipSet) error {
+	balance, err := mp.getStateBalance(m.Message.From, curTs)
+	if err != nil {
+		return xerrors.Errorf("failed to check sender balance: %s: %w", err, ErrSoftValidationFailure)
+	}
+
+	requiredFunds := m.Message.RequiredFunds()
+	if balance.LessThan(requiredFunds) {
+		return xerrors.Errorf("not enough funds (required: %s, balance: %s): %w", types.FIL(requiredFunds), types.FIL(balance), ErrNotEnoughFunds)
+	}
+
+	// add Value for soft failure check
+	//requiredFunds = types.BigAdd(requiredFunds, m.Message.Value)
+
+	mset, ok := mp.pending[m.Message.From]
+	if ok {
+		requiredFunds = types.BigAdd(requiredFunds, mset.getRequiredFunds(m.Message.Nonce))
+	}
+
+	if balance.LessThan(requiredFunds) {
+		// Note: we fail here for ErrSoftValidationFailure to signal a soft failure because we might
+		// be out of sync.
+		return xerrors.Errorf("not enough funds including pending messages (required: %s, balance: %s): %w", types.FIL(requiredFunds), types.FIL(balance), ErrSoftValidationFailure)
+	}
+
+	return nil
+}
+
+func (mp *MessagePool) addTs(m *types.SignedMessage, curTs *types.TipSet, local bool) (bool, error) {
 	snonce, err := mp.getStateNonce(m.Message.From, curTs)
 	if err != nil {
-		return xerrors.Errorf("failed to look up actor state nonce: %w", err)
+		return false, xerrors.Errorf("failed to look up actor state nonce: %s: %w", err, ErrSoftValidationFailure)
+	}
+
+	if snonce > m.Message.Nonce {
+		return false, xerrors.Errorf("minimum expected nonce is %d: %w", snonce, ErrNonceTooLow)
+	}
+
+	mp.lk.Lock()
+	defer mp.lk.Unlock()
+
+	publish, err := mp.verifyMsgBeforeAdd(m, curTs, local)
+	if err != nil {
+		return false, err
+	}
+
+	if err := mp.checkBalance(m, curTs); err != nil {
+		return false, err
+	}
+
+	return publish, mp.addLocked(m, !local)
+}
+
+func (mp *MessagePool) addLoaded(m *types.SignedMessage) error {
+	err := mp.checkMessage(m)
+	if err != nil {
+		return err
+	}
+
+	mp.curTsLk.Lock()
+	defer mp.curTsLk.Unlock()
+
+	curTs := mp.curTs
+
+	snonce, err := mp.getStateNonce(m.Message.From, curTs)
+	if err != nil {
+		return xerrors.Errorf("failed to look up actor state nonce: %s: %w", err, ErrSoftValidationFailure)
 	}
 
 	if snonce > m.Message.Nonce {
 		return xerrors.Errorf("minimum expected nonce is %d: %w", snonce, ErrNonceTooLow)
 	}
 
-	balance, err := mp.getStateBalance(m.Message.From, curTs)
-	if err != nil {
-		return xerrors.Errorf("failed to check sender balance: %w", err)
-	}
-
-	if balance.LessThan(m.Message.RequiredFunds()) {
-		return xerrors.Errorf("not enough funds (required: %s, balance: %s): %w", types.FIL(m.Message.RequiredFunds()), types.FIL(balance), ErrNotEnoughFunds)
-	}
-
 	mp.lk.Lock()
 	defer mp.lk.Unlock()
 
-	return mp.addLocked(m)
+	_, err = mp.verifyMsgBeforeAdd(m, curTs, true)
+	if err != nil {
+		return err
+	}
+
+	if err := mp.checkBalance(m, curTs); err != nil {
+		return err
+	}
+
+	return mp.addLocked(m, false)
 }
 
 func (mp *MessagePool) addSkipChecks(m *types.SignedMessage) error {
 	mp.lk.Lock()
 	defer mp.lk.Unlock()
 
-	return mp.addLocked(m)
+	return mp.addLocked(m, false)
 }
 
-func (mp *MessagePool) addLocked(m *types.SignedMessage) error {
-	log.Debugf("mpooladd: %s %s", m.Message.From, m.Message.Nonce)
-	if m.Signature.Type == types.KTBLS {
+func (mp *MessagePool) addLocked(m *types.SignedMessage, strict bool) error {
+	log.Debugf("mpooladd: %s %d", m.Message.From, m.Message.Nonce)
+	if m.Signature.Type == crypto.SigTypeBLS {
 		mp.blsSigCache.Add(m.Cid(), m.Signature)
 	}
 
@@ -357,18 +706,44 @@ func (mp *MessagePool) addLocked(m *types.SignedMessage) error {
 
 	mset, ok := mp.pending[m.Message.From]
 	if !ok {
-		mset = newMsgSet()
+		nonce, err := mp.getStateNonce(m.Message.From, mp.curTs)
+		if err != nil {
+			return xerrors.Errorf("failed to get initial actor nonce: %w", err)
+		}
+
+		mset = newMsgSet(nonce)
 		mp.pending[m.Message.From] = mset
 	}
 
-	if err := mset.add(m); err != nil {
-		log.Error(err)
+	incr, err := mset.add(m, mp, strict)
+	if err != nil {
+		log.Debug(err)
+		return err
+	}
+
+	if incr {
+		mp.currentSize++
+		if mp.currentSize > mp.cfg.SizeLimitHigh {
+			// send signal to prune messages if it hasnt already been sent
+			select {
+			case mp.pruneTrigger <- struct{}{}:
+			default:
+			}
+		}
 	}
 
 	mp.changes.Pub(api.MpoolUpdate{
 		Type:    api.MpoolAdd,
 		Message: m,
 	}, localUpdates)
+
+	journal.J.RecordEvent(mp.evtTypes[evtTypeMpoolAdd], func() interface{} {
+		return MessagePoolEvt{
+			Action:   "add",
+			Messages: []MessagePoolEvtMessage{{Message: m.Message, CID: m.Cid()}},
+		}
+	})
+
 	return nil
 }
 
@@ -403,42 +778,16 @@ func (mp *MessagePool) getNonceLocked(addr address.Address, curTs *types.TipSet)
 }
 
 func (mp *MessagePool) getStateNonce(addr address.Address, curTs *types.TipSet) (uint64, error) {
-	// TODO: this method probably should be cached
-
-	act, err := mp.api.StateGetActor(addr, curTs)
+	act, err := mp.api.GetActorAfter(addr, curTs)
 	if err != nil {
 		return 0, err
 	}
 
-	baseNonce := act.Nonce
-
-	// TODO: the correct thing to do here is probably to set curTs to chain.head
-	// but since we have an accurate view of the world until a head change occurs,
-	// this should be fine
-	if curTs == nil {
-		return baseNonce, nil
-	}
-
-	msgs, err := mp.api.MessagesForTipset(curTs)
-	if err != nil {
-		return 0, xerrors.Errorf("failed to check messages for tipset: %w", err)
-	}
-
-	for _, m := range msgs {
-		msg := m.VMMessage()
-		if msg.From == addr {
-			if msg.Nonce != baseNonce {
-				return 0, xerrors.Errorf("tipset %s has bad nonce ordering (%d != %d)", curTs.Cids(), msg.Nonce, baseNonce)
-			}
-			baseNonce++
-		}
-	}
-
-	return baseNonce, nil
+	return act.Nonce, nil
 }
 
 func (mp *MessagePool) getStateBalance(addr address.Address, ts *types.TipSet) (types.BigInt, error) {
-	act, err := mp.api.StateGetActor(addr, ts)
+	act, err := mp.api.GetActorAfter(addr, ts)
 	if err != nil {
 		return types.EmptyInt, err
 	}
@@ -446,22 +795,46 @@ func (mp *MessagePool) getStateBalance(addr address.Address, ts *types.TipSet) (
 	return act.Balance, nil
 }
 
-func (mp *MessagePool) PushWithNonce(addr address.Address, cb func(uint64) (*types.SignedMessage, error)) (*types.SignedMessage, error) {
-	mp.curTsLk.Lock()
-	defer mp.curTsLk.Unlock()
+func (mp *MessagePool) PushWithNonce(ctx context.Context, addr address.Address, cb func(address.Address, uint64) (*types.SignedMessage, error)) (*types.SignedMessage, error) {
+	// serialize push access to reduce lock contention
+	mp.addSema <- struct{}{}
+	defer func() {
+		<-mp.addSema
+	}()
 
+	mp.curTsLk.Lock()
 	mp.lk.Lock()
-	defer mp.lk.Unlock()
-	if addr.Protocol() == address.ID {
-		log.Warnf("Called pushWithNonce with ID address (%s) this might not be handled properly yet", addr)
+
+	curTs := mp.curTs
+
+	fromKey := addr
+	if fromKey.Protocol() == address.ID {
+		var err error
+		fromKey, err = mp.api.StateAccountKey(ctx, fromKey, mp.curTs)
+		if err != nil {
+			mp.lk.Unlock()
+			mp.curTsLk.Unlock()
+			return nil, xerrors.Errorf("resolving sender key: %w", err)
+		}
 	}
 
-	nonce, err := mp.getNonceLocked(addr, mp.curTs)
+	nonce, err := mp.getNonceLocked(fromKey, mp.curTs)
+	if err != nil {
+		mp.lk.Unlock()
+		mp.curTsLk.Unlock()
+		return nil, xerrors.Errorf("get nonce locked failed: %w", err)
+	}
+
+	// release the locks for signing
+	mp.lk.Unlock()
+	mp.curTsLk.Unlock()
+
+	msg, err := cb(fromKey, nonce)
 	if err != nil {
 		return nil, err
 	}
 
-	msg, err := cb(nonce)
+	err = mp.checkMessage(msg)
 	if err != nil {
 		return nil, err
 	}
@@ -471,20 +844,57 @@ func (mp *MessagePool) PushWithNonce(addr address.Address, cb func(uint64) (*typ
 		return nil, err
 	}
 
-	if err := mp.addLocked(msg); err != nil {
+	// reacquire the locks and check state for consistency
+	mp.curTsLk.Lock()
+	defer mp.curTsLk.Unlock()
+
+	if mp.curTs != curTs {
+		return nil, ErrTryAgain
+	}
+
+	mp.lk.Lock()
+	defer mp.lk.Unlock()
+
+	nonce2, err := mp.getNonceLocked(fromKey, mp.curTs)
+	if err != nil {
+		return nil, xerrors.Errorf("get nonce locked failed: %w", err)
+	}
+
+	if nonce2 != nonce {
+		return nil, ErrTryAgain
+	}
+
+	publish, err := mp.verifyMsgBeforeAdd(msg, curTs, true)
+	if err != nil {
 		return nil, err
 	}
+
+	if err := mp.checkBalance(msg, curTs); err != nil {
+		return nil, err
+	}
+
+	if err := mp.addLocked(msg, false); err != nil {
+		return nil, xerrors.Errorf("add locked failed: %w", err)
+	}
 	if err := mp.addLocal(msg, msgb); err != nil {
 		log.Errorf("addLocal failed: %+v", err)
 	}
 
-	return msg, mp.api.PubSubPublish(msgTopic, msgb)
+	if publish {
+		err = mp.api.PubSubPublish(build.MessagesTopic(mp.netName), msgb)
+	}
+
+	return msg, err
 }
 
-func (mp *MessagePool) Remove(from address.Address, nonce uint64) {
+func (mp *MessagePool) Remove(from address.Address, nonce uint64, applied bool) {
 	mp.lk.Lock()
 	defer mp.lk.Unlock()
 
+	mp.remove(from, nonce, applied)
+}
+
+func (mp *MessagePool) remove(from address.Address, nonce uint64, applied bool) {
 	mset, ok := mp.pending[from]
 	if !ok {
 		return
@@ -495,26 +905,22 @@ func (mp *MessagePool) Remove(from address.Address, nonce uint64) {
 			Type:    api.MpoolRemove,
 			Message: m,
 		}, localUpdates)
+
+		journal.J.RecordEvent(mp.evtTypes[evtTypeMpoolRemove], func() interface{} {
+			return MessagePoolEvt{
+				Action:   "remove",
+				Messages: []MessagePoolEvtMessage{{Message: m.Message, CID: m.Cid()}}}
+		})
+
+		mp.currentSize--
 	}
 
 	// NB: This deletes any message with the given nonce. This makes sense
 	// as two messages with the same sender cannot have the same nonce
-	delete(mset.msgs, nonce)
+	mset.rm(nonce, applied)
 
 	if len(mset.msgs) == 0 {
 		delete(mp.pending, from)
-	} else {
-		var max uint64
-		for nonce := range mset.msgs {
-			if max < nonce {
-				max = nonce
-			}
-		}
-		if max < nonce {
-			max = nonce // we could have not seen the removed message before
-		}
-
-		mset.nextNonce = max + 1
 	}
 }
 
@@ -525,6 +931,10 @@ func (mp *MessagePool) Pending() ([]*types.SignedMessage, *types.TipSet) {
 	mp.lk.Lock()
 	defer mp.lk.Unlock()
 
+	return mp.allPending()
+}
+
+func (mp *MessagePool) allPending() ([]*types.SignedMessage, *types.TipSet) {
 	out := make([]*types.SignedMessage, 0)
 	for a := range mp.pending {
 		out = append(out, mp.pendingFor(a)...)
@@ -533,6 +943,15 @@ func (mp *MessagePool) Pending() ([]*types.SignedMessage, *types.TipSet) {
 	return out, mp.curTs
 }
 
+func (mp *MessagePool) PendingFor(a address.Address) ([]*types.SignedMessage, *types.TipSet) {
+	mp.curTsLk.Lock()
+	defer mp.curTsLk.Unlock()
+
+	mp.lk.Lock()
+	defer mp.lk.Unlock()
+	return mp.pendingFor(a), mp.curTs
+}
+
 func (mp *MessagePool) pendingFor(a address.Address) []*types.SignedMessage {
 	mset := mp.pending[a]
 	if mset == nil || len(mset.msgs) == 0 {
@@ -556,6 +975,7 @@ func (mp *MessagePool) HeadChange(revert []*types.TipSet, apply []*types.TipSet)
 	mp.curTsLk.Lock()
 	defer mp.curTsLk.Unlock()
 
+	repubTrigger := false
 	rmsgs := make(map[address.Address]map[uint64]*types.SignedMessage)
 	add := func(m *types.SignedMessage) {
 		s, ok := rmsgs[m.Message.From]
@@ -568,7 +988,7 @@ func (mp *MessagePool) HeadChange(revert []*types.TipSet, apply []*types.TipSet)
 	rm := func(from address.Address, nonce uint64) {
 		s, ok := rmsgs[from]
 		if !ok {
-			mp.Remove(from, nonce)
+			mp.Remove(from, nonce, true)
 			return
 		}
 
@@ -577,43 +997,73 @@ func (mp *MessagePool) HeadChange(revert []*types.TipSet, apply []*types.TipSet)
 			return
 		}
 
-		mp.Remove(from, nonce)
+		mp.Remove(from, nonce, true)
 	}
 
+	maybeRepub := func(cid cid.Cid) {
+		if !repubTrigger {
+			mp.lk.Lock()
+			_, republished := mp.republished[cid]
+			mp.lk.Unlock()
+			if republished {
+				repubTrigger = true
+			}
+		}
+	}
+
+	var merr error
+
 	for _, ts := range revert {
 		pts, err := mp.api.LoadTipSet(ts.Parents())
 		if err != nil {
-			return err
-		}
-
-		msgs, err := mp.MessagesForBlocks(ts.Blocks())
-		if err != nil {
-			return err
+			log.Errorf("error loading reverted tipset parent: %s", err)
+			merr = multierror.Append(merr, err)
+			continue
 		}
 
 		mp.curTs = pts
 
+		msgs, err := mp.MessagesForBlocks(ts.Blocks())
+		if err != nil {
+			log.Errorf("error retrieving messages for reverted block: %s", err)
+			merr = multierror.Append(merr, err)
+			continue
+		}
+
 		for _, msg := range msgs {
 			add(msg)
 		}
 	}
 
 	for _, ts := range apply {
+		mp.curTs = ts
+
 		for _, b := range ts.Blocks() {
 			bmsgs, smsgs, err := mp.api.MessagesForBlock(b)
 			if err != nil {
-				return xerrors.Errorf("failed to get messages for apply block %s(height %d) (msgroot = %s): %w", b.Cid(), b.Height, b.Messages, err)
+				xerr := xerrors.Errorf("failed to get messages for apply block %s(height %d) (msgroot = %s): %w", b.Cid(), b.Height, b.Messages, err)
+				log.Errorf("error retrieving messages for block: %s", xerr)
+				merr = multierror.Append(merr, xerr)
+				continue
 			}
+
 			for _, msg := range smsgs {
 				rm(msg.Message.From, msg.Message.Nonce)
+				maybeRepub(msg.Cid())
 			}
 
 			for _, msg := range bmsgs {
 				rm(msg.From, msg.Nonce)
+				maybeRepub(msg.Cid())
 			}
 		}
+	}
 
-		mp.curTs = ts
+	if repubTrigger {
+		select {
+		case mp.repubTrigger <- struct{}{}:
+		default:
+		}
 	}
 
 	for _, s := range rmsgs {
@@ -624,7 +1074,144 @@ func (mp *MessagePool) HeadChange(revert []*types.TipSet, apply []*types.TipSet)
 		}
 	}
 
-	return nil
+	if len(revert) > 0 && futureDebug {
+		mp.lk.Lock()
+		msgs, ts := mp.allPending()
+		mp.lk.Unlock()
+
+		buckets := map[address.Address]*statBucket{}
+
+		for _, v := range msgs {
+			bkt, ok := buckets[v.Message.From]
+			if !ok {
+				bkt = &statBucket{
+					msgs: map[uint64]*types.SignedMessage{},
+				}
+				buckets[v.Message.From] = bkt
+			}
+
+			bkt.msgs[v.Message.Nonce] = v
+		}
+
+		for a, bkt := range buckets {
+			// TODO that might not be correct with GatActorAfter but it is only debug code
+			act, err := mp.api.GetActorAfter(a, ts)
+			if err != nil {
+				log.Debugf("%s, err: %s\n", a, err)
+				continue
+			}
+
+			var cmsg *types.SignedMessage
+			var ok bool
+
+			cur := act.Nonce
+			for {
+				cmsg, ok = bkt.msgs[cur]
+				if !ok {
+					break
+				}
+				cur++
+			}
+
+			ff := uint64(math.MaxUint64)
+			for k := range bkt.msgs {
+				if k > cur && k < ff {
+					ff = k
+				}
+			}
+
+			if ff != math.MaxUint64 {
+				m := bkt.msgs[ff]
+
+				// cmsg can be nil if no messages from the current nonce are in the mpool
+				ccid := "nil"
+				if cmsg != nil {
+					ccid = cmsg.Cid().String()
+				}
+
+				log.Debugw("Nonce gap",
+					"actor", a,
+					"future_cid", m.Cid(),
+					"future_nonce", ff,
+					"current_cid", ccid,
+					"current_nonce", cur,
+					"revert_tipset", revert[0].Key(),
+					"new_head", ts.Key(),
+				)
+			}
+		}
+	}
+
+	return merr
+}
+
+func (mp *MessagePool) runHeadChange(from *types.TipSet, to *types.TipSet, rmsgs map[address.Address]map[uint64]*types.SignedMessage) error {
+	add := func(m *types.SignedMessage) {
+		s, ok := rmsgs[m.Message.From]
+		if !ok {
+			s = make(map[uint64]*types.SignedMessage)
+			rmsgs[m.Message.From] = s
+		}
+		s[m.Message.Nonce] = m
+	}
+	rm := func(from address.Address, nonce uint64) {
+		s, ok := rmsgs[from]
+		if !ok {
+			return
+		}
+
+		if _, ok := s[nonce]; ok {
+			delete(s, nonce)
+			return
+		}
+
+	}
+
+	revert, apply, err := store.ReorgOps(mp.api.LoadTipSet, from, to)
+	if err != nil {
+		return xerrors.Errorf("failed to compute reorg ops for mpool pending messages: %w", err)
+	}
+
+	var merr error
+
+	for _, ts := range revert {
+		msgs, err := mp.MessagesForBlocks(ts.Blocks())
+		if err != nil {
+			log.Errorf("error retrieving messages for reverted block: %s", err)
+			merr = multierror.Append(merr, err)
+			continue
+		}
+
+		for _, msg := range msgs {
+			add(msg)
+		}
+	}
+
+	for _, ts := range apply {
+		for _, b := range ts.Blocks() {
+			bmsgs, smsgs, err := mp.api.MessagesForBlock(b)
+			if err != nil {
+				xerr := xerrors.Errorf("failed to get messages for apply block %s(height %d) (msgroot = %s): %w", b.Cid(), b.Height, b.Messages, err)
+				log.Errorf("error retrieving messages for block: %s", xerr)
+				merr = multierror.Append(merr, xerr)
+				continue
+			}
+
+			for _, msg := range smsgs {
+				rm(msg.Message.From, msg.Message.Nonce)
+			}
+
+			for _, msg := range bmsgs {
+				rm(msg.From, msg.Nonce)
+			}
+		}
+	}
+
+	return merr
+}
+
+type statBucket struct {
+	msgs map[uint64]*types.SignedMessage
 }
 
 func (mp *MessagePool) MessagesForBlocks(blks []*types.BlockHeader) ([]*types.SignedMessage, error) {
@@ -655,7 +1242,7 @@ func (mp *MessagePool) RecoverSig(msg *types.Message) *types.SignedMessage {
 	if !ok {
 		return nil
 	}
-	sig, ok := val.(types.Signature)
+	sig, ok := val.(crypto.Signature)
 	if !ok {
 		log.Errorf("value in signature cache was not a signature (got %T)", val)
 		return nil
@@ -673,6 +1260,7 @@ func (mp *MessagePool) Updates(ctx context.Context) (<-chan api.MpoolUpdate, err
 
 	go func() {
 		defer mp.changes.Unsub(sub, localUpdates)
+		defer close(out)
 
 		for {
 			select {
@@ -681,9 +1269,13 @@ func (mp *MessagePool) Updates(ctx context.Context) (<-chan api.MpoolUpdate, err
 				case out <- u.(api.MpoolUpdate):
 				case <-ctx.Done():
 					return
+				case <-mp.closer:
+					return
 				}
 			case <-ctx.Done():
 				return
+			case <-mp.closer:
+				return
 			}
 		}
 	}()
@@ -707,14 +1299,62 @@ func (mp *MessagePool) loadLocal() error {
 			return xerrors.Errorf("unmarshaling local message: %w", err)
 		}
 
-		if err := mp.Add(&sm); err != nil {
+		if err := mp.addLoaded(&sm); err != nil {
 			if xerrors.Is(err, ErrNonceTooLow) {
 				continue // todo: drop the message from local cache (if above certain confidence threshold)
 			}
 
 			log.Errorf("adding local message: %+v", err)
 		}
+
+		mp.localAddrs[sm.Message.From] = struct{}{}
 	}
 
 	return nil
 }
+
+func (mp *MessagePool) Clear(local bool) {
+	mp.lk.Lock()
+	defer mp.lk.Unlock()
+
+	// remove everything if local is true, including removing local messages from
+	// the datastore
+	if local {
+		for a := range mp.localAddrs {
+			mset, ok := mp.pending[a]
+			if !ok {
+				continue
+			}
+
+			for _, m := range mset.msgs {
+				err := mp.localMsgs.Delete(datastore.NewKey(string(m.Cid().Bytes())))
+				if err != nil {
+					log.Warnf("error deleting local message: %s", err)
+				}
+			}
+		}
+
+		mp.pending = make(map[address.Address]*msgSet)
+		mp.republished = nil
+
+		return
+	}
+
+	// remove everything except the local messages
+	for a := range mp.pending {
+		_, isLocal := mp.localAddrs[a]
+		if isLocal {
+			continue
+		}
+		delete(mp.pending, a)
+	}
+}
+
+func getBaseFeeLowerBound(baseFee, factor types.BigInt) types.BigInt {
+	baseFeeLowerBound := types.BigDiv(baseFee, factor)
+	if baseFeeLowerBound.LessThan(minimumBaseFee) {
+		baseFeeLowerBound = minimumBaseFee
+	}
+
+	return baseFeeLowerBound
+}
diff --git a/chain/messagepool/messagepool_test.go b/chain/messagepool/messagepool_test.go
index 514806eb1..a4aa059ca 100644
--- a/chain/messagepool/messagepool_test.go
+++ b/chain/messagepool/messagepool_test.go
@@ -1,82 +1,166 @@
 package messagepool
 
 import (
+	"context"
 	"fmt"
+	"sort"
 	"testing"
 
 	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/lotus/chain/store"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/crypto"
+	"github.com/filecoin-project/lotus/chain/messagepool/gasguess"
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/chain/types/mock"
 	"github.com/filecoin-project/lotus/chain/wallet"
+	_ "github.com/filecoin-project/lotus/lib/sigs/bls"
+	_ "github.com/filecoin-project/lotus/lib/sigs/secp"
+	"github.com/filecoin-project/specs-actors/actors/builtin"
 	"github.com/ipfs/go-cid"
 	"github.com/ipfs/go-datastore"
+	logging "github.com/ipfs/go-log/v2"
 )
 
-type testMpoolApi struct {
+func init() {
+	_ = logging.SetLogLevel("*", "INFO")
+}
+
+type testMpoolAPI struct {
 	cb func(rev, app []*types.TipSet) error
 
 	bmsgs      map[cid.Cid][]*types.SignedMessage
 	statenonce map[address.Address]uint64
+	balance    map[address.Address]types.BigInt
 
 	tipsets []*types.TipSet
+
+	published int
+
+	baseFee types.BigInt
 }
 
-func newTestMpoolApi() *testMpoolApi {
-	return &testMpoolApi{
+func newTestMpoolAPI() *testMpoolAPI {
+	tma := &testMpoolAPI{
 		bmsgs:      make(map[cid.Cid][]*types.SignedMessage),
 		statenonce: make(map[address.Address]uint64),
+		balance:    make(map[address.Address]types.BigInt),
+		baseFee:    types.NewInt(100),
 	}
+	genesis := mock.MkBlock(nil, 1, 1)
+	tma.tipsets = append(tma.tipsets, mock.TipSet(genesis))
+	return tma
 }
 
-func (tma *testMpoolApi) applyBlock(t *testing.T, b *types.BlockHeader) {
+func (tma *testMpoolAPI) nextBlock() *types.BlockHeader {
+	newBlk := mock.MkBlock(tma.tipsets[len(tma.tipsets)-1], 1, 1)
+	tma.tipsets = append(tma.tipsets, mock.TipSet(newBlk))
+	return newBlk
+}
+
+func (tma *testMpoolAPI) nextBlockWithHeight(height uint64) *types.BlockHeader {
+	newBlk := mock.MkBlock(tma.tipsets[len(tma.tipsets)-1], 1, 1)
+	newBlk.Height = abi.ChainEpoch(height)
+	tma.tipsets = append(tma.tipsets, mock.TipSet(newBlk))
+	return newBlk
+}
+
+func (tma *testMpoolAPI) applyBlock(t *testing.T, b *types.BlockHeader) {
 	t.Helper()
 	if err := tma.cb(nil, []*types.TipSet{mock.TipSet(b)}); err != nil {
 		t.Fatal(err)
 	}
 }
 
-func (tma *testMpoolApi) revertBlock(t *testing.T, b *types.BlockHeader) {
+func (tma *testMpoolAPI) revertBlock(t *testing.T, b *types.BlockHeader) {
 	t.Helper()
 	if err := tma.cb([]*types.TipSet{mock.TipSet(b)}, nil); err != nil {
 		t.Fatal(err)
 	}
 }
 
-func (tma *testMpoolApi) setStateNonce(addr address.Address, v uint64) {
+func (tma *testMpoolAPI) setStateNonce(addr address.Address, v uint64) {
 	tma.statenonce[addr] = v
 }
 
-func (tma *testMpoolApi) setBlockMessages(h *types.BlockHeader, msgs ...*types.SignedMessage) {
+func (tma *testMpoolAPI) setBalance(addr address.Address, v uint64) {
+	tma.balance[addr] = types.FromFil(v)
+}
+
+func (tma *testMpoolAPI) setBalanceRaw(addr address.Address, v types.BigInt) {
+	tma.balance[addr] = v
+}
+
+func (tma *testMpoolAPI) setBlockMessages(h *types.BlockHeader, msgs ...*types.SignedMessage) {
 	tma.bmsgs[h.Cid()] = msgs
-	tma.tipsets = append(tma.tipsets, mock.TipSet(h))
 }
 
-func (tma *testMpoolApi) SubscribeHeadChanges(cb func(rev, app []*types.TipSet) error) *types.TipSet {
+func (tma *testMpoolAPI) SubscribeHeadChanges(cb func(rev, app []*types.TipSet) error) *types.TipSet {
 	tma.cb = cb
-	return nil
+	return tma.tipsets[0]
 }
 
-func (tma *testMpoolApi) PutMessage(m store.ChainMsg) (cid.Cid, error) {
+func (tma *testMpoolAPI) PutMessage(m types.ChainMsg) (cid.Cid, error) {
 	return cid.Undef, nil
 }
 
-func (tma *testMpoolApi) PubSubPublish(string, []byte) error {
+func (tma *testMpoolAPI) PubSubPublish(string, []byte) error {
+	tma.published++
 	return nil
 }
 
-func (tma *testMpoolApi) StateGetActor(addr address.Address, ts *types.TipSet) (*types.Actor, error) {
+func (tma *testMpoolAPI) GetActorAfter(addr address.Address, ts *types.TipSet) (*types.Actor, error) {
+	// regression check for load bug
+	if ts == nil {
+		panic("GetActorAfter called with nil tipset")
+	}
+
+	balance, ok := tma.balance[addr]
+	if !ok {
+		balance = types.NewInt(1000e6)
+		tma.balance[addr] = balance
+	}
+
+	msgs := make([]*types.SignedMessage, 0)
+	for _, b := range ts.Blocks() {
+		for _, m := range tma.bmsgs[b.Cid()] {
+			if m.Message.From == addr {
+				msgs = append(msgs, m)
+			}
+		}
+	}
+
+	sort.Slice(msgs, func(i, j int) bool {
+		return msgs[i].Message.Nonce < msgs[j].Message.Nonce
+	})
+
+	nonce := tma.statenonce[addr]
+
+	for _, m := range msgs {
+		if m.Message.Nonce != nonce {
+			break
+		}
+		nonce++
+	}
+
 	return &types.Actor{
-		Nonce:   tma.statenonce[addr],
-		Balance: types.NewInt(90000000),
+		Code:    builtin.StorageMarketActorCodeID,
+		Nonce:   nonce,
+		Balance: balance,
 	}, nil
 }
 
-func (tma *testMpoolApi) MessagesForBlock(h *types.BlockHeader) ([]*types.Message, []*types.SignedMessage, error) {
+func (tma *testMpoolAPI) StateAccountKey(ctx context.Context, addr address.Address, ts *types.TipSet) (address.Address, error) {
+	if addr.Protocol() != address.BLS && addr.Protocol() != address.SECP256K1 {
+		return address.Undef, fmt.Errorf("given address was not a key addr")
+	}
+	return addr, nil
+}
+
+func (tma *testMpoolAPI) MessagesForBlock(h *types.BlockHeader) ([]*types.Message, []*types.SignedMessage, error) {
 	return nil, tma.bmsgs[h.Cid()], nil
 }
 
-func (tma *testMpoolApi) MessagesForTipset(ts *types.TipSet) ([]store.ChainMsg, error) {
+func (tma *testMpoolAPI) MessagesForTipset(ts *types.TipSet) ([]types.ChainMsg, error) {
 	if len(ts.Blocks()) != 1 {
 		panic("cant deal with multiblock tipsets in this test")
 	}
@@ -86,7 +170,7 @@ func (tma *testMpoolApi) MessagesForTipset(ts *types.TipSet) ([]store.ChainMsg,
 		return nil, err
 	}
 
-	var out []store.ChainMsg
+	var out []types.ChainMsg
 	for _, m := range bm {
 		out = append(out, m)
 	}
@@ -98,7 +182,7 @@ func (tma *testMpoolApi) MessagesForTipset(ts *types.TipSet) ([]store.ChainMsg,
 	return out, nil
 }
 
-func (tma *testMpoolApi) LoadTipSet(tsk types.TipSetKey) (*types.TipSet, error) {
+func (tma *testMpoolAPI) LoadTipSet(tsk types.TipSetKey) (*types.TipSet, error) {
 	for _, ts := range tma.tipsets {
 		if types.CidArrsEqual(tsk.Cids(), ts.Cids()) {
 			return ts, nil
@@ -108,6 +192,10 @@ func (tma *testMpoolApi) LoadTipSet(tsk types.TipSetKey) (*types.TipSet, error)
 	return nil, fmt.Errorf("tipset not found")
 }
 
+func (tma *testMpoolAPI) ChainComputeBaseFee(ctx context.Context, ts *types.TipSet) (types.BigInt, error) {
+	return tma.baseFee, nil
+}
+
 func assertNonce(t *testing.T, mp *MessagePool, addr address.Address, val uint64) {
 	t.Helper()
 	n, err := mp.GetNonce(addr)
@@ -128,7 +216,7 @@ func mustAdd(t *testing.T, mp *MessagePool, msg *types.SignedMessage) {
 }
 
 func TestMessagePool(t *testing.T) {
-	tma := newTestMpoolApi()
+	tma := newTestMpoolAPI()
 
 	w, err := wallet.NewWallet(wallet.NewMemKeyStore())
 	if err != nil {
@@ -137,14 +225,14 @@ func TestMessagePool(t *testing.T) {
 
 	ds := datastore.NewMapDatastore()
 
-	mp, err := New(tma, ds)
+	mp, err := New(tma, ds, "mptest")
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	a := mock.MkBlock(nil, 1, 1)
+	a := tma.nextBlock()
 
-	sender, err := w.GenerateKey(types.KTBLS)
+	sender, err := w.GenerateKey(crypto.SigTypeBLS)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -168,8 +256,8 @@ func TestMessagePool(t *testing.T) {
 	assertNonce(t, mp, sender, 2)
 }
 
-func TestRevertMessages(t *testing.T) {
-	tma := newTestMpoolApi()
+func TestMessagePoolMessagesInEachBlock(t *testing.T) {
+	tma := newTestMpoolAPI()
 
 	w, err := wallet.NewWallet(wallet.NewMemKeyStore())
 	if err != nil {
@@ -178,15 +266,64 @@ func TestRevertMessages(t *testing.T) {
 
 	ds := datastore.NewMapDatastore()
 
-	mp, err := New(tma, ds)
+	mp, err := New(tma, ds, "mptest")
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	a := mock.MkBlock(nil, 1, 1)
-	b := mock.MkBlock(mock.TipSet(a), 1, 1)
+	a := tma.nextBlock()
 
-	sender, err := w.GenerateKey(types.KTBLS)
+	sender, err := w.GenerateKey(crypto.SigTypeBLS)
+	if err != nil {
+		t.Fatal(err)
+	}
+	target := mock.Address(1001)
+
+	var msgs []*types.SignedMessage
+	for i := 0; i < 5; i++ {
+		m := mock.MkMessage(sender, target, uint64(i), w)
+		msgs = append(msgs, m)
+		mustAdd(t, mp, m)
+	}
+
+	tma.setStateNonce(sender, 0)
+
+	tma.setBlockMessages(a, msgs[0], msgs[1])
+	tma.applyBlock(t, a)
+	tsa := mock.TipSet(a)
+
+	_, _ = mp.Pending()
+
+	selm, _ := mp.SelectMessages(tsa, 1)
+	if len(selm) == 0 {
+		t.Fatal("should have returned the rest of the messages")
+	}
+}
+
+func TestRevertMessages(t *testing.T) {
+	futureDebug = true
+	defer func() {
+		futureDebug = false
+	}()
+
+	tma := newTestMpoolAPI()
+
+	w, err := wallet.NewWallet(wallet.NewMemKeyStore())
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	ds := datastore.NewMapDatastore()
+
+	mp, err := New(tma, ds, "mptest")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	a := tma.nextBlock()
+	b := tma.nextBlock()
+
+	sender, err := w.GenerateKey(crypto.SigTypeBLS)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -218,8 +355,319 @@ func TestRevertMessages(t *testing.T) {
 	assertNonce(t, mp, sender, 4)
 
 	p, _ := mp.Pending()
+	fmt.Printf("%+v\n", p)
 	if len(p) != 3 {
 		t.Fatal("expected three messages in mempool")
 	}
 
 }
+
+func TestPruningSimple(t *testing.T) {
+	oldMaxNonceGap := MaxNonceGap
+	MaxNonceGap = 1000
+	defer func() {
+		MaxNonceGap = oldMaxNonceGap
+	}()
+
+	tma := newTestMpoolAPI()
+
+	w, err := wallet.NewWallet(wallet.NewMemKeyStore())
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	ds := datastore.NewMapDatastore()
+
+	mp, err := New(tma, ds, "mptest")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	a := tma.nextBlock()
+	tma.applyBlock(t, a)
+
+	sender, err := w.GenerateKey(crypto.SigTypeBLS)
+	if err != nil {
+		t.Fatal(err)
+	}
+	tma.setBalance(sender, 1) // in FIL
+	target := mock.Address(1001)
+
+	for i := 0; i < 5; i++ {
+		smsg := mock.MkMessage(sender, target, uint64(i), w)
+		if err := mp.Add(smsg); err != nil {
+			t.Fatal(err)
+		}
+	}
+
+	for i := 10; i < 50; i++ {
+		smsg := mock.MkMessage(sender, target, uint64(i), w)
+		if err := mp.Add(smsg); err != nil {
+			t.Fatal(err)
+		}
+	}
+
+	mp.cfg.SizeLimitHigh = 40
+	mp.cfg.SizeLimitLow = 10
+
+	mp.Prune()
+
+	msgs, _ := mp.Pending()
+	if len(msgs) != 5 {
+		t.Fatal("expected only 5 messages in pool, got: ", len(msgs))
+	}
+}
+
+func TestLoadLocal(t *testing.T) {
+	tma := newTestMpoolAPI()
+	ds := datastore.NewMapDatastore()
+
+	mp, err := New(tma, ds, "mptest")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// the actors
+	w1, err := wallet.NewWallet(wallet.NewMemKeyStore())
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	a1, err := w1.GenerateKey(crypto.SigTypeSecp256k1)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	w2, err := wallet.NewWallet(wallet.NewMemKeyStore())
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	a2, err := w2.GenerateKey(crypto.SigTypeSecp256k1)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	tma.setBalance(a1, 1) // in FIL
+	tma.setBalance(a2, 1) // in FIL
+	gasLimit := gasguess.Costs[gasguess.CostKey{Code: builtin.StorageMarketActorCodeID, M: 2}]
+	msgs := make(map[cid.Cid]struct{})
+	for i := 0; i < 10; i++ {
+		m := makeTestMessage(w1, a1, a2, uint64(i), gasLimit, uint64(i+1))
+		cid, err := mp.Push(m)
+		if err != nil {
+			t.Fatal(err)
+		}
+		msgs[cid] = struct{}{}
+	}
+	err = mp.Close()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	mp, err = New(tma, ds, "mptest")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	pmsgs, _ := mp.Pending()
+	if len(msgs) != len(pmsgs) {
+		t.Fatalf("expected %d messages, but got %d", len(msgs), len(pmsgs))
+	}
+
+	for _, m := range pmsgs {
+		cid := m.Cid()
+		_, ok := msgs[cid]
+		if !ok {
+			t.Fatal("unknown message")
+		}
+
+		delete(msgs, cid)
+	}
+
+	if len(msgs) > 0 {
+		t.Fatalf("not all messages were laoded; missing %d messages", len(msgs))
+	}
+}
+
+func TestClearAll(t *testing.T) {
+	tma := newTestMpoolAPI()
+	ds := datastore.NewMapDatastore()
+
+	mp, err := New(tma, ds, "mptest")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// the actors
+	w1, err := wallet.NewWallet(wallet.NewMemKeyStore())
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	a1, err := w1.GenerateKey(crypto.SigTypeSecp256k1)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	w2, err := wallet.NewWallet(wallet.NewMemKeyStore())
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	a2, err := w2.GenerateKey(crypto.SigTypeSecp256k1)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	tma.setBalance(a1, 1) // in FIL
+	tma.setBalance(a2, 1) // in FIL
+	gasLimit := gasguess.Costs[gasguess.CostKey{Code: builtin.StorageMarketActorCodeID, M: 2}]
+	for i := 0; i < 10; i++ {
+		m := makeTestMessage(w1, a1, a2, uint64(i), gasLimit, uint64(i+1))
+		_, err := mp.Push(m)
+		if err != nil {
+			t.Fatal(err)
+		}
+	}
+
+	for i := 0; i < 10; i++ {
+		m := makeTestMessage(w2, a2, a1, uint64(i), gasLimit, uint64(i+1))
+		mustAdd(t, mp, m)
+	}
+
+	mp.Clear(true)
+
+	pending, _ := mp.Pending()
+	if len(pending) > 0 {
+		t.Fatalf("cleared the mpool, but got %d pending messages", len(pending))
+	}
+}
+
+func TestClearNonLocal(t *testing.T) {
+	tma := newTestMpoolAPI()
+	ds := datastore.NewMapDatastore()
+
+	mp, err := New(tma, ds, "mptest")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// the actors
+	w1, err := wallet.NewWallet(wallet.NewMemKeyStore())
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	a1, err := w1.GenerateKey(crypto.SigTypeSecp256k1)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	w2, err := wallet.NewWallet(wallet.NewMemKeyStore())
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	a2, err := w2.GenerateKey(crypto.SigTypeSecp256k1)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	tma.setBalance(a1, 1) // in FIL
+	tma.setBalance(a2, 1) // in FIL
+
+	gasLimit := gasguess.Costs[gasguess.CostKey{Code: builtin.StorageMarketActorCodeID, M: 2}]
+	for i := 0; i < 10; i++ {
+		m := makeTestMessage(w1, a1, a2, uint64(i), gasLimit, uint64(i+1))
+		_, err := mp.Push(m)
+		if err != nil {
+			t.Fatal(err)
+		}
+	}
+
+	for i := 0; i < 10; i++ {
+		m := makeTestMessage(w2, a2, a1, uint64(i), gasLimit, uint64(i+1))
+		mustAdd(t, mp, m)
+	}
+
+	mp.Clear(false)
+
+	pending, _ := mp.Pending()
+	if len(pending) != 10 {
+		t.Fatalf("expected 10 pending messages, but got %d instead", len(pending))
+	}
+
+	for _, m := range pending {
+		if m.Message.From != a1 {
+			t.Fatalf("expected message from %s but got one from %s instead", a1, m.Message.From)
+		}
+	}
+}
+
+func TestUpdates(t *testing.T) {
+	tma := newTestMpoolAPI()
+	ds := datastore.NewMapDatastore()
+
+	mp, err := New(tma, ds, "mptest")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// the actors
+	w1, err := wallet.NewWallet(wallet.NewMemKeyStore())
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	a1, err := w1.GenerateKey(crypto.SigTypeSecp256k1)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	w2, err := wallet.NewWallet(wallet.NewMemKeyStore())
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	a2, err := w2.GenerateKey(crypto.SigTypeSecp256k1)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	ctx, cancel := context.WithCancel(context.TODO())
+	defer cancel()
+
+	ch, err := mp.Updates(ctx)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	gasLimit := gasguess.Costs[gasguess.CostKey{Code: builtin.StorageMarketActorCodeID, M: 2}]
+
+	tma.setBalance(a1, 1) // in FIL
+	tma.setBalance(a2, 1) // in FIL
+
+	for i := 0; i < 10; i++ {
+		m := makeTestMessage(w1, a1, a2, uint64(i), gasLimit, uint64(i+1))
+		_, err := mp.Push(m)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		_, ok := <-ch
+		if !ok {
+			t.Fatal("expected update, but got a closed channel instead")
+		}
+	}
+
+	err = mp.Close()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	_, ok := <-ch
+	if ok {
+		t.Fatal("expected closed channel, but got an update instead")
+	}
+}
diff --git a/chain/messagepool/provider.go b/chain/messagepool/provider.go
new file mode 100644
index 000000000..347e90044
--- /dev/null
+++ b/chain/messagepool/provider.go
@@ -0,0 +1,83 @@
+package messagepool
+
+import (
+	"context"
+
+	"github.com/ipfs/go-cid"
+	pubsub "github.com/libp2p/go-libp2p-pubsub"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/lotus/chain/stmgr"
+	"github.com/filecoin-project/lotus/chain/types"
+)
+
+type Provider interface {
+	SubscribeHeadChanges(func(rev, app []*types.TipSet) error) *types.TipSet
+	PutMessage(m types.ChainMsg) (cid.Cid, error)
+	PubSubPublish(string, []byte) error
+	GetActorAfter(address.Address, *types.TipSet) (*types.Actor, error)
+	StateAccountKey(context.Context, address.Address, *types.TipSet) (address.Address, error)
+	MessagesForBlock(*types.BlockHeader) ([]*types.Message, []*types.SignedMessage, error)
+	MessagesForTipset(*types.TipSet) ([]types.ChainMsg, error)
+	LoadTipSet(tsk types.TipSetKey) (*types.TipSet, error)
+	ChainComputeBaseFee(ctx context.Context, ts *types.TipSet) (types.BigInt, error)
+}
+
+type mpoolProvider struct {
+	sm *stmgr.StateManager
+	ps *pubsub.PubSub
+}
+
+func NewProvider(sm *stmgr.StateManager, ps *pubsub.PubSub) Provider {
+	return &mpoolProvider{sm: sm, ps: ps}
+}
+
+func (mpp *mpoolProvider) SubscribeHeadChanges(cb func(rev, app []*types.TipSet) error) *types.TipSet {
+	mpp.sm.ChainStore().SubscribeHeadChanges(cb)
+	return mpp.sm.ChainStore().GetHeaviestTipSet()
+}
+
+func (mpp *mpoolProvider) PutMessage(m types.ChainMsg) (cid.Cid, error) {
+	return mpp.sm.ChainStore().PutMessage(m)
+}
+
+func (mpp *mpoolProvider) PubSubPublish(k string, v []byte) error {
+	return mpp.ps.Publish(k, v) //nolint
+}
+
+func (mpp *mpoolProvider) GetActorAfter(addr address.Address, ts *types.TipSet) (*types.Actor, error) {
+	stcid, _, err := mpp.sm.TipSetState(context.TODO(), ts)
+	if err != nil {
+		return nil, xerrors.Errorf("computing tipset state for GetActor: %w", err)
+	}
+	st, err := mpp.sm.StateTree(stcid)
+	if err != nil {
+		return nil, xerrors.Errorf("failed to load state tree: %w", err)
+	}
+	return st.GetActor(addr)
+}
+
+func (mpp *mpoolProvider) StateAccountKey(ctx context.Context, addr address.Address, ts *types.TipSet) (address.Address, error) {
+	return mpp.sm.ResolveToKeyAddress(ctx, addr, ts)
+}
+
+func (mpp *mpoolProvider) MessagesForBlock(h *types.BlockHeader) ([]*types.Message, []*types.SignedMessage, error) {
+	return mpp.sm.ChainStore().MessagesForBlock(h)
+}
+
+func (mpp *mpoolProvider) MessagesForTipset(ts *types.TipSet) ([]types.ChainMsg, error) {
+	return mpp.sm.ChainStore().MessagesForTipset(ts)
+}
+
+func (mpp *mpoolProvider) LoadTipSet(tsk types.TipSetKey) (*types.TipSet, error) {
+	return mpp.sm.ChainStore().LoadTipSet(tsk)
+}
+
+func (mpp *mpoolProvider) ChainComputeBaseFee(ctx context.Context, ts *types.TipSet) (types.BigInt, error) {
+	baseFee, err := mpp.sm.ChainStore().ComputeBaseFee(ctx, ts)
+	if err != nil {
+		return types.NewInt(0), xerrors.Errorf("computing base fee at %s: %w", ts, err)
+	}
+	return baseFee, nil
+}
diff --git a/chain/messagepool/pruning.go b/chain/messagepool/pruning.go
new file mode 100644
index 000000000..d0e53795a
--- /dev/null
+++ b/chain/messagepool/pruning.go
@@ -0,0 +1,113 @@
+package messagepool
+
+import (
+	"context"
+	"sort"
+	"time"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/ipfs/go-cid"
+	"golang.org/x/xerrors"
+)
+
+func (mp *MessagePool) pruneExcessMessages() error {
+	mp.curTsLk.Lock()
+	ts := mp.curTs
+	mp.curTsLk.Unlock()
+
+	mp.lk.Lock()
+	defer mp.lk.Unlock()
+
+	if mp.currentSize < mp.cfg.SizeLimitHigh {
+		return nil
+	}
+
+	select {
+	case <-mp.pruneCooldown:
+		err := mp.pruneMessages(context.TODO(), ts)
+		go func() {
+			time.Sleep(mp.cfg.PruneCooldown)
+			mp.pruneCooldown <- struct{}{}
+		}()
+		return err
+	default:
+		return xerrors.New("cannot prune before cooldown")
+	}
+}
+
+func (mp *MessagePool) pruneMessages(ctx context.Context, ts *types.TipSet) error {
+	start := time.Now()
+	defer func() {
+		log.Infof("message pruning took %s", time.Since(start))
+	}()
+
+	baseFee, err := mp.api.ChainComputeBaseFee(ctx, ts)
+	if err != nil {
+		return xerrors.Errorf("computing basefee: %w", err)
+	}
+	baseFeeLowerBound := getBaseFeeLowerBound(baseFee, baseFeeLowerBoundFactor)
+
+	pending, _ := mp.getPendingMessages(ts, ts)
+
+	// protected actors -- not pruned
+	protected := make(map[address.Address]struct{})
+
+	// we never prune priority addresses
+	for _, actor := range mp.cfg.PriorityAddrs {
+		protected[actor] = struct{}{}
+	}
+
+	// we also never prune locally published messages
+	for actor := range mp.localAddrs {
+		protected[actor] = struct{}{}
+	}
+
+	// Collect all messages to track which ones to remove and create chains for block inclusion
+	pruneMsgs := make(map[cid.Cid]*types.SignedMessage, mp.currentSize)
+	keepCount := 0
+
+	var chains []*msgChain
+	for actor, mset := range pending {
+		// we never prune protected actors
+		_, keep := protected[actor]
+		if keep {
+			keepCount += len(mset)
+			continue
+		}
+
+		// not a protected actor, track the messages and create chains
+		for _, m := range mset {
+			pruneMsgs[m.Message.Cid()] = m
+		}
+		actorChains := mp.createMessageChains(actor, mset, baseFeeLowerBound, ts)
+		chains = append(chains, actorChains...)
+	}
+
+	// Sort the chains
+	sort.Slice(chains, func(i, j int) bool {
+		return chains[i].Before(chains[j])
+	})
+
+	// Keep messages (remove them from pruneMsgs) from chains while we are under the low water mark
+	loWaterMark := mp.cfg.SizeLimitLow
+keepLoop:
+	for _, chain := range chains {
+		for _, m := range chain.msgs {
+			if keepCount < loWaterMark {
+				delete(pruneMsgs, m.Message.Cid())
+				keepCount++
+			} else {
+				break keepLoop
+			}
+		}
+	}
+
+	// and remove all messages that are still in pruneMsgs after processing the chains
+	log.Infof("Pruning %d messages", len(pruneMsgs))
+	for _, m := range pruneMsgs {
+		mp.remove(m.Message.From, m.Message.Nonce, false)
+	}
+
+	return nil
+}
diff --git a/chain/messagepool/repub.go b/chain/messagepool/repub.go
new file mode 100644
index 000000000..db31e18c2
--- /dev/null
+++ b/chain/messagepool/repub.go
@@ -0,0 +1,175 @@
+package messagepool
+
+import (
+	"context"
+	"sort"
+	"time"
+
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/messagepool/gasguess"
+	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/journal"
+	"github.com/ipfs/go-cid"
+)
+
+const repubMsgLimit = 30
+
+var RepublishBatchDelay = 100 * time.Millisecond
+
+func (mp *MessagePool) republishPendingMessages() error {
+	mp.curTsLk.Lock()
+	ts := mp.curTs
+
+	baseFee, err := mp.api.ChainComputeBaseFee(context.TODO(), ts)
+	if err != nil {
+		mp.curTsLk.Unlock()
+		return xerrors.Errorf("computing basefee: %w", err)
+	}
+	baseFeeLowerBound := getBaseFeeLowerBound(baseFee, baseFeeLowerBoundFactor)
+
+	pending := make(map[address.Address]map[uint64]*types.SignedMessage)
+	mp.lk.Lock()
+	mp.republished = nil // clear this to avoid races triggering an early republish
+	for actor := range mp.localAddrs {
+		mset, ok := mp.pending[actor]
+		if !ok {
+			continue
+		}
+		if len(mset.msgs) == 0 {
+			continue
+		}
+		// we need to copy this while holding the lock to avoid races with concurrent modification
+		pend := make(map[uint64]*types.SignedMessage, len(mset.msgs))
+		for nonce, m := range mset.msgs {
+			pend[nonce] = m
+		}
+		pending[actor] = pend
+	}
+	mp.lk.Unlock()
+	mp.curTsLk.Unlock()
+
+	if len(pending) == 0 {
+		return nil
+	}
+
+	var chains []*msgChain
+	for actor, mset := range pending {
+		// We use the baseFee lower bound for createChange so that we optimistically include
+		// chains that might become profitable in the next 20 blocks.
+		// We still check the lowerBound condition for individual messages so that we don't send
+		// messages that will be rejected by the mpool spam protector, so this is safe to do.
+		next := mp.createMessageChains(actor, mset, baseFeeLowerBound, ts)
+		chains = append(chains, next...)
+	}
+
+	if len(chains) == 0 {
+		return nil
+	}
+
+	sort.Slice(chains, func(i, j int) bool {
+		return chains[i].Before(chains[j])
+	})
+
+	gasLimit := int64(build.BlockGasLimit)
+	minGas := int64(gasguess.MinGas)
+	var msgs []*types.SignedMessage
+loop:
+	for i := 0; i < len(chains); {
+		chain := chains[i]
+
+		// we can exceed this if we have picked (some) longer chain already
+		if len(msgs) > repubMsgLimit {
+			break
+		}
+
+		// there is not enough gas for any message
+		if gasLimit <= minGas {
+			break
+		}
+
+		// has the chain been invalidated?
+		if !chain.valid {
+			i++
+			continue
+		}
+
+		// does it fit in a block?
+		if chain.gasLimit <= gasLimit {
+			// check the baseFee lower bound -- only republish messages that can be included in the chain
+			// within the next 20 blocks.
+			for _, m := range chain.msgs {
+				if !allowNegativeChains(ts.Height()) && m.Message.GasFeeCap.LessThan(baseFeeLowerBound) {
+					chain.Invalidate()
+					continue loop
+				}
+				gasLimit -= m.Message.GasLimit
+				msgs = append(msgs, m)
+			}
+
+			// we processed the whole chain, advance
+			i++
+			continue
+		}
+
+		// we can't fit the current chain but there is gas to spare
+		// trim it and push it down
+		chain.Trim(gasLimit, mp, baseFee, true)
+		for j := i; j < len(chains)-1; j++ {
+			if chains[j].Before(chains[j+1]) {
+				break
+			}
+			chains[j], chains[j+1] = chains[j+1], chains[j]
+		}
+	}
+
+	count := 0
+	log.Infof("republishing %d messages", len(msgs))
+	for _, m := range msgs {
+		mb, err := m.Serialize()
+		if err != nil {
+			return xerrors.Errorf("cannot serialize message: %w", err)
+		}
+
+		err = mp.api.PubSubPublish(build.MessagesTopic(mp.netName), mb)
+		if err != nil {
+			return xerrors.Errorf("cannot publish: %w", err)
+		}
+
+		count++
+
+		if count < len(msgs) {
+			// this delay is here to encourage the pubsub subsystem to process the messages serially
+			// and avoid creating nonce gaps because of concurrent validation.
+			time.Sleep(RepublishBatchDelay)
+		}
+	}
+
+	if len(msgs) > 0 {
+		journal.J.RecordEvent(mp.evtTypes[evtTypeMpoolRepub], func() interface{} {
+			msgs := make([]MessagePoolEvtMessage, 0, len(msgs))
+			for _, m := range msgs {
+				msgs = append(msgs, MessagePoolEvtMessage{Message: m.Message, CID: m.Cid()})
+			}
+			return MessagePoolEvt{
+				Action:   "repub",
+				Messages: msgs,
+			}
+		})
+	}
+
+	// track most recently republished messages
+	republished := make(map[cid.Cid]struct{})
+	for _, m := range msgs[:count] {
+		republished[m.Cid()] = struct{}{}
+	}
+
+	mp.lk.Lock()
+	// update the republished set so that we can trigger early republish from head changes
+	mp.republished = republished
+	mp.lk.Unlock()
+
+	return nil
+}
diff --git a/chain/messagepool/repub_test.go b/chain/messagepool/repub_test.go
new file mode 100644
index 000000000..491f484f5
--- /dev/null
+++ b/chain/messagepool/repub_test.go
@@ -0,0 +1,72 @@
+package messagepool
+
+import (
+	"testing"
+	"time"
+
+	"github.com/filecoin-project/go-state-types/crypto"
+	"github.com/filecoin-project/lotus/chain/messagepool/gasguess"
+	"github.com/filecoin-project/lotus/chain/wallet"
+	"github.com/filecoin-project/specs-actors/actors/builtin"
+	"github.com/ipfs/go-datastore"
+)
+
+func TestRepubMessages(t *testing.T) {
+	oldRepublishBatchDelay := RepublishBatchDelay
+	RepublishBatchDelay = time.Microsecond
+	defer func() {
+		RepublishBatchDelay = oldRepublishBatchDelay
+	}()
+
+	tma := newTestMpoolAPI()
+	ds := datastore.NewMapDatastore()
+
+	mp, err := New(tma, ds, "mptest")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// the actors
+	w1, err := wallet.NewWallet(wallet.NewMemKeyStore())
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	a1, err := w1.GenerateKey(crypto.SigTypeSecp256k1)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	w2, err := wallet.NewWallet(wallet.NewMemKeyStore())
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	a2, err := w2.GenerateKey(crypto.SigTypeSecp256k1)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	gasLimit := gasguess.Costs[gasguess.CostKey{Code: builtin.StorageMarketActorCodeID, M: 2}]
+
+	tma.setBalance(a1, 1) // in FIL
+
+	for i := 0; i < 10; i++ {
+		m := makeTestMessage(w1, a1, a2, uint64(i), gasLimit, uint64(i+1))
+		_, err := mp.Push(m)
+		if err != nil {
+			t.Fatal(err)
+		}
+	}
+
+	if tma.published != 10 {
+		t.Fatalf("expected to have published 10 messages, but got %d instead", tma.published)
+	}
+
+	mp.repubTrigger <- struct{}{}
+	time.Sleep(100 * time.Millisecond)
+
+	if tma.published != 20 {
+		t.Fatalf("expected to have published 20 messages, but got %d instead", tma.published)
+	}
+}
diff --git a/chain/messagepool/selection.go b/chain/messagepool/selection.go
new file mode 100644
index 000000000..2ddbed0ad
--- /dev/null
+++ b/chain/messagepool/selection.go
@@ -0,0 +1,939 @@
+package messagepool
+
+import (
+	"context"
+	"math/big"
+	"math/rand"
+	"sort"
+	"time"
+
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/abi"
+	tbig "github.com/filecoin-project/go-state-types/big"
+	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/messagepool/gasguess"
+	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/chain/vm"
+)
+
+var bigBlockGasLimit = big.NewInt(build.BlockGasLimit)
+
+// this is *temporary* mutilation until we have implemented uncapped miner penalties -- it will go
+// away in the next fork.
+func allowNegativeChains(epoch abi.ChainEpoch) bool {
+	return epoch < build.UpgradeBreezeHeight+5
+}
+
+const MaxBlocks = 15
+
+type msgChain struct {
+	msgs         []*types.SignedMessage
+	gasReward    *big.Int
+	gasLimit     int64
+	gasPerf      float64
+	effPerf      float64
+	bp           float64
+	parentOffset float64
+	valid        bool
+	merged       bool
+	next         *msgChain
+	prev         *msgChain
+}
+
+func (mp *MessagePool) SelectMessages(ts *types.TipSet, tq float64) ([]*types.SignedMessage, error) {
+	mp.curTsLk.Lock()
+	defer mp.curTsLk.Unlock()
+
+	mp.lk.Lock()
+	defer mp.lk.Unlock()
+
+	// if the ticket quality is high enough that the first block has higher probability
+	// than any other block, then we don't bother with optimal selection because the
+	// first block will always have higher effective performance
+	if tq > 0.84 {
+		return mp.selectMessagesGreedy(mp.curTs, ts)
+	}
+
+	return mp.selectMessagesOptimal(mp.curTs, ts, tq)
+}
+
+func (mp *MessagePool) selectMessagesOptimal(curTs, ts *types.TipSet, tq float64) ([]*types.SignedMessage, error) {
+	start := time.Now()
+
+	baseFee, err := mp.api.ChainComputeBaseFee(context.TODO(), ts)
+	if err != nil {
+		return nil, xerrors.Errorf("computing basefee: %w", err)
+	}
+
+	// 0. Load messages from the target tipset; if it is the same as the current tipset in
+	//    the mpool, then this is just the pending messages
+	pending, err := mp.getPendingMessages(curTs, ts)
+	if err != nil {
+		return nil, err
+	}
+
+	if len(pending) == 0 {
+		return nil, nil
+	}
+
+	// defer only here so if we have no pending messages we don't spam
+	defer func() {
+		log.Infow("message selection done", "took", time.Since(start))
+	}()
+
+	// 0b. Select all priority messages that fit in the block
+	minGas := int64(gasguess.MinGas)
+	result, gasLimit := mp.selectPriorityMessages(pending, baseFee, ts)
+
+	// have we filled the block?
+	if gasLimit < minGas {
+		return result, nil
+	}
+
+	// 1. Create a list of dependent message chains with maximal gas reward per limit consumed
+	startChains := time.Now()
+	var chains []*msgChain
+	for actor, mset := range pending {
+		next := mp.createMessageChains(actor, mset, baseFee, ts)
+		chains = append(chains, next...)
+	}
+	if dt := time.Since(startChains); dt > time.Millisecond {
+		log.Infow("create message chains done", "took", dt)
+	}
+
+	// 2. Sort the chains
+	sort.Slice(chains, func(i, j int) bool {
+		return chains[i].Before(chains[j])
+	})
+
+	if !allowNegativeChains(curTs.Height()) && len(chains) != 0 && chains[0].gasPerf < 0 {
+		log.Warnw("all messages in mpool have non-positive gas performance", "bestGasPerf", chains[0].gasPerf)
+		return result, nil
+	}
+
+	// 3. Parition chains into blocks (without trimming)
+	//    we use the full blockGasLimit (as opposed to the residual gas limit from the
+	//    priority message selection) as we have to account for what other miners are doing
+	nextChain := 0
+	partitions := make([][]*msgChain, MaxBlocks)
+	for i := 0; i < MaxBlocks && nextChain < len(chains); i++ {
+		gasLimit := int64(build.BlockGasLimit)
+		for nextChain < len(chains) {
+			chain := chains[nextChain]
+			nextChain++
+			partitions[i] = append(partitions[i], chain)
+			gasLimit -= chain.gasLimit
+			if gasLimit < minGas {
+				break
+			}
+		}
+
+	}
+
+	// 4. Compute effective performance for each chain, based on the partition they fall into
+	//    The effective performance is the gasPerf of the chain * block probability
+	blockProb := mp.blockProbabilities(tq)
+	effChains := 0
+	for i := 0; i < MaxBlocks; i++ {
+		for _, chain := range partitions[i] {
+			chain.SetEffectivePerf(blockProb[i])
+		}
+		effChains += len(partitions[i])
+	}
+
+	// nullify the effective performance of chains that don't fit in any partition
+	for _, chain := range chains[effChains:] {
+		chain.SetNullEffectivePerf()
+	}
+
+	// 5. Resort the chains based on effective performance
+	sort.Slice(chains, func(i, j int) bool {
+		return chains[i].BeforeEffective(chains[j])
+	})
+
+	// 6. Merge the head chains to produce the list of messages selected for inclusion
+	//    subject to the residual gas limit
+	//    When a chain is merged in, all its previous dependent chains *must* also be
+	//    merged in or we'll have a broken block
+	startMerge := time.Now()
+	last := len(chains)
+	for i, chain := range chains {
+		// did we run out of performing chains?
+		if !allowNegativeChains(curTs.Height()) && chain.gasPerf < 0 {
+			break
+		}
+
+		// has it already been merged?
+		if chain.merged {
+			continue
+		}
+
+		// compute the dependencies that must be merged and the gas limit including deps
+		chainGasLimit := chain.gasLimit
+		var chainDeps []*msgChain
+		for curChain := chain.prev; curChain != nil && !curChain.merged; curChain = curChain.prev {
+			chainDeps = append(chainDeps, curChain)
+			chainGasLimit += curChain.gasLimit
+		}
+
+		// does it all fit in the block?
+		if chainGasLimit <= gasLimit {
+			// include it together with all dependencies
+			for i := len(chainDeps) - 1; i >= 0; i-- {
+				curChain := chainDeps[i]
+				curChain.merged = true
+				result = append(result, curChain.msgs...)
+			}
+
+			chain.merged = true
+			// adjust the effective pefromance for all subsequent chains
+			if next := chain.next; next != nil && next.effPerf > 0 {
+				next.effPerf += next.parentOffset
+				for next = next.next; next != nil && next.effPerf > 0; next = next.next {
+					next.setEffPerf()
+				}
+			}
+			result = append(result, chain.msgs...)
+			gasLimit -= chainGasLimit
+
+			// resort to account for already merged chains and effective performance adjustments
+			// the sort *must* be stable or we end up getting negative gasPerfs pushed up.
+			sort.SliceStable(chains[i+1:], func(i, j int) bool {
+				return chains[i].BeforeEffective(chains[j])
+			})
+
+			continue
+		}
+
+		// we can't fit this chain and its dependencies because of block gasLimit -- we are
+		// at the edge
+		last = i
+		break
+	}
+	if dt := time.Since(startMerge); dt > time.Millisecond {
+		log.Infow("merge message chains done", "took", dt)
+	}
+
+	// 7. We have reached the edge of what can fit wholesale; if we still hae available
+	//    gasLimit to pack some more chains, then trim the last chain and push it down.
+	//    Trimming invalidaates subsequent dependent chains so that they can't be selected
+	//    as their dependency cannot be (fully) included.
+	//    We do this in a loop because the blocker might have been inordinately large and
+	//    we might have to do it multiple times to satisfy tail packing
+	startTail := time.Now()
+tailLoop:
+	for gasLimit >= minGas && last < len(chains) {
+		// trim if necessary
+		if chains[last].gasLimit > gasLimit {
+			chains[last].Trim(gasLimit, mp, baseFee, allowNegativeChains(curTs.Height()))
+		}
+
+		// push down if it hasn't been invalidated
+		if chains[last].valid {
+			for i := last; i < len(chains)-1; i++ {
+				if chains[i].BeforeEffective(chains[i+1]) {
+					break
+				}
+				chains[i], chains[i+1] = chains[i+1], chains[i]
+			}
+		}
+
+		// select the next (valid and fitting) chain and its dependencies for inclusion
+		for i, chain := range chains[last:] {
+			// has the chain been invalidated?
+			if !chain.valid {
+				continue
+			}
+
+			// has it already been merged?
+			if chain.merged {
+				continue
+			}
+
+			// if gasPerf < 0 we have no more profitable chains
+			if !allowNegativeChains(curTs.Height()) && chain.gasPerf < 0 {
+				break tailLoop
+			}
+
+			// compute the dependencies that must be merged and the gas limit including deps
+			chainGasLimit := chain.gasLimit
+			depGasLimit := int64(0)
+			var chainDeps []*msgChain
+			for curChain := chain.prev; curChain != nil && !curChain.merged; curChain = curChain.prev {
+				chainDeps = append(chainDeps, curChain)
+				chainGasLimit += curChain.gasLimit
+				depGasLimit += curChain.gasLimit
+			}
+
+			// does it all fit in the bock
+			if chainGasLimit <= gasLimit {
+				// include it together with all dependencies
+				for i := len(chainDeps) - 1; i >= 0; i-- {
+					curChain := chainDeps[i]
+					curChain.merged = true
+					result = append(result, curChain.msgs...)
+				}
+
+				chain.merged = true
+				result = append(result, chain.msgs...)
+				gasLimit -= chainGasLimit
+				continue
+			}
+
+			// it doesn't all fit; now we have to take into account the dependent chains before
+			// making a decision about trimming or invalidating.
+			// if the dependencies exceed the gas limit, then we must invalidate the chain
+			// as it can never be included.
+			// Otherwise we can just trim and continue
+			if depGasLimit > gasLimit {
+				chain.Invalidate()
+				last += i + 1
+				continue tailLoop
+			}
+
+			// dependencies fit, just trim it
+			chain.Trim(gasLimit-depGasLimit, mp, baseFee, allowNegativeChains(curTs.Height()))
+			last += i
+			continue tailLoop
+		}
+
+		// the merge loop ended after processing all the chains and we we probably have still
+		// gas to spare; end the loop.
+		break
+	}
+	if dt := time.Since(startTail); dt > time.Millisecond {
+		log.Infow("pack tail chains done", "took", dt)
+	}
+
+	// if we have gasLimit to spare, pick some random (non-negative) chains to fill the block
+	// we pick randomly so that we minimize the probability of duplication among all miners
+	if gasLimit >= minGas {
+		randomCount := 0
+
+		startRandom := time.Now()
+		shuffleChains(chains)
+
+		for _, chain := range chains {
+			// have we filled the block
+			if gasLimit < minGas {
+				break
+			}
+
+			// has it been merged or invalidated?
+			if chain.merged || !chain.valid {
+				continue
+			}
+
+			// is it negative?
+			if !allowNegativeChains(curTs.Height()) && chain.gasPerf < 0 {
+				continue
+			}
+
+			// compute the dependencies that must be merged and the gas limit including deps
+			chainGasLimit := chain.gasLimit
+			depGasLimit := int64(0)
+			var chainDeps []*msgChain
+			for curChain := chain.prev; curChain != nil && !curChain.merged; curChain = curChain.prev {
+				chainDeps = append(chainDeps, curChain)
+				chainGasLimit += curChain.gasLimit
+				depGasLimit += curChain.gasLimit
+			}
+
+			// do the deps fit? if the deps won't fit, invalidate the chain
+			if depGasLimit > gasLimit {
+				chain.Invalidate()
+				continue
+			}
+
+			// do they fit as is? if it doesn't, trim to make it fit if possible
+			if chainGasLimit > gasLimit {
+				chain.Trim(gasLimit-depGasLimit, mp, baseFee, allowNegativeChains(curTs.Height()))
+
+				if !chain.valid {
+					continue
+				}
+			}
+
+			// include it together with all dependencies
+			for i := len(chainDeps) - 1; i >= 0; i-- {
+				curChain := chainDeps[i]
+				curChain.merged = true
+				result = append(result, curChain.msgs...)
+				randomCount += len(curChain.msgs)
+			}
+
+			chain.merged = true
+			result = append(result, chain.msgs...)
+			randomCount += len(chain.msgs)
+			gasLimit -= chainGasLimit
+		}
+
+		if dt := time.Since(startRandom); dt > time.Millisecond {
+			log.Infow("pack random tail chains done", "took", dt)
+		}
+
+		if randomCount > 0 {
+			log.Warnf("optimal selection failed to pack a block; picked %d messages with random selection",
+				randomCount)
+		}
+	}
+
+	return result, nil
+}
+
+func (mp *MessagePool) selectMessagesGreedy(curTs, ts *types.TipSet) ([]*types.SignedMessage, error) {
+	start := time.Now()
+
+	baseFee, err := mp.api.ChainComputeBaseFee(context.TODO(), ts)
+	if err != nil {
+		return nil, xerrors.Errorf("computing basefee: %w", err)
+	}
+
+	// 0. Load messages for the target tipset; if it is the same as the current tipset in the mpool
+	//    then this is just the pending messages
+	pending, err := mp.getPendingMessages(curTs, ts)
+	if err != nil {
+		return nil, err
+	}
+
+	if len(pending) == 0 {
+		return nil, nil
+	}
+
+	// defer only here so if we have no pending messages we don't spam
+	defer func() {
+		log.Infow("message selection done", "took", time.Since(start))
+	}()
+
+	// 0b. Select all priority messages that fit in the block
+	minGas := int64(gasguess.MinGas)
+	result, gasLimit := mp.selectPriorityMessages(pending, baseFee, ts)
+
+	// have we filled the block?
+	if gasLimit < minGas {
+		return result, nil
+	}
+
+	// 1. Create a list of dependent message chains with maximal gas reward per limit consumed
+	startChains := time.Now()
+	var chains []*msgChain
+	for actor, mset := range pending {
+		next := mp.createMessageChains(actor, mset, baseFee, ts)
+		chains = append(chains, next...)
+	}
+	if dt := time.Since(startChains); dt > time.Millisecond {
+		log.Infow("create message chains done", "took", dt)
+	}
+
+	// 2. Sort the chains
+	sort.Slice(chains, func(i, j int) bool {
+		return chains[i].Before(chains[j])
+	})
+
+	if !allowNegativeChains(curTs.Height()) && len(chains) != 0 && chains[0].gasPerf < 0 {
+		log.Warnw("all messages in mpool have non-positive gas performance", "bestGasPerf", chains[0].gasPerf)
+		return result, nil
+	}
+
+	// 3. Merge the head chains to produce the list of messages selected for inclusion, subject to
+	//    the block gas limit.
+	startMerge := time.Now()
+	last := len(chains)
+	for i, chain := range chains {
+		// did we run out of performing chains?
+		if !allowNegativeChains(curTs.Height()) && chain.gasPerf < 0 {
+			break
+		}
+
+		// does it fit in the block?
+		if chain.gasLimit <= gasLimit {
+			gasLimit -= chain.gasLimit
+			result = append(result, chain.msgs...)
+			continue
+		}
+
+		// we can't fit this chain because of block gasLimit -- we are at the edge
+		last = i
+		break
+	}
+	if dt := time.Since(startMerge); dt > time.Millisecond {
+		log.Infow("merge message chains done", "took", dt)
+	}
+
+	// 4. We have reached the edge of what we can fit wholesale; if we still have available gasLimit
+	// to pack some more chains, then trim the last chain and push it down.
+	// Trimming invalidates subsequent dependent chains so that they can't be selected as their
+	// dependency cannot be (fully) included.
+	// We do this in a loop because the blocker might have been inordinately large and we might
+	// have to do it multiple times to satisfy tail packing.
+	startTail := time.Now()
+tailLoop:
+	for gasLimit >= minGas && last < len(chains) {
+		// trim
+		chains[last].Trim(gasLimit, mp, baseFee, allowNegativeChains(curTs.Height()))
+
+		// push down if it hasn't been invalidated
+		if chains[last].valid {
+			for i := last; i < len(chains)-1; i++ {
+				if chains[i].Before(chains[i+1]) {
+					break
+				}
+				chains[i], chains[i+1] = chains[i+1], chains[i]
+			}
+		}
+
+		// select the next (valid and fitting) chain for inclusion
+		for i, chain := range chains[last:] {
+			// has the chain been invalidated?
+			if !chain.valid {
+				continue
+			}
+
+			// if gasPerf < 0 we have no more profitable chains
+			if !allowNegativeChains(curTs.Height()) && chain.gasPerf < 0 {
+				break tailLoop
+			}
+
+			// does it fit in the bock?
+			if chain.gasLimit <= gasLimit {
+				gasLimit -= chain.gasLimit
+				result = append(result, chain.msgs...)
+				continue
+			}
+
+			// this chain needs to be trimmed
+			last += i
+			continue tailLoop
+		}
+
+		// the merge loop ended after processing all the chains and we probably still have
+		// gas to spare; end the loop
+		break
+	}
+	if dt := time.Since(startTail); dt > time.Millisecond {
+		log.Infow("pack tail chains done", "took", dt)
+	}
+
+	return result, nil
+}
+
+func (mp *MessagePool) selectPriorityMessages(pending map[address.Address]map[uint64]*types.SignedMessage, baseFee types.BigInt, ts *types.TipSet) ([]*types.SignedMessage, int64) {
+	start := time.Now()
+	defer func() {
+		if dt := time.Since(start); dt > time.Millisecond {
+			log.Infow("select priority messages done", "took", dt)
+		}
+	}()
+
+	result := make([]*types.SignedMessage, 0, mp.cfg.SizeLimitLow)
+	gasLimit := int64(build.BlockGasLimit)
+	minGas := int64(gasguess.MinGas)
+
+	// 1. Get priority actor chains
+	var chains []*msgChain
+	priority := mp.cfg.PriorityAddrs
+	for _, actor := range priority {
+		mset, ok := pending[actor]
+		if ok {
+			// remove actor from pending set as we are already processed these messages
+			delete(pending, actor)
+			// create chains for the priority actor
+			next := mp.createMessageChains(actor, mset, baseFee, ts)
+			chains = append(chains, next...)
+		}
+	}
+
+	if len(chains) == 0 {
+		return nil, gasLimit
+	}
+
+	// 2. Sort the chains
+	sort.Slice(chains, func(i, j int) bool {
+		return chains[i].Before(chains[j])
+	})
+
+	if !allowNegativeChains(ts.Height()) && len(chains) != 0 && chains[0].gasPerf < 0 {
+		log.Warnw("all priority messages in mpool have negative gas performance", "bestGasPerf", chains[0].gasPerf)
+		return nil, gasLimit
+	}
+
+	// 3. Merge chains until the block limit, as long as they have non-negative gas performance
+	last := len(chains)
+	for i, chain := range chains {
+		if !allowNegativeChains(ts.Height()) && chain.gasPerf < 0 {
+			break
+		}
+
+		if chain.gasLimit <= gasLimit {
+			gasLimit -= chain.gasLimit
+			result = append(result, chain.msgs...)
+			continue
+		}
+
+		// we can't fit this chain because of block gasLimit -- we are at the edge
+		last = i
+		break
+	}
+
+tailLoop:
+	for gasLimit >= minGas && last < len(chains) {
+		// trim, discarding negative performing messages
+		chains[last].Trim(gasLimit, mp, baseFee, allowNegativeChains(ts.Height()))
+
+		// push down if it hasn't been invalidated
+		if chains[last].valid {
+			for i := last; i < len(chains)-1; i++ {
+				if chains[i].Before(chains[i+1]) {
+					break
+				}
+				chains[i], chains[i+1] = chains[i+1], chains[i]
+			}
+		}
+
+		// select the next (valid and fitting) chain for inclusion
+		for i, chain := range chains[last:] {
+			// has the chain been invalidated
+			if !chain.valid {
+				continue
+			}
+
+			// if gasPerf < 0 we have no more profitable chains
+			if !allowNegativeChains(ts.Height()) && chain.gasPerf < 0 {
+				break tailLoop
+			}
+
+			// does it fit in the bock?
+			if chain.gasLimit <= gasLimit {
+				gasLimit -= chain.gasLimit
+				result = append(result, chain.msgs...)
+				continue
+			}
+
+			// this chain needs to be trimmed
+			last += i
+			continue tailLoop
+		}
+
+		// the merge loop ended after processing all the chains and we probably still have gas to spare;
+		// end the loop
+		break
+	}
+
+	return result, gasLimit
+}
+
+func (mp *MessagePool) getPendingMessages(curTs, ts *types.TipSet) (map[address.Address]map[uint64]*types.SignedMessage, error) {
+	start := time.Now()
+
+	result := make(map[address.Address]map[uint64]*types.SignedMessage)
+	defer func() {
+		if dt := time.Since(start); dt > time.Millisecond {
+			log.Infow("get pending messages done", "took", dt)
+		}
+	}()
+
+	// are we in sync?
+	inSync := false
+	if curTs.Height() == ts.Height() && curTs.Equals(ts) {
+		inSync = true
+	}
+
+	// first add our current pending messages
+	for a, mset := range mp.pending {
+		if inSync {
+			// no need to copy the map
+			result[a] = mset.msgs
+		} else {
+			// we need to copy the map to avoid clobbering it as we load more messages
+			msetCopy := make(map[uint64]*types.SignedMessage, len(mset.msgs))
+			for nonce, m := range mset.msgs {
+				msetCopy[nonce] = m
+			}
+			result[a] = msetCopy
+
+		}
+	}
+
+	// we are in sync, that's the happy path
+	if inSync {
+		return result, nil
+	}
+
+	if err := mp.runHeadChange(curTs, ts, result); err != nil {
+		return nil, xerrors.Errorf("failed to process difference between mpool head and given head: %w", err)
+	}
+
+	return result, nil
+}
+
+func (*MessagePool) getGasReward(msg *types.SignedMessage, baseFee types.BigInt) *big.Int {
+	maxPremium := types.BigSub(msg.Message.GasFeeCap, baseFee)
+
+	if types.BigCmp(maxPremium, msg.Message.GasPremium) > 0 {
+		maxPremium = msg.Message.GasPremium
+	}
+
+	gasReward := tbig.Mul(maxPremium, types.NewInt(uint64(msg.Message.GasLimit)))
+	return gasReward.Int
+}
+
+func (*MessagePool) getGasPerf(gasReward *big.Int, gasLimit int64) float64 {
+	// gasPerf = gasReward * build.BlockGasLimit / gasLimit
+	a := new(big.Rat).SetInt(new(big.Int).Mul(gasReward, bigBlockGasLimit))
+	b := big.NewRat(1, gasLimit)
+	c := new(big.Rat).Mul(a, b)
+	r, _ := c.Float64()
+	return r
+}
+
+func (mp *MessagePool) createMessageChains(actor address.Address, mset map[uint64]*types.SignedMessage, baseFee types.BigInt, ts *types.TipSet) []*msgChain {
+	// collect all messages
+	msgs := make([]*types.SignedMessage, 0, len(mset))
+	for _, m := range mset {
+		msgs = append(msgs, m)
+	}
+
+	// sort by nonce
+	sort.Slice(msgs, func(i, j int) bool {
+		return msgs[i].Message.Nonce < msgs[j].Message.Nonce
+	})
+
+	// sanity checks:
+	// - there can be no gaps in nonces, starting from the current actor nonce
+	//   if there is a gap, drop messages after the gap, we can't include them
+	// - all messages must have minimum gas and the total gas for the candidate messages
+	//   cannot exceed the block limit; drop all messages that exceed the limit
+	// - the total gasReward cannot exceed the actor's balance; drop all messages that exceed
+	//   the balance
+	a, err := mp.api.GetActorAfter(actor, ts)
+	if err != nil {
+		log.Errorf("failed to load actor state, not building chain for %s: %w", actor, err)
+		return nil
+	}
+
+	curNonce := a.Nonce
+	balance := a.Balance.Int
+	gasLimit := int64(0)
+	skip := 0
+	i := 0
+	rewards := make([]*big.Int, 0, len(msgs))
+	for i = 0; i < len(msgs); i++ {
+		m := msgs[i]
+
+		if m.Message.Nonce < curNonce {
+			log.Warnf("encountered message from actor %s with nonce (%d) less than the current nonce (%d)",
+				actor, m.Message.Nonce, curNonce)
+			skip++
+			continue
+		}
+
+		if m.Message.Nonce != curNonce {
+			break
+		}
+		curNonce++
+
+		minGas := vm.PricelistByEpoch(ts.Height()).OnChainMessage(m.ChainLength()).Total()
+		if m.Message.GasLimit < minGas {
+			break
+		}
+
+		gasLimit += m.Message.GasLimit
+		if gasLimit > build.BlockGasLimit {
+			break
+		}
+
+		required := m.Message.RequiredFunds().Int
+		if balance.Cmp(required) < 0 {
+			break
+		}
+		balance = new(big.Int).Sub(balance, required)
+
+		value := m.Message.Value.Int
+		if balance.Cmp(value) >= 0 {
+			// Note: we only account for the value if the balance doesn't drop below 0
+			//       otherwise the message will fail and the miner can reap the gas rewards
+			balance = new(big.Int).Sub(balance, value)
+		}
+
+		gasReward := mp.getGasReward(m, baseFee)
+		rewards = append(rewards, gasReward)
+	}
+
+	// check we have a sane set of messages to construct the chains
+	if i > skip {
+		msgs = msgs[skip:i]
+	} else {
+		return nil
+	}
+
+	// ok, now we can construct the chains using the messages we have
+	// invariant: each chain has a bigger gasPerf than the next -- otherwise they can be merged
+	// and increase the gasPerf of the first chain
+	// We do this in two passes:
+	// - in the first pass we create chains that aggreagate messages with non-decreasing gasPerf
+	// - in the second pass we merge chains to maintain the invariant.
+	var chains []*msgChain
+	var curChain *msgChain
+
+	newChain := func(m *types.SignedMessage, i int) *msgChain {
+		chain := new(msgChain)
+		chain.msgs = []*types.SignedMessage{m}
+		chain.gasReward = rewards[i]
+		chain.gasLimit = m.Message.GasLimit
+		chain.gasPerf = mp.getGasPerf(chain.gasReward, chain.gasLimit)
+		chain.valid = true
+		return chain
+	}
+
+	// create the individual chains
+	for i, m := range msgs {
+		if curChain == nil {
+			curChain = newChain(m, i)
+			continue
+		}
+
+		gasReward := new(big.Int).Add(curChain.gasReward, rewards[i])
+		gasLimit := curChain.gasLimit + m.Message.GasLimit
+		gasPerf := mp.getGasPerf(gasReward, gasLimit)
+
+		// try to add the message to the current chain -- if it decreases the gasPerf, then make a
+		// new chain
+		if gasPerf < curChain.gasPerf {
+			chains = append(chains, curChain)
+			curChain = newChain(m, i)
+		} else {
+			curChain.msgs = append(curChain.msgs, m)
+			curChain.gasReward = gasReward
+			curChain.gasLimit = gasLimit
+			curChain.gasPerf = gasPerf
+		}
+	}
+	chains = append(chains, curChain)
+
+	// merge chains to maintain the invariant
+	for {
+		merged := 0
+
+		for i := len(chains) - 1; i > 0; i-- {
+			if chains[i].gasPerf >= chains[i-1].gasPerf {
+				chains[i-1].msgs = append(chains[i-1].msgs, chains[i].msgs...)
+				chains[i-1].gasReward = new(big.Int).Add(chains[i-1].gasReward, chains[i].gasReward)
+				chains[i-1].gasLimit += chains[i].gasLimit
+				chains[i-1].gasPerf = mp.getGasPerf(chains[i-1].gasReward, chains[i-1].gasLimit)
+				chains[i].valid = false
+				merged++
+			}
+		}
+
+		if merged == 0 {
+			break
+		}
+
+		// drop invalidated chains
+		newChains := make([]*msgChain, 0, len(chains)-merged)
+		for _, c := range chains {
+			if c.valid {
+				newChains = append(newChains, c)
+			}
+		}
+		chains = newChains
+	}
+
+	// link dependent chains
+	for i := 0; i < len(chains)-1; i++ {
+		chains[i].next = chains[i+1]
+	}
+
+	for i := len(chains) - 1; i > 0; i-- {
+		chains[i].prev = chains[i-1]
+	}
+
+	return chains
+}
+
+func (mc *msgChain) Before(other *msgChain) bool {
+	return mc.gasPerf > other.gasPerf ||
+		(mc.gasPerf == other.gasPerf && mc.gasReward.Cmp(other.gasReward) > 0)
+}
+
+func (mc *msgChain) Trim(gasLimit int64, mp *MessagePool, baseFee types.BigInt, allowNegative bool) {
+	i := len(mc.msgs) - 1
+	for i >= 0 && (mc.gasLimit > gasLimit || (!allowNegative && mc.gasPerf < 0)) {
+		gasReward := mp.getGasReward(mc.msgs[i], baseFee)
+		mc.gasReward = new(big.Int).Sub(mc.gasReward, gasReward)
+		mc.gasLimit -= mc.msgs[i].Message.GasLimit
+		if mc.gasLimit > 0 {
+			mc.gasPerf = mp.getGasPerf(mc.gasReward, mc.gasLimit)
+			if mc.bp != 0 {
+				mc.setEffPerf()
+			}
+		} else {
+			mc.gasPerf = 0
+			mc.effPerf = 0
+		}
+		i--
+	}
+
+	if i < 0 {
+		mc.msgs = nil
+		mc.valid = false
+	} else {
+		mc.msgs = mc.msgs[:i+1]
+	}
+
+	if mc.next != nil {
+		mc.next.Invalidate()
+		mc.next = nil
+	}
+}
+
+func (mc *msgChain) Invalidate() {
+	mc.valid = false
+	mc.msgs = nil
+	if mc.next != nil {
+		mc.next.Invalidate()
+		mc.next = nil
+	}
+}
+
+func (mc *msgChain) SetEffectivePerf(bp float64) {
+	mc.bp = bp
+	mc.setEffPerf()
+}
+
+func (mc *msgChain) setEffPerf() {
+	effPerf := mc.gasPerf * mc.bp
+	if effPerf > 0 && mc.prev != nil {
+		effPerfWithParent := (effPerf*float64(mc.gasLimit) + mc.prev.effPerf*float64(mc.prev.gasLimit)) / float64(mc.gasLimit+mc.prev.gasLimit)
+		mc.parentOffset = effPerf - effPerfWithParent
+		effPerf = effPerfWithParent
+	}
+	mc.effPerf = effPerf
+
+}
+
+func (mc *msgChain) SetNullEffectivePerf() {
+	if mc.gasPerf < 0 {
+		mc.effPerf = mc.gasPerf
+	} else {
+		mc.effPerf = 0
+	}
+}
+
+func (mc *msgChain) BeforeEffective(other *msgChain) bool {
+	// move merged chains to the front so we can discard them earlier
+	return (mc.merged && !other.merged) ||
+		(mc.gasPerf >= 0 && other.gasPerf < 0) ||
+		mc.effPerf > other.effPerf ||
+		(mc.effPerf == other.effPerf && mc.gasPerf > other.gasPerf) ||
+		(mc.effPerf == other.effPerf && mc.gasPerf == other.gasPerf && mc.gasReward.Cmp(other.gasReward) > 0)
+}
+
+func shuffleChains(lst []*msgChain) {
+	for i := range lst {
+		j := rand.Intn(i + 1)
+		lst[i], lst[j] = lst[j], lst[i]
+	}
+}
diff --git a/chain/messagepool/selection_test.go b/chain/messagepool/selection_test.go
new file mode 100644
index 000000000..ea19dad9c
--- /dev/null
+++ b/chain/messagepool/selection_test.go
@@ -0,0 +1,1465 @@
+package messagepool
+
+import (
+	"compress/gzip"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"math"
+	"math/big"
+	"math/rand"
+	"os"
+	"sort"
+	"testing"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/crypto"
+	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/messagepool/gasguess"
+	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/chain/types/mock"
+	"github.com/filecoin-project/lotus/chain/wallet"
+	"github.com/filecoin-project/specs-actors/actors/builtin"
+	"github.com/ipfs/go-cid"
+	"github.com/ipfs/go-datastore"
+
+	_ "github.com/filecoin-project/lotus/lib/sigs/bls"
+	_ "github.com/filecoin-project/lotus/lib/sigs/secp"
+	logging "github.com/ipfs/go-log"
+)
+
+func init() {
+	// bump this for the selection tests
+	MaxActorPendingMessages = 1000000
+}
+
+func makeTestMessage(w *wallet.Wallet, from, to address.Address, nonce uint64, gasLimit int64, gasPrice uint64) *types.SignedMessage {
+	msg := &types.Message{
+		From:       from,
+		To:         to,
+		Method:     2,
+		Value:      types.FromFil(0),
+		Nonce:      nonce,
+		GasLimit:   gasLimit,
+		GasFeeCap:  types.NewInt(100 + gasPrice),
+		GasPremium: types.NewInt(gasPrice),
+	}
+	sig, err := w.Sign(context.TODO(), from, msg.Cid().Bytes())
+	if err != nil {
+		panic(err)
+	}
+	return &types.SignedMessage{
+		Message:   *msg,
+		Signature: *sig,
+	}
+}
+
+func makeTestMpool() (*MessagePool, *testMpoolAPI) {
+	tma := newTestMpoolAPI()
+	ds := datastore.NewMapDatastore()
+	mp, err := New(tma, ds, "test")
+	if err != nil {
+		panic(err)
+	}
+
+	return mp, tma
+}
+
+func TestMessageChains(t *testing.T) {
+	mp, tma := makeTestMpool()
+
+	// the actors
+	w1, err := wallet.NewWallet(wallet.NewMemKeyStore())
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	a1, err := w1.GenerateKey(crypto.SigTypeSecp256k1)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	w2, err := wallet.NewWallet(wallet.NewMemKeyStore())
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	a2, err := w2.GenerateKey(crypto.SigTypeSecp256k1)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	block := tma.nextBlock()
+	ts := mock.TipSet(block)
+
+	gasLimit := gasguess.Costs[gasguess.CostKey{Code: builtin.StorageMarketActorCodeID, M: 2}]
+
+	tma.setBalance(a1, 1) // in FIL
+
+	// test chain aggregations
+
+	// test1: 10 messages from a1 to a2, with increasing gasPerf; it should
+	//        make a single chain with 10 messages given enough balance
+	mset := make(map[uint64]*types.SignedMessage)
+	for i := 0; i < 10; i++ {
+		m := makeTestMessage(w1, a1, a2, uint64(i), gasLimit, uint64(i+1))
+		mset[uint64(i)] = m
+	}
+	baseFee := types.NewInt(0)
+
+	chains := mp.createMessageChains(a1, mset, baseFee, ts)
+	if len(chains) != 1 {
+		t.Fatal("expected a single chain")
+	}
+	if len(chains[0].msgs) != 10 {
+		t.Fatalf("expected 10 messages in the chain but got %d", len(chains[0].msgs))
+	}
+	for i, m := range chains[0].msgs {
+		if m.Message.Nonce != uint64(i) {
+			t.Fatalf("expected nonce %d but got %d", i, m.Message.Nonce)
+		}
+	}
+
+	// test2 : 10 messages from a1 to a2, with decreasing gasPerf; it should
+	//         make 10 chains with 1 message each
+	mset = make(map[uint64]*types.SignedMessage)
+	for i := 0; i < 10; i++ {
+		m := makeTestMessage(w1, a1, a2, uint64(i), gasLimit, uint64(10-i))
+		mset[uint64(i)] = m
+	}
+
+	chains = mp.createMessageChains(a1, mset, baseFee, ts)
+	if len(chains) != 10 {
+		t.Fatal("expected 10 chains")
+	}
+	for i, chain := range chains {
+		if len(chain.msgs) != 1 {
+			t.Fatalf("expected 1 message in chain %d but got %d", i, len(chain.msgs))
+		}
+	}
+	for i, chain := range chains {
+		m := chain.msgs[0]
+		if m.Message.Nonce != uint64(i) {
+			t.Fatalf("expected nonce %d but got %d", i, m.Message.Nonce)
+		}
+	}
+
+	// test3a: 10 messages from a1 to a2, with gasPerf increasing in groups of 3; it should
+	//         merge them in two chains, one with 9 messages and one with the last message
+	mset = make(map[uint64]*types.SignedMessage)
+	for i := 0; i < 10; i++ {
+		m := makeTestMessage(w1, a1, a2, uint64(i), gasLimit, uint64(1+i%3))
+		mset[uint64(i)] = m
+	}
+
+	chains = mp.createMessageChains(a1, mset, baseFee, ts)
+	if len(chains) != 2 {
+		t.Fatal("expected 1 chain")
+	}
+
+	if len(chains[0].msgs) != 9 {
+		t.Fatalf("expected 9 messages in the chain but got %d", len(chains[0].msgs))
+	}
+	if len(chains[1].msgs) != 1 {
+		t.Fatalf("expected 1 messages in the chain but got %d", len(chains[1].msgs))
+	}
+	nextNonce := 0
+	for _, chain := range chains {
+		for _, m := range chain.msgs {
+			if m.Message.Nonce != uint64(nextNonce) {
+				t.Fatalf("expected nonce %d but got %d", nextNonce, m.Message.Nonce)
+			}
+			nextNonce++
+		}
+	}
+
+	// test3b: 10 messages from a1 to a2, with gasPerf decreasing in groups of 3 with a bias for the
+	//        earlier chains; it should make 4 chains, the first 3 with 3 messages and the last with
+	//        a single message
+	mset = make(map[uint64]*types.SignedMessage)
+	for i := 0; i < 10; i++ {
+		bias := (12 - i) / 3
+		m := makeTestMessage(w1, a1, a2, uint64(i), gasLimit, uint64(1+i%3+bias))
+		mset[uint64(i)] = m
+	}
+
+	chains = mp.createMessageChains(a1, mset, baseFee, ts)
+	if len(chains) != 4 {
+		t.Fatal("expected 4 chains")
+	}
+	for i, chain := range chains {
+		expectedLen := 3
+		if i > 2 {
+			expectedLen = 1
+		}
+		if len(chain.msgs) != expectedLen {
+			t.Fatalf("expected %d message in chain %d but got %d", expectedLen, i, len(chain.msgs))
+		}
+	}
+	nextNonce = 0
+	for _, chain := range chains {
+		for _, m := range chain.msgs {
+			if m.Message.Nonce != uint64(nextNonce) {
+				t.Fatalf("expected nonce %d but got %d", nextNonce, m.Message.Nonce)
+			}
+			nextNonce++
+		}
+	}
+
+	// test chain breaks
+
+	// test4: 10 messages with non-consecutive nonces; it should make a single chain with just
+	//        the first message
+	mset = make(map[uint64]*types.SignedMessage)
+	for i := 0; i < 10; i++ {
+		m := makeTestMessage(w1, a1, a2, uint64(i*2), gasLimit, uint64(i+1))
+		mset[uint64(i)] = m
+	}
+
+	chains = mp.createMessageChains(a1, mset, baseFee, ts)
+	if len(chains) != 1 {
+		t.Fatal("expected a single chain")
+	}
+	if len(chains[0].msgs) != 1 {
+		t.Fatalf("expected 1 message in the chain but got %d", len(chains[0].msgs))
+	}
+	for i, m := range chains[0].msgs {
+		if m.Message.Nonce != uint64(i) {
+			t.Fatalf("expected nonce %d but got %d", i, m.Message.Nonce)
+		}
+	}
+
+	// test5: 10 messages with increasing gasLimit, except for the 6th message which has less than
+	//        the epoch gasLimit; it should create a single chain with the first 5 messages
+	mset = make(map[uint64]*types.SignedMessage)
+	for i := 0; i < 10; i++ {
+		var m *types.SignedMessage
+		if i != 5 {
+			m = makeTestMessage(w1, a1, a2, uint64(i), gasLimit, uint64(i+1))
+		} else {
+			m = makeTestMessage(w1, a1, a2, uint64(i), 1, uint64(i+1))
+		}
+		mset[uint64(i)] = m
+	}
+
+	chains = mp.createMessageChains(a1, mset, baseFee, ts)
+	if len(chains) != 1 {
+		t.Fatal("expected a single chain")
+	}
+	if len(chains[0].msgs) != 5 {
+		t.Fatalf("expected 5 message in the chain but got %d", len(chains[0].msgs))
+	}
+	for i, m := range chains[0].msgs {
+		if m.Message.Nonce != uint64(i) {
+			t.Fatalf("expected nonce %d but got %d", i, m.Message.Nonce)
+		}
+	}
+
+	// test6: one more message than what can fit in a block according to gas limit, with increasing
+	//        gasPerf; it should create a single chain with the max messages
+	maxMessages := int(build.BlockGasLimit / gasLimit)
+	nMessages := maxMessages + 1
+
+	mset = make(map[uint64]*types.SignedMessage)
+	for i := 0; i < nMessages; i++ {
+		mset[uint64(i)] = makeTestMessage(w1, a1, a2, uint64(i), gasLimit, uint64(i+1))
+	}
+
+	chains = mp.createMessageChains(a1, mset, baseFee, ts)
+	if len(chains) != 1 {
+		t.Fatal("expected a single chain")
+	}
+	if len(chains[0].msgs) != maxMessages {
+		t.Fatalf("expected %d message in the chain but got %d", maxMessages, len(chains[0].msgs))
+	}
+	for i, m := range chains[0].msgs {
+		if m.Message.Nonce != uint64(i) {
+			t.Fatalf("expected nonce %d but got %d", i, m.Message.Nonce)
+		}
+	}
+
+	// test5: insufficient balance for all messages
+	tma.setBalanceRaw(a1, types.NewInt(uint64((300)*gasLimit+1)))
+
+	mset = make(map[uint64]*types.SignedMessage)
+	for i := 0; i < 10; i++ {
+		mset[uint64(i)] = makeTestMessage(w1, a1, a2, uint64(i), gasLimit, uint64(i+1))
+	}
+
+	chains = mp.createMessageChains(a1, mset, baseFee, ts)
+	if len(chains) != 1 {
+		t.Fatalf("expected a single chain: got %d", len(chains))
+	}
+	if len(chains[0].msgs) != 2 {
+		t.Fatalf("expected %d message in the chain but got %d", 2, len(chains[0].msgs))
+	}
+	for i, m := range chains[0].msgs {
+		if m.Message.Nonce != uint64(i) {
+			t.Fatalf("expected nonce %d but got %d", i, m.Message.Nonce)
+		}
+	}
+
+}
+
+func TestMessageChainSkipping(t *testing.T) {
+	// regression test for chain skip bug
+
+	mp, tma := makeTestMpool()
+
+	// the actors
+	w1, err := wallet.NewWallet(wallet.NewMemKeyStore())
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	a1, err := w1.GenerateKey(crypto.SigTypeSecp256k1)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	w2, err := wallet.NewWallet(wallet.NewMemKeyStore())
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	a2, err := w2.GenerateKey(crypto.SigTypeSecp256k1)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	block := tma.nextBlock()
+	ts := mock.TipSet(block)
+
+	gasLimit := gasguess.Costs[gasguess.CostKey{Code: builtin.StorageMarketActorCodeID, M: 2}]
+	baseFee := types.NewInt(0)
+
+	tma.setBalance(a1, 1) // in FIL
+	tma.setStateNonce(a1, 10)
+
+	mset := make(map[uint64]*types.SignedMessage)
+	for i := 0; i < 20; i++ {
+		bias := (20 - i) / 3
+		m := makeTestMessage(w1, a1, a2, uint64(i), gasLimit, uint64(1+i%3+bias))
+		mset[uint64(i)] = m
+	}
+
+	chains := mp.createMessageChains(a1, mset, baseFee, ts)
+	if len(chains) != 4 {
+		t.Fatalf("expected 4 chains, got %d", len(chains))
+	}
+	for i, chain := range chains {
+		var expectedLen int
+		switch {
+		case i == 0:
+			expectedLen = 2
+		case i > 2:
+			expectedLen = 2
+		default:
+			expectedLen = 3
+		}
+		if len(chain.msgs) != expectedLen {
+			t.Fatalf("expected %d message in chain %d but got %d", expectedLen, i, len(chain.msgs))
+		}
+	}
+	nextNonce := 10
+	for _, chain := range chains {
+		for _, m := range chain.msgs {
+			if m.Message.Nonce != uint64(nextNonce) {
+				t.Fatalf("expected nonce %d but got %d", nextNonce, m.Message.Nonce)
+			}
+			nextNonce++
+		}
+	}
+
+}
+
+func TestBasicMessageSelection(t *testing.T) {
+	oldMaxNonceGap := MaxNonceGap
+	MaxNonceGap = 1000
+	defer func() {
+		MaxNonceGap = oldMaxNonceGap
+	}()
+
+	mp, tma := makeTestMpool()
+
+	// the actors
+	w1, err := wallet.NewWallet(wallet.NewMemKeyStore())
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	a1, err := w1.GenerateKey(crypto.SigTypeSecp256k1)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	w2, err := wallet.NewWallet(wallet.NewMemKeyStore())
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	a2, err := w2.GenerateKey(crypto.SigTypeSecp256k1)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	block := tma.nextBlock()
+	ts := mock.TipSet(block)
+	tma.applyBlock(t, block)
+
+	gasLimit := gasguess.Costs[gasguess.CostKey{Code: builtin.StorageMarketActorCodeID, M: 2}]
+
+	tma.setBalance(a1, 1) // in FIL
+	tma.setBalance(a2, 1) // in FIL
+
+	// we create 10 messages from each actor to another, with the first actor paying higher
+	// gas prices than the second; we expect message selection to order his messages first
+	for i := 0; i < 10; i++ {
+		m := makeTestMessage(w1, a1, a2, uint64(i), gasLimit, uint64(2*i+1))
+		mustAdd(t, mp, m)
+	}
+
+	for i := 0; i < 10; i++ {
+		m := makeTestMessage(w2, a2, a1, uint64(i), gasLimit, uint64(i+1))
+		mustAdd(t, mp, m)
+	}
+
+	msgs, err := mp.SelectMessages(ts, 1.0)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if len(msgs) != 20 {
+		t.Fatalf("exptected 20 messages, got %d", len(msgs))
+	}
+
+	nextNonce := 0
+	for i := 0; i < 10; i++ {
+		if msgs[i].Message.From != a1 {
+			t.Fatalf("expected message from actor a1")
+		}
+		if msgs[i].Message.Nonce != uint64(nextNonce) {
+			t.Fatalf("expected nonce %d, got %d", msgs[i].Message.Nonce, nextNonce)
+		}
+		nextNonce++
+	}
+
+	nextNonce = 0
+	for i := 10; i < 20; i++ {
+		if msgs[i].Message.From != a2 {
+			t.Fatalf("expected message from actor a2")
+		}
+		if msgs[i].Message.Nonce != uint64(nextNonce) {
+			t.Fatalf("expected nonce %d, got %d", msgs[i].Message.Nonce, nextNonce)
+		}
+		nextNonce++
+	}
+
+	// now we make a block with all the messages and advance the chain
+	block2 := tma.nextBlock()
+	tma.setBlockMessages(block2, msgs...)
+	tma.applyBlock(t, block2)
+
+	// we should have no pending messages in the mpool
+	pend, _ := mp.Pending()
+	if len(pend) != 0 {
+		t.Fatalf("expected no pending messages, but got %d", len(pend))
+	}
+
+	// create a block and advance the chain without applying to the mpool
+	msgs = nil
+	for i := 10; i < 20; i++ {
+		m := makeTestMessage(w1, a1, a2, uint64(i), gasLimit, uint64(2*i+1))
+		msgs = append(msgs, m)
+		m = makeTestMessage(w2, a2, a1, uint64(i), gasLimit, uint64(i+1))
+		msgs = append(msgs, m)
+	}
+	block3 := tma.nextBlock()
+	tma.setBlockMessages(block3, msgs...)
+	ts3 := mock.TipSet(block3)
+
+	// now create another set of messages and add them to the mpool
+	for i := 20; i < 30; i++ {
+		m := makeTestMessage(w1, a1, a2, uint64(i), gasLimit, uint64(2*i+200))
+		mustAdd(t, mp, m)
+		m = makeTestMessage(w2, a2, a1, uint64(i), gasLimit, uint64(i+1))
+		mustAdd(t, mp, m)
+	}
+
+	// select messages in the last tipset; this should include the missed messages as well as
+	// the last messages we added, with the first actor's messages first
+	// first we need to update the nonce on the tma
+	tma.setStateNonce(a1, 10)
+	tma.setStateNonce(a2, 10)
+
+	msgs, err = mp.SelectMessages(ts3, 1.0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(msgs) != 20 {
+		t.Fatalf("expected 20 messages, got %d", len(msgs))
+	}
+
+	nextNonce = 20
+	for i := 0; i < 10; i++ {
+		if msgs[i].Message.From != a1 {
+			t.Fatalf("expected message from actor a1")
+		}
+		if msgs[i].Message.Nonce != uint64(nextNonce) {
+			t.Fatalf("expected nonce %d, got %d", msgs[i].Message.Nonce, nextNonce)
+		}
+		nextNonce++
+	}
+
+	nextNonce = 20
+	for i := 10; i < 20; i++ {
+		if msgs[i].Message.From != a2 {
+			t.Fatalf("expected message from actor a2")
+		}
+		if msgs[i].Message.Nonce != uint64(nextNonce) {
+			t.Fatalf("expected nonce %d, got %d", msgs[i].Message.Nonce, nextNonce)
+		}
+		nextNonce++
+	}
+}
+
+func TestMessageSelectionTrimming(t *testing.T) {
+	mp, tma := makeTestMpool()
+
+	// the actors
+	w1, err := wallet.NewWallet(wallet.NewMemKeyStore())
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	a1, err := w1.GenerateKey(crypto.SigTypeSecp256k1)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	w2, err := wallet.NewWallet(wallet.NewMemKeyStore())
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	a2, err := w2.GenerateKey(crypto.SigTypeSecp256k1)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	block := tma.nextBlock()
+	ts := mock.TipSet(block)
+	tma.applyBlock(t, block)
+
+	gasLimit := gasguess.Costs[gasguess.CostKey{Code: builtin.StorageMarketActorCodeID, M: 2}]
+
+	tma.setBalance(a1, 1) // in FIL
+	tma.setBalance(a2, 1) // in FIL
+
+	// make many small chains for the two actors
+	nMessages := int((build.BlockGasLimit / gasLimit) + 1)
+	for i := 0; i < nMessages; i++ {
+		bias := (nMessages - i) / 3
+		m := makeTestMessage(w1, a1, a2, uint64(i), gasLimit, uint64(1+i%3+bias))
+		mustAdd(t, mp, m)
+		m = makeTestMessage(w2, a2, a1, uint64(i), gasLimit, uint64(1+i%3+bias))
+		mustAdd(t, mp, m)
+	}
+
+	msgs, err := mp.SelectMessages(ts, 1.0)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	expected := int(build.BlockGasLimit / gasLimit)
+	if len(msgs) != expected {
+		t.Fatalf("expected %d messages, bug got %d", expected, len(msgs))
+	}
+
+	mGasLimit := int64(0)
+	for _, m := range msgs {
+		mGasLimit += m.Message.GasLimit
+	}
+	if mGasLimit > build.BlockGasLimit {
+		t.Fatal("selected messages gas limit exceeds block gas limit!")
+	}
+
+}
+
+func TestPriorityMessageSelection(t *testing.T) {
+	mp, tma := makeTestMpool()
+
+	// the actors
+	w1, err := wallet.NewWallet(wallet.NewMemKeyStore())
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	a1, err := w1.GenerateKey(crypto.SigTypeSecp256k1)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	w2, err := wallet.NewWallet(wallet.NewMemKeyStore())
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	a2, err := w2.GenerateKey(crypto.SigTypeSecp256k1)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	block := tma.nextBlock()
+	ts := mock.TipSet(block)
+	tma.applyBlock(t, block)
+
+	gasLimit := gasguess.Costs[gasguess.CostKey{Code: builtin.StorageMarketActorCodeID, M: 2}]
+
+	tma.setBalance(a1, 1) // in FIL
+	tma.setBalance(a2, 1) // in FIL
+
+	mp.cfg.PriorityAddrs = []address.Address{a1}
+
+	nMessages := 10
+	for i := 0; i < nMessages; i++ {
+		bias := (nMessages - i) / 3
+		m := makeTestMessage(w1, a1, a2, uint64(i), gasLimit, uint64(1+i%3+bias))
+		mustAdd(t, mp, m)
+		m = makeTestMessage(w2, a2, a1, uint64(i), gasLimit, uint64(1+i%3+bias))
+		mustAdd(t, mp, m)
+	}
+
+	msgs, err := mp.SelectMessages(ts, 1.0)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if len(msgs) != 20 {
+		t.Fatalf("expected 20 messages but got %d", len(msgs))
+	}
+
+	// messages from a1 must be first
+	nextNonce := uint64(0)
+	for i := 0; i < 10; i++ {
+		m := msgs[i]
+		if m.Message.From != a1 {
+			t.Fatal("expected messages from a1 before messages from a2")
+		}
+		if m.Message.Nonce != nextNonce {
+			t.Fatalf("expected nonce %d but got %d", nextNonce, m.Message.Nonce)
+		}
+		nextNonce++
+	}
+
+	nextNonce = 0
+	for i := 10; i < 20; i++ {
+		m := msgs[i]
+		if m.Message.From != a2 {
+			t.Fatal("expected messages from a2 after messages from a1")
+		}
+		if m.Message.Nonce != nextNonce {
+			t.Fatalf("expected nonce %d but got %d", nextNonce, m.Message.Nonce)
+		}
+		nextNonce++
+	}
+}
+
+func TestPriorityMessageSelection2(t *testing.T) {
+	mp, tma := makeTestMpool()
+
+	// the actors
+	w1, err := wallet.NewWallet(wallet.NewMemKeyStore())
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	a1, err := w1.GenerateKey(crypto.SigTypeSecp256k1)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	w2, err := wallet.NewWallet(wallet.NewMemKeyStore())
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	a2, err := w2.GenerateKey(crypto.SigTypeSecp256k1)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	block := tma.nextBlock()
+	ts := mock.TipSet(block)
+	tma.applyBlock(t, block)
+
+	gasLimit := gasguess.Costs[gasguess.CostKey{Code: builtin.StorageMarketActorCodeID, M: 2}]
+
+	tma.setBalance(a1, 1) // in FIL
+	tma.setBalance(a2, 1) // in FIL
+
+	mp.cfg.PriorityAddrs = []address.Address{a1}
+
+	nMessages := int(2 * build.BlockGasLimit / gasLimit)
+	for i := 0; i < nMessages; i++ {
+		bias := (nMessages - i) / 3
+		m := makeTestMessage(w1, a1, a2, uint64(i), gasLimit, uint64(1+i%3+bias))
+		mustAdd(t, mp, m)
+		m = makeTestMessage(w2, a2, a1, uint64(i), gasLimit, uint64(1+i%3+bias))
+		mustAdd(t, mp, m)
+	}
+
+	msgs, err := mp.SelectMessages(ts, 1.0)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	expectedMsgs := int(build.BlockGasLimit / gasLimit)
+	if len(msgs) != expectedMsgs {
+		t.Fatalf("expected %d messages but got %d", expectedMsgs, len(msgs))
+	}
+
+	// all messages must be from a1
+	nextNonce := uint64(0)
+	for _, m := range msgs {
+		if m.Message.From != a1 {
+			t.Fatal("expected messages from a1 before messages from a2")
+		}
+		if m.Message.Nonce != nextNonce {
+			t.Fatalf("expected nonce %d but got %d", nextNonce, m.Message.Nonce)
+		}
+		nextNonce++
+	}
+}
+
+func TestPriorityMessageSelection3(t *testing.T) {
+	t.Skip("reenable after removing allow negative")
+
+	mp, tma := makeTestMpool()
+
+	// the actors
+	w1, err := wallet.NewWallet(wallet.NewMemKeyStore())
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	a1, err := w1.GenerateKey(crypto.SigTypeSecp256k1)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	w2, err := wallet.NewWallet(wallet.NewMemKeyStore())
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	a2, err := w2.GenerateKey(crypto.SigTypeSecp256k1)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	block := tma.nextBlock()
+	ts := mock.TipSet(block)
+	tma.applyBlock(t, block)
+
+	gasLimit := gasguess.Costs[gasguess.CostKey{Code: builtin.StorageMarketActorCodeID, M: 2}]
+
+	tma.setBalance(a1, 1) // in FIL
+	tma.setBalance(a2, 1) // in FIL
+
+	mp.cfg.PriorityAddrs = []address.Address{a1}
+
+	tma.baseFee = types.NewInt(1000)
+	nMessages := 10
+	for i := 0; i < nMessages; i++ {
+		bias := (nMessages - i) / 3
+		m := makeTestMessage(w1, a1, a2, uint64(i), gasLimit, uint64(1000+i%3+bias))
+		mustAdd(t, mp, m)
+		// messages from a2 have negative performance
+		m = makeTestMessage(w2, a2, a1, uint64(i), gasLimit, 100)
+		mustAdd(t, mp, m)
+	}
+
+	// test greedy selection
+	msgs, err := mp.SelectMessages(ts, 1.0)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	expectedMsgs := 10
+	if len(msgs) != expectedMsgs {
+		t.Fatalf("expected %d messages but got %d", expectedMsgs, len(msgs))
+	}
+
+	// all messages must be from a1
+	nextNonce := uint64(0)
+	for _, m := range msgs {
+		if m.Message.From != a1 {
+			t.Fatal("expected messages from a1 before messages from a2")
+		}
+		if m.Message.Nonce != nextNonce {
+			t.Fatalf("expected nonce %d but got %d", nextNonce, m.Message.Nonce)
+		}
+		nextNonce++
+	}
+
+	// test optimal selection
+	msgs, err = mp.SelectMessages(ts, 0.1)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	expectedMsgs = 10
+	if len(msgs) != expectedMsgs {
+		t.Fatalf("expected %d messages but got %d", expectedMsgs, len(msgs))
+	}
+
+	// all messages must be from a1
+	nextNonce = uint64(0)
+	for _, m := range msgs {
+		if m.Message.From != a1 {
+			t.Fatal("expected messages from a1 before messages from a2")
+		}
+		if m.Message.Nonce != nextNonce {
+			t.Fatalf("expected nonce %d but got %d", nextNonce, m.Message.Nonce)
+		}
+		nextNonce++
+	}
+
+}
+
+func TestOptimalMessageSelection1(t *testing.T) {
+	// this test uses just a single actor sending messages with a low tq
+	// the chain depenent merging algorithm should pick messages from the actor
+	// from the start
+	mp, tma := makeTestMpool()
+
+	// the actors
+	w1, err := wallet.NewWallet(wallet.NewMemKeyStore())
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	a1, err := w1.GenerateKey(crypto.SigTypeSecp256k1)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	w2, err := wallet.NewWallet(wallet.NewMemKeyStore())
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	a2, err := w2.GenerateKey(crypto.SigTypeSecp256k1)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	block := tma.nextBlock()
+	ts := mock.TipSet(block)
+	tma.applyBlock(t, block)
+
+	gasLimit := gasguess.Costs[gasguess.CostKey{Code: builtin.StorageMarketActorCodeID, M: 2}]
+
+	tma.setBalance(a1, 1) // in FIL
+	tma.setBalance(a2, 1) // in FIL
+
+	nMessages := int(10 * build.BlockGasLimit / gasLimit)
+	for i := 0; i < nMessages; i++ {
+		bias := (nMessages - i) / 3
+		m := makeTestMessage(w1, a1, a2, uint64(i), gasLimit, uint64(1+i%3+bias))
+		mustAdd(t, mp, m)
+	}
+
+	msgs, err := mp.SelectMessages(ts, 0.25)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	expectedMsgs := int(build.BlockGasLimit / gasLimit)
+	if len(msgs) != expectedMsgs {
+		t.Fatalf("expected %d messages, but got %d", expectedMsgs, len(msgs))
+	}
+
+	nextNonce := uint64(0)
+	for _, m := range msgs {
+		if m.Message.From != a1 {
+			t.Fatal("expected message from a1")
+		}
+
+		if m.Message.Nonce != nextNonce {
+			t.Fatalf("expected nonce %d but got %d", nextNonce, m.Message.Nonce)
+		}
+		nextNonce++
+	}
+}
+
+func TestOptimalMessageSelection2(t *testing.T) {
+	// this test uses two actors sending messages to each other, with the first
+	// actor paying (much) higher gas premium than the second.
+	// We select with a low ticket quality; the chain depenent merging algorithm should pick
+	// messages from the second actor from the start
+	mp, tma := makeTestMpool()
+
+	// the actors
+	w1, err := wallet.NewWallet(wallet.NewMemKeyStore())
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	a1, err := w1.GenerateKey(crypto.SigTypeSecp256k1)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	w2, err := wallet.NewWallet(wallet.NewMemKeyStore())
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	a2, err := w2.GenerateKey(crypto.SigTypeSecp256k1)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	block := tma.nextBlock()
+	ts := mock.TipSet(block)
+	tma.applyBlock(t, block)
+
+	gasLimit := gasguess.Costs[gasguess.CostKey{Code: builtin.StorageMarketActorCodeID, M: 2}]
+
+	tma.setBalance(a1, 1) // in FIL
+	tma.setBalance(a2, 1) // in FIL
+
+	nMessages := int(5 * build.BlockGasLimit / gasLimit)
+	for i := 0; i < nMessages; i++ {
+		bias := (nMessages - i) / 3
+		m := makeTestMessage(w1, a1, a2, uint64(i), gasLimit, uint64(200000+i%3+bias))
+		mustAdd(t, mp, m)
+		m = makeTestMessage(w2, a2, a1, uint64(i), gasLimit, uint64(190000+i%3+bias))
+		mustAdd(t, mp, m)
+	}
+
+	msgs, err := mp.SelectMessages(ts, 0.1)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	expectedMsgs := int(build.BlockGasLimit / gasLimit)
+	if len(msgs) != expectedMsgs {
+		t.Fatalf("expected %d messages, but got %d", expectedMsgs, len(msgs))
+	}
+
+	var nFrom1, nFrom2 int
+	var nextNonce1, nextNonce2 uint64
+	for _, m := range msgs {
+		if m.Message.From == a1 {
+			if m.Message.Nonce != nextNonce1 {
+				t.Fatalf("expected nonce %d but got %d", nextNonce1, m.Message.Nonce)
+			}
+			nextNonce1++
+			nFrom1++
+		} else {
+			if m.Message.Nonce != nextNonce2 {
+				t.Fatalf("expected nonce %d but got %d", nextNonce2, m.Message.Nonce)
+			}
+			nextNonce2++
+			nFrom2++
+		}
+	}
+
+	if nFrom1 > nFrom2 {
+		t.Fatalf("expected more messages from a2 than a1; nFrom1=%d nFrom2=%d", nFrom1, nFrom2)
+	}
+}
+
+func TestOptimalMessageSelection3(t *testing.T) {
+	// this test uses 10 actors sending a block of messages to each other, with the the first
+	// actors paying higher gas premium than the subsequent actors.
+	// We select with a low ticket quality; the chain depenent merging algorithm should pick
+	// messages from the median actor from the start
+	mp, tma := makeTestMpool()
+
+	nActors := 10
+	// the actors
+	var actors []address.Address
+	var wallets []*wallet.Wallet
+
+	for i := 0; i < nActors; i++ {
+		w, err := wallet.NewWallet(wallet.NewMemKeyStore())
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		a, err := w.GenerateKey(crypto.SigTypeSecp256k1)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		actors = append(actors, a)
+		wallets = append(wallets, w)
+	}
+
+	block := tma.nextBlock()
+	ts := mock.TipSet(block)
+	tma.applyBlock(t, block)
+
+	gasLimit := gasguess.Costs[gasguess.CostKey{Code: builtin.StorageMarketActorCodeID, M: 2}]
+
+	for _, a := range actors {
+		tma.setBalance(a, 1) // in FIL
+	}
+
+	nMessages := int(build.BlockGasLimit/gasLimit) + 1
+	for i := 0; i < nMessages; i++ {
+		for j := 0; j < nActors; j++ {
+			premium := 500000 + 10000*(nActors-j) + (nMessages+2-i)/(30*nActors) + i%3
+			m := makeTestMessage(wallets[j], actors[j], actors[j%nActors], uint64(i), gasLimit, uint64(premium))
+			mustAdd(t, mp, m)
+		}
+	}
+
+	msgs, err := mp.SelectMessages(ts, 0.1)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	expectedMsgs := int(build.BlockGasLimit / gasLimit)
+	if len(msgs) != expectedMsgs {
+		t.Fatalf("expected %d messages, but got %d", expectedMsgs, len(msgs))
+	}
+
+	whoIs := func(a address.Address) int {
+		for i, aa := range actors {
+			if a == aa {
+				return i
+			}
+		}
+		return -1
+	}
+
+	nonces := make([]uint64, nActors)
+	for _, m := range msgs {
+		who := whoIs(m.Message.From)
+		if who < 3 {
+			t.Fatalf("got message from %dth actor", who)
+		}
+
+		nextNonce := nonces[who]
+		if m.Message.Nonce != nextNonce {
+			t.Fatalf("expected nonce %d but got %d", nextNonce, m.Message.Nonce)
+		}
+		nonces[who]++
+	}
+}
+
+func testCompetitiveMessageSelection(t *testing.T, rng *rand.Rand, getPremium func() uint64) (float64, float64, float64) {
+	// in this test we use 300 actors and send 10 blocks of messages.
+	// actors send with an randomly distributed premium dictated by the getPremium function.
+	// a number of miners select with varying ticket quality and we compare the
+	// capacity and rewards of greedy selection -vs- optimal selection
+	mp, tma := makeTestMpool()
+
+	nActors := 300
+	// the actors
+	var actors []address.Address
+	var wallets []*wallet.Wallet
+
+	for i := 0; i < nActors; i++ {
+		w, err := wallet.NewWallet(wallet.NewMemKeyStore())
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		a, err := w.GenerateKey(crypto.SigTypeSecp256k1)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		actors = append(actors, a)
+		wallets = append(wallets, w)
+	}
+
+	block := tma.nextBlock()
+	ts := mock.TipSet(block)
+	tma.applyBlock(t, block)
+
+	gasLimit := gasguess.Costs[gasguess.CostKey{Code: builtin.StorageMarketActorCodeID, M: 2}]
+	baseFee := types.NewInt(0)
+
+	for _, a := range actors {
+		tma.setBalance(a, 1) // in FIL
+	}
+
+	nMessages := 10 * int(build.BlockGasLimit/gasLimit)
+	t.Log("nMessages", nMessages)
+	nonces := make([]uint64, nActors)
+	for i := 0; i < nMessages; i++ {
+		from := rng.Intn(nActors)
+		to := rng.Intn(nActors)
+		nonce := nonces[from]
+		nonces[from]++
+		premium := getPremium()
+		m := makeTestMessage(wallets[from], actors[from], actors[to], nonce, gasLimit, premium)
+		mustAdd(t, mp, m)
+	}
+
+	logging.SetLogLevel("messagepool", "error")
+
+	// 1. greedy selection
+	greedyMsgs, err := mp.selectMessagesGreedy(ts, ts)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	totalGreedyCapacity := 0.0
+	totalGreedyReward := 0.0
+	totalOptimalCapacity := 0.0
+	totalOptimalReward := 0.0
+	totalBestTQReward := 0.0
+	const runs = 1
+	for i := 0; i < runs; i++ {
+		// 2. optimal selection
+		minersRand := rng.Float64()
+		winerProba := noWinnersProb()
+		i := 0
+		for ; i < MaxBlocks && minersRand > 0; i++ {
+			minersRand -= winerProba[i]
+		}
+		nMiners := i - 1
+		if nMiners < 1 {
+			nMiners = 1
+		}
+
+		optMsgs := make(map[cid.Cid]*types.SignedMessage)
+		bestTq := 0.0
+		var bestMsgs []*types.SignedMessage
+		for j := 0; j < nMiners; j++ {
+			tq := rng.Float64()
+			msgs, err := mp.SelectMessages(ts, tq)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if tq > bestTq {
+				bestMsgs = msgs
+			}
+
+			for _, m := range msgs {
+				optMsgs[m.Cid()] = m
+			}
+		}
+
+		totalGreedyCapacity += float64(len(greedyMsgs))
+		totalOptimalCapacity += float64(len(optMsgs))
+		boost := float64(len(optMsgs)) / float64(len(greedyMsgs))
+
+		t.Logf("nMiners: %d", nMiners)
+		t.Logf("greedy capacity %d, optimal capacity %d (x %.1f )", len(greedyMsgs),
+			len(optMsgs), boost)
+		if len(greedyMsgs) > len(optMsgs) {
+			t.Errorf("greedy capacity higher than optimal capacity; wtf")
+		}
+
+		greedyReward := big.NewInt(0)
+		for _, m := range greedyMsgs {
+			greedyReward.Add(greedyReward, mp.getGasReward(m, baseFee))
+		}
+
+		optReward := big.NewInt(0)
+		for _, m := range optMsgs {
+			optReward.Add(optReward, mp.getGasReward(m, baseFee))
+		}
+
+		bestTqReward := big.NewInt(0)
+		for _, m := range bestMsgs {
+			bestTqReward.Add(bestTqReward, mp.getGasReward(m, baseFee))
+		}
+
+		totalBestTQReward += float64(bestTqReward.Uint64())
+
+		nMinersBig := big.NewInt(int64(nMiners))
+		greedyAvgReward, _ := new(big.Rat).SetFrac(greedyReward, nMinersBig).Float64()
+		totalGreedyReward += greedyAvgReward
+		optimalAvgReward, _ := new(big.Rat).SetFrac(optReward, nMinersBig).Float64()
+		totalOptimalReward += optimalAvgReward
+
+		boost = optimalAvgReward / greedyAvgReward
+		t.Logf("greedy reward: %.0f, optimal reward: %.0f (x %.1f )", greedyAvgReward,
+			optimalAvgReward, boost)
+
+	}
+
+	capacityBoost := totalOptimalCapacity / totalGreedyCapacity
+	rewardBoost := totalOptimalReward / totalGreedyReward
+	t.Logf("Average capacity boost: %f", capacityBoost)
+	t.Logf("Average reward boost: %f", rewardBoost)
+	t.Logf("Average best tq reward: %f", totalBestTQReward/runs/1e12)
+
+	logging.SetLogLevel("messagepool", "info")
+
+	return capacityBoost, rewardBoost, totalBestTQReward / runs / 1e12
+}
+
+func makeExpPremiumDistribution(rng *rand.Rand) func() uint64 {
+	return func() uint64 {
+		premium := 20000*math.Exp(-3.*rng.Float64()) + 5000
+		return uint64(premium)
+	}
+}
+
+func makeZipfPremiumDistribution(rng *rand.Rand) func() uint64 {
+	zipf := rand.NewZipf(rng, 1.001, 1, 40000)
+	return func() uint64 {
+		return zipf.Uint64() + 10000
+	}
+}
+
+func TestCompetitiveMessageSelectionExp(t *testing.T) {
+	if testing.Short() {
+		t.Skip("skipping in short mode")
+	}
+	var capacityBoost, rewardBoost, tqReward float64
+	seeds := []int64{1947, 1976, 2020, 2100, 10000, 143324, 432432, 131, 32, 45}
+	for _, seed := range seeds {
+		t.Log("running competitive message selection with Exponential premium distribution and seed", seed)
+		rng := rand.New(rand.NewSource(seed))
+		cb, rb, tqR := testCompetitiveMessageSelection(t, rng, makeExpPremiumDistribution(rng))
+		capacityBoost += cb
+		rewardBoost += rb
+		tqReward += tqR
+	}
+
+	capacityBoost /= float64(len(seeds))
+	rewardBoost /= float64(len(seeds))
+	tqReward /= float64(len(seeds))
+	t.Logf("Average capacity boost across all seeds: %f", capacityBoost)
+	t.Logf("Average reward boost across all seeds: %f", rewardBoost)
+	t.Logf("Average reward of best ticket across all seeds: %f", tqReward)
+}
+
+func TestCompetitiveMessageSelectionZipf(t *testing.T) {
+	var capacityBoost, rewardBoost, tqReward float64
+	seeds := []int64{1947, 1976, 2020, 2100, 10000, 143324, 432432, 131, 32, 45}
+	for _, seed := range seeds {
+		t.Log("running competitive message selection with Zipf premium distribution and seed", seed)
+		rng := rand.New(rand.NewSource(seed))
+		cb, rb, tqR := testCompetitiveMessageSelection(t, rng, makeZipfPremiumDistribution(rng))
+		capacityBoost += cb
+		rewardBoost += rb
+		tqReward += tqR
+	}
+
+	tqReward /= float64(len(seeds))
+	capacityBoost /= float64(len(seeds))
+	rewardBoost /= float64(len(seeds))
+	t.Logf("Average capacity boost across all seeds: %f", capacityBoost)
+	t.Logf("Average reward boost across all seeds: %f", rewardBoost)
+	t.Logf("Average reward of best ticket across all seeds: %f", tqReward)
+}
+
+func TestGasReward(t *testing.T) {
+	tests := []struct {
+		Premium   uint64
+		FeeCap    uint64
+		BaseFee   uint64
+		GasReward int64
+	}{
+		{Premium: 100, FeeCap: 200, BaseFee: 100, GasReward: 100},
+		{Premium: 100, FeeCap: 200, BaseFee: 210, GasReward: -10},
+		{Premium: 200, FeeCap: 250, BaseFee: 210, GasReward: 40},
+		{Premium: 200, FeeCap: 250, BaseFee: 2000, GasReward: -1750},
+	}
+
+	mp := new(MessagePool)
+	for _, test := range tests {
+		test := test
+		t.Run(fmt.Sprintf("%v", test), func(t *testing.T) {
+			msg := &types.SignedMessage{
+				Message: types.Message{
+					GasLimit:   10,
+					GasFeeCap:  types.NewInt(test.FeeCap),
+					GasPremium: types.NewInt(test.Premium),
+				},
+			}
+			rew := mp.getGasReward(msg, types.NewInt(test.BaseFee))
+			if rew.Cmp(big.NewInt(test.GasReward*10)) != 0 {
+				t.Errorf("bad reward: expected %d, got %s", test.GasReward*10, rew)
+			}
+		})
+	}
+}
+
+func TestRealWorldSelection(t *testing.T) {
+	// load test-messages.json.gz and rewrite the messages so that
+	// 1) we map each real actor to a test actor so that we can sign the messages
+	// 2) adjust the nonces so that they start from 0
+	file, err := os.Open("test-messages.json.gz")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	gzr, err := gzip.NewReader(file)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	dec := json.NewDecoder(gzr)
+
+	var msgs []*types.SignedMessage
+	baseNonces := make(map[address.Address]uint64)
+
+readLoop:
+	for {
+		m := new(types.SignedMessage)
+		err := dec.Decode(m)
+		switch err {
+		case nil:
+			msgs = append(msgs, m)
+			nonce, ok := baseNonces[m.Message.From]
+			if !ok || m.Message.Nonce < nonce {
+				baseNonces[m.Message.From] = m.Message.Nonce
+			}
+
+		case io.EOF:
+			break readLoop
+
+		default:
+			t.Fatal(err)
+		}
+	}
+
+	actorMap := make(map[address.Address]address.Address)
+	actorWallets := make(map[address.Address]*wallet.Wallet)
+
+	for _, m := range msgs {
+		baseNonce := baseNonces[m.Message.From]
+
+		localActor, ok := actorMap[m.Message.From]
+		if !ok {
+			w, err := wallet.NewWallet(wallet.NewMemKeyStore())
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			a, err := w.GenerateKey(crypto.SigTypeSecp256k1)
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			actorMap[m.Message.From] = a
+			actorWallets[a] = w
+			localActor = a
+		}
+
+		w, ok := actorWallets[localActor]
+		if !ok {
+			t.Fatalf("failed to lookup wallet for actor %s", localActor)
+		}
+
+		m.Message.From = localActor
+		m.Message.Nonce -= baseNonce
+
+		sig, err := w.Sign(context.TODO(), localActor, m.Message.Cid().Bytes())
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		m.Signature = *sig
+	}
+
+	mp, tma := makeTestMpool()
+
+	block := tma.nextBlockWithHeight(build.UpgradeBreezeHeight + 10)
+	ts := mock.TipSet(block)
+	tma.applyBlock(t, block)
+
+	for _, a := range actorMap {
+		tma.setBalance(a, 1000000)
+	}
+
+	tma.baseFee = types.NewInt(800_000_000)
+
+	sort.Slice(msgs, func(i, j int) bool {
+		return msgs[i].Message.Nonce < msgs[j].Message.Nonce
+	})
+
+	// add the messages
+	for _, m := range msgs {
+		mustAdd(t, mp, m)
+	}
+
+	// do message selection and check block packing
+	minGasLimit := int64(0.9 * float64(build.BlockGasLimit))
+
+	// greedy first
+	selected, err := mp.SelectMessages(ts, 1.0)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	gasLimit := int64(0)
+	for _, m := range selected {
+		gasLimit += m.Message.GasLimit
+	}
+	if gasLimit < minGasLimit {
+		t.Fatalf("failed to pack with tq=1.0; packed %d, minimum packing: %d", gasLimit, minGasLimit)
+	}
+
+	// high quality ticket
+	selected, err = mp.SelectMessages(ts, .8)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	gasLimit = int64(0)
+	for _, m := range selected {
+		gasLimit += m.Message.GasLimit
+	}
+	if gasLimit < minGasLimit {
+		t.Fatalf("failed to pack with tq=0.8; packed %d, minimum packing: %d", gasLimit, minGasLimit)
+	}
+
+	// mid quality ticket
+	selected, err = mp.SelectMessages(ts, .4)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	gasLimit = int64(0)
+	for _, m := range selected {
+		gasLimit += m.Message.GasLimit
+	}
+	if gasLimit < minGasLimit {
+		t.Fatalf("failed to pack with tq=0.4; packed %d, minimum packing: %d", gasLimit, minGasLimit)
+	}
+
+	// low quality ticket
+	selected, err = mp.SelectMessages(ts, .1)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	gasLimit = int64(0)
+	for _, m := range selected {
+		gasLimit += m.Message.GasLimit
+	}
+	if gasLimit < minGasLimit {
+		t.Fatalf("failed to pack with tq=0.1; packed %d, minimum packing: %d", gasLimit, minGasLimit)
+	}
+
+	// very low quality ticket
+	selected, err = mp.SelectMessages(ts, .01)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	gasLimit = int64(0)
+	for _, m := range selected {
+		gasLimit += m.Message.GasLimit
+	}
+	if gasLimit < minGasLimit {
+		t.Fatalf("failed to pack with tq=0.01; packed %d, minimum packing: %d", gasLimit, minGasLimit)
+	}
+
+}
diff --git a/chain/messagepool/test-messages.json.gz b/chain/messagepool/test-messages.json.gz
new file mode 100644
index 000000000..09481e1f8
Binary files /dev/null and b/chain/messagepool/test-messages.json.gz differ
diff --git a/chain/metrics/consensus.go b/chain/metrics/consensus.go
index b0352860e..c3c4a10d1 100644
--- a/chain/metrics/consensus.go
+++ b/chain/metrics/consensus.go
@@ -3,13 +3,14 @@ package metrics
 import (
 	"context"
 	"encoding/json"
-	"time"
 
+	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/ipfs/go-cid"
-	logging "github.com/ipfs/go-log"
+	logging "github.com/ipfs/go-log/v2"
 	pubsub "github.com/libp2p/go-libp2p-pubsub"
 	"go.uber.org/fx"
 
+	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/node/impl/full"
 	"github.com/filecoin-project/lotus/node/modules/helpers"
@@ -43,7 +44,7 @@ func SendHeadNotifs(nickname string) func(mctx helpers.MetricsCtx, lc fx.Lifecyc
 					}
 				}()
 				go func() {
-					sub, err := ps.Subscribe(topic)
+					sub, err := ps.Subscribe(topic) //nolint
 					if err != nil {
 						return
 					}
@@ -68,7 +69,7 @@ type message struct {
 	// TipSet
 	Cids   []cid.Cid
 	Blocks []*types.BlockHeader
-	Height uint64
+	Height abi.ChainEpoch
 	Weight types.BigInt
 	Time   uint64
 	Nonce  uint64
@@ -88,14 +89,14 @@ func sendHeadNotifs(ctx context.Context, ps *pubsub.PubSub, topic string, chain
 	}
 
 	// using unix nano time makes very sure we pick a nonce higher than previous restart
-	nonce := uint64(time.Now().UnixNano())
+	nonce := uint64(build.Clock.Now().UnixNano())
 
 	for {
 		select {
 		case notif := <-notifs:
 			n := notif[len(notif)-1]
 
-			w, err := chain.ChainTipSetWeight(ctx, n.Val)
+			w, err := chain.ChainTipSetWeight(ctx, n.Val.Key())
 			if err != nil {
 				return err
 			}
@@ -106,7 +107,7 @@ func sendHeadNotifs(ctx context.Context, ps *pubsub.PubSub, topic string, chain
 				Height:   n.Val.Height(),
 				Weight:   w,
 				NodeName: nickname,
-				Time:     uint64(time.Now().UnixNano() / 1000_000),
+				Time:     uint64(build.Clock.Now().UnixNano() / 1000_000),
 				Nonce:    nonce,
 			}
 
@@ -115,6 +116,7 @@ func sendHeadNotifs(ctx context.Context, ps *pubsub.PubSub, topic string, chain
 				return err
 			}
 
+			//nolint
 			if err := ps.Publish(topic, b); err != nil {
 				return err
 			}
diff --git a/chain/state/statetree.go b/chain/state/statetree.go
index fc3da47e4..fe932bfa1 100644
--- a/chain/state/statetree.go
+++ b/chain/state/statetree.go
@@ -1,48 +1,176 @@
 package state
 
 import (
+	"bytes"
 	"context"
 	"fmt"
 
 	"github.com/ipfs/go-cid"
-	hamt "github.com/ipfs/go-hamt-ipld"
-	logging "github.com/ipfs/go-log"
+	cbor "github.com/ipfs/go-ipld-cbor"
+	logging "github.com/ipfs/go-log/v2"
+	"go.opencensus.io/trace"
 	"golang.org/x/xerrors"
 
 	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/lotus/chain/actors"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/lotus/chain/actors/builtin"
+	init_ "github.com/filecoin-project/lotus/chain/actors/builtin/init"
+	cbg "github.com/whyrusleeping/cbor-gen"
+
+	"github.com/filecoin-project/lotus/chain/actors/adt"
 	"github.com/filecoin-project/lotus/chain/types"
 )
 
 var log = logging.Logger("statetree")
 
+// StateTree stores actors state by their ID.
 type StateTree struct {
-	root  *hamt.Node
-	Store *hamt.CborIpldStore
+	root    adt.Map
+	version builtin.Version // TODO
+	info    cid.Cid
+	Store   cbor.IpldStore
 
-	actorcache map[address.Address]*types.Actor
-	snapshot   cid.Cid
+	snaps *stateSnaps
 }
 
-func NewStateTree(cst *hamt.CborIpldStore) (*StateTree, error) {
+type stateSnaps struct {
+	layers []*stateSnapLayer
+}
+
+type stateSnapLayer struct {
+	actors       map[address.Address]streeOp
+	resolveCache map[address.Address]address.Address
+}
+
+func newStateSnapLayer() *stateSnapLayer {
+	return &stateSnapLayer{
+		actors:       make(map[address.Address]streeOp),
+		resolveCache: make(map[address.Address]address.Address),
+	}
+}
+
+type streeOp struct {
+	Act    types.Actor
+	Delete bool
+}
+
+func newStateSnaps() *stateSnaps {
+	ss := &stateSnaps{}
+	ss.addLayer()
+	return ss
+}
+
+func (ss *stateSnaps) addLayer() {
+	ss.layers = append(ss.layers, newStateSnapLayer())
+}
+
+func (ss *stateSnaps) dropLayer() {
+	ss.layers[len(ss.layers)-1] = nil // allow it to be GCed
+	ss.layers = ss.layers[:len(ss.layers)-1]
+}
+
+func (ss *stateSnaps) mergeLastLayer() {
+	last := ss.layers[len(ss.layers)-1]
+	nextLast := ss.layers[len(ss.layers)-2]
+
+	for k, v := range last.actors {
+		nextLast.actors[k] = v
+	}
+
+	for k, v := range last.resolveCache {
+		nextLast.resolveCache[k] = v
+	}
+
+	ss.dropLayer()
+}
+
+func (ss *stateSnaps) resolveAddress(addr address.Address) (address.Address, bool) {
+	for i := len(ss.layers) - 1; i >= 0; i-- {
+		resa, ok := ss.layers[i].resolveCache[addr]
+		if ok {
+			return resa, true
+		}
+	}
+	return address.Undef, false
+}
+
+func (ss *stateSnaps) cacheResolveAddress(addr, resa address.Address) {
+	ss.layers[len(ss.layers)-1].resolveCache[addr] = resa
+}
+
+func (ss *stateSnaps) getActor(addr address.Address) (*types.Actor, error) {
+	for i := len(ss.layers) - 1; i >= 0; i-- {
+		act, ok := ss.layers[i].actors[addr]
+		if ok {
+			if act.Delete {
+				return nil, types.ErrActorNotFound
+			}
+
+			return &act.Act, nil
+		}
+	}
+	return nil, nil
+}
+
+func (ss *stateSnaps) setActor(addr address.Address, act *types.Actor) {
+	ss.layers[len(ss.layers)-1].actors[addr] = streeOp{Act: *act}
+}
+
+func (ss *stateSnaps) deleteActor(addr address.Address) {
+	ss.layers[len(ss.layers)-1].actors[addr] = streeOp{Delete: true}
+}
+
+func NewStateTree(cst cbor.IpldStore, version builtin.Version) (*StateTree, error) {
+	var info cid.Cid
+	switch version {
+	case builtin.Version0:
+		// info is undefined
+	default:
+		return nil, xerrors.Errorf("unsupported state tree version: %d", version)
+	}
+	root, err := adt.NewMap(adt.WrapStore(context.TODO(), cst), version)
+	if err != nil {
+		return nil, err
+	}
+
 	return &StateTree{
-		root:       hamt.NewNode(cst),
-		Store:      cst,
-		actorcache: make(map[address.Address]*types.Actor),
+		root:    root,
+		info:    info,
+		version: version,
+		Store:   cst,
+		snaps:   newStateSnaps(),
 	}, nil
 }
 
-func LoadStateTree(cst *hamt.CborIpldStore, c cid.Cid) (*StateTree, error) {
-	nd, err := hamt.LoadNode(context.Background(), cst, c)
+func LoadStateTree(cst cbor.IpldStore, c cid.Cid) (*StateTree, error) {
+	var root types.StateRoot
+	// Try loading as a new-style state-tree (version/actors tuple).
+	if err := cst.Get(context.TODO(), c, &root); err != nil {
+		// We failed to decode as the new version, must be an old version.
+		root.Actors = c
+		root.Version = builtin.Version0
+	}
+
+	// If that fails, load as an old-style state-tree (direct hampt, version 0.
+	nd, err := adt.AsMap(adt.WrapStore(context.TODO(), cst), root.Actors, builtin.Version(root.Version))
 	if err != nil {
 		log.Errorf("loading hamt node %s failed: %s", c, err)
 		return nil, err
 	}
 
+	switch root.Version {
+	case builtin.Version0:
+		// supported
+	default:
+		return nil, xerrors.Errorf("unsupported state tree version: %d", root.Version)
+	}
+
 	return &StateTree{
-		root:       nd,
-		Store:      cst,
-		actorcache: make(map[address.Address]*types.Actor),
+		root:    nd,
+		info:    root.Info,
+		version: builtin.Version(root.Version),
+		Store:   cst,
+		snaps:   newStateSnaps(),
 	}, nil
 }
 
@@ -53,109 +181,165 @@ func (st *StateTree) SetActor(addr address.Address, act *types.Actor) error {
 	}
 	addr = iaddr
 
-	cact, ok := st.actorcache[addr]
-	if ok {
-		if act == cact {
-			return nil
-		}
-	}
-
-	st.actorcache[addr] = act
-
-	return st.root.Set(context.TODO(), string(addr.Bytes()), act)
+	st.snaps.setActor(addr, act)
+	return nil
 }
 
+// LookupID gets the ID address of this actor's `addr` stored in the `InitActor`.
 func (st *StateTree) LookupID(addr address.Address) (address.Address, error) {
 	if addr.Protocol() == address.ID {
 		return addr, nil
 	}
 
-	act, err := st.GetActor(actors.InitAddress)
+	resa, ok := st.snaps.resolveAddress(addr)
+	if ok {
+		return resa, nil
+	}
+
+	act, err := st.GetActor(init_.Address)
 	if err != nil {
 		return address.Undef, xerrors.Errorf("getting init actor: %w", err)
 	}
 
-	var ias actors.InitActorState
-	if err := st.Store.Get(context.TODO(), act.Head, &ias); err != nil {
+	ias, err := init_.Load(&AdtStore{st.Store}, act)
+	if err != nil {
 		return address.Undef, xerrors.Errorf("loading init actor state: %w", err)
 	}
 
-	return ias.Lookup(st.Store, addr)
+	a, found, err := ias.ResolveAddress(addr)
+	if err == nil && !found {
+		err = types.ErrActorNotFound
+	}
+	if err != nil {
+		return address.Undef, xerrors.Errorf("resolve address %s: %w", addr, err)
+	}
+
+	st.snaps.cacheResolveAddress(addr, a)
+
+	return a, nil
 }
 
+// GetActor returns the actor from any type of `addr` provided.
 func (st *StateTree) GetActor(addr address.Address) (*types.Actor, error) {
 	if addr == address.Undef {
 		return nil, fmt.Errorf("GetActor called on undefined address")
 	}
 
+	// Transform `addr` to its ID format.
 	iaddr, err := st.LookupID(addr)
 	if err != nil {
-		if xerrors.Is(err, hamt.ErrNotFound) {
-			return nil, xerrors.Errorf("resolution lookup failed (%s): %w", addr, types.ErrActorNotFound)
+		if xerrors.Is(err, types.ErrActorNotFound) {
+			return nil, xerrors.Errorf("resolution lookup failed (%s): %w", addr, err)
 		}
 		return nil, xerrors.Errorf("address resolution: %w", err)
 	}
 	addr = iaddr
 
-	cact, ok := st.actorcache[addr]
-	if ok {
-		return cact, nil
+	snapAct, err := st.snaps.getActor(addr)
+	if err != nil {
+		return nil, err
+	}
+
+	if snapAct != nil {
+		return snapAct, nil
 	}
 
 	var act types.Actor
-	err = st.root.Find(context.TODO(), string(addr.Bytes()), &act)
-	if err != nil {
-		if err == hamt.ErrNotFound {
-			return nil, types.ErrActorNotFound
-		}
+	if found, err := st.root.Get(abi.AddrKey(addr), &act); err != nil {
 		return nil, xerrors.Errorf("hamt find failed: %w", err)
+	} else if !found {
+		return nil, types.ErrActorNotFound
 	}
 
-	st.actorcache[addr] = &act
+	st.snaps.setActor(addr, &act)
 
 	return &act, nil
 }
 
-func (st *StateTree) Flush() (cid.Cid, error) {
-	for addr, act := range st.actorcache {
-		if err := st.root.Set(context.TODO(), string(addr.Bytes()), act); err != nil {
-			return cid.Undef, err
+func (st *StateTree) DeleteActor(addr address.Address) error {
+	if addr == address.Undef {
+		return xerrors.Errorf("DeleteActor called on undefined address")
+	}
+
+	iaddr, err := st.LookupID(addr)
+	if err != nil {
+		if xerrors.Is(err, types.ErrActorNotFound) {
+			return xerrors.Errorf("resolution lookup failed (%s): %w", addr, err)
 		}
-	}
-	st.actorcache = make(map[address.Address]*types.Actor)
-
-	if err := st.root.Flush(context.TODO()); err != nil {
-		return cid.Undef, err
+		return xerrors.Errorf("address resolution: %w", err)
 	}
 
-	return st.Store.Put(context.TODO(), st.root)
-}
+	addr = iaddr
 
-func (st *StateTree) Snapshot() error {
-	ss, err := st.Flush()
+	_, err = st.GetActor(addr)
 	if err != nil {
 		return err
 	}
 
-	st.snapshot = ss
+	st.snaps.deleteActor(addr)
+
 	return nil
 }
 
-func (st *StateTree) RegisterNewAddress(addr address.Address, act *types.Actor) (address.Address, error) {
+func (st *StateTree) Flush(ctx context.Context) (cid.Cid, error) {
+	ctx, span := trace.StartSpan(ctx, "stateTree.Flush") //nolint:staticcheck
+	defer span.End()
+	if len(st.snaps.layers) != 1 {
+		return cid.Undef, xerrors.Errorf("tried to flush state tree with snapshots on the stack")
+	}
+
+	for addr, sto := range st.snaps.layers[0].actors {
+		if sto.Delete {
+			if err := st.root.Delete(abi.AddrKey(addr)); err != nil {
+				return cid.Undef, err
+			}
+		} else {
+			if err := st.root.Put(abi.AddrKey(addr), &sto.Act); err != nil {
+				return cid.Undef, err
+			}
+		}
+	}
+
+	root, err := st.root.Root()
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("failed to flush state-tree hamt: %w", err)
+	}
+	// If we're version 0, return a raw tree.
+	if st.version == builtin.Version0 {
+		return root, nil
+	}
+	// Otherwise, return a versioned tree.
+	return st.Store.Put(ctx, &types.StateRoot{Version: uint64(st.version), Actors: root, Info: st.info})
+}
+
+func (st *StateTree) Snapshot(ctx context.Context) error {
+	ctx, span := trace.StartSpan(ctx, "stateTree.SnapShot") //nolint:staticcheck
+	defer span.End()
+
+	st.snaps.addLayer()
+
+	return nil
+}
+
+func (st *StateTree) ClearSnapshot() {
+	st.snaps.mergeLastLayer()
+}
+
+func (st *StateTree) RegisterNewAddress(addr address.Address) (address.Address, error) {
 	var out address.Address
-	err := st.MutateActor(actors.InitAddress, func(initact *types.Actor) error {
-		var ias actors.InitActorState
-		if err := st.Store.Get(context.TODO(), initact.Head, &ias); err != nil {
+	err := st.MutateActor(init_.Address, func(initact *types.Actor) error {
+		ias, err := init_.Load(&AdtStore{st.Store}, initact)
+		if err != nil {
 			return err
 		}
 
-		oaddr, err := ias.AddActor(st.Store, addr)
+		oaddr, err := ias.MapAddressToNewID(addr)
 		if err != nil {
 			return err
 		}
 		out = oaddr
 
-		ncid, err := st.Store.Put(context.TODO(), &ias)
+		ncid, err := st.Store.Put(context.TODO(), ias)
 		if err != nil {
 			return err
 		}
@@ -167,20 +351,21 @@ func (st *StateTree) RegisterNewAddress(addr address.Address, act *types.Actor)
 		return address.Undef, err
 	}
 
-	if err := st.SetActor(out, act); err != nil {
-		return address.Undef, err
-	}
-
 	return out, nil
 }
 
-func (st *StateTree) Revert() error {
-	nd, err := hamt.LoadNode(context.Background(), st.Store, st.snapshot)
-	if err != nil {
-		return err
-	}
+type AdtStore struct{ cbor.IpldStore }
+
+func (a *AdtStore) Context() context.Context {
+	return context.TODO()
+}
+
+var _ adt.Store = (*AdtStore)(nil)
+
+func (st *StateTree) Revert() error {
+	st.snaps.dropLayer()
+	st.snaps.addLayer()
 
-	st.root = nd
 	return nil
 }
 
@@ -196,3 +381,62 @@ func (st *StateTree) MutateActor(addr address.Address, f func(*types.Actor) erro
 
 	return st.SetActor(addr, act)
 }
+
+func (st *StateTree) ForEach(f func(address.Address, *types.Actor) error) error {
+	var act types.Actor
+	return st.root.ForEach(&act, func(k string) error {
+		act := act // copy
+		addr, err := address.NewFromBytes([]byte(k))
+		if err != nil {
+			return xerrors.Errorf("invalid address (%x) found in state tree key: %w", []byte(k), err)
+		}
+
+		return f(addr, &act)
+	})
+}
+
+// Version returns the version of the StateTree data structure in use.
+func (st *StateTree) Version() builtin.Version {
+	return st.version
+}
+
+func Diff(oldTree, newTree *StateTree) (map[string]types.Actor, error) {
+	out := map[string]types.Actor{}
+
+	var (
+		ncval, ocval cbg.Deferred
+		buf          = bytes.NewReader(nil)
+	)
+	if err := newTree.root.ForEach(&ncval, func(k string) error {
+		var act types.Actor
+
+		addr, err := address.NewFromBytes([]byte(k))
+		if err != nil {
+			return xerrors.Errorf("address in state tree was not valid: %w", err)
+		}
+
+		found, err := oldTree.root.Get(abi.AddrKey(addr), &ocval)
+		if err != nil {
+			return err
+		}
+
+		if found && bytes.Equal(ocval.Raw, ncval.Raw) {
+			return nil // not changed
+		}
+
+		buf.Reset(ncval.Raw)
+		err = act.UnmarshalCBOR(buf)
+		buf.Reset(nil)
+
+		if err != nil {
+			return err
+		}
+
+		out[addr.String()] = act
+
+		return nil
+	}); err != nil {
+		return nil, err
+	}
+	return out, nil
+}
diff --git a/chain/state/statetree_test.go b/chain/state/statetree_test.go
index a12bbbeca..79ab20606 100644
--- a/chain/state/statetree_test.go
+++ b/chain/state/statetree_test.go
@@ -1,17 +1,24 @@
 package state
 
 import (
+	"context"
+	"fmt"
 	"testing"
 
+	"github.com/ipfs/go-cid"
+	cbor "github.com/ipfs/go-ipld-cbor"
+
 	address "github.com/filecoin-project/go-address"
-	actors "github.com/filecoin-project/lotus/chain/actors"
+	"github.com/filecoin-project/specs-actors/actors/builtin"
+
+	"github.com/filecoin-project/lotus/build"
+	builtin2 "github.com/filecoin-project/lotus/chain/actors/builtin"
 	"github.com/filecoin-project/lotus/chain/types"
-	hamt "github.com/ipfs/go-hamt-ipld"
 )
 
 func BenchmarkStateTreeSet(b *testing.B) {
-	cst := hamt.NewCborStore()
-	st, err := NewStateTree(cst)
+	cst := cbor.NewMemCborStore()
+	st, err := NewStateTree(cst, builtin2.VersionForNetwork(build.NewestNetworkVersion))
 	if err != nil {
 		b.Fatal(err)
 	}
@@ -26,8 +33,8 @@ func BenchmarkStateTreeSet(b *testing.B) {
 		}
 		err = st.SetActor(a, &types.Actor{
 			Balance: types.NewInt(1258812523),
-			Code:    actors.StorageMinerCodeCid,
-			Head:    actors.AccountCodeCid,
+			Code:    builtin.StorageMinerActorCodeID,
+			Head:    builtin.AccountActorCodeID,
 			Nonce:   uint64(i),
 		})
 		if err != nil {
@@ -37,8 +44,8 @@ func BenchmarkStateTreeSet(b *testing.B) {
 }
 
 func BenchmarkStateTreeSetFlush(b *testing.B) {
-	cst := hamt.NewCborStore()
-	st, err := NewStateTree(cst)
+	cst := cbor.NewMemCborStore()
+	st, err := NewStateTree(cst, builtin2.VersionForNetwork(build.NewestNetworkVersion))
 	if err != nil {
 		b.Fatal(err)
 	}
@@ -53,22 +60,22 @@ func BenchmarkStateTreeSetFlush(b *testing.B) {
 		}
 		err = st.SetActor(a, &types.Actor{
 			Balance: types.NewInt(1258812523),
-			Code:    actors.StorageMinerCodeCid,
-			Head:    actors.AccountCodeCid,
+			Code:    builtin.StorageMinerActorCodeID,
+			Head:    builtin.AccountActorCodeID,
 			Nonce:   uint64(i),
 		})
 		if err != nil {
 			b.Fatal(err)
 		}
-		if _, err := st.Flush(); err != nil {
+		if _, err := st.Flush(context.TODO()); err != nil {
 			b.Fatal(err)
 		}
 	}
 }
 
 func BenchmarkStateTree10kGetActor(b *testing.B) {
-	cst := hamt.NewCborStore()
-	st, err := NewStateTree(cst)
+	cst := cbor.NewMemCborStore()
+	st, err := NewStateTree(cst, builtin2.VersionForNetwork(build.NewestNetworkVersion))
 	if err != nil {
 		b.Fatal(err)
 	}
@@ -79,8 +86,8 @@ func BenchmarkStateTree10kGetActor(b *testing.B) {
 		}
 		err = st.SetActor(a, &types.Actor{
 			Balance: types.NewInt(1258812523 + uint64(i)),
-			Code:    actors.StorageMinerCodeCid,
-			Head:    actors.AccountCodeCid,
+			Code:    builtin.StorageMinerActorCodeID,
+			Head:    builtin.AccountActorCodeID,
 			Nonce:   uint64(i),
 		})
 		if err != nil {
@@ -88,7 +95,7 @@ func BenchmarkStateTree10kGetActor(b *testing.B) {
 		}
 	}
 
-	if _, err := st.Flush(); err != nil {
+	if _, err := st.Flush(context.TODO()); err != nil {
 		b.Fatal(err)
 	}
 
@@ -109,8 +116,8 @@ func BenchmarkStateTree10kGetActor(b *testing.B) {
 }
 
 func TestSetCache(t *testing.T) {
-	cst := hamt.NewCborStore()
-	st, err := NewStateTree(cst)
+	cst := cbor.NewMemCborStore()
+	st, err := NewStateTree(cst, builtin2.VersionForNetwork(build.NewestNetworkVersion))
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -122,8 +129,8 @@ func TestSetCache(t *testing.T) {
 
 	act := &types.Actor{
 		Balance: types.NewInt(0),
-		Code:    actors.StorageMinerCodeCid,
-		Head:    actors.AccountCodeCid,
+		Code:    builtin.StorageMinerActorCodeID,
+		Head:    builtin.AccountActorCodeID,
 		Nonce:   0,
 	}
 
@@ -139,7 +146,136 @@ func TestSetCache(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	if outact.Nonce != act.Nonce {
-		t.Error("nonce didn't match")
+	if outact.Nonce == 1 {
+		t.Error("nonce should not have updated")
+	}
+}
+
+func TestSnapshots(t *testing.T) {
+	ctx := context.Background()
+	cst := cbor.NewMemCborStore()
+	st, err := NewStateTree(cst, builtin2.VersionForNetwork(build.NewestNetworkVersion))
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	var addrs []address.Address
+	//for _, a := range []string{"t15ocrptbu4i5qucjvvwecihd7fqqgzb27pz5l5zy", "t1dpyvgavvl3f4ujlk6odedss54z6rt5gyuknsuva", "t1feiejbkcvozy7iltt2pxzuoq4d2kpbsusugan7a", "t3rgjfqybjx7bahuhfv7nwfg3tlm4i4zyvldfirjvzm5z5xwjoqbj3rfi2mpmlxpqwxxxafgpkjilqzpg7cefa"} {
+	for _, a := range []string{"t0100", "t0101", "t0102", "t0103"} {
+		addr, err := address.NewFromString(a)
+		if err != nil {
+			t.Fatal(err)
+		}
+		addrs = append(addrs, addr)
+	}
+
+	if err := st.Snapshot(ctx); err != nil {
+		t.Fatal(err)
+	}
+
+	if err := st.SetActor(addrs[0], &types.Actor{Code: builtin.AccountActorCodeID, Head: builtin.AccountActorCodeID, Balance: types.NewInt(55)}); err != nil {
+		t.Fatal(err)
+	}
+
+	{ // sub call that will fail
+		if err := st.Snapshot(ctx); err != nil {
+			t.Fatal(err)
+		}
+
+		if err := st.SetActor(addrs[1], &types.Actor{Code: builtin.AccountActorCodeID, Head: builtin.AccountActorCodeID, Balance: types.NewInt(77)}); err != nil {
+			t.Fatal(err)
+		}
+
+		if err := st.Revert(); err != nil {
+			t.Fatal(err)
+		}
+		st.ClearSnapshot()
+	}
+
+	// more operations in top level call...
+	if err := st.SetActor(addrs[2], &types.Actor{Code: builtin.AccountActorCodeID, Head: builtin.AccountActorCodeID, Balance: types.NewInt(123)}); err != nil {
+		t.Fatal(err)
+	}
+
+	{ // sub call that succeeds
+		if err := st.Snapshot(ctx); err != nil {
+			t.Fatal(err)
+		}
+
+		if err := st.SetActor(addrs[3], &types.Actor{Code: builtin.AccountActorCodeID, Head: builtin.AccountActorCodeID, Balance: types.NewInt(5)}); err != nil {
+			t.Fatal(err)
+		}
+
+		st.ClearSnapshot()
+	}
+
+	st.ClearSnapshot()
+
+	if _, err := st.Flush(ctx); err != nil {
+		t.Fatal(err)
+	}
+
+	assertHas(t, st, addrs[0])
+	assertNotHas(t, st, addrs[1])
+	assertHas(t, st, addrs[2])
+	assertHas(t, st, addrs[3])
+}
+
+func assertHas(t *testing.T, st *StateTree, addr address.Address) {
+	_, err := st.GetActor(addr)
+	if err != nil {
+		t.Fatal(err)
+	}
+}
+
+func assertNotHas(t *testing.T, st *StateTree, addr address.Address) {
+	_, err := st.GetActor(addr)
+	if err == nil {
+		t.Fatal("shouldnt have found actor", addr)
+	}
+}
+
+func TestStateTreeConsistency(t *testing.T) {
+	cst := cbor.NewMemCborStore()
+	st, err := NewStateTree(cst, builtin2.VersionForNetwork(build.NewestNetworkVersion))
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	var addrs []address.Address
+	for i := 100; i < 150; i++ {
+		a, err := address.NewIDAddress(uint64(i))
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		addrs = append(addrs, a)
+	}
+
+	randomCid, err := cid.Decode("bafy2bzacecu7n7wbtogznrtuuvf73dsz7wasgyneqasksdblxupnyovmtwxxu")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	for i, a := range addrs {
+		err := st.SetActor(a, &types.Actor{
+			Code:    randomCid,
+			Head:    randomCid,
+			Balance: types.NewInt(uint64(10000 + i)),
+			Nonce:   uint64(1000 - i),
+		})
+		if err != nil {
+			t.Fatalf("while setting actor: %+v", err)
+		}
+	}
+
+	root, err := st.Flush(context.TODO())
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	fmt.Println("root is: ", root)
+	if root.String() != "bafy2bzaceb2bhqw75pqp44efoxvlnm73lnctq6djair56bfn5x3gw56epcxbi" {
+		t.Fatal("MISMATCH!")
 	}
 }
diff --git a/chain/stmgr/call.go b/chain/stmgr/call.go
index cfbe729c0..f4dfc7115 100644
--- a/chain/stmgr/call.go
+++ b/chain/stmgr/call.go
@@ -4,39 +4,58 @@ import (
 	"context"
 	"fmt"
 
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/crypto"
 	"github.com/ipfs/go-cid"
 	"go.opencensus.io/trace"
 	"golang.org/x/xerrors"
 
-	"github.com/filecoin-project/lotus/chain/actors"
+	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain/store"
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/chain/vm"
 )
 
-func (sm *StateManager) CallRaw(ctx context.Context, msg *types.Message, bstate cid.Cid, r vm.Rand, bheight uint64) (*types.MessageReceipt, error) {
+func (sm *StateManager) CallRaw(ctx context.Context, msg *types.Message, bstate cid.Cid, r vm.Rand, bheight abi.ChainEpoch) (*api.InvocResult, error) {
 	ctx, span := trace.StartSpan(ctx, "statemanager.CallRaw")
 	defer span.End()
 
-	vmi, err := vm.NewVM(bstate, bheight, r, actors.NetworkAddress, sm.cs.Blockstore())
+	vmopt := &vm.VMOpts{
+		StateBase:      bstate,
+		Epoch:          bheight,
+		Rand:           r,
+		Bstore:         sm.cs.Blockstore(),
+		Syscalls:       sm.cs.VMSys(),
+		CircSupplyCalc: sm.GetCirculatingSupply,
+		NtwkVersion:    sm.GetNtwkVersion,
+		BaseFee:        types.NewInt(0),
+	}
+
+	vmi, err := vm.NewVM(ctx, vmopt)
 	if err != nil {
 		return nil, xerrors.Errorf("failed to set up vm: %w", err)
 	}
 
-	if msg.GasLimit == types.EmptyInt {
-		msg.GasLimit = types.NewInt(10000000000)
+	if msg.GasLimit == 0 {
+		msg.GasLimit = build.BlockGasLimit
 	}
-	if msg.GasPrice == types.EmptyInt {
-		msg.GasPrice = types.NewInt(0)
+	if msg.GasFeeCap == types.EmptyInt {
+		msg.GasFeeCap = types.NewInt(0)
 	}
+	if msg.GasPremium == types.EmptyInt {
+		msg.GasPremium = types.NewInt(0)
+	}
+
 	if msg.Value == types.EmptyInt {
 		msg.Value = types.NewInt(0)
 	}
 
 	if span.IsRecordingEvents() {
 		span.AddAttributes(
-			trace.Int64Attribute("gas_limit", int64(msg.GasLimit.Uint64())),
-			trace.Int64Attribute("gas_price", int64(msg.GasPrice.Uint64())),
+			trace.Int64Attribute("gas_limit", msg.GasLimit),
+			trace.StringAttribute("gas_feecap", msg.GasFeeCap.String()),
 			trace.StringAttribute("value", msg.Value.String()),
 		)
 	}
@@ -49,37 +68,137 @@ func (sm *StateManager) CallRaw(ctx context.Context, msg *types.Message, bstate
 	msg.Nonce = fromActor.Nonce
 
 	// TODO: maybe just use the invoker directly?
-	ret, err := vmi.ApplyMessage(ctx, msg)
+	ret, err := vmi.ApplyImplicitMessage(ctx, msg)
 	if err != nil {
 		return nil, xerrors.Errorf("apply message failed: %w", err)
 	}
 
+	var errs string
 	if ret.ActorErr != nil {
+		errs = ret.ActorErr.Error()
 		log.Warnf("chain call failed: %s", ret.ActorErr)
 	}
-	return &ret.MessageReceipt, nil
+
+	return &api.InvocResult{
+		Msg:            msg,
+		MsgRct:         &ret.MessageReceipt,
+		ExecutionTrace: ret.ExecutionTrace,
+		Error:          errs,
+		Duration:       ret.Duration,
+	}, nil
 
 }
 
-func (sm *StateManager) Call(ctx context.Context, msg *types.Message, ts *types.TipSet) (*types.MessageReceipt, error) {
+func (sm *StateManager) Call(ctx context.Context, msg *types.Message, ts *types.TipSet) (*api.InvocResult, error) {
 	if ts == nil {
 		ts = sm.cs.GetHeaviestTipSet()
 	}
 
 	state := ts.ParentState()
 
-	r := store.NewChainRand(sm.cs, ts.Cids(), ts.Height())
+	r := store.NewChainRand(sm.cs, ts.Cids())
 
 	return sm.CallRaw(ctx, msg, state, r, ts.Height())
 }
 
+func (sm *StateManager) CallWithGas(ctx context.Context, msg *types.Message, priorMsgs []types.ChainMsg, ts *types.TipSet) (*api.InvocResult, error) {
+	ctx, span := trace.StartSpan(ctx, "statemanager.CallWithGas")
+	defer span.End()
+
+	if ts == nil {
+		ts = sm.cs.GetHeaviestTipSet()
+	}
+
+	state, _, err := sm.TipSetState(ctx, ts)
+	if err != nil {
+		return nil, xerrors.Errorf("computing tipset state: %w", err)
+	}
+
+	r := store.NewChainRand(sm.cs, ts.Cids())
+
+	if span.IsRecordingEvents() {
+		span.AddAttributes(
+			trace.Int64Attribute("gas_limit", msg.GasLimit),
+			trace.StringAttribute("gas_feecap", msg.GasFeeCap.String()),
+			trace.StringAttribute("value", msg.Value.String()),
+		)
+	}
+
+	vmopt := &vm.VMOpts{
+		StateBase:      state,
+		Epoch:          ts.Height() + 1,
+		Rand:           r,
+		Bstore:         sm.cs.Blockstore(),
+		Syscalls:       sm.cs.VMSys(),
+		CircSupplyCalc: sm.GetCirculatingSupply,
+		NtwkVersion:    sm.GetNtwkVersion,
+		BaseFee:        ts.Blocks()[0].ParentBaseFee,
+	}
+	vmi, err := vm.NewVM(ctx, vmopt)
+	if err != nil {
+		return nil, xerrors.Errorf("failed to set up vm: %w", err)
+	}
+	for i, m := range priorMsgs {
+		_, err := vmi.ApplyMessage(ctx, m)
+		if err != nil {
+			return nil, xerrors.Errorf("applying prior message (%d, %s): %w", i, m.Cid(), err)
+		}
+	}
+
+	fromActor, err := vmi.StateTree().GetActor(msg.From)
+	if err != nil {
+		return nil, xerrors.Errorf("call raw get actor: %s", err)
+	}
+
+	msg.Nonce = fromActor.Nonce
+
+	fromKey, err := sm.ResolveToKeyAddress(ctx, msg.From, ts)
+	if err != nil {
+		return nil, xerrors.Errorf("could not resolve key: %w", err)
+	}
+
+	var msgApply types.ChainMsg
+
+	switch fromKey.Protocol() {
+	case address.BLS:
+		msgApply = msg
+	case address.SECP256K1:
+		msgApply = &types.SignedMessage{
+			Message: *msg,
+			Signature: crypto.Signature{
+				Type: crypto.SigTypeSecp256k1,
+				Data: make([]byte, 65),
+			},
+		}
+
+	}
+
+	ret, err := vmi.ApplyMessage(ctx, msgApply)
+	if err != nil {
+		return nil, xerrors.Errorf("apply message failed: %w", err)
+	}
+
+	var errs string
+	if ret.ActorErr != nil {
+		errs = ret.ActorErr.Error()
+	}
+
+	return &api.InvocResult{
+		Msg:            msg,
+		MsgRct:         &ret.MessageReceipt,
+		ExecutionTrace: ret.ExecutionTrace,
+		Error:          errs,
+		Duration:       ret.Duration,
+	}, nil
+}
+
 var errHaltExecution = fmt.Errorf("halt")
 
 func (sm *StateManager) Replay(ctx context.Context, ts *types.TipSet, mcid cid.Cid) (*types.Message, *vm.ApplyRet, error) {
 	var outm *types.Message
 	var outr *vm.ApplyRet
 
-	_, _, err := sm.computeTipSetState(ctx, ts.Blocks(), func(c cid.Cid, m *types.Message, ret *vm.ApplyRet) error {
+	_, _, err := sm.computeTipSetState(ctx, ts, func(c cid.Cid, m *types.Message, ret *vm.ApplyRet) error {
 		if c == mcid {
 			outm = m
 			outr = ret
@@ -91,5 +210,9 @@ func (sm *StateManager) Replay(ctx context.Context, ts *types.TipSet, mcid cid.C
 		return nil, nil, xerrors.Errorf("unexpected error during execution: %w", err)
 	}
 
+	if outr == nil {
+		return nil, nil, xerrors.Errorf("given message not found in tipset")
+	}
+
 	return outm, outr, nil
 }
diff --git a/chain/stmgr/fork_no_p_eps.go b/chain/stmgr/fork_no_p_eps.go
deleted file mode 100644
index 2eb112ca6..000000000
--- a/chain/stmgr/fork_no_p_eps.go
+++ /dev/null
@@ -1,127 +0,0 @@
-package stmgr
-
-import (
-	"context"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-amt-ipld"
-	"github.com/ipfs/go-cid"
-	"github.com/ipfs/go-hamt-ipld"
-	cbor "github.com/ipfs/go-ipld-cbor"
-	"github.com/whyrusleeping/cbor-gen"
-	"golang.org/x/xerrors"
-
-	"github.com/filecoin-project/lotus/build"
-	"github.com/filecoin-project/lotus/chain/actors"
-	"github.com/filecoin-project/lotus/chain/state"
-	"github.com/filecoin-project/lotus/chain/types"
-)
-
-func (sm *StateManager) forkNoPowerEPS(ctx context.Context, pstate cid.Cid) (cid.Cid, error) {
-	cst := hamt.CSTFromBstore(sm.cs.Blockstore())
-	st, err := state.LoadStateTree(cst, pstate)
-	if err != nil {
-		return cid.Undef, xerrors.Errorf("loading parent state tree: %w", err)
-	}
-
-	if err := st.MutateActor(actors.StoragePowerAddress, func(spa *types.Actor) error {
-		var head actors.StoragePowerState
-		if err := cst.Get(ctx, spa.Head, &head); err != nil {
-			return xerrors.Errorf("reading StoragePower state: %w", err)
-		}
-
-		buckets, err := amt.LoadAMT(amt.WrapBlockstore(sm.cs.Blockstore()), head.ProvingBuckets)
-		if err != nil {
-			return xerrors.Errorf("opening proving buckets AMT: %w", err)
-		}
-
-		fixedBuckets := map[uint64]map[address.Address]struct{}{}
-
-		if err := buckets.ForEach(func(bucketId uint64, ent *typegen.Deferred) error {
-			var bcid cid.Cid
-			if err := cbor.DecodeInto(ent.Raw, &bcid); err != nil {
-				return xerrors.Errorf("decoding bucket cid: %w", err)
-			}
-
-			bucket, err := hamt.LoadNode(ctx, cst, bcid)
-			if err != nil {
-				return xerrors.Errorf("loading bucket hamt: %w", err)
-			}
-
-			return bucket.ForEach(ctx, func(abytes string, _ interface{}) error {
-				addr, err := address.NewFromBytes([]byte(abytes))
-				if err != nil {
-					return xerrors.Errorf("parsing address in proving bucket: %w", err)
-				}
-
-				// now find the correct bucket
-				miner, err := st.GetActor(addr)
-				if err != nil {
-					return xerrors.Errorf("getting miner %s: %w", addr, err)
-				}
-
-				var minerHead actors.StorageMinerActorState
-				if err := cst.Get(ctx, miner.Head, &minerHead); err != nil {
-					return xerrors.Errorf("reading miner %s state: %w", addr, err)
-				}
-
-				correctBucket := minerHead.ElectionPeriodStart % build.SlashablePowerDelay
-				if correctBucket != bucketId {
-					log.Warnf("miner %s was in wrong proving bucket %d, putting in %d (eps: %d)", addr, bucketId, correctBucket, minerHead.ElectionPeriodStart)
-				}
-
-				if _, ok := fixedBuckets[correctBucket]; !ok {
-					fixedBuckets[correctBucket] = map[address.Address]struct{}{}
-				}
-				fixedBuckets[correctBucket][addr] = struct{}{}
-
-				return nil
-			})
-		}); err != nil {
-			return err
-		}
-
-		// /////
-		// Write fixed buckets
-
-		fixed := amt.NewAMT(amt.WrapBlockstore(sm.cs.Blockstore()))
-
-		for bucketId, addrss := range fixedBuckets {
-			bucket := hamt.NewNode(cst)
-			for addr := range addrss {
-				if err := bucket.Set(ctx, string(addr.Bytes()), actors.CborNull); err != nil {
-					return xerrors.Errorf("setting address in bucket: %w", err)
-				}
-			}
-
-			if err := bucket.Flush(ctx); err != nil {
-				return xerrors.Errorf("flushing bucket amt: %w", err)
-			}
-
-			bcid, err := cst.Put(context.TODO(), bucket)
-			if err != nil {
-				return xerrors.Errorf("put bucket: %w", err)
-			}
-
-			if err := fixed.Set(bucketId, bcid); err != nil {
-				return xerrors.Errorf("set bucket: %w", err)
-			}
-		}
-
-		head.ProvingBuckets, err = fixed.Flush()
-		if err != nil {
-			return xerrors.Errorf("flushing bucket amt: %w", err)
-		}
-
-		spa.Head, err = cst.Put(ctx, &head)
-		if err != nil {
-			return xerrors.Errorf("putting actor head: %w", err)
-		}
-
-		return nil
-	}); err != nil {
-		return cid.Undef, err
-	}
-
-	return st.Flush()
-}
diff --git a/chain/stmgr/forks.go b/chain/stmgr/forks.go
index 0f92f3438..252b731d7 100644
--- a/chain/stmgr/forks.go
+++ b/chain/stmgr/forks.go
@@ -1,25 +1,625 @@
 package stmgr
 
 import (
+	"bytes"
 	"context"
+	"encoding/binary"
+	"math"
+
+	multisig0 "github.com/filecoin-project/specs-actors/actors/builtin/multisig"
+
+	"github.com/filecoin-project/lotus/chain/actors/builtin/multisig"
+
+	"github.com/filecoin-project/lotus/chain/state"
+
+	"github.com/filecoin-project/specs-actors/actors/migration/nv3"
+
 	"github.com/ipfs/go-cid"
-	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/big"
+
+	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
+	init0 "github.com/filecoin-project/specs-actors/actors/builtin/init"
+	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
+	power0 "github.com/filecoin-project/specs-actors/actors/builtin/power"
+	adt0 "github.com/filecoin-project/specs-actors/actors/util/adt"
 
 	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/chain/vm"
+	cbor "github.com/ipfs/go-ipld-cbor"
+	"golang.org/x/xerrors"
 )
 
-func (sm *StateManager) handleStateForks(ctx context.Context, pstate cid.Cid, height, parentH uint64) (_ cid.Cid, err error) {
-	for i := parentH; i < height; i++ {
-		switch i {
-		case build.ForkNoPowerEPSUpdates:
-			pstate, err = sm.forkNoPowerEPS(ctx, pstate)
-			if err != nil {
-				return cid.Undef, xerrors.Errorf("executing state fork in epoch %d: %w", i, err)
-			}
+var ForksAtHeight = map[abi.ChainEpoch]func(context.Context, *StateManager, ExecCallback, cid.Cid, *types.TipSet) (cid.Cid, error){
+	build.UpgradeBreezeHeight:   UpgradeFaucetBurnRecovery,
+	build.UpgradeIgnitionHeight: UpgradeIgnition,
+	build.UpgradeLiftoffHeight:  UpgradeLiftoff,
+}
 
-			log.Infof("forkNoPowerEPS state: %s", pstate)
+func (sm *StateManager) handleStateForks(ctx context.Context, root cid.Cid, height abi.ChainEpoch, cb ExecCallback, ts *types.TipSet) (cid.Cid, error) {
+	retCid := root
+	var err error
+	f, ok := ForksAtHeight[height]
+	if ok {
+		retCid, err = f(ctx, sm, cb, root, ts)
+		if err != nil {
+			return cid.Undef, err
 		}
 	}
 
-	return pstate, nil
+	return retCid, nil
+}
+
+func doTransfer(cb ExecCallback, tree types.StateTree, from, to address.Address, amt abi.TokenAmount) error {
+	fromAct, err := tree.GetActor(from)
+	if err != nil {
+		return xerrors.Errorf("failed to get 'from' actor for transfer: %w", err)
+	}
+
+	fromAct.Balance = types.BigSub(fromAct.Balance, amt)
+	if fromAct.Balance.Sign() < 0 {
+		return xerrors.Errorf("(sanity) deducted more funds from target account than it had (%s, %s)", from, types.FIL(amt))
+	}
+
+	if err := tree.SetActor(from, fromAct); err != nil {
+		return xerrors.Errorf("failed to persist from actor: %w", err)
+	}
+
+	toAct, err := tree.GetActor(to)
+	if err != nil {
+		return xerrors.Errorf("failed to get 'to' actor for transfer: %w", err)
+	}
+
+	toAct.Balance = types.BigAdd(toAct.Balance, amt)
+
+	if err := tree.SetActor(to, toAct); err != nil {
+		return xerrors.Errorf("failed to persist to actor: %w", err)
+	}
+
+	if cb != nil {
+		// record the transfer in execution traces
+
+		fakeMsg := &types.Message{
+			From:  from,
+			To:    to,
+			Value: amt,
+			Nonce: math.MaxUint64,
+		}
+		fakeRct := &types.MessageReceipt{
+			ExitCode: 0,
+			Return:   nil,
+			GasUsed:  0,
+		}
+
+		if err := cb(fakeMsg.Cid(), fakeMsg, &vm.ApplyRet{
+			MessageReceipt: *fakeRct,
+			ActorErr:       nil,
+			ExecutionTrace: types.ExecutionTrace{
+				Msg:        fakeMsg,
+				MsgRct:     fakeRct,
+				Error:      "",
+				Duration:   0,
+				GasCharges: nil,
+				Subcalls:   nil,
+			},
+			Duration: 0,
+			GasCosts: vm.ZeroGasOutputs(),
+		}); err != nil {
+			return xerrors.Errorf("recording transfer: %w", err)
+		}
+	}
+
+	return nil
+}
+
+func UpgradeFaucetBurnRecovery(ctx context.Context, sm *StateManager, cb ExecCallback, root cid.Cid, ts *types.TipSet) (cid.Cid, error) {
+	// Some initial parameters
+	FundsForMiners := types.FromFil(1_000_000)
+	LookbackEpoch := abi.ChainEpoch(32000)
+	AccountCap := types.FromFil(0)
+	BaseMinerBalance := types.FromFil(20)
+	DesiredReimbursementBalance := types.FromFil(5_000_000)
+
+	isSystemAccount := func(addr address.Address) (bool, error) {
+		id, err := address.IDFromAddress(addr)
+		if err != nil {
+			return false, xerrors.Errorf("id address: %w", err)
+		}
+
+		if id < 1000 {
+			return true, nil
+		}
+		return false, nil
+	}
+
+	minerFundsAlloc := func(pow, tpow abi.StoragePower) abi.TokenAmount {
+		return types.BigDiv(types.BigMul(pow, FundsForMiners), tpow)
+	}
+
+	// Grab lookback state for account checks
+	lbts, err := sm.ChainStore().GetTipsetByHeight(ctx, LookbackEpoch, ts, false)
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("failed to get tipset at lookback height: %w", err)
+	}
+
+	lbtree, err := sm.ParentState(lbts)
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("loading state tree failed: %w", err)
+	}
+
+	ReserveAddress, err := address.NewFromString("t090")
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("failed to parse reserve address: %w", err)
+	}
+
+	tree, err := sm.StateTree(root)
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("getting state tree: %w", err)
+	}
+
+	type transfer struct {
+		From address.Address
+		To   address.Address
+		Amt  abi.TokenAmount
+	}
+
+	var transfers []transfer
+
+	// Take all excess funds away, put them into the reserve account
+	err = tree.ForEach(func(addr address.Address, act *types.Actor) error {
+		switch act.Code {
+		case builtin0.AccountActorCodeID, builtin0.MultisigActorCodeID, builtin0.PaymentChannelActorCodeID:
+			sysAcc, err := isSystemAccount(addr)
+			if err != nil {
+				return xerrors.Errorf("checking system account: %w", err)
+			}
+
+			if !sysAcc {
+				transfers = append(transfers, transfer{
+					From: addr,
+					To:   ReserveAddress,
+					Amt:  act.Balance,
+				})
+			}
+		case builtin0.StorageMinerActorCodeID:
+			var st miner0.State
+			if err := sm.ChainStore().Store(ctx).Get(ctx, act.Head, &st); err != nil {
+				return xerrors.Errorf("failed to load miner state: %w", err)
+			}
+
+			var available abi.TokenAmount
+			{
+				defer func() {
+					if err := recover(); err != nil {
+						log.Warnf("Get available balance failed (%s, %s, %s): %s", addr, act.Head, act.Balance, err)
+					}
+					available = abi.NewTokenAmount(0)
+				}()
+				// this panics if the miner doesnt have enough funds to cover their locked pledge
+				available = st.GetAvailableBalance(act.Balance)
+			}
+
+			transfers = append(transfers, transfer{
+				From: addr,
+				To:   ReserveAddress,
+				Amt:  available,
+			})
+		}
+		return nil
+	})
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("foreach over state tree failed: %w", err)
+	}
+
+	// Execute transfers from previous step
+	for _, t := range transfers {
+		if err := doTransfer(cb, tree, t.From, t.To, t.Amt); err != nil {
+			return cid.Undef, xerrors.Errorf("transfer %s %s->%s failed: %w", t.Amt, t.From, t.To, err)
+		}
+	}
+
+	// pull up power table to give miners back some funds proportional to their power
+	var ps power0.State
+	powAct, err := tree.GetActor(builtin0.StoragePowerActorAddr)
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("failed to load power actor: %w", err)
+	}
+
+	cst := cbor.NewCborStore(sm.ChainStore().Blockstore())
+	if err := cst.Get(ctx, powAct.Head, &ps); err != nil {
+		return cid.Undef, xerrors.Errorf("failed to get power actor state: %w", err)
+	}
+
+	totalPower := ps.TotalBytesCommitted
+
+	var transfersBack []transfer
+	// Now, we return some funds to places where they are needed
+	err = tree.ForEach(func(addr address.Address, act *types.Actor) error {
+		lbact, err := lbtree.GetActor(addr)
+		if err != nil {
+			if !xerrors.Is(err, types.ErrActorNotFound) {
+				return xerrors.Errorf("failed to get actor in lookback state")
+			}
+		}
+
+		prevBalance := abi.NewTokenAmount(0)
+		if lbact != nil {
+			prevBalance = lbact.Balance
+		}
+
+		switch act.Code {
+		case builtin0.AccountActorCodeID, builtin0.MultisigActorCodeID, builtin0.PaymentChannelActorCodeID:
+			nbalance := big.Min(prevBalance, AccountCap)
+			if nbalance.Sign() != 0 {
+				transfersBack = append(transfersBack, transfer{
+					From: ReserveAddress,
+					To:   addr,
+					Amt:  nbalance,
+				})
+			}
+		case builtin0.StorageMinerActorCodeID:
+			var st miner0.State
+			if err := sm.ChainStore().Store(ctx).Get(ctx, act.Head, &st); err != nil {
+				return xerrors.Errorf("failed to load miner state: %w", err)
+			}
+
+			var minfo miner0.MinerInfo
+			if err := cst.Get(ctx, st.Info, &minfo); err != nil {
+				return xerrors.Errorf("failed to get miner info: %w", err)
+			}
+
+			sectorsArr, err := adt0.AsArray(sm.ChainStore().Store(ctx), st.Sectors)
+			if err != nil {
+				return xerrors.Errorf("failed to load sectors array: %w", err)
+			}
+
+			slen := sectorsArr.Length()
+
+			power := types.BigMul(types.NewInt(slen), types.NewInt(uint64(minfo.SectorSize)))
+
+			mfunds := minerFundsAlloc(power, totalPower)
+			transfersBack = append(transfersBack, transfer{
+				From: ReserveAddress,
+				To:   minfo.Worker,
+				Amt:  mfunds,
+			})
+
+			// Now make sure to give each miner who had power at the lookback some FIL
+			lbact, err := lbtree.GetActor(addr)
+			if err == nil {
+				var lbst miner0.State
+				if err := sm.ChainStore().Store(ctx).Get(ctx, lbact.Head, &lbst); err != nil {
+					return xerrors.Errorf("failed to load miner state: %w", err)
+				}
+
+				lbsectors, err := adt0.AsArray(sm.ChainStore().Store(ctx), lbst.Sectors)
+				if err != nil {
+					return xerrors.Errorf("failed to load lb sectors array: %w", err)
+				}
+
+				if lbsectors.Length() > 0 {
+					transfersBack = append(transfersBack, transfer{
+						From: ReserveAddress,
+						To:   minfo.Worker,
+						Amt:  BaseMinerBalance,
+					})
+				}
+
+			} else {
+				log.Warnf("failed to get miner in lookback state: %s", err)
+			}
+		}
+		return nil
+	})
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("foreach over state tree failed: %w", err)
+	}
+
+	for _, t := range transfersBack {
+		if err := doTransfer(cb, tree, t.From, t.To, t.Amt); err != nil {
+			return cid.Undef, xerrors.Errorf("transfer %s %s->%s failed: %w", t.Amt, t.From, t.To, err)
+		}
+	}
+
+	// transfer all burnt funds back to the reserve account
+	burntAct, err := tree.GetActor(builtin0.BurntFundsActorAddr)
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("failed to load burnt funds actor: %w", err)
+	}
+	if err := doTransfer(cb, tree, builtin0.BurntFundsActorAddr, ReserveAddress, burntAct.Balance); err != nil {
+		return cid.Undef, xerrors.Errorf("failed to unburn funds: %w", err)
+	}
+
+	// Top up the reimbursement service
+	reimbAddr, err := address.NewFromString("t0111")
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("failed to parse reimbursement service address")
+	}
+
+	reimb, err := tree.GetActor(reimbAddr)
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("failed to load reimbursement account actor: %w", err)
+	}
+
+	difference := types.BigSub(DesiredReimbursementBalance, reimb.Balance)
+	if err := doTransfer(cb, tree, ReserveAddress, reimbAddr, difference); err != nil {
+		return cid.Undef, xerrors.Errorf("failed to top up reimbursement account: %w", err)
+	}
+
+	// Now, a final sanity check to make sure the balances all check out
+	total := abi.NewTokenAmount(0)
+	err = tree.ForEach(func(addr address.Address, act *types.Actor) error {
+		total = types.BigAdd(total, act.Balance)
+		return nil
+	})
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("checking final state balance failed: %w", err)
+	}
+
+	exp := types.FromFil(build.FilBase)
+	if !exp.Equals(total) {
+		return cid.Undef, xerrors.Errorf("resultant state tree account balance was not correct: %s", total)
+	}
+
+	return tree.Flush(ctx)
+}
+
+func UpgradeIgnition(ctx context.Context, sm *StateManager, cb ExecCallback, root cid.Cid, ts *types.TipSet) (cid.Cid, error) {
+	store := sm.cs.Store(ctx)
+
+	nst, err := nv3.MigrateStateTree(ctx, store, root, build.UpgradeIgnitionHeight)
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("migrating actors state: %w", err)
+	}
+
+	tree, err := sm.StateTree(nst)
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("getting state tree: %w", err)
+	}
+
+	err = setNetworkName(ctx, store, tree, "ignition")
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("setting network name: %w", err)
+	}
+
+	split1, err := address.NewFromString("t0115")
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("first split address: %w", err)
+	}
+
+	split2, err := address.NewFromString("t0116")
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("second split address: %w", err)
+	}
+
+	err = resetGenesisMsigs(ctx, sm, store, tree)
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("resetting genesis msig start epochs: %w", err)
+	}
+
+	err = splitGenesisMultisig(ctx, cb, split1, store, tree, 50)
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("splitting first msig: %w", err)
+	}
+
+	err = splitGenesisMultisig(ctx, cb, split2, store, tree, 50)
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("splitting second msig: %w", err)
+	}
+
+	err = nv3.CheckStateTree(ctx, store, nst, build.UpgradeIgnitionHeight, builtin0.TotalFilecoin)
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("sanity check after ignition upgrade failed: %w", err)
+	}
+
+	return tree.Flush(ctx)
+}
+
+func UpgradeLiftoff(ctx context.Context, sm *StateManager, cb ExecCallback, root cid.Cid, ts *types.TipSet) (cid.Cid, error) {
+	tree, err := sm.StateTree(root)
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("getting state tree: %w", err)
+	}
+
+	err = setNetworkName(ctx, sm.cs.Store(ctx), tree, "mainnet")
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("setting network name: %w", err)
+	}
+
+	return tree.Flush(ctx)
+}
+
+func setNetworkName(ctx context.Context, store adt0.Store, tree *state.StateTree, name string) error {
+	ia, err := tree.GetActor(builtin0.InitActorAddr)
+	if err != nil {
+		return xerrors.Errorf("getting init actor: %w", err)
+	}
+
+	var initState init0.State
+	if err := store.Get(ctx, ia.Head, &initState); err != nil {
+		return xerrors.Errorf("reading init state: %w", err)
+	}
+
+	initState.NetworkName = name
+
+	ia.Head, err = store.Put(ctx, &initState)
+	if err != nil {
+		return xerrors.Errorf("writing new init state: %w", err)
+	}
+
+	if err := tree.SetActor(builtin0.InitActorAddr, ia); err != nil {
+		return xerrors.Errorf("setting init actor: %w", err)
+	}
+
+	return nil
+}
+
+func splitGenesisMultisig(ctx context.Context, cb ExecCallback, addr address.Address, store adt0.Store, tree *state.StateTree, portions uint64) error {
+	if portions < 1 {
+		return xerrors.Errorf("cannot split into 0 portions")
+	}
+
+	mact, err := tree.GetActor(addr)
+	if err != nil {
+		return xerrors.Errorf("getting msig actor: %w", err)
+	}
+
+	mst, err := multisig.Load(store, mact)
+	if err != nil {
+		return xerrors.Errorf("getting msig state: %w", err)
+	}
+
+	signers, err := mst.Signers()
+	if err != nil {
+		return xerrors.Errorf("getting msig signers: %w", err)
+	}
+
+	thresh, err := mst.Threshold()
+	if err != nil {
+		return xerrors.Errorf("getting msig threshold: %w", err)
+	}
+
+	ibal, err := mst.InitialBalance()
+	if err != nil {
+		return xerrors.Errorf("getting msig initial balance: %w", err)
+	}
+
+	se, err := mst.StartEpoch()
+	if err != nil {
+		return xerrors.Errorf("getting msig start epoch: %w", err)
+	}
+
+	ud, err := mst.UnlockDuration()
+	if err != nil {
+		return xerrors.Errorf("getting msig unlock duration: %w", err)
+	}
+
+	pending, err := adt0.MakeEmptyMap(store).Root()
+	if err != nil {
+		return xerrors.Errorf("failed to create empty map: %w", err)
+	}
+
+	newIbal := big.Div(ibal, types.NewInt(portions))
+	newState := &multisig0.State{
+		Signers:               signers,
+		NumApprovalsThreshold: thresh,
+		NextTxnID:             0,
+		InitialBalance:        newIbal,
+		StartEpoch:            se,
+		UnlockDuration:        ud,
+		PendingTxns:           pending,
+	}
+
+	scid, err := store.Put(ctx, newState)
+	if err != nil {
+		return xerrors.Errorf("storing new state: %w", err)
+	}
+
+	newActor := types.Actor{
+		Code:    builtin0.MultisigActorCodeID,
+		Head:    scid,
+		Nonce:   0,
+		Balance: big.Zero(),
+	}
+
+	i := uint64(0)
+	for i < portions {
+		keyAddr, err := makeKeyAddr(addr, i)
+		if err != nil {
+			return xerrors.Errorf("creating key address: %w", err)
+		}
+
+		idAddr, err := tree.RegisterNewAddress(keyAddr)
+		if err != nil {
+			return xerrors.Errorf("registering new address: %w", err)
+		}
+
+		err = tree.SetActor(idAddr, &newActor)
+		if err != nil {
+			return xerrors.Errorf("setting new msig actor state: %w", err)
+		}
+
+		if err := doTransfer(cb, tree, addr, idAddr, newIbal); err != nil {
+			return xerrors.Errorf("transferring split msig balance: %w", err)
+		}
+
+		i++
+	}
+
+	return nil
+}
+
+func makeKeyAddr(splitAddr address.Address, count uint64) (address.Address, error) {
+	var b bytes.Buffer
+	if err := splitAddr.MarshalCBOR(&b); err != nil {
+		return address.Undef, xerrors.Errorf("marshalling split address: %w", err)
+	}
+
+	if err := binary.Write(&b, binary.BigEndian, count); err != nil {
+		return address.Undef, xerrors.Errorf("writing count into a buffer: %w", err)
+	}
+
+	if err := binary.Write(&b, binary.BigEndian, []byte("Ignition upgrade")); err != nil {
+		return address.Undef, xerrors.Errorf("writing fork name into a buffer: %w", err)
+	}
+
+	addr, err := address.NewActorAddress(b.Bytes())
+	if err != nil {
+		return address.Undef, xerrors.Errorf("create actor address: %w", err)
+	}
+
+	return addr, nil
+}
+
+func resetGenesisMsigs(ctx context.Context, sm *StateManager, store adt0.Store, tree *state.StateTree) error {
+	gb, err := sm.cs.GetGenesis()
+	if err != nil {
+		return xerrors.Errorf("getting genesis block: %w", err)
+	}
+
+	gts, err := types.NewTipSet([]*types.BlockHeader{gb})
+	if err != nil {
+		return xerrors.Errorf("getting genesis tipset: %w", err)
+	}
+
+	cst := cbor.NewCborStore(sm.cs.Blockstore())
+	genesisTree, err := state.LoadStateTree(cst, gts.ParentState())
+	if err != nil {
+		return xerrors.Errorf("loading state tree: %w", err)
+	}
+
+	err = genesisTree.ForEach(func(addr address.Address, genesisActor *types.Actor) error {
+		if genesisActor.Code == builtin0.MultisigActorCodeID {
+			currActor, err := tree.GetActor(addr)
+			if err != nil {
+				return xerrors.Errorf("loading actor: %w", err)
+			}
+
+			var currState multisig0.State
+			if err := store.Get(ctx, currActor.Head, &currState); err != nil {
+				return xerrors.Errorf("reading multisig state: %w", err)
+			}
+
+			currState.StartEpoch = build.UpgradeLiftoffHeight
+
+			currActor.Head, err = store.Put(ctx, &currState)
+			if err != nil {
+				return xerrors.Errorf("writing new multisig state: %w", err)
+			}
+
+			if err := tree.SetActor(addr, currActor); err != nil {
+				return xerrors.Errorf("setting multisig actor: %w", err)
+			}
+		}
+		return nil
+	})
+
+	if err != nil {
+		return xerrors.Errorf("iterating over genesis actors: %w", err)
+	}
+
+	return nil
 }
diff --git a/chain/stmgr/forks_test.go b/chain/stmgr/forks_test.go
new file mode 100644
index 000000000..a3423ccdd
--- /dev/null
+++ b/chain/stmgr/forks_test.go
@@ -0,0 +1,225 @@
+package stmgr_test
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"testing"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/specs-actors/actors/builtin"
+	init_ "github.com/filecoin-project/specs-actors/actors/builtin/init"
+	"github.com/filecoin-project/specs-actors/actors/runtime"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/lotus/chain/actors"
+	"github.com/filecoin-project/lotus/chain/actors/aerrors"
+	lotusinit "github.com/filecoin-project/lotus/chain/actors/builtin/init"
+	"github.com/filecoin-project/lotus/chain/actors/policy"
+	"github.com/filecoin-project/lotus/chain/gen"
+	"github.com/filecoin-project/lotus/chain/stmgr"
+	. "github.com/filecoin-project/lotus/chain/stmgr"
+	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/chain/vm"
+	_ "github.com/filecoin-project/lotus/lib/sigs/bls"
+	_ "github.com/filecoin-project/lotus/lib/sigs/secp"
+
+	"github.com/ipfs/go-cid"
+	cbor "github.com/ipfs/go-ipld-cbor"
+	logging "github.com/ipfs/go-log"
+	cbg "github.com/whyrusleeping/cbor-gen"
+)
+
+func init() {
+	policy.SetSupportedProofTypes(abi.RegisteredSealProof_StackedDrg2KiBV1)
+	policy.SetConsensusMinerMinPower(abi.NewStoragePower(2048))
+	policy.SetMinVerifiedDealSize(abi.NewStoragePower(256))
+}
+
+const testForkHeight = 40
+
+type testActor struct {
+}
+
+type testActorState struct {
+	HasUpgraded uint64
+}
+
+func (tas *testActorState) MarshalCBOR(w io.Writer) error {
+	return cbg.CborWriteHeader(w, cbg.MajUnsignedInt, tas.HasUpgraded)
+}
+
+func (tas *testActorState) UnmarshalCBOR(r io.Reader) error {
+	t, v, err := cbg.CborReadHeader(r)
+	if err != nil {
+		return err
+	}
+	if t != cbg.MajUnsignedInt {
+		return fmt.Errorf("wrong type in test actor state (got %d)", t)
+	}
+	tas.HasUpgraded = v
+	return nil
+}
+
+func (ta *testActor) Exports() []interface{} {
+	return []interface{}{
+		1: ta.Constructor,
+		2: ta.TestMethod,
+	}
+}
+
+func (ta *testActor) Constructor(rt runtime.Runtime, params *abi.EmptyValue) *abi.EmptyValue {
+	rt.ValidateImmediateCallerAcceptAny()
+	rt.StateCreate(&testActorState{11})
+	fmt.Println("NEW ACTOR ADDRESS IS: ", rt.Receiver())
+
+	return abi.Empty
+}
+
+func (ta *testActor) TestMethod(rt runtime.Runtime, params *abi.EmptyValue) *abi.EmptyValue {
+	rt.ValidateImmediateCallerAcceptAny()
+	var st testActorState
+	rt.StateReadonly(&st)
+
+	if rt.CurrEpoch() > testForkHeight {
+		if st.HasUpgraded != 55 {
+			panic(aerrors.Fatal("fork updating applied in wrong order"))
+		}
+	} else {
+		if st.HasUpgraded != 11 {
+			panic(aerrors.Fatal("fork updating happened too early"))
+		}
+	}
+
+	return abi.Empty
+}
+
+func TestForkHeightTriggers(t *testing.T) {
+	logging.SetAllLoggers(logging.LevelInfo)
+
+	ctx := context.TODO()
+
+	cg, err := gen.NewGenerator()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	sm := NewStateManager(cg.ChainStore())
+
+	inv := vm.NewInvoker()
+
+	// predicting the address here... may break if other assumptions change
+	taddr, err := address.NewIDAddress(1002)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	stmgr.ForksAtHeight[testForkHeight] = func(ctx context.Context, sm *StateManager, cb ExecCallback, root cid.Cid, ts *types.TipSet) (cid.Cid, error) {
+		cst := cbor.NewCborStore(sm.ChainStore().Blockstore())
+
+		st, err := sm.StateTree(root)
+		if err != nil {
+			return cid.Undef, xerrors.Errorf("getting state tree: %w", err)
+		}
+
+		act, err := st.GetActor(taddr)
+		if err != nil {
+			return cid.Undef, err
+		}
+
+		var tas testActorState
+		if err := cst.Get(ctx, act.Head, &tas); err != nil {
+			return cid.Undef, xerrors.Errorf("in fork handler, failed to run get: %w", err)
+		}
+
+		tas.HasUpgraded = 55
+
+		ns, err := cst.Put(ctx, &tas)
+		if err != nil {
+			return cid.Undef, err
+		}
+
+		act.Head = ns
+
+		if err := st.SetActor(taddr, act); err != nil {
+			return cid.Undef, err
+		}
+
+		return st.Flush(ctx)
+	}
+
+	inv.Register(builtin.PaymentChannelActorCodeID, &testActor{}, &testActorState{})
+	sm.SetVMConstructor(func(ctx context.Context, vmopt *vm.VMOpts) (*vm.VM, error) {
+		nvm, err := vm.NewVM(ctx, vmopt)
+		if err != nil {
+			return nil, err
+		}
+		nvm.SetInvoker(inv)
+		return nvm, nil
+	})
+
+	cg.SetStateManager(sm)
+
+	var msgs []*types.SignedMessage
+
+	enc, err := actors.SerializeParams(&init_.ExecParams{CodeCID: builtin.PaymentChannelActorCodeID})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	m := &types.Message{
+		From:     cg.Banker(),
+		To:       lotusinit.Address,
+		Method:   builtin.MethodsInit.Exec,
+		Params:   enc,
+		GasLimit: types.TestGasLimit,
+	}
+	sig, err := cg.Wallet().Sign(ctx, cg.Banker(), m.Cid().Bytes())
+	if err != nil {
+		t.Fatal(err)
+	}
+	msgs = append(msgs, &types.SignedMessage{
+		Signature: *sig,
+		Message:   *m,
+	})
+
+	nonce := uint64(1)
+	cg.GetMessages = func(cg *gen.ChainGen) ([]*types.SignedMessage, error) {
+		if len(msgs) > 0 {
+			fmt.Println("added construct method")
+			m := msgs
+			msgs = nil
+			return m, nil
+		}
+
+		m := &types.Message{
+			From:     cg.Banker(),
+			To:       taddr,
+			Method:   2,
+			Params:   nil,
+			Nonce:    nonce,
+			GasLimit: types.TestGasLimit,
+		}
+		nonce++
+
+		sig, err := cg.Wallet().Sign(ctx, cg.Banker(), m.Cid().Bytes())
+		if err != nil {
+			return nil, err
+		}
+
+		return []*types.SignedMessage{
+			{
+				Signature: *sig,
+				Message:   *m,
+			},
+		}, nil
+	}
+
+	for i := 0; i < 50; i++ {
+		_, err = cg.NextTipSet()
+		if err != nil {
+			t.Fatal(err)
+		}
+	}
+}
diff --git a/chain/stmgr/read.go b/chain/stmgr/read.go
new file mode 100644
index 000000000..9a9b80265
--- /dev/null
+++ b/chain/stmgr/read.go
@@ -0,0 +1,66 @@
+package stmgr
+
+import (
+	"context"
+
+	"golang.org/x/xerrors"
+
+	"github.com/ipfs/go-cid"
+	cbor "github.com/ipfs/go-ipld-cbor"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/lotus/chain/state"
+	"github.com/filecoin-project/lotus/chain/types"
+)
+
+func (sm *StateManager) ParentStateTsk(tsk types.TipSetKey) (*state.StateTree, error) {
+	ts, err := sm.cs.GetTipSetFromKey(tsk)
+	if err != nil {
+		return nil, xerrors.Errorf("loading tipset %s: %w", tsk, err)
+	}
+	return sm.ParentState(ts)
+}
+
+func (sm *StateManager) ParentState(ts *types.TipSet) (*state.StateTree, error) {
+	cst := cbor.NewCborStore(sm.cs.Blockstore())
+	state, err := state.LoadStateTree(cst, sm.parentState(ts))
+	if err != nil {
+		return nil, xerrors.Errorf("load state tree: %w", err)
+	}
+
+	return state, nil
+}
+
+func (sm *StateManager) StateTree(st cid.Cid) (*state.StateTree, error) {
+	cst := cbor.NewCborStore(sm.cs.Blockstore())
+	state, err := state.LoadStateTree(cst, st)
+	if err != nil {
+		return nil, xerrors.Errorf("load state tree: %w", err)
+	}
+
+	return state, nil
+}
+
+func (sm *StateManager) LoadActor(_ context.Context, addr address.Address, ts *types.TipSet) (*types.Actor, error) {
+	state, err := sm.ParentState(ts)
+	if err != nil {
+		return nil, err
+	}
+	return state.GetActor(addr)
+}
+
+func (sm *StateManager) LoadActorTsk(_ context.Context, addr address.Address, tsk types.TipSetKey) (*types.Actor, error) {
+	state, err := sm.ParentStateTsk(tsk)
+	if err != nil {
+		return nil, err
+	}
+	return state.GetActor(addr)
+}
+
+func (sm *StateManager) LoadActorRaw(_ context.Context, addr address.Address, st cid.Cid) (*types.Actor, error) {
+	state, err := sm.StateTree(st)
+	if err != nil {
+		return nil, err
+	}
+	return state.GetActor(addr)
+}
diff --git a/chain/stmgr/stmgr.go b/chain/stmgr/stmgr.go
index b880492f2..e800ce665 100644
--- a/chain/stmgr/stmgr.go
+++ b/chain/stmgr/stmgr.go
@@ -5,21 +5,35 @@ import (
 	"fmt"
 	"sync"
 
+	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
+	msig0 "github.com/filecoin-project/specs-actors/actors/builtin/multisig"
+
+	"github.com/ipfs/go-cid"
+	cbor "github.com/ipfs/go-ipld-cbor"
+	logging "github.com/ipfs/go-log/v2"
+	cbg "github.com/whyrusleeping/cbor-gen"
+	"go.opencensus.io/trace"
+	"golang.org/x/xerrors"
+
 	"github.com/filecoin-project/go-address"
-	amt "github.com/filecoin-project/go-amt-ipld"
+	"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/chain/actors"
+	"github.com/filecoin-project/lotus/chain/actors/adt"
+	"github.com/filecoin-project/lotus/chain/actors/builtin"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/market"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/multisig"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/paych"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/power"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/reward"
 	"github.com/filecoin-project/lotus/chain/state"
 	"github.com/filecoin-project/lotus/chain/store"
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/chain/vm"
-	cbg "github.com/whyrusleeping/cbor-gen"
-	"golang.org/x/xerrors"
-
-	bls "github.com/filecoin-project/filecoin-ffi"
-	"github.com/ipfs/go-cid"
-	hamt "github.com/ipfs/go-hamt-ipld"
-	logging "github.com/ipfs/go-log"
-	"go.opencensus.io/trace"
 )
 
 var log = logging.Logger("statemgr")
@@ -27,13 +41,18 @@ var log = logging.Logger("statemgr")
 type StateManager struct {
 	cs *store.ChainStore
 
-	stCache  map[string][]cid.Cid
-	compWait map[string]chan struct{}
-	stlk     sync.Mutex
+	stCache              map[string][]cid.Cid
+	compWait             map[string]chan struct{}
+	stlk                 sync.Mutex
+	genesisMsigLk        sync.Mutex
+	newVM                func(context.Context, *vm.VMOpts) (*vm.VM, error)
+	preIgnitionGenInfos  *genesisInfo
+	postIgnitionGenInfos *genesisInfo
 }
 
 func NewStateManager(cs *store.ChainStore) *StateManager {
 	return &StateManager{
+		newVM:    vm.NewVM,
 		cs:       cs,
 		stCache:  make(map[string][]cid.Cid),
 		compWait: make(map[string]chan struct{}),
@@ -97,7 +116,7 @@ func (sm *StateManager) TipSetState(ctx context.Context, ts *types.TipSet) (st c
 		return ts.Blocks()[0].ParentStateRoot, ts.Blocks()[0].ParentMessageReceipts, nil
 	}
 
-	st, rec, err = sm.computeTipSetState(ctx, ts.Blocks(), nil)
+	st, rec, err = sm.computeTipSetState(ctx, ts, nil)
 	if err != nil {
 		return cid.Undef, cid.Undef, err
 	}
@@ -105,180 +124,205 @@ func (sm *StateManager) TipSetState(ctx context.Context, ts *types.TipSet) (st c
 	return st, rec, nil
 }
 
-func (sm *StateManager) computeTipSetState(ctx context.Context, blks []*types.BlockHeader, cb func(cid.Cid, *types.Message, *vm.ApplyRet) error) (cid.Cid, cid.Cid, error) {
-	ctx, span := trace.StartSpan(ctx, "computeTipSetState")
-	defer span.End()
+func traceFunc(trace *[]*api.InvocResult) func(mcid cid.Cid, msg *types.Message, ret *vm.ApplyRet) error {
+	return func(mcid cid.Cid, msg *types.Message, ret *vm.ApplyRet) error {
+		ir := &api.InvocResult{
+			Msg:            msg,
+			MsgRct:         &ret.MessageReceipt,
+			ExecutionTrace: ret.ExecutionTrace,
+			Duration:       ret.Duration,
+		}
+		if ret.ActorErr != nil {
+			ir.Error = ret.ActorErr.Error()
+		}
+		*trace = append(*trace, ir)
+		return nil
+	}
+}
 
-	for i := 0; i < len(blks); i++ {
-		for j := i + 1; j < len(blks); j++ {
-			if blks[i].Miner == blks[j].Miner {
-				return cid.Undef, cid.Undef,
-					xerrors.Errorf("duplicate miner in a tipset (%s %s)",
-						blks[i].Miner, blks[j].Miner)
+func (sm *StateManager) ExecutionTrace(ctx context.Context, ts *types.TipSet) (cid.Cid, []*api.InvocResult, error) {
+	var trace []*api.InvocResult
+	st, _, err := sm.computeTipSetState(ctx, ts, traceFunc(&trace))
+	if err != nil {
+		return cid.Undef, nil, err
+	}
+
+	return st, trace, nil
+}
+
+type ExecCallback func(cid.Cid, *types.Message, *vm.ApplyRet) error
+
+func (sm *StateManager) ApplyBlocks(ctx context.Context, parentEpoch abi.ChainEpoch, pstate cid.Cid, bms []store.BlockMessages, epoch abi.ChainEpoch, r vm.Rand, cb ExecCallback, baseFee abi.TokenAmount, ts *types.TipSet) (cid.Cid, cid.Cid, error) {
+
+	makeVmWithBaseState := func(base cid.Cid) (*vm.VM, error) {
+		vmopt := &vm.VMOpts{
+			StateBase:      base,
+			Epoch:          epoch,
+			Rand:           r,
+			Bstore:         sm.cs.Blockstore(),
+			Syscalls:       sm.cs.VMSys(),
+			CircSupplyCalc: sm.GetCirculatingSupply,
+			NtwkVersion:    sm.GetNtwkVersion,
+			BaseFee:        baseFee,
+		}
+
+		return sm.newVM(ctx, vmopt)
+	}
+
+	vmi, err := makeVmWithBaseState(pstate)
+	if err != nil {
+		return cid.Undef, cid.Undef, xerrors.Errorf("making vm: %w", err)
+	}
+
+	runCron := func() error {
+		// TODO: this nonce-getting is a tiny bit ugly
+		ca, err := vmi.StateTree().GetActor(builtin0.SystemActorAddr)
+		if err != nil {
+			return err
+		}
+
+		cronMsg := &types.Message{
+			To:         builtin0.CronActorAddr,
+			From:       builtin0.SystemActorAddr,
+			Nonce:      ca.Nonce,
+			Value:      types.NewInt(0),
+			GasFeeCap:  types.NewInt(0),
+			GasPremium: types.NewInt(0),
+			GasLimit:   build.BlockGasLimit * 10000, // Make super sure this is never too little
+			Method:     builtin0.MethodsCron.EpochTick,
+			Params:     nil,
+		}
+		ret, err := vmi.ApplyImplicitMessage(ctx, cronMsg)
+		if err != nil {
+			return err
+		}
+		if cb != nil {
+			if err := cb(cronMsg.Cid(), cronMsg, ret); err != nil {
+				return xerrors.Errorf("callback failed on cron message: %w", err)
 			}
 		}
-	}
-
-	pstate := blks[0].ParentStateRoot
-	if len(blks[0].Parents) > 0 { // don't support forks on genesis
-		parent, err := sm.cs.GetBlock(blks[0].Parents[0])
-		if err != nil {
-			return cid.Undef, cid.Undef, xerrors.Errorf("getting parent block: %w", err)
-		}
-
-		pstate, err = sm.handleStateForks(ctx, blks[0].ParentStateRoot, blks[0].Height, parent.Height)
-		if err != nil {
-			return cid.Undef, cid.Undef, xerrors.Errorf("error handling state forks: %w", err)
-		}
-	}
-
-	cids := make([]cid.Cid, len(blks))
-	for i, v := range blks {
-		cids[i] = v.Cid()
-	}
-
-	r := store.NewChainRand(sm.cs, cids, blks[0].Height)
-
-	vmi, err := vm.NewVM(pstate, blks[0].Height, r, address.Undef, sm.cs.Blockstore())
-	if err != nil {
-		return cid.Undef, cid.Undef, xerrors.Errorf("instantiating VM failed: %w", err)
-	}
-
-	netact, err := vmi.StateTree().GetActor(actors.NetworkAddress)
-	if err != nil {
-		return cid.Undef, cid.Undef, xerrors.Errorf("failed to get network actor: %w", err)
-	}
-	reward := vm.MiningReward(netact.Balance)
-	for tsi, b := range blks {
-		netact, err = vmi.StateTree().GetActor(actors.NetworkAddress)
-		if err != nil {
-			return cid.Undef, cid.Undef, xerrors.Errorf("failed to get network actor: %w", err)
-		}
-		vmi.SetBlockMiner(b.Miner)
-
-		owner, err := GetMinerOwner(ctx, sm, pstate, b.Miner)
-		if err != nil {
-			return cid.Undef, cid.Undef, xerrors.Errorf("failed to get owner for miner %s: %w", b.Miner, err)
-		}
-
-		act, err := vmi.StateTree().GetActor(owner)
-		if err != nil {
-			return cid.Undef, cid.Undef, xerrors.Errorf("failed to get miner owner actor")
-		}
-
-		if err := vm.Transfer(netact, act, reward); err != nil {
-			return cid.Undef, cid.Undef, xerrors.Errorf("failed to deduct funds from network actor: %w", err)
-		}
-
-		// all block miners created a valid post, go update the actor state
-		postSubmitMsg := &types.Message{
-			From:     actors.NetworkAddress,
-			Nonce:    netact.Nonce,
-			To:       b.Miner,
-			Method:   actors.MAMethods.SubmitElectionPoSt,
-			GasPrice: types.NewInt(0),
-			GasLimit: types.NewInt(10000000000),
-			Value:    types.NewInt(0),
-		}
-		ret, err := vmi.ApplyMessage(ctx, postSubmitMsg)
-		if err != nil {
-			return cid.Undef, cid.Undef, xerrors.Errorf("submit election post message for block %s (miner %s) invocation failed: %w", b.Cid(), b.Miner, err)
-		}
 		if ret.ExitCode != 0 {
-			return cid.Undef, cid.Undef, xerrors.Errorf("submit election post invocation returned nonzero exit code: %d (err = %s, block = %s, miner = %s, tsi = %d)", ret.ExitCode, ret.ActorErr, b.Cid(), b.Miner, tsi)
+			return xerrors.Errorf("CheckProofSubmissions exit was non-zero: %d", ret.ExitCode)
 		}
-	}
 
-	// TODO: can't use method from chainstore because it doesnt let us know who the block miners were
-	applied := make(map[address.Address]uint64)
-	balances := make(map[address.Address]types.BigInt)
-
-	preloadAddr := func(a address.Address) error {
-		if _, ok := applied[a]; !ok {
-			act, err := vmi.StateTree().GetActor(a)
-			if err != nil {
-				return err
-			}
-
-			applied[a] = act.Nonce
-			balances[a] = act.Balance
-		}
 		return nil
 	}
 
-	var receipts []cbg.CBORMarshaler
-	for _, b := range blks {
-		vmi.SetBlockMiner(b.Miner)
-
-		bms, sms, err := sm.cs.MessagesForBlock(b)
+	for i := parentEpoch; i < epoch; i++ {
+		// handle state forks
+		// XXX: The state tree
+		newState, err := sm.handleStateForks(ctx, pstate, i, cb, ts)
 		if err != nil {
-			return cid.Undef, cid.Undef, xerrors.Errorf("failed to get messages for block: %w", err)
+			return cid.Undef, cid.Undef, xerrors.Errorf("error handling state forks: %w", err)
 		}
 
-		cmsgs := make([]store.ChainMsg, 0, len(bms)+len(sms))
-		for _, m := range bms {
-			cmsgs = append(cmsgs, m)
-		}
-		for _, sm := range sms {
-			cmsgs = append(cmsgs, sm)
+		if pstate != newState {
+			vmi, err = makeVmWithBaseState(newState)
+			if err != nil {
+				return cid.Undef, cid.Undef, xerrors.Errorf("making vm: %w", err)
+			}
 		}
 
-		for _, cm := range cmsgs {
+		if i > parentEpoch {
+			// run cron for null rounds if any
+			if err := runCron(); err != nil {
+				return cid.Cid{}, cid.Cid{}, err
+			}
+
+			newState, err = vmi.Flush(ctx)
+			if err != nil {
+				return cid.Undef, cid.Undef, xerrors.Errorf("flushing vm: %w", err)
+			}
+		}
+
+		vmi.SetBlockHeight(i + 1)
+		pstate = newState
+	}
+
+	var receipts []cbg.CBORMarshaler
+	processedMsgs := map[cid.Cid]bool{}
+	for _, b := range bms {
+		penalty := types.NewInt(0)
+		gasReward := big.Zero()
+
+		for _, cm := range append(b.BlsMessages, b.SecpkMessages...) {
 			m := cm.VMMessage()
-			if err := preloadAddr(m.From); err != nil {
-				return cid.Undef, cid.Undef, err
-			}
-
-			if applied[m.From] != m.Nonce {
+			if _, found := processedMsgs[m.Cid()]; found {
 				continue
 			}
-			applied[m.From]++
-
-			if balances[m.From].LessThan(m.RequiredFunds()) {
-				continue
-			}
-			balances[m.From] = types.BigSub(balances[m.From], m.RequiredFunds())
-
-			r, err := vmi.ApplyMessage(ctx, m)
+			r, err := vmi.ApplyMessage(ctx, cm)
 			if err != nil {
 				return cid.Undef, cid.Undef, err
 			}
 
 			receipts = append(receipts, &r.MessageReceipt)
+			gasReward = big.Add(gasReward, r.GasCosts.MinerTip)
+			penalty = big.Add(penalty, r.GasCosts.MinerPenalty)
 
 			if cb != nil {
 				if err := cb(cm.Cid(), m, r); err != nil {
 					return cid.Undef, cid.Undef, err
 				}
 			}
+			processedMsgs[m.Cid()] = true
+		}
+
+		params, err := actors.SerializeParams(&reward.AwardBlockRewardParams{
+			Miner:     b.Miner,
+			Penalty:   penalty,
+			GasReward: gasReward,
+			WinCount:  b.WinCount,
+		})
+		if err != nil {
+			return cid.Undef, cid.Undef, xerrors.Errorf("failed to serialize award params: %w", err)
+		}
+
+		sysAct, actErr := vmi.StateTree().GetActor(builtin0.SystemActorAddr)
+		if actErr != nil {
+			return cid.Undef, cid.Undef, xerrors.Errorf("failed to get system actor: %w", err)
+		}
+
+		rwMsg := &types.Message{
+			From:       builtin0.SystemActorAddr,
+			To:         reward.Address,
+			Nonce:      sysAct.Nonce,
+			Value:      types.NewInt(0),
+			GasFeeCap:  types.NewInt(0),
+			GasPremium: types.NewInt(0),
+			GasLimit:   1 << 30,
+			Method:     builtin0.MethodsReward.AwardBlockReward,
+			Params:     params,
+		}
+		ret, actErr := vmi.ApplyImplicitMessage(ctx, rwMsg)
+		if actErr != nil {
+			return cid.Undef, cid.Undef, xerrors.Errorf("failed to apply reward message for miner %s: %w", b.Miner, err)
+		}
+		if cb != nil {
+			if err := cb(rwMsg.Cid(), rwMsg, ret); err != nil {
+				return cid.Undef, cid.Undef, xerrors.Errorf("callback failed on reward message: %w", err)
+			}
+		}
+
+		if ret.ExitCode != 0 {
+			return cid.Undef, cid.Undef, xerrors.Errorf("reward application message failed (exit %d): %s", ret.ExitCode, ret.ActorErr)
 		}
 	}
 
-	// TODO: this nonce-getting is a tiny bit ugly
-	ca, err := vmi.StateTree().GetActor(actors.CronAddress)
-	if err != nil {
-		return cid.Undef, cid.Undef, err
+	if err := runCron(); err != nil {
+		return cid.Cid{}, cid.Cid{}, err
 	}
 
-	ret, err := vmi.ApplyMessage(ctx, &types.Message{
-		To:       actors.CronAddress,
-		From:     actors.CronAddress,
-		Nonce:    ca.Nonce,
-		Value:    types.NewInt(0),
-		GasPrice: types.NewInt(0),
-		GasLimit: types.NewInt(1 << 30), // Make super sure this is never too little
-		Method:   actors.CAMethods.EpochTick,
-		Params:   nil,
-	})
+	// XXX: Is the height correct? Or should it be epoch-1?
+	rectarr, err := adt.NewArray(sm.cs.Store(ctx), builtin.VersionForNetwork(sm.GetNtwkVersion(ctx, epoch)))
 	if err != nil {
-		return cid.Undef, cid.Undef, err
+		return cid.Undef, cid.Undef, xerrors.Errorf("failed to create receipts amt: %w", err)
 	}
-	if ret.ExitCode != 0 {
-		return cid.Undef, cid.Undef, xerrors.Errorf("CheckProofSubmissions exit was non-zero: %d", ret.ExitCode)
+	for i, receipt := range receipts {
+		if err := rectarr.Set(uint64(i), receipt); err != nil {
+			return cid.Undef, cid.Undef, xerrors.Errorf("failed to build receipts amt: %w", err)
+		}
 	}
-
-	bs := amt.WrapBlockstore(sm.cs.Blockstore())
-	rectroot, err := amt.FromArray(bs, receipts)
+	rectroot, err := rectarr.Root()
 	if err != nil {
 		return cid.Undef, cid.Undef, xerrors.Errorf("failed to build receipts amt: %w", err)
 	}
@@ -291,51 +335,64 @@ func (sm *StateManager) computeTipSetState(ctx context.Context, blks []*types.Bl
 	return st, rectroot, nil
 }
 
-func (sm *StateManager) GetActor(addr address.Address, ts *types.TipSet) (*types.Actor, error) {
+func (sm *StateManager) computeTipSetState(ctx context.Context, ts *types.TipSet, cb ExecCallback) (cid.Cid, cid.Cid, error) {
+	ctx, span := trace.StartSpan(ctx, "computeTipSetState")
+	defer span.End()
+
+	blks := ts.Blocks()
+
+	for i := 0; i < len(blks); i++ {
+		for j := i + 1; j < len(blks); j++ {
+			if blks[i].Miner == blks[j].Miner {
+				return cid.Undef, cid.Undef,
+					xerrors.Errorf("duplicate miner in a tipset (%s %s)",
+						blks[i].Miner, blks[j].Miner)
+			}
+		}
+	}
+
+	var parentEpoch abi.ChainEpoch
+	pstate := blks[0].ParentStateRoot
+	if blks[0].Height > 0 {
+		parent, err := sm.cs.GetBlock(blks[0].Parents[0])
+		if err != nil {
+			return cid.Undef, cid.Undef, xerrors.Errorf("getting parent block: %w", err)
+		}
+
+		parentEpoch = parent.Height
+	}
+
+	cids := make([]cid.Cid, len(blks))
+	for i, v := range blks {
+		cids[i] = v.Cid()
+	}
+
+	r := store.NewChainRand(sm.cs, cids)
+
+	blkmsgs, err := sm.cs.BlockMsgsForTipset(ts)
+	if err != nil {
+		return cid.Undef, cid.Undef, xerrors.Errorf("getting block messages for tipset: %w", err)
+	}
+
+	baseFee := blks[0].ParentBaseFee
+
+	return sm.ApplyBlocks(ctx, parentEpoch, pstate, blkmsgs, blks[0].Height, r, cb, baseFee, ts)
+}
+
+func (sm *StateManager) parentState(ts *types.TipSet) cid.Cid {
 	if ts == nil {
 		ts = sm.cs.GetHeaviestTipSet()
 	}
 
-	stcid := ts.ParentState()
-
-	cst := hamt.CSTFromBstore(sm.cs.Blockstore())
-	state, err := state.LoadStateTree(cst, stcid)
-	if err != nil {
-		return nil, xerrors.Errorf("load state tree: %w", err)
-	}
-
-	return state.GetActor(addr)
-}
-
-func (sm *StateManager) GetBalance(addr address.Address, ts *types.TipSet) (types.BigInt, error) {
-	act, err := sm.GetActor(addr, ts)
-	if err != nil {
-		if xerrors.Is(err, types.ErrActorNotFound) {
-			return types.NewInt(0), nil
-		}
-		return types.EmptyInt, xerrors.Errorf("get actor: %w", err)
-	}
-
-	return act.Balance, nil
+	return ts.ParentState()
 }
 
 func (sm *StateManager) ChainStore() *store.ChainStore {
 	return sm.cs
 }
 
-func (sm *StateManager) LoadActorState(ctx context.Context, a address.Address, out interface{}, ts *types.TipSet) (*types.Actor, error) {
-	act, err := sm.GetActor(a, ts)
-	if err != nil {
-		return nil, err
-	}
-
-	cst := hamt.CSTFromBstore(sm.cs.Blockstore())
-	if err := cst.Get(ctx, act.Head, out); err != nil {
-		return nil, err
-	}
-
-	return act, nil
-}
+// ResolveToKeyAddress is similar to `vm.ResolveToKeyAddr` but does not allow `Actor` type of addresses.
+// Uses the `TipSet` `ts` to generate the VM state.
 func (sm *StateManager) ResolveToKeyAddress(ctx context.Context, addr address.Address, ts *types.TipSet) (address.Address, error) {
 	switch addr.Protocol() {
 	case address.BLS, address.SECP256K1:
@@ -354,7 +411,7 @@ func (sm *StateManager) ResolveToKeyAddress(ctx context.Context, addr address.Ad
 		return address.Undef, xerrors.Errorf("resolve address failed to get tipset state: %w", err)
 	}
 
-	cst := hamt.CSTFromBstore(sm.cs.Blockstore())
+	cst := cbor.NewCborStore(sm.cs.Blockstore())
 	tree, err := state.LoadStateTree(cst, st)
 	if err != nil {
 		return address.Undef, xerrors.Errorf("failed to load state tree")
@@ -363,7 +420,7 @@ func (sm *StateManager) ResolveToKeyAddress(ctx context.Context, addr address.Ad
 	return vm.ResolveToKeyAddr(tree, cst, addr)
 }
 
-func (sm *StateManager) GetBlsPublicKey(ctx context.Context, addr address.Address, ts *types.TipSet) (pubk bls.PublicKey, err error) {
+func (sm *StateManager) GetBlsPublicKey(ctx context.Context, addr address.Address, ts *types.TipSet) (pubk []byte, err error) {
 	kaddr, err := sm.ResolveToKeyAddress(ctx, addr, ts)
 	if err != nil {
 		return pubk, xerrors.Errorf("failed to resolve address to key address: %w", err)
@@ -373,8 +430,16 @@ func (sm *StateManager) GetBlsPublicKey(ctx context.Context, addr address.Addres
 		return pubk, xerrors.Errorf("address must be BLS address to load bls public key")
 	}
 
-	copy(pubk[:], kaddr.Payload())
-	return pubk, nil
+	return kaddr.Payload(), nil
+}
+
+func (sm *StateManager) LookupID(ctx context.Context, addr address.Address, ts *types.TipSet) (address.Address, error) {
+	cst := cbor.NewCborStore(sm.cs.Blockstore())
+	state, err := state.LoadStateTree(cst, sm.parentState(ts))
+	if err != nil {
+		return address.Undef, xerrors.Errorf("load state tree: %w", err)
+	}
+	return state.LookupID(addr)
 }
 
 func (sm *StateManager) GetReceipt(ctx context.Context, msg cid.Cid, ts *types.TipSet) (*types.MessageReceipt, error) {
@@ -383,7 +448,7 @@ func (sm *StateManager) GetReceipt(ctx context.Context, msg cid.Cid, ts *types.T
 		return nil, fmt.Errorf("failed to load message: %w", err)
 	}
 
-	r, err := sm.tipsetExecutedMessage(ts, msg, m.VMMessage())
+	r, _, err := sm.tipsetExecutedMessage(ts, msg, m.VMMessage())
 	if err != nil {
 		return nil, err
 	}
@@ -392,7 +457,7 @@ func (sm *StateManager) GetReceipt(ctx context.Context, msg cid.Cid, ts *types.T
 		return r, nil
 	}
 
-	_, r, err = sm.searchBackForMsg(ctx, ts, m)
+	_, r, _, err = sm.searchBackForMsg(ctx, ts, m)
 	if err != nil {
 		return nil, fmt.Errorf("failed to look back through chain for message: %w", err)
 	}
@@ -400,44 +465,48 @@ func (sm *StateManager) GetReceipt(ctx context.Context, msg cid.Cid, ts *types.T
 	return r, nil
 }
 
-func (sm *StateManager) WaitForMessage(ctx context.Context, mcid cid.Cid) (*types.TipSet, *types.MessageReceipt, error) {
+// WaitForMessage blocks until a message appears on chain. It looks backwards in the chain to see if this has already
+// happened. It guarantees that the message has been on chain for at least confidence epochs without being reverted
+// before returning.
+func (sm *StateManager) WaitForMessage(ctx context.Context, mcid cid.Cid, confidence uint64) (*types.TipSet, *types.MessageReceipt, cid.Cid, error) {
 	ctx, cancel := context.WithCancel(ctx)
 	defer cancel()
 
 	msg, err := sm.cs.GetCMessage(mcid)
 	if err != nil {
-		return nil, nil, fmt.Errorf("failed to load message: %w", err)
+		return nil, nil, cid.Undef, fmt.Errorf("failed to load message: %w", err)
 	}
 
 	tsub := sm.cs.SubHeadChanges(ctx)
 
 	head, ok := <-tsub
 	if !ok {
-		return nil, nil, fmt.Errorf("SubHeadChanges stream was invalid")
+		return nil, nil, cid.Undef, fmt.Errorf("SubHeadChanges stream was invalid")
 	}
 
 	if len(head) != 1 {
-		return nil, nil, fmt.Errorf("SubHeadChanges first entry should have been one item")
+		return nil, nil, cid.Undef, fmt.Errorf("SubHeadChanges first entry should have been one item")
 	}
 
 	if head[0].Type != store.HCCurrent {
-		return nil, nil, fmt.Errorf("expected current head on SHC stream (got %s)", head[0].Type)
+		return nil, nil, cid.Undef, fmt.Errorf("expected current head on SHC stream (got %s)", head[0].Type)
 	}
 
-	r, err := sm.tipsetExecutedMessage(head[0].Val, mcid, msg.VMMessage())
+	r, foundMsg, err := sm.tipsetExecutedMessage(head[0].Val, mcid, msg.VMMessage())
 	if err != nil {
-		return nil, nil, err
+		return nil, nil, cid.Undef, err
 	}
 
 	if r != nil {
-		return head[0].Val, r, nil
+		return head[0].Val, r, foundMsg, nil
 	}
 
 	var backTs *types.TipSet
 	var backRcp *types.MessageReceipt
+	var backFm cid.Cid
 	backSearchWait := make(chan struct{})
 	go func() {
-		fts, r, err := sm.searchBackForMsg(ctx, head[0].Val, msg)
+		fts, r, foundMsg, err := sm.searchBackForMsg(ctx, head[0].Val, msg)
 		if err != nil {
 			log.Warnf("failed to look back through chain for message: %w", err)
 			return
@@ -445,98 +514,162 @@ func (sm *StateManager) WaitForMessage(ctx context.Context, mcid cid.Cid) (*type
 
 		backTs = fts
 		backRcp = r
+		backFm = foundMsg
 		close(backSearchWait)
 	}()
 
+	var candidateTs *types.TipSet
+	var candidateRcp *types.MessageReceipt
+	var candidateFm cid.Cid
+	heightOfHead := head[0].Val.Height()
+	reverts := map[types.TipSetKey]bool{}
+
 	for {
 		select {
 		case notif, ok := <-tsub:
 			if !ok {
-				return nil, nil, ctx.Err()
+				return nil, nil, cid.Undef, ctx.Err()
 			}
 			for _, val := range notif {
 				switch val.Type {
 				case store.HCRevert:
-					continue
+					if val.Val.Equals(candidateTs) {
+						candidateTs = nil
+						candidateRcp = nil
+						candidateFm = cid.Undef
+					}
+					if backSearchWait != nil {
+						reverts[val.Val.Key()] = true
+					}
 				case store.HCApply:
-					r, err := sm.tipsetExecutedMessage(val.Val, mcid, msg.VMMessage())
+					if candidateTs != nil && val.Val.Height() >= candidateTs.Height()+abi.ChainEpoch(confidence) {
+						return candidateTs, candidateRcp, candidateFm, nil
+					}
+					r, foundMsg, err := sm.tipsetExecutedMessage(val.Val, mcid, msg.VMMessage())
 					if err != nil {
-						return nil, nil, err
+						return nil, nil, cid.Undef, err
 					}
 					if r != nil {
-						return val.Val, r, nil
+						if confidence == 0 {
+							return val.Val, r, foundMsg, err
+						}
+						candidateTs = val.Val
+						candidateRcp = r
+						candidateFm = foundMsg
 					}
+					heightOfHead = val.Val.Height()
 				}
 			}
 		case <-backSearchWait:
-			if backTs != nil {
-				return backTs, backRcp, nil
+			// check if we found the message in the chain and that is hasn't been reverted since we started searching
+			if backTs != nil && !reverts[backTs.Key()] {
+				// if head is at or past confidence interval, return immediately
+				if heightOfHead >= backTs.Height()+abi.ChainEpoch(confidence) {
+					return backTs, backRcp, backFm, nil
+				}
+
+				// wait for confidence interval
+				candidateTs = backTs
+				candidateRcp = backRcp
+				candidateFm = backFm
 			}
+			reverts = nil
 			backSearchWait = nil
 		case <-ctx.Done():
-			return nil, nil, ctx.Err()
+			return nil, nil, cid.Undef, ctx.Err()
 		}
 	}
 }
 
-func (sm *StateManager) searchBackForMsg(ctx context.Context, from *types.TipSet, m store.ChainMsg) (*types.TipSet, *types.MessageReceipt, error) {
+func (sm *StateManager) SearchForMessage(ctx context.Context, mcid cid.Cid) (*types.TipSet, *types.MessageReceipt, cid.Cid, error) {
+	msg, err := sm.cs.GetCMessage(mcid)
+	if err != nil {
+		return nil, nil, cid.Undef, fmt.Errorf("failed to load message: %w", err)
+	}
+
+	head := sm.cs.GetHeaviestTipSet()
+
+	r, foundMsg, err := sm.tipsetExecutedMessage(head, mcid, msg.VMMessage())
+	if err != nil {
+		return nil, nil, cid.Undef, err
+	}
+
+	if r != nil {
+		return head, r, foundMsg, nil
+	}
+
+	fts, r, foundMsg, err := sm.searchBackForMsg(ctx, head, msg)
+
+	if err != nil {
+		log.Warnf("failed to look back through chain for message %s", mcid)
+		return nil, nil, cid.Undef, err
+	}
+
+	if fts == nil {
+		return nil, nil, cid.Undef, nil
+	}
+
+	return fts, r, foundMsg, nil
+}
+
+func (sm *StateManager) searchBackForMsg(ctx context.Context, from *types.TipSet, m types.ChainMsg) (*types.TipSet, *types.MessageReceipt, cid.Cid, error) {
 
 	cur := from
 	for {
 		if cur.Height() == 0 {
 			// it ain't here!
-			return nil, nil, nil
+			return nil, nil, cid.Undef, nil
 		}
 
 		select {
 		case <-ctx.Done():
-			return nil, nil, nil
+			return nil, nil, cid.Undef, nil
 		default:
 		}
 
-		act, err := sm.GetActor(m.VMMessage().From, cur)
+		act, err := sm.LoadActor(ctx, m.VMMessage().From, cur)
 		if err != nil {
-			return nil, nil, err
+			return nil, nil, cid.Cid{}, err
 		}
 
-		if act.Nonce < m.VMMessage().Nonce {
-			// nonce on chain is before message nonce we're looking for, its
-			// not going to be here
-			return nil, nil, nil
+		// we either have no messages from the sender, or the latest message we found has a lower nonce than the one being searched for,
+		// either way, no reason to lookback, it ain't there
+		if act.Nonce == 0 || act.Nonce < m.VMMessage().Nonce {
+			return nil, nil, cid.Undef, nil
 		}
 
 		ts, err := sm.cs.LoadTipSet(cur.Parents())
 		if err != nil {
-			return nil, nil, fmt.Errorf("failed to load tipset during msg wait searchback: %w", err)
+			return nil, nil, cid.Undef, fmt.Errorf("failed to load tipset during msg wait searchback: %w", err)
 		}
 
-		r, err := sm.tipsetExecutedMessage(ts, m.Cid(), m.VMMessage())
+		r, foundMsg, err := sm.tipsetExecutedMessage(ts, m.Cid(), m.VMMessage())
 		if err != nil {
-			return nil, nil, fmt.Errorf("checking for message execution during lookback: %w", err)
+			return nil, nil, cid.Undef, fmt.Errorf("checking for message execution during lookback: %w", err)
 		}
 
 		if r != nil {
-			return ts, r, nil
+			return ts, r, foundMsg, nil
 		}
 
 		cur = ts
 	}
 }
 
-func (sm *StateManager) tipsetExecutedMessage(ts *types.TipSet, msg cid.Cid, vmm *types.Message) (*types.MessageReceipt, error) {
+func (sm *StateManager) tipsetExecutedMessage(ts *types.TipSet, msg cid.Cid, vmm *types.Message) (*types.MessageReceipt, cid.Cid, error) {
 	// The genesis block did not execute any messages
 	if ts.Height() == 0 {
-		return nil, nil
+		return nil, cid.Undef, nil
 	}
 
 	pts, err := sm.cs.LoadTipSet(ts.Parents())
 	if err != nil {
-		return nil, err
+		return nil, cid.Undef, err
 	}
 
 	cm, err := sm.cs.MessagesForTipset(pts)
 	if err != nil {
-		return nil, err
+		return nil, cid.Undef, err
 	}
 
 	for ii := range cm {
@@ -546,21 +679,30 @@ func (sm *StateManager) tipsetExecutedMessage(ts *types.TipSet, msg cid.Cid, vmm
 
 		if m.VMMessage().From == vmm.From { // cheaper to just check origin first
 			if m.VMMessage().Nonce == vmm.Nonce {
-				if m.Cid() == msg {
-					return sm.cs.GetParentReceipt(ts.Blocks()[0], i)
+				if m.VMMessage().EqualCall(vmm) {
+					if m.Cid() != msg {
+						log.Warnw("found message with equal nonce and call params but different CID",
+							"wanted", msg, "found", m.Cid(), "nonce", vmm.Nonce, "from", vmm.From)
+					}
+
+					pr, err := sm.cs.GetParentReceipt(ts.Blocks()[0], i)
+					if err != nil {
+						return nil, cid.Undef, err
+					}
+					return pr, m.Cid(), nil
 				}
 
 				// this should be that message
-				return nil, xerrors.Errorf("found message with equal nonce as the one we are looking for (F:%s n %d, TS: %s n%d)",
+				return nil, cid.Undef, xerrors.Errorf("found message with equal nonce as the one we are looking for (F:%s n %d, TS: %s n%d)",
 					msg, vmm.Nonce, m.Cid(), m.VMMessage().Nonce)
 			}
 			if m.VMMessage().Nonce < vmm.Nonce {
-				return nil, nil // don't bother looking further
+				return nil, cid.Undef, nil // don't bother looking further
 			}
 		}
 	}
 
-	return nil, nil
+	return nil, cid.Undef, nil
 }
 
 func (sm *StateManager) ListAllActors(ctx context.Context, ts *types.TipSet) ([]address.Address, error) {
@@ -572,18 +714,13 @@ func (sm *StateManager) ListAllActors(ctx context.Context, ts *types.TipSet) ([]
 		return nil, err
 	}
 
-	cst := hamt.CSTFromBstore(sm.cs.Blockstore())
-	r, err := hamt.LoadNode(ctx, cst, st)
+	stateTree, err := sm.StateTree(st)
 	if err != nil {
 		return nil, err
 	}
 
 	var out []address.Address
-	err = r.ForEach(ctx, func(k string, val interface{}) error {
-		addr, err := address.NewFromBytes([]byte(k))
-		if err != nil {
-			return xerrors.Errorf("address in state tree was not valid: %w", err)
-		}
+	err = stateTree.ForEach(func(addr address.Address, act *types.Actor) error {
 		out = append(out, addr)
 		return nil
 	})
@@ -594,16 +731,586 @@ func (sm *StateManager) ListAllActors(ctx context.Context, ts *types.TipSet) ([]
 	return out, nil
 }
 
-func (sm *StateManager) MarketBalance(ctx context.Context, addr address.Address, ts *types.TipSet) (actors.StorageParticipantBalance, error) {
-	var state actors.StorageMarketState
-	if _, err := sm.LoadActorState(ctx, actors.StorageMarketAddress, &state, ts); err != nil {
-		return actors.StorageParticipantBalance{}, err
-	}
-	cst := hamt.CSTFromBstore(sm.cs.Blockstore())
-	b, _, err := actors.GetMarketBalances(ctx, cst, state.Balances, addr)
+func (sm *StateManager) MarketBalance(ctx context.Context, addr address.Address, ts *types.TipSet) (api.MarketBalance, error) {
+	st, err := sm.ParentState(ts)
 	if err != nil {
-		return actors.StorageParticipantBalance{}, err
+		return api.MarketBalance{}, err
 	}
 
-	return b[0], nil
+	act, err := st.GetActor(market.Address)
+	if err != nil {
+		return api.MarketBalance{}, err
+	}
+
+	mstate, err := market.Load(sm.cs.Store(ctx), act)
+	if err != nil {
+		return api.MarketBalance{}, err
+	}
+
+	addr, err = sm.LookupID(ctx, addr, ts)
+	if err != nil {
+		return api.MarketBalance{}, err
+	}
+
+	var out api.MarketBalance
+
+	et, err := mstate.EscrowTable()
+	if err != nil {
+		return api.MarketBalance{}, err
+	}
+	out.Escrow, err = et.Get(addr)
+	if err != nil {
+		return api.MarketBalance{}, xerrors.Errorf("getting escrow balance: %w", err)
+	}
+
+	lt, err := mstate.LockedTable()
+	if err != nil {
+		return api.MarketBalance{}, err
+	}
+	out.Locked, err = lt.Get(addr)
+	if err != nil {
+		return api.MarketBalance{}, xerrors.Errorf("getting locked balance: %w", err)
+	}
+
+	return out, nil
+}
+
+func (sm *StateManager) ValidateChain(ctx context.Context, ts *types.TipSet) error {
+	tschain := []*types.TipSet{ts}
+	for ts.Height() != 0 {
+		next, err := sm.cs.LoadTipSet(ts.Parents())
+		if err != nil {
+			return err
+		}
+
+		tschain = append(tschain, next)
+		ts = next
+	}
+
+	lastState := tschain[len(tschain)-1].ParentState()
+	for i := len(tschain) - 1; i >= 0; i-- {
+		cur := tschain[i]
+		log.Infof("computing state (height: %d, ts=%s)", cur.Height(), cur.Cids())
+		if cur.ParentState() != lastState {
+			return xerrors.Errorf("tipset chain had state mismatch at height %d", cur.Height())
+		}
+		st, _, err := sm.TipSetState(ctx, cur)
+		if err != nil {
+			return err
+		}
+		lastState = st
+	}
+
+	return nil
+}
+
+func (sm *StateManager) SetVMConstructor(nvm func(context.Context, *vm.VMOpts) (*vm.VM, error)) {
+	sm.newVM = nvm
+}
+
+type genesisInfo struct {
+	genesisMsigs []msig0.State
+	// info about the Accounts in the genesis state
+	genesisActors      []genesisActor
+	genesisPledge      abi.TokenAmount
+	genesisMarketFunds abi.TokenAmount
+}
+
+type genesisActor struct {
+	addr    address.Address
+	initBal abi.TokenAmount
+}
+
+// sets up information about the actors in the genesis state
+func (sm *StateManager) setupGenesisActors(ctx context.Context) error {
+
+	gi := genesisInfo{}
+
+	gb, err := sm.cs.GetGenesis()
+	if err != nil {
+		return xerrors.Errorf("getting genesis block: %w", err)
+	}
+
+	gts, err := types.NewTipSet([]*types.BlockHeader{gb})
+	if err != nil {
+		return xerrors.Errorf("getting genesis tipset: %w", err)
+	}
+
+	st, _, err := sm.TipSetState(ctx, gts)
+	if err != nil {
+		return xerrors.Errorf("getting genesis tipset state: %w", err)
+	}
+
+	cst := cbor.NewCborStore(sm.cs.Blockstore())
+	sTree, err := state.LoadStateTree(cst, st)
+	if err != nil {
+		return xerrors.Errorf("loading state tree: %w", err)
+	}
+
+	gi.genesisMarketFunds, err = getFilMarketLocked(ctx, sTree)
+	if err != nil {
+		return xerrors.Errorf("setting up genesis market funds: %w", err)
+	}
+
+	gi.genesisPledge, err = getFilPowerLocked(ctx, sTree)
+	if err != nil {
+		return xerrors.Errorf("setting up genesis pledge: %w", err)
+	}
+
+	totalsByEpoch := make(map[abi.ChainEpoch]abi.TokenAmount)
+	err = sTree.ForEach(func(kaddr address.Address, act *types.Actor) error {
+		if act.IsMultisigActor() {
+			s, err := multisig.Load(sm.cs.Store(ctx), act)
+			if err != nil {
+				return err
+			}
+
+			se, err := s.StartEpoch()
+			if err != nil {
+				return err
+			}
+
+			if se != 0 {
+				return xerrors.New("genesis multisig doesn't start vesting at epoch 0!")
+			}
+
+			ud, err := s.UnlockDuration()
+			if err != nil {
+				return err
+			}
+
+			ib, err := s.InitialBalance()
+			if err != nil {
+				return err
+			}
+
+			ot, f := totalsByEpoch[ud]
+			if f {
+				totalsByEpoch[ud] = big.Add(ot, ib)
+			} else {
+				totalsByEpoch[ud] = ib
+			}
+
+		} else if act.IsAccountActor() {
+			// should exclude burnt funds actor and "remainder account actor"
+			// should only ever be "faucet" accounts in testnets
+			if kaddr == builtin0.BurntFundsActorAddr {
+				return nil
+			}
+
+			kid, err := sTree.LookupID(kaddr)
+			if err != nil {
+				return xerrors.Errorf("resolving address: %w", err)
+			}
+
+			gi.genesisActors = append(gi.genesisActors, genesisActor{
+				addr:    kid,
+				initBal: act.Balance,
+			})
+		}
+		return nil
+	})
+
+	if err != nil {
+		return xerrors.Errorf("error setting up genesis infos: %w", err)
+	}
+
+	// TODO: use network upgrade abstractions or always start at actors v0?
+	gi.genesisMsigs = make([]msig0.State, 0, len(totalsByEpoch))
+	for k, v := range totalsByEpoch {
+		ns := msig0.State{
+			InitialBalance: v,
+			UnlockDuration: k,
+			PendingTxns:    cid.Undef,
+		}
+		gi.genesisMsigs = append(gi.genesisMsigs, ns)
+	}
+
+	sm.preIgnitionGenInfos = &gi
+
+	return nil
+}
+
+// sets up information about the actors in the genesis state
+// For testnet we use a hardcoded set of multisig states, instead of what's actually in the genesis multisigs
+// We also do not consider ANY account actors (including the faucet)
+func (sm *StateManager) setupPreIgnitionGenesisActorsTestnet(ctx context.Context) error {
+
+	gi := genesisInfo{}
+
+	gb, err := sm.cs.GetGenesis()
+	if err != nil {
+		return xerrors.Errorf("getting genesis block: %w", err)
+	}
+
+	gts, err := types.NewTipSet([]*types.BlockHeader{gb})
+	if err != nil {
+		return xerrors.Errorf("getting genesis tipset: %w", err)
+	}
+
+	st, _, err := sm.TipSetState(ctx, gts)
+	if err != nil {
+		return xerrors.Errorf("getting genesis tipset state: %w", err)
+	}
+
+	cst := cbor.NewCborStore(sm.cs.Blockstore())
+	sTree, err := state.LoadStateTree(cst, st)
+	if err != nil {
+		return xerrors.Errorf("loading state tree: %w", err)
+	}
+
+	gi.genesisMarketFunds, err = getFilMarketLocked(ctx, sTree)
+	if err != nil {
+		return xerrors.Errorf("setting up genesis market funds: %w", err)
+	}
+
+	gi.genesisPledge, err = getFilPowerLocked(ctx, sTree)
+	if err != nil {
+		return xerrors.Errorf("setting up genesis pledge: %w", err)
+	}
+
+	totalsByEpoch := make(map[abi.ChainEpoch]abi.TokenAmount)
+
+	// 6 months
+	sixMonths := abi.ChainEpoch(183 * builtin0.EpochsInDay)
+	totalsByEpoch[sixMonths] = big.NewInt(49_929_341)
+	totalsByEpoch[sixMonths] = big.Add(totalsByEpoch[sixMonths], big.NewInt(32_787_700))
+
+	// 1 year
+	oneYear := abi.ChainEpoch(365 * builtin0.EpochsInDay)
+	totalsByEpoch[oneYear] = big.NewInt(22_421_712)
+
+	// 2 years
+	twoYears := abi.ChainEpoch(2 * 365 * builtin0.EpochsInDay)
+	totalsByEpoch[twoYears] = big.NewInt(7_223_364)
+
+	// 3 years
+	threeYears := abi.ChainEpoch(3 * 365 * builtin0.EpochsInDay)
+	totalsByEpoch[threeYears] = big.NewInt(87_637_883)
+
+	// 6 years
+	sixYears := abi.ChainEpoch(6 * 365 * builtin0.EpochsInDay)
+	totalsByEpoch[sixYears] = big.NewInt(100_000_000)
+	totalsByEpoch[sixYears] = big.Add(totalsByEpoch[sixYears], big.NewInt(300_000_000))
+
+	gi.genesisMsigs = make([]msig0.State, 0, len(totalsByEpoch))
+	for k, v := range totalsByEpoch {
+		ns := msig0.State{
+			InitialBalance: v,
+			UnlockDuration: k,
+			PendingTxns:    cid.Undef,
+		}
+		gi.genesisMsigs = append(gi.genesisMsigs, ns)
+	}
+
+	sm.preIgnitionGenInfos = &gi
+
+	return nil
+}
+
+// sets up information about the actors in the genesis state, post the ignition fork
+func (sm *StateManager) setupPostIgnitionGenesisActors(ctx context.Context) error {
+
+	gi := genesisInfo{}
+
+	gb, err := sm.cs.GetGenesis()
+	if err != nil {
+		return xerrors.Errorf("getting genesis block: %w", err)
+	}
+
+	gts, err := types.NewTipSet([]*types.BlockHeader{gb})
+	if err != nil {
+		return xerrors.Errorf("getting genesis tipset: %w", err)
+	}
+
+	st, _, err := sm.TipSetState(ctx, gts)
+	if err != nil {
+		return xerrors.Errorf("getting genesis tipset state: %w", err)
+	}
+
+	cst := cbor.NewCborStore(sm.cs.Blockstore())
+	sTree, err := state.LoadStateTree(cst, st)
+	if err != nil {
+		return xerrors.Errorf("loading state tree: %w", err)
+	}
+
+	// Unnecessary, should be removed
+	gi.genesisMarketFunds, err = getFilMarketLocked(ctx, sTree)
+	if err != nil {
+		return xerrors.Errorf("setting up genesis market funds: %w", err)
+	}
+
+	// Unnecessary, should be removed
+	gi.genesisPledge, err = getFilPowerLocked(ctx, sTree)
+	if err != nil {
+		return xerrors.Errorf("setting up genesis pledge: %w", err)
+	}
+
+	totalsByEpoch := make(map[abi.ChainEpoch]abi.TokenAmount)
+
+	// 6 months
+	sixMonths := abi.ChainEpoch(183 * builtin0.EpochsInDay)
+	totalsByEpoch[sixMonths] = big.NewInt(49_929_341)
+	totalsByEpoch[sixMonths] = big.Add(totalsByEpoch[sixMonths], big.NewInt(32_787_700))
+
+	// 1 year
+	oneYear := abi.ChainEpoch(365 * builtin0.EpochsInDay)
+	totalsByEpoch[oneYear] = big.NewInt(22_421_712)
+
+	// 2 years
+	twoYears := abi.ChainEpoch(2 * 365 * builtin0.EpochsInDay)
+	totalsByEpoch[twoYears] = big.NewInt(7_223_364)
+
+	// 3 years
+	threeYears := abi.ChainEpoch(3 * 365 * builtin0.EpochsInDay)
+	totalsByEpoch[threeYears] = big.NewInt(87_637_883)
+
+	// 6 years
+	sixYears := abi.ChainEpoch(6 * 365 * builtin0.EpochsInDay)
+	totalsByEpoch[sixYears] = big.NewInt(100_000_000)
+	totalsByEpoch[sixYears] = big.Add(totalsByEpoch[sixYears], big.NewInt(300_000_000))
+
+	gi.genesisMsigs = make([]msig0.State, 0, len(totalsByEpoch))
+	for k, v := range totalsByEpoch {
+		ns := msig0.State{
+			// In the pre-ignition logic, we incorrectly set this value in Fil, not attoFil, an off-by-10^18 error
+			InitialBalance: big.Mul(v, big.NewInt(int64(build.FilecoinPrecision))),
+			UnlockDuration: k,
+			PendingTxns:    cid.Undef,
+			// In the pre-ignition logic, the start epoch was 0. This changes in the fork logic of the Ignition upgrade itself.
+			StartEpoch: build.UpgradeLiftoffHeight,
+		}
+		gi.genesisMsigs = append(gi.genesisMsigs, ns)
+	}
+
+	sm.postIgnitionGenInfos = &gi
+
+	return nil
+}
+
+// GetVestedFunds returns all funds that have "left" actors that are in the genesis state:
+// - For Multisigs, it counts the actual amounts that have vested at the given epoch
+// - For Accounts, it counts max(currentBalance - genesisBalance, 0).
+func (sm *StateManager) GetFilVested(ctx context.Context, height abi.ChainEpoch, st *state.StateTree) (abi.TokenAmount, error) {
+	vf := big.Zero()
+	if height <= build.UpgradeIgnitionHeight {
+		for _, v := range sm.preIgnitionGenInfos.genesisMsigs {
+			au := big.Sub(v.InitialBalance, v.AmountLocked(height))
+			vf = big.Add(vf, au)
+		}
+	} else {
+		for _, v := range sm.postIgnitionGenInfos.genesisMsigs {
+			// In the pre-ignition logic, we simply called AmountLocked(height), assuming startEpoch was 0.
+			// The start epoch changed in the Ignition upgrade.
+			au := big.Sub(v.InitialBalance, v.AmountLocked(height-v.StartEpoch))
+			vf = big.Add(vf, au)
+		}
+	}
+
+	// there should not be any such accounts in testnet (and also none in mainnet?)
+	// continue to use preIgnitionGenInfos, nothing changed at the Ignition epoch
+	for _, v := range sm.preIgnitionGenInfos.genesisActors {
+		act, err := st.GetActor(v.addr)
+		if err != nil {
+			return big.Zero(), xerrors.Errorf("failed to get actor: %w", err)
+		}
+
+		diff := big.Sub(v.initBal, act.Balance)
+		if diff.GreaterThan(big.Zero()) {
+			vf = big.Add(vf, diff)
+		}
+	}
+
+	// continue to use preIgnitionGenInfos, nothing changed at the Ignition epoch
+	vf = big.Add(vf, sm.preIgnitionGenInfos.genesisPledge)
+	// continue to use preIgnitionGenInfos, nothing changed at the Ignition epoch
+	vf = big.Add(vf, sm.preIgnitionGenInfos.genesisMarketFunds)
+
+	return vf, nil
+}
+
+func GetFilMined(ctx context.Context, st *state.StateTree) (abi.TokenAmount, error) {
+	ractor, err := st.GetActor(reward.Address)
+	if err != nil {
+		return big.Zero(), xerrors.Errorf("failed to load reward actor state: %w", err)
+	}
+
+	rst, err := reward.Load(adt.WrapStore(ctx, st.Store), ractor)
+	if err != nil {
+		return big.Zero(), err
+	}
+
+	return rst.TotalStoragePowerReward()
+}
+
+func getFilMarketLocked(ctx context.Context, st *state.StateTree) (abi.TokenAmount, error) {
+	act, err := st.GetActor(market.Address)
+	if err != nil {
+		return big.Zero(), xerrors.Errorf("failed to load market actor: %w", err)
+	}
+
+	mst, err := market.Load(adt.WrapStore(ctx, st.Store), act)
+	if err != nil {
+		return big.Zero(), xerrors.Errorf("failed to load market state: %w", err)
+	}
+
+	return mst.TotalLocked()
+}
+
+func getFilPowerLocked(ctx context.Context, st *state.StateTree) (abi.TokenAmount, error) {
+	pactor, err := st.GetActor(power.Address)
+	if err != nil {
+		return big.Zero(), xerrors.Errorf("failed to load power actor: %w", err)
+	}
+
+	pst, err := power.Load(adt.WrapStore(ctx, st.Store), pactor)
+	if err != nil {
+		return big.Zero(), xerrors.Errorf("failed to load power state: %w", err)
+	}
+
+	return pst.TotalLocked()
+}
+
+func (sm *StateManager) GetFilLocked(ctx context.Context, st *state.StateTree) (abi.TokenAmount, error) {
+
+	filMarketLocked, err := getFilMarketLocked(ctx, st)
+	if err != nil {
+		return big.Zero(), xerrors.Errorf("failed to get filMarketLocked: %w", err)
+	}
+
+	filPowerLocked, err := getFilPowerLocked(ctx, st)
+	if err != nil {
+		return big.Zero(), xerrors.Errorf("failed to get filPowerLocked: %w", err)
+	}
+
+	return types.BigAdd(filMarketLocked, filPowerLocked), nil
+}
+
+func GetFilBurnt(ctx context.Context, st *state.StateTree) (abi.TokenAmount, error) {
+	burnt, err := st.GetActor(builtin0.BurntFundsActorAddr)
+	if err != nil {
+		return big.Zero(), xerrors.Errorf("failed to load burnt actor: %w", err)
+	}
+
+	return burnt.Balance, nil
+}
+
+func (sm *StateManager) GetCirculatingSupplyDetailed(ctx context.Context, height abi.ChainEpoch, st *state.StateTree) (api.CirculatingSupply, error) {
+	sm.genesisMsigLk.Lock()
+	defer sm.genesisMsigLk.Unlock()
+	if sm.preIgnitionGenInfos == nil {
+		err := sm.setupPreIgnitionGenesisActorsTestnet(ctx)
+		if err != nil {
+			return api.CirculatingSupply{}, xerrors.Errorf("failed to setup pre-ignition genesis information: %w", err)
+		}
+	}
+	if sm.postIgnitionGenInfos == nil {
+		err := sm.setupPostIgnitionGenesisActors(ctx)
+		if err != nil {
+			return api.CirculatingSupply{}, xerrors.Errorf("failed to setup post-ignition genesis information: %w", err)
+		}
+	}
+
+	filVested, err := sm.GetFilVested(ctx, height, st)
+	if err != nil {
+		return api.CirculatingSupply{}, xerrors.Errorf("failed to calculate filVested: %w", err)
+	}
+
+	filMined, err := GetFilMined(ctx, st)
+	if err != nil {
+		return api.CirculatingSupply{}, xerrors.Errorf("failed to calculate filMined: %w", err)
+	}
+
+	filBurnt, err := GetFilBurnt(ctx, st)
+	if err != nil {
+		return api.CirculatingSupply{}, xerrors.Errorf("failed to calculate filBurnt: %w", err)
+	}
+
+	filLocked, err := sm.GetFilLocked(ctx, st)
+	if err != nil {
+		return api.CirculatingSupply{}, xerrors.Errorf("failed to calculate filLocked: %w", err)
+	}
+
+	ret := types.BigAdd(filVested, filMined)
+	ret = types.BigSub(ret, filBurnt)
+	ret = types.BigSub(ret, filLocked)
+
+	if ret.LessThan(big.Zero()) {
+		ret = big.Zero()
+	}
+
+	return api.CirculatingSupply{
+		FilVested:      filVested,
+		FilMined:       filMined,
+		FilBurnt:       filBurnt,
+		FilLocked:      filLocked,
+		FilCirculating: ret,
+	}, nil
+}
+
+func (sm *StateManager) GetCirculatingSupply(ctx context.Context, height abi.ChainEpoch, st *state.StateTree) (abi.TokenAmount, error) {
+	csi, err := sm.GetCirculatingSupplyDetailed(ctx, height, st)
+	if err != nil {
+		return big.Zero(), err
+	}
+
+	return csi.FilCirculating, nil
+}
+
+func (sm *StateManager) GetNtwkVersion(ctx context.Context, height abi.ChainEpoch) network.Version {
+	// TODO: move hard fork epoch checks to a schedule defined in build/
+
+	if build.UseNewestNetwork() {
+		return build.NewestNetworkVersion
+	}
+
+	if height <= build.UpgradeBreezeHeight {
+		return network.Version0
+	}
+
+	if height <= build.UpgradeSmokeHeight {
+		return network.Version1
+	}
+
+	if height <= build.UpgradeIgnitionHeight {
+		return network.Version2
+	}
+
+	return build.NewestNetworkVersion
+}
+
+func (sm *StateManager) GetPaychState(ctx context.Context, addr address.Address, ts *types.TipSet) (*types.Actor, paych.State, error) {
+	st, err := sm.ParentState(ts)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	act, err := st.GetActor(addr)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	actState, err := paych.Load(sm.cs.Store(ctx), act)
+	if err != nil {
+		return nil, nil, err
+	}
+	return act, actState, nil
+}
+
+func (sm *StateManager) GetMarketState(ctx context.Context, ts *types.TipSet) (market.State, error) {
+	st, err := sm.ParentState(ts)
+	if err != nil {
+		return nil, err
+	}
+
+	act, err := st.GetActor(market.Address)
+	if err != nil {
+		return nil, err
+	}
+
+	actState, err := market.Load(sm.cs.Store(ctx), act)
+	if err != nil {
+		return nil, err
+	}
+	return actState, nil
 }
diff --git a/chain/stmgr/utils.go b/chain/stmgr/utils.go
index 109848f8e..58e7f480f 100644
--- a/chain/stmgr/utils.go
+++ b/chain/stmgr/utils.go
@@ -1,313 +1,656 @@
 package stmgr
 
 import (
+	"bytes"
 	"context"
+	"fmt"
+	"os"
+	"reflect"
+	"runtime"
+	"strings"
 
-	ffi "github.com/filecoin-project/filecoin-ffi"
-	sectorbuilder "github.com/filecoin-project/go-sectorbuilder"
-
-	"github.com/filecoin-project/go-address"
-
-	"github.com/filecoin-project/lotus/api"
-	"github.com/filecoin-project/lotus/chain/actors"
-	"github.com/filecoin-project/lotus/chain/types"
-
-	amt "github.com/filecoin-project/go-amt-ipld"
 	cid "github.com/ipfs/go-cid"
-	hamt "github.com/ipfs/go-hamt-ipld"
-	blockstore "github.com/ipfs/go-ipfs-blockstore"
-	cbor "github.com/ipfs/go-ipld-cbor"
-	"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/crypto"
+
+	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
+	account0 "github.com/filecoin-project/specs-actors/actors/builtin/account"
+	cron0 "github.com/filecoin-project/specs-actors/actors/builtin/cron"
+	init0 "github.com/filecoin-project/specs-actors/actors/builtin/init"
+	market0 "github.com/filecoin-project/specs-actors/actors/builtin/market"
+	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
+	msig0 "github.com/filecoin-project/specs-actors/actors/builtin/multisig"
+	paych0 "github.com/filecoin-project/specs-actors/actors/builtin/paych"
+	power0 "github.com/filecoin-project/specs-actors/actors/builtin/power"
+	reward0 "github.com/filecoin-project/specs-actors/actors/builtin/reward"
+	verifreg0 "github.com/filecoin-project/specs-actors/actors/builtin/verifreg"
+	proof0 "github.com/filecoin-project/specs-actors/actors/runtime/proof"
+
+	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/build"
+	init_ "github.com/filecoin-project/lotus/chain/actors/builtin/init"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/market"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/power"
+	"github.com/filecoin-project/lotus/chain/beacon"
+	"github.com/filecoin-project/lotus/chain/state"
+	"github.com/filecoin-project/lotus/chain/store"
+	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/chain/vm"
+	"github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper"
+	"github.com/filecoin-project/lotus/node/modules/dtypes"
 )
 
+func GetNetworkName(ctx context.Context, sm *StateManager, st cid.Cid) (dtypes.NetworkName, error) {
+	act, err := sm.LoadActorRaw(ctx, init_.Address, st)
+	if err != nil {
+		return "", err
+	}
+	ias, err := init_.Load(sm.cs.Store(ctx), act)
+	if err != nil {
+		return "", err
+	}
+
+	return ias.NetworkName()
+}
+
 func GetMinerWorkerRaw(ctx context.Context, sm *StateManager, st cid.Cid, maddr address.Address) (address.Address, error) {
-	recp, err := sm.CallRaw(ctx, &types.Message{
-		To:     maddr,
-		From:   maddr,
-		Method: actors.MAMethods.GetWorkerAddr,
-	}, st, nil, 0)
+	state, err := sm.StateTree(st)
 	if err != nil {
-		return address.Undef, xerrors.Errorf("callRaw failed: %w", err)
+		return address.Undef, xerrors.Errorf("(get sset) failed to load state tree: %w", err)
 	}
-
-	if recp.ExitCode != 0 {
-		return address.Undef, xerrors.Errorf("getting miner worker addr failed (exit code %d)", recp.ExitCode)
-	}
-
-	worker, err := address.NewFromBytes(recp.Return)
+	act, err := state.GetActor(maddr)
 	if err != nil {
-		return address.Undef, err
+		return address.Undef, xerrors.Errorf("(get sset) failed to load miner actor: %w", err)
+	}
+	mas, err := miner.Load(sm.cs.Store(ctx), act)
+	if err != nil {
+		return address.Undef, xerrors.Errorf("(get sset) failed to load miner actor state: %w", err)
 	}
 
-	if worker.Protocol() == address.ID {
-		return address.Undef, xerrors.Errorf("need to resolve worker address to a pubkeyaddr")
+	info, err := mas.Info()
+	if err != nil {
+		return address.Undef, xerrors.Errorf("failed to load actor info: %w", err)
 	}
 
-	return worker, nil
+	return vm.ResolveToKeyAddr(state, sm.cs.Store(ctx), info.Worker)
 }
 
-func GetMinerOwner(ctx context.Context, sm *StateManager, st cid.Cid, maddr address.Address) (address.Address, error) {
-	recp, err := sm.CallRaw(ctx, &types.Message{
-		To:     maddr,
-		From:   maddr,
-		Method: actors.MAMethods.GetOwner,
-	}, st, nil, 0)
-	if err != nil {
-		return address.Undef, xerrors.Errorf("callRaw failed: %w", err)
-	}
-
-	if recp.ExitCode != 0 {
-		return address.Undef, xerrors.Errorf("getting miner owner addr failed (exit code %d)", recp.ExitCode)
-	}
-
-	owner, err := address.NewFromBytes(recp.Return)
-	if err != nil {
-		return address.Undef, err
-	}
-
-	if owner.Protocol() == address.ID {
-		return address.Undef, xerrors.Errorf("need to resolve owner address to a pubkeyaddr")
-	}
-
-	return owner, nil
+func GetPower(ctx context.Context, sm *StateManager, ts *types.TipSet, maddr address.Address) (power.Claim, power.Claim, bool, error) {
+	return GetPowerRaw(ctx, sm, ts.ParentState(), maddr)
 }
 
-func GetPower(ctx context.Context, sm *StateManager, ts *types.TipSet, maddr address.Address) (types.BigInt, types.BigInt, error) {
-	var err error
+func GetPowerRaw(ctx context.Context, sm *StateManager, st cid.Cid, maddr address.Address) (power.Claim, power.Claim, bool, error) {
+	act, err := sm.LoadActorRaw(ctx, power.Address, st)
+	if err != nil {
+		return power.Claim{}, power.Claim{}, false, xerrors.Errorf("(get sset) failed to load power actor state: %w", err)
+	}
 
-	var mpow types.BigInt
+	pas, err := power.Load(sm.cs.Store(ctx), act)
+	if err != nil {
+		return power.Claim{}, power.Claim{}, false, err
+	}
 
+	tpow, err := pas.TotalPower()
+	if err != nil {
+		return power.Claim{}, power.Claim{}, false, err
+	}
+
+	var mpow power.Claim
 	if maddr != address.Undef {
-		enc, aerr := actors.SerializeParams(&actors.PowerLookupParams{maddr})
-		if aerr != nil {
-			return types.EmptyInt, types.EmptyInt, aerr
+		var found bool
+		mpow, found, err = pas.MinerPower(maddr)
+		if err != nil || !found {
+			// TODO: return an error when not found?
+			return power.Claim{}, power.Claim{}, false, err
 		}
-		ret, err := sm.Call(ctx, &types.Message{
-			From:   maddr,
-			To:     actors.StoragePowerAddress,
-			Method: actors.SPAMethods.PowerLookup,
-			Params: enc,
-		}, ts)
-		if err != nil {
-			return types.EmptyInt, types.EmptyInt, xerrors.Errorf("failed to get miner power from chain: %w", err)
-		}
-		if ret.ExitCode != 0 {
-			return types.EmptyInt, types.EmptyInt, xerrors.Errorf("failed to get miner power from chain (exit code %d)", ret.ExitCode)
-		}
-
-		mpow = types.BigFromBytes(ret.Return)
 	}
 
-	ret, err := sm.Call(ctx, &types.Message{
-		From:   actors.StoragePowerAddress,
-		To:     actors.StoragePowerAddress,
-		Method: actors.SPAMethods.GetTotalStorage,
-	}, ts)
+	minpow, err := pas.MinerNominalPowerMeetsConsensusMinimum(maddr)
 	if err != nil {
-		return types.EmptyInt, types.EmptyInt, xerrors.Errorf("failed to get total power from chain: %w", err)
-	}
-	if ret.ExitCode != 0 {
-		return types.EmptyInt, types.EmptyInt, xerrors.Errorf("failed to get total power from chain (exit code %d)", ret.ExitCode)
+		return power.Claim{}, power.Claim{}, false, err
 	}
 
-	tpow := types.BigFromBytes(ret.Return)
-
-	return mpow, tpow, nil
+	return mpow, tpow, minpow, nil
 }
 
-func GetMinerPeerID(ctx context.Context, sm *StateManager, ts *types.TipSet, maddr address.Address) (peer.ID, error) {
-	recp, err := sm.Call(ctx, &types.Message{
-		To:     maddr,
-		From:   maddr,
-		Method: actors.MAMethods.GetPeerID,
-	}, ts)
+func PreCommitInfo(ctx context.Context, sm *StateManager, maddr address.Address, sid abi.SectorNumber, ts *types.TipSet) (*miner.SectorPreCommitOnChainInfo, error) {
+	act, err := sm.LoadActor(ctx, maddr, ts)
 	if err != nil {
-		return "", xerrors.Errorf("call failed: %w", err)
+		return nil, xerrors.Errorf("(get sset) failed to load miner actor: %w", err)
 	}
 
-	if recp.ExitCode != 0 {
-		return "", xerrors.Errorf("getting miner peer ID failed (exit code %d)", recp.ExitCode)
-	}
-
-	return peer.IDFromBytes(recp.Return)
-}
-
-func GetMinerWorker(ctx context.Context, sm *StateManager, ts *types.TipSet, maddr address.Address) (address.Address, error) {
-	recp, err := sm.Call(ctx, &types.Message{
-		To:     maddr,
-		From:   maddr,
-		Method: actors.MAMethods.GetWorkerAddr,
-	}, ts)
-	if err != nil {
-		return address.Undef, xerrors.Errorf("call failed: %w", err)
-	}
-
-	if recp.ExitCode != 0 {
-		return address.Undef, xerrors.Errorf("getting miner peer ID failed (exit code %d)", recp.ExitCode)
-	}
-
-	return address.NewFromBytes(recp.Return)
-}
-
-func GetMinerElectionPeriodStart(ctx context.Context, sm *StateManager, ts *types.TipSet, maddr address.Address) (uint64, error) {
-	var mas actors.StorageMinerActorState
-	_, err := sm.LoadActorState(ctx, maddr, &mas, ts)
-	if err != nil {
-		return 0, xerrors.Errorf("(get eps) failed to load miner actor state: %w", err)
-	}
-
-	return mas.ElectionPeriodStart, nil
-}
-
-func SectorSetSizes(ctx context.Context, sm *StateManager, maddr address.Address, ts *types.TipSet) (api.MinerSectors, error) {
-	var mas actors.StorageMinerActorState
-	_, err := sm.LoadActorState(ctx, maddr, &mas, ts)
-	if err != nil {
-		return api.MinerSectors{}, xerrors.Errorf("(get sset) failed to load miner actor state: %w", err)
-	}
-
-	blks := amt.WrapBlockstore(sm.ChainStore().Blockstore())
-	ss, err := amt.LoadAMT(blks, mas.Sectors)
-	if err != nil {
-		return api.MinerSectors{}, err
-	}
-
-	ps, err := amt.LoadAMT(blks, mas.ProvingSet)
-	if err != nil {
-		return api.MinerSectors{}, err
-	}
-
-	return api.MinerSectors{
-		Pset: ps.Count,
-		Sset: ss.Count,
-	}, nil
-}
-
-func GetMinerProvingSet(ctx context.Context, sm *StateManager, ts *types.TipSet, maddr address.Address) ([]*api.ChainSectorInfo, error) {
-	var mas actors.StorageMinerActorState
-	_, err := sm.LoadActorState(ctx, maddr, &mas, ts)
-	if err != nil {
-		return nil, xerrors.Errorf("(get pset) failed to load miner actor state: %w", err)
-	}
-
-	return LoadSectorsFromSet(ctx, sm.ChainStore().Blockstore(), mas.ProvingSet)
-}
-
-func GetMinerSectorSet(ctx context.Context, sm *StateManager, ts *types.TipSet, maddr address.Address) ([]*api.ChainSectorInfo, error) {
-	var mas actors.StorageMinerActorState
-	_, err := sm.LoadActorState(ctx, maddr, &mas, ts)
+	mas, err := miner.Load(sm.cs.Store(ctx), act)
 	if err != nil {
 		return nil, xerrors.Errorf("(get sset) failed to load miner actor state: %w", err)
 	}
 
-	return LoadSectorsFromSet(ctx, sm.ChainStore().Blockstore(), mas.Sectors)
+	return mas.GetPrecommittedSector(sid)
 }
 
-func GetSectorsForElectionPost(ctx context.Context, sm *StateManager, ts *types.TipSet, maddr address.Address) (*sectorbuilder.SortedPublicSectorInfo, error) {
-	sectors, err := GetMinerProvingSet(ctx, sm, ts, maddr)
+func MinerSectorInfo(ctx context.Context, sm *StateManager, maddr address.Address, sid abi.SectorNumber, ts *types.TipSet) (*miner.SectorOnChainInfo, error) {
+	act, err := sm.LoadActor(ctx, maddr, ts)
 	if err != nil {
-		return nil, xerrors.Errorf("failed to get sector set for miner: %w", err)
+		return nil, xerrors.Errorf("(get sset) failed to load miner actor: %w", err)
 	}
 
-	var uselessOtherArray []ffi.PublicSectorInfo
-	for _, s := range sectors {
-		var uselessBuffer [32]byte
-		copy(uselessBuffer[:], s.CommR)
-		uselessOtherArray = append(uselessOtherArray, ffi.PublicSectorInfo{
-			SectorID: s.SectorID,
-			CommR:    uselessBuffer,
-		})
-	}
-
-	ssi := sectorbuilder.NewSortedPublicSectorInfo(uselessOtherArray)
-	return &ssi, nil
-}
-
-func GetMinerSectorSize(ctx context.Context, sm *StateManager, ts *types.TipSet, maddr address.Address) (uint64, error) {
-	var mas actors.StorageMinerActorState
-	_, err := sm.LoadActorState(ctx, maddr, &mas, ts)
+	mas, err := miner.Load(sm.cs.Store(ctx), act)
 	if err != nil {
-		return 0, xerrors.Errorf("(get ssize) failed to load miner actor state: %w", err)
+		return nil, xerrors.Errorf("(get sset) failed to load miner actor state: %w", err)
 	}
 
-	cst := hamt.CSTFromBstore(sm.cs.Blockstore())
-	var minfo actors.MinerInfo
-	if err := cst.Get(ctx, mas.Info, &minfo); err != nil {
-		return 0, xerrors.Errorf("failed to read miner info: %w", err)
-	}
-
-	return minfo.SectorSize, nil
+	return mas.GetSector(sid)
 }
 
-func GetMinerSlashed(ctx context.Context, sm *StateManager, ts *types.TipSet, maddr address.Address) (uint64, error) {
-	var mas actors.StorageMinerActorState
-	_, err := sm.LoadActorState(ctx, maddr, &mas, ts)
+func GetMinerSectorSet(ctx context.Context, sm *StateManager, ts *types.TipSet, maddr address.Address, snos *bitfield.BitField) ([]*miner.SectorOnChainInfo, error) {
+	act, err := sm.LoadActor(ctx, maddr, ts)
 	if err != nil {
-		return 0, xerrors.Errorf("(get mslash) failed to load miner actor state: %w", err)
+		return nil, xerrors.Errorf("(get sset) failed to load miner actor: %w", err)
 	}
 
-	return mas.SlashedAt, nil
+	mas, err := miner.Load(sm.cs.Store(ctx), act)
+	if err != nil {
+		return nil, xerrors.Errorf("(get sset) failed to load miner actor state: %w", err)
+	}
+
+	return mas.LoadSectors(snos)
 }
 
-func GetStorageDeal(ctx context.Context, sm *StateManager, dealId uint64, ts *types.TipSet) (*actors.OnChainDeal, error) {
-	var state actors.StorageMarketState
-	if _, err := sm.LoadActorState(ctx, actors.StorageMarketAddress, &state, ts); err != nil {
-		return nil, err
+func GetSectorsForWinningPoSt(ctx context.Context, pv ffiwrapper.Verifier, sm *StateManager, st cid.Cid, maddr address.Address, rand abi.PoStRandomness) ([]proof0.SectorInfo, error) {
+	act, err := sm.LoadActorRaw(ctx, maddr, st)
+	if err != nil {
+		return nil, xerrors.Errorf("failed to load miner actor: %w", err)
 	}
 
-	blks := amt.WrapBlockstore(sm.ChainStore().Blockstore())
-	da, err := amt.LoadAMT(blks, state.Deals)
+	mas, err := miner.Load(sm.cs.Store(ctx), act)
+	if err != nil {
+		return nil, xerrors.Errorf("failed to load miner actor state: %w", err)
+	}
+
+	// TODO (!!): Actor Update: Make this active sectors
+
+	allSectors, err := miner.AllPartSectors(mas, miner.Partition.AllSectors)
+	if err != nil {
+		return nil, xerrors.Errorf("get all sectors: %w", err)
+	}
+
+	faultySectors, err := miner.AllPartSectors(mas, miner.Partition.FaultySectors)
+	if err != nil {
+		return nil, xerrors.Errorf("get faulty sectors: %w", err)
+	}
+
+	provingSectors, err := bitfield.SubtractBitField(allSectors, faultySectors) // TODO: This is wrong, as it can contain faaults, change to just ActiveSectors in an upgrade
+	if err != nil {
+		return nil, xerrors.Errorf("calc proving sectors: %w", err)
+	}
+
+	numProvSect, err := provingSectors.Count()
+	if err != nil {
+		return nil, xerrors.Errorf("failed to count bits: %w", err)
+	}
+
+	// TODO(review): is this right? feels fishy to me
+	if numProvSect == 0 {
+		return nil, nil
+	}
+
+	info, err := mas.Info()
+	if err != nil {
+		return nil, xerrors.Errorf("getting miner info: %w", err)
+	}
+
+	spt, err := ffiwrapper.SealProofTypeFromSectorSize(info.SectorSize)
+	if err != nil {
+		return nil, xerrors.Errorf("getting seal proof type: %w", err)
+	}
+
+	wpt, err := spt.RegisteredWinningPoStProof()
+	if err != nil {
+		return nil, xerrors.Errorf("getting window proof type: %w", err)
+	}
+
+	mid, err := address.IDFromAddress(maddr)
+	if err != nil {
+		return nil, xerrors.Errorf("getting miner ID: %w", err)
+	}
+
+	ids, err := pv.GenerateWinningPoStSectorChallenge(ctx, wpt, abi.ActorID(mid), rand, numProvSect)
+	if err != nil {
+		return nil, xerrors.Errorf("generating winning post challenges: %w", err)
+	}
+
+	iter, err := provingSectors.BitIterator()
+	if err != nil {
+		return nil, xerrors.Errorf("iterating over proving sectors: %w", err)
+	}
+
+	// Select winning sectors by _index_ in the all-sectors bitfield.
+	selectedSectors := bitfield.New()
+	prev := uint64(0)
+	for _, n := range ids {
+		sno, err := iter.Nth(n - prev)
+		if err != nil {
+			return nil, xerrors.Errorf("iterating over proving sectors: %w", err)
+		}
+		selectedSectors.Set(sno)
+		prev = n
+	}
+
+	sectors, err := mas.LoadSectors(&selectedSectors)
+	if err != nil {
+		return nil, xerrors.Errorf("loading proving sectors: %w", err)
+	}
+
+	out := make([]proof0.SectorInfo, len(sectors))
+	for i, sinfo := range sectors {
+		out[i] = proof0.SectorInfo{
+			SealProof:    spt,
+			SectorNumber: sinfo.SectorNumber,
+			SealedCID:    sinfo.SealedCID,
+		}
+	}
+
+	return out, nil
+}
+
+func StateMinerInfo(ctx context.Context, sm *StateManager, ts *types.TipSet, maddr address.Address) (*miner.MinerInfo, error) {
+	act, err := sm.LoadActor(ctx, maddr, ts)
+	if err != nil {
+		return nil, xerrors.Errorf("failed to load miner actor: %w", err)
+	}
+
+	mas, err := miner.Load(sm.cs.Store(ctx), act)
+	if err != nil {
+		return nil, xerrors.Errorf("failed to load miner actor state: %w", err)
+	}
+
+	mi, err := mas.Info()
 	if err != nil {
 		return nil, err
 	}
 
-	var ocd actors.OnChainDeal
-	if err := da.Get(dealId, &ocd); err != nil {
+	return &mi, err
+}
+
+func GetMinerSlashed(ctx context.Context, sm *StateManager, ts *types.TipSet, maddr address.Address) (bool, error) {
+	act, err := sm.LoadActor(ctx, power.Address, ts)
+	if err != nil {
+		return false, xerrors.Errorf("failed to load power actor: %w", err)
+	}
+
+	spas, err := power.Load(sm.cs.Store(ctx), act)
+	if err != nil {
+		return false, xerrors.Errorf("failed to load power actor state: %w", err)
+	}
+
+	_, ok, err := spas.MinerPower(maddr)
+	if err != nil {
+		return false, xerrors.Errorf("getting miner power: %w", err)
+	}
+
+	if !ok {
+		return true, nil
+	}
+
+	return false, nil
+}
+
+func GetStorageDeal(ctx context.Context, sm *StateManager, dealID abi.DealID, ts *types.TipSet) (*api.MarketDeal, error) {
+	act, err := sm.LoadActor(ctx, market.Address, ts)
+	if err != nil {
+		return nil, xerrors.Errorf("failed to load market actor: %w", err)
+	}
+
+	state, err := market.Load(sm.cs.Store(ctx), act)
+	if err != nil {
+		return nil, xerrors.Errorf("failed to load market actor state: %w", err)
+	}
+
+	proposals, err := state.Proposals()
+	if err != nil {
 		return nil, err
 	}
 
-	return &ocd, nil
+	proposal, found, err := proposals.Get(dealID)
+
+	if err != nil {
+		return nil, err
+	} else if !found {
+		return nil, xerrors.Errorf("deal %d not found", dealID)
+	}
+
+	states, err := state.States()
+	if err != nil {
+		return nil, err
+	}
+
+	st, found, err := states.Get(dealID)
+	if err != nil {
+		return nil, err
+	}
+
+	if !found {
+		st = market.EmptyDealState()
+	}
+
+	return &api.MarketDeal{
+		Proposal: *proposal,
+		State:    *st,
+	}, nil
 }
 
 func ListMinerActors(ctx context.Context, sm *StateManager, ts *types.TipSet) ([]address.Address, error) {
-	var state actors.StoragePowerState
-	if _, err := sm.LoadActorState(ctx, actors.StoragePowerAddress, &state, ts); err != nil {
-		return nil, err
-	}
-
-	cst := hamt.CSTFromBstore(sm.ChainStore().Blockstore())
-	miners, err := actors.MinerSetList(ctx, cst, state.Miners)
+	act, err := sm.LoadActor(ctx, power.Address, ts)
 	if err != nil {
-		return nil, err
+		return nil, xerrors.Errorf("failed to load power actor: %w", err)
 	}
 
-	return miners, nil
+	powState, err := power.Load(sm.cs.Store(ctx), act)
+	if err != nil {
+		return nil, xerrors.Errorf("failed to load power actor state: %w", err)
+	}
+
+	return powState.ListAllMiners()
 }
 
-func LoadSectorsFromSet(ctx context.Context, bs blockstore.Blockstore, ssc cid.Cid) ([]*api.ChainSectorInfo, error) {
-	blks := amt.WrapBlockstore(bs)
-	a, err := amt.LoadAMT(blks, ssc)
-	if err != nil {
-		return nil, err
+func ComputeState(ctx context.Context, sm *StateManager, height abi.ChainEpoch, msgs []*types.Message, ts *types.TipSet) (cid.Cid, []*api.InvocResult, error) {
+	if ts == nil {
+		ts = sm.cs.GetHeaviestTipSet()
 	}
 
-	var sset []*api.ChainSectorInfo
-	if err := a.ForEach(func(i uint64, v *cbg.Deferred) error {
-		var comms [][]byte
-		if err := cbor.DecodeInto(v.Raw, &comms); err != nil {
-			return err
+	base, trace, err := sm.ExecutionTrace(ctx, ts)
+	if err != nil {
+		return cid.Undef, nil, err
+	}
+
+	for i := ts.Height(); i < height; i++ {
+		// handle state forks
+		base, err = sm.handleStateForks(ctx, base, i, traceFunc(&trace), ts)
+		if err != nil {
+			return cid.Undef, nil, xerrors.Errorf("error handling state forks: %w", err)
 		}
-		sset = append(sset, &api.ChainSectorInfo{
-			SectorID: i,
-			CommR:    comms[0],
-			CommD:    comms[1],
-		})
-		return nil
-	}); err != nil {
+
+		// TODO: should we also run cron here?
+	}
+
+	r := store.NewChainRand(sm.cs, ts.Cids())
+	vmopt := &vm.VMOpts{
+		StateBase:      base,
+		Epoch:          height,
+		Rand:           r,
+		Bstore:         sm.cs.Blockstore(),
+		Syscalls:       sm.cs.VMSys(),
+		CircSupplyCalc: sm.GetCirculatingSupply,
+		NtwkVersion:    sm.GetNtwkVersion,
+		BaseFee:        ts.Blocks()[0].ParentBaseFee,
+	}
+	vmi, err := vm.NewVM(ctx, vmopt)
+	if err != nil {
+		return cid.Undef, nil, err
+	}
+
+	for i, msg := range msgs {
+		// TODO: Use the signed message length for secp messages
+		ret, err := vmi.ApplyMessage(ctx, msg)
+		if err != nil {
+			return cid.Undef, nil, xerrors.Errorf("applying message %s: %w", msg.Cid(), err)
+		}
+		if ret.ExitCode != 0 {
+			log.Infof("compute state apply message %d failed (exit: %d): %s", i, ret.ExitCode, ret.ActorErr)
+		}
+	}
+
+	root, err := vmi.Flush(ctx)
+	if err != nil {
+		return cid.Undef, nil, err
+	}
+
+	return root, trace, nil
+}
+
+func GetLookbackTipSetForRound(ctx context.Context, sm *StateManager, ts *types.TipSet, round abi.ChainEpoch) (*types.TipSet, error) {
+	var lbr abi.ChainEpoch
+	if round > build.WinningPoStSectorSetLookback {
+		lbr = round - build.WinningPoStSectorSetLookback
+	}
+
+	// more null blocks than our lookback
+	if lbr > ts.Height() {
+		return ts, nil
+	}
+
+	lbts, err := sm.ChainStore().GetTipsetByHeight(ctx, lbr, ts, true)
+	if err != nil {
+		return nil, xerrors.Errorf("failed to get lookback tipset: %w", err)
+	}
+
+	return lbts, nil
+}
+
+func MinerGetBaseInfo(ctx context.Context, sm *StateManager, bcs beacon.Schedule, tsk types.TipSetKey, round abi.ChainEpoch, maddr address.Address, pv ffiwrapper.Verifier) (*api.MiningBaseInfo, error) {
+	ts, err := sm.ChainStore().LoadTipSet(tsk)
+	if err != nil {
+		return nil, xerrors.Errorf("failed to load tipset for mining base: %w", err)
+	}
+
+	prev, err := sm.ChainStore().GetLatestBeaconEntry(ts)
+	if err != nil {
+		if os.Getenv("LOTUS_IGNORE_DRAND") != "_yes_" {
+			return nil, xerrors.Errorf("failed to get latest beacon entry: %w", err)
+		}
+
+		prev = &types.BeaconEntry{}
+	}
+
+	entries, err := beacon.BeaconEntriesForBlock(ctx, bcs, round, ts.Height(), *prev)
+	if err != nil {
 		return nil, err
 	}
 
-	return sset, nil
+	rbase := *prev
+	if len(entries) > 0 {
+		rbase = entries[len(entries)-1]
+	}
+
+	lbts, err := GetLookbackTipSetForRound(ctx, sm, ts, round)
+	if err != nil {
+		return nil, xerrors.Errorf("getting lookback miner actor state: %w", err)
+	}
+
+	lbst, _, err := sm.TipSetState(ctx, lbts)
+	if err != nil {
+		return nil, err
+	}
+
+	act, err := sm.LoadActorRaw(ctx, maddr, lbst)
+	if err != nil {
+		return nil, xerrors.Errorf("failed to load miner actor: %w", err)
+	}
+
+	mas, err := miner.Load(sm.cs.Store(ctx), act)
+	if err != nil {
+		return nil, xerrors.Errorf("failed to load miner actor state: %w", err)
+	}
+
+	buf := new(bytes.Buffer)
+	if err := maddr.MarshalCBOR(buf); err != nil {
+		return nil, xerrors.Errorf("failed to marshal miner address: %w", err)
+	}
+
+	prand, err := store.DrawRandomness(rbase.Data, crypto.DomainSeparationTag_WinningPoStChallengeSeed, round, buf.Bytes())
+	if err != nil {
+		return nil, xerrors.Errorf("failed to get randomness for winning post: %w", err)
+	}
+
+	sectors, err := GetSectorsForWinningPoSt(ctx, pv, sm, lbst, maddr, prand)
+	if err != nil {
+		return nil, xerrors.Errorf("getting winning post proving set: %w", err)
+	}
+
+	if len(sectors) == 0 {
+		return nil, nil
+	}
+
+	mpow, tpow, hmp, err := GetPowerRaw(ctx, sm, lbst, maddr)
+	if err != nil {
+		return nil, xerrors.Errorf("failed to get power: %w", err)
+	}
+
+	info, err := mas.Info()
+	if err != nil {
+		return nil, err
+	}
+
+	worker, err := sm.ResolveToKeyAddress(ctx, info.Worker, ts)
+	if err != nil {
+		return nil, xerrors.Errorf("resolving worker address: %w", err)
+	}
+
+	return &api.MiningBaseInfo{
+		MinerPower:      mpow.QualityAdjPower,
+		NetworkPower:    tpow.QualityAdjPower,
+		Sectors:         sectors,
+		WorkerKey:       worker,
+		SectorSize:      info.SectorSize,
+		PrevBeaconEntry: *prev,
+		BeaconEntries:   entries,
+		HasMinPower:     hmp,
+	}, nil
+}
+
+type MethodMeta struct {
+	Name string
+
+	Params reflect.Type
+	Ret    reflect.Type
+}
+
+var MethodsMap = map[cid.Cid]map[abi.MethodNum]MethodMeta{}
+
+func init() {
+	cidToMethods := map[cid.Cid][2]interface{}{
+		// builtin.SystemActorCodeID:        {builtin.MethodsSystem, system.Actor{} }- apparently it doesn't have methods
+		builtin0.InitActorCodeID:             {builtin0.MethodsInit, init0.Actor{}},
+		builtin0.CronActorCodeID:             {builtin0.MethodsCron, cron0.Actor{}},
+		builtin0.AccountActorCodeID:          {builtin0.MethodsAccount, account0.Actor{}},
+		builtin0.StoragePowerActorCodeID:     {builtin0.MethodsPower, power0.Actor{}},
+		builtin0.StorageMinerActorCodeID:     {builtin0.MethodsMiner, miner0.Actor{}},
+		builtin0.StorageMarketActorCodeID:    {builtin0.MethodsMarket, market0.Actor{}},
+		builtin0.PaymentChannelActorCodeID:   {builtin0.MethodsPaych, paych0.Actor{}},
+		builtin0.MultisigActorCodeID:         {builtin0.MethodsMultisig, msig0.Actor{}},
+		builtin0.RewardActorCodeID:           {builtin0.MethodsReward, reward0.Actor{}},
+		builtin0.VerifiedRegistryActorCodeID: {builtin0.MethodsVerifiedRegistry, verifreg0.Actor{}},
+	}
+
+	for c, m := range cidToMethods {
+		exports := m[1].(vm.Invokee).Exports()
+		methods := make(map[abi.MethodNum]MethodMeta, len(exports))
+
+		// Explicitly add send, it's special.
+		methods[builtin0.MethodSend] = MethodMeta{
+			Name:   "Send",
+			Params: reflect.TypeOf(new(abi.EmptyValue)),
+			Ret:    reflect.TypeOf(new(abi.EmptyValue)),
+		}
+
+		// Learn method names from the builtin.Methods* structs.
+		rv := reflect.ValueOf(m[0])
+		rt := rv.Type()
+		nf := rt.NumField()
+		methodToName := make([]string, len(exports))
+		for i := 0; i < nf; i++ {
+			name := rt.Field(i).Name
+			number := rv.Field(i).Interface().(abi.MethodNum)
+			methodToName[number] = name
+		}
+
+		// Iterate over exported methods. Some of these _may_ be nil and
+		// must be skipped.
+		for number, export := range exports {
+			if export == nil {
+				continue
+			}
+
+			ev := reflect.ValueOf(export)
+			et := ev.Type()
+
+			// Make sure the method name is correct.
+			// This is just a nice sanity check.
+			fnName := runtime.FuncForPC(ev.Pointer()).Name()
+			fnName = strings.TrimSuffix(fnName[strings.LastIndexByte(fnName, '.')+1:], "-fm")
+			mName := methodToName[number]
+			if mName != fnName {
+				panic(fmt.Sprintf(
+					"actor method name is %s but exported method name is %s",
+					fnName, mName,
+				))
+			}
+
+			switch abi.MethodNum(number) {
+			case builtin0.MethodSend:
+				panic("method 0 is reserved for Send")
+			case builtin0.MethodConstructor:
+				if fnName != "Constructor" {
+					panic("method 1 is reserved for Constructor")
+				}
+			}
+
+			methods[abi.MethodNum(number)] = MethodMeta{
+				Name:   fnName,
+				Params: et.In(1),
+				Ret:    et.Out(0),
+			}
+		}
+		MethodsMap[c] = methods
+	}
+}
+
+func GetReturnType(ctx context.Context, sm *StateManager, to address.Address, method abi.MethodNum, ts *types.TipSet) (cbg.CBORUnmarshaler, error) {
+	act, err := sm.LoadActor(ctx, to, ts)
+	if err != nil {
+		return nil, xerrors.Errorf("(get sset) failed to load miner actor: %w", err)
+	}
+
+	m, found := MethodsMap[act.Code][method]
+	if !found {
+		return nil, fmt.Errorf("unknown method %d for actor %s", method, act.Code)
+	}
+	return reflect.New(m.Ret.Elem()).Interface().(cbg.CBORUnmarshaler), nil
+}
+
+func MinerHasMinPower(ctx context.Context, sm *StateManager, addr address.Address, ts *types.TipSet) (bool, error) {
+	pact, err := sm.LoadActor(ctx, power.Address, ts)
+	if err != nil {
+		return false, xerrors.Errorf("loading power actor state: %w", err)
+	}
+
+	ps, err := power.Load(sm.cs.Store(ctx), pact)
+	if err != nil {
+		return false, err
+	}
+
+	return ps.MinerNominalPowerMeetsConsensusMinimum(addr)
+}
+
+func CheckTotalFIL(ctx context.Context, sm *StateManager, ts *types.TipSet) (abi.TokenAmount, error) {
+	str, err := state.LoadStateTree(sm.ChainStore().Store(ctx), ts.ParentState())
+	if err != nil {
+		return abi.TokenAmount{}, err
+	}
+
+	sum := types.NewInt(0)
+	err = str.ForEach(func(a address.Address, act *types.Actor) error {
+		sum = types.BigAdd(sum, act.Balance)
+		return nil
+	})
+	if err != nil {
+		return abi.TokenAmount{}, err
+	}
+
+	return sum, nil
 }
diff --git a/chain/store/basefee.go b/chain/store/basefee.go
new file mode 100644
index 000000000..45785240e
--- /dev/null
+++ b/chain/store/basefee.go
@@ -0,0 +1,83 @@
+package store
+
+import (
+	"context"
+
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/big"
+	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/ipfs/go-cid"
+	"golang.org/x/xerrors"
+)
+
+func ComputeNextBaseFee(baseFee types.BigInt, gasLimitUsed int64, noOfBlocks int, epoch abi.ChainEpoch) types.BigInt {
+	// deta := gasLimitUsed/noOfBlocks - build.BlockGasTarget
+	// change := baseFee * deta / BlockGasTarget
+	// nextBaseFee = baseFee + change
+	// nextBaseFee = max(nextBaseFee, build.MinimumBaseFee)
+
+	var delta int64
+	if epoch > build.UpgradeSmokeHeight {
+		delta = gasLimitUsed / int64(noOfBlocks)
+		delta -= build.BlockGasTarget
+	} else {
+		delta = build.PackingEfficiencyDenom * gasLimitUsed / (int64(noOfBlocks) * build.PackingEfficiencyNum)
+		delta -= build.BlockGasTarget
+	}
+
+	// cap change at 12.5% (BaseFeeMaxChangeDenom) by capping delta
+	if delta > build.BlockGasTarget {
+		delta = build.BlockGasTarget
+	}
+	if delta < -build.BlockGasTarget {
+		delta = -build.BlockGasTarget
+	}
+
+	change := big.Mul(baseFee, big.NewInt(delta))
+	change = big.Div(change, big.NewInt(build.BlockGasTarget))
+	change = big.Div(change, big.NewInt(build.BaseFeeMaxChangeDenom))
+
+	nextBaseFee := big.Add(baseFee, change)
+	if big.Cmp(nextBaseFee, big.NewInt(build.MinimumBaseFee)) < 0 {
+		nextBaseFee = big.NewInt(build.MinimumBaseFee)
+	}
+	return nextBaseFee
+}
+
+func (cs *ChainStore) ComputeBaseFee(ctx context.Context, ts *types.TipSet) (abi.TokenAmount, error) {
+	if ts.Height() > build.UpgradeBreezeHeight && ts.Height() < build.UpgradeBreezeHeight+build.BreezeGasTampingDuration {
+		return abi.NewTokenAmount(100), nil
+	}
+
+	zero := abi.NewTokenAmount(0)
+
+	// totalLimit is sum of GasLimits of unique messages in a tipset
+	totalLimit := int64(0)
+
+	seen := make(map[cid.Cid]struct{})
+
+	for _, b := range ts.Blocks() {
+		msg1, msg2, err := cs.MessagesForBlock(b)
+		if err != nil {
+			return zero, xerrors.Errorf("error getting messages for: %s: %w", b.Cid(), err)
+		}
+		for _, m := range msg1 {
+			c := m.Cid()
+			if _, ok := seen[c]; !ok {
+				totalLimit += m.GasLimit
+				seen[c] = struct{}{}
+			}
+		}
+		for _, m := range msg2 {
+			c := m.Cid()
+			if _, ok := seen[c]; !ok {
+				totalLimit += m.Message.GasLimit
+				seen[c] = struct{}{}
+			}
+		}
+	}
+	parentBaseFee := ts.Blocks()[0].ParentBaseFee
+
+	return ComputeNextBaseFee(parentBaseFee, totalLimit, len(ts.Blocks()), ts.Height()), nil
+}
diff --git a/chain/store/basefee_test.go b/chain/store/basefee_test.go
new file mode 100644
index 000000000..b4757f70e
--- /dev/null
+++ b/chain/store/basefee_test.go
@@ -0,0 +1,34 @@
+package store
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestBaseFee(t *testing.T) {
+	tests := []struct {
+		basefee    uint64
+		limitUsed  int64
+		noOfBlocks int
+		output     uint64
+	}{
+		{100e6, 0, 1, 87.5e6},
+		{100e6, 0, 5, 87.5e6},
+		{100e6, build.BlockGasTarget, 1, 103.125e6},
+		{100e6, build.BlockGasTarget * 2, 2, 103.125e6},
+		{100e6, build.BlockGasLimit * 2, 2, 112.5e6},
+		{100e6, build.BlockGasLimit * 1.5, 2, 110937500},
+	}
+
+	for _, test := range tests {
+		test := test
+		t.Run(fmt.Sprintf("%v", test), func(t *testing.T) {
+			output := ComputeNextBaseFee(types.NewInt(test.basefee), test.limitUsed, test.noOfBlocks, 0)
+			assert.Equal(t, fmt.Sprintf("%d", test.output), output.String())
+		})
+	}
+}
diff --git a/chain/store/fts.go b/chain/store/fts.go
index f9ec4459e..0324938d7 100644
--- a/chain/store/fts.go
+++ b/chain/store/fts.go
@@ -32,8 +32,11 @@ func (fts *FullTipSet) Cids() []cid.Cid {
 	return cids
 }
 
+// TipSet returns a narrower view of this FullTipSet elliding the block
+// messages.
 func (fts *FullTipSet) TipSet() *types.TipSet {
 	if fts.tipset != nil {
+		// FIXME: fts.tipset is actually never set. Should it memoize?
 		return fts.tipset
 	}
 
diff --git a/chain/store/index.go b/chain/store/index.go
new file mode 100644
index 000000000..a9da994af
--- /dev/null
+++ b/chain/store/index.go
@@ -0,0 +1,176 @@
+package store
+
+import (
+	"context"
+	"os"
+	"strconv"
+
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/lotus/chain/types"
+	lru "github.com/hashicorp/golang-lru"
+	"golang.org/x/xerrors"
+)
+
+var DefaultChainIndexCacheSize = 32 << 10
+
+func init() {
+	if s := os.Getenv("LOTUS_CHAIN_INDEX_CACHE"); s != "" {
+		lcic, err := strconv.Atoi(s)
+		if err != nil {
+			log.Errorf("failed to parse 'LOTUS_CHAIN_INDEX_CACHE' env var: %s", err)
+		}
+		DefaultChainIndexCacheSize = lcic
+	}
+
+}
+
+type ChainIndex struct {
+	skipCache *lru.ARCCache
+
+	loadTipSet loadTipSetFunc
+
+	skipLength abi.ChainEpoch
+}
+type loadTipSetFunc func(types.TipSetKey) (*types.TipSet, error)
+
+func NewChainIndex(lts loadTipSetFunc) *ChainIndex {
+	sc, _ := lru.NewARC(DefaultChainIndexCacheSize)
+	return &ChainIndex{
+		skipCache:  sc,
+		loadTipSet: lts,
+		skipLength: 20,
+	}
+}
+
+type lbEntry struct {
+	ts           *types.TipSet
+	parentHeight abi.ChainEpoch
+	targetHeight abi.ChainEpoch
+	target       types.TipSetKey
+}
+
+func (ci *ChainIndex) GetTipsetByHeight(_ context.Context, from *types.TipSet, to abi.ChainEpoch) (*types.TipSet, error) {
+	if from.Height()-to <= ci.skipLength {
+		return ci.walkBack(from, to)
+	}
+
+	rounded, err := ci.roundDown(from)
+	if err != nil {
+		return nil, err
+	}
+
+	cur := rounded.Key()
+	for {
+		cval, ok := ci.skipCache.Get(cur)
+		if !ok {
+			fc, err := ci.fillCache(cur)
+			if err != nil {
+				return nil, err
+			}
+			cval = fc
+		}
+
+		lbe := cval.(*lbEntry)
+		if lbe.ts.Height() == to || lbe.parentHeight < to {
+			return lbe.ts, nil
+		} else if to > lbe.targetHeight {
+			return ci.walkBack(lbe.ts, to)
+		}
+
+		cur = lbe.target
+	}
+}
+
+func (ci *ChainIndex) GetTipsetByHeightWithoutCache(from *types.TipSet, to abi.ChainEpoch) (*types.TipSet, error) {
+	return ci.walkBack(from, to)
+}
+
+func (ci *ChainIndex) fillCache(tsk types.TipSetKey) (*lbEntry, error) {
+	ts, err := ci.loadTipSet(tsk)
+	if err != nil {
+		return nil, err
+	}
+
+	if ts.Height() == 0 {
+		return &lbEntry{
+			ts:           ts,
+			parentHeight: 0,
+		}, nil
+	}
+
+	// will either be equal to ts.Height, or at least > ts.Parent.Height()
+	rheight := ci.roundHeight(ts.Height())
+
+	parent, err := ci.loadTipSet(ts.Parents())
+	if err != nil {
+		return nil, err
+	}
+
+	rheight -= ci.skipLength
+
+	var skipTarget *types.TipSet
+	if parent.Height() < rheight {
+		skipTarget = parent
+	} else {
+		skipTarget, err = ci.walkBack(parent, rheight)
+		if err != nil {
+			return nil, xerrors.Errorf("fillCache walkback: %w", err)
+		}
+	}
+
+	lbe := &lbEntry{
+		ts:           ts,
+		parentHeight: parent.Height(),
+		targetHeight: skipTarget.Height(),
+		target:       skipTarget.Key(),
+	}
+	ci.skipCache.Add(tsk, lbe)
+
+	return lbe, nil
+}
+
+// floors to nearest skipLength multiple
+func (ci *ChainIndex) roundHeight(h abi.ChainEpoch) abi.ChainEpoch {
+	return (h / ci.skipLength) * ci.skipLength
+}
+
+func (ci *ChainIndex) roundDown(ts *types.TipSet) (*types.TipSet, error) {
+	target := ci.roundHeight(ts.Height())
+
+	rounded, err := ci.walkBack(ts, target)
+	if err != nil {
+		return nil, err
+	}
+
+	return rounded, nil
+}
+
+func (ci *ChainIndex) walkBack(from *types.TipSet, to abi.ChainEpoch) (*types.TipSet, error) {
+	if to > from.Height() {
+		return nil, xerrors.Errorf("looking for tipset with height greater than start point")
+	}
+
+	if to == from.Height() {
+		return from, nil
+	}
+
+	ts := from
+
+	for {
+		pts, err := ci.loadTipSet(ts.Parents())
+		if err != nil {
+			return nil, err
+		}
+
+		if to > pts.Height() {
+			// in case pts is lower than the epoch we're looking for (null blocks)
+			// return a tipset above that height
+			return ts, nil
+		}
+		if to == pts.Height() {
+			return pts, nil
+		}
+
+		ts = pts
+	}
+}
diff --git a/chain/store/index_test.go b/chain/store/index_test.go
new file mode 100644
index 000000000..63e08070c
--- /dev/null
+++ b/chain/store/index_test.go
@@ -0,0 +1,80 @@
+package store_test
+
+import (
+	"bytes"
+	"context"
+	"testing"
+
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/lotus/chain/gen"
+	"github.com/filecoin-project/lotus/chain/store"
+	"github.com/filecoin-project/lotus/chain/types/mock"
+	"github.com/filecoin-project/lotus/lib/blockstore"
+	datastore "github.com/ipfs/go-datastore"
+	syncds "github.com/ipfs/go-datastore/sync"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestIndexSeeks(t *testing.T) {
+	cg, err := gen.NewGenerator()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	gencar, err := cg.GenesisCar()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	gen := cg.Genesis()
+
+	ctx := context.TODO()
+
+	nbs := blockstore.NewTemporarySync()
+	cs := store.NewChainStore(nbs, syncds.MutexWrap(datastore.NewMapDatastore()), nil)
+
+	_, err = cs.Import(bytes.NewReader(gencar))
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	cur := mock.TipSet(gen)
+	if err := cs.PutTipSet(ctx, mock.TipSet(gen)); err != nil {
+		t.Fatal(err)
+	}
+	assert.NoError(t, cs.SetGenesis(gen))
+
+	// Put 113 blocks from genesis
+	for i := 0; i < 113; i++ {
+		nextts := mock.TipSet(mock.MkBlock(cur, 1, 1))
+
+		if err := cs.PutTipSet(ctx, nextts); err != nil {
+			t.Fatal(err)
+		}
+		cur = nextts
+	}
+
+	// Put 50 null epochs + 1 block
+	skip := mock.MkBlock(cur, 1, 1)
+	skip.Height += 50
+
+	skipts := mock.TipSet(skip)
+
+	if err := cs.PutTipSet(ctx, skipts); err != nil {
+		t.Fatal(err)
+	}
+
+	ts, err := cs.GetTipsetByHeight(ctx, skip.Height-10, skipts, false)
+	if err != nil {
+		t.Fatal(err)
+	}
+	assert.Equal(t, abi.ChainEpoch(164), ts.Height())
+
+	for i := 0; i <= 113; i++ {
+		ts3, err := cs.GetTipsetByHeight(ctx, abi.ChainEpoch(i), skipts, false)
+		if err != nil {
+			t.Fatal(err)
+		}
+		assert.Equal(t, abi.ChainEpoch(i), ts3.Height())
+	}
+}
diff --git a/chain/store/store.go b/chain/store/store.go
index d59126518..1dbf69547 100644
--- a/chain/store/store.go
+++ b/chain/store/store.go
@@ -1,29 +1,44 @@
 package store
 
 import (
+	"bytes"
 	"context"
-	"crypto/sha256"
 	"encoding/binary"
 	"encoding/json"
+	"io"
+	"os"
+	"strconv"
 	"sync"
 
+	"github.com/filecoin-project/go-state-types/crypto"
+	"github.com/minio/blake2b-simd"
+
 	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/specs-actors/actors/builtin"
+	"github.com/filecoin-project/specs-actors/actors/util/adt"
+
+	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/build"
-	"github.com/filecoin-project/lotus/chain/state"
 	"github.com/filecoin-project/lotus/chain/vm"
+	"github.com/filecoin-project/lotus/journal"
+	bstore "github.com/filecoin-project/lotus/lib/blockstore"
+	"github.com/filecoin-project/lotus/metrics"
+
+	"go.opencensus.io/stats"
 	"go.opencensus.io/trace"
 	"go.uber.org/multierr"
 
-	amt "github.com/filecoin-project/go-amt-ipld"
 	"github.com/filecoin-project/lotus/chain/types"
 
 	lru "github.com/hashicorp/golang-lru"
 	block "github.com/ipfs/go-block-format"
 	"github.com/ipfs/go-cid"
 	dstore "github.com/ipfs/go-datastore"
-	hamt "github.com/ipfs/go-hamt-ipld"
-	bstore "github.com/ipfs/go-ipfs-blockstore"
-	logging "github.com/ipfs/go-log"
+	cbor "github.com/ipfs/go-ipld-cbor"
+	logging "github.com/ipfs/go-log/v2"
+	car "github.com/ipld/go-car"
+	carutil "github.com/ipld/go-car/util"
 	cbg "github.com/whyrusleeping/cbor-gen"
 	pubsub "github.com/whyrusleeping/pubsub"
 	"golang.org/x/xerrors"
@@ -32,7 +47,55 @@ import (
 var log = logging.Logger("chainstore")
 
 var chainHeadKey = dstore.NewKey("head")
+var blockValidationCacheKeyPrefix = dstore.NewKey("blockValidation")
 
+var DefaultTipSetCacheSize = 8192
+var DefaultMsgMetaCacheSize = 2048
+
+func init() {
+	if s := os.Getenv("LOTUS_CHAIN_TIPSET_CACHE"); s != "" {
+		tscs, err := strconv.Atoi(s)
+		if err != nil {
+			log.Errorf("failed to parse 'LOTUS_CHAIN_TIPSET_CACHE' env var: %s", err)
+		}
+		DefaultTipSetCacheSize = tscs
+	}
+
+	if s := os.Getenv("LOTUS_CHAIN_MSGMETA_CACHE"); s != "" {
+		mmcs, err := strconv.Atoi(s)
+		if err != nil {
+			log.Errorf("failed to parse 'LOTUS_CHAIN_MSGMETA_CACHE' env var: %s", err)
+		}
+		DefaultMsgMetaCacheSize = mmcs
+	}
+}
+
+// ReorgNotifee represents a callback that gets called upon reorgs.
+type ReorgNotifee func(rev, app []*types.TipSet) error
+
+// Journal event types.
+const (
+	evtTypeHeadChange = iota
+)
+
+type HeadChangeEvt struct {
+	From        types.TipSetKey
+	FromHeight  abi.ChainEpoch
+	To          types.TipSetKey
+	ToHeight    abi.ChainEpoch
+	RevertCount int
+	ApplyCount  int
+}
+
+// ChainStore is the main point of access to chain data.
+//
+// Raw chain data is stored in the Blockstore, with relevant markers (genesis,
+// latest head tipset references) being tracked in the Datastore (key-value
+// store).
+//
+// To alleviate disk access, the ChainStore has two ARC caches:
+//   1. a tipset cache
+//   2. a block => messages references cache.
 type ChainStore struct {
 	bs bstore.Blockstore
 	ds dstore.Datastore
@@ -44,43 +107,56 @@ type ChainStore struct {
 	pubLk    sync.Mutex
 
 	tstLk   sync.Mutex
-	tipsets map[uint64][]cid.Cid
+	tipsets map[abi.ChainEpoch][]cid.Cid
 
-	reorgCh          chan<- reorg
-	headChangeNotifs []func(rev, app []*types.TipSet) error
+	cindex *ChainIndex
+
+	reorgCh        chan<- reorg
+	reorgNotifeeCh chan ReorgNotifee
 
 	mmCache *lru.ARCCache
 	tsCache *lru.ARCCache
+
+	vmcalls vm.SyscallBuilder
+
+	evtTypes [1]journal.EventType
 }
 
-func NewChainStore(bs bstore.Blockstore, ds dstore.Batching) *ChainStore {
-	c, _ := lru.NewARC(2048)
-	tsc, _ := lru.NewARC(4096)
+func NewChainStore(bs bstore.Blockstore, ds dstore.Batching, vmcalls vm.SyscallBuilder) *ChainStore {
+	c, _ := lru.NewARC(DefaultMsgMetaCacheSize)
+	tsc, _ := lru.NewARC(DefaultTipSetCacheSize)
 	cs := &ChainStore{
 		bs:       bs,
 		ds:       ds,
 		bestTips: pubsub.New(64),
-		tipsets:  make(map[uint64][]cid.Cid),
+		tipsets:  make(map[abi.ChainEpoch][]cid.Cid),
 		mmCache:  c,
 		tsCache:  tsc,
+		vmcalls:  vmcalls,
 	}
 
-	cs.reorgCh = cs.reorgWorker(context.TODO())
+	cs.evtTypes = [1]journal.EventType{
+		evtTypeHeadChange: journal.J.RegisterEventType("sync", "head_change"),
+	}
+
+	ci := NewChainIndex(cs.LoadTipSet)
+
+	cs.cindex = ci
 
 	hcnf := func(rev, app []*types.TipSet) error {
 		cs.pubLk.Lock()
 		defer cs.pubLk.Unlock()
 
-		notif := make([]*HeadChange, len(rev)+len(app))
+		notif := make([]*api.HeadChange, len(rev)+len(app))
 
 		for i, r := range rev {
-			notif[i] = &HeadChange{
+			notif[i] = &api.HeadChange{
 				Type: HCRevert,
 				Val:  r,
 			}
 		}
 		for i, r := range app {
-			notif[i+len(rev)] = &HeadChange{
+			notif[i+len(rev)] = &api.HeadChange{
 				Type: HCApply,
 				Val:  r,
 			}
@@ -90,7 +166,16 @@ func NewChainStore(bs bstore.Blockstore, ds dstore.Batching) *ChainStore {
 		return nil
 	}
 
-	cs.headChangeNotifs = append(cs.headChangeNotifs, hcnf)
+	hcmetric := func(rev, app []*types.TipSet) error {
+		ctx := context.Background()
+		for _, r := range app {
+			stats.Record(ctx, metrics.ChainNodeHeight.M(int64(r.Height())))
+		}
+		return nil
+	}
+
+	cs.reorgNotifeeCh = make(chan ReorgNotifee)
+	cs.reorgCh = cs.reorgWorker(context.TODO(), []ReorgNotifee{hcnf, hcmetric})
 
 	return cs
 }
@@ -139,19 +224,14 @@ const (
 	HCCurrent = "current"
 )
 
-type HeadChange struct {
-	Type string
-	Val  *types.TipSet
-}
-
-func (cs *ChainStore) SubHeadChanges(ctx context.Context) chan []*HeadChange {
+func (cs *ChainStore) SubHeadChanges(ctx context.Context) chan []*api.HeadChange {
 	cs.pubLk.Lock()
 	subch := cs.bestTips.Sub("headchange")
 	head := cs.GetHeaviestTipSet()
 	cs.pubLk.Unlock()
 
-	out := make(chan []*HeadChange, 16)
-	out <- []*HeadChange{{
+	out := make(chan []*api.HeadChange, 16)
+	out <- []*api.HeadChange{{
 		Type: HCCurrent,
 		Val:  head,
 	}}
@@ -171,7 +251,7 @@ func (cs *ChainStore) SubHeadChanges(ctx context.Context) chan []*HeadChange {
 					log.Warnf("head change sub is slow, has %d buffered entries", len(out))
 				}
 				select {
-				case out <- val.([]*HeadChange):
+				case out <- val.([]*api.HeadChange):
 				case <-ctx.Done():
 				}
 			case <-ctx.Done():
@@ -184,8 +264,24 @@ func (cs *ChainStore) SubHeadChanges(ctx context.Context) chan []*HeadChange {
 	return out
 }
 
-func (cs *ChainStore) SubscribeHeadChanges(f func(rev, app []*types.TipSet) error) {
-	cs.headChangeNotifs = append(cs.headChangeNotifs, f)
+func (cs *ChainStore) SubscribeHeadChanges(f ReorgNotifee) {
+	cs.reorgNotifeeCh <- f
+}
+
+func (cs *ChainStore) IsBlockValidated(ctx context.Context, blkid cid.Cid) (bool, error) {
+	key := blockValidationCacheKeyPrefix.Instance(blkid.String())
+
+	return cs.ds.Has(key)
+}
+
+func (cs *ChainStore) MarkBlockAsValidated(ctx context.Context, blkid cid.Cid) error {
+	key := blockValidationCacheKeyPrefix.Instance(blkid.String())
+
+	if err := cs.ds.Put(key, []byte{0}); err != nil {
+		return xerrors.Errorf("cache block validation: %w", err)
+	}
+
+	return nil
 }
 
 func (cs *ChainStore) SetGenesis(b *types.BlockHeader) error {
@@ -220,6 +316,9 @@ func (cs *ChainStore) PutTipSet(ctx context.Context, ts *types.TipSet) error {
 	return nil
 }
 
+// MaybeTakeHeavierTipSet evaluates the incoming tipset and locks it in our
+// internal state as our new head, if and only if it is heavier than the current
+// head.
 func (cs *ChainStore) MaybeTakeHeavierTipSet(ctx context.Context, ts *types.TipSet) error {
 	cs.heaviestLk.Lock()
 	defer cs.heaviestLk.Unlock()
@@ -246,13 +345,19 @@ type reorg struct {
 	new *types.TipSet
 }
 
-func (cs *ChainStore) reorgWorker(ctx context.Context) chan<- reorg {
+func (cs *ChainStore) reorgWorker(ctx context.Context, initialNotifees []ReorgNotifee) chan<- reorg {
 	out := make(chan reorg, 32)
+	notifees := make([]ReorgNotifee, len(initialNotifees))
+	copy(notifees, initialNotifees)
+
 	go func() {
 		defer log.Warn("reorgWorker quit")
 
 		for {
 			select {
+			case n := <-cs.reorgNotifeeCh:
+				notifees = append(notifees, n)
+
 			case r := <-out:
 				revert, apply, err := cs.ReorgOps(r.old, r.new)
 				if err != nil {
@@ -260,13 +365,24 @@ func (cs *ChainStore) reorgWorker(ctx context.Context) chan<- reorg {
 					continue
 				}
 
+				journal.J.RecordEvent(cs.evtTypes[evtTypeHeadChange], func() interface{} {
+					return HeadChangeEvt{
+						From:        r.old.Key(),
+						FromHeight:  r.old.Height(),
+						To:          r.new.Key(),
+						ToHeight:    r.new.Height(),
+						RevertCount: len(revert),
+						ApplyCount:  len(apply),
+					}
+				})
+
 				// reverse the apply array
 				for i := len(apply)/2 - 1; i >= 0; i-- {
 					opp := len(apply) - 1 - i
 					apply[i], apply[opp] = apply[opp], apply[i]
 				}
 
-				for _, hcf := range cs.headChangeNotifs {
+				for _, hcf := range notifees {
 					if err := hcf(revert, apply); err != nil {
 						log.Error("head change func errored (BAD): ", err)
 					}
@@ -279,6 +395,9 @@ func (cs *ChainStore) reorgWorker(ctx context.Context) chan<- reorg {
 	return out
 }
 
+// takeHeaviestTipSet actually sets the incoming tipset as our head both in
+// memory and in the ChainStore. It also sends a notification to deliver to
+// ReorgNotifees.
 func (cs *ChainStore) takeHeaviestTipSet(ctx context.Context, ts *types.TipSet) error {
 	_, span := trace.StartSpan(ctx, "takeHeaviestTipSet")
 	defer span.End()
@@ -316,6 +435,7 @@ func (cs *ChainStore) SetHead(ts *types.TipSet) error {
 	return cs.takeHeaviestTipSet(context.TODO(), ts)
 }
 
+// Contains returns whether our BlockStore has all blocks in the supplied TipSet.
 func (cs *ChainStore) Contains(ts *types.TipSet) (bool, error) {
 	for _, c := range ts.Cids() {
 		has, err := cs.bs.Has(c)
@@ -330,6 +450,8 @@ func (cs *ChainStore) Contains(ts *types.TipSet) (bool, error) {
 	return true, nil
 }
 
+// GetBlock fetches a BlockHeader with the supplied CID. It returns
+// blockstore.ErrNotFound if the block was not found in the BlockStore.
 func (cs *ChainStore) GetBlock(c cid.Cid) (*types.BlockHeader, error) {
 	sb, err := cs.bs.Get(c)
 	if err != nil {
@@ -365,7 +487,7 @@ func (cs *ChainStore) LoadTipSet(tsk types.TipSetKey) (*types.TipSet, error) {
 	return ts, nil
 }
 
-// returns true if 'a' is an ancestor of 'b'
+// IsAncestorOf returns true if 'a' is an ancestor of 'b'
 func (cs *ChainStore) IsAncestorOf(a, b *types.TipSet) (bool, error) {
 	if b.Height() <= a.Height() {
 		return false, nil
@@ -373,7 +495,7 @@ func (cs *ChainStore) IsAncestorOf(a, b *types.TipSet) (bool, error) {
 
 	cur := b
 	for !a.Equals(cur) && cur.Height() > a.Height() {
-		next, err := cs.LoadTipSet(b.Parents())
+		next, err := cs.LoadTipSet(cur.Parents())
 		if err != nil {
 			return false, err
 		}
@@ -394,6 +516,10 @@ func (cs *ChainStore) NearestCommonAncestor(a, b *types.TipSet) (*types.TipSet,
 }
 
 func (cs *ChainStore) ReorgOps(a, b *types.TipSet) ([]*types.TipSet, []*types.TipSet, error) {
+	return ReorgOps(cs.LoadTipSet, a, b)
+}
+
+func ReorgOps(lts func(types.TipSetKey) (*types.TipSet, error), a, b *types.TipSet) ([]*types.TipSet, []*types.TipSet, error) {
 	left := a
 	right := b
 
@@ -401,7 +527,7 @@ func (cs *ChainStore) ReorgOps(a, b *types.TipSet) ([]*types.TipSet, []*types.Ti
 	for !left.Equals(right) {
 		if left.Height() > right.Height() {
 			leftChain = append(leftChain, left)
-			par, err := cs.LoadTipSet(left.Parents())
+			par, err := lts(left.Parents())
 			if err != nil {
 				return nil, nil, err
 			}
@@ -409,7 +535,7 @@ func (cs *ChainStore) ReorgOps(a, b *types.TipSet) ([]*types.TipSet, []*types.Ti
 			left = par
 		} else {
 			rightChain = append(rightChain, right)
-			par, err := cs.LoadTipSet(right.Parents())
+			par, err := lts(right.Parents())
 			if err != nil {
 				log.Infof("failed to fetch right.Parents: %s", err)
 				return nil, nil, err
@@ -420,8 +546,10 @@ func (cs *ChainStore) ReorgOps(a, b *types.TipSet) ([]*types.TipSet, []*types.Ti
 	}
 
 	return leftChain, rightChain, nil
+
 }
 
+// GetHeaviestTipSet returns the current heaviest tipset known (i.e. our head).
 func (cs *ChainStore) GetHeaviestTipSet() *types.TipSet {
 	cs.heaviestLk.Lock()
 	defer cs.heaviestLk.Unlock()
@@ -572,13 +700,13 @@ func (cs *ChainStore) GetGenesis() (*types.BlockHeader, error) {
 	return types.DecodeBlock(genb.RawData())
 }
 
-func (cs *ChainStore) GetCMessage(c cid.Cid) (ChainMsg, error) {
+func (cs *ChainStore) GetCMessage(c cid.Cid) (types.ChainMsg, error) {
 	m, err := cs.GetMessage(c)
 	if err == nil {
 		return m, nil
 	}
 	if err != bstore.ErrNotFound {
-		log.Warn("GetCMessage: unexpected error getting unsigned message: %s", err)
+		log.Warnf("GetCMessage: unexpected error getting unsigned message: %s", err)
 	}
 
 	return cs.GetSignedMessage(c)
@@ -605,86 +733,113 @@ func (cs *ChainStore) GetSignedMessage(c cid.Cid) (*types.SignedMessage, error)
 }
 
 func (cs *ChainStore) readAMTCids(root cid.Cid) ([]cid.Cid, error) {
-	bs := amt.WrapBlockstore(cs.bs)
-	a, err := amt.LoadAMT(bs, root)
+	ctx := context.TODO()
+	a, err := adt.AsArray(cs.Store(ctx), root)
 	if err != nil {
 		return nil, xerrors.Errorf("amt load: %w", err)
 	}
 
-	var cids []cid.Cid
-	for i := uint64(0); i < a.Count; i++ {
-		var c cbg.CborCid
-		if err := a.Get(i, &c); err != nil {
-			return nil, xerrors.Errorf("failed to load cid from amt: %w", err)
-		}
+	var (
+		cids    []cid.Cid
+		cborCid cbg.CborCid
+	)
+	if err := a.ForEach(&cborCid, func(i int64) error {
+		c := cid.Cid(cborCid)
+		cids = append(cids, c)
+		return nil
+	}); err != nil {
+		return nil, xerrors.Errorf("failed to traverse amt: %w", err)
+	}
 
-		cids = append(cids, cid.Cid(c))
+	if uint64(len(cids)) != a.Length() {
+		return nil, xerrors.Errorf("found %d cids, expected %d", len(cids), a.Length())
 	}
 
 	return cids, nil
 }
 
-type ChainMsg interface {
-	Cid() cid.Cid
-	VMMessage() *types.Message
-	ToStorageBlock() (block.Block, error)
+type BlockMessages struct {
+	Miner         address.Address
+	BlsMessages   []types.ChainMsg
+	SecpkMessages []types.ChainMsg
+	WinCount      int64
 }
 
-func (cs *ChainStore) MessagesForTipset(ts *types.TipSet) ([]ChainMsg, error) {
+func (cs *ChainStore) BlockMsgsForTipset(ts *types.TipSet) ([]BlockMessages, error) {
 	applied := make(map[address.Address]uint64)
-	balances := make(map[address.Address]types.BigInt)
 
-	cst := hamt.CSTFromBstore(cs.bs)
-	st, err := state.LoadStateTree(cst, ts.Blocks()[0].ParentStateRoot)
-	if err != nil {
-		return nil, xerrors.Errorf("failed to load state tree")
-	}
-
-	preloadAddr := func(a address.Address) error {
-		if _, ok := applied[a]; !ok {
-			act, err := st.GetActor(a)
-			if err != nil {
-				return err
-			}
-
-			applied[a] = act.Nonce
-			balances[a] = act.Balance
+	selectMsg := func(m *types.Message) (bool, error) {
+		// The first match for a sender is guaranteed to have correct nonce -- the block isn't valid otherwise
+		if _, ok := applied[m.From]; !ok {
+			applied[m.From] = m.Nonce
 		}
-		return nil
+
+		if applied[m.From] != m.Nonce {
+			return false, nil
+		}
+
+		applied[m.From]++
+
+		return true, nil
 	}
 
-	var out []ChainMsg
+	var out []BlockMessages
 	for _, b := range ts.Blocks() {
+
 		bms, sms, err := cs.MessagesForBlock(b)
 		if err != nil {
 			return nil, xerrors.Errorf("failed to get messages for block: %w", err)
 		}
 
-		cmsgs := make([]ChainMsg, 0, len(bms)+len(sms))
-		for _, m := range bms {
-			cmsgs = append(cmsgs, m)
-		}
-		for _, sm := range sms {
-			cmsgs = append(cmsgs, sm)
+		bm := BlockMessages{
+			Miner:         b.Miner,
+			BlsMessages:   make([]types.ChainMsg, 0, len(bms)),
+			SecpkMessages: make([]types.ChainMsg, 0, len(sms)),
+			WinCount:      b.ElectionProof.WinCount,
 		}
 
-		for _, cm := range cmsgs {
-			m := cm.VMMessage()
-			if err := preloadAddr(m.From); err != nil {
-				return nil, err
+		for _, bmsg := range bms {
+			b, err := selectMsg(bmsg.VMMessage())
+			if err != nil {
+				return nil, xerrors.Errorf("failed to decide whether to select message for block: %w", err)
 			}
 
-			if applied[m.From] != m.Nonce {
-				continue
+			if b {
+				bm.BlsMessages = append(bm.BlsMessages, bmsg)
 			}
-			applied[m.From]++
+		}
 
-			if balances[m.From].LessThan(m.RequiredFunds()) {
-				continue
+		for _, smsg := range sms {
+			b, err := selectMsg(smsg.VMMessage())
+			if err != nil {
+				return nil, xerrors.Errorf("failed to decide whether to select message for block: %w", err)
 			}
-			balances[m.From] = types.BigSub(balances[m.From], m.RequiredFunds())
 
-			out = append(out, cm)
+			if b {
+				bm.SecpkMessages = append(bm.SecpkMessages, smsg)
+			}
+		}
+
+		out = append(out, bm)
+	}
+
+	return out, nil
+}
+
+func (cs *ChainStore) MessagesForTipset(ts *types.TipSet) ([]types.ChainMsg, error) {
+	bmsgs, err := cs.BlockMsgsForTipset(ts)
+	if err != nil {
+		return nil, err
+	}
+
+	var out []types.ChainMsg
+	for _, bm := range bmsgs {
+		for _, blsm := range bm.BlsMessages {
+			out = append(out, blsm)
+		}
+
+		for _, secm := range bm.SecpkMessages {
+			out = append(out, secm)
 		}
 	}
 
@@ -696,17 +851,17 @@ type mmCids struct {
 	secpk []cid.Cid
 }
 
-func (cs *ChainStore) readMsgMetaCids(mmc cid.Cid) ([]cid.Cid, []cid.Cid, error) {
+func (cs *ChainStore) ReadMsgMetaCids(mmc cid.Cid) ([]cid.Cid, []cid.Cid, error) {
 	o, ok := cs.mmCache.Get(mmc)
 	if ok {
 		mmcids := o.(*mmCids)
 		return mmcids.bls, mmcids.secpk, nil
 	}
 
-	cst := hamt.CSTFromBstore(cs.bs)
+	cst := cbor.NewCborStore(cs.bs)
 	var msgmeta types.MsgMeta
 	if err := cst.Get(context.TODO(), mmc, &msgmeta); err != nil {
-		return nil, nil, xerrors.Errorf("failed to load msgmeta: %w", err)
+		return nil, nil, xerrors.Errorf("failed to load msgmeta (%s): %w", mmc, err)
 	}
 
 	blscids, err := cs.readAMTCids(msgmeta.BlsMessages)
@@ -727,8 +882,32 @@ func (cs *ChainStore) readMsgMetaCids(mmc cid.Cid) ([]cid.Cid, []cid.Cid, error)
 	return blscids, secpkcids, nil
 }
 
+func (cs *ChainStore) GetPath(ctx context.Context, from types.TipSetKey, to types.TipSetKey) ([]*api.HeadChange, error) {
+	fts, err := cs.LoadTipSet(from)
+	if err != nil {
+		return nil, xerrors.Errorf("loading from tipset %s: %w", from, err)
+	}
+	tts, err := cs.LoadTipSet(to)
+	if err != nil {
+		return nil, xerrors.Errorf("loading to tipset %s: %w", to, err)
+	}
+	revert, apply, err := cs.ReorgOps(fts, tts)
+	if err != nil {
+		return nil, xerrors.Errorf("error getting tipset branches: %w", err)
+	}
+
+	path := make([]*api.HeadChange, len(revert)+len(apply))
+	for i, r := range revert {
+		path[i] = &api.HeadChange{Type: HCRevert, Val: r}
+	}
+	for j, i := 0, len(apply)-1; i >= 0; j, i = j+1, i-1 {
+		path[j+len(revert)] = &api.HeadChange{Type: HCApply, Val: apply[i]}
+	}
+	return path, nil
+}
+
 func (cs *ChainStore) MessagesForBlock(b *types.BlockHeader) ([]*types.Message, []*types.SignedMessage, error) {
-	blscids, secpkcids, err := cs.readMsgMetaCids(b.Messages)
+	blscids, secpkcids, err := cs.ReadMsgMetaCids(b.Messages)
 	if err != nil {
 		return nil, nil, err
 	}
@@ -747,15 +926,17 @@ func (cs *ChainStore) MessagesForBlock(b *types.BlockHeader) ([]*types.Message,
 }
 
 func (cs *ChainStore) GetParentReceipt(b *types.BlockHeader, i int) (*types.MessageReceipt, error) {
-	bs := amt.WrapBlockstore(cs.bs)
-	a, err := amt.LoadAMT(bs, b.ParentMessageReceipts)
+	ctx := context.TODO()
+	a, err := adt.AsArray(cs.Store(ctx), b.ParentMessageReceipts)
 	if err != nil {
 		return nil, xerrors.Errorf("amt load: %w", err)
 	}
 
 	var r types.MessageReceipt
-	if err := a.Get(uint64(i), &r); err != nil {
+	if found, err := a.Get(uint64(i), &r); err != nil {
 		return nil, err
+	} else if !found {
+		return nil, xerrors.Errorf("failed to find receipt %d", i)
 	}
 
 	return &r, nil
@@ -766,7 +947,7 @@ func (cs *ChainStore) LoadMessagesFromCids(cids []cid.Cid) ([]*types.Message, er
 	for i, c := range cids {
 		m, err := cs.GetMessage(c)
 		if err != nil {
-			return nil, xerrors.Errorf("failed to get message: (%s):%d: %w", err, c, i)
+			return nil, xerrors.Errorf("failed to get message: (%s):%d: %w", c, i, err)
 		}
 
 		msgs = append(msgs, m)
@@ -780,7 +961,7 @@ func (cs *ChainStore) LoadSignedMessagesFromCids(cids []cid.Cid) ([]*types.Signe
 	for i, c := range cids {
 		m, err := cs.GetSignedMessage(c)
 		if err != nil {
-			return nil, xerrors.Errorf("failed to get message: (%s):%d: %w", err, c, i)
+			return nil, xerrors.Errorf("failed to get message: (%s):%d: %w", c, i, err)
 		}
 
 		msgs = append(msgs, m)
@@ -793,6 +974,18 @@ func (cs *ChainStore) Blockstore() bstore.Blockstore {
 	return cs.bs
 }
 
+func ActorStore(ctx context.Context, bs bstore.Blockstore) adt.Store {
+	return adt.WrapStore(ctx, cbor.NewCborStore(bs))
+}
+
+func (cs *ChainStore) Store(ctx context.Context) adt.Store {
+	return ActorStore(ctx, cs.bs)
+}
+
+func (cs *ChainStore) VMSys() vm.SyscallBuilder {
+	return cs.vmcalls
+}
+
 func (cs *ChainStore) TryFillTipSet(ts *types.TipSet) (*FullTipSet, error) {
 	var out []*types.FullBlock
 
@@ -815,91 +1008,340 @@ func (cs *ChainStore) TryFillTipSet(ts *types.TipSet) (*FullTipSet, error) {
 	return NewFullTipSet(out), nil
 }
 
-func drawRandomness(t *types.Ticket, round int64) []byte {
-	h := sha256.New()
-	var buf [8]byte
-	binary.LittleEndian.PutUint64(buf[:], uint64(round))
-
-	h.Write(t.VRFProof)
-	h.Write(buf[:])
-
-	return h.Sum(nil)
-}
-
-func (cs *ChainStore) GetRandomness(ctx context.Context, blks []cid.Cid, round int64) ([]byte, error) {
-	_, span := trace.StartSpan(ctx, "store.GetRandomness")
-	defer span.End()
-	span.AddAttributes(trace.Int64Attribute("round", round))
-
-	for {
-		nts, err := cs.LoadTipSet(types.NewTipSetKey(blks...))
-		if err != nil {
-			return nil, err
-		}
-
-		mtb := nts.MinTicketBlock()
-
-		if int64(nts.Height()) <= round {
-			return drawRandomness(nts.MinTicketBlock().Ticket, round), nil
-		}
-
-		// special case for lookback behind genesis block
-		// TODO(spec): this is not in the spec, need to sync that
-		if mtb.Height == 0 {
-
-			// round is negative
-			thash := drawRandomness(mtb.Ticket, round*-1)
-
-			// for negative lookbacks, just use the hash of the positive tickethash value
-			h := sha256.Sum256(thash)
-			return h[:], nil
-		}
-
-		blks = mtb.Parents
+func DrawRandomness(rbase []byte, pers crypto.DomainSeparationTag, round abi.ChainEpoch, entropy []byte) ([]byte, error) {
+	h := blake2b.New256()
+	if err := binary.Write(h, binary.BigEndian, int64(pers)); err != nil {
+		return nil, xerrors.Errorf("deriving randomness: %w", err)
 	}
+	VRFDigest := blake2b.Sum256(rbase)
+	_, err := h.Write(VRFDigest[:])
+	if err != nil {
+		return nil, xerrors.Errorf("hashing VRFDigest: %w", err)
+	}
+	if err := binary.Write(h, binary.BigEndian, round); err != nil {
+		return nil, xerrors.Errorf("deriving randomness: %w", err)
+	}
+	_, err = h.Write(entropy)
+	if err != nil {
+		return nil, xerrors.Errorf("hashing entropy: %w", err)
+	}
+
+	return h.Sum(nil), nil
 }
 
-func (cs *ChainStore) GetTipsetByHeight(ctx context.Context, h uint64, ts *types.TipSet) (*types.TipSet, error) {
+func (cs *ChainStore) GetBeaconRandomness(ctx context.Context, blks []cid.Cid, pers crypto.DomainSeparationTag, round abi.ChainEpoch, entropy []byte) ([]byte, error) {
+	_, span := trace.StartSpan(ctx, "store.GetBeaconRandomness")
+	defer span.End()
+	span.AddAttributes(trace.Int64Attribute("round", int64(round)))
+
+	ts, err := cs.LoadTipSet(types.NewTipSetKey(blks...))
+	if err != nil {
+		return nil, err
+	}
+
+	if round > ts.Height() {
+		return nil, xerrors.Errorf("cannot draw randomness from the future")
+	}
+
+	searchHeight := round
+	if searchHeight < 0 {
+		searchHeight = 0
+	}
+
+	randTs, err := cs.GetTipsetByHeight(ctx, searchHeight, ts, true)
+	if err != nil {
+		return nil, err
+	}
+
+	be, err := cs.GetLatestBeaconEntry(randTs)
+	if err != nil {
+		return nil, err
+	}
+
+	// if at (or just past -- for null epochs) appropriate epoch
+	// or at genesis (works for negative epochs)
+	return DrawRandomness(be.Data, pers, round, entropy)
+}
+
+func (cs *ChainStore) GetChainRandomness(ctx context.Context, blks []cid.Cid, pers crypto.DomainSeparationTag, round abi.ChainEpoch, entropy []byte) ([]byte, error) {
+	_, span := trace.StartSpan(ctx, "store.GetChainRandomness")
+	defer span.End()
+	span.AddAttributes(trace.Int64Attribute("round", int64(round)))
+
+	ts, err := cs.LoadTipSet(types.NewTipSetKey(blks...))
+	if err != nil {
+		return nil, err
+	}
+
+	if round > ts.Height() {
+		return nil, xerrors.Errorf("cannot draw randomness from the future")
+	}
+
+	searchHeight := round
+	if searchHeight < 0 {
+		searchHeight = 0
+	}
+
+	randTs, err := cs.GetTipsetByHeight(ctx, searchHeight, ts, true)
+	if err != nil {
+		return nil, err
+	}
+
+	mtb := randTs.MinTicketBlock()
+
+	// if at (or just past -- for null epochs) appropriate epoch
+	// or at genesis (works for negative epochs)
+	return DrawRandomness(mtb.Ticket.VRFProof, pers, round, entropy)
+}
+
+// GetTipsetByHeight returns the tipset on the chain behind 'ts' at the given
+// height. In the case that the given height is a null round, the 'prev' flag
+// selects the tipset before the null round if true, and the tipset following
+// the null round if false.
+func (cs *ChainStore) GetTipsetByHeight(ctx context.Context, h abi.ChainEpoch, ts *types.TipSet, prev bool) (*types.TipSet, error) {
 	if ts == nil {
 		ts = cs.GetHeaviestTipSet()
 	}
 
 	if h > ts.Height() {
-		return nil, xerrors.Errorf("looking for tipset with height less than start point")
+		return nil, xerrors.Errorf("looking for tipset with height greater than start point")
 	}
 
-	if ts.Height()-h > build.ForkLengthThreshold {
-		log.Warnf("expensive call to GetTipsetByHeight, seeking %d levels", ts.Height()-h)
+	if h == ts.Height() {
+		return ts, nil
 	}
 
-	for {
-		pts, err := cs.LoadTipSet(ts.Parents())
+	lbts, err := cs.cindex.GetTipsetByHeight(ctx, ts, h)
+	if err != nil {
+		return nil, err
+	}
+
+	if lbts.Height() < h {
+		log.Warnf("chain index returned the wrong tipset at height %d, using slow retrieval", h)
+		lbts, err = cs.cindex.GetTipsetByHeightWithoutCache(ts, h)
 		if err != nil {
 			return nil, err
 		}
+	}
 
-		if h > pts.Height() {
-			return ts, nil
+	if lbts.Height() == h || !prev {
+		return lbts, nil
+	}
+
+	return cs.LoadTipSet(lbts.Parents())
+}
+
+func recurseLinks(bs bstore.Blockstore, walked *cid.Set, root cid.Cid, in []cid.Cid) ([]cid.Cid, error) {
+	if root.Prefix().Codec != cid.DagCBOR {
+		return in, nil
+	}
+
+	data, err := bs.Get(root)
+	if err != nil {
+		return nil, xerrors.Errorf("recurse links get (%s) failed: %w", root, err)
+	}
+
+	var rerr error
+	err = cbg.ScanForLinks(bytes.NewReader(data.RawData()), func(c cid.Cid) {
+		if rerr != nil {
+			// No error return on ScanForLinks :(
+			return
 		}
 
-		ts = pts
+		// traversed this already...
+		if !walked.Visit(c) {
+			return
+		}
+
+		in = append(in, c)
+		var err error
+		in, err = recurseLinks(bs, walked, c, in)
+		if err != nil {
+			rerr = err
+		}
+	})
+	if err != nil {
+		return nil, xerrors.Errorf("scanning for links failed: %w", err)
 	}
+
+	return in, rerr
+}
+
+func (cs *ChainStore) Export(ctx context.Context, ts *types.TipSet, inclRecentRoots abi.ChainEpoch, skipOldMsgs bool, w io.Writer) error {
+	if ts == nil {
+		ts = cs.GetHeaviestTipSet()
+	}
+
+	seen := cid.NewSet()
+	walked := cid.NewSet()
+
+	h := &car.CarHeader{
+		Roots:   ts.Cids(),
+		Version: 1,
+	}
+
+	if err := car.WriteHeader(h, w); err != nil {
+		return xerrors.Errorf("failed to write car header: %s", err)
+	}
+
+	blocksToWalk := ts.Cids()
+	currentMinHeight := ts.Height()
+
+	walkChain := func(blk cid.Cid) error {
+		if !seen.Visit(blk) {
+			return nil
+		}
+
+		data, err := cs.bs.Get(blk)
+		if err != nil {
+			return xerrors.Errorf("getting block: %w", err)
+		}
+
+		if err := carutil.LdWrite(w, blk.Bytes(), data.RawData()); err != nil {
+			return xerrors.Errorf("failed to write block to car output: %w", err)
+		}
+
+		var b types.BlockHeader
+		if err := b.UnmarshalCBOR(bytes.NewBuffer(data.RawData())); err != nil {
+			return xerrors.Errorf("unmarshaling block header (cid=%s): %w", blk, err)
+		}
+
+		if currentMinHeight > b.Height {
+			currentMinHeight = b.Height
+			if currentMinHeight%builtin.EpochsInDay == 0 {
+				log.Infow("export", "height", currentMinHeight)
+			}
+		}
+
+		var cids []cid.Cid
+		if !skipOldMsgs || b.Height > ts.Height()-inclRecentRoots {
+			mcids, err := recurseLinks(cs.bs, walked, b.Messages, []cid.Cid{b.Messages})
+			if err != nil {
+				return xerrors.Errorf("recursing messages failed: %w", err)
+			}
+			cids = mcids
+		}
+
+		if b.Height > 0 {
+			for _, p := range b.Parents {
+				blocksToWalk = append(blocksToWalk, p)
+			}
+		} else {
+			// include the genesis block
+			cids = append(cids, b.Parents...)
+		}
+
+		out := cids
+
+		if b.Height == 0 || b.Height > ts.Height()-inclRecentRoots {
+			cids, err := recurseLinks(cs.bs, walked, b.ParentStateRoot, []cid.Cid{b.ParentStateRoot})
+			if err != nil {
+				return xerrors.Errorf("recursing genesis state failed: %w", err)
+			}
+
+			out = append(out, cids...)
+		}
+
+		for _, c := range out {
+			if seen.Visit(c) {
+				if c.Prefix().Codec != cid.DagCBOR {
+					continue
+				}
+				data, err := cs.bs.Get(c)
+				if err != nil {
+					return xerrors.Errorf("writing object to car (get %s): %w", c, err)
+				}
+
+				if err := carutil.LdWrite(w, c.Bytes(), data.RawData()); err != nil {
+					return xerrors.Errorf("failed to write out car object: %w", err)
+				}
+			}
+		}
+
+		return nil
+	}
+
+	log.Infow("export started")
+	exportStart := build.Clock.Now()
+
+	for len(blocksToWalk) > 0 {
+		next := blocksToWalk[0]
+		blocksToWalk = blocksToWalk[1:]
+		if err := walkChain(next); err != nil {
+			return xerrors.Errorf("walk chain failed: %w", err)
+		}
+	}
+
+	log.Infow("export finished", "duration", build.Clock.Now().Sub(exportStart).Seconds())
+
+	return nil
+}
+
+func (cs *ChainStore) Import(r io.Reader) (*types.TipSet, error) {
+	header, err := car.LoadCar(cs.Blockstore(), r)
+	if err != nil {
+		return nil, xerrors.Errorf("loadcar failed: %w", err)
+	}
+
+	root, err := cs.LoadTipSet(types.NewTipSetKey(header.Roots...))
+	if err != nil {
+		return nil, xerrors.Errorf("failed to load root tipset from chainfile: %w", err)
+	}
+
+	return root, nil
+}
+
+func (cs *ChainStore) GetLatestBeaconEntry(ts *types.TipSet) (*types.BeaconEntry, error) {
+	cur := ts
+	for i := 0; i < 20; i++ {
+		cbe := cur.Blocks()[0].BeaconEntries
+		if len(cbe) > 0 {
+			return &cbe[len(cbe)-1], nil
+		}
+
+		if cur.Height() == 0 {
+			return nil, xerrors.Errorf("made it back to genesis block without finding beacon entry")
+		}
+
+		next, err := cs.LoadTipSet(cur.Parents())
+		if err != nil {
+			return nil, xerrors.Errorf("failed to load parents when searching back for latest beacon entry: %w", err)
+		}
+		cur = next
+	}
+
+	if os.Getenv("LOTUS_IGNORE_DRAND") == "_yes_" {
+		return &types.BeaconEntry{
+			Data: []byte{9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9},
+		}, nil
+	}
+
+	return nil, xerrors.Errorf("found NO beacon entries in the 20 latest tipsets")
 }
 
 type chainRand struct {
 	cs   *ChainStore
 	blks []cid.Cid
-	bh   uint64
 }
 
-func NewChainRand(cs *ChainStore, blks []cid.Cid, bheight uint64) vm.Rand {
+func NewChainRand(cs *ChainStore, blks []cid.Cid) vm.Rand {
 	return &chainRand{
 		cs:   cs,
 		blks: blks,
-		bh:   bheight,
 	}
 }
 
-func (cr *chainRand) GetRandomness(ctx context.Context, round int64) ([]byte, error) {
-	return cr.cs.GetRandomness(ctx, cr.blks, round)
+func (cr *chainRand) GetChainRandomness(ctx context.Context, pers crypto.DomainSeparationTag, round abi.ChainEpoch, entropy []byte) ([]byte, error) {
+	return cr.cs.GetChainRandomness(ctx, cr.blks, pers, round, entropy)
+}
+
+func (cr *chainRand) GetBeaconRandomness(ctx context.Context, pers crypto.DomainSeparationTag, round abi.ChainEpoch, entropy []byte) ([]byte, error) {
+	return cr.cs.GetBeaconRandomness(ctx, cr.blks, pers, round, entropy)
+}
+
+func (cs *ChainStore) GetTipSetFromKey(tsk types.TipSetKey) (*types.TipSet, error) {
+	if tsk.IsEmpty() {
+		return cs.GetHeaviestTipSet(), nil
+	}
+	return cs.LoadTipSet(tsk)
 }
diff --git a/chain/store/store_test.go b/chain/store/store_test.go
index 4d6d11c1b..b7adfb595 100644
--- a/chain/store/store_test.go
+++ b/chain/store/store_test.go
@@ -1,20 +1,27 @@
 package store_test
 
 import (
+	"bytes"
 	"context"
 	"testing"
 
-	"github.com/filecoin-project/lotus/build"
+	datastore "github.com/ipfs/go-datastore"
+
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/crypto"
+
+	"github.com/filecoin-project/lotus/chain/actors/policy"
 	"github.com/filecoin-project/lotus/chain/gen"
 	"github.com/filecoin-project/lotus/chain/store"
 	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/lib/blockstore"
 	"github.com/filecoin-project/lotus/node/repo"
-	blockstore "github.com/ipfs/go-ipfs-blockstore"
 )
 
 func init() {
-	build.SectorSizes = []uint64{1024}
-	build.MinimumMinerPower = 1024
+	policy.SetSupportedProofTypes(abi.RegisteredSealProof_StackedDrg2KiBV1)
+	policy.SetConsensusMinerMinPower(abi.NewStoragePower(2048))
+	policy.SetMinVerifiedDealSize(abi.NewStoragePower(256))
 }
 
 func BenchmarkGetRandomness(b *testing.B) {
@@ -43,7 +50,7 @@ func BenchmarkGetRandomness(b *testing.B) {
 		b.Fatal(err)
 	}
 
-	bds, err := lr.Datastore("/blocks")
+	bds, err := lr.Datastore("/chain")
 	if err != nil {
 		b.Fatal(err)
 	}
@@ -55,14 +62,48 @@ func BenchmarkGetRandomness(b *testing.B) {
 
 	bs := blockstore.NewBlockstore(bds)
 
-	cs := store.NewChainStore(bs, mds)
+	cs := store.NewChainStore(bs, mds, nil)
 
 	b.ResetTimer()
 
 	for i := 0; i < b.N; i++ {
-		_, err := cs.GetRandomness(context.TODO(), last.Cids(), 500)
+		_, err := cs.GetChainRandomness(context.TODO(), last.Cids(), crypto.DomainSeparationTag_SealRandomness, 500, nil)
 		if err != nil {
 			b.Fatal(err)
 		}
 	}
 }
+
+func TestChainExportImport(t *testing.T) {
+	cg, err := gen.NewGenerator()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	var last *types.TipSet
+	for i := 0; i < 100; i++ {
+		ts, err := cg.NextTipSet()
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		last = ts.TipSet.TipSet()
+	}
+
+	buf := new(bytes.Buffer)
+	if err := cg.ChainStore().Export(context.TODO(), last, 0, false, buf); err != nil {
+		t.Fatal(err)
+	}
+
+	nbs := blockstore.NewTemporary()
+	cs := store.NewChainStore(nbs, datastore.NewMapDatastore(), nil)
+
+	root, err := cs.Import(buf)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if !root.Equals(last) {
+		t.Fatal("imported chain differed from exported chain")
+	}
+}
diff --git a/chain/store/weight.go b/chain/store/weight.go
index 901356728..9100df315 100644
--- a/chain/store/weight.go
+++ b/chain/store/weight.go
@@ -4,10 +4,13 @@ import (
 	"context"
 	"math/big"
 
+	"github.com/filecoin-project/lotus/chain/actors/builtin/power"
+
+	big2 "github.com/filecoin-project/go-state-types/big"
 	"github.com/filecoin-project/lotus/build"
-	"github.com/filecoin-project/lotus/chain/actors"
+	"github.com/filecoin-project/lotus/chain/state"
 	"github.com/filecoin-project/lotus/chain/types"
-	"github.com/filecoin-project/lotus/chain/vm"
+	cbor "github.com/ipfs/go-ipld-cbor"
 	"golang.org/x/xerrors"
 )
 
@@ -17,25 +20,39 @@ func (cs *ChainStore) Weight(ctx context.Context, ts *types.TipSet) (types.BigIn
 	if ts == nil {
 		return types.NewInt(0), nil
 	}
-	// >>> w[r] <<< + wFunction(totalPowerAtTipset(ts)) * 2^8 + (wFunction(totalPowerAtTipset(ts)) * len(ts.blocks) * wRatio_num * 2^8) / (e * wRatio_den)
+	// >>> w[r] <<< + wFunction(totalPowerAtTipset(ts)) * 2^8 + (wFunction(totalPowerAtTipset(ts)) * sum(ts.blocks[].ElectionProof.WinCount) * wRatio_num * 2^8) / (e * wRatio_den)
 
-	var out = new(big.Int).Set(ts.Blocks()[0].ParentWeight.Int)
+	var out = new(big.Int).Set(ts.ParentWeight().Int)
 
-	// >>> wFunction(totalPowerAtTipset(ts)) * 2^8 <<< + (wFunction(totalPowerAtTipset(ts)) * len(ts.blocks) * wRatio_num * 2^8) / (e * wRatio_den)
+	// >>> wFunction(totalPowerAtTipset(ts)) * 2^8 <<< + (wFunction(totalPowerAtTipset(ts)) * sum(ts.blocks[].ElectionProof.WinCount) * wRatio_num * 2^8) / (e * wRatio_den)
 
-	ret, err := cs.call(ctx, &types.Message{
-		From:   actors.StoragePowerAddress,
-		To:     actors.StoragePowerAddress,
-		Method: actors.SPAMethods.GetTotalStorage,
-	}, ts)
-	if err != nil {
-		return types.EmptyInt, xerrors.Errorf("failed to get total power from chain: %w", err)
-	}
-	if ret.ExitCode != 0 {
-		return types.EmptyInt, xerrors.Errorf("failed to get total power from chain (exit code %d)", ret.ExitCode)
+	tpow := big2.Zero()
+	{
+		cst := cbor.NewCborStore(cs.Blockstore())
+		state, err := state.LoadStateTree(cst, ts.ParentState())
+		if err != nil {
+			return types.NewInt(0), xerrors.Errorf("load state tree: %w", err)
+		}
+
+		act, err := state.GetActor(power.Address)
+		if err != nil {
+			return types.NewInt(0), xerrors.Errorf("get power actor: %w", err)
+		}
+
+		powState, err := power.Load(cs.Store(ctx), act)
+		if err != nil {
+			return types.NewInt(0), xerrors.Errorf("failed to load power actor state: %w", err)
+		}
+
+		claim, err := powState.TotalPower()
+		if err != nil {
+			return types.NewInt(0), xerrors.Errorf("failed to get total power: %w", err)
+		}
+
+		tpow = claim.QualityAdjPower // TODO: REVIEW: Is this correct?
 	}
+
 	log2P := int64(0)
-	tpow := types.BigFromBytes(ret.Return)
 	if tpow.GreaterThan(zero) {
 		log2P = int64(tpow.BitLen() - 1)
 	} else {
@@ -45,51 +62,19 @@ func (cs *ChainStore) Weight(ctx context.Context, ts *types.TipSet) (types.BigIn
 
 	out.Add(out, big.NewInt(log2P<<8))
 
-	// (wFunction(totalPowerAtTipset(ts)) * len(ts.blocks) * wRatio_num * 2^8) / (e * wRatio_den)
+	// (wFunction(totalPowerAtTipset(ts)) * sum(ts.blocks[].ElectionProof.WinCount) * wRatio_num * 2^8) / (e * wRatio_den)
 
-	eWeight := big.NewInt((log2P * int64(len(ts.Blocks())) * build.WRatioNum) << 8)
-	eWeight.Div(eWeight, big.NewInt(int64(build.BlocksPerEpoch*build.WRatioDen)))
-	out.Add(out, eWeight)
+	totalJ := int64(0)
+	for _, b := range ts.Blocks() {
+		totalJ += b.ElectionProof.WinCount
+	}
+
+	eWeight := big.NewInt((log2P * build.WRatioNum))
+	eWeight = eWeight.Lsh(eWeight, 8)
+	eWeight = eWeight.Mul(eWeight, new(big.Int).SetInt64(totalJ))
+	eWeight = eWeight.Div(eWeight, big.NewInt(int64(build.BlocksPerEpoch*build.WRatioDen)))
+
+	out = out.Add(out, eWeight)
 
 	return types.BigInt{Int: out}, nil
 }
-
-// todo: dedupe with state manager
-func (cs *ChainStore) call(ctx context.Context, msg *types.Message, ts *types.TipSet) (*types.MessageReceipt, error) {
-	bstate := ts.ParentState()
-
-	r := NewChainRand(cs, ts.Cids(), ts.Height())
-
-	vmi, err := vm.NewVM(bstate, ts.Height(), r, actors.NetworkAddress, cs.bs)
-	if err != nil {
-		return nil, xerrors.Errorf("failed to set up vm: %w", err)
-	}
-
-	if msg.GasLimit == types.EmptyInt {
-		msg.GasLimit = types.NewInt(10000000000)
-	}
-	if msg.GasPrice == types.EmptyInt {
-		msg.GasPrice = types.NewInt(0)
-	}
-	if msg.Value == types.EmptyInt {
-		msg.Value = types.NewInt(0)
-	}
-
-	fromActor, err := vmi.StateTree().GetActor(msg.From)
-	if err != nil {
-		return nil, xerrors.Errorf("call raw get actor: %s", err)
-	}
-
-	msg.Nonce = fromActor.Nonce
-
-	// TODO: maybe just use the invoker directly?
-	ret, err := vmi.ApplyMessage(ctx, msg)
-	if err != nil {
-		return nil, xerrors.Errorf("apply message failed: %w", err)
-	}
-
-	if ret.ActorErr != nil {
-		log.Warnf("chain call failed: %s", ret.ActorErr)
-	}
-	return &ret.MessageReceipt, nil
-}
diff --git a/chain/sub/incoming.go b/chain/sub/incoming.go
index 79dc29b80..c6e0c8b80 100644
--- a/chain/sub/incoming.go
+++ b/chain/sub/incoming.go
@@ -2,20 +2,48 @@ package sub
 
 import (
 	"context"
+	"errors"
+	"fmt"
+	"sync"
 	"time"
 
-	logging "github.com/ipfs/go-log"
-	connmgr "github.com/libp2p/go-libp2p-core/connmgr"
-	pubsub "github.com/libp2p/go-libp2p-pubsub"
+	"golang.org/x/xerrors"
 
+	address "github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/specs-actors/actors/util/adt"
+	lru "github.com/hashicorp/golang-lru"
+	blocks "github.com/ipfs/go-block-format"
+	bserv "github.com/ipfs/go-blockservice"
+	"github.com/ipfs/go-cid"
+	cbor "github.com/ipfs/go-ipld-cbor"
+	logging "github.com/ipfs/go-log/v2"
+	connmgr "github.com/libp2p/go-libp2p-core/connmgr"
+	"github.com/libp2p/go-libp2p-core/peer"
+	pubsub "github.com/libp2p/go-libp2p-pubsub"
+	cbg "github.com/whyrusleeping/cbor-gen"
+	"go.opencensus.io/stats"
+	"go.opencensus.io/tag"
+
+	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
 	"github.com/filecoin-project/lotus/chain/messagepool"
+	"github.com/filecoin-project/lotus/chain/state"
+	"github.com/filecoin-project/lotus/chain/stmgr"
+	"github.com/filecoin-project/lotus/chain/store"
 	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/lib/blockstore"
+	"github.com/filecoin-project/lotus/lib/bufbstore"
+	"github.com/filecoin-project/lotus/lib/sigs"
+	"github.com/filecoin-project/lotus/metrics"
 )
 
 var log = logging.Logger("sub")
 
-func HandleIncomingBlocks(ctx context.Context, bsub *pubsub.Subscription, s *chain.Syncer, cmgr connmgr.ConnManager) {
+var ErrSoftFailure = errors.New("soft validation failure")
+var ErrInsufficientPower = errors.New("incoming block's miner does not have minimum power")
+
+func HandleIncomingBlocks(ctx context.Context, bsub *pubsub.Subscription, s *chain.Syncer, bserv bserv.BlockService, cmgr connmgr.ConnManager) {
 	for {
 		msg, err := bsub.Next(ctx)
 		if err != nil {
@@ -27,32 +55,32 @@ func HandleIncomingBlocks(ctx context.Context, bsub *pubsub.Subscription, s *cha
 			continue
 		}
 
-		blk, err := types.DecodeBlockMsg(msg.GetData())
-		if err != nil {
-			log.Error("got invalid block over pubsub: ", err)
-			continue
+		blk, ok := msg.ValidatorData.(*types.BlockMsg)
+		if !ok {
+			log.Warnf("pubsub block validator passed on wrong type: %#v", msg.ValidatorData)
+			return
 		}
 
+		src := msg.GetFrom()
+
 		go func() {
-			log.Infof("New block over pubsub: %s", blk.Cid())
-
-			start := time.Now()
+			start := build.Clock.Now()
 			log.Debug("about to fetch messages for block from pubsub")
-			bmsgs, err := s.Bsync.FetchMessagesByCids(context.TODO(), blk.BlsMessages)
+			bmsgs, err := FetchMessagesByCids(context.TODO(), bserv, blk.BlsMessages)
 			if err != nil {
-				log.Errorf("failed to fetch all bls messages for block received over pubusb: %s", err)
+				log.Errorf("failed to fetch all bls messages for block received over pubusb: %s; source: %s", err, src)
 				return
 			}
 
-			smsgs, err := s.Bsync.FetchSignedMessagesByCids(context.TODO(), blk.SecpkMessages)
+			smsgs, err := FetchSignedMessagesByCids(context.TODO(), bserv, blk.SecpkMessages)
 			if err != nil {
-				log.Errorf("failed to fetch all secpk messages for block received over pubusb: %s", err)
+				log.Errorf("failed to fetch all secpk messages for block received over pubusb: %s; source: %s", err, src)
 				return
 			}
 
-			took := time.Since(start)
+			took := build.Clock.Since(start)
 			log.Infow("new block over pubsub", "cid", blk.Header.Cid(), "source", msg.GetFrom(), "msgfetch", took)
-			if delay := time.Now().Unix() - int64(blk.Header.Timestamp); delay > 5 {
+			if delay := build.Clock.Now().Unix() - int64(blk.Header.Timestamp); delay > 5 {
 				log.Warnf("Received block with large delay %d from miner %s", delay, blk.Header.Miner)
 			}
 
@@ -67,9 +95,516 @@ func HandleIncomingBlocks(ctx context.Context, bsub *pubsub.Subscription, s *cha
 	}
 }
 
+func FetchMessagesByCids(
+	ctx context.Context,
+	bserv bserv.BlockService,
+	cids []cid.Cid,
+) ([]*types.Message, error) {
+	out := make([]*types.Message, len(cids))
+
+	err := fetchCids(ctx, bserv, cids, func(i int, b blocks.Block) error {
+		msg, err := types.DecodeMessage(b.RawData())
+		if err != nil {
+			return err
+		}
+
+		// FIXME: We already sort in `fetchCids`, we are duplicating too much work,
+		//  we don't need to pass the index.
+		if out[i] != nil {
+			return fmt.Errorf("received duplicate message")
+		}
+
+		out[i] = msg
+		return nil
+	})
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// FIXME: Duplicate of above.
+func FetchSignedMessagesByCids(
+	ctx context.Context,
+	bserv bserv.BlockService,
+	cids []cid.Cid,
+) ([]*types.SignedMessage, error) {
+	out := make([]*types.SignedMessage, len(cids))
+
+	err := fetchCids(ctx, bserv, cids, func(i int, b blocks.Block) error {
+		smsg, err := types.DecodeSignedMessage(b.RawData())
+		if err != nil {
+			return err
+		}
+
+		if out[i] != nil {
+			return fmt.Errorf("received duplicate message")
+		}
+
+		out[i] = smsg
+		return nil
+	})
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// Fetch `cids` from the block service, apply `cb` on each of them. Used
+//  by the fetch message functions above.
+// We check that each block is received only once and we do not received
+//  blocks we did not request.
+func fetchCids(
+	ctx context.Context,
+	bserv bserv.BlockService,
+	cids []cid.Cid,
+	cb func(int, blocks.Block) error,
+) error {
+	// FIXME: Why don't we use the context here?
+	fetchedBlocks := bserv.GetBlocks(context.TODO(), cids)
+
+	cidIndex := make(map[cid.Cid]int)
+	for i, c := range cids {
+		cidIndex[c] = i
+	}
+
+	for i := 0; i < len(cids); i++ {
+		select {
+		case block, ok := <-fetchedBlocks:
+			if !ok {
+				// Closed channel, no more blocks fetched, check if we have all
+				// of the CIDs requested.
+				// FIXME: Review this check. We don't call the callback on the
+				//  last index?
+				if i == len(cids)-1 {
+					break
+				}
+
+				return fmt.Errorf("failed to fetch all messages")
+			}
+
+			ix, ok := cidIndex[block.Cid()]
+			if !ok {
+				return fmt.Errorf("received message we didnt ask for")
+			}
+
+			if err := cb(ix, block); err != nil {
+				return err
+			}
+		}
+	}
+
+	return nil
+}
+
+type BlockValidator struct {
+	self peer.ID
+
+	peers *lru.TwoQueueCache
+
+	killThresh int
+
+	recvBlocks *blockReceiptCache
+
+	blacklist func(peer.ID)
+
+	// necessary for block validation
+	chain *store.ChainStore
+	stmgr *stmgr.StateManager
+
+	mx       sync.Mutex
+	keycache map[string]address.Address
+}
+
+func NewBlockValidator(self peer.ID, chain *store.ChainStore, stmgr *stmgr.StateManager, blacklist func(peer.ID)) *BlockValidator {
+	p, _ := lru.New2Q(4096)
+	return &BlockValidator{
+		self:       self,
+		peers:      p,
+		killThresh: 10,
+		blacklist:  blacklist,
+		recvBlocks: newBlockReceiptCache(),
+		chain:      chain,
+		stmgr:      stmgr,
+		keycache:   make(map[string]address.Address),
+	}
+}
+
+func (bv *BlockValidator) flagPeer(p peer.ID) {
+	v, ok := bv.peers.Get(p)
+	if !ok {
+		bv.peers.Add(p, int(1))
+		return
+	}
+
+	val := v.(int)
+
+	if val >= bv.killThresh {
+		log.Warnf("blacklisting peer %s", p)
+		bv.blacklist(p)
+		return
+	}
+
+	bv.peers.Add(p, v.(int)+1)
+}
+
+func (bv *BlockValidator) Validate(ctx context.Context, pid peer.ID, msg *pubsub.Message) pubsub.ValidationResult {
+	if pid == bv.self {
+		return bv.validateLocalBlock(ctx, msg)
+	}
+
+	// track validation time
+	begin := build.Clock.Now()
+	defer func() {
+		log.Debugf("block validation time: %s", build.Clock.Since(begin))
+	}()
+
+	stats.Record(ctx, metrics.BlockReceived.M(1))
+
+	recordFailureFlagPeer := func(what string) {
+		recordFailure(ctx, metrics.BlockValidationFailure, what)
+		bv.flagPeer(pid)
+	}
+
+	blk, what, err := bv.decodeAndCheckBlock(msg)
+	if err != nil {
+		log.Error("got invalid block over pubsub: ", err)
+		recordFailureFlagPeer(what)
+		return pubsub.ValidationReject
+	}
+
+	// validate the block meta: the Message CID in the header must match the included messages
+	err = bv.validateMsgMeta(ctx, blk)
+	if err != nil {
+		log.Warnf("error validating message metadata: %s", err)
+		recordFailureFlagPeer("invalid_block_meta")
+		return pubsub.ValidationReject
+	}
+
+	// we want to ensure that it is a block from a known miner; we reject blocks from unknown miners
+	// to prevent spam attacks.
+	// the logic works as follows: we lookup the miner in the chain for its key.
+	// if we can find it then it's a known miner and we can validate the signature.
+	// if we can't find it, we check whether we are (near) synced in the chain.
+	// if we are not synced we cannot validate the block and we must ignore it.
+	// if we are synced and the miner is unknown, then the block is rejcected.
+	key, err := bv.checkPowerAndGetWorkerKey(ctx, blk.Header)
+	if err != nil {
+		if err != ErrSoftFailure && bv.isChainNearSynced() {
+			log.Warnf("received block from unknown miner or miner that doesn't meet min power over pubsub; rejecting message")
+			recordFailureFlagPeer("unknown_miner")
+			return pubsub.ValidationReject
+		}
+
+		log.Warnf("cannot validate block message; unknown miner or miner that doesn't meet min power in unsynced chain")
+		return pubsub.ValidationIgnore
+	}
+
+	err = sigs.CheckBlockSignature(ctx, blk.Header, key)
+	if err != nil {
+		log.Errorf("block signature verification failed: %s", err)
+		recordFailureFlagPeer("signature_verification_failed")
+		return pubsub.ValidationReject
+	}
+
+	if blk.Header.ElectionProof.WinCount < 1 {
+		log.Errorf("block is not claiming to be winning")
+		recordFailureFlagPeer("not_winning")
+		return pubsub.ValidationReject
+	}
+
+	// it's a good block! make sure we've only seen it once
+	if bv.recvBlocks.add(blk.Header.Cid()) > 0 {
+		// TODO: once these changes propagate to the network, we can consider
+		// dropping peers who send us the same block multiple times
+		return pubsub.ValidationIgnore
+	}
+
+	// all good, accept the block
+	msg.ValidatorData = blk
+	stats.Record(ctx, metrics.BlockValidationSuccess.M(1))
+	return pubsub.ValidationAccept
+}
+
+func (bv *BlockValidator) validateLocalBlock(ctx context.Context, msg *pubsub.Message) pubsub.ValidationResult {
+	stats.Record(ctx, metrics.BlockPublished.M(1))
+
+	blk, what, err := bv.decodeAndCheckBlock(msg)
+	if err != nil {
+		log.Errorf("got invalid local block: %s", err)
+		ctx, _ = tag.New(ctx, tag.Insert(metrics.FailureType, what))
+		stats.Record(ctx, metrics.BlockValidationFailure.M(1))
+		return pubsub.ValidationIgnore
+	}
+
+	if count := bv.recvBlocks.add(blk.Header.Cid()); count > 0 {
+		log.Warnf("local block has been seen %d times; ignoring", count)
+		return pubsub.ValidationIgnore
+	}
+
+	msg.ValidatorData = blk
+	stats.Record(ctx, metrics.BlockValidationSuccess.M(1))
+	return pubsub.ValidationAccept
+}
+
+func (bv *BlockValidator) decodeAndCheckBlock(msg *pubsub.Message) (*types.BlockMsg, string, error) {
+	blk, err := types.DecodeBlockMsg(msg.GetData())
+	if err != nil {
+		return nil, "invalid", xerrors.Errorf("error decoding block: %w", err)
+	}
+
+	if count := len(blk.BlsMessages) + len(blk.SecpkMessages); count > build.BlockMessageLimit {
+		return nil, "too_many_messages", fmt.Errorf("block contains too many messages (%d)", count)
+	}
+
+	// make sure we have a signature
+	if blk.Header.BlockSig == nil {
+		return nil, "missing_signature", fmt.Errorf("block without a signature")
+	}
+
+	return blk, "", nil
+}
+
+func (bv *BlockValidator) isChainNearSynced() bool {
+	ts := bv.chain.GetHeaviestTipSet()
+	timestamp := ts.MinTimestamp()
+	timestampTime := time.Unix(int64(timestamp), 0)
+	return build.Clock.Since(timestampTime) < 6*time.Hour
+}
+
+func (bv *BlockValidator) validateMsgMeta(ctx context.Context, msg *types.BlockMsg) error {
+	// TODO there has to be a simpler way to do this without the blockstore dance
+	store := adt.WrapStore(ctx, cbor.NewCborStore(blockstore.NewTemporary()))
+	bmArr := adt.MakeEmptyArray(store)
+	smArr := adt.MakeEmptyArray(store)
+
+	for i, m := range msg.BlsMessages {
+		c := cbg.CborCid(m)
+		if err := bmArr.Set(uint64(i), &c); err != nil {
+			return err
+		}
+	}
+
+	for i, m := range msg.SecpkMessages {
+		c := cbg.CborCid(m)
+		if err := smArr.Set(uint64(i), &c); err != nil {
+			return err
+		}
+	}
+
+	bmroot, err := bmArr.Root()
+	if err != nil {
+		return err
+	}
+
+	smroot, err := smArr.Root()
+	if err != nil {
+		return err
+	}
+
+	mrcid, err := store.Put(store.Context(), &types.MsgMeta{
+		BlsMessages:   bmroot,
+		SecpkMessages: smroot,
+	})
+
+	if err != nil {
+		return err
+	}
+
+	if msg.Header.Messages != mrcid {
+		return fmt.Errorf("messages didn't match root cid in header")
+	}
+
+	return nil
+}
+
+func (bv *BlockValidator) checkPowerAndGetWorkerKey(ctx context.Context, bh *types.BlockHeader) (address.Address, error) {
+	addr := bh.Miner
+
+	bv.mx.Lock()
+	key, ok := bv.keycache[addr.String()]
+	bv.mx.Unlock()
+	if !ok {
+		// TODO I have a feeling all this can be simplified by cleverer DI to use the API
+		ts := bv.chain.GetHeaviestTipSet()
+		st, _, err := bv.stmgr.TipSetState(ctx, ts)
+		if err != nil {
+			return address.Undef, err
+		}
+
+		buf := bufbstore.NewBufferedBstore(bv.chain.Blockstore())
+		cst := cbor.NewCborStore(buf)
+		state, err := state.LoadStateTree(cst, st)
+		if err != nil {
+			return address.Undef, err
+		}
+		act, err := state.GetActor(addr)
+		if err != nil {
+			return address.Undef, err
+		}
+
+		mst, err := miner.Load(bv.chain.Store(ctx), act)
+		if err != nil {
+			return address.Undef, err
+		}
+
+		info, err := mst.Info()
+		if err != nil {
+			return address.Undef, err
+		}
+
+		worker := info.Worker
+		key, err = bv.stmgr.ResolveToKeyAddress(ctx, worker, ts)
+		if err != nil {
+			return address.Undef, err
+		}
+
+		bv.mx.Lock()
+		bv.keycache[addr.String()] = key
+		bv.mx.Unlock()
+	}
+
+	// we check that the miner met the minimum power at the lookback tipset
+
+	baseTs := bv.chain.GetHeaviestTipSet()
+	lbts, err := stmgr.GetLookbackTipSetForRound(ctx, bv.stmgr, baseTs, bh.Height)
+	if err != nil {
+		log.Warnf("failed to load lookback tipset for incoming block: %s", err)
+		return address.Undef, ErrSoftFailure
+	}
+
+	hmp, err := stmgr.MinerHasMinPower(ctx, bv.stmgr, bh.Miner, lbts)
+	if err != nil {
+		log.Warnf("failed to determine if incoming block's miner has minimum power: %s", err)
+		return address.Undef, ErrSoftFailure
+	}
+
+	if !hmp {
+		log.Warnf("incoming block's miner does not have minimum power")
+		return address.Undef, ErrInsufficientPower
+	}
+
+	return key, nil
+}
+
+type blockReceiptCache struct {
+	blocks *lru.TwoQueueCache
+}
+
+func newBlockReceiptCache() *blockReceiptCache {
+	c, _ := lru.New2Q(8192)
+
+	return &blockReceiptCache{
+		blocks: c,
+	}
+}
+
+func (brc *blockReceiptCache) add(bcid cid.Cid) int {
+	val, ok := brc.blocks.Get(bcid)
+	if !ok {
+		brc.blocks.Add(bcid, int(1))
+		return 0
+	}
+
+	brc.blocks.Add(bcid, val.(int)+1)
+	return val.(int)
+}
+
+type MessageValidator struct {
+	self  peer.ID
+	mpool *messagepool.MessagePool
+}
+
+func NewMessageValidator(self peer.ID, mp *messagepool.MessagePool) *MessageValidator {
+	return &MessageValidator{self: self, mpool: mp}
+}
+
+func (mv *MessageValidator) Validate(ctx context.Context, pid peer.ID, msg *pubsub.Message) pubsub.ValidationResult {
+	if pid == mv.self {
+		return mv.validateLocalMessage(ctx, msg)
+	}
+
+	stats.Record(ctx, metrics.MessageReceived.M(1))
+	m, err := types.DecodeSignedMessage(msg.Message.GetData())
+	if err != nil {
+		log.Warnf("failed to decode incoming message: %s", err)
+		ctx, _ = tag.New(ctx, tag.Insert(metrics.FailureType, "decode"))
+		stats.Record(ctx, metrics.MessageValidationFailure.M(1))
+		return pubsub.ValidationReject
+	}
+
+	if err := mv.mpool.Add(m); err != nil {
+		log.Debugf("failed to add message from network to message pool (From: %s, To: %s, Nonce: %d, Value: %s): %s", m.Message.From, m.Message.To, m.Message.Nonce, types.FIL(m.Message.Value), err)
+		ctx, _ = tag.New(
+			ctx,
+			tag.Upsert(metrics.Local, "false"),
+		)
+		recordFailure(ctx, metrics.MessageValidationFailure, "add")
+		switch {
+		case xerrors.Is(err, messagepool.ErrSoftValidationFailure):
+			fallthrough
+		case xerrors.Is(err, messagepool.ErrRBFTooLowPremium):
+			fallthrough
+		case xerrors.Is(err, messagepool.ErrTooManyPendingMessages):
+			fallthrough
+		case xerrors.Is(err, messagepool.ErrNonceGap):
+			fallthrough
+		case xerrors.Is(err, messagepool.ErrNonceTooLow):
+			return pubsub.ValidationIgnore
+		default:
+			return pubsub.ValidationReject
+		}
+	}
+	stats.Record(ctx, metrics.MessageValidationSuccess.M(1))
+	return pubsub.ValidationAccept
+}
+
+func (mv *MessageValidator) validateLocalMessage(ctx context.Context, msg *pubsub.Message) pubsub.ValidationResult {
+	ctx, _ = tag.New(
+		ctx,
+		tag.Upsert(metrics.Local, "true"),
+	)
+	// do some lightweight validation
+	stats.Record(ctx, metrics.MessagePublished.M(1))
+
+	m, err := types.DecodeSignedMessage(msg.Message.GetData())
+	if err != nil {
+		log.Warnf("failed to decode local message: %s", err)
+		recordFailure(ctx, metrics.MessageValidationFailure, "decode")
+		return pubsub.ValidationIgnore
+	}
+
+	if m.Size() > 32*1024 {
+		log.Warnf("local message is too large! (%dB)", m.Size())
+		recordFailure(ctx, metrics.MessageValidationFailure, "oversize")
+		return pubsub.ValidationIgnore
+	}
+
+	if m.Message.To == address.Undef {
+		log.Warn("local message has invalid destination address")
+		recordFailure(ctx, metrics.MessageValidationFailure, "undef-addr")
+		return pubsub.ValidationIgnore
+	}
+
+	if !m.Message.Value.LessThan(types.TotalFilecoinInt) {
+		log.Warnf("local messages has too high value: %s", m.Message.Value)
+		recordFailure(ctx, metrics.MessageValidationFailure, "value-too-high")
+		return pubsub.ValidationIgnore
+	}
+
+	if err := mv.mpool.VerifyMsgSig(m); err != nil {
+		log.Warnf("signature verification failed for local message: %s", err)
+		recordFailure(ctx, metrics.MessageValidationFailure, "verify-sig")
+		return pubsub.ValidationIgnore
+	}
+
+	stats.Record(ctx, metrics.MessageValidationSuccess.M(1))
+	return pubsub.ValidationAccept
+}
+
 func HandleIncomingMessages(ctx context.Context, mpool *messagepool.MessagePool, msub *pubsub.Subscription) {
 	for {
-		msg, err := msub.Next(ctx)
+		_, err := msub.Next(ctx)
 		if err != nil {
 			log.Warn("error from message subscription: ", err)
 			if ctx.Err() != nil {
@@ -79,15 +614,14 @@ func HandleIncomingMessages(ctx context.Context, mpool *messagepool.MessagePool,
 			continue
 		}
 
-		m, err := types.DecodeSignedMessage(msg.GetData())
-		if err != nil {
-			log.Errorf("got incorrectly formatted Message: %s", err)
-			continue
-		}
-
-		if err := mpool.Add(m); err != nil {
-			log.Warnf("failed to add message from network to message pool (From: %s, To: %s, Nonce: %d, Value: %s): %s", m.Message.From, m.Message.To, m.Message.Nonce, types.FIL(m.Message.Value), err)
-			continue
-		}
+		// Do nothing... everything happens in validate
 	}
 }
+
+func recordFailure(ctx context.Context, metric *stats.Int64Measure, failureType string) {
+	ctx, _ = tag.New(
+		ctx,
+		tag.Upsert(metrics.FailureType, failureType),
+	)
+	stats.Record(ctx, metric.M(1))
+}
diff --git a/chain/sync.go b/chain/sync.go
index 9065bc099..9e098a57e 100644
--- a/chain/sync.go
+++ b/chain/sync.go
@@ -3,50 +3,102 @@ package chain
 import (
 	"bytes"
 	"context"
-	"crypto/sha256"
 	"errors"
 	"fmt"
+	"os"
+	"sort"
+	"strings"
 	"sync"
 	"time"
 
+	"github.com/filecoin-project/lotus/node/modules/dtypes"
+
+	"github.com/filecoin-project/specs-actors/actors/runtime/proof"
+
 	"github.com/Gurpartap/async"
-	bls "github.com/filecoin-project/filecoin-ffi"
-	amt "github.com/filecoin-project/go-amt-ipld"
-	sectorbuilder "github.com/filecoin-project/go-sectorbuilder"
 	"github.com/hashicorp/go-multierror"
+	blocks "github.com/ipfs/go-block-format"
 	"github.com/ipfs/go-cid"
-	dstore "github.com/ipfs/go-datastore"
-	hamt "github.com/ipfs/go-hamt-ipld"
-	bstore "github.com/ipfs/go-ipfs-blockstore"
-	logging "github.com/ipfs/go-log"
+	cbor "github.com/ipfs/go-ipld-cbor"
+	logging "github.com/ipfs/go-log/v2"
 	"github.com/libp2p/go-libp2p-core/connmgr"
 	"github.com/libp2p/go-libp2p-core/peer"
 	cbg "github.com/whyrusleeping/cbor-gen"
 	"github.com/whyrusleeping/pubsub"
+	"go.opencensus.io/stats"
 	"go.opencensus.io/trace"
 	"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/crypto"
+	"github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper"
+	"github.com/filecoin-project/specs-actors/actors/util/adt"
+	blst "github.com/supranational/blst/bindings/go"
 
 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/build"
-	"github.com/filecoin-project/lotus/chain/actors"
-	"github.com/filecoin-project/lotus/chain/blocksync"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/power"
+	"github.com/filecoin-project/lotus/chain/beacon"
+	"github.com/filecoin-project/lotus/chain/exchange"
 	"github.com/filecoin-project/lotus/chain/gen"
 	"github.com/filecoin-project/lotus/chain/state"
 	"github.com/filecoin-project/lotus/chain/stmgr"
 	"github.com/filecoin-project/lotus/chain/store"
 	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/chain/vm"
+	bstore "github.com/filecoin-project/lotus/lib/blockstore"
+	"github.com/filecoin-project/lotus/lib/sigs"
+	"github.com/filecoin-project/lotus/lib/sigs/bls"
+	"github.com/filecoin-project/lotus/metrics"
 )
 
-var log = logging.Logger("chain")
+// Blocks that are more than MaxHeightDrift epochs above
+// the theoretical max height based on systime are quickly rejected
+const MaxHeightDrift = 5
 
-var LocalIncoming = "incoming"
+var (
+	// LocalIncoming is the _local_ pubsub (unrelated to libp2p pubsub) topic
+	// where the Syncer publishes candidate chain heads to be synced.
+	LocalIncoming = "incoming"
 
+	log = logging.Logger("chain")
+
+	concurrentSyncRequests = exchange.ShufflePeersPrefix
+	syncRequestBatchSize   = 8
+	syncRequestRetries     = 5
+)
+
+// Syncer is in charge of running the chain synchronization logic. As such, it
+// is tasked with these functions, amongst others:
+//
+//  * Fast-forwards the chain as it learns of new TipSets from the network via
+//    the SyncManager.
+//  * Applies the fork choice rule to select the correct side when confronted
+//    with a fork in the network.
+//  * Requests block headers and messages from other peers when not available
+//    in our BlockStore.
+//  * Tracks blocks marked as bad in a cache.
+//  * Keeps the BlockStore and ChainStore consistent with our view of the world,
+//    the latter of which in turn informs other components when a reorg has been
+//    committed.
+//
+// The Syncer does not run workers itself. It's mainly concerned with
+// ensuring a consistent state of chain consensus. The reactive and network-
+// interfacing processes are part of other components, such as the SyncManager
+// (which owns the sync scheduler and sync workers), ChainExchange, the HELLO
+// protocol, and the gossipsub block propagation layer.
+//
+// {hint/concept} The fork-choice rule as it currently stands is: "pick the
+// chain with the heaviest weight, so long as it hasn’t deviated one finality
+// threshold from our head (900 epochs, parameter determined by spec-actors)".
 type Syncer struct {
 	// The interface for accessing and putting tipsets into local storage
 	store *store.ChainStore
 
+	// handle to the random beacon for verification
+	beacon beacon.Schedule
+
 	// the state manager handles making state queries
 	sm *stmgr.StateManager
 
@@ -57,23 +109,36 @@ type Syncer struct {
 	bad *BadBlockCache
 
 	// handle to the block sync service
-	Bsync *blocksync.BlockSync
+	Exchange exchange.Client
 
 	self peer.ID
 
-	syncmgr *SyncManager
+	syncmgr SyncManager
 
 	connmgr connmgr.ConnManager
 
 	incoming *pubsub.PubSub
 
 	receiptTracker *blockReceiptTracker
+
+	verifier ffiwrapper.Verifier
+
+	tickerCtxCancel context.CancelFunc
+
+	checkptLk sync.Mutex
+
+	checkpt types.TipSetKey
+
+	ds dtypes.MetadataDS
 }
 
-func NewSyncer(sm *stmgr.StateManager, bsync *blocksync.BlockSync, connmgr connmgr.ConnManager, self peer.ID) (*Syncer, error) {
+type SyncManagerCtor func(syncFn SyncFunc) SyncManager
+
+// NewSyncer creates a new Syncer object.
+func NewSyncer(ds dtypes.MetadataDS, sm *stmgr.StateManager, exchange exchange.Client, syncMgrCtor SyncManagerCtor, connmgr connmgr.ConnManager, self peer.ID, beacon beacon.Schedule, verifier ffiwrapper.Verifier) (*Syncer, error) {
 	gen, err := sm.ChainStore().GetGenesis()
 	if err != nil {
-		return nil, err
+		return nil, xerrors.Errorf("getting genesis block: %w", err)
 	}
 
 	gent, err := types.NewTipSet([]*types.BlockHeader{gen})
@@ -81,29 +146,68 @@ func NewSyncer(sm *stmgr.StateManager, bsync *blocksync.BlockSync, connmgr connm
 		return nil, err
 	}
 
+	cp, err := loadCheckpoint(ds)
+	if err != nil {
+		return nil, xerrors.Errorf("error loading mpool config: %w", err)
+	}
+
 	s := &Syncer{
+		ds:             ds,
+		checkpt:        cp,
+		beacon:         beacon,
 		bad:            NewBadBlockCache(),
 		Genesis:        gent,
-		Bsync:          bsync,
+		Exchange:       exchange,
 		store:          sm.ChainStore(),
 		sm:             sm,
 		self:           self,
 		receiptTracker: newBlockReceiptTracker(),
 		connmgr:        connmgr,
+		verifier:       verifier,
 
 		incoming: pubsub.New(50),
 	}
 
-	s.syncmgr = NewSyncManager(s.Sync)
+	if build.InsecurePoStValidation {
+		log.Warn("*********************************************************************************************")
+		log.Warn(" [INSECURE-POST-VALIDATION] Insecure test validation is enabled. If you see this outside of a test, it is a severe bug! ")
+		log.Warn("*********************************************************************************************")
+	}
+
+	s.syncmgr = syncMgrCtor(s.Sync)
 	return s, nil
 }
 
 func (syncer *Syncer) Start() {
+	tickerCtx, tickerCtxCancel := context.WithCancel(context.Background())
 	syncer.syncmgr.Start()
+
+	syncer.tickerCtxCancel = tickerCtxCancel
+
+	go syncer.runMetricsTricker(tickerCtx)
+}
+
+func (syncer *Syncer) runMetricsTricker(tickerCtx context.Context) {
+	genesisTime := time.Unix(int64(syncer.Genesis.MinTimestamp()), 0)
+	ticker := build.Clock.Ticker(time.Duration(build.BlockDelaySecs) * time.Second)
+	defer ticker.Stop()
+
+	for {
+		select {
+		case <-ticker.C:
+			sinceGenesis := build.Clock.Now().Sub(genesisTime)
+			expectedHeight := int64(sinceGenesis.Seconds()) / int64(build.BlockDelaySecs)
+
+			stats.Record(tickerCtx, metrics.ChainNodeHeightExpected.M(expectedHeight))
+		case <-tickerCtx.Done():
+			return
+		}
+	}
 }
 
 func (syncer *Syncer) Stop() {
 	syncer.syncmgr.Stop()
+	syncer.tickerCtxCancel()
 }
 
 // InformNewHead informs the syncer about a new potential tipset
@@ -116,7 +220,16 @@ func (syncer *Syncer) InformNewHead(from peer.ID, fts *store.FullTipSet) bool {
 		return false
 	}
 
+	if syncer.IsEpochBeyondCurrMax(fts.TipSet().Height()) {
+		log.Errorf("Received block with impossibly large height %d", fts.TipSet().Height())
+		return false
+	}
+
 	for _, b := range fts.Blocks {
+		if reason, ok := syncer.bad.Has(b.Cid()); ok {
+			log.Warnf("InformNewHead called on block marked as bad: %s (reason: %s)", b.Cid(), reason)
+			return false
+		}
 		if err := syncer.ValidateMsgMeta(b); err != nil {
 			log.Warnf("invalid block received: %s", err)
 			return false
@@ -144,10 +257,10 @@ func (syncer *Syncer) InformNewHead(from peer.ID, fts *store.FullTipSet) bool {
 		return false
 	}
 
-	syncer.Bsync.AddPeer(from)
+	syncer.Exchange.AddPeer(from)
 
-	bestPweight := syncer.store.GetHeaviestTipSet().Blocks()[0].ParentWeight
-	targetWeight := fts.TipSet().Blocks()[0].ParentWeight
+	bestPweight := syncer.store.GetHeaviestTipSet().ParentWeight()
+	targetWeight := fts.TipSet().ParentWeight()
 	if targetWeight.LessThan(bestPweight) {
 		var miners []string
 		for _, blk := range fts.TipSet().Blocks() {
@@ -161,6 +274,11 @@ func (syncer *Syncer) InformNewHead(from peer.ID, fts *store.FullTipSet) bool {
 	return true
 }
 
+// IncomingBlocks spawns a goroutine that subscribes to the local eventbus to
+// receive new block headers as they arrive from the network, and sends them to
+// the returned channel.
+//
+// These blocks have not necessarily been incorporated to our view of the chain.
 func (syncer *Syncer) IncomingBlocks(ctx context.Context) (<-chan *types.BlockHeader, error) {
 	sub := syncer.incoming.Sub(LocalIncoming)
 	out := make(chan *types.BlockHeader, 10)
@@ -188,16 +306,22 @@ func (syncer *Syncer) IncomingBlocks(ctx context.Context) (<-chan *types.BlockHe
 	return out, nil
 }
 
+// ValidateMsgMeta performs structural and content hash validation of the
+// messages within this block. If validation passes, it stores the messages in
+// the underlying IPLD block store.
 func (syncer *Syncer) ValidateMsgMeta(fblk *types.FullBlock) error {
-	var bcids, scids []cbg.CBORMarshaler
+	if msgc := len(fblk.BlsMessages) + len(fblk.SecpkMessages); msgc > build.BlockMessageLimit {
+		return xerrors.Errorf("block %s has too many messages (%d)", fblk.Header.Cid(), msgc)
+	}
+
+	// Collect the CIDs of both types of messages separately: BLS and Secpk.
+	var bcids, scids []cid.Cid
 	for _, m := range fblk.BlsMessages {
-		c := cbg.CborCid(m.Cid())
-		bcids = append(bcids, &c)
+		bcids = append(bcids, m.Cid())
 	}
 
 	for _, m := range fblk.SecpkMessages {
-		c := cbg.CborCid(m.Cid())
-		scids = append(scids, &c)
+		scids = append(scids, m.Cid())
 	}
 
 	// TODO: IMPORTANT(GARBAGE). These message puts and the msgmeta
@@ -205,12 +329,15 @@ func (syncer *Syncer) ValidateMsgMeta(fblk *types.FullBlock) error {
 	// we implement that
 	blockstore := syncer.store.Blockstore()
 
-	bs := amt.WrapBlockstore(blockstore)
+	bs := cbor.NewCborStore(blockstore)
+
+	// Compute the root CID of the combined message trie.
 	smroot, err := computeMsgMeta(bs, bcids, scids)
 	if err != nil {
 		return xerrors.Errorf("validating msgmeta, compute failed: %w", err)
 	}
 
+	// Check that the message trie root matches with what's in the block.
 	if fblk.Header.Messages != smroot {
 		return xerrors.Errorf("messages in full block did not match msgmeta root in header (%s != %s)", fblk.Header.Messages, smroot)
 	}
@@ -248,21 +375,28 @@ func (syncer *Syncer) InformNewBlock(from peer.ID, blk *types.FullBlock) bool {
 	return syncer.InformNewHead(from, fts)
 }
 
-func copyBlockstore(from, to bstore.Blockstore) error {
-	cids, err := from.AllKeysChan(context.TODO())
+func copyBlockstore(ctx context.Context, from, to bstore.Blockstore) error {
+	ctx, span := trace.StartSpan(ctx, "copyBlockstore")
+	defer span.End()
+
+	cids, err := from.AllKeysChan(ctx)
 	if err != nil {
 		return err
 	}
 
+	// TODO: should probably expose better methods on the blockstore for this operation
+	var blks []blocks.Block
 	for c := range cids {
 		b, err := from.Get(c)
 		if err != nil {
 			return err
 		}
 
-		if err := to.Put(b); err != nil {
-			return err
-		}
+		blks = append(blks, b)
+	}
+
+	if err := to.PutMany(blks); err != nil {
+		return err
 	}
 
 	return nil
@@ -272,27 +406,29 @@ func copyBlockstore(from, to bstore.Blockstore) error {
 // either validate it here, or ensure that its validated elsewhere (maybe make
 // sure the blocksync code checks it?)
 // maybe this code should actually live in blocksync??
-func zipTipSetAndMessages(bs amt.Blocks, ts *types.TipSet, allbmsgs []*types.Message, allsmsgs []*types.SignedMessage, bmi, smi [][]uint64) (*store.FullTipSet, error) {
+func zipTipSetAndMessages(bs cbor.IpldStore, ts *types.TipSet, allbmsgs []*types.Message, allsmsgs []*types.SignedMessage, bmi, smi [][]uint64) (*store.FullTipSet, error) {
 	if len(ts.Blocks()) != len(smi) || len(ts.Blocks()) != len(bmi) {
 		return nil, fmt.Errorf("msgincl length didnt match tipset size")
 	}
 
 	fts := &store.FullTipSet{}
 	for bi, b := range ts.Blocks() {
+		if msgc := len(bmi[bi]) + len(smi[bi]); msgc > build.BlockMessageLimit {
+			return nil, fmt.Errorf("block %q has too many messages (%d)", b.Cid(), msgc)
+		}
+
 		var smsgs []*types.SignedMessage
-		var smsgCids []cbg.CBORMarshaler
+		var smsgCids []cid.Cid
 		for _, m := range smi[bi] {
 			smsgs = append(smsgs, allsmsgs[m])
-			c := cbg.CborCid(allsmsgs[m].Cid())
-			smsgCids = append(smsgCids, &c)
+			smsgCids = append(smsgCids, allsmsgs[m].Cid())
 		}
 
 		var bmsgs []*types.Message
-		var bmsgCids []cbg.CBORMarshaler
+		var bmsgCids []cid.Cid
 		for _, m := range bmi[bi] {
 			bmsgs = append(bmsgs, allbmsgs[m])
-			c := cbg.CborCid(allbmsgs[m].Cid())
-			bmsgCids = append(bmsgCids, &c)
+			bmsgCids = append(bmsgCids, allbmsgs[m].Cid())
 		}
 
 		mrcid, err := computeMsgMeta(bs, bmsgCids, smsgCids)
@@ -301,7 +437,7 @@ func zipTipSetAndMessages(bs amt.Blocks, ts *types.TipSet, allbmsgs []*types.Mes
 		}
 
 		if b.Messages != mrcid {
-			return nil, fmt.Errorf("messages didnt match message root in header")
+			return nil, fmt.Errorf("messages didnt match message root in header for ts %s", ts.Key())
 		}
 
 		fb := &types.FullBlock{
@@ -316,18 +452,38 @@ func zipTipSetAndMessages(bs amt.Blocks, ts *types.TipSet, allbmsgs []*types.Mes
 	return fts, nil
 }
 
-func computeMsgMeta(bs amt.Blocks, bmsgCids, smsgCids []cbg.CBORMarshaler) (cid.Cid, error) {
-	bmroot, err := amt.FromArray(bs, bmsgCids)
+// computeMsgMeta computes the root CID of the combined arrays of message CIDs
+// of both types (BLS and Secpk).
+func computeMsgMeta(bs cbor.IpldStore, bmsgCids, smsgCids []cid.Cid) (cid.Cid, error) {
+	store := adt.WrapStore(context.TODO(), bs)
+	bmArr := adt.MakeEmptyArray(store)
+	smArr := adt.MakeEmptyArray(store)
+
+	for i, m := range bmsgCids {
+		c := cbg.CborCid(m)
+		if err := bmArr.Set(uint64(i), &c); err != nil {
+			return cid.Undef, err
+		}
+	}
+
+	for i, m := range smsgCids {
+		c := cbg.CborCid(m)
+		if err := smArr.Set(uint64(i), &c); err != nil {
+			return cid.Undef, err
+		}
+	}
+
+	bmroot, err := bmArr.Root()
 	if err != nil {
 		return cid.Undef, err
 	}
 
-	smroot, err := amt.FromArray(bs, smsgCids)
+	smroot, err := smArr.Root()
 	if err != nil {
 		return cid.Undef, err
 	}
 
-	mrcid, err := bs.Put(&types.MsgMeta{
+	mrcid, err := store.Put(store.Context(), &types.MsgMeta{
 		BlsMessages:   bmroot,
 		SecpkMessages: smroot,
 	})
@@ -338,14 +494,24 @@ func computeMsgMeta(bs amt.Blocks, bmsgCids, smsgCids []cbg.CBORMarshaler) (cid.
 	return mrcid, nil
 }
 
+// FetchTipSet tries to load the provided tipset from the store, and falls back
+// to the network (client) by querying the supplied peer if not found
+// locally.
+//
+// {hint/usage} This is used from the HELLO protocol, to fetch the greeting
+// peer's heaviest tipset if we don't have it.
 func (syncer *Syncer) FetchTipSet(ctx context.Context, p peer.ID, tsk types.TipSetKey) (*store.FullTipSet, error) {
 	if fts, err := syncer.tryLoadFullTipSet(tsk); err == nil {
 		return fts, nil
 	}
 
-	return syncer.Bsync.GetFullTipSet(ctx, p, tsk)
+	// fall back to the network.
+	return syncer.Exchange.GetFullTipSet(ctx, p, tsk)
 }
 
+// tryLoadFullTipSet queries the tipset in the ChainStore, and returns a full
+// representation of it containing FullBlocks. If ALL blocks are not found
+// locally, it errors entirely with blockstore.ErrNotFound.
 func (syncer *Syncer) tryLoadFullTipSet(tsk types.TipSetKey) (*store.FullTipSet, error) {
 	ts, err := syncer.store.LoadTipSet(tsk)
 	if err != nil {
@@ -370,6 +536,12 @@ func (syncer *Syncer) tryLoadFullTipSet(tsk types.TipSetKey) (*store.FullTipSet,
 	return fts, nil
 }
 
+// Sync tries to advance our view of the chain to `maybeHead`. It does nothing
+// if our current head is heavier than the requested tipset, or if we're already
+// at the requested head, or if the head is the genesis.
+//
+// Most of the heavy-lifting logic happens in syncer#collectChain. Refer to the
+// godocs on that method for a more detailed view.
 func (syncer *Syncer) Sync(ctx context.Context, maybeHead *types.TipSet) error {
 	ctx, span := trace.StartSpan(ctx, "chain.Sync")
 	defer span.End()
@@ -398,6 +570,8 @@ func (syncer *Syncer) Sync(ctx context.Context, maybeHead *types.TipSet) error {
 		return xerrors.Errorf("collectChain failed: %w", err)
 	}
 
+	// At this point we have accepted and synced to the new `maybeHead`
+	// (`StageSyncComplete`).
 	if err := syncer.store.PutTipSet(ctx, maybeHead); err != nil {
 		span.AddAttributes(trace.StringAttribute("put_error", err.Error()))
 		span.SetStatus(trace.Status{
@@ -434,43 +608,49 @@ func (syncer *Syncer) ValidateTipSet(ctx context.Context, fts *store.FullTipSet)
 		return nil
 	}
 
+	var futures []async.ErrorFuture
 	for _, b := range fts.Blocks {
-		if err := syncer.ValidateBlock(ctx, b); err != nil {
-			if isPermanent(err) {
-				syncer.bad.Add(b.Cid())
-			}
-			return xerrors.Errorf("validating block %s: %w", b.Cid(), err)
-		}
+		b := b // rebind to a scoped variable
 
-		if err := syncer.sm.ChainStore().AddToTipSetTracker(b.Header); err != nil {
-			return xerrors.Errorf("failed to add validated header to tipset tracker: %w", err)
+		futures = append(futures, async.Err(func() error {
+			if err := syncer.ValidateBlock(ctx, b); err != nil {
+				if isPermanent(err) {
+					syncer.bad.Add(b.Cid(), NewBadBlockReason([]cid.Cid{b.Cid()}, err.Error()))
+				}
+				return xerrors.Errorf("validating block %s: %w", b.Cid(), err)
+			}
+
+			if err := syncer.sm.ChainStore().AddToTipSetTracker(b.Header); err != nil {
+				return xerrors.Errorf("failed to add validated header to tipset tracker: %w", err)
+			}
+			return nil
+		}))
+	}
+	for _, f := range futures {
+		if err := f.AwaitContext(ctx); err != nil {
+			return err
 		}
 	}
 	return nil
 }
 
 func (syncer *Syncer) minerIsValid(ctx context.Context, maddr address.Address, baseTs *types.TipSet) error {
-	var err error
-	enc, err := actors.SerializeParams(&actors.IsValidMinerParam{Addr: maddr})
+	act, err := syncer.sm.LoadActor(ctx, power.Address, baseTs)
 	if err != nil {
-		return err
+		return xerrors.Errorf("failed to load power actor: %w", err)
 	}
 
-	ret, err := syncer.sm.Call(ctx, &types.Message{
-		To:     actors.StoragePowerAddress,
-		From:   maddr,
-		Method: actors.SPAMethods.IsValidMiner,
-		Params: enc,
-	}, baseTs)
+	powState, err := power.Load(syncer.store.Store(ctx), act)
 	if err != nil {
-		return xerrors.Errorf("checking if block miner is valid failed: %w", err)
+		return xerrors.Errorf("failed to load power actor state: %w", err)
 	}
 
-	if ret.ExitCode != 0 {
-		return xerrors.Errorf("StorageMarket.IsValidMiner check failed (exit code %d)", ret.ExitCode)
+	_, exist, err := powState.MinerPower(maddr)
+	if err != nil {
+		return xerrors.Errorf("failed to look up miner's claim: %w", err)
 	}
 
-	if !bytes.Equal(ret.Return, cbg.CborBoolTrue) {
+	if !exist {
 		return xerrors.New("miner isn't valid")
 	}
 
@@ -479,12 +659,56 @@ func (syncer *Syncer) minerIsValid(ctx context.Context, maddr address.Address, b
 
 var ErrTemporal = errors.New("temporal error")
 
-// Should match up with 'Semantical Validation' in validation.md in the spec
-func (syncer *Syncer) ValidateBlock(ctx context.Context, b *types.FullBlock) error {
+func blockSanityChecks(h *types.BlockHeader) error {
+	if h.ElectionProof == nil {
+		return xerrors.Errorf("block cannot have nil election proof")
+	}
+
+	if h.Ticket == nil {
+		return xerrors.Errorf("block cannot have nil ticket")
+	}
+
+	if h.BlockSig == nil {
+		return xerrors.Errorf("block had nil signature")
+	}
+
+	if h.BLSAggregate == nil {
+		return xerrors.Errorf("block had nil bls aggregate signature")
+	}
+
+	return nil
+}
+
+// ValidateBlock should match up with 'Semantical Validation' in validation.md in the spec
+func (syncer *Syncer) ValidateBlock(ctx context.Context, b *types.FullBlock) (err error) {
+	defer func() {
+		// b.Cid() could panic for empty blocks that are used in tests.
+		if rerr := recover(); rerr != nil {
+			err = xerrors.Errorf("validate block panic: %w", rerr)
+			return
+		}
+	}()
+
+	isValidated, err := syncer.store.IsBlockValidated(ctx, b.Cid())
+	if err != nil {
+		return xerrors.Errorf("check block validation cache %s: %w", b.Cid(), err)
+	}
+
+	if isValidated {
+		return nil
+	}
+
+	validationStart := build.Clock.Now()
+	defer func() {
+		stats.Record(ctx, metrics.BlockValidationDurationMilliseconds.M(metrics.SinceInMilliseconds(validationStart)))
+		log.Infow("block validation", "took", time.Since(validationStart), "height", b.Header.Height, "age", time.Since(time.Unix(int64(b.Header.Timestamp), 0)))
+	}()
+
 	ctx, span := trace.StartSpan(ctx, "validateBlock")
 	defer span.End()
-	if build.InsecurePoStValidation {
-		log.Warn("insecure test validation is enabled, if you see this outside of a test, it is a severe bug!")
+
+	if err := blockSanityChecks(b.Header); err != nil {
+		return xerrors.Errorf("incoming header failed basic sanity checks: %w", err)
 	}
 
 	h := b.Header
@@ -494,61 +718,35 @@ func (syncer *Syncer) ValidateBlock(ctx context.Context, b *types.FullBlock) err
 		return xerrors.Errorf("load parent tipset failed (%s): %w", h.Parents, err)
 	}
 
+	lbts, err := stmgr.GetLookbackTipSetForRound(ctx, syncer.sm, baseTs, h.Height)
+	if err != nil {
+		return xerrors.Errorf("failed to get lookback tipset for block: %w", err)
+	}
+
+	lbst, _, err := syncer.sm.TipSetState(ctx, lbts)
+	if err != nil {
+		return xerrors.Errorf("failed to compute lookback tipset state: %w", err)
+	}
+
+	prevBeacon, err := syncer.store.GetLatestBeaconEntry(baseTs)
+	if err != nil {
+		return xerrors.Errorf("failed to get latest beacon entry: %w", err)
+	}
+
 	// fast checks first
-	if h.BlockSig == nil {
-		return xerrors.Errorf("block had nil signature")
+	nulls := h.Height - (baseTs.Height() + 1)
+	if tgtTs := baseTs.MinTimestamp() + build.BlockDelaySecs*uint64(nulls+1); h.Timestamp != tgtTs {
+		return xerrors.Errorf("block has wrong timestamp: %d != %d", h.Timestamp, tgtTs)
 	}
 
-	if h.Timestamp > uint64(time.Now().Unix()+build.AllowableClockDrift) {
-		return xerrors.Errorf("block was from the future: %w", ErrTemporal)
+	now := uint64(build.Clock.Now().Unix())
+	if h.Timestamp > now+build.AllowableClockDriftSecs {
+		return xerrors.Errorf("block was from the future (now=%d, blk=%d): %w", now, h.Timestamp, ErrTemporal)
 	}
-	if h.Timestamp > uint64(time.Now().Unix()) {
-		log.Warn("Got block from the future, but within threshold", h.Timestamp, time.Now().Unix())
+	if h.Timestamp > now {
+		log.Warn("Got block from the future, but within threshold", h.Timestamp, build.Clock.Now().Unix())
 	}
 
-	if h.Timestamp < baseTs.MinTimestamp()+(build.BlockDelay*(h.Height-baseTs.Height())) {
-		log.Warn("timestamp funtimes: ", h.Timestamp, baseTs.MinTimestamp(), h.Height, baseTs.Height())
-		return xerrors.Errorf("block was generated too soon (h.ts:%d < base.mints:%d + BLOCK_DELAY:%d * deltaH:%d)", h.Timestamp, baseTs.MinTimestamp(), build.BlockDelay, h.Height-baseTs.Height())
-	}
-
-	winnerCheck := async.Err(func() error {
-		slashedAt, err := stmgr.GetMinerSlashed(ctx, syncer.sm, baseTs, h.Miner)
-		if err != nil {
-			return xerrors.Errorf("failed to check if block miner was slashed: %w", err)
-		}
-
-		if slashedAt != 0 {
-			return xerrors.Errorf("received block was from miner slashed at height %d", slashedAt)
-		}
-
-		mpow, tpow, err := stmgr.GetPower(ctx, syncer.sm, baseTs, h.Miner)
-		if err != nil {
-			return xerrors.Errorf("failed getting power: %w", err)
-		}
-
-		ssize, err := stmgr.GetMinerSectorSize(ctx, syncer.sm, baseTs, h.Miner)
-		if err != nil {
-			return xerrors.Errorf("failed to get sector size for block miner: %w", err)
-		}
-
-		snum := types.BigDiv(mpow, types.NewInt(ssize))
-
-		// FORK START
-		if h.Height > build.ForkCCM {
-			if len(h.EPostProof.Candidates) == 0 {
-				return xerrors.Errorf("no candidates")
-			}
-		}
-		// FORK END
-
-		for _, t := range h.EPostProof.Candidates {
-			if !types.IsTicketWinner(t.Partial, ssize, snum.Uint64(), tpow) {
-				return xerrors.Errorf("miner created a block but was not a winner")
-			}
-		}
-		return nil
-	})
-
 	msgsCheck := async.Err(func() error {
 		if err := syncer.checkBlockMessages(ctx, b, baseTs); err != nil {
 			return xerrors.Errorf("block had invalid messages: %w", err)
@@ -563,6 +761,27 @@ func (syncer *Syncer) ValidateBlock(ctx context.Context, b *types.FullBlock) err
 		return nil
 	})
 
+	baseFeeCheck := async.Err(func() error {
+		baseFee, err := syncer.store.ComputeBaseFee(ctx, baseTs)
+		if err != nil {
+			return xerrors.Errorf("computing base fee: %w", err)
+		}
+		if types.BigCmp(baseFee, b.Header.ParentBaseFee) != 0 {
+			return xerrors.Errorf("base fee doesn't match: %s (header) != %s (computed)",
+				b.Header.ParentBaseFee, baseFee)
+		}
+		return nil
+	})
+	pweight, err := syncer.store.Weight(ctx, baseTs)
+	if err != nil {
+		return xerrors.Errorf("getting parent weight: %w", err)
+	}
+
+	if types.BigCmp(pweight, b.Header.ParentWeight) != 0 {
+		return xerrors.Errorf("parrent weight different: %s (header) != %s (computed)",
+			b.Header.ParentWeight, pweight)
+	}
+
 	// Stuff that needs stateroot / worker address
 	stateroot, precp, err := syncer.sm.TipSetState(ctx, baseTs)
 	if err != nil {
@@ -588,31 +807,112 @@ func (syncer *Syncer) ValidateBlock(ctx context.Context, b *types.FullBlock) err
 		return xerrors.Errorf("parent receipts root did not match computed value (%s != %s)", precp, h.ParentMessageReceipts)
 	}
 
-	waddr, err := stmgr.GetMinerWorkerRaw(ctx, syncer.sm, stateroot, h.Miner)
+	waddr, err := stmgr.GetMinerWorkerRaw(ctx, syncer.sm, lbst, h.Miner)
 	if err != nil {
 		return xerrors.Errorf("GetMinerWorkerRaw failed: %w", err)
 	}
 
+	winnerCheck := async.Err(func() error {
+		if h.ElectionProof.WinCount < 1 {
+			return xerrors.Errorf("block is not claiming to be a winner")
+		}
+
+		hp, err := stmgr.MinerHasMinPower(ctx, syncer.sm, h.Miner, lbts)
+		if err != nil {
+			return xerrors.Errorf("determining if miner has min power failed: %w", err)
+		}
+
+		if !hp {
+			return xerrors.New("block's miner does not meet minimum power threshold")
+		}
+
+		rBeacon := *prevBeacon
+		if len(h.BeaconEntries) != 0 {
+			rBeacon = h.BeaconEntries[len(h.BeaconEntries)-1]
+		}
+		buf := new(bytes.Buffer)
+		if err := h.Miner.MarshalCBOR(buf); err != nil {
+			return xerrors.Errorf("failed to marshal miner address to cbor: %w", err)
+		}
+
+		vrfBase, err := store.DrawRandomness(rBeacon.Data, crypto.DomainSeparationTag_ElectionProofProduction, h.Height, buf.Bytes())
+		if err != nil {
+			return xerrors.Errorf("could not draw randomness: %w", err)
+		}
+
+		if err := VerifyElectionPoStVRF(ctx, waddr, vrfBase, h.ElectionProof.VRFProof); err != nil {
+			return xerrors.Errorf("validating block election proof failed: %w", err)
+		}
+
+		slashed, err := stmgr.GetMinerSlashed(ctx, syncer.sm, baseTs, h.Miner)
+		if err != nil {
+			return xerrors.Errorf("failed to check if block miner was slashed: %w", err)
+		}
+
+		if slashed {
+			return xerrors.Errorf("received block was from slashed or invalid miner")
+		}
+
+		mpow, tpow, _, err := stmgr.GetPowerRaw(ctx, syncer.sm, lbst, h.Miner)
+		if err != nil {
+			return xerrors.Errorf("failed getting power: %w", err)
+		}
+
+		j := h.ElectionProof.ComputeWinCount(mpow.QualityAdjPower, tpow.QualityAdjPower)
+		if h.ElectionProof.WinCount != j {
+			return xerrors.Errorf("miner claims wrong number of wins: miner: %d, computed: %d", h.ElectionProof.WinCount, j)
+		}
+
+		return nil
+	})
+
 	blockSigCheck := async.Err(func() error {
-		if err := h.CheckBlockSignature(ctx, waddr); err != nil {
+		if err := sigs.CheckBlockSignature(ctx, h, waddr); err != nil {
 			return xerrors.Errorf("check block signature failed: %w", err)
 		}
 		return nil
 	})
 
+	beaconValuesCheck := async.Err(func() error {
+		if os.Getenv("LOTUS_IGNORE_DRAND") == "_yes_" {
+			return nil
+		}
+
+		if err := beacon.ValidateBlockValues(syncer.beacon, h, baseTs.Height(), *prevBeacon); err != nil {
+			return xerrors.Errorf("failed to validate blocks random beacon values: %w", err)
+		}
+		return nil
+	})
+
 	tktsCheck := async.Err(func() error {
-		vrfBase := baseTs.MinTicket().VRFProof
+		buf := new(bytes.Buffer)
+		if err := h.Miner.MarshalCBOR(buf); err != nil {
+			return xerrors.Errorf("failed to marshal miner address to cbor: %w", err)
+		}
 
-		err := gen.VerifyVRF(ctx, waddr, h.Miner, gen.DSepTicket, vrfBase, h.Ticket.VRFProof)
+		if h.Height > build.UpgradeSmokeHeight {
+			buf.Write(baseTs.MinTicket().VRFProof)
+		}
 
+		beaconBase := *prevBeacon
+		if len(h.BeaconEntries) != 0 {
+			beaconBase = h.BeaconEntries[len(h.BeaconEntries)-1]
+		}
+
+		vrfBase, err := store.DrawRandomness(beaconBase.Data, crypto.DomainSeparationTag_TicketProduction, h.Height-build.TicketRandomnessLookback, buf.Bytes())
+		if err != nil {
+			return xerrors.Errorf("failed to compute vrf base for ticket: %w", err)
+		}
+
+		err = VerifyElectionPoStVRF(ctx, waddr, vrfBase, h.Ticket.VRFProof)
 		if err != nil {
 			return xerrors.Errorf("validating block tickets failed: %w", err)
 		}
 		return nil
 	})
 
-	eproofCheck := async.Err(func() error {
-		if err := syncer.VerifyElectionPoStProof(ctx, h, baseTs, waddr); err != nil {
+	wproofCheck := async.Err(func() error {
+		if err := syncer.VerifyWinningPoStProof(ctx, h, *prevBeacon, lbst, waddr); err != nil {
 			return xerrors.Errorf("invalid election post: %w", err)
 		}
 		return nil
@@ -622,9 +922,11 @@ func (syncer *Syncer) ValidateBlock(ctx context.Context, b *types.FullBlock) err
 		minerCheck,
 		tktsCheck,
 		blockSigCheck,
-		eproofCheck,
+		beaconValuesCheck,
+		wproofCheck,
 		winnerCheck,
 		msgsCheck,
+		baseFeeCheck,
 	}
 
 	var merr error
@@ -633,72 +935,92 @@ func (syncer *Syncer) ValidateBlock(ctx context.Context, b *types.FullBlock) err
 			merr = multierror.Append(merr, err)
 		}
 	}
+	if merr != nil {
+		mulErr := merr.(*multierror.Error)
+		mulErr.ErrorFormat = func(es []error) string {
+			if len(es) == 1 {
+				return fmt.Sprintf("1 error occurred:\n\t* %+v\n\n", es[0])
+			}
 
-	return merr
-}
+			points := make([]string, len(es))
+			for i, err := range es {
+				points[i] = fmt.Sprintf("* %+v", err)
+			}
 
-func (syncer *Syncer) VerifyElectionPoStProof(ctx context.Context, h *types.BlockHeader, baseTs *types.TipSet, waddr address.Address) error {
-	rand, err := syncer.sm.ChainStore().GetRandomness(ctx, baseTs.Cids(), int64(h.Height-build.EcRandomnessLookback))
-	if err != nil {
-		return xerrors.Errorf("failed to get randomness for verifying election proof: %w", err)
-	}
-
-	if err := VerifyElectionPoStVRF(ctx, h.EPostProof.PostRand, rand, waddr, h.Miner); err != nil {
-		return xerrors.Errorf("checking eproof failed: %w", err)
-	}
-
-	ssize, err := stmgr.GetMinerSectorSize(ctx, syncer.sm, baseTs, h.Miner)
-	if err != nil {
-		return xerrors.Errorf("failed to get sector size for miner: %w", err)
-	}
-
-	var winners []sectorbuilder.EPostCandidate
-	for _, t := range h.EPostProof.Candidates {
-		var partial [32]byte
-		copy(partial[:], t.Partial)
-		winners = append(winners, sectorbuilder.EPostCandidate{
-			PartialTicket:        partial,
-			SectorID:             t.SectorID,
-			SectorChallengeIndex: t.ChallengeIndex,
-		})
-	}
-	// FORK START
-	if h.Height > build.ForkCCM {
-		if len(winners) == 0 {
-			return xerrors.Errorf("no candidates")
+			return fmt.Sprintf(
+				"%d errors occurred:\n\t%s\n\n",
+				len(es), strings.Join(points, "\n\t"))
 		}
-	}
-	// FORK END
-
-	sectorInfo, err := stmgr.GetSectorsForElectionPost(ctx, syncer.sm, baseTs, h.Miner)
-	if err != nil {
-		return xerrors.Errorf("getting election post sector set: %w", err)
+		return mulErr
 	}
 
-	if build.InsecurePoStValidation {
-		if string(h.EPostProof.Proof) == "valid proof" {
-			return nil
-		}
-		return xerrors.Errorf("[TESTING] election post was invalid")
-	}
-	hvrf := sha256.Sum256(h.EPostProof.PostRand)
-
-	ok, err := sectorbuilder.VerifyElectionPost(ctx, ssize, *sectorInfo, hvrf[:], h.EPostProof.Proof, winners, h.Miner)
-	if err != nil {
-		return xerrors.Errorf("failed to verify election post: %w", err)
-	}
-
-	if !ok {
-		return xerrors.Errorf("election post was invalid")
+	if err := syncer.store.MarkBlockAsValidated(ctx, b.Cid()); err != nil {
+		return xerrors.Errorf("caching block validation %s: %w", b.Cid(), err)
 	}
 
 	return nil
 }
 
+func (syncer *Syncer) VerifyWinningPoStProof(ctx context.Context, h *types.BlockHeader, prevBeacon types.BeaconEntry, lbst cid.Cid, waddr address.Address) error {
+	if build.InsecurePoStValidation {
+		if len(h.WinPoStProof) == 0 {
+			return xerrors.Errorf("[INSECURE-POST-VALIDATION] No winning post proof given")
+		}
+
+		if string(h.WinPoStProof[0].ProofBytes) == "valid proof" {
+			return nil
+		}
+		return xerrors.Errorf("[INSECURE-POST-VALIDATION] winning post was invalid")
+	}
+
+	buf := new(bytes.Buffer)
+	if err := h.Miner.MarshalCBOR(buf); err != nil {
+		return xerrors.Errorf("failed to marshal miner address: %w", err)
+	}
+
+	rbase := prevBeacon
+	if len(h.BeaconEntries) > 0 {
+		rbase = h.BeaconEntries[len(h.BeaconEntries)-1]
+	}
+
+	rand, err := store.DrawRandomness(rbase.Data, crypto.DomainSeparationTag_WinningPoStChallengeSeed, h.Height, buf.Bytes())
+	if err != nil {
+		return xerrors.Errorf("failed to get randomness for verifying winning post proof: %w", err)
+	}
+
+	mid, err := address.IDFromAddress(h.Miner)
+	if err != nil {
+		return xerrors.Errorf("failed to get ID from miner address %s: %w", h.Miner, err)
+	}
+
+	sectors, err := stmgr.GetSectorsForWinningPoSt(ctx, syncer.verifier, syncer.sm, lbst, h.Miner, rand)
+	if err != nil {
+		return xerrors.Errorf("getting winning post sector set: %w", err)
+	}
+
+	ok, err := ffiwrapper.ProofVerifier.VerifyWinningPoSt(ctx, proof.WinningPoStVerifyInfo{
+		Randomness:        rand,
+		Proofs:            h.WinPoStProof,
+		ChallengedSectors: sectors,
+		Prover:            abi.ActorID(mid),
+	})
+	if err != nil {
+		return xerrors.Errorf("failed to verify election post: %w", err)
+	}
+
+	if !ok {
+		log.Errorf("invalid winning post (block: %s, %x; %v)", h.Cid(), rand, sectors)
+		return xerrors.Errorf("winning post was invalid")
+	}
+
+	return nil
+}
+
+// TODO: We should extract this somewhere else and make the message pool and miner use the same logic
 func (syncer *Syncer) checkBlockMessages(ctx context.Context, b *types.FullBlock, baseTs *types.TipSet) error {
 	{
 		var sigCids []cid.Cid // this is what we get for people not wanting the marshalcbor method on the cid type
-		var pubks []bls.PublicKey
+		var pubks [][]byte
 
 		for _, m := range b.BlsMessages {
 			sigCids = append(sigCids, m.Cid())
@@ -717,31 +1039,49 @@ func (syncer *Syncer) checkBlockMessages(ctx context.Context, b *types.FullBlock
 	}
 
 	nonces := make(map[address.Address]uint64)
-	balances := make(map[address.Address]types.BigInt)
 
 	stateroot, _, err := syncer.sm.TipSetState(ctx, baseTs)
 	if err != nil {
 		return err
 	}
 
-	cst := hamt.CSTFromBstore(syncer.store.Blockstore())
+	cst := cbor.NewCborStore(syncer.store.Blockstore())
 	st, err := state.LoadStateTree(cst, stateroot)
 	if err != nil {
 		return xerrors.Errorf("failed to load base state tree: %w", err)
 	}
 
-	checkMsg := func(m *types.Message) error {
-		if m.To == address.Undef {
-			return xerrors.New("'To' address cannot be empty")
+	pl := vm.PricelistByEpoch(baseTs.Height())
+	var sumGasLimit int64
+	checkMsg := func(msg types.ChainMsg) error {
+		m := msg.VMMessage()
+
+		// Phase 1: syntactic validation, as defined in the spec
+		minGas := pl.OnChainMessage(msg.ChainLength())
+		if err := m.ValidForBlockInclusion(minGas.Total()); err != nil {
+			return err
 		}
 
+		// ValidForBlockInclusion checks if any single message does not exceed BlockGasLimit
+		// So below is overflow safe
+		sumGasLimit += m.GasLimit
+		if sumGasLimit > build.BlockGasLimit {
+			return xerrors.Errorf("block gas limit exceeded")
+		}
+
+		// Phase 2: (Partial) semantic validation:
+		// the sender exists and is an account actor, and the nonces make sense
 		if _, ok := nonces[m.From]; !ok {
+			// `GetActor` does not validate that this is an account actor.
 			act, err := st.GetActor(m.From)
 			if err != nil {
 				return xerrors.Errorf("failed to get actor: %w", err)
 			}
+
+			if !act.IsAccountActor() {
+				return xerrors.New("Sender must be an account actor")
+			}
 			nonces[m.From] = act.Nonce
-			balances[m.From] = act.Balance
 		}
 
 		if nonces[m.From] != m.Nonce {
@@ -749,56 +1089,57 @@ func (syncer *Syncer) checkBlockMessages(ctx context.Context, b *types.FullBlock
 		}
 		nonces[m.From]++
 
-		if balances[m.From].LessThan(m.RequiredFunds()) {
-			return xerrors.Errorf("not enough funds for message execution")
-		}
-
-		balances[m.From] = types.BigSub(balances[m.From], m.RequiredFunds())
 		return nil
 	}
 
-	bs := amt.WrapBlockstore(syncer.store.Blockstore())
-	var blsCids []cbg.CBORMarshaler
+	store := adt.WrapStore(ctx, cst)
 
+	bmArr := adt.MakeEmptyArray(store)
 	for i, m := range b.BlsMessages {
 		if err := checkMsg(m); err != nil {
 			return xerrors.Errorf("block had invalid bls message at index %d: %w", i, err)
 		}
 
 		c := cbg.CborCid(m.Cid())
-		blsCids = append(blsCids, &c)
+		if err := bmArr.Set(uint64(i), &c); err != nil {
+			return xerrors.Errorf("failed to put bls message at index %d: %w", i, err)
+		}
 	}
 
-	var secpkCids []cbg.CBORMarshaler
+	smArr := adt.MakeEmptyArray(store)
 	for i, m := range b.SecpkMessages {
-		if err := checkMsg(&m.Message); err != nil {
+		if err := checkMsg(m); err != nil {
 			return xerrors.Errorf("block had invalid secpk message at index %d: %w", i, err)
 		}
 
+		// `From` being an account actor is only validated inside the `vm.ResolveToKeyAddr` call
+		// in `StateManager.ResolveToKeyAddress` here (and not in `checkMsg`).
 		kaddr, err := syncer.sm.ResolveToKeyAddress(ctx, m.Message.From, baseTs)
 		if err != nil {
 			return xerrors.Errorf("failed to resolve key addr: %w", err)
 		}
 
-		if err := m.Signature.Verify(kaddr, m.Message.Cid().Bytes()); err != nil {
+		if err := sigs.Verify(&m.Signature, kaddr, m.Message.Cid().Bytes()); err != nil {
 			return xerrors.Errorf("secpk message %s has invalid signature: %w", m.Cid(), err)
 		}
 
 		c := cbg.CborCid(m.Cid())
-		secpkCids = append(secpkCids, &c)
+		if err := smArr.Set(uint64(i), &c); err != nil {
+			return xerrors.Errorf("failed to put secpk message at index %d: %w", i, err)
+		}
 	}
 
-	bmroot, err := amt.FromArray(bs, blsCids)
+	bmroot, err := bmArr.Root()
 	if err != nil {
-		return xerrors.Errorf("failed to build amt from bls msg cids: %w", err)
+		return err
 	}
 
-	smroot, err := amt.FromArray(bs, secpkCids)
+	smroot, err := smArr.Root()
 	if err != nil {
-		return xerrors.Errorf("failed to build amt from bls msg cids: %w", err)
+		return err
 	}
 
-	mrcid, err := bs.Put(&types.MsgMeta{
+	mrcid, err := cst.Put(ctx, &types.MsgMeta{
 		BlsMessages:   bmroot,
 		SecpkMessages: smroot,
 	})
@@ -813,33 +1154,27 @@ func (syncer *Syncer) checkBlockMessages(ctx context.Context, b *types.FullBlock
 	return nil
 }
 
-func (syncer *Syncer) verifyBlsAggregate(ctx context.Context, sig types.Signature, msgs []cid.Cid, pubks []bls.PublicKey) error {
+func (syncer *Syncer) verifyBlsAggregate(ctx context.Context, sig *crypto.Signature, msgs []cid.Cid, pubks [][]byte) error {
 	_, span := trace.StartSpan(ctx, "syncer.verifyBlsAggregate")
 	defer span.End()
 	span.AddAttributes(
 		trace.Int64Attribute("msgCount", int64(len(msgs))),
 	)
 
-	var wg sync.WaitGroup
-
-	digests := make([]bls.Digest, len(msgs))
-	for i := 0; i < 10; i++ {
-		wg.Add(1)
-		go func(w int) {
-			defer wg.Done()
-			for j := 0; (j*10)+w < len(msgs); j++ {
-				digests[j*10+w] = bls.Hash(bls.Message(msgs[j*10+w].Bytes()))
-			}
-		}(i)
+	msgsS := make([]blst.Message, len(msgs))
+	for i := 0; i < len(msgs); i++ {
+		msgsS[i] = msgs[i].Bytes()
 	}
-	wg.Wait()
 
-	var bsig bls.Signature
-	copy(bsig[:], sig.Data)
-	if !bls.Verify(&bsig, digests, pubks) {
+	if len(msgs) == 0 {
+		return nil
+	}
+
+	valid := new(bls.Signature).AggregateVerifyCompressed(sig.Data, pubks,
+		msgsS, []byte(bls.DST))
+	if !valid {
 		return xerrors.New("bls aggregate signature failed to verify")
 	}
-
 	return nil
 }
 
@@ -853,31 +1188,90 @@ func extractSyncState(ctx context.Context) *SyncerState {
 	return nil
 }
 
-func (syncer *Syncer) collectHeaders(ctx context.Context, from *types.TipSet, to *types.TipSet) ([]*types.TipSet, error) {
+// collectHeaders collects the headers from the blocks between any two tipsets.
+//
+// `incoming` is the heaviest/projected/target tipset we have learned about, and
+// `known` is usually an anchor tipset we already have in our view of the chain
+// (which could be the genesis).
+//
+// collectHeaders checks if portions of the chain are in our ChainStore; falling
+// down to the network to retrieve the missing parts. If during the process, any
+// portion we receive is in our denylist (bad list), we short-circuit.
+//
+// {hint/usage}: This is used by collectChain, which is in turn called from the
+// main Sync method (Syncer#Sync), so it's a pretty central method.
+//
+// {hint/logic}: The logic of this method is as follows:
+//
+//  1. Check that the from tipset is not linked to a parent block known to be
+//     bad.
+//  2. Check the consistency of beacon entries in the from tipset. We check
+//     total equality of the BeaconEntries in each block.
+//  3. Traverse the chain backwards, for each tipset:
+//  	3a. Load it from the chainstore; if found, it move on to its parent.
+//      3b. Query our peers via client in batches, requesting up to a
+//      maximum of 500 tipsets every time.
+//
+// Once we've concluded, if we find a mismatching tipset at the height where the
+// anchor tipset should be, we are facing a fork, and we invoke Syncer#syncFork
+// to resolve it. Refer to the godocs there.
+//
+// All throughout the process, we keep checking if the received blocks are in
+// the deny list, and short-circuit the process if so.
+func (syncer *Syncer) collectHeaders(ctx context.Context, incoming *types.TipSet, known *types.TipSet) ([]*types.TipSet, error) {
 	ctx, span := trace.StartSpan(ctx, "collectHeaders")
 	defer span.End()
 	ss := extractSyncState(ctx)
 
 	span.AddAttributes(
-		trace.Int64Attribute("fromHeight", int64(from.Height())),
-		trace.Int64Attribute("toHeight", int64(to.Height())),
+		trace.Int64Attribute("incomingHeight", int64(incoming.Height())),
+		trace.Int64Attribute("knownHeight", int64(known.Height())),
 	)
 
-	for _, pcid := range from.Parents().Cids() {
-		if syncer.bad.Has(pcid) {
-			for _, b := range from.Cids() {
-				syncer.bad.Add(b)
+	// Check if the parents of the from block are in the denylist.
+	// i.e. if a fork of the chain has been requested that we know to be bad.
+	for _, pcid := range incoming.Parents().Cids() {
+		if reason, ok := syncer.bad.Has(pcid); ok {
+			newReason := reason.Linked("linked to %s", pcid)
+			for _, b := range incoming.Cids() {
+				syncer.bad.Add(b, newReason)
 			}
-			return nil, xerrors.Errorf("chain linked to block marked previously as bad (%s, %s)", from.Cids(), pcid)
+			return nil, xerrors.Errorf("chain linked to block marked previously as bad (%s, %s) (reason: %s)", incoming.Cids(), pcid, reason)
 		}
 	}
 
-	blockSet := []*types.TipSet{from}
+	{
+		// ensure consistency of beacon entires
+		targetBE := incoming.Blocks()[0].BeaconEntries
+		sorted := sort.SliceIsSorted(targetBE, func(i, j int) bool {
+			return targetBE[i].Round < targetBE[j].Round
+		})
+		if !sorted {
+			syncer.bad.Add(incoming.Cids()[0], NewBadBlockReason(incoming.Cids(), "wrong order of beacon entires"))
+			return nil, xerrors.Errorf("wrong order of beacon entires")
+		}
 
-	at := from.Parents()
+		for _, bh := range incoming.Blocks()[1:] {
+			if len(targetBE) != len(bh.BeaconEntries) {
+				// cannot mark bad, I think @Kubuxu
+				return nil, xerrors.Errorf("tipset contained different number for beacon entires")
+			}
+			for i, be := range bh.BeaconEntries {
+				if targetBE[i].Round != be.Round || !bytes.Equal(targetBE[i].Data, be.Data) {
+					// cannot mark bad, I think @Kubuxu
+					return nil, xerrors.Errorf("tipset contained different beacon entires")
+				}
+			}
+
+		}
+	}
+
+	blockSet := []*types.TipSet{incoming}
+
+	at := incoming.Parents()
 
 	// we want to sync all the blocks until the height above the block we have
-	untilHeight := to.Height() + 1
+	untilHeight := known.Height() + 1
 
 	ss.SetHeight(blockSet[len(blockSet)-1].Height())
 
@@ -886,12 +1280,13 @@ func (syncer *Syncer) collectHeaders(ctx context.Context, from *types.TipSet, to
 loop:
 	for blockSet[len(blockSet)-1].Height() > untilHeight {
 		for _, bc := range at.Cids() {
-			if syncer.bad.Has(bc) {
+			if reason, ok := syncer.bad.Has(bc); ok {
+				newReason := reason.Linked("change contained %s", bc)
 				for _, b := range acceptedBlocks {
-					syncer.bad.Add(b)
+					syncer.bad.Add(b, newReason)
 				}
 
-				return nil, xerrors.Errorf("chain contained block marked previously as bad (%s, %s)", from.Cids(), bc)
+				return nil, xerrors.Errorf("chain contained block marked previously as bad (%s, %s) (reason: %s)", incoming.Cids(), bc, reason)
 			}
 		}
 
@@ -909,13 +1304,13 @@ loop:
 		}
 
 		// NB: GetBlocks validates that the blocks are in-fact the ones we
-		// requested, and that they are correctly linked to eachother. It does
-		// not validate any state transitions
+		// requested, and that they are correctly linked to one another. It does
+		// not validate any state transitions.
 		window := 500
 		if gap := int(blockSet[len(blockSet)-1].Height() - untilHeight); gap < window {
 			window = gap
 		}
-		blks, err := syncer.Bsync.GetBlocks(ctx, at, window)
+		blks, err := syncer.Exchange.GetBlocks(ctx, at, window)
 		if err != nil {
 			// Most likely our peers aren't fully synced yet, but forwarded
 			// new block message (ideally we'd find better peers)
@@ -929,17 +1324,34 @@ loop:
 		}
 		log.Info("Got blocks: ", blks[0].Height(), len(blks))
 
+		// Check that the fetched segment of the chain matches what we already
+		// have. Since we fetch from the head backwards our reassembled chain
+		// is sorted in reverse here: we have a child -> parent order, our last
+		// tipset then should be child of the first tipset retrieved.
+		// FIXME: The reassembly logic should be part of the `client`
+		//  service, the consumer should not be concerned with the
+		//  `MaxRequestLength` limitation, it should just be able to request
+		//  an segment of arbitrary length. The same burden is put on
+		//  `syncFork()` which needs to be aware this as well.
+		if blockSet[len(blockSet)-1].IsChildOf(blks[0]) == false {
+			return nil, xerrors.Errorf("retrieved segments of the chain are not connected at heights %d/%d",
+				blockSet[len(blockSet)-1].Height(), blks[0].Height())
+			// A successful `GetBlocks()` call is guaranteed to fetch at least
+			// one tipset so the acess `blks[0]` is safe.
+		}
+
 		for _, b := range blks {
 			if b.Height() < untilHeight {
 				break loop
 			}
 			for _, bc := range b.Cids() {
-				if syncer.bad.Has(bc) {
+				if reason, ok := syncer.bad.Has(bc); ok {
+					newReason := reason.Linked("change contained %s", bc)
 					for _, b := range acceptedBlocks {
-						syncer.bad.Add(b)
+						syncer.bad.Add(b, newReason)
 					}
 
-					return nil, xerrors.Errorf("chain contained block marked previously as bad (%s, %s)", from.Cids(), bc)
+					return nil, xerrors.Errorf("chain contained block marked previously as bad (%s, %s) (reason: %s)", incoming.Cids(), bc, reason)
 				}
 			}
 			blockSet = append(blockSet, b)
@@ -951,42 +1363,60 @@ loop:
 		at = blks[len(blks)-1].Parents()
 	}
 
-	// We have now ascertained that this is *not* a 'fast forward'
-	if !types.CidArrsEqual(blockSet[len(blockSet)-1].Parents().Cids(), to.Cids()) {
-		last := blockSet[len(blockSet)-1]
-		if last.Parents() == to.Parents() {
-			// common case: receiving a block thats potentially part of the same tipset as our best block
-			return blockSet, nil
-		}
-
-		log.Warnf("(fork detected) synced header chain (%s - %d) does not link to our best block (%s - %d)", from.Cids(), from.Height(), to.Cids(), to.Height())
-		fork, err := syncer.syncFork(ctx, last, to)
-		if err != nil {
-			if xerrors.Is(err, ErrForkTooLong) {
-				// TODO: we're marking this block bad in the same way that we mark invalid blocks bad. Maybe distinguish?
-				log.Warn("adding forked chain to our bad tipset cache")
-				for _, b := range from.Blocks() {
-					syncer.bad.Add(b.Cid())
-				}
-			}
-			return nil, xerrors.Errorf("failed to sync fork: %w", err)
-		}
-
-		blockSet = append(blockSet, fork...)
+	base := blockSet[len(blockSet)-1]
+	if base.Parents() == known.Parents() {
+		// common case: receiving a block thats potentially part of the same tipset as our best block
+		return blockSet, nil
 	}
 
+	if types.CidArrsEqual(base.Parents().Cids(), known.Cids()) {
+		// common case: receiving blocks that are building on top of our best tipset
+		return blockSet, nil
+	}
+
+	// We have now ascertained that this is *not* a 'fast forward'
+	log.Warnf("(fork detected) synced header chain (%s - %d) does not link to our best block (%s - %d)", incoming.Cids(), incoming.Height(), known.Cids(), known.Height())
+	fork, err := syncer.syncFork(ctx, base, known)
+	if err != nil {
+		if xerrors.Is(err, ErrForkTooLong) || xerrors.Is(err, ErrForkCheckpoint) {
+			// TODO: we're marking this block bad in the same way that we mark invalid blocks bad. Maybe distinguish?
+			log.Warn("adding forked chain to our bad tipset cache")
+			for _, b := range incoming.Blocks() {
+				syncer.bad.Add(b.Cid(), NewBadBlockReason(incoming.Cids(), "fork past finality"))
+			}
+		}
+		return nil, xerrors.Errorf("failed to sync fork: %w", err)
+	}
+
+	blockSet = append(blockSet, fork...)
+
 	return blockSet, nil
 }
 
 var ErrForkTooLong = fmt.Errorf("fork longer than threshold")
+var ErrForkCheckpoint = fmt.Errorf("fork would require us to diverge from checkpointed block")
 
-func (syncer *Syncer) syncFork(ctx context.Context, from *types.TipSet, to *types.TipSet) ([]*types.TipSet, error) {
-	tips, err := syncer.Bsync.GetBlocks(ctx, from.Parents(), build.ForkLengthThreshold)
+// syncFork tries to obtain the chain fragment that links a fork into a common
+// ancestor in our view of the chain.
+//
+// If the fork is too long (build.ForkLengthThreshold), or would cause us to diverge from the checkpoint (ErrForkCheckpoint),
+// we add the entire subchain to the denylist. Else, we find the common ancestor, and add the missing chain
+// fragment until the fork point to the returned []TipSet.
+func (syncer *Syncer) syncFork(ctx context.Context, incoming *types.TipSet, known *types.TipSet) ([]*types.TipSet, error) {
+
+	chkpt := syncer.GetCheckpoint()
+	if known.Key() == chkpt {
+		return nil, ErrForkCheckpoint
+	}
+
+	// TODO: Does this mean we always ask for ForkLengthThreshold blocks from the network, even if we just need, like, 2?
+	// Would it not be better to ask in smaller chunks, given that an ~ForkLengthThreshold is very rare?
+	tips, err := syncer.Exchange.GetBlocks(ctx, incoming.Parents(), int(build.ForkLengthThreshold))
 	if err != nil {
 		return nil, err
 	}
 
-	nts, err := syncer.store.LoadTipSet(to.Parents())
+	nts, err := syncer.store.LoadTipSet(known.Parents())
 	if err != nil {
 		return nil, xerrors.Errorf("failed to load next local tipset: %w", err)
 	}
@@ -996,7 +1426,7 @@ func (syncer *Syncer) syncFork(ctx context.Context, from *types.TipSet, to *type
 			if !syncer.Genesis.Equals(nts) {
 				return nil, xerrors.Errorf("somehow synced chain that linked back to a different genesis (bad genesis: %s)", nts.Key())
 			}
-			return nil, xerrors.Errorf("synced chain forked at genesis, refusing to sync")
+			return nil, xerrors.Errorf("synced chain forked at genesis, refusing to sync; incoming: %s", incoming.Cids())
 		}
 
 		if nts.Equals(tips[cur]) {
@@ -1006,12 +1436,18 @@ func (syncer *Syncer) syncFork(ctx context.Context, from *types.TipSet, to *type
 		if nts.Height() < tips[cur].Height() {
 			cur++
 		} else {
+			// We will be forking away from nts, check that it isn't checkpointed
+			if nts.Key() == chkpt {
+				return nil, ErrForkCheckpoint
+			}
+
 			nts, err = syncer.store.LoadTipSet(nts.Parents())
 			if err != nil {
 				return nil, xerrors.Errorf("loading next local tipset: %w", err)
 			}
 		}
 	}
+
 	return nil, ErrForkTooLong
 }
 
@@ -1026,6 +1462,7 @@ func (syncer *Syncer) syncMessagesAndCheckState(ctx context.Context, headers []*
 			return xerrors.Errorf("message processing failed: %w", err)
 		}
 
+		stats.Record(ctx, metrics.ChainNodeWorkerHeight.M(int64(fts.TipSet().Height())))
 		ss.SetHeight(fts.TipSet().Height())
 
 		return nil
@@ -1034,12 +1471,12 @@ func (syncer *Syncer) syncMessagesAndCheckState(ctx context.Context, headers []*
 
 // fills out each of the given tipsets with messages and calls the callback with it
 func (syncer *Syncer) iterFullTipsets(ctx context.Context, headers []*types.TipSet, cb func(context.Context, *store.FullTipSet) error) error {
+	ss := extractSyncState(ctx)
 	ctx, span := trace.StartSpan(ctx, "iterFullTipsets")
 	defer span.End()
 
 	span.AddAttributes(trace.Int64Attribute("num_headers", int64(len(headers))))
 
-	windowSize := 200
 	for i := len(headers) - 1; i >= 0; {
 		fts, err := syncer.store.TryFillTipSet(headers[i])
 		if err != nil {
@@ -1053,30 +1490,32 @@ func (syncer *Syncer) iterFullTipsets(ctx context.Context, headers []*types.TipS
 			continue
 		}
 
-		batchSize := windowSize
+		batchSize := concurrentSyncRequests * syncRequestBatchSize
 		if i < batchSize {
-			batchSize = i
+			batchSize = i + 1
 		}
 
-		next := headers[i-batchSize]
-		bstips, err := syncer.Bsync.GetChainMessages(ctx, next, uint64(batchSize+1))
-		if err != nil {
-			return xerrors.Errorf("message processing failed: %w", err)
+		ss.SetStage(api.StageFetchingMessages)
+		startOffset := i + 1 - batchSize
+		bstout, batchErr := syncer.fetchMessages(ctx, headers[startOffset:startOffset+batchSize], startOffset)
+		ss.SetStage(api.StageMessages)
+
+		if batchErr != nil {
+			return xerrors.Errorf("failed to fetch messages: %w", err)
 		}
 
-		for bsi := 0; bsi < len(bstips); bsi++ {
+		for bsi := 0; bsi < len(bstout); bsi++ {
 			// temp storage so we don't persist data we dont want to
-			ds := dstore.NewMapDatastore()
-			bs := bstore.NewBlockstore(ds)
-			blks := amt.WrapBlockstore(bs)
+			bs := bstore.NewTemporary()
+			blks := cbor.NewCborStore(bs)
 
 			this := headers[i-bsi]
-			bstip := bstips[len(bstips)-(bsi+1)]
-			fts, err := zipTipSetAndMessages(blks, this, bstip.BlsMessages, bstip.SecpkMessages, bstip.BlsMsgIncludes, bstip.SecpkMsgIncludes)
+			bstip := bstout[len(bstout)-(bsi+1)]
+			fts, err := zipTipSetAndMessages(blks, this, bstip.Bls, bstip.Secpk, bstip.BlsIncludes, bstip.SecpkIncludes)
 			if err != nil {
 				log.Warnw("zipping failed", "error", err, "bsi", bsi, "i", i,
-					"height", this.Height(), "bstip-height", bstip.Blocks[0].Height,
-					"bstips", bstips, "next-height", i+batchSize)
+					"height", this.Height(),
+					"next-height", i+batchSize)
 				return xerrors.Errorf("message processing failed: %w", err)
 			}
 
@@ -1084,31 +1523,101 @@ func (syncer *Syncer) iterFullTipsets(ctx context.Context, headers []*types.TipS
 				return err
 			}
 
-			if err := persistMessages(bs, bstip); err != nil {
+			if err := persistMessages(ctx, bs, bstip); err != nil {
 				return err
 			}
 
-			if err := copyBlockstore(bs, syncer.store.Blockstore()); err != nil {
+			if err := copyBlockstore(ctx, bs, syncer.store.Blockstore()); err != nil {
 				return xerrors.Errorf("message processing failed: %w", err)
 			}
 		}
-		i -= windowSize
+
+		i -= batchSize
 	}
 
 	return nil
 }
 
-func persistMessages(bs bstore.Blockstore, bst *blocksync.BSTipSet) error {
-	for _, m := range bst.BlsMessages {
+func (syncer *Syncer) fetchMessages(ctx context.Context, headers []*types.TipSet, startOffset int) ([]*exchange.CompactedMessages, error) {
+	batchSize := len(headers)
+	batch := make([]*exchange.CompactedMessages, batchSize)
+
+	var wg sync.WaitGroup
+	var mx sync.Mutex
+	var batchErr error
+
+	start := build.Clock.Now()
+
+	for j := 0; j < batchSize; j += syncRequestBatchSize {
+		wg.Add(1)
+		go func(j int) {
+			defer wg.Done()
+
+			nreq := syncRequestBatchSize
+			if j+nreq > batchSize {
+				nreq = batchSize - j
+			}
+
+			failed := false
+			for offset := 0; !failed && offset < nreq; {
+				nextI := j + offset
+				lastI := j + nreq
+
+				var requestErr error
+				var requestResult []*exchange.CompactedMessages
+				for retry := 0; requestResult == nil && retry < syncRequestRetries; retry++ {
+					if retry > 0 {
+						log.Infof("fetching messages at %d (retry %d)", startOffset+nextI, retry)
+					} else {
+						log.Infof("fetching messages at %d", startOffset+nextI)
+					}
+
+					result, err := syncer.Exchange.GetChainMessages(ctx, headers[nextI:lastI])
+					if err != nil {
+						requestErr = multierror.Append(requestErr, err)
+					} else {
+						requestResult = result
+					}
+				}
+
+				mx.Lock()
+				if requestResult != nil {
+					copy(batch[j+offset:], requestResult)
+					offset += len(requestResult)
+				} else {
+					log.Errorf("error fetching messages at %d: %s", nextI, requestErr)
+					batchErr = multierror.Append(batchErr, requestErr)
+					failed = true
+				}
+				mx.Unlock()
+			}
+		}(j)
+	}
+	wg.Wait()
+
+	if batchErr != nil {
+		return nil, batchErr
+	}
+
+	log.Infof("fetching messages for %d tipsets at %d done; took %s", batchSize, startOffset, build.Clock.Since(start))
+
+	return batch, nil
+}
+
+func persistMessages(ctx context.Context, bs bstore.Blockstore, bst *exchange.CompactedMessages) error {
+	_, span := trace.StartSpan(ctx, "persistMessages")
+	defer span.End()
+
+	for _, m := range bst.Bls {
 		//log.Infof("putting BLS message: %s", m.Cid())
 		if _, err := store.PutMessage(bs, m); err != nil {
 			log.Errorf("failed to persist messages: %+v", err)
 			return xerrors.Errorf("BLS message processing failed: %w", err)
 		}
 	}
-	for _, m := range bst.SecpkMessages {
-		if m.Signature.Type != types.KTSecp256k1 {
-			return xerrors.Errorf("unknown signature type on message %s: %q", m.Cid(), m.Signature.TypeCode)
+	for _, m := range bst.Secpk {
+		if m.Signature.Type != crypto.SigTypeSecp256k1 {
+			return xerrors.Errorf("unknown signature type on message %s: %q", m.Cid(), m.Signature.Type)
 		}
 		//log.Infof("putting secp256k1 message: %s", m.Cid())
 		if _, err := store.PutMessage(bs, m); err != nil {
@@ -1120,6 +1629,25 @@ func persistMessages(bs bstore.Blockstore, bst *blocksync.BSTipSet) error {
 	return nil
 }
 
+// collectChain tries to advance our view of the chain to the purported head.
+//
+// It goes through various stages:
+//
+//  1. StageHeaders: we proceed in the sync process by requesting block headers
+//     from our peers, moving back from their heads, until we reach a tipset
+//     that we have in common (such a common tipset must exist, thought it may
+//     simply be the genesis block).
+//
+//     If the common tipset is our head, we treat the sync as a "fast-forward",
+//     else we must drop part of our chain to connect to the peer's head
+//     (referred to as "forking").
+//
+//	2. StagePersistHeaders: now that we've collected the missing headers,
+//     augmented by those on the other side of a fork, we persist them to the
+//     BlockStore.
+//
+//  3. StageMessages: having acquired the headers and found a common tipset,
+//     we then move forward, requesting the full blocks, including the messages.
 func (syncer *Syncer) collectChain(ctx context.Context, ts *types.TipSet) error {
 	ctx, span := trace.StartSpan(ctx, "collectChain")
 	defer span.End()
@@ -1141,7 +1669,7 @@ func (syncer *Syncer) collectChain(ctx context.Context, ts *types.TipSet) error
 
 	ss.SetStage(api.StagePersistHeaders)
 
-	toPersist := make([]*types.BlockHeader, 0, len(headers)*build.BlocksPerEpoch)
+	toPersist := make([]*types.BlockHeader, 0, len(headers)*int(build.BlocksPerEpoch))
 	for _, ts := range headers {
 		toPersist = append(toPersist, ts.Blocks()...)
 	}
@@ -1166,22 +1694,60 @@ func (syncer *Syncer) collectChain(ctx context.Context, ts *types.TipSet) error
 	return nil
 }
 
-func VerifyElectionPoStVRF(ctx context.Context, evrf []byte, rand []byte, worker, miner address.Address) error {
-	if err := gen.VerifyVRF(ctx, worker, miner, gen.DSepElectionPost, rand, evrf); err != nil {
-		return xerrors.Errorf("failed to verify post_randomness vrf: %w", err)
+func VerifyElectionPoStVRF(ctx context.Context, worker address.Address, rand []byte, evrf []byte) error {
+	if build.InsecurePoStValidation {
+		return nil
 	}
-
-	return nil
+	return gen.VerifyVRF(ctx, worker, rand, evrf)
 }
 
 func (syncer *Syncer) State() []SyncerState {
-	var out []SyncerState
-	for _, ss := range syncer.syncmgr.syncStates {
-		out = append(out, ss.Snapshot())
-	}
-	return out
+	return syncer.syncmgr.State()
 }
 
+// MarkBad manually adds a block to the "bad blocks" cache.
 func (syncer *Syncer) MarkBad(blk cid.Cid) {
-	syncer.bad.Add(blk)
+	syncer.bad.Add(blk, NewBadBlockReason([]cid.Cid{blk}, "manually marked bad"))
+}
+
+// UnmarkBad manually adds a block to the "bad blocks" cache.
+func (syncer *Syncer) UnmarkBad(blk cid.Cid) {
+	syncer.bad.Remove(blk)
+}
+
+func (syncer *Syncer) CheckBadBlockCache(blk cid.Cid) (string, bool) {
+	bbr, ok := syncer.bad.Has(blk)
+	return bbr.String(), ok
+}
+
+func (syncer *Syncer) getLatestBeaconEntry(_ context.Context, ts *types.TipSet) (*types.BeaconEntry, error) {
+	cur := ts
+	for i := 0; i < 20; i++ {
+		cbe := cur.Blocks()[0].BeaconEntries
+		if len(cbe) > 0 {
+			return &cbe[len(cbe)-1], nil
+		}
+
+		if cur.Height() == 0 {
+			return nil, xerrors.Errorf("made it back to genesis block without finding beacon entry")
+		}
+
+		next, err := syncer.store.LoadTipSet(cur.Parents())
+		if err != nil {
+			return nil, xerrors.Errorf("failed to load parents when searching back for latest beacon entry: %w", err)
+		}
+		cur = next
+	}
+
+	return nil, xerrors.Errorf("found NO beacon entries in the 20 latest tipsets")
+}
+
+func (syncer *Syncer) IsEpochBeyondCurrMax(epoch abi.ChainEpoch) bool {
+	g, err := syncer.store.GetGenesis()
+	if err != nil {
+		return false
+	}
+
+	now := uint64(build.Clock.Now().Unix())
+	return epoch > (abi.ChainEpoch((now-g.Timestamp)/build.BlockDelaySecs) + MaxHeightDrift)
 }
diff --git a/chain/sync_manager.go b/chain/sync_manager.go
index e00063961..811092bc7 100644
--- a/chain/sync_manager.go
+++ b/chain/sync_manager.go
@@ -20,7 +20,28 @@ const (
 
 type SyncFunc func(context.Context, *types.TipSet) error
 
-type SyncManager struct {
+// SyncManager manages the chain synchronization process, both at bootstrap time
+// and during ongoing operation.
+//
+// It receives candidate chain heads in the form of tipsets from peers,
+// and schedules them onto sync workers, deduplicating processing for
+// already-active syncs.
+type SyncManager interface {
+	// Start starts the SyncManager.
+	Start()
+
+	// Stop stops the SyncManager.
+	Stop()
+
+	// SetPeerHead informs the SyncManager that the supplied peer reported the
+	// supplied tipset.
+	SetPeerHead(ctx context.Context, p peer.ID, ts *types.TipSet)
+
+	// State retrieves the state of the sync workers.
+	State() []SyncerState
+}
+
+type syncManager struct {
 	lk        sync.Mutex
 	peerHeads map[peer.ID]*types.TipSet
 
@@ -35,6 +56,7 @@ type SyncManager struct {
 
 	syncStates []*SyncerState
 
+	// Normally this handler is set to `(*Syncer).Sync()`.
 	doSync func(context.Context, *types.TipSet) error
 
 	stop chan struct{}
@@ -47,6 +69,8 @@ type SyncManager struct {
 	workerChan     chan *types.TipSet
 }
 
+var _ SyncManager = (*syncManager)(nil)
+
 type syncResult struct {
 	ts      *types.TipSet
 	success bool
@@ -54,8 +78,8 @@ type syncResult struct {
 
 const syncWorkerCount = 3
 
-func NewSyncManager(sync SyncFunc) *SyncManager {
-	return &SyncManager{
+func NewSyncManager(sync SyncFunc) SyncManager {
+	return &syncManager{
 		bspThresh:       1,
 		peerHeads:       make(map[peer.ID]*types.TipSet),
 		syncTargets:     make(chan *types.TipSet),
@@ -68,18 +92,18 @@ func NewSyncManager(sync SyncFunc) *SyncManager {
 	}
 }
 
-func (sm *SyncManager) Start() {
+func (sm *syncManager) Start() {
 	go sm.syncScheduler()
 	for i := 0; i < syncWorkerCount; i++ {
 		go sm.syncWorker(i)
 	}
 }
 
-func (sm *SyncManager) Stop() {
+func (sm *syncManager) Stop() {
 	close(sm.stop)
 }
 
-func (sm *SyncManager) SetPeerHead(ctx context.Context, p peer.ID, ts *types.TipSet) {
+func (sm *syncManager) SetPeerHead(ctx context.Context, p peer.ID, ts *types.TipSet) {
 	sm.lk.Lock()
 	defer sm.lk.Unlock()
 	sm.peerHeads[p] = ts
@@ -104,6 +128,14 @@ func (sm *SyncManager) SetPeerHead(ctx context.Context, p peer.ID, ts *types.Tip
 	sm.incomingTipSets <- ts
 }
 
+func (sm *syncManager) State() []SyncerState {
+	ret := make([]SyncerState, 0, len(sm.syncStates))
+	for _, s := range sm.syncStates {
+		ret = append(ret, s.Snapshot())
+	}
+	return ret
+}
+
 type syncBucketSet struct {
 	buckets []*syncTargetBucket
 }
@@ -233,7 +265,7 @@ func (stb *syncTargetBucket) heaviestTipSet() *types.TipSet {
 	return best
 }
 
-func (sm *SyncManager) selectSyncTarget() (*types.TipSet, error) {
+func (sm *syncManager) selectSyncTarget() (*types.TipSet, error) {
 	var buckets syncBucketSet
 
 	var peerHeads []*types.TipSet
@@ -257,7 +289,7 @@ func (sm *SyncManager) selectSyncTarget() (*types.TipSet, error) {
 	return buckets.Heaviest(), nil
 }
 
-func (sm *SyncManager) syncScheduler() {
+func (sm *syncManager) syncScheduler() {
 
 	for {
 		select {
@@ -279,8 +311,8 @@ func (sm *SyncManager) syncScheduler() {
 	}
 }
 
-func (sm *SyncManager) scheduleIncoming(ts *types.TipSet) {
-	log.Info("scheduling incoming tipset sync: ", ts.Cids())
+func (sm *syncManager) scheduleIncoming(ts *types.TipSet) {
+	log.Debug("scheduling incoming tipset sync: ", ts.Cids())
 	if sm.getBootstrapState() == BSStateSelected {
 		sm.setBootstrapState(BSStateScheduled)
 		sm.syncTargets <- ts
@@ -327,10 +359,11 @@ func (sm *SyncManager) scheduleIncoming(ts *types.TipSet) {
 	}
 }
 
-func (sm *SyncManager) scheduleProcessResult(res *syncResult) {
+func (sm *syncManager) scheduleProcessResult(res *syncResult) {
 	if res.success && sm.getBootstrapState() != BSStateComplete {
 		sm.setBootstrapState(BSStateComplete)
 	}
+
 	delete(sm.activeSyncs, res.ts.Key())
 	relbucket := sm.activeSyncTips.PopRelated(res.ts)
 	if relbucket != nil {
@@ -342,12 +375,12 @@ func (sm *SyncManager) scheduleProcessResult(res *syncResult) {
 				sm.syncQueue.buckets = append(sm.syncQueue.buckets, relbucket)
 			}
 			return
-		} else {
-			// TODO: this is the case where we try to sync a chain, and
-			// fail, and we have more blocks on top of that chain that
-			// have come in since.  The question is, should we try to
-			// sync these? or just drop them?
 		}
+		// TODO: this is the case where we try to sync a chain, and
+		// fail, and we have more blocks on top of that chain that
+		// have come in since.  The question is, should we try to
+		// sync these? or just drop them?
+		log.Error("failed to sync chain but have new unconnected blocks from chain")
 	}
 
 	if sm.nextSyncTarget == nil && !sm.syncQueue.Empty() {
@@ -359,7 +392,7 @@ func (sm *SyncManager) scheduleProcessResult(res *syncResult) {
 	}
 }
 
-func (sm *SyncManager) scheduleWorkSent() {
+func (sm *syncManager) scheduleWorkSent() {
 	hts := sm.nextSyncTarget.heaviestTipSet()
 	sm.activeSyncs[hts.Key()] = hts
 
@@ -371,7 +404,7 @@ func (sm *SyncManager) scheduleWorkSent() {
 	}
 }
 
-func (sm *SyncManager) syncWorker(id int) {
+func (sm *syncManager) syncWorker(id int) {
 	ss := &SyncerState{}
 	sm.syncStates[id] = ss
 	for {
@@ -396,7 +429,7 @@ func (sm *SyncManager) syncWorker(id int) {
 	}
 }
 
-func (sm *SyncManager) syncedPeerCount() int {
+func (sm *syncManager) syncedPeerCount() int {
 	var count int
 	for _, ts := range sm.peerHeads {
 		if ts.Height() > 0 {
@@ -406,19 +439,19 @@ func (sm *SyncManager) syncedPeerCount() int {
 	return count
 }
 
-func (sm *SyncManager) getBootstrapState() int {
+func (sm *syncManager) getBootstrapState() int {
 	sm.bssLk.Lock()
 	defer sm.bssLk.Unlock()
 	return sm.bootstrapState
 }
 
-func (sm *SyncManager) setBootstrapState(v int) {
+func (sm *syncManager) setBootstrapState(v int) {
 	sm.bssLk.Lock()
 	defer sm.bssLk.Unlock()
 	sm.bootstrapState = v
 }
 
-func (sm *SyncManager) IsBootstrapped() bool {
+func (sm *syncManager) IsBootstrapped() bool {
 	sm.bssLk.Lock()
 	defer sm.bssLk.Unlock()
 	return sm.bootstrapState == BSStateComplete
diff --git a/chain/sync_manager_test.go b/chain/sync_manager_test.go
index ca2ced856..269b3a62e 100644
--- a/chain/sync_manager_test.go
+++ b/chain/sync_manager_test.go
@@ -17,7 +17,7 @@ type syncOp struct {
 	done func()
 }
 
-func runSyncMgrTest(t *testing.T, tname string, thresh int, tf func(*testing.T, *SyncManager, chan *syncOp)) {
+func runSyncMgrTest(t *testing.T, tname string, thresh int, tf func(*testing.T, *syncManager, chan *syncOp)) {
 	syncTargets := make(chan *syncOp)
 	sm := NewSyncManager(func(ctx context.Context, ts *types.TipSet) error {
 		ch := make(chan struct{})
@@ -27,7 +27,7 @@ func runSyncMgrTest(t *testing.T, tname string, thresh int, tf func(*testing.T,
 		}
 		<-ch
 		return nil
-	})
+	}).(*syncManager)
 	sm.bspThresh = thresh
 
 	sm.Start()
@@ -77,12 +77,12 @@ func TestSyncManager(t *testing.T) {
 	c3 := mock.TipSet(mock.MkBlock(b, 3, 5))
 	d := mock.TipSet(mock.MkBlock(c1, 4, 5))
 
-	runSyncMgrTest(t, "testBootstrap", 1, func(t *testing.T, sm *SyncManager, stc chan *syncOp) {
+	runSyncMgrTest(t, "testBootstrap", 1, func(t *testing.T, sm *syncManager, stc chan *syncOp) {
 		sm.SetPeerHead(ctx, "peer1", c1)
 		assertGetSyncOp(t, stc, c1)
 	})
 
-	runSyncMgrTest(t, "testBootstrap", 2, func(t *testing.T, sm *SyncManager, stc chan *syncOp) {
+	runSyncMgrTest(t, "testBootstrap", 2, func(t *testing.T, sm *syncManager, stc chan *syncOp) {
 		sm.SetPeerHead(ctx, "peer1", c1)
 		assertNoOp(t, stc)
 
@@ -90,7 +90,7 @@ func TestSyncManager(t *testing.T) {
 		assertGetSyncOp(t, stc, c1)
 	})
 
-	runSyncMgrTest(t, "testSyncAfterBootstrap", 1, func(t *testing.T, sm *SyncManager, stc chan *syncOp) {
+	runSyncMgrTest(t, "testSyncAfterBootstrap", 1, func(t *testing.T, sm *syncManager, stc chan *syncOp) {
 		sm.SetPeerHead(ctx, "peer1", b)
 		assertGetSyncOp(t, stc, b)
 
@@ -101,7 +101,7 @@ func TestSyncManager(t *testing.T) {
 		assertGetSyncOp(t, stc, c2)
 	})
 
-	runSyncMgrTest(t, "testCoalescing", 1, func(t *testing.T, sm *SyncManager, stc chan *syncOp) {
+	runSyncMgrTest(t, "testCoalescing", 1, func(t *testing.T, sm *syncManager, stc chan *syncOp) {
 		sm.SetPeerHead(ctx, "peer1", a)
 		assertGetSyncOp(t, stc, a)
 
@@ -122,7 +122,7 @@ func TestSyncManager(t *testing.T) {
 		assertGetSyncOp(t, stc, d)
 	})
 
-	runSyncMgrTest(t, "testSyncIncomingTipset", 1, func(t *testing.T, sm *SyncManager, stc chan *syncOp) {
+	runSyncMgrTest(t, "testSyncIncomingTipset", 1, func(t *testing.T, sm *syncManager, stc chan *syncOp) {
 		sm.SetPeerHead(ctx, "peer1", a)
 		assertGetSyncOp(t, stc, a)
 
diff --git a/chain/sync_test.go b/chain/sync_test.go
index c9b8e7bbb..7a839be2b 100644
--- a/chain/sync_test.go
+++ b/chain/sync_test.go
@@ -7,17 +7,27 @@ import (
 	"testing"
 	"time"
 
-	logging "github.com/ipfs/go-log"
+	"github.com/filecoin-project/specs-actors/actors/runtime/proof"
+
+	"github.com/ipfs/go-cid"
+
+	ds "github.com/ipfs/go-datastore"
+	logging "github.com/ipfs/go-log/v2"
 	"github.com/libp2p/go-libp2p-core/peer"
 	mocknet "github.com/libp2p/go-libp2p/p2p/net/mock"
 	"github.com/stretchr/testify/require"
 
 	"github.com/filecoin-project/go-address"
+	"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/actors/policy"
 	"github.com/filecoin-project/lotus/chain/gen"
+	"github.com/filecoin-project/lotus/chain/gen/slashfilter"
 	"github.com/filecoin-project/lotus/chain/store"
 	"github.com/filecoin-project/lotus/chain/types"
+	mocktypes "github.com/filecoin-project/lotus/chain/types/mock"
 	"github.com/filecoin-project/lotus/node"
 	"github.com/filecoin-project/lotus/node/impl"
 	"github.com/filecoin-project/lotus/node/modules"
@@ -26,9 +36,13 @@ import (
 
 func init() {
 	build.InsecurePoStValidation = true
-	os.Setenv("TRUST_PARAMS", "1")
-	build.SectorSizes = []uint64{1024}
-	build.MinimumMinerPower = 1024
+	err := os.Setenv("TRUST_PARAMS", "1")
+	if err != nil {
+		panic(err)
+	}
+	policy.SetSupportedProofTypes(abi.RegisteredSealProof_StackedDrg2KiBV1)
+	policy.SetConsensusMinerMinPower(abi.NewStoragePower(2048))
+	policy.SetMinVerifiedDealSize(abi.NewStoragePower(256))
 }
 
 const source = 0
@@ -73,7 +87,7 @@ func prepSyncTest(t testing.TB, h int) *syncTestUtil {
 
 	g, err := gen.NewGenerator()
 	if err != nil {
-		t.Fatal(err)
+		t.Fatalf("%+v", err)
 	}
 
 	ctx, cancel := context.WithCancel(context.Background())
@@ -158,10 +172,9 @@ func (tu *syncTestUtil) pushTsExpectErr(to int, fts *store.FullTipSet, experr bo
 			require.NoError(tu.t, err)
 		}
 	}
-
 }
 
-func (tu *syncTestUtil) mineOnBlock(blk *store.FullTipSet, src int, miners []int, wait, fail bool) *store.FullTipSet {
+func (tu *syncTestUtil) mineOnBlock(blk *store.FullTipSet, to int, miners []int, wait, fail bool, msgs [][]*types.SignedMessage) *store.FullTipSet {
 	if miners == nil {
 		for i := range tu.g.Miners {
 			miners = append(miners, i)
@@ -175,37 +188,31 @@ func (tu *syncTestUtil) mineOnBlock(blk *store.FullTipSet, src int, miners []int
 
 	fmt.Println("Miner mining block: ", maddrs)
 
-	mts, err := tu.g.NextTipSetFromMiners(blk.TipSet(), maddrs)
-	require.NoError(tu.t, err)
-
-	if fail {
-		tu.pushTsExpectErr(src, mts.TipSet, true)
+	var nts *store.FullTipSet
+	var err error
+	if msgs != nil {
+		nts, err = tu.g.NextTipSetFromMinersWithMessages(blk.TipSet(), maddrs, msgs)
+		require.NoError(tu.t, err)
 	} else {
-		tu.pushFtsAndWait(src, mts.TipSet, wait)
+		mt, err := tu.g.NextTipSetFromMiners(blk.TipSet(), maddrs)
+		require.NoError(tu.t, err)
+		nts = mt.TipSet
 	}
 
-	return mts.TipSet
+	if fail {
+		tu.pushTsExpectErr(to, nts, true)
+	} else {
+		tu.pushFtsAndWait(to, nts, wait)
+	}
+
+	return nts
 }
 
 func (tu *syncTestUtil) mineNewBlock(src int, miners []int) {
-	mts := tu.mineOnBlock(tu.g.CurTipset, src, miners, true, false)
+	mts := tu.mineOnBlock(tu.g.CurTipset, src, miners, true, false, nil)
 	tu.g.CurTipset = mts
 }
 
-func fblkToBlkMsg(fb *types.FullBlock) *types.BlockMsg {
-	out := &types.BlockMsg{
-		Header: fb.Header,
-	}
-
-	for _, msg := range fb.BlsMessages {
-		out.BlsMessages = append(out.BlsMessages, msg.Cid())
-	}
-	for _, msg := range fb.SecpkMessages {
-		out.SecpkMessages = append(out.SecpkMessages, msg.Cid())
-	}
-	return out
-}
-
 func (tu *syncTestUtil) addSourceNode(gen int) {
 	if tu.genesis != nil {
 		tu.t.Fatal("source node already exists")
@@ -321,6 +328,36 @@ func (tu *syncTestUtil) compareSourceState(with int) {
 	}
 }
 
+func (tu *syncTestUtil) assertBad(node int, ts *types.TipSet) {
+	for _, blk := range ts.Cids() {
+		rsn, err := tu.nds[node].SyncCheckBad(context.TODO(), blk)
+		require.NoError(tu.t, err)
+		require.True(tu.t, len(rsn) != 0)
+	}
+}
+
+func (tu *syncTestUtil) getHead(node int) *types.TipSet {
+	ts, err := tu.nds[node].ChainHead(context.TODO())
+	require.NoError(tu.t, err)
+	return ts
+}
+
+func (tu *syncTestUtil) checkpointTs(node int, tsk types.TipSetKey) {
+	require.NoError(tu.t, tu.nds[node].SyncCheckpoint(context.TODO(), tsk))
+}
+
+func (tu *syncTestUtil) waitUntilNodeHasTs(node int, tsk types.TipSetKey) {
+	for {
+		_, err := tu.nds[node].ChainGetTipSet(context.TODO(), tsk)
+		if err != nil {
+			break
+		}
+	}
+
+	// Time to allow for syncing and validation
+	time.Sleep(2 * time.Second)
+}
+
 func (tu *syncTestUtil) waitUntilSync(from, to int) {
 	target, err := tu.nds[from].ChainHead(tu.ctx)
 	if err != nil {
@@ -398,21 +435,23 @@ func TestSyncBadTimestamp(t *testing.T) {
 	tu.waitUntilSync(0, client)
 
 	base := tu.g.CurTipset
-	tu.g.Timestamper = func(pts *types.TipSet, tl uint64) uint64 {
-		return pts.MinTimestamp() + (build.BlockDelay / 2)
+	tu.g.Timestamper = func(pts *types.TipSet, tl abi.ChainEpoch) uint64 {
+		return pts.MinTimestamp() + (build.BlockDelaySecs / 2)
 	}
 
 	fmt.Println("BASE: ", base.Cids())
 	tu.printHeads()
 
-	a1 := tu.mineOnBlock(base, 0, nil, false, true)
+	a1 := tu.mineOnBlock(base, 0, nil, false, true, nil)
 
 	tu.g.Timestamper = nil
-	tu.g.ResyncBankerNonce(a1.TipSet())
+	require.NoError(t, tu.g.ResyncBankerNonce(a1.TipSet()))
+
+	tu.nds[0].(*impl.FullNodeAPI).SlashFilter = slashfilter.New(ds.NewMapDatastore())
 
 	fmt.Println("After mine bad block!")
 	tu.printHeads()
-	a2 := tu.mineOnBlock(base, 0, nil, true, false)
+	a2 := tu.mineOnBlock(base, 0, nil, true, false, nil)
 
 	tu.waitUntilSync(0, client)
 
@@ -424,6 +463,41 @@ func TestSyncBadTimestamp(t *testing.T) {
 	}
 }
 
+type badWpp struct{}
+
+func (wpp badWpp) GenerateCandidates(context.Context, abi.PoStRandomness, uint64) ([]uint64, error) {
+	return []uint64{1}, nil
+}
+
+func (wpp badWpp) ComputeProof(context.Context, []proof.SectorInfo, abi.PoStRandomness) ([]proof.PoStProof, error) {
+	return []proof.PoStProof{
+		{
+			PoStProof:  abi.RegisteredPoStProof_StackedDrgWinning2KiBV1,
+			ProofBytes: []byte("evil"),
+		},
+	}, nil
+}
+
+func TestSyncBadWinningPoSt(t *testing.T) {
+	H := 15
+	tu := prepSyncTest(t, H)
+
+	client := tu.addClientNode()
+
+	require.NoError(t, tu.mn.LinkAll())
+	tu.connect(client, 0)
+	tu.waitUntilSync(0, client)
+
+	base := tu.g.CurTipset
+
+	// both miners now produce invalid winning posts
+	tu.g.SetWinningPoStProver(tu.g.Miners[0], &badWpp{})
+	tu.g.SetWinningPoStProver(tu.g.Miners[1], &badWpp{})
+
+	// now ensure that new blocks are not accepted
+	tu.mineOnBlock(base, client, nil, false, true, nil)
+}
+
 func (tu *syncTestUtil) loadChainToNode(to int) {
 	// utility to simulate incoming blocks without miner process
 	// TODO: should call syncer directly, this won't work correctly in all cases
@@ -466,16 +540,16 @@ func TestSyncFork(t *testing.T) {
 	fmt.Println("Mining base: ", base.TipSet().Cids(), base.TipSet().Height())
 
 	// The two nodes fork at this point into 'a' and 'b'
-	a1 := tu.mineOnBlock(base, p1, []int{0}, true, false)
-	a := tu.mineOnBlock(a1, p1, []int{0}, true, false)
-	a = tu.mineOnBlock(a, p1, []int{0}, true, false)
+	a1 := tu.mineOnBlock(base, p1, []int{0}, true, false, nil)
+	a := tu.mineOnBlock(a1, p1, []int{0}, true, false, nil)
+	a = tu.mineOnBlock(a, p1, []int{0}, true, false, nil)
 
-	tu.g.ResyncBankerNonce(a1.TipSet())
+	require.NoError(t, tu.g.ResyncBankerNonce(a1.TipSet()))
 	// chain B will now be heaviest
-	b := tu.mineOnBlock(base, p2, []int{1}, true, false)
-	b = tu.mineOnBlock(b, p2, []int{1}, true, false)
-	b = tu.mineOnBlock(b, p2, []int{1}, true, false)
-	b = tu.mineOnBlock(b, p2, []int{1}, true, false)
+	b := tu.mineOnBlock(base, p2, []int{1}, true, false, nil)
+	b = tu.mineOnBlock(b, p2, []int{1}, true, false, nil)
+	b = tu.mineOnBlock(b, p2, []int{1}, true, false, nil)
+	b = tu.mineOnBlock(b, p2, []int{1}, true, false, nil)
 
 	fmt.Println("A: ", a.Cids(), a.TipSet().Height())
 	fmt.Println("B: ", b.Cids(), b.TipSet().Height())
@@ -490,6 +564,142 @@ func TestSyncFork(t *testing.T) {
 	phead()
 }
 
+// This test crafts a tipset with 2 blocks, A and B.
+// A and B both include _different_ messages from sender X with nonce N (where N is the correct nonce for X).
+// We can confirm that the state can be correctly computed, and that `MessagesForTipset` behaves as expected.
+func TestDuplicateNonce(t *testing.T) {
+	H := 10
+	tu := prepSyncTest(t, H)
+
+	base := tu.g.CurTipset
+
+	// Produce a message from the banker to the rcvr
+	makeMsg := func(rcvr address.Address) *types.SignedMessage {
+
+		ba, err := tu.nds[0].StateGetActor(context.TODO(), tu.g.Banker(), base.TipSet().Key())
+		require.NoError(t, err)
+		msg := types.Message{
+			To:   rcvr,
+			From: tu.g.Banker(),
+
+			Nonce: ba.Nonce,
+
+			Value: types.NewInt(1),
+
+			Method: 0,
+
+			GasLimit:   100_000_000,
+			GasFeeCap:  types.NewInt(0),
+			GasPremium: types.NewInt(0),
+		}
+
+		sig, err := tu.g.Wallet().Sign(context.TODO(), tu.g.Banker(), msg.Cid().Bytes())
+		require.NoError(t, err)
+
+		return &types.SignedMessage{
+			Message:   msg,
+			Signature: *sig,
+		}
+	}
+
+	msgs := make([][]*types.SignedMessage, 2)
+	// Each miner includes a message from the banker with the same nonce, but to different addresses
+	for k := range msgs {
+		msgs[k] = []*types.SignedMessage{makeMsg(tu.g.Miners[k])}
+	}
+
+	ts1 := tu.mineOnBlock(base, 0, []int{0, 1}, true, false, msgs)
+
+	tu.waitUntilSyncTarget(0, ts1.TipSet())
+
+	// mine another tipset
+
+	ts2 := tu.mineOnBlock(ts1, 0, []int{0, 1}, true, false, make([][]*types.SignedMessage, 2))
+	tu.waitUntilSyncTarget(0, ts2.TipSet())
+
+	var includedMsg cid.Cid
+	var skippedMsg cid.Cid
+	r0, err0 := tu.nds[0].StateGetReceipt(context.TODO(), msgs[0][0].Cid(), ts2.TipSet().Key())
+	r1, err1 := tu.nds[0].StateGetReceipt(context.TODO(), msgs[1][0].Cid(), ts2.TipSet().Key())
+
+	if err0 == nil {
+		require.Error(t, err1, "at least one of the StateGetReceipt calls should fail")
+		require.True(t, r0.ExitCode.IsSuccess())
+		includedMsg = msgs[0][0].Message.Cid()
+		skippedMsg = msgs[1][0].Message.Cid()
+	} else {
+		require.NoError(t, err1, "both the StateGetReceipt calls should not fail")
+		require.True(t, r1.ExitCode.IsSuccess())
+		includedMsg = msgs[1][0].Message.Cid()
+		skippedMsg = msgs[0][0].Message.Cid()
+	}
+
+	_, rslts, err := tu.g.StateManager().ExecutionTrace(context.TODO(), ts1.TipSet())
+	require.NoError(t, err)
+	found := false
+	for _, v := range rslts {
+		if v.Msg.Cid() == skippedMsg {
+			t.Fatal("skipped message should not be in exec trace")
+		}
+
+		if v.Msg.Cid() == includedMsg {
+			found = true
+		}
+	}
+
+	if !found {
+		t.Fatal("included message should be in exec trace")
+	}
+
+	mft, err := tu.g.ChainStore().MessagesForTipset(ts1.TipSet())
+	require.NoError(t, err)
+	require.True(t, len(mft) == 1, "only expecting one message for this tipset")
+	require.Equal(t, includedMsg, mft[0].VMMessage().Cid(), "messages for tipset didn't contain expected message")
+}
+
+// This test asserts that a block that includes a message with bad nonce can't be synced. A nonce is "bad" if it can't
+// be applied on the parent state.
+func TestBadNonce(t *testing.T) {
+	H := 10
+	tu := prepSyncTest(t, H)
+
+	base := tu.g.CurTipset
+
+	// Produce a message from the banker with a bad nonce
+	makeBadMsg := func() *types.SignedMessage {
+
+		ba, err := tu.nds[0].StateGetActor(context.TODO(), tu.g.Banker(), base.TipSet().Key())
+		require.NoError(t, err)
+		msg := types.Message{
+			To:   tu.g.Banker(),
+			From: tu.g.Banker(),
+
+			Nonce: ba.Nonce + 5,
+
+			Value: types.NewInt(1),
+
+			Method: 0,
+
+			GasLimit:   100_000_000,
+			GasFeeCap:  types.NewInt(0),
+			GasPremium: types.NewInt(0),
+		}
+
+		sig, err := tu.g.Wallet().Sign(context.TODO(), tu.g.Banker(), msg.Cid().Bytes())
+		require.NoError(t, err)
+
+		return &types.SignedMessage{
+			Message:   msg,
+			Signature: *sig,
+		}
+	}
+
+	msgs := make([][]*types.SignedMessage, 1)
+	msgs[0] = []*types.SignedMessage{makeBadMsg()}
+
+	tu.mineOnBlock(base, 0, []int{0}, true, true, msgs)
+}
+
 func BenchmarkSyncBasic(b *testing.B) {
 	for i := 0; i < b.N; i++ {
 		runSyncBenchLength(b, 100)
@@ -509,3 +719,114 @@ func runSyncBenchLength(b *testing.B, l int) {
 
 	tu.waitUntilSync(0, client)
 }
+
+func TestSyncInputs(t *testing.T) {
+	H := 10
+	tu := prepSyncTest(t, H)
+
+	p1 := tu.addClientNode()
+
+	fn := tu.nds[p1].(*impl.FullNodeAPI)
+
+	s := fn.SyncAPI.Syncer
+
+	err := s.ValidateBlock(context.TODO(), &types.FullBlock{
+		Header: &types.BlockHeader{},
+	})
+	if err == nil {
+		t.Fatal("should error on empty block")
+	}
+
+	h := mocktypes.MkBlock(nil, 123, 432)
+
+	h.ElectionProof = nil
+
+	err = s.ValidateBlock(context.TODO(), &types.FullBlock{Header: h})
+	if err == nil {
+		t.Fatal("should error on block with nil election proof")
+	}
+}
+
+func TestSyncCheckpointHead(t *testing.T) {
+	H := 10
+	tu := prepSyncTest(t, H)
+
+	p1 := tu.addClientNode()
+	p2 := tu.addClientNode()
+
+	fmt.Println("GENESIS: ", tu.g.Genesis().Cid())
+	tu.loadChainToNode(p1)
+	tu.loadChainToNode(p2)
+
+	base := tu.g.CurTipset
+	fmt.Println("Mining base: ", base.TipSet().Cids(), base.TipSet().Height())
+
+	// The two nodes fork at this point into 'a' and 'b'
+	a1 := tu.mineOnBlock(base, p1, []int{0}, true, false, nil)
+	a := tu.mineOnBlock(a1, p1, []int{0}, true, false, nil)
+	a = tu.mineOnBlock(a, p1, []int{0}, true, false, nil)
+
+	tu.waitUntilSyncTarget(p1, a.TipSet())
+	tu.checkpointTs(p1, a.TipSet().Key())
+
+	require.NoError(t, tu.g.ResyncBankerNonce(a1.TipSet()))
+	// chain B will now be heaviest
+	b := tu.mineOnBlock(base, p2, []int{1}, true, false, nil)
+	b = tu.mineOnBlock(b, p2, []int{1}, true, false, nil)
+	b = tu.mineOnBlock(b, p2, []int{1}, true, false, nil)
+	b = tu.mineOnBlock(b, p2, []int{1}, true, false, nil)
+
+	fmt.Println("A: ", a.Cids(), a.TipSet().Height())
+	fmt.Println("B: ", b.Cids(), b.TipSet().Height())
+
+	// Now for the fun part!! p1 should mark p2's head as BAD.
+
+	require.NoError(t, tu.mn.LinkAll())
+	tu.connect(p1, p2)
+	tu.waitUntilNodeHasTs(p1, b.TipSet().Key())
+	p1Head := tu.getHead(p1)
+	require.Equal(tu.t, p1Head, a.TipSet())
+	tu.assertBad(p1, b.TipSet())
+}
+
+func TestSyncCheckpointEarlierThanHead(t *testing.T) {
+	H := 10
+	tu := prepSyncTest(t, H)
+
+	p1 := tu.addClientNode()
+	p2 := tu.addClientNode()
+
+	fmt.Println("GENESIS: ", tu.g.Genesis().Cid())
+	tu.loadChainToNode(p1)
+	tu.loadChainToNode(p2)
+
+	base := tu.g.CurTipset
+	fmt.Println("Mining base: ", base.TipSet().Cids(), base.TipSet().Height())
+
+	// The two nodes fork at this point into 'a' and 'b'
+	a1 := tu.mineOnBlock(base, p1, []int{0}, true, false, nil)
+	a := tu.mineOnBlock(a1, p1, []int{0}, true, false, nil)
+	a = tu.mineOnBlock(a, p1, []int{0}, true, false, nil)
+
+	tu.waitUntilSyncTarget(p1, a.TipSet())
+	tu.checkpointTs(p1, a1.TipSet().Key())
+
+	require.NoError(t, tu.g.ResyncBankerNonce(a1.TipSet()))
+	// chain B will now be heaviest
+	b := tu.mineOnBlock(base, p2, []int{1}, true, false, nil)
+	b = tu.mineOnBlock(b, p2, []int{1}, true, false, nil)
+	b = tu.mineOnBlock(b, p2, []int{1}, true, false, nil)
+	b = tu.mineOnBlock(b, p2, []int{1}, true, false, nil)
+
+	fmt.Println("A: ", a.Cids(), a.TipSet().Height())
+	fmt.Println("B: ", b.Cids(), b.TipSet().Height())
+
+	// Now for the fun part!! p1 should mark p2's head as BAD.
+
+	require.NoError(t, tu.mn.LinkAll())
+	tu.connect(p1, p2)
+	tu.waitUntilNodeHasTs(p1, b.TipSet().Key())
+	p1Head := tu.getHead(p1)
+	require.Equal(tu.t, p1Head, a.TipSet())
+	tu.assertBad(p1, b.TipSet())
+}
diff --git a/chain/syncstate.go b/chain/syncstate.go
index 622598193..06cd5d91e 100644
--- a/chain/syncstate.go
+++ b/chain/syncstate.go
@@ -1,37 +1,22 @@
 package chain
 
 import (
-	"fmt"
 	"sync"
 	"time"
 
+	"github.com/filecoin-project/go-state-types/abi"
+
 	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain/types"
 )
 
-func SyncStageString(v api.SyncStateStage) string {
-	switch v {
-	case api.StageHeaders:
-		return "header sync"
-	case api.StagePersistHeaders:
-		return "persisting headers"
-	case api.StageMessages:
-		return "message sync"
-	case api.StageSyncComplete:
-		return "complete"
-	case api.StageSyncErrored:
-		return "error"
-	default:
-		return fmt.Sprintf("<unknown: %d>", v)
-	}
-}
-
 type SyncerState struct {
 	lk      sync.Mutex
 	Target  *types.TipSet
 	Base    *types.TipSet
 	Stage   api.SyncStateStage
-	Height  uint64
+	Height  abi.ChainEpoch
 	Message string
 	Start   time.Time
 	End     time.Time
@@ -46,7 +31,7 @@ func (ss *SyncerState) SetStage(v api.SyncStateStage) {
 	defer ss.lk.Unlock()
 	ss.Stage = v
 	if v == api.StageSyncComplete {
-		ss.End = time.Now()
+		ss.End = build.Clock.Now()
 	}
 }
 
@@ -62,11 +47,11 @@ func (ss *SyncerState) Init(base, target *types.TipSet) {
 	ss.Stage = api.StageHeaders
 	ss.Height = 0
 	ss.Message = ""
-	ss.Start = time.Now()
+	ss.Start = build.Clock.Now()
 	ss.End = time.Time{}
 }
 
-func (ss *SyncerState) SetHeight(h uint64) {
+func (ss *SyncerState) SetHeight(h abi.ChainEpoch) {
 	if ss == nil {
 		return
 	}
@@ -85,7 +70,7 @@ func (ss *SyncerState) Error(err error) {
 	defer ss.lk.Unlock()
 	ss.Message = err.Error()
 	ss.Stage = api.StageSyncErrored
-	ss.End = time.Now()
+	ss.End = build.Clock.Now()
 }
 
 func (ss *SyncerState) Snapshot() SyncerState {
diff --git a/chain/types/actor.go b/chain/types/actor.go
index a3a4418c1..eb8e05c49 100644
--- a/chain/types/actor.go
+++ b/chain/types/actor.go
@@ -1,16 +1,35 @@
 package types
 
 import (
-	"fmt"
+	"errors"
 
 	"github.com/ipfs/go-cid"
+
+	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
 )
 
-var ErrActorNotFound = fmt.Errorf("actor not found")
+var ErrActorNotFound = errors.New("actor not found")
 
 type Actor struct {
+	// Identifies the type of actor (string coded as a CID), see `chain/actors/actors.go`.
 	Code    cid.Cid
 	Head    cid.Cid
 	Nonce   uint64
 	Balance BigInt
 }
+
+func (a *Actor) IsAccountActor() bool {
+	return a.Code == builtin0.AccountActorCodeID
+}
+
+func (a *Actor) IsStorageMinerActor() bool {
+	return a.Code == builtin0.StorageMinerActorCodeID
+}
+
+func (a *Actor) IsMultisigActor() bool {
+	return a.Code == builtin0.MultisigActorCodeID
+}
+
+func (a *Actor) IsPaymentChannelActor() bool {
+	return a.Code == builtin0.PaymentChannelActorCodeID
+}
diff --git a/chain/types/ask.go b/chain/types/ask.go
deleted file mode 100644
index 42265c9dc..000000000
--- a/chain/types/ask.go
+++ /dev/null
@@ -1,27 +0,0 @@
-package types
-
-import (
-	"github.com/filecoin-project/go-address"
-	cbor "github.com/ipfs/go-ipld-cbor"
-)
-
-func init() {
-	cbor.RegisterCborType(SignedStorageAsk{})
-	cbor.RegisterCborType(StorageAsk{})
-}
-
-type SignedStorageAsk struct {
-	Ask       *StorageAsk
-	Signature *Signature
-}
-
-type StorageAsk struct {
-	// Price per GiB / Epoch
-	Price BigInt
-
-	MinPieceSize uint64
-	Miner        address.Address
-	Timestamp    uint64
-	Expiry       uint64
-	SeqNo        uint64
-}
diff --git a/chain/types/bigint.go b/chain/types/bigint.go
index 99fb7c0fb..da4857d5b 100644
--- a/chain/types/bigint.go
+++ b/chain/types/bigint.go
@@ -1,44 +1,24 @@
 package types
 
 import (
-	"encoding/json"
 	"fmt"
-	"io"
 	"math/big"
 
-	"github.com/filecoin-project/lotus/build"
-	cbor "github.com/ipfs/go-ipld-cbor"
-	"github.com/polydawn/refmt/obj/atlas"
+	big2 "github.com/filecoin-project/go-state-types/big"
 
-	cbg "github.com/whyrusleeping/cbor-gen"
-	"golang.org/x/xerrors"
+	"github.com/filecoin-project/lotus/build"
 )
 
 const BigIntMaxSerializedLen = 128 // is this big enough? or too big?
 
-var TotalFilecoinInt = FromFil(build.TotalFilecoin)
-
-func init() {
-	cbor.RegisterCborType(atlas.BuildEntry(BigInt{}).Transform().
-		TransformMarshal(atlas.MakeMarshalTransformFunc(
-			func(i BigInt) ([]byte, error) {
-				return i.cborBytes(), nil
-			})).
-		TransformUnmarshal(atlas.MakeUnmarshalTransformFunc(
-			func(x []byte) (BigInt, error) {
-				return fromCborBytes(x)
-			})).
-		Complete())
-}
+var TotalFilecoinInt = FromFil(build.FilBase)
 
 var EmptyInt = BigInt{}
 
-type BigInt struct {
-	*big.Int
-}
+type BigInt = big2.Int
 
 func NewInt(i uint64) BigInt {
-	return BigInt{big.NewInt(0).SetUint64(i)}
+	return BigInt{Int: big.NewInt(0).SetUint64(i)}
 }
 
 func FromFil(i uint64) BigInt {
@@ -47,7 +27,7 @@ func FromFil(i uint64) BigInt {
 
 func BigFromBytes(b []byte) BigInt {
 	i := big.NewInt(0).SetBytes(b)
-	return BigInt{i}
+	return BigInt{Int: i}
 }
 
 func BigFromString(s string) (BigInt, error) {
@@ -56,204 +36,61 @@ func BigFromString(s string) (BigInt, error) {
 		return BigInt{}, fmt.Errorf("failed to parse string as a big int")
 	}
 
-	return BigInt{v}, nil
+	return BigInt{Int: v}, nil
 }
 
 func BigMul(a, b BigInt) BigInt {
-	return BigInt{big.NewInt(0).Mul(a.Int, b.Int)}
+	return BigInt{Int: big.NewInt(0).Mul(a.Int, b.Int)}
 }
 
 func BigDiv(a, b BigInt) BigInt {
-	return BigInt{big.NewInt(0).Div(a.Int, b.Int)}
+	return BigInt{Int: big.NewInt(0).Div(a.Int, b.Int)}
 }
 
 func BigMod(a, b BigInt) BigInt {
-	return BigInt{big.NewInt(0).Mod(a.Int, b.Int)}
+	return BigInt{Int: big.NewInt(0).Mod(a.Int, b.Int)}
 }
 
 func BigAdd(a, b BigInt) BigInt {
-	return BigInt{big.NewInt(0).Add(a.Int, b.Int)}
+	return BigInt{Int: big.NewInt(0).Add(a.Int, b.Int)}
 }
 
 func BigSub(a, b BigInt) BigInt {
-	return BigInt{big.NewInt(0).Sub(a.Int, b.Int)}
+	return BigInt{Int: big.NewInt(0).Sub(a.Int, b.Int)}
 }
 
 func BigCmp(a, b BigInt) int {
 	return a.Int.Cmp(b.Int)
 }
 
-func (bi BigInt) Nil() bool {
-	return bi.Int == nil
-}
+var byteSizeUnits = []string{"B", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "ZiB"}
 
-// LessThan returns true if bi < o
-func (bi BigInt) LessThan(o BigInt) bool {
-	return BigCmp(bi, o) < 0
-}
-
-// GreaterThan returns true if bi > o
-func (bi BigInt) GreaterThan(o BigInt) bool {
-	return BigCmp(bi, o) > 0
-}
-
-// Equals returns true if bi == o
-func (bi BigInt) Equals(o BigInt) bool {
-	return BigCmp(bi, o) == 0
-}
-
-func (bi *BigInt) MarshalJSON() ([]byte, error) {
-	return json.Marshal(bi.String())
-}
-
-func (bi *BigInt) UnmarshalJSON(b []byte) error {
-	var s string
-	if err := json.Unmarshal(b, &s); err != nil {
-		return err
-	}
-
-	i, ok := big.NewInt(0).SetString(s, 10)
-	if !ok {
-		if string(s) == "<nil>" {
-			return nil
-		}
-		return xerrors.Errorf("failed to parse bigint string: '%s'", string(b))
-	}
-
-	bi.Int = i
-	return nil
-}
-
-var sizeUnits = []string{"B", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "ZiB"}
-
-func (bi BigInt) SizeStr() string {
+func SizeStr(bi BigInt) string {
 	r := new(big.Rat).SetInt(bi.Int)
 	den := big.NewRat(1, 1024)
 
 	var i int
-	for f, _ := r.Float64(); f >= 1024 && i+1 < len(sizeUnits); f, _ = r.Float64() {
+	for f, _ := r.Float64(); f >= 1024 && i+1 < len(byteSizeUnits); f, _ = r.Float64() {
 		i++
 		r = r.Mul(r, den)
 	}
 
 	f, _ := r.Float64()
-	return fmt.Sprintf("%.3g %s", f, sizeUnits[i])
+	return fmt.Sprintf("%.4g %s", f, byteSizeUnits[i])
 }
 
-func (bi *BigInt) Scan(value interface{}) error {
-	switch value := value.(type) {
-	case string:
-		i, ok := big.NewInt(0).SetString(value, 10)
-		if !ok {
-			if value == "<nil>" {
-				return nil
-			}
-			return xerrors.Errorf("failed to parse bigint string: '%s'", value)
-		}
+var deciUnits = []string{"", "Ki", "Mi", "Gi", "Ti", "Pi", "Ei", "Zi"}
 
-		bi.Int = i
+func DeciStr(bi BigInt) string {
+	r := new(big.Rat).SetInt(bi.Int)
+	den := big.NewRat(1, 1024)
 
-		return nil
-	case int64:
-		bi.Int = big.NewInt(value)
-		return nil
-	default:
-		return xerrors.Errorf("non-string types unsupported: %T", value)
+	var i int
+	for f, _ := r.Float64(); f >= 1024 && i+1 < len(deciUnits); f, _ = r.Float64() {
+		i++
+		r = r.Mul(r, den)
 	}
-}
-
-func (bi *BigInt) cborBytes() []byte {
-	if bi.Int == nil {
-		return []byte{}
-	}
-
-	switch {
-	case bi.Sign() > 0:
-		return append([]byte{0}, bi.Bytes()...)
-	case bi.Sign() < 0:
-		return append([]byte{1}, bi.Bytes()...)
-	default: //  bi.Sign() == 0:
-		return []byte{}
-	}
-}
-
-func fromCborBytes(buf []byte) (BigInt, error) {
-	if len(buf) == 0 {
-		return NewInt(0), nil
-	}
-
-	var negative bool
-	switch buf[0] {
-	case 0:
-		negative = false
-	case 1:
-		negative = true
-	default:
-		return EmptyInt, fmt.Errorf("big int prefix should be either 0 or 1, got %d", buf[0])
-	}
-
-	i := big.NewInt(0).SetBytes(buf[1:])
-	if negative {
-		i.Neg(i)
-	}
-
-	return BigInt{i}, nil
-}
-
-func (bi *BigInt) MarshalCBOR(w io.Writer) error {
-	if bi.Int == nil {
-		zero := NewInt(0)
-		return zero.MarshalCBOR(w)
-	}
-
-	enc := bi.cborBytes()
-
-	header := cbg.CborEncodeMajorType(cbg.MajByteString, uint64(len(enc)))
-	if _, err := w.Write(header); err != nil {
-		return err
-	}
-
-	if _, err := w.Write(enc); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func (bi *BigInt) UnmarshalCBOR(br io.Reader) error {
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-
-	if maj != cbg.MajByteString {
-		return fmt.Errorf("cbor input for fil big int was not a byte string (%x)", maj)
-	}
-
-	if extra == 0 {
-		bi.Int = big.NewInt(0)
-		return nil
-	}
-
-	if extra > BigIntMaxSerializedLen {
-		return fmt.Errorf("big integer byte array too long")
-	}
-
-	buf := make([]byte, extra)
-	if _, err := io.ReadFull(br, buf); err != nil {
-		return err
-	}
-
-	i, err := fromCborBytes(buf)
-	if err != nil {
-		return err
-	}
-
-	*bi = i
-
-	return nil
-}
-
-func (bi *BigInt) IsZero() bool {
-	return bi.Int.Sign() == 0
+
+	f, _ := r.Float64()
+	return fmt.Sprintf("%.3g %s", f, deciUnits[i])
 }
diff --git a/chain/types/bigint_test.go b/chain/types/bigint_test.go
index be77acbde..b66528db3 100644
--- a/chain/types/bigint_test.go
+++ b/chain/types/bigint_test.go
@@ -3,7 +3,12 @@ package types
 import (
 	"bytes"
 	"math/big"
+	"math/rand"
+	"strings"
 	"testing"
+	"time"
+
+	"github.com/docker/go-units"
 
 	"github.com/stretchr/testify/assert"
 )
@@ -38,7 +43,7 @@ func TestBigIntSerializationRoundTrip(t *testing.T) {
 
 func TestFilRoundTrip(t *testing.T) {
 	testValues := []string{
-		"0", "1", "1.001", "100.10001", "101100", "5000.01", "5000",
+		"0 FIL", "1 FIL", "1.001 FIL", "100.10001 FIL", "101100 FIL", "5000.01 FIL", "5000 FIL",
 	}
 
 	for _, v := range testValues {
@@ -60,14 +65,32 @@ func TestSizeStr(t *testing.T) {
 	}{
 		{0, "0 B"},
 		{1, "1 B"},
+		{1016, "1016 B"},
 		{1024, "1 KiB"},
-		{2000, "1.95 KiB"},
+		{1000 * 1024, "1000 KiB"},
+		{2000, "1.953 KiB"},
 		{5 << 20, "5 MiB"},
 		{11 << 60, "11 EiB"},
 	}
 
 	for _, c := range cases {
-		assert.Equal(t, c.out, NewInt(c.in).SizeStr(), "input %+v, produced wrong result", c)
+		assert.Equal(t, c.out, SizeStr(NewInt(c.in)), "input %+v, produced wrong result", c)
+	}
+}
+
+func TestSizeStrUnitsSymmetry(t *testing.T) {
+	s := rand.NewSource(time.Now().UnixNano())
+	r := rand.New(s)
+
+	for i := 0; i < 10000; i++ {
+		n := r.Uint64()
+		l := strings.ReplaceAll(units.BytesSize(float64(n)), " ", "")
+		r := strings.ReplaceAll(SizeStr(NewInt(n)), " ", "")
+
+		assert.NotContains(t, l, "e+")
+		assert.NotContains(t, r, "e+")
+
+		assert.Equal(t, l, r, "wrong formatting for %d", n)
 	}
 }
 
@@ -75,6 +98,6 @@ func TestSizeStrBig(t *testing.T) {
 	ZiB := big.NewInt(50000)
 	ZiB = ZiB.Lsh(ZiB, 70)
 
-	assert.Equal(t, "5e+04 ZiB", BigInt{Int: ZiB}.SizeStr(), "inout %+v, produced wrong result", ZiB)
+	assert.Equal(t, "5e+04 ZiB", SizeStr(BigInt{Int: ZiB}), "inout %+v, produced wrong result", ZiB)
 
 }
diff --git a/chain/types/bitfield.go b/chain/types/bitfield.go
deleted file mode 100644
index d959e4f84..000000000
--- a/chain/types/bitfield.go
+++ /dev/null
@@ -1,200 +0,0 @@
-package types
-
-import (
-	"fmt"
-	"io"
-
-	rlepluslazy "github.com/filecoin-project/lotus/lib/rlepluslazy"
-	cbg "github.com/whyrusleeping/cbor-gen"
-	"golang.org/x/xerrors"
-)
-
-type BitField struct {
-	rle rlepluslazy.RLE
-
-	bits map[uint64]struct{}
-}
-
-func NewBitField() BitField {
-	rle, err := rlepluslazy.FromBuf([]byte{})
-	if err != nil {
-		panic(err)
-	}
-	return BitField{
-		rle:  rle,
-		bits: make(map[uint64]struct{}),
-	}
-}
-
-func BitFieldFromSet(setBits []uint64) BitField {
-	res := BitField{bits: make(map[uint64]struct{})}
-	for _, b := range setBits {
-		res.bits[b] = struct{}{}
-	}
-	return res
-}
-
-func MergeBitFields(a, b BitField) (BitField, error) {
-	ra, err := a.rle.RunIterator()
-	if err != nil {
-		return BitField{}, err
-	}
-
-	rb, err := b.rle.RunIterator()
-	if err != nil {
-		return BitField{}, err
-	}
-
-	merge, err := rlepluslazy.Sum(ra, rb)
-	if err != nil {
-		return BitField{}, err
-	}
-
-	mergebytes, err := rlepluslazy.EncodeRuns(merge, nil)
-	if err != nil {
-		return BitField{}, err
-	}
-
-	rle, err := rlepluslazy.FromBuf(mergebytes)
-	if err != nil {
-		return BitField{}, err
-	}
-
-	return BitField{
-		rle:  rle,
-		bits: make(map[uint64]struct{}),
-	}, nil
-}
-
-func (bf BitField) sum() (rlepluslazy.RunIterator, error) {
-	if len(bf.bits) == 0 {
-		return bf.rle.RunIterator()
-	}
-
-	a, err := bf.rle.RunIterator()
-	if err != nil {
-		return nil, err
-	}
-	slc := make([]uint64, 0, len(bf.bits))
-	for b := range bf.bits {
-		slc = append(slc, b)
-	}
-
-	b, err := rlepluslazy.RunsFromSlice(slc)
-	if err != nil {
-		return nil, err
-	}
-
-	res, err := rlepluslazy.Sum(a, b)
-	if err != nil {
-		return nil, err
-	}
-	return res, nil
-}
-
-// Set ...s bit in the BitField
-func (bf BitField) Set(bit uint64) {
-	bf.bits[bit] = struct{}{}
-}
-
-func (bf BitField) Count() (uint64, error) {
-	s, err := bf.sum()
-	if err != nil {
-		return 0, err
-	}
-	return rlepluslazy.Count(s)
-}
-
-// All returns all set bits
-func (bf BitField) All() ([]uint64, error) {
-
-	runs, err := bf.sum()
-	if err != nil {
-		return nil, err
-	}
-
-	res, err := rlepluslazy.SliceFromRuns(runs)
-	if err != nil {
-		return nil, err
-	}
-
-	return res, nil
-}
-
-func (bf BitField) AllMap() (map[uint64]bool, error) {
-
-	runs, err := bf.sum()
-	if err != nil {
-		return nil, err
-	}
-
-	res, err := rlepluslazy.SliceFromRuns(runs)
-	if err != nil {
-		return nil, err
-	}
-
-	out := make(map[uint64]bool)
-	for _, i := range res {
-		out[i] = true
-	}
-	return out, nil
-}
-
-func (bf BitField) MarshalCBOR(w io.Writer) error {
-	ints := make([]uint64, 0, len(bf.bits))
-	for i := range bf.bits {
-		ints = append(ints, i)
-	}
-
-	s, err := bf.sum()
-	if err != nil {
-		return err
-	}
-
-	rle, err := rlepluslazy.EncodeRuns(s, []byte{})
-	if err != nil {
-		return err
-	}
-
-	if len(rle) > 8192 {
-		return xerrors.Errorf("encoded bitfield was too large (%d)", len(rle))
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajByteString, uint64(len(rle)))); err != nil {
-		return err
-	}
-	if _, err = w.Write(rle); err != nil {
-		return xerrors.Errorf("writing rle: %w", err)
-	}
-	return nil
-}
-
-func (bf *BitField) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if extra > 8192 {
-		return fmt.Errorf("array too large")
-	}
-
-	if maj != cbg.MajByteString {
-		return fmt.Errorf("expected byte array")
-	}
-
-	buf := make([]byte, extra)
-	if _, err := io.ReadFull(br, buf); err != nil {
-		return err
-	}
-
-	rle, err := rlepluslazy.FromBuf(buf)
-	if err != nil {
-		return xerrors.Errorf("could not decode rle+: %w", err)
-	}
-	bf.rle = rle
-	bf.bits = make(map[uint64]struct{})
-
-	return nil
-}
diff --git a/chain/types/blockheader.go b/chain/types/blockheader.go
index 23fdab0f7..0ec33fe42 100644
--- a/chain/types/blockheader.go
+++ b/chain/types/blockheader.go
@@ -2,16 +2,17 @@ package types
 
 import (
 	"bytes"
-	"context"
 	"math/big"
 
-	"github.com/filecoin-project/go-sectorbuilder"
+	"github.com/filecoin-project/specs-actors/actors/runtime/proof"
+
+	"github.com/minio/blake2b-simd"
+
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/crypto"
 
 	block "github.com/ipfs/go-block-format"
 	"github.com/ipfs/go-cid"
-	"github.com/minio/sha256-simd"
-	"github.com/multiformats/go-multihash"
-	"go.opencensus.io/trace"
 	xerrors "golang.org/x/xerrors"
 
 	"github.com/filecoin-project/go-address"
@@ -23,52 +24,73 @@ type Ticket struct {
 	VRFProof []byte
 }
 
-type EPostTicket struct {
-	Partial        []byte
-	SectorID       uint64
-	ChallengeIndex uint64
+func (t *Ticket) Quality() float64 {
+	ticketHash := blake2b.Sum256(t.VRFProof)
+	ticketNum := BigFromBytes(ticketHash[:]).Int
+	ticketDenu := big.NewInt(1)
+	ticketDenu.Lsh(ticketDenu, 256)
+	tv, _ := new(big.Rat).SetFrac(ticketNum, ticketDenu).Float64()
+	tq := 1 - tv
+	return tq
 }
 
-type EPostProof struct {
-	Proof      []byte
-	PostRand   []byte
-	Candidates []EPostTicket
+type BeaconEntry struct {
+	Round uint64
+	Data  []byte
+}
+
+func NewBeaconEntry(round uint64, data []byte) BeaconEntry {
+	return BeaconEntry{
+		Round: round,
+		Data:  data,
+	}
 }
 
 type BlockHeader struct {
-	Miner address.Address
+	Miner address.Address // 0
 
-	Ticket *Ticket
+	Ticket *Ticket // 1
 
-	EPostProof EPostProof
+	ElectionProof *ElectionProof // 2
 
-	Parents []cid.Cid
+	BeaconEntries []BeaconEntry // 3
 
-	ParentWeight BigInt
+	WinPoStProof []proof.PoStProof // 4
 
-	Height uint64
+	Parents []cid.Cid // 5
 
-	ParentStateRoot cid.Cid
+	ParentWeight BigInt // 6
 
-	ParentMessageReceipts cid.Cid
+	Height abi.ChainEpoch // 7
 
-	Messages cid.Cid
+	ParentStateRoot cid.Cid // 8
 
-	BLSAggregate Signature
+	ParentMessageReceipts cid.Cid // 8
 
-	Timestamp uint64
+	Messages cid.Cid // 10
 
-	BlockSig *Signature
+	BLSAggregate *crypto.Signature // 11
+
+	Timestamp uint64 // 12
+
+	BlockSig *crypto.Signature // 13
+
+	ForkSignaling uint64 // 14
+
+	// ParentBaseFee is the base fee after executing parent tipset
+	ParentBaseFee abi.TokenAmount // 15
+
+	// internal
+	validated bool // true if the signature has been validated
 }
 
-func (b *BlockHeader) ToStorageBlock() (block.Block, error) {
-	data, err := b.Serialize()
+func (blk *BlockHeader) ToStorageBlock() (block.Block, error) {
+	data, err := blk.Serialize()
 	if err != nil {
 		return nil, err
 	}
 
-	pref := cid.NewPrefixV1(cid.DagCBOR, multihash.BLAKE2B_MIN+31)
-	c, err := pref.Sum(data)
+	c, err := abi.CidBuilder.Sum(data)
 	if err != nil {
 		return nil, err
 	}
@@ -76,8 +98,8 @@ func (b *BlockHeader) ToStorageBlock() (block.Block, error) {
 	return block.NewBlockWithCid(data, c)
 }
 
-func (b *BlockHeader) Cid() cid.Cid {
-	sb, err := b.ToStorageBlock()
+func (blk *BlockHeader) Cid() cid.Cid {
+	sb, err := blk.ToStorageBlock()
 	if err != nil {
 		panic(err) // Not sure i'm entirely comfortable with this one, needs to be checked
 	}
@@ -114,16 +136,12 @@ func (blk *BlockHeader) SigningBytes() ([]byte, error) {
 	return blkcopy.Serialize()
 }
 
-func (blk *BlockHeader) CheckBlockSignature(ctx context.Context, worker address.Address) error {
-	_, span := trace.StartSpan(ctx, "checkBlockSignature")
-	defer span.End()
+func (blk *BlockHeader) SetValidated() {
+	blk.validated = true
+}
 
-	sigb, err := blk.SigningBytes()
-	if err != nil {
-		return xerrors.Errorf("failed to get block signing bytes: %w", err)
-	}
-
-	return blk.BlockSig.Verify(worker, sigb)
+func (blk *BlockHeader) IsValidated() bool {
+	return blk.validated
 }
 
 type MsgMeta struct {
@@ -140,13 +158,12 @@ func (mm *MsgMeta) Cid() cid.Cid {
 }
 
 func (mm *MsgMeta) ToStorageBlock() (block.Block, error) {
-	buf := new(bytes.Buffer)
-	if err := mm.MarshalCBOR(buf); err != nil {
+	var buf bytes.Buffer
+	if err := mm.MarshalCBOR(&buf); err != nil {
 		return nil, xerrors.Errorf("failed to marshal MsgMeta: %w", err)
 	}
 
-	pref := cid.NewPrefixV1(cid.DagCBOR, multihash.BLAKE2B_MIN+31)
-	c, err := pref.Sum(buf.Bytes())
+	c, err := abi.CidBuilder.Sum(buf.Bytes())
 	if err != nil {
 		return nil, err
 	}
@@ -173,53 +190,60 @@ func CidArrsEqual(a, b []cid.Cid) bool {
 	return true
 }
 
+func CidArrsSubset(a, b []cid.Cid) bool {
+	// order ignoring compare...
+	s := make(map[cid.Cid]bool)
+	for _, c := range b {
+		s[c] = true
+	}
+
+	for _, c := range a {
+		if !s[c] {
+			return false
+		}
+	}
+	return true
+}
+
+func CidArrsContains(a []cid.Cid, b cid.Cid) bool {
+	for _, elem := range a {
+		if elem.Equals(b) {
+			return true
+		}
+	}
+	return false
+}
+
 var blocksPerEpoch = NewInt(build.BlocksPerEpoch)
 
 const sha256bits = 256
 
-func IsTicketWinner(partialTicket []byte, ssizeI uint64, snum uint64, totpow BigInt) bool {
-	ssize := NewInt(ssizeI)
-	ssampled := ElectionPostChallengeCount(snum, 0) // TODO: faults in epost?
+func IsTicketWinner(vrfTicket []byte, mypow BigInt, totpow BigInt) bool {
 	/*
 		Need to check that
-		(h(vrfout) + 1) / (max(h) + 1) <= e * sectorSize / totalPower
+		(h(vrfout) + 1) / (max(h) + 1) <= e * myPower / totalPower
 		max(h) == 2^256-1
 		which in terms of integer math means:
-		(h(vrfout) + 1) * totalPower <= e * sectorSize * 2^256
+		(h(vrfout) + 1) * totalPower <= e * myPower * 2^256
 		in 2^256 space, it is equivalent to:
-		h(vrfout) * totalPower < e * sectorSize * 2^256
+		h(vrfout) * totalPower < e * myPower * 2^256
 
-		Because of SectorChallengeRatioDiv sampling for proofs
-		we need to scale this appropriately.
-
-		Let c = ceil(numSectors/SectorChallengeRatioDiv)
-		(c is the number of tickets a miner requests)
-		Accordingly we check
-		(h(vrfout) + 1) / 2^256 <= e * sectorSize / totalPower * snum / c
-		or
-		h(vrfout) * totalPower * c < e * sectorSize * 2^256 * snum
 	*/
 
-	h := sha256.Sum256(partialTicket)
+	h := blake2b.Sum256(vrfTicket)
 
 	lhs := BigFromBytes(h[:]).Int
 	lhs = lhs.Mul(lhs, totpow.Int)
-	lhs = lhs.Mul(lhs, new(big.Int).SetUint64(ssampled))
 
 	// rhs = sectorSize * 2^256
 	// rhs = sectorSize << 256
-	rhs := new(big.Int).Lsh(ssize.Int, sha256bits)
-	rhs = rhs.Mul(rhs, new(big.Int).SetUint64(snum))
+	rhs := new(big.Int).Lsh(mypow.Int, sha256bits)
 	rhs = rhs.Mul(rhs, blocksPerEpoch.Int)
 
 	// h(vrfout) * totalPower < e * sectorSize * 2^256?
 	return lhs.Cmp(rhs) < 0
 }
 
-func ElectionPostChallengeCount(sectors uint64, faults int) uint64 {
-	return sectorbuilder.ElectionPostChallengeCount(sectors, faults)
-}
-
 func (t *Ticket) Equals(ot *Ticket) bool {
 	return bytes.Equal(t.VRFProof, ot.VRFProof)
 }
diff --git a/chain/types/blockheader_test.go b/chain/types/blockheader_test.go
index ee9ca8192..f5faac3b3 100644
--- a/chain/types/blockheader_test.go
+++ b/chain/types/blockheader_test.go
@@ -2,12 +2,19 @@ package types
 
 import (
 	"bytes"
+	"encoding/hex"
 	"fmt"
 	"reflect"
 	"testing"
 
-	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/specs-actors/actors/runtime/proof"
+
 	cid "github.com/ipfs/go-cid"
+	"github.com/stretchr/testify/require"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/crypto"
 )
 
 func testBlockHeader(t testing.TB) *BlockHeader {
@@ -25,21 +32,21 @@ func testBlockHeader(t testing.TB) *BlockHeader {
 
 	return &BlockHeader{
 		Miner: addr,
-		EPostProof: EPostProof{
-			Proof:    []byte("pruuf"),
-			PostRand: []byte("random"),
-		},
 		Ticket: &Ticket{
 			VRFProof: []byte("vrf proof0000000vrf proof0000000"),
 		},
+		ElectionProof: &ElectionProof{
+			VRFProof: []byte("vrf proof0000000vrf proof0000000"),
+		},
 		Parents:               []cid.Cid{c, c},
 		ParentMessageReceipts: c,
-		BLSAggregate:          Signature{Type: KTBLS, Data: []byte("boo! im a signature")},
+		BLSAggregate:          &crypto.Signature{Type: crypto.SigTypeBLS, Data: []byte("boo! im a signature")},
 		ParentWeight:          NewInt(123125126212),
 		Messages:              c,
 		Height:                85919298723,
 		ParentStateRoot:       c,
-		BlockSig:              &Signature{Type: KTBLS, Data: []byte("boo! im a signature")},
+		BlockSig:              &crypto.Signature{Type: crypto.SigTypeBLS, Data: []byte("boo! im a signature")},
+		ParentBaseFee:         NewInt(3432432843291),
 	}
 }
 
@@ -63,6 +70,60 @@ func TestBlockHeaderSerialization(t *testing.T) {
 	}
 }
 
+func TestInteropBH(t *testing.T) {
+	newAddr, err := address.NewSecp256k1Address([]byte("address0"))
+
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	mcid, err := cid.Parse("bafy2bzaceaxyj7xq27gc2747adjcirpxx52tt7owqx6z6kckun7tqivvoym4y")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	posts := []proof.PoStProof{
+		{PoStProof: abi.RegisteredPoStProof_StackedDrgWinning2KiBV1, ProofBytes: []byte{0x07}},
+	}
+
+	bh := &BlockHeader{
+		Miner:         newAddr,
+		Ticket:        &Ticket{[]byte{0x01, 0x02, 0x03}},
+		ElectionProof: &ElectionProof{0, []byte{0x0a, 0x0b}},
+		BeaconEntries: []BeaconEntry{
+			{
+				Round: 5,
+				Data:  []byte{0x0c},
+				//prevRound: 0,
+			},
+		},
+		Height:                2,
+		Messages:              mcid,
+		ParentMessageReceipts: mcid,
+		Parents:               []cid.Cid{mcid},
+		ParentWeight:          NewInt(1000),
+		ForkSignaling:         3,
+		ParentStateRoot:       mcid,
+		Timestamp:             1,
+		WinPoStProof:          posts,
+		BlockSig: &crypto.Signature{
+			Type: crypto.SigTypeBLS,
+			Data: []byte{0x3},
+		},
+		BLSAggregate:  &crypto.Signature{},
+		ParentBaseFee: NewInt(1000000000),
+	}
+
+	bhsb, err := bh.SigningBytes()
+
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	gfc := "905501d04cb15021bf6bd003073d79e2238d4e61f1ad2281430102038200420a0b818205410c818200410781d82a5827000171a0e402202f84fef0d7cc2d7f9f00d22445f7bf7539fdd685fd9f284aa37f3822b57619cc430003e802d82a5827000171a0e402202f84fef0d7cc2d7f9f00d22445f7bf7539fdd685fd9f284aa37f3822b57619ccd82a5827000171a0e402202f84fef0d7cc2d7f9f00d22445f7bf7539fdd685fd9f284aa37f3822b57619ccd82a5827000171a0e402202f84fef0d7cc2d7f9f00d22445f7bf7539fdd685fd9f284aa37f3822b57619cc410001f60345003b9aca00"
+	require.Equal(t, gfc, hex.EncodeToString(bhsb))
+}
+
 func BenchmarkBlockHeaderMarshal(b *testing.B) {
 	bh := testBlockHeader(b)
 
diff --git a/chain/types/cbor_gen.go b/chain/types/cbor_gen.go
index 407f89809..f95df33bc 100644
--- a/chain/types/cbor_gen.go
+++ b/chain/types/cbor_gen.go
@@ -1,28 +1,35 @@
+// Code generated by github.com/whyrusleeping/cbor-gen. DO NOT EDIT.
+
 package types
 
 import (
 	"fmt"
 	"io"
-	"math"
 
+	abi "github.com/filecoin-project/go-state-types/abi"
+	crypto "github.com/filecoin-project/go-state-types/crypto"
+	exitcode "github.com/filecoin-project/go-state-types/exitcode"
+	proof "github.com/filecoin-project/specs-actors/actors/runtime/proof"
 	cid "github.com/ipfs/go-cid"
 	cbg "github.com/whyrusleeping/cbor-gen"
 	xerrors "golang.org/x/xerrors"
 )
 
-// Code generated by github.com/whyrusleeping/cbor-gen. DO NOT EDIT.
-
 var _ = xerrors.Errorf
 
+var lengthBufBlockHeader = []byte{144}
+
 func (t *BlockHeader) MarshalCBOR(w io.Writer) error {
 	if t == nil {
 		_, err := w.Write(cbg.CborNull)
 		return err
 	}
-	if _, err := w.Write([]byte{140}); err != nil {
+	if _, err := w.Write(lengthBufBlockHeader); err != nil {
 		return err
 	}
 
+	scratch := make([]byte, 9)
+
 	// t.Miner (address.Address) (struct)
 	if err := t.Miner.MarshalCBOR(w); err != nil {
 		return err
@@ -33,74 +40,123 @@ func (t *BlockHeader) MarshalCBOR(w io.Writer) error {
 		return err
 	}
 
-	// t.EPostProof (types.EPostProof) (struct)
-	if err := t.EPostProof.MarshalCBOR(w); err != nil {
+	// t.ElectionProof (types.ElectionProof) (struct)
+	if err := t.ElectionProof.MarshalCBOR(w); err != nil {
 		return err
 	}
 
+	// t.BeaconEntries ([]types.BeaconEntry) (slice)
+	if len(t.BeaconEntries) > cbg.MaxLength {
+		return xerrors.Errorf("Slice value in field t.BeaconEntries was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajArray, uint64(len(t.BeaconEntries))); err != nil {
+		return err
+	}
+	for _, v := range t.BeaconEntries {
+		if err := v.MarshalCBOR(w); err != nil {
+			return err
+		}
+	}
+
+	// t.WinPoStProof ([]proof.PoStProof) (slice)
+	if len(t.WinPoStProof) > cbg.MaxLength {
+		return xerrors.Errorf("Slice value in field t.WinPoStProof was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajArray, uint64(len(t.WinPoStProof))); err != nil {
+		return err
+	}
+	for _, v := range t.WinPoStProof {
+		if err := v.MarshalCBOR(w); err != nil {
+			return err
+		}
+	}
+
 	// t.Parents ([]cid.Cid) (slice)
 	if len(t.Parents) > cbg.MaxLength {
 		return xerrors.Errorf("Slice value in field t.Parents was too long")
 	}
 
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajArray, uint64(len(t.Parents)))); err != nil {
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajArray, uint64(len(t.Parents))); err != nil {
 		return err
 	}
 	for _, v := range t.Parents {
-		if err := cbg.WriteCid(w, v); err != nil {
+		if err := cbg.WriteCidBuf(scratch, w, v); err != nil {
 			return xerrors.Errorf("failed writing cid field t.Parents: %w", err)
 		}
 	}
 
-	// t.ParentWeight (types.BigInt) (struct)
+	// t.ParentWeight (big.Int) (struct)
 	if err := t.ParentWeight.MarshalCBOR(w); err != nil {
 		return err
 	}
 
-	// t.Height (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.Height))); err != nil {
-		return err
+	// t.Height (abi.ChainEpoch) (int64)
+	if t.Height >= 0 {
+		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.Height)); err != nil {
+			return err
+		}
+	} else {
+		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajNegativeInt, uint64(-t.Height-1)); err != nil {
+			return err
+		}
 	}
 
 	// t.ParentStateRoot (cid.Cid) (struct)
 
-	if err := cbg.WriteCid(w, t.ParentStateRoot); err != nil {
+	if err := cbg.WriteCidBuf(scratch, w, t.ParentStateRoot); err != nil {
 		return xerrors.Errorf("failed to write cid field t.ParentStateRoot: %w", err)
 	}
 
 	// t.ParentMessageReceipts (cid.Cid) (struct)
 
-	if err := cbg.WriteCid(w, t.ParentMessageReceipts); err != nil {
+	if err := cbg.WriteCidBuf(scratch, w, t.ParentMessageReceipts); err != nil {
 		return xerrors.Errorf("failed to write cid field t.ParentMessageReceipts: %w", err)
 	}
 
 	// t.Messages (cid.Cid) (struct)
 
-	if err := cbg.WriteCid(w, t.Messages); err != nil {
+	if err := cbg.WriteCidBuf(scratch, w, t.Messages); err != nil {
 		return xerrors.Errorf("failed to write cid field t.Messages: %w", err)
 	}
 
-	// t.BLSAggregate (types.Signature) (struct)
+	// t.BLSAggregate (crypto.Signature) (struct)
 	if err := t.BLSAggregate.MarshalCBOR(w); err != nil {
 		return err
 	}
 
 	// t.Timestamp (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.Timestamp))); err != nil {
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.Timestamp)); err != nil {
 		return err
 	}
 
-	// t.BlockSig (types.Signature) (struct)
+	// t.BlockSig (crypto.Signature) (struct)
 	if err := t.BlockSig.MarshalCBOR(w); err != nil {
 		return err
 	}
+
+	// t.ForkSignaling (uint64) (uint64)
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.ForkSignaling)); err != nil {
+		return err
+	}
+
+	// t.ParentBaseFee (big.Int) (struct)
+	if err := t.ParentBaseFee.MarshalCBOR(w); err != nil {
+		return err
+	}
 	return nil
 }
 
 func (t *BlockHeader) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
+	*t = BlockHeader{}
 
-	maj, extra, err := cbg.CborReadHeader(br)
+	br := cbg.GetPeeker(r)
+	scratch := make([]byte, 8)
+
+	maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
 	if err != nil {
 		return err
 	}
@@ -108,7 +164,7 @@ func (t *BlockHeader) UnmarshalCBOR(r io.Reader) error {
 		return fmt.Errorf("cbor input should be of type array")
 	}
 
-	if extra != 12 {
+	if extra != 16 {
 		return fmt.Errorf("cbor input had wrong number of fields")
 	}
 
@@ -117,7 +173,7 @@ func (t *BlockHeader) UnmarshalCBOR(r io.Reader) error {
 	{
 
 		if err := t.Miner.UnmarshalCBOR(br); err != nil {
-			return err
+			return xerrors.Errorf("unmarshaling t.Miner: %w", err)
 		}
 
 	}
@@ -125,35 +181,101 @@ func (t *BlockHeader) UnmarshalCBOR(r io.Reader) error {
 
 	{
 
-		pb, err := br.PeekByte()
+		b, err := br.ReadByte()
 		if err != nil {
 			return err
 		}
-		if pb == cbg.CborNull[0] {
-			var nbuf [1]byte
-			if _, err := br.Read(nbuf[:]); err != nil {
+		if b != cbg.CborNull[0] {
+			if err := br.UnreadByte(); err != nil {
 				return err
 			}
-		} else {
 			t.Ticket = new(Ticket)
 			if err := t.Ticket.UnmarshalCBOR(br); err != nil {
-				return err
+				return xerrors.Errorf("unmarshaling t.Ticket pointer: %w", err)
 			}
 		}
 
 	}
-	// t.EPostProof (types.EPostProof) (struct)
+	// t.ElectionProof (types.ElectionProof) (struct)
 
 	{
 
-		if err := t.EPostProof.UnmarshalCBOR(br); err != nil {
+		b, err := br.ReadByte()
+		if err != nil {
 			return err
 		}
+		if b != cbg.CborNull[0] {
+			if err := br.UnreadByte(); err != nil {
+				return err
+			}
+			t.ElectionProof = new(ElectionProof)
+			if err := t.ElectionProof.UnmarshalCBOR(br); err != nil {
+				return xerrors.Errorf("unmarshaling t.ElectionProof pointer: %w", err)
+			}
+		}
 
 	}
+	// t.BeaconEntries ([]types.BeaconEntry) (slice)
+
+	maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
+	if err != nil {
+		return err
+	}
+
+	if extra > cbg.MaxLength {
+		return fmt.Errorf("t.BeaconEntries: array too large (%d)", extra)
+	}
+
+	if maj != cbg.MajArray {
+		return fmt.Errorf("expected cbor array")
+	}
+
+	if extra > 0 {
+		t.BeaconEntries = make([]BeaconEntry, extra)
+	}
+
+	for i := 0; i < int(extra); i++ {
+
+		var v BeaconEntry
+		if err := v.UnmarshalCBOR(br); err != nil {
+			return err
+		}
+
+		t.BeaconEntries[i] = v
+	}
+
+	// t.WinPoStProof ([]proof.PoStProof) (slice)
+
+	maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
+	if err != nil {
+		return err
+	}
+
+	if extra > cbg.MaxLength {
+		return fmt.Errorf("t.WinPoStProof: array too large (%d)", extra)
+	}
+
+	if maj != cbg.MajArray {
+		return fmt.Errorf("expected cbor array")
+	}
+
+	if extra > 0 {
+		t.WinPoStProof = make([]proof.PoStProof, extra)
+	}
+
+	for i := 0; i < int(extra); i++ {
+
+		var v proof.PoStProof
+		if err := v.UnmarshalCBOR(br); err != nil {
+			return err
+		}
+
+		t.WinPoStProof[i] = v
+	}
+
 	// t.Parents ([]cid.Cid) (slice)
 
-	maj, extra, err = cbg.CborReadHeader(br)
+	maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
 	if err != nil {
 		return err
 	}
@@ -165,9 +287,11 @@ func (t *BlockHeader) UnmarshalCBOR(r io.Reader) error {
 	if maj != cbg.MajArray {
 		return fmt.Errorf("expected cbor array")
 	}
+
 	if extra > 0 {
 		t.Parents = make([]cid.Cid, extra)
 	}
+
 	for i := 0; i < int(extra); i++ {
 
 		c, err := cbg.ReadCid(br)
@@ -177,25 +301,40 @@ func (t *BlockHeader) UnmarshalCBOR(r io.Reader) error {
 		t.Parents[i] = c
 	}
 
-	// t.ParentWeight (types.BigInt) (struct)
+	// t.ParentWeight (big.Int) (struct)
 
 	{
 
 		if err := t.ParentWeight.UnmarshalCBOR(br); err != nil {
-			return err
+			return xerrors.Errorf("unmarshaling t.ParentWeight: %w", err)
 		}
 
 	}
-	// t.Height (uint64) (uint64)
+	// t.Height (abi.ChainEpoch) (int64)
+	{
+		maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
+		var extraI int64
+		if err != nil {
+			return err
+		}
+		switch maj {
+		case cbg.MajUnsignedInt:
+			extraI = int64(extra)
+			if extraI < 0 {
+				return fmt.Errorf("int64 positive overflow")
+			}
+		case cbg.MajNegativeInt:
+			extraI = int64(extra)
+			if extraI < 0 {
+				return fmt.Errorf("int64 negative oveflow")
+			}
+			extraI = -1 - extraI
+		default:
+			return fmt.Errorf("wrong type for int64 field: %d", maj)
+		}
 
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
+		t.Height = abi.ChainEpoch(extraI)
 	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.Height = uint64(extra)
 	// t.ParentStateRoot (cid.Cid) (struct)
 
 	{
@@ -232,76 +371,119 @@ func (t *BlockHeader) UnmarshalCBOR(r io.Reader) error {
 		t.Messages = c
 
 	}
-	// t.BLSAggregate (types.Signature) (struct)
+	// t.BLSAggregate (crypto.Signature) (struct)
 
 	{
 
-		if err := t.BLSAggregate.UnmarshalCBOR(br); err != nil {
+		b, err := br.ReadByte()
+		if err != nil {
 			return err
 		}
+		if b != cbg.CborNull[0] {
+			if err := br.UnreadByte(); err != nil {
+				return err
+			}
+			t.BLSAggregate = new(crypto.Signature)
+			if err := t.BLSAggregate.UnmarshalCBOR(br); err != nil {
+				return xerrors.Errorf("unmarshaling t.BLSAggregate pointer: %w", err)
+			}
+		}
 
 	}
 	// t.Timestamp (uint64) (uint64)
 
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.Timestamp = uint64(extra)
-	// t.BlockSig (types.Signature) (struct)
-
 	{
 
-		pb, err := br.PeekByte()
+		maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
 		if err != nil {
 			return err
 		}
-		if pb == cbg.CborNull[0] {
-			var nbuf [1]byte
-			if _, err := br.Read(nbuf[:]); err != nil {
+		if maj != cbg.MajUnsignedInt {
+			return fmt.Errorf("wrong type for uint64 field")
+		}
+		t.Timestamp = uint64(extra)
+
+	}
+	// t.BlockSig (crypto.Signature) (struct)
+
+	{
+
+		b, err := br.ReadByte()
+		if err != nil {
+			return err
+		}
+		if b != cbg.CborNull[0] {
+			if err := br.UnreadByte(); err != nil {
 				return err
 			}
-		} else {
-			t.BlockSig = new(Signature)
+			t.BlockSig = new(crypto.Signature)
 			if err := t.BlockSig.UnmarshalCBOR(br); err != nil {
-				return err
+				return xerrors.Errorf("unmarshaling t.BlockSig pointer: %w", err)
 			}
 		}
 
+	}
+	// t.ForkSignaling (uint64) (uint64)
+
+	{
+
+		maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
+		if err != nil {
+			return err
+		}
+		if maj != cbg.MajUnsignedInt {
+			return fmt.Errorf("wrong type for uint64 field")
+		}
+		t.ForkSignaling = uint64(extra)
+
+	}
+	// t.ParentBaseFee (big.Int) (struct)
+
+	{
+
+		if err := t.ParentBaseFee.UnmarshalCBOR(br); err != nil {
+			return xerrors.Errorf("unmarshaling t.ParentBaseFee: %w", err)
+		}
+
 	}
 	return nil
 }
 
+var lengthBufTicket = []byte{129}
+
 func (t *Ticket) MarshalCBOR(w io.Writer) error {
 	if t == nil {
 		_, err := w.Write(cbg.CborNull)
 		return err
 	}
-	if _, err := w.Write([]byte{129}); err != nil {
+	if _, err := w.Write(lengthBufTicket); err != nil {
 		return err
 	}
 
+	scratch := make([]byte, 9)
+
 	// t.VRFProof ([]uint8) (slice)
 	if len(t.VRFProof) > cbg.ByteArrayMaxLen {
 		return xerrors.Errorf("Byte array in field t.VRFProof was too long")
 	}
 
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajByteString, uint64(len(t.VRFProof)))); err != nil {
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajByteString, uint64(len(t.VRFProof))); err != nil {
 		return err
 	}
-	if _, err := w.Write(t.VRFProof); err != nil {
+
+	if _, err := w.Write(t.VRFProof[:]); err != nil {
 		return err
 	}
 	return nil
 }
 
 func (t *Ticket) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
+	*t = Ticket{}
 
-	maj, extra, err := cbg.CborReadHeader(br)
+	br := cbg.GetPeeker(r)
+	scratch := make([]byte, 8)
+
+	maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
 	if err != nil {
 		return err
 	}
@@ -315,7 +497,7 @@ func (t *Ticket) UnmarshalCBOR(r io.Reader) error {
 
 	// t.VRFProof ([]uint8) (slice)
 
-	maj, extra, err = cbg.CborReadHeader(br)
+	maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
 	if err != nil {
 		return err
 	}
@@ -326,178 +508,63 @@ func (t *Ticket) UnmarshalCBOR(r io.Reader) error {
 	if maj != cbg.MajByteString {
 		return fmt.Errorf("expected byte array")
 	}
-	t.VRFProof = make([]byte, extra)
-	if _, err := io.ReadFull(br, t.VRFProof); err != nil {
-		return err
-	}
-	return nil
-}
 
-func (t *EPostProof) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{131}); err != nil {
-		return err
-	}
-
-	// t.Proof ([]uint8) (slice)
-	if len(t.Proof) > cbg.ByteArrayMaxLen {
-		return xerrors.Errorf("Byte array in field t.Proof was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajByteString, uint64(len(t.Proof)))); err != nil {
-		return err
-	}
-	if _, err := w.Write(t.Proof); err != nil {
-		return err
-	}
-
-	// t.PostRand ([]uint8) (slice)
-	if len(t.PostRand) > cbg.ByteArrayMaxLen {
-		return xerrors.Errorf("Byte array in field t.PostRand was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajByteString, uint64(len(t.PostRand)))); err != nil {
-		return err
-	}
-	if _, err := w.Write(t.PostRand); err != nil {
-		return err
-	}
-
-	// t.Candidates ([]types.EPostTicket) (slice)
-	if len(t.Candidates) > cbg.MaxLength {
-		return xerrors.Errorf("Slice value in field t.Candidates was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajArray, uint64(len(t.Candidates)))); err != nil {
-		return err
-	}
-	for _, v := range t.Candidates {
-		if err := v.MarshalCBOR(w); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func (t *EPostProof) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 3 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	// t.Proof ([]uint8) (slice)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-
-	if extra > cbg.ByteArrayMaxLen {
-		return fmt.Errorf("t.Proof: byte array too large (%d)", extra)
-	}
-	if maj != cbg.MajByteString {
-		return fmt.Errorf("expected byte array")
-	}
-	t.Proof = make([]byte, extra)
-	if _, err := io.ReadFull(br, t.Proof); err != nil {
-		return err
-	}
-	// t.PostRand ([]uint8) (slice)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-
-	if extra > cbg.ByteArrayMaxLen {
-		return fmt.Errorf("t.PostRand: byte array too large (%d)", extra)
-	}
-	if maj != cbg.MajByteString {
-		return fmt.Errorf("expected byte array")
-	}
-	t.PostRand = make([]byte, extra)
-	if _, err := io.ReadFull(br, t.PostRand); err != nil {
-		return err
-	}
-	// t.Candidates ([]types.EPostTicket) (slice)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-
-	if extra > cbg.MaxLength {
-		return fmt.Errorf("t.Candidates: array too large (%d)", extra)
-	}
-
-	if maj != cbg.MajArray {
-		return fmt.Errorf("expected cbor array")
-	}
 	if extra > 0 {
-		t.Candidates = make([]EPostTicket, extra)
-	}
-	for i := 0; i < int(extra); i++ {
-
-		var v EPostTicket
-		if err := v.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-		t.Candidates[i] = v
+		t.VRFProof = make([]uint8, extra)
 	}
 
+	if _, err := io.ReadFull(br, t.VRFProof[:]); err != nil {
+		return err
+	}
 	return nil
 }
 
-func (t *EPostTicket) MarshalCBOR(w io.Writer) error {
+var lengthBufElectionProof = []byte{130}
+
+func (t *ElectionProof) MarshalCBOR(w io.Writer) error {
 	if t == nil {
 		_, err := w.Write(cbg.CborNull)
 		return err
 	}
-	if _, err := w.Write([]byte{131}); err != nil {
+	if _, err := w.Write(lengthBufElectionProof); err != nil {
 		return err
 	}
 
-	// t.Partial ([]uint8) (slice)
-	if len(t.Partial) > cbg.ByteArrayMaxLen {
-		return xerrors.Errorf("Byte array in field t.Partial was too long")
+	scratch := make([]byte, 9)
+
+	// t.WinCount (int64) (int64)
+	if t.WinCount >= 0 {
+		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.WinCount)); err != nil {
+			return err
+		}
+	} else {
+		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajNegativeInt, uint64(-t.WinCount-1)); err != nil {
+			return err
+		}
 	}
 
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajByteString, uint64(len(t.Partial)))); err != nil {
-		return err
+	// t.VRFProof ([]uint8) (slice)
+	if len(t.VRFProof) > cbg.ByteArrayMaxLen {
+		return xerrors.Errorf("Byte array in field t.VRFProof was too long")
 	}
-	if _, err := w.Write(t.Partial); err != nil {
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajByteString, uint64(len(t.VRFProof))); err != nil {
 		return err
 	}
 
-	// t.SectorID (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.SectorID))); err != nil {
-		return err
-	}
-
-	// t.ChallengeIndex (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.ChallengeIndex))); err != nil {
+	if _, err := w.Write(t.VRFProof[:]); err != nil {
 		return err
 	}
 	return nil
 }
 
-func (t *EPostTicket) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
+func (t *ElectionProof) UnmarshalCBOR(r io.Reader) error {
+	*t = ElectionProof{}
 
-	maj, extra, err := cbg.CborReadHeader(br)
+	br := cbg.GetPeeker(r)
+	scratch := make([]byte, 8)
+
+	maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
 	if err != nil {
 		return err
 	}
@@ -505,56 +572,75 @@ func (t *EPostTicket) UnmarshalCBOR(r io.Reader) error {
 		return fmt.Errorf("cbor input should be of type array")
 	}
 
-	if extra != 3 {
+	if extra != 2 {
 		return fmt.Errorf("cbor input had wrong number of fields")
 	}
 
-	// t.Partial ([]uint8) (slice)
+	// t.WinCount (int64) (int64)
+	{
+		maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
+		var extraI int64
+		if err != nil {
+			return err
+		}
+		switch maj {
+		case cbg.MajUnsignedInt:
+			extraI = int64(extra)
+			if extraI < 0 {
+				return fmt.Errorf("int64 positive overflow")
+			}
+		case cbg.MajNegativeInt:
+			extraI = int64(extra)
+			if extraI < 0 {
+				return fmt.Errorf("int64 negative oveflow")
+			}
+			extraI = -1 - extraI
+		default:
+			return fmt.Errorf("wrong type for int64 field: %d", maj)
+		}
 
-	maj, extra, err = cbg.CborReadHeader(br)
+		t.WinCount = int64(extraI)
+	}
+	// t.VRFProof ([]uint8) (slice)
+
+	maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
 	if err != nil {
 		return err
 	}
 
 	if extra > cbg.ByteArrayMaxLen {
-		return fmt.Errorf("t.Partial: byte array too large (%d)", extra)
+		return fmt.Errorf("t.VRFProof: byte array too large (%d)", extra)
 	}
 	if maj != cbg.MajByteString {
 		return fmt.Errorf("expected byte array")
 	}
-	t.Partial = make([]byte, extra)
-	if _, err := io.ReadFull(br, t.Partial); err != nil {
-		return err
-	}
-	// t.SectorID (uint64) (uint64)
 
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
+	if extra > 0 {
+		t.VRFProof = make([]uint8, extra)
 	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.SectorID = uint64(extra)
-	// t.ChallengeIndex (uint64) (uint64)
 
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
+	if _, err := io.ReadFull(br, t.VRFProof[:]); err != nil {
 		return err
 	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.ChallengeIndex = uint64(extra)
 	return nil
 }
 
+var lengthBufMessage = []byte{138}
+
 func (t *Message) MarshalCBOR(w io.Writer) error {
 	if t == nil {
 		_, err := w.Write(cbg.CborNull)
 		return err
 	}
-	if _, err := w.Write([]byte{136}); err != nil {
+	if _, err := w.Write(lengthBufMessage); err != nil {
+		return err
+	}
+
+	scratch := make([]byte, 9)
+
+	// t.Version (uint64) (uint64)
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.Version)); err != nil {
 		return err
 	}
 
@@ -569,27 +655,40 @@ func (t *Message) MarshalCBOR(w io.Writer) error {
 	}
 
 	// t.Nonce (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.Nonce))); err != nil {
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.Nonce)); err != nil {
 		return err
 	}
 
-	// t.Value (types.BigInt) (struct)
+	// t.Value (big.Int) (struct)
 	if err := t.Value.MarshalCBOR(w); err != nil {
 		return err
 	}
 
-	// t.GasPrice (types.BigInt) (struct)
-	if err := t.GasPrice.MarshalCBOR(w); err != nil {
+	// t.GasLimit (int64) (int64)
+	if t.GasLimit >= 0 {
+		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.GasLimit)); err != nil {
+			return err
+		}
+	} else {
+		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajNegativeInt, uint64(-t.GasLimit-1)); err != nil {
+			return err
+		}
+	}
+
+	// t.GasFeeCap (big.Int) (struct)
+	if err := t.GasFeeCap.MarshalCBOR(w); err != nil {
 		return err
 	}
 
-	// t.GasLimit (types.BigInt) (struct)
-	if err := t.GasLimit.MarshalCBOR(w); err != nil {
+	// t.GasPremium (big.Int) (struct)
+	if err := t.GasPremium.MarshalCBOR(w); err != nil {
 		return err
 	}
 
-	// t.Method (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.Method))); err != nil {
+	// t.Method (abi.MethodNum) (uint64)
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.Method)); err != nil {
 		return err
 	}
 
@@ -598,19 +697,23 @@ func (t *Message) MarshalCBOR(w io.Writer) error {
 		return xerrors.Errorf("Byte array in field t.Params was too long")
 	}
 
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajByteString, uint64(len(t.Params)))); err != nil {
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajByteString, uint64(len(t.Params))); err != nil {
 		return err
 	}
-	if _, err := w.Write(t.Params); err != nil {
+
+	if _, err := w.Write(t.Params[:]); err != nil {
 		return err
 	}
 	return nil
 }
 
 func (t *Message) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
+	*t = Message{}
 
-	maj, extra, err := cbg.CborReadHeader(br)
+	br := cbg.GetPeeker(r)
+	scratch := make([]byte, 8)
+
+	maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
 	if err != nil {
 		return err
 	}
@@ -618,16 +721,30 @@ func (t *Message) UnmarshalCBOR(r io.Reader) error {
 		return fmt.Errorf("cbor input should be of type array")
 	}
 
-	if extra != 8 {
+	if extra != 10 {
 		return fmt.Errorf("cbor input had wrong number of fields")
 	}
 
+	// t.Version (uint64) (uint64)
+
+	{
+
+		maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
+		if err != nil {
+			return err
+		}
+		if maj != cbg.MajUnsignedInt {
+			return fmt.Errorf("wrong type for uint64 field")
+		}
+		t.Version = uint64(extra)
+
+	}
 	// t.To (address.Address) (struct)
 
 	{
 
 		if err := t.To.UnmarshalCBOR(br); err != nil {
-			return err
+			return xerrors.Errorf("unmarshaling t.To: %w", err)
 		}
 
 	}
@@ -636,60 +753,93 @@ func (t *Message) UnmarshalCBOR(r io.Reader) error {
 	{
 
 		if err := t.From.UnmarshalCBOR(br); err != nil {
-			return err
+			return xerrors.Errorf("unmarshaling t.From: %w", err)
 		}
 
 	}
 	// t.Nonce (uint64) (uint64)
 
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
+	{
+
+		maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
+		if err != nil {
+			return err
+		}
+		if maj != cbg.MajUnsignedInt {
+			return fmt.Errorf("wrong type for uint64 field")
+		}
+		t.Nonce = uint64(extra)
+
 	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.Nonce = uint64(extra)
-	// t.Value (types.BigInt) (struct)
+	// t.Value (big.Int) (struct)
 
 	{
 
 		if err := t.Value.UnmarshalCBOR(br); err != nil {
-			return err
+			return xerrors.Errorf("unmarshaling t.Value: %w", err)
 		}
 
 	}
-	// t.GasPrice (types.BigInt) (struct)
+	// t.GasLimit (int64) (int64)
+	{
+		maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
+		var extraI int64
+		if err != nil {
+			return err
+		}
+		switch maj {
+		case cbg.MajUnsignedInt:
+			extraI = int64(extra)
+			if extraI < 0 {
+				return fmt.Errorf("int64 positive overflow")
+			}
+		case cbg.MajNegativeInt:
+			extraI = int64(extra)
+			if extraI < 0 {
+				return fmt.Errorf("int64 negative oveflow")
+			}
+			extraI = -1 - extraI
+		default:
+			return fmt.Errorf("wrong type for int64 field: %d", maj)
+		}
+
+		t.GasLimit = int64(extraI)
+	}
+	// t.GasFeeCap (big.Int) (struct)
 
 	{
 
-		if err := t.GasPrice.UnmarshalCBOR(br); err != nil {
-			return err
+		if err := t.GasFeeCap.UnmarshalCBOR(br); err != nil {
+			return xerrors.Errorf("unmarshaling t.GasFeeCap: %w", err)
 		}
 
 	}
-	// t.GasLimit (types.BigInt) (struct)
+	// t.GasPremium (big.Int) (struct)
 
 	{
 
-		if err := t.GasLimit.UnmarshalCBOR(br); err != nil {
-			return err
+		if err := t.GasPremium.UnmarshalCBOR(br); err != nil {
+			return xerrors.Errorf("unmarshaling t.GasPremium: %w", err)
 		}
 
 	}
-	// t.Method (uint64) (uint64)
+	// t.Method (abi.MethodNum) (uint64)
+
+	{
+
+		maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
+		if err != nil {
+			return err
+		}
+		if maj != cbg.MajUnsignedInt {
+			return fmt.Errorf("wrong type for uint64 field")
+		}
+		t.Method = abi.MethodNum(extra)
 
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
 	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.Method = uint64(extra)
 	// t.Params ([]uint8) (slice)
 
-	maj, extra, err = cbg.CborReadHeader(br)
+	maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
 	if err != nil {
 		return err
 	}
@@ -700,19 +850,25 @@ func (t *Message) UnmarshalCBOR(r io.Reader) error {
 	if maj != cbg.MajByteString {
 		return fmt.Errorf("expected byte array")
 	}
-	t.Params = make([]byte, extra)
-	if _, err := io.ReadFull(br, t.Params); err != nil {
+
+	if extra > 0 {
+		t.Params = make([]uint8, extra)
+	}
+
+	if _, err := io.ReadFull(br, t.Params[:]); err != nil {
 		return err
 	}
 	return nil
 }
 
+var lengthBufSignedMessage = []byte{130}
+
 func (t *SignedMessage) MarshalCBOR(w io.Writer) error {
 	if t == nil {
 		_, err := w.Write(cbg.CborNull)
 		return err
 	}
-	if _, err := w.Write([]byte{130}); err != nil {
+	if _, err := w.Write(lengthBufSignedMessage); err != nil {
 		return err
 	}
 
@@ -721,7 +877,7 @@ func (t *SignedMessage) MarshalCBOR(w io.Writer) error {
 		return err
 	}
 
-	// t.Signature (types.Signature) (struct)
+	// t.Signature (crypto.Signature) (struct)
 	if err := t.Signature.MarshalCBOR(w); err != nil {
 		return err
 	}
@@ -729,9 +885,12 @@ func (t *SignedMessage) MarshalCBOR(w io.Writer) error {
 }
 
 func (t *SignedMessage) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
+	*t = SignedMessage{}
 
-	maj, extra, err := cbg.CborReadHeader(br)
+	br := cbg.GetPeeker(r)
+	scratch := make([]byte, 8)
+
+	maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
 	if err != nil {
 		return err
 	}
@@ -748,40 +907,44 @@ func (t *SignedMessage) UnmarshalCBOR(r io.Reader) error {
 	{
 
 		if err := t.Message.UnmarshalCBOR(br); err != nil {
-			return err
+			return xerrors.Errorf("unmarshaling t.Message: %w", err)
 		}
 
 	}
-	// t.Signature (types.Signature) (struct)
+	// t.Signature (crypto.Signature) (struct)
 
 	{
 
 		if err := t.Signature.UnmarshalCBOR(br); err != nil {
-			return err
+			return xerrors.Errorf("unmarshaling t.Signature: %w", err)
 		}
 
 	}
 	return nil
 }
 
+var lengthBufMsgMeta = []byte{130}
+
 func (t *MsgMeta) MarshalCBOR(w io.Writer) error {
 	if t == nil {
 		_, err := w.Write(cbg.CborNull)
 		return err
 	}
-	if _, err := w.Write([]byte{130}); err != nil {
+	if _, err := w.Write(lengthBufMsgMeta); err != nil {
 		return err
 	}
 
+	scratch := make([]byte, 9)
+
 	// t.BlsMessages (cid.Cid) (struct)
 
-	if err := cbg.WriteCid(w, t.BlsMessages); err != nil {
+	if err := cbg.WriteCidBuf(scratch, w, t.BlsMessages); err != nil {
 		return xerrors.Errorf("failed to write cid field t.BlsMessages: %w", err)
 	}
 
 	// t.SecpkMessages (cid.Cid) (struct)
 
-	if err := cbg.WriteCid(w, t.SecpkMessages); err != nil {
+	if err := cbg.WriteCidBuf(scratch, w, t.SecpkMessages); err != nil {
 		return xerrors.Errorf("failed to write cid field t.SecpkMessages: %w", err)
 	}
 
@@ -789,9 +952,12 @@ func (t *MsgMeta) MarshalCBOR(w io.Writer) error {
 }
 
 func (t *MsgMeta) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
+	*t = MsgMeta{}
 
-	maj, extra, err := cbg.CborReadHeader(br)
+	br := cbg.GetPeeker(r)
+	scratch := make([]byte, 8)
+
+	maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
 	if err != nil {
 		return err
 	}
@@ -830,404 +996,38 @@ func (t *MsgMeta) UnmarshalCBOR(r io.Reader) error {
 	return nil
 }
 
-func (t *SignedVoucher) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{137}); err != nil {
-		return err
-	}
-
-	// t.TimeLock (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.TimeLock))); err != nil {
-		return err
-	}
-
-	// t.SecretPreimage ([]uint8) (slice)
-	if len(t.SecretPreimage) > cbg.ByteArrayMaxLen {
-		return xerrors.Errorf("Byte array in field t.SecretPreimage was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajByteString, uint64(len(t.SecretPreimage)))); err != nil {
-		return err
-	}
-	if _, err := w.Write(t.SecretPreimage); err != nil {
-		return err
-	}
-
-	// t.Extra (types.ModVerifyParams) (struct)
-	if err := t.Extra.MarshalCBOR(w); err != nil {
-		return err
-	}
-
-	// t.Lane (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.Lane))); err != nil {
-		return err
-	}
-
-	// t.Nonce (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.Nonce))); err != nil {
-		return err
-	}
-
-	// t.Amount (types.BigInt) (struct)
-	if err := t.Amount.MarshalCBOR(w); err != nil {
-		return err
-	}
-
-	// t.MinCloseHeight (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.MinCloseHeight))); err != nil {
-		return err
-	}
-
-	// t.Merges ([]types.Merge) (slice)
-	if len(t.Merges) > cbg.MaxLength {
-		return xerrors.Errorf("Slice value in field t.Merges was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajArray, uint64(len(t.Merges)))); err != nil {
-		return err
-	}
-	for _, v := range t.Merges {
-		if err := v.MarshalCBOR(w); err != nil {
-			return err
-		}
-	}
-
-	// t.Signature (types.Signature) (struct)
-	if err := t.Signature.MarshalCBOR(w); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *SignedVoucher) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 9 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	// t.TimeLock (uint64) (uint64)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.TimeLock = uint64(extra)
-	// t.SecretPreimage ([]uint8) (slice)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-
-	if extra > cbg.ByteArrayMaxLen {
-		return fmt.Errorf("t.SecretPreimage: byte array too large (%d)", extra)
-	}
-	if maj != cbg.MajByteString {
-		return fmt.Errorf("expected byte array")
-	}
-	t.SecretPreimage = make([]byte, extra)
-	if _, err := io.ReadFull(br, t.SecretPreimage); err != nil {
-		return err
-	}
-	// t.Extra (types.ModVerifyParams) (struct)
-
-	{
-
-		pb, err := br.PeekByte()
-		if err != nil {
-			return err
-		}
-		if pb == cbg.CborNull[0] {
-			var nbuf [1]byte
-			if _, err := br.Read(nbuf[:]); err != nil {
-				return err
-			}
-		} else {
-			t.Extra = new(ModVerifyParams)
-			if err := t.Extra.UnmarshalCBOR(br); err != nil {
-				return err
-			}
-		}
-
-	}
-	// t.Lane (uint64) (uint64)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.Lane = uint64(extra)
-	// t.Nonce (uint64) (uint64)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.Nonce = uint64(extra)
-	// t.Amount (types.BigInt) (struct)
-
-	{
-
-		if err := t.Amount.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-	}
-	// t.MinCloseHeight (uint64) (uint64)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.MinCloseHeight = uint64(extra)
-	// t.Merges ([]types.Merge) (slice)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-
-	if extra > cbg.MaxLength {
-		return fmt.Errorf("t.Merges: array too large (%d)", extra)
-	}
-
-	if maj != cbg.MajArray {
-		return fmt.Errorf("expected cbor array")
-	}
-	if extra > 0 {
-		t.Merges = make([]Merge, extra)
-	}
-	for i := 0; i < int(extra); i++ {
-
-		var v Merge
-		if err := v.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-		t.Merges[i] = v
-	}
-
-	// t.Signature (types.Signature) (struct)
-
-	{
-
-		pb, err := br.PeekByte()
-		if err != nil {
-			return err
-		}
-		if pb == cbg.CborNull[0] {
-			var nbuf [1]byte
-			if _, err := br.Read(nbuf[:]); err != nil {
-				return err
-			}
-		} else {
-			t.Signature = new(Signature)
-			if err := t.Signature.UnmarshalCBOR(br); err != nil {
-				return err
-			}
-		}
-
-	}
-	return nil
-}
-
-func (t *ModVerifyParams) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{131}); err != nil {
-		return err
-	}
-
-	// t.Actor (address.Address) (struct)
-	if err := t.Actor.MarshalCBOR(w); err != nil {
-		return err
-	}
-
-	// t.Method (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.Method))); err != nil {
-		return err
-	}
-
-	// t.Data ([]uint8) (slice)
-	if len(t.Data) > cbg.ByteArrayMaxLen {
-		return xerrors.Errorf("Byte array in field t.Data was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajByteString, uint64(len(t.Data)))); err != nil {
-		return err
-	}
-	if _, err := w.Write(t.Data); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *ModVerifyParams) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 3 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	// t.Actor (address.Address) (struct)
-
-	{
-
-		if err := t.Actor.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-	}
-	// t.Method (uint64) (uint64)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.Method = uint64(extra)
-	// t.Data ([]uint8) (slice)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-
-	if extra > cbg.ByteArrayMaxLen {
-		return fmt.Errorf("t.Data: byte array too large (%d)", extra)
-	}
-	if maj != cbg.MajByteString {
-		return fmt.Errorf("expected byte array")
-	}
-	t.Data = make([]byte, extra)
-	if _, err := io.ReadFull(br, t.Data); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *Merge) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{130}); err != nil {
-		return err
-	}
-
-	// t.Lane (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.Lane))); err != nil {
-		return err
-	}
-
-	// t.Nonce (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.Nonce))); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *Merge) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 2 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	// t.Lane (uint64) (uint64)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.Lane = uint64(extra)
-	// t.Nonce (uint64) (uint64)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.Nonce = uint64(extra)
-	return nil
-}
+var lengthBufActor = []byte{132}
 
 func (t *Actor) MarshalCBOR(w io.Writer) error {
 	if t == nil {
 		_, err := w.Write(cbg.CborNull)
 		return err
 	}
-	if _, err := w.Write([]byte{132}); err != nil {
+	if _, err := w.Write(lengthBufActor); err != nil {
 		return err
 	}
 
+	scratch := make([]byte, 9)
+
 	// t.Code (cid.Cid) (struct)
 
-	if err := cbg.WriteCid(w, t.Code); err != nil {
+	if err := cbg.WriteCidBuf(scratch, w, t.Code); err != nil {
 		return xerrors.Errorf("failed to write cid field t.Code: %w", err)
 	}
 
 	// t.Head (cid.Cid) (struct)
 
-	if err := cbg.WriteCid(w, t.Head); err != nil {
+	if err := cbg.WriteCidBuf(scratch, w, t.Head); err != nil {
 		return xerrors.Errorf("failed to write cid field t.Head: %w", err)
 	}
 
 	// t.Nonce (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.Nonce))); err != nil {
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.Nonce)); err != nil {
 		return err
 	}
 
-	// t.Balance (types.BigInt) (struct)
+	// t.Balance (big.Int) (struct)
 	if err := t.Balance.MarshalCBOR(w); err != nil {
 		return err
 	}
@@ -1235,9 +1035,12 @@ func (t *Actor) MarshalCBOR(w io.Writer) error {
 }
 
 func (t *Actor) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
+	*t = Actor{}
 
-	maj, extra, err := cbg.CborReadHeader(br)
+	br := cbg.GetPeeker(r)
+	scratch := make([]byte, 8)
+
+	maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
 	if err != nil {
 		return err
 	}
@@ -1275,38 +1078,52 @@ func (t *Actor) UnmarshalCBOR(r io.Reader) error {
 	}
 	// t.Nonce (uint64) (uint64)
 
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
+	{
+
+		maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
+		if err != nil {
+			return err
+		}
+		if maj != cbg.MajUnsignedInt {
+			return fmt.Errorf("wrong type for uint64 field")
+		}
+		t.Nonce = uint64(extra)
+
 	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.Nonce = uint64(extra)
-	// t.Balance (types.BigInt) (struct)
+	// t.Balance (big.Int) (struct)
 
 	{
 
 		if err := t.Balance.UnmarshalCBOR(br); err != nil {
-			return err
+			return xerrors.Errorf("unmarshaling t.Balance: %w", err)
 		}
 
 	}
 	return nil
 }
 
+var lengthBufMessageReceipt = []byte{131}
+
 func (t *MessageReceipt) MarshalCBOR(w io.Writer) error {
 	if t == nil {
 		_, err := w.Write(cbg.CborNull)
 		return err
 	}
-	if _, err := w.Write([]byte{131}); err != nil {
+	if _, err := w.Write(lengthBufMessageReceipt); err != nil {
 		return err
 	}
 
-	// t.ExitCode (uint8) (uint8)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.ExitCode))); err != nil {
-		return err
+	scratch := make([]byte, 9)
+
+	// t.ExitCode (exitcode.ExitCode) (int64)
+	if t.ExitCode >= 0 {
+		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.ExitCode)); err != nil {
+			return err
+		}
+	} else {
+		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajNegativeInt, uint64(-t.ExitCode-1)); err != nil {
+			return err
+		}
 	}
 
 	// t.Return ([]uint8) (slice)
@@ -1314,24 +1131,34 @@ func (t *MessageReceipt) MarshalCBOR(w io.Writer) error {
 		return xerrors.Errorf("Byte array in field t.Return was too long")
 	}
 
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajByteString, uint64(len(t.Return)))); err != nil {
-		return err
-	}
-	if _, err := w.Write(t.Return); err != nil {
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajByteString, uint64(len(t.Return))); err != nil {
 		return err
 	}
 
-	// t.GasUsed (types.BigInt) (struct)
-	if err := t.GasUsed.MarshalCBOR(w); err != nil {
+	if _, err := w.Write(t.Return[:]); err != nil {
 		return err
 	}
+
+	// t.GasUsed (int64) (int64)
+	if t.GasUsed >= 0 {
+		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.GasUsed)); err != nil {
+			return err
+		}
+	} else {
+		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajNegativeInt, uint64(-t.GasUsed-1)); err != nil {
+			return err
+		}
+	}
 	return nil
 }
 
 func (t *MessageReceipt) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
+	*t = MessageReceipt{}
 
-	maj, extra, err := cbg.CborReadHeader(br)
+	br := cbg.GetPeeker(r)
+	scratch := make([]byte, 8)
+
+	maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
 	if err != nil {
 		return err
 	}
@@ -1343,22 +1170,34 @@ func (t *MessageReceipt) UnmarshalCBOR(r io.Reader) error {
 		return fmt.Errorf("cbor input had wrong number of fields")
 	}
 
-	// t.ExitCode (uint8) (uint8)
+	// t.ExitCode (exitcode.ExitCode) (int64)
+	{
+		maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
+		var extraI int64
+		if err != nil {
+			return err
+		}
+		switch maj {
+		case cbg.MajUnsignedInt:
+			extraI = int64(extra)
+			if extraI < 0 {
+				return fmt.Errorf("int64 positive overflow")
+			}
+		case cbg.MajNegativeInt:
+			extraI = int64(extra)
+			if extraI < 0 {
+				return fmt.Errorf("int64 negative oveflow")
+			}
+			extraI = -1 - extraI
+		default:
+			return fmt.Errorf("wrong type for int64 field: %d", maj)
+		}
 
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
+		t.ExitCode = exitcode.ExitCode(extraI)
 	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint8 field")
-	}
-	if extra > math.MaxUint8 {
-		return fmt.Errorf("integer in input was too large for uint8 field")
-	}
-	t.ExitCode = uint8(extra)
 	// t.Return ([]uint8) (slice)
 
-	maj, extra, err = cbg.CborReadHeader(br)
+	maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
 	if err != nil {
 		return err
 	}
@@ -1369,31 +1208,55 @@ func (t *MessageReceipt) UnmarshalCBOR(r io.Reader) error {
 	if maj != cbg.MajByteString {
 		return fmt.Errorf("expected byte array")
 	}
-	t.Return = make([]byte, extra)
-	if _, err := io.ReadFull(br, t.Return); err != nil {
+
+	if extra > 0 {
+		t.Return = make([]uint8, extra)
+	}
+
+	if _, err := io.ReadFull(br, t.Return[:]); err != nil {
 		return err
 	}
-	// t.GasUsed (types.BigInt) (struct)
-
+	// t.GasUsed (int64) (int64)
 	{
-
-		if err := t.GasUsed.UnmarshalCBOR(br); err != nil {
+		maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
+		var extraI int64
+		if err != nil {
 			return err
 		}
+		switch maj {
+		case cbg.MajUnsignedInt:
+			extraI = int64(extra)
+			if extraI < 0 {
+				return fmt.Errorf("int64 positive overflow")
+			}
+		case cbg.MajNegativeInt:
+			extraI = int64(extra)
+			if extraI < 0 {
+				return fmt.Errorf("int64 negative oveflow")
+			}
+			extraI = -1 - extraI
+		default:
+			return fmt.Errorf("wrong type for int64 field: %d", maj)
+		}
 
+		t.GasUsed = int64(extraI)
 	}
 	return nil
 }
 
+var lengthBufBlockMsg = []byte{131}
+
 func (t *BlockMsg) MarshalCBOR(w io.Writer) error {
 	if t == nil {
 		_, err := w.Write(cbg.CborNull)
 		return err
 	}
-	if _, err := w.Write([]byte{131}); err != nil {
+	if _, err := w.Write(lengthBufBlockMsg); err != nil {
 		return err
 	}
 
+	scratch := make([]byte, 9)
+
 	// t.Header (types.BlockHeader) (struct)
 	if err := t.Header.MarshalCBOR(w); err != nil {
 		return err
@@ -1404,11 +1267,11 @@ func (t *BlockMsg) MarshalCBOR(w io.Writer) error {
 		return xerrors.Errorf("Slice value in field t.BlsMessages was too long")
 	}
 
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajArray, uint64(len(t.BlsMessages)))); err != nil {
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajArray, uint64(len(t.BlsMessages))); err != nil {
 		return err
 	}
 	for _, v := range t.BlsMessages {
-		if err := cbg.WriteCid(w, v); err != nil {
+		if err := cbg.WriteCidBuf(scratch, w, v); err != nil {
 			return xerrors.Errorf("failed writing cid field t.BlsMessages: %w", err)
 		}
 	}
@@ -1418,11 +1281,11 @@ func (t *BlockMsg) MarshalCBOR(w io.Writer) error {
 		return xerrors.Errorf("Slice value in field t.SecpkMessages was too long")
 	}
 
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajArray, uint64(len(t.SecpkMessages)))); err != nil {
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajArray, uint64(len(t.SecpkMessages))); err != nil {
 		return err
 	}
 	for _, v := range t.SecpkMessages {
-		if err := cbg.WriteCid(w, v); err != nil {
+		if err := cbg.WriteCidBuf(scratch, w, v); err != nil {
 			return xerrors.Errorf("failed writing cid field t.SecpkMessages: %w", err)
 		}
 	}
@@ -1430,9 +1293,12 @@ func (t *BlockMsg) MarshalCBOR(w io.Writer) error {
 }
 
 func (t *BlockMsg) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
+	*t = BlockMsg{}
 
-	maj, extra, err := cbg.CborReadHeader(br)
+	br := cbg.GetPeeker(r)
+	scratch := make([]byte, 8)
+
+	maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
 	if err != nil {
 		return err
 	}
@@ -1448,26 +1314,24 @@ func (t *BlockMsg) UnmarshalCBOR(r io.Reader) error {
 
 	{
 
-		pb, err := br.PeekByte()
+		b, err := br.ReadByte()
 		if err != nil {
 			return err
 		}
-		if pb == cbg.CborNull[0] {
-			var nbuf [1]byte
-			if _, err := br.Read(nbuf[:]); err != nil {
+		if b != cbg.CborNull[0] {
+			if err := br.UnreadByte(); err != nil {
 				return err
 			}
-		} else {
 			t.Header = new(BlockHeader)
 			if err := t.Header.UnmarshalCBOR(br); err != nil {
-				return err
+				return xerrors.Errorf("unmarshaling t.Header pointer: %w", err)
 			}
 		}
 
 	}
 	// t.BlsMessages ([]cid.Cid) (slice)
 
-	maj, extra, err = cbg.CborReadHeader(br)
+	maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
 	if err != nil {
 		return err
 	}
@@ -1479,9 +1343,11 @@ func (t *BlockMsg) UnmarshalCBOR(r io.Reader) error {
 	if maj != cbg.MajArray {
 		return fmt.Errorf("expected cbor array")
 	}
+
 	if extra > 0 {
 		t.BlsMessages = make([]cid.Cid, extra)
 	}
+
 	for i := 0; i < int(extra); i++ {
 
 		c, err := cbg.ReadCid(br)
@@ -1493,7 +1359,7 @@ func (t *BlockMsg) UnmarshalCBOR(r io.Reader) error {
 
 	// t.SecpkMessages ([]cid.Cid) (slice)
 
-	maj, extra, err = cbg.CborReadHeader(br)
+	maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
 	if err != nil {
 		return err
 	}
@@ -1505,9 +1371,11 @@ func (t *BlockMsg) UnmarshalCBOR(r io.Reader) error {
 	if maj != cbg.MajArray {
 		return fmt.Errorf("expected cbor array")
 	}
+
 	if extra > 0 {
 		t.SecpkMessages = make([]cid.Cid, extra)
 	}
+
 	for i := 0; i < int(extra); i++ {
 
 		c, err := cbg.ReadCid(br)
@@ -1520,223 +1388,29 @@ func (t *BlockMsg) UnmarshalCBOR(r io.Reader) error {
 	return nil
 }
 
-func (t *SignedStorageAsk) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{130}); err != nil {
-		return err
-	}
-
-	// t.Ask (types.StorageAsk) (struct)
-	if err := t.Ask.MarshalCBOR(w); err != nil {
-		return err
-	}
-
-	// t.Signature (types.Signature) (struct)
-	if err := t.Signature.MarshalCBOR(w); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *SignedStorageAsk) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 2 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	// t.Ask (types.StorageAsk) (struct)
-
-	{
-
-		pb, err := br.PeekByte()
-		if err != nil {
-			return err
-		}
-		if pb == cbg.CborNull[0] {
-			var nbuf [1]byte
-			if _, err := br.Read(nbuf[:]); err != nil {
-				return err
-			}
-		} else {
-			t.Ask = new(StorageAsk)
-			if err := t.Ask.UnmarshalCBOR(br); err != nil {
-				return err
-			}
-		}
-
-	}
-	// t.Signature (types.Signature) (struct)
-
-	{
-
-		pb, err := br.PeekByte()
-		if err != nil {
-			return err
-		}
-		if pb == cbg.CborNull[0] {
-			var nbuf [1]byte
-			if _, err := br.Read(nbuf[:]); err != nil {
-				return err
-			}
-		} else {
-			t.Signature = new(Signature)
-			if err := t.Signature.UnmarshalCBOR(br); err != nil {
-				return err
-			}
-		}
-
-	}
-	return nil
-}
-
-func (t *StorageAsk) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{134}); err != nil {
-		return err
-	}
-
-	// t.Price (types.BigInt) (struct)
-	if err := t.Price.MarshalCBOR(w); err != nil {
-		return err
-	}
-
-	// t.MinPieceSize (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.MinPieceSize))); err != nil {
-		return err
-	}
-
-	// t.Miner (address.Address) (struct)
-	if err := t.Miner.MarshalCBOR(w); err != nil {
-		return err
-	}
-
-	// t.Timestamp (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.Timestamp))); err != nil {
-		return err
-	}
-
-	// t.Expiry (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.Expiry))); err != nil {
-		return err
-	}
-
-	// t.SeqNo (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.SeqNo))); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *StorageAsk) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 6 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	// t.Price (types.BigInt) (struct)
-
-	{
-
-		if err := t.Price.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-	}
-	// t.MinPieceSize (uint64) (uint64)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.MinPieceSize = uint64(extra)
-	// t.Miner (address.Address) (struct)
-
-	{
-
-		if err := t.Miner.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-	}
-	// t.Timestamp (uint64) (uint64)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.Timestamp = uint64(extra)
-	// t.Expiry (uint64) (uint64)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.Expiry = uint64(extra)
-	// t.SeqNo (uint64) (uint64)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.SeqNo = uint64(extra)
-	return nil
-}
+var lengthBufExpTipSet = []byte{131}
 
 func (t *ExpTipSet) MarshalCBOR(w io.Writer) error {
 	if t == nil {
 		_, err := w.Write(cbg.CborNull)
 		return err
 	}
-	if _, err := w.Write([]byte{131}); err != nil {
+	if _, err := w.Write(lengthBufExpTipSet); err != nil {
 		return err
 	}
 
+	scratch := make([]byte, 9)
+
 	// t.Cids ([]cid.Cid) (slice)
 	if len(t.Cids) > cbg.MaxLength {
 		return xerrors.Errorf("Slice value in field t.Cids was too long")
 	}
 
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajArray, uint64(len(t.Cids)))); err != nil {
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajArray, uint64(len(t.Cids))); err != nil {
 		return err
 	}
 	for _, v := range t.Cids {
-		if err := cbg.WriteCid(w, v); err != nil {
+		if err := cbg.WriteCidBuf(scratch, w, v); err != nil {
 			return xerrors.Errorf("failed writing cid field t.Cids: %w", err)
 		}
 	}
@@ -1746,7 +1420,7 @@ func (t *ExpTipSet) MarshalCBOR(w io.Writer) error {
 		return xerrors.Errorf("Slice value in field t.Blocks was too long")
 	}
 
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajArray, uint64(len(t.Blocks)))); err != nil {
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajArray, uint64(len(t.Blocks))); err != nil {
 		return err
 	}
 	for _, v := range t.Blocks {
@@ -1755,17 +1429,26 @@ func (t *ExpTipSet) MarshalCBOR(w io.Writer) error {
 		}
 	}
 
-	// t.Height (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.Height))); err != nil {
-		return err
+	// t.Height (abi.ChainEpoch) (int64)
+	if t.Height >= 0 {
+		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.Height)); err != nil {
+			return err
+		}
+	} else {
+		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajNegativeInt, uint64(-t.Height-1)); err != nil {
+			return err
+		}
 	}
 	return nil
 }
 
 func (t *ExpTipSet) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
+	*t = ExpTipSet{}
 
-	maj, extra, err := cbg.CborReadHeader(br)
+	br := cbg.GetPeeker(r)
+	scratch := make([]byte, 8)
+
+	maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
 	if err != nil {
 		return err
 	}
@@ -1779,7 +1462,7 @@ func (t *ExpTipSet) UnmarshalCBOR(r io.Reader) error {
 
 	// t.Cids ([]cid.Cid) (slice)
 
-	maj, extra, err = cbg.CborReadHeader(br)
+	maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
 	if err != nil {
 		return err
 	}
@@ -1791,9 +1474,11 @@ func (t *ExpTipSet) UnmarshalCBOR(r io.Reader) error {
 	if maj != cbg.MajArray {
 		return fmt.Errorf("expected cbor array")
 	}
+
 	if extra > 0 {
 		t.Cids = make([]cid.Cid, extra)
 	}
+
 	for i := 0; i < int(extra); i++ {
 
 		c, err := cbg.ReadCid(br)
@@ -1805,7 +1490,7 @@ func (t *ExpTipSet) UnmarshalCBOR(r io.Reader) error {
 
 	// t.Blocks ([]*types.BlockHeader) (slice)
 
-	maj, extra, err = cbg.CborReadHeader(br)
+	maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
 	if err != nil {
 		return err
 	}
@@ -1817,9 +1502,11 @@ func (t *ExpTipSet) UnmarshalCBOR(r io.Reader) error {
 	if maj != cbg.MajArray {
 		return fmt.Errorf("expected cbor array")
 	}
+
 	if extra > 0 {
 		t.Blocks = make([]*BlockHeader, extra)
 	}
+
 	for i := 0; i < int(extra); i++ {
 
 		var v BlockHeader
@@ -1830,15 +1517,248 @@ func (t *ExpTipSet) UnmarshalCBOR(r io.Reader) error {
 		t.Blocks[i] = &v
 	}
 
-	// t.Height (uint64) (uint64)
+	// t.Height (abi.ChainEpoch) (int64)
+	{
+		maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
+		var extraI int64
+		if err != nil {
+			return err
+		}
+		switch maj {
+		case cbg.MajUnsignedInt:
+			extraI = int64(extra)
+			if extraI < 0 {
+				return fmt.Errorf("int64 positive overflow")
+			}
+		case cbg.MajNegativeInt:
+			extraI = int64(extra)
+			if extraI < 0 {
+				return fmt.Errorf("int64 negative oveflow")
+			}
+			extraI = -1 - extraI
+		default:
+			return fmt.Errorf("wrong type for int64 field: %d", maj)
+		}
 
-	maj, extra, err = cbg.CborReadHeader(br)
+		t.Height = abi.ChainEpoch(extraI)
+	}
+	return nil
+}
+
+var lengthBufBeaconEntry = []byte{130}
+
+func (t *BeaconEntry) MarshalCBOR(w io.Writer) error {
+	if t == nil {
+		_, err := w.Write(cbg.CborNull)
+		return err
+	}
+	if _, err := w.Write(lengthBufBeaconEntry); err != nil {
+		return err
+	}
+
+	scratch := make([]byte, 9)
+
+	// t.Round (uint64) (uint64)
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.Round)); err != nil {
+		return err
+	}
+
+	// t.Data ([]uint8) (slice)
+	if len(t.Data) > cbg.ByteArrayMaxLen {
+		return xerrors.Errorf("Byte array in field t.Data was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajByteString, uint64(len(t.Data))); err != nil {
+		return err
+	}
+
+	if _, err := w.Write(t.Data[:]); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (t *BeaconEntry) UnmarshalCBOR(r io.Reader) error {
+	*t = BeaconEntry{}
+
+	br := cbg.GetPeeker(r)
+	scratch := make([]byte, 8)
+
+	maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
 	if err != nil {
 		return err
 	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
+	if maj != cbg.MajArray {
+		return fmt.Errorf("cbor input should be of type array")
+	}
+
+	if extra != 2 {
+		return fmt.Errorf("cbor input had wrong number of fields")
+	}
+
+	// t.Round (uint64) (uint64)
+
+	{
+
+		maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
+		if err != nil {
+			return err
+		}
+		if maj != cbg.MajUnsignedInt {
+			return fmt.Errorf("wrong type for uint64 field")
+		}
+		t.Round = uint64(extra)
+
+	}
+	// t.Data ([]uint8) (slice)
+
+	maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
+	if err != nil {
+		return err
+	}
+
+	if extra > cbg.ByteArrayMaxLen {
+		return fmt.Errorf("t.Data: byte array too large (%d)", extra)
+	}
+	if maj != cbg.MajByteString {
+		return fmt.Errorf("expected byte array")
+	}
+
+	if extra > 0 {
+		t.Data = make([]uint8, extra)
+	}
+
+	if _, err := io.ReadFull(br, t.Data[:]); err != nil {
+		return err
 	}
-	t.Height = uint64(extra)
+	return nil
+}
+
+var lengthBufStateRoot = []byte{131}
+
+func (t *StateRoot) MarshalCBOR(w io.Writer) error {
+	if t == nil {
+		_, err := w.Write(cbg.CborNull)
+		return err
+	}
+	if _, err := w.Write(lengthBufStateRoot); err != nil {
+		return err
+	}
+
+	scratch := make([]byte, 9)
+
+	// t.Version (uint64) (uint64)
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.Version)); err != nil {
+		return err
+	}
+
+	// t.Actors (cid.Cid) (struct)
+
+	if err := cbg.WriteCidBuf(scratch, w, t.Actors); err != nil {
+		return xerrors.Errorf("failed to write cid field t.Actors: %w", err)
+	}
+
+	// t.Info (cid.Cid) (struct)
+
+	if err := cbg.WriteCidBuf(scratch, w, t.Info); err != nil {
+		return xerrors.Errorf("failed to write cid field t.Info: %w", err)
+	}
+
+	return nil
+}
+
+func (t *StateRoot) UnmarshalCBOR(r io.Reader) error {
+	*t = StateRoot{}
+
+	br := cbg.GetPeeker(r)
+	scratch := make([]byte, 8)
+
+	maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
+	if err != nil {
+		return err
+	}
+	if maj != cbg.MajArray {
+		return fmt.Errorf("cbor input should be of type array")
+	}
+
+	if extra != 3 {
+		return fmt.Errorf("cbor input had wrong number of fields")
+	}
+
+	// t.Version (uint64) (uint64)
+
+	{
+
+		maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
+		if err != nil {
+			return err
+		}
+		if maj != cbg.MajUnsignedInt {
+			return fmt.Errorf("wrong type for uint64 field")
+		}
+		t.Version = uint64(extra)
+
+	}
+	// t.Actors (cid.Cid) (struct)
+
+	{
+
+		c, err := cbg.ReadCid(br)
+		if err != nil {
+			return xerrors.Errorf("failed to read cid field t.Actors: %w", err)
+		}
+
+		t.Actors = c
+
+	}
+	// t.Info (cid.Cid) (struct)
+
+	{
+
+		c, err := cbg.ReadCid(br)
+		if err != nil {
+			return xerrors.Errorf("failed to read cid field t.Info: %w", err)
+		}
+
+		t.Info = c
+
+	}
+	return nil
+}
+
+var lengthBufStateInfo = []byte{128}
+
+func (t *StateInfo) MarshalCBOR(w io.Writer) error {
+	if t == nil {
+		_, err := w.Write(cbg.CborNull)
+		return err
+	}
+	if _, err := w.Write(lengthBufStateInfo); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (t *StateInfo) UnmarshalCBOR(r io.Reader) error {
+	*t = StateInfo{}
+
+	br := cbg.GetPeeker(r)
+	scratch := make([]byte, 8)
+
+	maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
+	if err != nil {
+		return err
+	}
+	if maj != cbg.MajArray {
+		return fmt.Errorf("cbor input should be of type array")
+	}
+
+	if extra != 0 {
+		return fmt.Errorf("cbor input had wrong number of fields")
+	}
+
 	return nil
 }
diff --git a/chain/types/electionproof.go b/chain/types/electionproof.go
new file mode 100644
index 000000000..b8879b27c
--- /dev/null
+++ b/chain/types/electionproof.go
@@ -0,0 +1,205 @@
+package types
+
+import (
+	"math/big"
+
+	"github.com/filecoin-project/lotus/build"
+	"github.com/minio/blake2b-simd"
+)
+
+type ElectionProof struct {
+	WinCount int64
+	VRFProof []byte
+}
+
+const precision = 256
+
+var (
+	expNumCoef  []*big.Int
+	expDenoCoef []*big.Int
+)
+
+func init() {
+	parse := func(coefs []string) []*big.Int {
+		out := make([]*big.Int, len(coefs))
+		for i, coef := range coefs {
+			c, ok := new(big.Int).SetString(coef, 10)
+			if !ok {
+				panic("could not parse exp paramemter")
+			}
+			// << 256 (Q.0 to Q.256), >> 128 to transform integer params to coefficients
+			c = c.Lsh(c, precision-128)
+			out[i] = c
+		}
+		return out
+	}
+
+	// parameters are in integer format,
+	// coefficients are *2^-128 of that
+	num := []string{
+		"-648770010757830093818553637600",
+		"67469480939593786226847644286976",
+		"-3197587544499098424029388939001856",
+		"89244641121992890118377641805348864",
+		"-1579656163641440567800982336819953664",
+		"17685496037279256458459817590917169152",
+		"-115682590513835356866803355398940131328",
+		"340282366920938463463374607431768211456",
+	}
+	expNumCoef = parse(num)
+
+	deno := []string{
+		"1225524182432722209606361",
+		"114095592300906098243859450",
+		"5665570424063336070530214243",
+		"194450132448609991765137938448",
+		"5068267641632683791026134915072",
+		"104716890604972796896895427629056",
+		"1748338658439454459487681798864896",
+		"23704654329841312470660182937960448",
+		"259380097567996910282699886670381056",
+		"2250336698853390384720606936038375424",
+		"14978272436876548034486263159246028800",
+		"72144088983913131323343765784380833792",
+		"224599776407103106596571252037123047424",
+		"340282366920938463463374607431768211456",
+	}
+	expDenoCoef = parse(deno)
+}
+
+// expneg accepts x in Q.256 format and computes e^-x.
+// It is most precise within [0, 1.725) range, where error is less than 3.4e-30.
+// Over the [0, 5) range its error is less than 4.6e-15.
+// Output is in Q.256 format.
+func expneg(x *big.Int) *big.Int {
+	// exp is approximated by rational function
+	// polynomials of the rational function are evaluated using Horner's method
+	num := polyval(expNumCoef, x)   // Q.256
+	deno := polyval(expDenoCoef, x) // Q.256
+
+	num = num.Lsh(num, precision) // Q.512
+	return num.Div(num, deno)     // Q.512 / Q.256 => Q.256
+}
+
+// polyval evaluates a polynomial given by coefficients `p` in Q.256 format
+// at point `x` in Q.256 format. Output is in Q.256.
+// Coefficients should be ordered from the highest order coefficient to the lowest.
+func polyval(p []*big.Int, x *big.Int) *big.Int {
+	// evaluation using Horner's method
+	res := new(big.Int).Set(p[0]) // Q.256
+	tmp := new(big.Int)           // big.Int.Mul doesn't like when input is reused as output
+	for _, c := range p[1:] {
+		tmp = tmp.Mul(res, x)         // Q.256 * Q.256 => Q.512
+		res = res.Rsh(tmp, precision) // Q.512 >> 256 => Q.256
+		res = res.Add(res, c)
+	}
+
+	return res
+}
+
+// computes lambda in Q.256
+func lambda(power, totalPower *big.Int) *big.Int {
+	lam := new(big.Int).Mul(power, blocksPerEpoch.Int)   // Q.0
+	lam = lam.Lsh(lam, precision)                        // Q.256
+	lam = lam.Div(lam /* Q.256 */, totalPower /* Q.0 */) // Q.256
+	return lam
+}
+
+var MaxWinCount = 3 * int64(build.BlocksPerEpoch)
+
+type poiss struct {
+	lam  *big.Int
+	pmf  *big.Int
+	icdf *big.Int
+
+	tmp *big.Int // temporary variable for optimization
+
+	k uint64
+}
+
+// newPoiss starts poisson inverted CDF
+// lambda is in Q.256 format
+// returns (instance, `1-poisscdf(0, lambda)`)
+// CDF value returend is reused when calling `next`
+func newPoiss(lambda *big.Int) (*poiss, *big.Int) {
+
+	// pmf(k) = (lambda^k)*(e^lambda) / k!
+	// k = 0 here, so it simplifies to just e^-lambda
+	elam := expneg(lambda) // Q.256
+	pmf := new(big.Int).Set(elam)
+
+	// icdf(k) = 1 - ∑ᵏᵢ₌₀ pmf(i)
+	// icdf(0) = 1 - pmf(0)
+	icdf := big.NewInt(1)
+	icdf = icdf.Lsh(icdf, precision) // Q.256
+	icdf = icdf.Sub(icdf, pmf)       // Q.256
+
+	k := uint64(0)
+
+	p := &poiss{
+		lam: lambda,
+		pmf: pmf,
+
+		tmp:  elam,
+		icdf: icdf,
+
+		k: k,
+	}
+
+	return p, icdf
+}
+
+// next computes `k++, 1-poisscdf(k, lam)`
+// return is in Q.256 format
+func (p *poiss) next() *big.Int {
+	// incrementally compute next pmf and icdf
+
+	// pmf(k) = (lambda^k)*(e^lambda) / k!
+	// so pmf(k) = pmf(k-1) * lambda / k
+	p.k++
+	p.tmp.SetUint64(p.k) // Q.0
+
+	// calculate pmf for k
+	p.pmf = p.pmf.Div(p.pmf, p.tmp) // Q.256 / Q.0 => Q.256
+	// we are using `tmp` as target for multiplication as using an input as output
+	// for Int.Mul causes allocations
+	p.tmp = p.tmp.Mul(p.pmf, p.lam)     // Q.256 * Q.256 => Q.512
+	p.pmf = p.pmf.Rsh(p.tmp, precision) // Q.512 >> 256 => Q.256
+
+	// calculate output
+	// icdf(k) = icdf(k-1) - pmf(k)
+	p.icdf = p.icdf.Sub(p.icdf, p.pmf) // Q.256
+	return p.icdf
+}
+
+// ComputeWinCount uses VRFProof to compute number of wins
+// The algorithm is based on Algorand's Sortition with Binomial distribution
+// replaced by Poisson distribution.
+func (ep *ElectionProof) ComputeWinCount(power BigInt, totalPower BigInt) int64 {
+	h := blake2b.Sum256(ep.VRFProof)
+
+	lhs := BigFromBytes(h[:]).Int // 256bits, assume Q.256 so [0, 1)
+
+	// We are calculating upside-down CDF of Poisson distribution with
+	// rate λ=power*E/totalPower
+	// Steps:
+	//  1. calculate λ=power*E/totalPower
+	//  2. calculate elam = exp(-λ)
+	//  3. Check how many times we win:
+	//    j = 0
+	//    pmf = elam
+	//    rhs = 1 - pmf
+	//    for h(vrf) < rhs: j++; pmf = pmf * lam / j; rhs = rhs - pmf
+
+	lam := lambda(power.Int, totalPower.Int) // Q.256
+
+	p, rhs := newPoiss(lam)
+
+	var j int64
+	for lhs.Cmp(rhs) < 0 && j < MaxWinCount {
+		rhs = p.next()
+		j++
+	}
+
+	return j
+}
diff --git a/chain/types/electionproof_test.go b/chain/types/electionproof_test.go
new file mode 100644
index 000000000..9344ff6a6
--- /dev/null
+++ b/chain/types/electionproof_test.go
@@ -0,0 +1,145 @@
+package types
+
+import (
+	"bytes"
+	"fmt"
+	"math/big"
+	"os"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/xorcare/golden"
+)
+
+func TestPoissonFunction(t *testing.T) {
+	tests := []struct {
+		lambdaBase  uint64
+		lambdaShift uint
+	}{
+		{10, 10},      // 0.0097
+		{209714, 20},  // 0.19999885
+		{1036915, 20}, // 0.9888792038
+		{1706, 10},    // 1.6660
+		{2, 0},        // 2
+		{5242879, 20}, //4.9999990
+		{5, 0},        // 5
+	}
+
+	for _, test := range tests {
+		test := test
+		t.Run(fmt.Sprintf("lam-%d-%d", test.lambdaBase, test.lambdaShift), func(t *testing.T) {
+			b := &bytes.Buffer{}
+			b.WriteString("icdf\n")
+
+			lam := new(big.Int).SetUint64(test.lambdaBase)
+			lam = lam.Lsh(lam, precision-test.lambdaShift)
+			p, icdf := newPoiss(lam)
+
+			b.WriteString(icdf.String())
+			b.WriteRune('\n')
+
+			for i := 0; i < 15; i++ {
+				b.WriteString(p.next().String())
+				b.WriteRune('\n')
+			}
+			golden.Assert(t, []byte(b.String()))
+		})
+	}
+}
+
+func TestLambdaFunction(t *testing.T) {
+	tests := []struct {
+		power      string
+		totalPower string
+		target     float64
+	}{
+		{"10", "100", .1 * 5.},
+		{"1024", "2048", 0.5 * 5.},
+		{"2000000000000000", "100000000000000000", 0.02 * 5.},
+	}
+
+	for _, test := range tests {
+		test := test
+		t.Run(fmt.Sprintf("%s-%s", test.power, test.totalPower), func(t *testing.T) {
+			pow, ok := new(big.Int).SetString(test.power, 10)
+			assert.True(t, ok)
+			total, ok := new(big.Int).SetString(test.totalPower, 10)
+			assert.True(t, ok)
+			lam := lambda(pow, total)
+			assert.Equal(t, test.target, q256ToF(lam))
+			golden.Assert(t, []byte(lam.String()))
+		})
+	}
+}
+
+func TestExpFunction(t *testing.T) {
+	const N = 256
+
+	step := big.NewInt(5)
+	step = step.Lsh(step, 256) // Q.256
+	step = step.Div(step, big.NewInt(N-1))
+
+	x := big.NewInt(0)
+	b := &bytes.Buffer{}
+
+	b.WriteString("x, y\n")
+	for i := 0; i < N; i++ {
+		y := expneg(x)
+		fmt.Fprintf(b, "%s,%s\n", x, y)
+		x = x.Add(x, step)
+	}
+
+	golden.Assert(t, b.Bytes())
+}
+
+func q256ToF(x *big.Int) float64 {
+	deno := big.NewInt(1)
+	deno = deno.Lsh(deno, 256)
+	rat := new(big.Rat).SetFrac(x, deno)
+	f, _ := rat.Float64()
+	return f
+}
+
+func TestElectionLam(t *testing.T) {
+	p := big.NewInt(64)
+	tot := big.NewInt(128)
+	lam := lambda(p, tot)
+	target := 64. * 5. / 128.
+	if q256ToF(lam) != target {
+		t.Fatalf("wrong lambda: %f, should be: %f", q256ToF(lam), target)
+	}
+}
+
+var Res int64
+
+func BenchmarkWinCounts(b *testing.B) {
+	totalPower := NewInt(100)
+	power := NewInt(100)
+	ep := &ElectionProof{VRFProof: nil}
+	var res int64
+
+	b.ResetTimer()
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		ep.VRFProof = []byte{byte(i), byte(i >> 8), byte(i >> 16), byte(i >> 24), byte(i >> 32)}
+		j := ep.ComputeWinCount(power, totalPower)
+		res += j
+	}
+	Res += res
+}
+
+func TestWinCounts(t *testing.T) {
+	t.SkipNow()
+	totalPower := NewInt(100)
+	power := NewInt(30)
+
+	f, _ := os.Create("output.wins")
+	fmt.Fprintf(f, "wins\n")
+	ep := &ElectionProof{VRFProof: nil}
+	for i := uint64(0); i < 1000000; i++ {
+		i := i + 1000000
+		ep.VRFProof = []byte{byte(i), byte(i >> 8), byte(i >> 16), byte(i >> 24), byte(i >> 32)}
+		j := ep.ComputeWinCount(power, totalPower)
+		fmt.Fprintf(f, "%d\n", j)
+	}
+}
diff --git a/chain/types/execresult.go b/chain/types/execresult.go
new file mode 100644
index 000000000..6fc93fac6
--- /dev/null
+++ b/chain/types/execresult.go
@@ -0,0 +1,103 @@
+package types
+
+import (
+	"encoding/json"
+	"fmt"
+	"runtime"
+	"strings"
+	"time"
+)
+
+type ExecutionTrace struct {
+	Msg        *Message
+	MsgRct     *MessageReceipt
+	Error      string
+	Duration   time.Duration
+	GasCharges []*GasTrace
+
+	Subcalls []ExecutionTrace
+}
+
+type GasTrace struct {
+	Name string
+
+	Location          []Loc `json:"loc"`
+	TotalGas          int64 `json:"tg"`
+	ComputeGas        int64 `json:"cg"`
+	StorageGas        int64 `json:"sg"`
+	TotalVirtualGas   int64 `json:"vtg"`
+	VirtualComputeGas int64 `json:"vcg"`
+	VirtualStorageGas int64 `json:"vsg"`
+
+	TimeTaken time.Duration `json:"tt"`
+	Extra     interface{}   `json:"ex,omitempty"`
+
+	Callers []uintptr `json:"-"`
+}
+
+type Loc struct {
+	File     string
+	Line     int
+	Function string
+}
+
+func (l Loc) Show() bool {
+	ignorePrefix := []string{
+		"reflect.",
+		"github.com/filecoin-project/lotus/chain/vm.(*Invoker).transform",
+		"github.com/filecoin-project/go-amt-ipld/",
+	}
+	for _, pre := range ignorePrefix {
+		if strings.HasPrefix(l.Function, pre) {
+			return false
+		}
+	}
+	return true
+}
+func (l Loc) String() string {
+	file := strings.Split(l.File, "/")
+
+	fn := strings.Split(l.Function, "/")
+	var fnpkg string
+	if len(fn) > 2 {
+		fnpkg = strings.Join(fn[len(fn)-2:], "/")
+	} else {
+		fnpkg = l.Function
+	}
+
+	return fmt.Sprintf("%s@%s:%d", fnpkg, file[len(file)-1], l.Line)
+}
+
+func (l Loc) Important() bool {
+	if strings.HasPrefix(l.Function, "github.com/filecoin-project/specs-actors/actors/builtin") {
+		return true
+	}
+	return false
+}
+
+func (gt *GasTrace) MarshalJSON() ([]byte, error) {
+	type GasTraceCopy GasTrace
+	if len(gt.Location) == 0 {
+		if len(gt.Callers) != 0 {
+			frames := runtime.CallersFrames(gt.Callers)
+			for {
+				frame, more := frames.Next()
+				if frame.Function == "github.com/filecoin-project/lotus/chain/vm.(*VM).ApplyMessage" {
+					break
+				}
+				l := Loc{
+					File:     frame.File,
+					Line:     frame.Line,
+					Function: frame.Function,
+				}
+				gt.Location = append(gt.Location, l)
+				if !more {
+					break
+				}
+			}
+		}
+	}
+
+	cpy := (*GasTraceCopy)(gt)
+	return json.Marshal(cpy)
+}
diff --git a/chain/types/fil.go b/chain/types/fil.go
index 80de6ced3..99a896e38 100644
--- a/chain/types/fil.go
+++ b/chain/types/fil.go
@@ -1,6 +1,7 @@
 package types
 
 import (
+	"encoding"
 	"fmt"
 	"math/big"
 	"strings"
@@ -11,11 +12,11 @@ import (
 type FIL BigInt
 
 func (f FIL) String() string {
-	r := new(big.Rat).SetFrac(f.Int, big.NewInt(build.FilecoinPrecision))
+	r := new(big.Rat).SetFrac(f.Int, big.NewInt(int64(build.FilecoinPrecision)))
 	if r.Sign() == 0 {
-		return "0"
+		return "0 FIL"
 	}
-	return strings.TrimRight(strings.TrimRight(r.FloatString(18), "0"), ".")
+	return strings.TrimRight(strings.TrimRight(r.FloatString(18), "0"), ".") + " FIL"
 }
 
 func (f FIL) Format(s fmt.State, ch rune) {
@@ -27,16 +28,54 @@ func (f FIL) Format(s fmt.State, ch rune) {
 	}
 }
 
+func (f FIL) MarshalText() (text []byte, err error) {
+	return []byte(f.String()), nil
+}
+
+func (f FIL) UnmarshalText(text []byte) error {
+	p, err := ParseFIL(string(text))
+	if err != nil {
+		return err
+	}
+
+	f.Int.Set(p.Int)
+	return nil
+}
+
 func ParseFIL(s string) (FIL, error) {
+	suffix := strings.TrimLeft(s, ".1234567890")
+	s = s[:len(s)-len(suffix)]
+	var attofil bool
+	if suffix != "" {
+		norm := strings.ToLower(strings.TrimSpace(suffix))
+		switch norm {
+		case "", "fil":
+		case "attofil", "afil":
+			attofil = true
+		default:
+			return FIL{}, fmt.Errorf("unrecognized suffix: %q", suffix)
+		}
+	}
+
 	r, ok := new(big.Rat).SetString(s)
 	if !ok {
 		return FIL{}, fmt.Errorf("failed to parse %q as a decimal number", s)
 	}
 
-	r = r.Mul(r, big.NewRat(build.FilecoinPrecision, 1))
+	if !attofil {
+		r = r.Mul(r, big.NewRat(int64(build.FilecoinPrecision), 1))
+	}
+
 	if !r.IsInt() {
-		return FIL{}, fmt.Errorf("invalid FIL value: %q", s)
+		var pref string
+		if attofil {
+			pref = "atto"
+		}
+		return FIL{}, fmt.Errorf("invalid %sFIL value: %q", pref, s)
 	}
 
 	return FIL{r.Num()}, nil
 }
+
+var _ encoding.TextMarshaler = (*FIL)(nil)
+var _ encoding.TextUnmarshaler = (*FIL)(nil)
diff --git a/chain/types/invokeret.go b/chain/types/invokeret.go
deleted file mode 100644
index 030b728ae..000000000
--- a/chain/types/invokeret.go
+++ /dev/null
@@ -1,6 +0,0 @@
-package types
-
-type InvokeRet struct {
-	Result     []byte
-	ReturnCode byte
-}
diff --git a/chain/types/message.go b/chain/types/message.go
index 8d08dc53c..4fead44bc 100644
--- a/chain/types/message.go
+++ b/chain/types/message.go
@@ -4,34 +4,66 @@ import (
 	"bytes"
 	"fmt"
 
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/big"
+	"github.com/filecoin-project/lotus/build"
 	block "github.com/ipfs/go-block-format"
 	"github.com/ipfs/go-cid"
-	"github.com/multiformats/go-multihash"
+	xerrors "golang.org/x/xerrors"
 
 	"github.com/filecoin-project/go-address"
 )
 
+const MessageVersion = 0
+
+type ChainMsg interface {
+	Cid() cid.Cid
+	VMMessage() *Message
+	ToStorageBlock() (block.Block, error)
+	// FIXME: This is the *message* length, this name is misleading.
+	ChainLength() int
+}
+
 type Message struct {
+	Version uint64
+
 	To   address.Address
 	From address.Address
 
 	Nonce uint64
 
-	Value BigInt
+	Value abi.TokenAmount
 
-	GasPrice BigInt
-	GasLimit BigInt
+	GasLimit   int64
+	GasFeeCap  abi.TokenAmount
+	GasPremium abi.TokenAmount
 
-	Method uint64
+	Method abi.MethodNum
 	Params []byte
 }
 
+func (m *Message) Caller() address.Address {
+	return m.From
+}
+
+func (m *Message) Receiver() address.Address {
+	return m.To
+}
+
+func (m *Message) ValueReceived() abi.TokenAmount {
+	return m.Value
+}
+
 func DecodeMessage(b []byte) (*Message, error) {
 	var msg Message
 	if err := msg.UnmarshalCBOR(bytes.NewReader(b)); err != nil {
 		return nil, err
 	}
 
+	if msg.Version != MessageVersion {
+		return nil, fmt.Errorf("decoded message had incorrect version (%d)", msg.Version)
+	}
+
 	return &msg, nil
 }
 
@@ -43,14 +75,21 @@ func (m *Message) Serialize() ([]byte, error) {
 	return buf.Bytes(), nil
 }
 
+func (m *Message) ChainLength() int {
+	ser, err := m.Serialize()
+	if err != nil {
+		panic(err)
+	}
+	return len(ser)
+}
+
 func (m *Message) ToStorageBlock() (block.Block, error) {
 	data, err := m.Serialize()
 	if err != nil {
 		return nil, err
 	}
 
-	pref := cid.NewPrefixV1(cid.DagCBOR, multihash.BLAKE2B_MIN+31)
-	c, err := pref.Sum(data)
+	c, err := abi.CidBuilder.Sum(data)
 	if err != nil {
 		return nil, err
 	}
@@ -68,10 +107,7 @@ func (m *Message) Cid() cid.Cid {
 }
 
 func (m *Message) RequiredFunds() BigInt {
-	return BigAdd(
-		m.Value,
-		BigMul(m.GasPrice, m.GasLimit),
-	)
+	return BigMul(m.GasFeeCap, NewInt(uint64(m.GasLimit)))
 }
 
 func (m *Message) VMMessage() *Message {
@@ -81,3 +117,73 @@ func (m *Message) VMMessage() *Message {
 func (m *Message) Equals(o *Message) bool {
 	return m.Cid() == o.Cid()
 }
+
+func (m *Message) EqualCall(o *Message) bool {
+	m1 := *m
+	m2 := *o
+
+	m1.GasLimit, m2.GasLimit = 0, 0
+	m1.GasFeeCap, m2.GasFeeCap = big.Zero(), big.Zero()
+	m1.GasPremium, m2.GasPremium = big.Zero(), big.Zero()
+
+	return (&m1).Equals(&m2)
+}
+
+func (m *Message) ValidForBlockInclusion(minGas int64) error {
+	if m.Version != 0 {
+		return xerrors.New("'Version' unsupported")
+	}
+
+	if m.To == address.Undef {
+		return xerrors.New("'To' address cannot be empty")
+	}
+
+	if m.From == address.Undef {
+		return xerrors.New("'From' address cannot be empty")
+	}
+
+	if m.Value.Int == nil {
+		return xerrors.New("'Value' cannot be nil")
+	}
+
+	if m.Value.LessThan(big.Zero()) {
+		return xerrors.New("'Value' field cannot be negative")
+	}
+
+	if m.Value.GreaterThan(TotalFilecoinInt) {
+		return xerrors.New("'Value' field cannot be greater than total filecoin supply")
+	}
+
+	if m.GasFeeCap.Int == nil {
+		return xerrors.New("'GasFeeCap' cannot be nil")
+	}
+
+	if m.GasFeeCap.LessThan(big.Zero()) {
+		return xerrors.New("'GasFeeCap' field cannot be negative")
+	}
+
+	if m.GasPremium.Int == nil {
+		return xerrors.New("'GasPremium' cannot be nil")
+	}
+
+	if m.GasPremium.LessThan(big.Zero()) {
+		return xerrors.New("'GasPremium' field cannot be negative")
+	}
+
+	if m.GasPremium.GreaterThan(m.GasFeeCap) {
+		return xerrors.New("'GasFeeCap' less than 'GasPremium'")
+	}
+
+	if m.GasLimit > build.BlockGasLimit {
+		return xerrors.New("'GasLimit' field cannot be greater than a block's gas limit")
+	}
+
+	// since prices might vary with time, this is technically semantic validation
+	if m.GasLimit < minGas {
+		return xerrors.New("'GasLimit' field cannot be less than the cost of storing a message on chain")
+	}
+
+	return nil
+}
+
+const TestGasLimit = 100e6
diff --git a/chain/types/message_receipt.go b/chain/types/message_receipt.go
index 48139a347..57761680d 100644
--- a/chain/types/message_receipt.go
+++ b/chain/types/message_receipt.go
@@ -2,14 +2,16 @@ package types
 
 import (
 	"bytes"
+
+	"github.com/filecoin-project/go-state-types/exitcode"
 )
 
 type MessageReceipt struct {
-	ExitCode uint8
+	ExitCode exitcode.ExitCode
 	Return   []byte
-	GasUsed  BigInt
+	GasUsed  int64
 }
 
 func (mr *MessageReceipt) Equals(o *MessageReceipt) bool {
-	return mr.ExitCode == o.ExitCode && bytes.Equal(mr.Return, o.Return) && BigCmp(mr.GasUsed, o.GasUsed) == 0
+	return mr.ExitCode == o.ExitCode && bytes.Equal(mr.Return, o.Return) && mr.GasUsed == o.GasUsed
 }
diff --git a/chain/types/message_test.go b/chain/types/message_test.go
new file mode 100644
index 000000000..f57385a09
--- /dev/null
+++ b/chain/types/message_test.go
@@ -0,0 +1,72 @@
+package types
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/filecoin-project/go-state-types/big"
+	"github.com/filecoin-project/specs-actors/actors/builtin"
+)
+
+func TestEqualCall(t *testing.T) {
+	m1 := &Message{
+		To:    builtin.StoragePowerActorAddr,
+		From:  builtin.SystemActorAddr,
+		Nonce: 34,
+		Value: big.Zero(),
+
+		GasLimit:   123,
+		GasFeeCap:  big.NewInt(234),
+		GasPremium: big.NewInt(234),
+
+		Method: 6,
+		Params: []byte("hai"),
+	}
+
+	m2 := &Message{
+		To:    builtin.StoragePowerActorAddr,
+		From:  builtin.SystemActorAddr,
+		Nonce: 34,
+		Value: big.Zero(),
+
+		GasLimit:   1236, // changed
+		GasFeeCap:  big.NewInt(234),
+		GasPremium: big.NewInt(234),
+
+		Method: 6,
+		Params: []byte("hai"),
+	}
+
+	m3 := &Message{
+		To:    builtin.StoragePowerActorAddr,
+		From:  builtin.SystemActorAddr,
+		Nonce: 34,
+		Value: big.Zero(),
+
+		GasLimit:   123,
+		GasFeeCap:  big.NewInt(4524), // changed
+		GasPremium: big.NewInt(234),
+
+		Method: 6,
+		Params: []byte("hai"),
+	}
+
+	m4 := &Message{
+		To:    builtin.StoragePowerActorAddr,
+		From:  builtin.SystemActorAddr,
+		Nonce: 34,
+		Value: big.Zero(),
+
+		GasLimit:   123,
+		GasFeeCap:  big.NewInt(4524),
+		GasPremium: big.NewInt(234),
+
+		Method: 5, // changed
+		Params: []byte("hai"),
+	}
+
+	require.True(t, m1.EqualCall(m2))
+	require.True(t, m1.EqualCall(m3))
+	require.False(t, m1.EqualCall(m4))
+}
diff --git a/chain/types/mock/chain.go b/chain/types/mock/chain.go
index 55fe8c11d..559630619 100644
--- a/chain/types/mock/chain.go
+++ b/chain/types/mock/chain.go
@@ -5,9 +5,13 @@ import (
 	"fmt"
 
 	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/crypto"
+	"github.com/ipfs/go-cid"
+
+	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/chain/wallet"
-	"github.com/ipfs/go-cid"
 )
 
 func Address(i uint64) address.Address {
@@ -20,12 +24,13 @@ func Address(i uint64) address.Address {
 
 func MkMessage(from, to address.Address, nonce uint64, w *wallet.Wallet) *types.SignedMessage {
 	msg := &types.Message{
-		To:       to,
-		From:     from,
-		Value:    types.NewInt(1),
-		Nonce:    nonce,
-		GasLimit: types.NewInt(1),
-		GasPrice: types.NewInt(0),
+		To:         to,
+		From:       from,
+		Value:      types.NewInt(1),
+		Nonce:      nonce,
+		GasLimit:   1000000,
+		GasFeeCap:  types.NewInt(100),
+		GasPremium: types.NewInt(1),
 	}
 
 	sig, err := w.Sign(context.TODO(), from, msg.Cid().Bytes())
@@ -46,8 +51,13 @@ func MkBlock(parents *types.TipSet, weightInc uint64, ticketNonce uint64) *types
 		panic(err)
 	}
 
+	pstateRoot := c
+	if parents != nil {
+		pstateRoot = parents.Blocks()[0].ParentStateRoot
+	}
+
 	var pcids []cid.Cid
-	var height uint64
+	var height abi.ChainEpoch
 	weight := types.NewInt(weightInc)
 	if parents != nil {
 		pcids = parents.Cids()
@@ -57,20 +67,21 @@ func MkBlock(parents *types.TipSet, weightInc uint64, ticketNonce uint64) *types
 
 	return &types.BlockHeader{
 		Miner: addr,
-		EPostProof: types.EPostProof{
-			Proof: []byte("election post proof proof"),
+		ElectionProof: &types.ElectionProof{
+			VRFProof: []byte(fmt.Sprintf("====%d=====", ticketNonce)),
 		},
 		Ticket: &types.Ticket{
 			VRFProof: []byte(fmt.Sprintf("====%d=====", ticketNonce)),
 		},
 		Parents:               pcids,
 		ParentMessageReceipts: c,
-		BLSAggregate:          types.Signature{Type: types.KTBLS, Data: []byte("boo! im a signature")},
+		BLSAggregate:          &crypto.Signature{Type: crypto.SigTypeBLS, Data: []byte("boo! im a signature")},
 		ParentWeight:          weight,
 		Messages:              c,
 		Height:                height,
-		ParentStateRoot:       c,
-		BlockSig:              &types.Signature{Type: types.KTBLS, Data: []byte("boo! im a signature")},
+		ParentStateRoot:       pstateRoot,
+		BlockSig:              &crypto.Signature{Type: crypto.SigTypeBLS, Data: []byte("boo! im a signature")},
+		ParentBaseFee:         types.NewInt(uint64(build.MinimumBaseFee)),
 	}
 }
 
diff --git a/chain/types/mpool.go b/chain/types/mpool.go
new file mode 100644
index 000000000..cf08177e9
--- /dev/null
+++ b/chain/types/mpool.go
@@ -0,0 +1,22 @@
+package types
+
+import (
+	"time"
+
+	"github.com/filecoin-project/go-address"
+)
+
+type MpoolConfig struct {
+	PriorityAddrs          []address.Address
+	SizeLimitHigh          int
+	SizeLimitLow           int
+	ReplaceByFeeRatio      float64
+	PruneCooldown          time.Duration
+	GasLimitOverestimation float64
+}
+
+func (mc *MpoolConfig) Clone() *MpoolConfig {
+	r := new(MpoolConfig)
+	*r = *mc
+	return r
+}
diff --git a/chain/types/signature.go b/chain/types/signature.go
deleted file mode 100644
index f3a61327b..000000000
--- a/chain/types/signature.go
+++ /dev/null
@@ -1,120 +0,0 @@
-package types
-
-import (
-	"bytes"
-	"encoding/binary"
-	"fmt"
-	"io"
-
-	cbg "github.com/whyrusleeping/cbor-gen"
-)
-
-const SignatureMaxLength = 200
-
-const (
-	KTSecp256k1 = "secp256k1"
-	KTBLS       = "bls"
-)
-
-const (
-	IKTUnknown = -1
-
-	IKTSecp256k1 = iota
-	IKTBLS
-)
-
-type Signature struct {
-	Type string
-	Data []byte
-}
-
-func SignatureFromBytes(x []byte) (Signature, error) {
-	val, nr := binary.Uvarint(x)
-	if nr != 1 {
-		return Signature{}, fmt.Errorf("signatures with type field longer than one byte are invalid")
-	}
-	var ts string
-	switch val {
-	case IKTSecp256k1:
-		ts = KTSecp256k1
-	case IKTBLS:
-		ts = KTBLS
-	default:
-		return Signature{}, fmt.Errorf("unsupported signature type: %d", val)
-	}
-
-	return Signature{
-		Type: ts,
-		Data: x[1:],
-	}, nil
-}
-
-func (s *Signature) TypeCode() int {
-	switch s.Type {
-	case KTSecp256k1:
-		return IKTSecp256k1
-	case KTBLS:
-		return IKTBLS
-	default:
-		return IKTUnknown
-	}
-}
-
-func (s *Signature) MarshalCBOR(w io.Writer) error {
-	if s == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-
-	header := cbg.CborEncodeMajorType(cbg.MajByteString, uint64(len(s.Data)+1))
-
-	if _, err := w.Write(header); err != nil {
-		return err
-	}
-
-	if _, err := w.Write([]byte{byte(s.TypeCode())}); err != nil {
-		return err
-	}
-
-	if _, err := w.Write(s.Data); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func (s *Signature) UnmarshalCBOR(br io.Reader) error {
-	maj, l, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-
-	if maj != cbg.MajByteString {
-		return fmt.Errorf("cbor input for signature was not a byte string")
-	}
-
-	if l > SignatureMaxLength {
-		return fmt.Errorf("cbor byte array for signature was too long")
-	}
-
-	buf := make([]byte, l)
-	if _, err := io.ReadFull(br, buf); err != nil {
-		return err
-	}
-
-	switch buf[0] {
-	default:
-		return fmt.Errorf("invalid signature type in cbor input: %d", buf[0])
-	case IKTSecp256k1:
-		s.Type = KTSecp256k1
-	case IKTBLS:
-		s.Type = KTBLS
-	}
-	s.Data = buf[1:]
-
-	return nil
-}
-
-func (s *Signature) Equals(o *Signature) bool {
-	return s.Type == o.Type && bytes.Equal(s.Data, o.Data)
-}
diff --git a/chain/types/signature_cgo.go b/chain/types/signature_cgo.go
deleted file mode 100644
index d86e41d72..000000000
--- a/chain/types/signature_cgo.go
+++ /dev/null
@@ -1,55 +0,0 @@
-//+build cgo
-
-package types
-
-import (
-	"fmt"
-
-	bls "github.com/filecoin-project/filecoin-ffi"
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-crypto"
-	"github.com/minio/blake2b-simd"
-)
-
-func (s *Signature) Verify(addr address.Address, msg []byte) error {
-	if addr.Protocol() == address.ID {
-		return fmt.Errorf("must resolve ID addresses before using them to verify a signature")
-	}
-	b2sum := blake2b.Sum256(msg)
-
-	switch s.Type {
-	case KTSecp256k1:
-		pubk, err := crypto.EcRecover(b2sum[:], s.Data)
-		if err != nil {
-			return err
-		}
-
-		maybeaddr, err := address.NewSecp256k1Address(pubk)
-		if err != nil {
-			return err
-		}
-
-		if addr != maybeaddr {
-			return fmt.Errorf("signature did not match")
-		}
-
-		return nil
-	case KTBLS:
-		digests := []bls.Digest{bls.Hash(bls.Message(msg))}
-
-		var pubk bls.PublicKey
-		copy(pubk[:], addr.Payload())
-		pubkeys := []bls.PublicKey{pubk}
-
-		var sig bls.Signature
-		copy(sig[:], s.Data)
-
-		if !bls.Verify(&sig, digests, pubkeys) {
-			return fmt.Errorf("bls signature failed to verify")
-		}
-
-		return nil
-	default:
-		return fmt.Errorf("cannot verify signature of unsupported type: %s", s.Type)
-	}
-}
diff --git a/chain/types/signature_test.go b/chain/types/signature_test.go
index b45024b29..9ade3c046 100644
--- a/chain/types/signature_test.go
+++ b/chain/types/signature_test.go
@@ -3,12 +3,14 @@ package types
 import (
 	"bytes"
 	"testing"
+
+	"github.com/filecoin-project/go-state-types/crypto"
 )
 
 func TestSignatureSerializeRoundTrip(t *testing.T) {
-	s := &Signature{
+	s := &crypto.Signature{
 		Data: []byte("foo bar cat dog"),
-		Type: KTBLS,
+		Type: crypto.SigTypeBLS,
 	}
 
 	buf := new(bytes.Buffer)
@@ -16,7 +18,7 @@ func TestSignatureSerializeRoundTrip(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	var outs Signature
+	var outs crypto.Signature
 	if err := outs.UnmarshalCBOR(buf); err != nil {
 		t.Fatal(err)
 	}
diff --git a/chain/types/signedmessage.go b/chain/types/signedmessage.go
index 0ede20a4f..17d2f5d94 100644
--- a/chain/types/signedmessage.go
+++ b/chain/types/signedmessage.go
@@ -3,23 +3,23 @@ package types
 import (
 	"bytes"
 
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/crypto"
 	block "github.com/ipfs/go-block-format"
 	"github.com/ipfs/go-cid"
-	"github.com/multiformats/go-multihash"
 )
 
-func (m *SignedMessage) ToStorageBlock() (block.Block, error) {
-	if m.Signature.Type == KTBLS {
-		return m.Message.ToStorageBlock()
+func (sm *SignedMessage) ToStorageBlock() (block.Block, error) {
+	if sm.Signature.Type == crypto.SigTypeBLS {
+		return sm.Message.ToStorageBlock()
 	}
 
-	data, err := m.Serialize()
+	data, err := sm.Serialize()
 	if err != nil {
 		return nil, err
 	}
 
-	pref := cid.NewPrefixV1(cid.DagCBOR, multihash.BLAKE2B_MIN+31)
-	c, err := pref.Sum(data)
+	c, err := abi.CidBuilder.Sum(data)
 	if err != nil {
 		return nil, err
 	}
@@ -27,12 +27,12 @@ func (m *SignedMessage) ToStorageBlock() (block.Block, error) {
 	return block.NewBlockWithCid(data, c)
 }
 
-func (m *SignedMessage) Cid() cid.Cid {
-	if m.Signature.Type == KTBLS {
-		return m.Message.Cid()
+func (sm *SignedMessage) Cid() cid.Cid {
+	if sm.Signature.Type == crypto.SigTypeBLS {
+		return sm.Message.Cid()
 	}
 
-	sb, err := m.ToStorageBlock()
+	sb, err := sm.ToStorageBlock()
 	if err != nil {
 		panic(err)
 	}
@@ -42,7 +42,7 @@ func (m *SignedMessage) Cid() cid.Cid {
 
 type SignedMessage struct {
 	Message   Message
-	Signature Signature
+	Signature crypto.Signature
 }
 
 func DecodeSignedMessage(data []byte) (*SignedMessage, error) {
@@ -62,6 +62,14 @@ func (sm *SignedMessage) Serialize() ([]byte, error) {
 	return buf.Bytes(), nil
 }
 
+func (sm *SignedMessage) ChainLength() int {
+	ser, err := sm.Serialize()
+	if err != nil {
+		panic(err)
+	}
+	return len(ser)
+}
+
 func (sm *SignedMessage) Size() int {
 	serdata, err := sm.Serialize()
 	if err != nil {
diff --git a/chain/types/state.go b/chain/types/state.go
new file mode 100644
index 000000000..b99eb19c2
--- /dev/null
+++ b/chain/types/state.go
@@ -0,0 +1,15 @@
+package types
+
+import "github.com/ipfs/go-cid"
+
+type StateRoot struct {
+	// State root version. Versioned along with actors (for now).
+	Version uint64
+	// Actors tree. The structure depends on the state root version.
+	Actors cid.Cid
+	// Info. The structure depends on the state root version.
+	Info cid.Cid
+}
+
+// TODO: version this.
+type StateInfo struct{}
diff --git a/chain/types/testdata/TestExpFunction.golden b/chain/types/testdata/TestExpFunction.golden
new file mode 100644
index 000000000..1fb931874
--- /dev/null
+++ b/chain/types/testdata/TestExpFunction.golden
@@ -0,0 +1,257 @@
+x, y
+0,115792089237316195423570985008687907853269984665640564039457584007913129639936
+2270433122300317557324921274680155055946470287561579687048187921723786855685,113543770489016942962237377411819033281128847358465443152965692667674515268459
+4540866244600635114649842549360310111892940575123159374096375843447573711370,111339107030360092669625707586928312989271150877369072427721155459215537208890
+6811299366900952671974763824040465167839410862684739061144563765171360567055,109177251212712547631698034978205369781807498766451007885527881500477232021682
+9081732489201270229299685098720620223785881150246318748192751686895147422740,107057371846115774238270822835274977319670170085938012474442950429894883628816
+11352165611501587786624606373400775279732351437807898435240939608618934278425,104978653879710027736182386389791146063108246474333192437116903221506365793784
+13622598733801905343949527648080930335678821725369478122289127530342721134110,102940298088363735750708779071187005425195044826988440514290336074628648838684
+15893031856102222901274448922761085391625292012931057809337315452066507989795,100941520765387555093691898043462296359944447036680097792913901290457279892923
+18163464978402540458599370197441240447571762300492637496385503373790294845480,98981553421214956610998073555828635758296463224923810238433739306701915887016
+20433898100702858015924291472121395503518232588054217183433691295514081701165,97059642487933486831615191223039105587754475193940197594806835165639555904556
+22704331223003175573249212746801550559464702875615796870481879217237868556850,95175049029553104647921939291264669504212075519331704270982994731418832879574
+24974764345303493130574134021481705615411173163177376557530067138961655412535,93327048457900197046298852001610623840008858609979636336358094295509875743050
+27245197467603810687899055296161860671357643450738956244578255060685442268220,91514930254028040867379060937212497464993417057199803702713818093495592131219
+29515630589904128245223976570842015727304113738300535931626442982409229123905,89737997695036598537471612414728492361735134837457880776578397164411259714034
+31786063712204445802548897845522170783250584025862115618674630904133015979590,87995567586196615492499061341239298336716207707733388009305962491415997438251
+34056496834504763359873819120202325839197054313423695305722818825856802835275,86286969998275026412807199079440137158468693464163642116594809068619896392941
+36326929956805080917198740394882480895143524600985274992771006747580589690960,84611548009960677185535234025783667242734659094160158991843756961639811974930
+38597363079105398474523661669562635951089994888546854679819194669304376546645,82968657455291330479761642121918798999912566007436555574905312488221049770642
+40867796201405716031848582944242791007036465176108434366867382591028163402330,81357666675984845712317087407692885985045766475399018683682465654293317561467
+43138229323706033589173504218922946062982935463670014053915570512751950258015,79777956278579309738294730369672998880873563557913118175337099978291132200541
+45408662446006351146498425493603101118929405751231593740963758434475737113700,78228918896288743544848199105491032646200262796326433813989850094529077282776
+47679095568306668703823346768283256174875876038793173428011946356199523969385,76709958955482823270730386397827358293917115388940737122493792142598409249118
+49949528690606986261148268042963411230822346326354753115060134277923310825070,75220492446700831714270851931718222334181221472926734650894450187207587804959
+52219961812907303818473189317643566286768816613916332802108322199647097680755,73759946700111799812659669164881767734266809389910877226542646506513000978489
+54490394935207621375798110592323721342715286901477912489156510121370884536440,72327760165334507045772504425420867449416167380982855532448913178137554210923
+56760828057507938933123031867003876398661757189039492176204698043094671392125,70923382195532685995592428750934431740132395987623204573329785474158712116147
+59031261179808256490447953141684031454608227476601071863252885964818458247810,69546272835702420022053453330708655397369524375477499739230911030535808540657
+61301694302108574047772874416364186510554697764162651550301073886542245103495,68195902615070334829829990481057773300819373544625447529491837404705895284329
+63572127424408891605097795691044341566501168051724231237349261808266031959180,66871752343522765217935231891690355471651496064655471661919663456330328641288
+65842560546709209162422716965724496622447638339285810924397449729989818814865,65573312911987628132646843093927406319425698793733957333572673848799954239855
+68112993669009526719747638240404651678394108626847390611445637651713605670550,64300085096692252880128256597394188085029084300287019159255155536716536636582
+70383426791309844277072559515084806734340578914408970298493825573437392526235,63051579367221909582465988028351521656270181701866074076641181901174457665557
+72653859913610161834397480789764961790287049201970549985542013495161179381920,61827315698305238252660159775306665170268657207834096298284442133031571582783
+74924293035910479391722402064445116846233519489532129672590201416884966237605,60626823385254213782224025259478780989246898268785251219150451819890211607196
+77194726158210796949047323339125271902179989777093709359638389338608753093290,59449640862987687230396859494036983576366375788559345059199710577555290424321
+79465159280511114506372244613805426958126460064655289046686577260332539948975,58295315528568921616783939661658889268848452171972763039788768615558483626267
+81735592402811432063697165888485582014072930352216868733734765182056326804660,57163403567188891479248718554448273836403260979137552976694337187145017476501
+84006025525111749621022087163165737070019400639778448420782953103780113660345,56053469781528440285551018178364674618486430618035927413379628478874266581878
+86276458647412067178347008437845892125965870927340028107831141025503900516030,54965087424433688889920273781092319643978134551542030239286748341146003208614
+88546891769712384735671929712526047181912341214901607794879328947227687371715,53897838034840362103953324191045652555242797708181047223345801682385818568835
+90817324892012702292996850987206202237858811502463187481927516868951474227400,52851311276883949594712447365930530107052884187291818795931120263968492084774
+93087758014313019850321772261886357293805281790024767168975704790675261083085,51825104782133842211941756402475821837684219892038783449941692633646927028868
+95358191136613337407646693536566512349751752077586346856023892712399047938770,50818823994890785951863832476942579771969130641977742986737254850253840075592
+97628624258913654964971614811246667405698222365147926543072080634122834794455,49832082020488173548864433257316990617151231489408392527154422207621203727615
+99899057381213972522296536085926822461644692652709506230120268555846621650140,48864499476538848601355411822273410550321020146722594189563317351144555102308
+102169490503514290079621457360606977517591162940271085917168456477570408505825,47915704347070229628266128780655102907390977725210624641985610920484495320871
+104439923625814607636946378635287132573537633227832665604216644399294195361510,46985331839491671953371264029121450743887309752499067780940162596021543960818
+106710356748114925194271299909967287629484103515394245291264832321017982217195,46073024244339074252983177578294403714924665379395655719184742489399140111119
+108980789870415242751596221184647442685430573802955824978313020242741769072880,45178430797742804397094652011443390009353450908460410593202993111115176300509
+111251222992715560308921142459327597741377044090517404665361208164465555928565,44301207546566066275398443059622984529245531090835413454138285364317904357889
+113521656115015877866246063734007752797323514378078984352409396086189342784250,43441017216161856030307536334277824451020867870703344545581645152489753618625
+115792089237316195423570985008687907853269984665640564039457584007913129639935,42597529080697662913911602080197270017224605406643086589378214572018159359656
+118062522359616512980895906283368062909216454953202143726505771929636916495620,41770418835998057231823154500906296232954940017107200954896529163626836852806
+120332955481916830538220827558048217965162925240763723413553959851360703351305,40959368474856275913667539524102962047053738936489506227266772182693729839202
+122603388604217148095545748832728373021109395528325303100602147773084490206990,40164066164766865529760099118055626254866338159841829407810028308443332329921
+124873821726517465652870670107408528077055865815886882787650335694808277062675,39384206128032373421270623986368325593061645265273820139765067969067422649415
+127144254848817783210195591382088683133002336103448462474698523616532063918360,38619488524197990384791697485732970600503064875453399931120765038045198401265
+129414687971118100767520512656768838188948806391010042161746711538255850774045,37869619334768943402646797366590078932213917335501796767692394741802326454228
+131685121093418418324845433931448993244895276678571621848794899459979637629730,37134310250166314581624891999905972285593140562157169782497980837053288139911
+133955554215718735882170355206129148300841746966133201535843087381703424485415,36413278558877823092557676422579316779501436559193491643756131394023796062011
+136225987338019053439495276480809303356788217253694781222891275303427211341100,35706247038760950822158313374858241516488865748339595127547394046982094249410
+138496420460319370996820197755489458412734687541256360909939463225150998196785,35012943850456619981286410714734531636271581473914516202135729910546566402779
+140766853582619688554145119030169613468681157828817940596987651146874785052470,34333102432872442378462629116615524982524168457316936505909372845805604900401
+143037286704920006111470040304849768524627628116379520284035839068598571908155,33666461400695355776019567288676251030810566791286359575983902200864972469996
+145307719827220323668794961579529923580574098403941099971084026990322358763840,33012764443894243004677309675463059806544657868579375264515822376830510918451
+147578152949520641226119882854210078636520568691502679658132214912046145619525,32371760229173894620565861867718452819385944209047587245952825283707541232161
+149848586071820958783444804128890233692467038979064259345180402833769932475210,31743202303342426140951325851524709564919796135818066107980273521807047228205
+152119019194121276340769725403570388748413509266625839032228590755493719330895,31126848998554996579614932864397941484844825641744252641191173459915093805187
+154389452316421593898094646678250543804359979554187418719276778677217506186580,30522463339397396402839881838375473280428264227964104623768547140174704396628
+156659885438721911455419567952930698860306449841748998406324966598941293042265,29929812951773780419644078230146692062203486832083285970050129935848796157421
+158930318561022229012744489227610853916252920129310578093373154520665079897950,29348669973563514777235550444240282773251884769510008252819331832439494645079
+161200751683322546570069410502291008972199390416872157780421342442388866753635,28778810967012787421358795112757003059950944596369120909715112149169964220370
+163471184805622864127394331776971164028145860704433737467469530364112653609320,28220016832827298362763401072714572174637391915333615996330037256359689152007
+165741617927923181684719253051651319084092330991995317154517718285836440465005,27672072725933000121901983367925347694111025283271589335038719296229849510185
+168012051050223499242044174326331474140038801279556896841565906207560227320690,27134767972872500055614403280459447260039099989714465645168626995212978266528
+170282484172523816799369095601011629195985271567118476528614094129284014176375,26607895990805365148558542391218752327077936735384764869356894955189244136002
+172552917294824134356694016875691784251931741854680056215662282051007801032060,26091254208081186520295830628576992670321075391182679321065607327265313932322
+174823350417124451914018938150371939307878212142241635902710469972731587887745,25584643986354865593328765236833491064966760582438881050282097633879965205565
+177093783539424769471343859425052094363824682429803215589758657894455374743430,25087870544214176820510595839294024971107825899184642127021233999936247081507
+179364216661725087028668780699732249419771152717364795276806845816179161599115,24600742882290243310082706540466488496131563143845631581983311961047083061256
+181634649784025404585993701974412404475717623004926374963855033737902948454800,24123073709822131836694888705209306323992339748006300420231840208502026712055
+183905082906325722143318623249092559531664093292487954650903221659626735310485,23654679372647332806338881400061315566868133427664662629105489367609937695646
+186175516028626039700643544523772714587610563580049534337951409581350522166170,23195379782590438967131080837393236404679360225477050241221440433306491390529
+188445949150926357257968465798452869643557033867611114024999597503074309021855,22744998348222874237097258296963376819397584603868543116623643157984253142510
+190716382273226674815293387073133024699503504155172693712047785424798095877540,22303361906967051161228844170125488556352938430940411562982254002868044311034
+192986815395526992372618308347813179755449974442734273399095973346521882733225,21870300658518852415771961233241780589753603014109439052609181643134330131200
+195257248517827309929943229622493334811396444730295853086144161268245669588910,21445648099562838646716735757033316057251336889853858375428467187815522927837
+197527681640127627487268150897173489867342915017857432773192349189969456444595,21029240959755081956656390289742251499446416407847034496990361844628688581109
+199798114762427945044593072171853644923289385305419012460240537111693243300280,20620919138949011730680161329173099008306763464882403634448661640684501661866
+202068547884728262601917993446533799979235855592980592147288725033417030155965,20220525645640137405137620676980023532901299004381393279093890751532452054423
+204338981007028580159242914721213955035182325880542171834336912955140817011650,19827906536605981416712487046651644994469849037549721389552871270682788176368
+206609414129328897716567835995894110091128796168103751521385100876864603867335,19442910857718015103451661807495877546362994006807802531582187045985408388323
+208879847251629215273892757270574265147075266455665331208433288798588390723020,19065390585902840940891643898043637774181614198870274451246241331546097600612
+211150280373929532831217678545254420203021736743226910895481476720312177578705,18695200572230306358460705740514292808692490977651168538902708783481421680348
+213420713496229850388542599819934575258968207030788490582529664642035964434390,18332198486106667663798285266862799262530724876828607112610697476363307765699
+215691146618530167945867521094614730314914677318350070269577852563759751290075,17976244760551347472111336927386090359808454572176186089250363261529225698797
+217961579740830485503192442369294885370861147605911649956626040485483538145760,17627202538536245657534631830721579840416279034844169182844082749512022955880
+220232012863130803060517363643975040426807617893473229643674228407207325001445,17284937620366972373860132250248373607831381821348510576523341628979456457899
+222502445985431120617842284918655195482754088181034809330722416328931111857130,16949318412085772290021286893087219332537721900597190962614965688689436470898
+224772879107731438175167206193335350538700558468596389017770604250654898712815,16620215874876302005383259706474512944760516297587146250989332554945114509504
+227043312230031755732492127468015505594647028756157968704818792172378685568500,16297503475450807802230954908656139014943597886328184429574709348911081384486
+229313745352332073289817048742695660650593499043719548391866980094102472424185,15981057137400628605961920332938849374838761847812884031059653371884698227732
+231584178474632390847141970017375815706539969331281128078915168015826259279870,15670755193491319402603874616100339746216923922257041729716527735529769853650
+233854611596932708404466891292055970762486439618842707765963355937550046135555,15366478338884053550790009737665512422829259009202431332168817628656130747976
+236125044719233025961791812566736125818432909906404287453011543859273832991240,15068109585265318560877642552077774766432262308314225827173090425609387180236
+238395477841533343519116733841416280874379380193965867140059731780997619846925,14775534215867269134414164114591717654313758765518045957328319974951247947864
+240665910963833661076441655116096435930325850481527446827107919702721406702610,14488639741361443696906809527925407527798326175077538816130520515576676432536
+242936344086133978633766576390776590986272320769089026514156107624445193558295,14207315856608886447500721787929418266891341269962575206208292606790558927738
+245206777208434296191091497665456746042218791056650606201204295546168980413980,13931454398250046219817842121237250069017319717552215812396900410729316780042
+247477210330734613748416418940136901098165261344212185888252483467892767269665,13660949303118146325455249570700165024364040604752663984462703166489664742339
+249747643453034931305741340214817056154111731631773765575300671389616554125350,13395696567460036159625482974163434950873419335747629798807509358843043114747
+252018076575335248863066261489497211210058201919335345262348859311340340981035,13135594206948845808872493016734991140070074672980170698797842470835657746355
+254288509697635566420391182764177366266004672206896924949397047233064127836720,12880542217473069333080972366140272174677497922483630681691757178031836728636
+256558942819935883977716104038857521321951142494458504636445235154787914692405,12630442536687000915161971042648362535726831652623366360951945091372138829073
+258829375942236201535041025313537676377897612782020084323493423076511701548090,12385199006307740796619289137869014505391917569864233277491827537392271272526
+261099809064536519092365946588217831433844083069581664010541610998235488403775,12144717335144274958225939593470301902208893969091913127900701796820969916276
+263370242186836836649690867862897986489790553357143243697589798919959275259460,11908905062844413972629474569782724684547574705479145661987238841262047512889
+265640675309137154207015789137578141545737023644704823384637986841683062115145,11677671524345652458077781103683012746985203951843087585351200546458450234583
+267911108431437471764340710412258296601683493932266403071686174763406848970830,11450927815016281205730420816822769656276856651451425159655410140798486590368
+270181541553737789321665631686938451657629964219827982758734362685130635826515,11228586756473349441251594323339849390046255944661352162796836657552528120100
+272451974676038106878990552961618606713576434507389562445782550606854422682200,11010562863064334916605775798811477728189133603960442457397758272811779333449
+274722407798338424436315474236298761769522904794951142132830738528578209537885,10796772308999634710251182117797466377054234368136632046647040836884880709149
+276992840920638741993640395510978916825469375082512721819878926450301996393570,10587132896123239841361951569073852197393979276538146129343090522801499481360
+279263274042939059550965316785659071881415845370074301506927114372025783249255,10381564022309202172514611506897394878877748812065679452742065418299049556809
+281533707165239377108290238060339226937362315657635881193975302293749570104940,10179986650471742679787468858482358928499942961441493648347660820939932354037
+283804140287539694665615159335019381993308785945197460881023490215473356960625,9982323278177086101950544601003257424140532557067992549916807460469069141662
+286074573409840012222940080609699537049255256232759040568071678137197143816310,9788497907845338332079968817743865213174453409259845129758908478094549262272
+288345006532140329780265001884379692105201726520320620255119866058920930671995,9598436017530949774464402361919053565881937627109257874972510208401009770963
+290615439654440647337589923159059847161148196807882199942168053980644717527680,9412064532270530344304969563638312480198627803597895883581869229790285361030
+292885872776740964894914844433740002217094667095443779629216241902368504383365,9229311795986999922973693773512111376663242782368889508055395732551288322377
+295156305899041282452239765708420157273041137383005359316264429824092291239050,9050107543939271981357133004643947981886610395815063538792001543567721697353
+297426739021341600009564686983100312328987607670566939003312617745816078094735,8874382875706877830311960657026508969290082662731915199950324279800475201683
+299697172143641917566889608257780467384934077958128518690360805667539864950420,8702070228699144631140925089885492819072907992531772224458410703022324971560
+301967605265942235124214529532460622440880548245690098377408993589263651806105,8533103352178741979338410836757093105256375792397040329065630149508413086135
+304238038388242552681539450807140777496827018533251678064457181510987438661790,8367417281789609639196736794874998402544481231388500060346139012236641543825
+306508471510542870238864372081820932552773488820813257751505369432711225517475,8204948314579472931243763439936896182045474760835882712220942160049717189792
+308778904632843187796189293356501087608719959108374837438553557354435012373160,8045633984507342433459354572450622071501444572221358150888492135726910593613
+311049337755143505353514214631181242664666429395936417125601745276158799228845,7889413038426581123905040544325858121069927256074308557819634343914244175953
+313319770877443822910839135905861397720612899683497996812649933197882586084530,7736225412534304938490539495998345262722685569683811485718517851478118074806
+315590203999744140468164057180541552776559369971059576499698121119606372940215,7586012209278062013393244296606783131019725342345569324815264018948034488407
+317860637122044458025488978455221707832505840258621156186746309041330159795900,7438715674710911696077991529315597910182131547815478256768516102178053147428
+320131070244344775582813899729901862888452310546182735873794496963053946651585,7294279176286196809531497726711149751773109079006438039328871808860505208647
+322401503366645093140138821004582017944398780833744315560842684884777733507270,7152647181083471707513356405012353952405611456310792512957976292047901188617
+324671936488945410697463742279262173000345251121305895247890872806501520362955,7013765234457214429330978163948031181884804665874684563234080173204818792192
+326942369611245728254788663553942328056291721408867474934939060728225307218640,6877579939100113814604817973991912882261222190269087624747098477473070920910
+329212802733546045812113584828622483112238191696429054621987248649949094074325,6744038934512881834200618407209402738374726406854013386327229734819886355209
+331483235855846363369438506103302638168184661983990634309035436571672880930010,6613090876872697694251640706911864470257281520044099539344107417605448847522
+333753668978146680926763427377982793224131132271552213996083624493396667785695,6484685419292543536070441670407899002441885350144223913319492393155843996609
+336024102100446998484088348652662948280077602559113793683131812415120454641380,6358773192463841844684321602472961808036370534710746466420213566001948927453
+338294535222747316041413269927343103336024072846675373370180000336844241497065,6235305785674952050504565665502249112334426989789636398933745643420892537805
+340564968345047633598738191202023258391970543134236953057228188258568028352750,6114235728198228318918503273647009044057809740115762935228605445446011541536
+342835401467347951156063112476703413447917013421798532744276376180291815208435,5995516471038482226936505302234614253048545365172641788639745380038847011850
+345105834589648268713388033751383568503863483709360112431324564102015602064120,5879102369035832978915788636227029754149990028304128445154065521569679896299
+347376267711948586270712955026063723559809953996921692118372752023739388919805,5764948663316064068243885471976803898564123312018636117461200936317441104963
+349646700834248903828037876300743878615756424284483271805420939945463175775490,5653011464081738901084106683312765416762298565331902697873676865978153014007
+351917133956549221385362797575424033671702894572044851492469127867186962631175,5543247733737458913233334532284737157076797625887278020789776292123991283042
+354187567078849538942687718850104188727649364859606431179517315788910749486860,5435615270342776182191625059155814516167449877265043810529451526313401440000
+356458000201149856500012640124784343783595835147168010866565503710634536342545,5330072691386398513087911834712869898427723411257226595273064182550426763859
+358728433323450174057337561399464498839542305434729590553613691632358323198230,5226579417875448507582021006206716342354483979921442218144570774799799153756
+360998866445750491614662482674144653895488775722291170240661879554082110053915,5125095658733659256765209168041122238133229257032719961413509211200048248333
+363269299568050809171987403948824808951435246009852749927710067475805896909600,5025582395502508078982293698284693835284469532255851267477746214208169030829
+365539732690351126729312325223504964007381716297414329614758255397529683765285,4928001367339406197066635979466804208185522234029567523625554767402211661565
+367810165812651444286637246498185119063328186584975909301806443319253470620970,4832315056307176461496499130904489365080602372384889128573871476885084197963
+370080598934951761843962167772865274119274656872537488988854631240977257476655,4738486672949163220359850565587517062963871431792713253071282139856533845449
+372351032057252079401287089047545429175221127160099068675902819162701044332340,4646480142144428256814095536419820031461458638508982355406532908762559366752
+374621465179552396958612010322225584231167597447660648362951007084424831188025,4556260089237594402171008726677813775125098076724227743627974892272588327070
+376891898301852714515936931596905739287114067735222228049999195006148618043710,4467791826438004029228927006814200361630588836617618519025510750743109199997
+379162331424153032073261852871585894343060538022783807737047382927872404899395,4381041339482963176613798998129770586400722046177381492207741626501677387270
+381432764546453349630586774146266049399007008310345387424095570849596191755080,4295975274559943590489358236239541053798654812625189402565013609912762502063
+383703197668753667187911695420946204454953478597906967111143758771319978610765,4212560925482714534092886286689429135772883215331118745250144375204860994258
+385973630791053984745236616695626359510899948885468546798191946693043765466450,4130766221116473846427146968171682243610648632762217464220432443306744076356
+388244063913354302302561537970306514566846419173030126485240134614767552322135,4050559713047143466628204822445172093558799258185730849489440714923595198306
+390514497035654619859886459244986669622792889460591706172288322536491339177820,3971910563490088516841239430057423861561699540314803552309386818215754652836
+392784930157954937417211380519666824678739359748153285859336510458215126033505,3894788533433611089965680791375046317061917745510095607652825551910399528715
+395055363280255254974536301794346979734685830035714865546384698379938912889190,3819163971012660154769745087149569914465567827492977553371176365210754983049
+397325796402555572531861223069027134790632300323276445233432886301662699744875,3745007800108287504328254434609249402710340257581916107575424870725436120735
+399596229524855890089186144343707289846578770610838024920481074223386486600560,3672291509168466468538116483953888412415082359790291319830667248103068617726
+401866662647156207646511065618387444902525240898399604607529262145110273456245,3600987140245975220983870041875004895679551495743211205866825798183240723922
+404137095769456525203835986893067599958471711185961184294577450066834060311930,3531067278249129967384164433549615728055232151532910541204821495878913836970
+406407528891756842761160908167747755014418181473522763981625637988557847167615,3462505040401235139336450269559039606157745830970264242579700439549733102016
+408677962014057160318485829442427910070364651761084343668673825910281634023300,3395274065904697964555996096535291493010779102468849709076001181212499029926
+410948395136357477875810750717108065126311122048645923355722013832005420878985,3329348505805833474130146144622500207015802447060544079287034222519730000801
+413218828258657795433135671991788220182257592336207503042770201753729207734670,3264703013056463168733957305768762048671220120100675556528510459350361442934
+415489261380958112990460593266468375238204062623769082729818389675452994590355,3201312732768486228946010278262122858837369338972372870253840600423809756146
+417759694503258430547785514541148530294150532911330662416866577597176781446040,3139153292657676348854251985374092135837494969951169782173776159644176534423
+420030127625558748105110435815828685350097003198892242103914765518900568301725,3078200793673030025577310098607138197203259951148621910059374341071023253667
+422300560747859065662435357090508840406043473486453821790962953440624355157410,3018431800808063478119054352864365216599069977484266467250325895140520117178
+424570993870159383219760278365188995461989943774015401478011141362348142013095,2959823334090525324552359078463176696893036195521598690559604864862321028159
+426841426992459700777085199639869150517936414061576981165059329284071928868780,2902352859747060743788555836574429934024784962979281619588506007014730754443
+429111860114760018334410120914549305573882884349138560852107517205795715724465,2845998281539430113506217335511024116647561786738955796723957128032460028562
+431382293237060335891735042189229460629829354636700140539155705127519502580150,2790737932268951075048841664512779579965827455433050874470612581492493796612
+433652726359360653449059963463909615685775824924261720226203893049243289435835,2736550565445897654615705160581380392035754504074875922703396122219838983601
+435923159481660971006384884738589770741722295211823299913252080970967076291520,2683415347120653492731207292836793547250299699949146040965909097366506826314
+438193592603961288563709806013269925797668765499384879600300268892690863147205,2631311847873478425170175781779819578108906286445566029098739049466961949804
+440464025726261606121034727287950080853615235786946459287348456814414650002890,2580220034959808642151093783793953402129918191024990104539947286476194870361
+442734458848561923678359648562630235909561706074508038974396644736138436858575,2530120264608070452133030819123365918858694576649021314235932359705643943273
+445004891970862241235684569837310390965508176362069618661444832657862223714260,2480993274467046314956915988152178555256121842686531405628524104350927660746
+447275325093162558793009491111990546021454646649631198348493020579586010569945,2432820176199889308902969867700028980919093407680036321083074765251991144298
+449545758215462876350334412386670701077401116937192778035541208501309797425630,2385582448221938579601135652712703469128873722647430092259396421200608174744
+451816191337763193907659333661350856133347587224754357722589396423033584281315,2339261928579543607308487238103279986560541266662742536344201858542715699027
+454086624460063511464984254936031011189294057512315937409637584344757371137000,2293840807967159344114184788286120867801944082584440628149280631165005320951
+456357057582363829022309176210711166245240527799877517096685772266481157992685,2249301622880027434993188844156208157845130306302793141117411709623435670173
+458627490704664146579634097485391321301186998087439096783733960188204944848370,2205627248899810866744487578412286757829514684708503434368069205255340039839
+460897923826964464136959018760071476357133468375000676470782148109928731704055,2162800894110600506761016035372877280458113909309651595222790899580498073682
+463168356949264781694283940034751631413079938662562256157830336031652518559740,2120806092642762118940557002260420725877403403643132375546681834433562628493
+465438790071565099251608861309431786469026408950123835844878523953376305415425,2079626698342141596131901285086838588831365589656553686857278748333033108659
+467709223193865416808933782584111941524972879237685415531926711875100092271110,2039246878562194346216395910444043784690021169116503952080024996424232086889
+469979656316165734366258703858792096580919349525246995218974899796823879126795,1999651108076652030782767922491430088269301331012688651267426380085596201366
+472250089438466051923583625133472251636865819812808574906023087718547665982480,1960824163110386199534010054524334089541753293394021687030939529972846447262
+474520522560766369480908546408152406692812290100370154593071275640271452838165,1922751115486173807887555445320207063113604718628558999245364537712059659787
+476790955683066687038233467682832561748758760387931734280119463561995239693850,1885417326885114167166377133451693487795698974827428621915772121522296322640
+479061388805367004595558388957512716804705230675493313967167651483719026549535,1848808443218490573462190057395600374688639714455162176619470154537224426642
+481331821927667322152883310232192871860651700963054893654215839405442813405220,1812910389108912709483102199711379114048329569523931425832014763952606023142
+483602255049967639710208231506873026916598171250616473341264027327166600260905,1777709362478617929951137999560857523114698493464640463314567998578763375930
+485872688172267957267533152781553181972544641538178053028312215248890387116590,1743191829242850741544443083382012278950030439838258806090307410195511152367
+488143121294568274824858074056233337028491111825739632715360403170614173972275,1709344518106280188825408838548340945706907890570414138312511052040629403114
+490413554416868592382182995330913492084437582113301212402408591092337960827960,1676154415460454473592585178001481888630499860343530369736761941087841137938
+492683987539168909939507916605593647140384052400862792089456779014061747683645,1643608760380330981872631688029464454202113613160652114812004614315882448607
+494954420661469227496832837880273802196330522688424371776504966935785534539330,1611695039717957985264493988118541627646396847164138227584506579980006189593
+497224853783769545054157759154953957252276992975985951463553154857509321395015,1580400983291421636207279946257561145576531467125488184028701658324803392105
+499495286906069862611482680429634112308223463263547531150601342779233108250700,1549714559167208504327370397252359435900676480118217197526808984667322295656
+501765720028370180168807601704314267364169933551109110837649530700956895106385,1519623969034169817411698521182954716530148741935550434876916238707975489825
+504036153150670497726132522978994422420116403838670690524697718622680681962070,1490117643667308789561999136522296289524839311469606144758176235295035574077
+506306586272970815283457444253674577476062874126232270211745906544404468817755,1461184238479646954250162028027864509672389242493414237027164373310873876617
+508577019395271132840782365528354732532009344413793849898794094466128255673440,1432812629160459284595696582392048709701342884089101780789506016757983545698
+510847452517571450398107286803034887587955814701355429585842282387852042529125,1404991907398201090242984454401886460001256486743771644647644675643019397120
+513117885639871767955432208077715042643902284988917009272890470309575829384810,1377711376686482242495906258989351428318340736703325118283502743772525420186
+515388318762172085512757129352395197699848755276478588959938658231299616240495,1350960548211476209390117246928289328516166528957389393408566548846213309144
+517658751884472403070082050627075352755795225564040168646986846153023403096180,1324729136819182692425165292411394327407511934209655077877674460464300121300
+519929185006772720627406971901755507811741695851601748334035034074747189951865,1299007057060993358777871916475898081725576133192311731321945268374304875079
+522199618129073038184731893176435662867688166139163328021083221996470976807550,1273784419316040268779271406014391437821438711132700913654395176336120357812
+524470051251373355742056814451115817923634636426724907708131409918194763663235,1249051525988836119835059106151604655038913776255529646900786453845629450261
+526740484373673673299381735725795972979581106714286487395179597839918550518920,1224798867780744376154319639656429438292590596449478554800662259883398133550
+529010917495973990856706657000476128035527577001848067082227785761642337374605,1201017120033845739753282342628997286268151802300216872136210819143441303664
+531281350618274308414031578275156283091474047289409646769275973683366124230290,1177697139145795253133868286972489045105718361046528878527448066379668652133
+533551783740574625971356499549836438147420517576971226456324161605089911085975,1154829959054291618502821225483149900650534431243083949245642604820923646588
+535822216862874943528681420824516593203366987864532806143372349526813697941660,1132406787789807082890425327211328755183700827007270235992079331829362643852
+538092649985175261086006342099196748259313458152094385830420537448537484797345,1110419004095252483338613492946986193747814242216914544087253927761374702549
+540363083107475578643331263373876903315259928439655965517468725370261271653030,1088858154111277781547261772857694251337802353360681665028106984738120501199
+542633516229775896200656184648557058371206398727217545204516913291985058508715,1067715948125933652889320598100629627595490376276215626206049496855639908739
+544903949352076213757981105923237213427152869014779124891565101213708845364400,1046984257387444440232701363407888596891997329416358164537461237895052190493
+547174382474376531315306027197917368483099339302340704578613289135432632220085,1026655110978867048053673500561104502292891906760695382551282292885769647385
+549444815596676848872630948472597523539045809589902284265661477057156419075770,1006720692753434146222353671415953866113533147281398201361542821926894368710
+551715248718977166429955869747277678594992279877463863952709664978880205931455,987173338329403384733958131783829533009147622988398599380784122106977308530
+553985681841277483987280791021957833650938750165025443639757852900603992787140,968005532143257199520483988560220733582298517120243540446994347402239110174
+556256114963577801544605712296637988706885220452587023326806040822327779642825,949209904560120224102845604039392059367322323910424009332173176480678795959
+558526548085878119101930633571318143762831690740148603013854228744051566498510,930779229040283320858879764591061717606873826779909083197312274038703255036
+560796981208178436659255554845998298818778161027710182700902416665775353354195,912706419360744817546225148870963828076628869100719699856881194145713586169
+563067414330478754216580476120678453874724631315271762387950604587499140209880,894984526890700687724824577161411173596658532863246109848772040565011872478
+565337847452779071773905397395358608930671101602833342074998792509222927065565,877606737919936156004596577686776039865420267809390448859339117903023609116
+567608280575079389331230318670038763986617571890394921762046980430946713921250,860566371039091548574664590528726362251021703804112434559419129682978794632
+569878713697379706888555239944718919042564042177956501449095168352670500776935,843856874570795154071557033366442926236979708804975971538286570121216914411
+572149146819680024445880161219399074098510512465518081136143356274394287632620,827471824050675417183296315424741971779066957250062452852260880325027656529
+574419579941980342003205082494079229154456982753079660823191544196118074488305,811404919757283964983682303379036253598800697102332643556476037720459831748
+576690013064280659560530003768759384210403453040641240510239732117841861343990,795649984289979771219745127738174910086802387263030261900019674061458963150
+578960446186580977117854925043439539266349923328202820197287920039565648199675,780200960193843203865524721501305631184795994974723658032277935470179306730
diff --git a/chain/types/testdata/TestLambdaFunction/10-100.golden b/chain/types/testdata/TestLambdaFunction/10-100.golden
new file mode 100644
index 000000000..adb7eaf5e
--- /dev/null
+++ b/chain/types/testdata/TestLambdaFunction/10-100.golden
@@ -0,0 +1 @@
+57896044618658097711785492504343953926634992332820282019728792003956564819968
\ No newline at end of file
diff --git a/chain/types/testdata/TestLambdaFunction/1024-2048.golden b/chain/types/testdata/TestLambdaFunction/1024-2048.golden
new file mode 100644
index 000000000..d449e4eab
--- /dev/null
+++ b/chain/types/testdata/TestLambdaFunction/1024-2048.golden
@@ -0,0 +1 @@
+289480223093290488558927462521719769633174961664101410098643960019782824099840
\ No newline at end of file
diff --git a/chain/types/testdata/TestLambdaFunction/2000000000000000-100000000000000000.golden b/chain/types/testdata/TestLambdaFunction/2000000000000000-100000000000000000.golden
new file mode 100644
index 000000000..76d1403ac
--- /dev/null
+++ b/chain/types/testdata/TestLambdaFunction/2000000000000000-100000000000000000.golden
@@ -0,0 +1 @@
+11579208923731619542357098500868790785326998466564056403945758400791312963993
\ No newline at end of file
diff --git a/chain/types/testdata/TestPoissonFunction/lam-10-10.golden b/chain/types/testdata/TestPoissonFunction/lam-10-10.golden
new file mode 100644
index 000000000..fbe59115f
--- /dev/null
+++ b/chain/types/testdata/TestPoissonFunction/lam-10-10.golden
@@ -0,0 +1,17 @@
+icdf
+1125278653883954157340515998824199281259686237023612910954531537010133365568
+5485581780123676224984074899749002236148166431650497590243915223971292577
+17842170241691453912141677461647358103546946338181118738604570718548080
+43538699106868068808561503680708109912117284430088557923220935824303
+85008817354919776986513548953593326094752560579206896166859206326
+138328508214407784218646352510285887677303021571444942144212932
+192946940473264032619492808002293590266469557064324916486706
+235498963868775663540157747991701194152938740691242898919
+255504995002156513848360474242833468958493714151012216
+249505772801580009049072856702435230216536441494110
+232834101038081471620316286291642591265760137159
+11533551765583311484083562200606025547302501012
+11353456917542541496993529059255898133794641608
+11353321629946357024346977051186975261639061786
+11353321535577219060847642123725989684858819334
+11353321535515780819985988910882590605707269697
diff --git a/chain/types/testdata/TestPoissonFunction/lam-1036915-20.golden b/chain/types/testdata/TestPoissonFunction/lam-1036915-20.golden
new file mode 100644
index 000000000..45444615d
--- /dev/null
+++ b/chain/types/testdata/TestPoissonFunction/lam-1036915-20.golden
@@ -0,0 +1,17 @@
+icdf
+72718197862321603787957847055188249408647877796280116987586082825356498974798
+30123322455004902866096392147720313525979066051167804713805891738863284666878
+9062729215708086547397523150443475826195010851218953471088727298493148732956
+2120601657722952965249404258310617497861606438105371150448777320082300909521
+404370264674629622846679825118378024155401061236248117877372450081489268106
+64941157977031699837280219244596630364570458903895153606060064374226923144
+8998760514291795062091202215054973561658841304177095664084807386711484044
+1095864305518189121413406860322570887693509822868614985675874891701983877
+118988091690998292615838041961723734187855286032350465668217096980526413
+11653361409102593830837021393444274321721937984503223867724441309766994
+1039253147016500070761515827557061937775360855994320103804816785188376
+85064880905559492020902336338153555957806293407638915883403930221828
+6433469833589351070633969345898155559842007456615136652210720692299
+452164666340411064711833496915674079929092772106312520794348036629
+29679788379529243880483477334855509673275091060271619731000625321
+1827354397264548824373139406487609602015834650190678153972930556
diff --git a/chain/types/testdata/TestPoissonFunction/lam-1706-10.golden b/chain/types/testdata/TestPoissonFunction/lam-1706-10.golden
new file mode 100644
index 000000000..fb6689a48
--- /dev/null
+++ b/chain/types/testdata/TestPoissonFunction/lam-1706-10.golden
@@ -0,0 +1,17 @@
+icdf
+93907545465879218275260347624273708225148723352890415890955745471328115138024
+57447553596668785643406883388130520172829512611140657354486862128150346836988
+27076095525930017054568011324233899656590951319429188573619716140132147265911
+10209654292635635800479757502291310268341281539592025246744927385067352842651
+3184715634432458451975226003210729824895496226017269232182332263939291493510
+843984120585852874524302031056145794325474791455055607017530061469667926785
+194034907919461416983404196340045475941285897027461784665454449911533518447
+39345544525367691179167072173518251727638261160626536209449847049064587000
+7131182470884793691126479665205819536661348710819293305892247868965466268
+1167890189531948301087715470416213490892402026859749426392544722128541359
+174396377814374645286335419995210764907848995332895729280582459579342738
+23925812935985027317838050852967276757134553590636105055350959232313899
+3035286920153916620063269622769735189335169019323041991528942663951986
+358060554242868329017312833503133182524340437692927389149107908421231
+39467628723598770945019147503633808666969235107758896427288845018926
+4082242594961149456000070139366495398696105445630156285138889148853
diff --git a/chain/types/testdata/TestPoissonFunction/lam-2-0.golden b/chain/types/testdata/TestPoissonFunction/lam-2-0.golden
new file mode 100644
index 000000000..c64994bd9
--- /dev/null
+++ b/chain/types/testdata/TestPoissonFunction/lam-2-0.golden
@@ -0,0 +1,17 @@
+icdf
+100121334043824876020967110392587568107053060743383522309741056272383359786578
+68779823656842237215759361160386888614619212898869438850308000801323820079862
+37438313269859598410551611928186209122185365054355355390874945330264280373146
+16543973011871172540413112440052422793896133158012633084586241682891253902002
+6096802882876959605343862695985529629751517209841271931441889859204740666430
+1917934831279274431316162798358772364093670830572727470184149129730135372202
+524978814080046039973596165816519942207722037483212649764902219905266940794
+126991380594552213875719985090162107383165239457636986787974531383875960392
+27494522223178757351250939908572648677026039951243071043742609253528215292
+5384109251762433679146707645997213408995106727599978656135515446784271938
+962026657479168944725861193482126355388920082871360178614096685435483268
+158011640336757174831161838479383254733249783829793182701111456099339874
+24009137479688546515378612645592737957304733989532016715613917876649310
+3393367809370296005258116363471119991774726321799529640921988919312302
+448257856467688789526616894596603139556153797837745773108856211121302
+55576529414007827429083632080000892593677461309507924067105183362502
diff --git a/chain/types/testdata/TestPoissonFunction/lam-209714-20.golden b/chain/types/testdata/TestPoissonFunction/lam-209714-20.golden
new file mode 100644
index 000000000..3a5a7bd46
--- /dev/null
+++ b/chain/types/testdata/TestPoissonFunction/lam-209714-20.golden
@@ -0,0 +1,17 @@
+icdf
+20989436322611254574979389012727393136091537312055593688180077279147576363096
+2029014232696520721523332453453803636238058967796600089005757967894658844577
+132982872945592560215194824292206599698851338836977427578620974467337246296
+6581505574095040906286115477587166321018484661524779791358182693980706360
+261473369241451189291715224208035992983406808190620756138506410631265448
+8673527587881831627652027122245179992541421812500366598395022980519170
+246914417172755020716947338861248744263385116558896234139925344965714
+6155418508705151241339695503211918565434455355693098789916851059631
+136477982954924943101944815709613669983383501630000081908122878386
+2724514397229876659600187515561464490237868059330199615762951760
+49460332945698577716770256622916953121860884014393828193908634
+823264627479642334265449493920662550930201158945634649498769
+12651460568281449375957051928671501418597070452648092732548
+180560129118157986659345179422379755776654969450793746138
+2405427973892505908363489341734991530618943133521671600
+30045550760659097055494870911555042207154242485930695
diff --git a/chain/types/testdata/TestPoissonFunction/lam-5-0.golden b/chain/types/testdata/TestPoissonFunction/lam-5-0.golden
new file mode 100644
index 000000000..e7df148c9
--- /dev/null
+++ b/chain/types/testdata/TestPoissonFunction/lam-5-0.golden
@@ -0,0 +1,17 @@
+icdf
+115011888277122352219705460287186602222085188670665840381425306072442950421456
+111110883476153136200377836679680074066161208695792222091263916395092054329056
+101358371473730096152058777660913753676351258758608176365860442201714814098056
+85104184803025029404860345962969886360001342196634766823521318546086080379726
+64786451464643695970862306340540052214563946494168004895597413976550163231816
+44468718126262362536864266718110218069126550791701242967673509407014246083906
+27537273677611251341865900366085356281262054372978941361070255599067648460651
+15443384785717600488295638686067597861358842645320154499210788593391507301186
+7884704228284068704814225136056498848919335315533412710548621714843919076521
+3685437251932106602880106497161443842008497910096333939069640115650814507266
+1585803763756125551913047177713916338553079207377794553330149316054262222641
+631424905494315983291656577965040200618797978869367559812198952601283911451
+233767047885228663032743828069675143146180800324189645846386301162542948456
+80821718035579693702392770417611659502866500883736602013381435224565655001
+26198385946419347512981678399017558201682822512146229215879697389573764486
+7990608583365898783177981059486191101288263054949438283379118111243134316
diff --git a/chain/types/testdata/TestPoissonFunction/lam-5242879-20.golden b/chain/types/testdata/TestPoissonFunction/lam-5242879-20.golden
new file mode 100644
index 000000000..367cf4a6d
--- /dev/null
+++ b/chain/types/testdata/TestPoissonFunction/lam-5242879-20.golden
@@ -0,0 +1,17 @@
+icdf
+115011887533064380050215202002871794783671664388541274939039184893270600703151
+111110879755863630144777547269452207577572562543679248972859798819416242535921
+101358362173007217989878395557465593373392010546833825352856759707561945139525
+85104169301821710755220628061805234978705652326202881500299286939503312327242
+64786432088141395502693562453332343133008530920262028792733819517798429528997
+44468698749761909885846743680008378684637277300179598543979674797636862943384
+27537257530529080605729671834720742022613060678716434560927439906969908575619
+15443373252088578337713549627194971124753642243467082552611819728291522561946
+7884697019766617162458477655388623015603913245952633503615157778326861227793
+3685433247200570820185174890022164698361097802621279879954268046011715772231
+1585801761390548420193995297013958176769177427873274589439743405082427147382
+631423995328231141553650878972791975288890578033071631113620389859816342901
+233766668649395912353875000216328335294367462954196928187468994385755448892
+80821572175657684536655650469711580587115741420816601432036447172153463116
+26198333853594769407667441209847842642730676168975225661522405972966431948
+7990591219092428810606628986022697269060757693982546042792694706871429282
diff --git a/chain/types/tipset.go b/chain/types/tipset.go
index a4fb209cb..44d41c29d 100644
--- a/chain/types/tipset.go
+++ b/chain/types/tipset.go
@@ -7,8 +7,10 @@ import (
 	"io"
 	"sort"
 
+	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/ipfs/go-cid"
-	logging "github.com/ipfs/go-log"
+	logging "github.com/ipfs/go-log/v2"
+	"github.com/minio/blake2b-simd"
 	cbg "github.com/whyrusleeping/cbor-gen"
 	"golang.org/x/xerrors"
 )
@@ -18,18 +20,18 @@ var log = logging.Logger("types")
 type TipSet struct {
 	cids   []cid.Cid
 	blks   []*BlockHeader
-	height uint64
+	height abi.ChainEpoch
 }
 
-// why didnt i just export the fields? Because the struct has methods with the
-// same names already
 type ExpTipSet struct {
 	Cids   []cid.Cid
 	Blocks []*BlockHeader
-	Height uint64
+	Height abi.ChainEpoch
 }
 
 func (ts *TipSet) MarshalJSON() ([]byte, error) {
+	// why didnt i just export the fields? Because the struct has methods with the
+	// same names already
 	return json.Marshal(ExpTipSet{
 		Cids:   ts.cids,
 		Blocks: ts.blks,
@@ -88,13 +90,19 @@ func tipsetSortFunc(blks []*BlockHeader) func(i, j int) bool {
 
 		if ti.Equals(tj) {
 			log.Warnf("blocks have same ticket (%s %s)", blks[i].Miner, blks[j].Miner)
-			return blks[i].Cid().KeyString() < blks[j].Cid().KeyString()
+			return bytes.Compare(blks[i].Cid().Bytes(), blks[j].Cid().Bytes()) < 0
 		}
 
 		return ti.Less(tj)
 	}
 }
 
+// Checks:
+// * A tipset is composed of at least one block. (Because of our variable
+//   number of blocks per tipset, determined by randomness, we do not impose
+//   an upper limit.)
+// * All blocks have the same height.
+// * All blocks have the same parents (same number of them and matching CIDs).
 func NewTipSet(blks []*BlockHeader) (*TipSet, error) {
 	if len(blks) == 0 {
 		return nil, xerrors.Errorf("NewTipSet called with zero length array of blocks")
@@ -110,6 +118,10 @@ func NewTipSet(blks []*BlockHeader) (*TipSet, error) {
 			return nil, fmt.Errorf("cannot create tipset with mismatching heights")
 		}
 
+		if len(blks[0].Parents) != len(b.Parents) {
+			return nil, fmt.Errorf("cannot create tipset with mismatching number of parents")
+		}
+
 		for i, cid := range b.Parents {
 			if cid != blks[0].Parents[i] {
 				return nil, fmt.Errorf("cannot create tipset with mismatching parents")
@@ -129,10 +141,13 @@ func (ts *TipSet) Cids() []cid.Cid {
 }
 
 func (ts *TipSet) Key() TipSetKey {
+	if ts == nil {
+		return EmptyTSK
+	}
 	return NewTipSetKey(ts.cids...)
 }
 
-func (ts *TipSet) Height() uint64 {
+func (ts *TipSet) Height() abi.ChainEpoch {
 	return ts.height
 }
 
@@ -166,7 +181,9 @@ func (ts *TipSet) Equals(ots *TipSet) bool {
 }
 
 func (t *Ticket) Less(o *Ticket) bool {
-	return bytes.Compare(t.VRFProof, o.VRFProof) < 0
+	tDigest := blake2b.Sum256(t.VRFProof)
+	oDigest := blake2b.Sum256(o.VRFProof)
+	return bytes.Compare(tDigest[:], oDigest[:]) < 0
 }
 
 func (ts *TipSet) MinTicket() *Ticket {
@@ -213,3 +230,15 @@ func (ts *TipSet) Contains(oc cid.Cid) bool {
 	}
 	return false
 }
+
+func (ts *TipSet) IsChildOf(parent *TipSet) bool {
+	return CidArrsEqual(ts.Parents().Cids(), parent.Cids()) &&
+		// FIXME: The height check might go beyond what is meant by
+		//  "parent", but many parts of the code rely on the tipset's
+		//  height for their processing logic at the moment to obviate it.
+		ts.height > parent.height
+}
+
+func (ts *TipSet) String() string {
+	return fmt.Sprintf("%v", ts.cids)
+}
diff --git a/chain/types/tipset_key.go b/chain/types/tipset_key.go
index 194f712db..e5bc7750d 100644
--- a/chain/types/tipset_key.go
+++ b/chain/types/tipset_key.go
@@ -5,15 +5,19 @@ import (
 	"encoding/json"
 	"strings"
 
+	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/ipfs/go-cid"
-	"github.com/multiformats/go-multihash"
 )
 
+var EmptyTSK = TipSetKey{}
+
 // The length of a block header CID in bytes.
 var blockHeaderCIDLen int
 
 func init() {
-	c, err := cid.V1Builder{Codec: cid.DagCBOR, MhType: multihash.BLAKE2B_MIN + 31}.Sum([]byte{})
+	// hash a large string of zeros so we don't estimate based on inlined CIDs.
+	var buf [256]byte
+	c, err := abi.CidBuilder.Sum(buf[:])
 	if err != nil {
 		panic(err)
 	}
@@ -90,6 +94,10 @@ func (k *TipSetKey) UnmarshalJSON(b []byte) error {
 	return nil
 }
 
+func (k TipSetKey) IsEmpty() bool {
+	return len(k.value) == 0
+}
+
 func encodeKey(cids []cid.Cid) []byte {
 	buffer := new(bytes.Buffer)
 	for _, c := range cids {
diff --git a/chain/types/tipset_key_test.go b/chain/types/tipset_key_test.go
index 43ff1a3df..7b3ce439d 100644
--- a/chain/types/tipset_key_test.go
+++ b/chain/types/tipset_key_test.go
@@ -61,9 +61,9 @@ func TestTipSetKey(t *testing.T) {
 
 	t.Run("JSON", func(t *testing.T) {
 		k0 := NewTipSetKey()
-		verifyJson(t, "[]", k0)
+		verifyJSON(t, "[]", k0)
 		k3 := NewTipSetKey(c1, c2, c3)
-		verifyJson(t, `[`+
+		verifyJSON(t, `[`+
 			`{"/":"bafy2bzacecesrkxghscnq7vatble2hqdvwat6ed23vdu4vvo3uuggsoaya7ki"},`+
 			`{"/":"bafy2bzacebxfyh2fzoxrt6kcgc5dkaodpcstgwxxdizrww225vrhsizsfcg4g"},`+
 			`{"/":"bafy2bzacedwviarjtjraqakob5pslltmuo5n3xev3nt5zylezofkbbv5jclyu"}`+
@@ -71,7 +71,7 @@ func TestTipSetKey(t *testing.T) {
 	})
 }
 
-func verifyJson(t *testing.T, expected string, k TipSetKey) {
+func verifyJSON(t *testing.T, expected string, k TipSetKey) {
 	bytes, err := json.Marshal(k)
 	require.NoError(t, err)
 	assert.Equal(t, expected, string(bytes))
diff --git a/chain/types/types_test.go b/chain/types/types_test.go
index d912c20e3..1056fc430 100644
--- a/chain/types/types_test.go
+++ b/chain/types/types_test.go
@@ -22,13 +22,14 @@ func blsaddr(n int64) address.Address {
 
 func BenchmarkSerializeMessage(b *testing.B) {
 	m := &Message{
-		To:       blsaddr(1),
-		From:     blsaddr(2),
-		Nonce:    197,
-		Method:   1231254,
-		Params:   []byte("some bytes, idk. probably at least ten of them"),
-		GasLimit: NewInt(126723),
-		GasPrice: NewInt(1776234),
+		To:         blsaddr(1),
+		From:       blsaddr(2),
+		Nonce:      197,
+		Method:     1231254,
+		Params:     []byte("some bytes, idk. probably at least ten of them"),
+		GasLimit:   126723,
+		GasPremium: NewInt(1245667),
+		GasFeeCap:  NewInt(1245667),
 	}
 
 	b.ReportAllocs()
diff --git a/chain/types/vmcontext.go b/chain/types/vmcontext.go
index 1af2aa3da..d0ce42c0f 100644
--- a/chain/types/vmcontext.go
+++ b/chain/types/vmcontext.go
@@ -1,13 +1,10 @@
 package types
 
 import (
-	"context"
-
 	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-amt-ipld"
 	"github.com/filecoin-project/lotus/chain/actors/aerrors"
+
 	cid "github.com/ipfs/go-cid"
-	hamt "github.com/ipfs/go-hamt-ipld"
 	cbg "github.com/whyrusleeping/cbor-gen"
 )
 
@@ -24,31 +21,10 @@ type Storage interface {
 
 type StateTree interface {
 	SetActor(addr address.Address, act *Actor) error
+	// GetActor returns the actor from any type of `addr` provided.
 	GetActor(addr address.Address) (*Actor, error)
 }
 
-type VMContext interface {
-	Message() *Message
-	Origin() address.Address
-	Ipld() *hamt.CborIpldStore
-	Send(to address.Address, method uint64, value BigInt, params []byte) ([]byte, aerrors.ActorError)
-	BlockHeight() uint64
-	GasUsed() BigInt
-	Storage() Storage
-	StateTree() (StateTree, aerrors.ActorError)
-	VerifySignature(sig *Signature, from address.Address, data []byte) aerrors.ActorError
-	ChargeGas(uint64) aerrors.ActorError
-	GetRandomness(height uint64) ([]byte, aerrors.ActorError)
-	GetBalance(address.Address) (BigInt, aerrors.ActorError)
-	Sys() *VMSyscalls
-
-	Context() context.Context
-}
-
-type VMSyscalls struct {
-	ValidatePoRep func(context.Context, address.Address, uint64, []byte, []byte, []byte, []byte, []byte, uint64) (bool, aerrors.ActorError)
-}
-
 type storageWrapper struct {
 	s Storage
 }
@@ -69,7 +45,3 @@ func (sw *storageWrapper) Get(c cid.Cid, out cbg.CBORUnmarshaler) error {
 
 	return nil
 }
-
-func WrapStorage(s Storage) amt.Blocks {
-	return &storageWrapper{s}
-}
diff --git a/chain/types/voucher.go b/chain/types/voucher.go
index ba2bab6ec..687109c33 100644
--- a/chain/types/voucher.go
+++ b/chain/types/voucher.go
@@ -1,88 +1,22 @@
 package types
 
 import (
-	"bytes"
 	"encoding/base64"
 
-	"github.com/filecoin-project/go-address"
-	cborrpc "github.com/filecoin-project/go-cbor-util"
+	"github.com/filecoin-project/specs-actors/actors/builtin/paych"
 	cbor "github.com/ipfs/go-ipld-cbor"
 )
 
-type SignedVoucher struct {
-	TimeLock       uint64
-	SecretPreimage []byte
-	Extra          *ModVerifyParams
-	Lane           uint64
-	Nonce          uint64
-	Amount         BigInt
-	MinCloseHeight uint64
-
-	Merges []Merge
-
-	Signature *Signature
-}
-
-func (sv *SignedVoucher) SigningBytes() ([]byte, error) {
-	osv := *sv
-	osv.Signature = nil
-
-	buf := new(bytes.Buffer)
-	if err := osv.MarshalCBOR(buf); err != nil {
-		return nil, err
-	}
-
-	return buf.Bytes(), nil
-}
-
-func (sv *SignedVoucher) EncodedString() (string, error) {
-	buf := new(bytes.Buffer)
-	if err := sv.MarshalCBOR(buf); err != nil {
-		return "", err
-	}
-
-	return base64.RawURLEncoding.EncodeToString(buf.Bytes()), nil
-}
-
-func (sv *SignedVoucher) Equals(other *SignedVoucher) bool {
-	// TODO: make this less bad
-
-	selfB, err := cborrpc.Dump(sv)
-	if err != nil {
-		log.Errorf("SignedVoucher.Equals: dump self: %s", err)
-		return false
-	}
-
-	otherB, err := cborrpc.Dump(other)
-	if err != nil {
-		log.Errorf("SignedVoucher.Equals: dump other: %s", err)
-		return false
-	}
-
-	return bytes.Equal(selfB, otherB)
-}
-
-func DecodeSignedVoucher(s string) (*SignedVoucher, error) {
+func DecodeSignedVoucher(s string) (*paych.SignedVoucher, error) {
 	data, err := base64.RawURLEncoding.DecodeString(s)
 	if err != nil {
 		return nil, err
 	}
 
-	var sv SignedVoucher
+	var sv paych.SignedVoucher
 	if err := cbor.DecodeInto(data, &sv); err != nil {
 		return nil, err
 	}
 
 	return &sv, nil
 }
-
-type Merge struct {
-	Lane  uint64
-	Nonce uint64
-}
-
-type ModVerifyParams struct {
-	Actor  address.Address
-	Method uint64
-	Data   []byte
-}
diff --git a/chain/types_test.go b/chain/types_test.go
index 17b6c9cdd..b47471c9d 100644
--- a/chain/types_test.go
+++ b/chain/types_test.go
@@ -1,9 +1,12 @@
 package chain
 
 import (
+	"crypto/rand"
 	"encoding/json"
 	"testing"
 
+	"github.com/filecoin-project/lotus/build"
+
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/lotus/chain/types"
 )
@@ -13,14 +16,15 @@ func TestSignedMessageJsonRoundtrip(t *testing.T) {
 	from, _ := address.NewIDAddress(603911192)
 	smsg := &types.SignedMessage{
 		Message: types.Message{
-			To:       to,
-			From:     from,
-			Params:   []byte("some bytes, idk"),
-			Method:   1235126,
-			Value:    types.NewInt(123123),
-			GasPrice: types.NewInt(1234),
-			GasLimit: types.NewInt(9992969384),
-			Nonce:    123123,
+			To:         to,
+			From:       from,
+			Params:     []byte("some bytes, idk"),
+			Method:     1235126,
+			Value:      types.NewInt(123123),
+			GasFeeCap:  types.NewInt(1234),
+			GasPremium: types.NewInt(132414234),
+			GasLimit:   100_000_000,
+			Nonce:      123123,
 		},
 	}
 
@@ -34,3 +38,40 @@ func TestSignedMessageJsonRoundtrip(t *testing.T) {
 		t.Fatal(err)
 	}
 }
+
+func TestAddressType(t *testing.T) {
+	build.SetAddressNetwork(address.Testnet)
+	addr, err := makeRandomAddress()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if string(addr[0]) != address.TestnetPrefix {
+		t.Fatalf("address should start with %s", address.TestnetPrefix)
+	}
+
+	build.SetAddressNetwork(address.Mainnet)
+	addr, err = makeRandomAddress()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if string(addr[0]) != address.MainnetPrefix {
+		t.Fatalf("address should start with %s", address.MainnetPrefix)
+	}
+}
+
+func makeRandomAddress() (string, error) {
+	bytes := make([]byte, 32)
+	_, err := rand.Read(bytes)
+	if err != nil {
+		return "", err
+	}
+
+	addr, err := address.NewActorAddress(bytes)
+	if err != nil {
+		return "", err
+	}
+
+	return addr.String(), nil
+}
diff --git a/chain/validation/applier.go b/chain/validation/applier.go
deleted file mode 100644
index 4e21f1228..000000000
--- a/chain/validation/applier.go
+++ /dev/null
@@ -1,65 +0,0 @@
-package validation
-
-import (
-	"context"
-
-	vchain "github.com/filecoin-project/chain-validation/pkg/chain"
-	vstate "github.com/filecoin-project/chain-validation/pkg/state"
-	vtypes "github.com/filecoin-project/chain-validation/pkg/state/types"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/lotus/chain/types"
-	"github.com/filecoin-project/lotus/chain/vm"
-)
-
-// Applier applies messages to state trees and storage.
-type Applier struct {
-}
-
-var _ vchain.Applier = &Applier{}
-
-func NewApplier() *Applier {
-	return &Applier{}
-}
-
-func (a *Applier) ApplyMessage(eCtx *vchain.ExecutionContext, state vstate.Wrapper, message interface{}) (vchain.MessageReceipt, error) {
-	ctx := context.TODO()
-	st := state.(*StateWrapper)
-
-	base := st.Cid()
-	randSrc := &vmRand{eCtx}
-	minerAddr, err := address.NewFromBytes(eCtx.MinerOwner.Bytes())
-	if err != nil {
-		return vchain.MessageReceipt{}, err
-	}
-	lotusVM, err := vm.NewVM(base, eCtx.Epoch, randSrc, minerAddr, st.bs)
-	if err != nil {
-		return vchain.MessageReceipt{}, err
-	}
-
-	ret, err := lotusVM.ApplyMessage(ctx, message.(*types.Message))
-	if err != nil {
-		return vchain.MessageReceipt{}, err
-	}
-
-	st.stateRoot, err = lotusVM.Flush(ctx)
-	if err != nil {
-		return vchain.MessageReceipt{}, err
-	}
-
-	mr := vchain.MessageReceipt{
-		ExitCode:    ret.ExitCode,
-		ReturnValue: ret.Return,
-		GasUsed:     vtypes.GasUnit(ret.GasUsed.Uint64()),
-	}
-
-	return mr, ret.ActorErr
-}
-
-type vmRand struct {
-	eCtx *vchain.ExecutionContext
-}
-
-func (*vmRand) GetRandomness(ctx context.Context, h int64) ([]byte, error) {
-	panic("implement me")
-}
diff --git a/chain/validation/factories.go b/chain/validation/factories.go
deleted file mode 100644
index 336db2282..000000000
--- a/chain/validation/factories.go
+++ /dev/null
@@ -1,27 +0,0 @@
-package validation
-
-import (
-	vchain "github.com/filecoin-project/chain-validation/pkg/chain"
-	vstate "github.com/filecoin-project/chain-validation/pkg/state"
-	"github.com/filecoin-project/chain-validation/pkg/suites"
-)
-
-type factories struct {
-	*Applier
-}
-
-var _ suites.Factories = &factories{}
-
-func NewFactories() *factories {
-	applier := NewApplier()
-	return &factories{applier}
-}
-
-func (f *factories) NewState() vstate.Wrapper {
-	return NewState()
-}
-
-func (f *factories) NewMessageFactory(wrapper vstate.Wrapper) vchain.MessageFactory {
-	signer := wrapper.(*StateWrapper).Signer()
-	return NewMessageFactory(signer)
-}
diff --git a/chain/validation/message.go b/chain/validation/message.go
deleted file mode 100644
index 2e497184f..000000000
--- a/chain/validation/message.go
+++ /dev/null
@@ -1,96 +0,0 @@
-package validation
-
-import (
-	"context"
-	"github.com/ipfs/go-cid"
-	"golang.org/x/xerrors"
-
-	vchain "github.com/filecoin-project/chain-validation/pkg/chain"
-	vactors "github.com/filecoin-project/chain-validation/pkg/state/actors"
-	vaddress "github.com/filecoin-project/chain-validation/pkg/state/address"
-	vtypes "github.com/filecoin-project/chain-validation/pkg/state/types"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/lotus/chain/actors"
-	"github.com/filecoin-project/lotus/chain/types"
-)
-
-type Signer interface {
-	Sign(ctx context.Context, addr vaddress.Address, msg []byte) (*types.Signature, error)
-}
-
-type MessageFactory struct {
-	signer Signer
-}
-
-var _ vchain.MessageFactory = &MessageFactory{}
-
-func NewMessageFactory(signer Signer) *MessageFactory {
-	return &MessageFactory{signer}
-}
-
-func (mf *MessageFactory) MakeMessage(from, to vaddress.Address, method vchain.MethodID, nonce uint64, value, gasPrice vtypes.BigInt, gasLimit vtypes.GasUnit, params []byte) (interface{}, error) {
-	fromDec, err := address.NewFromBytes(from.Bytes())
-	if err != nil {
-		return nil, err
-	}
-	toDec, err := address.NewFromBytes(to.Bytes())
-	if err != nil {
-		return nil, err
-	}
-	valueDec := types.BigInt{value.Int}
-
-	if int(method) >= len(methods) {
-		return nil, xerrors.Errorf("No method name for method %v", method)
-	}
-	methodId := methods[method]
-	msg := &types.Message{
-		toDec,
-		fromDec,
-		nonce,
-		valueDec,
-		types.BigInt{gasPrice.Int},
-		types.NewInt(uint64(gasLimit)),
-		methodId,
-		params,
-	}
-
-	return msg, nil
-}
-
-func (mf *MessageFactory) FromSingletonAddress(addr vactors.SingletonActorID) vaddress.Address {
-	return fromSingletonAddress(addr)
-}
-
-func (mf *MessageFactory) FromActorCodeCid(code vactors.ActorCodeID) cid.Cid {
-	return fromActorCode(code)
-}
-
-// Maps method enumeration values to method names.
-// This will change to a mapping to method ids when method dispatch is updated to use integers.
-var methods = []uint64{
-	vchain.NoMethod: 0,
-	vchain.InitExec: actors.IAMethods.Exec,
-
-	vchain.StoragePowerConstructor:        actors.SPAMethods.Constructor,
-	vchain.StoragePowerCreateStorageMiner: actors.SPAMethods.CreateStorageMiner,
-	vchain.StoragePowerUpdatePower:        actors.SPAMethods.UpdateStorage,
-
-	vchain.StorageMinerUpdatePeerID:  actors.MAMethods.UpdatePeerID,
-	vchain.StorageMinerGetOwner:      actors.MAMethods.GetOwner,
-	vchain.StorageMinerGetPower:      actors.MAMethods.GetPower,
-	vchain.StorageMinerGetWorkerAddr: actors.MAMethods.GetWorkerAddr,
-	vchain.StorageMinerGetPeerID:     actors.MAMethods.GetPeerID,
-	vchain.StorageMinerGetSectorSize: actors.MAMethods.GetSectorSize,
-
-	vchain.MultiSigConstructor:       actors.MultiSigMethods.MultiSigConstructor,
-	vchain.MultiSigPropose:           actors.MultiSigMethods.Propose,
-	vchain.MultiSigApprove:           actors.MultiSigMethods.Approve,
-	vchain.MultiSigCancel:            actors.MultiSigMethods.Cancel,
-	vchain.MultiSigClearCompleted:    actors.MultiSigMethods.ClearCompleted,
-	vchain.MultiSigAddSigner:         actors.MultiSigMethods.AddSigner,
-	vchain.MultiSigRemoveSigner:      actors.MultiSigMethods.RemoveSigner,
-	vchain.MultiSigSwapSigner:        actors.MultiSigMethods.SwapSigner,
-	vchain.MultiSigChangeRequirement: actors.MultiSigMethods.ChangeRequirement,
-	// More to follow...
-}
diff --git a/chain/validation/message_test.go b/chain/validation/message_test.go
deleted file mode 100644
index 65fcc94dc..000000000
--- a/chain/validation/message_test.go
+++ /dev/null
@@ -1,59 +0,0 @@
-package validation
-
-import (
-	"context"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-
-	vchain "github.com/filecoin-project/chain-validation/pkg/chain"
-	vactors "github.com/filecoin-project/chain-validation/pkg/state/actors"
-	vaddress "github.com/filecoin-project/chain-validation/pkg/state/address"
-	vtypes "github.com/filecoin-project/chain-validation/pkg/state/types"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/lotus/chain/actors"
-	"github.com/filecoin-project/lotus/chain/types"
-	"github.com/filecoin-project/lotus/chain/wallet"
-)
-
-func TestMessageFactory(t *testing.T) {
-	ks := wallet.NewMemKeyStore()
-	wallet, err := wallet.NewWallet(ks)
-	require.NoError(t, err)
-	factory := NewMessageFactory(&walletWrapper{wallet})
-
-	gasPrice := vtypes.NewInt(1)
-	gasLimit := vtypes.GasUnit(1000)
-	p := vchain.NewMessageProducer(factory, gasLimit, gasPrice)
-
-	sender, err := wallet.GenerateKey(types.KTSecp256k1)
-	require.NoError(t, err)
-
-	bfAddr := factory.FromSingletonAddress(vactors.BurntFundsAddress)
-	addr, err := vaddress.NewFromBytes(sender.Bytes())
-	require.NoError(t, err)
-	m, err := p.Transfer(addr, bfAddr, 0, 1)
-	require.NoError(t, err)
-
-	messages := p.Messages()
-	assert.Equal(t, 1, len(messages))
-	msg := m.(*types.Message)
-	assert.Equal(t, m, msg)
-	assert.Equal(t, sender, msg.From)
-	assert.Equal(t, actors.BurntFundsAddress, msg.To)
-	assert.Equal(t, types.NewInt(1), msg.Value)
-}
-
-type walletWrapper struct {
-	w *wallet.Wallet
-}
-
-func (ww *walletWrapper) Sign(ctx context.Context, vaddr vaddress.Address, msg []byte) (*types.Signature, error) {
-	addr, err := address.NewFromBytes(vaddr.Bytes())
-	if err != nil {
-		return nil, err
-	}
-	return ww.w.Sign(ctx, addr, msg)
-}
diff --git a/chain/validation/state.go b/chain/validation/state.go
deleted file mode 100644
index f03aee5d8..000000000
--- a/chain/validation/state.go
+++ /dev/null
@@ -1,365 +0,0 @@
-package validation
-
-import (
-	"context"
-	"fmt"
-	"math/rand"
-
-	"github.com/ipfs/go-cid"
-	"github.com/ipfs/go-datastore"
-	"github.com/ipfs/go-hamt-ipld"
-	blockstore "github.com/ipfs/go-ipfs-blockstore"
-	"github.com/minio/blake2b-simd"
-	cbg "github.com/whyrusleeping/cbor-gen"
-	"golang.org/x/xerrors"
-
-	vstate "github.com/filecoin-project/chain-validation/pkg/state"
-	vactors "github.com/filecoin-project/chain-validation/pkg/state/actors"
-	vaddress "github.com/filecoin-project/chain-validation/pkg/state/address"
-	vtypes "github.com/filecoin-project/chain-validation/pkg/state/types"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-crypto"
-	"github.com/filecoin-project/lotus/chain/actors"
-	"github.com/filecoin-project/lotus/chain/gen"
-	"github.com/filecoin-project/lotus/chain/state"
-	"github.com/filecoin-project/lotus/chain/types"
-	"github.com/filecoin-project/lotus/chain/vm"
-	"github.com/filecoin-project/lotus/chain/wallet"
-)
-
-type StateWrapper struct {
-	// The blockstore underlying the state tree and storage.
-	bs blockstore.Blockstore
-	// HAMT-CBOR store on top of the blockstore.
-	cst *hamt.CborIpldStore
-	// A store for encryption keys.
-	keys *keyStore
-
-	// CID of the root of the state tree.
-	stateRoot cid.Cid
-	// The root node of the state tree, essentially a cache of LoadStateTree(cst, stateRoot)
-	//tree *state.StateTree
-	// A look-through storage implementation.
-	storage *directStorage
-}
-
-var _ vstate.Wrapper = &StateWrapper{}
-
-func NewState() *StateWrapper {
-	bs := blockstore.NewBlockstore(datastore.NewMapDatastore())
-	cst := hamt.CSTFromBstore(bs)
-	// Put EmptyObjectCid value in the store. When an actor is initially created its Head is set to this value.
-	_, err := cst.Put(context.TODO(), map[string]string{})
-	if err != nil {
-		panic(err)
-	}
-
-	treeImpl, err := state.NewStateTree(cst)
-	if err != nil {
-		panic(err) // Never returns error, the error return should be removed.
-	}
-	root, err := treeImpl.Flush()
-	if err != nil {
-		panic(err)
-	}
-	storageImpl := &directStorage{cst}
-	return &StateWrapper{bs, cst, newKeyStore(), root, storageImpl}
-}
-
-func (s *StateWrapper) Cid() cid.Cid {
-	return s.stateRoot
-}
-
-func (s *StateWrapper) Actor(addr vaddress.Address) (vstate.Actor, error) {
-	vaddr, err := address.NewFromBytes(addr.Bytes())
-	if err != nil {
-		return nil, err
-	}
-	tree, err := state.LoadStateTree(s.cst, s.stateRoot)
-	if err != nil {
-		return nil, err
-	}
-	fcActor, err := tree.GetActor(vaddr)
-	if err != nil {
-		return nil, err
-	}
-	return &actorWrapper{*fcActor}, nil
-}
-
-func (s *StateWrapper) Storage(addr vaddress.Address) (vstate.Storage, error) {
-	return s.storage, nil
-}
-
-func (s *StateWrapper) NewAccountAddress() (vaddress.Address, error) {
-	return s.keys.NewAddress()
-}
-
-func (s *StateWrapper) SetActor(addr vaddress.Address, code vactors.ActorCodeID, balance vtypes.BigInt) (vstate.Actor, vstate.Storage, error) {
-	addrInt, err := address.NewFromBytes(addr.Bytes())
-	if err != nil {
-		return nil, nil, err
-	}
-	tree, err := state.LoadStateTree(s.cst, s.stateRoot)
-	if err != nil {
-		return nil, nil, err
-	}
-	actr := &actorWrapper{types.Actor{
-		Code:    fromActorCode(code),
-		Balance: types.BigInt{balance.Int},
-		Head:    vm.EmptyObjectCid,
-	}}
-	// The ID-based address is dropped here, but should be reported back to the caller.
-	_, err = tree.RegisterNewAddress(addrInt, &actr.Actor)
-	if err != nil {
-		return nil, nil, xerrors.Errorf("register new address for actor: %w", err)
-	}
-	return actr, s.storage, s.flush(tree)
-}
-
-func (s *StateWrapper) SetSingletonActor(addr vactors.SingletonActorID, balance vtypes.BigInt) (vstate.Actor, vstate.Storage, error) {
-	vaddr := fromSingletonAddress(addr)
-
-	tree, err := state.LoadStateTree(s.cst, s.stateRoot)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	lotusAddr, err := address.NewFromBytes(vaddr.Bytes())
-	if err != nil {
-		return nil, nil, err
-	}
-
-	switch lotusAddr {
-	case actors.InitAddress:
-		initact, err := gen.SetupInitActor(s.bs, nil)
-		if err != nil {
-			return nil, nil, err
-		}
-		if err := tree.SetActor(actors.InitAddress, initact); err != nil {
-			return nil, nil, xerrors.Errorf("set init actor: %w", err)
-		}
-
-		return &actorWrapper{*initact}, s.storage, s.flush(tree)
-	case actors.StorageMarketAddress:
-		nsroot, err := gen.SetupStorageMarketActor(s.bs, s.stateRoot, nil)
-		if err != nil {
-			return nil, nil, err
-		}
-		s.stateRoot = nsroot
-
-		tree, err = state.LoadStateTree(s.cst, s.stateRoot)
-		if err != nil {
-			return nil, nil, err
-		}
-		smact, err := tree.GetActor(actors.StorageMarketAddress)
-		if err != nil {
-			return nil, nil, err
-		}
-		return &actorWrapper{*smact}, s.storage, s.flush(tree)
-	case actors.StoragePowerAddress:
-		spact, err := gen.SetupStoragePowerActor(s.bs)
-		if err != nil {
-			return nil, nil, err
-		}
-		if err := tree.SetActor(actors.StoragePowerAddress, spact); err != nil {
-			return nil, nil, xerrors.Errorf("set network storage market actor: %w", err)
-		}
-		return &actorWrapper{*spact}, s.storage, s.flush(tree)
-	case actors.NetworkAddress:
-		ntwkact := &types.Actor{
-			Code:    actors.AccountCodeCid,
-			Balance: types.BigInt{balance.Int},
-			Head:    vm.EmptyObjectCid,
-		}
-		if err := tree.SetActor(actors.NetworkAddress, ntwkact); err != nil {
-			return nil, nil, xerrors.Errorf("set network actor: %w", err)
-		}
-		return &actorWrapper{*ntwkact}, s.storage, s.flush(tree)
-	case actors.BurntFundsAddress:
-		ntwkact := &types.Actor{
-			Code:    actors.AccountCodeCid,
-			Balance: types.BigInt{balance.Int},
-			Head:    vm.EmptyObjectCid,
-		}
-		if err := tree.SetActor(actors.BurntFundsAddress, ntwkact); err != nil {
-			return nil, nil, xerrors.Errorf("set network actor: %w", err)
-		}
-		return &actorWrapper{*ntwkact}, s.storage, s.flush(tree)
-	default:
-		return nil, nil, xerrors.Errorf("%v is not a singleton actor address", addr)
-	}
-}
-
-func (s *StateWrapper) Sign(ctx context.Context, addr vaddress.Address, data []byte) (*vtypes.Signature, error) {
-	sig, err := s.keys.Sign(ctx, addr, data)
-	if err != nil {
-		return nil, err
-	}
-	return &vtypes.Signature{
-		Type: sig.Type,
-		Data: sig.Data,
-	}, nil
-}
-
-func (s *StateWrapper) Signer() *keyStore {
-	return s.keys
-}
-
-// Flushes a state tree to storage and sets this state's root to that tree's root CID.
-func (s *StateWrapper) flush(tree *state.StateTree) (err error) {
-	s.stateRoot, err = tree.Flush()
-	return
-}
-
-//
-// Key store
-//
-type keyStore struct {
-	// Private keys by address
-	keys map[vaddress.Address]vtypes.KeyInfo
-	// Seed for deterministic key generation.
-	seed int64
-}
-
-func newKeyStore() *keyStore {
-	return &keyStore{
-		keys: make(map[vaddress.Address]vtypes.KeyInfo),
-		seed: 0,
-	}
-}
-
-func (s *keyStore) NewAddress() (vaddress.Address, error) {
-	randSrc := rand.New(rand.NewSource(s.seed))
-	prv, err := crypto.GenerateKeyFromSeed(randSrc)
-	if err != nil {
-		return vaddress.Undef, err
-	}
-
-	vki := vtypes.KeyInfo{
-		PrivateKey: prv,
-		Type:       types.KTSecp256k1,
-	}
-	key, err := wallet.NewKey(types.KeyInfo{
-		Type:       vki.Type,
-		PrivateKey: vki.PrivateKey,
-	})
-	if err != nil {
-		return vaddress.Undef, err
-	}
-	vaddr, err := vaddress.NewFromBytes(key.Address.Bytes())
-	if err != nil {
-		return vaddress.Undef, err
-	}
-	s.keys[vaddr] = vki
-	s.seed++
-	return vaddress.NewFromBytes(key.Address.Bytes())
-}
-
-func (s *keyStore) Sign(ctx context.Context, addr vaddress.Address, data []byte) (*types.Signature, error) {
-	ki, ok := s.keys[addr]
-	if !ok {
-		return &types.Signature{}, fmt.Errorf("unknown address %v", addr)
-	}
-	b2sum := blake2b.Sum256(data)
-	digest, err := crypto.Sign(ki.PrivateKey, b2sum[:])
-	if err != nil {
-		return &types.Signature{}, err
-	}
-	return &types.Signature{
-		Type: types.KTSecp256k1,
-		Data: digest,
-	}, nil
-}
-
-//
-// Actor Wrapper
-//
-
-type actorWrapper struct {
-	types.Actor
-}
-
-func (a *actorWrapper) Code() cid.Cid {
-	return a.Actor.Code
-}
-
-func (a *actorWrapper) Head() cid.Cid {
-	return a.Actor.Head
-}
-
-func (a *actorWrapper) Nonce() uint64 {
-	return a.Actor.Nonce
-}
-
-func (a *actorWrapper) Balance() vtypes.BigInt {
-	return vtypes.NewInt(a.Actor.Balance.Uint64())
-
-}
-
-//
-// Storage
-//
-
-type directStorage struct {
-	cst *hamt.CborIpldStore
-}
-
-func (d *directStorage) Get(c cid.Cid, out interface{}) error {
-	if err := d.cst.Get(context.TODO(), c, out.(cbg.CBORUnmarshaler)); err != nil {
-		return err
-	}
-	return nil
-}
-
-func fromActorCode(code vactors.ActorCodeID) cid.Cid {
-	switch code {
-	case vactors.AccountActorCodeCid:
-		return actors.AccountCodeCid
-	case vactors.StorageMinerCodeCid:
-		return actors.StorageMinerCodeCid
-	case vactors.MultisigActorCodeCid:
-		return actors.MultisigCodeCid
-	case vactors.PaymentChannelActorCodeCid:
-		return actors.PaymentChannelCodeCid
-	default:
-		panic(fmt.Errorf("unknown actor code: %v", code))
-	}
-}
-
-func fromSingletonAddress(addr vactors.SingletonActorID) vaddress.Address {
-	switch addr {
-	case vactors.InitAddress:
-		out, err := vaddress.NewFromBytes(actors.InitAddress.Bytes())
-		if err != nil {
-			panic(err)
-		}
-		return out
-	case vactors.NetworkAddress:
-		out, err := vaddress.NewFromBytes(actors.NetworkAddress.Bytes())
-		if err != nil {
-			panic(err)
-		}
-		return out
-	case vactors.StorageMarketAddress:
-		out, err := vaddress.NewFromBytes(actors.StorageMarketAddress.Bytes())
-		if err != nil {
-			panic(err)
-		}
-		return out
-	case vactors.BurntFundsAddress:
-		out, err := vaddress.NewFromBytes(actors.BurntFundsAddress.Bytes())
-		if err != nil {
-			panic(err)
-		}
-		return out
-	case vactors.StoragePowerAddress:
-		out, err := vaddress.NewFromBytes(actors.StoragePowerAddress.Bytes())
-		if err != nil {
-			panic(err)
-		}
-		return out
-	default:
-		panic(fmt.Errorf("unknown singleton actor address: %v", addr))
-	}
-}
diff --git a/chain/vectors/gen/main.go b/chain/vectors/gen/main.go
new file mode 100644
index 000000000..2b1c6f340
--- /dev/null
+++ b/chain/vectors/gen/main.go
@@ -0,0 +1,207 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"math/rand"
+	"os"
+
+	power0 "github.com/filecoin-project/specs-actors/actors/builtin/power"
+
+	"github.com/filecoin-project/go-address"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/big"
+	"github.com/filecoin-project/go-state-types/crypto"
+	"github.com/filecoin-project/lotus/chain/gen"
+	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/chain/types/mock"
+	"github.com/filecoin-project/lotus/chain/vectors"
+	"github.com/filecoin-project/lotus/chain/wallet"
+	verifreg0 "github.com/filecoin-project/specs-actors/actors/builtin/verifreg"
+
+	_ "github.com/filecoin-project/lotus/lib/sigs/bls"
+	_ "github.com/filecoin-project/lotus/lib/sigs/secp"
+)
+
+func init() {
+	verifreg0.MinVerifiedDealSize = big.NewInt(2048)
+	power0.ConsensusMinerMinPower = big.NewInt(2048)
+}
+
+func MakeHeaderVectors() []vectors.HeaderVector {
+	cg, err := gen.NewGenerator()
+	if err != nil {
+		panic(err)
+	}
+
+	var out []vectors.HeaderVector
+	for i := 0; i < 5; i++ {
+		nts, err := cg.NextTipSet()
+		if err != nil {
+			panic(err)
+		}
+
+		h := nts.TipSet.Blocks[0].Header
+		data, err := h.Serialize()
+		if err != nil {
+			panic(err)
+		}
+
+		out = append(out, vectors.HeaderVector{
+			Block:   h,
+			Cid:     h.Cid().String(),
+			CborHex: fmt.Sprintf("%x", data),
+		})
+	}
+	return out
+}
+
+func MakeMessageSigningVectors() []vectors.MessageSigningVector {
+	w, err := wallet.NewWallet(wallet.NewMemKeyStore())
+	if err != nil {
+		panic(err)
+	}
+
+	blsk, err := w.GenerateKey(crypto.SigTypeBLS)
+	if err != nil {
+		panic(err)
+	}
+	bki, err := w.Export(blsk)
+	if err != nil {
+		panic(err)
+	}
+
+	to, err := address.NewIDAddress(99999)
+	if err != nil {
+		panic(err)
+	}
+
+	bmsg := mock.MkMessage(blsk, to, 55, w)
+
+	blsmsv := vectors.MessageSigningVector{
+		Unsigned:    &bmsg.Message,
+		Cid:         bmsg.Message.Cid().String(),
+		CidHexBytes: fmt.Sprintf("%x", bmsg.Message.Cid().Bytes()),
+		PrivateKey:  bki.PrivateKey,
+		Signature:   &bmsg.Signature,
+	}
+
+	secpk, err := w.GenerateKey(crypto.SigTypeBLS)
+	if err != nil {
+		panic(err)
+	}
+	ski, err := w.Export(secpk)
+	if err != nil {
+		panic(err)
+	}
+
+	smsg := mock.MkMessage(secpk, to, 55, w)
+
+	smsv := vectors.MessageSigningVector{
+		Unsigned:    &smsg.Message,
+		Cid:         smsg.Message.Cid().String(),
+		CidHexBytes: fmt.Sprintf("%x", smsg.Message.Cid().Bytes()),
+		PrivateKey:  ski.PrivateKey,
+		Signature:   &smsg.Signature,
+	}
+
+	return []vectors.MessageSigningVector{blsmsv, smsv}
+}
+
+func MakeUnsignedMessageVectors() []vectors.UnsignedMessageVector {
+	froms := []string{
+		"t2ch7krq7l35i74rebqbjdsp3ucl47t24e3juxjfa",
+		"t1pyfq7dg6sq65acyomqvzvbgwni4zllglqffw5dy",
+		"t1cyg66djxytxhzdq7ynoqfxk7xinp6xsejbeufli",
+		"t16n7vrq5humzoqll7zg4yw6dta645tuakcoalp6y",
+		"t1awsiuji4wpbxpzslg36f3wnfxzi4o5gq67tz2mi",
+		"t14mb3j32uuwajy5b2mliz63isp6zl5xkppzyuhfy",
+		"t1dzdmyzzdy6q5elobj63eokzv2xnwsp4vm5l6aka",
+		"t1svd45rkcfpsyqedvvhuv77yvllvu5ygmygjlvka",
+		"t1mrret5liwh46qde6qhaxrmcwil7jawjeqdijwfq",
+		"t1ly3ynedw74p4q3ytdnb4stjdkiodrl54moeyxea",
+		"t1uqexvn66gj4lxkbvmrgposwrlxbyd655o2nayyi",
+		"t1dwwjod7vw62jzw2eva7gtxohaidjhgh6w2rofui",
+		"t1slswisymmkfulmvl3jynrnwqi27tkvmsgzhztvy",
+		"t1e3vymxcdqfkqwz6e6wnxxx6ayuml3vxi5gef4xa",
+		"t1bgqopgk64ywpprka4citgi62aldclyaegvwvx6y",
+		"t1aizqgl2klzkzffwu35rufyuzefke2i6ndbewuhi",
+		"t1mzposcnsd2tc66yu5i3kajtrh5pvwohdjvitcey",
+		"t1x7xvs6oorrrlefyzn6wlbvaibzj3a2fyt4hsmvq",
+		"t1ez743nvc4j7qfirwnmxbh4qdqwha3iyalnq4rya",
+		"t17dvtgkop7cqgi6myjne5kzvrnsbg5wnowjphhwy",
+		"t1kvar5z3q7dwrfxjqsnuqpq5qsd7mvh2xypblwta",
+	}
+	var out []vectors.UnsignedMessageVector
+	for _, a := range froms {
+		from, err := address.NewFromString(a)
+		if err != nil {
+			panic(err)
+		}
+		uint63mask := uint64(1<<63 - 1)
+		to, err := address.NewIDAddress(rand.Uint64() & uint63mask)
+		if err != nil {
+			panic(err)
+		}
+
+		params := make([]byte, 32)
+		rand.Read(params)
+
+		msg := &types.Message{
+			To:         to,
+			From:       from,
+			Value:      types.NewInt(rand.Uint64()),
+			Method:     abi.MethodNum(rand.Uint64()),
+			GasFeeCap:  types.NewInt(rand.Uint64()),
+			GasPremium: types.NewInt(rand.Uint64()),
+			GasLimit:   rand.Int63(),
+			Nonce:      rand.Uint64() & (1<<63 - 1),
+			Params:     params,
+		}
+
+		ser, err := msg.Serialize()
+		if err != nil {
+			panic(err)
+		}
+
+		out = append(out, vectors.UnsignedMessageVector{
+			Message: msg,
+			HexCbor: fmt.Sprintf("%x", ser),
+		})
+	}
+	return out
+}
+
+func WriteJsonToFile(fname string, obj interface{}) error {
+	fi, err := os.Create(fname)
+	if err != nil {
+		return err
+	}
+	defer fi.Close() //nolint:errcheck
+
+	out, err := json.MarshalIndent(obj, "", "  ")
+	if err != nil {
+		return err
+	}
+
+	_, err = fi.Write(out)
+	if err != nil {
+		return xerrors.Errorf("writing json: %w", err)
+	}
+
+	return nil
+}
+
+func main() {
+	if err := WriteJsonToFile("block_headers.json", MakeHeaderVectors()); err != nil {
+		panic(err)
+	}
+	if err := WriteJsonToFile("message_signing.json", MakeMessageSigningVectors()); err != nil {
+		panic(err)
+	}
+	if err := WriteJsonToFile("unsigned_messages.json", MakeUnsignedMessageVectors()); err != nil {
+		panic(err)
+	}
+}
diff --git a/chain/vectors/vector_types.go b/chain/vectors/vector_types.go
new file mode 100644
index 000000000..7e014fb77
--- /dev/null
+++ b/chain/vectors/vector_types.go
@@ -0,0 +1,25 @@
+package vectors
+
+import (
+	"github.com/filecoin-project/go-state-types/crypto"
+	"github.com/filecoin-project/lotus/chain/types"
+)
+
+type HeaderVector struct {
+	Block   *types.BlockHeader `json:"block"`
+	CborHex string             `json:"cbor_hex"`
+	Cid     string             `json:"cid"`
+}
+
+type MessageSigningVector struct {
+	Unsigned    *types.Message
+	Cid         string
+	CidHexBytes string
+	PrivateKey  []byte
+	Signature   *crypto.Signature
+}
+
+type UnsignedMessageVector struct {
+	Message *types.Message `json:"message"`
+	HexCbor string         `json:"hex_cbor"`
+}
diff --git a/chain/vectors/vectors_test.go b/chain/vectors/vectors_test.go
new file mode 100644
index 000000000..68cc5ac45
--- /dev/null
+++ b/chain/vectors/vectors_test.go
@@ -0,0 +1,88 @@
+package vectors
+
+import (
+	"bytes"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/filecoin-project/lotus/chain/types"
+)
+
+func LoadVector(t *testing.T, f string, out interface{}) {
+	p := filepath.Join("../../extern/serialization-vectors", f)
+	fi, err := os.Open(p)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer fi.Close() //nolint:errcheck
+
+	if err := json.NewDecoder(fi).Decode(out); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestBlockHeaderVectors(t *testing.T) {
+	t.Skip("we need to regenerate for beacon")
+	var headers []HeaderVector
+	LoadVector(t, "block_headers.json", &headers)
+
+	for i, hv := range headers {
+		if hv.Block.Cid().String() != hv.Cid {
+			t.Fatalf("CID mismatch in test vector %d", i)
+		}
+
+		data, err := hv.Block.Serialize()
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		if fmt.Sprintf("%x", data) != hv.CborHex {
+			t.Fatalf("serialized data mismatched for test vector %d", i)
+		}
+	}
+}
+
+func TestMessageSigningVectors(t *testing.T) {
+	var msvs []MessageSigningVector
+	LoadVector(t, "message_signing.json", &msvs)
+
+	for i, msv := range msvs {
+		smsg := &types.SignedMessage{
+			Message:   *msv.Unsigned,
+			Signature: *msv.Signature,
+		}
+
+		if smsg.Cid().String() != msv.Cid {
+			t.Fatalf("cid of message in vector %d mismatches", i)
+		}
+
+		// TODO: check signature
+	}
+}
+
+func TestUnsignedMessageVectors(t *testing.T) {
+	t.Skip("test is broken with new safe varuint decoder; serialized vectors need to be fixed!")
+
+	var msvs []UnsignedMessageVector
+	LoadVector(t, "unsigned_messages.json", &msvs)
+
+	for i, msv := range msvs {
+		b, err := msv.Message.Serialize()
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		dec, err := hex.DecodeString(msv.HexCbor)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		if !bytes.Equal(b, dec) {
+			t.Fatalf("serialization vector %d mismatches bytes", i)
+		}
+	}
+}
diff --git a/chain/vm/burn.go b/chain/vm/burn.go
new file mode 100644
index 000000000..9f9b95755
--- /dev/null
+++ b/chain/vm/burn.go
@@ -0,0 +1,102 @@
+package vm
+
+import (
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/big"
+)
+
+const (
+	gasOveruseNum   = 11
+	gasOveruseDenom = 10
+)
+
+type GasOutputs struct {
+	BaseFeeBurn        abi.TokenAmount
+	OverEstimationBurn abi.TokenAmount
+
+	MinerPenalty abi.TokenAmount
+	MinerTip     abi.TokenAmount
+	Refund       abi.TokenAmount
+
+	GasRefund int64
+	GasBurned int64
+}
+
+// ZeroGasOutputs returns a logically zeroed GasOutputs.
+func ZeroGasOutputs() GasOutputs {
+	return GasOutputs{
+		BaseFeeBurn:        big.Zero(),
+		OverEstimationBurn: big.Zero(),
+		MinerPenalty:       big.Zero(),
+		MinerTip:           big.Zero(),
+		Refund:             big.Zero(),
+	}
+}
+
+// ComputeGasOverestimationBurn computes amount of gas to be refunded and amount of gas to be burned
+// Result is (refund, burn)
+func ComputeGasOverestimationBurn(gasUsed, gasLimit int64) (int64, int64) {
+	if gasUsed == 0 {
+		return 0, gasLimit
+	}
+
+	// over = gasLimit/gasUsed - 1 - 0.1
+	// over = min(over, 1)
+	// gasToBurn = (gasLimit - gasUsed) * over
+
+	// so to factor out division from `over`
+	// over*gasUsed = min(gasLimit - (11*gasUsed)/10, gasUsed)
+	// gasToBurn = ((gasLimit - gasUsed)*over*gasUsed) / gasUsed
+	over := gasLimit - (gasOveruseNum*gasUsed)/gasOveruseDenom
+	if over < 0 {
+		return gasLimit - gasUsed, 0
+	}
+
+	// if we want sharper scaling it goes here:
+	// over *= 2
+
+	if over > gasUsed {
+		over = gasUsed
+	}
+
+	// needs bigint, as it overflows in pathological case gasLimit > 2^32 gasUsed = gasLimit / 2
+	gasToBurn := big.NewInt(gasLimit - gasUsed)
+	gasToBurn = big.Mul(gasToBurn, big.NewInt(over))
+	gasToBurn = big.Div(gasToBurn, big.NewInt(gasUsed))
+
+	return gasLimit - gasUsed - gasToBurn.Int64(), gasToBurn.Int64()
+}
+
+func ComputeGasOutputs(gasUsed, gasLimit int64, baseFee, feeCap, gasPremium abi.TokenAmount) GasOutputs {
+	gasUsedBig := big.NewInt(gasUsed)
+	out := ZeroGasOutputs()
+
+	baseFeeToPay := baseFee
+	if baseFee.Cmp(feeCap.Int) > 0 {
+		baseFeeToPay = feeCap
+		out.MinerPenalty = big.Mul(big.Sub(baseFee, feeCap), gasUsedBig)
+	}
+	out.BaseFeeBurn = big.Mul(baseFeeToPay, gasUsedBig)
+
+	minerTip := gasPremium
+	if big.Cmp(big.Add(baseFeeToPay, minerTip), feeCap) > 0 {
+		minerTip = big.Sub(feeCap, baseFeeToPay)
+	}
+	out.MinerTip = big.Mul(minerTip, big.NewInt(gasLimit))
+
+	out.GasRefund, out.GasBurned = ComputeGasOverestimationBurn(gasUsed, gasLimit)
+
+	if out.GasBurned != 0 {
+		gasBurnedBig := big.NewInt(out.GasBurned)
+		out.OverEstimationBurn = big.Mul(baseFeeToPay, gasBurnedBig)
+		minerPenalty := big.Mul(big.Sub(baseFee, baseFeeToPay), gasBurnedBig)
+		out.MinerPenalty = big.Add(out.MinerPenalty, minerPenalty)
+	}
+
+	requiredFunds := big.Mul(big.NewInt(gasLimit), feeCap)
+	refund := big.Sub(requiredFunds, out.BaseFeeBurn)
+	refund = big.Sub(refund, out.MinerTip)
+	refund = big.Sub(refund, out.OverEstimationBurn)
+	out.Refund = refund
+	return out
+}
diff --git a/chain/vm/burn_test.go b/chain/vm/burn_test.go
new file mode 100644
index 000000000..58e133605
--- /dev/null
+++ b/chain/vm/burn_test.go
@@ -0,0 +1,78 @@
+package vm
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestGasBurn(t *testing.T) {
+	tests := []struct {
+		used   int64
+		limit  int64
+		refund int64
+		burn   int64
+	}{
+		{100, 200, 10, 90},
+		{100, 150, 30, 20},
+		{1000, 1300, 240, 60},
+		{500, 700, 140, 60},
+		{200, 200, 0, 0},
+		{20000, 21000, 1000, 0},
+		{0, 2000, 0, 2000},
+		{500, 651, 121, 30},
+		{500, 5000, 0, 4500},
+		{7499e6, 7500e6, 1000000, 0},
+		{7500e6 / 2, 7500e6, 375000000, 3375000000},
+		{1, 7500e6, 0, 7499999999},
+	}
+
+	for _, test := range tests {
+		test := test
+		t.Run(fmt.Sprintf("%v", test), func(t *testing.T) {
+			refund, toBurn := ComputeGasOverestimationBurn(test.used, test.limit)
+			assert.Equal(t, test.refund, refund, "refund")
+			assert.Equal(t, test.burn, toBurn, "burned")
+		})
+	}
+}
+
+func TestGasOutputs(t *testing.T) {
+	baseFee := types.NewInt(10)
+	tests := []struct {
+		used  int64
+		limit int64
+
+		feeCap  uint64
+		premium uint64
+
+		BaseFeeBurn        uint64
+		OverEstimationBurn uint64
+		MinerPenalty       uint64
+		MinerTip           uint64
+		Refund             uint64
+	}{
+		{100, 110, 11, 1, 1000, 0, 0, 110, 100},
+		{100, 130, 11, 1, 1000, 60, 0, 130, 240},
+		{100, 110, 10, 1, 1000, 0, 0, 0, 100},
+		{100, 110, 6, 1, 600, 0, 400, 0, 60},
+	}
+
+	for _, test := range tests {
+		test := test
+		t.Run(fmt.Sprintf("%v", test), func(t *testing.T) {
+			output := ComputeGasOutputs(test.used, test.limit, baseFee, types.NewInt(test.feeCap), types.NewInt(test.premium))
+			i2s := func(i uint64) string {
+				return fmt.Sprintf("%d", i)
+			}
+			assert.Equal(t, i2s(test.BaseFeeBurn), output.BaseFeeBurn.String(), "BaseFeeBurn")
+			assert.Equal(t, i2s(test.OverEstimationBurn), output.OverEstimationBurn.String(), "OverEstimationBurn")
+			assert.Equal(t, i2s(test.MinerPenalty), output.MinerPenalty.String(), "MinerPenalty")
+			assert.Equal(t, i2s(test.MinerTip), output.MinerTip.String(), "MinerTip")
+			assert.Equal(t, i2s(test.Refund), output.Refund.String(), "Refund")
+		})
+	}
+
+}
diff --git a/chain/vm/gas.go b/chain/vm/gas.go
new file mode 100644
index 000000000..12acf6a21
--- /dev/null
+++ b/chain/vm/gas.go
@@ -0,0 +1,232 @@
+package vm
+
+import (
+	"fmt"
+
+	"github.com/filecoin-project/specs-actors/actors/runtime/proof"
+
+	"github.com/filecoin-project/go-address"
+	addr "github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/crypto"
+	"github.com/filecoin-project/specs-actors/actors/runtime"
+	vmr "github.com/filecoin-project/specs-actors/actors/runtime"
+	"github.com/ipfs/go-cid"
+)
+
+const (
+	GasStorageMulti = 1000
+	GasComputeMulti = 1
+)
+
+type GasCharge struct {
+	Name  string
+	Extra interface{}
+
+	ComputeGas int64
+	StorageGas int64
+
+	VirtualCompute int64
+	VirtualStorage int64
+}
+
+func (g GasCharge) Total() int64 {
+	return g.ComputeGas*GasComputeMulti + g.StorageGas*GasStorageMulti
+}
+func (g GasCharge) WithVirtual(compute, storage int64) GasCharge {
+	out := g
+	out.VirtualCompute = compute
+	out.VirtualStorage = storage
+	return out
+}
+
+func (g GasCharge) WithExtra(extra interface{}) GasCharge {
+	out := g
+	out.Extra = extra
+	return out
+}
+
+func newGasCharge(name string, computeGas int64, storageGas int64) GasCharge {
+	return GasCharge{
+		Name:       name,
+		ComputeGas: computeGas,
+		StorageGas: storageGas,
+	}
+}
+
+// Pricelist provides prices for operations in the VM.
+//
+// Note: this interface should be APPEND ONLY since last chain checkpoint
+type Pricelist interface {
+	// OnChainMessage returns the gas used for storing a message of a given size in the chain.
+	OnChainMessage(msgSize int) GasCharge
+	// OnChainReturnValue returns the gas used for storing the response of a message in the chain.
+	OnChainReturnValue(dataSize int) GasCharge
+
+	// OnMethodInvocation returns the gas used when invoking a method.
+	OnMethodInvocation(value abi.TokenAmount, methodNum abi.MethodNum) GasCharge
+
+	// OnIpldGet returns the gas used for storing an object
+	OnIpldGet() GasCharge
+	// OnIpldPut returns the gas used for storing an object
+	OnIpldPut(dataSize int) GasCharge
+
+	// OnCreateActor returns the gas used for creating an actor
+	OnCreateActor() GasCharge
+	// OnDeleteActor returns the gas used for deleting an actor
+	OnDeleteActor() GasCharge
+
+	OnVerifySignature(sigType crypto.SigType, planTextSize int) (GasCharge, error)
+	OnHashing(dataSize int) GasCharge
+	OnComputeUnsealedSectorCid(proofType abi.RegisteredSealProof, pieces []abi.PieceInfo) GasCharge
+	OnVerifySeal(info proof.SealVerifyInfo) GasCharge
+	OnVerifyPost(info proof.WindowPoStVerifyInfo) GasCharge
+	OnVerifyConsensusFault() GasCharge
+}
+
+var prices = map[abi.ChainEpoch]Pricelist{
+	abi.ChainEpoch(0): &pricelistV0{
+		onChainMessageComputeBase:    38863,
+		onChainMessageStorageBase:    36,
+		onChainMessageStoragePerByte: 1,
+
+		onChainReturnValuePerByte: 1,
+
+		sendBase:                29233,
+		sendTransferFunds:       27500,
+		sendTransferOnlyPremium: 159672,
+		sendInvokeMethod:        -5377,
+
+		ipldGetBase:    75242,
+		ipldPutBase:    84070,
+		ipldPutPerByte: 1,
+
+		createActorCompute: 1108454,
+		createActorStorage: 36 + 40,
+		deleteActor:        -(36 + 40), // -createActorStorage
+
+		verifySignature: map[crypto.SigType]int64{
+			crypto.SigTypeBLS:       16598605,
+			crypto.SigTypeSecp256k1: 1637292,
+		},
+
+		hashingBase:                  31355,
+		computeUnsealedSectorCidBase: 98647,
+		verifySealBase:               2000, // TODO gas , it VerifySeal syscall is not used
+		verifyPostLookup: map[abi.RegisteredPoStProof]scalingCost{
+			abi.RegisteredPoStProof_StackedDrgWindow512MiBV1: {
+				flat:  123861062,
+				scale: 9226981,
+			},
+			abi.RegisteredPoStProof_StackedDrgWindow32GiBV1: {
+				flat:  748593537,
+				scale: 85639,
+			},
+			abi.RegisteredPoStProof_StackedDrgWindow64GiBV1: {
+				flat:  748593537,
+				scale: 85639,
+			},
+		},
+		verifyConsensusFault: 495422,
+	},
+}
+
+// PricelistByEpoch finds the latest prices for the given epoch
+func PricelistByEpoch(epoch abi.ChainEpoch) Pricelist {
+	// since we are storing the prices as map or epoch to price
+	// we need to get the price with the highest epoch that is lower or equal to the `epoch` arg
+	bestEpoch := abi.ChainEpoch(0)
+	bestPrice := prices[bestEpoch]
+	for e, pl := range prices {
+		// if `e` happened after `bestEpoch` and `e` is earlier or equal to the target `epoch`
+		if e > bestEpoch && e <= epoch {
+			bestEpoch = e
+			bestPrice = pl
+		}
+	}
+	if bestPrice == nil {
+		panic(fmt.Sprintf("bad setup: no gas prices available for epoch %d", epoch))
+	}
+	return bestPrice
+}
+
+type pricedSyscalls struct {
+	under     vmr.Syscalls
+	pl        Pricelist
+	chargeGas func(GasCharge)
+}
+
+// Verifies that a signature is valid for an address and plaintext.
+func (ps pricedSyscalls) VerifySignature(signature crypto.Signature, signer addr.Address, plaintext []byte) error {
+	c, err := ps.pl.OnVerifySignature(signature.Type, len(plaintext))
+	if err != nil {
+		return err
+	}
+	ps.chargeGas(c)
+	defer ps.chargeGas(gasOnActorExec)
+
+	return ps.under.VerifySignature(signature, signer, plaintext)
+}
+
+// Hashes input data using blake2b with 256 bit output.
+func (ps pricedSyscalls) HashBlake2b(data []byte) [32]byte {
+	ps.chargeGas(ps.pl.OnHashing(len(data)))
+	defer ps.chargeGas(gasOnActorExec)
+
+	return ps.under.HashBlake2b(data)
+}
+
+// Computes an unsealed sector CID (CommD) from its constituent piece CIDs (CommPs) and sizes.
+func (ps pricedSyscalls) ComputeUnsealedSectorCID(reg abi.RegisteredSealProof, pieces []abi.PieceInfo) (cid.Cid, error) {
+	ps.chargeGas(ps.pl.OnComputeUnsealedSectorCid(reg, pieces))
+	defer ps.chargeGas(gasOnActorExec)
+
+	return ps.under.ComputeUnsealedSectorCID(reg, pieces)
+}
+
+// Verifies a sector seal proof.
+func (ps pricedSyscalls) VerifySeal(vi proof.SealVerifyInfo) error {
+	ps.chargeGas(ps.pl.OnVerifySeal(vi))
+	defer ps.chargeGas(gasOnActorExec)
+
+	return ps.under.VerifySeal(vi)
+}
+
+// Verifies a proof of spacetime.
+func (ps pricedSyscalls) VerifyPoSt(vi proof.WindowPoStVerifyInfo) error {
+	ps.chargeGas(ps.pl.OnVerifyPost(vi))
+	defer ps.chargeGas(gasOnActorExec)
+
+	return ps.under.VerifyPoSt(vi)
+}
+
+// Verifies that two block headers provide proof of a consensus fault:
+// - both headers mined by the same actor
+// - headers are different
+// - first header is of the same or lower epoch as the second
+// - at least one of the headers appears in the current chain at or after epoch `earliest`
+// - the headers provide evidence of a fault (see the spec for the different fault types).
+// The parameters are all serialized block headers. The third "extra" parameter is consulted only for
+// the "parent grinding fault", in which case it must be the sibling of h1 (same parent tipset) and one of the
+// blocks in the parent of h2 (i.e. h2's grandparent).
+// Returns nil and an error if the headers don't prove a fault.
+func (ps pricedSyscalls) VerifyConsensusFault(h1 []byte, h2 []byte, extra []byte) (*runtime.ConsensusFault, error) {
+	ps.chargeGas(ps.pl.OnVerifyConsensusFault())
+	defer ps.chargeGas(gasOnActorExec)
+
+	return ps.under.VerifyConsensusFault(h1, h2, extra)
+}
+
+func (ps pricedSyscalls) BatchVerifySeals(inp map[address.Address][]proof.SealVerifyInfo) (map[address.Address][]bool, error) {
+	count := int64(0)
+	for _, svis := range inp {
+		count += int64(len(svis))
+	}
+
+	gasChargeSum := newGasCharge("BatchVerifySeals", 0, 0)
+	gasChargeSum = gasChargeSum.WithExtra(count).WithVirtual(15075005*count+899741502, 0)
+	ps.chargeGas(gasChargeSum) // real gas charged by actors
+	defer ps.chargeGas(gasOnActorExec)
+
+	return ps.under.BatchVerifySeals(inp)
+}
diff --git a/chain/vm/gas_v0.go b/chain/vm/gas_v0.go
new file mode 100644
index 000000000..e5ded440e
--- /dev/null
+++ b/chain/vm/gas_v0.go
@@ -0,0 +1,215 @@
+package vm
+
+import (
+	"fmt"
+
+	"github.com/filecoin-project/specs-actors/actors/runtime/proof"
+
+	"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/specs-actors/actors/builtin"
+)
+
+type scalingCost struct {
+	flat  int64
+	scale int64
+}
+
+type pricelistV0 struct {
+	///////////////////////////////////////////////////////////////////////////
+	// System operations
+	///////////////////////////////////////////////////////////////////////////
+
+	// Gas cost charged to the originator of an on-chain message (regardless of
+	// whether it succeeds or fails in application) is given by:
+	//   OnChainMessageBase + len(serialized message)*OnChainMessagePerByte
+	// Together, these account for the cost of message propagation and validation,
+	// up to but excluding any actual processing by the VM.
+	// This is the cost a block producer burns when including an invalid message.
+	onChainMessageComputeBase    int64
+	onChainMessageStorageBase    int64
+	onChainMessageStoragePerByte int64
+
+	// Gas cost charged to the originator of a non-nil return value produced
+	// by an on-chain message is given by:
+	//   len(return value)*OnChainReturnValuePerByte
+	onChainReturnValuePerByte int64
+
+	// Gas cost for any message send execution(including the top-level one
+	// initiated by an on-chain message).
+	// This accounts for the cost of loading sender and receiver actors and
+	// (for top-level messages) incrementing the sender's sequence number.
+	// Load and store of actor sub-state is charged separately.
+	sendBase int64
+
+	// Gas cost charged, in addition to SendBase, if a message send
+	// is accompanied by any nonzero currency amount.
+	// Accounts for writing receiver's new balance (the sender's state is
+	// already accounted for).
+	sendTransferFunds int64
+
+	// Gsa cost charged, in addition to SendBase, if message only transfers funds.
+	sendTransferOnlyPremium int64
+
+	// Gas cost charged, in addition to SendBase, if a message invokes
+	// a method on the receiver.
+	// Accounts for the cost of loading receiver code and method dispatch.
+	sendInvokeMethod int64
+
+	// Gas cost for any Get operation to the IPLD store
+	// in the runtime VM context.
+	ipldGetBase int64
+
+	// Gas cost (Base + len*PerByte) for any Put operation to the IPLD store
+	// in the runtime VM context.
+	//
+	// Note: these costs should be significantly higher than the costs for Get
+	// operations, since they reflect not only serialization/deserialization
+	// but also persistent storage of chain data.
+	ipldPutBase    int64
+	ipldPutPerByte int64
+
+	// Gas cost for creating a new actor (via InitActor's Exec method).
+	//
+	// Note: this costs assume that the extra will be partially or totally refunded while
+	// the base is covering for the put.
+	createActorCompute int64
+	createActorStorage int64
+
+	// Gas cost for deleting an actor.
+	//
+	// Note: this partially refunds the create cost to incentivise the deletion of the actors.
+	deleteActor int64
+
+	verifySignature map[crypto.SigType]int64
+
+	hashingBase int64
+
+	computeUnsealedSectorCidBase int64
+	verifySealBase               int64
+	verifyPostLookup             map[abi.RegisteredPoStProof]scalingCost
+	verifyConsensusFault         int64
+}
+
+var _ Pricelist = (*pricelistV0)(nil)
+
+// OnChainMessage returns the gas used for storing a message of a given size in the chain.
+func (pl *pricelistV0) OnChainMessage(msgSize int) GasCharge {
+	return newGasCharge("OnChainMessage", pl.onChainMessageComputeBase,
+		pl.onChainMessageStorageBase+pl.onChainMessageStoragePerByte*int64(msgSize))
+}
+
+// OnChainReturnValue returns the gas used for storing the response of a message in the chain.
+func (pl *pricelistV0) OnChainReturnValue(dataSize int) GasCharge {
+	return newGasCharge("OnChainReturnValue", 0, int64(dataSize)*pl.onChainReturnValuePerByte)
+}
+
+// OnMethodInvocation returns the gas used when invoking a method.
+func (pl *pricelistV0) OnMethodInvocation(value abi.TokenAmount, methodNum abi.MethodNum) GasCharge {
+	ret := pl.sendBase
+	extra := ""
+
+	if big.Cmp(value, abi.NewTokenAmount(0)) != 0 {
+		ret += pl.sendTransferFunds
+		if methodNum == builtin.MethodSend {
+			// transfer only
+			ret += pl.sendTransferOnlyPremium
+		}
+		extra += "t"
+	}
+
+	if methodNum != builtin.MethodSend {
+		extra += "i"
+		// running actors is cheaper becase we hand over to actors
+		ret += pl.sendInvokeMethod
+	}
+	return newGasCharge("OnMethodInvocation", ret, 0).WithExtra(extra)
+}
+
+// OnIpldGet returns the gas used for storing an object
+func (pl *pricelistV0) OnIpldGet() GasCharge {
+	return newGasCharge("OnIpldGet", pl.ipldGetBase, 0)
+}
+
+// OnIpldPut returns the gas used for storing an object
+func (pl *pricelistV0) OnIpldPut(dataSize int) GasCharge {
+	return newGasCharge("OnIpldPut", pl.ipldPutBase, int64(dataSize)*pl.ipldPutPerByte).
+		WithExtra(dataSize)
+}
+
+// OnCreateActor returns the gas used for creating an actor
+func (pl *pricelistV0) OnCreateActor() GasCharge {
+	return newGasCharge("OnCreateActor", pl.createActorCompute, pl.createActorStorage)
+}
+
+// OnDeleteActor returns the gas used for deleting an actor
+func (pl *pricelistV0) OnDeleteActor() GasCharge {
+	return newGasCharge("OnDeleteActor", 0, pl.deleteActor)
+}
+
+// OnVerifySignature
+
+func (pl *pricelistV0) OnVerifySignature(sigType crypto.SigType, planTextSize int) (GasCharge, error) {
+	cost, ok := pl.verifySignature[sigType]
+	if !ok {
+		return GasCharge{}, fmt.Errorf("cost function for signature type %d not supported", sigType)
+	}
+
+	sigName, _ := sigType.Name()
+	return newGasCharge("OnVerifySignature", cost, 0).
+		WithExtra(map[string]interface{}{
+			"type": sigName,
+			"size": planTextSize,
+		}), nil
+}
+
+// OnHashing
+func (pl *pricelistV0) OnHashing(dataSize int) GasCharge {
+	return newGasCharge("OnHashing", pl.hashingBase, 0).WithExtra(dataSize)
+}
+
+// OnComputeUnsealedSectorCid
+func (pl *pricelistV0) OnComputeUnsealedSectorCid(proofType abi.RegisteredSealProof, pieces []abi.PieceInfo) GasCharge {
+	return newGasCharge("OnComputeUnsealedSectorCid", pl.computeUnsealedSectorCidBase, 0)
+}
+
+// OnVerifySeal
+func (pl *pricelistV0) OnVerifySeal(info proof.SealVerifyInfo) GasCharge {
+	// TODO: this needs more cost tunning, check with @lotus
+	// this is not used
+	return newGasCharge("OnVerifySeal", pl.verifySealBase, 0)
+}
+
+// OnVerifyPost
+func (pl *pricelistV0) OnVerifyPost(info proof.WindowPoStVerifyInfo) GasCharge {
+	sectorSize := "unknown"
+	var proofType abi.RegisteredPoStProof
+
+	if len(info.Proofs) != 0 {
+		proofType = info.Proofs[0].PoStProof
+		ss, err := info.Proofs[0].PoStProof.SectorSize()
+		if err == nil {
+			sectorSize = ss.ShortString()
+		}
+	}
+
+	cost, ok := pl.verifyPostLookup[proofType]
+	if !ok {
+		cost = pl.verifyPostLookup[abi.RegisteredPoStProof_StackedDrgWindow512MiBV1]
+	}
+
+	gasUsed := cost.flat + int64(len(info.ChallengedSectors))*cost.scale
+	gasUsed /= 2 // XXX: this is an artificial discount
+
+	return newGasCharge("OnVerifyPost", gasUsed, 0).
+		WithExtra(map[string]interface{}{
+			"type": sectorSize,
+			"size": len(info.ChallengedSectors),
+		})
+}
+
+// OnVerifyConsensusFault
+func (pl *pricelistV0) OnVerifyConsensusFault() GasCharge {
+	return newGasCharge("OnVerifyConsensusFault", pl.verifyConsensusFault, 0)
+}
diff --git a/chain/vm/invoker.go b/chain/vm/invoker.go
index 0a792dbd8..0a83e273d 100644
--- a/chain/vm/invoker.go
+++ b/chain/vm/invoker.go
@@ -10,59 +10,75 @@ import (
 	cbg "github.com/whyrusleeping/cbor-gen"
 	"golang.org/x/xerrors"
 
-	"github.com/filecoin-project/lotus/chain/actors"
+	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
+	account0 "github.com/filecoin-project/specs-actors/actors/builtin/account"
+	cron0 "github.com/filecoin-project/specs-actors/actors/builtin/cron"
+	init0 "github.com/filecoin-project/specs-actors/actors/builtin/init"
+	market0 "github.com/filecoin-project/specs-actors/actors/builtin/market"
+	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
+	msig0 "github.com/filecoin-project/specs-actors/actors/builtin/multisig"
+	paych0 "github.com/filecoin-project/specs-actors/actors/builtin/paych"
+	power0 "github.com/filecoin-project/specs-actors/actors/builtin/power"
+	reward0 "github.com/filecoin-project/specs-actors/actors/builtin/reward"
+	system0 "github.com/filecoin-project/specs-actors/actors/builtin/system"
+	verifreg0 "github.com/filecoin-project/specs-actors/actors/builtin/verifreg"
+	vmr "github.com/filecoin-project/specs-actors/actors/runtime"
+
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/exitcode"
+
 	"github.com/filecoin-project/lotus/chain/actors/aerrors"
-	"github.com/filecoin-project/lotus/chain/types"
 )
 
-type invoker struct {
+type Invoker struct {
 	builtInCode  map[cid.Cid]nativeCode
 	builtInState map[cid.Cid]reflect.Type
 }
 
-type invokeFunc func(act *types.Actor, vmctx types.VMContext, params []byte) ([]byte, aerrors.ActorError)
+type invokeFunc func(rt vmr.Runtime, params []byte) ([]byte, aerrors.ActorError)
 type nativeCode []invokeFunc
 
-func newInvoker() *invoker {
-	inv := &invoker{
+func NewInvoker() *Invoker {
+	inv := &Invoker{
 		builtInCode:  make(map[cid.Cid]nativeCode),
 		builtInState: make(map[cid.Cid]reflect.Type),
 	}
 
 	// add builtInCode using: register(cid, singleton)
-	inv.register(actors.InitCodeCid, actors.InitActor{}, actors.InitActorState{})
-	inv.register(actors.CronCodeCid, actors.CronActor{}, actors.CronActorState{})
-	inv.register(actors.StoragePowerCodeCid, actors.StoragePowerActor{}, actors.StoragePowerState{})
-	inv.register(actors.StorageMarketCodeCid, actors.StorageMarketActor{}, actors.StorageMarketState{})
-	inv.register(actors.StorageMinerCodeCid, actors.StorageMinerActor{}, actors.StorageMinerActorState{})
-	inv.register(actors.MultisigCodeCid, actors.MultiSigActor{}, actors.MultiSigActorState{})
-	inv.register(actors.PaymentChannelCodeCid, actors.PaymentChannelActor{}, actors.PaymentChannelActorState{})
+	// NETUPGRADE: register code IDs for v2, etc.
+	inv.Register(builtin0.SystemActorCodeID, system0.Actor{}, abi.EmptyValue{})
+	inv.Register(builtin0.InitActorCodeID, init0.Actor{}, init0.State{})
+	inv.Register(builtin0.RewardActorCodeID, reward0.Actor{}, reward0.State{})
+	inv.Register(builtin0.CronActorCodeID, cron0.Actor{}, cron0.State{})
+	inv.Register(builtin0.StoragePowerActorCodeID, power0.Actor{}, power0.State{})
+	inv.Register(builtin0.StorageMarketActorCodeID, market0.Actor{}, market0.State{})
+	inv.Register(builtin0.StorageMinerActorCodeID, miner0.Actor{}, miner0.State{})
+	inv.Register(builtin0.MultisigActorCodeID, msig0.Actor{}, msig0.State{})
+	inv.Register(builtin0.PaymentChannelActorCodeID, paych0.Actor{}, paych0.State{})
+	inv.Register(builtin0.VerifiedRegistryActorCodeID, verifreg0.Actor{}, verifreg0.State{})
+	inv.Register(builtin0.AccountActorCodeID, account0.Actor{}, account0.State{})
 
 	return inv
 }
 
-func (inv *invoker) Invoke(act *types.Actor, vmctx types.VMContext, method uint64, params []byte) ([]byte, aerrors.ActorError) {
+func (inv *Invoker) Invoke(codeCid cid.Cid, rt vmr.Runtime, method abi.MethodNum, params []byte) ([]byte, aerrors.ActorError) {
 
-	if act.Code == actors.AccountCodeCid {
-		return nil, aerrors.Newf(254, "cannot invoke methods on account actors")
-	}
-
-	code, ok := inv.builtInCode[act.Code]
+	code, ok := inv.builtInCode[codeCid]
 	if !ok {
-		log.Errorf("no code for actor %s (Addr: %s)", act.Code, vmctx.Message().To)
-		return nil, aerrors.Newf(255, "no code for actor %s(%d)(%s)", act.Code, method, hex.EncodeToString(params))
+		log.Errorf("no code for actor %s (Addr: %s)", codeCid, rt.Receiver())
+		return nil, aerrors.Newf(exitcode.SysErrorIllegalActor, "no code for actor %s(%d)(%s)", codeCid, method, hex.EncodeToString(params))
 	}
-	if method >= uint64(len(code)) || code[method] == nil {
-		return nil, aerrors.Newf(255, "no method %d on actor", method)
+	if method >= abi.MethodNum(len(code)) || code[method] == nil {
+		return nil, aerrors.Newf(exitcode.SysErrInvalidMethod, "no method %d on actor", method)
 	}
-	return code[method](act, vmctx, params)
+	return code[method](rt, params)
 
 }
 
-func (inv *invoker) register(c cid.Cid, instance Invokee, state interface{}) {
+func (inv *Invoker) Register(c cid.Cid, instance Invokee, state interface{}) {
 	code, err := inv.transform(instance)
 	if err != nil {
-		panic(err)
+		panic(xerrors.Errorf("%s: %w", string(c.Hash()), err))
 	}
 	inv.builtInCode[c] = code
 	inv.builtInState[c] = reflect.TypeOf(state)
@@ -72,10 +88,7 @@ type Invokee interface {
 	Exports() []interface{}
 }
 
-var tVMContext = reflect.TypeOf((*types.VMContext)(nil)).Elem()
-var tAError = reflect.TypeOf((*aerrors.ActorError)(nil)).Elem()
-
-func (*invoker) transform(instance Invokee) (nativeCode, error) {
+func (*Invoker) transform(instance Invokee) (nativeCode, error) {
 	itype := reflect.TypeOf(instance)
 	exports := instance.Exports()
 	for i, m := range exports {
@@ -84,66 +97,70 @@ func (*invoker) transform(instance Invokee) (nativeCode, error) {
 			str := fmt.Sprintf(format, args...)
 			return fmt.Errorf("transform(%s) export(%d): %s", itype.Name(), i, str)
 		}
+
 		if m == nil {
 			continue
 		}
+
 		meth := reflect.ValueOf(m)
 		t := meth.Type()
 		if t.Kind() != reflect.Func {
 			return nil, newErr("is not a function")
 		}
-		if t.NumIn() != 3 {
+		if t.NumIn() != 2 {
 			return nil, newErr("wrong number of inputs should be: " +
-				"*types.Actor, *VMContext, <type of parameter>")
+				"vmr.Runtime, <parameter>")
 		}
-		if t.In(0) != reflect.TypeOf(&types.Actor{}) {
-			return nil, newErr("first arguemnt should be *types.Actor")
+		if t.In(0) != reflect.TypeOf((*vmr.Runtime)(nil)).Elem() {
+			return nil, newErr("first arguemnt should be vmr.Runtime")
 		}
-		if t.In(1) != tVMContext {
-			return nil, newErr("second argument should be types.VMContext")
+		if t.In(1).Kind() != reflect.Ptr {
+			return nil, newErr("second argument should be of kind reflect.Ptr")
 		}
 
-		if t.In(2).Kind() != reflect.Ptr {
-			return nil, newErr("parameter has to be a pointer to parameter, is: %s",
-				t.In(2).Kind())
-		}
-
-		if t.NumOut() != 2 {
+		if t.NumOut() != 1 {
 			return nil, newErr("wrong number of outputs should be: " +
-				"(InvokeRet, error)")
+				"cbg.CBORMarshaler")
 		}
-		if t.Out(0) != reflect.TypeOf([]byte{}) {
-			return nil, newErr("first output should be slice of bytes")
+		o0 := t.Out(0)
+		if !o0.Implements(reflect.TypeOf((*cbg.CBORMarshaler)(nil)).Elem()) {
+			return nil, newErr("output needs to implement cgb.CBORMarshaler")
 		}
-		if !t.Out(1).Implements(tAError) {
-			return nil, newErr("second output should be ActorError type")
-		}
-
 	}
 	code := make(nativeCode, len(exports))
 	for id, m := range exports {
+		if m == nil {
+			continue
+		}
 		meth := reflect.ValueOf(m)
 		code[id] = reflect.MakeFunc(reflect.TypeOf((invokeFunc)(nil)),
 			func(in []reflect.Value) []reflect.Value {
-				paramT := meth.Type().In(2).Elem()
+				paramT := meth.Type().In(1).Elem()
 				param := reflect.New(paramT)
 
-				inBytes := in[2].Interface().([]byte)
-				if len(inBytes) > 0 {
-					if err := DecodeParams(inBytes, param.Interface()); err != nil {
-						aerr := aerrors.Absorb(err, 1, "failed to decode parameters")
-						return []reflect.Value{
-							reflect.ValueOf([]byte{}),
-							// Below is a hack, fixed in Go 1.13
-							// https://git.io/fjXU6
-							reflect.ValueOf(&aerr).Elem(),
-						}
+				inBytes := in[1].Interface().([]byte)
+				if err := DecodeParams(inBytes, param.Interface()); err != nil {
+					aerr := aerrors.Absorb(err, 1, "failed to decode parameters")
+					return []reflect.Value{
+						reflect.ValueOf([]byte{}),
+						// Below is a hack, fixed in Go 1.13
+						// https://git.io/fjXU6
+						reflect.ValueOf(&aerr).Elem(),
 					}
 				}
-
-				return meth.Call([]reflect.Value{
-					in[0], in[1], param,
+				rt := in[0].Interface().(*Runtime)
+				rval, aerror := rt.shimCall(func() interface{} {
+					ret := meth.Call([]reflect.Value{
+						reflect.ValueOf(rt),
+						param,
+					})
+					return ret[0].Interface()
 				})
+
+				return []reflect.Value{
+					reflect.ValueOf(&rval).Elem(),
+					reflect.ValueOf(&aerror).Elem(),
+				}
 			}).Interface().(invokeFunc)
 
 	}
@@ -160,7 +177,11 @@ func DecodeParams(b []byte, out interface{}) error {
 }
 
 func DumpActorState(code cid.Cid, b []byte) (interface{}, error) {
-	i := newInvoker() // TODO: register builtins in init block
+	if code == builtin0.AccountActorCodeID { // Account code special case
+		return nil, nil
+	}
+
+	i := NewInvoker() // TODO: register builtins in init block
 
 	typ, ok := i.builtInState[code]
 	if !ok {
@@ -174,7 +195,7 @@ func DumpActorState(code cid.Cid, b []byte) (interface{}, error) {
 	}
 
 	if err := um.UnmarshalCBOR(bytes.NewReader(b)); err != nil {
-		return nil, err
+		return nil, xerrors.Errorf("unmarshaling actor state: %w", err)
 	}
 
 	return rv.Elem().Interface(), nil
diff --git a/chain/vm/invoker_test.go b/chain/vm/invoker_test.go
index e326d0e70..3744aa8d2 100644
--- a/chain/vm/invoker_test.go
+++ b/chain/vm/invoker_test.go
@@ -5,13 +5,16 @@ import (
 	"io"
 	"testing"
 
+	"github.com/filecoin-project/go-state-types/abi"
+
 	cbor "github.com/ipfs/go-ipld-cbor"
 	"github.com/stretchr/testify/assert"
 	cbg "github.com/whyrusleeping/cbor-gen"
 
+	"github.com/filecoin-project/go-state-types/exitcode"
 	"github.com/filecoin-project/lotus/chain/actors"
 	"github.com/filecoin-project/lotus/chain/actors/aerrors"
-	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/specs-actors/actors/runtime"
 )
 
 type basicContract struct{}
@@ -58,23 +61,23 @@ func (b basicContract) Exports() []interface{} {
 	}
 }
 
-func (basicContract) InvokeSomething0(act *types.Actor, vmctx types.VMContext,
-	params *basicParams) ([]byte, aerrors.ActorError) {
-	return nil, aerrors.New(params.B, "params.B")
+func (basicContract) InvokeSomething0(rt runtime.Runtime, params *basicParams) *abi.EmptyValue {
+	rt.Abortf(exitcode.ExitCode(params.B), "params.B")
+	return nil
 }
 
-func (basicContract) BadParam(act *types.Actor, vmctx types.VMContext,
-	params *basicParams) ([]byte, aerrors.ActorError) {
-	return nil, aerrors.New(255, "bad params")
+func (basicContract) BadParam(rt runtime.Runtime, params *basicParams) *abi.EmptyValue {
+	rt.Abortf(255, "bad params")
+	return nil
 }
 
-func (basicContract) InvokeSomething10(act *types.Actor, vmctx types.VMContext,
-	params *basicParams) ([]byte, aerrors.ActorError) {
-	return nil, aerrors.New(params.B+10, "params.B")
+func (basicContract) InvokeSomething10(rt runtime.Runtime, params *basicParams) *abi.EmptyValue {
+	rt.Abortf(exitcode.ExitCode(params.B+10), "params.B")
+	return nil
 }
 
 func TestInvokerBasic(t *testing.T) {
-	inv := invoker{}
+	inv := Invoker{}
 	code, err := inv.transform(basicContract{})
 	assert.NoError(t, err)
 
@@ -82,9 +85,9 @@ func TestInvokerBasic(t *testing.T) {
 		bParam, err := actors.SerializeParams(&basicParams{B: 1})
 		assert.NoError(t, err)
 
-		_, aerr := code[0](nil, &VMContext{}, bParam)
+		_, aerr := code[0](&Runtime{}, bParam)
 
-		assert.Equal(t, byte(1), aerrors.RetCode(aerr), "return code should be 1")
+		assert.Equal(t, exitcode.ExitCode(1), aerrors.RetCode(aerr), "return code should be 1")
 		if aerrors.IsFatal(aerr) {
 			t.Fatal("err should not be fatal")
 		}
@@ -94,17 +97,17 @@ func TestInvokerBasic(t *testing.T) {
 		bParam, err := actors.SerializeParams(&basicParams{B: 2})
 		assert.NoError(t, err)
 
-		_, aerr := code[10](nil, &VMContext{}, bParam)
-		assert.Equal(t, byte(12), aerrors.RetCode(aerr), "return code should be 12")
+		_, aerr := code[10](&Runtime{}, bParam)
+		assert.Equal(t, exitcode.ExitCode(12), aerrors.RetCode(aerr), "return code should be 12")
 		if aerrors.IsFatal(aerr) {
 			t.Fatal("err should not be fatal")
 		}
 	}
 
-	_, aerr := code[1](nil, &VMContext{}, []byte{99})
+	_, aerr := code[1](&Runtime{}, []byte{99})
 	if aerrors.IsFatal(aerr) {
 		t.Fatal("err should not be fatal")
 	}
-	assert.Equal(t, byte(1), aerrors.RetCode(aerr), "return code should be 1")
+	assert.Equal(t, exitcode.ExitCode(1), aerrors.RetCode(aerr), "return code should be 1")
 
 }
diff --git a/chain/vm/mkactor.go b/chain/vm/mkactor.go
index a84387321..43d2f9431 100644
--- a/chain/vm/mkactor.go
+++ b/chain/vm/mkactor.go
@@ -3,22 +3,22 @@ package vm
 import (
 	"context"
 
+	"github.com/filecoin-project/go-state-types/big"
+	"github.com/filecoin-project/go-state-types/exitcode"
+	"github.com/filecoin-project/lotus/chain/actors"
+	"github.com/filecoin-project/specs-actors/actors/builtin"
+
 	"github.com/ipfs/go-cid"
-	dstore "github.com/ipfs/go-datastore"
-	hamt "github.com/ipfs/go-hamt-ipld"
-	bstore "github.com/ipfs/go-ipfs-blockstore"
+	cbor "github.com/ipfs/go-ipld-cbor"
 
 	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/lotus/chain/actors"
 	"github.com/filecoin-project/lotus/chain/actors/aerrors"
-	"github.com/filecoin-project/lotus/chain/state"
 	"github.com/filecoin-project/lotus/chain/types"
 )
 
 func init() {
-	bs := bstore.NewBlockstore(dstore.NewMapDatastore())
-	cst := hamt.CSTFromBstore(bs)
-	emptyobject, err := cst.Put(context.TODO(), map[string]string{})
+	cst := cbor.NewMemCborStore()
+	emptyobject, err := cst.Put(context.TODO(), []struct{}{})
 	if err != nil {
 		panic(err)
 	}
@@ -28,58 +28,75 @@ func init() {
 
 var EmptyObjectCid cid.Cid
 
-func TryCreateAccountActor(st *state.StateTree, addr address.Address) (*types.Actor, aerrors.ActorError) {
-	act, err := makeActor(st, addr)
-	if err != nil {
+// TryCreateAccountActor creates account actors from only BLS/SECP256K1 addresses.
+func TryCreateAccountActor(rt *Runtime, addr address.Address) (*types.Actor, aerrors.ActorError) {
+	if err := rt.chargeGasSafe(PricelistByEpoch(rt.height).OnCreateActor()); err != nil {
 		return nil, err
 	}
 
-	if _, err := st.RegisterNewAddress(addr, act); err != nil {
+	addrID, err := rt.state.RegisterNewAddress(addr)
+	if err != nil {
 		return nil, aerrors.Escalate(err, "registering actor address")
 	}
 
+	act, aerr := makeActor(addr)
+	if aerr != nil {
+		return nil, aerr
+	}
+
+	if err := rt.state.SetActor(addrID, act); err != nil {
+		return nil, aerrors.Escalate(err, "creating new actor failed")
+	}
+
+	p, err := actors.SerializeParams(&addr)
+	if err != nil {
+		return nil, aerrors.Escalate(err, "couldn't serialize params for actor construction")
+	}
+	// call constructor on account
+
+	_, aerr = rt.internalSend(builtin.SystemActorAddr, addrID, builtin.MethodsAccount.Constructor, big.Zero(), p)
+	if aerr != nil {
+		return nil, aerrors.Wrap(aerr, "failed to invoke account constructor")
+	}
+
+	act, err = rt.state.GetActor(addrID)
+	if err != nil {
+		return nil, aerrors.Escalate(err, "loading newly created actor failed")
+	}
 	return act, nil
 }
 
-func makeActor(st *state.StateTree, addr address.Address) (*types.Actor, aerrors.ActorError) {
+func makeActor(addr address.Address) (*types.Actor, aerrors.ActorError) {
 	switch addr.Protocol() {
 	case address.BLS:
-		return NewBLSAccountActor(st, addr)
+		return NewBLSAccountActor(), nil
 	case address.SECP256K1:
-		return NewSecp256k1AccountActor(st, addr)
+		return NewSecp256k1AccountActor(), nil
 	case address.ID:
-		return nil, aerrors.Newf(1, "no actor with given ID: %s", addr)
+		return nil, aerrors.Newf(exitcode.SysErrInvalidReceiver, "no actor with given ID: %s", addr)
 	case address.Actor:
-		return nil, aerrors.Newf(1, "no such actor: %s", addr)
+		return nil, aerrors.Newf(exitcode.SysErrInvalidReceiver, "no such actor: %s", addr)
 	default:
-		return nil, aerrors.Newf(1, "address has unsupported protocol: %d", addr.Protocol())
+		return nil, aerrors.Newf(exitcode.SysErrInvalidReceiver, "address has unsupported protocol: %d", addr.Protocol())
 	}
 }
 
-func NewBLSAccountActor(st *state.StateTree, addr address.Address) (*types.Actor, aerrors.ActorError) {
-	var acstate actors.AccountActorState
-	acstate.Address = addr
-
-	c, err := st.Store.Put(context.TODO(), &acstate)
-	if err != nil {
-		return nil, aerrors.Escalate(err, "serializing account actor state")
-	}
-
+func NewBLSAccountActor() *types.Actor {
 	nact := &types.Actor{
-		Code:    actors.AccountCodeCid,
-		Balance: types.NewInt(0),
-		Head:    c,
-	}
-
-	return nact, nil
-}
-
-func NewSecp256k1AccountActor(st *state.StateTree, addr address.Address) (*types.Actor, aerrors.ActorError) {
-	nact := &types.Actor{
-		Code:    actors.AccountCodeCid,
+		Code:    builtin.AccountActorCodeID,
 		Balance: types.NewInt(0),
 		Head:    EmptyObjectCid,
 	}
 
-	return nact, nil
+	return nact
+}
+
+func NewSecp256k1AccountActor() *types.Actor {
+	nact := &types.Actor{
+		Code:    builtin.AccountActorCodeID,
+		Balance: types.NewInt(0),
+		Head:    EmptyObjectCid,
+	}
+
+	return nact
 }
diff --git a/chain/vm/runtime.go b/chain/vm/runtime.go
new file mode 100644
index 000000000..156d57282
--- /dev/null
+++ b/chain/vm/runtime.go
@@ -0,0 +1,561 @@
+package vm
+
+import (
+	"bytes"
+	"context"
+	"encoding/binary"
+	"fmt"
+	gruntime "runtime"
+	"time"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/big"
+	"github.com/filecoin-project/go-state-types/cbor"
+	"github.com/filecoin-project/go-state-types/crypto"
+	"github.com/filecoin-project/go-state-types/exitcode"
+	"github.com/filecoin-project/go-state-types/network"
+	rtt "github.com/filecoin-project/go-state-types/rt"
+	"github.com/filecoin-project/specs-actors/actors/builtin"
+	rt0 "github.com/filecoin-project/specs-actors/actors/runtime"
+	"github.com/ipfs/go-cid"
+	ipldcbor "github.com/ipfs/go-ipld-cbor"
+	"go.opencensus.io/trace"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/actors/aerrors"
+	"github.com/filecoin-project/lotus/chain/state"
+	"github.com/filecoin-project/lotus/chain/types"
+)
+
+type Runtime struct {
+	types.Message
+	rt0.Syscalls
+
+	ctx context.Context
+
+	vm        *VM
+	state     *state.StateTree
+	height    abi.ChainEpoch
+	cst       ipldcbor.IpldStore
+	pricelist Pricelist
+
+	gasAvailable int64
+	gasUsed      int64
+
+	// address that started invoke chain
+	origin      address.Address
+	originNonce uint64
+
+	executionTrace    types.ExecutionTrace
+	numActorsCreated  uint64
+	allowInternal     bool
+	callerValidated   bool
+	lastGasChargeTime time.Time
+	lastGasCharge     *types.GasTrace
+}
+
+func (rt *Runtime) NetworkVersion() network.Version {
+	return rt.vm.GetNtwkVersion(rt.ctx, rt.CurrEpoch())
+}
+
+func (rt *Runtime) TotalFilCircSupply() abi.TokenAmount {
+	cs, err := rt.vm.GetCircSupply(rt.ctx)
+	if err != nil {
+		rt.Abortf(exitcode.ErrIllegalState, "failed to get total circ supply: %s", err)
+	}
+
+	return cs
+}
+
+func (rt *Runtime) ResolveAddress(addr address.Address) (ret address.Address, ok bool) {
+	r, err := rt.state.LookupID(addr)
+	if err != nil {
+		if xerrors.Is(err, types.ErrActorNotFound) {
+			return address.Undef, false
+		}
+		panic(aerrors.Fatalf("failed to resolve address %s: %s", addr, err))
+	}
+	return r, true
+}
+
+type notFoundErr interface {
+	IsNotFound() bool
+}
+
+func (rt *Runtime) StoreGet(c cid.Cid, o cbor.Unmarshaler) bool {
+	if err := rt.cst.Get(context.TODO(), c, o); err != nil {
+		var nfe notFoundErr
+		if xerrors.As(err, &nfe) && nfe.IsNotFound() {
+			if xerrors.As(err, new(ipldcbor.SerializationError)) {
+				panic(aerrors.Newf(exitcode.ErrSerialization, "failed to unmarshal cbor object %s", err))
+			}
+			return false
+		}
+
+		panic(aerrors.Fatalf("failed to get cbor object %s: %s", c, err))
+	}
+	return true
+}
+
+func (rt *Runtime) StorePut(x cbor.Marshaler) cid.Cid {
+	c, err := rt.cst.Put(context.TODO(), x)
+	if err != nil {
+		if xerrors.As(err, new(ipldcbor.SerializationError)) {
+			panic(aerrors.Newf(exitcode.ErrSerialization, "failed to marshal cbor object %s", err))
+		}
+		panic(aerrors.Fatalf("failed to put cbor object: %s", err))
+	}
+	return c
+}
+
+var _ rt0.Runtime = (*Runtime)(nil)
+
+func (rt *Runtime) shimCall(f func() interface{}) (rval []byte, aerr aerrors.ActorError) {
+	defer func() {
+		if r := recover(); r != nil {
+			if ar, ok := r.(aerrors.ActorError); ok {
+				log.Warnf("VM.Call failure: %+v", ar)
+				aerr = ar
+				return
+			}
+			//log.Desugar().WithOptions(zap.AddStacktrace(zapcore.ErrorLevel)).
+			//Sugar().Errorf("spec actors failure: %s", r)
+			log.Errorf("spec actors failure: %s", r)
+			aerr = aerrors.Newf(1, "spec actors failure: %s", r)
+		}
+	}()
+
+	ret := f()
+
+	if !rt.callerValidated {
+		rt.Abortf(exitcode.SysErrorIllegalActor, "Caller MUST be validated during method execution")
+	}
+
+	switch ret := ret.(type) {
+	case []byte:
+		return ret, nil
+	case *abi.EmptyValue:
+		return nil, nil
+	case cbor.Marshaler:
+		buf := new(bytes.Buffer)
+		if err := ret.MarshalCBOR(buf); err != nil {
+			return nil, aerrors.Absorb(err, 2, "failed to marshal response to cbor")
+		}
+		return buf.Bytes(), nil
+	case nil:
+		return nil, nil
+	default:
+		return nil, aerrors.New(3, "could not determine type for response from call")
+	}
+}
+
+func (rt *Runtime) ValidateImmediateCallerAcceptAny() {
+	rt.abortIfAlreadyValidated()
+	return
+}
+
+func (rt *Runtime) CurrentBalance() abi.TokenAmount {
+	b, err := rt.GetBalance(rt.Receiver())
+	if err != nil {
+		rt.Abortf(err.RetCode(), "get current balance: %v", err)
+	}
+	return b
+}
+
+func (rt *Runtime) GetActorCodeCID(addr address.Address) (ret cid.Cid, ok bool) {
+	act, err := rt.state.GetActor(addr)
+	if err != nil {
+		if xerrors.Is(err, types.ErrActorNotFound) {
+			return cid.Undef, false
+		}
+
+		panic(aerrors.Fatalf("failed to get actor: %s", err))
+	}
+
+	return act.Code, true
+}
+
+func (rt *Runtime) GetRandomnessFromTickets(personalization crypto.DomainSeparationTag, randEpoch abi.ChainEpoch, entropy []byte) abi.Randomness {
+	res, err := rt.vm.rand.GetChainRandomness(rt.ctx, personalization, randEpoch, entropy)
+	if err != nil {
+		panic(aerrors.Fatalf("could not get randomness: %s", err))
+	}
+	return res
+}
+
+func (rt *Runtime) GetRandomnessFromBeacon(personalization crypto.DomainSeparationTag, randEpoch abi.ChainEpoch, entropy []byte) abi.Randomness {
+	res, err := rt.vm.rand.GetBeaconRandomness(rt.ctx, personalization, randEpoch, entropy)
+	if err != nil {
+		panic(aerrors.Fatalf("could not get randomness: %s", err))
+	}
+	return res
+}
+
+func (rt *Runtime) NewActorAddress() address.Address {
+	var b bytes.Buffer
+	oa, _ := ResolveToKeyAddr(rt.vm.cstate, rt.vm.cst, rt.origin)
+	if err := oa.MarshalCBOR(&b); err != nil { // todo: spec says cbor; why not just bytes?
+		panic(aerrors.Fatalf("writing caller address into a buffer: %v", err))
+	}
+
+	if err := binary.Write(&b, binary.BigEndian, rt.originNonce); err != nil {
+		panic(aerrors.Fatalf("writing nonce address into a buffer: %v", err))
+	}
+	if err := binary.Write(&b, binary.BigEndian, rt.numActorsCreated); err != nil { // TODO: expose on vm
+		panic(aerrors.Fatalf("writing callSeqNum address into a buffer: %v", err))
+	}
+	addr, err := address.NewActorAddress(b.Bytes())
+	if err != nil {
+		panic(aerrors.Fatalf("create actor address: %v", err))
+	}
+
+	rt.incrementNumActorsCreated()
+	return addr
+}
+
+func (rt *Runtime) CreateActor(codeID cid.Cid, address address.Address) {
+	if !builtin.IsBuiltinActor(codeID) {
+		rt.Abortf(exitcode.SysErrorIllegalArgument, "Can only create built-in actors.")
+	}
+
+	if builtin.IsSingletonActor(codeID) {
+		rt.Abortf(exitcode.SysErrorIllegalArgument, "Can only have one instance of singleton actors.")
+	}
+
+	_, err := rt.state.GetActor(address)
+	if err == nil {
+		rt.Abortf(exitcode.SysErrorIllegalArgument, "Actor address already exists")
+	}
+
+	rt.chargeGas(rt.Pricelist().OnCreateActor())
+
+	err = rt.state.SetActor(address, &types.Actor{
+		Code:    codeID,
+		Head:    EmptyObjectCid,
+		Nonce:   0,
+		Balance: big.Zero(),
+	})
+	if err != nil {
+		panic(aerrors.Fatalf("creating actor entry: %v", err))
+	}
+	_ = rt.chargeGasSafe(gasOnActorExec)
+}
+
+// DeleteActor deletes the executing actor from the state tree, transferring
+// any balance to beneficiary.
+// Aborts if the beneficiary does not exist.
+// May only be called by the actor itself.
+func (rt *Runtime) DeleteActor(beneficiary address.Address) {
+	rt.chargeGas(rt.Pricelist().OnDeleteActor())
+	act, err := rt.state.GetActor(rt.Receiver())
+	if err != nil {
+		if xerrors.Is(err, types.ErrActorNotFound) {
+			rt.Abortf(exitcode.SysErrorIllegalActor, "failed to load actor in delete actor: %s", err)
+		}
+		panic(aerrors.Fatalf("failed to get actor: %s", err))
+	}
+	if !act.Balance.IsZero() {
+		// Transfer the executing actor's balance to the beneficiary
+		if err := rt.vm.transfer(rt.Receiver(), beneficiary, act.Balance); err != nil {
+			panic(aerrors.Fatalf("failed to transfer balance to beneficiary actor: %s", err))
+		}
+	}
+
+	// Delete the executing actor
+	if err := rt.state.DeleteActor(rt.Receiver()); err != nil {
+		panic(aerrors.Fatalf("failed to delete actor: %s", err))
+	}
+	_ = rt.chargeGasSafe(gasOnActorExec)
+}
+
+func (rt *Runtime) StartSpan(name string) func() {
+	panic("implement me")
+}
+
+func (rt *Runtime) ValidateImmediateCallerIs(as ...address.Address) {
+	rt.abortIfAlreadyValidated()
+	imm := rt.Caller()
+
+	for _, a := range as {
+		if imm == a {
+			return
+		}
+	}
+	rt.Abortf(exitcode.SysErrForbidden, "caller %s is not one of %s", rt.Caller(), as)
+}
+
+func (rt *Runtime) Context() context.Context {
+	return rt.ctx
+}
+
+func (rt *Runtime) Abortf(code exitcode.ExitCode, msg string, args ...interface{}) {
+	log.Warnf("Abortf: " + fmt.Sprintf(msg, args...))
+	panic(aerrors.NewfSkip(2, code, msg, args...))
+}
+
+func (rt *Runtime) AbortStateMsg(msg string) {
+	panic(aerrors.NewfSkip(3, 101, msg))
+}
+
+func (rt *Runtime) ValidateImmediateCallerType(ts ...cid.Cid) {
+	rt.abortIfAlreadyValidated()
+	callerCid, ok := rt.GetActorCodeCID(rt.Caller())
+	if !ok {
+		panic(aerrors.Fatalf("failed to lookup code cid for caller"))
+	}
+	for _, t := range ts {
+		if t == callerCid {
+			return
+		}
+	}
+	rt.Abortf(exitcode.SysErrForbidden, "caller cid type %q was not one of %v", callerCid, ts)
+}
+
+func (rt *Runtime) CurrEpoch() abi.ChainEpoch {
+	return rt.height
+}
+
+func (rt *Runtime) Send(to address.Address, method abi.MethodNum, m cbor.Marshaler, value abi.TokenAmount, out cbor.Er) exitcode.ExitCode {
+	if !rt.allowInternal {
+		rt.Abortf(exitcode.SysErrorIllegalActor, "runtime.Send() is currently disallowed")
+	}
+	var params []byte
+	if m != nil {
+		buf := new(bytes.Buffer)
+		if err := m.MarshalCBOR(buf); err != nil {
+			rt.Abortf(exitcode.ErrSerialization, "failed to marshal input parameters: %s", err)
+		}
+		params = buf.Bytes()
+	}
+
+	ret, err := rt.internalSend(rt.Receiver(), to, method, value, params)
+	if err != nil {
+		if err.IsFatal() {
+			panic(err)
+		}
+		log.Warnf("vmctx send failed: to: %s, method: %d: ret: %d, err: %s", to, method, ret, err)
+		return err.RetCode()
+	}
+	_ = rt.chargeGasSafe(gasOnActorExec)
+
+	if err := out.UnmarshalCBOR(bytes.NewReader(ret)); err != nil {
+		rt.Abortf(exitcode.ErrSerialization, "failed to unmarshal return value: %s", err)
+	}
+	return 0
+}
+
+func (rt *Runtime) internalSend(from, to address.Address, method abi.MethodNum, value types.BigInt, params []byte) ([]byte, aerrors.ActorError) {
+	start := build.Clock.Now()
+	ctx, span := trace.StartSpan(rt.ctx, "vmc.Send")
+	defer span.End()
+	if span.IsRecordingEvents() {
+		span.AddAttributes(
+			trace.StringAttribute("to", to.String()),
+			trace.Int64Attribute("method", int64(method)),
+			trace.StringAttribute("value", value.String()),
+		)
+	}
+
+	msg := &types.Message{
+		From:     from,
+		To:       to,
+		Method:   method,
+		Value:    value,
+		Params:   params,
+		GasLimit: rt.gasAvailable,
+	}
+
+	st := rt.state
+	if err := st.Snapshot(ctx); err != nil {
+		return nil, aerrors.Fatalf("snapshot failed: %s", err)
+	}
+	defer st.ClearSnapshot()
+
+	ret, errSend, subrt := rt.vm.send(ctx, msg, rt, nil, start)
+	if errSend != nil {
+		if errRevert := st.Revert(); errRevert != nil {
+			return nil, aerrors.Escalate(errRevert, "failed to revert state tree after failed subcall")
+		}
+	}
+
+	if subrt != nil {
+		rt.numActorsCreated = subrt.numActorsCreated
+		rt.executionTrace.Subcalls = append(rt.executionTrace.Subcalls, subrt.executionTrace)
+	}
+	return ret, errSend
+}
+
+func (rt *Runtime) StateCreate(obj cbor.Marshaler) {
+	c := rt.StorePut(obj)
+	err := rt.stateCommit(EmptyObjectCid, c)
+	if err != nil {
+		panic(fmt.Errorf("failed to commit state after creating object: %w", err))
+	}
+}
+
+func (rt *Runtime) StateReadonly(obj cbor.Unmarshaler) {
+	act, err := rt.state.GetActor(rt.Receiver())
+	if err != nil {
+		rt.Abortf(exitcode.SysErrorIllegalArgument, "failed to get actor for Readonly state: %s", err)
+	}
+	rt.StoreGet(act.Head, obj)
+}
+
+func (rt *Runtime) StateTransaction(obj cbor.Er, f func()) {
+	if obj == nil {
+		rt.Abortf(exitcode.SysErrorIllegalActor, "Must not pass nil to Transaction()")
+	}
+
+	act, err := rt.state.GetActor(rt.Receiver())
+	if err != nil {
+		rt.Abortf(exitcode.SysErrorIllegalActor, "failed to get actor for Transaction: %s", err)
+	}
+	baseState := act.Head
+	rt.StoreGet(baseState, obj)
+
+	rt.allowInternal = false
+	f()
+	rt.allowInternal = true
+
+	c := rt.StorePut(obj)
+
+	err = rt.stateCommit(baseState, c)
+	if err != nil {
+		panic(fmt.Errorf("failed to commit state after transaction: %w", err))
+	}
+}
+
+func (rt *Runtime) GetBalance(a address.Address) (types.BigInt, aerrors.ActorError) {
+	act, err := rt.state.GetActor(a)
+	switch err {
+	default:
+		return types.EmptyInt, aerrors.Escalate(err, "failed to look up actor balance")
+	case types.ErrActorNotFound:
+		return types.NewInt(0), nil
+	case nil:
+		return act.Balance, nil
+	}
+}
+
+func (rt *Runtime) stateCommit(oldh, newh cid.Cid) aerrors.ActorError {
+	// TODO: we can make this more efficient in the future...
+	act, err := rt.state.GetActor(rt.Receiver())
+	if err != nil {
+		return aerrors.Escalate(err, "failed to get actor to commit state")
+	}
+
+	if act.Head != oldh {
+		return aerrors.Fatal("failed to update, inconsistent base reference")
+	}
+
+	act.Head = newh
+
+	if err := rt.state.SetActor(rt.Receiver(), act); err != nil {
+		return aerrors.Fatalf("failed to set actor in commit state: %s", err)
+	}
+
+	return nil
+}
+
+func (rt *Runtime) finilizeGasTracing() {
+	if rt.lastGasCharge != nil {
+		rt.lastGasCharge.TimeTaken = time.Since(rt.lastGasChargeTime)
+	}
+}
+
+// ChargeGas is spec actors function
+func (rt *Runtime) ChargeGas(name string, compute int64, virtual int64) {
+	err := rt.chargeGasInternal(newGasCharge(name, compute, 0).WithVirtual(virtual, 0), 1)
+	if err != nil {
+		panic(err)
+	}
+}
+
+func (rt *Runtime) chargeGas(gas GasCharge) {
+	err := rt.chargeGasInternal(gas, 1)
+	if err != nil {
+		panic(err)
+	}
+}
+
+func (rt *Runtime) chargeGasFunc(skip int) func(GasCharge) {
+	return func(gas GasCharge) {
+		err := rt.chargeGasInternal(gas, 1+skip)
+		if err != nil {
+			panic(err)
+		}
+	}
+
+}
+
+func (rt *Runtime) chargeGasInternal(gas GasCharge, skip int) aerrors.ActorError {
+	toUse := gas.Total()
+	var callers [10]uintptr
+	cout := gruntime.Callers(2+skip, callers[:])
+
+	now := build.Clock.Now()
+	if rt.lastGasCharge != nil {
+		rt.lastGasCharge.TimeTaken = now.Sub(rt.lastGasChargeTime)
+	}
+
+	gasTrace := types.GasTrace{
+		Name:  gas.Name,
+		Extra: gas.Extra,
+
+		TotalGas:   toUse,
+		ComputeGas: gas.ComputeGas,
+		StorageGas: gas.StorageGas,
+
+		TotalVirtualGas:   gas.VirtualCompute*GasComputeMulti + gas.VirtualStorage*GasStorageMulti,
+		VirtualComputeGas: gas.VirtualCompute,
+		VirtualStorageGas: gas.VirtualStorage,
+
+		Callers: callers[:cout],
+	}
+	rt.executionTrace.GasCharges = append(rt.executionTrace.GasCharges, &gasTrace)
+	rt.lastGasChargeTime = now
+	rt.lastGasCharge = &gasTrace
+
+	// overflow safe
+	if rt.gasUsed > rt.gasAvailable-toUse {
+		rt.gasUsed = rt.gasAvailable
+		return aerrors.Newf(exitcode.SysErrOutOfGas, "not enough gas: used=%d, available=%d",
+			rt.gasUsed, rt.gasAvailable)
+	}
+	rt.gasUsed += toUse
+	return nil
+}
+
+func (rt *Runtime) chargeGasSafe(gas GasCharge) aerrors.ActorError {
+	return rt.chargeGasInternal(gas, 1)
+}
+
+func (rt *Runtime) Pricelist() Pricelist {
+	return rt.pricelist
+}
+
+func (rt *Runtime) incrementNumActorsCreated() {
+	rt.numActorsCreated++
+}
+
+func (rt *Runtime) abortIfAlreadyValidated() {
+	if rt.callerValidated {
+		rt.Abortf(exitcode.SysErrorIllegalActor, "Method must validate caller identity exactly once")
+	}
+	rt.callerValidated = true
+}
+
+func (rt *Runtime) Log(level rtt.LogLevel, msg string, args ...interface{}) {
+	switch level {
+	case rtt.DEBUG:
+		actorLog.Debugf(msg, args...)
+	case rtt.INFO:
+		actorLog.Infof(msg, args...)
+	case rtt.WARN:
+		actorLog.Warnf(msg, args...)
+	case rtt.ERROR:
+		actorLog.Errorf(msg, args...)
+	}
+}
diff --git a/chain/vm/runtime_test.go b/chain/vm/runtime_test.go
new file mode 100644
index 000000000..c22a8b615
--- /dev/null
+++ b/chain/vm/runtime_test.go
@@ -0,0 +1,47 @@
+package vm
+
+import (
+	"io"
+	"testing"
+
+	cbor "github.com/ipfs/go-ipld-cbor"
+	cbg "github.com/whyrusleeping/cbor-gen"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-state-types/exitcode"
+
+	"github.com/filecoin-project/lotus/chain/actors/aerrors"
+)
+
+type NotAVeryGoodMarshaler struct{}
+
+func (*NotAVeryGoodMarshaler) MarshalCBOR(writer io.Writer) error {
+	return xerrors.Errorf("no")
+}
+
+var _ cbg.CBORMarshaler = &NotAVeryGoodMarshaler{}
+
+func TestRuntimePutErrors(t *testing.T) {
+	defer func() {
+		err := recover()
+		if err == nil {
+			t.Fatal("expected non-nil recovery")
+		}
+
+		aerr := err.(aerrors.ActorError)
+		if aerr.IsFatal() {
+			t.Fatal("expected non-fatal actor error")
+		}
+
+		if aerr.RetCode() != exitcode.ErrSerialization {
+			t.Fatal("expected serialization error")
+		}
+	}()
+
+	rt := Runtime{
+		cst: cbor.NewCborStore(nil),
+	}
+
+	rt.StorePut(&NotAVeryGoodMarshaler{})
+	t.Error("expected panic")
+}
diff --git a/chain/vm/syscalls.go b/chain/vm/syscalls.go
index 92f9ea269..a7f5dab0c 100644
--- a/chain/vm/syscalls.go
+++ b/chain/vm/syscalls.go
@@ -1,14 +1,299 @@
 package vm
 
 import (
-	"github.com/filecoin-project/lotus/chain/actors"
+	"bytes"
+	"context"
+	"fmt"
+	goruntime "runtime"
+	"sync"
+
+	"github.com/filecoin-project/specs-actors/actors/runtime/proof"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/ipfs/go-cid"
+	cbor "github.com/ipfs/go-ipld-cbor"
+	"github.com/minio/blake2b-simd"
+	mh "github.com/multiformats/go-multihash"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/crypto"
+	"github.com/filecoin-project/lotus/chain/actors/adt"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
+	"github.com/filecoin-project/lotus/chain/state"
 	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/lib/sigs"
+	"github.com/filecoin-project/specs-actors/actors/runtime"
+
+	"github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper"
 )
 
+func init() {
+	mh.Codes[0xf104] = "filecoin"
+}
+
 // Actual type is defined in chain/types/vmcontext.go because the VMContext interface is there
 
-func DefaultSyscalls() *types.VMSyscalls {
-	return &types.VMSyscalls{
-		ValidatePoRep: actors.ValidatePoRep,
+type SyscallBuilder func(ctx context.Context, cstate *state.StateTree, cst cbor.IpldStore) runtime.Syscalls
+
+func Syscalls(verifier ffiwrapper.Verifier) SyscallBuilder {
+	return func(ctx context.Context, cstate *state.StateTree, cst cbor.IpldStore) runtime.Syscalls {
+		return &syscallShim{
+			ctx: ctx,
+
+			cstate: cstate,
+			cst:    cst,
+
+			verifier: verifier,
+		}
 	}
 }
+
+type syscallShim struct {
+	ctx context.Context
+
+	cstate   *state.StateTree
+	cst      cbor.IpldStore
+	verifier ffiwrapper.Verifier
+}
+
+func (ss *syscallShim) ComputeUnsealedSectorCID(st abi.RegisteredSealProof, pieces []abi.PieceInfo) (cid.Cid, error) {
+	var sum abi.PaddedPieceSize
+	for _, p := range pieces {
+		sum += p.Size
+	}
+
+	commd, err := ffiwrapper.GenerateUnsealedCID(st, pieces)
+	if err != nil {
+		log.Errorf("generate data commitment failed: %s", err)
+		return cid.Undef, err
+	}
+
+	return commd, nil
+}
+
+func (ss *syscallShim) HashBlake2b(data []byte) [32]byte {
+	return blake2b.Sum256(data)
+}
+
+// Checks validity of the submitted consensus fault with the two block headers needed to prove the fault
+// and an optional extra one to check common ancestry (as needed).
+// Note that the blocks are ordered: the method requires a.Epoch() <= b.Epoch().
+func (ss *syscallShim) VerifyConsensusFault(a, b, extra []byte) (*runtime.ConsensusFault, error) {
+	// Note that block syntax is not validated. Any validly signed block will be accepted pursuant to the below conditions.
+	// Whether or not it could ever have been accepted in a chain is not checked/does not matter here.
+	// for that reason when checking block parent relationships, rather than instantiating a Tipset to do so
+	// (which runs a syntactic check), we do it directly on the CIDs.
+
+	// (0) cheap preliminary checks
+
+	// can blocks be decoded properly?
+	var blockA, blockB types.BlockHeader
+	if decodeErr := blockA.UnmarshalCBOR(bytes.NewReader(a)); decodeErr != nil {
+		return nil, xerrors.Errorf("cannot decode first block header: %w", decodeErr)
+	}
+
+	if decodeErr := blockB.UnmarshalCBOR(bytes.NewReader(b)); decodeErr != nil {
+		return nil, xerrors.Errorf("cannot decode second block header: %f", decodeErr)
+	}
+
+	// are blocks the same?
+	if blockA.Cid().Equals(blockB.Cid()) {
+		return nil, fmt.Errorf("no consensus fault: submitted blocks are the same")
+	}
+
+	// (1) check conditions necessary to any consensus fault
+
+	// were blocks mined by same miner?
+	if blockA.Miner != blockB.Miner {
+		return nil, fmt.Errorf("no consensus fault: blocks not mined by same miner")
+	}
+
+	// block a must be earlier or equal to block b, epoch wise (ie at least as early in the chain).
+	if blockB.Height < blockA.Height {
+		return nil, fmt.Errorf("first block must not be of higher height than second")
+	}
+
+	// (2) check for the consensus faults themselves
+	var consensusFault *runtime.ConsensusFault
+
+	// (a) double-fork mining fault
+	if blockA.Height == blockB.Height {
+		consensusFault = &runtime.ConsensusFault{
+			Target: blockA.Miner,
+			Epoch:  blockB.Height,
+			Type:   runtime.ConsensusFaultDoubleForkMining,
+		}
+	}
+
+	// (b) time-offset mining fault
+	// strictly speaking no need to compare heights based on double fork mining check above,
+	// but at same height this would be a different fault.
+	if types.CidArrsEqual(blockA.Parents, blockB.Parents) && blockA.Height != blockB.Height {
+		consensusFault = &runtime.ConsensusFault{
+			Target: blockA.Miner,
+			Epoch:  blockB.Height,
+			Type:   runtime.ConsensusFaultTimeOffsetMining,
+		}
+	}
+
+	// (c) parent-grinding fault
+	// Here extra is the "witness", a third block that shows the connection between A and B as
+	// A's sibling and B's parent.
+	// Specifically, since A is of lower height, it must be that B was mined omitting A from its tipset
+	//
+	//      B
+	//      |
+	//  [A, C]
+	var blockC types.BlockHeader
+	if len(extra) > 0 {
+		if decodeErr := blockC.UnmarshalCBOR(bytes.NewReader(extra)); decodeErr != nil {
+			return nil, xerrors.Errorf("cannot decode extra: %w", decodeErr)
+		}
+
+		if types.CidArrsEqual(blockA.Parents, blockC.Parents) && blockA.Height == blockC.Height &&
+			types.CidArrsContains(blockB.Parents, blockC.Cid()) && !types.CidArrsContains(blockB.Parents, blockA.Cid()) {
+			consensusFault = &runtime.ConsensusFault{
+				Target: blockA.Miner,
+				Epoch:  blockB.Height,
+				Type:   runtime.ConsensusFaultParentGrinding,
+			}
+		}
+	}
+
+	// (3) return if no consensus fault by now
+	if consensusFault == nil {
+		return nil, xerrors.Errorf("no consensus fault detected")
+	}
+
+	// else
+	// (4) expensive final checks
+
+	// check blocks are properly signed by their respective miner
+	// note we do not need to check extra's: it is a parent to block b
+	// which itself is signed, so it was willingly included by the miner
+	if sigErr := ss.VerifyBlockSig(&blockA); sigErr != nil {
+		return nil, xerrors.Errorf("cannot verify first block sig: %w", sigErr)
+	}
+
+	if sigErr := ss.VerifyBlockSig(&blockB); sigErr != nil {
+		return nil, xerrors.Errorf("cannot verify second block sig: %w", sigErr)
+	}
+
+	return consensusFault, nil
+}
+
+func (ss *syscallShim) VerifyBlockSig(blk *types.BlockHeader) error {
+
+	// get appropriate miner actor
+	act, err := ss.cstate.GetActor(blk.Miner)
+	if err != nil {
+		return err
+	}
+
+	// use that to get the miner state
+	mas, err := miner.Load(adt.WrapStore(ss.ctx, ss.cst), act)
+	if err != nil {
+		return err
+	}
+
+	info, err := mas.Info()
+	if err != nil {
+		return err
+	}
+
+	// and use to get resolved workerKey
+	waddr, err := ResolveToKeyAddr(ss.cstate, ss.cst, info.Worker)
+	if err != nil {
+		return err
+	}
+
+	if err := sigs.CheckBlockSignature(ss.ctx, blk, waddr); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (ss *syscallShim) VerifyPoSt(proof proof.WindowPoStVerifyInfo) error {
+	ok, err := ss.verifier.VerifyWindowPoSt(context.TODO(), proof)
+	if err != nil {
+		return err
+	}
+	if !ok {
+		return fmt.Errorf("proof was invalid")
+	}
+	return nil
+}
+
+func (ss *syscallShim) VerifySeal(info proof.SealVerifyInfo) error {
+	//_, span := trace.StartSpan(ctx, "ValidatePoRep")
+	//defer span.End()
+
+	miner, err := address.NewIDAddress(uint64(info.Miner))
+	if err != nil {
+		return xerrors.Errorf("weirdly failed to construct address: %w", err)
+	}
+
+	ticket := []byte(info.Randomness)
+	proof := info.Proof
+	seed := []byte(info.InteractiveRandomness)
+
+	log.Debugf("Verif r:%x; d:%x; m:%s; t:%x; s:%x; N:%d; p:%x", info.SealedCID, info.UnsealedCID, miner, ticket, seed, info.SectorID.Number, proof)
+
+	//func(ctx context.Context, maddr address.Address, ssize abi.SectorSize, commD, commR, ticket, proof, seed []byte, sectorID abi.SectorNumber)
+	ok, err := ss.verifier.VerifySeal(info)
+	if err != nil {
+		return xerrors.Errorf("failed to validate PoRep: %w", err)
+	}
+	if !ok {
+		return fmt.Errorf("invalid proof")
+	}
+
+	return nil
+}
+
+func (ss *syscallShim) VerifySignature(sig crypto.Signature, addr address.Address, input []byte) error {
+	// TODO: in genesis setup, we are currently faking signatures
+
+	kaddr, err := ResolveToKeyAddr(ss.cstate, ss.cst, addr)
+	if err != nil {
+		return err
+	}
+
+	return sigs.Verify(&sig, kaddr, input)
+}
+
+var BatchSealVerifyParallelism = goruntime.NumCPU()
+
+func (ss *syscallShim) BatchVerifySeals(inp map[address.Address][]proof.SealVerifyInfo) (map[address.Address][]bool, error) {
+	out := make(map[address.Address][]bool)
+
+	sema := make(chan struct{}, BatchSealVerifyParallelism)
+
+	var wg sync.WaitGroup
+	for addr, seals := range inp {
+		results := make([]bool, len(seals))
+		out[addr] = results
+
+		for i, s := range seals {
+			wg.Add(1)
+			go func(ma address.Address, ix int, svi proof.SealVerifyInfo, res []bool) {
+				defer wg.Done()
+				sema <- struct{}{}
+
+				if err := ss.VerifySeal(svi); err != nil {
+					log.Warnw("seal verify in batch failed", "miner", ma, "index", ix, "err", err)
+					res[ix] = false
+				} else {
+					res[ix] = true
+				}
+
+				<-sema
+			}(addr, i, s, results)
+		}
+	}
+	wg.Wait()
+
+	return out, nil
+}
diff --git a/chain/vm/validation_test.go b/chain/vm/validation_test.go
deleted file mode 100644
index 5e5a46a63..000000000
--- a/chain/vm/validation_test.go
+++ /dev/null
@@ -1,35 +0,0 @@
-package vm_test
-
-import (
-	"testing"
-
-	"github.com/filecoin-project/chain-validation/pkg/suites"
-
-	"github.com/filecoin-project/lotus/chain/validation"
-)
-
-func TestStorageMinerValidation(t *testing.T) {
-	t.SkipNow()
-	factory := validation.NewFactories()
-	suites.CreateStorageMinerAndUpdatePeerID(t, factory)
-
-}
-
-func TestValueTransfer(t *testing.T) {
-	factory := validation.NewFactories()
-	suites.AccountValueTransferSuccess(t, factory, 126)
-	suites.AccountValueTransferZeroFunds(t, factory, 112)
-	suites.AccountValueTransferOverBalanceNonZero(t, factory, 0)
-	suites.AccountValueTransferOverBalanceZero(t, factory, 0)
-	suites.AccountValueTransferToSelf(t, factory, 0)
-	suites.AccountValueTransferFromKnownToUnknownAccount(t, factory, 0)
-	suites.AccountValueTransferFromUnknownToKnownAccount(t, factory, 0)
-	suites.AccountValueTransferFromUnknownToUnknownAccount(t, factory, 0)
-}
-
-func TestMultiSig(t *testing.T) {
-	factory := validation.NewFactories()
-	suites.MultiSigActorConstructor(t, factory)
-	suites.MultiSigActorProposeApprove(t, factory)
-	suites.MultiSigActorProposeCancel(t, factory)
-}
diff --git a/chain/vm/vm.go b/chain/vm/vm.go
index 6fa6a432c..54ea47698 100644
--- a/chain/vm/vm.go
+++ b/chain/vm/vm.go
@@ -4,404 +4,312 @@ import (
 	"bytes"
 	"context"
 	"fmt"
-	"math/big"
+	"reflect"
+	"sync/atomic"
+	"time"
 
 	block "github.com/ipfs/go-block-format"
 	cid "github.com/ipfs/go-cid"
-	hamt "github.com/ipfs/go-hamt-ipld"
-	blockstore "github.com/ipfs/go-ipfs-blockstore"
-	logging "github.com/ipfs/go-log"
+	cbor "github.com/ipfs/go-ipld-cbor"
+	logging "github.com/ipfs/go-log/v2"
+	mh "github.com/multiformats/go-multihash"
 	cbg "github.com/whyrusleeping/cbor-gen"
 	"go.opencensus.io/trace"
 	"golang.org/x/xerrors"
 
 	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/big"
+	"github.com/filecoin-project/go-state-types/crypto"
+	"github.com/filecoin-project/go-state-types/exitcode"
+	"github.com/filecoin-project/go-state-types/network"
+	"github.com/filecoin-project/specs-actors/actors/builtin"
+
 	"github.com/filecoin-project/lotus/build"
-	"github.com/filecoin-project/lotus/chain/actors"
+	"github.com/filecoin-project/lotus/chain/actors/adt"
 	"github.com/filecoin-project/lotus/chain/actors/aerrors"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/account"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/reward"
 	"github.com/filecoin-project/lotus/chain/state"
 	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/lib/blockstore"
+	bstore "github.com/filecoin-project/lotus/lib/blockstore"
 	"github.com/filecoin-project/lotus/lib/bufbstore"
 )
 
 var log = logging.Logger("vm")
+var actorLog = logging.Logger("actors")
+var gasOnActorExec = newGasCharge("OnActorExec", 0, 0)
 
-const (
-	gasFundTransfer = 10
-	gasInvoke       = 5
-
-	gasGetObj         = 10
-	gasGetPerByte     = 1
-	gasPutObj         = 20
-	gasPutPerByte     = 2
-	gasCommit         = 50
-	gasPerMessageByte = 2
+// stat counters
+var (
+	StatSends   uint64
+	StatApplied uint64
 )
 
-const (
-	outOfGasErrCode = 200
-)
-
-type VMContext struct {
-	ctx context.Context
-
-	vm     *VM
-	state  *state.StateTree
-	msg    *types.Message
-	height uint64
-	cst    *hamt.CborIpldStore
-
-	gasAvailable types.BigInt
-	gasUsed      types.BigInt
-
-	sys *types.VMSyscalls
-
-	// root cid of the state of the actor this invocation will be on
-	sroot cid.Cid
-
-	// address that started invoke chain
-	origin address.Address
-}
-
-// Message is the message that kicked off the current invocation
-func (vmc *VMContext) Message() *types.Message {
-	return vmc.msg
-}
-
-func (vmc *VMContext) GetRandomness(height uint64) ([]byte, aerrors.ActorError) {
-
-	res, err := vmc.vm.rand.GetRandomness(vmc.ctx, int64(height))
-	if err != nil {
-		return nil, aerrors.Escalate(err, "could not get randomness")
-	}
-	return res, nil
-}
-
-func (vmc *VMContext) Sys() *types.VMSyscalls {
-	return vmc.sys
-}
-
-// Storage interface
-
-func (vmc *VMContext) Put(i cbg.CBORMarshaler) (cid.Cid, aerrors.ActorError) {
-	c, err := vmc.cst.Put(context.TODO(), i)
-	if err != nil {
-		return cid.Undef, aerrors.HandleExternalError(err, fmt.Sprintf("putting object %T", i))
-	}
-	return c, nil
-}
-
-func (vmc *VMContext) Get(c cid.Cid, out cbg.CBORUnmarshaler) aerrors.ActorError {
-	err := vmc.cst.Get(context.TODO(), c, out)
-	if err != nil {
-		return aerrors.HandleExternalError(err, "getting cid")
-	}
-	return nil
-}
-
-func (vmc *VMContext) GetHead() cid.Cid {
-	return vmc.sroot
-}
-
-func (vmc *VMContext) Commit(oldh, newh cid.Cid) aerrors.ActorError {
-	if err := vmc.ChargeGas(gasCommit); err != nil {
-		return aerrors.Wrap(err, "out of gas")
-	}
-	if vmc.sroot != oldh {
-		return aerrors.New(1, "failed to update, inconsistent base reference")
-	}
-
-	vmc.sroot = newh
-	return nil
-}
-
-// End of storage interface
-
-// Storage provides access to the VM storage layer
-func (vmc *VMContext) Storage() types.Storage {
-	return vmc
-}
-
-func (vmc *VMContext) Ipld() *hamt.CborIpldStore {
-	return vmc.cst
-}
-
-func (vmc *VMContext) Origin() address.Address {
-	return vmc.origin
-}
-
-// Send allows the current execution context to invoke methods on other actors in the system
-func (vmc *VMContext) Send(to address.Address, method uint64, value types.BigInt, params []byte) ([]byte, aerrors.ActorError) {
-	ctx, span := trace.StartSpan(vmc.ctx, "vmc.Send")
-	defer span.End()
-	if span.IsRecordingEvents() {
-		span.AddAttributes(
-			trace.StringAttribute("to", to.String()),
-			trace.Int64Attribute("method", int64(method)),
-			trace.StringAttribute("value", value.String()),
-		)
-	}
-
-	msg := &types.Message{
-		From:     vmc.msg.To,
-		To:       to,
-		Method:   method,
-		Value:    value,
-		Params:   params,
-		GasLimit: vmc.gasAvailable,
-	}
-
-	ret, err, _ := vmc.vm.send(ctx, msg, vmc, 0)
-	return ret, err
-}
-
-// BlockHeight returns the height of the block this message was added to the chain in
-func (vmc *VMContext) BlockHeight() uint64 {
-	return vmc.height
-}
-
-func (vmc *VMContext) GasUsed() types.BigInt {
-	return vmc.gasUsed
-}
-
-func (vmc *VMContext) ChargeGas(amount uint64) aerrors.ActorError {
-	toUse := types.NewInt(amount)
-	vmc.gasUsed = types.BigAdd(vmc.gasUsed, toUse)
-	if vmc.gasUsed.GreaterThan(vmc.gasAvailable) {
-		return aerrors.Newf(outOfGasErrCode, "not enough gas: used=%s, available=%s", vmc.gasUsed, vmc.gasAvailable)
-	}
-	return nil
-}
-
-func (vmc *VMContext) StateTree() (types.StateTree, aerrors.ActorError) {
-	if vmc.msg.To != actors.InitAddress {
-		return nil, aerrors.Escalate(fmt.Errorf("only init actor can access state tree directly"), "invalid use of StateTree")
-	}
-
-	return vmc.state, nil
-}
-
-const GasVerifySignature = 50
-
-func (vmctx *VMContext) VerifySignature(sig *types.Signature, act address.Address, data []byte) aerrors.ActorError {
-	if err := vmctx.ChargeGas(GasVerifySignature); err != nil {
-		return err
-	}
-
-	if act.Protocol() == address.ID {
-		kaddr, err := ResolveToKeyAddr(vmctx.state, vmctx.cst, act)
-		if err != nil {
-			return aerrors.Wrap(err, "failed to resolve address to key address")
-		}
-		act = kaddr
-	}
-
-	if err := sig.Verify(act, data); err != nil {
-		return aerrors.New(2, "signature verification failed")
-	}
-
-	return nil
-}
-
-func ResolveToKeyAddr(state types.StateTree, cst *hamt.CborIpldStore, addr address.Address) (address.Address, aerrors.ActorError) {
+// ResolveToKeyAddr returns the public key type of address (`BLS`/`SECP256K1`) of an account actor identified by `addr`.
+func ResolveToKeyAddr(state types.StateTree, cst cbor.IpldStore, addr address.Address) (address.Address, error) {
 	if addr.Protocol() == address.BLS || addr.Protocol() == address.SECP256K1 {
 		return addr, nil
 	}
 
 	act, err := state.GetActor(addr)
 	if err != nil {
-		return address.Undef, aerrors.Newf(1, "failed to find actor: %s", addr)
+		return address.Undef, xerrors.Errorf("failed to find actor: %s", addr)
 	}
 
-	if act.Code != actors.AccountCodeCid {
-		return address.Undef, aerrors.New(1, "address was not for an account actor")
+	aast, err := account.Load(adt.WrapStore(context.TODO(), cst), act)
+	if err != nil {
+		return address.Undef, xerrors.Errorf("failed to get account actor state for %s: %w", addr, err)
 	}
 
-	var aast actors.AccountActorState
-	if err := cst.Get(context.TODO(), act.Head, &aast); err != nil {
-		return address.Undef, aerrors.Escalate(err, fmt.Sprintf("failed to get account actor state for %s", addr))
-	}
-
-	return aast.Address, nil
+	return aast.PubkeyAddress()
 }
 
-func (vmctx *VMContext) GetBalance(a address.Address) (types.BigInt, aerrors.ActorError) {
-	act, err := vmctx.state.GetActor(a)
-	switch err {
-	default:
-		return types.EmptyInt, aerrors.Escalate(err, "failed to look up actor balance")
-	case hamt.ErrNotFound:
-		return types.NewInt(0), nil
-	case nil:
-		return act.Balance, nil
-	}
-}
-
-func (vmctx *VMContext) Context() context.Context {
-	return vmctx.ctx
-}
-
-type hBlocks interface {
-	GetBlock(context.Context, cid.Cid) (block.Block, error)
-	AddBlock(block.Block) error
-}
-
-var _ hBlocks = (*gasChargingBlocks)(nil)
+var _ cbor.IpldBlockstore = (*gasChargingBlocks)(nil)
 
 type gasChargingBlocks struct {
-	chargeGas func(uint64) aerrors.ActorError
-	under     hBlocks
+	chargeGas func(GasCharge)
+	pricelist Pricelist
+	under     cbor.IpldBlockstore
 }
 
-func (bs *gasChargingBlocks) GetBlock(ctx context.Context, c cid.Cid) (block.Block, error) {
-	if err := bs.chargeGas(gasGetObj); err != nil {
-		return nil, err
-	}
-	blk, err := bs.under.GetBlock(ctx, c)
+func (bs *gasChargingBlocks) Get(c cid.Cid) (block.Block, error) {
+	bs.chargeGas(bs.pricelist.OnIpldGet())
+	blk, err := bs.under.Get(c)
 	if err != nil {
-		return nil, err
-	}
-	if err := bs.chargeGas(uint64(len(blk.RawData())) * gasGetPerByte); err != nil {
-		return nil, err
+		return nil, aerrors.Escalate(err, "failed to get block from blockstore")
 	}
+	bs.chargeGas(newGasCharge("OnIpldGetEnd", 0, 0).WithExtra(len(blk.RawData())))
+	bs.chargeGas(gasOnActorExec)
 
 	return blk, nil
 }
 
-func (bs *gasChargingBlocks) AddBlock(blk block.Block) error {
-	if err := bs.chargeGas(gasPutObj + uint64(len(blk.RawData()))*gasPutPerByte); err != nil {
-		return err
+func (bs *gasChargingBlocks) Put(blk block.Block) error {
+	bs.chargeGas(bs.pricelist.OnIpldPut(len(blk.RawData())))
+
+	if err := bs.under.Put(blk); err != nil {
+		return aerrors.Escalate(err, "failed to write data to disk")
 	}
-	return bs.under.AddBlock(blk)
+	bs.chargeGas(gasOnActorExec)
+	return nil
 }
 
-func (vm *VM) makeVMContext(ctx context.Context, sroot cid.Cid, msg *types.Message, origin address.Address, usedGas types.BigInt) *VMContext {
-	vmc := &VMContext{
-		ctx:    ctx,
-		vm:     vm,
-		state:  vm.cstate,
-		sroot:  sroot,
-		msg:    msg,
-		origin: origin,
-		height: vm.blockHeight,
-		sys:    vm.Syscalls,
+func (vm *VM) makeRuntime(ctx context.Context, msg *types.Message, origin address.Address, originNonce uint64, usedGas int64, nac uint64) *Runtime {
+	rt := &Runtime{
+		ctx:         ctx,
+		vm:          vm,
+		state:       vm.cstate,
+		origin:      origin,
+		originNonce: originNonce,
+		height:      vm.blockHeight,
 
-		gasUsed:      usedGas,
-		gasAvailable: msg.GasLimit,
+		gasUsed:          usedGas,
+		gasAvailable:     msg.GasLimit,
+		numActorsCreated: nac,
+		pricelist:        PricelistByEpoch(vm.blockHeight),
+		allowInternal:    true,
+		callerValidated:  false,
+		executionTrace:   types.ExecutionTrace{Msg: msg},
 	}
-	vmc.cst = &hamt.CborIpldStore{
-		Blocks: &gasChargingBlocks{vmc.ChargeGas, vm.cst.Blocks},
+
+	rt.cst = &cbor.BasicIpldStore{
+		Blocks: &gasChargingBlocks{rt.chargeGasFunc(2), rt.pricelist, vm.cst.Blocks},
 		Atlas:  vm.cst.Atlas,
 	}
-	return vmc
+	rt.Syscalls = pricedSyscalls{
+		under:     vm.Syscalls(ctx, vm.cstate, rt.cst),
+		chargeGas: rt.chargeGasFunc(1),
+		pl:        rt.pricelist,
+	}
+
+	vmm := *msg
+	resF, ok := rt.ResolveAddress(msg.From)
+	if !ok {
+		rt.Abortf(exitcode.SysErrInvalidReceiver, "resolve msg.From address failed")
+	}
+	vmm.From = resF
+	rt.Message = vmm
+
+	return rt
 }
 
+type UnsafeVM struct {
+	VM *VM
+}
+
+func (vm *UnsafeVM) MakeRuntime(ctx context.Context, msg *types.Message, origin address.Address, originNonce uint64, usedGas int64, nac uint64) *Runtime {
+	return vm.VM.makeRuntime(ctx, msg, origin, originNonce, usedGas, nac)
+}
+
+type CircSupplyCalculator func(context.Context, abi.ChainEpoch, *state.StateTree) (abi.TokenAmount, error)
+type NtwkVersionGetter func(context.Context, abi.ChainEpoch) network.Version
+
 type VM struct {
-	cstate      *state.StateTree
-	base        cid.Cid
-	cst         *hamt.CborIpldStore
-	buf         *bufbstore.BufferedBS
-	blockHeight uint64
-	blockMiner  address.Address
-	inv         *invoker
-	rand        Rand
+	cstate         *state.StateTree
+	base           cid.Cid
+	cst            *cbor.BasicIpldStore
+	buf            *bufbstore.BufferedBS
+	blockHeight    abi.ChainEpoch
+	inv            *Invoker
+	rand           Rand
+	circSupplyCalc CircSupplyCalculator
+	ntwkVersion    NtwkVersionGetter
+	baseFee        abi.TokenAmount
 
-	Syscalls *types.VMSyscalls
+	Syscalls SyscallBuilder
 }
 
-func NewVM(base cid.Cid, height uint64, r Rand, maddr address.Address, cbs blockstore.Blockstore) (*VM, error) {
-	buf := bufbstore.NewBufferedBstore(cbs)
-	cst := hamt.CSTFromBstore(buf)
-	state, err := state.LoadStateTree(cst, base)
+type VMOpts struct {
+	StateBase      cid.Cid
+	Epoch          abi.ChainEpoch
+	Rand           Rand
+	Bstore         bstore.Blockstore
+	Syscalls       SyscallBuilder
+	CircSupplyCalc CircSupplyCalculator
+	NtwkVersion    NtwkVersionGetter // TODO: stebalien: In what cases do we actually need this? It seems like even when creating new networks we want to use the 'global'/build-default version getter
+	BaseFee        abi.TokenAmount
+}
+
+func NewVM(ctx context.Context, opts *VMOpts) (*VM, error) {
+	buf := bufbstore.NewBufferedBstore(opts.Bstore)
+	cst := cbor.NewCborStore(buf)
+	state, err := state.LoadStateTree(cst, opts.StateBase)
 	if err != nil {
 		return nil, err
 	}
 
 	return &VM{
-		cstate:      state,
-		base:        base,
-		cst:         cst,
-		buf:         buf,
-		blockHeight: height,
-		blockMiner:  maddr,
-		inv:         newInvoker(),
-		rand:        r,
-		Syscalls:    DefaultSyscalls(),
+		cstate:         state,
+		base:           opts.StateBase,
+		cst:            cst,
+		buf:            buf,
+		blockHeight:    opts.Epoch,
+		inv:            NewInvoker(),
+		rand:           opts.Rand, // TODO: Probably should be a syscall
+		circSupplyCalc: opts.CircSupplyCalc,
+		ntwkVersion:    opts.NtwkVersion,
+		Syscalls:       opts.Syscalls,
+		baseFee:        opts.BaseFee,
 	}, nil
 }
 
 type Rand interface {
-	GetRandomness(ctx context.Context, h int64) ([]byte, error)
+	GetChainRandomness(ctx context.Context, pers crypto.DomainSeparationTag, round abi.ChainEpoch, entropy []byte) ([]byte, error)
+	GetBeaconRandomness(ctx context.Context, pers crypto.DomainSeparationTag, round abi.ChainEpoch, entropy []byte) ([]byte, error)
 }
 
 type ApplyRet struct {
 	types.MessageReceipt
-	ActorErr aerrors.ActorError
+	ActorErr       aerrors.ActorError
+	ExecutionTrace types.ExecutionTrace
+	Duration       time.Duration
+	GasCosts       GasOutputs
 }
 
-func (vm *VM) send(ctx context.Context, msg *types.Message, parent *VMContext,
-	gasCharge uint64) ([]byte, aerrors.ActorError, *VMContext) {
+func (vm *VM) send(ctx context.Context, msg *types.Message, parent *Runtime,
+	gasCharge *GasCharge, start time.Time) ([]byte, aerrors.ActorError, *Runtime) {
+
+	defer atomic.AddUint64(&StatSends, 1)
 
 	st := vm.cstate
-	fromActor, err := st.GetActor(msg.From)
-	if err != nil {
-		return nil, aerrors.Absorb(err, 1, "could not find source actor"), nil
-	}
 
-	toActor, err := st.GetActor(msg.To)
-	if err != nil {
-		if xerrors.Is(err, types.ErrActorNotFound) {
-			a, err := TryCreateAccountActor(st, msg.To)
-			if err != nil {
-				return nil, aerrors.Absorb(err, 1, "could not create account"), nil
-			}
-			toActor = a
-		} else {
-			return nil, aerrors.Escalate(err, "getting actor"), nil
-		}
-	}
-
-	gasUsed := types.NewInt(gasCharge)
 	origin := msg.From
+	on := msg.Nonce
+	var nac uint64 = 0
+	var gasUsed int64
 	if parent != nil {
-		gasUsed = types.BigAdd(parent.gasUsed, gasUsed)
+		gasUsed = parent.gasUsed
 		origin = parent.origin
+		on = parent.originNonce
+		nac = parent.numActorsCreated
 	}
-	vmctx := vm.makeVMContext(ctx, toActor.Head, msg, origin, gasUsed)
+
+	rt := vm.makeRuntime(ctx, msg, origin, on, gasUsed, nac)
+	rt.lastGasChargeTime = start
 	if parent != nil {
+		rt.lastGasChargeTime = parent.lastGasChargeTime
+		rt.lastGasCharge = parent.lastGasCharge
 		defer func() {
-			parent.gasUsed = vmctx.gasUsed
+			parent.gasUsed = rt.gasUsed
+			parent.lastGasChargeTime = rt.lastGasChargeTime
+			parent.lastGasCharge = rt.lastGasCharge
 		}()
 	}
-
-	if types.BigCmp(msg.Value, types.NewInt(0)) != 0 {
-		if aerr := vmctx.ChargeGas(gasFundTransfer); aerr != nil {
-			return nil, aerrors.Wrap(aerr, "sending funds"), nil
-		}
-
-		if err := Transfer(fromActor, toActor, msg.Value); err != nil {
-			return nil, aerrors.Absorb(err, 1, "failed to transfer funds"), nil
+	if gasCharge != nil {
+		if err := rt.chargeGasSafe(*gasCharge); err != nil {
+			// this should never happen
+			return nil, aerrors.Wrap(err, "not enough gas for initial message charge, this should not happen"), rt
 		}
 	}
 
-	if msg.Method != 0 {
-		ret, err := vm.Invoke(toActor, vmctx, msg.Method, msg.Params)
-		if !aerrors.IsFatal(err) {
-			toActor.Head = vmctx.Storage().GetHead()
+	ret, err := func() ([]byte, aerrors.ActorError) {
+		_ = rt.chargeGasSafe(newGasCharge("OnGetActor", 0, 0))
+		toActor, err := st.GetActor(msg.To)
+		if err != nil {
+			if xerrors.Is(err, types.ErrActorNotFound) {
+				a, err := TryCreateAccountActor(rt, msg.To)
+				if err != nil {
+					return nil, aerrors.Wrapf(err, "could not create account")
+				}
+				toActor = a
+			} else {
+				return nil, aerrors.Escalate(err, "getting actor")
+			}
 		}
-		return ret, err, vmctx
+
+		if aerr := rt.chargeGasSafe(rt.Pricelist().OnMethodInvocation(msg.Value, msg.Method)); aerr != nil {
+			return nil, aerrors.Wrap(aerr, "not enough gas for method invocation")
+		}
+
+		// not charging any gas, just logging
+		//nolint:errcheck
+		defer rt.chargeGasSafe(newGasCharge("OnMethodInvocationDone", 0, 0))
+
+		if types.BigCmp(msg.Value, types.NewInt(0)) != 0 {
+			if err := vm.transfer(msg.From, msg.To, msg.Value); err != nil {
+				return nil, aerrors.Wrap(err, "failed to transfer funds")
+			}
+		}
+
+		if msg.Method != 0 {
+			var ret []byte
+			_ = rt.chargeGasSafe(gasOnActorExec)
+			ret, err := vm.Invoke(toActor, rt, msg.Method, msg.Params)
+			return ret, err
+		}
+		return nil, nil
+	}()
+
+	mr := types.MessageReceipt{
+		ExitCode: aerrors.RetCode(err),
+		Return:   ret,
+		GasUsed:  rt.gasUsed,
+	}
+	rt.executionTrace.MsgRct = &mr
+	rt.executionTrace.Duration = time.Since(start)
+	if err != nil {
+		rt.executionTrace.Error = err.Error()
 	}
 
-	return nil, nil, vmctx
+	return ret, err, rt
 }
 
 func checkMessage(msg *types.Message) error {
-	if msg.GasLimit == types.EmptyInt {
-		return xerrors.Errorf("message gas no gas limit set")
+	if msg.GasLimit == 0 {
+		return xerrors.Errorf("message has no gas limit set")
+	}
+	if msg.GasLimit < 0 {
+		return xerrors.Errorf("message has negative gas limit")
 	}
 
-	if msg.GasPrice == types.EmptyInt {
-		return xerrors.Errorf("message gas no gas price set")
+	if msg.GasFeeCap == types.EmptyInt {
+		return xerrors.Errorf("message fee cap not set")
+	}
+
+	if msg.GasPremium == types.EmptyInt {
+		return xerrors.Errorf("message gas premium not set")
 	}
 
 	if msg.Value == types.EmptyInt {
@@ -411,9 +319,30 @@ func checkMessage(msg *types.Message) error {
 	return nil
 }
 
-func (vm *VM) ApplyMessage(ctx context.Context, msg *types.Message) (*ApplyRet, error) {
+func (vm *VM) ApplyImplicitMessage(ctx context.Context, msg *types.Message) (*ApplyRet, error) {
+	start := build.Clock.Now()
+	defer atomic.AddUint64(&StatApplied, 1)
+	ret, actorErr, rt := vm.send(ctx, msg, nil, nil, start)
+	rt.finilizeGasTracing()
+	return &ApplyRet{
+		MessageReceipt: types.MessageReceipt{
+			ExitCode: aerrors.RetCode(actorErr),
+			Return:   ret,
+			GasUsed:  0,
+		},
+		ActorErr:       actorErr,
+		ExecutionTrace: rt.executionTrace,
+		GasCosts:       GasOutputs{},
+		Duration:       time.Since(start),
+	}, actorErr
+}
+
+func (vm *VM) ApplyMessage(ctx context.Context, cmsg types.ChainMsg) (*ApplyRet, error) {
+	start := build.Clock.Now()
 	ctx, span := trace.StartSpan(ctx, "vm.ApplyMessage")
 	defer span.End()
+	defer atomic.AddUint64(&StatApplied, 1)
+	msg := cmsg.VMMessage()
 	if span.IsRecordingEvents() {
 		span.AddAttributes(
 			trace.StringAttribute("to", msg.To.String()),
@@ -426,77 +355,170 @@ func (vm *VM) ApplyMessage(ctx context.Context, msg *types.Message) (*ApplyRet,
 		return nil, err
 	}
 
+	pl := PricelistByEpoch(vm.blockHeight)
+
+	msgGas := pl.OnChainMessage(cmsg.ChainLength())
+	msgGasCost := msgGas.Total()
+	// this should never happen, but is currently still exercised by some tests
+	if msgGasCost > msg.GasLimit {
+		gasOutputs := ZeroGasOutputs()
+		gasOutputs.MinerPenalty = types.BigMul(vm.baseFee, abi.NewTokenAmount(msgGasCost))
+		return &ApplyRet{
+			MessageReceipt: types.MessageReceipt{
+				ExitCode: exitcode.SysErrOutOfGas,
+				GasUsed:  0,
+			},
+			GasCosts: gasOutputs,
+			Duration: time.Since(start),
+		}, nil
+	}
+
 	st := vm.cstate
-	if err := st.Snapshot(); err != nil {
-		return nil, xerrors.Errorf("snapshot failed: %w", err)
-	}
 
+	minerPenaltyAmount := types.BigMul(vm.baseFee, abi.NewTokenAmount(msg.GasLimit))
 	fromActor, err := st.GetActor(msg.From)
+	// this should never happen, but is currently still exercised by some tests
 	if err != nil {
-		return nil, xerrors.Errorf("from actor not found: %w", err)
+		if xerrors.Is(err, types.ErrActorNotFound) {
+			gasOutputs := ZeroGasOutputs()
+			gasOutputs.MinerPenalty = minerPenaltyAmount
+			return &ApplyRet{
+				MessageReceipt: types.MessageReceipt{
+					ExitCode: exitcode.SysErrSenderInvalid,
+					GasUsed:  0,
+				},
+				ActorErr: aerrors.Newf(exitcode.SysErrSenderInvalid, "actor not found: %s", msg.From),
+				GasCosts: gasOutputs,
+				Duration: time.Since(start),
+			}, nil
+		}
+		return nil, xerrors.Errorf("failed to look up from actor: %w", err)
 	}
 
-	serMsg, err := msg.Serialize()
-	if err != nil {
-		return nil, xerrors.Errorf("could not serialize message: %w", err)
-	}
-	msgGasCost := uint64(len(serMsg)) * gasPerMessageByte
-
-	gascost := types.BigMul(msg.GasLimit, msg.GasPrice)
-	totalCost := types.BigAdd(gascost, msg.Value)
-	if fromActor.Balance.LessThan(totalCost) {
-		return nil, xerrors.Errorf("not enough funds (%s < %s)", fromActor.Balance, totalCost)
-	}
-
-	gasHolder := &types.Actor{Balance: types.NewInt(0)}
-	if err := Transfer(fromActor, gasHolder, gascost); err != nil {
-		return nil, xerrors.Errorf("failed to withdraw gas funds: %w", err)
+	// this should never happen, but is currently still exercised by some tests
+	if !fromActor.IsAccountActor() {
+		gasOutputs := ZeroGasOutputs()
+		gasOutputs.MinerPenalty = minerPenaltyAmount
+		return &ApplyRet{
+			MessageReceipt: types.MessageReceipt{
+				ExitCode: exitcode.SysErrSenderInvalid,
+				GasUsed:  0,
+			},
+			ActorErr: aerrors.Newf(exitcode.SysErrSenderInvalid, "send from not account actor: %s", fromActor.Code),
+			GasCosts: gasOutputs,
+			Duration: time.Since(start),
+		}, nil
 	}
 
 	if msg.Nonce != fromActor.Nonce {
-		return nil, xerrors.Errorf("invalid nonce (got %d, expected %d)", msg.Nonce, fromActor.Nonce)
+		gasOutputs := ZeroGasOutputs()
+		gasOutputs.MinerPenalty = minerPenaltyAmount
+		return &ApplyRet{
+			MessageReceipt: types.MessageReceipt{
+				ExitCode: exitcode.SysErrSenderStateInvalid,
+				GasUsed:  0,
+			},
+			ActorErr: aerrors.Newf(exitcode.SysErrSenderStateInvalid,
+				"actor nonce invalid: msg:%d != state:%d", msg.Nonce, fromActor.Nonce),
+
+			GasCosts: gasOutputs,
+			Duration: time.Since(start),
+		}, nil
 	}
-	fromActor.Nonce++
 
-	ret, actorErr, vmctx := vm.send(ctx, msg, nil, msgGasCost)
+	gascost := types.BigMul(types.NewInt(uint64(msg.GasLimit)), msg.GasFeeCap)
+	if fromActor.Balance.LessThan(gascost) {
+		gasOutputs := ZeroGasOutputs()
+		gasOutputs.MinerPenalty = minerPenaltyAmount
+		return &ApplyRet{
+			MessageReceipt: types.MessageReceipt{
+				ExitCode: exitcode.SysErrSenderStateInvalid,
+				GasUsed:  0,
+			},
+			ActorErr: aerrors.Newf(exitcode.SysErrSenderStateInvalid,
+				"actor balance less than needed: %s < %s", types.FIL(fromActor.Balance), types.FIL(gascost)),
+			GasCosts: gasOutputs,
+			Duration: time.Since(start),
+		}, nil
+	}
 
+	gasHolder := &types.Actor{Balance: types.NewInt(0)}
+	if err := vm.transferToGasHolder(msg.From, gasHolder, gascost); err != nil {
+		return nil, xerrors.Errorf("failed to withdraw gas funds: %w", err)
+	}
+
+	if err := vm.incrementNonce(msg.From); err != nil {
+		return nil, err
+	}
+
+	if err := st.Snapshot(ctx); err != nil {
+		return nil, xerrors.Errorf("snapshot failed: %w", err)
+	}
+	defer st.ClearSnapshot()
+
+	ret, actorErr, rt := vm.send(ctx, msg, nil, &msgGas, start)
 	if aerrors.IsFatal(actorErr) {
 		return nil, xerrors.Errorf("[from=%s,to=%s,n=%d,m=%d,h=%d] fatal error: %w", msg.From, msg.To, msg.Nonce, msg.Method, vm.blockHeight, actorErr)
 	}
+
 	if actorErr != nil {
-		log.Warnf("[from=%s,to=%s,n=%d,m=%d,h=%d] Send actor error: %+v", msg.From, msg.To, msg.Nonce, msg.Method, vm.blockHeight, actorErr)
+		log.Warnw("Send actor error", "from", msg.From, "to", msg.To, "nonce", msg.Nonce, "method", msg.Method, "height", vm.blockHeight, "error", fmt.Sprintf("%+v", actorErr))
 	}
 
-	var errcode uint8
-	var gasUsed types.BigInt
+	if actorErr != nil && len(ret) != 0 {
+		// This should not happen, something is wonky
+		return nil, xerrors.Errorf("message invocation errored, but had a return value anyway: %w", actorErr)
+	}
+
+	if rt == nil {
+		return nil, xerrors.Errorf("send returned nil runtime, send error was: %s", actorErr)
+	}
+
+	if len(ret) != 0 {
+		// safely override actorErr since it must be nil
+		actorErr = rt.chargeGasSafe(rt.Pricelist().OnChainReturnValue(len(ret)))
+		if actorErr != nil {
+			ret = nil
+		}
+	}
+
+	var errcode exitcode.ExitCode
+	var gasUsed int64
 
 	if errcode = aerrors.RetCode(actorErr); errcode != 0 {
-		gasUsed = msg.GasLimit
 		// revert all state changes since snapshot
 		if err := st.Revert(); err != nil {
 			return nil, xerrors.Errorf("revert state failed: %w", err)
 		}
-	} else {
-		// refund unused gas
-		gasUsed = vmctx.GasUsed()
-		refund := types.BigMul(types.BigSub(msg.GasLimit, gasUsed), msg.GasPrice)
-		if err := Transfer(gasHolder, fromActor, refund); err != nil {
-			return nil, xerrors.Errorf("failed to refund gas")
-		}
 	}
 
-	miner, err := st.GetActor(vm.blockMiner)
-	if err != nil {
-		return nil, xerrors.Errorf("getting block miner actor (%s) failed: %w", vm.blockMiner, err)
+	rt.finilizeGasTracing()
+
+	gasUsed = rt.gasUsed
+	if gasUsed < 0 {
+		gasUsed = 0
+	}
+	gasOutputs := ComputeGasOutputs(gasUsed, msg.GasLimit, vm.baseFee, msg.GasFeeCap, msg.GasPremium)
+
+	if err := vm.transferFromGasHolder(builtin.BurntFundsActorAddr, gasHolder,
+		gasOutputs.BaseFeeBurn); err != nil {
+		return nil, xerrors.Errorf("failed to burn base fee: %w", err)
 	}
 
-	// TODO: support multiple blocks in a tipset
-	// TODO: actually wire this up (miner is undef for now)
-	gasReward := types.BigMul(msg.GasPrice, gasUsed)
-	if err := Transfer(gasHolder, miner, gasReward); err != nil {
+	if err := vm.transferFromGasHolder(reward.Address, gasHolder, gasOutputs.MinerTip); err != nil {
 		return nil, xerrors.Errorf("failed to give miner gas reward: %w", err)
 	}
 
+	if err := vm.transferFromGasHolder(builtin.BurntFundsActorAddr, gasHolder,
+		gasOutputs.OverEstimationBurn); err != nil {
+		return nil, xerrors.Errorf("failed to burn overestimation fee: %w", err)
+	}
+
+	// refund unused gas
+	if err := vm.transferFromGasHolder(msg.From, gasHolder, gasOutputs.Refund); err != nil {
+		return nil, xerrors.Errorf("failed to refund gas: %w", err)
+	}
+
 	if types.BigCmp(types.NewInt(0), gasHolder.Balance) != 0 {
 		return nil, xerrors.Errorf("gas handling math is wrong")
 	}
@@ -507,14 +529,13 @@ func (vm *VM) ApplyMessage(ctx context.Context, msg *types.Message) (*ApplyRet,
 			Return:   ret,
 			GasUsed:  gasUsed,
 		},
-		ActorErr: actorErr,
+		ActorErr:       actorErr,
+		ExecutionTrace: rt.executionTrace,
+		GasCosts:       gasOutputs,
+		Duration:       time.Since(start),
 	}, nil
 }
 
-func (vm *VM) SetBlockMiner(m address.Address) {
-	vm.blockMiner = m
-}
-
 func (vm *VM) ActorBalance(addr address.Address) (types.BigInt, aerrors.ActorError) {
 	act, err := vm.cstate.GetActor(addr)
 	if err != nil {
@@ -531,30 +552,77 @@ func (vm *VM) Flush(ctx context.Context) (cid.Cid, error) {
 	from := vm.buf
 	to := vm.buf.Read()
 
-	root, err := vm.cstate.Flush()
+	root, err := vm.cstate.Flush(ctx)
 	if err != nil {
 		return cid.Undef, xerrors.Errorf("flushing vm: %w", err)
 	}
 
-	if err := Copy(from, to, root); err != nil {
+	if err := Copy(ctx, from, to, root); err != nil {
 		return cid.Undef, xerrors.Errorf("copying tree: %w", err)
 	}
 
 	return root, nil
 }
 
-func linksForObj(blk block.Block) ([]cid.Cid, error) {
+// MutateState usage: MutateState(ctx, idAddr, func(cst cbor.IpldStore, st *ActorStateType) error {...})
+func (vm *VM) MutateState(ctx context.Context, addr address.Address, fn interface{}) error {
+	act, err := vm.cstate.GetActor(addr)
+	if err != nil {
+		return xerrors.Errorf("actor not found: %w", err)
+	}
+
+	st := reflect.New(reflect.TypeOf(fn).In(1).Elem())
+	if err := vm.cst.Get(ctx, act.Head, st.Interface()); err != nil {
+		return xerrors.Errorf("read actor head: %w", err)
+	}
+
+	out := reflect.ValueOf(fn).Call([]reflect.Value{reflect.ValueOf(vm.cst), st})
+	if !out[0].IsNil() && out[0].Interface().(error) != nil {
+		return out[0].Interface().(error)
+	}
+
+	head, err := vm.cst.Put(ctx, st.Interface())
+	if err != nil {
+		return xerrors.Errorf("put new actor head: %w", err)
+	}
+
+	act.Head = head
+
+	if err := vm.cstate.SetActor(addr, act); err != nil {
+		return xerrors.Errorf("set actor: %w", err)
+	}
+
+	return nil
+}
+
+func linksForObj(blk block.Block, cb func(cid.Cid)) error {
 	switch blk.Cid().Prefix().Codec {
 	case cid.DagCBOR:
-		return cbg.ScanForLinks(bytes.NewReader(blk.RawData()))
+		err := cbg.ScanForLinks(bytes.NewReader(blk.RawData()), cb)
+		if err != nil {
+			return xerrors.Errorf("cbg.ScanForLinks: %w", err)
+		}
+		return nil
+	case cid.Raw:
+		// We implicitly have all children of raw blocks.
+		return nil
 	default:
-		return nil, xerrors.Errorf("vm flush copy method only supports dag cbor")
+		return xerrors.Errorf("vm flush copy method only supports dag cbor")
 	}
 }
 
-func Copy(from, to blockstore.Blockstore, root cid.Cid) error {
+func Copy(ctx context.Context, from, to blockstore.Blockstore, root cid.Cid) error {
+	ctx, span := trace.StartSpan(ctx, "vm.Copy") // nolint
+	defer span.End()
+
+	var numBlocks int
+	var totalCopySize int
+
 	var batch []block.Block
 	batchCp := func(blk block.Block) error {
+		numBlocks++
+		totalCopySize += len(blk.RawData())
+
 		batch = append(batch, blk)
 		if len(batch) > 100 {
 			if err := to.PutMany(batch); err != nil {
@@ -566,7 +634,7 @@ func Copy(from, to blockstore.Blockstore, root cid.Cid) error {
 	}
 
 	if err := copyRec(from, to, root, batchCp); err != nil {
-		return err
+		return xerrors.Errorf("copyRec: %w", err)
 	}
 
 	if len(batch) > 0 {
@@ -575,6 +643,11 @@ func Copy(from, to blockstore.Blockstore, root cid.Cid) error {
 		}
 	}
 
+	span.AddAttributes(
+		trace.Int64Attribute("numBlocks", int64(numBlocks)),
+		trace.Int64Attribute("copySize", int64(totalCopySize)),
+	)
+
 	return nil
 }
 
@@ -589,31 +662,50 @@ func copyRec(from, to blockstore.Blockstore, root cid.Cid, cp func(block.Block)
 		return xerrors.Errorf("get %s failed: %w", root, err)
 	}
 
-	links, err := linksForObj(blk)
-	if err != nil {
-		return err
-	}
-
-	for _, link := range links {
-		if link.Prefix().MhType == 0 {
-			continue
+	var lerr error
+	err = linksForObj(blk, func(link cid.Cid) {
+		if lerr != nil {
+			// Theres no erorr return on linksForObj callback :(
+			return
 		}
 
-		has, err := to.Has(link)
-		if err != nil {
-			return err
+		prefix := link.Prefix()
+		if prefix.Codec == cid.FilCommitmentSealed || prefix.Codec == cid.FilCommitmentUnsealed {
+			return
 		}
-		if has {
-			continue
+
+		// We always have blocks inlined into CIDs, but we may not have their children.
+		if prefix.MhType == mh.IDENTITY {
+			// Unless the inlined block has no children.
+			if prefix.Codec == cid.Raw {
+				return
+			}
+		} else {
+			// If we have an object, we already have its children, skip the object.
+			has, err := to.Has(link)
+			if err != nil {
+				lerr = xerrors.Errorf("has: %w", err)
+				return
+			}
+			if has {
+				return
+			}
 		}
 
 		if err := copyRec(from, to, link, cp); err != nil {
-			return err
+			lerr = err
+			return
 		}
+	})
+	if err != nil {
+		return xerrors.Errorf("linksForObj (%x): %w", blk.RawData(), err)
+	}
+	if lerr != nil {
+		return lerr
 	}
 
 	if err := cp(blk); err != nil {
-		return err
+		return xerrors.Errorf("copy: %w", err)
 	}
 	return nil
 }
@@ -622,52 +714,133 @@ func (vm *VM) StateTree() types.StateTree {
 	return vm.cstate
 }
 
-func (vm *VM) SetBlockHeight(h uint64) {
+func (vm *VM) SetBlockHeight(h abi.ChainEpoch) {
 	vm.blockHeight = h
 }
 
-func (vm *VM) Invoke(act *types.Actor, vmctx *VMContext, method uint64, params []byte) ([]byte, aerrors.ActorError) {
-	ctx, span := trace.StartSpan(vmctx.ctx, "vm.Invoke")
+func (vm *VM) Invoke(act *types.Actor, rt *Runtime, method abi.MethodNum, params []byte) ([]byte, aerrors.ActorError) {
+	ctx, span := trace.StartSpan(rt.ctx, "vm.Invoke")
 	defer span.End()
 	if span.IsRecordingEvents() {
 		span.AddAttributes(
-			trace.StringAttribute("to", vmctx.Message().To.String()),
+			trace.StringAttribute("to", rt.Receiver().String()),
 			trace.Int64Attribute("method", int64(method)),
-			trace.StringAttribute("value", vmctx.Message().Value.String()),
+			trace.StringAttribute("value", rt.ValueReceived().String()),
 		)
 	}
 
 	var oldCtx context.Context
-	oldCtx, vmctx.ctx = vmctx.ctx, ctx
+	oldCtx, rt.ctx = rt.ctx, ctx
 	defer func() {
-		vmctx.ctx = oldCtx
+		rt.ctx = oldCtx
 	}()
-	if err := vmctx.ChargeGas(gasInvoke); err != nil {
-		return nil, aerrors.Wrap(err, "invokeing")
-	}
-	ret, err := vm.inv.Invoke(act, vmctx, method, params)
+	ret, err := vm.inv.Invoke(act.Code, rt, method, params)
 	if err != nil {
 		return nil, err
 	}
 	return ret, nil
 }
 
-func Transfer(from, to *types.Actor, amt types.BigInt) error {
+func (vm *VM) SetInvoker(i *Invoker) {
+	vm.inv = i
+}
+
+func (vm *VM) GetNtwkVersion(ctx context.Context, ce abi.ChainEpoch) network.Version {
+	return vm.ntwkVersion(ctx, ce)
+}
+
+func (vm *VM) GetCircSupply(ctx context.Context) (abi.TokenAmount, error) {
+	return vm.circSupplyCalc(ctx, vm.blockHeight, vm.cstate)
+}
+
+func (vm *VM) incrementNonce(addr address.Address) error {
+	return vm.cstate.MutateActor(addr, func(a *types.Actor) error {
+		a.Nonce++
+		return nil
+	})
+}
+
+func (vm *VM) transfer(from, to address.Address, amt types.BigInt) aerrors.ActorError {
 	if from == to {
 		return nil
 	}
 
-	if amt.LessThan(types.NewInt(0)) {
-		return xerrors.Errorf("attempted to transfer negative value")
+	fromID, err := vm.cstate.LookupID(from)
+	if err != nil {
+		return aerrors.Fatalf("transfer failed when resolving sender address: %s", err)
 	}
 
-	if err := deductFunds(from, amt); err != nil {
-		return err
+	toID, err := vm.cstate.LookupID(to)
+	if err != nil {
+		return aerrors.Fatalf("transfer failed when resolving receiver address: %s", err)
 	}
-	depositFunds(to, amt)
+
+	if fromID == toID {
+		return nil
+	}
+
+	if amt.LessThan(types.NewInt(0)) {
+		return aerrors.Newf(exitcode.SysErrForbidden, "attempted to transfer negative value: %s", amt)
+	}
+
+	f, err := vm.cstate.GetActor(fromID)
+	if err != nil {
+		return aerrors.Fatalf("transfer failed when retrieving sender actor: %s", err)
+	}
+
+	t, err := vm.cstate.GetActor(toID)
+	if err != nil {
+		return aerrors.Fatalf("transfer failed when retrieving receiver actor: %s", err)
+	}
+
+	if err := deductFunds(f, amt); err != nil {
+		return aerrors.Newf(exitcode.SysErrInsufficientFunds, "transfer failed when deducting funds (%s): %s", types.FIL(amt), err)
+	}
+	depositFunds(t, amt)
+
+	if err := vm.cstate.SetActor(fromID, f); err != nil {
+		return aerrors.Fatalf("transfer failed when setting receiver actor: %s", err)
+	}
+
+	if err := vm.cstate.SetActor(toID, t); err != nil {
+		return aerrors.Fatalf("transfer failed when setting sender actor: %s", err)
+	}
+
 	return nil
 }
 
+func (vm *VM) transferToGasHolder(addr address.Address, gasHolder *types.Actor, amt types.BigInt) error {
+	if amt.LessThan(types.NewInt(0)) {
+		return xerrors.Errorf("attempted to transfer negative value to gas holder")
+	}
+
+	return vm.cstate.MutateActor(addr, func(a *types.Actor) error {
+		if err := deductFunds(a, amt); err != nil {
+			return err
+		}
+		depositFunds(gasHolder, amt)
+		return nil
+	})
+}
+
+func (vm *VM) transferFromGasHolder(addr address.Address, gasHolder *types.Actor, amt types.BigInt) error {
+	if amt.LessThan(types.NewInt(0)) {
+		return xerrors.Errorf("attempted to transfer negative value from gas holder")
+	}
+
+	if amt.Equals(big.NewInt(0)) {
+		return nil
+	}
+
+	return vm.cstate.MutateActor(addr, func(a *types.Actor) error {
+		if err := deductFunds(gasHolder, amt); err != nil {
+			return err
+		}
+		depositFunds(a, amt)
+		return nil
+	})
+}
+
 func deductFunds(act *types.Actor, amt types.BigInt) error {
 	if act.Balance.LessThan(amt) {
 		return fmt.Errorf("not enough funds")
@@ -680,16 +853,3 @@ func deductFunds(act *types.Actor, amt types.BigInt) error {
 func depositFunds(act *types.Actor, amt types.BigInt) {
 	act.Balance = types.BigAdd(act.Balance, amt)
 }
-
-var miningRewardTotal = types.FromFil(build.MiningRewardTotal)
-var blocksPerEpoch = types.NewInt(build.BlocksPerEpoch)
-
-// MiningReward returns correct mining reward
-//   coffer is amount of FIL in NetworkAddress
-func MiningReward(remainingReward types.BigInt) types.BigInt {
-	ci := big.NewInt(0).Set(remainingReward.Int)
-	res := ci.Mul(ci, build.InitialReward)
-	res = res.Div(res, miningRewardTotal.Int)
-	res = res.Div(res, blocksPerEpoch.Int)
-	return types.BigInt{res}
-}
diff --git a/chain/vm/vm_test.go b/chain/vm/vm_test.go
deleted file mode 100644
index 6ec007576..000000000
--- a/chain/vm/vm_test.go
+++ /dev/null
@@ -1,30 +0,0 @@
-package vm
-
-import (
-	"fmt"
-	"math/big"
-	"testing"
-
-	"github.com/filecoin-project/lotus/build"
-	"github.com/filecoin-project/lotus/chain/types"
-)
-
-const HalvingPeriodEpochs = 6 * 365 * 24 * 60 * 2
-
-func TestBlockReward(t *testing.T) {
-	coffer := types.FromFil(build.MiningRewardTotal).Int
-	sum := new(big.Int)
-	N := HalvingPeriodEpochs
-	for i := 0; i < N; i++ {
-		a := MiningReward(types.BigInt{coffer})
-		sum = sum.Add(sum, a.Int)
-		coffer = coffer.Sub(coffer, a.Int)
-	}
-
-	//sum = types.BigMul(sum, types.NewInt(60))
-
-	fmt.Println("After a halving period")
-	fmt.Printf("Total reward: %d\n", build.MiningRewardTotal)
-	fmt.Printf("Remaining: %s\n", types.BigDiv(types.BigInt{coffer}, types.NewInt(build.FilecoinPrecision)))
-	fmt.Printf("Given out: %s\n", types.BigDiv(types.BigInt{sum}, types.NewInt(build.FilecoinPrecision)))
-}
diff --git a/chain/wallet/wallet.go b/chain/wallet/wallet.go
index 9472d36e0..7cdb1929e 100644
--- a/chain/wallet/wallet.go
+++ b/chain/wallet/wallet.go
@@ -2,27 +2,31 @@ package wallet
 
 import (
 	"context"
-	"fmt"
 	"sort"
 	"strings"
 	"sync"
 
-	bls "github.com/filecoin-project/filecoin-ffi"
-
-	logging "github.com/ipfs/go-log"
-	"github.com/minio/blake2b-simd"
+	"github.com/filecoin-project/go-state-types/crypto"
+	logging "github.com/ipfs/go-log/v2"
 	"golang.org/x/xerrors"
 
 	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-crypto"
+
+	_ "github.com/filecoin-project/lotus/lib/sigs/bls"  // enable bls signatures
+	_ "github.com/filecoin-project/lotus/lib/sigs/secp" // enable secp signatures
+
 	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/lib/sigs"
 )
 
 var log = logging.Logger("wallet")
 
 const (
-	KNamePrefix = "wallet-"
-	KDefault    = "default"
+	KNamePrefix  = "wallet-"
+	KTrashPrefix = "trash-"
+	KDefault     = "default"
+	KTBLS        = "bls"
+	KTSecp256k1  = "secp256k1"
 )
 
 type Wallet struct {
@@ -52,7 +56,7 @@ func KeyWallet(keys ...*Key) *Wallet {
 	}
 }
 
-func (w *Wallet) Sign(ctx context.Context, addr address.Address, msg []byte) (*types.Signature, error) {
+func (w *Wallet) Sign(ctx context.Context, addr address.Address, msg []byte) (*crypto.Signature, error) {
 	ki, err := w.findKey(addr)
 	if err != nil {
 		return nil, err
@@ -61,31 +65,7 @@ func (w *Wallet) Sign(ctx context.Context, addr address.Address, msg []byte) (*t
 		return nil, xerrors.Errorf("signing using key '%s': %w", addr.String(), types.ErrKeyInfoNotFound)
 	}
 
-	switch ki.Type {
-	case types.KTSecp256k1:
-		b2sum := blake2b.Sum256(msg)
-		sig, err := crypto.Sign(ki.PrivateKey, b2sum[:])
-		if err != nil {
-			return nil, err
-		}
-
-		return &types.Signature{
-			Type: types.KTSecp256k1,
-			Data: sig,
-		}, nil
-	case types.KTBLS:
-		var pk bls.PrivateKey
-		copy(pk[:], ki.PrivateKey)
-		sig := bls.PrivateKeySign(pk, msg)
-
-		return &types.Signature{
-			Type: types.KTBLS,
-			Data: sig[:],
-		}, nil
-
-	default:
-		return nil, fmt.Errorf("cannot sign with unsupported key type: %q", ki.Type)
-	}
+	return sigs.Sign(ActSigType(ki.Type), ki.PrivateKey, msg)
 }
 
 func (w *Wallet) findKey(addr address.Address) (*Key, error) {
@@ -203,33 +183,19 @@ func (w *Wallet) SetDefault(a address.Address) error {
 	return nil
 }
 
-func GenerateKey(typ string) (*Key, error) {
-	switch typ {
-	case types.KTSecp256k1:
-		priv, err := crypto.GenerateKey()
-		if err != nil {
-			return nil, err
-		}
-		ki := types.KeyInfo{
-			Type:       typ,
-			PrivateKey: priv,
-		}
-
-		return NewKey(ki)
-	case types.KTBLS:
-		priv := bls.PrivateKeyGenerate()
-		ki := types.KeyInfo{
-			Type:       typ,
-			PrivateKey: priv[:],
-		}
-
-		return NewKey(ki)
-	default:
-		return nil, xerrors.Errorf("invalid key type: %s", typ)
+func GenerateKey(typ crypto.SigType) (*Key, error) {
+	pk, err := sigs.Generate(typ)
+	if err != nil {
+		return nil, err
 	}
+	ki := types.KeyInfo{
+		Type:       kstoreSigType(typ),
+		PrivateKey: pk,
+	}
+	return NewKey(ki)
 }
 
-func (w *Wallet) GenerateKey(typ string) (address.Address, error) {
+func (w *Wallet) GenerateKey(typ crypto.SigType) (address.Address, error) {
 	w.lk.Lock()
 	defer w.lk.Unlock()
 
@@ -265,6 +231,23 @@ func (w *Wallet) HasKey(addr address.Address) (bool, error) {
 	return k != nil, nil
 }
 
+func (w *Wallet) DeleteKey(addr address.Address) error {
+	k, err := w.findKey(addr)
+	if err != nil {
+		return xerrors.Errorf("failed to delete key %s : %w", addr, err)
+	}
+
+	if err := w.keystore.Put(KTrashPrefix+k.Address.String(), k.KeyInfo); err != nil {
+		return xerrors.Errorf("failed to mark key %s as trashed: %w", addr, err)
+	}
+
+	if err := w.keystore.Delete(KNamePrefix + k.Address.String()); err != nil {
+		return xerrors.Errorf("failed to delete key %s: %w", addr, err)
+	}
+
+	return nil
+}
+
 type Key struct {
 	types.KeyInfo
 
@@ -277,31 +260,48 @@ func NewKey(keyinfo types.KeyInfo) (*Key, error) {
 		KeyInfo: keyinfo,
 	}
 
-	switch k.Type {
-	case types.KTSecp256k1:
-		k.PublicKey = crypto.PublicKey(k.PrivateKey)
+	var err error
+	k.PublicKey, err = sigs.ToPublic(ActSigType(k.Type), k.PrivateKey)
+	if err != nil {
+		return nil, err
+	}
 
-		var err error
+	switch k.Type {
+	case KTSecp256k1:
 		k.Address, err = address.NewSecp256k1Address(k.PublicKey)
 		if err != nil {
 			return nil, xerrors.Errorf("converting Secp256k1 to address: %w", err)
 		}
-
-	case types.KTBLS:
-		var pk bls.PrivateKey
-		copy(pk[:], k.PrivateKey)
-		pub := bls.PrivateKeyPublicKey(pk)
-		k.PublicKey = pub[:]
-
-		var err error
+	case KTBLS:
 		k.Address, err = address.NewBLSAddress(k.PublicKey)
 		if err != nil {
 			return nil, xerrors.Errorf("converting BLS to address: %w", err)
 		}
-
 	default:
 		return nil, xerrors.Errorf("unknown key type")
 	}
 	return k, nil
 
 }
+
+func kstoreSigType(typ crypto.SigType) string {
+	switch typ {
+	case crypto.SigTypeBLS:
+		return KTBLS
+	case crypto.SigTypeSecp256k1:
+		return KTSecp256k1
+	default:
+		return ""
+	}
+}
+
+func ActSigType(typ string) crypto.SigType {
+	switch typ {
+	case KTBLS:
+		return crypto.SigTypeBLS
+	case KTSecp256k1:
+		return crypto.SigTypeSecp256k1
+	default:
+		return 0
+	}
+}
diff --git a/cli/auth.go b/cli/auth.go
index b912dda4b..ba20b2bcc 100644
--- a/cli/auth.go
+++ b/cli/auth.go
@@ -1,12 +1,15 @@
 package cli
 
 import (
-	"errors"
 	"fmt"
 
-	"gopkg.in/urfave/cli.v2"
+	"github.com/urfave/cli/v2"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-jsonrpc/auth"
 
 	"github.com/filecoin-project/lotus/api/apistruct"
+	"github.com/filecoin-project/lotus/node/repo"
 )
 
 var authCmd = &cli.Command{
@@ -14,6 +17,7 @@ var authCmd = &cli.Command{
 	Usage: "Manage RPC permissions",
 	Subcommands: []*cli.Command{
 		authCreateAdminToken,
+		authApiInfoToken,
 	},
 }
 
@@ -37,13 +41,13 @@ var authCreateAdminToken = &cli.Command{
 		ctx := ReqContext(cctx)
 
 		if !cctx.IsSet("perm") {
-			return errors.New("--perm flag not set")
+			return xerrors.New("--perm flag not set")
 		}
 
 		perm := cctx.String("perm")
 		idx := 0
 		for i, p := range apistruct.AllPermissions {
-			if perm == p {
+			if auth.Permission(perm) == p {
 				idx = i + 1
 			}
 		}
@@ -64,3 +68,66 @@ var authCreateAdminToken = &cli.Command{
 		return nil
 	},
 }
+
+var authApiInfoToken = &cli.Command{
+	Name:  "api-info",
+	Usage: "Get token with API info required to connect to this node",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:  "perm",
+			Usage: "permission to assign to the token, one of: read, write, sign, admin",
+		},
+	},
+
+	Action: func(cctx *cli.Context) error {
+		napi, closer, err := GetAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+
+		ctx := ReqContext(cctx)
+
+		if !cctx.IsSet("perm") {
+			return xerrors.New("--perm flag not set")
+		}
+
+		perm := cctx.String("perm")
+		idx := 0
+		for i, p := range apistruct.AllPermissions {
+			if auth.Permission(perm) == p {
+				idx = i + 1
+			}
+		}
+
+		if idx == 0 {
+			return fmt.Errorf("--perm flag has to be one of: %s", apistruct.AllPermissions)
+		}
+
+		// slice on [:idx] so for example: 'sign' gives you [read, write, sign]
+		token, err := napi.AuthNew(ctx, apistruct.AllPermissions[:idx])
+		if err != nil {
+			return err
+		}
+
+		ti, ok := cctx.App.Metadata["repoType"]
+		if !ok {
+			log.Errorf("unknown repo type, are you sure you want to use GetAPI?")
+			ti = repo.FullNode
+		}
+		t, ok := ti.(repo.RepoType)
+		if !ok {
+			log.Errorf("repoType type does not match the type of repo.RepoType")
+		}
+
+		ainfo, err := GetAPIInfo(cctx, t)
+		if err != nil {
+			return xerrors.Errorf("could not get API info: %w", err)
+		}
+
+		// TODO: Log in audit log when it is implemented
+
+		fmt.Printf("%s=%s:%s\n", envForRepo(t), string(token), ainfo.Addr)
+		return nil
+	},
+}
diff --git a/cli/chain.go b/cli/chain.go
index cb4133d49..73b25324b 100644
--- a/cli/chain.go
+++ b/cli/chain.go
@@ -1,17 +1,35 @@
 package cli
 
 import (
+	"bytes"
 	"context"
 	"encoding/json"
 	"fmt"
+	"os"
+	"os/exec"
+	"path"
+	"strconv"
 	"strings"
 	"time"
 
+	"github.com/filecoin-project/go-address"
+	cborutil "github.com/filecoin-project/go-cbor-util"
+	"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/account"
+	"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/power"
+	"github.com/filecoin-project/specs-actors/actors/util/adt"
 	cid "github.com/ipfs/go-cid"
+	"github.com/urfave/cli/v2"
+	cbg "github.com/whyrusleeping/cbor-gen"
 	"golang.org/x/xerrors"
-	"gopkg.in/urfave/cli.v2"
 
 	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/actors"
 	types "github.com/filecoin-project/lotus/chain/types"
 )
 
@@ -22,10 +40,16 @@ var chainCmd = &cli.Command{
 		chainHeadCmd,
 		chainGetBlock,
 		chainReadObjCmd,
+		chainDeleteObjCmd,
+		chainStatObjCmd,
 		chainGetMsgCmd,
 		chainSetHeadCmd,
 		chainListCmd,
 		chainGetCmd,
+		chainBisectCmd,
+		chainExportCmd,
+		slashConsensusFault,
+		chainGasPriceCmd,
 	},
 }
 
@@ -53,8 +77,9 @@ var chainHeadCmd = &cli.Command{
 }
 
 var chainGetBlock = &cli.Command{
-	Name:  "getblock",
-	Usage: "Get a block and print its details",
+	Name:      "getblock",
+	Usage:     "Get a block and print its details",
+	ArgsUsage: "[blockCid]",
 	Flags: []cli.Flag{
 		&cli.BoolFlag{
 			Name:  "raw",
@@ -143,8 +168,9 @@ func apiMsgCids(in []api.Message) []cid.Cid {
 }
 
 var chainReadObjCmd = &cli.Command{
-	Name:  "read-obj",
-	Usage: "Read the raw bytes of an object",
+	Name:      "read-obj",
+	Usage:     "Read the raw bytes of an object",
+	ArgsUsage: "[objectCid]",
 	Action: func(cctx *cli.Context) error {
 		api, closer, err := GetFullNodeAPI(cctx)
 		if err != nil {
@@ -168,9 +194,16 @@ var chainReadObjCmd = &cli.Command{
 	},
 }
 
-var chainGetMsgCmd = &cli.Command{
-	Name:  "getmessage",
-	Usage: "Get and print a message by its cid",
+var chainDeleteObjCmd = &cli.Command{
+	Name:        "delete-obj",
+	Usage:       "Delete an object from the chain blockstore",
+	Description: "WARNING: Removing wrong objects from the chain blockstore may lead to sync issues",
+	ArgsUsage:   "[objectCid]",
+	Flags: []cli.Flag{
+		&cli.BoolFlag{
+			Name: "really-do-it",
+		},
+	},
 	Action: func(cctx *cli.Context) error {
 		api, closer, err := GetFullNodeAPI(cctx)
 		if err != nil {
@@ -179,6 +212,88 @@ var chainGetMsgCmd = &cli.Command{
 		defer closer()
 		ctx := ReqContext(cctx)
 
+		c, err := cid.Decode(cctx.Args().First())
+		if err != nil {
+			return fmt.Errorf("failed to parse cid input: %s", err)
+		}
+
+		if !cctx.Bool("really-do-it") {
+			return xerrors.Errorf("pass the --really-do-it flag to proceed")
+		}
+
+		err = api.ChainDeleteObj(ctx, c)
+		if err != nil {
+			return err
+		}
+
+		fmt.Printf("Obj %s deleted\n", c.String())
+		return nil
+	},
+}
+
+var chainStatObjCmd = &cli.Command{
+	Name:      "stat-obj",
+	Usage:     "Collect size and ipld link counts for objs",
+	ArgsUsage: "[cid]",
+	Description: `Collect object size and ipld link count for an object.
+
+   When a base is provided it will be walked first, and all links visisted
+   will be ignored when the passed in object is walked.
+`,
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:  "base",
+			Usage: "ignore links found in this obj",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		api, closer, err := GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+		ctx := ReqContext(cctx)
+
+		obj, err := cid.Decode(cctx.Args().First())
+		if err != nil {
+			return fmt.Errorf("failed to parse cid input: %s", err)
+		}
+
+		base := cid.Undef
+		if cctx.IsSet("base") {
+			base, err = cid.Decode(cctx.String("base"))
+			if err != nil {
+				return err
+			}
+		}
+
+		stats, err := api.ChainStatObj(ctx, obj, base)
+		if err != nil {
+			return err
+		}
+
+		fmt.Printf("Links: %d\n", stats.Links)
+		fmt.Printf("Size: %s (%d)\n", types.SizeStr(types.NewInt(stats.Size)), stats.Size)
+		return nil
+	},
+}
+
+var chainGetMsgCmd = &cli.Command{
+	Name:      "getmessage",
+	Usage:     "Get and print a message by its cid",
+	ArgsUsage: "[messageCid]",
+	Action: func(cctx *cli.Context) error {
+		if !cctx.Args().Present() {
+			return fmt.Errorf("must pass a cid of a message to get")
+		}
+
+		api, closer, err := GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+		ctx := ReqContext(cctx)
+
 		c, err := cid.Decode(cctx.Args().First())
 		if err != nil {
 			return xerrors.Errorf("failed to parse cid input: %w", err)
@@ -212,8 +327,9 @@ var chainGetMsgCmd = &cli.Command{
 }
 
 var chainSetHeadCmd = &cli.Command{
-	Name:  "sethead",
-	Usage: "manually set the local nodes head tipset (Caution: normally only used for recovery)",
+	Name:      "sethead",
+	Usage:     "manually set the local nodes head tipset (Caution: normally only used for recovery)",
+	ArgsUsage: "[tipsetkey]",
 	Flags: []cli.Flag{
 		&cli.BoolFlag{
 			Name:  "genesis",
@@ -238,10 +354,10 @@ var chainSetHeadCmd = &cli.Command{
 			ts, err = api.ChainGetGenesis(ctx)
 		}
 		if ts == nil && cctx.IsSet("epoch") {
-			ts, err = api.ChainGetTipSetByHeight(ctx, cctx.Uint64("epoch"), nil)
+			ts, err = api.ChainGetTipSetByHeight(ctx, abi.ChainEpoch(cctx.Uint64("epoch")), types.EmptyTSK)
 		}
 		if ts == nil {
-			ts, err = parseTipSet(api, ctx, cctx.Args().Slice())
+			ts, err = parseTipSet(ctx, api, cctx.Args().Slice())
 		}
 		if err != nil {
 			return err
@@ -251,7 +367,7 @@ var chainSetHeadCmd = &cli.Command{
 			return fmt.Errorf("must pass cids for tipset to set as head")
 		}
 
-		if err := api.ChainSetHead(ctx, ts); err != nil {
+		if err := api.ChainSetHead(ctx, ts.Key()); err != nil {
 			return err
 		}
 
@@ -259,25 +375,6 @@ var chainSetHeadCmd = &cli.Command{
 	},
 }
 
-func parseTipSet(api api.FullNode, ctx context.Context, vals []string) (*types.TipSet, error) {
-	var headers []*types.BlockHeader
-	for _, c := range vals {
-		blkc, err := cid.Decode(c)
-		if err != nil {
-			return nil, err
-		}
-
-		bh, err := api.ChainGetBlock(ctx, blkc)
-		if err != nil {
-			return nil, err
-		}
-
-		headers = append(headers, bh)
-	}
-
-	return types.NewTipSet(headers)
-}
-
 var chainListCmd = &cli.Command{
 	Name:  "list",
 	Usage: "View a segment of the chain",
@@ -289,6 +386,10 @@ var chainListCmd = &cli.Command{
 			Usage: "specify the format to print out tipsets",
 			Value: "<height>: (<time>) <blocks>",
 		},
+		&cli.BoolFlag{
+			Name:  "gas-stats",
+			Usage: "view gas statistics for the chain",
+		},
 	},
 	Action: func(cctx *cli.Context) error {
 		api, closer, err := GetFullNodeAPI(cctx)
@@ -301,7 +402,7 @@ var chainListCmd = &cli.Command{
 		var head *types.TipSet
 
 		if cctx.IsSet("height") {
-			head, err = api.ChainGetTipSetByHeight(ctx, cctx.Uint64("height"), nil)
+			head, err = api.ChainGetTipSetByHeight(ctx, abi.ChainEpoch(cctx.Uint64("height")), types.EmptyTSK)
 		} else {
 			head, err = api.ChainHead(ctx)
 		}
@@ -330,25 +431,121 @@ var chainListCmd = &cli.Command{
 			tss = append(tss, head)
 		}
 
-		for i := len(tss) - 1; i >= 0; i-- {
-			printTipSet(cctx.String("format"), tss[i])
+		if cctx.Bool("gas-stats") {
+			otss := make([]*types.TipSet, 0, len(tss))
+			for i := len(tss) - 1; i >= 0; i-- {
+				otss = append(otss, tss[i])
+			}
+			tss = otss
+			for i, ts := range tss {
+				pbf := ts.Blocks()[0].ParentBaseFee
+				fmt.Printf("%d: %d blocks (baseFee: %s -> maxFee: %s)\n", ts.Height(), len(ts.Blocks()), ts.Blocks()[0].ParentBaseFee, types.FIL(types.BigMul(pbf, types.NewInt(uint64(build.BlockGasLimit)))))
+
+				for _, b := range ts.Blocks() {
+					msgs, err := api.ChainGetBlockMessages(ctx, b.Cid())
+					if err != nil {
+						return err
+					}
+					var limitSum int64
+					psum := big.NewInt(0)
+					for _, m := range msgs.BlsMessages {
+						limitSum += m.GasLimit
+						psum = big.Add(psum, m.GasPremium)
+					}
+
+					for _, m := range msgs.SecpkMessages {
+						limitSum += m.Message.GasLimit
+						psum = big.Add(psum, m.Message.GasPremium)
+					}
+
+					lenmsgs := len(msgs.BlsMessages) + len(msgs.SecpkMessages)
+
+					avgpremium := big.Zero()
+					if lenmsgs > 0 {
+						avgpremium = big.Div(psum, big.NewInt(int64(lenmsgs)))
+					}
+
+					fmt.Printf("\t%s: \t%d msgs, gasLimit: %d / %d (%0.2f%%), avgPremium: %s\n", b.Miner, len(msgs.BlsMessages)+len(msgs.SecpkMessages), limitSum, build.BlockGasLimit, 100*float64(limitSum)/float64(build.BlockGasLimit), avgpremium)
+				}
+				if i < len(tss)-1 {
+					msgs, err := api.ChainGetParentMessages(ctx, tss[i+1].Blocks()[0].Cid())
+					if err != nil {
+						return err
+					}
+					var limitSum int64
+					for _, m := range msgs {
+						limitSum += m.Message.GasLimit
+					}
+
+					recpts, err := api.ChainGetParentReceipts(ctx, tss[i+1].Blocks()[0].Cid())
+					if err != nil {
+						return err
+					}
+
+					var gasUsed int64
+					for _, r := range recpts {
+						gasUsed += r.GasUsed
+					}
+
+					fmt.Printf("\ttipset: \t%d msgs, %d / %d (%0.2f%%)\n", len(msgs), gasUsed, limitSum, 100*float64(gasUsed)/float64(limitSum))
+				}
+				fmt.Println()
+			}
+		} else {
+			for i := len(tss) - 1; i >= 0; i-- {
+				printTipSet(cctx.String("format"), tss[i])
+			}
 		}
 		return nil
 	},
 }
 
 var chainGetCmd = &cli.Command{
-	Name:  "get",
-	Usage: "Get chain DAG node by path",
+	Name:      "get",
+	Usage:     "Get chain DAG node by path",
+	ArgsUsage: "[path]",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:  "as-type",
+			Usage: "specify type to interpret output as",
+		},
+		&cli.BoolFlag{
+			Name:  "verbose",
+			Value: false,
+		},
+		&cli.StringFlag{
+			Name:  "tipset",
+			Usage: "specify tipset for /pstate (pass comma separated array of cids)",
+		},
+	},
 	Description: `Get ipld node under a specified path:
 
    lotus chain get /ipfs/[cid]/some/path
 
+   Path prefixes:
+   - /ipfs/[cid], /ipld/[cid] - traverse IPLD path
+   - /pstate - traverse from head.ParentStateRoot
+
    Note:
    You can use special path elements to traverse through some data structures:
    - /ipfs/[cid]/@H:elem - get 'elem' from hamt
+   - /ipfs/[cid]/@Hi:123 - get varint elem 123 from hamt
+   - /ipfs/[cid]/@Hu:123 - get uvarint elem 123 from hamt
    - /ipfs/[cid]/@Ha:t01 - get element under Addr(t01).Bytes
-   - /ipfs/[cid]/@A:10 - get 10th amt element
+   - /ipfs/[cid]/@A:10   - get 10th amt element
+   - .../@Ha:t01/@state  - get pretty map-based actor state
+
+   List of --as-type types:
+   - raw
+   - block
+   - message
+   - smessage, signedmessage
+   - actor
+   - amt
+   - hamt-epoch
+   - hamt-address
+   - cronevent
+   - account-state
 `,
 	Action: func(cctx *cli.Context) error {
 		api, closer, err := GetFullNodeAPI(cctx)
@@ -358,12 +555,89 @@ var chainGetCmd = &cli.Command{
 		defer closer()
 		ctx := ReqContext(cctx)
 
-		nd, err := api.ChainGetNode(ctx, cctx.Args().First())
+		p := path.Clean(cctx.Args().First())
+		if strings.HasPrefix(p, "/pstate") {
+			p = p[len("/pstate"):]
+
+			ts, err := LoadTipSet(ctx, cctx, api)
+			if err != nil {
+				return err
+			}
+
+			if ts == nil {
+				ts, err = api.ChainHead(ctx)
+				if err != nil {
+					return err
+				}
+			}
+			p = "/ipfs/" + ts.ParentState().String() + p
+			if cctx.Bool("verbose") {
+				fmt.Println(p)
+			}
+		}
+
+		obj, err := api.ChainGetNode(ctx, p)
 		if err != nil {
 			return err
 		}
 
-		b, err := json.MarshalIndent(nd, "", "\t")
+		t := strings.ToLower(cctx.String("as-type"))
+		if t == "" {
+			b, err := json.MarshalIndent(obj.Obj, "", "\t")
+			if err != nil {
+				return err
+			}
+			fmt.Println(string(b))
+			return nil
+		}
+
+		var cbu cbg.CBORUnmarshaler
+		switch t {
+		case "raw":
+			cbu = nil
+		case "block":
+			cbu = new(types.BlockHeader)
+		case "message":
+			cbu = new(types.Message)
+		case "smessage", "signedmessage":
+			cbu = new(types.SignedMessage)
+		case "actor":
+			cbu = new(types.Actor)
+		case "amt":
+			return handleAmt(ctx, api, obj.Cid)
+		case "hamt-epoch":
+			return handleHamtEpoch(ctx, api, obj.Cid)
+		case "hamt-address":
+			return handleHamtAddress(ctx, api, obj.Cid)
+		case "cronevent":
+			cbu = new(power.CronEvent)
+		case "account-state":
+			cbu = new(account.State)
+		case "miner-state":
+			cbu = new(miner.State)
+		case "power-state":
+			cbu = new(power.State)
+		case "market-state":
+			cbu = new(market.State)
+		default:
+			return fmt.Errorf("unknown type: %q", t)
+		}
+
+		raw, err := api.ChainReadObj(ctx, obj.Cid)
+		if err != nil {
+			return err
+		}
+
+		if cbu == nil {
+			fmt.Printf("%x", raw)
+			return nil
+		}
+
+		if err := cbu.UnmarshalCBOR(bytes.NewReader(raw)); err != nil {
+			return fmt.Errorf("failed to unmarshal as %q", t)
+		}
+
+		b, err := json.MarshalIndent(cbu, "", "\t")
 		if err != nil {
 			return err
 		}
@@ -372,6 +646,85 @@ var chainGetCmd = &cli.Command{
 	},
 }
 
+type apiIpldStore struct {
+	ctx context.Context
+	api api.FullNode
+}
+
+func (ht *apiIpldStore) Context() context.Context {
+	return ht.ctx
+}
+
+func (ht *apiIpldStore) Get(ctx context.Context, c cid.Cid, out interface{}) error {
+	raw, err := ht.api.ChainReadObj(ctx, c)
+	if err != nil {
+		return err
+	}
+
+	cu, ok := out.(cbg.CBORUnmarshaler)
+	if ok {
+		if err := cu.UnmarshalCBOR(bytes.NewReader(raw)); err != nil {
+			return err
+		}
+		return nil
+	}
+
+	return fmt.Errorf("Object does not implement CBORUnmarshaler")
+}
+
+func (ht *apiIpldStore) Put(ctx context.Context, v interface{}) (cid.Cid, error) {
+	panic("No mutations allowed")
+}
+
+func handleAmt(ctx context.Context, api api.FullNode, r cid.Cid) error {
+	s := &apiIpldStore{ctx, api}
+	mp, err := adt.AsArray(s, r)
+	if err != nil {
+		return err
+	}
+
+	return mp.ForEach(nil, func(key int64) error {
+		fmt.Printf("%d\n", key)
+		return nil
+	})
+}
+
+func handleHamtEpoch(ctx context.Context, api api.FullNode, r cid.Cid) error {
+	s := &apiIpldStore{ctx, api}
+	mp, err := adt.AsMap(s, r)
+	if err != nil {
+		return err
+	}
+
+	return mp.ForEach(nil, func(key string) error {
+		ik, err := abi.ParseIntKey(key)
+		if err != nil {
+			return err
+		}
+
+		fmt.Printf("%d\n", ik)
+		return nil
+	})
+}
+
+func handleHamtAddress(ctx context.Context, api api.FullNode, r cid.Cid) error {
+	s := &apiIpldStore{ctx, api}
+	mp, err := adt.AsMap(s, r)
+	if err != nil {
+		return err
+	}
+
+	return mp.ForEach(nil, func(key string) error {
+		addr, err := address.NewFromBytes([]byte(key))
+		if err != nil {
+			return err
+		}
+
+		fmt.Printf("%s\n", addr)
+		return nil
+	})
+}
+
 func printTipSet(format string, ts *types.TipSet) {
 	format = strings.ReplaceAll(format, "<height>", fmt.Sprint(ts.Height()))
 	format = strings.ReplaceAll(format, "<time>", time.Unix(int64(ts.MinTimestamp()), 0).Format(time.Stamp))
@@ -380,8 +733,351 @@ func printTipSet(format string, ts *types.TipSet) {
 		blks += fmt.Sprintf("%s: %s,", b.Cid(), b.Miner)
 	}
 	blks += " ]"
+
+	sCids := make([]string, 0, len(blks))
+
+	for _, c := range ts.Cids() {
+		sCids = append(sCids, c.String())
+	}
+
+	format = strings.ReplaceAll(format, "<tipset>", strings.Join(sCids, ","))
 	format = strings.ReplaceAll(format, "<blocks>", blks)
 	format = strings.ReplaceAll(format, "<weight>", fmt.Sprint(ts.Blocks()[0].ParentWeight))
 
 	fmt.Println(format)
 }
+
+var chainBisectCmd = &cli.Command{
+	Name:      "bisect",
+	Usage:     "bisect chain for an event",
+	ArgsUsage: "[minHeight maxHeight path shellCommand <shellCommandArgs (if any)>]",
+	Description: `Bisect the chain state tree:
+
+   lotus chain bisect [min height] [max height] '1/2/3/state/path' 'shell command' 'args'
+
+   Returns the first tipset in which condition is true
+                  v
+   [start] FFFFFFFTTT [end]
+
+   Example: find height at which deal ID 100 000 appeared
+    - lotus chain bisect 1 32000 '@Ha:t03/1' jq -e '.[2] > 100000'
+
+   For special path elements see 'chain get' help
+`,
+	Action: func(cctx *cli.Context) error {
+		api, closer, err := GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+		ctx := ReqContext(cctx)
+
+		if cctx.Args().Len() < 4 {
+			return xerrors.New("need at least 4 args")
+		}
+
+		start, err := strconv.ParseUint(cctx.Args().Get(0), 10, 64)
+		if err != nil {
+			return err
+		}
+
+		end, err := strconv.ParseUint(cctx.Args().Get(1), 10, 64)
+		if err != nil {
+			return err
+		}
+
+		subPath := cctx.Args().Get(2)
+
+		highest, err := api.ChainGetTipSetByHeight(ctx, abi.ChainEpoch(end), types.EmptyTSK)
+		if err != nil {
+			return xerrors.Errorf("getting end tipset: %w", err)
+		}
+
+		prev := highest.Height()
+
+		for {
+			mid := (start + end) / 2
+			if end-start == 1 {
+				mid = end
+				start = end
+			}
+
+			midTs, err := api.ChainGetTipSetByHeight(ctx, abi.ChainEpoch(mid), highest.Key())
+			if err != nil {
+				return err
+			}
+
+			path := "/ipld/" + midTs.ParentState().String() + "/" + subPath
+			fmt.Printf("* Testing %d (%d - %d) (%s): ", mid, start, end, path)
+
+			nd, err := api.ChainGetNode(ctx, path)
+			if err != nil {
+				return err
+			}
+
+			b, err := json.MarshalIndent(nd.Obj, "", "\t")
+			if err != nil {
+				return err
+			}
+
+			cmd := exec.CommandContext(ctx, cctx.Args().Get(3), cctx.Args().Slice()[4:]...)
+			cmd.Stdin = bytes.NewReader(b)
+
+			var out bytes.Buffer
+			var serr bytes.Buffer
+
+			cmd.Stdout = &out
+			cmd.Stderr = &serr
+
+			switch cmd.Run().(type) {
+			case nil:
+				// it's lower
+				if strings.TrimSpace(out.String()) != "false" {
+					end = mid
+					highest = midTs
+					fmt.Println("true")
+				} else {
+					start = mid
+					fmt.Printf("false (cli)\n")
+				}
+			case *exec.ExitError:
+				if len(serr.String()) > 0 {
+					fmt.Println("error")
+
+					fmt.Printf("> Command: %s\n---->\n", strings.Join(cctx.Args().Slice()[3:], " "))
+					fmt.Println(string(b))
+					fmt.Println("<----")
+					return xerrors.Errorf("error running bisect check: %s", serr.String())
+				}
+
+				start = mid
+				fmt.Println("false")
+			default:
+				return err
+			}
+
+			if start == end {
+				if strings.TrimSpace(out.String()) == "true" {
+					fmt.Println(midTs.Height())
+				} else {
+					fmt.Println(prev)
+				}
+				return nil
+			}
+
+			prev = abi.ChainEpoch(mid)
+		}
+	},
+}
+
+var chainExportCmd = &cli.Command{
+	Name:      "export",
+	Usage:     "export chain to a car file",
+	ArgsUsage: "[outputPath]",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name: "tipset",
+		},
+		&cli.Int64Flag{
+			Name:  "recent-stateroots",
+			Usage: "specify the number of recent state roots to include in the export",
+		},
+		&cli.BoolFlag{
+			Name: "skip-old-msgs",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		api, closer, err := GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+		ctx := ReqContext(cctx)
+
+		if !cctx.Args().Present() {
+			return fmt.Errorf("must specify filename to export chain to")
+		}
+
+		rsrs := abi.ChainEpoch(cctx.Int64("recent-stateroots"))
+		if cctx.IsSet("recent-stateroots") && rsrs < build.Finality {
+			return fmt.Errorf("\"recent-stateroots\" has to be greater than %d", build.Finality)
+		}
+
+		fi, err := os.Create(cctx.Args().First())
+		if err != nil {
+			return err
+		}
+		defer func() {
+			err := fi.Close()
+			if err != nil {
+				fmt.Printf("error closing output file: %+v", err)
+			}
+		}()
+
+		ts, err := LoadTipSet(ctx, cctx, api)
+		if err != nil {
+			return err
+		}
+
+		skipold := cctx.Bool("skip-old-msgs")
+
+		if rsrs == 0 && skipold {
+			return fmt.Errorf("must pass recent stateroots along with skip-old-msgs")
+		}
+
+		stream, err := api.ChainExport(ctx, rsrs, skipold, ts.Key())
+		if err != nil {
+			return err
+		}
+
+		for b := range stream {
+			_, err := fi.Write(b)
+			if err != nil {
+				return err
+			}
+		}
+
+		return nil
+	},
+}
+
+var slashConsensusFault = &cli.Command{
+	Name:      "slash-consensus",
+	Usage:     "Report consensus fault",
+	ArgsUsage: "[blockCid1 blockCid2]",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:  "miner",
+			Usage: "Miner address",
+		},
+		&cli.StringFlag{
+			Name:  "extra",
+			Usage: "Extra block cid",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		api, closer, err := GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+		ctx := ReqContext(cctx)
+
+		c1, err := cid.Parse(cctx.Args().Get(0))
+		if err != nil {
+			return xerrors.Errorf("parsing cid 1: %w", err)
+		}
+
+		b1, err := api.ChainGetBlock(ctx, c1)
+		if err != nil {
+			return xerrors.Errorf("getting block 1: %w", err)
+		}
+
+		c2, err := cid.Parse(cctx.Args().Get(1))
+		if err != nil {
+			return xerrors.Errorf("parsing cid 2: %w", err)
+		}
+
+		b2, err := api.ChainGetBlock(ctx, c2)
+		if err != nil {
+			return xerrors.Errorf("getting block 2: %w", err)
+		}
+
+		def, err := api.WalletDefaultAddress(ctx)
+		if err != nil {
+			return err
+		}
+
+		bh1, err := cborutil.Dump(b1)
+		if err != nil {
+			return err
+		}
+
+		bh2, err := cborutil.Dump(b2)
+		if err != nil {
+			return err
+		}
+
+		params := miner.ReportConsensusFaultParams{
+			BlockHeader1: bh1,
+			BlockHeader2: bh2,
+		}
+
+		if cctx.String("extra") != "" {
+			cExtra, err := cid.Parse(cctx.String("extra"))
+			if err != nil {
+				return xerrors.Errorf("parsing cid extra: %w", err)
+			}
+
+			bExtra, err := api.ChainGetBlock(ctx, cExtra)
+			if err != nil {
+				return xerrors.Errorf("getting block extra: %w", err)
+			}
+
+			be, err := cborutil.Dump(bExtra)
+			if err != nil {
+				return err
+			}
+
+			params.BlockHeaderExtra = be
+		}
+
+		enc, err := actors.SerializeParams(&params)
+		if err != nil {
+			return err
+		}
+
+		if cctx.String("miner") == "" {
+			return xerrors.Errorf("--miner flag is required")
+		}
+
+		maddr, err := address.NewFromString(cctx.String("miner"))
+		if err != nil {
+			return err
+		}
+
+		msg := &types.Message{
+			To:     maddr,
+			From:   def,
+			Value:  types.NewInt(0),
+			Method: builtin.MethodsMiner.ReportConsensusFault,
+			Params: enc,
+		}
+
+		smsg, err := api.MpoolPushMessage(ctx, msg, nil)
+		if err != nil {
+			return err
+		}
+
+		fmt.Println(smsg.Cid())
+
+		return nil
+	},
+}
+
+var chainGasPriceCmd = &cli.Command{
+	Name:  "gas-price",
+	Usage: "Estimate gas prices",
+	Action: func(cctx *cli.Context) error {
+		api, closer, err := GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+		ctx := ReqContext(cctx)
+
+		nb := []int{1, 2, 3, 5, 10, 20, 50, 100, 300}
+		for _, nblocks := range nb {
+			addr := builtin.SystemActorAddr // TODO: make real when used in GasEstimateGasPremium
+
+			est, err := api.GasEstimateGasPremium(ctx, uint64(nblocks), addr, 10000, types.EmptyTSK)
+			if err != nil {
+				return err
+			}
+
+			fmt.Printf("%d blocks: %s (%s)\n", nblocks, est, types.FIL(est))
+		}
+
+		return nil
+	},
+}
diff --git a/cli/client.go b/cli/client.go
index 34208318f..5d40dce0d 100644
--- a/cli/client.go
+++ b/cli/client.go
@@ -1,40 +1,107 @@
 package cli
 
 import (
+	"context"
+	"encoding/json"
 	"fmt"
+	"io"
 	"os"
 	"path/filepath"
+	"sort"
 	"strconv"
 	"text/tabwriter"
+	"time"
 
+	"github.com/filecoin-project/specs-actors/actors/builtin"
+
+	tm "github.com/buger/goterm"
+	"github.com/docker/go-units"
+	"github.com/fatih/color"
+	datatransfer "github.com/filecoin-project/go-data-transfer"
+	"github.com/filecoin-project/go-fil-markets/retrievalmarket"
 	"github.com/ipfs/go-cid"
+	"github.com/ipfs/go-cidutil/cidenc"
 	"github.com/libp2p/go-libp2p-core/peer"
+	"github.com/multiformats/go-multibase"
+	"github.com/urfave/cli/v2"
 	"golang.org/x/xerrors"
-	"gopkg.in/urfave/cli.v2"
 
 	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-fil-markets/storagemarket"
+	"github.com/filecoin-project/go-multistore"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/big"
+
+	"github.com/filecoin-project/lotus/api"
 	lapi "github.com/filecoin-project/lotus/api"
-	actors "github.com/filecoin-project/lotus/chain/actors"
+	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/market"
 	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/lib/tablewriter"
 )
 
+var CidBaseFlag = cli.StringFlag{
+	Name:        "cid-base",
+	Hidden:      true,
+	Value:       "base32",
+	Usage:       "Multibase encoding used for version 1 CIDs in output.",
+	DefaultText: "base32",
+}
+
+// GetCidEncoder returns an encoder using the `cid-base` flag if provided, or
+// the default (Base32) encoder if not.
+func GetCidEncoder(cctx *cli.Context) (cidenc.Encoder, error) {
+	val := cctx.String("cid-base")
+
+	e := cidenc.Encoder{Base: multibase.MustNewEncoder(multibase.Base32)}
+
+	if val != "" {
+		var err error
+		e.Base, err = multibase.EncoderByName(val)
+		if err != nil {
+			return e, err
+		}
+	}
+
+	return e, nil
+}
+
 var clientCmd = &cli.Command{
 	Name:  "client",
 	Usage: "Make deals, store data, retrieve data",
 	Subcommands: []*cli.Command{
-		clientImportCmd,
-		clientLocalCmd,
-		clientDealCmd,
-		clientFindCmd,
-		clientRetrieveCmd,
-		clientQueryAskCmd,
-		clientListDeals,
+		WithCategory("storage", clientDealCmd),
+		WithCategory("storage", clientQueryAskCmd),
+		WithCategory("storage", clientListDeals),
+		WithCategory("storage", clientGetDealCmd),
+		WithCategory("data", clientImportCmd),
+		WithCategory("data", clientDropCmd),
+		WithCategory("data", clientLocalCmd),
+		WithCategory("retrieval", clientFindCmd),
+		WithCategory("retrieval", clientRetrieveCmd),
+		WithCategory("util", clientCommPCmd),
+		WithCategory("util", clientCarGenCmd),
+		WithCategory("util", clientInfoCmd),
+		WithCategory("util", clientListTransfers),
 	},
 }
 
 var clientImportCmd = &cli.Command{
-	Name:  "import",
-	Usage: "Import data",
+	Name:      "import",
+	Usage:     "Import data",
+	ArgsUsage: "[inputPath]",
+	Flags: []cli.Flag{
+		&cli.BoolFlag{
+			Name:  "car",
+			Usage: "import from a car file instead of a regular file",
+		},
+		&cli.BoolFlag{
+			Name:    "quiet",
+			Aliases: []string{"q"},
+			Usage:   "Output root CID only",
+		},
+		&CidBaseFlag,
+	},
 	Action: func(cctx *cli.Context) error {
 		api, closer, err := GetFullNodeAPI(cctx)
 		if err != nil {
@@ -42,16 +109,136 @@ var clientImportCmd = &cli.Command{
 		}
 		defer closer()
 		ctx := ReqContext(cctx)
+
+		if cctx.NArg() != 1 {
+			return xerrors.New("expected input path as the only arg")
+		}
+
 		absPath, err := filepath.Abs(cctx.Args().First())
 		if err != nil {
 			return err
 		}
 
-		c, err := api.ClientImport(ctx, absPath)
+		ref := lapi.FileRef{
+			Path:  absPath,
+			IsCAR: cctx.Bool("car"),
+		}
+		c, err := api.ClientImport(ctx, ref)
 		if err != nil {
 			return err
 		}
-		fmt.Println(c.String())
+
+		encoder, err := GetCidEncoder(cctx)
+		if err != nil {
+			return err
+		}
+
+		if !cctx.Bool("quiet") {
+			fmt.Printf("Import %d, Root ", c.ImportID)
+		}
+		fmt.Println(encoder.Encode(c.Root))
+
+		return nil
+	},
+}
+
+var clientDropCmd = &cli.Command{
+	Name:      "drop",
+	Usage:     "Remove import",
+	ArgsUsage: "[import ID...]",
+	Action: func(cctx *cli.Context) error {
+		if !cctx.Args().Present() {
+			return xerrors.Errorf("no imports specified")
+		}
+
+		api, closer, err := GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+		ctx := ReqContext(cctx)
+
+		var ids []multistore.StoreID
+		for i, s := range cctx.Args().Slice() {
+			id, err := strconv.ParseInt(s, 10, 0)
+			if err != nil {
+				return xerrors.Errorf("parsing %d-th import ID: %w", i, err)
+			}
+
+			ids = append(ids, multistore.StoreID(id))
+		}
+
+		for _, id := range ids {
+			if err := api.ClientRemoveImport(ctx, id); err != nil {
+				return xerrors.Errorf("removing import %d: %w", id, err)
+			}
+		}
+
+		return nil
+	},
+}
+
+var clientCommPCmd = &cli.Command{
+	Name:      "commP",
+	Usage:     "Calculate the piece-cid (commP) of a CAR file",
+	ArgsUsage: "[inputFile]",
+	Flags: []cli.Flag{
+		&CidBaseFlag,
+	},
+	Action: func(cctx *cli.Context) error {
+		api, closer, err := GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+		ctx := ReqContext(cctx)
+
+		if cctx.Args().Len() != 1 {
+			return fmt.Errorf("usage: commP <inputPath>")
+		}
+
+		ret, err := api.ClientCalcCommP(ctx, cctx.Args().Get(0))
+		if err != nil {
+			return err
+		}
+
+		encoder, err := GetCidEncoder(cctx)
+		if err != nil {
+			return err
+		}
+
+		fmt.Println("CID: ", encoder.Encode(ret.Root))
+		fmt.Println("Piece size: ", types.SizeStr(types.NewInt(uint64(ret.Size))))
+		return nil
+	},
+}
+
+var clientCarGenCmd = &cli.Command{
+	Name:      "generate-car",
+	Usage:     "Generate a car file from input",
+	ArgsUsage: "[inputPath outputPath]",
+	Action: func(cctx *cli.Context) error {
+		api, closer, err := GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+		ctx := ReqContext(cctx)
+
+		if cctx.Args().Len() != 2 {
+			return fmt.Errorf("usage: generate-car <inputPath> <outputPath>")
+		}
+
+		ref := lapi.FileRef{
+			Path:  cctx.Args().First(),
+			IsCAR: false,
+		}
+
+		op := cctx.Args().Get(1)
+
+		if err = api.ClientGenCar(ctx, ref, op); err != nil {
+			return err
+		}
 		return nil
 	},
 }
@@ -59,6 +246,9 @@ var clientImportCmd = &cli.Command{
 var clientLocalCmd = &cli.Command{
 	Name:  "local",
 	Usage: "List locally imported data",
+	Flags: []cli.Flag{
+		&CidBaseFlag,
+	},
 	Action: func(cctx *cli.Context) error {
 		api, closer, err := GetFullNodeAPI(cctx)
 		if err != nil {
@@ -71,17 +261,74 @@ var clientLocalCmd = &cli.Command{
 		if err != nil {
 			return err
 		}
+
+		encoder, err := GetCidEncoder(cctx)
+		if err != nil {
+			return err
+		}
+
+		sort.Slice(list, func(i, j int) bool {
+			return list[i].Key < list[j].Key
+		})
+
 		for _, v := range list {
-			fmt.Printf("%s %s %d %s\n", v.Key, v.FilePath, v.Size, v.Status)
+			cidStr := "<nil>"
+			if v.Root != nil {
+				cidStr = encoder.Encode(*v.Root)
+			}
+
+			fmt.Printf("%d: %s @%s (%s)\n", v.Key, cidStr, v.FilePath, v.Source)
+			if v.Err != "" {
+				fmt.Printf("\terror: %s\n", v.Err)
+			}
 		}
 		return nil
 	},
 }
 
 var clientDealCmd = &cli.Command{
-	Name:  "deal",
-	Usage: "Initialize storage deal with a miner",
+	Name:      "deal",
+	Usage:     "Initialize storage deal with a miner",
+	ArgsUsage: "[dataCid miner price duration]",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:  "manual-piece-cid",
+			Usage: "manually specify piece commitment for data (dataCid must be to a car file)",
+		},
+		&cli.Int64Flag{
+			Name:  "manual-piece-size",
+			Usage: "if manually specifying piece cid, used to specify size (dataCid must be to a car file)",
+		},
+		&cli.StringFlag{
+			Name:  "from",
+			Usage: "specify address to fund the deal with",
+		},
+		&cli.Int64Flag{
+			Name:  "start-epoch",
+			Usage: "specify the epoch that the deal should start at",
+			Value: -1,
+		},
+		&cli.BoolFlag{
+			Name:  "fast-retrieval",
+			Usage: "indicates that data should be available for fast retrieval",
+			Value: true,
+		},
+		&cli.BoolFlag{
+			Name:  "verified-deal",
+			Usage: "indicate that the deal counts towards verified client total",
+			Value: false,
+		},
+		&cli.StringFlag{
+			Name:  "provider-collateral",
+			Usage: "specify the requested provider collateral the miner should put up",
+		},
+		&CidBaseFlag,
+	},
 	Action: func(cctx *cli.Context) error {
+		if !cctx.Args().Present() {
+			return interactiveDeal(cctx)
+		}
+
 		api, closer, err := GetFullNodeAPI(cctx)
 		if err != nil {
 			return err
@@ -93,7 +340,7 @@ var clientDealCmd = &cli.Command{
 			return xerrors.New("expected 4 args: dataCid, miner, price, duration")
 		}
 
-		// [data, miner, dur]
+		// [data, miner, price, dur]
 
 		data, err := cid.Parse(cctx.Args().Get(0))
 		if err != nil {
@@ -115,23 +362,310 @@ var clientDealCmd = &cli.Command{
 			return err
 		}
 
-		a, err := api.WalletDefaultAddress(ctx)
-		if err != nil {
-			return err
+		var provCol big.Int
+		if pcs := cctx.String("provider-collateral"); pcs != "" {
+			pc, err := big.FromString(pcs)
+			if err != nil {
+				return fmt.Errorf("failed to parse provider-collateral: %w", err)
+			}
+			provCol = pc
 		}
-		proposal, err := api.ClientStartDeal(ctx, data, a, miner, types.BigInt(price), uint64(dur))
+
+		if abi.ChainEpoch(dur) < build.MinDealDuration {
+			return xerrors.Errorf("minimum deal duration is %d blocks", build.MinDealDuration)
+		}
+
+		var a address.Address
+		if from := cctx.String("from"); from != "" {
+			faddr, err := address.NewFromString(from)
+			if err != nil {
+				return xerrors.Errorf("failed to parse 'from' address: %w", err)
+			}
+			a = faddr
+		} else {
+			def, err := api.WalletDefaultAddress(ctx)
+			if err != nil {
+				return err
+			}
+			a = def
+		}
+
+		ref := &storagemarket.DataRef{
+			TransferType: storagemarket.TTGraphsync,
+			Root:         data,
+		}
+
+		if mpc := cctx.String("manual-piece-cid"); mpc != "" {
+			c, err := cid.Parse(mpc)
+			if err != nil {
+				return xerrors.Errorf("failed to parse provided manual piece cid: %w", err)
+			}
+
+			ref.PieceCid = &c
+
+			psize := cctx.Int64("manual-piece-size")
+			if psize == 0 {
+				return xerrors.Errorf("must specify piece size when manually setting cid")
+			}
+
+			ref.PieceSize = abi.UnpaddedPieceSize(psize)
+
+			ref.TransferType = storagemarket.TTManual
+		}
+
+		// Check if the address is a verified client
+		dcap, err := api.StateVerifiedClientStatus(ctx, a, types.EmptyTSK)
 		if err != nil {
 			return err
 		}
 
-		fmt.Println(proposal)
+		isVerified := dcap != nil
+
+		// If the user has explicitly set the --verified-deal flag
+		if cctx.IsSet("verified-deal") {
+			// If --verified-deal is true, but the address is not a verified
+			// client, return an error
+			verifiedDealParam := cctx.Bool("verified-deal")
+			if verifiedDealParam && !isVerified {
+				return xerrors.Errorf("address %s does not have verified client status", a)
+			}
+
+			// Override the default
+			isVerified = verifiedDealParam
+		}
+
+		proposal, err := api.ClientStartDeal(ctx, &lapi.StartDealParams{
+			Data:               ref,
+			Wallet:             a,
+			Miner:              miner,
+			EpochPrice:         types.BigInt(price),
+			MinBlocksDuration:  uint64(dur),
+			DealStartEpoch:     abi.ChainEpoch(cctx.Int64("start-epoch")),
+			FastRetrieval:      cctx.Bool("fast-retrieval"),
+			VerifiedDeal:       isVerified,
+			ProviderCollateral: provCol,
+		})
+		if err != nil {
+			return err
+		}
+
+		encoder, err := GetCidEncoder(cctx)
+		if err != nil {
+			return err
+		}
+
+		fmt.Println(encoder.Encode(*proposal))
+
 		return nil
 	},
 }
 
+func interactiveDeal(cctx *cli.Context) error {
+	api, closer, err := GetFullNodeAPI(cctx)
+	if err != nil {
+		return err
+	}
+	defer closer()
+	ctx := ReqContext(cctx)
+
+	state := "import"
+
+	var data cid.Cid
+	var days int
+	var maddr address.Address
+	var ask storagemarket.StorageAsk
+	var epochPrice big.Int
+	var epochs abi.ChainEpoch
+
+	var a address.Address
+	if from := cctx.String("from"); from != "" {
+		faddr, err := address.NewFromString(from)
+		if err != nil {
+			return xerrors.Errorf("failed to parse 'from' address: %w", err)
+		}
+		a = faddr
+	} else {
+		def, err := api.WalletDefaultAddress(ctx)
+		if err != nil {
+			return err
+		}
+		a = def
+	}
+
+	printErr := func(err error) {
+		fmt.Printf("%s %s\n", color.RedString("Error:"), err.Error())
+	}
+
+	for {
+		// TODO: better exit handling
+		if err := ctx.Err(); err != nil {
+			return err
+		}
+
+		switch state {
+		case "import":
+			fmt.Print("Data CID (from " + color.YellowString("lotus client import") + "): ")
+
+			var cidStr string
+			_, err := fmt.Scan(&cidStr)
+			if err != nil {
+				printErr(xerrors.Errorf("reading cid string: %w", err))
+				continue
+			}
+
+			data, err = cid.Parse(cidStr)
+			if err != nil {
+				printErr(xerrors.Errorf("parsing cid string: %w", err))
+				continue
+			}
+
+			state = "duration"
+		case "duration":
+			fmt.Print("Deal duration (days): ")
+
+			_, err := fmt.Scan(&days)
+			if err != nil {
+				printErr(xerrors.Errorf("parsing duration: %w", err))
+				continue
+			}
+
+			if days < int(build.MinDealDuration/builtin.EpochsInDay) {
+				printErr(xerrors.Errorf("minimum duration is %d days", int(build.MinDealDuration/builtin.EpochsInDay)))
+				continue
+			}
+
+			state = "miner"
+		case "miner":
+			fmt.Print("Miner Address (t0..): ")
+			var maddrStr string
+
+			_, err := fmt.Scan(&maddrStr)
+			if err != nil {
+				printErr(xerrors.Errorf("reading miner address: %w", err))
+				continue
+			}
+
+			maddr, err = address.NewFromString(maddrStr)
+			if err != nil {
+				printErr(xerrors.Errorf("parsing miner address: %w", err))
+				continue
+			}
+
+			state = "query"
+		case "query":
+			color.Blue(".. querying miner ask")
+
+			mi, err := api.StateMinerInfo(ctx, maddr, types.EmptyTSK)
+			if err != nil {
+				printErr(xerrors.Errorf("failed to get peerID for miner: %w", err))
+				state = "miner"
+				continue
+			}
+
+			a, err := api.ClientQueryAsk(ctx, *mi.PeerId, maddr)
+			if err != nil {
+				printErr(xerrors.Errorf("failed to query ask: %w", err))
+				state = "miner"
+				continue
+			}
+
+			ask = *a.Ask
+
+			// TODO: run more validation
+			state = "confirm"
+		case "confirm":
+			fromBal, err := api.WalletBalance(ctx, a)
+			if err != nil {
+				return xerrors.Errorf("checking from address balance: %w", err)
+			}
+
+			color.Blue(".. calculating data size\n")
+			ds, err := api.ClientDealSize(ctx, data)
+			if err != nil {
+				return err
+			}
+
+			dur := 24 * time.Hour * time.Duration(days)
+
+			epochs = abi.ChainEpoch(dur / (time.Duration(build.BlockDelaySecs) * time.Second))
+			// TODO: do some more or epochs math (round to miner PP, deal start buffer)
+
+			gib := types.NewInt(1 << 30)
+
+			// TODO: price is based on PaddedPieceSize, right?
+			epochPrice = types.BigDiv(types.BigMul(ask.Price, types.NewInt(uint64(ds.PieceSize))), gib)
+			totalPrice := types.BigMul(epochPrice, types.NewInt(uint64(epochs)))
+
+			fmt.Printf("-----\n")
+			fmt.Printf("Proposing from %s\n", a)
+			fmt.Printf("\tBalance: %s\n", types.FIL(fromBal))
+			fmt.Printf("\n")
+			fmt.Printf("Piece size: %s (Payload size: %s)\n", units.BytesSize(float64(ds.PieceSize)), units.BytesSize(float64(ds.PayloadSize)))
+			fmt.Printf("Duration: %s\n", dur)
+			fmt.Printf("Total price: ~%s (%s per epoch)\n", types.FIL(totalPrice), types.FIL(epochPrice))
+
+			state = "accept"
+		case "accept":
+			fmt.Print("\nAccept (yes/no): ")
+
+			var yn string
+			_, err := fmt.Scan(&yn)
+			if err != nil {
+				return err
+			}
+
+			if yn == "no" {
+				return nil
+			}
+
+			if yn != "yes" {
+				fmt.Println("Type in full 'yes' or 'no'")
+				continue
+			}
+
+			state = "execute"
+		case "execute":
+			color.Blue(".. executing")
+			proposal, err := api.ClientStartDeal(ctx, &lapi.StartDealParams{
+				Data: &storagemarket.DataRef{
+					TransferType: storagemarket.TTGraphsync,
+					Root:         data,
+				},
+				Wallet:            a,
+				Miner:             maddr,
+				EpochPrice:        epochPrice,
+				MinBlocksDuration: uint64(epochs),
+				DealStartEpoch:    abi.ChainEpoch(cctx.Int64("start-epoch")),
+				FastRetrieval:     cctx.Bool("fast-retrieval"),
+				VerifiedDeal:      false, // TODO: Allow setting
+			})
+			if err != nil {
+				return err
+			}
+
+			encoder, err := GetCidEncoder(cctx)
+			if err != nil {
+				return err
+			}
+
+			fmt.Println("\nDeal CID:", color.GreenString(encoder.Encode(*proposal)))
+			return nil
+		default:
+			return xerrors.Errorf("unknown state: %s", state)
+		}
+	}
+}
+
 var clientFindCmd = &cli.Command{
-	Name:  "find",
-	Usage: "find data in the network",
+	Name:      "find",
+	Usage:     "Find data in the network",
+	ArgsUsage: "[dataCid]",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:  "pieceCid",
+			Usage: "require data to be retrieved from a specific Piece CID",
+		},
+	},
 	Action: func(cctx *cli.Context) error {
 		if !cctx.Args().Present() {
 			fmt.Println("Usage: find [CID]")
@@ -161,39 +695,66 @@ var clientFindCmd = &cli.Command{
 			fmt.Println("LOCAL")
 		}
 
-		offers, err := api.ClientFindData(ctx, file)
+		var pieceCid *cid.Cid
+		if cctx.String("pieceCid") != "" {
+			parsed, err := cid.Parse(cctx.String("pieceCid"))
+			if err != nil {
+				return err
+			}
+			pieceCid = &parsed
+		}
+
+		offers, err := api.ClientFindData(ctx, file, pieceCid)
 		if err != nil {
 			return err
 		}
 
 		for _, offer := range offers {
 			if offer.Err != "" {
-				fmt.Printf("ERR %s@%s: %s\n", offer.Miner, offer.MinerPeerID, offer.Err)
+				fmt.Printf("ERR %s@%s: %s\n", offer.Miner, offer.MinerPeer.ID, offer.Err)
 				continue
 			}
-			fmt.Printf("RETRIEVAL %s@%s-%sfil-%db\n", offer.Miner, offer.MinerPeerID, types.FIL(offer.MinPrice), offer.Size)
+			fmt.Printf("RETRIEVAL %s@%s-%s-%s\n", offer.Miner, offer.MinerPeer.ID, types.FIL(offer.MinPrice), types.SizeStr(types.NewInt(offer.Size)))
 		}
 
 		return nil
 	},
 }
 
+const DefaultMaxRetrievePrice = 1
+
 var clientRetrieveCmd = &cli.Command{
-	Name:  "retrieve",
-	Usage: "retrieve data from network",
+	Name:      "retrieve",
+	Usage:     "Retrieve data from network",
+	ArgsUsage: "[dataCid outputPath]",
 	Flags: []cli.Flag{
 		&cli.StringFlag{
-			Name:  "address",
-			Usage: "address to use for transactions",
+			Name:  "from",
+			Usage: "address to send transactions from",
+		},
+		&cli.BoolFlag{
+			Name:  "car",
+			Usage: "export to a car file instead of a regular file",
+		},
+		&cli.StringFlag{
+			Name:  "miner",
+			Usage: "miner address for retrieval, if not present it'll use local discovery",
+		},
+		&cli.StringFlag{
+			Name:  "maxPrice",
+			Usage: fmt.Sprintf("maximum price the client is willing to consider (default: %d FIL)", DefaultMaxRetrievePrice),
+		},
+		&cli.StringFlag{
+			Name:  "pieceCid",
+			Usage: "require data to be retrieved from a specific Piece CID",
 		},
 	},
 	Action: func(cctx *cli.Context) error {
 		if cctx.NArg() != 2 {
-			fmt.Println("Usage: retrieve [CID] [outfile]")
-			return nil
+			return ShowHelp(cctx, fmt.Errorf("incorrect number of arguments"))
 		}
 
-		api, closer, err := GetFullNodeAPI(cctx)
+		fapi, closer, err := GetFullNodeAPI(cctx)
 		if err != nil {
 			return err
 		}
@@ -201,10 +762,10 @@ var clientRetrieveCmd = &cli.Command{
 		ctx := ReqContext(cctx)
 
 		var payer address.Address
-		if cctx.String("address") != "" {
-			payer, err = address.NewFromString(cctx.String("address"))
+		if cctx.String("from") != "" {
+			payer, err = address.NewFromString(cctx.String("from"))
 		} else {
-			payer, err = api.WalletDefaultAddress(ctx)
+			payer, err = fapi.WalletDefaultAddress(ctx)
 		}
 		if err != nil {
 			return err
@@ -227,30 +788,111 @@ var clientRetrieveCmd = &cli.Command{
 			return nil
 		}*/ // TODO: fix
 
-		offers, err := api.ClientFindData(ctx, file)
+		var pieceCid *cid.Cid
+		if cctx.String("pieceCid") != "" {
+			parsed, err := cid.Parse(cctx.String("pieceCid"))
+			if err != nil {
+				return err
+			}
+			pieceCid = &parsed
+		}
+
+		var offer api.QueryOffer
+		minerStrAddr := cctx.String("miner")
+		if minerStrAddr == "" { // Local discovery
+			offers, err := fapi.ClientFindData(ctx, file, pieceCid)
+
+			var cleaned []api.QueryOffer
+			// filter out offers that errored
+			for _, o := range offers {
+				if o.Err == "" {
+					cleaned = append(cleaned, o)
+				}
+			}
+
+			offers = cleaned
+
+			// sort by price low to high
+			sort.Slice(offers, func(i, j int) bool {
+				return offers[i].MinPrice.LessThan(offers[j].MinPrice)
+			})
+			if err != nil {
+				return err
+			}
+
+			// TODO: parse offer strings from `client find`, make this smarter
+			if len(offers) < 1 {
+				fmt.Println("Failed to find file")
+				return nil
+			}
+			offer = offers[0]
+		} else { // Directed retrieval
+			minerAddr, err := address.NewFromString(minerStrAddr)
+			if err != nil {
+				return err
+			}
+			offer, err = fapi.ClientMinerQueryOffer(ctx, minerAddr, file, pieceCid)
+			if err != nil {
+				return err
+			}
+		}
+		if offer.Err != "" {
+			return fmt.Errorf("The received offer errored: %s", offer.Err)
+		}
+
+		maxPrice := types.FromFil(DefaultMaxRetrievePrice)
+
+		if cctx.String("maxPrice") != "" {
+			maxPriceFil, err := types.ParseFIL(cctx.String("maxPrice"))
+			if err != nil {
+				return xerrors.Errorf("parsing maxPrice: %w", err)
+			}
+
+			maxPrice = types.BigInt(maxPriceFil)
+		}
+
+		if offer.MinPrice.GreaterThan(maxPrice) {
+			return xerrors.Errorf("failed to find offer satisfying maxPrice: %s", maxPrice)
+		}
+
+		ref := &lapi.FileRef{
+			Path:  cctx.Args().Get(1),
+			IsCAR: cctx.Bool("car"),
+		}
+		updates, err := fapi.ClientRetrieveWithEvents(ctx, offer.Order(payer), ref)
 		if err != nil {
-			return err
+			return xerrors.Errorf("error setting up retrieval: %w", err)
 		}
 
-		// TODO: parse offer strings from `client find`, make this smarter
+		for {
+			select {
+			case evt, ok := <-updates:
+				if ok {
+					fmt.Printf("> Recv: %s, Paid %s, %s (%s)\n",
+						types.SizeStr(types.NewInt(evt.BytesReceived)),
+						types.FIL(evt.FundsSpent),
+						retrievalmarket.ClientEvents[evt.Event],
+						retrievalmarket.DealStatuses[evt.Status],
+					)
+				} else {
+					fmt.Println("Success")
+					return nil
+				}
 
-		if len(offers) < 1 {
-			fmt.Println("Failed to find file")
-			return nil
+				if evt.Err != "" {
+					return xerrors.Errorf("retrieval failed: %s", evt.Err)
+				}
+			case <-ctx.Done():
+				return xerrors.Errorf("retrieval timed out")
+			}
 		}
-
-		if err := api.ClientRetrieve(ctx, offers[0].Order(payer), cctx.Args().Get(1)); err != nil {
-			return xerrors.Errorf("Retrieval Failed: %w", err)
-		}
-
-		fmt.Println("Success")
-		return nil
 	},
 }
 
 var clientQueryAskCmd = &cli.Command{
-	Name:  "query-ask",
-	Usage: "find a miners ask",
+	Name:      "query-ask",
+	Usage:     "Find a miners ask",
+	ArgsUsage: "[minerAddress]",
 	Flags: []cli.Flag{
 		&cli.StringFlag{
 			Name:  "peerid",
@@ -267,7 +909,7 @@ var clientQueryAskCmd = &cli.Command{
 	},
 	Action: func(cctx *cli.Context) error {
 		if cctx.NArg() != 1 {
-			fmt.Println("Usage: query-ask [address]")
+			fmt.Println("Usage: query-ask [minerAddress]")
 			return nil
 		}
 
@@ -285,34 +927,22 @@ var clientQueryAskCmd = &cli.Command{
 
 		var pid peer.ID
 		if pidstr := cctx.String("peerid"); pidstr != "" {
-			p, err := peer.IDFromString(pidstr)
+			p, err := peer.Decode(pidstr)
 			if err != nil {
 				return err
 			}
 			pid = p
 		} else {
-			ret, err := api.StateCall(ctx, &types.Message{
-				To:     maddr,
-				From:   maddr,
-				Method: actors.MAMethods.GetPeerID,
-			}, nil)
+			mi, err := api.StateMinerInfo(ctx, maddr, types.EmptyTSK)
 			if err != nil {
 				return xerrors.Errorf("failed to get peerID for miner: %w", err)
 			}
 
-			if ret.ExitCode != 0 {
-				return fmt.Errorf("call to GetPeerID was unsuccesful (exit code %d)", ret.ExitCode)
-			}
-			if peer.ID(ret.Return) == peer.ID("SETME") {
+			if *mi.PeerId == peer.ID("SETME") {
 				return fmt.Errorf("the miner hasn't initialized yet")
 			}
 
-			p, err := peer.IDFromBytes(ret.Return)
-			if err != nil {
-				return err
-			}
-
-			pid = p
+			pid = *mi.PeerId
 		}
 
 		ask, err := api.ClientQueryAsk(ctx, pid, maddr)
@@ -322,6 +952,8 @@ var clientQueryAskCmd = &cli.Command{
 
 		fmt.Printf("Ask: %s\n", maddr)
 		fmt.Printf("Price per GiB: %s\n", types.FIL(ask.Ask.Price))
+		fmt.Printf("Verified Price per GiB: %s\n", types.FIL(ask.Ask.VerifiedPrice))
+		fmt.Printf("Max Piece size: %s\n", types.SizeStr(types.NewInt(uint64(ask.Ask.MaxPieceSize))))
 
 		size := cctx.Int64("size")
 		if size == 0 {
@@ -343,6 +975,22 @@ var clientQueryAskCmd = &cli.Command{
 var clientListDeals = &cli.Command{
 	Name:  "list-deals",
 	Usage: "List storage market deals",
+	Flags: []cli.Flag{
+		&cli.BoolFlag{
+			Name:    "verbose",
+			Aliases: []string{"v"},
+			Usage:   "print verbose deal details",
+		},
+		&cli.BoolFlag{
+			Name:  "color",
+			Usage: "use color in display output",
+			Value: true,
+		},
+		&cli.BoolFlag{
+			Name:  "watch",
+			Usage: "watch deal updates in real-time, rather than a one time list",
+		},
+	},
 	Action: func(cctx *cli.Context) error {
 		api, closer, err := GetFullNodeAPI(cctx)
 		if err != nil {
@@ -351,16 +999,439 @@ var clientListDeals = &cli.Command{
 		defer closer()
 		ctx := ReqContext(cctx)
 
-		deals, err := api.ClientListDeals(ctx)
+		verbose := cctx.Bool("verbose")
+		color := cctx.Bool("color")
+		watch := cctx.Bool("watch")
+
+		localDeals, err := api.ClientListDeals(ctx)
 		if err != nil {
 			return err
 		}
 
-		w := tabwriter.NewWriter(os.Stdout, 2, 4, 2, ' ', 0)
-		fmt.Fprintf(w, "DealCid\tProvider\tState\tPieceRef\tSize\tPrice\tDuration\n")
-		for _, d := range deals {
-			fmt.Fprintf(w, "%s\t%s\t%s\t%x\t%d\t%s\t%d\n", d.ProposalCid, d.Provider, lapi.DealStates[d.State], d.PieceRef, d.Size, d.PricePerEpoch, d.Duration)
+		if watch {
+			updates, err := api.ClientGetDealUpdates(ctx)
+			if err != nil {
+				return err
+			}
+
+			for {
+				tm.Clear()
+				tm.MoveCursor(1, 1)
+
+				err = outputStorageDeals(ctx, tm.Screen, api, localDeals, verbose, color)
+				if err != nil {
+					return err
+				}
+
+				tm.Flush()
+
+				select {
+				case <-ctx.Done():
+					return nil
+				case updated := <-updates:
+					var found bool
+					for i, existing := range localDeals {
+						if existing.ProposalCid.Equals(updated.ProposalCid) {
+							localDeals[i] = updated
+							found = true
+							break
+						}
+					}
+					if !found {
+						localDeals = append(localDeals, updated)
+					}
+				}
+			}
 		}
-		return w.Flush()
+
+		return outputStorageDeals(ctx, os.Stdout, api, localDeals, cctx.Bool("verbose"), cctx.Bool("color"))
 	},
 }
+
+func dealFromDealInfo(ctx context.Context, full api.FullNode, head *types.TipSet, v api.DealInfo) deal {
+	if v.DealID == 0 {
+		return deal{
+			LocalDeal:        v,
+			OnChainDealState: *market.EmptyDealState(),
+		}
+	}
+
+	onChain, err := full.StateMarketStorageDeal(ctx, v.DealID, head.Key())
+	if err != nil {
+		return deal{LocalDeal: v}
+	}
+
+	return deal{
+		LocalDeal:        v,
+		OnChainDealState: onChain.State,
+	}
+}
+
+func outputStorageDeals(ctx context.Context, out io.Writer, full api.FullNode, localDeals []api.DealInfo, verbose bool, color bool) error {
+	sort.Slice(localDeals, func(i, j int) bool {
+		return localDeals[i].CreationTime.Before(localDeals[j].CreationTime)
+	})
+
+	head, err := full.ChainHead(ctx)
+	if err != nil {
+		return err
+	}
+
+	var deals []deal
+	for _, localDeal := range localDeals {
+		deals = append(deals, dealFromDealInfo(ctx, full, head, localDeal))
+	}
+
+	if verbose {
+		w := tabwriter.NewWriter(out, 2, 4, 2, ' ', 0)
+		fmt.Fprintf(w, "Created\tDealCid\tDealId\tProvider\tState\tOn Chain?\tSlashed?\tPieceCID\tSize\tPrice\tDuration\tMessage\n")
+		for _, d := range deals {
+			onChain := "N"
+			if d.OnChainDealState.SectorStartEpoch != -1 {
+				onChain = fmt.Sprintf("Y (epoch %d)", d.OnChainDealState.SectorStartEpoch)
+			}
+
+			slashed := "N"
+			if d.OnChainDealState.SlashEpoch != -1 {
+				slashed = fmt.Sprintf("Y (epoch %d)", d.OnChainDealState.SlashEpoch)
+			}
+
+			price := types.FIL(types.BigMul(d.LocalDeal.PricePerEpoch, types.NewInt(d.LocalDeal.Duration)))
+			fmt.Fprintf(w, "%s\t%s\t%d\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%d\t%s\n", d.LocalDeal.CreationTime.Format(time.Stamp), d.LocalDeal.ProposalCid, d.LocalDeal.DealID, d.LocalDeal.Provider, dealStateString(color, d.LocalDeal.State), onChain, slashed, d.LocalDeal.PieceCID, types.SizeStr(types.NewInt(d.LocalDeal.Size)), price, d.LocalDeal.Duration, d.LocalDeal.Message)
+		}
+		return w.Flush()
+	}
+
+	w := tablewriter.New(tablewriter.Col("DealCid"),
+		tablewriter.Col("DealId"),
+		tablewriter.Col("Provider"),
+		tablewriter.Col("State"),
+		tablewriter.Col("On Chain?"),
+		tablewriter.Col("Slashed?"),
+		tablewriter.Col("PieceCID"),
+		tablewriter.Col("Size"),
+		tablewriter.Col("Price"),
+		tablewriter.Col("Duration"),
+		tablewriter.NewLineCol("Message"))
+
+	for _, d := range deals {
+		propcid := ellipsis(d.LocalDeal.ProposalCid.String(), 8)
+
+		onChain := "N"
+		if d.OnChainDealState.SectorStartEpoch != -1 {
+			onChain = fmt.Sprintf("Y (epoch %d)", d.OnChainDealState.SectorStartEpoch)
+		}
+
+		slashed := "N"
+		if d.OnChainDealState.SlashEpoch != -1 {
+			slashed = fmt.Sprintf("Y (epoch %d)", d.OnChainDealState.SlashEpoch)
+		}
+
+		piece := ellipsis(d.LocalDeal.PieceCID.String(), 8)
+
+		price := types.FIL(types.BigMul(d.LocalDeal.PricePerEpoch, types.NewInt(d.LocalDeal.Duration)))
+
+		w.Write(map[string]interface{}{
+			"DealCid":   propcid,
+			"DealId":    d.LocalDeal.DealID,
+			"Provider":  d.LocalDeal.Provider,
+			"State":     dealStateString(color, d.LocalDeal.State),
+			"On Chain?": onChain,
+			"Slashed?":  slashed,
+			"PieceCID":  piece,
+			"Size":      types.SizeStr(types.NewInt(d.LocalDeal.Size)),
+			"Price":     price,
+			"Duration":  d.LocalDeal.Duration,
+			"Message":   d.LocalDeal.Message,
+		})
+	}
+
+	return w.Flush(out)
+}
+
+func dealStateString(c bool, state storagemarket.StorageDealStatus) string {
+	s := storagemarket.DealStates[state]
+	if !c {
+		return s
+	}
+
+	switch state {
+	case storagemarket.StorageDealError, storagemarket.StorageDealExpired:
+		return color.RedString(s)
+	case storagemarket.StorageDealActive:
+		return color.GreenString(s)
+	default:
+		return s
+	}
+}
+
+type deal struct {
+	LocalDeal        lapi.DealInfo
+	OnChainDealState market.DealState
+}
+
+var clientGetDealCmd = &cli.Command{
+	Name:  "get-deal",
+	Usage: "Print detailed deal information",
+	Action: func(cctx *cli.Context) error {
+		if !cctx.Args().Present() {
+			return cli.ShowCommandHelp(cctx, cctx.Command.Name)
+		}
+
+		api, closer, err := GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+		ctx := ReqContext(cctx)
+
+		propcid, err := cid.Decode(cctx.Args().First())
+		if err != nil {
+			return err
+		}
+
+		di, err := api.ClientGetDealInfo(ctx, propcid)
+		if err != nil {
+			return err
+		}
+
+		out := map[string]interface{}{
+			"DealInfo: ": di,
+		}
+
+		if di.DealID != 0 {
+			onChain, err := api.StateMarketStorageDeal(ctx, di.DealID, types.EmptyTSK)
+			if err != nil {
+				return err
+			}
+
+			out["OnChain"] = onChain
+		}
+
+		b, err := json.MarshalIndent(out, "", "  ")
+		if err != nil {
+			return err
+		}
+		fmt.Println(string(b))
+		return nil
+	},
+}
+
+var clientInfoCmd = &cli.Command{
+	Name:  "info",
+	Usage: "Print storage market client information",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:  "client",
+			Usage: "specify storage client address",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		api, closer, err := GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+		ctx := ReqContext(cctx)
+
+		var addr address.Address
+		if clientFlag := cctx.String("client"); clientFlag != "" {
+			ca, err := address.NewFromString("client")
+			if err != nil {
+				return err
+			}
+
+			addr = ca
+		} else {
+			def, err := api.WalletDefaultAddress(ctx)
+			if err != nil {
+				return err
+			}
+			addr = def
+		}
+
+		balance, err := api.StateMarketBalance(ctx, addr, types.EmptyTSK)
+		if err != nil {
+			return err
+		}
+
+		fmt.Printf("Client Market Info:\n")
+
+		fmt.Printf("Locked Funds:\t%s\n", types.FIL(balance.Locked))
+		fmt.Printf("Escrowed Funds:\t%s\n", types.FIL(balance.Escrow))
+
+		return nil
+	},
+}
+
+var clientListTransfers = &cli.Command{
+	Name:  "list-transfers",
+	Usage: "List ongoing data transfers for deals",
+	Flags: []cli.Flag{
+		&cli.BoolFlag{
+			Name:  "color",
+			Usage: "use color in display output",
+			Value: true,
+		},
+		&cli.BoolFlag{
+			Name:  "completed",
+			Usage: "show completed data transfers",
+		},
+		&cli.BoolFlag{
+			Name:  "watch",
+			Usage: "watch deal updates in real-time, rather than a one time list",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		api, closer, err := GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+		ctx := ReqContext(cctx)
+
+		channels, err := api.ClientListDataTransfers(ctx)
+		if err != nil {
+			return err
+		}
+
+		completed := cctx.Bool("completed")
+		color := cctx.Bool("color")
+		watch := cctx.Bool("watch")
+
+		if watch {
+			channelUpdates, err := api.ClientDataTransferUpdates(ctx)
+			if err != nil {
+				return err
+			}
+
+			for {
+				tm.Clear() // Clear current screen
+
+				tm.MoveCursor(1, 1)
+
+				OutputDataTransferChannels(tm.Screen, channels, completed, color)
+
+				tm.Flush()
+
+				select {
+				case <-ctx.Done():
+					return nil
+				case channelUpdate := <-channelUpdates:
+					var found bool
+					for i, existing := range channels {
+						if existing.TransferID == channelUpdate.TransferID &&
+							existing.OtherPeer == channelUpdate.OtherPeer &&
+							existing.IsSender == channelUpdate.IsSender &&
+							existing.IsInitiator == channelUpdate.IsInitiator {
+							channels[i] = channelUpdate
+							found = true
+							break
+						}
+					}
+					if !found {
+						channels = append(channels, channelUpdate)
+					}
+				}
+			}
+		}
+		OutputDataTransferChannels(os.Stdout, channels, completed, color)
+		return nil
+	},
+}
+
+// OutputDataTransferChannels generates table output for a list of channels
+func OutputDataTransferChannels(out io.Writer, channels []lapi.DataTransferChannel, completed bool, color bool) {
+	sort.Slice(channels, func(i, j int) bool {
+		return channels[i].TransferID < channels[j].TransferID
+	})
+
+	var receivingChannels, sendingChannels []lapi.DataTransferChannel
+	for _, channel := range channels {
+		if !completed && channel.Status == datatransfer.Completed {
+			continue
+		}
+		if channel.IsSender {
+			sendingChannels = append(sendingChannels, channel)
+		} else {
+			receivingChannels = append(receivingChannels, channel)
+		}
+	}
+
+	fmt.Fprintf(out, "Sending Channels\n\n")
+	w := tablewriter.New(tablewriter.Col("ID"),
+		tablewriter.Col("Status"),
+		tablewriter.Col("Sending To"),
+		tablewriter.Col("Root Cid"),
+		tablewriter.Col("Initiated?"),
+		tablewriter.Col("Transferred"),
+		tablewriter.Col("Voucher"),
+		tablewriter.NewLineCol("Message"))
+	for _, channel := range sendingChannels {
+		w.Write(toChannelOutput(color, "Sending To", channel))
+	}
+	w.Flush(out) //nolint:errcheck
+
+	fmt.Fprintf(out, "\nReceiving Channels\n\n")
+	w = tablewriter.New(tablewriter.Col("ID"),
+		tablewriter.Col("Status"),
+		tablewriter.Col("Receiving From"),
+		tablewriter.Col("Root Cid"),
+		tablewriter.Col("Initiated?"),
+		tablewriter.Col("Transferred"),
+		tablewriter.Col("Voucher"),
+		tablewriter.NewLineCol("Message"))
+	for _, channel := range receivingChannels {
+		w.Write(toChannelOutput(color, "Receiving From", channel))
+	}
+	w.Flush(out) //nolint:errcheck
+}
+
+func channelStatusString(useColor bool, status datatransfer.Status) string {
+	s := datatransfer.Statuses[status]
+	if !useColor {
+		return s
+	}
+
+	switch status {
+	case datatransfer.Failed, datatransfer.Cancelled:
+		return color.RedString(s)
+	case datatransfer.Completed:
+		return color.GreenString(s)
+	default:
+		return s
+	}
+}
+
+func toChannelOutput(useColor bool, otherPartyColumn string, channel lapi.DataTransferChannel) map[string]interface{} {
+	rootCid := ellipsis(channel.BaseCID.String(), 8)
+	otherParty := ellipsis(channel.OtherPeer.String(), 8)
+
+	initiated := "N"
+	if channel.IsInitiator {
+		initiated = "Y"
+	}
+
+	voucher := channel.Voucher
+	if len(voucher) > 40 {
+		voucher = ellipsis(voucher, 37)
+	}
+
+	return map[string]interface{}{
+		"ID":             channel.TransferID,
+		"Status":         channelStatusString(useColor, channel.Status),
+		otherPartyColumn: otherParty,
+		"Root Cid":       rootCid,
+		"Initiated?":     initiated,
+		"Transferred":    channel.Transferred,
+		"Voucher":        voucher,
+		"Message":        channel.Message,
+	}
+}
+
+func ellipsis(s string, length int) string {
+	if length > 0 && len(s) > length {
+		return "..." + s[len(s)-length:]
+	}
+	return s
+}
diff --git a/cli/cmd.go b/cli/cmd.go
index 9eff3e541..c6617dcfd 100644
--- a/cli/cmd.go
+++ b/cli/cmd.go
@@ -9,25 +9,40 @@ import (
 	"strings"
 	"syscall"
 
-	logging "github.com/ipfs/go-log"
+	logging "github.com/ipfs/go-log/v2"
 	"github.com/mitchellh/go-homedir"
 	"github.com/multiformats/go-multiaddr"
-	manet "github.com/multiformats/go-multiaddr-net"
+	manet "github.com/multiformats/go-multiaddr/net"
+	"github.com/urfave/cli/v2"
 	"golang.org/x/xerrors"
-	"gopkg.in/urfave/cli.v2"
+
+	"github.com/filecoin-project/go-jsonrpc"
 
 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/api/client"
-	"github.com/filecoin-project/lotus/lib/jsonrpc"
 	"github.com/filecoin-project/lotus/node/repo"
 )
 
 var log = logging.Logger("cli")
 
 const (
-	metadataTraceConetxt = "traceContext"
+	metadataTraceContext = "traceContext"
 )
 
+// custom CLI error
+
+type ErrCmdFailed struct {
+	msg string
+}
+
+func (e *ErrCmdFailed) Error() string {
+	return e.msg
+}
+
+func NewCliError(s string) error {
+	return &ErrCmdFailed{s}
+}
+
 // ApiConnector returns API instance
 type ApiConnector func() api.FullNode
 
@@ -52,37 +67,94 @@ func (a APIInfo) AuthHeader() http.Header {
 	return nil
 }
 
+// The flag passed on the command line with the listen address of the API
+// server (only used by the tests)
+func flagForAPI(t repo.RepoType) string {
+	switch t {
+	case repo.FullNode:
+		return "api"
+	case repo.StorageMiner:
+		return "miner-api"
+	case repo.Worker:
+		return "worker-api"
+	default:
+		panic(fmt.Sprintf("Unknown repo type: %v", t))
+	}
+}
+
 func flagForRepo(t repo.RepoType) string {
 	switch t {
 	case repo.FullNode:
 		return "repo"
 	case repo.StorageMiner:
-		return "storagerepo"
+		return "miner-repo"
+	case repo.Worker:
+		return "worker-repo"
 	default:
 		panic(fmt.Sprintf("Unknown repo type: %v", t))
 	}
 }
 
 func envForRepo(t repo.RepoType) string {
+	switch t {
+	case repo.FullNode:
+		return "FULLNODE_API_INFO"
+	case repo.StorageMiner:
+		return "MINER_API_INFO"
+	case repo.Worker:
+		return "WORKER_API_INFO"
+	default:
+		panic(fmt.Sprintf("Unknown repo type: %v", t))
+	}
+}
+
+// TODO remove after deprecation period
+func envForRepoDeprecation(t repo.RepoType) string {
 	switch t {
 	case repo.FullNode:
 		return "FULLNODE_API_INFO"
 	case repo.StorageMiner:
 		return "STORAGE_API_INFO"
+	case repo.Worker:
+		return "WORKER_API_INFO"
 	default:
 		panic(fmt.Sprintf("Unknown repo type: %v", t))
 	}
 }
 
 func GetAPIInfo(ctx *cli.Context, t repo.RepoType) (APIInfo, error) {
-	if env, ok := os.LookupEnv(envForRepo(t)); ok {
+	// Check if there was a flag passed with the listen address of the API
+	// server (only used by the tests)
+	apiFlag := flagForAPI(t)
+	if ctx.IsSet(apiFlag) {
+		strma := ctx.String(apiFlag)
+		strma = strings.TrimSpace(strma)
+
+		apima, err := multiaddr.NewMultiaddr(strma)
+		if err != nil {
+			return APIInfo{}, err
+		}
+		return APIInfo{Addr: apima}, nil
+	}
+
+	envKey := envForRepo(t)
+	env, ok := os.LookupEnv(envKey)
+	if !ok {
+		// TODO remove after deprecation period
+		envKey = envForRepoDeprecation(t)
+		env, ok = os.LookupEnv(envKey)
+		if ok {
+			log.Warnf("Use deprecation env(%s) value, please use env(%s) instead.", envKey, envForRepo(t))
+		}
+	}
+	if ok {
 		sp := strings.SplitN(env, ":", 2)
 		if len(sp) != 2 {
-			log.Warnf("invalid env(%s) value, missing token or address", envForRepo(t))
+			log.Warnf("invalid env(%s) value, missing token or address", envKey)
 		} else {
 			ma, err := multiaddr.NewMultiaddr(sp[1])
 			if err != nil {
-				return APIInfo{}, xerrors.Errorf("could not parse multiaddr from env(%s): %w", envForRepo(t), err)
+				return APIInfo{}, xerrors.Errorf("could not parse multiaddr from env(%s): %w", envKey, err)
 			}
 			return APIInfo{
 				Addr:  ma,
@@ -95,7 +167,7 @@ func GetAPIInfo(ctx *cli.Context, t repo.RepoType) (APIInfo, error) {
 
 	p, err := homedir.Expand(ctx.String(repoFlag))
 	if err != nil {
-		return APIInfo{}, xerrors.Errorf("cound not exand home dir (%s): %w", repoFlag, err)
+		return APIInfo{}, xerrors.Errorf("could not expand home dir (%s): %w", repoFlag, err)
 	}
 
 	r, err := repo.NewFS(p)
@@ -105,7 +177,7 @@ func GetAPIInfo(ctx *cli.Context, t repo.RepoType) (APIInfo, error) {
 
 	ma, err := r.APIEndpoint()
 	if err != nil {
-		return APIInfo{}, xerrors.Errorf("could not get api enpoint: %w", err)
+		return APIInfo{}, xerrors.Errorf("could not get api endpoint: %w", err)
 	}
 
 	token, err := r.APIToken()
@@ -120,7 +192,6 @@ func GetAPIInfo(ctx *cli.Context, t repo.RepoType) (APIInfo, error) {
 }
 
 func GetRawAPI(ctx *cli.Context, t repo.RepoType) (string, http.Header, error) {
-
 	ainfo, err := GetAPIInfo(ctx, t)
 	if err != nil {
 		return "", nil, xerrors.Errorf("could not get API info: %w", err)
@@ -150,7 +221,7 @@ func GetAPI(ctx *cli.Context) (api.Common, jsonrpc.ClientCloser, error) {
 		return nil, nil, err
 	}
 
-	return client.NewCommonRPC(addr, headers)
+	return client.NewCommonRPC(ctx.Context, addr, headers)
 }
 
 func GetFullNodeAPI(ctx *cli.Context) (api.FullNode, jsonrpc.ClientCloser, error) {
@@ -159,20 +230,29 @@ func GetFullNodeAPI(ctx *cli.Context) (api.FullNode, jsonrpc.ClientCloser, error
 		return nil, nil, err
 	}
 
-	return client.NewFullNodeRPC(addr, headers)
+	return client.NewFullNodeRPC(ctx.Context, addr, headers)
 }
 
-func GetStorageMinerAPI(ctx *cli.Context) (api.StorageMiner, jsonrpc.ClientCloser, error) {
+func GetStorageMinerAPI(ctx *cli.Context, opts ...jsonrpc.Option) (api.StorageMiner, jsonrpc.ClientCloser, error) {
 	addr, headers, err := GetRawAPI(ctx, repo.StorageMiner)
 	if err != nil {
 		return nil, nil, err
 	}
 
-	return client.NewStorageMinerRPC(addr, headers)
+	return client.NewStorageMinerRPC(ctx.Context, addr, headers, opts...)
+}
+
+func GetWorkerAPI(ctx *cli.Context) (api.WorkerAPI, jsonrpc.ClientCloser, error) {
+	addr, headers, err := GetRawAPI(ctx, repo.Worker)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	return client.NewWorkerRPC(ctx.Context, addr, headers)
 }
 
 func DaemonContext(cctx *cli.Context) context.Context {
-	if mtCtx, ok := cctx.App.Metadata[metadataTraceConetxt]; ok {
+	if mtCtx, ok := cctx.App.Metadata[metadataTraceContext]; ok {
 		return mtCtx.(context.Context)
 	}
 
@@ -191,22 +271,41 @@ func ReqContext(cctx *cli.Context) context.Context {
 		<-sigChan
 		done()
 	}()
-	signal.Notify(sigChan, syscall.SIGTERM, syscall.SIGINT)
+	signal.Notify(sigChan, syscall.SIGTERM, syscall.SIGINT, syscall.SIGHUP)
 
 	return ctx
 }
 
-var Commands = []*cli.Command{
-	authCmd,
-	chainCmd,
-	clientCmd,
-	fetchParamCmd,
-	mpoolCmd,
+var CommonCommands = []*cli.Command{
 	netCmd,
-	paychCmd,
-	sendCmd,
-	stateCmd,
-	syncCmd,
-	versionCmd,
-	walletCmd,
+	authCmd,
+	logCmd,
+	waitApiCmd,
+	fetchParamCmd,
+	pprofCmd,
+	VersionCmd,
+}
+
+var Commands = []*cli.Command{
+	WithCategory("basic", sendCmd),
+	WithCategory("basic", walletCmd),
+	WithCategory("basic", clientCmd),
+	WithCategory("basic", multisigCmd),
+	WithCategory("basic", paychCmd),
+	WithCategory("developer", authCmd),
+	WithCategory("developer", mpoolCmd),
+	WithCategory("developer", stateCmd),
+	WithCategory("developer", chainCmd),
+	WithCategory("developer", logCmd),
+	WithCategory("developer", waitApiCmd),
+	WithCategory("developer", fetchParamCmd),
+	WithCategory("network", netCmd),
+	WithCategory("network", syncCmd),
+	pprofCmd,
+	VersionCmd,
+}
+
+func WithCategory(cat string, cmd *cli.Command) *cli.Command {
+	cmd.Category = cat
+	return cmd
 }
diff --git a/cli/helper.go b/cli/helper.go
new file mode 100644
index 000000000..70a168145
--- /dev/null
+++ b/cli/helper.go
@@ -0,0 +1,46 @@
+package cli
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/urfave/cli/v2"
+	"golang.org/x/xerrors"
+)
+
+type PrintHelpErr struct {
+	Err error
+	Ctx *cli.Context
+}
+
+func (e *PrintHelpErr) Error() string {
+	return e.Err.Error()
+}
+
+func (e *PrintHelpErr) Unwrap() error {
+	return e.Err
+}
+
+func (e *PrintHelpErr) Is(o error) bool {
+	_, ok := o.(*PrintHelpErr)
+	return ok
+}
+
+func ShowHelp(cctx *cli.Context, err error) error {
+	return &PrintHelpErr{Err: err, Ctx: cctx}
+}
+
+func RunApp(app *cli.App) {
+	if err := app.Run(os.Args); err != nil {
+		if os.Getenv("LOTUS_DEV") != "" {
+			log.Warnf("%+v", err)
+		} else {
+			fmt.Printf("ERROR: %s\n\n", err)
+		}
+		var phe *PrintHelpErr
+		if xerrors.As(err, &phe) {
+			_ = cli.ShowCommandHelp(phe.Ctx, phe.Ctx.Command.Name)
+		}
+		os.Exit(1)
+	}
+}
diff --git a/cli/log.go b/cli/log.go
new file mode 100644
index 000000000..ed624eb8d
--- /dev/null
+++ b/cli/log.go
@@ -0,0 +1,102 @@
+package cli
+
+import (
+	"fmt"
+
+	"github.com/urfave/cli/v2"
+	"golang.org/x/xerrors"
+)
+
+var logCmd = &cli.Command{
+	Name:  "log",
+	Usage: "Manage logging",
+	Subcommands: []*cli.Command{
+		logList,
+		logSetLevel,
+	},
+}
+
+var logList = &cli.Command{
+	Name:  "list",
+	Usage: "List log systems",
+	Action: func(cctx *cli.Context) error {
+		api, closer, err := GetAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+
+		ctx := ReqContext(cctx)
+
+		systems, err := api.LogList(ctx)
+		if err != nil {
+			return err
+		}
+
+		for _, system := range systems {
+			fmt.Println(system)
+		}
+
+		return nil
+	},
+}
+
+var logSetLevel = &cli.Command{
+	Name:      "set-level",
+	Usage:     "Set log level",
+	ArgsUsage: "[level]",
+	Description: `Set the log level for logging systems:
+
+   The system flag can be specified multiple times.
+
+   eg) log set-level --system chain --system chainxchg debug
+
+   Available Levels:
+   debug
+   info
+   warn
+   error
+
+   Environment Variables:
+   GOLOG_LOG_LEVEL - Default log level for all log systems
+   GOLOG_LOG_FMT   - Change output log format (json, nocolor)
+   GOLOG_FILE      - Write logs to file
+   GOLOG_OUTPUT    - Specify whether to output to file, stderr, stdout or a combination, i.e. file+stderr
+`,
+	Flags: []cli.Flag{
+		&cli.StringSliceFlag{
+			Name:  "system",
+			Usage: "limit to log system",
+			Value: &cli.StringSlice{},
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		api, closer, err := GetAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+		ctx := ReqContext(cctx)
+
+		if !cctx.Args().Present() {
+			return fmt.Errorf("level is required")
+		}
+
+		systems := cctx.StringSlice("system")
+		if len(systems) == 0 {
+			var err error
+			systems, err = api.LogList(ctx)
+			if err != nil {
+				return err
+			}
+		}
+
+		for _, system := range systems {
+			if err := api.LogSetLevel(ctx, system, cctx.Args().First()); err != nil {
+				return xerrors.Errorf("setting log level on %s: %w", system, err)
+			}
+		}
+
+		return nil
+	},
+}
diff --git a/cli/mpool.go b/cli/mpool.go
index 2517e7df6..65f4ef942 100644
--- a/cli/mpool.go
+++ b/cli/mpool.go
@@ -3,11 +3,20 @@ package cli
 import (
 	"encoding/json"
 	"fmt"
+	stdbig "math/big"
+	"sort"
+	"strconv"
 
+	"github.com/urfave/cli/v2"
 	"golang.org/x/xerrors"
-	"gopkg.in/urfave/cli.v2"
 
 	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/big"
+
+	lapi "github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/messagepool"
 	"github.com/filecoin-project/lotus/chain/types"
 )
 
@@ -16,14 +25,25 @@ var mpoolCmd = &cli.Command{
 	Usage: "Manage message pool",
 	Subcommands: []*cli.Command{
 		mpoolPending,
+		mpoolClear,
 		mpoolSub,
 		mpoolStat,
+		mpoolReplaceCmd,
+		mpoolFindCmd,
+		mpoolConfig,
+		mpoolGasPerfCmd,
 	},
 }
 
 var mpoolPending = &cli.Command{
 	Name:  "pending",
 	Usage: "Get pending messages",
+	Flags: []cli.Flag{
+		&cli.BoolFlag{
+			Name:  "local",
+			Usage: "print pending messages for addresses in local wallet only",
+		},
+	},
 	Action: func(cctx *cli.Context) error {
 		api, closer, err := GetFullNodeAPI(cctx)
 		if err != nil {
@@ -33,12 +53,32 @@ var mpoolPending = &cli.Command{
 
 		ctx := ReqContext(cctx)
 
-		msgs, err := api.MpoolPending(ctx, nil)
+		var filter map[address.Address]struct{}
+		if cctx.Bool("local") {
+			filter = map[address.Address]struct{}{}
+
+			addrss, err := api.WalletList(ctx)
+			if err != nil {
+				return xerrors.Errorf("getting local addresses: %w", err)
+			}
+
+			for _, a := range addrss {
+				filter[a] = struct{}{}
+			}
+		}
+
+		msgs, err := api.MpoolPending(ctx, types.EmptyTSK)
 		if err != nil {
 			return err
 		}
 
 		for _, msg := range msgs {
+			if filter != nil {
+				if _, has := filter[msg.Message.From]; !has {
+					continue
+				}
+			}
+
 			out, err := json.MarshalIndent(msg, "", "  ")
 			if err != nil {
 				return err
@@ -50,9 +90,42 @@ var mpoolPending = &cli.Command{
 	},
 }
 
+var mpoolClear = &cli.Command{
+	Name:  "clear",
+	Usage: "Clear all pending messages from the mpool (USE WITH CARE)",
+	Flags: []cli.Flag{
+		&cli.BoolFlag{
+			Name:  "local",
+			Usage: "also clear local messages",
+		},
+		&cli.BoolFlag{
+			Name:  "really-do-it",
+			Usage: "must be specified for the action to take effect",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		api, closer, err := GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+
+		really := cctx.Bool("really-do-it")
+		if !really {
+			//nolint:golint
+			return fmt.Errorf("--really-do-it must be specified for this action to have an effect; you have been warned")
+		}
+
+		local := cctx.Bool("local")
+
+		ctx := ReqContext(cctx)
+		return api.MpoolClear(ctx, local)
+	},
+}
+
 var mpoolSub = &cli.Command{
 	Name:  "sub",
-	Usage: "Subscibe to mpool changes",
+	Usage: "Subscribe to mpool changes",
 	Action: func(cctx *cli.Context) error {
 		api, closer, err := GetFullNodeAPI(cctx)
 		if err != nil {
@@ -85,10 +158,20 @@ var mpoolSub = &cli.Command{
 type statBucket struct {
 	msgs map[uint64]*types.SignedMessage
 }
+type mpStat struct {
+	addr              string
+	past, cur, future uint64
+}
 
 var mpoolStat = &cli.Command{
 	Name:  "stat",
 	Usage: "print mempool stats",
+	Flags: []cli.Flag{
+		&cli.BoolFlag{
+			Name:  "local",
+			Usage: "print stats for addresses in local wallet only",
+		},
+	},
 	Action: func(cctx *cli.Context) error {
 		api, closer, err := GetFullNodeAPI(cctx)
 		if err != nil {
@@ -103,7 +186,21 @@ var mpoolStat = &cli.Command{
 			return xerrors.Errorf("getting chain head: %w", err)
 		}
 
-		msgs, err := api.MpoolPending(ctx, nil)
+		var filter map[address.Address]struct{}
+		if cctx.Bool("local") {
+			filter = map[address.Address]struct{}{}
+
+			addrss, err := api.WalletList(ctx)
+			if err != nil {
+				return xerrors.Errorf("getting local addresses: %w", err)
+			}
+
+			for _, a := range addrss {
+				filter[a] = struct{}{}
+			}
+		}
+
+		msgs, err := api.MpoolPending(ctx, types.EmptyTSK)
 		if err != nil {
 			return err
 		}
@@ -111,6 +208,12 @@ var mpoolStat = &cli.Command{
 		buckets := map[address.Address]*statBucket{}
 
 		for _, v := range msgs {
+			if filter != nil {
+				if _, has := filter[v.Message.From]; !has {
+					continue
+				}
+			}
+
 			bkt, ok := buckets[v.Message.From]
 			if !ok {
 				bkt = &statBucket{
@@ -121,10 +224,14 @@ var mpoolStat = &cli.Command{
 
 			bkt.msgs[v.Message.Nonce] = v
 		}
+
+		var out []mpStat
+
 		for a, bkt := range buckets {
-			act, err := api.StateGetActor(ctx, a, ts)
+			act, err := api.StateGetActor(ctx, a, ts.Key())
 			if err != nil {
-				return err
+				fmt.Printf("%s, err: %s\n", a, err)
+				continue
 			}
 
 			cur := act.Nonce
@@ -136,8 +243,8 @@ var mpoolStat = &cli.Command{
 				cur++
 			}
 
-			past := 0
-			future := 0
+			past := uint64(0)
+			future := uint64(0)
 			for _, m := range bkt.msgs {
 				if m.Message.Nonce < act.Nonce {
 					past++
@@ -147,7 +254,366 @@ var mpoolStat = &cli.Command{
 				}
 			}
 
-			fmt.Printf("%s, past: %d, cur: %d, future: %d\n", a, past, cur-act.Nonce, future)
+			out = append(out, mpStat{
+				addr:   a.String(),
+				past:   past,
+				cur:    cur - act.Nonce,
+				future: future,
+			})
+		}
+
+		sort.Slice(out, func(i, j int) bool {
+			return out[i].addr < out[j].addr
+		})
+
+		var total mpStat
+
+		for _, stat := range out {
+			total.past += stat.past
+			total.cur += stat.cur
+			total.future += stat.future
+
+			fmt.Printf("%s: past: %d, cur: %d, future: %d\n", stat.addr, stat.past, stat.cur, stat.future)
+		}
+
+		fmt.Println("-----")
+		fmt.Printf("total: past: %d, cur: %d, future: %d\n", total.past, total.cur, total.future)
+
+		return nil
+	},
+}
+
+var mpoolReplaceCmd = &cli.Command{
+	Name:  "replace",
+	Usage: "replace a message in the mempool",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:  "gas-feecap",
+			Usage: "gas feecap for new message",
+		},
+		&cli.StringFlag{
+			Name:  "gas-premium",
+			Usage: "gas price for new message",
+		},
+		&cli.Int64Flag{
+			Name:  "gas-limit",
+			Usage: "gas price for new message",
+		},
+		&cli.BoolFlag{
+			Name:  "auto",
+			Usage: "automatically reprice the specified message",
+		},
+		&cli.StringFlag{
+			Name:  "max-fee",
+			Usage: "Spend up to X FIL for this message (applicable for auto mode)",
+		},
+	},
+	ArgsUsage: "[from] [nonce]",
+	Action: func(cctx *cli.Context) error {
+		if cctx.Args().Len() < 2 {
+			return cli.ShowCommandHelp(cctx, cctx.Command.Name)
+		}
+
+		from, err := address.NewFromString(cctx.Args().Get(0))
+		if err != nil {
+			return err
+		}
+
+		nonce, err := strconv.ParseUint(cctx.Args().Get(1), 10, 64)
+		if err != nil {
+			return err
+		}
+
+		api, closer, err := GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+
+		ctx := ReqContext(cctx)
+
+		ts, err := api.ChainHead(ctx)
+		if err != nil {
+			return xerrors.Errorf("getting chain head: %w", err)
+		}
+
+		pending, err := api.MpoolPending(ctx, ts.Key())
+		if err != nil {
+			return err
+		}
+
+		var found *types.SignedMessage
+		for _, p := range pending {
+			if p.Message.From == from && p.Message.Nonce == nonce {
+				found = p
+				break
+			}
+		}
+
+		if found == nil {
+			return fmt.Errorf("no pending message found from %s with nonce %d", from, nonce)
+		}
+
+		msg := found.Message
+
+		if cctx.Bool("auto") {
+			minRBF := messagepool.ComputeMinRBF(msg.GasPremium)
+
+			var mss *lapi.MessageSendSpec
+			if cctx.IsSet("max-fee") {
+				maxFee, err := types.BigFromString(cctx.String("max-fee"))
+				if err != nil {
+					return fmt.Errorf("parsing max-spend: %w", err)
+				}
+				mss = &lapi.MessageSendSpec{
+					MaxFee: maxFee,
+				}
+			}
+
+			// msg.GasLimit = 0 // TODO: need to fix the way we estimate gas limits to account for the messages already being in the mempool
+			msg.GasFeeCap = abi.NewTokenAmount(0)
+			msg.GasPremium = abi.NewTokenAmount(0)
+			retm, err := api.GasEstimateMessageGas(ctx, &msg, mss, types.EmptyTSK)
+			if err != nil {
+				return fmt.Errorf("failed to estimate gas values: %w", err)
+			}
+
+			msg.GasPremium = big.Max(retm.GasPremium, minRBF)
+			msg.GasFeeCap = big.Max(retm.GasFeeCap, msg.GasPremium)
+			messagepool.CapGasFee(&msg, mss.Get().MaxFee)
+		} else {
+			msg.GasLimit = cctx.Int64("gas-limit")
+			msg.GasPremium, err = types.BigFromString(cctx.String("gas-premium"))
+			if err != nil {
+				return fmt.Errorf("parsing gas-premium: %w", err)
+			}
+			// TODO: estimate fee cap here
+			msg.GasFeeCap, err = types.BigFromString(cctx.String("gas-feecap"))
+			if err != nil {
+				return fmt.Errorf("parsing gas-feecap: %w", err)
+			}
+		}
+
+		smsg, err := api.WalletSignMessage(ctx, msg.From, &msg)
+		if err != nil {
+			return fmt.Errorf("failed to sign message: %w", err)
+		}
+
+		cid, err := api.MpoolPush(ctx, smsg)
+		if err != nil {
+			return fmt.Errorf("failed to push new message to mempool: %w", err)
+		}
+
+		fmt.Println("new message cid: ", cid)
+		return nil
+	},
+}
+
+var mpoolFindCmd = &cli.Command{
+	Name:  "find",
+	Usage: "find a message in the mempool",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:  "from",
+			Usage: "search for messages with given 'from' address",
+		},
+		&cli.StringFlag{
+			Name:  "to",
+			Usage: "search for messages with given 'to' address",
+		},
+		&cli.Int64Flag{
+			Name:  "method",
+			Usage: "search for messages with given method",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		api, closer, err := GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+
+		ctx := ReqContext(cctx)
+
+		pending, err := api.MpoolPending(ctx, types.EmptyTSK)
+		if err != nil {
+			return err
+		}
+
+		var toFilter, fromFilter address.Address
+		if cctx.IsSet("to") {
+			a, err := address.NewFromString(cctx.String("to"))
+			if err != nil {
+				return fmt.Errorf("'to' address was invalid: %w", err)
+			}
+
+			toFilter = a
+		}
+
+		if cctx.IsSet("from") {
+			a, err := address.NewFromString(cctx.String("from"))
+			if err != nil {
+				return fmt.Errorf("'from' address was invalid: %w", err)
+			}
+
+			fromFilter = a
+		}
+
+		var methodFilter *abi.MethodNum
+		if cctx.IsSet("method") {
+			m := abi.MethodNum(cctx.Int64("method"))
+			methodFilter = &m
+		}
+
+		var out []*types.SignedMessage
+		for _, m := range pending {
+			if toFilter != address.Undef && m.Message.To != toFilter {
+				continue
+			}
+
+			if fromFilter != address.Undef && m.Message.From != fromFilter {
+				continue
+			}
+
+			if methodFilter != nil && *methodFilter != m.Message.Method {
+				continue
+			}
+
+			out = append(out, m)
+		}
+
+		b, err := json.MarshalIndent(out, "", "  ")
+		if err != nil {
+			return err
+		}
+
+		fmt.Println(string(b))
+		return nil
+	},
+}
+
+var mpoolConfig = &cli.Command{
+	Name:      "config",
+	Usage:     "get or set current mpool configuration",
+	ArgsUsage: "[new-config]",
+	Action: func(cctx *cli.Context) error {
+		if cctx.Args().Len() > 1 {
+			return cli.ShowCommandHelp(cctx, cctx.Command.Name)
+		}
+
+		api, closer, err := GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+
+		ctx := ReqContext(cctx)
+
+		if cctx.Args().Len() == 0 {
+			cfg, err := api.MpoolGetConfig(ctx)
+			if err != nil {
+				return err
+			}
+
+			bytes, err := json.Marshal(cfg)
+			if err != nil {
+				return err
+			}
+
+			fmt.Println(string(bytes))
+		} else {
+			cfg := new(types.MpoolConfig)
+			bytes := []byte(cctx.Args().Get(0))
+
+			err := json.Unmarshal(bytes, cfg)
+			if err != nil {
+				return err
+			}
+
+			return api.MpoolSetConfig(ctx, cfg)
+		}
+
+		return nil
+	},
+}
+
+var mpoolGasPerfCmd = &cli.Command{
+	Name:  "gas-perf",
+	Usage: "Check gas performance of messages in mempool",
+	Flags: []cli.Flag{
+		&cli.BoolFlag{
+			Name:  "all",
+			Usage: "print gas performance for all mempool messages (default only prints for local)",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		api, closer, err := GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+
+		ctx := ReqContext(cctx)
+
+		msgs, err := api.MpoolPending(ctx, types.EmptyTSK)
+		if err != nil {
+			return err
+		}
+
+		var filter map[address.Address]struct{}
+		if !cctx.Bool("all") {
+			filter = map[address.Address]struct{}{}
+
+			addrss, err := api.WalletList(ctx)
+			if err != nil {
+				return xerrors.Errorf("getting local addresses: %w", err)
+			}
+
+			for _, a := range addrss {
+				filter[a] = struct{}{}
+			}
+
+			var filtered []*types.SignedMessage
+			for _, msg := range msgs {
+				if _, has := filter[msg.Message.From]; !has {
+					continue
+				}
+				filtered = append(filtered, msg)
+			}
+			msgs = filtered
+		}
+
+		ts, err := api.ChainHead(ctx)
+		if err != nil {
+			return xerrors.Errorf("failed to get chain head: %w", err)
+		}
+
+		baseFee := ts.Blocks()[0].ParentBaseFee
+
+		bigBlockGasLimit := big.NewInt(build.BlockGasLimit)
+
+		getGasReward := func(msg *types.SignedMessage) big.Int {
+			maxPremium := types.BigSub(msg.Message.GasFeeCap, baseFee)
+			if types.BigCmp(maxPremium, msg.Message.GasPremium) < 0 {
+				maxPremium = msg.Message.GasPremium
+			}
+			return types.BigMul(maxPremium, types.NewInt(uint64(msg.Message.GasLimit)))
+		}
+
+		getGasPerf := func(gasReward big.Int, gasLimit int64) float64 {
+			// gasPerf = gasReward * build.BlockGasLimit / gasLimit
+			a := new(stdbig.Rat).SetInt(new(stdbig.Int).Mul(gasReward.Int, bigBlockGasLimit.Int))
+			b := stdbig.NewRat(1, gasLimit)
+			c := new(stdbig.Rat).Mul(a, b)
+			r, _ := c.Float64()
+			return r
+		}
+
+		for _, m := range msgs {
+			gasReward := getGasReward(m)
+			gasPerf := getGasPerf(gasReward, m.Message.GasLimit)
+
+			fmt.Printf("%s\t%d\t%s\t%f\n", m.Message.From, m.Message.Nonce, gasReward, gasPerf)
 		}
 
 		return nil
diff --git a/cli/multisig.go b/cli/multisig.go
new file mode 100644
index 000000000..5b0977382
--- /dev/null
+++ b/cli/multisig.go
@@ -0,0 +1,1301 @@
+package cli
+
+import (
+	"bytes"
+	"encoding/hex"
+	"fmt"
+	"os"
+	"sort"
+	"strconv"
+	"text/tabwriter"
+
+	"github.com/filecoin-project/lotus/chain/actors"
+
+	"github.com/filecoin-project/go-state-types/big"
+
+	"github.com/filecoin-project/go-state-types/abi"
+
+	"github.com/filecoin-project/go-address"
+	cbor "github.com/ipfs/go-ipld-cbor"
+	"github.com/urfave/cli/v2"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/specs-actors/actors/builtin"
+	init0 "github.com/filecoin-project/specs-actors/actors/builtin/init"
+	msig0 "github.com/filecoin-project/specs-actors/actors/builtin/multisig"
+
+	"github.com/filecoin-project/lotus/api/apibstore"
+	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/actors/adt"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/multisig"
+	"github.com/filecoin-project/lotus/chain/types"
+)
+
+var multisigCmd = &cli.Command{
+	Name:  "msig",
+	Usage: "Interact with a multisig wallet",
+	Subcommands: []*cli.Command{
+		msigCreateCmd,
+		msigInspectCmd,
+		msigProposeCmd,
+		msigApproveCmd,
+		msigAddProposeCmd,
+		msigAddApproveCmd,
+		msigAddCancelCmd,
+		msigSwapProposeCmd,
+		msigSwapApproveCmd,
+		msigSwapCancelCmd,
+		msigLockProposeCmd,
+		msigLockApproveCmd,
+		msigLockCancelCmd,
+		msigVestedCmd,
+	},
+}
+
+var msigCreateCmd = &cli.Command{
+	Name:      "create",
+	Usage:     "Create a new multisig wallet",
+	ArgsUsage: "[address1 address2 ...]",
+	Flags: []cli.Flag{
+		&cli.Int64Flag{
+			Name:  "required",
+			Usage: "number of required approvals (uses number of signers provided if omitted)",
+		},
+		&cli.StringFlag{
+			Name:  "value",
+			Usage: "initial funds to give to multisig",
+			Value: "0",
+		},
+		&cli.StringFlag{
+			Name:  "duration",
+			Usage: "length of the period over which funds unlock",
+			Value: "0",
+		},
+		&cli.StringFlag{
+			Name:  "from",
+			Usage: "account to send the create message from",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		if cctx.Args().Len() < 1 {
+			return ShowHelp(cctx, fmt.Errorf("multisigs must have at least one signer"))
+		}
+
+		api, closer, err := GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+		ctx := ReqContext(cctx)
+
+		var addrs []address.Address
+		for _, a := range cctx.Args().Slice() {
+			addr, err := address.NewFromString(a)
+			if err != nil {
+				return err
+			}
+			addrs = append(addrs, addr)
+		}
+
+		// get the address we're going to use to create the multisig (can be one of the above, as long as they have funds)
+		var sendAddr address.Address
+		if send := cctx.String("from"); send == "" {
+			defaddr, err := api.WalletDefaultAddress(ctx)
+			if err != nil {
+				return err
+			}
+
+			sendAddr = defaddr
+		} else {
+			addr, err := address.NewFromString(send)
+			if err != nil {
+				return err
+			}
+
+			sendAddr = addr
+		}
+
+		val := cctx.String("value")
+		filval, err := types.ParseFIL(val)
+		if err != nil {
+			return err
+		}
+
+		intVal := types.BigInt(filval)
+
+		required := cctx.Uint64("required")
+		if required == 0 {
+			required = uint64(len(addrs))
+		}
+
+		d := abi.ChainEpoch(cctx.Uint64("duration"))
+
+		gp := types.NewInt(1)
+
+		msgCid, err := api.MsigCreate(ctx, required, addrs, d, intVal, sendAddr, gp)
+		if err != nil {
+			return err
+		}
+
+		// wait for it to get mined into a block
+		wait, err := api.StateWaitMsg(ctx, msgCid, build.MessageConfidence)
+		if err != nil {
+			return err
+		}
+
+		// check it executed successfully
+		if wait.Receipt.ExitCode != 0 {
+			fmt.Println("actor creation failed!")
+			return err
+		}
+
+		// get address of newly created miner
+
+		var execreturn init0.ExecReturn
+		if err := execreturn.UnmarshalCBOR(bytes.NewReader(wait.Receipt.Return)); err != nil {
+			return err
+		}
+		fmt.Println("Created new multisig: ", execreturn.IDAddress, execreturn.RobustAddress)
+
+		// TODO: maybe register this somewhere
+		return nil
+	},
+}
+
+var msigInspectCmd = &cli.Command{
+	Name:      "inspect",
+	Usage:     "Inspect a multisig wallet",
+	ArgsUsage: "[address]",
+	Flags: []cli.Flag{
+		&cli.BoolFlag{
+			Name:  "vesting",
+			Usage: "Include vesting details",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		if !cctx.Args().Present() {
+			return ShowHelp(cctx, fmt.Errorf("must specify address of multisig to inspect"))
+		}
+
+		api, closer, err := GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+		ctx := ReqContext(cctx)
+
+		store := adt.WrapStore(ctx, cbor.NewCborStore(apibstore.NewAPIBlockstore(api)))
+
+		maddr, err := address.NewFromString(cctx.Args().First())
+		if err != nil {
+			return err
+		}
+
+		head, err := api.ChainHead(ctx)
+		if err != nil {
+			return err
+		}
+
+		act, err := api.StateGetActor(ctx, maddr, head.Key())
+		if err != nil {
+			return err
+		}
+
+		mstate, err := multisig.Load(store, act)
+		if err != nil {
+			return err
+		}
+		locked, err := mstate.LockedBalance(head.Height())
+		if err != nil {
+			return err
+		}
+
+		fmt.Printf("Balance: %s\n", types.FIL(act.Balance))
+		fmt.Printf("Spendable: %s\n", types.FIL(types.BigSub(act.Balance, locked)))
+
+		if cctx.Bool("vesting") {
+			ib, err := mstate.InitialBalance()
+			if err != nil {
+				return err
+			}
+			fmt.Printf("InitialBalance: %s\n", types.FIL(ib))
+			se, err := mstate.StartEpoch()
+			if err != nil {
+				return err
+			}
+			fmt.Printf("StartEpoch: %d\n", se)
+			ud, err := mstate.UnlockDuration()
+			if err != nil {
+				return err
+			}
+			fmt.Printf("UnlockDuration: %d\n", ud)
+		}
+
+		signers, err := mstate.Signers()
+		if err != nil {
+			return err
+		}
+		threshold, err := mstate.Threshold()
+		if err != nil {
+			return err
+		}
+		fmt.Printf("Threshold: %d / %d\n", threshold, len(signers))
+		fmt.Println("Signers:")
+		for _, s := range signers {
+			fmt.Printf("\t%s\n", s)
+		}
+
+		pending := make(map[int64]multisig.Transaction)
+		if err := mstate.ForEachPendingTxn(func(id int64, txn multisig.Transaction) error {
+			pending[id] = txn
+			return nil
+		}); err != nil {
+			return xerrors.Errorf("reading pending transactions: %w", err)
+		}
+
+		fmt.Println("Transactions: ", len(pending))
+		if len(pending) > 0 {
+			var txids []int64
+			for txid := range pending {
+				txids = append(txids, txid)
+			}
+			sort.Slice(txids, func(i, j int) bool {
+				return txids[i] < txids[j]
+			})
+
+			w := tabwriter.NewWriter(os.Stdout, 8, 4, 0, ' ', 0)
+			fmt.Fprintf(w, "ID\tState\tApprovals\tTo\tValue\tMethod\tParams\n")
+			for _, txid := range txids {
+				tx := pending[txid]
+				fmt.Fprintf(w, "%d\t%s\t%d\t%s\t%s\t%d\t%x\n", txid, "pending", len(tx.Approved), tx.To, types.FIL(tx.Value), tx.Method, tx.Params)
+			}
+			if err := w.Flush(); err != nil {
+				return xerrors.Errorf("flushing output: %+v", err)
+			}
+
+		}
+
+		return nil
+	},
+}
+
+var msigProposeCmd = &cli.Command{
+	Name:      "propose",
+	Usage:     "Propose a multisig transaction",
+	ArgsUsage: "[multisigAddress destinationAddress value <methodId methodParams> (optional)]",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:  "from",
+			Usage: "account to send the propose message from",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		if cctx.Args().Len() < 3 {
+			return ShowHelp(cctx, fmt.Errorf("must pass at least multisig address, destination, and value"))
+		}
+
+		if cctx.Args().Len() > 3 && cctx.Args().Len() != 5 {
+			return ShowHelp(cctx, fmt.Errorf("must either pass three or five arguments"))
+		}
+
+		api, closer, err := GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+		ctx := ReqContext(cctx)
+
+		msig, err := address.NewFromString(cctx.Args().Get(0))
+		if err != nil {
+			return err
+		}
+
+		dest, err := address.NewFromString(cctx.Args().Get(1))
+		if err != nil {
+			return err
+		}
+
+		value, err := types.ParseFIL(cctx.Args().Get(2))
+		if err != nil {
+			return err
+		}
+
+		var method uint64
+		var params []byte
+		if cctx.Args().Len() == 5 {
+			m, err := strconv.ParseUint(cctx.Args().Get(3), 10, 64)
+			if err != nil {
+				return err
+			}
+			method = m
+
+			p, err := hex.DecodeString(cctx.Args().Get(4))
+			if err != nil {
+				return err
+			}
+			params = p
+		}
+
+		var from address.Address
+		if cctx.IsSet("from") {
+			f, err := address.NewFromString(cctx.String("from"))
+			if err != nil {
+				return err
+			}
+			from = f
+		} else {
+			defaddr, err := api.WalletDefaultAddress(ctx)
+			if err != nil {
+				return err
+			}
+			from = defaddr
+		}
+
+		act, err := api.StateGetActor(ctx, msig, types.EmptyTSK)
+		if err != nil {
+			return fmt.Errorf("failed to look up multisig %s: %w", msig, err)
+		}
+
+		if !act.IsMultisigActor() {
+			return fmt.Errorf("actor %s is not a multisig actor", msig)
+		}
+
+		msgCid, err := api.MsigPropose(ctx, msig, dest, types.BigInt(value), from, method, params)
+		if err != nil {
+			return err
+		}
+
+		fmt.Println("send proposal in message: ", msgCid)
+
+		wait, err := api.StateWaitMsg(ctx, msgCid, build.MessageConfidence)
+		if err != nil {
+			return err
+		}
+
+		if wait.Receipt.ExitCode != 0 {
+			return fmt.Errorf("proposal returned exit %d", wait.Receipt.ExitCode)
+		}
+
+		var retval msig0.ProposeReturn
+		if err := retval.UnmarshalCBOR(bytes.NewReader(wait.Receipt.Return)); err != nil {
+			return fmt.Errorf("failed to unmarshal propose return value: %w", err)
+		}
+
+		fmt.Printf("Transaction ID: %d\n", retval.TxnID)
+		if retval.Applied {
+			fmt.Printf("Transaction was executed during propose\n")
+			fmt.Printf("Exit Code: %d\n", retval.Code)
+			fmt.Printf("Return Value: %x\n", retval.Ret)
+		}
+
+		return nil
+	},
+}
+
+var msigApproveCmd = &cli.Command{
+	Name:      "approve",
+	Usage:     "Approve a multisig message",
+	ArgsUsage: "[multisigAddress messageId proposerAddress destination value <methodId methodParams> (optional)]",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:  "from",
+			Usage: "account to send the approve message from",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		if cctx.Args().Len() < 5 {
+			return ShowHelp(cctx, fmt.Errorf("must pass multisig address, message ID, proposer address, destination, and value"))
+		}
+
+		if cctx.Args().Len() > 5 && cctx.Args().Len() != 7 {
+			return ShowHelp(cctx, fmt.Errorf("usage: msig approve <msig addr> <message ID> <proposer address> <desination> <value> [ <method> <params> ]"))
+		}
+
+		api, closer, err := GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+		ctx := ReqContext(cctx)
+
+		msig, err := address.NewFromString(cctx.Args().Get(0))
+		if err != nil {
+			return err
+		}
+
+		txid, err := strconv.ParseUint(cctx.Args().Get(1), 10, 64)
+		if err != nil {
+			return err
+		}
+
+		proposer, err := address.NewFromString(cctx.Args().Get(2))
+		if err != nil {
+			return err
+		}
+
+		if proposer.Protocol() != address.ID {
+			proposer, err = api.StateLookupID(ctx, proposer, types.EmptyTSK)
+			if err != nil {
+				return err
+			}
+		}
+
+		dest, err := address.NewFromString(cctx.Args().Get(3))
+		if err != nil {
+			return err
+		}
+
+		value, err := types.ParseFIL(cctx.Args().Get(4))
+		if err != nil {
+			return err
+		}
+
+		var method uint64
+		var params []byte
+		if cctx.Args().Len() == 7 {
+			m, err := strconv.ParseUint(cctx.Args().Get(5), 10, 64)
+			if err != nil {
+				return err
+			}
+			method = m
+
+			p, err := hex.DecodeString(cctx.Args().Get(6))
+			if err != nil {
+				return err
+			}
+			params = p
+		}
+
+		var from address.Address
+		if cctx.IsSet("from") {
+			f, err := address.NewFromString(cctx.String("from"))
+			if err != nil {
+				return err
+			}
+			from = f
+		} else {
+			defaddr, err := api.WalletDefaultAddress(ctx)
+			if err != nil {
+				return err
+			}
+			from = defaddr
+		}
+
+		msgCid, err := api.MsigApprove(ctx, msig, txid, proposer, dest, types.BigInt(value), from, method, params)
+		if err != nil {
+			return err
+		}
+
+		fmt.Println("sent approval in message: ", msgCid)
+
+		wait, err := api.StateWaitMsg(ctx, msgCid, build.MessageConfidence)
+		if err != nil {
+			return err
+		}
+
+		if wait.Receipt.ExitCode != 0 {
+			return fmt.Errorf("approve returned exit %d", wait.Receipt.ExitCode)
+		}
+
+		return nil
+	},
+}
+
+var msigAddProposeCmd = &cli.Command{
+	Name:      "add-propose",
+	Usage:     "Propose to add a signer",
+	ArgsUsage: "[multisigAddress signer]",
+	Flags: []cli.Flag{
+		&cli.BoolFlag{
+			Name:  "increase-threshold",
+			Usage: "whether the number of required signers should be increased",
+		},
+		&cli.StringFlag{
+			Name:  "from",
+			Usage: "account to send the propose message from",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		if cctx.Args().Len() != 2 {
+			return ShowHelp(cctx, fmt.Errorf("must pass multisig address and signer address"))
+		}
+
+		api, closer, err := GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+		ctx := ReqContext(cctx)
+
+		msig, err := address.NewFromString(cctx.Args().Get(0))
+		if err != nil {
+			return err
+		}
+
+		addr, err := address.NewFromString(cctx.Args().Get(1))
+		if err != nil {
+			return err
+		}
+
+		var from address.Address
+		if cctx.IsSet("from") {
+			f, err := address.NewFromString(cctx.String("from"))
+			if err != nil {
+				return err
+			}
+			from = f
+		} else {
+			defaddr, err := api.WalletDefaultAddress(ctx)
+			if err != nil {
+				return err
+			}
+			from = defaddr
+		}
+
+		msgCid, err := api.MsigAddPropose(ctx, msig, from, addr, cctx.Bool("increase-threshold"))
+		if err != nil {
+			return err
+		}
+
+		fmt.Println("sent add proposal in message: ", msgCid)
+
+		wait, err := api.StateWaitMsg(ctx, msgCid, build.MessageConfidence)
+		if err != nil {
+			return err
+		}
+
+		if wait.Receipt.ExitCode != 0 {
+			return fmt.Errorf("add proposal returned exit %d", wait.Receipt.ExitCode)
+		}
+
+		return nil
+	},
+}
+
+var msigAddApproveCmd = &cli.Command{
+	Name:      "add-approve",
+	Usage:     "Approve a message to add a signer",
+	ArgsUsage: "[multisigAddress proposerAddress txId newAddress increaseThreshold]",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:  "from",
+			Usage: "account to send the approve message from",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		if cctx.Args().Len() != 5 {
+			return ShowHelp(cctx, fmt.Errorf("must pass multisig address, proposer address, transaction id, new signer address, whether to increase threshold"))
+		}
+
+		api, closer, err := GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+		ctx := ReqContext(cctx)
+
+		msig, err := address.NewFromString(cctx.Args().Get(0))
+		if err != nil {
+			return err
+		}
+
+		prop, err := address.NewFromString(cctx.Args().Get(1))
+		if err != nil {
+			return err
+		}
+
+		txid, err := strconv.ParseUint(cctx.Args().Get(2), 10, 64)
+		if err != nil {
+			return err
+		}
+
+		newAdd, err := address.NewFromString(cctx.Args().Get(3))
+		if err != nil {
+			return err
+		}
+
+		inc, err := strconv.ParseBool(cctx.Args().Get(4))
+		if err != nil {
+			return err
+		}
+
+		var from address.Address
+		if cctx.IsSet("from") {
+			f, err := address.NewFromString(cctx.String("from"))
+			if err != nil {
+				return err
+			}
+			from = f
+		} else {
+			defaddr, err := api.WalletDefaultAddress(ctx)
+			if err != nil {
+				return err
+			}
+			from = defaddr
+		}
+
+		msgCid, err := api.MsigAddApprove(ctx, msig, from, txid, prop, newAdd, inc)
+		if err != nil {
+			return err
+		}
+
+		fmt.Println("sent add approval in message: ", msgCid)
+
+		wait, err := api.StateWaitMsg(ctx, msgCid, build.MessageConfidence)
+		if err != nil {
+			return err
+		}
+
+		if wait.Receipt.ExitCode != 0 {
+			return fmt.Errorf("add approval returned exit %d", wait.Receipt.ExitCode)
+		}
+
+		return nil
+	},
+}
+
+var msigAddCancelCmd = &cli.Command{
+	Name:      "add-cancel",
+	Usage:     "Cancel a message to add a signer",
+	ArgsUsage: "[multisigAddress txId newAddress increaseThreshold]",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:  "from",
+			Usage: "account to send the approve message from",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		if cctx.Args().Len() != 4 {
+			return ShowHelp(cctx, fmt.Errorf("must pass multisig address, transaction id, new signer address, whether to increase threshold"))
+		}
+
+		api, closer, err := GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+		ctx := ReqContext(cctx)
+
+		msig, err := address.NewFromString(cctx.Args().Get(0))
+		if err != nil {
+			return err
+		}
+
+		txid, err := strconv.ParseUint(cctx.Args().Get(1), 10, 64)
+		if err != nil {
+			return err
+		}
+
+		newAdd, err := address.NewFromString(cctx.Args().Get(2))
+		if err != nil {
+			return err
+		}
+
+		inc, err := strconv.ParseBool(cctx.Args().Get(3))
+		if err != nil {
+			return err
+		}
+
+		var from address.Address
+		if cctx.IsSet("from") {
+			f, err := address.NewFromString(cctx.String("from"))
+			if err != nil {
+				return err
+			}
+			from = f
+		} else {
+			defaddr, err := api.WalletDefaultAddress(ctx)
+			if err != nil {
+				return err
+			}
+			from = defaddr
+		}
+
+		msgCid, err := api.MsigAddCancel(ctx, msig, from, txid, newAdd, inc)
+		if err != nil {
+			return err
+		}
+
+		fmt.Println("sent add cancellation in message: ", msgCid)
+
+		wait, err := api.StateWaitMsg(ctx, msgCid, build.MessageConfidence)
+		if err != nil {
+			return err
+		}
+
+		if wait.Receipt.ExitCode != 0 {
+			return fmt.Errorf("add cancellation returned exit %d", wait.Receipt.ExitCode)
+		}
+
+		return nil
+	},
+}
+
+var msigSwapProposeCmd = &cli.Command{
+	Name:      "swap-propose",
+	Usage:     "Propose to swap signers",
+	ArgsUsage: "[multisigAddress oldAddress newAddress]",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:  "from",
+			Usage: "account to send the approve message from",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		if cctx.Args().Len() != 3 {
+			return ShowHelp(cctx, fmt.Errorf("must pass multisig address, old signer address, new signer address"))
+		}
+
+		api, closer, err := GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+		ctx := ReqContext(cctx)
+
+		msig, err := address.NewFromString(cctx.Args().Get(0))
+		if err != nil {
+			return err
+		}
+
+		oldAdd, err := address.NewFromString(cctx.Args().Get(1))
+		if err != nil {
+			return err
+		}
+
+		newAdd, err := address.NewFromString(cctx.Args().Get(2))
+		if err != nil {
+			return err
+		}
+
+		var from address.Address
+		if cctx.IsSet("from") {
+			f, err := address.NewFromString(cctx.String("from"))
+			if err != nil {
+				return err
+			}
+			from = f
+		} else {
+			defaddr, err := api.WalletDefaultAddress(ctx)
+			if err != nil {
+				return err
+			}
+			from = defaddr
+		}
+
+		msgCid, err := api.MsigSwapPropose(ctx, msig, from, oldAdd, newAdd)
+		if err != nil {
+			return err
+		}
+
+		fmt.Println("sent swap proposal in message: ", msgCid)
+
+		wait, err := api.StateWaitMsg(ctx, msgCid, build.MessageConfidence)
+		if err != nil {
+			return err
+		}
+
+		if wait.Receipt.ExitCode != 0 {
+			return fmt.Errorf("swap proposal returned exit %d", wait.Receipt.ExitCode)
+		}
+
+		return nil
+	},
+}
+
+var msigSwapApproveCmd = &cli.Command{
+	Name:      "swap-approve",
+	Usage:     "Approve a message to swap signers",
+	ArgsUsage: "[multisigAddress proposerAddress txId oldAddress newAddress]",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:  "from",
+			Usage: "account to send the approve message from",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		if cctx.Args().Len() != 5 {
+			return ShowHelp(cctx, fmt.Errorf("must pass multisig address, proposer address, transaction id, old signer address, new signer address"))
+		}
+
+		api, closer, err := GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+		ctx := ReqContext(cctx)
+
+		msig, err := address.NewFromString(cctx.Args().Get(0))
+		if err != nil {
+			return err
+		}
+
+		prop, err := address.NewFromString(cctx.Args().Get(1))
+		if err != nil {
+			return err
+		}
+
+		txid, err := strconv.ParseUint(cctx.Args().Get(2), 10, 64)
+		if err != nil {
+			return err
+		}
+
+		oldAdd, err := address.NewFromString(cctx.Args().Get(3))
+		if err != nil {
+			return err
+		}
+
+		newAdd, err := address.NewFromString(cctx.Args().Get(4))
+		if err != nil {
+			return err
+		}
+
+		var from address.Address
+		if cctx.IsSet("from") {
+			f, err := address.NewFromString(cctx.String("from"))
+			if err != nil {
+				return err
+			}
+			from = f
+		} else {
+			defaddr, err := api.WalletDefaultAddress(ctx)
+			if err != nil {
+				return err
+			}
+			from = defaddr
+		}
+
+		msgCid, err := api.MsigSwapApprove(ctx, msig, from, txid, prop, oldAdd, newAdd)
+		if err != nil {
+			return err
+		}
+
+		fmt.Println("sent swap approval in message: ", msgCid)
+
+		wait, err := api.StateWaitMsg(ctx, msgCid, build.MessageConfidence)
+		if err != nil {
+			return err
+		}
+
+		if wait.Receipt.ExitCode != 0 {
+			return fmt.Errorf("swap approval returned exit %d", wait.Receipt.ExitCode)
+		}
+
+		return nil
+	},
+}
+
+var msigSwapCancelCmd = &cli.Command{
+	Name:      "swap-cancel",
+	Usage:     "Cancel a message to swap signers",
+	ArgsUsage: "[multisigAddress txId oldAddress newAddress]",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:  "from",
+			Usage: "account to send the approve message from",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		if cctx.Args().Len() != 4 {
+			return ShowHelp(cctx, fmt.Errorf("must pass multisig address, transaction id, old signer address, new signer address"))
+		}
+
+		api, closer, err := GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+		ctx := ReqContext(cctx)
+
+		msig, err := address.NewFromString(cctx.Args().Get(0))
+		if err != nil {
+			return err
+		}
+
+		txid, err := strconv.ParseUint(cctx.Args().Get(1), 10, 64)
+		if err != nil {
+			return err
+		}
+
+		oldAdd, err := address.NewFromString(cctx.Args().Get(2))
+		if err != nil {
+			return err
+		}
+
+		newAdd, err := address.NewFromString(cctx.Args().Get(3))
+		if err != nil {
+			return err
+		}
+
+		var from address.Address
+		if cctx.IsSet("from") {
+			f, err := address.NewFromString(cctx.String("from"))
+			if err != nil {
+				return err
+			}
+			from = f
+		} else {
+			defaddr, err := api.WalletDefaultAddress(ctx)
+			if err != nil {
+				return err
+			}
+			from = defaddr
+		}
+
+		msgCid, err := api.MsigSwapCancel(ctx, msig, from, txid, oldAdd, newAdd)
+		if err != nil {
+			return err
+		}
+
+		fmt.Println("sent swap cancellation in message: ", msgCid)
+
+		wait, err := api.StateWaitMsg(ctx, msgCid, build.MessageConfidence)
+		if err != nil {
+			return err
+		}
+
+		if wait.Receipt.ExitCode != 0 {
+			return fmt.Errorf("swap cancellation returned exit %d", wait.Receipt.ExitCode)
+		}
+
+		return nil
+	},
+}
+
+var msigLockProposeCmd = &cli.Command{
+	Name:      "lock-propose",
+	Usage:     "Propose to lock up some balance",
+	ArgsUsage: "[multisigAddress startEpoch unlockDuration amount]",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:  "from",
+			Usage: "account to send the propose message from",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		if cctx.Args().Len() != 4 {
+			return ShowHelp(cctx, fmt.Errorf("must pass multisig address, start epoch, unlock duration, and amount"))
+		}
+
+		api, closer, err := GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+		ctx := ReqContext(cctx)
+
+		msig, err := address.NewFromString(cctx.Args().Get(0))
+		if err != nil {
+			return err
+		}
+
+		start, err := strconv.ParseUint(cctx.Args().Get(1), 10, 64)
+		if err != nil {
+			return err
+		}
+
+		duration, err := strconv.ParseUint(cctx.Args().Get(2), 10, 64)
+		if err != nil {
+			return err
+		}
+
+		amount, err := types.ParseFIL(cctx.Args().Get(3))
+		if err != nil {
+			return err
+		}
+
+		var from address.Address
+		if cctx.IsSet("from") {
+			f, err := address.NewFromString(cctx.String("from"))
+			if err != nil {
+				return err
+			}
+			from = f
+		} else {
+			defaddr, err := api.WalletDefaultAddress(ctx)
+			if err != nil {
+				return err
+			}
+			from = defaddr
+		}
+
+		params, actErr := actors.SerializeParams(&msig0.LockBalanceParams{
+			StartEpoch:     abi.ChainEpoch(start),
+			UnlockDuration: abi.ChainEpoch(duration),
+			Amount:         abi.NewTokenAmount(amount.Int64()),
+		})
+
+		if actErr != nil {
+			return actErr
+		}
+
+		msgCid, err := api.MsigPropose(ctx, msig, msig, big.Zero(), from, uint64(builtin.MethodsMultisig.LockBalance), params)
+		if err != nil {
+			return err
+		}
+
+		fmt.Println("sent lock proposal in message: ", msgCid)
+
+		wait, err := api.StateWaitMsg(ctx, msgCid, build.MessageConfidence)
+		if err != nil {
+			return err
+		}
+
+		if wait.Receipt.ExitCode != 0 {
+			return fmt.Errorf("lock proposal returned exit %d", wait.Receipt.ExitCode)
+		}
+
+		return nil
+	},
+}
+
+var msigLockApproveCmd = &cli.Command{
+	Name:      "lock-approve",
+	Usage:     "Approve a message to lock up some balance",
+	ArgsUsage: "[multisigAddress proposerAddress txId startEpoch unlockDuration amount]",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:  "from",
+			Usage: "account to send the approve message from",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		if cctx.Args().Len() != 6 {
+			return ShowHelp(cctx, fmt.Errorf("must pass multisig address, proposer address, tx id, start epoch, unlock duration, and amount"))
+		}
+
+		api, closer, err := GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+		ctx := ReqContext(cctx)
+
+		msig, err := address.NewFromString(cctx.Args().Get(0))
+		if err != nil {
+			return err
+		}
+
+		prop, err := address.NewFromString(cctx.Args().Get(1))
+		if err != nil {
+			return err
+		}
+
+		txid, err := strconv.ParseUint(cctx.Args().Get(2), 10, 64)
+		if err != nil {
+			return err
+		}
+
+		start, err := strconv.ParseUint(cctx.Args().Get(3), 10, 64)
+		if err != nil {
+			return err
+		}
+
+		duration, err := strconv.ParseUint(cctx.Args().Get(4), 10, 64)
+		if err != nil {
+			return err
+		}
+
+		amount, err := types.ParseFIL(cctx.Args().Get(5))
+		if err != nil {
+			return err
+		}
+
+		var from address.Address
+		if cctx.IsSet("from") {
+			f, err := address.NewFromString(cctx.String("from"))
+			if err != nil {
+				return err
+			}
+			from = f
+		} else {
+			defaddr, err := api.WalletDefaultAddress(ctx)
+			if err != nil {
+				return err
+			}
+			from = defaddr
+		}
+
+		params, actErr := actors.SerializeParams(&msig0.LockBalanceParams{
+			StartEpoch:     abi.ChainEpoch(start),
+			UnlockDuration: abi.ChainEpoch(duration),
+			Amount:         abi.NewTokenAmount(amount.Int64()),
+		})
+
+		if actErr != nil {
+			return actErr
+		}
+
+		msgCid, err := api.MsigApprove(ctx, msig, txid, prop, msig, big.Zero(), from, uint64(builtin.MethodsMultisig.LockBalance), params)
+		if err != nil {
+			return err
+		}
+
+		fmt.Println("sent lock approval in message: ", msgCid)
+
+		wait, err := api.StateWaitMsg(ctx, msgCid, build.MessageConfidence)
+		if err != nil {
+			return err
+		}
+
+		if wait.Receipt.ExitCode != 0 {
+			return fmt.Errorf("lock approval returned exit %d", wait.Receipt.ExitCode)
+		}
+
+		return nil
+	},
+}
+
+var msigLockCancelCmd = &cli.Command{
+	Name:      "lock-cancel",
+	Usage:     "Cancel a message to lock up some balance",
+	ArgsUsage: "[multisigAddress txId startEpoch unlockDuration amount]",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:  "from",
+			Usage: "account to send the cancel message from",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		if cctx.Args().Len() != 6 {
+			return ShowHelp(cctx, fmt.Errorf("must pass multisig address, tx id, start epoch, unlock duration, and amount"))
+		}
+
+		api, closer, err := GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+		ctx := ReqContext(cctx)
+
+		msig, err := address.NewFromString(cctx.Args().Get(0))
+		if err != nil {
+			return err
+		}
+
+		txid, err := strconv.ParseUint(cctx.Args().Get(1), 10, 64)
+		if err != nil {
+			return err
+		}
+
+		start, err := strconv.ParseUint(cctx.Args().Get(2), 10, 64)
+		if err != nil {
+			return err
+		}
+
+		duration, err := strconv.ParseUint(cctx.Args().Get(3), 10, 64)
+		if err != nil {
+			return err
+		}
+
+		amount, err := types.ParseFIL(cctx.Args().Get(4))
+		if err != nil {
+			return err
+		}
+
+		var from address.Address
+		if cctx.IsSet("from") {
+			f, err := address.NewFromString(cctx.String("from"))
+			if err != nil {
+				return err
+			}
+			from = f
+		} else {
+			defaddr, err := api.WalletDefaultAddress(ctx)
+			if err != nil {
+				return err
+			}
+			from = defaddr
+		}
+
+		params, actErr := actors.SerializeParams(&msig0.LockBalanceParams{
+			StartEpoch:     abi.ChainEpoch(start),
+			UnlockDuration: abi.ChainEpoch(duration),
+			Amount:         abi.NewTokenAmount(amount.Int64()),
+		})
+
+		if actErr != nil {
+			return actErr
+		}
+
+		msgCid, err := api.MsigCancel(ctx, msig, txid, msig, big.Zero(), from, uint64(builtin.MethodsMultisig.LockBalance), params)
+		if err != nil {
+			return err
+		}
+
+		fmt.Println("sent lock cancellation in message: ", msgCid)
+
+		wait, err := api.StateWaitMsg(ctx, msgCid, build.MessageConfidence)
+		if err != nil {
+			return err
+		}
+
+		if wait.Receipt.ExitCode != 0 {
+			return fmt.Errorf("lock cancellation returned exit %d", wait.Receipt.ExitCode)
+		}
+
+		return nil
+	},
+}
+
+var msigVestedCmd = &cli.Command{
+	Name:      "vested",
+	Usage:     "Gets the amount vested in an msig between two epochs",
+	ArgsUsage: "[multisigAddress]",
+	Flags: []cli.Flag{
+		&cli.Int64Flag{
+			Name:  "start-epoch",
+			Usage: "start epoch to measure vesting from",
+			Value: 0,
+		},
+		&cli.Int64Flag{
+			Name:  "end-epoch",
+			Usage: "end epoch to stop measure vesting at",
+			Value: -1,
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		if cctx.Args().Len() != 1 {
+			return ShowHelp(cctx, fmt.Errorf("must pass multisig address"))
+		}
+
+		api, closer, err := GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+		ctx := ReqContext(cctx)
+
+		msig, err := address.NewFromString(cctx.Args().Get(0))
+		if err != nil {
+			return err
+		}
+
+		start, err := api.ChainGetTipSetByHeight(ctx, abi.ChainEpoch(cctx.Int64("start-epoch")), types.EmptyTSK)
+		if err != nil {
+			return err
+		}
+
+		var end *types.TipSet
+		if cctx.Int64("end-epoch") < 0 {
+			end, err = LoadTipSet(ctx, cctx, api)
+			if err != nil {
+				return err
+			}
+		} else {
+			end, err = api.ChainGetTipSetByHeight(ctx, abi.ChainEpoch(cctx.Int64("end-epoch")), types.EmptyTSK)
+			if err != nil {
+				return err
+			}
+		}
+
+		ret, err := api.MsigGetVested(ctx, msig, start.Key(), end.Key())
+		if err != nil {
+			return err
+		}
+
+		fmt.Printf("Vested: %s between %d and %d\n", types.FIL(ret), start.Height(), end.Height())
+
+		return nil
+	},
+}
diff --git a/cli/net.go b/cli/net.go
index 78354d563..9c40c70c7 100644
--- a/cli/net.go
+++ b/cli/net.go
@@ -1,12 +1,24 @@
 package cli
 
 import (
+	"encoding/json"
 	"fmt"
+	"os"
 	"sort"
 	"strings"
+	"text/tabwriter"
 
-	"gopkg.in/urfave/cli.v2"
+	"github.com/dustin/go-humanize"
+	"github.com/urfave/cli/v2"
+	"golang.org/x/xerrors"
 
+	"github.com/libp2p/go-libp2p-core/peer"
+	protocol "github.com/libp2p/go-libp2p-core/protocol"
+	"github.com/multiformats/go-multiaddr"
+
+	"github.com/filecoin-project/go-address"
+
+	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/lib/addrutil"
 )
 
@@ -14,16 +26,27 @@ var netCmd = &cli.Command{
 	Name:  "net",
 	Usage: "Manage P2P Network",
 	Subcommands: []*cli.Command{
-		netPeers,
+		NetPeers,
 		netConnect,
-		netListen,
-		netId,
+		NetListen,
+		NetId,
+		netFindPeer,
+		netScores,
+		NetReachability,
+		NetBandwidthCmd,
 	},
 }
 
-var netPeers = &cli.Command{
+var NetPeers = &cli.Command{
 	Name:  "peers",
 	Usage: "Print peers",
+	Flags: []cli.Flag{
+		&cli.BoolFlag{
+			Name:    "agent",
+			Aliases: []string{"a"},
+			Usage:   "Print agent name",
+		},
+	},
 	Action: func(cctx *cli.Context) error {
 		api, closer, err := GetAPI(cctx)
 		if err != nil {
@@ -41,14 +64,63 @@ var netPeers = &cli.Command{
 		})
 
 		for _, peer := range peers {
-			fmt.Println(peer)
+			var agent string
+			if cctx.Bool("agent") {
+				agent, err = api.NetAgentVersion(ctx, peer.ID)
+				if err != nil {
+					log.Warnf("getting agent version: %s", err)
+				} else {
+					agent = ", " + agent
+				}
+			}
+
+			fmt.Printf("%s, %s%s\n", peer.ID, peer.Addrs, agent)
 		}
 
 		return nil
 	},
 }
 
-var netListen = &cli.Command{
+var netScores = &cli.Command{
+	Name:  "scores",
+	Usage: "Print peers' pubsub scores",
+	Flags: []cli.Flag{
+		&cli.BoolFlag{
+			Name:  "extended",
+			Usage: "print extended peer scores in json",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		api, closer, err := GetAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+		ctx := ReqContext(cctx)
+		scores, err := api.NetPubsubScores(ctx)
+		if err != nil {
+			return err
+		}
+
+		if cctx.Bool("extended") {
+			enc := json.NewEncoder(os.Stdout)
+			for _, peer := range scores {
+				err := enc.Encode(peer)
+				if err != nil {
+					return err
+				}
+			}
+		} else {
+			for _, peer := range scores {
+				fmt.Printf("%s, %f\n", peer.ID, peer.Score.Score)
+			}
+		}
+
+		return nil
+	},
+}
+
+var NetListen = &cli.Command{
 	Name:  "listen",
 	Usage: "List listen addresses",
 	Action: func(cctx *cli.Context) error {
@@ -74,7 +146,7 @@ var netListen = &cli.Command{
 var netConnect = &cli.Command{
 	Name:      "connect",
 	Usage:     "Connect to a peer",
-	ArgsUsage: "<peer multiaddr>",
+	ArgsUsage: "[peerMultiaddr|minerActorAddress]",
 	Action: func(cctx *cli.Context) error {
 		api, closer, err := GetAPI(cctx)
 		if err != nil {
@@ -85,7 +157,43 @@ var netConnect = &cli.Command{
 
 		pis, err := addrutil.ParseAddresses(ctx, cctx.Args().Slice())
 		if err != nil {
-			return err
+			a, perr := address.NewFromString(cctx.Args().First())
+			if perr != nil {
+				return err
+			}
+
+			na, fc, err := GetFullNodeAPI(cctx)
+			if err != nil {
+				return err
+			}
+			defer fc()
+
+			mi, err := na.StateMinerInfo(ctx, a, types.EmptyTSK)
+			if err != nil {
+				return xerrors.Errorf("getting miner info: %w", err)
+			}
+
+			if mi.PeerId == nil {
+				return xerrors.Errorf("no PeerID for miner")
+			}
+			multiaddrs := make([]multiaddr.Multiaddr, 0, len(mi.Multiaddrs))
+			for i, a := range mi.Multiaddrs {
+				maddr, err := multiaddr.NewMultiaddrBytes(a)
+				if err != nil {
+					log.Warnf("parsing multiaddr %d (%x): %s", i, a, err)
+					continue
+				}
+				multiaddrs = append(multiaddrs, maddr)
+			}
+
+			pi := peer.AddrInfo{
+				ID:    *mi.PeerId,
+				Addrs: multiaddrs,
+			}
+
+			fmt.Printf("%s -> %s\n", a, pi)
+
+			pis = append(pis, pi)
 		}
 
 		for _, pi := range pis {
@@ -102,7 +210,7 @@ var netConnect = &cli.Command{
 	},
 }
 
-var netId = &cli.Command{
+var NetId = &cli.Command{
 	Name:  "id",
 	Usage: "Get node identity",
 	Action: func(cctx *cli.Context) error {
@@ -123,3 +231,147 @@ var netId = &cli.Command{
 		return nil
 	},
 }
+
+var netFindPeer = &cli.Command{
+	Name:      "findpeer",
+	Usage:     "Find the addresses of a given peerID",
+	ArgsUsage: "[peerId]",
+	Action: func(cctx *cli.Context) error {
+		if cctx.NArg() != 1 {
+			fmt.Println("Usage: findpeer [peer ID]")
+			return nil
+		}
+
+		pid, err := peer.Decode(cctx.Args().First())
+		if err != nil {
+			return err
+		}
+
+		api, closer, err := GetAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+
+		ctx := ReqContext(cctx)
+
+		addrs, err := api.NetFindPeer(ctx, pid)
+
+		if err != nil {
+			return err
+		}
+
+		fmt.Println(addrs)
+		return nil
+	},
+}
+
+var NetReachability = &cli.Command{
+	Name:  "reachability",
+	Usage: "Print information about reachability from the internet",
+	Action: func(cctx *cli.Context) error {
+		api, closer, err := GetAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+
+		ctx := ReqContext(cctx)
+
+		i, err := api.NetAutoNatStatus(ctx)
+		if err != nil {
+			return err
+		}
+
+		fmt.Println("AutoNAT status: ", i.Reachability.String())
+		if i.PublicAddr != "" {
+			fmt.Println("Public address: ", i.PublicAddr)
+		}
+		return nil
+	},
+}
+
+var NetBandwidthCmd = &cli.Command{
+	Name:  "bandwidth",
+	Usage: "Print bandwidth usage information",
+	Flags: []cli.Flag{
+		&cli.BoolFlag{
+			Name:  "by-peer",
+			Usage: "list bandwidth usage by peer",
+		},
+		&cli.BoolFlag{
+			Name:  "by-protocol",
+			Usage: "list bandwidth usage by protocol",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		api, closer, err := GetAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+
+		ctx := ReqContext(cctx)
+
+		bypeer := cctx.Bool("by-peer")
+		byproto := cctx.Bool("by-protocol")
+
+		tw := tabwriter.NewWriter(os.Stdout, 4, 4, 2, ' ', 0)
+
+		fmt.Fprintf(tw, "Segment\tTotalIn\tTotalOut\tRateIn\tRateOut\n")
+
+		if bypeer {
+			bw, err := api.NetBandwidthStatsByPeer(ctx)
+			if err != nil {
+				return err
+			}
+
+			var peers []string
+			for p := range bw {
+				peers = append(peers, p)
+			}
+
+			sort.Slice(peers, func(i, j int) bool {
+				return peers[i] < peers[j]
+			})
+
+			for _, p := range peers {
+				s := bw[p]
+				fmt.Fprintf(tw, "%s\t%s\t%s\t%s/s\t%s/s\n", p, humanize.Bytes(uint64(s.TotalIn)), humanize.Bytes(uint64(s.TotalOut)), humanize.Bytes(uint64(s.RateIn)), humanize.Bytes(uint64(s.RateOut)))
+			}
+		} else if byproto {
+			bw, err := api.NetBandwidthStatsByProtocol(ctx)
+			if err != nil {
+				return err
+			}
+
+			var protos []protocol.ID
+			for p := range bw {
+				protos = append(protos, p)
+			}
+
+			sort.Slice(protos, func(i, j int) bool {
+				return protos[i] < protos[j]
+			})
+
+			for _, p := range protos {
+				s := bw[p]
+				if p == "" {
+					p = "<unknown>"
+				}
+				fmt.Fprintf(tw, "%s\t%s\t%s\t%s/s\t%s/s\n", p, humanize.Bytes(uint64(s.TotalIn)), humanize.Bytes(uint64(s.TotalOut)), humanize.Bytes(uint64(s.RateIn)), humanize.Bytes(uint64(s.RateOut)))
+			}
+		} else {
+
+			s, err := api.NetBandwidthStats(ctx)
+			if err != nil {
+				return err
+			}
+
+			fmt.Fprintf(tw, "Total\t%s\t%s\t%s/s\t%s/s\n", humanize.Bytes(uint64(s.TotalIn)), humanize.Bytes(uint64(s.TotalOut)), humanize.Bytes(uint64(s.RateIn)), humanize.Bytes(uint64(s.RateOut)))
+		}
+
+		return tw.Flush()
+
+	},
+}
diff --git a/cli/params.go b/cli/params.go
index 440c2bbdf..05c0a4cda 100644
--- a/cli/params.go
+++ b/cli/params.go
@@ -3,28 +3,27 @@ package cli
 import (
 	"github.com/docker/go-units"
 	paramfetch "github.com/filecoin-project/go-paramfetch"
+	"github.com/urfave/cli/v2"
 	"golang.org/x/xerrors"
-	"gopkg.in/urfave/cli.v2"
 
 	"github.com/filecoin-project/lotus/build"
 )
 
 var fetchParamCmd = &cli.Command{
-	Name:  "fetch-params",
-	Usage: "Fetch proving parameters",
-	Flags: []cli.Flag{
-		&cli.StringFlag{
-			Name:  "proving-params",
-			Usage: "download params used creating proofs for given size, i.e. 32GiB",
-		},
-	},
+	Name:      "fetch-params",
+	Usage:     "Fetch proving parameters",
+	ArgsUsage: "[sectorSize]",
 	Action: func(cctx *cli.Context) error {
-		sectorSizeInt, err := units.RAMInBytes(cctx.String("proving-params"))
+		if !cctx.Args().Present() {
+			return xerrors.Errorf("must pass sector size to fetch params for (specify as \"32GiB\", for instance)")
+		}
+		sectorSizeInt, err := units.RAMInBytes(cctx.Args().First())
 		if err != nil {
-			return err
+			return xerrors.Errorf("error parsing sector size (specify as \"32GiB\", for instance): %w", err)
 		}
 		sectorSize := uint64(sectorSizeInt)
-		err = paramfetch.GetParams(build.ParametersJson, sectorSize)
+
+		err = paramfetch.GetParams(ReqContext(cctx), build.ParametersJSON(), sectorSize)
 		if err != nil {
 			return xerrors.Errorf("fetching proof parameters: %w", err)
 		}
diff --git a/cli/paych.go b/cli/paych.go
index a41211e31..dc5b54c4a 100644
--- a/cli/paych.go
+++ b/cli/paych.go
@@ -1,44 +1,69 @@
 package cli
 
 import (
+	"bytes"
+	"encoding/base64"
 	"fmt"
+	"io"
+	"sort"
+	"strings"
+
+	"github.com/filecoin-project/lotus/api"
+
+	"github.com/filecoin-project/lotus/paychmgr"
 
 	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/specs-actors/actors/builtin/paych"
+	"github.com/urfave/cli/v2"
+
 	types "github.com/filecoin-project/lotus/chain/types"
-	"gopkg.in/urfave/cli.v2"
 )
 
 var paychCmd = &cli.Command{
 	Name:  "paych",
 	Usage: "Manage payment channels",
 	Subcommands: []*cli.Command{
-		paychGetCmd,
+		paychAddFundsCmd,
 		paychListCmd,
 		paychVoucherCmd,
+		paychSettleCmd,
+		paychStatusCmd,
+		paychStatusByFromToCmd,
+		paychCloseCmd,
 	},
 }
 
-var paychGetCmd = &cli.Command{
-	Name:  "get",
-	Usage: "Create a new payment channel or get existing one",
+var paychAddFundsCmd = &cli.Command{
+	Name:      "add-funds",
+	Usage:     "Add funds to the payment channel between fromAddress and toAddress. Creates the payment channel if it doesn't already exist.",
+	ArgsUsage: "[fromAddress toAddress amount]",
+	Flags: []cli.Flag{
+
+		&cli.BoolFlag{
+			Name:  "restart-retrievals",
+			Usage: "restart stalled retrieval deals on this payment channel",
+			Value: true,
+		},
+	},
 	Action: func(cctx *cli.Context) error {
 		if cctx.Args().Len() != 3 {
-			return fmt.Errorf("must pass three arguments: <from> <to> <available funds>")
+			return ShowHelp(cctx, fmt.Errorf("must pass three arguments: <from> <to> <available funds>"))
 		}
 
 		from, err := address.NewFromString(cctx.Args().Get(0))
 		if err != nil {
-			return fmt.Errorf("failed to parse from address: %s", err)
+			return ShowHelp(cctx, fmt.Errorf("failed to parse from address: %s", err))
 		}
 
 		to, err := address.NewFromString(cctx.Args().Get(1))
 		if err != nil {
-			return fmt.Errorf("failed to parse to address: %s", err)
+			return ShowHelp(cctx, fmt.Errorf("failed to parse to address: %s", err))
 		}
 
-		amt, err := types.BigFromString(cctx.Args().Get(2))
+		amt, err := types.ParseFIL(cctx.Args().Get(2))
 		if err != nil {
-			return fmt.Errorf("parsing amount failed: %s", err)
+			return ShowHelp(cctx, fmt.Errorf("parsing amount failed: %s", err))
 		}
 
 		api, closer, err := GetFullNodeAPI(cctx)
@@ -49,16 +74,150 @@ var paychGetCmd = &cli.Command{
 
 		ctx := ReqContext(cctx)
 
-		info, err := api.PaychGet(ctx, from, to, amt)
+		// Send a message to chain to create channel / add funds to existing
+		// channel
+		info, err := api.PaychGet(ctx, from, to, types.BigInt(amt))
 		if err != nil {
 			return err
 		}
 
-		fmt.Println(info.Channel.String())
+		// Wait for the message to be confirmed
+		chAddr, err := api.PaychGetWaitReady(ctx, info.WaitSentinel)
+		if err != nil {
+			return err
+		}
+
+		fmt.Fprintln(cctx.App.Writer, chAddr)
+		restartRetrievals := cctx.Bool("restart-retrievals")
+		if restartRetrievals {
+			return api.ClientRetrieveTryRestartInsufficientFunds(ctx, chAddr)
+		}
 		return nil
 	},
 }
 
+var paychStatusByFromToCmd = &cli.Command{
+	Name:      "status-by-from-to",
+	Usage:     "Show the status of an active outbound payment channel by from/to addresses",
+	ArgsUsage: "[fromAddress toAddress]",
+	Action: func(cctx *cli.Context) error {
+		if cctx.Args().Len() != 2 {
+			return ShowHelp(cctx, fmt.Errorf("must pass two arguments: <from address> <to address>"))
+		}
+		ctx := ReqContext(cctx)
+
+		from, err := address.NewFromString(cctx.Args().Get(0))
+		if err != nil {
+			return ShowHelp(cctx, fmt.Errorf("failed to parse from address: %s", err))
+		}
+
+		to, err := address.NewFromString(cctx.Args().Get(1))
+		if err != nil {
+			return ShowHelp(cctx, fmt.Errorf("failed to parse to address: %s", err))
+		}
+
+		api, closer, err := GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+
+		avail, err := api.PaychAvailableFundsByFromTo(ctx, from, to)
+		if err != nil {
+			return err
+		}
+
+		paychStatus(cctx.App.Writer, avail)
+		return nil
+	},
+}
+
+var paychStatusCmd = &cli.Command{
+	Name:      "status",
+	Usage:     "Show the status of an outbound payment channel",
+	ArgsUsage: "[channelAddress]",
+	Action: func(cctx *cli.Context) error {
+		if cctx.Args().Len() != 1 {
+			return ShowHelp(cctx, fmt.Errorf("must pass an argument: <channel address>"))
+		}
+		ctx := ReqContext(cctx)
+
+		ch, err := address.NewFromString(cctx.Args().Get(0))
+		if err != nil {
+			return ShowHelp(cctx, fmt.Errorf("failed to parse channel address: %s", err))
+		}
+
+		api, closer, err := GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+
+		avail, err := api.PaychAvailableFunds(ctx, ch)
+		if err != nil {
+			return err
+		}
+
+		paychStatus(cctx.App.Writer, avail)
+		return nil
+	},
+}
+
+func paychStatus(writer io.Writer, avail *api.ChannelAvailableFunds) {
+	if avail.Channel == nil {
+		if avail.PendingWaitSentinel != nil {
+			fmt.Fprint(writer, "Creating channel\n")
+			fmt.Fprintf(writer, "  From:          %s\n", avail.From)
+			fmt.Fprintf(writer, "  To:            %s\n", avail.To)
+			fmt.Fprintf(writer, "  Pending Amt:   %d\n", avail.PendingAmt)
+			fmt.Fprintf(writer, "  Wait Sentinel: %s\n", avail.PendingWaitSentinel)
+			return
+		}
+		fmt.Fprint(writer, "Channel does not exist\n")
+		fmt.Fprintf(writer, "  From: %s\n", avail.From)
+		fmt.Fprintf(writer, "  To:   %s\n", avail.To)
+		return
+	}
+
+	if avail.PendingWaitSentinel != nil {
+		fmt.Fprint(writer, "Adding Funds to channel\n")
+	} else {
+		fmt.Fprint(writer, "Channel exists\n")
+	}
+
+	nameValues := [][]string{
+		{"Channel", avail.Channel.String()},
+		{"From", avail.From.String()},
+		{"To", avail.To.String()},
+		{"Confirmed Amt", fmt.Sprintf("%d", avail.ConfirmedAmt)},
+		{"Pending Amt", fmt.Sprintf("%d", avail.PendingAmt)},
+		{"Queued Amt", fmt.Sprintf("%d", avail.QueuedAmt)},
+		{"Voucher Redeemed Amt", fmt.Sprintf("%d", avail.VoucherReedeemedAmt)},
+	}
+	if avail.PendingWaitSentinel != nil {
+		nameValues = append(nameValues, []string{
+			"Add Funds Wait Sentinel",
+			avail.PendingWaitSentinel.String(),
+		})
+	}
+	fmt.Fprint(writer, formatNameValues(nameValues))
+}
+
+func formatNameValues(nameValues [][]string) string {
+	maxLen := 0
+	for _, nv := range nameValues {
+		if len(nv[0]) > maxLen {
+			maxLen = len(nv[0])
+		}
+	}
+	out := make([]string, len(nameValues))
+	for i, nv := range nameValues {
+		namePad := strings.Repeat(" ", maxLen-len(nv[0]))
+		out[i] = "  " + nv[0] + ": " + namePad + nv[1]
+	}
+	return strings.Join(out, "\n") + "\n"
+}
+
 var paychListCmd = &cli.Command{
 	Name:  "list",
 	Usage: "List all locally registered payment channels",
@@ -77,12 +236,92 @@ var paychListCmd = &cli.Command{
 		}
 
 		for _, v := range chs {
-			fmt.Println(v.String())
+			fmt.Fprintln(cctx.App.Writer, v.String())
 		}
 		return nil
 	},
 }
 
+var paychSettleCmd = &cli.Command{
+	Name:      "settle",
+	Usage:     "Settle a payment channel",
+	ArgsUsage: "[channelAddress]",
+	Action: func(cctx *cli.Context) error {
+		if cctx.Args().Len() != 1 {
+			return fmt.Errorf("must pass payment channel address")
+		}
+
+		ch, err := address.NewFromString(cctx.Args().Get(0))
+		if err != nil {
+			return fmt.Errorf("failed to parse payment channel address: %s", err)
+		}
+
+		api, closer, err := GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+
+		ctx := ReqContext(cctx)
+
+		mcid, err := api.PaychSettle(ctx, ch)
+		if err != nil {
+			return err
+		}
+
+		mwait, err := api.StateWaitMsg(ctx, mcid, build.MessageConfidence)
+		if err != nil {
+			return nil
+		}
+		if mwait.Receipt.ExitCode != 0 {
+			return fmt.Errorf("settle message execution failed (exit code %d)", mwait.Receipt.ExitCode)
+		}
+
+		fmt.Fprintf(cctx.App.Writer, "Settled channel %s\n", ch)
+		return nil
+	},
+}
+
+var paychCloseCmd = &cli.Command{
+	Name:      "collect",
+	Usage:     "Collect funds for a payment channel",
+	ArgsUsage: "[channelAddress]",
+	Action: func(cctx *cli.Context) error {
+		if cctx.Args().Len() != 1 {
+			return fmt.Errorf("must pass payment channel address")
+		}
+
+		ch, err := address.NewFromString(cctx.Args().Get(0))
+		if err != nil {
+			return fmt.Errorf("failed to parse payment channel address: %s", err)
+		}
+
+		api, closer, err := GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+
+		ctx := ReqContext(cctx)
+
+		mcid, err := api.PaychCollect(ctx, ch)
+		if err != nil {
+			return err
+		}
+
+		mwait, err := api.StateWaitMsg(ctx, mcid, build.MessageConfidence)
+		if err != nil {
+			return nil
+		}
+		if mwait.Receipt.ExitCode != 0 {
+			return fmt.Errorf("collect message execution failed (exit code %d)", mwait.Receipt.ExitCode)
+		}
+
+		fmt.Fprintf(cctx.App.Writer, "Collected funds for channel %s\n", ch)
+		return nil
+	},
+}
+
 var paychVoucherCmd = &cli.Command{
 	Name:  "voucher",
 	Usage: "Interact with payment channel vouchers",
@@ -97,8 +336,9 @@ var paychVoucherCmd = &cli.Command{
 }
 
 var paychVoucherCreateCmd = &cli.Command{
-	Name:  "create",
-	Usage: "Create a signed payment channel voucher",
+	Name:      "create",
+	Usage:     "Create a signed payment channel voucher",
+	ArgsUsage: "[channelAddress amount]",
 	Flags: []cli.Flag{
 		&cli.IntFlag{
 			Name:  "lane",
@@ -108,7 +348,7 @@ var paychVoucherCreateCmd = &cli.Command{
 	},
 	Action: func(cctx *cli.Context) error {
 		if cctx.Args().Len() != 2 {
-			return fmt.Errorf("must pass two arguments: <channel> <amount>")
+			return ShowHelp(cctx, fmt.Errorf("must pass two arguments: <channel> <amount>"))
 		}
 
 		ch, err := address.NewFromString(cctx.Args().Get(0))
@@ -116,9 +356,9 @@ var paychVoucherCreateCmd = &cli.Command{
 			return err
 		}
 
-		amt, err := types.BigFromString(cctx.Args().Get(1))
+		amt, err := types.ParseFIL(cctx.Args().Get(1))
 		if err != nil {
-			return err
+			return ShowHelp(cctx, fmt.Errorf("parsing amount failed: %s", err))
 		}
 
 		lane := cctx.Int("lane")
@@ -131,27 +371,32 @@ var paychVoucherCreateCmd = &cli.Command{
 
 		ctx := ReqContext(cctx)
 
-		sv, err := api.PaychVoucherCreate(ctx, ch, amt, uint64(lane))
+		v, err := api.PaychVoucherCreate(ctx, ch, types.BigInt(amt), uint64(lane))
 		if err != nil {
 			return err
 		}
 
-		enc, err := sv.EncodedString()
+		if v.Voucher == nil {
+			return fmt.Errorf("Could not create voucher: insufficient funds in channel, shortfall: %d", v.Shortfall)
+		}
+
+		enc, err := EncodedString(v.Voucher)
 		if err != nil {
 			return err
 		}
 
-		fmt.Println(enc)
+		fmt.Fprintln(cctx.App.Writer, enc)
 		return nil
 	},
 }
 
 var paychVoucherCheckCmd = &cli.Command{
-	Name:  "check",
-	Usage: "Check validity of payment channel voucher",
+	Name:      "check",
+	Usage:     "Check validity of payment channel voucher",
+	ArgsUsage: "[channelAddress voucher]",
 	Action: func(cctx *cli.Context) error {
 		if cctx.Args().Len() != 2 {
-			return fmt.Errorf("must pass payment channel address and voucher to validate")
+			return ShowHelp(cctx, fmt.Errorf("must pass payment channel address and voucher to validate"))
 		}
 
 		ch, err := address.NewFromString(cctx.Args().Get(0))
@@ -176,17 +421,18 @@ var paychVoucherCheckCmd = &cli.Command{
 			return err
 		}
 
-		fmt.Println("voucher is valid")
+		fmt.Fprintln(cctx.App.Writer, "voucher is valid")
 		return nil
 	},
 }
 
 var paychVoucherAddCmd = &cli.Command{
-	Name:  "add",
-	Usage: "Add payment channel voucher to local datastore",
+	Name:      "add",
+	Usage:     "Add payment channel voucher to local datastore",
+	ArgsUsage: "[channelAddress voucher]",
 	Action: func(cctx *cli.Context) error {
 		if cctx.Args().Len() != 2 {
-			return fmt.Errorf("must pass payment channel address and voucher")
+			return ShowHelp(cctx, fmt.Errorf("must pass payment channel address and voucher"))
 		}
 
 		ch, err := address.NewFromString(cctx.Args().Get(0))
@@ -217,17 +463,18 @@ var paychVoucherAddCmd = &cli.Command{
 }
 
 var paychVoucherListCmd = &cli.Command{
-	Name:  "list",
-	Usage: "List stored vouchers for a given payment channel",
+	Name:      "list",
+	Usage:     "List stored vouchers for a given payment channel",
+	ArgsUsage: "[channelAddress]",
 	Flags: []cli.Flag{
 		&cli.BoolFlag{
 			Name:  "export",
-			Usage: "Print export strings",
+			Usage: "Print voucher as serialized string",
 		},
 	},
 	Action: func(cctx *cli.Context) error {
 		if cctx.Args().Len() != 1 {
-			return fmt.Errorf("must pass payment channel address")
+			return ShowHelp(cctx, fmt.Errorf("must pass payment channel address"))
 		}
 
 		ch, err := address.NewFromString(cctx.Args().Get(0))
@@ -248,16 +495,11 @@ var paychVoucherListCmd = &cli.Command{
 			return err
 		}
 
-		for _, v := range vouchers {
-			if cctx.Bool("export") {
-				enc, err := v.EncodedString()
-				if err != nil {
-					return err
-				}
-
-				fmt.Printf("Lane %d, Nonce %d: %s; %s\n", v.Lane, v.Nonce, v.Amount.String(), enc)
-			} else {
-				fmt.Printf("Lane %d, Nonce %d: %s\n", v.Lane, v.Nonce, v.Amount.String())
+		for _, v := range sortVouchers(vouchers) {
+			export := cctx.Bool("export")
+			err := outputVoucher(cctx.App.Writer, v, export)
+			if err != nil {
+				return err
 			}
 		}
 
@@ -266,11 +508,18 @@ var paychVoucherListCmd = &cli.Command{
 }
 
 var paychVoucherBestSpendableCmd = &cli.Command{
-	Name:  "best-spendable",
-	Usage: "Print voucher with highest value that is currently spendable",
+	Name:      "best-spendable",
+	Usage:     "Print vouchers with highest value that is currently spendable for each lane",
+	ArgsUsage: "[channelAddress]",
+	Flags: []cli.Flag{
+		&cli.BoolFlag{
+			Name:  "export",
+			Usage: "Print voucher as serialized string",
+		},
+	},
 	Action: func(cctx *cli.Context) error {
 		if cctx.Args().Len() != 1 {
-			return fmt.Errorf("must pass payment channel address")
+			return ShowHelp(cctx, fmt.Errorf("must pass payment channel address"))
 		}
 
 		ch, err := address.NewFromString(cctx.Args().Get(0))
@@ -286,45 +535,62 @@ var paychVoucherBestSpendableCmd = &cli.Command{
 
 		ctx := ReqContext(cctx)
 
-		vouchers, err := api.PaychVoucherList(ctx, ch)
+		vouchersByLane, err := paychmgr.BestSpendableByLane(ctx, api, ch)
 		if err != nil {
 			return err
 		}
 
-		var best *types.SignedVoucher
-		for _, v := range vouchers {
-			spendable, err := api.PaychVoucherCheckSpendable(ctx, ch, v, nil, nil)
+		var vouchers []*paych.SignedVoucher
+		for _, vchr := range vouchersByLane {
+			vouchers = append(vouchers, vchr)
+		}
+		for _, best := range sortVouchers(vouchers) {
+			export := cctx.Bool("export")
+			err := outputVoucher(cctx.App.Writer, best, export)
 			if err != nil {
 				return err
 			}
-			if spendable {
-				if best == nil || v.Amount.GreaterThan(best.Amount) {
-					best = v
-				}
-			}
 		}
 
-		if best == nil {
-			return fmt.Errorf("No spendable vouchers for that channel")
-		}
-
-		enc, err := best.EncodedString()
-		if err != nil {
-			return err
-		}
-
-		fmt.Println(enc)
-		fmt.Printf("Amount: %s\n", best.Amount)
 		return nil
 	},
 }
 
+func sortVouchers(vouchers []*paych.SignedVoucher) []*paych.SignedVoucher {
+	sort.Slice(vouchers, func(i, j int) bool {
+		if vouchers[i].Lane == vouchers[j].Lane {
+			return vouchers[i].Nonce < vouchers[j].Nonce
+		}
+		return vouchers[i].Lane < vouchers[j].Lane
+	})
+	return vouchers
+}
+
+func outputVoucher(w io.Writer, v *paych.SignedVoucher, export bool) error {
+	var enc string
+	if export {
+		var err error
+		enc, err = EncodedString(v)
+		if err != nil {
+			return err
+		}
+	}
+
+	fmt.Fprintf(w, "Lane %d, Nonce %d: %s", v.Lane, v.Nonce, v.Amount.String())
+	if export {
+		fmt.Fprintf(w, "; %s", enc)
+	}
+	fmt.Fprintln(w)
+	return nil
+}
+
 var paychVoucherSubmitCmd = &cli.Command{
-	Name:  "submit",
-	Usage: "Submit voucher to chain to update payment channel state",
+	Name:      "submit",
+	Usage:     "Submit voucher to chain to update payment channel state",
+	ArgsUsage: "[channelAddress voucher]",
 	Action: func(cctx *cli.Context) error {
 		if cctx.Args().Len() != 2 {
-			return fmt.Errorf("must pass payment channel address and voucher")
+			return ShowHelp(cctx, fmt.Errorf("must pass payment channel address and voucher"))
 		}
 
 		ch, err := address.NewFromString(cctx.Args().Get(0))
@@ -345,12 +611,12 @@ var paychVoucherSubmitCmd = &cli.Command{
 
 		ctx := ReqContext(cctx)
 
-		mcid, err := api.PaychVoucherSubmit(ctx, ch, sv)
+		mcid, err := api.PaychVoucherSubmit(ctx, ch, sv, nil, nil)
 		if err != nil {
 			return err
 		}
 
-		mwait, err := api.StateWaitMsg(ctx, mcid)
+		mwait, err := api.StateWaitMsg(ctx, mcid, build.MessageConfidence)
 		if err != nil {
 			return err
 		}
@@ -359,8 +625,17 @@ var paychVoucherSubmitCmd = &cli.Command{
 			return fmt.Errorf("message execution failed (exit code %d)", mwait.Receipt.ExitCode)
 		}
 
-		fmt.Println("channel updated succesfully")
+		fmt.Fprintln(cctx.App.Writer, "channel updated successfully")
 
 		return nil
 	},
 }
+
+func EncodedString(sv *paych.SignedVoucher) (string, error) {
+	buf := new(bytes.Buffer)
+	if err := sv.MarshalCBOR(buf); err != nil {
+		return "", err
+	}
+
+	return base64.RawURLEncoding.EncodeToString(buf.Bytes()), nil
+}
diff --git a/cli/paych_test.go b/cli/paych_test.go
new file mode 100644
index 000000000..35f56d90e
--- /dev/null
+++ b/cli/paych_test.go
@@ -0,0 +1,542 @@
+package cli
+
+import (
+	"bytes"
+	"context"
+	"flag"
+	"fmt"
+	"os"
+	"regexp"
+	"strconv"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+	"github.com/urfave/cli/v2"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/abi"
+	cbor "github.com/ipfs/go-ipld-cbor"
+	"github.com/multiformats/go-multiaddr"
+
+	"github.com/filecoin-project/lotus/chain/actors/adt"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/paych"
+	"github.com/filecoin-project/lotus/chain/actors/policy"
+
+	"github.com/filecoin-project/lotus/api/apibstore"
+	"github.com/filecoin-project/lotus/api/test"
+	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/events"
+	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/chain/wallet"
+	builder "github.com/filecoin-project/lotus/node/test"
+)
+
+func init() {
+	policy.SetSupportedProofTypes(abi.RegisteredSealProof_StackedDrg2KiBV1)
+	policy.SetConsensusMinerMinPower(abi.NewStoragePower(2048))
+	policy.SetMinVerifiedDealSize(abi.NewStoragePower(256))
+}
+
+// TestPaymentChannels does a basic test to exercise the payment channel CLI
+// commands
+func TestPaymentChannels(t *testing.T) {
+	_ = os.Setenv("BELLMAN_NO_GPU", "1")
+
+	blocktime := 5 * time.Millisecond
+	ctx := context.Background()
+	nodes, addrs := startTwoNodesOneMiner(ctx, t, blocktime)
+	paymentCreator := nodes[0]
+	paymentReceiver := nodes[1]
+	creatorAddr := addrs[0]
+	receiverAddr := addrs[1]
+
+	// Create mock CLI
+	mockCLI := newMockCLI(t)
+	creatorCLI := mockCLI.client(paymentCreator.ListenAddr)
+	receiverCLI := mockCLI.client(paymentReceiver.ListenAddr)
+
+	// creator: paych add-funds <creator> <receiver> <amount>
+	channelAmt := "100000"
+	cmd := []string{creatorAddr.String(), receiverAddr.String(), channelAmt}
+	chstr := creatorCLI.runCmd(paychAddFundsCmd, cmd)
+
+	chAddr, err := address.NewFromString(chstr)
+	require.NoError(t, err)
+
+	// creator: paych voucher create <channel> <amount>
+	voucherAmt := 100
+	vamt := strconv.Itoa(voucherAmt)
+	cmd = []string{chAddr.String(), vamt}
+	voucher := creatorCLI.runCmd(paychVoucherCreateCmd, cmd)
+
+	// receiver: paych voucher add <channel> <voucher>
+	cmd = []string{chAddr.String(), voucher}
+	receiverCLI.runCmd(paychVoucherAddCmd, cmd)
+
+	// creator: paych settle <channel>
+	cmd = []string{chAddr.String()}
+	creatorCLI.runCmd(paychSettleCmd, cmd)
+
+	// Wait for the chain to reach the settle height
+	chState := getPaychState(ctx, t, paymentReceiver, chAddr)
+	sa, err := chState.SettlingAt()
+	require.NoError(t, err)
+	waitForHeight(ctx, t, paymentReceiver, sa)
+
+	// receiver: paych collect <channel>
+	cmd = []string{chAddr.String()}
+	receiverCLI.runCmd(paychCloseCmd, cmd)
+}
+
+type voucherSpec struct {
+	serialized string
+	amt        int
+	lane       int
+}
+
+// TestPaymentChannelStatus tests the payment channel status CLI command
+func TestPaymentChannelStatus(t *testing.T) {
+	_ = os.Setenv("BELLMAN_NO_GPU", "1")
+
+	blocktime := 5 * time.Millisecond
+	ctx := context.Background()
+	nodes, addrs := startTwoNodesOneMiner(ctx, t, blocktime)
+	paymentCreator := nodes[0]
+	creatorAddr := addrs[0]
+	receiverAddr := addrs[1]
+
+	// Create mock CLI
+	mockCLI := newMockCLI(t)
+	creatorCLI := mockCLI.client(paymentCreator.ListenAddr)
+
+	cmd := []string{creatorAddr.String(), receiverAddr.String()}
+	out := creatorCLI.runCmd(paychStatusByFromToCmd, cmd)
+	fmt.Println(out)
+	noChannelState := "Channel does not exist"
+	require.Regexp(t, regexp.MustCompile(noChannelState), out)
+
+	channelAmt := uint64(100)
+	create := make(chan string)
+	go func() {
+		// creator: paych add-funds <creator> <receiver> <amount>
+		cmd = []string{creatorAddr.String(), receiverAddr.String(), fmt.Sprintf("%d", channelAmt)}
+		create <- creatorCLI.runCmd(paychAddFundsCmd, cmd)
+	}()
+
+	// Wait for the output to stop being "Channel does not exist"
+	for regexp.MustCompile(noChannelState).MatchString(out) {
+		cmd = []string{creatorAddr.String(), receiverAddr.String()}
+		out = creatorCLI.runCmd(paychStatusByFromToCmd, cmd)
+	}
+	fmt.Println(out)
+
+	// The next state should be creating channel or channel created, depending
+	// on timing
+	stateCreating := regexp.MustCompile("Creating channel").MatchString(out)
+	stateCreated := regexp.MustCompile("Channel exists").MatchString(out)
+	require.True(t, stateCreating || stateCreated)
+
+	channelAmtAtto := types.BigMul(types.NewInt(channelAmt), types.NewInt(build.FilecoinPrecision))
+	channelAmtStr := fmt.Sprintf("%d", channelAmtAtto)
+	if stateCreating {
+		// If we're in the creating state (most likely) the amount should be pending
+		require.Regexp(t, regexp.MustCompile("Pending.*"+channelAmtStr), out)
+	}
+
+	// Wait for create channel to complete
+	chstr := <-create
+
+	cmd = []string{chstr}
+	out = creatorCLI.runCmd(paychStatusCmd, cmd)
+	fmt.Println(out)
+	// Output should have the channel address
+	require.Regexp(t, regexp.MustCompile("Channel.*"+chstr), out)
+	// Output should have confirmed amount
+	require.Regexp(t, regexp.MustCompile("Confirmed.*"+channelAmtStr), out)
+
+	chAddr, err := address.NewFromString(chstr)
+	require.NoError(t, err)
+
+	// creator: paych voucher create <channel> <amount>
+	voucherAmt := uint64(10)
+	cmd = []string{chAddr.String(), fmt.Sprintf("%d", voucherAmt)}
+	creatorCLI.runCmd(paychVoucherCreateCmd, cmd)
+
+	cmd = []string{chstr}
+	out = creatorCLI.runCmd(paychStatusCmd, cmd)
+	fmt.Println(out)
+	voucherAmtAtto := types.BigMul(types.NewInt(voucherAmt), types.NewInt(build.FilecoinPrecision))
+	voucherAmtStr := fmt.Sprintf("%d", voucherAmtAtto)
+	// Output should include voucher amount
+	require.Regexp(t, regexp.MustCompile("Voucher.*"+voucherAmtStr), out)
+}
+
+// TestPaymentChannelVouchers does a basic test to exercise some payment
+// channel voucher commands
+func TestPaymentChannelVouchers(t *testing.T) {
+	_ = os.Setenv("BELLMAN_NO_GPU", "1")
+
+	blocktime := 5 * time.Millisecond
+	ctx := context.Background()
+	nodes, addrs := startTwoNodesOneMiner(ctx, t, blocktime)
+	paymentCreator := nodes[0]
+	paymentReceiver := nodes[1]
+	creatorAddr := addrs[0]
+	receiverAddr := addrs[1]
+
+	// Create mock CLI
+	mockCLI := newMockCLI(t)
+	creatorCLI := mockCLI.client(paymentCreator.ListenAddr)
+	receiverCLI := mockCLI.client(paymentReceiver.ListenAddr)
+
+	// creator: paych add-funds <creator> <receiver> <amount>
+	channelAmt := "100000"
+	cmd := []string{creatorAddr.String(), receiverAddr.String(), channelAmt}
+	chstr := creatorCLI.runCmd(paychAddFundsCmd, cmd)
+
+	chAddr, err := address.NewFromString(chstr)
+	require.NoError(t, err)
+
+	var vouchers []voucherSpec
+
+	// creator: paych voucher create <channel> <amount>
+	// Note: implied --lane=0
+	voucherAmt1 := 100
+	cmd = []string{chAddr.String(), strconv.Itoa(voucherAmt1)}
+	voucher1 := creatorCLI.runCmd(paychVoucherCreateCmd, cmd)
+	vouchers = append(vouchers, voucherSpec{serialized: voucher1, lane: 0, amt: voucherAmt1})
+
+	// creator: paych voucher create <channel> <amount> --lane=5
+	lane5 := "--lane=5"
+	voucherAmt2 := 50
+	cmd = []string{lane5, chAddr.String(), strconv.Itoa(voucherAmt2)}
+	voucher2 := creatorCLI.runCmd(paychVoucherCreateCmd, cmd)
+	vouchers = append(vouchers, voucherSpec{serialized: voucher2, lane: 5, amt: voucherAmt2})
+
+	// creator: paych voucher create <channel> <amount> --lane=5
+	voucherAmt3 := 70
+	cmd = []string{lane5, chAddr.String(), strconv.Itoa(voucherAmt3)}
+	voucher3 := creatorCLI.runCmd(paychVoucherCreateCmd, cmd)
+	vouchers = append(vouchers, voucherSpec{serialized: voucher3, lane: 5, amt: voucherAmt3})
+
+	// creator: paych voucher create <channel> <amount> --lane=5
+	voucherAmt4 := 80
+	cmd = []string{lane5, chAddr.String(), strconv.Itoa(voucherAmt4)}
+	voucher4 := creatorCLI.runCmd(paychVoucherCreateCmd, cmd)
+	vouchers = append(vouchers, voucherSpec{serialized: voucher4, lane: 5, amt: voucherAmt4})
+
+	// creator: paych voucher list <channel> --export
+	cmd = []string{"--export", chAddr.String()}
+	list := creatorCLI.runCmd(paychVoucherListCmd, cmd)
+
+	// Check that voucher list output is correct on creator
+	checkVoucherOutput(t, list, vouchers)
+
+	// creator: paych voucher best-spendable <channel>
+	cmd = []string{"--export", chAddr.String()}
+	bestSpendable := creatorCLI.runCmd(paychVoucherBestSpendableCmd, cmd)
+
+	// Check that best spendable output is correct on creator
+	bestVouchers := []voucherSpec{
+		{serialized: voucher1, lane: 0, amt: voucherAmt1},
+		{serialized: voucher4, lane: 5, amt: voucherAmt4},
+	}
+	checkVoucherOutput(t, bestSpendable, bestVouchers)
+
+	// receiver: paych voucher add <voucher>
+	cmd = []string{chAddr.String(), voucher1}
+	receiverCLI.runCmd(paychVoucherAddCmd, cmd)
+
+	// receiver: paych voucher add <voucher>
+	cmd = []string{chAddr.String(), voucher2}
+	receiverCLI.runCmd(paychVoucherAddCmd, cmd)
+
+	// receiver: paych voucher add <voucher>
+	cmd = []string{chAddr.String(), voucher3}
+	receiverCLI.runCmd(paychVoucherAddCmd, cmd)
+
+	// receiver: paych voucher add <voucher>
+	cmd = []string{chAddr.String(), voucher4}
+	receiverCLI.runCmd(paychVoucherAddCmd, cmd)
+
+	// receiver: paych voucher list <channel> --export
+	cmd = []string{"--export", chAddr.String()}
+	list = receiverCLI.runCmd(paychVoucherListCmd, cmd)
+
+	// Check that voucher list output is correct on receiver
+	checkVoucherOutput(t, list, vouchers)
+
+	// receiver: paych voucher best-spendable <channel>
+	cmd = []string{"--export", chAddr.String()}
+	bestSpendable = receiverCLI.runCmd(paychVoucherBestSpendableCmd, cmd)
+
+	// Check that best spendable output is correct on receiver
+	bestVouchers = []voucherSpec{
+		{serialized: voucher1, lane: 0, amt: voucherAmt1},
+		{serialized: voucher4, lane: 5, amt: voucherAmt4},
+	}
+	checkVoucherOutput(t, bestSpendable, bestVouchers)
+
+	// receiver: paych voucher submit <channel> <voucher>
+	cmd = []string{chAddr.String(), voucher1}
+	receiverCLI.runCmd(paychVoucherSubmitCmd, cmd)
+
+	// receiver: paych voucher best-spendable <channel>
+	cmd = []string{"--export", chAddr.String()}
+	bestSpendable = receiverCLI.runCmd(paychVoucherBestSpendableCmd, cmd)
+
+	// Check that best spendable output no longer includes submitted voucher
+	bestVouchers = []voucherSpec{
+		{serialized: voucher4, lane: 5, amt: voucherAmt4},
+	}
+	checkVoucherOutput(t, bestSpendable, bestVouchers)
+
+	// There are three vouchers in lane 5: 50, 70, 80
+	// Submit the voucher for 50. Best spendable should still be 80.
+	// receiver: paych voucher submit <channel> <voucher>
+	cmd = []string{chAddr.String(), voucher2}
+	receiverCLI.runCmd(paychVoucherSubmitCmd, cmd)
+
+	// receiver: paych voucher best-spendable <channel>
+	cmd = []string{"--export", chAddr.String()}
+	bestSpendable = receiverCLI.runCmd(paychVoucherBestSpendableCmd, cmd)
+
+	// Check that best spendable output still includes the voucher for 80
+	bestVouchers = []voucherSpec{
+		{serialized: voucher4, lane: 5, amt: voucherAmt4},
+	}
+	checkVoucherOutput(t, bestSpendable, bestVouchers)
+
+	// Submit the voucher for 80
+	// receiver: paych voucher submit <channel> <voucher>
+	cmd = []string{chAddr.String(), voucher4}
+	receiverCLI.runCmd(paychVoucherSubmitCmd, cmd)
+
+	// receiver: paych voucher best-spendable <channel>
+	cmd = []string{"--export", chAddr.String()}
+	bestSpendable = receiverCLI.runCmd(paychVoucherBestSpendableCmd, cmd)
+
+	// Check that best spendable output no longer includes submitted voucher
+	bestVouchers = []voucherSpec{}
+	checkVoucherOutput(t, bestSpendable, bestVouchers)
+}
+
+// TestPaymentChannelVoucherCreateShortfall verifies that if a voucher amount
+// is greater than what's left in the channel, voucher create fails
+func TestPaymentChannelVoucherCreateShortfall(t *testing.T) {
+	_ = os.Setenv("BELLMAN_NO_GPU", "1")
+
+	blocktime := 5 * time.Millisecond
+	ctx := context.Background()
+	nodes, addrs := startTwoNodesOneMiner(ctx, t, blocktime)
+	paymentCreator := nodes[0]
+	creatorAddr := addrs[0]
+	receiverAddr := addrs[1]
+
+	// Create mock CLI
+	mockCLI := newMockCLI(t)
+	creatorCLI := mockCLI.client(paymentCreator.ListenAddr)
+
+	// creator: paych add-funds <creator> <receiver> <amount>
+	channelAmt := 100
+	cmd := []string{creatorAddr.String(), receiverAddr.String(), fmt.Sprintf("%d", channelAmt)}
+	chstr := creatorCLI.runCmd(paychAddFundsCmd, cmd)
+
+	chAddr, err := address.NewFromString(chstr)
+	require.NoError(t, err)
+
+	// creator: paych voucher create <channel> <amount> --lane=1
+	voucherAmt1 := 60
+	lane1 := "--lane=1"
+	cmd = []string{lane1, chAddr.String(), strconv.Itoa(voucherAmt1)}
+	voucher1 := creatorCLI.runCmd(paychVoucherCreateCmd, cmd)
+	fmt.Println(voucher1)
+
+	// creator: paych voucher create <channel> <amount> --lane=2
+	lane2 := "--lane=2"
+	voucherAmt2 := 70
+	cmd = []string{lane2, chAddr.String(), strconv.Itoa(voucherAmt2)}
+	_, err = creatorCLI.runCmdRaw(paychVoucherCreateCmd, cmd)
+
+	// Should fail because channel doesn't have required amount
+	require.Error(t, err)
+
+	shortfall := voucherAmt1 + voucherAmt2 - channelAmt
+	require.Regexp(t, regexp.MustCompile(fmt.Sprintf("shortfall: %d", shortfall)), err.Error())
+}
+
+func checkVoucherOutput(t *testing.T, list string, vouchers []voucherSpec) {
+	lines := strings.Split(list, "\n")
+	listVouchers := make(map[string]string)
+	for _, line := range lines {
+		parts := strings.Split(line, ";")
+		if len(parts) == 2 {
+			serialized := strings.TrimSpace(parts[1])
+			listVouchers[serialized] = strings.TrimSpace(parts[0])
+		}
+	}
+	for _, vchr := range vouchers {
+		res, ok := listVouchers[vchr.serialized]
+		require.True(t, ok)
+		require.Regexp(t, fmt.Sprintf("Lane %d", vchr.lane), res)
+		require.Regexp(t, fmt.Sprintf("%d", vchr.amt), res)
+		delete(listVouchers, vchr.serialized)
+	}
+	for _, vchr := range listVouchers {
+		require.Fail(t, "Extra voucher "+vchr)
+	}
+}
+
+func startTwoNodesOneMiner(ctx context.Context, t *testing.T, blocktime time.Duration) ([]test.TestNode, []address.Address) {
+	n, sn := builder.RPCMockSbBuilder(t, 2, test.OneMiner)
+
+	paymentCreator := n[0]
+	paymentReceiver := n[1]
+	miner := sn[0]
+
+	// Get everyone connected
+	addrs, err := paymentCreator.NetAddrsListen(ctx)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if err := paymentReceiver.NetConnect(ctx, addrs); err != nil {
+		t.Fatal(err)
+	}
+
+	if err := miner.NetConnect(ctx, addrs); err != nil {
+		t.Fatal(err)
+	}
+
+	// Start mining blocks
+	bm := test.NewBlockMiner(ctx, t, miner, blocktime)
+	bm.MineBlocks()
+
+	// Send some funds to register the receiver
+	receiverAddr, err := paymentReceiver.WalletNew(ctx, wallet.ActSigType("secp256k1"))
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	test.SendFunds(ctx, t, paymentCreator, receiverAddr, abi.NewTokenAmount(1e18))
+
+	// Get the creator's address
+	creatorAddr, err := paymentCreator.WalletDefaultAddress(ctx)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// Create mock CLI
+	return n, []address.Address{creatorAddr, receiverAddr}
+}
+
+type mockCLI struct {
+	t    *testing.T
+	cctx *cli.Context
+	out  *bytes.Buffer
+}
+
+func newMockCLI(t *testing.T) *mockCLI {
+	// Create a CLI App with an --api flag so that we can specify which node
+	// the command should be executed against
+	app := cli.NewApp()
+	app.Flags = []cli.Flag{
+		&cli.StringFlag{
+			Name:   "api",
+			Hidden: true,
+		},
+	}
+	var out bytes.Buffer
+	app.Writer = &out
+	app.Setup()
+
+	cctx := cli.NewContext(app, &flag.FlagSet{}, nil)
+	return &mockCLI{t: t, cctx: cctx, out: &out}
+}
+
+func (c *mockCLI) client(addr multiaddr.Multiaddr) *mockCLIClient {
+	return &mockCLIClient{t: c.t, addr: addr, cctx: c.cctx, out: c.out}
+}
+
+// mockCLIClient runs commands against a particular node
+type mockCLIClient struct {
+	t    *testing.T
+	addr multiaddr.Multiaddr
+	cctx *cli.Context
+	out  *bytes.Buffer
+}
+
+func (c *mockCLIClient) runCmd(cmd *cli.Command, input []string) string {
+	out, err := c.runCmdRaw(cmd, input)
+	require.NoError(c.t, err)
+
+	return out
+}
+
+func (c *mockCLIClient) runCmdRaw(cmd *cli.Command, input []string) (string, error) {
+	// prepend --api=<node api listener address>
+	apiFlag := "--api=" + c.addr.String()
+	input = append([]string{apiFlag}, input...)
+
+	fs := c.flagSet(cmd)
+	err := fs.Parse(input)
+	require.NoError(c.t, err)
+
+	err = cmd.Action(cli.NewContext(c.cctx.App, fs, c.cctx))
+
+	// Get the output
+	str := strings.TrimSpace(c.out.String())
+	c.out.Reset()
+	return str, err
+}
+
+func (c *mockCLIClient) flagSet(cmd *cli.Command) *flag.FlagSet {
+	// Apply app level flags (so we can process --api flag)
+	fs := &flag.FlagSet{}
+	for _, f := range c.cctx.App.Flags {
+		err := f.Apply(fs)
+		if err != nil {
+			c.t.Fatal(err)
+		}
+	}
+	// Apply command level flags
+	for _, f := range cmd.Flags {
+		err := f.Apply(fs)
+		if err != nil {
+			c.t.Fatal(err)
+		}
+	}
+	return fs
+}
+
+// waitForHeight waits for the node to reach the given chain epoch
+func waitForHeight(ctx context.Context, t *testing.T, node test.TestNode, height abi.ChainEpoch) {
+	atHeight := make(chan struct{})
+	chainEvents := events.NewEvents(ctx, node)
+	err := chainEvents.ChainAt(func(ctx context.Context, ts *types.TipSet, curH abi.ChainEpoch) error {
+		close(atHeight)
+		return nil
+	}, nil, 1, height)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	select {
+	case <-atHeight:
+	case <-ctx.Done():
+	}
+}
+
+// getPaychState gets the state of the payment channel with the given address
+func getPaychState(ctx context.Context, t *testing.T, node test.TestNode, chAddr address.Address) paych.State {
+	act, err := node.StateGetActor(ctx, chAddr, types.EmptyTSK)
+	require.NoError(t, err)
+
+	store := cbor.NewCborStore(apibstore.NewAPIBlockstore(node))
+	chState, err := paych.Load(adt.WrapStore(ctx, store), act)
+	require.NoError(t, err)
+
+	return chState
+}
diff --git a/cli/pprof.go b/cli/pprof.go
new file mode 100644
index 000000000..6819b362a
--- /dev/null
+++ b/cli/pprof.go
@@ -0,0 +1,58 @@
+package cli
+
+import (
+	"io"
+	"net/http"
+	"os"
+
+	"github.com/urfave/cli/v2"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/lotus/node/repo"
+	manet "github.com/multiformats/go-multiaddr/net"
+)
+
+var pprofCmd = &cli.Command{
+	Name:   "pprof",
+	Hidden: true,
+	Subcommands: []*cli.Command{
+		PprofGoroutines,
+	},
+}
+
+var PprofGoroutines = &cli.Command{
+	Name:  "goroutines",
+	Usage: "Get goroutine stacks",
+	Action: func(cctx *cli.Context) error {
+		ti, ok := cctx.App.Metadata["repoType"]
+		if !ok {
+			log.Errorf("unknown repo type, are you sure you want to use GetAPI?")
+			ti = repo.FullNode
+		}
+		t, ok := ti.(repo.RepoType)
+		if !ok {
+			log.Errorf("repoType type does not match the type of repo.RepoType")
+		}
+		ainfo, err := GetAPIInfo(cctx, t)
+		if err != nil {
+			return xerrors.Errorf("could not get API info: %w", err)
+		}
+		_, addr, err := manet.DialArgs(ainfo.Addr)
+		if err != nil {
+			return err
+		}
+
+		addr = "http://" + addr + "/debug/pprof/goroutine?debug=2"
+
+		r, err := http.Get(addr) //nolint:gosec
+		if err != nil {
+			return err
+		}
+
+		if _, err := io.Copy(os.Stdout, r.Body); err != nil {
+			return err
+		}
+
+		return r.Body.Close()
+	},
+}
diff --git a/cli/send.go b/cli/send.go
index e221ee49a..14c1b263b 100644
--- a/cli/send.go
+++ b/cli/send.go
@@ -1,24 +1,72 @@
 package cli
 
 import (
+	"bytes"
+	"context"
+	"encoding/hex"
+	"encoding/json"
 	"fmt"
+	"reflect"
+
+	"github.com/urfave/cli/v2"
+	cbg "github.com/whyrusleeping/cbor-gen"
 
 	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/abi"
+
+	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/chain/stmgr"
 	"github.com/filecoin-project/lotus/chain/types"
-	"gopkg.in/urfave/cli.v2"
 )
 
 var sendCmd = &cli.Command{
 	Name:      "send",
 	Usage:     "Send funds between accounts",
-	ArgsUsage: "<target> <amount>",
+	ArgsUsage: "[targetAddress] [amount]",
 	Flags: []cli.Flag{
 		&cli.StringFlag{
-			Name:  "source",
-			Usage: "optinally specifiy the account to send funds from",
+			Name:  "from",
+			Usage: "optionally specify the account to send funds from",
+		},
+		&cli.StringFlag{
+			Name:  "gas-premium",
+			Usage: "specify gas price to use in AttoFIL",
+			Value: "0",
+		},
+		&cli.StringFlag{
+			Name:  "gas-feecap",
+			Usage: "specify gas fee cap to use in AttoFIL",
+			Value: "0",
+		},
+		&cli.Int64Flag{
+			Name:  "gas-limit",
+			Usage: "specify gas limit",
+			Value: 0,
+		},
+		&cli.Int64Flag{
+			Name:  "nonce",
+			Usage: "specify the nonce to use",
+			Value: -1,
+		},
+		&cli.Uint64Flag{
+			Name:  "method",
+			Usage: "specify method to invoke",
+			Value: 0,
+		},
+		&cli.StringFlag{
+			Name:  "params-json",
+			Usage: "specify invocation parameters in json",
+		},
+		&cli.StringFlag{
+			Name:  "params-hex",
+			Usage: "specify invocation parameters in hex",
 		},
 	},
 	Action: func(cctx *cli.Context) error {
+		if cctx.Args().Len() != 2 {
+			return ShowHelp(cctx, fmt.Errorf("'send' expects two arguments, target and amount"))
+		}
+
 		api, closer, err := GetFullNodeAPI(cctx)
 		if err != nil {
 			return err
@@ -27,22 +75,18 @@ var sendCmd = &cli.Command{
 
 		ctx := ReqContext(cctx)
 
-		if cctx.Args().Len() != 2 {
-			return fmt.Errorf("'send' expects two arguments, target and amount")
-		}
-
 		toAddr, err := address.NewFromString(cctx.Args().Get(0))
 		if err != nil {
-			return err
+			return ShowHelp(cctx, fmt.Errorf("failed to parse target address: %w", err))
 		}
 
 		val, err := types.ParseFIL(cctx.Args().Get(1))
 		if err != nil {
-			return err
+			return ShowHelp(cctx, fmt.Errorf("failed to parse amount: %w", err))
 		}
 
 		var fromAddr address.Address
-		if from := cctx.String("source"); from == "" {
+		if from := cctx.String("from"); from == "" {
 			defaddr, err := api.WalletDefaultAddress(ctx)
 			if err != nil {
 				return err
@@ -58,19 +102,91 @@ var sendCmd = &cli.Command{
 			fromAddr = addr
 		}
 
-		msg := &types.Message{
-			From:     fromAddr,
-			To:       toAddr,
-			Value:    types.BigInt(val),
-			GasLimit: types.NewInt(1000),
-			GasPrice: types.NewInt(0),
-		}
-
-		_, err = api.MpoolPushMessage(ctx, msg)
+		gp, err := types.BigFromString(cctx.String("gas-premium"))
 		if err != nil {
 			return err
 		}
+		gfc, err := types.BigFromString(cctx.String("gas-feecap"))
+		if err != nil {
+			return err
+		}
+
+		method := abi.MethodNum(cctx.Uint64("method"))
+
+		var params []byte
+		if cctx.IsSet("params-json") {
+			decparams, err := decodeTypedParams(ctx, api, toAddr, method, cctx.String("params-json"))
+			if err != nil {
+				return fmt.Errorf("failed to decode json params: %w", err)
+			}
+			params = decparams
+		}
+		if cctx.IsSet("params-hex") {
+			if params != nil {
+				return fmt.Errorf("can only specify one of 'params-json' and 'params-hex'")
+			}
+			decparams, err := hex.DecodeString(cctx.String("params-hex"))
+			if err != nil {
+				return fmt.Errorf("failed to decode hex params: %w", err)
+			}
+			params = decparams
+		}
+
+		msg := &types.Message{
+			From:       fromAddr,
+			To:         toAddr,
+			Value:      types.BigInt(val),
+			GasPremium: gp,
+			GasFeeCap:  gfc,
+			GasLimit:   cctx.Int64("gas-limit"),
+			Method:     method,
+			Params:     params,
+		}
+
+		if cctx.Int64("nonce") > 0 {
+			msg.Nonce = uint64(cctx.Int64("nonce"))
+			sm, err := api.WalletSignMessage(ctx, fromAddr, msg)
+			if err != nil {
+				return err
+			}
+
+			_, err = api.MpoolPush(ctx, sm)
+			if err != nil {
+				return err
+			}
+			fmt.Println(sm.Cid())
+		} else {
+			sm, err := api.MpoolPushMessage(ctx, msg, nil)
+			if err != nil {
+				return err
+			}
+			fmt.Println(sm.Cid())
+		}
 
 		return nil
 	},
 }
+
+func decodeTypedParams(ctx context.Context, fapi api.FullNode, to address.Address, method abi.MethodNum, paramstr string) ([]byte, error) {
+	act, err := fapi.StateGetActor(ctx, to, types.EmptyTSK)
+	if err != nil {
+		return nil, err
+	}
+
+	methodMeta, found := stmgr.MethodsMap[act.Code][method]
+	if !found {
+		return nil, fmt.Errorf("method %d not found on actor %s", method, act.Code)
+	}
+
+	p := reflect.New(methodMeta.Params.Elem()).Interface().(cbg.CBORMarshaler)
+
+	if err := json.Unmarshal([]byte(paramstr), p); err != nil {
+		return nil, fmt.Errorf("unmarshaling input into params type: %w", err)
+	}
+
+	buf := new(bytes.Buffer)
+	if err := p.MarshalCBOR(buf); err != nil {
+		return nil, err
+	}
+	return buf.Bytes(), nil
+}
diff --git a/cli/state.go b/cli/state.go
index 36c9ffa1b..b25a5e4a7 100644
--- a/cli/state.go
+++ b/cli/state.go
@@ -1,18 +1,44 @@
 package cli
 
 import (
+	"bytes"
 	"context"
 	"encoding/json"
 	"fmt"
+	"html/template"
+	"io"
+	"os"
+	"reflect"
+	"sort"
+	"strconv"
 	"strings"
+	"time"
 
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/lotus/api"
-	"github.com/filecoin-project/lotus/chain/types"
-	"golang.org/x/xerrors"
+	"github.com/filecoin-project/specs-actors/actors/runtime"
+
+	"github.com/multiformats/go-multiaddr"
 
 	"github.com/ipfs/go-cid"
-	"gopkg.in/urfave/cli.v2"
+	cbor "github.com/ipfs/go-ipld-cbor"
+	"github.com/libp2p/go-libp2p-core/peer"
+	"github.com/multiformats/go-multihash"
+	"github.com/urfave/cli/v2"
+	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/big"
+	"github.com/filecoin-project/go-state-types/exitcode"
+	"github.com/filecoin-project/specs-actors/actors/builtin"
+	"github.com/filecoin-project/specs-actors/actors/builtin/exported"
+
+	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/api/apibstore"
+	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/state"
+	"github.com/filecoin-project/lotus/chain/stmgr"
+	"github.com/filecoin-project/lotus/chain/types"
 )
 
 var stateCmd = &cli.Command{
@@ -27,25 +53,89 @@ var stateCmd = &cli.Command{
 	Subcommands: []*cli.Command{
 		statePowerCmd,
 		stateSectorsCmd,
-		stateProvingSetCmd,
-		statePledgeCollateralCmd,
+		stateActiveSectorsCmd,
 		stateListActorsCmd,
 		stateListMinersCmd,
+		stateCircSupplyCmd,
+		stateSectorCmd,
 		stateGetActorCmd,
 		stateLookupIDCmd,
 		stateReplaySetCmd,
 		stateSectorSizeCmd,
 		stateReadStateCmd,
 		stateListMessagesCmd,
+		stateComputeStateCmd,
+		stateCallCmd,
+		stateGetDealSetCmd,
+		stateWaitMsgCmd,
+		stateSearchMsgCmd,
+		stateMsgCostCmd,
+		stateMinerInfo,
+		stateMarketCmd,
 	},
 }
 
-func parseTipSetString(cctx *cli.Context) ([]cid.Cid, error) {
-	ts := cctx.String("tipset")
-	if ts == "" {
-		return nil, nil
-	}
+var stateMinerInfo = &cli.Command{
+	Name:      "miner-info",
+	Usage:     "Retrieve miner information",
+	ArgsUsage: "[minerAddress]",
+	Action: func(cctx *cli.Context) error {
+		api, closer, err := GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
 
+		ctx := ReqContext(cctx)
+
+		if !cctx.Args().Present() {
+			return fmt.Errorf("must specify miner to get information for")
+		}
+
+		addr, err := address.NewFromString(cctx.Args().First())
+		if err != nil {
+			return err
+		}
+
+		ts, err := LoadTipSet(ctx, cctx, api)
+		if err != nil {
+			return err
+		}
+
+		mi, err := api.StateMinerInfo(ctx, addr, ts.Key())
+		if err != nil {
+			return err
+		}
+
+		fmt.Printf("Owner:\t%s\n", mi.Owner)
+		fmt.Printf("Worker:\t%s\n", mi.Worker)
+		for i, controlAddress := range mi.ControlAddresses {
+			fmt.Printf("Control %d: \t%s\n", i, controlAddress)
+		}
+		fmt.Printf("PeerID:\t%s\n", mi.PeerId)
+		fmt.Printf("SectorSize:\t%s (%d)\n", types.SizeStr(types.NewInt(uint64(mi.SectorSize))), mi.SectorSize)
+		fmt.Printf("Multiaddrs: \t")
+		for _, addr := range mi.Multiaddrs {
+			a, err := multiaddr.NewMultiaddrBytes(addr)
+			if err != nil {
+				return xerrors.Errorf("undecodable listen address: %w", err)
+			}
+			fmt.Printf("%s ", a)
+		}
+		fmt.Println()
+
+		cd, err := api.StateMinerProvingDeadline(ctx, addr, ts.Key())
+		if err != nil {
+			return xerrors.Errorf("getting miner info: %w", err)
+		}
+
+		fmt.Printf("Proving Period Start:\t%s\n", EpochTime(cd.CurrentEpoch, cd.PeriodStart))
+
+		return nil
+	},
+}
+
+func ParseTipSetString(ts string) ([]cid.Cid, error) {
 	strs := strings.Split(ts, ",")
 
 	var cids []cid.Cid
@@ -60,8 +150,30 @@ func parseTipSetString(cctx *cli.Context) ([]cid.Cid, error) {
 	return cids, nil
 }
 
-func loadTipSet(ctx context.Context, cctx *cli.Context, api api.FullNode) (*types.TipSet, error) {
-	cids, err := parseTipSetString(cctx)
+func LoadTipSet(ctx context.Context, cctx *cli.Context, api api.FullNode) (*types.TipSet, error) {
+	tss := cctx.String("tipset")
+	if tss == "" {
+		return nil, nil
+	}
+
+	return ParseTipSetRef(ctx, api, tss)
+}
+
+func ParseTipSetRef(ctx context.Context, api api.FullNode, tss string) (*types.TipSet, error) {
+	if tss[0] == '@' {
+		if tss == "@head" {
+			return api.ChainHead(ctx)
+		}
+
+		var h uint64
+		if _, err := fmt.Sscanf(tss, "@%d", &h); err != nil {
+			return nil, xerrors.Errorf("parsing height tipset ref: %w", err)
+		}
+
+		return api.ChainGetTipSetByHeight(ctx, abi.ChainEpoch(h), types.EmptyTSK)
+	}
+
+	cids, err := ParseTipSetString(tss)
 	if err != nil {
 		return nil, err
 	}
@@ -80,8 +192,9 @@ func loadTipSet(ctx context.Context, cctx *cli.Context, api api.FullNode) (*type
 }
 
 var statePowerCmd = &cli.Command{
-	Name:  "power",
-	Usage: "Query network or miner power",
+	Name:      "power",
+	Usage:     "Query network or miner power",
+	ArgsUsage: "[<minerAddress> (optional)]",
 	Action: func(cctx *cli.Context) error {
 		api, closer, err := GetFullNodeAPI(cctx)
 		if err != nil {
@@ -99,29 +212,33 @@ var statePowerCmd = &cli.Command{
 			}
 		}
 
-		ts, err := loadTipSet(ctx, cctx, api)
+		ts, err := LoadTipSet(ctx, cctx, api)
 		if err != nil {
 			return err
 		}
 
-		power, err := api.StateMinerPower(ctx, maddr, ts)
+		power, err := api.StateMinerPower(ctx, maddr, ts.Key())
 		if err != nil {
 			return err
 		}
 
-		res := power.TotalPower
+		tp := power.TotalPower
 		if cctx.Args().Present() {
-			res = power.MinerPower
+			mp := power.MinerPower
+			percI := types.BigDiv(types.BigMul(mp.QualityAdjPower, types.NewInt(1000000)), tp.QualityAdjPower)
+			fmt.Printf("%s(%s) / %s(%s) ~= %0.4f%%\n", mp.QualityAdjPower.String(), types.SizeStr(mp.QualityAdjPower), tp.QualityAdjPower.String(), types.SizeStr(tp.QualityAdjPower), float64(percI.Int64())/10000)
+		} else {
+			fmt.Printf("%s(%s)\n", tp.QualityAdjPower.String(), types.SizeStr(tp.QualityAdjPower))
 		}
 
-		fmt.Println(res.String())
 		return nil
 	},
 }
 
 var stateSectorsCmd = &cli.Command{
-	Name:  "sectors",
-	Usage: "Query the sector set of a miner",
+	Name:      "sectors",
+	Usage:     "Query the sector set of a miner",
+	ArgsUsage: "[minerAddress]",
 	Action: func(cctx *cli.Context) error {
 		api, closer, err := GetFullNodeAPI(cctx)
 		if err != nil {
@@ -140,27 +257,28 @@ var stateSectorsCmd = &cli.Command{
 			return err
 		}
 
-		ts, err := loadTipSet(ctx, cctx, api)
+		ts, err := LoadTipSet(ctx, cctx, api)
 		if err != nil {
 			return err
 		}
 
-		sectors, err := api.StateMinerSectors(ctx, maddr, ts)
+		sectors, err := api.StateMinerSectors(ctx, maddr, nil, ts.Key())
 		if err != nil {
 			return err
 		}
 
 		for _, s := range sectors {
-			fmt.Printf("%d: %x %x\n", s.SectorID, s.CommR, s.CommD)
+			fmt.Printf("%d: %x\n", s.SectorNumber, s.SealedCID)
 		}
 
 		return nil
 	},
 }
 
-var stateProvingSetCmd = &cli.Command{
-	Name:  "proving",
-	Usage: "Query the proving set of a miner",
+var stateActiveSectorsCmd = &cli.Command{
+	Name:      "active-sectors",
+	Usage:     "Query the active sector set of a miner",
+	ArgsUsage: "[minerAddress]",
 	Action: func(cctx *cli.Context) error {
 		api, closer, err := GetFullNodeAPI(cctx)
 		if err != nil {
@@ -179,18 +297,18 @@ var stateProvingSetCmd = &cli.Command{
 			return err
 		}
 
-		ts, err := loadTipSet(ctx, cctx, api)
+		ts, err := LoadTipSet(ctx, cctx, api)
 		if err != nil {
 			return err
 		}
 
-		sectors, err := api.StateMinerProvingSet(ctx, maddr, ts)
+		sectors, err := api.StateMinerActiveSectors(ctx, maddr, ts.Key())
 		if err != nil {
 			return err
 		}
 
 		for _, s := range sectors {
-			fmt.Printf("%d: %x %x\n", s.SectorID, s.CommR, s.CommD)
+			fmt.Printf("%d: %x\n", s.SectorNumber, s.SealedCID)
 		}
 
 		return nil
@@ -198,11 +316,12 @@ var stateProvingSetCmd = &cli.Command{
 }
 
 var stateReplaySetCmd = &cli.Command{
-	Name:  "replay",
-	Usage: "Replay a particular message within a tipset",
+	Name:      "replay",
+	Usage:     "Replay a particular message within a tipset",
+	ArgsUsage: "[tipsetKey messageCid]",
 	Action: func(cctx *cli.Context) error {
-		if cctx.Args().Len() < 2 {
-			fmt.Println("usage: <tipset> <message cid>")
+		if cctx.Args().Len() < 1 {
+			fmt.Println("usage: [tipset] <message cid>")
 			fmt.Println("The last cid passed will be used as the message CID")
 			fmt.Println("All preceding ones will be used as the tipset")
 			return nil
@@ -214,16 +333,7 @@ var stateReplaySetCmd = &cli.Command{
 			return fmt.Errorf("message cid was invalid: %s", err)
 		}
 
-		var tscids []cid.Cid
-		for _, s := range args[:len(args)-1] {
-			c, err := cid.Decode(s)
-			if err != nil {
-				return fmt.Errorf("tipset cid was invalid: %s", err)
-			}
-			tscids = append(tscids, c)
-		}
-
-		api, closer, err := GetFullNodeAPI(cctx)
+		fapi, closer, err := GetFullNodeAPI(cctx)
 		if err != nil {
 			return err
 		}
@@ -231,31 +341,61 @@ var stateReplaySetCmd = &cli.Command{
 
 		ctx := ReqContext(cctx)
 
-		var headers []*types.BlockHeader
-		for _, c := range tscids {
-			h, err := api.ChainGetBlock(ctx, c)
-			if err != nil {
-				return err
+		var ts *types.TipSet
+		{
+			var tscids []cid.Cid
+			for _, s := range args[:len(args)-1] {
+				c, err := cid.Decode(s)
+				if err != nil {
+					return fmt.Errorf("tipset cid was invalid: %s", err)
+				}
+				tscids = append(tscids, c)
+			}
+
+			if len(tscids) > 0 {
+				var headers []*types.BlockHeader
+				for _, c := range tscids {
+					h, err := fapi.ChainGetBlock(ctx, c)
+					if err != nil {
+						return err
+					}
+
+					headers = append(headers, h)
+				}
+
+				ts, err = types.NewTipSet(headers)
+				if err != nil {
+					return err
+				}
+			} else {
+				var r *api.MsgLookup
+				r, err = fapi.StateWaitMsg(ctx, mcid, build.MessageConfidence)
+				if err != nil {
+					return xerrors.Errorf("finding message in chain: %w", err)
+				}
+
+				childTs, err := fapi.ChainGetTipSet(ctx, r.TipSet)
+				if err != nil {
+					return xerrors.Errorf("loading tipset: %w", err)
+				}
+				ts, err = fapi.ChainGetTipSet(ctx, childTs.Parents())
+				if err != nil {
+					return err
+				}
 			}
 
-			headers = append(headers, h)
 		}
 
-		ts, err := types.NewTipSet(headers)
-		if err != nil {
-			return err
-		}
-
-		res, err := api.StateReplay(ctx, ts, mcid)
+		res, err := fapi.StateReplay(ctx, ts.Key(), mcid)
 		if err != nil {
 			return xerrors.Errorf("replay call failed: %w", err)
 		}
 
 		fmt.Println("Replay receipt:")
-		fmt.Printf("Exit code: %d\n", res.Receipt.ExitCode)
-		fmt.Printf("Return: %x\n", res.Receipt.Return)
-		fmt.Printf("Gas Used: %s\n", res.Receipt.GasUsed)
-		if res.Receipt.ExitCode != 0 {
+		fmt.Printf("Exit code: %d\n", res.MsgRct.ExitCode)
+		fmt.Printf("Return: %x\n", res.MsgRct.Return)
+		fmt.Printf("Gas Used: %d\n", res.MsgRct.GasUsed)
+		if res.MsgRct.ExitCode != 0 {
 			fmt.Printf("Error message: %q\n", res.Error)
 		}
 
@@ -263,9 +403,10 @@ var stateReplaySetCmd = &cli.Command{
 	},
 }
 
-var statePledgeCollateralCmd = &cli.Command{
-	Name:  "pledge-collateral",
-	Usage: "Get minimum miner pledge collateral",
+var stateGetDealSetCmd = &cli.Command{
+	Name:      "get-deal",
+	Usage:     "View on-chain deal info",
+	ArgsUsage: "[dealId]",
 	Action: func(cctx *cli.Context) error {
 		api, closer, err := GetFullNodeAPI(cctx)
 		if err != nil {
@@ -275,17 +416,31 @@ var statePledgeCollateralCmd = &cli.Command{
 
 		ctx := ReqContext(cctx)
 
-		ts, err := loadTipSet(ctx, cctx, api)
+		if !cctx.Args().Present() {
+			return fmt.Errorf("must specify deal ID")
+		}
+
+		dealid, err := strconv.ParseUint(cctx.Args().First(), 10, 64)
+		if err != nil {
+			return xerrors.Errorf("parsing deal ID: %w", err)
+		}
+
+		ts, err := LoadTipSet(ctx, cctx, api)
 		if err != nil {
 			return err
 		}
 
-		coll, err := api.StatePledgeCollateral(ctx, ts)
+		deal, err := api.StateMarketStorageDeal(ctx, abi.DealID(dealid), ts.Key())
 		if err != nil {
 			return err
 		}
 
-		fmt.Println(types.FIL(coll))
+		data, err := json.MarshalIndent(deal, "", "  ")
+		if err != nil {
+			return err
+		}
+		fmt.Println(string(data))
+
 		return nil
 	},
 }
@@ -293,6 +448,12 @@ var statePledgeCollateralCmd = &cli.Command{
 var stateListMinersCmd = &cli.Command{
 	Name:  "list-miners",
 	Usage: "list all miners in the network",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:  "sort-by",
+			Usage: "criteria to sort miners by (none, num-deals)",
+		},
+	},
 	Action: func(cctx *cli.Context) error {
 		api, closer, err := GetFullNodeAPI(cctx)
 		if err != nil {
@@ -302,16 +463,36 @@ var stateListMinersCmd = &cli.Command{
 
 		ctx := ReqContext(cctx)
 
-		ts, err := loadTipSet(ctx, cctx, api)
+		ts, err := LoadTipSet(ctx, cctx, api)
 		if err != nil {
 			return err
 		}
 
-		miners, err := api.StateListMiners(ctx, ts)
+		miners, err := api.StateListMiners(ctx, ts.Key())
 		if err != nil {
 			return err
 		}
 
+		switch cctx.String("sort-by") {
+		case "num-deals":
+			ndm, err := getDealsCounts(ctx, api)
+			if err != nil {
+				return err
+			}
+
+			sort.Slice(miners, func(i, j int) bool {
+				return ndm[miners[i]] > ndm[miners[j]]
+			})
+
+			for i := 0; i < 50 && i < len(miners); i++ {
+				fmt.Printf("%s %d\n", miners[i], ndm[miners[i]])
+			}
+			return nil
+		default:
+			return fmt.Errorf("unrecognized sorting order")
+		case "", "none":
+		}
+
 		for _, m := range miners {
 			fmt.Println(m.String())
 		}
@@ -320,6 +501,22 @@ var stateListMinersCmd = &cli.Command{
 	},
 }
 
+func getDealsCounts(ctx context.Context, lapi api.FullNode) (map[address.Address]int, error) {
+	allDeals, err := lapi.StateMarketDeals(ctx, types.EmptyTSK)
+	if err != nil {
+		return nil, err
+	}
+
+	out := make(map[address.Address]int)
+	for _, d := range allDeals {
+		if d.State.SectorStartEpoch != -1 {
+			out[d.Proposal.Provider]++
+		}
+	}
+
+	return out, nil
+}
+
 var stateListActorsCmd = &cli.Command{
 	Name:  "list-actors",
 	Usage: "list all actors in the network",
@@ -332,12 +529,12 @@ var stateListActorsCmd = &cli.Command{
 
 		ctx := ReqContext(cctx)
 
-		ts, err := loadTipSet(ctx, cctx, api)
+		ts, err := LoadTipSet(ctx, cctx, api)
 		if err != nil {
 			return err
 		}
 
-		actors, err := api.StateListActors(ctx, ts)
+		actors, err := api.StateListActors(ctx, ts.Key())
 		if err != nil {
 			return err
 		}
@@ -351,8 +548,9 @@ var stateListActorsCmd = &cli.Command{
 }
 
 var stateGetActorCmd = &cli.Command{
-	Name:  "get-actor",
-	Usage: "Print actor information",
+	Name:      "get-actor",
+	Usage:     "Print actor information",
+	ArgsUsage: "[actorrAddress]",
 	Action: func(cctx *cli.Context) error {
 		api, closer, err := GetFullNodeAPI(cctx)
 		if err != nil {
@@ -371,20 +569,22 @@ var stateGetActorCmd = &cli.Command{
 			return err
 		}
 
-		ts, err := loadTipSet(ctx, cctx, api)
+		ts, err := LoadTipSet(ctx, cctx, api)
 		if err != nil {
 			return err
 		}
 
-		a, err := api.StateGetActor(ctx, addr, ts)
+		a, err := api.StateGetActor(ctx, addr, ts.Key())
 		if err != nil {
 			return err
 		}
 
+		strtype := builtin.ActorNameByCode(a.Code)
+
 		fmt.Printf("Address:\t%s\n", addr)
 		fmt.Printf("Balance:\t%s\n", types.FIL(a.Balance))
 		fmt.Printf("Nonce:\t\t%d\n", a.Nonce)
-		fmt.Printf("Code:\t\t%s\n", a.Code)
+		fmt.Printf("Code:\t\t%s (%s)\n", a.Code, strtype)
 		fmt.Printf("Head:\t\t%s\n", a.Head)
 
 		return nil
@@ -392,8 +592,16 @@ var stateGetActorCmd = &cli.Command{
 }
 
 var stateLookupIDCmd = &cli.Command{
-	Name:  "lookup",
-	Usage: "Find corresponding ID address",
+	Name:      "lookup",
+	Usage:     "Find corresponding ID address",
+	ArgsUsage: "[address]",
+	Flags: []cli.Flag{
+		&cli.BoolFlag{
+			Name:    "reverse",
+			Aliases: []string{"r"},
+			Usage:   "Perform reverse lookup",
+		},
+	},
 	Action: func(cctx *cli.Context) error {
 		api, closer, err := GetFullNodeAPI(cctx)
 		if err != nil {
@@ -412,12 +620,18 @@ var stateLookupIDCmd = &cli.Command{
 			return err
 		}
 
-		ts, err := loadTipSet(ctx, cctx, api)
+		ts, err := LoadTipSet(ctx, cctx, api)
 		if err != nil {
 			return err
 		}
 
-		a, err := api.StateLookupID(ctx, addr, ts)
+		var a address.Address
+		if !cctx.Bool("reverse") {
+			a, err = api.StateLookupID(ctx, addr, ts.Key())
+		} else {
+			a, err = api.StateAccountKey(ctx, addr, ts.Key())
+		}
+
 		if err != nil {
 			return err
 		}
@@ -429,8 +643,9 @@ var stateLookupIDCmd = &cli.Command{
 }
 
 var stateSectorSizeCmd = &cli.Command{
-	Name:  "sector-size",
-	Usage: "Look up miners sector size",
+	Name:      "sector-size",
+	Usage:     "Look up miners sector size",
+	ArgsUsage: "[minerAddress]",
 	Action: func(cctx *cli.Context) error {
 		api, closer, err := GetFullNodeAPI(cctx)
 		if err != nil {
@@ -441,7 +656,7 @@ var stateSectorSizeCmd = &cli.Command{
 		ctx := ReqContext(cctx)
 
 		if !cctx.Args().Present() {
-			return fmt.Errorf("must pass address of actor to get")
+			return fmt.Errorf("must pass miner's address")
 		}
 
 		addr, err := address.NewFromString(cctx.Args().First())
@@ -449,24 +664,25 @@ var stateSectorSizeCmd = &cli.Command{
 			return err
 		}
 
-		ts, err := loadTipSet(ctx, cctx, api)
+		ts, err := LoadTipSet(ctx, cctx, api)
 		if err != nil {
 			return err
 		}
 
-		ssize, err := api.StateMinerSectorSize(ctx, addr, ts)
+		mi, err := api.StateMinerInfo(ctx, addr, ts.Key())
 		if err != nil {
 			return err
 		}
 
-		fmt.Printf("%d\n", ssize)
+		fmt.Printf("%s (%d)\n", types.SizeStr(types.NewInt(uint64(mi.SectorSize))), mi.SectorSize)
 		return nil
 	},
 }
 
 var stateReadStateCmd = &cli.Command{
-	Name:  "read-state",
-	Usage: "View a json representation of an actors state",
+	Name:      "read-state",
+	Usage:     "View a json representation of an actors state",
+	ArgsUsage: "[actorAddress]",
 	Action: func(cctx *cli.Context) error {
 		api, closer, err := GetFullNodeAPI(cctx)
 		if err != nil {
@@ -485,17 +701,12 @@ var stateReadStateCmd = &cli.Command{
 			return err
 		}
 
-		ts, err := loadTipSet(ctx, cctx, api)
+		ts, err := LoadTipSet(ctx, cctx, api)
 		if err != nil {
 			return err
 		}
 
-		act, err := api.StateGetActor(ctx, addr, ts)
-		if err != nil {
-			return err
-		}
-
-		as, err := api.StateReadState(ctx, act, ts)
+		as, err := api.StateReadState(ctx, addr, ts.Key())
 		if err != nil {
 			return err
 		}
@@ -526,6 +737,10 @@ var stateListMessagesCmd = &cli.Command{
 			Name:  "toheight",
 			Usage: "don't look before given block height",
 		},
+		&cli.BoolFlag{
+			Name:  "cids",
+			Usage: "print message CIDs instead of messages",
+		},
 	},
 	Action: func(cctx *cli.Context) error {
 		api, closer, err := GetFullNodeAPI(cctx)
@@ -555,17 +770,22 @@ var stateListMessagesCmd = &cli.Command{
 
 		toh := cctx.Uint64("toheight")
 
-		ts, err := loadTipSet(ctx, cctx, api)
+		ts, err := LoadTipSet(ctx, cctx, api)
 		if err != nil {
 			return err
 		}
 
-		msgs, err := api.StateListMessages(ctx, &types.Message{To: toa, From: froma}, ts, toh)
+		msgs, err := api.StateListMessages(ctx, &types.Message{To: toa, From: froma}, ts.Key(), abi.ChainEpoch(toh))
 		if err != nil {
 			return err
 		}
 
 		for _, c := range msgs {
+			if cctx.Bool("cids") {
+				fmt.Println(c.String())
+				continue
+			}
+
 			m, err := api.ChainGetMessage(ctx, c)
 			if err != nil {
 				return err
@@ -580,3 +800,944 @@ var stateListMessagesCmd = &cli.Command{
 		return nil
 	},
 }
+
+var stateComputeStateCmd = &cli.Command{
+	Name:  "compute-state",
+	Usage: "Perform state computations",
+	Flags: []cli.Flag{
+		&cli.Uint64Flag{
+			Name:  "vm-height",
+			Usage: "set the height that the vm will see",
+		},
+		&cli.BoolFlag{
+			Name:  "apply-mpool-messages",
+			Usage: "apply messages from the mempool to the computed state",
+		},
+		&cli.BoolFlag{
+			Name:  "show-trace",
+			Usage: "print out full execution trace for given tipset",
+		},
+		&cli.BoolFlag{
+			Name:  "html",
+			Usage: "generate html report",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		api, closer, err := GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+
+		ctx := ReqContext(cctx)
+
+		ts, err := LoadTipSet(ctx, cctx, api)
+		if err != nil {
+			return err
+		}
+
+		h := abi.ChainEpoch(cctx.Uint64("vm-height"))
+		if ts == nil {
+			head, err := api.ChainHead(ctx)
+			if err != nil {
+				return err
+			}
+			ts = head
+		}
+		if h == 0 {
+			h = ts.Height()
+		}
+
+		var msgs []*types.Message
+		if cctx.Bool("apply-mpool-messages") {
+			pmsgs, err := api.MpoolSelect(ctx, ts.Key(), 1)
+			if err != nil {
+				return err
+			}
+
+			for _, sm := range pmsgs {
+				msgs = append(msgs, &sm.Message)
+			}
+		}
+
+		stout, err := api.StateCompute(ctx, h, msgs, ts.Key())
+		if err != nil {
+			return err
+		}
+
+		if cctx.Bool("html") {
+			st, err := state.LoadStateTree(cbor.NewCborStore(apibstore.NewAPIBlockstore(api)), stout.Root)
+			if err != nil {
+				return xerrors.Errorf("loading state tree: %w", err)
+			}
+
+			codeCache := map[address.Address]cid.Cid{}
+			getCode := func(addr address.Address) (cid.Cid, error) {
+				if c, found := codeCache[addr]; found {
+					return c, nil
+				}
+
+				c, err := st.GetActor(addr)
+				if err != nil {
+					return cid.Cid{}, err
+				}
+
+				codeCache[addr] = c.Code
+				return c.Code, nil
+			}
+
+			return ComputeStateHTMLTempl(os.Stdout, ts, stout, getCode)
+		}
+
+		fmt.Println("computed state cid: ", stout.Root)
+		if cctx.Bool("show-trace") {
+			for _, ir := range stout.Trace {
+				fmt.Printf("%s\t%s\t%s\t%d\t%x\t%d\t%x\n", ir.Msg.From, ir.Msg.To, ir.Msg.Value, ir.Msg.Method, ir.Msg.Params, ir.MsgRct.ExitCode, ir.MsgRct.Return)
+				printInternalExecutions("\t", ir.ExecutionTrace.Subcalls)
+			}
+		}
+		return nil
+	},
+}
+
+func printInternalExecutions(prefix string, trace []types.ExecutionTrace) {
+	for _, im := range trace {
+		fmt.Printf("%s%s\t%s\t%s\t%d\t%x\t%d\t%x\n", prefix, im.Msg.From, im.Msg.To, im.Msg.Value, im.Msg.Method, im.Msg.Params, im.MsgRct.ExitCode, im.MsgRct.Return)
+		printInternalExecutions(prefix+"\t", im.Subcalls)
+	}
+}
+
+var compStateTemplate = `
+<html>
+ <head>
+  <meta charset="UTF-8">
+  <style>
+   html, body { font-family: monospace; }
+   a:link, a:visited { color: #004; }
+   pre { background: #ccc; }
+   small { color: #444; }
+   .call { color: #00a; }
+   .params { background: #dfd; }
+   .ret { background: #ddf; }
+   .error { color: red; }
+   .exit0 { color: green; }
+   .exec {
+    padding-left: 15px;
+    border-left: 2.5px solid;
+    margin-bottom: 45px;
+   }
+   .exec:hover {
+    background: #eee;
+   }
+   .slow-true-false { color: #660; }
+   .slow-true-true { color: #f80; }
+   .deemp { color: #444; }
+   table {
+    font-size: 12px;
+    border-collapse: collapse;
+   }
+   tr {
+   	border-top: 1px solid black;
+   	border-bottom: 1px solid black;
+   }
+   tr.sum { border-top: 2px solid black; }
+   tr:first-child { border-top: none; }
+   tr:last-child { border-bottom: none; }
+
+
+   .ellipsis-content,
+   .ellipsis-toggle input {
+     display: none;
+   }
+   .ellipsis-toggle {
+     cursor: pointer;
+   }
+   /**
+   Checked State
+   **/
+
+   .ellipsis-toggle input:checked + .ellipsis {
+     display: none;
+   }
+   .ellipsis-toggle input:checked ~ .ellipsis-content {
+     display: inline;
+	 background-color: #ddd;
+   }
+   hr {
+    border: none;
+    height: 1px;
+    background-color: black;
+	margin: 0;
+   }
+  </style>
+ </head>
+ <body>
+  <div>Tipset: <b>{{.TipSet.Key}}</b></div>
+  <div>Epoch: {{.TipSet.Height}}</div>
+  <div>State CID: <b>{{.Comp.Root}}</b></div>
+  <div>Calls</div>
+  {{range .Comp.Trace}}
+   {{template "message" (Call .ExecutionTrace false .Msg.Cid.String)}}
+  {{end}}
+ </body>
+</html>
+`
+
+var compStateMsg = `
+<div class="exec" id="{{.Hash}}">
+ {{$code := GetCode .Msg.To}}
+ <div>
+ <a href="#{{.Hash}}">
+  {{if not .Subcall}}
+   <h2 class="call">
+  {{else}}
+   <h4 class="call">
+  {{end}}
+   {{- CodeStr $code}}:{{GetMethod ($code) (.Msg.Method)}}
+  {{if not .Subcall}}
+   </h2>
+  {{else}}
+   </h4>
+  {{end}}
+ </a>
+ </div>
+
+ <div><b>{{.Msg.From}}</b> -&gt; <b>{{.Msg.To}}</b> ({{ToFil .Msg.Value}} FIL), M{{.Msg.Method}}</div>
+ {{if not .Subcall}}<div><small>Msg CID: {{.Msg.Cid}}</small></div>{{end}}
+ {{if gt (len .Msg.Params) 0}}
+  <div><pre class="params">{{JsonParams ($code) (.Msg.Method) (.Msg.Params) | html}}</pre></div>
+ {{end}}
+ <div><span class="slow-{{IsSlow .Duration}}-{{IsVerySlow .Duration}}">Took {{.Duration}}</span>, <span class="exit{{IntExit .MsgRct.ExitCode}}">Exit: <b>{{.MsgRct.ExitCode}}</b></span>{{if gt (len .MsgRct.Return) 0}}, Return{{end}}</div>
+
+ {{if gt (len .MsgRct.Return) 0}}
+  <div><pre class="ret">{{JsonReturn ($code) (.Msg.Method) (.MsgRct.Return) | html}}</pre></div>
+ {{end}}
+
+ {{if ne .MsgRct.ExitCode 0}}
+  <div class="error">Error: <pre>{{.Error}}</pre></div>
+ {{end}}
+
+<details>
+<summary>Gas Trace</summary>
+<table>
+ <tr><th>Name</th><th>Total/Compute/Storage</th><th>Time Taken</th><th>Location</th></tr>
+ {{define "virt" -}}
+ {{- if . -}}
+ <span class="deemp">+({{.}})</span>
+ {{- end -}}
+ {{- end}}
+
+ {{define "gasC" -}}
+ <td>{{.TotalGas}}{{template "virt" .TotalVirtualGas }}/{{.ComputeGas}}{{template "virt" .VirtualComputeGas}}/{{.StorageGas}}{{template "virt" .VirtualStorageGas}}</td>
+ {{- end}}
+
+ {{range .GasCharges}}
+ <tr><td>{{.Name}}{{if .Extra}}:{{.Extra}}{{end}}</td>
+ {{template "gasC" .}}
+ <td>{{.TimeTaken}}</td>
+  <td>
+   {{ $fImp := FirstImportant .Location }}
+   {{ if $fImp }}
+   <details>
+    <summary>{{ $fImp }}</summary><hr />
+	{{ $elipOn := false }}
+    {{ range $index, $ele := .Location -}}
+     {{- if $index }}<br />{{end -}}
+     {{- if .Show -}}
+	  {{ if $elipOn }}
+	   {{ $elipOn = false }}
+       </span></label>
+	  {{end}}
+
+      {{- if .Important }}<b>{{end -}}
+      {{- . -}}
+      {{if .Important }}</b>{{end}}
+     {{else}}
+	  {{ if not $elipOn }}
+	    {{ $elipOn = true }}
+        <label class="ellipsis-toggle"><input type="checkbox" /><span class="ellipsis">[…]<br /></span>
+		<span class="ellipsis-content">
+	  {{end}}
+      {{- "" -}}
+      {{- . -}}
+     {{end}}
+    {{end}}
+	{{ if $elipOn }}
+	  {{ $elipOn = false }}
+      </span></label>
+	{{end}}
+   </details>
+  {{end}}
+  </td></tr>
+  {{end}}
+  {{with SumGas .GasCharges}}
+  <tr class="sum"><td><b>Sum</b></td>
+  {{template "gasC" .}}
+  <td>{{.TimeTaken}}</td>
+  <td></td></tr>
+  {{end}}
+</table>
+</details>
+
+
+ {{if gt (len .Subcalls) 0}}
+  <div>Subcalls:</div>
+  {{$hash := .Hash}}
+  {{range .Subcalls}}
+   {{template "message" (Call . true (printf "%s-%s" $hash .Msg.Cid.String))}}
+  {{end}}
+ {{end}}
+</div>`
+
+type compStateHTMLIn struct {
+	TipSet *types.TipSet
+	Comp   *api.ComputeStateOutput
+}
+
+func ComputeStateHTMLTempl(w io.Writer, ts *types.TipSet, o *api.ComputeStateOutput, getCode func(addr address.Address) (cid.Cid, error)) error {
+	t, err := template.New("compute_state").Funcs(map[string]interface{}{
+		"GetCode":    getCode,
+		"GetMethod":  getMethod,
+		"ToFil":      toFil,
+		"JsonParams": jsonParams,
+		"JsonReturn": jsonReturn,
+		"IsSlow":     isSlow,
+		"IsVerySlow": isVerySlow,
+		"IntExit":    func(i exitcode.ExitCode) int64 { return int64(i) },
+		"SumGas":     sumGas,
+		"CodeStr":    codeStr,
+		"Call":       call,
+		"FirstImportant": func(locs []types.Loc) *types.Loc {
+			if len(locs) != 0 {
+				for _, l := range locs {
+					if l.Important() {
+						return &l
+					}
+				}
+				return &locs[0]
+			}
+			return nil
+		},
+	}).Parse(compStateTemplate)
+	if err != nil {
+		return err
+	}
+	t, err = t.New("message").Parse(compStateMsg)
+	if err != nil {
+		return err
+	}
+
+	return t.ExecuteTemplate(w, "compute_state", &compStateHTMLIn{
+		TipSet: ts,
+		Comp:   o,
+	})
+}
+
+type callMeta struct {
+	types.ExecutionTrace
+	Subcall bool
+	Hash    string
+}
+
+func call(e types.ExecutionTrace, subcall bool, hash string) callMeta {
+	return callMeta{
+		ExecutionTrace: e,
+		Subcall:        subcall,
+		Hash:           hash,
+	}
+}
+
+func codeStr(c cid.Cid) string {
+	cmh, err := multihash.Decode(c.Hash())
+	if err != nil {
+		panic(err)
+	}
+	return string(cmh.Digest)
+}
+
+func getMethod(code cid.Cid, method abi.MethodNum) string {
+	return stmgr.MethodsMap[code][method].Name
+}
+
+func toFil(f types.BigInt) types.FIL {
+	return types.FIL(f)
+}
+
+func isSlow(t time.Duration) bool {
+	return t > 10*time.Millisecond
+}
+
+func isVerySlow(t time.Duration) bool {
+	return t > 50*time.Millisecond
+}
+
+func sumGas(changes []*types.GasTrace) types.GasTrace {
+	var out types.GasTrace
+	for _, gc := range changes {
+		out.TotalGas += gc.TotalGas
+		out.ComputeGas += gc.ComputeGas
+		out.StorageGas += gc.StorageGas
+
+		out.TotalVirtualGas += gc.TotalVirtualGas
+		out.VirtualComputeGas += gc.VirtualComputeGas
+		out.VirtualStorageGas += gc.VirtualStorageGas
+	}
+
+	return out
+}
+
+func jsonParams(code cid.Cid, method abi.MethodNum, params []byte) (string, error) {
+	methodMeta, found := stmgr.MethodsMap[code][method]
+	if !found {
+		return "", fmt.Errorf("method %d not found on actor %s", method, code)
+	}
+	re := reflect.New(methodMeta.Params.Elem())
+	p := re.Interface().(cbg.CBORUnmarshaler)
+	if err := p.UnmarshalCBOR(bytes.NewReader(params)); err != nil {
+		return "", err
+	}
+
+	b, err := json.MarshalIndent(p, "", "  ")
+	return string(b), err
+}
+
+func jsonReturn(code cid.Cid, method abi.MethodNum, ret []byte) (string, error) {
+	methodMeta, found := stmgr.MethodsMap[code][method]
+	if !found {
+		return "", fmt.Errorf("method %d not found on actor %s", method, code)
+	}
+	re := reflect.New(methodMeta.Ret.Elem())
+	p := re.Interface().(cbg.CBORUnmarshaler)
+	if err := p.UnmarshalCBOR(bytes.NewReader(ret)); err != nil {
+		return "", err
+	}
+
+	b, err := json.MarshalIndent(p, "", "  ")
+	return string(b), err
+}
+
+var stateWaitMsgCmd = &cli.Command{
+	Name:      "wait-msg",
+	Usage:     "Wait for a message to appear on chain",
+	ArgsUsage: "[messageCid]",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:  "timeout",
+			Value: "10m",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		if !cctx.Args().Present() {
+			return fmt.Errorf("must specify message cid to wait for")
+		}
+
+		api, closer, err := GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+
+		ctx := ReqContext(cctx)
+
+		msg, err := cid.Decode(cctx.Args().First())
+		if err != nil {
+			return err
+		}
+
+		mw, err := api.StateWaitMsg(ctx, msg, build.MessageConfidence)
+		if err != nil {
+			return err
+		}
+
+		m, err := api.ChainGetMessage(ctx, msg)
+		if err != nil {
+			return err
+		}
+
+		fmt.Printf("message was executed in tipset: %s\n", mw.TipSet.Cids())
+		fmt.Printf("Exit Code: %d\n", mw.Receipt.ExitCode)
+		fmt.Printf("Gas Used: %d\n", mw.Receipt.GasUsed)
+		fmt.Printf("Return: %x\n", mw.Receipt.Return)
+		if err := printReceiptReturn(ctx, api, m, mw.Receipt); err != nil {
+			return err
+		}
+
+		return nil
+	},
+}
+
+func printReceiptReturn(ctx context.Context, api api.FullNode, m *types.Message, r types.MessageReceipt) error {
+	act, err := api.StateGetActor(ctx, m.To, types.EmptyTSK)
+	if err != nil {
+		return err
+	}
+
+	jret, err := jsonReturn(act.Code, m.Method, r.Return)
+	if err != nil {
+		return err
+	}
+
+	fmt.Println(jret)
+
+	return nil
+}
+
+var stateSearchMsgCmd = &cli.Command{
+	Name:      "search-msg",
+	Usage:     "Search to see whether a message has appeared on chain",
+	ArgsUsage: "[messageCid]",
+	Action: func(cctx *cli.Context) error {
+		if !cctx.Args().Present() {
+			return fmt.Errorf("must specify message cid to search for")
+		}
+
+		api, closer, err := GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+
+		ctx := ReqContext(cctx)
+
+		msg, err := cid.Decode(cctx.Args().First())
+		if err != nil {
+			return err
+		}
+
+		mw, err := api.StateSearchMsg(ctx, msg)
+		if err != nil {
+			return err
+		}
+
+		if mw != nil {
+			fmt.Printf("message was executed in tipset: %s", mw.TipSet.Cids())
+			fmt.Printf("\nExit Code: %d", mw.Receipt.ExitCode)
+			fmt.Printf("\nGas Used: %d", mw.Receipt.GasUsed)
+			fmt.Printf("\nReturn: %x", mw.Receipt.Return)
+		} else {
+			fmt.Print("message was not found on chain")
+		}
+		return nil
+	},
+}
+
+var stateMsgCostCmd = &cli.Command{
+	Name:      "msg-cost",
+	Usage:     "Get the detailed gas costs of a message",
+	ArgsUsage: "[messageCid]",
+	Action: func(cctx *cli.Context) error {
+		if !cctx.Args().Present() {
+			return fmt.Errorf("must specify message cid to get gas costs for")
+		}
+
+		api, closer, err := GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+
+		ctx := ReqContext(cctx)
+
+		msg, err := cid.Decode(cctx.Args().First())
+		if err != nil {
+			return err
+		}
+
+		tsk := types.EmptyTSK
+
+		ts, err := LoadTipSet(ctx, cctx, api)
+		if err != nil {
+			return err
+		}
+
+		if ts != nil {
+			tsk = ts.Key()
+		}
+
+		mgc, err := api.StateMsgGasCost(ctx, msg, tsk)
+		if err != nil {
+			return err
+		}
+
+		if mgc != nil {
+			fmt.Printf("Message CID: %s", mgc.Message)
+			fmt.Printf("\nGas Used: %d", mgc.GasUsed)
+			fmt.Printf("\nBase Fee Burn: %d", mgc.BaseFeeBurn)
+			fmt.Printf("\nOverestimation Burn: %d", mgc.OverEstimationBurn)
+			fmt.Printf("\nMiner Tip: %d", mgc.MinerTip)
+			fmt.Printf("\nRefund: %d", mgc.Refund)
+			fmt.Printf("\nTotal Cost: %d", mgc.TotalCost)
+			fmt.Printf("\nMiner Penalty: %d", mgc.MinerPenalty)
+		} else {
+			fmt.Print("message was not found on chain")
+		}
+		return nil
+	},
+}
+
+var stateCallCmd = &cli.Command{
+	Name:      "call",
+	Usage:     "Invoke a method on an actor locally",
+	ArgsUsage: "[toAddress methodId <param1 param2 ...> (optional)]",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:  "from",
+			Usage: "",
+			Value: builtin.SystemActorAddr.String(),
+		},
+		&cli.StringFlag{
+			Name:  "value",
+			Usage: "specify value field for invocation",
+			Value: "0",
+		},
+		&cli.StringFlag{
+			Name:  "ret",
+			Usage: "specify how to parse output (auto, raw, addr, big)",
+			Value: "auto",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		if cctx.Args().Len() < 2 {
+			return fmt.Errorf("must specify at least actor and method to invoke")
+		}
+
+		api, closer, err := GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+
+		ctx := ReqContext(cctx)
+
+		toa, err := address.NewFromString(cctx.Args().First())
+		if err != nil {
+			return fmt.Errorf("given 'to' address %q was invalid: %w", cctx.Args().First(), err)
+		}
+
+		froma, err := address.NewFromString(cctx.String("from"))
+		if err != nil {
+			return fmt.Errorf("given 'from' address %q was invalid: %w", cctx.String("from"), err)
+		}
+
+		ts, err := LoadTipSet(ctx, cctx, api)
+		if err != nil {
+			return err
+		}
+
+		method, err := strconv.ParseUint(cctx.Args().Get(1), 10, 64)
+		if err != nil {
+			return fmt.Errorf("must pass method as a number")
+		}
+
+		value, err := types.ParseFIL(cctx.String("value"))
+		if err != nil {
+			return fmt.Errorf("failed to parse 'value': %s", err)
+		}
+
+		act, err := api.StateGetActor(ctx, toa, ts.Key())
+		if err != nil {
+			return fmt.Errorf("failed to lookup target actor: %s", err)
+		}
+
+		params, err := parseParamsForMethod(act.Code, method, cctx.Args().Slice()[2:])
+		if err != nil {
+			return fmt.Errorf("failed to parse params: %s", err)
+		}
+
+		ret, err := api.StateCall(ctx, &types.Message{
+			From:   froma,
+			To:     toa,
+			Value:  types.BigInt(value),
+			Method: abi.MethodNum(method),
+			Params: params,
+		}, ts.Key())
+		if err != nil {
+			return fmt.Errorf("state call failed: %s", err)
+		}
+
+		if ret.MsgRct.ExitCode != 0 {
+			return fmt.Errorf("invocation failed (exit: %d, gasUsed: %d): %s", ret.MsgRct.ExitCode, ret.MsgRct.GasUsed, ret.Error)
+		}
+
+		s, err := formatOutput(cctx.String("ret"), ret.MsgRct.Return)
+		if err != nil {
+			return fmt.Errorf("failed to format output: %s", err)
+		}
+
+		fmt.Printf("gas used: %d\n", ret.MsgRct.GasUsed)
+		fmt.Printf("return: %s\n", s)
+
+		return nil
+	},
+}
+
+func formatOutput(t string, val []byte) (string, error) {
+	switch t {
+	case "raw", "hex":
+		return fmt.Sprintf("%x", val), nil
+	case "address", "addr", "a":
+		a, err := address.NewFromBytes(val)
+		if err != nil {
+			return "", err
+		}
+		return a.String(), nil
+	case "big", "int", "bigint":
+		bi := types.BigFromBytes(val)
+		return bi.String(), nil
+	case "fil":
+		bi := types.FIL(types.BigFromBytes(val))
+		return bi.String(), nil
+	case "pid", "peerid", "peer":
+		pid, err := peer.IDFromBytes(val)
+		if err != nil {
+			return "", err
+		}
+
+		return pid.Pretty(), nil
+	case "auto":
+		if len(val) == 0 {
+			return "", nil
+		}
+
+		a, err := address.NewFromBytes(val)
+		if err == nil {
+			return "address: " + a.String(), nil
+		}
+
+		pid, err := peer.IDFromBytes(val)
+		if err == nil {
+			return "peerID: " + pid.Pretty(), nil
+		}
+
+		bi := types.BigFromBytes(val)
+		return "bigint: " + bi.String(), nil
+	default:
+		return "", fmt.Errorf("unrecognized output type: %q", t)
+	}
+}
+
+func parseParamsForMethod(act cid.Cid, method uint64, args []string) ([]byte, error) {
+	if len(args) == 0 {
+		return nil, nil
+	}
+
+	var target runtime.Invokee
+	for _, actor := range exported.BuiltinActors() {
+		if actor.Code() == act {
+			target = actor
+		}
+	}
+	if target == nil {
+		return nil, fmt.Errorf("unknown actor %s", act)
+	}
+	methods := target.Exports()
+	if uint64(len(methods)) <= method || methods[method] == nil {
+		return nil, fmt.Errorf("unknown method %d for actor %s", method, act)
+	}
+
+	f := methods[method]
+
+	rf := reflect.TypeOf(f)
+	if rf.NumIn() != 2 {
+		return nil, fmt.Errorf("expected referenced method to have three arguments")
+	}
+
+	paramObj := rf.In(1).Elem()
+	if paramObj.NumField() != len(args) {
+		return nil, fmt.Errorf("not enough arguments given to call that method (expecting %d)", paramObj.NumField())
+	}
+
+	p := reflect.New(paramObj)
+	for i := 0; i < len(args); i++ {
+		switch paramObj.Field(i).Type {
+		case reflect.TypeOf(address.Address{}):
+			a, err := address.NewFromString(args[i])
+			if err != nil {
+				return nil, fmt.Errorf("failed to parse address: %s", err)
+			}
+			p.Elem().Field(i).Set(reflect.ValueOf(a))
+		case reflect.TypeOf(uint64(0)):
+			val, err := strconv.ParseUint(args[i], 10, 64)
+			if err != nil {
+				return nil, err
+			}
+			p.Elem().Field(i).Set(reflect.ValueOf(val))
+		case reflect.TypeOf(abi.ChainEpoch(0)):
+			val, err := strconv.ParseInt(args[i], 10, 64)
+			if err != nil {
+				return nil, err
+			}
+			p.Elem().Field(i).Set(reflect.ValueOf(abi.ChainEpoch(val)))
+		case reflect.TypeOf(big.Int{}):
+			val, err := big.FromString(args[i])
+			if err != nil {
+				return nil, err
+			}
+			p.Elem().Field(i).Set(reflect.ValueOf(val))
+		case reflect.TypeOf(peer.ID("")):
+			pid, err := peer.Decode(args[i])
+			if err != nil {
+				return nil, fmt.Errorf("failed to parse peer ID: %s", err)
+			}
+			p.Elem().Field(i).Set(reflect.ValueOf(pid))
+		default:
+			return nil, fmt.Errorf("unsupported type for call (TODO): %s", paramObj.Field(i).Type)
+		}
+	}
+
+	m := p.Interface().(cbg.CBORMarshaler)
+	buf := new(bytes.Buffer)
+	if err := m.MarshalCBOR(buf); err != nil {
+		return nil, fmt.Errorf("failed to marshal param object: %s", err)
+	}
+	return buf.Bytes(), nil
+}
+
+var stateCircSupplyCmd = &cli.Command{
+	Name:  "circulating-supply",
+	Usage: "Get the current circulating supply of filecoin",
+	Action: func(cctx *cli.Context) error {
+		api, closer, err := GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+
+		ctx := ReqContext(cctx)
+
+		ts, err := LoadTipSet(ctx, cctx, api)
+		if err != nil {
+			return err
+		}
+
+		circ, err := api.StateCirculatingSupply(ctx, ts.Key())
+		if err != nil {
+			return err
+		}
+
+		fmt.Println("Circulating supply: ", types.FIL(circ.FilCirculating))
+		fmt.Println("Mined: ", types.FIL(circ.FilMined))
+		fmt.Println("Vested: ", types.FIL(circ.FilVested))
+		fmt.Println("Burnt: ", types.FIL(circ.FilBurnt))
+		fmt.Println("Locked: ", types.FIL(circ.FilLocked))
+
+		return nil
+	},
+}
+
+var stateSectorCmd = &cli.Command{
+	Name:      "sector",
+	Usage:     "Get miner sector info",
+	ArgsUsage: "[miner address] [sector number]",
+	Action: func(cctx *cli.Context) error {
+		api, closer, err := GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+
+		ctx := ReqContext(cctx)
+
+		if cctx.Args().Len() != 2 {
+			return xerrors.Errorf("expected 2 params")
+		}
+
+		ts, err := LoadTipSet(ctx, cctx, api)
+		if err != nil {
+			return err
+		}
+
+		if ts == nil {
+			ts, err = api.ChainHead(ctx)
+			if err != nil {
+				return err
+			}
+		}
+
+		maddr, err := address.NewFromString(cctx.Args().Get(0))
+		if err != nil {
+			return err
+		}
+
+		sid, err := strconv.ParseInt(cctx.Args().Get(1), 10, 64)
+		if err != nil {
+			return err
+		}
+
+		si, err := api.StateSectorGetInfo(ctx, maddr, abi.SectorNumber(sid), ts.Key())
+		if err != nil {
+			return err
+		}
+
+		fmt.Println("SectorNumber: ", si.SectorNumber)
+		fmt.Println("SealProof: ", si.SealProof)
+		fmt.Println("SealedCID: ", si.SealedCID)
+		fmt.Println("DealIDs: ", si.DealIDs)
+		fmt.Println()
+		fmt.Println("Activation: ", EpochTime(ts.Height(), si.Activation))
+		fmt.Println("Expiration: ", EpochTime(ts.Height(), si.Expiration))
+		fmt.Println()
+		fmt.Println("DealWeight: ", si.DealWeight)
+		fmt.Println("VerifiedDealWeight: ", si.VerifiedDealWeight)
+		fmt.Println("InitialPledge: ", types.FIL(si.InitialPledge))
+		fmt.Println("ExpectedDayReward: ", types.FIL(si.ExpectedDayReward))
+		fmt.Println("ExpectedStoragePledge: ", types.FIL(si.ExpectedStoragePledge))
+		fmt.Println()
+
+		sp, err := api.StateSectorPartition(ctx, maddr, abi.SectorNumber(sid), ts.Key())
+		if err != nil {
+			return err
+		}
+
+		fmt.Println("Deadline: ", sp.Deadline)
+		fmt.Println("Partition: ", sp.Partition)
+
+		return nil
+	},
+}
+
+var stateMarketCmd = &cli.Command{
+	Name:  "market",
+	Usage: "Inspect the storage market actor",
+	Subcommands: []*cli.Command{
+		stateMarketBalanceCmd,
+	},
+}
+
+var stateMarketBalanceCmd = &cli.Command{
+	Name:  "balance",
+	Usage: "Get the market balance (locked and escrowed) for a given account",
+	Action: func(cctx *cli.Context) error {
+		if !cctx.Args().Present() {
+			return ShowHelp(cctx, fmt.Errorf("must specify address to print market balance for"))
+		}
+
+		api, closer, err := GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+
+		ctx := ReqContext(cctx)
+
+		ts, err := LoadTipSet(ctx, cctx, api)
+		if err != nil {
+			return err
+		}
+
+		addr, err := address.NewFromString(cctx.Args().First())
+		if err != nil {
+			return err
+		}
+
+		balance, err := api.StateMarketBalance(ctx, addr, ts.Key())
+		if err != nil {
+			return err
+		}
+
+		fmt.Printf("Escrow: %s\n", types.FIL(balance.Escrow))
+		fmt.Printf("Locked: %s\n", types.FIL(balance.Locked))
+
+		return nil
+	},
+}
diff --git a/cli/sync.go b/cli/sync.go
index d3d425967..bee87cf70 100644
--- a/cli/sync.go
+++ b/cli/sync.go
@@ -5,12 +5,14 @@ import (
 	"fmt"
 	"time"
 
+	"github.com/filecoin-project/lotus/chain/types"
+
+	"github.com/filecoin-project/go-state-types/abi"
 	cid "github.com/ipfs/go-cid"
-	"gopkg.in/urfave/cli.v2"
+	"github.com/urfave/cli/v2"
 
 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/build"
-	"github.com/filecoin-project/lotus/chain"
 )
 
 var syncCmd = &cli.Command{
@@ -20,6 +22,9 @@ var syncCmd = &cli.Command{
 		syncStatusCmd,
 		syncWaitCmd,
 		syncMarkBadCmd,
+		syncUnmarkBadCmd,
+		syncCheckBadCmd,
+		syncCheckpointCmd,
 	},
 }
 
@@ -44,7 +49,7 @@ var syncStatusCmd = &cli.Command{
 			fmt.Printf("worker %d:\n", i)
 			var base, target []cid.Cid
 			var heightDiff int64
-			var theight uint64
+			var theight abi.ChainEpoch
 			if ss.Base != nil {
 				base = ss.Base.Cids()
 				heightDiff = int64(ss.Base.Height())
@@ -59,7 +64,7 @@ var syncStatusCmd = &cli.Command{
 			fmt.Printf("\tBase:\t%s\n", base)
 			fmt.Printf("\tTarget:\t%s (%d)\n", target, theight)
 			fmt.Printf("\tHeight diff:\t%d\n", heightDiff)
-			fmt.Printf("\tStage: %s\n", chain.SyncStageString(ss.Stage))
+			fmt.Printf("\tStage: %s\n", ss.Stage)
 			fmt.Printf("\tHeight: %d\n", ss.Height)
 			if ss.End.IsZero() {
 				if !ss.Start.IsZero() {
@@ -92,8 +97,9 @@ var syncWaitCmd = &cli.Command{
 }
 
 var syncMarkBadCmd = &cli.Command{
-	Name:  "mark-bad",
-	Usage: "Mark the given block as bad, will prevent syncing to a chain that contains it",
+	Name:      "mark-bad",
+	Usage:     "Mark the given block as bad, will prevent syncing to a chain that contains it",
+	ArgsUsage: "[blockCid]",
 	Action: func(cctx *cli.Context) error {
 		napi, closer, err := GetFullNodeAPI(cctx)
 		if err != nil {
@@ -115,7 +121,120 @@ var syncMarkBadCmd = &cli.Command{
 	},
 }
 
+var syncUnmarkBadCmd = &cli.Command{
+	Name:      "unmark-bad",
+	Usage:     "Unmark the given block as bad, makes it possible to sync to a chain containing it",
+	ArgsUsage: "[blockCid]",
+	Action: func(cctx *cli.Context) error {
+		napi, closer, err := GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+		ctx := ReqContext(cctx)
+
+		if !cctx.Args().Present() {
+			return fmt.Errorf("must specify block cid to unmark")
+		}
+
+		bcid, err := cid.Decode(cctx.Args().First())
+		if err != nil {
+			return fmt.Errorf("failed to decode input as a cid: %s", err)
+		}
+
+		return napi.SyncUnmarkBad(ctx, bcid)
+	},
+}
+
+var syncCheckBadCmd = &cli.Command{
+	Name:      "check-bad",
+	Usage:     "check if the given block was marked bad, and for what reason",
+	ArgsUsage: "[blockCid]",
+	Action: func(cctx *cli.Context) error {
+		napi, closer, err := GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+		ctx := ReqContext(cctx)
+
+		if !cctx.Args().Present() {
+			return fmt.Errorf("must specify block cid to check")
+		}
+
+		bcid, err := cid.Decode(cctx.Args().First())
+		if err != nil {
+			return fmt.Errorf("failed to decode input as a cid: %s", err)
+		}
+
+		reason, err := napi.SyncCheckBad(ctx, bcid)
+		if err != nil {
+			return err
+		}
+
+		if reason == "" {
+			fmt.Println("block was not marked as bad")
+			return nil
+		}
+
+		fmt.Println(reason)
+		return nil
+	},
+}
+
+var syncCheckpointCmd = &cli.Command{
+	Name:      "checkpoint",
+	Usage:     "mark a certain tipset as checkpointed; the node will never fork away from this tipset",
+	ArgsUsage: "[tipsetKey]",
+	Flags: []cli.Flag{
+		&cli.Uint64Flag{
+			Name:  "epoch",
+			Usage: "checkpoint the tipset at the given epoch",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		napi, closer, err := GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+		ctx := ReqContext(cctx)
+
+		var ts *types.TipSet
+
+		if cctx.IsSet("epoch") {
+			ts, err = napi.ChainGetTipSetByHeight(ctx, abi.ChainEpoch(cctx.Uint64("epoch")), types.EmptyTSK)
+		}
+		if ts == nil {
+			ts, err = parseTipSet(ctx, napi, cctx.Args().Slice())
+		}
+		if err != nil {
+			return err
+		}
+
+		if ts == nil {
+			return fmt.Errorf("must pass cids for tipset to set as head, or specify epoch flag")
+		}
+
+		if err := napi.SyncCheckpoint(ctx, ts.Key()); err != nil {
+			return err
+		}
+
+		return nil
+	},
+}
+
 func SyncWait(ctx context.Context, napi api.FullNode) error {
+	tick := time.Second / 4
+
+	lastLines := 0
+	ticker := time.NewTicker(tick)
+	defer ticker.Stop()
+
+	samples := 8
+	i := 0
+	var app, lastApp uint64
+
 	for {
 		state, err := napi.SyncState(ctx)
 		if err != nil {
@@ -140,14 +259,43 @@ func SyncWait(ctx context.Context, napi api.FullNode) error {
 
 		ss := state.ActiveSyncs[working]
 
+		var baseHeight abi.ChainEpoch
 		var target []cid.Cid
+		var theight abi.ChainEpoch
+		var heightDiff int64
+
+		if ss.Base != nil {
+			baseHeight = ss.Base.Height()
+			heightDiff = int64(ss.Base.Height())
+		}
 		if ss.Target != nil {
 			target = ss.Target.Cids()
+			theight = ss.Target.Height()
+			heightDiff = int64(ss.Target.Height()) - heightDiff
+		} else {
+			heightDiff = 0
 		}
 
-		fmt.Printf("\r\x1b[2KWorker %d: Target: %s\tState: %s\tHeight: %d", working, target, chain.SyncStageString(ss.Stage), ss.Height)
+		for i := 0; i < lastLines; i++ {
+			fmt.Print("\r\x1b[2K\x1b[A")
+		}
 
-		if time.Now().Unix()-int64(head.MinTimestamp()) < build.BlockDelay {
+		fmt.Printf("Worker: %d; Base: %d; Target: %d (diff: %d)\n", working, baseHeight, theight, heightDiff)
+		fmt.Printf("State: %s; Current Epoch: %d; Todo: %d\n", ss.Stage, ss.Height, theight-ss.Height)
+		lastLines = 2
+
+		if i%samples == 0 {
+			lastApp = app
+			app = state.VMApplied
+		}
+		if i > 0 {
+			fmt.Printf("Validated %d messages (%d per second)\n", state.VMApplied, (app-lastApp)*uint64(time.Second/tick)/uint64(samples))
+			lastLines++
+		}
+
+		_ = target // todo: maybe print? (creates a bunch of line wrapping issues with most tipsets)
+
+		if time.Now().Unix()-int64(head.MinTimestamp()) < int64(build.BlockDelaySecs) {
 			fmt.Println("\nDone!")
 			return nil
 		}
@@ -156,7 +304,9 @@ func SyncWait(ctx context.Context, napi api.FullNode) error {
 		case <-ctx.Done():
 			fmt.Println("\nExit by user")
 			return nil
-		case <-time.After(1 * time.Second):
+		case <-ticker.C:
 		}
+
+		i++
 	}
 }
diff --git a/cli/util.go b/cli/util.go
new file mode 100644
index 000000000..762cdb565
--- /dev/null
+++ b/cli/util.go
@@ -0,0 +1,47 @@
+package cli
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/ipfs/go-cid"
+
+	"github.com/filecoin-project/go-state-types/abi"
+
+	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/types"
+)
+
+func parseTipSet(ctx context.Context, api api.FullNode, vals []string) (*types.TipSet, error) {
+	var headers []*types.BlockHeader
+	for _, c := range vals {
+		blkc, err := cid.Decode(c)
+		if err != nil {
+			return nil, err
+		}
+
+		bh, err := api.ChainGetBlock(ctx, blkc)
+		if err != nil {
+			return nil, err
+		}
+
+		headers = append(headers, bh)
+	}
+
+	return types.NewTipSet(headers)
+}
+
+func EpochTime(curr, e abi.ChainEpoch) string {
+	switch {
+	case curr > e:
+		return fmt.Sprintf("%d (%s ago)", e, time.Second*time.Duration(int64(build.BlockDelaySecs)*int64(curr-e)))
+	case curr == e:
+		return fmt.Sprintf("%d (now)", e)
+	case curr < e:
+		return fmt.Sprintf("%d (in %s)", e, time.Second*time.Duration(int64(build.BlockDelaySecs)*int64(e-curr)))
+	}
+
+	panic("math broke")
+}
diff --git a/cli/version.go b/cli/version.go
index cf4ad2932..1cdc9c561 100644
--- a/cli/version.go
+++ b/cli/version.go
@@ -3,10 +3,10 @@ package cli
 import (
 	"fmt"
 
-	"gopkg.in/urfave/cli.v2"
+	"github.com/urfave/cli/v2"
 )
 
-var versionCmd = &cli.Command{
+var VersionCmd = &cli.Command{
 	Name:  "version",
 	Usage: "Print version",
 	Action: func(cctx *cli.Context) error {
@@ -23,7 +23,9 @@ var versionCmd = &cli.Command{
 		if err != nil {
 			return err
 		}
-		fmt.Println(v)
+		fmt.Println("Daemon: ", v)
+
+		fmt.Print("Local: ")
 		cli.VersionPrinter(cctx)
 		return nil
 	},
diff --git a/cli/wait.go b/cli/wait.go
new file mode 100644
index 000000000..ca8cdce3f
--- /dev/null
+++ b/cli/wait.go
@@ -0,0 +1,34 @@
+package cli
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/urfave/cli/v2"
+)
+
+var waitApiCmd = &cli.Command{
+	Name:  "wait-api",
+	Usage: "Wait for lotus api to come online",
+	Action: func(cctx *cli.Context) error {
+		for i := 0; i < 30; i++ {
+			api, closer, err := GetFullNodeAPI(cctx)
+			if err != nil {
+				fmt.Printf("Not online yet... (%s)\n", err)
+				time.Sleep(time.Second)
+				continue
+			}
+			defer closer()
+
+			ctx := ReqContext(cctx)
+
+			_, err = api.ID(ctx)
+			if err != nil {
+				return err
+			}
+
+			return nil
+		}
+		return fmt.Errorf("timed out waiting for api to come online")
+	},
+}
diff --git a/cli/wallet.go b/cli/wallet.go
index 1f950adb8..27993a1ba 100644
--- a/cli/wallet.go
+++ b/cli/wallet.go
@@ -1,6 +1,7 @@
 package cli
 
 import (
+	"bufio"
 	"encoding/hex"
 	"encoding/json"
 	"fmt"
@@ -9,8 +10,12 @@ import (
 	"strings"
 
 	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/crypto"
 	types "github.com/filecoin-project/lotus/chain/types"
-	"gopkg.in/urfave/cli.v2"
+	"github.com/filecoin-project/lotus/chain/wallet"
+	"golang.org/x/xerrors"
+
+	"github.com/urfave/cli/v2"
 )
 
 var walletCmd = &cli.Command{
@@ -24,13 +29,16 @@ var walletCmd = &cli.Command{
 		walletImport,
 		walletGetDefault,
 		walletSetDefault,
+		walletSign,
+		walletVerify,
+		walletDelete,
 	},
 }
 
 var walletNew = &cli.Command{
 	Name:      "new",
 	Usage:     "Generate a new key of the given type",
-	ArgsUsage: "[bls|secp256k1]",
+	ArgsUsage: "[bls|secp256k1 (default secp256k1)]",
 	Action: func(cctx *cli.Context) error {
 		api, closer, err := GetFullNodeAPI(cctx)
 		if err != nil {
@@ -41,10 +49,10 @@ var walletNew = &cli.Command{
 
 		t := cctx.Args().First()
 		if t == "" {
-			t = "bls"
+			t = "secp256k1"
 		}
 
-		nk, err := api.WalletNew(ctx, t)
+		nk, err := api.WalletNew(ctx, wallet.ActSigType(t))
 		if err != nil {
 			return err
 		}
@@ -81,7 +89,7 @@ var walletList = &cli.Command{
 var walletBalance = &cli.Command{
 	Name:      "balance",
 	Usage:     "Get account balance",
-	ArgsUsage: "[account address]",
+	ArgsUsage: "[address]",
 	Action: func(cctx *cli.Context) error {
 		api, closer, err := GetFullNodeAPI(cctx)
 		if err != nil {
@@ -105,7 +113,12 @@ var walletBalance = &cli.Command{
 			return err
 		}
 
-		fmt.Printf("%s\n", types.FIL(balance))
+		if balance.Equals(types.NewInt(0)) {
+			fmt.Printf("%s (warning: may display 0 if chain sync in progress)\n", types.FIL(balance))
+		} else {
+			fmt.Printf("%s\n", types.FIL(balance))
+		}
+
 		return nil
 	},
 }
@@ -132,8 +145,9 @@ var walletGetDefault = &cli.Command{
 }
 
 var walletSetDefault = &cli.Command{
-	Name:  "set-default",
-	Usage: "Set default wallet address",
+	Name:      "set-default",
+	Usage:     "Set default wallet address",
+	ArgsUsage: "[address]",
 	Action: func(cctx *cli.Context) error {
 		api, closer, err := GetFullNodeAPI(cctx)
 		if err != nil {
@@ -156,8 +170,9 @@ var walletSetDefault = &cli.Command{
 }
 
 var walletExport = &cli.Command{
-	Name:  "export",
-	Usage: "export keys",
+	Name:      "export",
+	Usage:     "export keys",
+	ArgsUsage: "[address]",
 	Action: func(cctx *cli.Context) error {
 		api, closer, err := GetFullNodeAPI(cctx)
 		if err != nil {
@@ -191,8 +206,20 @@ var walletExport = &cli.Command{
 }
 
 var walletImport = &cli.Command{
-	Name:  "import",
-	Usage: "import keys",
+	Name:      "import",
+	Usage:     "import keys",
+	ArgsUsage: "[<path> (optional, will read from stdin if omitted)]",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:  "format",
+			Usage: "specify input format for key",
+			Value: "hex-lotus",
+		},
+		&cli.BoolFlag{
+			Name:  "as-default",
+			Usage: "import the given key as your new default key",
+		},
+	},
 	Action: func(cctx *cli.Context) error {
 		api, closer, err := GetFullNodeAPI(cctx)
 		if err != nil {
@@ -201,29 +228,62 @@ var walletImport = &cli.Command{
 		defer closer()
 		ctx := ReqContext(cctx)
 
-		var hexdata []byte
+		var inpdata []byte
 		if !cctx.Args().Present() || cctx.Args().First() == "-" {
-			indata, err := ioutil.ReadAll(os.Stdin)
+			reader := bufio.NewReader(os.Stdin)
+			fmt.Print("Enter private key: ")
+			indata, err := reader.ReadBytes('\n')
 			if err != nil {
 				return err
 			}
-			hexdata = indata
+			inpdata = indata
 
 		} else {
 			fdata, err := ioutil.ReadFile(cctx.Args().First())
 			if err != nil {
 				return err
 			}
-			hexdata = fdata
-		}
-		data, err := hex.DecodeString(strings.TrimSpace(string(hexdata)))
-		if err != nil {
-			return err
+			inpdata = fdata
 		}
 
 		var ki types.KeyInfo
-		if err := json.Unmarshal(data, &ki); err != nil {
-			return err
+		switch cctx.String("format") {
+		case "hex-lotus":
+			data, err := hex.DecodeString(strings.TrimSpace(string(inpdata)))
+			if err != nil {
+				return err
+			}
+
+			if err := json.Unmarshal(data, &ki); err != nil {
+				return err
+			}
+		case "json-lotus":
+			if err := json.Unmarshal(inpdata, &ki); err != nil {
+				return err
+			}
+		case "gfc-json":
+			var f struct {
+				KeyInfo []struct {
+					PrivateKey []byte
+					SigType    int
+				}
+			}
+			if err := json.Unmarshal(inpdata, &f); err != nil {
+				return xerrors.Errorf("failed to parse go-filecoin key: %s", err)
+			}
+
+			gk := f.KeyInfo[0]
+			ki.PrivateKey = gk.PrivateKey
+			switch gk.SigType {
+			case 1:
+				ki.Type = wallet.KTSecp256k1
+			case 2:
+				ki.Type = wallet.KTBLS
+			default:
+				return fmt.Errorf("unrecognized key type: %d", gk.SigType)
+			}
+		default:
+			return fmt.Errorf("unrecognized format: %s", cctx.String("format"))
 		}
 
 		addr, err := api.WalletImport(ctx, &ki)
@@ -231,7 +291,131 @@ var walletImport = &cli.Command{
 			return err
 		}
 
+		if cctx.Bool("as-default") {
+			if err := api.WalletSetDefault(ctx, addr); err != nil {
+				return fmt.Errorf("failed to set default key: %w", err)
+			}
+		}
+
 		fmt.Printf("imported key %s successfully!\n", addr)
 		return nil
 	},
 }
+
+var walletSign = &cli.Command{
+	Name:      "sign",
+	Usage:     "sign a message",
+	ArgsUsage: "<signing address> <hexMessage>",
+	Action: func(cctx *cli.Context) error {
+		api, closer, err := GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+		ctx := ReqContext(cctx)
+
+		if !cctx.Args().Present() || cctx.NArg() != 2 {
+			return fmt.Errorf("must specify signing address and message to sign")
+		}
+
+		addr, err := address.NewFromString(cctx.Args().First())
+
+		if err != nil {
+			return err
+		}
+
+		msg, err := hex.DecodeString(cctx.Args().Get(1))
+
+		if err != nil {
+			return err
+		}
+
+		sig, err := api.WalletSign(ctx, addr, msg)
+
+		if err != nil {
+			return err
+		}
+
+		sigBytes := append([]byte{byte(sig.Type)}, sig.Data...)
+
+		fmt.Println(hex.EncodeToString(sigBytes))
+		return nil
+	},
+}
+
+var walletVerify = &cli.Command{
+	Name:      "verify",
+	Usage:     "verify the signature of a message",
+	ArgsUsage: "<signing address> <hexMessage> <signature>",
+	Action: func(cctx *cli.Context) error {
+		api, closer, err := GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+		ctx := ReqContext(cctx)
+
+		if !cctx.Args().Present() || cctx.NArg() != 3 {
+			return fmt.Errorf("must specify signing address, message, and signature to verify")
+		}
+
+		addr, err := address.NewFromString(cctx.Args().First())
+
+		if err != nil {
+			return err
+		}
+
+		msg, err := hex.DecodeString(cctx.Args().Get(1))
+
+		if err != nil {
+			return err
+		}
+
+		sigBytes, err := hex.DecodeString(cctx.Args().Get(2))
+
+		if err != nil {
+			return err
+		}
+
+		var sig crypto.Signature
+		if err := sig.UnmarshalBinary(sigBytes); err != nil {
+			return err
+		}
+
+		ok, err := api.WalletVerify(ctx, addr, msg, &sig)
+		if err != nil {
+			return err
+		}
+		if ok {
+			fmt.Println("valid")
+			return nil
+		}
+		fmt.Println("invalid")
+		return NewCliError("CLI Verify called with invalid signature")
+	},
+}
+
+var walletDelete = &cli.Command{
+	Name:      "delete",
+	Usage:     "Delete an account from the wallet",
+	ArgsUsage: "<address> ",
+	Action: func(cctx *cli.Context) error {
+		api, closer, err := GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+		ctx := ReqContext(cctx)
+
+		if !cctx.Args().Present() || cctx.NArg() != 1 {
+			return fmt.Errorf("must specify address to delete")
+		}
+
+		addr, err := address.NewFromString(cctx.Args().First())
+		if err != nil {
+			return err
+		}
+
+		return api.WalletDelete(ctx, addr)
+	},
+}
diff --git a/cmd/chain-noise/main.go b/cmd/chain-noise/main.go
index ae187b116..7b9824016 100644
--- a/cmd/chain-noise/main.go
+++ b/cmd/chain-noise/main.go
@@ -7,12 +7,15 @@ import (
 	"os"
 	"time"
 
+	"github.com/filecoin-project/go-state-types/crypto"
+
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain/types"
 	lcli "github.com/filecoin-project/lotus/cli"
 
-	"gopkg.in/urfave/cli.v2"
+	"github.com/urfave/cli/v2"
 )
 
 func main() {
@@ -51,15 +54,14 @@ var runCmd = &cli.Command{
 		defer closer()
 		ctx := lcli.ReqContext(cctx)
 
-		sendSmallFundsTxs(ctx, api, addr, 5)
-		return nil
+		return sendSmallFundsTxs(ctx, api, addr, 5)
 	},
 }
 
 func sendSmallFundsTxs(ctx context.Context, api api.FullNode, from address.Address, rate int) error {
 	var sendSet []address.Address
 	for i := 0; i < 20; i++ {
-		naddr, err := api.WalletNew(ctx, "bls")
+		naddr, err := api.WalletNew(ctx, crypto.SigTypeSecp256k1)
 		if err != nil {
 			return err
 		}
@@ -67,19 +69,17 @@ func sendSmallFundsTxs(ctx context.Context, api api.FullNode, from address.Addre
 		sendSet = append(sendSet, naddr)
 	}
 
-	tick := time.NewTicker(time.Second / time.Duration(rate))
+	tick := build.Clock.Ticker(time.Second / time.Duration(rate))
 	for {
 		select {
 		case <-tick.C:
 			msg := &types.Message{
-				From:     from,
-				To:       sendSet[rand.Intn(20)],
-				Value:    types.NewInt(1),
-				GasLimit: types.NewInt(100000),
-				GasPrice: types.NewInt(0),
+				From:  from,
+				To:    sendSet[rand.Intn(20)],
+				Value: types.NewInt(1),
 			}
 
-			smsg, err := api.MpoolPushMessage(ctx, msg)
+			smsg, err := api.MpoolPushMessage(ctx, msg, nil)
 			if err != nil {
 				return err
 			}
@@ -88,6 +88,4 @@ func sendSmallFundsTxs(ctx context.Context, api api.FullNode, from address.Addre
 			return nil
 		}
 	}
-
-	return nil
 }
diff --git a/cmd/lotus-bench/import.go b/cmd/lotus-bench/import.go
new file mode 100644
index 000000000..f2845ba20
--- /dev/null
+++ b/cmd/lotus-bench/import.go
@@ -0,0 +1,641 @@
+package main
+
+import (
+	"bufio"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"math"
+	"net/http"
+	_ "net/http/pprof"
+	"os"
+	"runtime"
+	"runtime/pprof"
+	"sort"
+	"time"
+
+	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/chain/stmgr"
+	"github.com/filecoin-project/lotus/chain/store"
+	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/chain/vm"
+	"github.com/filecoin-project/lotus/lib/blockstore"
+	_ "github.com/filecoin-project/lotus/lib/sigs/bls"
+	_ "github.com/filecoin-project/lotus/lib/sigs/secp"
+
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper"
+
+	"github.com/ipfs/go-datastore"
+	badger "github.com/ipfs/go-ds-badger2"
+	"github.com/urfave/cli/v2"
+	"golang.org/x/xerrors"
+)
+
+type TipSetExec struct {
+	TipSet   types.TipSetKey
+	Trace    []*api.InvocResult
+	Duration time.Duration
+}
+
+var importBenchCmd = &cli.Command{
+	Name:  "import",
+	Usage: "benchmark chain import and validation",
+	Subcommands: []*cli.Command{
+		importAnalyzeCmd,
+	},
+	Flags: []cli.Flag{
+		&cli.Int64Flag{
+			Name:  "height",
+			Usage: "halt validation after given height",
+		},
+		&cli.IntFlag{
+			Name:  "batch-seal-verify-threads",
+			Usage: "set the parallelism factor for batch seal verification",
+			Value: runtime.NumCPU(),
+		},
+		&cli.StringFlag{
+			Name:  "repodir",
+			Usage: "set the repo directory for the lotus bench run (defaults to /tmp)",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		vm.BatchSealVerifyParallelism = cctx.Int("batch-seal-verify-threads")
+		if !cctx.Args().Present() {
+			fmt.Println("must pass car file of chain to benchmark importing")
+			return nil
+		}
+
+		cfi, err := os.Open(cctx.Args().First())
+		if err != nil {
+			return err
+		}
+		defer cfi.Close() //nolint:errcheck // read only file
+
+		var tdir string
+		if rdir := cctx.String("repodir"); rdir != "" {
+			tdir = rdir
+		} else {
+			tmp, err := ioutil.TempDir("", "lotus-import-bench")
+			if err != nil {
+				return err
+			}
+			tdir = tmp
+		}
+
+		bds, err := badger.NewDatastore(tdir, nil)
+		if err != nil {
+			return err
+		}
+		bs := blockstore.NewBlockstore(bds)
+		cbs, err := blockstore.CachedBlockstore(context.TODO(), bs, blockstore.DefaultCacheOpts())
+		if err != nil {
+			return err
+		}
+		bs = cbs
+		ds := datastore.NewMapDatastore()
+		cs := store.NewChainStore(bs, ds, vm.Syscalls(ffiwrapper.ProofVerifier))
+		stm := stmgr.NewStateManager(cs)
+
+		prof, err := os.Create("import-bench.prof")
+		if err != nil {
+			return err
+		}
+		defer prof.Close() //nolint:errcheck
+
+		if err := pprof.StartCPUProfile(prof); err != nil {
+			return err
+		}
+
+		head, err := cs.Import(cfi)
+		if err != nil {
+			return err
+		}
+
+		gb, err := cs.GetTipsetByHeight(context.TODO(), 0, head, true)
+		if err != nil {
+			return err
+		}
+
+		err = cs.SetGenesis(gb.Blocks()[0])
+		if err != nil {
+			return err
+		}
+
+		if h := cctx.Int64("height"); h != 0 {
+			tsh, err := cs.GetTipsetByHeight(context.TODO(), abi.ChainEpoch(h), head, true)
+			if err != nil {
+				return err
+			}
+			head = tsh
+		}
+
+		ts := head
+		tschain := []*types.TipSet{ts}
+		for ts.Height() != 0 {
+			next, err := cs.LoadTipSet(ts.Parents())
+			if err != nil {
+				return err
+			}
+
+			tschain = append(tschain, next)
+			ts = next
+		}
+
+		ibj, err := os.Create("import-bench.json")
+		if err != nil {
+			return err
+		}
+		defer ibj.Close() //nolint:errcheck
+
+		enc := json.NewEncoder(ibj)
+
+		var lastTse *TipSetExec
+
+		lastState := tschain[len(tschain)-1].ParentState()
+		for i := len(tschain) - 2; i >= 0; i-- {
+			cur := tschain[i]
+			log.Infof("computing state (height: %d, ts=%s)", cur.Height(), cur.Cids())
+			if cur.ParentState() != lastState {
+				lastTrace := lastTse.Trace
+				d, err := json.MarshalIndent(lastTrace, "", "  ")
+				if err != nil {
+					panic(err)
+				}
+				fmt.Println("TRACE")
+				fmt.Println(string(d))
+				return xerrors.Errorf("tipset chain had state mismatch at height %d (%s != %s)", cur.Height(), cur.ParentState(), lastState)
+			}
+			start := time.Now()
+			st, trace, err := stm.ExecutionTrace(context.TODO(), cur)
+			if err != nil {
+				return err
+			}
+			stripCallers(trace)
+
+			lastTse = &TipSetExec{
+				TipSet:   cur.Key(),
+				Trace:    trace,
+				Duration: time.Since(start),
+			}
+			lastState = st
+			if err := enc.Encode(lastTse); err != nil {
+				return xerrors.Errorf("failed to write out tipsetexec: %w", err)
+			}
+		}
+
+		pprof.StopCPUProfile()
+
+		return nil
+
+	},
+}
+
+func walkExecutionTrace(et *types.ExecutionTrace) {
+	for _, gc := range et.GasCharges {
+		gc.Callers = nil
+	}
+	for _, sub := range et.Subcalls {
+		walkExecutionTrace(&sub) //nolint:scopelint,gosec
+	}
+}
+
+func stripCallers(trace []*api.InvocResult) {
+	for _, t := range trace {
+		walkExecutionTrace(&t.ExecutionTrace)
+	}
+}
+
+type Invocation struct {
+	TipSet types.TipSetKey
+	Invoc  *api.InvocResult
+}
+
+const GasPerNs = 10
+
+func countGasCosts(et *types.ExecutionTrace) (int64, int64) {
+	var cgas, vgas int64
+
+	for _, gc := range et.GasCharges {
+		cgas += gc.ComputeGas
+		vgas += gc.VirtualComputeGas
+	}
+
+	for _, sub := range et.Subcalls {
+		c, v := countGasCosts(&sub) //nolint
+		cgas += c
+		vgas += v
+	}
+
+	return cgas, vgas
+}
+
+type stats struct {
+	timeTaken meanVar
+	gasRatio  meanVar
+
+	extraCovar *covar
+}
+
+type covar struct {
+	meanX float64
+	meanY float64
+	c     float64
+	n     float64
+	m2x   float64
+	m2y   float64
+}
+
+func (cov1 *covar) Covariance() float64 {
+	return cov1.c / (cov1.n - 1)
+}
+
+func (cov1 *covar) VarianceX() float64 {
+	return cov1.m2x / (cov1.n - 1)
+}
+
+func (cov1 *covar) StddevX() float64 {
+	return math.Sqrt(cov1.VarianceX())
+}
+
+func (cov1 *covar) VarianceY() float64 {
+	return cov1.m2y / (cov1.n - 1)
+}
+
+func (cov1 *covar) StddevY() float64 {
+	return math.Sqrt(cov1.VarianceY())
+}
+
+func (cov1 *covar) AddPoint(x, y float64) {
+	cov1.n++
+
+	dx := x - cov1.meanX
+	cov1.meanX += dx / cov1.n
+	dx2 := x - cov1.meanX
+	cov1.m2x += dx * dx2
+
+	dy := y - cov1.meanY
+	cov1.meanY += dy / cov1.n
+	dy2 := y - cov1.meanY
+	cov1.m2y += dy * dy2
+
+	cov1.c += dx * dy
+}
+
+func (cov1 *covar) Combine(cov2 *covar) {
+	if cov1.n == 0 {
+		*cov1 = *cov2
+		return
+	}
+	if cov2.n == 0 {
+		return
+	}
+
+	if cov1.n == 1 {
+		cpy := *cov2
+		cpy.AddPoint(cov2.meanX, cov2.meanY)
+		*cov1 = cpy
+		return
+	}
+	if cov2.n == 1 {
+		cov1.AddPoint(cov2.meanX, cov2.meanY)
+	}
+
+	out := covar{}
+	out.n = cov1.n + cov2.n
+
+	dx := cov1.meanX - cov2.meanX
+	out.meanX = cov1.meanX - dx*cov2.n/out.n
+	out.m2x = cov1.m2x + cov2.m2x + dx*dx*cov1.n*cov2.n/out.n
+
+	dy := cov1.meanY - cov2.meanY
+	out.meanY = cov1.meanY - dy*cov2.n/out.n
+	out.m2y = cov1.m2y + cov2.m2y + dy*dy*cov1.n*cov2.n/out.n
+
+	out.c = cov1.c + cov2.c + dx*dy*cov1.n*cov2.n/out.n
+	*cov1 = out
+}
+
+func (cov1 *covar) A() float64 {
+	return cov1.Covariance() / cov1.VarianceX()
+}
+func (cov1 *covar) B() float64 {
+	return cov1.meanY - cov1.meanX*cov1.A()
+}
+func (cov1 *covar) Correl() float64 {
+	return cov1.Covariance() / cov1.StddevX() / cov1.StddevY()
+}
+
+type meanVar struct {
+	n    float64
+	mean float64
+	m2   float64
+}
+
+func (v1 *meanVar) AddPoint(value float64) {
+	// based on https://en.wikipedia.org/wiki/Algorithms_for_calculating_variance#Welford's_online_algorithm
+	v1.n++
+	delta := value - v1.mean
+	v1.mean += delta / v1.n
+	delta2 := value - v1.mean
+	v1.m2 += delta * delta2
+}
+
+func (v1 *meanVar) Variance() float64 {
+	return v1.m2 / (v1.n - 1)
+}
+func (v1 *meanVar) Mean() float64 {
+	return v1.mean
+}
+func (v1 *meanVar) Stddev() float64 {
+	return math.Sqrt(v1.Variance())
+}
+
+func (v1 *meanVar) Combine(v2 *meanVar) {
+	if v1.n == 0 {
+		*v1 = *v2
+		return
+	}
+	if v2.n == 0 {
+		return
+	}
+	if v1.n == 1 {
+		cpy := *v2
+		cpy.AddPoint(v1.mean)
+		*v1 = cpy
+		return
+	}
+	if v2.n == 1 {
+		v1.AddPoint(v2.mean)
+		return
+	}
+
+	newCount := v1.n + v2.n
+	delta := v2.mean - v1.mean
+	meanDelta := delta * v2.n / newCount
+	m2 := v1.m2 + v2.m2 + delta*meanDelta*v1.n
+	v1.n = newCount
+	v1.mean += meanDelta
+	v1.m2 = m2
+}
+
+func getExtras(ex interface{}) (*string, *float64) {
+	if t, ok := ex.(string); ok {
+		return &t, nil
+	}
+	if size, ok := ex.(float64); ok {
+		return nil, &size
+	}
+	if exMap, ok := ex.(map[string]interface{}); ok {
+		t, tok := exMap["type"].(string)
+		size, sok := exMap["size"].(float64)
+		if tok && sok {
+			return &t, &size
+		}
+		if tok {
+			return &t, nil
+		}
+		if sok {
+			return nil, &size
+		}
+		return nil, nil
+	}
+	return nil, nil
+}
+
+func tallyGasCharges(charges map[string]*stats, et types.ExecutionTrace) {
+	for i, gc := range et.GasCharges {
+		name := gc.Name
+		if name == "OnIpldGetEnd" {
+			continue
+		}
+		tt := float64(gc.TimeTaken.Nanoseconds())
+		if name == "OnVerifyPost" && tt > 2e9 {
+			log.Warnf("Skipping abnormally long OnVerifyPost: %fs", tt/1e9)
+			// discard initial very long OnVerifyPost
+			continue
+		}
+		eType, eSize := getExtras(gc.Extra)
+
+		if name == "OnIpldGet" {
+			next := &types.GasTrace{}
+			if i+1 < len(et.GasCharges) {
+				next = et.GasCharges[i+1]
+			}
+			if next.Name != "OnIpldGetEnd" {
+				log.Warn("OnIpldGet without OnIpldGetEnd")
+			} else {
+				_, size := getExtras(next.Extra)
+				eSize = size
+			}
+		}
+		if eType != nil {
+			name += "-" + *eType
+		}
+		compGas := gc.ComputeGas
+		if compGas == 0 {
+			compGas = gc.VirtualComputeGas
+		}
+		if compGas == 0 {
+			compGas = 1
+		}
+		s := charges[name]
+		if s == nil {
+			s = new(stats)
+			charges[name] = s
+		}
+
+		if eSize != nil {
+			if s.extraCovar == nil {
+				s.extraCovar = &covar{}
+			}
+			s.extraCovar.AddPoint(*eSize, tt)
+		}
+
+		s.timeTaken.AddPoint(tt)
+
+		ratio := tt / float64(compGas) * GasPerNs
+		s.gasRatio.AddPoint(ratio)
+	}
+	for _, sub := range et.Subcalls {
+		tallyGasCharges(charges, sub)
+	}
+}
+
+var importAnalyzeCmd = &cli.Command{
+	Name: "analyze",
+	Action: func(cctx *cli.Context) error {
+		if !cctx.Args().Present() {
+			fmt.Println("must pass bench file to analyze")
+			return nil
+		}
+
+		go func() {
+			http.ListenAndServe("localhost:6060", nil) //nolint:errcheck
+		}()
+
+		fi, err := os.Open(cctx.Args().First())
+		if err != nil {
+			return err
+		}
+		defer fi.Close() //nolint:errcheck
+
+		const nWorkers = 16
+		jsonIn := make(chan []byte, 2*nWorkers)
+		type result struct {
+			totalTime       time.Duration
+			chargeStats     map[string]*stats
+			expensiveInvocs []Invocation
+		}
+
+		results := make(chan result, nWorkers)
+
+		for i := 0; i < nWorkers; i++ {
+			go func() {
+				chargeStats := make(map[string]*stats)
+				var totalTime time.Duration
+				const invocsKeep = 32
+				var expensiveInvocs = make([]Invocation, 0, 8*invocsKeep)
+				var leastExpensiveInvoc = time.Duration(0)
+
+				for {
+					b, ok := <-jsonIn
+					if !ok {
+						results <- result{
+							totalTime:       totalTime,
+							chargeStats:     chargeStats,
+							expensiveInvocs: expensiveInvocs,
+						}
+						return
+					}
+
+					var tse TipSetExec
+					err := json.Unmarshal(b, &tse)
+					if err != nil {
+						log.Warnf("error unmarshaling tipset: %+v", err)
+						continue
+					}
+
+					totalTime += tse.Duration
+					for _, inv := range tse.Trace {
+						if inv.Duration > leastExpensiveInvoc {
+							expensiveInvocs = append(expensiveInvocs, Invocation{
+								TipSet: tse.TipSet,
+								Invoc:  inv,
+							})
+						}
+
+						tallyGasCharges(chargeStats, inv.ExecutionTrace)
+					}
+					if len(expensiveInvocs) > 4*invocsKeep {
+						sort.Slice(expensiveInvocs, func(i, j int) bool {
+							return expensiveInvocs[i].Invoc.Duration > expensiveInvocs[j].Invoc.Duration
+						})
+						leastExpensiveInvoc = expensiveInvocs[len(expensiveInvocs)-1].Invoc.Duration
+						n := 30
+						if len(expensiveInvocs) < n {
+							n = len(expensiveInvocs)
+						}
+						expensiveInvocs = expensiveInvocs[:n]
+					}
+				}
+			}()
+		}
+
+		var totalTipsets int64
+		reader := bufio.NewReader(fi)
+		for {
+			b, err := reader.ReadBytes('\n')
+			if err != nil && err != io.EOF {
+				if e, ok := err.(*json.SyntaxError); ok {
+					log.Warnf("syntax error at byte offset %d", e.Offset)
+				}
+				return err
+			}
+			totalTipsets++
+			jsonIn <- b
+			fmt.Fprintf(os.Stderr, "\rProcessed %d tipsets", totalTipsets)
+			if err == io.EOF {
+				break
+			}
+		}
+		close(jsonIn)
+		fmt.Fprintf(os.Stderr, "\n")
+		fmt.Fprintf(os.Stderr, "Collecting results\n")
+
+		var invocs []Invocation
+		var totalTime time.Duration
+		var keys []string
+		var charges = make(map[string]*stats)
+		for i := 0; i < nWorkers; i++ {
+			fmt.Fprintf(os.Stderr, "\rProcessing results from worker %d/%d", i+1, nWorkers)
+			res := <-results
+			invocs = append(invocs, res.expensiveInvocs...)
+			for k, v := range res.chargeStats {
+				s := charges[k]
+				if s == nil {
+					s = new(stats)
+					charges[k] = s
+				}
+				s.timeTaken.Combine(&v.timeTaken)
+				s.gasRatio.Combine(&v.gasRatio)
+
+				if v.extraCovar != nil {
+					if s.extraCovar == nil {
+						s.extraCovar = &covar{}
+					}
+					s.extraCovar.Combine(v.extraCovar)
+				}
+			}
+			totalTime += res.totalTime
+		}
+
+		fmt.Fprintf(os.Stderr, "\nCollecting gas keys\n")
+		for k := range charges {
+			keys = append(keys, k)
+		}
+
+		fmt.Println("Gas Price Deltas")
+		sort.Strings(keys)
+		for _, k := range keys {
+			s := charges[k]
+			fmt.Printf("%s: incr by %.4f~%.4f; tt %.4f~%.4f\n", k, s.gasRatio.Mean(), s.gasRatio.Stddev(),
+				s.timeTaken.Mean(), s.timeTaken.Stddev())
+			if s.extraCovar != nil {
+				fmt.Printf("\t correll: %.2f, tt = %.2f * extra + %.2f\n", s.extraCovar.Correl(),
+					s.extraCovar.A(), s.extraCovar.B())
+				fmt.Printf("\t covar: %.2f, extra: %.2f~%.2f, tt2: %.2f~%.2f, count %.0f\n",
+					s.extraCovar.Covariance(), s.extraCovar.meanX, s.extraCovar.StddevX(),
+					s.extraCovar.meanY, s.extraCovar.StddevY(), s.extraCovar.n)
+			}
+		}
+
+		sort.Slice(invocs, func(i, j int) bool {
+			return invocs[i].Invoc.Duration > invocs[j].Invoc.Duration
+		})
+
+		fmt.Println("Total time: ", totalTime)
+		fmt.Println("Average time per epoch: ", totalTime/time.Duration(totalTipsets))
+		if actorExec, ok := charges["OnActorExec"]; ok {
+			timeInActors := actorExec.timeTaken.Mean() * actorExec.timeTaken.n
+			fmt.Printf("Avarage time per epoch in actors: %s (%.1f%%)\n", time.Duration(timeInActors)/time.Duration(totalTipsets), timeInActors/float64(totalTime)*100)
+		}
+		if actorExecDone, ok := charges["OnMethodInvocationDone"]; ok {
+			timeInActors := actorExecDone.timeTaken.Mean() * actorExecDone.timeTaken.n
+			fmt.Printf("Avarage time per epoch in OnActorExecDone %s (%.1f%%)\n", time.Duration(timeInActors)/time.Duration(totalTipsets), timeInActors/float64(totalTime)*100)
+		}
+
+		n := 30
+		if len(invocs) < n {
+			n = len(invocs)
+		}
+		fmt.Printf("Top %d most expensive calls:\n", n)
+		for i := 0; i < n; i++ {
+			inv := invocs[i].Invoc
+			fmt.Printf("%s: %s %s %d %s\n", inv.Duration, inv.Msg.From, inv.Msg.To, inv.Msg.Method, invocs[i].TipSet)
+		}
+		return nil
+	},
+}
diff --git a/cmd/lotus-bench/main.go b/cmd/lotus-bench/main.go
index b0c90b58c..2516bfd26 100644
--- a/cmd/lotus-bench/main.go
+++ b/cmd/lotus-bench/main.go
@@ -1,9 +1,7 @@
 package main
 
 import (
-	"bytes"
 	"context"
-	"crypto/sha256"
 	"encoding/json"
 	"fmt"
 	"io/ioutil"
@@ -13,18 +11,27 @@ import (
 	"path/filepath"
 	"time"
 
+	saproof "github.com/filecoin-project/specs-actors/actors/runtime/proof"
+
 	"github.com/docker/go-units"
-	ffi "github.com/filecoin-project/filecoin-ffi"
-	paramfetch "github.com/filecoin-project/go-paramfetch"
-	"github.com/ipfs/go-datastore"
-	logging "github.com/ipfs/go-log"
+	logging "github.com/ipfs/go-log/v2"
+	"github.com/minio/blake2b-simd"
 	"github.com/mitchellh/go-homedir"
+	"github.com/urfave/cli/v2"
 	"golang.org/x/xerrors"
-	"gopkg.in/urfave/cli.v2"
 
 	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-sectorbuilder"
+	paramfetch "github.com/filecoin-project/go-paramfetch"
+	"github.com/filecoin-project/go-state-types/abi"
+	lcli "github.com/filecoin-project/lotus/cli"
+	"github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper"
+	"github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper/basicfs"
+	"github.com/filecoin-project/lotus/extern/sector-storage/stores"
+	"github.com/filecoin-project/specs-storage/storage"
+
+	lapi "github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/actors/policy"
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/genesis"
 )
@@ -32,23 +39,36 @@ import (
 var log = logging.Logger("lotus-bench")
 
 type BenchResults struct {
-	SectorSize uint64
+	SectorSize abi.SectorSize
 
 	SealingResults []SealingResult
 
 	PostGenerateCandidates time.Duration
-	PostEProofCold         time.Duration
-	PostEProofHot          time.Duration
-	VerifyEPostCold        time.Duration
-	VerifyEPostHot         time.Duration
+	PostWinningProofCold   time.Duration
+	PostWinningProofHot    time.Duration
+	VerifyWinningPostCold  time.Duration
+	VerifyWinningPostHot   time.Duration
+
+	PostWindowProofCold  time.Duration
+	PostWindowProofHot   time.Duration
+	VerifyWindowPostCold time.Duration
+	VerifyWindowPostHot  time.Duration
 }
 
 type SealingResult struct {
-	AddPiece  time.Duration
-	PreCommit time.Duration
-	Commit    time.Duration
-	Verify    time.Duration
-	Unseal    time.Duration
+	AddPiece   time.Duration
+	PreCommit1 time.Duration
+	PreCommit2 time.Duration
+	Commit1    time.Duration
+	Commit2    time.Duration
+	Verify     time.Duration
+	Unseal     time.Duration
+}
+
+type Commit2In struct {
+	SectorNum  int64
+	Phase1Out  []byte
+	SectorSize uint64
 }
 
 func main() {
@@ -56,322 +76,674 @@ func main() {
 
 	log.Info("Starting lotus-bench")
 
-	build.SectorSizes = append(build.SectorSizes, 1024)
+	policy.AddSupportedProofTypes(abi.RegisteredSealProof_StackedDrg2KiBV1)
 
 	app := &cli.App{
 		Name:    "lotus-bench",
 		Usage:   "Benchmark performance of lotus on your hardware",
-		Version: build.UserVersion,
-		Flags: []cli.Flag{
-			&cli.StringFlag{
-				Name:  "storage-dir",
-				Value: "~/.lotus-bench",
-				Usage: "Path to the storage directory that will store sectors long term",
-			},
-			&cli.StringFlag{
-				Name:  "sector-size",
-				Value: "1GiB",
-				Usage: "size of the sectors in bytes, i.e. 32GiB",
-			},
-			&cli.BoolFlag{
-				Name:  "no-gpu",
-				Usage: "disable gpu usage for the benchmark run",
-			},
-			&cli.StringFlag{
-				Name:  "miner-addr",
-				Usage: "pass miner address (only necessary if using existing sectorbuilder)",
-				Value: "t0101",
-			},
-			&cli.StringFlag{
-				Name:  "benchmark-existing-sectorbuilder",
-				Usage: "pass a directory to run election-post timings on an existing sectorbuilder",
-			},
-			&cli.BoolFlag{
-				Name:  "json-out",
-				Usage: "output results in json format",
-			},
-			&cli.BoolFlag{
-				Name:  "skip-unseal",
-				Usage: "skip the unseal portion of the benchmark",
-			},
-		},
-		Action: func(c *cli.Context) error {
-			if c.Bool("no-gpu") {
-				os.Setenv("BELLMAN_NO_GPU", "1")
-			}
-
-			robench := c.String("benchmark-existing-sectorbuilder")
-
-			var sbdir string
-
-			if robench == "" {
-				sdir, err := homedir.Expand(c.String("storage-dir"))
-				if err != nil {
-					return err
-				}
-
-				os.MkdirAll(sdir, 0775)
-
-				tsdir, err := ioutil.TempDir(sdir, "bench")
-				if err != nil {
-					return err
-				}
-				defer func() {
-					if err := os.RemoveAll(tsdir); err != nil {
-						log.Warn("remove all: ", err)
-					}
-				}()
-				sbdir = tsdir
-			} else {
-				exp, err := homedir.Expand(robench)
-				if err != nil {
-					return err
-				}
-				sbdir = exp
-			}
-
-			maddr, err := address.NewFromString(c.String("miner-addr"))
-			if err != nil {
-				return err
-			}
-
-			sectorSizeInt, err := units.RAMInBytes(c.String("sector-size"))
-			if err != nil {
-				return err
-			}
-			sectorSize := uint64(sectorSizeInt)
-
-			mds := datastore.NewMapDatastore()
-			cfg := &sectorbuilder.Config{
-				Miner:         maddr,
-				SectorSize:    sectorSize,
-				WorkerThreads: 2,
-				Dir:           sbdir,
-			}
-
-			if robench == "" {
-				if err := os.MkdirAll(sbdir, 0775); err != nil {
-					return err
-				}
-			}
-
-			if err := paramfetch.GetParams(build.ParametersJson, sectorSize); err != nil {
-				return xerrors.Errorf("getting params: %w", err)
-			}
-			sb, err := sectorbuilder.New(cfg, mds)
-			if err != nil {
-				return err
-			}
-
-			dataSize := sectorbuilder.UserBytesForSectorSize(sectorSize)
-
-			var sealTimings []SealingResult
-			var sealedSectors []ffi.PublicSectorInfo
-			numSectors := uint64(1)
-			for i := uint64(1); i <= numSectors && robench == ""; i++ {
-				start := time.Now()
-				log.Info("Writing piece into sector...")
-
-				r := rand.New(rand.NewSource(100 + int64(i)))
-
-				pi, err := sb.AddPiece(dataSize, i, r, nil)
-				if err != nil {
-					return err
-				}
-
-				addpiece := time.Now()
-
-				trand := sha256.Sum256([]byte(c.String("ticket-preimage")))
-				ticket := sectorbuilder.SealTicket{
-					TicketBytes: trand,
-				}
-
-				log.Info("Running replication...")
-				pieces := []sectorbuilder.PublicPieceInfo{pi}
-				pco, err := sb.SealPreCommit(i, ticket, pieces)
-				if err != nil {
-					return xerrors.Errorf("commit: %w", err)
-				}
-
-				precommit := time.Now()
-
-				sealedSectors = append(sealedSectors, ffi.PublicSectorInfo{
-					CommR:    pco.CommR,
-					SectorID: i,
-				})
-
-				seed := sectorbuilder.SealSeed{
-					BlockHeight: 101,
-					TicketBytes: [32]byte{1, 2, 3, 4, 5},
-				}
-
-				log.Info("Generating PoRep for sector")
-				proof, err := sb.SealCommit(i, ticket, seed, pieces, pco)
-				if err != nil {
-					return err
-				}
-
-				sealcommit := time.Now()
-				commD := pi.CommP
-				ok, err := sectorbuilder.VerifySeal(sectorSize, pco.CommR[:], commD[:], maddr, ticket.TicketBytes[:], seed.TicketBytes[:], i, proof)
-				if err != nil {
-					return err
-				}
-				if !ok {
-					return xerrors.Errorf("porep proof for sector %d was invalid", i)
-				}
-
-				verifySeal := time.Now()
-
-				if !c.Bool("skip-unseal") {
-					log.Info("Unsealing sector")
-					rc, err := sb.ReadPieceFromSealedSector(1, 0, dataSize, ticket.TicketBytes[:], commD[:])
-					if err != nil {
-						return err
-					}
-
-					if err := rc.Close(); err != nil {
-						return err
-					}
-				}
-				unseal := time.Now()
-
-				sealTimings = append(sealTimings, SealingResult{
-					AddPiece:  addpiece.Sub(start),
-					PreCommit: precommit.Sub(addpiece),
-					Commit:    sealcommit.Sub(precommit),
-					Verify:    verifySeal.Sub(sealcommit),
-					Unseal:    unseal.Sub(verifySeal),
-				})
-			}
-
-			beforePost := time.Now()
-
-			var challenge [32]byte
-			rand.Read(challenge[:])
-
-			if robench != "" {
-				// TODO: this assumes we only ever benchmark a preseal
-				// sectorbuilder directory... we need a better way to handle
-				// this in other cases
-
-				fdata, err := ioutil.ReadFile(filepath.Join(sbdir, "pre-seal-"+maddr.String()+".json"))
-				if err != nil {
-					return err
-				}
-
-				var genmm map[string]genesis.GenesisMiner
-				if err := json.Unmarshal(fdata, &genmm); err != nil {
-					return err
-				}
-
-				genm, ok := genmm[maddr.String()]
-				if !ok {
-					return xerrors.Errorf("preseal file didnt have expected miner in it")
-				}
-
-				for _, s := range genm.Sectors {
-					sealedSectors = append(sealedSectors, ffi.PublicSectorInfo{
-						CommR:    s.CommR,
-						SectorID: s.SectorID,
-					})
-				}
-			}
-
-			log.Info("generating election post candidates")
-			sinfos := sectorbuilder.NewSortedPublicSectorInfo(sealedSectors)
-			candidates, err := sb.GenerateEPostCandidates(sinfos, challenge, []uint64{})
-			if err != nil {
-				return err
-			}
-
-			gencandidates := time.Now()
-
-			log.Info("computing election post snark (cold)")
-			proof1, err := sb.ComputeElectionPoSt(sinfos, challenge[:], candidates[:1])
-			if err != nil {
-				return err
-			}
-
-			epost1 := time.Now()
-
-			log.Info("computing election post snark (hot)")
-			proof2, err := sb.ComputeElectionPoSt(sinfos, challenge[:], candidates[:1])
-			if err != nil {
-				return err
-			}
-
-			epost2 := time.Now()
-
-			if !bytes.Equal(proof1, proof2) {
-				log.Warn("separate epost calls returned different proof values (this might be bad)")
-			}
-
-			ok, err := sectorbuilder.VerifyElectionPost(context.TODO(), sectorSize, sinfos, challenge[:], proof1, candidates[:1], maddr)
-			if err != nil {
-				return err
-			}
-			if !ok {
-				log.Error("post verification failed")
-			}
-
-			verifypost1 := time.Now()
-
-			ok, err = sectorbuilder.VerifyElectionPost(context.TODO(), sectorSize, sinfos, challenge[:], proof2, candidates[:1], maddr)
-			if err != nil {
-				return err
-			}
-			if !ok {
-				log.Error("post verification failed")
-			}
-			verifypost2 := time.Now()
-
-			bo := BenchResults{
-				SectorSize:     cfg.SectorSize,
-				SealingResults: sealTimings,
-
-				PostGenerateCandidates: gencandidates.Sub(beforePost),
-				PostEProofCold:         epost1.Sub(gencandidates),
-				PostEProofHot:          epost2.Sub(epost1),
-				VerifyEPostCold:        verifypost1.Sub(epost2),
-				VerifyEPostHot:         verifypost2.Sub(verifypost1),
-			} // TODO: optionally write this as json to a file
-
-			if c.Bool("json-out") {
-				data, err := json.MarshalIndent(bo, "", "  ")
-				if err != nil {
-					return err
-				}
-
-				fmt.Println(string(data))
-			} else {
-				fmt.Printf("results (%d)\n", sectorSize)
-				if robench == "" {
-					fmt.Printf("seal: addPiece: %s (%s)\n", bo.SealingResults[0].AddPiece, bps(bo.SectorSize, bo.SealingResults[0].AddPiece)) // TODO: average across multiple sealings
-					fmt.Printf("seal: preCommit: %s (%s)\n", bo.SealingResults[0].PreCommit, bps(bo.SectorSize, bo.SealingResults[0].PreCommit))
-					fmt.Printf("seal: commit: %s (%s)\n", bo.SealingResults[0].Commit, bps(bo.SectorSize, bo.SealingResults[0].Commit))
-					fmt.Printf("seal: verify: %s\n", bo.SealingResults[0].Verify)
-					fmt.Printf("unseal: %s  (%s)\n", bo.SealingResults[0].Unseal, bps(bo.SectorSize, bo.SealingResults[0].Unseal))
-				}
-				fmt.Printf("generate candidates: %s (%s)\n", bo.PostGenerateCandidates, bps(bo.SectorSize*uint64(len(bo.SealingResults)), bo.PostGenerateCandidates))
-				fmt.Printf("compute epost proof (cold): %s\n", bo.PostEProofCold)
-				fmt.Printf("compute epost proof (hot): %s\n", bo.PostEProofHot)
-				fmt.Printf("verify epost proof (cold): %s\n", bo.VerifyEPostCold)
-				fmt.Printf("verify epost proof (hot): %s\n", bo.VerifyEPostHot)
-			}
-			return nil
+		Version: build.UserVersion(),
+		Commands: []*cli.Command{
+			proveCmd,
+			sealBenchCmd,
+			importBenchCmd,
 		},
 	}
 
 	if err := app.Run(os.Args); err != nil {
-		log.Warn(err)
+		log.Warnf("%+v", err)
 		return
 	}
 }
 
-func bps(data uint64, d time.Duration) string {
-	bdata := new(big.Int).SetUint64(data)
+var sealBenchCmd = &cli.Command{
+	Name: "sealing",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:  "storage-dir",
+			Value: "~/.lotus-bench",
+			Usage: "Path to the storage directory that will store sectors long term",
+		},
+		&cli.StringFlag{
+			Name:  "sector-size",
+			Value: "512MiB",
+			Usage: "size of the sectors in bytes, i.e. 32GiB",
+		},
+		&cli.BoolFlag{
+			Name:  "no-gpu",
+			Usage: "disable gpu usage for the benchmark run",
+		},
+		&cli.StringFlag{
+			Name:  "miner-addr",
+			Usage: "pass miner address (only necessary if using existing sectorbuilder)",
+			Value: "t01000",
+		},
+		&cli.StringFlag{
+			Name:  "benchmark-existing-sectorbuilder",
+			Usage: "pass a directory to run post timings on an existing sectorbuilder",
+		},
+		&cli.BoolFlag{
+			Name:  "json-out",
+			Usage: "output results in json format",
+		},
+		&cli.BoolFlag{
+			Name:  "skip-commit2",
+			Usage: "skip the commit2 (snark) portion of the benchmark",
+		},
+		&cli.BoolFlag{
+			Name:  "skip-unseal",
+			Usage: "skip the unseal portion of the benchmark",
+		},
+		&cli.StringFlag{
+			Name:  "save-commit2-input",
+			Usage: "Save commit2 input to a file",
+		},
+		&cli.IntFlag{
+			Name:  "num-sectors",
+			Value: 1,
+		},
+		&cli.IntFlag{
+			Name:  "parallel",
+			Value: 1,
+		},
+	},
+	Action: func(c *cli.Context) error {
+		if c.Bool("no-gpu") {
+			err := os.Setenv("BELLMAN_NO_GPU", "1")
+			if err != nil {
+				return xerrors.Errorf("setting no-gpu flag: %w", err)
+			}
+		}
+
+		robench := c.String("benchmark-existing-sectorbuilder")
+
+		var sbdir string
+
+		if robench == "" {
+			sdir, err := homedir.Expand(c.String("storage-dir"))
+			if err != nil {
+				return err
+			}
+
+			err = os.MkdirAll(sdir, 0775) //nolint:gosec
+			if err != nil {
+				return xerrors.Errorf("creating sectorbuilder dir: %w", err)
+			}
+
+			tsdir, err := ioutil.TempDir(sdir, "bench")
+			if err != nil {
+				return err
+			}
+			defer func() {
+				if err := os.RemoveAll(tsdir); err != nil {
+					log.Warn("remove all: ", err)
+				}
+			}()
+
+			// TODO: pretty sure this isnt even needed?
+			if err := os.MkdirAll(tsdir, 0775); err != nil {
+				return err
+			}
+
+			sbdir = tsdir
+		} else {
+			exp, err := homedir.Expand(robench)
+			if err != nil {
+				return err
+			}
+			sbdir = exp
+		}
+
+		// miner address
+		maddr, err := address.NewFromString(c.String("miner-addr"))
+		if err != nil {
+			return err
+		}
+		amid, err := address.IDFromAddress(maddr)
+		if err != nil {
+			return err
+		}
+		mid := abi.ActorID(amid)
+
+		// sector size
+		sectorSizeInt, err := units.RAMInBytes(c.String("sector-size"))
+		if err != nil {
+			return err
+		}
+		sectorSize := abi.SectorSize(sectorSizeInt)
+
+		spt, err := ffiwrapper.SealProofTypeFromSectorSize(sectorSize)
+		if err != nil {
+			return err
+		}
+
+		cfg := &ffiwrapper.Config{
+			SealProofType: spt,
+		}
+
+		// Only fetch parameters if actually needed
+		if !c.Bool("skip-commit2") {
+			if err := paramfetch.GetParams(lcli.ReqContext(c), build.ParametersJSON(), uint64(sectorSize)); err != nil {
+				return xerrors.Errorf("getting params: %w", err)
+			}
+		}
+
+		sbfs := &basicfs.Provider{
+			Root: sbdir,
+		}
+
+		sb, err := ffiwrapper.New(sbfs, cfg)
+		if err != nil {
+			return err
+		}
+
+		var sealTimings []SealingResult
+		var sealedSectors []saproof.SectorInfo
+
+		if robench == "" {
+			var err error
+			parCfg := ParCfg{
+				PreCommit1: c.Int("parallel"),
+				PreCommit2: 1,
+				Commit:     1,
+			}
+			sealTimings, sealedSectors, err = runSeals(sb, sbfs, c.Int("num-sectors"), parCfg, mid, sectorSize, []byte(c.String("ticket-preimage")), c.String("save-commit2-input"), c.Bool("skip-commit2"), c.Bool("skip-unseal"))
+			if err != nil {
+				return xerrors.Errorf("failed to run seals: %w", err)
+			}
+		}
+
+		beforePost := time.Now()
+
+		var challenge [32]byte
+		rand.Read(challenge[:])
+
+		if robench != "" {
+			// TODO: implement sbfs.List() and use that for all cases (preexisting sectorbuilder or not)
+
+			// TODO: this assumes we only ever benchmark a preseal
+			// sectorbuilder directory... we need a better way to handle
+			// this in other cases
+
+			fdata, err := ioutil.ReadFile(filepath.Join(sbdir, "pre-seal-"+maddr.String()+".json"))
+			if err != nil {
+				return err
+			}
+
+			var genmm map[string]genesis.Miner
+			if err := json.Unmarshal(fdata, &genmm); err != nil {
+				return err
+			}
+
+			genm, ok := genmm[maddr.String()]
+			if !ok {
+				return xerrors.Errorf("preseal file didnt have expected miner in it")
+			}
+
+			for _, s := range genm.Sectors {
+				sealedSectors = append(sealedSectors, saproof.SectorInfo{
+					SealedCID:    s.CommR,
+					SectorNumber: s.SectorID,
+					SealProof:    s.ProofType,
+				})
+			}
+		}
+
+		bo := BenchResults{
+			SectorSize:     sectorSize,
+			SealingResults: sealTimings,
+		}
+
+		if !c.Bool("skip-commit2") {
+			log.Info("generating winning post candidates")
+			wipt, err := spt.RegisteredWinningPoStProof()
+			if err != nil {
+				return err
+			}
+
+			fcandidates, err := ffiwrapper.ProofVerifier.GenerateWinningPoStSectorChallenge(context.TODO(), wipt, mid, challenge[:], uint64(len(sealedSectors)))
+			if err != nil {
+				return err
+			}
+
+			candidates := make([]saproof.SectorInfo, len(fcandidates))
+			for i, fcandidate := range fcandidates {
+				candidates[i] = sealedSectors[fcandidate]
+			}
+
+			gencandidates := time.Now()
+
+			log.Info("computing winning post snark (cold)")
+			proof1, err := sb.GenerateWinningPoSt(context.TODO(), mid, candidates, challenge[:])
+			if err != nil {
+				return err
+			}
+
+			winningpost1 := time.Now()
+
+			log.Info("computing winning post snark (hot)")
+			proof2, err := sb.GenerateWinningPoSt(context.TODO(), mid, candidates, challenge[:])
+			if err != nil {
+				return err
+			}
+
+			winnningpost2 := time.Now()
+
+			pvi1 := saproof.WinningPoStVerifyInfo{
+				Randomness:        abi.PoStRandomness(challenge[:]),
+				Proofs:            proof1,
+				ChallengedSectors: candidates,
+				Prover:            mid,
+			}
+			ok, err := ffiwrapper.ProofVerifier.VerifyWinningPoSt(context.TODO(), pvi1)
+			if err != nil {
+				return err
+			}
+			if !ok {
+				log.Error("post verification failed")
+			}
+
+			verifyWinningPost1 := time.Now()
+
+			pvi2 := saproof.WinningPoStVerifyInfo{
+				Randomness:        abi.PoStRandomness(challenge[:]),
+				Proofs:            proof2,
+				ChallengedSectors: candidates,
+				Prover:            mid,
+			}
+
+			ok, err = ffiwrapper.ProofVerifier.VerifyWinningPoSt(context.TODO(), pvi2)
+			if err != nil {
+				return err
+			}
+			if !ok {
+				log.Error("post verification failed")
+			}
+			verifyWinningPost2 := time.Now()
+
+			log.Info("computing window post snark (cold)")
+			wproof1, _, err := sb.GenerateWindowPoSt(context.TODO(), mid, sealedSectors, challenge[:])
+			if err != nil {
+				return err
+			}
+
+			windowpost1 := time.Now()
+
+			log.Info("computing window post snark (hot)")
+			wproof2, _, err := sb.GenerateWindowPoSt(context.TODO(), mid, sealedSectors, challenge[:])
+			if err != nil {
+				return err
+			}
+
+			windowpost2 := time.Now()
+
+			wpvi1 := saproof.WindowPoStVerifyInfo{
+				Randomness:        challenge[:],
+				Proofs:            wproof1,
+				ChallengedSectors: sealedSectors,
+				Prover:            mid,
+			}
+			ok, err = ffiwrapper.ProofVerifier.VerifyWindowPoSt(context.TODO(), wpvi1)
+			if err != nil {
+				return err
+			}
+			if !ok {
+				log.Error("window post verification failed")
+			}
+
+			verifyWindowpost1 := time.Now()
+
+			wpvi2 := saproof.WindowPoStVerifyInfo{
+				Randomness:        challenge[:],
+				Proofs:            wproof2,
+				ChallengedSectors: sealedSectors,
+				Prover:            mid,
+			}
+			ok, err = ffiwrapper.ProofVerifier.VerifyWindowPoSt(context.TODO(), wpvi2)
+			if err != nil {
+				return err
+			}
+			if !ok {
+				log.Error("window post verification failed")
+			}
+
+			verifyWindowpost2 := time.Now()
+
+			bo.PostGenerateCandidates = gencandidates.Sub(beforePost)
+			bo.PostWinningProofCold = winningpost1.Sub(gencandidates)
+			bo.PostWinningProofHot = winnningpost2.Sub(winningpost1)
+			bo.VerifyWinningPostCold = verifyWinningPost1.Sub(winnningpost2)
+			bo.VerifyWinningPostHot = verifyWinningPost2.Sub(verifyWinningPost1)
+
+			bo.PostWindowProofCold = windowpost1.Sub(verifyWinningPost2)
+			bo.PostWindowProofHot = windowpost2.Sub(windowpost1)
+			bo.VerifyWindowPostCold = verifyWindowpost1.Sub(windowpost2)
+			bo.VerifyWindowPostHot = verifyWindowpost2.Sub(verifyWindowpost1)
+		}
+
+		if c.Bool("json-out") {
+			data, err := json.MarshalIndent(bo, "", "  ")
+			if err != nil {
+				return err
+			}
+
+			fmt.Println(string(data))
+		} else {
+			fmt.Printf("----\nresults (v27) (%d)\n", sectorSize)
+			if robench == "" {
+				fmt.Printf("seal: addPiece: %s (%s)\n", bo.SealingResults[0].AddPiece, bps(bo.SectorSize, bo.SealingResults[0].AddPiece)) // TODO: average across multiple sealings
+				fmt.Printf("seal: preCommit phase 1: %s (%s)\n", bo.SealingResults[0].PreCommit1, bps(bo.SectorSize, bo.SealingResults[0].PreCommit1))
+				fmt.Printf("seal: preCommit phase 2: %s (%s)\n", bo.SealingResults[0].PreCommit2, bps(bo.SectorSize, bo.SealingResults[0].PreCommit2))
+				fmt.Printf("seal: commit phase 1: %s (%s)\n", bo.SealingResults[0].Commit1, bps(bo.SectorSize, bo.SealingResults[0].Commit1))
+				fmt.Printf("seal: commit phase 2: %s (%s)\n", bo.SealingResults[0].Commit2, bps(bo.SectorSize, bo.SealingResults[0].Commit2))
+				fmt.Printf("seal: verify: %s\n", bo.SealingResults[0].Verify)
+				if !c.Bool("skip-unseal") {
+					fmt.Printf("unseal: %s  (%s)\n", bo.SealingResults[0].Unseal, bps(bo.SectorSize, bo.SealingResults[0].Unseal))
+				}
+				fmt.Println("")
+			}
+			if !c.Bool("skip-commit2") {
+				fmt.Printf("generate candidates: %s (%s)\n", bo.PostGenerateCandidates, bps(bo.SectorSize*abi.SectorSize(len(bo.SealingResults)), bo.PostGenerateCandidates))
+				fmt.Printf("compute winning post proof (cold): %s\n", bo.PostWinningProofCold)
+				fmt.Printf("compute winning post proof (hot): %s\n", bo.PostWinningProofHot)
+				fmt.Printf("verify winning post proof (cold): %s\n", bo.VerifyWinningPostCold)
+				fmt.Printf("verify winning post proof (hot): %s\n\n", bo.VerifyWinningPostHot)
+
+				fmt.Printf("compute window post proof (cold): %s\n", bo.PostWindowProofCold)
+				fmt.Printf("compute window post proof (hot): %s\n", bo.PostWindowProofHot)
+				fmt.Printf("verify window post proof (cold): %s\n", bo.VerifyWindowPostCold)
+				fmt.Printf("verify window post proof (hot): %s\n", bo.VerifyWindowPostHot)
+			}
+		}
+		return nil
+	},
+}
+
+type ParCfg struct {
+	PreCommit1 int
+	PreCommit2 int
+	Commit     int
+}
+
+func runSeals(sb *ffiwrapper.Sealer, sbfs *basicfs.Provider, numSectors int, par ParCfg, mid abi.ActorID, sectorSize abi.SectorSize, ticketPreimage []byte, saveC2inp string, skipc2, skipunseal bool) ([]SealingResult, []saproof.SectorInfo, error) {
+	var pieces []abi.PieceInfo
+	sealTimings := make([]SealingResult, numSectors)
+	sealedSectors := make([]saproof.SectorInfo, numSectors)
+
+	preCommit2Sema := make(chan struct{}, par.PreCommit2)
+	commitSema := make(chan struct{}, par.Commit)
+
+	if numSectors%par.PreCommit1 != 0 {
+		return nil, nil, fmt.Errorf("parallelism factor must cleanly divide numSectors")
+	}
+
+	for i := abi.SectorNumber(1); i <= abi.SectorNumber(numSectors); i++ {
+		sid := abi.SectorID{
+			Miner:  mid,
+			Number: i,
+		}
+
+		start := time.Now()
+		log.Infof("[%d] Writing piece into sector...", i)
+
+		r := rand.New(rand.NewSource(100 + int64(i)))
+
+		pi, err := sb.AddPiece(context.TODO(), sid, nil, abi.PaddedPieceSize(sectorSize).Unpadded(), r)
+		if err != nil {
+			return nil, nil, err
+		}
+
+		pieces = append(pieces, pi)
+
+		sealTimings[i-1].AddPiece = time.Since(start)
+	}
+
+	sectorsPerWorker := numSectors / par.PreCommit1
+
+	errs := make(chan error, par.PreCommit1)
+	for wid := 0; wid < par.PreCommit1; wid++ {
+		go func(worker int) {
+			sealerr := func() error {
+				start := 1 + (worker * sectorsPerWorker)
+				end := start + sectorsPerWorker
+				for i := abi.SectorNumber(start); i < abi.SectorNumber(end); i++ {
+					ix := int(i - 1)
+					sid := abi.SectorID{
+						Miner:  mid,
+						Number: i,
+					}
+
+					start := time.Now()
+
+					trand := blake2b.Sum256(ticketPreimage)
+					ticket := abi.SealRandomness(trand[:])
+
+					log.Infof("[%d] Running replication(1)...", i)
+					pieces := []abi.PieceInfo{pieces[ix]}
+					pc1o, err := sb.SealPreCommit1(context.TODO(), sid, ticket, pieces)
+					if err != nil {
+						return xerrors.Errorf("commit: %w", err)
+					}
+
+					precommit1 := time.Now()
+
+					preCommit2Sema <- struct{}{}
+					pc2Start := time.Now()
+					log.Infof("[%d] Running replication(2)...", i)
+					cids, err := sb.SealPreCommit2(context.TODO(), sid, pc1o)
+					if err != nil {
+						return xerrors.Errorf("commit: %w", err)
+					}
+
+					precommit2 := time.Now()
+					<-preCommit2Sema
+
+					sealedSectors[ix] = saproof.SectorInfo{
+						SealProof:    sb.SealProofType(),
+						SectorNumber: i,
+						SealedCID:    cids.Sealed,
+					}
+
+					seed := lapi.SealSeed{
+						Epoch: 101,
+						Value: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 255},
+					}
+
+					commitSema <- struct{}{}
+					commitStart := time.Now()
+					log.Infof("[%d] Generating PoRep for sector (1)", i)
+					c1o, err := sb.SealCommit1(context.TODO(), sid, ticket, seed.Value, pieces, cids)
+					if err != nil {
+						return err
+					}
+
+					sealcommit1 := time.Now()
+
+					log.Infof("[%d] Generating PoRep for sector (2)", i)
+
+					if saveC2inp != "" {
+						c2in := Commit2In{
+							SectorNum:  int64(i),
+							Phase1Out:  c1o,
+							SectorSize: uint64(sectorSize),
+						}
+
+						b, err := json.Marshal(&c2in)
+						if err != nil {
+							return err
+						}
+
+						if err := ioutil.WriteFile(saveC2inp, b, 0664); err != nil {
+							log.Warnf("%+v", err)
+						}
+					}
+
+					var proof storage.Proof
+					if !skipc2 {
+						proof, err = sb.SealCommit2(context.TODO(), sid, c1o)
+						if err != nil {
+							return err
+						}
+					}
+
+					sealcommit2 := time.Now()
+					<-commitSema
+
+					if !skipc2 {
+						svi := saproof.SealVerifyInfo{
+							SectorID:              abi.SectorID{Miner: mid, Number: i},
+							SealedCID:             cids.Sealed,
+							SealProof:             sb.SealProofType(),
+							Proof:                 proof,
+							DealIDs:               nil,
+							Randomness:            ticket,
+							InteractiveRandomness: seed.Value,
+							UnsealedCID:           cids.Unsealed,
+						}
+
+						ok, err := ffiwrapper.ProofVerifier.VerifySeal(svi)
+						if err != nil {
+							return err
+						}
+						if !ok {
+							return xerrors.Errorf("porep proof for sector %d was invalid", i)
+						}
+					}
+
+					verifySeal := time.Now()
+
+					if !skipunseal {
+						log.Infof("[%d] Unsealing sector", i)
+						{
+							p, done, err := sbfs.AcquireSector(context.TODO(), abi.SectorID{Miner: mid, Number: 1}, stores.FTUnsealed, stores.FTNone, stores.PathSealing)
+							if err != nil {
+								return xerrors.Errorf("acquire unsealed sector for removing: %w", err)
+							}
+							done()
+
+							if err := os.Remove(p.Unsealed); err != nil {
+								return xerrors.Errorf("removing unsealed sector: %w", err)
+							}
+						}
+
+						err := sb.UnsealPiece(context.TODO(), abi.SectorID{Miner: mid, Number: 1}, 0, abi.PaddedPieceSize(sectorSize).Unpadded(), ticket, cids.Unsealed)
+						if err != nil {
+							return err
+						}
+					}
+					unseal := time.Now()
+
+					sealTimings[ix].PreCommit1 = precommit1.Sub(start)
+					sealTimings[ix].PreCommit2 = precommit2.Sub(pc2Start)
+					sealTimings[ix].Commit1 = sealcommit1.Sub(commitStart)
+					sealTimings[ix].Commit2 = sealcommit2.Sub(sealcommit1)
+					sealTimings[ix].Verify = verifySeal.Sub(sealcommit2)
+					sealTimings[ix].Unseal = unseal.Sub(verifySeal)
+				}
+				return nil
+			}()
+			if sealerr != nil {
+				errs <- sealerr
+				return
+			}
+			errs <- nil
+		}(wid)
+	}
+
+	for i := 0; i < par.PreCommit1; i++ {
+		err := <-errs
+		if err != nil {
+			return nil, nil, err
+		}
+	}
+
+	return sealTimings, sealedSectors, nil
+}
+
+var proveCmd = &cli.Command{
+	Name:  "prove",
+	Usage: "Benchmark a proof computation",
+	Flags: []cli.Flag{
+		&cli.BoolFlag{
+			Name:  "no-gpu",
+			Usage: "disable gpu usage for the benchmark run",
+		},
+		&cli.StringFlag{
+			Name:  "miner-addr",
+			Usage: "pass miner address (only necessary if using existing sectorbuilder)",
+			Value: "t01000",
+		},
+	},
+	Action: func(c *cli.Context) error {
+		if c.Bool("no-gpu") {
+			err := os.Setenv("BELLMAN_NO_GPU", "1")
+			if err != nil {
+				return xerrors.Errorf("setting no-gpu flag: %w", err)
+			}
+		}
+
+		if !c.Args().Present() {
+			return xerrors.Errorf("Usage: lotus-bench prove [input.json]")
+		}
+
+		inb, err := ioutil.ReadFile(c.Args().First())
+		if err != nil {
+			return xerrors.Errorf("reading input file: %w", err)
+		}
+
+		var c2in Commit2In
+		if err := json.Unmarshal(inb, &c2in); err != nil {
+			return xerrors.Errorf("unmarshalling input file: %w", err)
+		}
+
+		if err := paramfetch.GetParams(lcli.ReqContext(c), build.ParametersJSON(), c2in.SectorSize); err != nil {
+			return xerrors.Errorf("getting params: %w", err)
+		}
+
+		maddr, err := address.NewFromString(c.String("miner-addr"))
+		if err != nil {
+			return err
+		}
+		mid, err := address.IDFromAddress(maddr)
+		if err != nil {
+			return err
+		}
+
+		spt, err := ffiwrapper.SealProofTypeFromSectorSize(abi.SectorSize(c2in.SectorSize))
+		if err != nil {
+			return err
+		}
+
+		cfg := &ffiwrapper.Config{
+			SealProofType: spt,
+		}
+
+		sb, err := ffiwrapper.New(nil, cfg)
+		if err != nil {
+			return err
+		}
+
+		start := time.Now()
+
+		proof, err := sb.SealCommit2(context.TODO(), abi.SectorID{Miner: abi.ActorID(mid), Number: abi.SectorNumber(c2in.SectorNum)}, c2in.Phase1Out)
+		if err != nil {
+			return err
+		}
+
+		sealCommit2 := time.Now()
+
+		fmt.Printf("proof: %x\n", proof)
+
+		fmt.Printf("----\nresults (v27) (%d)\n", c2in.SectorSize)
+		dur := sealCommit2.Sub(start)
+
+		fmt.Printf("seal: commit phase 2: %s (%s)\n", dur, bps(abi.SectorSize(c2in.SectorSize), dur))
+		return nil
+	},
+}
+
+func bps(data abi.SectorSize, d time.Duration) string {
+	bdata := new(big.Int).SetUint64(uint64(data))
 	bdata = bdata.Mul(bdata, big.NewInt(time.Second.Nanoseconds()))
 	bps := bdata.Div(bdata, big.NewInt(d.Nanoseconds()))
-	return (types.BigInt{bps}).SizeStr() + "/s"
+	return types.SizeStr(types.BigInt{Int: bps}) + "/s"
 }
diff --git a/cmd/lotus-bench/stats_test.go b/cmd/lotus-bench/stats_test.go
new file mode 100644
index 000000000..16caf3f7e
--- /dev/null
+++ b/cmd/lotus-bench/stats_test.go
@@ -0,0 +1,47 @@
+package main
+
+import (
+	"math/rand"
+	"testing"
+)
+
+func TestMeanVar(t *testing.T) {
+	N := 16
+	ss := make([]*meanVar, N)
+	rng := rand.New(rand.NewSource(1))
+	for i := 0; i < N; i++ {
+		ss[i] = &meanVar{}
+		maxJ := rng.Intn(1000)
+		for j := 0; j < maxJ; j++ {
+			ss[i].AddPoint(rng.NormFloat64()*5 + 500)
+		}
+		t.Logf("mean: %f, stddev: %f, count %f", ss[i].mean, ss[i].Stddev(), ss[i].n)
+	}
+	out := &meanVar{}
+	for i := 0; i < N; i++ {
+		out.Combine(ss[i])
+		t.Logf("combine: mean: %f, stddev: %f", out.mean, out.Stddev())
+	}
+}
+
+func TestCovar(t *testing.T) {
+	N := 16
+	ss := make([]*covar, N)
+	rng := rand.New(rand.NewSource(1))
+	for i := 0; i < N; i++ {
+		ss[i] = &covar{}
+		maxJ := rng.Intn(1000) + 500
+		for j := 0; j < maxJ; j++ {
+			x := rng.NormFloat64()*5 + 500
+			ss[i].AddPoint(x, x*2-1000)
+		}
+		t.Logf("corell: %f, y = %f*x+%f @%.0f", ss[i].Correl(), ss[i].A(), ss[i].B(), ss[i].n)
+		t.Logf("\txVar: %f yVar: %f covar: %f", ss[i].StddevX(), ss[i].StddevY(), ss[i].Covariance())
+	}
+	out := &covar{}
+	for i := 0; i < N; i++ {
+		out.Combine(ss[i])
+		t.Logf("combine: corell: %f, y = %f*x+%f", out.Correl(), out.A(), out.B())
+		t.Logf("\txVar: %f yVar: %f covar: %f", out.StddevX(), out.StddevY(), out.Covariance())
+	}
+}
diff --git a/cmd/lotus-chainwatch/blockssub.go b/cmd/lotus-chainwatch/blockssub.go
deleted file mode 100644
index 9c5957f67..000000000
--- a/cmd/lotus-chainwatch/blockssub.go
+++ /dev/null
@@ -1,27 +0,0 @@
-package main
-
-import (
-	"context"
-
-	"github.com/filecoin-project/lotus/chain/types"
-	"github.com/ipfs/go-cid"
-
-	aapi "github.com/filecoin-project/lotus/api"
-)
-
-func subBlocks(ctx context.Context, api aapi.FullNode, st *storage) {
-	sub, err := api.SyncIncomingBlocks(ctx)
-	if err != nil {
-		log.Error(err)
-		return
-	}
-
-	for bh := range sub {
-		err := st.storeHeaders(map[cid.Cid]*types.BlockHeader{
-			bh.Cid(): bh,
-		}, false)
-		if err != nil {
-			log.Error(err)
-		}
-	}
-}
diff --git a/cmd/lotus-chainwatch/dot.go b/cmd/lotus-chainwatch/dot.go
index b3490d749..3149d65f5 100644
--- a/cmd/lotus-chainwatch/dot.go
+++ b/cmd/lotus-chainwatch/dot.go
@@ -1,12 +1,15 @@
 package main
 
 import (
+	"database/sql"
 	"fmt"
 	"hash/crc32"
 	"strconv"
 
 	"github.com/ipfs/go-cid"
-	"gopkg.in/urfave/cli.v2"
+	logging "github.com/ipfs/go-log/v2"
+	"github.com/urfave/cli/v2"
+	"golang.org/x/xerrors"
 )
 
 var dotCmd = &cli.Command{
@@ -14,19 +17,39 @@ var dotCmd = &cli.Command{
 	Usage:     "generate dot graphs",
 	ArgsUsage: "<minHeight> <toseeHeight>",
 	Action: func(cctx *cli.Context) error {
-		st, err := openStorage(cctx.String("db"))
-		if err != nil {
+		ll := cctx.String("log-level")
+		if err := logging.SetLogLevel("*", ll); err != nil {
 			return err
 		}
 
+		db, err := sql.Open("postgres", cctx.String("db"))
+		if err != nil {
+			return err
+		}
+		defer func() {
+			if err := db.Close(); err != nil {
+				log.Errorw("Failed to close database", "error", err)
+			}
+		}()
+
+		if err := db.Ping(); err != nil {
+			return xerrors.Errorf("Database failed to respond to ping (is it online?): %w", err)
+		}
+
 		minH, err := strconv.ParseInt(cctx.Args().Get(0), 10, 32)
+		if err != nil {
+			return err
+		}
 		tosee, err := strconv.ParseInt(cctx.Args().Get(1), 10, 32)
+		if err != nil {
+			return err
+		}
 		maxH := minH + tosee
 
-		res, err := st.db.Query(`select block, parent, b.miner, b.height, p.height from block_parents
+		res, err := db.Query(`select block, parent, b.miner, b.height, p.height from block_parents
     inner join blocks b on block_parents.block = b.cid
     inner join blocks p on block_parents.parent = p.cid
-where b.height > ? and b.height < ?`, minH, maxH)
+where b.height > $1 and b.height < $2`, minH, maxH)
 
 		if err != nil {
 			return err
@@ -34,6 +57,11 @@ where b.height > ? and b.height < ?`, minH, maxH)
 
 		fmt.Println("digraph D {")
 
+		hl, err := syncedBlocks(db)
+		if err != nil {
+			log.Fatal(err)
+		}
+
 		for res.Next() {
 			var block, parent, miner string
 			var height, ph uint64
@@ -46,7 +74,7 @@ where b.height > ? and b.height < ?`, minH, maxH)
 				return err
 			}
 
-			has := st.hasBlock(bc)
+			_, has := hl[bc]
 
 			col := crc32.Checksum([]byte(miner), crc32.MakeTable(crc32.Castagnoli))&0xc0c0c0c0 + 0x30303030
 
@@ -77,3 +105,27 @@ where b.height > ? and b.height < ?`, minH, maxH)
 		return nil
 	},
 }
+
+func syncedBlocks(db *sql.DB) (map[cid.Cid]struct{}, error) {
+	// timestamp is used to return a configurable amount of rows based on when they were last added.
+	rws, err := db.Query(`select cid FROM blocks_synced`)
+	if err != nil {
+		return nil, xerrors.Errorf("Failed to query blocks_synced: %w", err)
+	}
+	out := map[cid.Cid]struct{}{}
+
+	for rws.Next() {
+		var c string
+		if err := rws.Scan(&c); err != nil {
+			return nil, xerrors.Errorf("Failed to scan blocks_synced: %w", err)
+		}
+
+		ci, err := cid.Parse(c)
+		if err != nil {
+			return nil, xerrors.Errorf("Failed to parse blocks_synced: %w", err)
+		}
+
+		out[ci] = struct{}{}
+	}
+	return out, nil
+}
diff --git a/cmd/lotus-chainwatch/main.go b/cmd/lotus-chainwatch/main.go
index f808b1e81..5cb0f3507 100644
--- a/cmd/lotus-chainwatch/main.go
+++ b/cmd/lotus-chainwatch/main.go
@@ -1,104 +1,54 @@
 package main
 
 import (
-	"fmt"
-	"net/http"
 	"os"
 
-	logging "github.com/ipfs/go-log"
-	"golang.org/x/xerrors"
-	"gopkg.in/urfave/cli.v2"
-
 	"github.com/filecoin-project/lotus/build"
-	lcli "github.com/filecoin-project/lotus/cli"
+	logging "github.com/ipfs/go-log/v2"
+	"github.com/urfave/cli/v2"
 )
 
 var log = logging.Logger("chainwatch")
 
 func main() {
-	logging.SetLogLevel("*", "INFO")
-
-	log.Info("Starting chainwatch")
-
-	local := []*cli.Command{
-		runCmd,
-		dotCmd,
+	if err := logging.SetLogLevel("*", "info"); err != nil {
+		log.Fatal(err)
 	}
+	log.Info("Starting chainwatch", " v", build.UserVersion())
 
 	app := &cli.App{
 		Name:    "lotus-chainwatch",
 		Usage:   "Devnet token distribution utility",
-		Version: build.UserVersion,
+		Version: build.UserVersion(),
 		Flags: []cli.Flag{
 			&cli.StringFlag{
 				Name:    "repo",
 				EnvVars: []string{"LOTUS_PATH"},
 				Value:   "~/.lotus", // TODO: Consider XDG_DATA_HOME
 			},
+			&cli.StringFlag{
+				Name:    "api",
+				EnvVars: []string{"FULLNODE_API_INFO"},
+				Value:   "",
+			},
 			&cli.StringFlag{
 				Name:    "db",
 				EnvVars: []string{"LOTUS_DB"},
-				Value:   "./chainwatch.db",
+				Value:   "",
+			},
+			&cli.StringFlag{
+				Name:    "log-level",
+				EnvVars: []string{"GOLOG_LOG_LEVEL"},
+				Value:   "info",
 			},
 		},
-
-		Commands: local,
+		Commands: []*cli.Command{
+			dotCmd,
+			runCmd,
+		},
 	}
 
 	if err := app.Run(os.Args); err != nil {
-		log.Warnf("%+v", err)
-		return
+		log.Fatal(err)
 	}
 }
-
-var runCmd = &cli.Command{
-	Name:  "run",
-	Usage: "Start lotus chainwatch",
-	Flags: []cli.Flag{
-		&cli.StringFlag{
-			Name:  "front",
-			Value: "127.0.0.1:8418",
-		},
-	},
-	Action: func(cctx *cli.Context) error {
-		api, closer, err := lcli.GetFullNodeAPI(cctx)
-		if err != nil {
-			return err
-		}
-		defer closer()
-		ctx := lcli.ReqContext(cctx)
-
-		v, err := api.Version(ctx)
-		if err != nil {
-			return err
-		}
-
-		log.Info("Remote version: %s", v.Version)
-
-		st, err := openStorage(cctx.String("db"))
-		if err != nil {
-			return err
-		}
-		defer st.close()
-
-		runSyncer(ctx, api, st)
-		go subMpool(ctx, api, st)
-		go subBlocks(ctx, api, st)
-
-		h, err := newHandler(api, st)
-		if err != nil {
-			return xerrors.Errorf("handler setup: %w", err)
-		}
-
-		http.Handle("/", h)
-
-		fmt.Printf("Open http://%s\n", cctx.String("front"))
-
-		go func() {
-			<-ctx.Done()
-			os.Exit(0)
-		}()
-
-		return http.ListenAndServe(cctx.String("front"), nil)
-	},
-}
diff --git a/cmd/lotus-chainwatch/mpool.go b/cmd/lotus-chainwatch/mpool.go
deleted file mode 100644
index ce9e39b84..000000000
--- a/cmd/lotus-chainwatch/mpool.go
+++ /dev/null
@@ -1,38 +0,0 @@
-package main
-
-import (
-	"context"
-
-	"github.com/ipfs/go-cid"
-
-	aapi "github.com/filecoin-project/lotus/api"
-	"github.com/filecoin-project/lotus/chain/types"
-)
-
-func subMpool(ctx context.Context, api aapi.FullNode, st *storage) {
-	sub, err := api.MpoolSub(ctx)
-	if err != nil {
-		return
-	}
-
-	for change := range sub {
-		if change.Type != aapi.MpoolAdd {
-			continue
-		}
-
-		log.Info("mpool message")
-
-		err := st.storeMessages(map[cid.Cid]*types.Message{
-			change.Message.Message.Cid(): &change.Message.Message,
-		})
-		if err != nil {
-			log.Error(err)
-			continue
-		}
-
-		if err := st.storeMpoolInclusion(change.Message.Message.Cid()); err != nil {
-			log.Error(err)
-			continue
-		}
-	}
-}
diff --git a/cmd/lotus-chainwatch/processor/common_actors.go b/cmd/lotus-chainwatch/processor/common_actors.go
new file mode 100644
index 000000000..56520880c
--- /dev/null
+++ b/cmd/lotus-chainwatch/processor/common_actors.go
@@ -0,0 +1,296 @@
+package processor
+
+import (
+	"context"
+	"time"
+
+	"golang.org/x/sync/errgroup"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/abi"
+	_init "github.com/filecoin-project/lotus/chain/actors/builtin/init"
+	"github.com/filecoin-project/lotus/chain/events/state"
+	"github.com/filecoin-project/lotus/chain/types"
+	cw_util "github.com/filecoin-project/lotus/cmd/lotus-chainwatch/util"
+	"github.com/filecoin-project/specs-actors/actors/builtin"
+	"github.com/ipfs/go-cid"
+)
+
+func (p *Processor) setupCommonActors() error {
+	tx, err := p.db.Begin()
+	if err != nil {
+		return err
+	}
+
+	if _, err := tx.Exec(`
+create table if not exists id_address_map
+(
+	id text not null,
+	address text not null,
+	constraint id_address_map_pk
+		primary key (id, address)
+);
+
+create unique index if not exists id_address_map_id_uindex
+	on id_address_map (id);
+
+create unique index if not exists id_address_map_address_uindex
+	on id_address_map (address);
+
+create table if not exists actors
+  (
+	id text not null
+		constraint id_address_map_actors_id_fk
+			references id_address_map (id),
+	code text not null,
+	head text not null,
+	nonce int not null,
+	balance text not null,
+	stateroot text
+  );
+  
+create index if not exists actors_id_index
+	on actors (id);
+
+create index if not exists id_address_map_address_index
+	on id_address_map (address);
+
+create index if not exists id_address_map_id_index
+	on id_address_map (id);
+
+create or replace function actor_tips(epoch bigint)
+    returns table (id text,
+                    code text,
+                    head text,
+                    nonce int,
+                    balance text,
+                    stateroot text,
+                    height bigint,
+                    parentstateroot text) as
+$body$
+    select distinct on (id) * from actors
+        inner join state_heights sh on sh.parentstateroot = stateroot
+        where height < $1
+		order by id, height desc;
+$body$ language sql;
+
+create table if not exists actor_states
+(
+	head text not null,
+	code text not null,
+	state json not null
+);
+
+create unique index if not exists actor_states_head_code_uindex
+	on actor_states (head, code);
+
+create index if not exists actor_states_head_index
+	on actor_states (head);
+
+create index if not exists actor_states_code_head_index
+	on actor_states (head, code);
+
+`); err != nil {
+		return err
+	}
+
+	return tx.Commit()
+}
+
+func (p *Processor) HandleCommonActorsChanges(ctx context.Context, actors map[cid.Cid]ActorTips) error {
+	if err := p.storeActorAddresses(ctx, actors); err != nil {
+		return err
+	}
+
+	grp, _ := errgroup.WithContext(ctx)
+
+	grp.Go(func() error {
+		if err := p.storeActorHeads(actors); err != nil {
+			return err
+		}
+		return nil
+	})
+
+	grp.Go(func() error {
+		if err := p.storeActorStates(actors); err != nil {
+			return err
+		}
+		return nil
+	})
+
+	return grp.Wait()
+}
+
+type UpdateAddresses struct {
+	Old state.AddressPair
+	New state.AddressPair
+}
+
+func (p Processor) storeActorAddresses(ctx context.Context, actors map[cid.Cid]ActorTips) error {
+	start := time.Now()
+	defer func() {
+		log.Debugw("Stored Actor Addresses", "duration", time.Since(start).String())
+	}()
+
+	addressToID := map[address.Address]address.Address{}
+	// HACK until genesis storage is figured out:
+	addressToID[builtin.SystemActorAddr] = builtin.SystemActorAddr
+	addressToID[builtin.InitActorAddr] = builtin.InitActorAddr
+	addressToID[builtin.RewardActorAddr] = builtin.RewardActorAddr
+	addressToID[builtin.CronActorAddr] = builtin.CronActorAddr
+	addressToID[builtin.StoragePowerActorAddr] = builtin.StoragePowerActorAddr
+	addressToID[builtin.StorageMarketActorAddr] = builtin.StorageMarketActorAddr
+	addressToID[builtin.VerifiedRegistryActorAddr] = builtin.VerifiedRegistryActorAddr
+	addressToID[builtin.BurntFundsActorAddr] = builtin.BurntFundsActorAddr
+	initActor, err := p.node.StateGetActor(ctx, builtin.InitActorAddr, types.EmptyTSK)
+	if err != nil {
+		return err
+	}
+
+	initActorState, err := _init.Load(cw_util.NewAPIIpldStore(ctx, p.node), initActor)
+	if err != nil {
+		return err
+	}
+	// gross..
+	if err := initActorState.ForEachActor(func(id abi.ActorID, addr address.Address) error {
+		idAddr, err := address.NewIDAddress(uint64(id))
+		if err != nil {
+			return err
+		}
+		addressToID[addr] = idAddr
+		return nil
+	}); err != nil {
+		return err
+	}
+	tx, err := p.db.Begin()
+	if err != nil {
+		return err
+	}
+
+	if _, err := tx.Exec(`
+create temp table iam (like id_address_map excluding constraints) on commit drop;
+`); err != nil {
+		return xerrors.Errorf("prep temp: %w", err)
+	}
+
+	stmt, err := tx.Prepare(`copy iam (id, address) from STDIN `)
+	if err != nil {
+		return err
+	}
+
+	for a, i := range addressToID {
+		if i == address.Undef {
+			continue
+		}
+		if _, err := stmt.Exec(
+			i.String(),
+			a.String(),
+		); err != nil {
+			return err
+		}
+	}
+	if err := stmt.Close(); err != nil {
+		return err
+	}
+
+	// HACK until chain watch can handle reorgs we need to update this table when ID -> PubKey mappings change
+	if _, err := tx.Exec(`insert into id_address_map select * from iam on conflict (id) do update set address = EXCLUDED.address`); err != nil {
+		log.Warnw("Failed to update id_address_map table, this is a known issue")
+		return nil
+	}
+
+	return tx.Commit()
+}
+
+func (p *Processor) storeActorHeads(actors map[cid.Cid]ActorTips) error {
+	start := time.Now()
+	defer func() {
+		log.Debugw("Stored Actor Heads", "duration", time.Since(start).String())
+	}()
+	// Basic
+	tx, err := p.db.Begin()
+	if err != nil {
+		return err
+	}
+	if _, err := tx.Exec(`
+		create temp table a_tmp (like actors excluding constraints) on commit drop;
+	`); err != nil {
+		return xerrors.Errorf("prep temp: %w", err)
+	}
+
+	stmt, err := tx.Prepare(`copy a_tmp (id, code, head, nonce, balance, stateroot) from stdin `)
+	if err != nil {
+		return err
+	}
+
+	for code, actTips := range actors {
+		actorName := code.String()
+		if builtin.IsBuiltinActor(code) {
+			actorName = builtin.ActorNameByCode(code)
+		}
+		for _, actorInfo := range actTips {
+			for _, a := range actorInfo {
+				if _, err := stmt.Exec(a.addr.String(), actorName, a.act.Head.String(), a.act.Nonce, a.act.Balance.String(), a.stateroot.String()); err != nil {
+					return err
+				}
+			}
+		}
+	}
+
+	if err := stmt.Close(); err != nil {
+		return err
+	}
+
+	if _, err := tx.Exec(`insert into actors select * from a_tmp on conflict do nothing `); err != nil {
+		return xerrors.Errorf("actor put: %w", err)
+	}
+
+	return tx.Commit()
+}
+
+func (p *Processor) storeActorStates(actors map[cid.Cid]ActorTips) error {
+	start := time.Now()
+	defer func() {
+		log.Debugw("Stored Actor States", "duration", time.Since(start).String())
+	}()
+	// States
+	tx, err := p.db.Begin()
+	if err != nil {
+		return err
+	}
+	if _, err := tx.Exec(`
+		create temp table as_tmp (like actor_states excluding constraints) on commit drop;
+	`); err != nil {
+		return xerrors.Errorf("prep temp: %w", err)
+	}
+
+	stmt, err := tx.Prepare(`copy as_tmp (head, code, state) from stdin `)
+	if err != nil {
+		return err
+	}
+
+	for code, actTips := range actors {
+		actorName := code.String()
+		if builtin.IsBuiltinActor(code) {
+			actorName = builtin.ActorNameByCode(code)
+		}
+		for _, actorInfo := range actTips {
+			for _, a := range actorInfo {
+				if _, err := stmt.Exec(a.act.Head.String(), actorName, a.state); err != nil {
+					return err
+				}
+			}
+		}
+	}
+
+	if err := stmt.Close(); err != nil {
+		return err
+	}
+
+	if _, err := tx.Exec(`insert into actor_states select * from as_tmp on conflict do nothing `); err != nil {
+		return xerrors.Errorf("actor put: %w", err)
+	}
+
+	return tx.Commit()
+}
diff --git a/cmd/lotus-chainwatch/processor/market.go b/cmd/lotus-chainwatch/processor/market.go
new file mode 100644
index 000000000..17aa1c37b
--- /dev/null
+++ b/cmd/lotus-chainwatch/processor/market.go
@@ -0,0 +1,316 @@
+package processor
+
+import (
+	"context"
+	"strconv"
+	"time"
+
+	"golang.org/x/sync/errgroup"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/lotus/chain/actors/builtin/market"
+	"github.com/filecoin-project/lotus/chain/events/state"
+)
+
+func (p *Processor) setupMarket() error {
+	tx, err := p.db.Begin()
+	if err != nil {
+		return err
+	}
+
+	if _, err := tx.Exec(`
+create table if not exists market_deal_proposals
+(
+    deal_id bigint not null,
+    
+    state_root text not null,
+    
+    piece_cid text not null,
+    padded_piece_size bigint not null,
+    unpadded_piece_size bigint not null,
+    is_verified bool not null,
+    
+    client_id text not null,
+    provider_id text not null,
+    
+    start_epoch bigint not null,
+    end_epoch bigint not null,
+    slashed_epoch bigint,
+    storage_price_per_epoch text not null,
+    
+    provider_collateral text not null,
+    client_collateral text not null,
+    
+   constraint market_deal_proposal_pk
+ 		primary key (deal_id)
+);
+
+create table if not exists market_deal_states 
+(
+    deal_id bigint not null,
+    
+    sector_start_epoch bigint not null,
+    last_update_epoch bigint not null,
+    slash_epoch bigint not null,
+    
+    state_root text not null,
+    
+	unique (deal_id, sector_start_epoch, last_update_epoch, slash_epoch),
+ 
+	constraint market_deal_states_pk
+		primary key (deal_id, state_root)
+    
+);
+
+create table if not exists minerid_dealid_sectorid 
+(
+    deal_id bigint not null
+        constraint sectors_sector_ids_id_fk
+            references market_deal_proposals(deal_id),
+
+    sector_id bigint not null,
+    miner_id text not null,
+    foreign key (sector_id, miner_id) references sector_precommit_info(sector_id, miner_id),
+
+    constraint miner_sector_deal_ids_pk
+        primary key (miner_id, sector_id, deal_id)
+);
+
+`); err != nil {
+		return err
+	}
+
+	return tx.Commit()
+}
+
+type marketActorInfo struct {
+	common actorInfo
+}
+
+func (p *Processor) HandleMarketChanges(ctx context.Context, marketTips ActorTips) error {
+	marketChanges, err := p.processMarket(ctx, marketTips)
+	if err != nil {
+		log.Fatalw("Failed to process market actors", "error", err)
+	}
+
+	if err := p.persistMarket(ctx, marketChanges); err != nil {
+		log.Fatalw("Failed to persist market actors", "error", err)
+	}
+
+	if err := p.updateMarket(ctx, marketChanges); err != nil {
+		log.Fatalw("Failed to update market actors", "error", err)
+	}
+	return nil
+}
+
+func (p *Processor) processMarket(ctx context.Context, marketTips ActorTips) ([]marketActorInfo, error) {
+	start := time.Now()
+	defer func() {
+		log.Debugw("Processed Market", "duration", time.Since(start).String())
+	}()
+
+	var out []marketActorInfo
+	for _, markets := range marketTips {
+		for _, mt := range markets {
+			// NB: here is where we can extract the market state when we need it.
+			out = append(out, marketActorInfo{common: mt})
+		}
+	}
+	return out, nil
+}
+
+func (p *Processor) persistMarket(ctx context.Context, info []marketActorInfo) error {
+	start := time.Now()
+	defer func() {
+		log.Debugw("Persisted Market", "duration", time.Since(start).String())
+	}()
+
+	grp, ctx := errgroup.WithContext(ctx)
+
+	grp.Go(func() error {
+		if err := p.storeMarketActorDealProposals(ctx, info); err != nil {
+			return xerrors.Errorf("Failed to store marker deal proposals: %w", err)
+		}
+		return nil
+	})
+
+	grp.Go(func() error {
+		if err := p.storeMarketActorDealStates(info); err != nil {
+			return xerrors.Errorf("Failed to store marker deal states: %w", err)
+		}
+		return nil
+	})
+
+	return grp.Wait()
+
+}
+
+func (p *Processor) updateMarket(ctx context.Context, info []marketActorInfo) error {
+	if err := p.updateMarketActorDealProposals(ctx, info); err != nil {
+		return xerrors.Errorf("Failed to update market info: %w", err)
+	}
+	return nil
+}
+
+func (p *Processor) storeMarketActorDealStates(marketTips []marketActorInfo) error {
+	start := time.Now()
+	defer func() {
+		log.Debugw("Stored Market Deal States", "duration", time.Since(start).String())
+	}()
+	tx, err := p.db.Begin()
+	if err != nil {
+		return err
+	}
+	if _, err := tx.Exec(`create temp table mds (like market_deal_states excluding constraints) on commit drop;`); err != nil {
+		return err
+	}
+	stmt, err := tx.Prepare(`copy mds (deal_id, sector_start_epoch, last_update_epoch, slash_epoch, state_root) from STDIN`)
+	if err != nil {
+		return err
+	}
+	for _, mt := range marketTips {
+		dealStates, err := p.node.StateMarketDeals(context.TODO(), mt.common.tsKey)
+		if err != nil {
+			return err
+		}
+
+		for dealID, ds := range dealStates {
+			id, err := strconv.ParseUint(dealID, 10, 64)
+			if err != nil {
+				return err
+			}
+
+			if _, err := stmt.Exec(
+				id,
+				ds.State.SectorStartEpoch,
+				ds.State.LastUpdatedEpoch,
+				ds.State.SlashEpoch,
+				mt.common.stateroot.String(),
+			); err != nil {
+				return err
+			}
+
+		}
+	}
+	if err := stmt.Close(); err != nil {
+		return err
+	}
+
+	if _, err := tx.Exec(`insert into market_deal_states select * from mds on conflict do nothing`); err != nil {
+		return err
+	}
+
+	return tx.Commit()
+}
+
+func (p *Processor) storeMarketActorDealProposals(ctx context.Context, marketTips []marketActorInfo) error {
+	start := time.Now()
+	defer func() {
+		log.Debugw("Stored Market Deal Proposals", "duration", time.Since(start).String())
+	}()
+	tx, err := p.db.Begin()
+	if err != nil {
+		return err
+	}
+
+	if _, err := tx.Exec(`create temp table mdp (like market_deal_proposals excluding constraints) on commit drop;`); err != nil {
+		return xerrors.Errorf("prep temp: %w", err)
+	}
+
+	stmt, err := tx.Prepare(`copy mdp (deal_id, state_root, piece_cid, padded_piece_size, unpadded_piece_size, is_verified, client_id, provider_id, start_epoch, end_epoch, slashed_epoch, storage_price_per_epoch, provider_collateral, client_collateral) from STDIN`)
+	if err != nil {
+		return err
+	}
+
+	// insert in sorted order (lowest height -> highest height) since dealid is pk of table.
+	for _, mt := range marketTips {
+		dealStates, err := p.node.StateMarketDeals(ctx, mt.common.tsKey)
+		if err != nil {
+			return err
+		}
+
+		for dealID, ds := range dealStates {
+			id, err := strconv.ParseUint(dealID, 10, 64)
+			if err != nil {
+				return err
+			}
+
+			if _, err := stmt.Exec(
+				id,
+				mt.common.stateroot.String(),
+				ds.Proposal.PieceCID.String(),
+				ds.Proposal.PieceSize,
+				ds.Proposal.PieceSize.Unpadded(),
+				ds.Proposal.VerifiedDeal,
+				ds.Proposal.Client.String(),
+				ds.Proposal.Provider.String(),
+				ds.Proposal.StartEpoch,
+				ds.Proposal.EndEpoch,
+				nil, // slashed_epoch
+				ds.Proposal.StoragePricePerEpoch.String(),
+				ds.Proposal.ProviderCollateral.String(),
+				ds.Proposal.ClientCollateral.String(),
+			); err != nil {
+				return err
+			}
+
+		}
+	}
+	if err := stmt.Close(); err != nil {
+		return err
+	}
+	if _, err := tx.Exec(`insert into market_deal_proposals select * from mdp on conflict do nothing`); err != nil {
+		return err
+	}
+
+	return tx.Commit()
+
+}
+
+func (p *Processor) updateMarketActorDealProposals(ctx context.Context, marketTip []marketActorInfo) error {
+	start := time.Now()
+	defer func() {
+		log.Debugw("Updated Market Deal Proposals", "duration", time.Since(start).String())
+	}()
+	pred := state.NewStatePredicates(p.node)
+
+	tx, err := p.db.Begin()
+	if err != nil {
+		return err
+	}
+
+	stmt, err := tx.Prepare(`update market_deal_proposals set slashed_epoch=$1 where deal_id=$2`)
+	if err != nil {
+		return err
+	}
+
+	for _, mt := range marketTip {
+		stateDiff := pred.OnStorageMarketActorChanged(pred.OnDealStateChanged(pred.OnDealStateAmtChanged()))
+
+		changed, val, err := stateDiff(ctx, mt.common.parentTsKey, mt.common.tsKey)
+		if err != nil {
+			log.Warnw("error getting market deal state diff", "error", err)
+		}
+		if !changed {
+			continue
+		}
+		changes, ok := val.(*market.DealStateChanges)
+		if !ok {
+			return xerrors.Errorf("Unknown type returned by Deal State AMT predicate: %T", val)
+		}
+
+		for _, modified := range changes.Modified {
+			if modified.From.SlashEpoch != modified.To.SlashEpoch {
+				if _, err := stmt.Exec(modified.To.SlashEpoch, modified.ID); err != nil {
+					return err
+				}
+			}
+		}
+	}
+
+	if err := stmt.Close(); err != nil {
+		return err
+	}
+
+	return tx.Commit()
+}
diff --git a/cmd/lotus-chainwatch/processor/messages.go b/cmd/lotus-chainwatch/processor/messages.go
new file mode 100644
index 000000000..333477c6a
--- /dev/null
+++ b/cmd/lotus-chainwatch/processor/messages.go
@@ -0,0 +1,318 @@
+package processor
+
+import (
+	"context"
+	"sync"
+
+	"golang.org/x/sync/errgroup"
+	"golang.org/x/xerrors"
+
+	"github.com/ipfs/go-cid"
+
+	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/lib/parmap"
+)
+
+func (p *Processor) setupMessages() error {
+	tx, err := p.db.Begin()
+	if err != nil {
+		return err
+	}
+
+	if _, err := tx.Exec(`
+create table if not exists messages
+(
+	cid text not null
+		constraint messages_pk
+			primary key,
+	"from" text not null,
+	"to" text not null,
+	size_bytes bigint not null,
+	nonce bigint not null,
+	value text not null,
+	gas_fee_cap text not null,
+	gas_premium text not null,
+	gas_limit bigint not null,
+	method bigint,
+	params bytea
+);
+
+create unique index if not exists messages_cid_uindex
+	on messages (cid);
+
+create index if not exists messages_from_index
+	on messages ("from");
+
+create index if not exists messages_to_index
+	on messages ("to");
+
+create table if not exists block_messages
+(
+	block text not null
+	    constraint blocks_block_cids_cid_fk
+			references block_cids (cid),
+	message text not null,
+	constraint block_messages_pk
+		primary key (block, message)
+);
+
+create table if not exists mpool_messages
+(
+	msg text not null
+		constraint mpool_messages_pk
+			primary key
+		constraint mpool_messages_messages_cid_fk
+			references messages,
+	add_ts int not null
+);
+
+create unique index if not exists mpool_messages_msg_uindex
+	on mpool_messages (msg);
+
+create table if not exists receipts
+(
+	msg text not null,
+	state text not null,
+	idx int not null,
+	exit int not null,
+	gas_used bigint not null,
+	return bytea,
+	constraint receipts_pk
+		primary key (msg, state)
+);
+
+create index if not exists receipts_msg_state_index
+	on receipts (msg, state);
+`); err != nil {
+		return err
+	}
+
+	return tx.Commit()
+}
+
+func (p *Processor) HandleMessageChanges(ctx context.Context, blocks map[cid.Cid]*types.BlockHeader) error {
+	if err := p.persistMessagesAndReceipts(ctx, blocks); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (p *Processor) persistMessagesAndReceipts(ctx context.Context, blocks map[cid.Cid]*types.BlockHeader) error {
+	messages, inclusions := p.fetchMessages(ctx, blocks)
+	receipts := p.fetchParentReceipts(ctx, blocks)
+
+	grp, _ := errgroup.WithContext(ctx)
+
+	grp.Go(func() error {
+		return p.storeMessages(messages)
+	})
+
+	grp.Go(func() error {
+		return p.storeMsgInclusions(inclusions)
+	})
+
+	grp.Go(func() error {
+		return p.storeReceipts(receipts)
+	})
+
+	return grp.Wait()
+}
+
+func (p *Processor) storeReceipts(recs map[mrec]*types.MessageReceipt) error {
+	tx, err := p.db.Begin()
+	if err != nil {
+		return err
+	}
+
+	if _, err := tx.Exec(`
+create temp table recs (like receipts excluding constraints) on commit drop;
+`); err != nil {
+		return xerrors.Errorf("prep temp: %w", err)
+	}
+
+	stmt, err := tx.Prepare(`copy recs (msg, state, idx, exit, gas_used, return) from stdin `)
+	if err != nil {
+		return err
+	}
+
+	for c, m := range recs {
+		if _, err := stmt.Exec(
+			c.msg.String(),
+			c.state.String(),
+			c.idx,
+			m.ExitCode,
+			m.GasUsed,
+			m.Return,
+		); err != nil {
+			return err
+		}
+	}
+	if err := stmt.Close(); err != nil {
+		return err
+	}
+
+	if _, err := tx.Exec(`insert into receipts select * from recs on conflict do nothing `); err != nil {
+		return xerrors.Errorf("actor put: %w", err)
+	}
+
+	return tx.Commit()
+}
+
+func (p *Processor) storeMsgInclusions(incls map[cid.Cid][]cid.Cid) error {
+	tx, err := p.db.Begin()
+	if err != nil {
+		return err
+	}
+
+	if _, err := tx.Exec(`
+create temp table mi (like block_messages excluding constraints) on commit drop;
+`); err != nil {
+		return xerrors.Errorf("prep temp: %w", err)
+	}
+
+	stmt, err := tx.Prepare(`copy mi (block, message) from STDIN `)
+	if err != nil {
+		return err
+	}
+
+	for b, msgs := range incls {
+		for _, msg := range msgs {
+			if _, err := stmt.Exec(
+				b.String(),
+				msg.String(),
+			); err != nil {
+				return err
+			}
+		}
+	}
+	if err := stmt.Close(); err != nil {
+		return err
+	}
+
+	if _, err := tx.Exec(`insert into block_messages select * from mi on conflict do nothing `); err != nil {
+		return xerrors.Errorf("actor put: %w", err)
+	}
+
+	return tx.Commit()
+}
+
+func (p *Processor) storeMessages(msgs map[cid.Cid]*types.Message) error {
+	tx, err := p.db.Begin()
+	if err != nil {
+		return err
+	}
+
+	if _, err := tx.Exec(`
+create temp table msgs (like messages excluding constraints) on commit drop;
+`); err != nil {
+		return xerrors.Errorf("prep temp: %w", err)
+	}
+
+	stmt, err := tx.Prepare(`copy msgs (cid, "from", "to", size_bytes, nonce, "value", gas_premium, gas_fee_cap, gas_limit, method, params) from stdin `)
+	if err != nil {
+		return err
+	}
+
+	for c, m := range msgs {
+		var msgBytes int
+		if b, err := m.Serialize(); err == nil {
+			msgBytes = len(b)
+		}
+
+		if _, err := stmt.Exec(
+			c.String(),
+			m.From.String(),
+			m.To.String(),
+			msgBytes,
+			m.Nonce,
+			m.Value.String(),
+			m.GasPremium.String(),
+			m.GasFeeCap.String(),
+			m.GasLimit,
+			m.Method,
+			m.Params,
+		); err != nil {
+			return err
+		}
+	}
+	if err := stmt.Close(); err != nil {
+		return err
+	}
+
+	if _, err := tx.Exec(`insert into messages select * from msgs on conflict do nothing `); err != nil {
+		return xerrors.Errorf("actor put: %w", err)
+	}
+
+	return tx.Commit()
+}
+
+func (p *Processor) fetchMessages(ctx context.Context, blocks map[cid.Cid]*types.BlockHeader) (map[cid.Cid]*types.Message, map[cid.Cid][]cid.Cid) {
+	var lk sync.Mutex
+	messages := map[cid.Cid]*types.Message{}
+	inclusions := map[cid.Cid][]cid.Cid{} // block -> msgs
+
+	parmap.Par(50, parmap.MapArr(blocks), func(header *types.BlockHeader) {
+		msgs, err := p.node.ChainGetBlockMessages(ctx, header.Cid())
+		if err != nil {
+			log.Error(err)
+			log.Debugw("ChainGetBlockMessages", "header_cid", header.Cid())
+			return
+		}
+
+		vmm := make([]*types.Message, 0, len(msgs.Cids))
+		for _, m := range msgs.BlsMessages {
+			vmm = append(vmm, m)
+		}
+
+		for _, m := range msgs.SecpkMessages {
+			vmm = append(vmm, &m.Message)
+		}
+
+		lk.Lock()
+		for _, message := range vmm {
+			messages[message.Cid()] = message
+			inclusions[header.Cid()] = append(inclusions[header.Cid()], message.Cid())
+		}
+		lk.Unlock()
+	})
+
+	return messages, inclusions
+}
+
+type mrec struct {
+	msg   cid.Cid
+	state cid.Cid
+	idx   int
+}
+
+func (p *Processor) fetchParentReceipts(ctx context.Context, toSync map[cid.Cid]*types.BlockHeader) map[mrec]*types.MessageReceipt {
+	var lk sync.Mutex
+	out := map[mrec]*types.MessageReceipt{}
+
+	parmap.Par(50, parmap.MapArr(toSync), func(header *types.BlockHeader) {
+		recs, err := p.node.ChainGetParentReceipts(ctx, header.Cid())
+		if err != nil {
+			log.Error(err)
+			log.Debugw("ChainGetParentReceipts", "header_cid", header.Cid())
+			return
+		}
+		msgs, err := p.node.ChainGetParentMessages(ctx, header.Cid())
+		if err != nil {
+			log.Error(err)
+			log.Debugw("ChainGetParentMessages", "header_cid", header.Cid())
+			return
+		}
+
+		lk.Lock()
+		for i, r := range recs {
+			out[mrec{
+				msg:   msgs[i].Cid,
+				state: header.ParentStateRoot,
+				idx:   i,
+			}] = r
+		}
+		lk.Unlock()
+	})
+
+	return out
+}
diff --git a/cmd/lotus-chainwatch/processor/miner.go b/cmd/lotus-chainwatch/processor/miner.go
new file mode 100644
index 000000000..3a37a82f8
--- /dev/null
+++ b/cmd/lotus-chainwatch/processor/miner.go
@@ -0,0 +1,1035 @@
+package processor
+
+import (
+	"context"
+	"strings"
+	"time"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-bitfield"
+	"github.com/ipfs/go-cid"
+	"golang.org/x/sync/errgroup"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/big"
+
+	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/api/apibstore"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/power"
+	"github.com/filecoin-project/lotus/chain/events/state"
+	"github.com/filecoin-project/lotus/chain/store"
+	"github.com/filecoin-project/lotus/chain/types"
+	cw_util "github.com/filecoin-project/lotus/cmd/lotus-chainwatch/util"
+)
+
+func (p *Processor) setupMiners() error {
+	tx, err := p.db.Begin()
+	if err != nil {
+		return err
+	}
+
+	if _, err := tx.Exec(`
+
+create table if not exists miner_info
+(
+	miner_id text not null,
+	owner_addr text not null,
+	worker_addr text not null,
+	peer_id text,
+	sector_size text not null,
+	
+	constraint miner_info_pk
+		primary key (miner_id)
+);
+
+create table if not exists sector_precommit_info
+(
+    miner_id text not null,
+    sector_id bigint not null,
+    sealed_cid text not null,
+    state_root text not null,
+    
+    seal_rand_epoch bigint not null,
+    expiration_epoch bigint not null,
+    
+    precommit_deposit text not null,
+    precommit_epoch bigint not null,
+    deal_weight text not null,
+    verified_deal_weight text not null,
+    
+    
+    is_replace_capacity bool not null,
+    replace_sector_deadline bigint,
+    replace_sector_partition bigint,
+    replace_sector_number bigint,
+    
+    unique (miner_id, sector_id),
+    
+    constraint sector_precommit_info_pk
+		primary key (miner_id, sector_id, sealed_cid)
+    
+);
+
+create table if not exists sector_info
+(
+    miner_id text not null,
+    sector_id bigint not null,
+    sealed_cid text not null,
+    state_root text not null,
+    
+    activation_epoch bigint not null,
+    expiration_epoch bigint not null,
+    
+    deal_weight text not null,
+    verified_deal_weight text not null,
+    
+    initial_pledge text not null,
+	expected_day_reward text not null,
+	expected_storage_pledge text not null,
+    
+    constraint sector_info_pk
+		primary key (miner_id, sector_id, sealed_cid)
+);
+
+/*
+* captures miner-specific power state for any given stateroot
+*/
+create table if not exists miner_power
+(
+	miner_id text not null,
+	state_root text not null,
+	raw_bytes_power text not null,
+	quality_adjusted_power text not null,
+	constraint miner_power_pk
+		primary key (miner_id, state_root)
+);
+
+DO $$
+BEGIN
+    IF NOT EXISTS (SELECT 1 FROM pg_type WHERE typname = 'miner_sector_event_type') THEN
+        CREATE TYPE miner_sector_event_type AS ENUM
+        (
+            'PRECOMMIT_ADDED', 'PRECOMMIT_EXPIRED', 'COMMIT_CAPACITY_ADDED', 'SECTOR_ADDED',
+            'SECTOR_EXTENDED', 'SECTOR_EXPIRED', 'SECTOR_FAULTED', 'SECTOR_RECOVERING', 'SECTOR_RECOVERED', 'SECTOR_TERMINATED'
+        );
+    END IF;
+END$$;
+
+create table if not exists miner_sector_events
+(
+    miner_id text not null,
+    sector_id bigint not null,
+    state_root text not null,
+    event miner_sector_event_type not null,
+    
+	constraint miner_sector_events_pk
+		primary key (sector_id, event, miner_id, state_root)
+);
+
+`); err != nil {
+		return err
+	}
+
+	return tx.Commit()
+}
+
+type SectorLifecycleEvent string
+
+const (
+	PreCommitAdded   = "PRECOMMIT_ADDED"
+	PreCommitExpired = "PRECOMMIT_EXPIRED"
+
+	CommitCapacityAdded = "COMMIT_CAPACITY_ADDED"
+
+	SectorAdded      = "SECTOR_ADDED"
+	SectorExpired    = "SECTOR_EXPIRED"
+	SectorExtended   = "SECTOR_EXTENDED"
+	SectorFaulted    = "SECTOR_FAULTED"
+	SectorRecovering = "SECTOR_RECOVERING"
+	SectorRecovered  = "SECTOR_RECOVERED"
+	SectorTerminated = "SECTOR_TERMINATED"
+)
+
+type MinerSectorsEvent struct {
+	MinerID   address.Address
+	SectorIDs []uint64
+	StateRoot cid.Cid
+	Event     SectorLifecycleEvent
+}
+
+type SectorDealEvent struct {
+	MinerID  address.Address
+	SectorID uint64
+	DealIDs  []abi.DealID
+}
+
+type PartitionStatus struct {
+	Terminated bitfield.BitField
+	Expired    bitfield.BitField
+	Faulted    bitfield.BitField
+	InRecovery bitfield.BitField
+	Recovered  bitfield.BitField
+}
+
+type minerActorInfo struct {
+	common actorInfo
+
+	state miner.State
+
+	// tracked by power actor
+	rawPower big.Int
+	qalPower big.Int
+}
+
+func (p *Processor) HandleMinerChanges(ctx context.Context, minerTips ActorTips) error {
+	minerChanges, err := p.processMiners(ctx, minerTips)
+	if err != nil {
+		log.Fatalw("Failed to process miner actors", "error", err)
+	}
+
+	if err := p.persistMiners(ctx, minerChanges); err != nil {
+		log.Fatalw("Failed to persist miner actors", "error", err)
+	}
+
+	return nil
+}
+
+func (p *Processor) processMiners(ctx context.Context, minerTips map[types.TipSetKey][]actorInfo) ([]minerActorInfo, error) {
+	start := time.Now()
+	defer func() {
+		log.Debugw("Processed Miners", "duration", time.Since(start).String())
+	}()
+
+	stor := store.ActorStore(ctx, apibstore.NewAPIBlockstore(p.node))
+
+	var out []minerActorInfo
+	// TODO add parallel calls if this becomes slow
+	for tipset, miners := range minerTips {
+		// get the power actors claims map
+		powerState, err := getPowerActorState(ctx, p.node, tipset)
+		if err != nil {
+			return nil, err
+		}
+
+		// Get miner raw and quality power
+		for _, act := range miners {
+			var mi minerActorInfo
+			mi.common = act
+
+			// get miner claim from power actors claim map and store if found, else the miner had no claim at
+			// this tipset
+			claim, found, err := powerState.MinerPower(act.addr)
+			if err != nil {
+				return nil, err
+			}
+			if found {
+				mi.qalPower = claim.QualityAdjPower
+				mi.rawPower = claim.RawBytePower
+			}
+
+			// Get the miner state
+			mas, err := miner.Load(stor, &act.act)
+			if err != nil {
+				log.Warnw("failed to find miner actor state", "address", act.addr, "error", err)
+				continue
+			}
+			mi.state = mas
+			out = append(out, mi)
+		}
+	}
+	return out, nil
+}
+
+func (p *Processor) persistMiners(ctx context.Context, miners []minerActorInfo) error {
+	start := time.Now()
+	defer func() {
+		log.Debugw("Persisted Miners", "duration", time.Since(start).String())
+	}()
+
+	grp, _ := errgroup.WithContext(ctx)
+
+	grp.Go(func() error {
+		if err := p.storeMinersPower(miners); err != nil {
+			return err
+		}
+		return nil
+	})
+
+	grp.Go(func() error {
+		if err := p.storeMinersActorInfoState(ctx, miners); err != nil {
+			return err
+		}
+		return nil
+	})
+
+	// 8 is arbitrary, idk what a good value here is.
+	preCommitEvents := make(chan *MinerSectorsEvent, 8)
+	sectorEvents := make(chan *MinerSectorsEvent, 8)
+	partitionEvents := make(chan *MinerSectorsEvent, 8)
+	dealEvents := make(chan *SectorDealEvent, 8)
+
+	grp.Go(func() error {
+		return p.storePreCommitDealInfo(dealEvents)
+	})
+
+	grp.Go(func() error {
+		return p.storeMinerSectorEvents(ctx, sectorEvents, preCommitEvents, partitionEvents)
+	})
+
+	grp.Go(func() error {
+		defer func() {
+			close(preCommitEvents)
+			close(dealEvents)
+		}()
+		return p.storeMinerPreCommitInfo(ctx, miners, preCommitEvents, dealEvents)
+	})
+
+	grp.Go(func() error {
+		defer close(sectorEvents)
+		return p.storeMinerSectorInfo(ctx, miners, sectorEvents)
+	})
+
+	grp.Go(func() error {
+		defer close(partitionEvents)
+		return p.getMinerPartitionsDifferences(ctx, miners, partitionEvents)
+	})
+
+	return grp.Wait()
+}
+
+func (p *Processor) storeMinerPreCommitInfo(ctx context.Context, miners []minerActorInfo, sectorEvents chan<- *MinerSectorsEvent, sectorDeals chan<- *SectorDealEvent) error {
+	tx, err := p.db.Begin()
+	if err != nil {
+		return err
+	}
+
+	if _, err := tx.Exec(`create temp table spi (like sector_precommit_info excluding constraints) on commit drop;`); err != nil {
+		return xerrors.Errorf("Failed to create temp table for sector_precommit_info: %w", err)
+	}
+
+	stmt, err := tx.Prepare(`copy spi (miner_id, sector_id, sealed_cid, state_root, seal_rand_epoch, expiration_epoch, precommit_deposit, precommit_epoch, deal_weight, verified_deal_weight, is_replace_capacity, replace_sector_deadline, replace_sector_partition, replace_sector_number) from STDIN`)
+
+	if err != nil {
+		return xerrors.Errorf("Failed to prepare miner precommit info statement: %w", err)
+	}
+
+	grp, _ := errgroup.WithContext(ctx)
+	for _, m := range miners {
+		m := m
+		grp.Go(func() error {
+			changes, err := p.getMinerPreCommitChanges(ctx, m)
+			if err != nil {
+				if strings.Contains(err.Error(), types.ErrActorNotFound.Error()) {
+					return nil
+				}
+				return err
+			}
+			if changes == nil {
+				return nil
+			}
+
+			preCommitAdded := make([]uint64, len(changes.Added))
+			for i, added := range changes.Added {
+				if len(added.Info.DealIDs) > 0 {
+					sectorDeals <- &SectorDealEvent{
+						MinerID:  m.common.addr,
+						SectorID: uint64(added.Info.SectorNumber),
+						DealIDs:  added.Info.DealIDs,
+					}
+				}
+				if added.Info.ReplaceCapacity {
+					if _, err := stmt.Exec(
+						m.common.addr.String(),
+						added.Info.SectorNumber,
+						added.Info.SealedCID.String(),
+						m.common.stateroot.String(),
+						added.Info.SealRandEpoch,
+						added.Info.Expiration,
+						added.PreCommitDeposit.String(),
+						added.PreCommitEpoch,
+						added.DealWeight.String(),
+						added.VerifiedDealWeight.String(),
+						added.Info.ReplaceCapacity,
+						added.Info.ReplaceSectorDeadline,
+						added.Info.ReplaceSectorPartition,
+						added.Info.ReplaceSectorNumber,
+					); err != nil {
+						return err
+					}
+				} else {
+					if _, err := stmt.Exec(
+						m.common.addr.String(),
+						added.Info.SectorNumber,
+						added.Info.SealedCID.String(),
+						m.common.stateroot.String(),
+						added.Info.SealRandEpoch,
+						added.Info.Expiration,
+						added.PreCommitDeposit.String(),
+						added.PreCommitEpoch,
+						added.DealWeight.String(),
+						added.VerifiedDealWeight.String(),
+						added.Info.ReplaceCapacity,
+						nil, // replace deadline
+						nil, // replace partition
+						nil, // replace sector
+					); err != nil {
+						return err
+					}
+
+				}
+				preCommitAdded[i] = uint64(added.Info.SectorNumber)
+			}
+			if len(preCommitAdded) > 0 {
+				sectorEvents <- &MinerSectorsEvent{
+					MinerID:   m.common.addr,
+					StateRoot: m.common.stateroot,
+					SectorIDs: preCommitAdded,
+					Event:     PreCommitAdded,
+				}
+			}
+			var preCommitExpired []uint64
+			for _, removed := range changes.Removed {
+				// TODO: we can optimize this to not load the AMT every time, if necessary.
+				si, err := m.state.GetSector(removed.Info.SectorNumber)
+				if err != nil {
+					return err
+				}
+				if si == nil {
+					preCommitExpired = append(preCommitExpired, uint64(removed.Info.SectorNumber))
+				}
+			}
+			if len(preCommitExpired) > 0 {
+				sectorEvents <- &MinerSectorsEvent{
+					MinerID:   m.common.addr,
+					StateRoot: m.common.stateroot,
+					SectorIDs: preCommitExpired,
+					Event:     PreCommitExpired,
+				}
+			}
+			return nil
+		})
+	}
+	if err := grp.Wait(); err != nil {
+		return err
+	}
+
+	if err := stmt.Close(); err != nil {
+		return xerrors.Errorf("Failed to close sector precommit info statement: %w", err)
+	}
+
+	if _, err := tx.Exec(`insert into sector_precommit_info select * from spi on conflict do nothing`); err != nil {
+		return xerrors.Errorf("Failed to insert into sector precommit info table: %w", err)
+	}
+
+	if err := tx.Commit(); err != nil {
+		return xerrors.Errorf("Failed to commit sector precommit info: %w", err)
+	}
+	return nil
+}
+
+func (p *Processor) storeMinerSectorInfo(ctx context.Context, miners []minerActorInfo, events chan<- *MinerSectorsEvent) error {
+	tx, err := p.db.Begin()
+	if err != nil {
+		return err
+	}
+
+	if _, err := tx.Exec(`create temp table si (like sector_info excluding constraints) on commit drop;`); err != nil {
+		return xerrors.Errorf("Failed to create temp table for sector_: %w", err)
+	}
+
+	stmt, err := tx.Prepare(`copy si (miner_id, sector_id, sealed_cid, state_root, activation_epoch, expiration_epoch, deal_weight, verified_deal_weight, initial_pledge, expected_day_reward, expected_storage_pledge) from STDIN`)
+	if err != nil {
+		return xerrors.Errorf("Failed to prepare miner sector info statement: %w", err)
+	}
+
+	grp, _ := errgroup.WithContext(ctx)
+	for _, m := range miners {
+		m := m
+		grp.Go(func() error {
+			changes, err := p.getMinerSectorChanges(ctx, m)
+			if err != nil {
+				if strings.Contains(err.Error(), types.ErrActorNotFound.Error()) {
+					return nil
+				}
+				return err
+			}
+			if changes == nil {
+				return nil
+			}
+			var sectorsAdded []uint64
+			var ccAdded []uint64
+			var extended []uint64
+			for _, added := range changes.Added {
+				// add the sector to the table
+				if _, err := stmt.Exec(
+					m.common.addr.String(),
+					added.SectorNumber,
+					added.SealedCID.String(),
+					m.common.stateroot.String(),
+					added.Activation.String(),
+					added.Expiration.String(),
+					added.DealWeight.String(),
+					added.VerifiedDealWeight.String(),
+					added.InitialPledge.String(),
+					added.ExpectedDayReward.String(),
+					added.ExpectedStoragePledge.String(),
+				); err != nil {
+					log.Errorw("writing miner sector changes statement", "error", err.Error())
+				}
+				if len(added.DealIDs) == 0 {
+					ccAdded = append(ccAdded, uint64(added.SectorNumber))
+				} else {
+					sectorsAdded = append(sectorsAdded, uint64(added.SectorNumber))
+				}
+			}
+
+			for _, mod := range changes.Extended {
+				extended = append(extended, uint64(mod.To.SectorNumber))
+			}
+
+			events <- &MinerSectorsEvent{
+				MinerID:   m.common.addr,
+				StateRoot: m.common.stateroot,
+				SectorIDs: ccAdded,
+				Event:     CommitCapacityAdded,
+			}
+			events <- &MinerSectorsEvent{
+				MinerID:   m.common.addr,
+				StateRoot: m.common.stateroot,
+				SectorIDs: sectorsAdded,
+				Event:     SectorAdded,
+			}
+			events <- &MinerSectorsEvent{
+				MinerID:   m.common.addr,
+				StateRoot: m.common.stateroot,
+				SectorIDs: extended,
+				Event:     SectorExtended,
+			}
+			return nil
+		})
+	}
+
+	if err := grp.Wait(); err != nil {
+		return err
+	}
+
+	if err := stmt.Close(); err != nil {
+		return xerrors.Errorf("Failed to close sector info statement: %w", err)
+	}
+
+	if _, err := tx.Exec(`insert into sector_info select * from si on conflict do nothing`); err != nil {
+		return xerrors.Errorf("Failed to insert into sector info table: %w", err)
+	}
+
+	if err := tx.Commit(); err != nil {
+		return xerrors.Errorf("Failed to commit sector info: %w", err)
+	}
+	return nil
+
+}
+
+func (p *Processor) getMinerPartitionsDifferences(ctx context.Context, miners []minerActorInfo, events chan<- *MinerSectorsEvent) error {
+	grp, ctx := errgroup.WithContext(ctx)
+	for _, m := range miners {
+		m := m
+		grp.Go(func() error {
+			if err := p.diffMinerPartitions(ctx, m, events); err != nil {
+				if strings.Contains(err.Error(), types.ErrActorNotFound.Error()) {
+					return nil
+				}
+				return err
+			}
+			return nil
+		})
+	}
+	return grp.Wait()
+}
+
+func (p *Processor) storeMinerSectorEvents(ctx context.Context, sectorEvents, preCommitEvents, partitionEvents <-chan *MinerSectorsEvent) error {
+	tx, err := p.db.Begin()
+	if err != nil {
+		return err
+	}
+
+	if _, err := tx.Exec(`create temp table mse (like miner_sector_events excluding constraints) on commit drop;`); err != nil {
+		return xerrors.Errorf("Failed to create temp table for sector_: %w", err)
+	}
+
+	stmt, err := tx.Prepare(`copy mse (miner_id, sector_id, event, state_root) from STDIN`)
+	if err != nil {
+		return xerrors.Errorf("Failed to prepare miner sector info statement: %w", err)
+	}
+
+	grp, ctx := errgroup.WithContext(ctx)
+	grp.Go(func() error {
+		innerGrp, _ := errgroup.WithContext(ctx)
+		for mse := range sectorEvents {
+			mse := mse
+			innerGrp.Go(func() error {
+				for _, sid := range mse.SectorIDs {
+					if _, err := stmt.Exec(
+						mse.MinerID.String(),
+						sid,
+						mse.Event,
+						mse.StateRoot.String(),
+					); err != nil {
+						return err
+					}
+				}
+				return nil
+			})
+		}
+		return innerGrp.Wait()
+	})
+
+	grp.Go(func() error {
+		innerGrp, _ := errgroup.WithContext(ctx)
+		for mse := range preCommitEvents {
+			mse := mse
+			innerGrp.Go(func() error {
+				for _, sid := range mse.SectorIDs {
+					if _, err := stmt.Exec(
+						mse.MinerID.String(),
+						sid,
+						mse.Event,
+						mse.StateRoot.String(),
+					); err != nil {
+						return err
+					}
+				}
+				return nil
+			})
+		}
+		return innerGrp.Wait()
+	})
+
+	grp.Go(func() error {
+		innerGrp, _ := errgroup.WithContext(ctx)
+		for mse := range partitionEvents {
+			mse := mse
+			grp.Go(func() error {
+				for _, sid := range mse.SectorIDs {
+					if _, err := stmt.Exec(
+						mse.MinerID.String(),
+						sid,
+						mse.Event,
+						mse.StateRoot.String(),
+					); err != nil {
+						return err
+					}
+				}
+				return nil
+			})
+		}
+		return innerGrp.Wait()
+	})
+
+	if err := grp.Wait(); err != nil {
+		return err
+	}
+
+	if err := stmt.Close(); err != nil {
+		return xerrors.Errorf("Failed to close sector event statement: %w", err)
+	}
+
+	if _, err := tx.Exec(`insert into miner_sector_events select * from mse on conflict do nothing`); err != nil {
+		return xerrors.Errorf("Failed to insert into sector event table: %w", err)
+	}
+
+	if err := tx.Commit(); err != nil {
+		return xerrors.Errorf("Failed to commit sector events: %w", err)
+	}
+	return nil
+}
+
+func (p *Processor) getMinerStateAt(ctx context.Context, maddr address.Address, tskey types.TipSetKey) (miner.State, error) {
+	prevActor, err := p.node.StateGetActor(ctx, maddr, tskey)
+	if err != nil {
+		return nil, err
+	}
+	return miner.Load(store.ActorStore(ctx, apibstore.NewAPIBlockstore(p.node)), prevActor)
+}
+
+func (p *Processor) getMinerPreCommitChanges(ctx context.Context, m minerActorInfo) (*miner.PreCommitChanges, error) {
+	pred := state.NewStatePredicates(p.node)
+	changed, val, err := pred.OnMinerActorChange(m.common.addr, pred.OnMinerPreCommitChange())(ctx, m.common.parentTsKey, m.common.tsKey)
+	if err != nil {
+		return nil, xerrors.Errorf("Failed to diff miner precommit amt: %w", err)
+	}
+	if !changed {
+		return nil, nil
+	}
+	out := val.(*miner.PreCommitChanges)
+	return out, nil
+}
+
+func (p *Processor) getMinerSectorChanges(ctx context.Context, m minerActorInfo) (*miner.SectorChanges, error) {
+	pred := state.NewStatePredicates(p.node)
+	changed, val, err := pred.OnMinerActorChange(m.common.addr, pred.OnMinerSectorChange())(ctx, m.common.parentTsKey, m.common.tsKey)
+	if err != nil {
+		return nil, xerrors.Errorf("Failed to diff miner sectors amt: %w", err)
+	}
+	if !changed {
+		return nil, nil
+	}
+	out := val.(*miner.SectorChanges)
+	return out, nil
+}
+
+func (p *Processor) diffMinerPartitions(ctx context.Context, m minerActorInfo, events chan<- *MinerSectorsEvent) error {
+	prevMiner, err := p.getMinerStateAt(ctx, m.common.addr, m.common.parentTsKey)
+	if err != nil {
+		return err
+	}
+	curMiner := m.state
+	dc, err := prevMiner.DeadlinesChanged(curMiner)
+	if err != nil {
+		return err
+	}
+	if !dc {
+		return nil
+	}
+	panic("TODO")
+
+	// FIXME: This code doesn't work.
+	// 1. We need to diff all deadlines, not just the "current" deadline.
+	// 2. We need to handle the case where we _add_ a partition. (i.e.,
+	// where len(newPartitions) != len(oldPartitions).
+	/*
+
+			// NOTE: If we change the number of deadlines in an upgrade, this will
+			// break.
+
+			// load the old deadline
+			prevDls, err := prevMiner.LoadDeadlines(p.ctxStore)
+			if err != nil {
+				return err
+			}
+			var prevDl miner.Deadline
+			if err := p.ctxStore.Get(ctx, prevDls.Due[dlIdx], &prevDl); err != nil {
+				return err
+			}
+
+			prevPartitions, err := prevDl.PartitionsArray(p.ctxStore)
+			if err != nil {
+				return err
+			}
+
+			// load the new deadline
+			curDls, err := curMiner.LoadDeadlines(p.ctxStore)
+			if err != nil {
+				return err
+			}
+
+			var curDl miner.Deadline
+			if err := p.ctxStore.Get(ctx, curDls.Due[dlIdx], &curDl); err != nil {
+				return err
+			}
+
+			curPartitions, err := curDl.PartitionsArray(p.ctxStore)
+			if err != nil {
+				return err
+			}
+
+			// TODO this can be optimized by inspecting the miner state for partitions that have changed and only inspecting those.
+			var prevPart miner.Partition
+			if err := prevPartitions.ForEach(&prevPart, func(i int64) error {
+				var curPart miner.Partition
+				if found, err := curPartitions.Get(uint64(i), &curPart); err != nil {
+					return err
+				} else if !found {
+					log.Fatal("I don't know what this means, are partitions ever removed?")
+				}
+				partitionDiff, err := p.diffPartition(prevPart, curPart)
+				if err != nil {
+					return err
+				}
+
+				recovered, err := partitionDiff.Recovered.All(miner.SectorsMax)
+				if err != nil {
+					return err
+				}
+				events <- &MinerSectorsEvent{
+					MinerID:   m.common.addr,
+					StateRoot: m.common.stateroot,
+					SectorIDs: recovered,
+					Event:     SectorRecovered,
+				}
+				inRecovery, err := partitionDiff.InRecovery.All(miner.SectorsMax)
+				if err != nil {
+					return err
+				}
+				events <- &MinerSectorsEvent{
+					MinerID:   m.common.addr,
+					StateRoot: m.common.stateroot,
+					SectorIDs: inRecovery,
+					Event:     SectorRecovering,
+				}
+				faulted, err := partitionDiff.Faulted.All(miner.SectorsMax)
+				if err != nil {
+					return err
+				}
+				events <- &MinerSectorsEvent{
+					MinerID:   m.common.addr,
+					StateRoot: m.common.stateroot,
+					SectorIDs: faulted,
+					Event:     SectorFaulted,
+				}
+				terminated, err := partitionDiff.Terminated.All(miner.SectorsMax)
+				if err != nil {
+					return err
+				}
+				events <- &MinerSectorsEvent{
+					MinerID:   m.common.addr,
+					StateRoot: m.common.stateroot,
+					SectorIDs: terminated,
+					Event:     SectorTerminated,
+				}
+				expired, err := partitionDiff.Expired.All(miner.SectorsMax)
+				if err != nil {
+					return err
+				}
+				events <- &MinerSectorsEvent{
+					MinerID:   m.common.addr,
+					StateRoot: m.common.stateroot,
+					SectorIDs: expired,
+					Event:     SectorExpired,
+				}
+
+				return nil
+			}); err != nil {
+				return err
+			}
+
+		return nil
+	*/
+}
+
+func (p *Processor) diffPartition(prevPart, curPart miner.Partition) (*PartitionStatus, error) {
+	prevLiveSectors, err := prevPart.LiveSectors()
+	if err != nil {
+		return nil, err
+	}
+	curLiveSectors, err := curPart.LiveSectors()
+	if err != nil {
+		return nil, err
+	}
+
+	removedSectors, err := bitfield.SubtractBitField(prevLiveSectors, curLiveSectors)
+	if err != nil {
+		return nil, err
+	}
+
+	prevRecoveries, err := prevPart.RecoveringSectors()
+	if err != nil {
+		return nil, err
+	}
+
+	curRecoveries, err := curPart.RecoveringSectors()
+	if err != nil {
+		return nil, err
+	}
+
+	newRecoveries, err := bitfield.SubtractBitField(curRecoveries, prevRecoveries)
+	if err != nil {
+		return nil, err
+	}
+
+	prevFaults, err := prevPart.FaultySectors()
+	if err != nil {
+		return nil, err
+	}
+
+	curFaults, err := curPart.FaultySectors()
+	if err != nil {
+		return nil, err
+	}
+
+	newFaults, err := bitfield.SubtractBitField(curFaults, prevFaults)
+	if err != nil {
+		return nil, err
+	}
+
+	// all current good sectors
+	curActiveSectors, err := curPart.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
+	}
+
+	// TODO: distinguish between "terminated" and "expired" sectors. The
+	// previous code here never had a chance of working in the first place,
+	// so I'm not going to try to replicate it right now.
+	//
+	// How? If the sector expires before it should (according to sector
+	// info) and it wasn't replaced by a pre-commit deleted in this change
+	// set, it was "early terminated".
+
+	return &PartitionStatus{
+		Terminated: bitfield.New(),
+		Expired:    removedSectors,
+		Faulted:    newFaults,
+		InRecovery: newRecoveries,
+		Recovered:  recovered,
+	}, nil
+}
+
+func (p *Processor) storeMinersActorInfoState(ctx context.Context, miners []minerActorInfo) error {
+	start := time.Now()
+	defer func() {
+		log.Debugw("Stored Miners Actor State", "duration", time.Since(start).String())
+	}()
+
+	tx, err := p.db.Begin()
+	if err != nil {
+		return err
+	}
+
+	if _, err := tx.Exec(`create temp table mi (like miner_info excluding constraints) on commit drop;`); err != nil {
+		return xerrors.Errorf("prep temp: %w", err)
+	}
+
+	stmt, err := tx.Prepare(`copy mi (miner_id, owner_addr, worker_addr, peer_id, sector_size) from STDIN`)
+	if err != nil {
+		return err
+	}
+	for _, m := range miners {
+		mi, err := p.node.StateMinerInfo(ctx, m.common.addr, m.common.tsKey)
+		if err != nil {
+			if strings.Contains(err.Error(), types.ErrActorNotFound.Error()) {
+				continue
+			} else {
+				return err
+			}
+		}
+		var pid string
+		if mi.PeerId != nil {
+			pid = mi.PeerId.String()
+		}
+		if _, err := stmt.Exec(
+			m.common.addr.String(),
+			mi.Owner.String(),
+			mi.Worker.String(),
+			pid,
+			mi.SectorSize.ShortString(),
+		); err != nil {
+			log.Errorw("failed to store miner state", "state", m.state, "info", m.state.Info, "error", err)
+			return xerrors.Errorf("failed to store miner state: %w", err)
+		}
+
+	}
+	if err := stmt.Close(); err != nil {
+		return err
+	}
+
+	if _, err := tx.Exec(`insert into miner_info select * from mi on conflict do nothing `); err != nil {
+		return xerrors.Errorf("actor put: %w", err)
+	}
+
+	return tx.Commit()
+}
+
+func (p *Processor) storePreCommitDealInfo(dealEvents <-chan *SectorDealEvent) error {
+	tx, err := p.db.Begin()
+	if err != nil {
+		return err
+	}
+
+	if _, err := tx.Exec(`create temp table mds (like minerid_dealid_sectorid excluding constraints) on commit  drop;`); err != nil {
+		return xerrors.Errorf("Failed to create temp table for minerid_dealid_sectorid: %w", err)
+	}
+
+	stmt, err := tx.Prepare(`copy mds (deal_id, miner_id, sector_id) from STDIN`)
+	if err != nil {
+		return xerrors.Errorf("Failed to prepare minerid_dealid_sectorid statement: %w", err)
+	}
+
+	for sde := range dealEvents {
+		for _, did := range sde.DealIDs {
+			if _, err := stmt.Exec(
+				uint64(did),
+				sde.MinerID.String(),
+				sde.SectorID,
+			); err != nil {
+				return err
+			}
+		}
+	}
+
+	if err := stmt.Close(); err != nil {
+		return xerrors.Errorf("Failed to close miner sector deals statement: %w", err)
+	}
+
+	if _, err := tx.Exec(`insert into minerid_dealid_sectorid select * from mds on conflict do nothing`); err != nil {
+		return xerrors.Errorf("Failed to insert into miner deal sector table: %w", err)
+	}
+
+	if err := tx.Commit(); err != nil {
+		return xerrors.Errorf("Failed to commit miner deal sector table: %w", err)
+	}
+	return nil
+
+}
+
+func (p *Processor) storeMinersPower(miners []minerActorInfo) error {
+	start := time.Now()
+	defer func() {
+		log.Debugw("Stored Miners Power", "duration", time.Since(start).String())
+	}()
+
+	tx, err := p.db.Begin()
+	if err != nil {
+		return xerrors.Errorf("begin miner_power tx: %w", err)
+	}
+
+	if _, err := tx.Exec(`create temp table mp (like miner_power excluding constraints) on commit drop`); err != nil {
+		return xerrors.Errorf("prep miner_power temp: %w", err)
+	}
+
+	stmt, err := tx.Prepare(`copy mp (miner_id, state_root, raw_bytes_power, quality_adjusted_power) from STDIN`)
+	if err != nil {
+		return xerrors.Errorf("prepare tmp miner_power: %w", err)
+	}
+
+	for _, m := range miners {
+		if _, err := stmt.Exec(
+			m.common.addr.String(),
+			m.common.stateroot.String(),
+			m.rawPower.String(),
+			m.qalPower.String(),
+		); err != nil {
+			log.Errorw("failed to store miner power", "miner", m.common.addr, "stateroot", m.common.stateroot, "error", err)
+		}
+	}
+
+	if err := stmt.Close(); err != nil {
+		return xerrors.Errorf("close prepared miner_power: %w", err)
+	}
+
+	if _, err := tx.Exec(`insert into miner_power select * from mp on conflict do nothing`); err != nil {
+		return xerrors.Errorf("insert miner_power from tmp: %w", err)
+	}
+
+	if err := tx.Commit(); err != nil {
+		return xerrors.Errorf("commit miner_power tx: %w", err)
+	}
+
+	return nil
+
+}
+
+// load the power actor state clam as an adt.Map at the tipset `ts`.
+func getPowerActorState(ctx context.Context, api api.FullNode, ts types.TipSetKey) (power.State, error) {
+	powerActor, err := api.StateGetActor(ctx, power.Address, ts)
+	if err != nil {
+		return nil, err
+	}
+	return power.Load(cw_util.NewAPIIpldStore(ctx, api), powerActor)
+}
diff --git a/cmd/lotus-chainwatch/processor/mpool.go b/cmd/lotus-chainwatch/processor/mpool.go
new file mode 100644
index 000000000..0a6445d78
--- /dev/null
+++ b/cmd/lotus-chainwatch/processor/mpool.go
@@ -0,0 +1,100 @@
+package processor
+
+import (
+	"context"
+	"time"
+
+	"golang.org/x/xerrors"
+
+	"github.com/ipfs/go-cid"
+
+	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/chain/types"
+)
+
+func (p *Processor) subMpool(ctx context.Context) {
+	sub, err := p.node.MpoolSub(ctx)
+	if err != nil {
+		return
+	}
+
+	for {
+		var updates []api.MpoolUpdate
+
+		select {
+		case update := <-sub:
+			updates = append(updates, update)
+		case <-ctx.Done():
+			return
+		}
+
+	loop:
+		for {
+			select {
+			case update := <-sub:
+				updates = append(updates, update)
+			case <-time.After(10 * time.Millisecond):
+				break loop
+			}
+		}
+
+		msgs := map[cid.Cid]*types.Message{}
+		for _, v := range updates {
+			if v.Type != api.MpoolAdd {
+				continue
+			}
+
+			msgs[v.Message.Message.Cid()] = &v.Message.Message
+		}
+
+		err := p.storeMessages(msgs)
+		if err != nil {
+			log.Error(err)
+		}
+
+		if err := p.storeMpoolInclusions(updates); err != nil {
+			log.Error(err)
+		}
+	}
+}
+
+func (p *Processor) storeMpoolInclusions(msgs []api.MpoolUpdate) error {
+	tx, err := p.db.Begin()
+	if err != nil {
+		return err
+	}
+
+	if _, err := tx.Exec(`
+		create temp table mi (like mpool_messages excluding constraints) on commit drop;
+	`); err != nil {
+		return xerrors.Errorf("prep temp: %w", err)
+	}
+
+	stmt, err := tx.Prepare(`copy mi (msg, add_ts) from stdin `)
+	if err != nil {
+		return err
+	}
+
+	for _, msg := range msgs {
+		if msg.Type != api.MpoolAdd {
+			continue
+		}
+
+		if _, err := stmt.Exec(
+			msg.Message.Message.Cid().String(),
+			time.Now().Unix(),
+		); err != nil {
+			return err
+		}
+	}
+
+	if err := stmt.Close(); err != nil {
+		return err
+	}
+
+	if _, err := tx.Exec(`insert into mpool_messages select * from mi on conflict do nothing `); err != nil {
+		return xerrors.Errorf("actor put: %w", err)
+	}
+
+	return tx.Commit()
+}
diff --git a/cmd/lotus-chainwatch/processor/power.go b/cmd/lotus-chainwatch/processor/power.go
new file mode 100644
index 000000000..726a46706
--- /dev/null
+++ b/cmd/lotus-chainwatch/processor/power.go
@@ -0,0 +1,190 @@
+package processor
+
+import (
+	"context"
+	"time"
+
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-state-types/big"
+
+	"github.com/filecoin-project/lotus/chain/actors/builtin"
+)
+
+type powerActorInfo struct {
+	common actorInfo
+
+	totalRawBytes                      big.Int
+	totalRawBytesCommitted             big.Int
+	totalQualityAdjustedBytes          big.Int
+	totalQualityAdjustedBytesCommitted big.Int
+	totalPledgeCollateral              big.Int
+
+	qaPowerSmoothed builtin.FilterEstimate
+
+	minerCount                  int64
+	minerCountAboveMinimumPower int64
+}
+
+func (p *Processor) setupPower() error {
+	tx, err := p.db.Begin()
+	if err != nil {
+		return err
+	}
+
+	if _, err := tx.Exec(`
+create table if not exists chain_power
+(
+	state_root text not null
+		constraint power_smoothing_estimates_pk
+			primary key,
+
+	total_raw_bytes_power text not null,
+	total_raw_bytes_committed text not null,
+	total_qa_bytes_power text not null,
+	total_qa_bytes_committed text not null,
+	total_pledge_collateral text not null,
+
+	qa_smoothed_position_estimate text not null,
+	qa_smoothed_velocity_estimate text not null,
+
+	miner_count int not null,
+	minimum_consensus_miner_count int not null
+);
+`); err != nil {
+		return err
+	}
+
+	return tx.Commit()
+}
+
+func (p *Processor) HandlePowerChanges(ctx context.Context, powerTips ActorTips) error {
+	powerChanges, err := p.processPowerActors(ctx, powerTips)
+	if err != nil {
+		return xerrors.Errorf("Failed to process power actors: %w", err)
+	}
+
+	if err := p.persistPowerActors(ctx, powerChanges); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (p *Processor) processPowerActors(ctx context.Context, powerTips ActorTips) ([]powerActorInfo, error) {
+	start := time.Now()
+	defer func() {
+		log.Debugw("Processed Power Actors", "duration", time.Since(start).String())
+	}()
+
+	var out []powerActorInfo
+	for tipset, powerStates := range powerTips {
+		for _, act := range powerStates {
+			var pw powerActorInfo
+			pw.common = act
+
+			powerActorState, err := getPowerActorState(ctx, p.node, tipset)
+			if err != nil {
+				return nil, xerrors.Errorf("get power state (@ %s): %w", pw.common.stateroot.String(), err)
+			}
+
+			totalPower, err := powerActorState.TotalPower()
+			if err != nil {
+				return nil, xerrors.Errorf("failed to compute total power: %w", err)
+			}
+
+			totalCommitted, err := powerActorState.TotalCommitted()
+			if err != nil {
+				return nil, xerrors.Errorf("failed to compute total committed: %w", err)
+			}
+
+			totalLocked, err := powerActorState.TotalLocked()
+			if err != nil {
+				return nil, xerrors.Errorf("failed to compute total locked: %w", err)
+			}
+
+			powerSmoothed, err := powerActorState.TotalPowerSmoothed()
+			if err != nil {
+				return nil, xerrors.Errorf("failed to determine smoothed power: %w", err)
+			}
+
+			// NOTE: this doesn't set new* fields. Previously, we
+			// filled these using ThisEpoch* fields from the actor
+			// state, but these fields are effectively internal
+			// state and don't represent "new" power, as was
+			// assumed.
+
+			participatingMiners, totalMiners, err := powerActorState.MinerCounts()
+			if err != nil {
+				return nil, xerrors.Errorf("failed to count miners: %w", err)
+			}
+
+			pw.totalRawBytes = totalPower.RawBytePower
+			pw.totalQualityAdjustedBytes = totalPower.QualityAdjPower
+			pw.totalRawBytesCommitted = totalCommitted.RawBytePower
+			pw.totalQualityAdjustedBytesCommitted = totalCommitted.QualityAdjPower
+			pw.totalPledgeCollateral = totalLocked
+			pw.qaPowerSmoothed = powerSmoothed
+			pw.minerCountAboveMinimumPower = int64(participatingMiners)
+			pw.minerCount = int64(totalMiners)
+		}
+	}
+
+	return out, nil
+}
+
+func (p *Processor) persistPowerActors(ctx context.Context, powerStates []powerActorInfo) error {
+	// NB: use errgroup when there is more than a single store operation
+	return p.storePowerSmoothingEstimates(powerStates)
+}
+
+func (p *Processor) storePowerSmoothingEstimates(powerStates []powerActorInfo) error {
+	tx, err := p.db.Begin()
+	if err != nil {
+		return xerrors.Errorf("begin chain_power tx: %w", err)
+	}
+
+	if _, err := tx.Exec(`create temp table cp (like chain_power) on commit drop`); err != nil {
+		return xerrors.Errorf("prep chain_power: %w", err)
+	}
+
+	stmt, err := tx.Prepare(`copy cp (state_root, total_raw_bytes_power, total_raw_bytes_committed, total_qa_bytes_power, total_qa_bytes_committed, total_pledge_collateral, qa_smoothed_position_estimate, qa_smoothed_velocity_estimate, miner_count, minimum_consensus_miner_count) from stdin;`)
+	if err != nil {
+		return xerrors.Errorf("prepare tmp chain_power: %w", err)
+	}
+
+	for _, ps := range powerStates {
+		if _, err := stmt.Exec(
+			ps.common.stateroot.String(),
+
+			ps.totalRawBytes.String(),
+			ps.totalRawBytesCommitted.String(),
+			ps.totalQualityAdjustedBytes.String(),
+			ps.totalQualityAdjustedBytesCommitted.String(),
+			ps.totalPledgeCollateral.String(),
+
+			ps.qaPowerSmoothed.PositionEstimate.String(),
+			ps.qaPowerSmoothed.VelocityEstimate.String(),
+
+			ps.minerCount,
+			ps.minerCountAboveMinimumPower,
+		); err != nil {
+			return xerrors.Errorf("failed to store smoothing estimate: %w", err)
+		}
+	}
+
+	if err := stmt.Close(); err != nil {
+		return xerrors.Errorf("close prepared chain_power: %w", err)
+	}
+
+	if _, err := tx.Exec(`insert into chain_power select * from cp on conflict do nothing`); err != nil {
+		return xerrors.Errorf("insert chain_power from tmp: %w", err)
+	}
+
+	if err := tx.Commit(); err != nil {
+		return xerrors.Errorf("commit chain_power tx: %w", err)
+	}
+
+	return nil
+
+}
diff --git a/cmd/lotus-chainwatch/processor/processor.go b/cmd/lotus-chainwatch/processor/processor.go
new file mode 100644
index 000000000..bce2b9fb7
--- /dev/null
+++ b/cmd/lotus-chainwatch/processor/processor.go
@@ -0,0 +1,420 @@
+package processor
+
+import (
+	"context"
+	"database/sql"
+	"encoding/json"
+	"math"
+	"sync"
+	"time"
+
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/ipfs/go-cid"
+	logging "github.com/ipfs/go-log/v2"
+
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/specs-actors/actors/builtin"
+
+	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/chain/types"
+	cw_util "github.com/filecoin-project/lotus/cmd/lotus-chainwatch/util"
+	"github.com/filecoin-project/lotus/lib/parmap"
+)
+
+var log = logging.Logger("processor")
+
+type Processor struct {
+	db *sql.DB
+
+	node     api.FullNode
+	ctxStore *cw_util.APIIpldStore
+
+	genesisTs *types.TipSet
+
+	// number of blocks processed at a time
+	batch int
+}
+
+type ActorTips map[types.TipSetKey][]actorInfo
+
+type actorInfo struct {
+	act types.Actor
+
+	stateroot cid.Cid
+	height    abi.ChainEpoch // so that we can walk the actor changes in chronological order.
+
+	tsKey       types.TipSetKey
+	parentTsKey types.TipSetKey
+
+	addr  address.Address
+	state string
+}
+
+func NewProcessor(ctx context.Context, db *sql.DB, node api.FullNode, batch int) *Processor {
+	ctxStore := cw_util.NewAPIIpldStore(ctx, node)
+	return &Processor{
+		db:       db,
+		ctxStore: ctxStore,
+		node:     node,
+		batch:    batch,
+	}
+}
+
+func (p *Processor) setupSchemas() error {
+	// maintain order, subsequent calls create tables with foreign keys.
+	if err := p.setupMiners(); err != nil {
+		return err
+	}
+
+	if err := p.setupMarket(); err != nil {
+		return err
+	}
+
+	if err := p.setupRewards(); err != nil {
+		return err
+	}
+
+	if err := p.setupMessages(); err != nil {
+		return err
+	}
+
+	if err := p.setupCommonActors(); err != nil {
+		return err
+	}
+
+	if err := p.setupPower(); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (p *Processor) Start(ctx context.Context) {
+	log.Debug("Starting Processor")
+
+	if err := p.setupSchemas(); err != nil {
+		log.Fatalw("Failed to setup processor", "error", err)
+	}
+
+	var err error
+	p.genesisTs, err = p.node.ChainGetGenesis(ctx)
+	if err != nil {
+		log.Fatalw("Failed to get genesis state from lotus", "error", err.Error())
+	}
+
+	go p.subMpool(ctx)
+
+	// main processor loop
+	go func() {
+		for {
+			select {
+			case <-ctx.Done():
+				log.Info("Stopping Processor...")
+				return
+			default:
+				loopStart := time.Now()
+				toProcess, err := p.unprocessedBlocks(ctx, p.batch)
+				if err != nil {
+					log.Fatalw("Failed to get unprocessed blocks", "error", err)
+				}
+
+				if len(toProcess) == 0 {
+					log.Info("No unprocessed blocks. Wait then try again...")
+					time.Sleep(time.Second * 30)
+					continue
+				}
+
+				// TODO special case genesis state handling here to avoid all the special cases that will be needed for it else where
+				// before doing "normal" processing.
+
+				actorChanges, nullRounds, err := p.collectActorChanges(ctx, toProcess)
+				if err != nil {
+					log.Fatalw("Failed to collect actor changes", "error", err)
+				}
+				log.Infow("Collected Actor Changes",
+					"MarketChanges", len(actorChanges[builtin.StorageMarketActorCodeID]),
+					"MinerChanges", len(actorChanges[builtin.StorageMinerActorCodeID]),
+					"RewardChanges", len(actorChanges[builtin.RewardActorCodeID]),
+					"AccountChanges", len(actorChanges[builtin.AccountActorCodeID]),
+					"nullRounds", len(nullRounds))
+
+				grp := sync.WaitGroup{}
+
+				grp.Add(1)
+				go func() {
+					defer grp.Done()
+					if err := p.HandleMarketChanges(ctx, actorChanges[builtin.StorageMarketActorCodeID]); err != nil {
+						log.Errorf("Failed to handle market changes: %w", err)
+						return
+					}
+				}()
+
+				grp.Add(1)
+				go func() {
+					defer grp.Done()
+					if err := p.HandleMinerChanges(ctx, actorChanges[builtin.StorageMinerActorCodeID]); err != nil {
+						log.Errorf("Failed to handle miner changes: %w", err)
+						return
+					}
+				}()
+
+				grp.Add(1)
+				go func() {
+					defer grp.Done()
+					if err := p.HandleRewardChanges(ctx, actorChanges[builtin.RewardActorCodeID], nullRounds); err != nil {
+						log.Errorf("Failed to handle reward changes: %w", err)
+						return
+					}
+				}()
+
+				grp.Add(1)
+				go func() {
+					defer grp.Done()
+					if err := p.HandlePowerChanges(ctx, actorChanges[builtin.StoragePowerActorCodeID]); err != nil {
+						log.Errorf("Failed to handle power actor changes: %w", err)
+						return
+					}
+				}()
+
+				grp.Add(1)
+				go func() {
+					defer grp.Done()
+					if err := p.HandleMessageChanges(ctx, toProcess); err != nil {
+						log.Errorf("Failed to handle message changes: %w", err)
+						return
+					}
+				}()
+
+				grp.Add(1)
+				go func() {
+					defer grp.Done()
+					if err := p.HandleCommonActorsChanges(ctx, actorChanges); err != nil {
+						log.Errorf("Failed to handle common actor changes: %w", err)
+						return
+					}
+				}()
+
+				grp.Wait()
+
+				if err := p.markBlocksProcessed(ctx, toProcess); err != nil {
+					log.Fatalw("Failed to mark blocks as processed", "error", err)
+				}
+
+				if err := p.refreshViews(); err != nil {
+					log.Errorw("Failed to refresh views", "error", err)
+				}
+				log.Infow("Processed Batch Complete", "duration", time.Since(loopStart).String())
+			}
+		}
+	}()
+
+}
+
+func (p *Processor) refreshViews() error {
+	if _, err := p.db.Exec(`refresh materialized view state_heights`); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (p *Processor) collectActorChanges(ctx context.Context, toProcess map[cid.Cid]*types.BlockHeader) (map[cid.Cid]ActorTips, []types.TipSetKey, error) {
+	start := time.Now()
+	defer func() {
+		log.Debugw("Collected Actor Changes", "duration", time.Since(start).String())
+	}()
+	// ActorCode - > tipset->[]actorInfo
+	out := map[cid.Cid]ActorTips{}
+	var outMu sync.Mutex
+
+	// map of addresses to changed actors
+	var changes map[string]types.Actor
+	actorsSeen := map[cid.Cid]struct{}{}
+
+	var nullRounds []types.TipSetKey
+	var nullBlkMu sync.Mutex
+
+	// collect all actor state that has changes between block headers
+	paDone := 0
+	parmap.Par(50, parmap.MapArr(toProcess), func(bh *types.BlockHeader) {
+		paDone++
+		if paDone%100 == 0 {
+			log.Debugw("Collecting actor changes", "done", paDone, "percent", (paDone*100)/len(toProcess))
+		}
+
+		pts, err := p.node.ChainGetTipSet(ctx, types.NewTipSetKey(bh.Parents...))
+		if err != nil {
+			log.Error(err)
+			return
+		}
+
+		if pts.ParentState().Equals(bh.ParentStateRoot) {
+			nullBlkMu.Lock()
+			nullRounds = append(nullRounds, pts.Key())
+			nullBlkMu.Unlock()
+		}
+
+		// collect all actors that had state changes between the blockheader parent-state and its grandparent-state.
+		// TODO: changes will contain deleted actors, this causes needless processing further down the pipeline, consider
+		// a separate strategy for deleted actors
+		changes, err = p.node.StateChangedActors(ctx, pts.ParentState(), bh.ParentStateRoot)
+		if err != nil {
+			log.Error(err)
+			log.Debugw("StateChangedActors", "grandparent_state", pts.ParentState(), "parent_state", bh.ParentStateRoot)
+			return
+		}
+
+		// record the state of all actors that have changed
+		for a, act := range changes {
+			act := act
+			a := a
+
+			// ignore actors that were deleted.
+			has, err := p.node.ChainHasObj(ctx, act.Head)
+			if err != nil {
+				log.Error(err)
+				log.Debugw("ChanHasObj", "actor_head", act.Head)
+				return
+			}
+			if !has {
+				continue
+			}
+
+			addr, err := address.NewFromString(a)
+			if err != nil {
+				log.Error(err)
+				log.Debugw("NewFromString", "address_string", a)
+				return
+			}
+
+			ast, err := p.node.StateReadState(ctx, addr, pts.Key())
+			if err != nil {
+				log.Error(err)
+				log.Debugw("StateReadState", "address_string", a, "parent_tipset_key", pts.Key())
+				return
+			}
+
+			// TODO look here for an empty state, maybe thats a sign the actor was deleted?
+
+			state, err := json.Marshal(ast.State)
+			if err != nil {
+				log.Error(err)
+				return
+			}
+
+			outMu.Lock()
+			if _, ok := actorsSeen[act.Head]; !ok {
+				_, ok := out[act.Code]
+				if !ok {
+					out[act.Code] = map[types.TipSetKey][]actorInfo{}
+				}
+				out[act.Code][pts.Key()] = append(out[act.Code][pts.Key()], actorInfo{
+					act:         act,
+					stateroot:   bh.ParentStateRoot,
+					height:      bh.Height,
+					tsKey:       pts.Key(),
+					parentTsKey: pts.Parents(),
+					addr:        addr,
+					state:       string(state),
+				})
+			}
+			actorsSeen[act.Head] = struct{}{}
+			outMu.Unlock()
+		}
+	})
+	return out, nullRounds, nil
+}
+
+func (p *Processor) unprocessedBlocks(ctx context.Context, batch int) (map[cid.Cid]*types.BlockHeader, error) {
+	start := time.Now()
+	defer func() {
+		log.Debugw("Gathered Blocks to process", "duration", time.Since(start).String())
+	}()
+	rows, err := p.db.Query(`
+with toProcess as (
+    select b.cid, b.height, rank() over (order by height) as rnk
+    from blocks_synced bs
+        left join blocks b on bs.cid = b.cid
+    where bs.processed_at is null and b.height > 0
+)
+select cid
+from toProcess
+where rnk <= $1
+`, batch)
+	if err != nil {
+		return nil, xerrors.Errorf("Failed to query for unprocessed blocks: %w", err)
+	}
+	out := map[cid.Cid]*types.BlockHeader{}
+
+	minBlock := abi.ChainEpoch(math.MaxInt64)
+	maxBlock := abi.ChainEpoch(0)
+	// TODO consider parallel execution here for getting the blocks from the api as is done in fetchMessages()
+	for rows.Next() {
+		if rows.Err() != nil {
+			return nil, err
+		}
+		var c string
+		if err := rows.Scan(&c); err != nil {
+			log.Errorf("Failed to scan unprocessed blocks: %s", err.Error())
+			continue
+		}
+		ci, err := cid.Parse(c)
+		if err != nil {
+			log.Errorf("Failed to parse unprocessed blocks: %s", err.Error())
+			continue
+		}
+		bh, err := p.node.ChainGetBlock(ctx, ci)
+		if err != nil {
+			// this is a pretty serious issue.
+			log.Errorf("Failed to get block header %s: %s", ci.String(), err.Error())
+			continue
+		}
+		out[ci] = bh
+		if bh.Height < minBlock {
+			minBlock = bh.Height
+		}
+		if bh.Height > maxBlock {
+			maxBlock = bh.Height
+		}
+	}
+	if minBlock <= maxBlock {
+		log.Infow("Gathered Blocks to Process", "start", minBlock, "end", maxBlock)
+	}
+	return out, rows.Close()
+}
+
+func (p *Processor) markBlocksProcessed(ctx context.Context, processed map[cid.Cid]*types.BlockHeader) error {
+	start := time.Now()
+	processedHeight := abi.ChainEpoch(0)
+	defer func() {
+		log.Debugw("Marked blocks as Processed", "duration", time.Since(start).String())
+		log.Infow("Processed Blocks", "height", processedHeight)
+	}()
+	tx, err := p.db.Begin()
+	if err != nil {
+		return err
+	}
+
+	processedAt := time.Now().Unix()
+	stmt, err := tx.Prepare(`update blocks_synced set processed_at=$1 where cid=$2`)
+	if err != nil {
+		return err
+	}
+
+	for c, bh := range processed {
+		if bh.Height > processedHeight {
+			processedHeight = bh.Height
+		}
+		if _, err := stmt.Exec(processedAt, c.String()); err != nil {
+			return err
+		}
+	}
+
+	if err := stmt.Close(); err != nil {
+		return err
+	}
+
+	return tx.Commit()
+}
diff --git a/cmd/lotus-chainwatch/processor/reward.go b/cmd/lotus-chainwatch/processor/reward.go
new file mode 100644
index 000000000..72a329c87
--- /dev/null
+++ b/cmd/lotus-chainwatch/processor/reward.go
@@ -0,0 +1,234 @@
+package processor
+
+import (
+	"context"
+	"time"
+
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/big"
+
+	"github.com/filecoin-project/lotus/chain/actors/builtin"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/reward"
+	"github.com/filecoin-project/lotus/chain/types"
+
+	cw_util "github.com/filecoin-project/lotus/cmd/lotus-chainwatch/util"
+)
+
+type rewardActorInfo struct {
+	common actorInfo
+
+	cumSumBaselinePower big.Int
+	cumSumRealizedPower big.Int
+
+	effectiveNetworkTime   abi.ChainEpoch
+	effectiveBaselinePower big.Int
+
+	// NOTE: These variables are wrong. Talk to @ZX about fixing. These _do
+	// not_ represent "new" anything.
+	newBaselinePower     big.Int
+	newBaseReward        big.Int
+	newSmoothingEstimate builtin.FilterEstimate
+
+	totalMinedReward big.Int
+}
+
+func (rw *rewardActorInfo) set(s reward.State) (err error) {
+	rw.cumSumBaselinePower, err = s.CumsumBaseline()
+	if err != nil {
+		return xerrors.Errorf("getting cumsum baseline power (@ %s): %w", rw.common.stateroot.String(), err)
+	}
+
+	rw.cumSumRealizedPower, err = s.CumsumRealized()
+	if err != nil {
+		return xerrors.Errorf("getting cumsum realized power (@ %s): %w", rw.common.stateroot.String(), err)
+	}
+
+	rw.effectiveNetworkTime, err = s.EffectiveNetworkTime()
+	if err != nil {
+		return xerrors.Errorf("getting effective network time (@ %s): %w", rw.common.stateroot.String(), err)
+	}
+
+	rw.effectiveBaselinePower, err = s.EffectiveBaselinePower()
+	if err != nil {
+		return xerrors.Errorf("getting effective baseline power (@ %s): %w", rw.common.stateroot.String(), err)
+	}
+
+	rw.totalMinedReward, err = s.TotalStoragePowerReward()
+	if err != nil {
+		return xerrors.Errorf("getting  total mined (@ %s): %w", rw.common.stateroot.String(), err)
+	}
+
+	rw.newBaselinePower, err = s.ThisEpochBaselinePower()
+	if err != nil {
+		return xerrors.Errorf("getting this epoch baseline power (@ %s): %w", rw.common.stateroot.String(), err)
+	}
+
+	rw.newBaseReward, err = s.ThisEpochReward()
+	if err != nil {
+		return xerrors.Errorf("getting this epoch baseline power (@ %s): %w", rw.common.stateroot.String(), err)
+	}
+
+	rw.newSmoothingEstimate, err = s.ThisEpochRewardSmoothed()
+	if err != nil {
+		return xerrors.Errorf("getting this epoch baseline power (@ %s): %w", rw.common.stateroot.String(), err)
+	}
+	return nil
+}
+
+func (p *Processor) setupRewards() error {
+	tx, err := p.db.Begin()
+	if err != nil {
+		return err
+	}
+
+	if _, err := tx.Exec(`
+/* captures chain-specific power state for any given stateroot */
+create table if not exists chain_reward
+(
+	state_root text not null
+		constraint chain_reward_pk
+			primary key,
+	cum_sum_baseline text not null,
+	cum_sum_realized text not null,
+	effective_network_time int not null,
+	effective_baseline_power text not null,
+
+	new_baseline_power text not null,
+	new_reward numeric not null,
+	new_reward_smoothed_position_estimate text not null,
+	new_reward_smoothed_velocity_estimate text not null,
+
+	total_mined_reward text not null
+);
+`); err != nil {
+		return err
+	}
+
+	return tx.Commit()
+}
+
+func (p *Processor) HandleRewardChanges(ctx context.Context, rewardTips ActorTips, nullRounds []types.TipSetKey) error {
+	rewardChanges, err := p.processRewardActors(ctx, rewardTips, nullRounds)
+	if err != nil {
+		return xerrors.Errorf("Failed to process reward actors: %w", err)
+	}
+
+	if err := p.persistRewardActors(ctx, rewardChanges); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (p *Processor) processRewardActors(ctx context.Context, rewardTips ActorTips, nullRounds []types.TipSetKey) ([]rewardActorInfo, error) {
+	start := time.Now()
+	defer func() {
+		log.Debugw("Processed Reward Actors", "duration", time.Since(start).String())
+	}()
+
+	var out []rewardActorInfo
+	for tipset, rewards := range rewardTips {
+		for _, act := range rewards {
+			var rw rewardActorInfo
+			rw.common = act
+
+			// get reward actor states at each tipset once for all updates
+			rewardActor, err := p.node.StateGetActor(ctx, reward.Address, tipset)
+			if err != nil {
+				return nil, xerrors.Errorf("get reward state (@ %s): %w", rw.common.stateroot.String(), err)
+			}
+
+			rewardActorState, err := reward.Load(cw_util.NewAPIIpldStore(ctx, p.node), rewardActor)
+			if err != nil {
+				return nil, xerrors.Errorf("read state obj (@ %s): %w", rw.common.stateroot.String(), err)
+			}
+			if err := rw.set(rewardActorState); err != nil {
+				return nil, err
+			}
+
+			out = append(out, rw)
+		}
+	}
+	for _, tsKey := range nullRounds {
+		var rw rewardActorInfo
+		tipset, err := p.node.ChainGetTipSet(ctx, tsKey)
+		if err != nil {
+			return nil, err
+		}
+		rw.common.tsKey = tipset.Key()
+		rw.common.height = tipset.Height()
+		rw.common.stateroot = tipset.ParentState()
+		rw.common.parentTsKey = tipset.Parents()
+		// get reward actor states at each tipset once for all updates
+		rewardActor, err := p.node.StateGetActor(ctx, reward.Address, tsKey)
+		if err != nil {
+			return nil, err
+		}
+
+		rewardActorState, err := reward.Load(cw_util.NewAPIIpldStore(ctx, p.node), rewardActor)
+		if err != nil {
+			return nil, xerrors.Errorf("read state obj (@ %s): %w", rw.common.stateroot.String(), err)
+		}
+
+		if err := rw.set(rewardActorState); err != nil {
+			return nil, err
+		}
+		out = append(out, rw)
+	}
+
+	return out, nil
+}
+
+func (p *Processor) persistRewardActors(ctx context.Context, rewards []rewardActorInfo) error {
+	start := time.Now()
+	defer func() {
+		log.Debugw("Persisted Reward Actors", "duration", time.Since(start).String())
+	}()
+
+	tx, err := p.db.Begin()
+	if err != nil {
+		return xerrors.Errorf("begin chain_reward tx: %w", err)
+	}
+
+	if _, err := tx.Exec(`create temp table cr (like chain_reward excluding constraints) on commit drop`); err != nil {
+		return xerrors.Errorf("prep chain_reward temp: %w", err)
+	}
+
+	stmt, err := tx.Prepare(`copy cr ( state_root, cum_sum_baseline, cum_sum_realized, effective_network_time, effective_baseline_power, new_baseline_power, new_reward, new_reward_smoothed_position_estimate, new_reward_smoothed_velocity_estimate, total_mined_reward) from STDIN`)
+	if err != nil {
+		return xerrors.Errorf("prepare tmp chain_reward: %w", err)
+	}
+
+	for _, rewardState := range rewards {
+		if _, err := stmt.Exec(
+			rewardState.common.stateroot.String(),
+			rewardState.cumSumBaselinePower.String(),
+			rewardState.cumSumRealizedPower.String(),
+			uint64(rewardState.effectiveNetworkTime),
+			rewardState.effectiveBaselinePower.String(),
+			rewardState.newBaselinePower.String(),
+			rewardState.newBaseReward.String(),
+			rewardState.newSmoothingEstimate.PositionEstimate.String(),
+			rewardState.newSmoothingEstimate.VelocityEstimate.String(),
+			rewardState.totalMinedReward.String(),
+		); err != nil {
+			log.Errorw("failed to store chain power", "state_root", rewardState.common.stateroot, "error", err)
+		}
+	}
+
+	if err := stmt.Close(); err != nil {
+		return xerrors.Errorf("close prepared chain_reward: %w", err)
+	}
+
+	if _, err := tx.Exec(`insert into chain_reward select * from cr on conflict do nothing`); err != nil {
+		return xerrors.Errorf("insert chain_reward from tmp: %w", err)
+	}
+
+	if err := tx.Commit(); err != nil {
+		return xerrors.Errorf("commit chain_reward tx: %w", err)
+	}
+
+	return nil
+}
diff --git a/cmd/lotus-chainwatch/run.go b/cmd/lotus-chainwatch/run.go
new file mode 100644
index 000000000..64f242755
--- /dev/null
+++ b/cmd/lotus-chainwatch/run.go
@@ -0,0 +1,106 @@
+package main
+
+import (
+	"database/sql"
+	"fmt"
+	"net/http"
+	_ "net/http/pprof"
+	"os"
+	"strings"
+
+	_ "github.com/lib/pq"
+
+	"github.com/filecoin-project/go-jsonrpc"
+	logging "github.com/ipfs/go-log/v2"
+	"github.com/urfave/cli/v2"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/lotus/api"
+	lcli "github.com/filecoin-project/lotus/cli"
+	"github.com/filecoin-project/lotus/cmd/lotus-chainwatch/processor"
+	"github.com/filecoin-project/lotus/cmd/lotus-chainwatch/scheduler"
+	"github.com/filecoin-project/lotus/cmd/lotus-chainwatch/syncer"
+	"github.com/filecoin-project/lotus/cmd/lotus-chainwatch/util"
+)
+
+var runCmd = &cli.Command{
+	Name:  "run",
+	Usage: "Start lotus chainwatch",
+	Flags: []cli.Flag{
+		&cli.IntFlag{
+			Name:  "max-batch",
+			Value: 50,
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		go func() {
+			http.ListenAndServe(":6060", nil) //nolint:errcheck
+		}()
+		ll := cctx.String("log-level")
+		if err := logging.SetLogLevel("*", ll); err != nil {
+			return err
+		}
+		if err := logging.SetLogLevel("rpc", "error"); err != nil {
+			return err
+		}
+
+		var api api.FullNode
+		var closer jsonrpc.ClientCloser
+		var err error
+		if tokenMaddr := cctx.String("api"); tokenMaddr != "" {
+			toks := strings.Split(tokenMaddr, ":")
+			if len(toks) != 2 {
+				return fmt.Errorf("invalid api tokens, expected <token>:<maddr>, got: %s", tokenMaddr)
+			}
+
+			api, closer, err = util.GetFullNodeAPIUsingCredentials(cctx.Context, toks[1], toks[0])
+			if err != nil {
+				return err
+			}
+		} else {
+			api, closer, err = lcli.GetFullNodeAPI(cctx)
+			if err != nil {
+				return err
+			}
+		}
+		defer closer()
+		ctx := lcli.ReqContext(cctx)
+
+		v, err := api.Version(ctx)
+		if err != nil {
+			return err
+		}
+
+		log.Infof("Remote version: %s", v.Version)
+
+		maxBatch := cctx.Int("max-batch")
+
+		db, err := sql.Open("postgres", cctx.String("db"))
+		if err != nil {
+			return err
+		}
+		defer func() {
+			if err := db.Close(); err != nil {
+				log.Errorw("Failed to close database", "error", err)
+			}
+		}()
+
+		if err := db.Ping(); err != nil {
+			return xerrors.Errorf("Database failed to respond to ping (is it online?): %w", err)
+		}
+		db.SetMaxOpenConns(1350)
+
+		sync := syncer.NewSyncer(db, api, 1400)
+		sync.Start(ctx)
+
+		proc := processor.NewProcessor(ctx, db, api, maxBatch)
+		proc.Start(ctx)
+
+		sched := scheduler.PrepareScheduler(db)
+		sched.Start(ctx)
+
+		<-ctx.Done()
+		os.Exit(0)
+		return nil
+	},
+}
diff --git a/cmd/lotus-chainwatch/scheduler/refresh_top_miners_by_base_reward.go b/cmd/lotus-chainwatch/scheduler/refresh_top_miners_by_base_reward.go
new file mode 100644
index 000000000..145e84229
--- /dev/null
+++ b/cmd/lotus-chainwatch/scheduler/refresh_top_miners_by_base_reward.go
@@ -0,0 +1,78 @@
+package scheduler
+
+import (
+	"context"
+	"database/sql"
+
+	"golang.org/x/xerrors"
+)
+
+func setupTopMinerByBaseRewardSchema(ctx context.Context, db *sql.DB) error {
+	select {
+	case <-ctx.Done():
+		return nil
+	default:
+	}
+
+	tx, err := db.Begin()
+	if err != nil {
+		return err
+	}
+	if _, err := tx.Exec(`
+		create materialized view if not exists top_miners_by_base_reward as
+			with total_rewards_by_miner as (
+				select
+					b.miner,
+					sum(cr.new_reward * b.win_count) as total_reward
+				from blocks b
+				inner join chain_reward cr on b.parentstateroot = cr.state_root
+				group by 1
+			) select
+				rank() over (order by total_reward desc),
+				miner,
+				total_reward
+			from total_rewards_by_miner
+			group by 2, 3;
+
+		create index if not exists top_miners_by_base_reward_miner_index
+			on top_miners_by_base_reward (miner);
+
+		create materialized view if not exists top_miners_by_base_reward_max_height as
+			select
+				b."timestamp"as current_timestamp,
+				max(b.height) as current_height
+			from blocks b
+			join chain_reward cr on b.parentstateroot = cr.state_root
+			where cr.new_reward is not null
+			group by 1
+			order by 1 desc
+			limit 1;
+	`); err != nil {
+		return xerrors.Errorf("create top_miners_by_base_reward views: %w", err)
+	}
+
+	if err := tx.Commit(); err != nil {
+		return xerrors.Errorf("committing top_miners_by_base_reward views; %w", err)
+	}
+	return nil
+}
+
+func refreshTopMinerByBaseReward(ctx context.Context, db *sql.DB) error {
+	select {
+	case <-ctx.Done():
+		return nil
+	default:
+	}
+
+	_, err := db.Exec("refresh materialized view top_miners_by_base_reward;")
+	if err != nil {
+		return xerrors.Errorf("refresh top_miners_by_base_reward: %w", err)
+	}
+
+	_, err = db.Exec("refresh materialized view top_miners_by_base_reward_max_height;")
+	if err != nil {
+		return xerrors.Errorf("refresh top_miners_by_base_reward_max_height: %w", err)
+	}
+
+	return nil
+}
diff --git a/cmd/lotus-chainwatch/scheduler/scheduler.go b/cmd/lotus-chainwatch/scheduler/scheduler.go
new file mode 100644
index 000000000..6782bc16d
--- /dev/null
+++ b/cmd/lotus-chainwatch/scheduler/scheduler.go
@@ -0,0 +1,60 @@
+package scheduler
+
+import (
+	"context"
+	"database/sql"
+	"time"
+
+	logging "github.com/ipfs/go-log/v2"
+
+	"golang.org/x/xerrors"
+)
+
+var log = logging.Logger("scheduler")
+
+// Scheduler manages the execution of jobs triggered
+// by tickers. Not externally configurable at runtime.
+type Scheduler struct {
+	db *sql.DB
+}
+
+// PrepareScheduler returns a ready-to-run Scheduler
+func PrepareScheduler(db *sql.DB) *Scheduler {
+	return &Scheduler{db}
+}
+
+func (s *Scheduler) setupSchema(ctx context.Context) error {
+	if err := setupTopMinerByBaseRewardSchema(ctx, s.db); err != nil {
+		return xerrors.Errorf("setup top miners by reward schema: %w", err)
+	}
+	return nil
+}
+
+// Start the scheduler jobs at the defined intervals
+func (s *Scheduler) Start(ctx context.Context) {
+	log.Debug("Starting Scheduler")
+
+	if err := s.setupSchema(ctx); err != nil {
+		log.Fatalw("applying scheduling schema", "error", err)
+	}
+
+	go func() {
+		// run once on start after schema has initialized
+		time.Sleep(1 * time.Minute)
+		if err := refreshTopMinerByBaseReward(ctx, s.db); err != nil {
+			log.Errorw("failed to refresh top miner", "error", err)
+		}
+		refreshTopMinerCh := time.NewTicker(30 * time.Second)
+		defer refreshTopMinerCh.Stop()
+		for {
+			select {
+			case <-refreshTopMinerCh.C:
+				if err := refreshTopMinerByBaseReward(ctx, s.db); err != nil {
+					log.Errorw("failed to refresh top miner", "error", err)
+				}
+			case <-ctx.Done():
+				return
+			}
+		}
+	}()
+}
diff --git a/cmd/lotus-chainwatch/site/index.html b/cmd/lotus-chainwatch/site/index.html
deleted file mode 100644
index 1a1c2813a..000000000
--- a/cmd/lotus-chainwatch/site/index.html
+++ /dev/null
@@ -1,32 +0,0 @@
-<!DOCTYPE html>
-<html>
-<head>
-    <title>Lotus ChainWatch</title>
-    <link rel="stylesheet" type="text/css" href="main.css">
-</head>
-<body>
-<div class="Index">
-    <div class="Index-header">
-        <div>
-            <span>Lotus ChainWatch</span>
-        </div>
-    </div>
-    <div class="Index-nodes">
-        <div class="Index-node">
-            <b>{{countCol "actors" "id"}}</b> Actors;
-            <b>{{countCol "miner_heads" "addr"}}</b> Miners;
-            <b>{{netPower "slashed_at = 0" | sizeStr}}</b> Power
-            (<b>{{netPower "" | sizeStr}}</b> Total;
-            <b>{{netPower "slashed_at > 0" | sizeStr}}</b> Slashed)
-        </div>
-        <div class="Index-node">
-            {{count "messages"}} Messages; {{count "actors"}}  state changes
-        </div>
-        <div class="Index-node">
-            {{count "id_address_map" "id != address"}} <a href="keys.html">Keys</a>;
-            E% FIL in wallets; F% FIL in miners; M% in market; %G Other actors; %H FIL it treasury
-        </div>
-    </div>
-</div>
-</body>
-</html>
diff --git a/cmd/lotus-chainwatch/site/key.html b/cmd/lotus-chainwatch/site/key.html
deleted file mode 100644
index 697838ed2..000000000
--- a/cmd/lotus-chainwatch/site/key.html
+++ /dev/null
@@ -1,40 +0,0 @@
-<!DOCTYPE html>
-<html>
-<head>
-    <title>Lotus ChainWatch</title>
-    <link rel="stylesheet" type="text/css" href="main.css">
-</head>
-<body>
-{{$wallet := param "w"}}
-
-<div class="Index">
-    <div class="Index-header">
-        <div>
-            <span>Lotus ChainWatch - Wallet {{$wallet}}</span>
-        </div>
-    </div>
-    <div class="Index-nodes">
-        <div class="Index-node">
-            Balance: {{queryNum "select balance from actors inner join main.id_address_map m on m.address = ? where actors.id = m.id order by nonce desc limit 1" $wallet }}
-        </div>
-        <div class="Index-node">
-            Messages:
-            <table>
-                <tr><td>Dir</td><td>Peer</td><td>Nonce</td><td>Value</td><td>Block</td><td>Mpool Wait</td></tr>
-                {{ range messages "`from` = ? or `to` = ?" $wallet $wallet $wallet}}
-                    <tr>
-                        {{ if eq .From.String $wallet }}
-                            <td>To</td><td>{{.To.String}}</td>
-                        {{else}}
-                            <td>From</td><td>{{.From.String}}</td>
-                        {{end}}
-                        <td>{{.Nonce}}</td>
-                        <td>{{.Value}}</td>
-                    </tr>
-                {{end}}
-            </table>
-        </div>
-    </div>
-</div>
-</body>
-</html>
diff --git a/cmd/lotus-chainwatch/site/keys.html b/cmd/lotus-chainwatch/site/keys.html
deleted file mode 100644
index adf96adb1..000000000
--- a/cmd/lotus-chainwatch/site/keys.html
+++ /dev/null
@@ -1,23 +0,0 @@
-<!DOCTYPE html>
-<html>
-<head>
-    <title>Lotus ChainWatch</title>
-    <link rel="stylesheet" type="text/css" href="main.css">
-</head>
-<body>
-<div class="Index">
-    <div class="Index-header">
-        <div>
-            <span>Lotus ChainWatch - Wallets</span>
-        </div>
-    </div>
-    <div class="Index-nodes">
-        <div class="Index-node">
-           {{range strings "id_address_map" "address" "address != id"}}
-               <div><a href="key.html?w={{.}}">{{.}}</a></div>
-           {{end}}
-        </div>
-    </div>
-</div>
-</body>
-</html>
diff --git a/cmd/lotus-chainwatch/site/main.css b/cmd/lotus-chainwatch/site/main.css
deleted file mode 100644
index 820625360..000000000
--- a/cmd/lotus-chainwatch/site/main.css
+++ /dev/null
@@ -1,62 +0,0 @@
-body {
-    font-family: 'monospace';
-    background: #1f1f1f;
-    color: #f0f0f0;
-    padding: 0;
-    margin: 0;
-}
-
-.Index {
-    width: 100vw;
-    height: 100vh;
-    background: #1a1a1a;
-    color: #f0f0f0;
-    font-family: monospace;
-    overflow: auto;
-
-    display: grid;
-    grid-template-columns: auto 80vw auto;
-    grid-template-rows: 3em auto auto auto;
-    grid-template-areas:
-            "header header header header"
-            ". . . ."
-            ". main main ."
-            ". main main ."
-            ". main main ."
-            ". main main ."
-            ". main main ."
-            ". . . .";
-}
-
-.Index-header {
-    background: #2a2a2a;
-    grid-area: header;
-}
-
-.Index-Index-header > div {
-    padding-left: 0.7em;
-    padding-top: 0.7em;
-}
-
-.Index-nodes {
-    grid-area: main;
-    background: #2a2a2a;
-}
-
-.Index-node {
-    margin: 5px;
-    padding: 15px;
-    background: #1f1f1f;
-}
-
-a:link {
-    color: #50f020;
-}
-
-a:visited {
-    color: #50f020;
-}
-
-a:hover {
-    color: #30a00a;
-}
diff --git a/cmd/lotus-chainwatch/storage.go b/cmd/lotus-chainwatch/storage.go
deleted file mode 100644
index 5900f972b..000000000
--- a/cmd/lotus-chainwatch/storage.go
+++ /dev/null
@@ -1,501 +0,0 @@
-package main
-
-import (
-	"database/sql"
-	"sync"
-	"time"
-
-	"github.com/ipfs/go-cid"
-	_ "github.com/mattn/go-sqlite3"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/lotus/chain/types"
-)
-
-type storage struct {
-	db *sql.DB
-
-	headerLk sync.Mutex
-}
-
-func openStorage(dbSource string) (*storage, error) {
-	db, err := sql.Open("sqlite3", dbSource)
-	if err != nil {
-		return nil, err
-	}
-
-	st := &storage{db: db}
-
-	return st, st.setup()
-}
-
-func (st *storage) setup() error {
-	tx, err := st.db.Begin()
-	if err != nil {
-		return err
-	}
-	_, err = tx.Exec(`
-create table if not exists actors
-  (
-	id text not null,
-	code text not null,
-	head text not null,
-	nonce int not null,
-	balance text not null,
-	stateroot text
-		constraint actors_blocks_stateroot_fk
-			references blocks (parentStateRoot),
-	constraint actors_pk
-		primary key (id, nonce, balance, stateroot)
-  );
-  
-create index if not exists actors_id_index
-	on actors (id);
-
-create table if not exists id_address_map
-(
-	id text not null
-		constraint id_address_map_actors_id_fk
-			references actors (id),
-	address text not null,
-	constraint id_address_map_pk
-		primary key (id, address)
-);
-
-create index if not exists id_address_map_address_index
-	on id_address_map (address);
-
-create index if not exists id_address_map_id_index
-	on id_address_map (id);
-
-create table if not exists messages
-(
-	cid text not null
-		constraint messages_pk
-			primary key,
-	"from" text not null
-		constraint messages_id_address_map_from_fk
-			references id_address_map (address),
-	"to" text not null
-		constraint messages_id_address_map_to_fk
-			references id_address_map (address),
-	nonce int not null,
-	value text not null,
-	gasprice int not null,
-	gaslimit int not null,
-	method int,
-	params blob
-);
-
-create unique index if not exists messages_cid_uindex
-	on messages (cid);
-
-create table if not exists blocks
-(
-	cid text not null
-		constraint blocks_pk
-			primary key,
-	parentWeight numeric not null,
-	parentStateRoot text not null,
-	height int not null,
-	miner text not null
-		constraint blocks_id_address_map_miner_fk
-			references id_address_map (address),
-	timestamp int not null,
-	vrfproof blob,
-	tickets int not null,
-	eprof blob,
-	prand blob,
-	ep0partial blob,
-	ep0sector int not null,
-	ep0challangei int not null
-);
-
-create unique index if not exists block_cid_uindex
-	on blocks (cid);
-
-create table if not exists blocks_synced
-(
-	cid text not null
-		constraint blocks_synced_pk
-			primary key
-		constraint blocks_synced_blocks_cid_fk
-			references blocks,
-	add_ts int not null
-);
-
-create unique index if not exists blocks_synced_cid_uindex
-	on blocks_synced (cid);
-
-create table if not exists block_parents
-(
-	block text not null
-		constraint block_parents_blocks_cid_fk
-			references blocks,
-	parent text not null
-		constraint block_parents_blocks_cid_fk_2
-			references blocks
-);
-
-create unique index if not exists block_parents_block_parent_uindex
-	on block_parents (block, parent);
-
-create unique index if not exists blocks_cid_uindex
-	on blocks (cid);
-	
-create table if not exists block_messages
-(
-	block text not null
-		constraint block_messages_blk_fk
-			references blocks (cid),
-	message text not null
-		constraint block_messages_msg_fk
-			references messages,
-	constraint block_messages_pk
-		primary key (block, message)
-);
-
-create table if not exists mpool_messages
-(
-	msg text not null
-		constraint mpool_messages_pk
-			primary key
-		constraint mpool_messages_messages_cid_fk
-			references messages,
-	add_ts int not null
-);
-
-create unique index if not exists mpool_messages_msg_uindex
-	on mpool_messages (msg);
-
-create table if not exists receipts
-(
-	msg text not null
-		constraint receipts_messages_cid_fk
-			references messages,
-	state text not null
-		constraint receipts_blocks_parentStateRoot_fk
-			references blocks (parentStateRoot),
-	idx int not null,
-	exit int not null,
-	gas_used int not null,
-	return blob,
-	constraint receipts_pk
-		primary key (msg, state)
-);
-
-create index if not exists receipts_msg_state_index
-	on receipts (msg, state);
-
-
-create table if not exists miner_heads
-(
-	head text not null
-		constraint miner_heads_actors_head_fk
-			references actors (head),
-	addr text not null
-		constraint miner_heads_actors_id_fk
-			references actors (id),
-	stateroot text not null
-		constraint miner_heads_blocks_stateroot_fk
-			references blocks (parentStateRoot),
-	sectorset text not null,
-	setsize int not null,
-	provingset text not null,
-	provingsize int not null,
-	owner text not null,
-	worker text not null,
-	peerid text not null,
-	sectorsize int not null,
-	power text not null,
-	active int,
-	ppe int not null,
-	slashed_at int not null,
-	constraint miner_heads_id_address_map_owner_fk
-		foreign key (owner) references id_address_map (address),
-	constraint miner_heads_id_address_map_worker_fk
-		foreign key (worker) references id_address_map (address),
-	constraint miner_heads_pk
-		primary key (head, addr)
-);
-
-`)
-	if err != nil {
-		return err
-	}
-	return tx.Commit()
-}
-
-func (st *storage) hasBlock(bh cid.Cid) bool {
-	var exitsts bool
-	err := st.db.QueryRow(`select exists (select 1 FROM blocks_synced where cid=?)`, bh.String()).Scan(&exitsts)
-	if err != nil {
-		log.Error(err)
-		return false
-	}
-	return exitsts
-}
-
-func (st *storage) storeActors(actors map[address.Address]map[types.Actor]cid.Cid) error {
-	tx, err := st.db.Begin()
-	if err != nil {
-		return err
-	}
-
-	stmt, err := tx.Prepare(`insert into actors (id, code, head, nonce, balance, stateroot) values (?, ?, ?, ?, ?, ?) on conflict do nothing`)
-	if err != nil {
-		return err
-	}
-	defer stmt.Close()
-	for addr, acts := range actors {
-		for act, st := range acts {
-			if _, err := stmt.Exec(addr.String(), act.Code.String(), act.Head.String(), act.Nonce, act.Balance.String(), st.String()); err != nil {
-				return err
-			}
-		}
-	}
-
-	return tx.Commit()
-}
-
-func (st *storage) storeMiners(miners map[minerKey]*minerInfo) error {
-	tx, err := st.db.Begin()
-	if err != nil {
-		return err
-	}
-
-	stmt, err := tx.Prepare(`insert into miner_heads (head, addr, stateroot, sectorset, setsize, provingset, provingsize, owner, worker, peerid, sectorsize, power, active, ppe, slashed_at) values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) on conflict do nothing`)
-	if err != nil {
-		return err
-	}
-	defer stmt.Close()
-	for k, i := range miners {
-		if _, err := stmt.Exec(
-			k.act.Head.String(),
-			k.addr.String(),
-			k.stateroot.String(),
-			i.state.Sectors.String(),
-			i.ssize,
-			i.state.ProvingSet.String(),
-			i.psize,
-			i.info.Owner.String(),
-			i.info.Worker.String(),
-			i.info.PeerID.String(),
-			i.info.SectorSize,
-			i.state.Power.String(),
-			i.state.Active,
-			i.state.ElectionPeriodStart,
-			i.state.SlashedAt,
-		); err != nil {
-			return err
-		}
-	}
-
-	return tx.Commit()
-}
-
-func (st *storage) storeHeaders(bhs map[cid.Cid]*types.BlockHeader, sync bool) error {
-	st.headerLk.Lock()
-	defer st.headerLk.Unlock()
-
-	tx, err := st.db.Begin()
-	if err != nil {
-		return err
-	}
-
-	stmt, err := tx.Prepare(`insert into blocks (cid, parentWeight, parentStateRoot, height, miner, "timestamp", vrfproof, tickets, eprof, prand, ep0partial, ep0sector, ep0challangei) values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) on conflict do nothing`)
-	if err != nil {
-		return err
-	}
-	defer stmt.Close()
-	for _, bh := range bhs {
-		l := len(bh.EPostProof.Candidates)
-		if len(bh.EPostProof.Candidates) == 0 {
-			bh.EPostProof.Candidates = append(bh.EPostProof.Candidates, types.EPostTicket{})
-		}
-
-		if _, err := stmt.Exec(bh.Cid().String(),
-			bh.ParentWeight.String(),
-			bh.ParentStateRoot.String(),
-			bh.Height,
-			bh.Miner.String(),
-			bh.Timestamp,
-			bh.Ticket.VRFProof,
-			l,
-			bh.EPostProof.Proof,
-			bh.EPostProof.PostRand,
-			bh.EPostProof.Candidates[0].Partial,
-			bh.EPostProof.Candidates[0].SectorID,
-			bh.EPostProof.Candidates[0].ChallengeIndex,
-		); err != nil {
-			return err
-		}
-	}
-
-	stmt2, err := tx.Prepare(`insert into block_parents (block, parent) values (?, ?) on conflict do nothing`)
-	if err != nil {
-		return err
-	}
-	defer stmt2.Close()
-	for _, bh := range bhs {
-		for _, parent := range bh.Parents {
-			if _, err := stmt2.Exec(bh.Cid().String(), parent.String()); err != nil {
-				return err
-			}
-		}
-	}
-
-	if sync {
-		stmt, err := tx.Prepare(`insert into blocks_synced (cid, add_ts) values (?, ?) on conflict do nothing`)
-		if err != nil {
-			return err
-		}
-		defer stmt.Close()
-		now := time.Now().Unix()
-
-		for _, bh := range bhs {
-			if _, err := stmt.Exec(bh.Cid().String(), now); err != nil {
-				return err
-			}
-		}
-	}
-
-	return tx.Commit()
-}
-
-func (st *storage) storeMessages(msgs map[cid.Cid]*types.Message) error {
-	tx, err := st.db.Begin()
-	if err != nil {
-		return err
-	}
-
-	stmt, err := tx.Prepare(`insert into messages (cid, "from", "to", nonce, "value", gasprice, gaslimit, method, params) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?) on conflict do nothing`)
-	if err != nil {
-		return err
-	}
-	defer stmt.Close()
-
-	for c, m := range msgs {
-		if _, err := stmt.Exec(
-			c.String(),
-			m.From.String(),
-			m.To.String(),
-			m.Nonce,
-			m.Value.String(),
-			m.GasPrice.String(),
-			m.GasLimit.String(),
-			m.Method,
-			m.Params,
-		); err != nil {
-			return err
-		}
-	}
-
-	return tx.Commit()
-}
-
-func (st *storage) storeReceipts(recs map[mrec]*types.MessageReceipt) error {
-	tx, err := st.db.Begin()
-	if err != nil {
-		return err
-	}
-
-	stmt, err := tx.Prepare(`insert into receipts (msg, state, idx, exit, gas_used, return) VALUES (?, ?, ?, ?, ?, ?) on conflict do nothing`)
-	if err != nil {
-		return err
-	}
-	defer stmt.Close()
-
-	for c, m := range recs {
-		if _, err := stmt.Exec(
-			c.msg.String(),
-			c.state.String(),
-			c.idx,
-			m.ExitCode,
-			m.GasUsed.String(),
-			m.Return,
-		); err != nil {
-			return err
-		}
-	}
-
-	return tx.Commit()
-}
-
-func (st *storage) storeAddressMap(addrs map[address.Address]address.Address) error {
-	tx, err := st.db.Begin()
-	if err != nil {
-		return err
-	}
-
-	stmt, err := tx.Prepare(`insert into id_address_map (id, address) VALUES (?, ?) on conflict do nothing`)
-	if err != nil {
-		return err
-	}
-	defer stmt.Close()
-
-	for a, i := range addrs {
-		if i == address.Undef {
-			continue
-		}
-		if _, err := stmt.Exec(
-			i.String(),
-			a.String(),
-		); err != nil {
-			return err
-		}
-	}
-
-	return tx.Commit()
-}
-
-func (st *storage) storeMsgInclusions(incls map[cid.Cid][]cid.Cid) error {
-	tx, err := st.db.Begin()
-	if err != nil {
-		return err
-	}
-
-	stmt, err := tx.Prepare(`insert into block_messages (block, message) VALUES (?, ?) on conflict do nothing`)
-	if err != nil {
-		return err
-	}
-	defer stmt.Close()
-
-	for b, msgs := range incls {
-		for _, msg := range msgs {
-			if _, err := stmt.Exec(
-				b.String(),
-				msg.String(),
-			); err != nil {
-				return err
-			}
-		}
-	}
-
-	return tx.Commit()
-}
-
-func (st *storage) storeMpoolInclusion(msg cid.Cid) error {
-	tx, err := st.db.Begin()
-	if err != nil {
-		return err
-	}
-
-	stmt, err := tx.Prepare(`insert into mpool_messages (msg, add_ts) VALUES (?, ?) on conflict do nothing`)
-	if err != nil {
-		return err
-	}
-	defer stmt.Close()
-
-	if _, err := stmt.Exec(
-		msg.String(),
-		time.Now().Unix(),
-	); err != nil {
-		return err
-	}
-	return tx.Commit()
-}
-
-func (st *storage) close() error {
-	return st.db.Close()
-}
diff --git a/cmd/lotus-chainwatch/sync.go b/cmd/lotus-chainwatch/sync.go
deleted file mode 100644
index 947601321..000000000
--- a/cmd/lotus-chainwatch/sync.go
+++ /dev/null
@@ -1,348 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"container/list"
-	"context"
-	"sync"
-
-	"github.com/filecoin-project/go-address"
-	actors2 "github.com/filecoin-project/lotus/chain/actors"
-
-	"github.com/ipfs/go-cid"
-
-	"github.com/filecoin-project/lotus/api"
-	"github.com/filecoin-project/lotus/chain/store"
-	"github.com/filecoin-project/lotus/chain/types"
-)
-
-func runSyncer(ctx context.Context, api api.FullNode, st *storage) {
-	notifs, err := api.ChainNotify(ctx)
-	if err != nil {
-		panic(err)
-	}
-	go func() {
-		for notif := range notifs {
-			for _, change := range notif {
-				switch change.Type {
-				case store.HCCurrent:
-					fallthrough
-				case store.HCApply:
-					syncHead(ctx, api, st, change.Val)
-				case store.HCRevert:
-					log.Warnf("revert todo")
-				}
-			}
-		}
-	}()
-}
-
-type minerKey struct {
-	addr      address.Address
-	act       types.Actor
-	stateroot cid.Cid
-}
-
-type minerInfo struct {
-	state actors2.StorageMinerActorState
-	info  actors2.MinerInfo
-
-	ssize uint64
-	psize uint64
-}
-
-func syncHead(ctx context.Context, api api.FullNode, st *storage, ts *types.TipSet) {
-	addresses := map[address.Address]address.Address{}
-	actors := map[address.Address]map[types.Actor]cid.Cid{}
-	var alk sync.Mutex
-
-	log.Infof("Getting headers / actors")
-
-	toSync := map[cid.Cid]*types.BlockHeader{}
-	toVisit := list.New()
-
-	for _, header := range ts.Blocks() {
-		toVisit.PushBack(header)
-	}
-
-	for toVisit.Len() > 0 {
-		bh := toVisit.Remove(toVisit.Back()).(*types.BlockHeader)
-
-		if _, seen := toSync[bh.Cid()]; seen || st.hasBlock(bh.Cid()) {
-			continue
-		}
-
-		toSync[bh.Cid()] = bh
-		addresses[bh.Miner] = address.Undef
-
-		if len(toSync)%500 == 10 {
-			log.Infof("todo: (%d) %s", len(toSync), bh.Cid())
-		}
-
-		if len(bh.Parents) == 0 {
-			continue
-		}
-
-		pts, err := api.ChainGetTipSet(ctx, types.NewTipSetKey(bh.Parents...))
-		if err != nil {
-			log.Error(err)
-			continue
-		}
-
-		for _, header := range pts.Blocks() {
-			toVisit.PushBack(header)
-		}
-	}
-
-	log.Infof("Syncing %d blocks", len(toSync))
-
-	log.Infof("Persisting actors")
-
-	paDone := 0
-	par(50, maparr(toSync), func(bh *types.BlockHeader) {
-		paDone++
-		if paDone%100 == 0 {
-			log.Infof("pa: %d %d%%", paDone, (paDone*100)/len(toSync))
-		}
-
-		if len(bh.Parents) == 0 { // genesis case
-			ts, err := types.NewTipSet([]*types.BlockHeader{bh})
-			aadrs, err := api.StateListActors(ctx, ts)
-			if err != nil {
-				log.Error(err)
-				return
-			}
-
-			par(50, aadrs, func(addr address.Address) {
-				act, err := api.StateGetActor(ctx, addr, ts)
-				if err != nil {
-					log.Error(err)
-					return
-				}
-				alk.Lock()
-				_, ok := actors[addr]
-				if !ok {
-					actors[addr] = map[types.Actor]cid.Cid{}
-				}
-				actors[addr][*act] = bh.ParentStateRoot
-				addresses[addr] = address.Undef
-				alk.Unlock()
-			})
-
-			return
-		}
-
-		pts, err := api.ChainGetTipSet(ctx, types.NewTipSetKey(bh.Parents...))
-		if err != nil {
-			log.Error(err)
-			return
-		}
-
-		changes, err := api.StateChangedActors(ctx, pts.ParentState(), bh.ParentStateRoot)
-		if err != nil {
-			log.Error(err)
-			return
-		}
-
-		for a, act := range changes {
-			addr, err := address.NewFromString(a)
-			if err != nil {
-				log.Error(err)
-				return
-			}
-
-			alk.Lock()
-			_, ok := actors[addr]
-			if !ok {
-				actors[addr] = map[types.Actor]cid.Cid{}
-			}
-			actors[addr][act] = bh.ParentStateRoot
-			addresses[addr] = address.Undef
-			alk.Unlock()
-		}
-	})
-
-	if err := st.storeActors(actors); err != nil {
-		log.Error(err)
-		return
-	}
-
-	log.Infof("Persisting miners")
-
-	miners := map[minerKey]*minerInfo{}
-
-	for addr, m := range actors {
-		for actor, c := range m {
-			if actor.Code != actors2.StorageMinerCodeCid {
-				continue
-			}
-
-			miners[minerKey{
-				addr:      addr,
-				act:       actor,
-				stateroot: c,
-			}] = &minerInfo{}
-		}
-	}
-
-	par(50, kvmaparr(miners), func(it func() (minerKey, *minerInfo)) {
-		k, info := it()
-
-		sszs, err := api.StateMinerSectorCount(ctx, k.addr, nil)
-		if err != nil {
-			log.Error(err)
-			return
-		}
-		info.psize = sszs.Pset
-		info.ssize = sszs.Sset
-
-		astb, err := api.ChainReadObj(ctx, k.act.Head)
-		if err != nil {
-			log.Error(err)
-			return
-		}
-
-		if err := info.state.UnmarshalCBOR(bytes.NewReader(astb)); err != nil {
-			log.Error(err)
-			return
-		}
-
-		ib, err := api.ChainReadObj(ctx, info.state.Info)
-		if err != nil {
-			log.Error(err)
-			return
-		}
-
-		if err := info.info.UnmarshalCBOR(bytes.NewReader(ib)); err != nil {
-			log.Error(err)
-			return
-		}
-	})
-
-	if err := st.storeMiners(miners); err != nil {
-		log.Error(err)
-		return
-	}
-
-	log.Infof("Persisting headers")
-	if err := st.storeHeaders(toSync, true); err != nil {
-		log.Error(err)
-		return
-	}
-
-	log.Infof("Getting messages")
-
-	msgs, incls := fetchMessages(ctx, api, toSync)
-
-	if err := st.storeMessages(msgs); err != nil {
-		log.Error(err)
-		return
-	}
-
-	if err := st.storeMsgInclusions(incls); err != nil {
-		log.Error(err)
-		return
-	}
-
-	log.Infof("Getting parent receipts")
-
-	receipts := fetchParentReceipts(ctx, api, toSync)
-
-	if err := st.storeReceipts(receipts); err != nil {
-		log.Error(err)
-		return
-	}
-
-	log.Infof("Resolving addresses")
-
-	for _, message := range msgs {
-		addresses[message.To] = address.Undef
-		addresses[message.From] = address.Undef
-	}
-
-	par(50, kmaparr(addresses), func(addr address.Address) {
-		raddr, err := api.StateLookupID(ctx, addr, nil)
-		if err != nil {
-			log.Warn(err)
-			return
-		}
-		alk.Lock()
-		addresses[addr] = raddr
-		alk.Unlock()
-	})
-
-	if err := st.storeAddressMap(addresses); err != nil {
-		log.Error(err)
-		return
-	}
-
-	log.Infof("Sync done")
-}
-
-func fetchMessages(ctx context.Context, api api.FullNode, toSync map[cid.Cid]*types.BlockHeader) (map[cid.Cid]*types.Message, map[cid.Cid][]cid.Cid) {
-	var lk sync.Mutex
-	messages := map[cid.Cid]*types.Message{}
-	inclusions := map[cid.Cid][]cid.Cid{} // block -> msgs
-
-	par(50, maparr(toSync), func(header *types.BlockHeader) {
-		msgs, err := api.ChainGetBlockMessages(ctx, header.Cid())
-		if err != nil {
-			log.Error(err)
-			return
-		}
-
-		vmm := make([]*types.Message, 0, len(msgs.Cids))
-		for _, m := range msgs.BlsMessages {
-			vmm = append(vmm, m)
-		}
-
-		for _, m := range msgs.SecpkMessages {
-			vmm = append(vmm, &m.Message)
-		}
-
-		lk.Lock()
-		for _, message := range vmm {
-			messages[message.Cid()] = message
-			inclusions[header.Cid()] = append(inclusions[header.Cid()], message.Cid())
-		}
-		lk.Unlock()
-	})
-
-	return messages, inclusions
-}
-
-type mrec struct {
-	msg   cid.Cid
-	state cid.Cid
-	idx   int
-}
-
-func fetchParentReceipts(ctx context.Context, api api.FullNode, toSync map[cid.Cid]*types.BlockHeader) map[mrec]*types.MessageReceipt {
-	var lk sync.Mutex
-	out := map[mrec]*types.MessageReceipt{}
-
-	par(50, maparr(toSync), func(header *types.BlockHeader) {
-		recs, err := api.ChainGetParentReceipts(ctx, header.Cid())
-		if err != nil {
-			log.Error(err)
-			return
-		}
-		msgs, err := api.ChainGetParentMessages(ctx, header.Cid())
-		if err != nil {
-			log.Error(err)
-			return
-		}
-
-		lk.Lock()
-		for i, r := range recs {
-			out[mrec{
-				msg:   msgs[i].Cid,
-				state: header.ParentStateRoot,
-				idx:   i,
-			}] = r
-		}
-		lk.Unlock()
-	})
-
-	return out
-}
diff --git a/cmd/lotus-chainwatch/syncer/blockssub.go b/cmd/lotus-chainwatch/syncer/blockssub.go
new file mode 100644
index 000000000..ea9c079e8
--- /dev/null
+++ b/cmd/lotus-chainwatch/syncer/blockssub.go
@@ -0,0 +1,27 @@
+package syncer
+
+import (
+	"context"
+	"time"
+
+	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/ipfs/go-cid"
+)
+
+func (s *Syncer) subBlocks(ctx context.Context) {
+	sub, err := s.node.SyncIncomingBlocks(ctx)
+	if err != nil {
+		log.Errorf("opening incoming block channel: %+v", err)
+		return
+	}
+
+	log.Infow("Capturing incoming blocks")
+	for bh := range sub {
+		err := s.storeHeaders(map[cid.Cid]*types.BlockHeader{
+			bh.Cid(): bh,
+		}, false, time.Now())
+		if err != nil {
+			log.Errorf("storing incoming block header: %+v", err)
+		}
+	}
+}
diff --git a/cmd/lotus-chainwatch/syncer/sync.go b/cmd/lotus-chainwatch/syncer/sync.go
new file mode 100644
index 000000000..609b71088
--- /dev/null
+++ b/cmd/lotus-chainwatch/syncer/sync.go
@@ -0,0 +1,527 @@
+package syncer
+
+import (
+	"container/list"
+	"context"
+	"database/sql"
+	"fmt"
+	"sync"
+	"time"
+
+	"golang.org/x/xerrors"
+
+	"github.com/ipfs/go-cid"
+	logging "github.com/ipfs/go-log/v2"
+
+	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/chain/store"
+	"github.com/filecoin-project/lotus/chain/types"
+)
+
+var log = logging.Logger("syncer")
+
+type Syncer struct {
+	db *sql.DB
+
+	lookbackLimit uint64
+
+	headerLk sync.Mutex
+	node     api.FullNode
+}
+
+func NewSyncer(db *sql.DB, node api.FullNode, lookbackLimit uint64) *Syncer {
+	return &Syncer{
+		db:            db,
+		node:          node,
+		lookbackLimit: lookbackLimit,
+	}
+}
+
+func (s *Syncer) setupSchemas() error {
+	tx, err := s.db.Begin()
+	if err != nil {
+		return err
+	}
+
+	if _, err := tx.Exec(`
+/* tracks circulating fil available on the network at each tipset */
+create table if not exists chain_economics
+(
+	parent_state_root text not null
+		constraint chain_economics_pk primary key,
+	circulating_fil text not null,
+	vested_fil text not null,
+	mined_fil text not null,
+	burnt_fil text not null,
+	locked_fil text not null
+);
+
+create table if not exists block_cids
+(
+	cid text not null
+		constraint block_cids_pk
+			primary key
+);
+
+create unique index if not exists block_cids_cid_uindex
+	on block_cids (cid);
+
+create table if not exists blocks_synced
+(
+	cid text not null
+		constraint blocks_synced_pk
+			primary key
+	    constraint blocks_block_cids_cid_fk
+			references block_cids (cid),
+	synced_at int not null,
+	processed_at int
+);
+
+create unique index if not exists blocks_synced_cid_uindex
+	on blocks_synced (cid,processed_at);
+
+create table if not exists block_parents
+(
+	block text not null
+	    constraint blocks_block_cids_cid_fk
+			references block_cids (cid),
+	parent text not null
+);
+
+create unique index if not exists block_parents_block_parent_uindex
+	on block_parents (block, parent);
+
+create table if not exists drand_entries
+(
+    round bigint not null
+    	constraint drand_entries_pk
+			primary key,
+	data bytea not null
+);
+create unique index if not exists drand_entries_round_uindex
+	on drand_entries (round);
+
+create table if not exists block_drand_entries
+(
+    round bigint not null
+    	constraint block_drand_entries_drand_entries_round_fk
+			references drand_entries (round),
+	block text not null
+	    constraint blocks_block_cids_cid_fk
+			references block_cids (cid)
+);
+create unique index if not exists block_drand_entries_round_uindex
+	on block_drand_entries (round, block);
+
+create table if not exists blocks
+(
+	cid text not null
+		constraint blocks_pk
+			primary key
+	    constraint blocks_block_cids_cid_fk
+			references block_cids (cid),
+	parentWeight numeric not null,
+	parentStateRoot text not null,
+	height bigint not null,
+	miner text not null,
+	timestamp bigint not null,
+	ticket bytea not null,
+	election_proof bytea,
+	win_count bigint,
+	parent_base_fee text not null,
+	forksig bigint not null
+);
+
+create unique index if not exists block_cid_uindex
+	on blocks (cid,height);
+
+create materialized view if not exists state_heights
+    as select min(b.height) height, b.parentstateroot
+	from blocks b group by b.parentstateroot;
+
+create index if not exists state_heights_height_index
+	on state_heights (height);
+
+create index if not exists state_heights_parentstateroot_index
+	on state_heights (parentstateroot);
+`); err != nil {
+		return err
+	}
+
+	return tx.Commit()
+}
+
+func (s *Syncer) Start(ctx context.Context) {
+	if err := logging.SetLogLevel("syncer", "info"); err != nil {
+		log.Fatal(err)
+	}
+	log.Debug("Starting Syncer")
+
+	if err := s.setupSchemas(); err != nil {
+		log.Fatal(err)
+	}
+
+	// capture all reported blocks
+	go s.subBlocks(ctx)
+
+	// we need to ensure that on a restart we don't reprocess the whole flarping chain
+	var sinceEpoch uint64
+	blkCID, height, err := s.mostRecentlySyncedBlockHeight()
+	if err != nil {
+		log.Fatalw("failed to find most recently synced block", "error", err)
+	} else {
+		if height > 0 {
+			log.Infow("Found starting point for syncing", "blockCID", blkCID.String(), "height", height)
+			sinceEpoch = uint64(height)
+		}
+	}
+
+	// continue to keep the block headers table up to date.
+	notifs, err := s.node.ChainNotify(ctx)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	go func() {
+		for notif := range notifs {
+			for _, change := range notif {
+				switch change.Type {
+				case store.HCCurrent:
+					// This case is important for capturing the initial state of a node
+					// which might be on a dead network with no new blocks being produced.
+					// It also allows a fresh Chainwatch instance to start walking the
+					// chain without waiting for a new block to come along.
+					fallthrough
+				case store.HCApply:
+					unsynced, err := s.unsyncedBlocks(ctx, change.Val, sinceEpoch)
+					if err != nil {
+						log.Errorw("failed to gather unsynced blocks", "error", err)
+					}
+
+					if err := s.storeCirculatingSupply(ctx, change.Val); err != nil {
+						log.Errorw("failed to store circulating supply", "error", err)
+					}
+
+					if len(unsynced) == 0 {
+						continue
+					}
+
+					if err := s.storeHeaders(unsynced, true, time.Now()); err != nil {
+						// so this is pretty bad, need some kind of retry..
+						// for now just log an error and the blocks will be attempted again on next notifi
+						log.Errorw("failed to store unsynced blocks", "error", err)
+					}
+
+					sinceEpoch = uint64(change.Val.Height())
+				case store.HCRevert:
+					log.Debug("revert todo")
+				}
+			}
+		}
+	}()
+}
+
+func (s *Syncer) unsyncedBlocks(ctx context.Context, head *types.TipSet, since uint64) (map[cid.Cid]*types.BlockHeader, error) {
+	hasList, err := s.syncedBlocks(since, s.lookbackLimit)
+	if err != nil {
+		return nil, err
+	}
+
+	// build a list of blocks that we have not synced.
+	toVisit := list.New()
+	for _, header := range head.Blocks() {
+		toVisit.PushBack(header)
+	}
+
+	toSync := map[cid.Cid]*types.BlockHeader{}
+
+	for toVisit.Len() > 0 {
+		bh := toVisit.Remove(toVisit.Back()).(*types.BlockHeader)
+		_, has := hasList[bh.Cid()]
+		if _, seen := toSync[bh.Cid()]; seen || has {
+			continue
+		}
+
+		toSync[bh.Cid()] = bh
+		if len(toSync)%500 == 10 {
+			log.Debugw("To visit", "toVisit", toVisit.Len(), "toSync", len(toSync), "current_height", bh.Height)
+		}
+
+		if bh.Height == 0 {
+			continue
+		}
+
+		pts, err := s.node.ChainGetTipSet(ctx, types.NewTipSetKey(bh.Parents...))
+		if err != nil {
+			log.Error(err)
+			continue
+		}
+
+		for _, header := range pts.Blocks() {
+			toVisit.PushBack(header)
+		}
+	}
+	log.Debugw("Gathered unsynced blocks", "count", len(toSync))
+	return toSync, nil
+}
+
+func (s *Syncer) syncedBlocks(since, limit uint64) (map[cid.Cid]struct{}, error) {
+	rws, err := s.db.Query(`select bs.cid FROM blocks_synced bs left join blocks b on b.cid = bs.cid where b.height <= $1 and bs.processed_at is not null limit $2`, since, limit)
+	if err != nil {
+		return nil, xerrors.Errorf("Failed to query blocks_synced: %w", err)
+	}
+	out := map[cid.Cid]struct{}{}
+
+	for rws.Next() {
+		var c string
+		if err := rws.Scan(&c); err != nil {
+			return nil, xerrors.Errorf("Failed to scan blocks_synced: %w", err)
+		}
+
+		ci, err := cid.Parse(c)
+		if err != nil {
+			return nil, xerrors.Errorf("Failed to parse blocks_synced: %w", err)
+		}
+
+		out[ci] = struct{}{}
+	}
+	return out, nil
+}
+
+func (s *Syncer) mostRecentlySyncedBlockHeight() (cid.Cid, int64, error) {
+	rw := s.db.QueryRow(`
+select blocks_synced.cid, b.height
+from blocks_synced
+left join blocks b on blocks_synced.cid = b.cid
+where processed_at is not null
+order by height desc
+limit 1
+`)
+
+	var c string
+	var h int64
+	if err := rw.Scan(&c, &h); err != nil {
+		if err == sql.ErrNoRows {
+			return cid.Undef, 0, nil
+		}
+		return cid.Undef, -1, err
+	}
+
+	ci, err := cid.Parse(c)
+	if err != nil {
+		return cid.Undef, -1, err
+	}
+
+	return ci, h, nil
+}
+
+func (s *Syncer) storeCirculatingSupply(ctx context.Context, tipset *types.TipSet) error {
+	supply, err := s.node.StateCirculatingSupply(ctx, tipset.Key())
+	if err != nil {
+		return err
+	}
+
+	ceInsert := `insert into chain_economics (parent_state_root, circulating_fil, vested_fil, mined_fil, burnt_fil, locked_fil) ` +
+		`values ('%s', '%s', '%s', '%s', '%s', '%s') on conflict on constraint chain_economics_pk do ` +
+		`update set (circulating_fil, vested_fil, mined_fil, burnt_fil, locked_fil) = ('%[2]s', '%[3]s', '%[4]s', '%[5]s', '%[6]s') ` +
+		`where chain_economics.parent_state_root = '%[1]s';`
+
+	if _, err := s.db.Exec(fmt.Sprintf(ceInsert,
+		tipset.ParentState().String(),
+		supply.FilCirculating.String(),
+		supply.FilVested.String(),
+		supply.FilMined.String(),
+		supply.FilBurnt.String(),
+		supply.FilLocked.String(),
+	)); err != nil {
+		return xerrors.Errorf("insert circulating supply for tipset (%s): %w", tipset.Key().String(), err)
+	}
+
+	return nil
+}
+
+func (s *Syncer) storeHeaders(bhs map[cid.Cid]*types.BlockHeader, sync bool, timestamp time.Time) error {
+	s.headerLk.Lock()
+	defer s.headerLk.Unlock()
+	if len(bhs) == 0 {
+		return nil
+	}
+	log.Debugw("Storing Headers", "count", len(bhs))
+
+	tx, err := s.db.Begin()
+	if err != nil {
+		return xerrors.Errorf("begin: %w", err)
+	}
+
+	if _, err := tx.Exec(`
+
+create temp table bc (like block_cids excluding constraints) on commit drop;
+create temp table de (like drand_entries excluding constraints) on commit drop;
+create temp table bde (like block_drand_entries excluding constraints) on commit drop;
+create temp table tbp (like block_parents excluding constraints) on commit drop;
+create temp table bs (like blocks_synced excluding constraints) on commit drop;
+create temp table b (like blocks excluding constraints) on commit drop;
+
+
+`); err != nil {
+		return xerrors.Errorf("prep temp: %w", err)
+	}
+
+	{
+		stmt, err := tx.Prepare(`copy bc (cid) from STDIN`)
+		if err != nil {
+			return err
+		}
+
+		for _, bh := range bhs {
+			if _, err := stmt.Exec(bh.Cid().String()); err != nil {
+				log.Error(err)
+			}
+		}
+
+		if err := stmt.Close(); err != nil {
+			return err
+		}
+
+		if _, err := tx.Exec(`insert into block_cids select * from bc on conflict do nothing `); err != nil {
+			return xerrors.Errorf("drand entries put: %w", err)
+		}
+	}
+
+	{
+		stmt, err := tx.Prepare(`copy de (round, data) from STDIN`)
+		if err != nil {
+			return err
+		}
+
+		for _, bh := range bhs {
+			for _, ent := range bh.BeaconEntries {
+				if _, err := stmt.Exec(ent.Round, ent.Data); err != nil {
+					log.Error(err)
+				}
+			}
+		}
+
+		if err := stmt.Close(); err != nil {
+			return err
+		}
+
+		if _, err := tx.Exec(`insert into drand_entries select * from de on conflict do nothing `); err != nil {
+			return xerrors.Errorf("drand entries put: %w", err)
+		}
+	}
+
+	{
+		stmt, err := tx.Prepare(`copy bde (round, block) from STDIN`)
+		if err != nil {
+			return err
+		}
+
+		for _, bh := range bhs {
+			for _, ent := range bh.BeaconEntries {
+				if _, err := stmt.Exec(ent.Round, bh.Cid().String()); err != nil {
+					log.Error(err)
+				}
+			}
+		}
+
+		if err := stmt.Close(); err != nil {
+			return err
+		}
+
+		if _, err := tx.Exec(`insert into block_drand_entries select * from bde on conflict do nothing `); err != nil {
+			return xerrors.Errorf("block drand entries put: %w", err)
+		}
+	}
+
+	{
+		stmt, err := tx.Prepare(`copy tbp (block, parent) from STDIN`)
+		if err != nil {
+			return err
+		}
+
+		for _, bh := range bhs {
+			for _, parent := range bh.Parents {
+				if _, err := stmt.Exec(bh.Cid().String(), parent.String()); err != nil {
+					log.Error(err)
+				}
+			}
+		}
+
+		if err := stmt.Close(); err != nil {
+			return err
+		}
+
+		if _, err := tx.Exec(`insert into block_parents select * from tbp on conflict do nothing `); err != nil {
+			return xerrors.Errorf("parent put: %w", err)
+		}
+	}
+
+	if sync {
+
+		stmt, err := tx.Prepare(`copy bs (cid, synced_at) from stdin `)
+		if err != nil {
+			return err
+		}
+
+		for _, bh := range bhs {
+			if _, err := stmt.Exec(bh.Cid().String(), timestamp.Unix()); err != nil {
+				log.Error(err)
+			}
+		}
+
+		if err := stmt.Close(); err != nil {
+			return err
+		}
+
+		if _, err := tx.Exec(`insert into blocks_synced select * from bs on conflict do nothing `); err != nil {
+			return xerrors.Errorf("syncd put: %w", err)
+		}
+	}
+
+	stmt2, err := tx.Prepare(`copy b (cid, parentWeight, parentStateRoot, height, miner, "timestamp", ticket, election_proof, win_count, parent_base_fee, forksig) from stdin`)
+	if err != nil {
+		return err
+	}
+
+	for _, bh := range bhs {
+		var eproof, winCount interface{}
+		if bh.ElectionProof != nil {
+			eproof = bh.ElectionProof.VRFProof
+			winCount = bh.ElectionProof.WinCount
+		}
+
+		if bh.Ticket == nil {
+			log.Warnf("got a block with nil ticket")
+
+			bh.Ticket = &types.Ticket{
+				VRFProof: []byte{},
+			}
+		}
+
+		if _, err := stmt2.Exec(
+			bh.Cid().String(),
+			bh.ParentWeight.String(),
+			bh.ParentStateRoot.String(),
+			bh.Height,
+			bh.Miner.String(),
+			bh.Timestamp,
+			bh.Ticket.VRFProof,
+			eproof,
+			winCount,
+			bh.ParentBaseFee.String(),
+			bh.ForkSignaling); err != nil {
+			log.Error(err)
+		}
+	}
+
+	if err := stmt2.Close(); err != nil {
+		return xerrors.Errorf("s2 close: %w", err)
+	}
+
+	if _, err := tx.Exec(`insert into blocks select * from b on conflict do nothing `); err != nil {
+		return xerrors.Errorf("blk put: %w", err)
+	}
+
+	return tx.Commit()
+}
diff --git a/cmd/lotus-chainwatch/templates.go b/cmd/lotus-chainwatch/templates.go
deleted file mode 100644
index 02e85d6b0..000000000
--- a/cmd/lotus-chainwatch/templates.go
+++ /dev/null
@@ -1,253 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"html/template"
-	"net/http"
-	"os"
-	"path/filepath"
-
-	rice "github.com/GeertJohan/go.rice"
-	"github.com/ipfs/go-cid"
-	"golang.org/x/xerrors"
-
-	"github.com/filecoin-project/lotus/api"
-	"github.com/filecoin-project/lotus/chain/types"
-)
-
-type handler struct {
-	api    api.FullNode
-	st     *storage
-	site   *rice.Box
-	assets http.Handler
-
-	templates map[string]*template.Template
-}
-
-func newHandler(api api.FullNode, st *storage) (*handler, error) {
-	h := &handler{
-		api:  api,
-		st:   st,
-		site: rice.MustFindBox("site"),
-
-		templates: map[string]*template.Template{},
-	}
-	h.assets = http.FileServer(h.site.HTTPBox())
-
-	funcs := template.FuncMap{
-		"count":    h.count,
-		"countCol": h.countCol,
-		"sum":      h.sum,
-		"netPower": h.netPower,
-		"queryNum": h.queryNum,
-		"sizeStr":  sizeStr,
-		"strings":  h.strings,
-		"messages": h.messages,
-
-		"param": func(string) string { return "" }, // replaced in request handler
-	}
-
-	base := template.New("")
-
-	base.Funcs(funcs)
-
-	return h, h.site.Walk("", func(path string, info os.FileInfo, err error) error {
-		if filepath.Ext(path) != ".html" {
-			return nil
-		}
-		if err != nil {
-			return err
-		}
-		log.Info(path)
-
-		h.templates["/"+path], err = base.New(path).Parse(h.site.MustString(path))
-		return err
-	})
-}
-
-func (h *handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-	h, err := newHandler(h.api, h.st) // for faster dev
-	if err != nil {
-		log.Error(err)
-		return
-	}
-
-	p := r.URL.Path
-	if p == "/" {
-		p = "/index.html"
-	}
-
-	t, ok := h.templates[p]
-	if !ok {
-		h.assets.ServeHTTP(w, r)
-		return
-	}
-
-	t, err = t.Clone()
-	if err != nil {
-		log.Error(err)
-		return
-	}
-
-	t.Funcs(map[string]interface{}{
-		"param": r.FormValue,
-	})
-
-	if err := t.Execute(w, nil); err != nil {
-		log.Errorf("%+v", err)
-		return
-	}
-
-	log.Info(r.URL.Path)
-}
-
-// Template funcs
-
-func (h *handler) count(table string, filters ...string) (int, error) {
-	// explicitly not caring about sql injection too much, this doesn't take user input
-
-	filts := ""
-	if len(filters) > 0 {
-		filts = " where "
-		for _, filter := range filters {
-			filts += filter + " and "
-		}
-		filts = filts[:len(filts)-5]
-	}
-
-	var c int
-	err := h.st.db.QueryRow("select count(1) from " + table + filts).Scan(&c)
-	if err != nil {
-		return 0, err
-	}
-
-	return c, nil
-}
-
-func (h *handler) countCol(table string, col string, filters ...string) (int, error) {
-	// explicitly not caring about sql injection too much, this doesn't take user input
-
-	filts := ""
-	if len(filters) > 0 {
-		filts = " where "
-		for _, filter := range filters {
-			filts += filter + " and "
-		}
-		filts = filts[:len(filts)-5]
-	}
-
-	var c int
-	err := h.st.db.QueryRow("select count(distinct " + col + ") from " + table + filts).Scan(&c)
-	if err != nil {
-		return 0, err
-	}
-
-	return c, nil
-}
-
-func (h *handler) sum(table string, col string) (types.BigInt, error) {
-	return h.queryNum("select sum(cast(" + col + " as bigint)) from " + table)
-}
-
-func (h *handler) netPower(slashFilt string) (types.BigInt, error) {
-	if slashFilt != "" {
-		slashFilt = " where " + slashFilt
-	}
-	return h.queryNum(`select sum(power) from (
-	select miner_heads.power, miner_heads.slashed_at, max(height) from miner_heads
-    	inner join blocks b on miner_heads.stateroot = b.parentStateRoot
-	group by miner_heads.addr)` + slashFilt)
-}
-
-func (h *handler) queryNum(q string, p ...interface{}) (types.BigInt, error) {
-	// explicitly not caring about sql injection too much, this doesn't take user input
-
-	var c string
-	err := h.st.db.QueryRow(q, p...).Scan(&c)
-	if err != nil {
-		log.Error("qnum ", q, p, err)
-		return types.NewInt(0), err
-	}
-
-	i := types.NewInt(0)
-	_, ok := i.SetString(c, 10)
-	if !ok {
-		return types.NewInt(0), xerrors.New("num parse error: " + c)
-	}
-	return i, nil
-}
-
-var units = []string{"B", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "ZiB"}
-
-func sizeStr(size types.BigInt) string {
-	size = types.BigMul(size, types.NewInt(100))
-	i := 0
-	for types.BigCmp(size, types.NewInt(102400)) >= 0 && i < len(units)-1 {
-		size = types.BigDiv(size, types.NewInt(1024))
-		i++
-	}
-	return fmt.Sprintf("%s.%s %s", types.BigDiv(size, types.NewInt(100)), types.BigMod(size, types.NewInt(100)), units[i])
-}
-
-func (h *handler) strings(table string, col string, filter string, args ...interface{}) (out []string, err error) {
-	if len(filter) > 0 {
-		filter = " where " + filter
-	}
-	log.Info("strings qstr ", "select "+col+" from "+table+filter)
-	rws, err := h.st.db.Query("select "+col+" from "+table+filter, args...)
-	if err != nil {
-		return nil, err
-	}
-	for rws.Next() {
-		var r string
-		if err := rws.Scan(&r); err != nil {
-			return nil, err
-		}
-		out = append(out, r)
-	}
-
-	return
-}
-
-func (h *handler) messages(filter string, args ...interface{}) (out []types.Message, err error) {
-	if len(filter) > 0 {
-		filter = " where " + filter
-	}
-
-	rws, err := h.st.db.Query("select * from messages "+filter, args...)
-	if err != nil {
-		return nil, err
-	}
-	for rws.Next() {
-		var r types.Message
-		var cs string
-
-		if err := rws.Scan(
-			&cs,
-			&r.From,
-			&r.To,
-			&r.Nonce,
-			&r.Value,
-			&r.GasPrice,
-			&r.GasLimit,
-			&r.Method,
-			&r.Params,
-		); err != nil {
-			return nil, err
-		}
-
-		c, err := cid.Parse(cs)
-		if err != nil {
-			return nil, err
-		}
-		if c != r.Cid() {
-			log.Warn("msg cid doesn't match")
-		}
-
-		out = append(out, r)
-	}
-
-	return
-}
-
-var _ http.Handler = &handler{}
diff --git a/cmd/lotus-chainwatch/util/api.go b/cmd/lotus-chainwatch/util/api.go
new file mode 100644
index 000000000..cfda833e0
--- /dev/null
+++ b/cmd/lotus-chainwatch/util/api.go
@@ -0,0 +1,34 @@
+package util
+
+import (
+	"context"
+	"net/http"
+
+	"github.com/filecoin-project/go-jsonrpc"
+	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/api/client"
+	ma "github.com/multiformats/go-multiaddr"
+	manet "github.com/multiformats/go-multiaddr/net"
+)
+
+func GetFullNodeAPIUsingCredentials(ctx context.Context, listenAddr, token string) (api.FullNode, jsonrpc.ClientCloser, error) {
+	parsedAddr, err := ma.NewMultiaddr(listenAddr)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	_, addr, err := manet.DialArgs(parsedAddr)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	return client.NewFullNodeRPC(ctx, apiURI(addr), apiHeaders(token))
+}
+func apiURI(addr string) string {
+	return "ws://" + addr + "/rpc/v0"
+}
+func apiHeaders(token string) http.Header {
+	headers := http.Header{}
+	headers.Add("Authorization", "Bearer "+token)
+	return headers
+}
diff --git a/cmd/lotus-chainwatch/util/contextStore.go b/cmd/lotus-chainwatch/util/contextStore.go
new file mode 100644
index 000000000..bd812581b
--- /dev/null
+++ b/cmd/lotus-chainwatch/util/contextStore.go
@@ -0,0 +1,51 @@
+package util
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+
+	"github.com/ipfs/go-cid"
+	cbg "github.com/whyrusleeping/cbor-gen"
+
+	"github.com/filecoin-project/lotus/api"
+)
+
+// TODO extract this to a common location in lotus and reuse the code
+
+// APIIpldStore is required for AMT and HAMT access.
+type APIIpldStore struct {
+	ctx context.Context
+	api api.FullNode
+}
+
+func NewAPIIpldStore(ctx context.Context, api api.FullNode) *APIIpldStore {
+	return &APIIpldStore{
+		ctx: ctx,
+		api: api,
+	}
+}
+
+func (ht *APIIpldStore) Context() context.Context {
+	return ht.ctx
+}
+
+func (ht *APIIpldStore) Get(ctx context.Context, c cid.Cid, out interface{}) error {
+	raw, err := ht.api.ChainReadObj(ctx, c)
+	if err != nil {
+		return err
+	}
+
+	cu, ok := out.(cbg.CBORUnmarshaler)
+	if ok {
+		if err := cu.UnmarshalCBOR(bytes.NewReader(raw)); err != nil {
+			return err
+		}
+		return nil
+	}
+	return fmt.Errorf("Object does not implement CBORUnmarshaler: %T", out)
+}
+
+func (ht *APIIpldStore) Put(ctx context.Context, v interface{}) (cid.Cid, error) {
+	return cid.Undef, fmt.Errorf("Put is not implemented on APIIpldStore")
+}
diff --git a/cmd/lotus-fountain/main.go b/cmd/lotus-fountain/main.go
index 33abeb76b..ea7190e83 100644
--- a/cmd/lotus-fountain/main.go
+++ b/cmd/lotus-fountain/main.go
@@ -6,28 +6,22 @@ import (
 	"net"
 	"net/http"
 	"os"
-	"strconv"
 	"time"
 
 	rice "github.com/GeertJohan/go.rice"
-	"github.com/ipfs/go-cid"
-	logging "github.com/ipfs/go-log"
-	peer "github.com/libp2p/go-libp2p-peer"
+	logging "github.com/ipfs/go-log/v2"
+	"github.com/urfave/cli/v2"
 	"golang.org/x/xerrors"
-	"gopkg.in/urfave/cli.v2"
 
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/build"
-	"github.com/filecoin-project/lotus/chain/actors"
 	"github.com/filecoin-project/lotus/chain/types"
 	lcli "github.com/filecoin-project/lotus/cli"
 )
 
 var log = logging.Logger("main")
 
-var sendPerRequest, _ = types.ParseFIL("0.005")
-
 func main() {
 	logging.SetLogLevel("*", "INFO")
 
@@ -40,7 +34,7 @@ func main() {
 	app := &cli.App{
 		Name:    "lotus-fountain",
 		Usage:   "Devnet token distribution utility",
-		Version: build.UserVersion,
+		Version: build.UserVersion(),
 		Flags: []cli.Flag{
 			&cli.StringFlag{
 				Name:    "repo",
@@ -69,8 +63,18 @@ var runCmd = &cli.Command{
 		&cli.StringFlag{
 			Name: "from",
 		},
+		&cli.StringFlag{
+			Name:    "amount",
+			EnvVars: []string{"LOTUS_FOUNTAIN_AMOUNT"},
+			Value:   "50",
+		},
 	},
 	Action: func(cctx *cli.Context) error {
+		sendPerRequest, err := types.ParseFIL(cctx.String("amount"))
+		if err != nil {
+			return err
+		}
+
 		nodeApi, closer, err := lcli.GetFullNodeAPI(cctx)
 		if err != nil {
 			return err
@@ -91,32 +95,22 @@ var runCmd = &cli.Command{
 		}
 
 		h := &handler{
-			ctx:  ctx,
-			api:  nodeApi,
-			from: from,
+			ctx:            ctx,
+			api:            nodeApi,
+			from:           from,
+			sendPerRequest: sendPerRequest,
 			limiter: NewLimiter(LimiterConfig{
-				TotalRate:   time.Second,
-				TotalBurst:  20,
-				IPRate:      time.Minute,
+				TotalRate:   500 * time.Millisecond,
+				TotalBurst:  build.BlockMessageLimit,
+				IPRate:      10 * time.Minute,
 				IPBurst:     5,
 				WalletRate:  15 * time.Minute,
 				WalletBurst: 2,
 			}),
-			minerLimiter: NewLimiter(LimiterConfig{
-				TotalRate:   time.Second,
-				TotalBurst:  20,
-				IPRate:      10 * time.Minute,
-				IPBurst:     2,
-				WalletRate:  1 * time.Hour,
-				WalletBurst: 2,
-			}),
 		}
 
 		http.Handle("/", http.FileServer(rice.MustFindBox("site").HTTPBox()))
 		http.HandleFunc("/send", h.send)
-		http.HandleFunc("/mkminer", h.mkminer)
-		http.HandleFunc("/msgwait", h.msgwait)
-		http.HandleFunc("/msgwaitaddr", h.msgwaitaddr)
 
 		fmt.Printf("Open http://%s\n", cctx.String("front"))
 
@@ -133,17 +127,16 @@ type handler struct {
 	ctx context.Context
 	api api.FullNode
 
-	from address.Address
+	from           address.Address
+	sendPerRequest types.FIL
 
-	limiter      *Limiter
-	minerLimiter *Limiter
+	limiter *Limiter
 }
 
 func (h *handler) send(w http.ResponseWriter, r *http.Request) {
 	to, err := address.NewFromString(r.FormValue("address"))
 	if err != nil {
-		w.WriteHeader(400)
-		w.Write([]byte(err.Error()))
+		http.Error(w, err.Error(), http.StatusBadRequest)
 		return
 	}
 
@@ -181,172 +174,14 @@ func (h *handler) send(w http.ResponseWriter, r *http.Request) {
 	}
 
 	smsg, err := h.api.MpoolPushMessage(h.ctx, &types.Message{
-		Value: types.BigInt(sendPerRequest),
+		Value: types.BigInt(h.sendPerRequest),
 		From:  h.from,
 		To:    to,
-
-		GasPrice: types.NewInt(0),
-		GasLimit: types.NewInt(1000),
-	})
+	}, nil)
 	if err != nil {
-		w.WriteHeader(400)
-		w.Write([]byte(err.Error()))
+		http.Error(w, err.Error(), http.StatusBadRequest)
 		return
 	}
 
-	w.Write([]byte(smsg.Cid().String()))
-}
-
-func (h *handler) mkminer(w http.ResponseWriter, r *http.Request) {
-	owner, err := address.NewFromString(r.FormValue("address"))
-	if err != nil {
-		w.WriteHeader(400)
-		w.Write([]byte(err.Error()))
-		return
-	}
-
-	if owner.Protocol() != address.BLS {
-		w.WriteHeader(400)
-		w.Write([]byte("Miner address must use BLS"))
-		return
-	}
-
-	ssize, err := strconv.ParseInt(r.FormValue("sectorSize"), 10, 64)
-	if err != nil {
-		return
-	}
-
-	log.Infof("%s: create actor start", owner)
-
-	// Limit based on wallet address
-	limiter := h.minerLimiter.GetWalletLimiter(owner.String())
-	if !limiter.Allow() {
-		http.Error(w, http.StatusText(http.StatusTooManyRequests)+": wallet limit", http.StatusTooManyRequests)
-		return
-	}
-
-	// Limit based on IP
-	limiter = h.minerLimiter.GetIPLimiter(r.RemoteAddr)
-	if !limiter.Allow() {
-		http.Error(w, http.StatusText(http.StatusTooManyRequests)+": IP limit", http.StatusTooManyRequests)
-		return
-	}
-
-	// General limiter owner allow throttling all messages that can make it into the mpool
-	if !h.minerLimiter.Allow() {
-		http.Error(w, http.StatusText(http.StatusTooManyRequests)+": global limit", http.StatusTooManyRequests)
-		return
-	}
-
-	collateral, err := h.api.StatePledgeCollateral(r.Context(), nil)
-	if err != nil {
-		w.WriteHeader(400)
-		w.Write([]byte(err.Error()))
-		return
-	}
-
-	smsg, err := h.api.MpoolPushMessage(h.ctx, &types.Message{
-		Value: types.BigInt(sendPerRequest),
-		From:  h.from,
-		To:    owner,
-
-		GasPrice: types.NewInt(0),
-		GasLimit: types.NewInt(1000),
-	})
-	if err != nil {
-		w.WriteHeader(400)
-		w.Write([]byte("pushfunds: " + err.Error()))
-		return
-	}
-	log.Infof("%s: push funds %s", owner, smsg.Cid())
-
-	params, err := actors.SerializeParams(&actors.CreateStorageMinerParams{
-		Owner:      owner,
-		Worker:     owner,
-		SectorSize: uint64(ssize),
-		PeerID:     peer.ID("SETME"),
-	})
-	if err != nil {
-		w.WriteHeader(400)
-		w.Write([]byte(err.Error()))
-		return
-	}
-
-	createStorageMinerMsg := &types.Message{
-		To:    actors.StoragePowerAddress,
-		From:  h.from,
-		Value: collateral,
-
-		Method: actors.SPAMethods.CreateStorageMiner,
-		Params: params,
-
-		GasLimit: types.NewInt(10000000),
-		GasPrice: types.NewInt(0),
-	}
-
-	signed, err := h.api.MpoolPushMessage(r.Context(), createStorageMinerMsg)
-	if err != nil {
-		w.WriteHeader(400)
-		w.Write([]byte(err.Error()))
-		return
-	}
-
-	log.Infof("%s: create miner msg: %s", owner, signed.Cid())
-
-	http.Redirect(w, r, fmt.Sprintf("/wait.html?f=%s&m=%s&o=%s", signed.Cid(), smsg.Cid(), owner), 303)
-}
-
-func (h *handler) msgwait(w http.ResponseWriter, r *http.Request) {
-	c, err := cid.Parse(r.FormValue("cid"))
-	if err != nil {
-		w.WriteHeader(400)
-		w.Write([]byte(err.Error()))
-		return
-	}
-
-	mw, err := h.api.StateWaitMsg(r.Context(), c)
-	if err != nil {
-		w.WriteHeader(400)
-		w.Write([]byte(err.Error()))
-		return
-	}
-
-	if mw.Receipt.ExitCode != 0 {
-		w.WriteHeader(400)
-		w.Write([]byte(xerrors.Errorf("create storage miner failed: exit code %d", mw.Receipt.ExitCode).Error()))
-		return
-	}
-	w.WriteHeader(200)
-}
-
-func (h *handler) msgwaitaddr(w http.ResponseWriter, r *http.Request) {
-	c, err := cid.Parse(r.FormValue("cid"))
-	if err != nil {
-		w.WriteHeader(400)
-		w.Write([]byte(err.Error()))
-		return
-	}
-
-	mw, err := h.api.StateWaitMsg(r.Context(), c)
-	if err != nil {
-		w.WriteHeader(400)
-		w.Write([]byte(err.Error()))
-		return
-	}
-
-	if mw.Receipt.ExitCode != 0 {
-		w.WriteHeader(400)
-		w.Write([]byte(xerrors.Errorf("create storage miner failed: exit code %d", mw.Receipt.ExitCode).Error()))
-		return
-	}
-	w.WriteHeader(200)
-
-	addr, err := address.NewFromBytes(mw.Receipt.Return)
-	if err != nil {
-		w.WriteHeader(400)
-		w.Write([]byte(err.Error()))
-		return
-	}
-
-	fmt.Fprintf(w, "{\"addr\": \"%s\"}", addr)
+	_, _ = w.Write([]byte(smsg.Cid().String()))
 }
diff --git a/cmd/lotus-fountain/site/index.html b/cmd/lotus-fountain/site/index.html
index 85226e4c0..644960225 100644
--- a/cmd/lotus-fountain/site/index.html
+++ b/cmd/lotus-fountain/site/index.html
@@ -13,9 +13,6 @@
         <div class="Index-node">
             <a href="funds.html">[Send Funds]</a>
         </div>
-        <div class="Index-node">
-            <a href="miner.html">[Create Miner]</a>
-        </div>
     </div>
     <div class="Index-footer">
         <div>
diff --git a/cmd/lotus-fountain/site/miner.html b/cmd/lotus-fountain/site/miner.html
deleted file mode 100644
index 0fc88e792..000000000
--- a/cmd/lotus-fountain/site/miner.html
+++ /dev/null
@@ -1,47 +0,0 @@
-<!DOCTYPE html>
-<html>
-<head>
-    <title>Creating Storage Miner - Lotus Fountain</title>
-    <link rel="stylesheet" type="text/css" href="main.css">
-</head>
-<body>
-<div class="Index">
-    <div class="Index-nodes">
-        <div class="Index-node">
-            [CREATING STORAGE MINER]
-        </div>
-        <div class="Index-node" id="formnd">
-            <form id="f" action='/mkminer' method='POST'>
-                <span>Enter destination address:</span>
-                <input type='text' name='address' style="width: 300px">
-                <select name="sectorSize">
-                    <option selected value="1073741824">1GiB sectors</option>
-                    <option value="34359738368">32GiB sectors</option>
-                </select>
-                <button type='submit'>Create Miner</button>
-            </form>
-        </div>
-        <div id="plswait" style="display: none" class="Index-node">
-            <b>Waiting for transaction on chain..</b>
-        </div>
-        <div class="Index-node">
-            <span>When creating storage miner, DO NOT REFRESH THE PAGE, wait for it to load. This can take more than 5min.</span>
-        </div>
-    </div>
-    <div class="Index-footer">
-        <div>
-            <a href="index.html">[Back]</a>
-            <span style="float: right">Not dispensing real Filecoin tokens</span>
-        </div>
-    </div>
-</div>
-<script>
-    let f = document.getElementById('f')
-    f.onsubmit = ev => {
-        document.getElementById('plswait').style.display = 'block'
-        document.getElementById('formnd').style.display = 'none'
-    }
-
-</script>
-</body>
-</html>
diff --git a/cmd/lotus-fountain/site/wait.html b/cmd/lotus-fountain/site/wait.html
deleted file mode 100644
index 97ac4795d..000000000
--- a/cmd/lotus-fountain/site/wait.html
+++ /dev/null
@@ -1,69 +0,0 @@
-<!DOCTYPE html>
-<html>
-<head>
-    <title>Sending Funds - Lotus Fountain</title>
-    <link rel="stylesheet" type="text/css" href="main.css">
-</head>
-<body>
-<div class="Index">
-    <div class="Index-nodes">
-        <div class="Index-node">
-            [CREATING STORAGE MINER]
-        </div>
-        <div class="Index-node">
-            Gas Funds:&nbsp;&nbsp;&nbsp;<span id="fcid"></span> - <span id="fstate">WAIT</span>
-        </div>
-        <div class="Index-node">
-            Miner Actor:&nbsp;<span id="mcid"></span> - <span id="mstate">WAIT</span>
-        </div>
-        <div class="Index-node" style="display: none" id="fwait">
-            New storage miners address is: <b id="actaddr">t</b>
-        </div>
-        <div class="Index-node" style="display: none" id="mwait">
-            <div style="padding-bottom: 1em">To initialize the storage miner run the following command:</div>
-            <div style="overflow-x: visible; white-space: nowrap; background: #353500">
-                <code>lotus-storage-miner init --actor=<span id="actaddr2">t</span> --owner=<span id="owner">t3</span></code>
-            </div>
-        </div>
-    </div>
-    <div class="Index-footer">
-        <div>
-            <a href="index.html">[Back]</a>
-            <span style="float: right">Not dispensing real Filecoin tokens</span>
-        </div>
-    </div>
-</div>
-<script>
-  const params = new URLSearchParams(window.location.search);
-
-  const fcid = document.getElementById('fcid')
-  const mcid = document.getElementById('mcid')
-
-  fcid.innerText = params.get('f')
-  mcid.innerText = params.get('m')
-
-  async function waitFunds() {
-    await fetch('/msgwait?cid=' + params.get('f'))
-    document.getElementById('fstate').innerText = "OK"
-
-    document.getElementById('fwait').style.display = 'block'
-  }
-
-  async function waitMiner() {
-    const resp = await fetch('/msgwaitaddr?cid=' + params.get('f'))
-    document.getElementById('mstate').innerText = "OK"
-
-    const addr = (await resp.json()).addr
-
-    document.getElementById('actaddr').innerText = addr
-    document.getElementById('actaddr2').innerText = addr
-    document.getElementById('owner').innerText = params.get('o')
-
-    document.getElementById('mwait').style.display = 'block'
-  }
-
-  waitFunds()
-  waitMiner()
-</script>
-</body>
-</html>
diff --git a/cmd/lotus-gateway/api.go b/cmd/lotus-gateway/api.go
new file mode 100644
index 000000000..42e9e4829
--- /dev/null
+++ b/cmd/lotus-gateway/api.go
@@ -0,0 +1,90 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/ipfs/go-cid"
+
+	"go.opencensus.io/trace"
+)
+
+const LookbackCap = time.Hour
+
+var (
+	ErrLookbackTooLong = fmt.Errorf("lookbacks of more than %s are disallowed", LookbackCap)
+)
+
+type GatewayAPI struct {
+	api api.FullNode
+}
+
+func (a *GatewayAPI) getTipsetTimestamp(ctx context.Context, tsk types.TipSetKey) (time.Time, error) {
+	if tsk.IsEmpty() {
+		return time.Now(), nil
+	}
+
+	ts, err := a.api.ChainGetTipSet(ctx, tsk)
+	if err != nil {
+		return time.Time{}, err
+	}
+
+	return time.Unix(int64(ts.Blocks()[0].Timestamp), 0), nil
+}
+
+func (a *GatewayAPI) checkTipset(ctx context.Context, ts types.TipSetKey) error {
+	when, err := a.getTipsetTimestamp(ctx, ts)
+	if err != nil {
+		return err
+	}
+
+	if time.Since(when) > time.Hour {
+		return ErrLookbackTooLong
+	}
+
+	return nil
+}
+
+func (a *GatewayAPI) StateGetActor(ctx context.Context, actor address.Address, ts types.TipSetKey) (*types.Actor, error) {
+	ctx, span := trace.StartSpan(ctx, "StateGetActor")
+	defer span.End()
+
+	if err := a.checkTipset(ctx, ts); err != nil {
+		return nil, fmt.Errorf("bad tipset: %w", err)
+	}
+
+	return a.api.StateGetActor(ctx, actor, ts)
+}
+
+func (a *GatewayAPI) ChainHead(ctx context.Context) (*types.TipSet, error) {
+	ctx, span := trace.StartSpan(ctx, "ChainHead")
+	defer span.End()
+	// TODO: cache and invalidate cache when timestamp is up (or have internal ChainNotify)
+
+	return a.api.ChainHead(ctx)
+}
+
+func (a *GatewayAPI) ChainGetTipSet(ctx context.Context, tsk types.TipSetKey) (*types.TipSet, error) {
+	ctx, span := trace.StartSpan(ctx, "ChainGetTipSet")
+	defer span.End()
+
+	if err := a.checkTipset(ctx, tsk); err != nil {
+		return nil, fmt.Errorf("bad tipset: %w", err)
+	}
+
+	// TODO: since we're limiting lookbacks, should just cache this (could really even cache the json response bytes)
+	return a.api.ChainGetTipSet(ctx, tsk)
+}
+
+func (a *GatewayAPI) MpoolPush(ctx context.Context, sm *types.SignedMessage) (cid.Cid, error) {
+	ctx, span := trace.StartSpan(ctx, "MpoolPush")
+	defer span.End()
+
+	// TODO: additional anti-spam checks
+
+	return a.api.MpoolPush(ctx, sm)
+}
diff --git a/cmd/lotus-gateway/main.go b/cmd/lotus-gateway/main.go
new file mode 100644
index 000000000..c19599084
--- /dev/null
+++ b/cmd/lotus-gateway/main.go
@@ -0,0 +1,112 @@
+package main
+
+import (
+	"context"
+	"net"
+	"net/http"
+	"os"
+
+	"github.com/filecoin-project/go-jsonrpc"
+	"github.com/filecoin-project/lotus/build"
+	lcli "github.com/filecoin-project/lotus/cli"
+	"github.com/filecoin-project/lotus/lib/lotuslog"
+	logging "github.com/ipfs/go-log"
+
+	"github.com/gorilla/mux"
+	"github.com/urfave/cli/v2"
+)
+
+var log = logging.Logger("gateway")
+
+func main() {
+	lotuslog.SetupLogLevels()
+
+	local := []*cli.Command{
+		runCmd,
+	}
+
+	app := &cli.App{
+		Name:    "lotus-gateway",
+		Usage:   "Public API server for lotus",
+		Version: build.UserVersion(),
+		Flags: []cli.Flag{
+			&cli.StringFlag{
+				Name:    "repo",
+				EnvVars: []string{"LOTUS_PATH"},
+				Value:   "~/.lotus", // TODO: Consider XDG_DATA_HOME
+			},
+		},
+
+		Commands: local,
+	}
+	app.Setup()
+
+	if err := app.Run(os.Args); err != nil {
+		log.Warnf("%+v", err)
+		return
+	}
+}
+
+var runCmd = &cli.Command{
+	Name:  "run",
+	Usage: "Start api server",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:  "listen",
+			Usage: "host address and port the api server will listen on",
+			Value: "0.0.0.0:2346",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		log.Info("Starting lotus gateway")
+
+		ctx := lcli.ReqContext(cctx)
+		ctx, cancel := context.WithCancel(ctx)
+		defer cancel()
+
+		api, closer, err := lcli.GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+
+		address := cctx.String("listen")
+		mux := mux.NewRouter()
+
+		log.Info("Setting up API endpoint at " + address)
+
+		rpcServer := jsonrpc.NewServer()
+		rpcServer.Register("Filecoin", &GatewayAPI{api: api})
+
+		mux.Handle("/rpc/v0", rpcServer)
+		mux.PathPrefix("/").Handler(http.DefaultServeMux)
+
+		/*ah := &auth.Handler{
+			Verify: nodeApi.AuthVerify,
+			Next:   mux.ServeHTTP,
+		}*/
+
+		srv := &http.Server{
+			Handler: mux,
+			BaseContext: func(listener net.Listener) context.Context {
+				return ctx
+			},
+		}
+
+		go func() {
+			<-ctx.Done()
+			log.Warn("Shutting down...")
+			if err := srv.Shutdown(context.TODO()); err != nil {
+				log.Errorf("shutting down RPC server failed: %s", err)
+			}
+			log.Warn("Graceful shutdown successful")
+		}()
+
+		nl, err := net.Listen("tcp", address)
+		if err != nil {
+			return err
+		}
+
+		return srv.Serve(nl)
+	},
+}
diff --git a/cmd/lotus-health/main.go b/cmd/lotus-health/main.go
new file mode 100644
index 000000000..e8a32a719
--- /dev/null
+++ b/cmd/lotus-health/main.go
@@ -0,0 +1,265 @@
+package main
+
+import (
+	"context"
+	"errors"
+	"os"
+	"os/signal"
+	"syscall"
+	"time"
+
+	cid "github.com/ipfs/go-cid"
+	logging "github.com/ipfs/go-log"
+	"github.com/urfave/cli/v2"
+
+	"github.com/filecoin-project/go-jsonrpc"
+
+	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/types"
+	lcli "github.com/filecoin-project/lotus/cli"
+)
+
+type CidWindow [][]cid.Cid
+
+var log = logging.Logger("lotus-health")
+
+func main() {
+	logging.SetLogLevel("*", "INFO")
+
+	log.Info("Starting health agent")
+
+	local := []*cli.Command{
+		watchHeadCmd,
+	}
+
+	app := &cli.App{
+		Name:     "lotus-health",
+		Usage:    "Tools for monitoring lotus daemon health",
+		Version:  build.UserVersion(),
+		Commands: local,
+		Flags: []cli.Flag{
+			&cli.StringFlag{
+				Name:    "repo",
+				EnvVars: []string{"LOTUS_PATH"},
+				Value:   "~/.lotus", // TODO: Consider XDG_DATA_HOME
+			},
+		},
+	}
+
+	if err := app.Run(os.Args); err != nil {
+		log.Fatal(err)
+		return
+	}
+}
+
+var watchHeadCmd = &cli.Command{
+	Name: "watch-head",
+	Flags: []cli.Flag{
+		&cli.IntFlag{
+			Name:  "threshold",
+			Value: 3,
+			Usage: "number of times head remains unchanged before failing health check",
+		},
+		&cli.IntFlag{
+			Name:  "interval",
+			Value: int(build.BlockDelaySecs),
+			Usage: "interval in seconds between chain head checks",
+		},
+		&cli.StringFlag{
+			Name:  "systemd-unit",
+			Value: "lotus-daemon.service",
+			Usage: "systemd unit name to restart on health check failure",
+		},
+		&cli.IntFlag{
+			Name: "api-timeout",
+			// TODO: this default value seems spurious.
+			Value: int(build.BlockDelaySecs),
+			Usage: "timeout between API retries",
+		},
+		&cli.IntFlag{
+			Name:  "api-retries",
+			Value: 8,
+			Usage: "number of API retry attempts",
+		},
+	},
+	Action: func(c *cli.Context) error {
+		var headCheckWindow CidWindow
+		threshold := c.Int("threshold")
+		interval := time.Duration(c.Int("interval")) * time.Second
+		name := c.String("systemd-unit")
+		apiRetries := c.Int("api-retries")
+		apiTimeout := time.Duration(c.Int("api-timeout")) * time.Second
+
+		nCh := make(chan interface{}, 1)
+		sCh := make(chan os.Signal, 1)
+		signal.Notify(sCh, os.Interrupt, syscall.SIGTERM)
+
+		api, closer, err := getFullNodeAPI(c, apiRetries, apiTimeout)
+		if err != nil {
+			return err
+		}
+		defer closer()
+		ctx := lcli.ReqContext(c)
+
+		go func() {
+			for {
+				log.Info("Waiting for sync to complete")
+				if err := waitForSyncComplete(ctx, api, apiRetries, apiTimeout); err != nil {
+					nCh <- err
+					return
+				}
+				headCheckWindow, err = updateWindow(ctx, api, headCheckWindow, threshold, apiRetries, apiTimeout)
+				if err != nil {
+					log.Warn("Failed to connect to API. Restarting systemd service")
+					nCh <- nil
+					return
+				}
+				ok := checkWindow(headCheckWindow, threshold)
+				if !ok {
+					log.Warn("Chain head has not updated. Restarting systemd service")
+					nCh <- nil
+					break
+				}
+				log.Info("Chain head is healthy")
+				time.Sleep(interval)
+			}
+			return
+		}()
+
+		restart, err := notifyHandler(name, nCh, sCh)
+		if err != nil {
+			return err
+		}
+		if restart != "done" {
+			return errors.New("Systemd unit failed to restart:" + restart)
+		}
+		log.Info("Restarting health agent")
+		// Exit health agent and let supervisor restart health agent
+		// Restarting lotus systemd unit kills api connection
+		os.Exit(130)
+		return nil
+	},
+}
+
+/*
+ * reads channel of slices of Cids
+ * compares slices of Cids when len is greater or equal to `t` - threshold
+ * if all slices are equal, head has not updated and returns false
+ */
+func checkWindow(window CidWindow, t int) bool {
+	var dup int
+	windowLen := len(window)
+	if windowLen >= t {
+	cidWindow:
+		for i := range window {
+			next := windowLen - 1 - i
+			// if array length is different, head is changing
+			if next >= 1 && len(window[next]) != len(window[next-1]) {
+				break cidWindow
+			}
+			// if cids are different, head is changing
+			for j := range window[next] {
+				if next >= 1 && window[next][j] != window[next-1][j] {
+					break cidWindow
+				}
+			}
+			if i < (t - 1) {
+				dup++
+			}
+		}
+
+		if dup == (t - 1) {
+			return false
+		}
+	}
+	return true
+}
+
+/*
+ * returns a slice of slices of Cids
+ * len of slice <= `t` - threshold
+ */
+func updateWindow(ctx context.Context, a api.FullNode, w CidWindow, t int, r int, to time.Duration) (CidWindow, error) {
+	head, err := getHead(ctx, a, r, to)
+	if err != nil {
+		return nil, err
+	}
+	window := appendCIDsToWindow(w, head.Cids(), t)
+	return window, err
+}
+
+/*
+ * get chain head from API
+ * retries if API no available
+ * returns tipset
+ */
+func getHead(ctx context.Context, a api.FullNode, r int, t time.Duration) (*types.TipSet, error) {
+	for i := 0; i < r; i++ {
+		head, err := a.ChainHead(ctx)
+		if err != nil && i == (r-1) {
+			return nil, err
+		}
+		if err != nil {
+			log.Warnf("Call to API failed. Retrying in %.0fs", t.Seconds())
+			time.Sleep(t)
+			continue
+		}
+		return head, err
+	}
+	return nil, nil
+}
+
+/*
+ * appends slice of Cids to window slice
+ * keeps a fixed window slice size, dropping older slices
+ * returns new window
+ */
+func appendCIDsToWindow(w CidWindow, c []cid.Cid, t int) CidWindow {
+	offset := len(w) - t + 1
+	if offset >= 0 {
+		return append(w[offset:], c)
+	}
+	return append(w, c)
+}
+
+/*
+ * wait for node to sync
+ */
+func waitForSyncComplete(ctx context.Context, a api.FullNode, r int, t time.Duration) error {
+	for {
+		select {
+		case <-ctx.Done():
+			return ctx.Err()
+		case <-time.After(3 * time.Second):
+			head, err := getHead(ctx, a, r, t)
+			if err != nil {
+				return err
+			}
+
+			if time.Now().Unix()-int64(head.MinTimestamp()) < int64(build.BlockDelaySecs) {
+				return nil
+			}
+		}
+	}
+}
+
+/*
+ * A thin wrapper around lotus cli GetFullNodeAPI
+ * Adds retry logic
+ */
+func getFullNodeAPI(ctx *cli.Context, r int, t time.Duration) (api.FullNode, jsonrpc.ClientCloser, error) {
+	for i := 0; i < r; i++ {
+		api, closer, err := lcli.GetFullNodeAPI(ctx)
+		if err != nil && i == (r-1) {
+			return nil, nil, err
+		}
+		if err != nil {
+			log.Warnf("API connection failed. Retrying in %.0fs", t.Seconds())
+			time.Sleep(t)
+			continue
+		}
+		return api, closer, err
+	}
+	return nil, nil, nil
+}
diff --git a/cmd/lotus-health/main_test.go b/cmd/lotus-health/main_test.go
new file mode 100644
index 000000000..346376167
--- /dev/null
+++ b/cmd/lotus-health/main_test.go
@@ -0,0 +1,166 @@
+package main
+
+import (
+	"testing"
+
+	cid "github.com/ipfs/go-cid"
+	mh "github.com/multiformats/go-multihash"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestAppendCIDsToWindow(t *testing.T) {
+	assert := assert.New(t)
+	var window CidWindow
+	threshold := 3
+	cid0 := makeCID("0")
+	cid1 := makeCID("1")
+	cid2 := makeCID("2")
+	cid3 := makeCID("3")
+	window = appendCIDsToWindow(window, []cid.Cid{cid0}, threshold)
+	window = appendCIDsToWindow(window, []cid.Cid{cid1}, threshold)
+	window = appendCIDsToWindow(window, []cid.Cid{cid2}, threshold)
+	window = appendCIDsToWindow(window, []cid.Cid{cid3}, threshold)
+	assert.Len(window, 3)
+	assert.Equal(window[0][0], cid1)
+	assert.Equal(window[1][0], cid2)
+	assert.Equal(window[2][0], cid3)
+}
+
+func TestCheckWindow(t *testing.T) {
+	assert := assert.New(t)
+	threshold := 3
+
+	var healthyHeadCheckWindow CidWindow
+	healthyHeadCheckWindow = appendCIDsToWindow(healthyHeadCheckWindow, []cid.Cid{
+		makeCID("abcd"),
+	}, threshold)
+	healthyHeadCheckWindow = appendCIDsToWindow(healthyHeadCheckWindow, []cid.Cid{
+		makeCID("bbcd"),
+		makeCID("bbfe"),
+	}, threshold)
+	healthyHeadCheckWindow = appendCIDsToWindow(healthyHeadCheckWindow, []cid.Cid{
+		makeCID("bbcd"),
+		makeCID("bbfe"),
+	}, threshold)
+	ok := checkWindow(healthyHeadCheckWindow, threshold)
+	assert.True(ok)
+
+	var healthyHeadCheckWindow1 CidWindow
+	healthyHeadCheckWindow1 = appendCIDsToWindow(healthyHeadCheckWindow1, []cid.Cid{
+		makeCID("bbcd"),
+		makeCID("bbfe"),
+	}, threshold)
+	healthyHeadCheckWindow1 = appendCIDsToWindow(healthyHeadCheckWindow1, []cid.Cid{
+		makeCID("bbcd"),
+		makeCID("bbfe"),
+		makeCID("abcd"),
+	}, threshold)
+	healthyHeadCheckWindow1 = appendCIDsToWindow(healthyHeadCheckWindow1, []cid.Cid{
+		makeCID("abcd"),
+	}, threshold)
+	ok = checkWindow(healthyHeadCheckWindow1, threshold)
+	assert.True(ok)
+
+	var healthyHeadCheckWindow2 CidWindow
+	healthyHeadCheckWindow2 = appendCIDsToWindow(healthyHeadCheckWindow2, []cid.Cid{
+		makeCID("bbcd"),
+		makeCID("bbfe"),
+	}, threshold)
+	healthyHeadCheckWindow2 = appendCIDsToWindow(healthyHeadCheckWindow2, []cid.Cid{
+		makeCID("abcd"),
+	}, threshold)
+	ok = checkWindow(healthyHeadCheckWindow2, threshold)
+	assert.True(ok)
+
+	var healthyHeadCheckWindow3 CidWindow
+	healthyHeadCheckWindow3 = appendCIDsToWindow(healthyHeadCheckWindow3, []cid.Cid{
+		makeCID("abcd"),
+	}, threshold)
+	healthyHeadCheckWindow3 = appendCIDsToWindow(healthyHeadCheckWindow3, []cid.Cid{
+		makeCID("bbcd"),
+		makeCID("bbfe"),
+	}, threshold)
+	ok = checkWindow(healthyHeadCheckWindow3, threshold)
+	assert.True(ok)
+
+	var healthyHeadCheckWindow4 CidWindow
+	healthyHeadCheckWindow4 = appendCIDsToWindow(healthyHeadCheckWindow4, []cid.Cid{
+		makeCID("bbcd"),
+		makeCID("bbfe"),
+	}, threshold)
+	ok = checkWindow(healthyHeadCheckWindow4, threshold)
+	assert.True(ok)
+
+	var healthyHeadCheckWindow5 CidWindow
+	healthyHeadCheckWindow5 = appendCIDsToWindow(healthyHeadCheckWindow5, []cid.Cid{
+		makeCID("bbcd"),
+		makeCID("bbfe"),
+		makeCID("bbff"),
+	}, 5)
+	healthyHeadCheckWindow5 = appendCIDsToWindow(healthyHeadCheckWindow5, []cid.Cid{
+		makeCID("bbcd"),
+		makeCID("bbfe"),
+	}, 5)
+	healthyHeadCheckWindow5 = appendCIDsToWindow(healthyHeadCheckWindow5, []cid.Cid{
+		makeCID("abcd"),
+	}, 5)
+	healthyHeadCheckWindow5 = appendCIDsToWindow(healthyHeadCheckWindow5, []cid.Cid{
+		makeCID("cbcd"),
+		makeCID("cbfe"),
+	}, 5)
+	healthyHeadCheckWindow5 = appendCIDsToWindow(healthyHeadCheckWindow5, []cid.Cid{
+		makeCID("cbcd"),
+		makeCID("cbfe"),
+	}, 5)
+	ok = checkWindow(healthyHeadCheckWindow5, threshold)
+	assert.True(ok)
+
+	var unhealthyHeadCheckWindow CidWindow
+	unhealthyHeadCheckWindow = appendCIDsToWindow(unhealthyHeadCheckWindow, []cid.Cid{
+		makeCID("abcd"),
+		makeCID("fbcd"),
+	}, threshold)
+	unhealthyHeadCheckWindow = appendCIDsToWindow(unhealthyHeadCheckWindow, []cid.Cid{
+		makeCID("abcd"),
+		makeCID("fbcd"),
+	}, threshold)
+	unhealthyHeadCheckWindow = appendCIDsToWindow(unhealthyHeadCheckWindow, []cid.Cid{
+		makeCID("abcd"),
+		makeCID("fbcd"),
+	}, threshold)
+	ok = checkWindow(unhealthyHeadCheckWindow, threshold)
+	assert.False(ok)
+
+	var unhealthyHeadCheckWindow1 CidWindow
+	unhealthyHeadCheckWindow1 = appendCIDsToWindow(unhealthyHeadCheckWindow1, []cid.Cid{
+		makeCID("abcd"),
+		makeCID("fbcd"),
+	}, threshold)
+	unhealthyHeadCheckWindow1 = appendCIDsToWindow(unhealthyHeadCheckWindow1, []cid.Cid{
+		makeCID("abcd"),
+		makeCID("fbcd"),
+	}, threshold)
+	ok = checkWindow(unhealthyHeadCheckWindow1, threshold)
+	assert.True(ok)
+
+	var unhealthyHeadCheckWindow2 CidWindow
+	unhealthyHeadCheckWindow2 = appendCIDsToWindow(unhealthyHeadCheckWindow2, []cid.Cid{
+		makeCID("abcd"),
+	}, threshold)
+	unhealthyHeadCheckWindow2 = appendCIDsToWindow(unhealthyHeadCheckWindow2, []cid.Cid{
+		makeCID("abcd"),
+	}, threshold)
+	unhealthyHeadCheckWindow2 = appendCIDsToWindow(unhealthyHeadCheckWindow2, []cid.Cid{
+		makeCID("abcd"),
+	}, threshold)
+	ok = checkWindow(unhealthyHeadCheckWindow2, threshold)
+	assert.False(ok)
+}
+
+func makeCID(s string) cid.Cid {
+	h1, err := mh.Sum([]byte(s), mh.SHA2_256, -1)
+	if err != nil {
+		log.Fatal(err)
+	}
+	return cid.NewCidV1(0x55, h1)
+}
diff --git a/cmd/lotus-health/notify.go b/cmd/lotus-health/notify.go
new file mode 100644
index 000000000..031f0fe2f
--- /dev/null
+++ b/cmd/lotus-health/notify.go
@@ -0,0 +1,31 @@
+package main
+
+import (
+	"os"
+
+	"github.com/coreos/go-systemd/v22/dbus"
+)
+
+func notifyHandler(n string, ch chan interface{}, sCh chan os.Signal) (string, error) {
+	select {
+	// alerts to restart systemd unit
+	case <-ch:
+		statusCh := make(chan string, 1)
+		c, err := dbus.New()
+		if err != nil {
+			return "", err
+		}
+		_, err = c.TryRestartUnit(n, "fail", statusCh)
+		if err != nil {
+			return "", err
+		}
+		select {
+		case result := <-statusCh:
+			return result, nil
+		}
+	// SIGTERM
+	case <-sCh:
+		os.Exit(1)
+		return "", nil
+	}
+}
diff --git a/cmd/lotus-keygen/main.go b/cmd/lotus-keygen/main.go
new file mode 100644
index 000000000..8e2881ae9
--- /dev/null
+++ b/cmd/lotus-keygen/main.go
@@ -0,0 +1,81 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+
+	"github.com/filecoin-project/go-state-types/crypto"
+	"github.com/filecoin-project/lotus/chain/wallet"
+	_ "github.com/filecoin-project/lotus/lib/sigs/bls"
+	_ "github.com/filecoin-project/lotus/lib/sigs/secp"
+	"github.com/urfave/cli/v2"
+)
+
+func main() {
+
+	app := cli.NewApp()
+	app.Flags = []cli.Flag{
+		&cli.StringFlag{
+			Name:    "type",
+			Aliases: []string{"t"},
+			Value:   "bls",
+			Usage:   "specify key type to generate (bls or secp256k1)",
+		},
+	}
+	app.Action = func(cctx *cli.Context) error {
+		memks := wallet.NewMemKeyStore()
+		w, err := wallet.NewWallet(memks)
+		if err != nil {
+			return err
+		}
+
+		var kt crypto.SigType
+		switch cctx.String("type") {
+		case "bls":
+			kt = crypto.SigTypeBLS
+		case "secp256k1":
+			kt = crypto.SigTypeSecp256k1
+		default:
+			return fmt.Errorf("unrecognized key type: %q", cctx.String("type"))
+		}
+
+		kaddr, err := w.GenerateKey(kt)
+		if err != nil {
+			return err
+		}
+
+		ki, err := w.Export(kaddr)
+		if err != nil {
+			return err
+		}
+
+		fi, err := os.Create(fmt.Sprintf("%s.key", kaddr))
+		if err != nil {
+			return err
+		}
+		defer func() {
+			err2 := fi.Close()
+			if err == nil {
+				err = err2
+			}
+		}()
+
+		b, err := json.Marshal(ki)
+		if err != nil {
+			return err
+		}
+
+		if _, err := fi.Write(b); err != nil {
+			return fmt.Errorf("failed to write key info to file: %w", err)
+		}
+
+		fmt.Println("Generated new key: ", kaddr)
+		return nil
+	}
+
+	if err := app.Run(os.Args); err != nil {
+		fmt.Println(err)
+		os.Exit(1)
+	}
+}
diff --git a/cmd/lotus-pcr/main.go b/cmd/lotus-pcr/main.go
new file mode 100644
index 000000000..36961a663
--- /dev/null
+++ b/cmd/lotus-pcr/main.go
@@ -0,0 +1,634 @@
+package main
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	_ "net/http/pprof"
+	"os"
+	"path/filepath"
+	"strconv"
+	"time"
+
+	"github.com/filecoin-project/specs-actors/actors/builtin"
+	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
+
+	"github.com/filecoin-project/go-state-types/network"
+
+	"github.com/ipfs/go-cid"
+	logging "github.com/ipfs/go-log/v2"
+
+	"github.com/mitchellh/go-homedir"
+	"github.com/urfave/cli/v2"
+
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/big"
+	"github.com/filecoin-project/go-state-types/exitcode"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
+	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/tools/stats"
+)
+
+var log = logging.Logger("main")
+
+func main() {
+	local := []*cli.Command{
+		runCmd,
+		versionCmd,
+	}
+
+	app := &cli.App{
+		Name:  "lotus-pcr",
+		Usage: "Refunds precommit initial pledge for all miners",
+		Description: `Lotus PCR will attempt to reimbursement the initial pledge collateral of the PreCommitSector
+   miner actor method for all miners on the network.
+
+   The refund is sent directly to the miner actor, and not to the worker.
+
+   The value refunded to the miner actor is not the value in the message itself, but calculated
+   using StateMinerInitialPledgeCollateral of the PreCommitSector message params. This is to reduce
+   abuse by over send in the PreCommitSector message and receiving more funds than was actually
+   consumed by pledging the sector.
+
+   No gas charges are refunded as part of this process, but a small 3% (by default) additional
+   funds are provided.
+
+   A single message will be produced per miner totaling their refund for all PreCommitSector messages
+   in a tipset.
+`,
+		Version: build.UserVersion(),
+		Flags: []cli.Flag{
+			&cli.StringFlag{
+				Name:    "lotus-path",
+				EnvVars: []string{"LOTUS_PATH"},
+				Value:   "~/.lotus", // TODO: Consider XDG_DATA_HOME
+			},
+			&cli.StringFlag{
+				Name:    "repo",
+				EnvVars: []string{"LOTUS_PCR_PATH"},
+				Value:   "~/.lotuspcr", // TODO: Consider XDG_DATA_HOME
+			},
+			&cli.StringFlag{
+				Name:    "log-level",
+				EnvVars: []string{"LOTUS_PCR_LOG_LEVEL"},
+				Hidden:  true,
+				Value:   "info",
+			},
+		},
+		Before: func(cctx *cli.Context) error {
+			return logging.SetLogLevel("main", cctx.String("log-level"))
+		},
+		Commands: local,
+	}
+
+	if err := app.Run(os.Args); err != nil {
+		log.Errorw("exit in error", "err", err)
+		os.Exit(1)
+		return
+	}
+}
+
+var versionCmd = &cli.Command{
+	Name:  "version",
+	Usage: "Print version",
+	Action: func(cctx *cli.Context) error {
+		cli.VersionPrinter(cctx)
+		return nil
+	},
+}
+
+var runCmd = &cli.Command{
+	Name:  "run",
+	Usage: "Start message reimpursement",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:    "from",
+			EnvVars: []string{"LOTUS_PCR_FROM"},
+			Usage:   "wallet address to send refund from",
+		},
+		&cli.BoolFlag{
+			Name:    "no-sync",
+			EnvVars: []string{"LOTUS_PCR_NO_SYNC"},
+			Usage:   "do not wait for chain sync to complete",
+		},
+		&cli.IntFlag{
+			Name:    "percent-extra",
+			EnvVars: []string{"LOTUS_PCR_PERCENT_EXTRA"},
+			Usage:   "extra funds to send above the refund",
+			Value:   3,
+		},
+		&cli.IntFlag{
+			Name:    "max-message-queue",
+			EnvVars: []string{"LOTUS_PCR_MAX_MESSAGE_QUEUE"},
+			Usage:   "set the maximum number of messages that can be queue in the mpool",
+			Value:   300,
+		},
+		&cli.IntFlag{
+			Name:    "aggregate-tipsets",
+			EnvVars: []string{"LOTUS_PCR_AGGREGATE_TIPSETS"},
+			Usage:   "number of tipsets to process before sending messages",
+			Value:   1,
+		},
+		&cli.BoolFlag{
+			Name:    "dry-run",
+			EnvVars: []string{"LOTUS_PCR_DRY_RUN"},
+			Usage:   "do not send any messages",
+			Value:   false,
+		},
+		&cli.BoolFlag{
+			Name:    "pre-commit",
+			EnvVars: []string{"LOTUS_PCR_PRE_COMMIT"},
+			Usage:   "process PreCommitSector messages",
+			Value:   true,
+		},
+		&cli.BoolFlag{
+			Name:    "prove-commit",
+			EnvVars: []string{"LOTUS_PCR_PROVE_COMMIT"},
+			Usage:   "process ProveCommitSector messages",
+			Value:   true,
+		},
+		&cli.IntFlag{
+			Name:    "head-delay",
+			EnvVars: []string{"LOTUS_PCR_HEAD_DELAY"},
+			Usage:   "the number of tipsets to delay message processing to smooth chain reorgs",
+			Value:   int(build.MessageConfidence),
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		go func() {
+			http.ListenAndServe(":6060", nil) //nolint:errcheck
+		}()
+
+		ctx := context.Background()
+		api, closer, err := stats.GetFullNodeAPI(cctx.Context, cctx.String("lotus-path"))
+		if err != nil {
+			log.Fatal(err)
+		}
+		defer closer()
+
+		r, err := NewRepo(cctx.String("repo"))
+		if err != nil {
+			return err
+		}
+
+		if err := r.Open(); err != nil {
+			return err
+		}
+
+		from, err := address.NewFromString(cctx.String("from"))
+		if err != nil {
+			return xerrors.Errorf("parsing source address (provide correct --from flag!): %w", err)
+		}
+
+		if !cctx.Bool("no-sync") {
+			if err := stats.WaitForSyncComplete(ctx, api); err != nil {
+				log.Fatal(err)
+			}
+		}
+
+		tipsetsCh, err := stats.GetTips(ctx, api, r.Height(), cctx.Int("head-delay"))
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		percentExtra := cctx.Int("percent-extra")
+		maxMessageQueue := cctx.Int("max-message-queue")
+		dryRun := cctx.Bool("dry-run")
+		preCommitEnabled := cctx.Bool("pre-commit")
+		proveCommitEnabled := cctx.Bool("prove-commit")
+		aggregateTipsets := cctx.Int("aggregate-tipsets")
+
+		rf := &refunder{
+			api:                api,
+			wallet:             from,
+			percentExtra:       percentExtra,
+			dryRun:             dryRun,
+			preCommitEnabled:   preCommitEnabled,
+			proveCommitEnabled: proveCommitEnabled,
+		}
+
+		var refunds *MinersRefund = NewMinersRefund()
+		var rounds int = 0
+
+		for tipset := range tipsetsCh {
+			refunds, err = rf.ProcessTipset(ctx, tipset, refunds)
+			if err != nil {
+				return err
+			}
+
+			rounds = rounds + 1
+			if rounds < aggregateTipsets {
+				continue
+			}
+
+			refundTipset, err := api.ChainHead(ctx)
+			if err != nil {
+				return err
+			}
+
+			if err := rf.Refund(ctx, refundTipset, refunds, rounds); err != nil {
+				return err
+			}
+
+			rounds = 0
+			refunds = NewMinersRefund()
+
+			if err := r.SetHeight(tipset.Height()); err != nil {
+				return err
+			}
+
+			for {
+				msgs, err := api.MpoolPending(ctx, types.EmptyTSK)
+				if err != nil {
+					log.Warnw("failed to fetch pending messages", "err", err)
+					time.Sleep(time.Duration(int64(time.Second) * int64(build.BlockDelaySecs)))
+					continue
+				}
+
+				count := 0
+				for _, msg := range msgs {
+					if msg.Message.From == from {
+						count = count + 1
+					}
+				}
+
+				if count < maxMessageQueue {
+					break
+				}
+
+				log.Warnw("messages in mpool over max message queue", "message_count", count, "max_message_queue", maxMessageQueue)
+				time.Sleep(time.Duration(int64(time.Second) * int64(build.BlockDelaySecs)))
+			}
+		}
+
+		return nil
+	},
+}
+
+type MinersRefund struct {
+	refunds      map[address.Address]types.BigInt
+	count        int
+	totalRefunds types.BigInt
+}
+
+func NewMinersRefund() *MinersRefund {
+	return &MinersRefund{
+		refunds:      make(map[address.Address]types.BigInt),
+		totalRefunds: types.NewInt(0),
+	}
+}
+
+func (m *MinersRefund) Track(addr address.Address, value types.BigInt) {
+	if _, ok := m.refunds[addr]; !ok {
+		m.refunds[addr] = types.NewInt(0)
+	}
+
+	m.count = m.count + 1
+	m.totalRefunds = types.BigAdd(m.totalRefunds, value)
+
+	m.refunds[addr] = types.BigAdd(m.refunds[addr], value)
+}
+
+func (m *MinersRefund) Count() int {
+	return m.count
+}
+
+func (m *MinersRefund) TotalRefunds() types.BigInt {
+	return m.totalRefunds
+}
+
+func (m *MinersRefund) Miners() []address.Address {
+	miners := make([]address.Address, 0, len(m.refunds))
+	for addr := range m.refunds {
+		miners = append(miners, addr)
+	}
+
+	return miners
+}
+
+func (m *MinersRefund) GetRefund(addr address.Address) types.BigInt {
+	return m.refunds[addr]
+}
+
+type refunderNodeApi interface {
+	ChainGetParentMessages(ctx context.Context, blockCid cid.Cid) ([]api.Message, error)
+	ChainGetParentReceipts(ctx context.Context, blockCid cid.Cid) ([]*types.MessageReceipt, error)
+	ChainGetTipSetByHeight(ctx context.Context, epoch abi.ChainEpoch, tsk types.TipSetKey) (*types.TipSet, error)
+	StateMinerInitialPledgeCollateral(ctx context.Context, addr address.Address, precommitInfo miner.SectorPreCommitInfo, tsk types.TipSetKey) (types.BigInt, error)
+	StateSectorPreCommitInfo(ctx context.Context, addr address.Address, sector abi.SectorNumber, tsk types.TipSetKey) (miner.SectorPreCommitOnChainInfo, error)
+	StateGetActor(ctx context.Context, actor address.Address, tsk types.TipSetKey) (*types.Actor, error)
+	StateNetworkVersion(ctx context.Context, tsk types.TipSetKey) (network.Version, error)
+	MpoolPushMessage(ctx context.Context, msg *types.Message, spec *api.MessageSendSpec) (*types.SignedMessage, error)
+	GasEstimateGasPremium(ctx context.Context, nblocksincl uint64, sender address.Address, gaslimit int64, tsk types.TipSetKey) (types.BigInt, error)
+	WalletBalance(ctx context.Context, addr address.Address) (types.BigInt, error)
+}
+
+type refunder struct {
+	api                refunderNodeApi
+	wallet             address.Address
+	percentExtra       int
+	dryRun             bool
+	preCommitEnabled   bool
+	proveCommitEnabled bool
+}
+
+func (r *refunder) ProcessTipset(ctx context.Context, tipset *types.TipSet, refunds *MinersRefund) (*MinersRefund, error) {
+	cids := tipset.Cids()
+	if len(cids) == 0 {
+		log.Errorw("no cids in tipset", "height", tipset.Height(), "key", tipset.Key())
+		return nil, fmt.Errorf("no cids in tipset")
+	}
+
+	msgs, err := r.api.ChainGetParentMessages(ctx, cids[0])
+	if err != nil {
+		log.Errorw("failed to get tipset parent messages", "err", err, "height", tipset.Height(), "key", tipset.Key())
+		return nil, nil
+	}
+
+	recps, err := r.api.ChainGetParentReceipts(ctx, cids[0])
+	if err != nil {
+		log.Errorw("failed to get tipset parent receipts", "err", err, "height", tipset.Height(), "key", tipset.Key())
+		return nil, nil
+	}
+
+	if len(msgs) != len(recps) {
+		log.Errorw("message length does not match receipts length", "height", tipset.Height(), "key", tipset.Key(), "messages", len(msgs), "receipts", len(recps))
+		return nil, nil
+	}
+
+	refundValue := types.NewInt(0)
+	tipsetRefunds := NewMinersRefund()
+	for i, msg := range msgs {
+		m := msg.Message
+
+		a, err := r.api.StateGetActor(ctx, m.To, tipset.Key())
+		if err != nil {
+			log.Warnw("failed to look up state actor", "height", tipset.Height(), "key", tipset.Key(), "actor", m.To)
+			continue
+		}
+
+		if !a.IsStorageMinerActor() {
+			continue
+		}
+
+		var messageMethod string
+
+		switch m.Method {
+		case builtin.MethodsMiner.ProveCommitSector:
+			if !r.proveCommitEnabled {
+				continue
+			}
+
+			messageMethod = "ProveCommitSector"
+
+			if recps[i].ExitCode != exitcode.Ok {
+				log.Debugw("skipping non-ok exitcode message", "method", messageMethod, "cid", msg.Cid, "miner", m.To, "exitcode", recps[i].ExitCode)
+				continue
+			}
+
+			var sn abi.SectorNumber
+
+			var proveCommitSector miner0.ProveCommitSectorParams
+			if err := proveCommitSector.UnmarshalCBOR(bytes.NewBuffer(m.Params)); err != nil {
+				log.Warnw("failed to decode provecommit params", "err", err, "method", messageMethod, "cid", msg.Cid, "miner", m.To)
+				continue
+			}
+
+			sn = proveCommitSector.SectorNumber
+
+			// We use the parent tipset key because precommit information is removed when ProveCommitSector is executed
+			precommitChainInfo, err := r.api.StateSectorPreCommitInfo(ctx, m.To, sn, tipset.Parents())
+			if err != nil {
+				log.Warnw("failed to get precommit info for sector", "err", err, "method", messageMethod, "cid", msg.Cid, "miner", m.To, "sector_number", sn)
+				continue
+			}
+
+			precommitTipset, err := r.api.ChainGetTipSetByHeight(ctx, precommitChainInfo.PreCommitEpoch, tipset.Key())
+			if err != nil {
+				log.Warnf("failed to lookup precommit epoch", "err", err, "method", messageMethod, "cid", msg.Cid, "miner", m.To, "sector_number", sn)
+				continue
+			}
+
+			collateral, err := r.api.StateMinerInitialPledgeCollateral(ctx, m.To, precommitChainInfo.Info, precommitTipset.Key())
+			if err != nil {
+				log.Warnw("failed to get initial pledge collateral", "err", err, "method", messageMethod, "cid", msg.Cid, "miner", m.To, "sector_number", sn)
+			}
+
+			collateral = big.Sub(collateral, precommitChainInfo.PreCommitDeposit)
+			if collateral.LessThan(big.Zero()) {
+				log.Debugw("skipping zero pledge collateral difference", "method", messageMethod, "cid", msg.Cid, "miner", m.To, "sector_number", sn)
+				continue
+			}
+
+			refundValue = collateral
+		case builtin.MethodsMiner.PreCommitSector:
+			if !r.preCommitEnabled {
+				continue
+			}
+
+			messageMethod = "PreCommitSector"
+
+			if recps[i].ExitCode != exitcode.Ok {
+				log.Debugw("skipping non-ok exitcode message", "method", messageMethod, "cid", msg.Cid, "miner", m.To, "exitcode", recps[i].ExitCode)
+				continue
+			}
+
+			var precommitInfo miner.SectorPreCommitInfo
+			if err := precommitInfo.UnmarshalCBOR(bytes.NewBuffer(m.Params)); err != nil {
+				log.Warnw("failed to decode precommit params", "err", err, "method", messageMethod, "cid", msg.Cid, "miner", m.To)
+				continue
+			}
+
+			collateral, err := r.api.StateMinerInitialPledgeCollateral(ctx, m.To, precommitInfo, tipset.Key())
+			if err != nil {
+				log.Warnw("failed to calculate initial pledge collateral", "err", err, "method", messageMethod, "cid", msg.Cid, "miner", m.To, "sector_number", precommitInfo.SectorNumber)
+				continue
+			}
+
+			refundValue = collateral
+		default:
+			continue
+		}
+
+		if r.percentExtra > 0 {
+			refundValue = types.BigAdd(refundValue, types.BigMul(types.BigDiv(refundValue, types.NewInt(100)), types.NewInt(uint64(r.percentExtra))))
+		}
+
+		log.Debugw("processing message", "method", messageMethod, "cid", msg.Cid, "from", m.From, "to", m.To, "value", m.Value, "gas_fee_cap", m.GasFeeCap, "gas_premium", m.GasPremium, "gas_used", recps[i].GasUsed, "refund", refundValue)
+
+		refunds.Track(m.From, refundValue)
+		tipsetRefunds.Track(m.From, refundValue)
+	}
+
+	log.Infow("tipset stats", "height", tipset.Height(), "key", tipset.Key(), "total_refunds", tipsetRefunds.TotalRefunds(), "messages_processed", tipsetRefunds.Count())
+
+	return refunds, nil
+}
+
+func (r *refunder) Refund(ctx context.Context, tipset *types.TipSet, refunds *MinersRefund, rounds int) error {
+	if refunds.Count() == 0 {
+		log.Debugw("no messages to refund in tipset", "height", tipset.Height(), "key", tipset.Key())
+		return nil
+	}
+
+	var messages []*types.Message
+	refundSum := types.NewInt(0)
+
+	for _, maddr := range refunds.Miners() {
+		refundValue := refunds.GetRefund(maddr)
+
+		// We want to try and ensure these messages get mined quickly
+		gasPremium, err := r.api.GasEstimateGasPremium(ctx, 0, r.wallet, 0, tipset.Key())
+		if err != nil {
+			log.Warnw("failed to estimate gas premium", "err", err, "height", tipset.Height(), "key", tipset.Key())
+			continue
+		}
+
+		msg := &types.Message{
+			Value: refundValue,
+			From:  r.wallet,
+			To:    maddr,
+
+			GasPremium: gasPremium,
+		}
+
+		refundSum = types.BigAdd(refundSum, msg.Value)
+		messages = append(messages, msg)
+	}
+
+	balance, err := r.api.WalletBalance(ctx, r.wallet)
+	if err != nil {
+		log.Errorw("failed to get wallet balance", "err", err, "height", tipset.Height(), "key", tipset.Key())
+		return xerrors.Errorf("failed to get wallet balance :%w", err)
+	}
+
+	// Calculate the minimum balance as the total refund we need to issue plus 5% to cover fees
+	minBalance := types.BigAdd(refundSum, types.BigDiv(refundSum, types.NewInt(500)))
+	if balance.LessThan(minBalance) {
+		log.Errorw("not sufficient funds to cover refunds", "balance", balance, "refund_sum", refundSum, "minimum_required", minBalance)
+		return xerrors.Errorf("wallet does not have enough balance to cover refund")
+	}
+
+	failures := 0
+	refundSum.SetUint64(0)
+	for _, msg := range messages {
+		if !r.dryRun {
+			if _, err = r.api.MpoolPushMessage(ctx, msg, nil); err != nil {
+				log.Errorw("failed to MpoolPushMessage", "err", err, "msg", msg)
+				failures = failures + 1
+				continue
+			}
+		}
+
+		refundSum = types.BigAdd(refundSum, msg.Value)
+	}
+
+	log.Infow("refund stats", "tipsets_processed", rounds, "height", tipset.Height(), "key", tipset.Key(), "messages_sent", len(messages)-failures, "refund_sum", refundSum, "messages_failures", failures, "messages_processed", refunds.Count())
+	return nil
+}
+
+type Repo struct {
+	last abi.ChainEpoch
+	path string
+}
+
+func NewRepo(path string) (*Repo, error) {
+	path, err := homedir.Expand(path)
+	if err != nil {
+		return nil, err
+	}
+
+	return &Repo{
+		last: 0,
+		path: path,
+	}, nil
+}
+
+func (r *Repo) exists() (bool, error) {
+	_, err := os.Stat(r.path)
+	notexist := os.IsNotExist(err)
+	if notexist {
+		err = nil
+	}
+	return !notexist, err
+
+}
+
+func (r *Repo) init() error {
+	exist, err := r.exists()
+	if err != nil {
+		return err
+	}
+	if exist {
+		return nil
+	}
+
+	err = os.Mkdir(r.path, 0755) //nolint: gosec
+	if err != nil && !os.IsExist(err) {
+		return err
+	}
+
+	return nil
+}
+
+func (r *Repo) Open() (err error) {
+	if err = r.init(); err != nil {
+		return
+	}
+
+	var f *os.File
+
+	f, err = os.OpenFile(filepath.Join(r.path, "height"), os.O_RDWR|os.O_CREATE, 0644)
+	if err != nil {
+		return
+	}
+	defer func() {
+		err = f.Close()
+	}()
+
+	var raw []byte
+
+	raw, err = ioutil.ReadAll(f)
+	if err != nil {
+		return
+	}
+
+	height, err := strconv.Atoi(string(bytes.TrimSpace(raw)))
+	if err != nil {
+		return
+	}
+
+	r.last = abi.ChainEpoch(height)
+	return
+}
+
+func (r *Repo) Height() abi.ChainEpoch {
+	return r.last
+}
+
+func (r *Repo) SetHeight(last abi.ChainEpoch) (err error) {
+	r.last = last
+	var f *os.File
+	f, err = os.OpenFile(filepath.Join(r.path, "height"), os.O_RDWR, 0644)
+	if err != nil {
+		return
+	}
+
+	defer func() {
+		err = f.Close()
+	}()
+
+	if _, err = fmt.Fprintf(f, "%d", r.last); err != nil {
+		return
+	}
+
+	return
+}
diff --git a/cmd/lotus-seal-worker/info.go b/cmd/lotus-seal-worker/info.go
new file mode 100644
index 000000000..9b08a0c80
--- /dev/null
+++ b/cmd/lotus-seal-worker/info.go
@@ -0,0 +1,71 @@
+package main
+
+import (
+	"fmt"
+
+	"github.com/urfave/cli/v2"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/lotus/chain/types"
+	lcli "github.com/filecoin-project/lotus/cli"
+)
+
+var infoCmd = &cli.Command{
+	Name:  "info",
+	Usage: "Print worker info",
+	Action: func(cctx *cli.Context) error {
+		api, closer, err := lcli.GetWorkerAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+
+		ctx := lcli.ReqContext(cctx)
+
+		ver, err := api.Version(ctx)
+		if err != nil {
+			return xerrors.Errorf("getting version: %w", err)
+		}
+
+		fmt.Println("Worker version: ", ver)
+		fmt.Print("CLI version: ")
+		cli.VersionPrinter(cctx)
+		fmt.Println()
+
+		info, err := api.Info(ctx)
+		if err != nil {
+			return xerrors.Errorf("getting info: %w", err)
+		}
+
+		fmt.Printf("Hostname: %s\n", info.Hostname)
+		fmt.Printf("CPUs: %d; GPUs: %v\n", info.Resources.CPUs, info.Resources.GPUs)
+		fmt.Printf("RAM: %s; Swap: %s\n", types.SizeStr(types.NewInt(info.Resources.MemPhysical)), types.SizeStr(types.NewInt(info.Resources.MemSwap)))
+		fmt.Printf("Reserved memory: %s\n", types.SizeStr(types.NewInt(info.Resources.MemReserved)))
+		fmt.Println()
+
+		paths, err := api.Paths(ctx)
+		if err != nil {
+			return xerrors.Errorf("getting path info: %w", err)
+		}
+
+		for _, path := range paths {
+			fmt.Printf("%s:\n", path.ID)
+			fmt.Printf("\tWeight: %d; Use: ", path.Weight)
+			if path.CanSeal || path.CanStore {
+				fmt.Printf("Weight: %d; Use: ", path.Weight)
+				if path.CanSeal {
+					fmt.Print("Seal ")
+				}
+				if path.CanStore {
+					fmt.Print("Store")
+				}
+				fmt.Println("")
+			} else {
+				fmt.Print("Use: ReadOnly")
+			}
+			fmt.Printf("\tLocal: %s\n", path.LocalPath)
+		}
+
+		return nil
+	},
+}
diff --git a/cmd/lotus-seal-worker/main.go b/cmd/lotus-seal-worker/main.go
index 146c246e8..e36514bb8 100644
--- a/cmd/lotus-seal-worker/main.go
+++ b/cmd/lotus-seal-worker/main.go
@@ -1,65 +1,90 @@
 package main
 
 import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"net"
+	"net/http"
 	"os"
+	"path/filepath"
+	"strings"
+	"syscall"
+	"time"
 
-	"github.com/mitchellh/go-homedir"
-
-	logging "github.com/ipfs/go-log"
+	"github.com/google/uuid"
+	"github.com/gorilla/mux"
+	logging "github.com/ipfs/go-log/v2"
+	manet "github.com/multiformats/go-multiaddr/net"
+	"github.com/urfave/cli/v2"
 	"golang.org/x/xerrors"
-	"gopkg.in/urfave/cli.v2"
+
+	"github.com/filecoin-project/go-jsonrpc"
+	"github.com/filecoin-project/go-jsonrpc/auth"
+	paramfetch "github.com/filecoin-project/go-paramfetch"
 
 	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/api/apistruct"
 	"github.com/filecoin-project/lotus/build"
 	lcli "github.com/filecoin-project/lotus/cli"
+	sectorstorage "github.com/filecoin-project/lotus/extern/sector-storage"
+	"github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper"
+	"github.com/filecoin-project/lotus/extern/sector-storage/sealtasks"
+	"github.com/filecoin-project/lotus/extern/sector-storage/stores"
 	"github.com/filecoin-project/lotus/lib/lotuslog"
+	"github.com/filecoin-project/lotus/lib/rpcenc"
 	"github.com/filecoin-project/lotus/node/repo"
-	manet "github.com/multiformats/go-multiaddr-net"
 )
 
 var log = logging.Logger("main")
 
-func main() {
-	lotuslog.SetupLogLevels()
+const FlagWorkerRepo = "worker-repo"
 
-	log.Info("Starting lotus worker")
+// TODO remove after deprecation period
+const FlagWorkerRepoDeprecation = "workerrepo"
+
+func main() {
+	build.RunningNodeType = build.NodeWorker
+
+	lotuslog.SetupLogLevels()
 
 	local := []*cli.Command{
 		runCmd,
+		infoCmd,
+		storageCmd,
 	}
 
 	app := &cli.App{
-		Name:    "lotus-seal-worker",
-		Usage:   "Remote storage miner worker",
-		Version: build.UserVersion,
+		Name:    "lotus-worker",
+		Usage:   "Remote miner worker",
+		Version: build.UserVersion(),
 		Flags: []cli.Flag{
 			&cli.StringFlag{
-				Name:    "repo",
-				EnvVars: []string{"WORKER_PATH"},
+				Name:    FlagWorkerRepo,
+				Aliases: []string{FlagWorkerRepoDeprecation},
+				EnvVars: []string{"LOTUS_WORKER_PATH", "WORKER_PATH"},
 				Value:   "~/.lotusworker", // TODO: Consider XDG_DATA_HOME
+				Usage:   fmt.Sprintf("Specify worker repo path. flag %s and env WORKER_PATH are DEPRECATION, will REMOVE SOON", FlagWorkerRepoDeprecation),
 			},
 			&cli.StringFlag{
-				Name:    "storagerepo",
-				EnvVars: []string{"LOTUS_STORAGE_PATH"},
-				Value:   "~/.lotusstorage", // TODO: Consider XDG_DATA_HOME
+				Name:    "miner-repo",
+				Aliases: []string{"storagerepo"},
+				EnvVars: []string{"LOTUS_MINER_PATH", "LOTUS_STORAGE_PATH"},
+				Value:   "~/.lotusminer", // TODO: Consider XDG_DATA_HOME
+				Usage:   fmt.Sprintf("Specify miner repo path. flag storagerepo and env LOTUS_STORAGE_PATH are DEPRECATION, will REMOVE SOON"),
 			},
 			&cli.BoolFlag{
 				Name:  "enable-gpu-proving",
 				Usage: "enable use of GPU for mining operations",
 				Value: true,
 			},
-			&cli.BoolFlag{
-				Name: "no-precommit",
-			},
-			&cli.BoolFlag{
-				Name: "no-commit",
-			},
 		},
 
 		Commands: local,
 	}
 	app.Setup()
-	app.Metadata["repoType"] = repo.StorageMiner
+	app.Metadata["repoType"] = repo.Worker
 
 	if err := app.Run(os.Args); err != nil {
 		log.Warnf("%+v", err)
@@ -70,42 +95,409 @@ func main() {
 var runCmd = &cli.Command{
 	Name:  "run",
 	Usage: "Start lotus worker",
-	Action: func(cctx *cli.Context) error {
-		if !cctx.Bool("enable-gpu-proving") {
-			os.Setenv("BELLMAN_NO_GPU", "true")
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:  "listen",
+			Usage: "host address and port the worker api will listen on",
+			Value: "0.0.0.0:3456",
+		},
+		&cli.StringFlag{
+			Name:   "address",
+			Hidden: true,
+		},
+		&cli.BoolFlag{
+			Name:  "no-local-storage",
+			Usage: "don't use storageminer repo for sector storage",
+		},
+		&cli.BoolFlag{
+			Name:  "addpiece",
+			Usage: "enable addpiece",
+			Value: true,
+		},
+		&cli.BoolFlag{
+			Name:  "precommit1",
+			Usage: "enable precommit1 (32G sectors: 1 core, 128GiB Memory)",
+			Value: true,
+		},
+		&cli.BoolFlag{
+			Name:  "unseal",
+			Usage: "enable unsealing (32G sectors: 1 core, 128GiB Memory)",
+			Value: true,
+		},
+		&cli.BoolFlag{
+			Name:  "precommit2",
+			Usage: "enable precommit2 (32G sectors: all cores, 96GiB Memory)",
+			Value: true,
+		},
+		&cli.BoolFlag{
+			Name:  "commit",
+			Usage: "enable commit (32G sectors: all cores or GPUs, 128GiB Memory + 64GiB swap)",
+			Value: true,
+		},
+		&cli.IntFlag{
+			Name:  "parallel-fetch-limit",
+			Usage: "maximum fetch operations to run in parallel",
+			Value: 5,
+		},
+		&cli.StringFlag{
+			Name:  "timeout",
+			Usage: "used when 'listen' is unspecified. must be a valid duration recognized by golang's time.ParseDuration function",
+			Value: "30m",
+		},
+	},
+	Before: func(cctx *cli.Context) error {
+		if cctx.IsSet("address") {
+			log.Warnf("The '--address' flag is deprecated, it has been replaced by '--listen'")
+			if err := cctx.Set("listen", cctx.String("address")); err != nil {
+				return err
+			}
 		}
 
-		nodeApi, closer, err := lcli.GetStorageMinerAPI(cctx)
-		if err != nil {
-			return xerrors.Errorf("getting miner api: %w", err)
+		return nil
+	},
+	Action: func(cctx *cli.Context) error {
+		log.Info("Starting lotus worker")
+
+		if !cctx.Bool("enable-gpu-proving") {
+			if err := os.Setenv("BELLMAN_NO_GPU", "true"); err != nil {
+				return xerrors.Errorf("could not set no-gpu env: %+v", err)
+			}
 		}
+
+		// Connect to storage-miner
+		var nodeApi api.StorageMiner
+		var closer func()
+		var err error
+		for {
+			nodeApi, closer, err = lcli.GetStorageMinerAPI(cctx,
+				jsonrpc.WithNoReconnect(),
+				jsonrpc.WithTimeout(30*time.Second))
+			if err == nil {
+				break
+			}
+			fmt.Printf("\r\x1b[0KConnecting to miner API... (%s)", err)
+			time.Sleep(time.Second)
+			continue
+		}
+
 		defer closer()
 		ctx := lcli.ReqContext(cctx)
-
-		ainfo, err := lcli.GetAPIInfo(cctx, repo.StorageMiner)
-		if err != nil {
-			return xerrors.Errorf("could not get api info: %w", err)
-		}
-		_, storageAddr, err := manet.DialArgs(ainfo.Addr)
-
-		r, err := homedir.Expand(cctx.String("repo"))
-		if err != nil {
-			return err
-		}
+		ctx, cancel := context.WithCancel(ctx)
+		defer cancel()
 
 		v, err := nodeApi.Version(ctx)
 		if err != nil {
 			return err
 		}
-		if v.APIVersion != build.APIVersion {
-			return xerrors.Errorf("lotus-storage-miner API version doesn't match: local: ", api.Version{APIVersion: build.APIVersion})
+		if v.APIVersion != build.MinerAPIVersion {
+			return xerrors.Errorf("lotus-miner API version doesn't match: expected: %s", api.Version{APIVersion: build.MinerAPIVersion})
+		}
+		log.Infof("Remote version %s", v)
+
+		watchMinerConn(ctx, cctx, nodeApi)
+
+		// Check params
+
+		act, err := nodeApi.ActorAddress(ctx)
+		if err != nil {
+			return err
+		}
+		ssize, err := nodeApi.ActorSectorSize(ctx, act)
+		if err != nil {
+			return err
+		}
+
+		if cctx.Bool("commit") {
+			if err := paramfetch.GetParams(ctx, build.ParametersJSON(), uint64(ssize)); err != nil {
+				return xerrors.Errorf("get params: %w", err)
+			}
+		}
+
+		var taskTypes []sealtasks.TaskType
+
+		taskTypes = append(taskTypes, sealtasks.TTFetch, sealtasks.TTCommit1, sealtasks.TTFinalize)
+
+		if cctx.Bool("addpiece") {
+			taskTypes = append(taskTypes, sealtasks.TTAddPiece)
+		}
+		if cctx.Bool("precommit1") {
+			taskTypes = append(taskTypes, sealtasks.TTPreCommit1)
+		}
+		if cctx.Bool("unseal") {
+			taskTypes = append(taskTypes, sealtasks.TTUnseal)
+		}
+		if cctx.Bool("precommit2") {
+			taskTypes = append(taskTypes, sealtasks.TTPreCommit2)
+		}
+		if cctx.Bool("commit") {
+			taskTypes = append(taskTypes, sealtasks.TTCommit2)
+		}
+
+		if len(taskTypes) == 0 {
+			return xerrors.Errorf("no task types specified")
+		}
+
+		// Open repo
+
+		repoPath := cctx.String(FlagWorkerRepo)
+		r, err := repo.NewFS(repoPath)
+		if err != nil {
+			return err
+		}
+
+		ok, err := r.Exists()
+		if err != nil {
+			return err
+		}
+		if !ok {
+			if err := r.Init(repo.Worker); err != nil {
+				return err
+			}
+
+			lr, err := r.Lock(repo.Worker)
+			if err != nil {
+				return err
+			}
+
+			var localPaths []stores.LocalPath
+
+			if !cctx.Bool("no-local-storage") {
+				b, err := json.MarshalIndent(&stores.LocalStorageMeta{
+					ID:       stores.ID(uuid.New().String()),
+					Weight:   10,
+					CanSeal:  true,
+					CanStore: false,
+				}, "", "  ")
+				if err != nil {
+					return xerrors.Errorf("marshaling storage config: %w", err)
+				}
+
+				if err := ioutil.WriteFile(filepath.Join(lr.Path(), "sectorstore.json"), b, 0644); err != nil {
+					return xerrors.Errorf("persisting storage metadata (%s): %w", filepath.Join(lr.Path(), "sectorstore.json"), err)
+				}
+
+				localPaths = append(localPaths, stores.LocalPath{
+					Path: lr.Path(),
+				})
+			}
+
+			if err := lr.SetStorage(func(sc *stores.StorageConfig) {
+				sc.StoragePaths = append(sc.StoragePaths, localPaths...)
+			}); err != nil {
+				return xerrors.Errorf("set storage config: %w", err)
+			}
+
+			{
+				// init datastore for r.Exists
+				_, err := lr.Datastore("/metadata")
+				if err != nil {
+					return err
+				}
+			}
+			if err := lr.Close(); err != nil {
+				return xerrors.Errorf("close repo: %w", err)
+			}
+		}
+
+		lr, err := r.Lock(repo.Worker)
+		if err != nil {
+			return err
+		}
+
+		log.Info("Opening local storage; connecting to master")
+		const unspecifiedAddress = "0.0.0.0"
+		address := cctx.String("listen")
+		addressSlice := strings.Split(address, ":")
+		if ip := net.ParseIP(addressSlice[0]); ip != nil {
+			if ip.String() == unspecifiedAddress {
+				timeout, err := time.ParseDuration(cctx.String("timeout"))
+				if err != nil {
+					return err
+				}
+				rip, err := extractRoutableIP(timeout)
+				if err != nil {
+					return err
+				}
+				address = rip + ":" + addressSlice[1]
+			}
+		}
+
+		localStore, err := stores.NewLocal(ctx, lr, nodeApi, []string{"http://" + address + "/remote"})
+		if err != nil {
+			return err
+		}
+
+		// Setup remote sector store
+		spt, err := ffiwrapper.SealProofTypeFromSectorSize(ssize)
+		if err != nil {
+			return xerrors.Errorf("getting proof type: %w", err)
+		}
+
+		sminfo, err := lcli.GetAPIInfo(cctx, repo.StorageMiner)
+		if err != nil {
+			return xerrors.Errorf("could not get api info: %w", err)
+		}
+
+		remote := stores.NewRemote(localStore, nodeApi, sminfo.AuthHeader(), cctx.Int("parallel-fetch-limit"))
+
+		// Create / expose the worker
+
+		workerApi := &worker{
+			LocalWorker: sectorstorage.NewLocalWorker(sectorstorage.WorkerConfig{
+				SealProof: spt,
+				TaskTypes: taskTypes,
+			}, remote, localStore, nodeApi),
+			localStore: localStore,
+			ls:         lr,
+		}
+
+		mux := mux.NewRouter()
+
+		log.Info("Setting up control endpoint at " + address)
+
+		readerHandler, readerServerOpt := rpcenc.ReaderParamDecoder()
+		rpcServer := jsonrpc.NewServer(readerServerOpt)
+		rpcServer.Register("Filecoin", apistruct.PermissionedWorkerAPI(workerApi))
+
+		mux.Handle("/rpc/v0", rpcServer)
+		mux.Handle("/rpc/streams/v0/push/{uuid}", readerHandler)
+		mux.PathPrefix("/remote").HandlerFunc((&stores.FetchHandler{Local: localStore}).ServeHTTP)
+		mux.PathPrefix("/").Handler(http.DefaultServeMux) // pprof
+
+		ah := &auth.Handler{
+			Verify: nodeApi.AuthVerify,
+			Next:   mux.ServeHTTP,
+		}
+
+		srv := &http.Server{
+			Handler: ah,
+			BaseContext: func(listener net.Listener) context.Context {
+				return ctx
+			},
 		}
 
 		go func() {
 			<-ctx.Done()
-			log.Warn("Shutting down..")
+			log.Warn("Shutting down...")
+			if err := srv.Shutdown(context.TODO()); err != nil {
+				log.Errorf("shutting down RPC server failed: %s", err)
+			}
+			log.Warn("Graceful shutdown successful")
 		}()
 
-		return acceptJobs(ctx, nodeApi, "http://"+storageAddr, ainfo.AuthHeader(), r, cctx.Bool("no-precommit"), cctx.Bool("no-commit"))
+		nl, err := net.Listen("tcp", address)
+		if err != nil {
+			return err
+		}
+
+		{
+			a, err := net.ResolveTCPAddr("tcp", address)
+			if err != nil {
+				return xerrors.Errorf("parsing address: %w", err)
+			}
+
+			ma, err := manet.FromNetAddr(a)
+			if err != nil {
+				return xerrors.Errorf("creating api multiaddress: %w", err)
+			}
+
+			if err := lr.SetAPIEndpoint(ma); err != nil {
+				return xerrors.Errorf("setting api endpoint: %w", err)
+			}
+
+			ainfo, err := lcli.GetAPIInfo(cctx, repo.StorageMiner)
+			if err != nil {
+				return xerrors.Errorf("could not get miner API info: %w", err)
+			}
+
+			// TODO: ideally this would be a token with some permissions dropped
+			if err := lr.SetAPIToken(ainfo.Token); err != nil {
+				return xerrors.Errorf("setting api token: %w", err)
+			}
+		}
+
+		log.Info("Waiting for tasks")
+
+		go func() {
+			if err := nodeApi.WorkerConnect(ctx, "ws://"+address+"/rpc/v0"); err != nil {
+				log.Errorf("Registering worker failed: %+v", err)
+				cancel()
+				return
+			}
+		}()
+
+		return srv.Serve(nl)
 	},
 }
+
+func watchMinerConn(ctx context.Context, cctx *cli.Context, nodeApi api.StorageMiner) {
+	go func() {
+		closing, err := nodeApi.Closing(ctx)
+		if err != nil {
+			log.Errorf("failed to get remote closing channel: %+v", err)
+		}
+
+		select {
+		case <-closing:
+		case <-ctx.Done():
+		}
+
+		if ctx.Err() != nil {
+			return // graceful shutdown
+		}
+
+		log.Warnf("Connection with miner node lost, restarting")
+
+		exe, err := os.Executable()
+		if err != nil {
+			log.Errorf("getting executable for auto-restart: %+v", err)
+		}
+
+		_ = log.Sync()
+
+		// TODO: there are probably cleaner/more graceful ways to restart,
+		//  but this is good enough for now (FSM can recover from the mess this creates)
+		//nolint:gosec
+		if err := syscall.Exec(exe, []string{exe,
+			fmt.Sprintf("--worker-repo=%s", cctx.String("worker-repo")),
+			fmt.Sprintf("--miner-repo=%s", cctx.String("miner-repo")),
+			fmt.Sprintf("--enable-gpu-proving=%t", cctx.Bool("enable-gpu-proving")),
+			"run",
+			fmt.Sprintf("--listen=%s", cctx.String("listen")),
+			fmt.Sprintf("--no-local-storage=%t", cctx.Bool("no-local-storage")),
+			fmt.Sprintf("--addpiece=%t", cctx.Bool("addpiece")),
+			fmt.Sprintf("--precommit1=%t", cctx.Bool("precommit1")),
+			fmt.Sprintf("--unseal=%t", cctx.Bool("unseal")),
+			fmt.Sprintf("--precommit2=%t", cctx.Bool("precommit2")),
+			fmt.Sprintf("--commit=%t", cctx.Bool("commit")),
+			fmt.Sprintf("--parallel-fetch-limit=%d", cctx.Int("parallel-fetch-limit")),
+			fmt.Sprintf("--timeout=%s", cctx.String("timeout")),
+		}, os.Environ()); err != nil {
+			fmt.Println(err)
+		}
+	}()
+}
+
+func extractRoutableIP(timeout time.Duration) (string, error) {
+	minerMultiAddrKey := "MINER_API_INFO"
+	deprecatedMinerMultiAddrKey := "STORAGE_API_INFO"
+	env, ok := os.LookupEnv(minerMultiAddrKey)
+	if !ok {
+		// TODO remove after deprecation period
+		_, ok = os.LookupEnv(deprecatedMinerMultiAddrKey)
+		if ok {
+			log.Warnf("Using a deprecated env(%s) value, please use env(%s) instead.", deprecatedMinerMultiAddrKey, minerMultiAddrKey)
+		}
+		return "", xerrors.New("MINER_API_INFO environment variable required to extract IP")
+	}
+	minerAddr := strings.Split(env, "/")
+	conn, err := net.DialTimeout("tcp", minerAddr[2]+":"+minerAddr[4], timeout)
+	if err != nil {
+		return "", err
+	}
+	defer conn.Close() //nolint:errcheck
+
+	localAddr := conn.LocalAddr().(*net.TCPAddr)
+
+	return strings.Split(localAddr.IP.String(), ":")[0], nil
+}
diff --git a/cmd/lotus-seal-worker/rpc.go b/cmd/lotus-seal-worker/rpc.go
new file mode 100644
index 000000000..8aa9093c2
--- /dev/null
+++ b/cmd/lotus-seal-worker/rpc.go
@@ -0,0 +1,46 @@
+package main
+
+import (
+	"context"
+
+	"github.com/mitchellh/go-homedir"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/specs-storage/storage"
+
+	"github.com/filecoin-project/lotus/build"
+	sectorstorage "github.com/filecoin-project/lotus/extern/sector-storage"
+	"github.com/filecoin-project/lotus/extern/sector-storage/stores"
+)
+
+type worker struct {
+	*sectorstorage.LocalWorker
+
+	localStore *stores.Local
+	ls         stores.LocalStorage
+}
+
+func (w *worker) Version(context.Context) (build.Version, error) {
+	return build.WorkerAPIVersion, nil
+}
+
+func (w *worker) StorageAddLocal(ctx context.Context, path string) error {
+	path, err := homedir.Expand(path)
+	if err != nil {
+		return xerrors.Errorf("expanding local path: %w", err)
+	}
+
+	if err := w.localStore.OpenPath(ctx, path); err != nil {
+		return xerrors.Errorf("opening local path: %w", err)
+	}
+
+	if err := w.ls.SetStorage(func(sc *stores.StorageConfig) {
+		sc.StoragePaths = append(sc.StoragePaths, stores.LocalPath{Path: path})
+	}); err != nil {
+		return xerrors.Errorf("get storage config: %w", err)
+	}
+
+	return nil
+}
+
+var _ storage.Sealer = &worker{}
diff --git a/cmd/lotus-seal-worker/storage.go b/cmd/lotus-seal-worker/storage.go
new file mode 100644
index 000000000..39cd3ad5a
--- /dev/null
+++ b/cmd/lotus-seal-worker/storage.go
@@ -0,0 +1,105 @@
+package main
+
+import (
+	"encoding/json"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+
+	"github.com/google/uuid"
+	"github.com/mitchellh/go-homedir"
+	"github.com/urfave/cli/v2"
+	"golang.org/x/xerrors"
+
+	lcli "github.com/filecoin-project/lotus/cli"
+	"github.com/filecoin-project/lotus/extern/sector-storage/stores"
+)
+
+const metaFile = "sectorstore.json"
+
+var storageCmd = &cli.Command{
+	Name:  "storage",
+	Usage: "manage sector storage",
+	Subcommands: []*cli.Command{
+		storageAttachCmd,
+	},
+}
+
+var storageAttachCmd = &cli.Command{
+	Name:  "attach",
+	Usage: "attach local storage path",
+	Flags: []cli.Flag{
+		&cli.BoolFlag{
+			Name:  "init",
+			Usage: "initialize the path first",
+		},
+		&cli.Uint64Flag{
+			Name:  "weight",
+			Usage: "(for init) path weight",
+			Value: 10,
+		},
+		&cli.BoolFlag{
+			Name:  "seal",
+			Usage: "(for init) use path for sealing",
+		},
+		&cli.BoolFlag{
+			Name:  "store",
+			Usage: "(for init) use path for long-term storage",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		nodeApi, closer, err := lcli.GetWorkerAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+		ctx := lcli.ReqContext(cctx)
+
+		if !cctx.Args().Present() {
+			return xerrors.Errorf("must specify storage path to attach")
+		}
+
+		p, err := homedir.Expand(cctx.Args().First())
+		if err != nil {
+			return xerrors.Errorf("expanding path: %w", err)
+		}
+
+		if cctx.Bool("init") {
+			if err := os.MkdirAll(p, 0755); err != nil {
+				if !os.IsExist(err) {
+					return err
+				}
+			}
+
+			_, err := os.Stat(filepath.Join(p, metaFile))
+			if !os.IsNotExist(err) {
+				if err == nil {
+					return xerrors.Errorf("path is already initialized")
+				}
+				return err
+			}
+
+			cfg := &stores.LocalStorageMeta{
+				ID:       stores.ID(uuid.New().String()),
+				Weight:   cctx.Uint64("weight"),
+				CanSeal:  cctx.Bool("seal"),
+				CanStore: cctx.Bool("store"),
+			}
+
+			if !(cfg.CanStore || cfg.CanSeal) {
+				return xerrors.Errorf("must specify at least one of --store of --seal")
+			}
+
+			b, err := json.MarshalIndent(cfg, "", "  ")
+			if err != nil {
+				return xerrors.Errorf("marshaling storage config: %w", err)
+			}
+
+			if err := ioutil.WriteFile(filepath.Join(p, metaFile), b, 0644); err != nil {
+				return xerrors.Errorf("persisting storage metadata (%s): %w", filepath.Join(p, metaFile), err)
+			}
+		}
+
+		return nodeApi.StorageAddLocal(ctx, p)
+	},
+}
diff --git a/cmd/lotus-seal-worker/sub.go b/cmd/lotus-seal-worker/sub.go
deleted file mode 100644
index d79a8ed83..000000000
--- a/cmd/lotus-seal-worker/sub.go
+++ /dev/null
@@ -1,137 +0,0 @@
-package main
-
-import (
-	"context"
-	"net/http"
-
-	paramfetch "github.com/filecoin-project/go-paramfetch"
-	"github.com/filecoin-project/go-sectorbuilder"
-	"golang.org/x/xerrors"
-
-	lapi "github.com/filecoin-project/lotus/api"
-	"github.com/filecoin-project/lotus/build"
-)
-
-type worker struct {
-	api           lapi.StorageMiner
-	minerEndpoint string
-	repo          string
-	auth          http.Header
-
-	sb *sectorbuilder.SectorBuilder
-}
-
-func acceptJobs(ctx context.Context, api lapi.StorageMiner, endpoint string, auth http.Header, repo string, noprecommit, nocommit bool) error {
-	act, err := api.ActorAddress(ctx)
-	if err != nil {
-		return err
-	}
-	ssize, err := api.ActorSectorSize(ctx, act)
-	if err != nil {
-		return err
-	}
-
-	sb, err := sectorbuilder.NewStandalone(&sectorbuilder.Config{
-		SectorSize:    ssize,
-		Miner:         act,
-		WorkerThreads: 1,
-		Dir:           repo,
-	})
-	if err != nil {
-		return err
-	}
-
-	if err := paramfetch.GetParams(build.ParametersJson, ssize); err != nil {
-		return xerrors.Errorf("get params: %w", err)
-	}
-
-	w := &worker{
-		api:           api,
-		minerEndpoint: endpoint,
-		auth:          auth,
-		repo:          repo,
-		sb:            sb,
-	}
-
-	tasks, err := api.WorkerQueue(ctx, sectorbuilder.WorkerCfg{
-		NoPreCommit: noprecommit,
-		NoCommit:    nocommit,
-	})
-	if err != nil {
-		return err
-	}
-
-loop:
-	for {
-		log.Infof("Waiting for new task")
-
-		select {
-		case task := <-tasks:
-			log.Infof("New task: %d, sector %d, action: %d", task.TaskID, task.SectorID, task.Type)
-
-			res := w.processTask(ctx, task)
-
-			log.Infof("Task %d done, err: %+v", task.TaskID, res.GoErr)
-
-			if err := api.WorkerDone(ctx, task.TaskID, res); err != nil {
-				log.Error(err)
-			}
-		case <-ctx.Done():
-			break loop
-		}
-	}
-
-	log.Warn("acceptJobs exit")
-	return nil
-}
-
-func (w *worker) processTask(ctx context.Context, task sectorbuilder.WorkerTask) sectorbuilder.SealRes {
-	switch task.Type {
-	case sectorbuilder.WorkerPreCommit:
-	case sectorbuilder.WorkerCommit:
-	default:
-		return errRes(xerrors.Errorf("unknown task type %d", task.Type))
-	}
-
-	if err := w.fetchSector(task.SectorID, task.Type); err != nil {
-		return errRes(xerrors.Errorf("fetching sector: %w", err))
-	}
-
-	log.Infof("Data fetched, starting computation")
-
-	var res sectorbuilder.SealRes
-
-	switch task.Type {
-	case sectorbuilder.WorkerPreCommit:
-		rspco, err := w.sb.SealPreCommit(task.SectorID, task.SealTicket, task.Pieces)
-		if err != nil {
-			return errRes(xerrors.Errorf("precomitting: %w", err))
-		}
-		res.Rspco = rspco.ToJson()
-
-		if err := w.push("sealed", task.SectorID); err != nil {
-			return errRes(xerrors.Errorf("pushing precommited data: %w", err))
-		}
-
-		if err := w.push("cache", task.SectorID); err != nil {
-			return errRes(xerrors.Errorf("pushing precommited data: %w", err))
-		}
-	case sectorbuilder.WorkerCommit:
-		proof, err := w.sb.SealCommit(task.SectorID, task.SealTicket, task.SealSeed, task.Pieces, task.Rspco)
-		if err != nil {
-			return errRes(xerrors.Errorf("comitting: %w", err))
-		}
-
-		res.Proof = proof
-
-		if err := w.push("cache", task.SectorID); err != nil {
-			return errRes(xerrors.Errorf("pushing precommited data: %w", err))
-		}
-	}
-
-	return res
-}
-
-func errRes(err error) sectorbuilder.SealRes {
-	return sectorbuilder.SealRes{Err: err.Error(), GoErr: err}
-}
diff --git a/cmd/lotus-seal-worker/transfer.go b/cmd/lotus-seal-worker/transfer.go
deleted file mode 100644
index 9697a4bad..000000000
--- a/cmd/lotus-seal-worker/transfer.go
+++ /dev/null
@@ -1,147 +0,0 @@
-package main
-
-import (
-	"io"
-	"mime"
-	"net/http"
-	"os"
-
-	sectorbuilder "github.com/filecoin-project/go-sectorbuilder"
-	files "github.com/ipfs/go-ipfs-files"
-	"golang.org/x/xerrors"
-	"gopkg.in/cheggaaa/pb.v1"
-	"path/filepath"
-
-	"github.com/filecoin-project/lotus/lib/tarutil"
-)
-
-func (w *worker) fetch(typ string, sectorID uint64) error {
-	outname := filepath.Join(w.repo, typ, w.sb.SectorName(sectorID))
-
-	url := w.minerEndpoint + "/remote/" + typ + "/" + w.sb.SectorName(sectorID)
-	log.Infof("Fetch %s %s", typ, url)
-
-	req, err := http.NewRequest("GET", url, nil)
-	if err != nil {
-		return xerrors.Errorf("request: %w", err)
-	}
-	req.Header = w.auth
-
-	resp, err := http.DefaultClient.Do(req)
-	if err != nil {
-		return xerrors.Errorf("do request: %w", err)
-	}
-	defer resp.Body.Close()
-
-	if resp.StatusCode != 200 {
-		return xerrors.Errorf("non-200 code: %d", resp.StatusCode)
-	}
-
-	bar := pb.New64(resp.ContentLength)
-	bar.ShowPercent = true
-	bar.ShowSpeed = true
-	bar.Units = pb.U_BYTES
-
-	barreader := bar.NewProxyReader(resp.Body)
-
-	bar.Start()
-	defer bar.Finish()
-
-	mediatype, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
-	if err != nil {
-		return xerrors.Errorf("parse media type: %w", err)
-	}
-
-	if err := os.RemoveAll(outname); err != nil {
-		return xerrors.Errorf("removing dest: %w", err)
-	}
-
-	switch mediatype {
-	case "application/x-tar":
-		return tarutil.ExtractTar(barreader, outname)
-	case "application/octet-stream":
-		return files.WriteTo(files.NewReaderFile(barreader), outname)
-	default:
-		return xerrors.Errorf("unknown content type: '%s'", mediatype)
-	}
-
-}
-
-func (w *worker) push(typ string, sectorID uint64) error {
-	filename := filepath.Join(w.repo, typ, w.sb.SectorName(sectorID))
-
-	url := w.minerEndpoint + "/remote/" + typ + "/" + w.sb.SectorName(sectorID)
-	log.Infof("Push %s %s", typ, url)
-
-	stat, err := os.Stat(filename)
-	if err != nil {
-		return err
-	}
-
-	var r io.Reader
-	if stat.IsDir() {
-		r, err = tarutil.TarDirectory(filename)
-	} else {
-		r, err = os.OpenFile(filename, os.O_RDONLY, 0644)
-	}
-	if err != nil {
-		return xerrors.Errorf("opening push reader: %w", err)
-	}
-
-	bar := pb.New64(0)
-	bar.ShowPercent = true
-	bar.ShowSpeed = true
-	bar.ShowCounters = true
-	bar.Units = pb.U_BYTES
-
-	bar.Start()
-	defer bar.Finish()
-	//todo set content size
-
-	header := w.auth
-
-	if stat.IsDir() {
-		header.Set("Content-Type", "application/x-tar")
-	} else {
-		header.Set("Content-Type", "application/octet-stream")
-	}
-
-	req, err := http.NewRequest("PUT", url, bar.NewProxyReader(r))
-	if err != nil {
-		return err
-	}
-	req.Header = header
-
-	resp, err := http.DefaultClient.Do(req)
-	if err != nil {
-		return err
-	}
-	if resp.StatusCode != 200 {
-		return xerrors.Errorf("non-200 response: %d", resp.StatusCode)
-	}
-
-	if err := resp.Body.Close(); err != nil {
-		return err
-	}
-
-	// TODO: keep files around for later stages of sealing
-	return os.RemoveAll(filename)
-}
-
-func (w *worker) fetchSector(sectorID uint64, typ sectorbuilder.WorkerTaskType) error {
-	var err error
-	switch typ {
-	case sectorbuilder.WorkerPreCommit:
-		err = w.fetch("staging", sectorID)
-	case sectorbuilder.WorkerCommit:
-		err = w.fetch("sealed", sectorID)
-		if err != nil {
-			return xerrors.Errorf("fetch sealed: %w", err)
-		}
-		err = w.fetch("cache", sectorID)
-	}
-	if err != nil {
-		return xerrors.Errorf("fetch failed: %w", err)
-	}
-	return nil
-}
diff --git a/cmd/lotus-seed/genesis.go b/cmd/lotus-seed/genesis.go
new file mode 100644
index 000000000..bbaea6969
--- /dev/null
+++ b/cmd/lotus-seed/genesis.go
@@ -0,0 +1,304 @@
+package main
+
+import (
+	"encoding/csv"
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"os"
+	"strconv"
+	"strings"
+
+	"github.com/google/uuid"
+	"github.com/mitchellh/go-homedir"
+	"github.com/urfave/cli/v2"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/big"
+
+	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/gen"
+	genesis2 "github.com/filecoin-project/lotus/chain/gen/genesis"
+	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/genesis"
+)
+
+var genesisCmd = &cli.Command{
+	Name:        "genesis",
+	Description: "manipulate lotus genesis template",
+	Subcommands: []*cli.Command{
+		genesisNewCmd,
+		genesisAddMinerCmd,
+		genesisAddMsigsCmd,
+	},
+}
+
+var genesisNewCmd = &cli.Command{
+	Name:        "new",
+	Description: "create new genesis template",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name: "network-name",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		if !cctx.Args().Present() {
+			return xerrors.New("seed genesis new [genesis.json]")
+		}
+		out := genesis.Template{
+			Accounts:         []genesis.Actor{},
+			Miners:           []genesis.Miner{},
+			VerifregRootKey:  gen.DefaultVerifregRootkeyActor,
+			RemainderAccount: gen.DefaultRemainderAccountActor,
+			NetworkName:      cctx.String("network-name"),
+		}
+		if out.NetworkName == "" {
+			out.NetworkName = "localnet-" + uuid.New().String()
+		}
+
+		genb, err := json.MarshalIndent(&out, "", "  ")
+		if err != nil {
+			return err
+		}
+
+		genf, err := homedir.Expand(cctx.Args().First())
+		if err != nil {
+			return err
+		}
+
+		if err := ioutil.WriteFile(genf, genb, 0644); err != nil {
+			return err
+		}
+
+		return nil
+	},
+}
+
+var genesisAddMinerCmd = &cli.Command{
+	Name:        "add-miner",
+	Description: "add genesis miner",
+	Flags:       []cli.Flag{},
+	Action: func(cctx *cli.Context) error {
+		if cctx.Args().Len() != 2 {
+			return xerrors.New("seed genesis add-miner [genesis.json] [preseal.json]")
+		}
+
+		genf, err := homedir.Expand(cctx.Args().First())
+		if err != nil {
+			return err
+		}
+
+		var template genesis.Template
+		genb, err := ioutil.ReadFile(genf)
+		if err != nil {
+			return xerrors.Errorf("read genesis template: %w", err)
+		}
+
+		if err := json.Unmarshal(genb, &template); err != nil {
+			return xerrors.Errorf("unmarshal genesis template: %w", err)
+		}
+
+		minf, err := homedir.Expand(cctx.Args().Get(1))
+		if err != nil {
+			return xerrors.Errorf("expand preseal file path: %w", err)
+		}
+		miners := map[string]genesis.Miner{}
+		minb, err := ioutil.ReadFile(minf)
+		if err != nil {
+			return xerrors.Errorf("read preseal file: %w", err)
+		}
+		if err := json.Unmarshal(minb, &miners); err != nil {
+			return xerrors.Errorf("unmarshal miner info: %w", err)
+		}
+
+		for mn, miner := range miners {
+			log.Infof("Adding miner %s to genesis template", mn)
+			{
+				id := uint64(genesis2.MinerStart) + uint64(len(template.Miners))
+				maddr, err := address.NewFromString(mn)
+				if err != nil {
+					return xerrors.Errorf("parsing miner address: %w", err)
+				}
+				mid, err := address.IDFromAddress(maddr)
+				if err != nil {
+					return xerrors.Errorf("getting miner id from address: %w", err)
+				}
+				if mid != id {
+					return xerrors.Errorf("tried to set miner t0%d as t0%d", mid, id)
+				}
+			}
+
+			template.Miners = append(template.Miners, miner)
+			log.Infof("Giving %s some initial balance", miner.Owner)
+			template.Accounts = append(template.Accounts, genesis.Actor{
+				Type:    genesis.TAccount,
+				Balance: big.Mul(big.NewInt(50_000_000), big.NewInt(int64(build.FilecoinPrecision))),
+				Meta:    (&genesis.AccountMeta{Owner: miner.Owner}).ActorMeta(),
+			})
+		}
+
+		genb, err = json.MarshalIndent(&template, "", "  ")
+		if err != nil {
+			return err
+		}
+
+		if err := ioutil.WriteFile(genf, genb, 0644); err != nil {
+			return err
+		}
+
+		return nil
+	},
+}
+
+type GenAccountEntry struct {
+	Version       int
+	ID            string
+	Amount        types.FIL
+	VestingMonths int
+	CustodianID   int
+	M             int
+	N             int
+	Addresses     []address.Address
+	Type          string
+	Sig1          string
+	Sig2          string
+}
+
+var genesisAddMsigsCmd = &cli.Command{
+	Name: "add-msigs",
+	Action: func(cctx *cli.Context) error {
+		if cctx.Args().Len() < 2 {
+			return fmt.Errorf("must specify template file and csv file with accounts")
+		}
+
+		genf, err := homedir.Expand(cctx.Args().First())
+		if err != nil {
+			return err
+		}
+
+		csvf, err := homedir.Expand(cctx.Args().Get(1))
+		if err != nil {
+			return err
+		}
+
+		var template genesis.Template
+		b, err := ioutil.ReadFile(genf)
+		if err != nil {
+			return xerrors.Errorf("read genesis template: %w", err)
+		}
+
+		if err := json.Unmarshal(b, &template); err != nil {
+			return xerrors.Errorf("unmarshal genesis template: %w", err)
+		}
+
+		entries, err := parseMultisigCsv(csvf)
+		if err != nil {
+			return xerrors.Errorf("parsing multisig csv file: %w", err)
+		}
+
+		for i, e := range entries {
+			if len(e.Addresses) != e.N {
+				return fmt.Errorf("entry %d had mismatch between 'N' and number of addresses", i)
+			}
+
+			msig := &genesis.MultisigMeta{
+				Signers:         e.Addresses,
+				Threshold:       e.M,
+				VestingDuration: monthsToBlocks(e.VestingMonths),
+				VestingStart:    0,
+			}
+
+			act := genesis.Actor{
+				Type:    genesis.TMultisig,
+				Balance: abi.TokenAmount(e.Amount),
+				Meta:    msig.ActorMeta(),
+			}
+
+			template.Accounts = append(template.Accounts, act)
+
+		}
+
+		b, err = json.MarshalIndent(&template, "", "  ")
+		if err != nil {
+			return err
+		}
+
+		if err := ioutil.WriteFile(genf, b, 0644); err != nil {
+			return err
+		}
+		return nil
+	},
+}
+
+func monthsToBlocks(nmonths int) int {
+	days := uint64((365 * nmonths) / 12)
+	return int(days * 24 * 60 * 60 / build.BlockDelaySecs)
+}
+
+func parseMultisigCsv(csvf string) ([]GenAccountEntry, error) {
+	fileReader, err := os.Open(csvf)
+	if err != nil {
+		return nil, xerrors.Errorf("read multisig csv: %w", err)
+	}
+	defer fileReader.Close() //nolint:errcheck
+	r := csv.NewReader(fileReader)
+	records, err := r.ReadAll()
+	if err != nil {
+		return nil, xerrors.Errorf("read multisig csv: %w", err)
+	}
+	var entries []GenAccountEntry
+	for i, e := range records[1:] {
+		var addrs []address.Address
+		addrStrs := strings.Split(strings.TrimSpace(e[7]), ":")
+		for j, a := range addrStrs {
+			addr, err := address.NewFromString(a)
+			if err != nil {
+				return nil, xerrors.Errorf("failed to parse address %d in row %d (%q): %w", j, i, a, err)
+			}
+			addrs = append(addrs, addr)
+		}
+
+		balance, err := types.ParseFIL(strings.TrimSpace(e[2]))
+		if err != nil {
+			return nil, xerrors.Errorf("failed to parse account balance: %w", err)
+		}
+
+		vesting, err := strconv.Atoi(strings.TrimSpace(e[3]))
+		if err != nil {
+			return nil, xerrors.Errorf("failed to parse vesting duration for record %d: %w", i, err)
+		}
+
+		custodianID, err := strconv.Atoi(strings.TrimSpace(e[4]))
+		if err != nil {
+			return nil, xerrors.Errorf("failed to parse custodianID in record %d: %w", i, err)
+		}
+		threshold, err := strconv.Atoi(strings.TrimSpace(e[5]))
+		if err != nil {
+			return nil, xerrors.Errorf("failed to parse multisigM in record %d: %w", i, err)
+		}
+		num, err := strconv.Atoi(strings.TrimSpace(e[6]))
+		if err != nil {
+			return nil, xerrors.Errorf("Number of addresses be integer: %w", err)
+		}
+		if e[0] != "1" {
+			return nil, xerrors.Errorf("record version must be 1")
+		}
+		entries = append(entries, GenAccountEntry{
+			Version:       1,
+			ID:            e[1],
+			Amount:        balance,
+			CustodianID:   custodianID,
+			VestingMonths: vesting,
+			M:             threshold,
+			N:             num,
+			Type:          e[8],
+			Sig1:          e[9],
+			Sig2:          e[10],
+			Addresses:     addrs,
+		})
+	}
+
+	return entries, nil
+}
diff --git a/cmd/lotus-seed/main.go b/cmd/lotus-seed/main.go
index 82abbe047..d365f6493 100644
--- a/cmd/lotus-seed/main.go
+++ b/cmd/lotus-seed/main.go
@@ -1,23 +1,25 @@
 package main
 
 import (
-	"fmt"
-	"os"
-	"path/filepath"
-
+	"encoding/hex"
 	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"os"
 
-	sectorbuilder "github.com/filecoin-project/go-sectorbuilder"
-	"github.com/ipfs/go-datastore"
-	"github.com/ipfs/go-datastore/namespace"
-	badger "github.com/ipfs/go-ds-badger"
-	logging "github.com/ipfs/go-log"
+	"github.com/docker/go-units"
+	"github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper"
+
+	logging "github.com/ipfs/go-log/v2"
 	"github.com/mitchellh/go-homedir"
-	"golang.org/x/xerrors"
-	"gopkg.in/urfave/cli.v2"
+	"github.com/urfave/cli/v2"
 
 	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/big"
+
 	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/cmd/lotus-seed/seed"
 	"github.com/filecoin-project/lotus/genesis"
 )
@@ -27,21 +29,20 @@ var log = logging.Logger("lotus-seed")
 func main() {
 	logging.SetLogLevel("*", "INFO")
 
-	log.Info("Starting seed")
-
 	local := []*cli.Command{
+		genesisCmd,
+
 		preSealCmd,
 		aggregateManifestsCmd,
-		aggregateSectorDirsCmd,
 	}
 
 	app := &cli.App{
 		Name:    "lotus-seed",
 		Usage:   "Seal sectors for genesis miner",
-		Version: build.UserVersion,
+		Version: build.UserVersion(),
 		Flags: []cli.Flag{
 			&cli.StringFlag{
-				Name:  "sectorbuilder-dir",
+				Name:  "sector-dir",
 				Value: "~/.genesis-sectors",
 			},
 		},
@@ -51,7 +52,7 @@ func main() {
 
 	if err := app.Run(os.Args); err != nil {
 		log.Warn(err)
-		return
+		os.Exit(1)
 	}
 }
 
@@ -60,12 +61,12 @@ var preSealCmd = &cli.Command{
 	Flags: []cli.Flag{
 		&cli.StringFlag{
 			Name:  "miner-addr",
-			Value: "t0101",
+			Value: "t01000",
 			Usage: "specify the future address of your miner",
 		},
-		&cli.Uint64Flag{
+		&cli.StringFlag{
 			Name:  "sector-size",
-			Value: build.SectorSizes[0],
+			Value: "2KiB",
 			Usage: "specify size of sectors to pre-seal",
 		},
 		&cli.StringFlag{
@@ -83,9 +84,18 @@ var preSealCmd = &cli.Command{
 			Value: 0,
 			Usage: "how many sector ids to skip when starting to seal",
 		},
+		&cli.StringFlag{
+			Name:  "key",
+			Value: "",
+			Usage: "(optional) Key to use for signing / owner/worker addresses",
+		},
+		&cli.BoolFlag{
+			Name:  "fake-sectors",
+			Value: false,
+		},
 	},
 	Action: func(c *cli.Context) error {
-		sdir := c.String("sectorbuilder-dir")
+		sdir := c.String("sector-dir")
 		sbroot, err := homedir.Expand(sdir)
 		if err != nil {
 			return err
@@ -96,12 +106,39 @@ var preSealCmd = &cli.Command{
 			return err
 		}
 
-		gm, err := seed.PreSeal(maddr, c.Uint64("sector-size"), c.Uint64("sector-offset"), c.Int("num-sectors"), sbroot, []byte(c.String("ticket-preimage")))
+		var k *types.KeyInfo
+		if c.String("key") != "" {
+			k = new(types.KeyInfo)
+			kh, err := ioutil.ReadFile(c.String("key"))
+			if err != nil {
+				return err
+			}
+			kb, err := hex.DecodeString(string(kh))
+			if err != nil {
+				return err
+			}
+			if err := json.Unmarshal(kb, k); err != nil {
+				return err
+			}
+		}
+
+		sectorSizeInt, err := units.RAMInBytes(c.String("sector-size"))
+		if err != nil {
+			return err
+		}
+		sectorSize := abi.SectorSize(sectorSizeInt)
+
+		rp, err := ffiwrapper.SealProofTypeFromSectorSize(sectorSize)
 		if err != nil {
 			return err
 		}
 
-		return seed.WriteGenesisMiner(maddr, sbroot, gm)
+		gm, key, err := seed.PreSeal(maddr, rp, abi.SectorNumber(c.Uint64("sector-offset")), c.Int("num-sectors"), sbroot, []byte(c.String("ticket-preimage")), k, c.Bool("fake-sectors"))
+		if err != nil {
+			return err
+		}
+
+		return seed.WriteGenesisMiner(maddr, sbroot, gm, key)
 	},
 }
 
@@ -109,22 +146,24 @@ var aggregateManifestsCmd = &cli.Command{
 	Name:  "aggregate-manifests",
 	Usage: "aggregate a set of preseal manifests into a single file",
 	Action: func(cctx *cli.Context) error {
-		var inputs []map[string]genesis.GenesisMiner
+		var inputs []map[string]genesis.Miner
 		for _, infi := range cctx.Args().Slice() {
 			fi, err := os.Open(infi)
 			if err != nil {
 				return err
 			}
-			defer fi.Close()
-			var val map[string]genesis.GenesisMiner
+			var val map[string]genesis.Miner
 			if err := json.NewDecoder(fi).Decode(&val); err != nil {
 				return err
 			}
 
 			inputs = append(inputs, val)
+			if err := fi.Close(); err != nil {
+				return err
+			}
 		}
 
-		output := make(map[string]genesis.GenesisMiner)
+		output := make(map[string]genesis.Miner)
 		for _, in := range inputs {
 			for maddr, val := range in {
 				if gm, ok := output[maddr]; ok {
@@ -145,152 +184,18 @@ var aggregateManifestsCmd = &cli.Command{
 	},
 }
 
-var aggregateSectorDirsCmd = &cli.Command{
-	Name:  "aggregate-sector-dirs",
-	Usage: "aggregate a set of preseal manifests into a single file",
-	Flags: []cli.Flag{
-		&cli.StringFlag{
-			Name:  "miner",
-			Usage: "Specify address of miner to aggregate sectorbuilders for",
-		},
-		&cli.StringFlag{
-			Name:  "dest",
-			Usage: "specify directory to create aggregate sector store in",
-		},
-		&cli.Uint64Flag{
-			Name:  "sector-size",
-			Usage: "specify size of sectors to aggregate",
-			Value: 32 * 1024 * 1024 * 1024,
-		},
-	},
-	Action: func(cctx *cli.Context) error {
-		if cctx.String("miner") == "" {
-			return fmt.Errorf("must specify miner address with --miner")
-		}
-		if cctx.String("dest") == "" {
-			return fmt.Errorf("must specify dest directory with --dest")
-		}
-
-		maddr, err := address.NewFromString(cctx.String("miner"))
-		if err != nil {
-			return err
-		}
-
-		destdir, err := homedir.Expand(cctx.String("dest"))
-		if err != nil {
-			return err
-		}
-
-		if err := os.MkdirAll(destdir, 0755); err != nil {
-			return err
-		}
-
-		agmds, err := badger.NewDatastore(filepath.Join(destdir, "badger"), nil)
-		if err != nil {
-			return err
-		}
-		defer agmds.Close()
-
-		ssize := cctx.Uint64("sector-size")
-
-		agsb, err := sectorbuilder.New(&sectorbuilder.Config{
-			Miner:         maddr,
-			SectorSize:    ssize,
-			Dir:           destdir,
-			WorkerThreads: 2,
-		}, namespace.Wrap(agmds, datastore.NewKey("/sectorbuilder")))
-		if err != nil {
-			return err
-		}
-
-		var aggrGenMiner genesis.GenesisMiner
-		var highestSectorID uint64
-		for _, dir := range cctx.Args().Slice() {
-			dir, err := homedir.Expand(dir)
-			if err != nil {
-				return xerrors.Errorf("failed to expand %q: %w", dir, err)
-			}
-
-			st, err := os.Stat(dir)
-			if err != nil {
-				return err
-			}
-			if !st.IsDir() {
-				return fmt.Errorf("%q was not a directory", dir)
-			}
-
-			fi, err := os.Open(filepath.Join(dir, "pre-seal-"+maddr.String()+".json"))
-			if err != nil {
-				return err
-			}
-
-			var genmm map[string]genesis.GenesisMiner
-			if err := json.NewDecoder(fi).Decode(&genmm); err != nil {
-				return err
-			}
-
-			genm, ok := genmm[maddr.String()]
-			if !ok {
-				return xerrors.Errorf("input data did not have our miner in it (%s)", maddr)
-			}
-
-			if genm.SectorSize != ssize {
-				return xerrors.Errorf("sector size mismatch in %q (%d != %d)", dir)
-			}
-
-			for _, s := range genm.Sectors {
-				if s.SectorID > highestSectorID {
-					highestSectorID = s.SectorID
-				}
-			}
-
-			aggrGenMiner = mergeGenMiners(aggrGenMiner, genm)
-
-			opts := badger.DefaultOptions
-			opts.ReadOnly = true
-			mds, err := badger.NewDatastore(filepath.Join(dir, "badger"), &opts)
-			if err != nil {
-				return err
-			}
-			defer mds.Close()
-
-			sb, err := sectorbuilder.New(&sectorbuilder.Config{
-				Miner:         maddr,
-				SectorSize:    genm.SectorSize,
-				Dir:           dir,
-				WorkerThreads: 2,
-			}, namespace.Wrap(mds, datastore.NewKey("/sectorbuilder")))
-			if err != nil {
-				return err
-			}
-
-			if err := agsb.ImportFrom(sb, false); err != nil {
-				return xerrors.Errorf("importing sectors from %q failed: %w", dir, err)
-			}
-		}
-
-		if err := agsb.SetLastSectorID(highestSectorID); err != nil {
-			return err
-		}
-
-		if err := seed.WriteGenesisMiner(maddr, destdir, &aggrGenMiner); err != nil {
-			return err
-		}
-
-		return nil
-	},
-}
-
-func mergeGenMiners(a, b genesis.GenesisMiner) genesis.GenesisMiner {
+func mergeGenMiners(a, b genesis.Miner) genesis.Miner {
 	if a.SectorSize != b.SectorSize {
 		panic("sector sizes mismatch")
 	}
 
-	return genesis.GenesisMiner{
-		Owner:      a.Owner,
-		Worker:     a.Worker,
-		SectorSize: a.SectorSize,
-		Key:        a.Key,
-		Sectors:    append(a.Sectors, b.Sectors...),
+	return genesis.Miner{
+		Owner:         a.Owner,
+		Worker:        a.Worker,
+		PeerId:        a.PeerId,
+		MarketBalance: big.Zero(),
+		PowerBalance:  big.Zero(),
+		SectorSize:    a.SectorSize,
+		Sectors:       append(a.Sectors, b.Sectors...),
 	}
 }
diff --git a/cmd/lotus-seed/seed/seed.go b/cmd/lotus-seed/seed/seed.go
index e42593bf4..5e911991d 100644
--- a/cmd/lotus-seed/seed/seed.go
+++ b/cmd/lotus-seed/seed/seed.go
@@ -3,120 +3,225 @@ package seed
 import (
 	"context"
 	"crypto/rand"
-	"crypto/sha256"
+	"encoding/hex"
 	"encoding/json"
 	"fmt"
 	"io/ioutil"
 	"os"
 	"path/filepath"
 
-	sectorbuilder "github.com/filecoin-project/go-sectorbuilder"
-	"github.com/ipfs/go-datastore"
-	"github.com/ipfs/go-datastore/namespace"
-	badger "github.com/ipfs/go-ds-badger"
-	logging "github.com/ipfs/go-log"
+	"github.com/google/uuid"
+	logging "github.com/ipfs/go-log/v2"
+	ic "github.com/libp2p/go-libp2p-core/crypto"
+	"github.com/libp2p/go-libp2p-core/peer"
+	"github.com/minio/blake2b-simd"
 	"golang.org/x/xerrors"
 
+	ffi "github.com/filecoin-project/filecoin-ffi"
 	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/lotus/api"
-	"github.com/filecoin-project/lotus/chain/actors"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/big"
+	"github.com/filecoin-project/go-state-types/crypto"
+	"github.com/filecoin-project/lotus/extern/sector-storage/zerocomm"
+	"github.com/filecoin-project/specs-actors/actors/builtin/market"
+
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/chain/wallet"
+	"github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper"
+	"github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper/basicfs"
+	"github.com/filecoin-project/lotus/extern/sector-storage/stores"
 	"github.com/filecoin-project/lotus/genesis"
 )
 
 var log = logging.Logger("preseal")
 
-func PreSeal(maddr address.Address, ssize uint64, offset uint64, sectors int, sbroot string, preimage []byte) (*genesis.GenesisMiner, error) {
-	cfg := &sectorbuilder.Config{
-		Miner:          maddr,
-		SectorSize:     ssize,
-		FallbackLastID: offset,
-		Dir:            sbroot,
-		WorkerThreads:  2,
-	}
-
-	if err := os.MkdirAll(sbroot, 0775); err != nil {
-		return nil, err
-	}
-
-	mds, err := badger.NewDatastore(filepath.Join(sbroot, "badger"), nil)
+func PreSeal(maddr address.Address, spt abi.RegisteredSealProof, offset abi.SectorNumber, sectors int, sbroot string, preimage []byte, key *types.KeyInfo, fakeSectors bool) (*genesis.Miner, *types.KeyInfo, error) {
+	mid, err := address.IDFromAddress(maddr)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
-	sb, err := sectorbuilder.New(cfg, namespace.Wrap(mds, datastore.NewKey("/sectorbuilder")))
+	cfg := &ffiwrapper.Config{
+		SealProofType: spt,
+	}
+
+	if err := os.MkdirAll(sbroot, 0775); err != nil { //nolint:gosec
+		return nil, nil, err
+	}
+
+	next := offset
+
+	sbfs := &basicfs.Provider{
+		Root: sbroot,
+	}
+
+	sb, err := ffiwrapper.New(sbfs, cfg)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
-	size := sectorbuilder.UserBytesForSectorSize(ssize)
+	ssize, err := spt.SectorSize()
+	if err != nil {
+		return nil, nil, err
+	}
 
 	var sealedSectors []*genesis.PreSeal
 	for i := 0; i < sectors; i++ {
-		sid, err := sb.AcquireSectorId()
-		if err != nil {
-			return nil, err
+		sid := abi.SectorID{Miner: abi.ActorID(mid), Number: next}
+		next++
+
+		var preseal *genesis.PreSeal
+		if !fakeSectors {
+			preseal, err = presealSector(sb, sbfs, sid, spt, ssize, preimage)
+			if err != nil {
+				return nil, nil, err
+			}
+		} else {
+			preseal, err = presealSectorFake(sbfs, sid, spt, ssize)
+			if err != nil {
+				return nil, nil, err
+			}
 		}
 
-		pi, err := sb.AddPiece(size, sid, rand.Reader, nil)
-		if err != nil {
-			return nil, err
-		}
-
-		trand := sha256.Sum256(preimage)
-		ticket := sectorbuilder.SealTicket{
-			TicketBytes: trand,
-		}
-
-		fmt.Printf("sector-id: %d, piece info: %v", sid, pi)
-
-		pco, err := sb.SealPreCommit(sid, ticket, []sectorbuilder.PublicPieceInfo{pi})
-		if err != nil {
-			return nil, xerrors.Errorf("commit: %w", err)
-		}
-
-		if err := sb.TrimCache(sid); err != nil {
-			return nil, xerrors.Errorf("trim cache: %w", err)
-		}
-
-		log.Warn("PreCommitOutput: ", sid, pco)
-		sealedSectors = append(sealedSectors, &genesis.PreSeal{
-			CommR:    pco.CommR,
-			CommD:    pco.CommD,
-			SectorID: sid,
-		})
+		sealedSectors = append(sealedSectors, preseal)
 	}
 
-	minerAddr, err := wallet.GenerateKey(types.KTBLS)
+	var minerAddr *wallet.Key
+	if key != nil {
+		minerAddr, err = wallet.NewKey(*key)
+		if err != nil {
+			return nil, nil, err
+		}
+	} else {
+		minerAddr, err = wallet.GenerateKey(crypto.SigTypeBLS)
+		if err != nil {
+			return nil, nil, err
+		}
+	}
+
+	var pid peer.ID
+	{
+		log.Warn("PeerID not specified, generating dummy")
+		p, _, err := ic.GenerateEd25519Key(rand.Reader)
+		if err != nil {
+			return nil, nil, err
+		}
+
+		pid, err = peer.IDFromPrivateKey(p)
+		if err != nil {
+			return nil, nil, err
+		}
+	}
+
+	miner := &genesis.Miner{
+		ID:            maddr,
+		Owner:         minerAddr.Address,
+		Worker:        minerAddr.Address,
+		MarketBalance: big.Zero(),
+		PowerBalance:  big.Zero(),
+		SectorSize:    ssize,
+		Sectors:       sealedSectors,
+		PeerId:        pid,
+	}
+
+	if err := createDeals(miner, minerAddr, maddr, ssize); err != nil {
+		return nil, nil, xerrors.Errorf("creating deals: %w", err)
+	}
+
+	{
+		b, err := json.MarshalIndent(&stores.LocalStorageMeta{
+			ID:       stores.ID(uuid.New().String()),
+			Weight:   0, // read-only
+			CanSeal:  false,
+			CanStore: false,
+		}, "", "  ")
+		if err != nil {
+			return nil, nil, xerrors.Errorf("marshaling storage config: %w", err)
+		}
+
+		if err := ioutil.WriteFile(filepath.Join(sbroot, "sectorstore.json"), b, 0644); err != nil {
+			return nil, nil, xerrors.Errorf("persisting storage metadata (%s): %w", filepath.Join(sbroot, "storage.json"), err)
+		}
+	}
+
+	return miner, &minerAddr.KeyInfo, nil
+}
+
+func presealSector(sb *ffiwrapper.Sealer, sbfs *basicfs.Provider, sid abi.SectorID, spt abi.RegisteredSealProof, ssize abi.SectorSize, preimage []byte) (*genesis.PreSeal, error) {
+	pi, err := sb.AddPiece(context.TODO(), sid, nil, abi.PaddedPieceSize(ssize).Unpadded(), rand.Reader)
 	if err != nil {
 		return nil, err
 	}
 
-	miner := &genesis.GenesisMiner{
-		Owner:  minerAddr.Address,
-		Worker: minerAddr.Address,
+	trand := blake2b.Sum256(preimage)
+	ticket := abi.SealRandomness(trand[:])
 
-		SectorSize: ssize,
+	fmt.Printf("sector-id: %d, piece info: %v\n", sid, pi)
 
-		Sectors: sealedSectors,
-
-		Key: minerAddr.KeyInfo,
+	in2, err := sb.SealPreCommit1(context.TODO(), sid, ticket, []abi.PieceInfo{pi})
+	if err != nil {
+		return nil, xerrors.Errorf("commit: %w", err)
 	}
 
-	if err := createDeals(miner, minerAddr, maddr, ssize); err != nil {
-		return nil, xerrors.Errorf("creating deals: %w", err)
+	cids, err := sb.SealPreCommit2(context.TODO(), sid, in2)
+	if err != nil {
+		return nil, xerrors.Errorf("commit: %w", err)
 	}
 
-	if err := mds.Close(); err != nil {
-		return nil, xerrors.Errorf("closing datastore: %w", err)
+	if err := sb.FinalizeSector(context.TODO(), sid, nil); err != nil {
+		return nil, xerrors.Errorf("trim cache: %w", err)
 	}
 
-	return miner, nil
+	if err := cleanupUnsealed(sbfs, sid); err != nil {
+		return nil, xerrors.Errorf("remove unsealed file: %w", err)
+	}
+
+	log.Warn("PreCommitOutput: ", sid, cids.Sealed, cids.Unsealed)
+
+	return &genesis.PreSeal{
+		CommR:     cids.Sealed,
+		CommD:     cids.Unsealed,
+		SectorID:  sid.Number,
+		ProofType: spt,
+	}, nil
 }
 
-func WriteGenesisMiner(maddr address.Address, sbroot string, gm *genesis.GenesisMiner) error {
-	output := map[string]genesis.GenesisMiner{
+func presealSectorFake(sbfs *basicfs.Provider, sid abi.SectorID, spt abi.RegisteredSealProof, ssize abi.SectorSize) (*genesis.PreSeal, error) {
+	paths, done, err := sbfs.AcquireSector(context.TODO(), sid, 0, stores.FTSealed|stores.FTCache, stores.PathSealing)
+	if err != nil {
+		return nil, xerrors.Errorf("acquire unsealed sector: %w", err)
+	}
+	defer done()
+
+	if err := os.Mkdir(paths.Cache, 0755); err != nil {
+		return nil, xerrors.Errorf("mkdir cache: %w", err)
+	}
+
+	commr, err := ffi.FauxRep(spt, paths.Cache, paths.Sealed)
+	if err != nil {
+		return nil, xerrors.Errorf("fauxrep: %w", err)
+	}
+
+	return &genesis.PreSeal{
+		CommR:     commr,
+		CommD:     zerocomm.ZeroPieceCommitment(abi.PaddedPieceSize(ssize).Unpadded()),
+		SectorID:  sid.Number,
+		ProofType: spt,
+	}, nil
+}
+
+func cleanupUnsealed(sbfs *basicfs.Provider, sid abi.SectorID) error {
+	paths, done, err := sbfs.AcquireSector(context.TODO(), sid, stores.FTUnsealed, stores.FTNone, stores.PathSealing)
+	if err != nil {
+		return err
+	}
+	defer done()
+
+	return os.Remove(paths.Unsealed)
+}
+
+func WriteGenesisMiner(maddr address.Address, sbroot string, gm *genesis.Miner, key *types.KeyInfo) error {
+	output := map[string]genesis.Miner{
 		maddr.String(): *gm,
 	}
 
@@ -125,32 +230,40 @@ func WriteGenesisMiner(maddr address.Address, sbroot string, gm *genesis.Genesis
 		return err
 	}
 
+	log.Infof("Writing preseal manifest to %s", filepath.Join(sbroot, "pre-seal-"+maddr.String()+".json"))
+
 	if err := ioutil.WriteFile(filepath.Join(sbroot, "pre-seal-"+maddr.String()+".json"), out, 0664); err != nil {
 		return err
 	}
 
+	if key != nil {
+		b, err := json.Marshal(key)
+		if err != nil {
+			return err
+		}
+
+		// TODO: allow providing key
+		if err := ioutil.WriteFile(filepath.Join(sbroot, "pre-seal-"+maddr.String()+".key"), []byte(hex.EncodeToString(b)), 0664); err != nil {
+			return err
+		}
+	}
+
 	return nil
 }
 
-func createDeals(m *genesis.GenesisMiner, k *wallet.Key, maddr address.Address, ssize uint64) error {
-	for _, sector := range m.Sectors {
-		pref := make([]byte, len(sector.CommD))
-		copy(pref, sector.CommD[:])
-		proposal := &actors.StorageDealProposal{
-			PieceRef:             pref, // just one deal so this == CommP
-			PieceSize:            sectorbuilder.UserBytesForSectorSize(ssize),
+func createDeals(m *genesis.Miner, k *wallet.Key, maddr address.Address, ssize abi.SectorSize) error {
+	for i, sector := range m.Sectors {
+		proposal := &market.DealProposal{
+			PieceCID:             sector.CommD,
+			PieceSize:            abi.PaddedPieceSize(ssize),
 			Client:               k.Address,
 			Provider:             maddr,
-			ProposalExpiration:   9000, // TODO: allow setting
-			Duration:             9000,
-			StoragePricePerEpoch: types.NewInt(0),
-			StorageCollateral:    types.NewInt(0),
-			ProposerSignature:    nil,
-		}
-
-		// TODO: pretty sure we don't even need to sign this
-		if err := api.SignWith(context.TODO(), wallet.KeyWallet(k).Sign, k.Address, proposal); err != nil {
-			return err
+			Label:                fmt.Sprintf("%d", i),
+			StartEpoch:           0,
+			EndEpoch:             9001,
+			StoragePricePerEpoch: big.Zero(),
+			ProviderCollateral:   big.Zero(),
+			ClientCollateral:     big.Zero(),
 		}
 
 		sector.Deal = *proposal
diff --git a/cmd/lotus-shed/balances.go b/cmd/lotus-shed/balances.go
new file mode 100644
index 000000000..1c89a00cf
--- /dev/null
+++ b/cmd/lotus-shed/balances.go
@@ -0,0 +1,388 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"strconv"
+
+	"github.com/docker/go-units"
+	lotusbuiltin "github.com/filecoin-project/lotus/chain/actors/builtin"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/power"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/reward"
+
+	"github.com/ipfs/go-cid"
+	cbor "github.com/ipfs/go-ipld-cbor"
+	logging "github.com/ipfs/go-log/v2"
+	"github.com/urfave/cli/v2"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/big"
+	"github.com/filecoin-project/lotus/chain/actors/adt"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
+	"github.com/filecoin-project/lotus/chain/state"
+	"github.com/filecoin-project/lotus/chain/stmgr"
+	"github.com/filecoin-project/lotus/chain/store"
+	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/chain/vm"
+	lcli "github.com/filecoin-project/lotus/cli"
+	"github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper"
+	"github.com/filecoin-project/lotus/lib/blockstore"
+	"github.com/filecoin-project/lotus/node/repo"
+)
+
+type accountInfo struct {
+	Address       address.Address
+	Balance       types.FIL
+	Type          string
+	Power         abi.StoragePower
+	Worker        address.Address
+	Owner         address.Address
+	InitialPledge types.FIL
+	PreCommits    types.FIL
+	LockedFunds   types.FIL
+	Sectors       uint64
+}
+
+var auditsCmd = &cli.Command{
+	Name:        "audits",
+	Description: "a collection of utilities for auditing the filecoin chain",
+	Subcommands: []*cli.Command{
+		chainBalanceCmd,
+		chainBalanceStateCmd,
+		chainPledgeCmd,
+	},
+}
+
+var chainBalanceCmd = &cli.Command{
+	Name:        "chain-balances",
+	Description: "Produces a csv file of all account balances",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:  "tipset",
+			Usage: "specify tipset to start from",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		api, closer, err := lcli.GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+
+		defer closer()
+		ctx := lcli.ReqContext(cctx)
+
+		ts, err := lcli.LoadTipSet(ctx, cctx, api)
+		if err != nil {
+			return err
+		}
+
+		tsk := ts.Key()
+		actors, err := api.StateListActors(ctx, tsk)
+		if err != nil {
+			return err
+		}
+
+		var infos []accountInfo
+		for _, addr := range actors {
+			act, err := api.StateGetActor(ctx, addr, tsk)
+			if err != nil {
+				return err
+			}
+
+			ai := accountInfo{
+				Address: addr,
+				Balance: types.FIL(act.Balance),
+				Type:    string(act.Code.Hash()[2:]),
+			}
+
+			if act.IsStorageMinerActor() {
+				pow, err := api.StateMinerPower(ctx, addr, tsk)
+				if err != nil {
+					return xerrors.Errorf("failed to get power: %w", err)
+				}
+
+				ai.Power = pow.MinerPower.RawBytePower
+				info, err := api.StateMinerInfo(ctx, addr, tsk)
+				if err != nil {
+					return xerrors.Errorf("failed to get miner info: %w", err)
+				}
+				ai.Worker = info.Worker
+				ai.Owner = info.Owner
+
+			}
+			infos = append(infos, ai)
+		}
+
+		fmt.Printf("Address,Balance,Type,Power,Worker,Owner\n")
+		for _, acc := range infos {
+			fmt.Printf("%s,%s,%s,%s,%s,%s\n", acc.Address, acc.Balance, acc.Type, acc.Power, acc.Worker, acc.Owner)
+		}
+		return nil
+	},
+}
+
+var chainBalanceStateCmd = &cli.Command{
+	Name:        "stateroot-balances",
+	Description: "Produces a csv file of all account balances from a given stateroot",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:  "repo",
+			Value: "~/.lotus",
+		},
+		&cli.BoolFlag{
+			Name: "miner-info",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		ctx := context.TODO()
+
+		if !cctx.Args().Present() {
+			return fmt.Errorf("must pass state root")
+		}
+
+		sroot, err := cid.Decode(cctx.Args().First())
+		if err != nil {
+			return fmt.Errorf("failed to parse input: %w", err)
+		}
+
+		fsrepo, err := repo.NewFS(cctx.String("repo"))
+		if err != nil {
+			return err
+		}
+
+		lkrepo, err := fsrepo.Lock(repo.FullNode)
+		if err != nil {
+			return err
+		}
+
+		defer lkrepo.Close() //nolint:errcheck
+
+		ds, err := lkrepo.Datastore("/chain")
+		if err != nil {
+			return err
+		}
+
+		mds, err := lkrepo.Datastore("/metadata")
+		if err != nil {
+			return err
+		}
+
+		bs := blockstore.NewBlockstore(ds)
+
+		cs := store.NewChainStore(bs, mds, vm.Syscalls(ffiwrapper.ProofVerifier))
+
+		cst := cbor.NewCborStore(bs)
+		store := adt.WrapStore(ctx, cst)
+
+		sm := stmgr.NewStateManager(cs)
+
+		tree, err := state.LoadStateTree(cst, sroot)
+		if err != nil {
+			return err
+		}
+
+		minerInfo := cctx.Bool("miner-info")
+
+		var infos []accountInfo
+		err = tree.ForEach(func(addr address.Address, act *types.Actor) error {
+
+			ai := accountInfo{
+				Address:       addr,
+				Balance:       types.FIL(act.Balance),
+				Type:          string(act.Code.Hash()[2:]),
+				Power:         big.NewInt(0),
+				LockedFunds:   types.FIL(big.NewInt(0)),
+				InitialPledge: types.FIL(big.NewInt(0)),
+				PreCommits:    types.FIL(big.NewInt(0)),
+			}
+
+			if minerInfo && act.IsStorageMinerActor() {
+				pow, _, _, err := stmgr.GetPowerRaw(ctx, sm, sroot, addr)
+				if err != nil {
+					return xerrors.Errorf("failed to get power: %w", err)
+				}
+
+				ai.Power = pow.RawBytePower
+
+				st, err := miner.Load(store, act)
+				if err != nil {
+					return xerrors.Errorf("failed to read miner state: %w", err)
+				}
+
+				liveSectorCount, err := st.NumLiveSectors()
+				if err != nil {
+					return xerrors.Errorf("failed to compute live sector count: %w", err)
+				}
+
+				lockedFunds, err := st.LockedFunds()
+				if err != nil {
+					return xerrors.Errorf("failed to compute locked funds: %w", err)
+				}
+
+				ai.InitialPledge = types.FIL(lockedFunds.InitialPledgeRequirement)
+				ai.LockedFunds = types.FIL(lockedFunds.VestingFunds)
+				ai.PreCommits = types.FIL(lockedFunds.PreCommitDeposits)
+				ai.Sectors = liveSectorCount
+
+				minfo, err := st.Info()
+				if err != nil {
+					return xerrors.Errorf("failed to get miner info: %w", err)
+				}
+
+				ai.Worker = minfo.Worker
+				ai.Owner = minfo.Owner
+			}
+			infos = append(infos, ai)
+			return nil
+		})
+		if err != nil {
+			return xerrors.Errorf("failed to loop over actors: %w", err)
+		}
+
+		if minerInfo {
+			fmt.Printf("Address,Balance,Type,Sectors,Worker,Owner,InitialPledge,Locked,PreCommits\n")
+			for _, acc := range infos {
+				fmt.Printf("%s,%s,%s,%d,%s,%s,%s,%s,%s\n", acc.Address, acc.Balance, acc.Type, acc.Sectors, acc.Worker, acc.Owner, acc.InitialPledge, acc.LockedFunds, acc.PreCommits)
+			}
+		} else {
+			fmt.Printf("Address,Balance,Type\n")
+			for _, acc := range infos {
+				fmt.Printf("%s,%s,%s\n", acc.Address, acc.Balance, acc.Type)
+			}
+		}
+
+		return nil
+	},
+}
+
+var chainPledgeCmd = &cli.Command{
+	Name:        "stateroot-pledge",
+	Description: "Calculate sector pledge numbers",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:  "repo",
+			Value: "~/.lotus",
+		},
+	},
+	ArgsUsage: "[stateroot epoch]",
+	Action: func(cctx *cli.Context) error {
+		logging.SetLogLevel("badger", "ERROR")
+		ctx := context.TODO()
+
+		if !cctx.Args().Present() {
+			return fmt.Errorf("must pass state root")
+		}
+
+		sroot, err := cid.Decode(cctx.Args().First())
+		if err != nil {
+			return fmt.Errorf("failed to parse input: %w", err)
+		}
+
+		epoch, err := strconv.ParseInt(cctx.Args().Get(1), 10, 64)
+		if err != nil {
+			return xerrors.Errorf("parsing epoch arg: %w", err)
+		}
+
+		fsrepo, err := repo.NewFS(cctx.String("repo"))
+		if err != nil {
+			return err
+		}
+
+		lkrepo, err := fsrepo.Lock(repo.FullNode)
+		if err != nil {
+			return err
+		}
+
+		defer lkrepo.Close() //nolint:errcheck
+
+		ds, err := lkrepo.Datastore("/chain")
+		if err != nil {
+			return err
+		}
+
+		mds, err := lkrepo.Datastore("/metadata")
+		if err != nil {
+			return err
+		}
+
+		bs := blockstore.NewBlockstore(ds)
+
+		cs := store.NewChainStore(bs, mds, vm.Syscalls(ffiwrapper.ProofVerifier))
+
+		cst := cbor.NewCborStore(bs)
+		store := adt.WrapStore(ctx, cst)
+
+		sm := stmgr.NewStateManager(cs)
+
+		state, err := state.LoadStateTree(cst, sroot)
+		if err != nil {
+			return err
+		}
+
+		var (
+			powerSmoothed    lotusbuiltin.FilterEstimate
+			pledgeCollateral abi.TokenAmount
+		)
+		if act, err := state.GetActor(power.Address); err != nil {
+			return xerrors.Errorf("loading miner actor: %w", err)
+		} else if s, err := power.Load(store, act); err != nil {
+			return xerrors.Errorf("loading power actor state: %w", err)
+		} else if p, err := s.TotalPowerSmoothed(); err != nil {
+			return xerrors.Errorf("failed to determine total power: %w", err)
+		} else if c, err := s.TotalLocked(); err != nil {
+			return xerrors.Errorf("failed to determine pledge collateral: %w", err)
+		} else {
+			powerSmoothed = p
+			pledgeCollateral = c
+		}
+
+		circ, err := sm.GetCirculatingSupplyDetailed(ctx, abi.ChainEpoch(epoch), state)
+		if err != nil {
+			return err
+		}
+
+		fmt.Println("(real) circulating supply: ", types.FIL(circ.FilCirculating))
+		if circ.FilCirculating.LessThan(big.Zero()) {
+			circ.FilCirculating = big.Zero()
+		}
+
+		rewardActor, err := state.GetActor(reward.Address)
+		if err != nil {
+			return xerrors.Errorf("loading miner actor: %w", err)
+		}
+
+		rewardState, err := reward.Load(store, rewardActor)
+		if err != nil {
+			return xerrors.Errorf("loading reward actor state: %w", err)
+		}
+
+		fmt.Println("FilVested", types.FIL(circ.FilVested))
+		fmt.Println("FilMined", types.FIL(circ.FilMined))
+		fmt.Println("FilBurnt", types.FIL(circ.FilBurnt))
+		fmt.Println("FilLocked", types.FIL(circ.FilLocked))
+		fmt.Println("FilCirculating", types.FIL(circ.FilCirculating))
+
+		for _, sectorWeight := range []abi.StoragePower{
+			types.NewInt(32 << 30),
+			types.NewInt(64 << 30),
+			types.NewInt(32 << 30 * 10),
+			types.NewInt(64 << 30 * 10),
+		} {
+			initialPledge, err := rewardState.InitialPledgeForPower(
+				sectorWeight,
+				pledgeCollateral,
+				&powerSmoothed,
+				circ.FilCirculating,
+			)
+			if err != nil {
+				return xerrors.Errorf("calculating initial pledge: %w", err)
+			}
+
+			fmt.Println("IP ", units.HumanSize(float64(sectorWeight.Uint64())), types.FIL(initialPledge))
+		}
+
+		return nil
+	},
+}
diff --git a/cmd/lotus-shed/base16.go b/cmd/lotus-shed/base16.go
index e1b5a6502..adfdfeddb 100644
--- a/cmd/lotus-shed/base16.go
+++ b/cmd/lotus-shed/base16.go
@@ -8,7 +8,7 @@ import (
 	"os"
 	"strings"
 
-	"gopkg.in/urfave/cli.v2"
+	"github.com/urfave/cli/v2"
 )
 
 var base16Cmd = &cli.Command{
diff --git a/cmd/lotus-shed/base32.go b/cmd/lotus-shed/base32.go
index ff7fab858..cd30a2146 100644
--- a/cmd/lotus-shed/base32.go
+++ b/cmd/lotus-shed/base32.go
@@ -7,7 +7,7 @@ import (
 	"os"
 	"strings"
 
-	"gopkg.in/urfave/cli.v2"
+	"github.com/urfave/cli/v2"
 
 	"github.com/multiformats/go-base32"
 )
diff --git a/cmd/lotus-shed/bigint.go b/cmd/lotus-shed/bigint.go
new file mode 100644
index 000000000..e087a341a
--- /dev/null
+++ b/cmd/lotus-shed/bigint.go
@@ -0,0 +1,47 @@
+package main
+
+import (
+	"encoding/base64"
+	"encoding/hex"
+	"fmt"
+
+	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/urfave/cli/v2"
+)
+
+var bigIntParseCmd = &cli.Command{
+	Name:        "bigint",
+	Description: "parse encoded big ints",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:  "enc",
+			Value: "base64",
+			Usage: "specify input encoding to parse",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		val := cctx.Args().Get(0)
+
+		var dec []byte
+		switch cctx.String("enc") {
+		case "base64":
+			d, err := base64.StdEncoding.DecodeString(val)
+			if err != nil {
+				return fmt.Errorf("decoding base64 value: %w", err)
+			}
+			dec = d
+		case "hex":
+			d, err := hex.DecodeString(val)
+			if err != nil {
+				return fmt.Errorf("decoding hex value: %w", err)
+			}
+			dec = d
+		default:
+			return fmt.Errorf("unrecognized encoding: %s", cctx.String("enc"))
+		}
+
+		iv := types.BigFromBytes(dec)
+		fmt.Println(iv.String())
+		return nil
+	},
+}
diff --git a/cmd/lotus-shed/bitfield.go b/cmd/lotus-shed/bitfield.go
new file mode 100644
index 000000000..442cbef48
--- /dev/null
+++ b/cmd/lotus-shed/bitfield.go
@@ -0,0 +1,387 @@
+package main
+
+import (
+	"encoding/base64"
+	"encoding/hex"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"os"
+
+	"github.com/urfave/cli/v2"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-bitfield"
+	rlepluslazy "github.com/filecoin-project/go-bitfield/rle"
+)
+
+var bitFieldCmd = &cli.Command{
+	Name:        "bitfield",
+	Description: "analyze bitfields",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:  "enc",
+			Value: "base64",
+			Usage: "specify input encoding to parse",
+		},
+	},
+	Subcommands: []*cli.Command{
+		bitFieldRunsCmd,
+		bitFieldStatCmd,
+		bitFieldDecodeCmd,
+		bitFieldIntersectCmd,
+		bitFieldEncodeCmd,
+		bitFieldSubCmd,
+	},
+}
+
+var bitFieldRunsCmd = &cli.Command{
+	Name:        "runs",
+	Description: "print bit runs in a bitfield",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:  "enc",
+			Value: "base64",
+			Usage: "specify input encoding to parse",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		var val string
+		if cctx.Args().Present() {
+			val = cctx.Args().Get(0)
+		} else {
+			b, err := ioutil.ReadAll(os.Stdin)
+			if err != nil {
+				return err
+			}
+			val = string(b)
+		}
+
+		var dec []byte
+		switch cctx.String("enc") {
+		case "base64":
+			d, err := base64.StdEncoding.DecodeString(val)
+			if err != nil {
+				return fmt.Errorf("decoding base64 value: %w", err)
+			}
+			dec = d
+		case "hex":
+			d, err := hex.DecodeString(val)
+			if err != nil {
+				return fmt.Errorf("decoding hex value: %w", err)
+			}
+			dec = d
+		default:
+			return fmt.Errorf("unrecognized encoding: %s", cctx.String("enc"))
+		}
+
+		rle, err := rlepluslazy.FromBuf(dec)
+		if err != nil {
+			return xerrors.Errorf("opening rle: %w", err)
+		}
+
+		rit, err := rle.RunIterator()
+		if err != nil {
+			return xerrors.Errorf("getting run iterator: %w", err)
+		}
+		var idx uint64
+		for rit.HasNext() {
+			r, err := rit.NextRun()
+			if err != nil {
+				return xerrors.Errorf("next run: %w", err)
+			}
+			if !r.Valid() {
+				fmt.Print("!INVALID ")
+			}
+			s := "TRUE "
+			if !r.Val {
+				s = "FALSE"
+			}
+
+			fmt.Printf("@%d %s * %d\n", idx, s, r.Len)
+
+			idx += r.Len
+		}
+
+		return nil
+	},
+}
+
+var bitFieldStatCmd = &cli.Command{
+	Name:        "stat",
+	Description: "print bitfield stats",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:  "enc",
+			Value: "base64",
+			Usage: "specify input encoding to parse",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		var val string
+		if cctx.Args().Present() {
+			val = cctx.Args().Get(0)
+		} else {
+			b, err := ioutil.ReadAll(os.Stdin)
+			if err != nil {
+				return err
+			}
+			val = string(b)
+		}
+
+		var dec []byte
+		switch cctx.String("enc") {
+		case "base64":
+			d, err := base64.StdEncoding.DecodeString(val)
+			if err != nil {
+				return fmt.Errorf("decoding base64 value: %w", err)
+			}
+			dec = d
+		case "hex":
+			d, err := hex.DecodeString(val)
+			if err != nil {
+				return fmt.Errorf("decoding hex value: %w", err)
+			}
+			dec = d
+		default:
+			return fmt.Errorf("unrecognized encoding: %s", cctx.String("enc"))
+		}
+
+		rle, err := rlepluslazy.FromBuf(dec)
+		if err != nil {
+			return xerrors.Errorf("opening rle: %w", err)
+		}
+
+		rit, err := rle.RunIterator()
+		if err != nil {
+			return xerrors.Errorf("getting run iterator: %w", err)
+		}
+
+		fmt.Printf("Raw length: %d bits (%d bytes)\n", len(dec)*8, len(dec))
+
+		var ones, zeros, oneRuns, zeroRuns, invalid uint64
+
+		for rit.HasNext() {
+			r, err := rit.NextRun()
+			if err != nil {
+				return xerrors.Errorf("next run: %w", err)
+			}
+			if !r.Valid() {
+				invalid++
+			}
+			if r.Val {
+				ones += r.Len
+				oneRuns++
+			} else {
+				zeros += r.Len
+				zeroRuns++
+			}
+		}
+
+		if _, err := rle.Count(); err != nil { // check overflows
+			fmt.Println("Error: ", err)
+		}
+
+		fmt.Printf("Decoded length: %d bits\n", ones+zeros)
+		fmt.Printf("\tOnes:  %d\n", ones)
+		fmt.Printf("\tZeros: %d\n", zeros)
+		fmt.Printf("Runs: %d\n", oneRuns+zeroRuns)
+		fmt.Printf("\tOne Runs:  %d\n", oneRuns)
+		fmt.Printf("\tZero Runs: %d\n", zeroRuns)
+		fmt.Printf("Invalid runs: %d\n", invalid)
+		return nil
+	},
+}
+
+var bitFieldDecodeCmd = &cli.Command{
+	Name:        "decode",
+	Description: "decode bitfield and print all numbers in it",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:  "enc",
+			Value: "base64",
+			Usage: "specify input encoding to parse",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		rle, err := decode(cctx, 0)
+		if err != nil {
+			return err
+		}
+
+		vals, err := rle.All(100000000000)
+		if err != nil {
+			return xerrors.Errorf("getting all items: %w", err)
+		}
+		fmt.Println(vals)
+
+		return nil
+	},
+}
+
+var bitFieldIntersectCmd = &cli.Command{
+	Name:        "intersect",
+	Description: "intersect 2 bitfields and print the resulting bitfield as base64",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:  "enc",
+			Value: "base64",
+			Usage: "specify input encoding to parse",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		b, err := decode(cctx, 1)
+		if err != nil {
+			return err
+		}
+
+		a, err := decode(cctx, 0)
+		if err != nil {
+			return err
+		}
+
+		o, err := bitfield.IntersectBitField(a, b)
+		if err != nil {
+			return xerrors.Errorf("intersect: %w", err)
+		}
+
+		s, err := o.RunIterator()
+		if err != nil {
+			return err
+		}
+
+		bytes, err := rlepluslazy.EncodeRuns(s, []byte{})
+		if err != nil {
+			return err
+		}
+
+		fmt.Println(base64.StdEncoding.EncodeToString(bytes))
+
+		return nil
+	},
+}
+
+var bitFieldSubCmd = &cli.Command{
+	Name:        "sub",
+	Description: "subtract 2 bitfields and print the resulting bitfield as base64",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:  "enc",
+			Value: "base64",
+			Usage: "specify input encoding to parse",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		b, err := decode(cctx, 1)
+		if err != nil {
+			return err
+		}
+
+		a, err := decode(cctx, 0)
+		if err != nil {
+			return err
+		}
+
+		o, err := bitfield.SubtractBitField(a, b)
+		if err != nil {
+			return xerrors.Errorf("intersect: %w", err)
+		}
+
+		s, err := o.RunIterator()
+		if err != nil {
+			return err
+		}
+
+		bytes, err := rlepluslazy.EncodeRuns(s, []byte{})
+		if err != nil {
+			return err
+		}
+
+		fmt.Println(base64.StdEncoding.EncodeToString(bytes))
+
+		return nil
+	},
+}
+
+var bitFieldEncodeCmd = &cli.Command{
+	Name:        "encode",
+	Description: "encode a series of decimal numbers into a bitfield",
+	ArgsUsage:   "[infile]",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:  "enc",
+			Value: "base64",
+			Usage: "specify input encoding to parse",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		f, err := os.Open(cctx.Args().First())
+		if err != nil {
+			return err
+		}
+		defer f.Close() // nolint
+
+		out := bitfield.New()
+		for {
+			var i uint64
+			_, err := fmt.Fscan(f, &i)
+			if err == io.EOF {
+				break
+			}
+			out.Set(i)
+		}
+
+		s, err := out.RunIterator()
+		if err != nil {
+			return err
+		}
+
+		bytes, err := rlepluslazy.EncodeRuns(s, []byte{})
+		if err != nil {
+			return err
+		}
+
+		fmt.Println(base64.StdEncoding.EncodeToString(bytes))
+
+		return nil
+	},
+}
+
+func decode(cctx *cli.Context, a int) (bitfield.BitField, error) {
+	var val string
+	if cctx.Args().Present() {
+		if a >= cctx.NArg() {
+			return bitfield.BitField{}, xerrors.Errorf("need more than %d args", a)
+		}
+		val = cctx.Args().Get(a)
+	} else {
+		if a > 0 {
+			return bitfield.BitField{}, xerrors.Errorf("need more than %d args", a)
+		}
+		b, err := ioutil.ReadAll(os.Stdin)
+		if err != nil {
+			return bitfield.BitField{}, err
+		}
+		val = string(b)
+	}
+
+	var dec []byte
+	switch cctx.String("enc") {
+	case "base64":
+		d, err := base64.StdEncoding.DecodeString(val)
+		if err != nil {
+			return bitfield.BitField{}, fmt.Errorf("decoding base64 value: %w", err)
+		}
+		dec = d
+	case "hex":
+		d, err := hex.DecodeString(val)
+		if err != nil {
+			return bitfield.BitField{}, fmt.Errorf("decoding hex value: %w", err)
+		}
+		dec = d
+	default:
+		return bitfield.BitField{}, fmt.Errorf("unrecognized encoding: %s", cctx.String("enc"))
+	}
+
+	return bitfield.NewFromBytes(dec)
+}
diff --git a/cmd/lotus-shed/commp.go b/cmd/lotus-shed/commp.go
new file mode 100644
index 000000000..9b0cab75d
--- /dev/null
+++ b/cmd/lotus-shed/commp.go
@@ -0,0 +1,27 @@
+package main
+
+import (
+	"encoding/hex"
+	"fmt"
+
+	commcid "github.com/filecoin-project/go-fil-commcid"
+	"github.com/urfave/cli/v2"
+)
+
+var commpToCidCmd = &cli.Command{
+	Name:        "commp-to-cid",
+	Description: "Convert a raw commP to a piece-Cid",
+	Action: func(cctx *cli.Context) error {
+		if !cctx.Args().Present() {
+			return fmt.Errorf("must specify commP to convert")
+		}
+
+		dec, err := hex.DecodeString(cctx.Args().First())
+		if err != nil {
+			return fmt.Errorf("failed to decode input as hex string: %w", err)
+		}
+
+		fmt.Println(commcid.PieceCommitmentV1ToCID(dec))
+		return nil
+	},
+}
diff --git a/cmd/lotus-shed/consensus.go b/cmd/lotus-shed/consensus.go
new file mode 100644
index 000000000..59d9555df
--- /dev/null
+++ b/cmd/lotus-shed/consensus.go
@@ -0,0 +1,286 @@
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"io"
+	"os"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/api/client"
+	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/types"
+	lcli "github.com/filecoin-project/lotus/cli"
+	"github.com/libp2p/go-libp2p-core/peer"
+	"github.com/multiformats/go-multiaddr"
+	"github.com/urfave/cli/v2"
+)
+
+var consensusCmd = &cli.Command{
+	Name:  "consensus",
+	Usage: "tools for gathering information about consensus between nodes",
+	Flags: []cli.Flag{},
+	Subcommands: []*cli.Command{
+		consensusCheckCmd,
+	},
+}
+
+type consensusItem struct {
+	multiaddr     multiaddr.Multiaddr
+	genesisTipset *types.TipSet
+	targetTipset  *types.TipSet
+	headTipset    *types.TipSet
+	peerID        peer.ID
+	version       api.Version
+	api           api.FullNode
+}
+
+var consensusCheckCmd = &cli.Command{
+	Name:  "check",
+	Usage: "verify if all nodes agree upon a common tipset for a given tipset height",
+	Description: `Consensus check verifies that all nodes share a common tipset for a given
+   height.
+
+   The height flag specifies a chain height to start a comparison from. There are two special
+   arguments for this flag. All other expected values should be chain tipset heights.
+
+   @common   - Use the maximum common chain height between all nodes
+   @expected - Use the current time and the genesis timestamp to determine a height
+
+   Examples
+
+   Find the highest common tipset and look back 10 tipsets
+   lotus-shed consensus check --height @common --lookback 10
+
+   Calculate the expected tipset height and look back 10 tipsets
+   lotus-shed consensus check --height @expected --lookback 10
+
+   Check if nodes all share a common genesis
+   lotus-shed consensus check --height 0
+
+   Check that all nodes agree upon the tipset for 1day post genesis
+   lotus-shed consensus check --height 2880 --lookback 0
+	`,
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:  "height",
+			Value: "@common",
+			Usage: "height of tipset to start check from",
+		},
+		&cli.IntFlag{
+			Name:  "lookback",
+			Value: int(build.MessageConfidence * 2),
+			Usage: "number of tipsets behind to look back when comparing nodes",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		filePath := cctx.Args().First()
+
+		var input *bufio.Reader
+		if cctx.Args().Len() == 0 {
+			input = bufio.NewReader(os.Stdin)
+		} else {
+			var err error
+			inputFile, err := os.Open(filePath)
+			if err != nil {
+				return err
+			}
+			defer inputFile.Close() //nolint:errcheck
+			input = bufio.NewReader(inputFile)
+		}
+
+		var nodes []*consensusItem
+		ctx := lcli.ReqContext(cctx)
+
+		for {
+			strma, errR := input.ReadString('\n')
+			strma = strings.TrimSpace(strma)
+
+			if len(strma) == 0 {
+				if errR == io.EOF {
+					break
+				}
+				continue
+			}
+
+			apima, err := multiaddr.NewMultiaddr(strma)
+			if err != nil {
+				return err
+			}
+			ainfo := lcli.APIInfo{Addr: apima}
+			addr, err := ainfo.DialArgs()
+			if err != nil {
+				return err
+			}
+
+			api, closer, err := client.NewFullNodeRPC(cctx.Context, addr, nil)
+			if err != nil {
+				return err
+			}
+			defer closer()
+
+			peerID, err := api.ID(ctx)
+			if err != nil {
+				return err
+			}
+
+			version, err := api.Version(ctx)
+			if err != nil {
+				return err
+			}
+
+			genesisTipset, err := api.ChainGetGenesis(ctx)
+			if err != nil {
+				return err
+			}
+
+			headTipset, err := api.ChainHead(ctx)
+			if err != nil {
+				return err
+			}
+
+			nodes = append(nodes, &consensusItem{
+				genesisTipset: genesisTipset,
+				headTipset:    headTipset,
+				multiaddr:     apima,
+				api:           api,
+				peerID:        peerID,
+				version:       version,
+			})
+
+			if errR != nil && errR != io.EOF {
+				return err
+			}
+
+			if errR == io.EOF {
+				break
+			}
+		}
+
+		if len(nodes) == 0 {
+			return fmt.Errorf("no nodes")
+		}
+
+		genesisBuckets := make(map[types.TipSetKey][]*consensusItem)
+		for _, node := range nodes {
+			genesisBuckets[node.genesisTipset.Key()] = append(genesisBuckets[node.genesisTipset.Key()], node)
+
+		}
+
+		if len(genesisBuckets) != 1 {
+			for _, nodes := range genesisBuckets {
+				for _, node := range nodes {
+					log.Errorw(
+						"genesis do not match",
+						"genesis_tipset", node.genesisTipset.Key(),
+						"peer_id", node.peerID,
+						"version", node.version,
+					)
+				}
+			}
+
+			return fmt.Errorf("genesis does not match between all nodes")
+		}
+
+		target := abi.ChainEpoch(0)
+
+		switch cctx.String("height") {
+		case "@common":
+			minTipset := nodes[0].headTipset
+			for _, node := range nodes {
+				if node.headTipset.Height() < minTipset.Height() {
+					minTipset = node.headTipset
+				}
+			}
+
+			target = minTipset.Height()
+		case "@expected":
+			tnow := uint64(time.Now().Unix())
+			tgen := nodes[0].genesisTipset.MinTimestamp()
+
+			target = abi.ChainEpoch((tnow - tgen) / build.BlockDelaySecs)
+		default:
+			h, err := strconv.Atoi(strings.TrimSpace(cctx.String("height")))
+			if err != nil {
+				return fmt.Errorf("failed to parse string: %s", cctx.String("height"))
+			}
+
+			target = abi.ChainEpoch(h)
+		}
+
+		lookback := abi.ChainEpoch(cctx.Int("lookback"))
+		if lookback > target {
+			target = abi.ChainEpoch(0)
+		} else {
+			target = target - lookback
+		}
+
+		for _, node := range nodes {
+			targetTipset, err := node.api.ChainGetTipSetByHeight(ctx, target, types.EmptyTSK)
+			if err != nil {
+				log.Errorw("error checking target", "err", err)
+				node.targetTipset = nil
+			} else {
+				node.targetTipset = targetTipset
+			}
+
+		}
+		for _, node := range nodes {
+			log.Debugw(
+				"node info",
+				"peer_id", node.peerID,
+				"version", node.version,
+				"genesis_tipset", node.genesisTipset.Key(),
+				"head_tipset", node.headTipset.Key(),
+				"target_tipset", node.targetTipset.Key(),
+			)
+		}
+
+		targetBuckets := make(map[types.TipSetKey][]*consensusItem)
+		for _, node := range nodes {
+			if node.targetTipset == nil {
+				targetBuckets[types.EmptyTSK] = append(targetBuckets[types.EmptyTSK], node)
+				continue
+			}
+
+			targetBuckets[node.targetTipset.Key()] = append(targetBuckets[node.targetTipset.Key()], node)
+		}
+
+		if nodes, ok := targetBuckets[types.EmptyTSK]; ok {
+			for _, node := range nodes {
+				log.Errorw(
+					"targeted tipset not found",
+					"peer_id", node.peerID,
+					"version", node.version,
+					"genesis_tipset", node.genesisTipset.Key(),
+					"head_tipset", node.headTipset.Key(),
+					"target_tipset", node.targetTipset.Key(),
+				)
+			}
+
+			return fmt.Errorf("targeted tipset not found")
+		}
+
+		if len(targetBuckets) != 1 {
+			for _, nodes := range targetBuckets {
+				for _, node := range nodes {
+					log.Errorw(
+						"targeted tipset not found",
+						"peer_id", node.peerID,
+						"version", node.version,
+						"genesis_tipset", node.genesisTipset.Key(),
+						"head_tipset", node.headTipset.Key(),
+						"target_tipset", node.targetTipset.Key(),
+					)
+				}
+			}
+			return fmt.Errorf("nodes not in consensus at tipset height %d", target)
+		}
+
+		return nil
+	},
+}
diff --git a/cmd/lotus-shed/dealtracker.go b/cmd/lotus-shed/dealtracker.go
new file mode 100644
index 000000000..d39f51bd1
--- /dev/null
+++ b/cmd/lotus-shed/dealtracker.go
@@ -0,0 +1,265 @@
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"net"
+	"net/http"
+	"os"
+	"strings"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/lotus/api"
+	lcli "github.com/filecoin-project/lotus/cli"
+	"github.com/ipfs/go-cid"
+	"github.com/urfave/cli/v2"
+)
+
+type dealStatsServer struct {
+	api api.FullNode
+}
+
+var filteredClients map[address.Address]bool
+
+func init() {
+	fc := []string{"t0112", "t0113", "t0114", "t010089"}
+
+	filtered, set := os.LookupEnv("FILTERED_CLIENTS")
+	if set {
+		fc = strings.Split(filtered, ":")
+	}
+
+	filteredClients = make(map[address.Address]bool)
+	for _, a := range fc {
+		addr, err := address.NewFromString(a)
+		if err != nil {
+			panic(err)
+		}
+		filteredClients[addr] = true
+	}
+}
+
+type dealCountResp struct {
+	Total int64 `json:"total"`
+	Epoch int64 `json:"epoch"`
+}
+
+func (dss *dealStatsServer) handleStorageDealCount(w http.ResponseWriter, r *http.Request) {
+	ctx := context.Background()
+
+	head, err := dss.api.ChainHead(ctx)
+	if err != nil {
+		log.Warnf("failed to get chain head: %s", err)
+		w.WriteHeader(500)
+		return
+	}
+
+	deals, err := dss.api.StateMarketDeals(ctx, head.Key())
+	if err != nil {
+		log.Warnf("failed to get market deals: %s", err)
+		w.WriteHeader(500)
+		return
+	}
+
+	var count int64
+	for _, d := range deals {
+		if !filteredClients[d.Proposal.Client] {
+			count++
+		}
+	}
+
+	if err := json.NewEncoder(w).Encode(&dealCountResp{
+		Total: count,
+		Epoch: int64(head.Height()),
+	}); err != nil {
+		log.Warnf("failed to write back deal count response: %s", err)
+		return
+	}
+}
+
+type dealAverageResp struct {
+	AverageSize int64 `json:"average_size"`
+	Epoch       int64 `json:"epoch"`
+}
+
+func (dss *dealStatsServer) handleStorageDealAverageSize(w http.ResponseWriter, r *http.Request) {
+	ctx := context.Background()
+
+	head, err := dss.api.ChainHead(ctx)
+	if err != nil {
+		log.Warnf("failed to get chain head: %s", err)
+		w.WriteHeader(500)
+		return
+	}
+
+	deals, err := dss.api.StateMarketDeals(ctx, head.Key())
+	if err != nil {
+		log.Warnf("failed to get market deals: %s", err)
+		w.WriteHeader(500)
+		return
+	}
+
+	var count int64
+	var totalBytes int64
+	for _, d := range deals {
+		if !filteredClients[d.Proposal.Client] {
+			count++
+			totalBytes += int64(d.Proposal.PieceSize.Unpadded())
+		}
+	}
+
+	if err := json.NewEncoder(w).Encode(&dealAverageResp{
+		AverageSize: totalBytes / count,
+		Epoch:       int64(head.Height()),
+	}); err != nil {
+		log.Warnf("failed to write back deal average response: %s", err)
+		return
+	}
+}
+
+type dealTotalResp struct {
+	TotalBytes int64 `json:"total_size"`
+	Epoch      int64 `json:"epoch"`
+}
+
+func (dss *dealStatsServer) handleStorageDealTotalReal(w http.ResponseWriter, r *http.Request) {
+	ctx := context.Background()
+
+	head, err := dss.api.ChainHead(ctx)
+	if err != nil {
+		log.Warnf("failed to get chain head: %s", err)
+		w.WriteHeader(500)
+		return
+	}
+
+	deals, err := dss.api.StateMarketDeals(ctx, head.Key())
+	if err != nil {
+		log.Warnf("failed to get market deals: %s", err)
+		w.WriteHeader(500)
+		return
+	}
+
+	var totalBytes int64
+	for _, d := range deals {
+		if !filteredClients[d.Proposal.Client] {
+			totalBytes += int64(d.Proposal.PieceSize.Unpadded())
+		}
+	}
+
+	if err := json.NewEncoder(w).Encode(&dealTotalResp{
+		TotalBytes: totalBytes,
+		Epoch:      int64(head.Height()),
+	}); err != nil {
+		log.Warnf("failed to write back deal average response: %s", err)
+		return
+	}
+
+}
+
+type clientStatsOutput struct {
+	Client    address.Address `json:"client"`
+	DataSize  int64           `json:"data_size"`
+	NumCids   int             `json:"num_cids"`
+	NumDeals  int             `json:"num_deals"`
+	NumMiners int             `json:"num_miners"`
+
+	cids      map[cid.Cid]bool
+	providers map[address.Address]bool
+}
+
+func (dss *dealStatsServer) handleStorageClientStats(w http.ResponseWriter, r *http.Request) {
+	ctx := context.Background()
+
+	head, err := dss.api.ChainHead(ctx)
+	if err != nil {
+		log.Warnf("failed to get chain head: %s", err)
+		w.WriteHeader(500)
+		return
+	}
+
+	deals, err := dss.api.StateMarketDeals(ctx, head.Key())
+	if err != nil {
+		log.Warnf("failed to get market deals: %s", err)
+		w.WriteHeader(500)
+		return
+	}
+
+	stats := make(map[address.Address]*clientStatsOutput)
+
+	for _, d := range deals {
+		if filteredClients[d.Proposal.Client] {
+			continue
+		}
+
+		st, ok := stats[d.Proposal.Client]
+		if !ok {
+			st = &clientStatsOutput{
+				Client:    d.Proposal.Client,
+				cids:      make(map[cid.Cid]bool),
+				providers: make(map[address.Address]bool),
+			}
+			stats[d.Proposal.Client] = st
+		}
+
+		st.DataSize += int64(d.Proposal.PieceSize.Unpadded())
+		st.cids[d.Proposal.PieceCID] = true
+		st.providers[d.Proposal.Provider] = true
+		st.NumDeals++
+	}
+
+	out := make([]*clientStatsOutput, 0, len(stats))
+	for _, cso := range stats {
+		cso.NumCids = len(cso.cids)
+		cso.NumMiners = len(cso.providers)
+
+		out = append(out, cso)
+	}
+
+	if err := json.NewEncoder(w).Encode(out); err != nil {
+		log.Warnf("failed to write back client stats response: %s", err)
+		return
+	}
+}
+
+var serveDealStatsCmd = &cli.Command{
+	Name:  "serve-deal-stats",
+	Flags: []cli.Flag{},
+	Action: func(cctx *cli.Context) error {
+		api, closer, err := lcli.GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+
+		defer closer()
+		ctx := lcli.ReqContext(cctx)
+
+		_ = ctx
+
+		dss := &dealStatsServer{api}
+
+		mux := &http.ServeMux{}
+		mux.HandleFunc("/api/storagedeal/count", dss.handleStorageDealCount)
+		mux.HandleFunc("/api/storagedeal/averagesize", dss.handleStorageDealAverageSize)
+		mux.HandleFunc("/api/storagedeal/totalreal", dss.handleStorageDealTotalReal)
+		mux.HandleFunc("/api/storagedeal/clientstats", dss.handleStorageClientStats)
+
+		s := &http.Server{
+			Addr:    ":7272",
+			Handler: mux,
+		}
+
+		go func() {
+			<-ctx.Done()
+			if err := s.Shutdown(context.TODO()); err != nil {
+				log.Error(err)
+			}
+		}()
+
+		list, err := net.Listen("tcp", ":7272") // nolint
+		if err != nil {
+			panic(err)
+		}
+
+		return s.Serve(list)
+	},
+}
diff --git a/cmd/lotus-shed/export.go b/cmd/lotus-shed/export.go
new file mode 100644
index 000000000..c12cbd82d
--- /dev/null
+++ b/cmd/lotus-shed/export.go
@@ -0,0 +1,123 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"os"
+
+	"github.com/urfave/cli/v2"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/lotus/chain/store"
+	"github.com/filecoin-project/lotus/chain/types"
+	lcli "github.com/filecoin-project/lotus/cli"
+	"github.com/filecoin-project/lotus/lib/blockstore"
+	"github.com/filecoin-project/lotus/node/repo"
+)
+
+var exportChainCmd = &cli.Command{
+	Name:        "export",
+	Description: "Export chain from repo (requires node to be offline)",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:  "repo",
+			Value: "~/.lotus",
+		},
+		&cli.StringFlag{
+			Name:  "tipset",
+			Usage: "tipset to export from",
+		},
+		&cli.Int64Flag{
+			Name: "recent-stateroots",
+		},
+		&cli.BoolFlag{
+			Name: "full-state",
+		},
+		&cli.BoolFlag{
+			Name: "skip-old-msgs",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		if !cctx.Args().Present() {
+			return lcli.ShowHelp(cctx, fmt.Errorf("must specify file name to write export to"))
+		}
+
+		ctx := context.TODO()
+
+		r, err := repo.NewFS(cctx.String("repo"))
+		if err != nil {
+			return xerrors.Errorf("opening fs repo: %w", err)
+		}
+
+		exists, err := r.Exists()
+		if err != nil {
+			return err
+		}
+		if !exists {
+			return xerrors.Errorf("lotus repo doesn't exist")
+		}
+
+		lr, err := r.Lock(repo.FullNode)
+		if err != nil {
+			return err
+		}
+		defer lr.Close() //nolint:errcheck
+
+		fi, err := os.Create(cctx.Args().First())
+		if err != nil {
+			return xerrors.Errorf("opening the output file: %w", err)
+		}
+
+		defer fi.Close() //nolint:errcheck
+
+		ds, err := lr.Datastore("/chain")
+		if err != nil {
+			return err
+		}
+
+		mds, err := lr.Datastore("/metadata")
+		if err != nil {
+			return err
+		}
+
+		bs := blockstore.NewBlockstore(ds)
+
+		cs := store.NewChainStore(bs, mds, nil)
+		if err := cs.Load(); err != nil {
+			return err
+		}
+
+		nroots := abi.ChainEpoch(cctx.Int64("recent-stateroots"))
+		fullstate := cctx.Bool("full-state")
+		skipoldmsgs := cctx.Bool("skip-old-msgs")
+
+		var ts *types.TipSet
+		if tss := cctx.String("tipset"); tss != "" {
+			cids, err := lcli.ParseTipSetString(tss)
+			if err != nil {
+				return xerrors.Errorf("failed to parse tipset (%q): %w", tss, err)
+			}
+
+			tsk := types.NewTipSetKey(cids...)
+
+			selts, err := cs.LoadTipSet(tsk)
+			if err != nil {
+				return xerrors.Errorf("loading tipset: %w", err)
+			}
+			ts = selts
+		} else {
+			ts = cs.GetHeaviestTipSet()
+		}
+
+		if fullstate {
+			nroots = ts.Height() + 1
+		}
+
+		if err := cs.Export(ctx, ts, nroots, skipoldmsgs, fi); err != nil {
+			return xerrors.Errorf("export failed: %w", err)
+		}
+
+		return nil
+	},
+}
diff --git a/cmd/lotus-shed/genesis-verify.go b/cmd/lotus-shed/genesis-verify.go
new file mode 100644
index 000000000..da2c82359
--- /dev/null
+++ b/cmd/lotus-shed/genesis-verify.go
@@ -0,0 +1,175 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"sort"
+
+	"github.com/fatih/color"
+	"github.com/ipfs/go-datastore"
+	cbor "github.com/ipfs/go-ipld-cbor"
+	"github.com/urfave/cli/v2"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/big"
+
+	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/actors/adt"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/account"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/multisig"
+	"github.com/filecoin-project/lotus/chain/state"
+	"github.com/filecoin-project/lotus/chain/stmgr"
+	"github.com/filecoin-project/lotus/chain/store"
+	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/lib/blockstore"
+)
+
+type addrInfo struct {
+	Key     address.Address
+	Balance types.FIL
+}
+
+type msigInfo struct {
+	Signers   []address.Address
+	Balance   types.FIL
+	Threshold uint64
+}
+
+type minerInfo struct {
+}
+
+var genesisVerifyCmd = &cli.Command{
+	Name:        "verify-genesis",
+	Description: "verify some basic attributes of a genesis car file",
+	Action: func(cctx *cli.Context) error {
+		if !cctx.Args().Present() {
+			return fmt.Errorf("must pass genesis car file")
+		}
+		bs := blockstore.NewBlockstore(datastore.NewMapDatastore())
+
+		cs := store.NewChainStore(bs, datastore.NewMapDatastore(), nil)
+
+		cf := cctx.Args().Get(0)
+		f, err := os.Open(cf)
+		if err != nil {
+			return xerrors.Errorf("opening the car file: %w", err)
+		}
+
+		ts, err := cs.Import(f)
+		if err != nil {
+			return err
+		}
+
+		sm := stmgr.NewStateManager(cs)
+
+		total, err := stmgr.CheckTotalFIL(context.TODO(), sm, ts)
+		if err != nil {
+			return err
+		}
+
+		fmt.Println("Genesis: ", ts.Key())
+		expFIL := big.Mul(big.NewInt(int64(build.FilBase)), big.NewInt(int64(build.FilecoinPrecision)))
+		fmt.Printf("Total FIL: %s", types.FIL(total))
+		if !expFIL.Equals(total) {
+			color.Red("  INCORRECT!")
+		}
+		fmt.Println()
+
+		cst := cbor.NewCborStore(bs)
+
+		stree, err := state.LoadStateTree(cst, ts.ParentState())
+		if err != nil {
+			return err
+		}
+
+		var accAddrs, msigAddrs []address.Address
+		kaccounts := make(map[address.Address]addrInfo)
+		kmultisigs := make(map[address.Address]msigInfo)
+		kminers := make(map[address.Address]minerInfo)
+
+		ctx := context.TODO()
+		store := adt.WrapStore(ctx, cst)
+
+		if err := stree.ForEach(func(addr address.Address, act *types.Actor) error {
+			switch {
+			case act.IsStorageMinerActor():
+				_, err := miner.Load(store, act)
+				if err != nil {
+					return xerrors.Errorf("miner actor: %w", err)
+				}
+				// TODO: actually verify something here?
+				kminers[addr] = minerInfo{}
+			case act.IsMultisigActor():
+				st, err := multisig.Load(store, act)
+				if err != nil {
+					return xerrors.Errorf("multisig actor: %w", err)
+				}
+
+				signers, err := st.Signers()
+				if err != nil {
+					return xerrors.Errorf("multisig actor: %w", err)
+				}
+				threshold, err := st.Threshold()
+				if err != nil {
+					return xerrors.Errorf("multisig actor: %w", err)
+				}
+
+				kmultisigs[addr] = msigInfo{
+					Balance:   types.FIL(act.Balance),
+					Signers:   signers,
+					Threshold: threshold,
+				}
+				msigAddrs = append(msigAddrs, addr)
+			case act.IsAccountActor():
+				st, err := account.Load(store, act)
+				if err != nil {
+					// TODO: magik6k: this _used_ to log instead of failing, why?
+					return xerrors.Errorf("account actor %s: %w", addr, err)
+				}
+				pkaddr, err := st.PubkeyAddress()
+				if err != nil {
+					return xerrors.Errorf("failed to get actor pk address %s: %w", addr, err)
+				}
+				kaccounts[addr] = addrInfo{
+					Key:     pkaddr,
+					Balance: types.FIL(act.Balance.Copy()),
+				}
+				accAddrs = append(accAddrs, addr)
+			}
+			return nil
+		}); err != nil {
+			return err
+		}
+
+		sort.Slice(accAddrs, func(i, j int) bool {
+			return accAddrs[i].String() < accAddrs[j].String()
+		})
+
+		sort.Slice(msigAddrs, func(i, j int) bool {
+			return msigAddrs[i].String() < msigAddrs[j].String()
+		})
+
+		fmt.Println("Account Actors:")
+		for _, acc := range accAddrs {
+			a := kaccounts[acc]
+			fmt.Printf("%s\t%s\t%s\n", acc, a.Key, a.Balance)
+		}
+
+		fmt.Println("Multisig Actors:")
+		for _, acc := range msigAddrs {
+			m := kmultisigs[acc]
+			fmt.Printf("%s\t%s\t%d\t[", acc, m.Balance, m.Threshold)
+			for i, s := range m.Signers {
+				fmt.Print(s)
+				if i != len(m.Signers)-1 {
+					fmt.Print(",")
+				}
+			}
+			fmt.Printf("]\n")
+		}
+		return nil
+	},
+}
diff --git a/cmd/lotus-shed/import-car.go b/cmd/lotus-shed/import-car.go
new file mode 100644
index 000000000..01343c4a3
--- /dev/null
+++ b/cmd/lotus-shed/import-car.go
@@ -0,0 +1,83 @@
+package main
+
+import (
+	"fmt"
+	"io"
+	"os"
+
+	"github.com/ipld/go-car"
+	"github.com/urfave/cli/v2"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/lotus/lib/blockstore"
+	"github.com/filecoin-project/lotus/node/repo"
+)
+
+var importCarCmd = &cli.Command{
+	Name:        "import-car",
+	Description: "Import a car file into node chain blockstore",
+	Action: func(cctx *cli.Context) error {
+		r, err := repo.NewFS(cctx.String("repo"))
+		if err != nil {
+			return xerrors.Errorf("opening fs repo: %w", err)
+		}
+
+		exists, err := r.Exists()
+		if err != nil {
+			return err
+		}
+		if !exists {
+			return xerrors.Errorf("lotus repo doesn't exist")
+		}
+
+		lr, err := r.Lock(repo.FullNode)
+		if err != nil {
+			return err
+		}
+		defer lr.Close() //nolint:errcheck
+
+		cf := cctx.Args().Get(0)
+		f, err := os.OpenFile(cf, os.O_RDONLY, 0664)
+		if err != nil {
+			return xerrors.Errorf("opening the car file: %w", err)
+		}
+
+		ds, err := lr.Datastore("/chain")
+		if err != nil {
+			return err
+		}
+
+		bs := blockstore.NewBlockstore(ds)
+
+		cr, err := car.NewCarReader(f)
+		if err != nil {
+			return err
+		}
+
+		for {
+			blk, err := cr.Next()
+			switch err {
+			case io.EOF:
+				if err := f.Close(); err != nil {
+					return err
+				}
+				fmt.Println()
+				return ds.Close()
+			default:
+				if err := f.Close(); err != nil {
+					return err
+				}
+				fmt.Println()
+				return err
+			case nil:
+				fmt.Printf("\r%s", blk.Cid())
+				if err := bs.Put(blk); err != nil {
+					if err := f.Close(); err != nil {
+						return err
+					}
+					return xerrors.Errorf("put %s: %w", blk.Cid(), err)
+				}
+			}
+		}
+	},
+}
diff --git a/cmd/lotus-shed/jwt.go b/cmd/lotus-shed/jwt.go
new file mode 100644
index 000000000..7fa1a18dd
--- /dev/null
+++ b/cmd/lotus-shed/jwt.go
@@ -0,0 +1,188 @@
+package main
+
+import (
+	"bufio"
+	"crypto/rand"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"os"
+	"strings"
+
+	"github.com/gbrlsnchs/jwt/v3"
+	"github.com/urfave/cli/v2"
+
+	"github.com/filecoin-project/go-jsonrpc/auth"
+	"github.com/filecoin-project/lotus/api/apistruct"
+	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/node/modules"
+)
+
+var jwtCmd = &cli.Command{
+	Name:  "jwt",
+	Usage: "work with lotus jwt secrets and tokens",
+	Description: `The subcommands of jwt provide helpful tools for working with jwt files without
+   having to run the lotus daemon.`,
+	Subcommands: []*cli.Command{
+		jwtNewCmd,
+		jwtTokenCmd,
+	},
+}
+
+var jwtTokenCmd = &cli.Command{
+	Name:      "token",
+	Usage:     "create a token for a given jwt secret",
+	ArgsUsage: "<name>",
+	Description: `The jwt tokens have four different levels of permissions that provide some ability
+   to control access to what methods can be invoked by the holder of the token.
+
+   This command only works on jwt secrets that are base16 encoded files, such as those produced by the
+   sibling 'new' command.
+	`,
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:  "output",
+			Value: "token",
+			Usage: "specify a name",
+		},
+		&cli.BoolFlag{
+			Name:  "read",
+			Value: false,
+			Usage: "add read permissions to the token",
+		},
+		&cli.BoolFlag{
+			Name:  "write",
+			Value: false,
+			Usage: "add write permissions to the token",
+		},
+		&cli.BoolFlag{
+			Name:  "sign",
+			Value: false,
+			Usage: "add sign permissions to the token",
+		},
+		&cli.BoolFlag{
+			Name:  "admin",
+			Value: false,
+			Usage: "add admin permissions to the token",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		if !cctx.Args().Present() {
+			return fmt.Errorf("please specify a name")
+		}
+
+		inputFile, err := os.Open(cctx.Args().First())
+		if err != nil {
+			return err
+		}
+		defer inputFile.Close() //nolint:errcheck
+		input := bufio.NewReader(inputFile)
+
+		encoded, err := ioutil.ReadAll(input)
+		if err != nil {
+			return err
+		}
+
+		decoded, err := hex.DecodeString(strings.TrimSpace(string(encoded)))
+		if err != nil {
+			return err
+		}
+
+		var keyInfo types.KeyInfo
+		if err := json.Unmarshal(decoded, &keyInfo); err != nil {
+			return err
+		}
+
+		perms := []auth.Permission{}
+
+		if cctx.Bool("read") {
+			perms = append(perms, apistruct.PermRead)
+		}
+
+		if cctx.Bool("write") {
+			perms = append(perms, apistruct.PermWrite)
+		}
+
+		if cctx.Bool("sign") {
+			perms = append(perms, apistruct.PermSign)
+		}
+
+		if cctx.Bool("admin") {
+			perms = append(perms, apistruct.PermAdmin)
+		}
+
+		p := modules.JwtPayload{
+			Allow: perms,
+		}
+
+		token, err := jwt.Sign(&p, jwt.NewHS256(keyInfo.PrivateKey))
+		if err != nil {
+			return err
+		}
+
+		return ioutil.WriteFile(cctx.String("output"), token, 0600)
+	},
+}
+
+var jwtNewCmd = &cli.Command{
+	Name:      "new",
+	Usage:     "create a new jwt secret and token for lotus",
+	ArgsUsage: "<name>",
+	Description: `Jwt tokens are used to authenticate api requests to the lotus daemon.
+
+   The created jwt token have full privileges and should not be shared.`,
+	Flags: []cli.Flag{},
+	Action: func(cctx *cli.Context) error {
+		if !cctx.Args().Present() {
+			return fmt.Errorf("please specify a name")
+		}
+
+		keyName := cctx.Args().First()
+
+		sk, err := ioutil.ReadAll(io.LimitReader(rand.Reader, 32))
+		if err != nil {
+			return err
+		}
+
+		keyInfo := types.KeyInfo{
+			Type:       modules.KTJwtHmacSecret,
+			PrivateKey: sk,
+		}
+
+		p := modules.JwtPayload{
+			Allow: apistruct.AllPermissions,
+		}
+
+		token, err := jwt.Sign(&p, jwt.NewHS256(keyInfo.PrivateKey))
+		if err != nil {
+			return err
+		}
+
+		filename := fmt.Sprintf("jwt-%s.jwts", keyName)
+		file, err := os.OpenFile(filename, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0600)
+		if err != nil {
+			return err
+		}
+
+		defer func() {
+			if err := file.Close(); err != nil {
+				log.Warnf("failed to close output file: %w", err)
+			}
+		}()
+
+		bytes, err := json.Marshal(keyInfo)
+		if err != nil {
+			return err
+		}
+
+		encoded := hex.EncodeToString(bytes)
+		if _, err := file.Write([]byte(encoded)); err != nil {
+			return err
+		}
+
+		filenameToken := fmt.Sprintf("jwt-%s.token", keyName)
+		return ioutil.WriteFile(filenameToken, token, 0600)
+	},
+}
diff --git a/cmd/lotus-shed/keyinfo.go b/cmd/lotus-shed/keyinfo.go
index d3716d576..6090b7a0f 100644
--- a/cmd/lotus-shed/keyinfo.go
+++ b/cmd/lotus-shed/keyinfo.go
@@ -1,84 +1,460 @@
 package main
 
 import (
+	"bufio"
+	"encoding/base64"
 	"encoding/hex"
 	"encoding/json"
+	"fmt"
 	"io"
 	"io/ioutil"
 	"os"
+	"path"
 	"strings"
 	"text/template"
 
-	"gopkg.in/urfave/cli.v2"
+	"github.com/urfave/cli/v2"
+
+	"golang.org/x/xerrors"
+
+	"github.com/multiformats/go-base32"
+
+	"github.com/libp2p/go-libp2p-core/crypto"
+	"github.com/libp2p/go-libp2p-core/peer"
 
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/chain/wallet"
+	"github.com/filecoin-project/lotus/node/modules"
+	"github.com/filecoin-project/lotus/node/modules/lp2p"
+	"github.com/filecoin-project/lotus/node/repo"
+
+	_ "github.com/filecoin-project/lotus/lib/sigs/bls"
+	_ "github.com/filecoin-project/lotus/lib/sigs/secp"
 )
 
-type walletInfo struct {
+var validTypes = []string{wallet.KTBLS, wallet.KTSecp256k1, lp2p.KTLibp2pHost}
+
+type keyInfoOutput struct {
 	Type      string
 	Address   string
 	PublicKey string
 }
 
-func (wi walletInfo) String() string {
-	bs, _ := json.Marshal(wi)
-	return string(bs)
+var keyinfoCmd = &cli.Command{
+	Name:  "keyinfo",
+	Usage: "work with lotus keyinfo files (wallets and libp2p host keys)",
+	Description: `The subcommands of keyinfo provide helpful tools for working with keyinfo files without
+   having to run the lotus daemon.`,
+	Subcommands: []*cli.Command{
+		keyinfoNewCmd,
+		keyinfoInfoCmd,
+		keyinfoImportCmd,
+		keyinfoVerifyCmd,
+	},
 }
 
-var keyinfoCmd = &cli.Command{
-	Name:        "keyinfo",
-	Description: "decode a keyinfo",
+var keyinfoVerifyCmd = &cli.Command{
+	Name:  "verify",
+	Usage: "verify the filename of a keystore object on disk with it's contents",
+	Description: `Keystore objects are base32 enocded strings, with wallets being dynamically named via
+   the wallet address. This command can ensure that the naming of these keystore objects are correct`,
+	Action: func(cctx *cli.Context) error {
+		filePath := cctx.Args().First()
+		fileName := path.Base(filePath)
+
+		inputFile, err := os.Open(filePath)
+		if err != nil {
+			return err
+		}
+		defer inputFile.Close() //nolint:errcheck
+		input := bufio.NewReader(inputFile)
+
+		keyContent, err := ioutil.ReadAll(input)
+		if err != nil {
+			return err
+		}
+
+		var keyInfo types.KeyInfo
+		if err := json.Unmarshal(keyContent, &keyInfo); err != nil {
+			return err
+		}
+
+		switch keyInfo.Type {
+		case lp2p.KTLibp2pHost:
+			name, err := base32.RawStdEncoding.DecodeString(fileName)
+			if err != nil {
+				return xerrors.Errorf("decoding key: '%s': %w", fileName, err)
+			}
+
+			if string(name) != keyInfo.Type {
+				return fmt.Errorf("%s of type %s is incorrect", fileName, keyInfo.Type)
+			}
+		case modules.KTJwtHmacSecret:
+			name, err := base32.RawStdEncoding.DecodeString(fileName)
+			if err != nil {
+				return xerrors.Errorf("decoding key: '%s': %w", fileName, err)
+			}
+
+			if string(name) != modules.JWTSecretName {
+				return fmt.Errorf("%s of type %s is incorrect", fileName, keyInfo.Type)
+			}
+		case wallet.KTSecp256k1, wallet.KTBLS:
+			keystore := wallet.NewMemKeyStore()
+			w, err := wallet.NewWallet(keystore)
+			if err != nil {
+				return err
+			}
+
+			if _, err := w.Import(&keyInfo); err != nil {
+				return err
+			}
+
+			list, err := keystore.List()
+			if err != nil {
+				return err
+			}
+
+			if len(list) != 1 {
+				return fmt.Errorf("Unexpected number of keys, expected 1, found %d", len(list))
+			}
+
+			name, err := base32.RawStdEncoding.DecodeString(fileName)
+			if err != nil {
+				return xerrors.Errorf("decoding key: '%s': %w", fileName, err)
+			}
+
+			if string(name) != list[0] {
+				return fmt.Errorf("%s of type %s; file is named for %s, but key is actually %s", fileName, keyInfo.Type, string(name), list[0])
+			}
+
+			break
+		default:
+			return fmt.Errorf("Unknown keytype %s", keyInfo.Type)
+		}
+
+		return nil
+	},
+}
+
+var keyinfoImportCmd = &cli.Command{
+	Name:  "import",
+	Usage: "import a keyinfo file into a lotus repository",
+	Description: `The import command provides a way to import keyfiles into a lotus repository
+   without running the daemon.
+
+   Note: The LOTUS_PATH directory must be created. This command will not create this directory for you.
+
+   Examples
+
+   env LOTUS_PATH=/var/lib/lotus lotus-shed keyinfo import libp2p-host.keyinfo`,
+	Action: func(cctx *cli.Context) error {
+		flagRepo := cctx.String("repo")
+
+		var input io.Reader
+		if cctx.Args().Len() == 0 {
+			input = os.Stdin
+		} else {
+			var err error
+			inputFile, err := os.Open(cctx.Args().First())
+			if err != nil {
+				return err
+			}
+			defer inputFile.Close() //nolint:errcheck
+			input = bufio.NewReader(inputFile)
+		}
+
+		encoded, err := ioutil.ReadAll(input)
+		if err != nil {
+			return err
+		}
+
+		decoded, err := hex.DecodeString(strings.TrimSpace(string(encoded)))
+		if err != nil {
+			return err
+		}
+
+		var keyInfo types.KeyInfo
+		if err := json.Unmarshal(decoded, &keyInfo); err != nil {
+			return err
+		}
+
+		fsrepo, err := repo.NewFS(flagRepo)
+		if err != nil {
+			return err
+		}
+
+		lkrepo, err := fsrepo.Lock(repo.FullNode)
+		if err != nil {
+			return err
+		}
+
+		defer lkrepo.Close() //nolint:errcheck
+
+		keystore, err := lkrepo.KeyStore()
+		if err != nil {
+			return err
+		}
+
+		switch keyInfo.Type {
+		case lp2p.KTLibp2pHost:
+			if err := keystore.Put(lp2p.KLibp2pHost, keyInfo); err != nil {
+				return err
+			}
+
+			sk, err := crypto.UnmarshalPrivateKey(keyInfo.PrivateKey)
+			if err != nil {
+				return err
+			}
+
+			peerid, err := peer.IDFromPrivateKey(sk)
+			if err != nil {
+				return err
+			}
+
+			fmt.Printf("%s\n", peerid.String())
+
+			break
+		case wallet.KTSecp256k1, wallet.KTBLS:
+			w, err := wallet.NewWallet(keystore)
+			if err != nil {
+				return err
+			}
+
+			addr, err := w.Import(&keyInfo)
+			if err != nil {
+				return err
+			}
+
+			fmt.Printf("%s\n", addr.String())
+		}
+
+		return nil
+	},
+}
+
+var keyinfoInfoCmd = &cli.Command{
+	Name:  "info",
+	Usage: "print information about a keyinfo file",
+	Description: `The info command prints additional information about a key which can't easily
+   be retrieved by inspecting the file itself.
+
+   The 'format' flag takes a golang text/template template as its value.
+
+   The following fields can be retrieved through this command
+     Type
+     Address
+     PublicKey
+
+   The PublicKey value will be printed base64 encoded using golangs StdEncoding
+
+   Examples
+
+   Retrieve the address of a lotus wallet
+   lotus-shed keyinfo info --format '{{ .Address }}' wallet.keyinfo
+   `,
 	Flags: []cli.Flag{
 		&cli.StringFlag{
 			Name:  "format",
-			Value: "{{.Address}}",
-			Usage: "Format to output",
+			Value: "{{ .Type }} {{ .Address }}",
+			Usage: "specify which output columns to print",
 		},
 	},
 	Action: func(cctx *cli.Context) error {
 		format := cctx.String("format")
 
 		var input io.Reader
-
 		if cctx.Args().Len() == 0 {
 			input = os.Stdin
 		} else {
-			input = strings.NewReader(cctx.Args().First())
+			var err error
+			inputFile, err := os.Open(cctx.Args().First())
+			if err != nil {
+				return err
+			}
+			defer inputFile.Close() //nolint:errcheck
+			input = bufio.NewReader(inputFile)
 		}
 
-		bytes, err := ioutil.ReadAll(input)
-
-		data, err := hex.DecodeString(strings.TrimSpace(string(bytes)))
+		encoded, err := ioutil.ReadAll(input)
 		if err != nil {
 			return err
 		}
 
-		var ki types.KeyInfo
-		if err := json.Unmarshal(data, &ki); err != nil {
-			return err
-		}
-
-		key, err := wallet.NewKey(ki)
+		decoded, err := hex.DecodeString(strings.TrimSpace(string(encoded)))
 		if err != nil {
 			return err
 		}
 
-		bs, err := json.Marshal(key)
+		var keyInfo types.KeyInfo
+		if err := json.Unmarshal(decoded, &keyInfo); err != nil {
+			return err
+		}
+
+		var kio keyInfoOutput
+
+		switch keyInfo.Type {
+		case lp2p.KTLibp2pHost:
+			kio.Type = keyInfo.Type
+
+			sk, err := crypto.UnmarshalPrivateKey(keyInfo.PrivateKey)
+			if err != nil {
+				return err
+			}
+
+			pk := sk.GetPublic()
+
+			peerid, err := peer.IDFromPrivateKey(sk)
+			if err != nil {
+				return err
+			}
+
+			pkBytes, err := pk.Raw()
+			if err != nil {
+				return err
+			}
+
+			kio.Address = peerid.String()
+			kio.PublicKey = base64.StdEncoding.EncodeToString(pkBytes)
+
+			break
+		case wallet.KTSecp256k1, wallet.KTBLS:
+			kio.Type = keyInfo.Type
+
+			key, err := wallet.NewKey(keyInfo)
+			if err != nil {
+				return err
+			}
+
+			kio.Address = key.Address.String()
+			kio.PublicKey = base64.StdEncoding.EncodeToString(key.PublicKey)
+		}
+
+		tmpl, err := template.New("output").Parse(format)
 		if err != nil {
 			return err
 		}
 
-		var wi walletInfo
-		if err := json.Unmarshal(bs, &wi); err != nil {
-			return err
-		}
-
-		tmpl, err := template.New("").Parse(format)
-		if err != nil {
-			return err
-		}
-
-		return tmpl.Execute(os.Stdout, wi)
+		return tmpl.Execute(os.Stdout, kio)
 	},
 }
+
+var keyinfoNewCmd = &cli.Command{
+	Name:      "new",
+	Usage:     "create a new keyinfo file of the provided type",
+	ArgsUsage: "[bls|secp256k1|libp2p-host]",
+	Description: `Keyinfo files are base16 encoded json structures containing a type
+   string value, and a base64 encoded private key.
+
+   Both the bls and secp256k1 keyfiles can be imported into a running lotus daemon using
+   the 'lotus wallet import' command. Or imported to a non-running / unitialized repo using
+   the 'lotus-shed keyinfo import' command. Libp2p host keys can only be imported using lotus-shed
+   as lotus itself does not provide this functionality at the moment.`,
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:  "output",
+			Value: "<type>-<addr>.keyinfo",
+			Usage: "output file formt",
+		},
+		&cli.BoolFlag{
+			Name:  "silent",
+			Value: false,
+			Usage: "do not print the address to stdout",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		if !cctx.Args().Present() {
+			return fmt.Errorf("please specify a type to generate")
+		}
+
+		keyType := cctx.Args().First()
+		flagOutput := cctx.String("output")
+
+		if i := SliceIndex(len(validTypes), func(i int) bool {
+			if keyType == validTypes[i] {
+				return true
+			}
+			return false
+		}); i == -1 {
+			return fmt.Errorf("invalid key type argument provided '%s'", keyType)
+		}
+
+		keystore := wallet.NewMemKeyStore()
+
+		var keyAddr string
+		var keyInfo types.KeyInfo
+
+		switch keyType {
+		case lp2p.KTLibp2pHost:
+			sk, err := lp2p.PrivKey(keystore)
+			if err != nil {
+				return err
+			}
+
+			ki, err := keystore.Get(lp2p.KLibp2pHost)
+			if err != nil {
+				return err
+			}
+
+			peerid, err := peer.IDFromPrivateKey(sk)
+			if err != nil {
+				return err
+			}
+
+			keyAddr = peerid.String()
+			keyInfo = ki
+
+			break
+		case wallet.KTSecp256k1, wallet.KTBLS:
+			key, err := wallet.GenerateKey(wallet.ActSigType(keyType))
+			if err != nil {
+				return err
+			}
+
+			keyAddr = key.Address.String()
+			keyInfo = key.KeyInfo
+
+			break
+		}
+
+		filename := flagOutput
+		filename = strings.ReplaceAll(filename, "<addr>", keyAddr)
+		filename = strings.ReplaceAll(filename, "<type>", keyType)
+
+		file, err := os.OpenFile(filename, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0600)
+		if err != nil {
+			return err
+		}
+
+		defer func() {
+			if err := file.Close(); err != nil {
+				log.Warnf("failed to close output file: %w", err)
+			}
+		}()
+
+		bytes, err := json.Marshal(keyInfo)
+		if err != nil {
+			return err
+		}
+
+		encoded := hex.EncodeToString(bytes)
+		if _, err := file.Write([]byte(encoded)); err != nil {
+			return err
+		}
+
+		if !cctx.Bool("silent") {
+			fmt.Println(keyAddr)
+		}
+
+		return nil
+	},
+}
+
+func SliceIndex(length int, fn func(i int) bool) int {
+	for i := 0; i < length; i++ {
+		if fn(i) {
+			return i
+		}
+	}
+
+	return -1
+}
diff --git a/cmd/lotus-shed/main.go b/cmd/lotus-shed/main.go
index 79be74d31..118b4ea72 100644
--- a/cmd/lotus-shed/main.go
+++ b/cmd/lotus-shed/main.go
@@ -3,8 +3,8 @@ package main
 import (
 	"os"
 
-	logging "github.com/ipfs/go-log"
-	"gopkg.in/urfave/cli.v2"
+	logging "github.com/ipfs/go-log/v2"
+	"github.com/urfave/cli/v2"
 
 	"github.com/filecoin-project/lotus/build"
 )
@@ -17,9 +17,26 @@ func main() {
 	local := []*cli.Command{
 		base32Cmd,
 		base16Cmd,
+		bitFieldCmd,
 		keyinfoCmd,
-		peerkeyCmd,
+		jwtCmd,
 		noncefix,
+		bigIntParseCmd,
+		staterootCmd,
+		auditsCmd,
+		importCarCmd,
+		commpToCidCmd,
+		fetchParamCmd,
+		proofsCmd,
+		verifRegCmd,
+		miscCmd,
+		mpoolCmd,
+		genesisVerifyCmd,
+		mathCmd,
+		mpoolStatsCmd,
+		exportChainCmd,
+		consensusCmd,
+		serveDealStatsCmd,
 	}
 
 	app := &cli.App{
@@ -27,6 +44,21 @@ func main() {
 		Usage:    "A place for all the lotus tools",
 		Version:  build.BuildVersion,
 		Commands: local,
+		Flags: []cli.Flag{
+			&cli.StringFlag{
+				Name:    "repo",
+				EnvVars: []string{"LOTUS_PATH"},
+				Hidden:  true,
+				Value:   "~/.lotus", // TODO: Consider XDG_DATA_HOME
+			},
+			&cli.StringFlag{
+				Name:  "log-level",
+				Value: "info",
+			},
+		},
+		Before: func(cctx *cli.Context) error {
+			return logging.SetLogLevel("lotus-shed", cctx.String("log-level"))
+		},
 	}
 
 	if err := app.Run(os.Args); err != nil {
diff --git a/cmd/lotus-shed/math.go b/cmd/lotus-shed/math.go
new file mode 100644
index 000000000..434559f09
--- /dev/null
+++ b/cmd/lotus-shed/math.go
@@ -0,0 +1,103 @@
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"io"
+	"os"
+	"strings"
+
+	"github.com/urfave/cli/v2"
+
+	"github.com/filecoin-project/lotus/chain/types"
+)
+
+var mathCmd = &cli.Command{
+	Name:  "math",
+	Usage: "utility commands around doing math on a list of numbers",
+	Subcommands: []*cli.Command{
+		mathSumCmd,
+	},
+}
+
+func readLargeNumbers(i io.Reader) ([]types.BigInt, error) {
+	list := []types.BigInt{}
+	reader := bufio.NewReader(i)
+
+	exit := false
+	for {
+		if exit {
+			break
+		}
+
+		line, err := reader.ReadString('\n')
+		if err != nil && err != io.EOF {
+			break
+		}
+		if err == io.EOF {
+			exit = true
+		}
+
+		line = strings.Trim(line, "\n")
+
+		if len(line) == 0 {
+			continue
+		}
+
+		value, err := types.BigFromString(line)
+		if err != nil {
+			return []types.BigInt{}, fmt.Errorf("failed to parse line: %s", line)
+		}
+
+		list = append(list, value)
+	}
+
+	return list, nil
+}
+
+var mathSumCmd = &cli.Command{
+	Name:  "sum",
+	Usage: "Sum numbers",
+	Flags: []cli.Flag{
+		&cli.BoolFlag{
+			Name:  "avg",
+			Value: false,
+			Usage: "Print the average instead of the sum",
+		},
+		&cli.StringFlag{
+			Name:  "format",
+			Value: "raw",
+			Usage: "format the number in a more readable way [fil,bytes2,bytes10]",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		list, err := readLargeNumbers(os.Stdin)
+		if err != nil {
+			return err
+		}
+
+		val := types.NewInt(0)
+		for _, value := range list {
+			val = types.BigAdd(val, value)
+		}
+
+		if cctx.Bool("avg") {
+			val = types.BigDiv(val, types.NewInt(uint64(len(list))))
+		}
+
+		switch cctx.String("format") {
+		case "byte2":
+			fmt.Printf("%s\n", types.SizeStr(val))
+		case "byte10":
+			fmt.Printf("%s\n", types.DeciStr(val))
+		case "fil":
+			fmt.Printf("%s\n", types.FIL(val))
+		case "raw":
+			fmt.Printf("%s\n", val)
+		default:
+			return fmt.Errorf("Unknown format")
+		}
+
+		return nil
+	},
+}
diff --git a/cmd/lotus-shed/mempool-stats.go b/cmd/lotus-shed/mempool-stats.go
new file mode 100644
index 000000000..165c01432
--- /dev/null
+++ b/cmd/lotus-shed/mempool-stats.go
@@ -0,0 +1,274 @@
+package main
+
+import (
+	"fmt"
+	"net/http"
+	"sort"
+	"time"
+
+	"contrib.go.opencensus.io/exporter/prometheus"
+	"github.com/ipfs/go-cid"
+	logging "github.com/ipfs/go-log"
+	"github.com/urfave/cli/v2"
+	"go.opencensus.io/stats"
+	"go.opencensus.io/stats/view"
+	"go.opencensus.io/tag"
+
+	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
+
+	"github.com/filecoin-project/go-address"
+	lapi "github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/chain/types"
+	lcli "github.com/filecoin-project/lotus/cli"
+)
+
+var (
+	MpoolAge           = stats.Float64("mpoolage", "Age of messages in the mempool", stats.UnitSeconds)
+	MpoolSize          = stats.Int64("mpoolsize", "Number of messages in mempool", stats.UnitDimensionless)
+	MpoolInboundRate   = stats.Int64("inbound", "Counter for inbound messages", stats.UnitDimensionless)
+	BlockInclusionRate = stats.Int64("inclusion", "Counter for message included in blocks", stats.UnitDimensionless)
+	MsgWaitTime        = stats.Float64("msg-wait-time", "Wait time of messages to make it into a block", stats.UnitSeconds)
+)
+
+var (
+	LeTag, _ = tag.NewKey("quantile")
+	MTTag, _ = tag.NewKey("msg_type")
+)
+
+var (
+	AgeView = &view.View{
+		Name:        "mpool-age",
+		Measure:     MpoolAge,
+		TagKeys:     []tag.Key{LeTag, MTTag},
+		Aggregation: view.LastValue(),
+	}
+	SizeView = &view.View{
+		Name:        "mpool-size",
+		Measure:     MpoolSize,
+		TagKeys:     []tag.Key{MTTag},
+		Aggregation: view.LastValue(),
+	}
+	InboundRate = &view.View{
+		Name:        "msg-inbound",
+		Measure:     MpoolInboundRate,
+		TagKeys:     []tag.Key{MTTag},
+		Aggregation: view.Count(),
+	}
+	InclusionRate = &view.View{
+		Name:        "msg-inclusion",
+		Measure:     BlockInclusionRate,
+		TagKeys:     []tag.Key{MTTag},
+		Aggregation: view.Count(),
+	}
+	MsgWait = &view.View{
+		Name:        "msg-wait",
+		Measure:     MsgWaitTime,
+		TagKeys:     []tag.Key{MTTag},
+		Aggregation: view.Distribution(10, 30, 60, 120, 240, 600, 1800, 3600),
+	}
+)
+
+type msgInfo struct {
+	msg  *types.SignedMessage
+	seen time.Time
+}
+
+var mpoolStatsCmd = &cli.Command{
+	Name: "mpool-stats",
+	Action: func(cctx *cli.Context) error {
+		logging.SetLogLevel("rpc", "ERROR")
+
+		if err := view.Register(AgeView, SizeView, InboundRate, InclusionRate, MsgWait); err != nil {
+			return err
+		}
+
+		expo, err := prometheus.NewExporter(prometheus.Options{
+			Namespace: "lotusmpool",
+		})
+		if err != nil {
+			return err
+		}
+
+		http.Handle("/debug/metrics", expo)
+
+		go func() {
+			if err := http.ListenAndServe(":10555", nil); err != nil {
+				panic(err)
+			}
+		}()
+
+		api, closer, err := lcli.GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+
+		defer closer()
+		ctx := lcli.ReqContext(cctx)
+
+		updates, err := api.MpoolSub(ctx)
+		if err != nil {
+			return err
+		}
+
+		mcache := make(map[address.Address]bool)
+		isMiner := func(addr address.Address) (bool, error) {
+			cache, ok := mcache[addr]
+			if ok {
+				return cache, nil
+			}
+
+			act, err := api.StateGetActor(ctx, addr, types.EmptyTSK)
+			if err != nil {
+				return false, err
+			}
+
+			ism := act.IsStorageMinerActor()
+			mcache[addr] = ism
+			return ism, nil
+		}
+
+		wpostTracker := make(map[cid.Cid]*msgInfo)
+		tracker := make(map[cid.Cid]*msgInfo)
+		tick := time.Tick(time.Second)
+		for {
+			select {
+			case u, ok := <-updates:
+				if !ok {
+					return fmt.Errorf("connection with lotus node broke")
+				}
+				switch u.Type {
+				case lapi.MpoolAdd:
+					stats.Record(ctx, MpoolInboundRate.M(1))
+					tracker[u.Message.Cid()] = &msgInfo{
+						msg:  u.Message,
+						seen: time.Now(),
+					}
+
+					if u.Message.Message.Method == builtin0.MethodsMiner.SubmitWindowedPoSt {
+
+						miner, err := isMiner(u.Message.Message.To)
+						if err != nil {
+							log.Warnf("failed to determine if message target was to a miner: %s", err)
+							continue
+						}
+
+						if miner {
+							wpostTracker[u.Message.Cid()] = &msgInfo{
+								msg:  u.Message,
+								seen: time.Now(),
+							}
+							_ = stats.RecordWithTags(ctx, []tag.Mutator{tag.Upsert(MTTag, "wpost")}, MpoolInboundRate.M(1))
+						}
+					}
+
+				case lapi.MpoolRemove:
+					mi, ok := tracker[u.Message.Cid()]
+					if ok {
+						fmt.Printf("%s was in the mempool for %s (feecap=%s, prem=%s)\n", u.Message.Cid(), time.Since(mi.seen), u.Message.Message.GasFeeCap, u.Message.Message.GasPremium)
+						stats.Record(ctx, BlockInclusionRate.M(1))
+						stats.Record(ctx, MsgWaitTime.M(time.Since(mi.seen).Seconds()))
+						delete(tracker, u.Message.Cid())
+					}
+
+					wm, ok := wpostTracker[u.Message.Cid()]
+					if ok {
+						_ = stats.RecordWithTags(ctx, []tag.Mutator{tag.Upsert(MTTag, "wpost")}, BlockInclusionRate.M(1))
+						_ = stats.RecordWithTags(ctx, []tag.Mutator{tag.Upsert(MTTag, "wpost")}, MsgWaitTime.M(time.Since(wm.seen).Seconds()))
+						delete(wpostTracker, u.Message.Cid())
+					}
+				default:
+					return fmt.Errorf("unrecognized mpool update state: %d", u.Type)
+				}
+			case <-tick:
+				var ages []time.Duration
+				if len(tracker) > 0 {
+					for _, v := range tracker {
+						age := time.Since(v.seen)
+						ages = append(ages, age)
+					}
+
+					st := ageStats(ages)
+					_ = stats.RecordWithTags(ctx, []tag.Mutator{tag.Upsert(LeTag, "40")}, MpoolAge.M(st.Perc40.Seconds()))
+					_ = stats.RecordWithTags(ctx, []tag.Mutator{tag.Upsert(LeTag, "50")}, MpoolAge.M(st.Perc50.Seconds()))
+					_ = stats.RecordWithTags(ctx, []tag.Mutator{tag.Upsert(LeTag, "60")}, MpoolAge.M(st.Perc60.Seconds()))
+					_ = stats.RecordWithTags(ctx, []tag.Mutator{tag.Upsert(LeTag, "70")}, MpoolAge.M(st.Perc70.Seconds()))
+					_ = stats.RecordWithTags(ctx, []tag.Mutator{tag.Upsert(LeTag, "80")}, MpoolAge.M(st.Perc80.Seconds()))
+					_ = stats.RecordWithTags(ctx, []tag.Mutator{tag.Upsert(LeTag, "90")}, MpoolAge.M(st.Perc90.Seconds()))
+					_ = stats.RecordWithTags(ctx, []tag.Mutator{tag.Upsert(LeTag, "95")}, MpoolAge.M(st.Perc95.Seconds()))
+
+					stats.Record(ctx, MpoolSize.M(int64(len(tracker))))
+					fmt.Printf("%d messages in mempool for average of %s, (%s / %s / %s)\n", st.Count, st.Average, st.Perc50, st.Perc80, st.Perc95)
+				}
+
+				var wpages []time.Duration
+				if len(wpostTracker) > 0 {
+					for _, v := range wpostTracker {
+						age := time.Since(v.seen)
+						wpages = append(wpages, age)
+					}
+
+					st := ageStats(wpages)
+					_ = stats.RecordWithTags(ctx, []tag.Mutator{tag.Upsert(LeTag, "40"), tag.Upsert(MTTag, "wpost")}, MpoolAge.M(st.Perc40.Seconds()))
+					_ = stats.RecordWithTags(ctx, []tag.Mutator{tag.Upsert(LeTag, "50"), tag.Upsert(MTTag, "wpost")}, MpoolAge.M(st.Perc50.Seconds()))
+					_ = stats.RecordWithTags(ctx, []tag.Mutator{tag.Upsert(LeTag, "60"), tag.Upsert(MTTag, "wpost")}, MpoolAge.M(st.Perc60.Seconds()))
+					_ = stats.RecordWithTags(ctx, []tag.Mutator{tag.Upsert(LeTag, "70"), tag.Upsert(MTTag, "wpost")}, MpoolAge.M(st.Perc70.Seconds()))
+					_ = stats.RecordWithTags(ctx, []tag.Mutator{tag.Upsert(LeTag, "80"), tag.Upsert(MTTag, "wpost")}, MpoolAge.M(st.Perc80.Seconds()))
+					_ = stats.RecordWithTags(ctx, []tag.Mutator{tag.Upsert(LeTag, "90"), tag.Upsert(MTTag, "wpost")}, MpoolAge.M(st.Perc90.Seconds()))
+					_ = stats.RecordWithTags(ctx, []tag.Mutator{tag.Upsert(LeTag, "95"), tag.Upsert(MTTag, "wpost")}, MpoolAge.M(st.Perc95.Seconds()))
+
+					_ = stats.RecordWithTags(ctx, []tag.Mutator{tag.Upsert(MTTag, "wpost")}, MpoolSize.M(int64(len(wpostTracker))))
+					fmt.Printf("%d wpost messages in mempool for average of %s, (%s / %s / %s)\n", st.Count, st.Average, st.Perc50, st.Perc80, st.Perc95)
+				}
+			}
+		}
+	},
+}
+
+type ageStat struct {
+	Average time.Duration
+	Max     time.Duration
+	Perc40  time.Duration
+	Perc50  time.Duration
+	Perc60  time.Duration
+	Perc70  time.Duration
+	Perc80  time.Duration
+	Perc90  time.Duration
+	Perc95  time.Duration
+	Count   int
+}
+
+func ageStats(ages []time.Duration) *ageStat {
+	sort.Slice(ages, func(i, j int) bool {
+		return ages[i] < ages[j]
+	})
+
+	st := ageStat{
+		Count: len(ages),
+	}
+	var sum time.Duration
+	for _, a := range ages {
+		sum += a
+		if a > st.Max {
+			st.Max = a
+		}
+	}
+	st.Average = sum / time.Duration(len(ages))
+
+	p40 := (4 * len(ages)) / 10
+	p50 := len(ages) / 2
+	p60 := (6 * len(ages)) / 10
+	p70 := (7 * len(ages)) / 10
+	p80 := (4 * len(ages)) / 5
+	p90 := (9 * len(ages)) / 10
+	p95 := (19 * len(ages)) / 20
+
+	st.Perc40 = ages[p40]
+	st.Perc50 = ages[p50]
+	st.Perc60 = ages[p60]
+	st.Perc70 = ages[p70]
+	st.Perc80 = ages[p80]
+	st.Perc90 = ages[p90]
+	st.Perc95 = ages[p95]
+
+	return &st
+}
diff --git a/cmd/lotus-shed/misc.go b/cmd/lotus-shed/misc.go
new file mode 100644
index 000000000..b342fab0a
--- /dev/null
+++ b/cmd/lotus-shed/misc.go
@@ -0,0 +1,39 @@
+package main
+
+import (
+	"fmt"
+	"strconv"
+
+	"github.com/filecoin-project/go-fil-markets/storagemarket"
+	"github.com/urfave/cli/v2"
+)
+
+var miscCmd = &cli.Command{
+	Name:  "misc",
+	Usage: "Assorted unsorted commands for various purposes",
+	Flags: []cli.Flag{},
+	Subcommands: []*cli.Command{
+		dealStateMappingCmd,
+	},
+}
+
+var dealStateMappingCmd = &cli.Command{
+	Name: "deal-state",
+	Action: func(cctx *cli.Context) error {
+		if !cctx.Args().Present() {
+			return cli.ShowCommandHelp(cctx, cctx.Command.Name)
+		}
+
+		num, err := strconv.Atoi(cctx.Args().First())
+		if err != nil {
+			return err
+		}
+
+		ststr, ok := storagemarket.DealStates[uint64(num)]
+		if !ok {
+			return fmt.Errorf("no such deal state %d", num)
+		}
+		fmt.Println(ststr)
+		return nil
+	},
+}
diff --git a/cmd/lotus-shed/mpool.go b/cmd/lotus-shed/mpool.go
new file mode 100644
index 000000000..d3660db69
--- /dev/null
+++ b/cmd/lotus-shed/mpool.go
@@ -0,0 +1,68 @@
+package main
+
+import (
+	"fmt"
+
+	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/types"
+	lcli "github.com/filecoin-project/lotus/cli"
+	"github.com/urfave/cli/v2"
+)
+
+var mpoolCmd = &cli.Command{
+	Name:  "mpool",
+	Usage: "Tools for diagnosing mempool issues",
+	Flags: []cli.Flag{},
+	Subcommands: []*cli.Command{
+		minerSelectMsgsCmd,
+	},
+}
+
+var minerSelectMsgsCmd = &cli.Command{
+	Name: "miner-select-msgs",
+	Flags: []cli.Flag{
+		&cli.Float64Flag{
+			Name:  "ticket-quality",
+			Value: 1,
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		api, closer, err := lcli.GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+
+		defer closer()
+		ctx := lcli.ReqContext(cctx)
+
+		head, err := api.ChainHead(ctx)
+		if err != nil {
+			return err
+		}
+
+		msgs, err := api.MpoolSelect(ctx, head.Key(), cctx.Float64("ticket-quality"))
+		if err != nil {
+			return err
+		}
+
+		var totalGas int64
+		for i, f := range msgs {
+			from := f.Message.From.String()
+			if len(from) > 8 {
+				from = "..." + from[len(from)-8:]
+			}
+
+			to := f.Message.To.String()
+			if len(to) > 8 {
+				to = "..." + to[len(to)-8:]
+			}
+
+			fmt.Printf("%d: %s -> %s, method %d, gasFeecap %s, gasPremium %s, gasLimit %d, val %s\n", i, from, to, f.Message.Method, f.Message.GasFeeCap, f.Message.GasPremium, f.Message.GasLimit, types.FIL(f.Message.Value))
+			totalGas += f.Message.GasLimit
+		}
+
+		fmt.Println("selected messages: ", len(msgs))
+		fmt.Printf("total gas limit of selected messages: %d / %d (%0.2f%%)\n", totalGas, build.BlockGasLimit, 100*float64(totalGas)/float64(build.BlockGasLimit))
+		return nil
+	},
+}
diff --git a/cmd/lotus-shed/nonce-fix.go b/cmd/lotus-shed/nonce-fix.go
index 4450c3c79..4824a7bce 100644
--- a/cmd/lotus-shed/nonce-fix.go
+++ b/cmd/lotus-shed/nonce-fix.go
@@ -1,10 +1,14 @@
 package main
 
 import (
+	"fmt"
+	"math"
+
 	"github.com/filecoin-project/go-address"
+	"github.com/urfave/cli/v2"
+
 	"github.com/filecoin-project/lotus/chain/types"
 	lcli "github.com/filecoin-project/lotus/cli"
-	"gopkg.in/urfave/cli.v2"
 )
 
 var noncefix = &cli.Command{
@@ -25,6 +29,9 @@ var noncefix = &cli.Command{
 		&cli.StringFlag{
 			Name: "addr",
 		},
+		&cli.BoolFlag{
+			Name: "auto",
+		},
 	},
 	Action: func(cctx *cli.Context) error {
 		api, closer, err := lcli.GetFullNodeAPI(cctx)
@@ -40,14 +47,49 @@ var noncefix = &cli.Command{
 			return err
 		}
 
-		for i := cctx.Uint64("start"); i < cctx.Uint64("end"); i++ {
+		start := cctx.Uint64("start")
+		end := cctx.Uint64("end")
+		if end == 0 {
+			end = math.MaxUint64
+		}
+
+		if cctx.Bool("auto") {
+			a, err := api.StateGetActor(ctx, addr, types.EmptyTSK)
+			if err != nil {
+				return err
+			}
+			start = a.Nonce
+
+			msgs, err := api.MpoolPending(ctx, types.EmptyTSK)
+			if err != nil {
+				return err
+			}
+
+			for _, msg := range msgs {
+				if msg.Message.From != addr {
+					continue
+				}
+				if msg.Message.Nonce < start {
+					continue // past
+				}
+				if msg.Message.Nonce < end {
+					end = msg.Message.Nonce
+				}
+			}
+
+		}
+		if end == math.MaxUint64 {
+			fmt.Println("No nonce gap found or no --end flag specified")
+			return nil
+		}
+		fmt.Printf("Creating %d filler messages (%d ~ %d)\n", end-start, start, end)
+
+		for i := start; i < end; i++ {
 			msg := &types.Message{
-				From:     addr,
-				To:       addr,
-				Value:    types.NewInt(1),
-				GasLimit: types.NewInt(1000),
-				GasPrice: types.NewInt(1),
-				Nonce:    i,
+				From:  addr,
+				To:    addr,
+				Value: types.NewInt(1),
+				Nonce: i,
 			}
 			smsg, err := api.WalletSignMessage(ctx, addr, msg)
 			if err != nil {
diff --git a/cmd/lotus-shed/params.go b/cmd/lotus-shed/params.go
new file mode 100644
index 000000000..3f7e7b6fb
--- /dev/null
+++ b/cmd/lotus-shed/params.go
@@ -0,0 +1,35 @@
+package main
+
+import (
+	"github.com/docker/go-units"
+	paramfetch "github.com/filecoin-project/go-paramfetch"
+	lcli "github.com/filecoin-project/lotus/cli"
+	"github.com/urfave/cli/v2"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/lotus/build"
+)
+
+var fetchParamCmd = &cli.Command{
+	Name:  "fetch-params",
+	Usage: "Fetch proving parameters",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:  "proving-params",
+			Usage: "download params used creating proofs for given size, i.e. 32GiB",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		sectorSizeInt, err := units.RAMInBytes(cctx.String("proving-params"))
+		if err != nil {
+			return err
+		}
+		sectorSize := uint64(sectorSizeInt)
+		err = paramfetch.GetParams(lcli.ReqContext(cctx), build.ParametersJSON(), sectorSize)
+		if err != nil {
+			return xerrors.Errorf("fetching proof parameters: %w", err)
+		}
+
+		return nil
+	},
+}
diff --git a/cmd/lotus-shed/peerkey.go b/cmd/lotus-shed/peerkey.go
deleted file mode 100644
index 328ad455d..000000000
--- a/cmd/lotus-shed/peerkey.go
+++ /dev/null
@@ -1,105 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"fmt"
-	"os"
-	"strings"
-
-	"gopkg.in/urfave/cli.v2"
-
-	"github.com/filecoin-project/lotus/chain/types"
-	"github.com/filecoin-project/lotus/node/modules/lp2p"
-	"github.com/libp2p/go-libp2p-core/peer"
-)
-
-type keystore struct {
-	set  bool
-	info types.KeyInfo
-}
-
-func (ks *keystore) Put(name string, info types.KeyInfo) error {
-	ks.info = info
-	ks.set = true
-
-	return nil
-}
-
-func (ks *keystore) Get(name string) (types.KeyInfo, error) {
-	if !ks.set {
-		return types.KeyInfo{}, types.ErrKeyInfoNotFound
-	}
-
-	return ks.info, nil
-}
-
-func (ks *keystore) Delete(name string) error {
-	panic("Implement me")
-
-	return nil
-}
-
-func (ks *keystore) List() ([]string, error) {
-	panic("Implement me")
-
-	return []string{}, nil
-}
-
-var peerkeyCmd = &cli.Command{
-	Name:        "peerkey",
-	Description: "create libp2p host key",
-	Flags: []cli.Flag{
-		&cli.StringFlag{
-			Name:  "output",
-			Value: "<peerid>.peerkey",
-			Usage: "Output file format",
-		},
-		&cli.BoolFlag{
-			Name:  "silent",
-			Value: false,
-			Usage: "Do not print peerid at end",
-		},
-	},
-	Action: func(cctx *cli.Context) error {
-		output := cctx.String("output")
-		ks := keystore{}
-
-		sk, err := lp2p.PrivKey(&ks)
-		if err != nil {
-			return err
-		}
-
-		bs, err := json.Marshal(ks.info)
-		if err != nil {
-			return err
-		}
-
-		peerid, err := peer.IDFromPrivateKey(sk)
-		if err != nil {
-			return err
-		}
-
-		output = strings.ReplaceAll(output, "<peerid>", peerid.String())
-
-		f, err := os.Create(output)
-		if err != nil {
-			return err
-		}
-
-		defer func() {
-			if err := f.Close(); err != nil {
-				log.Warnf("failed to close output file: %w", err)
-			}
-		}()
-
-		if _, err := f.Write(bs); err != nil {
-			return err
-		}
-
-		if !cctx.Bool("silent") {
-			fmt.Println(peerid.String())
-		}
-
-		return nil
-	},
-}
diff --git a/cmd/lotus-shed/proofs.go b/cmd/lotus-shed/proofs.go
new file mode 100644
index 000000000..2379d8599
--- /dev/null
+++ b/cmd/lotus-shed/proofs.go
@@ -0,0 +1,110 @@
+package main
+
+import (
+	"encoding/hex"
+	"fmt"
+
+	saproof "github.com/filecoin-project/specs-actors/actors/runtime/proof"
+
+	"github.com/urfave/cli/v2"
+
+	ffi "github.com/filecoin-project/filecoin-ffi"
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/ipfs/go-cid"
+)
+
+var proofsCmd = &cli.Command{
+	Name: "proofs",
+	Subcommands: []*cli.Command{
+		verifySealProofCmd,
+	},
+}
+
+var verifySealProofCmd = &cli.Command{
+	Name:        "verify-seal",
+	ArgsUsage:   "<commr> <commd> <proof>",
+	Description: "Verify a seal proof with manual inputs",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name: "ticket",
+		},
+		&cli.StringFlag{
+			Name: "proof-rand",
+		},
+		&cli.StringFlag{
+			Name: "miner",
+		},
+		&cli.Uint64Flag{
+			Name: "sector-id",
+		},
+		&cli.Int64Flag{
+			Name: "proof-type",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		if cctx.Args().Len() != 3 {
+			return fmt.Errorf("must specify commR, commD, and proof to verify")
+		}
+
+		commr, err := cid.Decode(cctx.Args().Get(0))
+		if err != nil {
+			return err
+		}
+
+		commd, err := cid.Decode(cctx.Args().Get(1))
+		if err != nil {
+			return err
+		}
+
+		proof, err := hex.DecodeString(cctx.Args().Get(2))
+		if err != nil {
+			return fmt.Errorf("failed to decode hex proof input: %w", err)
+		}
+
+		maddr, err := address.NewFromString(cctx.String("miner"))
+		if err != nil {
+			return err
+		}
+
+		mid, err := address.IDFromAddress(maddr)
+		if err != nil {
+			return err
+		}
+
+		ticket, err := hex.DecodeString(cctx.String("ticket"))
+		if err != nil {
+			return err
+		}
+
+		proofRand, err := hex.DecodeString(cctx.String("proof-rand"))
+		if err != nil {
+			return err
+		}
+
+		snum := abi.SectorNumber(cctx.Uint64("sector-id"))
+
+		ok, err := ffi.VerifySeal(saproof.SealVerifyInfo{
+			SectorID: abi.SectorID{
+				Miner:  abi.ActorID(mid),
+				Number: snum,
+			},
+			SealedCID:             commr,
+			SealProof:             abi.RegisteredSealProof(cctx.Int64("proof-type")),
+			Proof:                 proof,
+			DealIDs:               nil,
+			Randomness:            abi.SealRandomness(ticket),
+			InteractiveRandomness: abi.InteractiveSealRandomness(proofRand),
+			UnsealedCID:           commd,
+		})
+		if err != nil {
+			return err
+		}
+		if !ok {
+			return fmt.Errorf("invalid proof")
+		}
+
+		fmt.Println("proof valid!")
+		return nil
+	},
+}
diff --git a/cmd/lotus-shed/stateroot-stats.go b/cmd/lotus-shed/stateroot-stats.go
new file mode 100644
index 000000000..023f782bd
--- /dev/null
+++ b/cmd/lotus-shed/stateroot-stats.go
@@ -0,0 +1,218 @@
+package main
+
+import (
+	"fmt"
+	"sort"
+
+	"github.com/multiformats/go-multihash"
+	"github.com/urfave/cli/v2"
+
+	"github.com/ipfs/go-cid"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/chain/types"
+	lcli "github.com/filecoin-project/lotus/cli"
+)
+
+var staterootCmd = &cli.Command{
+	Name: "stateroot",
+	Subcommands: []*cli.Command{
+		staterootDiffsCmd,
+		staterootStatCmd,
+	},
+}
+
+var staterootDiffsCmd = &cli.Command{
+	Name:        "diffs",
+	Description: "Walk down the chain and collect stats-obj changes between tipsets",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:  "tipset",
+			Usage: "specify tipset to start from",
+		},
+		&cli.IntFlag{
+			Name:  "count",
+			Usage: "number of tipsets to count back",
+			Value: 30,
+		},
+		&cli.BoolFlag{
+			Name:  "diff",
+			Usage: "compare tipset with previous",
+			Value: false,
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		api, closer, err := lcli.GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+
+		defer closer()
+		ctx := lcli.ReqContext(cctx)
+
+		ts, err := lcli.LoadTipSet(ctx, cctx, api)
+		if err != nil {
+			return err
+		}
+
+		if ts == nil {
+			ts, err = api.ChainHead(ctx)
+			if err != nil {
+				return err
+			}
+		}
+
+		fn := func(ts *types.TipSet) (cid.Cid, []cid.Cid) {
+			blk := ts.Blocks()[0]
+			strt := blk.ParentStateRoot
+			cids := blk.Parents
+
+			return strt, cids
+		}
+
+		count := cctx.Int("count")
+		diff := cctx.Bool("diff")
+
+		fmt.Printf("Height\tSize\tLinks\tObj\tBase\n")
+		for i := 0; i < count; i++ {
+			if ts.Height() == 0 {
+				return nil
+			}
+			strt, cids := fn(ts)
+
+			k := types.NewTipSetKey(cids...)
+			ts, err = api.ChainGetTipSet(ctx, k)
+			if err != nil {
+				return err
+			}
+
+			pstrt, _ := fn(ts)
+
+			if !diff {
+				pstrt = cid.Undef
+			}
+
+			stats, err := api.ChainStatObj(ctx, strt, pstrt)
+			if err != nil {
+				return err
+			}
+
+			fmt.Printf("%d\t%d\t%d\t%s\t%s\n", ts.Height(), stats.Size, stats.Links, strt, pstrt)
+		}
+
+		return nil
+	},
+}
+
+type statItem struct {
+	Addr  address.Address
+	Actor *types.Actor
+	Stat  api.ObjStat
+}
+
+var staterootStatCmd = &cli.Command{
+	Name:  "stat",
+	Usage: "print statistics for the stateroot of a given block",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:  "tipset",
+			Usage: "specify tipset to start from",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		api, closer, err := lcli.GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+
+		defer closer()
+		ctx := lcli.ReqContext(cctx)
+
+		ts, err := lcli.LoadTipSet(ctx, cctx, api)
+		if err != nil {
+			return err
+		}
+
+		if ts == nil {
+			ts, err = api.ChainHead(ctx)
+			if err != nil {
+				return err
+			}
+		}
+
+		var addrs []address.Address
+
+		for _, inp := range cctx.Args().Slice() {
+			a, err := address.NewFromString(inp)
+			if err != nil {
+				return err
+			}
+			addrs = append(addrs, a)
+		}
+
+		if len(addrs) == 0 {
+			allActors, err := api.StateListActors(ctx, ts.Key())
+			if err != nil {
+				return err
+			}
+			addrs = allActors
+		}
+
+		var infos []statItem
+		for _, a := range addrs {
+			act, err := api.StateGetActor(ctx, a, ts.Key())
+			if err != nil {
+				return err
+			}
+
+			stat, err := api.ChainStatObj(ctx, act.Head, cid.Undef)
+			if err != nil {
+				return err
+			}
+
+			infos = append(infos, statItem{
+				Addr:  a,
+				Actor: act,
+				Stat:  stat,
+			})
+		}
+
+		sort.Slice(infos, func(i, j int) bool {
+			return infos[i].Stat.Size > infos[j].Stat.Size
+		})
+
+		var totalActorsSize uint64
+		for _, info := range infos {
+			totalActorsSize += info.Stat.Size
+		}
+
+		outcap := 10
+		if cctx.Args().Len() > outcap {
+			outcap = cctx.Args().Len()
+		}
+		if len(infos) < outcap {
+			outcap = len(infos)
+		}
+
+		totalStat, err := api.ChainStatObj(ctx, ts.ParentState(), cid.Undef)
+		if err != nil {
+			return err
+		}
+
+		fmt.Println("Total state tree size: ", totalStat.Size)
+		fmt.Println("Sum of actor state size: ", totalActorsSize)
+		fmt.Println("State tree structure size: ", totalStat.Size-totalActorsSize)
+
+		fmt.Print("Addr\tType\tSize\n")
+		for _, inf := range infos[:outcap] {
+			cmh, err := multihash.Decode(inf.Actor.Code.Hash())
+			if err != nil {
+				return err
+			}
+
+			fmt.Printf("%s\t%s\t%d\n", inf.Addr, string(cmh.Digest), inf.Stat.Size)
+		}
+		return nil
+	},
+}
diff --git a/cmd/lotus-shed/verifreg.go b/cmd/lotus-shed/verifreg.go
new file mode 100644
index 000000000..3e2f34f4b
--- /dev/null
+++ b/cmd/lotus-shed/verifreg.go
@@ -0,0 +1,324 @@
+package main
+
+import (
+	"fmt"
+
+	"github.com/urfave/cli/v2"
+	"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"
+	verifreg0 "github.com/filecoin-project/specs-actors/actors/builtin/verifreg"
+
+	"github.com/filecoin-project/lotus/api/apibstore"
+	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/actors"
+	"github.com/filecoin-project/lotus/chain/actors/adt"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/verifreg"
+	"github.com/filecoin-project/lotus/chain/types"
+	lcli "github.com/filecoin-project/lotus/cli"
+	cbor "github.com/ipfs/go-ipld-cbor"
+)
+
+var verifRegCmd = &cli.Command{
+	Name:  "verifreg",
+	Usage: "Interact with the verified registry actor",
+	Flags: []cli.Flag{},
+	Subcommands: []*cli.Command{
+		verifRegAddVerifierCmd,
+		verifRegVerifyClientCmd,
+		verifRegListVerifiersCmd,
+		verifRegListClientsCmd,
+		verifRegCheckClientCmd,
+		verifRegCheckVerifierCmd,
+	},
+}
+
+var verifRegAddVerifierCmd = &cli.Command{
+	Name:  "add-verifier",
+	Usage: "make a given account a verifier",
+	Action: func(cctx *cli.Context) error {
+		fromk, err := address.NewFromString("t3qfoulel6fy6gn3hjmbhpdpf6fs5aqjb5fkurhtwvgssizq4jey5nw4ptq5up6h7jk7frdvvobv52qzmgjinq")
+		if err != nil {
+			return err
+		}
+
+		if cctx.Args().Len() != 2 {
+			return fmt.Errorf("must specify two arguments: address and allowance")
+		}
+
+		target, err := address.NewFromString(cctx.Args().Get(0))
+		if err != nil {
+			return err
+		}
+
+		allowance, err := types.BigFromString(cctx.Args().Get(1))
+		if err != nil {
+			return err
+		}
+
+		params, err := actors.SerializeParams(&verifreg0.AddVerifierParams{Address: target, Allowance: allowance})
+		if err != nil {
+			return err
+		}
+
+		api, closer, err := lcli.GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+		ctx := lcli.ReqContext(cctx)
+
+		msg := &types.Message{
+			To:     verifreg.Address,
+			From:   fromk,
+			Method: builtin0.MethodsVerifiedRegistry.AddVerifier,
+			Params: params,
+		}
+
+		smsg, err := api.MpoolPushMessage(ctx, msg, nil)
+		if err != nil {
+			return err
+		}
+
+		fmt.Printf("message sent, now waiting on cid: %s\n", smsg.Cid())
+
+		mwait, err := api.StateWaitMsg(ctx, smsg.Cid(), build.MessageConfidence)
+		if err != nil {
+			return err
+		}
+
+		if mwait.Receipt.ExitCode != 0 {
+			return fmt.Errorf("failed to add verifier: %d", mwait.Receipt.ExitCode)
+		}
+
+		return nil
+
+	},
+}
+
+var verifRegVerifyClientCmd = &cli.Command{
+	Name:  "verify-client",
+	Usage: "make a given account a verified client",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:  "from",
+			Usage: "specify your verifier address to send the message from",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		froms := cctx.String("from")
+		if froms == "" {
+			return fmt.Errorf("must specify from address with --from")
+		}
+
+		fromk, err := address.NewFromString(froms)
+		if err != nil {
+			return err
+		}
+
+		if cctx.Args().Len() != 2 {
+			return fmt.Errorf("must specify two arguments: address and allowance")
+		}
+
+		target, err := address.NewFromString(cctx.Args().Get(0))
+		if err != nil {
+			return err
+		}
+
+		allowance, err := types.BigFromString(cctx.Args().Get(1))
+		if err != nil {
+			return err
+		}
+
+		params, err := actors.SerializeParams(&verifreg0.AddVerifiedClientParams{Address: target, Allowance: allowance})
+		if err != nil {
+			return err
+		}
+
+		api, closer, err := lcli.GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+		ctx := lcli.ReqContext(cctx)
+
+		msg := &types.Message{
+			To:     verifreg.Address,
+			From:   fromk,
+			Method: builtin0.MethodsVerifiedRegistry.AddVerifiedClient,
+			Params: params,
+		}
+
+		smsg, err := api.MpoolPushMessage(ctx, msg, nil)
+		if err != nil {
+			return err
+		}
+
+		fmt.Printf("message sent, now waiting on cid: %s\n", smsg.Cid())
+
+		mwait, err := api.StateWaitMsg(ctx, smsg.Cid(), build.MessageConfidence)
+		if err != nil {
+			return err
+		}
+
+		if mwait.Receipt.ExitCode != 0 {
+			return fmt.Errorf("failed to add verified client: %d", mwait.Receipt.ExitCode)
+		}
+
+		return nil
+	},
+}
+
+var verifRegListVerifiersCmd = &cli.Command{
+	Name:  "list-verifiers",
+	Usage: "list all verifiers",
+	Action: func(cctx *cli.Context) error {
+		api, closer, err := lcli.GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+		ctx := lcli.ReqContext(cctx)
+
+		act, err := api.StateGetActor(ctx, verifreg.Address, types.EmptyTSK)
+		if err != nil {
+			return err
+		}
+
+		apibs := apibstore.NewAPIBlockstore(api)
+		store := adt.WrapStore(ctx, cbor.NewCborStore(apibs))
+
+		st, err := verifreg.Load(store, act)
+		if err != nil {
+			return err
+		}
+		return st.ForEachVerifier(func(addr address.Address, dcap abi.StoragePower) error {
+			_, err := fmt.Printf("%s: %s\n", addr, dcap)
+			return err
+		})
+	},
+}
+
+var verifRegListClientsCmd = &cli.Command{
+	Name:  "list-clients",
+	Usage: "list all verified clients",
+	Action: func(cctx *cli.Context) error {
+		api, closer, err := lcli.GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+		ctx := lcli.ReqContext(cctx)
+
+		act, err := api.StateGetActor(ctx, verifreg.Address, types.EmptyTSK)
+		if err != nil {
+			return err
+		}
+
+		apibs := apibstore.NewAPIBlockstore(api)
+		store := adt.WrapStore(ctx, cbor.NewCborStore(apibs))
+
+		st, err := verifreg.Load(store, act)
+		if err != nil {
+			return err
+		}
+		return st.ForEachClient(func(addr address.Address, dcap abi.StoragePower) error {
+			_, err := fmt.Printf("%s: %s\n", addr, dcap)
+			return err
+		})
+	},
+}
+
+var verifRegCheckClientCmd = &cli.Command{
+	Name:  "check-client",
+	Usage: "check verified client remaining bytes",
+	Action: func(cctx *cli.Context) error {
+		if !cctx.Args().Present() {
+			return fmt.Errorf("must specify client address to check")
+		}
+
+		caddr, err := address.NewFromString(cctx.Args().First())
+		if err != nil {
+			return err
+		}
+
+		api, closer, err := lcli.GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+		ctx := lcli.ReqContext(cctx)
+
+		dcap, err := api.StateVerifiedClientStatus(ctx, caddr, types.EmptyTSK)
+		if err != nil {
+			return err
+		}
+		if dcap == nil {
+			return xerrors.Errorf("client %s is not a verified client", err)
+		}
+
+		fmt.Println(*dcap)
+
+		return nil
+	},
+}
+
+var verifRegCheckVerifierCmd = &cli.Command{
+	Name:  "check-verifier",
+	Usage: "check verifiers remaining bytes",
+	Action: func(cctx *cli.Context) error {
+		if !cctx.Args().Present() {
+			return fmt.Errorf("must specify verifier address to check")
+		}
+
+		vaddr, err := address.NewFromString(cctx.Args().First())
+		if err != nil {
+			return err
+		}
+
+		api, closer, err := lcli.GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+		ctx := lcli.ReqContext(cctx)
+
+		head, err := api.ChainHead(ctx)
+		if err != nil {
+			return err
+		}
+
+		vid, err := api.StateLookupID(ctx, vaddr, head.Key())
+		if err != nil {
+			return err
+		}
+
+		act, err := api.StateGetActor(ctx, verifreg.Address, head.Key())
+		if err != nil {
+			return err
+		}
+
+		apibs := apibstore.NewAPIBlockstore(api)
+		store := adt.WrapStore(ctx, cbor.NewCborStore(apibs))
+
+		st, err := verifreg.Load(store, act)
+		if err != nil {
+			return err
+		}
+
+		found, dcap, err := st.VerifierDataCap(vid)
+		if err != nil {
+			return err
+		}
+		if !found {
+			return fmt.Errorf("not found")
+		}
+
+		fmt.Println(dcap)
+
+		return nil
+	},
+}
diff --git a/tools/stats/README.md b/cmd/lotus-stats/README.md
similarity index 61%
rename from tools/stats/README.md
rename to cmd/lotus-stats/README.md
index a75671220..04220aa3b 100644
--- a/tools/stats/README.md
+++ b/cmd/lotus-stats/README.md
@@ -1,6 +1,6 @@
-# Stats
+# lotus-stats
 
-Stats is a small tool to push chain information into influxdb
+`lotus-stats` is a small tool to push chain information into influxdb
 
 ## Setup
 
@@ -14,13 +14,13 @@ INFLUX_PASS=""
 
 ## Usage
 
-Stats will be default look in `~/.lotus` to connect to a running daemon and resume collecting stats from last record block height.
+lotus-stats will be default look in `~/.lotus` to connect to a running daemon and resume collecting stats from last record block height.
 
-For other usage see `./stats --help`
+For other usage see `./lotus-stats --help`
 
 ```
-go build -o stats *.go 
-. env.stats && ./stats
+go build -o lotus-stats *.go 
+. env.stats && ./lotus-stats
 ```
 
 
diff --git a/tools/stats/chain.dashboard.json b/cmd/lotus-stats/chain.dashboard.json
similarity index 88%
rename from tools/stats/chain.dashboard.json
rename to cmd/lotus-stats/chain.dashboard.json
index be923cc33..5ff7654d0 100644
--- a/tools/stats/chain.dashboard.json
+++ b/cmd/lotus-stats/chain.dashboard.json
@@ -62,7 +62,7 @@
   "panels": [
     {
       "aliasColors": {},
-      "bars": false,
+      "bars": true,
       "dashLength": 10,
       "dashes": false,
       "datasource": "${DS_INFLUXDB}",
@@ -70,7 +70,7 @@
       "fill": 3,
       "fillGradient": 0,
       "gridPos": {
-        "h": 16,
+        "h": 9,
         "w": 24,
         "x": 0,
         "y": 0
@@ -80,18 +80,18 @@
       "interval": "",
       "legend": {
         "alignAsTable": true,
-        "avg": false,
-        "current": true,
+        "avg": true,
+        "current": false,
         "max": false,
         "min": false,
         "rightSide": true,
         "show": true,
-        "sort": "current",
+        "sort": "avg",
         "sortDesc": true,
         "total": false,
         "values": true
       },
-      "lines": true,
+      "lines": false,
       "linewidth": 1,
       "nullPointMode": "null",
       "options": {
@@ -131,7 +131,7 @@
           "measurement": "chain.election",
           "orderByTime": "ASC",
           "policy": "default",
-          "query": "SELECT moving_average(count(\"value\"), 10) FROM \"chain.election\" WHERE $timeFilter -10m GROUP BY time($__interval), \"miner\" fill(null)",
+          "query": "SELECT count(\"value\") FROM \"chain.election\" WHERE $timeFilter -10m GROUP BY time($__interval), \"miner\" fill(null)",
           "rawQuery": true,
           "refId": "A",
           "resultFormat": "time_series",
@@ -214,9 +214,10 @@
         "h": 4,
         "w": 8,
         "x": 0,
-        "y": 16
+        "y": 9
       },
       "id": 22,
+      "interval": "",
       "legend": {
         "avg": false,
         "current": false,
@@ -268,7 +269,7 @@
         }
       ],
       "thresholds": [],
-      "timeFrom": null,
+      "timeFrom": "4h",
       "timeRegions": [],
       "timeShift": null,
       "title": "Total Power",
@@ -287,9 +288,8 @@
       },
       "yaxes": [
         {
-          "decimals": 2,
           "format": "bytes",
-          "label": "",
+          "label": null,
           "logBase": 1,
           "max": null,
           "min": null,
@@ -329,9 +329,9 @@
       },
       "gridPos": {
         "h": 4,
-        "w": 8,
+        "w": 4,
         "x": 8,
-        "y": 16
+        "y": 9
       },
       "id": 12,
       "interval": null,
@@ -413,6 +413,122 @@
       ],
       "valueName": "avg"
     },
+    {
+      "cacheTimeout": null,
+      "colorBackground": false,
+      "colorValue": false,
+      "colors": [
+        "#299c46",
+        "rgba(237, 129, 40, 0.89)",
+        "#d44a3a"
+      ],
+      "datasource": "${DS_INFLUXDB}",
+      "format": "bytes",
+      "gauge": {
+        "maxValue": 100,
+        "minValue": 0,
+        "show": false,
+        "thresholdLabels": false,
+        "thresholdMarkers": true
+      },
+      "gridPos": {
+        "h": 4,
+        "w": 4,
+        "x": 12,
+        "y": 9
+      },
+      "id": 42,
+      "interval": "",
+      "links": [],
+      "mappingType": 1,
+      "mappingTypes": [
+        {
+          "name": "value to text",
+          "value": 1
+        },
+        {
+          "name": "range to text",
+          "value": 2
+        }
+      ],
+      "maxDataPoints": 100,
+      "nullPointMode": "connected",
+      "nullText": null,
+      "options": {},
+      "postfix": "",
+      "postfixFontSize": "50%",
+      "prefix": "",
+      "prefixFontSize": "50%",
+      "rangeMaps": [
+        {
+          "from": "null",
+          "text": "N/A",
+          "to": "null"
+        }
+      ],
+      "sparkline": {
+        "fillColor": "rgba(31, 118, 189, 0.18)",
+        "full": false,
+        "lineColor": "rgb(31, 120, 193)",
+        "show": true,
+        "ymax": null,
+        "ymin": 0
+      },
+      "tableColumn": "",
+      "targets": [
+        {
+          "groupBy": [
+            {
+              "params": [
+                "$__interval"
+              ],
+              "type": "time"
+            },
+            {
+              "params": [
+                "null"
+              ],
+              "type": "fill"
+            }
+          ],
+          "orderByTime": "ASC",
+          "policy": "default",
+          "query": "SELECT sum(\"value\") FROM \"chain.miner_power\" WHERE $timeFilter GROUP BY time(45s)",
+          "rawQuery": true,
+          "refId": "A",
+          "resultFormat": "time_series",
+          "select": [
+            [
+              {
+                "params": [
+                  "value"
+                ],
+                "type": "field"
+              },
+              {
+                "params": [],
+                "type": "mean"
+              }
+            ]
+          ],
+          "tags": []
+        }
+      ],
+      "thresholds": "",
+      "timeFrom": null,
+      "timeShift": null,
+      "title": "Network Storage",
+      "type": "singlestat",
+      "valueFontSize": "80%",
+      "valueMaps": [
+        {
+          "op": "=",
+          "text": "N/A",
+          "value": "null"
+        }
+      ],
+      "valueName": "current"
+    },
     {
       "cacheTimeout": null,
       "colorBackground": false,
@@ -435,7 +551,7 @@
         "h": 4,
         "w": 8,
         "x": 16,
-        "y": 16
+        "y": 9
       },
       "id": 6,
       "interval": null,
@@ -477,8 +593,15 @@
       "tableColumn": "",
       "targets": [
         {
-          "groupBy": [],
-          "measurement": "chain.block_count",
+          "groupBy": [
+            {
+              "params": [
+                "$interval"
+              ],
+              "type": "time"
+            }
+          ],
+          "measurement": "chain.election",
           "orderByTime": "ASC",
           "policy": "default",
           "refId": "A",
@@ -490,6 +613,10 @@
                   "value"
                 ],
                 "type": "field"
+              },
+              {
+                "params": [],
+                "type": "sum"
               }
             ]
           ],
@@ -509,7 +636,7 @@
           "value": "null"
         }
       ],
-      "valueName": "current"
+      "valueName": "avg"
     },
     {
       "cacheTimeout": null,
@@ -534,7 +661,7 @@
         "h": 3,
         "w": 4,
         "x": 0,
-        "y": 20
+        "y": 13
       },
       "id": 4,
       "interval": null,
@@ -632,7 +759,7 @@
         "h": 3,
         "w": 4,
         "x": 4,
-        "y": 20
+        "y": 13
       },
       "id": 14,
       "interval": null,
@@ -734,7 +861,7 @@
         "h": 3,
         "w": 4,
         "x": 8,
-        "y": 20
+        "y": 13
       },
       "id": 32,
       "interval": null,
@@ -849,7 +976,7 @@
         "h": 3,
         "w": 4,
         "x": 12,
-        "y": 20
+        "y": 13
       },
       "id": 20,
       "interval": null,
@@ -964,7 +1091,7 @@
         "h": 3,
         "w": 4,
         "x": 16,
-        "y": 20
+        "y": 13
       },
       "id": 8,
       "interval": null,
@@ -1079,7 +1206,7 @@
         "h": 3,
         "w": 4,
         "x": 20,
-        "y": 20
+        "y": 13
       },
       "id": 10,
       "interval": null,
@@ -1131,7 +1258,7 @@
             },
             {
               "params": [
-                "0"
+                "null"
               ],
               "type": "fill"
             }
@@ -1139,8 +1266,8 @@
           "measurement": "chain.message_count",
           "orderByTime": "ASC",
           "policy": "default",
-          "query": "SELECT sum(\"value\") FROM (SELECT \"value\" FROM \"chain.message_count\" GROUP BY \"height\") WHERE $timeFilter GROUP BY time($__interval) fill(0)",
-          "rawQuery": true,
+          "query": "SELECT \"value\" FROM \"chain.message_count\" WHERE $timeFilter ",
+          "rawQuery": false,
           "refId": "A",
           "resultFormat": "time_series",
           "select": [
@@ -1153,7 +1280,7 @@
               },
               {
                 "params": [],
-                "type": "mean"
+                "type": "sum"
               }
             ]
           ],
@@ -1198,7 +1325,7 @@
         "h": 3,
         "w": 4,
         "x": 0,
-        "y": 23
+        "y": 16
       },
       "id": 16,
       "interval": "",
@@ -1293,16 +1420,16 @@
         "h": 3,
         "w": 16,
         "x": 4,
-        "y": 23
+        "y": 16
       },
       "id": 2,
       "legend": {
         "alignAsTable": true,
         "avg": true,
-        "current": false,
+        "current": true,
         "hideEmpty": false,
         "hideZero": false,
-        "max": false,
+        "max": true,
         "min": false,
         "rightSide": true,
         "show": true,
@@ -1321,10 +1448,6 @@
       "points": false,
       "renderer": "flot",
       "seriesOverrides": [
-        {
-          "alias": "chain.height.difference",
-          "yaxis": 2
-        },
         {
           "alias": "Null Blocks",
           "yaxis": 2
@@ -1399,7 +1522,7 @@
       "timeFrom": null,
       "timeRegions": [],
       "timeShift": null,
-      "title": "",
+      "title": "Tipsets",
       "tooltip": {
         "shared": true,
         "sort": 0,
@@ -1416,7 +1539,7 @@
       "yaxes": [
         {
           "format": "s",
-          "label": "Time delta",
+          "label": "Time between tipsets",
           "logBase": 1,
           "max": null,
           "min": null,
@@ -1425,7 +1548,7 @@
         {
           "decimals": 0,
           "format": "short",
-          "label": "# null blocks",
+          "label": "Number of Null blocks",
           "logBase": 1,
           "max": null,
           "min": "0",
@@ -1459,7 +1582,7 @@
         "h": 3,
         "w": 4,
         "x": 20,
-        "y": 23
+        "y": 16
       },
       "id": 30,
       "interval": null,
@@ -1540,10 +1663,10 @@
       "datasource": "${DS_INFLUXDB}",
       "fontSize": "100%",
       "gridPos": {
-        "h": 16,
+        "h": 21,
         "w": 4,
         "x": 0,
-        "y": 26
+        "y": 19
       },
       "id": 28,
       "options": {},
@@ -1627,13 +1750,13 @@
       "dashLength": 10,
       "dashes": false,
       "datasource": "${DS_INFLUXDB}",
-      "fill": 4,
+      "fill": 5,
       "fillGradient": 0,
       "gridPos": {
         "h": 8,
         "w": 12,
         "x": 4,
-        "y": 26
+        "y": 19
       },
       "id": 40,
       "interval": "",
@@ -1641,8 +1764,8 @@
         "alignAsTable": true,
         "avg": false,
         "current": true,
-        "hideEmpty": false,
-        "hideZero": false,
+        "hideEmpty": true,
+        "hideZero": true,
         "max": false,
         "min": false,
         "rightSide": true,
@@ -1765,10 +1888,10 @@
       "datasource": "${DS_INFLUXDB}",
       "fontSize": "100%",
       "gridPos": {
-        "h": 16,
+        "h": 21,
         "w": 8,
         "x": 16,
-        "y": 26
+        "y": 19
       },
       "id": 18,
       "options": {},
@@ -1862,10 +1985,10 @@
       "fill": 1,
       "fillGradient": 0,
       "gridPos": {
-        "h": 8,
+        "h": 6,
         "w": 12,
         "x": 4,
-        "y": 34
+        "y": 27
       },
       "id": 24,
       "legend": {
@@ -1981,6 +2104,128 @@
     {
       "aliasColors": {},
       "bars": false,
+      "cacheTimeout": null,
+      "dashLength": 10,
+      "dashes": false,
+      "datasource": "${DS_INFLUXDB}",
+      "fill": 1,
+      "fillGradient": 0,
+      "gridPos": {
+        "h": 7,
+        "w": 12,
+        "x": 4,
+        "y": 33
+      },
+      "id": 44,
+      "legend": {
+        "avg": false,
+        "current": false,
+        "max": false,
+        "min": false,
+        "show": true,
+        "total": false,
+        "values": false
+      },
+      "lines": true,
+      "linewidth": 1,
+      "links": [],
+      "nullPointMode": "null",
+      "options": {
+        "dataLinks": []
+      },
+      "percentage": false,
+      "pointradius": 2,
+      "points": false,
+      "renderer": "flot",
+      "seriesOverrides": [],
+      "spaceLength": 10,
+      "stack": false,
+      "steppedLine": false,
+      "targets": [
+        {
+          "groupBy": [
+            {
+              "params": [
+                "$__interval"
+              ],
+              "type": "time"
+            },
+            {
+              "params": [
+                "previous"
+              ],
+              "type": "fill"
+            }
+          ],
+          "measurement": "chain.miner_power",
+          "orderByTime": "ASC",
+          "policy": "default",
+          "query": "SELECT count(\"value\") FROM \"chain.miner_power\" WHERE $timeFilter GROUP BY time($__interval)",
+          "rawQuery": false,
+          "refId": "A",
+          "resultFormat": "time_series",
+          "select": [
+            [
+              {
+                "params": [
+                  "value"
+                ],
+                "type": "field"
+              },
+              {
+                "params": [],
+                "type": "count"
+              }
+            ]
+          ],
+          "tags": []
+        }
+      ],
+      "thresholds": [],
+      "timeFrom": null,
+      "timeRegions": [],
+      "timeShift": null,
+      "title": "Miners on Chain",
+      "tooltip": {
+        "shared": true,
+        "sort": 0,
+        "value_type": "individual"
+      },
+      "type": "graph",
+      "xaxis": {
+        "buckets": null,
+        "mode": "time",
+        "name": null,
+        "show": true,
+        "values": []
+      },
+      "yaxes": [
+        {
+          "decimals": 0,
+          "format": "none",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        },
+        {
+          "format": "short",
+          "label": null,
+          "logBase": 1,
+          "max": null,
+          "min": null,
+          "show": true
+        }
+      ],
+      "yaxis": {
+        "align": false,
+        "alignLevel": null
+      }
+    },
+    {
+      "aliasColors": {},
+      "bars": true,
       "dashLength": 10,
       "dashes": false,
       "datasource": "${DS_INFLUXDB}",
@@ -1990,7 +2235,7 @@
         "h": 9,
         "w": 12,
         "x": 0,
-        "y": 42
+        "y": 40
       },
       "id": 34,
       "legend": {
@@ -2004,7 +2249,7 @@
         "total": false,
         "values": false
       },
-      "lines": true,
+      "lines": false,
       "linewidth": 1,
       "nullPointMode": "null",
       "options": {
@@ -2050,8 +2295,6 @@
           "measurement": "chain.message_count",
           "orderByTime": "ASC",
           "policy": "default",
-          "query": "SELECT moving_average(count(\"value\"), 2) FROM \"chain.message_count\" WHERE $timeFilter -4m GROUP BY time($__interval), \"actor\", \"method\" fill(null)",
-          "rawQuery": true,
           "refId": "A",
           "resultFormat": "time_series",
           "select": [
@@ -2064,7 +2307,7 @@
               },
               {
                 "params": [],
-                "type": "count"
+                "type": "sum"
               }
             ]
           ],
@@ -2114,35 +2357,35 @@
     },
     {
       "aliasColors": {},
-      "bars": false,
+      "bars": true,
       "dashLength": 10,
       "dashes": false,
       "datasource": "${DS_INFLUXDB}",
-      "decimals": 2,
       "fill": 1,
       "fillGradient": 0,
       "gridPos": {
         "h": 9,
         "w": 12,
         "x": 12,
-        "y": 42
+        "y": 40
       },
       "id": 36,
-      "interval": "",
       "legend": {
         "alignAsTable": true,
-        "avg": true,
+        "avg": false,
         "current": false,
-        "max": true,
+        "hideEmpty": true,
+        "hideZero": true,
+        "max": false,
         "min": false,
         "rightSide": true,
         "show": true,
         "sort": "avg",
-        "sortDesc": true,
+        "sortDesc": false,
         "total": false,
-        "values": true
+        "values": false
       },
-      "lines": true,
+      "lines": false,
       "linewidth": 1,
       "nullPointMode": "null",
       "options": {
@@ -2166,6 +2409,12 @@
               ],
               "type": "time"
             },
+            {
+              "params": [
+                "method"
+              ],
+              "type": "tag"
+            },
             {
               "params": [
                 "exitcode"
@@ -2178,12 +2427,6 @@
               ],
               "type": "tag"
             },
-            {
-              "params": [
-                "method"
-              ],
-              "type": "tag"
-            },
             {
               "params": [
                 "null"
@@ -2194,7 +2437,7 @@
           "measurement": "chain.message_count",
           "orderByTime": "ASC",
           "policy": "default",
-          "query": "SELECT moving_average(count(\"value\"), 10) FROM \"chain.message_count\" WHERE $timeFilter -10m GROUP BY time($__interval), \"exitcode\", \"actor\", \"method\" fill(null)",
+          "query": "SELECT sum(\"value\") FROM \"chain.message_count\" WHERE $timeFilter GROUP BY time($__interval), \"method\", \"exitcode\", \"actor\" fill(null)",
           "rawQuery": true,
           "refId": "A",
           "resultFormat": "time_series",
@@ -2209,12 +2452,6 @@
               {
                 "params": [],
                 "type": "count"
-              },
-              {
-                "params": [
-                  10
-                ],
-                "type": "moving_average"
               }
             ]
           ],
@@ -2241,7 +2478,6 @@
       },
       "yaxes": [
         {
-          "decimals": null,
           "format": "short",
           "label": "",
           "logBase": 1,
@@ -2264,7 +2500,7 @@
       }
     }
   ],
-  "refresh": "30s",
+  "refresh": "45s",
   "schemaVersion": 20,
   "style": "dark",
   "tags": [],
@@ -2280,6 +2516,7 @@
       "5s",
       "10s",
       "30s",
+      "45s",
       "1m",
       "5m",
       "15m",
@@ -2292,5 +2529,5 @@
   "timezone": "",
   "title": "Chain",
   "uid": "z6FtI92Zz",
-  "version": 8
-}
\ No newline at end of file
+  "version": 9
+}
diff --git a/tools/stats/docker-compose.yml b/cmd/lotus-stats/docker-compose.yml
similarity index 100%
rename from tools/stats/docker-compose.yml
rename to cmd/lotus-stats/docker-compose.yml
diff --git a/tools/stats/env.stats b/cmd/lotus-stats/env.stats
similarity index 100%
rename from tools/stats/env.stats
rename to cmd/lotus-stats/env.stats
diff --git a/cmd/lotus-stats/main.go b/cmd/lotus-stats/main.go
new file mode 100644
index 000000000..3ca139b7d
--- /dev/null
+++ b/cmd/lotus-stats/main.go
@@ -0,0 +1,72 @@
+package main
+
+import (
+	"context"
+	"flag"
+	"os"
+
+	"github.com/filecoin-project/lotus/tools/stats"
+	logging "github.com/ipfs/go-log/v2"
+)
+
+var log = logging.Logger("stats")
+
+const (
+	influxAddrEnvVar = "INFLUX_ADDR"
+	influxUserEnvVar = "INFLUX_USER"
+	influxPassEnvVar = "INFLUX_PASS"
+)
+
+func main() {
+	var repo string = "~/.lotus"
+	var database string = "lotus"
+	var reset bool = false
+	var nosync bool = false
+	var height int64 = 0
+	var headlag int = 3
+
+	flag.StringVar(&repo, "repo", repo, "lotus repo path")
+	flag.StringVar(&database, "database", database, "influx database")
+	flag.Int64Var(&height, "height", height, "block height to start syncing from (0 will resume)")
+	flag.IntVar(&headlag, "head-lag", headlag, "number of head events to hold to protect against small reorgs")
+	flag.BoolVar(&reset, "reset", reset, "truncate database before starting stats gathering")
+	flag.BoolVar(&nosync, "nosync", nosync, "skip waiting for sync")
+
+	flag.Parse()
+
+	ctx := context.Background()
+
+	influx, err := stats.InfluxClient(os.Getenv(influxAddrEnvVar), os.Getenv(influxUserEnvVar), os.Getenv(influxPassEnvVar))
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	if reset {
+		if err := stats.ResetDatabase(influx, database); err != nil {
+			log.Fatal(err)
+		}
+	}
+
+	if !reset && height == 0 {
+		h, err := stats.GetLastRecordedHeight(influx, database)
+		if err != nil {
+			log.Info(err)
+		}
+
+		height = h
+	}
+
+	api, closer, err := stats.GetFullNodeAPI(ctx, repo)
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer closer()
+
+	if !nosync {
+		if err := stats.WaitForSyncComplete(ctx, api); err != nil {
+			log.Fatal(err)
+		}
+	}
+
+	stats.Collect(ctx, api, influx, database, height, headlag)
+}
diff --git a/tools/stats/setup.bash b/cmd/lotus-stats/setup.bash
similarity index 100%
rename from tools/stats/setup.bash
rename to cmd/lotus-stats/setup.bash
diff --git a/cmd/lotus-storage-miner/actor.go b/cmd/lotus-storage-miner/actor.go
new file mode 100644
index 000000000..ea21aa90d
--- /dev/null
+++ b/cmd/lotus-storage-miner/actor.go
@@ -0,0 +1,480 @@
+package main
+
+import (
+	"fmt"
+	"os"
+	"strings"
+
+	"github.com/fatih/color"
+	"github.com/libp2p/go-libp2p-core/peer"
+	ma "github.com/multiformats/go-multiaddr"
+	"github.com/urfave/cli/v2"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/big"
+
+	"github.com/filecoin-project/specs-actors/actors/builtin"
+	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
+
+	"github.com/filecoin-project/lotus/chain/actors"
+	"github.com/filecoin-project/lotus/chain/types"
+	lcli "github.com/filecoin-project/lotus/cli"
+	"github.com/filecoin-project/lotus/lib/tablewriter"
+	"github.com/filecoin-project/lotus/storage"
+)
+
+var actorCmd = &cli.Command{
+	Name:  "actor",
+	Usage: "manipulate the miner actor",
+	Subcommands: []*cli.Command{
+		actorSetAddrsCmd,
+		actorWithdrawCmd,
+		actorSetPeeridCmd,
+		actorControl,
+	},
+}
+
+var actorSetAddrsCmd = &cli.Command{
+	Name:  "set-addrs",
+	Usage: "set addresses that your miner can be publicly dialed on",
+	Flags: []cli.Flag{
+		&cli.Int64Flag{
+			Name:  "gas-limit",
+			Usage: "set gas limit",
+			Value: 0,
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		nodeAPI, closer, err := lcli.GetStorageMinerAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+
+		api, acloser, err := lcli.GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer acloser()
+
+		ctx := lcli.ReqContext(cctx)
+
+		var addrs []abi.Multiaddrs
+		for _, a := range cctx.Args().Slice() {
+			maddr, err := ma.NewMultiaddr(a)
+			if err != nil {
+				return fmt.Errorf("failed to parse %q as a multiaddr: %w", a, err)
+			}
+
+			maddrNop2p, strip := ma.SplitFunc(maddr, func(c ma.Component) bool {
+				return c.Protocol().Code == ma.P_P2P
+			})
+
+			if strip != nil {
+				fmt.Println("Stripping peerid ", strip, " from ", maddr)
+			}
+			addrs = append(addrs, maddrNop2p.Bytes())
+		}
+
+		maddr, err := nodeAPI.ActorAddress(ctx)
+		if err != nil {
+			return err
+		}
+
+		minfo, err := api.StateMinerInfo(ctx, maddr, types.EmptyTSK)
+		if err != nil {
+			return err
+		}
+
+		params, err := actors.SerializeParams(&miner0.ChangeMultiaddrsParams{NewMultiaddrs: addrs})
+		if err != nil {
+			return err
+		}
+
+		gasLimit := cctx.Int64("gas-limit")
+
+		smsg, err := api.MpoolPushMessage(ctx, &types.Message{
+			To:       maddr,
+			From:     minfo.Worker,
+			Value:    types.NewInt(0),
+			GasLimit: gasLimit,
+			Method:   builtin.MethodsMiner.ChangeMultiaddrs,
+			Params:   params,
+		}, nil)
+		if err != nil {
+			return err
+		}
+
+		fmt.Printf("Requested multiaddrs change in message %s\n", smsg.Cid())
+		return nil
+
+	},
+}
+
+var actorSetPeeridCmd = &cli.Command{
+	Name:  "set-peer-id",
+	Usage: "set the peer id of your miner",
+	Flags: []cli.Flag{
+		&cli.Int64Flag{
+			Name:  "gas-limit",
+			Usage: "set gas limit",
+			Value: 0,
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		nodeAPI, closer, err := lcli.GetStorageMinerAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+
+		api, acloser, err := lcli.GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer acloser()
+
+		ctx := lcli.ReqContext(cctx)
+
+		pid, err := peer.Decode(cctx.Args().Get(0))
+		if err != nil {
+			return fmt.Errorf("failed to parse input as a peerId: %w", err)
+		}
+
+		maddr, err := nodeAPI.ActorAddress(ctx)
+		if err != nil {
+			return err
+		}
+
+		minfo, err := api.StateMinerInfo(ctx, maddr, types.EmptyTSK)
+		if err != nil {
+			return err
+		}
+
+		params, err := actors.SerializeParams(&miner0.ChangePeerIDParams{NewID: abi.PeerID(pid)})
+		if err != nil {
+			return err
+		}
+
+		gasLimit := cctx.Int64("gas-limit")
+
+		smsg, err := api.MpoolPushMessage(ctx, &types.Message{
+			To:       maddr,
+			From:     minfo.Worker,
+			Value:    types.NewInt(0),
+			GasLimit: gasLimit,
+			Method:   builtin.MethodsMiner.ChangePeerID,
+			Params:   params,
+		}, nil)
+		if err != nil {
+			return err
+		}
+
+		fmt.Printf("Requested peerid change in message %s\n", smsg.Cid())
+		return nil
+
+	},
+}
+
+var actorWithdrawCmd = &cli.Command{
+	Name:      "withdraw",
+	Usage:     "withdraw available balance",
+	ArgsUsage: "[amount (FIL)]",
+	Action: func(cctx *cli.Context) error {
+		nodeApi, closer, err := lcli.GetStorageMinerAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+
+		api, acloser, err := lcli.GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer acloser()
+
+		ctx := lcli.ReqContext(cctx)
+
+		maddr, err := nodeApi.ActorAddress(ctx)
+		if err != nil {
+			return err
+		}
+
+		mi, err := api.StateMinerInfo(ctx, maddr, types.EmptyTSK)
+		if err != nil {
+			return err
+		}
+
+		available, err := api.StateMinerAvailableBalance(ctx, maddr, types.EmptyTSK)
+		if err != nil {
+			return err
+		}
+
+		amount := available
+		if cctx.Args().Present() {
+			f, err := types.ParseFIL(cctx.Args().First())
+			if err != nil {
+				return xerrors.Errorf("parsing 'amount' argument: %w", err)
+			}
+
+			amount = abi.TokenAmount(f)
+
+			if amount.GreaterThan(available) {
+				return xerrors.Errorf("can't withdraw more funds than available; requested: %s; available: %s", amount, available)
+			}
+		}
+
+		params, err := actors.SerializeParams(&miner0.WithdrawBalanceParams{
+			AmountRequested: amount, // Default to attempting to withdraw all the extra funds in the miner actor
+		})
+		if err != nil {
+			return err
+		}
+
+		smsg, err := api.MpoolPushMessage(ctx, &types.Message{
+			To:     maddr,
+			From:   mi.Owner,
+			Value:  types.NewInt(0),
+			Method: builtin.MethodsMiner.WithdrawBalance,
+			Params: params,
+		}, nil)
+		if err != nil {
+			return err
+		}
+
+		fmt.Printf("Requested rewards withdrawal in message %s\n", smsg.Cid())
+
+		return nil
+	},
+}
+
+var actorControl = &cli.Command{
+	Name:  "control",
+	Usage: "Manage control addresses",
+	Subcommands: []*cli.Command{
+		actorControlList,
+		actorControlSet,
+	},
+}
+
+var actorControlList = &cli.Command{
+	Name:  "list",
+	Usage: "Get currently set control addresses",
+	Flags: []cli.Flag{
+		&cli.BoolFlag{
+			Name: "verbose",
+		},
+		&cli.BoolFlag{
+			Name:  "color",
+			Value: true,
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		color.NoColor = !cctx.Bool("color")
+
+		nodeApi, closer, err := lcli.GetStorageMinerAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+
+		api, acloser, err := lcli.GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer acloser()
+
+		ctx := lcli.ReqContext(cctx)
+
+		maddr, err := nodeApi.ActorAddress(ctx)
+		if err != nil {
+			return err
+		}
+
+		mi, err := api.StateMinerInfo(ctx, maddr, types.EmptyTSK)
+		if err != nil {
+			return err
+		}
+
+		tw := tablewriter.New(
+			tablewriter.Col("name"),
+			tablewriter.Col("ID"),
+			tablewriter.Col("key"),
+			tablewriter.Col("use"),
+			tablewriter.Col("balance"),
+		)
+
+		postAddr, err := storage.AddressFor(ctx, api, mi, storage.PoStAddr, types.FromFil(1))
+		if err != nil {
+			return xerrors.Errorf("getting address for post: %w", err)
+		}
+
+		printKey := func(name string, a address.Address) {
+			b, err := api.WalletBalance(ctx, a)
+			if err != nil {
+				fmt.Printf("%s\t%s: error getting balance: %s\n", name, a, err)
+				return
+			}
+
+			k, err := api.StateAccountKey(ctx, a, types.EmptyTSK)
+			if err != nil {
+				fmt.Printf("%s\t%s: error getting account key: %s\n", name, a, err)
+				return
+			}
+
+			kstr := k.String()
+			if !cctx.Bool("verbose") {
+				kstr = kstr[:9] + "..."
+			}
+
+			bstr := types.FIL(b).String()
+			switch {
+			case b.LessThan(types.FromFil(10)):
+				bstr = color.RedString(bstr)
+			case b.LessThan(types.FromFil(50)):
+				bstr = color.YellowString(bstr)
+			default:
+				bstr = color.GreenString(bstr)
+			}
+
+			var uses []string
+			if a == mi.Worker {
+				uses = append(uses, color.YellowString("other"))
+			}
+			if a == postAddr {
+				uses = append(uses, color.GreenString("post"))
+			}
+
+			tw.Write(map[string]interface{}{
+				"name":    name,
+				"ID":      a,
+				"key":     kstr,
+				"use":     strings.Join(uses, " "),
+				"balance": bstr,
+			})
+		}
+
+		printKey("owner", mi.Owner)
+		printKey("worker", mi.Worker)
+		for i, ca := range mi.ControlAddresses {
+			printKey(fmt.Sprintf("control-%d", i), ca)
+		}
+
+		return tw.Flush(os.Stdout)
+	},
+}
+
+var actorControlSet = &cli.Command{
+	Name:      "set",
+	Usage:     "Set control address(-es)",
+	ArgsUsage: "[...address]",
+	Flags: []cli.Flag{
+		&cli.BoolFlag{
+			Name:  "really-do-it",
+			Usage: "Actually send transaction performing the action",
+			Value: false,
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		nodeApi, closer, err := lcli.GetStorageMinerAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+
+		api, acloser, err := lcli.GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer acloser()
+
+		ctx := lcli.ReqContext(cctx)
+
+		maddr, err := nodeApi.ActorAddress(ctx)
+		if err != nil {
+			return err
+		}
+
+		mi, err := api.StateMinerInfo(ctx, maddr, types.EmptyTSK)
+		if err != nil {
+			return err
+		}
+
+		del := map[address.Address]struct{}{}
+		existing := map[address.Address]struct{}{}
+		for _, controlAddress := range mi.ControlAddresses {
+			ka, err := api.StateAccountKey(ctx, controlAddress, types.EmptyTSK)
+			if err != nil {
+				return err
+			}
+
+			del[ka] = struct{}{}
+			existing[ka] = struct{}{}
+		}
+
+		var toSet []address.Address
+
+		for i, as := range cctx.Args().Slice() {
+			a, err := address.NewFromString(as)
+			if err != nil {
+				return xerrors.Errorf("parsing address %d: %w", i, err)
+			}
+
+			ka, err := api.StateAccountKey(ctx, a, types.EmptyTSK)
+			if err != nil {
+				return err
+			}
+
+			// make sure the address exists on chain
+			_, err = api.StateLookupID(ctx, ka, types.EmptyTSK)
+			if err != nil {
+				return xerrors.Errorf("looking up %s: %w", ka, err)
+			}
+
+			delete(del, ka)
+			toSet = append(toSet, ka)
+		}
+
+		for a := range del {
+			fmt.Println("Remove", a)
+		}
+		for _, a := range toSet {
+			if _, exists := existing[a]; !exists {
+				fmt.Println("Add", a)
+			}
+		}
+
+		if !cctx.Bool("really-do-it") {
+			fmt.Println("Pass --really-do-it to actually execute this action")
+			return nil
+		}
+
+		cwp := &miner0.ChangeWorkerAddressParams{
+			NewWorker:       mi.Worker,
+			NewControlAddrs: toSet,
+		}
+
+		sp, err := actors.SerializeParams(cwp)
+		if err != nil {
+			return xerrors.Errorf("serializing params: %w", err)
+		}
+
+		smsg, err := api.MpoolPushMessage(ctx, &types.Message{
+			From:   mi.Owner,
+			To:     maddr,
+			Method: builtin.MethodsMiner.ChangeWorkerAddress,
+
+			Value:  big.Zero(),
+			Params: sp,
+		}, nil)
+		if err != nil {
+			return xerrors.Errorf("mpool push: %w", err)
+		}
+
+		fmt.Println("Message CID:", smsg.Cid())
+
+		return nil
+	},
+}
diff --git a/cmd/lotus-storage-miner/config.go b/cmd/lotus-storage-miner/config.go
new file mode 100644
index 000000000..e5e4fc4c4
--- /dev/null
+++ b/cmd/lotus-storage-miner/config.go
@@ -0,0 +1,22 @@
+package main
+
+import (
+	"fmt"
+
+	"github.com/urfave/cli/v2"
+
+	"github.com/filecoin-project/lotus/node/config"
+)
+
+var configCmd = &cli.Command{
+	Name:  "config",
+	Usage: "Output default configuration",
+	Action: func(cctx *cli.Context) error {
+		comm, err := config.ConfigComment(config.DefaultStorageMiner())
+		if err != nil {
+			return err
+		}
+		fmt.Println(string(comm))
+		return nil
+	},
+}
diff --git a/cmd/lotus-storage-miner/info.go b/cmd/lotus-storage-miner/info.go
index a7c8b0d58..3ccfd67da 100644
--- a/cmd/lotus-storage-miner/info.go
+++ b/cmd/lotus-storage-miner/info.go
@@ -3,137 +3,298 @@ package main
 import (
 	"context"
 	"fmt"
+	"sort"
+	"time"
 
-	"gopkg.in/urfave/cli.v2"
+	"github.com/fatih/color"
+	"github.com/urfave/cli/v2"
+	"golang.org/x/xerrors"
+
+	cbor "github.com/ipfs/go-ipld-cbor"
+
+	"github.com/filecoin-project/go-fil-markets/storagemarket"
+	"github.com/filecoin-project/go-state-types/abi"
+	sealing "github.com/filecoin-project/lotus/extern/storage-sealing"
 
 	"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/miner"
 	"github.com/filecoin-project/lotus/chain/types"
 	lcli "github.com/filecoin-project/lotus/cli"
+	"github.com/filecoin-project/lotus/lib/blockstore"
+	"github.com/filecoin-project/lotus/lib/bufbstore"
 )
 
 var infoCmd = &cli.Command{
 	Name:  "info",
-	Usage: "Print storage miner info",
-	Action: func(cctx *cli.Context) error {
-		nodeApi, closer, err := lcli.GetStorageMinerAPI(cctx)
-		if err != nil {
-			return err
-		}
-		defer closer()
-
-		api, acloser, err := lcli.GetFullNodeAPI(cctx)
-		if err != nil {
-			return err
-		}
-		defer acloser()
-
-		ctx := lcli.ReqContext(cctx)
-
-		maddr, err := nodeApi.ActorAddress(ctx)
-		if err != nil {
-			return err
-		}
-
-		fmt.Printf("Miner: %s\n", maddr)
-
-		// Sector size
-		sizeByte, err := api.StateMinerSectorSize(ctx, maddr, nil)
-		if err != nil {
-			return err
-		}
-
-		fmt.Printf("Sector Size: %s\n", types.NewInt(sizeByte).SizeStr())
-
-		pow, err := api.StateMinerPower(ctx, maddr, nil)
-		if err != nil {
-			return err
-		}
-
-		percI := types.BigDiv(types.BigMul(pow.MinerPower, types.NewInt(1000)), pow.TotalPower)
-		fmt.Printf("Power: %s / %s (%0.4f%%)\n", pow.MinerPower.SizeStr(), pow.TotalPower.SizeStr(), float64(percI.Int64())/100000*10000)
-
-		secCounts, err := api.StateMinerSectorCount(ctx, maddr, nil)
-		if err != nil {
-			return err
-		}
-		fmt.Printf("\tCommitted: %s\n", types.BigMul(types.NewInt(secCounts.Sset), types.NewInt(sizeByte)).SizeStr())
-		fmt.Printf("\tProving: %s\n", types.BigMul(types.NewInt(secCounts.Pset), types.NewInt(sizeByte)).SizeStr())
-
-		// TODO: indicate whether the post worker is in use
-		wstat, err := nodeApi.WorkerStats(ctx)
-		if err != nil {
-			return err
-		}
-
-		fmt.Printf("Worker use:\n")
-		fmt.Printf("\tLocal: %d / %d (+%d reserved)\n", wstat.LocalTotal-wstat.LocalReserved-wstat.LocalFree, wstat.LocalTotal-wstat.LocalReserved, wstat.LocalReserved)
-		fmt.Printf("\tRemote: %d / %d\n", wstat.RemotesTotal-wstat.RemotesFree, wstat.RemotesTotal)
-
-		fmt.Printf("Queues:\n")
-		fmt.Printf("\tAddPiece: %d\n", wstat.AddPieceWait)
-		fmt.Printf("\tPreCommit: %d\n", wstat.PreCommitWait)
-		fmt.Printf("\tCommit: %d\n", wstat.CommitWait)
-		fmt.Printf("\tUnseal: %d\n", wstat.UnsealWait)
-
-		eps, err := api.StateMinerElectionPeriodStart(ctx, maddr, nil)
-		if err != nil {
-			return err
-		}
-		if eps != 0 {
-			head, err := api.ChainHead(ctx)
-			if err != nil {
-				return err
-			}
-			lastEps := int64(head.Height() - eps)
-			lastEpsS := lastEps * build.BlockDelay
-
-			fallback := lastEps + build.FallbackPoStDelay
-			fallbackS := fallback * build.BlockDelay
-
-			next := lastEps + build.SlashablePowerDelay
-			nextS := next * build.BlockDelay
-
-			fmt.Printf("PoSt Submissions:\n")
-			fmt.Printf("\tPrevious: Epoch %d (%d block(s), ~%dm %ds ago)\n", eps, lastEps, lastEpsS/60, lastEpsS%60)
-			fmt.Printf("\tFallback: Epoch %d (in %d blocks, ~%dm %ds)\n", eps+build.FallbackPoStDelay, fallback, fallbackS/60, fallbackS%60)
-			fmt.Printf("\tDeadline: Epoch %d (in %d blocks, ~%dm %ds)\n", eps+build.SlashablePowerDelay, next, nextS/60, nextS%60)
-
-		} else {
-			fmt.Printf("Proving Period: Not Proving\n")
-		}
-
-		sinfo, err := sectorsInfo(ctx, nodeApi)
-		if err != nil {
-			return err
-		}
-
-		fmt.Println("Sectors: ", sinfo)
-
-		// TODO: grab actr state / info
-		//  * Sealed sectors (count / bytes)
-		//  * Power
-		return nil
+	Usage: "Print miner info",
+	Subcommands: []*cli.Command{
+		infoAllCmd,
 	},
+	Action: infoCmdAct,
 }
 
-func sectorsInfo(ctx context.Context, napi api.StorageMiner) (map[string]int, error) {
-	sectors, err := napi.SectorsList(ctx)
+func infoCmdAct(cctx *cli.Context) error {
+	color.NoColor = !cctx.Bool("color")
+
+	nodeApi, closer, err := lcli.GetStorageMinerAPI(cctx)
 	if err != nil {
-		return nil, err
+		return err
+	}
+	defer closer()
+
+	api, acloser, err := lcli.GetFullNodeAPI(cctx)
+	if err != nil {
+		return err
+	}
+	defer acloser()
+
+	ctx := lcli.ReqContext(cctx)
+
+	maddr, err := getActorAddress(ctx, nodeApi, cctx.String("actor"))
+	if err != nil {
+		return err
 	}
 
-	out := map[string]int{
+	mact, err := api.StateGetActor(ctx, maddr, types.EmptyTSK)
+	if err != nil {
+		return err
+	}
+
+	tbs := bufbstore.NewTieredBstore(apibstore.NewAPIBlockstore(api), blockstore.NewTemporary())
+	mas, err := miner.Load(adt.WrapStore(ctx, cbor.NewCborStore(tbs)), mact)
+	if err != nil {
+		return err
+	}
+
+	fmt.Printf("Miner: %s\n", color.BlueString("%s", maddr))
+
+	// Sector size
+	mi, err := api.StateMinerInfo(ctx, maddr, types.EmptyTSK)
+	if err != nil {
+		return err
+	}
+
+	fmt.Printf("Sector Size: %s\n", types.SizeStr(types.NewInt(uint64(mi.SectorSize))))
+
+	pow, err := api.StateMinerPower(ctx, maddr, types.EmptyTSK)
+	if err != nil {
+		return err
+	}
+
+	rpercI := types.BigDiv(types.BigMul(pow.MinerPower.RawBytePower, types.NewInt(1000000)), pow.TotalPower.RawBytePower)
+	qpercI := types.BigDiv(types.BigMul(pow.MinerPower.QualityAdjPower, types.NewInt(1000000)), pow.TotalPower.QualityAdjPower)
+
+	fmt.Printf("Byte Power:   %s / %s (%0.4f%%)\n",
+		color.BlueString(types.SizeStr(pow.MinerPower.RawBytePower)),
+		types.SizeStr(pow.TotalPower.RawBytePower),
+		float64(rpercI.Int64())/10000)
+
+	fmt.Printf("Actual Power: %s / %s (%0.4f%%)\n",
+		color.GreenString(types.DeciStr(pow.MinerPower.QualityAdjPower)),
+		types.DeciStr(pow.TotalPower.QualityAdjPower),
+		float64(qpercI.Int64())/10000)
+
+	secCounts, err := api.StateMinerSectorCount(ctx, maddr, types.EmptyTSK)
+	if err != nil {
+		return err
+	}
+
+	proving := secCounts.Active + secCounts.Faulty
+	nfaults := secCounts.Faulty
+	fmt.Printf("\tCommitted: %s\n", types.SizeStr(types.BigMul(types.NewInt(secCounts.Live), types.NewInt(uint64(mi.SectorSize)))))
+	if nfaults == 0 {
+		fmt.Printf("\tProving: %s\n", types.SizeStr(types.BigMul(types.NewInt(proving), types.NewInt(uint64(mi.SectorSize)))))
+	} else {
+		var faultyPercentage float64
+		if secCounts.Live != 0 {
+			faultyPercentage = float64(10000*nfaults/secCounts.Live) / 100.
+		}
+		fmt.Printf("\tProving: %s (%s Faulty, %.2f%%)\n",
+			types.SizeStr(types.BigMul(types.NewInt(proving), types.NewInt(uint64(mi.SectorSize)))),
+			types.SizeStr(types.BigMul(types.NewInt(nfaults), types.NewInt(uint64(mi.SectorSize)))),
+			faultyPercentage)
+	}
+
+	if !pow.HasMinPower {
+		fmt.Print("Below minimum power threshold, no blocks will be won")
+	} else {
+		expWinChance := float64(types.BigMul(qpercI, types.NewInt(build.BlocksPerEpoch)).Int64()) / 1000000
+		if expWinChance > 0 {
+			if expWinChance > 1 {
+				expWinChance = 1
+			}
+			winRate := time.Duration(float64(time.Second*time.Duration(build.BlockDelaySecs)) / expWinChance)
+			winPerDay := float64(time.Hour*24) / float64(winRate)
+
+			fmt.Print("Expected block win rate: ")
+			color.Blue("%.4f/day (every %s)", winPerDay, winRate.Truncate(time.Second))
+		}
+	}
+
+	fmt.Println()
+
+	deals, err := nodeApi.MarketListIncompleteDeals(ctx)
+	if err != nil {
+		return err
+	}
+
+	var nactiveDeals, nVerifDeals, ndeals uint64
+	var activeDealBytes, activeVerifDealBytes, dealBytes abi.PaddedPieceSize
+	for _, deal := range deals {
+		ndeals++
+		dealBytes += deal.Proposal.PieceSize
+
+		if deal.State == storagemarket.StorageDealActive {
+			nactiveDeals++
+			activeDealBytes += deal.Proposal.PieceSize
+
+			if deal.Proposal.VerifiedDeal {
+				nVerifDeals++
+				activeVerifDealBytes += deal.Proposal.PieceSize
+			}
+		}
+	}
+
+	fmt.Printf("Deals: %d, %s\n", ndeals, types.SizeStr(types.NewInt(uint64(dealBytes))))
+	fmt.Printf("\tActive: %d, %s (Verified: %d, %s)\n", nactiveDeals, types.SizeStr(types.NewInt(uint64(activeDealBytes))), nVerifDeals, types.SizeStr(types.NewInt(uint64(activeVerifDealBytes))))
+	fmt.Println()
+
+	// NOTE: there's no need to unlock anything here. Funds only
+	// vest on deadline boundaries, and they're unlocked by cron.
+	lockedFunds, err := mas.LockedFunds()
+	if err != nil {
+		return xerrors.Errorf("getting locked funds: %w", err)
+	}
+	availBalance, err := mas.AvailableBalance(mact.Balance)
+	if err != nil {
+		return xerrors.Errorf("getting available balance: %w", err)
+	}
+	fmt.Printf("Miner Balance: %s\n", color.YellowString("%s", types.FIL(mact.Balance)))
+	fmt.Printf("\tPreCommit:   %s\n", types.FIL(lockedFunds.PreCommitDeposits))
+	fmt.Printf("\tPledge:      %s\n", types.FIL(lockedFunds.InitialPledgeRequirement))
+	fmt.Printf("\tVesting:     %s\n", types.FIL(lockedFunds.VestingFunds))
+	color.Green("\tAvailable:   %s", types.FIL(availBalance))
+	wb, err := api.WalletBalance(ctx, mi.Worker)
+	if err != nil {
+		return xerrors.Errorf("getting worker balance: %w", err)
+	}
+	color.Cyan("Worker Balance: %s", types.FIL(wb))
+
+	mb, err := api.StateMarketBalance(ctx, maddr, types.EmptyTSK)
+	if err != nil {
+		return xerrors.Errorf("getting market balance: %w", err)
+	}
+	fmt.Printf("Market (Escrow):  %s\n", types.FIL(mb.Escrow))
+	fmt.Printf("Market (Locked):  %s\n", types.FIL(mb.Locked))
+
+	fmt.Println()
+
+	sealdur, err := nodeApi.SectorGetExpectedSealDuration(ctx)
+	if err != nil {
+		return err
+	}
+
+	fmt.Printf("Expected Seal Duration: %s\n\n", sealdur)
+
+	fmt.Println("Sectors:")
+	err = sectorsInfo(ctx, nodeApi)
+	if err != nil {
+		return err
+	}
+
+	// TODO: grab actr state / info
+	//  * Sealed sectors (count / bytes)
+	//  * Power
+	return nil
+}
+
+type stateMeta struct {
+	i     int
+	col   color.Attribute
+	state sealing.SectorState
+}
+
+var stateOrder = map[sealing.SectorState]stateMeta{}
+var stateList = []stateMeta{
+	{col: 39, state: "Total"},
+	{col: color.FgGreen, state: sealing.Proving},
+
+	{col: color.FgBlue, state: sealing.Empty},
+	{col: color.FgBlue, state: sealing.WaitDeals},
+
+	{col: color.FgRed, state: sealing.UndefinedSectorState},
+	{col: color.FgYellow, state: sealing.Packing},
+	{col: color.FgYellow, state: sealing.PreCommit1},
+	{col: color.FgYellow, state: sealing.PreCommit2},
+	{col: color.FgYellow, state: sealing.PreCommitting},
+	{col: color.FgYellow, state: sealing.PreCommitWait},
+	{col: color.FgYellow, state: sealing.WaitSeed},
+	{col: color.FgYellow, state: sealing.Committing},
+	{col: color.FgYellow, state: sealing.SubmitCommit},
+	{col: color.FgYellow, state: sealing.CommitWait},
+	{col: color.FgYellow, state: sealing.FinalizeSector},
+
+	{col: color.FgCyan, state: sealing.Removing},
+	{col: color.FgCyan, state: sealing.Removed},
+
+	{col: color.FgRed, state: sealing.FailedUnrecoverable},
+	{col: color.FgRed, state: sealing.SealPreCommit1Failed},
+	{col: color.FgRed, state: sealing.SealPreCommit2Failed},
+	{col: color.FgRed, state: sealing.PreCommitFailed},
+	{col: color.FgRed, state: sealing.ComputeProofFailed},
+	{col: color.FgRed, state: sealing.CommitFailed},
+	{col: color.FgRed, state: sealing.PackingFailed},
+	{col: color.FgRed, state: sealing.FinalizeFailed},
+	{col: color.FgRed, state: sealing.Faulty},
+	{col: color.FgRed, state: sealing.FaultReported},
+	{col: color.FgRed, state: sealing.FaultedFinal},
+	{col: color.FgRed, state: sealing.RemoveFailed},
+	{col: color.FgRed, state: sealing.DealsExpired},
+	{col: color.FgRed, state: sealing.RecoverDealIDs},
+}
+
+func init() {
+	for i, state := range stateList {
+		stateOrder[state.state] = stateMeta{
+			i:   i,
+			col: state.col,
+		}
+	}
+}
+
+func sectorsInfo(ctx context.Context, napi api.StorageMiner) error {
+	sectors, err := napi.SectorsList(ctx)
+	if err != nil {
+		return err
+	}
+
+	buckets := map[sealing.SectorState]int{
 		"Total": len(sectors),
 	}
 	for _, s := range sectors {
-		st, err := napi.SectorsStatus(ctx, s)
+		st, err := napi.SectorsStatus(ctx, s, false)
 		if err != nil {
-			return nil, err
+			return err
 		}
 
-		out[api.SectorStates[st.State]]++
+		buckets[sealing.SectorState(st.State)]++
 	}
 
-	return out, nil
+	var sorted []stateMeta
+	for state, i := range buckets {
+		sorted = append(sorted, stateMeta{i: i, state: state})
+	}
+
+	sort.Slice(sorted, func(i, j int) bool {
+		return stateOrder[sorted[i].state].i < stateOrder[sorted[j].state].i
+	})
+
+	for _, s := range sorted {
+		_, _ = color.New(stateOrder[s.state].col).Printf("\t%s: %d\n", s.state, s.i)
+	}
+
+	return nil
 }
diff --git a/cmd/lotus-storage-miner/info_all.go b/cmd/lotus-storage-miner/info_all.go
new file mode 100644
index 000000000..265ba78a4
--- /dev/null
+++ b/cmd/lotus-storage-miner/info_all.go
@@ -0,0 +1,160 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+	"sort"
+
+	"github.com/urfave/cli/v2"
+
+	lcli "github.com/filecoin-project/lotus/cli"
+)
+
+var infoAllCmd = &cli.Command{
+	Name:  "all",
+	Usage: "dump all related miner info",
+	Action: func(cctx *cli.Context) error {
+		nodeApi, closer, err := lcli.GetStorageMinerAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+
+		api, acloser, err := lcli.GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer acloser()
+		_ = api
+
+		ctx := lcli.ReqContext(cctx)
+
+		// Top-level info
+
+		fmt.Println("#: Version")
+		if err := lcli.VersionCmd.Action(cctx); err != nil {
+			return err
+		}
+
+		fmt.Println("\n#: Miner Info")
+		if err := infoCmdAct(cctx); err != nil {
+			return err
+		}
+
+		// Verbose info
+
+		fmt.Println("\n#: Storage List")
+		if err := storageListCmd.Action(cctx); err != nil {
+			return err
+		}
+
+		fmt.Println("\n#: Worker List")
+		if err := sealingWorkersCmd.Action(cctx); err != nil {
+			return err
+		}
+
+		fmt.Println("\n#: PeerID")
+		if err := lcli.NetId.Action(cctx); err != nil {
+			return err
+		}
+
+		fmt.Println("\n#: Listen Addresses")
+		if err := lcli.NetListen.Action(cctx); err != nil {
+			return err
+		}
+
+		fmt.Println("\n#: Reachability")
+		if err := lcli.NetReachability.Action(cctx); err != nil {
+			return err
+		}
+
+		// Very Verbose info
+		fmt.Println("\n#: Peers")
+		if err := lcli.NetPeers.Action(cctx); err != nil {
+			return err
+		}
+
+		fmt.Println("\n#: Sealing Jobs")
+		if err := sealingJobsCmd.Action(cctx); err != nil {
+			return err
+		}
+
+		fmt.Println("\n#: Sched Diag")
+		if err := sealingSchedDiagCmd.Action(cctx); err != nil {
+			return err
+		}
+
+		fmt.Println("\n#: Storage Ask")
+		if err := getAskCmd.Action(cctx); err != nil {
+			return err
+		}
+
+		fmt.Println("\n#: Storage Deals")
+		if err := dealsListCmd.Action(cctx); err != nil {
+			return err
+		}
+
+		fmt.Println("\n#: Retrieval Deals")
+		if err := retrievalDealsListCmd.Action(cctx); err != nil {
+			return err
+		}
+
+		fmt.Println("\n#: Sector List")
+		if err := sectorsListCmd.Action(cctx); err != nil {
+			return err
+		}
+
+		fmt.Println("\n#: Sector Refs")
+		if err := sectorsRefsCmd.Action(cctx); err != nil {
+			return err
+		}
+
+		// Very Very Verbose info
+		fmt.Println("\n#: Per Sector Info")
+
+		list, err := nodeApi.SectorsList(ctx)
+		if err != nil {
+			return err
+		}
+
+		sort.Slice(list, func(i, j int) bool {
+			return list[i] < list[j]
+		})
+
+		for _, s := range list {
+			fmt.Printf("\n##: Sector %d Status\n", s)
+
+			fs := &flag.FlagSet{}
+			for _, f := range sectorsStatusCmd.Flags {
+				if err := f.Apply(fs); err != nil {
+					return err
+				}
+			}
+			if err := fs.Parse([]string{"--log", "--on-chain-info", fmt.Sprint(s)}); err != nil {
+				return err
+			}
+
+			if err := sectorsStatusCmd.Action(cli.NewContext(cctx.App, fs, cctx)); err != nil {
+				return err
+			}
+
+			fmt.Printf("\n##: Sector %d Storage Location\n", s)
+
+			fs = &flag.FlagSet{}
+			if err := fs.Parse([]string{fmt.Sprint(s)}); err != nil {
+				return err
+			}
+
+			if err := storageFindCmd.Action(cli.NewContext(cctx.App, fs, cctx)); err != nil {
+				return err
+			}
+		}
+
+		fmt.Println("\n#: Goroutines")
+		if err := lcli.PprofGoroutines.Action(cctx); err != nil {
+			return err
+		}
+
+		return nil
+	},
+}
diff --git a/cmd/lotus-storage-miner/init.go b/cmd/lotus-storage-miner/init.go
index 3e16e18e9..4faf6a25b 100644
--- a/cmd/lotus-storage-miner/init.go
+++ b/cmd/lotus-storage-miner/init.go
@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"context"
 	"crypto/rand"
+	"encoding/binary"
 	"encoding/json"
 	"fmt"
 	"io/ioutil"
@@ -11,26 +12,40 @@ import (
 	"path/filepath"
 	"strconv"
 
-	paramfetch "github.com/filecoin-project/go-paramfetch"
+	"github.com/filecoin-project/go-state-types/big"
+
+	"github.com/docker/go-units"
+	"github.com/google/uuid"
 	"github.com/ipfs/go-datastore"
-	"github.com/ipfs/go-datastore/namespace"
-	badger "github.com/ipfs/go-ds-badger"
 	"github.com/libp2p/go-libp2p-core/crypto"
 	"github.com/libp2p/go-libp2p-core/peer"
 	"github.com/mitchellh/go-homedir"
+	"github.com/urfave/cli/v2"
 	"golang.org/x/xerrors"
-	"gopkg.in/urfave/cli.v2"
 
 	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-cbor-util"
-	"github.com/filecoin-project/go-sectorbuilder"
+	cborutil "github.com/filecoin-project/go-cbor-util"
+	paramfetch "github.com/filecoin-project/go-paramfetch"
+	"github.com/filecoin-project/go-state-types/abi"
+	crypto2 "github.com/filecoin-project/go-state-types/crypto"
+	sectorstorage "github.com/filecoin-project/lotus/extern/sector-storage"
+	"github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper"
+	"github.com/filecoin-project/lotus/extern/sector-storage/stores"
+
+	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
+	market0 "github.com/filecoin-project/specs-actors/actors/builtin/market"
+	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
+	power0 "github.com/filecoin-project/specs-actors/actors/builtin/power"
+
 	lapi "github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain/actors"
-	"github.com/filecoin-project/lotus/chain/deals"
+	"github.com/filecoin-project/lotus/chain/gen/slashfilter"
 	"github.com/filecoin-project/lotus/chain/types"
 	lcli "github.com/filecoin-project/lotus/cli"
+	sealing "github.com/filecoin-project/lotus/extern/storage-sealing"
 	"github.com/filecoin-project/lotus/genesis"
+	"github.com/filecoin-project/lotus/journal"
 	"github.com/filecoin-project/lotus/miner"
 	"github.com/filecoin-project/lotus/node/modules"
 	"github.com/filecoin-project/lotus/node/modules/dtypes"
@@ -40,7 +55,7 @@ import (
 
 var initCmd = &cli.Command{
 	Name:  "init",
-	Usage: "Initialize a lotus storage miner repo",
+	Usage: "Initialize a lotus miner repo",
 	Flags: []cli.Flag{
 		&cli.StringFlag{
 			Name:  "actor",
@@ -65,15 +80,19 @@ var initCmd = &cli.Command{
 			Aliases: []string{"o"},
 			Usage:   "owner key to use",
 		},
-		&cli.Uint64Flag{
+		&cli.StringFlag{
 			Name:  "sector-size",
 			Usage: "specify sector size to use",
-			Value: build.SectorSizes[0],
+			Value: units.BytesSize(float64(build.DefaultSectorSize())),
 		},
-		&cli.StringFlag{
+		&cli.StringSliceFlag{
 			Name:  "pre-sealed-sectors",
 			Usage: "specify set of presealed sectors for starting as a genesis miner",
 		},
+		&cli.StringFlag{
+			Name:  "pre-sealed-metadata",
+			Usage: "specify the metadata file for the presealed sectors",
+		},
 		&cli.BoolFlag{
 			Name:  "nosync",
 			Usage: "don't check full-node sync status",
@@ -82,19 +101,44 @@ var initCmd = &cli.Command{
 			Name:  "symlink-imported-sectors",
 			Usage: "attempt to symlink to presealed sectors instead of copying them into place",
 		},
+		&cli.BoolFlag{
+			Name:  "no-local-storage",
+			Usage: "don't use storageminer repo for sector storage",
+		},
+		&cli.StringFlag{
+			Name:  "gas-premium",
+			Usage: "set gas premium for initialization messages in AttoFIL",
+			Value: "0",
+		},
+		&cli.StringFlag{
+			Name:  "from",
+			Usage: "select which address to send actor creation message from",
+		},
 	},
 	Action: func(cctx *cli.Context) error {
-		log.Info("Initializing lotus storage miner")
+		log.Info("Initializing lotus miner")
 
-		ssize := cctx.Uint64("sector-size")
+		sectorSizeInt, err := units.RAMInBytes(cctx.String("sector-size"))
+		if err != nil {
+			return err
+		}
+		ssize := abi.SectorSize(sectorSizeInt)
+
+		gasPrice, err := types.BigFromString(cctx.String("gas-premium"))
+		if err != nil {
+			return xerrors.Errorf("failed to parse gas-price flag: %s", err)
+		}
 
 		symlink := cctx.Bool("symlink-imported-sectors")
 		if symlink {
 			log.Info("will attempt to symlink to imported sectors")
 		}
 
+		ctx := lcli.ReqContext(cctx)
+
 		log.Info("Checking proof parameters")
-		if err := paramfetch.GetParams(build.ParametersJson, ssize); err != nil {
+
+		if err := paramfetch.GetParams(ctx, build.ParametersJSON(), uint64(ssize)); err != nil {
 			return xerrors.Errorf("fetching proof parameters: %w", err)
 		}
 
@@ -105,7 +149,6 @@ var initCmd = &cli.Command{
 			return err
 		}
 		defer closer()
-		ctx := lcli.ReqContext(cctx)
 
 		log.Info("Checking full node sync status")
 
@@ -117,7 +160,7 @@ var initCmd = &cli.Command{
 
 		log.Info("Checking if repo exists")
 
-		repoPath := cctx.String(FlagStorageRepo)
+		repoPath := cctx.String(FlagMinerRepo)
 		r, err := repo.NewFS(repoPath)
 		if err != nil {
 			return err
@@ -128,7 +171,7 @@ var initCmd = &cli.Command{
 			return err
 		}
 		if ok {
-			return xerrors.Errorf("repo at '%s' is already initialized", cctx.String(FlagStorageRepo))
+			return xerrors.Errorf("repo at '%s' is already initialized", cctx.String(FlagMinerRepo))
 		}
 
 		log.Info("Checking full node version")
@@ -138,8 +181,8 @@ var initCmd = &cli.Command{
 			return err
 		}
 
-		if !v.APIVersion.EqMajorMinor(build.APIVersion) {
-			return xerrors.Errorf("Remote API version didn't match (local %s, remote %s)", build.APIVersion, v.APIVersion)
+		if !v.APIVersion.EqMajorMinor(build.FullAPIVersion) {
+			return xerrors.Errorf("Remote API version didn't match (expected %s, remote %s)", build.FullAPIVersion, v.APIVersion)
 		}
 
 		log.Info("Initializing repo")
@@ -148,57 +191,61 @@ var initCmd = &cli.Command{
 			return err
 		}
 
-		if pssb := cctx.String("pre-sealed-sectors"); pssb != "" {
-			pssb, err := homedir.Expand(pssb)
-			if err != nil {
-				return err
-			}
-
-			log.Infof("moving pre-sealed-sectors from %s into newly created storage miner repo", pssb)
+		{
 			lr, err := r.Lock(repo.StorageMiner)
 			if err != nil {
 				return err
 			}
-			mds, err := lr.Datastore("/metadata")
-			if err != nil {
-				return err
+
+			var localPaths []stores.LocalPath
+
+			if pssb := cctx.StringSlice("pre-sealed-sectors"); len(pssb) != 0 {
+				log.Infof("Setting up storage config with presealed sectors: %v", pssb)
+
+				for _, psp := range pssb {
+					psp, err := homedir.Expand(psp)
+					if err != nil {
+						return err
+					}
+					localPaths = append(localPaths, stores.LocalPath{
+						Path: psp,
+					})
+				}
 			}
 
-			bopts := badger.DefaultOptions
-			bopts.ReadOnly = true
-			oldmds, err := badger.NewDatastore(filepath.Join(pssb, "badger"), &bopts)
-			if err != nil {
-				return err
+			if !cctx.Bool("no-local-storage") {
+				b, err := json.MarshalIndent(&stores.LocalStorageMeta{
+					ID:       stores.ID(uuid.New().String()),
+					Weight:   10,
+					CanSeal:  true,
+					CanStore: true,
+				}, "", "  ")
+				if err != nil {
+					return xerrors.Errorf("marshaling storage config: %w", err)
+				}
+
+				if err := ioutil.WriteFile(filepath.Join(lr.Path(), "sectorstore.json"), b, 0644); err != nil {
+					return xerrors.Errorf("persisting storage metadata (%s): %w", filepath.Join(lr.Path(), "sectorstore.json"), err)
+				}
+
+				localPaths = append(localPaths, stores.LocalPath{
+					Path: lr.Path(),
+				})
 			}
 
-			oldsb, err := sectorbuilder.New(&sectorbuilder.Config{
-				SectorSize:    ssize,
-				WorkerThreads: 2,
-				Dir:           pssb,
-			}, namespace.Wrap(oldmds, datastore.NewKey("/sectorbuilder")))
-			if err != nil {
-				return xerrors.Errorf("failed to open up preseal sectorbuilder: %w", err)
+			if err := lr.SetStorage(func(sc *stores.StorageConfig) {
+				sc.StoragePaths = append(sc.StoragePaths, localPaths...)
+			}); err != nil {
+				return xerrors.Errorf("set storage config: %w", err)
 			}
 
-			nsb, err := sectorbuilder.New(&sectorbuilder.Config{
-				SectorSize:    ssize,
-				WorkerThreads: 2,
-				Dir:           lr.Path(),
-			}, namespace.Wrap(mds, datastore.NewKey("/sectorbuilder")))
-			if err != nil {
-				return xerrors.Errorf("failed to open up sectorbuilder: %w", err)
-			}
-
-			if err := nsb.ImportFrom(oldsb, symlink); err != nil {
-				return err
-			}
 			if err := lr.Close(); err != nil {
-				return xerrors.Errorf("unlocking repo after preseal migration: %w", err)
+				return err
 			}
 		}
 
-		if err := storageMinerInit(ctx, cctx, api, r); err != nil {
-			log.Errorf("Failed to initialize lotus-storage-miner: %+v", err)
+		if err := storageMinerInit(ctx, cctx, api, r, ssize, gasPrice); err != nil {
+			log.Errorf("Failed to initialize lotus-miner: %+v", err)
 			path, err := homedir.Expand(repoPath)
 			if err != nil {
 				return err
@@ -211,58 +258,70 @@ var initCmd = &cli.Command{
 		}
 
 		// TODO: Point to setting storage price, maybe do it interactively or something
-		log.Info("Storage miner successfully created, you can now start it with 'lotus-storage-miner run'")
+		log.Info("Miner successfully created, you can now start it with 'lotus-miner run'")
 
 		return nil
 	},
 }
 
-func migratePreSealMeta(ctx context.Context, api lapi.FullNode, presealDir string, maddr address.Address, mds dtypes.MetadataDS) error {
-	presealDir, err := homedir.Expand(presealDir)
+func migratePreSealMeta(ctx context.Context, api lapi.FullNode, metadata string, maddr address.Address, mds dtypes.MetadataDS) error {
+	metadata, err := homedir.Expand(metadata)
 	if err != nil {
 		return xerrors.Errorf("expanding preseal dir: %w", err)
 	}
 
-	b, err := ioutil.ReadFile(filepath.Join(presealDir, "pre-seal-"+maddr.String()+".json"))
+	b, err := ioutil.ReadFile(metadata)
 	if err != nil {
 		return xerrors.Errorf("reading preseal metadata: %w", err)
 	}
 
-	preseals := map[string]genesis.GenesisMiner{}
-
-	if err := json.Unmarshal(b, &preseals); err != nil {
+	psm := map[string]genesis.Miner{}
+	if err := json.Unmarshal(b, &psm); err != nil {
 		return xerrors.Errorf("unmarshaling preseal metadata: %w", err)
 	}
 
-	meta, ok := preseals[maddr.String()]
+	meta, ok := psm[maddr.String()]
 	if !ok {
-		return xerrors.New("got wrong preseal info")
+		return xerrors.Errorf("preseal file didn't contain metadata for miner %s", maddr)
 	}
 
+	maxSectorID := abi.SectorNumber(0)
 	for _, sector := range meta.Sectors {
-		sectorKey := datastore.NewKey(storage.SectorStorePrefix).ChildString(fmt.Sprint(sector.SectorID))
+		sectorKey := datastore.NewKey(sealing.SectorStorePrefix).ChildString(fmt.Sprint(sector.SectorID))
 
 		dealID, err := findMarketDealID(ctx, api, sector.Deal)
 		if err != nil {
 			return xerrors.Errorf("finding storage deal for pre-sealed sector %d: %w", sector.SectorID, err)
 		}
+		commD := sector.CommD
+		commR := sector.CommR
 
-		info := &storage.SectorInfo{
-			State:    lapi.Proving,
-			SectorID: sector.SectorID,
-			Pieces: []storage.Piece{
+		info := &sealing.SectorInfo{
+			State:        sealing.Proving,
+			SectorNumber: sector.SectorID,
+			Pieces: []sealing.Piece{
 				{
-					DealID: dealID,
-					Size:   meta.SectorSize,
-					CommP:  sector.CommD[:],
+					Piece: abi.PieceInfo{
+						Size:     abi.PaddedPieceSize(meta.SectorSize),
+						PieceCID: commD,
+					},
+					DealInfo: &sealing.DealInfo{
+						DealID: dealID,
+						DealSchedule: sealing.DealSchedule{
+							StartEpoch: sector.Deal.StartEpoch,
+							EndEpoch:   sector.Deal.EndEpoch,
+						},
+					},
 				},
 			},
-			CommD:            sector.CommD[:],
-			CommR:            sector.CommR[:],
+			CommD:            &commD,
+			CommR:            &commR,
 			Proof:            nil,
-			Ticket:           storage.SealTicket{},
+			TicketValue:      abi.SealRandomness{},
+			TicketEpoch:      0,
 			PreCommitMessage: nil,
-			Seed:             storage.SealSeed{},
+			SeedValue:        abi.InteractiveSealRandomness{},
+			SeedEpoch:        0,
 			CommitMessage:    nil,
 		}
 
@@ -275,22 +334,28 @@ func migratePreSealMeta(ctx context.Context, api lapi.FullNode, presealDir strin
 			return err
 		}
 
-		proposalCid, err := sector.Deal.Cid()
+		if sector.SectorID > maxSectorID {
+			maxSectorID = sector.SectorID
+		}
+
+		/* // TODO: Import deals into market
+		pnd, err := cborutil.AsIpld(sector.Deal)
 		if err != nil {
 			return err
 		}
 
-		dealKey := datastore.NewKey(deals.ProviderDsPrefix).ChildString(proposalCid.String())
+		dealKey := datastore.NewKey(deals.ProviderDsPrefix).ChildString(pnd.Cid().String())
 
 		deal := &deals.MinerDeal{
-			Proposal:    sector.Deal,
-			ProposalCid: proposalCid,
-			State:       lapi.DealComplete,
-			Ref:         proposalCid, // TODO: This is super wrong, but there
-			// are no params for CommP CIDs, we can't recover unixfs cid easily,
-			// and this isn't even used after the deal enters Complete state
-			DealID:   dealID,
-			SectorID: sector.SectorID,
+			MinerDeal: storagemarket.MinerDeal{
+				ClientDealProposal: sector.Deal,
+				ProposalCid: pnd.Cid(),
+				State:       storagemarket.StorageDealActive,
+				Ref:         &storagemarket.DataRef{Root: proposalCid}, // TODO: This is super wrong, but there
+				// are no params for CommP CIDs, we can't recover unixfs cid easily,
+				// and this isn't even used after the deal enters Complete state
+				DealID: dealID,
+			},
 		}
 
 		b, err = cborutil.Dump(deal)
@@ -300,36 +365,39 @@ func migratePreSealMeta(ctx context.Context, api lapi.FullNode, presealDir strin
 
 		if err := mds.Put(dealKey, b); err != nil {
 			return err
-		}
+		}*/
 	}
 
-	return nil
+	buf := make([]byte, binary.MaxVarintLen64)
+	size := binary.PutUvarint(buf, uint64(maxSectorID))
+	return mds.Put(datastore.NewKey(modules.StorageCounterDSPrefix), buf[:size])
 }
 
-func findMarketDealID(ctx context.Context, api lapi.FullNode, deal actors.StorageDealProposal) (uint64, error) {
+func findMarketDealID(ctx context.Context, api lapi.FullNode, deal market0.DealProposal) (abi.DealID, error) {
 	// TODO: find a better way
 	//  (this is only used by genesis miners)
 
-	deals, err := api.StateMarketDeals(ctx, nil)
+	deals, err := api.StateMarketDeals(ctx, types.EmptyTSK)
 	if err != nil {
 		return 0, xerrors.Errorf("getting market deals: %w", err)
 	}
 
 	for k, v := range deals {
-		if bytes.Equal(v.PieceRef, deal.PieceRef) {
-			return strconv.ParseUint(k, 10, 64)
+		if v.Proposal.PieceCID.Equals(deal.PieceCID) {
+			id, err := strconv.ParseUint(k, 10, 64)
+			return abi.DealID(id), err
 		}
 	}
 
 	return 0, xerrors.New("deal not found")
 }
 
-func storageMinerInit(ctx context.Context, cctx *cli.Context, api lapi.FullNode, r repo.Repo) error {
+func storageMinerInit(ctx context.Context, cctx *cli.Context, api lapi.FullNode, r repo.Repo, ssize abi.SectorSize, gasPrice types.BigInt) error {
 	lr, err := r.Lock(repo.StorageMiner)
 	if err != nil {
 		return err
 	}
-	defer lr.Close()
+	defer lr.Close() //nolint:errcheck
 
 	log.Info("Initializing libp2p identity")
 
@@ -360,34 +428,63 @@ func storageMinerInit(ctx context.Context, cctx *cli.Context, api lapi.FullNode,
 				return err
 			}
 
-			sbcfg, err := modules.SectorBuilderConfig(lr.Path(), 2, false, false)(mds, api)
+			spt, err := ffiwrapper.SealProofTypeFromSectorSize(ssize)
 			if err != nil {
-				return xerrors.Errorf("getting genesis miner sector builder config: %w", err)
+				return err
 			}
-			sb, err := sectorbuilder.New(sbcfg, mds)
-			if err != nil {
-				return xerrors.Errorf("failed to set up sectorbuilder for genesis mining: %w", err)
-			}
-			epp := storage.NewElectionPoStProver(sb)
 
-			m := miner.NewMiner(api, epp)
+			mid, err := address.IDFromAddress(a)
+			if err != nil {
+				return xerrors.Errorf("getting id address: %w", err)
+			}
+
+			sa, err := modules.StorageAuth(ctx, api)
+			if err != nil {
+				return err
+			}
+
+			smgr, err := sectorstorage.New(ctx, lr, stores.NewIndex(), &ffiwrapper.Config{
+				SealProofType: spt,
+			}, sectorstorage.SealerConfig{
+				ParallelFetchLimit: 10,
+				AllowAddPiece:      true,
+				AllowPreCommit1:    true,
+				AllowPreCommit2:    true,
+				AllowCommit:        true,
+				AllowUnseal:        true,
+			}, nil, sa)
+			if err != nil {
+				return err
+			}
+			epp, err := storage.NewWinningPoStProver(api, smgr, ffiwrapper.ProofVerifier, dtypes.MinerID(mid))
+			if err != nil {
+				return err
+			}
+
+			if jrnl, err := journal.OpenFSJournal(lr, journal.DefaultDisabledEvents); err == nil {
+				journal.J = jrnl
+			} else {
+				return fmt.Errorf("failed to open filesystem journal: %w", err)
+			}
+
+			m := miner.NewMiner(api, epp, a, slashfilter.New(mds))
 			{
-				if err := m.Register(a); err != nil {
+				if err := m.Start(ctx); err != nil {
 					return xerrors.Errorf("failed to start up genesis miner: %w", err)
 				}
 
-				defer func() {
-					if err := m.Unregister(ctx, a); err != nil {
-						log.Error("failed to shut down storage miner: ", err)
-					}
-				}()
+				cerr := configureStorageMiner(ctx, api, a, peerid, gasPrice)
 
-				if err := configureStorageMiner(ctx, api, a, peerid); err != nil {
-					return xerrors.Errorf("failed to configure storage miner: %w", err)
+				if err := m.Stop(ctx); err != nil {
+					log.Error("failed to shut down miner: ", err)
+				}
+
+				if cerr != nil {
+					return xerrors.Errorf("failed to configure miner: %w", cerr)
 				}
 			}
 
-			if pssb := cctx.String("pre-sealed-sectors"); pssb != "" {
+			if pssb := cctx.String("pre-sealed-metadata"); pssb != "" {
 				pssb, err := homedir.Expand(pssb)
 				if err != nil {
 					return err
@@ -403,21 +500,34 @@ func storageMinerInit(ctx context.Context, cctx *cli.Context, api lapi.FullNode,
 			return nil
 		}
 
-		if err := configureStorageMiner(ctx, api, a, peerid); err != nil {
-			return xerrors.Errorf("failed to configure storage miner: %w", err)
+		if pssb := cctx.String("pre-sealed-metadata"); pssb != "" {
+			pssb, err := homedir.Expand(pssb)
+			if err != nil {
+				return err
+			}
+
+			log.Infof("Importing pre-sealed sector metadata for %s", a)
+
+			if err := migratePreSealMeta(ctx, api, pssb, a, mds); err != nil {
+				return xerrors.Errorf("migrating presealed sector metadata: %w", err)
+			}
+		}
+
+		if err := configureStorageMiner(ctx, api, a, peerid, gasPrice); err != nil {
+			return xerrors.Errorf("failed to configure miner: %w", err)
 		}
 
 		addr = a
 	} else {
-		a, err := createStorageMiner(ctx, api, peerid, cctx)
+		a, err := createStorageMiner(ctx, api, peerid, gasPrice, cctx)
 		if err != nil {
-			return err
+			return xerrors.Errorf("creating miner failed: %w", err)
 		}
 
 		addr = a
 	}
 
-	log.Infof("Created new storage miner: %s", addr)
+	log.Infof("Created new miner: %s", addr)
 	if err := mds.Put(datastore.NewKey("miner-address"), addr.Bytes()); err != nil {
 		return err
 	}
@@ -451,48 +561,33 @@ func makeHostKey(lr repo.LockedRepo) (crypto.PrivKey, error) {
 	return pk, nil
 }
 
-func configureStorageMiner(ctx context.Context, api lapi.FullNode, addr address.Address, peerid peer.ID) error {
-	// This really just needs to be an api call at this point...
-	recp, err := api.StateCall(ctx, &types.Message{
-		To:     addr,
-		From:   addr,
-		Method: actors.MAMethods.GetWorkerAddr,
-	}, nil)
-	if err != nil {
-		return xerrors.Errorf("failed to get worker address: %w", err)
-	}
-
-	if recp.ExitCode != 0 {
-		return xerrors.Errorf("getWorkerAddr returned exit code %d", recp.ExitCode)
-	}
-
-	waddr, err := address.NewFromBytes(recp.Return)
+func configureStorageMiner(ctx context.Context, api lapi.FullNode, addr address.Address, peerid peer.ID, gasPrice types.BigInt) error {
+	mi, err := api.StateMinerInfo(ctx, addr, types.EmptyTSK)
 	if err != nil {
 		return xerrors.Errorf("getWorkerAddr returned bad address: %w", err)
 	}
 
-	enc, err := actors.SerializeParams(&actors.UpdatePeerIDParams{PeerID: peerid})
+	enc, err := actors.SerializeParams(&miner0.ChangePeerIDParams{NewID: abi.PeerID(peerid)})
 	if err != nil {
 		return err
 	}
 
 	msg := &types.Message{
-		To:       addr,
-		From:     waddr,
-		Method:   actors.MAMethods.UpdatePeerID,
-		Params:   enc,
-		Value:    types.NewInt(0),
-		GasPrice: types.NewInt(0),
-		GasLimit: types.NewInt(100000000),
+		To:         addr,
+		From:       mi.Worker,
+		Method:     builtin0.MethodsMiner.ChangePeerID,
+		Params:     enc,
+		Value:      types.NewInt(0),
+		GasPremium: gasPrice,
 	}
 
-	smsg, err := api.MpoolPushMessage(ctx, msg)
+	smsg, err := api.MpoolPushMessage(ctx, msg, nil)
 	if err != nil {
 		return err
 	}
 
 	log.Info("Waiting for message: ", smsg.Cid())
-	ret, err := api.StateWaitMsg(ctx, smsg.Cid())
+	ret, err := api.StateWaitMsg(ctx, smsg.Cid(), build.MessageConfidence)
 	if err != nil {
 		return err
 	}
@@ -504,9 +599,10 @@ func configureStorageMiner(ctx context.Context, api lapi.FullNode, addr address.
 	return nil
 }
 
-func createStorageMiner(ctx context.Context, api lapi.FullNode, peerid peer.ID, cctx *cli.Context) (addr address.Address, err error) {
+func createStorageMiner(ctx context.Context, api lapi.FullNode, peerid peer.ID, gasPrice types.BigInt, cctx *cli.Context) (address.Address, error) {
 	log.Info("Creating StorageMarket.CreateStorageMiner message")
 
+	var err error
 	var owner address.Address
 	if cctx.String("owner") != "" {
 		owner, err = address.NewFromString(cctx.String("owner"))
@@ -517,47 +613,59 @@ func createStorageMiner(ctx context.Context, api lapi.FullNode, peerid peer.ID,
 		return address.Undef, err
 	}
 
-	ssize := cctx.Uint64("sector-size")
+	ssize, err := units.RAMInBytes(cctx.String("sector-size"))
+	if err != nil {
+		return address.Undef, fmt.Errorf("failed to parse sector size: %w", err)
+	}
 
 	worker := owner
 	if cctx.String("worker") != "" {
 		worker, err = address.NewFromString(cctx.String("worker"))
 	} else if cctx.Bool("create-worker-key") { // TODO: Do we need to force this if owner is Secpk?
-		worker, err = api.WalletNew(ctx, types.KTBLS)
+		worker, err = api.WalletNew(ctx, crypto2.SigTypeBLS)
 	}
 	// TODO: Transfer some initial funds to worker
 	if err != nil {
 		return address.Undef, err
 	}
 
-	collateral, err := api.StatePledgeCollateral(ctx, nil)
+	spt, err := ffiwrapper.SealProofTypeFromSectorSize(abi.SectorSize(ssize))
 	if err != nil {
 		return address.Undef, err
 	}
 
-	params, err := actors.SerializeParams(&actors.CreateStorageMinerParams{
-		Owner:      owner,
-		Worker:     worker,
-		SectorSize: ssize,
-		PeerID:     peerid,
+	params, err := actors.SerializeParams(&power0.CreateMinerParams{
+		Owner:         owner,
+		Worker:        worker,
+		SealProofType: spt,
+		Peer:          abi.PeerID(peerid),
 	})
 	if err != nil {
 		return address.Undef, err
 	}
 
-	createStorageMinerMsg := &types.Message{
-		To:    actors.StoragePowerAddress,
-		From:  owner,
-		Value: collateral,
-
-		Method: actors.SPAMethods.CreateStorageMiner,
-		Params: params,
-
-		GasLimit: types.NewInt(10000000),
-		GasPrice: types.NewInt(0),
+	sender := owner
+	if fromstr := cctx.String("from"); fromstr != "" {
+		faddr, err := address.NewFromString(fromstr)
+		if err != nil {
+			return address.Undef, fmt.Errorf("could not parse from address: %w", err)
+		}
+		sender = faddr
 	}
 
-	signed, err := api.MpoolPushMessage(ctx, createStorageMinerMsg)
+	createStorageMinerMsg := &types.Message{
+		To:    builtin0.StoragePowerActorAddr,
+		From:  sender,
+		Value: big.Zero(),
+
+		Method: builtin0.MethodsPower.CreateMiner,
+		Params: params,
+
+		GasLimit:   0,
+		GasPremium: gasPrice,
+	}
+
+	signed, err := api.MpoolPushMessage(ctx, createStorageMinerMsg, nil)
 	if err != nil {
 		return address.Undef, err
 	}
@@ -565,20 +673,20 @@ func createStorageMiner(ctx context.Context, api lapi.FullNode, peerid peer.ID,
 	log.Infof("Pushed StorageMarket.CreateStorageMiner, %s to Mpool", signed.Cid())
 	log.Infof("Waiting for confirmation")
 
-	mw, err := api.StateWaitMsg(ctx, signed.Cid())
+	mw, err := api.StateWaitMsg(ctx, signed.Cid(), build.MessageConfidence)
 	if err != nil {
 		return address.Undef, err
 	}
 
 	if mw.Receipt.ExitCode != 0 {
-		return address.Undef, xerrors.Errorf("create storage miner failed: exit code %d", mw.Receipt.ExitCode)
+		return address.Undef, xerrors.Errorf("create miner failed: exit code %d", mw.Receipt.ExitCode)
 	}
 
-	addr, err = address.NewFromBytes(mw.Receipt.Return)
-	if err != nil {
+	var retval power0.CreateMinerReturn
+	if err := retval.UnmarshalCBOR(bytes.NewReader(mw.Receipt.Return)); err != nil {
 		return address.Undef, err
 	}
 
-	log.Infof("New storage miners address is: %s", addr)
-	return addr, nil
+	log.Infof("New miners address is: %s (%s)", retval.IDAddress, retval.RobustAddress)
+	return retval.IDAddress, nil
 }
diff --git a/cmd/lotus-storage-miner/main.go b/cmd/lotus-storage-miner/main.go
index c05383116..cee64f077 100644
--- a/cmd/lotus-storage-miner/main.go
+++ b/cmd/lotus-storage-miner/main.go
@@ -1,32 +1,50 @@
 package main
 
 import (
-	"os"
+	"context"
+	"fmt"
 
-	logging "github.com/ipfs/go-log"
+	logging "github.com/ipfs/go-log/v2"
+	"github.com/urfave/cli/v2"
 	"go.opencensus.io/trace"
-	"gopkg.in/urfave/cli.v2"
+	"golang.org/x/xerrors"
 
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/build"
 	lcli "github.com/filecoin-project/lotus/cli"
 	"github.com/filecoin-project/lotus/lib/lotuslog"
+	"github.com/filecoin-project/lotus/lib/tracing"
 	"github.com/filecoin-project/lotus/node/repo"
-	"github.com/filecoin-project/lotus/tracing"
 )
 
 var log = logging.Logger("main")
 
-const FlagStorageRepo = "storagerepo"
+const FlagMinerRepo = "miner-repo"
+
+// TODO remove after deprecation period
+const FlagMinerRepoDeprecation = "storagerepo"
 
 func main() {
+	build.RunningNodeType = build.NodeMiner
+
 	lotuslog.SetupLogLevels()
 
 	local := []*cli.Command{
-		runCmd,
 		initCmd,
-		infoCmd,
-		pledgeSectorCmd,
-		sectorsCmd,
+		runCmd,
+		stopCmd,
+		configCmd,
+		lcli.WithCategory("chain", actorCmd),
+		lcli.WithCategory("chain", infoCmd),
+		lcli.WithCategory("market", storageDealsCmd),
+		lcli.WithCategory("market", retrievalDealsCmd),
+		lcli.WithCategory("market", dataTransfersCmd),
+		lcli.WithCategory("storage", sectorsCmd),
+		lcli.WithCategory("storage", provingCmd),
+		lcli.WithCategory("storage", storageCmd),
+		lcli.WithCategory("storage", sealingCmd),
+		lcli.WithCategory("retrieval", piecesCmd),
 	}
 	jaeger := tracing.SetupJaegerTracing("lotus")
 	defer func() {
@@ -50,10 +68,20 @@ func main() {
 	}
 
 	app := &cli.App{
-		Name:    "lotus-storage-miner",
-		Usage:   "Filecoin decentralized storage network storage miner",
-		Version: build.UserVersion,
+		Name:                 "lotus-miner",
+		Usage:                "Filecoin decentralized storage network miner",
+		Version:              build.UserVersion(),
+		EnableBashCompletion: true,
 		Flags: []cli.Flag{
+			&cli.StringFlag{
+				Name:    "actor",
+				Value:   "",
+				Usage:   "specify other actor to check state for (read only)",
+				Aliases: []string{"a"},
+			},
+			&cli.BoolFlag{
+				Name: "color",
+			},
 			&cli.StringFlag{
 				Name:    "repo",
 				EnvVars: []string{"LOTUS_PATH"},
@@ -61,19 +89,35 @@ func main() {
 				Value:   "~/.lotus", // TODO: Consider XDG_DATA_HOME
 			},
 			&cli.StringFlag{
-				Name:    FlagStorageRepo,
-				EnvVars: []string{"LOTUS_STORAGE_PATH"},
-				Value:   "~/.lotusstorage", // TODO: Consider XDG_DATA_HOME
+				Name:    FlagMinerRepo,
+				Aliases: []string{FlagMinerRepoDeprecation},
+				EnvVars: []string{"LOTUS_MINER_PATH", "LOTUS_STORAGE_PATH"},
+				Value:   "~/.lotusminer", // TODO: Consider XDG_DATA_HOME
+				Usage:   fmt.Sprintf("Specify miner repo path. flag(%s) and env(LOTUS_STORAGE_PATH) are DEPRECATION, will REMOVE SOON", FlagMinerRepoDeprecation),
 			},
 		},
 
-		Commands: append(local, lcli.Commands...),
+		Commands: append(local, lcli.CommonCommands...),
 	}
 	app.Setup()
 	app.Metadata["repoType"] = repo.StorageMiner
 
-	if err := app.Run(os.Args); err != nil {
-		log.Warnf("%+v", err)
-		os.Exit(1)
-	}
+	lcli.RunApp(app)
+}
+
+func getActorAddress(ctx context.Context, nodeAPI api.StorageMiner, overrideMaddr string) (maddr address.Address, err error) {
+	if overrideMaddr != "" {
+		maddr, err = address.NewFromString(overrideMaddr)
+		if err != nil {
+			return maddr, err
+		}
+		return
+	}
+
+	maddr, err = nodeAPI.ActorAddress(ctx)
+	if err != nil {
+		return maddr, xerrors.Errorf("getting actor address: %w", err)
+	}
+
+	return maddr, nil
 }
diff --git a/cmd/lotus-storage-miner/market.go b/cmd/lotus-storage-miner/market.go
new file mode 100644
index 000000000..0e7be3dd3
--- /dev/null
+++ b/cmd/lotus-storage-miner/market.go
@@ -0,0 +1,648 @@
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"sort"
+	"strconv"
+	"text/tabwriter"
+	"time"
+
+	tm "github.com/buger/goterm"
+	"github.com/docker/go-units"
+	"github.com/ipfs/go-cid"
+	"github.com/ipfs/go-cidutil/cidenc"
+	"github.com/multiformats/go-multibase"
+	"github.com/urfave/cli/v2"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-fil-markets/storagemarket"
+	"github.com/filecoin-project/go-state-types/abi"
+
+	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/types"
+	lcli "github.com/filecoin-project/lotus/cli"
+)
+
+var CidBaseFlag = cli.StringFlag{
+	Name:        "cid-base",
+	Hidden:      true,
+	Value:       "base32",
+	Usage:       "Multibase encoding used for version 1 CIDs in output.",
+	DefaultText: "base32",
+}
+
+// GetCidEncoder returns an encoder using the `cid-base` flag if provided, or
+// the default (Base32) encoder if not.
+func GetCidEncoder(cctx *cli.Context) (cidenc.Encoder, error) {
+	val := cctx.String("cid-base")
+
+	e := cidenc.Encoder{Base: multibase.MustNewEncoder(multibase.Base32)}
+
+	if val != "" {
+		var err error
+		e.Base, err = multibase.EncoderByName(val)
+		if err != nil {
+			return e, err
+		}
+	}
+
+	return e, nil
+}
+
+var storageDealSelectionCmd = &cli.Command{
+	Name:  "selection",
+	Usage: "Configure acceptance criteria for storage deal proposals",
+	Subcommands: []*cli.Command{
+		storageDealSelectionShowCmd,
+		storageDealSelectionResetCmd,
+		storageDealSelectionRejectCmd,
+	},
+}
+
+var storageDealSelectionShowCmd = &cli.Command{
+	Name:  "list",
+	Usage: "List storage deal proposal selection criteria",
+	Action: func(cctx *cli.Context) error {
+		smapi, closer, err := lcli.GetStorageMinerAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+
+		onlineOk, err := smapi.DealsConsiderOnlineStorageDeals(lcli.DaemonContext(cctx))
+		if err != nil {
+			return err
+		}
+
+		offlineOk, err := smapi.DealsConsiderOfflineStorageDeals(lcli.DaemonContext(cctx))
+		if err != nil {
+			return err
+		}
+
+		fmt.Printf("considering online storage deals: %t\n", onlineOk)
+		fmt.Printf("considering offline storage deals: %t\n", offlineOk)
+
+		return nil
+	},
+}
+
+var storageDealSelectionResetCmd = &cli.Command{
+	Name:  "reset",
+	Usage: "Reset storage deal proposal selection criteria to default values",
+	Action: func(cctx *cli.Context) error {
+		smapi, closer, err := lcli.GetStorageMinerAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+
+		err = smapi.DealsSetConsiderOnlineStorageDeals(lcli.DaemonContext(cctx), true)
+		if err != nil {
+			return err
+		}
+
+		err = smapi.DealsSetConsiderOfflineStorageDeals(lcli.DaemonContext(cctx), true)
+		if err != nil {
+			return err
+		}
+
+		return nil
+	},
+}
+
+var storageDealSelectionRejectCmd = &cli.Command{
+	Name:  "reject",
+	Usage: "Configure criteria which necessitate automatic rejection",
+	Flags: []cli.Flag{
+		&cli.BoolFlag{
+			Name: "online",
+		},
+		&cli.BoolFlag{
+			Name: "offline",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		smapi, closer, err := lcli.GetStorageMinerAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+
+		if cctx.Bool("online") {
+			err = smapi.DealsSetConsiderOnlineStorageDeals(lcli.DaemonContext(cctx), false)
+			if err != nil {
+				return err
+			}
+		}
+
+		if cctx.Bool("offline") {
+			err = smapi.DealsSetConsiderOfflineStorageDeals(lcli.DaemonContext(cctx), false)
+			if err != nil {
+				return err
+			}
+		}
+
+		return nil
+	},
+}
+
+var setAskCmd = &cli.Command{
+	Name:  "set-ask",
+	Usage: "Configure the miner's ask",
+	Flags: []cli.Flag{
+		&cli.Uint64Flag{
+			Name:     "price",
+			Usage:    "Set the price of the ask for unverified deals (specified as attoFIL / GiB / Epoch) to `PRICE`",
+			Required: true,
+		},
+		&cli.Uint64Flag{
+			Name:     "verified-price",
+			Usage:    "Set the price of the ask for verified deals (specified as attoFIL / GiB / Epoch) to `PRICE`",
+			Required: true,
+		},
+		&cli.StringFlag{
+			Name:        "duration",
+			Usage:       "Set duration of ask (a quantity of time after which the ask expires) `DURATION`",
+			DefaultText: "720h0m0s",
+			Value:       "720h0m0s",
+		},
+		&cli.StringFlag{
+			Name:        "min-piece-size",
+			Usage:       "Set minimum piece size (w/bit-padding, in bytes) in ask to `SIZE`",
+			DefaultText: "256B",
+			Value:       "256B",
+		},
+		&cli.StringFlag{
+			Name:        "max-piece-size",
+			Usage:       "Set maximum piece size (w/bit-padding, in bytes) in ask to `SIZE`",
+			DefaultText: "miner sector size",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		ctx := lcli.DaemonContext(cctx)
+
+		api, closer, err := lcli.GetStorageMinerAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+
+		pri := types.NewInt(cctx.Uint64("price"))
+		vpri := types.NewInt(cctx.Uint64("verified-price"))
+
+		dur, err := time.ParseDuration(cctx.String("duration"))
+		if err != nil {
+			return xerrors.Errorf("cannot parse duration: %w", err)
+		}
+
+		qty := dur.Seconds() / float64(build.BlockDelaySecs)
+
+		min, err := units.RAMInBytes(cctx.String("min-piece-size"))
+		if err != nil {
+			return xerrors.Errorf("cannot parse min-piece-size to quantity of bytes: %w", err)
+		}
+
+		if min < 256 {
+			return xerrors.New("minimum piece size (w/bit-padding) is 256B")
+		}
+
+		max, err := units.RAMInBytes(cctx.String("max-piece-size"))
+		if err != nil {
+			return xerrors.Errorf("cannot parse max-piece-size to quantity of bytes: %w", err)
+		}
+
+		maddr, err := api.ActorAddress(ctx)
+		if err != nil {
+			return err
+		}
+
+		ssize, err := api.ActorSectorSize(ctx, maddr)
+		if err != nil {
+			return err
+		}
+
+		smax := int64(ssize)
+
+		if max == 0 {
+			max = smax
+		}
+
+		if max > smax {
+			return xerrors.Errorf("max piece size (w/bit-padding) %s cannot exceed miner sector size %s", types.SizeStr(types.NewInt(uint64(max))), types.SizeStr(types.NewInt(uint64(smax))))
+		}
+
+		return api.MarketSetAsk(ctx, pri, vpri, abi.ChainEpoch(qty), abi.PaddedPieceSize(min), abi.PaddedPieceSize(max))
+	},
+}
+
+var getAskCmd = &cli.Command{
+	Name:  "get-ask",
+	Usage: "Print the miner's ask",
+	Flags: []cli.Flag{},
+	Action: func(cctx *cli.Context) error {
+		ctx := lcli.DaemonContext(cctx)
+
+		fnapi, closer, err := lcli.GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+
+		smapi, closer, err := lcli.GetStorageMinerAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+
+		sask, err := smapi.MarketGetAsk(ctx)
+		if err != nil {
+			return err
+		}
+
+		var ask *storagemarket.StorageAsk
+		if sask != nil && sask.Ask != nil {
+			ask = sask.Ask
+		}
+
+		w := tabwriter.NewWriter(os.Stdout, 2, 4, 2, ' ', 0)
+		fmt.Fprintf(w, "Price per GiB/Epoch\tVerified\tMin. Piece Size (padded)\tMax. Piece Size (padded)\tExpiry (Epoch)\tExpiry (Appx. Rem. Time)\tSeq. No.\n")
+		if ask == nil {
+			fmt.Fprintf(w, "<miner does not have an ask>\n")
+
+			return w.Flush()
+		}
+
+		head, err := fnapi.ChainHead(ctx)
+		if err != nil {
+			return err
+		}
+
+		dlt := ask.Expiry - head.Height()
+		rem := "<expired>"
+		if dlt > 0 {
+			rem = (time.Second * time.Duration(int64(dlt)*int64(build.BlockDelaySecs))).String()
+		}
+
+		fmt.Fprintf(w, "%s\t%s\t%s\t%s\t%d\t%s\t%d\n", ask.Price, ask.VerifiedPrice, types.SizeStr(types.NewInt(uint64(ask.MinPieceSize))), types.SizeStr(types.NewInt(uint64(ask.MaxPieceSize))), ask.Expiry, rem, ask.SeqNo)
+
+		return w.Flush()
+	},
+}
+
+var storageDealsCmd = &cli.Command{
+	Name:  "storage-deals",
+	Usage: "Manage storage deals and related configuration",
+	Subcommands: []*cli.Command{
+		dealsImportDataCmd,
+		dealsListCmd,
+		storageDealSelectionCmd,
+		setAskCmd,
+		getAskCmd,
+		setBlocklistCmd,
+		getBlocklistCmd,
+		resetBlocklistCmd,
+		setSealDurationCmd,
+	},
+}
+
+var dealsImportDataCmd = &cli.Command{
+	Name:      "import-data",
+	Usage:     "Manually import data for a deal",
+	ArgsUsage: "<proposal CID> <file>",
+	Action: func(cctx *cli.Context) error {
+		api, closer, err := lcli.GetStorageMinerAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+
+		ctx := lcli.DaemonContext(cctx)
+
+		if cctx.Args().Len() < 2 {
+			return fmt.Errorf("must specify proposal CID and file path")
+		}
+
+		propCid, err := cid.Decode(cctx.Args().Get(0))
+		if err != nil {
+			return err
+		}
+
+		fpath := cctx.Args().Get(1)
+
+		return api.DealsImportData(ctx, propCid, fpath)
+
+	},
+}
+
+var dealsListCmd = &cli.Command{
+	Name:  "list",
+	Usage: "List all deals for this miner",
+	Flags: []cli.Flag{
+		&cli.BoolFlag{
+			Name:    "verbose",
+			Aliases: []string{"v"},
+		},
+		&cli.BoolFlag{
+			Name:  "watch",
+			Usage: "watch deal updates in real-time, rather than a one time list",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		api, closer, err := lcli.GetStorageMinerAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+
+		ctx := lcli.DaemonContext(cctx)
+
+		deals, err := api.MarketListIncompleteDeals(ctx)
+		if err != nil {
+			return err
+		}
+
+		verbose := cctx.Bool("verbose")
+		watch := cctx.Bool("watch")
+
+		if watch {
+			updates, err := api.MarketGetDealUpdates(ctx)
+			if err != nil {
+				return err
+			}
+
+			for {
+				tm.Clear()
+				tm.MoveCursor(1, 1)
+
+				err = outputStorageDeals(tm.Output, deals, verbose)
+				if err != nil {
+					return err
+				}
+
+				tm.Flush()
+
+				select {
+				case <-ctx.Done():
+					return nil
+				case updated := <-updates:
+					var found bool
+					for i, existing := range deals {
+						if existing.ProposalCid.Equals(updated.ProposalCid) {
+							deals[i] = updated
+							found = true
+							break
+						}
+					}
+					if !found {
+						deals = append(deals, updated)
+					}
+				}
+			}
+		}
+
+		return outputStorageDeals(os.Stdout, deals, verbose)
+	},
+}
+
+func outputStorageDeals(out io.Writer, deals []storagemarket.MinerDeal, verbose bool) error {
+	sort.Slice(deals, func(i, j int) bool {
+		return deals[i].CreationTime.Time().Before(deals[j].CreationTime.Time())
+	})
+
+	w := tabwriter.NewWriter(out, 2, 4, 2, ' ', 0)
+
+	if verbose {
+		_, _ = fmt.Fprintf(w, "Creation\tProposalCid\tDealId\tState\tClient\tSize\tPrice\tDuration\tMessage\n")
+	} else {
+		_, _ = fmt.Fprintf(w, "ProposalCid\tDealId\tState\tClient\tSize\tPrice\tDuration\n")
+	}
+
+	for _, deal := range deals {
+		propcid := deal.ProposalCid.String()
+		if !verbose {
+			propcid = "..." + propcid[len(propcid)-8:]
+		}
+
+		fil := types.FIL(types.BigMul(deal.Proposal.StoragePricePerEpoch, types.NewInt(uint64(deal.Proposal.Duration()))))
+
+		if verbose {
+			_, _ = fmt.Fprintf(w, "%s\t", deal.CreationTime.Time().Format(time.Stamp))
+		}
+
+		_, _ = fmt.Fprintf(w, "%s\t%d\t%s\t%s\t%s\t%s\t%s", propcid, deal.DealID, storagemarket.DealStates[deal.State], deal.Proposal.Client, units.BytesSize(float64(deal.Proposal.PieceSize)), fil, deal.Proposal.Duration())
+		if verbose {
+			_, _ = fmt.Fprintf(w, "\t%s", deal.Message)
+		}
+
+		_, _ = fmt.Fprintln(w)
+	}
+
+	return w.Flush()
+}
+
+var getBlocklistCmd = &cli.Command{
+	Name:  "get-blocklist",
+	Usage: "List the contents of the miner's piece CID blocklist",
+	Flags: []cli.Flag{
+		&CidBaseFlag,
+	},
+	Action: func(cctx *cli.Context) error {
+		api, closer, err := lcli.GetStorageMinerAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+
+		blocklist, err := api.DealsPieceCidBlocklist(lcli.DaemonContext(cctx))
+		if err != nil {
+			return err
+		}
+
+		encoder, err := GetCidEncoder(cctx)
+		if err != nil {
+			return err
+		}
+
+		for idx := range blocklist {
+			fmt.Println(encoder.Encode(blocklist[idx]))
+		}
+
+		return nil
+	},
+}
+
+var setBlocklistCmd = &cli.Command{
+	Name:      "set-blocklist",
+	Usage:     "Set the miner's list of blocklisted piece CIDs",
+	ArgsUsage: "[<path-of-file-containing-newline-delimited-piece-CIDs> (optional, will read from stdin if omitted)]",
+	Flags:     []cli.Flag{},
+	Action: func(cctx *cli.Context) error {
+		api, closer, err := lcli.GetStorageMinerAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+
+		scanner := bufio.NewScanner(os.Stdin)
+		if cctx.Args().Present() && cctx.Args().First() != "-" {
+			absPath, err := filepath.Abs(cctx.Args().First())
+			if err != nil {
+				return err
+			}
+
+			file, err := os.Open(absPath)
+			if err != nil {
+				log.Fatal(err)
+			}
+			defer file.Close() //nolint:errcheck
+
+			scanner = bufio.NewScanner(file)
+		}
+
+		var blocklist []cid.Cid
+		for scanner.Scan() {
+			decoded, err := cid.Decode(scanner.Text())
+			if err != nil {
+				return err
+			}
+
+			blocklist = append(blocklist, decoded)
+		}
+
+		err = scanner.Err()
+		if err != nil {
+			return err
+		}
+
+		return api.DealsSetPieceCidBlocklist(lcli.DaemonContext(cctx), blocklist)
+	},
+}
+
+var resetBlocklistCmd = &cli.Command{
+	Name:  "reset-blocklist",
+	Usage: "Remove all entries from the miner's piece CID blocklist",
+	Flags: []cli.Flag{},
+	Action: func(cctx *cli.Context) error {
+		api, closer, err := lcli.GetStorageMinerAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+
+		return api.DealsSetPieceCidBlocklist(lcli.DaemonContext(cctx), []cid.Cid{})
+	},
+}
+
+var setSealDurationCmd = &cli.Command{
+	Name:      "set-seal-duration",
+	Usage:     "Set the expected time, in minutes, that you expect sealing sectors to take. Deals that start before this duration will be rejected.",
+	ArgsUsage: "<minutes>",
+	Action: func(cctx *cli.Context) error {
+		nodeApi, closer, err := lcli.GetStorageMinerAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+		ctx := lcli.ReqContext(cctx)
+		if cctx.Args().Len() != 1 {
+			return xerrors.Errorf("must pass duration in minutes")
+		}
+
+		hs, err := strconv.ParseUint(cctx.Args().Get(0), 10, 64)
+		if err != nil {
+			return xerrors.Errorf("could not parse duration: %w", err)
+		}
+
+		delay := hs * uint64(time.Minute)
+
+		return nodeApi.SectorSetExpectedSealDuration(ctx, time.Duration(delay))
+	},
+}
+
+var dataTransfersCmd = &cli.Command{
+	Name:  "data-transfers",
+	Usage: "Manage data transfers",
+	Subcommands: []*cli.Command{
+		transfersListCmd,
+	},
+}
+
+var transfersListCmd = &cli.Command{
+	Name:  "list",
+	Usage: "List ongoing data transfers for this miner",
+	Flags: []cli.Flag{
+		&cli.BoolFlag{
+			Name:  "color",
+			Usage: "use color in display output",
+			Value: true,
+		},
+		&cli.BoolFlag{
+			Name:  "completed",
+			Usage: "show completed data transfers",
+		},
+		&cli.BoolFlag{
+			Name:  "watch",
+			Usage: "watch deal updates in real-time, rather than a one time list",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		api, closer, err := lcli.GetStorageMinerAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+		ctx := lcli.ReqContext(cctx)
+
+		channels, err := api.MarketListDataTransfers(ctx)
+		if err != nil {
+			return err
+		}
+
+		completed := cctx.Bool("completed")
+		color := cctx.Bool("color")
+		watch := cctx.Bool("watch")
+
+		if watch {
+			channelUpdates, err := api.MarketDataTransferUpdates(ctx)
+			if err != nil {
+				return err
+			}
+
+			for {
+				tm.Clear() // Clear current screen
+
+				tm.MoveCursor(1, 1)
+
+				lcli.OutputDataTransferChannels(tm.Screen, channels, completed, color)
+
+				tm.Flush()
+
+				select {
+				case <-ctx.Done():
+					return nil
+				case channelUpdate := <-channelUpdates:
+					var found bool
+					for i, existing := range channels {
+						if existing.TransferID == channelUpdate.TransferID &&
+							existing.OtherPeer == channelUpdate.OtherPeer &&
+							existing.IsSender == channelUpdate.IsSender &&
+							existing.IsInitiator == channelUpdate.IsInitiator {
+							channels[i] = channelUpdate
+							found = true
+							break
+						}
+					}
+					if !found {
+						channels = append(channels, channelUpdate)
+					}
+				}
+			}
+		}
+		lcli.OutputDataTransferChannels(os.Stdout, channels, completed, color)
+		return nil
+	},
+}
diff --git a/cmd/lotus-storage-miner/pieces.go b/cmd/lotus-storage-miner/pieces.go
new file mode 100644
index 000000000..d5f189943
--- /dev/null
+++ b/cmd/lotus-storage-miner/pieces.go
@@ -0,0 +1,140 @@
+package main
+
+import (
+	"fmt"
+	"os"
+	"text/tabwriter"
+
+	lcli "github.com/filecoin-project/lotus/cli"
+	"github.com/ipfs/go-cid"
+	"github.com/urfave/cli/v2"
+)
+
+var piecesCmd = &cli.Command{
+	Name:        "pieces",
+	Usage:       "interact with the piecestore",
+	Description: "The piecestore is a database that tracks and manages data that is made available to the retrieval market",
+	Subcommands: []*cli.Command{
+		piecesListPiecesCmd,
+		piecesListCidInfosCmd,
+		piecesInfoCmd,
+		piecesCidInfoCmd,
+	},
+}
+
+var piecesListPiecesCmd = &cli.Command{
+	Name:  "list-pieces",
+	Usage: "list registered pieces",
+	Action: func(cctx *cli.Context) error {
+		nodeApi, closer, err := lcli.GetStorageMinerAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+		ctx := lcli.ReqContext(cctx)
+
+		pieceCids, err := nodeApi.PiecesListPieces(ctx)
+		if err != nil {
+			return err
+		}
+
+		for _, pc := range pieceCids {
+			fmt.Println(pc)
+		}
+		return nil
+	},
+}
+
+var piecesListCidInfosCmd = &cli.Command{
+	Name:  "list-cids",
+	Usage: "list registered payload CIDs",
+	Action: func(cctx *cli.Context) error {
+		nodeApi, closer, err := lcli.GetStorageMinerAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+		ctx := lcli.ReqContext(cctx)
+
+		cids, err := nodeApi.PiecesListCidInfos(ctx)
+		if err != nil {
+			return err
+		}
+
+		for _, c := range cids {
+			fmt.Println(c)
+		}
+		return nil
+	},
+}
+
+var piecesInfoCmd = &cli.Command{
+	Name:  "piece-info",
+	Usage: "get registered information for a given piece CID",
+	Action: func(cctx *cli.Context) error {
+		if !cctx.Args().Present() {
+			return lcli.ShowHelp(cctx, fmt.Errorf("must specify piece cid"))
+		}
+
+		nodeApi, closer, err := lcli.GetStorageMinerAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+		ctx := lcli.ReqContext(cctx)
+
+		c, err := cid.Decode(cctx.Args().First())
+		if err != nil {
+			return err
+		}
+
+		pi, err := nodeApi.PiecesGetPieceInfo(ctx, c)
+		if err != nil {
+			return err
+		}
+
+		fmt.Println("Piece: ", pi.PieceCID)
+		w := tabwriter.NewWriter(os.Stdout, 4, 4, 2, ' ', 0)
+		fmt.Fprintln(w, "Deals:\nDealID\tSectorID\tLength\tOffset")
+		for _, d := range pi.Deals {
+			fmt.Fprintf(w, "%d\t%d\t%d\t%d\n", d.DealID, d.SectorID, d.Length, d.Offset)
+		}
+		return w.Flush()
+	},
+}
+
+var piecesCidInfoCmd = &cli.Command{
+	Name:  "cid-info",
+	Usage: "get registered information for a given payload CID",
+	Action: func(cctx *cli.Context) error {
+		if !cctx.Args().Present() {
+			return lcli.ShowHelp(cctx, fmt.Errorf("must specify payload cid"))
+		}
+
+		nodeApi, closer, err := lcli.GetStorageMinerAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+		ctx := lcli.ReqContext(cctx)
+
+		c, err := cid.Decode(cctx.Args().First())
+		if err != nil {
+			return err
+		}
+
+		ci, err := nodeApi.PiecesGetCIDInfo(ctx, c)
+		if err != nil {
+			return err
+		}
+
+		fmt.Println("Info for: ", ci.CID)
+
+		w := tabwriter.NewWriter(os.Stdout, 4, 4, 2, ' ', 0)
+		fmt.Fprintf(w, "PieceCid\tOffset\tSize\n")
+		for _, loc := range ci.PieceBlockLocations {
+			fmt.Fprintf(w, "%s\t%d\t%d\n", loc.PieceCID, loc.RelOffset, loc.BlockSize)
+		}
+		return w.Flush()
+	},
+}
diff --git a/cmd/lotus-storage-miner/proving.go b/cmd/lotus-storage-miner/proving.go
new file mode 100644
index 000000000..377b81d32
--- /dev/null
+++ b/cmd/lotus-storage-miner/proving.go
@@ -0,0 +1,373 @@
+package main
+
+import (
+	"fmt"
+	"os"
+	"strconv"
+	"text/tabwriter"
+
+	"github.com/fatih/color"
+	"github.com/urfave/cli/v2"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/lotus/api/apibstore"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
+	"github.com/filecoin-project/lotus/chain/store"
+	"github.com/filecoin-project/lotus/chain/types"
+	lcli "github.com/filecoin-project/lotus/cli"
+)
+
+var provingCmd = &cli.Command{
+	Name:  "proving",
+	Usage: "View proving information",
+	Subcommands: []*cli.Command{
+		provingInfoCmd,
+		provingDeadlinesCmd,
+		provingDeadlineInfoCmd,
+		provingFaultsCmd,
+	},
+}
+
+var provingFaultsCmd = &cli.Command{
+	Name:  "faults",
+	Usage: "View the currently known proving faulty sectors information",
+	Action: func(cctx *cli.Context) error {
+		color.NoColor = !cctx.Bool("color")
+
+		nodeApi, closer, err := lcli.GetStorageMinerAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+
+		api, acloser, err := lcli.GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer acloser()
+
+		ctx := lcli.ReqContext(cctx)
+
+		stor := store.ActorStore(ctx, apibstore.NewAPIBlockstore(api))
+
+		maddr, err := getActorAddress(ctx, nodeApi, cctx.String("actor"))
+		if err != nil {
+			return err
+		}
+
+		mact, err := api.StateGetActor(ctx, maddr, types.EmptyTSK)
+		if err != nil {
+			return err
+		}
+
+		mas, err := miner.Load(stor, mact)
+		if err != nil {
+			return err
+		}
+
+		fmt.Printf("Miner: %s\n", color.BlueString("%s", maddr))
+
+		tw := tabwriter.NewWriter(os.Stdout, 2, 4, 2, ' ', 0)
+		_, _ = fmt.Fprintln(tw, "deadline\tpartition\tsectors")
+		err = mas.ForEachDeadline(func(dlIdx uint64, dl miner.Deadline) error {
+			return dl.ForEachPartition(func(partIdx uint64, part miner.Partition) error {
+				faults, err := part.FaultySectors()
+				if err != nil {
+					return err
+				}
+				return faults.ForEach(func(num uint64) error {
+					_, _ = fmt.Fprintf(tw, "%d\t%d\t%d\n", dlIdx, partIdx, num)
+					return nil
+				})
+			})
+		})
+		if err != nil {
+			return err
+		}
+		return tw.Flush()
+	},
+}
+
+var provingInfoCmd = &cli.Command{
+	Name:  "info",
+	Usage: "View current state information",
+	Action: func(cctx *cli.Context) error {
+		color.NoColor = !cctx.Bool("color")
+
+		nodeApi, closer, err := lcli.GetStorageMinerAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+
+		api, acloser, err := lcli.GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer acloser()
+
+		ctx := lcli.ReqContext(cctx)
+
+		maddr, err := getActorAddress(ctx, nodeApi, cctx.String("actor"))
+		if err != nil {
+			return err
+		}
+
+		head, err := api.ChainHead(ctx)
+		if err != nil {
+			return xerrors.Errorf("getting chain head: %w", err)
+		}
+
+		mact, err := api.StateGetActor(ctx, maddr, head.Key())
+		if err != nil {
+			return err
+		}
+
+		stor := store.ActorStore(ctx, apibstore.NewAPIBlockstore(api))
+
+		mas, err := miner.Load(stor, mact)
+		if err != nil {
+			return err
+		}
+
+		cd, err := api.StateMinerProvingDeadline(ctx, maddr, head.Key())
+		if err != nil {
+			return xerrors.Errorf("getting miner info: %w", err)
+		}
+
+		fmt.Printf("Miner: %s\n", color.BlueString("%s", maddr))
+
+		proving := uint64(0)
+		faults := uint64(0)
+		recovering := uint64(0)
+		curDeadlineSectors := uint64(0)
+
+		if err := mas.ForEachDeadline(func(dlIdx uint64, dl miner.Deadline) error {
+			return dl.ForEachPartition(func(partIdx uint64, part miner.Partition) error {
+				if bf, err := part.LiveSectors(); err != nil {
+					return err
+				} else if count, err := bf.Count(); err != nil {
+					return err
+				} else {
+					proving += count
+					if dlIdx == cd.Index {
+						curDeadlineSectors += count
+					}
+				}
+
+				if bf, err := part.FaultySectors(); err != nil {
+					return err
+				} else if count, err := bf.Count(); err != nil {
+					return err
+				} else {
+					faults += count
+				}
+
+				if bf, err := part.RecoveringSectors(); err != nil {
+					return err
+				} else if count, err := bf.Count(); err != nil {
+					return err
+				} else {
+					recovering += count
+				}
+
+				return nil
+			})
+		}); err != nil {
+			return xerrors.Errorf("walking miner deadlines and partitions: %w", err)
+		}
+
+		var faultPerc float64
+		if proving > 0 {
+			faultPerc = float64(faults*10000/proving) / 100
+		}
+
+		fmt.Printf("Current Epoch:           %d\n", cd.CurrentEpoch)
+
+		fmt.Printf("Proving Period Boundary: %d\n", cd.PeriodStart%cd.WPoStProvingPeriod)
+		fmt.Printf("Proving Period Start:    %s\n", lcli.EpochTime(cd.CurrentEpoch, cd.PeriodStart))
+		fmt.Printf("Next Period Start:       %s\n\n", lcli.EpochTime(cd.CurrentEpoch, cd.PeriodStart+cd.WPoStProvingPeriod))
+
+		fmt.Printf("Faults:      %d (%.2f%%)\n", faults, faultPerc)
+		fmt.Printf("Recovering:  %d\n", recovering)
+
+		fmt.Printf("Deadline Index:       %d\n", cd.Index)
+		fmt.Printf("Deadline Sectors:     %d\n", curDeadlineSectors)
+		fmt.Printf("Deadline Open:        %s\n", lcli.EpochTime(cd.CurrentEpoch, cd.Open))
+		fmt.Printf("Deadline Close:       %s\n", lcli.EpochTime(cd.CurrentEpoch, cd.Close))
+		fmt.Printf("Deadline Challenge:   %s\n", lcli.EpochTime(cd.CurrentEpoch, cd.Challenge))
+		fmt.Printf("Deadline FaultCutoff: %s\n", lcli.EpochTime(cd.CurrentEpoch, cd.FaultCutoff))
+		return nil
+	},
+}
+
+var provingDeadlinesCmd = &cli.Command{
+	Name:  "deadlines",
+	Usage: "View the current proving period deadlines information",
+	Action: func(cctx *cli.Context) error {
+		color.NoColor = !cctx.Bool("color")
+
+		nodeApi, closer, err := lcli.GetStorageMinerAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+
+		api, acloser, err := lcli.GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer acloser()
+
+		ctx := lcli.ReqContext(cctx)
+
+		maddr, err := getActorAddress(ctx, nodeApi, cctx.String("actor"))
+		if err != nil {
+			return err
+		}
+
+		deadlines, err := api.StateMinerDeadlines(ctx, maddr, types.EmptyTSK)
+		if err != nil {
+			return xerrors.Errorf("getting deadlines: %w", err)
+		}
+
+		di, err := api.StateMinerProvingDeadline(ctx, maddr, types.EmptyTSK)
+		if err != nil {
+			return xerrors.Errorf("getting deadlines: %w", err)
+		}
+
+		fmt.Printf("Miner: %s\n", color.BlueString("%s", maddr))
+
+		tw := tabwriter.NewWriter(os.Stdout, 2, 4, 2, ' ', 0)
+		_, _ = fmt.Fprintln(tw, "deadline\tpartitions\tsectors (faults)\tproven partitions")
+
+		for dlIdx, deadline := range deadlines {
+			partitions, err := api.StateMinerPartitions(ctx, maddr, uint64(dlIdx), types.EmptyTSK)
+			if err != nil {
+				return xerrors.Errorf("getting partitions for deadline %d: %w", dlIdx, err)
+			}
+
+			provenPartitions, err := deadline.PostSubmissions.Count()
+			if err != nil {
+				return err
+			}
+
+			sectors := uint64(0)
+			faults := uint64(0)
+
+			for _, partition := range partitions {
+				sc, err := partition.AllSectors.Count()
+				if err != nil {
+					return err
+				}
+
+				sectors += sc
+
+				fc, err := partition.FaultySectors.Count()
+				if err != nil {
+					return err
+				}
+
+				faults += fc
+			}
+
+			var cur string
+			if di.Index == uint64(dlIdx) {
+				cur += "\t(current)"
+			}
+			_, _ = fmt.Fprintf(tw, "%d\t%d\t%d (%d)\t%d%s\n", dlIdx, len(partitions), sectors, faults, provenPartitions, cur)
+		}
+
+		return tw.Flush()
+	},
+}
+
+var provingDeadlineInfoCmd = &cli.Command{
+	Name:      "deadline",
+	Usage:     "View the current proving period deadline information by its index ",
+	ArgsUsage: "<deadlineIdx>",
+	Action: func(cctx *cli.Context) error {
+
+		if cctx.Args().Len() != 1 {
+			return xerrors.Errorf("must pass deadline index")
+		}
+
+		dlIdx, err := strconv.ParseUint(cctx.Args().Get(0), 10, 64)
+		if err != nil {
+			return xerrors.Errorf("could not parse deadline index: %w", err)
+		}
+
+		nodeApi, closer, err := lcli.GetStorageMinerAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+
+		api, acloser, err := lcli.GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer acloser()
+
+		ctx := lcli.ReqContext(cctx)
+
+		maddr, err := getActorAddress(ctx, nodeApi, cctx.String("actor"))
+		if err != nil {
+			return err
+		}
+
+		deadlines, err := api.StateMinerDeadlines(ctx, maddr, types.EmptyTSK)
+		if err != nil {
+			return xerrors.Errorf("getting deadlines: %w", err)
+		}
+
+		di, err := api.StateMinerProvingDeadline(ctx, maddr, types.EmptyTSK)
+		if err != nil {
+			return xerrors.Errorf("getting deadlines: %w", err)
+		}
+
+		partitions, err := api.StateMinerPartitions(ctx, maddr, dlIdx, types.EmptyTSK)
+		if err != nil {
+			return xerrors.Errorf("getting partitions for deadline %d: %w", dlIdx, err)
+		}
+
+		provenPartitions, err := deadlines[dlIdx].PostSubmissions.Count()
+		if err != nil {
+			return err
+		}
+
+		fmt.Printf("Deadline Index:           %d\n", dlIdx)
+		fmt.Printf("Partitions:               %d\n", len(partitions))
+		fmt.Printf("Proven Partitions:        %d\n", provenPartitions)
+		fmt.Printf("Current:                  %t\n\n", di.Index == dlIdx)
+
+		for pIdx, partition := range partitions {
+			sectorCount, err := partition.AllSectors.Count()
+			if err != nil {
+				return err
+			}
+
+			sectorNumbers, err := partition.AllSectors.All(sectorCount)
+			if err != nil {
+				return err
+			}
+
+			faultsCount, err := partition.FaultySectors.Count()
+			if err != nil {
+				return err
+			}
+
+			fn, err := partition.FaultySectors.All(faultsCount)
+			if err != nil {
+				return err
+			}
+
+			fmt.Printf("Partition Index:          %d\n", pIdx)
+			fmt.Printf("Sectors:                  %d\n", sectorCount)
+			fmt.Printf("Sector Numbers:           %v\n", sectorNumbers)
+			fmt.Printf("Faults:                   %d\n", faultsCount)
+			fmt.Printf("Faulty Sectors:           %d\n", fn)
+		}
+		return nil
+	},
+}
diff --git a/cmd/lotus-storage-miner/retrieval-deals.go b/cmd/lotus-storage-miner/retrieval-deals.go
new file mode 100644
index 000000000..03d397852
--- /dev/null
+++ b/cmd/lotus-storage-miner/retrieval-deals.go
@@ -0,0 +1,270 @@
+package main
+
+import (
+	"fmt"
+	"os"
+	"text/tabwriter"
+
+	"github.com/docker/go-units"
+	"github.com/filecoin-project/go-fil-markets/retrievalmarket"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/urfave/cli/v2"
+
+	"github.com/filecoin-project/lotus/chain/types"
+	lcli "github.com/filecoin-project/lotus/cli"
+)
+
+var retrievalDealsCmd = &cli.Command{
+	Name:  "retrieval-deals",
+	Usage: "Manage retrieval deals and related configuration",
+	Subcommands: []*cli.Command{
+		retrievalDealSelectionCmd,
+		retrievalDealsListCmd,
+		retrievalSetAskCmd,
+		retrievalGetAskCmd,
+	},
+}
+
+var retrievalDealSelectionCmd = &cli.Command{
+	Name:  "selection",
+	Usage: "Configure acceptance criteria for retrieval deal proposals",
+	Subcommands: []*cli.Command{
+		retrievalDealSelectionShowCmd,
+		retrievalDealSelectionResetCmd,
+		retrievalDealSelectionRejectCmd,
+	},
+}
+
+var retrievalDealSelectionShowCmd = &cli.Command{
+	Name:  "list",
+	Usage: "List retrieval deal proposal selection criteria",
+	Action: func(cctx *cli.Context) error {
+		smapi, closer, err := lcli.GetStorageMinerAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+
+		onlineOk, err := smapi.DealsConsiderOnlineRetrievalDeals(lcli.DaemonContext(cctx))
+		if err != nil {
+			return err
+		}
+
+		offlineOk, err := smapi.DealsConsiderOfflineRetrievalDeals(lcli.DaemonContext(cctx))
+		if err != nil {
+			return err
+		}
+
+		fmt.Printf("considering online retrieval deals: %t\n", onlineOk)
+		fmt.Printf("considering offline retrieval deals: %t\n", offlineOk)
+
+		return nil
+	},
+}
+
+var retrievalDealSelectionResetCmd = &cli.Command{
+	Name:  "reset",
+	Usage: "Reset retrieval deal proposal selection criteria to default values",
+	Action: func(cctx *cli.Context) error {
+		smapi, closer, err := lcli.GetStorageMinerAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+
+		err = smapi.DealsSetConsiderOnlineRetrievalDeals(lcli.DaemonContext(cctx), true)
+		if err != nil {
+			return err
+		}
+
+		err = smapi.DealsSetConsiderOfflineRetrievalDeals(lcli.DaemonContext(cctx), true)
+		if err != nil {
+			return err
+		}
+
+		return nil
+	},
+}
+
+var retrievalDealSelectionRejectCmd = &cli.Command{
+	Name:  "reject",
+	Usage: "Configure criteria which necessitate automatic rejection",
+	Flags: []cli.Flag{
+		&cli.BoolFlag{
+			Name: "online",
+		},
+		&cli.BoolFlag{
+			Name: "offline",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		smapi, closer, err := lcli.GetStorageMinerAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+
+		if cctx.Bool("online") {
+			err = smapi.DealsSetConsiderOnlineRetrievalDeals(lcli.DaemonContext(cctx), false)
+			if err != nil {
+				return err
+			}
+		}
+
+		if cctx.Bool("offline") {
+			err = smapi.DealsSetConsiderOfflineRetrievalDeals(lcli.DaemonContext(cctx), false)
+			if err != nil {
+				return err
+			}
+		}
+
+		return nil
+	},
+}
+
+var retrievalDealsListCmd = &cli.Command{
+	Name:  "list",
+	Usage: "List all active retrieval deals for this miner",
+	Action: func(cctx *cli.Context) error {
+		api, closer, err := lcli.GetStorageMinerAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+
+		deals, err := api.MarketListRetrievalDeals(lcli.DaemonContext(cctx))
+		if err != nil {
+			return err
+		}
+
+		w := tabwriter.NewWriter(os.Stdout, 2, 4, 2, ' ', 0)
+
+		_, _ = fmt.Fprintf(w, "Receiver\tDealID\tPayload\tState\tPricePerByte\tBytesSent\tMessage\n")
+
+		for _, deal := range deals {
+			payloadCid := deal.PayloadCID.String()
+
+			_, _ = fmt.Fprintf(w,
+				"%s\t%d\t%s\t%s\t%s\t%d\t%s\n",
+				deal.Receiver.String(),
+				deal.ID,
+				"..."+payloadCid[len(payloadCid)-8:],
+				retrievalmarket.DealStatuses[deal.Status],
+				deal.PricePerByte.String(),
+				deal.TotalSent,
+				deal.Message,
+			)
+		}
+
+		return w.Flush()
+	},
+}
+
+var retrievalSetAskCmd = &cli.Command{
+	Name:  "set-ask",
+	Usage: "Configure the provider's retrieval ask",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:  "price",
+			Usage: "Set the price of the ask for retrievals (FIL/GiB)",
+		},
+		&cli.StringFlag{
+			Name:  "unseal-price",
+			Usage: "Set the price to unseal",
+		},
+		&cli.StringFlag{
+			Name:        "payment-interval",
+			Usage:       "Set the payment interval (in bytes) for retrieval",
+			DefaultText: "1MiB",
+		},
+		&cli.StringFlag{
+			Name:        "payment-interval-increase",
+			Usage:       "Set the payment interval increase (in bytes) for retrieval",
+			DefaultText: "1MiB",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		ctx := lcli.DaemonContext(cctx)
+
+		api, closer, err := lcli.GetStorageMinerAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+
+		ask, err := api.MarketGetRetrievalAsk(ctx)
+		if err != nil {
+			return err
+		}
+
+		if cctx.IsSet("price") {
+			v, err := types.ParseFIL(cctx.String("price"))
+			if err != nil {
+				return err
+			}
+			ask.PricePerByte = types.BigDiv(types.BigInt(v), types.NewInt(1<<30))
+		}
+
+		if cctx.IsSet("unseal-price") {
+			v, err := types.ParseFIL(cctx.String("unseal-price"))
+			if err != nil {
+				return err
+			}
+			ask.UnsealPrice = abi.TokenAmount(v)
+		}
+
+		if cctx.IsSet("payment-interval") {
+			v, err := units.RAMInBytes(cctx.String("payment-interval"))
+			if err != nil {
+				return err
+			}
+			ask.PaymentInterval = uint64(v)
+		}
+
+		if cctx.IsSet("payment-interval-increase") {
+			v, err := units.RAMInBytes(cctx.String("payment-interval-increase"))
+			if err != nil {
+				return err
+			}
+			ask.PaymentIntervalIncrease = uint64(v)
+		}
+
+		return api.MarketSetRetrievalAsk(ctx, ask)
+	},
+}
+
+var retrievalGetAskCmd = &cli.Command{
+	Name:  "get-ask",
+	Usage: "Get the provider's current retrieval ask",
+	Flags: []cli.Flag{},
+	Action: func(cctx *cli.Context) error {
+		ctx := lcli.DaemonContext(cctx)
+
+		api, closer, err := lcli.GetStorageMinerAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+
+		ask, err := api.MarketGetRetrievalAsk(ctx)
+		if err != nil {
+			return err
+		}
+
+		w := tabwriter.NewWriter(os.Stdout, 2, 4, 2, ' ', 0)
+		fmt.Fprintf(w, "Price per Byte\tUnseal Price\tPayment Interval\tPayment Interval Increase\n")
+		if ask == nil {
+			fmt.Fprintf(w, "<miner does not have an retrieval ask set>\n")
+			return w.Flush()
+		}
+
+		fmt.Fprintf(w, "%s\t%s\t%s\t%s\n",
+			types.FIL(ask.PricePerByte),
+			types.FIL(ask.UnsealPrice),
+			units.BytesSize(float64(ask.PaymentInterval)),
+			units.BytesSize(float64(ask.PaymentIntervalIncrease)),
+		)
+		return w.Flush()
+
+	},
+}
diff --git a/cmd/lotus-storage-miner/run.go b/cmd/lotus-storage-miner/run.go
index 080dabcee..a5d996f78 100644
--- a/cmd/lotus-storage-miner/run.go
+++ b/cmd/lotus-storage-miner/run.go
@@ -10,28 +10,31 @@ import (
 
 	mux "github.com/gorilla/mux"
 	"github.com/multiformats/go-multiaddr"
-	manet "github.com/multiformats/go-multiaddr-net"
+	manet "github.com/multiformats/go-multiaddr/net"
+	"github.com/urfave/cli/v2"
 	"golang.org/x/xerrors"
-	"gopkg.in/urfave/cli.v2"
+
+	"github.com/filecoin-project/go-jsonrpc"
+	"github.com/filecoin-project/go-jsonrpc/auth"
 
 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/api/apistruct"
 	"github.com/filecoin-project/lotus/build"
 	lcli "github.com/filecoin-project/lotus/cli"
-	"github.com/filecoin-project/lotus/lib/auth"
-	"github.com/filecoin-project/lotus/lib/jsonrpc"
+	"github.com/filecoin-project/lotus/lib/ulimit"
 	"github.com/filecoin-project/lotus/node"
 	"github.com/filecoin-project/lotus/node/impl"
+	"github.com/filecoin-project/lotus/node/modules/dtypes"
 	"github.com/filecoin-project/lotus/node/repo"
 )
 
 var runCmd = &cli.Command{
 	Name:  "run",
-	Usage: "Start a lotus storage miner process",
+	Usage: "Start a lotus miner process",
 	Flags: []cli.Flag{
 		&cli.StringFlag{
 			Name:  "api",
-			Value: "2345",
+			Usage: "2345",
 		},
 		&cli.BoolFlag{
 			Name:  "enable-gpu-proving",
@@ -42,10 +45,18 @@ var runCmd = &cli.Command{
 			Name:  "nosync",
 			Usage: "don't check full-node sync status",
 		},
+		&cli.BoolFlag{
+			Name:  "manage-fdlimit",
+			Usage: "manage open file limit",
+			Value: true,
+		},
 	},
 	Action: func(cctx *cli.Context) error {
 		if !cctx.Bool("enable-gpu-proving") {
-			os.Setenv("BELLMAN_NO_GPU", "true")
+			err := os.Setenv("BELLMAN_NO_GPU", "true")
+			if err != nil {
+				return err
+			}
 		}
 
 		nodeApi, ncloser, err := lcli.GetFullNodeAPI(cctx)
@@ -60,8 +71,14 @@ var runCmd = &cli.Command{
 			return err
 		}
 
-		if v.APIVersion != build.APIVersion {
-			return xerrors.Errorf("lotus-daemon API version doesn't match: local: %s", api.Version{APIVersion: build.APIVersion})
+		if cctx.Bool("manage-fdlimit") {
+			if _, _, err := ulimit.ManageFdLimit(); err != nil {
+				log.Errorf("setting file descriptor limit: %s", err)
+			}
+		}
+
+		if v.APIVersion != build.FullAPIVersion {
+			return xerrors.Errorf("lotus-daemon API version doesn't match: expected: %s", api.Version{APIVersion: build.FullAPIVersion})
 		}
 
 		log.Info("Checking full node sync status")
@@ -72,8 +89,8 @@ var runCmd = &cli.Command{
 			}
 		}
 
-		storageRepoPath := cctx.String(FlagStorageRepo)
-		r, err := repo.NewFS(storageRepoPath)
+		minerRepoPath := cctx.String(FlagMinerRepo)
+		r, err := repo.NewFS(minerRepoPath)
 		if err != nil {
 			return err
 		}
@@ -83,23 +100,21 @@ var runCmd = &cli.Command{
 			return err
 		}
 		if !ok {
-			return xerrors.Errorf("repo at '%s' is not initialized, run 'lotus-storage-miner init' to set it up", storageRepoPath)
+			return xerrors.Errorf("repo at '%s' is not initialized, run 'lotus-miner init' to set it up", minerRepoPath)
 		}
 
+		shutdownChan := make(chan struct{})
+
 		var minerapi api.StorageMiner
 		stop, err := node.New(ctx,
 			node.StorageMiner(&minerapi),
+			node.Override(new(dtypes.ShutdownChan), shutdownChan),
 			node.Online(),
 			node.Repo(r),
 
 			node.ApplyIf(func(s *node.Settings) bool { return cctx.IsSet("api") },
-				node.Override(node.SetApiEndpointKey, func(lr repo.LockedRepo) error {
-					apima, err := multiaddr.NewMultiaddr("/ip4/127.0.0.1/tcp/" +
-						cctx.String("api"))
-					if err != nil {
-						return err
-					}
-					return lr.SetAPIEndpoint(apima)
+				node.Override(new(dtypes.APIEndpoint), func() (dtypes.APIEndpoint, error) {
+					return multiaddr.NewMultiaddr("/ip4/127.0.0.1/tcp/" + cctx.String("api"))
 				})),
 			node.Override(new(api.FullNode), nodeApi),
 		)
@@ -147,8 +162,14 @@ var runCmd = &cli.Command{
 
 		sigChan := make(chan os.Signal, 2)
 		go func() {
-			<-sigChan
-			log.Warn("Shutting down..")
+			select {
+			case sig := <-sigChan:
+				log.Warnw("received shutdown", "signal", sig)
+			case <-shutdownChan:
+				log.Warn("received shutdown")
+			}
+
+			log.Warn("Shutting down...")
 			if err := stop(context.TODO()); err != nil {
 				log.Errorf("graceful shutting down failed: %s", err)
 			}
diff --git a/cmd/lotus-storage-miner/sealing.go b/cmd/lotus-storage-miner/sealing.go
new file mode 100644
index 000000000..5cc5c419a
--- /dev/null
+++ b/cmd/lotus-storage-miner/sealing.go
@@ -0,0 +1,216 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"sort"
+	"strings"
+	"text/tabwriter"
+	"time"
+
+	"golang.org/x/xerrors"
+
+	"github.com/fatih/color"
+	"github.com/urfave/cli/v2"
+
+	"github.com/filecoin-project/lotus/extern/sector-storage/storiface"
+
+	"github.com/filecoin-project/lotus/chain/types"
+	lcli "github.com/filecoin-project/lotus/cli"
+)
+
+var sealingCmd = &cli.Command{
+	Name:  "sealing",
+	Usage: "interact with sealing pipeline",
+	Subcommands: []*cli.Command{
+		sealingJobsCmd,
+		sealingWorkersCmd,
+		sealingSchedDiagCmd,
+	},
+}
+
+var sealingWorkersCmd = &cli.Command{
+	Name:  "workers",
+	Usage: "list workers",
+	Flags: []cli.Flag{
+		&cli.BoolFlag{Name: "color"},
+	},
+	Action: func(cctx *cli.Context) error {
+		color.NoColor = !cctx.Bool("color")
+
+		nodeApi, closer, err := lcli.GetStorageMinerAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+
+		ctx := lcli.ReqContext(cctx)
+
+		stats, err := nodeApi.WorkerStats(ctx)
+		if err != nil {
+			return err
+		}
+
+		type sortableStat struct {
+			id uint64
+			storiface.WorkerStats
+		}
+
+		st := make([]sortableStat, 0, len(stats))
+		for id, stat := range stats {
+			st = append(st, sortableStat{id, stat})
+		}
+
+		sort.Slice(st, func(i, j int) bool {
+			return st[i].id < st[j].id
+		})
+
+		for _, stat := range st {
+			gpuUse := "not "
+			gpuCol := color.FgBlue
+			if stat.GpuUsed {
+				gpuCol = color.FgGreen
+				gpuUse = ""
+			}
+
+			fmt.Printf("Worker %d, host %s\n", stat.id, color.MagentaString(stat.Info.Hostname))
+
+			var barCols = uint64(64)
+			cpuBars := int(stat.CpuUse * barCols / stat.Info.Resources.CPUs)
+			cpuBar := strings.Repeat("|", cpuBars) + strings.Repeat(" ", int(barCols)-cpuBars)
+
+			fmt.Printf("\tCPU:  [%s] %d core(s) in use\n", color.GreenString(cpuBar), stat.CpuUse)
+
+			ramBarsRes := int(stat.Info.Resources.MemReserved * barCols / stat.Info.Resources.MemPhysical)
+			ramBarsUsed := int(stat.MemUsedMin * barCols / stat.Info.Resources.MemPhysical)
+			ramBar := color.YellowString(strings.Repeat("|", ramBarsRes)) +
+				color.GreenString(strings.Repeat("|", ramBarsUsed)) +
+				strings.Repeat(" ", int(barCols)-ramBarsUsed-ramBarsRes)
+
+			vmem := stat.Info.Resources.MemPhysical + stat.Info.Resources.MemSwap
+
+			vmemBarsRes := int(stat.Info.Resources.MemReserved * barCols / vmem)
+			vmemBarsUsed := int(stat.MemUsedMax * barCols / vmem)
+			vmemBar := color.YellowString(strings.Repeat("|", vmemBarsRes)) +
+				color.GreenString(strings.Repeat("|", vmemBarsUsed)) +
+				strings.Repeat(" ", int(barCols)-vmemBarsUsed-vmemBarsRes)
+
+			fmt.Printf("\tRAM:  [%s] %d%% %s/%s\n", ramBar,
+				(stat.Info.Resources.MemReserved+stat.MemUsedMin)*100/stat.Info.Resources.MemPhysical,
+				types.SizeStr(types.NewInt(stat.Info.Resources.MemReserved+stat.MemUsedMin)),
+				types.SizeStr(types.NewInt(stat.Info.Resources.MemPhysical)))
+
+			fmt.Printf("\tVMEM: [%s] %d%% %s/%s\n", vmemBar,
+				(stat.Info.Resources.MemReserved+stat.MemUsedMax)*100/vmem,
+				types.SizeStr(types.NewInt(stat.Info.Resources.MemReserved+stat.MemUsedMax)),
+				types.SizeStr(types.NewInt(vmem)))
+
+			for _, gpu := range stat.Info.Resources.GPUs {
+				fmt.Printf("\tGPU: %s\n", color.New(gpuCol).Sprintf("%s, %sused", gpu, gpuUse))
+			}
+		}
+
+		return nil
+	},
+}
+
+var sealingJobsCmd = &cli.Command{
+	Name:  "jobs",
+	Usage: "list workers",
+	Flags: []cli.Flag{
+		&cli.BoolFlag{Name: "color"},
+	},
+	Action: func(cctx *cli.Context) error {
+		color.NoColor = !cctx.Bool("color")
+
+		nodeApi, closer, err := lcli.GetStorageMinerAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+
+		ctx := lcli.ReqContext(cctx)
+
+		jobs, err := nodeApi.WorkerJobs(ctx)
+		if err != nil {
+			return xerrors.Errorf("getting worker jobs: %w", err)
+		}
+
+		type line struct {
+			storiface.WorkerJob
+			wid uint64
+		}
+
+		lines := make([]line, 0)
+
+		for wid, jobs := range jobs {
+			for _, job := range jobs {
+				lines = append(lines, line{
+					WorkerJob: job,
+					wid:       wid,
+				})
+			}
+		}
+
+		// oldest first
+		sort.Slice(lines, func(i, j int) bool {
+			if lines[i].RunWait != lines[j].RunWait {
+				return lines[i].RunWait < lines[j].RunWait
+			}
+			return lines[i].Start.Before(lines[j].Start)
+		})
+
+		workerHostnames := map[uint64]string{}
+
+		wst, err := nodeApi.WorkerStats(ctx)
+		if err != nil {
+			return xerrors.Errorf("getting worker stats: %w", err)
+		}
+
+		for wid, st := range wst {
+			workerHostnames[wid] = st.Info.Hostname
+		}
+
+		tw := tabwriter.NewWriter(os.Stdout, 2, 4, 2, ' ', 0)
+		_, _ = fmt.Fprintf(tw, "ID\tSector\tWorker\tHostname\tTask\tState\tTime\n")
+
+		for _, l := range lines {
+			state := "running"
+			if l.RunWait != 0 {
+				state = fmt.Sprintf("assigned(%d)", l.RunWait-1)
+			}
+			_, _ = fmt.Fprintf(tw, "%d\t%d\t%d\t%s\t%s\t%s\t%s\n", l.ID, l.Sector.Number, l.wid, workerHostnames[l.wid], l.Task.Short(), state, time.Now().Sub(l.Start).Truncate(time.Millisecond*100))
+		}
+
+		return tw.Flush()
+	},
+}
+
+var sealingSchedDiagCmd = &cli.Command{
+	Name:  "sched-diag",
+	Usage: "Dump internal scheduler state",
+	Action: func(cctx *cli.Context) error {
+		nodeApi, closer, err := lcli.GetStorageMinerAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+
+		ctx := lcli.ReqContext(cctx)
+
+		st, err := nodeApi.SealingSchedDiag(ctx)
+		if err != nil {
+			return err
+		}
+
+		j, err := json.MarshalIndent(&st, "", "  ")
+		if err != nil {
+			return err
+		}
+
+		fmt.Println(string(j))
+
+		return nil
+	},
+}
diff --git a/cmd/lotus-storage-miner/sectors.go b/cmd/lotus-storage-miner/sectors.go
index bdc73f236..370962bdc 100644
--- a/cmd/lotus-storage-miner/sectors.go
+++ b/cmd/lotus-storage-miner/sectors.go
@@ -2,18 +2,46 @@ package main
 
 import (
 	"fmt"
+	"os"
 	"sort"
 	"strconv"
+	"text/tabwriter"
+	"time"
 
+	"github.com/urfave/cli/v2"
 	"golang.org/x/xerrors"
-	"gopkg.in/urfave/cli.v2"
+
+	"github.com/filecoin-project/go-state-types/abi"
+
+	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
 
 	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
+	"github.com/filecoin-project/lotus/chain/types"
+
 	lcli "github.com/filecoin-project/lotus/cli"
+	sealing "github.com/filecoin-project/lotus/extern/storage-sealing"
 )
 
-var pledgeSectorCmd = &cli.Command{
-	Name:  "pledge-sector",
+var sectorsCmd = &cli.Command{
+	Name:  "sectors",
+	Usage: "interact with sector store",
+	Subcommands: []*cli.Command{
+		sectorsStatusCmd,
+		sectorsListCmd,
+		sectorsRefsCmd,
+		sectorsUpdateCmd,
+		sectorsPledgeCmd,
+		sectorsRemoveCmd,
+		sectorsMarkForUpgradeCmd,
+		sectorsStartSealCmd,
+		sectorsSealDelayCmd,
+		sectorsCapacityCollateralCmd,
+	},
+}
+
+var sectorsPledgeCmd = &cli.Command{
+	Name:  "pledge",
 	Usage: "store random data in a sector",
 	Action: func(cctx *cli.Context) error {
 		nodeApi, closer, err := lcli.GetStorageMinerAPI(cctx)
@@ -27,20 +55,20 @@ var pledgeSectorCmd = &cli.Command{
 	},
 }
 
-var sectorsCmd = &cli.Command{
-	Name:  "sectors",
-	Usage: "interact with sector store",
-	Subcommands: []*cli.Command{
-		sectorsStatusCmd,
-		sectorsListCmd,
-		sectorsRefsCmd,
-		sectorsUpdateCmd,
-	},
-}
-
 var sectorsStatusCmd = &cli.Command{
-	Name:  "status",
-	Usage: "Get the seal status of a sector by its ID",
+	Name:      "status",
+	Usage:     "Get the seal status of a sector by its number",
+	ArgsUsage: "<sectorNum>",
+	Flags: []cli.Flag{
+		&cli.BoolFlag{
+			Name:  "log",
+			Usage: "display event log",
+		},
+		&cli.BoolFlag{
+			Name:  "on-chain-info",
+			Usage: "show sector on chain info",
+		},
+	},
 	Action: func(cctx *cli.Context) error {
 		nodeApi, closer, err := lcli.GetStorageMinerAPI(cctx)
 		if err != nil {
@@ -50,7 +78,7 @@ var sectorsStatusCmd = &cli.Command{
 		ctx := lcli.ReqContext(cctx)
 
 		if !cctx.Args().Present() {
-			return fmt.Errorf("must specify sector ID to get status of")
+			return fmt.Errorf("must specify sector number to get status of")
 		}
 
 		id, err := strconv.ParseUint(cctx.Args().First(), 10, 64)
@@ -58,25 +86,52 @@ var sectorsStatusCmd = &cli.Command{
 			return err
 		}
 
-		status, err := nodeApi.SectorsStatus(ctx, id)
+		onChainInfo := cctx.Bool("on-chain-info")
+		status, err := nodeApi.SectorsStatus(ctx, abi.SectorNumber(id), onChainInfo)
 		if err != nil {
 			return err
 		}
 
 		fmt.Printf("SectorID:\t%d\n", status.SectorID)
-		fmt.Printf("Status:\t%s\n", api.SectorStates[status.State])
-		fmt.Printf("CommD:\t\t%x\n", status.CommD)
-		fmt.Printf("CommR:\t\t%x\n", status.CommR)
-		fmt.Printf("Ticket:\t\t%x\n", status.Ticket.TicketBytes)
-		fmt.Printf("TicketH:\t\t%d\n", status.Ticket.BlockHeight)
-		fmt.Printf("Seed:\t\t%x\n", status.Seed.TicketBytes)
-		fmt.Printf("SeedH:\t\t%d\n", status.Seed.BlockHeight)
+		fmt.Printf("Status:\t\t%s\n", status.State)
+		fmt.Printf("CIDcommD:\t%s\n", status.CommD)
+		fmt.Printf("CIDcommR:\t%s\n", status.CommR)
+		fmt.Printf("Ticket:\t\t%x\n", status.Ticket.Value)
+		fmt.Printf("TicketH:\t%d\n", status.Ticket.Epoch)
+		fmt.Printf("Seed:\t\t%x\n", status.Seed.Value)
+		fmt.Printf("SeedH:\t\t%d\n", status.Seed.Epoch)
+		fmt.Printf("Precommit:\t%s\n", status.PreCommitMsg)
+		fmt.Printf("Commit:\t\t%s\n", status.CommitMsg)
 		fmt.Printf("Proof:\t\t%x\n", status.Proof)
 		fmt.Printf("Deals:\t\t%v\n", status.Deals)
-		fmt.Printf("Retries:\t\t%d\n", status.Retries)
+		fmt.Printf("Retries:\t%d\n", status.Retries)
 		if status.LastErr != "" {
 			fmt.Printf("Last Error:\t\t%s\n", status.LastErr)
 		}
+
+		if onChainInfo {
+			fmt.Printf("\nSector On Chain Info\n")
+			fmt.Printf("SealProof:\t\t%x\n", status.SealProof)
+			fmt.Printf("Activation:\t\t%v\n", status.Activation)
+			fmt.Printf("Expiration:\t\t%v\n", status.Expiration)
+			fmt.Printf("DealWeight:\t\t%v\n", status.DealWeight)
+			fmt.Printf("VerifiedDealWeight:\t\t%v\n", status.VerifiedDealWeight)
+			fmt.Printf("InitialPledge:\t\t%v\n", status.InitialPledge)
+			fmt.Printf("\nExpiration Info\n")
+			fmt.Printf("OnTime:\t\t%v\n", status.OnTime)
+			fmt.Printf("Early:\t\t%v\n", status.Early)
+		}
+
+		if cctx.Bool("log") {
+			fmt.Printf("--------\nEvent Log:\n")
+
+			for i, l := range status.Log {
+				fmt.Printf("%d.\t%s:\t[%s]\t%s\n", i, time.Unix(int64(l.Timestamp), 0), l.Kind, l.Message)
+				if l.Trace != "" {
+					fmt.Printf("\t%s\n", l.Trace)
+				}
+			}
+		}
 		return nil
 	},
 }
@@ -84,6 +139,12 @@ var sectorsStatusCmd = &cli.Command{
 var sectorsListCmd = &cli.Command{
 	Name:  "list",
 	Usage: "List sectors",
+	Flags: []cli.Flag{
+		&cli.BoolFlag{
+			Name:  "show-removed",
+			Usage: "show removed sectors",
+		},
+	},
 	Action: func(cctx *cli.Context) error {
 		nodeApi, closer, err := lcli.GetStorageMinerAPI(cctx)
 		if err != nil {
@@ -109,49 +170,55 @@ var sectorsListCmd = &cli.Command{
 			return err
 		}
 
-		pset, err := fullApi.StateMinerProvingSet(ctx, maddr, nil)
+		activeSet, err := fullApi.StateMinerActiveSectors(ctx, maddr, types.EmptyTSK)
 		if err != nil {
 			return err
 		}
-		provingIDs := make(map[uint64]struct{}, len(pset))
-		for _, info := range pset {
-			provingIDs[info.SectorID] = struct{}{}
+		activeIDs := make(map[abi.SectorNumber]struct{}, len(activeSet))
+		for _, info := range activeSet {
+			activeIDs[info.SectorNumber] = struct{}{}
 		}
 
-		sset, err := fullApi.StateMinerSectors(ctx, maddr, nil)
+		sset, err := fullApi.StateMinerSectors(ctx, maddr, nil, types.EmptyTSK)
 		if err != nil {
 			return err
 		}
-		commitedIDs := make(map[uint64]struct{}, len(pset))
+		commitedIDs := make(map[abi.SectorNumber]struct{}, len(activeSet))
 		for _, info := range sset {
-			commitedIDs[info.SectorID] = struct{}{}
+			commitedIDs[info.SectorNumber] = struct{}{}
 		}
 
 		sort.Slice(list, func(i, j int) bool {
 			return list[i] < list[j]
 		})
 
+		w := tabwriter.NewWriter(os.Stdout, 8, 4, 1, ' ', 0)
+
 		for _, s := range list {
-			st, err := nodeApi.SectorsStatus(ctx, s)
+			st, err := nodeApi.SectorsStatus(ctx, s, false)
 			if err != nil {
-				fmt.Printf("%d:\tError: %s\n", s, err)
+				fmt.Fprintf(w, "%d:\tError: %s\n", s, err)
 				continue
 			}
 
-			_, inSSet := commitedIDs[s]
-			_, inPSet := provingIDs[s]
+			if cctx.Bool("show-removed") || st.State != api.SectorState(sealing.Removed) {
+				_, inSSet := commitedIDs[s]
+				_, inASet := activeIDs[s]
 
-			fmt.Printf("%d: %s\tsSet: %s\tpSet: %s\ttktH: %d\tseedH: %d\tdeals: %v\n",
-				s,
-				api.SectorStates[st.State],
-				yesno(inSSet),
-				yesno(inPSet),
-				st.Ticket.BlockHeight,
-				st.Seed.BlockHeight,
-				st.Deals,
-			)
+				_, _ = fmt.Fprintf(w, "%d: %s\tsSet: %s\tactive: %s\ttktH: %d\tseedH: %d\tdeals: %v\t toUpgrade:%t\n",
+					s,
+					st.State,
+					yesno(inSSet),
+					yesno(inASet),
+					st.Ticket.Epoch,
+					st.Seed.Epoch,
+					st.Deals,
+					st.ToUpgrade,
+				)
+			}
 		}
-		return nil
+
+		return w.Flush()
 	},
 }
 
@@ -181,9 +248,165 @@ var sectorsRefsCmd = &cli.Command{
 	},
 }
 
+var sectorsRemoveCmd = &cli.Command{
+	Name:      "remove",
+	Usage:     "Forcefully remove a sector (WARNING: This means losing power and collateral for the removed sector)",
+	ArgsUsage: "<sectorNum>",
+	Flags: []cli.Flag{
+		&cli.BoolFlag{
+			Name:  "really-do-it",
+			Usage: "pass this flag if you know what you are doing",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		if !cctx.Bool("really-do-it") {
+			return xerrors.Errorf("this is a command for advanced users, only use it if you are sure of what you are doing")
+		}
+		nodeApi, closer, err := lcli.GetStorageMinerAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+		ctx := lcli.ReqContext(cctx)
+		if cctx.Args().Len() != 1 {
+			return xerrors.Errorf("must pass sector number")
+		}
+
+		id, err := strconv.ParseUint(cctx.Args().Get(0), 10, 64)
+		if err != nil {
+			return xerrors.Errorf("could not parse sector number: %w", err)
+		}
+
+		return nodeApi.SectorRemove(ctx, abi.SectorNumber(id))
+	},
+}
+
+var sectorsMarkForUpgradeCmd = &cli.Command{
+	Name:      "mark-for-upgrade",
+	Usage:     "Mark a committed capacity sector for replacement by a sector with deals",
+	ArgsUsage: "<sectorNum>",
+	Action: func(cctx *cli.Context) error {
+		if cctx.Args().Len() != 1 {
+			return lcli.ShowHelp(cctx, xerrors.Errorf("must pass sector number"))
+		}
+
+		nodeApi, closer, err := lcli.GetStorageMinerAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+		ctx := lcli.ReqContext(cctx)
+
+		id, err := strconv.ParseUint(cctx.Args().Get(0), 10, 64)
+		if err != nil {
+			return xerrors.Errorf("could not parse sector number: %w", err)
+		}
+
+		return nodeApi.SectorMarkForUpgrade(ctx, abi.SectorNumber(id))
+	},
+}
+
+var sectorsStartSealCmd = &cli.Command{
+	Name:      "seal",
+	Usage:     "Manually start sealing a sector (filling any unused space with junk)",
+	ArgsUsage: "<sectorNum>",
+	Action: func(cctx *cli.Context) error {
+		nodeApi, closer, err := lcli.GetStorageMinerAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+		ctx := lcli.ReqContext(cctx)
+		if cctx.Args().Len() != 1 {
+			return xerrors.Errorf("must pass sector number")
+		}
+
+		id, err := strconv.ParseUint(cctx.Args().Get(0), 10, 64)
+		if err != nil {
+			return xerrors.Errorf("could not parse sector number: %w", err)
+		}
+
+		return nodeApi.SectorStartSealing(ctx, abi.SectorNumber(id))
+	},
+}
+
+var sectorsSealDelayCmd = &cli.Command{
+	Name:      "set-seal-delay",
+	Usage:     "Set the time, in minutes, that a new sector waits for deals before sealing starts",
+	ArgsUsage: "<minutes>",
+	Action: func(cctx *cli.Context) error {
+		nodeApi, closer, err := lcli.GetStorageMinerAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+		ctx := lcli.ReqContext(cctx)
+		if cctx.Args().Len() != 1 {
+			return xerrors.Errorf("must pass duration in minutes")
+		}
+
+		hs, err := strconv.ParseUint(cctx.Args().Get(0), 10, 64)
+		if err != nil {
+			return xerrors.Errorf("could not parse sector number: %w", err)
+		}
+
+		delay := hs * uint64(time.Minute)
+
+		return nodeApi.SectorSetSealDelay(ctx, time.Duration(delay))
+	},
+}
+
+var sectorsCapacityCollateralCmd = &cli.Command{
+	Name:  "get-cc-collateral",
+	Usage: "Get the collateral required to pledge a committed capacity sector",
+	Flags: []cli.Flag{
+		&cli.Uint64Flag{
+			Name:  "expiration",
+			Usage: "the epoch when the sector will expire",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+
+		mApi, mCloser, err := lcli.GetStorageMinerAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer mCloser()
+
+		nApi, nCloser, err := lcli.GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer nCloser()
+
+		ctx := lcli.ReqContext(cctx)
+
+		maddr, err := mApi.ActorAddress(ctx)
+		if err != nil {
+			return err
+		}
+
+		pci := miner.SectorPreCommitInfo{
+			Expiration: abi.ChainEpoch(cctx.Uint64("expiration")),
+		}
+		if pci.Expiration == 0 {
+			pci.Expiration = miner0.MaxSectorExpirationExtension
+		}
+		pc, err := nApi.StateMinerInitialPledgeCollateral(ctx, maddr, pci, types.EmptyTSK)
+		if err != nil {
+			return err
+		}
+
+		fmt.Printf("Estimated collateral: %s\n", types.FIL(pc))
+
+		return nil
+	},
+}
+
 var sectorsUpdateCmd = &cli.Command{
-	Name:  "update-state",
-	Usage: "ADVANCED: manually update the state of a sector, this may aid in error recovery",
+	Name:      "update-state",
+	Usage:     "ADVANCED: manually update the state of a sector, this may aid in error recovery",
+	ArgsUsage: "<sectorNum> <newState>",
 	Flags: []cli.Flag{
 		&cli.BoolFlag{
 			Name:  "really-do-it",
@@ -201,22 +424,24 @@ var sectorsUpdateCmd = &cli.Command{
 		defer closer()
 		ctx := lcli.ReqContext(cctx)
 		if cctx.Args().Len() < 2 {
-			return xerrors.Errorf("must pass sector ID and new state")
+			return xerrors.Errorf("must pass sector number and new state")
 		}
 
 		id, err := strconv.ParseUint(cctx.Args().Get(0), 10, 64)
 		if err != nil {
-			return xerrors.Errorf("could not parse sector ID: %w", err)
+			return xerrors.Errorf("could not parse sector number: %w", err)
 		}
 
-		var st api.SectorState
-		for i, s := range api.SectorStates {
-			if cctx.Args().Get(1) == s {
-				st = api.SectorState(i)
+		newState := cctx.Args().Get(1)
+		if _, ok := sealing.ExistSectorStateList[sealing.SectorState(newState)]; !ok {
+			fmt.Printf(" \"%s\" is not a valid state. Possible states for sectors are: \n", newState)
+			for state := range sealing.ExistSectorStateList {
+				fmt.Printf("%s\n", string(state))
 			}
+			return nil
 		}
 
-		return nodeApi.SectorsUpdate(ctx, id, st)
+		return nodeApi.SectorsUpdate(ctx, abi.SectorNumber(id), api.SectorState(cctx.Args().Get(1)))
 	},
 }
 
diff --git a/cmd/lotus-storage-miner/stop.go b/cmd/lotus-storage-miner/stop.go
new file mode 100644
index 000000000..186a15616
--- /dev/null
+++ b/cmd/lotus-storage-miner/stop.go
@@ -0,0 +1,29 @@
+package main
+
+import (
+	_ "net/http/pprof"
+
+	"github.com/urfave/cli/v2"
+
+	lcli "github.com/filecoin-project/lotus/cli"
+)
+
+var stopCmd = &cli.Command{
+	Name:  "stop",
+	Usage: "Stop a running lotus miner",
+	Flags: []cli.Flag{},
+	Action: func(cctx *cli.Context) error {
+		api, closer, err := lcli.GetAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+
+		err = api.Shutdown(lcli.ReqContext(cctx))
+		if err != nil {
+			return err
+		}
+
+		return nil
+	},
+}
diff --git a/cmd/lotus-storage-miner/storage.go b/cmd/lotus-storage-miner/storage.go
new file mode 100644
index 000000000..8a3687877
--- /dev/null
+++ b/cmd/lotus-storage-miner/storage.go
@@ -0,0 +1,386 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/fatih/color"
+	"github.com/google/uuid"
+	"github.com/mitchellh/go-homedir"
+	"github.com/urfave/cli/v2"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/lotus/extern/sector-storage/fsutil"
+	"github.com/filecoin-project/lotus/extern/sector-storage/stores"
+
+	"github.com/filecoin-project/lotus/chain/types"
+	lcli "github.com/filecoin-project/lotus/cli"
+)
+
+const metaFile = "sectorstore.json"
+
+var storageCmd = &cli.Command{
+	Name:  "storage",
+	Usage: "manage sector storage",
+	Subcommands: []*cli.Command{
+		storageAttachCmd,
+		storageListCmd,
+		storageFindCmd,
+	},
+}
+
+var storageAttachCmd = &cli.Command{
+	Name:  "attach",
+	Usage: "attach local storage path",
+	Flags: []cli.Flag{
+		&cli.BoolFlag{
+			Name:  "init",
+			Usage: "initialize the path first",
+		},
+		&cli.Uint64Flag{
+			Name:  "weight",
+			Usage: "(for init) path weight",
+			Value: 10,
+		},
+		&cli.BoolFlag{
+			Name:  "seal",
+			Usage: "(for init) use path for sealing",
+		},
+		&cli.BoolFlag{
+			Name:  "store",
+			Usage: "(for init) use path for long-term storage",
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		nodeApi, closer, err := lcli.GetStorageMinerAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+		ctx := lcli.ReqContext(cctx)
+
+		if !cctx.Args().Present() {
+			return xerrors.Errorf("must specify storage path to attach")
+		}
+
+		p, err := homedir.Expand(cctx.Args().First())
+		if err != nil {
+			return xerrors.Errorf("expanding path: %w", err)
+		}
+
+		if cctx.Bool("init") {
+			if err := os.MkdirAll(p, 0755); err != nil {
+				if !os.IsExist(err) {
+					return err
+				}
+			}
+
+			_, err := os.Stat(filepath.Join(p, metaFile))
+			if !os.IsNotExist(err) {
+				if err == nil {
+					return xerrors.Errorf("path is already initialized")
+				}
+				return err
+			}
+
+			cfg := &stores.LocalStorageMeta{
+				ID:       stores.ID(uuid.New().String()),
+				Weight:   cctx.Uint64("weight"),
+				CanSeal:  cctx.Bool("seal"),
+				CanStore: cctx.Bool("store"),
+			}
+
+			if !(cfg.CanStore || cfg.CanSeal) {
+				return xerrors.Errorf("must specify at least one of --store of --seal")
+			}
+
+			b, err := json.MarshalIndent(cfg, "", "  ")
+			if err != nil {
+				return xerrors.Errorf("marshaling storage config: %w", err)
+			}
+
+			if err := ioutil.WriteFile(filepath.Join(p, metaFile), b, 0644); err != nil {
+				return xerrors.Errorf("persisting storage metadata (%s): %w", filepath.Join(p, metaFile), err)
+			}
+		}
+
+		return nodeApi.StorageAddLocal(ctx, p)
+	},
+}
+
+var storageListCmd = &cli.Command{
+	Name:  "list",
+	Usage: "list local storage paths",
+	Flags: []cli.Flag{
+		&cli.BoolFlag{Name: "color"},
+	},
+	Action: func(cctx *cli.Context) error {
+		color.NoColor = !cctx.Bool("color")
+
+		nodeApi, closer, err := lcli.GetStorageMinerAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+		ctx := lcli.ReqContext(cctx)
+
+		st, err := nodeApi.StorageList(ctx)
+		if err != nil {
+			return err
+		}
+
+		local, err := nodeApi.StorageLocal(ctx)
+		if err != nil {
+			return err
+		}
+
+		type fsInfo struct {
+			stores.ID
+			sectors []stores.Decl
+			stat    fsutil.FsStat
+		}
+
+		sorted := make([]fsInfo, 0, len(st))
+		for id, decls := range st {
+			st, err := nodeApi.StorageStat(ctx, id)
+			if err != nil {
+				sorted = append(sorted, fsInfo{ID: id, sectors: decls})
+				continue
+			}
+
+			sorted = append(sorted, fsInfo{id, decls, st})
+		}
+
+		sort.Slice(sorted, func(i, j int) bool {
+			if sorted[i].stat.Capacity != sorted[j].stat.Capacity {
+				return sorted[i].stat.Capacity > sorted[j].stat.Capacity
+			}
+			return sorted[i].ID < sorted[j].ID
+		})
+
+		for _, s := range sorted {
+
+			var cnt [3]int
+			for _, decl := range s.sectors {
+				for i := range cnt {
+					if decl.SectorFileType&(1<<i) != 0 {
+						cnt[i]++
+					}
+				}
+			}
+
+			fmt.Printf("%s:\n", s.ID)
+
+			pingStart := time.Now()
+			st, err := nodeApi.StorageStat(ctx, s.ID)
+			if err != nil {
+				fmt.Printf("\t%s: %s:\n", color.RedString("Error"), err)
+				continue
+			}
+			ping := time.Now().Sub(pingStart)
+
+			usedPercent := (st.Capacity - st.Available) * 100 / st.Capacity
+
+			percCol := color.FgGreen
+			switch {
+			case usedPercent > 98:
+				percCol = color.FgRed
+			case usedPercent > 90:
+				percCol = color.FgYellow
+			}
+
+			var barCols = int64(50)
+			set := (st.Capacity - st.Available) * barCols / st.Capacity
+			used := (st.Capacity - (st.Available + st.Reserved)) * barCols / st.Capacity
+			reserved := set - used
+			bar := strings.Repeat("#", int(used)) + strings.Repeat("*", int(reserved)) + strings.Repeat(" ", int(barCols-set))
+
+			fmt.Printf("\t[%s] %s/%s %s\n", color.New(percCol).Sprint(bar),
+				types.SizeStr(types.NewInt(uint64(st.Capacity-st.Available))),
+				types.SizeStr(types.NewInt(uint64(st.Capacity))),
+				color.New(percCol).Sprintf("%d%%", usedPercent))
+			fmt.Printf("\t%s; %s; %s; Reserved: %s\n",
+				color.YellowString("Unsealed: %d", cnt[0]),
+				color.GreenString("Sealed: %d", cnt[1]),
+				color.BlueString("Caches: %d", cnt[2]),
+				types.SizeStr(types.NewInt(uint64(st.Reserved))))
+
+			si, err := nodeApi.StorageInfo(ctx, s.ID)
+			if err != nil {
+				return err
+			}
+
+			fmt.Print("\t")
+			if si.CanSeal || si.CanStore {
+				fmt.Printf("Weight: %d; Use: ", si.Weight)
+				if si.CanSeal {
+					fmt.Print(color.MagentaString("Seal "))
+				}
+				if si.CanStore {
+					fmt.Print(color.CyanString("Store"))
+				}
+				fmt.Println("")
+			} else {
+				fmt.Print(color.HiYellowString("Use: ReadOnly"))
+			}
+
+			if localPath, ok := local[s.ID]; ok {
+				fmt.Printf("\tLocal: %s\n", color.GreenString(localPath))
+			}
+			for i, l := range si.URLs {
+				var rtt string
+				if _, ok := local[s.ID]; !ok && i == 0 {
+					rtt = " (latency: " + ping.Truncate(time.Microsecond*100).String() + ")"
+				}
+
+				fmt.Printf("\tURL: %s%s\n", l, rtt) // TODO; try pinging maybe?? print latency?
+			}
+			fmt.Println()
+		}
+
+		return nil
+	},
+}
+
+type storedSector struct {
+	id    stores.ID
+	store stores.SectorStorageInfo
+
+	unsealed, sealed, cache bool
+}
+
+var storageFindCmd = &cli.Command{
+	Name:      "find",
+	Usage:     "find sector in the storage system",
+	ArgsUsage: "[sector number]",
+	Action: func(cctx *cli.Context) error {
+		nodeApi, closer, err := lcli.GetStorageMinerAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+		ctx := lcli.ReqContext(cctx)
+
+		ma, err := nodeApi.ActorAddress(ctx)
+		if err != nil {
+			return err
+		}
+
+		mid, err := address.IDFromAddress(ma)
+		if err != nil {
+			return err
+		}
+
+		if !cctx.Args().Present() {
+			return xerrors.New("Usage: lotus-miner storage find [sector number]")
+		}
+
+		snum, err := strconv.ParseUint(cctx.Args().First(), 10, 64)
+		if err != nil {
+			return err
+		}
+
+		sid := abi.SectorID{
+			Miner:  abi.ActorID(mid),
+			Number: abi.SectorNumber(snum),
+		}
+
+		u, err := nodeApi.StorageFindSector(ctx, sid, stores.FTUnsealed, 0, false)
+		if err != nil {
+			return xerrors.Errorf("finding unsealed: %w", err)
+		}
+
+		s, err := nodeApi.StorageFindSector(ctx, sid, stores.FTSealed, 0, false)
+		if err != nil {
+			return xerrors.Errorf("finding sealed: %w", err)
+		}
+
+		c, err := nodeApi.StorageFindSector(ctx, sid, stores.FTCache, 0, false)
+		if err != nil {
+			return xerrors.Errorf("finding cache: %w", err)
+		}
+
+		byId := map[stores.ID]*storedSector{}
+		for _, info := range u {
+			sts, ok := byId[info.ID]
+			if !ok {
+				sts = &storedSector{
+					id:    info.ID,
+					store: info,
+				}
+				byId[info.ID] = sts
+			}
+			sts.unsealed = true
+		}
+		for _, info := range s {
+			sts, ok := byId[info.ID]
+			if !ok {
+				sts = &storedSector{
+					id:    info.ID,
+					store: info,
+				}
+				byId[info.ID] = sts
+			}
+			sts.sealed = true
+		}
+		for _, info := range c {
+			sts, ok := byId[info.ID]
+			if !ok {
+				sts = &storedSector{
+					id:    info.ID,
+					store: info,
+				}
+				byId[info.ID] = sts
+			}
+			sts.cache = true
+		}
+
+		local, err := nodeApi.StorageLocal(ctx)
+		if err != nil {
+			return err
+		}
+
+		var out []*storedSector
+		for _, sector := range byId {
+			out = append(out, sector)
+		}
+		sort.Slice(out, func(i, j int) bool {
+			return out[i].id < out[j].id
+		})
+
+		for _, info := range out {
+			var types string
+			if info.unsealed {
+				types += "Unsealed, "
+			}
+			if info.sealed {
+				types += "Sealed, "
+			}
+			if info.cache {
+				types += "Cache, "
+			}
+
+			fmt.Printf("In %s (%s)\n", info.id, types[:len(types)-2])
+			fmt.Printf("\tSealing: %t; Storage: %t\n", info.store.CanSeal, info.store.CanStore)
+			if localPath, ok := local[info.id]; ok {
+				fmt.Printf("\tLocal (%s)\n", localPath)
+			} else {
+				fmt.Printf("\tRemote\n")
+			}
+			for _, l := range info.store.URLs {
+				fmt.Printf("\tURL: %s\n", l)
+			}
+		}
+
+		return nil
+	},
+}
diff --git a/cmd/lotus-townhall/main.go b/cmd/lotus-townhall/main.go
index 8e7e78008..7e8f6df7f 100644
--- a/cmd/lotus-townhall/main.go
+++ b/cmd/lotus-townhall/main.go
@@ -6,28 +6,29 @@ import (
 	"encoding/json"
 	"fmt"
 	"net/http"
-	"strings"
 	"time"
 
 	rice "github.com/GeertJohan/go.rice"
 	"github.com/gorilla/websocket"
-	"github.com/ipfs/go-car"
-	"github.com/ipfs/go-datastore"
-	blockstore "github.com/ipfs/go-ipfs-blockstore"
+	"github.com/ipld/go-car"
 	"github.com/libp2p/go-libp2p"
 	"github.com/libp2p/go-libp2p-core/peer"
-	pnet "github.com/libp2p/go-libp2p-pnet"
 	pubsub "github.com/libp2p/go-libp2p-pubsub"
 
 	"github.com/filecoin-project/lotus/build"
-	"github.com/filecoin-project/lotus/node/modules/lp2p"
+	"github.com/filecoin-project/lotus/lib/blockstore"
 )
 
 var topic = "/fil/headnotifs/"
 
 func init() {
 	genBytes := build.MaybeGenesis()
-	bs := blockstore.NewBlockstore(datastore.NewMapDatastore())
+	if len(genBytes) == 0 {
+		topic = ""
+		return
+	}
+
+	bs := blockstore.NewTemporary()
 
 	c, err := car.LoadCar(bs, bytes.NewReader(genBytes))
 	if err != nil {
@@ -49,17 +50,16 @@ var upgrader = websocket.Upgrader{
 }
 
 func main() {
-	ctx := context.Background()
-
-	protec, err := pnet.NewProtector(strings.NewReader(lp2p.LotusKey))
-	if err != nil {
-		panic(err)
+	if topic == "" {
+		fmt.Println("FATAL: No genesis found")
+		return
 	}
 
+	ctx := context.Background()
+
 	host, err := libp2p.New(
 		ctx,
 		libp2p.Defaults,
-		libp2p.PrivateNetwork(protec),
 	)
 	if err != nil {
 		panic(err)
@@ -106,10 +106,11 @@ func handler(ps *pubsub.PubSub) func(w http.ResponseWriter, r *http.Request) {
 			return
 		}
 
-		sub, err := ps.Subscribe(topic)
+		sub, err := ps.Subscribe(topic) //nolint
 		if err != nil {
 			return
 		}
+		defer sub.Cancel() //nolint:errcheck
 
 		fmt.Println("new conn")
 
diff --git a/cmd/lotus/daemon.go b/cmd/lotus/daemon.go
index 59b17ceab..e0fee6564 100644
--- a/cmd/lotus/daemon.go
+++ b/cmd/lotus/daemon.go
@@ -4,27 +4,69 @@ package main
 
 import (
 	"context"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
 	"io/ioutil"
+	"os"
+	"runtime/pprof"
+	"strings"
+
+	"github.com/filecoin-project/lotus/chain/types"
 
 	paramfetch "github.com/filecoin-project/go-paramfetch"
+	"github.com/mitchellh/go-homedir"
 	"github.com/multiformats/go-multiaddr"
+	"github.com/urfave/cli/v2"
+	"go.opencensus.io/plugin/runmetrics"
+	"go.opencensus.io/stats"
+	"go.opencensus.io/stats/view"
+	"go.opencensus.io/tag"
 	"golang.org/x/xerrors"
-	"gopkg.in/urfave/cli.v2"
 
 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/stmgr"
+	"github.com/filecoin-project/lotus/chain/store"
+	"github.com/filecoin-project/lotus/chain/vm"
+	lcli "github.com/filecoin-project/lotus/cli"
+	"github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper"
+	"github.com/filecoin-project/lotus/lib/blockstore"
+	"github.com/filecoin-project/lotus/lib/peermgr"
+	"github.com/filecoin-project/lotus/lib/ulimit"
+	"github.com/filecoin-project/lotus/metrics"
 	"github.com/filecoin-project/lotus/node"
 	"github.com/filecoin-project/lotus/node/modules"
+	"github.com/filecoin-project/lotus/node/modules/dtypes"
 	"github.com/filecoin-project/lotus/node/modules/testing"
 	"github.com/filecoin-project/lotus/node/repo"
-	"github.com/filecoin-project/lotus/peermgr"
 )
 
 const (
-	makeGenFlag          = "lotus-make-random-genesis"
-	preSealedSectorsFlag = "genesis-presealed-sectors"
+	makeGenFlag     = "lotus-make-genesis"
+	preTemplateFlag = "genesis-template"
 )
 
+var daemonStopCmd = &cli.Command{
+	Name:  "stop",
+	Usage: "Stop a running lotus daemon",
+	Flags: []cli.Flag{},
+	Action: func(cctx *cli.Context) error {
+		api, closer, err := lcli.GetAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+
+		err = api.Shutdown(lcli.ReqContext(cctx))
+		if err != nil {
+			return err
+		}
+
+		return nil
+	},
+}
+
 // DaemonCmd is the `go-lotus daemon` command
 var DaemonCmd = &cli.Command{
 	Name:  "daemon",
@@ -40,25 +82,95 @@ var DaemonCmd = &cli.Command{
 			Hidden: true,
 		},
 		&cli.StringFlag{
-			Name:   preSealedSectorsFlag,
+			Name:   preTemplateFlag,
+			Hidden: true,
+		},
+		&cli.StringFlag{
+			Name:   "import-key",
+			Usage:  "on first run, import a default key from a given file",
 			Hidden: true,
 		},
 		&cli.StringFlag{
 			Name:  "genesis",
 			Usage: "genesis file to use for first node run",
 		},
-		&cli.StringFlag{
-			Name:   "genesis-timestamp",
-			Hidden: true,
-			Usage:  "set the timestamp for the genesis block that will be created",
-		},
 		&cli.BoolFlag{
 			Name:  "bootstrap",
 			Value: true,
 		},
+		&cli.StringFlag{
+			Name:  "import-chain",
+			Usage: "on first run, load chain from given file and validate",
+		},
+		&cli.StringFlag{
+			Name:  "import-snapshot",
+			Usage: "import chain state from a given chain export file",
+		},
+		&cli.BoolFlag{
+			Name:  "halt-after-import",
+			Usage: "halt the process after importing chain from file",
+		},
+		&cli.StringFlag{
+			Name:  "pprof",
+			Usage: "specify name of file for writing cpu profile to",
+		},
+		&cli.StringFlag{
+			Name:  "profile",
+			Usage: "specify type of node",
+		},
+		&cli.BoolFlag{
+			Name:  "manage-fdlimit",
+			Usage: "manage open file limit",
+			Value: true,
+		},
 	},
 	Action: func(cctx *cli.Context) error {
-		ctx := context.Background()
+		err := runmetrics.Enable(runmetrics.RunMetricOptions{
+			EnableCPU:    true,
+			EnableMemory: true,
+		})
+		if err != nil {
+			return xerrors.Errorf("enabling runtime metrics: %w", err)
+		}
+
+		if cctx.Bool("manage-fdlimit") {
+			if _, _, err := ulimit.ManageFdLimit(); err != nil {
+				log.Errorf("setting file descriptor limit: %s", err)
+			}
+		}
+
+		if prof := cctx.String("pprof"); prof != "" {
+			profile, err := os.Create(prof)
+			if err != nil {
+				return err
+			}
+
+			if err := pprof.StartCPUProfile(profile); err != nil {
+				return err
+			}
+			defer pprof.StopCPUProfile()
+		}
+
+		var isBootstrapper dtypes.Bootstrapper
+		switch profile := cctx.String("profile"); profile {
+		case "bootstrapper":
+			isBootstrapper = true
+		case "":
+			// do nothing
+		default:
+			return fmt.Errorf("unrecognized profile type: %q", profile)
+		}
+
+		ctx, _ := tag.New(context.Background(), tag.Insert(metrics.Version, build.BuildVersion), tag.Insert(metrics.Commit, build.CurrentCommit))
+		{
+			dir, err := homedir.Expand(cctx.String("repo"))
+			if err != nil {
+				log.Warnw("could not expand repo location", "error", err)
+			} else {
+				log.Infof("lotus repo: %s", dir)
+			}
+		}
+
 		r, err := repo.NewFS(cctx.String("repo"))
 		if err != nil {
 			return xerrors.Errorf("opening fs repo: %w", err)
@@ -68,17 +180,44 @@ var DaemonCmd = &cli.Command{
 			return xerrors.Errorf("repo init error: %w", err)
 		}
 
-		if err := paramfetch.GetParams(build.ParametersJson, 0); err != nil {
+		if err := paramfetch.GetParams(lcli.ReqContext(cctx), build.ParametersJSON(), 0); err != nil {
 			return xerrors.Errorf("fetching proof parameters: %w", err)
 		}
 
-		genBytes := build.MaybeGenesis()
-
+		var genBytes []byte
 		if cctx.String("genesis") != "" {
 			genBytes, err = ioutil.ReadFile(cctx.String("genesis"))
 			if err != nil {
 				return xerrors.Errorf("reading genesis: %w", err)
 			}
+		} else {
+			genBytes = build.MaybeGenesis()
+		}
+
+		chainfile := cctx.String("import-chain")
+		snapshot := cctx.String("import-snapshot")
+		if chainfile != "" || snapshot != "" {
+			if chainfile != "" && snapshot != "" {
+				return fmt.Errorf("cannot specify both 'import-snapshot' and 'import-chain'")
+			}
+			var issnapshot bool
+			if chainfile == "" {
+				chainfile = snapshot
+				issnapshot = true
+			}
+
+			chainfile, err := homedir.Expand(chainfile)
+			if err != nil {
+				return err
+			}
+
+			if err := ImportChain(r, chainfile, issnapshot); err != nil {
+				return err
+			}
+			if cctx.Bool("halt-after-import") {
+				fmt.Println("Chain import complete, halting as requested...")
+				return nil
+			}
 		}
 
 		genesis := node.Options()
@@ -86,17 +225,21 @@ var DaemonCmd = &cli.Command{
 			genesis = node.Override(new(modules.Genesis), modules.LoadGenesis(genBytes))
 		}
 		if cctx.String(makeGenFlag) != "" {
-			if cctx.String(preSealedSectorsFlag) == "" {
-				return xerrors.Errorf("must also pass file with miner preseal info to `--%s`", preSealedSectorsFlag)
+			if cctx.String(preTemplateFlag) == "" {
+				return xerrors.Errorf("must also pass file with genesis template to `--%s`", preTemplateFlag)
 			}
-			genesis = node.Override(new(modules.Genesis), testing.MakeGenesis(cctx.String(makeGenFlag), cctx.String(preSealedSectorsFlag), cctx.String("genesis-timestamp")))
+			genesis = node.Override(new(modules.Genesis), testing.MakeGenesis(cctx.String(makeGenFlag), cctx.String(preTemplateFlag)))
 		}
 
+		shutdownChan := make(chan struct{})
+
 		var api api.FullNode
 
 		stop, err := node.New(ctx,
 			node.FullAPI(&api),
 
+			node.Override(new(dtypes.Bootstrapper), isBootstrapper),
+			node.Override(new(dtypes.ShutdownChan), shutdownChan),
 			node.Online(),
 			node.Repo(r),
 
@@ -120,12 +263,125 @@ var DaemonCmd = &cli.Command{
 			return xerrors.Errorf("initializing node: %w", err)
 		}
 
+		if cctx.String("import-key") != "" {
+			if err := importKey(ctx, api, cctx.String("import-key")); err != nil {
+				log.Errorf("importing key failed: %+v", err)
+			}
+		}
+
+		// Register all metric views
+		if err = view.Register(
+			metrics.DefaultViews...,
+		); err != nil {
+			log.Fatalf("Cannot register the view: %v", err)
+		}
+
+		// Set the metric to one so it is published to the exporter
+		stats.Record(ctx, metrics.LotusInfo.M(1))
+
 		endpoint, err := r.APIEndpoint()
 		if err != nil {
 			return xerrors.Errorf("getting api endpoint: %w", err)
 		}
 
 		// TODO: properly parse api endpoint (or make it a URL)
-		return serveRPC(api, stop, endpoint)
+		return serveRPC(api, stop, endpoint, shutdownChan)
+	},
+	Subcommands: []*cli.Command{
+		daemonStopCmd,
 	},
 }
+
+func importKey(ctx context.Context, api api.FullNode, f string) error {
+	f, err := homedir.Expand(f)
+	if err != nil {
+		return err
+	}
+
+	hexdata, err := ioutil.ReadFile(f)
+	if err != nil {
+		return err
+	}
+
+	data, err := hex.DecodeString(strings.TrimSpace(string(hexdata)))
+	if err != nil {
+		return err
+	}
+
+	var ki types.KeyInfo
+	if err := json.Unmarshal(data, &ki); err != nil {
+		return err
+	}
+
+	addr, err := api.WalletImport(ctx, &ki)
+	if err != nil {
+		return err
+	}
+
+	if err := api.WalletSetDefault(ctx, addr); err != nil {
+		return err
+	}
+
+	log.Info("successfully imported key for %s", addr)
+	return nil
+}
+
+func ImportChain(r repo.Repo, fname string, snapshot bool) error {
+	fi, err := os.Open(fname)
+	if err != nil {
+		return err
+	}
+	defer fi.Close() //nolint:errcheck
+
+	lr, err := r.Lock(repo.FullNode)
+	if err != nil {
+		return err
+	}
+	defer lr.Close() //nolint:errcheck
+
+	ds, err := lr.Datastore("/chain")
+	if err != nil {
+		return err
+	}
+
+	mds, err := lr.Datastore("/metadata")
+	if err != nil {
+		return err
+	}
+
+	bs := blockstore.NewBlockstore(ds)
+
+	cst := store.NewChainStore(bs, mds, vm.Syscalls(ffiwrapper.ProofVerifier))
+
+	log.Info("importing chain from file...")
+	ts, err := cst.Import(fi)
+	if err != nil {
+		return xerrors.Errorf("importing chain failed: %w", err)
+	}
+
+	gb, err := cst.GetTipsetByHeight(context.TODO(), 0, ts, true)
+	if err != nil {
+		return err
+	}
+
+	err = cst.SetGenesis(gb.Blocks()[0])
+	if err != nil {
+		return err
+	}
+
+	stm := stmgr.NewStateManager(cst)
+
+	if !snapshot {
+		log.Infof("validating imported chain...")
+		if err := stm.ValidateChain(context.TODO(), ts); err != nil {
+			return xerrors.Errorf("chain validation failed: %w", err)
+		}
+	}
+
+	log.Info("accepting %s as new head", ts.Cids())
+	if err := cst.SetHead(ts); err != nil {
+		return err
+	}
+
+	return nil
+}
diff --git a/cmd/lotus/daemon_nodaemon.go b/cmd/lotus/daemon_nodaemon.go
index 05a8f97da..a11d92c6c 100644
--- a/cmd/lotus/daemon_nodaemon.go
+++ b/cmd/lotus/daemon_nodaemon.go
@@ -5,7 +5,7 @@ package main
 import (
 	"errors"
 
-	"gopkg.in/urfave/cli.v2"
+	"github.com/urfave/cli/v2"
 )
 
 // DaemonCmd is the `go-lotus daemon` command
diff --git a/cmd/lotus/debug_advance.go b/cmd/lotus/debug_advance.go
new file mode 100644
index 000000000..4e74a995f
--- /dev/null
+++ b/cmd/lotus/debug_advance.go
@@ -0,0 +1,93 @@
+// +build debug
+
+package main
+
+import (
+	"encoding/binary"
+	"time"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/crypto"
+	lapi "github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/gen"
+	"github.com/filecoin-project/lotus/chain/types"
+	lcli "github.com/filecoin-project/lotus/cli"
+	"golang.org/x/xerrors"
+
+	"github.com/urfave/cli/v2"
+)
+
+func init() {
+	AdvanceBlockCmd = &cli.Command{
+		Name: "advance-block",
+		Action: func(cctx *cli.Context) error {
+			api, closer, err := lcli.GetFullNodeAPI(cctx)
+			if err != nil {
+				return err
+			}
+			defer closer()
+
+			ctx := lcli.ReqContext(cctx)
+			head, err := api.ChainHead(ctx)
+			if err != nil {
+				return err
+			}
+			msgs, err := api.MpoolSelect(ctx, head.Key(), 1)
+			if err != nil {
+				return err
+			}
+
+			addr, _ := address.NewIDAddress(1000)
+			var ticket *types.Ticket
+			{
+				mi, err := api.StateMinerInfo(ctx, addr, head.Key())
+				if err != nil {
+					return xerrors.Errorf("StateMinerWorker: %w", err)
+				}
+
+				// XXX: This can't be right
+				rand, err := api.ChainGetRandomnessFromTickets(ctx, head.Key(), crypto.DomainSeparationTag_TicketProduction, head.Height(), addr.Bytes())
+				if err != nil {
+					return xerrors.Errorf("failed to get randomness: %w", err)
+				}
+
+				t, err := gen.ComputeVRF(ctx, api.WalletSign, mi.Worker, rand)
+				if err != nil {
+					return xerrors.Errorf("compute vrf failed: %w", err)
+				}
+				ticket = &types.Ticket{
+					VRFProof: t,
+				}
+
+			}
+
+			mbi, err := api.MinerGetBaseInfo(ctx, addr, head.Height()+1, head.Key())
+			if err != nil {
+				return xerrors.Errorf("getting base info: %w", err)
+			}
+
+			ep := &types.ElectionProof{}
+			ep.WinCount = ep.ComputeWinCount(types.NewInt(1), types.NewInt(1))
+			for ep.WinCount == 0 {
+				fakeVrf := make([]byte, 8)
+				unixNow := uint64(time.Now().UnixNano())
+				binary.LittleEndian.PutUint64(fakeVrf, unixNow)
+
+				ep.VRFProof = fakeVrf
+				ep.WinCount = ep.ComputeWinCount(types.NewInt(1), types.NewInt(1))
+			}
+
+			uts := head.MinTimestamp() + uint64(build.BlockDelaySecs)
+			nheight := head.Height() + 1
+			blk, err := api.MinerCreateBlock(ctx, &lapi.BlockTemplate{
+				addr, head.Key(), ticket, ep, mbi.BeaconEntries, msgs, nheight, uts, gen.ValidWpostForTesting,
+			})
+			if err != nil {
+				return xerrors.Errorf("creating block: %w", err)
+			}
+
+			return api.SyncSubmitBlock(ctx, blk)
+		},
+	}
+}
diff --git a/cmd/lotus/main.go b/cmd/lotus/main.go
index 3f081222d..ee95ad64b 100644
--- a/cmd/lotus/main.go
+++ b/cmd/lotus/main.go
@@ -2,24 +2,31 @@ package main
 
 import (
 	"context"
-	"os"
 
+	"github.com/urfave/cli/v2"
 	"go.opencensus.io/trace"
-	"gopkg.in/urfave/cli.v2"
 
 	"github.com/filecoin-project/lotus/build"
 	lcli "github.com/filecoin-project/lotus/cli"
 	"github.com/filecoin-project/lotus/lib/lotuslog"
+	"github.com/filecoin-project/lotus/lib/tracing"
 	"github.com/filecoin-project/lotus/node/repo"
-	"github.com/filecoin-project/lotus/tracing"
 )
 
+var AdvanceBlockCmd *cli.Command
+
 func main() {
+	build.RunningNodeType = build.NodeFull
+
 	lotuslog.SetupLogLevels()
 
 	local := []*cli.Command{
 		DaemonCmd,
 	}
+	if AdvanceBlockCmd != nil {
+		local = append(local, AdvanceBlockCmd)
+	}
+
 	jaeger := tracing.SetupJaegerTracing("lotus")
 	defer func() {
 		if jaeger != nil {
@@ -44,9 +51,10 @@ func main() {
 	defer span.End()
 
 	app := &cli.App{
-		Name:    "lotus",
-		Usage:   "Filecoin decentralized storage network client",
-		Version: build.UserVersion,
+		Name:                 "lotus",
+		Usage:                "Filecoin decentralized storage network client",
+		Version:              build.UserVersion(),
+		EnableBashCompletion: true,
 		Flags: []cli.Flag{
 			&cli.StringFlag{
 				Name:    "repo",
@@ -62,12 +70,5 @@ func main() {
 	app.Metadata["traceContext"] = ctx
 	app.Metadata["repoType"] = repo.FullNode
 
-	if err := app.Run(os.Args); err != nil {
-		span.SetStatus(trace.Status{
-			Code:    trace.StatusCodeFailedPrecondition,
-			Message: err.Error(),
-		})
-		log.Warnf("%+v", err)
-		os.Exit(1)
-	}
+	lcli.RunApp(app)
 }
diff --git a/cmd/lotus/rpc.go b/cmd/lotus/rpc.go
index 5178e1b6c..9718deb3a 100644
--- a/cmd/lotus/rpc.go
+++ b/cmd/lotus/rpc.go
@@ -3,29 +3,32 @@ package main
 import (
 	"context"
 	"encoding/json"
-	"github.com/filecoin-project/lotus/api/apistruct"
 	"net/http"
 	_ "net/http/pprof"
 	"os"
 	"os/signal"
 	"syscall"
 
+	"github.com/ipfs/go-cid"
+	logging "github.com/ipfs/go-log/v2"
+	"github.com/multiformats/go-multiaddr"
+	manet "github.com/multiformats/go-multiaddr/net"
+	"golang.org/x/xerrors"
+
+	"contrib.go.opencensus.io/exporter/prometheus"
+
+	"github.com/filecoin-project/go-jsonrpc"
+	"github.com/filecoin-project/go-jsonrpc/auth"
+
 	"github.com/filecoin-project/lotus/api"
-	"github.com/filecoin-project/lotus/lib/auth"
-	"github.com/filecoin-project/lotus/lib/jsonrpc"
+	"github.com/filecoin-project/lotus/api/apistruct"
 	"github.com/filecoin-project/lotus/node"
 	"github.com/filecoin-project/lotus/node/impl"
-
-	"github.com/ipfs/go-cid"
-	logging "github.com/ipfs/go-log"
-	"github.com/multiformats/go-multiaddr"
-	manet "github.com/multiformats/go-multiaddr-net"
-	"golang.org/x/xerrors"
 )
 
 var log = logging.Logger("main")
 
-func serveRPC(a api.FullNode, stop node.StopFunc, addr multiaddr.Multiaddr) error {
+func serveRPC(a api.FullNode, stop node.StopFunc, addr multiaddr.Multiaddr, shutdownCh <-chan struct{}) error {
 	rpcServer := jsonrpc.NewServer()
 	rpcServer.Register("Filecoin", apistruct.PermissionedFullAPI(a))
 
@@ -43,6 +46,15 @@ func serveRPC(a api.FullNode, stop node.StopFunc, addr multiaddr.Multiaddr) erro
 
 	http.Handle("/rest/v0/import", importAH)
 
+	exporter, err := prometheus.NewExporter(prometheus.Options{
+		Namespace: "lotus",
+	})
+	if err != nil {
+		log.Fatalf("could not create the prometheus stats exporter: %v", err)
+	}
+
+	http.Handle("/debug/metrics", exporter)
+
 	lst, err := manet.Listen(addr)
 	if err != nil {
 		return xerrors.Errorf("could not listen: %w", err)
@@ -50,19 +62,35 @@ func serveRPC(a api.FullNode, stop node.StopFunc, addr multiaddr.Multiaddr) erro
 
 	srv := &http.Server{Handler: http.DefaultServeMux}
 
-	sigChan := make(chan os.Signal, 2)
+	sigCh := make(chan os.Signal, 2)
+	shutdownDone := make(chan struct{})
 	go func() {
-		<-sigChan
+		select {
+		case sig := <-sigCh:
+			log.Warnw("received shutdown", "signal", sig)
+		case <-shutdownCh:
+			log.Warn("received shutdown")
+		}
+
+		log.Warn("Shutting down...")
 		if err := srv.Shutdown(context.TODO()); err != nil {
 			log.Errorf("shutting down RPC server failed: %s", err)
 		}
 		if err := stop(context.TODO()); err != nil {
 			log.Errorf("graceful shutting down failed: %s", err)
 		}
+		log.Warn("Graceful shutdown successful")
+		_ = log.Sync() //nolint:errcheck
+		close(shutdownDone)
 	}()
-	signal.Notify(sigChan, syscall.SIGTERM, syscall.SIGINT)
+	signal.Notify(sigCh, syscall.SIGTERM, syscall.SIGINT)
 
-	return srv.Serve(manet.NetListener(lst))
+	err = srv.Serve(manet.NetListener(lst))
+	if err == http.ErrServerClosed {
+		<-shutdownDone
+		return nil
+	}
+	return err
 }
 
 func handleImport(a *impl.FullNodeAPI) func(w http.ResponseWriter, r *http.Request) {
@@ -71,16 +99,16 @@ func handleImport(a *impl.FullNodeAPI) func(w http.ResponseWriter, r *http.Reque
 			w.WriteHeader(404)
 			return
 		}
-		if !apistruct.HasPerm(r.Context(), apistruct.PermWrite) {
+		if !auth.HasPerm(r.Context(), nil, apistruct.PermWrite) {
 			w.WriteHeader(401)
-			json.NewEncoder(w).Encode(struct{ Error string }{"unauthorized: missing write permission"})
+			_ = json.NewEncoder(w).Encode(struct{ Error string }{"unauthorized: missing write permission"})
 			return
 		}
 
 		c, err := a.ClientImportLocal(r.Context(), r.Body)
 		if err != nil {
 			w.WriteHeader(500)
-			json.NewEncoder(w).Encode(struct{ Error string }{err.Error()})
+			_ = json.NewEncoder(w).Encode(struct{ Error string }{err.Error()})
 			return
 		}
 		w.WriteHeader(200)
diff --git a/conformance/chaos/actor.go b/conformance/chaos/actor.go
new file mode 100644
index 000000000..477204374
--- /dev/null
+++ b/conformance/chaos/actor.go
@@ -0,0 +1,286 @@
+package chaos
+
+import (
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/exitcode"
+	"github.com/filecoin-project/specs-actors/actors/builtin"
+	"github.com/filecoin-project/specs-actors/actors/runtime"
+	"github.com/ipfs/go-cid"
+)
+
+//go:generate go run ./gen
+
+// Actor is a chaos actor. It implements a variety of illegal behaviours that
+// trigger violations of VM invariants. These behaviours are not found in
+// production code, but are important to test that the VM constraints are
+// properly enforced.
+//
+// The chaos actor is being incubated and its behaviour and ABI be standardised
+// shortly. Its CID is ChaosActorCodeCID, and its singleton address is 98 (Address).
+// It cannot be instantiated via the init actor, and its constructor panics.
+//
+// Test vectors relying on the chaos actor being deployed will carry selector
+// "chaos_actor:true".
+type Actor struct{}
+
+// CallerValidationBranch is an enum used to select a branch in the
+// CallerValidation method.
+type CallerValidationBranch int64
+
+const (
+	// CallerValidationBranchNone causes no caller validation to take place.
+	CallerValidationBranchNone CallerValidationBranch = iota
+	// CallerValidationBranchTwice causes Runtime.ValidateImmediateCallerAcceptAny to be called twice.
+	CallerValidationBranchTwice
+	// CallerValidationBranchIsAddress causes caller validation against CallerValidationArgs.Addrs.
+	CallerValidationBranchIsAddress
+	// CallerValidationBranchIsType causes caller validation against CallerValidationArgs.Types.
+	CallerValidationBranchIsType
+)
+
+// MutateStateBranch is an enum used to select the type of state mutation to attempt.
+type MutateStateBranch int64
+
+const (
+	// MutateInTransaction legally mutates state within a transaction.
+	MutateInTransaction MutateStateBranch = iota
+	// MutateReadonly ILLEGALLY mutates readonly state.
+	MutateReadonly
+	// MutateAfterTransaction ILLEGALLY mutates state after a transaction.
+	MutateAfterTransaction
+)
+
+const (
+	_                      = 0 // skip zero iota value; first usage of iota gets 1.
+	MethodCallerValidation = builtin.MethodConstructor + iota
+	MethodCreateActor
+	MethodResolveAddress
+	// MethodDeleteActor is the identifier for the method that deletes this actor.
+	MethodDeleteActor
+	// MethodSend is the identifier for the method that sends a message to another actor.
+	MethodSend
+	// MethodMutateState is the identifier for the method that attempts to mutate
+	// a state value in the actor.
+	MethodMutateState
+	// MethodAbortWith is the identifier for the method that panics optionally with
+	// a passed exit code.
+	MethodAbortWith
+	// MethodInspectRuntime is the identifier for the method that returns the
+	// current runtime values.
+	MethodInspectRuntime
+)
+
+// Exports defines the methods this actor exposes publicly.
+func (a Actor) Exports() []interface{} {
+	return []interface{}{
+		builtin.MethodConstructor: a.Constructor,
+		MethodCallerValidation:    a.CallerValidation,
+		MethodCreateActor:         a.CreateActor,
+		MethodResolveAddress:      a.ResolveAddress,
+		MethodDeleteActor:         a.DeleteActor,
+		MethodSend:                a.Send,
+		MethodMutateState:         a.MutateState,
+		MethodAbortWith:           a.AbortWith,
+		MethodInspectRuntime:      a.InspectRuntime,
+	}
+}
+
+var _ runtime.Invokee = Actor{}
+
+// SendArgs are the arguments for the Send method.
+type SendArgs struct {
+	To     address.Address
+	Value  abi.TokenAmount
+	Method abi.MethodNum
+	Params []byte
+}
+
+// SendReturn is the return values for the Send method.
+type SendReturn struct {
+	Return runtime.CBORBytes
+	Code   exitcode.ExitCode
+}
+
+// Send requests for this actor to send a message to an actor with the
+// passed parameters.
+func (a Actor) Send(rt runtime.Runtime, args *SendArgs) *SendReturn {
+	rt.ValidateImmediateCallerAcceptAny()
+	var out runtime.CBORBytes
+	code := rt.Send(
+		args.To,
+		args.Method,
+		runtime.CBORBytes(args.Params),
+		args.Value,
+		&out,
+	)
+	return &SendReturn{
+		Return: out,
+		Code:   code,
+	}
+}
+
+// Constructor will panic because the Chaos actor is a singleton.
+func (a Actor) Constructor(_ runtime.Runtime, _ *abi.EmptyValue) *abi.EmptyValue {
+	panic("constructor should not be called; the Chaos actor is a singleton actor")
+}
+
+// CallerValidationArgs are the arguments to Actor.CallerValidation.
+type CallerValidationArgs struct {
+	Branch CallerValidationBranch
+	Addrs  []address.Address
+	Types  []cid.Cid
+}
+
+// CallerValidation violates VM call validation constraints.
+//
+//  CallerValidationBranchNone performs no validation.
+//  CallerValidationBranchTwice validates twice.
+//  CallerValidationBranchIsAddress validates caller against CallerValidationArgs.Addrs.
+//  CallerValidationBranchIsType validates caller against CallerValidationArgs.Types.
+func (a Actor) CallerValidation(rt runtime.Runtime, args *CallerValidationArgs) *abi.EmptyValue {
+	switch args.Branch {
+	case CallerValidationBranchNone:
+	case CallerValidationBranchTwice:
+		rt.ValidateImmediateCallerAcceptAny()
+		rt.ValidateImmediateCallerAcceptAny()
+	case CallerValidationBranchIsAddress:
+		rt.ValidateImmediateCallerIs(args.Addrs...)
+	case CallerValidationBranchIsType:
+		rt.ValidateImmediateCallerType(args.Types...)
+	default:
+		panic("invalid branch passed to CallerValidation")
+	}
+
+	return nil
+}
+
+// CreateActorArgs are the arguments to CreateActor.
+type CreateActorArgs struct {
+	// UndefActorCID instructs us to use cid.Undef; we can't pass cid.Undef
+	// in ActorCID because it doesn't serialize.
+	UndefActorCID bool
+	ActorCID      cid.Cid
+
+	// UndefAddress is the same as UndefActorCID but for Address.
+	UndefAddress bool
+	Address      address.Address
+}
+
+// CreateActor creates an actor with the supplied CID and Address.
+func (a Actor) CreateActor(rt runtime.Runtime, args *CreateActorArgs) *abi.EmptyValue {
+	rt.ValidateImmediateCallerAcceptAny()
+
+	var (
+		acid = args.ActorCID
+		addr = args.Address
+	)
+
+	if args.UndefActorCID {
+		acid = cid.Undef
+	}
+	if args.UndefAddress {
+		addr = address.Undef
+	}
+
+	rt.CreateActor(acid, addr)
+	return nil
+}
+
+// ResolveAddressResponse holds the response of a call to runtime.ResolveAddress
+type ResolveAddressResponse struct {
+	Address address.Address
+	Success bool
+}
+
+func (a Actor) ResolveAddress(rt runtime.Runtime, args *address.Address) *ResolveAddressResponse {
+	rt.ValidateImmediateCallerAcceptAny()
+
+	resolvedAddr, ok := rt.ResolveAddress(*args)
+	if !ok {
+		invalidAddr, _ := address.NewIDAddress(0)
+		resolvedAddr = invalidAddr
+	}
+	return &ResolveAddressResponse{resolvedAddr, ok}
+}
+
+// DeleteActor deletes the executing actor from the state tree, transferring any
+// balance to beneficiary.
+func (a Actor) DeleteActor(rt runtime.Runtime, beneficiary *address.Address) *abi.EmptyValue {
+	rt.ValidateImmediateCallerAcceptAny()
+	rt.DeleteActor(*beneficiary)
+	return nil
+}
+
+// MutateStateArgs specify the value to set on the state and the way in which
+// it should be attempted to be set.
+type MutateStateArgs struct {
+	Value  string
+	Branch MutateStateBranch
+}
+
+// MutateState attempts to mutate a state value in the actor.
+func (a Actor) MutateState(rt runtime.Runtime, args *MutateStateArgs) *abi.EmptyValue {
+	rt.ValidateImmediateCallerAcceptAny()
+	var st State
+	switch args.Branch {
+	case MutateInTransaction:
+		rt.StateTransaction(&st, func() {
+			st.Value = args.Value
+		})
+	case MutateReadonly:
+		rt.StateReadonly(&st)
+		st.Value = args.Value
+	case MutateAfterTransaction:
+		rt.StateTransaction(&st, func() {
+			st.Value = args.Value + "-in"
+		})
+		st.Value = args.Value
+	default:
+		panic("unknown mutation type")
+	}
+	return nil
+}
+
+// AbortWithArgs are the arguments to the Actor.AbortWith method, specifying the
+// exit code to (optionally) abort with and the message.
+type AbortWithArgs struct {
+	Code         exitcode.ExitCode
+	Message      string
+	Uncontrolled bool
+}
+
+// AbortWith simply causes a panic with the passed exit code.
+func (a Actor) AbortWith(rt runtime.Runtime, args *AbortWithArgs) *abi.EmptyValue {
+	if args.Uncontrolled { // uncontrolled abort: directly panic
+		panic(args.Message)
+	} else {
+		rt.Abortf(args.Code, args.Message)
+	}
+	return nil
+}
+
+// InspectRuntimeReturn is the return value for the Actor.InspectRuntime method.
+type InspectRuntimeReturn struct {
+	Caller         address.Address
+	Receiver       address.Address
+	ValueReceived  abi.TokenAmount
+	CurrEpoch      abi.ChainEpoch
+	CurrentBalance abi.TokenAmount
+	State          State
+}
+
+// InspectRuntime returns a copy of the serializable values available in the Runtime.
+func (a Actor) InspectRuntime(rt runtime.Runtime, _ *abi.EmptyValue) *InspectRuntimeReturn {
+	rt.ValidateImmediateCallerAcceptAny()
+	var st State
+	rt.StateReadonly(&st)
+	return &InspectRuntimeReturn{
+		Caller:         rt.Caller(),
+		Receiver:       rt.Receiver(),
+		ValueReceived:  rt.ValueReceived(),
+		CurrEpoch:      rt.CurrEpoch(),
+		CurrentBalance: rt.CurrentBalance(),
+		State:          st,
+	}
+}
diff --git a/conformance/chaos/actor_test.go b/conformance/chaos/actor_test.go
new file mode 100644
index 000000000..2061efb82
--- /dev/null
+++ b/conformance/chaos/actor_test.go
@@ -0,0 +1,275 @@
+package chaos
+
+import (
+	"context"
+	"testing"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/exitcode"
+	"github.com/filecoin-project/specs-actors/actors/builtin"
+	"github.com/filecoin-project/specs-actors/support/mock"
+	atesting "github.com/filecoin-project/specs-actors/support/testing"
+	"github.com/ipfs/go-cid"
+)
+
+func TestSingleton(t *testing.T) {
+	receiver := atesting.NewIDAddr(t, 100)
+	builder := mock.NewBuilder(context.Background(), receiver)
+
+	rt := builder.Build(t)
+	var a Actor
+
+	msg := "constructor should not be called; the Chaos actor is a singleton actor"
+	rt.ExpectAssertionFailure(msg, func() {
+		rt.Call(a.Constructor, abi.Empty)
+	})
+	rt.Verify()
+}
+
+func TestCallerValidationNone(t *testing.T) {
+	receiver := atesting.NewIDAddr(t, 100)
+	builder := mock.NewBuilder(context.Background(), receiver)
+
+	rt := builder.Build(t)
+	var a Actor
+
+	rt.Call(a.CallerValidation, &CallerValidationArgs{Branch: CallerValidationBranchNone})
+	rt.Verify()
+}
+
+func TestCallerValidationIs(t *testing.T) {
+	caller := atesting.NewIDAddr(t, 100)
+	receiver := atesting.NewIDAddr(t, 101)
+	builder := mock.NewBuilder(context.Background(), receiver)
+
+	rt := builder.Build(t)
+	rt.SetCaller(caller, builtin.AccountActorCodeID)
+	var a Actor
+
+	caddrs := []address.Address{atesting.NewIDAddr(t, 101)}
+
+	rt.ExpectValidateCallerAddr(caddrs...)
+	// FIXME: https://github.com/filecoin-project/specs-actors/pull/1155
+	rt.ExpectAbort(exitcode.ErrForbidden, func() {
+		rt.Call(a.CallerValidation, &CallerValidationArgs{
+			Branch: CallerValidationBranchIsAddress,
+			Addrs:  caddrs,
+		})
+	})
+	rt.Verify()
+
+	rt.ExpectValidateCallerAddr(caller)
+	rt.Call(a.CallerValidation, &CallerValidationArgs{
+		Branch: CallerValidationBranchIsAddress,
+		Addrs:  []address.Address{caller},
+	})
+	rt.Verify()
+}
+
+func TestCallerValidationType(t *testing.T) {
+	caller := atesting.NewIDAddr(t, 100)
+	receiver := atesting.NewIDAddr(t, 101)
+	builder := mock.NewBuilder(context.Background(), receiver)
+
+	rt := builder.Build(t)
+	rt.SetCaller(caller, builtin.AccountActorCodeID)
+	var a Actor
+
+	rt.ExpectValidateCallerType(builtin.CronActorCodeID)
+	// FIXME: https://github.com/filecoin-project/specs-actors/pull/1155
+	rt.ExpectAbort(exitcode.ErrForbidden, func() {
+		rt.Call(a.CallerValidation, &CallerValidationArgs{
+			Branch: CallerValidationBranchIsType,
+			Types:  []cid.Cid{builtin.CronActorCodeID},
+		})
+	})
+	rt.Verify()
+
+	rt.ExpectValidateCallerType(builtin.AccountActorCodeID)
+	rt.Call(a.CallerValidation, &CallerValidationArgs{
+		Branch: CallerValidationBranchIsType,
+		Types:  []cid.Cid{builtin.AccountActorCodeID},
+	})
+	rt.Verify()
+}
+
+func TestCallerValidationInvalidBranch(t *testing.T) {
+	receiver := atesting.NewIDAddr(t, 100)
+	builder := mock.NewBuilder(context.Background(), receiver)
+
+	rt := builder.Build(t)
+	var a Actor
+
+	rt.ExpectAssertionFailure("invalid branch passed to CallerValidation", func() {
+		rt.Call(a.CallerValidation, &CallerValidationArgs{Branch: -1})
+	})
+	rt.Verify()
+}
+
+func TestDeleteActor(t *testing.T) {
+	receiver := atesting.NewIDAddr(t, 100)
+	beneficiary := atesting.NewIDAddr(t, 101)
+	builder := mock.NewBuilder(context.Background(), receiver)
+
+	rt := builder.Build(t)
+	var a Actor
+
+	rt.ExpectValidateCallerAny()
+	rt.ExpectDeleteActor(beneficiary)
+	rt.Call(a.DeleteActor, &beneficiary)
+	rt.Verify()
+}
+
+func TestMutateStateInTransaction(t *testing.T) {
+	receiver := atesting.NewIDAddr(t, 100)
+	builder := mock.NewBuilder(context.Background(), receiver)
+
+	rt := builder.Build(t)
+	var a Actor
+
+	rt.ExpectValidateCallerAny()
+	rt.StateCreate(&State{})
+
+	val := "__mutstat test"
+	rt.Call(a.MutateState, &MutateStateArgs{
+		Value:  val,
+		Branch: MutateInTransaction,
+	})
+
+	var st State
+	rt.GetState(&st)
+
+	if st.Value != val {
+		t.Fatal("state was not updated")
+	}
+
+	rt.Verify()
+}
+
+func TestMutateStateAfterTransaction(t *testing.T) {
+	receiver := atesting.NewIDAddr(t, 100)
+	builder := mock.NewBuilder(context.Background(), receiver)
+
+	rt := builder.Build(t)
+	var a Actor
+
+	rt.ExpectValidateCallerAny()
+	rt.StateCreate(&State{})
+
+	val := "__mutstat test"
+	rt.Call(a.MutateState, &MutateStateArgs{
+		Value:  val,
+		Branch: MutateAfterTransaction,
+	})
+
+	var st State
+	rt.GetState(&st)
+
+	// state should be updated successfully _in_ the transaction but not outside
+	if st.Value != val+"-in" {
+		t.Fatal("state was not updated")
+	}
+
+	rt.Verify()
+}
+
+func TestMutateStateReadonly(t *testing.T) {
+	receiver := atesting.NewIDAddr(t, 100)
+	builder := mock.NewBuilder(context.Background(), receiver)
+
+	rt := builder.Build(t)
+	var a Actor
+
+	rt.ExpectValidateCallerAny()
+	rt.StateCreate(&State{})
+
+	val := "__mutstat test"
+	rt.Call(a.MutateState, &MutateStateArgs{
+		Value:  val,
+		Branch: MutateReadonly,
+	})
+
+	var st State
+	rt.GetState(&st)
+
+	if st.Value != "" {
+		t.Fatal("state was not expected to be updated")
+	}
+
+	rt.Verify()
+}
+
+func TestMutateStateInvalidBranch(t *testing.T) {
+	receiver := atesting.NewIDAddr(t, 100)
+	builder := mock.NewBuilder(context.Background(), receiver)
+
+	rt := builder.Build(t)
+	var a Actor
+
+	rt.ExpectValidateCallerAny()
+	rt.ExpectAssertionFailure("unknown mutation type", func() {
+		rt.Call(a.MutateState, &MutateStateArgs{Branch: -1})
+	})
+	rt.Verify()
+}
+
+func TestAbortWith(t *testing.T) {
+	receiver := atesting.NewIDAddr(t, 100)
+	builder := mock.NewBuilder(context.Background(), receiver)
+
+	rt := builder.Build(t)
+	var a Actor
+
+	msg := "__test forbidden"
+	rt.ExpectAbortContainsMessage(exitcode.ErrForbidden, msg, func() {
+		rt.Call(a.AbortWith, &AbortWithArgs{
+			Code:         exitcode.ErrForbidden,
+			Message:      msg,
+			Uncontrolled: false,
+		})
+	})
+	rt.Verify()
+}
+
+func TestAbortWithUncontrolled(t *testing.T) {
+	receiver := atesting.NewIDAddr(t, 100)
+	builder := mock.NewBuilder(context.Background(), receiver)
+
+	rt := builder.Build(t)
+	var a Actor
+
+	msg := "__test uncontrolled panic"
+	rt.ExpectAssertionFailure(msg, func() {
+		rt.Call(a.AbortWith, &AbortWithArgs{
+			Message:      msg,
+			Uncontrolled: true,
+		})
+	})
+	rt.Verify()
+}
+
+func TestInspectRuntime(t *testing.T) {
+	caller := atesting.NewIDAddr(t, 100)
+	receiver := atesting.NewIDAddr(t, 101)
+	builder := mock.NewBuilder(context.Background(), receiver)
+
+	rt := builder.Build(t)
+	rt.SetCaller(caller, builtin.AccountActorCodeID)
+	rt.StateCreate(&State{})
+	var a Actor
+
+	rt.ExpectValidateCallerAny()
+	ret := rt.Call(a.InspectRuntime, abi.Empty)
+	rtr, ok := ret.(*InspectRuntimeReturn)
+	if !ok {
+		t.Fatal("invalid return value")
+	}
+	if rtr.Caller != caller {
+		t.Fatal("unexpected runtime caller")
+	}
+	if rtr.Receiver != receiver {
+		t.Fatal("unexpected runtime receiver")
+	}
+	rt.Verify()
+}
diff --git a/conformance/chaos/cbor_gen.go b/conformance/chaos/cbor_gen.go
new file mode 100644
index 000000000..882af7026
--- /dev/null
+++ b/conformance/chaos/cbor_gen.go
@@ -0,0 +1,1033 @@
+// Code generated by github.com/whyrusleeping/cbor-gen. DO NOT EDIT.
+
+package chaos
+
+import (
+	"fmt"
+	"io"
+
+	address "github.com/filecoin-project/go-address"
+	abi "github.com/filecoin-project/go-state-types/abi"
+	exitcode "github.com/filecoin-project/go-state-types/exitcode"
+	cid "github.com/ipfs/go-cid"
+	cbg "github.com/whyrusleeping/cbor-gen"
+	xerrors "golang.org/x/xerrors"
+)
+
+var _ = xerrors.Errorf
+
+var lengthBufState = []byte{130}
+
+func (t *State) MarshalCBOR(w io.Writer) error {
+	if t == nil {
+		_, err := w.Write(cbg.CborNull)
+		return err
+	}
+	if _, err := w.Write(lengthBufState); err != nil {
+		return err
+	}
+
+	scratch := make([]byte, 9)
+
+	// t.Value (string) (string)
+	if len(t.Value) > cbg.MaxLength {
+		return xerrors.Errorf("Value in field t.Value was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len(t.Value))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string(t.Value)); err != nil {
+		return err
+	}
+
+	// t.Unmarshallable ([]*chaos.UnmarshallableCBOR) (slice)
+	if len(t.Unmarshallable) > cbg.MaxLength {
+		return xerrors.Errorf("Slice value in field t.Unmarshallable was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajArray, uint64(len(t.Unmarshallable))); err != nil {
+		return err
+	}
+	for _, v := range t.Unmarshallable {
+		if err := v.MarshalCBOR(w); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (t *State) UnmarshalCBOR(r io.Reader) error {
+	*t = State{}
+
+	br := cbg.GetPeeker(r)
+	scratch := make([]byte, 8)
+
+	maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
+	if err != nil {
+		return err
+	}
+	if maj != cbg.MajArray {
+		return fmt.Errorf("cbor input should be of type array")
+	}
+
+	if extra != 2 {
+		return fmt.Errorf("cbor input had wrong number of fields")
+	}
+
+	// t.Value (string) (string)
+
+	{
+		sval, err := cbg.ReadStringBuf(br, scratch)
+		if err != nil {
+			return err
+		}
+
+		t.Value = string(sval)
+	}
+	// t.Unmarshallable ([]*chaos.UnmarshallableCBOR) (slice)
+
+	maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
+	if err != nil {
+		return err
+	}
+
+	if extra > cbg.MaxLength {
+		return fmt.Errorf("t.Unmarshallable: array too large (%d)", extra)
+	}
+
+	if maj != cbg.MajArray {
+		return fmt.Errorf("expected cbor array")
+	}
+
+	if extra > 0 {
+		t.Unmarshallable = make([]*UnmarshallableCBOR, extra)
+	}
+
+	for i := 0; i < int(extra); i++ {
+
+		var v UnmarshallableCBOR
+		if err := v.UnmarshalCBOR(br); err != nil {
+			return err
+		}
+
+		t.Unmarshallable[i] = &v
+	}
+
+	return nil
+}
+
+var lengthBufCallerValidationArgs = []byte{131}
+
+func (t *CallerValidationArgs) MarshalCBOR(w io.Writer) error {
+	if t == nil {
+		_, err := w.Write(cbg.CborNull)
+		return err
+	}
+	if _, err := w.Write(lengthBufCallerValidationArgs); err != nil {
+		return err
+	}
+
+	scratch := make([]byte, 9)
+
+	// t.Branch (chaos.CallerValidationBranch) (int64)
+	if t.Branch >= 0 {
+		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.Branch)); err != nil {
+			return err
+		}
+	} else {
+		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajNegativeInt, uint64(-t.Branch-1)); err != nil {
+			return err
+		}
+	}
+
+	// t.Addrs ([]address.Address) (slice)
+	if len(t.Addrs) > cbg.MaxLength {
+		return xerrors.Errorf("Slice value in field t.Addrs was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajArray, uint64(len(t.Addrs))); err != nil {
+		return err
+	}
+	for _, v := range t.Addrs {
+		if err := v.MarshalCBOR(w); err != nil {
+			return err
+		}
+	}
+
+	// t.Types ([]cid.Cid) (slice)
+	if len(t.Types) > cbg.MaxLength {
+		return xerrors.Errorf("Slice value in field t.Types was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajArray, uint64(len(t.Types))); err != nil {
+		return err
+	}
+	for _, v := range t.Types {
+		if err := cbg.WriteCidBuf(scratch, w, v); err != nil {
+			return xerrors.Errorf("failed writing cid field t.Types: %w", err)
+		}
+	}
+	return nil
+}
+
+func (t *CallerValidationArgs) UnmarshalCBOR(r io.Reader) error {
+	*t = CallerValidationArgs{}
+
+	br := cbg.GetPeeker(r)
+	scratch := make([]byte, 8)
+
+	maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
+	if err != nil {
+		return err
+	}
+	if maj != cbg.MajArray {
+		return fmt.Errorf("cbor input should be of type array")
+	}
+
+	if extra != 3 {
+		return fmt.Errorf("cbor input had wrong number of fields")
+	}
+
+	// t.Branch (chaos.CallerValidationBranch) (int64)
+	{
+		maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
+		var extraI int64
+		if err != nil {
+			return err
+		}
+		switch maj {
+		case cbg.MajUnsignedInt:
+			extraI = int64(extra)
+			if extraI < 0 {
+				return fmt.Errorf("int64 positive overflow")
+			}
+		case cbg.MajNegativeInt:
+			extraI = int64(extra)
+			if extraI < 0 {
+				return fmt.Errorf("int64 negative oveflow")
+			}
+			extraI = -1 - extraI
+		default:
+			return fmt.Errorf("wrong type for int64 field: %d", maj)
+		}
+
+		t.Branch = CallerValidationBranch(extraI)
+	}
+	// t.Addrs ([]address.Address) (slice)
+
+	maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
+	if err != nil {
+		return err
+	}
+
+	if extra > cbg.MaxLength {
+		return fmt.Errorf("t.Addrs: array too large (%d)", extra)
+	}
+
+	if maj != cbg.MajArray {
+		return fmt.Errorf("expected cbor array")
+	}
+
+	if extra > 0 {
+		t.Addrs = make([]address.Address, extra)
+	}
+
+	for i := 0; i < int(extra); i++ {
+
+		var v address.Address
+		if err := v.UnmarshalCBOR(br); err != nil {
+			return err
+		}
+
+		t.Addrs[i] = v
+	}
+
+	// t.Types ([]cid.Cid) (slice)
+
+	maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
+	if err != nil {
+		return err
+	}
+
+	if extra > cbg.MaxLength {
+		return fmt.Errorf("t.Types: array too large (%d)", extra)
+	}
+
+	if maj != cbg.MajArray {
+		return fmt.Errorf("expected cbor array")
+	}
+
+	if extra > 0 {
+		t.Types = make([]cid.Cid, extra)
+	}
+
+	for i := 0; i < int(extra); i++ {
+
+		c, err := cbg.ReadCid(br)
+		if err != nil {
+			return xerrors.Errorf("reading cid field t.Types failed: %w", err)
+		}
+		t.Types[i] = c
+	}
+
+	return nil
+}
+
+var lengthBufCreateActorArgs = []byte{132}
+
+func (t *CreateActorArgs) MarshalCBOR(w io.Writer) error {
+	if t == nil {
+		_, err := w.Write(cbg.CborNull)
+		return err
+	}
+	if _, err := w.Write(lengthBufCreateActorArgs); err != nil {
+		return err
+	}
+
+	scratch := make([]byte, 9)
+
+	// t.UndefActorCID (bool) (bool)
+	if err := cbg.WriteBool(w, t.UndefActorCID); err != nil {
+		return err
+	}
+
+	// t.ActorCID (cid.Cid) (struct)
+
+	if err := cbg.WriteCidBuf(scratch, w, t.ActorCID); err != nil {
+		return xerrors.Errorf("failed to write cid field t.ActorCID: %w", err)
+	}
+
+	// t.UndefAddress (bool) (bool)
+	if err := cbg.WriteBool(w, t.UndefAddress); err != nil {
+		return err
+	}
+
+	// t.Address (address.Address) (struct)
+	if err := t.Address.MarshalCBOR(w); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (t *CreateActorArgs) UnmarshalCBOR(r io.Reader) error {
+	*t = CreateActorArgs{}
+
+	br := cbg.GetPeeker(r)
+	scratch := make([]byte, 8)
+
+	maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
+	if err != nil {
+		return err
+	}
+	if maj != cbg.MajArray {
+		return fmt.Errorf("cbor input should be of type array")
+	}
+
+	if extra != 4 {
+		return fmt.Errorf("cbor input had wrong number of fields")
+	}
+
+	// t.UndefActorCID (bool) (bool)
+
+	maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
+	if err != nil {
+		return err
+	}
+	if maj != cbg.MajOther {
+		return fmt.Errorf("booleans must be major type 7")
+	}
+	switch extra {
+	case 20:
+		t.UndefActorCID = false
+	case 21:
+		t.UndefActorCID = true
+	default:
+		return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
+	}
+	// t.ActorCID (cid.Cid) (struct)
+
+	{
+
+		c, err := cbg.ReadCid(br)
+		if err != nil {
+			return xerrors.Errorf("failed to read cid field t.ActorCID: %w", err)
+		}
+
+		t.ActorCID = c
+
+	}
+	// t.UndefAddress (bool) (bool)
+
+	maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
+	if err != nil {
+		return err
+	}
+	if maj != cbg.MajOther {
+		return fmt.Errorf("booleans must be major type 7")
+	}
+	switch extra {
+	case 20:
+		t.UndefAddress = false
+	case 21:
+		t.UndefAddress = true
+	default:
+		return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
+	}
+	// t.Address (address.Address) (struct)
+
+	{
+
+		if err := t.Address.UnmarshalCBOR(br); err != nil {
+			return xerrors.Errorf("unmarshaling t.Address: %w", err)
+		}
+
+	}
+	return nil
+}
+
+var lengthBufResolveAddressResponse = []byte{130}
+
+func (t *ResolveAddressResponse) MarshalCBOR(w io.Writer) error {
+	if t == nil {
+		_, err := w.Write(cbg.CborNull)
+		return err
+	}
+	if _, err := w.Write(lengthBufResolveAddressResponse); err != nil {
+		return err
+	}
+
+	// t.Address (address.Address) (struct)
+	if err := t.Address.MarshalCBOR(w); err != nil {
+		return err
+	}
+
+	// t.Success (bool) (bool)
+	if err := cbg.WriteBool(w, t.Success); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (t *ResolveAddressResponse) UnmarshalCBOR(r io.Reader) error {
+	*t = ResolveAddressResponse{}
+
+	br := cbg.GetPeeker(r)
+	scratch := make([]byte, 8)
+
+	maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
+	if err != nil {
+		return err
+	}
+	if maj != cbg.MajArray {
+		return fmt.Errorf("cbor input should be of type array")
+	}
+
+	if extra != 2 {
+		return fmt.Errorf("cbor input had wrong number of fields")
+	}
+
+	// t.Address (address.Address) (struct)
+
+	{
+
+		if err := t.Address.UnmarshalCBOR(br); err != nil {
+			return xerrors.Errorf("unmarshaling t.Address: %w", err)
+		}
+
+	}
+	// t.Success (bool) (bool)
+
+	maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
+	if err != nil {
+		return err
+	}
+	if maj != cbg.MajOther {
+		return fmt.Errorf("booleans must be major type 7")
+	}
+	switch extra {
+	case 20:
+		t.Success = false
+	case 21:
+		t.Success = true
+	default:
+		return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
+	}
+	return nil
+}
+
+var lengthBufSendArgs = []byte{132}
+
+func (t *SendArgs) MarshalCBOR(w io.Writer) error {
+	if t == nil {
+		_, err := w.Write(cbg.CborNull)
+		return err
+	}
+	if _, err := w.Write(lengthBufSendArgs); err != nil {
+		return err
+	}
+
+	scratch := make([]byte, 9)
+
+	// t.To (address.Address) (struct)
+	if err := t.To.MarshalCBOR(w); err != nil {
+		return err
+	}
+
+	// t.Value (big.Int) (struct)
+	if err := t.Value.MarshalCBOR(w); err != nil {
+		return err
+	}
+
+	// t.Method (abi.MethodNum) (uint64)
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.Method)); err != nil {
+		return err
+	}
+
+	// t.Params ([]uint8) (slice)
+	if len(t.Params) > cbg.ByteArrayMaxLen {
+		return xerrors.Errorf("Byte array in field t.Params was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajByteString, uint64(len(t.Params))); err != nil {
+		return err
+	}
+
+	if _, err := w.Write(t.Params[:]); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (t *SendArgs) UnmarshalCBOR(r io.Reader) error {
+	*t = SendArgs{}
+
+	br := cbg.GetPeeker(r)
+	scratch := make([]byte, 8)
+
+	maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
+	if err != nil {
+		return err
+	}
+	if maj != cbg.MajArray {
+		return fmt.Errorf("cbor input should be of type array")
+	}
+
+	if extra != 4 {
+		return fmt.Errorf("cbor input had wrong number of fields")
+	}
+
+	// t.To (address.Address) (struct)
+
+	{
+
+		if err := t.To.UnmarshalCBOR(br); err != nil {
+			return xerrors.Errorf("unmarshaling t.To: %w", err)
+		}
+
+	}
+	// t.Value (big.Int) (struct)
+
+	{
+
+		if err := t.Value.UnmarshalCBOR(br); err != nil {
+			return xerrors.Errorf("unmarshaling t.Value: %w", err)
+		}
+
+	}
+	// t.Method (abi.MethodNum) (uint64)
+
+	{
+
+		maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
+		if err != nil {
+			return err
+		}
+		if maj != cbg.MajUnsignedInt {
+			return fmt.Errorf("wrong type for uint64 field")
+		}
+		t.Method = abi.MethodNum(extra)
+
+	}
+	// t.Params ([]uint8) (slice)
+
+	maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
+	if err != nil {
+		return err
+	}
+
+	if extra > cbg.ByteArrayMaxLen {
+		return fmt.Errorf("t.Params: byte array too large (%d)", extra)
+	}
+	if maj != cbg.MajByteString {
+		return fmt.Errorf("expected byte array")
+	}
+
+	if extra > 0 {
+		t.Params = make([]uint8, extra)
+	}
+
+	if _, err := io.ReadFull(br, t.Params[:]); err != nil {
+		return err
+	}
+	return nil
+}
+
+var lengthBufSendReturn = []byte{130}
+
+func (t *SendReturn) MarshalCBOR(w io.Writer) error {
+	if t == nil {
+		_, err := w.Write(cbg.CborNull)
+		return err
+	}
+	if _, err := w.Write(lengthBufSendReturn); err != nil {
+		return err
+	}
+
+	scratch := make([]byte, 9)
+
+	// t.Return (runtime.CBORBytes) (slice)
+	if len(t.Return) > cbg.ByteArrayMaxLen {
+		return xerrors.Errorf("Byte array in field t.Return was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajByteString, uint64(len(t.Return))); err != nil {
+		return err
+	}
+
+	if _, err := w.Write(t.Return[:]); err != nil {
+		return err
+	}
+
+	// t.Code (exitcode.ExitCode) (int64)
+	if t.Code >= 0 {
+		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.Code)); err != nil {
+			return err
+		}
+	} else {
+		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajNegativeInt, uint64(-t.Code-1)); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (t *SendReturn) UnmarshalCBOR(r io.Reader) error {
+	*t = SendReturn{}
+
+	br := cbg.GetPeeker(r)
+	scratch := make([]byte, 8)
+
+	maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
+	if err != nil {
+		return err
+	}
+	if maj != cbg.MajArray {
+		return fmt.Errorf("cbor input should be of type array")
+	}
+
+	if extra != 2 {
+		return fmt.Errorf("cbor input had wrong number of fields")
+	}
+
+	// t.Return (runtime.CBORBytes) (slice)
+
+	maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
+	if err != nil {
+		return err
+	}
+
+	if extra > cbg.ByteArrayMaxLen {
+		return fmt.Errorf("t.Return: byte array too large (%d)", extra)
+	}
+	if maj != cbg.MajByteString {
+		return fmt.Errorf("expected byte array")
+	}
+
+	if extra > 0 {
+		t.Return = make([]uint8, extra)
+	}
+
+	if _, err := io.ReadFull(br, t.Return[:]); err != nil {
+		return err
+	}
+	// t.Code (exitcode.ExitCode) (int64)
+	{
+		maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
+		var extraI int64
+		if err != nil {
+			return err
+		}
+		switch maj {
+		case cbg.MajUnsignedInt:
+			extraI = int64(extra)
+			if extraI < 0 {
+				return fmt.Errorf("int64 positive overflow")
+			}
+		case cbg.MajNegativeInt:
+			extraI = int64(extra)
+			if extraI < 0 {
+				return fmt.Errorf("int64 negative oveflow")
+			}
+			extraI = -1 - extraI
+		default:
+			return fmt.Errorf("wrong type for int64 field: %d", maj)
+		}
+
+		t.Code = exitcode.ExitCode(extraI)
+	}
+	return nil
+}
+
+var lengthBufMutateStateArgs = []byte{130}
+
+func (t *MutateStateArgs) MarshalCBOR(w io.Writer) error {
+	if t == nil {
+		_, err := w.Write(cbg.CborNull)
+		return err
+	}
+	if _, err := w.Write(lengthBufMutateStateArgs); err != nil {
+		return err
+	}
+
+	scratch := make([]byte, 9)
+
+	// t.Value (string) (string)
+	if len(t.Value) > cbg.MaxLength {
+		return xerrors.Errorf("Value in field t.Value was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len(t.Value))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string(t.Value)); err != nil {
+		return err
+	}
+
+	// t.Branch (chaos.MutateStateBranch) (int64)
+	if t.Branch >= 0 {
+		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.Branch)); err != nil {
+			return err
+		}
+	} else {
+		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajNegativeInt, uint64(-t.Branch-1)); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (t *MutateStateArgs) UnmarshalCBOR(r io.Reader) error {
+	*t = MutateStateArgs{}
+
+	br := cbg.GetPeeker(r)
+	scratch := make([]byte, 8)
+
+	maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
+	if err != nil {
+		return err
+	}
+	if maj != cbg.MajArray {
+		return fmt.Errorf("cbor input should be of type array")
+	}
+
+	if extra != 2 {
+		return fmt.Errorf("cbor input had wrong number of fields")
+	}
+
+	// t.Value (string) (string)
+
+	{
+		sval, err := cbg.ReadStringBuf(br, scratch)
+		if err != nil {
+			return err
+		}
+
+		t.Value = string(sval)
+	}
+	// t.Branch (chaos.MutateStateBranch) (int64)
+	{
+		maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
+		var extraI int64
+		if err != nil {
+			return err
+		}
+		switch maj {
+		case cbg.MajUnsignedInt:
+			extraI = int64(extra)
+			if extraI < 0 {
+				return fmt.Errorf("int64 positive overflow")
+			}
+		case cbg.MajNegativeInt:
+			extraI = int64(extra)
+			if extraI < 0 {
+				return fmt.Errorf("int64 negative oveflow")
+			}
+			extraI = -1 - extraI
+		default:
+			return fmt.Errorf("wrong type for int64 field: %d", maj)
+		}
+
+		t.Branch = MutateStateBranch(extraI)
+	}
+	return nil
+}
+
+var lengthBufAbortWithArgs = []byte{131}
+
+func (t *AbortWithArgs) MarshalCBOR(w io.Writer) error {
+	if t == nil {
+		_, err := w.Write(cbg.CborNull)
+		return err
+	}
+	if _, err := w.Write(lengthBufAbortWithArgs); err != nil {
+		return err
+	}
+
+	scratch := make([]byte, 9)
+
+	// t.Code (exitcode.ExitCode) (int64)
+	if t.Code >= 0 {
+		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.Code)); err != nil {
+			return err
+		}
+	} else {
+		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajNegativeInt, uint64(-t.Code-1)); err != nil {
+			return err
+		}
+	}
+
+	// t.Message (string) (string)
+	if len(t.Message) > cbg.MaxLength {
+		return xerrors.Errorf("Value in field t.Message was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len(t.Message))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string(t.Message)); err != nil {
+		return err
+	}
+
+	// t.Uncontrolled (bool) (bool)
+	if err := cbg.WriteBool(w, t.Uncontrolled); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (t *AbortWithArgs) UnmarshalCBOR(r io.Reader) error {
+	*t = AbortWithArgs{}
+
+	br := cbg.GetPeeker(r)
+	scratch := make([]byte, 8)
+
+	maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
+	if err != nil {
+		return err
+	}
+	if maj != cbg.MajArray {
+		return fmt.Errorf("cbor input should be of type array")
+	}
+
+	if extra != 3 {
+		return fmt.Errorf("cbor input had wrong number of fields")
+	}
+
+	// t.Code (exitcode.ExitCode) (int64)
+	{
+		maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
+		var extraI int64
+		if err != nil {
+			return err
+		}
+		switch maj {
+		case cbg.MajUnsignedInt:
+			extraI = int64(extra)
+			if extraI < 0 {
+				return fmt.Errorf("int64 positive overflow")
+			}
+		case cbg.MajNegativeInt:
+			extraI = int64(extra)
+			if extraI < 0 {
+				return fmt.Errorf("int64 negative oveflow")
+			}
+			extraI = -1 - extraI
+		default:
+			return fmt.Errorf("wrong type for int64 field: %d", maj)
+		}
+
+		t.Code = exitcode.ExitCode(extraI)
+	}
+	// t.Message (string) (string)
+
+	{
+		sval, err := cbg.ReadStringBuf(br, scratch)
+		if err != nil {
+			return err
+		}
+
+		t.Message = string(sval)
+	}
+	// t.Uncontrolled (bool) (bool)
+
+	maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
+	if err != nil {
+		return err
+	}
+	if maj != cbg.MajOther {
+		return fmt.Errorf("booleans must be major type 7")
+	}
+	switch extra {
+	case 20:
+		t.Uncontrolled = false
+	case 21:
+		t.Uncontrolled = true
+	default:
+		return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
+	}
+	return nil
+}
+
+var lengthBufInspectRuntimeReturn = []byte{134}
+
+func (t *InspectRuntimeReturn) MarshalCBOR(w io.Writer) error {
+	if t == nil {
+		_, err := w.Write(cbg.CborNull)
+		return err
+	}
+	if _, err := w.Write(lengthBufInspectRuntimeReturn); err != nil {
+		return err
+	}
+
+	scratch := make([]byte, 9)
+
+	// t.Caller (address.Address) (struct)
+	if err := t.Caller.MarshalCBOR(w); err != nil {
+		return err
+	}
+
+	// t.Receiver (address.Address) (struct)
+	if err := t.Receiver.MarshalCBOR(w); err != nil {
+		return err
+	}
+
+	// t.ValueReceived (big.Int) (struct)
+	if err := t.ValueReceived.MarshalCBOR(w); err != nil {
+		return err
+	}
+
+	// t.CurrEpoch (abi.ChainEpoch) (int64)
+	if t.CurrEpoch >= 0 {
+		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.CurrEpoch)); err != nil {
+			return err
+		}
+	} else {
+		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajNegativeInt, uint64(-t.CurrEpoch-1)); err != nil {
+			return err
+		}
+	}
+
+	// t.CurrentBalance (big.Int) (struct)
+	if err := t.CurrentBalance.MarshalCBOR(w); err != nil {
+		return err
+	}
+
+	// t.State (chaos.State) (struct)
+	if err := t.State.MarshalCBOR(w); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (t *InspectRuntimeReturn) UnmarshalCBOR(r io.Reader) error {
+	*t = InspectRuntimeReturn{}
+
+	br := cbg.GetPeeker(r)
+	scratch := make([]byte, 8)
+
+	maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
+	if err != nil {
+		return err
+	}
+	if maj != cbg.MajArray {
+		return fmt.Errorf("cbor input should be of type array")
+	}
+
+	if extra != 6 {
+		return fmt.Errorf("cbor input had wrong number of fields")
+	}
+
+	// t.Caller (address.Address) (struct)
+
+	{
+
+		if err := t.Caller.UnmarshalCBOR(br); err != nil {
+			return xerrors.Errorf("unmarshaling t.Caller: %w", err)
+		}
+
+	}
+	// t.Receiver (address.Address) (struct)
+
+	{
+
+		if err := t.Receiver.UnmarshalCBOR(br); err != nil {
+			return xerrors.Errorf("unmarshaling t.Receiver: %w", err)
+		}
+
+	}
+	// t.ValueReceived (big.Int) (struct)
+
+	{
+
+		if err := t.ValueReceived.UnmarshalCBOR(br); err != nil {
+			return xerrors.Errorf("unmarshaling t.ValueReceived: %w", err)
+		}
+
+	}
+	// t.CurrEpoch (abi.ChainEpoch) (int64)
+	{
+		maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
+		var extraI int64
+		if err != nil {
+			return err
+		}
+		switch maj {
+		case cbg.MajUnsignedInt:
+			extraI = int64(extra)
+			if extraI < 0 {
+				return fmt.Errorf("int64 positive overflow")
+			}
+		case cbg.MajNegativeInt:
+			extraI = int64(extra)
+			if extraI < 0 {
+				return fmt.Errorf("int64 negative oveflow")
+			}
+			extraI = -1 - extraI
+		default:
+			return fmt.Errorf("wrong type for int64 field: %d", maj)
+		}
+
+		t.CurrEpoch = abi.ChainEpoch(extraI)
+	}
+	// t.CurrentBalance (big.Int) (struct)
+
+	{
+
+		if err := t.CurrentBalance.UnmarshalCBOR(br); err != nil {
+			return xerrors.Errorf("unmarshaling t.CurrentBalance: %w", err)
+		}
+
+	}
+	// t.State (chaos.State) (struct)
+
+	{
+
+		if err := t.State.UnmarshalCBOR(br); err != nil {
+			return xerrors.Errorf("unmarshaling t.State: %w", err)
+		}
+
+	}
+	return nil
+}
diff --git a/conformance/chaos/gen/gen.go b/conformance/chaos/gen/gen.go
new file mode 100644
index 000000000..ac97da99e
--- /dev/null
+++ b/conformance/chaos/gen/gen.go
@@ -0,0 +1,23 @@
+package main
+
+import (
+	"github.com/filecoin-project/lotus/conformance/chaos"
+
+	gen "github.com/whyrusleeping/cbor-gen"
+)
+
+func main() {
+	if err := gen.WriteTupleEncodersToFile("./cbor_gen.go", "chaos",
+		chaos.State{},
+		chaos.CallerValidationArgs{},
+		chaos.CreateActorArgs{},
+		chaos.ResolveAddressResponse{},
+		chaos.SendArgs{},
+		chaos.SendReturn{},
+		chaos.MutateStateArgs{},
+		chaos.AbortWithArgs{},
+		chaos.InspectRuntimeReturn{},
+	); err != nil {
+		panic(err)
+	}
+}
diff --git a/conformance/chaos/ids.go b/conformance/chaos/ids.go
new file mode 100644
index 000000000..6b0ad86a7
--- /dev/null
+++ b/conformance/chaos/ids.go
@@ -0,0 +1,29 @@
+package chaos
+
+import (
+	"github.com/filecoin-project/go-address"
+	"github.com/ipfs/go-cid"
+	"github.com/multiformats/go-multihash"
+)
+
+// ChaosActorCodeCID is the CID by which this kind of actor will be identified.
+var ChaosActorCodeCID = func() cid.Cid {
+	builder := cid.V1Builder{Codec: cid.Raw, MhType: multihash.IDENTITY}
+	c, err := builder.Sum([]byte("fil/1/chaos"))
+	if err != nil {
+		panic(err)
+	}
+	return c
+}()
+
+// Address is the singleton address of this actor. Its value is 98
+// (builtin.FirstNonSingletonActorId - 2), as 99 is reserved for the burnt funds
+// singleton.
+var Address = func() address.Address {
+	// the address before the burnt funds address (99)
+	addr, err := address.NewIDAddress(98)
+	if err != nil {
+		panic(err)
+	}
+	return addr
+}()
diff --git a/conformance/chaos/state.go b/conformance/chaos/state.go
new file mode 100644
index 000000000..4a54ef61c
--- /dev/null
+++ b/conformance/chaos/state.go
@@ -0,0 +1,32 @@
+package chaos
+
+import (
+	"fmt"
+	"io"
+)
+
+// State is the state for the chaos actor used by some methods to invoke
+// behaviours in the vm or runtime.
+type State struct {
+	// Value can be updated by chaos actor methods to test illegal state
+	// mutations when the state is in readonly mode for example.
+	Value string
+	// Unmarshallable is a sentinel value. If the slice contains no values, the
+	// State struct will encode as CBOR without issue. If the slice is non-nil,
+	// CBOR encoding will fail.
+	Unmarshallable []*UnmarshallableCBOR
+}
+
+// UnmarshallableCBOR is a type that cannot be marshalled or unmarshalled to
+// CBOR despite implementing the CBORMarshaler and CBORUnmarshaler interface.
+type UnmarshallableCBOR struct{}
+
+// UnmarshalCBOR will fail to unmarshal the value from CBOR.
+func (t *UnmarshallableCBOR) UnmarshalCBOR(io.Reader) error {
+	return fmt.Errorf("failed to unmarshal cbor")
+}
+
+// MarshalCBOR will fail to marshal the value to CBOR.
+func (t *UnmarshallableCBOR) MarshalCBOR(io.Writer) error {
+	return fmt.Errorf("failed to marshal cbor")
+}
diff --git a/conformance/driver.go b/conformance/driver.go
new file mode 100644
index 000000000..f43a8739d
--- /dev/null
+++ b/conformance/driver.go
@@ -0,0 +1,178 @@
+package conformance
+
+import (
+	"context"
+
+	"github.com/filecoin-project/go-state-types/crypto"
+
+	"github.com/filecoin-project/lotus/chain/stmgr"
+	"github.com/filecoin-project/lotus/chain/store"
+	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/chain/vm"
+	"github.com/filecoin-project/lotus/conformance/chaos"
+	"github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper"
+	"github.com/filecoin-project/lotus/lib/blockstore"
+
+	"github.com/filecoin-project/go-state-types/abi"
+
+	"github.com/filecoin-project/test-vectors/schema"
+
+	"github.com/filecoin-project/go-address"
+
+	"github.com/ipfs/go-cid"
+	ds "github.com/ipfs/go-datastore"
+)
+
+var (
+	// BaseFee to use in the VM.
+	// TODO make parametrisable through vector.
+	BaseFee = abi.NewTokenAmount(100)
+)
+
+type Driver struct {
+	ctx      context.Context
+	selector schema.Selector
+}
+
+func NewDriver(ctx context.Context, selector schema.Selector) *Driver {
+	return &Driver{ctx: ctx, selector: selector}
+}
+
+type ExecuteTipsetResult struct {
+	ReceiptsRoot  cid.Cid
+	PostStateRoot cid.Cid
+
+	// AppliedMessages stores the messages that were applied, in the order they
+	// were applied. It includes implicit messages (cron, rewards).
+	AppliedMessages []*types.Message
+	// AppliedResults stores the results of AppliedMessages, in the same order.
+	AppliedResults []*vm.ApplyRet
+}
+
+// ExecuteTipset executes the supplied tipset on top of the state represented
+// by the preroot CID.
+//
+// parentEpoch is the last epoch in which an actual tipset was processed. This
+// is used by Lotus for null block counting and cron firing.
+//
+// This method returns the the receipts root, the poststate root, and the VM
+// message results. The latter _include_ implicit messages, such as cron ticks
+// and reward withdrawal per miner.
+func (d *Driver) ExecuteTipset(bs blockstore.Blockstore, ds ds.Batching, preroot cid.Cid, parentEpoch abi.ChainEpoch, tipset *schema.Tipset) (*ExecuteTipsetResult, error) {
+	var (
+		syscalls = mkFakedSigSyscalls(vm.Syscalls(ffiwrapper.ProofVerifier))
+		vmRand   = new(testRand)
+
+		cs = store.NewChainStore(bs, ds, syscalls)
+		sm = stmgr.NewStateManager(cs)
+	)
+
+	blocks := make([]store.BlockMessages, 0, len(tipset.Blocks))
+	for _, b := range tipset.Blocks {
+		sb := store.BlockMessages{
+			Miner:    b.MinerAddr,
+			WinCount: b.WinCount,
+		}
+		for _, m := range b.Messages {
+			msg, err := types.DecodeMessage(m)
+			if err != nil {
+				return nil, err
+			}
+			switch msg.From.Protocol() {
+			case address.SECP256K1:
+				sb.SecpkMessages = append(sb.SecpkMessages, toChainMsg(msg))
+			case address.BLS:
+				sb.BlsMessages = append(sb.BlsMessages, toChainMsg(msg))
+			default:
+				// sneak in messages originating from other addresses as both kinds.
+				// these should fail, as they are actually invalid senders.
+				sb.SecpkMessages = append(sb.SecpkMessages, msg)
+				sb.BlsMessages = append(sb.BlsMessages, msg)
+			}
+		}
+		blocks = append(blocks, sb)
+	}
+
+	var (
+		messages []*types.Message
+		results  []*vm.ApplyRet
+
+		epoch   = abi.ChainEpoch(tipset.Epoch)
+		basefee = abi.NewTokenAmount(tipset.BaseFee.Int64())
+	)
+
+	postcid, receiptsroot, err := sm.ApplyBlocks(context.Background(), parentEpoch, preroot, blocks, epoch, vmRand, func(_ cid.Cid, msg *types.Message, ret *vm.ApplyRet) error {
+		messages = append(messages, msg)
+		results = append(results, ret)
+		return nil
+	}, basefee, nil)
+
+	if err != nil {
+		return nil, err
+	}
+
+	ret := &ExecuteTipsetResult{
+		ReceiptsRoot:    receiptsroot,
+		PostStateRoot:   postcid,
+		AppliedMessages: messages,
+		AppliedResults:  results,
+	}
+	return ret, nil
+}
+
+// ExecuteMessage executes a conformance test vector message in a temporary VM.
+func (d *Driver) ExecuteMessage(bs blockstore.Blockstore, preroot cid.Cid, epoch abi.ChainEpoch, msg *types.Message) (*vm.ApplyRet, cid.Cid, error) {
+	// dummy state manager; only to reference the GetNetworkVersion method, which does not depend on state.
+	sm := new(stmgr.StateManager)
+	vmOpts := &vm.VMOpts{
+		StateBase:      preroot,
+		Epoch:          epoch,
+		Rand:           &testRand{}, // TODO always succeeds; need more flexibility.
+		Bstore:         bs,
+		Syscalls:       mkFakedSigSyscalls(vm.Syscalls(ffiwrapper.ProofVerifier)), // TODO always succeeds; need more flexibility.
+		CircSupplyCalc: nil,
+		BaseFee:        BaseFee,
+		NtwkVersion:    sm.GetNtwkVersion,
+	}
+
+	lvm, err := vm.NewVM(context.TODO(), vmOpts)
+	if err != nil {
+		return nil, cid.Undef, err
+	}
+
+	invoker := vm.NewInvoker()
+
+	// register the chaos actor if required by the vector.
+	if chaosOn, ok := d.selector["chaos_actor"]; ok && chaosOn == "true" {
+		invoker.Register(chaos.ChaosActorCodeCID, chaos.Actor{}, chaos.State{})
+	}
+
+	lvm.SetInvoker(invoker)
+
+	ret, err := lvm.ApplyMessage(d.ctx, toChainMsg(msg))
+	if err != nil {
+		return nil, cid.Undef, err
+	}
+
+	root, err := lvm.Flush(d.ctx)
+	return ret, root, err
+}
+
+// toChainMsg injects a synthetic 0-filled signature of the right length to
+// messages that originate from secp256k senders, leaving all
+// others untouched.
+// TODO: generate a signature in the DSL so that it's encoded in
+//  the test vector.
+func toChainMsg(msg *types.Message) (ret types.ChainMsg) {
+	ret = msg
+	if msg.From.Protocol() == address.SECP256K1 {
+		ret = &types.SignedMessage{
+			Message: *msg,
+			Signature: crypto.Signature{
+				Type: crypto.SigTypeSecp256k1,
+				Data: make([]byte, 65),
+			},
+		}
+	}
+	return ret
+}
diff --git a/conformance/runner_test.go b/conformance/runner_test.go
new file mode 100644
index 000000000..cc7ef6b3d
--- /dev/null
+++ b/conformance/runner_test.go
@@ -0,0 +1,376 @@
+package conformance
+
+import (
+	"bytes"
+	"compress/gzip"
+	"context"
+	"encoding/base64"
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"testing"
+
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/exitcode"
+	"github.com/ipfs/go-blockservice"
+	"github.com/ipfs/go-cid"
+	ds "github.com/ipfs/go-datastore"
+	offline "github.com/ipfs/go-ipfs-exchange-offline"
+	format "github.com/ipfs/go-ipld-format"
+	"github.com/ipfs/go-merkledag"
+
+	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/chain/vm"
+	"github.com/filecoin-project/lotus/lib/blockstore"
+
+	"github.com/filecoin-project/test-vectors/schema"
+
+	"github.com/fatih/color"
+	"github.com/ipld/go-car"
+)
+
+const (
+	// EnvSkipConformance, if 1, skips the conformance test suite.
+	EnvSkipConformance = "SKIP_CONFORMANCE"
+
+	// EnvCorpusRootDir is the name of the environment variable where the path
+	// to an alternative corpus location can be provided.
+	//
+	// The default is defaultCorpusRoot.
+	EnvCorpusRootDir = "CORPUS_DIR"
+
+	// defaultCorpusRoot is the directory where the test vector corpus is hosted.
+	// It is mounted on the Lotus repo as a git submodule.
+	//
+	// When running this test, the corpus root can be overridden through the
+	// -conformance.corpus CLI flag to run an alternate corpus.
+	defaultCorpusRoot = "../extern/test-vectors/corpus"
+)
+
+// ignore is a set of paths relative to root to skip.
+var ignore = map[string]struct{}{
+	".git":        {},
+	"schema.json": {},
+}
+
+// TestConformance is the entrypoint test that runs all test vectors found
+// in the corpus root directory.
+//
+// It locates all json files via a recursive walk, skipping over the ignore set,
+// as well as files beginning with _. It parses each file as a test vector, and
+// runs it via the Driver.
+func TestConformance(t *testing.T) {
+	if skip := strings.TrimSpace(os.Getenv(EnvSkipConformance)); skip == "1" {
+		t.SkipNow()
+	}
+	// corpusRoot is the effective corpus root path, taken from the `-conformance.corpus` CLI flag,
+	// falling back to defaultCorpusRoot if not provided.
+	corpusRoot := defaultCorpusRoot
+	if dir := strings.TrimSpace(os.Getenv(EnvCorpusRootDir)); dir != "" {
+		corpusRoot = dir
+	}
+
+	var vectors []string
+	err := filepath.Walk(corpusRoot+"/", func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		filename := filepath.Base(path)
+		rel, err := filepath.Rel(corpusRoot, path)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		if _, ok := ignore[rel]; ok {
+			// skip over using the right error.
+			if info.IsDir() {
+				return filepath.SkipDir
+			}
+			return nil
+		}
+		if info.IsDir() {
+			// dive into directories.
+			return nil
+		}
+		if filepath.Ext(path) != ".json" {
+			// skip if not .json.
+			return nil
+		}
+		if ignored := strings.HasPrefix(filename, "_"); ignored {
+			// ignore files starting with _.
+			t.Logf("ignoring: %s", rel)
+			return nil
+		}
+		vectors = append(vectors, rel)
+		return nil
+	})
+
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if len(vectors) == 0 {
+		t.Fatalf("no test vectors found")
+	}
+
+	// Run a test for each vector.
+	for _, v := range vectors {
+		path := filepath.Join(corpusRoot, v)
+		raw, err := ioutil.ReadFile(path)
+		if err != nil {
+			t.Fatalf("failed to read test raw file: %s", path)
+		}
+
+		var vector schema.TestVector
+		err = json.Unmarshal(raw, &vector)
+		if err != nil {
+			t.Errorf("failed to parse test vector %s: %s; skipping", path, err)
+			continue
+		}
+
+		t.Run(v, func(t *testing.T) {
+			for _, h := range vector.Hints {
+				if h == schema.HintIncorrect {
+					t.Logf("skipping vector marked as incorrect: %s", vector.Meta.ID)
+					t.SkipNow()
+				}
+			}
+
+			// dispatch the execution depending on the vector class.
+			switch vector.Class {
+			case "message":
+				executeMessageVector(t, &vector)
+			case "tipset":
+				executeTipsetVector(t, &vector)
+			default:
+				t.Fatalf("test vector class not supported: %s", vector.Class)
+			}
+		})
+	}
+}
+
+// executeMessageVector executes a message-class test vector.
+func executeMessageVector(t *testing.T, vector *schema.TestVector) {
+	var (
+		ctx   = context.Background()
+		epoch = vector.Pre.Epoch
+		root  = vector.Pre.StateTree.RootCID
+	)
+
+	// Load the CAR into a new temporary Blockstore.
+	bs := loadCAR(t, vector.CAR)
+
+	// Create a new Driver.
+	driver := NewDriver(ctx, vector.Selector)
+
+	// Apply every message.
+	for i, m := range vector.ApplyMessages {
+		msg, err := types.DecodeMessage(m.Bytes)
+		if err != nil {
+			t.Fatalf("failed to deserialize message: %s", err)
+		}
+
+		// add an epoch if one's set.
+		if m.Epoch != nil {
+			epoch = *m.Epoch
+		}
+
+		// Execute the message.
+		var ret *vm.ApplyRet
+		ret, root, err = driver.ExecuteMessage(bs, root, abi.ChainEpoch(epoch), msg)
+		if err != nil {
+			t.Fatalf("fatal failure when executing message: %s", err)
+		}
+
+		// Assert that the receipt matches what the test vector expects.
+		assertMsgResult(t, vector.Post.Receipts[i], ret, strconv.Itoa(i))
+	}
+
+	// Once all messages are applied, assert that the final state root matches
+	// the expected postcondition root.
+	if expected, actual := vector.Post.StateTree.RootCID, root; expected != actual {
+		t.Logf("actual state root CID doesn't match expected one; expected: %s, actual: %s", expected, actual)
+		dumpThreeWayStateDiff(t, vector, bs, root)
+		t.FailNow()
+	}
+}
+
+// executeTipsetVector executes a tipset-class test vector.
+func executeTipsetVector(t *testing.T, vector *schema.TestVector) {
+	var (
+		ctx       = context.Background()
+		prevEpoch = vector.Pre.Epoch
+		root      = vector.Pre.StateTree.RootCID
+		tmpds     = ds.NewMapDatastore()
+	)
+
+	// Load the CAR into a new temporary Blockstore.
+	bs := loadCAR(t, vector.CAR)
+
+	// Create a new Driver.
+	driver := NewDriver(ctx, vector.Selector)
+
+	// Apply every tipset.
+	var receiptsIdx int
+	for i, ts := range vector.ApplyTipsets {
+		ts := ts // capture
+		ret, err := driver.ExecuteTipset(bs, tmpds, root, abi.ChainEpoch(prevEpoch), &ts)
+		if err != nil {
+			t.Fatalf("failed to apply tipset %d message: %s", i, err)
+		}
+
+		for j, v := range ret.AppliedResults {
+			assertMsgResult(t, vector.Post.Receipts[receiptsIdx], v, fmt.Sprintf("%d of tipset %d", j, i))
+			receiptsIdx++
+		}
+
+		// Compare the receipts root.
+		if expected, actual := vector.Post.ReceiptsRoots[i], ret.ReceiptsRoot; expected != actual {
+			t.Errorf("post receipts root doesn't match; expected: %s, was: %s", expected, actual)
+		}
+
+		prevEpoch = ts.Epoch
+		root = ret.PostStateRoot
+	}
+
+	// Once all messages are applied, assert that the final state root matches
+	// the expected postcondition root.
+	if expected, actual := vector.Post.StateTree.RootCID, root; expected != actual {
+		t.Logf("actual state root CID doesn't match expected one; expected: %s, actual: %s", expected, actual)
+		dumpThreeWayStateDiff(t, vector, bs, root)
+		t.FailNow()
+	}
+}
+
+// assertMsgResult compares a message result. It takes the expected receipt
+// encoded in the vector, the actual receipt returned by Lotus, and a message
+// label to log in the assertion failure message to facilitate debugging.
+func assertMsgResult(t *testing.T, expected *schema.Receipt, actual *vm.ApplyRet, label string) {
+	t.Helper()
+
+	if expected, actual := exitcode.ExitCode(expected.ExitCode), actual.ExitCode; expected != actual {
+		t.Errorf("exit code of msg %s did not match; expected: %s, got: %s", label, expected, actual)
+	}
+	if expected, actual := expected.GasUsed, actual.GasUsed; expected != actual {
+		t.Errorf("gas used of msg %s did not match; expected: %d, got: %d", label, expected, actual)
+	}
+	if expected, actual := []byte(expected.ReturnValue), actual.Return; !bytes.Equal(expected, actual) {
+		t.Errorf("return value of msg %s did not match; expected: %s, got: %s", label, base64.StdEncoding.EncodeToString(expected), base64.StdEncoding.EncodeToString(actual))
+	}
+}
+
+func dumpThreeWayStateDiff(t *testing.T, vector *schema.TestVector, bs blockstore.Blockstore, actual cid.Cid) {
+	// check if statediff exists; if not, skip.
+	if err := exec.Command("statediff", "--help").Run(); err != nil {
+		t.Log("could not dump 3-way state tree diff upon test failure: statediff command not found")
+		t.Log("install statediff with:")
+		t.Log("$ git clone https://github.com/filecoin-project/statediff.git")
+		t.Log("$ cd statediff")
+		t.Log("$ go generate ./...")
+		t.Log("$ go install ./cmd/statediff")
+		return
+	}
+
+	tmpCar := writeStateToTempCAR(t, bs,
+		vector.Pre.StateTree.RootCID,
+		vector.Post.StateTree.RootCID,
+		actual,
+	)
+
+	color.NoColor = false // enable colouring.
+
+	t.Errorf("wrong post root cid; expected %v, but got %v", vector.Post.StateTree.RootCID, actual)
+
+	var (
+		a  = color.New(color.FgMagenta, color.Bold).Sprint("(A) expected final state")
+		b  = color.New(color.FgYellow, color.Bold).Sprint("(B) actual final state")
+		c  = color.New(color.FgCyan, color.Bold).Sprint("(C) initial state")
+		d1 = color.New(color.FgGreen, color.Bold).Sprint("[Δ1]")
+		d2 = color.New(color.FgGreen, color.Bold).Sprint("[Δ2]")
+		d3 = color.New(color.FgGreen, color.Bold).Sprint("[Δ3]")
+	)
+
+	printDiff := func(left, right cid.Cid) {
+		cmd := exec.Command("statediff", "car", "--file", tmpCar, left.String(), right.String())
+		b, err := cmd.CombinedOutput()
+		if err != nil {
+			t.Fatalf("statediff failed: %s", err)
+		}
+		t.Log(string(b))
+	}
+
+	bold := color.New(color.Bold).SprintfFunc()
+
+	// run state diffs.
+	t.Log(bold("=== dumping 3-way diffs between %s, %s, %s ===", a, b, c))
+
+	t.Log(bold("--- %s left: %s; right: %s ---", d1, a, b))
+	printDiff(vector.Post.StateTree.RootCID, actual)
+
+	t.Log(bold("--- %s left: %s; right: %s ---", d2, c, b))
+	printDiff(vector.Pre.StateTree.RootCID, actual)
+
+	t.Log(bold("--- %s left: %s; right: %s ---", d3, c, a))
+	printDiff(vector.Pre.StateTree.RootCID, vector.Post.StateTree.RootCID)
+}
+
+// writeStateToTempCAR writes the provided roots to a temporary CAR that'll be
+// cleaned up via t.Cleanup(). It returns the full path of the temp file.
+func writeStateToTempCAR(t *testing.T, bs blockstore.Blockstore, roots ...cid.Cid) string {
+	tmp, err := ioutil.TempFile("", "lotus-tests-*.car")
+	if err != nil {
+		t.Fatalf("failed to create temp file to dump CAR for diffing: %s", err)
+	}
+	// register a cleanup function to delete the CAR.
+	t.Cleanup(func() {
+		_ = os.Remove(tmp.Name())
+	})
+
+	carWalkFn := func(nd format.Node) (out []*format.Link, err error) {
+		for _, link := range nd.Links() {
+			if link.Cid.Prefix().Codec == cid.FilCommitmentSealed || link.Cid.Prefix().Codec == cid.FilCommitmentUnsealed {
+				continue
+			}
+			out = append(out, link)
+		}
+		return out, nil
+	}
+
+	var (
+		offl    = offline.Exchange(bs)
+		blkserv = blockservice.New(bs, offl)
+		dserv   = merkledag.NewDAGService(blkserv)
+	)
+
+	err = car.WriteCarWithWalker(context.Background(), dserv, roots, tmp, carWalkFn)
+	if err != nil {
+		t.Fatalf("failed to dump CAR for diffing: %s", err)
+	}
+	_ = tmp.Close()
+	return tmp.Name()
+}
+
+func loadCAR(t *testing.T, vectorCAR schema.Base64EncodedBytes) blockstore.Blockstore {
+	bs := blockstore.NewTemporary()
+
+	// Read the base64-encoded CAR from the vector, and inflate the gzip.
+	buf := bytes.NewReader(vectorCAR)
+	r, err := gzip.NewReader(buf)
+	if err != nil {
+		t.Fatalf("failed to inflate gzipped CAR: %s", err)
+	}
+	defer r.Close() // nolint
+
+	// Load the CAR embedded in the test vector into the Blockstore.
+	_, err = car.LoadCar(bs, r)
+	if err != nil {
+		t.Fatalf("failed to load state tree car from test vector: %s", err)
+	}
+	return bs
+}
diff --git a/conformance/stubs.go b/conformance/stubs.go
new file mode 100644
index 000000000..a7100892f
--- /dev/null
+++ b/conformance/stubs.go
@@ -0,0 +1,56 @@
+package conformance
+
+import (
+	"context"
+
+	"github.com/filecoin-project/specs-actors/actors/runtime/proof"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/lotus/chain/state"
+	"github.com/filecoin-project/lotus/chain/vm"
+
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/crypto"
+	"github.com/filecoin-project/specs-actors/actors/runtime"
+
+	cbor "github.com/ipfs/go-ipld-cbor"
+)
+
+type testRand struct{}
+
+var _ vm.Rand = (*testRand)(nil)
+
+func (r *testRand) GetChainRandomness(ctx context.Context, pers crypto.DomainSeparationTag, round abi.ChainEpoch, entropy []byte) ([]byte, error) {
+	return []byte("i_am_random_____i_am_random_____"), nil // 32 bytes.
+}
+
+func (r *testRand) GetBeaconRandomness(ctx context.Context, pers crypto.DomainSeparationTag, round abi.ChainEpoch, entropy []byte) ([]byte, error) {
+	return []byte("i_am_random_____i_am_random_____"), nil // 32 bytes.
+}
+
+type testSyscalls struct {
+	runtime.Syscalls
+}
+
+// TODO VerifySignature this will always succeed; but we want to be able to test failures too.
+func (fss *testSyscalls) VerifySignature(_ crypto.Signature, _ address.Address, _ []byte) error {
+	return nil
+}
+
+// TODO VerifySeal this will always succeed; but we want to be able to test failures too.
+func (fss *testSyscalls) VerifySeal(_ proof.SealVerifyInfo) error {
+	return nil
+}
+
+// TODO VerifyPoSt this will always succeed; but we want to be able to test failures too.
+func (fss *testSyscalls) VerifyPoSt(_ proof.WindowPoStVerifyInfo) error {
+	return nil
+}
+
+func mkFakedSigSyscalls(base vm.SyscallBuilder) vm.SyscallBuilder {
+	return func(ctx context.Context, cstate *state.StateTree, cst cbor.IpldStore) runtime.Syscalls {
+		return &testSyscalls{
+			base(ctx, cstate, cst),
+		}
+	}
+}
diff --git a/datatransfer/dagservice_impl.go b/datatransfer/dagservice_impl.go
deleted file mode 100644
index 98c15d062..000000000
--- a/datatransfer/dagservice_impl.go
+++ /dev/null
@@ -1,78 +0,0 @@
-package datatransfer
-
-import (
-	"context"
-	"reflect"
-
-	"github.com/ipfs/go-cid"
-	ipldformat "github.com/ipfs/go-ipld-format"
-	"github.com/ipfs/go-merkledag"
-	ipld "github.com/ipld/go-ipld-prime"
-	"github.com/libp2p/go-libp2p-core/peer"
-	"golang.org/x/xerrors"
-)
-
-// This file implements a VERY simple, incomplete version of the data transfer
-// module that allows us to make the necessary insertions of data transfer
-// functionality into the storage market
-// It does not:
-// -- actually validate requests
-// -- support Push requests
-// -- support multiple subscribers
-// -- do any actual network coordination or use Graphsync
-
-type dagserviceImpl struct {
-	dag        ipldformat.DAGService
-	subscriber Subscriber
-}
-
-// NewDAGServiceDataTransfer returns a data transfer manager based on
-// an IPLD DAGService
-func NewDAGServiceDataTransfer(dag ipldformat.DAGService) Manager {
-	return &dagserviceImpl{dag, nil}
-}
-
-// RegisterVoucherType registers a validator for the given voucher type
-// will error if voucher type does not implement voucher
-// or if there is a voucher type registered with an identical identifier
-func (impl *dagserviceImpl) RegisterVoucherType(voucherType reflect.Type, validator RequestValidator) error {
-	return nil
-}
-
-// open a data transfer that will send data to the recipient peer and
-// transfer parts of the piece that match the selector
-func (impl *dagserviceImpl) OpenPushDataChannel(ctx context.Context, to peer.ID, voucher Voucher, baseCid cid.Cid, Selector ipld.Node) (ChannelID, error) {
-	return ChannelID{}, xerrors.Errorf("not implemented")
-}
-
-// open a data transfer that will request data from the sending peer and
-// transfer parts of the piece that match the selector
-func (impl *dagserviceImpl) OpenPullDataChannel(ctx context.Context, to peer.ID, voucher Voucher, baseCid cid.Cid, Selector ipld.Node) (ChannelID, error) {
-	ctx, cancel := context.WithCancel(ctx)
-	go func() {
-		defer cancel()
-		err := merkledag.FetchGraph(ctx, baseCid, impl.dag)
-		var event Event
-		if err != nil {
-			event = Error
-		} else {
-			event = Complete
-		}
-		impl.subscriber(event, ChannelState{Channel: Channel{voucher: voucher}})
-	}()
-	return ChannelID{}, nil
-}
-
-// close an open channel (effectively a cancel)
-func (impl *dagserviceImpl) CloseDataTransferChannel(x ChannelID) {}
-
-// get status of a transfer
-func (impl *dagserviceImpl) TransferChannelStatus(x ChannelID) Status { return ChannelNotFoundError }
-
-// get notified when certain types of events happen
-func (impl *dagserviceImpl) SubscribeToEvents(subscriber Subscriber) {
-	impl.subscriber = subscriber
-}
-
-// get all in progress transfers
-func (impl *dagserviceImpl) InProgressChannels() map[ChannelID]ChannelState { return nil }
diff --git a/datatransfer/types.go b/datatransfer/types.go
deleted file mode 100644
index 684b7f7a8..000000000
--- a/datatransfer/types.go
+++ /dev/null
@@ -1,173 +0,0 @@
-package datatransfer
-
-import (
-	"context"
-	"reflect"
-
-	"github.com/ipfs/go-cid"
-	ipld "github.com/ipld/go-ipld-prime"
-	"github.com/libp2p/go-libp2p-core/peer"
-)
-
-// Voucher is used to validate
-// a data transfer request against the underlying storage or retrieval deal
-// that precipitated it. The only requirement is a voucher can read and write
-// from bytes, and has a string identifier type
-type Voucher interface {
-	// ToBytes converts the Voucher to raw bytes
-	ToBytes() ([]byte, error)
-	// FromBytes reads a Voucher from raw bytes
-	FromBytes([]byte) error
-	// Identifier is a unique string identifier for this voucher type
-	Identifier() string
-}
-
-// Status is the status of transfer for a given channel
-type Status int
-
-const (
-	// Ongoing means the data transfer is in progress
-	Ongoing Status = iota
-
-	// Completed means the data transfer is completed successfully
-	Completed
-
-	// Failed means the data transfer failed
-	Failed
-
-	// ChannelNotFoundError means the searched for data transfer does not exist
-	ChannelNotFoundError
-)
-
-// TransferID is an identifier for a data transfer, shared between
-// request/responder and unique to the requester
-type TransferID uint64
-
-// ChannelID is a unique identifier for a channel, distinct by both the other
-// party's peer ID + the transfer ID
-type ChannelID struct {
-	to peer.ID
-	id TransferID
-}
-
-// Channel represents all the parameters for a single data transfer
-type Channel struct {
-	// an identifier for this channel shared by request and responder, set by requester through protocol
-	transferID TransferID
-	// base CID for the piece being transferred
-	baseCid cid.Cid
-	// portion of Piece to return, specified by an IPLD selector
-	selector ipld.Node
-	// used to verify this channel
-	voucher Voucher
-	// the party that is sending the data (not who initiated the request)
-	sender peer.ID
-	// the party that is receiving the data (not who initiated the request)
-	recipient peer.ID
-	// expected amount of data to be transferred
-	totalSize uint64
-}
-
-// TransferID returns the transfer id for this channel
-func (c Channel) TransferID() TransferID { return c.transferID }
-
-// BaseCID returns the CID that is at the root of this data transfer
-func (c Channel) BaseCID() cid.Cid { return c.baseCid }
-
-// Selector returns the IPLD selector for this data transfer (represented as
-// an IPLD node)
-func (c Channel) Selector() ipld.Node { return c.selector }
-
-// Voucher returns the voucher for this data transfer
-func (c Channel) Voucher() Voucher { return c.voucher }
-
-// Sender returns the peer id for the node that is sending data
-func (c Channel) Sender() peer.ID { return c.sender }
-
-// Recipient returns the peer id for the node that is receiving data
-func (c Channel) Recipient() peer.ID { return c.recipient }
-
-// TotalSize returns the total size for the data being transferred
-func (c Channel) TotalSize() uint64 { return c.totalSize }
-
-// ChannelState is immutable channel data plus mutable state
-type ChannelState struct {
-	Channel
-	// total bytes sent from this node (0 if receiver)
-	sent uint64
-	// total bytes received by this node (0 if sender)
-	received uint64
-}
-
-// Sent returns the number of bytes sent
-func (c ChannelState) Sent() uint64 { return c.sent }
-
-// Received returns the number of bytes received
-func (c ChannelState) Received() uint64 { return c.received }
-
-// Event is a name for an event that occurs on a data transfer channel
-type Event int
-
-const (
-	// Open is an event occurs when a channel is first opened
-	Open Event = iota
-
-	// Progress is an event that gets emitted every time more data is transferred
-	Progress
-
-	// Error is an event that emits when an error occurs in a data transfer
-	Error
-
-	// Complete is emitted when a data transfer is complete
-	Complete
-)
-
-// Subscriber is a callback that is called when events are emitted
-type Subscriber func(event Event, channelState ChannelState)
-
-// RequestValidator is an interface implemented by the client of the
-// data transfer module to validate requests
-type RequestValidator interface {
-	// ValidatePush validates a push request received from the peer that will send data
-	ValidatePush(
-		sender peer.ID,
-		voucher Voucher,
-		baseCid cid.Cid,
-		selector ipld.Node) error
-	// ValidatePull validates a pull request received from the peer that will receive data
-	ValidatePull(
-		receiver peer.ID,
-		voucher Voucher,
-		baseCid cid.Cid,
-		selector ipld.Node) error
-}
-
-// Manager is the core interface presented by all implementations of
-// of the data transfer sub system
-type Manager interface {
-	// RegisterVoucherType registers a validator for the given voucher type
-	// will error if voucher type does not implement voucher
-	// or if there is a voucher type registered with an identical identifier
-	RegisterVoucherType(voucherType reflect.Type, validator RequestValidator) error
-
-	// open a data transfer that will send data to the recipient peer and
-	// open a data transfer that will send data to the recipient peer and
-	// transfer parts of the piece that match the selector
-	OpenPushDataChannel(ctx context.Context, to peer.ID, voucher Voucher, baseCid cid.Cid, selector ipld.Node) (ChannelID, error)
-
-	// open a data transfer that will request data from the sending peer and
-	// transfer parts of the piece that match the selector
-	OpenPullDataChannel(ctx context.Context, to peer.ID, voucher Voucher, baseCid cid.Cid, selector ipld.Node) (ChannelID, error)
-
-	// close an open channel (effectively a cancel)
-	CloseDataTransferChannel(x ChannelID)
-
-	// get status of a transfer
-	TransferChannelStatus(x ChannelID) Status
-
-	// get notified when certain types of events happen
-	SubscribeToEvents(subscriber Subscriber)
-
-	// get all in progress transfers
-	InProgressChannels() map[ChannelID]ChannelState
-}
diff --git a/documentation/en/.glossary.json b/documentation/en/.glossary.json
index 41126f974..e8a9e0846 100644
--- a/documentation/en/.glossary.json
+++ b/documentation/en/.glossary.json
@@ -63,17 +63,13 @@
     "title": "Proof-of-Spacetime(s)",
     "value": "Filecoin is a protocol token whose blockchain runs on a novel proof, called Proof-of-Spacetime, where blocks are created by miners that are storing data."
   },
-  "lotus-testnet": {
-    "title": "Filecoin Testnet",
-    "value": "Until we launch, we are making lots of changes to Lotus. The Testnet is expected to bring a few significant fixes/improvements. During Testnet, you can retrieve test filecoin from our network faucet to use as collateral to start mining. Test filecoin do not have any value – the official filecoin tokens will not be released until Mainnet launch."
-  },
   "filecoin-testnet": {
     "title": "Filecoin Testnet",
     "value": "Until we launch, we are making lots of changes to Lotus. The Testnet is expected to bring a few significant fixes/improvements. During Testnet, you can retrieve test filecoin from our network faucet to use as collateral to start mining. Test filecoin do not have any value – the official filecoin tokens will not be released until Mainnet launch."
   },
   "filecoin-decentralized-storage-market": {
     "title": "Filecoin Decentralized Storage Market",
-    "value": "Storage Market subsystem is the data entry point into the network. Storage miners only earn power from data stored in a storage deal and all deals live on the Filecoin network."
+    "value": "Storage Market subsystem is the data entry point into the network. Miners only earn power from data stored in a storage deal and all deals live on the Filecoin network."
   },
   "filecoin-proof-parameters": {
     "title": "Filecoin Proof Parameters",
@@ -99,13 +95,13 @@
     "title": "Miner (Block Producer)",
     "value": "The Block Producer Miner's logic. It currently shares an interface and process with the Lotus Node. A Block Producer chooses which messages to include in a block and is rewarded according to each message’s gas price and consumption, forming a market."
   },
-  "lotus-storage-miner": {
-    "title": "Storage Miner (lotus-storage-miner)",
-    "value": "The Storage Miner's logic. It has its own dedicated process. Contributes to the network through Sector commitments and Proofs of Spacetime to prove that it is storing the sectors it has commited to."
+  "lotus-miner": {
+    "title": "Miner (lotus-miner)",
+    "value": "The Miner's logic. It has its own dedicated process. Contributes to the network through Sector commitments and Proofs of Spacetime to prove that it is storing the sectors it has commited to."
   },
   "swarm-port": {
     "title": "Swarm Port (Libp2p)",
-    "value": "The LibP2P Swarm manages groups of connections to peers, handles incoming and outgoing streams, and is part of the storage miners implementation. The port value is part of the Host interface."
+    "value": "The LibP2P Swarm manages groups of connections to peers, handles incoming and outgoing streams, and is part of the miners implementation. The port value is part of the Host interface."
   },
   "daemon": {
     "title": "Lotus Daemon",
@@ -133,7 +129,7 @@
   },
   "total-network-power": {
     "title": "Total Network Power",
-    "value": "A reference to all the Power Tables for every subchain, accounting for each Lotus Storage Miner on chain."
+    "value": "A reference to all the Power Tables for every subchain, accounting for each Lotus Miner on chain."
   },
   "chain-block-height": {
     "title": "Chain Block Height",
diff --git a/documentation/en/.library.json b/documentation/en/.library.json
index 65dbff359..3fab0df9b 100644
--- a/documentation/en/.library.json
+++ b/documentation/en/.library.json
@@ -32,6 +32,12 @@
           "github": "en/install-lotus-ubuntu.md",
           "value": null
         },
+        {
+          "title": "Fedora Installation",
+          "slug": "en+install-lotus-fedora",
+          "github": "en/install-lotus-fedora.md",
+          "value": null
+        },
         {
           "title": "MacOS Installation",
           "slug": "en+install-lotus-macos",
@@ -50,11 +56,37 @@
           "github": "en/join-testnet.md",
           "value": null
         },
+        {
+          "title": "Use Lotus with systemd",
+          "slug": "en+install-systemd-services",
+          "github": "en/install-systemd-services.md",
+          "value": null
+        },
         {
           "title": "Setup Troubleshooting",
           "slug": "en+setup-troubleshooting",
           "github": "en/setup-troubleshooting.md",
           "value": null
+        },
+        {
+          "title": "Environment Variables",
+          "slug": "en+env-vars",
+          "github": "en/environment-vars.md",
+          "value": null
+        }
+      ]
+    },
+    {
+      "title": "Architecture",
+      "slug": "en+arch",
+      "github": "en/architecture.md",
+      "value": null,
+      "posts": [
+        {
+          "title": "The Message Pool",
+          "slug": "en+mpool",
+          "github": "en/mpool.md",
+          "value": null
         }
       ]
     },
@@ -65,9 +97,9 @@
       "value": null,
       "posts": [
         {
-          "title": "Lotus Seal Worker",
-          "slug": "en+lotus-seal-worker",
-          "github": "en/mining-lotus-seal-worker.md",
+          "title": "Lotus Worker",
+          "slug": "en+lotus-worker",
+          "github": "en/mining-lotus-worker.md",
           "value": null
         },
         {
@@ -95,6 +127,18 @@
           "slug": "en+storing-data-troubleshooting",
           "github": "en/storing-data-troubleshooting.md",
           "value": null
+        },
+        {
+          "title": "Information for Miners",
+          "slug": "en+info-for-miners",
+          "github": "en/miner-deals.md",
+          "value": null
+        },
+        {
+          "title": "IPFS Integration",
+          "slug": "en+ipfs-client-integration",
+          "github": "en/storing-ipfs-integration.md",
+          "value": null
         }
       ]
     },
@@ -105,6 +149,20 @@
       "value": null,
       "posts": []
     },
+    {
+      "title": "Payment Channels",
+      "slug": "en+payment-channels",
+      "github": "en/payment-channels.md",
+      "value": null,
+      "posts": []
+    },
+    {
+      "title": "Command Line Interface",
+      "slug": "en+cli",
+      "github": "en/cli.md",
+      "value": null,
+      "posts": []
+    },
     {
       "title": "API",
       "slug": "en+api",
@@ -112,11 +170,17 @@
       "value": null,
       "posts": [
         {
-          "title": "API Scripting Support",
+          "title": "Remote API Support",
           "slug": "en+api-scripting-support",
           "github": "en/api-scripting-support.md",
           "value": null
         },
+        {
+          "title": "API Methods",
+          "slug": "en+api-methods",
+          "github": "en/api-methods.md",
+          "value": null
+        },
         {
           "title": "API Troubleshooting",
           "slug": "en+api-troubleshooting",
@@ -138,13 +202,6 @@
           "value": null,
           "posts": []
         },
-        {
-          "title": "Pond UI",
-          "slug": "en+dev-tools-pond-ui",
-          "github": "en/dev-tools-pond-ui.md",
-          "value": null,
-          "posts": []
-        },
         {
           "title": "Jaeger Tracing",
           "slug": "en+dev-tools-jaeger-tracing",
@@ -154,6 +211,13 @@
         }
       ]
     },
+    {
+      "title": "FAQs",
+      "slug": "en+faqs",
+      "github": "en/faqs.md",
+      "value": null,
+      "posts": []
+    },
     {
       "title": "Glossary",
       "slug": "en+glossary",
diff --git a/documentation/en/api-methods.md b/documentation/en/api-methods.md
new file mode 100644
index 000000000..ed082ccbf
--- /dev/null
+++ b/documentation/en/api-methods.md
@@ -0,0 +1,4608 @@
+# Groups
+* [](#)
+  * [Closing](#Closing)
+  * [Shutdown](#Shutdown)
+  * [Version](#Version)
+* [Auth](#Auth)
+  * [AuthNew](#AuthNew)
+  * [AuthVerify](#AuthVerify)
+* [Beacon](#Beacon)
+  * [BeaconGetEntry](#BeaconGetEntry)
+* [Chain](#Chain)
+  * [ChainDeleteObj](#ChainDeleteObj)
+  * [ChainExport](#ChainExport)
+  * [ChainGetBlock](#ChainGetBlock)
+  * [ChainGetBlockMessages](#ChainGetBlockMessages)
+  * [ChainGetGenesis](#ChainGetGenesis)
+  * [ChainGetMessage](#ChainGetMessage)
+  * [ChainGetNode](#ChainGetNode)
+  * [ChainGetParentMessages](#ChainGetParentMessages)
+  * [ChainGetParentReceipts](#ChainGetParentReceipts)
+  * [ChainGetPath](#ChainGetPath)
+  * [ChainGetRandomnessFromBeacon](#ChainGetRandomnessFromBeacon)
+  * [ChainGetRandomnessFromTickets](#ChainGetRandomnessFromTickets)
+  * [ChainGetTipSet](#ChainGetTipSet)
+  * [ChainGetTipSetByHeight](#ChainGetTipSetByHeight)
+  * [ChainHasObj](#ChainHasObj)
+  * [ChainHead](#ChainHead)
+  * [ChainNotify](#ChainNotify)
+  * [ChainReadObj](#ChainReadObj)
+  * [ChainSetHead](#ChainSetHead)
+  * [ChainStatObj](#ChainStatObj)
+  * [ChainTipSetWeight](#ChainTipSetWeight)
+* [Client](#Client)
+  * [ClientCalcCommP](#ClientCalcCommP)
+  * [ClientDataTransferUpdates](#ClientDataTransferUpdates)
+  * [ClientDealSize](#ClientDealSize)
+  * [ClientFindData](#ClientFindData)
+  * [ClientGenCar](#ClientGenCar)
+  * [ClientGetDealInfo](#ClientGetDealInfo)
+  * [ClientGetDealUpdates](#ClientGetDealUpdates)
+  * [ClientHasLocal](#ClientHasLocal)
+  * [ClientImport](#ClientImport)
+  * [ClientListDataTransfers](#ClientListDataTransfers)
+  * [ClientListDeals](#ClientListDeals)
+  * [ClientListImports](#ClientListImports)
+  * [ClientMinerQueryOffer](#ClientMinerQueryOffer)
+  * [ClientQueryAsk](#ClientQueryAsk)
+  * [ClientRemoveImport](#ClientRemoveImport)
+  * [ClientRetrieve](#ClientRetrieve)
+  * [ClientRetrieveTryRestartInsufficientFunds](#ClientRetrieveTryRestartInsufficientFunds)
+  * [ClientRetrieveWithEvents](#ClientRetrieveWithEvents)
+  * [ClientStartDeal](#ClientStartDeal)
+* [Gas](#Gas)
+  * [GasEstimateFeeCap](#GasEstimateFeeCap)
+  * [GasEstimateGasLimit](#GasEstimateGasLimit)
+  * [GasEstimateGasPremium](#GasEstimateGasPremium)
+  * [GasEstimateMessageGas](#GasEstimateMessageGas)
+* [I](#I)
+  * [ID](#ID)
+* [Log](#Log)
+  * [LogList](#LogList)
+  * [LogSetLevel](#LogSetLevel)
+* [Market](#Market)
+  * [MarketEnsureAvailable](#MarketEnsureAvailable)
+* [Miner](#Miner)
+  * [MinerCreateBlock](#MinerCreateBlock)
+  * [MinerGetBaseInfo](#MinerGetBaseInfo)
+* [Mpool](#Mpool)
+  * [MpoolClear](#MpoolClear)
+  * [MpoolGetConfig](#MpoolGetConfig)
+  * [MpoolGetNonce](#MpoolGetNonce)
+  * [MpoolPending](#MpoolPending)
+  * [MpoolPush](#MpoolPush)
+  * [MpoolPushMessage](#MpoolPushMessage)
+  * [MpoolSelect](#MpoolSelect)
+  * [MpoolSetConfig](#MpoolSetConfig)
+  * [MpoolSub](#MpoolSub)
+* [Msig](#Msig)
+  * [MsigAddApprove](#MsigAddApprove)
+  * [MsigAddCancel](#MsigAddCancel)
+  * [MsigAddPropose](#MsigAddPropose)
+  * [MsigApprove](#MsigApprove)
+  * [MsigCancel](#MsigCancel)
+  * [MsigCreate](#MsigCreate)
+  * [MsigGetAvailableBalance](#MsigGetAvailableBalance)
+  * [MsigGetVested](#MsigGetVested)
+  * [MsigPropose](#MsigPropose)
+  * [MsigSwapApprove](#MsigSwapApprove)
+  * [MsigSwapCancel](#MsigSwapCancel)
+  * [MsigSwapPropose](#MsigSwapPropose)
+* [Net](#Net)
+  * [NetAddrsListen](#NetAddrsListen)
+  * [NetAgentVersion](#NetAgentVersion)
+  * [NetAutoNatStatus](#NetAutoNatStatus)
+  * [NetBandwidthStats](#NetBandwidthStats)
+  * [NetBandwidthStatsByPeer](#NetBandwidthStatsByPeer)
+  * [NetBandwidthStatsByProtocol](#NetBandwidthStatsByProtocol)
+  * [NetConnect](#NetConnect)
+  * [NetConnectedness](#NetConnectedness)
+  * [NetDisconnect](#NetDisconnect)
+  * [NetFindPeer](#NetFindPeer)
+  * [NetPeers](#NetPeers)
+  * [NetPubsubScores](#NetPubsubScores)
+* [Paych](#Paych)
+  * [PaychAllocateLane](#PaychAllocateLane)
+  * [PaychAvailableFunds](#PaychAvailableFunds)
+  * [PaychAvailableFundsByFromTo](#PaychAvailableFundsByFromTo)
+  * [PaychCollect](#PaychCollect)
+  * [PaychGet](#PaychGet)
+  * [PaychGetWaitReady](#PaychGetWaitReady)
+  * [PaychList](#PaychList)
+  * [PaychNewPayment](#PaychNewPayment)
+  * [PaychSettle](#PaychSettle)
+  * [PaychStatus](#PaychStatus)
+  * [PaychVoucherAdd](#PaychVoucherAdd)
+  * [PaychVoucherCheckSpendable](#PaychVoucherCheckSpendable)
+  * [PaychVoucherCheckValid](#PaychVoucherCheckValid)
+  * [PaychVoucherCreate](#PaychVoucherCreate)
+  * [PaychVoucherList](#PaychVoucherList)
+  * [PaychVoucherSubmit](#PaychVoucherSubmit)
+* [State](#State)
+  * [StateAccountKey](#StateAccountKey)
+  * [StateAllMinerFaults](#StateAllMinerFaults)
+  * [StateCall](#StateCall)
+  * [StateChangedActors](#StateChangedActors)
+  * [StateCirculatingSupply](#StateCirculatingSupply)
+  * [StateCompute](#StateCompute)
+  * [StateDealProviderCollateralBounds](#StateDealProviderCollateralBounds)
+  * [StateGetActor](#StateGetActor)
+  * [StateGetReceipt](#StateGetReceipt)
+  * [StateListActors](#StateListActors)
+  * [StateListMessages](#StateListMessages)
+  * [StateListMiners](#StateListMiners)
+  * [StateLookupID](#StateLookupID)
+  * [StateMarketBalance](#StateMarketBalance)
+  * [StateMarketDeals](#StateMarketDeals)
+  * [StateMarketParticipants](#StateMarketParticipants)
+  * [StateMarketStorageDeal](#StateMarketStorageDeal)
+  * [StateMinerActiveSectors](#StateMinerActiveSectors)
+  * [StateMinerAvailableBalance](#StateMinerAvailableBalance)
+  * [StateMinerDeadlines](#StateMinerDeadlines)
+  * [StateMinerFaults](#StateMinerFaults)
+  * [StateMinerInfo](#StateMinerInfo)
+  * [StateMinerInitialPledgeCollateral](#StateMinerInitialPledgeCollateral)
+  * [StateMinerPartitions](#StateMinerPartitions)
+  * [StateMinerPower](#StateMinerPower)
+  * [StateMinerPreCommitDepositForPower](#StateMinerPreCommitDepositForPower)
+  * [StateMinerProvingDeadline](#StateMinerProvingDeadline)
+  * [StateMinerRecoveries](#StateMinerRecoveries)
+  * [StateMinerSectorCount](#StateMinerSectorCount)
+  * [StateMinerSectors](#StateMinerSectors)
+  * [StateMsgGasCost](#StateMsgGasCost)
+  * [StateNetworkName](#StateNetworkName)
+  * [StateNetworkVersion](#StateNetworkVersion)
+  * [StateReadState](#StateReadState)
+  * [StateReplay](#StateReplay)
+  * [StateSearchMsg](#StateSearchMsg)
+  * [StateSectorExpiration](#StateSectorExpiration)
+  * [StateSectorGetInfo](#StateSectorGetInfo)
+  * [StateSectorPartition](#StateSectorPartition)
+  * [StateSectorPreCommitInfo](#StateSectorPreCommitInfo)
+  * [StateVerifiedClientStatus](#StateVerifiedClientStatus)
+  * [StateWaitMsg](#StateWaitMsg)
+* [Sync](#Sync)
+  * [SyncCheckBad](#SyncCheckBad)
+  * [SyncCheckpoint](#SyncCheckpoint)
+  * [SyncIncomingBlocks](#SyncIncomingBlocks)
+  * [SyncMarkBad](#SyncMarkBad)
+  * [SyncState](#SyncState)
+  * [SyncSubmitBlock](#SyncSubmitBlock)
+  * [SyncUnmarkBad](#SyncUnmarkBad)
+* [Wallet](#Wallet)
+  * [WalletBalance](#WalletBalance)
+  * [WalletDefaultAddress](#WalletDefaultAddress)
+  * [WalletDelete](#WalletDelete)
+  * [WalletExport](#WalletExport)
+  * [WalletHas](#WalletHas)
+  * [WalletImport](#WalletImport)
+  * [WalletList](#WalletList)
+  * [WalletNew](#WalletNew)
+  * [WalletSetDefault](#WalletSetDefault)
+  * [WalletSign](#WalletSign)
+  * [WalletSignMessage](#WalletSignMessage)
+  * [WalletVerify](#WalletVerify)
+## 
+
+
+### Closing
+
+
+Perms: read
+
+Inputs: `null`
+
+Response: `{}`
+
+### Shutdown
+
+
+Perms: admin
+
+Inputs: `null`
+
+Response: `{}`
+
+### Version
+
+
+Perms: read
+
+Inputs: `null`
+
+Response:
+```json
+{
+  "Version": "string value",
+  "APIVersion": 4096,
+  "BlockDelay": 42
+}
+```
+
+## Auth
+
+
+### AuthNew
+
+
+Perms: admin
+
+Inputs:
+```json
+[
+  null
+]
+```
+
+Response: `"Ynl0ZSBhcnJheQ=="`
+
+### AuthVerify
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  "string value"
+]
+```
+
+Response: `null`
+
+## Beacon
+The Beacon method group contains methods for interacting with the random beacon (DRAND)
+
+
+### BeaconGetEntry
+BeaconGetEntry returns the beacon entry for the given filecoin epoch. If
+the entry has not yet been produced, the call will block until the entry
+becomes available
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  10101
+]
+```
+
+Response:
+```json
+{
+  "Round": 42,
+  "Data": "Ynl0ZSBhcnJheQ=="
+}
+```
+
+## Chain
+The Chain method group contains methods for interacting with the
+blockchain, but that do not require any form of state computation.
+
+
+### ChainDeleteObj
+ChainDeleteObj deletes node referenced by the given CID
+
+
+Perms: admin
+
+Inputs:
+```json
+[
+  {
+    "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+  }
+]
+```
+
+Response: `{}`
+
+### ChainExport
+ChainExport returns a stream of bytes with CAR dump of chain data.
+The exported chain data includes the header chain from the given tipset
+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.
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  10101,
+  true,
+  [
+    {
+      "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+    },
+    {
+      "/": "bafy2bzacebp3shtrn43k7g3unredz7fxn4gj533d3o43tqn2p2ipxxhrvchve"
+    }
+  ]
+]
+```
+
+Response: `"Ynl0ZSBhcnJheQ=="`
+
+### ChainGetBlock
+ChainGetBlock returns the block specified by the given CID.
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  {
+    "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+  }
+]
+```
+
+Response:
+```json
+{
+  "Miner": "t01234",
+  "Ticket": {
+    "VRFProof": "Ynl0ZSBhcnJheQ=="
+  },
+  "ElectionProof": {
+    "WinCount": 9,
+    "VRFProof": "Ynl0ZSBhcnJheQ=="
+  },
+  "BeaconEntries": null,
+  "WinPoStProof": null,
+  "Parents": null,
+  "ParentWeight": "0",
+  "Height": 10101,
+  "ParentStateRoot": {
+    "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+  },
+  "ParentMessageReceipts": {
+    "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+  },
+  "Messages": {
+    "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+  },
+  "BLSAggregate": {
+    "Type": 2,
+    "Data": "Ynl0ZSBhcnJheQ=="
+  },
+  "Timestamp": 42,
+  "BlockSig": {
+    "Type": 2,
+    "Data": "Ynl0ZSBhcnJheQ=="
+  },
+  "ForkSignaling": 42,
+  "ParentBaseFee": "0"
+}
+```
+
+### ChainGetBlockMessages
+ChainGetBlockMessages returns messages stored in the specified block.
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  {
+    "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+  }
+]
+```
+
+Response:
+```json
+{
+  "BlsMessages": null,
+  "SecpkMessages": null,
+  "Cids": null
+}
+```
+
+### ChainGetGenesis
+ChainGetGenesis returns the genesis tipset.
+
+
+Perms: read
+
+Inputs: `null`
+
+Response:
+```json
+{
+  "Cids": null,
+  "Blocks": null,
+  "Height": 0
+}
+```
+
+### ChainGetMessage
+ChainGetMessage reads a message referenced by the specified CID from the
+chain blockstore.
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  {
+    "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+  }
+]
+```
+
+Response:
+```json
+{
+  "Version": 42,
+  "To": "t01234",
+  "From": "t01234",
+  "Nonce": 42,
+  "Value": "0",
+  "GasLimit": 9,
+  "GasFeeCap": "0",
+  "GasPremium": "0",
+  "Method": 1,
+  "Params": "Ynl0ZSBhcnJheQ=="
+}
+```
+
+### ChainGetNode
+There are not yet any comments for this method.
+
+Perms: read
+
+Inputs:
+```json
+[
+  "string value"
+]
+```
+
+Response:
+```json
+{
+  "Cid": {
+    "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+  },
+  "Obj": {}
+}
+```
+
+### ChainGetParentMessages
+ChainGetParentMessages returns messages stored in parent tipset of the
+specified block.
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  {
+    "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+  }
+]
+```
+
+Response: `null`
+
+### ChainGetParentReceipts
+ChainGetParentReceipts returns receipts for messages in parent tipset of
+the specified block.
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  {
+    "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+  }
+]
+```
+
+Response: `null`
+
+### ChainGetPath
+ChainGetPath returns a set of revert/apply operations needed to get from
+one tipset to another, for example:
+```
+       to
+        ^
+from   tAA
+  ^     ^
+tBA    tAB
+ ^---*--^
+     ^
+    tRR
+```
+Would return `[revert(tBA), apply(tAB), apply(tAA)]`
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  [
+    {
+      "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+    },
+    {
+      "/": "bafy2bzacebp3shtrn43k7g3unredz7fxn4gj533d3o43tqn2p2ipxxhrvchve"
+    }
+  ],
+  [
+    {
+      "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+    },
+    {
+      "/": "bafy2bzacebp3shtrn43k7g3unredz7fxn4gj533d3o43tqn2p2ipxxhrvchve"
+    }
+  ]
+]
+```
+
+Response: `null`
+
+### ChainGetRandomnessFromBeacon
+ChainGetRandomnessFromBeacon is used to sample the beacon for randomness.
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  [
+    {
+      "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+    },
+    {
+      "/": "bafy2bzacebp3shtrn43k7g3unredz7fxn4gj533d3o43tqn2p2ipxxhrvchve"
+    }
+  ],
+  2,
+  10101,
+  "Ynl0ZSBhcnJheQ=="
+]
+```
+
+Response: `null`
+
+### ChainGetRandomnessFromTickets
+ChainGetRandomnessFromTickets is used to sample the chain for randomness.
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  [
+    {
+      "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+    },
+    {
+      "/": "bafy2bzacebp3shtrn43k7g3unredz7fxn4gj533d3o43tqn2p2ipxxhrvchve"
+    }
+  ],
+  2,
+  10101,
+  "Ynl0ZSBhcnJheQ=="
+]
+```
+
+Response: `null`
+
+### ChainGetTipSet
+ChainGetTipSet returns the tipset specified by the given TipSetKey.
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  [
+    {
+      "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+    },
+    {
+      "/": "bafy2bzacebp3shtrn43k7g3unredz7fxn4gj533d3o43tqn2p2ipxxhrvchve"
+    }
+  ]
+]
+```
+
+Response:
+```json
+{
+  "Cids": null,
+  "Blocks": null,
+  "Height": 0
+}
+```
+
+### ChainGetTipSetByHeight
+ChainGetTipSetByHeight looks back for a tipset at the specified epoch.
+If there are no blocks at the specified epoch, a tipset at an earlier epoch
+will be returned.
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  10101,
+  [
+    {
+      "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+    },
+    {
+      "/": "bafy2bzacebp3shtrn43k7g3unredz7fxn4gj533d3o43tqn2p2ipxxhrvchve"
+    }
+  ]
+]
+```
+
+Response:
+```json
+{
+  "Cids": null,
+  "Blocks": null,
+  "Height": 0
+}
+```
+
+### ChainHasObj
+ChainHasObj checks if a given CID exists in the chain blockstore.
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  {
+    "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+  }
+]
+```
+
+Response: `true`
+
+### ChainHead
+ChainHead returns the current head of the chain.
+
+
+Perms: read
+
+Inputs: `null`
+
+Response:
+```json
+{
+  "Cids": null,
+  "Blocks": null,
+  "Height": 0
+}
+```
+
+### ChainNotify
+ChainNotify returns channel with chain head updates.
+First message is guaranteed to be of len == 1, and type == 'current'.
+
+
+Perms: read
+
+Inputs: `null`
+
+Response: `null`
+
+### ChainReadObj
+ChainReadObj reads ipld nodes referenced by the specified CID from chain
+blockstore and returns raw bytes.
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  {
+    "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+  }
+]
+```
+
+Response: `"Ynl0ZSBhcnJheQ=="`
+
+### ChainSetHead
+ChainSetHead forcefully sets current chain head. Use with caution.
+
+
+Perms: admin
+
+Inputs:
+```json
+[
+  [
+    {
+      "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+    },
+    {
+      "/": "bafy2bzacebp3shtrn43k7g3unredz7fxn4gj533d3o43tqn2p2ipxxhrvchve"
+    }
+  ]
+]
+```
+
+Response: `{}`
+
+### ChainStatObj
+ChainStatObj returns statistics about the graph referenced by 'obj'.
+If 'base' is also specified, then the returned stat will be a diff
+between the two objects.
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  {
+    "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+  },
+  {
+    "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+  }
+]
+```
+
+Response:
+```json
+{
+  "Size": 42,
+  "Links": 42
+}
+```
+
+### ChainTipSetWeight
+ChainTipSetWeight computes weight for the specified tipset.
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  [
+    {
+      "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+    },
+    {
+      "/": "bafy2bzacebp3shtrn43k7g3unredz7fxn4gj533d3o43tqn2p2ipxxhrvchve"
+    }
+  ]
+]
+```
+
+Response: `"0"`
+
+## Client
+The Client methods all have to do with interacting with the storage and
+retrieval markets as a client
+
+
+### ClientCalcCommP
+ClientCalcCommP calculates the CommP for a specified file
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  "string value"
+]
+```
+
+Response:
+```json
+{
+  "Root": {
+    "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+  },
+  "Size": 1024
+}
+```
+
+### ClientDataTransferUpdates
+There are not yet any comments for this method.
+
+Perms: write
+
+Inputs: `null`
+
+Response:
+```json
+{
+  "TransferID": 3,
+  "Status": 1,
+  "BaseCID": {
+    "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+  },
+  "IsInitiator": true,
+  "IsSender": true,
+  "Voucher": "string value",
+  "Message": "string value",
+  "OtherPeer": "12D3KooWGzxzKZYveHXtpG6AsrUJBcWxHBFS2HsEoGTxrMLvKXtf",
+  "Transferred": 42
+}
+```
+
+### ClientDealSize
+ClientDealSize calculates real deal data size
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  {
+    "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+  }
+]
+```
+
+Response:
+```json
+{
+  "PayloadSize": 9,
+  "PieceSize": 1032
+}
+```
+
+### ClientFindData
+ClientFindData identifies peers that have a certain file, and returns QueryOffers (one per peer).
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  {
+    "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+  },
+  null
+]
+```
+
+Response: `null`
+
+### ClientGenCar
+ClientGenCar generates a CAR file for the specified file.
+
+
+Perms: write
+
+Inputs:
+```json
+[
+  {
+    "Path": "string value",
+    "IsCAR": true
+  },
+  "string value"
+]
+```
+
+Response: `{}`
+
+### ClientGetDealInfo
+ClientGetDealInfo returns the latest information about a given deal.
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  {
+    "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+  }
+]
+```
+
+Response:
+```json
+{
+  "ProposalCid": {
+    "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+  },
+  "State": 42,
+  "Message": "string value",
+  "Provider": "t01234",
+  "DataRef": {
+    "TransferType": "string value",
+    "Root": {
+      "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+    },
+    "PieceCid": null,
+    "PieceSize": 1024
+  },
+  "PieceCID": {
+    "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+  },
+  "Size": 42,
+  "PricePerEpoch": "0",
+  "Duration": 42,
+  "DealID": 5432,
+  "CreationTime": "0001-01-01T00:00:00Z"
+}
+```
+
+### ClientGetDealUpdates
+ClientGetDealUpdates returns the status of updated deals
+
+
+Perms: read
+
+Inputs: `null`
+
+Response:
+```json
+{
+  "ProposalCid": {
+    "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+  },
+  "State": 42,
+  "Message": "string value",
+  "Provider": "t01234",
+  "DataRef": {
+    "TransferType": "string value",
+    "Root": {
+      "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+    },
+    "PieceCid": null,
+    "PieceSize": 1024
+  },
+  "PieceCID": {
+    "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+  },
+  "Size": 42,
+  "PricePerEpoch": "0",
+  "Duration": 42,
+  "DealID": 5432,
+  "CreationTime": "0001-01-01T00:00:00Z"
+}
+```
+
+### ClientHasLocal
+ClientHasLocal indicates whether a certain CID is locally stored.
+
+
+Perms: write
+
+Inputs:
+```json
+[
+  {
+    "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+  }
+]
+```
+
+Response: `true`
+
+### ClientImport
+ClientImport imports file under the specified path into filestore.
+
+
+Perms: admin
+
+Inputs:
+```json
+[
+  {
+    "Path": "string value",
+    "IsCAR": true
+  }
+]
+```
+
+Response:
+```json
+{
+  "Root": {
+    "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+  },
+  "ImportID": 50
+}
+```
+
+### ClientListDataTransfers
+ClientListTransfers returns the status of all ongoing transfers of data
+
+
+Perms: write
+
+Inputs: `null`
+
+Response: `null`
+
+### ClientListDeals
+ClientListDeals returns information about the deals made by the local client.
+
+
+Perms: write
+
+Inputs: `null`
+
+Response: `null`
+
+### ClientListImports
+ClientListImports lists imported files and their root CIDs
+
+
+Perms: write
+
+Inputs: `null`
+
+Response: `null`
+
+### ClientMinerQueryOffer
+ClientMinerQueryOffer returns a QueryOffer for the specific miner and file.
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  "t01234",
+  {
+    "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+  },
+  null
+]
+```
+
+Response:
+```json
+{
+  "Err": "string value",
+  "Root": {
+    "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+  },
+  "Piece": null,
+  "Size": 42,
+  "MinPrice": "0",
+  "UnsealPrice": "0",
+  "PaymentInterval": 42,
+  "PaymentIntervalIncrease": 42,
+  "Miner": "t01234",
+  "MinerPeer": {
+    "Address": "t01234",
+    "ID": "12D3KooWGzxzKZYveHXtpG6AsrUJBcWxHBFS2HsEoGTxrMLvKXtf",
+    "PieceCID": null
+  }
+}
+```
+
+### ClientQueryAsk
+ClientQueryAsk returns a signed StorageAsk from the specified miner.
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  "12D3KooWGzxzKZYveHXtpG6AsrUJBcWxHBFS2HsEoGTxrMLvKXtf",
+  "t01234"
+]
+```
+
+Response:
+```json
+{
+  "Ask": {
+    "Price": "0",
+    "VerifiedPrice": "0",
+    "MinPieceSize": 1032,
+    "MaxPieceSize": 1032,
+    "Miner": "t01234",
+    "Timestamp": 10101,
+    "Expiry": 10101,
+    "SeqNo": 42
+  },
+  "Signature": {
+    "Type": 2,
+    "Data": "Ynl0ZSBhcnJheQ=="
+  }
+}
+```
+
+### ClientRemoveImport
+ClientRemoveImport removes file import
+
+
+Perms: admin
+
+Inputs:
+```json
+[
+  50
+]
+```
+
+Response: `{}`
+
+### ClientRetrieve
+ClientRetrieve initiates the retrieval of a file, as specified in the order.
+
+
+Perms: admin
+
+Inputs:
+```json
+[
+  {
+    "Root": {
+      "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+    },
+    "Piece": null,
+    "Size": 42,
+    "Total": "0",
+    "UnsealPrice": "0",
+    "PaymentInterval": 42,
+    "PaymentIntervalIncrease": 42,
+    "Client": "t01234",
+    "Miner": "t01234",
+    "MinerPeer": {
+      "Address": "t01234",
+      "ID": "12D3KooWGzxzKZYveHXtpG6AsrUJBcWxHBFS2HsEoGTxrMLvKXtf",
+      "PieceCID": null
+    }
+  },
+  {
+    "Path": "string value",
+    "IsCAR": true
+  }
+]
+```
+
+Response: `{}`
+
+### ClientRetrieveTryRestartInsufficientFunds
+ClientRetrieveTryRestartInsufficientFunds attempts to restart stalled retrievals on a given payment channel
+which are stuck due to insufficient funds
+
+
+Perms: write
+
+Inputs:
+```json
+[
+  "t01234"
+]
+```
+
+Response: `{}`
+
+### ClientRetrieveWithEvents
+ClientRetrieveWithEvents initiates the retrieval of a file, as specified in the order, and provides a channel
+of status updates.
+
+
+Perms: admin
+
+Inputs:
+```json
+[
+  {
+    "Root": {
+      "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+    },
+    "Piece": null,
+    "Size": 42,
+    "Total": "0",
+    "UnsealPrice": "0",
+    "PaymentInterval": 42,
+    "PaymentIntervalIncrease": 42,
+    "Client": "t01234",
+    "Miner": "t01234",
+    "MinerPeer": {
+      "Address": "t01234",
+      "ID": "12D3KooWGzxzKZYveHXtpG6AsrUJBcWxHBFS2HsEoGTxrMLvKXtf",
+      "PieceCID": null
+    }
+  },
+  {
+    "Path": "string value",
+    "IsCAR": true
+  }
+]
+```
+
+Response:
+```json
+{
+  "Event": 5,
+  "Status": 0,
+  "BytesReceived": 42,
+  "FundsSpent": "0",
+  "Err": "string value"
+}
+```
+
+### ClientStartDeal
+ClientStartDeal proposes a deal with a miner.
+
+
+Perms: admin
+
+Inputs:
+```json
+[
+  {
+    "Data": {
+      "TransferType": "string value",
+      "Root": {
+        "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+      },
+      "PieceCid": null,
+      "PieceSize": 1024
+    },
+    "Wallet": "t01234",
+    "Miner": "t01234",
+    "EpochPrice": "0",
+    "MinBlocksDuration": 42,
+    "ProviderCollateral": "0",
+    "DealStartEpoch": 10101,
+    "FastRetrieval": true,
+    "VerifiedDeal": true
+  }
+]
+```
+
+Response: `null`
+
+## Gas
+
+
+### GasEstimateFeeCap
+GasEstimateFeeCap estimates gas fee cap
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  {
+    "Version": 42,
+    "To": "t01234",
+    "From": "t01234",
+    "Nonce": 42,
+    "Value": "0",
+    "GasLimit": 9,
+    "GasFeeCap": "0",
+    "GasPremium": "0",
+    "Method": 1,
+    "Params": "Ynl0ZSBhcnJheQ=="
+  },
+  9,
+  [
+    {
+      "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+    },
+    {
+      "/": "bafy2bzacebp3shtrn43k7g3unredz7fxn4gj533d3o43tqn2p2ipxxhrvchve"
+    }
+  ]
+]
+```
+
+Response: `"0"`
+
+### GasEstimateGasLimit
+GasEstimateGasLimit estimates gas used by the message and returns it.
+It fails if message fails to execute.
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  {
+    "Version": 42,
+    "To": "t01234",
+    "From": "t01234",
+    "Nonce": 42,
+    "Value": "0",
+    "GasLimit": 9,
+    "GasFeeCap": "0",
+    "GasPremium": "0",
+    "Method": 1,
+    "Params": "Ynl0ZSBhcnJheQ=="
+  },
+  [
+    {
+      "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+    },
+    {
+      "/": "bafy2bzacebp3shtrn43k7g3unredz7fxn4gj533d3o43tqn2p2ipxxhrvchve"
+    }
+  ]
+]
+```
+
+Response: `9`
+
+### GasEstimateGasPremium
+GasEstimateGasPremium estimates what gas price should be used for a
+message to have high likelihood of inclusion in `nblocksincl` epochs.
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  42,
+  "t01234",
+  9,
+  [
+    {
+      "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+    },
+    {
+      "/": "bafy2bzacebp3shtrn43k7g3unredz7fxn4gj533d3o43tqn2p2ipxxhrvchve"
+    }
+  ]
+]
+```
+
+Response: `"0"`
+
+### GasEstimateMessageGas
+GasEstimateMessageGas estimates gas values for unset message gas fields
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  {
+    "Version": 42,
+    "To": "t01234",
+    "From": "t01234",
+    "Nonce": 42,
+    "Value": "0",
+    "GasLimit": 9,
+    "GasFeeCap": "0",
+    "GasPremium": "0",
+    "Method": 1,
+    "Params": "Ynl0ZSBhcnJheQ=="
+  },
+  {
+    "MaxFee": "0"
+  },
+  [
+    {
+      "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+    },
+    {
+      "/": "bafy2bzacebp3shtrn43k7g3unredz7fxn4gj533d3o43tqn2p2ipxxhrvchve"
+    }
+  ]
+]
+```
+
+Response:
+```json
+{
+  "Version": 42,
+  "To": "t01234",
+  "From": "t01234",
+  "Nonce": 42,
+  "Value": "0",
+  "GasLimit": 9,
+  "GasFeeCap": "0",
+  "GasPremium": "0",
+  "Method": 1,
+  "Params": "Ynl0ZSBhcnJheQ=="
+}
+```
+
+## I
+
+
+### ID
+
+
+Perms: read
+
+Inputs: `null`
+
+Response: `"12D3KooWGzxzKZYveHXtpG6AsrUJBcWxHBFS2HsEoGTxrMLvKXtf"`
+
+## Log
+
+
+### LogList
+
+
+Perms: write
+
+Inputs: `null`
+
+Response: `null`
+
+### LogSetLevel
+
+
+Perms: write
+
+Inputs:
+```json
+[
+  "string value",
+  "string value"
+]
+```
+
+Response: `{}`
+
+## Market
+
+
+### MarketEnsureAvailable
+MarketFreeBalance
+
+
+Perms: sign
+
+Inputs:
+```json
+[
+  "t01234",
+  "t01234",
+  "0"
+]
+```
+
+Response:
+```json
+{
+  "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+}
+```
+
+## Miner
+
+
+### MinerCreateBlock
+There are not yet any comments for this method.
+
+Perms: write
+
+Inputs:
+```json
+[
+  {
+    "Miner": "t01234",
+    "Parents": [
+      {
+        "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+      },
+      {
+        "/": "bafy2bzacebp3shtrn43k7g3unredz7fxn4gj533d3o43tqn2p2ipxxhrvchve"
+      }
+    ],
+    "Ticket": {
+      "VRFProof": "Ynl0ZSBhcnJheQ=="
+    },
+    "Eproof": {
+      "WinCount": 9,
+      "VRFProof": "Ynl0ZSBhcnJheQ=="
+    },
+    "BeaconValues": null,
+    "Messages": null,
+    "Epoch": 10101,
+    "Timestamp": 42,
+    "WinningPoStProof": null
+  }
+]
+```
+
+Response:
+```json
+{
+  "Header": {
+    "Miner": "t01234",
+    "Ticket": {
+      "VRFProof": "Ynl0ZSBhcnJheQ=="
+    },
+    "ElectionProof": {
+      "WinCount": 9,
+      "VRFProof": "Ynl0ZSBhcnJheQ=="
+    },
+    "BeaconEntries": null,
+    "WinPoStProof": null,
+    "Parents": null,
+    "ParentWeight": "0",
+    "Height": 10101,
+    "ParentStateRoot": {
+      "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+    },
+    "ParentMessageReceipts": {
+      "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+    },
+    "Messages": {
+      "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+    },
+    "BLSAggregate": {
+      "Type": 2,
+      "Data": "Ynl0ZSBhcnJheQ=="
+    },
+    "Timestamp": 42,
+    "BlockSig": {
+      "Type": 2,
+      "Data": "Ynl0ZSBhcnJheQ=="
+    },
+    "ForkSignaling": 42,
+    "ParentBaseFee": "0"
+  },
+  "BlsMessages": null,
+  "SecpkMessages": null
+}
+```
+
+### MinerGetBaseInfo
+There are not yet any comments for this method.
+
+Perms: read
+
+Inputs:
+```json
+[
+  "t01234",
+  10101,
+  [
+    {
+      "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+    },
+    {
+      "/": "bafy2bzacebp3shtrn43k7g3unredz7fxn4gj533d3o43tqn2p2ipxxhrvchve"
+    }
+  ]
+]
+```
+
+Response:
+```json
+{
+  "MinerPower": "0",
+  "NetworkPower": "0",
+  "Sectors": null,
+  "WorkerKey": "t01234",
+  "SectorSize": 34359738368,
+  "PrevBeaconEntry": {
+    "Round": 42,
+    "Data": "Ynl0ZSBhcnJheQ=="
+  },
+  "BeaconEntries": null,
+  "HasMinPower": true
+}
+```
+
+## Mpool
+The Mpool methods are for interacting with the message pool. The message pool
+manages all incoming and outgoing 'messages' going over the network.
+
+
+### MpoolClear
+MpoolClear clears pending messages from the mpool
+
+
+Perms: write
+
+Inputs:
+```json
+[
+  true
+]
+```
+
+Response: `{}`
+
+### MpoolGetConfig
+MpoolGetConfig returns (a copy of) the current mpool config
+
+
+Perms: read
+
+Inputs: `null`
+
+Response:
+```json
+{
+  "PriorityAddrs": null,
+  "SizeLimitHigh": 123,
+  "SizeLimitLow": 123,
+  "ReplaceByFeeRatio": 12.3,
+  "PruneCooldown": 60000000000,
+  "GasLimitOverestimation": 12.3
+}
+```
+
+### MpoolGetNonce
+MpoolGetNonce gets next nonce for the specified sender.
+Note that this method may not be atomic. Use MpoolPushMessage instead.
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  "t01234"
+]
+```
+
+Response: `42`
+
+### MpoolPending
+MpoolPending returns pending mempool messages.
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  [
+    {
+      "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+    },
+    {
+      "/": "bafy2bzacebp3shtrn43k7g3unredz7fxn4gj533d3o43tqn2p2ipxxhrvchve"
+    }
+  ]
+]
+```
+
+Response: `null`
+
+### MpoolPush
+MpoolPush pushes a signed message to mempool.
+
+
+Perms: write
+
+Inputs:
+```json
+[
+  {
+    "Message": {
+      "Version": 42,
+      "To": "t01234",
+      "From": "t01234",
+      "Nonce": 42,
+      "Value": "0",
+      "GasLimit": 9,
+      "GasFeeCap": "0",
+      "GasPremium": "0",
+      "Method": 1,
+      "Params": "Ynl0ZSBhcnJheQ=="
+    },
+    "Signature": {
+      "Type": 2,
+      "Data": "Ynl0ZSBhcnJheQ=="
+    }
+  }
+]
+```
+
+Response:
+```json
+{
+  "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+}
+```
+
+### MpoolPushMessage
+MpoolPushMessage atomically assigns a nonce, signs, and pushes a message
+to mempool.
+maxFee is only used when GasFeeCap/GasPremium fields aren't specified
+
+When maxFee is set to 0, MpoolPushMessage will guess appropriate fee
+based on current chain conditions
+
+
+Perms: sign
+
+Inputs:
+```json
+[
+  {
+    "Version": 42,
+    "To": "t01234",
+    "From": "t01234",
+    "Nonce": 42,
+    "Value": "0",
+    "GasLimit": 9,
+    "GasFeeCap": "0",
+    "GasPremium": "0",
+    "Method": 1,
+    "Params": "Ynl0ZSBhcnJheQ=="
+  },
+  {
+    "MaxFee": "0"
+  }
+]
+```
+
+Response:
+```json
+{
+  "Message": {
+    "Version": 42,
+    "To": "t01234",
+    "From": "t01234",
+    "Nonce": 42,
+    "Value": "0",
+    "GasLimit": 9,
+    "GasFeeCap": "0",
+    "GasPremium": "0",
+    "Method": 1,
+    "Params": "Ynl0ZSBhcnJheQ=="
+  },
+  "Signature": {
+    "Type": 2,
+    "Data": "Ynl0ZSBhcnJheQ=="
+  }
+}
+```
+
+### MpoolSelect
+MpoolSelect returns a list of pending messages for inclusion in the next block
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  [
+    {
+      "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+    },
+    {
+      "/": "bafy2bzacebp3shtrn43k7g3unredz7fxn4gj533d3o43tqn2p2ipxxhrvchve"
+    }
+  ],
+  12.3
+]
+```
+
+Response: `null`
+
+### MpoolSetConfig
+MpoolSetConfig sets the mpool config to (a copy of) the supplied config
+
+
+Perms: write
+
+Inputs:
+```json
+[
+  {
+    "PriorityAddrs": null,
+    "SizeLimitHigh": 123,
+    "SizeLimitLow": 123,
+    "ReplaceByFeeRatio": 12.3,
+    "PruneCooldown": 60000000000,
+    "GasLimitOverestimation": 12.3
+  }
+]
+```
+
+Response: `{}`
+
+### MpoolSub
+There are not yet any comments for this method.
+
+Perms: read
+
+Inputs: `null`
+
+Response:
+```json
+{
+  "Type": 0,
+  "Message": {
+    "Message": {
+      "Version": 42,
+      "To": "t01234",
+      "From": "t01234",
+      "Nonce": 42,
+      "Value": "0",
+      "GasLimit": 9,
+      "GasFeeCap": "0",
+      "GasPremium": "0",
+      "Method": 1,
+      "Params": "Ynl0ZSBhcnJheQ=="
+    },
+    "Signature": {
+      "Type": 2,
+      "Data": "Ynl0ZSBhcnJheQ=="
+    }
+  }
+}
+```
+
+## Msig
+The Msig methods are used to interact with multisig wallets on the
+filecoin network
+
+
+### MsigAddApprove
+MsigAddApprove approves a previously proposed AddSigner message
+It takes the following params: <multisig address>, <sender address of the approve msg>, <proposed message ID>,
+<proposer address>, <new signer>, <whether the number of required signers should be increased>
+
+
+Perms: sign
+
+Inputs:
+```json
+[
+  "t01234",
+  "t01234",
+  42,
+  "t01234",
+  "t01234",
+  true
+]
+```
+
+Response:
+```json
+{
+  "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+}
+```
+
+### MsigAddCancel
+MsigAddCancel cancels a previously proposed AddSigner message
+It takes the following params: <multisig address>, <sender address of the cancel msg>, <proposed message ID>,
+<new signer>, <whether the number of required signers should be increased>
+
+
+Perms: sign
+
+Inputs:
+```json
+[
+  "t01234",
+  "t01234",
+  42,
+  "t01234",
+  true
+]
+```
+
+Response:
+```json
+{
+  "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+}
+```
+
+### MsigAddPropose
+MsigAddPropose proposes adding a signer in the multisig
+It takes the following params: <multisig address>, <sender address of the propose msg>,
+<new signer>, <whether the number of required signers should be increased>
+
+
+Perms: sign
+
+Inputs:
+```json
+[
+  "t01234",
+  "t01234",
+  "t01234",
+  true
+]
+```
+
+Response:
+```json
+{
+  "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+}
+```
+
+### MsigApprove
+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>
+
+
+Perms: sign
+
+Inputs:
+```json
+[
+  "t01234",
+  42,
+  "t01234",
+  "t01234",
+  "0",
+  "t01234",
+  42,
+  "Ynl0ZSBhcnJheQ=="
+]
+```
+
+Response:
+```json
+{
+  "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+}
+```
+
+### MsigCancel
+MsigCancel cancels a previously-proposed multisig message
+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>
+
+
+Perms: sign
+
+Inputs:
+```json
+[
+  "t01234",
+  42,
+  "t01234",
+  "0",
+  "t01234",
+  42,
+  "Ynl0ZSBhcnJheQ=="
+]
+```
+
+Response:
+```json
+{
+  "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+}
+```
+
+### MsigCreate
+MsigCreate creates a multisig wallet
+It takes the following params: <required number of senders>, <approving addresses>, <unlock duration>
+<initial balance>, <sender address of the create msg>, <gas price>
+
+
+Perms: sign
+
+Inputs:
+```json
+[
+  42,
+  null,
+  10101,
+  "0",
+  "t01234",
+  "0"
+]
+```
+
+Response:
+```json
+{
+  "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+}
+```
+
+### MsigGetAvailableBalance
+MsigGetAvailableBalance returns the portion of a multisig's balance that can be withdrawn or spent
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  "t01234",
+  [
+    {
+      "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+    },
+    {
+      "/": "bafy2bzacebp3shtrn43k7g3unredz7fxn4gj533d3o43tqn2p2ipxxhrvchve"
+    }
+  ]
+]
+```
+
+Response: `"0"`
+
+### MsigGetVested
+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>
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  "t01234",
+  [
+    {
+      "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+    },
+    {
+      "/": "bafy2bzacebp3shtrn43k7g3unredz7fxn4gj533d3o43tqn2p2ipxxhrvchve"
+    }
+  ],
+  [
+    {
+      "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+    },
+    {
+      "/": "bafy2bzacebp3shtrn43k7g3unredz7fxn4gj533d3o43tqn2p2ipxxhrvchve"
+    }
+  ]
+]
+```
+
+Response: `"0"`
+
+### MsigPropose
+MsigPropose proposes a multisig message
+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>
+
+
+Perms: sign
+
+Inputs:
+```json
+[
+  "t01234",
+  "t01234",
+  "0",
+  "t01234",
+  42,
+  "Ynl0ZSBhcnJheQ=="
+]
+```
+
+Response:
+```json
+{
+  "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+}
+```
+
+### MsigSwapApprove
+MsigSwapApprove approves a previously proposed SwapSigner
+It takes the following params: <multisig address>, <sender address of the approve msg>, <proposed message ID>,
+<proposer address>, <old signer>, <new signer>
+
+
+Perms: sign
+
+Inputs:
+```json
+[
+  "t01234",
+  "t01234",
+  42,
+  "t01234",
+  "t01234",
+  "t01234"
+]
+```
+
+Response:
+```json
+{
+  "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+}
+```
+
+### MsigSwapCancel
+MsigSwapCancel cancels a previously proposed SwapSigner message
+It takes the following params: <multisig address>, <sender address of the cancel msg>, <proposed message ID>,
+<old signer>, <new signer>
+
+
+Perms: sign
+
+Inputs:
+```json
+[
+  "t01234",
+  "t01234",
+  42,
+  "t01234",
+  "t01234"
+]
+```
+
+Response:
+```json
+{
+  "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+}
+```
+
+### MsigSwapPropose
+MsigSwapPropose proposes swapping 2 signers in the multisig
+It takes the following params: <multisig address>, <sender address of the propose msg>,
+<old signer>, <new signer>
+
+
+Perms: sign
+
+Inputs:
+```json
+[
+  "t01234",
+  "t01234",
+  "t01234",
+  "t01234"
+]
+```
+
+Response:
+```json
+{
+  "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+}
+```
+
+## Net
+
+
+### NetAddrsListen
+
+
+Perms: read
+
+Inputs: `null`
+
+Response:
+```json
+{
+  "Addrs": null,
+  "ID": "12D3KooWGzxzKZYveHXtpG6AsrUJBcWxHBFS2HsEoGTxrMLvKXtf"
+}
+```
+
+### NetAgentVersion
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  "12D3KooWGzxzKZYveHXtpG6AsrUJBcWxHBFS2HsEoGTxrMLvKXtf"
+]
+```
+
+Response: `"string value"`
+
+### NetAutoNatStatus
+
+
+Perms: read
+
+Inputs: `null`
+
+Response:
+```json
+{
+  "Reachability": 1,
+  "PublicAddr": "string value"
+}
+```
+
+### NetBandwidthStats
+
+
+Perms: read
+
+Inputs: `null`
+
+Response:
+```json
+{
+  "TotalIn": 9,
+  "TotalOut": 9,
+  "RateIn": 12.3,
+  "RateOut": 12.3
+}
+```
+
+### NetBandwidthStatsByPeer
+
+
+Perms: read
+
+Inputs: `null`
+
+Response:
+```json
+{
+  "12D3KooWSXmXLJmBR1M7i9RW9GQPNUhZSzXKzxDHWtAgNuJAbyEJ": {
+    "TotalIn": 174000,
+    "TotalOut": 12500,
+    "RateIn": 100,
+    "RateOut": 50
+  }
+}
+```
+
+### NetBandwidthStatsByProtocol
+
+
+Perms: read
+
+Inputs: `null`
+
+Response:
+```json
+{
+  "/fil/hello/1.0.0": {
+    "TotalIn": 174000,
+    "TotalOut": 12500,
+    "RateIn": 100,
+    "RateOut": 50
+  }
+}
+```
+
+### NetConnect
+
+
+Perms: write
+
+Inputs:
+```json
+[
+  {
+    "Addrs": null,
+    "ID": "12D3KooWGzxzKZYveHXtpG6AsrUJBcWxHBFS2HsEoGTxrMLvKXtf"
+  }
+]
+```
+
+Response: `{}`
+
+### NetConnectedness
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  "12D3KooWGzxzKZYveHXtpG6AsrUJBcWxHBFS2HsEoGTxrMLvKXtf"
+]
+```
+
+Response: `1`
+
+### NetDisconnect
+
+
+Perms: write
+
+Inputs:
+```json
+[
+  "12D3KooWGzxzKZYveHXtpG6AsrUJBcWxHBFS2HsEoGTxrMLvKXtf"
+]
+```
+
+Response: `{}`
+
+### NetFindPeer
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  "12D3KooWGzxzKZYveHXtpG6AsrUJBcWxHBFS2HsEoGTxrMLvKXtf"
+]
+```
+
+Response:
+```json
+{
+  "Addrs": null,
+  "ID": "12D3KooWGzxzKZYveHXtpG6AsrUJBcWxHBFS2HsEoGTxrMLvKXtf"
+}
+```
+
+### NetPeers
+
+
+Perms: read
+
+Inputs: `null`
+
+Response: `null`
+
+### NetPubsubScores
+
+
+Perms: read
+
+Inputs: `null`
+
+Response: `null`
+
+## Paych
+The Paych methods are for interacting with and managing payment channels
+
+
+### PaychAllocateLane
+There are not yet any comments for this method.
+
+Perms: sign
+
+Inputs:
+```json
+[
+  "t01234"
+]
+```
+
+Response: `42`
+
+### PaychAvailableFunds
+There are not yet any comments for this method.
+
+Perms: sign
+
+Inputs:
+```json
+[
+  "t01234"
+]
+```
+
+Response:
+```json
+{
+  "Channel": "\u003cempty\u003e",
+  "From": "t01234",
+  "To": "t01234",
+  "ConfirmedAmt": "0",
+  "PendingAmt": "0",
+  "PendingWaitSentinel": null,
+  "QueuedAmt": "0",
+  "VoucherReedeemedAmt": "0"
+}
+```
+
+### PaychAvailableFundsByFromTo
+There are not yet any comments for this method.
+
+Perms: sign
+
+Inputs:
+```json
+[
+  "t01234",
+  "t01234"
+]
+```
+
+Response:
+```json
+{
+  "Channel": "\u003cempty\u003e",
+  "From": "t01234",
+  "To": "t01234",
+  "ConfirmedAmt": "0",
+  "PendingAmt": "0",
+  "PendingWaitSentinel": null,
+  "QueuedAmt": "0",
+  "VoucherReedeemedAmt": "0"
+}
+```
+
+### PaychCollect
+There are not yet any comments for this method.
+
+Perms: sign
+
+Inputs:
+```json
+[
+  "t01234"
+]
+```
+
+Response:
+```json
+{
+  "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+}
+```
+
+### PaychGet
+There are not yet any comments for this method.
+
+Perms: sign
+
+Inputs:
+```json
+[
+  "t01234",
+  "t01234",
+  "0"
+]
+```
+
+Response:
+```json
+{
+  "Channel": "t01234",
+  "WaitSentinel": {
+    "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+  }
+}
+```
+
+### PaychGetWaitReady
+There are not yet any comments for this method.
+
+Perms: sign
+
+Inputs:
+```json
+[
+  {
+    "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+  }
+]
+```
+
+Response: `"t01234"`
+
+### PaychList
+There are not yet any comments for this method.
+
+Perms: read
+
+Inputs: `null`
+
+Response: `null`
+
+### PaychNewPayment
+There are not yet any comments for this method.
+
+Perms: sign
+
+Inputs:
+```json
+[
+  "t01234",
+  "t01234",
+  null
+]
+```
+
+Response:
+```json
+{
+  "Channel": "t01234",
+  "WaitSentinel": {
+    "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+  },
+  "Vouchers": null
+}
+```
+
+### PaychSettle
+There are not yet any comments for this method.
+
+Perms: sign
+
+Inputs:
+```json
+[
+  "t01234"
+]
+```
+
+Response:
+```json
+{
+  "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+}
+```
+
+### PaychStatus
+There are not yet any comments for this method.
+
+Perms: read
+
+Inputs:
+```json
+[
+  "t01234"
+]
+```
+
+Response:
+```json
+{
+  "ControlAddr": "t01234",
+  "Direction": 1
+}
+```
+
+### PaychVoucherAdd
+There are not yet any comments for this method.
+
+Perms: write
+
+Inputs:
+```json
+[
+  "t01234",
+  {
+    "ChannelAddr": "t01234",
+    "TimeLockMin": 10101,
+    "TimeLockMax": 10101,
+    "SecretPreimage": "Ynl0ZSBhcnJheQ==",
+    "Extra": {
+      "Actor": "t01234",
+      "Method": 1,
+      "Data": "Ynl0ZSBhcnJheQ=="
+    },
+    "Lane": 42,
+    "Nonce": 42,
+    "Amount": "0",
+    "MinSettleHeight": 10101,
+    "Merges": null,
+    "Signature": {
+      "Type": 2,
+      "Data": "Ynl0ZSBhcnJheQ=="
+    }
+  },
+  "Ynl0ZSBhcnJheQ==",
+  "0"
+]
+```
+
+Response: `"0"`
+
+### PaychVoucherCheckSpendable
+There are not yet any comments for this method.
+
+Perms: read
+
+Inputs:
+```json
+[
+  "t01234",
+  {
+    "ChannelAddr": "t01234",
+    "TimeLockMin": 10101,
+    "TimeLockMax": 10101,
+    "SecretPreimage": "Ynl0ZSBhcnJheQ==",
+    "Extra": {
+      "Actor": "t01234",
+      "Method": 1,
+      "Data": "Ynl0ZSBhcnJheQ=="
+    },
+    "Lane": 42,
+    "Nonce": 42,
+    "Amount": "0",
+    "MinSettleHeight": 10101,
+    "Merges": null,
+    "Signature": {
+      "Type": 2,
+      "Data": "Ynl0ZSBhcnJheQ=="
+    }
+  },
+  "Ynl0ZSBhcnJheQ==",
+  "Ynl0ZSBhcnJheQ=="
+]
+```
+
+Response: `true`
+
+### PaychVoucherCheckValid
+There are not yet any comments for this method.
+
+Perms: read
+
+Inputs:
+```json
+[
+  "t01234",
+  {
+    "ChannelAddr": "t01234",
+    "TimeLockMin": 10101,
+    "TimeLockMax": 10101,
+    "SecretPreimage": "Ynl0ZSBhcnJheQ==",
+    "Extra": {
+      "Actor": "t01234",
+      "Method": 1,
+      "Data": "Ynl0ZSBhcnJheQ=="
+    },
+    "Lane": 42,
+    "Nonce": 42,
+    "Amount": "0",
+    "MinSettleHeight": 10101,
+    "Merges": null,
+    "Signature": {
+      "Type": 2,
+      "Data": "Ynl0ZSBhcnJheQ=="
+    }
+  }
+]
+```
+
+Response: `{}`
+
+### PaychVoucherCreate
+There are not yet any comments for this method.
+
+Perms: sign
+
+Inputs:
+```json
+[
+  "t01234",
+  "0",
+  42
+]
+```
+
+Response:
+```json
+{
+  "Voucher": {
+    "ChannelAddr": "t01234",
+    "TimeLockMin": 10101,
+    "TimeLockMax": 10101,
+    "SecretPreimage": "Ynl0ZSBhcnJheQ==",
+    "Extra": {
+      "Actor": "t01234",
+      "Method": 1,
+      "Data": "Ynl0ZSBhcnJheQ=="
+    },
+    "Lane": 42,
+    "Nonce": 42,
+    "Amount": "0",
+    "MinSettleHeight": 10101,
+    "Merges": null,
+    "Signature": {
+      "Type": 2,
+      "Data": "Ynl0ZSBhcnJheQ=="
+    }
+  },
+  "Shortfall": "0"
+}
+```
+
+### PaychVoucherList
+There are not yet any comments for this method.
+
+Perms: write
+
+Inputs:
+```json
+[
+  "t01234"
+]
+```
+
+Response: `null`
+
+### PaychVoucherSubmit
+There are not yet any comments for this method.
+
+Perms: sign
+
+Inputs:
+```json
+[
+  "t01234",
+  {
+    "ChannelAddr": "t01234",
+    "TimeLockMin": 10101,
+    "TimeLockMax": 10101,
+    "SecretPreimage": "Ynl0ZSBhcnJheQ==",
+    "Extra": {
+      "Actor": "t01234",
+      "Method": 1,
+      "Data": "Ynl0ZSBhcnJheQ=="
+    },
+    "Lane": 42,
+    "Nonce": 42,
+    "Amount": "0",
+    "MinSettleHeight": 10101,
+    "Merges": null,
+    "Signature": {
+      "Type": 2,
+      "Data": "Ynl0ZSBhcnJheQ=="
+    }
+  },
+  "Ynl0ZSBhcnJheQ==",
+  "Ynl0ZSBhcnJheQ=="
+]
+```
+
+Response:
+```json
+{
+  "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+}
+```
+
+## State
+The State methods are used to query, inspect, and interact with chain state.
+All methods take a TipSetKey as a parameter. The state looked up is the state at that tipset.
+A nil TipSetKey can be provided as a param, this will cause the heaviest tipset in the chain to be used.
+
+
+### StateAccountKey
+StateAccountKey returns the public key address of the given ID address
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  "t01234",
+  [
+    {
+      "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+    },
+    {
+      "/": "bafy2bzacebp3shtrn43k7g3unredz7fxn4gj533d3o43tqn2p2ipxxhrvchve"
+    }
+  ]
+]
+```
+
+Response: `"t01234"`
+
+### StateAllMinerFaults
+StateAllMinerFaults returns all non-expired Faults that occur within lookback epochs of the given tipset
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  10101,
+  [
+    {
+      "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+    },
+    {
+      "/": "bafy2bzacebp3shtrn43k7g3unredz7fxn4gj533d3o43tqn2p2ipxxhrvchve"
+    }
+  ]
+]
+```
+
+Response: `null`
+
+### StateCall
+StateCall runs the given message and returns its result without any persisted changes.
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  {
+    "Version": 42,
+    "To": "t01234",
+    "From": "t01234",
+    "Nonce": 42,
+    "Value": "0",
+    "GasLimit": 9,
+    "GasFeeCap": "0",
+    "GasPremium": "0",
+    "Method": 1,
+    "Params": "Ynl0ZSBhcnJheQ=="
+  },
+  [
+    {
+      "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+    },
+    {
+      "/": "bafy2bzacebp3shtrn43k7g3unredz7fxn4gj533d3o43tqn2p2ipxxhrvchve"
+    }
+  ]
+]
+```
+
+Response:
+```json
+{
+  "Msg": {
+    "Version": 42,
+    "To": "t01234",
+    "From": "t01234",
+    "Nonce": 42,
+    "Value": "0",
+    "GasLimit": 9,
+    "GasFeeCap": "0",
+    "GasPremium": "0",
+    "Method": 1,
+    "Params": "Ynl0ZSBhcnJheQ=="
+  },
+  "MsgRct": {
+    "ExitCode": 0,
+    "Return": "Ynl0ZSBhcnJheQ==",
+    "GasUsed": 9
+  },
+  "ExecutionTrace": {
+    "Msg": {
+      "Version": 42,
+      "To": "t01234",
+      "From": "t01234",
+      "Nonce": 42,
+      "Value": "0",
+      "GasLimit": 9,
+      "GasFeeCap": "0",
+      "GasPremium": "0",
+      "Method": 1,
+      "Params": "Ynl0ZSBhcnJheQ=="
+    },
+    "MsgRct": {
+      "ExitCode": 0,
+      "Return": "Ynl0ZSBhcnJheQ==",
+      "GasUsed": 9
+    },
+    "Error": "string value",
+    "Duration": 60000000000,
+    "GasCharges": null,
+    "Subcalls": null
+  },
+  "Error": "string value",
+  "Duration": 60000000000
+}
+```
+
+### StateChangedActors
+StateChangedActors returns all the actors whose states change between the two given state CIDs
+TODO: Should this take tipset keys instead?
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  {
+    "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+  },
+  {
+    "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+  }
+]
+```
+
+Response:
+```json
+{
+  "t01236": {
+    "Code": {
+      "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+    },
+    "Head": {
+      "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+    },
+    "Nonce": 42,
+    "Balance": "0"
+  }
+}
+```
+
+### StateCirculatingSupply
+StateCirculatingSupply returns the circulating supply of Filecoin at the given tipset
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  [
+    {
+      "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+    },
+    {
+      "/": "bafy2bzacebp3shtrn43k7g3unredz7fxn4gj533d3o43tqn2p2ipxxhrvchve"
+    }
+  ]
+]
+```
+
+Response:
+```json
+{
+  "FilVested": "0",
+  "FilMined": "0",
+  "FilBurnt": "0",
+  "FilLocked": "0",
+  "FilCirculating": "0"
+}
+```
+
+### StateCompute
+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.
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  10101,
+  null,
+  [
+    {
+      "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+    },
+    {
+      "/": "bafy2bzacebp3shtrn43k7g3unredz7fxn4gj533d3o43tqn2p2ipxxhrvchve"
+    }
+  ]
+]
+```
+
+Response:
+```json
+{
+  "Root": {
+    "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+  },
+  "Trace": null
+}
+```
+
+### StateDealProviderCollateralBounds
+StateDealProviderCollateralBounds returns the min and max collateral a storage provider
+can issue. It takes the deal size and verified status as parameters.
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  1032,
+  true,
+  [
+    {
+      "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+    },
+    {
+      "/": "bafy2bzacebp3shtrn43k7g3unredz7fxn4gj533d3o43tqn2p2ipxxhrvchve"
+    }
+  ]
+]
+```
+
+Response:
+```json
+{
+  "Min": "0",
+  "Max": "0"
+}
+```
+
+### StateGetActor
+StateGetActor returns the indicated actor's nonce and balance.
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  "t01234",
+  [
+    {
+      "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+    },
+    {
+      "/": "bafy2bzacebp3shtrn43k7g3unredz7fxn4gj533d3o43tqn2p2ipxxhrvchve"
+    }
+  ]
+]
+```
+
+Response:
+```json
+{
+  "Code": {
+    "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+  },
+  "Head": {
+    "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+  },
+  "Nonce": 42,
+  "Balance": "0"
+}
+```
+
+### StateGetReceipt
+StateGetReceipt returns the message receipt for the given message
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  {
+    "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+  },
+  [
+    {
+      "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+    },
+    {
+      "/": "bafy2bzacebp3shtrn43k7g3unredz7fxn4gj533d3o43tqn2p2ipxxhrvchve"
+    }
+  ]
+]
+```
+
+Response:
+```json
+{
+  "ExitCode": 0,
+  "Return": "Ynl0ZSBhcnJheQ==",
+  "GasUsed": 9
+}
+```
+
+### StateListActors
+StateListActors returns the addresses of every actor in the state
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  [
+    {
+      "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+    },
+    {
+      "/": "bafy2bzacebp3shtrn43k7g3unredz7fxn4gj533d3o43tqn2p2ipxxhrvchve"
+    }
+  ]
+]
+```
+
+Response: `null`
+
+### StateListMessages
+StateListMessages looks back and returns all messages with a matching to or from address, stopping at the given height.
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  {
+    "Version": 42,
+    "To": "t01234",
+    "From": "t01234",
+    "Nonce": 42,
+    "Value": "0",
+    "GasLimit": 9,
+    "GasFeeCap": "0",
+    "GasPremium": "0",
+    "Method": 1,
+    "Params": "Ynl0ZSBhcnJheQ=="
+  },
+  [
+    {
+      "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+    },
+    {
+      "/": "bafy2bzacebp3shtrn43k7g3unredz7fxn4gj533d3o43tqn2p2ipxxhrvchve"
+    }
+  ],
+  10101
+]
+```
+
+Response: `null`
+
+### StateListMiners
+StateListMiners returns the addresses of every miner that has claimed power in the Power Actor
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  [
+    {
+      "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+    },
+    {
+      "/": "bafy2bzacebp3shtrn43k7g3unredz7fxn4gj533d3o43tqn2p2ipxxhrvchve"
+    }
+  ]
+]
+```
+
+Response: `null`
+
+### StateLookupID
+StateLookupID retrieves the ID address of the given address
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  "t01234",
+  [
+    {
+      "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+    },
+    {
+      "/": "bafy2bzacebp3shtrn43k7g3unredz7fxn4gj533d3o43tqn2p2ipxxhrvchve"
+    }
+  ]
+]
+```
+
+Response: `"t01234"`
+
+### StateMarketBalance
+StateMarketBalance looks up the Escrow and Locked balances of the given address in the Storage Market
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  "t01234",
+  [
+    {
+      "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+    },
+    {
+      "/": "bafy2bzacebp3shtrn43k7g3unredz7fxn4gj533d3o43tqn2p2ipxxhrvchve"
+    }
+  ]
+]
+```
+
+Response:
+```json
+{
+  "Escrow": "0",
+  "Locked": "0"
+}
+```
+
+### StateMarketDeals
+StateMarketDeals returns information about every deal in the Storage Market
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  [
+    {
+      "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+    },
+    {
+      "/": "bafy2bzacebp3shtrn43k7g3unredz7fxn4gj533d3o43tqn2p2ipxxhrvchve"
+    }
+  ]
+]
+```
+
+Response:
+```json
+{
+  "t026363": {
+    "Proposal": {
+      "PieceCID": {
+        "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+      },
+      "PieceSize": 1032,
+      "VerifiedDeal": true,
+      "Client": "t01234",
+      "Provider": "t01234",
+      "Label": "string value",
+      "StartEpoch": 10101,
+      "EndEpoch": 10101,
+      "StoragePricePerEpoch": "0",
+      "ProviderCollateral": "0",
+      "ClientCollateral": "0"
+    },
+    "State": {
+      "SectorStartEpoch": 10101,
+      "LastUpdatedEpoch": 10101,
+      "SlashEpoch": 10101
+    }
+  }
+}
+```
+
+### StateMarketParticipants
+StateMarketParticipants returns the Escrow and Locked balances of every participant in the Storage Market
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  [
+    {
+      "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+    },
+    {
+      "/": "bafy2bzacebp3shtrn43k7g3unredz7fxn4gj533d3o43tqn2p2ipxxhrvchve"
+    }
+  ]
+]
+```
+
+Response:
+```json
+{
+  "t026363": {
+    "Escrow": "0",
+    "Locked": "0"
+  }
+}
+```
+
+### StateMarketStorageDeal
+StateMarketStorageDeal returns information about the indicated deal
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  5432,
+  [
+    {
+      "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+    },
+    {
+      "/": "bafy2bzacebp3shtrn43k7g3unredz7fxn4gj533d3o43tqn2p2ipxxhrvchve"
+    }
+  ]
+]
+```
+
+Response:
+```json
+{
+  "Proposal": {
+    "PieceCID": {
+      "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+    },
+    "PieceSize": 1032,
+    "VerifiedDeal": true,
+    "Client": "t01234",
+    "Provider": "t01234",
+    "Label": "string value",
+    "StartEpoch": 10101,
+    "EndEpoch": 10101,
+    "StoragePricePerEpoch": "0",
+    "ProviderCollateral": "0",
+    "ClientCollateral": "0"
+  },
+  "State": {
+    "SectorStartEpoch": 10101,
+    "LastUpdatedEpoch": 10101,
+    "SlashEpoch": 10101
+  }
+}
+```
+
+### StateMinerActiveSectors
+StateMinerActiveSectors returns info about sectors that a given miner is actively proving.
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  "t01234",
+  [
+    {
+      "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+    },
+    {
+      "/": "bafy2bzacebp3shtrn43k7g3unredz7fxn4gj533d3o43tqn2p2ipxxhrvchve"
+    }
+  ]
+]
+```
+
+Response: `null`
+
+### StateMinerAvailableBalance
+StateMinerAvailableBalance returns the portion of a miner's balance that can be withdrawn or spent
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  "t01234",
+  [
+    {
+      "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+    },
+    {
+      "/": "bafy2bzacebp3shtrn43k7g3unredz7fxn4gj533d3o43tqn2p2ipxxhrvchve"
+    }
+  ]
+]
+```
+
+Response: `"0"`
+
+### StateMinerDeadlines
+StateMinerDeadlines returns all the proving deadlines for the given miner
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  "t01234",
+  [
+    {
+      "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+    },
+    {
+      "/": "bafy2bzacebp3shtrn43k7g3unredz7fxn4gj533d3o43tqn2p2ipxxhrvchve"
+    }
+  ]
+]
+```
+
+Response: `null`
+
+### StateMinerFaults
+StateMinerFaults returns a bitfield indicating the faulty sectors of the given miner
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  "t01234",
+  [
+    {
+      "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+    },
+    {
+      "/": "bafy2bzacebp3shtrn43k7g3unredz7fxn4gj533d3o43tqn2p2ipxxhrvchve"
+    }
+  ]
+]
+```
+
+Response:
+```json
+[
+  5,
+  1
+]
+```
+
+### StateMinerInfo
+StateMinerInfo returns info about the indicated miner
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  "t01234",
+  [
+    {
+      "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+    },
+    {
+      "/": "bafy2bzacebp3shtrn43k7g3unredz7fxn4gj533d3o43tqn2p2ipxxhrvchve"
+    }
+  ]
+]
+```
+
+Response:
+```json
+{
+  "Owner": "t01234",
+  "Worker": "t01234",
+  "NewWorker": "t01234",
+  "ControlAddresses": null,
+  "WorkerChangeEpoch": 10101,
+  "PeerId": "12D3KooWGzxzKZYveHXtpG6AsrUJBcWxHBFS2HsEoGTxrMLvKXtf",
+  "Multiaddrs": null,
+  "SealProofType": 3,
+  "SectorSize": 34359738368,
+  "WindowPoStPartitionSectors": 42
+}
+```
+
+### StateMinerInitialPledgeCollateral
+StateMinerInitialPledgeCollateral returns the initial pledge collateral for the specified miner's sector
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  "t01234",
+  {
+    "SealProof": 3,
+    "SectorNumber": 9,
+    "SealedCID": {
+      "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+    },
+    "SealRandEpoch": 10101,
+    "DealIDs": null,
+    "Expiration": 10101,
+    "ReplaceCapacity": true,
+    "ReplaceSectorDeadline": 42,
+    "ReplaceSectorPartition": 42,
+    "ReplaceSectorNumber": 9
+  },
+  [
+    {
+      "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+    },
+    {
+      "/": "bafy2bzacebp3shtrn43k7g3unredz7fxn4gj533d3o43tqn2p2ipxxhrvchve"
+    }
+  ]
+]
+```
+
+Response: `"0"`
+
+### StateMinerPartitions
+StateMinerPartitions returns all partitions in the specified deadline
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  "t01234",
+  42,
+  [
+    {
+      "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+    },
+    {
+      "/": "bafy2bzacebp3shtrn43k7g3unredz7fxn4gj533d3o43tqn2p2ipxxhrvchve"
+    }
+  ]
+]
+```
+
+Response: `null`
+
+### StateMinerPower
+StateMinerPower returns the power of the indicated miner
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  "t01234",
+  [
+    {
+      "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+    },
+    {
+      "/": "bafy2bzacebp3shtrn43k7g3unredz7fxn4gj533d3o43tqn2p2ipxxhrvchve"
+    }
+  ]
+]
+```
+
+Response:
+```json
+{
+  "MinerPower": {
+    "RawBytePower": "0",
+    "QualityAdjPower": "0"
+  },
+  "TotalPower": {
+    "RawBytePower": "0",
+    "QualityAdjPower": "0"
+  },
+  "HasMinPower": true
+}
+```
+
+### StateMinerPreCommitDepositForPower
+StateMinerInitialPledgeCollateral returns the precommit deposit for the specified miner's sector
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  "t01234",
+  {
+    "SealProof": 3,
+    "SectorNumber": 9,
+    "SealedCID": {
+      "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+    },
+    "SealRandEpoch": 10101,
+    "DealIDs": null,
+    "Expiration": 10101,
+    "ReplaceCapacity": true,
+    "ReplaceSectorDeadline": 42,
+    "ReplaceSectorPartition": 42,
+    "ReplaceSectorNumber": 9
+  },
+  [
+    {
+      "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+    },
+    {
+      "/": "bafy2bzacebp3shtrn43k7g3unredz7fxn4gj533d3o43tqn2p2ipxxhrvchve"
+    }
+  ]
+]
+```
+
+Response: `"0"`
+
+### StateMinerProvingDeadline
+StateMinerProvingDeadline calculates the deadline at some epoch for a proving period
+and returns the deadline-related calculations.
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  "t01234",
+  [
+    {
+      "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+    },
+    {
+      "/": "bafy2bzacebp3shtrn43k7g3unredz7fxn4gj533d3o43tqn2p2ipxxhrvchve"
+    }
+  ]
+]
+```
+
+Response:
+```json
+{
+  "CurrentEpoch": 10101,
+  "PeriodStart": 10101,
+  "Index": 42,
+  "Open": 10101,
+  "Close": 10101,
+  "Challenge": 10101,
+  "FaultCutoff": 10101,
+  "WPoStPeriodDeadlines": 42,
+  "WPoStProvingPeriod": 10101,
+  "WPoStChallengeWindow": 10101,
+  "WPoStChallengeLookback": 10101,
+  "FaultDeclarationCutoff": 10101
+}
+```
+
+### StateMinerRecoveries
+StateMinerRecoveries returns a bitfield indicating the recovering sectors of the given miner
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  "t01234",
+  [
+    {
+      "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+    },
+    {
+      "/": "bafy2bzacebp3shtrn43k7g3unredz7fxn4gj533d3o43tqn2p2ipxxhrvchve"
+    }
+  ]
+]
+```
+
+Response:
+```json
+[
+  5,
+  1
+]
+```
+
+### StateMinerSectorCount
+StateMinerSectorCount returns the number of sectors in a miner's sector set and proving set
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  "t01234",
+  [
+    {
+      "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+    },
+    {
+      "/": "bafy2bzacebp3shtrn43k7g3unredz7fxn4gj533d3o43tqn2p2ipxxhrvchve"
+    }
+  ]
+]
+```
+
+Response:
+```json
+{
+  "Live": 42,
+  "Active": 42,
+  "Faulty": 42
+}
+```
+
+### StateMinerSectors
+StateMinerSectors returns info about the given miner's sectors. If the filter bitfield is nil, all sectors are included.
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  "t01234",
+  [
+    0
+  ],
+  [
+    {
+      "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+    },
+    {
+      "/": "bafy2bzacebp3shtrn43k7g3unredz7fxn4gj533d3o43tqn2p2ipxxhrvchve"
+    }
+  ]
+]
+```
+
+Response: `null`
+
+### StateMsgGasCost
+StateMsgGasCost searches for a message in the chain, and returns details of the messages gas costs, including the penalty and miner tip
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  {
+    "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+  },
+  [
+    {
+      "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+    },
+    {
+      "/": "bafy2bzacebp3shtrn43k7g3unredz7fxn4gj533d3o43tqn2p2ipxxhrvchve"
+    }
+  ]
+]
+```
+
+Response:
+```json
+{
+  "Message": {
+    "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+  },
+  "GasUsed": "0",
+  "BaseFeeBurn": "0",
+  "OverEstimationBurn": "0",
+  "MinerPenalty": "0",
+  "MinerTip": "0",
+  "Refund": "0",
+  "TotalCost": "0"
+}
+```
+
+### StateNetworkName
+StateNetworkName returns the name of the network the node is synced to
+
+
+Perms: read
+
+Inputs: `null`
+
+Response: `"lotus"`
+
+### StateNetworkVersion
+StateNetworkVersion returns the network version at the given tipset
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  [
+    {
+      "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+    },
+    {
+      "/": "bafy2bzacebp3shtrn43k7g3unredz7fxn4gj533d3o43tqn2p2ipxxhrvchve"
+    }
+  ]
+]
+```
+
+Response: `3`
+
+### StateReadState
+StateReadState returns the indicated actor's state.
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  "t01234",
+  [
+    {
+      "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+    },
+    {
+      "/": "bafy2bzacebp3shtrn43k7g3unredz7fxn4gj533d3o43tqn2p2ipxxhrvchve"
+    }
+  ]
+]
+```
+
+Response:
+```json
+{
+  "Balance": "0",
+  "State": {}
+}
+```
+
+### StateReplay
+StateReplay returns the result of executing the indicated message, assuming it was executed in the indicated tipset.
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  [
+    {
+      "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+    },
+    {
+      "/": "bafy2bzacebp3shtrn43k7g3unredz7fxn4gj533d3o43tqn2p2ipxxhrvchve"
+    }
+  ],
+  {
+    "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+  }
+]
+```
+
+Response:
+```json
+{
+  "Msg": {
+    "Version": 42,
+    "To": "t01234",
+    "From": "t01234",
+    "Nonce": 42,
+    "Value": "0",
+    "GasLimit": 9,
+    "GasFeeCap": "0",
+    "GasPremium": "0",
+    "Method": 1,
+    "Params": "Ynl0ZSBhcnJheQ=="
+  },
+  "MsgRct": {
+    "ExitCode": 0,
+    "Return": "Ynl0ZSBhcnJheQ==",
+    "GasUsed": 9
+  },
+  "ExecutionTrace": {
+    "Msg": {
+      "Version": 42,
+      "To": "t01234",
+      "From": "t01234",
+      "Nonce": 42,
+      "Value": "0",
+      "GasLimit": 9,
+      "GasFeeCap": "0",
+      "GasPremium": "0",
+      "Method": 1,
+      "Params": "Ynl0ZSBhcnJheQ=="
+    },
+    "MsgRct": {
+      "ExitCode": 0,
+      "Return": "Ynl0ZSBhcnJheQ==",
+      "GasUsed": 9
+    },
+    "Error": "string value",
+    "Duration": 60000000000,
+    "GasCharges": null,
+    "Subcalls": null
+  },
+  "Error": "string value",
+  "Duration": 60000000000
+}
+```
+
+### StateSearchMsg
+StateSearchMsg searches for a message in the chain, and returns its receipt and the tipset where it was executed
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  {
+    "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+  }
+]
+```
+
+Response:
+```json
+{
+  "Message": {
+    "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+  },
+  "Receipt": {
+    "ExitCode": 0,
+    "Return": "Ynl0ZSBhcnJheQ==",
+    "GasUsed": 9
+  },
+  "ReturnDec": {},
+  "TipSet": [
+    {
+      "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+    },
+    {
+      "/": "bafy2bzacebp3shtrn43k7g3unredz7fxn4gj533d3o43tqn2p2ipxxhrvchve"
+    }
+  ],
+  "Height": 10101
+}
+```
+
+### StateSectorExpiration
+StateSectorExpiration returns epoch at which given sector will expire
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  "t01234",
+  9,
+  [
+    {
+      "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+    },
+    {
+      "/": "bafy2bzacebp3shtrn43k7g3unredz7fxn4gj533d3o43tqn2p2ipxxhrvchve"
+    }
+  ]
+]
+```
+
+Response:
+```json
+{
+  "OnTime": 10101,
+  "Early": 10101
+}
+```
+
+### StateSectorGetInfo
+StateSectorGetInfo returns the on-chain info for the specified miner's sector. Returns null in case the sector info isn't found
+NOTE: returned info.Expiration may not be accurate in some cases, use StateSectorExpiration to get accurate
+expiration epoch
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  "t01234",
+  9,
+  [
+    {
+      "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+    },
+    {
+      "/": "bafy2bzacebp3shtrn43k7g3unredz7fxn4gj533d3o43tqn2p2ipxxhrvchve"
+    }
+  ]
+]
+```
+
+Response:
+```json
+{
+  "SectorNumber": 9,
+  "SealProof": 3,
+  "SealedCID": {
+    "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+  },
+  "DealIDs": null,
+  "Activation": 10101,
+  "Expiration": 10101,
+  "DealWeight": "0",
+  "VerifiedDealWeight": "0",
+  "InitialPledge": "0",
+  "ExpectedDayReward": "0",
+  "ExpectedStoragePledge": "0"
+}
+```
+
+### StateSectorPartition
+StateSectorPartition finds deadline/partition with the specified sector
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  "t01234",
+  9,
+  [
+    {
+      "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+    },
+    {
+      "/": "bafy2bzacebp3shtrn43k7g3unredz7fxn4gj533d3o43tqn2p2ipxxhrvchve"
+    }
+  ]
+]
+```
+
+Response:
+```json
+{
+  "Deadline": 42,
+  "Partition": 42
+}
+```
+
+### StateSectorPreCommitInfo
+StateSectorPreCommitInfo returns the PreCommit info for the specified miner's sector
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  "t01234",
+  9,
+  [
+    {
+      "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+    },
+    {
+      "/": "bafy2bzacebp3shtrn43k7g3unredz7fxn4gj533d3o43tqn2p2ipxxhrvchve"
+    }
+  ]
+]
+```
+
+Response:
+```json
+{
+  "Info": {
+    "SealProof": 3,
+    "SectorNumber": 9,
+    "SealedCID": {
+      "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+    },
+    "SealRandEpoch": 10101,
+    "DealIDs": null,
+    "Expiration": 10101,
+    "ReplaceCapacity": true,
+    "ReplaceSectorDeadline": 42,
+    "ReplaceSectorPartition": 42,
+    "ReplaceSectorNumber": 9
+  },
+  "PreCommitDeposit": "0",
+  "PreCommitEpoch": 10101,
+  "DealWeight": "0",
+  "VerifiedDealWeight": "0"
+}
+```
+
+### StateVerifiedClientStatus
+StateVerifiedClientStatus returns the data cap for the given address.
+Returns nil if there is no entry in the data cap table for the
+address.
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  "t01234",
+  [
+    {
+      "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+    },
+    {
+      "/": "bafy2bzacebp3shtrn43k7g3unredz7fxn4gj533d3o43tqn2p2ipxxhrvchve"
+    }
+  ]
+]
+```
+
+Response: `"0"`
+
+### StateWaitMsg
+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.
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  {
+    "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+  },
+  42
+]
+```
+
+Response:
+```json
+{
+  "Message": {
+    "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+  },
+  "Receipt": {
+    "ExitCode": 0,
+    "Return": "Ynl0ZSBhcnJheQ==",
+    "GasUsed": 9
+  },
+  "ReturnDec": {},
+  "TipSet": [
+    {
+      "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+    },
+    {
+      "/": "bafy2bzacebp3shtrn43k7g3unredz7fxn4gj533d3o43tqn2p2ipxxhrvchve"
+    }
+  ],
+  "Height": 10101
+}
+```
+
+## Sync
+The Sync method group contains methods for interacting with and
+observing the lotus sync service.
+
+
+### SyncCheckBad
+SyncCheckBad checks if a block was marked as bad, and if it was, returns
+the reason.
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  {
+    "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+  }
+]
+```
+
+Response: `"string value"`
+
+### SyncCheckpoint
+SyncCheckpoint marks a blocks as checkpointed, meaning that it won't ever fork away from it.
+
+
+Perms: admin
+
+Inputs:
+```json
+[
+  [
+    {
+      "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+    },
+    {
+      "/": "bafy2bzacebp3shtrn43k7g3unredz7fxn4gj533d3o43tqn2p2ipxxhrvchve"
+    }
+  ]
+]
+```
+
+Response: `{}`
+
+### SyncIncomingBlocks
+SyncIncomingBlocks returns a channel streaming incoming, potentially not
+yet synced block headers.
+
+
+Perms: read
+
+Inputs: `null`
+
+Response:
+```json
+{
+  "Miner": "t01234",
+  "Ticket": {
+    "VRFProof": "Ynl0ZSBhcnJheQ=="
+  },
+  "ElectionProof": {
+    "WinCount": 9,
+    "VRFProof": "Ynl0ZSBhcnJheQ=="
+  },
+  "BeaconEntries": null,
+  "WinPoStProof": null,
+  "Parents": null,
+  "ParentWeight": "0",
+  "Height": 10101,
+  "ParentStateRoot": {
+    "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+  },
+  "ParentMessageReceipts": {
+    "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+  },
+  "Messages": {
+    "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+  },
+  "BLSAggregate": {
+    "Type": 2,
+    "Data": "Ynl0ZSBhcnJheQ=="
+  },
+  "Timestamp": 42,
+  "BlockSig": {
+    "Type": 2,
+    "Data": "Ynl0ZSBhcnJheQ=="
+  },
+  "ForkSignaling": 42,
+  "ParentBaseFee": "0"
+}
+```
+
+### SyncMarkBad
+SyncMarkBad marks a blocks as bad, meaning that it won't ever by synced.
+Use with extreme caution.
+
+
+Perms: admin
+
+Inputs:
+```json
+[
+  {
+    "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+  }
+]
+```
+
+Response: `{}`
+
+### SyncState
+SyncState returns the current status of the lotus sync system.
+
+
+Perms: read
+
+Inputs: `null`
+
+Response:
+```json
+{
+  "ActiveSyncs": null,
+  "VMApplied": 42
+}
+```
+
+### SyncSubmitBlock
+SyncSubmitBlock can be used to submit a newly created block to the.
+network through this node
+
+
+Perms: write
+
+Inputs:
+```json
+[
+  {
+    "Header": {
+      "Miner": "t01234",
+      "Ticket": {
+        "VRFProof": "Ynl0ZSBhcnJheQ=="
+      },
+      "ElectionProof": {
+        "WinCount": 9,
+        "VRFProof": "Ynl0ZSBhcnJheQ=="
+      },
+      "BeaconEntries": null,
+      "WinPoStProof": null,
+      "Parents": null,
+      "ParentWeight": "0",
+      "Height": 10101,
+      "ParentStateRoot": {
+        "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+      },
+      "ParentMessageReceipts": {
+        "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+      },
+      "Messages": {
+        "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+      },
+      "BLSAggregate": {
+        "Type": 2,
+        "Data": "Ynl0ZSBhcnJheQ=="
+      },
+      "Timestamp": 42,
+      "BlockSig": {
+        "Type": 2,
+        "Data": "Ynl0ZSBhcnJheQ=="
+      },
+      "ForkSignaling": 42,
+      "ParentBaseFee": "0"
+    },
+    "BlsMessages": null,
+    "SecpkMessages": null
+  }
+]
+```
+
+Response: `{}`
+
+### SyncUnmarkBad
+SyncUnmarkBad unmarks a blocks as bad, making it possible to be validated and synced again.
+
+
+Perms: admin
+
+Inputs:
+```json
+[
+  {
+    "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+  }
+]
+```
+
+Response: `{}`
+
+## Wallet
+
+
+### WalletBalance
+WalletBalance returns the balance of the given address at the current head of the chain.
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  "t01234"
+]
+```
+
+Response: `"0"`
+
+### WalletDefaultAddress
+WalletDefaultAddress returns the address marked as default in the wallet.
+
+
+Perms: write
+
+Inputs: `null`
+
+Response: `"t01234"`
+
+### WalletDelete
+WalletDelete deletes an address from the wallet.
+
+
+Perms: write
+
+Inputs:
+```json
+[
+  "t01234"
+]
+```
+
+Response: `{}`
+
+### WalletExport
+WalletExport returns the private key of an address in the wallet.
+
+
+Perms: admin
+
+Inputs:
+```json
+[
+  "t01234"
+]
+```
+
+Response:
+```json
+{
+  "Type": "string value",
+  "PrivateKey": "Ynl0ZSBhcnJheQ=="
+}
+```
+
+### WalletHas
+WalletHas indicates whether the given address is in the wallet.
+
+
+Perms: write
+
+Inputs:
+```json
+[
+  "t01234"
+]
+```
+
+Response: `true`
+
+### WalletImport
+WalletImport receives a KeyInfo, which includes a private key, and imports it into the wallet.
+
+
+Perms: admin
+
+Inputs:
+```json
+[
+  {
+    "Type": "string value",
+    "PrivateKey": "Ynl0ZSBhcnJheQ=="
+  }
+]
+```
+
+Response: `"t01234"`
+
+### WalletList
+WalletList lists all the addresses in the wallet.
+
+
+Perms: write
+
+Inputs: `null`
+
+Response: `null`
+
+### WalletNew
+WalletNew creates a new address in the wallet with the given sigType.
+
+
+Perms: write
+
+Inputs:
+```json
+[
+  2
+]
+```
+
+Response: `"t01234"`
+
+### WalletSetDefault
+WalletSetDefault marks the given address as as the default one.
+
+
+Perms: admin
+
+Inputs:
+```json
+[
+  "t01234"
+]
+```
+
+Response: `{}`
+
+### WalletSign
+WalletSign signs the given bytes using the given address.
+
+
+Perms: sign
+
+Inputs:
+```json
+[
+  "t01234",
+  "Ynl0ZSBhcnJheQ=="
+]
+```
+
+Response:
+```json
+{
+  "Type": 2,
+  "Data": "Ynl0ZSBhcnJheQ=="
+}
+```
+
+### WalletSignMessage
+WalletSignMessage signs the given message using the given address.
+
+
+Perms: sign
+
+Inputs:
+```json
+[
+  "t01234",
+  {
+    "Version": 42,
+    "To": "t01234",
+    "From": "t01234",
+    "Nonce": 42,
+    "Value": "0",
+    "GasLimit": 9,
+    "GasFeeCap": "0",
+    "GasPremium": "0",
+    "Method": 1,
+    "Params": "Ynl0ZSBhcnJheQ=="
+  }
+]
+```
+
+Response:
+```json
+{
+  "Message": {
+    "Version": 42,
+    "To": "t01234",
+    "From": "t01234",
+    "Nonce": 42,
+    "Value": "0",
+    "GasLimit": 9,
+    "GasFeeCap": "0",
+    "GasPremium": "0",
+    "Method": 1,
+    "Params": "Ynl0ZSBhcnJheQ=="
+  },
+  "Signature": {
+    "Type": 2,
+    "Data": "Ynl0ZSBhcnJheQ=="
+  }
+}
+```
+
+### WalletVerify
+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.
+
+
+Perms: read
+
+Inputs:
+```json
+[
+  "t01234",
+  "Ynl0ZSBhcnJheQ==",
+  {
+    "Type": 2,
+    "Data": "Ynl0ZSBhcnJheQ=="
+  }
+]
+```
+
+Response: `true`
+
diff --git a/documentation/en/api-scripting-support.md b/documentation/en/api-scripting-support.md
index 7ac4b027a..653f144ed 100644
--- a/documentation/en/api-scripting-support.md
+++ b/documentation/en/api-scripting-support.md
@@ -1,31 +1,25 @@
-# API Scripting Support
+# Remote API Support
 
-You may want to delegate the work **Lotus Storage Miner** or **Lotus Node** perform to other machines. Here is how to setup the necessary authorization and environment variables.
-
-## Generate a JWT
-
-To generate a JWT for your environment variables, use this command:
-
-```sh
-lotus auth create-token --perm admin
-lotus-storage-miner auth create-token --perm admin
-```
+You may want to delegate the work **Lotus Miner** or **Lotus Node** performs to other machines. 
+Here is how to setup the necessary authorization and environment variables.
 
 ## Environment variables
 
 Environmental variables are variables that are defined for the current shell and are inherited by any child shells or processes. Environmental variables are used to pass information into processes that are spawned from the shell.
 
-Using the JWT you generated, you can assign it and the **multiaddr** to the appropriate environment variable.
+Using the [JWT you generated](https://lotu.sh/en+api#how-do-i-generate-a-token-18865), you can assign it and the **multiaddr** to the appropriate environment variable.
 
 ```sh
 # Lotus Node
 FULLNODE_API_INFO="JWT_TOKEN:/ip4/127.0.0.1/tcp/1234/http"
 
-# Lotus Storage Miner
-STORAGE_API_INFO="JWT_TOKEN:/ip4/127.0.0.1/tcp/2345/http"
+# Lotus Miner
+MINER_API_INFO="JWT_TOKEN:/ip4/127.0.0.1/tcp/2345/http"
 ```
 
+You can also use `lotus auth api-info --perm admin` to quickly create _API_INFO env vars
+
 - The **Lotus Node**'s `mutliaddr` is in `~/.lotus/api`.
 - The default token is in `~/.lotus/token`.
-- The **Lotus Storage Miner**'s `multiaddr` is in `~/.lotusstorage/config`.
-- The default token is in `~/.lotusstorage/token`.
+- The **Lotus Miner**'s `multiaddr` is in `~/.lotusminer/config`.
+- The default token is in `~/.lotusminer/token`.
diff --git a/documentation/en/api.md b/documentation/en/api.md
index c52c6fbf4..9760e2f32 100644
--- a/documentation/en/api.md
+++ b/documentation/en/api.md
@@ -2,7 +2,7 @@
 
 Here is an early overview of how to make API calls.
 
-Implementation details for the **JSON-RPC** package are [here](https://github.com/filecoin-project/lotus/tree/master/lib/jsonrpc).
+Implementation details for the **JSON-RPC** package are [here](https://github.com/filecoin-project/go-jsonrpc).
 
 ## Overview: How do you modify the config.toml to change the API endpoint?
 
@@ -18,15 +18,15 @@ Options:
 
 For now, you can look into different files to find methods available to you based on your needs:
 
-- [Both Lotus node + storage miner APIs](https://github.com/filecoin-project/lotus/blob/master/api/api_common.go)
+- [Both Lotus node + miner APIs](https://github.com/filecoin-project/lotus/blob/master/api/api_common.go)
 - [Lotus node API](https://github.com/filecoin-project/lotus/blob/master/api/api_full.go)
-- [Storage miner API](https://github.com/filecoin-project/lotus/blob/master/api/api_storage.go)
+- [Lotus miner API](https://github.com/filecoin-project/lotus/blob/master/api/api_storage.go)
 
 The necessary permissions for each are in [api/struct.go](https://github.com/filecoin-project/lotus/blob/master/api/struct.go).
 
 ## How do I make an API request?
 
-To demonstrate making an API request, we will take the method `ChainHead` from [api/api.go](https://github.com/filecoin-project/lotus/blob/master/api/api_full.go).
+To demonstrate making an API request, we will take the method `ChainHead` from [api/api_full.go](https://github.com/filecoin-project/lotus/blob/master/api/api_full.go).
 
 ```go
 ChainHead(context.Context) (*types.TipSet, error)
@@ -46,7 +46,7 @@ If the request requires authorization, add an authorization header:
 ```sh
 curl -X POST \
      -H "Content-Type: application/json" \
-     -H "Authorization: Bearer $(cat ~/.lotusstorage/token)" \
+     -H "Authorization: Bearer $(cat ~/.lotusminer/token)" \
      --data '{ "jsonrpc": "2.0", "method": "Filecoin.ChainHead", "params": [], "id": 3 }' \
      'http://127.0.0.1:1234/rpc/v0'
 ```
@@ -58,10 +58,10 @@ curl -X POST \
 To authorize your request, you will need to include the **JWT** in a HTTP header, for example:
 
 ```sh
--H "Authorization: Bearer $(cat ~/.lotusstorage/token)"
+-H "Authorization: Bearer $(cat ~/.lotusminer/token)"
 ```
 
-Admin token is stored in `~/.lotus/token` for the **Lotus Node** or `~/.lotusstorage/token` for the **Lotus Storage Miner**.
+Admin token is stored in `~/.lotus/token` for the **Lotus Node** or `~/.lotusminer/token` for the **Lotus Miner**.
 
 ## How do I generate a token?
 
@@ -71,13 +71,13 @@ To generate a JWT with custom permissions, use this command:
 # Lotus Node
 lotus auth create-token --perm admin
 
-# Lotus Storage Miner
-lotus-storage-miner auth create-token --perm admin
+# Lotus Miner
+lotus-miner auth create-token --perm admin
 ```
 
 ## What authorization level should I use?
 
-When viewing [api/struct.go](https://github.com/filecoin-project/lotus/blob/master/api/struct.go), you will encounter these types:
+When viewing [api/apistruct/struct.go](https://github.com/filecoin-project/lotus/blob/master/api/apistruct/struct.go), you will encounter these types:
 
 - `read` - Read node state, no private data.
 - `write` - Write to local store / chain, and `read` permissions.
diff --git a/documentation/en/architecture.md b/documentation/en/architecture.md
new file mode 100644
index 000000000..ca4789fa0
--- /dev/null
+++ b/documentation/en/architecture.md
@@ -0,0 +1,394 @@
+# Lotus
+
+Lotus is an implementation of the [Filecoin Distributed Storage Network](https://filecoin.io/).
+A Lotus node syncs blockchains that follow the
+Filecoin protocol, validating the blocks and state transitions.
+The specification for the Filecoin protocol can be found [here](https://filecoin-project.github.io/specs/).
+
+For information on how to setup and operate a Lotus node,
+please follow the instructions [here](https://lotu.sh/en+getting-started).
+
+# Components
+
+At a high level, a Lotus node comprises the following components:
+
+FIXME: No mention of block production here, cross-reference with schomatis's miner doc
+- The Syncer, which manages the process of syncing the blockchain
+- The State Manager, which can compute the state at any given point in the chain
+- The Virtual Machine (VM), which executes messages
+- The Repository, where all data is stored
+- P2P stuff (FIXME missing libp2p listed under other PL dependencies)? allows hello, blocksync, retrieval, storage
+- API / CLI (FIXME missing, in scratchpad)
+- Other Filecoin dependencies (specs actors, proofs, storage, etc., FIXME missing)
+- Is the Builder worth its own component?
+- Other PL dependencies (IPFS, libp2p, IPLD? FIXME, missing)
+- External libraries used by Lotus and other deps (FIXME, missing)
+
+# Preliminaries
+
+We discuss some key Filecoin concepts here, aiming to explain them by contrasting them with analogous concepts
+in other well-known blockchains like Ethereum. We only provide brief descriptions here; elaboration
+can be found in the [spec](https://filecoin-project.github.io/specs/).
+
+### Tipsets
+
+Unlike in Ethereum, a block can have multiple parents in Filecoin. We thus refer to the parent set of a block,
+instead of a single parent.
+A [tipset](https://filecoin-project.github.io/specs/#systems__filecoin_blockchain__struct__tipset)
+is any set of blocks that share the same parent set.
+
+There is no concept of "block difficulty" in Filecoin. Instead,
+the weight of a tipset is simply the number of blocks in the chain that ends in that tipset. Note that a longer chain
+can have less weight than a shorter chain with more blocks per tipset.
+
+We also allow for "null" tipsets, which include zero blocks. This allows miners to "skip" a round, and build on top
+of an imaginary empty tipset if they want to.
+
+We call the heaviest tipset in a chain the "head" of the chain.
+
+### Actors and Messages
+
+An [Actor](https://filecoin-project.github.io/specs/#systems__filecoin_vm__actor)
+ is analogous to a smart contract in Ethereum. Filecoin does not allow users to define their own
+actors, but comes with several [builtin actors](https://github.com/filecoin-project/specs-actors),
+which can be thought of as pre-compiled contracts.
+
+A [Message](https://filecoin-project.github.io/specs/#systems__filecoin_vm__message)
+is analogous to transactions in Ethereum.
+
+# Sync
+
+Sync refers to the process by which a Lotus node synchronizes to the heaviest chain being advertised by its peers.
+At a high-level, Lotus syncs in a manner similar to most other blockchains; a Lotus node listens to the various
+chains its peers claim to be at, picks the heaviest one, requests the blocks in the chosen chain,
+and validates each block in that chain, running all state transitions along the way.
+
+The majority of the sync functionality happens in the [`Syncer`](https://github.com/filecoin-project/lotus/blob/master/chain/sync.go),
+internally managed by a [`SyncManager`](https://github.com/filecoin-project/lotus/blob/master/chain/sync_manager.go).
+
+We now discuss the various stages of the sync process.
+
+## Sync setup
+
+When a Lotus node connects to a new peer, we exchange the head of our chain
+with the new peer through [the `hello` protocol](https://github.com/filecoin-project/lotus/blob/master/node/hello/hello.go).
+If the peer's head is heavier than ours, we try to sync to it. Note
+that we do NOT update our chain head at this stage.
+
+## Fetching and Persisting Block Headers
+
+Note: The API refers to these stages as `StageHeaders` and `StagePersistHeaders`.
+
+We proceed in the sync process by requesting block headers from the peer,
+moving back from their head, until we reach a tipset that we have in common
+(such a common tipset must exist, thought it may simply be the genesis block).
+The functionality can be found in `Syncer::collectHeaders()`.
+
+If the common tipset is our head, we treat the sync as a "fast-forward", else we must
+drop part of our chain to connect to the peer's head (referred to as "forking").
+
+FIXME: This next para might be best replaced with a link to the validation doc
+Some of the possible causes of failure in this stage include:
+
+- The chain is linked to a block that we have previously marked as bad,
+and stored in a [`BadBlockCache`](https://github.com/filecoin-project/lotus/blob/master/chain/badtscache.go).
+- The beacon entries in a block are inconsistent (FIXME: more details about what is validated here wouldn't be bad).
+- Switching to this new chain would involve a chain reorganization beyond the allowed threshold (SPECK-CHECK).
+
+## Fetching and Validating Blocks
+
+Note: The API refers to this stage as `StageMessages`.
+
+Having acquired the headers and found a common tipset, we then move forward, requesting the full blocks, including the messages.
+
+For each block, we  first confirm the syntactic validity of the block (SPECK-CHECK),
+which includes the syntactic validity of messages included
+in the block.
+We then apply the messages, running all the state transitions, and compare the state root we calculate with the provided state root.
+
+
+FIXME: This next para might be best replaced with a link to the validation doc
+Some of the possible causes of failure in this stage include:
+
+- a block is syntactically invalid (including potentially containing syntactically invalid messages)
+- the computed state root after applying the block doesn't match the block's state root
+- FIXME: Check what's covered by syntactic validity, and add anything important that isn't (like proof validity, future checks, etc.)
+
+The core functionality can be found in `Syncer::ValidateTipset()`, with `Syncer::checkBlockMessages()` performing
+syntactic validation of messages.
+
+## Setting the head
+
+Note: The API refers to this stage as `StageSyncComplete`.
+
+If all validations pass we will now set that head as our heaviest tipset in
+[`ChainStore`](https://github.com/filecoin-project/lotus/blob/master/chain/store/store.go).
+We already have the full state, since we calculated
+it during the sync process.
+
+FIXME (aayush) I don't fuilly understand the next 2 paragraphs, but it seems important. Confirm and polish.
+Relevant issue in IPFS: https://github.com/ipfs/ipfs-docs/issues/264
+
+It is important to note at this point that similar to the IPFS architecture of addressing by content and not by location/address (FIXME: check and link to IPFS docs) the "actual" chain stored in the node repo is *relative* to which CID we look for. We always have stored a series of Filecoin blocks pointing to other blocks, each a potential chain in itself by following its parent's reference, and its parent's parent, and so on up to the genesis block. (FIXME: We need a diagram here, one of the Filecoin blog entries might have something similar to what we are describing here.) It only depends on *where* (location) do we start to look for. The *only* address/location reference we hold of the chain, a relative reference, is the `heaviest` pointer. This is reflected by the fact that we don't store it in the `Blockstore` by a fixed, *absolute*, CID that reflects its contents, as this will change each time we sync to a new head (FIXME: link to the immutability IPFS doc that I need to write).
+
+FIXME: Create a further reading appendix, move this next para to it, along with other
+extraneous content
+This is one of the few items we store in `Datastore` by key, location, allowing its contents to change on every sync. This is reflected in the `(*ChainStore) writeHead()` function (called by `takeHeaviestTipSet()` above) where we reference the pointer by the explicit `chainHeadKey` address (the string `"head"`, not a hash embedded in a CID), and similarly in `(*ChainStore).Load()` when we start the node and create the `ChainStore`. Compare this to a Filecoin block or message which are immutable, stored in the `Blockstore` by CID, once created they never change.
+
+## Keeping up with the chain
+
+A Lotus node also listens for new blocks broadcast by its peers over the `gossipsub` channel (see FIXME for more).
+If we have validated such a block's parent tipset, and adding it to our tipset at its height would lead to a heavier
+head, then we validate and add this block. The validation described is identical to that invoked during the sync
+process (indeed, it's the same codepath).
+
+# State
+
+In Filecoin, the chain state at any given point is  a collection of data stored under a root CID
+encapsulated in the [`StateTree`](https://github.com/filecoin-project/lotus/blob/master/chain/state/statetree.go),
+and accessed through the
+[`StateManager`](https://github.com/filecoin-project/lotus/blob/master/chain/stmgr/stmgr.go).
+The state at the chain's head is thus easily tracked and updated in a state root CID.
+(FIXME: Talk about CIDs somewhere,  we might want to explain some of the modify/flush/update-root mechanism here.))
+
+## Calculating a Tipset State
+
+Recall that a tipset is a set of blocks that have identical parents (that is, that are built on top of the same tipset).
+The genesis tipset comprises the genesis block(s), and has some state corresponding to it.
+
+The methods `TipSetState()` and `computeTipSetState()` in
+[`StateManager`](https://github.com/filecoin-project/lotus/blob/master/chain/stmgr/stmgr.go)
+ are responsible for computing
+the state that results from applying a tipset. This involves applying all the messages included
+in the tipset, and performing implicit operations like awarding block rewards.
+
+Any valid block built on top of a tipset `ts` should have its Parent State Root equal to the result of
+calculating the tipset state of `ts`. Note that this means that all blocks in a tipset must have the same Parent
+State Root (which is to be expected, since they have the same parent tipset)
+
+### Preparing to apply a tipset
+
+When `StateManager::computeTipsetState()` is called with a tipset, `ts`,
+it retrieves the parent state root of the blocks in `ts`. It also creates a list of `BlockMessages`, which wraps the BLS
+and SecP messages in a block along with the miner that produced the block.
+
+Control then flows to `StateManager::ApplyBlocks()`, which builds a VM to apply the messages given to it. The VM
+is initialized with the parent state root of the blocks in `ts`. We apply the blocks in `ts` in order (see FIXME for
+ordering of blocks in a tipset).
+
+### Applying a block
+
+For each block, we prepare to apply the ordered messages (first BLS, then SecP). Before applying a message, we check if
+we have already applied a message with that CID within the scope of this method. If so, we simply skip that message;
+this is how duplicate messages included in the same tipset are skipped (with only the miner of the "first" block to
+include the message getting the reward). For the actual process of message application, see FIXME (need an
+internal link here), for now we
+simply assume that the outcome of the VM applying a message is either an error, or a
+[`MessageReceipt`](https://github.com/filecoin-project/lotus/blob/master/chain/types/message_receipt.go)
+ and some
+other information.
+
+We treat an error from the VM as a showstopper; there is no recovery, and no meaningful state can be computed for `ts`.
+Given a successful receipt, we add the rewards and penalties to what the miner has earned so far. Once all the messages
+included in a block have been applied (or skipped if they're a duplicate), we use an implicit message to call
+the Reward Actor. This awards the miner their reward for having won a block, and also awards / penalizes them based
+on the message rewards and penalties we tracked.
+
+We then proceed to apply the next block in `ts`, using the same VM. This means that the state changes that result
+from applying a message are visible when applying all subsequent messages, even if they are included in a different block.
+
+### Finishing up
+
+Having applied all the blocks, we send one more implicit message, to the Cron Actor, which handles operations that
+must be performed at the end of every epoch (see FIXME for more). The resulting state after calling the Cron Actor
+is the computed state of the tipset.
+
+# Virtual Machine
+
+The Virtual Machine (VM) is responsible for executing messages.
+The [Lotus Virtual Machine](https://github.com/filecoin-project/lotus/blob/master/chain/vm/vm.go)
+invokes the appropriate methods in the builtin actors, and provides
+a [`Runtime`](https://github.com/filecoin-project/specs-actors/blob/master/actors/runtime/runtime.go)
+interface to the [builtin actors](https://github.com/filecoin-project/specs-actors)
+that exposes their state, allows them to take certain actions, and meters
+their gas usage. The VM also performs balance transfers, creates new account actors as needed, and tracks the gas reward,
+penalty, return value, and exit code.
+
+## Applying a Message
+
+The primary entrypoint of the VM is the `ApplyMessage()` method. This method should not return an error
+unless something goes unrecoverably wrong.
+
+The first thing this method does is assess if the message provided meets any of the penalty criteria.
+If so, a penalty is issued, and the method returns. Next, the entire gas cost of the message is transferred to
+a temporary gas holder account. It is from this gas holder that gas will be deducted; if it runs out of gas, the message
+fails. Any unused gas in this holder will be refunded to the message's sender at the end of message execution.
+
+The VM then increments the sender's nonce, takes a snapshot of the state, and invokes `VM::send()`.
+
+The `send()` method creates a [`Runtime`](https://github.com/filecoin-project/lotus/blob/master/chain/vm/runtime.go)
+ for the subsequent message execution.
+It then transfers the message's value to the recipient, creating a new account actor if needed.
+
+### Method Invocation
+
+We use reflection to translate a Filecoin message for the VM to an actual Go function, relying on the VM's
+[`invoker`](https://github.com/filecoin-project/lotus/blob/master/chain/vm/invoker.go) structure.
+Each actor has its own set of codes defined in `specs-actors/actors/builtin/methods.go`.
+The `invoker` structure maps the builtin actors' CIDs
+ to a list of `invokeFunc` (one per exported method), which each take the `Runtime` (for state manipulation)
+ and the serialized input parameters.
+
+FIXME (aayush) Polish this next para.
+
+The basic layout (without reflection details) of `(*invoker).transform()` is as follows. From each actor registered in `NewInvoker()` we take its `Exports()` methods converting them to `invokeFunc`s. The actual method is wrapped in another function that takes care of decoding the serialized parameters and the runtime, this function is passed to `shimCall()` that will encapsulate the actors code being run inside a `defer` function to `recover()` from panics (we fail in the actors code with panics to unwrap the stack). The return values will then be (CBOR) marshaled and returned to the VM.
+
+### Returning from the VM
+
+Once method invocation is complete (including any subcalls), we return to `ApplyMessage()`, which receives
+the serialized response and the [`ActorError`](https://github.com/filecoin-project/lotus/blob/master/chain/actors/aerrors/error.go).
+The sender will be charged the appropriate amount of gas for the returned response, which gets put into the
+[`MessageReceipt`](https://github.com/filecoin-project/lotus/blob/master/chain/types/message_receipt.go).
+
+The method then refunds any unused gas to the sender, sets up the gas reward for the miner, and
+wraps all of this into an `ApplyRet`, which is returned.
+
+# Building a Lotus node
+
+When we launch a Lotus node with the command `./lotus daemon`
+(see [here](https://github.com/filecoin-project/lotus/blob/master/cmd/lotus/daemon.go) for more),
+the node is created through [dependency injection](https://godoc.org/go.uber.org/fx).
+This relies on reflection, which makes some of the references hard to follow.
+The node sets up all of the subsystems it needs to run, such as the repository, the network connections, the chain sync
+service, etc.
+This setup is orchestrated through calls to the `node.Override` function.
+The structure of each call indicates the type of component it will set up
+(many defined in [`node/modules/dtypes/`](https://github.com/filecoin-project/lotus/tree/master/node/modules/dtypes)),
+and the function that will provide it.
+The dependency is implicit in the argument of the provider function.
+
+As an example, consider the `modules.ChainStore()` function that provides the
+[`ChainStore`](https://github.com/filecoin-project/lotus/blob/master/chain/store/store.go) structure.
+It takes as one of its parameters the [`ChainBlockstore`](https://github.com/filecoin-project/lotus/blob/master/node/modules/dtypes/storage.go)
+type, which becomes one of its dependencies.
+For the node to be built successfully the `ChainBlockstore` will need to be provided before `ChainStore`, a requirement
+that is made explicit in another `Override()` call that sets the provider of that type as the `ChainBlockstore()` function.
+
+## The Repository
+
+The repo is the directory where all of a node's information is stored. The node is entirely defined by its repo, which
+makes it easy to port to another location. This one-to-one relationship means we can speak
+of the node as the repo it is associated with, instead of the daemon process that runs from that repo.
+
+Only one daemon can run be running with an associated repo at a time.
+A process signals that it is running a node associated with a particular repo, by creating and acquiring
+a `repo.lock`.
+
+```sh
+lsof ~/.lotus/repo.lock
+# COMMAND   PID
+# lotus   52356
+```
+Trying to launch a second daemon hooked to the same repo leads to a `repo is already locked (lotus daemon already running)`
+error.
+
+The `node.Repo()` function (`node/builder.go`) contains most of the dependencies (specified as `Override()` calls)
+needed to properly set up the node's repo. We list the most salient ones here.
+
+### Datastore
+
+`Datastore` and `ChainBlockstore`: Data related to the node state is saved in the repo's `Datastore`,
+an IPFS interface defined [here](https://github.com/ipfs/go-datastore/blob/master/datastore.go).
+Lotus creates this interface from a [Badger DB](https://github.com/dgraph-io/badger) in
+ [`FsRepo`](https://github.com/filecoin-project/lotus/blob/master/node/repo/fsrepo.go).
+Every piece of data is fundamentally a key-value pair in the `datastore` directory of the repo.
+There are several abstractions laid on top of it that appear through the code depending on *how* we access it,
+but it is important to remember that we're always accessing it from the same place.
+
+FIXME: Maybe mention the `Batching` interface as the developer will stumble upon it before reaching the `Datastore` one.
+
+#### Blocks
+
+FIXME: IPFS blocks vs Filecoin blocks ideally happens before this / here
+
+The [`Blockstore` interface](`github.com/ipfs/go-ipfs-blockstore/blockstore.go`) structures the key-value pair
+into the CID format for the key and the [`Block` interface](`github.com/ipfs/go-block-format/blocks.go`) for the value.
+The `Block` value is just a raw string of bytes addressed by its hash, which is included in the CID key.
+
+`ChainBlockstore` creates a `Blockstore` in the repo under the `/blocks` namespace.
+Every key stored there will have the `blocks` prefix so that it does not collide with other stores that use the same repo.
+
+FIXME: Link to IPFS documentation about DAG, CID, and related, especially we need a diagram that shows how do we wrap each datastore inside the next layer (datastore, batching, block store, gc, etc).
+
+#### Metadata
+
+`modules.Datastore()` creates a `dtypes.MetadataDS`, which is an alias for the basic `Datastore` interface.
+Metadata is stored here under the `/metadata` prefix.
+(FIXME: Explain *what* is metadata in contrast with the block store, namely we store the pointer to the heaviest chain, we might just link to that unwritten section here later.)
+
+FIXME: Explain the key store related calls (maybe remove, per Schomatis)
+
+### LockedRepo
+
+`LockedRepo()`: This method doesn't create or initialize any new structures, but rather registers an
+ `OnStop` [hook](https://godoc.org/go.uber.org/fx/internal/lifecycle#Hook)
+ that will close the locked repository associated with it on shutdown.
+
+
+### Repo types / Node types
+
+FIXME: This section needs to be clarified / corrected...I don't fully understand the config differences (what do they have in common, if anything?)
+
+At the end of the `Repo()` function we see two mutually exclusive configuration calls based on the `RepoType` (`node/repo/fsrepo.go`).
+```Go
+			ApplyIf(isType(repo.FullNode), ConfigFullNode(c)),
+			ApplyIf(isType(repo.StorageMiner), ConfigStorageMiner(c)),
+```
+As we said, the repo fully identifies the node so a repo type is also a *node* type, in this case a full node or a miner. (FIXME: What is the difference between the two, does *full* imply miner?) In this case the `daemon` command will create a `FullNode`, this is specified in the command logic itself in `main.DaemonCmd()`, the `FsRepo` created (and passed to `node.Repo()`) will be initiated with that type (see `(*FsRepo).Init(t RepoType)`).
+
+## Online
+
+FIXME: Much of this might need to be subsumed into the p2p section
+
+The `node.Online()` configuration function (`node/builder.go`) initializes components that involve connecting to,
+or interacting with, the Filecoin network. These connections are managed through the libp2p stack (FIXME link to this section when it exists).
+We discuss some of the components found in the full node type (that is, included in the `ApplyIf(isType(repo.FullNode),` call).
+
+#### Chainstore
+
+`modules.ChainStore()` creates the [`store.ChainStore`](https://github.com/filecoin-project/lotus/blob/master/chain/store/store.go))
+that wraps the stores
+ previously instantiated in `Repo()`. It is the main point of entry for the node to all chain-related data
+ (FIXME: this is incorrect, we sometimes access its underlying block store directly, and probably shouldn't).
+ It also holds the crucial `heaviest` pointer, which indicates the current head of the chain.
+
+ #### ChainExchange and ChainBlockservice
+`ChainExchange()` and `ChainBlockservice()` establish a BitSwap connection (FIXME libp2p link)
+to exchange chain information in the form of `blocks.Block`s stored in the repo. (See sync section for more details, the Filecoin blocks and messages are backed by these raw IPFS blocks that together form the different structures that define the state of the current/heaviest chain.)
+
+#### Incoming handlers
+`HandleIncomingBlocks()` and `HandleIncomingMessages()` start the services in charge of processing new Filecoin blocks
+and messages from the network (see `<undefined>` for more information about the topics the node is subscribed to, FIXME: should that be part of the libp2p section or should we expand on gossipsub separately?).
+
+#### Hello
+`RunHello()`: starts the services to both send (`(*Service).SayHello()`) and receive (`(*Service).HandleStream()`, `node/hello/hello.go`)
+`hello` messages. When nodes establish a new connection with each other, they exchange these messages
+to share chain-related information (namely their genesis block and their heaviest tipset).
+
+#### Syncer
+`NewSyncer()` creates the `Syncer` structure and starts the services related to the chain sync process (FIXME link).
+
+### Ordering the dependencies
+
+We can establish the dependency relations by looking at the parameters that each function needs and by understanding
+the architecture of the node and how the different components relate to each other (the chief purpose of this document).
+
+As an example, the sync mechanism depends on the node being able to exchange different IPFS blocks with the network,
+so as to be able to request the "missing pieces" needed to construct the chain. This dependency is reflected by `NewSyncer()`
+having a `blocksync.BlockSync` parameter, which in turn depends on `ChainBlockservice()` and `ChainExchange()`.
+The chain exchange service further depends on the chain store to save and retrieve chain data, which is reflected
+in `ChainExchange()` having `ChainGCBlockstore` as a parameter (which is just a wrapper around `ChainBlockstore` capable
+ of garbage collection).
+
+This block store is the same store underlying the chain store, which is an indirect dependency of `NewSyncer()` (through the `StateManager`).
+(FIXME: This last line is flaky, we need to resolve the hierarchy better, we sometimes refer to the chain store and sometimes to its underlying block store. We need a diagram to visualize all the different components just mentioned otherwise it is too hard to follow. We probably even need to skip some of the connections mentioned.)
diff --git a/documentation/en/block-validation.md b/documentation/en/block-validation.md
new file mode 100644
index 000000000..ccd83a904
--- /dev/null
+++ b/documentation/en/block-validation.md
@@ -0,0 +1,137 @@
+# Incoming block validations
+
+This document reviews the code flow that takes place inside the full node after receiving a new block from the GossipSub `/fil/blocks` topic and traces all of its protocol-related validation logic. We do not include validation logic *inside* the VM, the analysis stops at `(*VM).Invoke()`. The `V:` tag explicitly signals validations throughout the text.
+
+## `modules.HandleIncomingBlocks()`
+
+We subscribe to the `/fil/blocks` PubSub topic to receive external blocks from peers in the network and register a block validator that operates at the PubSub (`libp2p` stack) level, validating each PubSub message containing a Filecoin block header.
+
+`V:` PubSub message is a valid CBOR `BlockMsg`.
+
+`V:` Total messages in block are under `BlockMessageLimit`.
+
+`V:` Aggregate message CIDs, encapsulated in the `MsgMeta` structure, serialize to the `Messages` CID in the block header (`ValidateMsgMeta()`).
+
+`V:` Miner `Address` in block header is present and corresponds to a public-key address in the current chain state.
+
+`V:` Block signature (`BlockSig`) is present and belongs to the public-key address retrieved for the miner (`CheckBlockSignature()`).
+
+## `sub.HandleIncomingBlocks()`
+
+Assemble a `FullBlock` from the received block header retrieving its Filecoin messages.
+
+`V:` Block messages CIDs can be retrieved from the network and decode into valid CBOR `Message`/`SignedMessage`.
+
+## `(*Syncer).InformNewHead()`
+
+Assemble a `FullTipSet` populated with the single block received earlier.
+
+`V:` `ValidateMsgMeta()` (already done in the topic validator).
+
+`V:` Block's `ParentWeight` is greater than the one from the (first block of the) heaviest tipset.
+
+## `(*Syncer).Sync()`
+
+`(*Syncer).collectHeaders()`: we retrieve all tipsets from the received block down to our chain. Validation now is expanded to *every* block inside these tipsets.
+
+`V`: Beacon entires are ordered by their round number.
+
+`V:` Tipset `Parents` CIDs match the fetched parent tipset through block sync. (This check is not enforced correctly at the moment, see [issue](https://github.com/filecoin-project/lotus/issues/1918).)
+
+## `(*Syncer).ValidateBlock()`
+
+This function contains most of the validation logic grouped in separate closures that run asynchronously, this list does not reflect validation order then.
+
+`V:` Block `Timestamp`:
+  * Is not bigger than current time plus `AllowableClockDriftSecs`.
+  * Is not smaller than previous block's `Timestamp` plus `BlockDelay` (including null blocks).
+
+### Messages
+
+We check all the messages contained in one block at a time (`(*Syncer).checkBlockMessages()`).
+
+`V:` The block's `BLSAggregate` matches the aggregate of BLS messages digests and public keys (extracted from the messages `From`).
+
+`V:` Each `secp256k1` message `Signature` is signed with the public key extracted from the message `From`.
+
+`V:` Aggregate message CIDs, encapsulated in the `MsgMeta` structure, serialize to the `Messages` CID in block header (similar to `ValidateMsgMeta()` call).
+
+`V:` For each message, in `ValidForBlockInclusion()`:
+* Message fields `Version`, `To`, `From`, `Value`, `GasPrice`, and `GasLimit` are correctly defined.
+* Message `GasLimit` is under the message minimum gas cost (derived from chain height and message length).
+
+`V:` Actor associated with message `From` exists and is an account actor, its `Nonce` matches the message `Nonce`.
+
+### Miner
+
+`V:` Miner address is registered in the `Claims` HAMT of the Power actor.
+
+### Compute parent tipset state
+
+`V:` Block's `ParentStateRoot` CID matches the state CID computed from the parent tipset.
+
+`V:` Block's `ParentMessageReceipts` CID matches receipts CID computed from the parent tipset.
+
+### Winner
+
+Draw randomness for current epoch with minimum ticket from previous tipset, using `ElectionProofProduction`
+domain separation tag.
+`V`: `ElectionProof.VRFProof` is computed correctly by checking BLS signature using miner's key.
+`V`: Miner is not slashed in `StoragePowerActor`.
+`V`: Check if ticket is a winning ticket:
+```
+h := blake2b(VRFProof)
+lhs := AsInt(h) * totalNetworkPower
+rhs := minerPower * 2^256
+if lhs < rhs { return "Winner" } else { return "Not a winner" }
+```
+
+### Block signature
+
+`V:` `CheckBlockSignature()` (same signature validation as the one applied to the incoming block).
+
+### Beacon values check
+
+`V`: Validate that all `BeaconEntries` are valid. Check that every one of them is a signature of a message: `previousSignature || round` signed using drand's public key.
+`V`: All entries between `MaxBeaconRoundForEpoch` down to `prevEntry` (from previous tipset) are included.
+
+### Verify VRF Ticket chain
+
+Draw randomness for current epoch with minimum ticket from previous tipset, using `TicketProduction`
+domain separation tag.
+`V`: `VerifyVRF` using drawn randomness and miner public key.
+
+### Winning PoSt proof
+
+Draw randomness for current epoch with `WinningPoSt` domain separation tag.
+Get list of sectors challanged in this epoch for this miner, based on the randomness drawn. 
+
+`V`: Use filecoin proofs system to verify that miner prooved access to sealed versions of these sectors.
+
+## `(*StateManager).TipSetState()`
+
+Called throughout the validation process for the parent of each tipset being validated. The checks here then do not apply to the received new head itself that started the validation process.
+
+### `(*StateManager).computeTipSetState()`
+
+`V:` Every block in the tipset should belong to different a miner.
+
+### `(*StateManager).ApplyBlocks()`
+
+We create a new VM with the tipset's `ParentStateRoot` (this is then the parent state of the parent of the tipset currently being validated) on which to apply all messages from all blocks in the tipset. For each message independently we apply the validations listed next.
+
+### `(*VM).ApplyMessage()`
+
+`V:` Basic gas and value checks in `checkMessage()`:
+* Message `GasLimit` is bigger than zero.
+* Message `GasPrice` and `Value` are set.
+
+`V:` Message storage gas cost is under the message's `GasLimit`.
+
+`V:` Message's `Nonce` matches nonce in actor retrieved from message's `From`.
+
+`V:` Message's maximum gas cost (derived from its `GasLimit`, `GasPrice`, and `Value`) is under the balance of the actor retrieved from message's `From`.
+
+### `(*VM).send()`
+
+`V:` Message's transfer `Value` is under the balance in actor retrieved from message's `From`.
diff --git a/documentation/en/cli.md b/documentation/en/cli.md
new file mode 100644
index 000000000..fd26400d0
--- /dev/null
+++ b/documentation/en/cli.md
@@ -0,0 +1,108 @@
+# Lotus Command Line Interface
+
+The Command Line Interface (CLI) is a convenient way to interact with
+a Lotus node. You can use the CLI to operate your node,
+get information about the blockchain,
+manage your accounts and transfer funds,
+create storage deals, and much more! 
+
+The CLI is intended to be self-documenting, so when in doubt, simply add `--help`
+to whatever command you're trying to run! This will also display all of the 
+input parameters that can be provided to a command.
+
+We highlight some of the commonly
+used features of the CLI below.
+All CLI commands should be run from the home directory of the Lotus project.
+
+## Operating a Lotus node
+
+### Starting up a node
+
+```sh
+lotus daemon
+```
+This command will start up your Lotus node, with its API port open at 1234. 
+You can pass `--api=<number>` to use a different port.
+
+### Checking your sync progress
+
+```sh
+lotus sync status
+```
+This command will print your current tipset height under `Height`, and the target tipset height
+under `Taregt`. 
+
+You can also run `lotus sync wait` to get constant updates on your sync progress.
+
+### Getting the head tipset
+
+```sh
+lotus chain head
+```
+
+### Control the logging level
+
+```sh
+lotus log set-level
+```
+This command can be used to toggle the logging levels of the different
+systems of a Lotus node. In decreasing order
+of logging detail, the levels are `debug`, `info`, `warn`, and `error`. 
+
+As an example,
+to set the `chain` and `blocksync` to log at the `debug` level, run 
+`lotus log set-level --system chain --system blocksync debug`. 
+
+To see the various logging system, run `lotus log list`.
+
+### Find out what version of Lotus you're running
+
+```sh
+lotus version
+```
+
+## Managing your accounts
+
+### Listing accounts in your wallet
+
+```sh
+lotus wallet list
+``` 
+
+### Creating a new account
+
+```sh
+lotus wallet new bls
+```
+This command will create a new BLS account in your wallet; these
+addresses start with the prefix `t3`. Running `lotus wallet new secp256k1` 
+(or just `lotus wallet new`) will create
+a new Secp256k1 account, which begins with the prefix `t1`.
+
+### Getting an account's balance
+
+```sh
+lotus wallet balance <address>
+``` 
+
+### Transferring funds 
+
+```sh
+lotus send --source=<source address> <destination address> <amount>
+``` 
+This command will transfer `amount` (in attoFIL) from `source address` to `destination address`.
+
+### Importing an account into your wallet
+
+```sh
+lotus wallet import <path to private key>
+``` 
+This command will import an account whose private key is saved at the specified file.
+
+### Exporting an account from your wallet
+
+```sh
+lotus wallet export <address>
+``` 
+This command will print out the private key of the specified address
+if it is in your wallet. Always be careful with your private key!
diff --git a/documentation/en/dev-tools-pond-ui.md b/documentation/en/dev-tools-pond-ui.md
index e5c992073..7d110890b 100644
--- a/documentation/en/dev-tools-pond-ui.md
+++ b/documentation/en/dev-tools-pond-ui.md
@@ -1,6 +1,6 @@
 # Pond UI
 
-Pond is a graphical testbed for [Lotus](https://docs.lotu.sh). Using it will setup a separate local network which is helpful for debugging. Pond will spin up nodes, connect them in a given topology, start them mining, and observe how they function over time.
+Pond is a graphical testbed for [Lotus](https://lotu.sh). Using it will setup a separate local network which is helpful for debugging. Pond will spin up nodes, connect them in a given topology, start them mining, and observe how they function over time.
 
 ## Build
 
@@ -19,7 +19,7 @@ Now go to `http://127.0.0.1:2222`.
 ## What can I test?
 
 - The `Spawn Node` button starts a new **Lotus Node** in a new draggable window.
-- Click `[Spawn Storage Miner]` to start a **Lotus Storage Miner**. This require's the node's wallet to have funds.
+- Click `[Spawn Miner]` to start a **Lotus Miner**. This require's the node's wallet to have funds.
 - Click on `[Client]` to open the **Lotus Node**'s client interface and propose a deal with an existing Miner. If successful you'll see a payment channel open up with that Miner.
 
 Don't leave Pond unattended for more than 10 hours, the web client will eventually consume all available RAM.
@@ -27,6 +27,6 @@ Don't leave Pond unattended for more than 10 hours, the web client will eventual
 ## Troubleshooting
 
 - Turn it off and on - Start at the top
-- `rm -rf ~/.lotus ~/.lotusstorage/`, this command will delete chain sync data, stored wallets, and other configurations so be careful.
+- `rm -rf ~/.lotus ~/.lotusminer/`, this command will delete chain sync data, stored wallets, and other configurations so be careful.
 - Verify you have the correct versions of dependencies
 - If stuck on a bad fork, try `lotus chain sethead --genesis`
diff --git a/documentation/en/dev-tools.md b/documentation/en/dev-tools.md
index 33bc73f93..60b9b26d4 100644
--- a/documentation/en/dev-tools.md
+++ b/documentation/en/dev-tools.md
@@ -1,3 +1,3 @@
-# Development Tools
+# Developer Tools
 
-> This page is a work in progress
+> Running a local network can be a great way to understand how Lotus works and test your setup. 
diff --git a/documentation/en/dev/WIP-arch-complementary-notes.md b/documentation/en/dev/WIP-arch-complementary-notes.md
new file mode 100644
index 000000000..013a7bbac
--- /dev/null
+++ b/documentation/en/dev/WIP-arch-complementary-notes.md
@@ -0,0 +1,153 @@
+# Genesis block
+
+Seems a good way to start exploring the VM state though the instantiation of its different actors like the storage power.
+
+Explain where do we load the genesis block, the CAR entries, and we set the root of the state. Follow the daemon command option, `chain.LoadGenesis()` saves all the blocks of the CAR file into the store provided by `ChainBlockstore` (this should already be explained in the previous section). The CAR root (MT root?) of those blocks is decoded into the `BlockHeader` that will be the Filecoin (genesis) block of the chain, but most of the information was stored in the raw data (non-Filecoin, what's the correct term?) blocks forwarded directly to the chain, the block header just has a pointer to it.
+
+`SetGenesis` block with name 0. `(ChainStore).SetGenesis()` stores it there.
+
+`MakeInitialStateTree` (`chain/gen/genesis/genesis.go`, used to construct the genesis block (`MakeGenesisBlock()`), constructs the state tree (`NewStateTree`) which is just a "pointer" (root node in the HAMT) to the different actors. It will be continuously used in `(*StateTree).SetActor()` an `types.Actor` structure under a certain `Address` (in the HAMT). (How does the `stateSnaps` work? It has no comments.)
+
+From this point we can follow different setup function like:
+
+* `SetupInitActor()`: see the `AddressMap`.
+
+* `SetupStoragePowerActor`: initial (zero) power state of the chain, most important attributes.
+
+* Account actors in the `template.Accounts`: `SetActor`.
+
+Which other actor type could be helpful at this point?
+
+# Basic concepts
+
+What should be clear at this point either from this document or the spec.
+
+## Addresses
+
+## Accounts
+
+# Sync Topics PubSub
+
+Gossip sub spec and some introduction.
+
+# Look at the constructor of a miner
+
+Follow the `lotus-miner` command to see how a miner is created, from the command to the message to the storage power logic.
+
+# Directory structure so far, main structures seen, their relation
+
+List what are the main directories we should be looking at (e.g., `chain/`) and the most important structures (e.g., `StateTree`, `Runtime`, etc.)
+
+# Tests
+
+Run a few messages and observe state changes. What is the easiest test that also let's us "interact" with it (modify something and observe the difference).
+
+### Filecoin blocks vs IPFS blocks
+
+The term *block* has different meanings depending on the context, many times both meanings coexist at once in the code and it is important to distinguish them. (FIXME: link to IPFS blocks and related doc throughout this explanation). In terms of the lower IPFS layer, in charge of storing and retrieving data, both present at the repo or accessible through the network (e.g., through the BitSwap protocol discussed later), a block is a string of raw bytes identified by its hash, embedded and fully qualified in a CID identifier. IPFS blocks are the "building blocks" of almost any other piece of (chain) data described in the Filecoin protocol.
+
+In contrast, in the higher Filecoin (application) layer, a block is roughly (FIXME: link to spec definition, if we have any) a set of zero or more messages grouped together by a single miner which is itself grouped with other blocks (from other miners) in the same round to form a tipset. The Filecoin blockchain is a series of "chained" tipsets, each referencing its parent by its header's *CID*, that is, its header as seen as a single IPFS block, this is where both layers interact.
+
+Using now the full Go package qualifiers to avoid any ambiguity, the Filecoin block, `github.com/filecoin-project/lotus/chain/types.FullBlock`, is defined as,
+
+```Go
+package types
+
+import "github.com/ipfs/go-cid"
+
+type FullBlock struct {
+	Header        *BlockHeader
+	BlsMessages   []*Message
+	SecpkMessages []*SignedMessage
+}
+
+func (fb *FullBlock) Cid() cid.Cid {
+	return fb.Header.Cid()
+}
+```
+
+It has, besides the Filecoin messages, a header with protocol related information (e.g., its `Height`) which is (like virtually any other piece of data in the Filecoin protocol) stored, retrieved and shared as an IPFS block with its corresponding CID,
+
+```Go
+func (b *BlockHeader) Cid() cid.Cid {
+	sb, err := b.ToStorageBlock()
+
+	return sb.Cid()
+}
+
+func (b *BlockHeader) ToStorageBlock() (block.Block, error) {
+	data, err := b.Serialize()
+
+	return github.com/ipfs/go-block-format.block.NewBlockWithCid(data)
+}
+```
+
+These edited extracts from the `BlockHeader` show how it's treated as an IPFS block, `github.com/ipfs/go-block-format.block.BasicBlock`, to be both stored and referenced by its block storage CID.
+
+This duality permeates the code (and the Filecoin spec for that matter) but it is usually clear within the context to which block we are referring to. Normally the unqualified *block* is reserved for the Filecoin block and we won't usually refer to the IPFS one but only implicitly through the concept of its CID. With enough understanding of both stack's architecture the two definitions can coexist without much confusion as we will abstract away the IPFS layer and just use the CID as an identifier that we now its unique for two sequences of different *raw* byte strings.
+
+(FIXME: We use to do this presentation when talking about `gossipsub` topics and incoming blocks, and had to deal with, besides the block ambiguity, a similar confusion with the *message* term, used in libp2p to name anything that comes through the network, needing to present the extremely confusing hierarchy of a libp2p message containing a Filecoin block, identified by a IPFS block CID, containing Filecoin messages.)
+
+FIXME: Move the following tipset definition to sync or wherever is most needed, to avoid making this more confusing.
+
+Messages from the same round are collected into a block set (`chain/store/fts.go`):
+
+```Go
+type FullTipSet struct {
+	Blocks []*types.FullBlock
+	tipset *types.TipSet
+	cids   []cid.Cid
+}
+```
+
+The "tipset" denomination might be a bit misleading as it doesn't refer *only* to the tip, the block set from the last round in the chain, but to *any* set of blocks, depending on the context the tipset is the actual tip or not. From its own perspective any block set is always the tip because it assumes nothing from following blocks.
+
+# CLI, API
+
+Explain how do we communicate with the node, both in terms of the CLI and the programmatic way (to create our own tools).
+
+## Client/server architecture
+
+In terms of the Filecoin network the node is a peer on a distributed hierarchy, but in terms of how we interact with the node we have client/server architecture.
+
+The node itself was initiated with the `daemon` command, it already started syncing to the chain by default. Along with that service it also started a [JSON-RPC](https://en.wikipedia.org/wiki/JSON-RPC) server to allow a client to interact with it. (FIXME: Check if this client is local or can be remote, link to external documentation of connection API.)
+
+We can connect to this server through the Lotus CLI. Virtually any other command other than `daemon` will run a client that will connect (by default) to the address specified in the `api` file in the repo associated with the node (by default in `~/.lotus`), e.g.,
+
+```sh
+cat  ~/.lotus/api && echo
+# /ip4/127.0.0.1/tcp/1234/http
+
+# With `lotus daemon` running in another terminal.
+nc -v -z 127.0.0.1 1234 
+
+# Start daemon and turn off the logs to not clutter the command line.
+bash -c "lotus daemon &" &&
+  lotus wait-api &&
+  lotus log set-level error # Or a env.var in the daemon command.
+
+nc -v -z 127.0.0.1 1234
+# Connection to 127.0.0.1 1234 port [tcp/*] succeeded!
+
+killall lotus
+# FIXME: We need a lotus stop command:
+#  https://github.com/filecoin-project/lotus/issues/1827
+```
+
+FIXME: Link to more in-depth documentation of the CLI architecture, maybe some IPFS documentation (since they share some common logic).
+
+## Node API
+
+The JSON-RPC server exposes the node API, the `FullNode` interface (defined in `api/api_full.go`). When we issue a command like `lotus sync status` to query the progress of the node sync we don't access the node's internals, those are decoupled in a separate daemon process, we call the `SyncState` function (of the `FullNode` API interface) through the RPC client started by our own command (see `NewFullNodeRPC` in `api/client/client.go` for more details).
+
+FIXME: Link to (and create) documentation about API fulfillment.
+
+Because we rely heavily on reflection for this part of the code the call chain is not easily visible by just following the references through the symbolic analysis of the IDE. If we start by the `lotus sync` command definition (in `cli/sync.go`), we eventually end up in the method interface `SyncState`, and when we look for its implementation we will find two functions:
+
+* `(*SyncAPI).SyncState()` (in `node/impl/full/sync.go`): this is the actual implementation of the API function that shows what the node (here acting as the RPC server) will execute when it receives the RPC request issued from the CLI acting as the client.
+
+* `(*FullNodeStruct).SyncState()`: this is an "empty placeholder" structure that will get later connected to the JSON-RPC client logic (see `NewMergeClient` in `lib/jsonrpc/client.go`, which is called by `NewFullNodeRPC`). (FIXME: check if this is accurate). The CLI (JSON-RPC client) will actually execute this function which will connect to the server and send the corresponding JSON request that will trigger the call of `(*SyncAPI).SyncState()` with the node implementation.
+
+This means that when we are tracking the logic of a CLI command we will eventually find this bifurcation and need to study the code of the server-side implementation in `node/impl/full` (mostly in the `common/` and `full/` directories). If we understand this architecture going directly to that part of the code abstracts away the JSON-RPC client/server logic and we can think that the CLI is actually running the node's logic.
+
+FIXME: Explain that "*the* node" is actually an API structure like `impl.FullNodeAPI` with the different API subcomponents like `full.SyncAPI`. We won't see a *single* node structure, each API (full node, minder, etc) will gather the necessary subcomponents it needs to service its calls.
\ No newline at end of file
diff --git a/documentation/en/dev/create-miner.md b/documentation/en/dev/create-miner.md
new file mode 100644
index 000000000..7b3b81765
--- /dev/null
+++ b/documentation/en/dev/create-miner.md
@@ -0,0 +1,90 @@
+# Creating a storage miner
+
+This document explains the code flow of the [storage miner](https://filecoin-project.github.io/specs/#systems__filecoin_mining) creation process. It describes the flow on two dimensions: at the network level, from the local node to the rest of the Filecoin network, and at the VM level, from the CLI commands to the new chain state. It assumes the reader is already familiar with the general Lotus [architecture](architecture-2.md), relying especially on the descriptions of the CLI/API interface and the VM chain state.
+
+Note we are not following the [Storage Mining](https://lotu.sh/en+mining) user documentation where the miner is created along with the owner through the faucet, but we do those in separate stages try to exercise what will be the closest code path to Mainnet, using the `createStorageMiner()` call in the CLI (when `--actor` is not provided).
+
+FIXME: Check that all the information it assumes throughout this document is actually present in the main architecture doc.
+
+Topics with new information covered here (at different levels of detail) are:
+ * Addresses
+ * Wallet, key store
+ * Account actor
+ * Filecoin Message
+ * Storage node type
+ * Miner actor, owner and worker addresses
+ * Message generation and message pool
+ * Message execution in the VM
+ * Power actor
+ * PubSub/GossipSub
+
+## Wallet
+
+We start by creating a new wallet which will be associated with the miner. A "wallet" is just an abstraction over a Filecoin [address](https://filecoin-project.github.io/specs/#appendix__address) associated to an [account actor](https://filecoin-project.github.io/specs/#actor): an actor (object) in the VM that represents a user in the network.
+
+```
+lotus wallet new
+# t1ildao7vmywh67lolnd7esq7bqkfkhnalxsj74wq
+```
+
+The returned (random-looking) string is the address associated with the new wallet. The first part of the string encodes its [`Protocol`](https://github.com/filecoin-project/go-address/blob/master/address.go), in this case type 1 (`t1`), which corresponds to a public-key address generated from the [`secp256k1`](https://en.bitcoin.it/wiki/Secp256k1) elliptic curve (default option in the `wallet` command, alternatively it can also generate the [BLS](https://en.wikipedia.org/wiki/Boneh%E2%80%93Lynn%E2%80%93Shacham) signature scheme).
+
+At this point the address still hasn't been transmitted to the network, it is just reflected on the key store of our local node. The key store (by default in `~/.lotus/keystore/`) contains all the keys generated by this node, including this new key which will be set as the *default* and will be used by other commands (like the miner creation one). (See the [`WalletNew()`](https://github.com/filecoin-project/lotus/blob/master/chain/wallet/wallet.go) API for more information about key generation and storage.)
+
+It is important to note that the key store also holds the *private* key associated with the public one (that represent a Filecoin address) but this one is *never* transmitted over the network, it is just used locally to sign messages and prove this node is in possession of it and hence represents the account actor associated to the address/wallet.
+
+## Account actor
+
+There is no explicit Filecoin message or CLI command that creates an account actor but rather it is implicit in the public-key address reflected by the wallet. The first time the VM sees it as the receiving address of a Filecoin message it will automatically create the associated account actor.
+
+We will trigger its creation then by sending funds to it, needed for the creation of the storage miner (note this document reflects the Filecoin Testnet, where we actually don't need funds to create a miner but will do the full procedure regardless to show the full cycle). In the Testnet we can send funds to an account through the [Faucet](http://spacerace.faucet.glif.io/), inserting the address returned by the `wallet new` command.
+
+FIXME: Is there an easy way to visualize the message generated by the Faucet?
+
+## Storage miner node
+
+The `lotus-miner` command provides a set of tools to manage the miners associated with the local storage miner node. At this point it is important to note the different [node types](https://github.com/filecoin-project/lotus/blob/master/node/repo/fsrepo.go), in the previous document we always referred to a *single* local node, `FullNode`, which handled the sync process and any other communication with the Filecoin network (the term *full* stands for full validation of the consensus protocol, there are no *light* clients at the moment that do not do the full validation). We now create a new node of type [`StorageMiner`](https://github.com/filecoin-project/lotus/blob/master/node/repo/fsrepo.go), with its own repo (each node is always associated to its own repo), by default in `~/.lotusstorage`. The difference between the two nodes lies in the services they run (see build options in the main architecture document).
+
+The `lotus-miner init` command option creates a new storage miner node. We will only be able to run the command once the chain has been synced by the full node (which needs to be running) and it will also require the download of the [proof parameters](https://filecoin.io/blog/filecoin-proof-system/) (of several GBs, so it may take some time).
+
+The main options that define a miner are the owner and worker addresses associated to it (stored in [`MinerInfo`](https://github.com/filecoin-project/specs-actors/blob/master/actors/builtin/miner/miner_state.go), a substructure of the Miner Actor State) and its peer ID. We use default values for all of these options in the command and briefly described them here:
+
+* Owner: address of the account actor that manages this miner (receives its payments, can change its information, etc.). By default this option is set to the default wallet address (and associated account actor), in the case of this example it will be the address just created with the `wallet new` command.
+
+* Worker: address of an account actor that signs blocks and submits proofs associated with this miner, it can be the same as the owner address. By default the command will create a new wallet address for it, of type BLS (the only one accepted for worker addresses).
+
+* [Peer ID](https://docs.libp2p.io/reference/glossary/#peerid): a network ID (belonging to the `libp2p` stack) used to contact the miner directly off-chain (e.g., to make a storage deal). Note the difference with the rest of the communication in the Filecoin network that happens largely inside the chain itself: when we "send" messages to the different actors that is actually a VM abstraction meaning we execute the method in the VM itself run by logic of the targeted actor, physically (at the network TCP/IP level) we broadcast the message to all of our peers to be included in a Filecoin block.
+
+With the miner information filled the command constructs a Filecoin message to broadcast to the network and be included in a Filecoin block by a miner (see [`createStorageMiner()`](https://github.com/filecoin-project/lotus/blob/master/cmd/lotus-miner/init.go)). We will wait for that block to be synced to the chain (by the full node) before returning the miner ID address. The ID address is another way to refer to the miner through a unique ID in the chain, it has a type 0 and it is the address that is normally seen in chain visualization tools, e.g., `t01475` (since, in contrast with the public-key types of addresses, it is easily readable by humans).
+
+The Filecoin message constructed will be targeted to the [Power Actor](https://filecoin-project.github.io/specs/#systems__filecoin_blockchain__storage_power_consensus__storage_power_actor) (`StoragePowerActorAddr`), which tracks the amount of power (storage capacity) every miner has, and it will have the method number of the [`CreateMiner`](https://github.com/filecoin-project/specs-actors/blob/master/actors/builtin/methods.go) constant.
+
+## Message broadcast
+
+At the network level, the message (to be included in a block) is sent through the [message pool](https://filecoin-project.github.io/specs/#systems__filecoin_blockchain__message_pool) to the miners. The message pool is an abstraction over `libp2p`'s [PubSub protocol](https://docs.libp2p.io/reference/glossary/#pubsub), a communication pattern where peers subscribe to a topic (an identifying string) and other peers publish to it (broadcasting to all the subscribed peers it has registered). (Particularly in Lotus we use the [GossipSub](https://github.com/libp2p/specs/blob/master/pubsub/gossipsub/README.md) implementation of that protocol.) In this case the topic we publish to is [`/fil/msgs`](https://github.com/filecoin-project/lotus/blob/master/build/params_shared.go), to which the miners will be subscribed and will receive, validate and process the message (see [`HandleIncomingMessages`](https://github.com/filecoin-project/lotus/blob/master/node/modules/services.go) in the [miner node construction](https://github.com/filecoin-project/lotus/blob/master/node/builder.go) for more details).
+
+It is of interest to note that the GossipSub protocol is the same that miners themselves use to publish mined blocks in the `/fil/blocks` topic, to which the full node is subscribed to, used in the sync process (along with the `hello` protocol described in the architecture doc).
+
+Back to the CLI command, the [`MpoolPushMessage`](https://github.com/filecoin-project/lotus/blob/master/node/impl/full/mpool.go) API in the full node takes care of populating the rest of the Filecoin message (e.g., inserting the correct nonce) and serializing it before actually publishing to the GossipSub network. After that, it explicitly waits for the message to be included by a miner in a block and then for that block to reach the chain where the full node will receive it as part of the sync process (see [`StateWaitMsg`](https://github.com/filecoin-project/lotus/blob/master/node/impl/full/state.go)), checking its return code for success and its return value for the miner ID.
+
+## VM: message execution
+
+We describe here the code flow inside the VM when it executes the `CreateMiner` method (of the message sent by the `lotus-miner` command included by a miner in a block). This execution will be the same seen by all participants in the Filecoin protocol, the miner including the message in the block, the full node syncing to it, and any other peer receiving also this message.
+
+There is a one-to-one mapping between the pair of actor and method number (`To:`/`Method:` fields) in a message in the VM, and the Go function in an actor's exported methods list that implement it. In this case, for the Power Actor list of method numbers defined in [`MethodsPower`](https://github.com/filecoin-project/specs-actors/blob/master/actors/builtin/methods.go), the `CreateMiner` method number 2 will correspond to the Go function with the same index in the list of methods returned by [`Exports()`](https://github.com/filecoin-project/specs-actors/blob/master/actors/builtin/power/power_actor.go) (and normally also the same name, here `(Actor).CreateMiner()`).
+
+The Power Actor in `CreateMiner()` will do two things:
+
+1. Send *another* message, `Exec`, to the Init Actor to instruct it to create the miner actor with the information provided by `lotus-miner` and receive its ID address (this ID is the one returned to the CLI command).
+
+2. Generate an entry in its list of power claims ([`State.Claims`](https://github.com/filecoin-project/specs-actors/blob/master/actors/builtin/power/power_state.go)) for the newly created ID address of the miner.
+
+### Init Actor: create a new actor
+
+The [`Init`](https://github.com/filecoin-project/specs-actors/blob/master/actors/builtin/init/init_actor.go) actor is the only way to create actors (besides the initial actors included in the genesis block). It has a single method (besides its own constructor), `Exec`. An actor is nothing more than an entry in the `Init`'s [`State.AddressMap`](https://github.com/filecoin-project/specs-actors/blob/master/actors/builtin/init/init_actor_state.go), a [HAMT](https://en.wikipedia.org/wiki/Hash_array_mapped_trie) that maps an ([`Actor`](https://github.com/filecoin-project/specs-actors/blob/master/vendor/github.com/filecoin-project/go-address/address.go)) address to an ID one. The `Actor` address is a unique address provided by the `Runtime` ([`NewActorAddress()`](https://github.com/filecoin-project/lotus/blob/master/chain/vm/runtime.go)) derived from the public key of the message's origin address, in this case the `--owner` defined in the CLI command.
+
+### Miner Actor: constructor
+
+The Init actor will also call the constructor for the type of actor it created, in this case a [Miner](https://github.com/filecoin-project/specs-actors/blob/master/actors/builtin/miner/miner_actor.go). The constructor is always the method numbered 1 for any actor.
+
+FIXME: Do we want to say anything about the constructor? The setting of the proving period? Everything else seems like default values.
diff --git a/documentation/en/environment-vars.md b/documentation/en/environment-vars.md
new file mode 100644
index 000000000..9d455a74d
--- /dev/null
+++ b/documentation/en/environment-vars.md
@@ -0,0 +1,65 @@
+# Lotus Environment Variables
+
+## Building
+
+## Common
+
+The environment variables are common across most lotus binaries.
+
+### `LOTUS_FD_MAX`
+
+Sets the file descriptor limit for the process. This should be set high (8192
+or higher) if you ever notice 'too many open file descriptor' errors.
+
+### `LOTUS_JAEGER`
+
+This can be set to enable jaeger trace reporting. The value should be the url
+of the jaeger trace collector, the default for most jaeger setups should be
+`localhost:6831`.
+
+### `LOTUS_DEV`
+
+If set to a non-empty value, certain parts of the application will print more
+verbose information to aid in development of the software. Not recommended for
+end users.
+
+## Lotus Daemon
+
+### `LOTUS_PATH`
+
+Sets the location for the lotus daemon on-disk repo. If left empty, this defaults to `~/.lotus`.
+
+### `LOTUS_SKIP_GENESIS_CHECK`
+
+Can be set to `_yes_` if you wish to run a lotus network with a different
+genesis than the default one built into your lotus binary.
+
+### `LOTUS_CHAIN_TIPSET_CACHE`
+
+Sets the cache size for the chainstore tipset cache. The default value is 8192,
+but if your usage of the lotus API involves frequent arbitrary tipset lookups,
+you may want to increase this.
+
+### `LOTUS_CHAIN_INDEX_CACHE`
+
+Sets the cache size for the chainstore epoch index cache. The default value is 32768,
+but if your usage of the lotus API involves frequent deep chain lookups for
+block heights that are very far from the current chain height, you may want to
+increase this.
+
+
+### `LOTUS_BSYNC_MSG_WINDOW`
+
+Set the initial maximum window size for message fetching blocksync requests. If
+you have a slower internet connection and are having trouble syncing, you might
+try lowering this down to 10-20 for a 'poor' internet connection.
+
+## Lotus Miner
+
+A number of environment variables are respected for configuring the behavior of the filecoin proving subsystem. For more details on those [see here](https://github.com/filecoin-project/rust-fil-proofs/#settings).
+
+### `LOTUS_MINER_PATH`
+
+Sets the location for the lotus miners on-disk repo. If left empty, this defaults to `~/.lotusminer`.
+
+
diff --git a/documentation/en/faqs.md b/documentation/en/faqs.md
new file mode 100644
index 000000000..c2d526830
--- /dev/null
+++ b/documentation/en/faqs.md
@@ -0,0 +1,138 @@
+# Frequently Asked Questions
+
+Here are some FAQs concerning the Lotus implementation and participation in 
+Testnet.
+For questions concerning the broader Filecoin project, please 
+go [here](https://filecoin.io/faqs/).
+
+## Introduction to Lotus
+
+### What is Lotus?
+
+Lotus is an implementation of the **Filecoin Distributed Storage Network**, written in Go. 
+It is designed to be modular and interoperable with any other implementation of the Filecoin Protocol.
+More information about Lotus can be found [here](https://lotu.sh/).
+
+### What are the components of Lotus?
+
+Lotus is composed of two separate pieces that can talk to each other:
+
+The Lotus Node can sync the blockchain, validating all blocks, transfers, and deals
+along the way. It can also facilitate the creation of new storage deals. If you are not 
+interested in providing your own storage to the network, and do not want to produce blocks
+yourself, then the Lotus Node is all you need!
+
+The Lotus Miner does everything you need for the registration of storage, and the
+production of new blocks. The Lotus Miner communicates with the network by talking 
+to a Lotus Node over the JSON-RPC API.
+
+## Setting up a Lotus Node
+
+### How do I set up a Lotus Node?
+
+Follow the instructions found [here](https://lotu.sh/en+getting-started).
+
+### Where can I get the latest version of Lotus?
+
+Download the binary tagged as the `Latest Release` from the
+ [Lotus Github repo](https://github.com/filecoin-project/lotus/releases).
+ 
+### What operating systems can Lotus run on?
+
+Lotus can build and run on most Linux and MacOS systems with at least 
+8GB of RAM. Windows is not yet supported.
+
+### How can I update to the latest version of Lotus?
+
+To update Lotus, follow the instructions [here](https://lotu.sh/en+updating-lotus).
+
+### How do I prepare a fresh installation of Lotus?
+
+Stop the Lotus daemon, and delete all related files, including sealed and chain data by 
+running `rm ~/.lotus ~/.lotusminer`.
+
+Then, install Lotus afresh by following the instructions 
+found [here](https://lotu.sh/en+getting-started).
+
+### Can I configure where the node's config and data goes?
+
+Yes! The `LOTUS_PATH` variable sets the path for where the Lotus node's data is written.
+The `LOTUS_MINER_PATH` variable does the same for miner-specific information.
+
+## Interacting with a Lotus Node
+
+### How can I communicate with a Lotus Node?
+
+Lotus Nodes have a command-line interface, as well as a JSON-RPC API.
+
+### What are the commands I can send using the command-line interface? 
+
+The command-line interface is self-documenting, try running `lotus --help` from the `lotus` home 
+directory for more.
+
+### How can I send a request over the JSON-RPC API?
+
+Information on how to send a `cURL` request to the JSON-RPC API can be found
+[here](https://lotu.sh/en+api). A JavaScript client is under development.
+
+### What are the requests I can send over the JSON-RPC API?
+
+Please have a look at the 
+[source code](https://github.com/filecoin-project/lotus/blob/master/api/api_full.go) 
+for a list of methods supported by the JSON-RPC API.
+## The Test Network
+
+### What is Testnet?
+
+Testnet is a live network of Lotus Nodes run by the 
+community for testing purposes.
+ It has 2 PiB of storage (and growing!) dedicated to it.
+
+### Is FIL on the Testnet worth anything?
+
+Nothing at all! Real-world incentives may be provided in a future phase of Testnet, but this is 
+yet to be confirmed.
+
+### How can I see the status of Testnet?
+
+The [dashboard](https://stats.testnet.filecoin.io/) displays the status of the network as 
+well as a ton
+of other metrics you might find interesting.
+
+## Mining with a Lotus Node on Testnet
+
+### How do I get started mining with Lotus?
+
+Follow the instructions found [here](https://lotu.sh/en+mining).
+
+### What are the minimum hardware requirements?
+
+An example test configuration, and minimum hardware requirements can be found 
+[here](https://lotu.sh/en+hardware-mining). 
+
+Note that these might NOT be the minimum requirements for mining on Mainnet.
+
+### What are some GPUs that have been tested?
+
+A list of benchmarked GPUs can be found [here](https://lotu.sh/en+hardware-mining#benchmarked-gpus-7393).
+
+### Why is my GPU not being used when sealing a sector?
+
+Sealing a sector does not involve constant GPU operations. It's possible
+that your GPU simply isn't necessary at the moment you checked.
+
+## Advanced questions
+
+### Is there a Docker image for lotus?
+
+Community-contributed Docker and Docker Compose examples are available 
+[here](https://github.com/filecoin-project/lotus/tree/master/tools/dockers/docker-examples).
+
+### How can I run two miners on the same machine?
+
+You can do so by changing the storage path variable for the second miner, e.g.,
+`LOTUS_MINER_PATH=~/.lotusminer2`. You will also need to make sure that no ports collide.
+
+### How do I setup my own local devnet?     
+
+Follow the instructions found [here](https://lotu.sh/en+setup-local-dev-net).
diff --git a/documentation/en/getting-started.md b/documentation/en/getting-started.md
index a1c3e0ac5..e38a2ab97 100644
--- a/documentation/en/getting-started.md
+++ b/documentation/en/getting-started.md
@@ -2,22 +2,22 @@
 
 Lotus is an implementation of the **Filecoin Distributed Storage Network**. You can run the Lotus software client to join the **Filecoin Testnet**.
 
-For more details about Filecoin, check out the [Filecoin Spec](https://github.com/filecoin-project/specs).
+For more details about Filecoin, check out the [Filecoin Docs](https://docs.filecoin.io) and [Filecoin Spec](https://filecoin-project.github.io/specs/).
 
 ## What can I learn here?
 
-- How to install Lotus on [Arch Linux](https://docs.lotu.sh/en+install-lotus-arch), [Ubuntu](https://docs.lotu.sh/en+install-lotus-ubuntu), or [MacOS](https://docs.lotu.sh/en+install-lotus-macos).
-- Joining the [Lotus Testnet](https://docs.lotu.sh/en+join-testnet).
-- [Storing](https://docs.lotu.sh/en+storing-data) or [retrieving](https://docs.lotu.sh/en+retrieving-data) data.
-- Mining Filecoin using the **Lotus Storage Miner** in your [CLI](https://docs.lotu.sh/en+mining).
+- How to install Lotus on [Arch Linux](https://lotu.sh/en+install-lotus-arch), [Ubuntu](https://lotu.sh/en+install-lotus-ubuntu), or [MacOS](https://lotu.sh/en+install-lotus-macos).
+- Joining the [Lotus Testnet](https://lotu.sh/en+join-testnet).
+- [Storing](https://lotu.sh/en+storing-data) or [retrieving](https://lotu.sh/en+retrieving-data) data.
+- Mining Filecoin using the **Lotus Miner** in your [CLI](https://lotu.sh/en+mining).
 
-## What makes Lotus different?
+## How is Lotus designed?
 
 Lotus is architected modularly to keep clean API boundaries while using the same process. Installing Lotus will include two separate programs:
 
 - The **Lotus Node**
-- The **Lotus Storage Miner**
+- The **Lotus Miner**
 
-The **Lotus Storage Miner** is intended to be run on the machine that manages a single storage miner instance, and is meant to communicate with the **Lotus Node** via the websocket **JSON-RPC** API for all of the chain interaction needs.
+The **Lotus Miner** is intended to be run on the machine that manages a single miner instance, and is meant to communicate with the **Lotus Node** via the websocket **JSON-RPC** API for all of the chain interaction needs.
 
-This way, a mining operation may easily run a **Lotus Storage Miner** or many of them, connected to one or many **Lotus Node** instances.
+This way, a mining operation may easily run a **Lotus Miner** or many of them, connected to one or many **Lotus Node** instances.
diff --git a/documentation/en/hardware-mining.md b/documentation/en/hardware-mining.md
index 16bffaf9c..d421f6fb1 100644
--- a/documentation/en/hardware-mining.md
+++ b/documentation/en/hardware-mining.md
@@ -1,6 +1,6 @@
 # Protocol Labs Standard Testing Configuration
 
-> This documentation page describes the standard testing configuration the Protocol Labs team has used to test **Lotus Storage Miner**s on Lotus. There is no guarantee this testing configuration will be suitable for Filecoin storage mining at MainNet launch. If you need to buy new hardware to join the Filecoin Testnet, we recommend to buy no more hardware than you require for testing. To learn more please read this [Protocol Labs Standard Testing Configuration post](https://filecoin.io/blog/filecoin-testnet-mining/).
+> This documentation page describes the standard testing configuration the Protocol Labs team has used to test **Lotus Miner**s on Lotus. There is no guarantee this testing configuration will be suitable for Filecoin storage mining at MainNet launch. If you need to buy new hardware to join the Filecoin Testnet, we recommend to buy no more hardware than you require for testing. To learn more please read this [Protocol Labs Standard Testing Configuration post](https://filecoin.io/blog/filecoin-testnet-mining/).
 
 **Sector sizes** and **minimum pledged storage** required to mine blocks are two very important Filecoin Testnet parameters that impact hardware decisions. We will continue to refine all parameters during Testnet.
 
@@ -16,6 +16,8 @@ The setup below is a minimal example for sealing 32 GiB sectors on Lotus:
 
 Note that 1GB sectors don't require as high of specs, but are likely to be removed as we improve the performance of 32GB sector sealing.
 
+For the first part of the sealing process, AMD CPU's are __highly recommended__, because of the `Intel SHA Extensions` instruction set that is available there ever since the `Zen` microarchitecture. Hence, AMD CPU's seem to perform much better on the testnet than other CPU's. Contrary to what the name implies, this extended instruction set is not available on recent Intel desktop/server chips. 
+
 ## Testnet discoveries
 
 - If you only have 128GiB of ram, enabling 256GB of **NVMe** swap on an SSD will help you avoid out-of-memory issues while mining.
@@ -33,7 +35,7 @@ GPUs are a must for getting **block rewards**. Here are a few that have been con
 
 ## Testing other GPUs
 
-If you want to test a GPU that is not explicitly supported, use the following global**environment variable**:
+If you want to test a GPU that is not explicitly supported, use the following global **environment variable**:
 
 ```sh
 BELLMAN_CUSTOM_GPU="<NAME>:<NUMBER_OF_CORES>"
@@ -49,4 +51,4 @@ To get the number of cores for your GPU, you will need to check your card’s sp
 
 ## Benchmarking
 
-Here is a [benchmarking tool](https://github.com/filecoin-project/lotus/tree/testnet-staging/cmd/lotus-bench) and a [GitHub issue thread](https://github.com/filecoin-project/lotus/issues/694) for those who wish to experiment with and contribute hardware setups for the **Filecoin Testnet**.
+Here is a [benchmarking tool](https://github.com/filecoin-project/lotus/tree/master/cmd/lotus-bench) and a [GitHub issue thread](https://github.com/filecoin-project/lotus/issues/694) for those who wish to experiment with and contribute hardware setups for the **Filecoin Testnet**.
diff --git a/documentation/en/install-lotus-arch.md b/documentation/en/install-lotus-arch.md
index 4927d063b..8e06aae4e 100644
--- a/documentation/en/install-lotus-arch.md
+++ b/documentation/en/install-lotus-arch.md
@@ -2,7 +2,7 @@
 
 These steps will install the following dependencies:
 
-- go (1.13 or higher)
+- go (1.14 or higher)
 - gcc (7.4.0 or higher)
 - git (version 2 or higher)
 - bzr (some go dependency needs this)
@@ -15,30 +15,37 @@ These steps will install the following dependencies:
 - llvm (proofs build)
 - clang (proofs build)
 
-Run
+### Install dependencies
 
 ```sh
-sudo pacman -Syu opencl-icd-loader
+sudo pacman -Syu opencl-icd-loader gcc git bzr jq pkg-config opencl-icd-loader opencl-headers
 ```
 
-Build
+### Install Go 1.14
 
-```sh
-sudo pacman -Syu go gcc git bzr jq pkg-config opencl-icd-loader opencl-headers
-```
+Install the latest version of Go by following [the docs on their website](https://golang.org/doc/install).
 
-Clone
+### Clone the Lotus repository
 
 ```sh
 git clone https://github.com/filecoin-project/lotus.git
 cd lotus/
 ```
 
-Install
+### Build the Lotus binaries from source and install
+
+! **If you are running an AMD platform or if your CPU supports SHA extensions you will want to build the Filecoin proofs natively**
 
 ```sh
 make clean && make all
 sudo make install
 ```
 
-After installing Lotus, you can run the `lotus` command directly from your CLI to see usage documentation. Next, you can join the [Lotus Testnet](https://docs.lotu.sh/en+join-testnet).
+#### Native Filecoin FFI building
+
+```sh
+env env RUSTFLAGS="-C target-cpu=native -g" FFI_BUILD_FROM_SOURCE=1 make clean deps all
+sudo make install
+```
+
+After installing Lotus, you can run the `lotus` command directly from your CLI to see usage documentation. Next, you can join the [Lotus Testnet](https://lotu.sh/en+join-testnet).
diff --git a/documentation/en/install-lotus-fedora.md b/documentation/en/install-lotus-fedora.md
index 9f5864496..c37161b7a 100644
--- a/documentation/en/install-lotus-fedora.md
+++ b/documentation/en/install-lotus-fedora.md
@@ -6,7 +6,7 @@
 
 These steps will install the following dependencies:
 
-- go (1.13 or higher)
+- go (1.14 or higher)
 - gcc (7.4.0 or higher)
 - git (version 2 or higher)
 - bzr (some go dependency needs this)
@@ -16,26 +16,39 @@ These steps will install the following dependencies:
 - llvm (proofs build)
 - clang (proofs build)
 
-Run
+### Install dependencies
 
 ```sh
 $ sudo dnf -y update
-$ sudo dnf -y install go gcc git bzr jq pkgconfig mesa-libOpenCL mesa-libOpenCL-devel opencl-headers ocl-icd ocl-icd-devel clang llvm
+$ sudo dnf -y install gcc git bzr jq pkgconfig mesa-libOpenCL mesa-libOpenCL-devel opencl-headers ocl-icd ocl-icd-devel clang llvm
 $ curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
 ```
 
-Clone
+### Install Go 1.14
+
+Install the latest version of Go by following [the docs on their website](https://golang.org/doc/install).
+
+### Clone the Lotus repository
 
 ```sh
 git clone https://github.com/filecoin-project/lotus.git
 cd lotus/
 ```
 
-Install
+### Build the Lotus binaries from source and install
+
+! **If you are running an AMD platform or if your CPU supports SHA extensions you will want to build the Filecoin proofs natively**
 
 ```sh
 $ make clean && make all
 $ sudo make install
 ```
 
-After installing Lotus, you can run the `lotus` command directly from your CLI to see usage documentation. Next, you can join the [Lotus TestNet](https://docs.lotu.sh/en+join-testnet).
+#### Native Filecoin FFI building
+
+```sh
+env env RUSTFLAGS="-C target-cpu=native -g" FFI_BUILD_FROM_SOURCE=1 make clean deps all
+sudo make install
+```
+
+After installing Lotus, you can run the `lotus` command directly from your CLI to see usage documentation. Next, you can join the [Lotus TestNet](https://lotu.sh/en+join-testnet).
diff --git a/documentation/en/install-lotus-macos.md b/documentation/en/install-lotus-macos.md
index f4afa67b5..371832c96 100644
--- a/documentation/en/install-lotus-macos.md
+++ b/documentation/en/install-lotus-macos.md
@@ -59,4 +59,4 @@ make clean && make all
 sudo make install
 ```
 
-After installing Lotus, you can run the `lotus` command directly from your CLI to see usage documentation. Next, you can join the [Lotus Testnet](https://docs.lotu.sh/en+join-testnet).
+After installing Lotus, you can run the `lotus` command directly from your CLI to see usage documentation. Next, you can join the [Lotus Testnet](https://lotu.sh/en+join-testnet).
diff --git a/documentation/en/install-lotus-ubuntu.md b/documentation/en/install-lotus-ubuntu.md
index 236033794..500650692 100644
--- a/documentation/en/install-lotus-ubuntu.md
+++ b/documentation/en/install-lotus-ubuntu.md
@@ -2,7 +2,7 @@
 
 These steps will install the following dependencies:
 
-- go (1.13 or higher)
+- go (1.14 or higher)
 - gcc (7.4.0 or higher)
 - git (version 2 or higher)
 - bzr (some go dependency needs this)
@@ -15,33 +15,40 @@ These steps will install the following dependencies:
 - llvm (proofs build)
 - clang (proofs build)
 
-Run
+### Install dependencies
 
 ```sh
 sudo apt update
-sudo apt install mesa-opencl-icd ocl-icd-opencl-dev
+sudo apt install mesa-opencl-icd ocl-icd-opencl-dev gcc git bzr jq pkg-config curl
+sudo apt upgrade
 ```
 
-Build
+### Install Go 1.14
 
-```sh
-sudo add-apt-repository ppa:longsleep/golang-backports
-sudo apt update
-sudo apt install golang-go gcc git bzr jq pkg-config mesa-opencl-icd ocl-icd-opencl-dev
-```
+Install the latest version of Go by following [the docs on their website](https://golang.org/doc/install).
 
-Clone
+### Clone the Lotus repository
 
 ```sh
 git clone https://github.com/filecoin-project/lotus.git
 cd lotus/
 ```
 
-Install
+### Build the Lotus binaries from source and install
+
+! **If you are running an AMD platform or if your CPU supports SHA extensions you will want to build the Filecoin proofs natively**
 
 ```sh
 make clean && make all
 sudo make install
 ```
 
-After installing Lotus, you can run the `lotus` command directly from your CLI to see usage documentation. Next, you can join the [Lotus Testnet](https://docs.lotu.sh/en+join-testnet).
+#### Native Filecoin FFI building
+
+```sh
+env env RUSTFLAGS="-C target-cpu=native -g" FFI_BUILD_FROM_SOURCE=1 make clean deps all
+sudo make install
+```
+
+
+After installing Lotus, you can run the `lotus` command directly from your CLI to see usage documentation. Next, you can join the [Lotus Testnet](https://lotu.sh/en+join-testnet).
diff --git a/documentation/en/install-systemd-services.md b/documentation/en/install-systemd-services.md
new file mode 100644
index 000000000..3ce52acdf
--- /dev/null
+++ b/documentation/en/install-systemd-services.md
@@ -0,0 +1,145 @@
+# Use Lotus with systemd
+
+Lotus is capable of running as a systemd service daemon. You can find installable service files for systemd in the [lotus repo scripts directory](https://github.com/filecoin-project/lotus/tree/master/scripts) as files with `.service` extension. In order to install these service files, you can copy these `.service` files to the default systemd unit load path.
+
+The services expect their binaries to be present in `/usr/local/bin/`. You can use `make` to install them by running:
+
+```sh
+$ sudo make install
+```
+
+for `lotus` and `lotus-miner` and 
+
+```sh
+$ sudo make install-chainwatch
+```
+
+for the `chainwatch` tool.
+
+## Installing services via `make`
+
+If your host uses the default systemd unit load path, the `lotus-daemon` and `lotus-miner` services can be installed by running:
+
+```sh
+$ sudo make install-services
+```
+
+To install the the `lotus-chainwatch` service run:
+
+```sh
+$ sudo make install-chainwatch-service
+```
+
+You can install all services together by running:
+
+```sh
+$ sudo make install-all-services
+```
+
+The `lotus-daemon` and the `lotus-miner` services can be installed individually too by running:
+
+```sh
+$ sudo make install-daemon-service
+```
+
+and 
+
+```sh
+$ sudo make install-miner-service
+```
+
+### Notes
+
+When installing the `lotus-miner` and/or `lotus-chainwatch` service the `lotus-daemon` service gets automatically installed since the other two services depend on it being installed to run.
+
+All `install-*-service*` commands will install the latest binaries in the lotus build folders to `/usr/local/bin/`. If you do not want to use the latest build binaries please copy the `*.service` files by hand.
+
+## Removing via `make`
+
+All services can beremoved via `make`. To remove all services together run:
+
+```sh
+$ sudo make clean-all-services
+```
+
+Individual services can be removed by running:
+
+```sh
+$ sudo make clean-chainwatch-services
+$ sudo make clean-miner-services
+$ sudo make clean-daemon-services
+```
+
+### Notes
+
+The services will be stoppend and disabled when removed.
+
+Removing the `lotus-daemon` service will automatically remove the depending services `lotus-miner` and `lotus-chainwatch`.
+
+
+## Controlling services
+
+All service can be controlled with the `systemctl`. A few basic control commands are listed below. To get detailed infos about the capabilities of the `systemctl` command please consult your distributions man pages by running: 
+
+```sh
+$ man systemctl
+```
+
+### Start/Stop services
+
+You can start the services by running:
+
+```sh
+$ sudo systemctl start lotus-daemon
+$ sudo systemctl start lotus-miner
+$ sudo systemctl start lotus-chainwatch
+```
+
+and can be stopped by running:
+
+```sh
+$ sudo systemctl stop lotus-daemon
+$ sudo systemctl stop lotus-miner
+$ sudo systemctl stop lotus-chainwatch
+```
+
+### Enabling services on startup
+
+To enable the services to run automatically on startup execute:
+
+```sh
+$ sudo systemctl enable lotus-daemon
+$ sudo systemctl enable lotus-miner
+$ sudo systemctl enable lotus-chainwatch
+```
+
+To disable the services on startup run:
+
+```sh
+$ sudo systemctl disable lotus-daemon
+$ sudo systemctl disable lotus-miner
+$ sudo systemctl disable lotus-chainwatch
+```
+### Notes
+
+Systemd will not let services be enabled or started without their requirements. Starting the `lotus-chainwatch` and/or `lotus-miner` service with automatically start the `lotus-daemon` service (if installed!). Stopping the `lotus-daemon` service will stop the other two services. The same pattern is executed for enabling and disabling the services. 
+
+## Interacting with service logs
+
+Logs from the services can be reviewed using `journalctl`.
+
+### Follow logs from a specific service unit
+
+```sh
+$ sudo journalctl -u lotus-daemon -f
+```
+
+### View logs in reverse order
+
+```sh
+$ sudo journalctl -u lotus-miner -r
+```
+
+### Log files
+
+Besides the systemd service logs all services save their own log files in `/var/log/lotus/`.
diff --git a/documentation/en/join-testnet.md b/documentation/en/join-testnet.md
index ae97db49f..6660d26d8 100644
--- a/documentation/en/join-testnet.md
+++ b/documentation/en/join-testnet.md
@@ -4,18 +4,12 @@
 
 Anyone can set up a **Lotus Node** and connect to the **Lotus Testnet**. This is the best way to explore the current CLI and the **Filecoin Decentralized Storage Market**.
 
-If you have installed older versions, you may need to clear existing chain data, stored wallets and miners if you run into any errors. You can use this command:
-
-```sh
-rm -rf ~/.lotus ~/.lotusstorage
-```
-
 ## Note: Using the Lotus Node from China
 
 If you are trying to use `lotus` from China. You should set this **environment variable** on your machine:
 
 ```sh
-IPFS_GATEWAY="https://proof-parameters.s3.cn-south-1.jdcloud-oss.com/ipfs/"
+export IPFS_GATEWAY="https://proof-parameters.s3.cn-south-1.jdcloud-oss.com/ipfs/"
 ```
 
 ## Get started
@@ -32,36 +26,40 @@ In another terminal window, check your connection with peers:
 lotus net peers | wc -l
 ```
 
-In order to connect to the network, you need to be connected to at least 1 peer. If you’re seeing 0 peers, read our [troubleshooting notes](https://docs.lotu.sh/en+setup-troubleshooting).
+In order to connect to the network, you need to be connected to at least 1 peer. If you’re seeing 0 peers, read our [troubleshooting notes](https://lotu.sh/en+setup-troubleshooting).
+
+Make sure that you have a reasonable "open files limit" set on your machine, such as 10000. If you're seeing a lower value, such as 256 (default on macOS), read our [troubleshooting notes](https://lotu.sh/en+setup-troubleshooting) on how to update it prior to starting the Lotus daemon.
 
 ## Chain sync
 
-While the daemon is running, the next requirement is to sync the chain. Run the command below to start the chain sync progress. To see current chain height, visit the [network stats page](http://stats.testnet.filecoin.io/).
+While the daemon is running, the next requirement is to sync the chain. Run the command below to view the chain sync progress. To see current chain height, visit the [network stats page](https://stats.testnet.filecoin.io/).
 
 ```sh
 lotus sync wait
 ```
 
-- This step will take anywhere between 30 minutes to a few hours.
+- This step will take anywhere between a few hours to a couple of days.
 - You will be able to perform **Lotus Testnet** operations after it is finished.
 
 ## Create your first address
 
-Initialize a wallet using BLS signature formats:
+Initialize a new wallet:
 
 ```sh
-lotus wallet new bls
+lotus wallet new
 ```
 
+Sometimes your operating system may limit file name length to under 150 characters. You need to use a file system that supports long filenames.
+
 Here is an example of the response:
 
 ```sh
-t3vhfme4qfvegqaz7m7q6o6afjcs67n6kpzv7t2eozio4chwpafwa2y4l7zhwd5eom7jmihzdg4s52dpvnclza
+t1aswwvjsae63tcrniz6x5ykvsuotlgkvlulnqpsi
 ```
 
-- Visit the [faucet](https://lotus-faucet.kittyhawk.wtf/funds.html) to add funds.
-- Paste the address you created.
-- Press the send button.
+- Visit the [faucet](http://spacerace.faucet.glif.io/) to add funds.
+- Paste the address you created under REQUEST.
+- Press the Request button.
 
 ## Check wallet address balance
 
@@ -75,12 +73,21 @@ You will not see any attoFIL in your wallet if your **chain** is not fully synce
 
 ## Send FIL to another wallet
 
-To send FIL to another wallet, use this command:
+To send FIL to another wallet from your default account, use this command:
 
 ```
 lotus send <target> <amount>
 ```
 
+## Configure your node's connectivity
+
+To effectively accept incoming storage & retrieval deals, your Lotus node needs to be accessible to other nodes on the network. To improve your connectivity, be sure to: 
+
+- [Set the multiaddresses for you miner to listen on](https://docs.filecoin.io/mine/connectivity/#setting-multiaddresses)
+- [Maintain a healthy peer count](https://docs.filecoin.io/mine/connectivity/#checking-peer-count)
+- [Enable port forwarding](https://docs.filecoin.io/mine/connectivity/#port-forwarding)
+- [Configure your public IP address and port](https://docs.filecoin.io/mine/connectivity/#setting-a-public-ip-address)
+
 ## Monitor the dashboard
 
 To see the latest network activity, including **chain block height**, **block height**, **blocktime**, **total network power**, largest **block producer miner**, check out the [monitoring dashboard](https://stats.testnet.filecoin.io).
diff --git a/documentation/en/local-dev-net.md b/documentation/en/local-dev-net.md
index 19b1c52db..3382b6471 100644
--- a/documentation/en/local-dev-net.md
+++ b/documentation/en/local-dev-net.md
@@ -1,33 +1,54 @@
 # Setup Local Devnet
 
-Build the Lotus Binaries in debug mode, This enables the use of 1024 byte sectors.
+Build the Lotus Binaries in debug mode, This enables the use of 2048 byte sectors.
 
 ```sh
-make debug
+make 2k
+```
+
+Set the `LOTUS_SKIP_GENESIS_CHECK` environment variable to `_yes_`. This tells your
+Lotus node that it's okay if the genesis being used doesn't match any baked-in
+genesis.
+
+```sh
+export LOTUS_SKIP_GENESIS_CHECK=_yes_
+```
+
+Download the 2048 byte parameters:
+```sh
+./lotus fetch-params 2048
 ```
 
 Pre-seal some sectors:
 
 ```sh
-./lotus-seed pre-seal --sector-size 1024 --num-sectors 2
+./lotus-seed pre-seal --sector-size 2KiB --num-sectors 2
 ```
 
 Create the genesis block and start up the first node:
 
 ```sh
-./lotus daemon --lotus-make-random-genesis=dev.gen --genesis-presealed-sectors=~/.genesis-sectors/pre-seal-t0101.json --bootstrap=false
+./lotus-seed genesis new localnet.json
+./lotus-seed genesis add-miner localnet.json ~/.genesis-sectors/pre-seal-t01000.json
+./lotus daemon --lotus-make-genesis=devgen.car --genesis-template=localnet.json --bootstrap=false
+```
+
+Then, in another console, import the genesis miner key:
+
+```sh
+./lotus wallet import --as-default ~/.genesis-sectors/pre-seal-t01000.key
 ```
 
 Set up the genesis miner:
 
 ```sh
-./lotus-storage-miner init --genesis-miner --actor=t0101 --sector-size=1024 --pre-sealed-sectors=~/.genesis-sectors --nosync
+./lotus-miner init --genesis-miner --actor=t01000 --sector-size=2KiB --pre-sealed-sectors=~/.genesis-sectors --pre-sealed-metadata=~/.genesis-sectors/pre-seal-t01000.json --nosync
 ```
 
 Now, finally, start up the miner:
 
 ```sh
-./lotus-storage-miner run --nosync
+./lotus-miner run --nosync
 ```
 
 If all went well, you will have your own local Lotus Devnet running.
diff --git a/documentation/en/miner-deals.md b/documentation/en/miner-deals.md
new file mode 100644
index 000000000..0aee0e1af
--- /dev/null
+++ b/documentation/en/miner-deals.md
@@ -0,0 +1,39 @@
+# Information for Miners 
+
+Here is how a miner can get set up to accept storage deals. The first step is
+to install a Lotus node and sync to the top of the chain.
+
+## Set up an ask
+
+```
+lotus-miner set-price <price>
+```
+
+This command will set up your miner to accept deal proposals that meet the input price.
+The price is inputted in FIL per GiB per epoch, and the default is 0.0000000005. 
+
+## Ensure you can be discovered
+
+Clients need to be able to find you in order to make storage deals with you. 
+While there isn't necessarily anything you need to do to become discoverable, here are some things you can
+try to check that people can connect to you. 
+
+To start off, make sure you are connected to at least some peers, and your port is 
+open and working.
+
+### Connect to your own node
+
+If you are in contact with someone else running Lotus, you can ask them to try connecting
+to your node. To do so, provide them your peer ID, which you can get by running `lotus net id` on
+your node.
+
+They can then try running `lotus net findpeer <peerID>` to get your address(es), and can then
+run `lotus net connect <address>` to connect to you. If successful, your node will now
+appear on their peers list (run `lotus net peers` to check).
+
+You can also check this by running a second instance of Lotus yourself.
+
+### Query your own ask
+
+A client should be able to find your ask by running `lotus client query-ask <minerID>`. If 
+someone is not able to retrieve your ask by doing so, then there is an issue with your node.
\ No newline at end of file
diff --git a/documentation/en/mining-lotus-seal-worker.md b/documentation/en/mining-lotus-seal-worker.md
deleted file mode 100644
index d2ea9197b..000000000
--- a/documentation/en/mining-lotus-seal-worker.md
+++ /dev/null
@@ -1,87 +0,0 @@
-# Lotus Seal Worker
-
-The **Lotus Seal Worker** is an extra process that can offload heavy processing tasks from your **Lotus Storage Miner**. It can be run on the same machine as your `lotus-storage-miner`, or on another machine communicating over a fast network.
-
-## Note: Using the Lotus Seal Worker from China
-
-If you are trying to use `lotus-seal-worker` from China. You should set this **environment variable** on your machine:
-
-```sh
-IPFS_GATEWAY="https://proof-parameters.s3.cn-south-1.jdcloud-oss.com/ipfs/"
-```
-
-## Get Started
-
-Make sure that the `lotus-seal-worker` is installed by running:
-
-```sh
-make lotus-seal-worker
-```
-
-## Running Alongside Storage Miner
-
-You may wish to run the **Lotus Seal Worker** on the same computer as the **Lotus Storage Miner**. This allows you to easily set the process priority of the sealing tasks to be lower than the priority of your more important storage miner process.
-
-To do this, simply run `lotus-seal-worker run`, and the seal worker will automatically pick up the correct authentication tokens from the `LOTUS_STORAGE_PATH` miner repository.
-
-To check that the **Lotus Seal Worker** is properly connected to your storage miner, run `lotus-storage-miner info` and check that the remote worker count has increased.
-
-```sh
-why@computer ~/lotus> lotus-storage-miner info
-Miner: t0103
-Sector Size: 16.0 MiB
-Power: 0 B / 16.0 MiB (0%)
-Worker use:
-        Local: 0 / 2 (+1 reserved)
-        **Remote: 0 / 1**
-PoSt Submissions: Not Proving
-Sectors:  map[Committing:0 Proving:0 Total:0]
-```
-
-## Running Over the Network
-
-Warning: This setup is a little more complex than running it locally.
-
-To use an entirely separate computer for sealing tasks, you will want to run the `lotus-seal-worker` on a separate machine, connected to your **Lotus Storage Miner** via the local area network.
-
-First, you will need to ensure your `lotus-storage-miner`'s API is accessible over the network.
-
-To do this, open up `~/.lotusstorage/config.toml` (Or if you manually set `LOTUS_STORAGE_PATH`, look under that directory) and look for the API field.
-
-Default config:
-
-```toml
-[API]
-ListenAddress = "/ip4/127.0.0.1/tcp/2345/http"
-```
-
-To make your node accessible over the local area network, you will need to determine your machines IP on the LAN, and change the `127.0.0.1` in the file to that address.
-
-A more permissive and less secure option is to change it to `0.0.0.0`. This will allow anyone who can connect to your computer on that port to access the [API](https://docs.lotu.sh/en+api). They will still need an auth token.
-
-Next, you will need to [create an authentication token](https://docs.lotu.sh/en+api-scripting-support#generate-a-jwt-46). All Lotus APIs require authentication tokens to ensure your processes are as secure against attackers attempting to make unauthenticated requests to them.
-
-### Connect the Lotus Seal Worker
-
-On the machine that will run `lotus-seal-worker`, set the `STORAGE_API_INFO` environment variable to `TOKEN:STORAGE_NODE_MULTIADDR`. Where `TOKEN` is the token we created above, and `STORAGE_NODE_MULTIADDR` is the `multiaddr` of the **Lotus Storage Miner** API that was set in `config.toml`.
-
-Once this is set, run:
-
-```sh
-lotus-seal-worker run
-```
-
-To check that the **Lotus Seal Worker** is connected to your **Lotus Storage Miner**, run `lotus-storage-miner info` and check that the remote worker count has increased.
-
-```sh
-why@computer ~/lotus> lotus-storage-miner info
-Miner: t05749
-Sector Size: 1 GiB
-Power: 0 B / 136 TiB (0.0000%)
-  Committed: 1 GiB
-  Proving: 1 GiB
-Worker use:
-  Local: 0 / 1 (+1 reserved)
-  **Remote: 0 / 1**
-Sectors:  map[Proving:1 Total:1]
-```
diff --git a/documentation/en/mining-lotus-worker.md b/documentation/en/mining-lotus-worker.md
new file mode 100644
index 000000000..f93780c44
--- /dev/null
+++ b/documentation/en/mining-lotus-worker.md
@@ -0,0 +1,81 @@
+# Lotus Worker
+
+The **Lotus Worker** is an extra process that can offload heavy processing tasks from your **Lotus Miner**. The sealing process automatically runs in the **Lotus Miner** process, but you can use the Worker on another machine communicating over a fast network to free up resources on the machine running the mining process.
+
+## Note: Using the Lotus Worker from China
+
+If you are trying to use `lotus-worker` from China. You should set this **environment variable** on your machine:
+
+```sh
+export IPFS_GATEWAY="https://proof-parameters.s3.cn-south-1.jdcloud-oss.com/ipfs/"
+```
+
+## Get Started
+
+Make sure that the `lotus-worker` is compiled and installed by running:
+
+```sh
+make lotus-worker
+```
+
+## Setting up the Miner
+
+First, you will need to ensure your `lotus-miner`'s API is accessible over the network.
+
+To do this, open up `~/.lotusminer/config.toml` (Or if you manually set `LOTUS_MINER_PATH`, look under that directory) and look for the API field.
+
+Default config:
+
+```toml
+[API]
+ListenAddress = "/ip4/127.0.0.1/tcp/2345/http"
+RemoteListenAddress = "127.0.0.1:2345"
+```
+
+To make your node accessible over the local area network, you will need to determine your machines IP on the LAN, and change the `127.0.0.1` in the file to that address.
+
+A more permissive and less secure option is to change it to `0.0.0.0`. This will allow anyone who can connect to your computer on that port to access the [API](https://lotu.sh/en+api). They will still need an auth token.
+
+`RemoteListenAddress` must be set to an address which other nodes on your network will be able to reach.
+
+Next, you will need to [create an authentication token](https://lotu.sh/en+api-scripting-support#generate-a-jwt-46). All Lotus APIs require authentication tokens to ensure your processes are as secure against attackers attempting to make unauthenticated requests to them.
+
+### Connect the Lotus Worker
+
+On the machine that will run `lotus-worker`, set the `MINER_API_INFO` environment variable to `TOKEN:MINER_NODE_MULTIADDR`. Where `TOKEN` is the token we created above, and `NIMER_NODE_MULTIADDR` is the `multiaddr` of the **Lotus Miner** API that was set in `config.toml`.
+
+Once this is set, run:
+
+```sh
+lotus-worker run
+```
+
+If you are running multiple workers on the same host, you will need to specify the `--listen` flag and ensure each worker is on a different port.
+
+To check that the **Lotus Worker** is connected to your **Lotus Miner**, run `lotus-miner sealing workers` and check that the remote worker count has increased.
+
+```sh
+why@computer ~/lotus> lotus-miner sealing workers
+Worker 0, host computer
+        CPU:  [                                                                ] 0 core(s) in use
+        RAM:  [||||||||||||||||||                                              ] 28% 18.1 GiB/62.7 GiB
+        VMEM: [||||||||||||||||||                                              ] 28% 18.1 GiB/62.7 GiB
+        GPU: GeForce RTX 2080, not used
+
+Worker 1, host othercomputer
+        CPU:  [                                                                ] 0 core(s) in use
+        RAM:  [||||||||||||||                                                  ] 23% 14 GiB/62.7 GiB
+        VMEM: [||||||||||||||                                                  ] 23% 14 GiB/62.7 GiB
+        GPU: GeForce RTX 2080, not used
+```
+
+### Running locally for manually managing process priority
+
+You can also run the **Lotus Worker** on the same machine as your **Lotus Miner**, so you can manually manage the process priority.
+To do so you have to first __disable all seal task types__ in the miner config. This is important to prevent conflicts between the two processes.
+
+You can then run the miner on your local-loopback interface; 
+
+```sh
+lotus-worker run
+```
diff --git a/documentation/en/mining-troubleshooting.md b/documentation/en/mining-troubleshooting.md
index c3195c9f2..d2cc036a7 100644
--- a/documentation/en/mining-troubleshooting.md
+++ b/documentation/en/mining-troubleshooting.md
@@ -16,16 +16,16 @@ The **Bellman** lockfile is created to lock a GPU for a process. This bug can oc
 mining block failed: computing election proof: github.com/filecoin-project/lotus/miner.(*Miner).mineOne
 ```
 
-This bug occurs when the storage miner can't acquire the `bellman.lock`. To fix it you need to stop the `lotus-storage-miner` and remove `/tmp/bellman.lock`.
+This bug occurs when the miner can't acquire the `bellman.lock`. To fix it you need to stop the `lotus-miner` and remove `/tmp/bellman.lock`.
 
 ## Error: Failed to get api endpoint
 
 ```sh
-lotus-storage-miner info
-# WARN  main  lotus-storage-miner/main.go:73  failed to get api endpoint: (/Users/myrmidon/.lotusstorage) %!w(*errors.errorString=&{API not running (no endpoint)}):
+lotus-miner info
+# WARN  main  lotus-miner/main.go:73  failed to get api endpoint: (/Users/myrmidon/.lotusminer) %!w(*errors.errorString=&{API not running (no endpoint)}):
 ```
 
-If you see this, that means your **Lotus Storage Miner** isn't ready yet. You need to finish [syncing the chain](https://docs.lotu.sh/en+join-testnet).
+If you see this, that means your **Lotus Miner** isn't ready yet. You need to finish [syncing the chain](https://lotu.sh/en+join-testnet).
 
 ## Error: Your computer may not be fast enough
 
@@ -38,7 +38,7 @@ If you see this, that means your computer is too slow and your blocks are not in
 ## Error: No space left on device
 
 ```sh
-lotus-storage-miner pledge-sector
+lotus-miner sectors pledge
 # No space left on device (os error 28)
 ```
 
@@ -51,7 +51,8 @@ If you suspect that your GPU is not being used, first make sure it is properly c
 First, to watch GPU utilization run `nvtop` in one terminal, then in a separate terminal, run:
 
 ```sh
-lotus-bench --sector-size=1024
+make bench
+./bench sealing --sector-size=2KiB
 ```
 
 This process uses a fair amount of GPU, and generally takes ~4 minutes to complete. If you do not see any activity in nvtop from lotus during the entire process, it is likely something is misconfigured with your GPU.
diff --git a/documentation/en/mining.md b/documentation/en/mining.md
index 41c998959..32c3c51d2 100644
--- a/documentation/en/mining.md
+++ b/documentation/en/mining.md
@@ -1,50 +1,37 @@
 # Storage Mining
 
-Here are instructions to learn how to perform storage mining. For hardware specifications please read [this](https://docs.lotu.sh/en+hardware-mining).
+Here are instructions to learn how to perform storage mining. For hardware specifications please read [this](https://lotu.sh/en+hardware-mining).
 
-It is useful to [join the Testnet](https://docs.lotu.sh/en+join-testnet) prior to attempting storage mining for the first time.
+It is useful to [join the Testnet](https://lotu.sh/en+join-testnet) prior to attempting storage mining for the first time.
 
-## Note: Using the Lotus Storage Miner from China
+## Note: Using the Lotus Miner from China
 
-If you are trying to use `lotus-storage-miner` from China. You should set this **environment variable** on your machine.
+If you are trying to use `lotus-miner` from China. You should set this **environment variable** on your machine.
 
 ```sh
-IPFS_GATEWAY="https://proof-parameters.s3.cn-south-1.jdcloud-oss.com/ipfs/"
+export IPFS_GATEWAY="https://proof-parameters.s3.cn-south-1.jdcloud-oss.com/ipfs/"
 ```
 
 ## Get started
 
-Please ensure that at least one **BLS address** in your wallet exists with the following command:
+Please ensure that at least one **BLS address** (starts with `t3`) in your wallet exists with the following command:
 
 ```sh
 lotus wallet list
 ```
 
+If you do not have a bls address, create a new bls wallet:
+
+```sh
+lotus wallet new bls
+```
+
 With your wallet address:
 
-- Visit the [faucet](https://lotus-faucet.kittyhawk.wtf/miner.html)
-- Click "Create Miner"
-- DO NOT REFRESH THE PAGE. THIS OPERATION CAN TAKE SOME TIME.
-
-The task will be complete when you see:
-
-```sh
-New storage miners address is: <YOUR_NEW_MINING_ADDRESS>
-```
-
-## Initialize the storage miner
-
-In a CLI window, use the following command to start your miner:
-
-```sh
-lotus-storage-miner init --actor=ACTOR_VALUE_RECEIVED --owner=OWNER_VALUE_RECEIVED
-```
-
-Example
-
-```sh
-lotus-storage-miner init --actor=t01424 --owner=t3spmep2xxsl33o4gxk7yjxcobyohzgj3vejzerug25iinbznpzob6a6kexcbeix73th6vjtzfq7boakfdtd6a
-```
+- Visit the [faucet](http://spacerace.faucet.glif.io/)
+- Paste the address you created under REQUEST.
+- Press the Request button.
+- Run `/lotus-miner init --owner=<blsAddress> --worker=<blsAddress>`
 
 You will have to wait some time for this operation to complete.
 
@@ -53,7 +40,7 @@ You will have to wait some time for this operation to complete.
 To mine:
 
 ```sh
-lotus-storage-miner run
+lotus-miner run
 ```
 
 If you are downloading **Filecoin Proof Parameters**, the download can take some time.
@@ -61,14 +48,14 @@ If you are downloading **Filecoin Proof Parameters**, the download can take some
 Get information about your miner:
 
 ```sh
-lotus-storage-miner info
+lotus-miner info
 # example: miner id `t0111`
 ```
 
 **Seal** random data to start producing **PoSts**:
 
 ```sh
-lotus-storage-miner pledge-sector
+lotus-miner sectors pledge
 ```
 
 - Warning: On Linux configurations, this command will write data to `$TMPDIR` which is not usually the largest partition. You should point the value to a larger partition if possible.
@@ -76,19 +63,87 @@ lotus-storage-miner pledge-sector
 Get **miner power** and **sector usage**:
 
 ```sh
-lotus-storage-miner state power
+lotus state power
 # returns total power
 
-lotus-storage-miner state power <miner>
+lotus state power <miner>
 
-lotus-storage-miner state sectors <miner>
+lotus state sectors <miner>
 ```
 
-## Change nickname
+## Performance tuning
 
-Update `~/.lotus/config.toml` with:
+### `FIL_PROOFS_MAXIMIZE_CACHING=1` Environment variable
 
+This env var can be used with `lotus-miner`, `lotus-worker`, and `lotus-bench` to make the precommit1 step faster at the cost of some memory use (1x sector size)
+
+### `FIL_PROOFS_USE_GPU_COLUMN_BUILDER=1` Environment variable
+
+This env var can be used with `lotus-miner`, `lotus-worker`, and `lotus-bench` to enable experimental precommit2 GPU acceleration
+
+### Setting multiaddresses
+
+Set multiaddresses for the miner to listen on in a miner's `config.toml` file
+(by default, it is located at `~/.lotusminer/config.toml`). The `ListenAddresses` in this file should be interface listen addresses (usually `/ip4/0.0.0.0/tcp/PORT`), and the `AnnounceAddresses` should match the addresses being passed to `set-addrs`.
+
+The addresses passed to `set-addrs` parameter in the commands below should be currently active and dialable; confirm they are before entering them.
+
+Once the config file has been updated, set the on-chain record of the miner's listen addresses:
+
+```
+lotus-miner actor set-addrs <multiaddr_1> <multiaddr_2> ... <multiaddr_n>
+```
+
+This updates the `MinerInfo` object in the miner's actor, which will be looked up
+when a client attempts to make a deal. Any number of addresses can be provided.
+
+Example:
+
+```
+lotus-miner actor set-addrs /ip4/123.123.73.123/tcp/12345 /ip4/223.223.83.223/tcp/23456
+```
+
+# Separate address for windowPoSt messages
+
+WindowPoSt is the mechanism through which storage is verified in Filecoin. It requires miners to submit proofs for all sectors every 24h, which require sending messages to the chain.
+
+Because many other mining related actions require sending messages to the chain, and not all of those are "high value", it may be desirable to use a separate account to send PoSt messages from. This allows for setting lower GasFeeCaps on the lower value messages without creating head-of-line blocking problems for the PoSt messages in congested chain conditions
+
+To set this up, first create a new account, and send it some funds for gas fees:
 ```sh
-[Metrics]
-Nickname="fun"
+lotus wallet new bls
+t3defg...
+
+lotus send t3defg... 100
+```
+
+Next add the control address
+```sh
+lotus-miner actor control set t3defg...
+Add t3defg...
+Pass --really-do-it to actually execute this action
+```
+
+Now actually set the addresses
+```sh
+lotus-miner actor control set --really-do-it t3defg...
+Add t3defg...
+Message CID: bafy2..
+```
+
+Wait for the message to land on chain
+```sh
+lotus state wait-msg bafy2..
+...
+Exit Code: 0
+...
+```
+
+Check miner control address list to make sure the address was correctly setup
+```sh
+lotus-miner actor control list
+name       ID      key           use    balance
+owner      t01111  t3abcd...  other  300 FIL
+worker     t01111  t3abcd...  other  300 FIL
+control-0  t02222  t3defg...  post   100 FIL
 ```
diff --git a/documentation/en/mpool.md b/documentation/en/mpool.md
new file mode 100644
index 000000000..65e7ce2d7
--- /dev/null
+++ b/documentation/en/mpool.md
@@ -0,0 +1,176 @@
+# The Message Pool
+
+The Message Pool (mpool) is the component of lotus that handles
+pending messages for inclusion in the chain. Messages are added to the
+mpool either directly for locally published messages or through pubsub
+propagation.  Whenever a miner is ready to create a block for a
+tipset, it invokes the mpool selection algorithm which selects an
+appropriate set of messages such that it optimizes miner reward and
+chain capacity.
+
+## API
+
+The full node API defines the following methods for interacting with the mpool:
+```
+    MpoolPending(context.Context, types.TipSetKey) ([]*types.SignedMessage, error)
+    MpoolSelect(context.Context, types.TipSetKey, float64) ([]*types.SignedMessage, error)
+    MpoolPush(context.Context, *types.SignedMessage) (cid.Cid, error)
+    MpoolPushMessage(ctx context.Context, msg *types.Message, spec *MessageSendSpec) (*types.SignedMessage, error)
+    MpoolGetNonce(context.Context, address.Address) (uint64, error)
+    MpoolSub(context.Context) (<-chan MpoolUpdate, error)
+    MpoolGetConfig(context.Context) (*types.MpoolConfig, error)
+    MpoolSetConfig(context.Context, *types.MpoolConfig) error
+    MpoolClear(context.Context, local bool) error
+```
+
+### MpoolPending
+
+Returns the list of messages that are pending for a tipset.
+
+### MpoolSelect
+
+Selects and returns a list of pending messages for inclusion in the next block.
+
+### MpoolPush
+
+Pushes a signed message to the mpool; returns the CID of the message.
+
+### MpoolPushMessage
+
+Atomically assigns a nonce, signs, and pushes a message to the mpool.
+
+The MaxFee field of the spec argument is only used when
+GasFeeCap/GasPremium fields aren't specified in the message. When
+maxFee is set to 0, MpoolPushMessage will guess appropriate fee based
+on current chain conditions.
+
+### MpoolGetNonce
+
+Returns the next nonce for the specified sender. Note that this method may not be atomic.
+Use `MpoolPushMessage` instead.
+
+### MpoolSub
+
+Returns a channel to receive notifications about updates to the message pool.
+Note that the context *must* be cancelled when the caller is done with the subscription.
+
+### MpoolGetConfig
+
+Returns (a copy of) the current mpool configuration.
+
+### MpoolSetConfig
+
+Sets the mpool configuration to (a copy of) the supplied configuration object.
+
+### MpoolClear
+
+Clears pending messages from the mpool; if `local` is `true` then local messages are also cleared and removed from the datastore.
+
+This should be used with extreme care and only in the case of errors during head changes that
+would leave the mpool in an inconsistent state.
+
+
+## Command Line Interfae
+
+The lotus command line interface defines an `mpool` command which
+allows a user to interact with the mpool.
+
+The following commands are supported:
+```
+lotus mpool pending [--local]
+lotus mpool sub
+lotus mpool stat [--local]
+lotus mpool replace [--gas-feecap <feecap>] [--gas-premium <premium>] [--gas-limit <limit>] [from] [nonce]
+lotus mpool find [--from <address>] [--to <address>] [--method <int>]
+lotus mpool config [<configuration>]
+lotus mpool clear [--local]
+```
+
+### lotus mpool pending
+Prints the pending messages in the mpool, as returned by the `MpoolPending` API call.
+If `--local` is specified, it only prints pending messages for addresses in the local wallet.
+
+### lotus mpool sub
+Subscribes to mpool changes using the `MpoolSub` API call and prints the stream of mpool
+updates.
+
+### lotus mpool stat
+Prints various mpool statistics.
+If `--local` is specified then only prints statistics for addresses in the local wallet.
+
+### lotus mpool replace
+Replaces a message in the mpool.
+
+### lotus mpool find
+Searches for messages in the mpool.
+
+### lotus mpool config
+Gets or sets the current mpool configuration.
+
+### lotus mpool clear
+Unconditionally clears pending messages from the mpool.
+If the `--local` flag is passed, then local messages are also cleared; otherwise local messages are retained.
+
+*Warning*: this command should only be used in the case of head change errors leaving the mpool in an  state.
+
+## Configuration
+
+The mpool a few parameters that can be configured by the user, either through the API
+or the command line interface.
+
+The config struct is defined as follows:
+```
+type MpoolConfig struct {
+	PriorityAddrs          []address.Address
+	SizeLimitHigh          int
+	SizeLimitLow           int
+	ReplaceByFeeRatio      float64
+	PruneCooldown          time.Duration
+	GasLimitOverestimation float64
+}
+
+```
+
+The meaning of these fields is as follows:
+- `PriorityAddrs` -- these are the addresses of actors whose pending messages should always
+  be included in a block during message selection, as long as they are profitable.
+  Miners should configure their own worker addresses so that they include their own messages
+  when they produce a new block.
+  Default is empty.
+- `SizeLimitHigh` -- this is the maximum number of pending messages before triggering a
+  prune in the message pool. Note that messages from priority addresses are never pruned.
+  Defafult is 30000.
+- `SizeLimitLow` -- this is the number of pending messages that should be kept after a prune.
+  Default is 20000.
+- `ReplaceByFeeRatio` -- this is the gas fee ratio for replacing messages in the mpool.
+  Whenever a message is replaced, the `GasPremium` must be increased by this ratio.
+  Default is 1.25.
+- `PruneCooldown` -- this is the period of time to wait before triggering a new prune.
+  Default is 1min.
+- `GasLimitOverestimation` -- this is a parameter that controls the gas limit overestimation for new messages.
+  Default is 1.25.
+
+
+## Message Selection
+
+A few words regarding message selection are pertinent. In message
+selection, a miner selects a set of messages from the pending messages
+for inclusion to the next block in order to maximize its reward. The
+problem however is NP-hard (it's an instance of knapsack packing),
+further confounded by the fact that miners don't communicate their
+tickets to each other. So at best we can approximate the optimal
+selection in a reasonable amount of time.
+
+The mpool employs a sophisticated algorithm for selecting messages for
+inclusion, given the ticket quality of a miner. The ticket quality
+reflects the probability of execution order for a block in the
+tipset. Given the ticket quality the algorithm computes the
+probability of each block, and picks dependent chains of messages such
+that the reward is maximized, while also optimizing the capacity of
+the chain.  If the ticket quality is sufficiently high, then a greedy
+selection algorithm is used instead that simply picks dependent chains of
+maximum reward.  Note that pending message chains from priority addresses
+are always selected, regardless of their profitability.
+
+For algorithm details, please prefer to the implementation in
+`chain/messagepool/selection.go`.
diff --git a/documentation/en/payment-channels.md b/documentation/en/payment-channels.md
new file mode 100644
index 000000000..afddcdc40
--- /dev/null
+++ b/documentation/en/payment-channels.md
@@ -0,0 +1,111 @@
+# Payment Channels
+
+Payment channels are used to transfer funds between two actors.
+
+For example in lotus a payment channel is created when a client wants to fetch data from a provider.
+The client sends vouchers for the payment channel, and the provider sends data in response.
+
+The payment channel is created on-chain with an initial amount.
+Vouchers allow the client and the provider to exchange funds incrementally off-chain.
+The provider can submit vouchers to chain at any stage.
+Either party to the payment channel can settle the payment channel on chain.
+After a settlement period (currently 12 hours) either party to the payment channel can call collect on chain.
+Collect sends the value of submitted vouchers to the channel recipient (the provider), and refunds the remaining channel balance to the channel creator (the client).
+
+Vouchers have a lane, a nonce and a value, where vouchers with a higher nonce supersede vouchers with a lower nonce in the same lane.
+Each deal is created on a different lane. 
+
+Note that payment channels and vouchers can be used for any situation in which two parties need to incrementally transfer value between each other off-chain.
+
+## Using the CLI
+
+For example a client creates a payment channel to a provider with value 10 FIL.
+
+```sh
+$ lotus paych add-funds <client addr> <provider addr> 10
+<channel addr>
+```
+
+The client creates a voucher in lane 0 (implied) with nonce 1 (implied) and value 2.
+
+```sh
+$ lotus paych voucher create <channel addr> 2
+<voucher>
+```
+
+The client sends the voucher to the provider and the provider adds the voucher to their local store.
+
+```sh
+$ lotus paych voucher add <channel addr> <voucher>
+```
+
+The provider sends some data to the client.
+
+The client creates a voucher in lane 0 (implied) with nonce 2 (implied) and value 4.
+
+```sh
+$ lotus paych voucher create <channel addr> 4
+<voucher>
+```
+
+The client sends the voucher to the provider and the provider adds the voucher and sends back more data.
+etc.
+
+The client can add value to the channel after it has been created by calling `paych add-funds` with the same client and provider addresses.
+
+```sh
+$ lotus paych add-funds <client addr> <provider addr> 5
+<channel addr> # Same address as above. Channel now has 15
+```
+
+Once the client has received all their data, they may settle the channel.
+Note that settlement doesn't have to be done immediately.
+For example the client may keep the channel open as long as it wants to continue making deals with the provider.
+
+```sh
+$ lotus paych settle <channel addr>
+```
+
+The provider can submit vouchers to chain (note that lotus does this automatically when it sees a settle message appear on chain).
+The provider may have received many vouchers with incrementally higher values.
+The provider should submit the best vouchers. Note that there will be one best voucher for each lane.
+
+```sh
+$ lotus paych voucher best-spendable <channel addr>
+<voucher>
+<voucher>
+<voucher>
+
+$ lotus paych voucher submit <channel addr> <voucher>
+```
+
+Once the settlement period is over, either the client or provider can call collect to disburse funds.
+
+```sh
+$ lotus paych collect <channel addr>
+```
+
+Check the status of a channel that is still being created using `lotus paych status-by-from-to`.
+
+```sh
+$ lotus paych status-by-from-to <from addr> <to addr>
+Creating channel
+  From:          t3sb6xzvs6rhlziatagevxpp3dwapdolurtkpn4kyh3kgoo4tn5o7lutjqlsnvpceztlhxu3lzzfe34rvpsjgq
+  To:            t1zip4sblhyrn4oxygzsm6nafbsynp2avmk3xafea
+  Pending Amt:   10000
+  Wait Sentinel: bafy2bzacedk2jidsyxcynusted35t5ipkhu2kpiodtwyjr3pimrhke6f5pqbm
+```
+
+Check the status of a channel that has been created using `lotus paych status`.
+
+```sh
+$ lotus paych status <channel addr>
+Channel exists
+  Channel:              t2nydpzhmeqkmid5smtqnowlr2mr5az6rexpmyv6i
+  From:                 t3sb6xzvs6rhlziatagevxpp3dwapdolurtkpn4kyh3kgoo4tn5o7lutjqlsnvpceztlhxu3lzzfe34rvpsjgq
+  To:                   t1zip4sblhyrn4oxygzsm6nafbsynp2avmk3xafea
+  Confirmed Amt:        10000
+  Pending Amt:          6000
+  Queued Amt:           3000
+  Voucher Redeemed Amt: 2000
+```
diff --git a/documentation/en/retrieving-data.md b/documentation/en/retrieving-data.md
index 56f8296e8..7cb0e31be 100644
--- a/documentation/en/retrieving-data.md
+++ b/documentation/en/retrieving-data.md
@@ -2,9 +2,9 @@
 
 > There are recent bug reports with these instructions. If you happen to encounter any problems, please create a [GitHub issue](https://github.com/filecoin-project/lotus/issues/new) and a maintainer will address the problem as soon as they can.
 
-Here are the operations you can perform after you have stored and sealed a **Data CID** with the **Lotus Storage Miner** in the network.
+Here are the operations you can perform after you have stored and sealed a **Data CID** with the **Lotus Miner** in the network.
 
-If you would like to learn how to store a **Data CID** on a miner, read the instructions [here](https://docs.lotu.sh/en+storing-data).
+If you would like to learn how to store a **Data CID** on a miner, read the instructions [here](https://lotu.sh/en+storing-data).
 
 ## Find by Data CID
 
diff --git a/documentation/en/sealing-procs.md b/documentation/en/sealing-procs.md
new file mode 100644
index 000000000..1b4f2877c
--- /dev/null
+++ b/documentation/en/sealing-procs.md
@@ -0,0 +1,70 @@
+# Why does Filecoin mining work best on AMD?
+Currently, Filecoin's Proof of Replication (PoRep) prefers to be run on AMD
+processors.  More accurately, it runs much much slower on Intel CPUs (it runs
+competitively fast on some ARM processors, like the ones in newer Samsung
+phones, but they lack the RAM to seal the larger sector sizes). The main reason
+that we see this benefit on AMD processors is due to their implementation of
+the SHA hardware instructions. Now, why do we use the SHA instruction?
+
+## PoRep security assumptions
+Our research team has two different models for the security of Proofs of
+Replication. These are the Latency Assumption, and the Cost Assumption. These
+assumptions are arguments for why an attacker cannot pull off a 'regeneration
+attack'. That is, the attacker cannot seal and commit random data (generated by
+a function), delete it, and then reseal it on the fly to respond to PoSt
+challenges, without actually storing the data for that time period.
+
+### Cost Assumptions
+The cost assumption states that the real money cost (hardware, electricity,
+etc) of generating a sector is higher than the real money cost of simply
+storing it on disks. NSE is a new PoRep our research team is working on that is
+based on the cost assumption, and is thus able to be very parallelizable (In
+comparison to schemes based on a latency assumption, as will be explained
+next). However, cost assumptions vary greatly with available and hypothetical
+hardware. For example, someone making an ASIC for NSE could break the cost
+assumption by lowering the cost of sealing too much. This is one of our main
+hesitations around shipping NSE.
+
+### Latency Assumptions
+A Proof of Replication that is secure under a latency assumption is secure
+because an attacker cannot regenerate the data in time. We use this assumption
+for SDR, where we assume that an attacker cannot regenerate enough of a sector
+fast enough to respond to a PoSt. The way we achieve this is through the use
+of depth-robust graphs. Without going into too much detail, depth-robust
+graphs guarantee a minimum number of serial operations to compute an encoding
+based on the graph. Each edge in the graph represents an operation we need to
+perform. We thus have a guarantee that someone has to perform some operation
+N times in a row in order to compute the encoding. That means that the
+computation of the encoding must take at least as long as N times the fastest
+someone can do that operation.
+
+Now, to make this secure, we need to choose an operation that can't be made
+much faster. There are many potential candidates here, depending on what
+hardware you want to require. We opted not to require ASICs in order to mine
+Filecoin, so that limits our choices severely. We have to look at what
+operations CPUs are really good at. One candidate was AES encryption, which
+also has hardware instructions. However, the difference between the performance
+of CPU AES instructions, and the hypothetical 'best' performance you get was
+still too great. This gap is generally called 'Amax', an attacker’s maximum
+advantage. The higher the Amax of an algorithm we choose, the more expensive
+the overall process has to become in order to bound how fast the attacker could
+do it.
+As we were doing our research, we noticed that AMD shipped their new processors
+with a builtin SHA function, and we looked into how fast someone could possibly
+compute a SHA hash. We found that AMD’s implementation is only around 3 times
+slower than anyone could reasonably do (given estimates by the hardware
+engineers at [Supranational](https://www.supranational.net/) ). This is
+incredibly impressive for something you can get in consumer hardware. With
+this, we were able to make SDR sealing reasonably performant for people with
+off-the-shelf hardware.
+
+## Super Optimized CPUs
+
+Given all of the above, with a latency assumption that we're basing our proofs
+on right now, you need a processor that can do iterated SHA hashes really fast.
+As mentioned earlier, this isn’t just AMD processors, but many ARM processors
+also have support for this. Hopefully, new Intel processors also follow suit.
+But for now, Filecoin works best on AMD processors.
+
+
+
diff --git a/documentation/en/setting-a-static-port.md b/documentation/en/setting-a-static-port.md
index 43a38daa9..97ac6528e 100644
--- a/documentation/en/setting-a-static-port.md
+++ b/documentation/en/setting-a-static-port.md
@@ -1,10 +1,10 @@
 # Static Ports
 
-Depending on how your network is set up, you may need to set a static port to successfully connect to peers to perform storage deals with your **Lotus Storage Miner**.
+Depending on how your network is set up, you may need to set a static port to successfully connect to peers to perform storage deals with your **Lotus Miner**.
 
 ## Setup
 
-To change the random **swarm port**, you may edit the `config.toml` file located under `$LOTUS_STORAGE_PATH`. The default location of this file is `$HOME/.lotusstorage`.
+To change the random **swarm port**, you may edit the `config.toml` file located under `$LOTUS_MINER_PATH`. The default location of this file is `$HOME/.lotusminer`.
 
 To change the port to `1347`:
 
@@ -15,6 +15,20 @@ To change the port to `1347`:
 
 After changing the port value, restart your **daemon**.
 
+## Announce Addresses
+
+If the **swarm port** is port-forwarded from another address, it is possible to control what addresses
+are announced to the network.
+
+```sh
+[Libp2p]
+  AnnounceAddresses = ["/ip4/<public-ip>/tcp/1347"]
+```
+
+If non-empty, this array specifies the swarm addresses to announce to the network. If empty, the daemon will announce inferred swarm addresses.
+
+Similarly, it is possible to set `NoAnnounceAddresses` with an array of addresses to not announce to the network.
+
 ## Ubuntu's Uncomplicated Firewall
 
 Open firewall manually:
diff --git a/documentation/en/setup-troubleshooting.md b/documentation/en/setup-troubleshooting.md
index 4bc76357c..a1c78b51b 100644
--- a/documentation/en/setup-troubleshooting.md
+++ b/documentation/en/setup-troubleshooting.md
@@ -5,7 +5,7 @@
 Here is a command that will delete your chain data, stored wallets, stored data and any miners you have set up:
 
 ```sh
-rm -rf ~/.lotus ~/.lotusstorage
+rm -rf ~/.lotus ~/.lotusminer
 ```
 
 This command usually resolves any issues with running `lotus` but it is not always required for updates. We will share information about when resetting your chain data and miners is required for an update in the future.
@@ -29,15 +29,18 @@ ERROR hello hello/hello.go:81 other peer has different genesis!
 - repo is already locked
 ```
 
-- You already have another lotus deamon running.
+- You already have another lotus daemon running.
 
-## Warning: get message get failed
+## Config: Open files limit
 
-Some errors will occur that do not prevent Lotus from working:
+On most systems you can check the open files limit with:
 
 ```sh
-ERROR chainstore  store/store.go:564  get message get failed: <Data CID>: blockstore: block not found
-
+ulimit -n
 ```
 
-- Someone is requesting a **Data CID** from you that you don't have.
+You can also modify this number by using the `ulimit` command. It gives you the ability to control the resources available for the shell or process started by it. If the number is below 10000, you can change it with the following command prior to starting the Lotus daemon:
+
+```sh
+ulimit -n 10000
+```
diff --git a/documentation/en/storing-data-troubleshooting.md b/documentation/en/storing-data-troubleshooting.md
index 2f1a6b607..c8a0254fa 100644
--- a/documentation/en/storing-data-troubleshooting.md
+++ b/documentation/en/storing-data-troubleshooting.md
@@ -21,7 +21,7 @@ WARN  main  lotus/main.go:72  failed to start deal: computing commP failed: gene
 In order to retrieve a file, it must be sealed. Miners can check sealing progress with this command:
 
 ```sh
-lotus-storage-miner sectors list
+lotus-miner sectors list
 ```
 
-When sealing is complete, `pSet: NO` will become `pSet: YES`. From now on the **Data CID** is [retrievable](https://docs.lotu.sh/en+retrieving-data) from the **Lotus Storage Miner**.
+When sealing is complete, `pSet: NO` will become `pSet: YES`. From now on the **Data CID** is [retrievable](https://lotu.sh/en+retrieving-data) from the **Lotus Miner**.
diff --git a/documentation/en/storing-data.md b/documentation/en/storing-data.md
index 410a06553..67d2b1533 100644
--- a/documentation/en/storing-data.md
+++ b/documentation/en/storing-data.md
@@ -49,9 +49,14 @@ Store a **Data CID** with a miner:
 lotus client deal <Data CID> <miner> <price> <duration>
 ```
 
-- Price is in attoFIL.
-- The `duration`, which represents how long the miner will keep your file hosted, is represented in blocks. Each block represents 45 seconds.
+Check the status of a deal:
+
+```sh
+lotus client list-deals
+```
+
+- The `duration`, which represents how long the miner will keep your file hosted, is represented in blocks. Each block represents 25 seconds.
 
 Upon success, this command will return a **Deal CID**.
 
-The storage miner will need to **seal** the file before it can be retrieved. If the **Lotus Storage Miner** is not running on a machine designed for sealing, the process will take a very long time.
+The miner will need to **seal** the file before it can be retrieved. If the **Lotus Miner** is not running on a machine designed for sealing, the process will take a very long time.
diff --git a/documentation/en/storing-ipfs-integration.md b/documentation/en/storing-ipfs-integration.md
new file mode 100644
index 000000000..041364380
--- /dev/null
+++ b/documentation/en/storing-ipfs-integration.md
@@ -0,0 +1,20 @@
+# IPFS Integration
+
+Lotus supports making deals with data stored in IPFS, without having to re-import it into lotus.
+
+To enable this integration, you need to have an IPFS daemon running in the background.
+Then, open up `~/.lotus/config.toml` (or if you manually set `LOTUS_PATH`, look under that directory) 
+and look for the Client field, and set `UseIpfs` to `true`.
+
+```toml
+[Client]
+UseIpfs = true
+```
+
+After restarting the lotus daemon, you should be able to make deals with data in your IPFS node:
+
+```sh
+$ ipfs add -r SomeData
+QmSomeData
+$ ./lotus client deal QmSomeData t01000 0.0000000001 80000
+```
diff --git a/documentation/en/updating-lotus.md b/documentation/en/updating-lotus.md
index cf89bb773..862cea136 100644
--- a/documentation/en/updating-lotus.md
+++ b/documentation/en/updating-lotus.md
@@ -8,14 +8,7 @@ git pull origin master
 
 # clean and remake the binaries
 make clean && make build
+
+# instal binaries in correct location
+make install # or sudo make install if necessary
 ```
-
-Sometimes when you run Lotus after a pull, certain commands such as `lotus daemon` may break.
-
-Here is a command that will delete your chain data, stored wallets and any miners you have set up:
-
-```sh
-rm -rf ~/.lotus ~/.lotusstorage
-```
-
-This command usually resolves any issues with running `lotus` commands but it is not always required for updates. We will share information about when resetting your chain data and miners is required for an update in the future.
diff --git a/extern/fil-blst b/extern/fil-blst
new file mode 160000
index 000000000..8609119cf
--- /dev/null
+++ b/extern/fil-blst
@@ -0,0 +1 @@
+Subproject commit 8609119cf4595d1741139c24378fcd8bc4f1c475
diff --git a/extern/filecoin-ffi b/extern/filecoin-ffi
index f261762ff..57e38efe4 160000
--- a/extern/filecoin-ffi
+++ b/extern/filecoin-ffi
@@ -1 +1 @@
-Subproject commit f261762ff8ede465f22b364a214ed01d8b0d64c3
+Subproject commit 57e38efe4943f09d3127dcf6f0edd614e6acf68e
diff --git a/extern/oni b/extern/oni
new file mode 160000
index 000000000..9a0d5cd73
--- /dev/null
+++ b/extern/oni
@@ -0,0 +1 @@
+Subproject commit 9a0d5cd739de77b357589ac1fc8b756ed27299be
diff --git a/extern/rleplus/internal/bitvector.go b/extern/rleplus/internal/bitvector.go
deleted file mode 100644
index 65bae074e..000000000
--- a/extern/rleplus/internal/bitvector.go
+++ /dev/null
@@ -1,154 +0,0 @@
-package bitvector
-
-import (
-	"errors"
-	"log"
-)
-
-var (
-	// ErrOutOfRange - the index passed is out of range for the BitVector
-	ErrOutOfRange = errors.New("index out of range")
-)
-
-// BitNumbering indicates the ordering of bits, either
-// least-significant bit in position 0, or most-significant bit
-// in position 0.
-//
-// It it used in 3 ways with BitVector:
-// 1. Ordering of bits within the Buf []byte structure
-// 2. What order to add bits when using Extend()
-// 3. What order to read bits when using Take()
-//
-// https://en.wikipedia.org/wiki/Bit_numbering
-type BitNumbering int
-
-const (
-	// LSB0 - bit ordering starts with the low-order bit
-	LSB0 BitNumbering = iota
-
-	// MSB0 - bit ordering starts with the high-order bit
-	MSB0
-)
-
-// BitVector is used to manipulate ordered collections of bits
-type BitVector struct {
-	Buf []byte
-
-	// BytePacking is the bit ordering within bytes
-	BytePacking BitNumbering
-
-	// Len is the logical number of bits in the vector.
-	// The last byte in Buf may have undefined bits if Len is not a multiple of 8
-	Len uint
-}
-
-// NewBitVector constructs a new BitVector from a slice of bytes.
-//
-// The bytePacking parameter is required to know how to interpret the bit ordering within the bytes.
-func NewBitVector(buf []byte, bytePacking BitNumbering) *BitVector {
-	return &BitVector{
-		BytePacking: bytePacking,
-		Buf:         buf,
-		Len:         uint(len(buf) * 8),
-	}
-}
-
-// Push adds a single bit to the BitVector.
-//
-// Although it takes a byte, only the low-order bit is used, so just use 0 or 1.
-func (v *BitVector) Push(val byte) {
-	if v.Len%8 == 0 {
-		v.Buf = append(v.Buf, 0)
-	}
-	lastIdx := v.Len / 8
-
-	switch v.BytePacking {
-	case LSB0:
-		v.Buf[lastIdx] |= (val & 1) << (v.Len % 8)
-	default:
-		v.Buf[lastIdx] |= (val & 1) << (7 - (v.Len % 8))
-	}
-
-	v.Len++
-}
-
-// Get returns a single bit as a byte -- either 0 or 1
-func (v *BitVector) Get(idx uint) (byte, error) {
-	if idx >= v.Len {
-		return 0, ErrOutOfRange
-	}
-	blockIdx := idx / 8
-
-	switch v.BytePacking {
-	case LSB0:
-		return v.Buf[blockIdx] >> (idx % 8) & 1, nil
-	default:
-		return v.Buf[blockIdx] >> (7 - idx%8) & 1, nil
-	}
-}
-
-// Extend adds up to 8 bits to the receiver
-//
-// Given a byte b == 0b11010101
-// v.Extend(b, 4, LSB0) would add < 1, 0, 1, 0 >
-// v.Extend(b, 4, MSB0) would add < 1, 1, 0, 1 >
-//
-// Panics if count is out of range
-func (v *BitVector) Extend(val byte, count uint, order BitNumbering) {
-	if count > 8 {
-		log.Panicf("invalid count")
-	}
-
-	for i := uint(0); i < count; i++ {
-		switch order {
-		case LSB0:
-			v.Push((val >> i) & 1)
-		default:
-			v.Push((val >> (7 - i)) & 1)
-		}
-	}
-}
-
-// Take reads up to 8 bits at the given index.
-//
-// Given a BitVector < 1, 1, 0, 1, 0, 1, 0, 1 >
-// v.Take(0, 4, LSB0) would return 0b00001011
-// v.Take(0, 4, MSB0) would return 0b11010000
-//
-// Panics if count is out of range
-func (v *BitVector) Take(index uint, count uint, order BitNumbering) (out byte) {
-	if count > 8 {
-		log.Panicf("invalid count")
-	}
-
-	for i := uint(0); i < count; i++ {
-		val, _ := v.Get(index + i)
-
-		switch order {
-		case LSB0:
-			out |= val << i
-		default:
-			out |= val << (7 - i)
-		}
-	}
-	return
-}
-
-// Iterator returns a function, which when invoked, returns the number
-// of bits requested, and increments an internal cursor.
-//
-// When the end of the BitVector is reached, it returns zeroes indefinitely
-//
-// Panics if count is out of range
-func (v *BitVector) Iterator(order BitNumbering) func(uint) byte {
-	cursor := uint(0)
-	return func(count uint) (out byte) {
-		if count > 8 {
-			log.Panicf("invalid count")
-		}
-
-		out = v.Take(cursor, count, order)
-		cursor += count
-		return
-	}
-}
diff --git a/extern/rleplus/internal/bitvector_test.go b/extern/rleplus/internal/bitvector_test.go
deleted file mode 100644
index 2895db3a3..000000000
--- a/extern/rleplus/internal/bitvector_test.go
+++ /dev/null
@@ -1,136 +0,0 @@
-package bitvector_test
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-
-	bitvector "github.com/filecoin-project/lotus/extern/rleplus/internal"
-)
-
-func TestBitVector(t *testing.T) {
-	t.Run("zero value", func(t *testing.T) {
-		var v bitvector.BitVector
-
-		assert.Equal(t, bitvector.LSB0, v.BytePacking)
-	})
-
-	t.Run("Push", func(t *testing.T) {
-		// MSB0 bit numbering
-		v := bitvector.BitVector{BytePacking: bitvector.MSB0}
-		v.Push(1)
-		v.Push(0)
-		v.Push(1)
-		v.Push(1)
-
-		assert.Equal(t, byte(176), v.Buf[0])
-
-		// LSB0 bit numbering
-		v = bitvector.BitVector{BytePacking: bitvector.LSB0}
-		v.Push(1)
-		v.Push(0)
-		v.Push(1)
-		v.Push(1)
-
-		assert.Equal(t, byte(13), v.Buf[0])
-	})
-
-	t.Run("Get", func(t *testing.T) {
-		bits := []byte{1, 0, 1, 1, 0, 0, 1, 0}
-
-		for _, numbering := range []bitvector.BitNumbering{bitvector.MSB0, bitvector.LSB0} {
-			v := bitvector.BitVector{BytePacking: numbering}
-
-			for _, bit := range bits {
-				v.Push(bit)
-			}
-
-			for idx, expected := range bits {
-				actual, _ := v.Get(uint(idx))
-				assert.Equal(t, expected, actual)
-			}
-		}
-	})
-
-	t.Run("Extend", func(t *testing.T) {
-		val := byte(171) // 0b10101011
-
-		var v bitvector.BitVector
-
-		// MSB0 bit numbering
-		v = bitvector.BitVector{}
-		v.Extend(val, 4, bitvector.MSB0)
-		assertBitVector(t, []byte{1, 0, 1, 0}, v)
-		v.Extend(val, 5, bitvector.MSB0)
-		assertBitVector(t, []byte{1, 0, 1, 0, 1, 0, 1, 0, 1}, v)
-
-		// LSB0 bit numbering
-		v = bitvector.BitVector{}
-		v.Extend(val, 4, bitvector.LSB0)
-		assertBitVector(t, []byte{1, 1, 0, 1}, v)
-		v.Extend(val, 5, bitvector.LSB0)
-		assertBitVector(t, []byte{1, 1, 0, 1, 1, 1, 0, 1, 0}, v)
-	})
-
-	t.Run("invalid counts to Take/Extend/Iterator cause panics", func(t *testing.T) {
-		v := bitvector.BitVector{BytePacking: bitvector.LSB0}
-
-		assert.Panics(t, func() { v.Extend(0xff, 9, bitvector.LSB0) })
-
-		assert.Panics(t, func() { v.Take(0, 9, bitvector.LSB0) })
-
-		next := v.Iterator(bitvector.LSB0)
-		assert.Panics(t, func() { next(9) })
-	})
-
-	t.Run("Take", func(t *testing.T) {
-		var v bitvector.BitVector
-
-		bits := []byte{1, 0, 1, 0, 1, 0, 1, 1}
-		for _, bit := range bits {
-			v.Push(bit)
-		}
-
-		assert.Equal(t, byte(176), v.Take(4, 4, bitvector.MSB0))
-		assert.Equal(t, byte(13), v.Take(4, 4, bitvector.LSB0))
-	})
-
-	t.Run("Iterator", func(t *testing.T) {
-		var buf []byte
-
-		// make a bitvector of 256 sample bits
-		for i := 0; i < 32; i++ {
-			buf = append(buf, 128+32)
-		}
-
-		v := bitvector.NewBitVector(buf, bitvector.LSB0)
-
-		next := v.Iterator(bitvector.LSB0)
-
-		// compare to Get()
-		for i := uint(0); i < v.Len; i++ {
-			expected, _ := v.Get(i)
-			assert.Equal(t, expected, next(1))
-		}
-
-		// out of range should return zero
-		assert.Equal(t, byte(0), next(1))
-		assert.Equal(t, byte(0), next(8))
-
-		// compare to Take()
-		next = v.Iterator(bitvector.LSB0)
-		assert.Equal(t, next(5), v.Take(0, 5, bitvector.LSB0))
-		assert.Equal(t, next(8), v.Take(5, 8, bitvector.LSB0))
-	})
-}
-
-// Note: When using this helper assertion, expectedBits should *only* be 0s and 1s.
-func assertBitVector(t *testing.T, expectedBits []byte, actual bitvector.BitVector) {
-	assert.Equal(t, uint(len(expectedBits)), actual.Len)
-
-	for idx, bit := range expectedBits {
-		actualBit, err := actual.Get(uint(idx))
-		assert.NoError(t, err)
-		assert.Equal(t, bit, actualBit)
-	}
-}
diff --git a/extern/rleplus/rleplus.go b/extern/rleplus/rleplus.go
deleted file mode 100644
index 5d09c2e18..000000000
--- a/extern/rleplus/rleplus.go
+++ /dev/null
@@ -1,204 +0,0 @@
-package rleplus
-
-import (
-	"encoding/binary"
-	"errors"
-	"fmt"
-	"sort"
-
-	bitvector "github.com/filecoin-project/lotus/extern/rleplus/internal"
-)
-
-// Version is the 2 lowest bits of this constant
-const Version = 0
-
-var (
-	// ErrRunLengthTooLarge - data implies a run-length which isn't supported
-	ErrRunLengthTooLarge = fmt.Errorf("run length too large for RLE+ version %d", Version)
-
-	// ErrDecode - invalid encoding for this version
-	ErrDecode = fmt.Errorf("invalid encoding for RLE+ version %d", Version)
-
-	// ErrWrongVersion - wrong version of RLE+
-	ErrWrongVersion = errors.New("invalid RLE+ version")
-)
-
-// Encode returns the RLE+ representation of the provided integers.
-// Also returned is the number of bits required by this encoding,
-// which is not necessarily on a byte boundary.
-//
-// The RLE+ spec is here: https://github.com/filecoin-project/specs/blob/master/data-structures.md#rle-bitset-encoding
-// and is described by the BNF Grammar:
-//
-//    <encoding> ::= <header> <blocks>
-//    <header> ::= <version> <bit>
-//    <version> ::= "00"
-//    <blocks> ::= <block> <blocks> | ""
-//    <block> ::= <block_single> | <block_short> | <block_long>
-//    <block_single> ::= "1"
-//    <block_short> ::= "01" <bit> <bit> <bit> <bit>
-//    <block_long> ::= "00" <unsigned_varint>
-//    <bit> ::= "0" | "1"
-//
-// Filecoin specific:
-// The encoding is returned as a []byte, each byte packed starting with the low-order bit (LSB0)
-func Encode(ints []uint64) ([]byte, uint, error) {
-	v := bitvector.BitVector{BytePacking: bitvector.LSB0}
-	firstBit, runs := RunLengths(ints)
-
-	// Add version header
-	v.Extend(Version, 2, bitvector.LSB0)
-
-	v.Push(firstBit)
-
-	for _, run := range runs {
-		switch {
-		case run == 1:
-			v.Push(1)
-		case run < 16:
-			v.Push(0)
-			v.Push(1)
-			v.Extend(byte(run), 4, bitvector.LSB0)
-		case run >= 16:
-			v.Push(0)
-			v.Push(0)
-			// 10 bytes needed to encode MaxUint64
-			buf := make([]byte, 10)
-			numBytes := binary.PutUvarint(buf, run)
-			for i := 0; i < numBytes; i++ {
-				v.Extend(buf[i], 8, bitvector.LSB0)
-			}
-		default:
-			return nil, 0, ErrRunLengthTooLarge
-		}
-	}
-
-	return v.Buf, v.Len, nil
-}
-
-// Decode returns integers represented by the given RLE+ encoding
-//
-// The length of the encoding is not specified.  It is inferred by
-// reading zeroes from the (possibly depleted) BitVector, by virtue
-// of the behavior of BitVector.Take() returning 0 when the end of
-// the BitVector has been reached. This has the downside of not
-// being able to detect corrupt encodings.
-//
-// The passed []byte should be packed in LSB0 bit numbering
-func Decode(buf []byte) (ints []uint64, err error) {
-	if len(buf) == 0 {
-		return
-	}
-
-	v := bitvector.NewBitVector(buf, bitvector.LSB0)
-	take := v.Iterator(bitvector.LSB0)
-
-	// Read version and check
-	// Version check
-	ver := take(2)
-	if ver != Version {
-		return nil, ErrWrongVersion
-	}
-
-	curIdx := uint64(0)
-	curBit := take(1)
-	var runLength int
-	done := false
-
-	for done == false {
-		y := take(1)
-		switch y {
-		case 1:
-			runLength = 1
-		case 0:
-			val := take(1)
-
-			if val == 1 {
-				// short block
-				runLength = int(take(4))
-			} else {
-				// long block
-				var buf []byte
-				for {
-					b := take(8)
-					buf = append(buf, b)
-
-					if b&0x80 == 0 {
-						break
-					}
-
-					// 10 bytes is required to store math.MaxUint64 in a uvarint
-					if len(buf) > 10 {
-						return nil, ErrDecode
-					}
-				}
-				x, _ := binary.Uvarint(buf)
-
-				if x == 0 {
-					done = true
-				}
-				runLength = int(x)
-			}
-		}
-
-		if curBit == 1 {
-			for j := 0; j < runLength; j++ {
-				ints = append(ints, curIdx+uint64(j))
-			}
-		}
-		curIdx += uint64(runLength)
-		curBit = 1 - curBit
-	}
-
-	return
-}
-
-// RunLengths transforms integers into its bit-set-run-length representation.
-//
-// A set of unsigned integers { 0, 2, 4, 5, 6 } can be thought of as
-// indices into a bitset { 1, 0, 1, 0, 1, 1, 1 } where bitset[index] == 1.
-//
-// The bit set run lengths of this set would then be { 1, 1, 1, 1, 3 },
-// representing lengths of runs alternating between 1 and 0, starting
-// with a first bit of 1.
-//
-// Duplicated numbers are ignored.
-//
-// This is a helper function for Encode()
-func RunLengths(ints []uint64) (firstBit byte, runs []uint64) {
-	if len(ints) == 0 {
-		return
-	}
-
-	// Sort our incoming numbers
-	sort.Slice(ints, func(i, j int) bool { return ints[i] < ints[j] })
-
-	prev := ints[0]
-
-	// Initialize our return value
-	if prev == 0 {
-		firstBit = 1
-	}
-
-	if firstBit == 0 {
-		// first run of zeroes
-		runs = append(runs, prev)
-	}
-	runs = append(runs, 1)
-
-	for _, cur := range ints[1:] {
-		delta := cur - prev
-		switch {
-		case delta == 1:
-			runs[len(runs)-1]++
-		case delta > 1:
-			// add run of zeroes if there is a gap
-			runs = append(runs, delta-1)
-			runs = append(runs, 1)
-		default:
-			// repeated number?
-		}
-		prev = cur
-	}
-	return
-}
diff --git a/extern/rleplus/rleplus_test.go b/extern/rleplus/rleplus_test.go
deleted file mode 100644
index ecb2259e6..000000000
--- a/extern/rleplus/rleplus_test.go
+++ /dev/null
@@ -1,213 +0,0 @@
-package rleplus_test
-
-import (
-	"fmt"
-	"math"
-	"sort"
-	"testing"
-
-	"github.com/filecoin-project/lotus/extern/rleplus"
-	bitvector "github.com/filecoin-project/lotus/extern/rleplus/internal"
-	"gotest.tools/assert"
-)
-
-func TestRleplus(t *testing.T) {
-
-	t.Run("Encode", func(t *testing.T) {
-		// Encode an intset
-		ints := []uint64{
-			// run of 1
-			0,
-			// gap of 1
-			// run of 1
-			2,
-			// gap of 1
-			// run of 3
-			4, 5, 6,
-			// gap of 4
-			// run of 17
-			11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
-		}
-
-		expectedBits := []byte{
-			0, 0, // version
-			1,                // first bit
-			1,                // run of 1
-			1,                // gap of 1
-			1,                // run of 1
-			1,                // gap of 1
-			0, 1, 1, 1, 0, 0, // run of 3
-			0, 1, 0, 0, 1, 0, // gap of 4
-
-			// run of 17 < 0 0 (varint) >
-			0, 0,
-			1, 0, 0, 0, 1, 0, 0, 0,
-		}
-
-		v := bitvector.BitVector{}
-		for _, bit := range expectedBits {
-			v.Push(bit)
-		}
-		actualBytes, _, err := rleplus.Encode(ints)
-		assert.NilError(t, err)
-
-		assert.Equal(t, len(v.Buf), len(actualBytes))
-		for idx, expected := range v.Buf {
-			assert.Equal(
-				t,
-				fmt.Sprintf("%08b", expected),
-				fmt.Sprintf("%08b", actualBytes[idx]),
-			)
-		}
-	})
-
-	t.Run("Encode allows all runs sizes possible uint64", func(t *testing.T) {
-		// create a run of math.MaxUint64
-		ints := []uint64{math.MaxUint64}
-
-		// There would be 64 bits(1) for the UvarInt, totally 9 bytes.
-		expected := []byte{0xe0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0x20}
-		encodeBytes, _, err := rleplus.Encode(ints)
-		assert.NilError(t, err)
-		for idx, v := range encodeBytes {
-			assert.Equal(
-				t,
-				fmt.Sprintf("%8b", v),
-				fmt.Sprintf("%8b", expected[idx]),
-			)
-		}
-	})
-
-	t.Run("Encode for some big numbers", func(t *testing.T) {
-		// create a run of math.MaxUint64
-		ints := make([]uint64, 1024)
-
-		// ints {2^63 .. 2^63+1023}
-		for i := uint64(0); i < 1024; i++ {
-			ints[i] = uint64(1)<<63 + i
-		}
-
-		expected := []byte{0x00, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x30, 0x00, 0x40, 0x04}
-		encodeBytes, _, err := rleplus.Encode(ints)
-		assert.NilError(t, err)
-		for idx, v := range encodeBytes {
-			// fmt.Println(v, expected[idx])
-			assert.Equal(
-				t,
-				fmt.Sprintf("%8b", v),
-				fmt.Sprintf("%8b", expected[idx]),
-			)
-		}
-	})
-
-	t.Run("Decode", func(t *testing.T) {
-		testCases := [][]uint64{
-			{},
-			{1},
-			{0},
-			{0, 1, 2, 3},
-			{
-				// run of 1
-				0,
-				// gap of 1
-				// run of 1
-				2,
-				// gap of 1
-				// run of 3
-				4, 5, 6,
-				// gap of 4
-				// run of 17
-				11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
-			},
-		}
-
-		for _, tc := range testCases {
-			encoded, _, err := rleplus.Encode(tc)
-			assert.NilError(t, err)
-
-			result, err := rleplus.Decode(encoded)
-			assert.NilError(t, err)
-
-			sort.Slice(tc, func(i, j int) bool { return tc[i] < tc[j] })
-			sort.Slice(result, func(i, j int) bool { return result[i] < result[j] })
-
-			assert.Equal(t, len(tc), len(result))
-
-			for idx, expected := range tc {
-				assert.Equal(t, expected, result[idx])
-			}
-		}
-	})
-
-	t.Run("Decode version check", func(t *testing.T) {
-		_, err := rleplus.Decode([]byte{0xff})
-		assert.Error(t, err, "invalid RLE+ version")
-	})
-
-	t.Run("Decode returns an error with a bad encoding", func(t *testing.T) {
-		// create an encoding with a buffer with a run which is too long
-		_, err := rleplus.Decode([]byte{0xe0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff})
-		assert.Error(t, err, "invalid encoding for RLE+ version 0")
-	})
-
-	t.Run("outputs same as reference implementation", func(t *testing.T) {
-		// Encoding bitvec![LittleEndian; 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
-		// in the Rust reference implementation gives an encoding of [223, 145, 136, 0] (without version field)
-		// The bit vector is equivalent to the integer set { 0, 2, 4, 5, 6, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27 }
-
-		// This is the above reference output with a version header "00" manually added
-		referenceEncoding := []byte{124, 71, 34, 2}
-
-		expectedNumbers := []uint64{0, 2, 4, 5, 6, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27}
-
-		encoded, _, err := rleplus.Encode(expectedNumbers)
-		assert.NilError(t, err)
-
-		// Our encoded bytes are the same as the ref bytes
-		assert.Equal(t, len(referenceEncoding), len(encoded))
-		for idx, expected := range referenceEncoding {
-			assert.Equal(t, expected, encoded[idx])
-		}
-
-		decoded, err := rleplus.Decode(referenceEncoding)
-		assert.NilError(t, err)
-
-		// Our decoded integers are the same as expected
-		sort.Slice(decoded, func(i, j int) bool { return decoded[i] < decoded[j] })
-		assert.Equal(t, len(expectedNumbers), len(decoded))
-		for idx, expected := range expectedNumbers {
-			assert.Equal(t, expected, decoded[idx])
-		}
-	})
-
-	t.Run("RunLengths", func(t *testing.T) {
-		testCases := []struct {
-			ints  []uint64
-			first byte
-			runs  []uint64
-		}{
-			// empty
-			{},
-
-			// leading with ones
-			{[]uint64{0}, 1, []uint64{1}},
-			{[]uint64{0, 1}, 1, []uint64{2}},
-			{[]uint64{0, 0xffffffff, 0xffffffff + 1}, 1, []uint64{1, 0xffffffff - 1, 2}},
-
-			// leading with zeroes
-			{[]uint64{1}, 0, []uint64{1, 1}},
-			{[]uint64{2}, 0, []uint64{2, 1}},
-			{[]uint64{10, 11, 13, 20}, 0, []uint64{10, 2, 1, 1, 6, 1}},
-			{[]uint64{10, 11, 11, 13, 20, 10, 11, 13, 20}, 0, []uint64{10, 2, 1, 1, 6, 1}},
-		}
-
-		for _, testCase := range testCases {
-			first, runs := rleplus.RunLengths(testCase.ints)
-			assert.Equal(t, testCase.first, first)
-			assert.Equal(t, len(testCase.runs), len(runs))
-			for idx, runLength := range testCase.runs {
-				assert.Equal(t, runLength, runs[idx])
-			}
-		}
-	})
-}
diff --git a/extern/sector-storage/README.md b/extern/sector-storage/README.md
new file mode 100644
index 000000000..a4661f9d8
--- /dev/null
+++ b/extern/sector-storage/README.md
@@ -0,0 +1,61 @@
+# sector-storage
+
+[![](https://img.shields.io/badge/made%20by-Protocol%20Labs-blue.svg?style=flat-square)](http://ipn.io)
+[![CircleCI](https://circleci.com/gh/filecoin-project/sector-storage.svg?style=svg)](https://circleci.com/gh/filecoin-project/sector-storage)
+[![standard-readme compliant](https://img.shields.io/badge/standard--readme-OK-green.svg?style=flat-square)](https://github.com/RichardLitt/standard-readme)
+
+> a concrete implementation of the [specs-storage](https://github.com/filecoin-project/specs-storage) interface
+
+The sector-storage project provides a implementation-nonspecific reference implementation of the [specs-storage](https://github.com/filecoin-project/specs-storage) interface.
+
+## Disclaimer
+
+Please report your issues with regards to sector-storage at the [lotus issue tracker](https://github.com/filecoin-project/lotus/issues)
+
+## Architecture
+
+![high-level architecture](docs/sector-storage.svg)
+
+### `Manager`
+
+Manages is the top-level piece of the storage system gluing all the other pieces
+together. It also implements scheduling logic.
+
+### `package stores`
+
+This package implements the sector storage subsystem. Fundamentally the storage
+is divided into `path`s, each path has it's UUID, and stores a set of sector
+'files'. There are currently 3 types of sector files - `unsealed`, `sealed`,
+and `cache`.
+
+Paths can be shared between nodes by sharing the underlying filesystem.
+
+### `stores.Local`
+
+The Local store implements SectorProvider for paths mounted in the local
+filesystem. Paths can be shared between nodes, and support shared filesystems
+such as NFS.
+
+stores.Local implements all native filesystem-related operations 
+
+### `stores.Remote`
+
+The Remote store extends Local store, handles fetching sector files into a local
+store if needed, and handles removing sectors from non-local stores.
+
+### `stores.Index`
+
+The Index is a singleton holding metadata about storage paths, and a mapping of
+sector files to paths
+
+### `LocalWorker`
+
+LocalWorker implements the Worker interface with ffiwrapper.Sealer and a
+store.Store instance
+
+## License
+
+The Filecoin Project is dual-licensed under Apache 2.0 and MIT terms:
+
+- Apache License, Version 2.0, ([LICENSE-APACHE](https://github.com/filecoin-project/sector-storage/blob/master/LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0)
+- MIT license ([LICENSE-MIT](https://github.com/filecoin-project/sector-storage/blob/master/LICENSE-MIT) or http://opensource.org/licenses/MIT)
diff --git a/extern/sector-storage/docs/sector-storage.svg b/extern/sector-storage/docs/sector-storage.svg
new file mode 100644
index 000000000..3978ef2f8
--- /dev/null
+++ b/extern/sector-storage/docs/sector-storage.svg
@@ -0,0 +1,3 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg xmlns="http://www.w3.org/2000/svg" style="background-color: rgb(255, 255, 255);" xmlns:xlink="http://www.w3.org/1999/xlink" version="1.1" width="851px" height="1001px" viewBox="-0.5 -0.5 851 1001" content="&lt;mxfile host=&quot;app.diagrams.net&quot; modified=&quot;2020-04-06T17:42:42.123Z&quot; agent=&quot;5.0 (X11)&quot; etag=&quot;ilAX9XQorx-cbKmfSJum&quot; version=&quot;12.9.8&quot; type=&quot;browser&quot;&gt;&lt;diagram id=&quot;6lDjA8ebbJXz-MvvKowY&quot; name=&quot;Page-1&quot;&gt;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&lt;/diagram&gt;&lt;/mxfile&gt;"><defs/><g><rect x="0" y="680" width="610" height="320" fill="#bac8d3" stroke="#23445d" pointer-events="all"/><rect x="479.5" y="680" width="120" height="50" fill="none" stroke="#000000" pointer-events="all"/><rect x="0" y="0" width="850" height="640" fill="#bac8d3" stroke="#23445d" pointer-events="all"/><rect x="0" y="30" width="840" height="470" fill="#fad9d5" stroke="#ae4132" pointer-events="all"/><rect x="60" y="440" width="770" height="60" fill="#fad9d5" stroke="#ae4132" stroke-dasharray="3 3" pointer-events="all"/><rect x="500" y="110" width="285" height="210" fill="#d5e8d4" stroke="#82b366" pointer-events="all"/><rect x="605" y="110" width="80" height="20" fill="none" stroke="none" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 78px; height: 1px; padding-top: 120px; margin-left: 606px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; "><div>LocalWorker</div></div></div></div></foreignObject><text x="645" y="124" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">LocalWorker</text></switch></g><path d="M 620 170 L 640 170 L 640 230 L 626.37 230" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 621.12 230 L 628.12 226.5 L 626.37 230 L 628.12 233.5 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/><rect x="500" y="160" width="120" height="20" fill="#d5e8d4" stroke="#82b366" pointer-events="all"/><rect x="500" y="160" width="70" height="20" fill="none" stroke="none" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 68px; height: 1px; padding-top: 170px; margin-left: 501px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">stores.Local</div></div></div></foreignObject><text x="535" y="174" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">stores.Local</text></switch></g><path d="M 620 140 L 710 140 L 710 273.63" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 710 278.88 L 706.5 271.88 L 710 273.63 L 713.5 271.88 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/><rect x="500" y="130" width="120" height="20" fill="#d5e8d4" stroke="#82b366" pointer-events="all"/><rect x="500" y="130" width="70" height="20" fill="none" stroke="none" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 68px; height: 1px; padding-top: 140px; margin-left: 501px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">stores.Store</div></div></div></foreignObject><text x="535" y="144" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">stores.Store</text></switch></g><path d="M 620 200 L 680 200 L 680 273.63" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 680 278.88 L 676.5 271.88 L 680 273.63 L 683.5 271.88 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/><rect x="500" y="190" width="120" height="20" fill="#d5e8d4" stroke="#82b366" pointer-events="all"/><rect x="500" y="190" width="100" height="20" fill="none" stroke="none" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 98px; height: 1px; padding-top: 200px; margin-left: 501px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">stores.SectorIndex</div></div></div></foreignObject><text x="550" y="204" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">stores.SectorInd...</text></switch></g><rect x="510" y="250" width="140" height="60" fill="#dae8fc" stroke="#6c8ebf" pointer-events="all"/><rect x="535" y="250" width="90" height="24" fill="none" stroke="none" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 88px; height: 1px; padding-top: 262px; margin-left: 536px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; "><div>ffiwrapper.Sealer</div></div></div></div></foreignObject><text x="580" y="266" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">ffiwrapper.Seal...</text></switch></g><rect x="565" y="286" width="85" height="24" fill="none" stroke="none" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 83px; height: 1px; padding-top: 298px; margin-left: 566px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">SectorProvider</div></div></div></foreignObject><text x="608" y="302" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">SectorProvider</text></switch></g><path d="M 650 280 L 575 280 Q 565 280 565 290 L 565 310" fill="none" stroke="#6c8ebf" stroke-miterlimit="10" pointer-events="stroke"/><rect x="650" y="280" width="120" height="30" fill="#d5e8d4" stroke="#82b366" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 118px; height: 1px; padding-top: 295px; margin-left: 651px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">localProvider</div></div></div></foreignObject><text x="710" y="299" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">localProvider</text></switch></g><path d="M 710 310 L 710 310" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 710 310 L 710 310 L 710 310 L 710 310 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/><rect x="500" y="220" width="120" height="20" fill="#d5e8d4" stroke="#82b366" stroke-dasharray="3 3" pointer-events="all"/><path d="M 500 230 L 470 230 L 470 270 L 446.37 270" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 441.12 270 L 448.12 266.5 L 446.37 270 L 448.12 273.5 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/><rect x="500" y="220" width="40" height="20" fill="none" stroke="none" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 38px; height: 1px; padding-top: 230px; margin-left: 501px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">Worker</div></div></div></foreignObject><text x="520" y="234" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">Worker</text></switch></g><path d="M 557.5 250 L 560 250 L 560 246.37" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 560 241.12 L 563.5 248.12 L 560 246.37 L 556.5 248.12 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/><rect x="10" y="70" width="220" height="160" fill="#ffe6cc" stroke="#d79b00" pointer-events="all"/><rect x="77.5" y="70" width="85" height="20" fill="none" stroke="none" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 83px; height: 1px; padding-top: 80px; margin-left: 79px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; "><div>stores.Remote</div></div></div></div></foreignObject><text x="120" y="84" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">stores.Remote</text></switch></g><rect x="30" y="130" width="170" height="100" fill="#e1d5e7" stroke="#9673a6" pointer-events="all"/><rect x="80" y="130" width="70" height="20" fill="none" stroke="none" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 68px; height: 1px; padding-top: 140px; margin-left: 81px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">stores.Local</div></div></div></foreignObject><text x="115" y="144" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">stores.Local</text></switch></g><rect x="80" y="150" width="120" height="20" fill="#e1d5e7" stroke="#9673a6" pointer-events="all"/><rect x="100" y="150" width="100" height="20" fill="none" stroke="none" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 98px; height: 1px; padding-top: 160px; margin-left: 101px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">stores.SectorIndex</div></div></div></foreignObject><text x="150" y="164" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">stores.SectorInd...</text></switch></g><rect x="40" y="180" width="100" height="20" fill="none" stroke="none" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 98px; height: 1px; padding-top: 190px; margin-left: 41px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; "><div>localPaths []string</div></div></div></div></foreignObject><text x="90" y="194" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">localPaths []str...</text></switch></g><rect x="40" y="200" width="70" height="20" fill="none" stroke="none" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 68px; height: 1px; padding-top: 210px; margin-left: 41px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">urls []string</div></div></div></foreignObject><text x="75" y="214" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">urls []stri...</text></switch></g><rect x="110" y="100" width="120" height="20" fill="#ffe6cc" stroke="#d79b00" pointer-events="all"/><rect x="110" y="100" width="120" height="20" fill="#ffe6cc" stroke="#d79b00" pointer-events="all"/><rect x="130" y="100" width="100" height="20" fill="none" stroke="none" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 98px; height: 1px; padding-top: 110px; margin-left: 131px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">stores.SectorIndex</div></div></div></foreignObject><text x="180" y="114" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">stores.SectorInd...</text></switch></g><path d="M 200 180 L 200 170 L 493.63 170" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 498.88 170 L 491.88 173.5 L 493.63 170 L 491.88 166.5 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/><path d="M 230 150 L 230 140 L 493.63 140" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 498.88 140 L 491.88 143.5 L 493.63 140 L 491.88 136.5 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/><path d="M 145 390 L 145 430 L 145 430 L 145 463.63" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 145 468.88 L 141.5 461.88 L 145 463.63 L 148.5 461.88 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/><rect x="20" y="300" width="250" height="90" fill="#ffff88" stroke="#36393d" pointer-events="all"/><rect x="85" y="300" width="120" height="20" fill="none" stroke="none" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 118px; height: 1px; padding-top: 310px; margin-left: 86px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">specs-storage.Prover</div></div></div></foreignObject><text x="145" y="314" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">specs-storage.Prover</text></switch></g><rect x="170" y="350" width="90" height="30" fill="#ffff88" stroke="#36393d" pointer-events="all"/><rect x="170" y="355" width="90" height="25" fill="none" stroke="none" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 88px; height: 1px; padding-top: 368px; margin-left: 171px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">ronlyProvider</div></div></div></foreignObject><text x="215" y="371" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">ronlyProvider</text></switch></g><path d="M 157.5 230 L 157.5 290 L 215 290 L 215 343.63" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 215 348.88 L 211.5 341.88 L 215 343.63 L 218.5 341.88 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/><path d="M 230 110 L 230 110" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 230 110 L 230 110 L 230 110 L 230 110 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/><rect x="340" y="70" width="120" height="20" fill="#b1ddf0" stroke="#10739e" pointer-events="all"/><rect x="340" y="70" width="120" height="20" fill="none" stroke="none" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 118px; height: 1px; padding-top: 80px; margin-left: 341px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">stores.Index</div></div></div></foreignObject><text x="400" y="84" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">stores.Index</text></switch></g><path d="M 400 90 L 400 110 L 236.37 110" fill="none" stroke="#10739e" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 231.12 110 L 238.12 106.5 L 236.37 110 L 238.12 113.5 Z" fill="#10739e" stroke="#10739e" stroke-miterlimit="10" pointer-events="all"/><path d="M 400 90 L 400 200 L 493.63 200" fill="none" stroke="#10739e" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 498.88 200 L 491.88 203.5 L 493.63 200 L 491.88 196.5 Z" fill="#10739e" stroke="#10739e" stroke-miterlimit="10" pointer-events="all"/><path d="M 400 90 L 400 160 L 206.37 160" fill="none" stroke="#10739e" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 201.12 160 L 208.12 156.5 L 206.37 160 L 208.12 163.5 Z" fill="#10739e" stroke="#10739e" stroke-miterlimit="10" pointer-events="all"/><rect x="415" y="470" width="120" height="30" fill="#fad9d5" stroke="#ae4132" pointer-events="all"/><rect x="435" y="470" width="80" height="30" fill="none" stroke="none" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 78px; height: 1px; padding-top: 485px; margin-left: 436px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">FetchHandler</div></div></div></foreignObject><text x="475" y="489" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">FetchHandler</text></switch></g><rect x="30" y="320" width="140" height="60" fill="#dae8fc" stroke="#6c8ebf" pointer-events="all"/><rect x="55" y="320" width="90" height="24" fill="none" stroke="none" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 88px; height: 1px; padding-top: 332px; margin-left: 56px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; "><div>ffiwrapper.Sealer</div></div></div></div></foreignObject><text x="100" y="336" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">ffiwrapper.Seal...</text></switch></g><rect x="85" y="356" width="85" height="24" fill="none" stroke="none" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 83px; height: 1px; padding-top: 368px; margin-left: 86px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">SectorProvider</div></div></div></foreignObject><text x="128" y="372" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">SectorProvider</text></switch></g><path d="M 170 350 L 95 350 Q 85 350 85 360 L 85 380" fill="none" stroke="#6c8ebf" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 270 470 L 270 450 L 327.5 450 L 327.5 416.37" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 327.5 411.12 L 331 418.12 L 327.5 416.37 L 324 418.12 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/><rect x="225" y="470" width="180" height="30" fill="#fad9d5" stroke="#ae4132" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 178px; height: 1px; padding-top: 485px; margin-left: 226px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; "><div>specs-storage.[Sealer,Storage]</div></div></div></div></foreignObject><text x="315" y="489" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">specs-storage.[Sealer,Storage]</text></switch></g><rect x="75" y="470" width="140" height="30" fill="#fad9d5" stroke="#ae4132" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 138px; height: 1px; padding-top: 485px; margin-left: 76px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">specs-storage.Prover</div></div></div></foreignObject><text x="145" y="489" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">specs-storage.Prover</text></switch></g><rect x="715" y="440" width="120" height="20" fill="none" stroke="none" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 118px; height: 1px; padding-top: 450px; margin-left: 716px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">Manager API</div></div></div></foreignObject><text x="775" y="454" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">Manager API</text></switch></g><path d="M 157.5 230 L 157.5 290 L 280 290 L 280 430 L 475 430 L 475 463.63" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 475 468.88 L 471.5 461.88 L 475 463.63 L 478.5 461.88 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/><rect x="290" y="220" width="150" height="190" rx="22.5" ry="22.5" fill="#fad9d5" stroke="#ae4132" stroke-dasharray="3 3" pointer-events="all"/><rect x="335" y="220" width="60" height="20" fill="none" stroke="none" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 58px; height: 1px; padding-top: 230px; margin-left: 336px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">Scheduler</div></div></div></foreignObject><text x="365" y="234" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">Scheduler</text></switch></g><rect x="320" y="240" width="120" height="110" fill="#fad9d5" stroke="#ae4132" stroke-dasharray="3 3" pointer-events="all"/><rect x="320" y="240" width="120" height="20" fill="none" stroke="none" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 118px; height: 1px; padding-top: 250px; margin-left: 321px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">[]workerHandle</div></div></div></foreignObject><text x="380" y="254" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">[]workerHandle</text></switch></g><rect x="340" y="260" width="100" height="40" fill="#fad9d5" stroke="#ae4132" stroke-dasharray="3 3" pointer-events="all"/><rect x="395" y="260" width="45" height="20" fill="none" stroke="none" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 43px; height: 1px; padding-top: 270px; margin-left: 396px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">Worker</div></div></div></foreignObject><text x="418" y="274" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">Worker</text></switch></g><rect x="390" y="305" width="40" height="20" fill="none" stroke="none" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 38px; height: 1px; padding-top: 315px; margin-left: 391px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">WorkerInfo</div></div></div></foreignObject><text x="410" y="319" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">Worker...</text></switch></g><rect x="370" y="320" width="70" height="20" fill="none" stroke="none" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 68px; height: 1px; padding-top: 330px; margin-left: 371px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">resourceInfo</div></div></div></foreignObject><text x="405" y="334" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">resourceInfo</text></switch></g><path d="M 380 350 L 380 350" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 380 350 L 380 350 L 380 350 L 380 350 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/><rect x="330" y="380" width="70" height="20" fill="none" stroke="none" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 68px; height: 1px; padding-top: 390px; margin-left: 331px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">schedQueue</div></div></div></foreignObject><text x="365" y="394" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">schedQueue</text></switch></g><rect x="545" y="470" width="120" height="30" fill="#b1ddf0" stroke="#10739e" stroke-dasharray="3 3" pointer-events="all"/><path d="M 575 466.13 L 575 410 L 480 410 L 480 200" fill="none" stroke="#10739e" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 575 471.38 L 571.5 464.38 L 575 466.13 L 578.5 464.38 Z" fill="#10739e" stroke="#10739e" stroke-miterlimit="10" pointer-events="all"/><path d="M 600 503.87 L 600 533.8 L 650 533.8 L 650 570" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 600 498.62 L 603.5 505.62 L 600 503.87 L 596.5 505.62 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/><rect x="550" y="472.5" width="100" height="25" fill="none" stroke="none" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 98px; height: 1px; padding-top: 485px; margin-left: 551px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">stores.SectorIndex</div></div></div></foreignObject><text x="600" y="489" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">stores.SectorInd...</text></switch></g><rect x="347.5" y="40" width="145" height="20" fill="none" stroke="none" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 143px; height: 1px; padding-top: 50px; margin-left: 349px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">sector-storage.Manager</div></div></div></foreignObject><text x="420" y="54" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">sector-storage.Manager</text></switch></g><path d="M 712.5 470 L 690 470 L 690 400 L 470 400 L 470 290 L 446.37 290" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 441.12 290 L 448.12 286.5 L 446.37 290 L 448.12 293.5 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/><rect x="675" y="470" width="150" height="30" fill="none" stroke="#000000" pointer-events="all"/><path d="M 750 501.37 L 750 532.5 L 735 532.5 L 735 570" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 750 496.12 L 753.5 503.12 L 750 501.37 L 746.5 503.12 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/><rect x="675" y="475" width="150" height="20" fill="none" stroke="none" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 148px; height: 1px; padding-top: 485px; margin-left: 676px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">worker management APIs</div></div></div></foreignObject><text x="750" y="489" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">worker management APIs</text></switch></g><rect x="0" y="0" width="120" height="30" fill="none" stroke="none" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 118px; height: 1px; padding-top: 15px; margin-left: 1px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">Filecoin 'Miner' Node</div></div></div></foreignObject><text x="60" y="19" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">Filecoin 'Miner' Node</text></switch></g><rect x="330" y="560" width="490" height="80" fill="none" stroke="#000000" pointer-events="all"/><rect x="330" y="560" width="60" height="20" fill="none" stroke="none" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 58px; height: 1px; padding-top: 570px; margin-left: 331px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">HTTP API</div></div></div></foreignObject><text x="360" y="574" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">HTTP API</text></switch></g><rect x="350" y="610" width="120" height="30" fill="#bac8d3" stroke="#23445d" pointer-events="all"/><rect x="370" y="610" width="80" height="30" fill="none" stroke="none" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 78px; height: 1px; padding-top: 625px; margin-left: 371px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">/remote</div></div></div></foreignObject><text x="410" y="629" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">/remote</text></switch></g><path d="M 410 603.63 L 410 530 L 475 530 L 475 500" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 410 608.88 L 406.5 601.88 L 410 603.63 L 413.5 601.88 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/><rect x="480" y="570" width="340" height="70" fill="none" stroke="#000000" pointer-events="all"/><rect x="480" y="570" width="60" height="20" fill="none" stroke="none" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 58px; height: 1px; padding-top: 580px; margin-left: 481px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; "><div>JsonRPC</div></div></div></div></foreignObject><text x="510" y="584" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">JsonRPC</text></switch></g><path d="M 550 646.37 L 550 660 L 300 660 L 300 680" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 550 641.12 L 553.5 648.12 L 550 646.37 L 546.5 648.12 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/><rect x="490" y="610" width="120" height="30" fill="none" stroke="#000000" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 118px; height: 1px; padding-top: 625px; margin-left: 491px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">/rpc/v0</div></div></div></foreignObject><text x="550" y="629" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">/rpc/v0</text></switch></g><rect x="291" y="780" width="285" height="210" fill="#d5e8d4" stroke="#82b366" pointer-events="all"/><rect x="396" y="780" width="80" height="20" fill="none" stroke="none" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 78px; height: 1px; padding-top: 790px; margin-left: 397px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; "><div>LocalWorker</div></div></div></div></foreignObject><text x="436" y="794" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">LocalWorker</text></switch></g><path d="M 411 840 L 431 840 L 431 900 L 417.37 900" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 412.12 900 L 419.12 896.5 L 417.37 900 L 419.12 903.5 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/><rect x="291" y="830" width="120" height="20" fill="#d5e8d4" stroke="#82b366" pointer-events="all"/><rect x="291" y="830" width="70" height="20" fill="none" stroke="none" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 68px; height: 1px; padding-top: 840px; margin-left: 292px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">stores.Local</div></div></div></foreignObject><text x="326" y="844" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">stores.Local</text></switch></g><path d="M 411 810 L 501 810 L 501 943.63" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 501 948.88 L 497.5 941.88 L 501 943.63 L 504.5 941.88 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/><rect x="291" y="800" width="120" height="20" fill="#d5e8d4" stroke="#82b366" pointer-events="all"/><path d="M 284.63 810 L 260.5 810 L 260.5 820 L 230 820" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 289.88 810 L 282.88 813.5 L 284.63 810 L 282.88 806.5 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/><rect x="291" y="800" width="70" height="20" fill="none" stroke="none" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 68px; height: 1px; padding-top: 810px; margin-left: 292px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">stores.Store</div></div></div></foreignObject><text x="326" y="814" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">stores.Store</text></switch></g><path d="M 411 870 L 471 870 L 471 943.63" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 471 948.88 L 467.5 941.88 L 471 943.63 L 474.5 941.88 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/><rect x="291" y="860" width="120" height="20" fill="#d5e8d4" stroke="#82b366" pointer-events="all"/><path d="M 284.63 870 L 270.3 870 L 270.25 700" fill="none" stroke="#10739e" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 289.88 870 L 282.88 873.5 L 284.63 870 L 282.88 866.5 Z" fill="#10739e" stroke="#10739e" stroke-miterlimit="10" pointer-events="all"/><rect x="291" y="860" width="100" height="20" fill="none" stroke="none" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 98px; height: 1px; padding-top: 870px; margin-left: 292px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">stores.SectorIndex</div></div></div></foreignObject><text x="341" y="874" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">stores.SectorInd...</text></switch></g><rect x="301" y="920" width="140" height="60" fill="#dae8fc" stroke="#6c8ebf" pointer-events="all"/><rect x="326" y="920" width="90" height="24" fill="none" stroke="none" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 88px; height: 1px; padding-top: 932px; margin-left: 327px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; "><div>ffiwrapper.Sealer</div></div></div></div></foreignObject><text x="371" y="936" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">ffiwrapper.Seal...</text></switch></g><rect x="356" y="956" width="85" height="24" fill="none" stroke="none" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 83px; height: 1px; padding-top: 968px; margin-left: 357px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">SectorProvider</div></div></div></foreignObject><text x="399" y="972" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">SectorProvider</text></switch></g><path d="M 441 950 L 366 950 Q 356 950 356 960 L 356 980" fill="none" stroke="#6c8ebf" stroke-miterlimit="10" pointer-events="stroke"/><rect x="441" y="950" width="120" height="30" fill="#d5e8d4" stroke="#82b366" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 118px; height: 1px; padding-top: 965px; margin-left: 442px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">localProvider</div></div></div></foreignObject><text x="501" y="969" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">localProvider</text></switch></g><path d="M 501 980 L 501 980" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 501 980 L 501 980 L 501 980 L 501 980 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/><rect x="291" y="890" width="120" height="20" fill="#d5e8d4" stroke="#82b366" stroke-dasharray="3 3" pointer-events="all"/><path d="M 291 900 L 250 900 L 250 715 L 349.63 715" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 354.88 715 L 347.88 718.5 L 349.63 715 L 347.88 711.5 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/><rect x="291" y="890" width="40" height="20" fill="none" stroke="none" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 38px; height: 1px; padding-top: 900px; margin-left: 292px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">Worker</div></div></div></foreignObject><text x="311" y="904" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">Worker</text></switch></g><path d="M 348.5 920 L 351 920 L 351 916.37" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 351 911.12 L 354.5 918.12 L 351 916.37 L 347.5 918.12 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/><rect x="10" y="740" width="220" height="160" fill="#ffe6cc" stroke="#d79b00" pointer-events="all"/><rect x="77.5" y="740" width="85" height="20" fill="none" stroke="none" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 83px; height: 1px; padding-top: 750px; margin-left: 79px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; "><div>stores.Remote</div></div></div></div></foreignObject><text x="120" y="754" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">stores.Remote</text></switch></g><rect x="30" y="800" width="170" height="100" fill="#e1d5e7" stroke="#9673a6" pointer-events="all"/><rect x="80" y="800" width="70" height="20" fill="none" stroke="none" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 68px; height: 1px; padding-top: 810px; margin-left: 81px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">stores.Local</div></div></div></foreignObject><text x="115" y="814" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">stores.Local</text></switch></g><rect x="80" y="820" width="120" height="20" fill="#e1d5e7" stroke="#9673a6" pointer-events="all"/><path d="M 206.37 830 L 270.3 830 L 270.25 700" fill="none" stroke="#10739e" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 201.12 830 L 208.12 826.5 L 206.37 830 L 208.12 833.5 Z" fill="#10739e" stroke="#10739e" stroke-miterlimit="10" pointer-events="all"/><rect x="100" y="820" width="100" height="20" fill="none" stroke="none" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 98px; height: 1px; padding-top: 830px; margin-left: 101px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">stores.SectorIndex</div></div></div></foreignObject><text x="150" y="834" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">stores.SectorInd...</text></switch></g><rect x="40" y="850" width="100" height="20" fill="none" stroke="none" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 98px; height: 1px; padding-top: 860px; margin-left: 41px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; "><div>localPaths []string</div></div></div></div></foreignObject><text x="90" y="864" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">localPaths []str...</text></switch></g><rect x="40" y="870" width="70" height="20" fill="none" stroke="none" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 68px; height: 1px; padding-top: 880px; margin-left: 41px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">urls []string</div></div></div></foreignObject><text x="75" y="884" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">urls []stri...</text></switch></g><rect x="110" y="770" width="120" height="20" fill="#ffe6cc" stroke="#d79b00" pointer-events="all"/><rect x="110" y="770" width="120" height="20" fill="#ffe6cc" stroke="#d79b00" pointer-events="all"/><rect x="130" y="770" width="100" height="20" fill="none" stroke="none" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 98px; height: 1px; padding-top: 780px; margin-left: 131px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">stores.SectorIndex</div></div></div></foreignObject><text x="180" y="784" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">stores.SectorInd...</text></switch></g><path d="M 230 780 L 230 780" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 230 780 L 230 780 L 230 780 L 230 780 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/><rect x="181" y="680" width="139" height="20" fill="none" stroke="#000000" pointer-events="all"/><path d="M 240.5 706.37 L 240.5 720 L 200 720" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 240.5 701.12 L 244 708.12 L 240.5 706.37 L 237 708.12 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/><rect x="181" y="680" width="119" height="20" fill="none" stroke="none" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 117px; height: 1px; padding-top: 690px; margin-left: 182px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">Miner JsonRPC client</div></div></div></foreignObject><text x="241" y="694" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">Miner JsonRPC client</text></switch></g><rect x="15" y="710" width="185" height="20" rx="3" ry="3" fill="none" stroke="#000000" stroke-dasharray="3 3" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 183px; height: 1px; padding-top: 720px; margin-left: 16px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">miner.Register(remoteWorker)</div></div></div></foreignObject><text x="108" y="724" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">miner.Register(remoteWorker)</text></switch></g><rect x="330" y="680" width="269" height="90" fill="none" stroke="#000000" stroke-dasharray="3 3" pointer-events="all"/><rect x="540" y="750" width="59" height="20" fill="none" stroke="none" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 57px; height: 1px; padding-top: 760px; margin-left: 541px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">HTTP API</div></div></div></foreignObject><text x="570" y="764" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">HTTP API</text></switch></g><rect x="489" y="700" width="101" height="20" fill="#fad9d5" stroke="#ae4132" pointer-events="all"/><path d="M 521 726.37 L 521 760 L 72.5 760 L 72.5 800" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 521 721.12 L 524.5 728.12 L 521 726.37 L 517.5 728.12 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/><rect x="501" y="700" width="80" height="20" fill="none" stroke="none" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 78px; height: 1px; padding-top: 710px; margin-left: 502px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">FetchHandler</div></div></div></foreignObject><text x="541" y="714" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">FetchHandler</text></switch></g><rect x="514.5" y="680" width="50" height="20" fill="none" stroke="none" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 48px; height: 1px; padding-top: 690px; margin-left: 516px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">/remote</div></div></div></foreignObject><text x="540" y="694" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">/remote</text></switch></g><rect x="341" y="680" width="120" height="70" fill="none" stroke="#000000" pointer-events="all"/><rect x="356" y="705" width="89" height="20" fill="#fff2cc" stroke="#d6b656" stroke-dasharray="3 3" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 87px; height: 1px; padding-top: 715px; margin-left: 357px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">RemoteWorker</div></div></div></foreignObject><text x="401" y="719" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">RemoteWorker</text></switch></g><rect x="341" y="680" width="69" height="20" fill="none" stroke="#000000" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 67px; height: 1px; padding-top: 690px; margin-left: 342px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">/rpc/v0</div></div></div></foreignObject><text x="376" y="694" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">/rpc/v0</text></switch></g><rect x="341" y="730" width="59" height="20" fill="none" stroke="none" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 57px; height: 1px; padding-top: 740px; margin-left: 342px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">JsonRPC</div></div></div></foreignObject><text x="371" y="744" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">JsonRPC</text></switch></g><path d="M 284.63 840 L 210 840 L 210 850 L 200 850" fill="none" stroke="#000000" stroke-miterlimit="10" pointer-events="stroke"/><path d="M 289.88 840 L 282.88 843.5 L 284.63 840 L 282.88 836.5 Z" fill="#000000" stroke="#000000" stroke-miterlimit="10" pointer-events="all"/><rect x="0" y="680" width="110" height="20" fill="none" stroke="none" pointer-events="all"/><g transform="translate(-0.5 -0.5)"><switch><foreignObject style="overflow: visible; text-align: left;" pointer-events="none" width="100%" height="100%" requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"><div xmlns="http://www.w3.org/1999/xhtml" style="display: flex; align-items: unsafe center; justify-content: unsafe center; width: 108px; height: 1px; padding-top: 690px; margin-left: 1px;"><div style="box-sizing: border-box; font-size: 0; text-align: center; "><div style="display: inline-block; font-size: 12px; font-family: Helvetica; color: #000000; line-height: 1.2; pointer-events: all; white-space: normal; word-wrap: normal; ">Seal Worker Node</div></div></div></foreignObject><text x="55" y="694" fill="#000000" font-family="Helvetica" font-size="12px" text-anchor="middle">Seal Worker Node</text></switch></g></g><switch><g requiredFeatures="http://www.w3.org/TR/SVG11/feature#Extensibility"/><a transform="translate(0,-5)" xlink:href="https://desk.draw.io/support/solutions/articles/16000042487" target="_blank"><text text-anchor="middle" font-size="10px" x="50%" y="100%">Viewer does not support full SVG 1.1</text></a></switch></svg>
\ No newline at end of file
diff --git a/extern/sector-storage/faults.go b/extern/sector-storage/faults.go
new file mode 100644
index 000000000..31a1a3690
--- /dev/null
+++ b/extern/sector-storage/faults.go
@@ -0,0 +1,115 @@
+package sectorstorage
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/lotus/extern/sector-storage/stores"
+)
+
+// FaultTracker TODO: Track things more actively
+type FaultTracker interface {
+	CheckProvable(ctx context.Context, spt abi.RegisteredSealProof, sectors []abi.SectorID) ([]abi.SectorID, error)
+}
+
+// CheckProvable returns unprovable sectors
+func (m *Manager) CheckProvable(ctx context.Context, spt abi.RegisteredSealProof, sectors []abi.SectorID) ([]abi.SectorID, error) {
+	var bad []abi.SectorID
+
+	ssize, err := spt.SectorSize()
+	if err != nil {
+		return nil, err
+	}
+
+	// TODO: More better checks
+	for _, sector := range sectors {
+		err := func() error {
+			ctx, cancel := context.WithCancel(ctx)
+			defer cancel()
+
+			locked, err := m.index.StorageTryLock(ctx, sector, stores.FTSealed|stores.FTCache, stores.FTNone)
+			if err != nil {
+				return xerrors.Errorf("acquiring sector lock: %w", err)
+			}
+
+			if !locked {
+				log.Warnw("CheckProvable Sector FAULT: can't acquire read lock", "sector", sector, "sealed")
+				bad = append(bad, sector)
+				return nil
+			}
+
+			lp, _, err := m.localStore.AcquireSector(ctx, sector, spt, stores.FTSealed|stores.FTCache, stores.FTNone, stores.PathStorage, stores.AcquireMove)
+			if err != nil {
+				log.Warnw("CheckProvable Sector FAULT: acquire sector in checkProvable", "sector", sector, "error", err)
+				bad = append(bad, sector)
+				return nil
+			}
+
+			if lp.Sealed == "" || lp.Cache == "" {
+				log.Warnw("CheckProvable Sector FAULT: cache an/or sealed paths not found", "sector", sector, "sealed", lp.Sealed, "cache", lp.Cache)
+				bad = append(bad, sector)
+				return nil
+			}
+
+			toCheck := map[string]int64{
+				lp.Sealed:                        1,
+				filepath.Join(lp.Cache, "t_aux"): 0,
+				filepath.Join(lp.Cache, "p_aux"): 0,
+			}
+
+			addCachePathsForSectorSize(toCheck, lp.Cache, ssize)
+
+			for p, sz := range toCheck {
+				st, err := os.Stat(p)
+				if err != nil {
+					log.Warnw("CheckProvable Sector FAULT: sector file stat error", "sector", sector, "sealed", lp.Sealed, "cache", lp.Cache, "file", p, "err", err)
+					bad = append(bad, sector)
+					return nil
+				}
+
+				if sz != 0 {
+					if st.Size() != int64(ssize)*sz {
+						log.Warnw("CheckProvable Sector FAULT: sector file is wrong size", "sector", sector, "sealed", lp.Sealed, "cache", lp.Cache, "file", p, "size", st.Size(), "expectSize", int64(ssize)*sz)
+						bad = append(bad, sector)
+						return nil
+					}
+				}
+			}
+
+			return nil
+		}()
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	return bad, nil
+}
+
+func addCachePathsForSectorSize(chk map[string]int64, cacheDir string, ssize abi.SectorSize) {
+	switch ssize {
+	case 2 << 10:
+		fallthrough
+	case 8 << 20:
+		fallthrough
+	case 512 << 20:
+		chk[filepath.Join(cacheDir, "sc-02-data-tree-r-last.dat")] = 0
+	case 32 << 30:
+		for i := 0; i < 8; i++ {
+			chk[filepath.Join(cacheDir, fmt.Sprintf("sc-02-data-tree-r-last-%d.dat", i))] = 0
+		}
+	case 64 << 30:
+		for i := 0; i < 16; i++ {
+			chk[filepath.Join(cacheDir, fmt.Sprintf("sc-02-data-tree-r-last-%d.dat", i))] = 0
+		}
+	default:
+		log.Warnf("not checking cache files of %s sectors for faults", ssize)
+	}
+}
+
+var _ FaultTracker = &Manager{}
diff --git a/extern/sector-storage/ffiwrapper/basicfs/fs.go b/extern/sector-storage/ffiwrapper/basicfs/fs.go
new file mode 100644
index 000000000..00aa49b98
--- /dev/null
+++ b/extern/sector-storage/ffiwrapper/basicfs/fs.go
@@ -0,0 +1,86 @@
+package basicfs
+
+import (
+	"context"
+	"os"
+	"path/filepath"
+	"sync"
+
+	"github.com/filecoin-project/go-state-types/abi"
+
+	"github.com/filecoin-project/lotus/extern/sector-storage/stores"
+	"github.com/filecoin-project/lotus/extern/sector-storage/storiface"
+)
+
+type sectorFile struct {
+	abi.SectorID
+	stores.SectorFileType
+}
+
+type Provider struct {
+	Root string
+
+	lk         sync.Mutex
+	waitSector map[sectorFile]chan struct{}
+}
+
+func (b *Provider) AcquireSector(ctx context.Context, id abi.SectorID, existing stores.SectorFileType, allocate stores.SectorFileType, ptype stores.PathType) (stores.SectorPaths, func(), error) {
+	if err := os.Mkdir(filepath.Join(b.Root, stores.FTUnsealed.String()), 0755); err != nil && !os.IsExist(err) { // nolint
+		return stores.SectorPaths{}, nil, err
+	}
+	if err := os.Mkdir(filepath.Join(b.Root, stores.FTSealed.String()), 0755); err != nil && !os.IsExist(err) { // nolint
+		return stores.SectorPaths{}, nil, err
+	}
+	if err := os.Mkdir(filepath.Join(b.Root, stores.FTCache.String()), 0755); err != nil && !os.IsExist(err) { // nolint
+		return stores.SectorPaths{}, nil, err
+	}
+
+	done := func() {}
+
+	out := stores.SectorPaths{
+		ID: id,
+	}
+
+	for _, fileType := range stores.PathTypes {
+		if !existing.Has(fileType) && !allocate.Has(fileType) {
+			continue
+		}
+
+		b.lk.Lock()
+		if b.waitSector == nil {
+			b.waitSector = map[sectorFile]chan struct{}{}
+		}
+		ch, found := b.waitSector[sectorFile{id, fileType}]
+		if !found {
+			ch = make(chan struct{}, 1)
+			b.waitSector[sectorFile{id, fileType}] = ch
+		}
+		b.lk.Unlock()
+
+		select {
+		case ch <- struct{}{}:
+		case <-ctx.Done():
+			done()
+			return stores.SectorPaths{}, nil, ctx.Err()
+		}
+
+		path := filepath.Join(b.Root, fileType.String(), stores.SectorName(id))
+
+		prevDone := done
+		done = func() {
+			prevDone()
+			<-ch
+		}
+
+		if !allocate.Has(fileType) {
+			if _, err := os.Stat(path); os.IsNotExist(err) {
+				done()
+				return stores.SectorPaths{}, nil, storiface.ErrSectorNotFound
+			}
+		}
+
+		stores.SetPathByType(&out, fileType, path)
+	}
+
+	return out, done, nil
+}
diff --git a/extern/sector-storage/ffiwrapper/config.go b/extern/sector-storage/ffiwrapper/config.go
new file mode 100644
index 000000000..ca32b1191
--- /dev/null
+++ b/extern/sector-storage/ffiwrapper/config.go
@@ -0,0 +1,34 @@
+package ffiwrapper
+
+import (
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-state-types/abi"
+)
+
+type Config struct {
+	SealProofType abi.RegisteredSealProof
+
+	_ struct{} // guard against nameless init
+}
+
+func sizeFromConfig(cfg Config) (abi.SectorSize, error) {
+	return cfg.SealProofType.SectorSize()
+}
+
+func SealProofTypeFromSectorSize(ssize abi.SectorSize) (abi.RegisteredSealProof, error) {
+	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)
+	}
+}
diff --git a/extern/sector-storage/ffiwrapper/files.go b/extern/sector-storage/ffiwrapper/files.go
new file mode 100644
index 000000000..a13776d2d
--- /dev/null
+++ b/extern/sector-storage/ffiwrapper/files.go
@@ -0,0 +1,53 @@
+package ffiwrapper
+
+import (
+	"io"
+	"os"
+	"sync"
+
+	"golang.org/x/xerrors"
+)
+
+func ToReadableFile(r io.Reader, n int64) (*os.File, func() error, error) {
+	f, ok := r.(*os.File)
+	if ok {
+		return f, func() error { return nil }, nil
+	}
+
+	var w *os.File
+
+	f, w, err := os.Pipe()
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var wait sync.Mutex
+	var werr error
+
+	wait.Lock()
+	go func() {
+		defer wait.Unlock()
+
+		var copied int64
+		copied, werr = io.CopyN(w, r, n)
+		if werr != nil {
+			log.Warnf("toReadableFile: copy error: %+v", werr)
+		}
+
+		err := w.Close()
+		if werr == nil && err != nil {
+			werr = err
+			log.Warnf("toReadableFile: close error: %+v", err)
+			return
+		}
+		if copied != n {
+			log.Warnf("copied different amount than expected: %d != %d", copied, n)
+			werr = xerrors.Errorf("copied different amount than expected: %d != %d", copied, n)
+		}
+	}()
+
+	return f, func() error {
+		wait.Lock()
+		return werr
+	}, nil
+}
diff --git a/extern/sector-storage/ffiwrapper/partialfile.go b/extern/sector-storage/ffiwrapper/partialfile.go
new file mode 100644
index 000000000..e19930ac1
--- /dev/null
+++ b/extern/sector-storage/ffiwrapper/partialfile.go
@@ -0,0 +1,316 @@
+package ffiwrapper
+
+import (
+	"encoding/binary"
+	"io"
+	"os"
+	"syscall"
+
+	"github.com/detailyang/go-fallocate"
+	"golang.org/x/xerrors"
+
+	rlepluslazy "github.com/filecoin-project/go-bitfield/rle"
+	"github.com/filecoin-project/go-state-types/abi"
+
+	"github.com/filecoin-project/lotus/extern/sector-storage/fsutil"
+	"github.com/filecoin-project/lotus/extern/sector-storage/storiface"
+)
+
+const veryLargeRle = 1 << 20
+
+// Sectors can be partially unsealed. We support this by appending a small
+// trailer to each unsealed sector file containing an RLE+ marking which bytes
+// in a sector are unsealed, and which are not (holes)
+
+// unsealed sector files internally have this structure
+// [unpadded (raw) data][rle+][4B LE length fo the rle+ field]
+
+type partialFile struct {
+	maxPiece abi.PaddedPieceSize
+
+	path      string
+	allocated rlepluslazy.RLE
+
+	file *os.File
+}
+
+func writeTrailer(maxPieceSize int64, w *os.File, r rlepluslazy.RunIterator) error {
+	trailer, err := rlepluslazy.EncodeRuns(r, nil)
+	if err != nil {
+		return xerrors.Errorf("encoding trailer: %w", err)
+	}
+
+	// maxPieceSize == unpadded(sectorSize) == trailer start
+	if _, err := w.Seek(maxPieceSize, io.SeekStart); err != nil {
+		return xerrors.Errorf("seek to trailer start: %w", err)
+	}
+
+	rb, err := w.Write(trailer)
+	if err != nil {
+		return xerrors.Errorf("writing trailer data: %w", err)
+	}
+
+	if err := binary.Write(w, binary.LittleEndian, uint32(len(trailer))); err != nil {
+		return xerrors.Errorf("writing trailer length: %w", err)
+	}
+
+	return w.Truncate(maxPieceSize + int64(rb) + 4)
+}
+
+func createPartialFile(maxPieceSize abi.PaddedPieceSize, path string) (*partialFile, error) {
+	f, err := os.OpenFile(path, os.O_RDWR|os.O_CREATE, 0644) // nolint
+	if err != nil {
+		return nil, xerrors.Errorf("openning partial file '%s': %w", path, err)
+	}
+
+	err = func() error {
+		err := fallocate.Fallocate(f, 0, int64(maxPieceSize))
+		if errno, ok := err.(syscall.Errno); ok {
+			if errno == syscall.EOPNOTSUPP || errno == syscall.ENOSYS {
+				log.Warnf("could not allocated space, ignoring: %v", errno)
+				err = nil // log and ignore
+			}
+		}
+		if err != nil {
+			return xerrors.Errorf("fallocate '%s': %w", path, err)
+		}
+
+		if err := writeTrailer(int64(maxPieceSize), f, &rlepluslazy.RunSliceIterator{}); err != nil {
+			return xerrors.Errorf("writing trailer: %w", err)
+		}
+
+		return nil
+	}()
+	if err != nil {
+		_ = f.Close()
+		return nil, err
+	}
+	if err := f.Close(); err != nil {
+		return nil, xerrors.Errorf("close empty partial file: %w", err)
+	}
+
+	return openPartialFile(maxPieceSize, path)
+}
+
+func openPartialFile(maxPieceSize abi.PaddedPieceSize, path string) (*partialFile, error) {
+	f, err := os.OpenFile(path, os.O_RDWR, 0644) // nolint
+	if err != nil {
+		return nil, xerrors.Errorf("openning partial file '%s': %w", path, err)
+	}
+
+	var rle rlepluslazy.RLE
+	err = func() error {
+		st, err := f.Stat()
+		if err != nil {
+			return xerrors.Errorf("stat '%s': %w", path, err)
+		}
+		if st.Size() < int64(maxPieceSize) {
+			return xerrors.Errorf("sector file '%s' was smaller than the sector size %d < %d", path, st.Size(), maxPieceSize)
+		}
+		// read trailer
+		var tlen [4]byte
+		_, err = f.ReadAt(tlen[:], st.Size()-int64(len(tlen)))
+		if err != nil {
+			return xerrors.Errorf("reading trailer length: %w", err)
+		}
+
+		// sanity-check the length
+		trailerLen := binary.LittleEndian.Uint32(tlen[:])
+		expectLen := int64(trailerLen) + int64(len(tlen)) + int64(maxPieceSize)
+		if expectLen != st.Size() {
+			return xerrors.Errorf("file '%s' has inconsistent length; has %d bytes; expected %d (%d trailer, %d sector data)", path, st.Size(), expectLen, int64(trailerLen)+int64(len(tlen)), maxPieceSize)
+		}
+		if trailerLen > veryLargeRle {
+			log.Warnf("Partial file '%s' has a VERY large trailer with %d bytes", path, trailerLen)
+		}
+
+		trailerStart := st.Size() - int64(len(tlen)) - int64(trailerLen)
+		if trailerStart != int64(maxPieceSize) {
+			return xerrors.Errorf("expected sector size to equal trailer start index")
+		}
+
+		trailerBytes := make([]byte, trailerLen)
+		_, err = f.ReadAt(trailerBytes, trailerStart)
+		if err != nil {
+			return xerrors.Errorf("reading trailer: %w", err)
+		}
+
+		rle, err = rlepluslazy.FromBuf(trailerBytes)
+		if err != nil {
+			return xerrors.Errorf("decoding trailer: %w", err)
+		}
+
+		it, err := rle.RunIterator()
+		if err != nil {
+			return xerrors.Errorf("getting trailer run iterator: %w", err)
+		}
+
+		f, err := rlepluslazy.Fill(it)
+		if err != nil {
+			return xerrors.Errorf("filling bitfield: %w", err)
+		}
+		lastSet, err := rlepluslazy.Count(f)
+		if err != nil {
+			return xerrors.Errorf("finding last set byte index: %w", err)
+		}
+
+		if lastSet > uint64(maxPieceSize) {
+			return xerrors.Errorf("last set byte at index higher than sector size: %d > %d", lastSet, maxPieceSize)
+		}
+
+		return nil
+	}()
+	if err != nil {
+		_ = f.Close()
+		return nil, err
+	}
+
+	return &partialFile{
+		maxPiece:  maxPieceSize,
+		path:      path,
+		allocated: rle,
+		file:      f,
+	}, nil
+}
+
+func (pf *partialFile) Close() error {
+	return pf.file.Close()
+}
+
+func (pf *partialFile) Writer(offset storiface.PaddedByteIndex, size abi.PaddedPieceSize) (io.Writer, error) {
+	if _, err := pf.file.Seek(int64(offset), io.SeekStart); err != nil {
+		return nil, xerrors.Errorf("seek piece start: %w", err)
+	}
+
+	{
+		have, err := pf.allocated.RunIterator()
+		if err != nil {
+			return nil, err
+		}
+
+		and, err := rlepluslazy.And(have, pieceRun(offset, size))
+		if err != nil {
+			return nil, err
+		}
+
+		c, err := rlepluslazy.Count(and)
+		if err != nil {
+			return nil, err
+		}
+
+		if c > 0 {
+			log.Warnf("getting partial file writer overwriting %d allocated bytes", c)
+		}
+	}
+
+	return pf.file, nil
+}
+
+func (pf *partialFile) MarkAllocated(offset storiface.PaddedByteIndex, size abi.PaddedPieceSize) error {
+	have, err := pf.allocated.RunIterator()
+	if err != nil {
+		return err
+	}
+
+	ored, err := rlepluslazy.Or(have, pieceRun(offset, size))
+	if err != nil {
+		return err
+	}
+
+	if err := writeTrailer(int64(pf.maxPiece), pf.file, ored); err != nil {
+		return xerrors.Errorf("writing trailer: %w", err)
+	}
+
+	return nil
+}
+
+func (pf *partialFile) Free(offset storiface.PaddedByteIndex, size abi.PaddedPieceSize) error {
+	have, err := pf.allocated.RunIterator()
+	if err != nil {
+		return err
+	}
+
+	if err := fsutil.Deallocate(pf.file, int64(offset), int64(size)); err != nil {
+		return xerrors.Errorf("deallocating: %w", err)
+	}
+
+	s, err := rlepluslazy.Subtract(have, pieceRun(offset, size))
+	if err != nil {
+		return err
+	}
+
+	if err := writeTrailer(int64(pf.maxPiece), pf.file, s); err != nil {
+		return xerrors.Errorf("writing trailer: %w", err)
+	}
+
+	return nil
+}
+
+func (pf *partialFile) Reader(offset storiface.PaddedByteIndex, size abi.PaddedPieceSize) (*os.File, error) {
+	if _, err := pf.file.Seek(int64(offset), io.SeekStart); err != nil {
+		return nil, xerrors.Errorf("seek piece start: %w", err)
+	}
+
+	{
+		have, err := pf.allocated.RunIterator()
+		if err != nil {
+			return nil, err
+		}
+
+		and, err := rlepluslazy.And(have, pieceRun(offset, size))
+		if err != nil {
+			return nil, err
+		}
+
+		c, err := rlepluslazy.Count(and)
+		if err != nil {
+			return nil, err
+		}
+
+		if c != uint64(size) {
+			log.Warnf("getting partial file reader reading %d unallocated bytes", uint64(size)-c)
+		}
+	}
+
+	return pf.file, nil
+}
+
+func (pf *partialFile) Allocated() (rlepluslazy.RunIterator, error) {
+	return pf.allocated.RunIterator()
+}
+
+func (pf *partialFile) HasAllocated(offset storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize) (bool, error) {
+	have, err := pf.Allocated()
+	if err != nil {
+		return false, err
+	}
+
+	u, err := rlepluslazy.And(have, pieceRun(offset.Padded(), size.Padded()))
+	if err != nil {
+		return false, err
+	}
+
+	uc, err := rlepluslazy.Count(u)
+	if err != nil {
+		return false, err
+	}
+
+	return abi.PaddedPieceSize(uc) == size.Padded(), nil
+}
+
+func pieceRun(offset storiface.PaddedByteIndex, size abi.PaddedPieceSize) rlepluslazy.RunIterator {
+	var runs []rlepluslazy.Run
+	if offset > 0 {
+		runs = append(runs, rlepluslazy.Run{
+			Val: false,
+			Len: uint64(offset),
+		})
+	}
+
+	runs = append(runs, rlepluslazy.Run{
+		Val: true,
+		Len: uint64(size),
+	})
+
+	return &rlepluslazy.RunSliceIterator{Runs: runs}
+}
diff --git a/extern/sector-storage/ffiwrapper/sealer.go b/extern/sector-storage/ffiwrapper/sealer.go
new file mode 100644
index 000000000..c1b558d9a
--- /dev/null
+++ b/extern/sector-storage/ffiwrapper/sealer.go
@@ -0,0 +1,28 @@
+package ffiwrapper
+
+import (
+	"github.com/filecoin-project/go-state-types/abi"
+	logging "github.com/ipfs/go-log/v2"
+)
+
+var log = logging.Logger("ffiwrapper")
+
+type Sealer struct {
+	sealProofType abi.RegisteredSealProof
+	ssize         abi.SectorSize // a function of sealProofType and postProofType
+
+	sectors  SectorProvider
+	stopping chan struct{}
+}
+
+func (sb *Sealer) Stop() {
+	close(sb.stopping)
+}
+
+func (sb *Sealer) SectorSize() abi.SectorSize {
+	return sb.ssize
+}
+
+func (sb *Sealer) SealProofType() abi.RegisteredSealProof {
+	return sb.sealProofType
+}
diff --git a/extern/sector-storage/ffiwrapper/sealer_cgo.go b/extern/sector-storage/ffiwrapper/sealer_cgo.go
new file mode 100644
index 000000000..9bc2680ed
--- /dev/null
+++ b/extern/sector-storage/ffiwrapper/sealer_cgo.go
@@ -0,0 +1,677 @@
+//+build cgo
+
+package ffiwrapper
+
+import (
+	"bufio"
+	"bytes"
+	"context"
+	"io"
+	"math/bits"
+	"os"
+	"runtime"
+
+	"github.com/ipfs/go-cid"
+	"golang.org/x/xerrors"
+
+	ffi "github.com/filecoin-project/filecoin-ffi"
+	rlepluslazy "github.com/filecoin-project/go-bitfield/rle"
+	commcid "github.com/filecoin-project/go-fil-commcid"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/specs-storage/storage"
+
+	"github.com/filecoin-project/lotus/extern/sector-storage/fr32"
+	"github.com/filecoin-project/lotus/extern/sector-storage/stores"
+	"github.com/filecoin-project/lotus/extern/sector-storage/storiface"
+	"github.com/filecoin-project/lotus/extern/sector-storage/zerocomm"
+)
+
+var _ Storage = &Sealer{}
+
+func New(sectors SectorProvider, cfg *Config) (*Sealer, error) {
+	sectorSize, err := sizeFromConfig(*cfg)
+	if err != nil {
+		return nil, err
+	}
+
+	sb := &Sealer{
+		sealProofType: cfg.SealProofType,
+		ssize:         sectorSize,
+
+		sectors: sectors,
+
+		stopping: make(chan struct{}),
+	}
+
+	return sb, nil
+}
+
+func (sb *Sealer) NewSector(ctx context.Context, sector abi.SectorID) error {
+	// TODO: Allocate the sector here instead of in addpiece
+
+	return nil
+}
+
+func (sb *Sealer) AddPiece(ctx context.Context, sector abi.SectorID, existingPieceSizes []abi.UnpaddedPieceSize, pieceSize abi.UnpaddedPieceSize, file storage.Data) (abi.PieceInfo, error) {
+	var offset abi.UnpaddedPieceSize
+	for _, size := range existingPieceSizes {
+		offset += size
+	}
+
+	maxPieceSize := abi.PaddedPieceSize(sb.ssize)
+
+	if offset.Padded()+pieceSize.Padded() > maxPieceSize {
+		return abi.PieceInfo{}, xerrors.Errorf("can't add %d byte piece to sector %v with %d bytes of existing pieces", pieceSize, sector, offset)
+	}
+
+	var err error
+	var done func()
+	var stagedFile *partialFile
+
+	defer func() {
+		if done != nil {
+			done()
+		}
+
+		if stagedFile != nil {
+			if err := stagedFile.Close(); err != nil {
+				log.Errorf("closing staged file: %+v", err)
+			}
+		}
+	}()
+
+	var stagedPath stores.SectorPaths
+	if len(existingPieceSizes) == 0 {
+		stagedPath, done, err = sb.sectors.AcquireSector(ctx, sector, 0, stores.FTUnsealed, stores.PathSealing)
+		if err != nil {
+			return abi.PieceInfo{}, xerrors.Errorf("acquire unsealed sector: %w", err)
+		}
+
+		stagedFile, err = createPartialFile(maxPieceSize, stagedPath.Unsealed)
+		if err != nil {
+			return abi.PieceInfo{}, xerrors.Errorf("creating unsealed sector file: %w", err)
+		}
+	} else {
+		stagedPath, done, err = sb.sectors.AcquireSector(ctx, sector, stores.FTUnsealed, 0, stores.PathSealing)
+		if err != nil {
+			return abi.PieceInfo{}, xerrors.Errorf("acquire unsealed sector: %w", err)
+		}
+
+		stagedFile, err = openPartialFile(maxPieceSize, stagedPath.Unsealed)
+		if err != nil {
+			return abi.PieceInfo{}, xerrors.Errorf("opening unsealed sector file: %w", err)
+		}
+	}
+
+	w, err := stagedFile.Writer(storiface.UnpaddedByteIndex(offset).Padded(), pieceSize.Padded())
+	if err != nil {
+		return abi.PieceInfo{}, xerrors.Errorf("getting partial file writer: %w", err)
+	}
+
+	pw := fr32.NewPadWriter(w)
+
+	pr := io.TeeReader(io.LimitReader(file, int64(pieceSize)), pw)
+
+	chunk := abi.PaddedPieceSize(4 << 20)
+
+	buf := make([]byte, chunk.Unpadded())
+	var pieceCids []abi.PieceInfo
+
+	for {
+		var read int
+		for rbuf := buf; len(rbuf) > 0; {
+			n, err := pr.Read(rbuf)
+			if err != nil && err != io.EOF {
+				return abi.PieceInfo{}, xerrors.Errorf("pr read error: %w", err)
+			}
+
+			rbuf = rbuf[n:]
+			read += n
+
+			if err == io.EOF {
+				break
+			}
+		}
+		if read == 0 {
+			break
+		}
+
+		c, err := sb.pieceCid(buf[:read])
+		if err != nil {
+			return abi.PieceInfo{}, xerrors.Errorf("pieceCid error: %w", err)
+		}
+		pieceCids = append(pieceCids, abi.PieceInfo{
+			Size:     abi.UnpaddedPieceSize(len(buf[:read])).Padded(),
+			PieceCID: c,
+		})
+	}
+
+	if err := pw.Close(); err != nil {
+		return abi.PieceInfo{}, xerrors.Errorf("closing padded writer: %w", err)
+	}
+
+	if err := stagedFile.MarkAllocated(storiface.UnpaddedByteIndex(offset).Padded(), pieceSize.Padded()); err != nil {
+		return abi.PieceInfo{}, xerrors.Errorf("marking data range as allocated: %w", err)
+	}
+
+	if err := stagedFile.Close(); err != nil {
+		return abi.PieceInfo{}, err
+	}
+	stagedFile = nil
+
+	if len(pieceCids) == 1 {
+		return pieceCids[0], nil
+	}
+
+	pieceCID, err := ffi.GenerateUnsealedCID(sb.sealProofType, pieceCids)
+	if err != nil {
+		return abi.PieceInfo{}, xerrors.Errorf("generate unsealed CID: %w", err)
+	}
+
+	// validate that the pieceCID was properly formed
+	if _, err := commcid.CIDToPieceCommitmentV1(pieceCID); err != nil {
+		return abi.PieceInfo{}, err
+	}
+
+	return abi.PieceInfo{
+		Size:     pieceSize.Padded(),
+		PieceCID: pieceCID,
+	}, nil
+}
+
+func (sb *Sealer) pieceCid(in []byte) (cid.Cid, error) {
+	prf, werr, err := ToReadableFile(bytes.NewReader(in), int64(len(in)))
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("getting tee reader pipe: %w", err)
+	}
+
+	pieceCID, err := ffi.GeneratePieceCIDFromFile(sb.sealProofType, prf, abi.UnpaddedPieceSize(len(in)))
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("generating piece commitment: %w", err)
+	}
+
+	_ = prf.Close()
+
+	return pieceCID, werr()
+}
+
+func (sb *Sealer) UnsealPiece(ctx context.Context, sector abi.SectorID, offset storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize, randomness abi.SealRandomness, commd cid.Cid) error {
+	maxPieceSize := abi.PaddedPieceSize(sb.ssize)
+
+	// try finding existing
+	unsealedPath, done, err := sb.sectors.AcquireSector(ctx, sector, stores.FTUnsealed, stores.FTNone, stores.PathStorage)
+	var pf *partialFile
+
+	switch {
+	case xerrors.Is(err, storiface.ErrSectorNotFound):
+		unsealedPath, done, err = sb.sectors.AcquireSector(ctx, sector, stores.FTNone, stores.FTUnsealed, stores.PathStorage)
+		if err != nil {
+			return xerrors.Errorf("acquire unsealed sector path (allocate): %w", err)
+		}
+		defer done()
+
+		pf, err = createPartialFile(maxPieceSize, unsealedPath.Unsealed)
+		if err != nil {
+			return xerrors.Errorf("create unsealed file: %w", err)
+		}
+
+	case err == nil:
+		defer done()
+
+		pf, err = openPartialFile(maxPieceSize, unsealedPath.Unsealed)
+		if err != nil {
+			return xerrors.Errorf("opening partial file: %w", err)
+		}
+	default:
+		return xerrors.Errorf("acquire unsealed sector path (existing): %w", err)
+	}
+	defer pf.Close() // nolint
+
+	allocated, err := pf.Allocated()
+	if err != nil {
+		return xerrors.Errorf("getting bitruns of allocated data: %w", err)
+	}
+
+	toUnseal, err := computeUnsealRanges(allocated, offset, size)
+	if err != nil {
+		return xerrors.Errorf("computing unseal ranges: %w", err)
+	}
+
+	if !toUnseal.HasNext() {
+		return nil
+	}
+
+	srcPaths, srcDone, err := sb.sectors.AcquireSector(ctx, sector, stores.FTCache|stores.FTSealed, stores.FTNone, stores.PathStorage)
+	if err != nil {
+		return xerrors.Errorf("acquire sealed sector paths: %w", err)
+	}
+	defer srcDone()
+
+	sealed, err := os.OpenFile(srcPaths.Sealed, os.O_RDONLY, 0644) // nolint:gosec
+	if err != nil {
+		return xerrors.Errorf("opening sealed file: %w", err)
+	}
+	defer sealed.Close() // nolint
+
+	var at, nextat abi.PaddedPieceSize
+	first := true
+	for first || toUnseal.HasNext() {
+		first = false
+
+		piece, err := toUnseal.NextRun()
+		if err != nil {
+			return xerrors.Errorf("getting next range to unseal: %w", err)
+		}
+
+		at = nextat
+		nextat += abi.PaddedPieceSize(piece.Len)
+
+		if !piece.Val {
+			continue
+		}
+
+		out, err := pf.Writer(offset.Padded(), size.Padded())
+		if err != nil {
+			return xerrors.Errorf("getting partial file writer: %w", err)
+		}
+
+		// <eww>
+		opr, opw, err := os.Pipe()
+		if err != nil {
+			return xerrors.Errorf("creating out pipe: %w", err)
+		}
+
+		var perr error
+		outWait := make(chan struct{})
+
+		{
+			go func() {
+				defer close(outWait)
+				defer opr.Close() // nolint
+
+				padwriter := fr32.NewPadWriter(out)
+				if err != nil {
+					perr = xerrors.Errorf("creating new padded writer: %w", err)
+					return
+				}
+
+				bsize := uint64(size.Padded())
+				if bsize > uint64(runtime.NumCPU())*fr32.MTTresh {
+					bsize = uint64(runtime.NumCPU()) * fr32.MTTresh
+				}
+
+				bw := bufio.NewWriterSize(padwriter, int(abi.PaddedPieceSize(bsize).Unpadded()))
+
+				_, err = io.CopyN(bw, opr, int64(size))
+				if err != nil {
+					perr = xerrors.Errorf("copying data: %w", err)
+					return
+				}
+
+				if err := bw.Flush(); err != nil {
+					perr = xerrors.Errorf("flushing unpadded data: %w", err)
+					return
+				}
+
+				if err := padwriter.Close(); err != nil {
+					perr = xerrors.Errorf("closing padwriter: %w", err)
+					return
+				}
+			}()
+		}
+		// </eww>
+
+		// TODO: This may be possible to do in parallel
+		err = ffi.UnsealRange(sb.sealProofType,
+			srcPaths.Cache,
+			sealed,
+			opw,
+			sector.Number,
+			sector.Miner,
+			randomness,
+			commd,
+			uint64(at.Unpadded()),
+			uint64(abi.PaddedPieceSize(piece.Len).Unpadded()))
+
+		_ = opw.Close()
+
+		if err != nil {
+			return xerrors.Errorf("unseal range: %w", err)
+		}
+
+		select {
+		case <-outWait:
+		case <-ctx.Done():
+			return ctx.Err()
+		}
+
+		if perr != nil {
+			return xerrors.Errorf("piping output to unsealed file: %w", perr)
+		}
+
+		if err := pf.MarkAllocated(storiface.PaddedByteIndex(at), abi.PaddedPieceSize(piece.Len)); err != nil {
+			return xerrors.Errorf("marking unsealed range as allocated: %w", err)
+		}
+
+		if !toUnseal.HasNext() {
+			break
+		}
+	}
+
+	return nil
+}
+
+func (sb *Sealer) ReadPiece(ctx context.Context, writer io.Writer, sector abi.SectorID, offset storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize) (bool, error) {
+	path, done, err := sb.sectors.AcquireSector(ctx, sector, stores.FTUnsealed, stores.FTNone, stores.PathStorage)
+	if err != nil {
+		return false, xerrors.Errorf("acquire unsealed sector path: %w", err)
+	}
+	defer done()
+
+	maxPieceSize := abi.PaddedPieceSize(sb.ssize)
+
+	pf, err := openPartialFile(maxPieceSize, path.Unsealed)
+	if err != nil {
+		if xerrors.Is(err, os.ErrNotExist) {
+			return false, nil
+		}
+
+		return false, xerrors.Errorf("opening partial file: %w", err)
+	}
+
+	ok, err := pf.HasAllocated(offset, size)
+	if err != nil {
+		_ = pf.Close()
+		return false, err
+	}
+
+	if !ok {
+		_ = pf.Close()
+		return false, nil
+	}
+
+	f, err := pf.Reader(offset.Padded(), size.Padded())
+	if err != nil {
+		_ = pf.Close()
+		return false, xerrors.Errorf("getting partial file reader: %w", err)
+	}
+
+	upr, err := fr32.NewUnpadReader(f, size.Padded())
+	if err != nil {
+		return false, xerrors.Errorf("creating unpadded reader: %w", err)
+	}
+
+	if _, err := io.CopyN(writer, upr, int64(size)); err != nil {
+		_ = pf.Close()
+		return false, xerrors.Errorf("reading unsealed file: %w", err)
+	}
+
+	if err := pf.Close(); err != nil {
+		return false, xerrors.Errorf("closing partial file: %w", err)
+	}
+
+	return true, nil
+}
+
+func (sb *Sealer) SealPreCommit1(ctx context.Context, sector abi.SectorID, ticket abi.SealRandomness, pieces []abi.PieceInfo) (out storage.PreCommit1Out, err error) {
+	paths, done, err := sb.sectors.AcquireSector(ctx, sector, stores.FTUnsealed, stores.FTSealed|stores.FTCache, stores.PathSealing)
+	if err != nil {
+		return nil, xerrors.Errorf("acquiring sector paths: %w", err)
+	}
+	defer done()
+
+	e, err := os.OpenFile(paths.Sealed, os.O_RDWR|os.O_CREATE, 0644) // nolint:gosec
+	if err != nil {
+		return nil, xerrors.Errorf("ensuring sealed file exists: %w", err)
+	}
+	if err := e.Close(); err != nil {
+		return nil, err
+	}
+
+	if err := os.Mkdir(paths.Cache, 0755); err != nil { // nolint
+		if os.IsExist(err) {
+			log.Warnf("existing cache in %s; removing", paths.Cache)
+
+			if err := os.RemoveAll(paths.Cache); err != nil {
+				return nil, xerrors.Errorf("remove existing sector cache from %s (sector %d): %w", paths.Cache, sector, err)
+			}
+
+			if err := os.Mkdir(paths.Cache, 0755); err != nil { // nolint:gosec
+				return nil, xerrors.Errorf("mkdir cache path after cleanup: %w", err)
+			}
+		} else {
+			return nil, err
+		}
+	}
+
+	var sum abi.UnpaddedPieceSize
+	for _, piece := range pieces {
+		sum += piece.Size.Unpadded()
+	}
+	ussize := abi.PaddedPieceSize(sb.ssize).Unpadded()
+	if sum != ussize {
+		return nil, xerrors.Errorf("aggregated piece sizes don't match sector size: %d != %d (%d)", sum, ussize, int64(ussize-sum))
+	}
+
+	// TODO: context cancellation respect
+	p1o, err := ffi.SealPreCommitPhase1(
+		sb.sealProofType,
+		paths.Cache,
+		paths.Unsealed,
+		paths.Sealed,
+		sector.Number,
+		sector.Miner,
+		ticket,
+		pieces,
+	)
+	if err != nil {
+		return nil, xerrors.Errorf("presealing sector %d (%s): %w", sector.Number, paths.Unsealed, err)
+	}
+	return p1o, nil
+}
+
+func (sb *Sealer) SealPreCommit2(ctx context.Context, sector abi.SectorID, phase1Out storage.PreCommit1Out) (storage.SectorCids, error) {
+	paths, done, err := sb.sectors.AcquireSector(ctx, sector, stores.FTSealed|stores.FTCache, 0, stores.PathSealing)
+	if err != nil {
+		return storage.SectorCids{}, xerrors.Errorf("acquiring sector paths: %w", err)
+	}
+	defer done()
+
+	sealedCID, unsealedCID, err := ffi.SealPreCommitPhase2(phase1Out, paths.Cache, paths.Sealed)
+	if err != nil {
+		return storage.SectorCids{}, xerrors.Errorf("presealing sector %d (%s): %w", sector.Number, paths.Unsealed, err)
+	}
+
+	return storage.SectorCids{
+		Unsealed: unsealedCID,
+		Sealed:   sealedCID,
+	}, nil
+}
+
+func (sb *Sealer) SealCommit1(ctx context.Context, sector abi.SectorID, ticket abi.SealRandomness, seed abi.InteractiveSealRandomness, pieces []abi.PieceInfo, cids storage.SectorCids) (storage.Commit1Out, error) {
+	paths, done, err := sb.sectors.AcquireSector(ctx, sector, stores.FTSealed|stores.FTCache, 0, stores.PathSealing)
+	if err != nil {
+		return nil, xerrors.Errorf("acquire sector paths: %w", err)
+	}
+	defer done()
+	output, err := ffi.SealCommitPhase1(
+		sb.sealProofType,
+		cids.Sealed,
+		cids.Unsealed,
+		paths.Cache,
+		paths.Sealed,
+		sector.Number,
+		sector.Miner,
+		ticket,
+		seed,
+		pieces,
+	)
+	if err != nil {
+		log.Warn("StandaloneSealCommit error: ", err)
+		log.Warnf("num:%d tkt:%v seed:%v, pi:%v sealedCID:%v, unsealedCID:%v", sector.Number, ticket, seed, pieces, cids.Sealed, cids.Unsealed)
+
+		return nil, xerrors.Errorf("StandaloneSealCommit: %w", err)
+	}
+	return output, nil
+}
+
+func (sb *Sealer) SealCommit2(ctx context.Context, sector abi.SectorID, phase1Out storage.Commit1Out) (storage.Proof, error) {
+	return ffi.SealCommitPhase2(phase1Out, sector.Number, sector.Miner)
+}
+
+func (sb *Sealer) FinalizeSector(ctx context.Context, sector abi.SectorID, keepUnsealed []storage.Range) error {
+	if len(keepUnsealed) > 0 {
+		maxPieceSize := abi.PaddedPieceSize(sb.ssize)
+
+		sr := pieceRun(0, maxPieceSize)
+
+		for _, s := range keepUnsealed {
+			si := &rlepluslazy.RunSliceIterator{}
+			if s.Offset != 0 {
+				si.Runs = append(si.Runs, rlepluslazy.Run{Val: false, Len: uint64(s.Offset)})
+			}
+			si.Runs = append(si.Runs, rlepluslazy.Run{Val: true, Len: uint64(s.Size)})
+
+			var err error
+			sr, err = rlepluslazy.Subtract(sr, si)
+			if err != nil {
+				return err
+			}
+		}
+
+		paths, done, err := sb.sectors.AcquireSector(ctx, sector, stores.FTUnsealed, 0, stores.PathStorage)
+		if err != nil {
+			return xerrors.Errorf("acquiring sector cache path: %w", err)
+		}
+		defer done()
+
+		pf, err := openPartialFile(maxPieceSize, paths.Unsealed)
+		if xerrors.Is(err, os.ErrNotExist) {
+			return xerrors.Errorf("opening partial file: %w", err)
+		}
+
+		var at uint64
+		for sr.HasNext() {
+			r, err := sr.NextRun()
+			if err != nil {
+				_ = pf.Close()
+				return err
+			}
+
+			offset := at
+			at += r.Len
+			if !r.Val {
+				continue
+			}
+
+			err = pf.Free(storiface.PaddedByteIndex(abi.UnpaddedPieceSize(offset).Padded()), abi.UnpaddedPieceSize(r.Len).Padded())
+			if err != nil {
+				_ = pf.Close()
+				return xerrors.Errorf("free partial file range: %w", err)
+			}
+		}
+
+		if err := pf.Close(); err != nil {
+			return err
+		}
+	}
+
+	paths, done, err := sb.sectors.AcquireSector(ctx, sector, stores.FTCache, 0, stores.PathStorage)
+	if err != nil {
+		return xerrors.Errorf("acquiring sector cache path: %w", err)
+	}
+	defer done()
+
+	return ffi.ClearCache(uint64(sb.ssize), paths.Cache)
+}
+
+func (sb *Sealer) ReleaseUnsealed(ctx context.Context, sector abi.SectorID, safeToFree []storage.Range) error {
+	// This call is meant to mark storage as 'freeable'. Given that unsealing is
+	// very expensive, we don't remove data as soon as we can - instead we only
+	// do that when we don't have free space for data that really needs it
+
+	// This function should not be called at this layer, everything should be
+	// handled in localworker
+	return xerrors.Errorf("not supported at this layer")
+}
+
+func (sb *Sealer) Remove(ctx context.Context, sector abi.SectorID) error {
+	return xerrors.Errorf("not supported at this layer") // happens in localworker
+}
+
+func GeneratePieceCIDFromFile(proofType abi.RegisteredSealProof, piece io.Reader, pieceSize abi.UnpaddedPieceSize) (cid.Cid, error) {
+	f, werr, err := ToReadableFile(piece, int64(pieceSize))
+	if err != nil {
+		return cid.Undef, err
+	}
+
+	pieceCID, err := ffi.GeneratePieceCIDFromFile(proofType, f, pieceSize)
+	if err != nil {
+		return cid.Undef, err
+	}
+
+	return pieceCID, werr()
+}
+
+func GetRequiredPadding(oldLength abi.PaddedPieceSize, newPieceLength abi.PaddedPieceSize) ([]abi.PaddedPieceSize, abi.PaddedPieceSize) {
+
+	padPieces := make([]abi.PaddedPieceSize, 0)
+
+	toFill := uint64(-oldLength % newPieceLength)
+
+	n := bits.OnesCount64(toFill)
+	var sum abi.PaddedPieceSize
+	for i := 0; i < n; i++ {
+		next := bits.TrailingZeros64(toFill)
+		psize := uint64(1) << uint(next)
+		toFill ^= psize
+
+		padded := abi.PaddedPieceSize(psize)
+		padPieces = append(padPieces, padded)
+		sum += padded
+	}
+
+	return padPieces, sum
+}
+
+func GenerateUnsealedCID(proofType abi.RegisteredSealProof, pieces []abi.PieceInfo) (cid.Cid, error) {
+	ssize, err := proofType.SectorSize()
+	if err != nil {
+		return cid.Undef, err
+	}
+
+	pssize := abi.PaddedPieceSize(ssize)
+	allPieces := make([]abi.PieceInfo, 0, len(pieces))
+	if len(pieces) == 0 {
+		allPieces = append(allPieces, abi.PieceInfo{
+			Size:     pssize,
+			PieceCID: zerocomm.ZeroPieceCommitment(pssize.Unpadded()),
+		})
+	} else {
+		var sum abi.PaddedPieceSize
+
+		padTo := func(pads []abi.PaddedPieceSize) {
+			for _, p := range pads {
+				allPieces = append(allPieces, abi.PieceInfo{
+					Size:     p,
+					PieceCID: zerocomm.ZeroPieceCommitment(p.Unpadded()),
+				})
+
+				sum += p
+			}
+		}
+
+		for _, p := range pieces {
+			ps, _ := GetRequiredPadding(sum, p.Size)
+			padTo(ps)
+
+			allPieces = append(allPieces, p)
+			sum += p.Size
+		}
+
+		ps, _ := GetRequiredPadding(sum, pssize)
+		padTo(ps)
+	}
+
+	return ffi.GenerateUnsealedCID(proofType, allPieces)
+}
diff --git a/extern/sector-storage/ffiwrapper/sealer_test.go b/extern/sector-storage/ffiwrapper/sealer_test.go
new file mode 100644
index 000000000..bb26adb77
--- /dev/null
+++ b/extern/sector-storage/ffiwrapper/sealer_test.go
@@ -0,0 +1,617 @@
+package ffiwrapper
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"math/rand"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"sync"
+	"testing"
+	"time"
+
+	saproof "github.com/filecoin-project/specs-actors/actors/runtime/proof"
+
+	"github.com/ipfs/go-cid"
+
+	logging "github.com/ipfs/go-log"
+	"github.com/stretchr/testify/require"
+	"golang.org/x/xerrors"
+
+	paramfetch "github.com/filecoin-project/go-paramfetch"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/specs-storage/storage"
+
+	ffi "github.com/filecoin-project/filecoin-ffi"
+
+	"github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper/basicfs"
+	"github.com/filecoin-project/lotus/extern/sector-storage/stores"
+)
+
+func init() {
+	logging.SetLogLevel("*", "DEBUG") //nolint: errcheck
+}
+
+var sealProofType = abi.RegisteredSealProof_StackedDrg2KiBV1
+var sectorSize, _ = sealProofType.SectorSize()
+
+var sealRand = abi.SealRandomness{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2}
+
+type seal struct {
+	id     abi.SectorID
+	cids   storage.SectorCids
+	pi     abi.PieceInfo
+	ticket abi.SealRandomness
+}
+
+func data(sn abi.SectorNumber, dlen abi.UnpaddedPieceSize) io.Reader {
+	return io.MultiReader(
+		io.LimitReader(rand.New(rand.NewSource(42+int64(sn))), int64(123)),
+		io.LimitReader(rand.New(rand.NewSource(42+int64(sn))), int64(dlen-123)),
+	)
+}
+
+func (s *seal) precommit(t *testing.T, sb *Sealer, id abi.SectorID, done func()) {
+	defer done()
+	dlen := abi.PaddedPieceSize(sectorSize).Unpadded()
+
+	var err error
+	r := data(id.Number, dlen)
+	s.pi, err = sb.AddPiece(context.TODO(), id, []abi.UnpaddedPieceSize{}, dlen, r)
+	if err != nil {
+		t.Fatalf("%+v", err)
+	}
+
+	s.ticket = sealRand
+
+	p1, err := sb.SealPreCommit1(context.TODO(), id, s.ticket, []abi.PieceInfo{s.pi})
+	if err != nil {
+		t.Fatalf("%+v", err)
+	}
+	cids, err := sb.SealPreCommit2(context.TODO(), id, p1)
+	if err != nil {
+		t.Fatalf("%+v", err)
+	}
+	s.cids = cids
+}
+
+func (s *seal) commit(t *testing.T, sb *Sealer, done func()) {
+	defer done()
+	seed := abi.InteractiveSealRandomness{0, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 9, 8, 7, 6, 45, 3, 2, 1, 0, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 9}
+
+	pc1, err := sb.SealCommit1(context.TODO(), s.id, s.ticket, seed, []abi.PieceInfo{s.pi}, s.cids)
+	if err != nil {
+		t.Fatalf("%+v", err)
+	}
+	proof, err := sb.SealCommit2(context.TODO(), s.id, pc1)
+	if err != nil {
+		t.Fatalf("%+v", err)
+	}
+
+	ok, err := ProofVerifier.VerifySeal(saproof.SealVerifyInfo{
+		SectorID:              s.id,
+		SealedCID:             s.cids.Sealed,
+		SealProof:             sealProofType,
+		Proof:                 proof,
+		Randomness:            s.ticket,
+		InteractiveRandomness: seed,
+		UnsealedCID:           s.cids.Unsealed,
+	})
+	if err != nil {
+		t.Fatalf("%+v", err)
+	}
+
+	if !ok {
+		t.Fatal("proof failed to validate")
+	}
+}
+
+func (s *seal) unseal(t *testing.T, sb *Sealer, sp *basicfs.Provider, si abi.SectorID, done func()) {
+	defer done()
+
+	var b bytes.Buffer
+	_, err := sb.ReadPiece(context.TODO(), &b, si, 0, 1016)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	expect, _ := ioutil.ReadAll(data(si.Number, 1016))
+	if !bytes.Equal(b.Bytes(), expect) {
+		t.Fatal("read wrong bytes")
+	}
+
+	p, sd, err := sp.AcquireSector(context.TODO(), si, stores.FTUnsealed, stores.FTNone, stores.PathStorage)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := os.Remove(p.Unsealed); err != nil {
+		t.Fatal(err)
+	}
+	sd()
+
+	_, err = sb.ReadPiece(context.TODO(), &b, si, 0, 1016)
+	if err == nil {
+		t.Fatal("HOW?!")
+	}
+	log.Info("this is what we expect: ", err)
+
+	if err := sb.UnsealPiece(context.TODO(), si, 0, 1016, sealRand, s.cids.Unsealed); err != nil {
+		t.Fatal(err)
+	}
+
+	b.Reset()
+	_, err = sb.ReadPiece(context.TODO(), &b, si, 0, 1016)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	expect, _ = ioutil.ReadAll(data(si.Number, 1016))
+	require.Equal(t, expect, b.Bytes())
+
+	b.Reset()
+	have, err := sb.ReadPiece(context.TODO(), &b, si, 0, 2032)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if have {
+		t.Errorf("didn't expect to read things")
+	}
+
+	if b.Len() != 0 {
+		t.Fatal("read bytes")
+	}
+}
+
+func post(t *testing.T, sealer *Sealer, skipped []abi.SectorID, seals ...seal) {
+	randomness := abi.PoStRandomness{0, 9, 2, 7, 6, 5, 4, 3, 2, 1, 0, 9, 8, 7, 6, 45, 3, 2, 1, 0, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 9, 7}
+
+	sis := make([]saproof.SectorInfo, len(seals))
+	for i, s := range seals {
+		sis[i] = saproof.SectorInfo{
+			SealProof:    sealProofType,
+			SectorNumber: s.id.Number,
+			SealedCID:    s.cids.Sealed,
+		}
+	}
+
+	proofs, skp, err := sealer.GenerateWindowPoSt(context.TODO(), seals[0].id.Miner, sis, randomness)
+	if len(skipped) > 0 {
+		require.Error(t, err)
+		require.EqualValues(t, skipped, skp)
+		return
+	}
+
+	if err != nil {
+		t.Fatalf("%+v", err)
+	}
+
+	ok, err := ProofVerifier.VerifyWindowPoSt(context.TODO(), saproof.WindowPoStVerifyInfo{
+		Randomness:        randomness,
+		Proofs:            proofs,
+		ChallengedSectors: sis,
+		Prover:            seals[0].id.Miner,
+	})
+	if err != nil {
+		t.Fatalf("%+v", err)
+	}
+	if !ok {
+		t.Fatal("bad post")
+	}
+}
+
+func corrupt(t *testing.T, sealer *Sealer, id abi.SectorID) {
+	paths, done, err := sealer.sectors.AcquireSector(context.Background(), id, stores.FTSealed, 0, stores.PathStorage)
+	require.NoError(t, err)
+	defer done()
+
+	log.Infof("corrupt %s", paths.Sealed)
+	f, err := os.OpenFile(paths.Sealed, os.O_RDWR, 0664)
+	require.NoError(t, err)
+
+	_, err = f.WriteAt(bytes.Repeat([]byte{'d'}, 2048), 0)
+	require.NoError(t, err)
+
+	require.NoError(t, f.Close())
+}
+
+func getGrothParamFileAndVerifyingKeys(s abi.SectorSize) {
+	dat, err := ioutil.ReadFile("../../../build/proof-params/parameters.json")
+	if err != nil {
+		panic(err)
+	}
+
+	err = paramfetch.GetParams(context.TODO(), dat, uint64(s))
+	if err != nil {
+		panic(xerrors.Errorf("failed to acquire Groth parameters for 2KiB sectors: %w", err))
+	}
+}
+
+// TestDownloadParams exists only so that developers and CI can pre-download
+// Groth parameters and verifying keys before running the tests which rely on
+// those parameters and keys. To do this, run the following command:
+//
+// go test -run=^TestDownloadParams
+//
+func TestDownloadParams(t *testing.T) {
+	defer requireFDsClosed(t, openFDs(t))
+
+	getGrothParamFileAndVerifyingKeys(sectorSize)
+}
+
+func TestSealAndVerify(t *testing.T) {
+	if testing.Short() {
+		t.Skip("skipping test in short mode")
+	}
+
+	defer requireFDsClosed(t, openFDs(t))
+
+	if runtime.NumCPU() < 10 && os.Getenv("CI") == "" { // don't bother on slow hardware
+		t.Skip("this is slow")
+	}
+	_ = os.Setenv("RUST_LOG", "info")
+
+	getGrothParamFileAndVerifyingKeys(sectorSize)
+
+	cdir, err := ioutil.TempDir("", "sbtest-c-")
+	if err != nil {
+		t.Fatal(err)
+	}
+	miner := abi.ActorID(123)
+
+	cfg := &Config{
+		SealProofType: sealProofType,
+	}
+
+	sp := &basicfs.Provider{
+		Root: cdir,
+	}
+	sb, err := New(sp, cfg)
+	if err != nil {
+		t.Fatalf("%+v", err)
+	}
+	cleanup := func() {
+		if t.Failed() {
+			fmt.Printf("not removing %s\n", cdir)
+			return
+		}
+		if err := os.RemoveAll(cdir); err != nil {
+			t.Error(err)
+		}
+	}
+	defer cleanup()
+
+	si := abi.SectorID{Miner: miner, Number: 1}
+
+	s := seal{id: si}
+
+	start := time.Now()
+
+	s.precommit(t, sb, si, func() {})
+
+	precommit := time.Now()
+
+	s.commit(t, sb, func() {})
+
+	commit := time.Now()
+
+	post(t, sb, nil, s)
+
+	epost := time.Now()
+
+	post(t, sb, nil, s)
+
+	if err := sb.FinalizeSector(context.TODO(), si, nil); err != nil {
+		t.Fatalf("%+v", err)
+	}
+
+	s.unseal(t, sb, sp, si, func() {})
+
+	fmt.Printf("PreCommit: %s\n", precommit.Sub(start).String())
+	fmt.Printf("Commit: %s\n", commit.Sub(precommit).String())
+	fmt.Printf("EPoSt: %s\n", epost.Sub(commit).String())
+}
+
+func TestSealPoStNoCommit(t *testing.T) {
+	if testing.Short() {
+		t.Skip("skipping test in short mode")
+	}
+
+	defer requireFDsClosed(t, openFDs(t))
+
+	if runtime.NumCPU() < 10 && os.Getenv("CI") == "" { // don't bother on slow hardware
+		t.Skip("this is slow")
+	}
+	_ = os.Setenv("RUST_LOG", "info")
+
+	getGrothParamFileAndVerifyingKeys(sectorSize)
+
+	dir, err := ioutil.TempDir("", "sbtest")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	miner := abi.ActorID(123)
+
+	cfg := &Config{
+		SealProofType: sealProofType,
+	}
+	sp := &basicfs.Provider{
+		Root: dir,
+	}
+	sb, err := New(sp, cfg)
+	if err != nil {
+		t.Fatalf("%+v", err)
+	}
+
+	cleanup := func() {
+		if t.Failed() {
+			fmt.Printf("not removing %s\n", dir)
+			return
+		}
+		if err := os.RemoveAll(dir); err != nil {
+			t.Error(err)
+		}
+	}
+	defer cleanup()
+
+	si := abi.SectorID{Miner: miner, Number: 1}
+
+	s := seal{id: si}
+
+	start := time.Now()
+
+	s.precommit(t, sb, si, func() {})
+
+	precommit := time.Now()
+
+	if err := sb.FinalizeSector(context.TODO(), si, nil); err != nil {
+		t.Fatal(err)
+	}
+
+	post(t, sb, nil, s)
+
+	epost := time.Now()
+
+	fmt.Printf("PreCommit: %s\n", precommit.Sub(start).String())
+	fmt.Printf("EPoSt: %s\n", epost.Sub(precommit).String())
+}
+
+func TestSealAndVerify3(t *testing.T) {
+	if testing.Short() {
+		t.Skip("skipping test in short mode")
+	}
+
+	defer requireFDsClosed(t, openFDs(t))
+
+	if runtime.NumCPU() < 10 && os.Getenv("CI") == "" { // don't bother on slow hardware
+		t.Skip("this is slow")
+	}
+	_ = os.Setenv("RUST_LOG", "trace")
+
+	getGrothParamFileAndVerifyingKeys(sectorSize)
+
+	dir, err := ioutil.TempDir("", "sbtest")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	miner := abi.ActorID(123)
+
+	cfg := &Config{
+		SealProofType: sealProofType,
+	}
+	sp := &basicfs.Provider{
+		Root: dir,
+	}
+	sb, err := New(sp, cfg)
+	if err != nil {
+		t.Fatalf("%+v", err)
+	}
+
+	cleanup := func() {
+		if err := os.RemoveAll(dir); err != nil {
+			t.Error(err)
+		}
+	}
+
+	defer cleanup()
+
+	var wg sync.WaitGroup
+
+	si1 := abi.SectorID{Miner: miner, Number: 1}
+	si2 := abi.SectorID{Miner: miner, Number: 2}
+	si3 := abi.SectorID{Miner: miner, Number: 3}
+
+	s1 := seal{id: si1}
+	s2 := seal{id: si2}
+	s3 := seal{id: si3}
+
+	wg.Add(3)
+	go s1.precommit(t, sb, si1, wg.Done) //nolint: staticcheck
+	time.Sleep(100 * time.Millisecond)
+	go s2.precommit(t, sb, si2, wg.Done) //nolint: staticcheck
+	time.Sleep(100 * time.Millisecond)
+	go s3.precommit(t, sb, si3, wg.Done) //nolint: staticcheck
+	wg.Wait()
+
+	wg.Add(3)
+	go s1.commit(t, sb, wg.Done) //nolint: staticcheck
+	go s2.commit(t, sb, wg.Done) //nolint: staticcheck
+	go s3.commit(t, sb, wg.Done) //nolint: staticcheck
+	wg.Wait()
+
+	post(t, sb, nil, s1, s2, s3)
+
+	corrupt(t, sb, si1)
+	corrupt(t, sb, si2)
+
+	post(t, sb, []abi.SectorID{si1, si2}, s1, s2, s3)
+}
+
+func BenchmarkWriteWithAlignment(b *testing.B) {
+	bt := abi.UnpaddedPieceSize(2 * 127 * 1024 * 1024)
+	b.SetBytes(int64(bt))
+
+	for i := 0; i < b.N; i++ {
+		b.StopTimer()
+		rf, w, _ := ToReadableFile(bytes.NewReader(bytes.Repeat([]byte{0xff, 0}, int(bt/2))), int64(bt))
+		tf, _ := ioutil.TempFile("/tmp/", "scrb-")
+		b.StartTimer()
+
+		ffi.WriteWithAlignment(abi.RegisteredSealProof_StackedDrg2KiBV1, rf, bt, tf, nil) // nolint:errcheck
+		_ = w()
+	}
+}
+
+func openFDs(t *testing.T) int {
+	dent, err := ioutil.ReadDir("/proc/self/fd")
+	require.NoError(t, err)
+
+	var skip int
+	for _, info := range dent {
+		l, err := os.Readlink(filepath.Join("/proc/self/fd", info.Name()))
+		if err != nil {
+			continue
+		}
+
+		if strings.HasPrefix(l, "/dev/nvidia") {
+			skip++
+		}
+
+		if strings.HasPrefix(l, "/var/tmp/filecoin-proof-parameters/") {
+			skip++
+		}
+	}
+
+	return len(dent) - skip
+}
+
+func requireFDsClosed(t *testing.T, start int) {
+	openNow := openFDs(t)
+
+	if start != openNow {
+		dent, err := ioutil.ReadDir("/proc/self/fd")
+		require.NoError(t, err)
+
+		for _, info := range dent {
+			l, err := os.Readlink(filepath.Join("/proc/self/fd", info.Name()))
+			if err != nil {
+				fmt.Printf("FD err %s\n", err)
+				continue
+			}
+
+			fmt.Printf("FD %s -> %s\n", info.Name(), l)
+		}
+	}
+
+	log.Infow("open FDs", "start", start, "now", openNow)
+	require.Equal(t, start, openNow, "FDs shouldn't leak")
+}
+
+func TestGenerateUnsealedCID(t *testing.T) {
+	pt := abi.RegisteredSealProof_StackedDrg2KiBV1
+	ups := int(abi.PaddedPieceSize(2048).Unpadded())
+
+	commP := func(b []byte) cid.Cid {
+		pf, werr, err := ToReadableFile(bytes.NewReader(b), int64(len(b)))
+		require.NoError(t, err)
+
+		c, err := ffi.GeneratePieceCIDFromFile(pt, pf, abi.UnpaddedPieceSize(len(b)))
+		require.NoError(t, err)
+
+		require.NoError(t, werr())
+
+		return c
+	}
+
+	testCommEq := func(name string, in [][]byte, expect [][]byte) {
+		t.Run(name, func(t *testing.T) {
+			upi := make([]abi.PieceInfo, len(in))
+			for i, b := range in {
+				upi[i] = abi.PieceInfo{
+					Size:     abi.UnpaddedPieceSize(len(b)).Padded(),
+					PieceCID: commP(b),
+				}
+			}
+
+			sectorPi := []abi.PieceInfo{
+				{
+					Size:     2048,
+					PieceCID: commP(bytes.Join(expect, nil)),
+				},
+			}
+
+			expectCid, err := GenerateUnsealedCID(pt, sectorPi)
+			require.NoError(t, err)
+
+			actualCid, err := GenerateUnsealedCID(pt, upi)
+			require.NoError(t, err)
+
+			require.Equal(t, expectCid, actualCid)
+		})
+	}
+
+	barr := func(b byte, den int) []byte {
+		return bytes.Repeat([]byte{b}, ups/den)
+	}
+
+	// 0000
+	testCommEq("zero",
+		nil,
+		[][]byte{barr(0, 1)},
+	)
+
+	// 1111
+	testCommEq("one",
+		[][]byte{barr(1, 1)},
+		[][]byte{barr(1, 1)},
+	)
+
+	// 11 00
+	testCommEq("one|2",
+		[][]byte{barr(1, 2)},
+		[][]byte{barr(1, 2), barr(0, 2)},
+	)
+
+	// 1 0 00
+	testCommEq("one|4",
+		[][]byte{barr(1, 4)},
+		[][]byte{barr(1, 4), barr(0, 4), barr(0, 2)},
+	)
+
+	// 11 2 0
+	testCommEq("one|2-two|4",
+		[][]byte{barr(1, 2), barr(2, 4)},
+		[][]byte{barr(1, 2), barr(2, 4), barr(0, 4)},
+	)
+
+	// 1 0 22
+	testCommEq("one|4-two|2",
+		[][]byte{barr(1, 4), barr(2, 2)},
+		[][]byte{barr(1, 4), barr(0, 4), barr(2, 2)},
+	)
+
+	// 1 0 22 0000
+	testCommEq("one|8-two|4",
+		[][]byte{barr(1, 8), barr(2, 4)},
+		[][]byte{barr(1, 8), barr(0, 8), barr(2, 4), barr(0, 2)},
+	)
+
+	// 11 2 0 0000
+	testCommEq("one|4-two|8",
+		[][]byte{barr(1, 4), barr(2, 8)},
+		[][]byte{barr(1, 4), barr(2, 8), barr(0, 8), barr(0, 2)},
+	)
+
+	// 1 0 22 3 0 00 4444 5 0 00
+	testCommEq("one|16-two|8-three|16-four|4-five|16",
+		[][]byte{barr(1, 16), barr(2, 8), barr(3, 16), barr(4, 4), barr(5, 16)},
+		[][]byte{barr(1, 16), barr(0, 16), barr(2, 8), barr(3, 16), barr(0, 16), barr(0, 8), barr(4, 4), barr(5, 16), barr(0, 16), barr(0, 8)},
+	)
+}
diff --git a/extern/sector-storage/ffiwrapper/types.go b/extern/sector-storage/ffiwrapper/types.go
new file mode 100644
index 000000000..318dbd2b0
--- /dev/null
+++ b/extern/sector-storage/ffiwrapper/types.go
@@ -0,0 +1,51 @@
+package ffiwrapper
+
+import (
+	"context"
+	"io"
+
+	"github.com/filecoin-project/specs-actors/actors/runtime/proof"
+
+	"github.com/ipfs/go-cid"
+
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/specs-storage/storage"
+
+	"github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper/basicfs"
+	"github.com/filecoin-project/lotus/extern/sector-storage/stores"
+	"github.com/filecoin-project/lotus/extern/sector-storage/storiface"
+)
+
+type Validator interface {
+	CanCommit(sector stores.SectorPaths) (bool, error)
+	CanProve(sector stores.SectorPaths) (bool, error)
+}
+
+type StorageSealer interface {
+	storage.Sealer
+	storage.Storage
+}
+
+type Storage interface {
+	storage.Prover
+	StorageSealer
+
+	UnsealPiece(ctx context.Context, sector abi.SectorID, offset storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize, randomness abi.SealRandomness, commd cid.Cid) error
+	ReadPiece(ctx context.Context, writer io.Writer, sector abi.SectorID, offset storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize) (bool, error)
+}
+
+type Verifier interface {
+	VerifySeal(proof.SealVerifyInfo) (bool, error)
+	VerifyWinningPoSt(ctx context.Context, info proof.WinningPoStVerifyInfo) (bool, error)
+	VerifyWindowPoSt(ctx context.Context, info proof.WindowPoStVerifyInfo) (bool, error)
+
+	GenerateWinningPoStSectorChallenge(context.Context, abi.RegisteredPoStProof, abi.ActorID, abi.PoStRandomness, uint64) ([]uint64, error)
+}
+
+type SectorProvider interface {
+	// * returns storiface.ErrSectorNotFound if a requested existing sector doesn't exist
+	// * returns an error when allocate is set, and existing isn't, and the sector exists
+	AcquireSector(ctx context.Context, id abi.SectorID, existing stores.SectorFileType, allocate stores.SectorFileType, ptype stores.PathType) (stores.SectorPaths, func(), error)
+}
+
+var _ SectorProvider = &basicfs.Provider{}
diff --git a/extern/sector-storage/ffiwrapper/unseal_ranges.go b/extern/sector-storage/ffiwrapper/unseal_ranges.go
new file mode 100644
index 000000000..4519fc21e
--- /dev/null
+++ b/extern/sector-storage/ffiwrapper/unseal_ranges.go
@@ -0,0 +1,27 @@
+package ffiwrapper
+
+import (
+	"golang.org/x/xerrors"
+
+	rlepluslazy "github.com/filecoin-project/go-bitfield/rle"
+
+	"github.com/filecoin-project/go-state-types/abi"
+
+	"github.com/filecoin-project/lotus/extern/sector-storage/storiface"
+)
+
+// merge gaps between ranges which are close to each other
+//  TODO: more benchmarking to come up with more optimal number
+const mergeGaps = 32 << 20
+
+// TODO const expandRuns = 16 << 20 // unseal more than requested for future requests
+
+func computeUnsealRanges(unsealed rlepluslazy.RunIterator, offset storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize) (rlepluslazy.RunIterator, error) {
+	todo := pieceRun(offset.Padded(), size.Padded())
+	todo, err := rlepluslazy.Subtract(todo, unsealed)
+	if err != nil {
+		return nil, xerrors.Errorf("compute todo-unsealed: %w", err)
+	}
+
+	return rlepluslazy.JoinClose(todo, mergeGaps)
+}
diff --git a/extern/sector-storage/ffiwrapper/verifier_cgo.go b/extern/sector-storage/ffiwrapper/verifier_cgo.go
new file mode 100644
index 000000000..d6c0ae35f
--- /dev/null
+++ b/extern/sector-storage/ffiwrapper/verifier_cgo.go
@@ -0,0 +1,136 @@
+//+build cgo
+
+package ffiwrapper
+
+import (
+	"context"
+
+	"github.com/filecoin-project/specs-actors/actors/runtime/proof"
+
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-state-types/abi"
+
+	ffi "github.com/filecoin-project/filecoin-ffi"
+
+	"github.com/filecoin-project/lotus/extern/sector-storage/stores"
+
+	"go.opencensus.io/trace"
+)
+
+func (sb *Sealer) GenerateWinningPoSt(ctx context.Context, minerID abi.ActorID, sectorInfo []proof.SectorInfo, randomness abi.PoStRandomness) ([]proof.PoStProof, error) {
+	randomness[31] &= 0x3f
+	privsectors, skipped, done, err := sb.pubSectorToPriv(ctx, minerID, sectorInfo, nil, abi.RegisteredSealProof.RegisteredWinningPoStProof) // TODO: FAULTS?
+	if err != nil {
+		return nil, err
+	}
+	defer done()
+	if len(skipped) > 0 {
+		return nil, xerrors.Errorf("pubSectorToPriv skipped sectors: %+v", skipped)
+	}
+
+	return ffi.GenerateWinningPoSt(minerID, privsectors, randomness)
+}
+
+func (sb *Sealer) GenerateWindowPoSt(ctx context.Context, minerID abi.ActorID, sectorInfo []proof.SectorInfo, randomness abi.PoStRandomness) ([]proof.PoStProof, []abi.SectorID, error) {
+	randomness[31] &= 0x3f
+	privsectors, skipped, done, err := sb.pubSectorToPriv(ctx, minerID, sectorInfo, nil, abi.RegisteredSealProof.RegisteredWindowPoStProof)
+	if err != nil {
+		return nil, nil, xerrors.Errorf("gathering sector info: %w", err)
+	}
+	defer done()
+
+	if len(skipped) > 0 {
+		return nil, skipped, xerrors.Errorf("pubSectorToPriv skipped some sectors")
+	}
+
+	proof, faulty, err := ffi.GenerateWindowPoSt(minerID, privsectors, randomness)
+
+	var faultyIDs []abi.SectorID
+	for _, f := range faulty {
+		faultyIDs = append(faultyIDs, abi.SectorID{
+			Miner:  minerID,
+			Number: f,
+		})
+	}
+
+	return proof, faultyIDs, err
+}
+
+func (sb *Sealer) pubSectorToPriv(ctx context.Context, mid abi.ActorID, sectorInfo []proof.SectorInfo, faults []abi.SectorNumber, rpt func(abi.RegisteredSealProof) (abi.RegisteredPoStProof, error)) (ffi.SortedPrivateSectorInfo, []abi.SectorID, func(), error) {
+	fmap := map[abi.SectorNumber]struct{}{}
+	for _, fault := range faults {
+		fmap[fault] = struct{}{}
+	}
+
+	var doneFuncs []func()
+	done := func() {
+		for _, df := range doneFuncs {
+			df()
+		}
+	}
+
+	var skipped []abi.SectorID
+	var out []ffi.PrivateSectorInfo
+	for _, s := range sectorInfo {
+		if _, faulty := fmap[s.SectorNumber]; faulty {
+			continue
+		}
+
+		sid := abi.SectorID{Miner: mid, Number: s.SectorNumber}
+
+		paths, d, err := sb.sectors.AcquireSector(ctx, sid, stores.FTCache|stores.FTSealed, 0, stores.PathStorage)
+		if err != nil {
+			log.Warnw("failed to acquire sector, skipping", "sector", sid, "error", err)
+			skipped = append(skipped, sid)
+			continue
+		}
+		doneFuncs = append(doneFuncs, d)
+
+		postProofType, err := rpt(s.SealProof)
+		if err != nil {
+			done()
+			return ffi.SortedPrivateSectorInfo{}, nil, nil, xerrors.Errorf("acquiring registered PoSt proof from sector info %+v: %w", s, err)
+		}
+
+		out = append(out, ffi.PrivateSectorInfo{
+			CacheDirPath:     paths.Cache,
+			PoStProofType:    postProofType,
+			SealedSectorPath: paths.Sealed,
+			SectorInfo:       s,
+		})
+	}
+
+	return ffi.NewSortedPrivateSectorInfo(out...), skipped, done, nil
+}
+
+var _ Verifier = ProofVerifier
+
+type proofVerifier struct{}
+
+var ProofVerifier = proofVerifier{}
+
+func (proofVerifier) VerifySeal(info proof.SealVerifyInfo) (bool, error) {
+	return ffi.VerifySeal(info)
+}
+
+func (proofVerifier) VerifyWinningPoSt(ctx context.Context, info proof.WinningPoStVerifyInfo) (bool, error) {
+	info.Randomness[31] &= 0x3f
+	_, span := trace.StartSpan(ctx, "VerifyWinningPoSt")
+	defer span.End()
+
+	return ffi.VerifyWinningPoSt(info)
+}
+
+func (proofVerifier) VerifyWindowPoSt(ctx context.Context, info proof.WindowPoStVerifyInfo) (bool, error) {
+	info.Randomness[31] &= 0x3f
+	_, span := trace.StartSpan(ctx, "VerifyWindowPoSt")
+	defer span.End()
+
+	return ffi.VerifyWindowPoSt(info)
+}
+
+func (proofVerifier) GenerateWinningPoStSectorChallenge(ctx context.Context, proofType abi.RegisteredPoStProof, minerID abi.ActorID, randomness abi.PoStRandomness, eligibleSectorCount uint64) ([]uint64, error) {
+	randomness[31] &= 0x3f
+	return ffi.GenerateWinningPoStSectorChallenge(proofType, minerID, randomness, eligibleSectorCount)
+}
diff --git a/extern/sector-storage/fr32/fr32.go b/extern/sector-storage/fr32/fr32.go
new file mode 100644
index 000000000..17e6a1142
--- /dev/null
+++ b/extern/sector-storage/fr32/fr32.go
@@ -0,0 +1,157 @@
+package fr32
+
+import (
+	"math/bits"
+	"runtime"
+	"sync"
+
+	"github.com/filecoin-project/go-state-types/abi"
+)
+
+var MTTresh = uint64(32 << 20)
+
+func mtChunkCount(usz abi.PaddedPieceSize) uint64 {
+	threads := (uint64(usz)) / MTTresh
+	if threads > uint64(runtime.NumCPU()) {
+		threads = 1 << (bits.Len32(uint32(runtime.NumCPU())))
+	}
+	if threads == 0 {
+		return 1
+	}
+	if threads > 32 {
+		return 32 // avoid too large buffers
+	}
+	return threads
+}
+
+func mt(in, out []byte, padLen int, op func(unpadded, padded []byte)) {
+	threads := mtChunkCount(abi.PaddedPieceSize(padLen))
+	threadBytes := abi.PaddedPieceSize(padLen / int(threads))
+
+	var wg sync.WaitGroup
+	wg.Add(int(threads))
+
+	for i := 0; i < int(threads); i++ {
+		go func(thread int) {
+			defer wg.Done()
+
+			start := threadBytes * abi.PaddedPieceSize(thread)
+			end := start + threadBytes
+
+			op(in[start.Unpadded():end.Unpadded()], out[start:end])
+		}(i)
+	}
+	wg.Wait()
+}
+
+func Pad(in, out []byte) {
+	// Assumes len(in)%127==0 and len(out)%128==0
+	if len(out) > int(MTTresh) {
+		mt(in, out, len(out), pad)
+		return
+	}
+
+	pad(in, out)
+}
+
+func pad(in, out []byte) {
+	chunks := len(out) / 128
+	for chunk := 0; chunk < chunks; chunk++ {
+		inOff := chunk * 127
+		outOff := chunk * 128
+
+		copy(out[outOff:outOff+31], in[inOff:inOff+31])
+
+		t := in[inOff+31] >> 6
+		out[outOff+31] = in[inOff+31] & 0x3f
+		var v byte
+
+		for i := 32; i < 64; i++ {
+			v = in[inOff+i]
+			out[outOff+i] = (v << 2) | t
+			t = v >> 6
+		}
+
+		t = v >> 4
+		out[outOff+63] &= 0x3f
+
+		for i := 64; i < 96; i++ {
+			v = in[inOff+i]
+			out[outOff+i] = (v << 4) | t
+			t = v >> 4
+		}
+
+		t = v >> 2
+		out[outOff+95] &= 0x3f
+
+		for i := 96; i < 127; i++ {
+			v = in[inOff+i]
+			out[outOff+i] = (v << 6) | t
+			t = v >> 2
+		}
+
+		out[outOff+127] = t & 0x3f
+	}
+}
+
+func Unpad(in []byte, out []byte) {
+	// Assumes len(in)%128==0 and len(out)%127==0
+	if len(in) > int(MTTresh) {
+		mt(out, in, len(in), unpad)
+		return
+	}
+
+	unpad(out, in)
+}
+
+func unpad(out, in []byte) {
+	chunks := len(in) / 128
+	for chunk := 0; chunk < chunks; chunk++ {
+		inOffNext := chunk*128 + 1
+		outOff := chunk * 127
+
+		at := in[chunk*128]
+
+		for i := 0; i < 32; i++ {
+			next := in[i+inOffNext]
+
+			out[outOff+i] = at
+			//out[i] |= next << 8
+
+			at = next
+		}
+
+		out[outOff+31] |= at << 6
+
+		for i := 32; i < 64; i++ {
+			next := in[i+inOffNext]
+
+			out[outOff+i] = at >> 2
+			out[outOff+i] |= next << 6
+
+			at = next
+		}
+
+		out[outOff+63] ^= (at << 6) ^ (at << 4)
+
+		for i := 64; i < 96; i++ {
+			next := in[i+inOffNext]
+
+			out[outOff+i] = at >> 4
+			out[outOff+i] |= next << 4
+
+			at = next
+		}
+
+		out[outOff+95] ^= (at << 4) ^ (at << 2)
+
+		for i := 96; i < 127; i++ {
+			next := in[i+inOffNext]
+
+			out[outOff+i] = at >> 6
+			out[outOff+i] |= next << 2
+
+			at = next
+		}
+	}
+}
diff --git a/extern/sector-storage/fr32/fr32_ffi_cmp_test.go b/extern/sector-storage/fr32/fr32_ffi_cmp_test.go
new file mode 100644
index 000000000..3d5679095
--- /dev/null
+++ b/extern/sector-storage/fr32/fr32_ffi_cmp_test.go
@@ -0,0 +1,67 @@
+package fr32_test
+
+import (
+	"bytes"
+	"io"
+	"io/ioutil"
+	"os"
+	"testing"
+
+	"github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper"
+	"github.com/filecoin-project/lotus/extern/sector-storage/fr32"
+
+	ffi "github.com/filecoin-project/filecoin-ffi"
+
+	"github.com/filecoin-project/go-state-types/abi"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestWriteTwoPcs(t *testing.T) {
+	tf, _ := ioutil.TempFile("/tmp/", "scrb-")
+
+	paddedSize := abi.PaddedPieceSize(16 << 20)
+	n := 2
+
+	var rawBytes []byte
+
+	for i := 0; i < n; i++ {
+		buf := bytes.Repeat([]byte{0xab * byte(i)}, int(paddedSize.Unpadded()))
+		rawBytes = append(rawBytes, buf...)
+
+		rf, w, _ := ffiwrapper.ToReadableFile(bytes.NewReader(buf), int64(len(buf)))
+
+		_, _, _, err := ffi.WriteWithAlignment(abi.RegisteredSealProof_StackedDrg32GiBV1, rf, abi.UnpaddedPieceSize(len(buf)), tf, nil)
+		if err != nil {
+			panic(err)
+		}
+		if err := w(); err != nil {
+			panic(err)
+		}
+	}
+
+	if _, err := tf.Seek(io.SeekStart, 0); err != nil { // nolint:staticcheck
+		panic(err)
+	}
+
+	ffiBytes, err := ioutil.ReadAll(tf)
+	if err != nil {
+		panic(err)
+	}
+
+	if err := tf.Close(); err != nil {
+		panic(err)
+	}
+
+	if err := os.Remove(tf.Name()); err != nil {
+		panic(err)
+	}
+
+	outBytes := make([]byte, int(paddedSize)*n)
+	fr32.Pad(rawBytes, outBytes)
+	require.Equal(t, ffiBytes, outBytes)
+
+	unpadBytes := make([]byte, int(paddedSize.Unpadded())*n)
+	fr32.Unpad(ffiBytes, unpadBytes)
+	require.Equal(t, rawBytes, unpadBytes)
+}
diff --git a/extern/sector-storage/fr32/fr32_test.go b/extern/sector-storage/fr32/fr32_test.go
new file mode 100644
index 000000000..415134272
--- /dev/null
+++ b/extern/sector-storage/fr32/fr32_test.go
@@ -0,0 +1,250 @@
+package fr32_test
+
+import (
+	"bytes"
+	"io"
+	"io/ioutil"
+	"math/rand"
+	"os"
+	"testing"
+
+	ffi "github.com/filecoin-project/filecoin-ffi"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/stretchr/testify/require"
+
+	"github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper"
+	"github.com/filecoin-project/lotus/extern/sector-storage/fr32"
+)
+
+func padFFI(buf []byte) []byte {
+	rf, w, _ := ffiwrapper.ToReadableFile(bytes.NewReader(buf), int64(len(buf)))
+	tf, _ := ioutil.TempFile("/tmp/", "scrb-")
+
+	_, _, _, err := ffi.WriteWithAlignment(abi.RegisteredSealProof_StackedDrg32GiBV1, rf, abi.UnpaddedPieceSize(len(buf)), tf, nil)
+	if err != nil {
+		panic(err)
+	}
+	if err := w(); err != nil {
+		panic(err)
+	}
+
+	if _, err := tf.Seek(io.SeekStart, 0); err != nil { // nolint:staticcheck
+		panic(err)
+	}
+
+	padded, err := ioutil.ReadAll(tf)
+	if err != nil {
+		panic(err)
+	}
+
+	if err := tf.Close(); err != nil {
+		panic(err)
+	}
+
+	if err := os.Remove(tf.Name()); err != nil {
+		panic(err)
+	}
+
+	return padded
+}
+
+func TestPadChunkFFI(t *testing.T) {
+	testByteChunk := func(b byte) func(*testing.T) {
+		return func(t *testing.T) {
+			var buf [128]byte
+			copy(buf[:], bytes.Repeat([]byte{b}, 127))
+
+			fr32.Pad(buf[:], buf[:])
+
+			expect := padFFI(bytes.Repeat([]byte{b}, 127))
+
+			require.Equal(t, expect, buf[:])
+		}
+	}
+
+	t.Run("ones", testByteChunk(0xff))
+	t.Run("lsb1", testByteChunk(0x01))
+	t.Run("msb1", testByteChunk(0x80))
+	t.Run("zero", testByteChunk(0x0))
+	t.Run("mid", testByteChunk(0x3c))
+}
+
+func TestPadChunkRandEqFFI(t *testing.T) {
+	for i := 0; i < 200; i++ {
+		var input [127]byte
+		rand.Read(input[:])
+
+		var buf [128]byte
+
+		fr32.Pad(input[:], buf[:])
+
+		expect := padFFI(input[:])
+
+		require.Equal(t, expect, buf[:])
+	}
+}
+
+func TestRoundtrip(t *testing.T) {
+	testByteChunk := func(b byte) func(*testing.T) {
+		return func(t *testing.T) {
+			var buf [128]byte
+			input := bytes.Repeat([]byte{0x01}, 127)
+
+			fr32.Pad(input, buf[:])
+
+			var out [127]byte
+			fr32.Unpad(buf[:], out[:])
+
+			require.Equal(t, input, out[:])
+		}
+	}
+
+	t.Run("ones", testByteChunk(0xff))
+	t.Run("lsb1", testByteChunk(0x01))
+	t.Run("msb1", testByteChunk(0x80))
+	t.Run("zero", testByteChunk(0x0))
+	t.Run("mid", testByteChunk(0x3c))
+}
+
+func TestRoundtripChunkRand(t *testing.T) {
+	for i := 0; i < 200; i++ {
+		var input [127]byte
+		rand.Read(input[:])
+
+		var buf [128]byte
+		copy(buf[:], input[:])
+
+		fr32.Pad(buf[:], buf[:])
+
+		var out [127]byte
+		fr32.Unpad(buf[:], out[:])
+
+		require.Equal(t, input[:], out[:])
+	}
+}
+
+func TestRoundtrip16MRand(t *testing.T) {
+	up := abi.PaddedPieceSize(16 << 20).Unpadded()
+
+	input := make([]byte, up)
+	rand.Read(input[:])
+
+	buf := make([]byte, 16<<20)
+
+	fr32.Pad(input, buf)
+
+	out := make([]byte, up)
+	fr32.Unpad(buf, out)
+
+	require.Equal(t, input, out)
+
+	ffi := padFFI(input)
+	require.Equal(t, ffi, buf)
+}
+
+func BenchmarkPadChunk(b *testing.B) {
+	var buf [128]byte
+	in := bytes.Repeat([]byte{0xff}, 127)
+
+	b.SetBytes(127)
+
+	for i := 0; i < b.N; i++ {
+		fr32.Pad(in, buf[:])
+	}
+}
+
+func BenchmarkChunkRoundtrip(b *testing.B) {
+	var buf [128]byte
+	copy(buf[:], bytes.Repeat([]byte{0xff}, 127))
+	var out [127]byte
+
+	b.SetBytes(127)
+
+	for i := 0; i < b.N; i++ {
+		fr32.Pad(buf[:], buf[:])
+		fr32.Unpad(buf[:], out[:])
+	}
+}
+
+func BenchmarkUnpadChunk(b *testing.B) {
+	var buf [128]byte
+	copy(buf[:], bytes.Repeat([]byte{0xff}, 127))
+
+	fr32.Pad(buf[:], buf[:])
+	var out [127]byte
+
+	b.SetBytes(127)
+	b.ReportAllocs()
+
+	bs := buf[:]
+
+	for i := 0; i < b.N; i++ {
+		fr32.Unpad(bs, out[:])
+	}
+}
+
+func BenchmarkUnpad16MChunk(b *testing.B) {
+	up := abi.PaddedPieceSize(16 << 20).Unpadded()
+
+	var buf [16 << 20]byte
+
+	fr32.Pad(bytes.Repeat([]byte{0xff}, int(up)), buf[:])
+	var out [16 << 20]byte
+
+	b.SetBytes(16 << 20)
+	b.ReportAllocs()
+	b.ResetTimer()
+
+	for i := 0; i < b.N; i++ {
+		fr32.Unpad(buf[:], out[:])
+	}
+}
+
+func BenchmarkPad16MChunk(b *testing.B) {
+	up := abi.PaddedPieceSize(16 << 20).Unpadded()
+
+	var buf [16 << 20]byte
+
+	in := bytes.Repeat([]byte{0xff}, int(up))
+
+	b.SetBytes(16 << 20)
+	b.ReportAllocs()
+	b.ResetTimer()
+
+	for i := 0; i < b.N; i++ {
+		fr32.Pad(in, buf[:])
+	}
+}
+
+func BenchmarkPad1GChunk(b *testing.B) {
+	up := abi.PaddedPieceSize(1 << 30).Unpadded()
+
+	var buf [1 << 30]byte
+
+	in := bytes.Repeat([]byte{0xff}, int(up))
+
+	b.SetBytes(1 << 30)
+	b.ReportAllocs()
+	b.ResetTimer()
+
+	for i := 0; i < b.N; i++ {
+		fr32.Pad(in, buf[:])
+	}
+}
+
+func BenchmarkUnpad1GChunk(b *testing.B) {
+	up := abi.PaddedPieceSize(1 << 30).Unpadded()
+
+	var buf [1 << 30]byte
+
+	fr32.Pad(bytes.Repeat([]byte{0xff}, int(up)), buf[:])
+	var out [1 << 30]byte
+
+	b.SetBytes(1 << 30)
+	b.ReportAllocs()
+	b.ResetTimer()
+
+	for i := 0; i < b.N; i++ {
+		fr32.Unpad(buf[:], out[:])
+	}
+}
diff --git a/extern/sector-storage/fr32/readers.go b/extern/sector-storage/fr32/readers.go
new file mode 100644
index 000000000..20f3e9b31
--- /dev/null
+++ b/extern/sector-storage/fr32/readers.go
@@ -0,0 +1,133 @@
+package fr32
+
+import (
+	"io"
+	"math/bits"
+
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-state-types/abi"
+)
+
+type unpadReader struct {
+	src io.Reader
+
+	left uint64
+	work []byte
+}
+
+func NewUnpadReader(src io.Reader, sz abi.PaddedPieceSize) (io.Reader, error) {
+	if err := sz.Validate(); err != nil {
+		return nil, xerrors.Errorf("bad piece size: %w", err)
+	}
+
+	buf := make([]byte, MTTresh*mtChunkCount(sz))
+
+	return &unpadReader{
+		src: src,
+
+		left: uint64(sz),
+		work: buf,
+	}, nil
+}
+
+func (r *unpadReader) Read(out []byte) (int, error) {
+	if r.left == 0 {
+		return 0, io.EOF
+	}
+
+	chunks := len(out) / 127
+
+	outTwoPow := 1 << (63 - bits.LeadingZeros64(uint64(chunks*128)))
+
+	if err := abi.PaddedPieceSize(outTwoPow).Validate(); err != nil {
+		return 0, xerrors.Errorf("output must be of valid padded piece size: %w", err)
+	}
+
+	todo := abi.PaddedPieceSize(outTwoPow)
+	if r.left < uint64(todo) {
+		todo = abi.PaddedPieceSize(1 << (63 - bits.LeadingZeros64(r.left)))
+	}
+
+	r.left -= uint64(todo)
+
+	n, err := r.src.Read(r.work[:todo])
+	if err != nil && err != io.EOF {
+		return n, err
+	}
+
+	if n != int(todo) {
+		return 0, xerrors.Errorf("didn't read enough: %w", err)
+	}
+
+	Unpad(r.work[:todo], out[:todo.Unpadded()])
+
+	return int(todo.Unpadded()), err
+}
+
+type padWriter struct {
+	dst io.Writer
+
+	stash []byte
+	work  []byte
+}
+
+func NewPadWriter(dst io.Writer) io.WriteCloser {
+	return &padWriter{
+		dst: dst,
+	}
+}
+
+func (w *padWriter) Write(p []byte) (int, error) {
+	in := p
+
+	if len(p)+len(w.stash) < 127 {
+		w.stash = append(w.stash, p...)
+		return len(p), nil
+	}
+
+	if len(w.stash) != 0 {
+		in = append(w.stash, in...)
+	}
+
+	for {
+		pieces := subPieces(abi.UnpaddedPieceSize(len(in)))
+		biggest := pieces[len(pieces)-1]
+
+		if abi.PaddedPieceSize(cap(w.work)) < biggest.Padded() {
+			w.work = make([]byte, 0, biggest.Padded())
+		}
+
+		Pad(in[:int(biggest)], w.work[:int(biggest.Padded())])
+
+		n, err := w.dst.Write(w.work[:int(biggest.Padded())])
+		if err != nil {
+			return int(abi.PaddedPieceSize(n).Unpadded()), err
+		}
+
+		in = in[biggest:]
+
+		if len(in) < 127 {
+			if cap(w.stash) < len(in) {
+				w.stash = make([]byte, 0, len(in))
+			}
+			w.stash = w.stash[:len(in)]
+			copy(w.stash, in)
+
+			return len(p), nil
+		}
+	}
+}
+
+func (w *padWriter) Close() error {
+	if len(w.stash) > 0 {
+		return xerrors.Errorf("still have %d unprocessed bytes", len(w.stash))
+	}
+
+	// allow gc
+	w.stash = nil
+	w.work = nil
+	w.dst = nil
+
+	return nil
+}
diff --git a/extern/sector-storage/fr32/readers_test.go b/extern/sector-storage/fr32/readers_test.go
new file mode 100644
index 000000000..706af5fee
--- /dev/null
+++ b/extern/sector-storage/fr32/readers_test.go
@@ -0,0 +1,34 @@
+package fr32_test
+
+import (
+	"bytes"
+	"io/ioutil"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/filecoin-project/go-state-types/abi"
+
+	"github.com/filecoin-project/lotus/extern/sector-storage/fr32"
+)
+
+func TestUnpadReader(t *testing.T) {
+	ps := abi.PaddedPieceSize(64 << 20).Unpadded()
+
+	raw := bytes.Repeat([]byte{0x77}, int(ps))
+
+	padOut := make([]byte, ps.Padded())
+	fr32.Pad(raw, padOut)
+
+	r, err := fr32.NewUnpadReader(bytes.NewReader(padOut), ps.Padded())
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	readered, err := ioutil.ReadAll(r)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	require.Equal(t, raw, readered)
+}
diff --git a/extern/sector-storage/fr32/utils.go b/extern/sector-storage/fr32/utils.go
new file mode 100644
index 000000000..26c348f4f
--- /dev/null
+++ b/extern/sector-storage/fr32/utils.go
@@ -0,0 +1,31 @@
+package fr32
+
+import (
+	"math/bits"
+
+	"github.com/filecoin-project/go-state-types/abi"
+)
+
+func subPieces(in abi.UnpaddedPieceSize) []abi.UnpaddedPieceSize {
+	// Convert to in-sector bytes for easier math:
+	//
+	// (we convert to sector bytes as they are nice round binary numbers)
+
+	w := uint64(in.Padded())
+
+	out := make([]abi.UnpaddedPieceSize, bits.OnesCount64(w))
+	for i := range out {
+		// Extract the next lowest non-zero bit
+		next := bits.TrailingZeros64(w)
+		psize := uint64(1) << next
+		// e.g: if the number is 0b010100, psize will be 0b000100
+
+		// set that bit to 0 by XORing it, so the next iteration looks at the
+		// next bit
+		w ^= psize
+
+		// Add the piece size to the list of pieces we need to create
+		out[i] = abi.PaddedPieceSize(psize).Unpadded()
+	}
+	return out
+}
diff --git a/extern/sector-storage/fsutil/dealloc_linux.go b/extern/sector-storage/fsutil/dealloc_linux.go
new file mode 100644
index 000000000..0b20c568d
--- /dev/null
+++ b/extern/sector-storage/fsutil/dealloc_linux.go
@@ -0,0 +1,28 @@
+package fsutil
+
+import (
+	"os"
+	"syscall"
+
+	logging "github.com/ipfs/go-log/v2"
+)
+
+var log = logging.Logger("fsutil")
+
+const FallocFlPunchHole = 0x02 // linux/falloc.h
+
+func Deallocate(file *os.File, offset int64, length int64) error {
+	if length == 0 {
+		return nil
+	}
+
+	err := syscall.Fallocate(int(file.Fd()), FallocFlPunchHole, offset, length)
+	if errno, ok := err.(syscall.Errno); ok {
+		if errno == syscall.EOPNOTSUPP || errno == syscall.ENOSYS {
+			log.Warnf("could not deallocate space, ignoring: %v", errno)
+			err = nil // log and ignore
+		}
+	}
+
+	return err
+}
diff --git a/extern/sector-storage/fsutil/dealloc_other.go b/extern/sector-storage/fsutil/dealloc_other.go
new file mode 100644
index 000000000..4f8347951
--- /dev/null
+++ b/extern/sector-storage/fsutil/dealloc_other.go
@@ -0,0 +1,17 @@
+// +build !linux
+
+package fsutil
+
+import (
+	"os"
+
+	logging "github.com/ipfs/go-log/v2"
+)
+
+var log = logging.Logger("fsutil")
+
+func Deallocate(file *os.File, offset int64, length int64) error {
+	log.Warnf("deallocating space not supported")
+
+	return nil
+}
diff --git a/extern/sector-storage/fsutil/filesize_unix.go b/extern/sector-storage/fsutil/filesize_unix.go
new file mode 100644
index 000000000..500e54386
--- /dev/null
+++ b/extern/sector-storage/fsutil/filesize_unix.go
@@ -0,0 +1,29 @@
+package fsutil
+
+import (
+	"os"
+	"syscall"
+
+	"golang.org/x/xerrors"
+)
+
+type SizeInfo struct {
+	OnDisk int64
+}
+
+// FileSize returns bytes used by a file on disk
+func FileSize(path string) (SizeInfo, error) {
+	var stat syscall.Stat_t
+	if err := syscall.Stat(path, &stat); err != nil {
+		if err == syscall.ENOENT {
+			return SizeInfo{}, os.ErrNotExist
+		}
+		return SizeInfo{}, xerrors.Errorf("stat: %w", err)
+	}
+
+	// NOTE: stat.Blocks is in 512B blocks, NOT in stat.Blksize
+	//  See https://www.gnu.org/software/libc/manual/html_node/Attribute-Meanings.html
+	return SizeInfo{
+		int64(stat.Blocks) * 512, // nolint NOTE: int64 cast is needed on osx
+	}, nil
+}
diff --git a/extern/sector-storage/fsutil/statfs.go b/extern/sector-storage/fsutil/statfs.go
new file mode 100644
index 000000000..2a00ccb9a
--- /dev/null
+++ b/extern/sector-storage/fsutil/statfs.go
@@ -0,0 +1,7 @@
+package fsutil
+
+type FsStat struct {
+	Capacity  int64
+	Available int64 // Available to use for sector storage
+	Reserved  int64
+}
diff --git a/extern/sector-storage/fsutil/statfs_unix.go b/extern/sector-storage/fsutil/statfs_unix.go
new file mode 100644
index 000000000..831fd8b4f
--- /dev/null
+++ b/extern/sector-storage/fsutil/statfs_unix.go
@@ -0,0 +1,21 @@
+package fsutil
+
+import (
+	"syscall"
+
+	"golang.org/x/xerrors"
+)
+
+func Statfs(path string) (FsStat, error) {
+	var stat syscall.Statfs_t
+	if err := syscall.Statfs(path, &stat); err != nil {
+		return FsStat{}, xerrors.Errorf("statfs: %w", err)
+	}
+
+	// force int64 to handle platform specific differences
+	//nolint:unconvert
+	return FsStat{
+		Capacity:  int64(stat.Blocks) * int64(stat.Bsize),
+		Available: int64(stat.Bavail) * int64(stat.Bsize),
+	}, nil
+}
diff --git a/extern/sector-storage/fsutil/statfs_windows.go b/extern/sector-storage/fsutil/statfs_windows.go
new file mode 100644
index 000000000..d78565182
--- /dev/null
+++ b/extern/sector-storage/fsutil/statfs_windows.go
@@ -0,0 +1,28 @@
+package fsutil
+
+import (
+	"syscall"
+	"unsafe"
+)
+
+func Statfs(volumePath string) (FsStat, error) {
+	// From https://github.com/ricochet2200/go-disk-usage/blob/master/du/diskusage_windows.go
+
+	h := syscall.MustLoadDLL("kernel32.dll")
+	c := h.MustFindProc("GetDiskFreeSpaceExW")
+
+	var freeBytes int64
+	var totalBytes int64
+	var availBytes int64
+
+	c.Call(
+		uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(volumePath))),
+		uintptr(unsafe.Pointer(&freeBytes)),
+		uintptr(unsafe.Pointer(&totalBytes)),
+		uintptr(unsafe.Pointer(&availBytes)))
+
+	return FsStat{
+		Capacity:  totalBytes,
+		Available: availBytes,
+	}, nil
+}
diff --git a/extern/sector-storage/localworker.go b/extern/sector-storage/localworker.go
new file mode 100644
index 000000000..2c3c350f7
--- /dev/null
+++ b/extern/sector-storage/localworker.go
@@ -0,0 +1,298 @@
+package sectorstorage
+
+import (
+	"context"
+	"io"
+	"os"
+	"runtime"
+
+	"github.com/elastic/go-sysinfo"
+	"github.com/hashicorp/go-multierror"
+	"github.com/ipfs/go-cid"
+	"golang.org/x/xerrors"
+
+	ffi "github.com/filecoin-project/filecoin-ffi"
+	"github.com/filecoin-project/go-state-types/abi"
+	storage2 "github.com/filecoin-project/specs-storage/storage"
+
+	"github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper"
+	"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"
+)
+
+var pathTypes = []stores.SectorFileType{stores.FTUnsealed, stores.FTSealed, stores.FTCache}
+
+type WorkerConfig struct {
+	SealProof abi.RegisteredSealProof
+	TaskTypes []sealtasks.TaskType
+}
+
+type LocalWorker struct {
+	scfg       *ffiwrapper.Config
+	storage    stores.Store
+	localStore *stores.Local
+	sindex     stores.SectorIndex
+
+	acceptTasks map[sealtasks.TaskType]struct{}
+}
+
+func NewLocalWorker(wcfg WorkerConfig, store stores.Store, local *stores.Local, sindex stores.SectorIndex) *LocalWorker {
+	acceptTasks := map[sealtasks.TaskType]struct{}{}
+	for _, taskType := range wcfg.TaskTypes {
+		acceptTasks[taskType] = struct{}{}
+	}
+
+	return &LocalWorker{
+		scfg: &ffiwrapper.Config{
+			SealProofType: wcfg.SealProof,
+		},
+		storage:    store,
+		localStore: local,
+		sindex:     sindex,
+
+		acceptTasks: acceptTasks,
+	}
+}
+
+type localWorkerPathProvider struct {
+	w  *LocalWorker
+	op stores.AcquireMode
+}
+
+func (l *localWorkerPathProvider) AcquireSector(ctx context.Context, sector abi.SectorID, existing stores.SectorFileType, allocate stores.SectorFileType, sealing stores.PathType) (stores.SectorPaths, func(), error) {
+
+	paths, storageIDs, err := l.w.storage.AcquireSector(ctx, sector, l.w.scfg.SealProofType, existing, allocate, sealing, l.op)
+	if err != nil {
+		return stores.SectorPaths{}, nil, err
+	}
+
+	releaseStorage, err := l.w.localStore.Reserve(ctx, sector, l.w.scfg.SealProofType, allocate, storageIDs, stores.FSOverheadSeal)
+	if err != nil {
+		return stores.SectorPaths{}, nil, xerrors.Errorf("reserving storage space: %w", err)
+	}
+
+	log.Debugf("acquired sector %d (e:%d; a:%d): %v", sector, existing, allocate, paths)
+
+	return paths, func() {
+		releaseStorage()
+
+		for _, fileType := range pathTypes {
+			if fileType&allocate == 0 {
+				continue
+			}
+
+			sid := stores.PathByType(storageIDs, fileType)
+
+			if err := l.w.sindex.StorageDeclareSector(ctx, stores.ID(sid), sector, fileType, l.op == stores.AcquireMove); err != nil {
+				log.Errorf("declare sector error: %+v", err)
+			}
+		}
+	}, nil
+}
+
+func (l *LocalWorker) sb() (ffiwrapper.Storage, error) {
+	return ffiwrapper.New(&localWorkerPathProvider{w: l}, l.scfg)
+}
+
+func (l *LocalWorker) NewSector(ctx context.Context, sector abi.SectorID) error {
+	sb, err := l.sb()
+	if err != nil {
+		return err
+	}
+
+	return sb.NewSector(ctx, sector)
+}
+
+func (l *LocalWorker) AddPiece(ctx context.Context, sector abi.SectorID, epcs []abi.UnpaddedPieceSize, sz abi.UnpaddedPieceSize, r io.Reader) (abi.PieceInfo, error) {
+	sb, err := l.sb()
+	if err != nil {
+		return abi.PieceInfo{}, err
+	}
+
+	return sb.AddPiece(ctx, sector, epcs, sz, r)
+}
+
+func (l *LocalWorker) Fetch(ctx context.Context, sector abi.SectorID, fileType stores.SectorFileType, ptype stores.PathType, am stores.AcquireMode) error {
+	_, done, err := (&localWorkerPathProvider{w: l, op: am}).AcquireSector(ctx, sector, fileType, stores.FTNone, ptype)
+	if err != nil {
+		return err
+	}
+	done()
+	return nil
+}
+
+func (l *LocalWorker) SealPreCommit1(ctx context.Context, sector abi.SectorID, ticket abi.SealRandomness, pieces []abi.PieceInfo) (out storage2.PreCommit1Out, err error) {
+	{
+		// cleanup previous failed attempts if they exist
+		if err := l.storage.Remove(ctx, sector, stores.FTSealed, true); err != nil {
+			return nil, xerrors.Errorf("cleaning up sealed data: %w", err)
+		}
+
+		if err := l.storage.Remove(ctx, sector, stores.FTCache, true); err != nil {
+			return nil, xerrors.Errorf("cleaning up cache data: %w", err)
+		}
+	}
+
+	sb, err := l.sb()
+	if err != nil {
+		return nil, err
+	}
+
+	return sb.SealPreCommit1(ctx, sector, ticket, pieces)
+}
+
+func (l *LocalWorker) SealPreCommit2(ctx context.Context, sector abi.SectorID, phase1Out storage2.PreCommit1Out) (cids storage2.SectorCids, err error) {
+	sb, err := l.sb()
+	if err != nil {
+		return storage2.SectorCids{}, err
+	}
+
+	return sb.SealPreCommit2(ctx, sector, phase1Out)
+}
+
+func (l *LocalWorker) SealCommit1(ctx context.Context, sector abi.SectorID, ticket abi.SealRandomness, seed abi.InteractiveSealRandomness, pieces []abi.PieceInfo, cids storage2.SectorCids) (output storage2.Commit1Out, err error) {
+	sb, err := l.sb()
+	if err != nil {
+		return nil, err
+	}
+
+	return sb.SealCommit1(ctx, sector, ticket, seed, pieces, cids)
+}
+
+func (l *LocalWorker) SealCommit2(ctx context.Context, sector abi.SectorID, phase1Out storage2.Commit1Out) (proof storage2.Proof, err error) {
+	sb, err := l.sb()
+	if err != nil {
+		return nil, err
+	}
+
+	return sb.SealCommit2(ctx, sector, phase1Out)
+}
+
+func (l *LocalWorker) FinalizeSector(ctx context.Context, sector abi.SectorID, keepUnsealed []storage2.Range) error {
+	sb, err := l.sb()
+	if err != nil {
+		return err
+	}
+
+	if err := sb.FinalizeSector(ctx, sector, keepUnsealed); err != nil {
+		return xerrors.Errorf("finalizing sector: %w", err)
+	}
+
+	if len(keepUnsealed) == 0 {
+		if err := l.storage.Remove(ctx, sector, stores.FTUnsealed, true); err != nil {
+			return xerrors.Errorf("removing unsealed data: %w", err)
+		}
+	}
+
+	return nil
+}
+
+func (l *LocalWorker) ReleaseUnsealed(ctx context.Context, sector abi.SectorID, safeToFree []storage2.Range) error {
+	return xerrors.Errorf("implement me")
+}
+
+func (l *LocalWorker) Remove(ctx context.Context, sector abi.SectorID) error {
+	var err error
+
+	if rerr := l.storage.Remove(ctx, sector, stores.FTSealed, true); rerr != nil {
+		err = multierror.Append(err, xerrors.Errorf("removing sector (sealed): %w", rerr))
+	}
+	if rerr := l.storage.Remove(ctx, sector, stores.FTCache, true); rerr != nil {
+		err = multierror.Append(err, xerrors.Errorf("removing sector (cache): %w", rerr))
+	}
+	if rerr := l.storage.Remove(ctx, sector, stores.FTUnsealed, true); rerr != nil {
+		err = multierror.Append(err, xerrors.Errorf("removing sector (unsealed): %w", rerr))
+	}
+
+	return err
+}
+
+func (l *LocalWorker) MoveStorage(ctx context.Context, sector abi.SectorID, types stores.SectorFileType) error {
+	if err := l.storage.MoveStorage(ctx, sector, l.scfg.SealProofType, types); err != nil {
+		return xerrors.Errorf("moving sealed data to storage: %w", err)
+	}
+
+	return nil
+}
+
+func (l *LocalWorker) UnsealPiece(ctx context.Context, sector abi.SectorID, index storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize, randomness abi.SealRandomness, cid cid.Cid) error {
+	sb, err := l.sb()
+	if err != nil {
+		return err
+	}
+
+	if err := sb.UnsealPiece(ctx, sector, index, size, randomness, cid); err != nil {
+		return xerrors.Errorf("unsealing sector: %w", err)
+	}
+
+	if err := l.storage.RemoveCopies(ctx, sector, stores.FTSealed); err != nil {
+		return xerrors.Errorf("removing source data: %w", err)
+	}
+
+	if err := l.storage.RemoveCopies(ctx, sector, stores.FTCache); err != nil {
+		return xerrors.Errorf("removing source data: %w", err)
+	}
+
+	return nil
+}
+
+func (l *LocalWorker) ReadPiece(ctx context.Context, writer io.Writer, sector abi.SectorID, index storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize) (bool, error) {
+	sb, err := l.sb()
+	if err != nil {
+		return false, err
+	}
+
+	return sb.ReadPiece(ctx, writer, sector, index, size)
+}
+
+func (l *LocalWorker) TaskTypes(context.Context) (map[sealtasks.TaskType]struct{}, error) {
+	return l.acceptTasks, nil
+}
+
+func (l *LocalWorker) Paths(ctx context.Context) ([]stores.StoragePath, error) {
+	return l.localStore.Local(ctx)
+}
+
+func (l *LocalWorker) Info(context.Context) (storiface.WorkerInfo, error) {
+	hostname, err := os.Hostname() // TODO: allow overriding from config
+	if err != nil {
+		panic(err)
+	}
+
+	gpus, err := ffi.GetGPUDevices()
+	if err != nil {
+		log.Errorf("getting gpu devices failed: %+v", err)
+	}
+
+	h, err := sysinfo.Host()
+	if err != nil {
+		return storiface.WorkerInfo{}, xerrors.Errorf("getting host info: %w", err)
+	}
+
+	mem, err := h.Memory()
+	if err != nil {
+		return storiface.WorkerInfo{}, xerrors.Errorf("getting memory info: %w", err)
+	}
+
+	return storiface.WorkerInfo{
+		Hostname: hostname,
+		Resources: storiface.WorkerResources{
+			MemPhysical: mem.Total,
+			MemSwap:     mem.VirtualTotal,
+			MemReserved: mem.VirtualUsed + mem.Total - mem.Available, // TODO: sub this process
+			CPUs:        uint64(runtime.NumCPU()),
+			GPUs:        gpus,
+		},
+	}, nil
+}
+
+func (l *LocalWorker) Closing(ctx context.Context) (<-chan struct{}, error) {
+	return make(chan struct{}), nil
+}
+
+func (l *LocalWorker) Close() error {
+	return nil
+}
+
+var _ Worker = &LocalWorker{}
diff --git a/extern/sector-storage/manager.go b/extern/sector-storage/manager.go
new file mode 100644
index 000000000..73a5eb51e
--- /dev/null
+++ b/extern/sector-storage/manager.go
@@ -0,0 +1,521 @@
+package sectorstorage
+
+import (
+	"context"
+	"errors"
+	"io"
+	"net/http"
+
+	"github.com/hashicorp/go-multierror"
+	"github.com/ipfs/go-cid"
+	logging "github.com/ipfs/go-log/v2"
+	"github.com/mitchellh/go-homedir"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/specs-storage/storage"
+
+	"github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper"
+	"github.com/filecoin-project/lotus/extern/sector-storage/fsutil"
+	"github.com/filecoin-project/lotus/extern/sector-storage/sealtasks"
+	"github.com/filecoin-project/lotus/extern/sector-storage/stores"
+	"github.com/filecoin-project/lotus/extern/sector-storage/storiface"
+)
+
+var log = logging.Logger("advmgr")
+
+var ErrNoWorkers = errors.New("no suitable workers found")
+
+type URLs []string
+
+type Worker interface {
+	ffiwrapper.StorageSealer
+
+	MoveStorage(ctx context.Context, sector abi.SectorID, types stores.SectorFileType) error
+
+	Fetch(ctx context.Context, s abi.SectorID, ft stores.SectorFileType, ptype stores.PathType, am stores.AcquireMode) 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)
+
+	TaskTypes(context.Context) (map[sealtasks.TaskType]struct{}, error)
+
+	// Returns paths accessible to the worker
+	Paths(context.Context) ([]stores.StoragePath, error)
+
+	Info(context.Context) (storiface.WorkerInfo, error)
+
+	// returns channel signalling worker shutdown
+	Closing(context.Context) (<-chan struct{}, error)
+
+	Close() error
+}
+
+type SectorManager interface {
+	SectorSize() abi.SectorSize
+
+	ReadPiece(context.Context, io.Writer, abi.SectorID, storiface.UnpaddedByteIndex, abi.UnpaddedPieceSize, abi.SealRandomness, cid.Cid) error
+
+	ffiwrapper.StorageSealer
+	storage.Prover
+	FaultTracker
+}
+
+type WorkerID uint64
+
+type Manager struct {
+	scfg *ffiwrapper.Config
+
+	ls         stores.LocalStorage
+	storage    *stores.Remote
+	localStore *stores.Local
+	remoteHnd  *stores.FetchHandler
+	index      stores.SectorIndex
+
+	sched *scheduler
+
+	storage.Prover
+}
+
+type SealerConfig struct {
+	ParallelFetchLimit int
+
+	// Local worker config
+	AllowAddPiece   bool
+	AllowPreCommit1 bool
+	AllowPreCommit2 bool
+	AllowCommit     bool
+	AllowUnseal     bool
+}
+
+type StorageAuth http.Header
+
+func New(ctx context.Context, ls stores.LocalStorage, si stores.SectorIndex, cfg *ffiwrapper.Config, sc SealerConfig, urls URLs, sa StorageAuth) (*Manager, error) {
+	lstor, err := stores.NewLocal(ctx, ls, si, urls)
+	if err != nil {
+		return nil, err
+	}
+
+	prover, err := ffiwrapper.New(&readonlyProvider{stor: lstor, index: si}, cfg)
+	if err != nil {
+		return nil, xerrors.Errorf("creating prover instance: %w", err)
+	}
+
+	stor := stores.NewRemote(lstor, si, http.Header(sa), sc.ParallelFetchLimit)
+
+	m := &Manager{
+		scfg: cfg,
+
+		ls:         ls,
+		storage:    stor,
+		localStore: lstor,
+		remoteHnd:  &stores.FetchHandler{Local: lstor},
+		index:      si,
+
+		sched: newScheduler(cfg.SealProofType),
+
+		Prover: prover,
+	}
+
+	go m.sched.runSched()
+
+	localTasks := []sealtasks.TaskType{
+		sealtasks.TTCommit1, sealtasks.TTFinalize, sealtasks.TTFetch, sealtasks.TTReadUnsealed,
+	}
+	if sc.AllowAddPiece {
+		localTasks = append(localTasks, sealtasks.TTAddPiece)
+	}
+	if sc.AllowPreCommit1 {
+		localTasks = append(localTasks, sealtasks.TTPreCommit1)
+	}
+	if sc.AllowPreCommit2 {
+		localTasks = append(localTasks, sealtasks.TTPreCommit2)
+	}
+	if sc.AllowCommit {
+		localTasks = append(localTasks, sealtasks.TTCommit2)
+	}
+	if sc.AllowUnseal {
+		localTasks = append(localTasks, sealtasks.TTUnseal)
+	}
+
+	err = m.AddWorker(ctx, NewLocalWorker(WorkerConfig{
+		SealProof: cfg.SealProofType,
+		TaskTypes: localTasks,
+	}, stor, lstor, si))
+	if err != nil {
+		return nil, xerrors.Errorf("adding local worker: %w", err)
+	}
+
+	return m, nil
+}
+
+func (m *Manager) AddLocalStorage(ctx context.Context, path string) error {
+	path, err := homedir.Expand(path)
+	if err != nil {
+		return xerrors.Errorf("expanding local path: %w", err)
+	}
+
+	if err := m.localStore.OpenPath(ctx, path); err != nil {
+		return xerrors.Errorf("opening local path: %w", err)
+	}
+
+	if err := m.ls.SetStorage(func(sc *stores.StorageConfig) {
+		sc.StoragePaths = append(sc.StoragePaths, stores.LocalPath{Path: path})
+	}); err != nil {
+		return xerrors.Errorf("get storage config: %w", err)
+	}
+	return nil
+}
+
+func (m *Manager) AddWorker(ctx context.Context, w Worker) error {
+	info, err := w.Info(ctx)
+	if err != nil {
+		return xerrors.Errorf("getting worker info: %w", err)
+	}
+
+	m.sched.newWorkers <- &workerHandle{
+		w: w,
+		wt: &workTracker{
+			running: map[uint64]storiface.WorkerJob{},
+		},
+		info:      info,
+		preparing: &activeResources{},
+		active:    &activeResources{},
+	}
+	return nil
+}
+
+func (m *Manager) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	m.remoteHnd.ServeHTTP(w, r)
+}
+
+func (m *Manager) SectorSize() abi.SectorSize {
+	sz, _ := m.scfg.SealProofType.SectorSize()
+	return sz
+}
+
+func schedNop(context.Context, Worker) error {
+	return nil
+}
+
+func schedFetch(sector abi.SectorID, ft stores.SectorFileType, ptype stores.PathType, am stores.AcquireMode) func(context.Context, Worker) error {
+	return func(ctx context.Context, worker Worker) error {
+		return worker.Fetch(ctx, sector, ft, ptype, am)
+	}
+}
+
+func (m *Manager) tryReadUnsealedPiece(ctx context.Context, sink io.Writer, sector abi.SectorID, offset storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize) (foundUnsealed bool, readOk bool, selector WorkerSelector, returnErr error) {
+
+	// acquire a lock purely for reading unsealed sectors
+	ctx, cancel := context.WithCancel(ctx)
+	defer cancel()
+
+	if err := m.index.StorageLock(ctx, sector, stores.FTUnsealed, stores.FTNone); err != nil {
+		returnErr = xerrors.Errorf("acquiring read sector lock: %w", err)
+		return
+	}
+
+	// passing 0 spt because we only need it when allowFetch is true
+	best, err := m.index.StorageFindSector(ctx, sector, stores.FTUnsealed, 0, false)
+	if err != nil {
+		returnErr = xerrors.Errorf("read piece: checking for already existing unsealed sector: %w", err)
+		return
+	}
+
+	foundUnsealed = len(best) > 0
+	if foundUnsealed { // append to existing
+		// There is unsealed sector, see if we can read from it
+
+		selector = newExistingSelector(m.index, sector, stores.FTUnsealed, false)
+
+		err = m.sched.Schedule(ctx, sector, sealtasks.TTReadUnsealed, selector, schedFetch(sector, stores.FTUnsealed, stores.PathSealing, stores.AcquireMove), func(ctx context.Context, w Worker) error {
+			readOk, err = w.ReadPiece(ctx, sink, sector, offset, size)
+			return err
+		})
+		if err != nil {
+			returnErr = xerrors.Errorf("reading piece from sealed sector: %w", err)
+		}
+	} else {
+		selector = newAllocSelector(m.index, stores.FTUnsealed, stores.PathSealing)
+	}
+	return
+}
+
+func (m *Manager) ReadPiece(ctx context.Context, sink io.Writer, sector abi.SectorID, offset storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize, ticket abi.SealRandomness, unsealed cid.Cid) error {
+	foundUnsealed, readOk, selector, err := m.tryReadUnsealedPiece(ctx, sink, sector, offset, size)
+	if err != nil {
+		return err
+	}
+	if readOk {
+		return nil
+	}
+	ctx, cancel := context.WithCancel(ctx)
+	defer cancel()
+
+	if err := m.index.StorageLock(ctx, sector, stores.FTSealed|stores.FTCache, stores.FTUnsealed); err != nil {
+		return xerrors.Errorf("acquiring unseal sector lock: %w", err)
+	}
+
+	unsealFetch := func(ctx context.Context, worker Worker) error {
+		if err := worker.Fetch(ctx, sector, stores.FTSealed|stores.FTCache, stores.PathSealing, stores.AcquireCopy); err != nil {
+			return xerrors.Errorf("copy sealed/cache sector data: %w", err)
+		}
+
+		if foundUnsealed {
+			if err := worker.Fetch(ctx, sector, stores.FTUnsealed, stores.PathSealing, stores.AcquireMove); err != nil {
+				return xerrors.Errorf("copy unsealed sector data: %w", err)
+			}
+		}
+		return nil
+	}
+
+	if unsealed == cid.Undef {
+		return xerrors.Errorf("cannot unseal piece (sector: %d, offset: %d size: %d) - unsealed cid is undefined", sector, offset, size)
+	}
+	err = m.sched.Schedule(ctx, sector, sealtasks.TTUnseal, selector, unsealFetch, func(ctx context.Context, w Worker) error {
+		return w.UnsealPiece(ctx, sector, offset, size, ticket, unsealed)
+	})
+	if err != nil {
+		return err
+	}
+
+	selector = newExistingSelector(m.index, sector, stores.FTUnsealed, false)
+
+	err = m.sched.Schedule(ctx, sector, sealtasks.TTReadUnsealed, selector, schedFetch(sector, stores.FTUnsealed, stores.PathSealing, stores.AcquireMove), func(ctx context.Context, w Worker) error {
+		readOk, err = w.ReadPiece(ctx, sink, sector, offset, size)
+		return err
+	})
+	if err != nil {
+		return xerrors.Errorf("reading piece from sealed sector: %w", err)
+	}
+
+	if !readOk {
+		return xerrors.Errorf("failed to read unsealed piece")
+	}
+
+	return nil
+}
+
+func (m *Manager) NewSector(ctx context.Context, sector abi.SectorID) error {
+	log.Warnf("stub NewSector")
+	return nil
+}
+
+func (m *Manager) AddPiece(ctx context.Context, sector abi.SectorID, existingPieces []abi.UnpaddedPieceSize, sz abi.UnpaddedPieceSize, r io.Reader) (abi.PieceInfo, error) {
+	ctx, cancel := context.WithCancel(ctx)
+	defer cancel()
+
+	if err := m.index.StorageLock(ctx, sector, stores.FTNone, stores.FTUnsealed); err != nil {
+		return abi.PieceInfo{}, xerrors.Errorf("acquiring sector lock: %w", err)
+	}
+
+	var selector WorkerSelector
+	var err error
+	if len(existingPieces) == 0 { // new
+		selector = newAllocSelector(m.index, stores.FTUnsealed, stores.PathSealing)
+	} else { // use existing
+		selector = newExistingSelector(m.index, sector, stores.FTUnsealed, false)
+	}
+
+	var out abi.PieceInfo
+	err = m.sched.Schedule(ctx, sector, sealtasks.TTAddPiece, selector, schedNop, func(ctx context.Context, w Worker) error {
+		p, err := w.AddPiece(ctx, sector, existingPieces, sz, r)
+		if err != nil {
+			return err
+		}
+		out = p
+		return nil
+	})
+
+	return out, err
+}
+
+func (m *Manager) SealPreCommit1(ctx context.Context, sector abi.SectorID, ticket abi.SealRandomness, pieces []abi.PieceInfo) (out storage.PreCommit1Out, err error) {
+	ctx, cancel := context.WithCancel(ctx)
+	defer cancel()
+
+	if err := m.index.StorageLock(ctx, sector, stores.FTUnsealed, stores.FTSealed|stores.FTCache); err != nil {
+		return nil, xerrors.Errorf("acquiring sector lock: %w", err)
+	}
+
+	// TODO: also consider where the unsealed data sits
+
+	selector := newAllocSelector(m.index, stores.FTCache|stores.FTSealed, stores.PathSealing)
+
+	err = m.sched.Schedule(ctx, sector, sealtasks.TTPreCommit1, selector, schedFetch(sector, stores.FTUnsealed, stores.PathSealing, stores.AcquireMove), func(ctx context.Context, w Worker) error {
+		p, err := w.SealPreCommit1(ctx, sector, ticket, pieces)
+		if err != nil {
+			return err
+		}
+		out = p
+		return nil
+	})
+
+	return out, err
+}
+
+func (m *Manager) SealPreCommit2(ctx context.Context, sector abi.SectorID, phase1Out storage.PreCommit1Out) (out storage.SectorCids, err error) {
+	ctx, cancel := context.WithCancel(ctx)
+	defer cancel()
+
+	if err := m.index.StorageLock(ctx, sector, stores.FTSealed, stores.FTCache); err != nil {
+		return storage.SectorCids{}, xerrors.Errorf("acquiring sector lock: %w", err)
+	}
+
+	selector := newExistingSelector(m.index, sector, stores.FTCache|stores.FTSealed, true)
+
+	err = m.sched.Schedule(ctx, sector, sealtasks.TTPreCommit2, selector, schedFetch(sector, stores.FTCache|stores.FTSealed, stores.PathSealing, stores.AcquireMove), func(ctx context.Context, w Worker) error {
+		p, err := w.SealPreCommit2(ctx, sector, phase1Out)
+		if err != nil {
+			return err
+		}
+		out = p
+		return nil
+	})
+	return out, err
+}
+
+func (m *Manager) SealCommit1(ctx context.Context, sector abi.SectorID, ticket abi.SealRandomness, seed abi.InteractiveSealRandomness, pieces []abi.PieceInfo, cids storage.SectorCids) (out storage.Commit1Out, err error) {
+	ctx, cancel := context.WithCancel(ctx)
+	defer cancel()
+
+	if err := m.index.StorageLock(ctx, sector, stores.FTSealed, stores.FTCache); err != nil {
+		return storage.Commit1Out{}, xerrors.Errorf("acquiring sector lock: %w", err)
+	}
+
+	// NOTE: We set allowFetch to false in so that we always execute on a worker
+	// with direct access to the data. We want to do that because this step is
+	// generally very cheap / fast, and transferring data is not worth the effort
+	selector := newExistingSelector(m.index, sector, stores.FTCache|stores.FTSealed, false)
+
+	err = m.sched.Schedule(ctx, sector, sealtasks.TTCommit1, selector, schedFetch(sector, stores.FTCache|stores.FTSealed, stores.PathSealing, stores.AcquireMove), func(ctx context.Context, w Worker) error {
+		p, err := w.SealCommit1(ctx, sector, ticket, seed, pieces, cids)
+		if err != nil {
+			return err
+		}
+		out = p
+		return nil
+	})
+	return out, err
+}
+
+func (m *Manager) SealCommit2(ctx context.Context, sector abi.SectorID, phase1Out storage.Commit1Out) (out storage.Proof, err error) {
+	selector := newTaskSelector()
+
+	err = m.sched.Schedule(ctx, sector, sealtasks.TTCommit2, selector, schedNop, func(ctx context.Context, w Worker) error {
+		p, err := w.SealCommit2(ctx, sector, phase1Out)
+		if err != nil {
+			return err
+		}
+		out = p
+		return nil
+	})
+
+	return out, err
+}
+
+func (m *Manager) FinalizeSector(ctx context.Context, sector abi.SectorID, keepUnsealed []storage.Range) error {
+	ctx, cancel := context.WithCancel(ctx)
+	defer cancel()
+
+	if err := m.index.StorageLock(ctx, sector, stores.FTNone, stores.FTSealed|stores.FTUnsealed|stores.FTCache); err != nil {
+		return xerrors.Errorf("acquiring sector lock: %w", err)
+	}
+
+	unsealed := stores.FTUnsealed
+	{
+		unsealedStores, err := m.index.StorageFindSector(ctx, sector, stores.FTUnsealed, 0, false)
+		if err != nil {
+			return xerrors.Errorf("finding unsealed sector: %w", err)
+		}
+
+		if len(unsealedStores) == 0 { // Is some edge-cases unsealed sector may not exist already, that's fine
+			unsealed = stores.FTNone
+		}
+	}
+
+	selector := newExistingSelector(m.index, sector, stores.FTCache|stores.FTSealed, false)
+
+	err := m.sched.Schedule(ctx, sector, sealtasks.TTFinalize, selector,
+		schedFetch(sector, stores.FTCache|stores.FTSealed|unsealed, stores.PathSealing, stores.AcquireMove),
+		func(ctx context.Context, w Worker) error {
+			return w.FinalizeSector(ctx, sector, keepUnsealed)
+		})
+	if err != nil {
+		return err
+	}
+
+	fetchSel := newAllocSelector(m.index, stores.FTCache|stores.FTSealed, stores.PathStorage)
+	moveUnsealed := unsealed
+	{
+		if len(keepUnsealed) == 0 {
+			moveUnsealed = stores.FTNone
+		}
+	}
+
+	err = m.sched.Schedule(ctx, sector, sealtasks.TTFetch, fetchSel,
+		schedFetch(sector, stores.FTCache|stores.FTSealed|moveUnsealed, stores.PathStorage, stores.AcquireMove),
+		func(ctx context.Context, w Worker) error {
+			return w.MoveStorage(ctx, sector, stores.FTCache|stores.FTSealed|moveUnsealed)
+		})
+	if err != nil {
+		return xerrors.Errorf("moving sector to storage: %w", err)
+	}
+
+	return nil
+}
+
+func (m *Manager) ReleaseUnsealed(ctx context.Context, sector abi.SectorID, safeToFree []storage.Range) error {
+	log.Warnw("ReleaseUnsealed todo")
+	return nil
+}
+
+func (m *Manager) Remove(ctx context.Context, sector abi.SectorID) error {
+	ctx, cancel := context.WithCancel(ctx)
+	defer cancel()
+
+	if err := m.index.StorageLock(ctx, sector, stores.FTNone, stores.FTSealed|stores.FTUnsealed|stores.FTCache); err != nil {
+		return xerrors.Errorf("acquiring sector lock: %w", err)
+	}
+
+	var err error
+
+	if rerr := m.storage.Remove(ctx, sector, stores.FTSealed, true); rerr != nil {
+		err = multierror.Append(err, xerrors.Errorf("removing sector (sealed): %w", rerr))
+	}
+	if rerr := m.storage.Remove(ctx, sector, stores.FTCache, true); rerr != nil {
+		err = multierror.Append(err, xerrors.Errorf("removing sector (cache): %w", rerr))
+	}
+	if rerr := m.storage.Remove(ctx, sector, stores.FTUnsealed, true); rerr != nil {
+		err = multierror.Append(err, xerrors.Errorf("removing sector (unsealed): %w", rerr))
+	}
+
+	return err
+}
+
+func (m *Manager) StorageLocal(ctx context.Context) (map[stores.ID]string, error) {
+	l, err := m.localStore.Local(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	out := map[stores.ID]string{}
+	for _, st := range l {
+		out[st.ID] = st.LocalPath
+	}
+
+	return out, nil
+}
+
+func (m *Manager) FsStat(ctx context.Context, id stores.ID) (fsutil.FsStat, error) {
+	return m.storage.FsStat(ctx, id)
+}
+
+func (m *Manager) SchedDiag(ctx context.Context) (interface{}, error) {
+	return m.sched.Info(ctx)
+}
+
+func (m *Manager) Close(ctx context.Context) error {
+	return m.sched.Close(ctx)
+}
+
+var _ SectorManager = &Manager{}
diff --git a/extern/sector-storage/manager_test.go b/extern/sector-storage/manager_test.go
new file mode 100644
index 000000000..ee704cb5a
--- /dev/null
+++ b/extern/sector-storage/manager_test.go
@@ -0,0 +1,152 @@
+package sectorstorage
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper"
+	"github.com/filecoin-project/lotus/extern/sector-storage/fsutil"
+	"github.com/filecoin-project/lotus/extern/sector-storage/sealtasks"
+	"github.com/filecoin-project/lotus/extern/sector-storage/stores"
+
+	"github.com/filecoin-project/go-state-types/abi"
+
+	"github.com/google/uuid"
+	logging "github.com/ipfs/go-log"
+	"github.com/stretchr/testify/require"
+)
+
+func init() {
+	logging.SetAllLoggers(logging.LevelDebug)
+}
+
+type testStorage stores.StorageConfig
+
+func (t testStorage) DiskUsage(path string) (int64, error) {
+	return 1, nil // close enough
+}
+
+func newTestStorage(t *testing.T) *testStorage {
+	tp, err := ioutil.TempDir(os.TempDir(), "sector-storage-test-")
+	require.NoError(t, err)
+
+	{
+		b, err := json.MarshalIndent(&stores.LocalStorageMeta{
+			ID:       stores.ID(uuid.New().String()),
+			Weight:   1,
+			CanSeal:  true,
+			CanStore: true,
+		}, "", "  ")
+		require.NoError(t, err)
+
+		err = ioutil.WriteFile(filepath.Join(tp, "sectorstore.json"), b, 0644)
+		require.NoError(t, err)
+	}
+
+	return &testStorage{
+		StoragePaths: []stores.LocalPath{
+			{Path: tp},
+		},
+	}
+}
+
+func (t testStorage) cleanup() {
+	for _, path := range t.StoragePaths {
+		if err := os.RemoveAll(path.Path); err != nil {
+			fmt.Println("Cleanup error:", err)
+		}
+	}
+}
+
+func (t testStorage) GetStorage() (stores.StorageConfig, error) {
+	return stores.StorageConfig(t), nil
+}
+
+func (t *testStorage) SetStorage(f func(*stores.StorageConfig)) error {
+	f((*stores.StorageConfig)(t))
+	return nil
+}
+
+func (t *testStorage) Stat(path string) (fsutil.FsStat, error) {
+	return fsutil.Statfs(path)
+}
+
+var _ stores.LocalStorage = &testStorage{}
+
+func newTestMgr(ctx context.Context, t *testing.T) (*Manager, *stores.Local, *stores.Remote, *stores.Index) {
+	st := newTestStorage(t)
+	defer st.cleanup()
+
+	si := stores.NewIndex()
+	cfg := &ffiwrapper.Config{
+		SealProofType: abi.RegisteredSealProof_StackedDrg2KiBV1,
+	}
+
+	lstor, err := stores.NewLocal(ctx, st, si, nil)
+	require.NoError(t, err)
+
+	prover, err := ffiwrapper.New(&readonlyProvider{stor: lstor}, cfg)
+	require.NoError(t, err)
+
+	stor := stores.NewRemote(lstor, si, nil, 6000)
+
+	m := &Manager{
+		scfg: cfg,
+
+		ls:         st,
+		storage:    stor,
+		localStore: lstor,
+		remoteHnd:  &stores.FetchHandler{Local: lstor},
+		index:      si,
+
+		sched: newScheduler(cfg.SealProofType),
+
+		Prover: prover,
+	}
+
+	go m.sched.runSched()
+
+	return m, lstor, stor, si
+}
+
+func TestSimple(t *testing.T) {
+	logging.SetAllLoggers(logging.LevelDebug)
+
+	ctx := context.Background()
+	m, lstor, _, _ := newTestMgr(ctx, t)
+
+	localTasks := []sealtasks.TaskType{
+		sealtasks.TTAddPiece, sealtasks.TTPreCommit1, sealtasks.TTCommit1, sealtasks.TTFinalize, sealtasks.TTFetch,
+	}
+
+	err := m.AddWorker(ctx, newTestWorker(WorkerConfig{
+		SealProof: abi.RegisteredSealProof_StackedDrg2KiBV1,
+		TaskTypes: localTasks,
+	}, lstor))
+	require.NoError(t, err)
+
+	sid := abi.SectorID{Miner: 1000, Number: 1}
+
+	pi, err := m.AddPiece(ctx, sid, nil, 1016, strings.NewReader(strings.Repeat("testthis", 127)))
+	require.NoError(t, err)
+	require.Equal(t, abi.PaddedPieceSize(1024), pi.Size)
+
+	piz, err := m.AddPiece(ctx, sid, nil, 1016, bytes.NewReader(make([]byte, 1016)[:]))
+	require.NoError(t, err)
+	require.Equal(t, abi.PaddedPieceSize(1024), piz.Size)
+
+	pieces := []abi.PieceInfo{pi, piz}
+
+	ticket := abi.SealRandomness{9, 9, 9, 9, 9, 9, 9, 9}
+
+	_, err = m.SealPreCommit1(ctx, sid, ticket, pieces)
+	require.NoError(t, err)
+
+}
diff --git a/extern/sector-storage/mock/mock.go b/extern/sector-storage/mock/mock.go
new file mode 100644
index 000000000..64207e66d
--- /dev/null
+++ b/extern/sector-storage/mock/mock.go
@@ -0,0 +1,452 @@
+package mock
+
+import (
+	"bytes"
+	"context"
+	"crypto/sha256"
+	"fmt"
+	"io"
+	"math/rand"
+	"sync"
+
+	"github.com/filecoin-project/specs-actors/actors/runtime/proof"
+
+	commcid "github.com/filecoin-project/go-fil-commcid"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/specs-storage/storage"
+	"github.com/ipfs/go-cid"
+	logging "github.com/ipfs/go-log"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper"
+	"github.com/filecoin-project/lotus/extern/sector-storage/storiface"
+)
+
+var log = logging.Logger("sbmock")
+
+type SectorMgr struct {
+	sectors      map[abi.SectorID]*sectorState
+	pieces       map[cid.Cid][]byte
+	sectorSize   abi.SectorSize
+	nextSectorID abi.SectorNumber
+	proofType    abi.RegisteredSealProof
+
+	lk sync.Mutex
+}
+
+type mockVerif struct{}
+
+func NewMockSectorMgr(ssize abi.SectorSize, genesisSectors []abi.SectorID) *SectorMgr {
+	rt, err := ffiwrapper.SealProofTypeFromSectorSize(ssize)
+	if err != nil {
+		panic(err)
+	}
+
+	sectors := make(map[abi.SectorID]*sectorState)
+	for _, sid := range genesisSectors {
+		sectors[sid] = &sectorState{
+			failed: false,
+			state:  stateCommit,
+		}
+	}
+
+	return &SectorMgr{
+		sectors:      sectors,
+		pieces:       map[cid.Cid][]byte{},
+		sectorSize:   ssize,
+		nextSectorID: 5,
+		proofType:    rt,
+	}
+}
+
+const (
+	statePacking = iota
+	statePreCommit
+	stateCommit // nolint
+)
+
+type sectorState struct {
+	pieces    []cid.Cid
+	failed    bool
+	corrupted bool
+
+	state int
+
+	lk sync.Mutex
+}
+
+func (mgr *SectorMgr) NewSector(ctx context.Context, sector abi.SectorID) error {
+	return nil
+}
+
+func (mgr *SectorMgr) AddPiece(ctx context.Context, sectorID abi.SectorID, existingPieces []abi.UnpaddedPieceSize, size abi.UnpaddedPieceSize, r io.Reader) (abi.PieceInfo, error) {
+	log.Warn("Add piece: ", sectorID, size, mgr.proofType)
+
+	var b bytes.Buffer
+	tr := io.TeeReader(r, &b)
+
+	c, err := ffiwrapper.GeneratePieceCIDFromFile(mgr.proofType, tr, size)
+	if err != nil {
+		return abi.PieceInfo{}, xerrors.Errorf("failed to generate piece cid: %w", err)
+	}
+
+	log.Warn("Generated Piece CID: ", c)
+
+	mgr.lk.Lock()
+	mgr.pieces[c] = b.Bytes()
+
+	ss, ok := mgr.sectors[sectorID]
+	if !ok {
+		ss = &sectorState{
+			state: statePacking,
+		}
+		mgr.sectors[sectorID] = ss
+	}
+	mgr.lk.Unlock()
+
+	ss.lk.Lock()
+	ss.pieces = append(ss.pieces, c)
+	ss.lk.Unlock()
+
+	return abi.PieceInfo{
+
+		Size:     size.Padded(),
+		PieceCID: c,
+	}, nil
+}
+
+func (mgr *SectorMgr) SectorSize() abi.SectorSize {
+	return mgr.sectorSize
+}
+
+func (mgr *SectorMgr) AcquireSectorNumber() (abi.SectorNumber, error) {
+	mgr.lk.Lock()
+	defer mgr.lk.Unlock()
+	id := mgr.nextSectorID
+	mgr.nextSectorID++
+	return id, nil
+}
+
+func (mgr *SectorMgr) SealPreCommit1(ctx context.Context, sid abi.SectorID, ticket abi.SealRandomness, pieces []abi.PieceInfo) (out storage.PreCommit1Out, err error) {
+	mgr.lk.Lock()
+	ss, ok := mgr.sectors[sid]
+	mgr.lk.Unlock()
+	if !ok {
+		return nil, xerrors.Errorf("no sector with id %d in storage", sid)
+	}
+
+	ss.lk.Lock()
+	defer ss.lk.Unlock()
+
+	ussize := abi.PaddedPieceSize(mgr.sectorSize).Unpadded()
+
+	// TODO: verify pieces in sinfo.pieces match passed in pieces
+
+	var sum abi.UnpaddedPieceSize
+	for _, p := range pieces {
+		sum += p.Size.Unpadded()
+	}
+
+	if sum != ussize {
+		return nil, xerrors.Errorf("aggregated piece sizes don't match up: %d != %d", sum, ussize)
+	}
+
+	if ss.state != statePacking {
+		return nil, xerrors.Errorf("cannot call pre-seal on sector not in 'packing' state")
+	}
+
+	opFinishWait(ctx)
+
+	ss.state = statePreCommit
+
+	pis := make([]abi.PieceInfo, len(ss.pieces))
+	for i, piece := range ss.pieces {
+		pis[i] = abi.PieceInfo{
+			Size:     pieces[i].Size,
+			PieceCID: piece,
+		}
+	}
+
+	commd, err := MockVerifier.GenerateDataCommitment(mgr.proofType, pis)
+	if err != nil {
+		return nil, err
+	}
+
+	_, _, cc, err := commcid.CIDToCommitment(commd)
+	if err != nil {
+		panic(err)
+	}
+
+	cc[0] ^= 'd'
+
+	return cc, nil
+}
+
+func (mgr *SectorMgr) SealPreCommit2(ctx context.Context, sid abi.SectorID, phase1Out storage.PreCommit1Out) (cids storage.SectorCids, err error) {
+	db := []byte(string(phase1Out))
+	db[0] ^= 'd'
+
+	d, _ := commcid.DataCommitmentV1ToCID(db)
+
+	commr := make([]byte, 32)
+	for i := range db {
+		commr[32-(i+1)] = db[i]
+	}
+
+	commR, _ := commcid.ReplicaCommitmentV1ToCID(commr)
+
+	return storage.SectorCids{
+		Unsealed: d,
+		Sealed:   commR,
+	}, nil
+}
+
+func (mgr *SectorMgr) SealCommit1(ctx context.Context, sid abi.SectorID, ticket abi.SealRandomness, seed abi.InteractiveSealRandomness, pieces []abi.PieceInfo, cids storage.SectorCids) (output storage.Commit1Out, err error) {
+	mgr.lk.Lock()
+	ss, ok := mgr.sectors[sid]
+	mgr.lk.Unlock()
+	if !ok {
+		return nil, xerrors.Errorf("no such sector %d", sid)
+	}
+	ss.lk.Lock()
+	defer ss.lk.Unlock()
+
+	if ss.failed {
+		return nil, xerrors.Errorf("[mock] cannot commit failed sector %d", sid)
+	}
+
+	if ss.state != statePreCommit {
+		return nil, xerrors.Errorf("cannot commit sector that has not been precommitted")
+	}
+
+	opFinishWait(ctx)
+
+	var out [32]byte
+	for i := range out {
+		out[i] = cids.Unsealed.Bytes()[i] + cids.Sealed.Bytes()[31-i] - ticket[i]*seed[i] ^ byte(sid.Number&0xff)
+	}
+
+	return out[:], nil
+}
+
+func (mgr *SectorMgr) SealCommit2(ctx context.Context, sid abi.SectorID, phase1Out storage.Commit1Out) (proof storage.Proof, err error) {
+	var out [32]byte
+	for i := range out {
+		out[i] = phase1Out[i] ^ byte(sid.Number&0xff)
+	}
+
+	return out[:], nil
+}
+
+// Test Instrumentation Methods
+
+func (mgr *SectorMgr) MarkFailed(sid abi.SectorID, failed bool) error {
+	mgr.lk.Lock()
+	defer mgr.lk.Unlock()
+	ss, ok := mgr.sectors[sid]
+	if !ok {
+		return fmt.Errorf("no such sector in storage")
+	}
+
+	ss.failed = failed
+	return nil
+}
+
+func (mgr *SectorMgr) MarkCorrupted(sid abi.SectorID, corrupted bool) error {
+	mgr.lk.Lock()
+	defer mgr.lk.Unlock()
+	ss, ok := mgr.sectors[sid]
+	if !ok {
+		return fmt.Errorf("no such sector in storage")
+	}
+
+	ss.corrupted = corrupted
+	return nil
+}
+
+func opFinishWait(ctx context.Context) {
+	val, ok := ctx.Value("opfinish").(chan struct{})
+	if !ok {
+		return
+	}
+	<-val
+}
+
+func AddOpFinish(ctx context.Context) (context.Context, func()) {
+	done := make(chan struct{})
+
+	return context.WithValue(ctx, "opfinish", done), func() { // nolint
+		close(done)
+	}
+}
+
+func (mgr *SectorMgr) GenerateWinningPoSt(ctx context.Context, minerID abi.ActorID, sectorInfo []proof.SectorInfo, randomness abi.PoStRandomness) ([]proof.PoStProof, error) {
+	return generateFakePoSt(sectorInfo, abi.RegisteredSealProof.RegisteredWinningPoStProof, randomness), nil
+}
+
+func (mgr *SectorMgr) GenerateWindowPoSt(ctx context.Context, minerID abi.ActorID, sectorInfo []proof.SectorInfo, randomness abi.PoStRandomness) ([]proof.PoStProof, []abi.SectorID, error) {
+	si := make([]proof.SectorInfo, 0, len(sectorInfo))
+	var skipped []abi.SectorID
+
+	var err error
+
+	for _, info := range sectorInfo {
+		sid := abi.SectorID{
+			Miner:  minerID,
+			Number: info.SectorNumber,
+		}
+
+		_, found := mgr.sectors[sid]
+
+		if found && !mgr.sectors[sid].failed && !mgr.sectors[sid].corrupted {
+			si = append(si, info)
+		} else {
+			skipped = append(skipped, sid)
+			err = xerrors.Errorf("skipped some sectors")
+		}
+	}
+
+	if err != nil {
+		return nil, skipped, err
+	}
+
+	return generateFakePoSt(si, abi.RegisteredSealProof.RegisteredWindowPoStProof, randomness), skipped, nil
+}
+
+func generateFakePoStProof(sectorInfo []proof.SectorInfo, randomness abi.PoStRandomness) []byte {
+	hasher := sha256.New()
+	_, _ = hasher.Write(randomness)
+	for _, info := range sectorInfo {
+		err := info.MarshalCBOR(hasher)
+		if err != nil {
+			panic(err)
+		}
+	}
+	return hasher.Sum(nil)
+
+}
+
+func generateFakePoSt(sectorInfo []proof.SectorInfo, rpt func(abi.RegisteredSealProof) (abi.RegisteredPoStProof, error), randomness abi.PoStRandomness) []proof.PoStProof {
+	wp, err := rpt(sectorInfo[0].SealProof)
+	if err != nil {
+		panic(err)
+	}
+
+	return []proof.PoStProof{
+		{
+			PoStProof:  wp,
+			ProofBytes: generateFakePoStProof(sectorInfo, randomness),
+		},
+	}
+}
+
+func (mgr *SectorMgr) ReadPiece(ctx context.Context, w io.Writer, sectorID abi.SectorID, offset storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize, randomness abi.SealRandomness, c cid.Cid) error {
+	if len(mgr.sectors[sectorID].pieces) > 1 || offset != 0 {
+		panic("implme")
+	}
+
+	_, err := io.CopyN(w, bytes.NewReader(mgr.pieces[mgr.sectors[sectorID].pieces[0]]), int64(size))
+	return err
+}
+
+func (mgr *SectorMgr) StageFakeData(mid abi.ActorID) (abi.SectorID, []abi.PieceInfo, error) {
+	usize := abi.PaddedPieceSize(mgr.sectorSize).Unpadded()
+	sid, err := mgr.AcquireSectorNumber()
+	if err != nil {
+		return abi.SectorID{}, nil, err
+	}
+
+	buf := make([]byte, usize)
+	_, _ = rand.Read(buf) // nolint:gosec
+
+	id := abi.SectorID{
+		Miner:  mid,
+		Number: sid,
+	}
+
+	pi, err := mgr.AddPiece(context.TODO(), id, nil, usize, bytes.NewReader(buf))
+	if err != nil {
+		return abi.SectorID{}, nil, err
+	}
+
+	return id, []abi.PieceInfo{pi}, nil
+}
+
+func (mgr *SectorMgr) FinalizeSector(context.Context, abi.SectorID, []storage.Range) error {
+	return nil
+}
+
+func (mgr *SectorMgr) ReleaseUnsealed(ctx context.Context, sector abi.SectorID, safeToFree []storage.Range) error {
+	return nil
+}
+
+func (mgr *SectorMgr) Remove(ctx context.Context, sector abi.SectorID) error {
+	mgr.lk.Lock()
+	defer mgr.lk.Unlock()
+
+	if _, has := mgr.sectors[sector]; !has {
+		return xerrors.Errorf("sector not found")
+	}
+
+	delete(mgr.sectors, sector)
+	return nil
+}
+
+func (mgr *SectorMgr) CheckProvable(ctx context.Context, spt abi.RegisteredSealProof, ids []abi.SectorID) ([]abi.SectorID, error) {
+	var bad []abi.SectorID
+
+	for _, sid := range ids {
+		_, found := mgr.sectors[sid]
+
+		if !found || mgr.sectors[sid].failed {
+			bad = append(bad, sid)
+		}
+	}
+
+	return bad, nil
+}
+
+func (m mockVerif) VerifySeal(svi proof.SealVerifyInfo) (bool, error) {
+	if len(svi.Proof) != 32 { // Real ones are longer, but this should be fine
+		return false, nil
+	}
+
+	for i, b := range svi.Proof {
+		if b != svi.UnsealedCID.Bytes()[i]+svi.SealedCID.Bytes()[31-i]-svi.InteractiveRandomness[i]*svi.Randomness[i] {
+			return false, nil
+		}
+	}
+
+	return true, nil
+}
+
+func (m mockVerif) VerifyWinningPoSt(ctx context.Context, info proof.WinningPoStVerifyInfo) (bool, error) {
+	return true, nil
+}
+
+func (m mockVerif) VerifyWindowPoSt(ctx context.Context, info proof.WindowPoStVerifyInfo) (bool, error) {
+	if len(info.Proofs) != 1 {
+		return false, xerrors.Errorf("expected 1 proof entry")
+	}
+
+	proof := info.Proofs[0]
+
+	expected := generateFakePoStProof(info.ChallengedSectors, info.Randomness)
+	if !bytes.Equal(proof.ProofBytes, expected) {
+		return false, xerrors.Errorf("bad proof")
+	}
+	return true, nil
+}
+
+func (m mockVerif) GenerateDataCommitment(pt abi.RegisteredSealProof, pieces []abi.PieceInfo) (cid.Cid, error) {
+	return ffiwrapper.GenerateUnsealedCID(pt, pieces)
+}
+
+func (m mockVerif) GenerateWinningPoStSectorChallenge(ctx context.Context, proofType abi.RegisteredPoStProof, minerID abi.ActorID, randomness abi.PoStRandomness, eligibleSectorCount uint64) ([]uint64, error) {
+	return []uint64{0}, nil
+}
+
+var MockVerifier = mockVerif{}
+
+var _ storage.Sealer = &SectorMgr{}
+var _ ffiwrapper.Verifier = MockVerifier
diff --git a/extern/sector-storage/mock/mock_test.go b/extern/sector-storage/mock/mock_test.go
new file mode 100644
index 000000000..47c060f66
--- /dev/null
+++ b/extern/sector-storage/mock/mock_test.go
@@ -0,0 +1,45 @@
+package mock
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/filecoin-project/go-state-types/abi"
+)
+
+func TestOpFinish(t *testing.T) {
+	sb := NewMockSectorMgr(2048, nil)
+
+	sid, pieces, err := sb.StageFakeData(123)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	ctx, done := AddOpFinish(context.TODO())
+
+	finished := make(chan struct{})
+	go func() {
+		_, err := sb.SealPreCommit1(ctx, sid, abi.SealRandomness{}, pieces)
+		if err != nil {
+			t.Error(err)
+			return
+		}
+
+		close(finished)
+	}()
+
+	select {
+	case <-finished:
+		t.Fatal("should not finish until we tell it to")
+	case <-time.After(time.Second / 2):
+	}
+
+	done()
+
+	select {
+	case <-finished:
+	case <-time.After(time.Second / 2):
+		t.Fatal("should finish after we tell it to")
+	}
+}
diff --git a/extern/sector-storage/mock/util.go b/extern/sector-storage/mock/util.go
new file mode 100644
index 000000000..2d2ebbfe2
--- /dev/null
+++ b/extern/sector-storage/mock/util.go
@@ -0,0 +1,9 @@
+package mock
+
+func CommDR(in []byte) (out [32]byte) {
+	for i, b := range in {
+		out[i] = ^b
+	}
+
+	return out
+}
diff --git a/extern/sector-storage/request_queue.go b/extern/sector-storage/request_queue.go
new file mode 100644
index 000000000..9247ce24a
--- /dev/null
+++ b/extern/sector-storage/request_queue.go
@@ -0,0 +1,50 @@
+package sectorstorage
+
+import "sort"
+
+type requestQueue []*workerRequest
+
+func (q requestQueue) Len() int { return len(q) }
+
+func (q requestQueue) Less(i, j int) bool {
+	oneMuchLess, muchLess := q[i].taskType.MuchLess(q[j].taskType)
+	if oneMuchLess {
+		return muchLess
+	}
+
+	if q[i].priority != q[j].priority {
+		return q[i].priority > q[j].priority
+	}
+
+	if q[i].taskType != q[j].taskType {
+		return q[i].taskType.Less(q[j].taskType)
+	}
+
+	return q[i].sector.Number < q[j].sector.Number // optimize minerActor.NewSectors bitfield
+}
+
+func (q requestQueue) Swap(i, j int) {
+	q[i], q[j] = q[j], q[i]
+	q[i].index = i
+	q[j].index = j
+}
+
+func (q *requestQueue) Push(x *workerRequest) {
+	n := len(*q)
+	item := x
+	item.index = n
+	*q = append(*q, item)
+	sort.Sort(q)
+}
+
+func (q *requestQueue) Remove(i int) *workerRequest {
+	old := *q
+	n := len(old)
+	item := old[i]
+	old[i] = old[n-1]
+	old[n-1] = nil
+	item.index = -1
+	*q = old[0 : n-1]
+	sort.Sort(q)
+	return item
+}
diff --git a/extern/sector-storage/request_queue_test.go b/extern/sector-storage/request_queue_test.go
new file mode 100644
index 000000000..ed802f30a
--- /dev/null
+++ b/extern/sector-storage/request_queue_test.go
@@ -0,0 +1,62 @@
+package sectorstorage
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/filecoin-project/lotus/extern/sector-storage/sealtasks"
+)
+
+func TestRequestQueue(t *testing.T) {
+	rq := &requestQueue{}
+
+	rq.Push(&workerRequest{taskType: sealtasks.TTAddPiece})
+	rq.Push(&workerRequest{taskType: sealtasks.TTPreCommit1})
+	rq.Push(&workerRequest{taskType: sealtasks.TTPreCommit2})
+	rq.Push(&workerRequest{taskType: sealtasks.TTPreCommit1})
+	rq.Push(&workerRequest{taskType: sealtasks.TTAddPiece})
+
+	dump := func(s string) {
+		fmt.Println("---")
+		fmt.Println(s)
+
+		for sqi := 0; sqi < rq.Len(); sqi++ {
+			task := (*rq)[sqi]
+			fmt.Println(sqi, task.taskType)
+		}
+	}
+
+	dump("start")
+
+	pt := rq.Remove(0)
+
+	dump("pop 1")
+
+	if pt.taskType != sealtasks.TTPreCommit2 {
+		t.Error("expected precommit2, got", pt.taskType)
+	}
+
+	pt = rq.Remove(0)
+
+	dump("pop 2")
+
+	if pt.taskType != sealtasks.TTPreCommit1 {
+		t.Error("expected precommit1, got", pt.taskType)
+	}
+
+	pt = rq.Remove(1)
+
+	dump("pop 3")
+
+	if pt.taskType != sealtasks.TTAddPiece {
+		t.Error("expected addpiece, got", pt.taskType)
+	}
+
+	pt = rq.Remove(0)
+
+	dump("pop 4")
+
+	if pt.taskType != sealtasks.TTPreCommit1 {
+		t.Error("expected precommit1, got", pt.taskType)
+	}
+}
diff --git a/extern/sector-storage/resources.go b/extern/sector-storage/resources.go
new file mode 100644
index 000000000..28ab47e6f
--- /dev/null
+++ b/extern/sector-storage/resources.go
@@ -0,0 +1,293 @@
+package sectorstorage
+
+import (
+	"github.com/filecoin-project/go-state-types/abi"
+
+	"github.com/filecoin-project/lotus/extern/sector-storage/sealtasks"
+)
+
+type Resources struct {
+	MinMemory uint64 // What Must be in RAM for decent perf
+	MaxMemory uint64 // Memory required (swap + ram)
+
+	Threads int // -1 = multithread
+	CanGPU  bool
+
+	BaseMinMemory uint64 // What Must be in RAM for decent perf (shared between threads)
+}
+
+func (r Resources) MultiThread() bool {
+	return r.Threads == -1
+}
+
+var ResourceTable = map[sealtasks.TaskType]map[abi.RegisteredSealProof]Resources{
+	sealtasks.TTAddPiece: {
+		abi.RegisteredSealProof_StackedDrg64GiBV1: Resources{
+			MaxMemory: 8 << 30,
+			MinMemory: 8 << 30,
+
+			Threads: 1,
+
+			BaseMinMemory: 1 << 30,
+		},
+		abi.RegisteredSealProof_StackedDrg32GiBV1: Resources{
+			MaxMemory: 4 << 30,
+			MinMemory: 4 << 30,
+
+			Threads: 1,
+
+			BaseMinMemory: 1 << 30,
+		},
+		abi.RegisteredSealProof_StackedDrg512MiBV1: Resources{
+			MaxMemory: 1 << 30,
+			MinMemory: 1 << 30,
+
+			Threads: 1,
+
+			BaseMinMemory: 1 << 30,
+		},
+		abi.RegisteredSealProof_StackedDrg2KiBV1: Resources{
+			MaxMemory: 2 << 10,
+			MinMemory: 2 << 10,
+
+			Threads: 1,
+
+			BaseMinMemory: 2 << 10,
+		},
+		abi.RegisteredSealProof_StackedDrg8MiBV1: Resources{
+			MaxMemory: 8 << 20,
+			MinMemory: 8 << 20,
+
+			Threads: 1,
+
+			BaseMinMemory: 8 << 20,
+		},
+	},
+	sealtasks.TTPreCommit1: {
+		abi.RegisteredSealProof_StackedDrg64GiBV1: Resources{
+			MaxMemory: 128 << 30,
+			MinMemory: 112 << 30,
+
+			Threads: 1,
+
+			BaseMinMemory: 10 << 20,
+		},
+		abi.RegisteredSealProof_StackedDrg32GiBV1: Resources{
+			MaxMemory: 64 << 30,
+			MinMemory: 56 << 30,
+
+			Threads: 1,
+
+			BaseMinMemory: 10 << 20,
+		},
+		abi.RegisteredSealProof_StackedDrg512MiBV1: Resources{
+			MaxMemory: 1 << 30,
+			MinMemory: 768 << 20,
+
+			Threads: 1,
+
+			BaseMinMemory: 1 << 20,
+		},
+		abi.RegisteredSealProof_StackedDrg2KiBV1: Resources{
+			MaxMemory: 2 << 10,
+			MinMemory: 2 << 10,
+
+			Threads: 1,
+
+			BaseMinMemory: 2 << 10,
+		},
+		abi.RegisteredSealProof_StackedDrg8MiBV1: Resources{
+			MaxMemory: 8 << 20,
+			MinMemory: 8 << 20,
+
+			Threads: 1,
+
+			BaseMinMemory: 8 << 20,
+		},
+	},
+	sealtasks.TTPreCommit2: {
+		abi.RegisteredSealProof_StackedDrg64GiBV1: Resources{
+			MaxMemory: 64 << 30,
+			MinMemory: 64 << 30,
+
+			Threads: -1,
+			CanGPU:  true,
+
+			BaseMinMemory: 60 << 30,
+		},
+		abi.RegisteredSealProof_StackedDrg32GiBV1: Resources{
+			MaxMemory: 32 << 30,
+			MinMemory: 32 << 30,
+
+			Threads: -1,
+			CanGPU:  true,
+
+			BaseMinMemory: 30 << 30,
+		},
+		abi.RegisteredSealProof_StackedDrg512MiBV1: Resources{
+			MaxMemory: 3 << 29, // 1.5G
+			MinMemory: 1 << 30,
+
+			Threads: -1,
+
+			BaseMinMemory: 1 << 30,
+		},
+		abi.RegisteredSealProof_StackedDrg2KiBV1: Resources{
+			MaxMemory: 2 << 10,
+			MinMemory: 2 << 10,
+
+			Threads: -1,
+
+			BaseMinMemory: 2 << 10,
+		},
+		abi.RegisteredSealProof_StackedDrg8MiBV1: Resources{
+			MaxMemory: 8 << 20,
+			MinMemory: 8 << 20,
+
+			Threads: -1,
+
+			BaseMinMemory: 8 << 20,
+		},
+	},
+	sealtasks.TTCommit1: { // Very short (~100ms), so params are very light
+		abi.RegisteredSealProof_StackedDrg64GiBV1: Resources{
+			MaxMemory: 1 << 30,
+			MinMemory: 1 << 30,
+
+			Threads: 0,
+
+			BaseMinMemory: 1 << 30,
+		},
+		abi.RegisteredSealProof_StackedDrg32GiBV1: Resources{
+			MaxMemory: 1 << 30,
+			MinMemory: 1 << 30,
+
+			Threads: 0,
+
+			BaseMinMemory: 1 << 30,
+		},
+		abi.RegisteredSealProof_StackedDrg512MiBV1: Resources{
+			MaxMemory: 1 << 30,
+			MinMemory: 1 << 30,
+
+			Threads: 0,
+
+			BaseMinMemory: 1 << 30,
+		},
+		abi.RegisteredSealProof_StackedDrg2KiBV1: Resources{
+			MaxMemory: 2 << 10,
+			MinMemory: 2 << 10,
+
+			Threads: 0,
+
+			BaseMinMemory: 2 << 10,
+		},
+		abi.RegisteredSealProof_StackedDrg8MiBV1: Resources{
+			MaxMemory: 8 << 20,
+			MinMemory: 8 << 20,
+
+			Threads: 0,
+
+			BaseMinMemory: 8 << 20,
+		},
+	},
+	sealtasks.TTCommit2: {
+		abi.RegisteredSealProof_StackedDrg64GiBV1: Resources{
+			MaxMemory: 190 << 30, // TODO: Confirm
+			MinMemory: 60 << 30,
+
+			Threads: -1,
+			CanGPU:  true,
+
+			BaseMinMemory: 64 << 30, // params
+		},
+		abi.RegisteredSealProof_StackedDrg32GiBV1: Resources{
+			MaxMemory: 150 << 30, // TODO: ~30G of this should really be BaseMaxMemory
+			MinMemory: 30 << 30,
+
+			Threads: -1,
+			CanGPU:  true,
+
+			BaseMinMemory: 32 << 30, // params
+		},
+		abi.RegisteredSealProof_StackedDrg512MiBV1: Resources{
+			MaxMemory: 3 << 29, // 1.5G
+			MinMemory: 1 << 30,
+
+			Threads: 1, // This is fine
+			CanGPU:  true,
+
+			BaseMinMemory: 10 << 30,
+		},
+		abi.RegisteredSealProof_StackedDrg2KiBV1: Resources{
+			MaxMemory: 2 << 10,
+			MinMemory: 2 << 10,
+
+			Threads: 1,
+			CanGPU:  true,
+
+			BaseMinMemory: 2 << 10,
+		},
+		abi.RegisteredSealProof_StackedDrg8MiBV1: Resources{
+			MaxMemory: 8 << 20,
+			MinMemory: 8 << 20,
+
+			Threads: 1,
+			CanGPU:  true,
+
+			BaseMinMemory: 8 << 20,
+		},
+	},
+	sealtasks.TTFetch: {
+		abi.RegisteredSealProof_StackedDrg64GiBV1: Resources{
+			MaxMemory: 1 << 20,
+			MinMemory: 1 << 20,
+
+			Threads: 0,
+			CanGPU:  false,
+
+			BaseMinMemory: 0,
+		},
+		abi.RegisteredSealProof_StackedDrg32GiBV1: Resources{
+			MaxMemory: 1 << 20,
+			MinMemory: 1 << 20,
+
+			Threads: 0,
+			CanGPU:  false,
+
+			BaseMinMemory: 0,
+		},
+		abi.RegisteredSealProof_StackedDrg512MiBV1: Resources{
+			MaxMemory: 1 << 20,
+			MinMemory: 1 << 20,
+
+			Threads: 0,
+			CanGPU:  false,
+
+			BaseMinMemory: 0,
+		},
+		abi.RegisteredSealProof_StackedDrg2KiBV1: Resources{
+			MaxMemory: 1 << 20,
+			MinMemory: 1 << 20,
+
+			Threads: 0,
+			CanGPU:  false,
+
+			BaseMinMemory: 0,
+		},
+		abi.RegisteredSealProof_StackedDrg8MiBV1: Resources{
+			MaxMemory: 1 << 20,
+			MinMemory: 1 << 20,
+
+			Threads: 0,
+			CanGPU:  false,
+
+			BaseMinMemory: 0,
+		},
+	},
+}
+
+func init() {
+	ResourceTable[sealtasks.TTUnseal] = ResourceTable[sealtasks.TTPreCommit1] // TODO: measure accurately
+	ResourceTable[sealtasks.TTReadUnsealed] = ResourceTable[sealtasks.TTFetch]
+}
diff --git a/extern/sector-storage/roprov.go b/extern/sector-storage/roprov.go
new file mode 100644
index 000000000..2b009c63b
--- /dev/null
+++ b/extern/sector-storage/roprov.go
@@ -0,0 +1,40 @@
+package sectorstorage
+
+import (
+	"context"
+
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-state-types/abi"
+
+	"github.com/filecoin-project/lotus/extern/sector-storage/stores"
+)
+
+type readonlyProvider struct {
+	index stores.SectorIndex
+	stor  *stores.Local
+	spt   abi.RegisteredSealProof
+}
+
+func (l *readonlyProvider) AcquireSector(ctx context.Context, id abi.SectorID, existing stores.SectorFileType, allocate stores.SectorFileType, sealing stores.PathType) (stores.SectorPaths, func(), error) {
+	if allocate != stores.FTNone {
+		return stores.SectorPaths{}, nil, xerrors.New("read-only storage")
+	}
+
+	ctx, cancel := context.WithCancel(ctx)
+
+	// use TryLock to avoid blocking
+	locked, err := l.index.StorageTryLock(ctx, id, existing, stores.FTNone)
+	if err != nil {
+		cancel()
+		return stores.SectorPaths{}, nil, xerrors.Errorf("acquiring sector lock: %w", err)
+	}
+	if !locked {
+		cancel()
+		return stores.SectorPaths{}, nil, xerrors.Errorf("failed to acquire sector lock")
+	}
+
+	p, _, err := l.stor.AcquireSector(ctx, id, l.spt, existing, allocate, sealing, stores.AcquireMove)
+
+	return p, cancel, err
+}
diff --git a/extern/sector-storage/sched.go b/extern/sector-storage/sched.go
new file mode 100644
index 000000000..8b8ef6d46
--- /dev/null
+++ b/extern/sector-storage/sched.go
@@ -0,0 +1,845 @@
+package sectorstorage
+
+import (
+	"context"
+	"fmt"
+	"math/rand"
+	"sort"
+	"sync"
+	"time"
+
+	"golang.org/x/xerrors"
+
+	"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/storiface"
+)
+
+type schedPrioCtxKey int
+
+var SchedPriorityKey schedPrioCtxKey
+var DefaultSchedPriority = 0
+var SelectorTimeout = 5 * time.Second
+var InitWait = 3 * time.Second
+
+var (
+	SchedWindows = 2
+)
+
+func getPriority(ctx context.Context) int {
+	sp := ctx.Value(SchedPriorityKey)
+	if p, ok := sp.(int); ok {
+		return p
+	}
+
+	return DefaultSchedPriority
+}
+
+func WithPriority(ctx context.Context, priority int) context.Context {
+	return context.WithValue(ctx, SchedPriorityKey, priority)
+}
+
+const mib = 1 << 20
+
+type WorkerAction func(ctx context.Context, w Worker) error
+
+type WorkerSelector interface {
+	Ok(ctx context.Context, task sealtasks.TaskType, spt abi.RegisteredSealProof, a *workerHandle) (bool, error) // true if worker is acceptable for performing a task
+
+	Cmp(ctx context.Context, task sealtasks.TaskType, a, b *workerHandle) (bool, error) // true if a is preferred over b
+}
+
+type scheduler struct {
+	spt abi.RegisteredSealProof
+
+	workersLk  sync.RWMutex
+	nextWorker WorkerID
+	workers    map[WorkerID]*workerHandle
+
+	newWorkers chan *workerHandle
+
+	watchClosing  chan WorkerID
+	workerClosing chan WorkerID
+
+	schedule       chan *workerRequest
+	windowRequests chan *schedWindowRequest
+
+	// owned by the sh.runSched goroutine
+	schedQueue  *requestQueue
+	openWindows []*schedWindowRequest
+
+	info chan func(interface{})
+
+	closing  chan struct{}
+	closed   chan struct{}
+	testSync chan struct{} // used for testing
+}
+
+type workerHandle struct {
+	w Worker
+
+	info storiface.WorkerInfo
+
+	preparing *activeResources
+	active    *activeResources
+
+	lk sync.Mutex
+
+	wndLk         sync.Mutex
+	activeWindows []*schedWindow
+
+	// stats / tracking
+	wt *workTracker
+
+	// for sync manager goroutine closing
+	cleanupStarted bool
+	closedMgr      chan struct{}
+	closingMgr     chan struct{}
+}
+
+type schedWindowRequest struct {
+	worker WorkerID
+
+	done chan *schedWindow
+}
+
+type schedWindow struct {
+	allocated activeResources
+	todo      []*workerRequest
+}
+
+type activeResources struct {
+	memUsedMin uint64
+	memUsedMax uint64
+	gpuUsed    bool
+	cpuUse     uint64
+
+	cond *sync.Cond
+}
+
+type workerRequest struct {
+	sector   abi.SectorID
+	taskType sealtasks.TaskType
+	priority int // larger values more important
+	sel      WorkerSelector
+
+	prepare WorkerAction
+	work    WorkerAction
+
+	start time.Time
+
+	index int // The index of the item in the heap.
+
+	indexHeap int
+	ret       chan<- workerResponse
+	ctx       context.Context
+}
+
+type workerResponse struct {
+	err error
+}
+
+func newScheduler(spt abi.RegisteredSealProof) *scheduler {
+	return &scheduler{
+		spt: spt,
+
+		nextWorker: 0,
+		workers:    map[WorkerID]*workerHandle{},
+
+		newWorkers: make(chan *workerHandle),
+
+		watchClosing:  make(chan WorkerID),
+		workerClosing: make(chan WorkerID),
+
+		schedule:       make(chan *workerRequest),
+		windowRequests: make(chan *schedWindowRequest, 20),
+
+		schedQueue: &requestQueue{},
+
+		info: make(chan func(interface{})),
+
+		closing: make(chan struct{}),
+		closed:  make(chan struct{}),
+	}
+}
+
+func (sh *scheduler) Schedule(ctx context.Context, sector abi.SectorID, taskType sealtasks.TaskType, sel WorkerSelector, prepare WorkerAction, work WorkerAction) error {
+	ret := make(chan workerResponse)
+
+	select {
+	case sh.schedule <- &workerRequest{
+		sector:   sector,
+		taskType: taskType,
+		priority: getPriority(ctx),
+		sel:      sel,
+
+		prepare: prepare,
+		work:    work,
+
+		start: time.Now(),
+
+		ret: ret,
+		ctx: ctx,
+	}:
+	case <-sh.closing:
+		return xerrors.New("closing")
+	case <-ctx.Done():
+		return ctx.Err()
+	}
+
+	select {
+	case resp := <-ret:
+		return resp.err
+	case <-sh.closing:
+		return xerrors.New("closing")
+	case <-ctx.Done():
+		return ctx.Err()
+	}
+}
+
+func (r *workerRequest) respond(err error) {
+	select {
+	case r.ret <- workerResponse{err: err}:
+	case <-r.ctx.Done():
+		log.Warnf("request got cancelled before we could respond")
+	}
+}
+
+type SchedDiagRequestInfo struct {
+	Sector   abi.SectorID
+	TaskType sealtasks.TaskType
+	Priority int
+}
+
+type SchedDiagInfo struct {
+	Requests    []SchedDiagRequestInfo
+	OpenWindows []WorkerID
+}
+
+func (sh *scheduler) runSched() {
+	defer close(sh.closed)
+
+	go sh.runWorkerWatcher()
+
+	iw := time.After(InitWait)
+	var initialised bool
+
+	for {
+		var doSched bool
+
+		select {
+		case w := <-sh.newWorkers:
+			sh.newWorker(w)
+
+		case wid := <-sh.workerClosing:
+			sh.dropWorker(wid)
+
+		case req := <-sh.schedule:
+			sh.schedQueue.Push(req)
+			doSched = true
+
+			if sh.testSync != nil {
+				sh.testSync <- struct{}{}
+			}
+		case req := <-sh.windowRequests:
+			sh.openWindows = append(sh.openWindows, req)
+			doSched = true
+		case ireq := <-sh.info:
+			ireq(sh.diag())
+
+		case <-iw:
+			initialised = true
+			iw = nil
+			doSched = true
+		case <-sh.closing:
+			sh.schedClose()
+			return
+		}
+
+		if doSched && initialised {
+			// First gather any pending tasks, so we go through the scheduling loop
+			// once for every added task
+		loop:
+			for {
+				select {
+				case req := <-sh.schedule:
+					sh.schedQueue.Push(req)
+					if sh.testSync != nil {
+						sh.testSync <- struct{}{}
+					}
+				case req := <-sh.windowRequests:
+					sh.openWindows = append(sh.openWindows, req)
+				default:
+					break loop
+				}
+			}
+
+			sh.trySched()
+		}
+
+	}
+}
+
+func (sh *scheduler) diag() SchedDiagInfo {
+	var out SchedDiagInfo
+
+	for sqi := 0; sqi < sh.schedQueue.Len(); sqi++ {
+		task := (*sh.schedQueue)[sqi]
+
+		out.Requests = append(out.Requests, SchedDiagRequestInfo{
+			Sector:   task.sector,
+			TaskType: task.taskType,
+			Priority: task.priority,
+		})
+	}
+
+	for _, window := range sh.openWindows {
+		out.OpenWindows = append(out.OpenWindows, window.worker)
+	}
+
+	return out
+}
+
+func (sh *scheduler) trySched() {
+	/*
+		This assigns tasks to workers based on:
+		- Task priority (achieved by handling sh.schedQueue in order, since it's already sorted by priority)
+		- Worker resource availability
+		- Task-specified worker preference (acceptableWindows array below sorted by this preference)
+		- Window request age
+
+		1. For each task in the schedQueue find windows which can handle them
+		1.1. Create list of windows capable of handling a task
+		1.2. Sort windows according to task selector preferences
+		2. Going through schedQueue again, assign task to first acceptable window
+		   with resources available
+		3. Submit windows with scheduled tasks to workers
+
+	*/
+
+	windows := make([]schedWindow, len(sh.openWindows))
+	acceptableWindows := make([][]int, sh.schedQueue.Len())
+
+	log.Debugf("SCHED %d queued; %d open windows", sh.schedQueue.Len(), len(windows))
+
+	sh.workersLk.RLock()
+	defer sh.workersLk.RUnlock()
+	if len(sh.openWindows) == 0 {
+		// nothing to schedule on
+		return
+	}
+
+	// Step 1
+	concurrency := len(sh.openWindows)
+	throttle := make(chan struct{}, concurrency)
+
+	var wg sync.WaitGroup
+	wg.Add(sh.schedQueue.Len())
+
+	for i := 0; i < sh.schedQueue.Len(); i++ {
+		throttle <- struct{}{}
+
+		go func(sqi int) {
+			defer wg.Done()
+			defer func() {
+				<-throttle
+			}()
+
+			task := (*sh.schedQueue)[sqi]
+			needRes := ResourceTable[task.taskType][sh.spt]
+
+			task.indexHeap = sqi
+			for wnd, windowRequest := range sh.openWindows {
+				worker, ok := sh.workers[windowRequest.worker]
+				if !ok {
+					log.Errorf("worker referenced by windowRequest not found (worker: %d)", windowRequest.worker)
+					// TODO: How to move forward here?
+					continue
+				}
+
+				// TODO: allow bigger windows
+				if !windows[wnd].allocated.canHandleRequest(needRes, windowRequest.worker, "schedAcceptable", worker.info.Resources) {
+					continue
+				}
+
+				rpcCtx, cancel := context.WithTimeout(task.ctx, SelectorTimeout)
+				ok, err := task.sel.Ok(rpcCtx, task.taskType, sh.spt, worker)
+				cancel()
+				if err != nil {
+					log.Errorf("trySched(1) req.sel.Ok error: %+v", err)
+					continue
+				}
+
+				if !ok {
+					continue
+				}
+
+				acceptableWindows[sqi] = append(acceptableWindows[sqi], wnd)
+			}
+
+			if len(acceptableWindows[sqi]) == 0 {
+				return
+			}
+
+			// Pick best worker (shuffle in case some workers are equally as good)
+			rand.Shuffle(len(acceptableWindows[sqi]), func(i, j int) {
+				acceptableWindows[sqi][i], acceptableWindows[sqi][j] = acceptableWindows[sqi][j], acceptableWindows[sqi][i] // nolint:scopelint
+			})
+			sort.SliceStable(acceptableWindows[sqi], func(i, j int) bool {
+				wii := sh.openWindows[acceptableWindows[sqi][i]].worker // nolint:scopelint
+				wji := sh.openWindows[acceptableWindows[sqi][j]].worker // nolint:scopelint
+
+				if wii == wji {
+					// for the same worker prefer older windows
+					return acceptableWindows[sqi][i] < acceptableWindows[sqi][j] // nolint:scopelint
+				}
+
+				wi := sh.workers[wii]
+				wj := sh.workers[wji]
+
+				rpcCtx, cancel := context.WithTimeout(task.ctx, SelectorTimeout)
+				defer cancel()
+
+				r, err := task.sel.Cmp(rpcCtx, task.taskType, wi, wj)
+				if err != nil {
+					log.Error("selecting best worker: %s", err)
+				}
+				return r
+			})
+		}(i)
+	}
+
+	wg.Wait()
+
+	log.Debugf("SCHED windows: %+v", windows)
+	log.Debugf("SCHED Acceptable win: %+v", acceptableWindows)
+
+	// Step 2
+	scheduled := 0
+
+	for sqi := 0; sqi < sh.schedQueue.Len(); sqi++ {
+		task := (*sh.schedQueue)[sqi]
+		needRes := ResourceTable[task.taskType][sh.spt]
+
+		selectedWindow := -1
+		for _, wnd := range acceptableWindows[task.indexHeap] {
+			wid := sh.openWindows[wnd].worker
+			wr := sh.workers[wid].info.Resources
+
+			log.Debugf("SCHED try assign sqi:%d sector %d to window %d", sqi, task.sector.Number, wnd)
+
+			// TODO: allow bigger windows
+			if !windows[wnd].allocated.canHandleRequest(needRes, wid, "schedAssign", wr) {
+				continue
+			}
+
+			log.Debugf("SCHED ASSIGNED sqi:%d sector %d task %s to window %d", sqi, task.sector.Number, task.taskType, wnd)
+
+			windows[wnd].allocated.add(wr, needRes)
+			// TODO: We probably want to re-sort acceptableWindows here based on new
+			//  workerHandle.utilization + windows[wnd].allocated.utilization (workerHandle.utilization is used in all
+			//  task selectors, but not in the same way, so need to figure out how to do that in a non-O(n^2 way), and
+			//  without additional network roundtrips (O(n^2) could be avoided by turning acceptableWindows.[] into heaps))
+
+			selectedWindow = wnd
+			break
+		}
+
+		if selectedWindow < 0 {
+			// all windows full
+			continue
+		}
+
+		windows[selectedWindow].todo = append(windows[selectedWindow].todo, task)
+
+		sh.schedQueue.Remove(sqi)
+		sqi--
+		scheduled++
+	}
+
+	// Step 3
+
+	if scheduled == 0 {
+		return
+	}
+
+	scheduledWindows := map[int]struct{}{}
+	for wnd, window := range windows {
+		if len(window.todo) == 0 {
+			// Nothing scheduled here, keep the window open
+			continue
+		}
+
+		scheduledWindows[wnd] = struct{}{}
+
+		window := window // copy
+		select {
+		case sh.openWindows[wnd].done <- &window:
+		default:
+			log.Error("expected sh.openWindows[wnd].done to be buffered")
+		}
+	}
+
+	// Rewrite sh.openWindows array, removing scheduled windows
+	newOpenWindows := make([]*schedWindowRequest, 0, len(sh.openWindows)-len(scheduledWindows))
+	for wnd, window := range sh.openWindows {
+		if _, scheduled := scheduledWindows[wnd]; scheduled {
+			// keep unscheduled windows open
+			continue
+		}
+
+		newOpenWindows = append(newOpenWindows, window)
+	}
+
+	sh.openWindows = newOpenWindows
+}
+
+func (sh *scheduler) runWorker(wid WorkerID) {
+	var ready sync.WaitGroup
+	ready.Add(1)
+	defer ready.Wait()
+
+	go func() {
+		sh.workersLk.RLock()
+		worker, found := sh.workers[wid]
+		sh.workersLk.RUnlock()
+
+		ready.Done()
+
+		if !found {
+			panic(fmt.Sprintf("worker %d not found", wid))
+		}
+
+		defer close(worker.closedMgr)
+
+		scheduledWindows := make(chan *schedWindow, SchedWindows)
+		taskDone := make(chan struct{}, 1)
+		windowsRequested := 0
+
+		ctx, cancel := context.WithCancel(context.TODO())
+		defer cancel()
+
+		workerClosing, err := worker.w.Closing(ctx)
+		if err != nil {
+			return
+		}
+
+		defer func() {
+			log.Warnw("Worker closing", "workerid", wid)
+
+			// TODO: close / return all queued tasks
+		}()
+
+		for {
+			// ask for more windows if we need them
+			for ; windowsRequested < SchedWindows; windowsRequested++ {
+				select {
+				case sh.windowRequests <- &schedWindowRequest{
+					worker: wid,
+					done:   scheduledWindows,
+				}:
+				case <-sh.closing:
+					return
+				case <-workerClosing:
+					return
+				case <-worker.closingMgr:
+					return
+				}
+			}
+
+			select {
+			case w := <-scheduledWindows:
+				worker.wndLk.Lock()
+				worker.activeWindows = append(worker.activeWindows, w)
+				worker.wndLk.Unlock()
+			case <-taskDone:
+				log.Debugw("task done", "workerid", wid)
+			case <-sh.closing:
+				return
+			case <-workerClosing:
+				return
+			case <-worker.closingMgr:
+				return
+			}
+
+			sh.workersLk.RLock()
+			worker.wndLk.Lock()
+
+			windowsRequested -= sh.workerCompactWindows(worker, wid)
+
+		assignLoop:
+			// process windows in order
+			for len(worker.activeWindows) > 0 {
+				firstWindow := worker.activeWindows[0]
+
+				// process tasks within a window, preferring tasks at lower indexes
+				for len(firstWindow.todo) > 0 {
+					tidx := -1
+
+					worker.lk.Lock()
+					for t, todo := range firstWindow.todo {
+						needRes := ResourceTable[todo.taskType][sh.spt]
+						if worker.preparing.canHandleRequest(needRes, wid, "startPreparing", worker.info.Resources) {
+							tidx = t
+							break
+						}
+					}
+					worker.lk.Unlock()
+
+					if tidx == -1 {
+						break assignLoop
+					}
+
+					todo := firstWindow.todo[tidx]
+
+					log.Debugf("assign worker sector %d", todo.sector.Number)
+					err := sh.assignWorker(taskDone, wid, worker, todo)
+
+					if err != nil {
+						log.Error("assignWorker error: %+v", err)
+						go todo.respond(xerrors.Errorf("assignWorker error: %w", err))
+					}
+
+					// Note: we're not freeing window.allocated resources here very much on purpose
+					copy(firstWindow.todo[tidx:], firstWindow.todo[tidx+1:])
+					firstWindow.todo[len(firstWindow.todo)-1] = nil
+					firstWindow.todo = firstWindow.todo[:len(firstWindow.todo)-1]
+				}
+
+				copy(worker.activeWindows, worker.activeWindows[1:])
+				worker.activeWindows[len(worker.activeWindows)-1] = nil
+				worker.activeWindows = worker.activeWindows[:len(worker.activeWindows)-1]
+
+				windowsRequested--
+			}
+
+			worker.wndLk.Unlock()
+			sh.workersLk.RUnlock()
+		}
+	}()
+}
+
+func (sh *scheduler) workerCompactWindows(worker *workerHandle, wid WorkerID) int {
+	// move tasks from older windows to newer windows if older windows
+	// still can fit them
+	if len(worker.activeWindows) > 1 {
+		for wi, window := range worker.activeWindows[1:] {
+			lower := worker.activeWindows[wi]
+			var moved []int
+
+			for ti, todo := range window.todo {
+				needRes := ResourceTable[todo.taskType][sh.spt]
+				if !lower.allocated.canHandleRequest(needRes, wid, "compactWindows", worker.info.Resources) {
+					continue
+				}
+
+				moved = append(moved, ti)
+				lower.todo = append(lower.todo, todo)
+				lower.allocated.add(worker.info.Resources, needRes)
+				window.allocated.free(worker.info.Resources, needRes)
+			}
+
+			if len(moved) > 0 {
+				newTodo := make([]*workerRequest, 0, len(window.todo)-len(moved))
+				for i, t := range window.todo {
+					if len(moved) > 0 && moved[0] == i {
+						moved = moved[1:]
+						continue
+					}
+
+					newTodo = append(newTodo, t)
+				}
+				window.todo = newTodo
+			}
+		}
+	}
+
+	var compacted int
+	var newWindows []*schedWindow
+
+	for _, window := range worker.activeWindows {
+		if len(window.todo) == 0 {
+			compacted++
+			continue
+		}
+
+		newWindows = append(newWindows, window)
+	}
+
+	worker.activeWindows = newWindows
+
+	return compacted
+}
+
+func (sh *scheduler) assignWorker(taskDone chan struct{}, wid WorkerID, w *workerHandle, req *workerRequest) error {
+	needRes := ResourceTable[req.taskType][sh.spt]
+
+	w.lk.Lock()
+	w.preparing.add(w.info.Resources, needRes)
+	w.lk.Unlock()
+
+	go func() {
+		err := req.prepare(req.ctx, w.wt.worker(w.w))
+		sh.workersLk.Lock()
+
+		if err != nil {
+			w.lk.Lock()
+			w.preparing.free(w.info.Resources, needRes)
+			w.lk.Unlock()
+			sh.workersLk.Unlock()
+
+			select {
+			case taskDone <- struct{}{}:
+			case <-sh.closing:
+				log.Warnf("scheduler closed while sending response (prepare error: %+v)", err)
+			}
+
+			select {
+			case req.ret <- workerResponse{err: err}:
+			case <-req.ctx.Done():
+				log.Warnf("request got cancelled before we could respond (prepare error: %+v)", err)
+			case <-sh.closing:
+				log.Warnf("scheduler closed while sending response (prepare error: %+v)", err)
+			}
+			return
+		}
+
+		err = w.active.withResources(wid, w.info.Resources, needRes, &sh.workersLk, func() error {
+			w.lk.Lock()
+			w.preparing.free(w.info.Resources, needRes)
+			w.lk.Unlock()
+			sh.workersLk.Unlock()
+			defer sh.workersLk.Lock() // we MUST return locked from this function
+
+			select {
+			case taskDone <- struct{}{}:
+			case <-sh.closing:
+			}
+
+			err = req.work(req.ctx, w.wt.worker(w.w))
+
+			select {
+			case req.ret <- workerResponse{err: err}:
+			case <-req.ctx.Done():
+				log.Warnf("request got cancelled before we could respond")
+			case <-sh.closing:
+				log.Warnf("scheduler closed while sending response")
+			}
+
+			return nil
+		})
+
+		sh.workersLk.Unlock()
+
+		// This error should always be nil, since nothing is setting it, but just to be safe:
+		if err != nil {
+			log.Errorf("error executing worker (withResources): %+v", err)
+		}
+	}()
+
+	return nil
+}
+
+func (sh *scheduler) newWorker(w *workerHandle) {
+	w.closedMgr = make(chan struct{})
+	w.closingMgr = make(chan struct{})
+
+	sh.workersLk.Lock()
+
+	id := sh.nextWorker
+	sh.workers[id] = w
+	sh.nextWorker++
+
+	sh.workersLk.Unlock()
+
+	sh.runWorker(id)
+
+	select {
+	case sh.watchClosing <- id:
+	case <-sh.closing:
+		return
+	}
+}
+
+func (sh *scheduler) dropWorker(wid WorkerID) {
+	sh.workersLk.Lock()
+	defer sh.workersLk.Unlock()
+
+	w := sh.workers[wid]
+
+	sh.workerCleanup(wid, w)
+
+	delete(sh.workers, wid)
+}
+
+func (sh *scheduler) workerCleanup(wid WorkerID, w *workerHandle) {
+	select {
+	case <-w.closingMgr:
+	default:
+		close(w.closingMgr)
+	}
+
+	sh.workersLk.Unlock()
+	select {
+	case <-w.closedMgr:
+	case <-time.After(time.Second):
+		log.Errorf("timeout closing worker manager goroutine %d", wid)
+	}
+	sh.workersLk.Lock()
+
+	if !w.cleanupStarted {
+		w.cleanupStarted = true
+
+		newWindows := make([]*schedWindowRequest, 0, len(sh.openWindows))
+		for _, window := range sh.openWindows {
+			if window.worker != wid {
+				newWindows = append(newWindows, window)
+			}
+		}
+		sh.openWindows = newWindows
+
+		log.Debugf("dropWorker %d", wid)
+
+		go func() {
+			if err := w.w.Close(); err != nil {
+				log.Warnf("closing worker %d: %+v", err)
+			}
+		}()
+	}
+}
+
+func (sh *scheduler) schedClose() {
+	sh.workersLk.Lock()
+	defer sh.workersLk.Unlock()
+	log.Debugf("closing scheduler")
+
+	for i, w := range sh.workers {
+		sh.workerCleanup(i, w)
+	}
+}
+
+func (sh *scheduler) Info(ctx context.Context) (interface{}, error) {
+	ch := make(chan interface{}, 1)
+
+	sh.info <- func(res interface{}) {
+		ch <- res
+	}
+
+	select {
+	case res := <-ch:
+		return res, nil
+	case <-ctx.Done():
+		return nil, ctx.Err()
+	}
+}
+
+func (sh *scheduler) Close(ctx context.Context) error {
+	close(sh.closing)
+	select {
+	case <-sh.closed:
+	case <-ctx.Done():
+		return ctx.Err()
+	}
+	return nil
+}
diff --git a/extern/sector-storage/sched_resources.go b/extern/sector-storage/sched_resources.go
new file mode 100644
index 000000000..623472a20
--- /dev/null
+++ b/extern/sector-storage/sched_resources.go
@@ -0,0 +1,124 @@
+package sectorstorage
+
+import (
+	"sync"
+
+	"github.com/filecoin-project/lotus/extern/sector-storage/storiface"
+)
+
+func (a *activeResources) withResources(id WorkerID, wr storiface.WorkerResources, r Resources, locker sync.Locker, cb func() error) error {
+	for !a.canHandleRequest(r, id, "withResources", wr) {
+		if a.cond == nil {
+			a.cond = sync.NewCond(locker)
+		}
+		a.cond.Wait()
+	}
+
+	a.add(wr, r)
+
+	err := cb()
+
+	a.free(wr, r)
+	if a.cond != nil {
+		a.cond.Broadcast()
+	}
+
+	return err
+}
+
+func (a *activeResources) add(wr storiface.WorkerResources, r Resources) {
+	a.gpuUsed = r.CanGPU
+	if r.MultiThread() {
+		a.cpuUse += wr.CPUs
+	} else {
+		a.cpuUse += uint64(r.Threads)
+	}
+
+	a.memUsedMin += r.MinMemory
+	a.memUsedMax += r.MaxMemory
+}
+
+func (a *activeResources) free(wr storiface.WorkerResources, r Resources) {
+	if r.CanGPU {
+		a.gpuUsed = false
+	}
+	if r.MultiThread() {
+		a.cpuUse -= wr.CPUs
+	} else {
+		a.cpuUse -= uint64(r.Threads)
+	}
+
+	a.memUsedMin -= r.MinMemory
+	a.memUsedMax -= r.MaxMemory
+}
+
+func (a *activeResources) canHandleRequest(needRes Resources, wid WorkerID, caller string, res storiface.WorkerResources) bool {
+
+	// TODO: dedupe needRes.BaseMinMemory per task type (don't add if that task is already running)
+	minNeedMem := res.MemReserved + a.memUsedMin + needRes.MinMemory + needRes.BaseMinMemory
+	if minNeedMem > res.MemPhysical {
+		log.Debugf("sched: not scheduling on worker %d for %s; not enough physical memory - need: %dM, have %dM", wid, caller, minNeedMem/mib, res.MemPhysical/mib)
+		return false
+	}
+
+	maxNeedMem := res.MemReserved + a.memUsedMax + needRes.MaxMemory + needRes.BaseMinMemory
+
+	if maxNeedMem > res.MemSwap+res.MemPhysical {
+		log.Debugf("sched: not scheduling on worker %d for %s; not enough virtual memory - need: %dM, have %dM", wid, caller, maxNeedMem/mib, (res.MemSwap+res.MemPhysical)/mib)
+		return false
+	}
+
+	if needRes.MultiThread() {
+		if a.cpuUse > 0 {
+			log.Debugf("sched: not scheduling on worker %d for %s; multicore process needs %d threads, %d in use, target %d", wid, caller, res.CPUs, a.cpuUse, res.CPUs)
+			return false
+		}
+	} else {
+		if a.cpuUse+uint64(needRes.Threads) > res.CPUs {
+			log.Debugf("sched: not scheduling on worker %d for %s; not enough threads, need %d, %d in use, target %d", wid, caller, needRes.Threads, a.cpuUse, res.CPUs)
+			return false
+		}
+	}
+
+	if len(res.GPUs) > 0 && needRes.CanGPU {
+		if a.gpuUsed {
+			log.Debugf("sched: not scheduling on worker %d for %s; GPU in use", wid, caller)
+			return false
+		}
+	}
+
+	return true
+}
+
+func (a *activeResources) utilization(wr storiface.WorkerResources) float64 {
+	var max float64
+
+	cpu := float64(a.cpuUse) / float64(wr.CPUs)
+	max = cpu
+
+	memMin := float64(a.memUsedMin+wr.MemReserved) / float64(wr.MemPhysical)
+	if memMin > max {
+		max = memMin
+	}
+
+	memMax := float64(a.memUsedMax+wr.MemReserved) / float64(wr.MemPhysical+wr.MemSwap)
+	if memMax > max {
+		max = memMax
+	}
+
+	return max
+}
+
+func (wh *workerHandle) utilization() float64 {
+	wh.lk.Lock()
+	u := wh.active.utilization(wh.info.Resources)
+	u += wh.preparing.utilization(wh.info.Resources)
+	wh.lk.Unlock()
+	wh.wndLk.Lock()
+	for _, window := range wh.activeWindows {
+		u += window.allocated.utilization(wh.info.Resources)
+	}
+	wh.wndLk.Unlock()
+
+	return u
+}
diff --git a/extern/sector-storage/sched_test.go b/extern/sector-storage/sched_test.go
new file mode 100644
index 000000000..c560a58f6
--- /dev/null
+++ b/extern/sector-storage/sched_test.go
@@ -0,0 +1,645 @@
+package sectorstorage
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"runtime"
+	"sort"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/ipfs/go-cid"
+	logging "github.com/ipfs/go-log/v2"
+	"github.com/stretchr/testify/require"
+
+	"github.com/filecoin-project/go-state-types/abi"
+
+	"github.com/filecoin-project/lotus/extern/sector-storage/fsutil"
+	"github.com/filecoin-project/lotus/extern/sector-storage/sealtasks"
+	"github.com/filecoin-project/lotus/extern/sector-storage/stores"
+	"github.com/filecoin-project/lotus/extern/sector-storage/storiface"
+	"github.com/filecoin-project/specs-storage/storage"
+)
+
+func init() {
+	InitWait = 10 * time.Millisecond
+}
+
+func TestWithPriority(t *testing.T) {
+	ctx := context.Background()
+
+	require.Equal(t, DefaultSchedPriority, getPriority(ctx))
+
+	ctx = WithPriority(ctx, 2222)
+
+	require.Equal(t, 2222, getPriority(ctx))
+}
+
+type schedTestWorker struct {
+	name      string
+	taskTypes map[sealtasks.TaskType]struct{}
+	paths     []stores.StoragePath
+
+	closed  bool
+	closing chan struct{}
+}
+
+func (s *schedTestWorker) SealPreCommit1(ctx context.Context, sector abi.SectorID, ticket abi.SealRandomness, pieces []abi.PieceInfo) (storage.PreCommit1Out, error) {
+	panic("implement me")
+}
+
+func (s *schedTestWorker) SealPreCommit2(ctx context.Context, sector abi.SectorID, pc1o storage.PreCommit1Out) (storage.SectorCids, error) {
+	panic("implement me")
+}
+
+func (s *schedTestWorker) SealCommit1(ctx context.Context, sector abi.SectorID, ticket abi.SealRandomness, seed abi.InteractiveSealRandomness, pieces []abi.PieceInfo, cids storage.SectorCids) (storage.Commit1Out, error) {
+	panic("implement me")
+}
+
+func (s *schedTestWorker) SealCommit2(ctx context.Context, sector abi.SectorID, c1o storage.Commit1Out) (storage.Proof, error) {
+	panic("implement me")
+}
+
+func (s *schedTestWorker) FinalizeSector(ctx context.Context, sector abi.SectorID, keepUnsealed []storage.Range) error {
+	panic("implement me")
+}
+
+func (s *schedTestWorker) ReleaseUnsealed(ctx context.Context, sector abi.SectorID, safeToFree []storage.Range) error {
+	panic("implement me")
+}
+
+func (s *schedTestWorker) Remove(ctx context.Context, sector abi.SectorID) error {
+	panic("implement me")
+}
+
+func (s *schedTestWorker) NewSector(ctx context.Context, sector abi.SectorID) error {
+	panic("implement me")
+}
+
+func (s *schedTestWorker) AddPiece(ctx context.Context, sector abi.SectorID, pieceSizes []abi.UnpaddedPieceSize, newPieceSize abi.UnpaddedPieceSize, pieceData storage.Data) (abi.PieceInfo, error) {
+	panic("implement me")
+}
+
+func (s *schedTestWorker) MoveStorage(ctx context.Context, sector abi.SectorID, types stores.SectorFileType) error {
+	panic("implement me")
+}
+
+func (s *schedTestWorker) Fetch(ctx context.Context, id abi.SectorID, ft stores.SectorFileType, ptype stores.PathType, am stores.AcquireMode) error {
+	panic("implement me")
+}
+
+func (s *schedTestWorker) UnsealPiece(ctx context.Context, id abi.SectorID, index storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize, randomness abi.SealRandomness, cid cid.Cid) error {
+	panic("implement me")
+}
+
+func (s *schedTestWorker) ReadPiece(ctx context.Context, writer io.Writer, id abi.SectorID, index storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize) (bool, error) {
+	panic("implement me")
+}
+
+func (s *schedTestWorker) TaskTypes(ctx context.Context) (map[sealtasks.TaskType]struct{}, error) {
+	return s.taskTypes, nil
+}
+
+func (s *schedTestWorker) Paths(ctx context.Context) ([]stores.StoragePath, error) {
+	return s.paths, nil
+}
+
+var decentWorkerResources = storiface.WorkerResources{
+	MemPhysical: 128 << 30,
+	MemSwap:     200 << 30,
+	MemReserved: 2 << 30,
+	CPUs:        32,
+	GPUs:        []string{"a GPU"},
+}
+
+func (s *schedTestWorker) Info(ctx context.Context) (storiface.WorkerInfo, error) {
+	return storiface.WorkerInfo{
+		Hostname:  s.name,
+		Resources: decentWorkerResources,
+	}, nil
+}
+
+func (s *schedTestWorker) Closing(ctx context.Context) (<-chan struct{}, error) {
+	return s.closing, nil
+}
+
+func (s *schedTestWorker) Close() error {
+	if !s.closed {
+		log.Info("close schedTestWorker")
+		s.closed = true
+		close(s.closing)
+	}
+	return nil
+}
+
+var _ Worker = &schedTestWorker{}
+
+func addTestWorker(t *testing.T, sched *scheduler, index *stores.Index, name string, taskTypes map[sealtasks.TaskType]struct{}) {
+	w := &schedTestWorker{
+		name:      name,
+		taskTypes: taskTypes,
+		paths:     []stores.StoragePath{{ID: "bb-8", Weight: 2, LocalPath: "<octopus>food</octopus>", CanSeal: true, CanStore: true}},
+
+		closing: make(chan struct{}),
+	}
+
+	for _, path := range w.paths {
+		err := index.StorageAttach(context.TODO(), stores.StorageInfo{
+			ID:       path.ID,
+			URLs:     nil,
+			Weight:   path.Weight,
+			CanSeal:  path.CanSeal,
+			CanStore: path.CanStore,
+		}, fsutil.FsStat{
+			Capacity:  1 << 40,
+			Available: 1 << 40,
+			Reserved:  3,
+		})
+		require.NoError(t, err)
+	}
+
+	info, err := w.Info(context.TODO())
+	require.NoError(t, err)
+
+	sched.newWorkers <- &workerHandle{
+		w: w,
+		wt: &workTracker{
+			running: map[uint64]storiface.WorkerJob{},
+		},
+		info:      info,
+		preparing: &activeResources{},
+		active:    &activeResources{},
+	}
+}
+
+func TestSchedStartStop(t *testing.T) {
+	spt := abi.RegisteredSealProof_StackedDrg32GiBV1
+	sched := newScheduler(spt)
+	go sched.runSched()
+
+	addTestWorker(t, sched, stores.NewIndex(), "fred", nil)
+
+	require.NoError(t, sched.Close(context.TODO()))
+}
+
+func TestSched(t *testing.T) {
+	ctx, done := context.WithTimeout(context.Background(), 30*time.Second)
+	defer done()
+
+	spt := abi.RegisteredSealProof_StackedDrg32GiBV1
+
+	type workerSpec struct {
+		name      string
+		taskTypes map[sealtasks.TaskType]struct{}
+	}
+
+	noopAction := func(ctx context.Context, w Worker) error {
+		return nil
+	}
+
+	type runMeta struct {
+		done map[string]chan struct{}
+
+		wg sync.WaitGroup
+	}
+
+	type task func(*testing.T, *scheduler, *stores.Index, *runMeta)
+
+	sched := func(taskName, expectWorker string, sid abi.SectorNumber, taskType sealtasks.TaskType) task {
+		_, _, l, _ := runtime.Caller(1)
+		_, _, l2, _ := runtime.Caller(2)
+
+		return func(t *testing.T, sched *scheduler, index *stores.Index, rm *runMeta) {
+			done := make(chan struct{})
+			rm.done[taskName] = done
+
+			sel := newAllocSelector(index, stores.FTCache, stores.PathSealing)
+
+			rm.wg.Add(1)
+			go func() {
+				defer rm.wg.Done()
+
+				sectorNum := abi.SectorID{
+					Miner:  8,
+					Number: sid,
+				}
+
+				err := sched.Schedule(ctx, sectorNum, taskType, sel, func(ctx context.Context, w Worker) error {
+					wi, err := w.Info(ctx)
+					require.NoError(t, err)
+
+					require.Equal(t, expectWorker, wi.Hostname)
+
+					log.Info("IN  ", taskName)
+
+					for {
+						_, ok := <-done
+						if !ok {
+							break
+						}
+					}
+
+					log.Info("OUT ", taskName)
+
+					return nil
+				}, noopAction)
+				require.NoError(t, err, fmt.Sprint(l, l2))
+			}()
+
+			<-sched.testSync
+		}
+	}
+
+	taskStarted := func(name string) task {
+		_, _, l, _ := runtime.Caller(1)
+		_, _, l2, _ := runtime.Caller(2)
+		return func(t *testing.T, sched *scheduler, index *stores.Index, rm *runMeta) {
+			select {
+			case rm.done[name] <- struct{}{}:
+			case <-ctx.Done():
+				t.Fatal("ctx error", ctx.Err(), l, l2)
+			}
+		}
+	}
+
+	taskDone := func(name string) task {
+		_, _, l, _ := runtime.Caller(1)
+		_, _, l2, _ := runtime.Caller(2)
+		return func(t *testing.T, sched *scheduler, index *stores.Index, rm *runMeta) {
+			select {
+			case rm.done[name] <- struct{}{}:
+			case <-ctx.Done():
+				t.Fatal("ctx error", ctx.Err(), l, l2)
+			}
+			close(rm.done[name])
+		}
+	}
+
+	taskNotScheduled := func(name string) task {
+		_, _, l, _ := runtime.Caller(1)
+		_, _, l2, _ := runtime.Caller(2)
+		return func(t *testing.T, sched *scheduler, index *stores.Index, rm *runMeta) {
+			select {
+			case rm.done[name] <- struct{}{}:
+				t.Fatal("not expected", l, l2)
+			case <-time.After(10 * time.Millisecond): // TODO: better synchronization thingy
+			}
+		}
+	}
+
+	testFunc := func(workers []workerSpec, tasks []task) func(t *testing.T) {
+		return func(t *testing.T) {
+			index := stores.NewIndex()
+
+			sched := newScheduler(spt)
+			sched.testSync = make(chan struct{})
+
+			go sched.runSched()
+
+			for _, worker := range workers {
+				addTestWorker(t, sched, index, worker.name, worker.taskTypes)
+			}
+
+			rm := runMeta{
+				done: map[string]chan struct{}{},
+			}
+
+			for i, task := range tasks {
+				log.Info("TASK", i)
+				task(t, sched, index, &rm)
+			}
+
+			log.Info("wait for async stuff")
+			rm.wg.Wait()
+
+			require.NoError(t, sched.Close(context.TODO()))
+		}
+	}
+
+	multTask := func(tasks ...task) task {
+		return func(t *testing.T, s *scheduler, index *stores.Index, meta *runMeta) {
+			for _, tsk := range tasks {
+				tsk(t, s, index, meta)
+			}
+		}
+	}
+
+	t.Run("one-pc1", testFunc([]workerSpec{
+		{name: "fred", taskTypes: map[sealtasks.TaskType]struct{}{sealtasks.TTPreCommit1: {}}},
+	}, []task{
+		sched("pc1-1", "fred", 8, sealtasks.TTPreCommit1),
+		taskDone("pc1-1"),
+	}))
+
+	t.Run("pc1-2workers-1", testFunc([]workerSpec{
+		{name: "fred2", taskTypes: map[sealtasks.TaskType]struct{}{sealtasks.TTPreCommit2: {}}},
+		{name: "fred1", taskTypes: map[sealtasks.TaskType]struct{}{sealtasks.TTPreCommit1: {}}},
+	}, []task{
+		sched("pc1-1", "fred1", 8, sealtasks.TTPreCommit1),
+		taskDone("pc1-1"),
+	}))
+
+	t.Run("pc1-2workers-2", testFunc([]workerSpec{
+		{name: "fred1", taskTypes: map[sealtasks.TaskType]struct{}{sealtasks.TTPreCommit1: {}}},
+		{name: "fred2", taskTypes: map[sealtasks.TaskType]struct{}{sealtasks.TTPreCommit2: {}}},
+	}, []task{
+		sched("pc1-1", "fred1", 8, sealtasks.TTPreCommit1),
+		taskDone("pc1-1"),
+	}))
+
+	t.Run("pc1-block-pc2", testFunc([]workerSpec{
+		{name: "fred", taskTypes: map[sealtasks.TaskType]struct{}{sealtasks.TTPreCommit1: {}, sealtasks.TTPreCommit2: {}}},
+	}, []task{
+		sched("pc1", "fred", 8, sealtasks.TTPreCommit1),
+		taskStarted("pc1"),
+
+		sched("pc2", "fred", 8, sealtasks.TTPreCommit2),
+		taskNotScheduled("pc2"),
+
+		taskDone("pc1"),
+		taskDone("pc2"),
+	}))
+
+	t.Run("pc2-block-pc1", testFunc([]workerSpec{
+		{name: "fred", taskTypes: map[sealtasks.TaskType]struct{}{sealtasks.TTPreCommit1: {}, sealtasks.TTPreCommit2: {}}},
+	}, []task{
+		sched("pc2", "fred", 8, sealtasks.TTPreCommit2),
+		taskStarted("pc2"),
+
+		sched("pc1", "fred", 8, sealtasks.TTPreCommit1),
+		taskNotScheduled("pc1"),
+
+		taskDone("pc2"),
+		taskDone("pc1"),
+	}))
+
+	t.Run("pc1-batching", testFunc([]workerSpec{
+		{name: "fred", taskTypes: map[sealtasks.TaskType]struct{}{sealtasks.TTPreCommit1: {}}},
+	}, []task{
+		sched("t1", "fred", 8, sealtasks.TTPreCommit1),
+		taskStarted("t1"),
+
+		sched("t2", "fred", 8, sealtasks.TTPreCommit1),
+		taskStarted("t2"),
+
+		// with worker settings, we can only run 2 parallel PC1s
+
+		// start 2 more to fill fetch buffer
+
+		sched("t3", "fred", 8, sealtasks.TTPreCommit1),
+		taskNotScheduled("t3"),
+
+		sched("t4", "fred", 8, sealtasks.TTPreCommit1),
+		taskNotScheduled("t4"),
+
+		taskDone("t1"),
+		taskDone("t2"),
+
+		taskStarted("t3"),
+		taskStarted("t4"),
+
+		taskDone("t3"),
+		taskDone("t4"),
+	}))
+
+	twoPC1 := func(prefix string, sid abi.SectorNumber, schedAssert func(name string) task) task {
+		return multTask(
+			sched(prefix+"-a", "fred", sid, sealtasks.TTPreCommit1),
+			schedAssert(prefix+"-a"),
+
+			sched(prefix+"-b", "fred", sid+1, sealtasks.TTPreCommit1),
+			schedAssert(prefix+"-b"),
+		)
+	}
+
+	twoPC1Act := func(prefix string, schedAssert func(name string) task) task {
+		return multTask(
+			schedAssert(prefix+"-a"),
+			schedAssert(prefix+"-b"),
+		)
+	}
+
+	diag := func() task {
+		return func(t *testing.T, s *scheduler, index *stores.Index, meta *runMeta) {
+			time.Sleep(20 * time.Millisecond)
+			for _, request := range s.diag().Requests {
+				log.Infof("!!! sDIAG: sid(%d) task(%s)", request.Sector.Number, request.TaskType)
+			}
+
+			wj := (&Manager{sched: s}).WorkerJobs()
+
+			type line struct {
+				storiface.WorkerJob
+				wid uint64
+			}
+
+			lines := make([]line, 0)
+
+			for wid, jobs := range wj {
+				for _, job := range jobs {
+					lines = append(lines, line{
+						WorkerJob: job,
+						wid:       wid,
+					})
+				}
+			}
+
+			// oldest first
+			sort.Slice(lines, func(i, j int) bool {
+				if lines[i].RunWait != lines[j].RunWait {
+					return lines[i].RunWait < lines[j].RunWait
+				}
+				return lines[i].Start.Before(lines[j].Start)
+			})
+
+			for _, l := range lines {
+				log.Infof("!!! wDIAG: rw(%d) sid(%d) t(%s)", l.RunWait, l.Sector.Number, l.Task)
+			}
+		}
+	}
+
+	// run this one a bunch of times, it had a very annoying tendency to fail randomly
+	for i := 0; i < 40; i++ {
+		t.Run("pc1-pc2-prio", testFunc([]workerSpec{
+			{name: "fred", taskTypes: map[sealtasks.TaskType]struct{}{sealtasks.TTPreCommit1: {}, sealtasks.TTPreCommit2: {}}},
+		}, []task{
+			// fill queues
+			twoPC1("w0", 0, taskStarted),
+			twoPC1("w1", 2, taskNotScheduled),
+			sched("w2", "fred", 4, sealtasks.TTPreCommit1),
+			taskNotScheduled("w2"),
+
+			// windowed
+
+			sched("t1", "fred", 8, sealtasks.TTPreCommit1),
+			taskNotScheduled("t1"),
+
+			sched("t2", "fred", 9, sealtasks.TTPreCommit1),
+			taskNotScheduled("t2"),
+
+			sched("t3", "fred", 10, sealtasks.TTPreCommit2),
+			taskNotScheduled("t3"),
+
+			diag(),
+
+			twoPC1Act("w0", taskDone),
+			twoPC1Act("w1", taskStarted),
+			taskNotScheduled("w2"),
+
+			twoPC1Act("w1", taskDone),
+			taskStarted("w2"),
+
+			taskDone("w2"),
+
+			diag(),
+
+			taskStarted("t3"),
+			taskNotScheduled("t1"),
+			taskNotScheduled("t2"),
+
+			taskDone("t3"),
+
+			taskStarted("t1"),
+			taskStarted("t2"),
+
+			taskDone("t1"),
+			taskDone("t2"),
+		}))
+	}
+}
+
+type slowishSelector bool
+
+func (s slowishSelector) Ok(ctx context.Context, task sealtasks.TaskType, spt abi.RegisteredSealProof, a *workerHandle) (bool, error) {
+	time.Sleep(200 * time.Microsecond)
+	return bool(s), nil
+}
+
+func (s slowishSelector) Cmp(ctx context.Context, task sealtasks.TaskType, a, b *workerHandle) (bool, error) {
+	time.Sleep(100 * time.Microsecond)
+	return true, nil
+}
+
+var _ WorkerSelector = slowishSelector(true)
+
+func BenchmarkTrySched(b *testing.B) {
+	spt := abi.RegisteredSealProof_StackedDrg32GiBV1
+	logging.SetAllLoggers(logging.LevelInfo)
+	defer logging.SetAllLoggers(logging.LevelDebug)
+	ctx := context.Background()
+
+	test := func(windows, queue int) func(b *testing.B) {
+		return func(b *testing.B) {
+			for i := 0; i < b.N; i++ {
+				b.StopTimer()
+
+				sched := newScheduler(spt)
+				sched.workers[0] = &workerHandle{
+					w: nil,
+					info: storiface.WorkerInfo{
+						Hostname:  "t",
+						Resources: decentWorkerResources,
+					},
+					preparing: &activeResources{},
+					active:    &activeResources{},
+				}
+
+				for i := 0; i < windows; i++ {
+					sched.openWindows = append(sched.openWindows, &schedWindowRequest{
+						worker: 0,
+						done:   make(chan *schedWindow, 1000),
+					})
+				}
+
+				for i := 0; i < queue; i++ {
+					sched.schedQueue.Push(&workerRequest{
+						taskType: sealtasks.TTCommit2,
+						sel:      slowishSelector(true),
+						ctx:      ctx,
+					})
+				}
+
+				b.StartTimer()
+
+				sched.trySched()
+			}
+		}
+	}
+
+	b.Run("1w-1q", test(1, 1))
+	b.Run("500w-1q", test(500, 1))
+	b.Run("1w-500q", test(1, 500))
+	b.Run("200w-400q", test(200, 400))
+}
+
+func TestWindowCompact(t *testing.T) {
+	sh := scheduler{
+		spt: abi.RegisteredSealProof_StackedDrg32GiBV1,
+	}
+
+	test := func(start [][]sealtasks.TaskType, expect [][]sealtasks.TaskType) func(t *testing.T) {
+		return func(t *testing.T) {
+			wh := &workerHandle{
+				info: storiface.WorkerInfo{
+					Resources: decentWorkerResources,
+				},
+			}
+
+			for _, windowTasks := range start {
+				window := &schedWindow{}
+
+				for _, task := range windowTasks {
+					window.todo = append(window.todo, &workerRequest{taskType: task})
+					window.allocated.add(wh.info.Resources, ResourceTable[task][sh.spt])
+				}
+
+				wh.activeWindows = append(wh.activeWindows, window)
+			}
+
+			n := sh.workerCompactWindows(wh, 0)
+			require.Equal(t, len(start)-len(expect), n)
+
+			for wi, tasks := range expect {
+				var expectRes activeResources
+
+				for ti, task := range tasks {
+					require.Equal(t, task, wh.activeWindows[wi].todo[ti].taskType, "%d, %d", wi, ti)
+					expectRes.add(wh.info.Resources, ResourceTable[task][sh.spt])
+				}
+
+				require.Equal(t, expectRes.cpuUse, wh.activeWindows[wi].allocated.cpuUse, "%d", wi)
+				require.Equal(t, expectRes.gpuUsed, wh.activeWindows[wi].allocated.gpuUsed, "%d", wi)
+				require.Equal(t, expectRes.memUsedMin, wh.activeWindows[wi].allocated.memUsedMin, "%d", wi)
+				require.Equal(t, expectRes.memUsedMax, wh.activeWindows[wi].allocated.memUsedMax, "%d", wi)
+			}
+
+		}
+	}
+
+	t.Run("2-pc1-windows", test(
+		[][]sealtasks.TaskType{{sealtasks.TTPreCommit1}, {sealtasks.TTPreCommit1}},
+		[][]sealtasks.TaskType{{sealtasks.TTPreCommit1, sealtasks.TTPreCommit1}}),
+	)
+
+	t.Run("1-window", test(
+		[][]sealtasks.TaskType{{sealtasks.TTPreCommit1, sealtasks.TTPreCommit1}},
+		[][]sealtasks.TaskType{{sealtasks.TTPreCommit1, sealtasks.TTPreCommit1}}),
+	)
+
+	t.Run("2-pc2-windows", test(
+		[][]sealtasks.TaskType{{sealtasks.TTPreCommit2}, {sealtasks.TTPreCommit2}},
+		[][]sealtasks.TaskType{{sealtasks.TTPreCommit2}, {sealtasks.TTPreCommit2}}),
+	)
+
+	t.Run("2pc1-pc1ap", test(
+		[][]sealtasks.TaskType{{sealtasks.TTPreCommit1, sealtasks.TTPreCommit1}, {sealtasks.TTPreCommit1, sealtasks.TTAddPiece}},
+		[][]sealtasks.TaskType{{sealtasks.TTPreCommit1, sealtasks.TTPreCommit1, sealtasks.TTAddPiece}, {sealtasks.TTPreCommit1}}),
+	)
+
+	t.Run("2pc1-pc1appc2", test(
+		[][]sealtasks.TaskType{{sealtasks.TTPreCommit1, sealtasks.TTPreCommit1}, {sealtasks.TTPreCommit1, sealtasks.TTAddPiece, sealtasks.TTPreCommit2}},
+		[][]sealtasks.TaskType{{sealtasks.TTPreCommit1, sealtasks.TTPreCommit1, sealtasks.TTAddPiece}, {sealtasks.TTPreCommit1, sealtasks.TTPreCommit2}}),
+	)
+}
diff --git a/extern/sector-storage/sched_watch.go b/extern/sector-storage/sched_watch.go
new file mode 100644
index 000000000..2dd9875d7
--- /dev/null
+++ b/extern/sector-storage/sched_watch.go
@@ -0,0 +1,100 @@
+package sectorstorage
+
+import (
+	"context"
+	"reflect"
+)
+
+func (sh *scheduler) runWorkerWatcher() {
+	ctx, cancel := context.WithCancel(context.TODO())
+	defer cancel()
+
+	nilch := reflect.ValueOf(new(chan struct{})).Elem()
+
+	cases := []reflect.SelectCase{
+		{
+			Dir:  reflect.SelectRecv,
+			Chan: reflect.ValueOf(sh.closing),
+		},
+		{
+			Dir:  reflect.SelectRecv,
+			Chan: reflect.ValueOf(sh.watchClosing),
+		},
+	}
+
+	caseToWorker := map[int]WorkerID{}
+
+	for {
+		n, rv, ok := reflect.Select(cases)
+
+		switch {
+		case n == 0: // sh.closing
+			return
+		case n == 1: // sh.watchClosing
+			if !ok {
+				log.Errorf("watchClosing channel closed")
+				return
+			}
+
+			wid, ok := rv.Interface().(WorkerID)
+			if !ok {
+				panic("got a non-WorkerID message")
+			}
+
+			sh.workersLk.Lock()
+			workerClosing, err := sh.workers[wid].w.Closing(ctx)
+			sh.workersLk.Unlock()
+			if err != nil {
+				log.Errorf("getting worker closing channel: %+v", err)
+				select {
+				case sh.workerClosing <- wid:
+				case <-sh.closing:
+					return
+				}
+
+				continue
+			}
+
+			toSet := -1
+			for i, sc := range cases {
+				if sc.Chan == nilch {
+					toSet = i
+					break
+				}
+			}
+			if toSet == -1 {
+				toSet = len(cases)
+				cases = append(cases, reflect.SelectCase{})
+			}
+
+			cases[toSet] = reflect.SelectCase{
+				Dir:  reflect.SelectRecv,
+				Chan: reflect.ValueOf(workerClosing),
+			}
+
+			caseToWorker[toSet] = wid
+		default:
+			wid, found := caseToWorker[n]
+			if !found {
+				log.Errorf("worker ID not found for case %d", n)
+				continue
+			}
+
+			delete(caseToWorker, n)
+			cases[n] = reflect.SelectCase{
+				Dir:  reflect.SelectRecv,
+				Chan: nilch,
+			}
+
+			log.Warnf("worker %d dropped", wid)
+			// send in a goroutine to avoid a deadlock between workerClosing / watchClosing
+			go func() {
+				select {
+				case sh.workerClosing <- wid:
+				case <-sh.closing:
+					return
+				}
+			}()
+		}
+	}
+}
diff --git a/extern/sector-storage/sealtasks/task.go b/extern/sector-storage/sealtasks/task.go
new file mode 100644
index 000000000..4174373a6
--- /dev/null
+++ b/extern/sector-storage/sealtasks/task.go
@@ -0,0 +1,63 @@
+package sealtasks
+
+type TaskType string
+
+const (
+	TTAddPiece   TaskType = "seal/v0/addpiece"
+	TTPreCommit1 TaskType = "seal/v0/precommit/1"
+	TTPreCommit2 TaskType = "seal/v0/precommit/2"
+	TTCommit1    TaskType = "seal/v0/commit/1" // NOTE: We use this to transfer the sector into miner-local storage for now; Don't use on workers!
+	TTCommit2    TaskType = "seal/v0/commit/2"
+
+	TTFinalize TaskType = "seal/v0/finalize"
+
+	TTFetch        TaskType = "seal/v0/fetch"
+	TTUnseal       TaskType = "seal/v0/unseal"
+	TTReadUnsealed TaskType = "seal/v0/unsealread"
+)
+
+var order = map[TaskType]int{
+	TTAddPiece:     6, // least priority
+	TTPreCommit1:   5,
+	TTPreCommit2:   4,
+	TTCommit2:      3,
+	TTCommit1:      2,
+	TTUnseal:       1,
+	TTFetch:        -1,
+	TTReadUnsealed: -1,
+	TTFinalize:     -2, // most priority
+}
+
+var shortNames = map[TaskType]string{
+	TTAddPiece: "AP ",
+
+	TTPreCommit1: "PC1",
+	TTPreCommit2: "PC2",
+	TTCommit1:    "C1 ",
+	TTCommit2:    "C2 ",
+
+	TTFinalize: "FIN",
+
+	TTFetch:        "GET",
+	TTUnseal:       "UNS",
+	TTReadUnsealed: "RD ",
+}
+
+func (a TaskType) MuchLess(b TaskType) (bool, bool) {
+	oa, ob := order[a], order[b]
+	oneNegative := oa^ob < 0
+	return oneNegative, oa < ob
+}
+
+func (a TaskType) Less(b TaskType) bool {
+	return order[a] < order[b]
+}
+
+func (a TaskType) Short() string {
+	n, ok := shortNames[a]
+	if !ok {
+		return "UNK"
+	}
+
+	return n
+}
diff --git a/extern/sector-storage/selector_alloc.go b/extern/sector-storage/selector_alloc.go
new file mode 100644
index 000000000..b891383fb
--- /dev/null
+++ b/extern/sector-storage/selector_alloc.go
@@ -0,0 +1,65 @@
+package sectorstorage
+
+import (
+	"context"
+
+	"golang.org/x/xerrors"
+
+	"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"
+)
+
+type allocSelector struct {
+	index stores.SectorIndex
+	alloc stores.SectorFileType
+	ptype stores.PathType
+}
+
+func newAllocSelector(index stores.SectorIndex, alloc stores.SectorFileType, ptype stores.PathType) *allocSelector {
+	return &allocSelector{
+		index: index,
+		alloc: alloc,
+		ptype: ptype,
+	}
+}
+
+func (s *allocSelector) Ok(ctx context.Context, task sealtasks.TaskType, spt abi.RegisteredSealProof, whnd *workerHandle) (bool, error) {
+	tasks, err := whnd.w.TaskTypes(ctx)
+	if err != nil {
+		return false, xerrors.Errorf("getting supported worker task types: %w", err)
+	}
+	if _, supported := tasks[task]; !supported {
+		return false, nil
+	}
+
+	paths, err := whnd.w.Paths(ctx)
+	if err != nil {
+		return false, xerrors.Errorf("getting worker paths: %w", err)
+	}
+
+	have := map[stores.ID]struct{}{}
+	for _, path := range paths {
+		have[path.ID] = struct{}{}
+	}
+
+	best, err := s.index.StorageBestAlloc(ctx, s.alloc, spt, s.ptype)
+	if err != nil {
+		return false, xerrors.Errorf("finding best alloc storage: %w", err)
+	}
+
+	for _, info := range best {
+		if _, ok := have[info.ID]; ok {
+			return true, nil
+		}
+	}
+
+	return false, nil
+}
+
+func (s *allocSelector) Cmp(ctx context.Context, task sealtasks.TaskType, a, b *workerHandle) (bool, error) {
+	return a.utilization() < b.utilization(), nil
+}
+
+var _ WorkerSelector = &allocSelector{}
diff --git a/extern/sector-storage/selector_existing.go b/extern/sector-storage/selector_existing.go
new file mode 100644
index 000000000..fb161f085
--- /dev/null
+++ b/extern/sector-storage/selector_existing.go
@@ -0,0 +1,67 @@
+package sectorstorage
+
+import (
+	"context"
+
+	"golang.org/x/xerrors"
+
+	"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"
+)
+
+type existingSelector struct {
+	index      stores.SectorIndex
+	sector     abi.SectorID
+	alloc      stores.SectorFileType
+	allowFetch bool
+}
+
+func newExistingSelector(index stores.SectorIndex, sector abi.SectorID, alloc stores.SectorFileType, allowFetch bool) *existingSelector {
+	return &existingSelector{
+		index:      index,
+		sector:     sector,
+		alloc:      alloc,
+		allowFetch: allowFetch,
+	}
+}
+
+func (s *existingSelector) Ok(ctx context.Context, task sealtasks.TaskType, spt abi.RegisteredSealProof, whnd *workerHandle) (bool, error) {
+	tasks, err := whnd.w.TaskTypes(ctx)
+	if err != nil {
+		return false, xerrors.Errorf("getting supported worker task types: %w", err)
+	}
+	if _, supported := tasks[task]; !supported {
+		return false, nil
+	}
+
+	paths, err := whnd.w.Paths(ctx)
+	if err != nil {
+		return false, xerrors.Errorf("getting worker paths: %w", err)
+	}
+
+	have := map[stores.ID]struct{}{}
+	for _, path := range paths {
+		have[path.ID] = struct{}{}
+	}
+
+	best, err := s.index.StorageFindSector(ctx, s.sector, s.alloc, spt, s.allowFetch)
+	if err != nil {
+		return false, xerrors.Errorf("finding best storage: %w", err)
+	}
+
+	for _, info := range best {
+		if _, ok := have[info.ID]; ok {
+			return true, nil
+		}
+	}
+
+	return false, nil
+}
+
+func (s *existingSelector) Cmp(ctx context.Context, task sealtasks.TaskType, a, b *workerHandle) (bool, error) {
+	return a.utilization() < b.utilization(), nil
+}
+
+var _ WorkerSelector = &existingSelector{}
diff --git a/extern/sector-storage/selector_task.go b/extern/sector-storage/selector_task.go
new file mode 100644
index 000000000..807b53103
--- /dev/null
+++ b/extern/sector-storage/selector_task.go
@@ -0,0 +1,48 @@
+package sectorstorage
+
+import (
+	"context"
+
+	"golang.org/x/xerrors"
+
+	"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"
+)
+
+type taskSelector struct {
+	best []stores.StorageInfo //nolint: unused, structcheck
+}
+
+func newTaskSelector() *taskSelector {
+	return &taskSelector{}
+}
+
+func (s *taskSelector) Ok(ctx context.Context, task sealtasks.TaskType, spt abi.RegisteredSealProof, whnd *workerHandle) (bool, error) {
+	tasks, err := whnd.w.TaskTypes(ctx)
+	if err != nil {
+		return false, xerrors.Errorf("getting supported worker task types: %w", err)
+	}
+	_, supported := tasks[task]
+
+	return supported, nil
+}
+
+func (s *taskSelector) Cmp(ctx context.Context, _ sealtasks.TaskType, a, b *workerHandle) (bool, error) {
+	atasks, err := a.w.TaskTypes(ctx)
+	if err != nil {
+		return false, xerrors.Errorf("getting supported worker task types: %w", err)
+	}
+	btasks, err := b.w.TaskTypes(ctx)
+	if err != nil {
+		return false, xerrors.Errorf("getting supported worker task types: %w", err)
+	}
+	if len(atasks) != len(btasks) {
+		return len(atasks) < len(btasks), nil // prefer workers which can do less
+	}
+
+	return a.utilization() < b.utilization(), nil
+}
+
+var _ WorkerSelector = &allocSelector{}
diff --git a/extern/sector-storage/stats.go b/extern/sector-storage/stats.go
new file mode 100644
index 000000000..7f95e3bc3
--- /dev/null
+++ b/extern/sector-storage/stats.go
@@ -0,0 +1,51 @@
+package sectorstorage
+
+import (
+	"github.com/filecoin-project/lotus/extern/sector-storage/storiface"
+)
+
+func (m *Manager) WorkerStats() map[uint64]storiface.WorkerStats {
+	m.sched.workersLk.RLock()
+	defer m.sched.workersLk.RUnlock()
+
+	out := map[uint64]storiface.WorkerStats{}
+
+	for id, handle := range m.sched.workers {
+		out[uint64(id)] = storiface.WorkerStats{
+			Info:       handle.info,
+			MemUsedMin: handle.active.memUsedMin,
+			MemUsedMax: handle.active.memUsedMax,
+			GpuUsed:    handle.active.gpuUsed,
+			CpuUse:     handle.active.cpuUse,
+		}
+	}
+
+	return out
+}
+
+func (m *Manager) WorkerJobs() map[uint64][]storiface.WorkerJob {
+	m.sched.workersLk.RLock()
+	defer m.sched.workersLk.RUnlock()
+
+	out := map[uint64][]storiface.WorkerJob{}
+
+	for id, handle := range m.sched.workers {
+		out[uint64(id)] = handle.wt.Running()
+
+		handle.wndLk.Lock()
+		for wi, window := range handle.activeWindows {
+			for _, request := range window.todo {
+				out[uint64(id)] = append(out[uint64(id)], storiface.WorkerJob{
+					ID:      0,
+					Sector:  request.sector,
+					Task:    request.taskType,
+					RunWait: wi + 1,
+					Start:   request.start,
+				})
+			}
+		}
+		handle.wndLk.Unlock()
+	}
+
+	return out
+}
diff --git a/extern/sector-storage/stores/filetype.go b/extern/sector-storage/stores/filetype.go
new file mode 100644
index 000000000..90cc1d160
--- /dev/null
+++ b/extern/sector-storage/stores/filetype.go
@@ -0,0 +1,141 @@
+package stores
+
+import (
+	"fmt"
+
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-state-types/abi"
+)
+
+const (
+	FTUnsealed SectorFileType = 1 << iota
+	FTSealed
+	FTCache
+
+	FileTypes = iota
+)
+
+const (
+	FTNone SectorFileType = 0
+)
+
+const FSOverheadDen = 10
+
+var FSOverheadSeal = map[SectorFileType]int{ // 10x overheads
+	FTUnsealed: FSOverheadDen,
+	FTSealed:   FSOverheadDen,
+	FTCache:    141, // 11 layers + D(2x ssize) + C + R
+}
+
+var FsOverheadFinalized = map[SectorFileType]int{
+	FTUnsealed: FSOverheadDen,
+	FTSealed:   FSOverheadDen,
+	FTCache:    2,
+}
+
+type SectorFileType int
+
+func (t SectorFileType) String() string {
+	switch t {
+	case FTUnsealed:
+		return "unsealed"
+	case FTSealed:
+		return "sealed"
+	case FTCache:
+		return "cache"
+	default:
+		return fmt.Sprintf("<unknown %d>", t)
+	}
+}
+
+func (t SectorFileType) Has(singleType SectorFileType) bool {
+	return t&singleType == singleType
+}
+
+func (t SectorFileType) SealSpaceUse(spt abi.RegisteredSealProof) (uint64, error) {
+	ssize, err := spt.SectorSize()
+	if err != nil {
+		return 0, xerrors.Errorf("getting sector size: %w", err)
+	}
+
+	var need uint64
+	for _, pathType := range PathTypes {
+		if !t.Has(pathType) {
+			continue
+		}
+
+		oh, ok := FSOverheadSeal[pathType]
+		if !ok {
+			return 0, xerrors.Errorf("no seal overhead info for %s", pathType)
+		}
+
+		need += uint64(oh) * uint64(ssize) / FSOverheadDen
+	}
+
+	return need, nil
+}
+
+func (t SectorFileType) All() [FileTypes]bool {
+	var out [FileTypes]bool
+
+	for i := range out {
+		out[i] = t&(1<<i) > 0
+	}
+
+	return out
+}
+
+type SectorPaths struct {
+	ID abi.SectorID
+
+	Unsealed string
+	Sealed   string
+	Cache    string
+}
+
+func ParseSectorID(baseName string) (abi.SectorID, error) {
+	var n abi.SectorNumber
+	var mid abi.ActorID
+	read, err := fmt.Sscanf(baseName, "s-t0%d-%d", &mid, &n)
+	if err != nil {
+		return abi.SectorID{}, xerrors.Errorf("sscanf sector name ('%s'): %w", baseName, err)
+	}
+
+	if read != 2 {
+		return abi.SectorID{}, xerrors.Errorf("parseSectorID expected to scan 2 values, got %d", read)
+	}
+
+	return abi.SectorID{
+		Miner:  mid,
+		Number: n,
+	}, nil
+}
+
+func SectorName(sid abi.SectorID) string {
+	return fmt.Sprintf("s-t0%d-%d", sid.Miner, sid.Number)
+}
+
+func PathByType(sps SectorPaths, fileType SectorFileType) string {
+	switch fileType {
+	case FTUnsealed:
+		return sps.Unsealed
+	case FTSealed:
+		return sps.Sealed
+	case FTCache:
+		return sps.Cache
+	}
+
+	panic("requested unknown path type")
+}
+
+func SetPathByType(sps *SectorPaths, fileType SectorFileType, p string) {
+	switch fileType {
+	case FTUnsealed:
+		sps.Unsealed = p
+	case FTSealed:
+		sps.Sealed = p
+	case FTCache:
+		sps.Cache = p
+	}
+}
diff --git a/extern/sector-storage/stores/http_handler.go b/extern/sector-storage/stores/http_handler.go
new file mode 100644
index 000000000..97af6e769
--- /dev/null
+++ b/extern/sector-storage/stores/http_handler.go
@@ -0,0 +1,155 @@
+package stores
+
+import (
+	"encoding/json"
+	"io"
+	"net/http"
+	"os"
+
+	"github.com/gorilla/mux"
+	logging "github.com/ipfs/go-log/v2"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/lotus/extern/sector-storage/tarutil"
+)
+
+var log = logging.Logger("stores")
+
+type FetchHandler struct {
+	*Local
+}
+
+func (handler *FetchHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) { // /remote/
+	mux := mux.NewRouter()
+
+	mux.HandleFunc("/remote/stat/{id}", handler.remoteStatFs).Methods("GET")
+	mux.HandleFunc("/remote/{type}/{id}", handler.remoteGetSector).Methods("GET")
+	mux.HandleFunc("/remote/{type}/{id}", handler.remoteDeleteSector).Methods("DELETE")
+
+	mux.ServeHTTP(w, r)
+}
+
+func (handler *FetchHandler) remoteStatFs(w http.ResponseWriter, r *http.Request) {
+	vars := mux.Vars(r)
+	id := ID(vars["id"])
+
+	st, err := handler.Local.FsStat(r.Context(), id)
+	switch err {
+	case errPathNotFound:
+		w.WriteHeader(404)
+		return
+	case nil:
+		break
+	default:
+		w.WriteHeader(500)
+		log.Errorf("%+v", err)
+		return
+	}
+
+	if err := json.NewEncoder(w).Encode(&st); err != nil {
+		log.Warnf("error writing stat response: %+v", err)
+	}
+}
+
+func (handler *FetchHandler) remoteGetSector(w http.ResponseWriter, r *http.Request) {
+	log.Infof("SERVE GET %s", r.URL)
+	vars := mux.Vars(r)
+
+	id, err := ParseSectorID(vars["id"])
+	if err != nil {
+		log.Error("%+v", err)
+		w.WriteHeader(500)
+		return
+	}
+
+	ft, err := ftFromString(vars["type"])
+	if err != nil {
+		log.Error("%+v", err)
+		w.WriteHeader(500)
+		return
+	}
+
+	// The caller has a lock on this sector already, no need to get one here
+
+	// passing 0 spt because we don't allocate anything
+	paths, _, err := handler.Local.AcquireSector(r.Context(), id, 0, ft, FTNone, PathStorage, AcquireMove)
+	if err != nil {
+		log.Error("%+v", err)
+		w.WriteHeader(500)
+		return
+	}
+
+	// TODO: reserve local storage here
+
+	path := PathByType(paths, ft)
+	if path == "" {
+		log.Error("acquired path was empty")
+		w.WriteHeader(500)
+		return
+	}
+
+	stat, err := os.Stat(path)
+	if err != nil {
+		log.Error("%+v", err)
+		w.WriteHeader(500)
+		return
+	}
+
+	var rd io.Reader
+	if stat.IsDir() {
+		rd, err = tarutil.TarDirectory(path)
+		w.Header().Set("Content-Type", "application/x-tar")
+	} else {
+		rd, err = os.OpenFile(path, os.O_RDONLY, 0644) // nolint
+		w.Header().Set("Content-Type", "application/octet-stream")
+	}
+	if err != nil {
+		log.Error("%+v", err)
+		w.WriteHeader(500)
+		return
+	}
+
+	w.WriteHeader(200)
+	if _, err := io.Copy(w, rd); err != nil { // TODO: default 32k buf may be too small
+		log.Error("%+v", err)
+		return
+	}
+}
+
+func (handler *FetchHandler) remoteDeleteSector(w http.ResponseWriter, r *http.Request) {
+	log.Infof("SERVE DELETE %s", r.URL)
+	vars := mux.Vars(r)
+
+	id, err := ParseSectorID(vars["id"])
+	if err != nil {
+		log.Error("%+v", err)
+		w.WriteHeader(500)
+		return
+	}
+
+	ft, err := ftFromString(vars["type"])
+	if err != nil {
+		log.Error("%+v", err)
+		w.WriteHeader(500)
+		return
+	}
+
+	if err := handler.Remove(r.Context(), id, ft, false); err != nil {
+		log.Error("%+v", err)
+		w.WriteHeader(500)
+		return
+	}
+}
+
+func ftFromString(t string) (SectorFileType, error) {
+	switch t {
+	case FTUnsealed.String():
+		return FTUnsealed, nil
+	case FTSealed.String():
+		return FTSealed, nil
+	case FTCache.String():
+		return FTCache, nil
+	default:
+		return 0, xerrors.Errorf("unknown sector file type: '%s'", t)
+	}
+}
diff --git a/extern/sector-storage/stores/index.go b/extern/sector-storage/stores/index.go
new file mode 100644
index 000000000..e2bd7e4ee
--- /dev/null
+++ b/extern/sector-storage/stores/index.go
@@ -0,0 +1,443 @@
+package stores
+
+import (
+	"context"
+	"net/url"
+	gopath "path"
+	"sort"
+	"sync"
+	"time"
+
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/lotus/extern/sector-storage/fsutil"
+
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/big"
+)
+
+var HeartbeatInterval = 10 * time.Second
+var SkippedHeartbeatThresh = HeartbeatInterval * 5
+
+// ID identifies sector storage by UUID. One sector storage should map to one
+//  filesystem, local or networked / shared by multiple machines
+type ID string
+
+type StorageInfo struct {
+	ID     ID
+	URLs   []string // TODO: Support non-http transports
+	Weight uint64
+
+	CanSeal  bool
+	CanStore bool
+}
+
+type HealthReport struct {
+	Stat fsutil.FsStat
+	Err  error
+}
+
+type SectorStorageInfo struct {
+	ID     ID
+	URLs   []string // TODO: Support non-http transports
+	Weight uint64
+
+	CanSeal  bool
+	CanStore bool
+
+	Primary bool
+}
+
+type SectorIndex interface { // part of storage-miner api
+	StorageAttach(context.Context, StorageInfo, fsutil.FsStat) error
+	StorageInfo(context.Context, ID) (StorageInfo, error)
+	StorageReportHealth(context.Context, ID, HealthReport) error
+
+	StorageDeclareSector(ctx context.Context, storageID ID, s abi.SectorID, ft SectorFileType, primary bool) error
+	StorageDropSector(ctx context.Context, storageID ID, s abi.SectorID, ft SectorFileType) error
+	StorageFindSector(ctx context.Context, sector abi.SectorID, ft SectorFileType, spt abi.RegisteredSealProof, allowFetch bool) ([]SectorStorageInfo, error)
+
+	StorageBestAlloc(ctx context.Context, allocate SectorFileType, spt abi.RegisteredSealProof, pathType PathType) ([]StorageInfo, error)
+
+	// atomically acquire locks on all sector file types. close ctx to unlock
+	StorageLock(ctx context.Context, sector abi.SectorID, read SectorFileType, write SectorFileType) error
+	StorageTryLock(ctx context.Context, sector abi.SectorID, read SectorFileType, write SectorFileType) (bool, error)
+}
+
+type Decl struct {
+	abi.SectorID
+	SectorFileType
+}
+
+type declMeta struct {
+	storage ID
+	primary bool
+}
+
+type storageEntry struct {
+	info *StorageInfo
+	fsi  fsutil.FsStat
+
+	lastHeartbeat time.Time
+	heartbeatErr  error
+}
+
+type Index struct {
+	*indexLocks
+	lk sync.RWMutex
+
+	sectors map[Decl][]*declMeta
+	stores  map[ID]*storageEntry
+}
+
+func NewIndex() *Index {
+	return &Index{
+		indexLocks: &indexLocks{
+			locks: map[abi.SectorID]*sectorLock{},
+		},
+		sectors: map[Decl][]*declMeta{},
+		stores:  map[ID]*storageEntry{},
+	}
+}
+
+func (i *Index) StorageList(ctx context.Context) (map[ID][]Decl, error) {
+	i.lk.RLock()
+	defer i.lk.RUnlock()
+
+	byID := map[ID]map[abi.SectorID]SectorFileType{}
+
+	for id := range i.stores {
+		byID[id] = map[abi.SectorID]SectorFileType{}
+	}
+	for decl, ids := range i.sectors {
+		for _, id := range ids {
+			byID[id.storage][decl.SectorID] |= decl.SectorFileType
+		}
+	}
+
+	out := map[ID][]Decl{}
+	for id, m := range byID {
+		out[id] = []Decl{}
+		for sectorID, fileType := range m {
+			out[id] = append(out[id], Decl{
+				SectorID:       sectorID,
+				SectorFileType: fileType,
+			})
+		}
+	}
+
+	return out, nil
+}
+
+func (i *Index) StorageAttach(ctx context.Context, si StorageInfo, st fsutil.FsStat) error {
+	i.lk.Lock()
+	defer i.lk.Unlock()
+
+	log.Infof("New sector storage: %s", si.ID)
+
+	if _, ok := i.stores[si.ID]; ok {
+		for _, u := range si.URLs {
+			if _, err := url.Parse(u); err != nil {
+				return xerrors.Errorf("failed to parse url %s: %w", si.URLs, err)
+			}
+		}
+
+	uloop:
+		for _, u := range si.URLs {
+			for _, l := range i.stores[si.ID].info.URLs {
+				if u == l {
+					continue uloop
+				}
+			}
+
+			i.stores[si.ID].info.URLs = append(i.stores[si.ID].info.URLs, u)
+		}
+
+		return nil
+	}
+	i.stores[si.ID] = &storageEntry{
+		info: &si,
+		fsi:  st,
+
+		lastHeartbeat: time.Now(),
+	}
+	return nil
+}
+
+func (i *Index) StorageReportHealth(ctx context.Context, id ID, report HealthReport) error {
+	i.lk.Lock()
+	defer i.lk.Unlock()
+
+	ent, ok := i.stores[id]
+	if !ok {
+		return xerrors.Errorf("health report for unknown storage: %s", id)
+	}
+
+	ent.fsi = report.Stat
+	ent.heartbeatErr = report.Err
+	ent.lastHeartbeat = time.Now()
+
+	return nil
+}
+
+func (i *Index) StorageDeclareSector(ctx context.Context, storageID ID, s abi.SectorID, ft SectorFileType, primary bool) error {
+	i.lk.Lock()
+	defer i.lk.Unlock()
+
+loop:
+	for _, fileType := range PathTypes {
+		if fileType&ft == 0 {
+			continue
+		}
+
+		d := Decl{s, fileType}
+
+		for _, sid := range i.sectors[d] {
+			if sid.storage == storageID {
+				if !sid.primary && primary {
+					sid.primary = true
+				} else {
+					log.Warnf("sector %v redeclared in %s", s, storageID)
+				}
+				continue loop
+			}
+		}
+
+		i.sectors[d] = append(i.sectors[d], &declMeta{
+			storage: storageID,
+			primary: primary,
+		})
+	}
+
+	return nil
+}
+
+func (i *Index) StorageDropSector(ctx context.Context, storageID ID, s abi.SectorID, ft SectorFileType) error {
+	i.lk.Lock()
+	defer i.lk.Unlock()
+
+	for _, fileType := range PathTypes {
+		if fileType&ft == 0 {
+			continue
+		}
+
+		d := Decl{s, fileType}
+
+		if len(i.sectors[d]) == 0 {
+			return nil
+		}
+
+		rewritten := make([]*declMeta, 0, len(i.sectors[d])-1)
+		for _, sid := range i.sectors[d] {
+			if sid.storage == storageID {
+				continue
+			}
+
+			rewritten = append(rewritten, sid)
+		}
+		if len(rewritten) == 0 {
+			delete(i.sectors, d)
+			return nil
+		}
+
+		i.sectors[d] = rewritten
+	}
+
+	return nil
+}
+
+func (i *Index) StorageFindSector(ctx context.Context, s abi.SectorID, ft SectorFileType, spt abi.RegisteredSealProof, allowFetch bool) ([]SectorStorageInfo, error) {
+	i.lk.RLock()
+	defer i.lk.RUnlock()
+
+	storageIDs := map[ID]uint64{}
+	isprimary := map[ID]bool{}
+
+	for _, pathType := range PathTypes {
+		if ft&pathType == 0 {
+			continue
+		}
+
+		for _, id := range i.sectors[Decl{s, pathType}] {
+			storageIDs[id.storage]++
+			isprimary[id.storage] = isprimary[id.storage] || id.primary
+		}
+	}
+
+	out := make([]SectorStorageInfo, 0, len(storageIDs))
+
+	for id, n := range storageIDs {
+		st, ok := i.stores[id]
+		if !ok {
+			log.Warnf("storage %s is not present in sector index (referenced by sector %v)", id, s)
+			continue
+		}
+
+		urls := make([]string, len(st.info.URLs))
+		for k, u := range st.info.URLs {
+			rl, err := url.Parse(u)
+			if err != nil {
+				return nil, xerrors.Errorf("failed to parse url: %w", err)
+			}
+
+			rl.Path = gopath.Join(rl.Path, ft.String(), SectorName(s))
+			urls[k] = rl.String()
+		}
+
+		out = append(out, SectorStorageInfo{
+			ID:     id,
+			URLs:   urls,
+			Weight: st.info.Weight * n, // storage with more sector types is better
+
+			CanSeal:  st.info.CanSeal,
+			CanStore: st.info.CanStore,
+
+			Primary: isprimary[id],
+		})
+	}
+
+	if allowFetch {
+		spaceReq, err := ft.SealSpaceUse(spt)
+		if err != nil {
+			return nil, xerrors.Errorf("estimating required space: %w", err)
+		}
+
+		for id, st := range i.stores {
+			if !st.info.CanSeal {
+				continue
+			}
+
+			if spaceReq > uint64(st.fsi.Available) {
+				log.Debugf("not selecting on %s, out of space (available: %d, need: %d)", st.info.ID, st.fsi.Available, spaceReq)
+				continue
+			}
+
+			if time.Since(st.lastHeartbeat) > SkippedHeartbeatThresh {
+				log.Debugf("not selecting on %s, didn't receive heartbeats for %s", st.info.ID, time.Since(st.lastHeartbeat))
+				continue
+			}
+
+			if st.heartbeatErr != nil {
+				log.Debugf("not selecting on %s, heartbeat error: %s", st.info.ID, st.heartbeatErr)
+				continue
+			}
+
+			if _, ok := storageIDs[id]; ok {
+				continue
+			}
+
+			urls := make([]string, len(st.info.URLs))
+			for k, u := range st.info.URLs {
+				rl, err := url.Parse(u)
+				if err != nil {
+					return nil, xerrors.Errorf("failed to parse url: %w", err)
+				}
+
+				rl.Path = gopath.Join(rl.Path, ft.String(), SectorName(s))
+				urls[k] = rl.String()
+			}
+
+			out = append(out, SectorStorageInfo{
+				ID:     id,
+				URLs:   urls,
+				Weight: st.info.Weight * 0, // TODO: something better than just '0'
+
+				CanSeal:  st.info.CanSeal,
+				CanStore: st.info.CanStore,
+
+				Primary: false,
+			})
+		}
+	}
+
+	return out, nil
+}
+
+func (i *Index) StorageInfo(ctx context.Context, id ID) (StorageInfo, error) {
+	i.lk.RLock()
+	defer i.lk.RUnlock()
+
+	si, found := i.stores[id]
+	if !found {
+		return StorageInfo{}, xerrors.Errorf("sector store not found")
+	}
+
+	return *si.info, nil
+}
+
+func (i *Index) StorageBestAlloc(ctx context.Context, allocate SectorFileType, spt abi.RegisteredSealProof, pathType PathType) ([]StorageInfo, error) {
+	i.lk.RLock()
+	defer i.lk.RUnlock()
+
+	var candidates []storageEntry
+
+	spaceReq, err := allocate.SealSpaceUse(spt)
+	if err != nil {
+		return nil, xerrors.Errorf("estimating required space: %w", err)
+	}
+
+	for _, p := range i.stores {
+		if (pathType == PathSealing) && !p.info.CanSeal {
+			continue
+		}
+		if (pathType == PathStorage) && !p.info.CanStore {
+			continue
+		}
+
+		if spaceReq > uint64(p.fsi.Available) {
+			log.Debugf("not allocating on %s, out of space (available: %d, need: %d)", p.info.ID, p.fsi.Available, spaceReq)
+			continue
+		}
+
+		if time.Since(p.lastHeartbeat) > SkippedHeartbeatThresh {
+			log.Debugf("not allocating on %s, didn't receive heartbeats for %s", p.info.ID, time.Since(p.lastHeartbeat))
+			continue
+		}
+
+		if p.heartbeatErr != nil {
+			log.Debugf("not allocating on %s, heartbeat error: %s", p.info.ID, p.heartbeatErr)
+			continue
+		}
+
+		candidates = append(candidates, *p)
+	}
+
+	if len(candidates) == 0 {
+		return nil, xerrors.New("no good path found")
+	}
+
+	sort.Slice(candidates, func(i, j int) bool {
+		iw := big.Mul(big.NewInt(candidates[i].fsi.Available), big.NewInt(int64(candidates[i].info.Weight)))
+		jw := big.Mul(big.NewInt(candidates[j].fsi.Available), big.NewInt(int64(candidates[j].info.Weight)))
+
+		return iw.GreaterThan(jw)
+	})
+
+	out := make([]StorageInfo, len(candidates))
+	for i, candidate := range candidates {
+		out[i] = *candidate.info
+	}
+
+	return out, nil
+}
+
+func (i *Index) FindSector(id abi.SectorID, typ SectorFileType) ([]ID, error) {
+	i.lk.RLock()
+	defer i.lk.RUnlock()
+
+	f, ok := i.sectors[Decl{
+		SectorID:       id,
+		SectorFileType: typ,
+	}]
+	if !ok {
+		return nil, nil
+	}
+	out := make([]ID, 0, len(f))
+	for _, meta := range f {
+		out = append(out, meta.storage)
+	}
+
+	return out, nil
+}
+
+var _ SectorIndex = &Index{}
diff --git a/extern/sector-storage/stores/index_locks.go b/extern/sector-storage/stores/index_locks.go
new file mode 100644
index 000000000..32c963a41
--- /dev/null
+++ b/extern/sector-storage/stores/index_locks.go
@@ -0,0 +1,154 @@
+package stores
+
+import (
+	"context"
+	"sync"
+
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-state-types/abi"
+)
+
+type sectorLock struct {
+	cond *ctxCond
+
+	r [FileTypes]uint
+	w SectorFileType
+
+	refs uint // access with indexLocks.lk
+}
+
+func (l *sectorLock) canLock(read SectorFileType, write SectorFileType) bool {
+	for i, b := range write.All() {
+		if b && l.r[i] > 0 {
+			return false
+		}
+	}
+
+	// check that there are no locks taken for either read or write file types we want
+	return l.w&read == 0 && l.w&write == 0
+}
+
+func (l *sectorLock) tryLock(read SectorFileType, write SectorFileType) bool {
+	if !l.canLock(read, write) {
+		return false
+	}
+
+	for i, set := range read.All() {
+		if set {
+			l.r[i]++
+		}
+	}
+
+	l.w |= write
+
+	return true
+}
+
+type lockFn func(l *sectorLock, ctx context.Context, read SectorFileType, write SectorFileType) (bool, error)
+
+func (l *sectorLock) tryLockSafe(ctx context.Context, read SectorFileType, write SectorFileType) (bool, error) {
+	l.cond.L.Lock()
+	defer l.cond.L.Unlock()
+
+	return l.tryLock(read, write), nil
+}
+
+func (l *sectorLock) lock(ctx context.Context, read SectorFileType, write SectorFileType) (bool, error) {
+	l.cond.L.Lock()
+	defer l.cond.L.Unlock()
+
+	for !l.tryLock(read, write) {
+		if err := l.cond.Wait(ctx); err != nil {
+			return false, err
+		}
+	}
+
+	return true, nil
+}
+
+func (l *sectorLock) unlock(read SectorFileType, write SectorFileType) {
+	l.cond.L.Lock()
+	defer l.cond.L.Unlock()
+
+	for i, set := range read.All() {
+		if set {
+			l.r[i]--
+		}
+	}
+
+	l.w &= ^write
+
+	l.cond.Broadcast()
+}
+
+type indexLocks struct {
+	lk sync.Mutex
+
+	locks map[abi.SectorID]*sectorLock
+}
+
+func (i *indexLocks) lockWith(ctx context.Context, lockFn lockFn, sector abi.SectorID, read SectorFileType, write SectorFileType) (bool, error) {
+	if read|write == 0 {
+		return false, nil
+	}
+
+	if read|write > (1<<FileTypes)-1 {
+		return false, xerrors.Errorf("unknown file types specified")
+	}
+
+	i.lk.Lock()
+	slk, ok := i.locks[sector]
+	if !ok {
+		slk = &sectorLock{}
+		slk.cond = newCtxCond(&sync.Mutex{})
+		i.locks[sector] = slk
+	}
+
+	slk.refs++
+
+	i.lk.Unlock()
+
+	locked, err := lockFn(slk, ctx, read, write)
+	if err != nil {
+		return false, err
+	}
+	if !locked {
+		return false, nil
+	}
+
+	go func() {
+		// TODO: we can avoid this goroutine with a bit of creativity and reflect
+
+		<-ctx.Done()
+		i.lk.Lock()
+
+		slk.unlock(read, write)
+		slk.refs--
+
+		if slk.refs == 0 {
+			delete(i.locks, sector)
+		}
+
+		i.lk.Unlock()
+	}()
+
+	return true, nil
+}
+
+func (i *indexLocks) StorageLock(ctx context.Context, sector abi.SectorID, read SectorFileType, write SectorFileType) error {
+	ok, err := i.lockWith(ctx, (*sectorLock).lock, sector, read, write)
+	if err != nil {
+		return err
+	}
+
+	if !ok {
+		return xerrors.Errorf("failed to acquire lock")
+	}
+
+	return nil
+}
+
+func (i *indexLocks) StorageTryLock(ctx context.Context, sector abi.SectorID, read SectorFileType, write SectorFileType) (bool, error) {
+	return i.lockWith(ctx, (*sectorLock).tryLockSafe, sector, read, write)
+}
diff --git a/extern/sector-storage/stores/index_locks_test.go b/extern/sector-storage/stores/index_locks_test.go
new file mode 100644
index 000000000..1c550d3ca
--- /dev/null
+++ b/extern/sector-storage/stores/index_locks_test.go
@@ -0,0 +1,170 @@
+package stores
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/filecoin-project/go-state-types/abi"
+)
+
+var aSector = abi.SectorID{
+	Miner:  2,
+	Number: 9000,
+}
+
+func TestCanLock(t *testing.T) {
+	lk := sectorLock{
+		r: [FileTypes]uint{},
+		w: FTNone,
+	}
+
+	require.Equal(t, true, lk.canLock(FTUnsealed, FTNone))
+	require.Equal(t, true, lk.canLock(FTNone, FTUnsealed))
+
+	ftAll := FTUnsealed | FTSealed | FTCache
+
+	require.Equal(t, true, lk.canLock(ftAll, FTNone))
+	require.Equal(t, true, lk.canLock(FTNone, ftAll))
+
+	lk.r[0] = 1 // unsealed read taken
+
+	require.Equal(t, true, lk.canLock(FTUnsealed, FTNone))
+	require.Equal(t, false, lk.canLock(FTNone, FTUnsealed))
+
+	require.Equal(t, true, lk.canLock(ftAll, FTNone))
+	require.Equal(t, false, lk.canLock(FTNone, ftAll))
+
+	require.Equal(t, true, lk.canLock(FTNone, FTSealed|FTCache))
+	require.Equal(t, true, lk.canLock(FTUnsealed, FTSealed|FTCache))
+
+	lk.r[0] = 0
+
+	lk.w = FTSealed
+
+	require.Equal(t, true, lk.canLock(FTUnsealed, FTNone))
+	require.Equal(t, true, lk.canLock(FTNone, FTUnsealed))
+
+	require.Equal(t, false, lk.canLock(FTSealed, FTNone))
+	require.Equal(t, false, lk.canLock(FTNone, FTSealed))
+
+	require.Equal(t, false, lk.canLock(ftAll, FTNone))
+	require.Equal(t, false, lk.canLock(FTNone, ftAll))
+}
+
+func TestIndexLocksSeq(t *testing.T) {
+	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
+
+	ilk := &indexLocks{
+		locks: map[abi.SectorID]*sectorLock{},
+	}
+
+	require.NoError(t, ilk.StorageLock(ctx, aSector, FTNone, FTUnsealed))
+	cancel()
+
+	ctx, cancel = context.WithTimeout(context.Background(), time.Second)
+	require.NoError(t, ilk.StorageLock(ctx, aSector, FTNone, FTUnsealed))
+	cancel()
+
+	ctx, cancel = context.WithTimeout(context.Background(), time.Second)
+	require.NoError(t, ilk.StorageLock(ctx, aSector, FTNone, FTUnsealed))
+	cancel()
+
+	ctx, cancel = context.WithTimeout(context.Background(), time.Second)
+	require.NoError(t, ilk.StorageLock(ctx, aSector, FTUnsealed, FTNone))
+	cancel()
+
+	ctx, cancel = context.WithTimeout(context.Background(), time.Second)
+	require.NoError(t, ilk.StorageLock(ctx, aSector, FTNone, FTUnsealed))
+	cancel()
+
+	ctx, cancel = context.WithTimeout(context.Background(), time.Second)
+	require.NoError(t, ilk.StorageLock(ctx, aSector, FTNone, FTUnsealed))
+	cancel()
+}
+
+func TestIndexLocksBlockOn(t *testing.T) {
+	test := func(r1 SectorFileType, w1 SectorFileType, r2 SectorFileType, w2 SectorFileType) func(t *testing.T) {
+		return func(t *testing.T) {
+			ctx, cancel := context.WithCancel(context.Background())
+
+			ilk := &indexLocks{
+				locks: map[abi.SectorID]*sectorLock{},
+			}
+
+			require.NoError(t, ilk.StorageLock(ctx, aSector, r1, w1))
+
+			sch := make(chan struct{})
+			go func() {
+				ctx, cancel := context.WithCancel(context.Background())
+
+				sch <- struct{}{}
+
+				require.NoError(t, ilk.StorageLock(ctx, aSector, r2, w2))
+				cancel()
+
+				sch <- struct{}{}
+			}()
+
+			<-sch
+
+			select {
+			case <-sch:
+				t.Fatal("that shouldn't happen")
+			case <-time.After(40 * time.Millisecond):
+			}
+
+			cancel()
+
+			select {
+			case <-sch:
+			case <-time.After(time.Second):
+				t.Fatal("timed out")
+			}
+		}
+	}
+
+	t.Run("readBlocksWrite", test(FTUnsealed, FTNone, FTNone, FTUnsealed))
+	t.Run("writeBlocksRead", test(FTNone, FTUnsealed, FTUnsealed, FTNone))
+	t.Run("writeBlocksWrite", test(FTNone, FTUnsealed, FTNone, FTUnsealed))
+}
+
+func TestIndexLocksBlockWonR(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+
+	ilk := &indexLocks{
+		locks: map[abi.SectorID]*sectorLock{},
+	}
+
+	require.NoError(t, ilk.StorageLock(ctx, aSector, FTUnsealed, FTNone))
+
+	sch := make(chan struct{})
+	go func() {
+		ctx, cancel := context.WithCancel(context.Background())
+
+		sch <- struct{}{}
+
+		require.NoError(t, ilk.StorageLock(ctx, aSector, FTNone, FTUnsealed))
+		cancel()
+
+		sch <- struct{}{}
+	}()
+
+	<-sch
+
+	select {
+	case <-sch:
+		t.Fatal("that shouldn't happen")
+	case <-time.After(40 * time.Millisecond):
+	}
+
+	cancel()
+
+	select {
+	case <-sch:
+	case <-time.After(time.Second):
+		t.Fatal("timed out")
+	}
+}
diff --git a/extern/sector-storage/stores/index_locks_util.go b/extern/sector-storage/stores/index_locks_util.go
new file mode 100644
index 000000000..a8327fded
--- /dev/null
+++ b/extern/sector-storage/stores/index_locks_util.go
@@ -0,0 +1,49 @@
+package stores
+
+import (
+	"context"
+	"sync"
+)
+
+// like sync.Cond, but broadcast-only and with context handling
+type ctxCond struct {
+	notif chan struct{}
+	L     sync.Locker
+
+	lk sync.Mutex
+}
+
+func newCtxCond(l sync.Locker) *ctxCond {
+	return &ctxCond{
+		L: l,
+	}
+}
+
+func (c *ctxCond) Broadcast() {
+	c.lk.Lock()
+	if c.notif != nil {
+		close(c.notif)
+		c.notif = nil
+	}
+	c.lk.Unlock()
+}
+
+func (c *ctxCond) Wait(ctx context.Context) error {
+	c.lk.Lock()
+	if c.notif == nil {
+		c.notif = make(chan struct{})
+	}
+
+	wait := c.notif
+	c.lk.Unlock()
+
+	c.L.Unlock()
+	defer c.L.Lock()
+
+	select {
+	case <-wait:
+		return nil
+	case <-ctx.Done():
+		return ctx.Err()
+	}
+}
diff --git a/extern/sector-storage/stores/interface.go b/extern/sector-storage/stores/interface.go
new file mode 100644
index 000000000..875754fc5
--- /dev/null
+++ b/extern/sector-storage/stores/interface.go
@@ -0,0 +1,36 @@
+package stores
+
+import (
+	"context"
+
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/lotus/extern/sector-storage/fsutil"
+)
+
+type PathType string
+
+const (
+	PathStorage PathType = "storage"
+	PathSealing PathType = "sealing"
+)
+
+type AcquireMode string
+
+const (
+	AcquireMove AcquireMode = "move"
+	AcquireCopy AcquireMode = "copy"
+)
+
+type Store interface {
+	AcquireSector(ctx context.Context, s abi.SectorID, spt abi.RegisteredSealProof, existing SectorFileType, allocate SectorFileType, sealing PathType, op AcquireMode) (paths SectorPaths, stores SectorPaths, err error)
+	Remove(ctx context.Context, s abi.SectorID, types SectorFileType, force bool) error
+
+	// like remove, but doesn't remove the primary sector copy, nor the last
+	// non-primary copy if there no primary copies
+	RemoveCopies(ctx context.Context, s abi.SectorID, types SectorFileType) error
+
+	// move sectors into storage
+	MoveStorage(ctx context.Context, s abi.SectorID, spt abi.RegisteredSealProof, types SectorFileType) error
+
+	FsStat(ctx context.Context, id ID) (fsutil.FsStat, error)
+}
diff --git a/extern/sector-storage/stores/local.go b/extern/sector-storage/stores/local.go
new file mode 100644
index 000000000..75387acc8
--- /dev/null
+++ b/extern/sector-storage/stores/local.go
@@ -0,0 +1,592 @@
+package stores
+
+import (
+	"context"
+	"encoding/json"
+	"io/ioutil"
+	"math/bits"
+	"math/rand"
+	"os"
+	"path/filepath"
+	"sync"
+	"time"
+
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-state-types/abi"
+
+	"github.com/filecoin-project/lotus/extern/sector-storage/fsutil"
+)
+
+type StoragePath struct {
+	ID     ID
+	Weight uint64
+
+	LocalPath string
+
+	CanSeal  bool
+	CanStore bool
+}
+
+// LocalStorageMeta [path]/sectorstore.json
+type LocalStorageMeta struct {
+	ID     ID
+	Weight uint64 // 0 = readonly
+
+	CanSeal  bool
+	CanStore bool
+}
+
+// StorageConfig .lotusstorage/storage.json
+type StorageConfig struct {
+	StoragePaths []LocalPath
+}
+
+type LocalPath struct {
+	Path string
+}
+
+type LocalStorage interface {
+	GetStorage() (StorageConfig, error)
+	SetStorage(func(*StorageConfig)) error
+
+	Stat(path string) (fsutil.FsStat, error)
+
+	// returns real disk usage for a file/directory
+	// os.ErrNotExit when file doesn't exist
+	DiskUsage(path string) (int64, error)
+}
+
+const MetaFile = "sectorstore.json"
+
+var PathTypes = []SectorFileType{FTUnsealed, FTSealed, FTCache}
+
+type Local struct {
+	localStorage LocalStorage
+	index        SectorIndex
+	urls         []string
+
+	paths map[ID]*path
+
+	localLk sync.RWMutex
+}
+
+type path struct {
+	local string // absolute local path
+
+	reserved     int64
+	reservations map[abi.SectorID]SectorFileType
+}
+
+func (p *path) stat(ls LocalStorage) (fsutil.FsStat, error) {
+	stat, err := ls.Stat(p.local)
+	if err != nil {
+		return fsutil.FsStat{}, xerrors.Errorf("stat %s: %w", p.local, err)
+	}
+
+	stat.Reserved = p.reserved
+
+	for id, ft := range p.reservations {
+		for _, fileType := range PathTypes {
+			if fileType&ft == 0 {
+				continue
+			}
+
+			sp := p.sectorPath(id, fileType)
+
+			used, err := ls.DiskUsage(sp)
+			if err == os.ErrNotExist {
+				p, ferr := tempFetchDest(sp, false)
+				if ferr != nil {
+					return fsutil.FsStat{}, ferr
+				}
+
+				used, err = ls.DiskUsage(p)
+			}
+			if err != nil {
+				log.Errorf("getting disk usage of '%s': %+v", p.sectorPath(id, fileType), err)
+				continue
+			}
+
+			stat.Reserved -= used
+		}
+	}
+
+	if stat.Reserved < 0 {
+		log.Warnf("negative reserved storage: p.reserved=%d, reserved: %d", p.reserved, stat.Reserved)
+		stat.Reserved = 0
+	}
+
+	stat.Available -= stat.Reserved
+	if stat.Available < 0 {
+		stat.Available = 0
+	}
+
+	return stat, err
+}
+
+func (p *path) sectorPath(sid abi.SectorID, fileType SectorFileType) string {
+	return filepath.Join(p.local, fileType.String(), SectorName(sid))
+}
+
+func NewLocal(ctx context.Context, ls LocalStorage, index SectorIndex, urls []string) (*Local, error) {
+	l := &Local{
+		localStorage: ls,
+		index:        index,
+		urls:         urls,
+
+		paths: map[ID]*path{},
+	}
+	return l, l.open(ctx)
+}
+
+func (st *Local) OpenPath(ctx context.Context, p string) error {
+	st.localLk.Lock()
+	defer st.localLk.Unlock()
+
+	mb, err := ioutil.ReadFile(filepath.Join(p, MetaFile))
+	if err != nil {
+		return xerrors.Errorf("reading storage metadata for %s: %w", p, err)
+	}
+
+	var meta LocalStorageMeta
+	if err := json.Unmarshal(mb, &meta); err != nil {
+		return xerrors.Errorf("unmarshalling storage metadata for %s: %w", p, err)
+	}
+
+	// TODO: Check existing / dedupe
+
+	out := &path{
+		local: p,
+
+		reserved:     0,
+		reservations: map[abi.SectorID]SectorFileType{},
+	}
+
+	fst, err := out.stat(st.localStorage)
+	if err != nil {
+		return err
+	}
+
+	err = st.index.StorageAttach(ctx, StorageInfo{
+		ID:       meta.ID,
+		URLs:     st.urls,
+		Weight:   meta.Weight,
+		CanSeal:  meta.CanSeal,
+		CanStore: meta.CanStore,
+	}, fst)
+	if err != nil {
+		return xerrors.Errorf("declaring storage in index: %w", err)
+	}
+
+	for _, t := range PathTypes {
+		ents, err := ioutil.ReadDir(filepath.Join(p, t.String()))
+		if err != nil {
+			if os.IsNotExist(err) {
+				if err := os.MkdirAll(filepath.Join(p, t.String()), 0755); err != nil { // nolint
+					return xerrors.Errorf("openPath mkdir '%s': %w", filepath.Join(p, t.String()), err)
+				}
+
+				continue
+			}
+			return xerrors.Errorf("listing %s: %w", filepath.Join(p, t.String()), err)
+		}
+
+		for _, ent := range ents {
+			if ent.Name() == FetchTempSubdir {
+				continue
+			}
+
+			sid, err := ParseSectorID(ent.Name())
+			if err != nil {
+				return xerrors.Errorf("parse sector id %s: %w", ent.Name(), err)
+			}
+
+			if err := st.index.StorageDeclareSector(ctx, meta.ID, sid, t, meta.CanStore); err != nil {
+				return xerrors.Errorf("declare sector %d(t:%d) -> %s: %w", sid, t, meta.ID, err)
+			}
+		}
+	}
+
+	st.paths[meta.ID] = out
+
+	return nil
+}
+
+func (st *Local) open(ctx context.Context) error {
+	cfg, err := st.localStorage.GetStorage()
+	if err != nil {
+		return xerrors.Errorf("getting local storage config: %w", err)
+	}
+
+	for _, path := range cfg.StoragePaths {
+		err := st.OpenPath(ctx, path.Path)
+		if err != nil {
+			return xerrors.Errorf("opening path %s: %w", path.Path, err)
+		}
+	}
+
+	go st.reportHealth(ctx)
+
+	return nil
+}
+
+func (st *Local) reportHealth(ctx context.Context) {
+	// randomize interval by ~10%
+	interval := (HeartbeatInterval*100_000 + time.Duration(rand.Int63n(10_000))) / 100_000
+
+	for {
+		select {
+		case <-time.After(interval):
+		case <-ctx.Done():
+			return
+		}
+
+		st.localLk.RLock()
+
+		toReport := map[ID]HealthReport{}
+		for id, p := range st.paths {
+			stat, err := p.stat(st.localStorage)
+
+			toReport[id] = HealthReport{
+				Stat: stat,
+				Err:  err,
+			}
+		}
+
+		st.localLk.RUnlock()
+
+		for id, report := range toReport {
+			if err := st.index.StorageReportHealth(ctx, id, report); err != nil {
+				log.Warnf("error reporting storage health for %s: %+v", id, report)
+			}
+		}
+	}
+}
+
+func (st *Local) Reserve(ctx context.Context, sid abi.SectorID, spt abi.RegisteredSealProof, ft SectorFileType, storageIDs SectorPaths, overheadTab map[SectorFileType]int) (func(), error) {
+	ssize, err := spt.SectorSize()
+	if err != nil {
+		return nil, xerrors.Errorf("getting sector size: %w", err)
+	}
+
+	st.localLk.Lock()
+
+	done := func() {}
+	deferredDone := func() { done() }
+	defer func() {
+		st.localLk.Unlock()
+		deferredDone()
+	}()
+
+	for _, fileType := range PathTypes {
+		if fileType&ft == 0 {
+			continue
+		}
+
+		id := ID(PathByType(storageIDs, fileType))
+
+		p, ok := st.paths[id]
+		if !ok {
+			return nil, errPathNotFound
+		}
+
+		stat, err := p.stat(st.localStorage)
+		if err != nil {
+			return nil, xerrors.Errorf("getting local storage stat: %w", err)
+		}
+
+		overhead := int64(overheadTab[fileType]) * int64(ssize) / FSOverheadDen
+
+		if stat.Available < overhead {
+			return nil, xerrors.Errorf("can't reserve %d bytes in '%s' (id:%s), only %d available", overhead, p.local, id, stat.Available)
+		}
+
+		p.reserved += overhead
+
+		prevDone := done
+		done = func() {
+			prevDone()
+
+			st.localLk.Lock()
+			defer st.localLk.Unlock()
+
+			p.reserved -= overhead
+		}
+	}
+
+	deferredDone = func() {}
+	return done, nil
+}
+
+func (st *Local) AcquireSector(ctx context.Context, sid abi.SectorID, spt abi.RegisteredSealProof, existing SectorFileType, allocate SectorFileType, pathType PathType, op AcquireMode) (SectorPaths, SectorPaths, error) {
+	if existing|allocate != existing^allocate {
+		return SectorPaths{}, SectorPaths{}, xerrors.New("can't both find and allocate a sector")
+	}
+
+	st.localLk.RLock()
+	defer st.localLk.RUnlock()
+
+	var out SectorPaths
+	var storageIDs SectorPaths
+
+	for _, fileType := range PathTypes {
+		if fileType&existing == 0 {
+			continue
+		}
+
+		si, err := st.index.StorageFindSector(ctx, sid, fileType, spt, false)
+		if err != nil {
+			log.Warnf("finding existing sector %d(t:%d) failed: %+v", sid, fileType, err)
+			continue
+		}
+
+		for _, info := range si {
+			p, ok := st.paths[info.ID]
+			if !ok {
+				continue
+			}
+
+			if p.local == "" { // TODO: can that even be the case?
+				continue
+			}
+
+			spath := p.sectorPath(sid, fileType)
+			SetPathByType(&out, fileType, spath)
+			SetPathByType(&storageIDs, fileType, string(info.ID))
+
+			existing ^= fileType
+			break
+		}
+	}
+
+	for _, fileType := range PathTypes {
+		if fileType&allocate == 0 {
+			continue
+		}
+
+		sis, err := st.index.StorageBestAlloc(ctx, fileType, spt, pathType)
+		if err != nil {
+			return SectorPaths{}, SectorPaths{}, xerrors.Errorf("finding best storage for allocating : %w", err)
+		}
+
+		var best string
+		var bestID ID
+
+		for _, si := range sis {
+			p, ok := st.paths[si.ID]
+			if !ok {
+				continue
+			}
+
+			if p.local == "" { // TODO: can that even be the case?
+				continue
+			}
+
+			if (pathType == PathSealing) && !si.CanSeal {
+				continue
+			}
+
+			if (pathType == PathStorage) && !si.CanStore {
+				continue
+			}
+
+			// TODO: Check free space
+
+			best = p.sectorPath(sid, fileType)
+			bestID = si.ID
+			break
+		}
+
+		if best == "" {
+			return SectorPaths{}, SectorPaths{}, xerrors.Errorf("couldn't find a suitable path for a sector")
+		}
+
+		SetPathByType(&out, fileType, best)
+		SetPathByType(&storageIDs, fileType, string(bestID))
+		allocate ^= fileType
+	}
+
+	return out, storageIDs, nil
+}
+
+func (st *Local) Local(ctx context.Context) ([]StoragePath, error) {
+	st.localLk.RLock()
+	defer st.localLk.RUnlock()
+
+	var out []StoragePath
+	for id, p := range st.paths {
+		if p.local == "" {
+			continue
+		}
+
+		si, err := st.index.StorageInfo(ctx, id)
+		if err != nil {
+			return nil, xerrors.Errorf("get storage info for %s: %w", id, err)
+		}
+
+		out = append(out, StoragePath{
+			ID:        id,
+			Weight:    si.Weight,
+			LocalPath: p.local,
+			CanSeal:   si.CanSeal,
+			CanStore:  si.CanStore,
+		})
+	}
+
+	return out, nil
+}
+
+func (st *Local) Remove(ctx context.Context, sid abi.SectorID, typ SectorFileType, force bool) error {
+	if bits.OnesCount(uint(typ)) != 1 {
+		return xerrors.New("delete expects one file type")
+	}
+
+	si, err := st.index.StorageFindSector(ctx, sid, typ, 0, false)
+	if err != nil {
+		return xerrors.Errorf("finding existing sector %d(t:%d) failed: %w", sid, typ, err)
+	}
+
+	if len(si) == 0 && !force {
+		return xerrors.Errorf("can't delete sector %v(%d), not found", sid, typ)
+	}
+
+	for _, info := range si {
+		if err := st.removeSector(ctx, sid, typ, info.ID); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (st *Local) RemoveCopies(ctx context.Context, sid abi.SectorID, typ SectorFileType) error {
+	if bits.OnesCount(uint(typ)) != 1 {
+		return xerrors.New("delete expects one file type")
+	}
+
+	si, err := st.index.StorageFindSector(ctx, sid, typ, 0, false)
+	if err != nil {
+		return xerrors.Errorf("finding existing sector %d(t:%d) failed: %w", sid, typ, err)
+	}
+
+	var hasPrimary bool
+	for _, info := range si {
+		if info.Primary {
+			hasPrimary = true
+			break
+		}
+	}
+
+	if !hasPrimary {
+		log.Warnf("RemoveCopies: no primary copies of sector %v (%s), not removing anything", sid, typ)
+		return nil
+	}
+
+	for _, info := range si {
+		if info.Primary {
+			continue
+		}
+
+		if err := st.removeSector(ctx, sid, typ, info.ID); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (st *Local) removeSector(ctx context.Context, sid abi.SectorID, typ SectorFileType, storage ID) error {
+	p, ok := st.paths[storage]
+	if !ok {
+		return nil
+	}
+
+	if p.local == "" { // TODO: can that even be the case?
+		return nil
+	}
+
+	if err := st.index.StorageDropSector(ctx, storage, sid, typ); err != nil {
+		return xerrors.Errorf("dropping sector from index: %w", err)
+	}
+
+	spath := p.sectorPath(sid, typ)
+	log.Infof("remove %s", spath)
+
+	if err := os.RemoveAll(spath); err != nil {
+		log.Errorf("removing sector (%v) from %s: %+v", sid, spath, err)
+	}
+
+	return nil
+}
+
+func (st *Local) MoveStorage(ctx context.Context, s abi.SectorID, spt abi.RegisteredSealProof, types SectorFileType) error {
+	dest, destIds, err := st.AcquireSector(ctx, s, spt, FTNone, types, PathStorage, AcquireMove)
+	if err != nil {
+		return xerrors.Errorf("acquire dest storage: %w", err)
+	}
+
+	src, srcIds, err := st.AcquireSector(ctx, s, spt, types, FTNone, PathStorage, AcquireMove)
+	if err != nil {
+		return xerrors.Errorf("acquire src storage: %w", err)
+	}
+
+	for _, fileType := range PathTypes {
+		if fileType&types == 0 {
+			continue
+		}
+
+		sst, err := st.index.StorageInfo(ctx, ID(PathByType(srcIds, fileType)))
+		if err != nil {
+			return xerrors.Errorf("failed to get source storage info: %w", err)
+		}
+
+		dst, err := st.index.StorageInfo(ctx, ID(PathByType(destIds, fileType)))
+		if err != nil {
+			return xerrors.Errorf("failed to get source storage info: %w", err)
+		}
+
+		if sst.ID == dst.ID {
+			log.Debugf("not moving %v(%d); src and dest are the same", s, fileType)
+			continue
+		}
+
+		if sst.CanStore {
+			log.Debugf("not moving %v(%d); source supports storage", s, fileType)
+			continue
+		}
+
+		log.Debugf("moving %v(%d) to storage: %s(se:%t; st:%t) -> %s(se:%t; st:%t)", s, fileType, sst.ID, sst.CanSeal, sst.CanStore, dst.ID, dst.CanSeal, dst.CanStore)
+
+		if err := st.index.StorageDropSector(ctx, ID(PathByType(srcIds, fileType)), s, fileType); err != nil {
+			return xerrors.Errorf("dropping source sector from index: %w", err)
+		}
+
+		if err := move(PathByType(src, fileType), PathByType(dest, fileType)); err != nil {
+			// TODO: attempt some recovery (check if src is still there, re-declare)
+			return xerrors.Errorf("moving sector %v(%d): %w", s, fileType, err)
+		}
+
+		if err := st.index.StorageDeclareSector(ctx, ID(PathByType(destIds, fileType)), s, fileType, true); err != nil {
+			return xerrors.Errorf("declare sector %d(t:%d) -> %s: %w", s, fileType, ID(PathByType(destIds, fileType)), err)
+		}
+	}
+
+	return nil
+}
+
+var errPathNotFound = xerrors.Errorf("fsstat: path not found")
+
+func (st *Local) FsStat(ctx context.Context, id ID) (fsutil.FsStat, error) {
+	st.localLk.RLock()
+	defer st.localLk.RUnlock()
+
+	p, ok := st.paths[id]
+	if !ok {
+		return fsutil.FsStat{}, errPathNotFound
+	}
+
+	return p.stat(st.localStorage)
+}
+
+var _ Store = &Local{}
diff --git a/extern/sector-storage/stores/local_test.go b/extern/sector-storage/stores/local_test.go
new file mode 100644
index 000000000..1c31e8c09
--- /dev/null
+++ b/extern/sector-storage/stores/local_test.go
@@ -0,0 +1,95 @@
+package stores
+
+import (
+	"context"
+	"encoding/json"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/filecoin-project/lotus/extern/sector-storage/fsutil"
+
+	"github.com/google/uuid"
+	"github.com/stretchr/testify/require"
+)
+
+const pathSize = 16 << 20
+
+type TestingLocalStorage struct {
+	root string
+	c    StorageConfig
+}
+
+func (t *TestingLocalStorage) DiskUsage(path string) (int64, error) {
+	return 1, nil
+}
+
+func (t *TestingLocalStorage) GetStorage() (StorageConfig, error) {
+	return t.c, nil
+}
+
+func (t *TestingLocalStorage) SetStorage(f func(*StorageConfig)) error {
+	f(&t.c)
+	return nil
+}
+
+func (t *TestingLocalStorage) Stat(path string) (fsutil.FsStat, error) {
+	return fsutil.FsStat{
+		Capacity:  pathSize,
+		Available: pathSize,
+	}, nil
+}
+
+func (t *TestingLocalStorage) init(subpath string) error {
+	path := filepath.Join(t.root, subpath)
+	if err := os.Mkdir(path, 0755); err != nil {
+		return err
+	}
+
+	metaFile := filepath.Join(path, MetaFile)
+
+	meta := &LocalStorageMeta{
+		ID:       ID(uuid.New().String()),
+		Weight:   1,
+		CanSeal:  true,
+		CanStore: true,
+	}
+
+	mb, err := json.MarshalIndent(meta, "", "  ")
+	if err != nil {
+		return err
+	}
+
+	if err := ioutil.WriteFile(metaFile, mb, 0644); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+var _ LocalStorage = &TestingLocalStorage{}
+
+func TestLocalStorage(t *testing.T) {
+	ctx := context.TODO()
+
+	root, err := ioutil.TempDir("", "sector-storage-teststorage-")
+	require.NoError(t, err)
+
+	tstor := &TestingLocalStorage{
+		root: root,
+	}
+
+	index := NewIndex()
+
+	st, err := NewLocal(ctx, tstor, index, nil)
+	require.NoError(t, err)
+
+	p1 := "1"
+	require.NoError(t, tstor.init("1"))
+
+	err = st.OpenPath(ctx, filepath.Join(tstor.root, p1))
+	require.NoError(t, err)
+
+	// TODO: put more things here
+}
diff --git a/extern/sector-storage/stores/remote.go b/extern/sector-storage/stores/remote.go
new file mode 100644
index 000000000..b9d241b5f
--- /dev/null
+++ b/extern/sector-storage/stores/remote.go
@@ -0,0 +1,406 @@
+package stores
+
+import (
+	"context"
+	"encoding/json"
+	"io/ioutil"
+	"math/bits"
+	"mime"
+	"net/http"
+	"net/url"
+	"os"
+	gopath "path"
+	"path/filepath"
+	"sort"
+	"sync"
+
+	"github.com/filecoin-project/lotus/extern/sector-storage/fsutil"
+	"github.com/filecoin-project/lotus/extern/sector-storage/storiface"
+	"github.com/filecoin-project/lotus/extern/sector-storage/tarutil"
+
+	"github.com/filecoin-project/go-state-types/abi"
+
+	"github.com/hashicorp/go-multierror"
+	files "github.com/ipfs/go-ipfs-files"
+	"golang.org/x/xerrors"
+)
+
+var FetchTempSubdir = "fetching"
+
+type Remote struct {
+	local *Local
+	index SectorIndex
+	auth  http.Header
+
+	limit chan struct{}
+
+	fetchLk  sync.Mutex
+	fetching map[abi.SectorID]chan struct{}
+}
+
+func (r *Remote) RemoveCopies(ctx context.Context, s abi.SectorID, types SectorFileType) error {
+	// TODO: do this on remotes too
+	//  (not that we really need to do that since it's always called by the
+	//   worker which pulled the copy)
+
+	return r.local.RemoveCopies(ctx, s, types)
+}
+
+func NewRemote(local *Local, index SectorIndex, auth http.Header, fetchLimit int) *Remote {
+	return &Remote{
+		local: local,
+		index: index,
+		auth:  auth,
+
+		limit: make(chan struct{}, fetchLimit),
+
+		fetching: map[abi.SectorID]chan struct{}{},
+	}
+}
+
+func (r *Remote) AcquireSector(ctx context.Context, s abi.SectorID, spt abi.RegisteredSealProof, existing SectorFileType, allocate SectorFileType, pathType PathType, op AcquireMode) (SectorPaths, SectorPaths, error) {
+	if existing|allocate != existing^allocate {
+		return SectorPaths{}, SectorPaths{}, xerrors.New("can't both find and allocate a sector")
+	}
+
+	for {
+		r.fetchLk.Lock()
+
+		c, locked := r.fetching[s]
+		if !locked {
+			r.fetching[s] = make(chan struct{})
+			r.fetchLk.Unlock()
+			break
+		}
+
+		r.fetchLk.Unlock()
+
+		select {
+		case <-c:
+			continue
+		case <-ctx.Done():
+			return SectorPaths{}, SectorPaths{}, ctx.Err()
+		}
+	}
+
+	defer func() {
+		r.fetchLk.Lock()
+		close(r.fetching[s])
+		delete(r.fetching, s)
+		r.fetchLk.Unlock()
+	}()
+
+	paths, stores, err := r.local.AcquireSector(ctx, s, spt, existing, allocate, pathType, op)
+	if err != nil {
+		return SectorPaths{}, SectorPaths{}, xerrors.Errorf("local acquire error: %w", err)
+	}
+
+	var toFetch SectorFileType
+	for _, fileType := range PathTypes {
+		if fileType&existing == 0 {
+			continue
+		}
+
+		if PathByType(paths, fileType) == "" {
+			toFetch |= fileType
+		}
+	}
+
+	apaths, ids, err := r.local.AcquireSector(ctx, s, spt, FTNone, toFetch, pathType, op)
+	if err != nil {
+		return SectorPaths{}, SectorPaths{}, xerrors.Errorf("allocate local sector for fetching: %w", err)
+	}
+
+	odt := FSOverheadSeal
+	if pathType == PathStorage {
+		odt = FsOverheadFinalized
+	}
+
+	releaseStorage, err := r.local.Reserve(ctx, s, spt, toFetch, ids, odt)
+	if err != nil {
+		return SectorPaths{}, SectorPaths{}, xerrors.Errorf("reserving storage space: %w", err)
+	}
+	defer releaseStorage()
+
+	for _, fileType := range PathTypes {
+		if fileType&existing == 0 {
+			continue
+		}
+
+		if PathByType(paths, fileType) != "" {
+			continue
+		}
+
+		dest := PathByType(apaths, fileType)
+		storageID := PathByType(ids, fileType)
+
+		url, err := r.acquireFromRemote(ctx, s, fileType, dest)
+		if err != nil {
+			return SectorPaths{}, SectorPaths{}, err
+		}
+
+		SetPathByType(&paths, fileType, dest)
+		SetPathByType(&stores, fileType, storageID)
+
+		if err := r.index.StorageDeclareSector(ctx, ID(storageID), s, fileType, op == AcquireMove); err != nil {
+			log.Warnf("declaring sector %v in %s failed: %+v", s, storageID, err)
+			continue
+		}
+
+		if op == AcquireMove {
+			if err := r.deleteFromRemote(ctx, url); err != nil {
+				log.Warnf("deleting sector %v from %s (delete %s): %+v", s, storageID, url, err)
+			}
+		}
+	}
+
+	return paths, stores, nil
+}
+
+func tempFetchDest(spath string, create bool) (string, error) {
+	st, b := filepath.Split(spath)
+	tempdir := filepath.Join(st, FetchTempSubdir)
+	if create {
+		if err := os.MkdirAll(tempdir, 0755); err != nil { // nolint
+			return "", xerrors.Errorf("creating temp fetch dir: %w", err)
+		}
+	}
+
+	return filepath.Join(tempdir, b), nil
+}
+
+func (r *Remote) acquireFromRemote(ctx context.Context, s abi.SectorID, fileType SectorFileType, dest string) (string, error) {
+	si, err := r.index.StorageFindSector(ctx, s, fileType, 0, false)
+	if err != nil {
+		return "", err
+	}
+
+	if len(si) == 0 {
+		return "", xerrors.Errorf("failed to acquire sector %v from remote(%d): %w", s, fileType, storiface.ErrSectorNotFound)
+	}
+
+	sort.Slice(si, func(i, j int) bool {
+		return si[i].Weight < si[j].Weight
+	})
+
+	var merr error
+	for _, info := range si {
+		// TODO: see what we have local, prefer that
+
+		for _, url := range info.URLs {
+			tempDest, err := tempFetchDest(dest, true)
+			if err != nil {
+				return "", err
+			}
+
+			if err := os.RemoveAll(dest); err != nil {
+				return "", xerrors.Errorf("removing dest: %w", err)
+			}
+
+			err = r.fetch(ctx, url, tempDest)
+			if err != nil {
+				merr = multierror.Append(merr, xerrors.Errorf("fetch error %s (storage %s) -> %s: %w", url, info.ID, tempDest, err))
+				continue
+			}
+
+			if err := move(tempDest, dest); err != nil {
+				return "", xerrors.Errorf("fetch move error (storage %s) %s -> %s: %w", info.ID, tempDest, dest, err)
+			}
+
+			if merr != nil {
+				log.Warnw("acquireFromRemote encountered errors when fetching sector from remote", "errors", merr)
+			}
+			return url, nil
+		}
+	}
+
+	return "", xerrors.Errorf("failed to acquire sector %v from remote (tried %v): %w", s, si, merr)
+}
+
+func (r *Remote) fetch(ctx context.Context, url, outname string) error {
+	log.Infof("Fetch %s -> %s", url, outname)
+
+	if len(r.limit) >= cap(r.limit) {
+		log.Infof("Throttling fetch, %d already running", len(r.limit))
+	}
+
+	// TODO: Smarter throttling
+	//  * Priority (just going sequentially is still pretty good)
+	//  * Per interface
+	//  * Aware of remote load
+	select {
+	case r.limit <- struct{}{}:
+		defer func() { <-r.limit }()
+	case <-ctx.Done():
+		return xerrors.Errorf("context error while waiting for fetch limiter: %w", ctx.Err())
+	}
+
+	req, err := http.NewRequest("GET", url, nil)
+	if err != nil {
+		return xerrors.Errorf("request: %w", err)
+	}
+	req.Header = r.auth
+	req = req.WithContext(ctx)
+
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return xerrors.Errorf("do request: %w", err)
+	}
+	defer resp.Body.Close() // nolint
+
+	if resp.StatusCode != 200 {
+		return xerrors.Errorf("non-200 code: %d", resp.StatusCode)
+	}
+
+	/*bar := pb.New64(w.sizeForType(typ))
+	bar.ShowPercent = true
+	bar.ShowSpeed = true
+	bar.Units = pb.U_BYTES
+
+	barreader := bar.NewProxyReader(resp.Body)
+
+	bar.Start()
+	defer bar.Finish()*/
+
+	mediatype, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
+	if err != nil {
+		return xerrors.Errorf("parse media type: %w", err)
+	}
+
+	if err := os.RemoveAll(outname); err != nil {
+		return xerrors.Errorf("removing dest: %w", err)
+	}
+
+	switch mediatype {
+	case "application/x-tar":
+		return tarutil.ExtractTar(resp.Body, outname)
+	case "application/octet-stream":
+		return files.WriteTo(files.NewReaderFile(resp.Body), outname)
+	default:
+		return xerrors.Errorf("unknown content type: '%s'", mediatype)
+	}
+}
+
+func (r *Remote) MoveStorage(ctx context.Context, s abi.SectorID, spt abi.RegisteredSealProof, types SectorFileType) error {
+	// Make sure we have the data local
+	_, _, err := r.AcquireSector(ctx, s, spt, types, FTNone, PathStorage, AcquireMove)
+	if err != nil {
+		return xerrors.Errorf("acquire src storage (remote): %w", err)
+	}
+
+	return r.local.MoveStorage(ctx, s, spt, types)
+}
+
+func (r *Remote) Remove(ctx context.Context, sid abi.SectorID, typ SectorFileType, force bool) error {
+	if bits.OnesCount(uint(typ)) != 1 {
+		return xerrors.New("delete expects one file type")
+	}
+
+	if err := r.local.Remove(ctx, sid, typ, force); err != nil {
+		return xerrors.Errorf("remove from local: %w", err)
+	}
+
+	si, err := r.index.StorageFindSector(ctx, sid, typ, 0, false)
+	if err != nil {
+		return xerrors.Errorf("finding existing sector %d(t:%d) failed: %w", sid, typ, err)
+	}
+
+	for _, info := range si {
+		for _, url := range info.URLs {
+			if err := r.deleteFromRemote(ctx, url); err != nil {
+				log.Warnf("remove %s: %+v", url, err)
+				continue
+			}
+			break
+		}
+	}
+
+	return nil
+}
+
+func (r *Remote) deleteFromRemote(ctx context.Context, url string) error {
+	log.Infof("Delete %s", url)
+
+	req, err := http.NewRequest("DELETE", url, nil)
+	if err != nil {
+		return xerrors.Errorf("request: %w", err)
+	}
+	req.Header = r.auth
+	req = req.WithContext(ctx)
+
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return xerrors.Errorf("do request: %w", err)
+	}
+	defer resp.Body.Close() // nolint
+
+	if resp.StatusCode != 200 {
+		return xerrors.Errorf("non-200 code: %d", resp.StatusCode)
+	}
+
+	return nil
+}
+
+func (r *Remote) FsStat(ctx context.Context, id ID) (fsutil.FsStat, error) {
+	st, err := r.local.FsStat(ctx, id)
+	switch err {
+	case nil:
+		return st, nil
+	case errPathNotFound:
+		break
+	default:
+		return fsutil.FsStat{}, xerrors.Errorf("local stat: %w", err)
+	}
+
+	si, err := r.index.StorageInfo(ctx, id)
+	if err != nil {
+		return fsutil.FsStat{}, xerrors.Errorf("getting remote storage info: %w", err)
+	}
+
+	if len(si.URLs) == 0 {
+		return fsutil.FsStat{}, xerrors.Errorf("no known URLs for remote storage %s", id)
+	}
+
+	rl, err := url.Parse(si.URLs[0])
+	if err != nil {
+		return fsutil.FsStat{}, xerrors.Errorf("failed to parse url: %w", err)
+	}
+
+	rl.Path = gopath.Join(rl.Path, "stat", string(id))
+
+	req, err := http.NewRequest("GET", rl.String(), nil)
+	if err != nil {
+		return fsutil.FsStat{}, xerrors.Errorf("request: %w", err)
+	}
+	req.Header = r.auth
+	req = req.WithContext(ctx)
+
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return fsutil.FsStat{}, xerrors.Errorf("do request: %w", err)
+	}
+	switch resp.StatusCode {
+	case 200:
+		break
+	case 404:
+		return fsutil.FsStat{}, errPathNotFound
+	case 500:
+		b, err := ioutil.ReadAll(resp.Body)
+		if err != nil {
+			return fsutil.FsStat{}, xerrors.Errorf("fsstat: got http 500, then failed to read the error: %w", err)
+		}
+
+		return fsutil.FsStat{}, xerrors.Errorf("fsstat: got http 500: %s", string(b))
+	}
+
+	var out fsutil.FsStat
+	if err := json.NewDecoder(resp.Body).Decode(&out); err != nil {
+		return fsutil.FsStat{}, xerrors.Errorf("decoding fsstat: %w", err)
+	}
+
+	defer resp.Body.Close() // nolint
+
+	return out, nil
+}
+
+var _ Store = &Remote{}
diff --git a/extern/sector-storage/stores/util_unix.go b/extern/sector-storage/stores/util_unix.go
new file mode 100644
index 000000000..2b057468d
--- /dev/null
+++ b/extern/sector-storage/stores/util_unix.go
@@ -0,0 +1,43 @@
+package stores
+
+import (
+	"bytes"
+	"os/exec"
+	"path/filepath"
+	"strings"
+
+	"github.com/mitchellh/go-homedir"
+	"golang.org/x/xerrors"
+)
+
+func move(from, to string) error {
+	from, err := homedir.Expand(from)
+	if err != nil {
+		return xerrors.Errorf("move: expanding from: %w", err)
+	}
+
+	to, err = homedir.Expand(to)
+	if err != nil {
+		return xerrors.Errorf("move: expanding to: %w", err)
+	}
+
+	if filepath.Base(from) != filepath.Base(to) {
+		return xerrors.Errorf("move: base names must match ('%s' != '%s')", filepath.Base(from), filepath.Base(to))
+	}
+
+	log.Debugw("move sector data", "from", from, "to", to)
+
+	toDir := filepath.Dir(to)
+
+	// `mv` has decades of experience in moving files quickly; don't pretend we
+	//  can do better
+
+	var errOut bytes.Buffer
+	cmd := exec.Command("/usr/bin/env", "mv", "-t", toDir, from) // nolint
+	cmd.Stderr = &errOut
+	if err := cmd.Run(); err != nil {
+		return xerrors.Errorf("exec mv (stderr: %s): %w", strings.TrimSpace(errOut.String()), err)
+	}
+
+	return nil
+}
diff --git a/extern/sector-storage/storiface/ffi.go b/extern/sector-storage/storiface/ffi.go
new file mode 100644
index 000000000..95d400e52
--- /dev/null
+++ b/extern/sector-storage/storiface/ffi.go
@@ -0,0 +1,17 @@
+package storiface
+
+import (
+	"errors"
+
+	"github.com/filecoin-project/go-state-types/abi"
+)
+
+var ErrSectorNotFound = errors.New("sector not found")
+
+type UnpaddedByteIndex uint64
+
+func (i UnpaddedByteIndex) Padded() PaddedByteIndex {
+	return PaddedByteIndex(abi.UnpaddedPieceSize(i).Padded())
+}
+
+type PaddedByteIndex uint64
diff --git a/extern/sector-storage/storiface/worker.go b/extern/sector-storage/storiface/worker.go
new file mode 100644
index 000000000..25e3175bd
--- /dev/null
+++ b/extern/sector-storage/storiface/worker.go
@@ -0,0 +1,42 @@
+package storiface
+
+import (
+	"time"
+
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/lotus/extern/sector-storage/sealtasks"
+)
+
+type WorkerInfo struct {
+	Hostname string
+
+	Resources WorkerResources
+}
+
+type WorkerResources struct {
+	MemPhysical uint64
+	MemSwap     uint64
+
+	MemReserved uint64 // Used by system / other processes
+
+	CPUs uint64 // Logical cores
+	GPUs []string
+}
+
+type WorkerStats struct {
+	Info WorkerInfo
+
+	MemUsedMin uint64
+	MemUsedMax uint64
+	GpuUsed    bool   // nolint
+	CpuUse     uint64 // nolint
+}
+
+type WorkerJob struct {
+	ID     uint64
+	Sector abi.SectorID
+	Task   sealtasks.TaskType
+
+	RunWait int // 0 - running, 1+ - assigned
+	Start   time.Time
+}
diff --git a/lib/tarutil/systar.go b/extern/sector-storage/tarutil/systar.go
similarity index 86%
rename from lib/tarutil/systar.go
rename to extern/sector-storage/tarutil/systar.go
index 67a87d321..2329aafc7 100644
--- a/lib/tarutil/systar.go
+++ b/extern/sector-storage/tarutil/systar.go
@@ -2,19 +2,20 @@ package tarutil
 
 import (
 	"archive/tar"
-	"golang.org/x/xerrors"
 	"io"
 	"io/ioutil"
 	"os"
 	"path/filepath"
 
-	logging "github.com/ipfs/go-log"
+	"golang.org/x/xerrors"
+
+	logging "github.com/ipfs/go-log/v2"
 )
 
-var log = logging.Logger("tarutil")
+var log = logging.Logger("tarutil") // nolint
 
 func ExtractTar(body io.Reader, dir string) error {
-	if err := os.MkdirAll(dir, 0755); err != nil {
+	if err := os.MkdirAll(dir, 0755); err != nil { // nolint
 		return xerrors.Errorf("mkdir: %w", err)
 	}
 
@@ -35,6 +36,8 @@ func ExtractTar(body io.Reader, dir string) error {
 			return xerrors.Errorf("creating file %s: %w", filepath.Join(dir, header.Name), err)
 		}
 
+		// This data is coming from a trusted source, no need to check the size.
+		//nolint:gosec
 		if _, err := io.Copy(f, tr); err != nil {
 			return err
 		}
@@ -73,7 +76,7 @@ func writeTarDirectory(dir string, w io.Writer) error {
 			return xerrors.Errorf("wiritng header for file %s: %w", file.Name(), err)
 		}
 
-		f, err := os.OpenFile(filepath.Join(dir, file.Name()), os.O_RDONLY, 644)
+		f, err := os.OpenFile(filepath.Join(dir, file.Name()), os.O_RDONLY, 644) // nolint
 		if err != nil {
 			return xerrors.Errorf("opening %s for reading: %w", file.Name(), err)
 		}
diff --git a/extern/sector-storage/testworker_test.go b/extern/sector-storage/testworker_test.go
new file mode 100644
index 000000000..8f27401f0
--- /dev/null
+++ b/extern/sector-storage/testworker_test.go
@@ -0,0 +1,127 @@
+package sectorstorage
+
+import (
+	"context"
+	"io"
+
+	"github.com/ipfs/go-cid"
+
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/specs-storage/storage"
+
+	"github.com/filecoin-project/lotus/extern/sector-storage/mock"
+	"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"
+)
+
+type testWorker struct {
+	acceptTasks map[sealtasks.TaskType]struct{}
+	lstor       *stores.Local
+
+	mockSeal *mock.SectorMgr
+}
+
+func newTestWorker(wcfg WorkerConfig, lstor *stores.Local) *testWorker {
+	ssize, err := wcfg.SealProof.SectorSize()
+	if err != nil {
+		panic(err)
+	}
+
+	acceptTasks := map[sealtasks.TaskType]struct{}{}
+	for _, taskType := range wcfg.TaskTypes {
+		acceptTasks[taskType] = struct{}{}
+	}
+
+	return &testWorker{
+		acceptTasks: acceptTasks,
+		lstor:       lstor,
+
+		mockSeal: mock.NewMockSectorMgr(ssize, nil),
+	}
+}
+
+func (t *testWorker) SealPreCommit1(ctx context.Context, sector abi.SectorID, ticket abi.SealRandomness, pieces []abi.PieceInfo) (storage.PreCommit1Out, error) {
+	return t.mockSeal.SealPreCommit1(ctx, sector, ticket, pieces)
+}
+
+func (t *testWorker) NewSector(ctx context.Context, sector abi.SectorID) error {
+	panic("implement me")
+}
+
+func (t *testWorker) UnsealPiece(ctx context.Context, id abi.SectorID, index storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize, randomness abi.SealRandomness, cid cid.Cid) error {
+	panic("implement me")
+}
+
+func (t *testWorker) ReadPiece(ctx context.Context, writer io.Writer, id abi.SectorID, index storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize) (bool, error) {
+	panic("implement me")
+}
+
+func (t *testWorker) AddPiece(ctx context.Context, sector abi.SectorID, pieceSizes []abi.UnpaddedPieceSize, newPieceSize abi.UnpaddedPieceSize, pieceData storage.Data) (abi.PieceInfo, error) {
+	return t.mockSeal.AddPiece(ctx, sector, pieceSizes, newPieceSize, pieceData)
+}
+
+func (t *testWorker) SealPreCommit2(ctx context.Context, sector abi.SectorID, pc1o storage.PreCommit1Out) (storage.SectorCids, error) {
+	panic("implement me")
+}
+
+func (t *testWorker) SealCommit1(ctx context.Context, sector abi.SectorID, ticket abi.SealRandomness, seed abi.InteractiveSealRandomness, pieces []abi.PieceInfo, cids storage.SectorCids) (storage.Commit1Out, error) {
+	panic("implement me")
+}
+
+func (t *testWorker) SealCommit2(ctx context.Context, sector abi.SectorID, c1o storage.Commit1Out) (storage.Proof, error) {
+	panic("implement me")
+}
+
+func (t *testWorker) FinalizeSector(ctx context.Context, sector abi.SectorID, keepUnsealed []storage.Range) error {
+	panic("implement me")
+}
+
+func (t *testWorker) ReleaseUnsealed(ctx context.Context, sector abi.SectorID, safeToFree []storage.Range) error {
+	panic("implement me")
+}
+
+func (t *testWorker) Remove(ctx context.Context, sector abi.SectorID) error {
+	panic("implement me")
+}
+
+func (t *testWorker) MoveStorage(ctx context.Context, sector abi.SectorID, types stores.SectorFileType) error {
+	panic("implement me")
+}
+
+func (t *testWorker) Fetch(ctx context.Context, id abi.SectorID, fileType stores.SectorFileType, ptype stores.PathType, am stores.AcquireMode) error {
+	return nil
+}
+
+func (t *testWorker) TaskTypes(ctx context.Context) (map[sealtasks.TaskType]struct{}, error) {
+	return t.acceptTasks, nil
+}
+
+func (t *testWorker) Paths(ctx context.Context) ([]stores.StoragePath, error) {
+	return t.lstor.Local(ctx)
+}
+
+func (t *testWorker) Info(ctx context.Context) (storiface.WorkerInfo, error) {
+	res := ResourceTable[sealtasks.TTPreCommit2][abi.RegisteredSealProof_StackedDrg2KiBV1]
+
+	return storiface.WorkerInfo{
+		Hostname: "testworkerer",
+		Resources: storiface.WorkerResources{
+			MemPhysical: res.MinMemory * 3,
+			MemSwap:     0,
+			MemReserved: res.MinMemory,
+			CPUs:        32,
+			GPUs:        nil,
+		},
+	}, nil
+}
+
+func (t *testWorker) Closing(ctx context.Context) (<-chan struct{}, error) {
+	return ctx.Done(), nil
+}
+
+func (t *testWorker) Close() error {
+	panic("implement me")
+}
+
+var _ Worker = &testWorker{}
diff --git a/extern/sector-storage/work_tracker.go b/extern/sector-storage/work_tracker.go
new file mode 100644
index 000000000..5dc12802c
--- /dev/null
+++ b/extern/sector-storage/work_tracker.go
@@ -0,0 +1,129 @@
+package sectorstorage
+
+import (
+	"context"
+	"io"
+	"sync"
+	"time"
+
+	"github.com/ipfs/go-cid"
+
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/specs-storage/storage"
+
+	"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"
+)
+
+type workTracker struct {
+	lk sync.Mutex
+
+	ctr     uint64
+	running map[uint64]storiface.WorkerJob
+
+	// TODO: done, aggregate stats, queue stats, scheduler feedback
+}
+
+func (wt *workTracker) track(sid abi.SectorID, task sealtasks.TaskType) func() {
+	wt.lk.Lock()
+	defer wt.lk.Unlock()
+
+	id := wt.ctr
+	wt.ctr++
+
+	wt.running[id] = storiface.WorkerJob{
+		ID:     id,
+		Sector: sid,
+		Task:   task,
+		Start:  time.Now(),
+	}
+
+	return func() {
+		wt.lk.Lock()
+		defer wt.lk.Unlock()
+
+		delete(wt.running, id)
+	}
+}
+
+func (wt *workTracker) worker(w Worker) Worker {
+	return &trackedWorker{
+		Worker:  w,
+		tracker: wt,
+	}
+}
+
+func (wt *workTracker) Running() []storiface.WorkerJob {
+	wt.lk.Lock()
+	defer wt.lk.Unlock()
+
+	out := make([]storiface.WorkerJob, 0, len(wt.running))
+	for _, job := range wt.running {
+		out = append(out, job)
+	}
+
+	return out
+}
+
+type trackedWorker struct {
+	Worker
+
+	tracker *workTracker
+}
+
+func (t *trackedWorker) SealPreCommit1(ctx context.Context, sector abi.SectorID, ticket abi.SealRandomness, pieces []abi.PieceInfo) (storage.PreCommit1Out, error) {
+	defer t.tracker.track(sector, sealtasks.TTPreCommit1)()
+
+	return t.Worker.SealPreCommit1(ctx, sector, ticket, pieces)
+}
+
+func (t *trackedWorker) SealPreCommit2(ctx context.Context, sector abi.SectorID, pc1o storage.PreCommit1Out) (storage.SectorCids, error) {
+	defer t.tracker.track(sector, sealtasks.TTPreCommit2)()
+
+	return t.Worker.SealPreCommit2(ctx, sector, pc1o)
+}
+
+func (t *trackedWorker) SealCommit1(ctx context.Context, sector abi.SectorID, ticket abi.SealRandomness, seed abi.InteractiveSealRandomness, pieces []abi.PieceInfo, cids storage.SectorCids) (storage.Commit1Out, error) {
+	defer t.tracker.track(sector, sealtasks.TTCommit1)()
+
+	return t.Worker.SealCommit1(ctx, sector, ticket, seed, pieces, cids)
+}
+
+func (t *trackedWorker) SealCommit2(ctx context.Context, sector abi.SectorID, c1o storage.Commit1Out) (storage.Proof, error) {
+	defer t.tracker.track(sector, sealtasks.TTCommit2)()
+
+	return t.Worker.SealCommit2(ctx, sector, c1o)
+}
+
+func (t *trackedWorker) FinalizeSector(ctx context.Context, sector abi.SectorID, keepUnsealed []storage.Range) error {
+	defer t.tracker.track(sector, sealtasks.TTFinalize)()
+
+	return t.Worker.FinalizeSector(ctx, sector, keepUnsealed)
+}
+
+func (t *trackedWorker) AddPiece(ctx context.Context, sector abi.SectorID, pieceSizes []abi.UnpaddedPieceSize, newPieceSize abi.UnpaddedPieceSize, pieceData storage.Data) (abi.PieceInfo, error) {
+	defer t.tracker.track(sector, sealtasks.TTAddPiece)()
+
+	return t.Worker.AddPiece(ctx, sector, pieceSizes, newPieceSize, pieceData)
+}
+
+func (t *trackedWorker) Fetch(ctx context.Context, s abi.SectorID, ft stores.SectorFileType, ptype stores.PathType, am stores.AcquireMode) error {
+	defer t.tracker.track(s, sealtasks.TTFetch)()
+
+	return t.Worker.Fetch(ctx, s, ft, ptype, am)
+}
+
+func (t *trackedWorker) UnsealPiece(ctx context.Context, id abi.SectorID, index storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize, randomness abi.SealRandomness, cid cid.Cid) error {
+	defer t.tracker.track(id, sealtasks.TTUnseal)()
+
+	return t.Worker.UnsealPiece(ctx, id, index, size, randomness, cid)
+}
+
+func (t *trackedWorker) ReadPiece(ctx context.Context, writer io.Writer, id abi.SectorID, index storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize) (bool, error) {
+	defer t.tracker.track(id, sealtasks.TTReadUnsealed)()
+
+	return t.Worker.ReadPiece(ctx, writer, id, index, size)
+}
+
+var _ Worker = &trackedWorker{}
diff --git a/extern/sector-storage/zerocomm/zerocomm.go b/extern/sector-storage/zerocomm/zerocomm.go
new file mode 100644
index 000000000..9855a5821
--- /dev/null
+++ b/extern/sector-storage/zerocomm/zerocomm.go
@@ -0,0 +1,56 @@
+package zerocomm
+
+import (
+	"math/bits"
+
+	commcid "github.com/filecoin-project/go-fil-commcid"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/ipfs/go-cid"
+)
+
+const Levels = 37
+const Skip = 2 // can't generate for 32, 64b
+
+var PieceComms = [Levels - Skip][32]byte{
+	{0x37, 0x31, 0xbb, 0x99, 0xac, 0x68, 0x9f, 0x66, 0xee, 0xf5, 0x97, 0x3e, 0x4a, 0x94, 0xda, 0x18, 0x8f, 0x4d, 0xdc, 0xae, 0x58, 0x7, 0x24, 0xfc, 0x6f, 0x3f, 0xd6, 0xd, 0xfd, 0x48, 0x83, 0x33},
+	{0x64, 0x2a, 0x60, 0x7e, 0xf8, 0x86, 0xb0, 0x4, 0xbf, 0x2c, 0x19, 0x78, 0x46, 0x3a, 0xe1, 0xd4, 0x69, 0x3a, 0xc0, 0xf4, 0x10, 0xeb, 0x2d, 0x1b, 0x7a, 0x47, 0xfe, 0x20, 0x5e, 0x5e, 0x75, 0xf},
+	{0x57, 0xa2, 0x38, 0x1a, 0x28, 0x65, 0x2b, 0xf4, 0x7f, 0x6b, 0xef, 0x7a, 0xca, 0x67, 0x9b, 0xe4, 0xae, 0xde, 0x58, 0x71, 0xab, 0x5c, 0xf3, 0xeb, 0x2c, 0x8, 0x11, 0x44, 0x88, 0xcb, 0x85, 0x26},
+	{0x1f, 0x7a, 0xc9, 0x59, 0x55, 0x10, 0xe0, 0x9e, 0xa4, 0x1c, 0x46, 0xb, 0x17, 0x64, 0x30, 0xbb, 0x32, 0x2c, 0xd6, 0xfb, 0x41, 0x2e, 0xc5, 0x7c, 0xb1, 0x7d, 0x98, 0x9a, 0x43, 0x10, 0x37, 0x2f},
+	{0xfc, 0x7e, 0x92, 0x82, 0x96, 0xe5, 0x16, 0xfa, 0xad, 0xe9, 0x86, 0xb2, 0x8f, 0x92, 0xd4, 0x4a, 0x4f, 0x24, 0xb9, 0x35, 0x48, 0x52, 0x23, 0x37, 0x6a, 0x79, 0x90, 0x27, 0xbc, 0x18, 0xf8, 0x33},
+	{0x8, 0xc4, 0x7b, 0x38, 0xee, 0x13, 0xbc, 0x43, 0xf4, 0x1b, 0x91, 0x5c, 0xe, 0xed, 0x99, 0x11, 0xa2, 0x60, 0x86, 0xb3, 0xed, 0x62, 0x40, 0x1b, 0xf9, 0xd5, 0x8b, 0x8d, 0x19, 0xdf, 0xf6, 0x24},
+	{0xb2, 0xe4, 0x7b, 0xfb, 0x11, 0xfa, 0xcd, 0x94, 0x1f, 0x62, 0xaf, 0x5c, 0x75, 0xf, 0x3e, 0xa5, 0xcc, 0x4d, 0xf5, 0x17, 0xd5, 0xc4, 0xf1, 0x6d, 0xb2, 0xb4, 0xd7, 0x7b, 0xae, 0xc1, 0xa3, 0x2f},
+	{0xf9, 0x22, 0x61, 0x60, 0xc8, 0xf9, 0x27, 0xbf, 0xdc, 0xc4, 0x18, 0xcd, 0xf2, 0x3, 0x49, 0x31, 0x46, 0x0, 0x8e, 0xae, 0xfb, 0x7d, 0x2, 0x19, 0x4d, 0x5e, 0x54, 0x81, 0x89, 0x0, 0x51, 0x8},
+	{0x2c, 0x1a, 0x96, 0x4b, 0xb9, 0xb, 0x59, 0xeb, 0xfe, 0xf, 0x6d, 0xa2, 0x9a, 0xd6, 0x5a, 0xe3, 0xe4, 0x17, 0x72, 0x4a, 0x8f, 0x7c, 0x11, 0x74, 0x5a, 0x40, 0xca, 0xc1, 0xe5, 0xe7, 0x40, 0x11},
+	{0xfe, 0xe3, 0x78, 0xce, 0xf1, 0x64, 0x4, 0xb1, 0x99, 0xed, 0xe0, 0xb1, 0x3e, 0x11, 0xb6, 0x24, 0xff, 0x9d, 0x78, 0x4f, 0xbb, 0xed, 0x87, 0x8d, 0x83, 0x29, 0x7e, 0x79, 0x5e, 0x2, 0x4f, 0x2},
+	{0x8e, 0x9e, 0x24, 0x3, 0xfa, 0x88, 0x4c, 0xf6, 0x23, 0x7f, 0x60, 0xdf, 0x25, 0xf8, 0x3e, 0xe4, 0xd, 0xca, 0x9e, 0xd8, 0x79, 0xeb, 0x6f, 0x63, 0x52, 0xd1, 0x50, 0x84, 0xf5, 0xad, 0xd, 0x3f},
+	{0x75, 0x2d, 0x96, 0x93, 0xfa, 0x16, 0x75, 0x24, 0x39, 0x54, 0x76, 0xe3, 0x17, 0xa9, 0x85, 0x80, 0xf0, 0x9, 0x47, 0xaf, 0xb7, 0xa3, 0x5, 0x40, 0xd6, 0x25, 0xa9, 0x29, 0x1c, 0xc1, 0x2a, 0x7},
+	{0x70, 0x22, 0xf6, 0xf, 0x7e, 0xf6, 0xad, 0xfa, 0x17, 0x11, 0x7a, 0x52, 0x61, 0x9e, 0x30, 0xce, 0xa8, 0x2c, 0x68, 0x7, 0x5a, 0xdf, 0x1c, 0x66, 0x77, 0x86, 0xec, 0x50, 0x6e, 0xef, 0x2d, 0x19},
+	{0xd9, 0x98, 0x87, 0xb9, 0x73, 0x57, 0x3a, 0x96, 0xe1, 0x13, 0x93, 0x64, 0x52, 0x36, 0xc1, 0x7b, 0x1f, 0x4c, 0x70, 0x34, 0xd7, 0x23, 0xc7, 0xa9, 0x9f, 0x70, 0x9b, 0xb4, 0xda, 0x61, 0x16, 0x2b},
+	{0xd0, 0xb5, 0x30, 0xdb, 0xb0, 0xb4, 0xf2, 0x5c, 0x5d, 0x2f, 0x2a, 0x28, 0xdf, 0xee, 0x80, 0x8b, 0x53, 0x41, 0x2a, 0x2, 0x93, 0x1f, 0x18, 0xc4, 0x99, 0xf5, 0xa2, 0x54, 0x8, 0x6b, 0x13, 0x26},
+	{0x84, 0xc0, 0x42, 0x1b, 0xa0, 0x68, 0x5a, 0x1, 0xbf, 0x79, 0x5a, 0x23, 0x44, 0x6, 0x4f, 0xe4, 0x24, 0xbd, 0x52, 0xa9, 0xd2, 0x43, 0x77, 0xb3, 0x94, 0xff, 0x4c, 0x4b, 0x45, 0x68, 0xe8, 0x11},
+	{0x65, 0xf2, 0x9e, 0x5d, 0x98, 0xd2, 0x46, 0xc3, 0x8b, 0x38, 0x8c, 0xfc, 0x6, 0xdb, 0x1f, 0x6b, 0x2, 0x13, 0x3, 0xc5, 0xa2, 0x89, 0x0, 0xb, 0xdc, 0xe8, 0x32, 0xa9, 0xc3, 0xec, 0x42, 0x1c},
+	{0xa2, 0x24, 0x75, 0x8, 0x28, 0x58, 0x50, 0x96, 0x5b, 0x7e, 0x33, 0x4b, 0x31, 0x27, 0xb0, 0xc0, 0x42, 0xb1, 0xd0, 0x46, 0xdc, 0x54, 0x40, 0x21, 0x37, 0x62, 0x7c, 0xd8, 0x79, 0x9c, 0xe1, 0x3a},
+	{0xda, 0xfd, 0xab, 0x6d, 0xa9, 0x36, 0x44, 0x53, 0xc2, 0x6d, 0x33, 0x72, 0x6b, 0x9f, 0xef, 0xe3, 0x43, 0xbe, 0x8f, 0x81, 0x64, 0x9e, 0xc0, 0x9, 0xaa, 0xd3, 0xfa, 0xff, 0x50, 0x61, 0x75, 0x8},
+	{0xd9, 0x41, 0xd5, 0xe0, 0xd6, 0x31, 0x4a, 0x99, 0x5c, 0x33, 0xff, 0xbd, 0x4f, 0xbe, 0x69, 0x11, 0x8d, 0x73, 0xd4, 0xe5, 0xfd, 0x2c, 0xd3, 0x1f, 0xf, 0x7c, 0x86, 0xeb, 0xdd, 0x14, 0xe7, 0x6},
+	{0x51, 0x4c, 0x43, 0x5c, 0x3d, 0x4, 0xd3, 0x49, 0xa5, 0x36, 0x5f, 0xbd, 0x59, 0xff, 0xc7, 0x13, 0x62, 0x91, 0x11, 0x78, 0x59, 0x91, 0xc1, 0xa3, 0xc5, 0x3a, 0xf2, 0x20, 0x79, 0x74, 0x1a, 0x2f},
+	{0xad, 0x6, 0x85, 0x39, 0x69, 0xd3, 0x7d, 0x34, 0xff, 0x8, 0xe0, 0x9f, 0x56, 0x93, 0xa, 0x4a, 0xd1, 0x9a, 0x89, 0xde, 0xf6, 0xc, 0xbf, 0xee, 0x7e, 0x1d, 0x33, 0x81, 0xc1, 0xe7, 0x1c, 0x37},
+	{0x39, 0x56, 0xe, 0x7b, 0x13, 0xa9, 0x3b, 0x7, 0xa2, 0x43, 0xfd, 0x27, 0x20, 0xff, 0xa7, 0xcb, 0x3e, 0x1d, 0x2e, 0x50, 0x5a, 0xb3, 0x62, 0x9e, 0x79, 0xf4, 0x63, 0x13, 0x51, 0x2c, 0xda, 0x6},
+	{0xcc, 0xc3, 0xc0, 0x12, 0xf5, 0xb0, 0x5e, 0x81, 0x1a, 0x2b, 0xbf, 0xdd, 0xf, 0x68, 0x33, 0xb8, 0x42, 0x75, 0xb4, 0x7b, 0xf2, 0x29, 0xc0, 0x5, 0x2a, 0x82, 0x48, 0x4f, 0x3c, 0x1a, 0x5b, 0x3d},
+	{0x7d, 0xf2, 0x9b, 0x69, 0x77, 0x31, 0x99, 0xe8, 0xf2, 0xb4, 0xb, 0x77, 0x91, 0x9d, 0x4, 0x85, 0x9, 0xee, 0xd7, 0x68, 0xe2, 0xc7, 0x29, 0x7b, 0x1f, 0x14, 0x37, 0x3, 0x4f, 0xc3, 0xc6, 0x2c},
+	{0x66, 0xce, 0x5, 0xa3, 0x66, 0x75, 0x52, 0xcf, 0x45, 0xc0, 0x2b, 0xcc, 0x4e, 0x83, 0x92, 0x91, 0x9b, 0xde, 0xac, 0x35, 0xde, 0x2f, 0xf5, 0x62, 0x71, 0x84, 0x8e, 0x9f, 0x7b, 0x67, 0x51, 0x7},
+	{0xd8, 0x61, 0x2, 0x18, 0x42, 0x5a, 0xb5, 0xe9, 0x5b, 0x1c, 0xa6, 0x23, 0x9d, 0x29, 0xa2, 0xe4, 0x20, 0xd7, 0x6, 0xa9, 0x6f, 0x37, 0x3e, 0x2f, 0x9c, 0x9a, 0x91, 0xd7, 0x59, 0xd1, 0x9b, 0x1},
+	{0x6d, 0x36, 0x4b, 0x1e, 0xf8, 0x46, 0x44, 0x1a, 0x5a, 0x4a, 0x68, 0x86, 0x23, 0x14, 0xac, 0xc0, 0xa4, 0x6f, 0x1, 0x67, 0x17, 0xe5, 0x34, 0x43, 0xe8, 0x39, 0xee, 0xdf, 0x83, 0xc2, 0x85, 0x3c},
+	{0x7, 0x7e, 0x5f, 0xde, 0x35, 0xc5, 0xa, 0x93, 0x3, 0xa5, 0x50, 0x9, 0xe3, 0x49, 0x8a, 0x4e, 0xbe, 0xdf, 0xf3, 0x9c, 0x42, 0xb7, 0x10, 0xb7, 0x30, 0xd8, 0xec, 0x7a, 0xc7, 0xaf, 0xa6, 0x3e},
+	{0xe6, 0x40, 0x5, 0xa6, 0xbf, 0xe3, 0x77, 0x79, 0x53, 0xb8, 0xad, 0x6e, 0xf9, 0x3f, 0xf, 0xca, 0x10, 0x49, 0xb2, 0x4, 0x16, 0x54, 0xf2, 0xa4, 0x11, 0xf7, 0x70, 0x27, 0x99, 0xce, 0xce, 0x2},
+	{0x25, 0x9d, 0x3d, 0x6b, 0x1f, 0x4d, 0x87, 0x6d, 0x11, 0x85, 0xe1, 0x12, 0x3a, 0xf6, 0xf5, 0x50, 0x1a, 0xf0, 0xf6, 0x7c, 0xf1, 0x5b, 0x52, 0x16, 0x25, 0x5b, 0x7b, 0x17, 0x8d, 0x12, 0x5, 0x1d},
+	{0x3f, 0x9a, 0x4d, 0x41, 0x1d, 0xa4, 0xef, 0x1b, 0x36, 0xf3, 0x5f, 0xf0, 0xa1, 0x95, 0xae, 0x39, 0x2a, 0xb2, 0x3f, 0xee, 0x79, 0x67, 0xb7, 0xc4, 0x1b, 0x3, 0xd1, 0x61, 0x3f, 0xc2, 0x92, 0x39},
+	{0xfe, 0x4e, 0xf3, 0x28, 0xc6, 0x1a, 0xa3, 0x9c, 0xfd, 0xb2, 0x48, 0x4e, 0xaa, 0x32, 0xa1, 0x51, 0xb1, 0xfe, 0x3d, 0xfd, 0x1f, 0x96, 0xdd, 0x8c, 0x97, 0x11, 0xfd, 0x86, 0xd6, 0xc5, 0x81, 0x13},
+	{0xf5, 0x5d, 0x68, 0x90, 0xe, 0x2d, 0x83, 0x81, 0xec, 0xcb, 0x81, 0x64, 0xcb, 0x99, 0x76, 0xf2, 0x4b, 0x2d, 0xe0, 0xdd, 0x61, 0xa3, 0x1b, 0x97, 0xce, 0x6e, 0xb2, 0x38, 0x50, 0xd5, 0xe8, 0x19},
+	{0xaa, 0xaa, 0x8c, 0x4c, 0xb4, 0xa, 0xac, 0xee, 0x1e, 0x2, 0xdc, 0x65, 0x42, 0x4b, 0x2a, 0x6c, 0x8e, 0x99, 0xf8, 0x3, 0xb7, 0x2f, 0x79, 0x29, 0xc4, 0x10, 0x1d, 0x7f, 0xae, 0x6b, 0xff, 0x32},
+}
+
+func ZeroPieceCommitment(sz abi.UnpaddedPieceSize) cid.Cid {
+	level := bits.TrailingZeros64(uint64(sz.Padded())) - Skip - 5 // 2^5 = 32
+	commP, _ := commcid.PieceCommitmentV1ToCID(PieceComms[level][:])
+	return commP
+}
diff --git a/extern/sector-storage/zerocomm/zerocomm_test.go b/extern/sector-storage/zerocomm/zerocomm_test.go
new file mode 100644
index 000000000..393f61d64
--- /dev/null
+++ b/extern/sector-storage/zerocomm/zerocomm_test.go
@@ -0,0 +1,115 @@
+package zerocomm_test
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"testing"
+
+	commcid "github.com/filecoin-project/go-fil-commcid"
+	abi "github.com/filecoin-project/go-state-types/abi"
+	"github.com/ipfs/go-cid"
+
+	"github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper"
+	"github.com/filecoin-project/lotus/extern/sector-storage/zerocomm"
+)
+
+func TestComms(t *testing.T) {
+	t.Skip("don't have enough ram") // no, but seriously, currently this needs like 3tb of /tmp
+
+	var expPieceComms [zerocomm.Levels - zerocomm.Skip]cid.Cid
+
+	{
+		l2, err := ffiwrapper.GeneratePieceCIDFromFile(abi.RegisteredSealProof_StackedDrg2KiBV1, bytes.NewReader(make([]byte, 127)), 127)
+		if err != nil {
+			t.Fatal(err)
+		}
+		expPieceComms[0] = l2
+	}
+
+	for i := 1; i < zerocomm.Levels-2; i++ {
+		var err error
+		sz := abi.UnpaddedPieceSize(127 << uint(i))
+		fmt.Println(i, sz)
+		r := io.LimitReader(&NullReader{}, int64(sz))
+
+		expPieceComms[i], err = ffiwrapper.GeneratePieceCIDFromFile(abi.RegisteredSealProof_StackedDrg2KiBV1, r, sz)
+		if err != nil {
+			t.Fatal(err)
+		}
+	}
+
+	for i, comm := range expPieceComms {
+		c, err := commcid.CIDToPieceCommitmentV1(comm)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if string(c) != string(zerocomm.PieceComms[i][:]) {
+			t.Errorf("zero commitment %d didn't match", i)
+		}
+	}
+
+	for _, comm := range expPieceComms { // Could do codegen, but this is good enough
+		fmt.Printf("%#v,\n", comm)
+	}
+}
+
+func TestCommsSmall(t *testing.T) {
+	var expPieceComms [8]cid.Cid
+	lvls := len(expPieceComms) + zerocomm.Skip
+
+	{
+		l2, err := ffiwrapper.GeneratePieceCIDFromFile(abi.RegisteredSealProof_StackedDrg2KiBV1, bytes.NewReader(make([]byte, 127)), 127)
+		if err != nil {
+			t.Fatal(err)
+		}
+		expPieceComms[0] = l2
+	}
+
+	for i := 1; i < lvls-2; i++ {
+		var err error
+		sz := abi.UnpaddedPieceSize(127 << uint(i))
+		fmt.Println(i, sz)
+		r := io.LimitReader(&NullReader{}, int64(sz))
+
+		expPieceComms[i], err = ffiwrapper.GeneratePieceCIDFromFile(abi.RegisteredSealProof_StackedDrg2KiBV1, r, sz)
+		if err != nil {
+			t.Fatal(err)
+		}
+	}
+
+	for i, comm := range expPieceComms {
+		c, err := commcid.CIDToPieceCommitmentV1(comm)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if string(c) != string(zerocomm.PieceComms[i][:]) {
+			t.Errorf("zero commitment %d didn't match", i)
+		}
+	}
+
+	for _, comm := range expPieceComms { // Could do codegen, but this is good enough
+		fmt.Printf("%#v,\n", comm)
+	}
+}
+
+func TestForSise(t *testing.T) {
+	exp, err := ffiwrapper.GeneratePieceCIDFromFile(abi.RegisteredSealProof_StackedDrg2KiBV1, bytes.NewReader(make([]byte, 1016)), 1016)
+	if err != nil {
+		return
+	}
+
+	actual := zerocomm.ZeroPieceCommitment(1016)
+	if !exp.Equals(actual) {
+		t.Errorf("zero commitment didn't match")
+	}
+}
+
+type NullReader struct{}
+
+func (NullReader) Read(out []byte) (int, error) {
+	for i := range out {
+		out[i] = 0
+	}
+	return len(out), nil
+}
diff --git a/extern/serialization-vectors b/extern/serialization-vectors
new file mode 160000
index 000000000..5bfb92891
--- /dev/null
+++ b/extern/serialization-vectors
@@ -0,0 +1 @@
+Subproject commit 5bfb928910b01ac8b940a693af2884f7f8276211
diff --git a/extern/storage-sealing/cbor_gen.go b/extern/storage-sealing/cbor_gen.go
new file mode 100644
index 000000000..78765d7b4
--- /dev/null
+++ b/extern/storage-sealing/cbor_gen.go
@@ -0,0 +1,1678 @@
+// Code generated by github.com/whyrusleeping/cbor-gen. DO NOT EDIT.
+
+package sealing
+
+import (
+	"fmt"
+	"io"
+
+	abi "github.com/filecoin-project/go-state-types/abi"
+	miner "github.com/filecoin-project/specs-actors/actors/builtin/miner"
+	cbg "github.com/whyrusleeping/cbor-gen"
+	xerrors "golang.org/x/xerrors"
+)
+
+var _ = xerrors.Errorf
+
+func (t *Piece) MarshalCBOR(w io.Writer) error {
+	if t == nil {
+		_, err := w.Write(cbg.CborNull)
+		return err
+	}
+	if _, err := w.Write([]byte{162}); err != nil {
+		return err
+	}
+
+	scratch := make([]byte, 9)
+
+	// t.Piece (abi.PieceInfo) (struct)
+	if len("Piece") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"Piece\" was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("Piece"))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string("Piece")); err != nil {
+		return err
+	}
+
+	if err := t.Piece.MarshalCBOR(w); err != nil {
+		return err
+	}
+
+	// t.DealInfo (sealing.DealInfo) (struct)
+	if len("DealInfo") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"DealInfo\" was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("DealInfo"))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string("DealInfo")); err != nil {
+		return err
+	}
+
+	if err := t.DealInfo.MarshalCBOR(w); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (t *Piece) UnmarshalCBOR(r io.Reader) error {
+	*t = Piece{}
+
+	br := cbg.GetPeeker(r)
+	scratch := make([]byte, 8)
+
+	maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
+	if err != nil {
+		return err
+	}
+	if maj != cbg.MajMap {
+		return fmt.Errorf("cbor input should be of type map")
+	}
+
+	if extra > cbg.MaxLength {
+		return fmt.Errorf("Piece: map struct too large (%d)", extra)
+	}
+
+	var name string
+	n := extra
+
+	for i := uint64(0); i < n; i++ {
+
+		{
+			sval, err := cbg.ReadStringBuf(br, scratch)
+			if err != nil {
+				return err
+			}
+
+			name = string(sval)
+		}
+
+		switch name {
+		// t.Piece (abi.PieceInfo) (struct)
+		case "Piece":
+
+			{
+
+				if err := t.Piece.UnmarshalCBOR(br); err != nil {
+					return xerrors.Errorf("unmarshaling t.Piece: %w", err)
+				}
+
+			}
+			// t.DealInfo (sealing.DealInfo) (struct)
+		case "DealInfo":
+
+			{
+
+				b, err := br.ReadByte()
+				if err != nil {
+					return err
+				}
+				if b != cbg.CborNull[0] {
+					if err := br.UnreadByte(); err != nil {
+						return err
+					}
+					t.DealInfo = new(DealInfo)
+					if err := t.DealInfo.UnmarshalCBOR(br); err != nil {
+						return xerrors.Errorf("unmarshaling t.DealInfo pointer: %w", err)
+					}
+				}
+
+			}
+
+		default:
+			return fmt.Errorf("unknown struct field %d: '%s'", i, name)
+		}
+	}
+
+	return nil
+}
+func (t *DealInfo) MarshalCBOR(w io.Writer) error {
+	if t == nil {
+		_, err := w.Write(cbg.CborNull)
+		return err
+	}
+	if _, err := w.Write([]byte{164}); err != nil {
+		return err
+	}
+
+	scratch := make([]byte, 9)
+
+	// t.PublishCid (cid.Cid) (struct)
+	if len("PublishCid") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"PublishCid\" was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("PublishCid"))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string("PublishCid")); err != nil {
+		return err
+	}
+
+	if t.PublishCid == nil {
+		if _, err := w.Write(cbg.CborNull); err != nil {
+			return err
+		}
+	} else {
+		if err := cbg.WriteCidBuf(scratch, w, *t.PublishCid); err != nil {
+			return xerrors.Errorf("failed to write cid field t.PublishCid: %w", err)
+		}
+	}
+
+	// t.DealID (abi.DealID) (uint64)
+	if len("DealID") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"DealID\" was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("DealID"))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string("DealID")); err != nil {
+		return err
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.DealID)); err != nil {
+		return err
+	}
+
+	// t.DealSchedule (sealing.DealSchedule) (struct)
+	if len("DealSchedule") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"DealSchedule\" was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("DealSchedule"))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string("DealSchedule")); err != nil {
+		return err
+	}
+
+	if err := t.DealSchedule.MarshalCBOR(w); err != nil {
+		return err
+	}
+
+	// t.KeepUnsealed (bool) (bool)
+	if len("KeepUnsealed") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"KeepUnsealed\" was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("KeepUnsealed"))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string("KeepUnsealed")); err != nil {
+		return err
+	}
+
+	if err := cbg.WriteBool(w, t.KeepUnsealed); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (t *DealInfo) UnmarshalCBOR(r io.Reader) error {
+	*t = DealInfo{}
+
+	br := cbg.GetPeeker(r)
+	scratch := make([]byte, 8)
+
+	maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
+	if err != nil {
+		return err
+	}
+	if maj != cbg.MajMap {
+		return fmt.Errorf("cbor input should be of type map")
+	}
+
+	if extra > cbg.MaxLength {
+		return fmt.Errorf("DealInfo: map struct too large (%d)", extra)
+	}
+
+	var name string
+	n := extra
+
+	for i := uint64(0); i < n; i++ {
+
+		{
+			sval, err := cbg.ReadStringBuf(br, scratch)
+			if err != nil {
+				return err
+			}
+
+			name = string(sval)
+		}
+
+		switch name {
+		// t.PublishCid (cid.Cid) (struct)
+		case "PublishCid":
+
+			{
+
+				b, err := br.ReadByte()
+				if err != nil {
+					return err
+				}
+				if b != cbg.CborNull[0] {
+					if err := br.UnreadByte(); err != nil {
+						return err
+					}
+
+					c, err := cbg.ReadCid(br)
+					if err != nil {
+						return xerrors.Errorf("failed to read cid field t.PublishCid: %w", err)
+					}
+
+					t.PublishCid = &c
+				}
+
+			}
+			// t.DealID (abi.DealID) (uint64)
+		case "DealID":
+
+			{
+
+				maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
+				if err != nil {
+					return err
+				}
+				if maj != cbg.MajUnsignedInt {
+					return fmt.Errorf("wrong type for uint64 field")
+				}
+				t.DealID = abi.DealID(extra)
+
+			}
+			// t.DealSchedule (sealing.DealSchedule) (struct)
+		case "DealSchedule":
+
+			{
+
+				if err := t.DealSchedule.UnmarshalCBOR(br); err != nil {
+					return xerrors.Errorf("unmarshaling t.DealSchedule: %w", err)
+				}
+
+			}
+			// t.KeepUnsealed (bool) (bool)
+		case "KeepUnsealed":
+
+			maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
+			if err != nil {
+				return err
+			}
+			if maj != cbg.MajOther {
+				return fmt.Errorf("booleans must be major type 7")
+			}
+			switch extra {
+			case 20:
+				t.KeepUnsealed = false
+			case 21:
+				t.KeepUnsealed = true
+			default:
+				return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
+			}
+
+		default:
+			return fmt.Errorf("unknown struct field %d: '%s'", i, name)
+		}
+	}
+
+	return nil
+}
+func (t *DealSchedule) MarshalCBOR(w io.Writer) error {
+	if t == nil {
+		_, err := w.Write(cbg.CborNull)
+		return err
+	}
+	if _, err := w.Write([]byte{162}); err != nil {
+		return err
+	}
+
+	scratch := make([]byte, 9)
+
+	// t.StartEpoch (abi.ChainEpoch) (int64)
+	if len("StartEpoch") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"StartEpoch\" was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("StartEpoch"))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string("StartEpoch")); err != nil {
+		return err
+	}
+
+	if t.StartEpoch >= 0 {
+		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.StartEpoch)); err != nil {
+			return err
+		}
+	} else {
+		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajNegativeInt, uint64(-t.StartEpoch-1)); err != nil {
+			return err
+		}
+	}
+
+	// t.EndEpoch (abi.ChainEpoch) (int64)
+	if len("EndEpoch") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"EndEpoch\" was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("EndEpoch"))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string("EndEpoch")); err != nil {
+		return err
+	}
+
+	if t.EndEpoch >= 0 {
+		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.EndEpoch)); err != nil {
+			return err
+		}
+	} else {
+		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajNegativeInt, uint64(-t.EndEpoch-1)); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (t *DealSchedule) UnmarshalCBOR(r io.Reader) error {
+	*t = DealSchedule{}
+
+	br := cbg.GetPeeker(r)
+	scratch := make([]byte, 8)
+
+	maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
+	if err != nil {
+		return err
+	}
+	if maj != cbg.MajMap {
+		return fmt.Errorf("cbor input should be of type map")
+	}
+
+	if extra > cbg.MaxLength {
+		return fmt.Errorf("DealSchedule: map struct too large (%d)", extra)
+	}
+
+	var name string
+	n := extra
+
+	for i := uint64(0); i < n; i++ {
+
+		{
+			sval, err := cbg.ReadStringBuf(br, scratch)
+			if err != nil {
+				return err
+			}
+
+			name = string(sval)
+		}
+
+		switch name {
+		// t.StartEpoch (abi.ChainEpoch) (int64)
+		case "StartEpoch":
+			{
+				maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
+				var extraI int64
+				if err != nil {
+					return err
+				}
+				switch maj {
+				case cbg.MajUnsignedInt:
+					extraI = int64(extra)
+					if extraI < 0 {
+						return fmt.Errorf("int64 positive overflow")
+					}
+				case cbg.MajNegativeInt:
+					extraI = int64(extra)
+					if extraI < 0 {
+						return fmt.Errorf("int64 negative oveflow")
+					}
+					extraI = -1 - extraI
+				default:
+					return fmt.Errorf("wrong type for int64 field: %d", maj)
+				}
+
+				t.StartEpoch = abi.ChainEpoch(extraI)
+			}
+			// t.EndEpoch (abi.ChainEpoch) (int64)
+		case "EndEpoch":
+			{
+				maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
+				var extraI int64
+				if err != nil {
+					return err
+				}
+				switch maj {
+				case cbg.MajUnsignedInt:
+					extraI = int64(extra)
+					if extraI < 0 {
+						return fmt.Errorf("int64 positive overflow")
+					}
+				case cbg.MajNegativeInt:
+					extraI = int64(extra)
+					if extraI < 0 {
+						return fmt.Errorf("int64 negative oveflow")
+					}
+					extraI = -1 - extraI
+				default:
+					return fmt.Errorf("wrong type for int64 field: %d", maj)
+				}
+
+				t.EndEpoch = abi.ChainEpoch(extraI)
+			}
+
+		default:
+			return fmt.Errorf("unknown struct field %d: '%s'", i, name)
+		}
+	}
+
+	return nil
+}
+func (t *SectorInfo) MarshalCBOR(w io.Writer) error {
+	if t == nil {
+		_, err := w.Write(cbg.CborNull)
+		return err
+	}
+	if _, err := w.Write([]byte{183}); err != nil {
+		return err
+	}
+
+	scratch := make([]byte, 9)
+
+	// t.State (sealing.SectorState) (string)
+	if len("State") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"State\" was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("State"))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string("State")); err != nil {
+		return err
+	}
+
+	if len(t.State) > cbg.MaxLength {
+		return xerrors.Errorf("Value in field t.State was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len(t.State))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string(t.State)); err != nil {
+		return err
+	}
+
+	// t.SectorNumber (abi.SectorNumber) (uint64)
+	if len("SectorNumber") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"SectorNumber\" was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("SectorNumber"))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string("SectorNumber")); err != nil {
+		return err
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.SectorNumber)); err != nil {
+		return err
+	}
+
+	// t.SectorType (abi.RegisteredSealProof) (int64)
+	if len("SectorType") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"SectorType\" was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("SectorType"))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string("SectorType")); err != nil {
+		return err
+	}
+
+	if t.SectorType >= 0 {
+		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.SectorType)); err != nil {
+			return err
+		}
+	} else {
+		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajNegativeInt, uint64(-t.SectorType-1)); err != nil {
+			return err
+		}
+	}
+
+	// t.Pieces ([]sealing.Piece) (slice)
+	if len("Pieces") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"Pieces\" was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("Pieces"))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string("Pieces")); err != nil {
+		return err
+	}
+
+	if len(t.Pieces) > cbg.MaxLength {
+		return xerrors.Errorf("Slice value in field t.Pieces was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajArray, uint64(len(t.Pieces))); err != nil {
+		return err
+	}
+	for _, v := range t.Pieces {
+		if err := v.MarshalCBOR(w); err != nil {
+			return err
+		}
+	}
+
+	// t.TicketValue (abi.SealRandomness) (slice)
+	if len("TicketValue") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"TicketValue\" was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("TicketValue"))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string("TicketValue")); err != nil {
+		return err
+	}
+
+	if len(t.TicketValue) > cbg.ByteArrayMaxLen {
+		return xerrors.Errorf("Byte array in field t.TicketValue was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajByteString, uint64(len(t.TicketValue))); err != nil {
+		return err
+	}
+
+	if _, err := w.Write(t.TicketValue[:]); err != nil {
+		return err
+	}
+
+	// t.TicketEpoch (abi.ChainEpoch) (int64)
+	if len("TicketEpoch") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"TicketEpoch\" was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("TicketEpoch"))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string("TicketEpoch")); err != nil {
+		return err
+	}
+
+	if t.TicketEpoch >= 0 {
+		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.TicketEpoch)); err != nil {
+			return err
+		}
+	} else {
+		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajNegativeInt, uint64(-t.TicketEpoch-1)); err != nil {
+			return err
+		}
+	}
+
+	// t.PreCommit1Out (storage.PreCommit1Out) (slice)
+	if len("PreCommit1Out") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"PreCommit1Out\" was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("PreCommit1Out"))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string("PreCommit1Out")); err != nil {
+		return err
+	}
+
+	if len(t.PreCommit1Out) > cbg.ByteArrayMaxLen {
+		return xerrors.Errorf("Byte array in field t.PreCommit1Out was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajByteString, uint64(len(t.PreCommit1Out))); err != nil {
+		return err
+	}
+
+	if _, err := w.Write(t.PreCommit1Out[:]); err != nil {
+		return err
+	}
+
+	// t.CommD (cid.Cid) (struct)
+	if len("CommD") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"CommD\" was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("CommD"))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string("CommD")); err != nil {
+		return err
+	}
+
+	if t.CommD == nil {
+		if _, err := w.Write(cbg.CborNull); err != nil {
+			return err
+		}
+	} else {
+		if err := cbg.WriteCidBuf(scratch, w, *t.CommD); err != nil {
+			return xerrors.Errorf("failed to write cid field t.CommD: %w", err)
+		}
+	}
+
+	// t.CommR (cid.Cid) (struct)
+	if len("CommR") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"CommR\" was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("CommR"))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string("CommR")); err != nil {
+		return err
+	}
+
+	if t.CommR == nil {
+		if _, err := w.Write(cbg.CborNull); err != nil {
+			return err
+		}
+	} else {
+		if err := cbg.WriteCidBuf(scratch, w, *t.CommR); err != nil {
+			return xerrors.Errorf("failed to write cid field t.CommR: %w", err)
+		}
+	}
+
+	// t.Proof ([]uint8) (slice)
+	if len("Proof") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"Proof\" was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("Proof"))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string("Proof")); err != nil {
+		return err
+	}
+
+	if len(t.Proof) > cbg.ByteArrayMaxLen {
+		return xerrors.Errorf("Byte array in field t.Proof was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajByteString, uint64(len(t.Proof))); err != nil {
+		return err
+	}
+
+	if _, err := w.Write(t.Proof[:]); err != nil {
+		return err
+	}
+
+	// t.PreCommitInfo (miner.SectorPreCommitInfo) (struct)
+	if len("PreCommitInfo") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"PreCommitInfo\" was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("PreCommitInfo"))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string("PreCommitInfo")); err != nil {
+		return err
+	}
+
+	if err := t.PreCommitInfo.MarshalCBOR(w); err != nil {
+		return err
+	}
+
+	// t.PreCommitDeposit (big.Int) (struct)
+	if len("PreCommitDeposit") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"PreCommitDeposit\" was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("PreCommitDeposit"))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string("PreCommitDeposit")); err != nil {
+		return err
+	}
+
+	if err := t.PreCommitDeposit.MarshalCBOR(w); err != nil {
+		return err
+	}
+
+	// t.PreCommitMessage (cid.Cid) (struct)
+	if len("PreCommitMessage") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"PreCommitMessage\" was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("PreCommitMessage"))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string("PreCommitMessage")); err != nil {
+		return err
+	}
+
+	if t.PreCommitMessage == nil {
+		if _, err := w.Write(cbg.CborNull); err != nil {
+			return err
+		}
+	} else {
+		if err := cbg.WriteCidBuf(scratch, w, *t.PreCommitMessage); err != nil {
+			return xerrors.Errorf("failed to write cid field t.PreCommitMessage: %w", err)
+		}
+	}
+
+	// t.PreCommitTipSet (sealing.TipSetToken) (slice)
+	if len("PreCommitTipSet") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"PreCommitTipSet\" was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("PreCommitTipSet"))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string("PreCommitTipSet")); err != nil {
+		return err
+	}
+
+	if len(t.PreCommitTipSet) > cbg.ByteArrayMaxLen {
+		return xerrors.Errorf("Byte array in field t.PreCommitTipSet was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajByteString, uint64(len(t.PreCommitTipSet))); err != nil {
+		return err
+	}
+
+	if _, err := w.Write(t.PreCommitTipSet[:]); err != nil {
+		return err
+	}
+
+	// t.PreCommit2Fails (uint64) (uint64)
+	if len("PreCommit2Fails") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"PreCommit2Fails\" was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("PreCommit2Fails"))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string("PreCommit2Fails")); err != nil {
+		return err
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.PreCommit2Fails)); err != nil {
+		return err
+	}
+
+	// t.SeedValue (abi.InteractiveSealRandomness) (slice)
+	if len("SeedValue") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"SeedValue\" was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("SeedValue"))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string("SeedValue")); err != nil {
+		return err
+	}
+
+	if len(t.SeedValue) > cbg.ByteArrayMaxLen {
+		return xerrors.Errorf("Byte array in field t.SeedValue was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajByteString, uint64(len(t.SeedValue))); err != nil {
+		return err
+	}
+
+	if _, err := w.Write(t.SeedValue[:]); err != nil {
+		return err
+	}
+
+	// t.SeedEpoch (abi.ChainEpoch) (int64)
+	if len("SeedEpoch") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"SeedEpoch\" was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("SeedEpoch"))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string("SeedEpoch")); err != nil {
+		return err
+	}
+
+	if t.SeedEpoch >= 0 {
+		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.SeedEpoch)); err != nil {
+			return err
+		}
+	} else {
+		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajNegativeInt, uint64(-t.SeedEpoch-1)); err != nil {
+			return err
+		}
+	}
+
+	// t.CommitMessage (cid.Cid) (struct)
+	if len("CommitMessage") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"CommitMessage\" was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("CommitMessage"))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string("CommitMessage")); err != nil {
+		return err
+	}
+
+	if t.CommitMessage == nil {
+		if _, err := w.Write(cbg.CborNull); err != nil {
+			return err
+		}
+	} else {
+		if err := cbg.WriteCidBuf(scratch, w, *t.CommitMessage); err != nil {
+			return xerrors.Errorf("failed to write cid field t.CommitMessage: %w", err)
+		}
+	}
+
+	// t.InvalidProofs (uint64) (uint64)
+	if len("InvalidProofs") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"InvalidProofs\" was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("InvalidProofs"))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string("InvalidProofs")); err != nil {
+		return err
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.InvalidProofs)); err != nil {
+		return err
+	}
+
+	// t.FaultReportMsg (cid.Cid) (struct)
+	if len("FaultReportMsg") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"FaultReportMsg\" was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("FaultReportMsg"))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string("FaultReportMsg")); err != nil {
+		return err
+	}
+
+	if t.FaultReportMsg == nil {
+		if _, err := w.Write(cbg.CborNull); err != nil {
+			return err
+		}
+	} else {
+		if err := cbg.WriteCidBuf(scratch, w, *t.FaultReportMsg); err != nil {
+			return xerrors.Errorf("failed to write cid field t.FaultReportMsg: %w", err)
+		}
+	}
+
+	// t.Return (sealing.ReturnState) (string)
+	if len("Return") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"Return\" was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("Return"))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string("Return")); err != nil {
+		return err
+	}
+
+	if len(t.Return) > cbg.MaxLength {
+		return xerrors.Errorf("Value in field t.Return was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len(t.Return))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string(t.Return)); err != nil {
+		return err
+	}
+
+	// t.LastErr (string) (string)
+	if len("LastErr") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"LastErr\" was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("LastErr"))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string("LastErr")); err != nil {
+		return err
+	}
+
+	if len(t.LastErr) > cbg.MaxLength {
+		return xerrors.Errorf("Value in field t.LastErr was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len(t.LastErr))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string(t.LastErr)); err != nil {
+		return err
+	}
+
+	// t.Log ([]sealing.Log) (slice)
+	if len("Log") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"Log\" was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("Log"))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string("Log")); err != nil {
+		return err
+	}
+
+	if len(t.Log) > cbg.MaxLength {
+		return xerrors.Errorf("Slice value in field t.Log was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajArray, uint64(len(t.Log))); err != nil {
+		return err
+	}
+	for _, v := range t.Log {
+		if err := v.MarshalCBOR(w); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (t *SectorInfo) UnmarshalCBOR(r io.Reader) error {
+	*t = SectorInfo{}
+
+	br := cbg.GetPeeker(r)
+	scratch := make([]byte, 8)
+
+	maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
+	if err != nil {
+		return err
+	}
+	if maj != cbg.MajMap {
+		return fmt.Errorf("cbor input should be of type map")
+	}
+
+	if extra > cbg.MaxLength {
+		return fmt.Errorf("SectorInfo: map struct too large (%d)", extra)
+	}
+
+	var name string
+	n := extra
+
+	for i := uint64(0); i < n; i++ {
+
+		{
+			sval, err := cbg.ReadStringBuf(br, scratch)
+			if err != nil {
+				return err
+			}
+
+			name = string(sval)
+		}
+
+		switch name {
+		// t.State (sealing.SectorState) (string)
+		case "State":
+
+			{
+				sval, err := cbg.ReadStringBuf(br, scratch)
+				if err != nil {
+					return err
+				}
+
+				t.State = SectorState(sval)
+			}
+			// t.SectorNumber (abi.SectorNumber) (uint64)
+		case "SectorNumber":
+
+			{
+
+				maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
+				if err != nil {
+					return err
+				}
+				if maj != cbg.MajUnsignedInt {
+					return fmt.Errorf("wrong type for uint64 field")
+				}
+				t.SectorNumber = abi.SectorNumber(extra)
+
+			}
+			// t.SectorType (abi.RegisteredSealProof) (int64)
+		case "SectorType":
+			{
+				maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
+				var extraI int64
+				if err != nil {
+					return err
+				}
+				switch maj {
+				case cbg.MajUnsignedInt:
+					extraI = int64(extra)
+					if extraI < 0 {
+						return fmt.Errorf("int64 positive overflow")
+					}
+				case cbg.MajNegativeInt:
+					extraI = int64(extra)
+					if extraI < 0 {
+						return fmt.Errorf("int64 negative oveflow")
+					}
+					extraI = -1 - extraI
+				default:
+					return fmt.Errorf("wrong type for int64 field: %d", maj)
+				}
+
+				t.SectorType = abi.RegisteredSealProof(extraI)
+			}
+			// t.Pieces ([]sealing.Piece) (slice)
+		case "Pieces":
+
+			maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
+			if err != nil {
+				return err
+			}
+
+			if extra > cbg.MaxLength {
+				return fmt.Errorf("t.Pieces: array too large (%d)", extra)
+			}
+
+			if maj != cbg.MajArray {
+				return fmt.Errorf("expected cbor array")
+			}
+
+			if extra > 0 {
+				t.Pieces = make([]Piece, extra)
+			}
+
+			for i := 0; i < int(extra); i++ {
+
+				var v Piece
+				if err := v.UnmarshalCBOR(br); err != nil {
+					return err
+				}
+
+				t.Pieces[i] = v
+			}
+
+			// t.TicketValue (abi.SealRandomness) (slice)
+		case "TicketValue":
+
+			maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
+			if err != nil {
+				return err
+			}
+
+			if extra > cbg.ByteArrayMaxLen {
+				return fmt.Errorf("t.TicketValue: byte array too large (%d)", extra)
+			}
+			if maj != cbg.MajByteString {
+				return fmt.Errorf("expected byte array")
+			}
+
+			if extra > 0 {
+				t.TicketValue = make([]uint8, extra)
+			}
+
+			if _, err := io.ReadFull(br, t.TicketValue[:]); err != nil {
+				return err
+			}
+			// t.TicketEpoch (abi.ChainEpoch) (int64)
+		case "TicketEpoch":
+			{
+				maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
+				var extraI int64
+				if err != nil {
+					return err
+				}
+				switch maj {
+				case cbg.MajUnsignedInt:
+					extraI = int64(extra)
+					if extraI < 0 {
+						return fmt.Errorf("int64 positive overflow")
+					}
+				case cbg.MajNegativeInt:
+					extraI = int64(extra)
+					if extraI < 0 {
+						return fmt.Errorf("int64 negative oveflow")
+					}
+					extraI = -1 - extraI
+				default:
+					return fmt.Errorf("wrong type for int64 field: %d", maj)
+				}
+
+				t.TicketEpoch = abi.ChainEpoch(extraI)
+			}
+			// t.PreCommit1Out (storage.PreCommit1Out) (slice)
+		case "PreCommit1Out":
+
+			maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
+			if err != nil {
+				return err
+			}
+
+			if extra > cbg.ByteArrayMaxLen {
+				return fmt.Errorf("t.PreCommit1Out: byte array too large (%d)", extra)
+			}
+			if maj != cbg.MajByteString {
+				return fmt.Errorf("expected byte array")
+			}
+
+			if extra > 0 {
+				t.PreCommit1Out = make([]uint8, extra)
+			}
+
+			if _, err := io.ReadFull(br, t.PreCommit1Out[:]); err != nil {
+				return err
+			}
+			// t.CommD (cid.Cid) (struct)
+		case "CommD":
+
+			{
+
+				b, err := br.ReadByte()
+				if err != nil {
+					return err
+				}
+				if b != cbg.CborNull[0] {
+					if err := br.UnreadByte(); err != nil {
+						return err
+					}
+
+					c, err := cbg.ReadCid(br)
+					if err != nil {
+						return xerrors.Errorf("failed to read cid field t.CommD: %w", err)
+					}
+
+					t.CommD = &c
+				}
+
+			}
+			// t.CommR (cid.Cid) (struct)
+		case "CommR":
+
+			{
+
+				b, err := br.ReadByte()
+				if err != nil {
+					return err
+				}
+				if b != cbg.CborNull[0] {
+					if err := br.UnreadByte(); err != nil {
+						return err
+					}
+
+					c, err := cbg.ReadCid(br)
+					if err != nil {
+						return xerrors.Errorf("failed to read cid field t.CommR: %w", err)
+					}
+
+					t.CommR = &c
+				}
+
+			}
+			// t.Proof ([]uint8) (slice)
+		case "Proof":
+
+			maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
+			if err != nil {
+				return err
+			}
+
+			if extra > cbg.ByteArrayMaxLen {
+				return fmt.Errorf("t.Proof: byte array too large (%d)", extra)
+			}
+			if maj != cbg.MajByteString {
+				return fmt.Errorf("expected byte array")
+			}
+
+			if extra > 0 {
+				t.Proof = make([]uint8, extra)
+			}
+
+			if _, err := io.ReadFull(br, t.Proof[:]); err != nil {
+				return err
+			}
+			// t.PreCommitInfo (miner.SectorPreCommitInfo) (struct)
+		case "PreCommitInfo":
+
+			{
+
+				b, err := br.ReadByte()
+				if err != nil {
+					return err
+				}
+				if b != cbg.CborNull[0] {
+					if err := br.UnreadByte(); err != nil {
+						return err
+					}
+					t.PreCommitInfo = new(miner.SectorPreCommitInfo)
+					if err := t.PreCommitInfo.UnmarshalCBOR(br); err != nil {
+						return xerrors.Errorf("unmarshaling t.PreCommitInfo pointer: %w", err)
+					}
+				}
+
+			}
+			// t.PreCommitDeposit (big.Int) (struct)
+		case "PreCommitDeposit":
+
+			{
+
+				if err := t.PreCommitDeposit.UnmarshalCBOR(br); err != nil {
+					return xerrors.Errorf("unmarshaling t.PreCommitDeposit: %w", err)
+				}
+
+			}
+			// t.PreCommitMessage (cid.Cid) (struct)
+		case "PreCommitMessage":
+
+			{
+
+				b, err := br.ReadByte()
+				if err != nil {
+					return err
+				}
+				if b != cbg.CborNull[0] {
+					if err := br.UnreadByte(); err != nil {
+						return err
+					}
+
+					c, err := cbg.ReadCid(br)
+					if err != nil {
+						return xerrors.Errorf("failed to read cid field t.PreCommitMessage: %w", err)
+					}
+
+					t.PreCommitMessage = &c
+				}
+
+			}
+			// t.PreCommitTipSet (sealing.TipSetToken) (slice)
+		case "PreCommitTipSet":
+
+			maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
+			if err != nil {
+				return err
+			}
+
+			if extra > cbg.ByteArrayMaxLen {
+				return fmt.Errorf("t.PreCommitTipSet: byte array too large (%d)", extra)
+			}
+			if maj != cbg.MajByteString {
+				return fmt.Errorf("expected byte array")
+			}
+
+			if extra > 0 {
+				t.PreCommitTipSet = make([]uint8, extra)
+			}
+
+			if _, err := io.ReadFull(br, t.PreCommitTipSet[:]); err != nil {
+				return err
+			}
+			// t.PreCommit2Fails (uint64) (uint64)
+		case "PreCommit2Fails":
+
+			{
+
+				maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
+				if err != nil {
+					return err
+				}
+				if maj != cbg.MajUnsignedInt {
+					return fmt.Errorf("wrong type for uint64 field")
+				}
+				t.PreCommit2Fails = uint64(extra)
+
+			}
+			// t.SeedValue (abi.InteractiveSealRandomness) (slice)
+		case "SeedValue":
+
+			maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
+			if err != nil {
+				return err
+			}
+
+			if extra > cbg.ByteArrayMaxLen {
+				return fmt.Errorf("t.SeedValue: byte array too large (%d)", extra)
+			}
+			if maj != cbg.MajByteString {
+				return fmt.Errorf("expected byte array")
+			}
+
+			if extra > 0 {
+				t.SeedValue = make([]uint8, extra)
+			}
+
+			if _, err := io.ReadFull(br, t.SeedValue[:]); err != nil {
+				return err
+			}
+			// t.SeedEpoch (abi.ChainEpoch) (int64)
+		case "SeedEpoch":
+			{
+				maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
+				var extraI int64
+				if err != nil {
+					return err
+				}
+				switch maj {
+				case cbg.MajUnsignedInt:
+					extraI = int64(extra)
+					if extraI < 0 {
+						return fmt.Errorf("int64 positive overflow")
+					}
+				case cbg.MajNegativeInt:
+					extraI = int64(extra)
+					if extraI < 0 {
+						return fmt.Errorf("int64 negative oveflow")
+					}
+					extraI = -1 - extraI
+				default:
+					return fmt.Errorf("wrong type for int64 field: %d", maj)
+				}
+
+				t.SeedEpoch = abi.ChainEpoch(extraI)
+			}
+			// t.CommitMessage (cid.Cid) (struct)
+		case "CommitMessage":
+
+			{
+
+				b, err := br.ReadByte()
+				if err != nil {
+					return err
+				}
+				if b != cbg.CborNull[0] {
+					if err := br.UnreadByte(); err != nil {
+						return err
+					}
+
+					c, err := cbg.ReadCid(br)
+					if err != nil {
+						return xerrors.Errorf("failed to read cid field t.CommitMessage: %w", err)
+					}
+
+					t.CommitMessage = &c
+				}
+
+			}
+			// t.InvalidProofs (uint64) (uint64)
+		case "InvalidProofs":
+
+			{
+
+				maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
+				if err != nil {
+					return err
+				}
+				if maj != cbg.MajUnsignedInt {
+					return fmt.Errorf("wrong type for uint64 field")
+				}
+				t.InvalidProofs = uint64(extra)
+
+			}
+			// t.FaultReportMsg (cid.Cid) (struct)
+		case "FaultReportMsg":
+
+			{
+
+				b, err := br.ReadByte()
+				if err != nil {
+					return err
+				}
+				if b != cbg.CborNull[0] {
+					if err := br.UnreadByte(); err != nil {
+						return err
+					}
+
+					c, err := cbg.ReadCid(br)
+					if err != nil {
+						return xerrors.Errorf("failed to read cid field t.FaultReportMsg: %w", err)
+					}
+
+					t.FaultReportMsg = &c
+				}
+
+			}
+			// t.Return (sealing.ReturnState) (string)
+		case "Return":
+
+			{
+				sval, err := cbg.ReadStringBuf(br, scratch)
+				if err != nil {
+					return err
+				}
+
+				t.Return = ReturnState(sval)
+			}
+			// t.LastErr (string) (string)
+		case "LastErr":
+
+			{
+				sval, err := cbg.ReadStringBuf(br, scratch)
+				if err != nil {
+					return err
+				}
+
+				t.LastErr = string(sval)
+			}
+			// t.Log ([]sealing.Log) (slice)
+		case "Log":
+
+			maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
+			if err != nil {
+				return err
+			}
+
+			if extra > cbg.MaxLength {
+				return fmt.Errorf("t.Log: array too large (%d)", extra)
+			}
+
+			if maj != cbg.MajArray {
+				return fmt.Errorf("expected cbor array")
+			}
+
+			if extra > 0 {
+				t.Log = make([]Log, extra)
+			}
+
+			for i := 0; i < int(extra); i++ {
+
+				var v Log
+				if err := v.UnmarshalCBOR(br); err != nil {
+					return err
+				}
+
+				t.Log[i] = v
+			}
+
+		default:
+			return fmt.Errorf("unknown struct field %d: '%s'", i, name)
+		}
+	}
+
+	return nil
+}
+func (t *Log) MarshalCBOR(w io.Writer) error {
+	if t == nil {
+		_, err := w.Write(cbg.CborNull)
+		return err
+	}
+	if _, err := w.Write([]byte{164}); err != nil {
+		return err
+	}
+
+	scratch := make([]byte, 9)
+
+	// t.Timestamp (uint64) (uint64)
+	if len("Timestamp") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"Timestamp\" was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("Timestamp"))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string("Timestamp")); err != nil {
+		return err
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.Timestamp)); err != nil {
+		return err
+	}
+
+	// t.Trace (string) (string)
+	if len("Trace") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"Trace\" was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("Trace"))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string("Trace")); err != nil {
+		return err
+	}
+
+	if len(t.Trace) > cbg.MaxLength {
+		return xerrors.Errorf("Value in field t.Trace was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len(t.Trace))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string(t.Trace)); err != nil {
+		return err
+	}
+
+	// t.Message (string) (string)
+	if len("Message") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"Message\" was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("Message"))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string("Message")); err != nil {
+		return err
+	}
+
+	if len(t.Message) > cbg.MaxLength {
+		return xerrors.Errorf("Value in field t.Message was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len(t.Message))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string(t.Message)); err != nil {
+		return err
+	}
+
+	// t.Kind (string) (string)
+	if len("Kind") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"Kind\" was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("Kind"))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string("Kind")); err != nil {
+		return err
+	}
+
+	if len(t.Kind) > cbg.MaxLength {
+		return xerrors.Errorf("Value in field t.Kind was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len(t.Kind))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string(t.Kind)); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (t *Log) UnmarshalCBOR(r io.Reader) error {
+	*t = Log{}
+
+	br := cbg.GetPeeker(r)
+	scratch := make([]byte, 8)
+
+	maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
+	if err != nil {
+		return err
+	}
+	if maj != cbg.MajMap {
+		return fmt.Errorf("cbor input should be of type map")
+	}
+
+	if extra > cbg.MaxLength {
+		return fmt.Errorf("Log: map struct too large (%d)", extra)
+	}
+
+	var name string
+	n := extra
+
+	for i := uint64(0); i < n; i++ {
+
+		{
+			sval, err := cbg.ReadStringBuf(br, scratch)
+			if err != nil {
+				return err
+			}
+
+			name = string(sval)
+		}
+
+		switch name {
+		// t.Timestamp (uint64) (uint64)
+		case "Timestamp":
+
+			{
+
+				maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
+				if err != nil {
+					return err
+				}
+				if maj != cbg.MajUnsignedInt {
+					return fmt.Errorf("wrong type for uint64 field")
+				}
+				t.Timestamp = uint64(extra)
+
+			}
+			// t.Trace (string) (string)
+		case "Trace":
+
+			{
+				sval, err := cbg.ReadStringBuf(br, scratch)
+				if err != nil {
+					return err
+				}
+
+				t.Trace = string(sval)
+			}
+			// t.Message (string) (string)
+		case "Message":
+
+			{
+				sval, err := cbg.ReadStringBuf(br, scratch)
+				if err != nil {
+					return err
+				}
+
+				t.Message = string(sval)
+			}
+			// t.Kind (string) (string)
+		case "Kind":
+
+			{
+				sval, err := cbg.ReadStringBuf(br, scratch)
+				if err != nil {
+					return err
+				}
+
+				t.Kind = string(sval)
+			}
+
+		default:
+			return fmt.Errorf("unknown struct field %d: '%s'", i, name)
+		}
+	}
+
+	return nil
+}
diff --git a/extern/storage-sealing/checks.go b/extern/storage-sealing/checks.go
new file mode 100644
index 000000000..49994024f
--- /dev/null
+++ b/extern/storage-sealing/checks.go
@@ -0,0 +1,211 @@
+package sealing
+
+import (
+	"bytes"
+	"context"
+
+	"github.com/filecoin-project/lotus/chain/actors/policy"
+
+	"github.com/filecoin-project/lotus/build"
+	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
+
+	proof0 "github.com/filecoin-project/specs-actors/actors/runtime/proof"
+
+	"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/crypto"
+	"github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper"
+	"github.com/filecoin-project/lotus/extern/sector-storage/zerocomm"
+)
+
+// TODO: For now we handle this by halting state execution, when we get jsonrpc reconnecting
+//  We should implement some wait-for-api logic
+type ErrApi struct{ error }
+
+type ErrInvalidDeals struct{ error }
+type ErrInvalidPiece struct{ error }
+type ErrExpiredDeals struct{ error }
+
+type ErrBadCommD struct{ error }
+type ErrExpiredTicket struct{ error }
+type ErrBadTicket struct{ error }
+type ErrPrecommitOnChain struct{ error }
+type ErrSectorNumberAllocated struct{ error }
+
+type ErrBadSeed struct{ error }
+type ErrInvalidProof struct{ error }
+type ErrNoPrecommit struct{ error }
+type ErrCommitWaitFailed struct{ error }
+
+func checkPieces(ctx context.Context, maddr address.Address, si SectorInfo, api SealingAPI) error {
+	tok, height, err := api.ChainHead(ctx)
+	if err != nil {
+		return &ErrApi{xerrors.Errorf("getting chain head: %w", err)}
+	}
+
+	for i, p := range si.Pieces {
+		// if no deal is associated with the piece, ensure that we added it as
+		// filler (i.e. ensure that it has a zero PieceCID)
+		if p.DealInfo == nil {
+			exp := zerocomm.ZeroPieceCommitment(p.Piece.Size.Unpadded())
+			if !p.Piece.PieceCID.Equals(exp) {
+				return &ErrInvalidPiece{xerrors.Errorf("sector %d piece %d had non-zero PieceCID %+v", si.SectorNumber, i, p.Piece.PieceCID)}
+			}
+			continue
+		}
+
+		proposal, err := api.StateMarketStorageDeal(ctx, p.DealInfo.DealID, tok)
+		if err != nil {
+			return &ErrInvalidDeals{xerrors.Errorf("getting deal %d for piece %d: %w", p.DealInfo.DealID, i, err)}
+		}
+
+		if proposal.Provider != maddr {
+			return &ErrInvalidDeals{xerrors.Errorf("piece %d (of %d) of sector %d refers deal %d with wrong provider: %s != %s", i, len(si.Pieces), si.SectorNumber, p.DealInfo.DealID, proposal.Provider, maddr)}
+		}
+
+		if proposal.PieceCID != p.Piece.PieceCID {
+			return &ErrInvalidDeals{xerrors.Errorf("piece %d (of %d) of sector %d refers deal %d with wrong PieceCID: %x != %x", i, len(si.Pieces), si.SectorNumber, p.DealInfo.DealID, p.Piece.PieceCID, proposal.PieceCID)}
+		}
+
+		if p.Piece.Size != proposal.PieceSize {
+			return &ErrInvalidDeals{xerrors.Errorf("piece %d (of %d) of sector %d refers deal %d with different size: %d != %d", i, len(si.Pieces), si.SectorNumber, p.DealInfo.DealID, p.Piece.Size, proposal.PieceSize)}
+		}
+
+		if height >= proposal.StartEpoch {
+			return &ErrExpiredDeals{xerrors.Errorf("piece %d (of %d) of sector %d refers expired deal %d - should start at %d, head %d", i, len(si.Pieces), si.SectorNumber, p.DealInfo.DealID, proposal.StartEpoch, height)}
+		}
+	}
+
+	return nil
+}
+
+// checkPrecommit checks that data commitment generated in the sealing process
+//  matches pieces, and that the seal ticket isn't expired
+func checkPrecommit(ctx context.Context, maddr address.Address, si SectorInfo, tok TipSetToken, height abi.ChainEpoch, api SealingAPI) (err error) {
+	if err := checkPieces(ctx, maddr, si, api); err != nil {
+		return err
+	}
+
+	commD, err := api.StateComputeDataCommitment(ctx, maddr, si.SectorType, si.dealIDs(), tok)
+	if err != nil {
+		return &ErrApi{xerrors.Errorf("calling StateComputeDataCommitment: %w", err)}
+	}
+
+	if si.CommD == nil || !commD.Equals(*si.CommD) {
+		return &ErrBadCommD{xerrors.Errorf("on chain CommD differs from sector: %s != %s", commD, si.CommD)}
+	}
+
+	nv, err := api.StateNetworkVersion(ctx, tok)
+	if err != nil {
+		return &ErrApi{xerrors.Errorf("calling StateNetworkVersion: %w", err)}
+	}
+
+	var msd abi.ChainEpoch
+	if nv < build.ActorUpgradeNetworkVersion {
+		msd = miner0.MaxSealDuration[si.SectorType]
+	} else {
+		// TODO: ActorUpgrade(use MaxProveCommitDuration)
+		msd = 0
+	}
+
+	if height-(si.TicketEpoch+SealRandomnessLookback) > msd {
+		return &ErrExpiredTicket{xerrors.Errorf("ticket expired: seal height: %d, head: %d", si.TicketEpoch+SealRandomnessLookback, height)}
+	}
+
+	pci, err := api.StateSectorPreCommitInfo(ctx, maddr, si.SectorNumber, tok)
+	if err != nil {
+		if err == ErrSectorAllocated {
+			return &ErrSectorNumberAllocated{err}
+		}
+		return &ErrApi{xerrors.Errorf("getting precommit info: %w", err)}
+	}
+
+	if pci != nil {
+		if pci.Info.SealRandEpoch != si.TicketEpoch {
+			return &ErrBadTicket{xerrors.Errorf("bad ticket epoch: %d != %d", pci.Info.SealRandEpoch, si.TicketEpoch)}
+		}
+		return &ErrPrecommitOnChain{xerrors.Errorf("precommit already on chain")}
+	}
+
+	return nil
+}
+
+func (m *Sealing) checkCommit(ctx context.Context, si SectorInfo, proof []byte, tok TipSetToken) (err error) {
+	if si.SeedEpoch == 0 {
+		return &ErrBadSeed{xerrors.Errorf("seed epoch was not set")}
+	}
+
+	pci, err := m.api.StateSectorPreCommitInfo(ctx, m.maddr, si.SectorNumber, tok)
+	if err == ErrSectorAllocated {
+		// not much more we can check here, basically try to wait for commit,
+		// and hope that this will work
+
+		if si.CommitMessage != nil {
+			return &ErrCommitWaitFailed{err}
+		}
+
+		return err
+	}
+	if err != nil {
+		return xerrors.Errorf("getting precommit info: %w", err)
+	}
+
+	if pci == nil {
+		return &ErrNoPrecommit{xerrors.Errorf("precommit info not found on-chain")}
+	}
+
+	if pci.PreCommitEpoch+policy.GetPreCommitChallengeDelay() != si.SeedEpoch {
+		return &ErrBadSeed{xerrors.Errorf("seed epoch doesn't match on chain info: %d != %d", pci.PreCommitEpoch+policy.GetPreCommitChallengeDelay(), si.SeedEpoch)}
+	}
+
+	buf := new(bytes.Buffer)
+	if err := m.maddr.MarshalCBOR(buf); err != nil {
+		return err
+	}
+
+	seed, err := m.api.ChainGetRandomnessFromBeacon(ctx, tok, crypto.DomainSeparationTag_InteractiveSealChallengeSeed, si.SeedEpoch, buf.Bytes())
+	if err != nil {
+		return &ErrApi{xerrors.Errorf("failed to get randomness for computing seal proof: %w", err)}
+	}
+
+	if string(seed) != string(si.SeedValue) {
+		return &ErrBadSeed{xerrors.Errorf("seed has changed")}
+	}
+
+	ss, err := m.api.StateMinerSectorSize(ctx, m.maddr, tok)
+	if err != nil {
+		return &ErrApi{err}
+	}
+	spt, err := ffiwrapper.SealProofTypeFromSectorSize(ss)
+	if err != nil {
+		return err
+	}
+
+	if *si.CommR != pci.Info.SealedCID {
+		log.Warn("on-chain sealed CID doesn't match!")
+	}
+
+	ok, err := m.verif.VerifySeal(proof0.SealVerifyInfo{
+		SectorID:              m.minerSector(si.SectorNumber),
+		SealedCID:             pci.Info.SealedCID,
+		SealProof:             spt,
+		Proof:                 proof,
+		Randomness:            si.TicketValue,
+		InteractiveRandomness: si.SeedValue,
+		UnsealedCID:           *si.CommD,
+	})
+	if err != nil {
+		return &ErrInvalidProof{xerrors.Errorf("verify seal: %w", err)}
+	}
+	if !ok {
+		return &ErrInvalidProof{xerrors.New("invalid proof (compute error?)")}
+	}
+
+	if err := checkPieces(ctx, m.maddr, si, m.api); err != nil {
+		return err
+	}
+
+	return nil
+}
diff --git a/extern/storage-sealing/constants.go b/extern/storage-sealing/constants.go
new file mode 100644
index 000000000..8c7fa5abc
--- /dev/null
+++ b/extern/storage-sealing/constants.go
@@ -0,0 +1,11 @@
+package sealing
+
+import (
+	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
+)
+
+// Epochs
+const SealRandomnessLookback = miner0.ChainFinality
+
+// Epochs
+const InteractivePoRepConfidence = 6
diff --git a/extern/storage-sealing/events.go b/extern/storage-sealing/events.go
new file mode 100644
index 000000000..298063147
--- /dev/null
+++ b/extern/storage-sealing/events.go
@@ -0,0 +1,15 @@
+package sealing
+
+import (
+	"context"
+
+	"github.com/filecoin-project/go-state-types/abi"
+)
+
+// `curH`-`ts.Height` = `confidence`
+type HeightHandler func(ctx context.Context, tok TipSetToken, curH abi.ChainEpoch) error
+type RevertHandler func(ctx context.Context, tok TipSetToken) error
+
+type Events interface {
+	ChainAt(hnd HeightHandler, rev RevertHandler, confidence int, h abi.ChainEpoch) error
+}
diff --git a/extern/storage-sealing/fsm.go b/extern/storage-sealing/fsm.go
new file mode 100644
index 000000000..0d2e766fd
--- /dev/null
+++ b/extern/storage-sealing/fsm.go
@@ -0,0 +1,489 @@
+//go:generate go run ./gen
+
+package sealing
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"reflect"
+	"time"
+
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-state-types/abi"
+	statemachine "github.com/filecoin-project/go-statemachine"
+)
+
+func (m *Sealing) Plan(events []statemachine.Event, user interface{}) (interface{}, uint64, error) {
+	next, processed, err := m.plan(events, user.(*SectorInfo))
+	if err != nil || next == nil {
+		return nil, processed, err
+	}
+
+	return func(ctx statemachine.Context, si SectorInfo) error {
+		err := next(ctx, si)
+		if err != nil {
+			log.Errorf("unhandled sector error (%d): %+v", si.SectorNumber, err)
+			return nil
+		}
+
+		return nil
+	}, processed, nil // TODO: This processed event count is not very correct
+}
+
+var fsmPlanners = map[SectorState]func(events []statemachine.Event, state *SectorInfo) (uint64, error){
+	// Sealing
+
+	UndefinedSectorState: planOne(
+		on(SectorStart{}, Empty),
+		on(SectorStartCC{}, Packing),
+	),
+	Empty: planOne(on(SectorAddPiece{}, WaitDeals)),
+	WaitDeals: planOne(
+		on(SectorAddPiece{}, WaitDeals),
+		on(SectorStartPacking{}, Packing),
+	),
+	Packing: planOne(on(SectorPacked{}, PreCommit1)),
+	PreCommit1: planOne(
+		on(SectorPreCommit1{}, PreCommit2),
+		on(SectorSealPreCommit1Failed{}, SealPreCommit1Failed),
+		on(SectorDealsExpired{}, DealsExpired),
+		on(SectorInvalidDealIDs{}, RecoverDealIDs),
+	),
+	PreCommit2: planOne(
+		on(SectorPreCommit2{}, PreCommitting),
+		on(SectorSealPreCommit2Failed{}, SealPreCommit2Failed),
+	),
+	PreCommitting: planOne(
+		on(SectorSealPreCommit1Failed{}, SealPreCommit1Failed),
+		on(SectorPreCommitted{}, PreCommitWait),
+		on(SectorChainPreCommitFailed{}, PreCommitFailed),
+		on(SectorPreCommitLanded{}, WaitSeed),
+		on(SectorDealsExpired{}, DealsExpired),
+		on(SectorInvalidDealIDs{}, RecoverDealIDs),
+	),
+	PreCommitWait: planOne(
+		on(SectorChainPreCommitFailed{}, PreCommitFailed),
+		on(SectorPreCommitLanded{}, WaitSeed),
+		on(SectorRetryPreCommit{}, PreCommitting),
+	),
+	WaitSeed: planOne(
+		on(SectorSeedReady{}, Committing),
+		on(SectorChainPreCommitFailed{}, PreCommitFailed),
+	),
+	Committing: planCommitting,
+	SubmitCommit: planOne(
+		on(SectorCommitSubmitted{}, CommitWait),
+		on(SectorCommitFailed{}, CommitFailed),
+	),
+	CommitWait: planOne(
+		on(SectorProving{}, FinalizeSector),
+		on(SectorCommitFailed{}, CommitFailed),
+		on(SectorRetrySubmitCommit{}, SubmitCommit),
+	),
+
+	FinalizeSector: planOne(
+		on(SectorFinalized{}, Proving),
+		on(SectorFinalizeFailed{}, FinalizeFailed),
+	),
+
+	// Sealing errors
+
+	SealPreCommit1Failed: planOne(
+		on(SectorRetrySealPreCommit1{}, PreCommit1),
+	),
+	SealPreCommit2Failed: planOne(
+		on(SectorRetrySealPreCommit1{}, PreCommit1),
+		on(SectorRetrySealPreCommit2{}, PreCommit2),
+	),
+	PreCommitFailed: planOne(
+		on(SectorRetryPreCommit{}, PreCommitting),
+		on(SectorRetryWaitSeed{}, WaitSeed),
+		on(SectorSealPreCommit1Failed{}, SealPreCommit1Failed),
+		on(SectorPreCommitLanded{}, WaitSeed),
+		on(SectorDealsExpired{}, DealsExpired),
+		on(SectorInvalidDealIDs{}, RecoverDealIDs),
+	),
+	ComputeProofFailed: planOne(
+		on(SectorRetryComputeProof{}, Committing),
+		on(SectorSealPreCommit1Failed{}, SealPreCommit1Failed),
+	),
+	CommitFailed: planOne(
+		on(SectorSealPreCommit1Failed{}, SealPreCommit1Failed),
+		on(SectorRetryWaitSeed{}, WaitSeed),
+		on(SectorRetryComputeProof{}, Committing),
+		on(SectorRetryInvalidProof{}, Committing),
+		on(SectorRetryPreCommitWait{}, PreCommitWait),
+		on(SectorChainPreCommitFailed{}, PreCommitFailed),
+		on(SectorRetryPreCommit{}, PreCommitting),
+		on(SectorRetryCommitWait{}, CommitWait),
+		on(SectorDealsExpired{}, DealsExpired),
+		on(SectorInvalidDealIDs{}, RecoverDealIDs),
+	),
+	FinalizeFailed: planOne(
+		on(SectorRetryFinalize{}, FinalizeSector),
+	),
+	PackingFailed: planOne(), // TODO: Deprecated, remove
+	DealsExpired:  planOne(
+	// SectorRemove (global)
+	),
+	RecoverDealIDs: planOne(
+		onReturning(SectorUpdateDealIDs{}),
+	),
+
+	// Post-seal
+
+	Proving: planOne(
+		on(SectorFaultReported{}, FaultReported),
+		on(SectorFaulty{}, Faulty),
+	),
+	Removing: planOne(
+		on(SectorRemoved{}, Removed),
+		on(SectorRemoveFailed{}, RemoveFailed),
+	),
+	RemoveFailed: planOne(
+	// SectorRemove (global)
+	),
+	Faulty: planOne(
+		on(SectorFaultReported{}, FaultReported),
+	),
+
+	FaultedFinal: final,
+	Removed:      final,
+}
+
+func (m *Sealing) plan(events []statemachine.Event, state *SectorInfo) (func(statemachine.Context, SectorInfo) error, uint64, error) {
+	/////
+	// First process all events
+
+	for _, event := range events {
+		e, err := json.Marshal(event)
+		if err != nil {
+			log.Errorf("marshaling event for logging: %+v", err)
+			continue
+		}
+
+		l := Log{
+			Timestamp: uint64(time.Now().Unix()),
+			Message:   string(e),
+			Kind:      fmt.Sprintf("event;%T", event.User),
+		}
+
+		if err, iserr := event.User.(xerrors.Formatter); iserr {
+			l.Trace = fmt.Sprintf("%+v", err)
+		}
+
+		if len(state.Log) > 8000 {
+			log.Warnw("truncating sector log", "sector", state.SectorNumber)
+			state.Log[2000] = Log{
+				Timestamp: uint64(time.Now().Unix()),
+				Message:   "truncating log (above 8000 entries)",
+				Kind:      fmt.Sprintf("truncate"),
+			}
+
+			state.Log = append(state.Log[:2000], state.Log[:6000]...)
+		}
+
+		state.Log = append(state.Log, l)
+	}
+
+	if m.notifee != nil {
+		defer func(before SectorInfo) {
+			m.notifee(before, *state)
+		}(*state) // take safe-ish copy of the before state (except for nested pointers)
+	}
+
+	p := fsmPlanners[state.State]
+	if p == nil {
+		return nil, 0, xerrors.Errorf("planner for state %s not found", state.State)
+	}
+
+	processed, err := p(events, state)
+	if err != nil {
+		return nil, 0, xerrors.Errorf("running planner for state %s failed: %w", state.State, err)
+	}
+
+	/////
+	// Now decide what to do next
+
+	/*
+
+				*   Empty <- incoming deals
+				|   |
+				|   v
+			    *<- WaitDeals <- incoming deals
+				|   |
+				|   v
+				*<- Packing <- incoming committed capacity
+				|   |
+				|   v
+				*<- PreCommit1 <--> SealPreCommit1Failed
+				|   |       ^          ^^
+				|   |       *----------++----\
+				|   v       v          ||    |
+				*<- PreCommit2 --------++--> SealPreCommit2Failed
+				|   |                  ||
+				|   v          /-------/|
+				*   PreCommitting <-----+---> PreCommitFailed
+				|   |                   |     ^
+				|   v                   |     |
+				*<- WaitSeed -----------+-----/
+				|   |||  ^              |
+				|   |||  \--------*-----/
+				|   |||           |
+				|   vvv      v----+----> ComputeProofFailed
+				*<- Committing    |
+				|   |        ^--> CommitFailed
+				|   v             ^
+		        |   SubmitCommit  |
+		        |   |             |
+		        |   v             |
+				*<- CommitWait ---/
+				|   |
+				|   v
+				|   FinalizeSector <--> FinalizeFailed
+				|   |
+				|   v
+				*<- Proving
+				|
+				v
+				FailedUnrecoverable
+
+				UndefinedSectorState <- ¯\_(ツ)_/¯
+					|                     ^
+					*---------------------/
+
+	*/
+
+	m.stats.updateSector(m.minerSector(state.SectorNumber), state.State)
+
+	switch state.State {
+	// Happy path
+	case Empty:
+		fallthrough
+	case WaitDeals:
+		log.Infof("Waiting for deals %d", state.SectorNumber)
+	case Packing:
+		return m.handlePacking, processed, nil
+	case PreCommit1:
+		return m.handlePreCommit1, processed, nil
+	case PreCommit2:
+		return m.handlePreCommit2, processed, nil
+	case PreCommitting:
+		return m.handlePreCommitting, processed, nil
+	case PreCommitWait:
+		return m.handlePreCommitWait, processed, nil
+	case WaitSeed:
+		return m.handleWaitSeed, processed, nil
+	case Committing:
+		return m.handleCommitting, processed, nil
+	case SubmitCommit:
+		return m.handleSubmitCommit, processed, nil
+	case CommitWait:
+		return m.handleCommitWait, processed, nil
+	case FinalizeSector:
+		return m.handleFinalizeSector, processed, nil
+
+	// Handled failure modes
+	case SealPreCommit1Failed:
+		return m.handleSealPrecommit1Failed, processed, nil
+	case SealPreCommit2Failed:
+		return m.handleSealPrecommit2Failed, processed, nil
+	case PreCommitFailed:
+		return m.handlePreCommitFailed, processed, nil
+	case ComputeProofFailed:
+		return m.handleComputeProofFailed, processed, nil
+	case CommitFailed:
+		return m.handleCommitFailed, processed, nil
+	case FinalizeFailed:
+		return m.handleFinalizeFailed, processed, nil
+	case PackingFailed: // DEPRECATED: remove this for the next reset
+		state.State = DealsExpired
+		fallthrough
+	case DealsExpired:
+		return m.handleDealsExpired, processed, nil
+	case RecoverDealIDs:
+		return m.handleRecoverDealIDs, processed, nil
+
+	// Post-seal
+	case Proving:
+		return m.handleProvingSector, processed, nil
+	case Removing:
+		return m.handleRemoving, processed, nil
+	case Removed:
+		return nil, processed, nil
+
+	case RemoveFailed:
+		return m.handleRemoveFailed, processed, nil
+
+		// Faults
+	case Faulty:
+		return m.handleFaulty, processed, nil
+	case FaultReported:
+		return m.handleFaultReported, processed, nil
+
+	// Fatal errors
+	case UndefinedSectorState:
+		log.Error("sector update with undefined state!")
+	case FailedUnrecoverable:
+		log.Errorf("sector %d failed unrecoverably", state.SectorNumber)
+	default:
+		log.Errorf("unexpected sector update state: %s", state.State)
+	}
+
+	return nil, processed, nil
+}
+
+func planCommitting(events []statemachine.Event, state *SectorInfo) (uint64, error) {
+	for i, event := range events {
+		switch e := event.User.(type) {
+		case globalMutator:
+			if e.applyGlobal(state) {
+				return uint64(i + 1), nil
+			}
+		case SectorCommitted: // the normal case
+			e.apply(state)
+			state.State = SubmitCommit
+		case SectorSeedReady: // seed changed :/
+			if e.SeedEpoch == state.SeedEpoch && bytes.Equal(e.SeedValue, state.SeedValue) {
+				log.Warnf("planCommitting: got SectorSeedReady, but the seed didn't change")
+				continue // or it didn't!
+			}
+
+			log.Warnf("planCommitting: commit Seed changed")
+			e.apply(state)
+			state.State = Committing
+			return uint64(i + 1), nil
+		case SectorComputeProofFailed:
+			state.State = ComputeProofFailed
+		case SectorSealPreCommit1Failed:
+			state.State = SealPreCommit1Failed
+		case SectorCommitFailed:
+			state.State = CommitFailed
+		case SectorRetryCommitWait:
+			state.State = CommitWait
+		default:
+			return uint64(i), xerrors.Errorf("planCommitting got event of unknown type %T, events: %+v", event.User, events)
+		}
+	}
+	return uint64(len(events)), nil
+}
+
+func (m *Sealing) restartSectors(ctx context.Context) error {
+	trackedSectors, err := m.ListSectors()
+	if err != nil {
+		log.Errorf("loading sector list: %+v", err)
+	}
+
+	cfg, err := m.getConfig()
+	if err != nil {
+		return xerrors.Errorf("getting the sealing delay: %w", err)
+	}
+
+	m.unsealedInfoMap.lk.Lock()
+	defer m.unsealedInfoMap.lk.Unlock()
+	for _, sector := range trackedSectors {
+		if err := m.sectors.Send(uint64(sector.SectorNumber), SectorRestart{}); err != nil {
+			log.Errorf("restarting sector %d: %+v", sector.SectorNumber, err)
+		}
+
+		if sector.State == WaitDeals {
+
+			// put the sector in the unsealedInfoMap
+			if _, ok := m.unsealedInfoMap.infos[sector.SectorNumber]; ok {
+				// something's funky here, but probably safe to move on
+				log.Warnf("sector %v was already in the unsealedInfoMap when restarting", sector.SectorNumber)
+			} else {
+				ui := UnsealedSectorInfo{}
+				for _, p := range sector.Pieces {
+					if p.DealInfo != nil {
+						ui.numDeals++
+					}
+					ui.stored += p.Piece.Size
+					ui.pieceSizes = append(ui.pieceSizes, p.Piece.Size.Unpadded())
+				}
+
+				m.unsealedInfoMap.infos[sector.SectorNumber] = ui
+			}
+
+			// start a fresh timer for the sector
+			if cfg.WaitDealsDelay > 0 {
+				timer := time.NewTimer(cfg.WaitDealsDelay)
+				go func() {
+					<-timer.C
+					if err := m.StartPacking(sector.SectorNumber); err != nil {
+						log.Errorf("starting sector %d: %+v", sector.SectorNumber, err)
+					}
+				}()
+			}
+		}
+	}
+
+	// TODO: Grab on-chain sector set and diff with trackedSectors
+
+	return nil
+}
+
+func (m *Sealing) ForceSectorState(ctx context.Context, id abi.SectorNumber, state SectorState) error {
+	return m.sectors.Send(id, SectorForceState{state})
+}
+
+func final(events []statemachine.Event, state *SectorInfo) (uint64, error) {
+	return 0, xerrors.Errorf("didn't expect any events in state %s, got %+v", state.State, events)
+}
+
+func on(mut mutator, next SectorState) func() (mutator, func(*SectorInfo) error) {
+	return func() (mutator, func(*SectorInfo) error) {
+		return mut, func(state *SectorInfo) error {
+			state.State = next
+			return nil
+		}
+	}
+}
+
+func onReturning(mut mutator) func() (mutator, func(*SectorInfo) error) {
+	return func() (mutator, func(*SectorInfo) error) {
+		return mut, func(state *SectorInfo) error {
+			if state.Return == "" {
+				return xerrors.Errorf("return state not set")
+			}
+
+			state.State = SectorState(state.Return)
+			state.Return = ""
+			return nil
+		}
+	}
+}
+
+func planOne(ts ...func() (mut mutator, next func(*SectorInfo) error)) func(events []statemachine.Event, state *SectorInfo) (uint64, error) {
+	return func(events []statemachine.Event, state *SectorInfo) (uint64, error) {
+		if gm, ok := events[0].User.(globalMutator); ok {
+			gm.applyGlobal(state)
+			return 1, nil
+		}
+
+		for _, t := range ts {
+			mut, next := t()
+
+			if reflect.TypeOf(events[0].User) != reflect.TypeOf(mut) {
+				continue
+			}
+
+			if err, iserr := events[0].User.(error); iserr {
+				log.Warnf("sector %d got error event %T: %+v", state.SectorNumber, events[0].User, err)
+			}
+
+			events[0].User.(mutator).apply(state)
+			return 1, next(state)
+		}
+
+		_, ok := events[0].User.(Ignorable)
+		if ok {
+			return 1, nil
+		}
+
+		return 0, xerrors.Errorf("planner for state %s received unexpected event %T (%+v)", state.State, events[0].User, events[0])
+	}
+}
diff --git a/extern/storage-sealing/fsm_events.go b/extern/storage-sealing/fsm_events.go
new file mode 100644
index 000000000..3e597d761
--- /dev/null
+++ b/extern/storage-sealing/fsm_events.go
@@ -0,0 +1,318 @@
+package sealing
+
+import (
+	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
+	"github.com/ipfs/go-cid"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/big"
+	"github.com/filecoin-project/specs-storage/storage"
+)
+
+type mutator interface {
+	apply(state *SectorInfo)
+}
+
+// globalMutator is an event which can apply in every state
+type globalMutator interface {
+	// applyGlobal applies the event to the state. If if returns true,
+	//  event processing should be interrupted
+	applyGlobal(state *SectorInfo) bool
+}
+
+type Ignorable interface {
+	Ignore()
+}
+
+// Global events
+
+type SectorRestart struct{}
+
+func (evt SectorRestart) applyGlobal(*SectorInfo) bool { return false }
+
+type SectorFatalError struct{ error }
+
+func (evt SectorFatalError) FormatError(xerrors.Printer) (next error) { return evt.error }
+
+func (evt SectorFatalError) applyGlobal(state *SectorInfo) bool {
+	log.Errorf("Fatal error on sector %d: %+v", state.SectorNumber, evt.error)
+	// TODO: Do we want to mark the state as unrecoverable?
+	//  I feel like this should be a softer error, where the user would
+	//  be able to send a retry event of some kind
+	return true
+}
+
+type SectorForceState struct {
+	State SectorState
+}
+
+func (evt SectorForceState) applyGlobal(state *SectorInfo) bool {
+	state.State = evt.State
+	return true
+}
+
+// Normal path
+
+type SectorStart struct {
+	ID         abi.SectorNumber
+	SectorType abi.RegisteredSealProof
+}
+
+func (evt SectorStart) apply(state *SectorInfo) {
+	state.SectorNumber = evt.ID
+	state.SectorType = evt.SectorType
+}
+
+type SectorStartCC struct {
+	ID         abi.SectorNumber
+	SectorType abi.RegisteredSealProof
+	Pieces     []Piece
+}
+
+func (evt SectorStartCC) apply(state *SectorInfo) {
+	state.SectorNumber = evt.ID
+	state.Pieces = evt.Pieces
+	state.SectorType = evt.SectorType
+}
+
+type SectorAddPiece struct {
+	NewPiece Piece
+}
+
+func (evt SectorAddPiece) apply(state *SectorInfo) {
+	state.Pieces = append(state.Pieces, evt.NewPiece)
+}
+
+type SectorStartPacking struct{}
+
+func (evt SectorStartPacking) apply(*SectorInfo) {}
+
+func (evt SectorStartPacking) Ignore() {}
+
+type SectorPacked struct{ FillerPieces []abi.PieceInfo }
+
+func (evt SectorPacked) apply(state *SectorInfo) {
+	for idx := range evt.FillerPieces {
+		state.Pieces = append(state.Pieces, Piece{
+			Piece:    evt.FillerPieces[idx],
+			DealInfo: nil, // filler pieces don't have deals associated with them
+		})
+	}
+}
+
+type SectorPreCommit1 struct {
+	PreCommit1Out storage.PreCommit1Out
+	TicketValue   abi.SealRandomness
+	TicketEpoch   abi.ChainEpoch
+}
+
+func (evt SectorPreCommit1) apply(state *SectorInfo) {
+	state.PreCommit1Out = evt.PreCommit1Out
+	state.TicketEpoch = evt.TicketEpoch
+	state.TicketValue = evt.TicketValue
+	state.PreCommit2Fails = 0
+}
+
+type SectorPreCommit2 struct {
+	Sealed   cid.Cid
+	Unsealed cid.Cid
+}
+
+func (evt SectorPreCommit2) apply(state *SectorInfo) {
+	commd := evt.Unsealed
+	state.CommD = &commd
+	commr := evt.Sealed
+	state.CommR = &commr
+}
+
+type SectorPreCommitLanded struct {
+	TipSet TipSetToken
+}
+
+func (evt SectorPreCommitLanded) apply(si *SectorInfo) {
+	si.PreCommitTipSet = evt.TipSet
+}
+
+type SectorSealPreCommit1Failed struct{ error }
+
+func (evt SectorSealPreCommit1Failed) FormatError(xerrors.Printer) (next error) { return evt.error }
+func (evt SectorSealPreCommit1Failed) apply(si *SectorInfo) {
+	si.InvalidProofs = 0 // reset counter
+	si.PreCommit2Fails = 0
+}
+
+type SectorSealPreCommit2Failed struct{ error }
+
+func (evt SectorSealPreCommit2Failed) FormatError(xerrors.Printer) (next error) { return evt.error }
+func (evt SectorSealPreCommit2Failed) apply(si *SectorInfo) {
+	si.InvalidProofs = 0 // reset counter
+	si.PreCommit2Fails++
+}
+
+type SectorChainPreCommitFailed struct{ error }
+
+func (evt SectorChainPreCommitFailed) FormatError(xerrors.Printer) (next error) { return evt.error }
+func (evt SectorChainPreCommitFailed) apply(*SectorInfo)                        {}
+
+type SectorPreCommitted struct {
+	Message          cid.Cid
+	PreCommitDeposit big.Int
+	PreCommitInfo    miner.SectorPreCommitInfo
+}
+
+func (evt SectorPreCommitted) apply(state *SectorInfo) {
+	state.PreCommitMessage = &evt.Message
+	state.PreCommitDeposit = evt.PreCommitDeposit
+	state.PreCommitInfo = &evt.PreCommitInfo
+}
+
+type SectorSeedReady struct {
+	SeedValue abi.InteractiveSealRandomness
+	SeedEpoch abi.ChainEpoch
+}
+
+func (evt SectorSeedReady) apply(state *SectorInfo) {
+	state.SeedEpoch = evt.SeedEpoch
+	state.SeedValue = evt.SeedValue
+}
+
+type SectorComputeProofFailed struct{ error }
+
+func (evt SectorComputeProofFailed) FormatError(xerrors.Printer) (next error) { return evt.error }
+func (evt SectorComputeProofFailed) apply(*SectorInfo)                        {}
+
+type SectorCommitFailed struct{ error }
+
+func (evt SectorCommitFailed) FormatError(xerrors.Printer) (next error) { return evt.error }
+func (evt SectorCommitFailed) apply(*SectorInfo)                        {}
+
+type SectorRetrySubmitCommit struct{}
+
+func (evt SectorRetrySubmitCommit) apply(*SectorInfo) {}
+
+type SectorDealsExpired struct{ error }
+
+func (evt SectorDealsExpired) FormatError(xerrors.Printer) (next error) { return evt.error }
+func (evt SectorDealsExpired) apply(*SectorInfo)                        {}
+
+type SectorCommitted struct {
+	Proof []byte
+}
+
+func (evt SectorCommitted) apply(state *SectorInfo) {
+	state.Proof = evt.Proof
+}
+
+type SectorCommitSubmitted struct {
+	Message cid.Cid
+}
+
+func (evt SectorCommitSubmitted) apply(state *SectorInfo) {
+	state.CommitMessage = &evt.Message
+}
+
+type SectorProving struct{}
+
+func (evt SectorProving) apply(*SectorInfo) {}
+
+type SectorFinalized struct{}
+
+func (evt SectorFinalized) apply(*SectorInfo) {}
+
+type SectorRetryFinalize struct{}
+
+func (evt SectorRetryFinalize) apply(*SectorInfo) {}
+
+type SectorFinalizeFailed struct{ error }
+
+func (evt SectorFinalizeFailed) FormatError(xerrors.Printer) (next error) { return evt.error }
+func (evt SectorFinalizeFailed) apply(*SectorInfo)                        {}
+
+// Failed state recovery
+
+type SectorRetrySealPreCommit1 struct{}
+
+func (evt SectorRetrySealPreCommit1) apply(state *SectorInfo) {}
+
+type SectorRetrySealPreCommit2 struct{}
+
+func (evt SectorRetrySealPreCommit2) apply(state *SectorInfo) {}
+
+type SectorRetryPreCommit struct{}
+
+func (evt SectorRetryPreCommit) apply(state *SectorInfo) {}
+
+type SectorRetryWaitSeed struct{}
+
+func (evt SectorRetryWaitSeed) apply(state *SectorInfo) {}
+
+type SectorRetryPreCommitWait struct{}
+
+func (evt SectorRetryPreCommitWait) apply(state *SectorInfo) {}
+
+type SectorRetryComputeProof struct{}
+
+func (evt SectorRetryComputeProof) apply(state *SectorInfo) {
+	state.InvalidProofs++
+}
+
+type SectorRetryInvalidProof struct{}
+
+func (evt SectorRetryInvalidProof) apply(state *SectorInfo) {
+	state.InvalidProofs++
+}
+
+type SectorRetryCommitWait struct{}
+
+func (evt SectorRetryCommitWait) apply(state *SectorInfo) {}
+
+type SectorInvalidDealIDs struct {
+	Return ReturnState
+}
+
+func (evt SectorInvalidDealIDs) apply(state *SectorInfo) {
+	state.Return = evt.Return
+}
+
+type SectorUpdateDealIDs struct {
+	Updates map[int]abi.DealID
+}
+
+func (evt SectorUpdateDealIDs) apply(state *SectorInfo) {
+	for i, id := range evt.Updates {
+		state.Pieces[i].DealInfo.DealID = id
+	}
+}
+
+// Faults
+
+type SectorFaulty struct{}
+
+func (evt SectorFaulty) apply(state *SectorInfo) {}
+
+type SectorFaultReported struct{ reportMsg cid.Cid }
+
+func (evt SectorFaultReported) apply(state *SectorInfo) {
+	state.FaultReportMsg = &evt.reportMsg
+}
+
+type SectorFaultedFinal struct{}
+
+// External events
+
+type SectorRemove struct{}
+
+func (evt SectorRemove) applyGlobal(state *SectorInfo) bool {
+	state.State = Removing
+	return true
+}
+
+type SectorRemoved struct{}
+
+func (evt SectorRemoved) apply(state *SectorInfo) {}
+
+type SectorRemoveFailed struct{ error }
+
+func (evt SectorRemoveFailed) FormatError(xerrors.Printer) (next error) { return evt.error }
+func (evt SectorRemoveFailed) apply(*SectorInfo)                        {}
diff --git a/extern/storage-sealing/fsm_test.go b/extern/storage-sealing/fsm_test.go
new file mode 100644
index 000000000..51fd2a37b
--- /dev/null
+++ b/extern/storage-sealing/fsm_test.go
@@ -0,0 +1,156 @@
+package sealing
+
+import (
+	"testing"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/abi"
+	logging "github.com/ipfs/go-log/v2"
+	"github.com/stretchr/testify/require"
+
+	"github.com/filecoin-project/go-statemachine"
+)
+
+func init() {
+	_ = logging.SetLogLevel("*", "INFO")
+}
+
+func (t *test) planSingle(evt interface{}) {
+	_, _, err := t.s.plan([]statemachine.Event{{User: evt}}, t.state)
+	require.NoError(t.t, err)
+}
+
+type test struct {
+	s     *Sealing
+	t     *testing.T
+	state *SectorInfo
+}
+
+func TestHappyPath(t *testing.T) {
+	var notif []struct{ before, after SectorInfo }
+	ma, _ := address.NewIDAddress(55151)
+	m := test{
+		s: &Sealing{
+			maddr: ma,
+			stats: SectorStats{
+				bySector: map[abi.SectorID]statSectorState{},
+			},
+			notifee: func(before, after SectorInfo) {
+				notif = append(notif, struct{ before, after SectorInfo }{before, after})
+			},
+		},
+		t:     t,
+		state: &SectorInfo{State: Packing},
+	}
+
+	m.planSingle(SectorPacked{})
+	require.Equal(m.t, m.state.State, PreCommit1)
+
+	m.planSingle(SectorPreCommit1{})
+	require.Equal(m.t, m.state.State, PreCommit2)
+
+	m.planSingle(SectorPreCommit2{})
+	require.Equal(m.t, m.state.State, PreCommitting)
+
+	m.planSingle(SectorPreCommitted{})
+	require.Equal(m.t, m.state.State, PreCommitWait)
+
+	m.planSingle(SectorPreCommitLanded{})
+	require.Equal(m.t, m.state.State, WaitSeed)
+
+	m.planSingle(SectorSeedReady{})
+	require.Equal(m.t, m.state.State, Committing)
+
+	m.planSingle(SectorCommitted{})
+	require.Equal(m.t, m.state.State, SubmitCommit)
+
+	m.planSingle(SectorCommitSubmitted{})
+	require.Equal(m.t, m.state.State, CommitWait)
+
+	m.planSingle(SectorProving{})
+	require.Equal(m.t, m.state.State, FinalizeSector)
+
+	m.planSingle(SectorFinalized{})
+	require.Equal(m.t, m.state.State, Proving)
+
+	expected := []SectorState{Packing, PreCommit1, PreCommit2, PreCommitting, PreCommitWait, WaitSeed, Committing, SubmitCommit, CommitWait, FinalizeSector, Proving}
+	for i, n := range notif {
+		if n.before.State != expected[i] {
+			t.Fatalf("expected before state: %s, got: %s", expected[i], n.before.State)
+		}
+		if n.after.State != expected[i+1] {
+			t.Fatalf("expected after state: %s, got: %s", expected[i+1], n.after.State)
+		}
+	}
+}
+
+func TestSeedRevert(t *testing.T) {
+	ma, _ := address.NewIDAddress(55151)
+	m := test{
+		s: &Sealing{
+			maddr: ma,
+			stats: SectorStats{
+				bySector: map[abi.SectorID]statSectorState{},
+			},
+		},
+		t:     t,
+		state: &SectorInfo{State: Packing},
+	}
+
+	m.planSingle(SectorPacked{})
+	require.Equal(m.t, m.state.State, PreCommit1)
+
+	m.planSingle(SectorPreCommit1{})
+	require.Equal(m.t, m.state.State, PreCommit2)
+
+	m.planSingle(SectorPreCommit2{})
+	require.Equal(m.t, m.state.State, PreCommitting)
+
+	m.planSingle(SectorPreCommitted{})
+	require.Equal(m.t, m.state.State, PreCommitWait)
+
+	m.planSingle(SectorPreCommitLanded{})
+	require.Equal(m.t, m.state.State, WaitSeed)
+
+	m.planSingle(SectorSeedReady{})
+	require.Equal(m.t, m.state.State, Committing)
+
+	_, _, err := m.s.plan([]statemachine.Event{{User: SectorSeedReady{SeedValue: nil, SeedEpoch: 5}}, {User: SectorCommitted{}}}, m.state)
+	require.NoError(t, err)
+	require.Equal(m.t, m.state.State, Committing)
+
+	// not changing the seed this time
+	_, _, err = m.s.plan([]statemachine.Event{{User: SectorSeedReady{SeedValue: nil, SeedEpoch: 5}}, {User: SectorCommitted{}}}, m.state)
+	require.NoError(t, err)
+	require.Equal(m.t, m.state.State, SubmitCommit)
+
+	m.planSingle(SectorCommitSubmitted{})
+	require.Equal(m.t, m.state.State, CommitWait)
+
+	m.planSingle(SectorProving{})
+	require.Equal(m.t, m.state.State, FinalizeSector)
+
+	m.planSingle(SectorFinalized{})
+	require.Equal(m.t, m.state.State, Proving)
+}
+
+func TestPlanCommittingHandlesSectorCommitFailed(t *testing.T) {
+	ma, _ := address.NewIDAddress(55151)
+	m := test{
+		s: &Sealing{
+			maddr: ma,
+			stats: SectorStats{
+				bySector: map[abi.SectorID]statSectorState{},
+			},
+		},
+		t:     t,
+		state: &SectorInfo{State: Committing},
+	}
+
+	events := []statemachine.Event{{User: SectorCommitFailed{}}}
+
+	_, err := planCommitting(events, m.state)
+	require.NoError(t, err)
+
+	require.Equal(t, CommitFailed, m.state.State)
+}
diff --git a/extern/storage-sealing/garbage.go b/extern/storage-sealing/garbage.go
new file mode 100644
index 000000000..caf371806
--- /dev/null
+++ b/extern/storage-sealing/garbage.go
@@ -0,0 +1,83 @@
+package sealing
+
+import (
+	"context"
+
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-state-types/abi"
+)
+
+func (m *Sealing) pledgeSector(ctx context.Context, sectorID abi.SectorID, existingPieceSizes []abi.UnpaddedPieceSize, sizes ...abi.UnpaddedPieceSize) ([]abi.PieceInfo, error) {
+	if len(sizes) == 0 {
+		return nil, nil
+	}
+
+	log.Infof("Pledge %d, contains %+v", sectorID, existingPieceSizes)
+
+	out := make([]abi.PieceInfo, len(sizes))
+	for i, size := range sizes {
+		ppi, err := m.sealer.AddPiece(ctx, sectorID, existingPieceSizes, size, NewNullReader(size))
+		if err != nil {
+			return nil, xerrors.Errorf("add piece: %w", err)
+		}
+
+		existingPieceSizes = append(existingPieceSizes, size)
+
+		out[i] = ppi
+	}
+
+	return out, nil
+}
+
+func (m *Sealing) PledgeSector() error {
+	cfg, err := m.getConfig()
+	if err != nil {
+		return xerrors.Errorf("getting config: %w", err)
+	}
+
+	if cfg.MaxSealingSectors > 0 {
+		if m.stats.curSealing() > cfg.MaxSealingSectors {
+			return xerrors.Errorf("too many sectors sealing (curSealing: %d, max: %d)", m.stats.curSealing(), cfg.MaxSealingSectors)
+		}
+	}
+
+	go func() {
+		ctx := context.TODO() // we can't use the context from command which invokes
+		// this, as we run everything here async, and it's cancelled when the
+		// command exits
+
+		size := abi.PaddedPieceSize(m.sealer.SectorSize()).Unpadded()
+
+		sid, err := m.sc.Next()
+		if err != nil {
+			log.Errorf("%+v", err)
+			return
+		}
+		err = m.sealer.NewSector(ctx, m.minerSector(sid))
+		if err != nil {
+			log.Errorf("%+v", err)
+			return
+		}
+
+		pieces, err := m.pledgeSector(ctx, m.minerSector(sid), []abi.UnpaddedPieceSize{}, size)
+		if err != nil {
+			log.Errorf("%+v", err)
+			return
+		}
+
+		ps := make([]Piece, len(pieces))
+		for idx := range ps {
+			ps[idx] = Piece{
+				Piece:    pieces[idx],
+				DealInfo: nil,
+			}
+		}
+
+		if err := m.newSectorCC(sid, ps); err != nil {
+			log.Errorf("%+v", err)
+			return
+		}
+	}()
+	return nil
+}
diff --git a/extern/storage-sealing/gen/main.go b/extern/storage-sealing/gen/main.go
new file mode 100644
index 000000000..97c2bacd5
--- /dev/null
+++ b/extern/storage-sealing/gen/main.go
@@ -0,0 +1,24 @@
+package main
+
+import (
+	"fmt"
+	"os"
+
+	gen "github.com/whyrusleeping/cbor-gen"
+
+	sealing "github.com/filecoin-project/lotus/extern/storage-sealing"
+)
+
+func main() {
+	err := gen.WriteMapEncodersToFile("./cbor_gen.go", "sealing",
+		sealing.Piece{},
+		sealing.DealInfo{},
+		sealing.DealSchedule{},
+		sealing.SectorInfo{},
+		sealing.Log{},
+	)
+	if err != nil {
+		fmt.Println(err)
+		os.Exit(1)
+	}
+}
diff --git a/extern/storage-sealing/lib/nullreader/nullreader.go b/extern/storage-sealing/lib/nullreader/nullreader.go
new file mode 100644
index 000000000..dc3537ad7
--- /dev/null
+++ b/extern/storage-sealing/lib/nullreader/nullreader.go
@@ -0,0 +1,11 @@
+package nullreader
+
+// TODO: extract this to someplace where it can be shared with lotus
+type Reader struct{}
+
+func (Reader) Read(out []byte) (int, error) {
+	for i := range out {
+		out[i] = 0
+	}
+	return len(out), nil
+}
diff --git a/extern/storage-sealing/nullreader.go b/extern/storage-sealing/nullreader.go
new file mode 100644
index 000000000..5987a4145
--- /dev/null
+++ b/extern/storage-sealing/nullreader.go
@@ -0,0 +1,20 @@
+package sealing
+
+import (
+	"io"
+
+	"github.com/filecoin-project/go-state-types/abi"
+	nr "github.com/filecoin-project/lotus/extern/storage-sealing/lib/nullreader"
+)
+
+type NullReader struct {
+	*io.LimitedReader
+}
+
+func NewNullReader(size abi.UnpaddedPieceSize) io.Reader {
+	return &NullReader{(io.LimitReader(&nr.Reader{}, int64(size))).(*io.LimitedReader)}
+}
+
+func (m NullReader) NullBytes() int64 {
+	return m.N
+}
diff --git a/extern/storage-sealing/precommit_policy.go b/extern/storage-sealing/precommit_policy.go
new file mode 100644
index 000000000..0b774b56f
--- /dev/null
+++ b/extern/storage-sealing/precommit_policy.go
@@ -0,0 +1,86 @@
+package sealing
+
+import (
+	"context"
+
+	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
+
+	"github.com/filecoin-project/go-state-types/network"
+
+	"github.com/filecoin-project/go-state-types/abi"
+)
+
+type PreCommitPolicy interface {
+	Expiration(ctx context.Context, ps ...Piece) (abi.ChainEpoch, error)
+}
+
+type Chain interface {
+	ChainHead(ctx context.Context) (TipSetToken, abi.ChainEpoch, error)
+	StateNetworkVersion(ctx context.Context, tok TipSetToken) (network.Version, error)
+}
+
+// BasicPreCommitPolicy satisfies PreCommitPolicy. It has two modes:
+//
+// Mode 1: The sector contains a non-zero quantity of pieces with deal info
+// Mode 2: The sector contains no pieces with deal info
+//
+// The BasicPreCommitPolicy#Expiration method is given a slice of the pieces
+// which the miner has encoded into the sector, and from that slice picks either
+// the first or second mode.
+//
+// If we're in Mode 1: The pre-commit expiration epoch will be the maximum
+// deal end epoch of a piece in the sector.
+//
+// If we're in Mode 2: The pre-commit expiration epoch will be set to the
+// current epoch + the provided default duration.
+type BasicPreCommitPolicy struct {
+	api Chain
+
+	provingBoundary abi.ChainEpoch
+	duration        abi.ChainEpoch
+}
+
+// NewBasicPreCommitPolicy produces a BasicPreCommitPolicy
+func NewBasicPreCommitPolicy(api Chain, duration abi.ChainEpoch, provingBoundary abi.ChainEpoch) BasicPreCommitPolicy {
+	return BasicPreCommitPolicy{
+		api:             api,
+		provingBoundary: provingBoundary,
+		duration:        duration,
+	}
+}
+
+// Expiration produces the pre-commit sector expiration epoch for an encoded
+// replica containing the provided enumeration of pieces and deals.
+func (p *BasicPreCommitPolicy) Expiration(ctx context.Context, ps ...Piece) (abi.ChainEpoch, error) {
+	_, epoch, err := p.api.ChainHead(ctx)
+	if err != nil {
+		return 0, err
+	}
+
+	var end *abi.ChainEpoch
+
+	for _, p := range ps {
+		if p.DealInfo == nil {
+			continue
+		}
+
+		if p.DealInfo.DealSchedule.EndEpoch < epoch {
+			log.Warnf("piece schedule %+v ended before current epoch %d", p, epoch)
+			continue
+		}
+
+		if end == nil || *end < p.DealInfo.DealSchedule.EndEpoch {
+			tmp := p.DealInfo.DealSchedule.EndEpoch
+			end = &tmp
+		}
+	}
+
+	if end == nil {
+		tmp := epoch + p.duration
+		end = &tmp
+	}
+
+	*end += miner.WPoStProvingPeriod - (*end % miner.WPoStProvingPeriod) + p.provingBoundary - 1
+
+	return *end, nil
+}
diff --git a/extern/storage-sealing/precommit_policy_test.go b/extern/storage-sealing/precommit_policy_test.go
new file mode 100644
index 000000000..52814167a
--- /dev/null
+++ b/extern/storage-sealing/precommit_policy_test.go
@@ -0,0 +1,149 @@
+package sealing_test
+
+import (
+	"context"
+	"testing"
+
+	"github.com/filecoin-project/go-state-types/network"
+	"github.com/filecoin-project/lotus/build"
+
+	"github.com/ipfs/go-cid"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	commcid "github.com/filecoin-project/go-fil-commcid"
+	"github.com/filecoin-project/go-state-types/abi"
+
+	sealing "github.com/filecoin-project/lotus/extern/storage-sealing"
+)
+
+type fakeChain struct {
+	h abi.ChainEpoch
+}
+
+func (f *fakeChain) StateNetworkVersion(ctx context.Context, tok sealing.TipSetToken) (network.Version, error) {
+	return build.NewestNetworkVersion, nil
+}
+
+func (f *fakeChain) ChainHead(ctx context.Context) (sealing.TipSetToken, abi.ChainEpoch, error) {
+	return []byte{1, 2, 3}, f.h, nil
+}
+
+func fakePieceCid(t *testing.T) cid.Cid {
+	comm := [32]byte{1, 2, 3}
+	fakePieceCid, err := commcid.ReplicaCommitmentV1ToCID(comm[:])
+	require.NoError(t, err)
+	return fakePieceCid
+}
+
+func TestBasicPolicyEmptySector(t *testing.T) {
+	policy := sealing.NewBasicPreCommitPolicy(&fakeChain{
+		h: abi.ChainEpoch(55),
+	}, 10, 0)
+
+	exp, err := policy.Expiration(context.Background())
+	require.NoError(t, err)
+
+	assert.Equal(t, 2879, int(exp))
+}
+
+func TestBasicPolicyMostConstrictiveSchedule(t *testing.T) {
+	policy := sealing.NewBasicPreCommitPolicy(&fakeChain{
+		h: abi.ChainEpoch(55),
+	}, 100, 11)
+
+	pieces := []sealing.Piece{
+		{
+			Piece: abi.PieceInfo{
+				Size:     abi.PaddedPieceSize(1024),
+				PieceCID: fakePieceCid(t),
+			},
+			DealInfo: &sealing.DealInfo{
+				DealID: abi.DealID(42),
+				DealSchedule: sealing.DealSchedule{
+					StartEpoch: abi.ChainEpoch(70),
+					EndEpoch:   abi.ChainEpoch(75),
+				},
+			},
+		},
+		{
+			Piece: abi.PieceInfo{
+				Size:     abi.PaddedPieceSize(1024),
+				PieceCID: fakePieceCid(t),
+			},
+			DealInfo: &sealing.DealInfo{
+				DealID: abi.DealID(43),
+				DealSchedule: sealing.DealSchedule{
+					StartEpoch: abi.ChainEpoch(80),
+					EndEpoch:   abi.ChainEpoch(100),
+				},
+			},
+		},
+	}
+
+	exp, err := policy.Expiration(context.Background(), pieces...)
+	require.NoError(t, err)
+
+	assert.Equal(t, 2890, int(exp))
+}
+
+func TestBasicPolicyIgnoresExistingScheduleIfExpired(t *testing.T) {
+	policy := sealing.NewBasicPreCommitPolicy(&fakeChain{
+		h: abi.ChainEpoch(55),
+	}, 100, 0)
+
+	pieces := []sealing.Piece{
+		{
+			Piece: abi.PieceInfo{
+				Size:     abi.PaddedPieceSize(1024),
+				PieceCID: fakePieceCid(t),
+			},
+			DealInfo: &sealing.DealInfo{
+				DealID: abi.DealID(44),
+				DealSchedule: sealing.DealSchedule{
+					StartEpoch: abi.ChainEpoch(1),
+					EndEpoch:   abi.ChainEpoch(10),
+				},
+			},
+		},
+	}
+
+	exp, err := policy.Expiration(context.Background(), pieces...)
+	require.NoError(t, err)
+
+	assert.Equal(t, 2879, int(exp))
+}
+
+func TestMissingDealIsIgnored(t *testing.T) {
+	policy := sealing.NewBasicPreCommitPolicy(&fakeChain{
+		h: abi.ChainEpoch(55),
+	}, 100, 11)
+
+	pieces := []sealing.Piece{
+		{
+			Piece: abi.PieceInfo{
+				Size:     abi.PaddedPieceSize(1024),
+				PieceCID: fakePieceCid(t),
+			},
+			DealInfo: &sealing.DealInfo{
+				DealID: abi.DealID(44),
+				DealSchedule: sealing.DealSchedule{
+					StartEpoch: abi.ChainEpoch(1),
+					EndEpoch:   abi.ChainEpoch(10),
+				},
+			},
+		},
+		{
+			Piece: abi.PieceInfo{
+				Size:     abi.PaddedPieceSize(1024),
+				PieceCID: fakePieceCid(t),
+			},
+			DealInfo: nil,
+		},
+	}
+
+	exp, err := policy.Expiration(context.Background(), pieces...)
+	require.NoError(t, err)
+
+	assert.Equal(t, 2890, int(exp))
+}
diff --git a/extern/storage-sealing/sealiface/config.go b/extern/storage-sealing/sealiface/config.go
new file mode 100644
index 000000000..945565562
--- /dev/null
+++ b/extern/storage-sealing/sealiface/config.go
@@ -0,0 +1,18 @@
+package sealiface
+
+import "time"
+
+// this has to be in a separate package to not make lotus API depend on filecoin-ffi
+
+type Config struct {
+	// 0 = no limit
+	MaxWaitDealsSectors uint64
+
+	// includes failed, 0 = no limit
+	MaxSealingSectors uint64
+
+	// includes failed, 0 = no limit
+	MaxSealingSectorsForDeals uint64
+
+	WaitDealsDelay time.Duration
+}
diff --git a/extern/storage-sealing/sealing.go b/extern/storage-sealing/sealing.go
new file mode 100644
index 000000000..1ba53661a
--- /dev/null
+++ b/extern/storage-sealing/sealing.go
@@ -0,0 +1,421 @@
+package sealing
+
+import (
+	"context"
+	"errors"
+	"io"
+	"math"
+	"sync"
+	"time"
+
+	"github.com/filecoin-project/go-state-types/network"
+	"github.com/ipfs/go-cid"
+	"github.com/ipfs/go-datastore"
+	"github.com/ipfs/go-datastore/namespace"
+	logging "github.com/ipfs/go-log/v2"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-address"
+	padreader "github.com/filecoin-project/go-padreader"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/big"
+	"github.com/filecoin-project/go-state-types/crypto"
+	statemachine "github.com/filecoin-project/go-statemachine"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/market"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
+	sectorstorage "github.com/filecoin-project/lotus/extern/sector-storage"
+	"github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper"
+)
+
+const SectorStorePrefix = "/sectors"
+
+var ErrTooManySectorsSealing = xerrors.New("too many sectors sealing")
+
+var log = logging.Logger("sectors")
+
+type SectorLocation struct {
+	Deadline  uint64
+	Partition uint64
+}
+
+var ErrSectorAllocated = errors.New("sectorNumber is allocated, but PreCommit info wasn't found on chain")
+
+type SealingAPI interface {
+	StateWaitMsg(context.Context, cid.Cid) (MsgLookup, error)
+	StateSearchMsg(context.Context, cid.Cid) (*MsgLookup, error)
+	StateComputeDataCommitment(ctx context.Context, maddr address.Address, sectorType abi.RegisteredSealProof, deals []abi.DealID, tok TipSetToken) (cid.Cid, error)
+
+	// Can return ErrSectorAllocated in case precommit info wasn't found, but the sector number is marked as allocated
+	StateSectorPreCommitInfo(ctx context.Context, maddr address.Address, sectorNumber abi.SectorNumber, tok TipSetToken) (*miner.SectorPreCommitOnChainInfo, error)
+	StateSectorGetInfo(ctx context.Context, maddr address.Address, sectorNumber abi.SectorNumber, tok TipSetToken) (*miner.SectorOnChainInfo, error)
+	StateSectorPartition(ctx context.Context, maddr address.Address, sectorNumber abi.SectorNumber, tok TipSetToken) (*SectorLocation, error)
+	StateMinerSectorSize(context.Context, address.Address, TipSetToken) (abi.SectorSize, error)
+	StateMinerWorkerAddress(ctx context.Context, maddr address.Address, tok TipSetToken) (address.Address, error)
+	StateMinerPreCommitDepositForPower(context.Context, address.Address, miner.SectorPreCommitInfo, TipSetToken) (big.Int, error)
+	StateMinerInitialPledgeCollateral(context.Context, address.Address, miner.SectorPreCommitInfo, TipSetToken) (big.Int, error)
+	StateMarketStorageDeal(context.Context, abi.DealID, TipSetToken) (market.DealProposal, error)
+	StateNetworkVersion(ctx context.Context, tok TipSetToken) (network.Version, error)
+	SendMsg(ctx context.Context, from, to address.Address, method abi.MethodNum, value, maxFee abi.TokenAmount, params []byte) (cid.Cid, error)
+	ChainHead(ctx context.Context) (TipSetToken, abi.ChainEpoch, error)
+	ChainGetRandomnessFromBeacon(ctx context.Context, tok TipSetToken, personalization crypto.DomainSeparationTag, randEpoch abi.ChainEpoch, entropy []byte) (abi.Randomness, error)
+	ChainGetRandomnessFromTickets(ctx context.Context, tok TipSetToken, personalization crypto.DomainSeparationTag, randEpoch abi.ChainEpoch, entropy []byte) (abi.Randomness, error)
+	ChainReadObj(context.Context, cid.Cid) ([]byte, error)
+}
+
+type SectorStateNotifee func(before, after SectorInfo)
+
+type Sealing struct {
+	api    SealingAPI
+	feeCfg FeeConfig
+	events Events
+
+	maddr address.Address
+
+	sealer  sectorstorage.SectorManager
+	sectors *statemachine.StateGroup
+	sc      SectorIDCounter
+	verif   ffiwrapper.Verifier
+
+	pcp             PreCommitPolicy
+	unsealedInfoMap UnsealedSectorMap
+
+	upgradeLk sync.Mutex
+	toUpgrade map[abi.SectorNumber]struct{}
+
+	notifee SectorStateNotifee
+
+	stats SectorStats
+
+	getConfig GetSealingConfigFunc
+}
+
+type FeeConfig struct {
+	MaxPreCommitGasFee abi.TokenAmount
+	MaxCommitGasFee    abi.TokenAmount
+}
+
+type UnsealedSectorMap struct {
+	infos map[abi.SectorNumber]UnsealedSectorInfo
+	lk    sync.Mutex
+}
+
+type UnsealedSectorInfo struct {
+	numDeals uint64
+	// stored should always equal sum of pieceSizes.Padded()
+	stored     abi.PaddedPieceSize
+	pieceSizes []abi.UnpaddedPieceSize
+}
+
+func New(api SealingAPI, fc FeeConfig, events Events, maddr address.Address, ds datastore.Batching, sealer sectorstorage.SectorManager, sc SectorIDCounter, verif ffiwrapper.Verifier, pcp PreCommitPolicy, gc GetSealingConfigFunc, notifee SectorStateNotifee) *Sealing {
+	s := &Sealing{
+		api:    api,
+		feeCfg: fc,
+		events: events,
+
+		maddr:  maddr,
+		sealer: sealer,
+		sc:     sc,
+		verif:  verif,
+		pcp:    pcp,
+		unsealedInfoMap: UnsealedSectorMap{
+			infos: make(map[abi.SectorNumber]UnsealedSectorInfo),
+			lk:    sync.Mutex{},
+		},
+
+		toUpgrade: map[abi.SectorNumber]struct{}{},
+
+		notifee: notifee,
+
+		getConfig: gc,
+
+		stats: SectorStats{
+			bySector: map[abi.SectorID]statSectorState{},
+		},
+	}
+
+	s.sectors = statemachine.New(namespace.Wrap(ds, datastore.NewKey(SectorStorePrefix)), s, SectorInfo{})
+
+	return s
+}
+
+func (m *Sealing) Run(ctx context.Context) error {
+	if err := m.restartSectors(ctx); err != nil {
+		log.Errorf("%+v", err)
+		return xerrors.Errorf("failed load sector states: %w", err)
+	}
+
+	return nil
+}
+
+func (m *Sealing) Stop(ctx context.Context) error {
+	return m.sectors.Stop(ctx)
+}
+func (m *Sealing) AddPieceToAnySector(ctx context.Context, size abi.UnpaddedPieceSize, r io.Reader, d DealInfo) (abi.SectorNumber, abi.PaddedPieceSize, error) {
+	log.Infof("Adding piece for deal %d (publish msg: %s)", d.DealID, d.PublishCid)
+	if (padreader.PaddedSize(uint64(size))) != size {
+		return 0, 0, xerrors.Errorf("cannot allocate unpadded piece")
+	}
+
+	if size > abi.PaddedPieceSize(m.sealer.SectorSize()).Unpadded() {
+		return 0, 0, xerrors.Errorf("piece cannot fit into a sector")
+	}
+
+	m.unsealedInfoMap.lk.Lock()
+
+	sid, pads, err := m.getSectorAndPadding(size)
+	if err != nil {
+		m.unsealedInfoMap.lk.Unlock()
+		return 0, 0, xerrors.Errorf("getting available sector: %w", err)
+	}
+
+	for _, p := range pads {
+		err = m.addPiece(ctx, sid, p.Unpadded(), NewNullReader(p.Unpadded()), nil)
+		if err != nil {
+			m.unsealedInfoMap.lk.Unlock()
+			return 0, 0, xerrors.Errorf("writing pads: %w", err)
+		}
+	}
+
+	offset := m.unsealedInfoMap.infos[sid].stored
+	err = m.addPiece(ctx, sid, size, r, &d)
+
+	if err != nil {
+		m.unsealedInfoMap.lk.Unlock()
+		return 0, 0, xerrors.Errorf("adding piece to sector: %w", err)
+	}
+
+	startPacking := m.unsealedInfoMap.infos[sid].numDeals >= getDealPerSectorLimit(m.sealer.SectorSize())
+
+	m.unsealedInfoMap.lk.Unlock()
+
+	if startPacking {
+		if err := m.StartPacking(sid); err != nil {
+			return 0, 0, xerrors.Errorf("start packing: %w", err)
+		}
+	}
+
+	return sid, offset, nil
+}
+
+// Caller should hold m.unsealedInfoMap.lk
+func (m *Sealing) addPiece(ctx context.Context, sectorID abi.SectorNumber, size abi.UnpaddedPieceSize, r io.Reader, di *DealInfo) error {
+	log.Infof("Adding piece to sector %d", sectorID)
+	ppi, err := m.sealer.AddPiece(sectorstorage.WithPriority(ctx, DealSectorPriority), m.minerSector(sectorID), m.unsealedInfoMap.infos[sectorID].pieceSizes, size, r)
+	if err != nil {
+		return xerrors.Errorf("writing piece: %w", err)
+	}
+	piece := Piece{
+		Piece:    ppi,
+		DealInfo: di,
+	}
+
+	err = m.sectors.Send(uint64(sectorID), SectorAddPiece{NewPiece: piece})
+	if err != nil {
+		return err
+	}
+
+	ui := m.unsealedInfoMap.infos[sectorID]
+	num := m.unsealedInfoMap.infos[sectorID].numDeals
+	if di != nil {
+		num = num + 1
+	}
+	m.unsealedInfoMap.infos[sectorID] = UnsealedSectorInfo{
+		numDeals:   num,
+		stored:     ui.stored + piece.Piece.Size,
+		pieceSizes: append(ui.pieceSizes, piece.Piece.Size.Unpadded()),
+	}
+
+	return nil
+}
+
+func (m *Sealing) Remove(ctx context.Context, sid abi.SectorNumber) error {
+	return m.sectors.Send(uint64(sid), SectorRemove{})
+}
+
+// Caller should NOT hold m.unsealedInfoMap.lk
+func (m *Sealing) StartPacking(sectorID abi.SectorNumber) error {
+	// locking here ensures that when the SectorStartPacking event is sent, the sector won't be picked up anywhere else
+	m.unsealedInfoMap.lk.Lock()
+	defer m.unsealedInfoMap.lk.Unlock()
+
+	// cannot send SectorStartPacking to sectors that have already been packed, otherwise it will cause the state machine to exit
+	if _, ok := m.unsealedInfoMap.infos[sectorID]; !ok {
+		log.Warnf("call start packing, but sector %v not in unsealedInfoMap.infos, maybe have called", sectorID)
+		return nil
+	}
+	log.Infof("Starting packing sector %d", sectorID)
+	err := m.sectors.Send(uint64(sectorID), SectorStartPacking{})
+	if err != nil {
+		return err
+	}
+	log.Infof("send Starting packing event success sector %d", sectorID)
+
+	delete(m.unsealedInfoMap.infos, sectorID)
+
+	return nil
+}
+
+// Caller should hold m.unsealedInfoMap.lk
+func (m *Sealing) getSectorAndPadding(size abi.UnpaddedPieceSize) (abi.SectorNumber, []abi.PaddedPieceSize, error) {
+	ss := abi.PaddedPieceSize(m.sealer.SectorSize())
+	for k, v := range m.unsealedInfoMap.infos {
+		pads, padLength := ffiwrapper.GetRequiredPadding(v.stored, size.Padded())
+		if v.stored+size.Padded()+padLength <= ss {
+			return k, pads, nil
+		}
+	}
+
+	ns, err := m.newDealSector()
+	if err != nil {
+		return 0, nil, err
+	}
+
+	m.unsealedInfoMap.infos[ns] = UnsealedSectorInfo{
+		numDeals:   0,
+		stored:     0,
+		pieceSizes: nil,
+	}
+
+	return ns, nil, nil
+}
+
+// newDealSector creates a new sector for deal storage
+func (m *Sealing) newDealSector() (abi.SectorNumber, error) {
+	// First make sure we don't have too many 'open' sectors
+
+	cfg, err := m.getConfig()
+	if err != nil {
+		return 0, xerrors.Errorf("getting config: %w", err)
+	}
+
+	if cfg.MaxSealingSectorsForDeals > 0 {
+		if m.stats.curSealing() > cfg.MaxSealingSectorsForDeals {
+			return 0, ErrTooManySectorsSealing
+		}
+	}
+
+	if cfg.MaxWaitDealsSectors > 0 {
+		// run in a loop because we have to drop the map lock here for a bit
+		tries := 0
+
+		// we have to run in a loop as we're dropping unsealedInfoMap.lk
+		//  to actually call StartPacking. When we do that, another entry can
+		//  get added to unsealedInfoMap.
+		for uint64(len(m.unsealedInfoMap.infos)) >= cfg.MaxWaitDealsSectors {
+			if tries > 10 {
+				// whatever...
+				break
+			}
+
+			if tries > 0 {
+				m.unsealedInfoMap.lk.Unlock()
+				time.Sleep(time.Second)
+				m.unsealedInfoMap.lk.Lock()
+			}
+
+			tries++
+			var mostStored abi.PaddedPieceSize = math.MaxUint64
+			var best abi.SectorNumber = math.MaxUint64
+
+			for sn, info := range m.unsealedInfoMap.infos {
+				if info.stored+1 > mostStored+1 { // 18446744073709551615 + 1 = 0
+					best = sn
+				}
+			}
+
+			if best == math.MaxUint64 {
+				// probably not possible, but who knows
+				break
+			}
+
+			m.unsealedInfoMap.lk.Unlock()
+			if err := m.StartPacking(best); err != nil {
+				log.Error("newDealSector StartPacking error: %+v", err)
+				continue // let's pretend this is fine
+			}
+			m.unsealedInfoMap.lk.Lock()
+		}
+	}
+
+	// Now actually create a new sector
+
+	sid, err := m.sc.Next()
+	if err != nil {
+		return 0, xerrors.Errorf("getting sector number: %w", err)
+	}
+
+	err = m.sealer.NewSector(context.TODO(), m.minerSector(sid))
+	if err != nil {
+		return 0, xerrors.Errorf("initializing sector: %w", err)
+	}
+
+	rt, err := ffiwrapper.SealProofTypeFromSectorSize(m.sealer.SectorSize())
+	if err != nil {
+		return 0, xerrors.Errorf("bad sector size: %w", err)
+	}
+
+	log.Infof("Creating sector %d", sid)
+	err = m.sectors.Send(uint64(sid), SectorStart{
+		ID:         sid,
+		SectorType: rt,
+	})
+
+	if err != nil {
+		return 0, xerrors.Errorf("starting the sector fsm: %w", err)
+	}
+
+	cf, err := m.getConfig()
+	if err != nil {
+		return 0, xerrors.Errorf("getting the sealing delay: %w", err)
+	}
+
+	if cf.WaitDealsDelay > 0 {
+		timer := time.NewTimer(cf.WaitDealsDelay)
+		go func() {
+			<-timer.C
+			if err := m.StartPacking(sid); err != nil {
+				log.Errorf("starting sector %d: %+v", sid, err)
+			}
+		}()
+	}
+
+	return sid, nil
+}
+
+// newSectorCC accepts a slice of pieces with no deal (junk data)
+func (m *Sealing) newSectorCC(sid abi.SectorNumber, pieces []Piece) error {
+	rt, err := ffiwrapper.SealProofTypeFromSectorSize(m.sealer.SectorSize())
+	if err != nil {
+		return xerrors.Errorf("bad sector size: %w", err)
+	}
+
+	log.Infof("Creating CC sector %d", sid)
+	return m.sectors.Send(uint64(sid), SectorStartCC{
+		ID:         sid,
+		Pieces:     pieces,
+		SectorType: rt,
+	})
+}
+
+func (m *Sealing) minerSector(num abi.SectorNumber) abi.SectorID {
+	mid, err := address.IDFromAddress(m.maddr)
+	if err != nil {
+		panic(err)
+	}
+
+	return abi.SectorID{
+		Number: num,
+		Miner:  abi.ActorID(mid),
+	}
+}
+
+func (m *Sealing) Address() address.Address {
+	return m.maddr
+}
+
+func getDealPerSectorLimit(size abi.SectorSize) uint64 {
+	if size < 64<<30 {
+		return 256
+	}
+	return 512
+}
diff --git a/extern/storage-sealing/sector_state.go b/extern/storage-sealing/sector_state.go
new file mode 100644
index 000000000..10b96e504
--- /dev/null
+++ b/extern/storage-sealing/sector_state.go
@@ -0,0 +1,84 @@
+package sealing
+
+type SectorState string
+
+var ExistSectorStateList = map[SectorState]struct{}{
+	Empty:                {},
+	WaitDeals:            {},
+	Packing:              {},
+	PreCommit1:           {},
+	PreCommit2:           {},
+	PreCommitting:        {},
+	PreCommitWait:        {},
+	WaitSeed:             {},
+	Committing:           {},
+	SubmitCommit:         {},
+	CommitWait:           {},
+	FinalizeSector:       {},
+	Proving:              {},
+	FailedUnrecoverable:  {},
+	SealPreCommit1Failed: {},
+	SealPreCommit2Failed: {},
+	PreCommitFailed:      {},
+	ComputeProofFailed:   {},
+	CommitFailed:         {},
+	PackingFailed:        {},
+	FinalizeFailed:       {},
+	DealsExpired:         {},
+	RecoverDealIDs:       {},
+	Faulty:               {},
+	FaultReported:        {},
+	FaultedFinal:         {},
+	Removing:             {},
+	RemoveFailed:         {},
+	Removed:              {},
+}
+
+const (
+	UndefinedSectorState SectorState = ""
+
+	// happy path
+	Empty          SectorState = "Empty"
+	WaitDeals      SectorState = "WaitDeals"     // waiting for more pieces (deals) to be added to the sector
+	Packing        SectorState = "Packing"       // sector not in sealStore, and not on chain
+	PreCommit1     SectorState = "PreCommit1"    // do PreCommit1
+	PreCommit2     SectorState = "PreCommit2"    // do PreCommit2
+	PreCommitting  SectorState = "PreCommitting" // on chain pre-commit
+	PreCommitWait  SectorState = "PreCommitWait" // waiting for precommit to land on chain
+	WaitSeed       SectorState = "WaitSeed"      // waiting for seed
+	Committing     SectorState = "Committing"    // compute PoRep
+	SubmitCommit   SectorState = "SubmitCommit"  // send commit message to the chain
+	CommitWait     SectorState = "CommitWait"    // wait for the commit message to land on chain
+	FinalizeSector SectorState = "FinalizeSector"
+	Proving        SectorState = "Proving"
+	// error modes
+	FailedUnrecoverable  SectorState = "FailedUnrecoverable"
+	SealPreCommit1Failed SectorState = "SealPreCommit1Failed"
+	SealPreCommit2Failed SectorState = "SealPreCommit2Failed"
+	PreCommitFailed      SectorState = "PreCommitFailed"
+	ComputeProofFailed   SectorState = "ComputeProofFailed"
+	CommitFailed         SectorState = "CommitFailed"
+	PackingFailed        SectorState = "PackingFailed" // TODO: deprecated, remove
+	FinalizeFailed       SectorState = "FinalizeFailed"
+	DealsExpired         SectorState = "DealsExpired"
+	RecoverDealIDs       SectorState = "RecoverDealIDs"
+
+	Faulty        SectorState = "Faulty"        // sector is corrupted or gone for some reason
+	FaultReported SectorState = "FaultReported" // sector has been declared as a fault on chain
+	FaultedFinal  SectorState = "FaultedFinal"  // fault declared on chain
+
+	Removing     SectorState = "Removing"
+	RemoveFailed SectorState = "RemoveFailed"
+	Removed      SectorState = "Removed"
+)
+
+func toStatState(st SectorState) statSectorState {
+	switch st {
+	case Empty, WaitDeals, Packing, PreCommit1, PreCommit2, PreCommitting, PreCommitWait, WaitSeed, Committing, CommitWait, FinalizeSector:
+		return sstSealing
+	case Proving, Removed, Removing:
+		return sstProving
+	}
+
+	return sstFailed
+}
diff --git a/extern/storage-sealing/states_failed.go b/extern/storage-sealing/states_failed.go
new file mode 100644
index 000000000..b026e70f9
--- /dev/null
+++ b/extern/storage-sealing/states_failed.go
@@ -0,0 +1,363 @@
+package sealing
+
+import (
+	"bytes"
+	"time"
+
+	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
+
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/exitcode"
+	"github.com/filecoin-project/go-statemachine"
+	"github.com/filecoin-project/specs-actors/actors/builtin/market"
+
+	"github.com/filecoin-project/lotus/extern/sector-storage/zerocomm"
+)
+
+const minRetryTime = 1 * time.Minute
+
+func failedCooldown(ctx statemachine.Context, sector SectorInfo) error {
+	// TODO: Exponential backoff when we see consecutive failures
+
+	retryStart := time.Unix(int64(sector.Log[len(sector.Log)-1].Timestamp), 0).Add(minRetryTime)
+	if len(sector.Log) > 0 && !time.Now().After(retryStart) {
+		log.Infof("%s(%d), waiting %s before retrying", sector.State, sector.SectorNumber, time.Until(retryStart))
+		select {
+		case <-time.After(time.Until(retryStart)):
+		case <-ctx.Context().Done():
+			return ctx.Context().Err()
+		}
+	}
+
+	return nil
+}
+
+func (m *Sealing) checkPreCommitted(ctx statemachine.Context, sector SectorInfo) (*miner.SectorPreCommitOnChainInfo, bool) {
+	tok, _, err := m.api.ChainHead(ctx.Context())
+	if err != nil {
+		log.Errorf("handleSealPrecommit1Failed(%d): temp error: %+v", sector.SectorNumber, err)
+		return nil, true
+	}
+
+	info, err := m.api.StateSectorPreCommitInfo(ctx.Context(), m.maddr, sector.SectorNumber, tok)
+	if err != nil {
+		log.Errorf("handleSealPrecommit1Failed(%d): temp error: %+v", sector.SectorNumber, err)
+		return nil, true
+	}
+
+	return info, false
+}
+
+func (m *Sealing) handleSealPrecommit1Failed(ctx statemachine.Context, sector SectorInfo) error {
+	if err := failedCooldown(ctx, sector); err != nil {
+		return err
+	}
+
+	return ctx.Send(SectorRetrySealPreCommit1{})
+}
+
+func (m *Sealing) handleSealPrecommit2Failed(ctx statemachine.Context, sector SectorInfo) error {
+	if err := failedCooldown(ctx, sector); err != nil {
+		return err
+	}
+
+	if sector.PreCommit2Fails > 3 {
+		return ctx.Send(SectorRetrySealPreCommit1{})
+	}
+
+	return ctx.Send(SectorRetrySealPreCommit2{})
+}
+
+func (m *Sealing) handlePreCommitFailed(ctx statemachine.Context, sector SectorInfo) error {
+	tok, height, err := m.api.ChainHead(ctx.Context())
+	if err != nil {
+		log.Errorf("handlePreCommitFailed: api error, not proceeding: %+v", err)
+		return nil
+	}
+
+	if err := checkPrecommit(ctx.Context(), m.Address(), sector, tok, height, m.api); err != nil {
+		switch err.(type) {
+		case *ErrApi:
+			log.Errorf("handlePreCommitFailed: api error, not proceeding: %+v", err)
+			return nil
+		case *ErrBadCommD: // TODO: Should this just back to packing? (not really needed since handlePreCommit1 will do that too)
+			return ctx.Send(SectorSealPreCommit1Failed{xerrors.Errorf("bad CommD error: %w", err)})
+		case *ErrExpiredTicket:
+			return ctx.Send(SectorSealPreCommit1Failed{xerrors.Errorf("ticket expired error: %w", err)})
+		case *ErrBadTicket:
+			return ctx.Send(SectorSealPreCommit1Failed{xerrors.Errorf("bad expired: %w", err)})
+		case *ErrInvalidDeals:
+			log.Warnf("invalid deals in sector %d: %v", sector.SectorNumber, err)
+			return ctx.Send(SectorInvalidDealIDs{Return: RetPreCommitFailed})
+		case *ErrExpiredDeals:
+			return ctx.Send(SectorDealsExpired{xerrors.Errorf("sector deals expired: %w", err)})
+		case *ErrNoPrecommit:
+			return ctx.Send(SectorRetryPreCommit{})
+		case *ErrPrecommitOnChain:
+			// noop
+		case *ErrSectorNumberAllocated:
+			log.Errorf("handlePreCommitFailed: sector number already allocated, not proceeding: %+v", err)
+			// TODO: check if the sector is committed (not sure how we'd end up here)
+			// TODO: check on-chain state, adjust local sector number counter to not give out allocated numbers
+			return nil
+		default:
+			return xerrors.Errorf("checkPrecommit sanity check error: %w", err)
+		}
+	}
+
+	if pci, is := m.checkPreCommitted(ctx, sector); is && pci != nil {
+		if sector.PreCommitMessage != nil {
+			log.Warn("sector %d is precommitted on chain, but we don't have precommit message", sector.SectorNumber)
+			return ctx.Send(SectorPreCommitLanded{TipSet: tok})
+		}
+
+		if pci.Info.SealedCID != *sector.CommR {
+			log.Warn("sector %d is precommitted on chain, with different CommR: %x != %x", sector.SectorNumber, pci.Info.SealedCID, sector.CommR)
+			return nil // TODO: remove when the actor allows re-precommit
+		}
+
+		// TODO: we could compare more things, but I don't think we really need to
+		//  CommR tells us that CommD (and CommPs), and the ticket are all matching
+
+		if err := failedCooldown(ctx, sector); err != nil {
+			return err
+		}
+
+		return ctx.Send(SectorRetryWaitSeed{})
+	}
+
+	if sector.PreCommitMessage != nil {
+		log.Warn("retrying precommit even though the message failed to apply")
+	}
+
+	if err := failedCooldown(ctx, sector); err != nil {
+		return err
+	}
+
+	return ctx.Send(SectorRetryPreCommit{})
+}
+
+func (m *Sealing) handleComputeProofFailed(ctx statemachine.Context, sector SectorInfo) error {
+	// TODO: Check sector files
+
+	if err := failedCooldown(ctx, sector); err != nil {
+		return err
+	}
+
+	if sector.InvalidProofs > 1 {
+		return ctx.Send(SectorSealPreCommit1Failed{xerrors.Errorf("consecutive compute fails")})
+	}
+
+	return ctx.Send(SectorRetryComputeProof{})
+}
+
+func (m *Sealing) handleCommitFailed(ctx statemachine.Context, sector SectorInfo) error {
+	tok, height, err := m.api.ChainHead(ctx.Context())
+	if err != nil {
+		log.Errorf("handleCommitting: api error, not proceeding: %+v", err)
+		return nil
+	}
+
+	if err := checkPrecommit(ctx.Context(), m.maddr, sector, tok, height, m.api); err != nil {
+		switch err.(type) {
+		case *ErrApi:
+			log.Errorf("handleCommitFailed: api error, not proceeding: %+v", err)
+			return nil
+		case *ErrBadCommD:
+			return ctx.Send(SectorSealPreCommit1Failed{xerrors.Errorf("bad CommD error: %w", err)})
+		case *ErrExpiredTicket:
+			return ctx.Send(SectorSealPreCommit1Failed{xerrors.Errorf("ticket expired error: %w", err)})
+		case *ErrBadTicket:
+			return ctx.Send(SectorSealPreCommit1Failed{xerrors.Errorf("bad ticket: %w", err)})
+		case *ErrInvalidDeals:
+			log.Warnf("invalid deals in sector %d: %v", sector.SectorNumber, err)
+			return ctx.Send(SectorInvalidDealIDs{Return: RetCommitFailed})
+		case *ErrExpiredDeals:
+			return ctx.Send(SectorDealsExpired{xerrors.Errorf("sector deals expired: %w", err)})
+		case nil:
+			return ctx.Send(SectorChainPreCommitFailed{xerrors.Errorf("no precommit: %w", err)})
+		case *ErrPrecommitOnChain:
+			// noop, this is expected
+		case *ErrSectorNumberAllocated:
+			// noop, already committed?
+		default:
+			return xerrors.Errorf("checkPrecommit sanity check error (%T): %w", err, err)
+		}
+	}
+
+	if err := m.checkCommit(ctx.Context(), sector, sector.Proof, tok); err != nil {
+		switch err.(type) {
+		case *ErrApi:
+			log.Errorf("handleCommitFailed: api error, not proceeding: %+v", err)
+			return nil
+		case *ErrBadSeed:
+			log.Errorf("seed changed, will retry: %+v", err)
+			return ctx.Send(SectorRetryWaitSeed{})
+		case *ErrInvalidProof:
+			if err := failedCooldown(ctx, sector); err != nil {
+				return err
+			}
+
+			if sector.InvalidProofs > 0 {
+				return ctx.Send(SectorSealPreCommit1Failed{xerrors.Errorf("consecutive invalid proofs")})
+			}
+
+			return ctx.Send(SectorRetryInvalidProof{})
+		case *ErrPrecommitOnChain:
+			log.Errorf("no precommit on chain, will retry: %+v", err)
+			return ctx.Send(SectorRetryPreCommitWait{})
+		case *ErrNoPrecommit:
+			return ctx.Send(SectorRetryPreCommit{})
+		case *ErrInvalidDeals:
+			log.Warnf("invalid deals in sector %d: %v", sector.SectorNumber, err)
+			return ctx.Send(SectorInvalidDealIDs{Return: RetCommitFailed})
+		case *ErrExpiredDeals:
+			return ctx.Send(SectorDealsExpired{xerrors.Errorf("sector deals expired: %w", err)})
+		case *ErrCommitWaitFailed:
+			if err := failedCooldown(ctx, sector); err != nil {
+				return err
+			}
+
+			return ctx.Send(SectorRetryCommitWait{})
+		default:
+			return xerrors.Errorf("checkCommit sanity check error (%T): %w", err, err)
+		}
+	}
+
+	// TODO: Check sector files
+
+	if err := failedCooldown(ctx, sector); err != nil {
+		return err
+	}
+
+	return ctx.Send(SectorRetryComputeProof{})
+}
+
+func (m *Sealing) handleFinalizeFailed(ctx statemachine.Context, sector SectorInfo) error {
+	// TODO: Check sector files
+
+	if err := failedCooldown(ctx, sector); err != nil {
+		return err
+	}
+
+	return ctx.Send(SectorRetryFinalize{})
+}
+
+func (m *Sealing) handleRemoveFailed(ctx statemachine.Context, sector SectorInfo) error {
+	if err := failedCooldown(ctx, sector); err != nil {
+		return err
+	}
+
+	return ctx.Send(SectorRemove{})
+}
+
+func (m *Sealing) handleDealsExpired(ctx statemachine.Context, sector SectorInfo) error {
+	// First make vary sure the sector isn't committed
+	si, err := m.api.StateSectorGetInfo(ctx.Context(), m.maddr, sector.SectorNumber, nil)
+	if err != nil {
+		return xerrors.Errorf("getting sector info: %w", err)
+	}
+	if si != nil {
+		// TODO: this should never happen, but in case it does, try to go back to
+		//  the proving state after running some checks
+		return xerrors.Errorf("sector is committed on-chain, but we're in DealsExpired")
+	}
+
+	if sector.PreCommitInfo == nil {
+		// TODO: Create a separate state which will remove those pieces, and go back to PC1
+		log.Errorf("non-precommitted sector with expired deals, can't recover from this yet")
+	}
+
+	// Not much to do here, we can't go back in time to commit this sector
+	return ctx.Send(SectorRemove{})
+}
+
+func (m *Sealing) handleRecoverDealIDs(ctx statemachine.Context, sector SectorInfo) error {
+	tok, height, err := m.api.ChainHead(ctx.Context())
+	if err != nil {
+		return xerrors.Errorf("getting chain head: %w", err)
+	}
+
+	var toFix []int
+
+	for i, p := range sector.Pieces {
+		// if no deal is associated with the piece, ensure that we added it as
+		// filler (i.e. ensure that it has a zero PieceCID)
+		if p.DealInfo == nil {
+			exp := zerocomm.ZeroPieceCommitment(p.Piece.Size.Unpadded())
+			if !p.Piece.PieceCID.Equals(exp) {
+				return xerrors.Errorf("sector %d piece %d had non-zero PieceCID %+v", sector.SectorNumber, i, p.Piece.PieceCID)
+			}
+			continue
+		}
+
+		proposal, err := m.api.StateMarketStorageDeal(ctx.Context(), p.DealInfo.DealID, tok)
+		if err != nil {
+			log.Warnf("getting deal %d for piece %d: %+v", p.DealInfo.DealID, i, err)
+			toFix = append(toFix, i)
+			continue
+		}
+
+		if proposal.Provider != m.maddr {
+			log.Warnf("piece %d (of %d) of sector %d refers deal %d with wrong provider: %s != %s", i, len(sector.Pieces), sector.SectorNumber, p.DealInfo.DealID, proposal.Provider, m.maddr)
+			toFix = append(toFix, i)
+			continue
+		}
+
+		if proposal.PieceCID != p.Piece.PieceCID {
+			log.Warnf("piece %d (of %d) of sector %d refers deal %d with wrong PieceCID: %x != %x", i, len(sector.Pieces), sector.SectorNumber, p.DealInfo.DealID, p.Piece.PieceCID, proposal.PieceCID)
+			toFix = append(toFix, i)
+			continue
+		}
+
+		if p.Piece.Size != proposal.PieceSize {
+			log.Warnf("piece %d (of %d) of sector %d refers deal %d with different size: %d != %d", i, len(sector.Pieces), sector.SectorNumber, p.DealInfo.DealID, p.Piece.Size, proposal.PieceSize)
+			toFix = append(toFix, i)
+			continue
+		}
+
+		if height >= proposal.StartEpoch {
+			// TODO: check if we are in an early enough state (before precommit), try to remove the offending pieces
+			//  (tricky as we have to 'defragment' the sector while doing that, and update piece references for retrieval)
+			return xerrors.Errorf("can't fix sector deals: piece %d (of %d) of sector %d refers expired deal %d - should start at %d, head %d", i, len(sector.Pieces), sector.SectorNumber, p.DealInfo.DealID, proposal.StartEpoch, height)
+		}
+	}
+
+	updates := map[int]abi.DealID{}
+	for _, i := range toFix {
+		p := sector.Pieces[i]
+
+		if p.DealInfo.PublishCid == nil {
+			// TODO: check if we are in an early enough state try to remove this piece
+			log.Error("can't fix sector deals: piece %d (of %d) of sector %d has nil DealInfo.PublishCid (refers to deal %d)", i, len(sector.Pieces), sector.SectorNumber, p.DealInfo.DealID)
+			// Not much to do here (and this can only happen for old spacerace sectors)
+			return ctx.Send(SectorRemove{})
+		}
+
+		ml, err := m.api.StateSearchMsg(ctx.Context(), *p.DealInfo.PublishCid)
+		if err != nil {
+			return xerrors.Errorf("looking for publish deal message %s (sector %d, piece %d): %w", *p.DealInfo.PublishCid, sector.SectorNumber, i, err)
+		}
+
+		if ml.Receipt.ExitCode != exitcode.Ok {
+			return xerrors.Errorf("looking for publish deal message %s (sector %d, piece %d): non-ok exit code: %s", *p.DealInfo.PublishCid, sector.SectorNumber, i, ml.Receipt.ExitCode)
+		}
+
+		var retval market.PublishStorageDealsReturn
+		if err := retval.UnmarshalCBOR(bytes.NewReader(ml.Receipt.Return)); err != nil {
+			return xerrors.Errorf("looking for publish deal message: unmarshaling message return: %w", err)
+		}
+
+		if len(retval.IDs) != 1 {
+			// market currently only ever sends messages with 1 deal
+			return xerrors.Errorf("can't recover dealIDs from publish deal message with more than 1 deal")
+		}
+
+		updates[i] = retval.IDs[0]
+	}
+
+	// Not much to do here, we can't go back in time to commit this sector
+	return ctx.Send(SectorUpdateDealIDs{Updates: updates})
+}
diff --git a/extern/storage-sealing/states_proving.go b/extern/storage-sealing/states_proving.go
new file mode 100644
index 000000000..6684c714d
--- /dev/null
+++ b/extern/storage-sealing/states_proving.go
@@ -0,0 +1,40 @@
+package sealing
+
+import (
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-statemachine"
+)
+
+func (m *Sealing) handleFaulty(ctx statemachine.Context, sector SectorInfo) error {
+	// TODO: noop because this is now handled by the PoSt scheduler. We can reuse
+	//  this state for tracking faulty sectors, or remove it when that won't be
+	//  a breaking change
+	return nil
+}
+
+func (m *Sealing) handleFaultReported(ctx statemachine.Context, sector SectorInfo) error {
+	if sector.FaultReportMsg == nil {
+		return xerrors.Errorf("entered fault reported state without a FaultReportMsg cid")
+	}
+
+	mw, err := m.api.StateWaitMsg(ctx.Context(), *sector.FaultReportMsg)
+	if err != nil {
+		return xerrors.Errorf("failed to wait for fault declaration: %w", err)
+	}
+
+	if mw.Receipt.ExitCode != 0 {
+		log.Errorf("UNHANDLED: declaring sector fault failed (exit=%d, msg=%s) (id: %d)", mw.Receipt.ExitCode, *sector.FaultReportMsg, sector.SectorNumber)
+		return xerrors.Errorf("UNHANDLED: submitting fault declaration failed (exit %d)", mw.Receipt.ExitCode)
+	}
+
+	return ctx.Send(SectorFaultedFinal{})
+}
+
+func (m *Sealing) handleRemoving(ctx statemachine.Context, sector SectorInfo) error {
+	if err := m.sealer.Remove(ctx.Context(), m.minerSector(sector.SectorNumber)); err != nil {
+		return ctx.Send(SectorRemoveFailed{err})
+	}
+
+	return ctx.Send(SectorRemoved{})
+}
diff --git a/extern/storage-sealing/states_sealing.go b/extern/storage-sealing/states_sealing.go
new file mode 100644
index 000000000..a4e852454
--- /dev/null
+++ b/extern/storage-sealing/states_sealing.go
@@ -0,0 +1,475 @@
+package sealing
+
+import (
+	"bytes"
+	"context"
+
+	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
+	"github.com/filecoin-project/lotus/chain/actors/policy"
+	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
+
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/big"
+	"github.com/filecoin-project/go-state-types/crypto"
+	"github.com/filecoin-project/go-state-types/exitcode"
+	"github.com/filecoin-project/go-statemachine"
+	"github.com/filecoin-project/specs-actors/actors/builtin"
+	"github.com/filecoin-project/specs-storage/storage"
+)
+
+var DealSectorPriority = 1024
+
+func (m *Sealing) handlePacking(ctx statemachine.Context, sector SectorInfo) error {
+	log.Infow("performing filling up rest of the sector...", "sector", sector.SectorNumber)
+
+	var allocated abi.UnpaddedPieceSize
+	for _, piece := range sector.Pieces {
+		allocated += piece.Piece.Size.Unpadded()
+	}
+
+	ubytes := abi.PaddedPieceSize(m.sealer.SectorSize()).Unpadded()
+
+	if allocated > ubytes {
+		return xerrors.Errorf("too much data in sector: %d > %d", allocated, ubytes)
+	}
+
+	fillerSizes, err := fillersFromRem(ubytes - allocated)
+	if err != nil {
+		return err
+	}
+
+	if len(fillerSizes) > 0 {
+		log.Warnf("Creating %d filler pieces for sector %d", len(fillerSizes), sector.SectorNumber)
+	}
+
+	fillerPieces, err := m.pledgeSector(sector.sealingCtx(ctx.Context()), m.minerSector(sector.SectorNumber), sector.existingPieceSizes(), fillerSizes...)
+	if err != nil {
+		return xerrors.Errorf("filling up the sector (%v): %w", fillerSizes, err)
+	}
+
+	return ctx.Send(SectorPacked{FillerPieces: fillerPieces})
+}
+
+func (m *Sealing) getTicket(ctx statemachine.Context, sector SectorInfo) (abi.SealRandomness, abi.ChainEpoch, error) {
+	tok, epoch, err := m.api.ChainHead(ctx.Context())
+	if err != nil {
+		log.Errorf("handlePreCommit1: api error, not proceeding: %+v", err)
+		return nil, 0, nil
+	}
+
+	ticketEpoch := epoch - SealRandomnessLookback
+	buf := new(bytes.Buffer)
+	if err := m.maddr.MarshalCBOR(buf); err != nil {
+		return nil, 0, err
+	}
+
+	pci, err := m.api.StateSectorPreCommitInfo(ctx.Context(), m.maddr, sector.SectorNumber, tok)
+	if err != nil {
+		return nil, 0, xerrors.Errorf("getting precommit info: %w", err)
+	}
+
+	if pci != nil {
+		ticketEpoch = pci.Info.SealRandEpoch
+	}
+
+	rand, err := m.api.ChainGetRandomnessFromTickets(ctx.Context(), tok, crypto.DomainSeparationTag_SealRandomness, ticketEpoch, buf.Bytes())
+	if err != nil {
+		return nil, 0, err
+	}
+
+	return abi.SealRandomness(rand), ticketEpoch, nil
+}
+
+func (m *Sealing) handlePreCommit1(ctx statemachine.Context, sector SectorInfo) error {
+	if err := checkPieces(ctx.Context(), m.maddr, sector, m.api); err != nil { // Sanity check state
+		switch err.(type) {
+		case *ErrApi:
+			log.Errorf("handlePreCommit1: api error, not proceeding: %+v", err)
+			return nil
+		case *ErrInvalidDeals:
+			log.Warnf("invalid deals in sector %d: %v", sector.SectorNumber, err)
+			return ctx.Send(SectorInvalidDealIDs{Return: RetPreCommit1})
+		case *ErrExpiredDeals: // Probably not much we can do here, maybe re-pack the sector?
+			return ctx.Send(SectorDealsExpired{xerrors.Errorf("expired dealIDs in sector: %w", err)})
+		default:
+			return xerrors.Errorf("checkPieces sanity check error: %w", err)
+		}
+	}
+
+	log.Infow("performing sector replication...", "sector", sector.SectorNumber)
+	ticketValue, ticketEpoch, err := m.getTicket(ctx, sector)
+	if err != nil {
+		return ctx.Send(SectorSealPreCommit1Failed{xerrors.Errorf("getting ticket failed: %w", err)})
+	}
+
+	pc1o, err := m.sealer.SealPreCommit1(sector.sealingCtx(ctx.Context()), m.minerSector(sector.SectorNumber), ticketValue, sector.pieceInfos())
+	if err != nil {
+		return ctx.Send(SectorSealPreCommit1Failed{xerrors.Errorf("seal pre commit(1) failed: %w", err)})
+	}
+
+	return ctx.Send(SectorPreCommit1{
+		PreCommit1Out: pc1o,
+		TicketValue:   ticketValue,
+		TicketEpoch:   ticketEpoch,
+	})
+}
+
+func (m *Sealing) handlePreCommit2(ctx statemachine.Context, sector SectorInfo) error {
+	cids, err := m.sealer.SealPreCommit2(sector.sealingCtx(ctx.Context()), m.minerSector(sector.SectorNumber), sector.PreCommit1Out)
+	if err != nil {
+		return ctx.Send(SectorSealPreCommit2Failed{xerrors.Errorf("seal pre commit(2) failed: %w", err)})
+	}
+
+	return ctx.Send(SectorPreCommit2{
+		Unsealed: cids.Unsealed,
+		Sealed:   cids.Sealed,
+	})
+}
+
+// TODO: We should probably invoke this method in most (if not all) state transition failures after handlePreCommitting
+func (m *Sealing) remarkForUpgrade(sid abi.SectorNumber) {
+	err := m.MarkForUpgrade(sid)
+	if err != nil {
+		log.Errorf("error re-marking sector %d as for upgrade: %+v", sid, err)
+	}
+}
+
+func (m *Sealing) handlePreCommitting(ctx statemachine.Context, sector SectorInfo) error {
+	tok, height, err := m.api.ChainHead(ctx.Context())
+	if err != nil {
+		log.Errorf("handlePreCommitting: api error, not proceeding: %+v", err)
+		return nil
+	}
+
+	waddr, err := m.api.StateMinerWorkerAddress(ctx.Context(), m.maddr, tok)
+	if err != nil {
+		log.Errorf("handlePreCommitting: api error, not proceeding: %+v", err)
+		return nil
+	}
+
+	if err := checkPrecommit(ctx.Context(), m.Address(), sector, tok, height, m.api); err != nil {
+		switch err := err.(type) {
+		case *ErrApi:
+			log.Errorf("handlePreCommitting: api error, not proceeding: %+v", err)
+			return nil
+		case *ErrBadCommD: // TODO: Should this just back to packing? (not really needed since handlePreCommit1 will do that too)
+			return ctx.Send(SectorSealPreCommit1Failed{xerrors.Errorf("bad CommD error: %w", err)})
+		case *ErrExpiredTicket:
+			return ctx.Send(SectorSealPreCommit1Failed{xerrors.Errorf("ticket expired: %w", err)})
+		case *ErrBadTicket:
+			return ctx.Send(SectorSealPreCommit1Failed{xerrors.Errorf("bad ticket: %w", err)})
+		case *ErrInvalidDeals:
+			log.Warnf("invalid deals in sector %d: %v", sector.SectorNumber, err)
+			return ctx.Send(SectorInvalidDealIDs{Return: RetPreCommitting})
+		case *ErrExpiredDeals:
+			return ctx.Send(SectorDealsExpired{xerrors.Errorf("sector deals expired: %w", err)})
+		case *ErrPrecommitOnChain:
+			return ctx.Send(SectorPreCommitLanded{TipSet: tok}) // we re-did precommit
+		case *ErrSectorNumberAllocated:
+			log.Errorf("handlePreCommitFailed: sector number already allocated, not proceeding: %+v", err)
+			// TODO: check if the sector is committed (not sure how we'd end up here)
+			return nil
+		default:
+			return xerrors.Errorf("checkPrecommit sanity check error: %w", err)
+		}
+	}
+
+	expiration, err := m.pcp.Expiration(ctx.Context(), sector.Pieces...)
+	if err != nil {
+		return ctx.Send(SectorSealPreCommit1Failed{xerrors.Errorf("handlePreCommitting: failed to compute pre-commit expiry: %w", err)})
+	}
+
+	// Sectors must last _at least_ MinSectorExpiration + MaxSealDuration.
+	// TODO: The "+10" allows the pre-commit to take 10 blocks to be accepted.
+	nv, err := m.api.StateNetworkVersion(ctx.Context(), tok)
+	if err != nil {
+		return ctx.Send(SectorSealPreCommit1Failed{xerrors.Errorf("failed to get network version: %w", err)})
+	}
+
+	var msd abi.ChainEpoch
+	if nv < build.ActorUpgradeNetworkVersion {
+		msd = miner0.MaxSealDuration[sector.SectorType]
+	} else {
+		// TODO: ActorUpgrade(use MaxProveCommitDuration)
+		msd = 0
+	}
+
+	if minExpiration := height + msd + miner.MinSectorExpiration + 10; expiration < minExpiration {
+		expiration = minExpiration
+	}
+	// TODO: enforce a reasonable _maximum_ sector lifetime?
+
+	params := &miner.SectorPreCommitInfo{
+		Expiration:   expiration,
+		SectorNumber: sector.SectorNumber,
+		SealProof:    sector.SectorType,
+
+		SealedCID:     *sector.CommR,
+		SealRandEpoch: sector.TicketEpoch,
+		DealIDs:       sector.dealIDs(),
+	}
+
+	depositMinimum := m.tryUpgradeSector(ctx.Context(), params)
+
+	enc := new(bytes.Buffer)
+	if err := params.MarshalCBOR(enc); err != nil {
+		return ctx.Send(SectorChainPreCommitFailed{xerrors.Errorf("could not serialize pre-commit sector parameters: %w", err)})
+	}
+
+	collateral, err := m.api.StateMinerPreCommitDepositForPower(ctx.Context(), m.maddr, *params, tok)
+	if err != nil {
+		return xerrors.Errorf("getting initial pledge collateral: %w", err)
+	}
+
+	deposit := big.Max(depositMinimum, collateral)
+
+	log.Infof("submitting precommit for sector %d (deposit: %s): ", sector.SectorNumber, deposit)
+	mcid, err := m.api.SendMsg(ctx.Context(), waddr, m.maddr, builtin.MethodsMiner.PreCommitSector, deposit, m.feeCfg.MaxPreCommitGasFee, enc.Bytes())
+	if err != nil {
+		if params.ReplaceCapacity {
+			m.remarkForUpgrade(params.ReplaceSectorNumber)
+		}
+		return ctx.Send(SectorChainPreCommitFailed{xerrors.Errorf("pushing message to mpool: %w", err)})
+	}
+
+	return ctx.Send(SectorPreCommitted{Message: mcid, PreCommitDeposit: deposit, PreCommitInfo: *params})
+}
+
+func (m *Sealing) handlePreCommitWait(ctx statemachine.Context, sector SectorInfo) error {
+	if sector.PreCommitMessage == nil {
+		return ctx.Send(SectorChainPreCommitFailed{xerrors.Errorf("precommit message was nil")})
+	}
+
+	// would be ideal to just use the events.Called handler, but it wouldn't be able to handle individual message timeouts
+	log.Info("Sector precommitted: ", sector.SectorNumber)
+	mw, err := m.api.StateWaitMsg(ctx.Context(), *sector.PreCommitMessage)
+	if err != nil {
+		return ctx.Send(SectorChainPreCommitFailed{err})
+	}
+
+	switch mw.Receipt.ExitCode {
+	case exitcode.Ok:
+		// this is what we expect
+	case exitcode.SysErrOutOfGas:
+		// gas estimator guessed a wrong number
+		return ctx.Send(SectorRetryPreCommit{})
+	default:
+		log.Error("sector precommit failed: ", mw.Receipt.ExitCode)
+		err := xerrors.Errorf("sector precommit failed: %d", mw.Receipt.ExitCode)
+		return ctx.Send(SectorChainPreCommitFailed{err})
+	}
+
+	log.Info("precommit message landed on chain: ", sector.SectorNumber)
+
+	return ctx.Send(SectorPreCommitLanded{TipSet: mw.TipSetTok})
+}
+
+func (m *Sealing) handleWaitSeed(ctx statemachine.Context, sector SectorInfo) error {
+	tok, _, err := m.api.ChainHead(ctx.Context())
+	if err != nil {
+		log.Errorf("handleWaitSeed: api error, not proceeding: %+v", err)
+		return nil
+	}
+
+	pci, err := m.api.StateSectorPreCommitInfo(ctx.Context(), m.maddr, sector.SectorNumber, tok)
+	if err != nil {
+		return xerrors.Errorf("getting precommit info: %w", err)
+	}
+	if pci == nil {
+		return ctx.Send(SectorChainPreCommitFailed{error: xerrors.Errorf("precommit info not found on chain")})
+	}
+
+	randHeight := pci.PreCommitEpoch + policy.GetPreCommitChallengeDelay()
+
+	err = m.events.ChainAt(func(ectx context.Context, _ TipSetToken, curH abi.ChainEpoch) error {
+		// in case of null blocks the randomness can land after the tipset we
+		// get from the events API
+		tok, _, err := m.api.ChainHead(ctx.Context())
+		if err != nil {
+			log.Errorf("handleCommitting: api error, not proceeding: %+v", err)
+			return nil
+		}
+
+		buf := new(bytes.Buffer)
+		if err := m.maddr.MarshalCBOR(buf); err != nil {
+			return err
+		}
+		rand, err := m.api.ChainGetRandomnessFromBeacon(ectx, tok, crypto.DomainSeparationTag_InteractiveSealChallengeSeed, randHeight, buf.Bytes())
+		if err != nil {
+			err = xerrors.Errorf("failed to get randomness for computing seal proof (ch %d; rh %d; tsk %x): %w", curH, randHeight, tok, err)
+
+			_ = ctx.Send(SectorChainPreCommitFailed{error: err})
+			return err
+		}
+
+		_ = ctx.Send(SectorSeedReady{SeedValue: abi.InteractiveSealRandomness(rand), SeedEpoch: randHeight})
+
+		return nil
+	}, func(ctx context.Context, ts TipSetToken) error {
+		log.Warn("revert in interactive commit sector step")
+		// TODO: need to cancel running process and restart...
+		return nil
+	}, InteractivePoRepConfidence, randHeight)
+	if err != nil {
+		log.Warn("waitForPreCommitMessage ChainAt errored: ", err)
+	}
+
+	return nil
+}
+
+func (m *Sealing) handleCommitting(ctx statemachine.Context, sector SectorInfo) error {
+	if sector.CommitMessage != nil {
+		log.Warnf("sector %d entered committing state with a commit message cid", sector.SectorNumber)
+
+		ml, err := m.api.StateSearchMsg(ctx.Context(), *sector.CommitMessage)
+		if err != nil {
+			log.Warnf("sector %d searching existing commit message %s: %+v", sector.SectorNumber, *sector.CommitMessage, err)
+		}
+
+		if ml != nil {
+			// some weird retry paths can lead here
+			return ctx.Send(SectorRetryCommitWait{})
+		}
+	}
+
+	log.Info("scheduling seal proof computation...")
+
+	log.Infof("KOMIT %d %x(%d); %x(%d); %v; r:%x; d:%x", sector.SectorNumber, sector.TicketValue, sector.TicketEpoch, sector.SeedValue, sector.SeedEpoch, sector.pieceInfos(), sector.CommR, sector.CommD)
+
+	if sector.CommD == nil || sector.CommR == nil {
+		return ctx.Send(SectorCommitFailed{xerrors.Errorf("sector had nil commR or commD")})
+	}
+
+	cids := storage.SectorCids{
+		Unsealed: *sector.CommD,
+		Sealed:   *sector.CommR,
+	}
+	c2in, err := m.sealer.SealCommit1(sector.sealingCtx(ctx.Context()), m.minerSector(sector.SectorNumber), sector.TicketValue, sector.SeedValue, sector.pieceInfos(), cids)
+	if err != nil {
+		return ctx.Send(SectorComputeProofFailed{xerrors.Errorf("computing seal proof failed(1): %w", err)})
+	}
+
+	proof, err := m.sealer.SealCommit2(sector.sealingCtx(ctx.Context()), m.minerSector(sector.SectorNumber), c2in)
+	if err != nil {
+		return ctx.Send(SectorComputeProofFailed{xerrors.Errorf("computing seal proof failed(2): %w", err)})
+	}
+
+	return ctx.Send(SectorCommitted{
+		Proof: proof,
+	})
+}
+
+func (m *Sealing) handleSubmitCommit(ctx statemachine.Context, sector SectorInfo) error {
+	tok, _, err := m.api.ChainHead(ctx.Context())
+	if err != nil {
+		log.Errorf("handleCommitting: api error, not proceeding: %+v", err)
+		return nil
+	}
+
+	if err := m.checkCommit(ctx.Context(), sector, sector.Proof, tok); err != nil {
+		return ctx.Send(SectorCommitFailed{xerrors.Errorf("commit check error: %w", err)})
+	}
+
+	enc := new(bytes.Buffer)
+	params := &miner.ProveCommitSectorParams{
+		SectorNumber: sector.SectorNumber,
+		Proof:        sector.Proof,
+	}
+
+	if err := params.MarshalCBOR(enc); err != nil {
+		return ctx.Send(SectorCommitFailed{xerrors.Errorf("could not serialize commit sector parameters: %w", err)})
+	}
+
+	waddr, err := m.api.StateMinerWorkerAddress(ctx.Context(), m.maddr, tok)
+	if err != nil {
+		log.Errorf("handleCommitting: api error, not proceeding: %+v", err)
+		return nil
+	}
+
+	pci, err := m.api.StateSectorPreCommitInfo(ctx.Context(), m.maddr, sector.SectorNumber, tok)
+	if err != nil {
+		return xerrors.Errorf("getting precommit info: %w", err)
+	}
+	if pci == nil {
+		return ctx.Send(SectorCommitFailed{error: xerrors.Errorf("precommit info not found on chain")})
+	}
+
+	collateral, err := m.api.StateMinerInitialPledgeCollateral(ctx.Context(), m.maddr, pci.Info, tok)
+	if err != nil {
+		return xerrors.Errorf("getting initial pledge collateral: %w", err)
+	}
+
+	collateral = big.Sub(collateral, pci.PreCommitDeposit)
+	if collateral.LessThan(big.Zero()) {
+		collateral = big.Zero()
+	}
+
+	// TODO: check seed / ticket / deals are up to date
+	mcid, err := m.api.SendMsg(ctx.Context(), waddr, m.maddr, builtin.MethodsMiner.ProveCommitSector, collateral, m.feeCfg.MaxCommitGasFee, enc.Bytes())
+	if err != nil {
+		return ctx.Send(SectorCommitFailed{xerrors.Errorf("pushing message to mpool: %w", err)})
+	}
+
+	return ctx.Send(SectorCommitSubmitted{
+		Message: mcid,
+	})
+}
+
+func (m *Sealing) handleCommitWait(ctx statemachine.Context, sector SectorInfo) error {
+	if sector.CommitMessage == nil {
+		log.Errorf("sector %d entered commit wait state without a message cid", sector.SectorNumber)
+		return ctx.Send(SectorCommitFailed{xerrors.Errorf("entered commit wait with no commit cid")})
+	}
+
+	mw, err := m.api.StateWaitMsg(ctx.Context(), *sector.CommitMessage)
+	if err != nil {
+		return ctx.Send(SectorCommitFailed{xerrors.Errorf("failed to wait for porep inclusion: %w", err)})
+	}
+
+	switch mw.Receipt.ExitCode {
+	case exitcode.Ok:
+		// this is what we expect
+	case exitcode.SysErrOutOfGas:
+		// gas estimator guessed a wrong number
+		return ctx.Send(SectorRetrySubmitCommit{})
+	default:
+		return ctx.Send(SectorCommitFailed{xerrors.Errorf("submitting sector proof failed (exit=%d, msg=%s) (t:%x; s:%x(%d); p:%x)", mw.Receipt.ExitCode, sector.CommitMessage, sector.TicketValue, sector.SeedValue, sector.SeedEpoch, sector.Proof)})
+	}
+
+	si, err := m.api.StateSectorGetInfo(ctx.Context(), m.maddr, sector.SectorNumber, mw.TipSetTok)
+	if err != nil {
+		return ctx.Send(SectorCommitFailed{xerrors.Errorf("proof validation failed, calling StateSectorGetInfo: %w", err)})
+	}
+	if si == nil {
+		return ctx.Send(SectorCommitFailed{xerrors.Errorf("proof validation failed, sector not found in sector set after cron")})
+	}
+
+	return ctx.Send(SectorProving{})
+}
+
+func (m *Sealing) handleFinalizeSector(ctx statemachine.Context, sector SectorInfo) error {
+	// TODO: Maybe wait for some finality
+
+	if err := m.sealer.FinalizeSector(sector.sealingCtx(ctx.Context()), m.minerSector(sector.SectorNumber), sector.keepUnsealedRanges(false)); err != nil {
+		return ctx.Send(SectorFinalizeFailed{xerrors.Errorf("finalize sector: %w", err)})
+	}
+
+	return ctx.Send(SectorFinalized{})
+}
+
+func (m *Sealing) handleProvingSector(ctx statemachine.Context, sector SectorInfo) error {
+	// TODO: track sector health / expiration
+	log.Infof("Proving sector %d", sector.SectorNumber)
+
+	if err := m.sealer.ReleaseUnsealed(ctx.Context(), m.minerSector(sector.SectorNumber), sector.keepUnsealedRanges(true)); err != nil {
+		log.Error(err)
+	}
+
+	// TODO: Watch termination
+	// TODO: Auto-extend if set
+
+	return nil
+}
diff --git a/extern/storage-sealing/stats.go b/extern/storage-sealing/stats.go
new file mode 100644
index 000000000..78630c216
--- /dev/null
+++ b/extern/storage-sealing/stats.go
@@ -0,0 +1,45 @@
+package sealing
+
+import (
+	"sync"
+
+	"github.com/filecoin-project/go-state-types/abi"
+)
+
+type statSectorState int
+
+const (
+	sstSealing statSectorState = iota
+	sstFailed
+	sstProving
+	nsst
+)
+
+type SectorStats struct {
+	lk sync.Mutex
+
+	bySector map[abi.SectorID]statSectorState
+	totals   [nsst]uint64
+}
+
+func (ss *SectorStats) updateSector(id abi.SectorID, st SectorState) {
+	ss.lk.Lock()
+	defer ss.lk.Unlock()
+
+	oldst, found := ss.bySector[id]
+	if found {
+		ss.totals[oldst]--
+	}
+
+	sst := toStatState(st)
+	ss.bySector[id] = sst
+	ss.totals[sst]++
+}
+
+// return the number of sectors currently in the sealing pipeline
+func (ss *SectorStats) curSealing() uint64 {
+	ss.lk.Lock()
+	defer ss.lk.Unlock()
+
+	return ss.totals[sstSealing] + ss.totals[sstFailed]
+}
diff --git a/extern/storage-sealing/types.go b/extern/storage-sealing/types.go
new file mode 100644
index 000000000..c044defd3
--- /dev/null
+++ b/extern/storage-sealing/types.go
@@ -0,0 +1,208 @@
+package sealing
+
+import (
+	"bytes"
+	"context"
+
+	"github.com/ipfs/go-cid"
+
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/big"
+	"github.com/filecoin-project/go-state-types/exitcode"
+	"github.com/filecoin-project/specs-actors/actors/builtin/miner"
+	"github.com/filecoin-project/specs-storage/storage"
+
+	sectorstorage "github.com/filecoin-project/lotus/extern/sector-storage"
+	"github.com/filecoin-project/lotus/extern/storage-sealing/sealiface"
+)
+
+// Piece is a tuple of piece and deal info
+type PieceWithDealInfo struct {
+	Piece    abi.PieceInfo
+	DealInfo DealInfo
+}
+
+// Piece is a tuple of piece info and optional deal
+type Piece struct {
+	Piece    abi.PieceInfo
+	DealInfo *DealInfo // nil for pieces which do not appear in deals (e.g. filler pieces)
+}
+
+// DealInfo is a tuple of deal identity and its schedule
+type DealInfo struct {
+	PublishCid   *cid.Cid
+	DealID       abi.DealID
+	DealSchedule DealSchedule
+	KeepUnsealed bool
+}
+
+// DealSchedule communicates the time interval of a storage deal. The deal must
+// appear in a sealed (proven) sector no later than StartEpoch, otherwise it
+// is invalid.
+type DealSchedule struct {
+	StartEpoch abi.ChainEpoch
+	EndEpoch   abi.ChainEpoch
+}
+
+type Log struct {
+	Timestamp uint64
+	Trace     string // for errors
+
+	Message string
+
+	// additional data (Event info)
+	Kind string
+}
+
+type ReturnState string
+
+const (
+	RetPreCommit1      = ReturnState(PreCommit1)
+	RetPreCommitting   = ReturnState(PreCommitting)
+	RetPreCommitFailed = ReturnState(PreCommitFailed)
+	RetCommitFailed    = ReturnState(CommitFailed)
+)
+
+type SectorInfo struct {
+	State        SectorState
+	SectorNumber abi.SectorNumber
+
+	SectorType abi.RegisteredSealProof
+
+	// Packing
+	Pieces []Piece
+
+	// PreCommit1
+	TicketValue   abi.SealRandomness
+	TicketEpoch   abi.ChainEpoch
+	PreCommit1Out storage.PreCommit1Out
+
+	// PreCommit2
+	CommD *cid.Cid
+	CommR *cid.Cid
+	Proof []byte
+
+	PreCommitInfo    *miner.SectorPreCommitInfo
+	PreCommitDeposit big.Int
+	PreCommitMessage *cid.Cid
+	PreCommitTipSet  TipSetToken
+
+	PreCommit2Fails uint64
+
+	// WaitSeed
+	SeedValue abi.InteractiveSealRandomness
+	SeedEpoch abi.ChainEpoch
+
+	// Committing
+	CommitMessage *cid.Cid
+	InvalidProofs uint64 // failed proof computations (doesn't validate with proof inputs; can't compute)
+
+	// Faults
+	FaultReportMsg *cid.Cid
+
+	// Recovery
+	Return ReturnState
+
+	// Debug
+	LastErr string
+
+	Log []Log
+}
+
+func (t *SectorInfo) pieceInfos() []abi.PieceInfo {
+	out := make([]abi.PieceInfo, len(t.Pieces))
+	for i, p := range t.Pieces {
+		out[i] = p.Piece
+	}
+	return out
+}
+
+func (t *SectorInfo) dealIDs() []abi.DealID {
+	out := make([]abi.DealID, 0, len(t.Pieces))
+	for _, p := range t.Pieces {
+		if p.DealInfo == nil {
+			continue
+		}
+		out = append(out, p.DealInfo.DealID)
+	}
+	return out
+}
+
+func (t *SectorInfo) existingPieceSizes() []abi.UnpaddedPieceSize {
+	out := make([]abi.UnpaddedPieceSize, len(t.Pieces))
+	for i, p := range t.Pieces {
+		out[i] = p.Piece.Size.Unpadded()
+	}
+	return out
+}
+
+func (t *SectorInfo) hasDeals() bool {
+	for _, piece := range t.Pieces {
+		if piece.DealInfo != nil {
+			return true
+		}
+	}
+
+	return false
+}
+
+func (t *SectorInfo) sealingCtx(ctx context.Context) context.Context {
+	// TODO: can also take start epoch into account to give priority to sectors
+	//  we need sealed sooner
+
+	if t.hasDeals() {
+		return sectorstorage.WithPriority(ctx, DealSectorPriority)
+	}
+
+	return ctx
+}
+
+// Returns list of offset/length tuples of sector data ranges which clients
+// requested to keep unsealed
+func (t *SectorInfo) keepUnsealedRanges(invert bool) []storage.Range {
+	var out []storage.Range
+
+	var at abi.UnpaddedPieceSize
+	for _, piece := range t.Pieces {
+		psize := piece.Piece.Size.Unpadded()
+		at += psize
+
+		if piece.DealInfo == nil {
+			continue
+		}
+		if piece.DealInfo.KeepUnsealed == invert {
+			continue
+		}
+
+		out = append(out, storage.Range{
+			Offset: at - psize,
+			Size:   psize,
+		})
+	}
+
+	return out
+}
+
+type SectorIDCounter interface {
+	Next() (abi.SectorNumber, error)
+}
+
+type TipSetToken []byte
+
+type MsgLookup struct {
+	Receipt   MessageReceipt
+	TipSetTok TipSetToken
+	Height    abi.ChainEpoch
+}
+
+type MessageReceipt struct {
+	ExitCode exitcode.ExitCode
+	Return   []byte
+	GasUsed  int64
+}
+
+type GetSealingConfigFunc func() (sealiface.Config, error)
+
+func (mr *MessageReceipt) Equals(o *MessageReceipt) bool {
+	return mr.ExitCode == o.ExitCode && bytes.Equal(mr.Return, o.Return) && mr.GasUsed == o.GasUsed
+}
diff --git a/extern/storage-sealing/types_test.go b/extern/storage-sealing/types_test.go
new file mode 100644
index 000000000..fc56620dc
--- /dev/null
+++ b/extern/storage-sealing/types_test.go
@@ -0,0 +1,70 @@
+package sealing
+
+import (
+	"bytes"
+	"testing"
+
+	"gotest.tools/assert"
+
+	cborutil "github.com/filecoin-project/go-cbor-util"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/specs-actors/actors/builtin"
+)
+
+func TestSectorInfoSelialization(t *testing.T) {
+	d := abi.DealID(1234)
+
+	dealInfo := DealInfo{
+		DealID: d,
+		DealSchedule: DealSchedule{
+			StartEpoch: 0,
+			EndEpoch:   100,
+		},
+	}
+
+	dummyCid := builtin.AccountActorCodeID
+
+	si := &SectorInfo{
+		State:        "stateful",
+		SectorNumber: 234,
+		Pieces: []Piece{{
+			Piece: abi.PieceInfo{
+				Size:     5,
+				PieceCID: dummyCid,
+			},
+			DealInfo: &dealInfo,
+		}},
+		CommD:            &dummyCid,
+		CommR:            nil,
+		Proof:            nil,
+		TicketValue:      []byte{87, 78, 7, 87},
+		TicketEpoch:      345,
+		PreCommitMessage: nil,
+		SeedValue:        []byte{},
+		SeedEpoch:        0,
+		CommitMessage:    nil,
+		FaultReportMsg:   nil,
+		LastErr:          "hi",
+	}
+
+	b, err := cborutil.Dump(si)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	var si2 SectorInfo
+	if err := cborutil.ReadCborRPC(bytes.NewReader(b), &si); err != nil {
+		return
+	}
+
+	assert.Equal(t, si.State, si2.State)
+	assert.Equal(t, si.SectorNumber, si2.SectorNumber)
+
+	assert.Equal(t, si.Pieces, si2.Pieces)
+	assert.Equal(t, si.CommD, si2.CommD)
+	assert.Equal(t, si.TicketValue, si2.TicketValue)
+	assert.Equal(t, si.TicketEpoch, si2.TicketEpoch)
+
+	assert.Equal(t, si, si2)
+
+}
diff --git a/extern/storage-sealing/upgrade_queue.go b/extern/storage-sealing/upgrade_queue.go
new file mode 100644
index 000000000..78a78fc45
--- /dev/null
+++ b/extern/storage-sealing/upgrade_queue.go
@@ -0,0 +1,109 @@
+package sealing
+
+import (
+	"context"
+
+	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
+
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/big"
+)
+
+func (m *Sealing) IsMarkedForUpgrade(id abi.SectorNumber) bool {
+	m.upgradeLk.Lock()
+	_, found := m.toUpgrade[id]
+	m.upgradeLk.Unlock()
+	return found
+}
+
+func (m *Sealing) MarkForUpgrade(id abi.SectorNumber) error {
+	m.upgradeLk.Lock()
+	defer m.upgradeLk.Unlock()
+
+	_, found := m.toUpgrade[id]
+	if found {
+		return xerrors.Errorf("sector %d already marked for upgrade", id)
+	}
+
+	si, err := m.GetSectorInfo(id)
+	if err != nil {
+		return xerrors.Errorf("getting sector info: %w", err)
+	}
+
+	if si.State != Proving {
+		return xerrors.Errorf("can't mark sectors not in the 'Proving' state for upgrade")
+	}
+
+	if len(si.Pieces) != 1 {
+		return xerrors.Errorf("not a committed-capacity sector, expected 1 piece")
+	}
+
+	if si.Pieces[0].DealInfo != nil {
+		return xerrors.Errorf("not a committed-capacity sector, has deals")
+	}
+
+	// TODO: more checks to match actor constraints
+
+	m.toUpgrade[id] = struct{}{}
+
+	return nil
+}
+
+func (m *Sealing) tryUpgradeSector(ctx context.Context, params *miner.SectorPreCommitInfo) big.Int {
+	if len(params.DealIDs) == 0 {
+		return big.Zero()
+	}
+	replace := m.maybeUpgradableSector()
+	if replace != nil {
+		loc, err := m.api.StateSectorPartition(ctx, m.maddr, *replace, nil)
+		if err != nil {
+			log.Errorf("error calling StateSectorPartition for replaced sector: %+v", err)
+			return big.Zero()
+		}
+
+		params.ReplaceCapacity = true
+		params.ReplaceSectorNumber = *replace
+		params.ReplaceSectorDeadline = loc.Deadline
+		params.ReplaceSectorPartition = loc.Partition
+
+		log.Infof("replacing sector %d with %d", *replace, params.SectorNumber)
+
+		ri, err := m.api.StateSectorGetInfo(ctx, m.maddr, *replace, nil)
+		if err != nil {
+			log.Errorf("error calling StateSectorGetInfo for replaced sector: %+v", err)
+			return big.Zero()
+		}
+		if ri == nil {
+			log.Errorf("couldn't find sector info for sector to replace: %+v", replace)
+			return big.Zero()
+		}
+
+		if params.Expiration < ri.Expiration {
+			// TODO: Some limit on this
+			params.Expiration = ri.Expiration
+		}
+
+		return ri.InitialPledge
+	}
+
+	return big.Zero()
+}
+
+func (m *Sealing) maybeUpgradableSector() *abi.SectorNumber {
+	m.upgradeLk.Lock()
+	defer m.upgradeLk.Unlock()
+	for number := range m.toUpgrade {
+		// TODO: checks to match actor constraints
+
+		// this one looks good
+		/*if checks */
+		{
+			delete(m.toUpgrade, number)
+			return &number
+		}
+	}
+
+	return nil
+}
diff --git a/storage/sector_utils.go b/extern/storage-sealing/utils.go
similarity index 72%
rename from storage/sector_utils.go
rename to extern/storage-sealing/utils.go
index 664223a20..dadef227d 100644
--- a/storage/sector_utils.go
+++ b/extern/storage-sealing/utils.go
@@ -1,12 +1,12 @@
-package storage
+package sealing
 
 import (
 	"math/bits"
 
-	sectorbuilder "github.com/filecoin-project/go-sectorbuilder"
+	"github.com/filecoin-project/go-state-types/abi"
 )
 
-func fillersFromRem(toFill uint64) ([]uint64, error) {
+func fillersFromRem(in abi.UnpaddedPieceSize) ([]abi.UnpaddedPieceSize, error) {
 	// Convert to in-sector bytes for easier math:
 	//
 	// Sector size to user bytes ratio is constant, e.g. for 1024B we have 1016B
@@ -19,13 +19,13 @@ func fillersFromRem(toFill uint64) ([]uint64, error) {
 	//
 	// (we convert to sector bytes as they are nice round binary numbers)
 
-	toFill += toFill / 127
+	toFill := uint64(in + (in / 127))
 
 	// We need to fill the sector with pieces that are powers of 2. Conveniently
 	// computers store numbers in binary, which means we can look at 1s to get
 	// all the piece sizes we need to fill the sector. It also means that number
 	// of pieces is the number of 1s in the number of remaining bytes to fill
-	out := make([]uint64, bits.OnesCount64(toFill))
+	out := make([]abi.UnpaddedPieceSize, bits.OnesCount64(toFill))
 	for i := range out {
 		// Extract the next lowest non-zero bit
 		next := bits.TrailingZeros64(toFill)
@@ -37,12 +37,12 @@ func fillersFromRem(toFill uint64) ([]uint64, error) {
 		toFill ^= psize
 
 		// Add the piece size to the list of pieces we need to create
-		out[i] = sectorbuilder.UserBytesForSectorSize(psize)
+		out[i] = abi.PaddedPieceSize(psize).Unpadded()
 	}
 	return out, nil
 }
 
-func (m *Miner) ListSectors() ([]SectorInfo, error) {
+func (m *Sealing) ListSectors() ([]SectorInfo, error) {
 	var sectors []SectorInfo
 	if err := m.sectors.List(&sectors); err != nil {
 		return nil, err
@@ -50,8 +50,8 @@ func (m *Miner) ListSectors() ([]SectorInfo, error) {
 	return sectors, nil
 }
 
-func (m *Miner) GetSectorInfo(sid uint64) (SectorInfo, error) {
+func (m *Sealing) GetSectorInfo(sid abi.SectorNumber) (SectorInfo, error) {
 	var out SectorInfo
-	err := m.sectors.Get(sid, &out)
+	err := m.sectors.Get(uint64(sid)).Get(&out)
 	return out, err
 }
diff --git a/extern/storage-sealing/utils_test.go b/extern/storage-sealing/utils_test.go
new file mode 100644
index 000000000..e346b6dc9
--- /dev/null
+++ b/extern/storage-sealing/utils_test.go
@@ -0,0 +1,45 @@
+package sealing
+
+import (
+	"testing"
+
+	"github.com/filecoin-project/go-state-types/abi"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func testFill(t *testing.T, n abi.UnpaddedPieceSize, exp []abi.UnpaddedPieceSize) {
+	f, err := fillersFromRem(n)
+	assert.NoError(t, err)
+	assert.Equal(t, exp, f)
+
+	var sum abi.UnpaddedPieceSize
+	for _, u := range f {
+		sum += u
+	}
+	assert.Equal(t, n, sum)
+}
+
+func TestFillersFromRem(t *testing.T) {
+	for i := 8; i < 32; i++ {
+		// single
+		ub := abi.PaddedPieceSize(uint64(1) << i).Unpadded()
+		testFill(t, ub, []abi.UnpaddedPieceSize{ub})
+
+		// 2
+		ub = abi.PaddedPieceSize(uint64(5) << i).Unpadded()
+		ub1 := abi.PaddedPieceSize(uint64(1) << i).Unpadded()
+		ub3 := abi.PaddedPieceSize(uint64(4) << i).Unpadded()
+		testFill(t, ub, []abi.UnpaddedPieceSize{ub1, ub3})
+
+		// 4
+		ub = abi.PaddedPieceSize(uint64(15) << i).Unpadded()
+		ub2 := abi.PaddedPieceSize(uint64(2) << i).Unpadded()
+		ub4 := abi.PaddedPieceSize(uint64(8) << i).Unpadded()
+		testFill(t, ub, []abi.UnpaddedPieceSize{ub1, ub2, ub3, ub4})
+
+		// different 2
+		ub = abi.PaddedPieceSize(uint64(9) << i).Unpadded()
+		testFill(t, ub, []abi.UnpaddedPieceSize{ub1, ub4})
+	}
+}
diff --git a/extern/test-vectors b/extern/test-vectors
new file mode 160000
index 000000000..6bea015ed
--- /dev/null
+++ b/extern/test-vectors
@@ -0,0 +1 @@
+Subproject commit 6bea015edddde116001a4251dce3c4a9966c25d9
diff --git a/gen/main.go b/gen/main.go
index 52fcf4665..bcb43a8f0 100644
--- a/gen/main.go
+++ b/gen/main.go
@@ -7,42 +7,37 @@ import (
 	gen "github.com/whyrusleeping/cbor-gen"
 
 	"github.com/filecoin-project/lotus/api"
-	"github.com/filecoin-project/lotus/chain/actors"
-	"github.com/filecoin-project/lotus/chain/blocksync"
-	"github.com/filecoin-project/lotus/chain/deals"
+	"github.com/filecoin-project/lotus/chain/exchange"
 	"github.com/filecoin-project/lotus/chain/types"
-	"github.com/filecoin-project/lotus/paych"
-	"github.com/filecoin-project/lotus/retrieval"
-	"github.com/filecoin-project/lotus/storage"
+	"github.com/filecoin-project/lotus/node/hello"
+	"github.com/filecoin-project/lotus/paychmgr"
 )
 
 func main() {
 	err := gen.WriteTupleEncodersToFile("./chain/types/cbor_gen.go", "types",
 		types.BlockHeader{},
 		types.Ticket{},
-		types.EPostProof{},
-		types.EPostTicket{},
+		types.ElectionProof{},
 		types.Message{},
 		types.SignedMessage{},
 		types.MsgMeta{},
-		types.SignedVoucher{},
-		types.ModVerifyParams{},
-		types.Merge{},
 		types.Actor{},
 		types.MessageReceipt{},
 		types.BlockMsg{},
-		types.SignedStorageAsk{},
-		types.StorageAsk{},
 		types.ExpTipSet{},
+		types.BeaconEntry{},
+		types.StateRoot{},
+		types.StateInfo{},
 	)
 	if err != nil {
 		fmt.Println(err)
 		os.Exit(1)
 	}
 
-	err = gen.WriteTupleEncodersToFile("./paych/cbor_gen.go", "paych",
-		paych.VoucherInfo{},
-		paych.ChannelInfo{},
+	err = gen.WriteMapEncodersToFile("./paychmgr/cbor_gen.go", "paychmgr",
+		paychmgr.VoucherInfo{},
+		paychmgr.ChannelInfo{},
+		paychmgr.MsgInfo{},
 	)
 	if err != nil {
 		fmt.Println(err)
@@ -53,112 +48,28 @@ func main() {
 		api.PaymentInfo{},
 		api.SealedRef{},
 		api.SealedRefs{},
+		api.SealTicket{},
+		api.SealSeed{},
 	)
 	if err != nil {
 		fmt.Println(err)
 		os.Exit(1)
 	}
 
-	err = gen.WriteTupleEncodersToFile("./retrieval/cbor_gen.go", "retrieval",
-		retrieval.RetParams{},
-
-		retrieval.Query{},
-		retrieval.QueryResponse{},
-		retrieval.Unixfs0Offer{},
-		retrieval.DealProposal{},
-		retrieval.DealResponse{},
-		retrieval.Block{},
+	err = gen.WriteTupleEncodersToFile("./node/hello/cbor_gen.go", "hello",
+		hello.HelloMessage{},
+		hello.LatencyMessage{},
 	)
 	if err != nil {
 		fmt.Println(err)
 		os.Exit(1)
 	}
 
-	err = gen.WriteTupleEncodersToFile("./chain/blocksync/cbor_gen.go", "blocksync",
-		blocksync.BlockSyncRequest{},
-		blocksync.BlockSyncResponse{},
-		blocksync.BSTipSet{},
-	)
-	if err != nil {
-		fmt.Println(err)
-		os.Exit(1)
-	}
-
-	err = gen.WriteTupleEncodersToFile("./chain/actors/cbor_gen.go", "actors",
-		actors.InitActorState{},
-		actors.ExecParams{},
-		actors.AccountActorState{},
-		actors.StorageMinerActorState{},
-		actors.StorageMinerConstructorParams{},
-		actors.SectorPreCommitInfo{},
-		actors.PreCommittedSector{},
-		actors.MinerInfo{},
-		actors.SubmitFallbackPoStParams{},
-		actors.PaymentVerifyParams{},
-		actors.UpdatePeerIDParams{},
-		actors.DeclareFaultsParams{},
-		actors.MultiSigActorState{},
-		actors.MultiSigConstructorParams{},
-		actors.MultiSigProposeParams{},
-		actors.MultiSigTxID{},
-		actors.MultiSigSwapSignerParams{},
-		actors.MultiSigChangeReqParams{},
-		actors.MTransaction{},
-		actors.MultiSigRemoveSignerParam{},
-		actors.MultiSigAddSignerParam{},
-		actors.PaymentChannelActorState{},
-		actors.PCAConstructorParams{},
-		actors.LaneState{},
-		actors.PCAUpdateChannelStateParams{},
-		actors.PaymentInfo{},
-		actors.StoragePowerState{},
-		actors.CreateStorageMinerParams{},
-		actors.IsValidMinerParam{},
-		actors.PowerLookupParams{},
-		actors.UpdateStorageParams{},
-		actors.ArbitrateConsensusFaultParams{},
-		actors.PledgeCollateralParams{},
-		actors.MinerSlashConsensusFault{},
-		actors.StorageParticipantBalance{},
-		actors.StorageMarketState{},
-		actors.WithdrawBalanceParams{},
-		actors.StorageDealProposal{},
-		actors.PublishStorageDealsParams{},
-		actors.PublishStorageDealResponse{},
-		actors.ActivateStorageDealsParams{},
-		actors.ProcessStorageDealsPaymentParams{},
-		actors.OnChainDeal{},
-		actors.ComputeDataCommitmentParams{},
-		actors.SectorProveCommitInfo{},
-		actors.CheckMinerParams{},
-		actors.CronActorState{},
-	)
-	if err != nil {
-		fmt.Println(err)
-		os.Exit(1)
-	}
-
-	err = gen.WriteTupleEncodersToFile("./chain/deals/cbor_gen.go", "deals",
-		deals.AskRequest{},
-		deals.AskResponse{},
-		deals.Proposal{},
-		deals.Response{},
-		deals.SignedResponse{},
-		deals.ClientDealProposal{},
-		deals.ClientDeal{},
-		deals.MinerDeal{},
-		deals.StorageDataTransferVoucher{},
-	)
-	if err != nil {
-		fmt.Println(err)
-		os.Exit(1)
-	}
-
-	err = gen.WriteMapEncodersToFile("./storage/cbor_gen.go", "storage",
-		storage.SealTicket{},
-		storage.SealSeed{},
-		storage.Piece{},
-		storage.SectorInfo{},
+	err = gen.WriteTupleEncodersToFile("./chain/exchange/cbor_gen.go", "exchange",
+		exchange.Request{},
+		exchange.Response{},
+		exchange.CompactedMessages{},
+		exchange.BSTipSet{},
 	)
 	if err != nil {
 		fmt.Println(err)
diff --git a/genesis/types.go b/genesis/types.go
index 27eabea4a..79656feac 100644
--- a/genesis/types.go
+++ b/genesis/types.go
@@ -1,25 +1,85 @@
 package genesis
 
 import (
+	"encoding/json"
+
 	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/lotus/chain/actors"
-	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/specs-actors/actors/builtin/market"
+	"github.com/ipfs/go-cid"
+	"github.com/libp2p/go-libp2p-core/peer"
+)
+
+type ActorType string
+
+const (
+	TAccount  ActorType = "account"
+	TMultisig ActorType = "multisig"
 )
 
 type PreSeal struct {
-	CommR    [32]byte
-	CommD    [32]byte
-	SectorID uint64
-	Deal     actors.StorageDealProposal
+	CommR     cid.Cid
+	CommD     cid.Cid
+	SectorID  abi.SectorNumber
+	Deal      market.DealProposal
+	ProofType abi.RegisteredSealProof
 }
 
-type GenesisMiner struct {
+type Miner struct {
+	ID     address.Address
 	Owner  address.Address
 	Worker address.Address
+	PeerId peer.ID //nolint:golint
 
-	SectorSize uint64
+	MarketBalance abi.TokenAmount
+	PowerBalance  abi.TokenAmount
+
+	SectorSize abi.SectorSize
 
 	Sectors []*PreSeal
-
-	Key types.KeyInfo // TODO: separate file
+}
+
+type AccountMeta struct {
+	Owner address.Address // bls / secpk
+}
+
+func (am *AccountMeta) ActorMeta() json.RawMessage {
+	out, err := json.Marshal(am)
+	if err != nil {
+		panic(err)
+	}
+	return out
+}
+
+type MultisigMeta struct {
+	Signers         []address.Address
+	Threshold       int
+	VestingDuration int
+	VestingStart    int
+}
+
+func (mm *MultisigMeta) ActorMeta() json.RawMessage {
+	out, err := json.Marshal(mm)
+	if err != nil {
+		panic(err)
+	}
+	return out
+}
+
+type Actor struct {
+	Type    ActorType
+	Balance abi.TokenAmount
+
+	Meta json.RawMessage
+}
+
+type Template struct {
+	Accounts []Actor
+	Miners   []Miner
+
+	NetworkName string
+	Timestamp   uint64 `json:",omitempty"`
+
+	VerifregRootKey  Actor
+	RemainderAccount Actor
 }
diff --git a/go.mod b/go.mod
index fa68fc620..67d87347f 100644
--- a/go.mod
+++ b/go.mod
@@ -1,110 +1,130 @@
 module github.com/filecoin-project/lotus
 
-go 1.13
+go 1.14
 
 require (
 	contrib.go.opencensus.io/exporter/jaeger v0.1.0
+	contrib.go.opencensus.io/exporter/prometheus v0.1.0
 	github.com/BurntSushi/toml v0.3.1
 	github.com/GeertJohan/go.rice v1.0.0
 	github.com/Gurpartap/async v0.0.0-20180927173644-4f7f499dd9ee
 	github.com/StackExchange/wmi v0.0.0-20190523213315-cbe66965904d // indirect
+	github.com/acarl005/stripansi v0.0.0-20180116102854-5a71ef0e047d
+	github.com/buger/goterm v0.0.0-20200322175922-2f3e71b85129
+	github.com/coreos/go-systemd/v22 v22.0.0
+	github.com/detailyang/go-fallocate v0.0.0-20180908115635-432fa640bd2e
+	github.com/dgraph-io/badger/v2 v2.2007.2
 	github.com/docker/go-units v0.4.0
-	github.com/filecoin-project/chain-validation v0.0.3
-	github.com/filecoin-project/filecoin-ffi v0.0.0-20191219131535-bb699517a590
-	github.com/filecoin-project/go-address v0.0.0-20191219011437-af739c490b4f
-	github.com/filecoin-project/go-amt-ipld v0.0.0-20191205011053-79efc22d6cdc
+	github.com/drand/drand v1.1.2-0.20200905144319-79c957281b32
+	github.com/drand/kyber v1.1.2
+	github.com/dustin/go-humanize v1.0.0
+	github.com/elastic/go-sysinfo v1.3.0
+	github.com/fatih/color v1.8.0
+	github.com/filecoin-project/filecoin-ffi v0.30.4-0.20200716204036-cddc56607e1d
+	github.com/filecoin-project/go-address v0.0.4
+	github.com/filecoin-project/go-bitfield v0.2.0
 	github.com/filecoin-project/go-cbor-util v0.0.0-20191219014500-08c40a1e63a2
 	github.com/filecoin-project/go-crypto v0.0.0-20191218222705-effae4ea9f03
-	github.com/filecoin-project/go-paramfetch v0.0.1
-	github.com/filecoin-project/go-sectorbuilder v0.0.0-20200107152336-0cbb2c483013
-	github.com/filecoin-project/go-statestore v0.0.0-20200102200712-1f63c701c1e5
+	github.com/filecoin-project/go-data-transfer v0.6.6
+	github.com/filecoin-project/go-fil-commcid v0.0.0-20200716160307-8f644712406f
+	github.com/filecoin-project/go-fil-markets v0.6.3
+	github.com/filecoin-project/go-jsonrpc v0.1.2-0.20200822201400-474f4fdccc52
+	github.com/filecoin-project/go-multistore v0.0.3
+	github.com/filecoin-project/go-padreader v0.0.0-20200903213702-ed5fae088b20
+	github.com/filecoin-project/go-paramfetch v0.0.2-0.20200701152213-3e0f0afdc261
+	github.com/filecoin-project/go-state-types v0.0.0-20200911004822-964d6c679cfc
+	github.com/filecoin-project/go-statemachine v0.0.0-20200813232949-df9b130df370
+	github.com/filecoin-project/go-statestore v0.1.0
+	github.com/filecoin-project/go-storedcounter v0.0.0-20200421200003-1c99c62e8a5b
+	github.com/filecoin-project/specs-actors v0.9.11
+	github.com/filecoin-project/specs-storage v0.1.1-0.20200907031224-ed2e5cd13796
+	github.com/filecoin-project/test-vectors/schema v0.0.1
 	github.com/gbrlsnchs/jwt/v3 v3.0.0-beta.1
+	github.com/go-kit/kit v0.10.0
 	github.com/go-ole/go-ole v1.2.4 // indirect
-	github.com/google/go-cmp v0.3.1 // indirect
-	github.com/gorilla/mux v1.7.3
-	github.com/gorilla/websocket v1.4.1
-	github.com/hashicorp/go-multierror v1.0.0
-	github.com/hashicorp/golang-lru v0.5.3
-	github.com/influxdata/influxdb1-client v0.0.0-20190809212627-fc22c7df067e
-	github.com/ipfs/go-bitswap v0.1.8
+	github.com/google/uuid v1.1.1
+	github.com/gorilla/mux v1.7.4
+	github.com/gorilla/websocket v1.4.2
+	github.com/hannahhoward/go-pubsub v0.0.0-20200423002714-8d62886cc36e
+	github.com/hashicorp/go-multierror v1.1.0
+	github.com/hashicorp/golang-lru v0.5.4
+	github.com/influxdata/influxdb1-client v0.0.0-20191209144304-8bf82d3c094d
+	github.com/ipfs/go-bitswap v0.2.20
 	github.com/ipfs/go-block-format v0.0.2
-	github.com/ipfs/go-blockservice v0.1.3-0.20190908200855-f22eea50656c
-	github.com/ipfs/go-car v0.0.2
-	github.com/ipfs/go-cid v0.0.4
-	github.com/ipfs/go-datastore v0.1.1
-	github.com/ipfs/go-ds-badger v0.0.7
-	github.com/ipfs/go-filestore v0.0.2
-	github.com/ipfs/go-fs-lock v0.0.1
-	github.com/ipfs/go-hamt-ipld v0.0.14-0.20191218031521-b2c774a54db1
-	github.com/ipfs/go-ipfs-blockstore v0.1.1
-	github.com/ipfs/go-ipfs-blocksutil v0.0.1
-	github.com/ipfs/go-ipfs-chunker v0.0.1
-	github.com/ipfs/go-ipfs-ds-help v0.0.1
+	github.com/ipfs/go-blockservice v0.1.4-0.20200624145336-a978cec6e834
+	github.com/ipfs/go-cid v0.0.7
+	github.com/ipfs/go-cidutil v0.0.2
+	github.com/ipfs/go-datastore v0.4.4
+	github.com/ipfs/go-ds-badger2 v0.1.1-0.20200708190120-187fc06f714e
+	github.com/ipfs/go-ds-leveldb v0.4.2
+	github.com/ipfs/go-ds-measure v0.1.0
+	github.com/ipfs/go-filestore v1.0.0
+	github.com/ipfs/go-fs-lock v0.0.6
+	github.com/ipfs/go-graphsync v0.2.1
+	github.com/ipfs/go-ipfs-blockstore v1.0.1
+	github.com/ipfs/go-ipfs-chunker v0.0.5
+	github.com/ipfs/go-ipfs-ds-help v1.0.0
 	github.com/ipfs/go-ipfs-exchange-interface v0.0.1
 	github.com/ipfs/go-ipfs-exchange-offline v0.0.1
-	github.com/ipfs/go-ipfs-files v0.0.4
+	github.com/ipfs/go-ipfs-files v0.0.8
+	github.com/ipfs/go-ipfs-http-client v0.0.5
 	github.com/ipfs/go-ipfs-routing v0.1.0
-	github.com/ipfs/go-ipld-cbor v0.0.3
-	github.com/ipfs/go-ipld-format v0.0.2
-	github.com/ipfs/go-log v1.0.1
-	github.com/ipfs/go-log/v2 v2.0.2 // indirect
-	github.com/ipfs/go-merkledag v0.2.4
+	github.com/ipfs/go-ipld-cbor v0.0.5-0.20200428170625-a0bd04d3cbdf
+	github.com/ipfs/go-ipld-format v0.2.0
+	github.com/ipfs/go-log v1.0.4
+	github.com/ipfs/go-log/v2 v2.1.2-0.20200626104915-0016c0b4b3e4
+	github.com/ipfs/go-merkledag v0.3.2
 	github.com/ipfs/go-path v0.0.7
-	github.com/ipfs/go-unixfs v0.2.2-0.20190827150610-868af2e9e5cb
-	github.com/ipld/go-ipld-prime v0.0.2-0.20191025154717-8dff1cbec43b
-	github.com/libp2p/go-libp2p v0.4.2
-	github.com/libp2p/go-libp2p-circuit v0.1.4
-	github.com/libp2p/go-libp2p-connmgr v0.1.0
-	github.com/libp2p/go-libp2p-core v0.2.4
-	github.com/libp2p/go-libp2p-discovery v0.2.0
-	github.com/libp2p/go-libp2p-kad-dht v0.1.1
-	github.com/libp2p/go-libp2p-mplex v0.2.1
-	github.com/libp2p/go-libp2p-peer v0.2.0
-	github.com/libp2p/go-libp2p-peerstore v0.1.4
-	github.com/libp2p/go-libp2p-pnet v0.1.0
-	github.com/libp2p/go-libp2p-pubsub v0.2.3
-	github.com/libp2p/go-libp2p-quic-transport v0.1.1
-	github.com/libp2p/go-libp2p-record v0.1.1
-	github.com/libp2p/go-libp2p-routing-helpers v0.1.0
-	github.com/libp2p/go-libp2p-secio v0.2.1
-	github.com/libp2p/go-libp2p-tls v0.1.0
-	github.com/libp2p/go-libp2p-yamux v0.2.1
-	github.com/libp2p/go-maddr-filter v0.0.5
-	github.com/mattn/go-sqlite3 v1.12.0
+	github.com/ipfs/go-unixfs v0.2.4
+	github.com/ipfs/interface-go-ipfs-core v0.2.3
+	github.com/ipld/go-car v0.1.1-0.20200923150018-8cdef32e2da4
+	github.com/ipld/go-ipld-prime v0.5.1-0.20200828233916-988837377a7f
+	github.com/kelseyhightower/envconfig v1.4.0
+	github.com/lib/pq v1.7.0
+	github.com/libp2p/go-eventbus v0.2.1
+	github.com/libp2p/go-libp2p v0.11.0
+	github.com/libp2p/go-libp2p-connmgr v0.2.4
+	github.com/libp2p/go-libp2p-core v0.6.1
+	github.com/libp2p/go-libp2p-discovery v0.5.0
+	github.com/libp2p/go-libp2p-kad-dht v0.8.3
+	github.com/libp2p/go-libp2p-mplex v0.2.4
+	github.com/libp2p/go-libp2p-noise v0.1.1
+	github.com/libp2p/go-libp2p-peerstore v0.2.6
+	github.com/libp2p/go-libp2p-pubsub v0.3.6-0.20200910093904-f7f33e10cc18
+	github.com/libp2p/go-libp2p-quic-transport v0.8.0
+	github.com/libp2p/go-libp2p-record v0.1.3
+	github.com/libp2p/go-libp2p-routing-helpers v0.2.3
+	github.com/libp2p/go-libp2p-swarm v0.2.8
+	github.com/libp2p/go-libp2p-tls v0.1.3
+	github.com/libp2p/go-libp2p-yamux v0.2.8
+	github.com/libp2p/go-maddr-filter v0.1.0
 	github.com/minio/blake2b-simd v0.0.0-20160723061019-3f5f724cb5b1
-	github.com/minio/sha256-simd v0.1.1
 	github.com/mitchellh/go-homedir v1.1.0
 	github.com/multiformats/go-base32 v0.0.3
-	github.com/multiformats/go-multiaddr v0.1.1
+	github.com/multiformats/go-multiaddr v0.3.1
 	github.com/multiformats/go-multiaddr-dns v0.2.0
-	github.com/multiformats/go-multiaddr-net v0.1.1
-	github.com/multiformats/go-multihash v0.0.10
-	github.com/multiformats/go-varint v0.0.2
-	github.com/onsi/ginkgo v1.9.0 // indirect
-	github.com/onsi/gomega v1.6.0 // indirect
-	github.com/opentracing/opentracing-go v1.1.0
-	github.com/polydawn/refmt v0.0.0-20190809202753-05966cbd336a
-	github.com/prometheus/common v0.2.0
-	github.com/stretchr/testify v1.4.0
+	github.com/multiformats/go-multibase v0.0.3
+	github.com/multiformats/go-multihash v0.0.14
+	github.com/opentracing/opentracing-go v1.2.0
+	github.com/raulk/clock v1.1.0
+	github.com/stretchr/testify v1.6.1
+	github.com/supranational/blst v0.1.1
+	github.com/syndtr/goleveldb v1.0.0
+	github.com/urfave/cli/v2 v2.2.0
 	github.com/whyrusleeping/bencher v0.0.0-20190829221104-bb6607aa8bba
-	github.com/whyrusleeping/cbor-gen v0.0.0-20191216205031-b047b6acb3c0
+	github.com/whyrusleeping/cbor-gen v0.0.0-20200814224545-656e08ce49ee
 	github.com/whyrusleeping/multiaddr-filter v0.0.0-20160516205228-e903e4adabd7
 	github.com/whyrusleeping/pubsub v0.0.0-20131020042734-02de8aa2db3d
-	go.opencensus.io v0.22.2
-	go.uber.org/atomic v1.5.1 // indirect
-	go.uber.org/dig v1.7.0 // indirect
+	github.com/xorcare/golden v0.6.1-0.20191112154924-b87f686d7542
+	go.opencensus.io v0.22.4
+	go.uber.org/dig v1.10.0 // indirect
 	go.uber.org/fx v1.9.0
-	go.uber.org/goleak v0.10.0 // indirect
-	go.uber.org/multierr v1.4.0
-	go.uber.org/zap v1.13.0
-	go4.org v0.0.0-20190313082347-94abd6928b1d // indirect
-	golang.org/x/lint v0.0.0-20191125180803-fdd1cda4f05f // indirect
-	golang.org/x/sys v0.0.0-20200107162124-548cf772de50 // indirect
-	golang.org/x/time v0.0.0-20190308202827-9d24e82272b4
-	golang.org/x/tools v0.0.0-20200108195415-316d2f248479 // indirect
-	golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543
-	gopkg.in/cheggaaa/pb.v1 v1.0.28
-	gopkg.in/urfave/cli.v2 v2.0.0-20180128182452-d3ae77c26ac8
+	go.uber.org/multierr v1.5.0
+	go.uber.org/zap v1.15.0
+	golang.org/x/sync v0.0.0-20200625203802-6e8e738ad208
+	golang.org/x/sys v0.0.0-20200602225109-6fdc65e7d980
+	golang.org/x/time v0.0.0-20191024005414-555d28b269f0
+	golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1
 	gotest.tools v2.2.0+incompatible
 	launchpad.net/gocheck v0.0.0-20140225173054-000000000087 // indirect
 )
@@ -112,3 +132,9 @@ require (
 replace github.com/golangci/golangci-lint => github.com/golangci/golangci-lint v1.18.0
 
 replace github.com/filecoin-project/filecoin-ffi => ./extern/filecoin-ffi
+
+replace github.com/filecoin-project/test-vectors => ./extern/test-vectors
+
+replace github.com/supranational/blst => ./extern/fil-blst/blst
+
+replace github.com/filecoin-project/fil-blst => ./extern/fil-blst
diff --git a/go.sum b/go.sum
index 2caf516d4..05e643708 100644
--- a/go.sum
+++ b/go.sum
@@ -1,41 +1,103 @@
 cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
+cloud.google.com/go v0.31.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
 cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
+cloud.google.com/go v0.37.0/go.mod h1:TS1dMSSfndXH133OKGwekG838Om/cQT0BUHV3HcBgoo=
+cloud.google.com/go v0.38.0/go.mod h1:990N+gfupTy94rShfmMCWGDn0LpTmnzTp2qbd1dvSRU=
+cloud.google.com/go v0.44.1/go.mod h1:iSa0KzasP4Uvy3f1mN/7PiObzGgflwredwwASm/v6AU=
+cloud.google.com/go v0.44.2/go.mod h1:60680Gw3Yr4ikxnPRS/oxxkBccT6SA1yMk63TGekxKY=
+cloud.google.com/go v0.45.1/go.mod h1:RpBamKRgapWJb87xiFSdk4g1CME7QZg3uwTez+TSTjc=
+cloud.google.com/go v0.46.3/go.mod h1:a6bKKbmY7er1mI7TEI4lsAkts/mkhTSZK8w33B4RAg0=
+cloud.google.com/go v0.50.0/go.mod h1:r9sluTvynVuxRIOHXQEHMFffphuXHOMZMycpNR5e6To=
+cloud.google.com/go v0.53.0/go.mod h1:fp/UouUEsRkN6ryDKNW/Upv/JBKnv6WDthjR6+vze6M=
+cloud.google.com/go/bigquery v1.0.1/go.mod h1:i/xbL2UlR5RvWAURpBYZTtm/cXjCha9lbfbpx4poX+o=
+cloud.google.com/go/bigquery v1.3.0/go.mod h1:PjpwJnslEMmckchkHFfq+HTD2DmtT67aNFKH1/VBDHE=
+cloud.google.com/go/datastore v1.0.0/go.mod h1:LXYbyblFSglQ5pkeyhO+Qmw7ukd3C+pD7TKLgZqpHYE=
+cloud.google.com/go/pubsub v1.0.1/go.mod h1:R0Gpsv3s54REJCy4fxDixWD93lHJMoZTyQ2kNxGRt3I=
+cloud.google.com/go/pubsub v1.1.0/go.mod h1:EwwdRX2sKPjnvnqCa270oGRyludottCI76h+R3AArQw=
+cloud.google.com/go/storage v1.0.0/go.mod h1:IhtSnM/ZTZV8YYJWCY8RULGVqBDmpoyjwiyrjsg+URw=
+cloud.google.com/go/storage v1.5.0/go.mod h1:tpKbwo567HUNpVclU5sGELwQWBDZ8gh0ZeosJ0Rtdos=
 contrib.go.opencensus.io/exporter/jaeger v0.1.0 h1:WNc9HbA38xEQmsI40Tjd/MNU/g8byN2Of7lwIjv0Jdc=
 contrib.go.opencensus.io/exporter/jaeger v0.1.0/go.mod h1:VYianECmuFPwU37O699Vc1GOcy+y8kOsfaxHRImmjbA=
+contrib.go.opencensus.io/exporter/prometheus v0.1.0 h1:SByaIoWwNgMdPSgl5sMqM2KDE5H/ukPWBRo314xiDvg=
+contrib.go.opencensus.io/exporter/prometheus v0.1.0/go.mod h1:cGFniUXGZlKRjzOyuZJ6mgB+PgBcCIa79kEKR8YCW+A=
+dmitri.shuralyov.com/app/changes v0.0.0-20180602232624-0a106ad413e3/go.mod h1:Yl+fi1br7+Rr3LqpNJf1/uxUdtRUV+Tnj0o93V2B9MU=
+dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU=
+dmitri.shuralyov.com/html/belt v0.0.0-20180602232347-f7d459c86be0/go.mod h1:JLBrvjyP0v+ecvNYvCpyZgu5/xkfAUhi6wJj28eUfSU=
+dmitri.shuralyov.com/service/change v0.0.0-20181023043359-a85b471d5412/go.mod h1:a1inKt/atXimZ4Mv927x+r7UpyzRUf4emIoiiSC2TN4=
+dmitri.shuralyov.com/state v0.0.0-20180228185332-28bcc343414c/go.mod h1:0PRwlb0D6DFvNNtx+9ybjezNCa8XF0xaYcETyp6rHWU=
+git.apache.org/thrift.git v0.0.0-20180902110319-2566ecd5d999/go.mod h1:fPE2ZNJGynbRyZ4dJvy6G277gSllfV2HJqblrnkyeyg=
 github.com/AndreasBriese/bbloom v0.0.0-20180913140656-343706a395b7/go.mod h1:bOvUY6CB00SOBii9/FifXqc0awNKxLFCL/+pkDPuyl8=
 github.com/AndreasBriese/bbloom v0.0.0-20190306092124-e2d15f34fcf9 h1:HD8gA2tkByhMAwYaFAX9w2l7vxvBQ5NMoxDrkhqhtn4=
 github.com/AndreasBriese/bbloom v0.0.0-20190306092124-e2d15f34fcf9/go.mod h1:bOvUY6CB00SOBii9/FifXqc0awNKxLFCL/+pkDPuyl8=
 github.com/BurntSushi/toml v0.3.1 h1:WXkYYl6Yr3qBf1K79EBnL4mak0OimBfB0XUf9Vl28OQ=
 github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
+github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo=
+github.com/DataDog/zstd v1.4.1 h1:3oxKN3wbHibqx897utPC2LTQU4J+IHWWJO+glkAkpFM=
+github.com/DataDog/zstd v1.4.1/go.mod h1:1jcaCB/ufaK+sKp1NBhlGmpz41jOoPQ35bpF36t7BBo=
 github.com/GeertJohan/go.incremental v1.0.0 h1:7AH+pY1XUgQE4Y1HcXYaMqAI0m9yrFqo/jt0CW30vsg=
 github.com/GeertJohan/go.incremental v1.0.0/go.mod h1:6fAjUhbVuX1KcMD3c8TEgVUqmo4seqhv0i0kdATSkM0=
 github.com/GeertJohan/go.rice v1.0.0 h1:KkI6O9uMaQU3VEKaj01ulavtF7o1fWT7+pk/4voiMLQ=
 github.com/GeertJohan/go.rice v1.0.0/go.mod h1:eH6gbSOAUv07dQuZVnBmoDP8mgsM1rtixis4Tib9if0=
 github.com/Gurpartap/async v0.0.0-20180927173644-4f7f499dd9ee h1:8doiS7ib3zi6/K172oDhSKU0dJ/miJramo9NITOMyZQ=
 github.com/Gurpartap/async v0.0.0-20180927173644-4f7f499dd9ee/go.mod h1:W0GbEAA4uFNYOGG2cJpmFJ04E6SD1NLELPYZB57/7AY=
+github.com/Knetic/govaluate v3.0.1-0.20171022003610-9aa49832a739+incompatible/go.mod h1:r7JcOSlj0wfOMncg0iLm8Leh48TZaKVeNIfJntJ2wa0=
 github.com/Kubuxu/go-os-helper v0.0.1/go.mod h1:N8B+I7vPCT80IcP58r50u4+gEEcsZETFUpAzWW2ep1Y=
+github.com/OneOfOne/xxhash v1.2.2 h1:KMrpdQIwFcEqXDklaen+P1axHaj9BSKzvpUUfnHldSE=
+github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU=
 github.com/Shopify/sarama v1.19.0/go.mod h1:FVkBWblsNy7DGZRfXLU0O9RCGt5g3g3yEuWXgklEdEo=
 github.com/Shopify/toxiproxy v2.1.4+incompatible/go.mod h1:OXgGpZ6Cli1/URJOF1DMxUHB2q5Ap20/P/eIdh4G0pI=
 github.com/StackExchange/wmi v0.0.0-20190523213315-cbe66965904d h1:G0m3OIz70MZUWq3EgK3CesDbo8upS2Vm9/P3FtgI+Jk=
 github.com/StackExchange/wmi v0.0.0-20190523213315-cbe66965904d/go.mod h1:3eOhrUMpNV+6aFIbp5/iudMxNCF27Vw2OZgy4xEx0Fg=
+github.com/Stebalien/go-bitfield v0.0.0-20180330043415-076a62f9ce6e/go.mod h1:3oM7gXIttpYDAJXpVNnSCiUMYBLIZ6cb1t+Ip982MRo=
 github.com/Stebalien/go-bitfield v0.0.1 h1:X3kbSSPUaJK60wV2hjOPZwmpljr6VGCqdq4cBLhbQBo=
 github.com/Stebalien/go-bitfield v0.0.1/go.mod h1:GNjFpasyUVkHMsfEOk8EFLJ9syQ6SI+XWrX9Wf2XH0s=
+github.com/VividCortex/gohistogram v1.0.0/go.mod h1:Pf5mBqqDxYaXu3hDrrU+w6nw50o/4+TcAqDqk/vUH7g=
+github.com/acarl005/stripansi v0.0.0-20180116102854-5a71ef0e047d h1:licZJFw2RwpHMqeKTCYkitsPqHNxTmd4SNR5r94FGM8=
+github.com/acarl005/stripansi v0.0.0-20180116102854-5a71ef0e047d/go.mod h1:asat636LX7Bqt5lYEZ27JNDcqxfjdBQuJ/MM4CN/Lzo=
 github.com/aead/siphash v1.0.1/go.mod h1:Nywa3cDsYNNK3gaciGTWPwHt0wlpNV15vwmswBAUSII=
+github.com/afex/hystrix-go v0.0.0-20180502004556-fa1af6a1f4f5/go.mod h1:SkGFH1ia65gfNATL8TAiHDNxPzPdmEL5uirI2Uyuz6c=
 github.com/akavel/rsrc v0.8.0 h1:zjWn7ukO9Kc5Q62DOJCcxGpXC18RawVtYAGdz2aLlfw=
 github.com/akavel/rsrc v0.8.0/go.mod h1:uLoCtb9J+EyAqh+26kdrTgmzRBFPGOolLWKpdxkKq+c=
-github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc h1:cAKDfWh5VpdgMhJosfJnn5/FoN2SRZ4p7fJNX58YPaU=
 github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
-github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf h1:qet1QNfXsQxTZqLG4oE62mJzwPIB8+Tee4RNCL9ulrY=
+github.com/alecthomas/template v0.0.0-20190718012654-fb15b899a751 h1:JYp7IbQjafoB+tBA3gMyHYHrpOtNuDiK/uB5uXxq5wM=
+github.com/alecthomas/template v0.0.0-20190718012654-fb15b899a751/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
 github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
-github.com/apache/thrift v0.12.0 h1:pODnxUFNcjP9UTLZGTdeh+j16A8lJbRvD3rOtrk/7bs=
+github.com/alecthomas/units v0.0.0-20190717042225-c3de453c63f4/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
+github.com/alecthomas/units v0.0.0-20190924025748-f65c72e2690d h1:UQZhZ2O0vMHr2cI+DC1Mbh0TJxzA3RcLoMsFw+aXw7E=
+github.com/alecthomas/units v0.0.0-20190924025748-f65c72e2690d/go.mod h1:rBZYJk541a8SKzHPHnH3zbiI+7dagKZ0cgpgrD7Fyho=
+github.com/anmitsu/go-shlex v0.0.0-20161002113705-648efa622239/go.mod h1:2FmKhYUyUczH0OGQWaF5ceTx0UBShxjsH6f8oGKYe2c=
+github.com/antihax/optional v1.0.0/go.mod h1:uupD/76wgC+ih3iEmQUL+0Ugr19nfwCT1kdvxnR2qWY=
 github.com/apache/thrift v0.12.0/go.mod h1:cp2SuWMxlEZw2r+iP2GNCdIi4C1qmUzdZFSVb+bacwQ=
+github.com/apache/thrift v0.13.0 h1:5hryIiq9gtn+MiLVn0wP37kb/uTeRZgN08WoCsAhIhI=
+github.com/apache/thrift v0.13.0/go.mod h1:cp2SuWMxlEZw2r+iP2GNCdIi4C1qmUzdZFSVb+bacwQ=
+github.com/armon/circbuf v0.0.0-20150827004946-bbbad097214e/go.mod h1:3U/XgcO3hCbHZ8TKRvWD2dDTCfh9M9ya+I9JpbB7O8o=
 github.com/armon/consul-api v0.0.0-20180202201655-eb2c6b5be1b6/go.mod h1:grANhF5doyWs3UAsr3K4I6qtAmlQcZDesFNEHPZAzj8=
+github.com/armon/go-metrics v0.0.0-20180917152333-f0300d1749da/go.mod h1:Q73ZrmVTwzkszR9V5SSuryQ31EELlFMUz1kKyl939pY=
+github.com/armon/go-radix v0.0.0-20180808171621-7fddfc383310/go.mod h1:ufUuZ+zHj4x4TnLV4JWEpy2hxWSpsRywHrMgIH9cCH8=
+github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5/go.mod h1:wHh0iHkYZB8zMSxRWpUBQtwG5a7fFgvEO+odwuTv2gs=
+github.com/aryann/difflib v0.0.0-20170710044230-e206f873d14a/go.mod h1:DAHtR1m6lCRdSC2Tm3DSWRPvIPr6xNKyeHdqDQSQT+A=
+github.com/aws/aws-lambda-go v1.13.3/go.mod h1:4UKl9IzQMoD+QF79YdCuzCwp8VbmG4VAQwij/eHl5CU=
+github.com/aws/aws-sdk-go v1.27.0/go.mod h1:KmX6BPdI08NWTb3/sm4ZGu5ShLoqVDhKgpiN924inxo=
+github.com/aws/aws-sdk-go v1.32.11/go.mod h1:5zCpMtNQVjRREroY7sYe8lOMRSxkhG6MZveU8YkpAk0=
+github.com/aws/aws-sdk-go-v2 v0.18.0/go.mod h1:JWVYvqSMppoMJC0x5wdwiImzgXTI9FuZwxzkQq9wy+g=
+github.com/beevik/ntp v0.2.0/go.mod h1:hIHWr+l3+/clUnF44zdK+CWW7fO8dR5cIylAQ76NRpg=
+github.com/benbjohnson/clock v1.0.1/go.mod h1:bGMdMPoPVvcYyt1gHDf4J2KE153Yf9BuiUKYMaxlTDM=
+github.com/benbjohnson/clock v1.0.2/go.mod h1:bGMdMPoPVvcYyt1gHDf4J2KE153Yf9BuiUKYMaxlTDM=
+github.com/benbjohnson/clock v1.0.3 h1:vkLuvpK4fmtSCuo60+yC63p7y0BmQ8gm5ZXGuBCJyXg=
+github.com/benbjohnson/clock v1.0.3/go.mod h1:bGMdMPoPVvcYyt1gHDf4J2KE153Yf9BuiUKYMaxlTDM=
 github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q=
+github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+CedLV8=
+github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
+github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
+github.com/bgentry/speakeasy v0.1.0/go.mod h1:+zsyZBPWlz7T6j88CTgSN5bM796AkVf0kBD4zp0CCIs=
+github.com/bradfitz/go-smtpd v0.0.0-20170404230938-deb6d6237625/go.mod h1:HYsPBTaaSFSlLx/70C2HPIMNZpVV8+vt/A+FMnYP11g=
+github.com/briandowns/spinner v1.11.1/go.mod h1:QOuQk7x+EaDASo80FEXwlwiA+j/PPIcX3FScO+3/ZPQ=
 github.com/btcsuite/btcd v0.0.0-20190213025234-306aecffea32/go.mod h1:DrZx5ec/dmnfpw9KyYoQyYo7d0KEvTkk/5M/vbZjAr8=
 github.com/btcsuite/btcd v0.0.0-20190523000118-16327141da8c/go.mod h1:3J08xEfcugPacsc34/LKRU2yO7YmuT8yt28J8k2+rrI=
 github.com/btcsuite/btcd v0.0.0-20190605094302-a0d1e3e36d50/go.mod h1:3J08xEfcugPacsc34/LKRU2yO7YmuT8yt28J8k2+rrI=
-github.com/btcsuite/btcd v0.0.0-20190824003749-130ea5bddde3 h1:A/EVblehb75cUgXA5njHPn0kLAsykn6mJGz7rnmW5W0=
 github.com/btcsuite/btcd v0.0.0-20190824003749-130ea5bddde3/go.mod h1:3J08xEfcugPacsc34/LKRU2yO7YmuT8yt28J8k2+rrI=
+github.com/btcsuite/btcd v0.20.1-beta h1:Ik4hyJqN8Jfyv3S4AGBOmyouMsYE3EdYODkMbQjwPGw=
+github.com/btcsuite/btcd v0.20.1-beta/go.mod h1:wVuoA8VJLEcwgqHBwHmzLRazpKxTv13Px/pDuV7OomQ=
 github.com/btcsuite/btclog v0.0.0-20170628155309-84c8d2346e9f/go.mod h1:TdznJufoqS23FtqVCzL0ZqgP5MqXbb4fg/WgDys70nA=
 github.com/btcsuite/btcutil v0.0.0-20190207003914-4c204d697803/go.mod h1:+5NJ2+qvTyV9exUAL/rxXi3DcLg2Ts+ymUAY5y4NvMg=
 github.com/btcsuite/btcutil v0.0.0-20190425235716-9e5f4b9a998d/go.mod h1:+5NJ2+qvTyV9exUAL/rxXi3DcLg2Ts+ymUAY5y4NvMg=
@@ -44,16 +106,48 @@ github.com/btcsuite/goleveldb v0.0.0-20160330041536-7834afc9e8cd/go.mod h1:F+uVa
 github.com/btcsuite/snappy-go v0.0.0-20151229074030-0bdef8d06723/go.mod h1:8woku9dyThutzjeg+3xrA5iCpBRH8XEEg3lh6TiUghc=
 github.com/btcsuite/websocket v0.0.0-20150119174127-31079b680792/go.mod h1:ghJtEyQwv5/p4Mg4C0fgbePVuGr935/5ddU9Z3TmDRY=
 github.com/btcsuite/winsvc v1.0.0/go.mod h1:jsenWakMcC0zFBFurPLEAyrnc/teJEM1O46fmI40EZs=
+github.com/buger/goterm v0.0.0-20200322175922-2f3e71b85129 h1:gfAMKE626QEuKG3si0pdTRcr/YEbBoxY+3GOH3gWvl4=
+github.com/buger/goterm v0.0.0-20200322175922-2f3e71b85129/go.mod h1:u9UyCz2eTrSGy6fbupqJ54eY5c4IC8gREQ1053dK12U=
+github.com/buger/jsonparser v0.0.0-20181115193947-bf1c66bbce23/go.mod h1:bbYlZJ7hK1yFx9hf58LP0zeX7UjIGs20ufpu3evjr+s=
+github.com/casbin/casbin/v2 v2.1.2/go.mod h1:YcPU1XXisHhLzuxH9coDNf2FbKpjGlbCg3n9yuLkIJQ=
+github.com/cenkalti/backoff v2.2.1+incompatible/go.mod h1:90ReRw6GdpyfrHakVjL/QHaoyV4aDUVVkXQJJJ3NXXM=
+github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
+github.com/cespare/xxhash v1.1.0 h1:a6HrQnmkObjyL+Gs60czilIUGqrzKutQD6XZog3p+ko=
+github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc=
+github.com/cespare/xxhash/v2 v2.1.1 h1:6MnRN8NT7+YBpUIWxHtefFZOKTAPgGjpQSxqLNn0+qY=
+github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
 github.com/cheekybits/genny v1.0.0 h1:uGGa4nei+j20rOSeDeP5Of12XVm7TGUd4dJA9RDitfE=
 github.com/cheekybits/genny v1.0.0/go.mod h1:+tQajlRqAUrPI7DOSpB0XAqZYtQakVtB7wXkRAgjxjQ=
+github.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI=
+github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e/go.mod h1:nSuG5e5PlCu98SY8svDHJxuZscDgtXS6KTTbou5AhLI=
+github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU=
+github.com/clbanning/x2j v0.0.0-20191024224557-825249438eec/go.mod h1:jMjuTZXRI4dUb/I5gc9Hdhagfvm9+RyrPryS/auMzxE=
 github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
+github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc=
+github.com/cockroachdb/datadriven v0.0.0-20190809214429-80d97fb3cbaa/go.mod h1:zn76sxSg3SzpJ0PPJaLDCu+Bu0Lg3sKTORVIj19EIF8=
+github.com/codahale/hdrhistogram v0.0.0-20161010025455-3a0bb77429bd h1:qMd81Ts1T2OTKmB4acZcyKaMtRnY5Y44NuXGX2GFJ1w=
+github.com/codahale/hdrhistogram v0.0.0-20161010025455-3a0bb77429bd/go.mod h1:sE/e/2PUdi/liOCUjSTXgM1o87ZssimdTWN964YiIeI=
 github.com/coreos/etcd v3.3.10+incompatible/go.mod h1:uF7uidLiAD3TWHmW31ZFd/JWoc32PjwdhPthX9715RE=
 github.com/coreos/go-etcd v2.0.0+incompatible/go.mod h1:Jez6KQU2B/sWsbdaef3ED8NzMklzPG4d5KIOhIy30Tk=
 github.com/coreos/go-semver v0.2.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk=
 github.com/coreos/go-semver v0.2.1-0.20180108230905-e214231b295a/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk=
 github.com/coreos/go-semver v0.3.0 h1:wkHLiw0WNATZnSG7epLsujiMCgPAc9xhjJ4tgnAxmfM=
 github.com/coreos/go-semver v0.3.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk=
+github.com/coreos/go-systemd v0.0.0-20180511133405-39ca1b05acc7/go.mod h1:F5haX7vjVVG0kc13fIWeqUViNPyEJxv/OmvnBo0Yme4=
+github.com/coreos/go-systemd v0.0.0-20181012123002-c6f51f82210d/go.mod h1:F5haX7vjVVG0kc13fIWeqUViNPyEJxv/OmvnBo0Yme4=
+github.com/coreos/go-systemd v0.0.0-20191104093116-d3cd4ed1dbcf h1:iW4rZ826su+pqaw19uhpSCzhj44qo35pNgKFGqzDKkU=
+github.com/coreos/go-systemd v0.0.0-20191104093116-d3cd4ed1dbcf/go.mod h1:F5haX7vjVVG0kc13fIWeqUViNPyEJxv/OmvnBo0Yme4=
+github.com/coreos/go-systemd/v22 v22.0.0 h1:XJIw/+VlJ+87J+doOxznsAWIdmWuViOVhkQamW5YV28=
+github.com/coreos/go-systemd/v22 v22.0.0/go.mod h1:xO0FLkIi5MaZafQlIrOotqXZ90ih+1atmu1JpKERPPk=
+github.com/coreos/pkg v0.0.0-20160727233714-3ac0863d7acf/go.mod h1:E3G3o1h8I7cfcXa63jLwjI0eiQQMgzzUDFVpN/nH/eA=
+github.com/cpuguy83/go-md2man v1.0.10 h1:BSKMNlYxDvnunlTymqtgONjNnaRV1sTpcovwwjF22jk=
 github.com/cpuguy83/go-md2man v1.0.10/go.mod h1:SmD6nW6nTyfqj6ABTjUi3V3JVMnlJmwcJI5acqYI6dE=
+github.com/cpuguy83/go-md2man/v2 v2.0.0-20190314233015-f79a8a8ca69d/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU=
+github.com/cpuguy83/go-md2man/v2 v2.0.0 h1:EoUDS0afbrsXAZ9YQ9jdu/mZ2sXgT1/2yyNng4PGlyM=
+github.com/cpuguy83/go-md2man/v2 v2.0.0/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU=
+github.com/crackcomm/go-gitignore v0.0.0-20170627025303-887ab5e44cc3 h1:HVTnpeuvF6Owjd5mniCL8DEXo7uYXdQEmOP4FJbV5tg=
+github.com/crackcomm/go-gitignore v0.0.0-20170627025303-887ab5e44cc3/go.mod h1:p1d6YEZWvFzEh4KLyvBcVSnrfNDDvK2zfK/4x2v/4pE=
+github.com/creack/pty v1.1.7/go.mod h1:lj5s0c3V2DBrqTV7llrYr5NG6My20zk30Fl46Y7DoTY=
 github.com/cskr/pubsub v1.0.2 h1:vlOzMhl6PFn60gRlTQQsIfVwaPB/B/8MziK8FhEPt/0=
 github.com/cskr/pubsub v1.0.2/go.mod h1:/8MzYXk/NJAz782G8RPkFzXTZVu63VotefPnR9TIRis=
 github.com/daaku/go.zipexe v1.0.0 h1:VSOgZtH418pH9L16hC/JrgSNJbbAL26pj7lmD1+CGdY=
@@ -62,459 +156,884 @@ github.com/davecgh/go-spew v0.0.0-20171005155431-ecdeabc65495/go.mod h1:J7Y8YcW2
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/davidlazar/go-crypto v0.0.0-20170701192655-dcfb0a7ac018 h1:6xT9KW8zLC5IlbaIF5Q7JNieBoACT7iW0YTxQHR0in0=
 github.com/davidlazar/go-crypto v0.0.0-20170701192655-dcfb0a7ac018/go.mod h1:rQYf4tfk5sSwFsnDg3qYaBxSjsD9S8+59vW0dKUgme4=
+github.com/davidlazar/go-crypto v0.0.0-20190912175916-7055855a373f h1:BOaYiTvg8p9vBUXpklC22XSK/mifLF7lG9jtmYYi3Tc=
+github.com/davidlazar/go-crypto v0.0.0-20190912175916-7055855a373f/go.mod h1:rQYf4tfk5sSwFsnDg3qYaBxSjsD9S8+59vW0dKUgme4=
+github.com/detailyang/go-fallocate v0.0.0-20180908115635-432fa640bd2e h1:lj77EKYUpYXTd8CD/+QMIf8b6OIOTsfEBSXiAzuEHTU=
+github.com/detailyang/go-fallocate v0.0.0-20180908115635-432fa640bd2e/go.mod h1:3ZQK6DMPSz/QZ73jlWxBtUhNA8xZx7LzUFSq/OfP8vk=
 github.com/dgraph-io/badger v1.5.5-0.20190226225317-8115aed38f8f/go.mod h1:VZxzAIRPHRVNRKRo6AXrX9BJegn6il06VMTZVJYCIjQ=
 github.com/dgraph-io/badger v1.6.0-rc1/go.mod h1:zwt7syl517jmP8s94KqSxTlM6IMsdhYy6psNgSztDR4=
-github.com/dgraph-io/badger v1.6.0 h1:DshxFxZWXUcO0xX476VJC07Xsr6ZCBVRHKZ93Oh7Evo=
 github.com/dgraph-io/badger v1.6.0/go.mod h1:zwt7syl517jmP8s94KqSxTlM6IMsdhYy6psNgSztDR4=
+github.com/dgraph-io/badger v1.6.1 h1:w9pSFNSdq/JPM1N12Fz/F/bzo993Is1W+Q7HjPzi7yg=
+github.com/dgraph-io/badger v1.6.1/go.mod h1:FRmFw3uxvcpa8zG3Rxs0th+hCLIuaQg8HlNV5bjgnuU=
+github.com/dgraph-io/badger/v2 v2.0.3/go.mod h1:3KY8+bsP8wI0OEnQJAKpd4wIJW/Mm32yw2j/9FUVnIM=
+github.com/dgraph-io/badger/v2 v2.2007.2 h1:EjjK0KqwaFMlPin1ajhP943VPENHJdEz1KLIegjaI3k=
+github.com/dgraph-io/badger/v2 v2.2007.2/go.mod h1:26P/7fbL4kUZVEVKLAKXkBXKOydDmM2p1e+NhhnBCAE=
+github.com/dgraph-io/ristretto v0.0.2-0.20200115201040-8f368f2f2ab3/go.mod h1:KPxhHT9ZxKefz+PCeOGsrHpl1qZ7i70dGTu2u+Ahh6E=
+github.com/dgraph-io/ristretto v0.0.2/go.mod h1:KPxhHT9ZxKefz+PCeOGsrHpl1qZ7i70dGTu2u+Ahh6E=
+github.com/dgraph-io/ristretto v0.0.3-0.20200630154024-f66de99634de h1:t0UHb5vdojIDUqktM6+xJAfScFBsVpXZmqC9dsgJmeA=
+github.com/dgraph-io/ristretto v0.0.3-0.20200630154024-f66de99634de/go.mod h1:KPxhHT9ZxKefz+PCeOGsrHpl1qZ7i70dGTu2u+Ahh6E=
+github.com/dgrijalva/jwt-go v3.2.0+incompatible/go.mod h1:E3ru+11k8xSBh+hMPgOLZmtrrCbhqsmaPHjLKYnJCaQ=
 github.com/dgryski/go-farm v0.0.0-20190104051053-3adb47b1fb0f/go.mod h1:SqUrOPUnsFjfmXRMNPybcSiG0BgUW2AuFH8PAnS2iTw=
 github.com/dgryski/go-farm v0.0.0-20190423205320-6a90982ecee2 h1:tdlZCpZ/P9DhczCTSixgIKmwPv6+wP5DGjqLYw5SUiA=
 github.com/dgryski/go-farm v0.0.0-20190423205320-6a90982ecee2/go.mod h1:SqUrOPUnsFjfmXRMNPybcSiG0BgUW2AuFH8PAnS2iTw=
 github.com/docker/go-units v0.4.0 h1:3uh0PgVws3nIA0Q+MwDC8yjEPf9zjRfZZWXZYDct3Tw=
 github.com/docker/go-units v0.4.0/go.mod h1:fgPhTUdO+D/Jk86RDLlptpiXQzgHJF7gydDDbaIK4Dk=
+github.com/drand/bls12-381 v0.3.2 h1:RImU8Wckmx8XQx1tp1q04OV73J9Tj6mmpQLYDP7V1XE=
+github.com/drand/bls12-381 v0.3.2/go.mod h1:dtcLgPtYT38L3NO6mPDYH0nbpc5tjPassDqiniuAt4Y=
+github.com/drand/drand v1.1.2-0.20200905144319-79c957281b32 h1:sU+51aQRaDxg0KnjQg19KuYRIxDBEUHffBAICSnBys8=
+github.com/drand/drand v1.1.2-0.20200905144319-79c957281b32/go.mod h1:0sQEVg+ngs1jaDPVIiEgY0lbENWJPaUlWxGHEaSmKVM=
+github.com/drand/kyber v1.0.1-0.20200110225416-8de27ed8c0e2/go.mod h1:UpXoA0Upd1N9l4TvRPHr1qAUBBERj6JQ/mnKI3BPEmw=
+github.com/drand/kyber v1.0.2/go.mod h1:x6KOpK7avKj0GJ4emhXFP5n7M7W7ChAPmnQh/OL6vRw=
+github.com/drand/kyber v1.1.2 h1:faemqlaFyLrbBSjZGRzzu5SG/do+uTYpHlnrJIHbAhQ=
+github.com/drand/kyber v1.1.2/go.mod h1:x6KOpK7avKj0GJ4emhXFP5n7M7W7ChAPmnQh/OL6vRw=
+github.com/drand/kyber-bls12381 v0.1.0 h1:/P4C65VnyEwxzR5ZYYVMNzY1If+aYBrdUU5ukwh7LQw=
+github.com/drand/kyber-bls12381 v0.1.0/go.mod h1:N1emiHpm+jj7kMlxEbu3MUyOiooTgNySln564cgD9mk=
+github.com/dustin/go-humanize v0.0.0-20171111073723-bb3d318650d4/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=
 github.com/dustin/go-humanize v1.0.0 h1:VSnTsYCnlFHaM2/igO1h6X3HA71jcobQuxemgkq4zYo=
 github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=
 github.com/eapache/go-resiliency v1.1.0/go.mod h1:kFI+JgMyC7bLPUVY133qvEBtVayf5mFgVsvEsIPBvNs=
 github.com/eapache/go-xerial-snappy v0.0.0-20180814174437-776d5712da21/go.mod h1:+020luEh2TKB4/GOp8oxxtq0Daoen/Cii55CzbTV6DU=
 github.com/eapache/queue v1.1.0/go.mod h1:6eCeP0CKFpHLu8blIFXhExK/dRa7WDZfr6jVFPTqq+I=
-github.com/fatih/color v1.7.0 h1:DkWD4oS2D8LGGgTQ6IvwJJXSL5Vp2ffcQg58nFV38Ys=
+github.com/edsrzf/mmap-go v1.0.0/go.mod h1:YO35OhQPt3KJa3ryjFM5Bs14WD66h8eGKpfaBNrHW5M=
+github.com/elastic/go-sysinfo v1.3.0 h1:eb2XFGTMlSwG/yyU9Y8jVAYLIzU2sFzWXwo2gmetyrE=
+github.com/elastic/go-sysinfo v1.3.0/go.mod h1:i1ZYdU10oLNfRzq4vq62BEwD2fH8KaWh6eh0ikPT9F0=
+github.com/elastic/go-windows v1.0.0 h1:qLURgZFkkrYyTTkvYpsZIgf83AUsdIHfvlJaqaZ7aSY=
+github.com/elastic/go-windows v1.0.0/go.mod h1:TsU0Nrp7/y3+VwE82FoZF8gC/XFg/Elz6CcloAxnPgU=
+github.com/ema/qdisc v0.0.0-20190904071900-b82c76788043/go.mod h1:ix4kG2zvdUd8kEKSW0ZTr1XLks0epFpI4j745DXxlNE=
+github.com/envoyproxy/go-control-plane v0.6.9/go.mod h1:SBwIajubJHhxtWwsL9s8ss4safvEdbitLhGGK48rN6g=
+github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
+github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
+github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98=
+github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
+github.com/facebookgo/atomicfile v0.0.0-20151019160806-2de1f203e7d5 h1:BBso6MBKW8ncyZLv37o+KNyy0HrrHgfnOaGQC2qvN+A=
+github.com/facebookgo/atomicfile v0.0.0-20151019160806-2de1f203e7d5/go.mod h1:JpoxHjuQauoxiFMl1ie8Xc/7TfLuMZ5eOCONd1sUBHg=
 github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4=
 github.com/fatih/color v1.8.0 h1:5bzFgL+oy7JITMTxUPJ00n7VxmYd/PdMp5mHFX40/RY=
 github.com/fatih/color v1.8.0/go.mod h1:3l45GVGkyrnYNl9HoIjnp2NnNWvh6hLAqD8yTfGjnw8=
 github.com/fd/go-nat v1.0.0/go.mod h1:BTBu/CKvMmOMUPkKVef1pngt2WFH/lg7E6yQnulfp6E=
-github.com/filecoin-project/chain-validation v0.0.3 h1:luT/8kJ0WdMIqQ9Bm31W4JkuYCW0wUb26AvnD4WK59M=
-github.com/filecoin-project/chain-validation v0.0.3/go.mod h1:NCEGFjcWRjb8akWFSOXvU6n2efkWIqAeOKU6o5WBGQw=
-github.com/filecoin-project/go-address v0.0.0-20191219011437-af739c490b4f h1:L2jaVU8TvWTx7iZPhlYvUE8vkoOnj778XuKavz8W36g=
-github.com/filecoin-project/go-address v0.0.0-20191219011437-af739c490b4f/go.mod h1:rCbpXPva2NKF9/J4X6sr7hbKBgQCxyFtRj7KOZqoIms=
-github.com/filecoin-project/go-amt-ipld v0.0.0-20191205011053-79efc22d6cdc h1:cODZD2YzpTUtrOSxbEnWFcQHidNRZiRdvLxySjGvG/M=
-github.com/filecoin-project/go-amt-ipld v0.0.0-20191205011053-79efc22d6cdc/go.mod h1:KsFPWjF+UUYl6n9A+qbg4bjFgAOneicFZtDH/LQEX2U=
+github.com/filecoin-project/go-address v0.0.3 h1:eVfbdjEbpbzIrbiSa+PiGUY+oDK9HnUn+M1R/ggoHf8=
+github.com/filecoin-project/go-address v0.0.3/go.mod h1:jr8JxKsYx+lQlQZmF5i2U0Z+cGQ59wMIps/8YW/lDj8=
+github.com/filecoin-project/go-address v0.0.4 h1:gSNMv0qWwH16fGQs7ycOUrDjY6YCSsgLUl0I0KLjo8w=
+github.com/filecoin-project/go-address v0.0.4/go.mod h1:jr8JxKsYx+lQlQZmF5i2U0Z+cGQ59wMIps/8YW/lDj8=
+github.com/filecoin-project/go-amt-ipld/v2 v2.1.0 h1:t6qDiuGYYngDqaLc2ZUvdtAg4UNxPeOYaXhBWSNsVaM=
+github.com/filecoin-project/go-amt-ipld/v2 v2.1.0/go.mod h1:nfFPoGyX0CU9SkXX8EoCcSuHN1XcbN0c6KBh7yvP5fs=
+github.com/filecoin-project/go-bitfield v0.2.0 h1:gCtLcjskIPtdg4NfN7gQZSQF9yrBQ7mkT0qCJxzGI2Q=
+github.com/filecoin-project/go-bitfield v0.2.0/go.mod h1:CNl9WG8hgR5mttCnUErjcQjGvuiZjRqK9rHVBsQF4oM=
 github.com/filecoin-project/go-cbor-util v0.0.0-20191219014500-08c40a1e63a2 h1:av5fw6wmm58FYMgJeoB/lK9XXrgdugYiTqkdxjTy9k8=
 github.com/filecoin-project/go-cbor-util v0.0.0-20191219014500-08c40a1e63a2/go.mod h1:pqTiPHobNkOVM5thSRsHYjyQfq7O5QSCMhvuu9JoDlg=
 github.com/filecoin-project/go-crypto v0.0.0-20191218222705-effae4ea9f03 h1:2pMXdBnCiXjfCYx/hLqFxccPoqsSveQFxVLvNxy9bus=
-github.com/filecoin-project/go-crypto v0.0.0-20191218222705-effae4ea9f03 h1:2pMXdBnCiXjfCYx/hLqFxccPoqsSveQFxVLvNxy9bus=
 github.com/filecoin-project/go-crypto v0.0.0-20191218222705-effae4ea9f03/go.mod h1:+viYnvGtUTgJRdy6oaeF4MTFKAfatX071MPDPBL11EQ=
-github.com/filecoin-project/go-crypto v0.0.0-20191218222705-effae4ea9f03/go.mod h1:+viYnvGtUTgJRdy6oaeF4MTFKAfatX071MPDPBL11EQ=
-github.com/filecoin-project/go-paramfetch v0.0.0-20200102181131-b20d579f2878 h1:YicJT9xhPzZ1SBGiJFNUCkfwqK/G9vFyY1ytKBSjNJA=
-github.com/filecoin-project/go-paramfetch v0.0.0-20200102181131-b20d579f2878 h1:YicJT9xhPzZ1SBGiJFNUCkfwqK/G9vFyY1ytKBSjNJA=
-github.com/filecoin-project/go-paramfetch v0.0.0-20200102181131-b20d579f2878/go.mod h1:40kI2Gv16mwcRsHptI3OAV4nlOEU7wVDc4RgMylNFjU=
-github.com/filecoin-project/go-paramfetch v0.0.0-20200102181131-b20d579f2878/go.mod h1:40kI2Gv16mwcRsHptI3OAV4nlOEU7wVDc4RgMylNFjU=
-github.com/filecoin-project/go-paramfetch v0.0.1 h1:gV7bs5YaqlgpGFMiLxInGK2L1FyCXUE0rimz4L7ghoE=
-github.com/filecoin-project/go-paramfetch v0.0.1/go.mod h1:fZzmf4tftbwf9S37XRifoJlz7nCjRdIrMGLR07dKLCc=
-github.com/filecoin-project/go-sectorbuilder v0.0.0-20200107152336-0cbb2c483013 h1:OGpRq3HRxyrxZJtbNKCOsb5YTmc+RBLLwdAgwZfkRnY=
-github.com/filecoin-project/go-sectorbuilder v0.0.0-20200107152336-0cbb2c483013/go.mod h1:3OZ4E3B2OuwhJjtxR4r7hPU9bCfB+A+hm4alLEsaeDc=
-github.com/filecoin-project/go-statestore v0.0.0-20200102200712-1f63c701c1e5 h1:NZXq90YlfakSmB2/84dGr0AVmKYFA97+yyViBIgTFbk=
-github.com/filecoin-project/go-statestore v0.0.0-20200102200712-1f63c701c1e5/go.mod h1:LFc9hD+fRxPqiHiaqUEZOinUJB4WARkRfNl10O7kTnI=
-github.com/fsnotify/fsnotify v1.4.7 h1:IXs+QLmnXW2CcXuY+8Mzv/fWEsPGWxqefPtCP5CnV9I=
+github.com/filecoin-project/go-data-transfer v0.6.6 h1:2TccLSxPYJENcYRdov2WvpTvQ1qUMrPkWe8sBrfj36g=
+github.com/filecoin-project/go-data-transfer v0.6.6/go.mod h1:C++k1U6+jMQODOaen5OPDo9XQbth9Yq3ie94vNjBJbk=
+github.com/filecoin-project/go-fil-commcid v0.0.0-20200716160307-8f644712406f h1:GxJzR3oRIMTPtpZ0b7QF8FKPK6/iPAc7trhlL5k/g+s=
+github.com/filecoin-project/go-fil-commcid v0.0.0-20200716160307-8f644712406f/go.mod h1:Eaox7Hvus1JgPrL5+M3+h7aSPHc0cVqpSxA+TxIEpZQ=
+github.com/filecoin-project/go-fil-markets v0.6.3 h1:3kTxfquGvk3zQY+hJH1kEA28tRQ47phqSRqOI4+YcQM=
+github.com/filecoin-project/go-fil-markets v0.6.3/go.mod h1:Ug1yhGhzTYC6qrpKsR2QpU8QRCeBpwkTA9RICVKuOMM=
+github.com/filecoin-project/go-hamt-ipld v0.1.5 h1:uoXrKbCQZ49OHpsTCkrThPNelC4W3LPEk0OrS/ytIBM=
+github.com/filecoin-project/go-hamt-ipld v0.1.5 h1:uoXrKbCQZ49OHpsTCkrThPNelC4W3LPEk0OrS/ytIBM=
+github.com/filecoin-project/go-hamt-ipld v0.1.5/go.mod h1:6Is+ONR5Cd5R6XZoCse1CWaXZc0Hdb/JeX+EQCQzX24=
+github.com/filecoin-project/go-hamt-ipld v0.1.5/go.mod h1:6Is+ONR5Cd5R6XZoCse1CWaXZc0Hdb/JeX+EQCQzX24=
+github.com/filecoin-project/go-jsonrpc v0.1.2-0.20200822201400-474f4fdccc52 h1:FXtCp0ybqdQL9knb3OGDpkNTaBbPxgkqPeWKotUwkH0=
+github.com/filecoin-project/go-jsonrpc v0.1.2-0.20200822201400-474f4fdccc52/go.mod h1:XBBpuKIMaXIIzeqzO1iucq4GvbF8CxmXRFoezRh+Cx4=
+github.com/filecoin-project/go-multistore v0.0.3 h1:vaRBY4YiA2UZFPK57RNuewypB8u0DzzQwqsL0XarpnI=
+github.com/filecoin-project/go-multistore v0.0.3/go.mod h1:kaNqCC4IhU4B1uyr7YWFHd23TL4KM32aChS0jNkyUvQ=
+github.com/filecoin-project/go-padreader v0.0.0-20200903213702-ed5fae088b20 h1:+/4aUeUoKr6AKfPE3mBhXA5spIV6UcKdTYDPNU2Tdmg=
+github.com/filecoin-project/go-padreader v0.0.0-20200903213702-ed5fae088b20/go.mod h1:mPn+LRRd5gEKNAtc+r3ScpW2JRU/pj4NBKdADYWHiak=
+github.com/filecoin-project/go-paramfetch v0.0.2-0.20200701152213-3e0f0afdc261 h1:A256QonvzRaknIIAuWhe/M2dpV2otzs3NBhi5TWa/UA=
+github.com/filecoin-project/go-paramfetch v0.0.2-0.20200701152213-3e0f0afdc261/go.mod h1:fZzmf4tftbwf9S37XRifoJlz7nCjRdIrMGLR07dKLCc=
+github.com/filecoin-project/go-state-types v0.0.0-20200903145444-247639ffa6ad/go.mod h1:IQ0MBPnonv35CJHtWSN3YY1Hz2gkPru1Q9qoaYLxx9I=
+github.com/filecoin-project/go-state-types v0.0.0-20200904021452-1883f36ca2f4/go.mod h1:IQ0MBPnonv35CJHtWSN3YY1Hz2gkPru1Q9qoaYLxx9I=
+github.com/filecoin-project/go-state-types v0.0.0-20200905071437-95828685f9df/go.mod h1:IQ0MBPnonv35CJHtWSN3YY1Hz2gkPru1Q9qoaYLxx9I=
+github.com/filecoin-project/go-state-types v0.0.0-20200911004822-964d6c679cfc h1:1vr/LoqGq5m5g37Q3sNSAjfwF1uJY0zmiHcvnxY6hik=
+github.com/filecoin-project/go-state-types v0.0.0-20200911004822-964d6c679cfc/go.mod h1:ezYnPf0bNkTsDibL/psSz5dy4B5awOJ/E7P2Saeep8g=
+github.com/filecoin-project/go-statemachine v0.0.0-20200714194326-a77c3ae20989/go.mod h1:FGwQgZAt2Gh5mjlwJUlVB62JeYdo+if0xWxSEfBD9ig=
+github.com/filecoin-project/go-statemachine v0.0.0-20200813232949-df9b130df370 h1:Jbburj7Ih2iaJ/o5Q9A+EAeTabME6YII7FLi9SKUf5c=
+github.com/filecoin-project/go-statemachine v0.0.0-20200813232949-df9b130df370/go.mod h1:FGwQgZAt2Gh5mjlwJUlVB62JeYdo+if0xWxSEfBD9ig=
+github.com/filecoin-project/go-statestore v0.1.0 h1:t56reH59843TwXHkMcwyuayStBIiWBRilQjQ+5IiwdQ=
+github.com/filecoin-project/go-statestore v0.1.0/go.mod h1:LFc9hD+fRxPqiHiaqUEZOinUJB4WARkRfNl10O7kTnI=
+github.com/filecoin-project/go-storedcounter v0.0.0-20200421200003-1c99c62e8a5b h1:fkRZSPrYpk42PV3/lIXiL0LHetxde7vyYYvSsttQtfg=
+github.com/filecoin-project/go-storedcounter v0.0.0-20200421200003-1c99c62e8a5b/go.mod h1:Q0GQOBtKf1oE10eSXSlhN45kDBdGvEcVOqMiffqX+N8=
+github.com/filecoin-project/specs-actors v0.9.4/go.mod h1:BStZQzx5x7TmCkLv0Bpa07U6cPKol6fd3w9KjMPZ6Z4=
+github.com/filecoin-project/specs-actors v0.9.7/go.mod h1:wM2z+kwqYgXn5Z7scV1YHLyd1Q1cy0R8HfTIWQ0BFGU=
+github.com/filecoin-project/specs-actors v0.9.11 h1:TnpG7HAeiUrfj0mJM7UaPW0P2137H62RGof7ftT5Mas=
+github.com/filecoin-project/specs-actors v0.9.11/go.mod h1:czlvLQGEX0fjLLfdNHD7xLymy6L3n7aQzRWzsYGf+ys=
+github.com/filecoin-project/specs-storage v0.1.1-0.20200907031224-ed2e5cd13796 h1:dJsTPWpG2pcTeojO2pyn0c6l+x/3MZYCBgo/9d11JEk=
+github.com/filecoin-project/specs-storage v0.1.1-0.20200907031224-ed2e5cd13796/go.mod h1:nJRRM7Aa9XVvygr3W9k6xGF46RWzr2zxF/iGoAIfA/g=
+github.com/filecoin-project/test-vectors/schema v0.0.1 h1:5fNF76nl4qolEvcIsjc0kUADlTMVHO73tW4kXXPnsus=
+github.com/filecoin-project/test-vectors/schema v0.0.1/go.mod h1:iQ9QXLpYWL3m7warwvK1JC/pTri8mnfEmKygNDqqY6E=
+github.com/flynn/go-shlex v0.0.0-20150515145356-3f9db97f8568/go.mod h1:xEzjJPgXI435gkrCt3MPfRiAkVrwSbHsst4LCFVfpJc=
+github.com/flynn/noise v0.0.0-20180327030543-2492fe189ae6 h1:u/UEqS66A5ckRmS4yNpjmVH56sVtS/RfclBAYocb4as=
+github.com/flynn/noise v0.0.0-20180327030543-2492fe189ae6/go.mod h1:1i71OnUq3iUe1ma7Lr6yG6/rjvM3emb6yoL7xLFzcVQ=
+github.com/francoispqt/gojay v1.2.13 h1:d2m3sFjloqoIUQU3TsHBgj6qg/BVGlTBeHDUmyJnXKk=
+github.com/francoispqt/gojay v1.2.13/go.mod h1:ehT5mTG4ua4581f1++1WLG0vPdaA9HaiDsoyrBGkyDY=
+github.com/franela/goblin v0.0.0-20200105215937-c9ffbefa60db/go.mod h1:7dvUGVsVBjqR7JHJk0brhHOZYGmfBYOrK0ZhYMEtBr4=
+github.com/franela/goreq v0.0.0-20171204163338-bcd34c9993f8/go.mod h1:ZhphrRTfi2rbfLwlschooIH4+wKKDR4Pdxhh+TRoA20=
 github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
+github.com/fsnotify/fsnotify v1.4.9 h1:hsms1Qyu0jgnwNXIxa+/V/PDsU6CfLf6CNO8H7IWoS4=
+github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ=
 github.com/gbrlsnchs/jwt/v3 v3.0.0-beta.1 h1:EzDjxMg43q1tA2c0MV3tNbaontnHLplHyFF6M5KiVP0=
 github.com/gbrlsnchs/jwt/v3 v3.0.0-beta.1/go.mod h1:0eHX/BVySxPc6SE2mZRoppGq7qcEagxdmQnA3dzork8=
-github.com/go-check/check v0.0.0-20180628173108-788fd7840127 h1:0gkP6mzaMqkmpcJYCFOLkIBwI7xFExG03bbkOkCvUPI=
+github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04=
+github.com/gliderlabs/ssh v0.1.1/go.mod h1:U7qILu1NlMHj9FlMhZLlkCdDnU1DBEAqr0aevW3Awn0=
 github.com/go-check/check v0.0.0-20180628173108-788fd7840127/go.mod h1:9ES+weclKsC9YodN5RgxqK/VD9HM9JsCSh7rNhMZE98=
+github.com/go-errors/errors v1.0.1/go.mod h1:f4zRHt4oKfwPJE5k8C9vpYG+aDHdBFUsgrm6/TyX73Q=
+github.com/go-gl/glfw v0.0.0-20190409004039-e6da0acd62b1/go.mod h1:vR7hzQXu2zJy9AVAgeJqvqgH9Q5CA+iKCZ2gyEVpxRU=
+github.com/go-gl/glfw/v3.3/glfw v0.0.0-20191125211704-12ad95a8df72/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8=
 github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
+github.com/go-kit/kit v0.9.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
+github.com/go-kit/kit v0.10.0 h1:dXFJfIHVvUcpSgDOV+Ne6t7jXri8Tfv2uOLHUZ2XNuo=
+github.com/go-kit/kit v0.10.0/go.mod h1:xUsJbQ/Fp4kEt7AFgCuvyX4a71u8h9jB8tj/ORgOZ7o=
 github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE=
+github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk=
+github.com/go-logfmt/logfmt v0.5.0 h1:TrB8swr/68K7m9CcGut2g3UOihhbcbiMAYiuTXdEih4=
+github.com/go-logfmt/logfmt v0.5.0/go.mod h1:wCYkCAKZfumFQihp8CzCvQ3paCTfi41vtzG1KdI/P7A=
 github.com/go-ole/go-ole v1.2.4 h1:nNBDSCOigTSiarFpYE9J/KtEA1IOW4CNeqT9TQDqCxI=
 github.com/go-ole/go-ole v1.2.4/go.mod h1:XCwSNxSkXRo4vlyPy93sltvi/qJq0jqQhjqQNIwKuxM=
+github.com/go-sql-driver/mysql v1.4.0/go.mod h1:zAC/RDZ24gD3HViQzih4MyKcchzm+sOG5ZlKdlhCg5w=
+github.com/go-sql-driver/mysql v1.5.0/go.mod h1:DCzpHaOWr8IXmIStZouvnhqoel9Qv2LBy8hT2VhHyBg=
+github.com/go-stack/stack v1.8.0 h1:5SgMzNM5HxrEjV0ww2lTmX6E2Izsfxas4+YHWRs3Lsk=
 github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
+github.com/godbus/dbus v0.0.0-20190402143921-271e53dc4968 h1:s+PDl6lozQ+dEUtUtQnO7+A2iPG3sK1pI4liU+jxn90=
+github.com/godbus/dbus v0.0.0-20190402143921-271e53dc4968/go.mod h1:/YcGZj5zSblfDWMMoOzV4fas9FZnQYTkDnsGvmh2Grw=
+github.com/godbus/dbus/v5 v5.0.3 h1:ZqHaoEF7TBzh4jzPmqVhE/5A1z9of6orkAe5uHoAeME=
+github.com/godbus/dbus/v5 v5.0.3/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
+github.com/gogo/googleapis v0.0.0-20180223154316-0cd9801be74a/go.mod h1:gf4bu3Q80BeJ6H1S1vYPm8/ELATdvryBaNFGgqEef3s=
+github.com/gogo/googleapis v1.1.0/go.mod h1:gf4bu3Q80BeJ6H1S1vYPm8/ELATdvryBaNFGgqEef3s=
+github.com/gogo/googleapis v1.4.0 h1:zgVt4UpGxcqVOw97aRGxT4svlcmdK35fynLNctY32zI=
+github.com/gogo/googleapis v1.4.0/go.mod h1:5YRNX2z1oM5gXdAkurHa942MDgEJyk02w4OecKY87+c=
 github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
 github.com/gogo/protobuf v1.2.0/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
 github.com/gogo/protobuf v1.2.1/go.mod h1:hp+jE20tsWTFYpLwKvXlhS1hjn+gTNwPg2I6zVXpSg4=
 github.com/gogo/protobuf v1.3.0/go.mod h1:SlYgWuQ5SjCEi6WLHjHCa1yvBfUnHcTbrrZtXPKa29o=
 github.com/gogo/protobuf v1.3.1 h1:DqDEcV5aeaTmdFBePNpYsp3FlcVH/2ISVVM9Qf8PSls=
 github.com/gogo/protobuf v1.3.1/go.mod h1:SlYgWuQ5SjCEi6WLHjHCa1yvBfUnHcTbrrZtXPKa29o=
+github.com/gogo/status v1.0.3/go.mod h1:SavQ51ycCLnc7dGyJxp8YAmudx8xqiVrRf+6IXRsugc=
+github.com/gogo/status v1.1.0 h1:+eIkrewn5q6b30y+g/BJINVVdi2xH7je5MPJ3ZPK3JA=
+github.com/gogo/status v1.1.0/go.mod h1:BFv9nrluPLmrS0EmGVvLaPNmRosr9KapBYd5/hpY1WM=
 github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
-github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6 h1:ZgQEtGgCBiWRM39fZuwSd1LwSqqSW0hOdXCYYDX0R3I=
+github.com/golang/groupcache v0.0.0-20160516000752-02826c3e7903/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
 github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
+github.com/golang/groupcache v0.0.0-20191027212112-611e8accdfc9/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
+github.com/golang/groupcache v0.0.0-20191227052852-215e87163ea7/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
+github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e h1:1r7pUrabqp18hOBcwBwiTsbnFeTZHV9eER/QT5JVZxY=
+github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
+github.com/golang/lint v0.0.0-20180702182130-06c8688daad7/go.mod h1:tluoj9z5200jBnyusfRPU2LqT6J+DAorxEvtC7LHB+E=
 github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
-github.com/golang/mock v1.2.0 h1:28o5sBqPkBsMGnC6b4MvE2TzSr5/AT4c/1fLqVGIwlk=
 github.com/golang/mock v1.2.0/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
+github.com/golang/mock v1.3.1/go.mod h1:sBzyDLLjw3U8JLTeZvSv8jJB+tU5PVekmnlKIyFUx0Y=
+github.com/golang/mock v1.4.0/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw=
+github.com/golang/mock v1.4.4 h1:l75CXGRSwbaYNpl/Z2X1XIIAMSCquvXgpVZDhwEIJsc=
+github.com/golang/mock v1.4.4/go.mod h1:l3mdAwkq5BuhzHwde/uurv3sEJeZMXNpwsxVWU71h+4=
 github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
 github.com/golang/protobuf v1.3.0/go.mod h1:Qd/q+1AKNOZr9uGQzbzCmRO6sUih6GTPZv6a1/R87v0=
-github.com/golang/protobuf v1.3.1 h1:YF8+flBXS5eO826T4nzqPrxfhQThhXl0YzfuUPu4SBg=
 github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.3.3/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=
+github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8=
+github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA=
+github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs=
+github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w=
+github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0=
+github.com/golang/protobuf v1.4.1/go.mod h1:U8fpvMrcmy5pZrNK1lt4xCsGvpyWQ/VVv6QDs8UjoX8=
+github.com/golang/protobuf v1.4.2 h1:+Z5KGCizgyZCbGh1KZqA0fcLLkwbsjIzS4aV2v7wJX0=
+github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
 github.com/golang/snappy v0.0.0-20180518054509-2e65f85255db/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
+github.com/golang/snappy v0.0.1 h1:Qgr9rKW7uDUkrbSmQeiDsGa8SjGyCOGtuasMWwvp2P4=
+github.com/golang/snappy v0.0.1/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
+github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
+github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
 github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
 github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
-github.com/google/go-cmp v0.3.1 h1:Xye71clBPdm5HgqGwUkwhbynsUJZhDbS20FvLhQ2izg=
 github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
+github.com/google/go-cmp v0.4.0 h1:xsAVV57WRhGj6kEIi8ReJzQlHHqcBYCElAvkovg3B/4=
+github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-github v17.0.0+incompatible/go.mod h1:zLgOLi98H3fifZn+44m+umXrS52loVEgC2AApnigrVQ=
+github.com/google/go-querystring v1.0.0/go.mod h1:odCYkC5MyYFN7vkCjXpyrEuKhc/BUO6wN/zVPAxq5ck=
+github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
+github.com/google/gopacket v1.1.17/go.mod h1:UdDNZ1OO62aGYVnPhxT1U6aI7ukYtA/kB8vaU0diBUM=
+github.com/google/gopacket v1.1.18 h1:lum7VRA9kdlvBi7/v2p7/zcbkduHaCH/SVVyurs7OpY=
+github.com/google/gopacket v1.1.18/go.mod h1:UdDNZ1OO62aGYVnPhxT1U6aI7ukYtA/kB8vaU0diBUM=
+github.com/google/martian v2.1.0+incompatible/go.mod h1:9I4somxYTbIHy5NJKHRl3wXiIaQGbYVAs8BPL6v8lEs=
+github.com/google/pprof v0.0.0-20181206194817-3ea8567a2e57/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc=
+github.com/google/pprof v0.0.0-20190515194954-54271f7e092f/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc=
+github.com/google/pprof v0.0.0-20200212024743-f11f1df84d12/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
 github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI=
+github.com/google/uuid v1.0.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/google/uuid v1.1.1 h1:Gkbcsh/GbpXz7lPftLA3P6TYMwjCLYm83jiFQZF/3gY=
 github.com/google/uuid v1.1.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/googleapis/gax-go v2.0.0+incompatible/go.mod h1:SFVmujtThgffbyetf+mdk2eWhX2bMyUtNHzFKcPA9HY=
+github.com/googleapis/gax-go/v2 v2.0.3/go.mod h1:LLvjysVCY1JZeum8Z6l8qUty8fiNwE08qbEPm1M08qg=
+github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg=
+github.com/googleapis/gax-go/v2 v2.0.5/go.mod h1:DWXyrwAJ9X0FpwwEdw+IPEYBICEFu5mhpdKc/us6bOk=
 github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY=
 github.com/gopherjs/gopherjs v0.0.0-20190430165422-3e4dfb77656c/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY=
 github.com/gopherjs/gopherjs v0.0.0-20190812055157-5d271430af9f h1:KMlcu9X58lhTA/KrfX8Bi1LQSO4pzoVjTiL3h4Jk+Zk=
 github.com/gopherjs/gopherjs v0.0.0-20190812055157-5d271430af9f/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY=
 github.com/gorilla/context v1.1.1/go.mod h1:kBGZzfjB9CEq2AlWe17Uuf7NDRt0dE0s8S51q0aT7Yg=
+github.com/gorilla/handlers v1.4.2/go.mod h1:Qkdc/uu4tH4g6mTK6auzZ766c4CA0Ng8+o/OAirnOIQ=
 github.com/gorilla/mux v1.6.2/go.mod h1:1lud6UwP+6orDFRuTfBEV8e9/aOM/c4fVVCaMa2zaAs=
-github.com/gorilla/mux v1.7.3 h1:gnP5JzjVOuiZD07fKKToCAOjS0yOpj/qPETTXCCS6hw=
 github.com/gorilla/mux v1.7.3/go.mod h1:1lud6UwP+6orDFRuTfBEV8e9/aOM/c4fVVCaMa2zaAs=
+github.com/gorilla/mux v1.7.4 h1:VuZ8uybHlWmqV03+zRzdwKL4tUnIp1MAQtp1mIFE1bc=
+github.com/gorilla/mux v1.7.4/go.mod h1:DVbg23sWSpFRCP0SfiEN6jmj59UnW/n46BH5rLB71So=
+github.com/gorilla/websocket v0.0.0-20170926233335-4201258b820c/go.mod h1:E7qHFY5m1UJ88s3WnNqhKjPHQ0heANvMoAMk2YaljkQ=
 github.com/gorilla/websocket v1.4.0/go.mod h1:E7qHFY5m1UJ88s3WnNqhKjPHQ0heANvMoAMk2YaljkQ=
-github.com/gorilla/websocket v1.4.1 h1:q7AeDBpnBk8AogcD4DSag/Ukw/KV+YhzLj2bP5HvKCM=
 github.com/gorilla/websocket v1.4.1/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
+github.com/gorilla/websocket v1.4.2 h1:+/TMaTYc4QFitKJxsQ7Yye35DkWvkdLcvGKqM+x0Ufc=
+github.com/gorilla/websocket v1.4.2/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
+github.com/gregjones/httpcache v0.0.0-20180305231024-9cad4c3443a7/go.mod h1:FecbI9+v66THATjSRHfNgh1IVFe/9kFxbXtjV0ctIMA=
+github.com/grpc-ecosystem/go-grpc-middleware v1.0.1-0.20190118093823-f849b5445de4/go.mod h1:FiyG127CGDf3tlThmgyCl78X/SZQqEOJBCDaAfeWzPs=
+github.com/grpc-ecosystem/go-grpc-middleware v1.1.0/go.mod h1:f5nM7jw/oeRSadq3xCzHAvxcr8HZnzsqU6ILg/0NiiE=
+github.com/grpc-ecosystem/go-grpc-middleware v1.2.0 h1:0IKlLyQ3Hs9nDaiK5cSHAGmcQEIC8l2Ts1u6x5Dfrqg=
+github.com/grpc-ecosystem/go-grpc-middleware v1.2.0/go.mod h1:mJzapYve32yjrKlk9GbyCZHuPgZsrbyIbyKhSzOpg6s=
+github.com/grpc-ecosystem/go-grpc-prometheus v1.2.0 h1:Ovs26xHkKqVztRpIrF/92BcuyuQ/YW4NSIpoGtfXNho=
+github.com/grpc-ecosystem/go-grpc-prometheus v1.2.0/go.mod h1:8NvIoxWQoOIhqOTXgfV/d3M/q6VIi02HzZEHgUlZvzk=
+github.com/grpc-ecosystem/grpc-gateway v1.5.0/go.mod h1:RSKVYQBd5MCa4OVpNdGskqpgL2+G+NZTnrVHpWWfpdw=
+github.com/grpc-ecosystem/grpc-gateway v1.9.5/go.mod h1:vNeuVxBJEsws4ogUvrchl83t/GYV9WGTSLVdBhOQFDY=
+github.com/grpc-ecosystem/grpc-gateway v1.14.6 h1:8ERzHx8aj1Sc47mu9n/AksaKCSWrMchFtkdrS4BIj5o=
+github.com/grpc-ecosystem/grpc-gateway v1.14.6/go.mod h1:zdiPV4Yse/1gnckTHtghG4GkDEdKCRJduHpTxT3/jcw=
+github.com/grpc-ecosystem/grpc-opentracing v0.0.0-20180507213350-8e809c8a8645/go.mod h1:6iZfnjpejD4L/4DwD7NryNaJyCQdzwWwH2MWhCA90Kw=
+github.com/gxed/go-shellwords v1.0.3/go.mod h1:N7paucT91ByIjmVJHhvoarjoQnmsi3Jd3vH7VqgtMxQ=
 github.com/gxed/hashland/keccakpg v0.0.1/go.mod h1:kRzw3HkwxFU1mpmPP8v1WyQzwdGfmKFJ6tItnhQ67kU=
 github.com/gxed/hashland/murmur3 v0.0.1/go.mod h1:KjXop02n4/ckmZSnY2+HKcLud/tcmvhST0bie/0lS48=
 github.com/gxed/pubsub v0.0.0-20180201040156-26ebdf44f824/go.mod h1:OiEWyHgK+CWrmOlVquHaIK1vhpUJydC9m0Je6mhaiNE=
+github.com/hannahhoward/cbor-gen-for v0.0.0-20200817222906-ea96cece81f1 h1:F9k+7wv5OIk1zcq23QpdiL0hfDuXPjuOmMNaC6fgQ0Q=
+github.com/hannahhoward/cbor-gen-for v0.0.0-20200817222906-ea96cece81f1/go.mod h1:jvfsLIxk0fY/2BKSQ1xf2406AKA5dwMmKKv0ADcOfN8=
+github.com/hannahhoward/go-pubsub v0.0.0-20200423002714-8d62886cc36e h1:3YKHER4nmd7b5qy5t0GWDTwSn4OyRgfAXSmo6VnryBY=
+github.com/hannahhoward/go-pubsub v0.0.0-20200423002714-8d62886cc36e/go.mod h1:I8h3MITA53gN9OnWGCgaMa0JWVRdXthWw4M3CPM54OY=
+github.com/hashicorp/consul/api v1.3.0/go.mod h1:MmDNSzIMUjNpY/mQ398R4bk2FnqQLoPndWW5VkKPlCE=
+github.com/hashicorp/consul/sdk v0.3.0/go.mod h1:VKf9jXwCTEY1QZP2MOLRhb5i/I/ssyNV1vwHyQBF0x8=
 github.com/hashicorp/errwrap v1.0.0 h1:hLrqtEDnRye3+sgx6z4qVLNuviH3MR5aQ0ykNJa/UYA=
 github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4=
-github.com/hashicorp/go-multierror v1.0.0 h1:iVjPR7a6H0tWELX5NxNe7bYopibicUzc7uPribsnS6o=
+github.com/hashicorp/go-cleanhttp v0.5.1/go.mod h1:JpRdi6/HCYpAwUzNwuwqhbovhLtngrth3wmdIIUrZ80=
+github.com/hashicorp/go-immutable-radix v1.0.0/go.mod h1:0y9vanUI8NX6FsYoO3zeMjhV/C5i9g4Q3DwcSNZ4P60=
+github.com/hashicorp/go-msgpack v0.5.3/go.mod h1:ahLV/dePpqEmjfWmKiqvPkv/twdG7iPBM1vqhUKIvfM=
 github.com/hashicorp/go-multierror v1.0.0/go.mod h1:dHtQlpGsu+cZNNAkkCN/P3hoUDHhCYQXV3UM06sGGrk=
+github.com/hashicorp/go-multierror v1.1.0 h1:B9UzwGQJehnUY1yNrnwREHc3fGbC2xefo8g4TbElacI=
+github.com/hashicorp/go-multierror v1.1.0/go.mod h1:spPvp8C1qA32ftKqdAHm4hHTbPw+vmowP0z+KUhOZdA=
+github.com/hashicorp/go-rootcerts v1.0.0/go.mod h1:K6zTfqpRlCUIjkwsN4Z+hiSfzSTQa6eBIzfwKfwNnHU=
+github.com/hashicorp/go-sockaddr v1.0.0/go.mod h1:7Xibr9yA9JjQq1JpNB2Vw7kxv8xerXegt+ozgdvDeDU=
+github.com/hashicorp/go-syslog v1.0.0/go.mod h1:qPfqrKkXGihmCqbJM2mZgkZGvKG1dFdvsLplgctolz4=
+github.com/hashicorp/go-uuid v1.0.0/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro=
+github.com/hashicorp/go-uuid v1.0.1/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro=
+github.com/hashicorp/go-version v1.2.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA=
+github.com/hashicorp/go.net v0.0.1/go.mod h1:hjKkEWcCURg++eb33jQU7oqQcI9XDCnUzHA0oac0k90=
 github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
 github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
-github.com/hashicorp/golang-lru v0.5.3 h1:YPkqC67at8FYaadspW/6uE0COsBxS2656RLEr8Bppgk=
 github.com/hashicorp/golang-lru v0.5.3/go.mod h1:iADmTwqILo4mZ8BN3D2Q6+9jd8WM5uGBxy+E8yxSoD4=
+github.com/hashicorp/golang-lru v0.5.4 h1:YDjusn29QI/Das2iO9M0BHnIbxPeyuCHsjMW+lJfyTc=
+github.com/hashicorp/golang-lru v0.5.4/go.mod h1:iADmTwqILo4mZ8BN3D2Q6+9jd8WM5uGBxy+E8yxSoD4=
 github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ=
-github.com/hpcloud/tail v1.0.0 h1:nfCOvKYfkgYP8hkirhJocXT2+zOD8yUNjXaWfTlyFKI=
+github.com/hashicorp/logutils v1.0.0/go.mod h1:QIAnNjmIWmVIIkWDTG1z5v++HQmx9WQRO+LraFDTW64=
+github.com/hashicorp/mdns v1.0.0/go.mod h1:tL+uN++7HEJ6SQLQ2/p+z2pH24WQKWjBPkE0mNTz8vQ=
+github.com/hashicorp/memberlist v0.1.3/go.mod h1:ajVTdAv/9Im8oMAAj5G31PhhMCZJV2pPBoIllUwCN7I=
+github.com/hashicorp/serf v0.8.2/go.mod h1:6hOLApaqBFA1NXqRQAsxw9QxuDEvNxSQRwA/JwenrHc=
+github.com/hodgesds/perf-utils v0.0.8/go.mod h1:F6TfvsbtrF88i++hou29dTXlI2sfsJv+gRZDtmTJkAs=
 github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
+github.com/hudl/fargo v1.3.0/go.mod h1:y3CKSmjA+wD2gak7sUSXTAoopbhU08POFhmITJgmKTg=
 github.com/huin/goupnp v0.0.0-20180415215157-1395d1447324/go.mod h1:MZ2ZmwcBpvOoJ22IJsc7va19ZwoheaBk43rKg12SKag=
 github.com/huin/goupnp v1.0.0 h1:wg75sLpL6DZqwHQN6E1Cfk6mtfzS45z8OV+ic+DtHRo=
 github.com/huin/goupnp v1.0.0/go.mod h1:n9v9KO1tAxYH82qOn+UTIFQDmx5n1Zxd/ClZDMX7Bnc=
 github.com/huin/goutil v0.0.0-20170803182201-1ca381bf3150/go.mod h1:PpLOETDnJ0o3iZrZfqZzyLl6l7F3c6L1oWn7OICBi6o=
+github.com/ianlancetaylor/demangle v0.0.0-20181102032728-5e5cf60278f6/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc=
 github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8=
-github.com/influxdata/influxdb1-client v0.0.0-20190809212627-fc22c7df067e h1:txQltCyjXAqVVSZDArPEhUTg35hKwVIuXwtQo7eAMNQ=
-github.com/influxdata/influxdb1-client v0.0.0-20190809212627-fc22c7df067e/go.mod h1:qj24IKcXYK6Iy9ceXlo3Tc+vtHo9lIhSX5JddghvEPo=
+github.com/influxdata/influxdb1-client v0.0.0-20191209144304-8bf82d3c094d h1:/WZQPMZNsjZ7IlCpsLGdQBINg5bxKQ1K1sh6awxLtkA=
+github.com/influxdata/influxdb1-client v0.0.0-20191209144304-8bf82d3c094d/go.mod h1:qj24IKcXYK6Iy9ceXlo3Tc+vtHo9lIhSX5JddghvEPo=
 github.com/ipfs/bbloom v0.0.1/go.mod h1:oqo8CVWsJFMOZqTglBG4wydCE4IQA/G2/SEofB0rjUI=
 github.com/ipfs/bbloom v0.0.4 h1:Gi+8EGJ2y5qiD5FbsbpX/TMNcJw8gSqr7eyjHa4Fhvs=
 github.com/ipfs/bbloom v0.0.4/go.mod h1:cS9YprKXpoZ9lT0n/Mw/a6/aFV6DTjTLYHeA+gyqMG0=
+github.com/ipfs/go-bitswap v0.0.3/go.mod h1:jadAZYsP/tcRMl47ZhFxhaNuDQoXawT8iHMg+iFoQbg=
 github.com/ipfs/go-bitswap v0.0.9/go.mod h1:kAPf5qgn2W2DrgAcscZ3HrM9qh4pH+X8Fkk3UPrwvis=
 github.com/ipfs/go-bitswap v0.1.0/go.mod h1:FFJEf18E9izuCqUtHxbWEvq+reg7o4CW5wSAE1wsxj0=
 github.com/ipfs/go-bitswap v0.1.2/go.mod h1:qxSWS4NXGs7jQ6zQvoPY3+NmOfHHG47mhkiLzBpJQIs=
-github.com/ipfs/go-bitswap v0.1.3/go.mod h1:YEQlFy0kkxops5Vy+OxWdRSEZIoS7I7KDIwoa5Chkps=
-github.com/ipfs/go-bitswap v0.1.8 h1:38X1mKXkiU6Nzw4TOSWD8eTVY5eX3slQunv3QEWfXKg=
 github.com/ipfs/go-bitswap v0.1.8/go.mod h1:TOWoxllhccevbWFUR2N7B1MTSVVge1s6XSMiCSA4MzM=
+github.com/ipfs/go-bitswap v0.2.20 h1:Zfi5jDUoqxDThORUznqdeL77DdGniAzlccNJ4vr+Itc=
+github.com/ipfs/go-bitswap v0.2.20/go.mod h1:C7TwBgHnu89Q8sHsTJP7IhUqF9XYLe71P4tT5adgmYo=
 github.com/ipfs/go-block-format v0.0.1/go.mod h1:DK/YYcsSUIVAFNwo/KZCdIIbpN0ROH/baNLgayt4pFc=
 github.com/ipfs/go-block-format v0.0.2 h1:qPDvcP19izTjU8rgo6p7gTXZlkMkF5bz5G3fqIsSCPE=
 github.com/ipfs/go-block-format v0.0.2/go.mod h1:AWR46JfpcObNfg3ok2JHDUfdiHRgWhJgCQF+KIgOPJY=
+github.com/ipfs/go-blockservice v0.0.3/go.mod h1:/NNihwTi6V2Yr6g8wBI+BSwPuURpBRMtYNGrlxZ8KuI=
 github.com/ipfs/go-blockservice v0.0.7/go.mod h1:EOfb9k/Y878ZTRY/CH0x5+ATtaipfbRhbvNSdgc/7So=
 github.com/ipfs/go-blockservice v0.1.0/go.mod h1:hzmMScl1kXHg3M2BjTymbVPjv627N7sYcvYaKbop39M=
-github.com/ipfs/go-blockservice v0.1.3-0.20190908200855-f22eea50656c h1:lN5IQA07VtLiTLAp/Scezp1ljFhXErC6yq4O1cu+yJ0=
-github.com/ipfs/go-blockservice v0.1.3-0.20190908200855-f22eea50656c/go.mod h1:t+411r7psEUhLueM8C7aPA7cxCclv4O3VsUVxt9kz2I=
-github.com/ipfs/go-car v0.0.2 h1:j02lzgeijorstzoMl3nQmvvb8wjJUVCiOAl8XEwYMCQ=
-github.com/ipfs/go-car v0.0.2/go.mod h1:60pzeu308k5kVFHzq0HIi2kPtITgor+1ll1xuGk5JwQ=
+github.com/ipfs/go-blockservice v0.1.3/go.mod h1:OTZhFpkgY48kNzbgyvcexW9cHrpjBYIjSR0KoDOFOLU=
+github.com/ipfs/go-blockservice v0.1.4-0.20200624145336-a978cec6e834 h1:hFJoI1D2a3MqiNkSb4nKwrdkhCngUxUTFNwVwovZX2s=
+github.com/ipfs/go-blockservice v0.1.4-0.20200624145336-a978cec6e834/go.mod h1:OTZhFpkgY48kNzbgyvcexW9cHrpjBYIjSR0KoDOFOLU=
 github.com/ipfs/go-cid v0.0.1/go.mod h1:GHWU/WuQdMPmIosc4Yn1bcCT7dSeX4lBafM7iqUPQvM=
 github.com/ipfs/go-cid v0.0.2/go.mod h1:GHWU/WuQdMPmIosc4Yn1bcCT7dSeX4lBafM7iqUPQvM=
 github.com/ipfs/go-cid v0.0.3/go.mod h1:GHWU/WuQdMPmIosc4Yn1bcCT7dSeX4lBafM7iqUPQvM=
 github.com/ipfs/go-cid v0.0.4-0.20191112011718-79e75dffeb10/go.mod h1:/BYOuUoxkE+0f6tGzlzMvycuN+5l35VOR4Bpg2sCmds=
-github.com/ipfs/go-cid v0.0.4 h1:UlfXKrZx1DjZoBhQHmNHLC1fK1dUJDN20Y28A7s+gJ8=
 github.com/ipfs/go-cid v0.0.4/go.mod h1:4LLaPOQwmk5z9LBgQnpkivrx8BJjUyGwTXCd5Xfj6+M=
+github.com/ipfs/go-cid v0.0.5/go.mod h1:plgt+Y5MnOey4vO4UlUazGqdbEXuFYitED67FexhXog=
+github.com/ipfs/go-cid v0.0.6-0.20200501230655-7c82f3b81c00/go.mod h1:plgt+Y5MnOey4vO4UlUazGqdbEXuFYitED67FexhXog=
+github.com/ipfs/go-cid v0.0.6/go.mod h1:6Ux9z5e+HpkQdckYoX1PG/6xqKspzlEIR5SDmgqgC/I=
+github.com/ipfs/go-cid v0.0.7 h1:ysQJVJA3fNDF1qigJbsSQOdjhVLsOEoPdh0+R97k3jY=
+github.com/ipfs/go-cid v0.0.7/go.mod h1:6Ux9z5e+HpkQdckYoX1PG/6xqKspzlEIR5SDmgqgC/I=
+github.com/ipfs/go-cidutil v0.0.2 h1:CNOboQf1t7Qp0nuNh8QMmhJs0+Q//bRL1axtCnIB1Yo=
+github.com/ipfs/go-cidutil v0.0.2/go.mod h1:ewllrvrxG6AMYStla3GD7Cqn+XYSLqjK0vc+086tB6s=
 github.com/ipfs/go-datastore v0.0.1/go.mod h1:d4KVXhMt913cLBEI/PXAy6ko+W7e9AhyAKBGh803qeE=
 github.com/ipfs/go-datastore v0.0.5/go.mod h1:d4KVXhMt913cLBEI/PXAy6ko+W7e9AhyAKBGh803qeE=
 github.com/ipfs/go-datastore v0.1.0/go.mod h1:d4KVXhMt913cLBEI/PXAy6ko+W7e9AhyAKBGh803qeE=
-github.com/ipfs/go-datastore v0.1.1 h1:F4k0TkTAZGLFzBOrVKDAvch6JZtuN4NHkfdcEZL50aI=
 github.com/ipfs/go-datastore v0.1.1/go.mod h1:w38XXW9kVFNp57Zj5knbKWM2T+KOZCGDRVNdgPHtbHw=
+github.com/ipfs/go-datastore v0.3.0/go.mod h1:w38XXW9kVFNp57Zj5knbKWM2T+KOZCGDRVNdgPHtbHw=
+github.com/ipfs/go-datastore v0.3.1/go.mod h1:w38XXW9kVFNp57Zj5knbKWM2T+KOZCGDRVNdgPHtbHw=
+github.com/ipfs/go-datastore v0.4.0/go.mod h1:SX/xMIKoCszPqp+z9JhPYCmoOoXTvaa13XEbGtsFUhA=
+github.com/ipfs/go-datastore v0.4.1/go.mod h1:SX/xMIKoCszPqp+z9JhPYCmoOoXTvaa13XEbGtsFUhA=
+github.com/ipfs/go-datastore v0.4.2/go.mod h1:SX/xMIKoCszPqp+z9JhPYCmoOoXTvaa13XEbGtsFUhA=
+github.com/ipfs/go-datastore v0.4.4 h1:rjvQ9+muFaJ+QZ7dN5B1MSDNQ0JVZKkkES/rMZmA8X8=
+github.com/ipfs/go-datastore v0.4.4/go.mod h1:SX/xMIKoCszPqp+z9JhPYCmoOoXTvaa13XEbGtsFUhA=
 github.com/ipfs/go-detect-race v0.0.1 h1:qX/xay2W3E4Q1U7d9lNs1sU9nvguX0a7319XbyQ6cOk=
 github.com/ipfs/go-detect-race v0.0.1/go.mod h1:8BNT7shDZPo99Q74BpGMK+4D8Mn4j46UU0LZ723meps=
 github.com/ipfs/go-ds-badger v0.0.2/go.mod h1:Y3QpeSFWQf6MopLTiZD+VT6IC1yZqaGmjvRcKeSGij8=
 github.com/ipfs/go-ds-badger v0.0.5/go.mod h1:g5AuuCGmr7efyzQhLL8MzwqcauPojGPUaHzfGTzuE3s=
-github.com/ipfs/go-ds-badger v0.0.7 h1:NMyh88Q50HG6/S2YD58DLkq0c0/ZQPMbSojONH+PRf4=
 github.com/ipfs/go-ds-badger v0.0.7/go.mod h1:qt0/fWzZDoPW6jpQeqUjR5kBfhDNB65jd9YlmAvpQBk=
+github.com/ipfs/go-ds-badger v0.2.1/go.mod h1:Tx7l3aTph3FMFrRS838dcSJh+jjA7cX9DrGVwx/NOwE=
+github.com/ipfs/go-ds-badger v0.2.3 h1:J27YvAcpuA5IvZUbeBxOcQgqnYHUPxoygc6QxxkodZ4=
+github.com/ipfs/go-ds-badger v0.2.3/go.mod h1:pEYw0rgg3FIrywKKnL+Snr+w/LjJZVMTBRn4FS6UHUk=
+github.com/ipfs/go-ds-badger2 v0.1.0/go.mod h1:pbR1p817OZbdId9EvLOhKBgUVTM3BMCSTan78lDDVaw=
+github.com/ipfs/go-ds-badger2 v0.1.1-0.20200708190120-187fc06f714e h1:Xi1nil8K2lBOorBS6Ys7+hmUCzH8fr3U9ipdL/IrcEI=
+github.com/ipfs/go-ds-badger2 v0.1.1-0.20200708190120-187fc06f714e/go.mod h1:lJnws7amT9Ehqzta0gwMrRsURU04caT0iRPr1W8AsOU=
 github.com/ipfs/go-ds-leveldb v0.0.1/go.mod h1:feO8V3kubwsEF22n0YRQCffeb79OOYIykR4L04tMOYc=
 github.com/ipfs/go-ds-leveldb v0.1.0/go.mod h1:hqAW8y4bwX5LWcCtku2rFNX3vjDZCy5LZCg+cSZvYb8=
-github.com/ipfs/go-filestore v0.0.2 h1:pcYwpjtXXwirtbjBXKVJM9CTa9F7/8v1EkfnDaHTO3s=
-github.com/ipfs/go-filestore v0.0.2/go.mod h1:KnZ41qJsCt2OX2mxZS0xsK3Psr0/oB93HMMssLujjVc=
-github.com/ipfs/go-fs-lock v0.0.1 h1:XHX8uW4jQBYWHj59XXcjg7BHlHxV9ZOYs6Y43yb7/l0=
-github.com/ipfs/go-fs-lock v0.0.1/go.mod h1:DNBekbboPKcxs1aukPSaOtFA3QfSdi5C855v0i9XJ8Y=
-github.com/ipfs/go-hamt-ipld v0.0.14-0.20191218031521-b2c774a54db1 h1:0xpCaaXvN8bPyws3ObiCn7G0KIfgbS9E132eL57dHx8=
-github.com/ipfs/go-hamt-ipld v0.0.14-0.20191218031521-b2c774a54db1/go.mod h1:8yRx0xLUps1Xq8ZDnIwIVdQRp7JjA55gGvCiRHT91Vk=
+github.com/ipfs/go-ds-leveldb v0.4.1/go.mod h1:jpbku/YqBSsBc1qgME8BkWS4AxzF2cEu1Ii2r79Hh9s=
+github.com/ipfs/go-ds-leveldb v0.4.2 h1:QmQoAJ9WkPMUfBLnu1sBVy0xWWlJPg0m4kRAiJL9iaw=
+github.com/ipfs/go-ds-leveldb v0.4.2/go.mod h1:jpbku/YqBSsBc1qgME8BkWS4AxzF2cEu1Ii2r79Hh9s=
+github.com/ipfs/go-ds-measure v0.1.0 h1:vE4TyY4aeLeVgnnPBC5QzKIjKrqzha0NCujTfgvVbVQ=
+github.com/ipfs/go-ds-measure v0.1.0/go.mod h1:1nDiFrhLlwArTME1Ees2XaBOl49OoCgd2A3f8EchMSY=
+github.com/ipfs/go-filestore v1.0.0 h1:QR7ekKH+q2AGiWDc7W2Q0qHuYSRZGUJqUn0GsegEPb0=
+github.com/ipfs/go-filestore v1.0.0/go.mod h1:/XOCuNtIe2f1YPbiXdYvD0BKLA0JR1MgPiFOdcuu9SM=
+github.com/ipfs/go-fs-lock v0.0.6 h1:sn3TWwNVQqSeNjlWy6zQ1uUGAZrV3hPOyEA6y1/N2a0=
+github.com/ipfs/go-fs-lock v0.0.6/go.mod h1:OTR+Rj9sHiRubJh3dRhD15Juhd/+w6VPOY28L7zESmM=
+github.com/ipfs/go-graphsync v0.1.0/go.mod h1:jMXfqIEDFukLPZHqDPp8tJMbHO9Rmeb9CEGevngQbmE=
+github.com/ipfs/go-graphsync v0.2.1 h1:MdehhqBSuTI2LARfKLkpYnt0mUrqHs/mtuDnESXHBfU=
+github.com/ipfs/go-graphsync v0.2.1/go.mod h1:gEBvJUNelzMkaRPJTpg/jaKN4AQW/7wDWu0K92D8o10=
+github.com/ipfs/go-hamt-ipld v0.1.1/go.mod h1:1EZCr2v0jlCnhpa+aZ0JZYp8Tt2w16+JJOAVz17YcDk=
 github.com/ipfs/go-ipfs-blockstore v0.0.1/go.mod h1:d3WClOmRQKFnJ0Jz/jj/zmksX0ma1gROTlovZKBmN08=
 github.com/ipfs/go-ipfs-blockstore v0.1.0/go.mod h1:5aD0AvHPi7mZc6Ci1WCAhiBQu2IsfTduLl+422H6Rqw=
-github.com/ipfs/go-ipfs-blockstore v0.1.1 h1:+PAFREAlSxLs9IEtrRcnJ/DqWkGlDa+l547WFZnohNw=
-github.com/ipfs/go-ipfs-blockstore v0.1.1/go.mod h1:8gZOgIN5e+Xdg2YSGdwTTRbguSVjYyosIDRQCY8E9QM=
+github.com/ipfs/go-ipfs-blockstore v0.1.4/go.mod h1:Jxm3XMVjh6R17WvxFEiyKBLUGr86HgIYJW/D/MwqeYQ=
+github.com/ipfs/go-ipfs-blockstore v1.0.0/go.mod h1:knLVdhVU9L7CC4T+T4nvGdeUIPAXlnd9zmXfp+9MIjU=
+github.com/ipfs/go-ipfs-blockstore v1.0.1 h1:fnuVj4XdZp4yExhd0CnUwAiMNJHiPnfInhiuwz4lW1w=
+github.com/ipfs/go-ipfs-blockstore v1.0.1/go.mod h1:MGNZlHNEnR4KGgPHM3/k8lBySIOK2Ve+0KjZubKlaOE=
 github.com/ipfs/go-ipfs-blocksutil v0.0.1 h1:Eh/H4pc1hsvhzsQoMEP3Bke/aW5P5rVM1IWFJMcGIPQ=
 github.com/ipfs/go-ipfs-blocksutil v0.0.1/go.mod h1:Yq4M86uIOmxmGPUHv/uI7uKqZNtLb449gwKqXjIsnRk=
-github.com/ipfs/go-ipfs-chunker v0.0.1 h1:cHUUxKFQ99pozdahi+uSC/3Y6HeRpi9oTeUHbE27SEw=
 github.com/ipfs/go-ipfs-chunker v0.0.1/go.mod h1:tWewYK0we3+rMbOh7pPFGDyypCtvGcBFymgY4rSDLAw=
+github.com/ipfs/go-ipfs-chunker v0.0.5 h1:ojCf7HV/m+uS2vhUGWcogIIxiO5ubl5O57Q7NapWLY8=
+github.com/ipfs/go-ipfs-chunker v0.0.5/go.mod h1:jhgdF8vxRHycr00k13FM8Y0E+6BoalYeobXmUyTreP8=
+github.com/ipfs/go-ipfs-cmds v0.1.0 h1:0CEde9EcxByej8+L6d1PST57J4ambRPyCTjLG5Ymou8=
+github.com/ipfs/go-ipfs-cmds v0.1.0/go.mod h1:TiK4e7/V31tuEb8YWDF8lN3qrnDH+BS7ZqWIeYJlAs8=
+github.com/ipfs/go-ipfs-config v0.0.11 h1:5/4nas2CQXiKr2/MLxU24GDGTBvtstQIQezuk7ltOQQ=
+github.com/ipfs/go-ipfs-config v0.0.11/go.mod h1:wveA8UT5ywN26oKStByzmz1CO6cXwLKKM6Jn/Hfw08I=
 github.com/ipfs/go-ipfs-delay v0.0.0-20181109222059-70721b86a9a8/go.mod h1:8SP1YXK1M1kXuc4KJZINY3TQQ03J2rwBG9QfXmbRPrw=
 github.com/ipfs/go-ipfs-delay v0.0.1 h1:r/UXYyRcddO6thwOnhiznIAiSvxMECGgtv35Xs1IeRQ=
 github.com/ipfs/go-ipfs-delay v0.0.1/go.mod h1:8SP1YXK1M1kXuc4KJZINY3TQQ03J2rwBG9QfXmbRPrw=
-github.com/ipfs/go-ipfs-ds-help v0.0.1 h1:QBg+Ts2zgeemK/dB0saiF/ykzRGgfoFMT90Rzo0OnVU=
 github.com/ipfs/go-ipfs-ds-help v0.0.1/go.mod h1:gtP9xRaZXqIQRh1HRpp595KbBEdgqWFxefeVKOV8sxo=
+github.com/ipfs/go-ipfs-ds-help v0.1.1/go.mod h1:SbBafGJuGsPI/QL3j9Fc5YPLeAu+SzOkI0gFwAg+mOs=
+github.com/ipfs/go-ipfs-ds-help v1.0.0 h1:bEQ8hMGs80h0sR8O4tfDgV6B01aaF9qeTrujrTLYV3g=
+github.com/ipfs/go-ipfs-ds-help v1.0.0/go.mod h1:ujAbkeIgkKAWtxxNkoZHWLCyk5JpPoKnGyCcsoF6ueE=
 github.com/ipfs/go-ipfs-exchange-interface v0.0.1 h1:LJXIo9W7CAmugqI+uofioIpRb6rY30GUu7G6LUfpMvM=
 github.com/ipfs/go-ipfs-exchange-interface v0.0.1/go.mod h1:c8MwfHjtQjPoDyiy9cFquVtVHkO9b9Ob3FG91qJnWCM=
 github.com/ipfs/go-ipfs-exchange-offline v0.0.1 h1:P56jYKZF7lDDOLx5SotVh5KFxoY6C81I1NSHW1FxGew=
 github.com/ipfs/go-ipfs-exchange-offline v0.0.1/go.mod h1:WhHSFCVYX36H/anEKQboAzpUws3x7UeEGkzQc3iNkM0=
+github.com/ipfs/go-ipfs-files v0.0.2/go.mod h1:INEFm0LL2LWXBhNJ2PMIIb2w45hpXgPjNoE7yA8Y1d4=
 github.com/ipfs/go-ipfs-files v0.0.3/go.mod h1:INEFm0LL2LWXBhNJ2PMIIb2w45hpXgPjNoE7yA8Y1d4=
-github.com/ipfs/go-ipfs-files v0.0.4 h1:WzRCivcybUQch/Qh6v8LBRhKtRsjnwyiuOV09mK7mrE=
 github.com/ipfs/go-ipfs-files v0.0.4/go.mod h1:INEFm0LL2LWXBhNJ2PMIIb2w45hpXgPjNoE7yA8Y1d4=
+github.com/ipfs/go-ipfs-files v0.0.8 h1:8o0oFJkJ8UkO/ABl8T6ac6tKF3+NIpj67aAB6ZpusRg=
+github.com/ipfs/go-ipfs-files v0.0.8/go.mod h1:wiN/jSG8FKyk7N0WyctKSvq3ljIa2NNTiZB55kpTdOs=
 github.com/ipfs/go-ipfs-flags v0.0.1/go.mod h1:RnXBb9WV53GSfTrSDVK61NLTFKvWc60n+K9EgCDh+rA=
+github.com/ipfs/go-ipfs-http-client v0.0.5 h1:niW5M0qqa0O/VRCAzr3f5Y7i3MjTpf0lhpkisjRtHR8=
+github.com/ipfs/go-ipfs-http-client v0.0.5/go.mod h1:8EKP9RGUrUex4Ff86WhnKU7seEBOtjdgXlY9XHYvYMw=
 github.com/ipfs/go-ipfs-posinfo v0.0.1 h1:Esoxj+1JgSjX0+ylc0hUmJCOv6V2vFoZiETLR6OtpRs=
 github.com/ipfs/go-ipfs-posinfo v0.0.1/go.mod h1:SwyeVP+jCwiDu0C313l/8jg6ZxM0qqtlt2a0vILTc1A=
-github.com/ipfs/go-ipfs-pq v0.0.1 h1:zgUotX8dcAB/w/HidJh1zzc1yFq6Vm8J7T2F4itj/RU=
 github.com/ipfs/go-ipfs-pq v0.0.1/go.mod h1:LWIqQpqfRG3fNc5XsnIhz/wQ2XXGyugQwls7BgUmUfY=
+github.com/ipfs/go-ipfs-pq v0.0.2 h1:e1vOOW6MuOwG2lqxcLA+wEn93i/9laCY8sXAw76jFOY=
+github.com/ipfs/go-ipfs-pq v0.0.2/go.mod h1:LWIqQpqfRG3fNc5XsnIhz/wQ2XXGyugQwls7BgUmUfY=
 github.com/ipfs/go-ipfs-routing v0.0.1/go.mod h1:k76lf20iKFxQTjcJokbPM9iBXVXVZhcOwc360N4nuKs=
 github.com/ipfs/go-ipfs-routing v0.1.0 h1:gAJTT1cEeeLj6/DlLX6t+NxD9fQe2ymTO6qWRDI/HQQ=
 github.com/ipfs/go-ipfs-routing v0.1.0/go.mod h1:hYoUkJLyAUKhF58tysKpids8RNDPO42BVMgK5dNsoqY=
-github.com/ipfs/go-ipfs-util v0.0.1 h1:Wz9bL2wB2YBJqggkA4dD7oSmqB4cAnpNbGrlHJulv50=
 github.com/ipfs/go-ipfs-util v0.0.1/go.mod h1:spsl5z8KUnrve+73pOhSVZND1SIxPW5RyBCNzQxlJBc=
+github.com/ipfs/go-ipfs-util v0.0.2 h1:59Sswnk1MFaiq+VcaknX7aYEyGyGDAA73ilhEK2POp8=
+github.com/ipfs/go-ipfs-util v0.0.2/go.mod h1:CbPtkWJzjLdEcezDns2XYaehFVNXG9zrdrtMecczcsQ=
+github.com/ipfs/go-ipld-cbor v0.0.1/go.mod h1:RXHr8s4k0NE0TKhnrxqZC9M888QfsBN9rhS5NjfKzY8=
 github.com/ipfs/go-ipld-cbor v0.0.2/go.mod h1:wTBtrQZA3SoFKMVkp6cn6HMRteIB1VsmHA0AQFOn7Nc=
-github.com/ipfs/go-ipld-cbor v0.0.3 h1:ENsxvybwkmke7Z/QJOmeJfoguj6GH3Y0YOaGrfy9Q0I=
 github.com/ipfs/go-ipld-cbor v0.0.3/go.mod h1:wTBtrQZA3SoFKMVkp6cn6HMRteIB1VsmHA0AQFOn7Nc=
+github.com/ipfs/go-ipld-cbor v0.0.4/go.mod h1:BkCduEx3XBCO6t2Sfo5BaHzuok7hbhdMm9Oh8B2Ftq4=
+github.com/ipfs/go-ipld-cbor v0.0.5-0.20200204214505-252690b78669/go.mod h1:BkCduEx3XBCO6t2Sfo5BaHzuok7hbhdMm9Oh8B2Ftq4=
+github.com/ipfs/go-ipld-cbor v0.0.5-0.20200428170625-a0bd04d3cbdf h1:PRCy+w3GocY77CBEwTprp6hn7PLiEU1YToKe7B+1FVk=
+github.com/ipfs/go-ipld-cbor v0.0.5-0.20200428170625-a0bd04d3cbdf/go.mod h1:BkCduEx3XBCO6t2Sfo5BaHzuok7hbhdMm9Oh8B2Ftq4=
 github.com/ipfs/go-ipld-format v0.0.1/go.mod h1:kyJtbkDALmFHv3QR6et67i35QzO3S0dCDnkOJhcZkms=
-github.com/ipfs/go-ipld-format v0.0.2 h1:OVAGlyYT6JPZ0pEfGntFPS40lfrDmaDbQwNHEY2G9Zs=
 github.com/ipfs/go-ipld-format v0.0.2/go.mod h1:4B6+FM2u9OJ9zCV+kSbgFAZlOrv1Hqbf0INGQgiKf9k=
+github.com/ipfs/go-ipld-format v0.2.0 h1:xGlJKkArkmBvowr+GMCX0FEZtkro71K1AwiKnL37mwA=
+github.com/ipfs/go-ipld-format v0.2.0/go.mod h1:3l3C1uKoadTPbeNfrDi+xMInYKlx2Cvg1BuydPSdzQs=
+github.com/ipfs/go-ipns v0.0.2 h1:oq4ErrV4hNQ2Eim257RTYRgfOSV/s8BDaf9iIl4NwFs=
+github.com/ipfs/go-ipns v0.0.2/go.mod h1:WChil4e0/m9cIINWLxZe1Jtf77oz5L05rO2ei/uKJ5U=
 github.com/ipfs/go-log v0.0.1/go.mod h1:kL1d2/hzSpI0thNYjiKfjanbVNU+IIGA/WnNESY9leM=
-github.com/ipfs/go-log v1.0.0 h1:BW3LQIiZzpNyolt84yvKNCd3FU+AK4VDw1hnHR+1aiI=
 github.com/ipfs/go-log v1.0.0/go.mod h1:JO7RzlMK6rA+CIxFMLOuB6Wf5b81GDiKElL7UPSIKjA=
-github.com/ipfs/go-log v1.0.1 h1:5lIEEOQTk/vd1WuPFBRqz2mcp+5G1fMVcW+Ib/H5Hfo=
 github.com/ipfs/go-log v1.0.1/go.mod h1:HuWlQttfN6FWNHRhlY5yMk/lW7evQC0HHGOxEwMRR8I=
-github.com/ipfs/go-log/v2 v2.0.1 h1:mnR9XFltezAtO8A6tj5U7nKkRzhEQNEw/wT11U2HhPM=
+github.com/ipfs/go-log v1.0.2/go.mod h1:1MNjMxe0u6xvJZgeqbJ8vdo2TKaGwZ1a0Bpza+sr2Sk=
+github.com/ipfs/go-log v1.0.3/go.mod h1:OsLySYkwIbiSUR/yBTdv1qPtcE4FW3WPWk/ewz9Ru+A=
+github.com/ipfs/go-log v1.0.4 h1:6nLQdX4W8P9yZZFH7mO+X/PzjN8Laozm/lMJ6esdgzY=
+github.com/ipfs/go-log v1.0.4/go.mod h1:oDCg2FkjogeFOhqqb+N39l2RpTNPL6F/StPkB3kPgcs=
 github.com/ipfs/go-log/v2 v2.0.1/go.mod h1:O7P1lJt27vWHhOwQmcFEvlmo49ry2VY2+JfBWFaa9+0=
-github.com/ipfs/go-log/v2 v2.0.2 h1:xguurydRdfKMJjKyxNXNU8lYP0VZH1NUwJRwUorjuEw=
 github.com/ipfs/go-log/v2 v2.0.2/go.mod h1:O7P1lJt27vWHhOwQmcFEvlmo49ry2VY2+JfBWFaa9+0=
+github.com/ipfs/go-log/v2 v2.0.3/go.mod h1:O7P1lJt27vWHhOwQmcFEvlmo49ry2VY2+JfBWFaa9+0=
+github.com/ipfs/go-log/v2 v2.0.5/go.mod h1:eZs4Xt4ZUJQFM3DlanGhy7TkwwawCZcSByscwkWG+dw=
+github.com/ipfs/go-log/v2 v2.0.8/go.mod h1:eZs4Xt4ZUJQFM3DlanGhy7TkwwawCZcSByscwkWG+dw=
+github.com/ipfs/go-log/v2 v2.1.1/go.mod h1:2v2nsGfZsvvAJz13SyFzf9ObaqwHiHxsPLEHntrv9KM=
+github.com/ipfs/go-log/v2 v2.1.2-0.20200626104915-0016c0b4b3e4 h1:3bijxqzQ1O9yg7gd7Aqk80oaEvsJ+uXw0zSvi2qR3Jw=
+github.com/ipfs/go-log/v2 v2.1.2-0.20200626104915-0016c0b4b3e4/go.mod h1:2v2nsGfZsvvAJz13SyFzf9ObaqwHiHxsPLEHntrv9KM=
+github.com/ipfs/go-merkledag v0.0.3/go.mod h1:Oc5kIXLHokkE1hWGMBHw+oxehkAaTOqtEb7Zbh6BhLA=
 github.com/ipfs/go-merkledag v0.0.6/go.mod h1:QYPdnlvkOg7GnQRofu9XZimC5ZW5Wi3bKys/4GQQfto=
-github.com/ipfs/go-merkledag v0.1.0/go.mod h1:SQiXrtSts3KGNmgOzMICy5c0POOpUNQLvB3ClKnBAlk=
 github.com/ipfs/go-merkledag v0.2.3/go.mod h1:SQiXrtSts3KGNmgOzMICy5c0POOpUNQLvB3ClKnBAlk=
-github.com/ipfs/go-merkledag v0.2.4 h1:ZSHQSe9BENfixUjT+MaLeHEeZGxrZQfgo3KT3SLosF8=
-github.com/ipfs/go-merkledag v0.2.4/go.mod h1:SQiXrtSts3KGNmgOzMICy5c0POOpUNQLvB3ClKnBAlk=
+github.com/ipfs/go-merkledag v0.3.1/go.mod h1:fvkZNNZixVW6cKSZ/JfLlON5OlgTXNdRLz0p6QG/I2M=
+github.com/ipfs/go-merkledag v0.3.2 h1:MRqj40QkrWkvPswXs4EfSslhZ4RVPRbxwX11js0t1xY=
+github.com/ipfs/go-merkledag v0.3.2/go.mod h1:fvkZNNZixVW6cKSZ/JfLlON5OlgTXNdRLz0p6QG/I2M=
 github.com/ipfs/go-metrics-interface v0.0.1 h1:j+cpbjYvu4R8zbleSs36gvB7jR+wsL2fGD6n0jO4kdg=
 github.com/ipfs/go-metrics-interface v0.0.1/go.mod h1:6s6euYU4zowdslK0GKHmqaIZ3j/b/tL7HTWtJ4VPgWY=
+github.com/ipfs/go-path v0.0.3/go.mod h1:zIRQUez3LuQIU25zFjC2hpBTHimWx7VK5bjZgRLbbdo=
 github.com/ipfs/go-path v0.0.7 h1:H06hKMquQ0aYtHiHryOMLpQC1qC3QwXwkahcEVD51Ho=
 github.com/ipfs/go-path v0.0.7/go.mod h1:6KTKmeRnBXgqrTvzFrPV3CamxcgvXX/4z79tfAd2Sno=
 github.com/ipfs/go-peertaskqueue v0.0.4/go.mod h1:03H8fhyeMfKNFWqzYEVyMbcPUeYrqP1MX6Kd+aN+rMQ=
 github.com/ipfs/go-peertaskqueue v0.1.0/go.mod h1:Jmk3IyCcfl1W3jTW3YpghSwSEC6IJ3Vzz/jUmWw8Z0U=
-github.com/ipfs/go-peertaskqueue v0.1.1 h1:+gPjbI+V3NktXZOqJA1kzbms2pYmhjgQQal0MzZrOAY=
 github.com/ipfs/go-peertaskqueue v0.1.1/go.mod h1:Jmk3IyCcfl1W3jTW3YpghSwSEC6IJ3Vzz/jUmWw8Z0U=
-github.com/ipfs/go-todocounter v0.0.1 h1:kITWA5ZcQZfrUnDNkRn04Xzh0YFaDFXsoO2A81Eb6Lw=
+github.com/ipfs/go-peertaskqueue v0.2.0 h1:2cSr7exUGKYyDeUyQ7P/nHPs9P7Ht/B+ROrpN1EJOjc=
+github.com/ipfs/go-peertaskqueue v0.2.0/go.mod h1:5/eNrBEbtSKWCG+kQK8K8fGNixoYUnr+P7jivavs9lY=
 github.com/ipfs/go-todocounter v0.0.1/go.mod h1:l5aErvQc8qKE2r7NDMjmq5UNAvuZy0rC8BHOplkWvZ4=
-github.com/ipfs/go-unixfs v0.2.2-0.20190827150610-868af2e9e5cb h1:tmWYgjltxwM7PDmFJgWgLuy5qx24csUvRoIiO+F/zQ4=
-github.com/ipfs/go-unixfs v0.2.2-0.20190827150610-868af2e9e5cb/go.mod h1:IwAAgul1UQIcNZzKPYZWOCijryFBeCV79cNubPzol+k=
+github.com/ipfs/go-unixfs v0.0.4/go.mod h1:eIo/p9ADu/MFOuyxzwU+Th8D6xoxU//r590vUpWyfz8=
+github.com/ipfs/go-unixfs v0.2.1/go.mod h1:IwAAgul1UQIcNZzKPYZWOCijryFBeCV79cNubPzol+k=
+github.com/ipfs/go-unixfs v0.2.4 h1:6NwppOXefWIyysZ4LR/qUBPvXd5//8J3jiMdvpbw6Lo=
+github.com/ipfs/go-unixfs v0.2.4/go.mod h1:SUdisfUjNoSDzzhGVxvCL9QO/nKdwXdr+gbMUdqcbYw=
 github.com/ipfs/go-verifcid v0.0.1 h1:m2HI7zIuR5TFyQ1b79Da5N9dnnCP1vcu2QqawmWlK2E=
 github.com/ipfs/go-verifcid v0.0.1/go.mod h1:5Hrva5KBeIog4A+UpqlaIU+DEstipcJYQQZc0g37pY0=
-github.com/ipld/go-ipld-prime v0.0.2-0.20191025154717-8dff1cbec43b h1:ACSEK4f1SDQC+FJ4B4pqHFW14d7kEW2ufwXA/c7eLP0=
-github.com/ipld/go-ipld-prime v0.0.2-0.20191025154717-8dff1cbec43b/go.mod h1:bDDSvVz7vaK12FNvMeRYnpRFkSUPNQOiCYQezMD/P3w=
+github.com/ipfs/interface-go-ipfs-core v0.2.3 h1:E6uQ+1fJjkxJWlL9lAE72a5FWeyeeNL3GitLy8+jq3Y=
+github.com/ipfs/interface-go-ipfs-core v0.2.3/go.mod h1:Tihp8zxGpUeE3Tokr94L6zWZZdkRQvG5TL6i9MuNE+s=
+github.com/ipfs/iptb v1.4.0 h1:YFYTrCkLMRwk/35IMyC6+yjoQSHTEcNcefBStLJzgvo=
+github.com/ipfs/iptb v1.4.0/go.mod h1:1rzHpCYtNp87/+hTxG5TfCVn/yMY3dKnLn8tBiMfdmg=
+github.com/ipfs/iptb-plugins v0.2.1 h1:au4HWn9/pRPbkxA08pDx2oRAs4cnbgQWgV0teYXuuGA=
+github.com/ipfs/iptb-plugins v0.2.1/go.mod h1:QXMbtIWZ+jRsW8a4h13qAKU7jcM7qaittO8wOsTP0Rs=
+github.com/ipld/go-car v0.1.1-0.20200923150018-8cdef32e2da4 h1:6phjU3kXvCEWOZpu+Ob0w6DzgPFZmDLgLPxJhD8RxEY=
+github.com/ipld/go-car v0.1.1-0.20200923150018-8cdef32e2da4/go.mod h1:xrMEcuSq+D1vEwl+YAXsg/JfA98XGpXDwnkIL4Aimqw=
+github.com/ipld/go-ipld-prime v0.0.2-0.20200428162820-8b59dc292b8e/go.mod h1:uVIwe/u0H4VdKv3kaN1ck7uCb6yD9cFLS9/ELyXbsw8=
+github.com/ipld/go-ipld-prime v0.5.1-0.20200828233916-988837377a7f h1:XpOuNQ5GbXxUcSukbQcW9jkE7REpaFGJU2/T00fo9kA=
+github.com/ipld/go-ipld-prime v0.5.1-0.20200828233916-988837377a7f/go.mod h1:0xEgdD6MKbZ1vF0GC+YcR/C4SQCAlRuOjIJ2i0HxqzM=
+github.com/ipld/go-ipld-prime-proto v0.0.0-20200428191222-c1ffdadc01e1/go.mod h1:OAV6xBmuTLsPZ+epzKkPB1e25FHk/vCtyatkdHcArLs=
+github.com/ipld/go-ipld-prime-proto v0.0.0-20200922192210-9a2bfd4440a6 h1:6Mq+tZGSEMEoJJ1NbJRhddeelkXZcU8yfH/ZRYUo/Es=
+github.com/ipld/go-ipld-prime-proto v0.0.0-20200922192210-9a2bfd4440a6/go.mod h1:3pHYooM9Ea65jewRwrb2u5uHZCNkNTe9ABsVB+SrkH0=
 github.com/ipsn/go-secp256k1 v0.0.0-20180726113642-9d62b9f0bc52 h1:QG4CGBqCeuBo6aZlGAamSkxWdgWfZGeE49eUOWJPA4c=
 github.com/ipsn/go-secp256k1 v0.0.0-20180726113642-9d62b9f0bc52/go.mod h1:fdg+/X9Gg4AsAIzWpEHwnqd+QY3b7lajxyjE1m4hkq4=
 github.com/jackpal/gateway v1.0.4/go.mod h1:lTpwd4ACLXmpyiCTRtfiNyVnUmqT9RivzCDQetPfnjA=
-github.com/jackpal/gateway v1.0.5 h1:qzXWUJfuMdlLMtt0a3Dgt+xkWQiA5itDEITVJtuSwMc=
 github.com/jackpal/gateway v1.0.5/go.mod h1:lTpwd4ACLXmpyiCTRtfiNyVnUmqT9RivzCDQetPfnjA=
-github.com/jackpal/go-nat-pmp v1.0.1 h1:i0LektDkO1QlrTm/cSuP+PyBCDnYvjPLGl4LdWEMiaA=
 github.com/jackpal/go-nat-pmp v1.0.1/go.mod h1:QPH045xvCAeXUZOxsnwmrtiCoxIr9eob+4orBN1SBKc=
+github.com/jackpal/go-nat-pmp v1.0.2 h1:KzKSgb7qkJvOUTqYl9/Hg/me3pWgBmERKrTGD7BdWus=
+github.com/jackpal/go-nat-pmp v1.0.2/go.mod h1:QPH045xvCAeXUZOxsnwmrtiCoxIr9eob+4orBN1SBKc=
 github.com/jbenet/go-cienv v0.0.0-20150120210510-1bb1476777ec/go.mod h1:rGaEvXB4uRSZMmzKNLoXvTu1sfx+1kv/DojUlPrSZGs=
 github.com/jbenet/go-cienv v0.1.0 h1:Vc/s0QbQtoxX8MwwSLWWh+xNNZvM3Lw7NsTcHrvvhMc=
 github.com/jbenet/go-cienv v0.1.0/go.mod h1:TqNnHUmJgXau0nCzC7kXWeotg3J9W34CUv5Djy1+FlA=
-github.com/jbenet/go-temp-err-catcher v0.0.0-20150120210811-aac704a3f4f2 h1:vhC1OXXiT9R2pczegwz6moDvuRpggaroAXhPIseh57A=
+github.com/jbenet/go-random v0.0.0-20190219211222-123a90aedc0c h1:uUx61FiAa1GI6ZmVd2wf2vULeQZIKG66eybjNXKYCz4=
+github.com/jbenet/go-random v0.0.0-20190219211222-123a90aedc0c/go.mod h1:sdx1xVM9UuLw1tXnhJWN3piypTUO3vCIHYmG15KE/dU=
 github.com/jbenet/go-temp-err-catcher v0.0.0-20150120210811-aac704a3f4f2/go.mod h1:8GXXJV31xl8whumTzdZsTt3RnUIiPqzkyf7mxToRCMs=
+github.com/jbenet/go-temp-err-catcher v0.1.0 h1:zpb3ZH6wIE8Shj2sKS+khgRvf7T7RABoLk/+KKHggpk=
+github.com/jbenet/go-temp-err-catcher v0.1.0/go.mod h1:0kJRvmDZXNMIiJirNPEYfhpPwbGVtZVWC34vc5WLsDk=
 github.com/jbenet/goprocess v0.0.0-20160826012719-b497e2f366b8/go.mod h1:Ly/wlsjFq/qrU3Rar62tu1gASgGw6chQbSh/XgIIXCY=
-github.com/jbenet/goprocess v0.1.3 h1:YKyIEECS/XvcfHtBzxtjBBbWK+MbvA6dG8ASiqwvr10=
 github.com/jbenet/goprocess v0.1.3/go.mod h1:5yspPrukOVuOLORacaBi858NqyClJPQxYZlqdZVfqY4=
+github.com/jbenet/goprocess v0.1.4 h1:DRGOFReOMqqDNXwW70QkacFW0YN9QnwLV0Vqk+3oU0o=
+github.com/jbenet/goprocess v0.1.4/go.mod h1:5yspPrukOVuOLORacaBi858NqyClJPQxYZlqdZVfqY4=
+github.com/jellevandenhooff/dkim v0.0.0-20150330215556-f50fe3d243e1/go.mod h1:E0B/fFc00Y+Rasa88328GlI/XbtyysCtTHZS8h7IrBU=
 github.com/jessevdk/go-flags v0.0.0-20141203071132-1679536dcc89/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI=
 github.com/jessevdk/go-flags v1.4.0 h1:4IU2WS7AumrZ/40jfhf4QVDMsQwqA7VEHozFRrGARJA=
 github.com/jessevdk/go-flags v1.4.0/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI=
+github.com/jmespath/go-jmespath v0.0.0-20180206201540-c2b33e8439af/go.mod h1:Nht3zPeWKUH0NzdCt2Blrr5ys8VGpn0CEB0cQHVjt7k=
+github.com/jmespath/go-jmespath v0.3.0/go.mod h1:9QtRXoHjLGCJ5IBSaohpXITPlowMeeYCZ7fLUTSywik=
+github.com/joeshaw/multierror v0.0.0-20140124173710-69b34d4ec901 h1:rp+c0RAYOWj8l6qbCUTSiRLG/iKnW3K3/QfPPuSsBt4=
+github.com/joeshaw/multierror v0.0.0-20140124173710-69b34d4ec901/go.mod h1:Z86h9688Y0wesXCyonoVr47MasHilkuLMqGhRZ4Hpak=
+github.com/jonboulle/clockwork v0.1.0/go.mod h1:Ii8DK3G1RaLaWxj9trq07+26W01tbo22gdxWY5EU2bo=
+github.com/jonboulle/clockwork v0.1.1-0.20190114141812-62fb9bc030d1 h1:qBCV/RLV02TSfQa7tFmxTihnG+u+7JXByOkhlkR5rmQ=
+github.com/jonboulle/clockwork v0.1.1-0.20190114141812-62fb9bc030d1/go.mod h1:Ii8DK3G1RaLaWxj9trq07+26W01tbo22gdxWY5EU2bo=
+github.com/jpillora/backoff v1.0.0 h1:uvFg412JmmHBHw7iwprIxkPMI+sGQ4kzOWsMeHnm2EA=
+github.com/jpillora/backoff v1.0.0/go.mod h1:J/6gKK9jxlEcS3zixgDgUAsiuZ7yrSoa/FX5e0EB2j4=
 github.com/jrick/logrotate v1.0.0/go.mod h1:LNinyqDIJnpAur+b8yyulnQw/wDuN1+BYKlTRt3OuAQ=
+github.com/jsimonetti/rtnetlink v0.0.0-20190606172950-9527aa82566a/go.mod h1:Oz+70psSo5OFh8DBl0Zv2ACw7Esh6pPUphlvZG9x7uw=
+github.com/jsimonetti/rtnetlink v0.0.0-20190830100107-3784a6c7c552/go.mod h1:Oz+70psSo5OFh8DBl0Zv2ACw7Esh6pPUphlvZG9x7uw=
+github.com/jsimonetti/rtnetlink v0.0.0-20200117123717-f846d4f6c1f4/go.mod h1:WGuG/smIU4J/54PblvSbh+xvCZmpJnFgr3ds6Z55XMQ=
+github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU=
+github.com/json-iterator/go v1.1.7/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
+github.com/json-iterator/go v1.1.8/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
+github.com/json-iterator/go v1.1.9/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
+github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024/go.mod h1:6v2b51hI/fHJwM22ozAgKL4VKDeJcHhJFhtBdhmNjmU=
+github.com/jstemmer/go-junit-report v0.9.1/go.mod h1:Brl9GWCQeLvo8nXZwPNNblvFj/XSXhF0NWZEnDohbsk=
 github.com/jtolds/gls v4.2.1+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU=
 github.com/jtolds/gls v4.20.0+incompatible h1:xdiiI2gbIgH/gLH7ADydsJ1uDOEzR8yvV7C0MuV77Wo=
 github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU=
 github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w=
+github.com/kabukky/httpscerts v0.0.0-20150320125433-617593d7dcb3 h1:Iy7Ifq2ysilWU4QlCx/97OoI4xT1IV7i8byT/EyIT/M=
+github.com/kabukky/httpscerts v0.0.0-20150320125433-617593d7dcb3/go.mod h1:BYpt4ufZiIGv2nXn4gMxnfKV306n3mWXgNu/d2TqdTU=
 github.com/kami-zh/go-capturer v0.0.0-20171211120116-e492ea43421d/go.mod h1:P2viExyCEfeWGU259JnaQ34Inuec4R38JCyBx2edgD0=
+github.com/kelseyhightower/envconfig v1.4.0 h1:Im6hONhd3pLkfDFsbRgu68RDNkGF1r3dvMUtDTo2cv8=
+github.com/kelseyhightower/envconfig v1.4.0/go.mod h1:cccZRl6mQpaq41TPp5QxidR+Sa3axMbJDNb//FQX6Gg=
+github.com/kilic/bls12-381 v0.0.0-20200607163746-32e1441c8a9f h1:qET3Wx0v8tMtoTOQnsJXVvqvCopSf48qobR6tcJuDHo=
+github.com/kilic/bls12-381 v0.0.0-20200607163746-32e1441c8a9f/go.mod h1:XXfR6YFCRSrkEXbNlIyDsgXVNJWVUV30m/ebkVy9n6s=
 github.com/kisielk/errcheck v1.1.0/go.mod h1:EZBBE59ingxPouuu3KfxchcWSUPOHkagtvWXihfKN4Q=
 github.com/kisielk/errcheck v1.2.0/go.mod h1:/BMXB+zMLi60iA8Vv6Ksmxu/1UDYcXs4uQLJ+jE2L00=
 github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
 github.com/kkdai/bstream v0.0.0-20161212061736-f391b8402d23/go.mod h1:J+Gs4SYgM6CZQHDETBtE9HaSEkGmuNXF86RwHhHUvq4=
-github.com/konsorten/go-windows-terminal-sequences v1.0.1 h1:mweAR1A6xJ3oS2pRaGiHgQ4OO8tzTaLawm8vnODuwDk=
 github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
+github.com/konsorten/go-windows-terminal-sequences v1.0.3 h1:CE8S1cTafDpPvMhIxNJKvHsGVBgn1xWYf1NbHQhywc8=
+github.com/konsorten/go-windows-terminal-sequences v1.0.3/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
 github.com/koron/go-ssdp v0.0.0-20180514024734-4a0ed625a78b/go.mod h1:5Ky9EC2xfoUKUor0Hjgi2BJhCSXJfMOFlmyYrVKGQMk=
 github.com/koron/go-ssdp v0.0.0-20191105050749-2e1c40ed0b5d h1:68u9r4wEvL3gYg2jvAOgROwZ3H+Y3hIDk4tbbmIjcYQ=
 github.com/koron/go-ssdp v0.0.0-20191105050749-2e1c40ed0b5d/go.mod h1:5Ky9EC2xfoUKUor0Hjgi2BJhCSXJfMOFlmyYrVKGQMk=
 github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc=
-github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI=
 github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
+github.com/kr/pretty v0.2.0 h1:s5hAObm+yFO5uHYt5dYjxi2rXrsnmRpJx4OYvIWUaQs=
+github.com/kr/pretty v0.2.0/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
 github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
+github.com/kr/pty v1.1.3/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
 github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
-github.com/libp2p/go-addr-util v0.0.1 h1:TpTQm9cXVRVSKsYbgQ7GKc3KbbHVTnbostgGaDEP+88=
+github.com/lib/pq v1.7.0 h1:h93mCPfUSkaul3Ka/VG8uZdmW1uMHDGxzu0NWHuJmHY=
+github.com/lib/pq v1.7.0/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o=
 github.com/libp2p/go-addr-util v0.0.1/go.mod h1:4ac6O7n9rIAKB1dnd+s8IbbMXkt+oBpzX4/+RACcnlQ=
+github.com/libp2p/go-addr-util v0.0.2 h1:7cWK5cdA5x72jX0g8iLrQWm5TRJZ6CzGdPEhWj7plWU=
+github.com/libp2p/go-addr-util v0.0.2/go.mod h1:Ecd6Fb3yIuLzq4bD7VcywcVSBtefcAwnUISBM3WG15E=
 github.com/libp2p/go-buffer-pool v0.0.1/go.mod h1:xtyIz9PMobb13WaxR6Zo1Pd1zXJKYg0a8KiIvDp3TzQ=
 github.com/libp2p/go-buffer-pool v0.0.2 h1:QNK2iAFa8gjAe1SPz6mHSMuCcjs+X1wlHzeOSqcmlfs=
 github.com/libp2p/go-buffer-pool v0.0.2/go.mod h1:MvaB6xw5vOrDl8rYZGLFdKAuk/hRoRZd1Vi32+RXyFM=
 github.com/libp2p/go-conn-security v0.0.1/go.mod h1:bGmu51N0KU9IEjX7kl2PQjgZa40JQWnayTvNMgD/vyk=
+github.com/libp2p/go-conn-security-multistream v0.0.1/go.mod h1:nc9vud7inQ+d6SO0I/6dSWrdMnHnzZNHeyUQqrAJulE=
 github.com/libp2p/go-conn-security-multistream v0.0.2/go.mod h1:nc9vud7inQ+d6SO0I/6dSWrdMnHnzZNHeyUQqrAJulE=
-github.com/libp2p/go-conn-security-multistream v0.1.0 h1:aqGmto+ttL/uJgX0JtQI0tD21CIEy5eYd1Hlp0juHY0=
 github.com/libp2p/go-conn-security-multistream v0.1.0/go.mod h1:aw6eD7LOsHEX7+2hJkDxw1MteijaVcI+/eP2/x3J1xc=
-github.com/libp2p/go-eventbus v0.1.0 h1:mlawomSAjjkk97QnYiEmHsLu7E136+2oCWSHRUvMfzQ=
+github.com/libp2p/go-conn-security-multistream v0.2.0 h1:uNiDjS58vrvJTg9jO6bySd1rMKejieG7v45ekqHbZ1M=
+github.com/libp2p/go-conn-security-multistream v0.2.0/go.mod h1:hZN4MjlNetKD3Rq5Jb/P5ohUnFLNzEAR4DLSzpn2QLU=
+github.com/libp2p/go-eventbus v0.0.2/go.mod h1:Hr/yGlwxA/stuLnpMiu82lpNKpvRy3EaJxPu40XYOwk=
 github.com/libp2p/go-eventbus v0.1.0/go.mod h1:vROgu5cs5T7cv7POWlWxBaVLxfSegC5UGQf8A2eEmx4=
-github.com/libp2p/go-flow-metrics v0.0.1 h1:0gxuFd2GuK7IIP5pKljLwps6TvcuYgvG7Atqi3INF5s=
+github.com/libp2p/go-eventbus v0.2.1 h1:VanAdErQnpTioN2TowqNcOijf6YwhuODe4pPKSDpxGc=
+github.com/libp2p/go-eventbus v0.2.1/go.mod h1:jc2S4SoEVPP48H9Wpzm5aiGwUCBMfGhVhhBjyhhCJs8=
 github.com/libp2p/go-flow-metrics v0.0.1/go.mod h1:Iv1GH0sG8DtYN3SVJ2eG221wMiNpZxBdp967ls1g+k8=
+github.com/libp2p/go-flow-metrics v0.0.2/go.mod h1:HeoSNUrOJVK1jEpDqVEiUOIXqhbnS27omG0uWU5slZs=
+github.com/libp2p/go-flow-metrics v0.0.3 h1:8tAs/hSdNvUiLgtlSy3mxwxWP4I9y/jlkPFT7epKdeM=
+github.com/libp2p/go-flow-metrics v0.0.3/go.mod h1:HeoSNUrOJVK1jEpDqVEiUOIXqhbnS27omG0uWU5slZs=
+github.com/libp2p/go-libp2p v0.0.2/go.mod h1:Qu8bWqFXiocPloabFGUcVG4kk94fLvfC8mWTDdFC9wE=
 github.com/libp2p/go-libp2p v0.0.30/go.mod h1:XWT8FGHlhptAv1+3V/+J5mEpzyui/5bvFsNuWYs611A=
 github.com/libp2p/go-libp2p v0.1.0/go.mod h1:6D/2OBauqLUoqcADOJpn9WbKqvaM07tDw68qHM0BxUM=
 github.com/libp2p/go-libp2p v0.1.1/go.mod h1:I00BRo1UuUSdpuc8Q2mN7yDF/oTUTRAX6JWpTiK9Rp8=
-github.com/libp2p/go-libp2p v0.4.2 h1:p0cthB0jDNHO4gH2HzS8/nAMMXbfUlFHs0jwZ4U+F2g=
-github.com/libp2p/go-libp2p v0.4.2/go.mod h1:MNmgUxUw5pMsdOzMlT0EE7oKjRasl+WyVwM0IBlpKgQ=
+github.com/libp2p/go-libp2p v0.3.1/go.mod h1:e6bwxbdYH1HqWTz8faTChKGR0BjPc8p+6SyP8GTTR7Y=
+github.com/libp2p/go-libp2p v0.4.0/go.mod h1:9EsEIf9p2UDuwtPd0DwJsAl0qXVxgAnuDGRvHbfATfI=
+github.com/libp2p/go-libp2p v0.6.0/go.mod h1:mfKWI7Soz3ABX+XEBR61lGbg+ewyMtJHVt043oWeqwg=
+github.com/libp2p/go-libp2p v0.6.1/go.mod h1:CTFnWXogryAHjXAKEbOf1OWY+VeAP3lDMZkfEI5sT54=
+github.com/libp2p/go-libp2p v0.7.0/go.mod h1:hZJf8txWeCduQRDC/WSqBGMxaTHCOYHt2xSU1ivxn0k=
+github.com/libp2p/go-libp2p v0.7.4/go.mod h1:oXsBlTLF1q7pxr+9w6lqzS1ILpyHsaBPniVO7zIHGMw=
+github.com/libp2p/go-libp2p v0.8.1/go.mod h1:QRNH9pwdbEBpx5DTJYg+qxcVaDMAz3Ee/qDKwXujH5o=
+github.com/libp2p/go-libp2p v0.8.3/go.mod h1:EsH1A+8yoWK+L4iKcbPYu6MPluZ+CHWI9El8cTaefiM=
+github.com/libp2p/go-libp2p v0.9.2/go.mod h1:cunHNLDVus66Ct9iXXcjKRLdmHdFdHVe1TAnbubJQqQ=
+github.com/libp2p/go-libp2p v0.10.0/go.mod h1:yBJNpb+mGJdgrwbKAKrhPU0u3ogyNFTfjJ6bdM+Q/G8=
+github.com/libp2p/go-libp2p v0.11.0 h1:jb5mqdqYEBAybTEhD8io43Cz5LzVKuWxOK7znSN69jE=
+github.com/libp2p/go-libp2p v0.11.0/go.mod h1:3/ogJDXsbbepEfqtZKBR/DedzxJXCeK17t2Z9RE9bEE=
+github.com/libp2p/go-libp2p-autonat v0.0.2/go.mod h1:fs71q5Xk+pdnKU014o2iq1RhMs9/PMaG5zXRFNnIIT4=
 github.com/libp2p/go-libp2p-autonat v0.0.6/go.mod h1:uZneLdOkZHro35xIhpbtTzLlgYturpu4J5+0cZK3MqE=
 github.com/libp2p/go-libp2p-autonat v0.1.0/go.mod h1:1tLf2yXxiE/oKGtDwPYWTSYG3PtvYlJmg7NeVtPRqH8=
-github.com/libp2p/go-libp2p-autonat v0.1.1 h1:WLBZcIRsjZlWdAZj9CiBSvU2wQXoUOiS1Zk1tM7DTJI=
 github.com/libp2p/go-libp2p-autonat v0.1.1/go.mod h1:OXqkeGOY2xJVWKAGV2inNF5aKN/djNA3fdpCWloIudE=
+github.com/libp2p/go-libp2p-autonat v0.2.0/go.mod h1:DX+9teU4pEEoZUqR1PiMlqliONQdNbfzE1C718tcViI=
+github.com/libp2p/go-libp2p-autonat v0.2.1/go.mod h1:MWtAhV5Ko1l6QBsHQNSuM6b1sRkXrpk0/LqCr+vCVxI=
+github.com/libp2p/go-libp2p-autonat v0.2.2/go.mod h1:HsM62HkqZmHR2k1xgX34WuWDzk/nBwNHoeyyT4IWV6A=
+github.com/libp2p/go-libp2p-autonat v0.2.3/go.mod h1:2U6bNWCNsAG9LEbwccBDQbjzQ8Krdjge1jLTE9rdoMM=
+github.com/libp2p/go-libp2p-autonat v0.3.2 h1:OhDSwVVaq7liTaRIsFFYvsaPp0pn2yi0WazejZ4DUmo=
+github.com/libp2p/go-libp2p-autonat v0.3.2/go.mod h1:0OzOi1/cVc7UcxfOddemYD5vzEqi4fwRbnZcJGLi68U=
+github.com/libp2p/go-libp2p-autonat-svc v0.1.0/go.mod h1:fqi8Obl/z3R4PFVLm8xFtZ6PBL9MlV/xumymRFkKq5A=
 github.com/libp2p/go-libp2p-blankhost v0.0.1/go.mod h1:Ibpbw/7cPPYwFb7PACIWdvxxv0t0XCCI10t7czjAjTc=
 github.com/libp2p/go-libp2p-blankhost v0.1.1/go.mod h1:pf2fvdLJPsC1FsVrNP3DUUvMzUts2dsLLBEpo1vW1ro=
-github.com/libp2p/go-libp2p-blankhost v0.1.4 h1:I96SWjR4rK9irDHcHq3XHN6hawCRTPUADzkJacgZLvk=
+github.com/libp2p/go-libp2p-blankhost v0.1.3/go.mod h1:KML1//wiKR8vuuJO0y3LUd1uLv+tlkGTAr3jC0S5cLg=
 github.com/libp2p/go-libp2p-blankhost v0.1.4/go.mod h1:oJF0saYsAXQCSfDq254GMNmLNz6ZTHTOvtF4ZydUvwU=
+github.com/libp2p/go-libp2p-blankhost v0.1.6/go.mod h1:jONCAJqEP+Z8T6EQviGL4JsQcLx1LgTGtVqFNY8EMfQ=
+github.com/libp2p/go-libp2p-blankhost v0.2.0 h1:3EsGAi0CBGcZ33GwRuXEYJLLPoVWyXJ1bcJzAJjINkk=
+github.com/libp2p/go-libp2p-blankhost v0.2.0/go.mod h1:eduNKXGTioTuQAUcZ5epXi9vMl+t4d8ugUBRQ4SqaNQ=
+github.com/libp2p/go-libp2p-circuit v0.0.1/go.mod h1:Dqm0s/BiV63j8EEAs8hr1H5HudqvCAeXxDyic59lCwE=
 github.com/libp2p/go-libp2p-circuit v0.0.9/go.mod h1:uU+IBvEQzCu953/ps7bYzC/D/R0Ho2A9LfKVVCatlqU=
 github.com/libp2p/go-libp2p-circuit v0.1.0/go.mod h1:Ahq4cY3V9VJcHcn1SBXjr78AbFkZeIRmfunbA7pmFh8=
-github.com/libp2p/go-libp2p-circuit v0.1.4 h1:Phzbmrg3BkVzbqd4ZZ149JxCuUWu2wZcXf/Kr6hZJj8=
+github.com/libp2p/go-libp2p-circuit v0.1.1/go.mod h1:Ahq4cY3V9VJcHcn1SBXjr78AbFkZeIRmfunbA7pmFh8=
+github.com/libp2p/go-libp2p-circuit v0.1.3/go.mod h1:Xqh2TjSy8DD5iV2cCOMzdynd6h8OTBGoV1AWbWor3qM=
 github.com/libp2p/go-libp2p-circuit v0.1.4/go.mod h1:CY67BrEjKNDhdTk8UgBX1Y/H5c3xkAcs3gnksxY7osU=
-github.com/libp2p/go-libp2p-connmgr v0.1.0 h1:vp0t0F0EuT3rrlTtnMnIyyzCnly7nIlRoEbhJpgp0qU=
-github.com/libp2p/go-libp2p-connmgr v0.1.0/go.mod h1:wZxh8veAmU5qdrfJ0ZBLcU8oJe9L82ciVP/fl1VHjXk=
+github.com/libp2p/go-libp2p-circuit v0.2.1/go.mod h1:BXPwYDN5A8z4OEY9sOfr2DUQMLQvKt/6oku45YUmjIo=
+github.com/libp2p/go-libp2p-circuit v0.2.2/go.mod h1:nkG3iE01tR3FoQ2nMm06IUrCpCyJp1Eo4A1xYdpjfs4=
+github.com/libp2p/go-libp2p-circuit v0.2.3/go.mod h1:nkG3iE01tR3FoQ2nMm06IUrCpCyJp1Eo4A1xYdpjfs4=
+github.com/libp2p/go-libp2p-circuit v0.3.1 h1:69ENDoGnNN45BNDnBd+8SXSetDuw0eJFcGmOvvtOgBw=
+github.com/libp2p/go-libp2p-circuit v0.3.1/go.mod h1:8RMIlivu1+RxhebipJwFDA45DasLx+kkrp4IlJj53F4=
+github.com/libp2p/go-libp2p-connmgr v0.1.1/go.mod h1:wZxh8veAmU5qdrfJ0ZBLcU8oJe9L82ciVP/fl1VHjXk=
+github.com/libp2p/go-libp2p-connmgr v0.2.3/go.mod h1:Gqjg29zI8CwXX21zRxy6gOg8VYu3zVerJRt2KyktzH4=
+github.com/libp2p/go-libp2p-connmgr v0.2.4 h1:TMS0vc0TCBomtQJyWr7fYxcVYYhx+q/2gF++G5Jkl/w=
+github.com/libp2p/go-libp2p-connmgr v0.2.4/go.mod h1:YV0b/RIm8NGPnnNWM7hG9Q38OeQiQfKhHCCs1++ufn0=
 github.com/libp2p/go-libp2p-core v0.0.1/go.mod h1:g/VxnTZ/1ygHxH3dKok7Vno1VfpvGcGip57wjTU4fco=
 github.com/libp2p/go-libp2p-core v0.0.2/go.mod h1:9dAcntw/n46XycV4RnlBq3BpgrmyUi9LuoTNdPrbUco=
 github.com/libp2p/go-libp2p-core v0.0.3/go.mod h1:j+YQMNz9WNSkNezXOsahp9kwZBKBvxLpKD316QWSJXE=
 github.com/libp2p/go-libp2p-core v0.0.4/go.mod h1:jyuCQP356gzfCFtRKyvAbNkyeuxb7OlyhWZ3nls5d2I=
+github.com/libp2p/go-libp2p-core v0.0.6/go.mod h1:0d9xmaYAVY5qmbp/fcgxHT3ZJsLjYeYPMJAUKpaCHrE=
 github.com/libp2p/go-libp2p-core v0.2.0/go.mod h1:X0eyB0Gy93v0DZtSYbEM7RnMChm9Uv3j7yRXjO77xSI=
 github.com/libp2p/go-libp2p-core v0.2.2/go.mod h1:8fcwTbsG2B+lTgRJ1ICZtiM5GWCWZVoVrLaDRvIRng0=
-github.com/libp2p/go-libp2p-core v0.2.4 h1:Et6ykkTwI6PU44tr8qUF9k43vP0aduMNniShAbUJJw8=
+github.com/libp2p/go-libp2p-core v0.2.3/go.mod h1:GqhyQqyIAPsxFYXHMjfXgMv03lxsvM0mFzuYA9Ib42A=
 github.com/libp2p/go-libp2p-core v0.2.4/go.mod h1:STh4fdfa5vDYr0/SzYYeqnt+E6KfEV5VxfIrm0bcI0g=
+github.com/libp2p/go-libp2p-core v0.2.5/go.mod h1:6+5zJmKhsf7yHn1RbmYDu08qDUpIUxGdqHuEZckmZOA=
+github.com/libp2p/go-libp2p-core v0.3.0/go.mod h1:ACp3DmS3/N64c2jDzcV429ukDpicbL6+TrrxANBjPGw=
+github.com/libp2p/go-libp2p-core v0.3.1/go.mod h1:thvWy0hvaSBhnVBaW37BvzgVV68OUhgJJLAa6almrII=
+github.com/libp2p/go-libp2p-core v0.4.0/go.mod h1:49XGI+kc38oGVwqSBhDEwytaAxgZasHhFfQKibzTls0=
+github.com/libp2p/go-libp2p-core v0.5.0/go.mod h1:49XGI+kc38oGVwqSBhDEwytaAxgZasHhFfQKibzTls0=
+github.com/libp2p/go-libp2p-core v0.5.1/go.mod h1:uN7L2D4EvPCvzSH5SrhR72UWbnSGpt5/a35Sm4upn4Y=
+github.com/libp2p/go-libp2p-core v0.5.2/go.mod h1:uN7L2D4EvPCvzSH5SrhR72UWbnSGpt5/a35Sm4upn4Y=
+github.com/libp2p/go-libp2p-core v0.5.3/go.mod h1:uN7L2D4EvPCvzSH5SrhR72UWbnSGpt5/a35Sm4upn4Y=
+github.com/libp2p/go-libp2p-core v0.5.4/go.mod h1:uN7L2D4EvPCvzSH5SrhR72UWbnSGpt5/a35Sm4upn4Y=
+github.com/libp2p/go-libp2p-core v0.5.5/go.mod h1:vj3awlOr9+GMZJFH9s4mpt9RHHgGqeHCopzbYKZdRjM=
+github.com/libp2p/go-libp2p-core v0.5.6/go.mod h1:txwbVEhHEXikXn9gfC7/UDDw7rkxuX0bJvM49Ykaswo=
+github.com/libp2p/go-libp2p-core v0.5.7/go.mod h1:txwbVEhHEXikXn9gfC7/UDDw7rkxuX0bJvM49Ykaswo=
+github.com/libp2p/go-libp2p-core v0.6.0/go.mod h1:txwbVEhHEXikXn9gfC7/UDDw7rkxuX0bJvM49Ykaswo=
+github.com/libp2p/go-libp2p-core v0.6.1 h1:XS+Goh+QegCDojUZp00CaPMfiEADCrLjNZskWE7pvqs=
+github.com/libp2p/go-libp2p-core v0.6.1/go.mod h1:FfewUH/YpvWbEB+ZY9AQRQ4TAD8sJBt/G1rVvhz5XT8=
 github.com/libp2p/go-libp2p-crypto v0.0.1/go.mod h1:yJkNyDmO341d5wwXxDUGO0LykUVT72ImHNUqh5D/dBE=
 github.com/libp2p/go-libp2p-crypto v0.0.2/go.mod h1:eETI5OUfBnvARGOHrJz2eWNyTUxEGZnBxMcbUjfIj4I=
-github.com/libp2p/go-libp2p-crypto v0.1.0 h1:k9MFy+o2zGDNGsaoZl0MA3iZ75qXxr9OOoAZF+sD5OQ=
 github.com/libp2p/go-libp2p-crypto v0.1.0/go.mod h1:sPUokVISZiy+nNuTTH/TY+leRSxnFj/2GLjtOTW90hI=
+github.com/libp2p/go-libp2p-daemon v0.2.2/go.mod h1:kyrpsLB2JeNYR2rvXSVWyY0iZuRIMhqzWR3im9BV6NQ=
+github.com/libp2p/go-libp2p-discovery v0.0.1/go.mod h1:ZkkF9xIFRLA1xCc7bstYFkd80gBGK8Fc1JqGoU2i+zI=
 github.com/libp2p/go-libp2p-discovery v0.0.5/go.mod h1:YtF20GUxjgoKZ4zmXj8j3Nb2TUSBHFlOCetzYdbZL5I=
 github.com/libp2p/go-libp2p-discovery v0.1.0/go.mod h1:4F/x+aldVHjHDHuX85x1zWoFTGElt8HnoDzwkFZm29g=
-github.com/libp2p/go-libp2p-discovery v0.2.0 h1:1p3YSOq7VsgaL+xVHPi8XAmtGyas6D2J6rWBEfz/aiY=
 github.com/libp2p/go-libp2p-discovery v0.2.0/go.mod h1:s4VGaxYMbw4+4+tsoQTqh7wfxg97AEdo4GYBt6BadWg=
+github.com/libp2p/go-libp2p-discovery v0.3.0/go.mod h1:o03drFnz9BVAZdzC/QUQ+NeQOu38Fu7LJGEOK2gQltw=
+github.com/libp2p/go-libp2p-discovery v0.4.0/go.mod h1:bZ0aJSrFc/eX2llP0ryhb1kpgkPyTo23SJ5b7UQCMh4=
+github.com/libp2p/go-libp2p-discovery v0.5.0 h1:Qfl+e5+lfDgwdrXdu4YNCWyEo3fWuP+WgN9mN0iWviQ=
+github.com/libp2p/go-libp2p-discovery v0.5.0/go.mod h1:+srtPIU9gDaBNu//UHvcdliKBIcr4SfDcm0/PfPJLug=
 github.com/libp2p/go-libp2p-host v0.0.1/go.mod h1:qWd+H1yuU0m5CwzAkvbSjqKairayEHdR5MMl7Cwa7Go=
 github.com/libp2p/go-libp2p-host v0.0.3/go.mod h1:Y/qPyA6C8j2coYyos1dfRm0I8+nvd4TGrDGt4tA7JR8=
 github.com/libp2p/go-libp2p-interface-connmgr v0.0.1/go.mod h1:GarlRLH0LdeWcLnYM/SaBykKFl9U5JFnbBGruAk/D5k=
 github.com/libp2p/go-libp2p-interface-connmgr v0.0.4/go.mod h1:GarlRLH0LdeWcLnYM/SaBykKFl9U5JFnbBGruAk/D5k=
 github.com/libp2p/go-libp2p-interface-connmgr v0.0.5/go.mod h1:GarlRLH0LdeWcLnYM/SaBykKFl9U5JFnbBGruAk/D5k=
 github.com/libp2p/go-libp2p-interface-pnet v0.0.1/go.mod h1:el9jHpQAXK5dnTpKA4yfCNBZXvrzdOU75zz+C6ryp3k=
-github.com/libp2p/go-libp2p-kad-dht v0.1.1 h1:IH6NQuoUv5w5e1O8Jc3KyVDtr0rNd0G9aaADpLI1xVo=
-github.com/libp2p/go-libp2p-kad-dht v0.1.1/go.mod h1:1kj2Rk5pX3/0RwqMm9AMNCT7DzcMHYhgDN5VTi+cY0M=
-github.com/libp2p/go-libp2p-kbucket v0.2.0 h1:FB2a0VkOTNGTP5gu/I444u4WabNM9V1zCkQcWb7zajI=
-github.com/libp2p/go-libp2p-kbucket v0.2.0/go.mod h1:JNymBToym3QXKBMKGy3m29+xprg0EVr/GJFHxFEdgh8=
+github.com/libp2p/go-libp2p-kad-dht v0.2.1/go.mod h1:k7ONOlup7HKzQ68dE6lSnp07cdxdkmnRa+6B4Fh9/w0=
+github.com/libp2p/go-libp2p-kad-dht v0.8.3 h1:ceK5ML6s/I8UAcw6veoNsuEHdHvfo88leU/5uWOIFWs=
+github.com/libp2p/go-libp2p-kad-dht v0.8.3/go.mod h1:HnYYy8taJWESkqiESd1ngb9XX/XGGsMA5G0Vj2HoSh4=
+github.com/libp2p/go-libp2p-kbucket v0.2.1/go.mod h1:/Rtu8tqbJ4WQ2KTCOMJhggMukOLNLNPY1EtEWWLxUvc=
+github.com/libp2p/go-libp2p-kbucket v0.4.2 h1:wg+VPpCtY61bCasGRexCuXOmEmdKjN+k1w+JtTwu9gA=
+github.com/libp2p/go-libp2p-kbucket v0.4.2/go.mod h1:7sCeZx2GkNK1S6lQnGUW5JYZCFPnXzAZCCBBS70lytY=
 github.com/libp2p/go-libp2p-loggables v0.0.1/go.mod h1:lDipDlBNYbpyqyPX/KcoO+eq0sJYEVR2JgOexcivchg=
 github.com/libp2p/go-libp2p-loggables v0.1.0 h1:h3w8QFfCt2UJl/0/NW4K829HX/0S4KD31PQ7m8UXXO8=
 github.com/libp2p/go-libp2p-loggables v0.1.0/go.mod h1:EyumB2Y6PrYjr55Q3/tiJ/o3xoDasoRYM7nOzEpoa90=
 github.com/libp2p/go-libp2p-metrics v0.0.1/go.mod h1:jQJ95SXXA/K1VZi13h52WZMa9ja78zjyy5rspMsC/08=
 github.com/libp2p/go-libp2p-mplex v0.1.1/go.mod h1:KUQWpGkCzfV7UIpi8SKsAVxyBgz1c9R5EvxgnwLsb/I=
 github.com/libp2p/go-libp2p-mplex v0.2.0/go.mod h1:Ejl9IyjvXJ0T9iqUTE1jpYATQ9NM3g+OtR+EMMODbKo=
-github.com/libp2p/go-libp2p-mplex v0.2.1 h1:E1xaJBQnbSiTHGI1gaBKmKhu1TUKkErKJnE8iGvirYI=
 github.com/libp2p/go-libp2p-mplex v0.2.1/go.mod h1:SC99Rxs8Vuzrf/6WhmH41kNn13TiYdAWNYHrwImKLnE=
+github.com/libp2p/go-libp2p-mplex v0.2.2/go.mod h1:74S9eum0tVQdAfFiKxAyKzNdSuLqw5oadDq7+L/FELo=
+github.com/libp2p/go-libp2p-mplex v0.2.3/go.mod h1:CK3p2+9qH9x+7ER/gWWDYJ3QW5ZxWDkm+dVvjfuG3ek=
+github.com/libp2p/go-libp2p-mplex v0.2.4 h1:XFFXaN4jhqnIuJVjYOR3k6bnRj0mFfJOlIuDVww+4Zo=
+github.com/libp2p/go-libp2p-mplex v0.2.4/go.mod h1:mI7iOezdWFOisvUwaYd3IDrJ4oVmgoXK8H331ui39CE=
+github.com/libp2p/go-libp2p-nat v0.0.2/go.mod h1:QrjXQSD5Dj4IJOdEcjHRkWTSomyxRo6HnUkf/TfQpLQ=
 github.com/libp2p/go-libp2p-nat v0.0.4/go.mod h1:N9Js/zVtAXqaeT99cXgTV9e75KpnWCvVOiGzlcHmBbY=
-github.com/libp2p/go-libp2p-nat v0.0.5 h1:/mH8pXFVKleflDL1YwqMg27W9GD8kjEx7NY0P6eGc98=
 github.com/libp2p/go-libp2p-nat v0.0.5/go.mod h1:1qubaE5bTZMJE+E/uu2URroMbzdubFz1ChgiN79yKPE=
+github.com/libp2p/go-libp2p-nat v0.0.6 h1:wMWis3kYynCbHoyKLPBEMu4YRLltbm8Mk08HGSfvTkU=
+github.com/libp2p/go-libp2p-nat v0.0.6/go.mod h1:iV59LVhB3IkFvS6S6sauVTSOrNEANnINbI/fkaLimiw=
 github.com/libp2p/go-libp2p-net v0.0.1/go.mod h1:Yt3zgmlsHOgUWSXmt5V/Jpz9upuJBE8EgNU9DrCcR8c=
 github.com/libp2p/go-libp2p-net v0.0.2/go.mod h1:Yt3zgmlsHOgUWSXmt5V/Jpz9upuJBE8EgNU9DrCcR8c=
 github.com/libp2p/go-libp2p-netutil v0.0.1/go.mod h1:GdusFvujWZI9Vt0X5BKqwWWmZFxecf9Gt03cKxm2f/Q=
 github.com/libp2p/go-libp2p-netutil v0.1.0 h1:zscYDNVEcGxyUpMd0JReUZTrpMfia8PmLKcKF72EAMQ=
 github.com/libp2p/go-libp2p-netutil v0.1.0/go.mod h1:3Qv/aDqtMLTUyQeundkKsA+YCThNdbQD54k3TqjpbFU=
+github.com/libp2p/go-libp2p-noise v0.1.1 h1:vqYQWvnIcHpIoWJKC7Al4D6Hgj0H012TuXRhPwSMGpQ=
+github.com/libp2p/go-libp2p-noise v0.1.1/go.mod h1:QDFLdKX7nluB7DEnlVPbz7xlLHdwHFA9HiohJRr3vwM=
 github.com/libp2p/go-libp2p-peer v0.0.1/go.mod h1:nXQvOBbwVqoP+T5Y5nCjeH4sP9IX/J0AMzcDUVruVoo=
 github.com/libp2p/go-libp2p-peer v0.1.1/go.mod h1:jkF12jGB4Gk/IOo+yomm+7oLWxF278F7UnrYUQ1Q8es=
-github.com/libp2p/go-libp2p-peer v0.2.0 h1:EQ8kMjaCUwt/Y5uLgjT8iY2qg0mGUT0N1zUjer50DsY=
 github.com/libp2p/go-libp2p-peer v0.2.0/go.mod h1:RCffaCvUyW2CJmG2gAWVqwePwW7JMgxjsHm7+J5kjWY=
 github.com/libp2p/go-libp2p-peerstore v0.0.1/go.mod h1:RabLyPVJLuNQ+GFyoEkfi8H4Ti6k/HtZJ7YKgtSq+20=
 github.com/libp2p/go-libp2p-peerstore v0.0.6/go.mod h1:RabLyPVJLuNQ+GFyoEkfi8H4Ti6k/HtZJ7YKgtSq+20=
 github.com/libp2p/go-libp2p-peerstore v0.1.0/go.mod h1:2CeHkQsr8svp4fZ+Oi9ykN1HBb6u0MOvdJ7YIsmcwtY=
 github.com/libp2p/go-libp2p-peerstore v0.1.3/go.mod h1:BJ9sHlm59/80oSkpWgr1MyY1ciXAXV397W6h1GH/uKI=
-github.com/libp2p/go-libp2p-peerstore v0.1.4 h1:d23fvq5oYMJ/lkkbO4oTwBp/JP+I/1m5gZJobNXCE/k=
 github.com/libp2p/go-libp2p-peerstore v0.1.4/go.mod h1:+4BDbDiiKf4PzpANZDAT+knVdLxvqh7hXOujessqdzs=
-github.com/libp2p/go-libp2p-pnet v0.1.0 h1:kRUES28dktfnHNIRW4Ro78F7rKBHBiw5MJpl0ikrLIA=
-github.com/libp2p/go-libp2p-pnet v0.1.0/go.mod h1:ZkyZw3d0ZFOex71halXRihWf9WH/j3OevcJdTmD0lyE=
+github.com/libp2p/go-libp2p-peerstore v0.2.0/go.mod h1:N2l3eVIeAitSg3Pi2ipSrJYnqhVnMNQZo9nkSCuAbnQ=
+github.com/libp2p/go-libp2p-peerstore v0.2.1/go.mod h1:NQxhNjWxf1d4w6PihR8btWIRjwRLBr4TYKfNgrUkOPA=
+github.com/libp2p/go-libp2p-peerstore v0.2.2/go.mod h1:NQxhNjWxf1d4w6PihR8btWIRjwRLBr4TYKfNgrUkOPA=
+github.com/libp2p/go-libp2p-peerstore v0.2.3/go.mod h1:K8ljLdFn590GMttg/luh4caB/3g0vKuY01psze0upRw=
+github.com/libp2p/go-libp2p-peerstore v0.2.4/go.mod h1:ss/TWTgHZTMpsU/oKVVPQCGuDHItOpf2W8RxAi50P2s=
+github.com/libp2p/go-libp2p-peerstore v0.2.6 h1:2ACefBX23iMdJU9Ke+dcXt3w86MIryes9v7In4+Qq3U=
+github.com/libp2p/go-libp2p-peerstore v0.2.6/go.mod h1:ss/TWTgHZTMpsU/oKVVPQCGuDHItOpf2W8RxAi50P2s=
+github.com/libp2p/go-libp2p-pnet v0.2.0 h1:J6htxttBipJujEjz1y0a5+eYoiPcFHhSYHH6na5f0/k=
+github.com/libp2p/go-libp2p-pnet v0.2.0/go.mod h1:Qqvq6JH/oMZGwqs3N1Fqhv8NVhrdYcO0BW4wssv21LA=
 github.com/libp2p/go-libp2p-protocol v0.0.1/go.mod h1:Af9n4PiruirSDjHycM1QuiMi/1VZNHYcK8cLgFJLZ4s=
 github.com/libp2p/go-libp2p-protocol v0.1.0/go.mod h1:KQPHpAabB57XQxGrXCNvbL6UEXfQqUgC/1adR2Xtflk=
-github.com/libp2p/go-libp2p-pubsub v0.2.3 h1:qJRnRnM7Z4xnHb4i6EBb3DKQXRPgtFWlKP4AmfJudLQ=
-github.com/libp2p/go-libp2p-pubsub v0.2.3/go.mod h1:Jscj3fk23R5mCrOwb625xjVs5ZEyTZcx/OlTwMDqU+g=
-github.com/libp2p/go-libp2p-quic-transport v0.1.1 h1:MFMJzvsxIEDEVKzO89BnB/FgvMj9WI4GDGUW2ArDPUA=
+github.com/libp2p/go-libp2p-pubsub v0.1.1/go.mod h1:ZwlKzRSe1eGvSIdU5bD7+8RZN/Uzw0t1Bp9R1znpR/Q=
+github.com/libp2p/go-libp2p-pubsub v0.3.2-0.20200527132641-c0712c6e92cf/go.mod h1:TxPOBuo1FPdsTjFnv+FGZbNbWYsp74Culx+4ViQpato=
+github.com/libp2p/go-libp2p-pubsub v0.3.6-0.20200910093904-f7f33e10cc18 h1:+ae7vHSv/PJ4xGXwLV6LKGj32zjyB8ttJHtyV4TXal0=
+github.com/libp2p/go-libp2p-pubsub v0.3.6-0.20200910093904-f7f33e10cc18/go.mod h1:DTMSVmZZfXodB/pvdTGrY2eHPZ9W2ev7hzTH83OKHrI=
 github.com/libp2p/go-libp2p-quic-transport v0.1.1/go.mod h1:wqG/jzhF3Pu2NrhJEvE+IE0NTHNXslOPn9JQzyCAxzU=
+github.com/libp2p/go-libp2p-quic-transport v0.5.0/go.mod h1:IEcuC5MLxvZ5KuHKjRu+dr3LjCT1Be3rcD/4d8JrX8M=
+github.com/libp2p/go-libp2p-quic-transport v0.8.0 h1:mHA94K2+TD0e9XtjWx/P5jGGZn0GdQ4OFYwNllagv4E=
+github.com/libp2p/go-libp2p-quic-transport v0.8.0/go.mod h1:F2FG/6Bzz0U6essUVxDzE0s9CrY4XGLbl7QEmDNvU7A=
 github.com/libp2p/go-libp2p-record v0.0.1/go.mod h1:grzqg263Rug/sRex85QrDOLntdFAymLDLm7lxMgU79Q=
 github.com/libp2p/go-libp2p-record v0.1.0/go.mod h1:ujNc8iuE5dlKWVy6wuL6dd58t0n7xI4hAIl8pE6wu5Q=
-github.com/libp2p/go-libp2p-record v0.1.1 h1:ZJK2bHXYUBqObHX+rHLSNrM3M8fmJUlUHrodDPPATmY=
 github.com/libp2p/go-libp2p-record v0.1.1/go.mod h1:VRgKajOyMVgP/F0L5g3kH7SVskp17vFi2xheb5uMJtg=
+github.com/libp2p/go-libp2p-record v0.1.2/go.mod h1:pal0eNcT5nqZaTV7UGhqeGqxFgGdsU/9W//C8dqjQDk=
+github.com/libp2p/go-libp2p-record v0.1.3 h1:R27hoScIhQf/A8XJZ8lYpnqh9LatJ5YbHs28kCIfql0=
+github.com/libp2p/go-libp2p-record v0.1.3/go.mod h1:yNUff/adKIfPnYQXgp6FQmNu3gLJ6EMg7+/vv2+9pY4=
 github.com/libp2p/go-libp2p-routing v0.0.1/go.mod h1:N51q3yTr4Zdr7V8Jt2JIktVU+3xBBylx1MZeVA6t1Ys=
-github.com/libp2p/go-libp2p-routing v0.1.0 h1:hFnj3WR3E2tOcKaGpyzfP4gvFZ3t8JkQmbapN0Ct+oU=
 github.com/libp2p/go-libp2p-routing v0.1.0/go.mod h1:zfLhI1RI8RLEzmEaaPwzonRvXeeSHddONWkcTcB54nE=
-github.com/libp2p/go-libp2p-routing-helpers v0.1.0 h1:BaFvpyv8TyhCN7TihawTiKuzeu8/Pyw7ZnMA4IvqIN8=
-github.com/libp2p/go-libp2p-routing-helpers v0.1.0/go.mod h1:oUs0h39vNwYtYXnQWOTU5BaafbedSyWCCal3gqHuoOQ=
+github.com/libp2p/go-libp2p-routing-helpers v0.2.3 h1:xY61alxJ6PurSi+MXbywZpelvuU4U4p/gPTxjqCqTzY=
+github.com/libp2p/go-libp2p-routing-helpers v0.2.3/go.mod h1:795bh+9YeoFl99rMASoiVgHdi5bjack0N1+AFAdbvBw=
+github.com/libp2p/go-libp2p-secio v0.0.1/go.mod h1:IdG6iQybdcYmbTzxp4J5dwtUEDTOvZrT0opIDVNPrJs=
 github.com/libp2p/go-libp2p-secio v0.0.3/go.mod h1:hS7HQ00MgLhRO/Wyu1bTX6ctJKhVpm+j2/S2A5UqYb0=
 github.com/libp2p/go-libp2p-secio v0.1.0/go.mod h1:tMJo2w7h3+wN4pgU2LSYeiKPrfqBgkOsdiKK77hE7c8=
 github.com/libp2p/go-libp2p-secio v0.2.0/go.mod h1:2JdZepB8J5V9mBp79BmwsaPQhRPNN2NrnB2lKQcdy6g=
-github.com/libp2p/go-libp2p-secio v0.2.1 h1:eNWbJTdyPA7NxhP7J3c5lT97DC5d+u+IldkgCYFTPVA=
 github.com/libp2p/go-libp2p-secio v0.2.1/go.mod h1:cWtZpILJqkqrSkiYcDBh5lA3wbT2Q+hz3rJQq3iftD8=
+github.com/libp2p/go-libp2p-secio v0.2.2/go.mod h1:wP3bS+m5AUnFA+OFO7Er03uO1mncHG0uVwGrwvjYlNY=
+github.com/libp2p/go-libp2p-swarm v0.0.1/go.mod h1:mh+KZxkbd3lQnveQ3j2q60BM1Cw2mX36XXQqwfPOShs=
 github.com/libp2p/go-libp2p-swarm v0.0.6/go.mod h1:s5GZvzg9xXe8sbeESuFpjt8CJPTCa8mhEusweJqyFy8=
 github.com/libp2p/go-libp2p-swarm v0.1.0/go.mod h1:wQVsCdjsuZoc730CgOvh5ox6K8evllckjebkdiY5ta4=
-github.com/libp2p/go-libp2p-swarm v0.2.2 h1:T4hUpgEs2r371PweU3DuH7EOmBIdTBCwWs+FLcgx3bQ=
+github.com/libp2p/go-libp2p-swarm v0.2.1/go.mod h1:x07b4zkMFo2EvgPV2bMTlNmdQc8i+74Jjio7xGvsTgU=
 github.com/libp2p/go-libp2p-swarm v0.2.2/go.mod h1:fvmtQ0T1nErXym1/aa1uJEyN7JzaTNyBcHImCxRpPKU=
+github.com/libp2p/go-libp2p-swarm v0.2.3/go.mod h1:P2VO/EpxRyDxtChXz/VPVXyTnszHvokHKRhfkEgFKNM=
+github.com/libp2p/go-libp2p-swarm v0.2.4/go.mod h1:/xIpHFPPh3wmSthtxdGbkHZ0OET1h/GGZes8Wku/M5Y=
+github.com/libp2p/go-libp2p-swarm v0.2.7/go.mod h1:ZSJ0Q+oq/B1JgfPHJAT2HTall+xYRNYp1xs4S2FBWKA=
+github.com/libp2p/go-libp2p-swarm v0.2.8 h1:cIUUvytBzNQmGSjnXFlI6UpoBGsaud82mJPIJVfkDlg=
+github.com/libp2p/go-libp2p-swarm v0.2.8/go.mod h1:JQKMGSth4SMqonruY0a8yjlPVIkb0mdNSwckW7OYziM=
 github.com/libp2p/go-libp2p-testing v0.0.1/go.mod h1:gvchhf3FQOtBdr+eFUABet5a4MBLK8jM3V4Zghvmi+E=
 github.com/libp2p/go-libp2p-testing v0.0.2/go.mod h1:gvchhf3FQOtBdr+eFUABet5a4MBLK8jM3V4Zghvmi+E=
 github.com/libp2p/go-libp2p-testing v0.0.3/go.mod h1:gvchhf3FQOtBdr+eFUABet5a4MBLK8jM3V4Zghvmi+E=
 github.com/libp2p/go-libp2p-testing v0.0.4/go.mod h1:gvchhf3FQOtBdr+eFUABet5a4MBLK8jM3V4Zghvmi+E=
-github.com/libp2p/go-libp2p-testing v0.1.0 h1:WaFRj/t3HdMZGNZqnU2pS7pDRBmMeoDx7/HDNpeyT9U=
 github.com/libp2p/go-libp2p-testing v0.1.0/go.mod h1:xaZWMJrPUM5GlDBxCeGUi7kI4eqnjVyavGroI2nxEM0=
-github.com/libp2p/go-libp2p-tls v0.1.0 h1:o4bjjAdnUjNgJoPoDd0wUaZH7K+EenlNWJpgyXB3ulA=
-github.com/libp2p/go-libp2p-tls v0.1.0/go.mod h1:VZdoSWQDeNpIIAFJFv+6uqTqpnIIDHcqZQSTC/A1TT0=
+github.com/libp2p/go-libp2p-testing v0.1.1/go.mod h1:xaZWMJrPUM5GlDBxCeGUi7kI4eqnjVyavGroI2nxEM0=
+github.com/libp2p/go-libp2p-testing v0.1.2-0.20200422005655-8775583591d8 h1:v4dvk7YEW8buwCdIVWnhpv0Hp/AAJKRWIxBhmLRZrsk=
+github.com/libp2p/go-libp2p-testing v0.1.2-0.20200422005655-8775583591d8/go.mod h1:Qy8sAncLKpwXtS2dSnDOP8ktexIAHKu+J+pnZOFZLTc=
+github.com/libp2p/go-libp2p-tls v0.1.3 h1:twKMhMu44jQO+HgQK9X8NHO5HkeJu2QbhLzLJpa8oNM=
+github.com/libp2p/go-libp2p-tls v0.1.3/go.mod h1:wZfuewxOndz5RTnCAxFliGjvYSDA40sKitV4c50uI1M=
 github.com/libp2p/go-libp2p-transport v0.0.1/go.mod h1:UzbUs9X+PHOSw7S3ZmeOxfnwaQY5vGDzZmKPod3N3tk=
 github.com/libp2p/go-libp2p-transport v0.0.4/go.mod h1:StoY3sx6IqsP6XKoabsPnHCwqKXWUMWU7Rfcsubee/A=
 github.com/libp2p/go-libp2p-transport v0.0.5/go.mod h1:StoY3sx6IqsP6XKoabsPnHCwqKXWUMWU7Rfcsubee/A=
+github.com/libp2p/go-libp2p-transport-upgrader v0.0.1/go.mod h1:NJpUAgQab/8K6K0m+JmZCe5RUXG10UMEx4kWe9Ipj5c=
 github.com/libp2p/go-libp2p-transport-upgrader v0.0.4/go.mod h1:RGq+tupk+oj7PzL2kn/m1w6YXxcIAYJYeI90h6BGgUc=
-github.com/libp2p/go-libp2p-transport-upgrader v0.1.1 h1:PZMS9lhjK9VytzMCW3tWHAXtKXmlURSc3ZdvwEcKCzw=
 github.com/libp2p/go-libp2p-transport-upgrader v0.1.1/go.mod h1:IEtA6or8JUbsV07qPW4r01GnTenLW4oi3lOPbUMGJJA=
+github.com/libp2p/go-libp2p-transport-upgrader v0.2.0/go.mod h1:mQcrHj4asu6ArfSoMuyojOdjx73Q47cYD7s5+gZOlns=
+github.com/libp2p/go-libp2p-transport-upgrader v0.3.0 h1:q3ULhsknEQ34eVDhv4YwKS8iet69ffs9+Fir6a7weN4=
+github.com/libp2p/go-libp2p-transport-upgrader v0.3.0/go.mod h1:i+SKzbRnvXdVbU3D1dwydnTmKRPXiAR/fyvi1dXuL4o=
 github.com/libp2p/go-libp2p-yamux v0.1.2/go.mod h1:xUoV/RmYkg6BW/qGxA9XJyg+HzXFYkeXbnhjmnYzKp8=
 github.com/libp2p/go-libp2p-yamux v0.1.3/go.mod h1:VGSQVrqkh6y4nm0189qqxMtvyBft44MOYYPpYKXiVt4=
 github.com/libp2p/go-libp2p-yamux v0.2.0/go.mod h1:Db2gU+XfLpm6E4rG5uGCFX6uXA8MEXOxFcRoXUODaK8=
-github.com/libp2p/go-libp2p-yamux v0.2.1 h1:Q3XYNiKCC2vIxrvUJL+Jg1kiyeEaIDNKLjgEjo3VQdI=
 github.com/libp2p/go-libp2p-yamux v0.2.1/go.mod h1:1FBXiHDk1VyRM1C0aez2bCfHQ4vMZKkAQzZbkSQt5fI=
+github.com/libp2p/go-libp2p-yamux v0.2.2/go.mod h1:lIohaR0pT6mOt0AZ0L2dFze9hds9Req3OfS+B+dv4qw=
+github.com/libp2p/go-libp2p-yamux v0.2.5/go.mod h1:Zpgj6arbyQrmZ3wxSZxfBmbdnWtbZ48OpsfmQVTErwA=
+github.com/libp2p/go-libp2p-yamux v0.2.7/go.mod h1:X28ENrBMU/nm4I3Nx4sZ4dgjZ6VhLEn0XhIoZ5viCwU=
+github.com/libp2p/go-libp2p-yamux v0.2.8 h1:0s3ELSLu2O7hWKfX1YjzudBKCP0kZ+m9e2+0veXzkn4=
+github.com/libp2p/go-libp2p-yamux v0.2.8/go.mod h1:/t6tDqeuZf0INZMTgd0WxIRbtK2EzI2h7HbFm9eAKI4=
 github.com/libp2p/go-maddr-filter v0.0.1/go.mod h1:6eT12kSQMA9x2pvFQa+xesMKUBlj9VImZbj3B9FBH/Q=
 github.com/libp2p/go-maddr-filter v0.0.4/go.mod h1:6eT12kSQMA9x2pvFQa+xesMKUBlj9VImZbj3B9FBH/Q=
-github.com/libp2p/go-maddr-filter v0.0.5 h1:CW3AgbMO6vUvT4kf87y4N+0P8KUl2aqLYhrGyDUbLSg=
 github.com/libp2p/go-maddr-filter v0.0.5/go.mod h1:Jk+36PMfIqCJhAnaASRH83bdAvfDRp/w6ENFaC9bG+M=
+github.com/libp2p/go-maddr-filter v0.1.0 h1:4ACqZKw8AqiuJfwFGq1CYDFugfXTOos+qQ3DETkhtCE=
+github.com/libp2p/go-maddr-filter v0.1.0/go.mod h1:VzZhTXkMucEGGEOSKddrwGiOv0tUhgnKqNEmIAz/bPU=
+github.com/libp2p/go-mplex v0.0.1/go.mod h1:pK5yMLmOoBR1pNCqDlA2GQrdAVTMkqFalaTWe7l4Yd0=
 github.com/libp2p/go-mplex v0.0.3/go.mod h1:pK5yMLmOoBR1pNCqDlA2GQrdAVTMkqFalaTWe7l4Yd0=
 github.com/libp2p/go-mplex v0.0.4/go.mod h1:pK5yMLmOoBR1pNCqDlA2GQrdAVTMkqFalaTWe7l4Yd0=
-github.com/libp2p/go-mplex v0.1.0 h1:/nBTy5+1yRyY82YaO6HXQRnO5IAGsXTjEJaR3LdTPc0=
 github.com/libp2p/go-mplex v0.1.0/go.mod h1:SXgmdki2kwCUlCCbfGLEgHjC4pFqhTp0ZoV6aiKgxDU=
+github.com/libp2p/go-mplex v0.1.1/go.mod h1:Xgz2RDCi3co0LeZfgjm4OgUF15+sVR8SRcu3SFXI1lk=
+github.com/libp2p/go-mplex v0.1.2 h1:qOg1s+WdGLlpkrczDqmhYzyk3vCfsQ8+RxRTQjOZWwI=
+github.com/libp2p/go-mplex v0.1.2/go.mod h1:Xgz2RDCi3co0LeZfgjm4OgUF15+sVR8SRcu3SFXI1lk=
+github.com/libp2p/go-msgio v0.0.1/go.mod h1:63lBBgOTDKQL6EWazRMCwXsEeEeK9O2Cd+0+6OOuipQ=
 github.com/libp2p/go-msgio v0.0.2/go.mod h1:63lBBgOTDKQL6EWazRMCwXsEeEeK9O2Cd+0+6OOuipQ=
 github.com/libp2p/go-msgio v0.0.3/go.mod h1:63lBBgOTDKQL6EWazRMCwXsEeEeK9O2Cd+0+6OOuipQ=
-github.com/libp2p/go-msgio v0.0.4 h1:agEFehY3zWJFUHK6SEMR7UYmk2z6kC3oeCM7ybLhguA=
 github.com/libp2p/go-msgio v0.0.4/go.mod h1:63lBBgOTDKQL6EWazRMCwXsEeEeK9O2Cd+0+6OOuipQ=
+github.com/libp2p/go-msgio v0.0.6 h1:lQ7Uc0kS1wb1EfRxO2Eir/RJoHkHn7t6o+EiwsYIKJA=
+github.com/libp2p/go-msgio v0.0.6/go.mod h1:4ecVB6d9f4BDSL5fqvPiC4A3KivjWn+Venn/1ALLMWA=
 github.com/libp2p/go-nat v0.0.3/go.mod h1:88nUEt0k0JD45Bk93NIwDqjlhiOwOoV36GchpcVc1yI=
-github.com/libp2p/go-nat v0.0.4 h1:KbizNnq8YIf7+Hn7+VFL/xE0eDrkPru2zIO9NMwL8UQ=
 github.com/libp2p/go-nat v0.0.4/go.mod h1:Nmw50VAvKuk38jUBcmNh6p9lUJLoODbJRvYAa/+KSDo=
+github.com/libp2p/go-nat v0.0.5 h1:qxnwkco8RLKqVh1NmjQ+tJ8p8khNLFxuElYG/TwqW4Q=
+github.com/libp2p/go-nat v0.0.5/go.mod h1:B7NxsVNPZmRLvMOwiEO1scOSyjA56zxYAGv1yQgRkEU=
+github.com/libp2p/go-netroute v0.1.2/go.mod h1:jZLDV+1PE8y5XxBySEBgbuVAXbhtuHSdmLPL2n9MKbk=
+github.com/libp2p/go-netroute v0.1.3 h1:1ngWRx61us/EpaKkdqkMjKk/ufr/JlIFYQAxV2XX8Ig=
+github.com/libp2p/go-netroute v0.1.3/go.mod h1:jZLDV+1PE8y5XxBySEBgbuVAXbhtuHSdmLPL2n9MKbk=
 github.com/libp2p/go-openssl v0.0.2/go.mod h1:v8Zw2ijCSWBQi8Pq5GAixw6DbFfa9u6VIYDXnvOXkc0=
-github.com/libp2p/go-openssl v0.0.3 h1:wjlG7HvQkt4Fq4cfH33Ivpwp0omaElYEi9z26qaIkIk=
 github.com/libp2p/go-openssl v0.0.3/go.mod h1:unDrJpgy3oFr+rqXsarWifmJuNnJR4chtO1HmaZjggc=
-github.com/libp2p/go-reuseport v0.0.1 h1:7PhkfH73VXfPJYKQ6JwS5I/eVcoyYi9IMNGc6FWpFLw=
+github.com/libp2p/go-openssl v0.0.4/go.mod h1:unDrJpgy3oFr+rqXsarWifmJuNnJR4chtO1HmaZjggc=
+github.com/libp2p/go-openssl v0.0.5/go.mod h1:unDrJpgy3oFr+rqXsarWifmJuNnJR4chtO1HmaZjggc=
+github.com/libp2p/go-openssl v0.0.7 h1:eCAzdLejcNVBzP/iZM9vqHnQm+XyCEbSSIheIPRGNsw=
+github.com/libp2p/go-openssl v0.0.7/go.mod h1:unDrJpgy3oFr+rqXsarWifmJuNnJR4chtO1HmaZjggc=
 github.com/libp2p/go-reuseport v0.0.1/go.mod h1:jn6RmB1ufnQwl0Q1f+YxAj8isJgDCQzaaxIFYDhcYEA=
-github.com/libp2p/go-reuseport-transport v0.0.2 h1:WglMwyXyBu61CMkjCCtnmqNqnjib0GIEjMiHTwR/KN4=
+github.com/libp2p/go-reuseport v0.0.2 h1:XSG94b1FJfGA01BUrT82imejHQyTxO4jEWqheyCXYvU=
+github.com/libp2p/go-reuseport v0.0.2/go.mod h1:SPD+5RwGC7rcnzngoYC86GjPzjSywuQyMVAheVBD9nQ=
+github.com/libp2p/go-reuseport-transport v0.0.1/go.mod h1:YkbSDrvjUVDL6b8XqriyA20obEtsW9BLkuOUyQAOCbs=
 github.com/libp2p/go-reuseport-transport v0.0.2/go.mod h1:YkbSDrvjUVDL6b8XqriyA20obEtsW9BLkuOUyQAOCbs=
+github.com/libp2p/go-reuseport-transport v0.0.3/go.mod h1:Spv+MPft1exxARzP2Sruj2Wb5JSyHNncjf1Oi2dEbzM=
+github.com/libp2p/go-reuseport-transport v0.0.4 h1:OZGz0RB620QDGpv300n1zaOcKGGAoGVf8h9txtt/1uM=
+github.com/libp2p/go-reuseport-transport v0.0.4/go.mod h1:trPa7r/7TJK/d+0hdBLOCGvpQQVOU74OXbNCIMkufGw=
+github.com/libp2p/go-sockaddr v0.0.2/go.mod h1:syPvOmNs24S3dFVGJA1/mrqdeijPxLV2Le3BRLKd68k=
+github.com/libp2p/go-sockaddr v0.1.0 h1:Y4s3/jNoryVRKEBrkJ576F17CPOaMIzUeCsg7dlTDj0=
+github.com/libp2p/go-sockaddr v0.1.0/go.mod h1:syPvOmNs24S3dFVGJA1/mrqdeijPxLV2Le3BRLKd68k=
 github.com/libp2p/go-stream-muxer v0.0.1/go.mod h1:bAo8x7YkSpadMTbtTaxGVHWUQsR/l5MEaHbKaliuT14=
 github.com/libp2p/go-stream-muxer v0.1.0/go.mod h1:8JAVsjeRBCWwPoZeH0W1imLOcriqXJyFvB0mR4A04sQ=
 github.com/libp2p/go-stream-muxer-multistream v0.1.1/go.mod h1:zmGdfkQ1AzOECIAcccoL8L//laqawOsO03zX8Sa+eGw=
-github.com/libp2p/go-stream-muxer-multistream v0.2.0 h1:714bRJ4Zy9mdhyTLJ+ZKiROmAFwUHpeRidG+q7LTQOg=
 github.com/libp2p/go-stream-muxer-multistream v0.2.0/go.mod h1:j9eyPol/LLRqT+GPLSxvimPhNph4sfYfMoDPd7HkzIc=
+github.com/libp2p/go-stream-muxer-multistream v0.3.0 h1:TqnSHPJEIqDEO7h1wZZ0p3DXdvDSiLHQidKKUGZtiOY=
+github.com/libp2p/go-stream-muxer-multistream v0.3.0/go.mod h1:yDh8abSIzmZtqtOt64gFJUXEryejzNb0lisTt+fAMJA=
+github.com/libp2p/go-tcp-transport v0.0.1/go.mod h1:mnjg0o0O5TmXUaUIanYPUqkW4+u6mK0en8rlpA6BBTs=
 github.com/libp2p/go-tcp-transport v0.0.4/go.mod h1:+E8HvC8ezEVOxIo3V5vCK9l1y/19K427vCzQ+xHKH/o=
 github.com/libp2p/go-tcp-transport v0.1.0/go.mod h1:oJ8I5VXryj493DEJ7OsBieu8fcg2nHGctwtInJVpipc=
-github.com/libp2p/go-tcp-transport v0.1.1 h1:yGlqURmqgNA2fvzjSgZNlHcsd/IulAnKM8Ncu+vlqnw=
 github.com/libp2p/go-tcp-transport v0.1.1/go.mod h1:3HzGvLbx6etZjnFlERyakbaYPdfjg2pWP97dFZworkY=
+github.com/libp2p/go-tcp-transport v0.2.0/go.mod h1:vX2U0CnWimU4h0SGSEsg++AzvBcroCGYw28kh94oLe0=
+github.com/libp2p/go-tcp-transport v0.2.1 h1:ExZiVQV+h+qL16fzCWtd1HSzPsqWottJ8KXwWaVi8Ns=
+github.com/libp2p/go-tcp-transport v0.2.1/go.mod h1:zskiJ70MEfWz2MKxvFB/Pv+tPIB1PpPUrHIWQ8aFw7M=
 github.com/libp2p/go-testutil v0.0.1/go.mod h1:iAcJc/DKJQanJ5ws2V+u5ywdL2n12X1WbbEG+Jjy69I=
 github.com/libp2p/go-testutil v0.1.0/go.mod h1:81b2n5HypcVyrCg/MJx4Wgfp/VHojytjVe/gLzZ2Ehc=
+github.com/libp2p/go-ws-transport v0.0.1/go.mod h1:p3bKjDWHEgtuKKj+2OdPYs5dAPIjtpQGHF2tJfGz7Ww=
 github.com/libp2p/go-ws-transport v0.0.5/go.mod h1:Qbl4BxPfXXhhd/o0wcrgoaItHqA9tnZjoFZnxykuaXU=
 github.com/libp2p/go-ws-transport v0.1.0/go.mod h1:rjw1MG1LU9YDC6gzmwObkPd/Sqwhw7yT74kj3raBFuo=
-github.com/libp2p/go-ws-transport v0.1.2 h1:VnxQcLfSGtqupqPpBNu8fUiCv+IN1RJ2BcVqQEM+z8E=
 github.com/libp2p/go-ws-transport v0.1.2/go.mod h1:dsh2Ld8F+XNmzpkaAijmg5Is+e9l6/1tK/6VFOdN69Y=
+github.com/libp2p/go-ws-transport v0.2.0/go.mod h1:9BHJz/4Q5A9ludYWKoGCFC5gUElzlHoKzu0yY9p/klM=
+github.com/libp2p/go-ws-transport v0.3.0/go.mod h1:bpgTJmRZAvVHrgHybCVyqoBmyLQ1fiZuEaBYusP5zsk=
+github.com/libp2p/go-ws-transport v0.3.1 h1:ZX5rWB8nhRRJVaPO6tmkGI/Xx8XNboYX20PW5hXIscw=
+github.com/libp2p/go-ws-transport v0.3.1/go.mod h1:bpgTJmRZAvVHrgHybCVyqoBmyLQ1fiZuEaBYusP5zsk=
 github.com/libp2p/go-yamux v1.2.1/go.mod h1:FGTiPvoV/3DVdgWpX+tM0OW3tsM+W5bSE3gZwqQTcow=
 github.com/libp2p/go-yamux v1.2.2/go.mod h1:FGTiPvoV/3DVdgWpX+tM0OW3tsM+W5bSE3gZwqQTcow=
-github.com/libp2p/go-yamux v1.2.3 h1:xX8A36vpXb59frIzWFdEgptLMsOANMFq2K7fPRlunYI=
 github.com/libp2p/go-yamux v1.2.3/go.mod h1:FGTiPvoV/3DVdgWpX+tM0OW3tsM+W5bSE3gZwqQTcow=
-github.com/lucas-clemente/quic-go v0.11.2 h1:Mop0ac3zALaBR3wGs6j8OYe/tcFvFsxTUFMkE/7yUOI=
+github.com/libp2p/go-yamux v1.3.0/go.mod h1:FGTiPvoV/3DVdgWpX+tM0OW3tsM+W5bSE3gZwqQTcow=
+github.com/libp2p/go-yamux v1.3.3/go.mod h1:FGTiPvoV/3DVdgWpX+tM0OW3tsM+W5bSE3gZwqQTcow=
+github.com/libp2p/go-yamux v1.3.5/go.mod h1:FGTiPvoV/3DVdgWpX+tM0OW3tsM+W5bSE3gZwqQTcow=
+github.com/libp2p/go-yamux v1.3.6/go.mod h1:FGTiPvoV/3DVdgWpX+tM0OW3tsM+W5bSE3gZwqQTcow=
+github.com/libp2p/go-yamux v1.3.7 h1:v40A1eSPJDIZwz2AvrV3cxpTZEGDP11QJbukmEhYyQI=
+github.com/libp2p/go-yamux v1.3.7/go.mod h1:fr7aVgmdNGJK+N1g+b6DW6VxzbRCjCOejR/hkmpooHE=
+github.com/lightstep/lightstep-tracer-common/golang/gogo v0.0.0-20190605223551-bc2310a04743/go.mod h1:qklhhLq1aX+mtWk9cPHPzaBjWImj5ULL6C7HFJtXQMM=
+github.com/lightstep/lightstep-tracer-go v0.18.1/go.mod h1:jlF1pusYV4pidLvZ+XD0UBX0ZE6WURAspgAczcDHrL4=
 github.com/lucas-clemente/quic-go v0.11.2/go.mod h1:PpMmPfPKO9nKJ/psF49ESTAGQSdfXxlg1otPbEB2nOw=
+github.com/lucas-clemente/quic-go v0.16.0/go.mod h1:I0+fcNTdb9eS1ZcjQZbDVPGchJ86chcIxPALn9lEJqE=
+github.com/lucas-clemente/quic-go v0.18.0 h1:JhQDdqxdwdmGdKsKgXi1+coHRoGhvU6z0rNzOJqZ/4o=
+github.com/lucas-clemente/quic-go v0.18.0/go.mod h1:yXttHsSNxQi8AWijC/vLP+OJczXqzHSOcJrM5ITUlCg=
+github.com/lufia/iostat v1.1.0/go.mod h1:rEPNA0xXgjHQjuI5Cy05sLlS2oRcSlWHRLrvh/AQ+Pg=
+github.com/lunixbochs/vtclean v1.0.0/go.mod h1:pHhQNgMf3btfWnGBVipUOjRYhoOsdGqdm/+2c2E2WMI=
+github.com/lyft/protoc-gen-validate v0.0.13/go.mod h1:XbGvPuh87YZc5TdIa2/I4pLk0QoUACkjt2znoq26NVQ=
 github.com/magiconair/properties v1.8.0/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ=
 github.com/mailru/easyjson v0.0.0-20180823135443-60711f1a8329/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc=
-github.com/marten-seemann/qtls v0.2.3 h1:0yWJ43C62LsZt08vuQJDK1uC1czUc3FJeCLPoNAI4vA=
+github.com/mailru/easyjson v0.0.0-20190312143242-1de009706dbe/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc=
+github.com/marten-seemann/qpack v0.1.0/go.mod h1:LFt1NU/Ptjip0C2CPkhimBz5CGE3WGDAUWqna+CNTrI=
+github.com/marten-seemann/qpack v0.2.0/go.mod h1:F7Gl5L1jIgN1D11ucXefiuJS9UMVP2opoCp2jDKb7wc=
 github.com/marten-seemann/qtls v0.2.3/go.mod h1:xzjG7avBwGGbdZ8dTGxlBnLArsVKLvwmjgmPuiQEcYk=
+github.com/marten-seemann/qtls v0.9.1/go.mod h1:T1MmAdDPyISzxlK6kjRr0pcZFBVd1OZbBb/j3cvzHhk=
+github.com/marten-seemann/qtls v0.10.0 h1:ECsuYUKalRL240rRD4Ri33ISb7kAQ3qGDlrrl55b2pc=
+github.com/marten-seemann/qtls v0.10.0/go.mod h1:UvMd1oaYDACI99/oZUYLzMCkBXQVT0aGm99sJhbT8hs=
+github.com/marten-seemann/qtls-go1-15 v0.1.0 h1:i/YPXVxz8q9umso/5y474CNcHmTpA+5DH+mFPjx6PZg=
+github.com/marten-seemann/qtls-go1-15 v0.1.0/go.mod h1:GyFwywLKkRt+6mfU99csTEY1joMZz5vmB1WNZH3P81I=
 github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU=
 github.com/mattn/go-colorable v0.1.1/go.mod h1:FuOcm+DKB9mbwrcAfNl7/TZVBZ6rcnceauSikq3lYCQ=
-github.com/mattn/go-colorable v0.1.2 h1:/bC9yWikZXAL9uJdulbSfyVNIR3n3trXl+v8+1sx8mU=
 github.com/mattn/go-colorable v0.1.2/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE=
 github.com/mattn/go-colorable v0.1.4 h1:snbPLB8fVfU9iwbbo30TPtbLRzwWu6aJS6Xh4eaaviA=
 github.com/mattn/go-colorable v0.1.4/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE=
 github.com/mattn/go-isatty v0.0.3/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4=
 github.com/mattn/go-isatty v0.0.4/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4=
 github.com/mattn/go-isatty v0.0.5/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
+github.com/mattn/go-isatty v0.0.8 h1:HLtExJ+uU2HOZ+wI0Tt5DtUDrx8yhUqDcp7fYERX4CE=
 github.com/mattn/go-isatty v0.0.8/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
-github.com/mattn/go-isatty v0.0.9 h1:d5US/mDsogSGW37IV293h//ZFaeajb69h+EHFsv2xGg=
-github.com/mattn/go-isatty v0.0.9/go.mod h1:YNRxwqDuOph6SZLI9vUUz6OYw3QyUt7WiY2yME+cCiQ=
+github.com/mattn/go-runewidth v0.0.2/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU=
 github.com/mattn/go-runewidth v0.0.7 h1:Ei8KR0497xHyKJPAv59M1dkC+rOZCMBJ+t3fZ+twI54=
 github.com/mattn/go-runewidth v0.0.7/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
-github.com/mattn/go-sqlite3 v1.12.0 h1:u/x3mp++qUxvYfulZ4HKOvVO0JWhk7HtE8lWhbGz/Do=
-github.com/mattn/go-sqlite3 v1.12.0/go.mod h1:FPy6KqzDD04eiIsT53CuJW3U88zkxoIYsOqkbpncsNc=
+github.com/mattn/go-xmlrpc v0.0.3/go.mod h1:mqc2dz7tP5x5BKlCahN/n+hs7OSZKJkS9JsHNBRlrxA=
+github.com/matttproud/golang_protobuf_extensions v1.0.1 h1:4hp9jkHxhMHkqkrB3Ix0jegS5sx/RkqARlsWZ6pIwiU=
 github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=
+github.com/mdlayher/genetlink v1.0.0/go.mod h1:0rJ0h4itni50A86M2kHcgS85ttZazNt7a8H2a2cw0Gc=
+github.com/mdlayher/netlink v0.0.0-20190409211403-11939a169225/go.mod h1:eQB3mZE4aiYnlUsyGGCOpPETfdQq4Jhsgf1fk3cwQaA=
+github.com/mdlayher/netlink v0.0.0-20190828143259-340058475d09/go.mod h1:KxeJAFOFLG6AjpyDkQ/iIhxygIUKD+vcwqcnu43w/+M=
+github.com/mdlayher/netlink v1.0.0/go.mod h1:KxeJAFOFLG6AjpyDkQ/iIhxygIUKD+vcwqcnu43w/+M=
+github.com/mdlayher/netlink v1.1.0/go.mod h1:H4WCitaheIsdF9yOYu8CFmCgQthAPIWZmcKp9uZHgmY=
+github.com/mdlayher/wifi v0.0.0-20190303161829-b1436901ddee/go.mod h1:Evt/EIne46u9PtQbeTx2NTcqURpr5K4SvKtGmBuDPN8=
 github.com/mgutz/ansi v0.0.0-20170206155736-9520e82c474b/go.mod h1:01TrycV0kFyexm33Z7vhZRXopbI8J3TDReVlkTgMUxE=
+github.com/microcosm-cc/bluemonday v1.0.1/go.mod h1:hsXNsILzKxV+sX77C5b8FSuKF00vh2OMYv+xgHpAMF4=
+github.com/miekg/dns v1.0.14/go.mod h1:W1PPwlIAgtquWBMBEV9nkV9Cazfe8ScdGz/Lj7v3Nrg=
+github.com/miekg/dns v1.1.4/go.mod h1:W1PPwlIAgtquWBMBEV9nkV9Cazfe8ScdGz/Lj7v3Nrg=
 github.com/miekg/dns v1.1.12/go.mod h1:W1PPwlIAgtquWBMBEV9nkV9Cazfe8ScdGz/Lj7v3Nrg=
+github.com/miekg/dns v1.1.28/go.mod h1:KNUDUusw/aVsxyTYZM1oqvCicbwhgbNgztCETuNZ7xM=
+github.com/miekg/dns v1.1.31/go.mod h1:KNUDUusw/aVsxyTYZM1oqvCicbwhgbNgztCETuNZ7xM=
 github.com/minio/blake2b-simd v0.0.0-20160723061019-3f5f724cb5b1 h1:lYpkrQH5ajf0OXOcUbGjvZxxijuBwbbmlSxLiuofa+g=
 github.com/minio/blake2b-simd v0.0.0-20160723061019-3f5f724cb5b1/go.mod h1:pD8RvIylQ358TN4wwqatJ8rNavkEINozVn9DtGI3dfQ=
 github.com/minio/sha256-simd v0.0.0-20190131020904-2d45a736cd16/go.mod h1:2FMWW+8GMoPweT6+pI63m9YE3Lmw4J71hV56Chs1E/U=
@@ -523,24 +1042,44 @@ github.com/minio/sha256-simd v0.1.0/go.mod h1:2FMWW+8GMoPweT6+pI63m9YE3Lmw4J71hV
 github.com/minio/sha256-simd v0.1.1-0.20190913151208-6de447530771/go.mod h1:B5e1o+1/KgNmWrSQK08Y6Z1Vb5pwIktudl0J58iy0KM=
 github.com/minio/sha256-simd v0.1.1 h1:5QHSlgo3nt5yKOJrC7W8w7X+NFl8cMPZm96iu8kKUJU=
 github.com/minio/sha256-simd v0.1.1/go.mod h1:B5e1o+1/KgNmWrSQK08Y6Z1Vb5pwIktudl0J58iy0KM=
+github.com/mitchellh/cli v1.0.0/go.mod h1:hNIlj7HEI86fIcpObd7a0FcrxTWetlwJDGcceTlRvqc=
+github.com/mitchellh/go-homedir v1.0.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
 github.com/mitchellh/go-homedir v1.1.0 h1:lukF9ziXFxDFPkA1vsr5zpc1XuPDn/wFntq5mG+4E0Y=
 github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
+github.com/mitchellh/go-testing-interface v1.0.0/go.mod h1:kRemZodwjscx+RGhAo8eIhFbs2+BFgRtFPeD/KE+zxI=
+github.com/mitchellh/gox v0.4.0/go.mod h1:Sd9lOJ0+aimLBi73mGofS1ycjY8lL3uZM3JPS42BGNg=
+github.com/mitchellh/iochan v1.0.0/go.mod h1:JwYml1nuB7xOzsp52dPpHFffvOCDupsG0QubkSMEySY=
+github.com/mitchellh/mapstructure v0.0.0-20160808181253-ca63d7c062ee/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
 github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
+github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
+github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
+github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
+github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
 github.com/mr-tron/base58 v1.1.0/go.mod h1:xcD2VGqlgYjBdcBLw+TuYLr8afG+Hj8g2eTVqeSzSU8=
 github.com/mr-tron/base58 v1.1.1/go.mod h1:xcD2VGqlgYjBdcBLw+TuYLr8afG+Hj8g2eTVqeSzSU8=
 github.com/mr-tron/base58 v1.1.2/go.mod h1:BinMc/sQntlIE1frQmRFPUoPA1Zkr8VRgBdjWI2mNwc=
-github.com/mr-tron/base58 v1.1.3 h1:v+sk57XuaCKGXpWtVBX8YJzO7hMGx4Aajh4TQbdEFdc=
 github.com/mr-tron/base58 v1.1.3/go.mod h1:BinMc/sQntlIE1frQmRFPUoPA1Zkr8VRgBdjWI2mNwc=
+github.com/mr-tron/base58 v1.2.0 h1:T/HDJBh4ZCPbU39/+c3rRvE0uKBQlU27+QI8LJ4t64o=
+github.com/mr-tron/base58 v1.2.0/go.mod h1:BinMc/sQntlIE1frQmRFPUoPA1Zkr8VRgBdjWI2mNwc=
 github.com/multiformats/go-base32 v0.0.3 h1:tw5+NhuwaOjJCC5Pp82QuXbrmLzWg7uxlMFp8Nq/kkI=
 github.com/multiformats/go-base32 v0.0.3/go.mod h1:pLiuGC8y0QR3Ue4Zug5UzK9LjgbkL8NSQj0zQ5Nz/AA=
+github.com/multiformats/go-base36 v0.1.0 h1:JR6TyF7JjGd3m6FbLU2cOxhC0Li8z8dLNGQ89tUg4F4=
+github.com/multiformats/go-base36 v0.1.0/go.mod h1:kFGE83c6s80PklsHO9sRn2NCoffoRdUUOENyW/Vv6sM=
 github.com/multiformats/go-multiaddr v0.0.1/go.mod h1:xKVEak1K9cS1VdmPZW3LSIb6lgmoS58qz/pzqmAxV44=
 github.com/multiformats/go-multiaddr v0.0.2/go.mod h1:xKVEak1K9cS1VdmPZW3LSIb6lgmoS58qz/pzqmAxV44=
 github.com/multiformats/go-multiaddr v0.0.4/go.mod h1:xKVEak1K9cS1VdmPZW3LSIb6lgmoS58qz/pzqmAxV44=
 github.com/multiformats/go-multiaddr v0.1.0/go.mod h1:xKVEak1K9cS1VdmPZW3LSIb6lgmoS58qz/pzqmAxV44=
-github.com/multiformats/go-multiaddr v0.1.1 h1:rVAztJYMhCQ7vEFr8FvxW3mS+HF2eY/oPbOMeS0ZDnE=
 github.com/multiformats/go-multiaddr v0.1.1/go.mod h1:aMKBKNEYmzmDmxfX88/vz+J5IU55txyt0p4aiWVohjo=
+github.com/multiformats/go-multiaddr v0.2.0/go.mod h1:0nO36NvPpyV4QzvTLi/lafl2y95ncPj0vFwVF6k6wJ4=
+github.com/multiformats/go-multiaddr v0.2.1/go.mod h1:s/Apk6IyxfvMjDafnhJgJ3/46z7tZ04iMk5wP4QMGGE=
+github.com/multiformats/go-multiaddr v0.2.2/go.mod h1:NtfXiOtHvghW9KojvtySjH5y0u0xW5UouOmQQrn6a3Y=
+github.com/multiformats/go-multiaddr v0.3.0/go.mod h1:dF9kph9wfJ+3VLAaeBqo9Of8x4fJxp6ggJGteB8HQTI=
+github.com/multiformats/go-multiaddr v0.3.1 h1:1bxa+W7j9wZKTZREySx1vPMs2TqrYWjVZ7zE6/XLG1I=
+github.com/multiformats/go-multiaddr v0.3.1/go.mod h1:uPbspcUPd5AfaP6ql3ujFY+QWzmBD8uLLL4bXW0XfGc=
 github.com/multiformats/go-multiaddr-dns v0.0.1/go.mod h1:9kWcqw/Pj6FwxAwW38n/9403szc57zJPs45fmnznu3Q=
 github.com/multiformats/go-multiaddr-dns v0.0.2/go.mod h1:9kWcqw/Pj6FwxAwW38n/9403szc57zJPs45fmnznu3Q=
+github.com/multiformats/go-multiaddr-dns v0.0.3/go.mod h1:9kWcqw/Pj6FwxAwW38n/9403szc57zJPs45fmnznu3Q=
+github.com/multiformats/go-multiaddr-dns v0.1.0/go.mod h1:01k2RAqtoXIuPa3DCavAE9/6jc6nM0H3EgZyfUhN2oY=
 github.com/multiformats/go-multiaddr-dns v0.2.0 h1:YWJoIDwLePniH7OU5hBnDZV6SWuvJqJ0YtN6pLeH9zA=
 github.com/multiformats/go-multiaddr-dns v0.2.0/go.mod h1:TJ5pr5bBO7Y1B18djPuRsVkduhQH2YqYSbxWJzYGdK0=
 github.com/multiformats/go-multiaddr-fmt v0.0.1/go.mod h1:aBYjqL4T/7j4Qx+R73XSv/8JsgnRFlf0w2KGLCmXl3Q=
@@ -548,50 +1087,101 @@ github.com/multiformats/go-multiaddr-fmt v0.1.0 h1:WLEFClPycPkp4fnIzoFoV9FVd49/e
 github.com/multiformats/go-multiaddr-fmt v0.1.0/go.mod h1:hGtDIW4PU4BqJ50gW2quDuPVjyWNZxToGUh/HwTZYJo=
 github.com/multiformats/go-multiaddr-net v0.0.1/go.mod h1:nw6HSxNmCIQH27XPGBuX+d1tnvM7ihcFwHMSstNAVUU=
 github.com/multiformats/go-multiaddr-net v0.1.0/go.mod h1:5JNbcfBOP4dnhoZOv10JJVkJO0pCCEf8mTnipAo2UZQ=
-github.com/multiformats/go-multiaddr-net v0.1.1 h1:jFFKUuXTXv+3ARyHZi3XUqQO+YWMKgBdhEvuGRfnL6s=
 github.com/multiformats/go-multiaddr-net v0.1.1/go.mod h1:5JNbcfBOP4dnhoZOv10JJVkJO0pCCEf8mTnipAo2UZQ=
-github.com/multiformats/go-multibase v0.0.1 h1:PN9/v21eLywrFWdFNsFKaU04kLJzuYzmrJR+ubhT9qA=
+github.com/multiformats/go-multiaddr-net v0.1.2/go.mod h1:QsWt3XK/3hwvNxZJp92iMQKME1qHfpYmyIjFVsSOY6Y=
+github.com/multiformats/go-multiaddr-net v0.1.3/go.mod h1:ilNnaM9HbmVFqsb/qcNysjCu4PVONlrBZpHIrw/qQuA=
+github.com/multiformats/go-multiaddr-net v0.1.4/go.mod h1:ilNnaM9HbmVFqsb/qcNysjCu4PVONlrBZpHIrw/qQuA=
+github.com/multiformats/go-multiaddr-net v0.1.5/go.mod h1:ilNnaM9HbmVFqsb/qcNysjCu4PVONlrBZpHIrw/qQuA=
+github.com/multiformats/go-multiaddr-net v0.2.0 h1:MSXRGN0mFymt6B1yo/6BPnIRpLPEnKgQNvVfCX5VDJk=
+github.com/multiformats/go-multiaddr-net v0.2.0/go.mod h1:gGdH3UXny6U3cKKYCvpXI5rnK7YaOIEOPVDI9tsJbEA=
 github.com/multiformats/go-multibase v0.0.1/go.mod h1:bja2MqRZ3ggyXtZSEDKpl0uO/gviWFaSteVbWT51qgs=
+github.com/multiformats/go-multibase v0.0.2/go.mod h1:bja2MqRZ3ggyXtZSEDKpl0uO/gviWFaSteVbWT51qgs=
+github.com/multiformats/go-multibase v0.0.3 h1:l/B6bJDQjvQ5G52jw4QGSYeOTZoAwIO77RblWplfIqk=
+github.com/multiformats/go-multibase v0.0.3/go.mod h1:5+1R4eQrT3PkYZ24C3W2Ue2tPwIdYQD509ZjSb5y9Oc=
 github.com/multiformats/go-multihash v0.0.1/go.mod h1:w/5tugSrLEbWqlcgJabL3oHFKTwfvkofsjW2Qa1ct4U=
 github.com/multiformats/go-multihash v0.0.5/go.mod h1:lt/HCbqlQwlPBz7lv0sQCdtfcMtlJvakRUn/0Ual8po=
+github.com/multiformats/go-multihash v0.0.7/go.mod h1:XuKXPp8VHcTygube3OWZC+aZrA+H1IhmjoCDtJc7PXM=
 github.com/multiformats/go-multihash v0.0.8/go.mod h1:YSLudS+Pi8NHE7o6tb3D8vrpKa63epEDmG8nTduyAew=
 github.com/multiformats/go-multihash v0.0.9/go.mod h1:YSLudS+Pi8NHE7o6tb3D8vrpKa63epEDmG8nTduyAew=
-github.com/multiformats/go-multihash v0.0.10 h1:lMoNbh2Ssd9PUF74Nz008KGzGPlfeV6wH3rit5IIGCM=
 github.com/multiformats/go-multihash v0.0.10/go.mod h1:YSLudS+Pi8NHE7o6tb3D8vrpKa63epEDmG8nTduyAew=
+github.com/multiformats/go-multihash v0.0.13/go.mod h1:VdAWLKTwram9oKAatUcLxBNUjdtcVwxObEQBtRfuyjc=
+github.com/multiformats/go-multihash v0.0.14 h1:QoBceQYQQtNUuf6s7wHxnE2c8bhbMqhfGzNI032se/I=
+github.com/multiformats/go-multihash v0.0.14/go.mod h1:VdAWLKTwram9oKAatUcLxBNUjdtcVwxObEQBtRfuyjc=
 github.com/multiformats/go-multistream v0.0.1/go.mod h1:fJTiDfXJVmItycydCnNx4+wSzZ5NwG2FEVAI30fiovg=
 github.com/multiformats/go-multistream v0.0.4/go.mod h1:fJTiDfXJVmItycydCnNx4+wSzZ5NwG2FEVAI30fiovg=
-github.com/multiformats/go-multistream v0.1.0 h1:UpO6jrsjqs46mqAK3n6wKRYFhugss9ArzbyUzU+4wkQ=
 github.com/multiformats/go-multistream v0.1.0/go.mod h1:fJTiDfXJVmItycydCnNx4+wSzZ5NwG2FEVAI30fiovg=
+github.com/multiformats/go-multistream v0.1.1/go.mod h1:KmHZ40hzVxiaiwlj3MEbYgK9JFk2/9UktWZAF54Du38=
+github.com/multiformats/go-multistream v0.1.2 h1:knyamLYMPFPngQjGQ0lhnlys3jtVR/3xV6TREUJr+fE=
+github.com/multiformats/go-multistream v0.1.2/go.mod h1:5GZPQZbkWOLOn3J2y4Y99vVW7vOfsAflxARk3x14o6k=
 github.com/multiformats/go-varint v0.0.1/go.mod h1:3Ls8CIEsrijN6+B7PbrXRPxHRPuXSrVKRY101jdMZYE=
-github.com/multiformats/go-varint v0.0.2 h1:6sUvyh2YHpJCb8RZ6eYzj6iJQ4+chWYmyIHxszqlPTA=
 github.com/multiformats/go-varint v0.0.2/go.mod h1:3Ls8CIEsrijN6+B7PbrXRPxHRPuXSrVKRY101jdMZYE=
+github.com/multiformats/go-varint v0.0.5/go.mod h1:3Ls8CIEsrijN6+B7PbrXRPxHRPuXSrVKRY101jdMZYE=
+github.com/multiformats/go-varint v0.0.6 h1:gk85QWKxh3TazbLxED/NlDVv8+q+ReFJk7Y2W/KhfNY=
+github.com/multiformats/go-varint v0.0.6/go.mod h1:3Ls8CIEsrijN6+B7PbrXRPxHRPuXSrVKRY101jdMZYE=
 github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
+github.com/nats-io/jwt v0.3.0/go.mod h1:fRYCDE99xlTsqUzISS1Bi75UBJ6ljOJQOAAu5VglpSg=
+github.com/nats-io/jwt v0.3.2/go.mod h1:/euKqTS1ZD+zzjYrY7pseZrTtWQSjujC7xjPc8wL6eU=
+github.com/nats-io/nats-server/v2 v2.1.2/go.mod h1:Afk+wRZqkMQs/p45uXdrVLuab3gwv3Z8C4HTBu8GD/k=
+github.com/nats-io/nats.go v1.9.1/go.mod h1:ZjDU1L/7fJ09jvUSRVBR2e7+RnLiiIQyqyzEE/Zbp4w=
+github.com/nats-io/nkeys v0.1.0/go.mod h1:xpnFELMwJABBLVhffcfd1MZx6VsNRFpEugbxziKVo7w=
+github.com/nats-io/nkeys v0.1.3/go.mod h1:xpnFELMwJABBLVhffcfd1MZx6VsNRFpEugbxziKVo7w=
+github.com/nats-io/nuid v1.0.1/go.mod h1:19wcPz3Ph3q0Jbyiqsd0kePYG7A95tJPxeL+1OSON2c=
+github.com/neelance/astrewrite v0.0.0-20160511093645-99348263ae86/go.mod h1:kHJEU3ofeGjhHklVoIGuVj85JJwZ6kWPaJwCIxgnFmo=
+github.com/neelance/sourcemap v0.0.0-20151028013722-8c68805598ab/go.mod h1:Qr6/a/Q4r9LP1IltGz7tA7iOK1WonHEYhu1HRBA7ZiM=
+github.com/nikkolasg/hexjson v0.0.0-20181101101858-78e39397e00c h1:5bFTChQxSKNwy8ALwOebjekYExl9HTT9urdawqC95tA=
+github.com/nikkolasg/hexjson v0.0.0-20181101101858-78e39397e00c/go.mod h1:7qN3Y0BvzRUf4LofcoJplQL10lsFDb4PYlePTVwrP28=
 github.com/nkovacs/streamquote v0.0.0-20170412213628-49af9bddb229 h1:E2B8qYyeSgv5MXpmzZXRNp8IAQ4vjxIjhpAf5hv/tAg=
 github.com/nkovacs/streamquote v0.0.0-20170412213628-49af9bddb229/go.mod h1:0aYXnNPJ8l7uZxf45rWW1a/uME32OF0rhiYGNQ2oF2E=
+github.com/nxadm/tail v1.4.4 h1:DQuhQpB1tVlglWS2hLQ5OV6B5r8aGxSrPc5Qo6uTN78=
+github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A=
+github.com/oklog/oklog v0.3.2/go.mod h1:FCV+B7mhrz4o+ueLpx+KqkyXRGMWOYEvfiXtdGtbWGs=
+github.com/oklog/run v1.0.0/go.mod h1:dlhp/R75TPv97u0XWUtDeV/lRKWPKSdTuV0TZvrmrQA=
+github.com/olekukonko/tablewriter v0.0.0-20170122224234-a0225b3f23b5/go.mod h1:vsDQFd/mU46D+Z4whnwzcISnGGzXWMclvtLoiIKAKIo=
 github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
 github.com/onsi/ginkgo v1.7.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
 github.com/onsi/ginkgo v1.8.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
-github.com/onsi/ginkgo v1.9.0 h1:SZjF721BByVj8QH636/8S2DnX4n0Re3SteMmw3N+tzc=
-github.com/onsi/ginkgo v1.9.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
+github.com/onsi/ginkgo v1.11.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
+github.com/onsi/ginkgo v1.12.0/go.mod h1:oUhWkIvk5aDxtKvDDuw8gItl8pKl42LzjC9KZE0HfGg=
+github.com/onsi/ginkgo v1.12.1/go.mod h1:zj2OWP4+oCPe1qIXoGWkgMRwljMUYCdkwsT2108oapk=
+github.com/onsi/ginkgo v1.14.0 h1:2mOpI4JVVPBN+WQRa0WKH2eXR+Ey+uK4n7Zj0aYpIQA=
+github.com/onsi/ginkgo v1.14.0/go.mod h1:iSB4RoI2tjJc9BBv4NKIKWKya62Rps+oPG/Lv9klQyY=
 github.com/onsi/gomega v1.4.3/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
 github.com/onsi/gomega v1.5.0/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
-github.com/onsi/gomega v1.6.0 h1:8XTW0fcJZEq9q+Upcyws4JSGua2MFysCL5xkaSgHc+M=
-github.com/onsi/gomega v1.6.0/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
+github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7JYyY=
+github.com/onsi/gomega v1.8.1/go.mod h1:Ho0h+IUsWyvy1OpqCwxlQ/21gkhVunqlU8fDGcoTdcA=
+github.com/onsi/gomega v1.9.0/go.mod h1:Ho0h+IUsWyvy1OpqCwxlQ/21gkhVunqlU8fDGcoTdcA=
+github.com/onsi/gomega v1.10.1 h1:o0+MgICZLuZ7xjH7Vx6zS/zcu93/BEp1VwkIW1mEXCE=
+github.com/onsi/gomega v1.10.1/go.mod h1:iN09h71vgCQne3DLsj+A5owkum+a2tYe+TOCB1ybHNo=
+github.com/op/go-logging v0.0.0-20160315200505-970db520ece7/go.mod h1:HzydrMdWErDVzsI23lYNej1Htcns9BCg93Dk0bBINWk=
+github.com/opentracing-contrib/go-grpc v0.0.0-20180928155321-4b5a12d3ff02/go.mod h1:JNdpVEzCpXBgIiv4ds+TzhN1hrtxq6ClLrTlT9OQRSc=
+github.com/opentracing-contrib/go-grpc v0.0.0-20191001143057-db30781987df h1:vdYtBU6zvL7v+Tr+0xFM/qhahw/EvY8DMMunZHKH6eE=
+github.com/opentracing-contrib/go-grpc v0.0.0-20191001143057-db30781987df/go.mod h1:DYR5Eij8rJl8h7gblRrOZ8g0kW1umSpKqYIBTgeDtLo=
+github.com/opentracing-contrib/go-observer v0.0.0-20170622124052-a52f23424492/go.mod h1:Ngi6UdF0k5OKD5t5wlmGhe/EDKPoUM3BXZSSfIuJbis=
+github.com/opentracing-contrib/go-stdlib v0.0.0-20190519235532-cf7a6c988dc9/go.mod h1:PLldrQSroqzH70Xl+1DQcGnefIbqsKR7UDaiux3zV+w=
+github.com/opentracing-contrib/go-stdlib v1.0.0 h1:TBS7YuVotp8myLon4Pv7BtCBzOTo1DeZCld0Z63mW2w=
+github.com/opentracing-contrib/go-stdlib v1.0.0/go.mod h1:qtI1ogk+2JhVPIXVc6q+NHziSmy2W5GbdQZFUHADCBU=
+github.com/opentracing/basictracer-go v1.0.0/go.mod h1:QfBfYuafItcjQuMwinw9GhYKwFXS9KnPs5lxoYwgW74=
 github.com/opentracing/opentracing-go v1.0.2/go.mod h1:UkNAQd3GIcIGf0SeVgPpRdFStlNbqXla1AfSYxPUl2o=
-github.com/opentracing/opentracing-go v1.1.0 h1:pWlfV3Bxv7k65HYwkikxat0+s3pV4bsqf19k25Ur8rU=
 github.com/opentracing/opentracing-go v1.1.0/go.mod h1:UkNAQd3GIcIGf0SeVgPpRdFStlNbqXla1AfSYxPUl2o=
+github.com/opentracing/opentracing-go v1.2.0 h1:uEJPy/1a5RIPAJ0Ov+OIO8OxWu77jEv+1B0VhjKrZUs=
+github.com/opentracing/opentracing-go v1.2.0/go.mod h1:GxEUsuufX4nBwe+T+Wl9TAgYrxe9dPLANfrWvHYVTgc=
+github.com/openzipkin-contrib/zipkin-go-opentracing v0.4.5/go.mod h1:/wsWhb9smxSfWAKL3wpBW7V8scJMt8N8gnaMCS9E/cA=
+github.com/openzipkin/zipkin-go v0.1.1/go.mod h1:NtoC/o8u3JlF1lSlyPNswIbeQH9bJTmOf0Erfk+hxe8=
 github.com/openzipkin/zipkin-go v0.1.6/go.mod h1:QgAqvLzwWbR/WpD4A3cGpPtJrZXNIiJc5AZX7/PBEpw=
-github.com/otiai10/copy v1.0.2 h1:DDNipYy6RkIkjMwy+AWzgKiNTyj2RUI9yEMeETEpVyc=
-github.com/otiai10/copy v1.0.2/go.mod h1:c7RpqBkwMom4bYTSkLSym4VSJz/XtncWRAj/J4PEIMY=
-github.com/otiai10/curr v0.0.0-20150429015615-9b4961190c95 h1:+OLn68pqasWca0z5ryit9KGfp3sUsW4Lqg32iRMJyzs=
-github.com/otiai10/curr v0.0.0-20150429015615-9b4961190c95/go.mod h1:9qAhocn7zKJG+0mI8eUu6xqkFDYS2kb2saOteoSB3cE=
-github.com/otiai10/mint v1.3.0 h1:Ady6MKVezQwHBkGzLFbrsywyp09Ah7rkmfjV3Bcr5uc=
-github.com/otiai10/mint v1.3.0/go.mod h1:F5AjcsTsWUqX+Na9fpHb52P8pcRX2CI6A3ctIT91xUo=
+github.com/openzipkin/zipkin-go v0.2.1/go.mod h1:NaW6tEwdmWMaCDZzg8sh+IBNOxHMPnhQw8ySjnjRyN4=
+github.com/openzipkin/zipkin-go v0.2.2/go.mod h1:NaW6tEwdmWMaCDZzg8sh+IBNOxHMPnhQw8ySjnjRyN4=
+github.com/pact-foundation/pact-go v1.0.4/go.mod h1:uExwJY4kCzNPcHRj+hCR/HBbOOIwwtUjcrb0b5/5kLM=
+github.com/pascaldekloe/goe v0.0.0-20180627143212-57f6aae5913c/go.mod h1:lzWF7FIEvWOWxwDKqyGYQf6ZUaNfKdP144TG7ZOy1lc=
+github.com/pborman/uuid v1.2.0/go.mod h1:X/NO0urCmaxf9VXbdlT7C2Yzkj2IKimNn4k+gtPdI/k=
 github.com/pelletier/go-toml v1.2.0/go.mod h1:5z9KED0ma1S8pY6P1sdut58dfprrGBbd/94hg7ilaic=
+github.com/performancecopilot/speed v3.0.0+incompatible/go.mod h1:/CLtqpZ5gBg1M9iaPbIdPPGyKcA8hKdoy6hAWba7Yac=
+github.com/pierrec/lz4 v1.0.2-0.20190131084431-473cd7ce01a1/go.mod h1:3/3N9NVKO0jef7pBehbT1qWhCMrIgbYNnFAZCqQ5LRc=
 github.com/pierrec/lz4 v2.0.5+incompatible/go.mod h1:pdkljMzZIN41W+lC3N2tnIh5sFi+IEE17M5jbnwPHcY=
 github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
-github.com/pkg/errors v0.8.1 h1:iURUrRGxPUNPdy5/HRSm+Yj6okJ6UtLINN0Q9M4+h3I=
 github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
+github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pkg/profile v1.2.1/go.mod h1:hJw3o1OdXxsrSjjVksARp5W95eeEaEfptyVZyv6JUPA=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/polydawn/refmt v0.0.0-20190221155625-df39d6c2d992/go.mod h1:uIp+gprXxxrWSjjklXD+mN4wed/tMfjMMmN/9+JsA9o=
@@ -599,30 +1189,113 @@ github.com/polydawn/refmt v0.0.0-20190408063855-01bf1e26dd14/go.mod h1:uIp+gprXx
 github.com/polydawn/refmt v0.0.0-20190807091052-3d65705ee9f1/go.mod h1:uIp+gprXxxrWSjjklXD+mN4wed/tMfjMMmN/9+JsA9o=
 github.com/polydawn/refmt v0.0.0-20190809202753-05966cbd336a h1:hjZfReYVLbqFkAtr2us7vdy04YWz3LVAirzP7reh8+M=
 github.com/polydawn/refmt v0.0.0-20190809202753-05966cbd336a/go.mod h1:uIp+gprXxxrWSjjklXD+mN4wed/tMfjMMmN/9+JsA9o=
+github.com/posener/complete v1.1.1/go.mod h1:em0nMJCgc9GFtwrmVmEMR/ZL6WyhyjMBndrE9hABlRI=
+github.com/prometheus/client_golang v0.8.0/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw=
 github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw=
+github.com/prometheus/client_golang v0.9.2/go.mod h1:OsXs2jCmiKlQ1lTBmv21f2mNfw4xf/QclQDMrYNZzcM=
 github.com/prometheus/client_golang v0.9.3-0.20190127221311-3c4408c8b829/go.mod h1:p2iRAGwDERtqlqzRXnrOVns+ignqQo//hLXqYxZYVNs=
+github.com/prometheus/client_golang v1.0.0/go.mod h1:db9x61etRT2tGnBNRi70OPL5FsnadC4Ky3P0J6CfImo=
+github.com/prometheus/client_golang v1.1.0/go.mod h1:I1FGZT9+L76gKKOs5djB6ezCbFQP1xR9D75/vuwEF3g=
+github.com/prometheus/client_golang v1.3.0/go.mod h1:hJaj2vgQTGQmVCsAACORcieXFeDPbaTKGT+JTgUa3og=
+github.com/prometheus/client_golang v1.4.1/go.mod h1:e9GMxYsXl05ICDXkRhurwBS4Q3OK1iX/F2sw+iXX5zU=
+github.com/prometheus/client_golang v1.6.0 h1:YVPodQOcK15POxhgARIvnDRVpLcuK8mglnMrWfyrw6A=
+github.com/prometheus/client_golang v1.6.0/go.mod h1:ZLOG9ck3JLRdB5MgO8f+lLTe83AXG6ro35rLTxvnIl4=
 github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
 github.com/prometheus/client_model v0.0.0-20190115171406-56726106282f/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
-github.com/prometheus/common v0.2.0 h1:kUZDBDTdBVBYBj5Tmh2NZLlF60mfjA27rM34b+cVwNU=
+github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
+github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
+github.com/prometheus/client_model v0.1.0/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
+github.com/prometheus/client_model v0.2.0 h1:uq5h0d+GuxiXLJLNABMgp2qUWDPiLvgCzz2dUR+/W/M=
+github.com/prometheus/client_model v0.2.0/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
+github.com/prometheus/common v0.0.0-20180801064454-c7de2306084e/go.mod h1:daVV7qP5qjZbuso7PdcryaAu0sAZbrN9i7WWcTMWvro=
+github.com/prometheus/common v0.0.0-20181126121408-4724e9255275/go.mod h1:daVV7qP5qjZbuso7PdcryaAu0sAZbrN9i7WWcTMWvro=
 github.com/prometheus/common v0.2.0/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=
+github.com/prometheus/common v0.4.1/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=
+github.com/prometheus/common v0.6.0/go.mod h1:eBmuwkDJBwy6iBfxCBob6t6dR6ENT/y+J+Zk0j9GMYc=
+github.com/prometheus/common v0.7.0/go.mod h1:DjGbpBbp5NYNiECxcL/VnbXCCaQpKd3tt26CguLLsqA=
+github.com/prometheus/common v0.9.1/go.mod h1:yhUN8i9wzaXS3w1O07YhxHEBxD+W35wd8bs7vj7HSQ4=
+github.com/prometheus/common v0.10.0 h1:RyRA7RzGXQZiW+tGMr7sxa85G1z0yOpM1qq5c8lNawc=
+github.com/prometheus/common v0.10.0/go.mod h1:Tlit/dnDKsSWFlCLTWaA1cyBgKHSMdTB80sz/V91rCo=
+github.com/prometheus/node_exporter v1.0.0-rc.0.0.20200428091818-01054558c289/go.mod h1:FGbBv5OPKjch+jNUJmEQpMZytIdyW0NdBtWFcfSKusc=
+github.com/prometheus/procfs v0.0.0-20180725123919-05ee40e3a273/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
 github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
+github.com/prometheus/procfs v0.0.0-20181204211112-1dc9a6cbc91a/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
 github.com/prometheus/procfs v0.0.0-20190117184657-bf6a532e95b1/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
+github.com/prometheus/procfs v0.0.0-20190425082905-87a4384529e0/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA=
+github.com/prometheus/procfs v0.0.2/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA=
+github.com/prometheus/procfs v0.0.3/go.mod h1:4A/X28fw3Fc593LaREMrKMqOKvUAntwMDaekg4FpcdQ=
+github.com/prometheus/procfs v0.0.8/go.mod h1:7Qr8sr6344vo1JqZ6HhLceV9o3AJ1Ff+GxbHq6oeK9A=
+github.com/prometheus/procfs v0.0.11/go.mod h1:lV6e/gmhEcM9IjHGsFOCxxuZ+z1YqCvr4OA4YeYWdaU=
+github.com/prometheus/procfs v0.1.0 h1:jhMy6QXfi3y2HEzFoyuCj40z4OZIIHHPtFyCMftmvKA=
+github.com/prometheus/procfs v0.1.0/go.mod h1:lV6e/gmhEcM9IjHGsFOCxxuZ+z1YqCvr4OA4YeYWdaU=
+github.com/raulk/clock v1.1.0 h1:dpb29+UKMbLqiU/jqIJptgLR1nn23HLgMY0sTCDza5Y=
+github.com/raulk/clock v1.1.0/go.mod h1:3MpVxdZ/ODBQDxbN+kzshf5OSZwPjtMDx6BBXBmOeY0=
 github.com/rcrowley/go-metrics v0.0.0-20181016184325-3113b8401b8a/go.mod h1:bCqnVzQkZxMG4s8nGwiZ5l3QUCyqpo9Y+/ZMZ9VjZe4=
+github.com/remyoudompheng/bigfft v0.0.0-20200410134404-eec4a21b6bb0 h1:OdAsTTz6OkFY5QxjkYwrChwuRruF69c169dPK26NUlk=
+github.com/remyoudompheng/bigfft v0.0.0-20200410134404-eec4a21b6bb0/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo=
+github.com/rogpeppe/fastuuid v0.0.0-20150106093220-6724a57986af/go.mod h1:XWv6SoW27p1b0cqNHllgS5HIMJraePCO15w5zCzIWYg=
+github.com/rogpeppe/fastuuid v1.2.0/go.mod h1:jVj6XXZzXRy/MSR5jhDC/2q6DgLz+nrA6LYCDYWNEvQ=
 github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
+github.com/rs/cors v1.6.0 h1:G9tHG9lebljV9mfp9SNPDL36nCDxmo3zTlAf1YgvzmI=
+github.com/rs/cors v1.6.0/go.mod h1:gFx+x8UowdsKA9AchylcLynDq+nNFfI8FkUZdN/jGCU=
+github.com/russross/blackfriday v1.5.2 h1:HyvC0ARfnZBqnXwABFeSZHpKvJHJJfPz81GNueLj0oo=
 github.com/russross/blackfriday v1.5.2/go.mod h1:JO/DiYxRf+HjHt06OyowR9PTA263kcR/rfWxYHBV53g=
+github.com/russross/blackfriday/v2 v2.0.1 h1:lPqVAte+HuHNfhJ/0LC98ESWRz8afy9tM/0RK8m9o+Q=
+github.com/russross/blackfriday/v2 v2.0.1/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
+github.com/rwcarlsen/goexif v0.0.0-20190401172101-9e8deecbddbd/go.mod h1:hPqNNc0+uJM6H+SuU8sEs5K5IQeKccPqeSjfgcKGgPk=
+github.com/ryanuber/columnize v0.0.0-20160712163229-9b3edd62028f/go.mod h1:sm1tb6uqfes/u+d4ooFouqFdy9/2g9QGwK3SQygK0Ts=
+github.com/samuel/go-zookeeper v0.0.0-20190923202752-2cc03de413da/go.mod h1:gi+0XIa01GRL2eRQVjQkKGqKF3SF9vZR/HnPullcV2E=
+github.com/sean-/seed v0.0.0-20170313163322-e2103e2c3529/go.mod h1:DxrIzT+xaE7yg65j358z/aeFdxmN0P9QXhEzd20vsDc=
+github.com/sercand/kuberesolver v2.1.0+incompatible/go.mod h1:lWF3GL0xptCB/vCiJPl/ZshwPsX/n4Y7u0CW9E7aQIQ=
+github.com/sercand/kuberesolver v2.4.0+incompatible h1:WE2OlRf6wjLxHwNkkFLQGaZcVLEXjMjBPjjEU5vksH8=
+github.com/sercand/kuberesolver v2.4.0+incompatible/go.mod h1:lWF3GL0xptCB/vCiJPl/ZshwPsX/n4Y7u0CW9E7aQIQ=
+github.com/sergi/go-diff v1.0.0/go.mod h1:0CfEIISq7TuYL3j771MWULgwwjU+GofnZX9QAmXWZgo=
 github.com/shirou/gopsutil v2.18.12+incompatible h1:1eaJvGomDnH74/5cF4CTmTbLHAriGFsTZppLXDX93OM=
 github.com/shirou/gopsutil v2.18.12+incompatible/go.mod h1:5b4v6he4MtMOwMlS0TUMTu2PcXUg8+E1lC7eC3UO/RA=
-github.com/sirupsen/logrus v1.2.0 h1:juTguoYk5qI21pwyTXY3B3Y5cOTH3ZUyZCg1v/mihuo=
+github.com/shurcooL/component v0.0.0-20170202220835-f88ec8f54cc4/go.mod h1:XhFIlyj5a1fBNx5aJTbKoIq0mNaPvOagO+HjB3EtxrY=
+github.com/shurcooL/events v0.0.0-20181021180414-410e4ca65f48/go.mod h1:5u70Mqkb5O5cxEA8nxTsgrgLehJeAw6Oc4Ab1c/P1HM=
+github.com/shurcooL/github_flavored_markdown v0.0.0-20181002035957-2122de532470/go.mod h1:2dOwnU2uBioM+SGy2aZoq1f/Sd1l9OkAeAUvjSyvgU0=
+github.com/shurcooL/go v0.0.0-20180423040247-9e1955d9fb6e/go.mod h1:TDJrrUr11Vxrven61rcy3hJMUqaf/CLWYhHNPmT14Lk=
+github.com/shurcooL/go-goon v0.0.0-20170922171312-37c2f522c041/go.mod h1:N5mDOmsrJOB+vfqUK+7DmDyjhSLIIBnXo9lvZJj3MWQ=
+github.com/shurcooL/gofontwoff v0.0.0-20180329035133-29b52fc0a18d/go.mod h1:05UtEgK5zq39gLST6uB0cf3NEHjETfB4Fgr3Gx5R9Vw=
+github.com/shurcooL/gopherjslib v0.0.0-20160914041154-feb6d3990c2c/go.mod h1:8d3azKNyqcHP1GaQE/c6dDgjkgSx2BZ4IoEi4F1reUI=
+github.com/shurcooL/highlight_diff v0.0.0-20170515013008-09bb4053de1b/go.mod h1:ZpfEhSmds4ytuByIcDnOLkTHGUI6KNqRNPDLHDk+mUU=
+github.com/shurcooL/highlight_go v0.0.0-20181028180052-98c3abbbae20/go.mod h1:UDKB5a1T23gOMUJrI+uSuH0VRDStOiUVSjBTRDVBVag=
+github.com/shurcooL/home v0.0.0-20181020052607-80b7ffcb30f9/go.mod h1:+rgNQw2P9ARFAs37qieuu7ohDNQ3gds9msbT2yn85sg=
+github.com/shurcooL/htmlg v0.0.0-20170918183704-d01228ac9e50/go.mod h1:zPn1wHpTIePGnXSHpsVPWEktKXHr6+SS6x/IKRb7cpw=
+github.com/shurcooL/httperror v0.0.0-20170206035902-86b7830d14cc/go.mod h1:aYMfkZ6DWSJPJ6c4Wwz3QtW22G7mf/PEgaB9k/ik5+Y=
+github.com/shurcooL/httpfs v0.0.0-20171119174359-809beceb2371/go.mod h1:ZY1cvUeJuFPAdZ/B6v7RHavJWZn2YPVFQ1OSXhCGOkg=
+github.com/shurcooL/httpgzip v0.0.0-20180522190206-b1c53ac65af9/go.mod h1:919LwcH0M7/W4fcZ0/jy0qGght1GIhqyS/EgWGH2j5Q=
+github.com/shurcooL/issues v0.0.0-20181008053335-6292fdc1e191/go.mod h1:e2qWDig5bLteJ4fwvDAc2NHzqFEthkqn7aOZAOpj+PQ=
+github.com/shurcooL/issuesapp v0.0.0-20180602232740-048589ce2241/go.mod h1:NPpHK2TI7iSaM0buivtFUc9offApnI0Alt/K8hcHy0I=
+github.com/shurcooL/notifications v0.0.0-20181007000457-627ab5aea122/go.mod h1:b5uSkrEVM1jQUspwbixRBhaIjIzL2xazXp6kntxYle0=
+github.com/shurcooL/octicon v0.0.0-20181028054416-fa4f57f9efb2/go.mod h1:eWdoE5JD4R5UVWDucdOPg1g2fqQRq78IQa9zlOV1vpQ=
+github.com/shurcooL/reactions v0.0.0-20181006231557-f2e0b4ca5b82/go.mod h1:TCR1lToEk4d2s07G3XGfz2QrgHXg4RJBvjrOozvoWfk=
+github.com/shurcooL/sanitized_anchor_name v0.0.0-20170918181015-86672fcb3f95/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc=
+github.com/shurcooL/sanitized_anchor_name v1.0.0 h1:PdmoCO6wvbs+7yrJyMORt4/BmY5IYyJwS/kOiWx8mHo=
+github.com/shurcooL/sanitized_anchor_name v1.0.0/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc=
+github.com/shurcooL/users v0.0.0-20180125191416-49c67e49c537/go.mod h1:QJTqeLYEDaXHZDBsXlPCDqdhQuJkuw4NOtaxYe3xii4=
+github.com/shurcooL/webdavfs v0.0.0-20170829043945-18c3829fa133/go.mod h1:hKmq5kWdCj2z2KEozexVbfEZIWiTjhE0+UjmZgPqehw=
+github.com/siebenmann/go-kstat v0.0.0-20160321171754-d34789b79745/go.mod h1:G81aIFAMS9ECrwBYR9YxhlPjWgrItd+Kje78O6+uqm8=
 github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=
+github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE=
+github.com/sirupsen/logrus v1.6.0 h1:UBcNElsrwanuuMsnGSlYmtmgbb23qDR5dG+6X6Oo89I=
+github.com/sirupsen/logrus v1.6.0/go.mod h1:7uNnSEd1DgxDLC74fIahvMZmmYsHGZGEOFrfsX/uA88=
 github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d/go.mod h1:OnSkiWE9lh6wB0YB77sQom3nweQdgAjqCqsofrRNTgc=
 github.com/smartystreets/assertions v1.0.0/go.mod h1:kHHU4qYBaI3q23Pp3VPrmWhuIUrLW/7eUrw0BU5VaoM=
 github.com/smartystreets/assertions v1.0.1 h1:voD4ITNjPL5jjBfgR/r8fPIIBrliWrWHeiJApdr3r4w=
 github.com/smartystreets/assertions v1.0.1/go.mod h1:kHHU4qYBaI3q23Pp3VPrmWhuIUrLW/7eUrw0BU5VaoM=
 github.com/smartystreets/goconvey v0.0.0-20190222223459-a17d461953aa/go.mod h1:2RVY1rIf+2J2o/IM9+vPq9RzmHDSseB7FoXiSNIUsoU=
 github.com/smartystreets/goconvey v0.0.0-20190330032615-68dc04aab96a/go.mod h1:syvi0/a8iFYH4r/RixwvyeAJjdLS9QV7WQ/tjFTllLA=
-github.com/smartystreets/goconvey v0.0.0-20190731233626-505e41936337 h1:WN9BUFbdyOsSH/XohnWpXOlq9NBD5sGAB2FciQMUEe8=
 github.com/smartystreets/goconvey v0.0.0-20190731233626-505e41936337/go.mod h1:syvi0/a8iFYH4r/RixwvyeAJjdLS9QV7WQ/tjFTllLA=
+github.com/smartystreets/goconvey v1.6.4 h1:fv0U8FUIMPNf1L9lnHLvLhgicrIVChEkdzIKYqbNC9s=
+github.com/smartystreets/goconvey v1.6.4/go.mod h1:syvi0/a8iFYH4r/RixwvyeAJjdLS9QV7WQ/tjFTllLA=
 github.com/smola/gocompat v0.2.0/go.mod h1:1B0MlxbmoZNo3h8guHp8HztB3BSYR5itql9qtVc0ypY=
+github.com/soheilhy/cmux v0.1.4/go.mod h1:IM3LyeVVIOuxMH7sFAkER9+bJ4dT7Ms6E4xg4kGIyLM=
+github.com/sony/gobreaker v0.4.1/go.mod h1:ZKptC7FHNvhBz7dN2LGjPVBz2sZJmc0/PkyDJOjmxWY=
+github.com/soundcloud/go-runit v0.0.0-20150630195641-06ad41a06c4a/go.mod h1:LeFCbQYJ3KJlPs/FvPz2dy1tkpxyeNESVyCNNzRXFR0=
+github.com/sourcegraph/annotate v0.0.0-20160123013949-f4cad6c6324d/go.mod h1:UdhH50NIW0fCiwBSr0co2m7BnFLdv4fQTgdqdJTHFeE=
+github.com/sourcegraph/syntaxhighlight v0.0.0-20170531221838-bd320f5d308e/go.mod h1:HuIsMU8RRBOtsCgI77wP899iHVBQpCmg4ErYMZB+2IA=
 github.com/spacemonkeygo/openssl v0.0.0-20181017203307-c2dcc5cca94a/go.mod h1:7AyxJNCJ7SBZ1MfVQCWD6Uqo2oubI2Eq2y2eqf+A5r0=
 github.com/spacemonkeygo/spacelog v0.0.0-20180420211403-2296661a0572 h1:RC6RW7j+1+HkWaX/Yh71Ee5ZHaHYt7ZP4sQgUrm6cDU=
 github.com/spacemonkeygo/spacelog v0.0.0-20180420211403-2296661a0572/go.mod h1:w0SWMsp6j9O/dk4/ZpIhL+3CkG8ofA2vuv7k+ltqUMc=
@@ -631,46 +1304,87 @@ github.com/spaolacci/murmur3 v1.1.0 h1:7c1g84S4BPRrfL5Xrdp6fOJ206sU9y293DDHaoy0b
 github.com/spaolacci/murmur3 v1.1.0/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA=
 github.com/spf13/afero v1.1.2/go.mod h1:j4pytiNVoe2o6bmDsKpLACNPDBIoEAkihy7loJ1B0CQ=
 github.com/spf13/cast v1.3.0/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE=
+github.com/spf13/cobra v0.0.3/go.mod h1:1l0Ry5zgKvJasoi3XT1TypsSe7PqH0Sj9dhYf7v3XqQ=
 github.com/spf13/cobra v0.0.5/go.mod h1:3K3wKZymM7VvHMDS9+Akkh4K60UwM26emMESw8tLCHU=
 github.com/spf13/jwalterweatherman v1.0.0/go.mod h1:cQK4TGJAtQXfYWX+Ddv3mKDzgVb68N+wFjFa4jdeBTo=
+github.com/spf13/pflag v1.0.1/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
 github.com/spf13/pflag v1.0.3/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
 github.com/spf13/viper v1.3.2/go.mod h1:ZiWeW+zYFKm7srdB9IoDzzZXaJaI5eL9QjNiN/DMA2s=
 github.com/src-d/envconfig v1.0.0/go.mod h1:Q9YQZ7BKITldTBnoxsE5gOeB5y66RyPXeue/R4aaNBc=
+github.com/streadway/amqp v0.0.0-20190404075320-75d898a42a94/go.mod h1:AZpEONHx3DKn8O/DFsRAY58/XVQiIPMTMB1SddzLXVw=
+github.com/streadway/amqp v0.0.0-20190827072141-edfb9018d271/go.mod h1:AZpEONHx3DKn8O/DFsRAY58/XVQiIPMTMB1SddzLXVw=
+github.com/streadway/handy v0.0.0-20190108123426-d5acb3125c2a/go.mod h1:qNTQ5P5JnDBl6z3cMAg/SywNDC5ABu5ApDIw6lUbRmI=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.1.1 h1:2vfRuCMp5sSVIDSqO8oNnWJq7mPa6KVP3iPIwFBuy8A=
 github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
-github.com/stretchr/testify v1.4.0 h1:2E4SXV/wtOkTonXsotYi4li6zVWxYlZuYNCXe9XRJyk=
 github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
+github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
+github.com/stretchr/testify v1.6.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.6.1 h1:hDPOHmpOpP40lSULcqw7IrRb/u7w6RpDC9399XyoNd0=
+github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/syndtr/goleveldb v1.0.0 h1:fBdIW9lB4Iz0n9khmH8w27SJ3QEJ7+IgjPEwGSZiFdE=
 github.com/syndtr/goleveldb v1.0.0/go.mod h1:ZVVdQEZoIme9iO1Ch2Jdy24qqXrMMOU6lpPAyBWyWuQ=
+github.com/tarm/serial v0.0.0-20180830185346-98f6abe2eb07/go.mod h1:kDXzergiv9cbyO7IOYJZWg1U88JhDg3PB6klq9Hg2pA=
+github.com/texttheater/golang-levenshtein v0.0.0-20180516184445-d188e65d659e/go.mod h1:XDKHRm5ThF8YJjx001LtgelzsoaEcvnA7lVWz9EeX3g=
+github.com/tj/go-spin v1.1.0 h1:lhdWZsvImxvZ3q1C5OIB7d72DuOwP4O2NdBg9PyzNds=
+github.com/tj/go-spin v1.1.0/go.mod h1:Mg1mzmePZm4dva8Qz60H2lHwmJ2loum4VIrLgVnKwh4=
+github.com/tmc/grpc-websocket-proxy v0.0.0-20170815181823-89b8d40f7ca8/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U=
+github.com/uber/jaeger-client-go v2.15.0+incompatible/go.mod h1:WVhlPFC8FDjOFMMWRy2pZqQJSXxYSwNYOkTr/Z6d3Kk=
+github.com/uber/jaeger-client-go v2.23.1+incompatible h1:uArBYHQR0HqLFFAypI7RsWTzPSj/bDpmZZuQjMLSg1A=
+github.com/uber/jaeger-client-go v2.23.1+incompatible/go.mod h1:WVhlPFC8FDjOFMMWRy2pZqQJSXxYSwNYOkTr/Z6d3Kk=
+github.com/uber/jaeger-lib v1.5.1-0.20181102163054-1fc5c315e03c/go.mod h1:ComeNDZlWwrWnDv8aPp0Ba6+uUTzImX/AauajbLI56U=
+github.com/uber/jaeger-lib v2.2.0+incompatible h1:MxZXOiR2JuoANZ3J6DE/U0kSFv/eJ/GfSYVCjK7dyaw=
+github.com/uber/jaeger-lib v2.2.0+incompatible/go.mod h1:ComeNDZlWwrWnDv8aPp0Ba6+uUTzImX/AauajbLI56U=
 github.com/ugorji/go/codec v0.0.0-20181204163529-d75b2dcb6bc8/go.mod h1:VFNgLljTbGfSG7qAOspJ7OScBnGdDN/yBr0sguwnwf0=
 github.com/urfave/cli v1.20.0/go.mod h1:70zkFmudgCuE/ngEzBv17Jvp/497gISqfk5gWijbERA=
+github.com/urfave/cli v1.22.1 h1:+mkCCcOFKPnCmVYVcURKps1Xe+3zP90gSYGNfRkjoIY=
+github.com/urfave/cli v1.22.1/go.mod h1:Gos4lmkARVdJ6EkW0WaNv/tZAAMe9V7XWyB60NtXRu0=
+github.com/urfave/cli/v2 v2.0.0/go.mod h1:SE9GqnLQmjVa0iPEY0f1w3ygNIYcIJ0OKPMoW2caLfQ=
+github.com/urfave/cli/v2 v2.2.0 h1:JTTnM6wKzdA0Jqodd966MVj4vWbbquZykeX1sKbe2C4=
+github.com/urfave/cli/v2 v2.2.0/go.mod h1:SE9GqnLQmjVa0iPEY0f1w3ygNIYcIJ0OKPMoW2caLfQ=
 github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw=
 github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc=
 github.com/valyala/fasttemplate v1.0.1 h1:tY9CJiPnMXf1ERmG2EyK7gNUd+c6RKGD0IfU8WdUSz8=
 github.com/valyala/fasttemplate v1.0.1/go.mod h1:UQGH1tvbgY+Nz5t2n7tXsz52dQxojPUpymEIMZ47gx8=
+github.com/viant/assertly v0.4.8/go.mod h1:aGifi++jvCrUaklKEKT0BU95igDNaqkvz+49uaYMPRU=
+github.com/viant/toolbox v0.24.0/go.mod h1:OxMCG57V0PXuIP2HNQrtJf2CjqdmbrOx5EkMILuUhzM=
+github.com/wangjia184/sortedset v0.0.0-20160527075905-f5d03557ba30/go.mod h1:YkocrP2K2tcw938x9gCOmT5G5eCD6jsTz0SZuyAqwIE=
 github.com/warpfork/go-wish v0.0.0-20180510122957-5ad1f5abf436/go.mod h1:x6AKhvSSexNrVSrViXSHUEbICjmGXhtgABaHIySUSGw=
-github.com/warpfork/go-wish v0.0.0-20190328234359-8b3e70f8e830 h1:8kxMKmKzXXL4Ru1nyhvdms/JjWt+3YLpvRb/bAjO/y0=
 github.com/warpfork/go-wish v0.0.0-20190328234359-8b3e70f8e830/go.mod h1:x6AKhvSSexNrVSrViXSHUEbICjmGXhtgABaHIySUSGw=
-github.com/whyrusleeping/base32 v0.0.0-20170828182744-c30ac30633cc h1:BCPnHtcboadS0DvysUuJXZ4lWVv5Bh5i7+tbIyi+ck4=
+github.com/warpfork/go-wish v0.0.0-20200122115046-b9ea61034e4a h1:G++j5e0OC488te356JvdhaM8YS6nMsjLAYF7JxCv07w=
+github.com/warpfork/go-wish v0.0.0-20200122115046-b9ea61034e4a/go.mod h1:x6AKhvSSexNrVSrViXSHUEbICjmGXhtgABaHIySUSGw=
+github.com/weaveworks/common v0.0.0-20200512154658-384f10054ec5 h1:EYxr08r8x6r/5fLEAMMkida1BVgxVXE4LfZv/XV+znU=
+github.com/weaveworks/common v0.0.0-20200512154658-384f10054ec5/go.mod h1:c98fKi5B9u8OsKGiWHLRKus6ToQ1Tubeow44ECO1uxY=
+github.com/weaveworks/promrus v1.2.0 h1:jOLf6pe6/vss4qGHjXmGz4oDJQA+AOCqEL3FvvZGz7M=
+github.com/weaveworks/promrus v1.2.0/go.mod h1:SaE82+OJ91yqjrE1rsvBWVzNZKcHYFtMUyS1+Ogs/KA=
 github.com/whyrusleeping/base32 v0.0.0-20170828182744-c30ac30633cc/go.mod h1:r45hJU7yEoA81k6MWNhpMj/kms0n14dkzkxYHoB96UM=
 github.com/whyrusleeping/bencher v0.0.0-20190829221104-bb6607aa8bba h1:X4n8JG2e2biEZZXdBKt9HX7DN3bYGFUqljqqy0DqgnY=
 github.com/whyrusleeping/bencher v0.0.0-20190829221104-bb6607aa8bba/go.mod h1:CHQnYnQUEPydYCwuy8lmTHfGmdw9TKrhWV0xLx8l0oM=
-github.com/whyrusleeping/cbor-gen v0.0.0-20190910031516-c1cbffdb01bb/go.mod h1:xdlJQaiqipF0HW+Mzpg7XRM3fWbGvfgFlcppuvlkIvY=
-github.com/whyrusleeping/cbor-gen v0.0.0-20190917003517-d78d67427694/go.mod h1:xdlJQaiqipF0HW+Mzpg7XRM3fWbGvfgFlcppuvlkIvY=
-github.com/whyrusleeping/cbor-gen v0.0.0-20191116002219-891f55cd449d/go.mod h1:xdlJQaiqipF0HW+Mzpg7XRM3fWbGvfgFlcppuvlkIvY=
-github.com/whyrusleeping/cbor-gen v0.0.0-20191216205031-b047b6acb3c0 h1:efb/4CnrubzNGqQOeHErxyQ6rIsJb7GcgeSDF7fqWeI=
 github.com/whyrusleeping/cbor-gen v0.0.0-20191216205031-b047b6acb3c0/go.mod h1:xdlJQaiqipF0HW+Mzpg7XRM3fWbGvfgFlcppuvlkIvY=
+github.com/whyrusleeping/cbor-gen v0.0.0-20200123233031-1cdf64d27158/go.mod h1:Xj/M2wWU+QdTdRbu/L/1dIZY8/Wb2K9pAhtroQuxJJI=
+github.com/whyrusleeping/cbor-gen v0.0.0-20200402171437-3d27c146c105/go.mod h1:Xj/M2wWU+QdTdRbu/L/1dIZY8/Wb2K9pAhtroQuxJJI=
+github.com/whyrusleeping/cbor-gen v0.0.0-20200414195334-429a0b5e922e/go.mod h1:Xj/M2wWU+QdTdRbu/L/1dIZY8/Wb2K9pAhtroQuxJJI=
+github.com/whyrusleeping/cbor-gen v0.0.0-20200504204219-64967432584d/go.mod h1:W5MvapuoHRP8rz4vxjwCK1pDqF1aQcWsV5PZ+AHbqdg=
+github.com/whyrusleeping/cbor-gen v0.0.0-20200710004633-5379fc63235d/go.mod h1:fgkXqYy7bV2cFeIEOkVTZS/WjXARfBqSH6Q2qHL33hQ=
+github.com/whyrusleeping/cbor-gen v0.0.0-20200715143311-227fab5a2377/go.mod h1:fgkXqYy7bV2cFeIEOkVTZS/WjXARfBqSH6Q2qHL33hQ=
+github.com/whyrusleeping/cbor-gen v0.0.0-20200810223238-211df3b9e24c/go.mod h1:fgkXqYy7bV2cFeIEOkVTZS/WjXARfBqSH6Q2qHL33hQ=
+github.com/whyrusleeping/cbor-gen v0.0.0-20200812213548-958ddffe352c/go.mod h1:fgkXqYy7bV2cFeIEOkVTZS/WjXARfBqSH6Q2qHL33hQ=
+github.com/whyrusleeping/cbor-gen v0.0.0-20200814224545-656e08ce49ee h1:U7zWWvvAjT76EiuWPSOiZlQDnaQYPxPoxugTtTAcJK0=
+github.com/whyrusleeping/cbor-gen v0.0.0-20200814224545-656e08ce49ee/go.mod h1:fgkXqYy7bV2cFeIEOkVTZS/WjXARfBqSH6Q2qHL33hQ=
 github.com/whyrusleeping/chunker v0.0.0-20181014151217-fe64bd25879f h1:jQa4QT2UP9WYv2nzyawpKMOCl+Z/jW7djv2/J50lj9E=
 github.com/whyrusleeping/chunker v0.0.0-20181014151217-fe64bd25879f/go.mod h1:p9UJB6dDgdPgMJZs7UjUOdulKyRr9fqkS+6JKAInPy8=
+github.com/whyrusleeping/go-ctrlnet v0.0.0-20180313164037-f564fbbdaa95/go.mod h1:SJqKCCPXRfBFCwXjfNT/skfsceF7+MBFLI2OrvuRA7g=
 github.com/whyrusleeping/go-keyspace v0.0.0-20160322163242-5b898ac5add1 h1:EKhdznlJHPMoKr0XTrX+IlJs1LH3lyx2nfr1dOlZ79k=
 github.com/whyrusleeping/go-keyspace v0.0.0-20160322163242-5b898ac5add1/go.mod h1:8UvriyWtv5Q5EOgjHaSseUEdkQfvwFv1I/In/O2M9gc=
 github.com/whyrusleeping/go-logging v0.0.0-20170515211332-0457bb6b88fc/go.mod h1:bopw91TMyo8J3tvftk8xmU2kPmlrt4nScJQZU2hE5EM=
+github.com/whyrusleeping/go-logging v0.0.1/go.mod h1:lDPYj54zutzG1XYfHAhcc7oNXEburHQBn+Iqd4yS4vE=
 github.com/whyrusleeping/go-notifier v0.0.0-20170827234753-097c5d47330f/go.mod h1:cZNvX9cFybI01GriPRMXDtczuvUhgbcYr9iCGaNlRv8=
 github.com/whyrusleeping/go-smux-multiplex v3.0.16+incompatible/go.mod h1:34LEDbeKFZInPUrAG+bjuJmUXONGdEFW7XL0SpTY1y4=
 github.com/whyrusleeping/go-smux-multistream v2.0.2+incompatible/go.mod h1:dRWHHvc4HDQSHh9gbKEBbUZ+f2Q8iZTPG3UOGYODxSQ=
 github.com/whyrusleeping/go-smux-yamux v2.0.8+incompatible/go.mod h1:6qHUzBXUbB9MXmw3AUdB52L8sEb/hScCqOdW2kj/wuI=
-github.com/whyrusleeping/mafmt v1.2.8 h1:TCghSl5kkwEE0j+sU/gudyhVMRlpBin8fMBBHg59EbA=
+github.com/whyrusleeping/go-smux-yamux v2.0.9+incompatible/go.mod h1:6qHUzBXUbB9MXmw3AUdB52L8sEb/hScCqOdW2kj/wuI=
 github.com/whyrusleeping/mafmt v1.2.8/go.mod h1:faQJFPbLSxzD9xpA02ttW/tS9vZykNvXwGvqIpk20FA=
 github.com/whyrusleeping/mdns v0.0.0-20180901202407-ef14215e6b30/go.mod h1:j4l84WPFclQPj320J9gp0XwNKBb3U0zt5CBqjPp22G4=
 github.com/whyrusleeping/mdns v0.0.0-20190826153040-b9b60ed33aa9/go.mod h1:j4l84WPFclQPj320J9gp0XwNKBb3U0zt5CBqjPp22G4=
@@ -682,178 +1396,430 @@ github.com/whyrusleeping/timecache v0.0.0-20160911033111-cfcb2f1abfee h1:lYbXeSv
 github.com/whyrusleeping/timecache v0.0.0-20160911033111-cfcb2f1abfee/go.mod h1:m2aV4LZI4Aez7dP5PMyVKEHhUyEJ/RjmPEDOpDvudHg=
 github.com/whyrusleeping/yamux v1.1.5/go.mod h1:E8LnQQ8HKx5KD29HZFUwM1PxCOdPRzGwur1mcYhXcD8=
 github.com/x-cray/logrus-prefixed-formatter v0.5.2/go.mod h1:2duySbKsL6M18s5GU7VPsoEPHyzalCE06qoARUCeBBE=
+github.com/xiang90/probing v0.0.0-20190116061207-43a291ad63a2/go.mod h1:UETIi67q53MR2AWcXfiuqkDkRtnGDLqkBTpCHuJHxtU=
+github.com/xlab/c-for-go v0.0.0-20200718154222-87b0065af829 h1:wb7xrDzfkLgPHsSEBm+VSx6aDdi64VtV0xvP0E6j8bk=
+github.com/xlab/c-for-go v0.0.0-20200718154222-87b0065af829/go.mod h1:h/1PEBwj7Ym/8kOuMWvO2ujZ6Lt+TMbySEXNhjjR87I=
+github.com/xlab/pkgconfig v0.0.0-20170226114623-cea12a0fd245 h1:Sw125DKxZhPUI4JLlWugkzsrlB50jR9v2khiD9FxuSo=
+github.com/xlab/pkgconfig v0.0.0-20170226114623-cea12a0fd245/go.mod h1:C+diUUz7pxhNY6KAoLgrTYARGWnt82zWTylZlxT92vk=
+github.com/xorcare/golden v0.6.0/go.mod h1:7T39/ZMvaSEZlBPoYfVFmsBLmUl3uz9IuzWj/U6FtvQ=
+github.com/xorcare/golden v0.6.1-0.20191112154924-b87f686d7542 h1:oWgZJmC1DorFZDpfMfWg7xk29yEOZiXmo/wZl+utTI8=
+github.com/xorcare/golden v0.6.1-0.20191112154924-b87f686d7542/go.mod h1:7T39/ZMvaSEZlBPoYfVFmsBLmUl3uz9IuzWj/U6FtvQ=
 github.com/xordataexchange/crypt v0.0.3-0.20170626215501-b2862e3d0a77/go.mod h1:aYKd//L2LvnjZzWKhF00oedf4jCCReLcmhLdhm1A27Q=
+github.com/yuin/goldmark v1.1.32/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
+go.dedis.ch/fixbuf v1.0.3 h1:hGcV9Cd/znUxlusJ64eAlExS+5cJDIyTyEG+otu5wQs=
+go.dedis.ch/fixbuf v1.0.3/go.mod h1:yzJMt34Wa5xD37V5RTdmp38cz3QhMagdGoem9anUalw=
+go.dedis.ch/kyber/v3 v3.0.4/go.mod h1:OzvaEnPvKlyrWyp3kGXlFdp7ap1VC6RkZDTaPikqhsQ=
+go.dedis.ch/kyber/v3 v3.0.9 h1:i0ZbOQocHUjfFasBiUql5zVeC7u/vahFd96DFA8UOWk=
+go.dedis.ch/kyber/v3 v3.0.9/go.mod h1:rhNjUUg6ahf8HEg5HUvVBYoWY4boAafX8tYxX+PS+qg=
+go.dedis.ch/protobuf v1.0.5/go.mod h1:eIV4wicvi6JK0q/QnfIEGeSFNG0ZeB24kzut5+HaRLo=
+go.dedis.ch/protobuf v1.0.7/go.mod h1:pv5ysfkDX/EawiPqcW3ikOxsL5t+BqnV6xHSmE79KI4=
+go.dedis.ch/protobuf v1.0.11 h1:FTYVIEzY/bfl37lu3pR4lIj+F9Vp1jE8oh91VmxKgLo=
+go.dedis.ch/protobuf v1.0.11/go.mod h1:97QR256dnkimeNdfmURz0wAMNVbd1VmLXhG1CrTYrJ4=
+go.etcd.io/bbolt v1.3.3/go.mod h1:IbVyRI1SCnLcuJnV2u8VeU0CEYM7e686BmAb1XKL+uU=
+go.etcd.io/bbolt v1.3.4 h1:hi1bXHMVrlQh6WwxAy+qZCV/SYIlqo+Ushwdpa4tAKg=
+go.etcd.io/bbolt v1.3.4/go.mod h1:G5EMThwa9y8QZGBClrRx5EY+Yw9kAhnjy3bSjsnlVTQ=
+go.etcd.io/etcd v0.0.0-20191023171146-3cf2f69b5738/go.mod h1:dnLIgRNXwCJa5e+c6mIZCrds/GIG4ncV9HhK5PX7jPg=
+go.opencensus.io v0.18.0/go.mod h1:vKdFvxhtzZ9onBp9VKHK8z/sRpBMnKAsufL7wlDrCOA=
 go.opencensus.io v0.20.1/go.mod h1:6WKK9ahsWS3RSO+PY9ZHZUfv2irvY6gN279GOPZjmmk=
+go.opencensus.io v0.20.2/go.mod h1:6WKK9ahsWS3RSO+PY9ZHZUfv2irvY6gN279GOPZjmmk=
 go.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU=
+go.opencensus.io v0.22.0/go.mod h1:+kGneAE2xo2IficOXnaByMWTGM9T73dGwxeWcUqIpI8=
 go.opencensus.io v0.22.1/go.mod h1:Ap50jQcDJrx6rB6VgeeFPtuPIf3wMRvRfrfYDO6+BmA=
-go.opencensus.io v0.22.2 h1:75k/FF0Q2YM8QYo07VPddOLBslDt1MZOdEslOHvmzAs=
 go.opencensus.io v0.22.2/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
+go.opencensus.io v0.22.3/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
+go.opencensus.io v0.22.4 h1:LYy1Hy3MJdrCdMwwzxA/dRok4ejH+RwNGbuoD9fCjto=
+go.opencensus.io v0.22.4/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
+go.uber.org/atomic v1.3.2/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE=
 go.uber.org/atomic v1.4.0/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE=
-go.uber.org/atomic v1.5.0 h1:OI5t8sDa1Or+q8AeE+yKeB/SDYioSHAgcVljj9JIETY=
 go.uber.org/atomic v1.5.0/go.mod h1:sABNBOSYdrvTF6hTgEIbc7YasKWGhgEQZyfxyTvoXHQ=
-go.uber.org/atomic v1.5.1 h1:rsqfU5vBkVknbhUGbAUwQKR2H4ItV8tjJ+6kJX4cxHM=
 go.uber.org/atomic v1.5.1/go.mod h1:sABNBOSYdrvTF6hTgEIbc7YasKWGhgEQZyfxyTvoXHQ=
-go.uber.org/dig v1.7.0 h1:E5/L92iQTNJTjfgJF2KgU+/JpMaiuvK2DHLBj0+kSZk=
-go.uber.org/dig v1.7.0/go.mod h1:z+dSd2TP9Usi48jL8M3v63iSBVkiwtVyMKxMZYYauPg=
+go.uber.org/atomic v1.6.0 h1:Ezj3JGmsOnG1MoRWQkPBsKLe9DwWD9QeXzTRzzldNVk=
+go.uber.org/atomic v1.6.0/go.mod h1:sABNBOSYdrvTF6hTgEIbc7YasKWGhgEQZyfxyTvoXHQ=
+go.uber.org/dig v1.10.0 h1:yLmDDj9/zuDjv3gz8GQGviXMs9TfysIUMUilCpgzUJY=
+go.uber.org/dig v1.10.0/go.mod h1:X34SnWGr8Fyla9zQNO2GSO2D+TIuqB14OS8JhYocIyw=
 go.uber.org/fx v1.9.0 h1:7OAz8ucp35AU8eydejpYG7QrbE8rLKzGhHbZlJi5LYY=
 go.uber.org/fx v1.9.0/go.mod h1:mFdUyAUuJ3w4jAckiKSKbldsxy1ojpAMJ+dVZg5Y0Aw=
-go.uber.org/goleak v0.10.0 h1:G3eWbSNIskeRqtsN/1uI5B+eP73y3JUuBsv9AZjehb4=
-go.uber.org/goleak v0.10.0/go.mod h1:VCZuO8V8mFPlL0F5J5GK1rtHV3DrFcQ1R8ryq7FK0aI=
+go.uber.org/goleak v1.0.0 h1:qsup4IcBdlmsnGfqyLl4Ntn3C2XCCuKAE7DwHpScyUo=
+go.uber.org/goleak v1.0.0/go.mod h1:8a7PlsEVH3e/a/GLqe5IIrQx6GzcnRmZEufDUTk4A7A=
 go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/0=
 go.uber.org/multierr v1.3.0/go.mod h1:VgVr7evmIr6uPjLBxg28wmKNXyqE9akIJ5XnfpiKl+4=
-go.uber.org/multierr v1.4.0 h1:f3WCSC2KzAcBXGATIxAB1E2XuCpNU255wNKZ505qi3E=
 go.uber.org/multierr v1.4.0/go.mod h1:VgVr7evmIr6uPjLBxg28wmKNXyqE9akIJ5XnfpiKl+4=
+go.uber.org/multierr v1.5.0 h1:KCa4XfM8CWFCpxXRGok+Q0SS/0XBhMDbHHGABQLvD2A=
+go.uber.org/multierr v1.5.0/go.mod h1:FeouvMocqHpRaaGuG9EjoKcStLC43Zu/fmqdUMPcKYU=
 go.uber.org/tools v0.0.0-20190618225709-2cfd321de3ee h1:0mgffUl7nfd+FpvXMVz4IDEaUSmT1ysygQC7qYo7sG4=
 go.uber.org/tools v0.0.0-20190618225709-2cfd321de3ee/go.mod h1:vJERXedbb3MVM5f9Ejo0C68/HhF8uaILCdgjnY+goOA=
-go.uber.org/zap v1.10.0 h1:ORx85nbTijNz8ljznvCMR1ZBIPKFn3jQrag10X2AsuM=
 go.uber.org/zap v1.10.0/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q=
-go.uber.org/zap v1.13.0 h1:nR6NoDBgAf67s68NhaXbsojM+2gxp3S1hWkHDl27pVU=
 go.uber.org/zap v1.13.0/go.mod h1:zwrFLgMcdUuIBviXEYEH1YKNaOBnKXsx2IPda5bBwHM=
-go4.org v0.0.0-20190218023631-ce4c26f7be8e/go.mod h1:MkTOUMDaeVYJUOUsaDXIhWPZYa1yOyC1qaOBpL57BhE=
-go4.org v0.0.0-20190313082347-94abd6928b1d h1:JkRdGP3zvTtTbabWSAC6n67ka30y7gOzWAah4XYJSfw=
-go4.org v0.0.0-20190313082347-94abd6928b1d/go.mod h1:MkTOUMDaeVYJUOUsaDXIhWPZYa1yOyC1qaOBpL57BhE=
+go.uber.org/zap v1.14.1/go.mod h1:Mb2vm2krFEG5DV0W9qcHBYFtp/Wku1cvYaqPsS/WYfc=
+go.uber.org/zap v1.15.0 h1:ZZCA22JRF2gQE5FoNmhmrf7jeJJ2uhqDUNRYKm8dvmM=
+go.uber.org/zap v1.15.0/go.mod h1:Mb2vm2krFEG5DV0W9qcHBYFtp/Wku1cvYaqPsS/WYfc=
+go4.org v0.0.0-20180809161055-417644f6feb5/go.mod h1:MkTOUMDaeVYJUOUsaDXIhWPZYa1yOyC1qaOBpL57BhE=
+go4.org v0.0.0-20200411211856-f5505b9728dd h1:BNJlw5kRTzdmyfh5U8F93HA2OwkP7ZGwA51eJ/0wKOU=
+go4.org v0.0.0-20200411211856-f5505b9728dd/go.mod h1:CIiUVy99QCPfoE13bO4EZaz5GZMZXMSBGhxRdsvzbkg=
+golang.org/x/build v0.0.0-20190111050920-041ab4dc3f9d/go.mod h1:OWs+y06UdEOHN4y+MfF/py+xQ/tYqIWW03b70/CG9Rw=
 golang.org/x/crypto v0.0.0-20170930174604-9419663f5a44/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
+golang.org/x/crypto v0.0.0-20181029021203-45a5f77698d3/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
+golang.org/x/crypto v0.0.0-20181030102418-4d3f4d9ffa16/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/crypto v0.0.0-20181203042331-505ab145d0a9/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
+golang.org/x/crypto v0.0.0-20190123085648-057139ce5d2b/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/crypto v0.0.0-20190211182817-74369b46fc67/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/crypto v0.0.0-20190225124518-7f87c0fbb88b/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/crypto v0.0.0-20190228161510-8dd112bcdc25/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20190313024323-a1f597ede03a/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20190426145343-a29dc8fdc734/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20190513172903-22d7a77e9e5f/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20190530122614-20be4c3c3ed5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20190611184440-5c40567a22f8/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20190618222545-ea8f1a30c443/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20190701094942-4def268fd1a4/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20190923035154-9ee001bba392/go.mod h1:/lpIB1dKB+9EgE3H3cr1v9wB50oz8l4C4h62xy7jSTY=
 golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
-golang.org/x/crypto v0.0.0-20191206172530-e9b2fee46413 h1:ULYEB3JvPRE/IfO+9uO7vKV/xzVTO7XPAwm8xbf4w2g=
-golang.org/x/crypto v0.0.0-20191206172530-e9b2fee46413/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/crypto v0.0.0-20200117160349-530e935923ad/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/crypto v0.0.0-20200128174031-69ecbb4d6d5d/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/crypto v0.0.0-20200221231518-2aa609cf4a9d/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/crypto v0.0.0-20200423211502-4bdfaf469ed5/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/crypto v0.0.0-20200510223506-06a226fb4e37/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/crypto v0.0.0-20200604202706-70a84ac30bf9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9 h1:psW17arqaxU48Z5kZ0CQnkZWQJsqcURM6tKiBApRjXI=
+golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
+golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
+golang.org/x/exp v0.0.0-20190510132918-efd6b22b2522/go.mod h1:ZjyILWgesfNpC6sMxTJOJm9Kp84zZh5NQWvqDGG3Qr8=
+golang.org/x/exp v0.0.0-20190829153037-c13cbed26979/go.mod h1:86+5VVa7VpoJ4kLfm080zCjGlMRFzhUhsZKEZO7MGek=
+golang.org/x/exp v0.0.0-20191030013958-a1ab85dbe136/go.mod h1:JXzH8nQsPlswgeRAPE3MuO9GYsAcnJvJ4vnMwN/5qkY=
+golang.org/x/exp v0.0.0-20191129062945-2f5052295587/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
+golang.org/x/exp v0.0.0-20191227195350-da58074b4299/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
+golang.org/x/exp v0.0.0-20200207192155-f17229e696bd h1:zkO/Lhoka23X63N9OSzpSeROEUQ5ODw47tM3YWjygbs=
+golang.org/x/exp v0.0.0-20200207192155-f17229e696bd/go.mod h1:J/WKrq2StrnmMY6+EHIKF9dgMWnmCNThgcyBT1FY9mM=
+golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js=
+golang.org/x/image v0.0.0-20190802002840-cff245a6509b/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
+golang.org/x/lint v0.0.0-20180702182130-06c8688daad7/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
 golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
 golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU=
 golang.org/x/lint v0.0.0-20190301231843-5614ed5bae6f/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
 golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
-golang.org/x/lint v0.0.0-20190930215403-16217165b5de h1:5hukYrvBGR8/eNkX5mdUezrA6JiaEZDtJb9Ei+1LlBs=
+golang.org/x/lint v0.0.0-20190409202823-959b441ac422/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
+golang.org/x/lint v0.0.0-20190909230951-414d861bb4ac/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
 golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
-golang.org/x/lint v0.0.0-20191125180803-fdd1cda4f05f h1:J5lckAjkw6qYlOZNj90mLYNTEKDvWeuc1yieZ8qUzUE=
 golang.org/x/lint v0.0.0-20191125180803-fdd1cda4f05f/go.mod h1:5qLYkcX4OjUUV8bRuDixDT3tpyyb+LUpUlRWLxfhWrs=
+golang.org/x/lint v0.0.0-20200130185559-910be7a94367 h1:0IiAsCRByjO2QjX7ZPkw5oU9x+n1YqRL802rjC0c3Aw=
+golang.org/x/lint v0.0.0-20200130185559-910be7a94367/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
+golang.org/x/mobile v0.0.0-20190312151609-d3739f865fa6/go.mod h1:z+o9i4GpDbdi3rU15maQ/Ox0txvL9dWGYEHz965HBQE=
+golang.org/x/mobile v0.0.0-20190719004257-d2bd2a29d028/go.mod h1:E/iHnbuqvinMTCcRqshq8CkpyQDoeVncDDYHnLhea+o=
 golang.org/x/mod v0.0.0-20190513183733-4bf6d317e70e/go.mod h1:mXi4GBBbnImb6dmsKGUJ2LatrhH/nqhxcFungHvyanc=
+golang.org/x/mod v0.1.0/go.mod h1:0QHyrYULN0/3qlju5TqG8bIK38QM8yzMo5ekMj3DlcY=
 golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
+golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/mod v0.3.0 h1:RM4zey1++hCTbCVQfnWeKs9/IEsaBLA8vTkd0WVtmH4=
+golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/net v0.0.0-20180524181706-dfa909b99c79/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20181011144130-49bb7cea24b1/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20181023162649-9b4f9f5ad519/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20181029044818-c44066c5c816/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20181106065722-10aee1819953/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20181201002055-351d144fa1fc/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20181220203305-927f97764cc3/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20190125091013-d26f9f9a57f3/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20190227160552-c95aed5357e7/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190228165749-92fc7df08ae7/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190313220215-9f648a60d977/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190501004415-9ce7a6920f09/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190503192946-f4e77d36d62c/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190522155817-f3200d17e092/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
+golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
 golang.org/x/net v0.0.0-20190611141213-3f473d35a33a/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20190620200207-3b0461eec859 h1:R/3boaszxrf1GEUWTVDzSKVwLmSJpwZ1yqXm8j0v2QI=
+golang.org/x/net v0.0.0-20190613194153-d28f0bde5980/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20190724013045-ca1201d0de80/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20190813141303-74dc4d7220e7/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20190827160401-ba9fcec4b297/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20190921015927-1a5e07d1ff72/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20190923162816-aa69164e4478/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20191002035440-2ec189313ef0/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20191007182048-72f939374954/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200202094626-16171245cfb2/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200222125558-5a598a2470a0/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200519113804-d87ec0cfa476/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
+golang.org/x/net v0.0.0-20200520004742-59133d7f0dd7/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
+golang.org/x/net v0.0.0-20200602114024-627f9648deb9/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
+golang.org/x/net v0.0.0-20200625001655-4c5254603344/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
+golang.org/x/net v0.0.0-20200707034311-ab3426394381 h1:VXak5I6aEWmAXeQjA+QSZzlgNrpq9mjcfDemuexIKsU=
+golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
 golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
+golang.org/x/oauth2 v0.0.0-20181017192945-9dcd33a902f4/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
+golang.org/x/oauth2 v0.0.0-20181203162652-d668ce993890/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
 golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
+golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
+golang.org/x/oauth2 v0.0.0-20191202225959-858c2ad4c8b6/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
+golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
+golang.org/x/perf v0.0.0-20180704124530-6e6d33e29852/go.mod h1:JLpeXjPJfIyPr5TlbXLkXWLhP8nz10XfvxElABhCtcw=
 golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20190423024810-112230192c58 h1:8gQV6CLnAEikrhgkHFbMAEhagSSnXWGV915qUMm9mrU=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20200317015054-43a5402ce75a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20200625203802-6e8e738ad208 h1:qwRHBd0NqMbJxfbotnDhm2ByMI1Shq4Y6oRJo21SGJA=
+golang.org/x/sync v0.0.0-20200625203802-6e8e738ad208/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sys v0.0.0-20180202135801-37707fdb30a5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20180823144017-11551d06cbcc/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20181026203630-95b1ffbd15a5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20181029174526-d69651ed3497/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20181107165924-66b7b1311ac8/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20181116152217-5ac8a444bdc5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20181122145206-62eef0e2fa9b/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20181205085412-a5c9d58dba9a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190124100055-b90733256f2e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190219092855-153ac476189d/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190228124157-a34e9553db1e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190302025703-b6889370fb10/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190312061237-fead79001313/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190316082340-a2f829d7f35f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190405154228-4b34438f7a67/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190411185658-b44545bcd369/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190502145724-3ef323f4f1fd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190507160741-ecd444e8653b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190524122548-abf6ff778158/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190524152521-dbbf3f1254d4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190526052359-791d8a0f4d09/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190606165138-5da285871e9c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190610200419-93c9922d18ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190624142023-c5567b49c5d0/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190626221950-04f50cda93cb/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20190813064441-fde4db37ae7a/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190726091711-fc99dfbffb4e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190801041406-cbf593c0f2f3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190826190057-c7b8b68b1456/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190902133755-9109b7679e13/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190904154756-749cb33beabd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190922100055-0a153f010e69/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20191210023423-ac6580df4449 h1:gSbV7h1NRL2G1xTg/owz62CST1oJBmxy4QpMMregXVQ=
-golang.org/x/sys v0.0.0-20191210023423-ac6580df4449/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200107162124-548cf772de50 h1:YvQ10rzcqWXLlJZ3XCUoO25savxmscf4+SC+ZqiCHhA=
-golang.org/x/sys v0.0.0-20200107162124-548cf772de50/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190924154521-2837fb4f24fe/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191008105621-543471e840be/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191025021431-6c3a3bfe00ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191025090151-53bf42e6b339/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191120155948-bd437916bb0e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191220142924-d4481acd189f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191228213918-04cbcbbfeed8/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200106162015-b016eb3dc98e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200122134326-e047566fdf82/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200124204421-9fbb57f87de9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200202164722-d101bd2416d5/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200212091648-12a6c2dcc1e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200217220822-9197077df867/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200420163511-1957bb5e6d1f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200509044756-6aff5f38e54f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200519105757-fe76b779f299/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200602225109-6fdc65e7d980 h1:OjiUf46hAmXblsZdnoSXsEUSKU8r1UEzcL5RVZ4gO9Y=
+golang.org/x/sys v0.0.0-20200602225109-6fdc65e7d980/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.2 h1:tW2bmiBqwgJj/UpqtC8EpXEZVYOwU0yG4iWbprSVAcs=
 golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
-golang.org/x/time v0.0.0-20190308202827-9d24e82272b4 h1:SvFZT6jyqRaOeXpc5h/JSfZenJ2O330aBsf7JfSUXmQ=
+golang.org/x/time v0.0.0-20180412165947-fbb02b2291d2/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
+golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
+golang.org/x/time v0.0.0-20191024005414-555d28b269f0 h1:/5xXl8Y5W96D+TtHSlonuFqGHIWVuyCkGJLwGh9JJFs=
+golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/tools v0.0.0-20180221164845-07fd8470d635/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20180828015842-6cd1fcedba52/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20181030000716-a0a13e073c7b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20181030221726-6c7e314b6563/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20181130052023-1c3d964395ce/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY=
 golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+golang.org/x/tools v0.0.0-20190312151545-0bb0c0a6e846/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
 golang.org/x/tools v0.0.0-20190312170243-e65039ee4138/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
 golang.org/x/tools v0.0.0-20190328211700-ab21143f2384/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+golang.org/x/tools v0.0.0-20190425150028-36563e24a262/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
+golang.org/x/tools v0.0.0-20190506145303-2d16b83fe98c/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
+golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
+golang.org/x/tools v0.0.0-20190606124116-d0a3d012864b/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
 golang.org/x/tools v0.0.0-20190621195816-6e04913cbbac/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
+golang.org/x/tools v0.0.0-20190628153133-6cdbf07be9d0/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
+golang.org/x/tools v0.0.0-20190816200558-6889da9d5479/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20190911174233-4f2ddba30aff/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191012152004-8de300cfc20a/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.0.0-20191029041327-9cc4af7d6b2c/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20191029190741-b9c20aec41a5 h1:hKsoRgsbwY1NafxrwTs+k64bikrLBkAgPir1TNCj3Zs=
 golang.org/x/tools v0.0.0-20191029190741-b9c20aec41a5/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191030062658-86caa796c7ab/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191108193012-7d206e10da11/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191113191852-77e3bb0ad9e7/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191115202509-3a792d9c32b2/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.0.0-20191125144606-a911d9008d1f/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20200108195415-316d2f248479 h1:csuS+MHeEA2eWhyjQCMaPMq4z1+/PohkBSjJZHSIbOE=
-golang.org/x/tools v0.0.0-20200108195415-316d2f248479/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
-golang.org/x/xerrors v0.0.0-20190513163551-3ee3066db522/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/tools v0.0.0-20191216052735-49a3e744a425/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20191216173652-a0e659d51361/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20191227053925-7b8e75db28f4/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200103221440-774c71fcf114/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200130002326-2f3ba24bd6e7/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200207183749-b753a1ba74fa/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200212150539-ea181f53ac56/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200216192241-b320d3a0f5a2/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200711155855-7342f9734a7d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA=
+golang.org/x/tools v0.0.0-20200827010519-17fd2f27a9e3 h1:r3P/5xOq/dK1991B65Oy6E1fRF/2d/fSYZJ/fXGVfJc=
+golang.org/x/tools v0.0.0-20200827010519-17fd2f27a9e3/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE=
+golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+google.golang.org/api v0.0.0-20180910000450-7ca32eb868bf/go.mod h1:4mhQ8q/RsB7i+udVvVy5NUi08OU8ZlA0gRVgrF7VFY0=
+google.golang.org/api v0.0.0-20181030000543-1d582fd0359e/go.mod h1:4mhQ8q/RsB7i+udVvVy5NUi08OU8ZlA0gRVgrF7VFY0=
+google.golang.org/api v0.1.0/go.mod h1:UGEZY7KEX120AnNLIHFMKIo4obdJhkp2tPbaPlQx13Y=
 google.golang.org/api v0.3.1/go.mod h1:6wY9I6uQWHQ8EM57III9mq/AjF+i8G65rmVagqKMtkk=
-google.golang.org/api v0.3.2 h1:iTp+3yyl/KOtxa/d1/JUE0GGSoR6FuW5udver22iwpw=
 google.golang.org/api v0.3.2/go.mod h1:6wY9I6uQWHQ8EM57III9mq/AjF+i8G65rmVagqKMtkk=
+google.golang.org/api v0.4.0/go.mod h1:8k5glujaEP+g9n7WNsDg8QP6cUVNI86fCNMcbazEtwE=
+google.golang.org/api v0.7.0/go.mod h1:WtwebWUNSVBH/HAw79HIFXZNqEvBhG+Ra+ax0hx3E3M=
+google.golang.org/api v0.8.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg=
+google.golang.org/api v0.9.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg=
+google.golang.org/api v0.13.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI=
+google.golang.org/api v0.14.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI=
+google.golang.org/api v0.15.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI=
+google.golang.org/api v0.17.0 h1:0q95w+VuFtv4PAx4PZVQdBMmYbaCHbnfKaEiDIcVyag=
+google.golang.org/api v0.17.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
 google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
+google.golang.org/appengine v1.2.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
+google.golang.org/appengine v1.3.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
 google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
+google.golang.org/appengine v1.5.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
+google.golang.org/appengine v1.6.1/go.mod h1:i06prIuMbXzDqacNJfV5OdTW448YApPu5ww/cMBSeb0=
+google.golang.org/appengine v1.6.5/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
+google.golang.org/genproto v0.0.0-20180518175338-11a468237815/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
 google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
 google.golang.org/genproto v0.0.0-20180831171423-11092d34479b/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
+google.golang.org/genproto v0.0.0-20181029155118-b69ba1387ce2/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
+google.golang.org/genproto v0.0.0-20181202183823-bd91e49a0898/go.mod h1:7Ep/1NZk928CDR8SjdVbjWNpdIf6nzjE3BTgJDr2Atg=
+google.golang.org/genproto v0.0.0-20190306203927-b5d61aea6440/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
 google.golang.org/genproto v0.0.0-20190307195333-5fe7a883aa19/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
+google.golang.org/genproto v0.0.0-20190418145605-e7d98fc518a7/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
 google.golang.org/genproto v0.0.0-20190425155659-357c62f0e4bb/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
+google.golang.org/genproto v0.0.0-20190502173448-54afdca5d873/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
+google.golang.org/genproto v0.0.0-20190530194941-fb225487d101/go.mod h1:z3L6/3dTEVtUr6QSP8miRzeRqwQOioJ9I66odjN4I7s=
+google.golang.org/genproto v0.0.0-20190801165951-fa694d86fc64/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
+google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
+google.golang.org/genproto v0.0.0-20190911173649-1774047e7e51/go.mod h1:IbNlFCBrqXvoKpeg0TB2l7cyZUmoaFKYIwrEpbDKLA8=
+google.golang.org/genproto v0.0.0-20191108220845-16a3f7862a1a/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
+google.golang.org/genproto v0.0.0-20191115194625-c23dd37a84c9/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
+google.golang.org/genproto v0.0.0-20191216164720-4f79533eabd1/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
+google.golang.org/genproto v0.0.0-20191230161307-f3c370f40bfb/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
+google.golang.org/genproto v0.0.0-20200212174721-66ed5ce911ce/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200513103714-09dca8ec2884/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo=
+google.golang.org/genproto v0.0.0-20200608115520-7c474a2e3482 h1:i+Aiej6cta/Frzp13/swvwz5O00kYcSe0A/C5Wd7zX8=
+google.golang.org/genproto v0.0.0-20200608115520-7c474a2e3482/go.mod h1:jDfRM7FcilCzHH/e9qn6dsT145K34l5v+OpcnNgKAAA=
+google.golang.org/grpc v1.12.0/go.mod h1:yo6s7OP7yaDglbqo1J04qKzAhqBH6lvTonzMVmEdcZw=
+google.golang.org/grpc v1.14.0/go.mod h1:yo6s7OP7yaDglbqo1J04qKzAhqBH6lvTonzMVmEdcZw=
+google.golang.org/grpc v1.16.0/go.mod h1:0JHn/cJsOMiMfNA9+DeHDlAU7KAAB5GDlYFpa9MZMio=
 google.golang.org/grpc v1.17.0/go.mod h1:6QZJwpn2B+Zp71q/5VxRsJ6NXXVCE5NRUHRo+f3cWCs=
 google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
+google.golang.org/grpc v1.20.0/go.mod h1:chYK+tFQF0nDUGJgXMSgLCQk3phJEuONr2DCgLDdAQM=
 google.golang.org/grpc v1.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiqXj38=
+google.golang.org/grpc v1.21.0/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM=
+google.golang.org/grpc v1.21.1/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM=
+google.golang.org/grpc v1.22.1/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg=
+google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg=
+google.golang.org/grpc v1.23.1/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg=
+google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY=
+google.golang.org/grpc v1.26.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
+google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
+google.golang.org/grpc v1.27.1/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
+google.golang.org/grpc v1.29.1 h1:EC2SB8S04d2r73uptxphDSUG+kTKVgjRPF+N3xpxRB4=
+google.golang.org/grpc v1.29.1/go.mod h1:itym6AZVZYACWQqET3MqgPpjcuV5QH3BxFS3IjizoKk=
+google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
+google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=
+google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM=
+google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE=
+google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo=
+google.golang.org/protobuf v1.22.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
+google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
+google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
+google.golang.org/protobuf v1.24.0 h1:UhZDfRO8JRQru4/+LlLE0BRKGF8L+PICnvYZmx/fEGA=
+google.golang.org/protobuf v1.24.0/go.mod h1:r/3tXBNzIEhYS9I1OUVjXDlt8tc493IdKGjtUeSXeh4=
 gopkg.in/alecthomas/kingpin.v2 v2.2.6 h1:jMFz6MfLP0/4fUyZle81rXUoxOBFi19VUFKVDOQfozc=
 gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15 h1:YR8cESwS4TdDjEe65xsg0ogRM/Nc3DYOhEAlW+xobZo=
 gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/cheggaaa/pb.v1 v1.0.25/go.mod h1:V/YB90LKu/1FcN3WVnfiiE5oMCibMjukxqG/qStrOgw=
 gopkg.in/cheggaaa/pb.v1 v1.0.28 h1:n1tBJnnK2r7g9OW2btFH91V92STTUevLXYFb8gy9EMk=
 gopkg.in/cheggaaa/pb.v1 v1.0.28/go.mod h1:V/YB90LKu/1FcN3WVnfiiE5oMCibMjukxqG/qStrOgw=
 gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=
-gopkg.in/fsnotify.v1 v1.4.7 h1:xOHLXZwVvI9hhs+cLKq5+I5onOuwQLhQwiu63xxlHs4=
 gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
+gopkg.in/gcfg.v1 v1.2.3/go.mod h1:yesOnuUOFQAhST5vPY4nbZsb/huCgGGXlipJsBn0b3o=
+gopkg.in/inf.v0 v0.9.1/go.mod h1:cWUDdTG/fYaXco+Dcufb5Vnc6Gp2YChqWtbxRZE0mXw=
+gopkg.in/resty.v1 v1.12.0/go.mod h1:mDo4pnntr5jdWRML875a/NmxYqAlA73dVijT2AXvQQo=
 gopkg.in/src-d/go-cli.v0 v0.0.0-20181105080154-d492247bbc0d/go.mod h1:z+K8VcOYVYcSwSjGebuDL6176A1XskgbtNl64NSg+n8=
 gopkg.in/src-d/go-log.v1 v1.0.1/go.mod h1:GN34hKP0g305ysm2/hctJ0Y8nWP3zxXXJ8GFabTyABE=
 gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ=
 gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
-gopkg.in/urfave/cli.v2 v2.0.0-20180128182452-d3ae77c26ac8 h1:Ggy3mWN4l3PUFPfSG0YB3n5fVYggzysUmiUQ89SnX6Y=
-gopkg.in/urfave/cli.v2 v2.0.0-20180128182452-d3ae77c26ac8/go.mod h1:cKXr3E0k4aosgycml1b5z33BVV6hai1Kh7uDgFOkbcs=
+gopkg.in/warnings.v0 v0.1.2/go.mod h1:jksf8JmL6Qr/oQM2OXTHunEvvTAsrWBLb6OOjuVWRNI=
+gopkg.in/yaml.v2 v2.0.0-20170812160011-eb3733d160e7/go.mod h1:JAlM8MvJe8wmxCU4Bli9HhUf9+ttbYbLASfIpnQbh74=
 gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.2.4 h1:/eiJrUcujPVeJ3xlSWaiNi3uSVmDGBK1pDHUHAnao1I=
+gopkg.in/yaml.v2 v2.2.3/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.5/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.3.0 h1:clyUAQHOM3G0M3f5vQj7LuJrETvjVot3Z5el9nffUtU=
+gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gotest.tools v2.2.0+incompatible h1:VsBPFP1AI068pPrMxtb/S8Zkgf9xEmTLJjfM+P5UIEo=
 gotest.tools v2.2.0+incompatible/go.mod h1:DsYFclhRJ6vuDpmuTbkuFWG+y2sxOXAzmJt81HFBacw=
+grpc.go4.org v0.0.0-20170609214715-11d0a25b4919/go.mod h1:77eQGdRu53HpSqPFJFmuJdjuHRquDANNeA4x7B8WQ9o=
 honnef.co/go/tools v0.0.0-20180728063816-88497007e858/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
 honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+honnef.co/go/tools v0.0.0-20190418001031-e561f6794a2a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
 honnef.co/go/tools v0.0.1-2019.2.3 h1:3JgtbtFHMiCmsznwGVTUWbgGov+pVqnlf1dEJTNAXeM=
 honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg=
+howett.net/plist v0.0.0-20181124034731-591f970eefbb h1:jhnBjNi9UFpfpl8YZhA9CrOqpnJdvzuiHsl/dnxl11M=
+howett.net/plist v0.0.0-20181124034731-591f970eefbb/go.mod h1:vMygbs4qMhSZSc4lCUl2OEE+rDiIIJAIdR4m7MiMcm0=
 launchpad.net/gocheck v0.0.0-20140225173054-000000000087 h1:Izowp2XBH6Ya6rv+hqbceQyw/gSGoXfH/UPoTGduL54=
 launchpad.net/gocheck v0.0.0-20140225173054-000000000087/go.mod h1:hj7XX3B/0A+80Vse0e+BUHsHMTEhd0O4cpUHr/e/BUM=
+modernc.org/cc v1.0.0 h1:nPibNuDEx6tvYrUAtvDTTw98rx5juGsa5zuDnKwEEQQ=
+modernc.org/cc v1.0.0/go.mod h1:1Sk4//wdnYJiUIxnW8ddKpaOJCF37yAdqYnkxUpaYxw=
+modernc.org/golex v1.0.0 h1:wWpDlbK8ejRfSyi0frMyhilD3JBvtcx2AdGDnU+JtsE=
+modernc.org/golex v1.0.0/go.mod h1:b/QX9oBD/LhixY6NDh+IdGv17hgB+51fET1i2kPSmvk=
+modernc.org/mathutil v1.1.1 h1:FeylZSVX8S+58VsyJlkEj2bcpdytmp9MmDKZkKx8OIE=
+modernc.org/mathutil v1.1.1/go.mod h1:mZW8CKdRPY1v87qxC/wUdX5O1qDzXMP5TH3wjfpga6E=
+modernc.org/strutil v1.1.0 h1:+1/yCzZxY2pZwwrsbH+4T7BQMoLQ9QiBshRC9eicYsc=
+modernc.org/strutil v1.1.0/go.mod h1:lstksw84oURvj9y3tn8lGvRxyRC1S2+g5uuIzNfIOBs=
+modernc.org/xc v1.0.0 h1:7ccXrupWZIS3twbUGrtKmHS2DXY6xegFua+6O3xgAFU=
+modernc.org/xc v1.0.0/go.mod h1:mRNCo0bvLjGhHO9WsyuKVU4q0ceiDDDoEeWDJHrNx8I=
+rsc.io/binaryregexp v0.2.0/go.mod h1:qTv7/COck+e2FymRvadv62gMdZztPaShugOCi3I+8D8=
+rsc.io/quote/v3 v3.1.0/go.mod h1:yEA65RcK8LyAZtP9Kv3t0HmxON59tX3rD+tICJqUlj0=
+rsc.io/sampler v1.3.0/go.mod h1:T1hPZKmBbMNahiBKFy5HrXp6adAjACjK9JXDnKaTXpA=
+sigs.k8s.io/yaml v1.1.0/go.mod h1:UJmg0vDUVViEyp3mgSv9WPwZCDxu4rQW1olrI1uml+o=
+sourcegraph.com/sourcegraph/appdash v0.0.0-20190731080439-ebfcffb1b5c0/go.mod h1:hI742Nqp5OhwiqlzhgfbWU4mW4yO10fP+LoT9WOswdU=
+sourcegraph.com/sourcegraph/go-diff v0.5.0/go.mod h1:kuch7UrkMzY0X+p9CRK03kfuPQ2zzQcaEFbx8wA8rck=
+sourcegraph.com/sqs/pbtypes v0.0.0-20180604144634-d3ebe8f20ae4/go.mod h1:ketZ/q3QxT9HOBeFhu6RdvsftgpsbFHBF5Cas6cDKZ0=
diff --git a/journal/fs.go b/journal/fs.go
new file mode 100644
index 000000000..57774d3aa
--- /dev/null
+++ b/journal/fs.go
@@ -0,0 +1,136 @@
+package journal
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/node/repo"
+)
+
+const RFC3339nocolon = "2006-01-02T150405Z0700"
+
+// fsJournal is a basic journal backed by files on a filesystem.
+type fsJournal struct {
+	EventTypeRegistry
+
+	dir       string
+	sizeLimit int64
+
+	fi    *os.File
+	fSize int64
+
+	incoming chan *Event
+
+	closing chan struct{}
+	closed  chan struct{}
+}
+
+// OpenFSJournal constructs a rolling filesystem journal, with a default
+// per-file size limit of 1GiB.
+func OpenFSJournal(lr repo.LockedRepo, disabled DisabledEvents) (Journal, error) {
+	dir := filepath.Join(lr.Path(), "journal")
+	if err := os.MkdirAll(dir, 0755); err != nil {
+		return nil, fmt.Errorf("failed to mk directory %s for file journal: %w", dir, err)
+	}
+
+	f := &fsJournal{
+		EventTypeRegistry: NewEventTypeRegistry(disabled),
+		dir:               dir,
+		sizeLimit:         1 << 30,
+		incoming:          make(chan *Event, 32),
+		closing:           make(chan struct{}),
+		closed:            make(chan struct{}),
+	}
+
+	if err := f.rollJournalFile(); err != nil {
+		return nil, err
+	}
+
+	go f.runLoop()
+
+	return f, nil
+}
+
+func (f *fsJournal) RecordEvent(evtType EventType, supplier func() interface{}) {
+	defer func() {
+		if r := recover(); r != nil {
+			log.Warnf("recovered from panic while recording journal event; type=%s, err=%v", evtType, r)
+		}
+	}()
+
+	if !evtType.Enabled() {
+		return
+	}
+
+	je := &Event{
+		EventType: evtType,
+		Timestamp: build.Clock.Now(),
+		Data:      supplier(),
+	}
+	select {
+	case f.incoming <- je:
+	case <-f.closing:
+		log.Warnw("journal closed but tried to log event", "event", je)
+	}
+}
+
+func (f *fsJournal) Close() error {
+	close(f.closing)
+	<-f.closed
+	return nil
+}
+
+func (f *fsJournal) putEvent(evt *Event) error {
+	b, err := json.Marshal(evt)
+	if err != nil {
+		return err
+	}
+	n, err := f.fi.Write(append(b, '\n'))
+	if err != nil {
+		return err
+	}
+
+	f.fSize += int64(n)
+
+	if f.fSize >= f.sizeLimit {
+		_ = f.rollJournalFile()
+	}
+
+	return nil
+}
+
+func (f *fsJournal) rollJournalFile() error {
+	if f.fi != nil {
+		_ = f.fi.Close()
+	}
+
+	nfi, err := os.Create(filepath.Join(f.dir, fmt.Sprintf("lotus-journal-%s.ndjson", build.Clock.Now().Format(RFC3339nocolon))))
+	if err != nil {
+		return xerrors.Errorf("failed to open journal file: %w", err)
+	}
+
+	f.fi = nfi
+	f.fSize = 0
+	return nil
+}
+
+func (f *fsJournal) runLoop() {
+	defer close(f.closed)
+
+	for {
+		select {
+		case je := <-f.incoming:
+			if err := f.putEvent(je); err != nil {
+				log.Errorw("failed to write out journal event", "event", je, "err", err)
+			}
+		case <-f.closing:
+			_ = f.fi.Close()
+			return
+		}
+	}
+}
diff --git a/journal/global.go b/journal/global.go
new file mode 100644
index 000000000..b4d0e0a1b
--- /dev/null
+++ b/journal/global.go
@@ -0,0 +1,9 @@
+package journal
+
+var (
+	// J is a globally accessible Journal. It starts being NilJournal, and early
+	// during the Lotus initialization routine, it is reset to whichever Journal
+	// is configured (by default, the filesystem journal). Components can safely
+	// record in the journal by calling: journal.J.RecordEvent(...).
+	J Journal = NilJournal() // nolint
+)
diff --git a/journal/nil.go b/journal/nil.go
new file mode 100644
index 000000000..fa72fa373
--- /dev/null
+++ b/journal/nil.go
@@ -0,0 +1,16 @@
+package journal
+
+type nilJournal struct{}
+
+// nilj is a singleton nil journal.
+var nilj Journal = &nilJournal{}
+
+func NilJournal() Journal {
+	return nilj
+}
+
+func (n *nilJournal) RegisterEventType(_, _ string) EventType { return EventType{} }
+
+func (n *nilJournal) RecordEvent(_ EventType, _ func() interface{}) {}
+
+func (n *nilJournal) Close() error { return nil }
diff --git a/journal/registry.go b/journal/registry.go
new file mode 100644
index 000000000..6ab5b5fb1
--- /dev/null
+++ b/journal/registry.go
@@ -0,0 +1,57 @@
+package journal
+
+import "sync"
+
+// EventTypeRegistry is a component that constructs tracked EventType tokens,
+// for usage with a Journal.
+type EventTypeRegistry interface {
+
+	// RegisterEventType introduces a new event type to a journal, and
+	// returns an EventType token that components can later use to check whether
+	// journalling for that type is enabled/suppressed, and to tag journal
+	// entries appropriately.
+	RegisterEventType(system, event string) EventType
+}
+
+// eventTypeRegistry is an embeddable mixin that takes care of tracking disabled
+// event types, and returning initialized/safe EventTypes when requested.
+type eventTypeRegistry struct {
+	sync.Mutex
+
+	m map[string]EventType
+}
+
+var _ EventTypeRegistry = (*eventTypeRegistry)(nil)
+
+func NewEventTypeRegistry(disabled DisabledEvents) EventTypeRegistry {
+	ret := &eventTypeRegistry{
+		m: make(map[string]EventType, len(disabled)+32), // + extra capacity.
+	}
+
+	for _, et := range disabled {
+		et.enabled, et.safe = false, true
+		ret.m[et.System+":"+et.Event] = et
+	}
+
+	return ret
+}
+
+func (d *eventTypeRegistry) RegisterEventType(system, event string) EventType {
+	d.Lock()
+	defer d.Unlock()
+
+	key := system + ":" + event
+	if et, ok := d.m[key]; ok {
+		return et
+	}
+
+	et := EventType{
+		System:  system,
+		Event:   event,
+		enabled: true,
+		safe:    true,
+	}
+
+	d.m[key] = et
+	return et
+}
diff --git a/journal/registry_test.go b/journal/registry_test.go
new file mode 100644
index 000000000..9d2085c12
--- /dev/null
+++ b/journal/registry_test.go
@@ -0,0 +1,49 @@
+package journal
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestDisabledEvents(t *testing.T) {
+	req := require.New(t)
+
+	test := func(dis DisabledEvents) func(*testing.T) {
+		return func(t *testing.T) {
+			registry := NewEventTypeRegistry(dis)
+
+			reg1 := registry.RegisterEventType("system1", "disabled1")
+			reg2 := registry.RegisterEventType("system2", "disabled2")
+
+			req.False(reg1.Enabled())
+			req.False(reg2.Enabled())
+			req.True(reg1.safe)
+			req.True(reg2.safe)
+
+			reg3 := registry.RegisterEventType("system3", "enabled3")
+			req.True(reg3.Enabled())
+			req.True(reg3.safe)
+		}
+	}
+
+	t.Run("direct", test(DisabledEvents{
+		EventType{System: "system1", Event: "disabled1"},
+		EventType{System: "system2", Event: "disabled2"},
+	}))
+
+	dis, err := ParseDisabledEvents("system1:disabled1,system2:disabled2")
+	req.NoError(err)
+
+	t.Run("parsed", test(dis))
+
+	dis, err = ParseDisabledEvents("  system1:disabled1 , system2:disabled2  ")
+	req.NoError(err)
+
+	t.Run("parsed_spaces", test(dis))
+}
+
+func TestParseDisableEvents(t *testing.T) {
+	_, err := ParseDisabledEvents("system1:disabled1:failed,system2:disabled2")
+	require.Error(t, err)
+}
diff --git a/journal/types.go b/journal/types.go
new file mode 100644
index 000000000..56c7d4bc0
--- /dev/null
+++ b/journal/types.go
@@ -0,0 +1,102 @@
+package journal
+
+import (
+	"fmt"
+	"strings"
+	"time"
+
+	logging "github.com/ipfs/go-log"
+)
+
+var log = logging.Logger("journal")
+
+var (
+	// DefaultDisabledEvents lists the journal events disabled by
+	// default, usually because they are considered noisy.
+	DefaultDisabledEvents = DisabledEvents{
+		EventType{System: "mpool", Event: "add"},
+		EventType{System: "mpool", Event: "remove"},
+	}
+)
+
+// DisabledEvents is the set of event types whose journaling is suppressed.
+type DisabledEvents []EventType
+
+// ParseDisabledEvents parses a string of the form: "system1:event1,system2:event2[,...]"
+// into a DisabledEvents object, returning an error if the string failed to parse.
+//
+// It sanitizes strings via strings.TrimSpace.
+func ParseDisabledEvents(s string) (DisabledEvents, error) {
+	s = strings.TrimSpace(s) // sanitize
+	evts := strings.Split(s, ",")
+	ret := make(DisabledEvents, 0, len(evts))
+	for _, evt := range evts {
+		evt = strings.TrimSpace(evt) // sanitize
+		s := strings.Split(evt, ":")
+		if len(s) != 2 {
+			return nil, fmt.Errorf("invalid event type: %s", s)
+		}
+		ret = append(ret, EventType{System: s[0], Event: s[1]})
+	}
+	return ret, nil
+}
+
+// EventType represents the signature of an event.
+type EventType struct {
+	System string
+	Event  string
+
+	// enabled stores whether this event type is enabled.
+	enabled bool
+
+	// safe is a sentinel marker that's set to true if this EventType was
+	// constructed correctly (via Journal#RegisterEventType).
+	safe bool
+}
+
+func (et EventType) String() string {
+	return et.System + ":" + et.Event
+}
+
+// Enabled returns whether this event type is enabled in the journaling
+// subsystem. Users are advised to check this before actually attempting to
+// add a journal entry, as it helps bypass object construction for events that
+// would be discarded anyway.
+//
+// All event types are enabled by default, and specific event types can only
+// be disabled at Journal construction time.
+func (et EventType) Enabled() bool {
+	return et.safe && et.enabled
+}
+
+// Journal represents an audit trail of system actions.
+//
+// Every entry is tagged with a timestamp, a system name, and an event name.
+// The supplied data can be any type, as long as it is JSON serializable,
+// including structs, map[string]interface{}, or primitive types.
+//
+// For cleanliness and type safety, we recommend to use typed events. See the
+// *Evt struct types in this package for more info.
+type Journal interface {
+	EventTypeRegistry
+
+	// RecordEvent records this event to the journal, if and only if the
+	// EventType is enabled. If so, it calls the supplier function to obtain
+	// the payload to record.
+	//
+	// Implementations MUST recover from panics raised by the supplier function.
+	RecordEvent(evtType EventType, supplier func() interface{})
+
+	// Close closes this journal for further writing.
+	Close() error
+}
+
+// Event represents a journal entry.
+//
+// See godocs on Journal for more information.
+type Event struct {
+	EventType
+
+	Timestamp time.Time
+	Data      interface{}
+}
diff --git a/lib/addrutil/parse.go b/lib/addrutil/parse.go
index fad389e33..f9ee04c3f 100644
--- a/lib/addrutil/parse.go
+++ b/lib/addrutil/parse.go
@@ -11,7 +11,7 @@ import (
 	madns "github.com/multiformats/go-multiaddr-dns"
 )
 
-// parseAddresses is a function that takes in a slice of string peer addresses
+// ParseAddresses is a function that takes in a slice of string peer addresses
 // (multiaddr + peerid) and returns a slice of properly constructed peers
 func ParseAddresses(ctx context.Context, addrs []string) ([]peer.AddrInfo, error) {
 	// resolve addresses
diff --git a/lib/auth/handler.go b/lib/auth/handler.go
deleted file mode 100644
index b6112ce8c..000000000
--- a/lib/auth/handler.go
+++ /dev/null
@@ -1,51 +0,0 @@
-package auth
-
-import (
-	"context"
-	"net/http"
-	"strings"
-
-	logging "github.com/ipfs/go-log"
-
-	"github.com/filecoin-project/lotus/api"
-	"github.com/filecoin-project/lotus/api/apistruct"
-)
-
-var log = logging.Logger("auth")
-
-type Handler struct {
-	Verify func(ctx context.Context, token string) ([]api.Permission, error)
-	Next   http.HandlerFunc
-}
-
-func (h *Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-	ctx := r.Context()
-
-	token := r.Header.Get("Authorization")
-	if token == "" {
-		token = r.FormValue("token")
-		if token != "" {
-			token = "Bearer " + token
-		}
-	}
-
-	if token != "" {
-		if !strings.HasPrefix(token, "Bearer ") {
-			log.Warn("missing Bearer prefix in auth header")
-			w.WriteHeader(401)
-			return
-		}
-		token = strings.TrimPrefix(token, "Bearer ")
-
-		allow, err := h.Verify(ctx, token)
-		if err != nil {
-			log.Warnf("JWT Verification failed: %s", err)
-			w.WriteHeader(401)
-			return
-		}
-
-		ctx = apistruct.WithPerm(ctx, allow)
-	}
-
-	h.Next(w, r.WithContext(ctx))
-}
diff --git a/lib/blockstore/blockstore.go b/lib/blockstore/blockstore.go
new file mode 100644
index 000000000..9e74f4373
--- /dev/null
+++ b/lib/blockstore/blockstore.go
@@ -0,0 +1,63 @@
+// blockstore contains all the basic blockstore constructors used by lotus. Any
+// blockstores not ultimately constructed out of the building blocks in this
+// package may not work properly.
+//
+//  * This package correctly wraps blockstores with the IdBlockstore. This blockstore:
+//    * Filters out all puts for blocks with CIDs using the "identity" hash function.
+//    * Extracts inlined blocks from CIDs using the identity hash function and
+//      returns them on get/has, ignoring the contents of the blockstore.
+//  * In the future, this package may enforce additional restrictions on block
+//    sizes, CID validity, etc.
+//
+// To make auditing for misuse of blockstores tractable, this package re-exports
+// parts of the go-ipfs-blockstore package such that no other package needs to
+// import it directly.
+package blockstore
+
+import (
+	"context"
+
+	ds "github.com/ipfs/go-datastore"
+	dssync "github.com/ipfs/go-datastore/sync"
+
+	blockstore "github.com/ipfs/go-ipfs-blockstore"
+)
+
+// NewTemporary returns a temporary blockstore.
+func NewTemporary() blockstore.Blockstore {
+	return NewBlockstore(ds.NewMapDatastore())
+}
+
+// NewTemporarySync returns a thread-safe temporary blockstore.
+func NewTemporarySync() blockstore.Blockstore {
+	return NewBlockstore(dssync.MutexWrap(ds.NewMapDatastore()))
+}
+
+// WrapIDStore wraps the underlying blockstore in an "identity" blockstore.
+func WrapIDStore(bstore blockstore.Blockstore) blockstore.Blockstore {
+	return blockstore.NewIdStore(bstore)
+}
+
+// NewBlockstore creates a new blockstore wrapped by the given datastore.
+func NewBlockstore(dstore ds.Batching) blockstore.Blockstore {
+	return WrapIDStore(blockstore.NewBlockstore(dstore))
+}
+
+// Alias so other packages don't have to import go-ipfs-blockstore
+type Blockstore = blockstore.Blockstore
+type GCBlockstore = blockstore.GCBlockstore
+type CacheOpts = blockstore.CacheOpts
+type GCLocker = blockstore.GCLocker
+
+var NewGCLocker = blockstore.NewGCLocker
+var NewGCBlockstore = blockstore.NewGCBlockstore
+var DefaultCacheOpts = blockstore.DefaultCacheOpts
+var ErrNotFound = blockstore.ErrNotFound
+
+func CachedBlockstore(ctx context.Context, bs Blockstore, opts CacheOpts) (Blockstore, error) {
+	bs, err := blockstore.CachedBlockstore(ctx, bs, opts)
+	if err != nil {
+		return nil, err
+	}
+	return WrapIDStore(bs), nil
+}
diff --git a/lib/bufbstore/buf_bstore.go b/lib/bufbstore/buf_bstore.go
index b3421537e..a766c2b52 100644
--- a/lib/bufbstore/buf_bstore.go
+++ b/lib/bufbstore/buf_bstore.go
@@ -2,26 +2,42 @@ package bufbstore
 
 import (
 	"context"
+	"os"
 
 	block "github.com/ipfs/go-block-format"
 	"github.com/ipfs/go-cid"
-	ds "github.com/ipfs/go-datastore"
-	bstore "github.com/ipfs/go-ipfs-blockstore"
+	logging "github.com/ipfs/go-log/v2"
+
+	bstore "github.com/filecoin-project/lotus/lib/blockstore"
 )
 
+var log = logging.Logger("bufbs")
+
 type BufferedBS struct {
 	read  bstore.Blockstore
 	write bstore.Blockstore
 }
 
 func NewBufferedBstore(base bstore.Blockstore) *BufferedBS {
-	buf := bstore.NewBlockstore(ds.NewMapDatastore())
+	buf := bstore.NewTemporary()
+	if os.Getenv("LOTUS_DISABLE_VM_BUF") == "iknowitsabadidea" {
+		log.Warn("VM BLOCKSTORE BUFFERING IS DISABLED")
+		buf = base
+	}
+
 	return &BufferedBS{
 		read:  base,
 		write: buf,
 	}
 }
 
+func NewTieredBstore(r bstore.Blockstore, w bstore.Blockstore) *BufferedBS {
+	return &BufferedBS{
+		read:  r,
+		write: w,
+	}
+}
+
 var _ (bstore.Blockstore) = &BufferedBS{}
 
 func (bs *BufferedBS) AllKeysChan(ctx context.Context) (<-chan cid.Cid, error) {
@@ -88,10 +104,24 @@ func (bs *BufferedBS) Get(c cid.Cid) (block.Block, error) {
 }
 
 func (bs *BufferedBS) GetSize(c cid.Cid) (int, error) {
-	panic("nyi")
+	s, err := bs.read.GetSize(c)
+	if err == bstore.ErrNotFound || s == 0 {
+		return bs.write.GetSize(c)
+	}
+
+	return s, err
 }
 
 func (bs *BufferedBS) Put(blk block.Block) error {
+	has, err := bs.read.Has(blk.Cid())
+	if err != nil {
+		return err
+	}
+
+	if has {
+		return nil
+	}
+
 	return bs.write.Put(blk)
 }
 
diff --git a/lib/cachebs/cachebs.go b/lib/cachebs/cachebs.go
new file mode 100644
index 000000000..046f100c0
--- /dev/null
+++ b/lib/cachebs/cachebs.go
@@ -0,0 +1,89 @@
+package cachebs
+
+import (
+	"context"
+
+	lru "github.com/hashicorp/golang-lru"
+	block "github.com/ipfs/go-block-format"
+	"github.com/ipfs/go-cid"
+	logging "github.com/ipfs/go-log/v2"
+
+	bstore "github.com/filecoin-project/lotus/lib/blockstore"
+)
+
+//nolint:deadcode,varcheck
+var log = logging.Logger("cachebs")
+
+type CacheBS struct {
+	cache *lru.ARCCache
+	bs    bstore.Blockstore
+}
+
+func NewBufferedBstore(base bstore.Blockstore, size int) bstore.Blockstore {
+	c, err := lru.NewARC(size)
+	if err != nil {
+		panic(err)
+	}
+	// Wrap this in an ID blockstore to avoid caching blocks inlined into
+	// CIDs.
+	return bstore.WrapIDStore(&CacheBS{
+		cache: c,
+		bs:    base,
+	})
+}
+
+var _ (bstore.Blockstore) = &CacheBS{}
+
+func (bs *CacheBS) AllKeysChan(ctx context.Context) (<-chan cid.Cid, error) {
+	return bs.bs.AllKeysChan(ctx)
+}
+
+func (bs *CacheBS) DeleteBlock(c cid.Cid) error {
+	bs.cache.Remove(c)
+
+	return bs.bs.DeleteBlock(c)
+}
+
+func (bs *CacheBS) Get(c cid.Cid) (block.Block, error) {
+	v, ok := bs.cache.Get(c)
+	if ok {
+		return v.(block.Block), nil
+	}
+
+	out, err := bs.bs.Get(c)
+	if err != nil {
+		return nil, err
+	}
+
+	bs.cache.Add(c, out)
+	return out, nil
+}
+
+func (bs *CacheBS) GetSize(c cid.Cid) (int, error) {
+	return bs.bs.GetSize(c)
+}
+
+func (bs *CacheBS) Put(blk block.Block) error {
+	bs.cache.Add(blk.Cid(), blk)
+
+	return bs.bs.Put(blk)
+}
+
+func (bs *CacheBS) Has(c cid.Cid) (bool, error) {
+	if bs.cache.Contains(c) {
+		return true, nil
+	}
+
+	return bs.bs.Has(c)
+}
+
+func (bs *CacheBS) HashOnRead(hor bool) {
+	bs.bs.HashOnRead(hor)
+}
+
+func (bs *CacheBS) PutMany(blks []block.Block) error {
+	for _, blk := range blks {
+		bs.cache.Add(blk.Cid(), blk)
+	}
+	return bs.bs.PutMany(blks)
+}
diff --git a/lib/increadtimeout/incrt.go b/lib/increadtimeout/incrt.go
new file mode 100644
index 000000000..dd5a05ff8
--- /dev/null
+++ b/lib/increadtimeout/incrt.go
@@ -0,0 +1,73 @@
+package incrt
+
+import (
+	"io"
+	"time"
+
+	logging "github.com/ipfs/go-log/v2"
+
+	"github.com/filecoin-project/lotus/build"
+)
+
+var log = logging.Logger("incrt")
+
+type ReaderDeadline interface {
+	Read([]byte) (int, error)
+	SetReadDeadline(time.Time) error
+}
+
+type incrt struct {
+	rd ReaderDeadline
+
+	waitPerByte time.Duration
+	wait        time.Duration
+	maxWait     time.Duration
+}
+
+// New creates an Incremental Reader Timeout, with minimum sustained speed of
+// minSpeed bytes per second and with maximum wait of maxWait
+func New(rd ReaderDeadline, minSpeed int64, maxWait time.Duration) io.Reader {
+	return &incrt{
+		rd:          rd,
+		waitPerByte: time.Second / time.Duration(minSpeed),
+		wait:        maxWait,
+		maxWait:     maxWait,
+	}
+}
+
+type errNoWait struct{}
+
+func (err errNoWait) Error() string {
+	return "wait time exceeded"
+}
+func (err errNoWait) Timeout() bool {
+	return true
+}
+
+func (crt *incrt) Read(buf []byte) (int, error) {
+	start := build.Clock.Now()
+	if crt.wait == 0 {
+		return 0, errNoWait{}
+	}
+
+	err := crt.rd.SetReadDeadline(start.Add(crt.wait))
+	if err != nil {
+		log.Debugf("unable to set deadline: %+v", err)
+	}
+
+	n, err := crt.rd.Read(buf)
+
+	_ = crt.rd.SetReadDeadline(time.Time{})
+	if err == nil {
+		dur := build.Clock.Now().Sub(start)
+		crt.wait -= dur
+		crt.wait += time.Duration(n) * crt.waitPerByte
+		if crt.wait < 0 {
+			crt.wait = 0
+		}
+		if crt.wait > crt.maxWait {
+			crt.wait = crt.maxWait
+		}
+	}
+	return n, err
+}
diff --git a/lib/ipfsbstore/ipfsbstore.go b/lib/ipfsbstore/ipfsbstore.go
new file mode 100644
index 000000000..748afee51
--- /dev/null
+++ b/lib/ipfsbstore/ipfsbstore.go
@@ -0,0 +1,135 @@
+package ipfsbstore
+
+import (
+	"bytes"
+	"context"
+	"io/ioutil"
+
+	"golang.org/x/xerrors"
+
+	"github.com/multiformats/go-multiaddr"
+	"github.com/multiformats/go-multihash"
+
+	blocks "github.com/ipfs/go-block-format"
+	"github.com/ipfs/go-cid"
+	httpapi "github.com/ipfs/go-ipfs-http-client"
+	iface "github.com/ipfs/interface-go-ipfs-core"
+	"github.com/ipfs/interface-go-ipfs-core/options"
+	"github.com/ipfs/interface-go-ipfs-core/path"
+
+	"github.com/filecoin-project/lotus/lib/blockstore"
+)
+
+type IpfsBstore struct {
+	ctx context.Context
+	api iface.CoreAPI
+}
+
+func NewIpfsBstore(ctx context.Context) (*IpfsBstore, error) {
+	localApi, err := httpapi.NewLocalApi()
+	if err != nil {
+		return nil, xerrors.Errorf("getting local ipfs api: %w", err)
+	}
+	api, err := localApi.WithOptions(options.Api.Offline(true))
+	if err != nil {
+		return nil, xerrors.Errorf("setting offline mode: %s", err)
+	}
+
+	return &IpfsBstore{
+		ctx: ctx,
+		api: api,
+	}, nil
+}
+
+func NewRemoteIpfsBstore(ctx context.Context, maddr multiaddr.Multiaddr) (*IpfsBstore, error) {
+	httpApi, err := httpapi.NewApi(maddr)
+	if err != nil {
+		return nil, xerrors.Errorf("setting remote ipfs api: %w", err)
+	}
+	api, err := httpApi.WithOptions(options.Api.Offline(true))
+	if err != nil {
+		return nil, xerrors.Errorf("applying offline mode: %s", err)
+	}
+
+	return &IpfsBstore{
+		ctx: ctx,
+		api: api,
+	}, nil
+}
+
+func (i *IpfsBstore) DeleteBlock(cid cid.Cid) error {
+	return xerrors.Errorf("not supported")
+}
+
+func (i *IpfsBstore) Has(cid cid.Cid) (bool, error) {
+	_, err := i.api.Block().Stat(i.ctx, path.IpldPath(cid))
+	if err != nil {
+		// The underlying client is running in Offline mode.
+		// Stat() will fail with an err if the block isn't in the
+		// blockstore. If that's the case, return false without
+		// an error since that's the original intention of this method.
+		if err.Error() == "blockservice: key not found" {
+			return false, nil
+		}
+		return false, xerrors.Errorf("getting ipfs block: %w", err)
+	}
+
+	return true, nil
+}
+
+func (i *IpfsBstore) Get(cid cid.Cid) (blocks.Block, error) {
+	rd, err := i.api.Block().Get(i.ctx, path.IpldPath(cid))
+	if err != nil {
+		return nil, xerrors.Errorf("getting ipfs block: %w", err)
+	}
+
+	data, err := ioutil.ReadAll(rd)
+	if err != nil {
+		return nil, err
+	}
+
+	return blocks.NewBlockWithCid(data, cid)
+}
+
+func (i *IpfsBstore) GetSize(cid cid.Cid) (int, error) {
+	st, err := i.api.Block().Stat(i.ctx, path.IpldPath(cid))
+	if err != nil {
+		return 0, xerrors.Errorf("getting ipfs block: %w", err)
+	}
+
+	return st.Size(), nil
+}
+
+func (i *IpfsBstore) Put(block blocks.Block) error {
+	mhd, err := multihash.Decode(block.Cid().Hash())
+	if err != nil {
+		return err
+	}
+
+	_, err = i.api.Block().Put(i.ctx, bytes.NewReader(block.RawData()),
+		options.Block.Hash(mhd.Code, mhd.Length),
+		options.Block.Format(cid.CodecToStr[block.Cid().Type()]))
+	return err
+}
+
+func (i *IpfsBstore) PutMany(blocks []blocks.Block) error {
+	// TODO: could be done in parallel
+
+	for _, block := range blocks {
+		if err := i.Put(block); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (i *IpfsBstore) AllKeysChan(ctx context.Context) (<-chan cid.Cid, error) {
+	return nil, xerrors.Errorf("not supported")
+}
+
+func (i *IpfsBstore) HashOnRead(enabled bool) {
+	return // TODO: We could technically support this, but..
+}
+
+var _ blockstore.Blockstore = &IpfsBstore{}
diff --git a/lib/jsonrpc/client.go b/lib/jsonrpc/client.go
deleted file mode 100644
index 45b52c0e0..000000000
--- a/lib/jsonrpc/client.go
+++ /dev/null
@@ -1,392 +0,0 @@
-package jsonrpc
-
-import (
-	"container/list"
-	"context"
-	"encoding/base64"
-	"encoding/json"
-	"fmt"
-	"net/http"
-	"reflect"
-	"sync"
-	"sync/atomic"
-
-	"github.com/gorilla/websocket"
-	logging "github.com/ipfs/go-log"
-	"go.opencensus.io/trace"
-	"go.opencensus.io/trace/propagation"
-	"golang.org/x/xerrors"
-)
-
-var log = logging.Logger("rpc")
-
-var (
-	errorType   = reflect.TypeOf(new(error)).Elem()
-	contextType = reflect.TypeOf(new(context.Context)).Elem()
-)
-
-// ErrClient is an error which occurred on the client side the library
-type ErrClient struct {
-	err error
-}
-
-func (e *ErrClient) Error() string {
-	return fmt.Sprintf("RPC client error: %s", e.err)
-}
-
-// Unwrap unwraps the actual error
-func (e *ErrClient) Unwrap(err error) error {
-	return e.err
-}
-
-type clientResponse struct {
-	Jsonrpc string          `json:"jsonrpc"`
-	Result  json.RawMessage `json:"result"`
-	ID      int64           `json:"id"`
-	Error   *respError      `json:"error,omitempty"`
-}
-
-type makeChanSink func() (context.Context, func([]byte, bool))
-
-type clientRequest struct {
-	req   request
-	ready chan clientResponse
-
-	// retCh provides a context and sink for handling incoming channel messages
-	retCh makeChanSink
-}
-
-// ClientCloser is used to close Client from further use
-type ClientCloser func()
-
-// NewClient creates new jsonrpc 2.0 client
-//
-// handler must be pointer to a struct with function fields
-// Returned value closes the client connection
-// TODO: Example
-func NewClient(addr string, namespace string, handler interface{}, requestHeader http.Header) (ClientCloser, error) {
-	return NewMergeClient(addr, namespace, []interface{}{handler}, requestHeader)
-}
-
-type client struct {
-	namespace string
-
-	requests chan clientRequest
-	exiting  <-chan struct{}
-	idCtr    int64
-}
-
-// NewMergeClient is like NewClient, but allows to specify multiple structs
-// to be filled in the same namespace, using one connection
-func NewMergeClient(addr string, namespace string, outs []interface{}, requestHeader http.Header) (ClientCloser, error) {
-	conn, _, err := websocket.DefaultDialer.Dial(addr, requestHeader)
-	if err != nil {
-		return nil, err
-	}
-
-	c := client{
-		namespace: namespace,
-	}
-
-	stop := make(chan struct{})
-	exiting := make(chan struct{})
-	c.requests = make(chan clientRequest)
-	c.exiting = exiting
-
-	handlers := map[string]rpcHandler{}
-	go (&wsConn{
-		conn:     conn,
-		handler:  handlers,
-		requests: c.requests,
-		stop:     stop,
-		exiting:  exiting,
-	}).handleWsConn(context.TODO())
-
-	for _, handler := range outs {
-		htyp := reflect.TypeOf(handler)
-		if htyp.Kind() != reflect.Ptr {
-			return nil, xerrors.New("expected handler to be a pointer")
-		}
-		typ := htyp.Elem()
-		if typ.Kind() != reflect.Struct {
-			return nil, xerrors.New("handler should be a struct")
-		}
-
-		val := reflect.ValueOf(handler)
-
-		for i := 0; i < typ.NumField(); i++ {
-			fn, err := c.makeRpcFunc(typ.Field(i))
-			if err != nil {
-				return nil, err
-			}
-
-			val.Elem().Field(i).Set(fn)
-		}
-	}
-
-	return func() {
-		close(stop)
-		<-exiting
-	}, nil
-}
-
-func (c *client) makeOutChan(ctx context.Context, ftyp reflect.Type, valOut int) (func() reflect.Value, makeChanSink) {
-	retVal := reflect.Zero(ftyp.Out(valOut))
-
-	chCtor := func() (context.Context, func([]byte, bool)) {
-		// unpack chan type to make sure it's reflect.BothDir
-		ctyp := reflect.ChanOf(reflect.BothDir, ftyp.Out(valOut).Elem())
-		ch := reflect.MakeChan(ctyp, 0) // todo: buffer?
-		chCtx, chCancel := context.WithCancel(ctx)
-		retVal = ch.Convert(ftyp.Out(valOut))
-
-		buf := (&list.List{}).Init()
-		var bufLk sync.Mutex
-
-		return ctx, func(result []byte, ok bool) {
-			if !ok {
-				chCancel()
-				// remote channel closed, close ours too
-				ch.Close()
-				return
-			}
-
-			val := reflect.New(ftyp.Out(valOut).Elem())
-			if err := json.Unmarshal(result, val.Interface()); err != nil {
-				log.Errorf("error unmarshaling chan response: %s", err)
-				return
-			}
-
-			bufLk.Lock()
-			if ctx.Err() != nil {
-				log.Errorf("got rpc message with cancelled context: %s", ctx.Err())
-				bufLk.Unlock()
-				return
-			}
-
-			buf.PushBack(val)
-
-			if buf.Len() > 1 {
-				log.Warnw("rpc output message buffer", "n", buf.Len())
-				bufLk.Unlock()
-				return
-			}
-
-			go func() {
-				for buf.Len() > 0 {
-					front := buf.Front()
-					bufLk.Unlock()
-
-					cases := []reflect.SelectCase{
-						{
-							Dir:  reflect.SelectRecv,
-							Chan: reflect.ValueOf(chCtx.Done()),
-						},
-						{
-							Dir:  reflect.SelectSend,
-							Chan: ch,
-							Send: front.Value.(reflect.Value).Elem(),
-						},
-					}
-
-					chosen, _, _ := reflect.Select(cases)
-					bufLk.Lock()
-
-					switch chosen {
-					case 0:
-						buf.Init()
-					case 1:
-						buf.Remove(front)
-					}
-				}
-
-				bufLk.Unlock()
-			}()
-
-		}
-	}
-
-	return func() reflect.Value { return retVal }, chCtor
-}
-
-func (c *client) sendRequest(ctx context.Context, req request, chCtor makeChanSink) (clientResponse, error) {
-	rchan := make(chan clientResponse, 1)
-	creq := clientRequest{
-		req:   req,
-		ready: rchan,
-
-		retCh: chCtor,
-	}
-	select {
-	case c.requests <- creq:
-	case <-c.exiting:
-		return clientResponse{}, fmt.Errorf("websocket routine exiting")
-	}
-
-	var ctxDone <-chan struct{}
-	var resp clientResponse
-
-	if ctx != nil {
-		ctxDone = ctx.Done()
-	}
-
-	// wait for response, handle context cancellation
-loop:
-	for {
-		select {
-		case resp = <-rchan:
-			break loop
-		case <-ctxDone: // send cancel request
-			ctxDone = nil
-
-			cancelReq := clientRequest{
-				req: request{
-					Jsonrpc: "2.0",
-					Method:  wsCancel,
-					Params:  []param{{v: reflect.ValueOf(*req.ID)}},
-				},
-			}
-			select {
-			case c.requests <- cancelReq:
-			case <-c.exiting:
-				log.Warn("failed to send request cancellation, websocket routing exited")
-			}
-		}
-	}
-
-	return resp, nil
-}
-
-type rpcFunc struct {
-	client *client
-
-	ftyp reflect.Type
-	name string
-
-	nout   int
-	valOut int
-	errOut int
-
-	hasCtx int
-	retCh  bool
-}
-
-func (fn *rpcFunc) processResponse(resp clientResponse, rval reflect.Value) []reflect.Value {
-	out := make([]reflect.Value, fn.nout)
-
-	if fn.valOut != -1 {
-		out[fn.valOut] = rval
-	}
-	if fn.errOut != -1 {
-		out[fn.errOut] = reflect.New(errorType).Elem()
-		if resp.Error != nil {
-			out[fn.errOut].Set(reflect.ValueOf(resp.Error))
-		}
-	}
-
-	return out
-}
-
-func (fn *rpcFunc) processError(err error) []reflect.Value {
-	out := make([]reflect.Value, fn.nout)
-
-	if fn.valOut != -1 {
-		out[fn.valOut] = reflect.New(fn.ftyp.Out(fn.valOut)).Elem()
-	}
-	if fn.errOut != -1 {
-		out[fn.errOut] = reflect.New(errorType).Elem()
-		out[fn.errOut].Set(reflect.ValueOf(&ErrClient{err}))
-	}
-
-	return out
-}
-
-func (fn *rpcFunc) handleRpcCall(args []reflect.Value) (results []reflect.Value) {
-	id := atomic.AddInt64(&fn.client.idCtr, 1)
-	params := make([]param, len(args)-fn.hasCtx)
-	for i, arg := range args[fn.hasCtx:] {
-		params[i] = param{
-			v: arg,
-		}
-	}
-
-	var ctx context.Context
-	var span *trace.Span
-	if fn.hasCtx == 1 {
-		ctx = args[0].Interface().(context.Context)
-		ctx, span = trace.StartSpan(ctx, "api.call")
-		defer span.End()
-	}
-
-	retVal := func() reflect.Value { return reflect.Value{} }
-
-	// if the function returns a channel, we need to provide a sink for the
-	// messages
-	var chCtor makeChanSink
-	if fn.retCh {
-		retVal, chCtor = fn.client.makeOutChan(ctx, fn.ftyp, fn.valOut)
-	}
-
-	req := request{
-		Jsonrpc: "2.0",
-		ID:      &id,
-		Method:  fn.client.namespace + "." + fn.name,
-		Params:  params,
-	}
-
-	if span != nil {
-		span.AddAttributes(trace.StringAttribute("method", req.Method))
-
-		eSC := base64.StdEncoding.EncodeToString(
-			propagation.Binary(span.SpanContext()))
-		req.Meta = map[string]string{
-			"SpanContext": eSC,
-		}
-	}
-
-	resp, err := fn.client.sendRequest(ctx, req, chCtor)
-	if err != nil {
-		return fn.processError(fmt.Errorf("sendRequest failed: %w", err))
-	}
-
-	if resp.ID != *req.ID {
-		return fn.processError(xerrors.New("request and response id didn't match"))
-	}
-
-	if fn.valOut != -1 && !fn.retCh {
-		val := reflect.New(fn.ftyp.Out(fn.valOut))
-
-		if resp.Result != nil {
-			log.Debugw("rpc result", "type", fn.ftyp.Out(fn.valOut))
-			if err := json.Unmarshal(resp.Result, val.Interface()); err != nil {
-				log.Warnw("unmarshaling failed", "message", string(resp.Result))
-				return fn.processError(xerrors.Errorf("unmarshaling result: %w", err))
-			}
-		}
-
-		retVal = func() reflect.Value { return val.Elem() }
-	}
-
-	return fn.processResponse(resp, retVal())
-}
-
-func (c *client) makeRpcFunc(f reflect.StructField) (reflect.Value, error) {
-	ftyp := f.Type
-	if ftyp.Kind() != reflect.Func {
-		return reflect.Value{}, xerrors.New("handler field not a func")
-	}
-
-	fun := &rpcFunc{
-		client: c,
-		ftyp:   ftyp,
-		name:   f.Name,
-	}
-	fun.valOut, fun.errOut, fun.nout = processFuncOut(ftyp)
-
-	if ftyp.NumIn() > 0 && ftyp.In(0) == contextType {
-		fun.hasCtx = 1
-	}
-	fun.retCh = fun.valOut != -1 && ftyp.Out(fun.valOut).Kind() == reflect.Chan
-
-	return reflect.MakeFunc(ftyp, fun.handleRpcCall), nil
-}
diff --git a/lib/jsonrpc/handler.go b/lib/jsonrpc/handler.go
deleted file mode 100644
index e771b172e..000000000
--- a/lib/jsonrpc/handler.go
+++ /dev/null
@@ -1,240 +0,0 @@
-package jsonrpc
-
-import (
-	"bytes"
-	"context"
-	"encoding/base64"
-	"encoding/json"
-	"fmt"
-	"io"
-	"reflect"
-
-	"go.opencensus.io/trace"
-	"go.opencensus.io/trace/propagation"
-	"golang.org/x/xerrors"
-)
-
-type rpcHandler struct {
-	paramReceivers []reflect.Type
-	nParams        int
-
-	receiver    reflect.Value
-	handlerFunc reflect.Value
-
-	hasCtx int
-
-	errOut int
-	valOut int
-}
-
-type handlers map[string]rpcHandler
-
-// Request / response
-
-type request struct {
-	Jsonrpc string            `json:"jsonrpc"`
-	ID      *int64            `json:"id,omitempty"`
-	Method  string            `json:"method"`
-	Params  []param           `json:"params"`
-	Meta    map[string]string `json:"meta,omitempty"`
-}
-
-type respError struct {
-	Code    int    `json:"code"`
-	Message string `json:"message"`
-}
-
-func (e *respError) Error() string {
-	if e.Code >= -32768 && e.Code <= -32000 {
-		return fmt.Sprintf("RPC error (%d): %s", e.Code, e.Message)
-	}
-	return e.Message
-}
-
-type response struct {
-	Jsonrpc string      `json:"jsonrpc"`
-	Result  interface{} `json:"result,omitempty"`
-	ID      int64       `json:"id"`
-	Error   *respError  `json:"error,omitempty"`
-}
-
-// Register
-
-func (h handlers) register(namespace string, r interface{}) {
-	val := reflect.ValueOf(r)
-	//TODO: expect ptr
-
-	for i := 0; i < val.NumMethod(); i++ {
-		method := val.Type().Method(i)
-
-		funcType := method.Func.Type()
-		hasCtx := 0
-		if funcType.NumIn() >= 2 && funcType.In(1) == contextType {
-			hasCtx = 1
-		}
-
-		ins := funcType.NumIn() - 1 - hasCtx
-		recvs := make([]reflect.Type, ins)
-		for i := 0; i < ins; i++ {
-			recvs[i] = method.Type.In(i + 1 + hasCtx)
-		}
-
-		valOut, errOut, _ := processFuncOut(funcType)
-
-		h[namespace+"."+method.Name] = rpcHandler{
-			paramReceivers: recvs,
-			nParams:        ins,
-
-			handlerFunc: method.Func,
-			receiver:    val,
-
-			hasCtx: hasCtx,
-
-			errOut: errOut,
-			valOut: valOut,
-		}
-	}
-}
-
-// Handle
-
-type rpcErrFunc func(w func(func(io.Writer)), req *request, code int, err error)
-type chanOut func(reflect.Value) interface{}
-
-func (h handlers) handleReader(ctx context.Context, r io.Reader, w io.Writer, rpcError rpcErrFunc) {
-	wf := func(cb func(io.Writer)) {
-		cb(w)
-	}
-
-	var req request
-	if err := json.NewDecoder(r).Decode(&req); err != nil {
-		rpcError(wf, &req, rpcParseError, xerrors.Errorf("unmarshaling request: %w", err))
-		return
-	}
-
-	h.handle(ctx, req, wf, rpcError, func(bool) {}, nil)
-}
-
-func doCall(methodName string, f reflect.Value, params []reflect.Value) (out []reflect.Value, err error) {
-	defer func() {
-		if i := recover(); i != nil {
-			err = xerrors.Errorf("panic in rpc method '%s': %s", methodName, i)
-			log.Error(err)
-		}
-	}()
-
-	out = f.Call(params)
-	return out, nil
-}
-
-func (handlers) getSpan(ctx context.Context, req request) (context.Context, *trace.Span) {
-	if req.Meta == nil {
-		return ctx, nil
-	}
-	if eSC, ok := req.Meta["SpanContext"]; ok {
-		bSC := make([]byte, base64.StdEncoding.DecodedLen(len(eSC)))
-		_, err := base64.StdEncoding.Decode(bSC, []byte(eSC))
-		if err != nil {
-			log.Errorf("SpanContext: decode", "error", err)
-			return ctx, nil
-		}
-		sc, ok := propagation.FromBinary(bSC)
-		if !ok {
-			log.Errorf("SpanContext: could not create span", "data", bSC)
-			return ctx, nil
-		}
-		ctx, span := trace.StartSpanWithRemoteParent(ctx, "api.handle", sc)
-		span.AddAttributes(trace.StringAttribute("method", req.Method))
-		return ctx, span
-	}
-	return ctx, nil
-}
-
-func (h handlers) handle(ctx context.Context, req request, w func(func(io.Writer)), rpcError rpcErrFunc, done func(keepCtx bool), chOut chanOut) {
-	ctx, span := h.getSpan(ctx, req)
-	defer span.End()
-
-	handler, ok := h[req.Method]
-	if !ok {
-		rpcError(w, &req, rpcMethodNotFound, fmt.Errorf("method '%s' not found", req.Method))
-		done(false)
-		return
-	}
-
-	if len(req.Params) != handler.nParams {
-		rpcError(w, &req, rpcInvalidParams, fmt.Errorf("wrong param count"))
-		done(false)
-		return
-	}
-
-	outCh := handler.valOut != -1 && handler.handlerFunc.Type().Out(handler.valOut).Kind() == reflect.Chan
-	defer done(outCh)
-
-	if chOut == nil && outCh {
-		rpcError(w, &req, rpcMethodNotFound, fmt.Errorf("method '%s' not supported in this mode (no out channel support)", req.Method))
-		return
-	}
-
-	callParams := make([]reflect.Value, 1+handler.hasCtx+handler.nParams)
-	callParams[0] = handler.receiver
-	if handler.hasCtx == 1 {
-		callParams[1] = reflect.ValueOf(ctx)
-	}
-
-	for i := 0; i < handler.nParams; i++ {
-		rp := reflect.New(handler.paramReceivers[i])
-		if err := json.NewDecoder(bytes.NewReader(req.Params[i].data)).Decode(rp.Interface()); err != nil {
-			rpcError(w, &req, rpcParseError, xerrors.Errorf("unmarshaling params for '%s': %w", handler.handlerFunc, err))
-			return
-		}
-
-		callParams[i+1+handler.hasCtx] = reflect.ValueOf(rp.Elem().Interface())
-	}
-
-	///////////////////
-
-	callResult, err := doCall(req.Method, handler.handlerFunc, callParams)
-	if err != nil {
-		rpcError(w, &req, 0, xerrors.Errorf("fatal error calling '%s': %w", req.Method, err))
-		return
-	}
-	if req.ID == nil {
-		return // notification
-	}
-
-	///////////////////
-
-	resp := response{
-		Jsonrpc: "2.0",
-		ID:      *req.ID,
-	}
-
-	if handler.errOut != -1 {
-		err := callResult[handler.errOut].Interface()
-		if err != nil {
-			log.Warnf("error in RPC call to '%s': %+v", req.Method, err)
-			resp.Error = &respError{
-				Code:    1,
-				Message: err.(error).Error(),
-			}
-		}
-	}
-	if handler.valOut != -1 {
-		resp.Result = callResult[handler.valOut].Interface()
-	}
-
-	w(func(w io.Writer) {
-		if resp.Result != nil && reflect.TypeOf(resp.Result).Kind() == reflect.Chan {
-			// this must happen in the writer callback, otherwise we may start sending
-			// channel messages before we send this response
-
-			//noinspection GoNilness // already checked above
-			resp.Result = chOut(callResult[handler.valOut])
-		}
-
-		if err := json.NewEncoder(w).Encode(resp); err != nil {
-			log.Error(err)
-			return
-		}
-	})
-}
diff --git a/lib/jsonrpc/rpc_test.go b/lib/jsonrpc/rpc_test.go
deleted file mode 100644
index 3073816a6..000000000
--- a/lib/jsonrpc/rpc_test.go
+++ /dev/null
@@ -1,379 +0,0 @@
-package jsonrpc
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"net/http/httptest"
-	"strconv"
-	"strings"
-	"sync"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/require"
-)
-
-type SimpleServerHandler struct {
-	n int
-}
-
-type TestType struct {
-	S string
-	I int
-}
-
-type TestOut struct {
-	TestType
-	Ok bool
-}
-
-func (h *SimpleServerHandler) Add(in int) error {
-	if in == -3546 {
-		return errors.New("test")
-	}
-
-	h.n += in
-
-	return nil
-}
-
-func (h *SimpleServerHandler) AddGet(in int) int {
-	h.n += in
-	return h.n
-}
-
-func (h *SimpleServerHandler) StringMatch(t TestType, i2 int64) (out TestOut, err error) {
-	if strconv.FormatInt(i2, 10) == t.S {
-		out.Ok = true
-	}
-	if i2 != int64(t.I) {
-		return TestOut{}, errors.New(":(")
-	}
-	out.I = t.I
-	out.S = t.S
-	return
-}
-
-func TestRPC(t *testing.T) {
-	// setup server
-
-	serverHandler := &SimpleServerHandler{}
-
-	rpcServer := NewServer()
-	rpcServer.Register("SimpleServerHandler", serverHandler)
-
-	// httptest stuff
-	testServ := httptest.NewServer(rpcServer)
-	defer testServ.Close()
-	// setup client
-
-	var client struct {
-		Add         func(int) error
-		AddGet      func(int) int
-		StringMatch func(t TestType, i2 int64) (out TestOut, err error)
-	}
-	closer, err := NewClient("ws://"+testServ.Listener.Addr().String(), "SimpleServerHandler", &client, nil)
-	require.NoError(t, err)
-	defer closer()
-
-	// Add(int) error
-
-	require.NoError(t, client.Add(2))
-	require.Equal(t, 2, serverHandler.n)
-
-	err = client.Add(-3546)
-	require.EqualError(t, err, "test")
-
-	// AddGet(int) int
-
-	n := client.AddGet(3)
-	require.Equal(t, 5, n)
-	require.Equal(t, 5, serverHandler.n)
-
-	// StringMatch
-
-	o, err := client.StringMatch(TestType{S: "0"}, 0)
-	require.NoError(t, err)
-	require.Equal(t, "0", o.S)
-	require.Equal(t, 0, o.I)
-
-	_, err = client.StringMatch(TestType{S: "5"}, 5)
-	require.EqualError(t, err, ":(")
-
-	o, err = client.StringMatch(TestType{S: "8", I: 8}, 8)
-	require.NoError(t, err)
-	require.Equal(t, "8", o.S)
-	require.Equal(t, 8, o.I)
-
-	// Invalid client handlers
-
-	var noret struct {
-		Add func(int)
-	}
-	closer, err = NewClient("ws://"+testServ.Listener.Addr().String(), "SimpleServerHandler", &noret, nil)
-	require.NoError(t, err)
-
-	// this one should actually work
-	noret.Add(4)
-	require.Equal(t, 9, serverHandler.n)
-	closer()
-
-	var noparam struct {
-		Add func()
-	}
-	closer, err = NewClient("ws://"+testServ.Listener.Addr().String(), "SimpleServerHandler", &noparam, nil)
-	require.NoError(t, err)
-
-	// shouldn't panic
-	noparam.Add()
-	closer()
-
-	var erronly struct {
-		AddGet func() (int, error)
-	}
-	closer, err = NewClient("ws://"+testServ.Listener.Addr().String(), "SimpleServerHandler", &erronly, nil)
-	require.NoError(t, err)
-
-	_, err = erronly.AddGet()
-	if err == nil || err.Error() != "RPC error (-32602): wrong param count" {
-		t.Error("wrong error:", err)
-	}
-	closer()
-
-	var wrongtype struct {
-		Add func(string) error
-	}
-	closer, err = NewClient("ws://"+testServ.Listener.Addr().String(), "SimpleServerHandler", &wrongtype, nil)
-	require.NoError(t, err)
-
-	err = wrongtype.Add("not an int")
-	if err == nil || !strings.Contains(err.Error(), "RPC error (-32700):") || !strings.Contains(err.Error(), "json: cannot unmarshal string into Go value of type int") {
-		t.Error("wrong error:", err)
-	}
-	closer()
-
-	var notfound struct {
-		NotThere func(string) error
-	}
-	closer, err = NewClient("ws://"+testServ.Listener.Addr().String(), "SimpleServerHandler", &notfound, nil)
-	require.NoError(t, err)
-
-	err = notfound.NotThere("hello?")
-	if err == nil || err.Error() != "RPC error (-32601): method 'SimpleServerHandler.NotThere' not found" {
-		t.Error("wrong error:", err)
-	}
-	closer()
-}
-
-type CtxHandler struct {
-	lk sync.Mutex
-
-	cancelled bool
-	i         int
-}
-
-func (h *CtxHandler) Test(ctx context.Context) {
-	h.lk.Lock()
-	defer h.lk.Unlock()
-	timeout := time.After(300 * time.Millisecond)
-	h.i++
-
-	select {
-	case <-timeout:
-	case <-ctx.Done():
-		h.cancelled = true
-	}
-}
-
-func TestCtx(t *testing.T) {
-	// setup server
-
-	serverHandler := &CtxHandler{}
-
-	rpcServer := NewServer()
-	rpcServer.Register("CtxHandler", serverHandler)
-
-	// httptest stuff
-	testServ := httptest.NewServer(rpcServer)
-	defer testServ.Close()
-
-	// setup client
-
-	var client struct {
-		Test func(ctx context.Context)
-	}
-	closer, err := NewClient("ws://"+testServ.Listener.Addr().String(), "CtxHandler", &client, nil)
-	require.NoError(t, err)
-
-	ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
-	defer cancel()
-
-	client.Test(ctx)
-	serverHandler.lk.Lock()
-
-	if !serverHandler.cancelled {
-		t.Error("expected cancellation on the server side")
-	}
-
-	serverHandler.cancelled = false
-
-	serverHandler.lk.Unlock()
-	closer()
-
-	var noCtxClient struct {
-		Test func()
-	}
-	closer, err = NewClient("ws://"+testServ.Listener.Addr().String(), "CtxHandler", &noCtxClient, nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	noCtxClient.Test()
-
-	serverHandler.lk.Lock()
-
-	if serverHandler.cancelled || serverHandler.i != 2 {
-		t.Error("wrong serverHandler state")
-	}
-
-	serverHandler.lk.Unlock()
-	closer()
-}
-
-type UnUnmarshalable int
-
-func (*UnUnmarshalable) UnmarshalJSON([]byte) error {
-	return errors.New("nope")
-}
-
-type UnUnmarshalableHandler struct{}
-
-func (*UnUnmarshalableHandler) GetUnUnmarshalableStuff() (UnUnmarshalable, error) {
-	return UnUnmarshalable(5), nil
-}
-
-func TestUnmarshalableResult(t *testing.T) {
-	var client struct {
-		GetUnUnmarshalableStuff func() (UnUnmarshalable, error)
-	}
-
-	rpcServer := NewServer()
-	rpcServer.Register("Handler", &UnUnmarshalableHandler{})
-
-	testServ := httptest.NewServer(rpcServer)
-	defer testServ.Close()
-
-	closer, err := NewClient("ws://"+testServ.Listener.Addr().String(), "Handler", &client, nil)
-	require.NoError(t, err)
-	defer closer()
-
-	_, err = client.GetUnUnmarshalableStuff()
-	require.EqualError(t, err, "RPC client error: unmarshaling result: nope")
-}
-
-type ChanHandler struct {
-	wait chan struct{}
-}
-
-func (h *ChanHandler) Sub(ctx context.Context, i int, eq int) (<-chan int, error) {
-	out := make(chan int)
-
-	go func() {
-		defer close(out)
-		var n int
-
-		for {
-			select {
-			case <-ctx.Done():
-				fmt.Println("ctxdone1")
-				return
-			case <-h.wait:
-			}
-
-			n += i
-
-			if n == eq {
-				fmt.Println("eq")
-				return
-			}
-
-			select {
-			case <-ctx.Done():
-				fmt.Println("ctxdone2")
-				return
-			case out <- n:
-			}
-		}
-	}()
-
-	return out, nil
-}
-
-func TestChan(t *testing.T) {
-	var client struct {
-		Sub func(context.Context, int, int) (<-chan int, error)
-	}
-
-	serverHandler := &ChanHandler{
-		wait: make(chan struct{}, 5),
-	}
-
-	rpcServer := NewServer()
-	rpcServer.Register("ChanHandler", serverHandler)
-
-	testServ := httptest.NewServer(rpcServer)
-	defer testServ.Close()
-
-	closer, err := NewClient("ws://"+testServ.Listener.Addr().String(), "ChanHandler", &client, nil)
-	require.NoError(t, err)
-
-	defer closer()
-
-	serverHandler.wait <- struct{}{}
-
-	ctx, cancel := context.WithCancel(context.Background())
-
-	// sub
-
-	sub, err := client.Sub(ctx, 2, -1)
-	require.NoError(t, err)
-
-	// recv one
-
-	require.Equal(t, 2, <-sub)
-
-	// recv many (order)
-
-	serverHandler.wait <- struct{}{}
-	serverHandler.wait <- struct{}{}
-	serverHandler.wait <- struct{}{}
-
-	require.Equal(t, 4, <-sub)
-	require.Equal(t, 6, <-sub)
-	require.Equal(t, 8, <-sub)
-
-	// close (through ctx)
-	cancel()
-
-	_, ok := <-sub
-	require.Equal(t, false, ok)
-
-	// sub (again)
-
-	serverHandler.wait <- struct{}{}
-
-	ctx, cancel = context.WithCancel(context.Background())
-	defer cancel()
-
-	sub, err = client.Sub(ctx, 3, 6)
-	require.NoError(t, err)
-
-	require.Equal(t, 3, <-sub)
-
-	// close (remote)
-	serverHandler.wait <- struct{}{}
-	_, ok = <-sub
-	require.Equal(t, false, ok)
-
-}
diff --git a/lib/jsonrpc/server.go b/lib/jsonrpc/server.go
deleted file mode 100644
index bb9fa4594..000000000
--- a/lib/jsonrpc/server.go
+++ /dev/null
@@ -1,113 +0,0 @@
-package jsonrpc
-
-import (
-	"context"
-	"encoding/json"
-	"io"
-	"net/http"
-	"strings"
-
-	"github.com/gorilla/websocket"
-)
-
-const (
-	rpcParseError     = -32700
-	rpcMethodNotFound = -32601
-	rpcInvalidParams  = -32602
-)
-
-// RPCServer provides a jsonrpc 2.0 http server handler
-type RPCServer struct {
-	methods handlers
-}
-
-// NewServer creates new RPCServer instance
-func NewServer() *RPCServer {
-	return &RPCServer{
-		methods: map[string]rpcHandler{},
-	}
-}
-
-var upgrader = websocket.Upgrader{
-	CheckOrigin: func(r *http.Request) bool {
-		return true
-	},
-}
-
-func (s *RPCServer) handleWS(ctx context.Context, w http.ResponseWriter, r *http.Request) {
-	// TODO: allow setting
-	// (note that we still are mostly covered by jwt tokens)
-	w.Header().Set("Access-Control-Allow-Origin", "*")
-	if r.Header.Get("Sec-WebSocket-Protocol") != "" {
-		w.Header().Set("Sec-WebSocket-Protocol", r.Header.Get("Sec-WebSocket-Protocol"))
-	}
-
-	c, err := upgrader.Upgrade(w, r, nil)
-	if err != nil {
-		log.Error(err)
-		w.WriteHeader(500)
-		return
-	}
-
-	(&wsConn{
-		conn:    c,
-		handler: s.methods,
-		exiting: make(chan struct{}),
-	}).handleWsConn(ctx)
-
-	if err := c.Close(); err != nil {
-		log.Error(err)
-		return
-	}
-}
-
-// TODO: return errors to clients per spec
-func (s *RPCServer) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-	ctx := r.Context()
-
-	if strings.Contains(r.Header.Get("Connection"), "Upgrade") {
-		s.handleWS(ctx, w, r)
-		return
-	}
-
-	s.methods.handleReader(ctx, r.Body, w, rpcError)
-}
-
-func rpcError(wf func(func(io.Writer)), req *request, code int, err error) {
-	log.Errorf("RPC Error: %s", err)
-	wf(func(w io.Writer) {
-		if hw, ok := w.(http.ResponseWriter); ok {
-			hw.WriteHeader(500)
-		}
-
-		log.Warnf("rpc error: %s", err)
-
-		if req.ID == nil { // notification
-			return
-		}
-
-		resp := response{
-			Jsonrpc: "2.0",
-			ID:      *req.ID,
-			Error: &respError{
-				Code:    code,
-				Message: err.Error(),
-			},
-		}
-
-		err = json.NewEncoder(w).Encode(resp)
-		if err != nil {
-			log.Warnf("failed to write rpc error: %s", err)
-			return
-		}
-	})
-}
-
-// Register registers new RPC handler
-//
-// Handler is any value with methods defined
-func (s *RPCServer) Register(namespace string, handler interface{}) {
-	s.methods.register(namespace, handler)
-}
-
-var _ error = &respError{}
diff --git a/lib/jsonrpc/util.go b/lib/jsonrpc/util.go
deleted file mode 100644
index 03b0bf7bd..000000000
--- a/lib/jsonrpc/util.go
+++ /dev/null
@@ -1,51 +0,0 @@
-package jsonrpc
-
-import (
-	"encoding/json"
-	"fmt"
-	"reflect"
-)
-
-type param struct {
-	data []byte // from unmarshal
-
-	v reflect.Value // to marshal
-}
-
-func (p *param) UnmarshalJSON(raw []byte) error {
-	p.data = make([]byte, len(raw))
-	copy(p.data, raw)
-	return nil
-}
-
-func (p *param) MarshalJSON() ([]byte, error) {
-	return json.Marshal(p.v.Interface())
-}
-
-// processFuncOut finds value and error Outs in function
-func processFuncOut(funcType reflect.Type) (valOut int, errOut int, n int) {
-	errOut = -1 // -1 if not found
-	valOut = -1
-	n = funcType.NumOut()
-
-	switch n {
-	case 0:
-	case 1:
-		if funcType.Out(0) == errorType {
-			errOut = 0
-		} else {
-			valOut = 0
-		}
-	case 2:
-		valOut = 0
-		errOut = 1
-		if funcType.Out(1) != errorType {
-			panic("expected error as second return value")
-		}
-	default:
-		errstr := fmt.Sprintf("too many return values: %s", funcType)
-		panic(errstr)
-	}
-
-	return
-}
diff --git a/lib/jsonrpc/websocket.go b/lib/jsonrpc/websocket.go
deleted file mode 100644
index 23da51598..000000000
--- a/lib/jsonrpc/websocket.go
+++ /dev/null
@@ -1,461 +0,0 @@
-package jsonrpc
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-	"io"
-	"io/ioutil"
-	"reflect"
-	"sync"
-	"sync/atomic"
-
-	"github.com/gorilla/websocket"
-)
-
-const wsCancel = "xrpc.cancel"
-const chValue = "xrpc.ch.val"
-const chClose = "xrpc.ch.close"
-
-type frame struct {
-	// common
-	Jsonrpc string            `json:"jsonrpc"`
-	ID      *int64            `json:"id,omitempty"`
-	Meta    map[string]string `json:"meta,omitempty"`
-
-	// request
-	Method string  `json:"method,omitempty"`
-	Params []param `json:"params,omitempty"`
-
-	// response
-	Result json.RawMessage `json:"result,omitempty"`
-	Error  *respError      `json:"error,omitempty"`
-}
-
-type outChanReg struct {
-	id uint64
-	ch reflect.Value
-}
-
-type wsConn struct {
-	// outside params
-	conn     *websocket.Conn
-	handler  handlers
-	requests <-chan clientRequest
-	stop     <-chan struct{}
-	exiting  chan struct{}
-
-	// incoming messages
-	incoming    chan io.Reader
-	incomingErr error
-
-	// outgoing messages
-	writeLk sync.Mutex
-
-	// ////
-	// Client related
-
-	// inflight are requests we've sent to the remote
-	inflight map[int64]clientRequest
-
-	// chanHandlers is a map of client-side channel handlers
-	chanHandlers map[uint64]func(m []byte, ok bool)
-
-	// ////
-	// Server related
-
-	// handling are the calls we handle
-	handling   map[int64]context.CancelFunc
-	handlingLk sync.Mutex
-
-	spawnOutChanHandlerOnce sync.Once
-
-	// chanCtr is a counter used for identifying output channels on the server side
-	chanCtr uint64
-
-	registerCh chan outChanReg
-}
-
-//                         //
-// WebSocket Message utils //
-//                         //
-
-// nextMessage wait for one message and puts it to the incoming channel
-func (c *wsConn) nextMessage() {
-	msgType, r, err := c.conn.NextReader()
-	if err != nil {
-		c.incomingErr = err
-		close(c.incoming)
-		return
-	}
-	if msgType != websocket.BinaryMessage && msgType != websocket.TextMessage {
-		c.incomingErr = errors.New("unsupported message type")
-		close(c.incoming)
-		return
-	}
-	c.incoming <- r
-}
-
-// nextWriter waits for writeLk and invokes the cb callback with WS message
-// writer when the lock is acquired
-func (c *wsConn) nextWriter(cb func(io.Writer)) {
-	c.writeLk.Lock()
-	defer c.writeLk.Unlock()
-
-	wcl, err := c.conn.NextWriter(websocket.TextMessage)
-	if err != nil {
-		log.Error("handle me:", err)
-		return
-	}
-
-	cb(wcl)
-
-	if err := wcl.Close(); err != nil {
-		log.Error("handle me:", err)
-		return
-	}
-}
-
-func (c *wsConn) sendRequest(req request) {
-	c.writeLk.Lock()
-	if err := c.conn.WriteJSON(req); err != nil {
-		log.Error("handle me:", err)
-		c.writeLk.Unlock()
-		return
-	}
-	c.writeLk.Unlock()
-}
-
-//                 //
-// Output channels //
-//                 //
-
-// handleOutChans handles channel communication on the server side
-// (forwards channel messages to client)
-func (c *wsConn) handleOutChans() {
-	regV := reflect.ValueOf(c.registerCh)
-
-	cases := []reflect.SelectCase{
-		{ // registration chan always 0
-			Dir:  reflect.SelectRecv,
-			Chan: regV,
-		},
-	}
-	var caseToID []uint64
-
-	for {
-		chosen, val, ok := reflect.Select(cases)
-
-		if chosen == 0 { // control channel
-			if !ok {
-				// control channel closed - signals closed connection
-				//
-				// We're not closing any channels as we're on receiving end.
-				// Also, context cancellation below should take care of any running
-				// requests
-				return
-			}
-
-			registration := val.Interface().(outChanReg)
-
-			caseToID = append(caseToID, registration.id)
-			cases = append(cases, reflect.SelectCase{
-				Dir:  reflect.SelectRecv,
-				Chan: registration.ch,
-			})
-
-			continue
-		}
-
-		if !ok {
-			// Output channel closed, cleanup, and tell remote that this happened
-
-			n := len(caseToID)
-			if n > 0 {
-				cases[chosen] = cases[n]
-				caseToID[chosen-1] = caseToID[n-1]
-			}
-
-			id := caseToID[chosen-1]
-			cases = cases[:n]
-			caseToID = caseToID[:n-1]
-
-			c.sendRequest(request{
-				Jsonrpc: "2.0",
-				ID:      nil, // notification
-				Method:  chClose,
-				Params:  []param{{v: reflect.ValueOf(id)}},
-			})
-			continue
-		}
-
-		// forward message
-		c.sendRequest(request{
-			Jsonrpc: "2.0",
-			ID:      nil, // notification
-			Method:  chValue,
-			Params:  []param{{v: reflect.ValueOf(caseToID[chosen-1])}, {v: val}},
-		})
-	}
-}
-
-// handleChanOut registers output channel for forwarding to client
-func (c *wsConn) handleChanOut(ch reflect.Value) interface{} {
-	c.spawnOutChanHandlerOnce.Do(func() {
-		go c.handleOutChans()
-	})
-	id := atomic.AddUint64(&c.chanCtr, 1)
-
-	c.registerCh <- outChanReg{
-		id: id,
-		ch: ch,
-	}
-
-	return id
-}
-
-//                          //
-// Context.Done propagation //
-//                          //
-
-// handleCtxAsync handles context lifetimes for client
-// TODO: this should be aware of events going through chanHandlers, and quit
-//  when the related channel is closed.
-//  This should also probably be a single goroutine,
-//  Note that not doing this should be fine for now as long as we are using
-//  contexts correctly (cancelling when async functions are no longer is use)
-func (c *wsConn) handleCtxAsync(actx context.Context, id int64) {
-	<-actx.Done()
-
-	c.sendRequest(request{
-		Jsonrpc: "2.0",
-		Method:  wsCancel,
-		Params:  []param{{v: reflect.ValueOf(id)}},
-	})
-}
-
-// cancelCtx is a built-in rpc which handles context cancellation over rpc
-func (c *wsConn) cancelCtx(req frame) {
-	if req.ID != nil {
-		log.Warnf("%s call with ID set, won't respond", wsCancel)
-	}
-
-	var id int64
-	if err := json.Unmarshal(req.Params[0].data, &id); err != nil {
-		log.Error("handle me:", err)
-		return
-	}
-
-	c.handlingLk.Lock()
-	defer c.handlingLk.Unlock()
-
-	cf, ok := c.handling[id]
-	if ok {
-		cf()
-	}
-}
-
-//                     //
-// Main Handling logic //
-//                     //
-
-func (c *wsConn) handleChanMessage(frame frame) {
-	var chid uint64
-	if err := json.Unmarshal(frame.Params[0].data, &chid); err != nil {
-		log.Error("failed to unmarshal channel id in xrpc.ch.val: %s", err)
-		return
-	}
-
-	hnd, ok := c.chanHandlers[chid]
-	if !ok {
-		log.Errorf("xrpc.ch.val: handler %d not found", chid)
-		return
-	}
-
-	hnd(frame.Params[1].data, true)
-}
-
-func (c *wsConn) handleChanClose(frame frame) {
-	var chid uint64
-	if err := json.Unmarshal(frame.Params[0].data, &chid); err != nil {
-		log.Error("failed to unmarshal channel id in xrpc.ch.val: %s", err)
-		return
-	}
-
-	hnd, ok := c.chanHandlers[chid]
-	if !ok {
-		log.Errorf("xrpc.ch.val: handler %d not found", chid)
-		return
-	}
-
-	delete(c.chanHandlers, chid)
-
-	hnd(nil, false)
-}
-
-func (c *wsConn) handleResponse(frame frame) {
-	req, ok := c.inflight[*frame.ID]
-	if !ok {
-		log.Error("client got unknown ID in response")
-		return
-	}
-
-	if req.retCh != nil && frame.Result != nil {
-		// output is channel
-		var chid uint64
-		if err := json.Unmarshal(frame.Result, &chid); err != nil {
-			log.Errorf("failed to unmarshal channel id response: %s, data '%s'", err, string(frame.Result))
-			return
-		}
-
-		var chanCtx context.Context
-		chanCtx, c.chanHandlers[chid] = req.retCh()
-		go c.handleCtxAsync(chanCtx, *frame.ID)
-	}
-
-	req.ready <- clientResponse{
-		Jsonrpc: frame.Jsonrpc,
-		Result:  frame.Result,
-		ID:      *frame.ID,
-		Error:   frame.Error,
-	}
-	delete(c.inflight, *frame.ID)
-}
-
-func (c *wsConn) handleCall(ctx context.Context, frame frame) {
-	req := request{
-		Jsonrpc: frame.Jsonrpc,
-		ID:      frame.ID,
-		Meta:    frame.Meta,
-		Method:  frame.Method,
-		Params:  frame.Params,
-	}
-
-	ctx, cancel := context.WithCancel(ctx)
-
-	nextWriter := func(cb func(io.Writer)) {
-		cb(ioutil.Discard)
-	}
-	done := func(keepCtx bool) {
-		if !keepCtx {
-			cancel()
-		}
-	}
-	if frame.ID != nil {
-		nextWriter = c.nextWriter
-
-		c.handlingLk.Lock()
-		c.handling[*frame.ID] = cancel
-		c.handlingLk.Unlock()
-
-		done = func(keepctx bool) {
-			c.handlingLk.Lock()
-			defer c.handlingLk.Unlock()
-
-			if !keepctx {
-				cancel()
-				delete(c.handling, *frame.ID)
-			}
-		}
-	}
-
-	go c.handler.handle(ctx, req, nextWriter, rpcError, done, c.handleChanOut)
-}
-
-// handleFrame handles all incoming messages (calls and responses)
-func (c *wsConn) handleFrame(ctx context.Context, frame frame) {
-	// Get message type by method name:
-	// "" - response
-	// "xrpc.*" - builtin
-	// anything else - incoming remote call
-	switch frame.Method {
-	case "": // Response to our call
-		c.handleResponse(frame)
-	case wsCancel:
-		c.cancelCtx(frame)
-	case chValue:
-		c.handleChanMessage(frame)
-	case chClose:
-		c.handleChanClose(frame)
-	default: // Remote call
-		c.handleCall(ctx, frame)
-	}
-}
-
-func (c *wsConn) handleWsConn(ctx context.Context) {
-	c.incoming = make(chan io.Reader)
-	c.inflight = map[int64]clientRequest{}
-	c.handling = map[int64]context.CancelFunc{}
-	c.chanHandlers = map[uint64]func(m []byte, ok bool){}
-
-	c.registerCh = make(chan outChanReg)
-	defer close(c.registerCh)
-	defer close(c.exiting)
-
-	// ////
-
-	// on close, make sure to return from all pending calls, and cancel context
-	//  on all calls we handle
-	defer func() {
-		for id, req := range c.inflight {
-			req.ready <- clientResponse{
-				Jsonrpc: "2.0",
-				ID:      id,
-				Error: &respError{
-					Message: "handler: websocket connection closed",
-				},
-			}
-
-			c.handlingLk.Lock()
-			for _, cancel := range c.handling {
-				cancel()
-			}
-			c.handlingLk.Unlock()
-		}
-	}()
-
-	// wait for the first message
-	go c.nextMessage()
-
-	for {
-		select {
-		case r, ok := <-c.incoming:
-			if !ok {
-				if c.incomingErr != nil {
-					if !websocket.IsCloseError(c.incomingErr, websocket.CloseNormalClosure) {
-						log.Debugw("websocket error", "error", c.incomingErr)
-					}
-				}
-				return // remote closed
-			}
-
-			// debug util - dump all messages to stderr
-			// r = io.TeeReader(r, os.Stderr)
-
-			var frame frame
-			if err := json.NewDecoder(r).Decode(&frame); err != nil {
-				log.Error("handle me:", err)
-				return
-			}
-
-			c.handleFrame(ctx, frame)
-			go c.nextMessage()
-		case req := <-c.requests:
-			if req.req.ID != nil {
-				c.inflight[*req.req.ID] = req
-			}
-			c.sendRequest(req.req)
-		case <-c.stop:
-			c.writeLk.Lock()
-			cmsg := websocket.FormatCloseMessage(websocket.CloseNormalClosure, "")
-			if err := c.conn.WriteMessage(websocket.CloseMessage, cmsg); err != nil {
-				log.Warn("failed to write close message: ", err)
-			}
-			if err := c.conn.Close(); err != nil {
-				log.Warnw("websocket close error", "error", err)
-			}
-			c.writeLk.Unlock()
-			return
-		}
-	}
-}
diff --git a/lib/lotuslog/levels.go b/lib/lotuslog/levels.go
index ddb70535c..d8b4678b7 100644
--- a/lib/lotuslog/levels.go
+++ b/lib/lotuslog/levels.go
@@ -1,12 +1,23 @@
 package lotuslog
 
-import logging "github.com/ipfs/go-log"
+import (
+	"os"
+
+	logging "github.com/ipfs/go-log/v2"
+)
 
 func SetupLogLevels() {
-	logging.SetLogLevel("*", "INFO")
-	logging.SetLogLevel("dht", "ERROR")
-	logging.SetLogLevel("swarm2", "WARN")
-	logging.SetLogLevel("bitswap", "WARN")
-	logging.SetLogLevel("pubsub", "WARN")
-	logging.SetLogLevel("connmgr", "WARN")
+	if _, set := os.LookupEnv("GOLOG_LOG_LEVEL"); !set {
+		_ = logging.SetLogLevel("*", "INFO")
+		_ = logging.SetLogLevel("dht", "ERROR")
+		_ = logging.SetLogLevel("swarm2", "WARN")
+		_ = logging.SetLogLevel("bitswap", "WARN")
+		//_ = logging.SetLogLevel("pubsub", "WARN")
+		_ = logging.SetLogLevel("connmgr", "WARN")
+		_ = logging.SetLogLevel("advmgr", "DEBUG")
+		_ = logging.SetLogLevel("stores", "DEBUG")
+		_ = logging.SetLogLevel("nat", "INFO")
+	}
+	// Always mute RtRefreshManager because it breaks terminals
+	_ = logging.SetLogLevel("dht/RtRefreshManager", "FATAL")
 }
diff --git a/lib/nullreader/reader.go b/lib/nullreader/reader.go
new file mode 100644
index 000000000..3c0a856ca
--- /dev/null
+++ b/lib/nullreader/reader.go
@@ -0,0 +1,10 @@
+package nullreader
+
+type Reader struct{}
+
+func (Reader) Read(out []byte) (int, error) {
+	for i := range out {
+		out[i] = 0
+	}
+	return len(out), nil
+}
diff --git a/lib/padreader/padreader.go b/lib/padreader/padreader.go
deleted file mode 100644
index 179ae305b..000000000
--- a/lib/padreader/padreader.go
+++ /dev/null
@@ -1,38 +0,0 @@
-package padreader
-
-import (
-	"io"
-	"math/bits"
-
-	sectorbuilder "github.com/filecoin-project/filecoin-ffi"
-)
-
-func PaddedSize(size uint64) uint64 {
-	logv := 64 - bits.LeadingZeros64(size)
-
-	sectSize := uint64(1 << logv)
-	bound := sectorbuilder.GetMaxUserBytesPerStagedSector(sectSize)
-	if size <= bound {
-		return bound
-	}
-
-	return sectorbuilder.GetMaxUserBytesPerStagedSector(1 << (logv + 1))
-}
-
-type nullReader struct{}
-
-func (nr nullReader) Read(b []byte) (int, error) {
-	for i := range b {
-		b[i] = 0
-	}
-	return len(b), nil
-}
-
-func New(r io.Reader, size uint64) (io.Reader, uint64) {
-	padSize := PaddedSize(size)
-
-	return io.MultiReader(
-		io.LimitReader(r, int64(size)),
-		io.LimitReader(nullReader{}, int64(padSize-size)),
-	), padSize
-}
diff --git a/lib/padreader/padreader_test.go b/lib/padreader/padreader_test.go
deleted file mode 100644
index 712317e11..000000000
--- a/lib/padreader/padreader_test.go
+++ /dev/null
@@ -1,19 +0,0 @@
-package padreader
-
-import (
-	"testing"
-
-	"gotest.tools/assert"
-)
-
-func TestComputePaddedSize(t *testing.T) {
-	assert.Equal(t, uint64(1040384), PaddedSize(1000000))
-
-	assert.Equal(t, uint64(1016), PaddedSize(548))
-	assert.Equal(t, uint64(1016), PaddedSize(1015))
-	assert.Equal(t, uint64(1016), PaddedSize(1016))
-	assert.Equal(t, uint64(2032), PaddedSize(1017))
-
-	assert.Equal(t, uint64(2032), PaddedSize(1024))
-	assert.Equal(t, uint64(4064), PaddedSize(2048))
-}
diff --git a/cmd/lotus-chainwatch/utils.go b/lib/parmap/parmap.go
similarity index 76%
rename from cmd/lotus-chainwatch/utils.go
rename to lib/parmap/parmap.go
index a5c821683..dcf0ef3c8 100644
--- a/cmd/lotus-chainwatch/utils.go
+++ b/lib/parmap/parmap.go
@@ -1,11 +1,12 @@
-package main
+package parmap
 
 import (
 	"reflect"
 	"sync"
 )
 
-func maparr(in interface{}) interface{} {
+// MapArr transforms map into slice of map values
+func MapArr(in interface{}) interface{} {
 	rin := reflect.ValueOf(in)
 	rout := reflect.MakeSlice(reflect.SliceOf(rin.Type().Elem()), rin.Len(), rin.Len())
 	var i int
@@ -19,7 +20,8 @@ func maparr(in interface{}) interface{} {
 	return rout.Interface()
 }
 
-func kmaparr(in interface{}) interface{} {
+// KMapArr transforms map into slice of map keys
+func KMapArr(in interface{}) interface{} {
 	rin := reflect.ValueOf(in)
 	rout := reflect.MakeSlice(reflect.SliceOf(rin.Type().Key()), rin.Len(), rin.Len())
 	var i int
@@ -33,8 +35,9 @@ func kmaparr(in interface{}) interface{} {
 	return rout.Interface()
 }
 
-// map[k]v => []func() (k, v)
-func kvmaparr(in interface{}) interface{} {
+// KVMapArr transforms map into slice of functions returning (key, val) pairs.
+// map[A]B => []func()(A, B)
+func KVMapArr(in interface{}) interface{} {
 	rin := reflect.ValueOf(in)
 
 	t := reflect.FuncOf([]reflect.Type{}, []reflect.Type{
@@ -59,7 +62,7 @@ func kvmaparr(in interface{}) interface{} {
 	return rout.Interface()
 }
 
-func par(concurrency int, arr interface{}, f interface{}) {
+func Par(concurrency int, arr interface{}, f interface{}) {
 	throttle := make(chan struct{}, concurrency)
 	var wg sync.WaitGroup
 
diff --git a/peermgr/peermgr.go b/lib/peermgr/peermgr.go
similarity index 67%
rename from peermgr/peermgr.go
rename to lib/peermgr/peermgr.go
index fe87e723f..2f9d34674 100644
--- a/peermgr/peermgr.go
+++ b/lib/peermgr/peermgr.go
@@ -5,15 +5,21 @@ import (
 	"sync"
 	"time"
 
+	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/metrics"
 	"github.com/filecoin-project/lotus/node/modules/dtypes"
+	"go.opencensus.io/stats"
 	"go.uber.org/fx"
+	"go.uber.org/multierr"
+	"golang.org/x/xerrors"
 
+	"github.com/libp2p/go-libp2p-core/event"
 	host "github.com/libp2p/go-libp2p-core/host"
 	net "github.com/libp2p/go-libp2p-core/network"
 	peer "github.com/libp2p/go-libp2p-core/peer"
 	dht "github.com/libp2p/go-libp2p-kad-dht"
 
-	logging "github.com/ipfs/go-log"
+	logging "github.com/ipfs/go-log/v2"
 )
 
 var log = logging.Logger("peermgr")
@@ -42,25 +48,49 @@ type PeerMgr struct {
 	maxFilPeers int
 	minFilPeers int
 
-	expanding bool
+	expanding chan struct{}
 
 	h   host.Host
 	dht *dht.IpfsDHT
 
-	notifee *net.NotifyBundle
+	notifee        *net.NotifyBundle
+	filPeerEmitter event.Emitter
+
+	done chan struct{}
 }
 
-func NewPeerMgr(h host.Host, dht *dht.IpfsDHT, bootstrap dtypes.BootstrapPeers) *PeerMgr {
+type NewFilPeer struct {
+	Id peer.ID
+}
+
+func NewPeerMgr(lc fx.Lifecycle, h host.Host, dht *dht.IpfsDHT, bootstrap dtypes.BootstrapPeers) (*PeerMgr, error) {
 	pm := &PeerMgr{
 		h:             h,
 		dht:           dht,
 		bootstrappers: bootstrap,
 
-		peers: make(map[peer.ID]time.Duration),
+		peers:     make(map[peer.ID]time.Duration),
+		expanding: make(chan struct{}, 1),
 
 		maxFilPeers: MaxFilPeers,
 		minFilPeers: MinFilPeers,
+
+		done: make(chan struct{}),
 	}
+	emitter, err := h.EventBus().Emitter(new(NewFilPeer))
+	if err != nil {
+		return nil, xerrors.Errorf("creating NewFilPeer emitter: %w", err)
+	}
+	pm.filPeerEmitter = emitter
+
+	lc.Append(fx.Hook{
+		OnStop: func(ctx context.Context) error {
+			return multierr.Combine(
+				pm.filPeerEmitter.Close(),
+				pm.Stop(ctx),
+			)
+		},
+	})
 
 	pm.notifee = &net.NotifyBundle{
 		DisconnectedF: func(_ net.Network, c net.Conn) {
@@ -70,10 +100,11 @@ func NewPeerMgr(h host.Host, dht *dht.IpfsDHT, bootstrap dtypes.BootstrapPeers)
 
 	h.Network().Notify(pm.notifee)
 
-	return pm
+	return pm, nil
 }
 
 func (pmgr *PeerMgr) AddFilecoinPeer(p peer.ID) {
+	_ = pmgr.filPeerEmitter.Emit(NewFilPeer{Id: p}) //nolint:errcheck
 	pmgr.peersLk.Lock()
 	defer pmgr.peersLk.Unlock()
 	pmgr.peers[p] = time.Duration(0)
@@ -103,8 +134,14 @@ func (pmgr *PeerMgr) Disconnect(p peer.ID) {
 	}
 }
 
+func (pmgr *PeerMgr) Stop(ctx context.Context) error {
+	log.Warn("closing peermgr done")
+	close(pmgr.done)
+	return nil
+}
+
 func (pmgr *PeerMgr) Run(ctx context.Context) {
-	tick := time.NewTicker(time.Second * 5)
+	tick := build.Clock.Ticker(time.Second * 5)
 	for {
 		select {
 		case <-tick.C:
@@ -112,8 +149,12 @@ func (pmgr *PeerMgr) Run(ctx context.Context) {
 			if pcount < pmgr.minFilPeers {
 				pmgr.expandPeers()
 			} else if pcount > pmgr.maxFilPeers {
-				log.Debug("peer count about threshold: %d > %d", pcount, pmgr.maxFilPeers)
+				log.Debugf("peer count about threshold: %d > %d", pcount, pmgr.maxFilPeers)
 			}
+			stats.Record(ctx, metrics.PeerCount.M(int64(pmgr.getPeerCount())))
+		case <-pmgr.done:
+			log.Warn("exiting peermgr run")
+			return
 		}
 	}
 }
@@ -125,18 +166,19 @@ func (pmgr *PeerMgr) getPeerCount() int {
 }
 
 func (pmgr *PeerMgr) expandPeers() {
-	if pmgr.expanding {
+	select {
+	case pmgr.expanding <- struct{}{}:
+	default:
 		return
 	}
-	pmgr.expanding = true
+
 	go func() {
-		defer func() {
-			pmgr.expanding = false
-		}()
 		ctx, cancel := context.WithTimeout(context.TODO(), time.Second*30)
 		defer cancel()
 
 		pmgr.doExpand(ctx)
+
+		<-pmgr.expanding
 	}()
 }
 
diff --git a/lib/rlepluslazy/bits.go b/lib/rlepluslazy/bits.go
deleted file mode 100644
index 6cf57e27b..000000000
--- a/lib/rlepluslazy/bits.go
+++ /dev/null
@@ -1,160 +0,0 @@
-package rlepluslazy
-
-import (
-	"sort"
-)
-
-type it2b struct {
-	source RunIterator
-	curIdx uint64
-
-	run Run
-}
-
-func (it *it2b) HasNext() bool {
-	return it.run.Valid()
-}
-
-func (it *it2b) Next() (uint64, error) {
-	it.run.Len--
-	res := it.curIdx
-	it.curIdx++
-	return res, it.prep()
-}
-
-func (it *it2b) prep() error {
-	for !it.run.Valid() && it.source.HasNext() {
-		var err error
-		it.run, err = it.source.NextRun()
-		if err != nil {
-			return err
-		}
-
-		if !it.run.Val {
-			it.curIdx += it.run.Len
-			it.run.Len = 0
-		}
-	}
-	return nil
-}
-
-func BitsFromRuns(source RunIterator) (BitIterator, error) {
-	it := &it2b{source: source}
-	if err := it.prep(); err != nil {
-		return nil, err
-	}
-	return it, nil
-}
-
-type sliceIt struct {
-	s []uint64
-}
-
-func (it sliceIt) HasNext() bool {
-	return len(it.s) != 0
-}
-
-func (it *sliceIt) Next() (uint64, error) {
-	res := it.s[0]
-	it.s = it.s[1:]
-	return res, nil
-}
-
-func BitsFromSlice(slice []uint64) BitIterator {
-	sort.Slice(slice, func(i, j int) bool { return slice[i] < slice[j] })
-	return &sliceIt{slice}
-}
-
-type it2r struct {
-	source BitIterator
-
-	runIdx uint64
-	run    [2]Run
-}
-
-func (it *it2r) HasNext() bool {
-	return it.run[0].Valid()
-}
-
-func (it *it2r) NextRun() (Run, error) {
-	res := it.run[0]
-	it.runIdx = it.runIdx + res.Len
-	it.run[0], it.run[1] = it.run[1], Run{}
-	return res, it.prep()
-}
-
-func (it *it2r) prep() error {
-	if !it.HasNext() {
-		return nil
-	}
-	if it.run[0].Val == false {
-		it.run[1].Val = true
-		it.run[1].Len = 1
-		return nil
-	}
-
-	for it.source.HasNext() && !it.run[1].Valid() {
-		nB, err := it.source.Next()
-		if err != nil {
-			return err
-		}
-
-		//fmt.Printf("runIdx: %d, run[0].Len: %d, nB: %d\n", it.runIdx, it.run[0].Len, nB)
-		if it.runIdx+it.run[0].Len == nB {
-			it.run[0].Len++
-		} else {
-			it.run[1].Len = nB - it.runIdx - it.run[0].Len
-			it.run[1].Val = false
-		}
-	}
-	return nil
-}
-
-func (it *it2r) init() error {
-	if it.source.HasNext() {
-		nB, err := it.source.Next()
-		if err != nil {
-			return err
-		}
-		it.run[0].Len = nB
-		it.run[0].Val = false
-		it.run[1].Len = 1
-		it.run[1].Val = true
-	}
-
-	if !it.run[0].Valid() {
-		it.run[0], it.run[1] = it.run[1], Run{}
-		return it.prep()
-	}
-	return nil
-}
-
-func SliceFromRuns(source RunIterator) ([]uint64, error) {
-	rit, err := BitsFromRuns(source)
-	if err != nil {
-		return nil, err
-	}
-
-	res := make([]uint64, 0)
-	for rit.HasNext() {
-		bit, err := rit.Next()
-		if err != nil {
-			return nil, err
-		}
-		res = append(res, bit)
-	}
-	return res, nil
-}
-
-func RunsFromBits(source BitIterator) (RunIterator, error) {
-	it := &it2r{source: source}
-
-	if err := it.init(); err != nil {
-		return nil, err
-	}
-	return it, nil
-}
-
-func RunsFromSlice(slice []uint64) (RunIterator, error) {
-	return RunsFromBits(BitsFromSlice(slice))
-}
diff --git a/lib/rlepluslazy/bits_test.go b/lib/rlepluslazy/bits_test.go
deleted file mode 100644
index 96eac25fa..000000000
--- a/lib/rlepluslazy/bits_test.go
+++ /dev/null
@@ -1,27 +0,0 @@
-package rlepluslazy
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestRunsFromBits(t *testing.T) {
-	expected := []Run{Run{Val: false, Len: 0x1},
-		{Val: true, Len: 0x3},
-		{Val: false, Len: 0x2},
-		{Val: true, Len: 0x3},
-	}
-	rit, err := RunsFromBits(BitsFromSlice([]uint64{1, 2, 3, 6, 7, 8}))
-	assert.NoError(t, err)
-	i := 10
-	output := make([]Run, 0, 4)
-	for rit.HasNext() && i > 0 {
-		run, err := rit.NextRun()
-		assert.NoError(t, err)
-		i--
-		output = append(output, run)
-	}
-	assert.NotEqual(t, 0, i, "too many iterations")
-	assert.Equal(t, expected, output)
-}
diff --git a/lib/rlepluslazy/bitvec.go b/lib/rlepluslazy/bitvec.go
deleted file mode 100644
index e442c09c4..000000000
--- a/lib/rlepluslazy/bitvec.go
+++ /dev/null
@@ -1,114 +0,0 @@
-package rlepluslazy
-
-type rbitvec struct {
-	index int
-
-	bits   uint16
-	bitCap byte
-
-	vec []byte
-}
-
-func readBitvec(vec []byte) *rbitvec {
-	bv := &rbitvec{
-		vec:    vec,
-		index:  1,
-		bitCap: 8,
-	}
-	if len(vec) > 0 {
-		bv.bits = uint16(bv.vec[0])
-	}
-	return bv
-}
-
-// bitMasks is a mask for selecting N first bits out of a byte
-var bitMasks = [9]byte{
-	0x0,
-	0x1,
-	0x3,
-	0x7,
-	0xF,
-	0x1F,
-	0x3F,
-	0x7F,
-	0xFF,
-}
-
-func (bv *rbitvec) Get(count byte) byte {
-	res := byte(bv.bits) & bitMasks[count] // select count bits
-	bv.bits = bv.bits >> count             // remove those bits from storage
-	bv.bitCap = bv.bitCap - count          // decrease nuber of stored bits
-
-	if bv.index < len(bv.vec) { // if vector allows
-		// add bits onto the end of temporary storage
-		bv.bits = bv.bits | uint16(bv.vec[bv.index])<<bv.bitCap
-	}
-
-	// Here be dragons
-	// This is equivalent to
-	// if bv.bitCap < 8 {
-	//     bv.index++
-	//     bv.bitCap = bv.bitCap + 8
-	// }
-	// but implemented without branches because the branch here is unpredictable
-	// Why this is without branches and reading has branch?
-	//  Because branch above is predictable, in 99.99% of cases it will be true
-
-	// if bitCap < 8 it underflows, then high bits get set to 1s
-	// we shift by 7 so the highest bit is in place of the lowest
-	inc := (bv.bitCap - 8) >> 7    // inc == 1 iff bitcap<8 (+10% perf)
-	bv.index = bv.index + int(inc) // increase index if we need more bits
-	bv.bitCap = bv.bitCap + inc*8  // increase bitCap by 8
-
-	return res
-}
-
-func writeBitvec(buf []byte) *wbitvec {
-	// reslice to 0 length for consistent input but to keep capacity
-	return &wbitvec{buf: buf[:0]}
-}
-
-type wbitvec struct {
-	buf   []byte // buffer we will be saving to
-	index int    // index of at which the next byte will be saved
-
-	bits   uint16 // temporary storage for bits
-	bitCap byte   // number of bits stored in temporary storage
-}
-
-func (bv *wbitvec) Out() []byte {
-	if bv.bitCap != 0 {
-		// if there are some bits in temporary storage we need to save them
-		bv.buf = append(bv.buf, 0)[:bv.index+1]
-		bv.buf[bv.index] = byte(bv.bits)
-	}
-	if bv.bitCap > 8 {
-		// if we store some needed bits in second byte, save them also
-		bv.buf = append(bv.buf, byte(bv.bitCap>>8))
-		bv.index++
-		bv.bits = bv.bits - 8
-	}
-	return bv.buf
-}
-
-func (bv *wbitvec) Put(val byte, count byte) {
-	// put val into its place in bv.bits
-	bv.bits = bv.bits | uint16(val)<<bv.bitCap
-	// increase bitCap by the number of bits
-	bv.bitCap = bv.bitCap + count
-
-	// increase len of the buffer if it is needed
-	if bv.index+1 > cap(bv.buf) {
-		bv.buf = append(bv.buf, 0)
-	}
-	bv.buf = bv.buf[:bv.index+1]
-	// save the bits
-	bv.buf[bv.index] = byte(bv.bits)
-
-	// Warning, dragons again
-	// if bitCap is greater than 7 it underflows, same thing as in Put
-	inc := (7 - bv.bitCap) >> 7    // inc == 1 iff bitcap>=8
-	bv.index = bv.index + int(inc) // increase index for the next save
-	bv.bitCap = bv.bitCap - inc*8  // we store less bits now in temporary buffer
-	bv.bits = bv.bits >> (inc * 8) // we can discard those bits as they were saved
-}
diff --git a/lib/rlepluslazy/bitvec_test.go b/lib/rlepluslazy/bitvec_test.go
deleted file mode 100644
index 6938bd793..000000000
--- a/lib/rlepluslazy/bitvec_test.go
+++ /dev/null
@@ -1,21 +0,0 @@
-package rlepluslazy
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestReadBitVec(t *testing.T) {
-	buf := []byte{0x0, 0xff}
-	bv := readBitvec(buf)
-
-	o := bv.Get(1)
-	assert.EqualValues(t, 0, o)
-
-	o = bv.Get(8)
-	assert.EqualValues(t, 0x80, o)
-
-	o = bv.Get(7)
-	assert.EqualValues(t, 0x7f, o)
-}
diff --git a/lib/rlepluslazy/interface.go b/lib/rlepluslazy/interface.go
deleted file mode 100644
index e9f45910f..000000000
--- a/lib/rlepluslazy/interface.go
+++ /dev/null
@@ -1,24 +0,0 @@
-package rlepluslazy
-
-type Run struct {
-	Val bool
-	Len uint64
-}
-
-func (r Run) Valid() bool {
-	return r.Len != 0
-}
-
-type RunIterator interface {
-	NextRun() (Run, error)
-	HasNext() bool
-}
-
-type RunIterable interface {
-	RunIterator() (RunIterator, error)
-}
-
-type BitIterator interface {
-	Next() (uint64, error)
-	HasNext() bool
-}
diff --git a/lib/rlepluslazy/rleplus.go b/lib/rlepluslazy/rleplus.go
deleted file mode 100644
index 100007d65..000000000
--- a/lib/rlepluslazy/rleplus.go
+++ /dev/null
@@ -1,47 +0,0 @@
-package rlepluslazy
-
-import (
-	"errors"
-	"fmt"
-
-	"golang.org/x/xerrors"
-)
-
-const Version = 0
-
-var (
-	ErrWrongVersion = errors.New("invalid RLE+ version")
-	ErrDecode       = fmt.Errorf("invalid encoding for RLE+ version %d", Version)
-)
-
-type RLE struct {
-	buf []byte
-}
-
-func FromBuf(buf []byte) (RLE, error) {
-	rle := RLE{buf: buf}
-
-	if len(buf) > 0 && buf[0]&3 != Version {
-		return RLE{}, xerrors.Errorf("could not create RLE+ for a buffer: %w", ErrWrongVersion)
-	}
-
-	_, err := rle.Count()
-	if err != nil {
-		return RLE{}, err
-	}
-
-	return rle, nil
-}
-
-func (rle *RLE) RunIterator() (RunIterator, error) {
-	source, err := DecodeRLE(rle.buf)
-	return source, err
-}
-
-func (rle *RLE) Count() (uint64, error) {
-	it, err := rle.RunIterator()
-	if err != nil {
-		return 0, err
-	}
-	return Count(it)
-}
diff --git a/lib/rlepluslazy/rleplus_golden_test.go b/lib/rlepluslazy/rleplus_golden_test.go
deleted file mode 100644
index 091d9826c..000000000
--- a/lib/rlepluslazy/rleplus_golden_test.go
+++ /dev/null
@@ -1,3 +0,0 @@
-package rlepluslazy
-
-var goldenRLE = []byte{0x20, 0xfc, 0x40, 0xc2, 0xcc, 0xe5, 0xd8, 0xc1, 0xe1, 0x1e, 0x23, 0xd3, 0x2, 0x2e, 0xcd, 0x3, 0x3e, 0x83, 0x16, 0x26, 0x3a, 0x5c, 0x30, 0x8e, 0x0, 0x5, 0xcc, 0x24, 0xe, 0x96, 0x15, 0x48, 0xa0, 0x2a, 0x40, 0x4, 0x92, 0xe, 0x94, 0xc0, 0x48, 0x91, 0xee, 0x5, 0x28, 0x98, 0x55, 0x90, 0xa0, 0xa4, 0x50, 0x98, 0x14, 0x40, 0x4, 0x59, 0xa, 0x22, 0x0, 0x74, 0xb0, 0x40, 0x66, 0x30, 0xf9, 0x66, 0x90, 0x51, 0xc7, 0x70, 0x74, 0x40, 0x48, 0x7f, 0xf0, 0x80, 0x24, 0x20, 0x85, 0x58, 0x6, 0x7, 0x66, 0x4, 0x87, 0xe5, 0x5, 0x28, 0x0, 0xa4, 0xf0, 0x61, 0x2e, 0x90, 0x8, 0x44, 0x70, 0x38, 0x34, 0xf0, 0x8, 0x4f, 0x70, 0x68, 0xad, 0xd0, 0x90, 0x1e, 0x90, 0x38, 0xc1, 0x85, 0x76, 0x4, 0x15, 0x7c, 0x4, 0x28, 0x28, 0x17, 0x70, 0xe0, 0x15, 0x0, 0x82, 0xfb, 0x11, 0xb, 0x76, 0x9, 0x22, 0xb8, 0x2f, 0x90, 0x20, 0x5f, 0x80, 0x84, 0xc9, 0x10, 0x85, 0x66, 0x9, 0x5, 0xc9, 0x3, 0x2d, 0x19, 0xa4, 0x5a, 0x70, 0x45, 0xa5, 0x40, 0xc2, 0x5, 0x6c, 0x4a, 0xf, 0x64, 0xf4, 0x19, 0xb0, 0x40, 0x28, 0x8b, 0x2, 0x6c, 0x20, 0x3e, 0x90, 0x40, 0x1, 0x19, 0xea, 0x9, 0x20, 0x60, 0x2f, 0x50, 0x60, 0x15, 0x0, 0x4, 0x69, 0x6, 0xb1, 0x8c, 0xa9, 0x85, 0xc6, 0x1f, 0x13, 0x54, 0x3e, 0x58, 0x40, 0x17, 0x60, 0x41, 0x2e, 0x8a, 0x42, 0x3c, 0x8b, 0xb, 0x3f, 0x8, 0x10, 0x5c, 0x32, 0x38, 0xd4, 0x1e, 0x68, 0x18, 0x5b, 0x70, 0xc1, 0x2c, 0x6, 0x17, 0x6c, 0x17, 0xf8, 0x74, 0x36, 0x28, 0x9c, 0xe, 0x20, 0x2, 0xa1, 0x84, 0xf, 0xa2, 0x82, 0xe, 0xbf, 0x82, 0x45, 0x29, 0x84, 0x7, 0x16, 0x25, 0x10, 0x12, 0x38, 0x8c, 0x13, 0x50, 0x41, 0xff, 0x3, 0x13, 0x70, 0x16, 0x80, 0x81, 0x63, 0x85, 0x8f, 0xa0, 0x81, 0xa, 0xe1, 0x80, 0x84, 0xa3, 0x81, 0x89, 0xff, 0x84, 0xc7, 0x3c, 0x87, 0x49, 0xbb, 0x81, 0x4b, 0x21, 0x82, 0x3, 0x2f, 0x83, 0x84, 0x29, 0x83, 0x8c, 0xe0, 0x0, 0x40, 0x8c, 0xda, 0x20, 0x42, 0x6, 0x13, 0x64, 0x7, 0x24, 0x85, 0xc, 0xa6, 0x21, 0x24, 0x6c, 0x7, 0x74, 0x20, 0x13, 0x3c, 0x2, 0x13, 0x54, 0xba, 0x1d, 0x14, 0x9e, 0xb, 0xe0, 0x0, 0x39, 0x82, 0xa, 0x72, 0xb, 0x80, 0x60, 0x53, 0x20, 0xd5, 0xe, 0x32, 0xd5, 0xe, 0x12, 0xb9, 0x1, 0x44, 0x90, 0x27, 0x51, 0x59, 0xe0, 0x12, 0xc3, 0x4, 0xe8, 0x1, 0x78, 0x40, 0xd8, 0xe0, 0x3, 0x7b, 0x60, 0x93, 0x6b, 0x20, 0x72, 0xf8, 0x20, 0xf1, 0xe1, 0xe0, 0x4d, 0x90, 0xdf, 0x2, 0x1f, 0x69, 0x3, 0x36, 0x30, 0x8d, 0x20, 0x82, 0x58, 0xa, 0x8f, 0xec, 0x2, 0x8d, 0xe8, 0x0, 0x11, 0x55, 0x81, 0x58, 0x17, 0xa0, 0x82, 0xa5, 0x81, 0x88, 0xb6, 0x83, 0x88, 0xed, 0x86, 0x88, 0xe0, 0x86, 0x4b, 0x6e, 0x82, 0x45, 0xe1, 0x89, 0xc8, 0x2c, 0x41, 0x78, 0x9, 0x12, 0xbd, 0x91, 0x50, 0x1, 0x42, 0x90, 0x85, 0x70, 0x69, 0xb5, 0x20, 0x83, 0x5e, 0x2, 0x8d, 0xfb, 0x2, 0xf, 0xfb, 0xa, 0x9, 0xcc, 0x4, 0x8b, 0xe4, 0x5, 0x87, 0xc9, 0x2, 0xf, 0xfc, 0x1, 0x5c, 0x8, 0xf, 0xd0, 0x1, 0x4e, 0xd0, 0x60, 0x4d, 0x50, 0xa1, 0x3c, 0xf0, 0x20, 0x6c, 0x88, 0xe1, 0x41, 0x5c, 0x11, 0x1c, 0xc8, 0x25, 0x4c, 0xc0, 0x1d, 0x1c, 0x4e, 0x61, 0x54, 0x2a, 0x5, 0x14, 0xf6, 0x54, 0x3c, 0xb, 0x44, 0xe4, 0x5, 0x64, 0x42, 0x1f, 0x64, 0x32, 0x23, 0xa0, 0x20, 0xf9, 0x1, 0xc, 0x40, 0x27, 0xf8, 0x40, 0x3c, 0xc0, 0x82, 0x72, 0x1, 0xd, 0xd1, 0x43, 0x11, 0x1, 0xd, 0xaa, 0x35, 0xc8, 0xe0, 0x1e, 0x42, 0x41, 0x5b, 0x20, 0x8b, 0x4, 0xe, 0xc9, 0x3, 0xa, 0xea, 0x1, 0x3e, 0x5f, 0x12, 0xab, 0x7, 0x40, 0xf0, 0xad, 0x60, 0x42, 0x6f, 0xa1, 0xd2, 0x39, 0x60, 0x91, 0x64, 0xf1, 0xe4, 0x10, 0x3f, 0x60, 0xc2, 0x5c, 0x94, 0x62, 0x7, 0x1f, 0x67, 0x5, 0x87, 0xcc, 0x7, 0x9f, 0xee, 0xe, 0x13, 0xd8, 0x2, 0x38, 0xa0, 0xb5, 0x20, 0x2, 0x4e, 0x1, 0x85, 0x7c, 0xc, 0x4e, 0xb0, 0xde, 0x90, 0x80, 0x2c, 0x50, 0xd8, 0x77, 0x88, 0xf6, 0x80, 0x4, 0x22, 0x85, 0xce, 0xf2, 0x82, 0xcb, 0xb4, 0x5, 0x14, 0x68, 0xa9, 0x70, 0x77, 0xb8, 0x34, 0x1b, 0xf0, 0x1, 0xec, 0x1, 0x13, 0x58, 0x1a, 0x78, 0x88, 0xb, 0x58, 0x80, 0x27, 0x98, 0x20, 0x4b, 0x50, 0x41, 0x69, 0x84, 0xc9, 0x63, 0x81, 0x8, 0x7b, 0x6, 0x10, 0xd8, 0x1e, 0x38, 0x1c, 0x17, 0x68, 0x0, 0x2e, 0xa8, 0xe4, 0x23, 0x78, 0xdc, 0xa, 0x28, 0x38, 0xb, 0x28, 0xcc, 0x1f, 0x40, 0x1, 0x6f, 0x83, 0x88, 0x75, 0x82, 0xc7, 0x8c, 0x4, 0xec, 0x8, 0x28, 0xcc, 0x7b, 0xe4, 0xb8, 0x0, 0xe, 0x46, 0x35, 0x2c, 0xc2, 0x2d, 0xb8, 0xe0, 0xb5, 0x42, 0xa2, 0x75, 0x40, 0x2, 0xfc, 0xc4, 0x43, 0x98, 0x41, 0xa1, 0x56, 0x40, 0xc4, 0x5a, 0x1, 0x13, 0xda, 0x33, 0x5c, 0xf2, 0x7, 0x44, 0x74, 0x3f, 0x5c, 0x5a, 0x49, 0x24, 0x64, 0x3, 0x2c, 0xd8, 0x23, 0x34, 0x78, 0x19, 0xb8, 0x61, 0x15, 0x42, 0xa3, 0xc6, 0x46, 0x73, 0x80, 0xa, 0x52, 0x17, 0x0, 0xa1, 0x7d, 0x40, 0x26, 0x19, 0xc1, 0x6, 0xf0, 0x40, 0x45, 0x90, 0xc2, 0x81, 0xf6, 0xc0, 0x22, 0xf3, 0x80, 0x15, 0x2, 0x7, 0x2c, 0x9a, 0x3, 0xd8, 0xc0, 0x95, 0x21, 0xbb, 0x4, 0x80, 0x0, 0x99, 0xe0, 0x90, 0x19, 0x21, 0x93, 0xfe, 0x21, 0x43, 0x1a, 0x90, 0x64, 0x2, 0x2e, 0x20, 0x65, 0xc8, 0x79, 0x86, 0xc4, 0x78, 0x4, 0x2a, 0x38, 0x9e, 0x50, 0x82, 0xaf, 0x5, 0x17, 0x50, 0x33, 0xa0, 0x42, 0x21, 0x5, 0x24, 0xc0, 0xf, 0x64, 0xb0, 0x40, 0xe5, 0x3a, 0x42, 0xc1, 0xfd, 0x2, 0x3c, 0x10, 0x9, 0x88, 0x40, 0x5a, 0x40, 0x84, 0x11, 0x41, 0x83, 0x7f, 0x42, 0x82, 0x10, 0x3, 0x8, 0x8a, 0x1b, 0xc8, 0xc0, 0xb2, 0x81, 0x16, 0x6e, 0x68, 0x21, 0x1a, 0x2, 0x11, 0x30, 0x0, 0x42, 0x71, 0xc1, 0xe7, 0x89, 0x18, 0x60, 0x5, 0x3c, 0x70, 0x3c, 0xa2, 0x35, 0x14, 0xe6, 0x25, 0x98, 0x20, 0x97, 0x20, 0xa8, 0x2, 0x26, 0x8e, 0x12, 0x6c, 0x30, 0x2a, 0xa0, 0x22, 0x5e, 0xc2, 0x5, 0x8f, 0x8, 0xa, 0xea, 0x4, 0xa, 0x9b, 0x4, 0x3e, 0xf4, 0x3, 0x2e, 0x92, 0x5, 0x26, 0x65, 0xe0, 0x28, 0xe, 0x38, 0x50, 0xb0, 0x2f, 0x61, 0xe1, 0x6a, 0xa0, 0xf3, 0x2c, 0x12, 0x49, 0x6, 0x26, 0x20, 0x84, 0x30, 0x51, 0x5d, 0x90, 0xb0, 0x57, 0x70, 0x11, 0x3d, 0x70, 0x10, 0x53, 0x1c, 0x98, 0xf8, 0x54, 0x0, 0x2, 0xc3, 0x10, 0x58, 0xb0, 0x4d, 0xb0, 0x20, 0xd, 0x71, 0x40, 0x4d, 0x20, 0x4, 0x79, 0x5, 0x1f, 0x7b, 0x1, 0x89, 0x69, 0x2, 0x28, 0xc8, 0x17, 0x30, 0x81, 0x15, 0xd0, 0xc0, 0x5f, 0x50, 0x19, 0x1e, 0x72, 0x4d, 0x8d, 0xc1, 0x1, 0x91, 0x7e, 0x5, 0x34, 0x30, 0xe, 0x91, 0xc9, 0x74, 0x20, 0x84, 0xd5, 0x13, 0xb, 0x61, 0xd, 0x8f, 0xd8, 0x0, 0x32, 0x88, 0x4e, 0x20, 0x4, 0xd7, 0x84, 0xbc, 0x6, 0x38, 0x6c, 0x1f, 0xc8, 0xe0, 0x12, 0x68, 0xb4, 0x16, 0xa0, 0x41, 0x3a, 0x7, 0x27, 0x90, 0x1a, 0x88, 0x18, 0xa, 0xa5, 0x71, 0x25, 0xf1, 0x9, 0xa8, 0x50, 0x9d, 0xe1, 0x82, 0xbc, 0x81, 0x4, 0xc9, 0x9, 0x7c, 0x10, 0x3e, 0x40, 0x5, 0xe9, 0x2, 0x3a, 0xce, 0xd, 0x5c, 0x70, 0xfa, 0x60, 0x91, 0x41, 0x9, 0xc7, 0x8, 0xa, 0x93, 0x3, 0x7c, 0xa0, 0x3f, 0xe0, 0x53, 0x4b, 0x40, 0x6, 0xea, 0xd, 0xa, 0xcd, 0x18, 0xa, 0x83, 0x5, 0x2a, 0x29, 0xe, 0xc3, 0x1, 0x54, 0xb0, 0x7c, 0x41, 0x4, 0xaf, 0x2, 0x54, 0x40, 0xbe, 0x20, 0x41, 0xa7, 0x21, 0x29, 0xe1, 0x62, 0x6a, 0x81, 0x8, 0xb8, 0x4, 0x64, 0xb0, 0x29, 0xa0, 0xb0, 0x7f, 0xe0, 0x0, 0x3a, 0xc0, 0x5, 0xcb, 0x2, 0xb8, 0xe0, 0x6e, 0xc0, 0x8, 0xda, 0x13, 0x78, 0xe0, 0x1a, 0x0, 0x4, 0xe2, 0x8, 0xa, 0x1b, 0x16, 0x9d, 0x35, 0x88, 0x0, 0xa, 0x61, 0xe3, 0x1d, 0x61, 0xa1, 0x8f, 0xe0, 0xe3, 0x7d, 0x0, 0x8, 0x56, 0x16, 0xb9, 0x5, 0x7c, 0x50, 0x5a, 0xe2, 0xd1, 0xc9, 0x40, 0x8, 0x93, 0xa, 0x36, 0xc4, 0x2, 0xe, 0xf7, 0x15, 0xa, 0xae, 0x1b, 0xa, 0x83, 0xd, 0x36, 0xe8, 0xa, 0x16, 0xde, 0x11, 0x3e, 0x89, 0xb, 0x50, 0x70, 0xd9, 0x10, 0xca, 0x0, 0x38, 0xc0, 0x8f, 0xc1, 0x83, 0x77, 0x86, 0xc, 0x1b, 0xe8, 0x0, 0x9e, 0x78, 0x8, 0xb, 0xa0, 0xc3, 0xb7, 0x84, 0x82, 0x18, 0x4b, 0x54, 0x3b, 0x70, 0x81, 0xbe, 0x41, 0xcc, 0xd, 0x8, 0x61, 0x8e, 0x17, 0x0, 0xd, 0xd8, 0x40, 0x34, 0x20, 0xbd, 0x12, 0xe, 0x83, 0x16, 0x3a, 0x8a, 0x16, 0x48, 0xd0, 0x59, 0xe0, 0x21, 0x4c, 0x60, 0x42, 0xaa, 0xa0, 0x60, 0x69, 0x0, 0x5, 0xb9, 0x2, 0x12, 0x94, 0xf, 0x48, 0x60, 0xfe, 0x90, 0x66, 0x3, 0x4e, 0xf8, 0x4c, 0x50, 0xd8, 0x5f, 0x70, 0x99, 0x1f, 0xd0, 0xf0, 0x55, 0x88, 0x74, 0x81, 0xd, 0x6b, 0x80, 0x84, 0xb9, 0x8d, 0xc7, 0x34, 0x81, 0x4e, 0xa4, 0x8a, 0x82, 0xa1, 0x2, 0x15, 0x40, 0x7, 0x70, 0x81, 0x7f, 0x8d, 0x3, 0x61, 0x2, 0x11, 0x1c, 0x1e, 0x78, 0xb8, 0x1a, 0x80, 0x2, 0xa3, 0x80, 0x2, 0x69, 0x80, 0xc7, 0xf3, 0x1, 0x2c, 0xdc, 0x13, 0x90, 0x81, 0xad, 0x81, 0x88, 0xb8, 0x81, 0x82, 0x78, 0x84, 0x4e, 0xb6, 0x83, 0x45, 0xb3, 0x6, 0x37, 0x90, 0x5e, 0x68, 0x48, 0x82, 0x28, 0x0, 0xc1, 0x1, 0xe5, 0x80, 0x86, 0xf2, 0x81, 0xcc, 0xb9, 0x81, 0x88, 0xeb, 0x80, 0x3, 0xb7, 0x87, 0x8d, 0x69, 0x83, 0x45, 0x74, 0x5, 0x22, 0x84, 0x43, 0x48, 0x48, 0x9f, 0xa4, 0xf3, 0x40, 0xa4, 0x78, 0x80, 0xb, 0xec, 0xb, 0x2c, 0x8, 0x7, 0x74, 0x88, 0x15, 0x34, 0xc2, 0xa2, 0xa1, 0x33, 0xd, 0xc1, 0x8, 0x91, 0x18, 0xf0, 0x60, 0x38, 0x40, 0x7, 0x83, 0x1, 0x8c, 0x10, 0x19, 0x40, 0x4, 0xbb, 0x1a, 0x68, 0x30, 0x2b, 0x60, 0x92, 0xaa, 0x80, 0x8, 0xef, 0x2, 0x54, 0x50, 0x7f, 0x80, 0xa, 0x89, 0x2, 0x32, 0x94, 0x17, 0x1a, 0xe1, 0x4, 0xe, 0xa6, 0x1, 0xa, 0x97, 0xb, 0x16, 0xe4, 0xa, 0x91, 0x3c, 0x90, 0xf9, 0x1e, 0x10, 0xf1, 0x25, 0x70, 0x29, 0x1d, 0xa0, 0x82, 0xf0, 0x4, 0x40, 0xe8, 0x56, 0x40, 0x5, 0x54, 0xf, 0x1b, 0xc6, 0x1, 0x2a, 0x98, 0x35, 0xf0, 0x30, 0xbd, 0x80, 0x7, 0xd9, 0x6, 0x20, 0x90, 0x5e, 0x9, 0xf9, 0xb, 0x1c, 0xac, 0x22, 0x20, 0xc1, 0x96, 0x4f, 0x70, 0x80, 0x4b, 0xae, 0x81, 0x47, 0xb9, 0x8d, 0x8d, 0x3d, 0x82, 0x45, 0x65, 0x80, 0xca, 0xb9, 0x5, 0x18, 0x6c, 0x26, 0xa4, 0x53, 0x40, 0xc7, 0xb2, 0xc2, 0x6, 0xdf, 0x80, 0xa, 0xa0, 0x29, 0x30, 0x23, 0x32, 0x81, 0x8, 0x7c, 0x3c, 0x3e, 0x37, 0xb8, 0x20, 0xd7, 0x80, 0xb, 0xfc, 0x25, 0x24, 0xe8, 0x1d, 0x2c, 0x50, 0xd, 0x3c, 0xe0, 0x88, 0x60, 0x3a, 0x83, 0xc, 0xa6, 0x11, 0xb2, 0x5c, 0xc1, 0x7, 0xf2, 0x1, 0x2a, 0xce, 0x1, 0x12, 0xd7, 0x64, 0xe, 0xb2, 0x7, 0xa9, 0x6e, 0xd0, 0x71, 0x1d, 0x70, 0x80, 0xe5, 0x8, 0x6d, 0x83, 0x84, 0x6a, 0x0, 0x19, 0x78, 0xe, 0x48, 0xc4, 0x7, 0x80, 0x81, 0xae, 0x80, 0x44, 0x3f, 0x1, 0x13, 0x4c, 0x1f, 0x58, 0xe0, 0x4a, 0x48, 0x8c, 0x2e, 0x4, 0x78, 0x81, 0x16, 0x7a, 0x5, 0x90, 0xa0, 0xdd, 0xc3, 0xa7, 0xd8, 0xc2, 0x44, 0xfc, 0x40, 0x2, 0xda, 0x0, 0xc, 0x54, 0x11, 0xe0, 0xc0, 0xba, 0x80, 0x9, 0x7a, 0x9, 0xa0, 0x0, 0x52, 0x40, 0x61, 0x51, 0x44, 0x67, 0x12, 0x3, 0xc, 0x0, 0xf, 0x70, 0xe1, 0x31, 0xc0, 0xe1, 0xb6, 0xc2, 0xa1, 0xb9, 0xc1, 0x46, 0x50, 0x40, 0x1, 0x9b, 0x1, 0x1a, 0xc2, 0x11, 0x72, 0x4c, 0xa1, 0x2, 0x5b, 0x20, 0xb1, 0x28, 0xc0, 0x4, 0xc7, 0x12, 0x40, 0x0, 0xee, 0x0, 0x8, 0xd1, 0x2a, 0x32, 0xd0, 0x11, 0x81, 0x7f, 0xa0, 0x84, 0x77, 0xa, 0x93, 0xc8, 0x0, 0x97, 0xe7, 0x1, 0x9, 0x50, 0x1, 0x5, 0xf5, 0x0, 0x85, 0xee, 0x3, 0x93, 0x59, 0x82, 0x3c, 0x59, 0x14, 0x52, 0x28, 0xa4, 0xb, 0x28, 0x30, 0xa, 0x84, 0x4d, 0x81, 0x7f, 0x43, 0xa7, 0x56, 0x80, 0xb, 0x92, 0xf, 0x3c, 0x98, 0x47, 0xa8, 0x0, 0x35, 0x20, 0xde, 0x3, 0x2a, 0x8b, 0x2, 0x2e, 0x8f, 0x6, 0x58, 0x40, 0x58, 0xe0, 0x33, 0x4d, 0xc1, 0xa, 0xc0, 0x6, 0xc0, 0xc0, 0x4, 0x5, 0xf5, 0x4, 0x16, 0xfa, 0x26, 0x60, 0x60, 0x9c, 0xa0, 0x63, 0x2f, 0x20, 0x13, 0xbe, 0x81, 0xc, 0x97, 0xd, 0x32, 0xd0, 0x1, 0x22, 0x3e, 0x80, 0x20, 0x49, 0xe0, 0x50, 0x18, 0x21, 0x2, 0x19, 0xe0, 0x20, 0xbd, 0x10, 0xc8, 0x4, 0x9b, 0x40, 0xd, 0x24, 0xe0, 0xcd, 0x90, 0xe9, 0x3, 0x82, 0x16, 0x11, 0x28, 0x2a, 0xd0, 0xb5, 0x0, 0x83, 0x73, 0xb, 0x19, 0xd6, 0x7, 0x1b, 0x71, 0x5, 0x26, 0x28, 0x6d, 0x0, 0x82, 0x7f, 0x5, 0x2a, 0xb8, 0x56, 0x80, 0x84, 0x79, 0x4, 0x86, 0xa0, 0x7e, 0x50, 0x20, 0xe3, 0x3, 0x20, 0x36, 0x88, 0xaf, 0x90, 0x91, 0xd5, 0x60, 0x82, 0xe4, 0x1, 0x93, 0xf4, 0x8, 0x95, 0xc0, 0x5, 0x1b, 0x61, 0x6, 0x87, 0xc3, 0x1, 0x47, 0xb5, 0x41, 0x51, 0xc9, 0x26, 0x0, 0x3, 0xc1, 0x0, 0x87, 0x46, 0x5, 0x8f, 0x5a, 0x1, 0x95, 0xef, 0x9, 0x89, 0xca, 0x0, 0x8b, 0xf7, 0x2, 0x19, 0x5b, 0xb, 0x32, 0x8, 0x82, 0x2, 0xec, 0x0, 0x13, 0x23, 0x11, 0x40, 0x4, 0x20, 0xe0, 0x26, 0x51, 0x89, 0x85, 0x40, 0x84, 0xc2, 0x1, 0xf, 0x51, 0x1, 0xd, 0x8, 0x6e, 0xf8, 0x6e, 0x0, 0x82, 0x6a, 0x1, 0xf, 0x72, 0x4, 0x2c, 0x40, 0x4d, 0x50, 0x41, 0x16, 0x8, 0x67, 0x46, 0x4a, 0xd, 0x90, 0xc0, 0xfe, 0xc1, 0x42, 0x30, 0x1, 0x9, 0x50, 0xd, 0x5c, 0x16, 0x9, 0xc0, 0x0, 0xf6, 0x41, 0x27, 0x92, 0xc0, 0x63, 0x7a, 0xc2, 0xa1, 0x9c, 0x40, 0x21, 0x27, 0xec, 0x25, 0x4c, 0x80, 0x1b, 0x20, 0x81, 0x2b, 0xa0, 0x0, 0x18, 0xe0, 0xe1, 0x6a, 0x21, 0x2, 0xa3, 0xd2, 0xaf, 0xe0, 0x3, 0x7a, 0x0, 0x4, 0x99, 0x26, 0x50, 0x70, 0xcf, 0xa0, 0xe1, 0x58, 0xa1, 0xd3, 0x38, 0xa0, 0x30, 0x79, 0x20, 0xd2, 0x3a, 0x20, 0xb3, 0x5e, 0x60, 0xa1, 0xeb, 0x80, 0x5, 0xc8, 0x1, 0x4c, 0xc0, 0x5b, 0xa0, 0x60, 0xc8, 0x41, 0x4, 0x6d, 0xc8, 0x20, 0xab, 0x10, 0xe3, 0x7, 0x1f, 0x4b, 0x7, 0x28, 0x70, 0x17, 0x80, 0x84, 0xf9, 0x6, 0x46, 0x90, 0x44, 0xf0, 0x40, 0xf6, 0x60, 0x5, 0xca, 0x7, 0x1b, 0xcf, 0x2, 0xb, 0x61, 0x12, 0x15}
diff --git a/lib/rlepluslazy/rleplus_reader.go b/lib/rlepluslazy/rleplus_reader.go
deleted file mode 100644
index 0b3a77da0..000000000
--- a/lib/rlepluslazy/rleplus_reader.go
+++ /dev/null
@@ -1,77 +0,0 @@
-package rlepluslazy
-
-import (
-	"github.com/multiformats/go-varint"
-	"golang.org/x/xerrors"
-)
-
-func DecodeRLE(buf []byte) (RunIterator, error) {
-	bv := readBitvec(buf)
-
-	ver := bv.Get(2) // Read version
-	if ver != Version {
-		return nil, ErrWrongVersion
-	}
-
-	it := &rleIterator{bv: bv}
-
-	// next run is previous in relation to prep
-	// so we invert the value
-	it.nextRun.Val = bv.Get(1) != 1
-	if err := it.prep(); err != nil {
-		return nil, err
-	}
-	return it, nil
-}
-
-type rleIterator struct {
-	bv *rbitvec
-
-	nextRun Run
-}
-
-func (it *rleIterator) HasNext() bool {
-	return it.nextRun.Valid()
-}
-
-func (it *rleIterator) NextRun() (Run, error) {
-	ret := it.nextRun
-	return ret, it.prep()
-}
-
-func (it *rleIterator) prep() error {
-	x := it.bv.Get(1)
-
-	switch x {
-	case 1:
-		it.nextRun.Len = 1
-
-	case 0:
-		y := it.bv.Get(1)
-		switch y {
-		case 1:
-			it.nextRun.Len = uint64(it.bv.Get(4))
-		case 0:
-			var buf = make([]byte, 0, 10)
-			for {
-				b := it.bv.Get(8)
-				buf = append(buf, b)
-				if b&0x80 == 0 {
-					break
-				}
-				if len(buf) > 10 {
-					return xerrors.Errorf("run too long: %w", ErrDecode)
-				}
-			}
-			var err error
-			it.nextRun.Len, _, err = varint.FromUvarint(buf)
-			if err != nil {
-				return err
-			}
-
-		}
-	}
-
-	it.nextRun.Val = !it.nextRun.Val
-	return nil
-}
diff --git a/lib/rlepluslazy/rleplus_test.go b/lib/rlepluslazy/rleplus_test.go
deleted file mode 100644
index 3b47d02c2..000000000
--- a/lib/rlepluslazy/rleplus_test.go
+++ /dev/null
@@ -1,170 +0,0 @@
-package rlepluslazy
-
-import (
-	"math/rand"
-	"testing"
-
-	"github.com/filecoin-project/lotus/extern/rleplus"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestDecode(t *testing.T) {
-	// Encoding bitvec![LittleEndian; 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
-	// in the Rust reference implementation gives an encoding of [223, 145, 136, 0] (without version field)
-	// The bit vector is equivalent to the integer set { 0, 2, 4, 5, 6, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27 }
-
-	// This is the above reference output with a version header "00" manually added
-	referenceEncoding := []byte{124, 71, 34, 2}
-
-	expectedNumbers := []uint64{0, 2, 4, 5, 6, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27}
-
-	runs, err := RunsFromBits(BitsFromSlice(expectedNumbers))
-	assert.NoError(t, err)
-	encoded, err := EncodeRuns(runs, []byte{})
-	assert.NoError(t, err)
-
-	// Our encoded bytes are the same as the ref bytes
-	assert.Equal(t, len(referenceEncoding), len(encoded))
-	assert.Equal(t, referenceEncoding, encoded)
-
-	rle, err := FromBuf(encoded)
-	assert.NoError(t, err)
-	decoded := make([]uint64, 0, len(expectedNumbers))
-
-	rit, err := rle.RunIterator()
-	assert.NoError(t, err)
-
-	it, err := BitsFromRuns(rit)
-	assert.NoError(t, err)
-	for it.HasNext() {
-		bit, err := it.Next()
-		assert.NoError(t, err)
-		decoded = append(decoded, bit)
-	}
-
-	// Our decoded integers are the same as expected
-	assert.Equal(t, expectedNumbers, decoded)
-}
-
-func TestGoldenGen(t *testing.T) {
-	t.SkipNow()
-	N := 10000
-	mod := uint32(1) << 20
-	runExProp := float32(0.93)
-
-	bits := make([]uint64, N)
-
-	for i := 0; i < N; i++ {
-		x := rand.Uint32() % mod
-		bits[i] = uint64(x)
-		for rand.Float32() < runExProp && i+1 < N {
-			i++
-			x = (x + 1) % mod
-			bits[i] = uint64(x)
-		}
-	}
-
-	out, _, err := rleplus.Encode(bits)
-	assert.NoError(t, err)
-	t.Logf("%#v", out)
-	_, runs := rleplus.RunLengths(bits)
-	t.Logf("runs: %v", runs)
-	t.Logf("len: %d", len(out))
-}
-
-func TestGolden(t *testing.T) {
-	expected, _ := rleplus.Decode(goldenRLE)
-	res := make([]uint64, 0, len(expected))
-
-	rle, err := FromBuf(goldenRLE)
-	assert.NoError(t, err)
-	rit, err := rle.RunIterator()
-	assert.NoError(t, err)
-	it, err := BitsFromRuns(rit)
-	assert.NoError(t, err)
-	for it.HasNext() {
-		bit, err := it.Next()
-		assert.NoError(t, err)
-		res = append(res, bit)
-	}
-	assert.Equal(t, expected, res)
-}
-
-func TestGoldenLoop(t *testing.T) {
-	rle, err := FromBuf(goldenRLE)
-	assert.NoError(t, err)
-
-	rit, err := rle.RunIterator()
-	assert.NoError(t, err)
-
-	buf, err := EncodeRuns(rit, nil)
-	assert.NoError(t, err)
-
-	assert.Equal(t, goldenRLE, buf)
-}
-
-var Res uint64 = 0
-
-func BenchmarkRunIterator(b *testing.B) {
-	b.ReportAllocs()
-	var r uint64
-	for i := 0; i < b.N; i++ {
-		rle, _ := FromBuf(goldenRLE)
-		rit, _ := rle.RunIterator()
-		for rit.HasNext() {
-			run, _ := rit.NextRun()
-			if run.Val {
-				r = r + run.Len
-			}
-		}
-	}
-	Res = Res + r
-}
-
-func BenchmarkRunsToBits(b *testing.B) {
-	b.ReportAllocs()
-	var r uint64
-	for i := 0; i < b.N; i++ {
-		rle, _ := FromBuf(goldenRLE)
-		rit, _ := rle.RunIterator()
-		it, _ := BitsFromRuns(rit)
-		for it.HasNext() {
-			bit, _ := it.Next()
-			if bit < 1<<63 {
-				r++
-			}
-		}
-	}
-	Res = Res + r
-}
-
-func BenchmarkOldRLE(b *testing.B) {
-	b.ReportAllocs()
-	var r uint64
-	for i := 0; i < b.N; i++ {
-		rle, _ := rleplus.Decode(goldenRLE)
-		r = r + uint64(len(rle))
-	}
-	Res = Res + r
-}
-
-func BenchmarkDecodeEncode(b *testing.B) {
-	b.ReportAllocs()
-	var r uint64
-	out := make([]byte, 0, len(goldenRLE))
-	for i := 0; i < b.N; i++ {
-		rle, _ := FromBuf(goldenRLE)
-		rit, _ := rle.RunIterator()
-		out, _ = EncodeRuns(rit, out)
-		r = r + uint64(len(out))
-	}
-
-	/*
-		for i := 0; i < b.N; i++ {
-			rle, _ := rleplus.Decode(goldenRLE)
-			out, _, _ := rleplus.Encode(rle)
-			r = r + uint64(len(out))
-		}
-	*/
-	Res = Res + r
-}
diff --git a/lib/rlepluslazy/rleplus_writer.go b/lib/rlepluslazy/rleplus_writer.go
deleted file mode 100644
index 306da18d3..000000000
--- a/lib/rlepluslazy/rleplus_writer.go
+++ /dev/null
@@ -1,51 +0,0 @@
-package rlepluslazy
-
-import (
-	"encoding/binary"
-)
-
-func EncodeRuns(rit RunIterator, buf []byte) ([]byte, error) {
-	bv := writeBitvec(buf)
-	bv.Put(0, 2)
-
-	first := true
-	varBuf := make([]byte, binary.MaxVarintLen64)
-
-	for rit.HasNext() {
-		run, err := rit.NextRun()
-		if err != nil {
-			return nil, err
-		}
-
-		if first {
-			if run.Val {
-				bv.Put(1, 1)
-			} else {
-				bv.Put(0, 1)
-			}
-			first = false
-		}
-
-		switch {
-		case run.Len == 1:
-			bv.Put(1, 1)
-		case run.Len < 16:
-			bv.Put(2, 2)
-			bv.Put(byte(run.Len), 4)
-		case run.Len >= 16:
-			bv.Put(0, 2)
-			numBytes := binary.PutUvarint(varBuf, run.Len)
-			for i := 0; i < numBytes; i++ {
-				bv.Put(varBuf[i], 8)
-			}
-		}
-
-	}
-
-	if first {
-		bv.Put(0, 1)
-	}
-
-	return bv.Out(), nil
-
-}
diff --git a/lib/rlepluslazy/runs.go b/lib/rlepluslazy/runs.go
deleted file mode 100644
index 034a449c9..000000000
--- a/lib/rlepluslazy/runs.go
+++ /dev/null
@@ -1,120 +0,0 @@
-package rlepluslazy
-
-import (
-	"math"
-
-	"golang.org/x/xerrors"
-)
-
-func Sum(a, b RunIterator) (RunIterator, error) {
-	it := addIt{a: a, b: b}
-	it.prep()
-	return &it, nil
-}
-
-type addIt struct {
-	a RunIterator
-	b RunIterator
-
-	next Run
-
-	arun Run
-	brun Run
-}
-
-func (it *addIt) prep() error {
-	var err error
-
-	fetch := func() error {
-		if !it.arun.Valid() && it.a.HasNext() {
-			it.arun, err = it.a.NextRun()
-			if err != nil {
-				return err
-			}
-		}
-
-		if !it.brun.Valid() && it.b.HasNext() {
-			it.brun, err = it.b.NextRun()
-			if err != nil {
-				return err
-			}
-		}
-		return nil
-	}
-
-	if err := fetch(); err != nil {
-		return err
-	}
-
-	// one is not valid
-	if !it.arun.Valid() {
-		it.next = it.brun
-		it.brun.Len = 0
-		return nil
-	}
-
-	if !it.brun.Valid() {
-		it.next = it.arun
-		it.arun.Len = 0
-		return nil
-	}
-
-	if !(it.arun.Val || it.brun.Val) {
-		min := it.arun.Len
-		if it.brun.Len < min {
-			min = it.brun.Len
-		}
-		it.next = Run{Val: it.arun.Val, Len: min}
-		it.arun.Len -= it.next.Len
-		it.brun.Len -= it.next.Len
-		return nil
-	}
-
-	it.next = Run{Val: true}
-	// different vals, 'true' wins
-	for (it.arun.Val && it.arun.Valid()) || (it.brun.Val && it.brun.Valid()) {
-		min := it.arun.Len
-		if it.brun.Len < min && it.brun.Valid() || !it.arun.Valid() {
-			min = it.brun.Len
-		}
-		it.next.Len += min
-		if it.arun.Valid() {
-			it.arun.Len -= min
-		}
-		if it.brun.Valid() {
-			it.brun.Len -= min
-		}
-		if err := fetch(); err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-func (it *addIt) HasNext() bool {
-	return it.next.Valid()
-}
-
-func (it *addIt) NextRun() (Run, error) {
-	next := it.next
-	return next, it.prep()
-}
-
-func Count(ri RunIterator) (uint64, error) {
-	var count uint64
-
-	for ri.HasNext() {
-		r, err := ri.NextRun()
-		if err != nil {
-			return 0, err
-		}
-		if r.Val {
-			if math.MaxUint64-r.Len < count {
-				return 0, xerrors.New("RLE+ overflows")
-			}
-			count += r.Len
-		}
-	}
-	return count, nil
-}
diff --git a/lib/rlepluslazy/runs_test.go b/lib/rlepluslazy/runs_test.go
deleted file mode 100644
index aefeb2c70..000000000
--- a/lib/rlepluslazy/runs_test.go
+++ /dev/null
@@ -1,94 +0,0 @@
-package rlepluslazy
-
-import (
-	"math/rand"
-	"sort"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestSumRuns(t *testing.T) {
-	{
-		a, err := RunsFromSlice([]uint64{0, 1, 2, 3, 4, 5, 6, 7, 8, 11, 12, 13, 14})
-		assert.NoError(t, err)
-		b, err := RunsFromSlice([]uint64{0, 1, 2, 3, 9, 10, 16, 17, 18, 50, 51, 70})
-		assert.NoError(t, err)
-
-		s, err := Sum(a, b)
-		assert.NoError(t, err)
-		bis, err := SliceFromRuns(s)
-		assert.Equal(t, []uint64{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 16, 17, 18, 50, 51, 70}, bis)
-		assert.NoError(t, err)
-	}
-
-	{
-		a, err := RunsFromSlice([]uint64{0, 1, 2, 3, 4, 5, 6, 7, 8, 11, 12, 13, 14})
-		assert.NoError(t, err)
-		b, err := RunsFromSlice([]uint64{0, 1, 2, 3, 9, 10, 16, 17, 18, 50, 51, 70})
-		assert.NoError(t, err)
-
-		s, err := Sum(b, a)
-		assert.NoError(t, err)
-		bis, err := SliceFromRuns(s)
-		assert.Equal(t, []uint64{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 16, 17, 18, 50, 51, 70}, bis)
-		assert.NoError(t, err)
-	}
-}
-
-func randomBits(N int, max uint64) []uint64 {
-	all := make(map[uint64]struct{})
-	for len(all) <= N {
-		x := rand.Uint64() % max
-		if _, has := all[x]; has {
-			continue
-		}
-		all[x] = struct{}{}
-	}
-
-	res := make([]uint64, 0, N)
-	for x := range all {
-		res = append(res, x)
-	}
-	sort.Slice(res, func(i, j int) bool { return res[i] < res[j] })
-
-	return res
-}
-
-func sum(a, b []uint64) []uint64 {
-	all := make(map[uint64]struct{})
-	for _, x := range a {
-		all[x] = struct{}{}
-	}
-	for _, x := range b {
-		all[x] = struct{}{}
-	}
-	res := make([]uint64, 0, len(all))
-	for x := range all {
-		res = append(res, x)
-	}
-	sort.Slice(res, func(i, j int) bool { return res[i] < res[j] })
-
-	return res
-}
-
-func TestSumRandom(t *testing.T) {
-	N := 100
-
-	for i := 0; i < N; i++ {
-		abits := randomBits(1000, 1500)
-		bbits := randomBits(1000, 1500)
-		sumbits := sum(abits, bbits)
-
-		a, err := RunsFromSlice(abits)
-		assert.NoError(t, err)
-		b, err := RunsFromSlice(bbits)
-		assert.NoError(t, err)
-
-		s, err := Sum(b, a)
-		assert.NoError(t, err)
-		bis, err := SliceFromRuns(s)
-		assert.NoError(t, err)
-		assert.Equal(t, sumbits, bis)
-	}
-}
diff --git a/lib/rpcenc/reader.go b/lib/rpcenc/reader.go
new file mode 100644
index 000000000..617c6495e
--- /dev/null
+++ b/lib/rpcenc/reader.go
@@ -0,0 +1,191 @@
+package rpcenc
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"net/http"
+	"net/url"
+	"path"
+	"reflect"
+	"strconv"
+	"sync"
+	"time"
+
+	"github.com/google/uuid"
+	logging "github.com/ipfs/go-log/v2"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-jsonrpc"
+	"github.com/filecoin-project/go-state-types/abi"
+	sealing "github.com/filecoin-project/lotus/extern/storage-sealing"
+)
+
+var log = logging.Logger("rpcenc")
+
+var Timeout = 30 * time.Second
+
+type StreamType string
+
+const (
+	Null       StreamType = "null"
+	PushStream StreamType = "push"
+	// TODO: Data transfer handoff to workers?
+)
+
+type ReaderStream struct {
+	Type StreamType
+	Info string
+}
+
+func ReaderParamEncoder(addr string) jsonrpc.Option {
+	return jsonrpc.WithParamEncoder(new(io.Reader), func(value reflect.Value) (reflect.Value, error) {
+		r := value.Interface().(io.Reader)
+
+		if r, ok := r.(*sealing.NullReader); ok {
+			return reflect.ValueOf(ReaderStream{Type: Null, Info: fmt.Sprint(r.N)}), nil
+		}
+
+		reqID := uuid.New()
+		u, err := url.Parse(addr)
+		if err != nil {
+			return reflect.Value{}, xerrors.Errorf("parsing push address: %w", err)
+		}
+		u.Path = path.Join(u.Path, reqID.String())
+
+		go func() {
+			// TODO: figure out errors here
+
+			resp, err := http.Post(u.String(), "application/octet-stream", r)
+			if err != nil {
+				log.Errorf("sending reader param: %+v", err)
+				return
+			}
+
+			defer resp.Body.Close() //nolint:errcheck
+
+			if resp.StatusCode != 200 {
+				b, _ := ioutil.ReadAll(resp.Body)
+				log.Errorf("sending reader param (%s): non-200 status: %s, msg: '%s'", u.String(), resp.Status, string(b))
+				return
+			}
+
+		}()
+
+		return reflect.ValueOf(ReaderStream{Type: PushStream, Info: reqID.String()}), nil
+	})
+}
+
+type waitReadCloser struct {
+	io.ReadCloser
+	wait chan struct{}
+}
+
+func (w *waitReadCloser) Read(p []byte) (int, error) {
+	n, err := w.ReadCloser.Read(p)
+	if err != nil {
+		close(w.wait)
+	}
+	return n, err
+}
+
+func (w *waitReadCloser) Close() error {
+	close(w.wait)
+	return w.ReadCloser.Close()
+}
+
+func ReaderParamDecoder() (http.HandlerFunc, jsonrpc.ServerOption) {
+	var readersLk sync.Mutex
+	readers := map[uuid.UUID]chan *waitReadCloser{}
+
+	hnd := func(resp http.ResponseWriter, req *http.Request) {
+		strId := path.Base(req.URL.Path)
+		u, err := uuid.Parse(strId)
+		if err != nil {
+			http.Error(resp, fmt.Sprintf("parsing reader uuid: %s", err), 400)
+			return
+		}
+
+		readersLk.Lock()
+		ch, found := readers[u]
+		if !found {
+			ch = make(chan *waitReadCloser)
+			readers[u] = ch
+		}
+		readersLk.Unlock()
+
+		wr := &waitReadCloser{
+			ReadCloser: req.Body,
+			wait:       make(chan struct{}),
+		}
+
+		tctx, cancel := context.WithTimeout(req.Context(), Timeout)
+		defer cancel()
+
+		select {
+		case ch <- wr:
+		case <-tctx.Done():
+			close(ch)
+			log.Error("context error in reader stream handler (1): %v", tctx.Err())
+			resp.WriteHeader(500)
+			return
+		}
+
+		select {
+		case <-wr.wait:
+		case <-req.Context().Done():
+			log.Error("context error in reader stream handler (2): %v", req.Context().Err())
+			resp.WriteHeader(500)
+			return
+		}
+
+		resp.WriteHeader(200)
+	}
+
+	dec := jsonrpc.WithParamDecoder(new(io.Reader), func(ctx context.Context, b []byte) (reflect.Value, error) {
+		var rs ReaderStream
+		if err := json.Unmarshal(b, &rs); err != nil {
+			return reflect.Value{}, xerrors.Errorf("unmarshaling reader id: %w", err)
+		}
+
+		if rs.Type == Null {
+			n, err := strconv.ParseInt(rs.Info, 10, 64)
+			if err != nil {
+				return reflect.Value{}, xerrors.Errorf("parsing null byte count: %w", err)
+			}
+
+			return reflect.ValueOf(sealing.NewNullReader(abi.UnpaddedPieceSize(n))), nil
+		}
+
+		u, err := uuid.Parse(rs.Info)
+		if err != nil {
+			return reflect.Value{}, xerrors.Errorf("parsing reader UUDD: %w", err)
+		}
+
+		readersLk.Lock()
+		ch, found := readers[u]
+		if !found {
+			ch = make(chan *waitReadCloser)
+			readers[u] = ch
+		}
+		readersLk.Unlock()
+
+		ctx, cancel := context.WithTimeout(ctx, Timeout)
+		defer cancel()
+
+		select {
+		case wr, ok := <-ch:
+			if !ok {
+				return reflect.Value{}, xerrors.Errorf("handler timed out")
+			}
+
+			return reflect.ValueOf(wr), nil
+		case <-ctx.Done():
+			return reflect.Value{}, ctx.Err()
+		}
+	})
+
+	return hnd, dec
+}
diff --git a/lib/rpcenc/reader_test.go b/lib/rpcenc/reader_test.go
new file mode 100644
index 000000000..3aef2bb54
--- /dev/null
+++ b/lib/rpcenc/reader_test.go
@@ -0,0 +1,90 @@
+package rpcenc
+
+import (
+	"context"
+	"io"
+	"io/ioutil"
+	"net/http/httptest"
+	"strings"
+	"testing"
+
+	"github.com/gorilla/mux"
+	"github.com/stretchr/testify/require"
+
+	"github.com/filecoin-project/go-jsonrpc"
+	sealing "github.com/filecoin-project/lotus/extern/storage-sealing"
+)
+
+type ReaderHandler struct {
+}
+
+func (h *ReaderHandler) ReadAll(ctx context.Context, r io.Reader) ([]byte, error) {
+	return ioutil.ReadAll(r)
+}
+
+func (h *ReaderHandler) ReadNullLen(ctx context.Context, r io.Reader) (int64, error) {
+	return r.(*sealing.NullReader).N, nil
+}
+
+func (h *ReaderHandler) ReadUrl(ctx context.Context, u string) (string, error) {
+	return u, nil
+}
+
+func TestReaderProxy(t *testing.T) {
+	var client struct {
+		ReadAll func(ctx context.Context, r io.Reader) ([]byte, error)
+	}
+
+	serverHandler := &ReaderHandler{}
+
+	readerHandler, readerServerOpt := ReaderParamDecoder()
+	rpcServer := jsonrpc.NewServer(readerServerOpt)
+	rpcServer.Register("ReaderHandler", serverHandler)
+
+	mux := mux.NewRouter()
+	mux.Handle("/rpc/v0", rpcServer)
+	mux.Handle("/rpc/streams/v0/push/{uuid}", readerHandler)
+
+	testServ := httptest.NewServer(mux)
+	defer testServ.Close()
+
+	re := ReaderParamEncoder("http://" + testServ.Listener.Addr().String() + "/rpc/streams/v0/push")
+	closer, err := jsonrpc.NewMergeClient(context.Background(), "ws://"+testServ.Listener.Addr().String()+"/rpc/v0", "ReaderHandler", []interface{}{&client}, nil, re)
+	require.NoError(t, err)
+
+	defer closer()
+
+	read, err := client.ReadAll(context.TODO(), strings.NewReader("pooooootato"))
+	require.NoError(t, err)
+	require.Equal(t, "pooooootato", string(read), "potatoes weren't equal")
+}
+
+func TestNullReaderProxy(t *testing.T) {
+	var client struct {
+		ReadAll     func(ctx context.Context, r io.Reader) ([]byte, error)
+		ReadNullLen func(ctx context.Context, r io.Reader) (int64, error)
+	}
+
+	serverHandler := &ReaderHandler{}
+
+	readerHandler, readerServerOpt := ReaderParamDecoder()
+	rpcServer := jsonrpc.NewServer(readerServerOpt)
+	rpcServer.Register("ReaderHandler", serverHandler)
+
+	mux := mux.NewRouter()
+	mux.Handle("/rpc/v0", rpcServer)
+	mux.Handle("/rpc/streams/v0/push/{uuid}", readerHandler)
+
+	testServ := httptest.NewServer(mux)
+	defer testServ.Close()
+
+	re := ReaderParamEncoder("http://" + testServ.Listener.Addr().String() + "/rpc/streams/v0/push")
+	closer, err := jsonrpc.NewMergeClient(context.Background(), "ws://"+testServ.Listener.Addr().String()+"/rpc/v0", "ReaderHandler", []interface{}{&client}, nil, re)
+	require.NoError(t, err)
+
+	defer closer()
+
+	n, err := client.ReadNullLen(context.TODO(), sealing.NewNullReader(1016))
+	require.NoError(t, err)
+	require.Equal(t, int64(1016), n)
+}
diff --git a/lib/sigs/bls/bls_bench_test.go b/lib/sigs/bls/bls_bench_test.go
new file mode 100644
index 000000000..118d25975
--- /dev/null
+++ b/lib/sigs/bls/bls_bench_test.go
@@ -0,0 +1,39 @@
+package bls
+
+import (
+	"crypto/rand"
+	"testing"
+
+	"github.com/filecoin-project/go-address"
+)
+
+func BenchmarkBLSSign(b *testing.B) {
+	signer := blsSigner{}
+	for i := 0; i < b.N; i++ {
+		b.StopTimer()
+		pk, _ := signer.GenPrivate()
+		randMsg := make([]byte, 32)
+		_, _ = rand.Read(randMsg)
+		b.StartTimer()
+
+		_, _ = signer.Sign(pk, randMsg)
+	}
+}
+
+func BenchmarkBLSVerify(b *testing.B) {
+	signer := blsSigner{}
+	for i := 0; i < b.N; i++ {
+		b.StopTimer()
+		randMsg := make([]byte, 32)
+		_, _ = rand.Read(randMsg)
+
+		priv, _ := signer.GenPrivate()
+		pk, _ := signer.ToPublic(priv)
+		addr, _ := address.NewBLSAddress(pk)
+		sig, _ := signer.Sign(priv, randMsg)
+
+		b.StartTimer()
+
+		_ = signer.Verify(sig, addr, randMsg)
+	}
+}
diff --git a/lib/sigs/bls/init.go b/lib/sigs/bls/init.go
new file mode 100644
index 000000000..42633eee8
--- /dev/null
+++ b/lib/sigs/bls/init.go
@@ -0,0 +1,61 @@
+package bls
+
+import (
+	"crypto/rand"
+	"fmt"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/crypto"
+
+	blst "github.com/supranational/blst/bindings/go"
+
+	"github.com/filecoin-project/lotus/lib/sigs"
+)
+
+const DST = string("BLS_SIG_BLS12381G2_XMD:SHA-256_SSWU_RO_NUL_")
+
+type SecretKey = blst.SecretKey
+type PublicKey = blst.P1Affine
+type Signature = blst.P2Affine
+type AggregateSignature = blst.P2Aggregate
+
+type blsSigner struct{}
+
+func (blsSigner) GenPrivate() ([]byte, error) {
+	// Generate 32 bytes of randomness
+	var ikm [32]byte
+	_, err := rand.Read(ikm[:])
+	if err != nil {
+		return nil, fmt.Errorf("bls signature error generating random data")
+	}
+	// Note private keys seem to be serialized little-endian!
+	pk := blst.KeyGen(ikm[:]).ToLEndian()
+	return pk, nil
+}
+
+func (blsSigner) ToPublic(priv []byte) ([]byte, error) {
+	pk := new(SecretKey).FromLEndian(priv)
+	if pk == nil || !pk.Valid() {
+		return nil, fmt.Errorf("bls signature invalid private key")
+	}
+	return new(PublicKey).From(pk).Compress(), nil
+}
+
+func (blsSigner) Sign(p []byte, msg []byte) ([]byte, error) {
+	pk := new(SecretKey).FromLEndian(p)
+	if pk == nil || !pk.Valid() {
+		return nil, fmt.Errorf("bls signature invalid private key")
+	}
+	return new(Signature).Sign(pk, msg, []byte(DST)).Compress(), nil
+}
+
+func (blsSigner) Verify(sig []byte, a address.Address, msg []byte) error {
+	if !new(Signature).VerifyCompressed(sig, a.Payload()[:], msg, []byte(DST)) {
+		return fmt.Errorf("bls signature failed to verify")
+	}
+	return nil
+}
+
+func init() {
+	sigs.RegisterSignature(crypto.SigTypeBLS, blsSigner{})
+}
diff --git a/lib/sigs/doc.go b/lib/sigs/doc.go
new file mode 100644
index 000000000..ca3093f39
--- /dev/null
+++ b/lib/sigs/doc.go
@@ -0,0 +1,9 @@
+// Package sigs allows for signing, verifying signatures and key generation
+// using key types selected by package user.
+//
+// For support of secp256k1 import:
+// _ "github.com/filecoin-project/lotus/lib/sigs/secp"
+//
+// For  support of Filecoin BLS import:
+// _ "github.com/filecoin-project/lotus/lib/sigs/bls"
+package sigs
diff --git a/lib/sigs/secp/init.go b/lib/sigs/secp/init.go
new file mode 100644
index 000000000..674bbbb28
--- /dev/null
+++ b/lib/sigs/secp/init.go
@@ -0,0 +1,59 @@
+package secp
+
+import (
+	"fmt"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-crypto"
+	crypto2 "github.com/filecoin-project/go-state-types/crypto"
+	"github.com/minio/blake2b-simd"
+
+	"github.com/filecoin-project/lotus/lib/sigs"
+)
+
+type secpSigner struct{}
+
+func (secpSigner) GenPrivate() ([]byte, error) {
+	priv, err := crypto.GenerateKey()
+	if err != nil {
+		return nil, err
+	}
+	return priv, nil
+}
+
+func (secpSigner) ToPublic(pk []byte) ([]byte, error) {
+	return crypto.PublicKey(pk), nil
+}
+
+func (secpSigner) Sign(pk []byte, msg []byte) ([]byte, error) {
+	b2sum := blake2b.Sum256(msg)
+	sig, err := crypto.Sign(pk, b2sum[:])
+	if err != nil {
+		return nil, err
+	}
+
+	return sig, nil
+}
+
+func (secpSigner) Verify(sig []byte, a address.Address, msg []byte) error {
+	b2sum := blake2b.Sum256(msg)
+	pubk, err := crypto.EcRecover(b2sum[:], sig)
+	if err != nil {
+		return err
+	}
+
+	maybeaddr, err := address.NewSecp256k1Address(pubk)
+	if err != nil {
+		return err
+	}
+
+	if a != maybeaddr {
+		return fmt.Errorf("signature did not match")
+	}
+
+	return nil
+}
+
+func init() {
+	sigs.RegisterSignature(crypto2.SigTypeSecp256k1, secpSigner{})
+}
diff --git a/lib/sigs/sigs.go b/lib/sigs/sigs.go
new file mode 100644
index 000000000..1f56846a8
--- /dev/null
+++ b/lib/sigs/sigs.go
@@ -0,0 +1,112 @@
+package sigs
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/crypto"
+	"go.opencensus.io/trace"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/lotus/chain/types"
+)
+
+// Sign takes in signature type, private key and message. Returns a signature for that message.
+// Valid sigTypes are: "secp256k1" and "bls"
+func Sign(sigType crypto.SigType, privkey []byte, msg []byte) (*crypto.Signature, error) {
+	sv, ok := sigs[sigType]
+	if !ok {
+		return nil, fmt.Errorf("cannot sign message with signature of unsupported type: %v", sigType)
+	}
+
+	sb, err := sv.Sign(privkey, msg)
+	if err != nil {
+		return nil, err
+	}
+	return &crypto.Signature{
+		Type: sigType,
+		Data: sb,
+	}, nil
+}
+
+// Verify verifies signatures
+func Verify(sig *crypto.Signature, addr address.Address, msg []byte) error {
+	if sig == nil {
+		return xerrors.Errorf("signature is nil")
+	}
+
+	if addr.Protocol() == address.ID {
+		return fmt.Errorf("must resolve ID addresses before using them to verify a signature")
+	}
+
+	sv, ok := sigs[sig.Type]
+	if !ok {
+		return fmt.Errorf("cannot verify signature of unsupported type: %v", sig.Type)
+	}
+
+	return sv.Verify(sig.Data, addr, msg)
+}
+
+// Generate generates private key of given type
+func Generate(sigType crypto.SigType) ([]byte, error) {
+	sv, ok := sigs[sigType]
+	if !ok {
+		return nil, fmt.Errorf("cannot generate private key of unsupported type: %v", sigType)
+	}
+
+	return sv.GenPrivate()
+}
+
+// ToPublic converts private key to public key
+func ToPublic(sigType crypto.SigType, pk []byte) ([]byte, error) {
+	sv, ok := sigs[sigType]
+	if !ok {
+		return nil, fmt.Errorf("cannot generate public key of unsupported type: %v", sigType)
+	}
+
+	return sv.ToPublic(pk)
+}
+
+func CheckBlockSignature(ctx context.Context, blk *types.BlockHeader, worker address.Address) error {
+	_, span := trace.StartSpan(ctx, "checkBlockSignature")
+	defer span.End()
+
+	if blk.IsValidated() {
+		return nil
+	}
+
+	if blk.BlockSig == nil {
+		return xerrors.New("block signature not present")
+	}
+
+	sigb, err := blk.SigningBytes()
+	if err != nil {
+		return xerrors.Errorf("failed to get block signing bytes: %w", err)
+	}
+
+	err = Verify(blk.BlockSig, worker, sigb)
+	if err == nil {
+		blk.SetValidated()
+	}
+
+	return err
+}
+
+// SigShim is used for introducing signature functions
+type SigShim interface {
+	GenPrivate() ([]byte, error)
+	ToPublic(pk []byte) ([]byte, error)
+	Sign(pk []byte, msg []byte) ([]byte, error)
+	Verify(sig []byte, a address.Address, msg []byte) error
+}
+
+var sigs map[crypto.SigType]SigShim
+
+// RegisterSignature should be only used during init
+func RegisterSignature(typ crypto.SigType, vs SigShim) {
+	if sigs == nil {
+		sigs = make(map[crypto.SigType]SigShim)
+	}
+	sigs[typ] = vs
+}
diff --git a/lib/tablewriter/tablewiter_test.go b/lib/tablewriter/tablewiter_test.go
new file mode 100644
index 000000000..9c5f9d37d
--- /dev/null
+++ b/lib/tablewriter/tablewiter_test.go
@@ -0,0 +1,34 @@
+package tablewriter
+
+import (
+	"os"
+	"testing"
+
+	"github.com/fatih/color"
+)
+
+func TestTableWriter(t *testing.T) {
+	tw := New(Col("C1"), Col("X"), Col("C333"), NewLineCol("Thing"))
+	tw.Write(map[string]interface{}{
+		"C1":   "234",
+		"C333": "ou",
+	})
+	tw.Write(map[string]interface{}{
+		"C1":    "23uieui4",
+		"C333":  "ou",
+		"X":     color.GreenString("#"),
+		"Thing": "a very long thing, annoyingly so",
+	})
+	tw.Write(map[string]interface{}{
+		"C1":   "ttttttttt",
+		"C333": "eui",
+	})
+	tw.Write(map[string]interface{}{
+		"C1":             "1",
+		"C333":           "2",
+		"SurpriseColumn": "42",
+	})
+	if err := tw.Flush(os.Stdout); err != nil {
+		t.Fatal(err)
+	}
+}
diff --git a/lib/tablewriter/tablewriter.go b/lib/tablewriter/tablewriter.go
new file mode 100644
index 000000000..d77611390
--- /dev/null
+++ b/lib/tablewriter/tablewriter.go
@@ -0,0 +1,129 @@
+package tablewriter
+
+import (
+	"fmt"
+	"io"
+	"strings"
+	"unicode/utf8"
+
+	"github.com/acarl005/stripansi"
+)
+
+type Column struct {
+	Name         string
+	SeparateLine bool
+}
+
+type TableWriter struct {
+	cols []Column
+	rows []map[int]string
+}
+
+func Col(name string) Column {
+	return Column{
+		Name:         name,
+		SeparateLine: false,
+	}
+}
+
+func NewLineCol(name string) Column {
+	return Column{
+		Name:         name,
+		SeparateLine: true,
+	}
+}
+
+// Unlike text/tabwriter, this works with CLI escape codes, and allows for info
+//  in separate lines
+func New(cols ...Column) *TableWriter {
+	return &TableWriter{
+		cols: cols,
+	}
+}
+
+func (w *TableWriter) Write(r map[string]interface{}) {
+	// this can cause columns to be out of order, but will at least work
+	byColID := map[int]string{}
+
+cloop:
+	for col, val := range r {
+		for i, column := range w.cols {
+			if column.Name == col {
+				byColID[i] = fmt.Sprint(val)
+				continue cloop
+			}
+		}
+
+		byColID[len(w.cols)] = fmt.Sprint(val)
+		w.cols = append(w.cols, Column{
+			Name:         col,
+			SeparateLine: false,
+		})
+	}
+
+	w.rows = append(w.rows, byColID)
+}
+
+func (w *TableWriter) Flush(out io.Writer) error {
+	colLengths := make([]int, len(w.cols))
+
+	header := map[int]string{}
+	for i, col := range w.cols {
+		if col.SeparateLine {
+			continue
+		}
+		header[i] = col.Name
+	}
+
+	w.rows = append([]map[int]string{header}, w.rows...)
+
+	for col := range w.cols {
+		for _, row := range w.rows {
+			val, found := row[col]
+			if !found {
+				continue
+			}
+
+			if cliStringLength(val) > colLengths[col] {
+				colLengths[col] = cliStringLength(val)
+			}
+		}
+	}
+
+	for _, row := range w.rows {
+		cols := make([]string, len(w.cols))
+
+		for ci, col := range w.cols {
+			e, _ := row[ci]
+			pad := colLengths[ci] - cliStringLength(e) + 2
+			if !col.SeparateLine {
+				e = e + strings.Repeat(" ", pad)
+				if _, err := fmt.Fprint(out, e); err != nil {
+					return err
+				}
+			}
+
+			cols[ci] = e
+		}
+
+		if _, err := fmt.Fprintln(out); err != nil {
+			return err
+		}
+
+		for ci, col := range w.cols {
+			if !col.SeparateLine || len(cols[ci]) == 0 {
+				continue
+			}
+
+			if _, err := fmt.Fprintf(out, "  %s: %s\n", col.Name, cols[ci]); err != nil {
+				return err
+			}
+		}
+	}
+
+	return nil
+}
+
+func cliStringLength(s string) (n int) {
+	return utf8.RuneCountInString(stripansi.Strip(s))
+}
diff --git a/tracing/setup.go b/lib/tracing/setup.go
similarity index 94%
rename from tracing/setup.go
rename to lib/tracing/setup.go
index ee8e4c8dd..141683b39 100644
--- a/tracing/setup.go
+++ b/lib/tracing/setup.go
@@ -4,7 +4,7 @@ import (
 	"os"
 
 	"contrib.go.opencensus.io/exporter/jaeger"
-	logging "github.com/ipfs/go-log"
+	logging "github.com/ipfs/go-log/v2"
 	"go.opencensus.io/trace"
 )
 
diff --git a/lib/ulimit/ulimit.go b/lib/ulimit/ulimit.go
new file mode 100644
index 000000000..f9999cf68
--- /dev/null
+++ b/lib/ulimit/ulimit.go
@@ -0,0 +1,121 @@
+package ulimit
+
+// from go-ipfs
+
+import (
+	"fmt"
+	"os"
+	"strconv"
+	"syscall"
+
+	logging "github.com/ipfs/go-log"
+)
+
+var log = logging.Logger("ulimit")
+
+var (
+	supportsFDManagement = false
+
+	// getlimit returns the soft and hard limits of file descriptors counts
+	getLimit func() (uint64, uint64, error)
+	// set limit sets the soft and hard limits of file descriptors counts
+	setLimit func(uint64, uint64) error
+)
+
+// minimum file descriptor limit before we complain
+const minFds = 2048
+
+// default max file descriptor limit.
+const maxFds = 16 << 10
+
+// userMaxFDs returns the value of LOTUS_FD_MAX
+func userMaxFDs() uint64 {
+	// check if the LOTUS_FD_MAX is set up and if it does
+	// not have a valid fds number notify the user
+	val := os.Getenv("LOTUS_FD_MAX")
+	if val == "" {
+		val = os.Getenv("IPFS_FD_MAX")
+	}
+
+	if val != "" {
+		fds, err := strconv.ParseUint(val, 10, 64)
+		if err != nil {
+			log.Errorf("bad value for LOTUS_FD_MAX: %s", err)
+			return 0
+		}
+		return fds
+	}
+	return 0
+}
+
+// ManageFdLimit raise the current max file descriptor count
+// of the process based on the LOTUS_FD_MAX value
+func ManageFdLimit() (changed bool, newLimit uint64, err error) {
+	if !supportsFDManagement {
+		return false, 0, nil
+	}
+
+	targetLimit := uint64(maxFds)
+	userLimit := userMaxFDs()
+	if userLimit > 0 {
+		targetLimit = userLimit
+	}
+
+	soft, hard, err := getLimit()
+	if err != nil {
+		return false, 0, err
+	}
+
+	if targetLimit <= soft {
+		return false, 0, nil
+	}
+
+	// the soft limit is the value that the kernel enforces for the
+	// corresponding resource
+	// the hard limit acts as a ceiling for the soft limit
+	// an unprivileged process may only set it's soft limit to a
+	// alue in the range from 0 up to the hard limit
+	err = setLimit(targetLimit, targetLimit)
+	switch err {
+	case nil:
+		newLimit = targetLimit
+	case syscall.EPERM:
+		// lower limit if necessary.
+		if targetLimit > hard {
+			targetLimit = hard
+		}
+
+		// the process does not have permission so we should only
+		// set the soft value
+		err = setLimit(targetLimit, hard)
+		if err != nil {
+			err = fmt.Errorf("error setting ulimit wihout hard limit: %s", err)
+			break
+		}
+		newLimit = targetLimit
+
+		// Warn on lowered limit.
+
+		if newLimit < userLimit {
+			err = fmt.Errorf(
+				"failed to raise ulimit to LOTUS_FD_MAX (%d): set to %d",
+				userLimit,
+				newLimit,
+			)
+			break
+		}
+
+		if userLimit == 0 && newLimit < minFds {
+			err = fmt.Errorf(
+				"failed to raise ulimit to minimum %d: set to %d",
+				minFds,
+				newLimit,
+			)
+			break
+		}
+	default:
+		err = fmt.Errorf("error setting: ulimit: %s", err)
+	}
+
+	return newLimit > 0, newLimit, err
+}
diff --git a/lib/ulimit/ulimit_freebsd.go b/lib/ulimit/ulimit_freebsd.go
new file mode 100644
index 000000000..7e50436f3
--- /dev/null
+++ b/lib/ulimit/ulimit_freebsd.go
@@ -0,0 +1,36 @@
+// +build freebsd
+
+package ulimit
+
+import (
+	"errors"
+	"math"
+
+	unix "golang.org/x/sys/unix"
+)
+
+func init() {
+	supportsFDManagement = true
+	getLimit = freebsdGetLimit
+	setLimit = freebsdSetLimit
+}
+
+func freebsdGetLimit() (uint64, uint64, error) {
+	rlimit := unix.Rlimit{}
+	err := unix.Getrlimit(unix.RLIMIT_NOFILE, &rlimit)
+	if (rlimit.Cur < 0) || (rlimit.Max < 0) {
+		return 0, 0, errors.New("invalid rlimits")
+	}
+	return uint64(rlimit.Cur), uint64(rlimit.Max), err
+}
+
+func freebsdSetLimit(soft uint64, max uint64) error {
+	if (soft > math.MaxInt64) || (max > math.MaxInt64) {
+		return errors.New("invalid rlimits")
+	}
+	rlimit := unix.Rlimit{
+		Cur: int64(soft),
+		Max: int64(max),
+	}
+	return unix.Setrlimit(unix.RLIMIT_NOFILE, &rlimit)
+}
diff --git a/lib/ulimit/ulimit_test.go b/lib/ulimit/ulimit_test.go
new file mode 100644
index 000000000..c99b7fb57
--- /dev/null
+++ b/lib/ulimit/ulimit_test.go
@@ -0,0 +1,84 @@
+// +build !windows
+
+package ulimit
+
+import (
+	"fmt"
+	"os"
+	"strings"
+	"syscall"
+	"testing"
+)
+
+func TestManageFdLimit(t *testing.T) {
+	t.Log("Testing file descriptor count")
+	if _, _, err := ManageFdLimit(); err != nil {
+		t.Errorf("Cannot manage file descriptors")
+	}
+
+	if maxFds != uint64(16<<10) {
+		t.Errorf("Maximum file descriptors default value changed")
+	}
+}
+
+func TestManageInvalidNFds(t *testing.T) {
+	t.Logf("Testing file descriptor invalidity")
+	var err error
+	if err = os.Unsetenv("IPFS_FD_MAX"); err != nil {
+		t.Fatal("Cannot unset the IPFS_FD_MAX env variable")
+	}
+
+	rlimit := syscall.Rlimit{}
+	if err = syscall.Getrlimit(syscall.RLIMIT_NOFILE, &rlimit); err != nil {
+		t.Fatal("Cannot get the file descriptor count")
+	}
+
+	value := rlimit.Max + rlimit.Cur
+	if err = os.Setenv("IPFS_FD_MAX", fmt.Sprintf("%d", value)); err != nil {
+		t.Fatal("Cannot set the IPFS_FD_MAX env variable")
+	}
+
+	t.Logf("setting ulimit to %d, max %d, cur %d", value, rlimit.Max, rlimit.Cur)
+
+	if changed, new, err := ManageFdLimit(); err == nil {
+		t.Errorf("ManageFdLimit should return an error: changed %t, new: %d", changed, new)
+	} else if err != nil {
+		flag := strings.Contains(err.Error(),
+			"failed to raise ulimit to LOTUS_FD_MAX")
+		if !flag {
+			t.Error("ManageFdLimit returned unexpected error", err)
+		}
+	}
+
+	// unset all previous operations
+	if err = os.Unsetenv("IPFS_FD_MAX"); err != nil {
+		t.Fatal("Cannot unset the IPFS_FD_MAX env variable")
+	}
+}
+
+func TestManageFdLimitWithEnvSet(t *testing.T) {
+	t.Logf("Testing file descriptor manager with IPFS_FD_MAX set")
+	var err error
+	if err = os.Unsetenv("IPFS_FD_MAX"); err != nil {
+		t.Fatal("Cannot unset the IPFS_FD_MAX env variable")
+	}
+
+	rlimit := syscall.Rlimit{}
+	if err = syscall.Getrlimit(syscall.RLIMIT_NOFILE, &rlimit); err != nil {
+		t.Fatal("Cannot get the file descriptor count")
+	}
+
+	value := rlimit.Max - rlimit.Cur + 1
+	if err = os.Setenv("IPFS_FD_MAX", fmt.Sprintf("%d", value)); err != nil {
+		t.Fatal("Cannot set the IPFS_FD_MAX env variable")
+	}
+
+	if _, _, err = ManageFdLimit(); err != nil {
+		t.Errorf("Cannot manage file descriptor count")
+	}
+
+	// unset all previous operations
+	if err = os.Unsetenv("IPFS_FD_MAX"); err != nil {
+		t.Fatal("Cannot unset the IPFS_FD_MAX env variable")
+	}
+}
diff --git a/lib/ulimit/ulimit_unix.go b/lib/ulimit/ulimit_unix.go
new file mode 100644
index 000000000..a351236dc
--- /dev/null
+++ b/lib/ulimit/ulimit_unix.go
@@ -0,0 +1,27 @@
+// +build darwin linux netbsd openbsd
+
+package ulimit
+
+import (
+	unix "golang.org/x/sys/unix"
+)
+
+func init() {
+	supportsFDManagement = true
+	getLimit = unixGetLimit
+	setLimit = unixSetLimit
+}
+
+func unixGetLimit() (uint64, uint64, error) {
+	rlimit := unix.Rlimit{}
+	err := unix.Getrlimit(unix.RLIMIT_NOFILE, &rlimit)
+	return rlimit.Cur, rlimit.Max, err
+}
+
+func unixSetLimit(soft uint64, max uint64) error {
+	rlimit := unix.Rlimit{
+		Cur: soft,
+		Max: max,
+	}
+	return unix.Setrlimit(unix.RLIMIT_NOFILE, &rlimit)
+}
diff --git a/lotuspond/api.go b/lotuspond/api.go
index ef742b1a2..a02357919 100644
--- a/lotuspond/api.go
+++ b/lotuspond/api.go
@@ -1,6 +1,7 @@
 package main
 
 import (
+	"context"
 	"crypto/rand"
 	"io"
 	"io/ioutil"
@@ -9,14 +10,15 @@ import (
 
 	"golang.org/x/xerrors"
 
-	"github.com/filecoin-project/lotus/lib/jsonrpc"
+	"github.com/filecoin-project/go-jsonrpc"
+
 	"github.com/filecoin-project/lotus/node/repo"
 )
 
 type NodeState int
 
 const (
-	NodeUnknown = iota
+	NodeUnknown = iota //nolint:deadcode
 	NodeRunning
 	NodeStopped
 )
@@ -31,7 +33,7 @@ type api struct {
 type nodeInfo struct {
 	Repo    string
 	ID      int32
-	ApiPort int32
+	APIPort int32
 	State   NodeState
 
 	FullNode string // only for storage nodes
@@ -128,9 +130,9 @@ type client struct {
 	Nodes func() []nodeInfo
 }
 
-func apiClient() (*client, error) {
+func apiClient(ctx context.Context) (*client, error) {
 	c := &client{}
-	if _, err := jsonrpc.NewClient("ws://"+listenAddr+"/rpc/v0", "Pond", c, nil); err != nil {
+	if _, err := jsonrpc.NewClient(ctx, "ws://"+listenAddr+"/rpc/v0", "Pond", c, nil); err != nil {
 		return nil, err
 	}
 	return c, nil
diff --git a/lotuspond/front/src/Address.js b/lotuspond/front/src/Address.js
index 1ac98d7f2..b2987646e 100644
--- a/lotuspond/front/src/Address.js
+++ b/lotuspond/front/src/Address.js
@@ -3,7 +3,7 @@ import CID from 'cids'
 import ReactTooltip from 'react-tooltip'
 import * as multihash from "multihashes"
 import State from "./State"
-import methods from "./chain/methods"
+import methods from "./chain/methods.json"
 import Fil from "./Fil";
 
 function truncAddr(addr, len) {
@@ -50,11 +50,11 @@ class Address extends React.Component {
 
     try {
       balance = await this.props.client.call('Filecoin.WalletBalance', [this.props.addr])
-      actor = await this.props.client.call('Filecoin.StateGetActor', [this.props.addr, this.props.ts || null])
+      actor = await this.props.client.call('Filecoin.StateGetActor', [this.props.addr, (this.props.ts || {}).Cids])
 
-      actorInfo = await this.actorInfo(actor)
+      actorInfo = await this.actorInfo(actor, this.props.addr)
       if(this.props.miner) {
-        minerInfo = await this.props.client.call('Filecoin.StateMinerPower', [this.props.addr, this.props.ts || null])
+        minerInfo = await this.props.client.call('Filecoin.StateMinerPower', [this.props.addr, (this.props.ts || {}).Cids])
       }
       if(this.props.nonce) {
         nonce = await this.props.client.call('Filecoin.MpoolGetNonce', [this.props.addr])
@@ -70,7 +70,7 @@ class Address extends React.Component {
     this.props.mountWindow((onClose) => <State addr={this.props.addr} actor={this.state.actor} client={this.props.client} onClose={onClose} mountWindow={this.props.mountWindow}/>)
   }
 
-  async actorInfo(actor) {
+  async actorInfo(actor, addr) {
     const c = new CID(actor.Code['/'])
     const mh = multihash.decode(c.multihash) // TODO: check identity
 
@@ -82,7 +82,7 @@ class Address extends React.Component {
     let info = <span>({mh.digest.toString()}{method})</span>
     switch(mh.digest.toString()) {
       case 'paych':
-        const actstate = await this.props.client.call('Filecoin.StateReadState', [actor, this.props.ts || null])
+        const actstate = await this.props.client.call('Filecoin.StateReadState', [addr, (this.props.ts || {}).Cids])
         info = <span>({mh.digest.toString()}{method} to <Address nobalance={true} client={this.props.client} addr={actstate.State.To} mountWindow={this.props.mountWindow}/>)</span>
     }
 
@@ -97,10 +97,10 @@ class Address extends React.Component {
   render() {
     let add20k = <span/>
     if(this.props.addN) {
-      add20k = <span>&nbsp;<a href="#" onClick={() => this.props.addN(this.props.addr, 200000)}>[+200k]</a></span>
+      add20k = <span>&nbsp;<a href="#" onClick={() => this.props.addN(this.props.addr, 2e+18)}>[+2]</a></span>
       if (this.props.add10k) {
-        add20k = <span>{add20k}&nbsp;<a href="#" onClick={() => this.props.addN(this.props.addr, 2000000)}>[+2M]</a></span>
-        add20k = <span>{add20k}&nbsp;<a href="#" onClick={() => this.props.addN(this.props.addr, 20000000)}>[+20M]</a></span>
+        add20k = <span>{add20k}&nbsp;<a href="#" onClick={() => this.props.addN(this.props.addr, 20e+18)}>[+20]</a></span>
+        add20k = <span>{add20k}&nbsp;<a href="#" onClick={() => this.props.addN(this.props.addr, 200e+18)}>[+200]</a></span>
         add20k = <span>{add20k}&nbsp;<a href="#" onClick={() => this.addColl()}>[<abbr title="min collateral">+C</abbr>]</a></span>
       }
     }
@@ -138,7 +138,7 @@ class Address extends React.Component {
 
     let minerInfo = <span/>
     if(this.state.minerInfo) {
-      minerInfo = <span>&nbsp;Power: {this.state.minerInfo.MinerPower} ({this.state.minerInfo.MinerPower/this.state.minerInfo.TotalPower*100}%)</span>
+      minerInfo = <span>&nbsp;Power: {this.state.minerInfo.MinerPower.QualityAdjPower} ({this.state.minerInfo.MinerPower.QualityAdjPower/this.state.minerInfo.TotalPower.QualityAdjPower*100}%)</span>
     }
 
     return <span data-tip data-for={this.props.addr}>{addr}{balance}{actInfo}{nonce}{add20k}{transfer}{minerInfo}</span>
diff --git a/lotuspond/front/src/Block.js b/lotuspond/front/src/Block.js
index 44104d483..4bae57c81 100644
--- a/lotuspond/front/src/Block.js
+++ b/lotuspond/front/src/Block.js
@@ -70,6 +70,8 @@ class Block extends React.Component {
             <span>&nbsp;<Address client={this.props.conn} short={true} addr="t01" mountWindow={this.props.mountWindow}/></span>
             <span>&nbsp;<Address client={this.props.conn} short={true} addr="t02" mountWindow={this.props.mountWindow}/></span>
             <span>&nbsp;<Address client={this.props.conn} short={true} addr="t03" mountWindow={this.props.mountWindow}/></span>
+            <span>&nbsp;<Address client={this.props.conn} short={true} addr="t04" mountWindow={this.props.mountWindow}/></span>
+            <span>&nbsp;<Address client={this.props.conn} short={true} addr="t05" mountWindow={this.props.mountWindow}/></span>
             <span>&nbsp;<Address client={this.props.conn} short={true} addr="t099" mountWindow={this.props.mountWindow}/></span>
           </div>
           <div>----</div>
diff --git a/lotuspond/front/src/BlockLink.js b/lotuspond/front/src/BlockLink.js
index bfdbd5ea9..1d524999f 100644
--- a/lotuspond/front/src/BlockLink.js
+++ b/lotuspond/front/src/BlockLink.js
@@ -12,7 +12,7 @@ export class BlockLinks extends React.Component {
         block = this.props.blocks[k]
       }
 
-      return <span><BlockLink key={c + '-' + k} block={block} conn={this.props.conn} cid={c} mountWindow={this.props.mountWindow}/> </span>
+      return <span key={c + '-' + k}><BlockLink block={block} conn={this.props.conn} cid={c} mountWindow={this.props.mountWindow}/> </span>
     })
   }
 }
diff --git a/lotuspond/front/src/Client.js b/lotuspond/front/src/Client.js
index 70aabfd6f..244f07bd8 100644
--- a/lotuspond/front/src/Client.js
+++ b/lotuspond/front/src/Client.js
@@ -1,68 +1,97 @@
-import React from 'react';
-import Address from "./Address";
-import Window from "./Window";
-import Fil from "./Fil";
+import React from 'react'
+import Address from './Address'
+import Window from './Window'
+import Fil from './Fil'
 
 const dealStates = [
-  "Unknown",
-  "Rejected",
-  "Accepted",
-  "Staged",
-  "Sealing",
-  "Failed",
-  "Complete",
-  "Error",
-]
+  'Unknown',
+  'ProposalNotFound',
+  'ProposalRejected',
+  'ProposalAccepted',
+  'Staged',
+  'Sealing',
+  'ProposalSigned',
+  'Published',
+  'Committed',
+  'Active',
+  'Failing',
+  'Recovering',
+  'Expired',
+  'NotFound',
 
+  'Validating',
+  'Transferring',
+  'VerifyData',
+  'Publishing',
+  'Error'
+]
 
 class Client extends React.Component {
   constructor(props) {
     super(props)
 
     this.state = {
-      miners: ["t0101"],
-      ask: {Price: "1000000000"}, // 2x min default ask to account for bin packing (could also do the math correctly below, but..)
+      miners: ['t0101'],
+      ask: { Price: '1000000000' }, // 2x min default ask to account for bin packing (could also do the math correctly below, but..)
 
       kbs: 1,
       blocks: 12,
       total: 36000,
-      miner: "t0101",
+      miner: 't0101',
 
       deals: [],
 
-      blockDelay: 10,
+      blockDelay: 10
     }
   }
 
   async componentDidMount() {
     let ver = await this.props.client.call('Filecoin.Version', [])
-    this.setState({blockDelay: ver.BlockDelay})
+    this.setState({ blockDelay: ver.BlockDelay })
 
     this.getDeals()
     setInterval(this.getDeals, 1325)
   }
 
   getDeals = async () => {
-    let miners = await this.props.client.call('Filecoin.StateListMiners', [null])
+    let miners = await this.props.client.call('Filecoin.StateListMiners', [
+      null
+    ])
     let deals = await this.props.client.call('Filecoin.ClientListDeals', [])
     miners.sort()
-    this.setState({deals, miners})
+    this.setState({ deals, miners })
   }
 
-  update = (name) => (e) => this.setState({ [name]: e.target.value });
+  update = name => e => this.setState({ [name]: e.target.value })
 
   makeDeal = async () => {
-    let perBlk = this.state.ask.Price * this.state.kbs * 1000 / (1 << 30) * 2
+    let perBlk =
+      ((this.state.ask.Price * this.state.kbs * 1000) / (1 << 30)) * 2
 
-    let file = await this.props.pondClient.call('Pond.CreateRandomFile', [this.state.kbs * 1000]) // 1024 won't fit in 1k blocks :(
-    let cid = await this.props.client.call('Filecoin.ClientImport', [file])
-    let dealcid = await this.props.client.call('Filecoin.ClientStartDeal', [cid, this.state.miner, `${Math.round(perBlk)}`, Number(this.state.blocks)])
-    console.log("deal cid: ", dealcid)
+    let file = await this.props.pondClient.call('Pond.CreateRandomFile', [
+      this.state.kbs * 1000
+    ]) // 1024 won't fit in 1k blocks :(
+    let cid = await this.props.client.call('Filecoin.ClientImport', [
+      {
+        Path: file,
+        IsCar: false
+      }
+    ])
+    let dealcid = await this.props.client.call('Filecoin.ClientStartDeal', [
+      cid,
+      this.state.miner,
+      `${Math.round(perBlk)}`,
+      Number(this.state.blocks)
+    ])
+    console.log('deal cid: ', dealcid)
   }
 
-  retrieve = (deal) => async () => {
+  retrieve = deal => async () => {
     console.log(deal)
-    let client = await this.props.client.call('Filecoin.WalletDefaultAddress', [])
+    let client = await this.props.client.call(
+      'Filecoin.WalletDefaultAddress',
+      []
+    )
 
     let order = {
       Root: deal.PieceRef,
@@ -74,7 +103,13 @@ class Client extends React.Component {
       Miner: deal.Miner
     }
 
-    await this.props.client.call('Filecoin.ClientRetrieve', [order, '/dev/null'])
+    await this.props.client.call('Filecoin.ClientRetrieve', [
+      order,
+      {
+        Path: '/dev/null',
+        IsCAR: false
+      }
+    ])
   }
 
   render() {
@@ -82,41 +117,111 @@ class Client extends React.Component {
     let total = perBlk * this.state.blocks
     let days = (this.state.blocks * this.state.blockDelay) / 60 / 60 / 24
 
-    let dealMaker = <div hidden={!this.props.pondClient}>
-      <div>
-        <span>Make Deal: </span>
-        <select>{this.state.miners.map(m => <option key={m} value={m}>{m}</option>)}</select>
-        <span> Ask: <b><Fil>{this.state.ask.Price}</Fil></b> Fil/Byte/Block</span>
+    let dealMaker = (
+      <div hidden={!this.props.pondClient}>
+        <div>
+          <span>Make Deal: </span>
+          <select>
+            {this.state.miners.map(m => (
+              <option key={m} value={m}>
+                {m}
+              </option>
+            ))}
+          </select>
+          <span>
+            {' '}
+            Ask:{' '}
+            <b>
+              <Fil>{this.state.ask.Price}</Fil>
+            </b>{' '}
+            Fil/Byte/Block
+          </span>
+        </div>
+        <div>
+          Data Size:{' '}
+          <input
+            type="text"
+            placeholder="KBs"
+            defaultValue={1}
+            onChange={this.update('kbs')}
+            style={{ width: '5em' }}
+          />
+          KB; Duration:
+          <input
+            type="text"
+            placeholder="blocks"
+            defaultValue={12}
+            onChange={this.update('blocks')}
+            style={{ width: '5em' }}
+          />
+          Blocks
+        </div>
+        <div>
+          Total: <Fil>{total}</Fil>; {days} Days
+        </div>
+        <button onClick={this.makeDeal}>Deal!</button>
       </div>
-      <div>
-        Data Size: <input type="text" placeholder="KBs" defaultValue={1} onChange={this.update("kbs")} style={{width: "5em"}}/>KB;
-        Duration:<input type="text" placeholder="blocks" defaultValue={12} onChange={this.update("blocks")} style={{width: "5em"}}/>Blocks
-      </div>
-      <div>
-        Total: <Fil>{total}</Fil>; {days} Days
-      </div>
-      <button onClick={this.makeDeal}>Deal!</button>
-    </div>
+    )
 
-    let deals = this.state.deals.map((deal, i) => <div key={i}>
-      <ul>
-        <li>{i}. Proposal: {deal.ProposalCid['/'].substr(0, 18)}... <Address nobalance={true} client={this.props.client} addr={deal.Provider} mountWindow={this.props.mountWindow}/>: <b>{dealStates[deal.State]}</b>
-          {dealStates[deal.State] === 'Complete' ? <span>&nbsp;<a href="#" onClick={this.retrieve(deal)}>[Retrieve]</a></span> : <span/> }
-          <ul>
-            <li>Data: {deal.PieceRef['/']}, <b>{deal.Size}</b>B; Duration: <b>{deal.Duration}</b>Blocks</li>
-            <li>Total: <b>{deal.TotalPrice}</b>FIL; Per Block: <b>{Math.round(deal.TotalPrice / deal.Duration * 100) / 100}</b>FIL; PerMbyteByteBlock: <b>{Math.round(deal.TotalPrice / deal.Duration / (deal.Size / 1000000) * 100) / 100}</b>FIL</li>
-          </ul>
-        </li>
-      </ul>
-
-    </div>)
-
-    return <Window title={"Client - Node " + this.props.node.ID} onClose={this.props.onClose} initialSize={{width: 600, height: 400}}>
-      <div className="Client">
-        <div>{dealMaker}</div>
-        <div>{deals}</div>
+    let deals = this.state.deals.map((deal, i) => (
+      <div key={i}>
+        <ul>
+          <li>
+            {i}. Proposal: {deal.ProposalCid['/'].substr(0, 18)}...{' '}
+            <Address
+              nobalance={true}
+              client={this.props.client}
+              addr={deal.Provider}
+              mountWindow={this.props.mountWindow}
+            />
+            : <b>{dealStates[deal.State]}</b>
+            {dealStates[deal.State] === 'Complete' ? (
+              <span>
+                &nbsp;
+                <a href="#" onClick={this.retrieve(deal)}>
+                  [Retrieve]
+                </a>
+              </span>
+            ) : (
+              <span />
+            )}
+            <ul>
+              <li>
+                Data: {deal.PieceRef['/']}, <b>{deal.Size}</b>B; Duration:{' '}
+                <b>{deal.Duration}</b>Blocks
+              </li>
+              <li>
+                Total: <b>{deal.TotalPrice}</b>FIL; Per Block:{' '}
+                <b>
+                  {Math.round((deal.TotalPrice / deal.Duration) * 100) / 100}
+                </b>
+                FIL; PerMbyteByteBlock:{' '}
+                <b>
+                  {Math.round(
+                    (deal.TotalPrice / deal.Duration / (deal.Size / 1000000)) *
+                      100
+                  ) / 100}
+                </b>
+                FIL
+              </li>
+            </ul>
+          </li>
+        </ul>
       </div>
-    </Window>
+    ))
+
+    return (
+      <Window
+        title={'Client - Node ' + this.props.node.ID}
+        onClose={this.props.onClose}
+        initialSize={{ width: 600, height: 400 }}
+      >
+        <div className="Client">
+          <div>{dealMaker}</div>
+          <div>{deals}</div>
+        </div>
+      </Window>
+    )
   }
 }
 
diff --git a/lotuspond/front/src/FullNode.js b/lotuspond/front/src/FullNode.js
index eb530dee3..c67faba9f 100644
--- a/lotuspond/front/src/FullNode.js
+++ b/lotuspond/front/src/FullNode.js
@@ -45,7 +45,7 @@ class FullNode extends React.Component {
       return this.props.client.call('Filecoin.PaychVoucherList', [paych])
     }))
 
-    let mpoolPending = (await this.props.client.call('Filecoin.MpoolPending', [tipset])).length
+    let mpoolPending = (await this.props.client.call('Filecoin.MpoolPending', [tipset.Cids])).length
 
     this.setState(() => ({
       id: id,
@@ -64,13 +64,13 @@ class FullNode extends React.Component {
   }
 
   async newSecpAddr() {
-    const t = "secp256k1"
+    const t = 1
     await this.props.client.call("Filecoin.WalletNew", [t])
     this.loadInfo()
   }
 
   async newBLSAddr() {
-    const t = "bls"
+    const t = 2
     await this.props.client.call("Filecoin.WalletNew", [t])
     this.loadInfo()
   }
@@ -106,7 +106,7 @@ class FullNode extends React.Component {
         )
       }
 
-      let storageMine = <a href="#" onClick={this.startStorageMiner} hidden={!this.props.spawnStorageNode}>[Spawn Storage Miner]</a>
+      let storageMine = <a href="#" onClick={this.startStorageMiner} hidden={!this.props.spawnStorageNode}>[Spawn Miner]</a>
 
       let addresses = this.state.addrs.map((addr) => {
         let line = <Address client={this.props.client} addN={this.props.giveN} add10k={true} nonce={true} addr={addr} mountWindow={this.props.mountWindow}/>
diff --git a/lotuspond/front/src/NodeList.js b/lotuspond/front/src/NodeList.js
index 78203929b..a29d723c0 100644
--- a/lotuspond/front/src/NodeList.js
+++ b/lotuspond/front/src/NodeList.js
@@ -35,7 +35,7 @@ class NodeList extends React.Component {
   async mountNode(node) {
     const token = await this.props.client.call('Pond.TokenFor', [node.ID])
 
-    const client = new Client(`ws://127.0.0.1:${node.ApiPort}/rpc/v0?token=${token}`)
+    const client = new Client(`ws://127.0.0.1:${node.APIPort}/rpc/v0?token=${token}`)
     client.on('open', async () => {
       const id = await client.call("Filecoin.ID", [])
 
diff --git a/lotuspond/front/src/State.js b/lotuspond/front/src/State.js
index d5b81ff83..04175d231 100644
--- a/lotuspond/front/src/State.js
+++ b/lotuspond/front/src/State.js
@@ -22,7 +22,7 @@ class State extends React.Component {
 
   async componentDidMount() {
     const tipset = this.props.tipset || await this.props.client.call("Filecoin.ChainHead", [])
-    const actstate = await this.props.client.call('Filecoin.StateReadState', [this.props.actor, tipset])
+    const actstate = await this.props.client.call('Filecoin.StateReadState', [this.props.addr, tipset.Cids])
 
     const c = new CID(this.props.actor.Code['/'])
     const mh = multihash.decode(c.multihash)
@@ -37,7 +37,7 @@ class State extends React.Component {
       const Stelem = this.byCode[this.state.code]
       state = <Stelem addr={this.props.addr} actor={this.props.actor} client={this.props.client} mountWindow={this.props.mountWindow} tipset={this.props.tipset}/>
     } else {
-      state = <div>{Object.keys(this.state.State).map(k => <div key={k}>{k}: <span>{JSON.stringify(this.state.State[k])}</span></div>)}</div>
+      state = <div>{Object.keys(this.state.State || {}).map(k => <div key={k}>{k}: <span>{JSON.stringify(this.state.State[k])}</span></div>)}</div>
     }
 
     const content = <div className="State">
@@ -60,7 +60,7 @@ class InitState extends React.Component {
 
   async componentDidMount() {
     const tipset = await this.props.client.call("Filecoin.ChainHead", []) // TODO: from props
-    const actors = await this.props.client.call("Filecoin.StateListActors", [tipset])
+    const actors = await this.props.client.call("Filecoin.StateListActors", [tipset.Cids])
     this.setState({actors: actors})
   }
 
@@ -79,8 +79,8 @@ class PowerState extends React.Component {
 
   async componentDidMount() {
     const tipset = await this.props.client.call("Filecoin.ChainHead", []) // TODO: from props
-    const actors = await this.props.client.call("Filecoin.StateListMiners", [tipset])
-    const state = await this.props.client.call('Filecoin.StateReadState', [this.props.actor, tipset])
+    const actors = await this.props.client.call("Filecoin.StateListMiners", [tipset.Cids])
+    const state = await this.props.client.call('Filecoin.StateReadState', [this.props.addr, tipset.Cids])
 
     this.setState({actors, state})
   }
@@ -105,9 +105,9 @@ class MarketState extends React.Component {
 
   async componentDidMount() {
     const tipset = await this.props.client.call("Filecoin.ChainHead", []) // TODO: from props
-    const participants = await this.props.client.call("Filecoin.StateMarketParticipants", [tipset])
-    const deals = await this.props.client.call("Filecoin.StateMarketDeals", [tipset])
-    const state = await this.props.client.call('Filecoin.StateReadState', [this.props.actor, tipset])
+    const participants = await this.props.client.call("Filecoin.StateMarketParticipants", [tipset.Cids])
+    const deals = await this.props.client.call("Filecoin.StateMarketDeals", [tipset.Cids])
+    const state = await this.props.client.call('Filecoin.StateReadState', [this.props.addr, tipset.Cids])
     this.setState({participants, deals, nextDeal: state.State.NextDealID})
   }
 
@@ -128,15 +128,15 @@ class MarketState extends React.Component {
         <div>---</div>
         <div>Deals ({this.state.nextDeal} Total):</div>
         <table>
-          <tr><td>id</td><td>Active</td><td>Client</td><td>Provider</td><td>Size</td><td>Price</td><td>Duration</td></tr>
+          <tr><td>id</td><td>Started</td><td>Client</td><td>Provider</td><td>Size</td><td>Price</td><td>Duration</td></tr>
           {Object.keys(this.state.deals).map(d => <tr>
             <td>{d}</td>
-            <td>{this.state.deals[d].ActivationEpoch || "No"}</td>
-            <td><Address short={true} addr={this.state.deals[d].Deal.Proposal.Client} client={this.props.client} mountWindow={this.props.mountWindow}/></td>
-            <td><Address short={true} addr={this.state.deals[d].Deal.Proposal.Provider} client={this.props.client} mountWindow={this.props.mountWindow}/></td>
-            <td>{this.state.deals[d].Deal.Proposal.PieceSize}B</td>
-            <td>{this.state.deals[d].Deal.Proposal.StoragePricePerEpoch*this.state.deals[d].Deal.Proposal.Duration}</td>
-            <td>{this.state.deals[d].Deal.Proposal.Duration}</td>
+            <td>{this.state.deals[d].State.SectorStartEpoch || "No"}</td>
+            <td><Address short={true} addr={this.state.deals[d].Proposal.Client} client={this.props.client} mountWindow={this.props.mountWindow}/></td>
+            <td><Address short={true} addr={this.state.deals[d].Proposal.Provider} client={this.props.client} mountWindow={this.props.mountWindow}/></td>
+            <td>{this.state.deals[d].Proposal.PieceSize}B</td>
+            <td>{this.state.deals[d].Proposal.StoragePricePerEpoch*(this.state.deals[d].Proposal.EndEpoch-this.state.deals[d].Proposal.StartEpoch)}</td>
+            <td>{this.state.deals[d].Proposal.EndEpoch-this.state.deals[d].Proposal.StartEpoch}</td>
           </tr>)}
         </table>
       </div>
@@ -153,17 +153,17 @@ class MinerState extends React.Component {
   async componentDidMount() {
     const tipset = await this.props.client.call("Filecoin.ChainHead", []) // TODO: from props
 
-    const state = await this.props.client.call('Filecoin.StateReadState', [this.props.actor, tipset])
-    const sectorSize = await this.props.client.call("Filecoin.StateMinerSectorSize", [this.props.addr, tipset])
-    const worker = await this.props.client.call("Filecoin.StateMinerWorker", [this.props.addr, tipset])
+    const state = await this.props.client.call('Filecoin.StateReadState', [this.props.addr, tipset.Cids])
+    const sectorSize = await this.props.client.call("Filecoin.StateMinerSectorSize", [this.props.addr, tipset.Cids])
+    const worker = await this.props.client.call("Filecoin.StateMinerWorker", [this.props.addr, tipset.Cids])
 
-    const tpow = await this.props.client.call("Filecoin.StateMinerPower", [this.props.addr, tipset])
+    const tpow = await this.props.client.call("Filecoin.StateMinerPower", [this.props.addr, tipset.Cids])
     const networkPower = tpow.TotalPower
 
     let sectors = {}
 
-    const sset = await this.props.client.call("Filecoin.StateMinerSectors", [this.props.addr, tipset]) || []
-    const pset = await this.props.client.call("Filecoin.StateMinerProvingSet", [this.props.addr, tipset]) || []
+    const sset = await this.props.client.call("Filecoin.StateMinerSectors", [this.props.addr, tipset.Cids]) || []
+    const pset = await this.props.client.call("Filecoin.StateMinerProvingSet", [this.props.addr, tipset.Cids]) || []
 
     sset.forEach(s => sectors[s.SectorID] = {...s, sectorSet: true})
     pset.forEach(s => sectors[s.SectorID] = {...(sectors[s.SectorID] || s), provingSet: true})
@@ -181,7 +181,7 @@ class MinerState extends React.Component {
     return <div>
       <div>Worker: <Address addr={this.state.worker} client={this.props.client} mountWindow={this.props.mountWindow}/></div>
       <div>Sector Size: <b>{this.state.sectorSize/1024}</b> KiB</div>
-      <div>Power: <b>{state.Power}</b> (<b>{state.Power/this.state.networkPower*100}</b>%)</div>
+      <div>Power: <b>todoPower</b> (<b>{1/this.state.networkPower*100}</b>%)</div>
       <div>Election Period Start: <b>{state.ElectionPeriodStart}</b></div>
       <div>Slashed: <b>{state.SlashedAt === 0 ? "NO" : state.SlashedAt}</b></div>
       <div>
diff --git a/lotuspond/front/src/StorageNode.js b/lotuspond/front/src/StorageNode.js
index d86c83549..9026cdb94 100644
--- a/lotuspond/front/src/StorageNode.js
+++ b/lotuspond/front/src/StorageNode.js
@@ -8,20 +8,27 @@ const stateConnecting = 'connecting'
 const stateGettingToken = 'getting-token'
 
 let sealCodes = [
-  "Undefined",
-  "Empty",
-  "Packing",
-  "Unsealed",
-  "PreCommitting",
-  "PreCommitted",
-  "Committing",
-  "CommitWait",
-  "Proving",
+ "UndefinedSectorState",
+ "Empty",
+ "Packing",
+ "Unsealed",
+ "PreCommitting",
+ "WaitSeed",
+ "Committing",
+ "CommitWait",
+ "FinalizeSector",
+ "Proving",
 
-  "SealFailed",
-  "PreCommitFailed",
-  "SealCommitFailed",
-  "CommitFailed",
+ "SealFailed",
+ "PreCommitFailed",
+ "SealCommitFailed",
+ "CommitFailed",
+ "PackingFailed",
+
+ "FailedUnrecoverable",
+ "Faulty",
+ "FaultReported",
+ "FaultedFinal",
 ]
 
 class StorageNode extends React.Component {
@@ -52,7 +59,7 @@ class StorageNode extends React.Component {
       token: token,
     }))
 
-    const client = new Client(`ws://127.0.0.1:${this.props.node.ApiPort}/rpc/v0?token=${token}`)
+    const client = new Client(`ws://127.0.0.1:${this.props.node.APIPort}/rpc/v0?token=${token}`)
     client.on('open', async () => {
       this.setState(() => ({
         state: stateConnected,
@@ -81,8 +88,7 @@ class StorageNode extends React.Component {
     const peers = await this.state.client.call("Filecoin.NetPeers", [])
     const actor = await this.state.client.call("Filecoin.ActorAddress", [])
 
-    const stActor = await this.props.fullConn.call('Filecoin.StateGetActor', [actor, null])
-    const actorState = await this.props.fullConn.call('Filecoin.StateReadState', [stActor, null])
+    const actorState = await this.props.fullConn.call('Filecoin.StateReadState', [actor, null])
 
     this.setState({version: version, peers: peers.length, actor: actor, actorState: actorState})
     await this.stagedList()
@@ -91,7 +97,7 @@ class StorageNode extends React.Component {
   async stagedList() {
     let stagedList = await this.state.client.call("Filecoin.SectorsList", [])
     let staged = await stagedList
-      .map(sector => this.state.client.call("Filecoin.SectorsStatus", [sector]))
+      .map(sector => this.state.client.call("Filecoin.SectorsStatus", [sector, false]))
       .reduce(async (p, n) => [...await p, await n], Promise.resolve([]))
 
     let statusCounts = staged.reduce((p, n) => p.map((e, i) => e + (i === n.State ? 1 : 0) ), [0, 0, 0, 0, 0])
@@ -120,7 +126,7 @@ class StorageNode extends React.Component {
       runtime = (
         <div>
           <div>v{this.state.version.Version}, <abbr title={this.state.id}>{this.state.id.substr(-8)}</abbr>, {this.state.peers} peers</div>
-          <div>Repo: LOTUS_STORAGE_PATH={this.props.node.Repo}</div>
+          <div>Repo: LOTUS_MINER_PATH={this.props.node.Repo}</div>
           <div>
             {pledgeSector} {sealStaged}
           </div>
@@ -140,7 +146,7 @@ class StorageNode extends React.Component {
     }
 
     return <Window
-      title={"Storage Miner Node " + this.props.node.ID}
+      title={"Miner Node " + this.props.node.ID}
       initialPosition={{x: this.props.node.ID*30, y: this.props.node.ID * 30}}
       onClose={this.stop} >
       <div className="CristalScroll">
diff --git a/lotuspond/front/src/StorageNodeInit.js b/lotuspond/front/src/StorageNodeInit.js
index bd9d5390a..4ffe7c075 100644
--- a/lotuspond/front/src/StorageNodeInit.js
+++ b/lotuspond/front/src/StorageNodeInit.js
@@ -11,7 +11,7 @@ class StorageNodeInit extends React.Component {
 
   render() {
     return <Window
-      title={"Storage miner initializing"}
+      title={"Miner initializing"}
       initialPosition={'center'}>
       <div className="CristalScroll">
         <div className="StorageNodeInit">
diff --git a/lotuspond/front/src/chain/code.js b/lotuspond/front/src/chain/code.js
deleted file mode 100644
index c8ffc0b03..000000000
--- a/lotuspond/front/src/chain/code.js
+++ /dev/null
@@ -1,9 +0,0 @@
-export default {
-  account: "fil/1/account",
-  power: "fil/1/power",
-  market: "fil/1/market",
-  miner: "fil/1/miner",
-  multisig: "fil/1/multisig",
-  init: "fil/1/init",
-  paych: "fil/1/paych",
-}
diff --git a/lotuspond/front/src/chain/code.json b/lotuspond/front/src/chain/code.json
new file mode 100644
index 000000000..098b40244
--- /dev/null
+++ b/lotuspond/front/src/chain/code.json
@@ -0,0 +1,13 @@
+{
+  "account": "fil/1/account",
+  "cron": "fil/1/cron",
+  "init": "fil/1/init",
+  "market": "fil/1/storagemarket",
+  "miner": "fil/1/storageminer",
+  "multisig": "fil/1/multisig",
+  "paych": "fil/1/paymentchannel",
+  "power": "fil/1/storagepower",
+  "reward": "fil/1/reward",
+  "system": "fil/1/system",
+  "verifreg": "fil/1/verifiedregistry"
+}
\ No newline at end of file
diff --git a/lotuspond/front/src/chain/methodgen.go b/lotuspond/front/src/chain/methodgen.go
new file mode 100644
index 000000000..3197803fe
--- /dev/null
+++ b/lotuspond/front/src/chain/methodgen.go
@@ -0,0 +1,85 @@
+package main
+
+import (
+	"encoding/json"
+	"io/ioutil"
+	"os"
+	"reflect"
+
+	"github.com/ipfs/go-cid"
+	"github.com/multiformats/go-multihash"
+
+	"github.com/filecoin-project/specs-actors/actors/builtin"
+)
+
+func main() {
+	if _, err := os.Stat("code.json"); err != nil {
+		panic(err) // note: must run in lotuspond/front/src/chain
+	}
+
+	names := map[string]string{
+		"system":   "fil/1/system",
+		"init":     "fil/1/init",
+		"cron":     "fil/1/cron",
+		"account":  "fil/1/account",
+		"power":    "fil/1/storagepower",
+		"miner":    "fil/1/storageminer",
+		"market":   "fil/1/storagemarket",
+		"paych":    "fil/1/paymentchannel",
+		"multisig": "fil/1/multisig",
+		"reward":   "fil/1/reward",
+		"verifreg": "fil/1/verifiedregistry",
+	}
+
+	{
+		b, err := json.MarshalIndent(names, "", "  ")
+		if err != nil {
+			panic(err)
+		}
+
+		if err := ioutil.WriteFile("code.json", b, 0664); err != nil {
+			panic(err)
+		}
+	}
+
+	methods := map[cid.Cid]interface{}{
+		// builtin.SystemActorCodeID:        builtin.MethodsSystem - apparently it doesn't have methods
+		builtin.InitActorCodeID:             builtin.MethodsInit,
+		builtin.CronActorCodeID:             builtin.MethodsCron,
+		builtin.AccountActorCodeID:          builtin.MethodsAccount,
+		builtin.StoragePowerActorCodeID:     builtin.MethodsPower,
+		builtin.StorageMinerActorCodeID:     builtin.MethodsMiner,
+		builtin.StorageMarketActorCodeID:    builtin.MethodsMarket,
+		builtin.PaymentChannelActorCodeID:   builtin.MethodsPaych,
+		builtin.MultisigActorCodeID:         builtin.MethodsMultisig,
+		builtin.RewardActorCodeID:           builtin.MethodsReward,
+		builtin.VerifiedRegistryActorCodeID: builtin.MethodsVerifiedRegistry,
+	}
+
+	out := map[string][]string{}
+	for c, methods := range methods {
+		cmh, err := multihash.Decode(c.Hash())
+		if err != nil {
+			panic(err)
+		}
+
+		rt := reflect.TypeOf(methods)
+		nf := rt.NumField()
+
+		out[string(cmh.Digest)] = append(out[string(cmh.Digest)], "Send")
+		for i := 0; i < nf; i++ {
+			out[string(cmh.Digest)] = append(out[string(cmh.Digest)], rt.Field(i).Name)
+		}
+	}
+
+	{
+		b, err := json.MarshalIndent(out, "", "  ")
+		if err != nil {
+			panic(err)
+		}
+
+		if err := ioutil.WriteFile("methods.json", b, 0664); err != nil {
+			panic(err)
+		}
+	}
+}
diff --git a/lotuspond/front/src/chain/methods.js b/lotuspond/front/src/chain/methods.js
deleted file mode 100644
index 172531c5a..000000000
--- a/lotuspond/front/src/chain/methods.js
+++ /dev/null
@@ -1,81 +0,0 @@
-import code from "./code";
-
-export default {
-  [code.account]: [
-    "Send",
-    "Constructor",
-    "GetAddress",
-  ],
-  [code.power]: [
-    "Send",
-    "Constructor",
-    "CreateStorageMiner",
-    "SlashConsensusFault",
-    "UpdateStorage",
-    "GetTotalStorage",
-    "PowerLookup",
-    "IsMiner",
-    "StorageCollateralForSize"
-  ],
-  [code.market]: [
-    "Send",
-    "Constructor",
-    "WithdrawBalance",
-    "AddBalance",
-    "CheckLockedBalance",
-    "PublishStorageDeals",
-    "HandleCronAction",
-    "SettleExpiredDeals",
-    "ProcessStorageDealsPayment",
-    "SlashStorageDealCollateral",
-    "GetLastExpirationFromDealIDs",
-    "ActivateStorageDeals",
-  ],
-  [code.miner]: [
-    "Send",
-    "Constructor",
-    "PreCommitSector",
-    "ProveCommitSector",
-    "SubmitPoSt",
-    "SlashStorageFault",
-    "GetCurrentProvingSet",
-    "ArbitrateDeal",
-    "DePledge",
-    "GetOwner",
-    "GetWorkerAddr",
-    "GetPower",
-    "GetPeerID",
-    "GetSectorSize",
-    "UpdatePeerID",
-    "ChangeWorker",
-    "IsSlashed",
-    "IsLate",
-    "DeclareFaults",
-    "SlashConsensusFault",
-  ],
-  [code.multisig]: [
-    "Send",
-    "Constructor",
-    "Propose",
-    "Approve",
-    "Cancel",
-    "ClearCompleted",
-    "AddSigner",
-    "RemoveSigner",
-    "SwapSigner",
-    "ChangeRequirement",
-  ],
-  [code.init]: [
-    "Send",
-    "Constructor",
-    "Exec",
-    "GetIdForAddress"
-  ],
-  [code.paych]: [
-    "Send",
-    "Constructor",
-    "UpdateChannelState",
-    "Close",
-    "Collect",
-  ],
-}
\ No newline at end of file
diff --git a/lotuspond/front/src/chain/methods.json b/lotuspond/front/src/chain/methods.json
new file mode 100644
index 000000000..ce4919cc4
--- /dev/null
+++ b/lotuspond/front/src/chain/methods.json
@@ -0,0 +1,99 @@
+{
+  "fil/1/account": [
+    "Send",
+    "Constructor",
+    "PubkeyAddress"
+  ],
+  "fil/1/cron": [
+    "Send",
+    "Constructor",
+    "EpochTick"
+  ],
+  "fil/1/init": [
+    "Send",
+    "Constructor",
+    "Exec"
+  ],
+  "fil/1/multisig": [
+    "Send",
+    "Constructor",
+    "Propose",
+    "Approve",
+    "Cancel",
+    "AddSigner",
+    "RemoveSigner",
+    "SwapSigner",
+    "ChangeNumApprovalsThreshold",
+    "LockBalance"
+  ],
+  "fil/1/paymentchannel": [
+    "Send",
+    "Constructor",
+    "UpdateChannelState",
+    "Settle",
+    "Collect"
+  ],
+  "fil/1/reward": [
+    "Send",
+    "Constructor",
+    "AwardBlockReward",
+    "ThisEpochReward",
+    "UpdateNetworkKPI"
+  ],
+  "fil/1/storagemarket": [
+    "Send",
+    "Constructor",
+    "AddBalance",
+    "WithdrawBalance",
+    "PublishStorageDeals",
+    "VerifyDealsForActivation",
+    "ActivateDeals",
+    "OnMinerSectorsTerminate",
+    "ComputeDataCommitment",
+    "CronTick"
+  ],
+  "fil/1/storageminer": [
+    "Send",
+    "Constructor",
+    "ControlAddresses",
+    "ChangeWorkerAddress",
+    "ChangePeerID",
+    "SubmitWindowedPoSt",
+    "PreCommitSector",
+    "ProveCommitSector",
+    "ExtendSectorExpiration",
+    "TerminateSectors",
+    "DeclareFaults",
+    "DeclareFaultsRecovered",
+    "OnDeferredCronEvent",
+    "CheckSectorProven",
+    "AddLockedFund",
+    "ReportConsensusFault",
+    "WithdrawBalance",
+    "ConfirmSectorProofsValid",
+    "ChangeMultiaddrs",
+    "CompactPartitions",
+    "CompactSectorNumbers"
+  ],
+  "fil/1/storagepower": [
+    "Send",
+    "Constructor",
+    "CreateMiner",
+    "UpdateClaimedPower",
+    "EnrollCronEvent",
+    "OnEpochTickEnd",
+    "UpdatePledgeTotal",
+    "OnConsensusFault",
+    "SubmitPoRepForBulkVerify",
+    "CurrentTotalPower"
+  ],
+  "fil/1/verifiedregistry": [
+    "Send",
+    "Constructor",
+    "AddVerifier",
+    "RemoveVerifier",
+    "AddVerifiedClient",
+    "UseBytes",
+    "RestoreBytes"
+  ]
+}
\ No newline at end of file
diff --git a/lotuspond/front/src/chain/send.js b/lotuspond/front/src/chain/send.js
index d09333dd6..a0fc89437 100644
--- a/lotuspond/front/src/chain/send.js
+++ b/lotuspond/front/src/chain/send.js
@@ -3,12 +3,6 @@ import { Buffer } from 'buffer'
 import { Tagged } from 'borc'
 
 async function pushMessage(client, from, inmsg) {
-    if(!inmsg.GasLimit) {
-        inmsg.GasLimit = "1000"
-    }
-    if(!inmsg.GasPrice) {
-        inmsg.GasPrice = "0"
-    }
     if(!inmsg.Params) {
         inmsg.Params = "oA==" // 0b101_00000: empty cbor map: {}
     }
@@ -39,4 +33,4 @@ async function pushMessage(client, from, inmsg) {
     await client.call('Filecoin.MpoolPushMessage', [inmsg])
 }
 
-export default pushMessage
\ No newline at end of file
+export default pushMessage
diff --git a/lotuspond/main.go b/lotuspond/main.go
index 17ad7c970..ec01e8b42 100644
--- a/lotuspond/main.go
+++ b/lotuspond/main.go
@@ -8,9 +8,9 @@ import (
 	"path"
 	"strconv"
 
-	"github.com/filecoin-project/lotus/lib/jsonrpc"
+	"github.com/urfave/cli/v2"
 
-	"gopkg.in/urfave/cli.v2"
+	"github.com/filecoin-project/go-jsonrpc"
 )
 
 const listenAddr = "127.0.0.1:2222"
@@ -27,7 +27,7 @@ var onCmd = &cli.Command{
 	Name:  "on",
 	Usage: "run a command on a given node",
 	Action: func(cctx *cli.Context) error {
-		client, err := apiClient()
+		client, err := apiClient(cctx.Context)
 		if err != nil {
 			return err
 		}
@@ -37,7 +37,7 @@ var onCmd = &cli.Command{
 			return err
 		}
 
-		node := nodeById(client.Nodes(), int(nd))
+		node := nodeByID(client.Nodes(), int(nd))
 		var cmd *exec.Cmd
 		if !node.Storage {
 			cmd = exec.Command("./lotus", cctx.Args().Slice()[1:]...)
@@ -45,9 +45,9 @@ var onCmd = &cli.Command{
 				"LOTUS_PATH=" + node.Repo,
 			}
 		} else {
-			cmd = exec.Command("./lotus-storage-miner")
+			cmd = exec.Command("./lotus-miner")
 			cmd.Env = []string{
-				"LOTUS_STORAGE_PATH=" + node.Repo,
+				"LOTUS_MINER_PATH=" + node.Repo,
 				"LOTUS_PATH=" + node.FullNode,
 			}
 		}
@@ -65,7 +65,7 @@ var shCmd = &cli.Command{
 	Name:  "sh",
 	Usage: "spawn shell with node shell variables set",
 	Action: func(cctx *cli.Context) error {
-		client, err := apiClient()
+		client, err := apiClient(cctx.Context)
 		if err != nil {
 			return err
 		}
@@ -75,7 +75,7 @@ var shCmd = &cli.Command{
 			return err
 		}
 
-		node := nodeById(client.Nodes(), int(nd))
+		node := nodeByID(client.Nodes(), int(nd))
 		shcmd := exec.Command("/bin/bash")
 		if !node.Storage {
 			shcmd.Env = []string{
@@ -83,7 +83,7 @@ var shCmd = &cli.Command{
 			}
 		} else {
 			shcmd.Env = []string{
-				"LOTUS_STORAGE_PATH=" + node.Repo,
+				"LOTUS_MINER_PATH=" + node.Repo,
 				"LOTUS_PATH=" + node.FullNode,
 			}
 		}
@@ -102,7 +102,7 @@ var shCmd = &cli.Command{
 	},
 }
 
-func nodeById(nodes []nodeInfo, i int) nodeInfo {
+func nodeByID(nodes []nodeInfo, i int) nodeInfo {
 	for _, n := range nodes {
 		if n.ID == int32(i) {
 			return n
@@ -116,7 +116,6 @@ func logHandler(api *api) func(http.ResponseWriter, *http.Request) {
 		id, err := strconv.ParseInt(path.Base(req.URL.Path), 10, 32)
 		if err != nil {
 			panic(err)
-			return
 		}
 
 		api.runningLk.Lock()
diff --git a/lotuspond/outmux.go b/lotuspond/outmux.go
index 406001078..199c83ef1 100644
--- a/lotuspond/outmux.go
+++ b/lotuspond/outmux.go
@@ -73,7 +73,7 @@ func (m *outmux) run() {
 		case msg := <-stdout:
 			for k, out := range m.outs {
 				if err := out.WriteMessage(websocket.BinaryMessage, msg); err != nil {
-					out.Close()
+					_ = out.Close()
 					fmt.Printf("outmux write failed: %s\n", err)
 					delete(m.outs, k)
 				}
diff --git a/lotuspond/spawn.go b/lotuspond/spawn.go
index bc0602fa6..8b2e8661d 100644
--- a/lotuspond/spawn.go
+++ b/lotuspond/spawn.go
@@ -1,6 +1,7 @@
 package main
 
 import (
+	"encoding/json"
 	"fmt"
 	"io"
 	"io/ioutil"
@@ -10,15 +11,22 @@ import (
 	"sync/atomic"
 	"time"
 
+	"github.com/filecoin-project/lotus/chain/actors/policy"
+	"github.com/filecoin-project/lotus/chain/types"
+
 	"golang.org/x/xerrors"
 
 	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/go-state-types/abi"
+	genesis2 "github.com/filecoin-project/lotus/chain/gen/genesis"
+
+	"github.com/filecoin-project/lotus/chain/gen"
 	"github.com/filecoin-project/lotus/cmd/lotus-seed/seed"
+	"github.com/filecoin-project/lotus/genesis"
 )
 
 func init() {
-	build.SectorSizes = []uint64{1024}
+	policy.SetSupportedProofTypes(abi.RegisteredSealProof_StackedDrg2KiBV1)
 }
 
 func (api *api) Spawn() (nodeInfo, error) {
@@ -34,21 +42,42 @@ func (api *api) Spawn() (nodeInfo, error) {
 	if id == 1 {
 		// preseal
 
-		genMiner, err := address.NewIDAddress(101)
+		genMiner, err := address.NewIDAddress(genesis2.MinerStart)
 		if err != nil {
 			return nodeInfo{}, err
 		}
 
 		sbroot := filepath.Join(dir, "preseal")
-		genm, err := seed.PreSeal(genMiner, build.SectorSizes[0], 0, 2, sbroot, []byte("8"))
+		genm, ki, err := seed.PreSeal(genMiner, abi.RegisteredSealProof_StackedDrg2KiBV1, 0, 2, sbroot, []byte("8"), nil, false)
 		if err != nil {
 			return nodeInfo{}, xerrors.Errorf("preseal failed: %w", err)
 		}
 
-		if err := seed.WriteGenesisMiner(genMiner, sbroot, genm); err != nil {
+		if err := seed.WriteGenesisMiner(genMiner, sbroot, genm, ki); err != nil {
 			return nodeInfo{}, xerrors.Errorf("failed to write genminer info: %w", err)
 		}
-		params = append(params, "--genesis-presealed-sectors="+filepath.Join(dir, "preseal", "pre-seal-t0101.json"))
+		params = append(params, "--import-key="+filepath.Join(dir, "preseal", "pre-seal-t01000.key"))
+		params = append(params, "--genesis-template="+filepath.Join(dir, "preseal", "genesis-template.json"))
+
+		// Create template
+
+		var template genesis.Template
+		template.Miners = append(template.Miners, *genm)
+		template.Accounts = append(template.Accounts, genesis.Actor{
+			Type:    genesis.TAccount,
+			Balance: types.FromFil(5000000),
+			Meta:    (&genesis.AccountMeta{Owner: genm.Owner}).ActorMeta(),
+		})
+		template.VerifregRootKey = gen.DefaultVerifregRootkeyActor
+
+		tb, err := json.Marshal(&template)
+		if err != nil {
+			return nodeInfo{}, xerrors.Errorf("marshal genesis template: %w", err)
+		}
+
+		if err := ioutil.WriteFile(filepath.Join(dir, "preseal", "genesis-template.json"), tb, 0664); err != nil {
+			return nodeInfo{}, xerrors.Errorf("write genesis template: %w", err)
+		}
 
 		// make genesis
 		genf, err := ioutil.TempFile(os.TempDir(), "lotus-genesis-")
@@ -57,7 +86,7 @@ func (api *api) Spawn() (nodeInfo, error) {
 		}
 
 		api.genesis = genf.Name()
-		genParam = "--lotus-make-random-genesis=" + api.genesis
+		genParam = "--lotus-make-genesis=" + api.genesis
 
 		if err := genf.Close(); err != nil {
 			return nodeInfo{}, err
@@ -94,7 +123,7 @@ func (api *api) Spawn() (nodeInfo, error) {
 	info := nodeInfo{
 		Repo:    dir,
 		ID:      id,
-		ApiPort: 2500 + id,
+		APIPort: 2500 + id,
 		State:   NodeRunning,
 	}
 
@@ -142,14 +171,15 @@ func (api *api) SpawnStorage(fullNodeRepo string) (nodeInfo, error) {
 
 	initArgs := []string{"init", "--nosync"}
 	if fullNodeRepo == api.running[1].meta.Repo {
-		initArgs = []string{"init", "--actor=t0101", "--genesis-miner", "--pre-sealed-sectors=" + filepath.Join(fullNodeRepo, "preseal")}
+		presealPrefix := filepath.Join(fullNodeRepo, "preseal")
+		initArgs = []string{"init", "--actor=t01000", "--genesis-miner", "--pre-sealed-sectors=" + presealPrefix, "--pre-sealed-metadata=" + filepath.Join(presealPrefix, "pre-seal-t01000.json")}
 	}
 
 	id := atomic.AddInt32(&api.cmds, 1)
-	cmd := exec.Command("./lotus-storage-miner", initArgs...)
+	cmd := exec.Command("./lotus-miner", initArgs...)
 	cmd.Stderr = io.MultiWriter(os.Stderr, errlogfile)
 	cmd.Stdout = io.MultiWriter(os.Stdout, logfile)
-	cmd.Env = append(os.Environ(), "LOTUS_STORAGE_PATH="+dir, "LOTUS_PATH="+fullNodeRepo)
+	cmd.Env = append(os.Environ(), "LOTUS_MINER_PATH="+dir, "LOTUS_PATH="+fullNodeRepo)
 	if err := cmd.Run(); err != nil {
 		return nodeInfo{}, err
 	}
@@ -158,10 +188,10 @@ func (api *api) SpawnStorage(fullNodeRepo string) (nodeInfo, error) {
 
 	mux := newWsMux()
 
-	cmd = exec.Command("./lotus-storage-miner", "run", "--api", fmt.Sprintf("%d", 2500+id), "--nosync")
+	cmd = exec.Command("./lotus-miner", "run", "--api", fmt.Sprintf("%d", 2500+id), "--nosync")
 	cmd.Stderr = io.MultiWriter(os.Stderr, errlogfile, mux.errpw)
 	cmd.Stdout = io.MultiWriter(os.Stdout, logfile, mux.outpw)
-	cmd.Env = append(os.Environ(), "LOTUS_STORAGE_PATH="+dir, "LOTUS_PATH="+fullNodeRepo)
+	cmd.Env = append(os.Environ(), "LOTUS_MINER_PATH="+dir, "LOTUS_PATH="+fullNodeRepo)
 	if err := cmd.Start(); err != nil {
 		return nodeInfo{}, err
 	}
@@ -169,7 +199,7 @@ func (api *api) SpawnStorage(fullNodeRepo string) (nodeInfo, error) {
 	info := nodeInfo{
 		Repo:    dir,
 		ID:      id,
-		ApiPort: 2500 + id,
+		APIPort: 2500 + id,
 		State:   NodeRunning,
 
 		FullNode: fullNodeRepo,
@@ -218,7 +248,7 @@ func (api *api) RestartNode(id int32) (nodeInfo, error) {
 
 	var cmd *exec.Cmd
 	if nd.meta.Storage {
-		cmd = exec.Command("./lotus-storage-miner", "run", "--api", fmt.Sprintf("%d", 2500+id), "--nosync")
+		cmd = exec.Command("./lotus-miner", "run", "--api", fmt.Sprintf("%d", 2500+id), "--nosync")
 	} else {
 		cmd = exec.Command("./lotus", "daemon", "--api", fmt.Sprintf("%d", 2500+id))
 	}
diff --git a/markets/dealfilter/cli.go b/markets/dealfilter/cli.go
new file mode 100644
index 000000000..2cb9d6c4f
--- /dev/null
+++ b/markets/dealfilter/cli.go
@@ -0,0 +1,40 @@
+package dealfilter
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"os/exec"
+
+	"github.com/filecoin-project/go-fil-markets/storagemarket"
+
+	"github.com/filecoin-project/lotus/node/modules/dtypes"
+)
+
+func CliDealFilter(cmd string) dtypes.DealFilter {
+	// TODO: run some checks on the cmd string
+
+	return func(ctx context.Context, deal storagemarket.MinerDeal) (bool, string, error) {
+		j, err := json.MarshalIndent(deal, "", "  ")
+		if err != nil {
+			return false, "", err
+		}
+
+		var out bytes.Buffer
+
+		c := exec.Command("sh", "-c", cmd)
+		c.Stdin = bytes.NewReader(j)
+		c.Stdout = &out
+		c.Stderr = &out
+
+		switch err := c.Run().(type) {
+		case nil:
+			return true, "", nil
+		case *exec.ExitError:
+			return false, out.String(), nil
+		default:
+			return false, "filter cmd run error", err
+		}
+
+	}
+}
diff --git a/markets/journal.go b/markets/journal.go
new file mode 100644
index 000000000..a73d28011
--- /dev/null
+++ b/markets/journal.go
@@ -0,0 +1,76 @@
+package markets
+
+import (
+	"github.com/filecoin-project/go-fil-markets/retrievalmarket"
+	"github.com/filecoin-project/go-fil-markets/storagemarket"
+
+	"github.com/filecoin-project/lotus/journal"
+)
+
+type StorageClientEvt struct {
+	Event string
+	Deal  storagemarket.ClientDeal
+}
+
+type StorageProviderEvt struct {
+	Event string
+	Deal  storagemarket.MinerDeal
+}
+
+type RetrievalClientEvt struct {
+	Event string
+	Deal  retrievalmarket.ClientDealState
+}
+
+type RetrievalProviderEvt struct {
+	Event string
+	Deal  retrievalmarket.ProviderDealState
+}
+
+// StorageClientJournaler records journal events from the storage client.
+func StorageClientJournaler(evtType journal.EventType) func(event storagemarket.ClientEvent, deal storagemarket.ClientDeal) {
+	return func(event storagemarket.ClientEvent, deal storagemarket.ClientDeal) {
+		journal.J.RecordEvent(evtType, func() interface{} {
+			return StorageClientEvt{
+				Event: storagemarket.ClientEvents[event],
+				Deal:  deal,
+			}
+		})
+	}
+}
+
+// StorageProviderJournaler records journal events from the storage provider.
+func StorageProviderJournaler(evtType journal.EventType) func(event storagemarket.ProviderEvent, deal storagemarket.MinerDeal) {
+	return func(event storagemarket.ProviderEvent, deal storagemarket.MinerDeal) {
+		journal.J.RecordEvent(evtType, func() interface{} {
+			return StorageProviderEvt{
+				Event: storagemarket.ProviderEvents[event],
+				Deal:  deal,
+			}
+		})
+	}
+}
+
+// RetrievalClientJournaler records journal events from the retrieval client.
+func RetrievalClientJournaler(evtType journal.EventType) func(event retrievalmarket.ClientEvent, deal retrievalmarket.ClientDealState) {
+	return func(event retrievalmarket.ClientEvent, deal retrievalmarket.ClientDealState) {
+		journal.J.RecordEvent(evtType, func() interface{} {
+			return RetrievalClientEvt{
+				Event: retrievalmarket.ClientEvents[event],
+				Deal:  deal,
+			}
+		})
+	}
+}
+
+// RetrievalProviderJournaler records journal events from the retrieval provider.
+func RetrievalProviderJournaler(evtType journal.EventType) func(event retrievalmarket.ProviderEvent, deal retrievalmarket.ProviderDealState) {
+	return func(event retrievalmarket.ProviderEvent, deal retrievalmarket.ProviderDealState) {
+		journal.J.RecordEvent(evtType, func() interface{} {
+			return RetrievalProviderEvt{
+				Event: retrievalmarket.ProviderEvents[event],
+				Deal:  deal,
+			}
+		})
+	}
+}
diff --git a/markets/loggers/loggers.go b/markets/loggers/loggers.go
new file mode 100644
index 000000000..27a6b2c63
--- /dev/null
+++ b/markets/loggers/loggers.go
@@ -0,0 +1,38 @@
+package marketevents
+
+import (
+	"github.com/filecoin-project/go-fil-markets/retrievalmarket"
+	"github.com/filecoin-project/go-fil-markets/storagemarket"
+	"github.com/filecoin-project/go-state-types/abi"
+	logging "github.com/ipfs/go-log/v2"
+)
+
+var log = logging.Logger("markets")
+
+// StorageClientLogger logs events from the storage client
+func StorageClientLogger(event storagemarket.ClientEvent, deal storagemarket.ClientDeal) {
+	log.Infow("storage event", "name", storagemarket.ClientEvents[event], "proposal CID", deal.ProposalCid, "state", storagemarket.DealStates[deal.State], "message", deal.Message)
+}
+
+// StorageProviderLogger logs events from the storage provider
+func StorageProviderLogger(event storagemarket.ProviderEvent, deal storagemarket.MinerDeal) {
+	log.Infow("storage event", "name", storagemarket.ProviderEvents[event], "proposal CID", deal.ProposalCid, "state", storagemarket.DealStates[deal.State], "message", deal.Message)
+}
+
+// RetrievalClientLogger logs events from the retrieval client
+func RetrievalClientLogger(event retrievalmarket.ClientEvent, deal retrievalmarket.ClientDealState) {
+	log.Infow("retrieval event", "name", retrievalmarket.ClientEvents[event], "deal ID", deal.ID, "state", retrievalmarket.DealStatuses[deal.Status], "message", deal.Message)
+}
+
+// RetrievalProviderLogger logs events from the retrieval provider
+func RetrievalProviderLogger(event retrievalmarket.ProviderEvent, deal retrievalmarket.ProviderDealState) {
+	log.Infow("retrieval event", "name", retrievalmarket.ProviderEvents[event], "deal ID", deal.ID, "receiver", deal.Receiver, "state", retrievalmarket.DealStatuses[deal.Status], "message", deal.Message)
+}
+
+type RetrievalEvent struct {
+	Event         retrievalmarket.ClientEvent
+	Status        retrievalmarket.DealStatus
+	BytesReceived uint64
+	FundsSpent    abi.TokenAmount
+	Err           string
+}
diff --git a/markets/retrievaladapter/client.go b/markets/retrievaladapter/client.go
new file mode 100644
index 000000000..ab81dd8c9
--- /dev/null
+++ b/markets/retrievaladapter/client.go
@@ -0,0 +1,115 @@
+package retrievaladapter
+
+import (
+	"context"
+
+	"github.com/filecoin-project/specs-actors/actors/builtin/paych"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-fil-markets/retrievalmarket"
+	"github.com/filecoin-project/go-fil-markets/shared"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/ipfs/go-cid"
+	"github.com/multiformats/go-multiaddr"
+
+	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/node/impl/full"
+	payapi "github.com/filecoin-project/lotus/node/impl/paych"
+)
+
+type retrievalClientNode struct {
+	chainAPI full.ChainAPI
+	payAPI   payapi.PaychAPI
+	stateAPI full.StateAPI
+}
+
+// NewRetrievalClientNode returns a new node adapter for a retrieval client that talks to the
+// Lotus Node
+func NewRetrievalClientNode(payAPI payapi.PaychAPI, chainAPI full.ChainAPI, stateAPI full.StateAPI) retrievalmarket.RetrievalClientNode {
+	return &retrievalClientNode{payAPI: payAPI, chainAPI: chainAPI, stateAPI: stateAPI}
+}
+
+// GetOrCreatePaymentChannel sets up a new payment channel if one does not exist
+// between a client and a miner and ensures the client has the given amount of
+// funds available in the channel.
+func (rcn *retrievalClientNode) GetOrCreatePaymentChannel(ctx context.Context, clientAddress address.Address, minerAddress address.Address, clientFundsAvailable abi.TokenAmount, tok shared.TipSetToken) (address.Address, cid.Cid, error) {
+	// TODO: respect the provided TipSetToken (a serialized TipSetKey) when
+	// querying the chain
+	ci, err := rcn.payAPI.PaychGet(ctx, clientAddress, minerAddress, clientFundsAvailable)
+	if err != nil {
+		return address.Undef, cid.Undef, err
+	}
+	return ci.Channel, ci.WaitSentinel, nil
+}
+
+// Allocate late creates a lane within a payment channel so that calls to
+// CreatePaymentVoucher will automatically make vouchers only for the difference
+// in total
+func (rcn *retrievalClientNode) AllocateLane(ctx context.Context, paymentChannel address.Address) (uint64, error) {
+	return rcn.payAPI.PaychAllocateLane(ctx, paymentChannel)
+}
+
+// CreatePaymentVoucher creates a new payment voucher in the given lane for a
+// given payment channel so that all the payment vouchers in the lane add up
+// to the given amount (so the payment voucher will be for the difference)
+func (rcn *retrievalClientNode) CreatePaymentVoucher(ctx context.Context, paymentChannel address.Address, amount abi.TokenAmount, lane uint64, tok shared.TipSetToken) (*paych.SignedVoucher, error) {
+	// TODO: respect the provided TipSetToken (a serialized TipSetKey) when
+	// querying the chain
+	voucher, err := rcn.payAPI.PaychVoucherCreate(ctx, paymentChannel, amount, lane)
+	if err != nil {
+		return nil, err
+	}
+	if voucher.Voucher == nil {
+		return nil, retrievalmarket.NewShortfallError(voucher.Shortfall)
+	}
+	return voucher.Voucher, nil
+}
+
+func (rcn *retrievalClientNode) GetChainHead(ctx context.Context) (shared.TipSetToken, abi.ChainEpoch, error) {
+	head, err := rcn.chainAPI.ChainHead(ctx)
+	if err != nil {
+		return nil, 0, err
+	}
+
+	return head.Key().Bytes(), head.Height(), nil
+}
+
+func (rcn *retrievalClientNode) WaitForPaymentChannelReady(ctx context.Context, messageCID cid.Cid) (address.Address, error) {
+	return rcn.payAPI.PaychGetWaitReady(ctx, messageCID)
+}
+
+func (rcn *retrievalClientNode) CheckAvailableFunds(ctx context.Context, paymentChannel address.Address) (retrievalmarket.ChannelAvailableFunds, error) {
+
+	channelAvailableFunds, err := rcn.payAPI.PaychAvailableFunds(ctx, paymentChannel)
+	if err != nil {
+		return retrievalmarket.ChannelAvailableFunds{}, err
+	}
+	return retrievalmarket.ChannelAvailableFunds{
+		ConfirmedAmt:        channelAvailableFunds.ConfirmedAmt,
+		PendingAmt:          channelAvailableFunds.PendingAmt,
+		PendingWaitSentinel: channelAvailableFunds.PendingWaitSentinel,
+		QueuedAmt:           channelAvailableFunds.QueuedAmt,
+		VoucherReedeemedAmt: channelAvailableFunds.VoucherReedeemedAmt,
+	}, nil
+}
+
+func (rcn *retrievalClientNode) GetKnownAddresses(ctx context.Context, p retrievalmarket.RetrievalPeer, encodedTs shared.TipSetToken) ([]multiaddr.Multiaddr, error) {
+	tsk, err := types.TipSetKeyFromBytes(encodedTs)
+	if err != nil {
+		return nil, err
+	}
+	mi, err := rcn.stateAPI.StateMinerInfo(ctx, p.Address, tsk)
+	if err != nil {
+		return nil, err
+	}
+	multiaddrs := make([]multiaddr.Multiaddr, 0, len(mi.Multiaddrs))
+	for _, a := range mi.Multiaddrs {
+		maddr, err := multiaddr.NewMultiaddrBytes(a)
+		if err != nil {
+			return nil, err
+		}
+		multiaddrs = append(multiaddrs, maddr)
+	}
+
+	return multiaddrs, nil
+}
diff --git a/markets/retrievaladapter/provider.go b/markets/retrievaladapter/provider.go
new file mode 100644
index 000000000..443c4fb4a
--- /dev/null
+++ b/markets/retrievaladapter/provider.go
@@ -0,0 +1,87 @@
+package retrievaladapter
+
+import (
+	"context"
+	"io"
+
+	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/chain/types"
+	sectorstorage "github.com/filecoin-project/lotus/extern/sector-storage"
+	"github.com/filecoin-project/lotus/extern/sector-storage/storiface"
+	"github.com/filecoin-project/lotus/storage"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-fil-markets/retrievalmarket"
+	"github.com/filecoin-project/go-fil-markets/shared"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/specs-actors/actors/builtin/paych"
+
+	"github.com/ipfs/go-cid"
+)
+
+type retrievalProviderNode struct {
+	miner  *storage.Miner
+	sealer sectorstorage.SectorManager
+	full   api.FullNode
+}
+
+// NewRetrievalProviderNode returns a new node adapter for a retrieval provider that talks to the
+// Lotus Node
+func NewRetrievalProviderNode(miner *storage.Miner, sealer sectorstorage.SectorManager, full api.FullNode) retrievalmarket.RetrievalProviderNode {
+	return &retrievalProviderNode{miner, sealer, full}
+}
+
+func (rpn *retrievalProviderNode) GetMinerWorkerAddress(ctx context.Context, miner address.Address, tok shared.TipSetToken) (address.Address, error) {
+	tsk, err := types.TipSetKeyFromBytes(tok)
+	if err != nil {
+		return address.Undef, err
+	}
+
+	mi, err := rpn.full.StateMinerInfo(ctx, miner, tsk)
+	return mi.Worker, err
+}
+
+func (rpn *retrievalProviderNode) UnsealSector(ctx context.Context, sectorID abi.SectorNumber, offset abi.UnpaddedPieceSize, length abi.UnpaddedPieceSize) (io.ReadCloser, error) {
+	si, err := rpn.miner.GetSectorInfo(sectorID)
+	if err != nil {
+		return nil, err
+	}
+
+	mid, err := address.IDFromAddress(rpn.miner.Address())
+	if err != nil {
+		return nil, err
+	}
+
+	sid := abi.SectorID{
+		Miner:  abi.ActorID(mid),
+		Number: sectorID,
+	}
+
+	r, w := io.Pipe()
+	go func() {
+		var commD cid.Cid
+		if si.CommD != nil {
+			commD = *si.CommD
+		}
+		err := rpn.sealer.ReadPiece(ctx, w, sid, storiface.UnpaddedByteIndex(offset), length, si.TicketValue, commD)
+		_ = w.CloseWithError(err)
+	}()
+
+	return r, nil
+}
+
+func (rpn *retrievalProviderNode) SavePaymentVoucher(ctx context.Context, paymentChannel address.Address, voucher *paych.SignedVoucher, proof []byte, expectedAmount abi.TokenAmount, tok shared.TipSetToken) (abi.TokenAmount, error) {
+	// TODO: respect the provided TipSetToken (a serialized TipSetKey) when
+	// querying the chain
+	added, err := rpn.full.PaychVoucherAdd(ctx, paymentChannel, voucher, proof, expectedAmount)
+	return added, err
+}
+
+func (rpn *retrievalProviderNode) GetChainHead(ctx context.Context) (shared.TipSetToken, abi.ChainEpoch, error) {
+	head, err := rpn.full.ChainHead(ctx)
+	if err != nil {
+		return nil, 0, err
+	}
+
+	return head.Key().Bytes(), head.Height(), nil
+}
diff --git a/markets/storageadapter/client.go b/markets/storageadapter/client.go
new file mode 100644
index 000000000..fabc5b197
--- /dev/null
+++ b/markets/storageadapter/client.go
@@ -0,0 +1,516 @@
+package storageadapter
+
+// this file implements storagemarket.StorageClientNode
+
+import (
+	"bytes"
+	"context"
+
+	"github.com/filecoin-project/go-state-types/big"
+	miner0 "github.com/filecoin-project/specs-actors/actors/builtin"
+	market0 "github.com/filecoin-project/specs-actors/actors/builtin/market"
+
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-address"
+	cborutil "github.com/filecoin-project/go-cbor-util"
+	"github.com/filecoin-project/go-fil-markets/shared"
+	"github.com/filecoin-project/go-fil-markets/storagemarket"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/crypto"
+	"github.com/filecoin-project/go-state-types/exitcode"
+	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
+	"github.com/filecoin-project/lotus/chain/events"
+	"github.com/filecoin-project/lotus/chain/events/state"
+	"github.com/filecoin-project/lotus/chain/market"
+	"github.com/filecoin-project/lotus/chain/stmgr"
+	"github.com/filecoin-project/lotus/chain/store"
+	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/lib/sigs"
+	"github.com/filecoin-project/lotus/markets/utils"
+	"github.com/filecoin-project/lotus/node/impl/full"
+	"github.com/ipfs/go-cid"
+)
+
+type ClientNodeAdapter struct {
+	full.StateAPI
+	full.ChainAPI
+	full.MpoolAPI
+
+	sm *stmgr.StateManager
+	cs *store.ChainStore
+	fm *market.FundMgr
+	ev *events.Events
+}
+
+type clientApi struct {
+	full.ChainAPI
+	full.StateAPI
+}
+
+func NewClientNodeAdapter(state full.StateAPI, chain full.ChainAPI, mpool full.MpoolAPI, sm *stmgr.StateManager, cs *store.ChainStore, fm *market.FundMgr) storagemarket.StorageClientNode {
+	return &ClientNodeAdapter{
+		StateAPI: state,
+		ChainAPI: chain,
+		MpoolAPI: mpool,
+
+		sm: sm,
+		cs: cs,
+		fm: fm,
+		ev: events.NewEvents(context.TODO(), &clientApi{chain, state}),
+	}
+}
+
+func (c *ClientNodeAdapter) ListStorageProviders(ctx context.Context, encodedTs shared.TipSetToken) ([]*storagemarket.StorageProviderInfo, error) {
+	tsk, err := types.TipSetKeyFromBytes(encodedTs)
+	if err != nil {
+		return nil, err
+	}
+
+	addresses, err := c.StateListMiners(ctx, tsk)
+	if err != nil {
+		return nil, err
+	}
+
+	var out []*storagemarket.StorageProviderInfo
+
+	for _, addr := range addresses {
+		mi, err := c.GetMinerInfo(ctx, addr, encodedTs)
+		if err != nil {
+			return nil, err
+		}
+
+		out = append(out, mi)
+	}
+
+	return out, nil
+}
+
+func (c *ClientNodeAdapter) VerifySignature(ctx context.Context, sig crypto.Signature, addr address.Address, input []byte, encodedTs shared.TipSetToken) (bool, error) {
+	addr, err := c.StateAccountKey(ctx, addr, types.EmptyTSK)
+	if err != nil {
+		return false, err
+	}
+
+	err = sigs.Verify(&sig, addr, input)
+	return err == nil, err
+}
+
+// Adds funds with the StorageMinerActor for a storage participant.  Used by both providers and clients.
+func (c *ClientNodeAdapter) AddFunds(ctx context.Context, addr address.Address, amount abi.TokenAmount) (cid.Cid, error) {
+	// (Provider Node API)
+	smsg, err := c.MpoolPushMessage(ctx, &types.Message{
+		To:     miner0.StorageMarketActorAddr,
+		From:   addr,
+		Value:  amount,
+		Method: miner0.MethodsMarket.AddBalance,
+	}, nil)
+	if err != nil {
+		return cid.Undef, err
+	}
+
+	return smsg.Cid(), nil
+}
+
+func (c *ClientNodeAdapter) EnsureFunds(ctx context.Context, addr, wallet address.Address, amount abi.TokenAmount, ts shared.TipSetToken) (cid.Cid, error) {
+	return c.fm.EnsureAvailable(ctx, addr, wallet, amount)
+}
+
+func (c *ClientNodeAdapter) GetBalance(ctx context.Context, addr address.Address, encodedTs shared.TipSetToken) (storagemarket.Balance, error) {
+	tsk, err := types.TipSetKeyFromBytes(encodedTs)
+	if err != nil {
+		return storagemarket.Balance{}, err
+	}
+
+	bal, err := c.StateMarketBalance(ctx, addr, tsk)
+	if err != nil {
+		return storagemarket.Balance{}, err
+	}
+
+	return utils.ToSharedBalance(bal), nil
+}
+
+// ValidatePublishedDeal validates that the provided deal has appeared on chain and references the same ClientDeal
+// returns the Deal id if there is no error
+func (c *ClientNodeAdapter) ValidatePublishedDeal(ctx context.Context, deal storagemarket.ClientDeal) (abi.DealID, error) {
+	log.Infow("DEAL ACCEPTED!")
+
+	pubmsg, err := c.cs.GetMessage(*deal.PublishMessage)
+	if err != nil {
+		return 0, xerrors.Errorf("getting deal publish message: %w", err)
+	}
+
+	mi, err := stmgr.StateMinerInfo(ctx, c.sm, c.cs.GetHeaviestTipSet(), deal.Proposal.Provider)
+	if err != nil {
+		return 0, xerrors.Errorf("getting miner worker failed: %w", err)
+	}
+
+	fromid, err := c.StateLookupID(ctx, pubmsg.From, types.EmptyTSK)
+	if err != nil {
+		return 0, xerrors.Errorf("failed to resolve from msg ID addr: %w", err)
+	}
+
+	if fromid != mi.Worker {
+		return 0, xerrors.Errorf("deal wasn't published by storage provider: from=%s, provider=%s", pubmsg.From, deal.Proposal.Provider)
+	}
+
+	if pubmsg.To != miner0.StorageMarketActorAddr {
+		return 0, xerrors.Errorf("deal publish message wasn't set to StorageMarket actor (to=%s)", pubmsg.To)
+	}
+
+	if pubmsg.Method != miner0.MethodsMarket.PublishStorageDeals {
+		return 0, xerrors.Errorf("deal publish message called incorrect method (method=%s)", pubmsg.Method)
+	}
+
+	var params market0.PublishStorageDealsParams
+	if err := params.UnmarshalCBOR(bytes.NewReader(pubmsg.Params)); err != nil {
+		return 0, err
+	}
+
+	dealIdx := -1
+	for i, storageDeal := range params.Deals {
+		// TODO: make it less hacky
+		sd := storageDeal
+		eq, err := cborutil.Equals(&deal.ClientDealProposal, &sd)
+		if err != nil {
+			return 0, err
+		}
+		if eq {
+			dealIdx = i
+			break
+		}
+	}
+
+	if dealIdx == -1 {
+		return 0, xerrors.Errorf("deal publish didn't contain our deal (message cid: %s)", deal.PublishMessage)
+	}
+
+	// TODO: timeout
+	_, ret, _, err := c.sm.WaitForMessage(ctx, *deal.PublishMessage, build.MessageConfidence)
+	if err != nil {
+		return 0, xerrors.Errorf("waiting for deal publish message: %w", err)
+	}
+	if ret.ExitCode != 0 {
+		return 0, xerrors.Errorf("deal publish failed: exit=%d", ret.ExitCode)
+	}
+
+	var res market0.PublishStorageDealsReturn
+	if err := res.UnmarshalCBOR(bytes.NewReader(ret.Return)); err != nil {
+		return 0, err
+	}
+
+	return res.IDs[dealIdx], nil
+}
+
+const clientOverestimation = 2
+
+func (c *ClientNodeAdapter) DealProviderCollateralBounds(ctx context.Context, size abi.PaddedPieceSize, isVerified bool) (abi.TokenAmount, abi.TokenAmount, error) {
+	bounds, err := c.StateDealProviderCollateralBounds(ctx, size, isVerified, types.EmptyTSK)
+	if err != nil {
+		return abi.TokenAmount{}, abi.TokenAmount{}, err
+	}
+
+	return big.Mul(bounds.Min, big.NewInt(clientOverestimation)), bounds.Max, nil
+}
+
+func (c *ClientNodeAdapter) OnDealSectorCommitted(ctx context.Context, provider address.Address, dealId abi.DealID, cb storagemarket.DealSectorCommittedCallback) error {
+	checkFunc := func(ts *types.TipSet) (done bool, more bool, err error) {
+		sd, err := stmgr.GetStorageDeal(ctx, c.StateManager, dealId, ts)
+
+		if err != nil {
+			// TODO: This may be fine for some errors
+			return false, false, xerrors.Errorf("client: failed to look up deal on chain: %w", err)
+		}
+
+		if sd.State.SectorStartEpoch > 0 {
+			cb(nil)
+			return true, false, nil
+		}
+
+		return false, true, nil
+	}
+
+	called := func(msg *types.Message, rec *types.MessageReceipt, ts *types.TipSet, curH abi.ChainEpoch) (more bool, err error) {
+		defer func() {
+			if err != nil {
+				cb(xerrors.Errorf("handling applied event: %w", err))
+			}
+		}()
+
+		if msg == nil {
+			log.Error("timed out waiting for deal activation... what now?")
+			return false, nil
+		}
+
+		sd, err := stmgr.GetStorageDeal(ctx, c.StateManager, dealId, ts)
+		if err != nil {
+			return false, xerrors.Errorf("failed to look up deal on chain: %w", err)
+		}
+
+		if sd.State.SectorStartEpoch < 1 {
+			return false, xerrors.Errorf("deal wasn't active: deal=%d, parentState=%s, h=%d", dealId, ts.ParentState(), ts.Height())
+		}
+
+		log.Infof("Storage deal %d activated at epoch %d", dealId, sd.State.SectorStartEpoch)
+
+		cb(nil)
+
+		return false, nil
+	}
+
+	revert := func(ctx context.Context, ts *types.TipSet) error {
+		log.Warn("deal activation reverted; TODO: actually handle this!")
+		// TODO: Just go back to DealSealing?
+		return nil
+	}
+
+	var sectorNumber abi.SectorNumber
+	var sectorFound bool
+	matchEvent := func(msg *types.Message) (matchOnce bool, matched bool, err error) {
+		if msg.To != provider {
+			return true, false, nil
+		}
+
+		switch msg.Method {
+		case miner0.MethodsMiner.PreCommitSector:
+			var params miner.SectorPreCommitInfo
+			if err := params.UnmarshalCBOR(bytes.NewReader(msg.Params)); err != nil {
+				return true, false, xerrors.Errorf("unmarshal pre commit: %w", err)
+			}
+
+			for _, did := range params.DealIDs {
+				if did == dealId {
+					sectorNumber = params.SectorNumber
+					sectorFound = true
+					return true, false, nil
+				}
+			}
+
+			return true, false, nil
+		case miner0.MethodsMiner.ProveCommitSector:
+			var params miner.ProveCommitSectorParams
+			if err := params.UnmarshalCBOR(bytes.NewReader(msg.Params)); err != nil {
+				return true, false, xerrors.Errorf("failed to unmarshal prove commit sector params: %w", err)
+			}
+
+			if !sectorFound {
+				return true, false, nil
+			}
+
+			if params.SectorNumber != sectorNumber {
+				return true, false, nil
+			}
+
+			return false, true, nil
+		default:
+			return true, false, nil
+		}
+	}
+
+	if err := c.ev.Called(checkFunc, called, revert, int(build.MessageConfidence+1), events.NoTimeout, matchEvent); err != nil {
+		return xerrors.Errorf("failed to set up called handler: %w", err)
+	}
+
+	return nil
+}
+
+func (c *ClientNodeAdapter) OnDealExpiredOrSlashed(ctx context.Context, dealID abi.DealID, onDealExpired storagemarket.DealExpiredCallback, onDealSlashed storagemarket.DealSlashedCallback) error {
+	head, err := c.ChainHead(ctx)
+	if err != nil {
+		return xerrors.Errorf("client: failed to get chain head: %w", err)
+	}
+
+	sd, err := c.StateMarketStorageDeal(ctx, dealID, head.Key())
+	if err != nil {
+		return xerrors.Errorf("client: failed to look up deal %d on chain: %w", dealID, err)
+	}
+
+	// Called immediately to check if the deal has already expired or been slashed
+	checkFunc := func(ts *types.TipSet) (done bool, more bool, err error) {
+		if ts == nil {
+			// keep listening for events
+			return false, true, nil
+		}
+
+		// Check if the deal has already expired
+		if sd.Proposal.EndEpoch <= ts.Height() {
+			onDealExpired(nil)
+			return true, false, nil
+		}
+
+		// If there is no deal assume it's already been slashed
+		if sd.State.SectorStartEpoch < 0 {
+			onDealSlashed(ts.Height(), nil)
+			return true, false, nil
+		}
+
+		// No events have occurred yet, so return
+		// done: false, more: true (keep listening for events)
+		return false, true, nil
+	}
+
+	// Called when there was a match against the state change we're looking for
+	// and the chain has advanced to the confidence height
+	stateChanged := func(ts *types.TipSet, ts2 *types.TipSet, states events.StateChange, h abi.ChainEpoch) (more bool, err error) {
+		// Check if the deal has already expired
+		if sd.Proposal.EndEpoch <= ts2.Height() {
+			onDealExpired(nil)
+			return false, nil
+		}
+
+		// Timeout waiting for state change
+		if states == nil {
+			log.Error("timed out waiting for deal expiry")
+			return false, nil
+		}
+
+		changedDeals, ok := states.(state.ChangedDeals)
+		if !ok {
+			panic("Expected state.ChangedDeals")
+		}
+
+		deal, ok := changedDeals[dealID]
+		if !ok {
+			// No change to deal
+			return true, nil
+		}
+
+		// Deal was slashed
+		if deal.To == nil {
+			onDealSlashed(ts2.Height(), nil)
+			return false, nil
+		}
+
+		return true, nil
+	}
+
+	// Called when there was a chain reorg and the state change was reverted
+	revert := func(ctx context.Context, ts *types.TipSet) error {
+		// TODO: Is it ok to just ignore this?
+		log.Warn("deal state reverted; TODO: actually handle this!")
+		return nil
+	}
+
+	// Watch for state changes to the deal
+	preds := state.NewStatePredicates(c)
+	dealDiff := preds.OnStorageMarketActorChanged(
+		preds.OnDealStateChanged(
+			preds.DealStateChangedForIDs([]abi.DealID{dealID})))
+	match := func(oldTs, newTs *types.TipSet) (bool, events.StateChange, error) {
+		return dealDiff(ctx, oldTs.Key(), newTs.Key())
+	}
+
+	// Wait until after the end epoch for the deal and then timeout
+	timeout := (sd.Proposal.EndEpoch - head.Height()) + 1
+	if err := c.ev.StateChanged(checkFunc, stateChanged, revert, int(build.MessageConfidence)+1, timeout, match); err != nil {
+		return xerrors.Errorf("failed to set up state changed handler: %w", err)
+	}
+
+	return nil
+}
+
+func (c *ClientNodeAdapter) SignProposal(ctx context.Context, signer address.Address, proposal market0.DealProposal) (*market0.ClientDealProposal, error) {
+	// TODO: output spec signed proposal
+	buf, err := cborutil.Dump(&proposal)
+	if err != nil {
+		return nil, err
+	}
+
+	signer, err = c.StateAccountKey(ctx, signer, types.EmptyTSK)
+	if err != nil {
+		return nil, err
+	}
+
+	sig, err := c.Wallet.Sign(ctx, signer, buf)
+	if err != nil {
+		return nil, err
+	}
+
+	return &market0.ClientDealProposal{
+		Proposal:        proposal,
+		ClientSignature: *sig,
+	}, nil
+}
+
+func (c *ClientNodeAdapter) GetDefaultWalletAddress(ctx context.Context) (address.Address, error) {
+	addr, err := c.Wallet.GetDefault()
+	return addr, err
+}
+
+func (c *ClientNodeAdapter) ValidateAskSignature(ctx context.Context, ask *storagemarket.SignedStorageAsk, encodedTs shared.TipSetToken) (bool, error) {
+	tsk, err := types.TipSetKeyFromBytes(encodedTs)
+	if err != nil {
+		return false, err
+	}
+
+	mi, err := c.StateMinerInfo(ctx, ask.Ask.Miner, tsk)
+	if err != nil {
+		return false, xerrors.Errorf("failed to get worker for miner in ask: %w", err)
+	}
+
+	sigb, err := cborutil.Dump(ask.Ask)
+	if err != nil {
+		return false, xerrors.Errorf("failed to re-serialize ask")
+	}
+
+	ts, err := c.ChainGetTipSet(ctx, tsk)
+	if err != nil {
+		return false, xerrors.Errorf("failed to load tipset")
+	}
+
+	m, err := c.StateManager.ResolveToKeyAddress(ctx, mi.Worker, ts)
+
+	if err != nil {
+		return false, xerrors.Errorf("failed to resolve miner to key address")
+	}
+
+	err = sigs.Verify(ask.Signature, m, sigb)
+	return err == nil, err
+}
+
+func (c *ClientNodeAdapter) GetChainHead(ctx context.Context) (shared.TipSetToken, abi.ChainEpoch, error) {
+	head, err := c.ChainHead(ctx)
+	if err != nil {
+		return nil, 0, err
+	}
+
+	return head.Key().Bytes(), head.Height(), nil
+}
+
+func (c *ClientNodeAdapter) WaitForMessage(ctx context.Context, mcid cid.Cid, cb func(code exitcode.ExitCode, bytes []byte, finalCid cid.Cid, err error) error) error {
+	receipt, err := c.StateWaitMsg(ctx, mcid, build.MessageConfidence)
+	if err != nil {
+		return cb(0, nil, cid.Undef, err)
+	}
+	return cb(receipt.Receipt.ExitCode, receipt.Receipt.Return, receipt.Message, nil)
+}
+
+func (c *ClientNodeAdapter) GetMinerInfo(ctx context.Context, addr address.Address, encodedTs shared.TipSetToken) (*storagemarket.StorageProviderInfo, error) {
+	tsk, err := types.TipSetKeyFromBytes(encodedTs)
+	if err != nil {
+		return nil, err
+	}
+	mi, err := c.StateMinerInfo(ctx, addr, tsk)
+	if err != nil {
+		return nil, err
+	}
+
+	out := utils.NewStorageProviderInfo(addr, mi.Worker, mi.SectorSize, *mi.PeerId, mi.Multiaddrs)
+	return &out, nil
+}
+
+func (c *ClientNodeAdapter) SignBytes(ctx context.Context, signer address.Address, b []byte) (*crypto.Signature, error) {
+	signer, err := c.StateAccountKey(ctx, signer, types.EmptyTSK)
+	if err != nil {
+		return nil, err
+	}
+
+	localSignature, err := c.Wallet.Sign(ctx, signer, b)
+	if err != nil {
+		return nil, err
+	}
+	return localSignature, nil
+}
+
+var _ storagemarket.StorageClientNode = &ClientNodeAdapter{}
diff --git a/markets/storageadapter/provider.go b/markets/storageadapter/provider.go
new file mode 100644
index 000000000..9f610d76a
--- /dev/null
+++ b/markets/storageadapter/provider.go
@@ -0,0 +1,472 @@
+package storageadapter
+
+// this file implements storagemarket.StorageProviderNode
+
+import (
+	"bytes"
+	"context"
+	"io"
+	"time"
+
+	"github.com/ipfs/go-cid"
+	logging "github.com/ipfs/go-log/v2"
+	"golang.org/x/xerrors"
+
+	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
+	market0 "github.com/filecoin-project/specs-actors/actors/builtin/market"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-fil-markets/shared"
+	"github.com/filecoin-project/go-fil-markets/storagemarket"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/crypto"
+	"github.com/filecoin-project/go-state-types/exitcode"
+
+	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/actors"
+	"github.com/filecoin-project/lotus/chain/events"
+
+	"github.com/filecoin-project/lotus/chain/actors/builtin/market"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
+	"github.com/filecoin-project/lotus/chain/events/state"
+	"github.com/filecoin-project/lotus/chain/types"
+	sealing "github.com/filecoin-project/lotus/extern/storage-sealing"
+	"github.com/filecoin-project/lotus/lib/sigs"
+	"github.com/filecoin-project/lotus/markets/utils"
+	"github.com/filecoin-project/lotus/node/modules/dtypes"
+	"github.com/filecoin-project/lotus/storage/sectorblocks"
+)
+
+var addPieceRetryWait = 5 * time.Minute
+var addPieceRetryTimeout = 6 * time.Hour
+var log = logging.Logger("storageadapter")
+
+type ProviderNodeAdapter struct {
+	api.FullNode
+
+	// this goes away with the data transfer module
+	dag dtypes.StagingDAG
+
+	secb *sectorblocks.SectorBlocks
+	ev   *events.Events
+}
+
+func NewProviderNodeAdapter(dag dtypes.StagingDAG, secb *sectorblocks.SectorBlocks, full api.FullNode) storagemarket.StorageProviderNode {
+	return &ProviderNodeAdapter{
+		FullNode: full,
+		dag:      dag,
+		secb:     secb,
+		ev:       events.NewEvents(context.TODO(), full),
+	}
+}
+
+func (n *ProviderNodeAdapter) PublishDeals(ctx context.Context, deal storagemarket.MinerDeal) (cid.Cid, error) {
+	log.Info("publishing deal")
+
+	mi, err := n.StateMinerInfo(ctx, deal.Proposal.Provider, types.EmptyTSK)
+	if err != nil {
+		return cid.Undef, err
+	}
+
+	params, err := actors.SerializeParams(&market0.PublishStorageDealsParams{
+		Deals: []market0.ClientDealProposal{deal.ClientDealProposal},
+	})
+
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("serializing PublishStorageDeals params failed: %w", err)
+	}
+
+	// TODO: We may want this to happen after fetching data
+	smsg, err := n.MpoolPushMessage(ctx, &types.Message{
+		To:     market.Address,
+		From:   mi.Worker,
+		Value:  types.NewInt(0),
+		Method: builtin0.MethodsMarket.PublishStorageDeals,
+		Params: params,
+	}, nil)
+	if err != nil {
+		return cid.Undef, err
+	}
+	return smsg.Cid(), nil
+}
+
+func (n *ProviderNodeAdapter) OnDealComplete(ctx context.Context, deal storagemarket.MinerDeal, pieceSize abi.UnpaddedPieceSize, pieceData io.Reader) (*storagemarket.PackingResult, error) {
+	if deal.PublishCid == nil {
+		return nil, xerrors.Errorf("deal.PublishCid can't be nil")
+	}
+
+	sdInfo := sealing.DealInfo{
+		DealID:     deal.DealID,
+		PublishCid: deal.PublishCid,
+		DealSchedule: sealing.DealSchedule{
+			StartEpoch: deal.ClientDealProposal.Proposal.StartEpoch,
+			EndEpoch:   deal.ClientDealProposal.Proposal.EndEpoch,
+		},
+		KeepUnsealed: deal.FastRetrieval,
+	}
+
+	p, offset, err := n.secb.AddPiece(ctx, pieceSize, pieceData, sdInfo)
+	curTime := time.Now()
+	for time.Since(curTime) < addPieceRetryTimeout {
+		if !xerrors.Is(err, sealing.ErrTooManySectorsSealing) {
+			if err != nil {
+				log.Errorf("failed to addPiece for deal %d, err: %w", deal.DealID, err)
+			}
+			break
+		}
+		select {
+		case <-time.After(addPieceRetryWait):
+			p, offset, err = n.secb.AddPiece(ctx, pieceSize, pieceData, sdInfo)
+		case <-ctx.Done():
+			return nil, xerrors.New("context expired while waiting to retry AddPiece")
+		}
+	}
+
+	if err != nil {
+		return nil, xerrors.Errorf("AddPiece failed: %s", err)
+	}
+	log.Warnf("New Deal: deal %d", deal.DealID)
+
+	return &storagemarket.PackingResult{
+		SectorNumber: p,
+		Offset:       offset,
+		Size:         pieceSize.Padded(),
+	}, nil
+}
+
+func (n *ProviderNodeAdapter) VerifySignature(ctx context.Context, sig crypto.Signature, addr address.Address, input []byte, encodedTs shared.TipSetToken) (bool, error) {
+	addr, err := n.StateAccountKey(ctx, addr, types.EmptyTSK)
+	if err != nil {
+		return false, err
+	}
+
+	err = sigs.Verify(&sig, addr, input)
+	return err == nil, err
+}
+
+func (n *ProviderNodeAdapter) GetMinerWorkerAddress(ctx context.Context, miner address.Address, tok shared.TipSetToken) (address.Address, error) {
+	tsk, err := types.TipSetKeyFromBytes(tok)
+	if err != nil {
+		return address.Undef, err
+	}
+
+	mi, err := n.StateMinerInfo(ctx, miner, tsk)
+	if err != nil {
+		return address.Address{}, err
+	}
+	return mi.Worker, nil
+}
+
+func (n *ProviderNodeAdapter) SignBytes(ctx context.Context, signer address.Address, b []byte) (*crypto.Signature, error) {
+	signer, err := n.StateAccountKey(ctx, signer, types.EmptyTSK)
+	if err != nil {
+		return nil, err
+	}
+
+	localSignature, err := n.WalletSign(ctx, signer, b)
+	if err != nil {
+		return nil, err
+	}
+	return localSignature, nil
+}
+
+func (n *ProviderNodeAdapter) EnsureFunds(ctx context.Context, addr, wallet address.Address, amt abi.TokenAmount, encodedTs shared.TipSetToken) (cid.Cid, error) {
+	return n.MarketEnsureAvailable(ctx, addr, wallet, amt)
+}
+
+// Adds funds with the StorageMinerActor for a storage participant.  Used by both providers and clients.
+func (n *ProviderNodeAdapter) AddFunds(ctx context.Context, addr address.Address, amount abi.TokenAmount) (cid.Cid, error) {
+	// (Provider Node API)
+	smsg, err := n.MpoolPushMessage(ctx, &types.Message{
+		To:     market.Address,
+		From:   addr,
+		Value:  amount,
+		Method: builtin0.MethodsMarket.AddBalance,
+	}, nil)
+	if err != nil {
+		return cid.Undef, err
+	}
+
+	return smsg.Cid(), nil
+}
+
+func (n *ProviderNodeAdapter) GetBalance(ctx context.Context, addr address.Address, encodedTs shared.TipSetToken) (storagemarket.Balance, error) {
+	tsk, err := types.TipSetKeyFromBytes(encodedTs)
+	if err != nil {
+		return storagemarket.Balance{}, err
+	}
+
+	bal, err := n.StateMarketBalance(ctx, addr, tsk)
+	if err != nil {
+		return storagemarket.Balance{}, err
+	}
+
+	return utils.ToSharedBalance(bal), nil
+}
+
+// TODO: why doesnt this method take in a sector ID?
+func (n *ProviderNodeAdapter) LocatePieceForDealWithinSector(ctx context.Context, dealID abi.DealID, encodedTs shared.TipSetToken) (sectorID abi.SectorNumber, offset abi.PaddedPieceSize, length abi.PaddedPieceSize, err error) {
+	refs, err := n.secb.GetRefs(dealID)
+	if err != nil {
+		return 0, 0, 0, err
+	}
+	if len(refs) == 0 {
+		return 0, 0, 0, xerrors.New("no sector information for deal ID")
+	}
+
+	// TODO: better strategy (e.g. look for already unsealed)
+	var best api.SealedRef
+	var bestSi sealing.SectorInfo
+	for _, r := range refs {
+		si, err := n.secb.Miner.GetSectorInfo(r.SectorID)
+		if err != nil {
+			return 0, 0, 0, xerrors.Errorf("getting sector info: %w", err)
+		}
+		if si.State == sealing.Proving {
+			best = r
+			bestSi = si
+			break
+		}
+	}
+	if bestSi.State == sealing.UndefinedSectorState {
+		return 0, 0, 0, xerrors.New("no sealed sector found")
+	}
+	return best.SectorID, best.Offset, best.Size.Padded(), nil
+}
+
+func (n *ProviderNodeAdapter) DealProviderCollateralBounds(ctx context.Context, size abi.PaddedPieceSize, isVerified bool) (abi.TokenAmount, abi.TokenAmount, error) {
+	bounds, err := n.StateDealProviderCollateralBounds(ctx, size, isVerified, types.EmptyTSK)
+	if err != nil {
+		return abi.TokenAmount{}, abi.TokenAmount{}, err
+	}
+
+	return bounds.Min, bounds.Max, nil
+}
+
+func (n *ProviderNodeAdapter) OnDealSectorCommitted(ctx context.Context, provider address.Address, dealID abi.DealID, cb storagemarket.DealSectorCommittedCallback) error {
+	checkFunc := func(ts *types.TipSet) (done bool, more bool, err error) {
+		sd, err := n.StateMarketStorageDeal(ctx, dealID, ts.Key())
+
+		if err != nil {
+			// TODO: This may be fine for some errors
+			return false, false, xerrors.Errorf("failed to look up deal on chain: %w", err)
+		}
+
+		if sd.State.SectorStartEpoch > 0 {
+			cb(nil)
+			return true, false, nil
+		}
+
+		return false, true, nil
+	}
+
+	called := func(msg *types.Message, rec *types.MessageReceipt, ts *types.TipSet, curH abi.ChainEpoch) (more bool, err error) {
+		defer func() {
+			if err != nil {
+				cb(xerrors.Errorf("handling applied event: %w", err))
+			}
+		}()
+
+		if msg == nil {
+			log.Error("timed out waiting for deal activation... what now?")
+			return false, nil
+		}
+
+		sd, err := n.StateMarketStorageDeal(ctx, dealID, ts.Key())
+		if err != nil {
+			return false, xerrors.Errorf("failed to look up deal on chain: %w", err)
+		}
+
+		if sd.State.SectorStartEpoch < 1 {
+			return false, xerrors.Errorf("deal wasn't active: deal=%d, parentState=%s, h=%d", dealID, ts.ParentState(), ts.Height())
+		}
+
+		log.Infof("Storage deal %d activated at epoch %d", dealID, sd.State.SectorStartEpoch)
+
+		cb(nil)
+
+		return false, nil
+	}
+
+	revert := func(ctx context.Context, ts *types.TipSet) error {
+		log.Warn("deal activation reverted; TODO: actually handle this!")
+		// TODO: Just go back to DealSealing?
+		return nil
+	}
+
+	var sectorNumber abi.SectorNumber
+	var sectorFound bool
+
+	matchEvent := func(msg *types.Message) (matchOnce bool, matched bool, err error) {
+		if msg.To != provider {
+			return true, false, nil
+		}
+
+		switch msg.Method {
+		case builtin0.MethodsMiner.PreCommitSector:
+			var params miner.SectorPreCommitInfo
+			if err := params.UnmarshalCBOR(bytes.NewReader(msg.Params)); err != nil {
+				return true, false, xerrors.Errorf("unmarshal pre commit: %w", err)
+			}
+
+			for _, did := range params.DealIDs {
+				if did == dealID {
+					sectorNumber = params.SectorNumber
+					sectorFound = true
+					return true, false, nil
+				}
+			}
+
+			return true, false, nil
+		case builtin0.MethodsMiner.ProveCommitSector:
+			var params miner.ProveCommitSectorParams
+			if err := params.UnmarshalCBOR(bytes.NewReader(msg.Params)); err != nil {
+				return true, false, xerrors.Errorf("failed to unmarshal prove commit sector params: %w", err)
+			}
+
+			if !sectorFound {
+				return true, false, nil
+			}
+
+			if params.SectorNumber != sectorNumber {
+				return true, false, nil
+			}
+
+			return false, true, nil
+		default:
+			return true, false, nil
+		}
+
+	}
+
+	if err := n.ev.Called(checkFunc, called, revert, int(build.MessageConfidence+1), events.NoTimeout, matchEvent); err != nil {
+		return xerrors.Errorf("failed to set up called handler: %w", err)
+	}
+
+	return nil
+}
+
+func (n *ProviderNodeAdapter) GetChainHead(ctx context.Context) (shared.TipSetToken, abi.ChainEpoch, error) {
+	head, err := n.ChainHead(ctx)
+	if err != nil {
+		return nil, 0, err
+	}
+
+	return head.Key().Bytes(), head.Height(), nil
+}
+
+func (n *ProviderNodeAdapter) WaitForMessage(ctx context.Context, mcid cid.Cid, cb func(code exitcode.ExitCode, bytes []byte, finalCid cid.Cid, err error) error) error {
+	receipt, err := n.StateWaitMsg(ctx, mcid, 2*build.MessageConfidence)
+	if err != nil {
+		return cb(0, nil, cid.Undef, err)
+	}
+	return cb(receipt.Receipt.ExitCode, receipt.Receipt.Return, receipt.Message, nil)
+}
+
+func (n *ProviderNodeAdapter) GetDataCap(ctx context.Context, addr address.Address, encodedTs shared.TipSetToken) (*abi.StoragePower, error) {
+	tsk, err := types.TipSetKeyFromBytes(encodedTs)
+	if err != nil {
+		return nil, err
+	}
+
+	sp, err := n.StateVerifiedClientStatus(ctx, addr, tsk)
+	return sp, err
+}
+
+func (n *ProviderNodeAdapter) OnDealExpiredOrSlashed(ctx context.Context, dealID abi.DealID, onDealExpired storagemarket.DealExpiredCallback, onDealSlashed storagemarket.DealSlashedCallback) error {
+	head, err := n.ChainHead(ctx)
+	if err != nil {
+		return xerrors.Errorf("client: failed to get chain head: %w", err)
+	}
+
+	sd, err := n.StateMarketStorageDeal(ctx, dealID, head.Key())
+	if err != nil {
+		return xerrors.Errorf("client: failed to look up deal %d on chain: %w", dealID, err)
+	}
+
+	// Called immediately to check if the deal has already expired or been slashed
+	checkFunc := func(ts *types.TipSet) (done bool, more bool, err error) {
+		if ts == nil {
+			// keep listening for events
+			return false, true, nil
+		}
+
+		// Check if the deal has already expired
+		if sd.Proposal.EndEpoch <= ts.Height() {
+			onDealExpired(nil)
+			return true, false, nil
+		}
+
+		// If there is no deal assume it's already been slashed
+		if sd.State.SectorStartEpoch < 0 {
+			onDealSlashed(ts.Height(), nil)
+			return true, false, nil
+		}
+
+		// No events have occurred yet, so return
+		// done: false, more: true (keep listening for events)
+		return false, true, nil
+	}
+
+	// Called when there was a match against the state change we're looking for
+	// and the chain has advanced to the confidence height
+	stateChanged := func(ts *types.TipSet, ts2 *types.TipSet, states events.StateChange, h abi.ChainEpoch) (more bool, err error) {
+		// Check if the deal has already expired
+		if sd.Proposal.EndEpoch <= ts2.Height() {
+			onDealExpired(nil)
+			return false, nil
+		}
+
+		// Timeout waiting for state change
+		if states == nil {
+			log.Error("timed out waiting for deal expiry")
+			return false, nil
+		}
+
+		changedDeals, ok := states.(state.ChangedDeals)
+		if !ok {
+			panic("Expected state.ChangedDeals")
+		}
+
+		deal, ok := changedDeals[dealID]
+		if !ok {
+			// No change to deal
+			return true, nil
+		}
+
+		// Deal was slashed
+		if deal.To == nil {
+			onDealSlashed(ts2.Height(), nil)
+			return false, nil
+		}
+
+		return true, nil
+	}
+
+	// Called when there was a chain reorg and the state change was reverted
+	revert := func(ctx context.Context, ts *types.TipSet) error {
+		// TODO: Is it ok to just ignore this?
+		log.Warn("deal state reverted; TODO: actually handle this!")
+		return nil
+	}
+
+	// Watch for state changes to the deal
+	preds := state.NewStatePredicates(n)
+	dealDiff := preds.OnStorageMarketActorChanged(
+		preds.OnDealStateChanged(
+			preds.DealStateChangedForIDs([]abi.DealID{dealID})))
+	match := func(oldTs, newTs *types.TipSet) (bool, events.StateChange, error) {
+		return dealDiff(ctx, oldTs.Key(), newTs.Key())
+	}
+
+	// Wait until after the end epoch for the deal and then timeout
+	timeout := (sd.Proposal.EndEpoch - head.Height()) + 1
+	if err := n.ev.StateChanged(checkFunc, stateChanged, revert, int(build.MessageConfidence)+1, timeout, match); err != nil {
+		return xerrors.Errorf("failed to set up state changed handler: %w", err)
+	}
+
+	return nil
+}
+
+var _ storagemarket.StorageProviderNode = &ProviderNodeAdapter{}
diff --git a/markets/utils/converters.go b/markets/utils/converters.go
new file mode 100644
index 000000000..4a3d21140
--- /dev/null
+++ b/markets/utils/converters.go
@@ -0,0 +1,38 @@
+package utils
+
+import (
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/big"
+	"github.com/filecoin-project/lotus/api"
+	peer "github.com/libp2p/go-libp2p-core/peer"
+	"github.com/multiformats/go-multiaddr"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-fil-markets/storagemarket"
+)
+
+func NewStorageProviderInfo(address address.Address, miner address.Address, sectorSize abi.SectorSize, peer peer.ID, addrs []abi.Multiaddrs) storagemarket.StorageProviderInfo {
+	multiaddrs := make([]multiaddr.Multiaddr, 0, len(addrs))
+	for _, a := range addrs {
+		maddr, err := multiaddr.NewMultiaddrBytes(a)
+		if err != nil {
+			return storagemarket.StorageProviderInfo{}
+		}
+		multiaddrs = append(multiaddrs, maddr)
+	}
+
+	return storagemarket.StorageProviderInfo{
+		Address:    address,
+		Worker:     miner,
+		SectorSize: uint64(sectorSize),
+		PeerID:     peer,
+		Addrs:      multiaddrs,
+	}
+}
+
+func ToSharedBalance(bal api.MarketBalance) storagemarket.Balance {
+	return storagemarket.Balance{
+		Locked:    bal.Locked,
+		Available: big.Sub(bal.Escrow, bal.Locked),
+	}
+}
diff --git a/metrics/metrics.go b/metrics/metrics.go
new file mode 100644
index 000000000..5dd865263
--- /dev/null
+++ b/metrics/metrics.go
@@ -0,0 +1,170 @@
+package metrics
+
+import (
+	"time"
+
+	"go.opencensus.io/stats"
+	"go.opencensus.io/stats/view"
+	"go.opencensus.io/tag"
+
+	rpcmetrics "github.com/filecoin-project/go-jsonrpc/metrics"
+)
+
+// Distribution
+var defaultMillisecondsDistribution = view.Distribution(0.01, 0.05, 0.1, 0.3, 0.6, 0.8, 1, 2, 3, 4, 5, 6, 8, 10, 13, 16, 20, 25, 30, 40, 50, 65, 80, 100, 130, 160, 200, 250, 300, 400, 500, 650, 800, 1000, 2000, 5000, 10000, 20000, 50000, 100000)
+
+// Global Tags
+var (
+	Version, _      = tag.NewKey("version")
+	Commit, _       = tag.NewKey("commit")
+	PeerID, _       = tag.NewKey("peer_id")
+	FailureType, _  = tag.NewKey("failure_type")
+	Local, _        = tag.NewKey("local")
+	MessageFrom, _  = tag.NewKey("message_from")
+	MessageTo, _    = tag.NewKey("message_to")
+	MessageNonce, _ = tag.NewKey("message_nonce")
+	ReceivedFrom, _ = tag.NewKey("received_from")
+)
+
+// Measures
+var (
+	LotusInfo                           = stats.Int64("info", "Arbitrary counter to tag lotus info to", stats.UnitDimensionless)
+	ChainNodeHeight                     = stats.Int64("chain/node_height", "Current Height of the node", stats.UnitDimensionless)
+	ChainNodeHeightExpected             = stats.Int64("chain/node_height_expected", "Expected Height of the node", stats.UnitDimensionless)
+	ChainNodeWorkerHeight               = stats.Int64("chain/node_worker_height", "Current Height of workers on the node", stats.UnitDimensionless)
+	MessagePublished                    = stats.Int64("message/published", "Counter for total locally published messages", stats.UnitDimensionless)
+	MessageReceived                     = stats.Int64("message/received", "Counter for total received messages", stats.UnitDimensionless)
+	MessageValidationFailure            = stats.Int64("message/failure", "Counter for message validation failures", stats.UnitDimensionless)
+	MessageValidationSuccess            = stats.Int64("message/success", "Counter for message validation successes", stats.UnitDimensionless)
+	BlockPublished                      = stats.Int64("block/published", "Counter for total locally published blocks", stats.UnitDimensionless)
+	BlockReceived                       = stats.Int64("block/received", "Counter for total received blocks", stats.UnitDimensionless)
+	BlockValidationFailure              = stats.Int64("block/failure", "Counter for block validation failures", stats.UnitDimensionless)
+	BlockValidationSuccess              = stats.Int64("block/success", "Counter for block validation successes", stats.UnitDimensionless)
+	BlockValidationDurationMilliseconds = stats.Float64("block/validation_ms", "Duration for Block Validation in ms", stats.UnitMilliseconds)
+	PeerCount                           = stats.Int64("peer/count", "Current number of FIL peers", stats.UnitDimensionless)
+	PubsubPublishMessage                = stats.Int64("pubsub/published", "Counter for total published messages", stats.UnitDimensionless)
+	PubsubDeliverMessage                = stats.Int64("pubsub/delivered", "Counter for total delivered messages", stats.UnitDimensionless)
+	PubsubRejectMessage                 = stats.Int64("pubsub/rejected", "Counter for total rejected messages", stats.UnitDimensionless)
+	PubsubDuplicateMessage              = stats.Int64("pubsub/duplicate", "Counter for total duplicate messages", stats.UnitDimensionless)
+	PubsubRecvRPC                       = stats.Int64("pubsub/recv_rpc", "Counter for total received RPCs", stats.UnitDimensionless)
+	PubsubSendRPC                       = stats.Int64("pubsub/send_rpc", "Counter for total sent RPCs", stats.UnitDimensionless)
+	PubsubDropRPC                       = stats.Int64("pubsub/drop_rpc", "Counter for total dropped RPCs", stats.UnitDimensionless)
+)
+
+var (
+	InfoView = &view.View{
+		Name:        "info",
+		Description: "Lotus node information",
+		Measure:     LotusInfo,
+		Aggregation: view.LastValue(),
+		TagKeys:     []tag.Key{Version, Commit},
+	}
+	ChainNodeHeightView = &view.View{
+		Measure:     ChainNodeHeight,
+		Aggregation: view.LastValue(),
+	}
+	ChainNodeHeightExpectedView = &view.View{
+		Measure:     ChainNodeHeightExpected,
+		Aggregation: view.LastValue(),
+	}
+	ChainNodeWorkerHeightView = &view.View{
+		Measure:     ChainNodeWorkerHeight,
+		Aggregation: view.LastValue(),
+	}
+	BlockReceivedView = &view.View{
+		Measure:     BlockReceived,
+		Aggregation: view.Count(),
+	}
+	BlockValidationFailureView = &view.View{
+		Measure:     BlockValidationFailure,
+		Aggregation: view.Count(),
+		TagKeys:     []tag.Key{FailureType},
+	}
+	BlockValidationSuccessView = &view.View{
+		Measure:     BlockValidationSuccess,
+		Aggregation: view.Count(),
+	}
+	BlockValidationDurationView = &view.View{
+		Measure:     BlockValidationDurationMilliseconds,
+		Aggregation: defaultMillisecondsDistribution,
+	}
+	MessagePublishedView = &view.View{
+		Measure:     MessagePublished,
+		Aggregation: view.Count(),
+	}
+	MessageReceivedView = &view.View{
+		Measure:     MessageReceived,
+		Aggregation: view.Count(),
+	}
+	MessageValidationFailureView = &view.View{
+		Measure:     MessageValidationFailure,
+		Aggregation: view.Count(),
+		TagKeys:     []tag.Key{FailureType, Local},
+	}
+	MessageValidationSuccessView = &view.View{
+		Measure:     MessageValidationSuccess,
+		Aggregation: view.Count(),
+	}
+	PeerCountView = &view.View{
+		Measure:     PeerCount,
+		Aggregation: view.LastValue(),
+	}
+	PubsubPublishMessageView = &view.View{
+		Measure:     PubsubPublishMessage,
+		Aggregation: view.Count(),
+	}
+	PubsubDeliverMessageView = &view.View{
+		Measure:     PubsubDeliverMessage,
+		Aggregation: view.Count(),
+	}
+	PubsubRejectMessageView = &view.View{
+		Measure:     PubsubRejectMessage,
+		Aggregation: view.Count(),
+	}
+	PubsubDuplicateMessageView = &view.View{
+		Measure:     PubsubDuplicateMessage,
+		Aggregation: view.Count(),
+	}
+	PubsubRecvRPCView = &view.View{
+		Measure:     PubsubRecvRPC,
+		Aggregation: view.Count(),
+	}
+	PubsubSendRPCView = &view.View{
+		Measure:     PubsubSendRPC,
+		Aggregation: view.Count(),
+	}
+	PubsubDropRPCView = &view.View{
+		Measure:     PubsubDropRPC,
+		Aggregation: view.Count(),
+	}
+)
+
+// DefaultViews is an array of OpenCensus views for metric gathering purposes
+var DefaultViews = append([]*view.View{
+	InfoView,
+	ChainNodeHeightView,
+	ChainNodeHeightExpectedView,
+	ChainNodeWorkerHeightView,
+	BlockReceivedView,
+	BlockValidationFailureView,
+	BlockValidationSuccessView,
+	BlockValidationDurationView,
+	MessagePublishedView,
+	MessageReceivedView,
+	MessageValidationFailureView,
+	MessageValidationSuccessView,
+	PeerCountView,
+	PubsubPublishMessageView,
+	PubsubDeliverMessageView,
+	PubsubRejectMessageView,
+	PubsubDuplicateMessageView,
+	PubsubRecvRPCView,
+	PubsubSendRPCView,
+	PubsubDropRPCView,
+},
+	rpcmetrics.DefaultViews...)
+
+// SinceInMilliseconds returns the duration of time since the provide time as a float64.
+func SinceInMilliseconds(startTime time.Time) float64 {
+	return float64(time.Since(startTime).Nanoseconds()) / 1e6
+}
diff --git a/miner/miner.go b/miner/miner.go
index 4c6c3d2a0..1b79f5245 100644
--- a/miner/miner.go
+++ b/miner/miner.go
@@ -1,38 +1,80 @@
 package miner
 
 import (
+	"bytes"
 	"context"
+	"crypto/rand"
+	"encoding/binary"
+	"fmt"
 	"sync"
 	"time"
 
+	proof0 "github.com/filecoin-project/specs-actors/actors/runtime/proof"
+
+	"github.com/filecoin-project/lotus/chain/gen/slashfilter"
+
 	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/crypto"
+	lru "github.com/hashicorp/golang-lru"
+
 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/build"
-	"github.com/filecoin-project/lotus/chain/actors"
 	"github.com/filecoin-project/lotus/chain/gen"
+	"github.com/filecoin-project/lotus/chain/messagepool/gasguess"
+	"github.com/filecoin-project/lotus/chain/store"
 	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/journal"
 
-	logging "github.com/ipfs/go-log"
+	logging "github.com/ipfs/go-log/v2"
 	"go.opencensus.io/trace"
 	"golang.org/x/xerrors"
 )
 
-const MaxMessagesPerBlock = 4000
-
 var log = logging.Logger("miner")
 
-type waitFunc func(ctx context.Context, baseTime uint64) error
+// Journal event types.
+const (
+	evtTypeBlockMined = iota
+)
+
+// returns a callback reporting whether we mined a blocks in this round
+type waitFunc func(ctx context.Context, baseTime uint64) (func(bool, abi.ChainEpoch, error), abi.ChainEpoch, error)
+
+func randTimeOffset(width time.Duration) time.Duration {
+	buf := make([]byte, 8)
+	rand.Reader.Read(buf) //nolint:errcheck
+	val := time.Duration(binary.BigEndian.Uint64(buf) % uint64(width))
+
+	return val - (width / 2)
+}
+
+func NewMiner(api api.FullNode, epp gen.WinningPoStProver, addr address.Address, sf *slashfilter.SlashFilter) *Miner {
+	arc, err := lru.NewARC(10000)
+	if err != nil {
+		panic(err)
+	}
 
-func NewMiner(api api.FullNode, epp gen.ElectionPoStProver) *Miner {
 	return &Miner{
-		api: api,
-		epp: epp,
-		waitFunc: func(ctx context.Context, baseTime uint64) error {
+		api:     api,
+		epp:     epp,
+		address: addr,
+		waitFunc: func(ctx context.Context, baseTime uint64) (func(bool, abi.ChainEpoch, error), abi.ChainEpoch, error) {
 			// Wait around for half the block time in case other parents come in
-			deadline := baseTime + build.PropagationDelay
-			time.Sleep(time.Until(time.Unix(int64(deadline), 0)))
+			deadline := baseTime + build.PropagationDelaySecs
+			baseT := time.Unix(int64(deadline), 0)
 
-			return nil
+			baseT = baseT.Add(randTimeOffset(time.Second))
+
+			build.Clock.Sleep(build.Clock.Until(baseT))
+
+			return func(bool, abi.ChainEpoch, error) {}, 0, nil
+		},
+
+		sf:                sf,
+		minedBlockHeights: arc,
+		evtTypes: [...]journal.EventType{
+			evtTypeBlockMined: journal.J.RegisterEventType("miner", "block_mined"),
 		},
 	}
 }
@@ -40,86 +82,66 @@ func NewMiner(api api.FullNode, epp gen.ElectionPoStProver) *Miner {
 type Miner struct {
 	api api.FullNode
 
-	epp gen.ElectionPoStProver
+	epp gen.WinningPoStProver
 
-	lk        sync.Mutex
-	addresses []address.Address
-	stop      chan struct{}
-	stopping  chan struct{}
+	lk       sync.Mutex
+	address  address.Address
+	stop     chan struct{}
+	stopping chan struct{}
 
 	waitFunc waitFunc
 
 	lastWork *MiningBase
+
+	sf                *slashfilter.SlashFilter
+	minedBlockHeights *lru.ARCCache
+
+	evtTypes [1]journal.EventType
 }
 
-func (m *Miner) Addresses() ([]address.Address, error) {
+func (m *Miner) Address() address.Address {
 	m.lk.Lock()
 	defer m.lk.Unlock()
 
-	out := make([]address.Address, len(m.addresses))
-	copy(out, m.addresses)
-
-	return out, nil
+	return m.address
 }
 
-func (m *Miner) Register(addr address.Address) error {
+func (m *Miner) Start(ctx context.Context) error {
 	m.lk.Lock()
 	defer m.lk.Unlock()
-
-	if len(m.addresses) > 0 {
-		for _, a := range m.addresses {
-			if a == addr {
-				log.Warnf("miner.Register called more than once for actor '%s'", addr)
-				return xerrors.Errorf("miner.Register called more than once for actor '%s'", addr)
-			}
-		}
+	if m.stop != nil {
+		return fmt.Errorf("miner already started")
 	}
-
-	m.addresses = append(m.addresses, addr)
-	if len(m.addresses) == 1 {
-		m.stop = make(chan struct{})
-		go m.mine(context.TODO())
-	}
-
+	m.stop = make(chan struct{})
+	go m.mine(context.TODO())
 	return nil
 }
 
-func (m *Miner) Unregister(ctx context.Context, addr address.Address) error {
+func (m *Miner) Stop(ctx context.Context) error {
 	m.lk.Lock()
-	defer m.lk.Unlock()
-	if len(m.addresses) == 0 {
-		return xerrors.New("no addresses registered")
+
+	m.stopping = make(chan struct{})
+	stopping := m.stopping
+	close(m.stop)
+
+	m.lk.Unlock()
+
+	select {
+	case <-stopping:
+		return nil
+	case <-ctx.Done():
+		return ctx.Err()
 	}
+}
 
-	idx := -1
-
-	for i, a := range m.addresses {
-		if a == addr {
-			idx = i
-			break
-		}
+func (m *Miner) niceSleep(d time.Duration) bool {
+	select {
+	case <-build.Clock.After(d):
+		return true
+	case <-m.stop:
+		log.Infow("received interrupt while trying to sleep in mining cycle")
+		return false
 	}
-	if idx == -1 {
-		return xerrors.New("unregister: address not found")
-	}
-
-	m.addresses[idx] = m.addresses[len(m.addresses)-1]
-	m.addresses = m.addresses[:len(m.addresses)-1]
-
-	// Unregistering last address, stop mining first
-	if len(m.addresses) == 0 && m.stop != nil {
-		m.stopping = make(chan struct{})
-		stopping := m.stopping
-		close(m.stop)
-
-		select {
-		case <-stopping:
-		case <-ctx.Done():
-			return ctx.Err()
-		}
-	}
-
-	return nil
 }
 
 func (m *Miner) mine(ctx context.Context) {
@@ -127,8 +149,7 @@ func (m *Miner) mine(ctx context.Context) {
 	defer span.End()
 
 	var lastBase MiningBase
-
-eventLoop:
+minerLoop:
 	for {
 		select {
 		case <-m.stop:
@@ -141,99 +162,170 @@ eventLoop:
 		default:
 		}
 
-		m.lk.Lock()
-		addrs := m.addresses
-		m.lk.Unlock()
+		var base *MiningBase
+		var onDone func(bool, abi.ChainEpoch, error)
+		var injectNulls abi.ChainEpoch
 
-		prebase, err := m.GetBestMiningCandidate(ctx)
-		if err != nil {
-			log.Errorf("failed to get best mining candidate: %s", err)
-			time.Sleep(time.Second * 5)
+		for {
+			prebase, err := m.GetBestMiningCandidate(ctx)
+			if err != nil {
+				log.Errorf("failed to get best mining candidate: %s", err)
+				if !m.niceSleep(time.Second * 5) {
+					continue minerLoop
+				}
+				continue
+			}
+
+			if base != nil && base.TipSet.Height() == prebase.TipSet.Height() && base.NullRounds == prebase.NullRounds {
+				base = prebase
+				break
+			}
+			if base != nil {
+				onDone(false, 0, nil)
+			}
+
+			// TODO: need to change the orchestration here. the problem is that
+			// we are waiting *after* we enter this loop and selecta mining
+			// candidate, which is almost certain to change in multiminer
+			// tests. Instead, we should block before entering the loop, so
+			// that when the test 'MineOne' function is triggered, we pull our
+			// best mining candidate at that time.
+
+			// Wait until propagation delay period after block we plan to mine on
+			onDone, injectNulls, err = m.waitFunc(ctx, prebase.TipSet.MinTimestamp())
+			if err != nil {
+				log.Error(err)
+				continue
+			}
+
+			// just wait for the beacon entry to become available before we select our final mining base
+			_, err = m.api.BeaconGetEntry(ctx, prebase.TipSet.Height()+prebase.NullRounds+1)
+			if err != nil {
+				log.Errorf("failed getting beacon entry: %s", err)
+				if !m.niceSleep(time.Second) {
+					continue minerLoop
+				}
+				continue
+			}
+
+			base = prebase
+		}
+
+		if base.TipSet.Equals(lastBase.TipSet) && lastBase.NullRounds == base.NullRounds {
+			log.Warnf("BestMiningCandidate from the previous round: %s (nulls:%d)", lastBase.TipSet.Cids(), lastBase.NullRounds)
+			if !m.niceSleep(time.Duration(build.BlockDelaySecs) * time.Second) {
+				continue minerLoop
+			}
 			continue
 		}
 
-		// Wait until propagation delay period after block we plan to mine on
-		if err := m.waitFunc(ctx, prebase.ts.MinTimestamp()); err != nil {
-			log.Error(err)
-			return
-		}
+		base.NullRounds += injectNulls // testing
 
-		base, err := m.GetBestMiningCandidate(ctx)
+		b, err := m.mineOne(ctx, base)
 		if err != nil {
-			log.Errorf("failed to get best mining candidate: %s", err)
-			continue
-		}
-		if base.ts.Equals(lastBase.ts) && lastBase.nullRounds == base.nullRounds {
-			log.Warnf("BestMiningCandidate from the previous round: %s (nulls:%d)", lastBase.ts.Cids(), lastBase.nullRounds)
-			time.Sleep(build.BlockDelay * time.Second)
+			log.Errorf("mining block failed: %+v", err)
+			if !m.niceSleep(time.Second) {
+				continue minerLoop
+			}
+			onDone(false, 0, err)
 			continue
 		}
 		lastBase = *base
 
-		blks := make([]*types.BlockMsg, 0)
+		var h abi.ChainEpoch
+		if b != nil {
+			h = b.Header.Height
+		}
+		onDone(b != nil, h, nil)
 
-		for _, addr := range addrs {
-			b, err := m.mineOne(ctx, addr, base)
-			if err != nil {
-				log.Errorf("mining block failed: %+v", err)
+		if b != nil {
+			journal.J.RecordEvent(m.evtTypes[evtTypeBlockMined], func() interface{} {
+				return map[string]interface{}{
+					"parents":   base.TipSet.Cids(),
+					"nulls":     base.NullRounds,
+					"epoch":     b.Header.Height,
+					"timestamp": b.Header.Timestamp,
+					"cid":       b.Header.Cid(),
+				}
+			})
+
+			btime := time.Unix(int64(b.Header.Timestamp), 0)
+			now := build.Clock.Now()
+			switch {
+			case btime == now:
+				// block timestamp is perfectly aligned with time.
+			case btime.After(now):
+				if !m.niceSleep(build.Clock.Until(btime)) {
+					log.Warnf("received interrupt while waiting to broadcast block, will shutdown after block is sent out")
+					build.Clock.Sleep(build.Clock.Until(btime))
+				}
+			default:
+				log.Warnw("mined block in the past",
+					"block-time", btime, "time", build.Clock.Now(), "difference", build.Clock.Since(btime))
+			}
+
+			if err := m.sf.MinedBlock(b.Header, base.TipSet.Height()+base.NullRounds); err != nil {
+				log.Errorf("<!!> SLASH FILTER ERROR: %s", err)
 				continue
 			}
-			if b != nil {
-				blks = append(blks, b)
-			}
-		}
 
-		if len(blks) != 0 {
-			btime := time.Unix(int64(blks[0].Header.Timestamp), 0)
-			if time.Now().Before(btime) {
-				time.Sleep(time.Until(btime))
-			} else {
-				log.Warnw("mined block in the past", "block-time", btime,
-					"time", time.Now(), "duration", time.Since(btime))
+			blkKey := fmt.Sprintf("%d", b.Header.Height)
+			if _, ok := m.minedBlockHeights.Get(blkKey); ok {
+				log.Warnw("Created a block at the same height as another block we've created", "height", b.Header.Height, "miner", b.Header.Miner, "parents", b.Header.Parents)
+				continue
 			}
 
-			mWon := make(map[address.Address]struct{})
-			for _, b := range blks {
-				_, notOk := mWon[b.Header.Miner]
-				if notOk {
-					log.Errorw("2 blocks for the same miner. Throwing hands in the air. Report this. It is important.", "bloks", blks)
-					continue eventLoop
-				}
-				mWon[b.Header.Miner] = struct{}{}
-			}
-			for _, b := range blks {
-				if err := m.api.SyncSubmitBlock(ctx, b); err != nil {
-					log.Errorf("failed to submit newly mined block: %s", err)
-				}
+			m.minedBlockHeights.Add(blkKey, true)
+
+			if err := m.api.SyncSubmitBlock(ctx, b); err != nil {
+				log.Errorf("failed to submit newly mined block: %s", err)
 			}
 		} else {
-			nextRound := time.Unix(int64(base.ts.MinTimestamp()+uint64(build.BlockDelay*base.nullRounds)), 0)
-			time.Sleep(time.Until(nextRound))
+			base.NullRounds++
+
+			// Wait until the next epoch, plus the propagation delay, so a new tipset
+			// has enough time to form.
+			//
+			// See:  https://github.com/filecoin-project/lotus/issues/1845
+			nextRound := time.Unix(int64(base.TipSet.MinTimestamp()+build.BlockDelaySecs*uint64(base.NullRounds))+int64(build.PropagationDelaySecs), 0)
+
+			select {
+			case <-build.Clock.After(build.Clock.Until(nextRound)):
+			case <-m.stop:
+				stopping := m.stopping
+				m.stop = nil
+				m.stopping = nil
+				close(stopping)
+				return
+			}
 		}
 	}
 }
 
 type MiningBase struct {
-	ts         *types.TipSet
-	nullRounds uint64
+	TipSet     *types.TipSet
+	NullRounds abi.ChainEpoch
 }
 
 func (m *Miner) GetBestMiningCandidate(ctx context.Context) (*MiningBase, error) {
+	m.lk.Lock()
+	defer m.lk.Unlock()
+
 	bts, err := m.api.ChainHead(ctx)
 	if err != nil {
 		return nil, err
 	}
 
 	if m.lastWork != nil {
-		if m.lastWork.ts.Equals(bts) {
+		if m.lastWork.TipSet.Equals(bts) {
 			return m.lastWork, nil
 		}
 
-		btsw, err := m.api.ChainTipSetWeight(ctx, bts)
+		btsw, err := m.api.ChainTipSetWeight(ctx, bts.Key())
 		if err != nil {
 			return nil, err
 		}
-		ltsw, err := m.api.ChainTipSetWeight(ctx, m.lastWork.ts)
+		ltsw, err := m.api.ChainTipSetWeight(ctx, m.lastWork.TipSet.Key())
 		if err != nil {
 			return nil, err
 		}
@@ -243,111 +335,150 @@ func (m *Miner) GetBestMiningCandidate(ctx context.Context) (*MiningBase, error)
 		}
 	}
 
-	m.lastWork = &MiningBase{ts: bts}
+	m.lastWork = &MiningBase{TipSet: bts}
 	return m.lastWork, nil
 }
 
-func (m *Miner) hasPower(ctx context.Context, addr address.Address, ts *types.TipSet) (bool, error) {
-	power, err := m.api.StateMinerPower(ctx, addr, ts)
+// mineOne attempts to mine a single block, and does so synchronously, if and
+// only if we are eligible to mine.
+//
+// {hint/landmark}: This method coordinates all the steps involved in mining a
+// block, including the condition of whether mine or not at all depending on
+// whether we win the round or not.
+//
+// This method does the following:
+//
+//  1.
+func (m *Miner) mineOne(ctx context.Context, base *MiningBase) (*types.BlockMsg, error) {
+	log.Debugw("attempting to mine a block", "tipset", types.LogCids(base.TipSet.Cids()))
+	start := build.Clock.Now()
+
+	round := base.TipSet.Height() + base.NullRounds + 1
+
+	mbi, err := m.api.MinerGetBaseInfo(ctx, m.address, round, base.TipSet.Key())
 	if err != nil {
-		return false, err
+		return nil, xerrors.Errorf("failed to get mining base info: %w", err)
 	}
-
-	return !power.MinerPower.Equals(types.NewInt(0)), nil
-}
-
-func (m *Miner) mineOne(ctx context.Context, addr address.Address, base *MiningBase) (*types.BlockMsg, error) {
-	log.Debugw("attempting to mine a block", "tipset", types.LogCids(base.ts.Cids()))
-	start := time.Now()
-
-	hasPower, err := m.hasPower(ctx, addr, base.ts)
-	if err != nil {
-		return nil, xerrors.Errorf("checking if miner is slashed: %w", err)
+	if mbi == nil {
+		return nil, nil
 	}
-	if !hasPower {
+	if !mbi.HasMinPower {
 		// slashed or just have no power yet
-		base.nullRounds++
 		return nil, nil
 	}
 
-	log.Infof("Time delta between now and our mining base: %ds (nulls: %d)", uint64(time.Now().Unix())-base.ts.MinTimestamp(), base.nullRounds)
+	tMBI := build.Clock.Now()
 
-	ticket, err := m.computeTicket(ctx, addr, base)
+	beaconPrev := mbi.PrevBeaconEntry
+
+	tDrand := build.Clock.Now()
+	bvals := mbi.BeaconEntries
+
+	tPowercheck := build.Clock.Now()
+
+	log.Infof("Time delta between now and our mining base: %ds (nulls: %d)", uint64(build.Clock.Now().Unix())-base.TipSet.MinTimestamp(), base.NullRounds)
+
+	rbase := beaconPrev
+	if len(bvals) > 0 {
+		rbase = bvals[len(bvals)-1]
+	}
+
+	ticket, err := m.computeTicket(ctx, &rbase, base)
 	if err != nil {
 		return nil, xerrors.Errorf("scratching ticket failed: %w", err)
 	}
 
-	proofin, err := gen.IsRoundWinner(ctx, base.ts, int64(base.ts.Height()+base.nullRounds+1), addr, m.epp, m.api)
+	winner, err := gen.IsRoundWinner(ctx, base.TipSet, round, m.address, rbase, mbi, m.api)
 	if err != nil {
 		return nil, xerrors.Errorf("failed to check if we win next round: %w", err)
 	}
 
-	if proofin == nil {
-		base.nullRounds++
+	if winner == nil {
 		return nil, nil
 	}
 
+	tTicket := build.Clock.Now()
+
+	buf := new(bytes.Buffer)
+	if err := m.address.MarshalCBOR(buf); err != nil {
+		return nil, xerrors.Errorf("failed to marshal miner address: %w", err)
+	}
+
+	rand, err := store.DrawRandomness(rbase.Data, crypto.DomainSeparationTag_WinningPoStChallengeSeed, base.TipSet.Height()+base.NullRounds+1, buf.Bytes())
+	if err != nil {
+		return nil, xerrors.Errorf("failed to get randomness for winning post: %w", err)
+	}
+
+	prand := abi.PoStRandomness(rand)
+
+	tSeed := build.Clock.Now()
+
+	postProof, err := m.epp.ComputeProof(ctx, mbi.Sectors, prand)
+	if err != nil {
+		return nil, xerrors.Errorf("failed to compute winning post proof: %w", err)
+	}
+
 	// get pending messages early,
-	pending, err := m.api.MpoolPending(context.TODO(), base.ts)
+	msgs, err := m.api.MpoolSelect(context.TODO(), base.TipSet.Key(), ticket.Quality())
 	if err != nil {
-		return nil, xerrors.Errorf("failed to get pending messages: %w", err)
+		return nil, xerrors.Errorf("failed to select messages for block: %w", err)
 	}
 
-	proof, err := gen.ComputeProof(ctx, m.epp, proofin)
-	if err != nil {
-		return nil, xerrors.Errorf("computing election proof: %w", err)
-	}
+	tPending := build.Clock.Now()
 
-	b, err := m.createBlock(base, addr, ticket, proof, pending)
+	// TODO: winning post proof
+	b, err := m.createBlock(base, m.address, ticket, winner, bvals, postProof, msgs)
 	if err != nil {
 		return nil, xerrors.Errorf("failed to create block: %w", err)
 	}
 
-	dur := time.Since(start)
-	log.Infow("mined new block", "cid", b.Cid(), "height", b.Header.Height, "took", dur)
-	if dur > time.Second*build.BlockDelay {
-		log.Warn("CAUTION: block production took longer than the block delay. Your computer may not be fast enough to keep up")
+	tCreateBlock := build.Clock.Now()
+	dur := tCreateBlock.Sub(start)
+	parentMiners := make([]address.Address, len(base.TipSet.Blocks()))
+	for i, header := range base.TipSet.Blocks() {
+		parentMiners[i] = header.Miner
+	}
+	log.Infow("mined new block", "cid", b.Cid(), "height", b.Header.Height, "miner", b.Header.Miner, "parents", parentMiners, "took", dur)
+	if dur > time.Second*time.Duration(build.BlockDelaySecs) {
+		log.Warnw("CAUTION: block production took longer than the block delay. Your computer may not be fast enough to keep up",
+			"tMinerBaseInfo ", tMBI.Sub(start),
+			"tDrand ", tDrand.Sub(tMBI),
+			"tPowercheck ", tPowercheck.Sub(tDrand),
+			"tTicket ", tTicket.Sub(tPowercheck),
+			"tSeed ", tSeed.Sub(tTicket),
+			"tPending ", tPending.Sub(tSeed),
+			"tCreateBlock ", tCreateBlock.Sub(tPending))
 	}
 
 	return b, nil
 }
 
-func (m *Miner) computeVRF(ctx context.Context, addr address.Address, input []byte) ([]byte, error) {
-	w, err := m.getMinerWorker(ctx, addr, nil)
+func (m *Miner) computeTicket(ctx context.Context, brand *types.BeaconEntry, base *MiningBase) (*types.Ticket, error) {
+	mi, err := m.api.StateMinerInfo(ctx, m.address, types.EmptyTSK)
+	if err != nil {
+		return nil, err
+	}
+	worker, err := m.api.StateAccountKey(ctx, mi.Worker, types.EmptyTSK)
 	if err != nil {
 		return nil, err
 	}
 
-	return gen.ComputeVRF(ctx, m.api.WalletSign, w, addr, gen.DSepTicket, input)
-}
+	buf := new(bytes.Buffer)
+	if err := m.address.MarshalCBOR(buf); err != nil {
+		return nil, xerrors.Errorf("failed to marshal address to cbor: %w", err)
+	}
 
-func (m *Miner) getMinerWorker(ctx context.Context, addr address.Address, ts *types.TipSet) (address.Address, error) {
-	ret, err := m.api.StateCall(ctx, &types.Message{
-		From:   addr,
-		To:     addr,
-		Method: actors.MAMethods.GetWorkerAddr,
-	}, ts)
+	round := base.TipSet.Height() + base.NullRounds + 1
+	if round > build.UpgradeSmokeHeight {
+		buf.Write(base.TipSet.MinTicket().VRFProof)
+	}
+
+	input, err := store.DrawRandomness(brand.Data, crypto.DomainSeparationTag_TicketProduction, round-build.TicketRandomnessLookback, buf.Bytes())
 	if err != nil {
-		return address.Undef, xerrors.Errorf("failed to get miner worker addr: %w", err)
+		return nil, err
 	}
 
-	if ret.ExitCode != 0 {
-		return address.Undef, xerrors.Errorf("failed to get miner worker addr (exit code %d)", ret.ExitCode)
-	}
-
-	w, err := address.NewFromBytes(ret.Return)
-	if err != nil {
-		return address.Undef, xerrors.Errorf("GetWorkerAddr returned malformed address: %w", err)
-	}
-
-	return w, nil
-}
-
-func (m *Miner) computeTicket(ctx context.Context, addr address.Address, base *MiningBase) (*types.Ticket, error) {
-
-	vrfBase := base.ts.MinTicket().VRFProof
-
-	vrfOut, err := m.computeVRF(ctx, addr, vrfBase)
+	vrfOut, err := gen.ComputeVRF(ctx, m.api.WalletSign, worker, input)
 	if err != nil {
 		return nil, err
 	}
@@ -357,78 +488,52 @@ func (m *Miner) computeTicket(ctx context.Context, addr address.Address, base *M
 	}, nil
 }
 
-func (m *Miner) createBlock(base *MiningBase, addr address.Address, ticket *types.Ticket, proof *types.EPostProof, pending []*types.SignedMessage) (*types.BlockMsg, error) {
-	msgs, err := selectMessages(context.TODO(), m.api.StateGetActor, base, pending)
-	if err != nil {
-		return nil, xerrors.Errorf("message filtering failed: %w", err)
-	}
+func (m *Miner) createBlock(base *MiningBase, addr address.Address, ticket *types.Ticket,
+	eproof *types.ElectionProof, bvals []types.BeaconEntry, wpostProof []proof0.PoStProof, msgs []*types.SignedMessage) (*types.BlockMsg, error) {
+	uts := base.TipSet.MinTimestamp() + build.BlockDelaySecs*(uint64(base.NullRounds)+1)
 
-	uts := base.ts.MinTimestamp() + uint64(build.BlockDelay*(base.nullRounds+1))
-
-	nheight := base.ts.Height() + base.nullRounds + 1
+	nheight := base.TipSet.Height() + base.NullRounds + 1
 
 	// why even return this? that api call could just submit it for us
-	return m.api.MinerCreateBlock(context.TODO(), addr, base.ts, ticket, proof, msgs, nheight, uint64(uts))
+	return m.api.MinerCreateBlock(context.TODO(), &api.BlockTemplate{
+		Miner:            addr,
+		Parents:          base.TipSet.Key(),
+		Ticket:           ticket,
+		Eproof:           eproof,
+		BeaconValues:     bvals,
+		Messages:         msgs,
+		Epoch:            nheight,
+		Timestamp:        uts,
+		WinningPoStProof: wpostProof,
+	})
 }
 
-type actorLookup func(context.Context, address.Address, *types.TipSet) (*types.Actor, error)
+type actCacheEntry struct {
+	act *types.Actor
+	err error
+}
 
-func countFrom(msgs []*types.SignedMessage, from address.Address) (out int) {
-	for _, msg := range msgs {
-		if msg.Message.From == from {
-			out++
+type cachedActorLookup struct {
+	tsk      types.TipSetKey
+	cache    map[address.Address]actCacheEntry
+	fallback gasguess.ActorLookup
+}
+
+func (c *cachedActorLookup) StateGetActor(ctx context.Context, a address.Address, tsk types.TipSetKey) (*types.Actor, error) {
+	if c.tsk == tsk {
+		e, has := c.cache[a]
+		if has {
+			return e.act, e.err
 		}
 	}
-	return out
-}
 
-func selectMessages(ctx context.Context, al actorLookup, base *MiningBase, msgs []*types.SignedMessage) ([]*types.SignedMessage, error) {
-	out := make([]*types.SignedMessage, 0, len(msgs))
-	inclNonces := make(map[address.Address]uint64)
-	inclBalances := make(map[address.Address]types.BigInt)
-	inclCount := make(map[address.Address]int)
-
-	for _, msg := range msgs {
-		if msg.Message.To == address.Undef {
-			log.Warnf("message in mempool had bad 'To' address")
-			continue
-		}
-
-		from := msg.Message.From
-
-		if _, ok := inclNonces[from]; !ok {
-			act, err := al(ctx, from, base.ts)
-			if err != nil {
-				return nil, xerrors.Errorf("failed to check message sender balance: %w", err)
-			}
-
-			inclNonces[from] = act.Nonce
-			inclBalances[from] = act.Balance
-		}
-
-		if inclBalances[from].LessThan(msg.Message.RequiredFunds()) {
-			log.Warnf("message in mempool does not have enough funds: %s", msg.Cid())
-			continue
-		}
-
-		if msg.Message.Nonce > inclNonces[from] {
-			log.Warnf("message in mempool has too high of a nonce (%d > %d, from %s, inclcount %d) %s (%d pending for orig)", msg.Message.Nonce, inclNonces[from], from, inclCount[from], msg.Cid(), countFrom(msgs, from))
-			continue
-		}
-
-		if msg.Message.Nonce < inclNonces[from] {
-			log.Warnf("message in mempool has already used nonce (%d < %d), from %s, to %s, %s (%d pending for)", msg.Message.Nonce, inclNonces[from], msg.Message.From, msg.Message.To, msg.Cid(), countFrom(msgs, from))
-			continue
-		}
-
-		inclNonces[from] = msg.Message.Nonce + 1
-		inclBalances[from] = types.BigSub(inclBalances[from], msg.Message.RequiredFunds())
-		inclCount[from]++
-
-		out = append(out, msg)
-		if len(out) >= MaxMessagesPerBlock {
-			break
+	e, err := c.fallback(ctx, a, tsk)
+	if c.tsk == tsk {
+		c.cache[a] = actCacheEntry{
+			act: e, err: err,
 		}
 	}
-	return out, nil
+	return e, err
 }
+
+type ActorLookup func(context.Context, address.Address, types.TipSetKey) (*types.Actor, error)
diff --git a/miner/miner_test.go b/miner/miner_test.go
deleted file mode 100644
index 3b6f34b82..000000000
--- a/miner/miner_test.go
+++ /dev/null
@@ -1,104 +0,0 @@
-package miner
-
-import (
-	"context"
-	"testing"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/lotus/chain/types"
-)
-
-func mustIDAddr(i uint64) address.Address {
-	a, err := address.NewIDAddress(i)
-	if err != nil {
-		panic(err)
-	}
-
-	return a
-}
-
-func TestMessageFiltering(t *testing.T) {
-	ctx := context.TODO()
-	a1 := mustIDAddr(1)
-	a2 := mustIDAddr(2)
-
-	actors := map[address.Address]*types.Actor{
-		a1: &types.Actor{
-			Nonce:   3,
-			Balance: types.NewInt(1200),
-		},
-		a2: &types.Actor{
-			Nonce:   1,
-			Balance: types.NewInt(1000),
-		},
-	}
-
-	af := func(ctx context.Context, addr address.Address, ts *types.TipSet) (*types.Actor, error) {
-		return actors[addr], nil
-	}
-
-	msgs := []types.Message{
-		types.Message{
-			From:     a1,
-			To:       a1,
-			Nonce:    3,
-			Value:    types.NewInt(500),
-			GasLimit: types.NewInt(50),
-			GasPrice: types.NewInt(1),
-		},
-		types.Message{
-			From:     a1,
-			To:       a1,
-			Nonce:    4,
-			Value:    types.NewInt(500),
-			GasLimit: types.NewInt(50),
-			GasPrice: types.NewInt(1),
-		},
-		types.Message{
-			From:     a2,
-			To:       a1,
-			Nonce:    1,
-			Value:    types.NewInt(800),
-			GasLimit: types.NewInt(100),
-			GasPrice: types.NewInt(1),
-		},
-		types.Message{
-			From:     a2,
-			To:       a1,
-			Nonce:    0,
-			Value:    types.NewInt(800),
-			GasLimit: types.NewInt(100),
-			GasPrice: types.NewInt(1),
-		},
-		types.Message{
-			From:     a2,
-			To:       a1,
-			Nonce:    2,
-			Value:    types.NewInt(150),
-			GasLimit: types.NewInt(100),
-			GasPrice: types.NewInt(1),
-		},
-	}
-
-	outmsgs, err := selectMessages(ctx, af, &MiningBase{}, wrapMsgs(msgs))
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if len(outmsgs) != 3 {
-		t.Fatal("filtering didnt work as expected")
-	}
-
-	m1 := outmsgs[2].Message
-	if m1.From != msgs[2].From || m1.Nonce != msgs[2].Nonce {
-		t.Fatal("filtering bad")
-	}
-}
-
-func wrapMsgs(msgs []types.Message) []*types.SignedMessage {
-	var out []*types.SignedMessage
-	for _, m := range msgs {
-		out = append(out, &types.SignedMessage{Message: m})
-	}
-	return out
-}
diff --git a/miner/testminer.go b/miner/testminer.go
index 8e60956c8..64e3b3a62 100644
--- a/miner/testminer.go
+++ b/miner/testminer.go
@@ -3,34 +3,51 @@ package miner
 import (
 	"context"
 
+	lru "github.com/hashicorp/golang-lru"
+	ds "github.com/ipfs/go-datastore"
+
 	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/chain/gen"
+	"github.com/filecoin-project/lotus/chain/gen/slashfilter"
 )
 
-func NewTestMiner(nextCh <-chan struct{}, addr address.Address) func(api.FullNode, gen.ElectionPoStProver) *Miner {
-	return func(api api.FullNode, epp gen.ElectionPoStProver) *Miner {
-		m := &Miner{
-			api:      api,
-			waitFunc: chanWaiter(nextCh),
-			epp:      epp,
+type MineReq struct {
+	InjectNulls abi.ChainEpoch
+	Done        func(bool, abi.ChainEpoch, error)
+}
+
+func NewTestMiner(nextCh <-chan MineReq, addr address.Address) func(api.FullNode, gen.WinningPoStProver) *Miner {
+	return func(api api.FullNode, epp gen.WinningPoStProver) *Miner {
+		arc, err := lru.NewARC(10000)
+		if err != nil {
+			panic(err)
 		}
 
-		if err := m.Register(addr); err != nil {
+		m := &Miner{
+			api:               api,
+			waitFunc:          chanWaiter(nextCh),
+			epp:               epp,
+			minedBlockHeights: arc,
+			address:           addr,
+			sf:                slashfilter.New(ds.NewMapDatastore()),
+		}
+
+		if err := m.Start(context.TODO()); err != nil {
 			panic(err)
 		}
 		return m
 	}
 }
 
-func chanWaiter(next <-chan struct{}) func(ctx context.Context, _ uint64) error {
-	return func(ctx context.Context, _ uint64) error {
+func chanWaiter(next <-chan MineReq) func(ctx context.Context, _ uint64) (func(bool, abi.ChainEpoch, error), abi.ChainEpoch, error) {
+	return func(ctx context.Context, _ uint64) (func(bool, abi.ChainEpoch, error), abi.ChainEpoch, error) {
 		select {
 		case <-ctx.Done():
-			return ctx.Err()
-		case <-next:
+			return nil, 0, ctx.Err()
+		case req := <-next:
+			return req.Done, req.InjectNulls, nil
 		}
-
-		return nil
 	}
 }
diff --git a/node/builder.go b/node/builder.go
index ee34b3600..c37a5db58 100644
--- a/node/builder.go
+++ b/node/builder.go
@@ -3,15 +3,16 @@ package node
 import (
 	"context"
 	"errors"
+	"os"
 	"time"
 
-	sectorbuilder "github.com/filecoin-project/go-sectorbuilder"
-	blockstore "github.com/ipfs/go-ipfs-blockstore"
+	logging "github.com/ipfs/go-log"
 	ci "github.com/libp2p/go-libp2p-core/crypto"
 	"github.com/libp2p/go-libp2p-core/host"
 	"github.com/libp2p/go-libp2p-core/peer"
 	"github.com/libp2p/go-libp2p-core/peerstore"
 	"github.com/libp2p/go-libp2p-core/routing"
+	dht "github.com/libp2p/go-libp2p-kad-dht"
 	"github.com/libp2p/go-libp2p-peerstore/pstoremem"
 	pubsub "github.com/libp2p/go-libp2p-pubsub"
 	record "github.com/libp2p/go-libp2p-record"
@@ -19,61 +20,93 @@ import (
 	"go.uber.org/fx"
 	"golang.org/x/xerrors"
 
+	"github.com/filecoin-project/go-fil-markets/retrievalmarket"
+	"github.com/filecoin-project/go-fil-markets/retrievalmarket/discovery"
+	"github.com/filecoin-project/go-fil-markets/storagemarket"
+	"github.com/filecoin-project/go-fil-markets/storagemarket/impl/storedask"
+
+	storage2 "github.com/filecoin-project/specs-storage/storage"
+
 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/chain"
-	"github.com/filecoin-project/lotus/chain/blocksync"
-	"github.com/filecoin-project/lotus/chain/deals"
+	"github.com/filecoin-project/lotus/chain/beacon"
+	"github.com/filecoin-project/lotus/chain/exchange"
 	"github.com/filecoin-project/lotus/chain/gen"
+	"github.com/filecoin-project/lotus/chain/gen/slashfilter"
 	"github.com/filecoin-project/lotus/chain/market"
 	"github.com/filecoin-project/lotus/chain/messagepool"
 	"github.com/filecoin-project/lotus/chain/metrics"
 	"github.com/filecoin-project/lotus/chain/stmgr"
 	"github.com/filecoin-project/lotus/chain/store"
 	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/chain/vm"
 	"github.com/filecoin-project/lotus/chain/wallet"
+	sectorstorage "github.com/filecoin-project/lotus/extern/sector-storage"
+	"github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper"
+	"github.com/filecoin-project/lotus/extern/sector-storage/stores"
+	sealing "github.com/filecoin-project/lotus/extern/storage-sealing"
+	"github.com/filecoin-project/lotus/journal"
+	"github.com/filecoin-project/lotus/lib/blockstore"
+	"github.com/filecoin-project/lotus/lib/peermgr"
+	_ "github.com/filecoin-project/lotus/lib/sigs/bls"
+	_ "github.com/filecoin-project/lotus/lib/sigs/secp"
+	"github.com/filecoin-project/lotus/markets/dealfilter"
+	"github.com/filecoin-project/lotus/markets/storageadapter"
 	"github.com/filecoin-project/lotus/miner"
 	"github.com/filecoin-project/lotus/node/config"
 	"github.com/filecoin-project/lotus/node/hello"
 	"github.com/filecoin-project/lotus/node/impl"
+	"github.com/filecoin-project/lotus/node/impl/common"
 	"github.com/filecoin-project/lotus/node/modules"
 	"github.com/filecoin-project/lotus/node/modules/dtypes"
 	"github.com/filecoin-project/lotus/node/modules/helpers"
 	"github.com/filecoin-project/lotus/node/modules/lp2p"
 	"github.com/filecoin-project/lotus/node/modules/testing"
 	"github.com/filecoin-project/lotus/node/repo"
-	"github.com/filecoin-project/lotus/paych"
-	"github.com/filecoin-project/lotus/peermgr"
-	"github.com/filecoin-project/lotus/retrieval"
-	"github.com/filecoin-project/lotus/retrieval/discovery"
+	"github.com/filecoin-project/lotus/paychmgr"
+	"github.com/filecoin-project/lotus/paychmgr/settler"
 	"github.com/filecoin-project/lotus/storage"
 	"github.com/filecoin-project/lotus/storage/sectorblocks"
 )
 
+// EnvJournalDisabledEvents is the environment variable through which disabled
+// journal events can be customized.
+const EnvJournalDisabledEvents = "LOTUS_JOURNAL_DISABLED_EVENTS"
+
+//nolint:deadcode,varcheck
+var log = logging.Logger("builder")
+
 // special is a type used to give keys to modules which
 //  can't really be identified by the returned type
 type special struct{ id int }
 
 //nolint:golint
 var (
-	DefaultTransportsKey = special{0} // Libp2p option
-	PNetKey              = special{1} // Option + multiret
-	DiscoveryHandlerKey  = special{2} // Private type
-	AddrsFactoryKey      = special{3} // Libp2p option
-	SmuxTransportKey     = special{4} // Libp2p option
-	RelayKey             = special{5} // Libp2p option
-	SecurityKey          = special{6} // Libp2p option
-	BaseRoutingKey       = special{7} // fx groups + multiret
-	NatPortMapKey        = special{8} // Libp2p option
-	ConnectionManagerKey = special{9} // Libp2p option
+	DefaultTransportsKey = special{0}  // Libp2p option
+	DiscoveryHandlerKey  = special{2}  // Private type
+	AddrsFactoryKey      = special{3}  // Libp2p option
+	SmuxTransportKey     = special{4}  // Libp2p option
+	RelayKey             = special{5}  // Libp2p option
+	SecurityKey          = special{6}  // Libp2p option
+	BaseRoutingKey       = special{7}  // fx groups + multiret
+	NatPortMapKey        = special{8}  // Libp2p option
+	ConnectionManagerKey = special{9}  // Libp2p option
+	AutoNATSvcKey        = special{10} // Libp2p option
+	BandwidthReporterKey = special{11} // Libp2p option
 )
 
 type invoke int
 
+// Invokes are called in the order they are defined.
 //nolint:golint
 const (
+	// InitJournal at position 0 initializes the journal global var as soon as
+	// the system starts, so that it's available for all other components.
+	InitJournalKey = invoke(iota)
+
 	// libp2p
 
-	PstoreAddSelfKeysKey = invoke(iota)
+	PstoreAddSelfKeysKey
 	StartListeningKey
 	BootstrapKey
 
@@ -81,25 +114,25 @@ const (
 	SetGenesisKey
 
 	RunHelloKey
-	RunBlockSyncKey
+	RunChainExchangeKey
+	RunChainGraphsync
 	RunPeerMgrKey
 
 	HandleIncomingBlocksKey
 	HandleIncomingMessagesKey
 
-	RunDealClientKey
-	RegisterClientValidatorKey
+	HandlePaymentChannelManagerKey
 
-	// storage miner
+	// miner
 	GetParamsKey
 	HandleDealsKey
 	HandleRetrievalKey
 	RunSectorServiceKey
-	RegisterProviderValidatorKey
 
 	// daemon
 	ExtractApiKey
 	HeadMetricsKey
+	SettlePaymentChannelsKey
 	RunPeerTaggerKey
 
 	SetApiEndpointKey
@@ -123,12 +156,30 @@ type Settings struct {
 
 	Online bool // Online option applied
 	Config bool // Config option applied
+
 }
 
 func defaults() []Option {
 	return []Option{
+		// global system journal.
+		Override(new(journal.DisabledEvents), func() journal.DisabledEvents {
+			if env, ok := os.LookupEnv(EnvJournalDisabledEvents); ok {
+				if ret, err := journal.ParseDisabledEvents(env); err == nil {
+					return ret
+				}
+			}
+			// fallback if env variable is not set, or if it failed to parse.
+			return journal.DefaultDisabledEvents
+		}),
+		Override(new(journal.Journal), modules.OpenFilesystemJournal),
+		Override(InitJournalKey, func(j journal.Journal) {
+			journal.J = j // eagerly sets the global journal through fx.Invoke.
+		}),
+
 		Override(new(helpers.MetricsCtx), context.Background),
 		Override(new(record.Validator), modules.RecordValidator),
+		Override(new(dtypes.Bootstrapper), dtypes.Bootstrapper(false)),
+		Override(new(dtypes.ShutdownChan), make(chan struct{})),
 
 		// Filecoin modules
 
@@ -140,26 +191,33 @@ func libp2p() Option {
 		Override(new(peerstore.Peerstore), pstoremem.NewPeerstore),
 
 		Override(DefaultTransportsKey, lp2p.DefaultTransports),
-		Override(PNetKey, lp2p.PNet),
 
 		Override(new(lp2p.RawHost), lp2p.Host),
 		Override(new(host.Host), lp2p.RoutedHost),
-		Override(new(lp2p.BaseIpfsRouting), lp2p.DHTRouting(false)),
+		Override(new(lp2p.BaseIpfsRouting), lp2p.DHTRouting(dht.ModeAuto)),
 
 		Override(DiscoveryHandlerKey, lp2p.DiscoveryHandler),
 		Override(AddrsFactoryKey, lp2p.AddrsFactory(nil, nil)),
 		Override(SmuxTransportKey, lp2p.SmuxTransport(true)),
-		Override(RelayKey, lp2p.Relay(true, false)),
+		Override(RelayKey, lp2p.NoRelay()),
 		Override(SecurityKey, lp2p.Security(true, false)),
 
 		Override(BaseRoutingKey, lp2p.BaseRouting),
 		Override(new(routing.Routing), lp2p.Routing),
 
 		Override(NatPortMapKey, lp2p.NatPortMap),
+		Override(BandwidthReporterKey, lp2p.BandwidthCounter),
 
 		Override(ConnectionManagerKey, lp2p.ConnectionManager(50, 200, 20*time.Second, nil)),
+		Override(AutoNATSvcKey, lp2p.AutoNATService),
 
-		Override(new(*pubsub.PubSub), lp2p.GossipSub()),
+		Override(new(*dtypes.ScoreKeeper), lp2p.ScoreKeeper),
+		Override(new(*pubsub.PubSub), lp2p.GossipSub),
+		Override(new(*config.Pubsub), func(bs dtypes.Bootstrapper) *config.Pubsub {
+			return &config.Pubsub{
+				Bootstrapper: bool(bs),
+			}
+		}),
 
 		Override(PstoreAddSelfKeysKey, lp2p.PstoreAddSelfKeys),
 		Override(StartListeningKey, lp2p.StartListening(config.DefaultFullNode().Libp2p.ListenAddresses)),
@@ -183,6 +241,7 @@ func Online() Option {
 		libp2p(),
 
 		// common
+		Override(new(*slashfilter.SlashFilter), modules.NewSlashFilter),
 
 		// Full node
 
@@ -190,72 +249,119 @@ func Online() Option {
 			// TODO: Fix offline mode
 
 			Override(new(dtypes.BootstrapPeers), modules.BuiltinBootstrap),
+			Override(new(dtypes.DrandBootstrap), modules.DrandBootstrap),
+			Override(new(dtypes.DrandSchedule), modules.BuiltinDrandConfig),
 
 			Override(HandleIncomingMessagesKey, modules.HandleIncomingMessages),
 
+			Override(new(ffiwrapper.Verifier), ffiwrapper.ProofVerifier),
+			Override(new(vm.SyscallBuilder), vm.Syscalls),
 			Override(new(*store.ChainStore), modules.ChainStore),
 			Override(new(*stmgr.StateManager), stmgr.NewStateManager),
 			Override(new(*wallet.Wallet), wallet.NewWallet),
 
 			Override(new(dtypes.ChainGCLocker), blockstore.NewGCLocker),
 			Override(new(dtypes.ChainGCBlockstore), modules.ChainGCBlockstore),
-			Override(new(dtypes.ChainExchange), modules.ChainExchange),
-			Override(new(dtypes.ChainBlockService), modules.ChainBlockservice),
-			Override(new(dtypes.ClientDAG), testing.MemoryClientDag),
+			Override(new(dtypes.ChainBitswap), modules.ChainBitswap),
+			Override(new(dtypes.ChainBlockService), modules.ChainBlockService),
 
 			// Filecoin services
+			// We don't want the SyncManagerCtor to be used as an fx constructor, but rather as a value.
+			// It will be called implicitly by the Syncer constructor.
+			Override(new(chain.SyncManagerCtor), func() chain.SyncManagerCtor { return chain.NewSyncManager }),
 			Override(new(*chain.Syncer), modules.NewSyncer),
-			Override(new(*blocksync.BlockSync), blocksync.NewBlockSyncClient),
+			Override(new(exchange.Client), exchange.NewClient),
 			Override(new(*messagepool.MessagePool), modules.MessagePool),
 
 			Override(new(modules.Genesis), modules.ErrorGenesis),
-			Override(SetGenesisKey, modules.SetGenesis),
+			Override(new(dtypes.AfterGenesisSet), modules.SetGenesis),
+			Override(SetGenesisKey, modules.DoSetGenesis),
 
+			Override(new(dtypes.NetworkName), modules.NetworkName),
 			Override(new(*hello.Service), hello.NewHelloService),
-			Override(new(*blocksync.BlockSyncService), blocksync.NewBlockSyncService),
+			Override(new(exchange.Server), exchange.NewServer),
 			Override(new(*peermgr.PeerMgr), peermgr.NewPeerMgr),
 
+			Override(new(dtypes.Graphsync), modules.Graphsync),
+			Override(new(*dtypes.MpoolLocker), new(dtypes.MpoolLocker)),
+
 			Override(RunHelloKey, modules.RunHello),
-			Override(RunBlockSyncKey, modules.RunBlockSync),
+			Override(RunChainExchangeKey, modules.RunChainExchange),
 			Override(RunPeerMgrKey, modules.RunPeerMgr),
 			Override(HandleIncomingBlocksKey, modules.HandleIncomingBlocks),
 
-			Override(new(*discovery.Local), discovery.NewLocal),
-			Override(new(discovery.PeerResolver), modules.RetrievalResolver),
+			Override(new(*discovery.Local), modules.NewLocalDiscovery),
+			Override(new(retrievalmarket.PeerResolver), modules.RetrievalResolver),
 
-			Override(new(*retrieval.Client), retrieval.NewClient),
-			Override(new(dtypes.ClientDealStore), modules.NewClientDealStore),
-			Override(new(dtypes.ClientDataTransfer), modules.NewClientDAGServiceDataTransfer),
-			Override(new(*deals.ClientRequestValidator), deals.NewClientRequestValidator),
-			Override(new(*deals.Client), deals.NewClient),
-			Override(RegisterClientValidatorKey, modules.RegisterClientValidator),
-			Override(RunDealClientKey, modules.RunDealClient),
+			Override(new(retrievalmarket.RetrievalClient), modules.RetrievalClient),
+			Override(new(dtypes.ClientDatastore), modules.NewClientDatastore),
+			Override(new(dtypes.ClientDataTransfer), modules.NewClientGraphsyncDataTransfer),
+			Override(new(modules.ClientDealFunds), modules.NewClientDealFunds),
+			Override(new(storagemarket.StorageClient), modules.StorageClient),
+			Override(new(storagemarket.StorageClientNode), storageadapter.NewClientNodeAdapter),
+			Override(new(beacon.Schedule), modules.RandomSchedule),
 
-			Override(new(*paych.Store), paych.NewStore),
-			Override(new(*paych.Manager), paych.NewManager),
-			Override(new(*market.FundMgr), market.NewFundMgr),
+			Override(new(*paychmgr.Store), paychmgr.NewStore),
+			Override(new(*paychmgr.Manager), paychmgr.NewManager),
+			Override(new(*market.FundMgr), market.StartFundManager),
+			Override(HandlePaymentChannelManagerKey, paychmgr.HandleManager),
+			Override(SettlePaymentChannelsKey, settler.SettlePaymentChannels),
 		),
 
-		// Storage miner
+		// miner
 		ApplyIf(func(s *Settings) bool { return s.nodeType == repo.StorageMiner },
-			Override(new(*sectorbuilder.SectorBuilder), modules.SectorBuilder),
+			Override(new(api.Common), From(new(common.CommonAPI))),
+			Override(new(sectorstorage.StorageAuth), modules.StorageAuth),
+
+			Override(new(*stores.Index), stores.NewIndex),
+			Override(new(stores.SectorIndex), From(new(*stores.Index))),
+			Override(new(dtypes.MinerID), modules.MinerID),
+			Override(new(dtypes.MinerAddress), modules.MinerAddress),
+			Override(new(*ffiwrapper.Config), modules.ProofsConfig),
+			Override(new(stores.LocalStorage), From(new(repo.LockedRepo))),
+			Override(new(sealing.SectorIDCounter), modules.SectorIDCounter),
+			Override(new(*sectorstorage.Manager), modules.SectorStorage),
+			Override(new(ffiwrapper.Verifier), ffiwrapper.ProofVerifier),
+
+			Override(new(sectorstorage.SectorManager), From(new(*sectorstorage.Manager))),
+			Override(new(storage2.Prover), From(new(sectorstorage.SectorManager))),
+
 			Override(new(*sectorblocks.SectorBlocks), sectorblocks.NewSectorBlocks),
-			Override(new(storage.TicketFn), modules.SealTicketGen),
-			Override(new(*storage.Miner), modules.StorageMiner),
+			Override(new(*storage.Miner), modules.StorageMiner(config.DefaultStorageMiner().Fees)),
+			Override(new(dtypes.NetworkName), modules.StorageNetworkName),
 
+			Override(new(dtypes.StagingMultiDstore), modules.StagingMultiDatastore),
+			Override(new(dtypes.StagingBlockstore), modules.StagingBlockstore),
 			Override(new(dtypes.StagingDAG), modules.StagingDAG),
-
-			Override(new(*retrieval.Miner), retrieval.NewMiner),
-			Override(new(dtypes.ProviderDealStore), modules.NewProviderDealStore),
+			Override(new(dtypes.StagingGraphsync), modules.StagingGraphsync),
+			Override(new(retrievalmarket.RetrievalProvider), modules.RetrievalProvider),
 			Override(new(dtypes.ProviderDataTransfer), modules.NewProviderDAGServiceDataTransfer),
-			Override(new(*deals.ProviderRequestValidator), deals.NewProviderRequestValidator),
-			Override(new(*deals.Provider), deals.NewProvider),
-			Override(RegisterProviderValidatorKey, modules.RegisterProviderValidator),
+			Override(new(dtypes.ProviderPieceStore), modules.NewProviderPieceStore),
+			Override(new(*storedask.StoredAsk), modules.NewStorageAsk),
+			Override(new(dtypes.DealFilter), modules.BasicDealFilter(nil)),
+			Override(new(modules.ProviderDealFunds), modules.NewProviderDealFunds),
+			Override(new(storagemarket.StorageProvider), modules.StorageProvider),
+			Override(new(storagemarket.StorageProviderNode), storageadapter.NewProviderNodeAdapter),
 			Override(HandleRetrievalKey, modules.HandleRetrieval),
 			Override(GetParamsKey, modules.GetParams),
 			Override(HandleDealsKey, modules.HandleDeals),
-			Override(new(gen.ElectionPoStProver), storage.NewElectionPoStProver),
+			Override(new(gen.WinningPoStProver), storage.NewWinningPoStProver),
 			Override(new(*miner.Miner), modules.SetupBlockProducer),
+
+			Override(new(dtypes.ConsiderOnlineStorageDealsConfigFunc), modules.NewConsiderOnlineStorageDealsConfigFunc),
+			Override(new(dtypes.SetConsiderOnlineStorageDealsConfigFunc), modules.NewSetConsideringOnlineStorageDealsFunc),
+			Override(new(dtypes.ConsiderOnlineRetrievalDealsConfigFunc), modules.NewConsiderOnlineRetrievalDealsConfigFunc),
+			Override(new(dtypes.SetConsiderOnlineRetrievalDealsConfigFunc), modules.NewSetConsiderOnlineRetrievalDealsConfigFunc),
+			Override(new(dtypes.StorageDealPieceCidBlocklistConfigFunc), modules.NewStorageDealPieceCidBlocklistConfigFunc),
+			Override(new(dtypes.SetStorageDealPieceCidBlocklistConfigFunc), modules.NewSetStorageDealPieceCidBlocklistConfigFunc),
+			Override(new(dtypes.ConsiderOfflineStorageDealsConfigFunc), modules.NewConsiderOfflineStorageDealsConfigFunc),
+			Override(new(dtypes.SetConsiderOfflineStorageDealsConfigFunc), modules.NewSetConsideringOfflineStorageDealsFunc),
+			Override(new(dtypes.ConsiderOfflineRetrievalDealsConfigFunc), modules.NewConsiderOfflineRetrievalDealsConfigFunc),
+			Override(new(dtypes.SetConsiderOfflineRetrievalDealsConfigFunc), modules.NewSetConsiderOfflineRetrievalDealsConfigFunc),
+			Override(new(dtypes.SetSealingConfigFunc), modules.NewSetSealConfigFunc),
+			Override(new(dtypes.GetSealingConfigFunc), modules.NewGetSealConfigFunc),
+			Override(new(dtypes.SetExpectedSealDurationFunc), modules.NewSetExpectedSealDurationFunc),
+			Override(new(dtypes.GetExpectedSealDurationFunc), modules.NewGetExpectedSealDurationFunc),
 		),
 	)
 }
@@ -276,7 +382,7 @@ func StorageMiner(out *api.StorageMiner) Option {
 
 		func(s *Settings) error {
 			resAPI := &impl.StorageMinerAPI{}
-			s.invokes[ExtractApiKey] = fx.Extract(resAPI)
+			s.invokes[ExtractApiKey] = fx.Populate(resAPI)
 			*out = resAPI
 			return nil
 		},
@@ -287,15 +393,19 @@ func StorageMiner(out *api.StorageMiner) Option {
 func ConfigCommon(cfg *config.Common) Option {
 	return Options(
 		func(s *Settings) error { s.Config = true; return nil },
-
-		Override(SetApiEndpointKey, func(lr repo.LockedRepo) error {
-			apima, err := multiaddr.NewMultiaddr(cfg.API.ListenAddress)
-			if err != nil {
-				return err
-			}
-			return lr.SetAPIEndpoint(apima)
+		Override(new(dtypes.APIEndpoint), func() (dtypes.APIEndpoint, error) {
+			return multiaddr.NewMultiaddr(cfg.API.ListenAddress)
 		}),
+		Override(SetApiEndpointKey, func(lr repo.LockedRepo, e dtypes.APIEndpoint) error {
+			return lr.SetAPIEndpoint(e)
+		}),
+		Override(new(sectorstorage.URLs), func(e dtypes.APIEndpoint) (sectorstorage.URLs, error) {
+			ip := cfg.API.RemoteListenAddress
 
+			var urls sectorstorage.URLs
+			urls = append(urls, "http://"+ip+"/remote") // TODO: This makes no assumptions, and probably could...
+			return urls, nil
+		}),
 		ApplyIf(func(s *Settings) bool { return s.Online },
 			Override(StartListeningKey, lp2p.StartListening(cfg.Libp2p.ListenAddresses)),
 			Override(ConnectionManagerKey, lp2p.ConnectionManager(
@@ -303,11 +413,16 @@ func ConfigCommon(cfg *config.Common) Option {
 				cfg.Libp2p.ConnMgrHigh,
 				time.Duration(cfg.Libp2p.ConnMgrGrace),
 				cfg.Libp2p.ProtectedPeers)),
+			Override(new(*pubsub.PubSub), lp2p.GossipSub),
+			Override(new(*config.Pubsub), &cfg.Pubsub),
 
 			ApplyIf(func(s *Settings) bool { return len(cfg.Libp2p.BootstrapPeers) > 0 },
 				Override(new(dtypes.BootstrapPeers), modules.ConfigBootstrap(cfg.Libp2p.BootstrapPeers)),
 			),
 		),
+		Override(AddrsFactoryKey, lp2p.AddrsFactory(
+			cfg.Libp2p.AnnounceAddresses,
+			cfg.Libp2p.NoAnnounceAddresses)),
 	)
 }
 
@@ -317,35 +432,36 @@ func ConfigFullNode(c interface{}) Option {
 		return Error(xerrors.Errorf("invalid config from repo, got: %T", c))
 	}
 
+	ipfsMaddr := cfg.Client.IpfsMAddr
 	return Options(
 		ConfigCommon(&cfg.Common),
+		If(cfg.Client.UseIpfs,
+			Override(new(dtypes.ClientBlockstore), modules.IpfsClientBlockstore(ipfsMaddr)),
+			If(cfg.Client.IpfsUseForRetrieval,
+				Override(new(dtypes.ClientRetrievalStoreManager), modules.ClientBlockstoreRetrievalStoreManager),
+			),
+		),
 		If(cfg.Metrics.HeadNotifs,
 			Override(HeadMetricsKey, metrics.SendHeadNotifs(cfg.Metrics.Nickname)),
 		),
-		If(cfg.Metrics.PubsubTracing,
-			Override(new(*pubsub.PubSub), lp2p.GossipSub(lp2p.PubsubTracer())),
-		),
 	)
 }
 
-func ConfigStorageMiner(c interface{}, lr repo.LockedRepo) Option {
+func ConfigStorageMiner(c interface{}) Option {
 	cfg, ok := c.(*config.StorageMiner)
 	if !ok {
 		return Error(xerrors.Errorf("invalid config from repo, got: %T", c))
 	}
 
-	path := cfg.SectorBuilder.Path
-	if path == "" {
-		path = lr.Path()
-	}
-
 	return Options(
 		ConfigCommon(&cfg.Common),
 
-		Override(new(*sectorbuilder.Config), modules.SectorBuilderConfig(path,
-			cfg.SectorBuilder.WorkerCount,
-			cfg.SectorBuilder.DisableLocalPreCommit,
-			cfg.SectorBuilder.DisableLocalCommit)),
+		If(cfg.Dealmaking.Filter != "",
+			Override(new(dtypes.DealFilter), modules.BasicDealFilter(dealfilter.CliDealFilter(cfg.Dealmaking.Filter))),
+		),
+
+		Override(new(sectorstorage.SealerConfig), cfg.Storage),
+		Override(new(*storage.Miner), modules.StorageMiner(cfg.Fees)),
 	)
 }
 
@@ -363,16 +479,14 @@ func Repo(r repo.Repo) Option {
 		return Options(
 			Override(new(repo.LockedRepo), modules.LockedRepo(lr)), // module handles closing
 
-			ApplyIf(isType(repo.FullNode), ConfigFullNode(c)),
-			ApplyIf(isType(repo.StorageMiner), ConfigStorageMiner(c, lr)),
-
 			Override(new(dtypes.MetadataDS), modules.Datastore),
 			Override(new(dtypes.ChainBlockstore), modules.ChainBlockstore),
 
-			Override(new(dtypes.ClientFilestore), modules.ClientFstore),
-			Override(new(dtypes.ClientBlockstore), modules.ClientBlockstore),
-			Override(new(dtypes.ClientDAG), modules.ClientDAG),
+			Override(new(dtypes.ClientImportMgr), modules.ClientImportMgr),
+			Override(new(dtypes.ClientMultiDstore), modules.ClientMultiDatastore),
 
+			Override(new(dtypes.ClientBlockstore), modules.ClientBlockstore),
+			Override(new(dtypes.ClientRetrievalStoreManager), modules.ClientRetrievalStoreManager),
 			Override(new(ci.PrivKey), lp2p.PrivKey),
 			Override(new(ci.PubKey), ci.PrivKey.GetPublic),
 			Override(new(peer.ID), peer.IDFromPublicKey),
@@ -380,17 +494,26 @@ func Repo(r repo.Repo) Option {
 			Override(new(types.KeyStore), modules.KeyStore),
 
 			Override(new(*dtypes.APIAlg), modules.APISecret),
+
+			ApplyIf(isType(repo.FullNode), ConfigFullNode(c)),
+			ApplyIf(isType(repo.StorageMiner), ConfigStorageMiner(c)),
 		)(settings)
 	}
 }
 
 func FullAPI(out *api.FullNode) Option {
-	return func(s *Settings) error {
-		resAPI := &impl.FullNodeAPI{}
-		s.invokes[ExtractApiKey] = fx.Extract(resAPI)
-		*out = resAPI
-		return nil
-	}
+	return Options(
+		func(s *Settings) error {
+			s.nodeType = repo.FullNode
+			return nil
+		},
+		func(s *Settings) error {
+			resAPI := &impl.FullNodeAPI{}
+			s.invokes[ExtractApiKey] = fx.Populate(resAPI)
+			*out = resAPI
+			return nil
+		},
+	)
 }
 
 type StopFunc func(context.Context) error
@@ -398,14 +521,13 @@ type StopFunc func(context.Context) error
 // New builds and starts new Filecoin node
 func New(ctx context.Context, opts ...Option) (StopFunc, error) {
 	settings := Settings{
-		modules:  map[interface{}]fx.Option{},
-		invokes:  make([]fx.Option, _nInvokes),
-		nodeType: repo.FullNode,
+		modules: map[interface{}]fx.Option{},
+		invokes: make([]fx.Option, _nInvokes),
 	}
 
 	// apply module options in the right order
 	if err := Options(Options(defaults()...), Options(opts...))(&settings); err != nil {
-		return nil, err
+		return nil, xerrors.Errorf("applying node options failed: %w", err)
 	}
 
 	// gather constructors for fx.Options
@@ -433,7 +555,7 @@ func New(ctx context.Context, opts ...Option) (StopFunc, error) {
 	//  correctly
 	if err := app.Start(ctx); err != nil {
 		// comment fx.NopLogger few lines above for easier debugging
-		return nil, err
+		return nil, xerrors.Errorf("starting node: %w", err)
 	}
 
 	return app.Stop, nil
@@ -445,5 +567,6 @@ func Test() Option {
 	return Options(
 		Unset(RunPeerMgrKey),
 		Unset(new(*peermgr.PeerMgr)),
+		Override(new(beacon.Schedule), testing.RandomBeacon),
 	)
 }
diff --git a/node/config/def.go b/node/config/def.go
index 97ed036d5..9fee8895a 100644
--- a/node/config/def.go
+++ b/node/config/def.go
@@ -3,62 +3,106 @@ package config
 import (
 	"encoding"
 	"time"
+
+	"github.com/ipfs/go-cid"
+
+	"github.com/filecoin-project/lotus/chain/types"
+	sectorstorage "github.com/filecoin-project/lotus/extern/sector-storage"
 )
 
 // Common is common config between full node and miner
 type Common struct {
 	API    API
 	Libp2p Libp2p
+	Pubsub Pubsub
 }
 
 // FullNode is a full node config
 type FullNode struct {
 	Common
+	Client  Client
 	Metrics Metrics
 }
 
 // // Common
 
-// StorageMiner is a storage miner config
+// StorageMiner is a miner config
 type StorageMiner struct {
 	Common
 
-	SectorBuilder SectorBuilder
+	Dealmaking DealmakingConfig
+	Sealing    SealingConfig
+	Storage    sectorstorage.SealerConfig
+	Fees       MinerFeeConfig
+}
+
+type DealmakingConfig struct {
+	ConsiderOnlineStorageDeals    bool
+	ConsiderOfflineStorageDeals   bool
+	ConsiderOnlineRetrievalDeals  bool
+	ConsiderOfflineRetrievalDeals bool
+	PieceCidBlocklist             []cid.Cid
+	ExpectedSealDuration          Duration
+
+	Filter string
+}
+
+type SealingConfig struct {
+	// 0 = no limit
+	MaxWaitDealsSectors uint64
+
+	// includes failed, 0 = no limit
+	MaxSealingSectors uint64
+
+	// includes failed, 0 = no limit
+	MaxSealingSectorsForDeals uint64
+
+	WaitDealsDelay Duration
+}
+
+type MinerFeeConfig struct {
+	MaxPreCommitGasFee  types.FIL
+	MaxCommitGasFee     types.FIL
+	MaxWindowPoStGasFee types.FIL
 }
 
 // API contains configs for API endpoint
 type API struct {
-	ListenAddress string
-	Timeout       Duration
+	ListenAddress       string
+	RemoteListenAddress string
+	Timeout             Duration
 }
 
 // Libp2p contains configs for libp2p
 type Libp2p struct {
-	ListenAddresses []string
-	BootstrapPeers  []string
-	ProtectedPeers  []string
+	ListenAddresses     []string
+	AnnounceAddresses   []string
+	NoAnnounceAddresses []string
+	BootstrapPeers      []string
+	ProtectedPeers      []string
 
 	ConnMgrLow   uint
 	ConnMgrHigh  uint
 	ConnMgrGrace Duration
 }
 
+type Pubsub struct {
+	Bootstrapper bool
+	DirectPeers  []string
+	RemoteTracer string
+}
+
 // // Full Node
 
 type Metrics struct {
-	Nickname      string
-	HeadNotifs    bool
-	PubsubTracing bool
+	Nickname   string
+	HeadNotifs bool
 }
 
-// // Storage Miner
-
-type SectorBuilder struct {
-	Path        string
-	WorkerCount uint
-
-	DisableLocalPreCommit bool
-	DisableLocalCommit    bool
+type Client struct {
+	UseIpfs             bool
+	IpfsMAddr           string
+	IpfsUseForRetrieval bool
 }
 
 func defCommon() Common {
@@ -72,16 +116,23 @@ func defCommon() Common {
 				"/ip4/0.0.0.0/tcp/0",
 				"/ip6/::/tcp/0",
 			},
+			AnnounceAddresses:   []string{},
+			NoAnnounceAddresses: []string{},
 
 			ConnMgrLow:   150,
 			ConnMgrHigh:  180,
 			ConnMgrGrace: Duration(20 * time.Second),
 		},
+		Pubsub: Pubsub{
+			Bootstrapper: false,
+			DirectPeers:  nil,
+			RemoteTracer: "/dns4/pubsub-tracer.filecoin.io/tcp/4001/p2p/QmTd6UvR47vUidRNZ1ZKXHrAFhqTJAD27rKL9XYghEKgKX",
+		},
 	}
 
 }
 
-// Default returns the default config
+// DefaultFullNode returns the default config
 func DefaultFullNode() *FullNode {
 	return &FullNode{
 		Common: defCommon(),
@@ -92,11 +143,43 @@ func DefaultStorageMiner() *StorageMiner {
 	cfg := &StorageMiner{
 		Common: defCommon(),
 
-		SectorBuilder: SectorBuilder{
-			WorkerCount: 5,
+		Sealing: SealingConfig{
+			MaxWaitDealsSectors:       2, // 64G with 32G sectors
+			MaxSealingSectors:         0,
+			MaxSealingSectorsForDeals: 0,
+			WaitDealsDelay:            Duration(time.Hour),
+		},
+
+		Storage: sectorstorage.SealerConfig{
+			AllowAddPiece:   true,
+			AllowPreCommit1: true,
+			AllowPreCommit2: true,
+			AllowCommit:     true,
+			AllowUnseal:     true,
+
+			// Default to 10 - tcp should still be able to figure this out, and
+			// it's the ratio between 10gbit / 1gbit
+			ParallelFetchLimit: 10,
+		},
+
+		Dealmaking: DealmakingConfig{
+			ConsiderOnlineStorageDeals:    true,
+			ConsiderOfflineStorageDeals:   true,
+			ConsiderOnlineRetrievalDeals:  true,
+			ConsiderOfflineRetrievalDeals: true,
+			PieceCidBlocklist:             []cid.Cid{},
+			// TODO: It'd be nice to set this based on sector size
+			ExpectedSealDuration: Duration(time.Hour * 12),
+		},
+
+		Fees: MinerFeeConfig{
+			MaxPreCommitGasFee:  types.FIL(types.BigDiv(types.FromFil(1), types.NewInt(20))), // 0.05
+			MaxCommitGasFee:     types.FIL(types.BigDiv(types.FromFil(1), types.NewInt(20))),
+			MaxWindowPoStGasFee: types.FIL(types.FromFil(50)),
 		},
 	}
 	cfg.Common.API.ListenAddress = "/ip4/127.0.0.1/tcp/2345/http"
+	cfg.Common.API.RemoteListenAddress = "127.0.0.1:2345"
 	return cfg
 }
 
diff --git a/node/config/def_test.go b/node/config/def_test.go
new file mode 100644
index 000000000..d45bc6ec8
--- /dev/null
+++ b/node/config/def_test.go
@@ -0,0 +1,54 @@
+package config
+
+import (
+	"bytes"
+	"fmt"
+	"reflect"
+	"strings"
+	"testing"
+
+	"github.com/BurntSushi/toml"
+	"github.com/stretchr/testify/require"
+)
+
+func TestDefaultFullNodeRoundtrip(t *testing.T) {
+	c := DefaultFullNode()
+
+	var s string
+	{
+		buf := new(bytes.Buffer)
+		_, _ = buf.WriteString("# Default config:\n")
+		e := toml.NewEncoder(buf)
+		require.NoError(t, e.Encode(c))
+
+		s = buf.String()
+	}
+
+	c2, err := FromReader(strings.NewReader(s), DefaultFullNode())
+	require.NoError(t, err)
+
+	fmt.Println(s)
+
+	require.True(t, reflect.DeepEqual(c, c2))
+}
+
+func TestDefaultMinerRoundtrip(t *testing.T) {
+	c := DefaultStorageMiner()
+
+	var s string
+	{
+		buf := new(bytes.Buffer)
+		_, _ = buf.WriteString("# Default config:\n")
+		e := toml.NewEncoder(buf)
+		require.NoError(t, e.Encode(c))
+
+		s = buf.String()
+	}
+
+	c2, err := FromReader(strings.NewReader(s), DefaultStorageMiner())
+	require.NoError(t, err)
+
+	fmt.Println(s)
+
+	require.True(t, reflect.DeepEqual(c, c2))
+}
diff --git a/node/config/load.go b/node/config/load.go
index 352d17197..61e6e8f97 100644
--- a/node/config/load.go
+++ b/node/config/load.go
@@ -2,15 +2,17 @@ package config
 
 import (
 	"bytes"
+	"fmt"
 	"io"
 	"os"
 
 	"github.com/BurntSushi/toml"
+	"github.com/kelseyhightower/envconfig"
 	"golang.org/x/xerrors"
 )
 
 // FromFile loads config from a specified file overriding defaults specified in
-// the def parameter. If file does not exist or is empty defaults are asummed.
+// the def parameter. If file does not exist or is empty defaults are assumed.
 func FromFile(path string, def interface{}) (interface{}, error) {
 	file, err := os.Open(path)
 	switch {
@@ -32,6 +34,11 @@ func FromReader(reader io.Reader, def interface{}) (interface{}, error) {
 		return nil, err
 	}
 
+	err = envconfig.Process("LOTUS", cfg)
+	if err != nil {
+		return nil, fmt.Errorf("processing env vars overrides: %s", err)
+	}
+
 	return cfg, nil
 }
 
@@ -46,5 +53,4 @@ func ConfigComment(t interface{}) ([]byte, error) {
 	b = bytes.ReplaceAll(b, []byte("\n"), []byte("\n#"))
 	b = bytes.ReplaceAll(b, []byte("#["), []byte("["))
 	return b, nil
-
 }
diff --git a/node/config/storage.go b/node/config/storage.go
new file mode 100644
index 000000000..68170ee2f
--- /dev/null
+++ b/node/config/storage.go
@@ -0,0 +1,51 @@
+package config
+
+import (
+	"encoding/json"
+	"io"
+	"io/ioutil"
+	"os"
+
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/lotus/extern/sector-storage/stores"
+)
+
+func StorageFromFile(path string, def *stores.StorageConfig) (*stores.StorageConfig, error) {
+	file, err := os.Open(path)
+	switch {
+	case os.IsNotExist(err):
+		if def == nil {
+			return nil, xerrors.Errorf("couldn't load storage config: %w", err)
+		}
+		return def, nil
+	case err != nil:
+		return nil, err
+	}
+
+	defer file.Close() //nolint:errcheck // The file is RO
+	return StorageFromReader(file)
+}
+
+func StorageFromReader(reader io.Reader) (*stores.StorageConfig, error) {
+	var cfg stores.StorageConfig
+	err := json.NewDecoder(reader).Decode(&cfg)
+	if err != nil {
+		return nil, err
+	}
+
+	return &cfg, nil
+}
+
+func WriteStorageFile(path string, config stores.StorageConfig) error {
+	b, err := json.MarshalIndent(config, "", "  ")
+	if err != nil {
+		return xerrors.Errorf("marshaling storage config: %w", err)
+	}
+
+	if err := ioutil.WriteFile(path, b, 0644); err != nil {
+		return xerrors.Errorf("persisting storage config (%s): %w", path, err)
+	}
+
+	return nil
+}
diff --git a/node/fxlog.go b/node/fxlog.go
index 3f0e18d64..d5d1a3e1f 100644
--- a/node/fxlog.go
+++ b/node/fxlog.go
@@ -1,7 +1,7 @@
 package node
 
 import (
-	logging "github.com/ipfs/go-log"
+	logging "github.com/ipfs/go-log/v2"
 
 	"go.uber.org/fx"
 )
diff --git a/node/hello/cbor_gen.go b/node/hello/cbor_gen.go
new file mode 100644
index 000000000..3b85e3a74
--- /dev/null
+++ b/node/hello/cbor_gen.go
@@ -0,0 +1,270 @@
+// Code generated by github.com/whyrusleeping/cbor-gen. DO NOT EDIT.
+
+package hello
+
+import (
+	"fmt"
+	"io"
+
+	abi "github.com/filecoin-project/go-state-types/abi"
+	cid "github.com/ipfs/go-cid"
+	cbg "github.com/whyrusleeping/cbor-gen"
+	xerrors "golang.org/x/xerrors"
+)
+
+var _ = xerrors.Errorf
+
+var lengthBufHelloMessage = []byte{132}
+
+func (t *HelloMessage) MarshalCBOR(w io.Writer) error {
+	if t == nil {
+		_, err := w.Write(cbg.CborNull)
+		return err
+	}
+	if _, err := w.Write(lengthBufHelloMessage); err != nil {
+		return err
+	}
+
+	scratch := make([]byte, 9)
+
+	// t.HeaviestTipSet ([]cid.Cid) (slice)
+	if len(t.HeaviestTipSet) > cbg.MaxLength {
+		return xerrors.Errorf("Slice value in field t.HeaviestTipSet was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajArray, uint64(len(t.HeaviestTipSet))); err != nil {
+		return err
+	}
+	for _, v := range t.HeaviestTipSet {
+		if err := cbg.WriteCidBuf(scratch, w, v); err != nil {
+			return xerrors.Errorf("failed writing cid field t.HeaviestTipSet: %w", err)
+		}
+	}
+
+	// t.HeaviestTipSetHeight (abi.ChainEpoch) (int64)
+	if t.HeaviestTipSetHeight >= 0 {
+		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.HeaviestTipSetHeight)); err != nil {
+			return err
+		}
+	} else {
+		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajNegativeInt, uint64(-t.HeaviestTipSetHeight-1)); err != nil {
+			return err
+		}
+	}
+
+	// t.HeaviestTipSetWeight (big.Int) (struct)
+	if err := t.HeaviestTipSetWeight.MarshalCBOR(w); err != nil {
+		return err
+	}
+
+	// t.GenesisHash (cid.Cid) (struct)
+
+	if err := cbg.WriteCidBuf(scratch, w, t.GenesisHash); err != nil {
+		return xerrors.Errorf("failed to write cid field t.GenesisHash: %w", err)
+	}
+
+	return nil
+}
+
+func (t *HelloMessage) UnmarshalCBOR(r io.Reader) error {
+	*t = HelloMessage{}
+
+	br := cbg.GetPeeker(r)
+	scratch := make([]byte, 8)
+
+	maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
+	if err != nil {
+		return err
+	}
+	if maj != cbg.MajArray {
+		return fmt.Errorf("cbor input should be of type array")
+	}
+
+	if extra != 4 {
+		return fmt.Errorf("cbor input had wrong number of fields")
+	}
+
+	// t.HeaviestTipSet ([]cid.Cid) (slice)
+
+	maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
+	if err != nil {
+		return err
+	}
+
+	if extra > cbg.MaxLength {
+		return fmt.Errorf("t.HeaviestTipSet: array too large (%d)", extra)
+	}
+
+	if maj != cbg.MajArray {
+		return fmt.Errorf("expected cbor array")
+	}
+
+	if extra > 0 {
+		t.HeaviestTipSet = make([]cid.Cid, extra)
+	}
+
+	for i := 0; i < int(extra); i++ {
+
+		c, err := cbg.ReadCid(br)
+		if err != nil {
+			return xerrors.Errorf("reading cid field t.HeaviestTipSet failed: %w", err)
+		}
+		t.HeaviestTipSet[i] = c
+	}
+
+	// t.HeaviestTipSetHeight (abi.ChainEpoch) (int64)
+	{
+		maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
+		var extraI int64
+		if err != nil {
+			return err
+		}
+		switch maj {
+		case cbg.MajUnsignedInt:
+			extraI = int64(extra)
+			if extraI < 0 {
+				return fmt.Errorf("int64 positive overflow")
+			}
+		case cbg.MajNegativeInt:
+			extraI = int64(extra)
+			if extraI < 0 {
+				return fmt.Errorf("int64 negative oveflow")
+			}
+			extraI = -1 - extraI
+		default:
+			return fmt.Errorf("wrong type for int64 field: %d", maj)
+		}
+
+		t.HeaviestTipSetHeight = abi.ChainEpoch(extraI)
+	}
+	// t.HeaviestTipSetWeight (big.Int) (struct)
+
+	{
+
+		if err := t.HeaviestTipSetWeight.UnmarshalCBOR(br); err != nil {
+			return xerrors.Errorf("unmarshaling t.HeaviestTipSetWeight: %w", err)
+		}
+
+	}
+	// t.GenesisHash (cid.Cid) (struct)
+
+	{
+
+		c, err := cbg.ReadCid(br)
+		if err != nil {
+			return xerrors.Errorf("failed to read cid field t.GenesisHash: %w", err)
+		}
+
+		t.GenesisHash = c
+
+	}
+	return nil
+}
+
+var lengthBufLatencyMessage = []byte{130}
+
+func (t *LatencyMessage) MarshalCBOR(w io.Writer) error {
+	if t == nil {
+		_, err := w.Write(cbg.CborNull)
+		return err
+	}
+	if _, err := w.Write(lengthBufLatencyMessage); err != nil {
+		return err
+	}
+
+	scratch := make([]byte, 9)
+
+	// t.TArrival (int64) (int64)
+	if t.TArrival >= 0 {
+		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.TArrival)); err != nil {
+			return err
+		}
+	} else {
+		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajNegativeInt, uint64(-t.TArrival-1)); err != nil {
+			return err
+		}
+	}
+
+	// t.TSent (int64) (int64)
+	if t.TSent >= 0 {
+		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.TSent)); err != nil {
+			return err
+		}
+	} else {
+		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajNegativeInt, uint64(-t.TSent-1)); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (t *LatencyMessage) UnmarshalCBOR(r io.Reader) error {
+	*t = LatencyMessage{}
+
+	br := cbg.GetPeeker(r)
+	scratch := make([]byte, 8)
+
+	maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
+	if err != nil {
+		return err
+	}
+	if maj != cbg.MajArray {
+		return fmt.Errorf("cbor input should be of type array")
+	}
+
+	if extra != 2 {
+		return fmt.Errorf("cbor input had wrong number of fields")
+	}
+
+	// t.TArrival (int64) (int64)
+	{
+		maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
+		var extraI int64
+		if err != nil {
+			return err
+		}
+		switch maj {
+		case cbg.MajUnsignedInt:
+			extraI = int64(extra)
+			if extraI < 0 {
+				return fmt.Errorf("int64 positive overflow")
+			}
+		case cbg.MajNegativeInt:
+			extraI = int64(extra)
+			if extraI < 0 {
+				return fmt.Errorf("int64 negative oveflow")
+			}
+			extraI = -1 - extraI
+		default:
+			return fmt.Errorf("wrong type for int64 field: %d", maj)
+		}
+
+		t.TArrival = int64(extraI)
+	}
+	// t.TSent (int64) (int64)
+	{
+		maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
+		var extraI int64
+		if err != nil {
+			return err
+		}
+		switch maj {
+		case cbg.MajUnsignedInt:
+			extraI = int64(extra)
+			if extraI < 0 {
+				return fmt.Errorf("int64 positive overflow")
+			}
+		case cbg.MajNegativeInt:
+			extraI = int64(extra)
+			if extraI < 0 {
+				return fmt.Errorf("int64 negative oveflow")
+			}
+			extraI = -1 - extraI
+		default:
+			return fmt.Errorf("wrong type for int64 field: %d", maj)
+		}
+
+		t.TSent = int64(extraI)
+	}
+	return nil
+}
diff --git a/node/hello/hello.go b/node/hello/hello.go
index d05e0a0c8..05d53de06 100644
--- a/node/hello/hello.go
+++ b/node/hello/hello.go
@@ -4,36 +4,38 @@ import (
 	"context"
 	"time"
 
+	"github.com/filecoin-project/go-state-types/abi"
+	xerrors "golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-state-types/big"
 	"github.com/ipfs/go-cid"
-	cbor "github.com/ipfs/go-ipld-cbor"
-	logging "github.com/ipfs/go-log"
+	logging "github.com/ipfs/go-log/v2"
 	"github.com/libp2p/go-libp2p-core/host"
 	inet "github.com/libp2p/go-libp2p-core/network"
 	"github.com/libp2p/go-libp2p-core/peer"
 	protocol "github.com/libp2p/go-libp2p-core/protocol"
 
-	"github.com/filecoin-project/go-cbor-util"
+	cborutil "github.com/filecoin-project/go-cbor-util"
+	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain"
 	"github.com/filecoin-project/lotus/chain/store"
 	"github.com/filecoin-project/lotus/chain/types"
-	"github.com/filecoin-project/lotus/peermgr"
+	"github.com/filecoin-project/lotus/lib/peermgr"
 )
 
 const ProtocolID = "/fil/hello/1.0.0"
 
 var log = logging.Logger("hello")
 
-func init() {
-	cbor.RegisterCborType(Message{})
-}
-
-type Message struct {
+type HelloMessage struct {
 	HeaviestTipSet       []cid.Cid
-	HeaviestTipSetWeight types.BigInt
+	HeaviestTipSetHeight abi.ChainEpoch
+	HeaviestTipSetWeight big.Int
 	GenesisHash          cid.Cid
-
-	TArrial int64
-	TSent   int64
+}
+type LatencyMessage struct {
+	TArrival int64
+	TSent    int64
 }
 
 type NewStreamFunc func(context.Context, peer.ID, ...protocol.ID) (inet.Stream, error)
@@ -61,13 +63,13 @@ func NewHelloService(h host.Host, cs *store.ChainStore, syncer *chain.Syncer, pm
 
 func (hs *Service) HandleStream(s inet.Stream) {
 
-	var hmsg Message
+	var hmsg HelloMessage
 	if err := cborutil.ReadCborRPC(s, &hmsg); err != nil {
-		log.Infow("failed to read hello message, diconnecting", "error", err)
-		s.Conn().Close()
+		log.Infow("failed to read hello message, disconnecting", "error", err)
+		_ = s.Conn().Close()
 		return
 	}
-	arrived := time.Now()
+	arrived := build.Clock.Now()
 
 	log.Debugw("genesis from hello",
 		"tipset", hmsg.HeaviestTipSet,
@@ -76,25 +78,39 @@ func (hs *Service) HandleStream(s inet.Stream) {
 
 	if hmsg.GenesisHash != hs.syncer.Genesis.Cids()[0] {
 		log.Warnf("other peer has different genesis! (%s)", hmsg.GenesisHash)
-		s.Conn().Close()
+		_ = s.Conn().Close()
 		return
 	}
 	go func() {
-		defer s.Close()
+		defer s.Close() //nolint:errcheck
 
-		sent := time.Now()
-		msg := &Message{
-			TArrial: arrived.UnixNano(),
-			TSent:   sent.UnixNano(),
+		sent := build.Clock.Now()
+		msg := &LatencyMessage{
+			TArrival: arrived.UnixNano(),
+			TSent:    sent.UnixNano(),
 		}
 		if err := cborutil.WriteCborRPC(s, msg); err != nil {
 			log.Debugf("error while responding to latency: %v", err)
 		}
 	}()
 
+	protos, err := hs.h.Peerstore().GetProtocols(s.Conn().RemotePeer())
+	if err != nil {
+		log.Warnf("got error from peerstore.GetProtocols: %s", err)
+	}
+	if len(protos) == 0 {
+		log.Warn("other peer hasnt completed libp2p identify, waiting a bit")
+		// TODO: this better
+		build.Clock.Sleep(time.Millisecond * 300)
+	}
+
+	if hs.pmgr != nil {
+		hs.pmgr.AddFilecoinPeer(s.Conn().RemotePeer())
+	}
+
 	ts, err := hs.syncer.FetchTipSet(context.Background(), s.Conn().RemotePeer(), types.NewTipSetKey(hmsg.HeaviestTipSet...))
 	if err != nil {
-		log.Errorf("failed to fetch tipset from peer during hello: %s", err)
+		log.Errorf("failed to fetch tipset from peer during hello: %+v", err)
 		return
 	}
 
@@ -105,16 +121,13 @@ func (hs *Service) HandleStream(s inet.Stream) {
 		log.Infof("Got new tipset through Hello: %s from %s", ts.Cids(), s.Conn().RemotePeer())
 		hs.syncer.InformNewHead(s.Conn().RemotePeer(), ts)
 	}
-	if hs.pmgr != nil {
-		hs.pmgr.AddFilecoinPeer(s.Conn().RemotePeer())
-	}
 
 }
 
 func (hs *Service) SayHello(ctx context.Context, pid peer.ID) error {
 	s, err := hs.h.NewStream(ctx, pid, ProtocolID)
 	if err != nil {
-		return err
+		return xerrors.Errorf("error opening stream: %w", err)
 	}
 
 	hts := hs.cs.GetHeaviestTipSet()
@@ -128,37 +141,40 @@ func (hs *Service) SayHello(ctx context.Context, pid peer.ID) error {
 		return err
 	}
 
-	hmsg := &Message{
+	hmsg := &HelloMessage{
 		HeaviestTipSet:       hts.Cids(),
+		HeaviestTipSetHeight: hts.Height(),
 		HeaviestTipSetWeight: weight,
 		GenesisHash:          gen.Cid(),
 	}
 	log.Debug("Sending hello message: ", hts.Cids(), hts.Height(), gen.Cid())
 
-	t0 := time.Now()
+	t0 := build.Clock.Now()
 	if err := cborutil.WriteCborRPC(s, hmsg); err != nil {
-		return err
+		return xerrors.Errorf("writing rpc to peer: %w", err)
 	}
 
 	go func() {
-		defer s.Close()
+		defer s.Close() //nolint:errcheck
 
-		hmsg = &Message{}
-		s.SetReadDeadline(time.Now().Add(10 * time.Second))
-		err := cborutil.ReadCborRPC(s, hmsg)
-		ok := err == nil
+		lmsg := &LatencyMessage{}
+		_ = s.SetReadDeadline(build.Clock.Now().Add(10 * time.Second))
+		err := cborutil.ReadCborRPC(s, lmsg)
+		if err != nil {
+			log.Infow("reading latency message", "error", err)
+		}
 
-		t3 := time.Now()
+		t3 := build.Clock.Now()
 		lat := t3.Sub(t0)
 		// add to peer tracker
 		if hs.pmgr != nil {
 			hs.pmgr.SetPeerLatency(pid, lat)
 		}
 
-		if ok {
-			if hmsg.TArrial != 0 && hmsg.TSent != 0 {
-				t1 := time.Unix(0, hmsg.TArrial)
-				t2 := time.Unix(0, hmsg.TSent)
+		if err == nil {
+			if lmsg.TArrival != 0 && lmsg.TSent != 0 {
+				t1 := time.Unix(0, lmsg.TArrival)
+				t2 := time.Unix(0, lmsg.TSent)
 				offset := t0.Sub(t1) + t3.Sub(t2)
 				offset /= 2
 				log.Infow("time offset", "offset", offset.Seconds(), "peerid", pid.String())
diff --git a/node/impl/client/client.go b/node/impl/client/client.go
index a0c420e7e..81978af16 100644
--- a/node/impl/client/client.go
+++ b/node/impl/client/client.go
@@ -2,39 +2,65 @@ package client
 
 import (
 	"context"
-	"errors"
+	"fmt"
 	"io"
-	"math"
 	"os"
 
+	"github.com/filecoin-project/go-state-types/dline"
+
+	datatransfer "github.com/filecoin-project/go-data-transfer"
+	"github.com/filecoin-project/go-state-types/big"
 	"golang.org/x/xerrors"
 
 	"github.com/ipfs/go-blockservice"
 	"github.com/ipfs/go-cid"
-	"github.com/ipfs/go-filestore"
+	"github.com/ipfs/go-cidutil"
 	chunker "github.com/ipfs/go-ipfs-chunker"
 	offline "github.com/ipfs/go-ipfs-exchange-offline"
 	files "github.com/ipfs/go-ipfs-files"
 	ipld "github.com/ipfs/go-ipld-format"
 	"github.com/ipfs/go-merkledag"
+	unixfile "github.com/ipfs/go-unixfs/file"
 	"github.com/ipfs/go-unixfs/importer/balanced"
 	ihelper "github.com/ipfs/go-unixfs/importer/helpers"
+	"github.com/ipld/go-car"
+	basicnode "github.com/ipld/go-ipld-prime/node/basic"
+	"github.com/ipld/go-ipld-prime/traversal/selector"
+	"github.com/ipld/go-ipld-prime/traversal/selector/builder"
+	"github.com/libp2p/go-libp2p-core/host"
 	"github.com/libp2p/go-libp2p-core/peer"
+	mh "github.com/multiformats/go-multihash"
 	"go.uber.org/fx"
 
 	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-fil-markets/pieceio"
+	"github.com/filecoin-project/go-fil-markets/retrievalmarket"
+	rm "github.com/filecoin-project/go-fil-markets/retrievalmarket"
+	"github.com/filecoin-project/go-fil-markets/shared"
+	"github.com/filecoin-project/go-fil-markets/storagemarket"
+	"github.com/filecoin-project/go-multistore"
+	"github.com/filecoin-project/go-padreader"
+	"github.com/filecoin-project/go-state-types/abi"
+	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
+
+	"github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper"
+	marketevents "github.com/filecoin-project/lotus/markets/loggers"
+
 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/build"
-	"github.com/filecoin-project/lotus/chain/deals"
 	"github.com/filecoin-project/lotus/chain/store"
 	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/markets/utils"
 	"github.com/filecoin-project/lotus/node/impl/full"
 	"github.com/filecoin-project/lotus/node/impl/paych"
 	"github.com/filecoin-project/lotus/node/modules/dtypes"
-	"github.com/filecoin-project/lotus/retrieval"
-	"github.com/filecoin-project/lotus/retrieval/discovery"
+	"github.com/filecoin-project/lotus/node/repo/importmgr"
 )
 
+var DefaultHashFunction = uint64(mh.BLAKE2B_MIN + 31)
+
+const dealStartBufferHours uint64 = 24
+
 type API struct {
 	fx.In
 
@@ -43,56 +69,116 @@ type API struct {
 	full.WalletAPI
 	paych.PaychAPI
 
-	DealClient   *deals.Client
-	RetDiscovery discovery.PeerResolver
-	Retrieval    *retrieval.Client
+	SMDealClient storagemarket.StorageClient
+	RetDiscovery rm.PeerResolver
+	Retrieval    rm.RetrievalClient
 	Chain        *store.ChainStore
 
-	LocalDAG   dtypes.ClientDAG
-	Blockstore dtypes.ClientBlockstore
-	Filestore  dtypes.ClientFilestore `optional:"true"`
+	Imports dtypes.ClientImportMgr
+
+	CombinedBstore    dtypes.ClientBlockstore // TODO: try to remove
+	RetrievalStoreMgr dtypes.ClientRetrievalStoreManager
+	DataTransfer      dtypes.ClientDataTransfer
+	Host              host.Host
 }
 
-func (a *API) ClientStartDeal(ctx context.Context, data cid.Cid, addr address.Address, miner address.Address, epochPrice types.BigInt, blocksDuration uint64) (*cid.Cid, error) {
-	exist, err := a.WalletHas(ctx, addr)
+func calcDealExpiration(minDuration uint64, md *dline.Info, startEpoch abi.ChainEpoch) abi.ChainEpoch {
+	// Make sure we give some time for the miner to seal
+	minExp := startEpoch + abi.ChainEpoch(minDuration)
+
+	// Align on miners ProvingPeriodBoundary
+	return minExp + miner0.WPoStProvingPeriod - (minExp % miner0.WPoStProvingPeriod) + (md.PeriodStart % miner0.WPoStProvingPeriod) - 1
+}
+
+func (a *API) imgr() *importmgr.Mgr {
+	return a.Imports
+}
+
+func (a *API) ClientStartDeal(ctx context.Context, params *api.StartDealParams) (*cid.Cid, error) {
+	var storeID *multistore.StoreID
+	if params.Data.TransferType == storagemarket.TTGraphsync {
+		importIDs := a.imgr().List()
+		for _, importID := range importIDs {
+			info, err := a.imgr().Info(importID)
+			if err != nil {
+				continue
+			}
+			if info.Labels[importmgr.LRootCid] == "" {
+				continue
+			}
+			c, err := cid.Parse(info.Labels[importmgr.LRootCid])
+			if err != nil {
+				continue
+			}
+			if c.Equals(params.Data.Root) {
+				storeID = &importID //nolint
+				break
+			}
+		}
+	}
+	exist, err := a.WalletHas(ctx, params.Wallet)
 	if err != nil {
-		return nil, xerrors.Errorf("failed getting addr from wallet: %w", addr)
+		return nil, xerrors.Errorf("failed getting addr from wallet: %w", params.Wallet)
 	}
 	if !exist {
 		return nil, xerrors.Errorf("provided address doesn't exist in wallet")
 	}
 
-	pid, err := a.StateMinerPeerID(ctx, miner, nil)
+	mi, err := a.StateMinerInfo(ctx, params.Miner, types.EmptyTSK)
 	if err != nil {
 		return nil, xerrors.Errorf("failed getting peer ID: %w", err)
 	}
 
-	mw, err := a.StateMinerWorker(ctx, miner, nil)
+	md, err := a.StateMinerProvingDeadline(ctx, params.Miner, types.EmptyTSK)
 	if err != nil {
-		return nil, xerrors.Errorf("failed getting miner worker: %w", err)
+		return nil, xerrors.Errorf("failed getting miner's deadline info: %w", err)
 	}
 
-	proposal := deals.ClientDealProposal{
-		Data:               data,
-		PricePerEpoch:      epochPrice,
-		ProposalExpiration: math.MaxUint64, // TODO: set something reasonable
-		Duration:           blocksDuration,
-		Client:             addr,
-		ProviderAddress:    miner,
-		MinerWorker:        mw,
-		MinerID:            pid,
+	rt, err := ffiwrapper.SealProofTypeFromSectorSize(mi.SectorSize)
+	if err != nil {
+		return nil, xerrors.Errorf("bad sector size: %w", err)
 	}
 
-	c, err := a.DealClient.Start(ctx, proposal)
+	if uint64(params.Data.PieceSize.Padded()) > uint64(mi.SectorSize) {
+		return nil, xerrors.New("data doesn't fit in a sector")
+	}
+
+	providerInfo := utils.NewStorageProviderInfo(params.Miner, mi.Worker, mi.SectorSize, *mi.PeerId, mi.Multiaddrs)
+
+	dealStart := params.DealStartEpoch
+	if dealStart <= 0 { // unset, or explicitly 'epoch undefined'
+		ts, err := a.ChainHead(ctx)
+		if err != nil {
+			return nil, xerrors.Errorf("failed getting chain height: %w", err)
+		}
+
+		blocksPerHour := 60 * 60 / build.BlockDelaySecs
+		dealStart = ts.Height() + abi.ChainEpoch(dealStartBufferHours*blocksPerHour)
+	}
+
+	result, err := a.SMDealClient.ProposeStorageDeal(ctx, storagemarket.ProposeStorageDealParams{
+		Addr:          params.Wallet,
+		Info:          &providerInfo,
+		Data:          params.Data,
+		StartEpoch:    dealStart,
+		EndEpoch:      calcDealExpiration(params.MinBlocksDuration, md, dealStart),
+		Price:         params.EpochPrice,
+		Collateral:    params.ProviderCollateral,
+		Rt:            rt,
+		FastRetrieval: params.FastRetrieval,
+		VerifiedDeal:  params.VerifiedDeal,
+		StoreID:       storeID,
+	})
+
 	if err != nil {
 		return nil, xerrors.Errorf("failed to start deal: %w", err)
 	}
 
-	return &c, nil
+	return &result.ProposalCid, nil
 }
 
 func (a *API) ClientListDeals(ctx context.Context) ([]api.DealInfo, error) {
-	deals, err := a.DealClient.List()
+	deals, err := a.SMDealClient.ListLocalDeals(ctx)
 	if err != nil {
 		return nil, err
 	}
@@ -101,14 +187,18 @@ func (a *API) ClientListDeals(ctx context.Context) ([]api.DealInfo, error) {
 	for k, v := range deals {
 		out[k] = api.DealInfo{
 			ProposalCid: v.ProposalCid,
+			DataRef:     v.DataRef,
 			State:       v.State,
+			Message:     v.Message,
 			Provider:    v.Proposal.Provider,
 
-			PieceRef: v.Proposal.PieceRef,
-			Size:     v.Proposal.PieceSize,
+			PieceCID: v.Proposal.PieceCID,
+			Size:     uint64(v.Proposal.PieceSize.Unpadded()),
 
 			PricePerEpoch: v.Proposal.StoragePricePerEpoch,
-			Duration:      v.Proposal.Duration,
+			Duration:      uint64(v.Proposal.Duration()),
+			DealID:        v.DealID,
+			CreationTime:  v.CreationTime.Time(),
 		}
 	}
 
@@ -116,25 +206,44 @@ func (a *API) ClientListDeals(ctx context.Context) ([]api.DealInfo, error) {
 }
 
 func (a *API) ClientGetDealInfo(ctx context.Context, d cid.Cid) (*api.DealInfo, error) {
-	v, err := a.DealClient.GetDeal(d)
+	v, err := a.SMDealClient.GetLocalDeal(ctx, d)
 	if err != nil {
 		return nil, err
 	}
+
 	return &api.DealInfo{
 		ProposalCid:   v.ProposalCid,
 		State:         v.State,
+		Message:       v.Message,
 		Provider:      v.Proposal.Provider,
-		PieceRef:      v.Proposal.PieceRef,
-		Size:          v.Proposal.PieceSize,
+		PieceCID:      v.Proposal.PieceCID,
+		Size:          uint64(v.Proposal.PieceSize.Unpadded()),
 		PricePerEpoch: v.Proposal.StoragePricePerEpoch,
-		Duration:      v.Proposal.Duration,
+		Duration:      uint64(v.Proposal.Duration()),
+		DealID:        v.DealID,
+		CreationTime:  v.CreationTime.Time(),
 	}, nil
 }
 
+func (a *API) ClientGetDealUpdates(ctx context.Context) (<-chan api.DealInfo, error) {
+	updates := make(chan api.DealInfo)
+
+	unsub := a.SMDealClient.SubscribeToEvents(func(_ storagemarket.ClientEvent, deal storagemarket.ClientDeal) {
+		updates <- newDealInfo(deal)
+	})
+
+	go func() {
+		defer unsub()
+		<-ctx.Done()
+	}()
+
+	return updates, nil
+}
+
 func (a *API) ClientHasLocal(ctx context.Context, root cid.Cid) (bool, error) {
 	// TODO: check if we have the ENTIRE dag
 
-	offExch := merkledag.NewDAGService(blockservice.New(a.Blockstore, offline.Exchange(a.Blockstore)))
+	offExch := merkledag.NewDAGService(blockservice.New(a.Imports.Blockstore, offline.Exchange(a.Imports.Blockstore)))
 	_, err := offExch.Get(ctx, root)
 	if err == ipld.ErrNotFound {
 		return false, nil
@@ -145,71 +254,123 @@ func (a *API) ClientHasLocal(ctx context.Context, root cid.Cid) (bool, error) {
 	return true, nil
 }
 
-func (a *API) ClientFindData(ctx context.Context, root cid.Cid) ([]api.QueryOffer, error) {
+func (a *API) ClientFindData(ctx context.Context, root cid.Cid, piece *cid.Cid) ([]api.QueryOffer, error) {
 	peers, err := a.RetDiscovery.GetPeers(root)
 	if err != nil {
 		return nil, err
 	}
 
-	out := make([]api.QueryOffer, len(peers))
-	for k, p := range peers {
-		out[k] = a.Retrieval.Query(ctx, p, root)
+	out := make([]api.QueryOffer, 0, len(peers))
+	for _, p := range peers {
+		if piece != nil && !piece.Equals(*p.PieceCID) {
+			continue
+		}
+		out = append(out, a.makeRetrievalQuery(ctx, p, root, piece, rm.QueryParams{}))
 	}
 
 	return out, nil
 }
 
-func (a *API) ClientImport(ctx context.Context, path string) (cid.Cid, error) {
-	f, err := os.Open(path)
+func (a *API) ClientMinerQueryOffer(ctx context.Context, miner address.Address, root cid.Cid, piece *cid.Cid) (api.QueryOffer, error) {
+	mi, err := a.StateMinerInfo(ctx, miner, types.EmptyTSK)
 	if err != nil {
-		return cid.Undef, err
+		return api.QueryOffer{}, err
 	}
-	stat, err := f.Stat()
+	rp := rm.RetrievalPeer{
+		Address: miner,
+		ID:      *mi.PeerId,
+	}
+	return a.makeRetrievalQuery(ctx, rp, root, piece, rm.QueryParams{}), nil
+}
+
+func (a *API) makeRetrievalQuery(ctx context.Context, rp rm.RetrievalPeer, payload cid.Cid, piece *cid.Cid, qp rm.QueryParams) api.QueryOffer {
+	queryResponse, err := a.Retrieval.Query(ctx, rp, payload, qp)
 	if err != nil {
-		return cid.Undef, err
+		return api.QueryOffer{Err: err.Error(), Miner: rp.Address, MinerPeer: rp}
+	}
+	var errStr string
+	switch queryResponse.Status {
+	case rm.QueryResponseAvailable:
+		errStr = ""
+	case rm.QueryResponseUnavailable:
+		errStr = fmt.Sprintf("retrieval query offer was unavailable: %s", queryResponse.Message)
+	case rm.QueryResponseError:
+		errStr = fmt.Sprintf("retrieval query offer errored: %s", queryResponse.Message)
 	}
 
-	file, err := files.NewReaderPathFile(path, f, stat)
+	return api.QueryOffer{
+		Root:                    payload,
+		Piece:                   piece,
+		Size:                    queryResponse.Size,
+		MinPrice:                queryResponse.PieceRetrievalPrice(),
+		UnsealPrice:             queryResponse.UnsealPrice,
+		PaymentInterval:         queryResponse.MaxPaymentInterval,
+		PaymentIntervalIncrease: queryResponse.MaxPaymentIntervalIncrease,
+		Miner:                   queryResponse.PaymentAddress, // TODO: check
+		MinerPeer:               rp,
+		Err:                     errStr,
+	}
+}
+
+func (a *API) ClientImport(ctx context.Context, ref api.FileRef) (*api.ImportRes, error) {
+	id, st, err := a.imgr().NewStore()
 	if err != nil {
-		return cid.Undef, err
+		return nil, err
+	}
+	if err := a.imgr().AddLabel(id, importmgr.LSource, "import"); err != nil {
+		return nil, err
 	}
 
-	bufferedDS := ipld.NewBufferedDAG(ctx, a.LocalDAG)
-
-	params := ihelper.DagBuilderParams{
-		Maxlinks:   build.UnixfsLinksPerLevel,
-		RawLeaves:  true,
-		CidBuilder: nil,
-		Dagserv:    bufferedDS,
-		NoCopy:     true,
+	if err := a.imgr().AddLabel(id, importmgr.LFileName, ref.Path); err != nil {
+		return nil, err
 	}
 
-	db, err := params.New(chunker.NewSizeSplitter(file, int64(build.UnixfsChunkSize)))
+	nd, err := a.clientImport(ctx, ref, st)
 	if err != nil {
-		return cid.Undef, err
-	}
-	nd, err := balanced.Layout(db)
-	if err != nil {
-		return cid.Undef, err
+		return nil, err
 	}
 
-	if err := bufferedDS.Commit(); err != nil {
-		return cid.Undef, err
+	if err := a.imgr().AddLabel(id, importmgr.LRootCid, nd.String()); err != nil {
+		return nil, err
 	}
 
-	return nd.Cid(), nil
+	return &api.ImportRes{
+		Root:     nd,
+		ImportID: id,
+	}, nil
+}
+
+func (a *API) ClientRemoveImport(ctx context.Context, importID multistore.StoreID) error {
+	return a.imgr().Remove(importID)
 }
 
 func (a *API) ClientImportLocal(ctx context.Context, f io.Reader) (cid.Cid, error) {
 	file := files.NewReaderFile(f)
 
-	bufferedDS := ipld.NewBufferedDAG(ctx, a.LocalDAG)
+	id, st, err := a.imgr().NewStore()
+	if err != nil {
+		return cid.Undef, err
+	}
+	if err := a.imgr().AddLabel(id, "source", "import-local"); err != nil {
+		return cid.Cid{}, err
+	}
+
+	bufferedDS := ipld.NewBufferedDAG(ctx, st.DAG)
+
+	prefix, err := merkledag.PrefixForCidVersion(1)
+	if err != nil {
+		return cid.Undef, err
+	}
+	prefix.MhType = DefaultHashFunction
 
 	params := ihelper.DagBuilderParams{
-		Maxlinks:   build.UnixfsLinksPerLevel,
-		RawLeaves:  true,
-		CidBuilder: nil,
-		Dagserv:    bufferedDS,
+		Maxlinks:  build.UnixfsLinksPerLevel,
+		RawLeaves: true,
+		CidBuilder: cidutil.InlineBuilder{
+			Builder: prefix,
+			Limit:   126,
+		},
+		Dagserv: bufferedDS,
 	}
 
 	db, err := params.New(chunker.NewSizeSplitter(file, int64(build.UnixfsChunkSize)))
@@ -220,63 +381,475 @@ func (a *API) ClientImportLocal(ctx context.Context, f io.Reader) (cid.Cid, erro
 	if err != nil {
 		return cid.Undef, err
 	}
+	if err := a.imgr().AddLabel(id, "root", nd.Cid().String()); err != nil {
+		return cid.Cid{}, err
+	}
 
 	return nd.Cid(), bufferedDS.Commit()
 }
 
 func (a *API) ClientListImports(ctx context.Context) ([]api.Import, error) {
-	if a.Filestore == nil {
-		return nil, errors.New("listing imports is not supported with in-memory dag yet")
+	importIDs := a.imgr().List()
+
+	out := make([]api.Import, len(importIDs))
+	for i, id := range importIDs {
+		info, err := a.imgr().Info(id)
+		if err != nil {
+			out[i] = api.Import{
+				Key: id,
+				Err: xerrors.Errorf("getting info: %w", err).Error(),
+			}
+			continue
+		}
+
+		ai := api.Import{
+			Key:      id,
+			Source:   info.Labels[importmgr.LSource],
+			FilePath: info.Labels[importmgr.LFileName],
+		}
+
+		if info.Labels[importmgr.LRootCid] != "" {
+			c, err := cid.Parse(info.Labels[importmgr.LRootCid])
+			if err != nil {
+				ai.Err = err.Error()
+			} else {
+				ai.Root = &c
+			}
+		}
+
+		out[i] = ai
 	}
-	next, err := filestore.ListAll(a.Filestore, false)
+
+	return out, nil
+}
+
+func (a *API) ClientRetrieve(ctx context.Context, order api.RetrievalOrder, ref *api.FileRef) error {
+	events := make(chan marketevents.RetrievalEvent)
+	go a.clientRetrieve(ctx, order, ref, events)
+
+	for {
+		select {
+		case evt, ok := <-events:
+			if !ok { // done successfully
+				return nil
+			}
+
+			if evt.Err != "" {
+				return xerrors.Errorf("retrieval failed: %s", evt.Err)
+			}
+		case <-ctx.Done():
+			return xerrors.Errorf("retrieval timed out")
+		}
+	}
+}
+
+func (a *API) ClientRetrieveWithEvents(ctx context.Context, order api.RetrievalOrder, ref *api.FileRef) (<-chan marketevents.RetrievalEvent, error) {
+	events := make(chan marketevents.RetrievalEvent)
+	go a.clientRetrieve(ctx, order, ref, events)
+	return events, nil
+}
+
+type retrievalSubscribeEvent struct {
+	event rm.ClientEvent
+	state rm.ClientDealState
+}
+
+func readSubscribeEvents(ctx context.Context, subscribeEvents chan retrievalSubscribeEvent, events chan marketevents.RetrievalEvent) error {
+	for {
+		var subscribeEvent retrievalSubscribeEvent
+		select {
+		case <-ctx.Done():
+			return xerrors.New("Retrieval Timed Out")
+		case subscribeEvent = <-subscribeEvents:
+		}
+
+		select {
+		case <-ctx.Done():
+			return xerrors.New("Retrieval Timed Out")
+		case events <- marketevents.RetrievalEvent{
+			Event:         subscribeEvent.event,
+			Status:        subscribeEvent.state.Status,
+			BytesReceived: subscribeEvent.state.TotalReceived,
+			FundsSpent:    subscribeEvent.state.FundsSpent,
+		}:
+		}
+
+		state := subscribeEvent.state
+		switch state.Status {
+		case rm.DealStatusCompleted:
+			return nil
+		case rm.DealStatusRejected:
+			return xerrors.Errorf("Retrieval Proposal Rejected: %s", state.Message)
+		case
+			rm.DealStatusDealNotFound,
+			rm.DealStatusErrored:
+			return xerrors.Errorf("Retrieval Error: %s", state.Message)
+		}
+	}
+}
+
+func (a *API) clientRetrieve(ctx context.Context, order api.RetrievalOrder, ref *api.FileRef, events chan marketevents.RetrievalEvent) {
+	defer close(events)
+
+	finish := func(e error) {
+		if e != nil {
+			events <- marketevents.RetrievalEvent{Err: e.Error(), FundsSpent: big.Zero()}
+		}
+	}
+
+	if order.MinerPeer.ID == "" {
+		mi, err := a.StateMinerInfo(ctx, order.Miner, types.EmptyTSK)
+		if err != nil {
+			finish(err)
+			return
+		}
+
+		order.MinerPeer = retrievalmarket.RetrievalPeer{
+			ID:      *mi.PeerId,
+			Address: order.Miner,
+		}
+	}
+
+	if order.Size == 0 {
+		finish(xerrors.Errorf("cannot make retrieval deal for zero bytes"))
+		return
+	}
+
+	/*id, st, err := a.imgr().NewStore()
+	if err != nil {
+		return err
+	}
+	if err := a.imgr().AddLabel(id, "source", "retrieval"); err != nil {
+		return err
+	}*/
+
+	var dealID retrievalmarket.DealID
+	subscribeEvents := make(chan retrievalSubscribeEvent, 1)
+	subscribeCtx, cancel := context.WithCancel(ctx)
+	defer cancel()
+	unsubscribe := a.Retrieval.SubscribeToEvents(func(event rm.ClientEvent, state rm.ClientDealState) {
+		if state.PayloadCID.Equals(order.Root) && state.ID == dealID {
+			select {
+			case <-subscribeCtx.Done():
+			case subscribeEvents <- retrievalSubscribeEvent{event, state}:
+			}
+		}
+	})
+
+	ppb := types.BigDiv(order.Total, types.NewInt(order.Size))
+
+	params, err := rm.NewParamsV1(ppb, order.PaymentInterval, order.PaymentIntervalIncrease, shared.AllSelector(), order.Piece, order.UnsealPrice)
+	if err != nil {
+		finish(xerrors.Errorf("Error in retrieval params: %s", err))
+		return
+	}
+
+	store, err := a.RetrievalStoreMgr.NewStore()
+	if err != nil {
+		finish(xerrors.Errorf("Error setting up new store: %w", err))
+		return
+	}
+
+	defer func() {
+		_ = a.RetrievalStoreMgr.ReleaseStore(store)
+	}()
+
+	dealID, err = a.Retrieval.Retrieve(
+		ctx,
+		order.Root,
+		params,
+		order.Total,
+		order.MinerPeer,
+		order.Client,
+		order.Miner,
+		store.StoreID())
+
+	if err != nil {
+		finish(xerrors.Errorf("Retrieve failed: %w", err))
+		return
+	}
+
+	err = readSubscribeEvents(ctx, subscribeEvents, events)
+
+	unsubscribe()
+	if err != nil {
+		finish(xerrors.Errorf("Retrieve: %w", err))
+		return
+	}
+
+	// If ref is nil, it only fetches the data into the configured blockstore.
+	if ref == nil {
+		finish(nil)
+		return
+	}
+
+	rdag := store.DAGService()
+
+	if ref.IsCAR {
+		f, err := os.OpenFile(ref.Path, os.O_CREATE|os.O_WRONLY, 0644)
+		if err != nil {
+			finish(err)
+			return
+		}
+		err = car.WriteCar(ctx, rdag, []cid.Cid{order.Root}, f)
+		if err != nil {
+			finish(err)
+			return
+		}
+		finish(f.Close())
+		return
+	}
+
+	nd, err := rdag.Get(ctx, order.Root)
+	if err != nil {
+		finish(xerrors.Errorf("ClientRetrieve: %w", err))
+		return
+	}
+	file, err := unixfile.NewUnixfsFile(ctx, rdag, nd)
+	if err != nil {
+		finish(xerrors.Errorf("ClientRetrieve: %w", err))
+		return
+	}
+	finish(files.WriteTo(file, ref.Path))
+	return
+}
+
+func (a *API) ClientQueryAsk(ctx context.Context, p peer.ID, miner address.Address) (*storagemarket.SignedStorageAsk, error) {
+	mi, err := a.StateMinerInfo(ctx, miner, types.EmptyTSK)
+	if err != nil {
+		return nil, xerrors.Errorf("failed getting miner info: %w", err)
+	}
+
+	info := utils.NewStorageProviderInfo(miner, mi.Worker, mi.SectorSize, p, mi.Multiaddrs)
+	signedAsk, err := a.SMDealClient.GetAsk(ctx, info)
+	if err != nil {
+		return nil, err
+	}
+	return signedAsk, nil
+}
+
+func (a *API) ClientCalcCommP(ctx context.Context, inpath string) (*api.CommPRet, error) {
+
+	// Hard-code the sector size to 32GiB, because:
+	// - pieceio.GeneratePieceCommitment requires a RegisteredSealProof
+	// - commP itself is sector-size independent, with rather low probability of that changing
+	//   ( note how the final rust call is identical for every RegSP type )
+	//   https://github.com/filecoin-project/rust-filecoin-proofs-api/blob/v5.0.0/src/seal.rs#L1040-L1050
+	//
+	// IF/WHEN this changes in the future we will have to be able to calculate
+	// "old style" commP, and thus will need to introduce a version switch or similar
+	arbitrarySectorSize := abi.SectorSize(32 << 30)
+
+	rt, err := ffiwrapper.SealProofTypeFromSectorSize(arbitrarySectorSize)
+	if err != nil {
+		return nil, xerrors.Errorf("bad sector size: %w", err)
+	}
+
+	rdr, err := os.Open(inpath)
+	if err != nil {
+		return nil, err
+	}
+	defer rdr.Close() //nolint:errcheck
+
+	stat, err := rdr.Stat()
 	if err != nil {
 		return nil, err
 	}
 
-	// TODO: make this less very bad by tracking root cids instead of using ListAll
+	commP, pieceSize, err := pieceio.GeneratePieceCommitment(rt, rdr, uint64(stat.Size()))
 
-	out := make([]api.Import, 0)
-	for {
-		r := next()
-		if r == nil {
-			return out, nil
-		}
-		if r.Offset != 0 {
-			continue
-		}
-		out = append(out, api.Import{
-			Status:   r.Status,
-			Key:      r.Key,
-			FilePath: r.FilePath,
-			Size:     r.Size,
-		})
+	if err != nil {
+		return nil, xerrors.Errorf("computing commP failed: %w", err)
 	}
+
+	return &api.CommPRet{
+		Root: commP,
+		Size: pieceSize,
+	}, nil
 }
 
-func (a *API) ClientRetrieve(ctx context.Context, order api.RetrievalOrder, path string) error {
-	if order.MinerPeerID == "" {
-		pid, err := a.StateMinerPeerID(ctx, order.Miner, nil)
-		if err != nil {
-			return err
-		}
+type lenWriter int64
 
-		order.MinerPeerID = pid
+func (w *lenWriter) Write(p []byte) (n int, err error) {
+	*w += lenWriter(len(p))
+	return len(p), nil
+}
+
+func (a *API) ClientDealSize(ctx context.Context, root cid.Cid) (api.DataSize, error) {
+	dag := merkledag.NewDAGService(blockservice.New(a.CombinedBstore, offline.Exchange(a.CombinedBstore)))
+
+	w := lenWriter(0)
+
+	err := car.WriteCar(ctx, dag, []cid.Cid{root}, &w)
+	if err != nil {
+		return api.DataSize{}, err
 	}
 
-	outFile, err := os.OpenFile(path, os.O_TRUNC|os.O_CREATE|os.O_WRONLY, 0777)
+	up := padreader.PaddedSize(uint64(w))
+
+	return api.DataSize{
+		PayloadSize: int64(w),
+		PieceSize:   up.Padded(),
+	}, nil
+}
+
+func (a *API) ClientGenCar(ctx context.Context, ref api.FileRef, outputPath string) error {
+	id, st, err := a.imgr().NewStore()
+	if err != nil {
+		return err
+	}
+	if err := a.imgr().AddLabel(id, "source", "gen-car"); err != nil {
+		return err
+	}
+
+	bufferedDS := ipld.NewBufferedDAG(ctx, st.DAG)
+	c, err := a.clientImport(ctx, ref, st)
+
 	if err != nil {
 		return err
 	}
 
-	err = a.Retrieval.RetrieveUnixfs(ctx, order.Root, order.Size, order.Total, order.MinerPeerID, order.Client, order.Miner, outFile)
+	// TODO: does that defer mean to remove the whole blockstore?
+	defer bufferedDS.Remove(ctx, c) //nolint:errcheck
+	ssb := builder.NewSelectorSpecBuilder(basicnode.Prototype.Any)
+
+	// entire DAG selector
+	allSelector := ssb.ExploreRecursive(selector.RecursionLimitNone(),
+		ssb.ExploreAll(ssb.ExploreRecursiveEdge())).Node()
+
+	f, err := os.Create(outputPath)
 	if err != nil {
-		_ = outFile.Close()
-		return xerrors.Errorf("RetrieveUnixfs: %w", err)
+		return err
 	}
 
-	return outFile.Close()
+	sc := car.NewSelectiveCar(ctx, st.Bstore, []car.Dag{{Root: c, Selector: allSelector}})
+	if err = sc.Write(f); err != nil {
+		return err
+	}
+
+	return f.Close()
 }
 
-func (a *API) ClientQueryAsk(ctx context.Context, p peer.ID, miner address.Address) (*types.SignedStorageAsk, error) {
-	return a.DealClient.QueryAsk(ctx, p, miner)
+func (a *API) clientImport(ctx context.Context, ref api.FileRef, store *multistore.Store) (cid.Cid, error) {
+	f, err := os.Open(ref.Path)
+	if err != nil {
+		return cid.Undef, err
+	}
+	defer f.Close() //nolint:errcheck
+
+	stat, err := f.Stat()
+	if err != nil {
+		return cid.Undef, err
+	}
+
+	file, err := files.NewReaderPathFile(ref.Path, f, stat)
+	if err != nil {
+		return cid.Undef, err
+	}
+
+	if ref.IsCAR {
+		var st car.Store
+		if store.Fstore == nil {
+			st = store.Bstore
+		} else {
+			st = store.Fstore
+		}
+		result, err := car.LoadCar(st, file)
+		if err != nil {
+			return cid.Undef, err
+		}
+
+		if len(result.Roots) != 1 {
+			return cid.Undef, xerrors.New("cannot import car with more than one root")
+		}
+
+		return result.Roots[0], nil
+	}
+
+	bufDs := ipld.NewBufferedDAG(ctx, store.DAG)
+
+	prefix, err := merkledag.PrefixForCidVersion(1)
+	if err != nil {
+		return cid.Undef, err
+	}
+	prefix.MhType = DefaultHashFunction
+
+	params := ihelper.DagBuilderParams{
+		Maxlinks:  build.UnixfsLinksPerLevel,
+		RawLeaves: true,
+		CidBuilder: cidutil.InlineBuilder{
+			Builder: prefix,
+			Limit:   126,
+		},
+		Dagserv: bufDs,
+		NoCopy:  true,
+	}
+
+	db, err := params.New(chunker.NewSizeSplitter(file, int64(build.UnixfsChunkSize)))
+	if err != nil {
+		return cid.Undef, err
+	}
+	nd, err := balanced.Layout(db)
+	if err != nil {
+		return cid.Undef, err
+	}
+
+	if err := bufDs.Commit(); err != nil {
+		return cid.Undef, err
+	}
+
+	return nd.Cid(), nil
+}
+
+func (a *API) ClientListDataTransfers(ctx context.Context) ([]api.DataTransferChannel, error) {
+	inProgressChannels, err := a.DataTransfer.InProgressChannels(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	apiChannels := make([]api.DataTransferChannel, 0, len(inProgressChannels))
+	for _, channelState := range inProgressChannels {
+		apiChannels = append(apiChannels, api.NewDataTransferChannel(a.Host.ID(), channelState))
+	}
+
+	return apiChannels, nil
+}
+
+func (a *API) ClientDataTransferUpdates(ctx context.Context) (<-chan api.DataTransferChannel, error) {
+	channels := make(chan api.DataTransferChannel)
+
+	unsub := a.DataTransfer.SubscribeToEvents(func(evt datatransfer.Event, channelState datatransfer.ChannelState) {
+		channel := api.NewDataTransferChannel(a.Host.ID(), channelState)
+		select {
+		case <-ctx.Done():
+		case channels <- channel:
+		}
+	})
+
+	go func() {
+		defer unsub()
+		<-ctx.Done()
+	}()
+
+	return channels, nil
+}
+
+func newDealInfo(v storagemarket.ClientDeal) api.DealInfo {
+	return api.DealInfo{
+		ProposalCid:   v.ProposalCid,
+		DataRef:       v.DataRef,
+		State:         v.State,
+		Message:       v.Message,
+		Provider:      v.Proposal.Provider,
+		PieceCID:      v.Proposal.PieceCID,
+		Size:          uint64(v.Proposal.PieceSize.Unpadded()),
+		PricePerEpoch: v.Proposal.StoragePricePerEpoch,
+		Duration:      uint64(v.Proposal.Duration()),
+		DealID:        v.DealID,
+		CreationTime:  v.CreationTime.Time(),
+	}
+}
+
+func (a *API) ClientRetrieveTryRestartInsufficientFunds(ctx context.Context, paymentChannel address.Address) error {
+	return a.Retrieval.TryRestartInsufficientFunds(paymentChannel)
 }
diff --git a/node/impl/common.go b/node/impl/common.go
deleted file mode 100644
index c77535779..000000000
--- a/node/impl/common.go
+++ /dev/null
@@ -1,95 +0,0 @@
-package impl
-
-import (
-	"context"
-
-	"github.com/gbrlsnchs/jwt/v3"
-	"github.com/libp2p/go-libp2p-core/host"
-	"github.com/libp2p/go-libp2p-core/network"
-	"github.com/libp2p/go-libp2p-core/peer"
-	ma "github.com/multiformats/go-multiaddr"
-	"go.uber.org/fx"
-	"golang.org/x/xerrors"
-
-	"github.com/filecoin-project/lotus/api"
-	"github.com/filecoin-project/lotus/build"
-	"github.com/filecoin-project/lotus/node/modules/dtypes"
-)
-
-type CommonAPI struct {
-	fx.In
-
-	APISecret *dtypes.APIAlg
-	Host      host.Host
-}
-
-type jwtPayload struct {
-	Allow []string
-}
-
-func (a *CommonAPI) AuthVerify(ctx context.Context, token string) ([]api.Permission, error) {
-	var payload jwtPayload
-	if _, err := jwt.Verify([]byte(token), (*jwt.HMACSHA)(a.APISecret), &payload); err != nil {
-		return nil, xerrors.Errorf("JWT Verification failed: %w", err)
-	}
-
-	return payload.Allow, nil
-}
-
-func (a *CommonAPI) AuthNew(ctx context.Context, perms []api.Permission) ([]byte, error) {
-	p := jwtPayload{
-		Allow: perms, // TODO: consider checking validity
-	}
-
-	return jwt.Sign(&p, (*jwt.HMACSHA)(a.APISecret))
-}
-
-func (a *CommonAPI) NetConnectedness(ctx context.Context, pid peer.ID) (network.Connectedness, error) {
-	return a.Host.Network().Connectedness(pid), nil
-}
-
-func (a *CommonAPI) NetPeers(context.Context) ([]peer.AddrInfo, error) {
-	conns := a.Host.Network().Conns()
-	out := make([]peer.AddrInfo, len(conns))
-
-	for i, conn := range conns {
-		out[i] = peer.AddrInfo{
-			ID: conn.RemotePeer(),
-			Addrs: []ma.Multiaddr{
-				conn.RemoteMultiaddr(),
-			},
-		}
-	}
-
-	return out, nil
-}
-
-func (a *CommonAPI) NetConnect(ctx context.Context, p peer.AddrInfo) error {
-	return a.Host.Connect(ctx, p)
-}
-
-func (a *CommonAPI) NetAddrsListen(context.Context) (peer.AddrInfo, error) {
-	return peer.AddrInfo{
-		ID:    a.Host.ID(),
-		Addrs: a.Host.Addrs(),
-	}, nil
-}
-
-func (a *CommonAPI) NetDisconnect(ctx context.Context, p peer.ID) error {
-	return a.Host.Network().ClosePeer(p)
-}
-
-func (a *CommonAPI) ID(context.Context) (peer.ID, error) {
-	return a.Host.ID(), nil
-}
-
-func (a *CommonAPI) Version(context.Context) (api.Version, error) {
-	return api.Version{
-		Version:    build.UserVersion,
-		APIVersion: build.APIVersion,
-
-		BlockDelay: build.BlockDelay,
-	}, nil
-}
-
-var _ api.Common = &CommonAPI{}
diff --git a/node/impl/common/common.go b/node/impl/common/common.go
new file mode 100644
index 000000000..b07c18305
--- /dev/null
+++ b/node/impl/common/common.go
@@ -0,0 +1,203 @@
+package common
+
+import (
+	"context"
+	"sort"
+	"strings"
+
+	logging "github.com/ipfs/go-log/v2"
+
+	"github.com/gbrlsnchs/jwt/v3"
+	"github.com/libp2p/go-libp2p-core/host"
+	metrics "github.com/libp2p/go-libp2p-core/metrics"
+	"github.com/libp2p/go-libp2p-core/network"
+	"github.com/libp2p/go-libp2p-core/peer"
+	protocol "github.com/libp2p/go-libp2p-core/protocol"
+	swarm "github.com/libp2p/go-libp2p-swarm"
+	basichost "github.com/libp2p/go-libp2p/p2p/host/basic"
+	ma "github.com/multiformats/go-multiaddr"
+	"go.uber.org/fx"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-jsonrpc/auth"
+
+	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/node/modules/dtypes"
+	"github.com/filecoin-project/lotus/node/modules/lp2p"
+)
+
+type CommonAPI struct {
+	fx.In
+
+	APISecret    *dtypes.APIAlg
+	RawHost      lp2p.RawHost
+	Host         host.Host
+	Router       lp2p.BaseIpfsRouting
+	Reporter     metrics.Reporter
+	Sk           *dtypes.ScoreKeeper
+	ShutdownChan dtypes.ShutdownChan
+}
+
+type jwtPayload struct {
+	Allow []auth.Permission
+}
+
+func (a *CommonAPI) AuthVerify(ctx context.Context, token string) ([]auth.Permission, error) {
+	var payload jwtPayload
+	if _, err := jwt.Verify([]byte(token), (*jwt.HMACSHA)(a.APISecret), &payload); err != nil {
+		return nil, xerrors.Errorf("JWT Verification failed: %w", err)
+	}
+
+	return payload.Allow, nil
+}
+
+func (a *CommonAPI) AuthNew(ctx context.Context, perms []auth.Permission) ([]byte, error) {
+	p := jwtPayload{
+		Allow: perms, // TODO: consider checking validity
+	}
+
+	return jwt.Sign(&p, (*jwt.HMACSHA)(a.APISecret))
+}
+
+func (a *CommonAPI) NetConnectedness(ctx context.Context, pid peer.ID) (network.Connectedness, error) {
+	return a.Host.Network().Connectedness(pid), nil
+}
+func (a *CommonAPI) NetPubsubScores(context.Context) ([]api.PubsubScore, error) {
+	scores := a.Sk.Get()
+	out := make([]api.PubsubScore, len(scores))
+	i := 0
+	for k, v := range scores {
+		out[i] = api.PubsubScore{ID: k, Score: v}
+		i++
+	}
+
+	sort.Slice(out, func(i, j int) bool {
+		return strings.Compare(string(out[i].ID), string(out[j].ID)) > 0
+	})
+
+	return out, nil
+}
+
+func (a *CommonAPI) NetPeers(context.Context) ([]peer.AddrInfo, error) {
+	conns := a.Host.Network().Conns()
+	out := make([]peer.AddrInfo, len(conns))
+
+	for i, conn := range conns {
+		out[i] = peer.AddrInfo{
+			ID: conn.RemotePeer(),
+			Addrs: []ma.Multiaddr{
+				conn.RemoteMultiaddr(),
+			},
+		}
+	}
+
+	return out, nil
+}
+
+func (a *CommonAPI) NetConnect(ctx context.Context, p peer.AddrInfo) error {
+	if swrm, ok := a.Host.Network().(*swarm.Swarm); ok {
+		swrm.Backoff().Clear(p.ID)
+	}
+
+	return a.Host.Connect(ctx, p)
+}
+
+func (a *CommonAPI) NetAddrsListen(context.Context) (peer.AddrInfo, error) {
+	return peer.AddrInfo{
+		ID:    a.Host.ID(),
+		Addrs: a.Host.Addrs(),
+	}, nil
+}
+
+func (a *CommonAPI) NetDisconnect(ctx context.Context, p peer.ID) error {
+	return a.Host.Network().ClosePeer(p)
+}
+
+func (a *CommonAPI) NetFindPeer(ctx context.Context, p peer.ID) (peer.AddrInfo, error) {
+	return a.Router.FindPeer(ctx, p)
+}
+
+func (a *CommonAPI) NetAutoNatStatus(ctx context.Context) (i api.NatInfo, err error) {
+	autonat := a.RawHost.(*basichost.BasicHost).AutoNat
+
+	var maddr string
+	if autonat.Status() == network.ReachabilityPublic {
+		pa, err := autonat.PublicAddr()
+		if err != nil {
+			return api.NatInfo{}, err
+		}
+		maddr = pa.String()
+	}
+
+	return api.NatInfo{
+		Reachability: autonat.Status(),
+		PublicAddr:   maddr,
+	}, nil
+}
+
+func (a *CommonAPI) NetAgentVersion(ctx context.Context, p peer.ID) (string, error) {
+	ag, err := a.Host.Peerstore().Get(p, "AgentVersion")
+	if err != nil {
+		return "", err
+	}
+
+	if ag == nil {
+		return "unknown", nil
+	}
+
+	return ag.(string), nil
+}
+
+func (a *CommonAPI) NetBandwidthStats(ctx context.Context) (metrics.Stats, error) {
+	return a.Reporter.GetBandwidthTotals(), nil
+}
+
+func (a *CommonAPI) NetBandwidthStatsByPeer(ctx context.Context) (map[string]metrics.Stats, error) {
+	out := make(map[string]metrics.Stats)
+	for p, s := range a.Reporter.GetBandwidthByPeer() {
+		out[p.String()] = s
+	}
+	return out, nil
+}
+
+func (a *CommonAPI) NetBandwidthStatsByProtocol(ctx context.Context) (map[protocol.ID]metrics.Stats, error) {
+	return a.Reporter.GetBandwidthByProtocol(), nil
+}
+
+func (a *CommonAPI) ID(context.Context) (peer.ID, error) {
+	return a.Host.ID(), nil
+}
+
+func (a *CommonAPI) Version(context.Context) (api.Version, error) {
+	v, err := build.VersionForType(build.RunningNodeType)
+	if err != nil {
+		return api.Version{}, err
+	}
+
+	return api.Version{
+		Version:    build.UserVersion(),
+		APIVersion: v,
+
+		BlockDelay: build.BlockDelaySecs,
+	}, nil
+}
+
+func (a *CommonAPI) LogList(context.Context) ([]string, error) {
+	return logging.GetSubsystems(), nil
+}
+
+func (a *CommonAPI) LogSetLevel(ctx context.Context, subsystem, level string) error {
+	return logging.SetLogLevel(subsystem, level)
+}
+
+func (a *CommonAPI) Shutdown(ctx context.Context) error {
+	a.ShutdownChan <- struct{}{}
+	return nil
+}
+
+func (a *CommonAPI) Closing(ctx context.Context) (<-chan struct{}, error) {
+	return make(chan struct{}), nil // relies on jsonrpc closing
+}
+
+var _ api.Common = &CommonAPI{}
diff --git a/node/impl/full.go b/node/impl/full.go
index 2c01674fb..feeb29745 100644
--- a/node/impl/full.go
+++ b/node/impl/full.go
@@ -1,28 +1,31 @@
 package impl
 
 import (
-	logging "github.com/ipfs/go-log"
-
-	"github.com/filecoin-project/lotus/node/impl/client"
-	"github.com/filecoin-project/lotus/node/impl/market"
-	"github.com/filecoin-project/lotus/node/impl/paych"
+	logging "github.com/ipfs/go-log/v2"
 
 	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/node/impl/client"
+	"github.com/filecoin-project/lotus/node/impl/common"
 	"github.com/filecoin-project/lotus/node/impl/full"
+	"github.com/filecoin-project/lotus/node/impl/market"
+	"github.com/filecoin-project/lotus/node/impl/paych"
 )
 
 var log = logging.Logger("node")
 
 type FullNodeAPI struct {
-	CommonAPI
+	common.CommonAPI
 	full.ChainAPI
 	client.API
 	full.MpoolAPI
+	full.GasAPI
 	market.MarketAPI
 	paych.PaychAPI
 	full.StateAPI
+	full.MsigAPI
 	full.WalletAPI
 	full.SyncAPI
+	full.BeaconAPI
 }
 
 var _ api.FullNode = &FullNodeAPI{}
diff --git a/node/impl/full/beacon.go b/node/impl/full/beacon.go
new file mode 100644
index 000000000..bc7232c27
--- /dev/null
+++ b/node/impl/full/beacon.go
@@ -0,0 +1,36 @@
+package full
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/lotus/chain/beacon"
+	"github.com/filecoin-project/lotus/chain/types"
+	"go.uber.org/fx"
+)
+
+type BeaconAPI struct {
+	fx.In
+
+	Beacon beacon.Schedule
+}
+
+func (a *BeaconAPI) BeaconGetEntry(ctx context.Context, epoch abi.ChainEpoch) (*types.BeaconEntry, error) {
+	b := a.Beacon.BeaconForEpoch(epoch)
+	rr := b.MaxBeaconRoundForEpoch(epoch)
+	e := b.Entry(ctx, rr)
+
+	select {
+	case be, ok := <-e:
+		if !ok {
+			return nil, fmt.Errorf("beacon get returned no value")
+		}
+		if be.Err != nil {
+			return nil, be.Err
+		}
+		return &be.Entry, nil
+	case <-ctx.Done():
+		return nil, ctx.Err()
+	}
+}
diff --git a/node/impl/full/chain.go b/node/impl/full/chain.go
index b8622421b..9606a023a 100644
--- a/node/impl/full/chain.go
+++ b/node/impl/full/chain.go
@@ -1,32 +1,44 @@
 package full
 
 import (
+	"bufio"
+	"bytes"
 	"context"
-	"fmt"
+	"encoding/json"
+	"io"
 	"strconv"
 	"strings"
+	"sync"
+
+	"go.uber.org/fx"
+	"golang.org/x/xerrors"
 
-	"github.com/filecoin-project/go-amt-ipld"
 	"github.com/ipfs/go-blockservice"
 	"github.com/ipfs/go-cid"
-	"github.com/ipfs/go-hamt-ipld"
-	blockstore "github.com/ipfs/go-ipfs-blockstore"
 	offline "github.com/ipfs/go-ipfs-exchange-offline"
 	cbor "github.com/ipfs/go-ipld-cbor"
 	ipld "github.com/ipfs/go-ipld-format"
+	logging "github.com/ipfs/go-log"
 	"github.com/ipfs/go-merkledag"
 	"github.com/ipfs/go-path"
 	"github.com/ipfs/go-path/resolver"
 	mh "github.com/multiformats/go-multihash"
-	"go.uber.org/fx"
-	"golang.org/x/xerrors"
+	cbg "github.com/whyrusleeping/cbor-gen"
 
 	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/crypto"
+	"github.com/filecoin-project/specs-actors/actors/util/adt"
+
 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/chain/store"
 	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/chain/vm"
+	"github.com/filecoin-project/lotus/lib/blockstore"
 )
 
+var log = logging.Logger("fullnode")
+
 type ChainAPI struct {
 	fx.In
 
@@ -35,7 +47,7 @@ type ChainAPI struct {
 	Chain *store.ChainStore
 }
 
-func (a *ChainAPI) ChainNotify(ctx context.Context) (<-chan []*store.HeadChange, error) {
+func (a *ChainAPI) ChainNotify(ctx context.Context) (<-chan []*api.HeadChange, error) {
 	return a.Chain.SubHeadChanges(ctx), nil
 }
 
@@ -43,8 +55,22 @@ func (a *ChainAPI) ChainHead(context.Context) (*types.TipSet, error) {
 	return a.Chain.GetHeaviestTipSet(), nil
 }
 
-func (a *ChainAPI) ChainGetRandomness(ctx context.Context, pts types.TipSetKey, round int64) ([]byte, error) {
-	return a.Chain.GetRandomness(ctx, pts.Cids(), round)
+func (a *ChainAPI) ChainGetRandomnessFromTickets(ctx context.Context, tsk types.TipSetKey, personalization crypto.DomainSeparationTag, randEpoch abi.ChainEpoch, entropy []byte) (abi.Randomness, error) {
+	pts, err := a.Chain.LoadTipSet(tsk)
+	if err != nil {
+		return nil, xerrors.Errorf("loading tipset key: %w", err)
+	}
+
+	return a.Chain.GetChainRandomness(ctx, pts.Cids(), personalization, randEpoch, entropy)
+}
+
+func (a *ChainAPI) ChainGetRandomnessFromBeacon(ctx context.Context, tsk types.TipSetKey, personalization crypto.DomainSeparationTag, randEpoch abi.ChainEpoch, entropy []byte) (abi.Randomness, error) {
+	pts, err := a.Chain.LoadTipSet(tsk)
+	if err != nil {
+		return nil, xerrors.Errorf("loading tipset key: %w", err)
+	}
+
+	return a.Chain.GetBeaconRandomness(ctx, pts.Cids(), personalization, randEpoch, entropy)
 }
 
 func (a *ChainAPI) ChainGetBlock(ctx context.Context, msg cid.Cid) (*types.BlockHeader, error) {
@@ -83,6 +109,10 @@ func (a *ChainAPI) ChainGetBlockMessages(ctx context.Context, msg cid.Cid) (*api
 	}, nil
 }
 
+func (a *ChainAPI) ChainGetPath(ctx context.Context, from types.TipSetKey, to types.TipSetKey) ([]*api.HeadChange, error) {
+	return a.Chain.GetPath(ctx, from, to)
+}
+
 func (a *ChainAPI) ChainGetParentMessages(ctx context.Context, bcid cid.Cid) ([]api.Message, error) {
 	b, err := a.Chain.GetBlock(bcid)
 	if err != nil {
@@ -150,8 +180,12 @@ func (a *ChainAPI) ChainGetParentReceipts(ctx context.Context, bcid cid.Cid) ([]
 	return out, nil
 }
 
-func (a *ChainAPI) ChainGetTipSetByHeight(ctx context.Context, h uint64, ts *types.TipSet) (*types.TipSet, error) {
-	return a.Chain.GetTipsetByHeight(ctx, h, ts)
+func (a *ChainAPI) ChainGetTipSetByHeight(ctx context.Context, h abi.ChainEpoch, tsk types.TipSetKey) (*types.TipSet, error) {
+	ts, err := a.Chain.GetTipSetFromKey(tsk)
+	if err != nil {
+		return nil, xerrors.Errorf("loading tipset %s: %w", tsk, err)
+	}
+	return a.Chain.GetTipsetByHeight(ctx, h, ts, true)
 }
 
 func (a *ChainAPI) ChainReadObj(ctx context.Context, obj cid.Cid) ([]byte, error) {
@@ -163,7 +197,67 @@ func (a *ChainAPI) ChainReadObj(ctx context.Context, obj cid.Cid) ([]byte, error
 	return blk.RawData(), nil
 }
 
-func (a *ChainAPI) ChainSetHead(ctx context.Context, ts *types.TipSet) error {
+func (a *ChainAPI) ChainDeleteObj(ctx context.Context, obj cid.Cid) error {
+	return a.Chain.Blockstore().DeleteBlock(obj)
+}
+
+func (a *ChainAPI) ChainHasObj(ctx context.Context, obj cid.Cid) (bool, error) {
+	return a.Chain.Blockstore().Has(obj)
+}
+
+func (a *ChainAPI) ChainStatObj(ctx context.Context, obj cid.Cid, base cid.Cid) (api.ObjStat, error) {
+	bs := a.Chain.Blockstore()
+	bsvc := blockservice.New(bs, offline.Exchange(bs))
+
+	dag := merkledag.NewDAGService(bsvc)
+
+	seen := cid.NewSet()
+
+	var statslk sync.Mutex
+	var stats api.ObjStat
+	var collect = true
+
+	walker := func(ctx context.Context, c cid.Cid) ([]*ipld.Link, error) {
+		if c.Prefix().Codec == cid.FilCommitmentSealed || c.Prefix().Codec == cid.FilCommitmentUnsealed {
+			return []*ipld.Link{}, nil
+		}
+
+		nd, err := dag.Get(ctx, c)
+		if err != nil {
+			return nil, err
+		}
+
+		if collect {
+			s := uint64(len(nd.RawData()))
+			statslk.Lock()
+			stats.Size = stats.Size + s
+			stats.Links = stats.Links + 1
+			statslk.Unlock()
+		}
+
+		return nd.Links(), nil
+	}
+
+	if base != cid.Undef {
+		collect = false
+		if err := merkledag.Walk(ctx, walker, base, seen.Visit, merkledag.Concurrent()); err != nil {
+			return api.ObjStat{}, err
+		}
+		collect = true
+	}
+
+	if err := merkledag.Walk(ctx, walker, obj, seen.Visit, merkledag.Concurrent()); err != nil {
+		return api.ObjStat{}, err
+	}
+
+	return stats, nil
+}
+
+func (a *ChainAPI) ChainSetHead(ctx context.Context, tsk types.TipSetKey) error {
+	ts, err := a.Chain.GetTipSetFromKey(tsk)
+	if err != nil {
+		return xerrors.Errorf("loading tipset %s: %w", tsk, err)
+	}
 	return a.Chain.SetHead(ts)
 }
 
@@ -176,12 +270,25 @@ func (a *ChainAPI) ChainGetGenesis(ctx context.Context) (*types.TipSet, error) {
 	return types.NewTipSet([]*types.BlockHeader{genb})
 }
 
-func (a *ChainAPI) ChainTipSetWeight(ctx context.Context, ts *types.TipSet) (types.BigInt, error) {
+func (a *ChainAPI) ChainTipSetWeight(ctx context.Context, tsk types.TipSetKey) (types.BigInt, error) {
+	ts, err := a.Chain.GetTipSetFromKey(tsk)
+	if err != nil {
+		return types.EmptyInt, xerrors.Errorf("loading tipset %s: %w", tsk, err)
+	}
 	return a.Chain.Weight(ctx, ts)
 }
 
+// This allows us to lookup string keys in the actor's adt.Map type.
+type stringKey string
+
+func (s stringKey) Key() string {
+	return (string)(s)
+}
+
 func resolveOnce(bs blockstore.Blockstore) func(ctx context.Context, ds ipld.NodeGetter, nd ipld.Node, names []string) (*ipld.Link, []string, error) {
 	return func(ctx context.Context, ds ipld.NodeGetter, nd ipld.Node, names []string) (*ipld.Link, []string, error) {
+		store := adt.WrapStore(ctx, cbor.NewCborStore(bs))
+
 		if strings.HasPrefix(names[0], "@Ha:") {
 			addr, err := address.NewFromString(names[0][4:])
 			if err != nil {
@@ -191,17 +298,43 @@ func resolveOnce(bs blockstore.Blockstore) func(ctx context.Context, ds ipld.Nod
 			names[0] = "@H:" + string(addr.Bytes())
 		}
 
-		if strings.HasPrefix(names[0], "@H:") {
-			cst := hamt.CSTFromBstore(bs)
+		if strings.HasPrefix(names[0], "@Hi:") {
+			i, err := strconv.ParseInt(names[0][4:], 10, 64)
+			if err != nil {
+				return nil, nil, xerrors.Errorf("parsing int64: %w", err)
+			}
 
-			h, err := hamt.LoadNode(ctx, cst, nd.Cid())
+			ik := abi.IntKey(i)
+
+			names[0] = "@H:" + ik.Key()
+		}
+
+		if strings.HasPrefix(names[0], "@Hu:") {
+			i, err := strconv.ParseUint(names[0][4:], 10, 64)
+			if err != nil {
+				return nil, nil, xerrors.Errorf("parsing uint64: %w", err)
+			}
+
+			ik := abi.UIntKey(i)
+
+			names[0] = "@H:" + ik.Key()
+		}
+
+		if strings.HasPrefix(names[0], "@H:") {
+			h, err := adt.AsMap(store, nd.Cid())
 			if err != nil {
 				return nil, nil, xerrors.Errorf("resolving hamt link: %w", err)
 			}
 
-			var m interface{}
-			if err := h.Find(ctx, names[0][3:], &m); err != nil {
+			var deferred cbg.Deferred
+			if found, err := h.Get(stringKey(names[0][3:]), &deferred); err != nil {
 				return nil, nil, xerrors.Errorf("resolve hamt: %w", err)
+			} else if !found {
+				return nil, nil, xerrors.Errorf("resolve hamt: not found")
+			}
+			var m interface{}
+			if err := cbor.DecodeInto(deferred.Raw, &m); err != nil {
+				return nil, nil, xerrors.Errorf("failed to decode cbor object: %w", err)
 			}
 			if c, ok := m.(cid.Cid); ok {
 				return &ipld.Link{
@@ -230,7 +363,7 @@ func resolveOnce(bs blockstore.Blockstore) func(ctx context.Context, ds ipld.Nod
 		}
 
 		if strings.HasPrefix(names[0], "@A:") {
-			a, err := amt.LoadAMT(amt.WrapBlockstore(bs), nd.Cid())
+			a, err := adt.AsArray(store, nd.Cid())
 			if err != nil {
 				return nil, nil, xerrors.Errorf("load amt: %w", err)
 			}
@@ -240,11 +373,17 @@ func resolveOnce(bs blockstore.Blockstore) func(ctx context.Context, ds ipld.Nod
 				return nil, nil, xerrors.Errorf("parsing amt index: %w", err)
 			}
 
-			var m interface{}
-			if err := a.Get(idx, &m); err != nil {
-				return nil, nil, xerrors.Errorf("amt get: %w", err)
+			var deferred cbg.Deferred
+			if found, err := a.Get(idx, &deferred); err != nil {
+				return nil, nil, xerrors.Errorf("resolve amt: %w", err)
+			} else if !found {
+				return nil, nil, xerrors.Errorf("resolve amt: not found")
 			}
-			fmt.Printf("AG %T %v\n", m, m)
+			var m interface{}
+			if err := cbor.DecodeInto(deferred.Raw, &m); err != nil {
+				return nil, nil, xerrors.Errorf("failed to decode cbor object: %w", err)
+			}
+
 			if c, ok := m.(cid.Cid); ok {
 				return &ipld.Link{
 					Name: names[0][3:],
@@ -272,11 +411,59 @@ func resolveOnce(bs blockstore.Blockstore) func(ctx context.Context, ds ipld.Nod
 			return resolveOnce(bs)(ctx, ds, n, names[1:])
 		}
 
+		if names[0] == "@state" {
+			var act types.Actor
+			if err := act.UnmarshalCBOR(bytes.NewReader(nd.RawData())); err != nil {
+				return nil, nil, xerrors.Errorf("unmarshaling actor struct for @state: %w", err)
+			}
+
+			head, err := ds.Get(ctx, act.Head)
+			if err != nil {
+				return nil, nil, xerrors.Errorf("getting actor head for @state: %w", err)
+			}
+
+			m, err := vm.DumpActorState(act.Code, head.RawData())
+			if err != nil {
+				return nil, nil, err
+			}
+
+			// a hack to workaround struct aliasing in refmt
+			ms := map[string]interface{}{}
+			{
+				mstr, err := json.Marshal(m)
+				if err != nil {
+					return nil, nil, err
+				}
+				if err := json.Unmarshal(mstr, &ms); err != nil {
+					return nil, nil, err
+				}
+			}
+
+			n, err := cbor.WrapObject(ms, mh.SHA2_256, 32)
+			if err != nil {
+				return nil, nil, err
+			}
+
+			if err := bs.Put(n); err != nil {
+				return nil, nil, xerrors.Errorf("put amt val: %w", err)
+			}
+
+			if len(names) == 1 {
+				return &ipld.Link{
+					Name: "state",
+					Size: 0,
+					Cid:  n.Cid(),
+				}, nil, nil
+			}
+
+			return resolveOnce(bs)(ctx, ds, n, names[1:])
+		}
+
 		return nd.ResolveLink(names)
 	}
 }
 
-func (a *ChainAPI) ChainGetNode(ctx context.Context, p string) (interface{}, error) {
+func (a *ChainAPI) ChainGetNode(ctx context.Context, p string) (*api.IpldObject, error) {
 	ip, err := path.ParsePath(p)
 	if err != nil {
 		return nil, xerrors.Errorf("parsing path: %w", err)
@@ -297,7 +484,10 @@ func (a *ChainAPI) ChainGetNode(ctx context.Context, p string) (interface{}, err
 		return nil, err
 	}
 
-	return node, nil
+	return &api.IpldObject{
+		Cid: node.Cid(),
+		Obj: node,
+	}, nil
 }
 
 func (a *ChainAPI) ChainGetMessage(ctx context.Context, mc cid.Cid) (*types.Message, error) {
@@ -308,3 +498,46 @@ func (a *ChainAPI) ChainGetMessage(ctx context.Context, mc cid.Cid) (*types.Mess
 
 	return cm.VMMessage(), nil
 }
+
+func (a *ChainAPI) ChainExport(ctx context.Context, nroots abi.ChainEpoch, skipoldmsgs bool, tsk types.TipSetKey) (<-chan []byte, error) {
+	ts, err := a.Chain.GetTipSetFromKey(tsk)
+	if err != nil {
+		return nil, xerrors.Errorf("loading tipset %s: %w", tsk, err)
+	}
+	r, w := io.Pipe()
+	out := make(chan []byte)
+	go func() {
+		defer w.Close() //nolint:errcheck // it is a pipe
+
+		bw := bufio.NewWriterSize(w, 1<<20)
+		defer bw.Flush() //nolint:errcheck // it is a write to a pipe
+
+		if err := a.Chain.Export(ctx, ts, nroots, skipoldmsgs, bw); err != nil {
+			log.Errorf("chain export call failed: %s", err)
+			return
+		}
+	}()
+
+	go func() {
+		defer close(out)
+		for {
+			buf := make([]byte, 1<<20)
+			n, err := r.Read(buf)
+			if err != nil && err != io.EOF {
+				log.Errorf("chain export pipe read failed: %s", err)
+				return
+			}
+			select {
+			case out <- buf[:n]:
+			case <-ctx.Done():
+				log.Warnf("export writer failed: %s", ctx.Err())
+				return
+			}
+			if err == io.EOF {
+				return
+			}
+		}
+	}()
+
+	return out, nil
+}
diff --git a/node/impl/full/gas.go b/node/impl/full/gas.go
new file mode 100644
index 000000000..f03807c80
--- /dev/null
+++ b/node/impl/full/gas.go
@@ -0,0 +1,224 @@
+package full
+
+import (
+	"context"
+	"math"
+	"math/rand"
+	"sort"
+
+	"go.uber.org/fx"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/big"
+	"github.com/filecoin-project/go-state-types/exitcode"
+
+	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
+
+	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/messagepool"
+	"github.com/filecoin-project/lotus/chain/stmgr"
+	"github.com/filecoin-project/lotus/chain/store"
+	"github.com/filecoin-project/lotus/chain/types"
+)
+
+type GasAPI struct {
+	fx.In
+	Stmgr *stmgr.StateManager
+	Chain *store.ChainStore
+	Mpool *messagepool.MessagePool
+}
+
+const MinGasPremium = 100e3
+const MaxSpendOnFeeDenom = 100
+
+func (a *GasAPI) GasEstimateFeeCap(ctx context.Context, msg *types.Message, maxqueueblks int64,
+	tsk types.TipSetKey) (types.BigInt, error) {
+	ts := a.Chain.GetHeaviestTipSet()
+
+	parentBaseFee := ts.Blocks()[0].ParentBaseFee
+	increaseFactor := math.Pow(1.+1./float64(build.BaseFeeMaxChangeDenom), float64(maxqueueblks))
+
+	feeInFuture := types.BigMul(parentBaseFee, types.NewInt(uint64(increaseFactor*(1<<8))))
+	out := types.BigDiv(feeInFuture, types.NewInt(1<<8))
+
+	if msg.GasPremium != types.EmptyInt {
+		out = types.BigAdd(out, msg.GasPremium)
+	}
+
+	return out, nil
+}
+
+type gasMeta struct {
+	price big.Int
+	limit int64
+}
+
+func medianGasPremium(prices []gasMeta, blocks int) abi.TokenAmount {
+	sort.Slice(prices, func(i, j int) bool {
+		// sort desc by price
+		return prices[i].price.GreaterThan(prices[j].price)
+	})
+
+	at := build.BlockGasTarget * int64(blocks) / 2
+	prev1, prev2 := big.Zero(), big.Zero()
+	for _, price := range prices {
+		prev1, prev2 = price.price, prev1
+		at -= price.limit
+		if at < 0 {
+			break
+		}
+	}
+
+	premium := prev1
+	if prev2.Sign() != 0 {
+		premium = big.Div(types.BigAdd(prev1, prev2), types.NewInt(2))
+	}
+
+	return premium
+}
+
+func (a *GasAPI) GasEstimateGasPremium(ctx context.Context, nblocksincl uint64,
+	sender address.Address, gaslimit int64, _ types.TipSetKey) (types.BigInt, error) {
+
+	if nblocksincl == 0 {
+		nblocksincl = 1
+	}
+
+	var prices []gasMeta
+	var blocks int
+
+	ts := a.Chain.GetHeaviestTipSet()
+	for i := uint64(0); i < nblocksincl*2; i++ {
+		if ts.Height() == 0 {
+			break // genesis
+		}
+
+		pts, err := a.Chain.LoadTipSet(ts.Parents())
+		if err != nil {
+			return types.BigInt{}, err
+		}
+
+		blocks += len(pts.Blocks())
+
+		msgs, err := a.Chain.MessagesForTipset(pts)
+		if err != nil {
+			return types.BigInt{}, xerrors.Errorf("loading messages: %w", err)
+		}
+		for _, msg := range msgs {
+			prices = append(prices, gasMeta{
+				price: msg.VMMessage().GasPremium,
+				limit: msg.VMMessage().GasLimit,
+			})
+		}
+
+		ts = pts
+	}
+
+	premium := medianGasPremium(prices, blocks)
+
+	if types.BigCmp(premium, types.NewInt(MinGasPremium)) < 0 {
+		switch nblocksincl {
+		case 1:
+			premium = types.NewInt(2 * MinGasPremium)
+		case 2:
+			premium = types.NewInt(1.5 * MinGasPremium)
+		default:
+			premium = types.NewInt(MinGasPremium)
+		}
+	}
+
+	// add some noise to normalize behaviour of message selection
+	const precision = 32
+	// mean 1, stddev 0.005 => 95% within +-1%
+	noise := 1 + rand.NormFloat64()*0.005
+	premium = types.BigMul(premium, types.NewInt(uint64(noise*(1<<precision))+1))
+	premium = types.BigDiv(premium, types.NewInt(1<<precision))
+	return premium, nil
+}
+
+func (a *GasAPI) GasEstimateGasLimit(ctx context.Context, msgIn *types.Message, _ types.TipSetKey) (int64, error) {
+
+	msg := *msgIn
+	msg.GasLimit = build.BlockGasLimit
+	msg.GasFeeCap = types.NewInt(uint64(build.MinimumBaseFee) + 1)
+	msg.GasPremium = types.NewInt(1)
+
+	currTs := a.Chain.GetHeaviestTipSet()
+	fromA, err := a.Stmgr.ResolveToKeyAddress(ctx, msgIn.From, currTs)
+	if err != nil {
+		return -1, xerrors.Errorf("getting key address: %w", err)
+	}
+
+	pending, ts := a.Mpool.PendingFor(fromA)
+	priorMsgs := make([]types.ChainMsg, 0, len(pending))
+	for _, m := range pending {
+		priorMsgs = append(priorMsgs, m)
+	}
+
+	res, err := a.Stmgr.CallWithGas(ctx, &msg, priorMsgs, ts)
+	if err != nil {
+		return -1, xerrors.Errorf("CallWithGas failed: %w", err)
+	}
+	if res.MsgRct.ExitCode != exitcode.Ok {
+		return -1, xerrors.Errorf("message execution failed: exit %s, reason: %s", res.MsgRct.ExitCode, res.Error)
+	}
+
+	// Special case for PaymentChannel collect, which is deleting actor
+	st, err := a.Stmgr.ParentState(ts)
+	if err != nil {
+		_ = err
+		// somewhat ignore it as it can happen and we just want to detect
+		// an existing PaymentChannel actor
+		return res.MsgRct.GasUsed, nil
+	}
+	act, err := st.GetActor(msg.To)
+	if err != nil {
+		_ = err
+		// somewhat ignore it as it can happen and we just want to detect
+		// an existing PaymentChannel actor
+		return res.MsgRct.GasUsed, nil
+	}
+
+	if !act.IsPaymentChannelActor() {
+		return res.MsgRct.GasUsed, nil
+	}
+	if msgIn.Method != builtin0.MethodsPaych.Collect {
+		return res.MsgRct.GasUsed, nil
+	}
+
+	// return GasUsed without the refund for DestoryActor
+	return res.MsgRct.GasUsed + 76e3, nil
+}
+
+func (a *GasAPI) GasEstimateMessageGas(ctx context.Context, msg *types.Message, spec *api.MessageSendSpec, _ types.TipSetKey) (*types.Message, error) {
+	if msg.GasLimit == 0 {
+		gasLimit, err := a.GasEstimateGasLimit(ctx, msg, types.TipSetKey{})
+		if err != nil {
+			return nil, xerrors.Errorf("estimating gas used: %w", err)
+		}
+		msg.GasLimit = int64(float64(gasLimit) * a.Mpool.GetConfig().GasLimitOverestimation)
+	}
+
+	if msg.GasPremium == types.EmptyInt || types.BigCmp(msg.GasPremium, types.NewInt(0)) == 0 {
+		gasPremium, err := a.GasEstimateGasPremium(ctx, 2, msg.From, msg.GasLimit, types.TipSetKey{})
+		if err != nil {
+			return nil, xerrors.Errorf("estimating gas price: %w", err)
+		}
+		msg.GasPremium = gasPremium
+	}
+
+	if msg.GasFeeCap == types.EmptyInt || types.BigCmp(msg.GasFeeCap, types.NewInt(0)) == 0 {
+		feeCap, err := a.GasEstimateFeeCap(ctx, msg, 20, types.EmptyTSK)
+		if err != nil {
+			return nil, xerrors.Errorf("estimating fee cap: %w", err)
+		}
+		msg.GasFeeCap = feeCap
+	}
+
+	messagepool.CapGasFee(msg, spec.Get().MaxFee)
+
+	return msg, nil
+}
diff --git a/node/impl/full/gas_test.go b/node/impl/full/gas_test.go
new file mode 100644
index 000000000..2452ab807
--- /dev/null
+++ b/node/impl/full/gas_test.go
@@ -0,0 +1,40 @@
+package full
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/filecoin-project/go-state-types/big"
+
+	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/types"
+)
+
+func TestMedian(t *testing.T) {
+	require.Equal(t, types.NewInt(5), medianGasPremium([]gasMeta{
+		{big.NewInt(5), build.BlockGasTarget},
+	}, 1))
+
+	require.Equal(t, types.NewInt(10), medianGasPremium([]gasMeta{
+		{big.NewInt(5), build.BlockGasTarget},
+		{big.NewInt(10), build.BlockGasTarget},
+	}, 1))
+
+	require.Equal(t, types.NewInt(15), medianGasPremium([]gasMeta{
+		{big.NewInt(10), build.BlockGasTarget / 2},
+		{big.NewInt(20), build.BlockGasTarget / 2},
+	}, 1))
+
+	require.Equal(t, types.NewInt(25), medianGasPremium([]gasMeta{
+		{big.NewInt(10), build.BlockGasTarget / 2},
+		{big.NewInt(20), build.BlockGasTarget / 2},
+		{big.NewInt(30), build.BlockGasTarget / 2},
+	}, 1))
+
+	require.Equal(t, types.NewInt(15), medianGasPremium([]gasMeta{
+		{big.NewInt(10), build.BlockGasTarget / 2},
+		{big.NewInt(20), build.BlockGasTarget / 2},
+		{big.NewInt(30), build.BlockGasTarget / 2},
+	}, 2))
+}
diff --git a/node/impl/full/mpool.go b/node/impl/full/mpool.go
index cedb1785e..6acb17990 100644
--- a/node/impl/full/mpool.go
+++ b/node/impl/full/mpool.go
@@ -2,29 +2,55 @@ package full
 
 import (
 	"context"
+	"encoding/json"
 
+	"github.com/filecoin-project/go-address"
 	"github.com/ipfs/go-cid"
 	"go.uber.org/fx"
 	"golang.org/x/xerrors"
 
-	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/chain/messagepool"
 	"github.com/filecoin-project/lotus/chain/store"
 	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/node/modules/dtypes"
 )
 
 type MpoolAPI struct {
 	fx.In
 
 	WalletAPI
+	GasAPI
 
 	Chain *store.ChainStore
 
 	Mpool *messagepool.MessagePool
+
+	PushLocks *dtypes.MpoolLocker
 }
 
-func (a *MpoolAPI) MpoolPending(ctx context.Context, ts *types.TipSet) ([]*types.SignedMessage, error) {
+func (a *MpoolAPI) MpoolGetConfig(context.Context) (*types.MpoolConfig, error) {
+	return a.Mpool.GetConfig(), nil
+}
+
+func (a *MpoolAPI) MpoolSetConfig(ctx context.Context, cfg *types.MpoolConfig) error {
+	return a.Mpool.SetConfig(cfg)
+}
+
+func (a *MpoolAPI) MpoolSelect(ctx context.Context, tsk types.TipSetKey, ticketQuality float64) ([]*types.SignedMessage, error) {
+	ts, err := a.Chain.GetTipSetFromKey(tsk)
+	if err != nil {
+		return nil, xerrors.Errorf("loading tipset %s: %w", tsk, err)
+	}
+
+	return a.Mpool.SelectMessages(ts, ticketQuality)
+}
+
+func (a *MpoolAPI) MpoolPending(ctx context.Context, tsk types.TipSetKey) ([]*types.SignedMessage, error) {
+	ts, err := a.Chain.GetTipSetFromKey(tsk)
+	if err != nil {
+		return nil, xerrors.Errorf("loading tipset %s: %w", tsk, err)
+	}
 	pending, mpts := a.Mpool.Pending()
 
 	haveCids := map[cid.Cid]struct{}{}
@@ -78,17 +104,51 @@ func (a *MpoolAPI) MpoolPending(ctx context.Context, ts *types.TipSet) ([]*types
 	}
 }
 
+func (a *MpoolAPI) MpoolClear(ctx context.Context, local bool) error {
+	a.Mpool.Clear(local)
+	return nil
+}
+
 func (a *MpoolAPI) MpoolPush(ctx context.Context, smsg *types.SignedMessage) (cid.Cid, error) {
 	return a.Mpool.Push(smsg)
 }
 
-func (a *MpoolAPI) MpoolPushMessage(ctx context.Context, msg *types.Message) (*types.SignedMessage, error) {
+func (a *MpoolAPI) MpoolPushMessage(ctx context.Context, msg *types.Message, spec *api.MessageSendSpec) (*types.SignedMessage, error) {
+	inMsg := *msg
+	{
+		fromA, err := a.Stmgr.ResolveToKeyAddress(ctx, msg.From, nil)
+		if err != nil {
+			return nil, xerrors.Errorf("getting key address: %w", err)
+		}
+		done, err := a.PushLocks.TakeLock(ctx, fromA)
+		if err != nil {
+			return nil, xerrors.Errorf("taking lock: %w", err)
+		}
+		defer done()
+	}
+
 	if msg.Nonce != 0 {
 		return nil, xerrors.Errorf("MpoolPushMessage expects message nonce to be 0, was %d", msg.Nonce)
 	}
 
-	return a.Mpool.PushWithNonce(msg.From, func(nonce uint64) (*types.SignedMessage, error) {
+	msg, err := a.GasAPI.GasEstimateMessageGas(ctx, msg, spec, types.EmptyTSK)
+	if err != nil {
+		return nil, xerrors.Errorf("GasEstimateMessageGas error: %w", err)
+	}
+
+	if msg.GasPremium.GreaterThan(msg.GasFeeCap) {
+		inJson, _ := json.Marshal(inMsg)
+		outJson, _ := json.Marshal(msg)
+		return nil, xerrors.Errorf("After estimation, GasPremium is greater than GasFeeCap, inmsg: %s, outmsg: %s",
+			inJson, outJson)
+	}
+
+	sign := func(from address.Address, nonce uint64) (*types.SignedMessage, error) {
 		msg.Nonce = nonce
+		if msg.From.Protocol() == address.ID {
+			log.Warnf("Push from ID address (%s), adjusting to %s", msg.From, from)
+			msg.From = from
+		}
 
 		b, err := a.WalletBalance(ctx, msg.From)
 		if err != nil {
@@ -99,8 +159,17 @@ func (a *MpoolAPI) MpoolPushMessage(ctx context.Context, msg *types.Message) (*t
 			return nil, xerrors.Errorf("mpool push: not enough funds: %s < %s", b, msg.Value)
 		}
 
-		return a.WalletSignMessage(ctx, msg.From, msg)
-	})
+		return a.WalletSignMessage(ctx, from, msg)
+	}
+
+	var m *types.SignedMessage
+again:
+	m, err = a.Mpool.PushWithNonce(ctx, msg.From, sign)
+	if err == messagepool.ErrTryAgain {
+		log.Debugf("temporary failure while pushing message: %s; retrying", err)
+		goto again
+	}
+	return m, err
 }
 
 func (a *MpoolAPI) MpoolGetNonce(ctx context.Context, addr address.Address) (uint64, error) {
diff --git a/node/impl/full/multisig.go b/node/impl/full/multisig.go
new file mode 100644
index 000000000..8c15a27be
--- /dev/null
+++ b/node/impl/full/multisig.go
@@ -0,0 +1,299 @@
+package full
+
+import (
+	"context"
+
+	"github.com/filecoin-project/go-state-types/big"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/chain/actors"
+	init_ "github.com/filecoin-project/lotus/chain/actors/builtin/init"
+	"github.com/filecoin-project/lotus/chain/types"
+
+	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/ipfs/go-cid"
+	"github.com/minio/blake2b-simd"
+	"go.uber.org/fx"
+	"golang.org/x/xerrors"
+)
+
+type MsigAPI struct {
+	fx.In
+
+	WalletAPI WalletAPI
+	StateAPI  StateAPI
+	MpoolAPI  MpoolAPI
+}
+
+// TODO: remove gp (gasPrice) from arguments
+func (a *MsigAPI) MsigCreate(ctx context.Context, req uint64, addrs []address.Address, duration abi.ChainEpoch, val types.BigInt, src address.Address, gp types.BigInt) (cid.Cid, error) {
+
+	lenAddrs := uint64(len(addrs))
+
+	if lenAddrs < req {
+		return cid.Undef, xerrors.Errorf("cannot require signing of more addresses than provided for multisig")
+	}
+
+	if req == 0 {
+		req = lenAddrs
+	}
+
+	if src == address.Undef {
+		return cid.Undef, xerrors.Errorf("must provide source address")
+	}
+
+	// Set up constructor parameters for multisig
+	msigParams := &multisig0.ConstructorParams{
+		Signers:               addrs,
+		NumApprovalsThreshold: req,
+		UnlockDuration:        duration,
+	}
+
+	enc, actErr := actors.SerializeParams(msigParams)
+	if actErr != nil {
+		return cid.Undef, actErr
+	}
+
+	// new actors are created by invoking 'exec' on the init actor with the constructor params
+	// TODO: network upgrade?
+	execParams := &init0.ExecParams{
+		CodeCID:           builtin0.MultisigActorCodeID,
+		ConstructorParams: enc,
+	}
+
+	enc, actErr = actors.SerializeParams(execParams)
+	if actErr != nil {
+		return cid.Undef, actErr
+	}
+
+	// now we create the message to send this with
+	msg := types.Message{
+		To:     init_.Address,
+		From:   src,
+		Method: builtin0.MethodsInit.Exec,
+		Params: enc,
+		Value:  val,
+	}
+
+	// send the message out to the network
+	smsg, err := a.MpoolAPI.MpoolPushMessage(ctx, &msg, nil)
+	if err != nil {
+		return cid.Undef, err
+	}
+
+	return smsg.Cid(), nil
+}
+
+func (a *MsigAPI) MsigPropose(ctx context.Context, msig address.Address, to address.Address, amt types.BigInt, src address.Address, method uint64, params []byte) (cid.Cid, error) {
+
+	if msig == address.Undef {
+		return cid.Undef, xerrors.Errorf("must provide a multisig address for proposal")
+	}
+
+	if to == address.Undef {
+		return cid.Undef, xerrors.Errorf("must provide a target address for proposal")
+	}
+
+	if amt.Sign() == -1 {
+		return cid.Undef, xerrors.Errorf("must provide a positive amount for proposed send")
+	}
+
+	if src == address.Undef {
+		return cid.Undef, xerrors.Errorf("must provide source address")
+	}
+
+	enc, actErr := actors.SerializeParams(&multisig0.ProposeParams{
+		To:     to,
+		Value:  amt,
+		Method: abi.MethodNum(method),
+		Params: params,
+	})
+	if actErr != nil {
+		return cid.Undef, xerrors.Errorf("failed to serialize parameters: %w", actErr)
+	}
+
+	msg := &types.Message{
+		To:     msig,
+		From:   src,
+		Value:  types.NewInt(0),
+		Method: builtin0.MethodsMultisig.Propose,
+		Params: enc,
+	}
+
+	smsg, err := a.MpoolAPI.MpoolPushMessage(ctx, msg, nil)
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("failed to push message: %w", err)
+	}
+
+	return smsg.Cid(), nil
+}
+
+func (a *MsigAPI) MsigAddPropose(ctx context.Context, msig address.Address, src address.Address, newAdd address.Address, inc bool) (cid.Cid, error) {
+	enc, actErr := serializeAddParams(newAdd, inc)
+	if actErr != nil {
+		return cid.Undef, actErr
+	}
+
+	return a.MsigPropose(ctx, msig, msig, big.Zero(), src, uint64(builtin0.MethodsMultisig.AddSigner), enc)
+}
+
+func (a *MsigAPI) MsigAddApprove(ctx context.Context, msig address.Address, src address.Address, txID uint64, proposer address.Address, newAdd address.Address, inc bool) (cid.Cid, error) {
+	enc, actErr := serializeAddParams(newAdd, inc)
+	if actErr != nil {
+		return cid.Undef, actErr
+	}
+
+	return a.MsigApprove(ctx, msig, txID, proposer, msig, big.Zero(), src, uint64(builtin0.MethodsMultisig.AddSigner), enc)
+}
+
+func (a *MsigAPI) MsigAddCancel(ctx context.Context, msig address.Address, src address.Address, txID uint64, newAdd address.Address, inc bool) (cid.Cid, error) {
+	enc, actErr := serializeAddParams(newAdd, inc)
+	if actErr != nil {
+		return cid.Undef, actErr
+	}
+
+	return a.MsigCancel(ctx, msig, txID, msig, big.Zero(), src, uint64(builtin0.MethodsMultisig.AddSigner), enc)
+}
+
+func (a *MsigAPI) MsigSwapPropose(ctx context.Context, msig address.Address, src address.Address, oldAdd address.Address, newAdd address.Address) (cid.Cid, error) {
+	enc, actErr := serializeSwapParams(oldAdd, newAdd)
+	if actErr != nil {
+		return cid.Undef, actErr
+	}
+
+	return a.MsigPropose(ctx, msig, msig, big.Zero(), src, uint64(builtin0.MethodsMultisig.SwapSigner), enc)
+}
+
+func (a *MsigAPI) MsigSwapApprove(ctx context.Context, msig address.Address, src address.Address, txID uint64, proposer address.Address, oldAdd address.Address, newAdd address.Address) (cid.Cid, error) {
+	enc, actErr := serializeSwapParams(oldAdd, newAdd)
+	if actErr != nil {
+		return cid.Undef, actErr
+	}
+
+	return a.MsigApprove(ctx, msig, txID, proposer, msig, big.Zero(), src, uint64(builtin0.MethodsMultisig.SwapSigner), enc)
+}
+
+func (a *MsigAPI) MsigSwapCancel(ctx context.Context, msig address.Address, src address.Address, txID uint64, oldAdd address.Address, newAdd address.Address) (cid.Cid, error) {
+	enc, actErr := serializeSwapParams(oldAdd, newAdd)
+	if actErr != nil {
+		return cid.Undef, actErr
+	}
+
+	return a.MsigCancel(ctx, msig, txID, msig, big.Zero(), src, uint64(builtin0.MethodsMultisig.SwapSigner), enc)
+}
+
+func (a *MsigAPI) MsigApprove(ctx context.Context, msig address.Address, txID uint64, proposer address.Address, to address.Address, amt types.BigInt, src address.Address, method uint64, params []byte) (cid.Cid, error) {
+	return a.msigApproveOrCancel(ctx, api.MsigApprove, msig, txID, proposer, to, amt, src, method, params)
+}
+
+func (a *MsigAPI) MsigCancel(ctx context.Context, msig address.Address, txID uint64, to address.Address, amt types.BigInt, src address.Address, method uint64, params []byte) (cid.Cid, error) {
+	return a.msigApproveOrCancel(ctx, api.MsigCancel, msig, txID, src, to, amt, src, method, params)
+}
+
+func (a *MsigAPI) msigApproveOrCancel(ctx context.Context, operation api.MsigProposeResponse, msig address.Address, txID uint64, proposer address.Address, to address.Address, amt types.BigInt, src address.Address, method uint64, params []byte) (cid.Cid, error) {
+	if msig == address.Undef {
+		return cid.Undef, xerrors.Errorf("must provide multisig address")
+	}
+
+	if to == address.Undef {
+		return cid.Undef, xerrors.Errorf("must provide proposed target address")
+	}
+
+	if amt.Sign() == -1 {
+		return cid.Undef, xerrors.Errorf("must provide the positive amount that was proposed")
+	}
+
+	if src == address.Undef {
+		return cid.Undef, xerrors.Errorf("must provide source address")
+	}
+
+	if proposer.Protocol() != address.ID {
+		proposerID, err := a.StateAPI.StateLookupID(ctx, proposer, types.EmptyTSK)
+		if err != nil {
+			return cid.Undef, err
+		}
+		proposer = proposerID
+	}
+
+	p := multisig0.ProposalHashData{
+		Requester: proposer,
+		To:        to,
+		Value:     amt,
+		Method:    abi.MethodNum(method),
+		Params:    params,
+	}
+
+	pser, err := p.Serialize()
+	if err != nil {
+		return cid.Undef, err
+	}
+	phash := blake2b.Sum256(pser)
+
+	enc, err := actors.SerializeParams(&multisig0.TxnIDParams{
+		ID:           multisig0.TxnID(txID),
+		ProposalHash: phash[:],
+	})
+
+	if err != nil {
+		return cid.Undef, err
+	}
+
+	var msigResponseMethod abi.MethodNum
+
+	/*
+		We pass in a MsigProposeResponse instead of MethodNum to
+		tighten the possible inputs to just Approve and Cancel.
+	*/
+	switch operation {
+	case api.MsigApprove:
+		msigResponseMethod = builtin0.MethodsMultisig.Approve
+	case api.MsigCancel:
+		msigResponseMethod = builtin0.MethodsMultisig.Cancel
+	default:
+		return cid.Undef, xerrors.Errorf("Invalid operation for msigApproveOrCancel")
+	}
+
+	msg := &types.Message{
+		To:     msig,
+		From:   src,
+		Value:  types.NewInt(0),
+		Method: msigResponseMethod,
+		Params: enc,
+	}
+
+	smsg, err := a.MpoolAPI.MpoolPushMessage(ctx, msg, nil)
+	if err != nil {
+		return cid.Undef, err
+	}
+
+	return smsg.Cid(), nil
+}
+
+func serializeAddParams(new address.Address, inc bool) ([]byte, error) {
+	enc, actErr := actors.SerializeParams(&multisig0.AddSignerParams{
+		Signer:   new,
+		Increase: inc,
+	})
+	if actErr != nil {
+		return nil, actErr
+	}
+
+	return enc, nil
+}
+
+func serializeSwapParams(old address.Address, new address.Address) ([]byte, error) {
+	enc, actErr := actors.SerializeParams(&multisig0.SwapSignerParams{
+		From: old,
+		To:   new,
+	})
+	if actErr != nil {
+		return nil, actErr
+	}
+
+	return enc, nil
+}
diff --git a/node/impl/full/state.go b/node/impl/full/state.go
index 2d0835f68..f8bf92a92 100644
--- a/node/impl/full/state.go
+++ b/node/impl/full/state.go
@@ -5,18 +5,34 @@ import (
 	"context"
 	"strconv"
 
-	"github.com/filecoin-project/go-amt-ipld"
+	lotusbuiltin "github.com/filecoin-project/lotus/chain/actors/builtin"
+
+	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
+	market0 "github.com/filecoin-project/specs-actors/actors/builtin/market"
+
+	"github.com/filecoin-project/lotus/chain/actors/builtin/verifreg"
+
+	"github.com/filecoin-project/go-state-types/dline"
+	"github.com/filecoin-project/go-state-types/network"
 
 	cid "github.com/ipfs/go-cid"
-	"github.com/ipfs/go-hamt-ipld"
-	"github.com/libp2p/go-libp2p-core/peer"
-	cbg "github.com/whyrusleeping/cbor-gen"
+	cbor "github.com/ipfs/go-ipld-cbor"
 	"go.uber.org/fx"
 	"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/big"
+	"github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper"
+
 	"github.com/filecoin-project/lotus/api"
-	"github.com/filecoin-project/lotus/chain/actors"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/market"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/multisig"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/power"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/reward"
+	"github.com/filecoin-project/lotus/chain/beacon"
 	"github.com/filecoin-project/lotus/chain/gen"
 	"github.com/filecoin-project/lotus/chain/state"
 	"github.com/filecoin-project/lotus/chain/stmgr"
@@ -25,6 +41,7 @@ import (
 	"github.com/filecoin-project/lotus/chain/vm"
 	"github.com/filecoin-project/lotus/chain/wallet"
 	"github.com/filecoin-project/lotus/lib/bufbstore"
+	"github.com/filecoin-project/lotus/node/modules/dtypes"
 )
 
 type StateAPI struct {
@@ -34,85 +51,277 @@ type StateAPI struct {
 	// API attached to the state API. It probably should live somewhere better
 	Wallet *wallet.Wallet
 
-	StateManager *stmgr.StateManager
-	Chain        *store.ChainStore
+	ProofVerifier ffiwrapper.Verifier
+	StateManager  *stmgr.StateManager
+	Chain         *store.ChainStore
+	Beacon        beacon.Schedule
 }
 
-func (a *StateAPI) StateMinerSectors(ctx context.Context, addr address.Address, ts *types.TipSet) ([]*api.ChainSectorInfo, error) {
-	return stmgr.GetMinerSectorSet(ctx, a.StateManager, ts, addr)
+func (a *StateAPI) StateNetworkName(ctx context.Context) (dtypes.NetworkName, error) {
+	return stmgr.GetNetworkName(ctx, a.StateManager, a.Chain.GetHeaviestTipSet().ParentState())
 }
 
-func (a *StateAPI) StateMinerProvingSet(ctx context.Context, addr address.Address, ts *types.TipSet) ([]*api.ChainSectorInfo, error) {
-	return stmgr.GetMinerProvingSet(ctx, a.StateManager, ts, addr)
-}
-
-func (a *StateAPI) StateMinerPower(ctx context.Context, maddr address.Address, ts *types.TipSet) (api.MinerPower, error) {
-	mpow, tpow, err := stmgr.GetPower(ctx, a.StateManager, ts, maddr)
+func (a *StateAPI) StateMinerSectors(ctx context.Context, addr address.Address, sectorNos *bitfield.BitField, tsk types.TipSetKey) ([]*miner.SectorOnChainInfo, error) {
+	ts, err := a.Chain.GetTipSetFromKey(tsk)
 	if err != nil {
-		return api.MinerPower{}, err
+		return nil, xerrors.Errorf("loading tipset %s: %w", tsk, err)
+	}
+	return stmgr.GetMinerSectorSet(ctx, a.StateManager, ts, addr, sectorNos)
+}
+
+func (a *StateAPI) StateMinerActiveSectors(ctx context.Context, maddr address.Address, tsk types.TipSetKey) ([]*miner.SectorOnChainInfo, error) { // TODO: only used in cli
+	ts, err := a.Chain.GetTipSetFromKey(tsk)
+	if err != nil {
+		return nil, xerrors.Errorf("loading tipset %s: %w", tsk, err)
 	}
 
-	if maddr != address.Undef {
-		slashed, err := stmgr.GetMinerSlashed(ctx, a.StateManager, ts, maddr)
+	act, err := a.StateManager.LoadActorTsk(ctx, maddr, tsk)
+	if err != nil {
+		return nil, xerrors.Errorf("failed to load miner actor: %w", err)
+	}
+
+	mas, err := miner.Load(a.StateManager.ChainStore().Store(ctx), act)
+	if err != nil {
+		return nil, xerrors.Errorf("failed to load miner actor state: %w", err)
+	}
+
+	activeSectors, err := miner.AllPartSectors(mas, miner.Partition.ActiveSectors)
+	if err != nil {
+		return nil, xerrors.Errorf("merge partition active sets: %w", err)
+	}
+
+	return stmgr.GetMinerSectorSet(ctx, a.StateManager, ts, maddr, &activeSectors)
+}
+
+func (a *StateAPI) StateMinerInfo(ctx context.Context, actor address.Address, tsk types.TipSetKey) (miner.MinerInfo, error) {
+	act, err := a.StateManager.LoadActorTsk(ctx, actor, tsk)
+	if err != nil {
+		return miner.MinerInfo{}, xerrors.Errorf("failed to load miner actor: %w", err)
+	}
+
+	mas, err := miner.Load(a.StateManager.ChainStore().Store(ctx), act)
+	if err != nil {
+		return miner.MinerInfo{}, xerrors.Errorf("failed to load miner actor state: %w", err)
+	}
+
+	return mas.Info()
+}
+
+func (a *StateAPI) StateMinerDeadlines(ctx context.Context, m address.Address, tsk types.TipSetKey) ([]api.Deadline, error) {
+	act, err := a.StateManager.LoadActorTsk(ctx, m, tsk)
+	if err != nil {
+		return nil, xerrors.Errorf("failed to load miner actor: %w", err)
+	}
+
+	mas, err := miner.Load(a.StateManager.ChainStore().Store(ctx), act)
+	if err != nil {
+		return nil, xerrors.Errorf("failed to load miner actor state: %w", err)
+	}
+
+	deadlines, err := mas.NumDeadlines()
+	if err != nil {
+		return nil, xerrors.Errorf("getting deadline count: %w", err)
+	}
+
+	out := make([]api.Deadline, deadlines)
+	if err := mas.ForEachDeadline(func(i uint64, dl miner.Deadline) error {
+		ps, err := dl.PostSubmissions()
 		if err != nil {
-			return api.MinerPower{}, err
+			return err
 		}
-		if slashed != 0 {
-			mpow = types.NewInt(0)
+
+		out[i] = api.Deadline{
+			PostSubmissions: ps,
+		}
+		return nil
+	}); err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (a *StateAPI) StateMinerPartitions(ctx context.Context, m address.Address, dlIdx uint64, tsk types.TipSetKey) ([]api.Partition, error) {
+	act, err := a.StateManager.LoadActorTsk(ctx, m, tsk)
+	if err != nil {
+		return nil, xerrors.Errorf("failed to load miner actor: %w", err)
+	}
+
+	mas, err := miner.Load(a.StateManager.ChainStore().Store(ctx), act)
+	if err != nil {
+		return nil, xerrors.Errorf("failed to load miner actor state: %w", err)
+	}
+
+	dl, err := mas.LoadDeadline(dlIdx)
+	if err != nil {
+		return nil, xerrors.Errorf("failed to load the deadline: %w", err)
+	}
+
+	var out []api.Partition
+	err = dl.ForEachPartition(func(_ uint64, part miner.Partition) error {
+		allSectors, err := part.AllSectors()
+		if err != nil {
+			return xerrors.Errorf("getting AllSectors: %w", err)
+		}
+
+		faultySectors, err := part.FaultySectors()
+		if err != nil {
+			return xerrors.Errorf("getting FaultySectors: %w", err)
+		}
+
+		recoveringSectors, err := part.RecoveringSectors()
+		if err != nil {
+			return xerrors.Errorf("getting RecoveringSectors: %w", err)
+		}
+
+		liveSectors, err := part.LiveSectors()
+		if err != nil {
+			return xerrors.Errorf("getting LiveSectors: %w", err)
+		}
+
+		activeSectors, err := part.ActiveSectors()
+		if err != nil {
+			return xerrors.Errorf("getting ActiveSectors: %w", err)
+		}
+
+		out = append(out, api.Partition{
+			AllSectors:        allSectors,
+			FaultySectors:     faultySectors,
+			RecoveringSectors: recoveringSectors,
+			LiveSectors:       liveSectors,
+			ActiveSectors:     activeSectors,
+		})
+		return nil
+	})
+
+	return out, err
+}
+
+func (a *StateAPI) StateMinerProvingDeadline(ctx context.Context, addr address.Address, tsk types.TipSetKey) (*dline.Info, error) {
+	ts, err := a.StateManager.ChainStore().GetTipSetFromKey(tsk)
+	if err != nil {
+		return nil, xerrors.Errorf("loading tipset %s: %w", tsk, err)
+	}
+
+	act, err := a.StateManager.LoadActor(ctx, addr, ts)
+	if err != nil {
+		return nil, xerrors.Errorf("failed to load miner actor: %w", err)
+	}
+
+	mas, err := miner.Load(a.StateManager.ChainStore().Store(ctx), act)
+	if err != nil {
+		return nil, xerrors.Errorf("failed to load miner actor state: %w", err)
+	}
+
+	di, err := mas.DeadlineInfo(ts.Height())
+	if err != nil {
+		return nil, xerrors.Errorf("failed to get deadline info: %w", err)
+	}
+
+	return di.NextNotElapsed(), nil
+}
+
+func (a *StateAPI) StateMinerFaults(ctx context.Context, addr address.Address, tsk types.TipSetKey) (bitfield.BitField, error) {
+	act, err := a.StateManager.LoadActorTsk(ctx, addr, tsk)
+	if err != nil {
+		return bitfield.BitField{}, xerrors.Errorf("failed to load miner actor: %w", err)
+	}
+
+	mas, err := miner.Load(a.StateManager.ChainStore().Store(ctx), act)
+	if err != nil {
+		return bitfield.BitField{}, xerrors.Errorf("failed to load miner actor state: %w", err)
+	}
+
+	return miner.AllPartSectors(mas, miner.Partition.FaultySectors)
+}
+
+func (a *StateAPI) StateAllMinerFaults(ctx context.Context, lookback abi.ChainEpoch, endTsk types.TipSetKey) ([]*api.Fault, error) {
+	return nil, xerrors.Errorf("fixme")
+
+	/*endTs, err := a.Chain.GetTipSetFromKey(endTsk)
+	if err != nil {
+		return nil, xerrors.Errorf("loading end tipset %s: %w", endTsk, err)
+	}
+
+	cutoff := endTs.Height() - lookback
+	miners, err := stmgr.ListMinerActors(ctx, a.StateManager, endTs)
+
+	if err != nil {
+		return nil, xerrors.Errorf("loading miners: %w", err)
+	}
+
+	var allFaults []*api.Fault
+
+	for _, m := range miners {
+		var mas miner.State
+		_, err := a.StateManager.LoadActorState(ctx, m, &mas, endTs)
+		if err != nil {
+			return nil, xerrors.Errorf("failed to load miner actor state %s: %w", m, err)
+		}
+
+		err = mas.ForEachFaultEpoch(a.Chain.Store(ctx), func(faultStart abi.ChainEpoch, faults abi.BitField) error {
+			if faultStart >= cutoff {
+				allFaults = append(allFaults, &api.Fault{
+					Miner: m,
+					Epoch: faultStart,
+				})
+				return nil
+			}
+			return nil
+		})
+
+		if err != nil {
+			return nil, xerrors.Errorf("failure when iterating over miner states: %w", err)
 		}
 	}
 
-	return api.MinerPower{
-		MinerPower: mpow,
-		TotalPower: tpow,
+	return allFaults, nil*/
+}
+
+func (a *StateAPI) StateMinerRecoveries(ctx context.Context, addr address.Address, tsk types.TipSetKey) (bitfield.BitField, error) {
+	act, err := a.StateManager.LoadActorTsk(ctx, addr, tsk)
+	if err != nil {
+		return bitfield.BitField{}, xerrors.Errorf("failed to load miner actor: %w", err)
+	}
+
+	mas, err := miner.Load(a.StateManager.ChainStore().Store(ctx), act)
+	if err != nil {
+		return bitfield.BitField{}, xerrors.Errorf("failed to load miner actor state: %w", err)
+	}
+
+	return miner.AllPartSectors(mas, miner.Partition.RecoveringSectors)
+}
+
+func (a *StateAPI) StateMinerPower(ctx context.Context, addr address.Address, tsk types.TipSetKey) (*api.MinerPower, error) {
+	ts, err := a.Chain.GetTipSetFromKey(tsk)
+	if err != nil {
+		return nil, xerrors.Errorf("loading tipset %s: %w", tsk, err)
+	}
+
+	m, net, hmp, err := stmgr.GetPower(ctx, a.StateManager, ts, addr)
+	if err != nil {
+		return nil, err
+	}
+
+	return &api.MinerPower{
+		MinerPower:  m,
+		TotalPower:  net,
+		HasMinPower: hmp,
 	}, nil
 }
 
-func (a *StateAPI) StateMinerWorker(ctx context.Context, m address.Address, ts *types.TipSet) (address.Address, error) {
-	return stmgr.GetMinerWorker(ctx, a.StateManager, ts, m)
-}
-
-func (a *StateAPI) StateMinerPeerID(ctx context.Context, m address.Address, ts *types.TipSet) (peer.ID, error) {
-	return stmgr.GetMinerPeerID(ctx, a.StateManager, ts, m)
-}
-
-func (a *StateAPI) StateMinerElectionPeriodStart(ctx context.Context, actor address.Address, ts *types.TipSet) (uint64, error) {
-	return stmgr.GetMinerElectionPeriodStart(ctx, a.StateManager, ts, actor)
-}
-
-func (a *StateAPI) StateMinerSectorSize(ctx context.Context, actor address.Address, ts *types.TipSet) (uint64, error) {
-	return stmgr.GetMinerSectorSize(ctx, a.StateManager, ts, actor)
-}
-
-func (a *StateAPI) StatePledgeCollateral(ctx context.Context, ts *types.TipSet) (types.BigInt, error) {
-	param, err := actors.SerializeParams(&actors.PledgeCollateralParams{Size: types.NewInt(0)})
+func (a *StateAPI) StateCall(ctx context.Context, msg *types.Message, tsk types.TipSetKey) (*api.InvocResult, error) {
+	ts, err := a.Chain.GetTipSetFromKey(tsk)
 	if err != nil {
-		return types.NewInt(0), err
+		return nil, xerrors.Errorf("loading tipset %s: %w", tsk, err)
 	}
-
-	ret, aerr := a.StateManager.Call(ctx, &types.Message{
-		From:   actors.StoragePowerAddress,
-		To:     actors.StoragePowerAddress,
-		Method: actors.SPAMethods.PledgeCollateralForSize,
-
-		Params: param,
-	}, ts)
-	if aerr != nil {
-		return types.NewInt(0), xerrors.Errorf("failed to get miner worker addr: %w", err)
-	}
-
-	if ret.ExitCode != 0 {
-		return types.NewInt(0), xerrors.Errorf("failed to get miner worker addr (exit code %d)", ret.ExitCode)
-	}
-
-	return types.BigFromBytes(ret.Return), nil
-}
-
-func (a *StateAPI) StateCall(ctx context.Context, msg *types.Message, ts *types.TipSet) (*types.MessageReceipt, error) {
 	return a.StateManager.Call(ctx, msg, ts)
 }
 
-func (a *StateAPI) StateReplay(ctx context.Context, ts *types.TipSet, mc cid.Cid) (*api.ReplayResults, error) {
+func (a *StateAPI) StateReplay(ctx context.Context, tsk types.TipSetKey, mc cid.Cid) (*api.InvocResult, error) {
+	ts, err := a.Chain.GetTipSetFromKey(tsk)
+	if err != nil {
+		return nil, xerrors.Errorf("loading tipset %s: %w", tsk, err)
+	}
 	m, r, err := a.StateManager.Replay(ctx, ts, mc)
 	if err != nil {
 		return nil, err
@@ -123,10 +332,12 @@ func (a *StateAPI) StateReplay(ctx context.Context, ts *types.TipSet, mc cid.Cid
 		errstr = r.ActorErr.Error()
 	}
 
-	return &api.ReplayResults{
-		Msg:     m,
-		Receipt: &r.MessageReceipt,
-		Error:   errstr,
+	return &api.InvocResult{
+		Msg:            m,
+		MsgRct:         &r.MessageReceipt,
+		ExecutionTrace: r.ExecutionTrace,
+		Error:          errstr,
+		Duration:       r.Duration,
 	}, nil
 }
 
@@ -141,11 +352,15 @@ func (a *StateAPI) stateForTs(ctx context.Context, ts *types.TipSet) (*state.Sta
 	}
 
 	buf := bufbstore.NewBufferedBstore(a.Chain.Blockstore())
-	cst := hamt.CSTFromBstore(buf)
+	cst := cbor.NewCborStore(buf)
 	return state.LoadStateTree(cst, st)
 }
 
-func (a *StateAPI) StateGetActor(ctx context.Context, actor address.Address, ts *types.TipSet) (*types.Actor, error) {
+func (a *StateAPI) StateGetActor(ctx context.Context, actor address.Address, tsk types.TipSetKey) (*types.Actor, error) {
+	ts, err := a.Chain.GetTipSetFromKey(tsk)
+	if err != nil {
+		return nil, xerrors.Errorf("loading tipset %s: %w", tsk, err)
+	}
 	state, err := a.stateForTs(ctx, ts)
 	if err != nil {
 		return nil, xerrors.Errorf("computing tipset state failed: %w", err)
@@ -154,7 +369,11 @@ func (a *StateAPI) StateGetActor(ctx context.Context, actor address.Address, ts
 	return state.GetActor(actor)
 }
 
-func (a *StateAPI) StateLookupID(ctx context.Context, addr address.Address, ts *types.TipSet) (address.Address, error) {
+func (a *StateAPI) StateLookupID(ctx context.Context, addr address.Address, tsk types.TipSetKey) (address.Address, error) {
+	ts, err := a.Chain.GetTipSetFromKey(tsk)
+	if err != nil {
+		return address.Undef, xerrors.Errorf("loading tipset %s: %w", tsk, err)
+	}
 	state, err := a.stateForTs(ctx, ts)
 	if err != nil {
 		return address.Undef, err
@@ -163,20 +382,38 @@ func (a *StateAPI) StateLookupID(ctx context.Context, addr address.Address, ts *
 	return state.LookupID(addr)
 }
 
-func (a *StateAPI) StateReadState(ctx context.Context, act *types.Actor, ts *types.TipSet) (*api.ActorState, error) {
-	state, err := a.stateForTs(ctx, ts)
+func (a *StateAPI) StateAccountKey(ctx context.Context, addr address.Address, tsk types.TipSetKey) (address.Address, error) {
+	ts, err := a.Chain.GetTipSetFromKey(tsk)
 	if err != nil {
-		return nil, err
+		return address.Undef, xerrors.Errorf("loading tipset %s: %w", tsk, err)
 	}
 
-	blk, err := state.Store.Blocks.GetBlock(ctx, act.Head)
+	return a.StateManager.ResolveToKeyAddress(ctx, addr, ts)
+}
+
+func (a *StateAPI) StateReadState(ctx context.Context, actor address.Address, tsk types.TipSetKey) (*api.ActorState, error) {
+	ts, err := a.Chain.GetTipSetFromKey(tsk)
 	if err != nil {
-		return nil, err
+		return nil, xerrors.Errorf("loading tipset %s: %w", tsk, err)
+	}
+	state, err := a.stateForTs(ctx, ts)
+	if err != nil {
+		return nil, xerrors.Errorf("getting state for tipset: %w", err)
+	}
+
+	act, err := state.GetActor(actor)
+	if err != nil {
+		return nil, xerrors.Errorf("getting actor: %w", err)
+	}
+
+	blk, err := state.Store.(*cbor.BasicIpldStore).Blocks.Get(act.Head)
+	if err != nil {
+		return nil, xerrors.Errorf("getting actor head: %w", err)
 	}
 
 	oif, err := vm.DumpActorState(act.Code, blk.RawData())
 	if err != nil {
-		return nil, err
+		return nil, xerrors.Errorf("dumping actor state (a:%s): %w", actor, err)
 	}
 
 	return &api.ActorState{
@@ -186,8 +423,12 @@ func (a *StateAPI) StateReadState(ctx context.Context, act *types.Actor, ts *typ
 }
 
 // This is on StateAPI because miner.Miner requires this, and MinerAPI requires miner.Miner
-func (a *StateAPI) MinerCreateBlock(ctx context.Context, addr address.Address, parents *types.TipSet, ticket *types.Ticket, proof *types.EPostProof, msgs []*types.SignedMessage, height, ts uint64) (*types.BlockMsg, error) {
-	fblk, err := gen.MinerCreateBlock(ctx, a.StateManager, a.Wallet, addr, parents, ticket, proof, msgs, height, ts)
+func (a *StateAPI) MinerGetBaseInfo(ctx context.Context, maddr address.Address, epoch abi.ChainEpoch, tsk types.TipSetKey) (*api.MiningBaseInfo, error) {
+	return stmgr.MinerGetBaseInfo(ctx, a.StateManager, a.Beacon, tsk, epoch, maddr, a.ProofVerifier)
+}
+
+func (a *StateAPI) MinerCreateBlock(ctx context.Context, bt *api.BlockTemplate) (*types.BlockMsg, error) {
+	fblk, err := gen.MinerCreateBlock(ctx, a.StateManager, a.Wallet, bt)
 	if err != nil {
 		return nil, err
 	}
@@ -204,60 +445,123 @@ func (a *StateAPI) MinerCreateBlock(ctx context.Context, addr address.Address, p
 	return &out, nil
 }
 
-func (a *StateAPI) StateWaitMsg(ctx context.Context, msg cid.Cid) (*api.MsgWait, error) {
-	// TODO: consider using event system for this, expose confidence
-
-	ts, recpt, err := a.StateManager.WaitForMessage(ctx, msg)
+func (a *StateAPI) StateWaitMsg(ctx context.Context, msg cid.Cid, confidence uint64) (*api.MsgLookup, error) {
+	ts, recpt, found, err := a.StateManager.WaitForMessage(ctx, msg, confidence)
 	if err != nil {
 		return nil, err
 	}
 
-	return &api.MsgWait{
-		Receipt: *recpt,
-		TipSet:  ts,
+	var returndec interface{}
+	if recpt.ExitCode == 0 && len(recpt.Return) > 0 {
+		cmsg, err := a.Chain.GetCMessage(msg)
+		if err != nil {
+			return nil, xerrors.Errorf("failed to load message after successful receipt search: %w", err)
+		}
+
+		vmsg := cmsg.VMMessage()
+
+		t, err := stmgr.GetReturnType(ctx, a.StateManager, vmsg.To, vmsg.Method, ts)
+		if err != nil {
+			return nil, xerrors.Errorf("failed to get return type: %w", err)
+		}
+
+		if err := t.UnmarshalCBOR(bytes.NewReader(recpt.Return)); err != nil {
+			return nil, err
+		}
+
+		returndec = t
+	}
+
+	return &api.MsgLookup{
+		Message:   found,
+		Receipt:   *recpt,
+		ReturnDec: returndec,
+		TipSet:    ts.Key(),
+		Height:    ts.Height(),
 	}, nil
 }
 
-func (a *StateAPI) StateGetReceipt(ctx context.Context, msg cid.Cid, ts *types.TipSet) (*types.MessageReceipt, error) {
-	return a.StateManager.GetReceipt(ctx, msg, ts)
-}
-
-func (a *StateAPI) StateListMiners(ctx context.Context, ts *types.TipSet) ([]address.Address, error) {
-	return stmgr.ListMinerActors(ctx, a.StateManager, ts)
-}
-
-func (a *StateAPI) StateListActors(ctx context.Context, ts *types.TipSet) ([]address.Address, error) {
-	return a.StateManager.ListAllActors(ctx, ts)
-}
-
-func (a *StateAPI) StateMarketBalance(ctx context.Context, addr address.Address, ts *types.TipSet) (actors.StorageParticipantBalance, error) {
-	return a.StateManager.MarketBalance(ctx, addr, ts)
-}
-
-func (a *StateAPI) StateMarketParticipants(ctx context.Context, ts *types.TipSet) (map[string]actors.StorageParticipantBalance, error) {
-	out := map[string]actors.StorageParticipantBalance{}
-
-	var state actors.StorageMarketState
-	if _, err := a.StateManager.LoadActorState(ctx, actors.StorageMarketAddress, &state, ts); err != nil {
-		return nil, err
-	}
-	cst := hamt.CSTFromBstore(a.StateManager.ChainStore().Blockstore())
-	nd, err := hamt.LoadNode(ctx, cst, state.Balances)
+func (a *StateAPI) StateSearchMsg(ctx context.Context, msg cid.Cid) (*api.MsgLookup, error) {
+	ts, recpt, found, err := a.StateManager.SearchForMessage(ctx, msg)
 	if err != nil {
 		return nil, err
 	}
 
-	err = nd.ForEach(ctx, func(k string, val interface{}) error {
-		cv := val.(*cbg.Deferred)
-		a, err := address.NewFromBytes([]byte(k))
+	if ts != nil {
+		return &api.MsgLookup{
+			Message: found,
+			Receipt: *recpt,
+			TipSet:  ts.Key(),
+			Height:  ts.Height(),
+		}, nil
+	}
+	return nil, nil
+}
+
+func (a *StateAPI) StateGetReceipt(ctx context.Context, msg cid.Cid, tsk types.TipSetKey) (*types.MessageReceipt, error) {
+	ts, err := a.Chain.GetTipSetFromKey(tsk)
+	if err != nil {
+		return nil, xerrors.Errorf("loading tipset %s: %w", tsk, err)
+	}
+	return a.StateManager.GetReceipt(ctx, msg, ts)
+}
+
+func (a *StateAPI) StateListMiners(ctx context.Context, tsk types.TipSetKey) ([]address.Address, error) {
+	ts, err := a.Chain.GetTipSetFromKey(tsk)
+	if err != nil {
+		return nil, xerrors.Errorf("loading tipset %s: %w", tsk, err)
+	}
+	return stmgr.ListMinerActors(ctx, a.StateManager, ts)
+}
+
+func (a *StateAPI) StateListActors(ctx context.Context, tsk types.TipSetKey) ([]address.Address, error) {
+	ts, err := a.Chain.GetTipSetFromKey(tsk)
+	if err != nil {
+		return nil, xerrors.Errorf("loading tipset %s: %w", tsk, err)
+	}
+	return a.StateManager.ListAllActors(ctx, ts)
+}
+
+func (a *StateAPI) StateMarketBalance(ctx context.Context, addr address.Address, tsk types.TipSetKey) (api.MarketBalance, error) {
+	ts, err := a.Chain.GetTipSetFromKey(tsk)
+	if err != nil {
+		return api.MarketBalance{}, xerrors.Errorf("loading tipset %s: %w", tsk, err)
+	}
+	return a.StateManager.MarketBalance(ctx, addr, ts)
+}
+
+func (a *StateAPI) StateMarketParticipants(ctx context.Context, tsk types.TipSetKey) (map[string]api.MarketBalance, error) {
+	out := map[string]api.MarketBalance{}
+
+	ts, err := a.Chain.GetTipSetFromKey(tsk)
+	if err != nil {
+		return nil, xerrors.Errorf("loading tipset %s: %w", tsk, err)
+	}
+
+	state, err := a.StateManager.GetMarketState(ctx, ts)
+	if err != nil {
+		return nil, err
+	}
+	escrow, err := state.EscrowTable()
+	if err != nil {
+		return nil, err
+	}
+	locked, err := state.LockedTable()
+	if err != nil {
+		return nil, err
+	}
+
+	err = escrow.ForEach(func(a address.Address, es abi.TokenAmount) error {
+
+		lk, err := locked.Get(a)
 		if err != nil {
 			return err
 		}
-		var b actors.StorageParticipantBalance
-		if err := b.UnmarshalCBOR(bytes.NewReader(cv.Raw)); err != nil {
-			return err
+
+		out[a.String()] = api.MarketBalance{
+			Escrow: es,
+			Locked: lk,
 		}
-		out[a.String()] = b
 		return nil
 	})
 	if err != nil {
@@ -266,26 +570,40 @@ func (a *StateAPI) StateMarketParticipants(ctx context.Context, ts *types.TipSet
 	return out, nil
 }
 
-func (a *StateAPI) StateMarketDeals(ctx context.Context, ts *types.TipSet) (map[string]actors.OnChainDeal, error) {
-	out := map[string]actors.OnChainDeal{}
+func (a *StateAPI) StateMarketDeals(ctx context.Context, tsk types.TipSetKey) (map[string]api.MarketDeal, error) {
+	out := map[string]api.MarketDeal{}
 
-	var state actors.StorageMarketState
-	if _, err := a.StateManager.LoadActorState(ctx, actors.StorageMarketAddress, &state, ts); err != nil {
-		return nil, err
+	ts, err := a.Chain.GetTipSetFromKey(tsk)
+	if err != nil {
+		return nil, xerrors.Errorf("loading tipset %s: %w", tsk, err)
 	}
 
-	blks := amt.WrapBlockstore(a.StateManager.ChainStore().Blockstore())
-	da, err := amt.LoadAMT(blks, state.Deals)
+	state, err := a.StateManager.GetMarketState(ctx, ts)
 	if err != nil {
 		return nil, err
 	}
 
-	if err := da.ForEach(func(i uint64, v *cbg.Deferred) error {
-		var d actors.OnChainDeal
-		if err := d.UnmarshalCBOR(bytes.NewReader(v.Raw)); err != nil {
-			return err
+	da, err := state.Proposals()
+	if err != nil {
+		return nil, err
+	}
+
+	sa, err := state.States()
+	if err != nil {
+		return nil, err
+	}
+
+	if err := da.ForEach(func(dealID abi.DealID, d market.DealProposal) error {
+		s, found, err := sa.Get(dealID)
+		if err != nil {
+			return xerrors.Errorf("failed to get state for deal in proposals array: %w", err)
+		} else if !found {
+			s = market.EmptyDealState()
+		}
+		out[strconv.FormatInt(int64(dealID), 10)] = api.MarketDeal{
+			Proposal: d,
+			State:    *s,
 		}
-		out[strconv.FormatInt(int64(i), 10)] = d
 		return nil
 	}); err != nil {
 		return nil, err
@@ -293,66 +611,122 @@ func (a *StateAPI) StateMarketDeals(ctx context.Context, ts *types.TipSet) (map[
 	return out, nil
 }
 
-func (a *StateAPI) StateMarketStorageDeal(ctx context.Context, dealId uint64, ts *types.TipSet) (*actors.OnChainDeal, error) {
+func (a *StateAPI) StateMarketStorageDeal(ctx context.Context, dealId abi.DealID, tsk types.TipSetKey) (*api.MarketDeal, error) {
+	ts, err := a.Chain.GetTipSetFromKey(tsk)
+	if err != nil {
+		return nil, xerrors.Errorf("loading tipset %s: %w", tsk, err)
+	}
 	return stmgr.GetStorageDeal(ctx, a.StateManager, dealId, ts)
 }
 
 func (a *StateAPI) StateChangedActors(ctx context.Context, old cid.Cid, new cid.Cid) (map[string]types.Actor, error) {
-	cst := hamt.CSTFromBstore(a.Chain.Blockstore())
+	store := a.Chain.Store(ctx)
 
-	nh, err := hamt.LoadNode(ctx, cst, new)
+	oldTree, err := state.LoadStateTree(store, old)
 	if err != nil {
-		return nil, err
+		return nil, xerrors.Errorf("failed to load old state tree: %w", err)
 	}
 
-	oh, err := hamt.LoadNode(ctx, cst, old)
+	newTree, err := state.LoadStateTree(store, new)
 	if err != nil {
-		return nil, err
+		return nil, xerrors.Errorf("failed to load new state tree: %w", err)
 	}
 
-	out := map[string]types.Actor{}
+	return state.Diff(oldTree, newTree)
+}
 
-	err = nh.ForEach(ctx, func(k string, nval interface{}) error {
-		ncval := nval.(*cbg.Deferred)
-		var act types.Actor
-
-		var ocval cbg.Deferred
-
-		switch err := oh.Find(ctx, k, &ocval); err {
-		case nil:
-			if bytes.Equal(ocval.Raw, ncval.Raw) {
-				return nil // not changed
-			}
-			fallthrough
-		case hamt.ErrNotFound:
-			if err := act.UnmarshalCBOR(bytes.NewReader(ncval.Raw)); err != nil {
+func (a *StateAPI) StateMinerSectorCount(ctx context.Context, addr address.Address, tsk types.TipSetKey) (api.MinerSectors, error) {
+	act, err := a.StateManager.LoadActorTsk(ctx, addr, tsk)
+	if err != nil {
+		return api.MinerSectors{}, err
+	}
+	mas, err := miner.Load(a.Chain.Store(ctx), act)
+	if err != nil {
+		return api.MinerSectors{}, err
+	}
+	var activeCount, liveCount, faultyCount uint64
+	if err := mas.ForEachDeadline(func(_ uint64, dl miner.Deadline) error {
+		return dl.ForEachPartition(func(_ uint64, part miner.Partition) error {
+			if active, err := part.ActiveSectors(); err != nil {
 				return err
+			} else if count, err := active.Count(); err != nil {
+				return err
+			} else {
+				activeCount += count
 			}
-
-			addr, err := address.NewFromBytes([]byte(k))
-			if err != nil {
-				return xerrors.Errorf("address in state tree was not valid: %w", err)
+			if live, err := part.LiveSectors(); err != nil {
+				return err
+			} else if count, err := live.Count(); err != nil {
+				return err
+			} else {
+				liveCount += count
 			}
+			if faulty, err := part.FaultySectors(); err != nil {
+				return err
+			} else if count, err := faulty.Count(); err != nil {
+				return err
+			} else {
+				faultyCount += count
+			}
+			return nil
+		})
+	}); err != nil {
+		return api.MinerSectors{}, err
+	}
+	return api.MinerSectors{Live: liveCount, Active: activeCount, Faulty: faultyCount}, nil
+}
 
-			out[addr.String()] = act
-		default:
-			return err
-		}
+func (a *StateAPI) StateSectorPreCommitInfo(ctx context.Context, maddr address.Address, n abi.SectorNumber, tsk types.TipSetKey) (miner.SectorPreCommitOnChainInfo, error) {
+	ts, err := a.Chain.GetTipSetFromKey(tsk)
+	if err != nil {
+		return miner.SectorPreCommitOnChainInfo{}, xerrors.Errorf("loading tipset %s: %w", tsk, err)
+	}
 
-		return nil
-	})
+	pci, err := stmgr.PreCommitInfo(ctx, a.StateManager, maddr, n, ts)
+	if err != nil {
+		return miner.SectorPreCommitOnChainInfo{}, err
+	}
+
+	return *pci, err
+}
+
+func (a *StateAPI) StateSectorGetInfo(ctx context.Context, maddr address.Address, n abi.SectorNumber, tsk types.TipSetKey) (*miner.SectorOnChainInfo, error) {
+	ts, err := a.Chain.GetTipSetFromKey(tsk)
+	if err != nil {
+		return nil, xerrors.Errorf("loading tipset %s: %w", tsk, err)
+	}
+	return stmgr.MinerSectorInfo(ctx, a.StateManager, maddr, n, ts)
+}
+
+func (a *StateAPI) StateSectorExpiration(ctx context.Context, maddr address.Address, sectorNumber abi.SectorNumber, tsk types.TipSetKey) (*miner.SectorExpiration, error) {
+	act, err := a.StateManager.LoadActorTsk(ctx, maddr, tsk)
 	if err != nil {
 		return nil, err
 	}
-
-	return out, nil
+	mas, err := miner.Load(a.StateManager.ChainStore().Store(ctx), act)
+	if err != nil {
+		return nil, err
+	}
+	return mas.GetSectorExpiration(sectorNumber)
 }
 
-func (a *StateAPI) StateMinerSectorCount(ctx context.Context, addr address.Address, ts *types.TipSet) (api.MinerSectors, error) {
-	return stmgr.SectorSetSizes(ctx, a.StateManager, addr, ts)
+func (a *StateAPI) StateSectorPartition(ctx context.Context, maddr address.Address, sectorNumber abi.SectorNumber, tsk types.TipSetKey) (*miner.SectorLocation, error) {
+	act, err := a.StateManager.LoadActorTsk(ctx, maddr, tsk)
+	if err != nil {
+		return nil, err
+	}
+	mas, err := miner.Load(a.StateManager.ChainStore().Store(ctx), act)
+	if err != nil {
+		return nil, err
+	}
+	return mas.FindSector(sectorNumber)
 }
 
-func (a *StateAPI) StateListMessages(ctx context.Context, match *types.Message, ts *types.TipSet, toheight uint64) ([]cid.Cid, error) {
+func (a *StateAPI) StateListMessages(ctx context.Context, match *types.Message, tsk types.TipSetKey, toheight abi.ChainEpoch) ([]cid.Cid, error) {
+	ts, err := a.Chain.GetTipSetFromKey(tsk)
+	if err != nil {
+		return nil, xerrors.Errorf("loading tipset %s: %w", tsk, err)
+	}
 	if ts == nil {
 		ts = a.Chain.GetHeaviestTipSet()
 	}
@@ -400,3 +774,410 @@ func (a *StateAPI) StateListMessages(ctx context.Context, match *types.Message,
 
 	return out, nil
 }
+
+func (a *StateAPI) StateCompute(ctx context.Context, height abi.ChainEpoch, msgs []*types.Message, tsk types.TipSetKey) (*api.ComputeStateOutput, error) {
+	ts, err := a.Chain.GetTipSetFromKey(tsk)
+	if err != nil {
+		return nil, xerrors.Errorf("loading tipset %s: %w", tsk, err)
+	}
+	st, t, err := stmgr.ComputeState(ctx, a.StateManager, height, msgs, ts)
+	if err != nil {
+		return nil, err
+	}
+
+	return &api.ComputeStateOutput{
+		Root:  st,
+		Trace: t,
+	}, nil
+}
+
+func (a *StateAPI) MsigGetAvailableBalance(ctx context.Context, addr address.Address, tsk types.TipSetKey) (types.BigInt, error) {
+	ts, err := a.Chain.GetTipSetFromKey(tsk)
+	if err != nil {
+		return types.EmptyInt, xerrors.Errorf("loading tipset %s: %w", tsk, err)
+	}
+
+	act, err := a.StateManager.LoadActor(ctx, addr, ts)
+	if err != nil {
+		return types.EmptyInt, xerrors.Errorf("failed to load multisig actor: %w", err)
+	}
+	msas, err := multisig.Load(a.Chain.Store(ctx), act)
+	if err != nil {
+		return types.EmptyInt, xerrors.Errorf("failed to load multisig actor state: %w", err)
+	}
+	locked, err := msas.LockedBalance(ts.Height())
+	if err != nil {
+		return types.EmptyInt, xerrors.Errorf("failed to compute locked multisig balance: %w", err)
+	}
+	return types.BigSub(act.Balance, locked), nil
+}
+
+func (a *StateAPI) MsigGetVested(ctx context.Context, addr address.Address, start types.TipSetKey, end types.TipSetKey) (types.BigInt, error) {
+	startTs, err := a.Chain.GetTipSetFromKey(start)
+	if err != nil {
+		return types.EmptyInt, xerrors.Errorf("loading start tipset %s: %w", start, err)
+	}
+
+	endTs, err := a.Chain.GetTipSetFromKey(end)
+	if err != nil {
+		return types.EmptyInt, xerrors.Errorf("loading end tipset %s: %w", end, err)
+	}
+
+	if startTs.Height() > endTs.Height() {
+		return types.EmptyInt, xerrors.Errorf("start tipset %d is after end tipset %d", startTs.Height(), endTs.Height())
+	} else if startTs.Height() == endTs.Height() {
+		return big.Zero(), nil
+	}
+
+	act, err := a.StateManager.LoadActor(ctx, addr, endTs)
+	if err != nil {
+		return types.EmptyInt, xerrors.Errorf("failed to load multisig actor at end epoch: %w", err)
+	}
+
+	msas, err := multisig.Load(a.Chain.Store(ctx), act)
+	if err != nil {
+		return types.EmptyInt, xerrors.Errorf("failed to load multisig actor state: %w", err)
+	}
+
+	startLk, err := msas.LockedBalance(startTs.Height())
+	if err != nil {
+		return types.EmptyInt, xerrors.Errorf("failed to compute locked balance at start height: %w", err)
+	}
+
+	endLk, err := msas.LockedBalance(endTs.Height())
+	if err != nil {
+		return types.EmptyInt, xerrors.Errorf("failed to compute locked balance at end height: %w", err)
+	}
+
+	return types.BigSub(startLk, endLk), nil
+}
+
+var initialPledgeNum = types.NewInt(110)
+var initialPledgeDen = types.NewInt(100)
+
+func (a *StateAPI) StateMinerPreCommitDepositForPower(ctx context.Context, maddr address.Address, pci miner.SectorPreCommitInfo, tsk types.TipSetKey) (types.BigInt, error) {
+	ts, err := a.Chain.GetTipSetFromKey(tsk)
+	if err != nil {
+		return types.EmptyInt, xerrors.Errorf("loading tipset %s: %w", tsk, err)
+	}
+
+	state, err := a.StateManager.ParentState(ts)
+	if err != nil {
+		return types.EmptyInt, xerrors.Errorf("loading state %s: %w", tsk, err)
+	}
+
+	ssize, err := pci.SealProof.SectorSize()
+	if err != nil {
+		return types.EmptyInt, xerrors.Errorf("failed to get resolve size: %w", err)
+	}
+
+	store := a.Chain.Store(ctx)
+
+	var sectorWeight abi.StoragePower
+	if act, err := state.GetActor(market.Address); err != nil {
+		return types.EmptyInt, xerrors.Errorf("loading market actor %s: %w", maddr, err)
+	} else if s, err := market.Load(store, act); err != nil {
+		return types.EmptyInt, xerrors.Errorf("loading market actor state %s: %w", maddr, err)
+	} else if w, vw, err := s.VerifyDealsForActivation(maddr, pci.DealIDs, ts.Height(), pci.Expiration); err != nil {
+		return types.EmptyInt, xerrors.Errorf("verifying deals for activation: %w", err)
+	} else {
+		// NB: not exactly accurate, but should always lead us to *over* estimate, not under
+		duration := pci.Expiration - ts.Height()
+		sectorWeight = lotusbuiltin.QAPowerForWeight(ssize, duration, w, vw)
+	}
+
+	var powerSmoothed lotusbuiltin.FilterEstimate
+	if act, err := state.GetActor(power.Address); err != nil {
+		return types.EmptyInt, xerrors.Errorf("loading power actor: %w", err)
+	} else if s, err := power.Load(store, act); err != nil {
+		return types.EmptyInt, xerrors.Errorf("loading power actor state: %w", err)
+	} else if p, err := s.TotalPowerSmoothed(); err != nil {
+		return types.EmptyInt, xerrors.Errorf("failed to determine total power: %w", err)
+	} else {
+		powerSmoothed = p
+	}
+
+	rewardActor, err := state.GetActor(reward.Address)
+	if err != nil {
+		return types.EmptyInt, xerrors.Errorf("loading miner actor: %w", err)
+	}
+
+	rewardState, err := reward.Load(store, rewardActor)
+	if err != nil {
+		return types.EmptyInt, xerrors.Errorf("loading reward actor state: %w", err)
+	}
+
+	deposit, err := rewardState.PreCommitDepositForPower(powerSmoothed, sectorWeight)
+	if err != nil {
+		return big.Zero(), xerrors.Errorf("calculating precommit deposit: %w", err)
+	}
+
+	return types.BigDiv(types.BigMul(deposit, initialPledgeNum), initialPledgeDen), nil
+}
+
+func (a *StateAPI) StateMinerInitialPledgeCollateral(ctx context.Context, maddr address.Address, pci miner.SectorPreCommitInfo, tsk types.TipSetKey) (types.BigInt, error) {
+	// TODO: this repeats a lot of the previous function. Fix that.
+	ts, err := a.Chain.GetTipSetFromKey(tsk)
+	if err != nil {
+		return types.EmptyInt, xerrors.Errorf("loading tipset %s: %w", tsk, err)
+	}
+
+	state, err := a.StateManager.ParentState(ts)
+	if err != nil {
+		return types.EmptyInt, xerrors.Errorf("loading state %s: %w", tsk, err)
+	}
+
+	ssize, err := pci.SealProof.SectorSize()
+	if err != nil {
+		return types.EmptyInt, xerrors.Errorf("failed to get resolve size: %w", err)
+	}
+
+	store := a.Chain.Store(ctx)
+
+	var sectorWeight abi.StoragePower
+	if act, err := state.GetActor(market.Address); err != nil {
+		return types.EmptyInt, xerrors.Errorf("loading miner actor %s: %w", maddr, err)
+	} else if s, err := market.Load(store, act); err != nil {
+		return types.EmptyInt, xerrors.Errorf("loading market actor state %s: %w", maddr, err)
+	} else if w, vw, err := s.VerifyDealsForActivation(maddr, pci.DealIDs, ts.Height(), pci.Expiration); err != nil {
+		return types.EmptyInt, xerrors.Errorf("verifying deals for activation: %w", err)
+	} else {
+		// NB: not exactly accurate, but should always lead us to *over* estimate, not under
+		duration := pci.Expiration - ts.Height()
+		sectorWeight = lotusbuiltin.QAPowerForWeight(ssize, duration, w, vw)
+	}
+
+	var (
+		powerSmoothed    lotusbuiltin.FilterEstimate
+		pledgeCollateral abi.TokenAmount
+	)
+	if act, err := state.GetActor(power.Address); err != nil {
+		return types.EmptyInt, xerrors.Errorf("loading miner actor: %w", err)
+	} else if s, err := power.Load(store, act); err != nil {
+		return types.EmptyInt, xerrors.Errorf("loading power actor state: %w", err)
+	} else if p, err := s.TotalPowerSmoothed(); err != nil {
+		return types.EmptyInt, xerrors.Errorf("failed to determine total power: %w", err)
+	} else if c, err := s.TotalLocked(); err != nil {
+		return types.EmptyInt, xerrors.Errorf("failed to determine pledge collateral: %w", err)
+	} else {
+		powerSmoothed = p
+		pledgeCollateral = c
+	}
+
+	rewardActor, err := state.GetActor(reward.Address)
+	if err != nil {
+		return types.EmptyInt, xerrors.Errorf("loading miner actor: %w", err)
+	}
+
+	rewardState, err := reward.Load(store, rewardActor)
+	if err != nil {
+		return types.EmptyInt, xerrors.Errorf("loading reward actor state: %w", err)
+	}
+
+	circSupply, err := a.StateCirculatingSupply(ctx, ts.Key())
+	if err != nil {
+		return big.Zero(), xerrors.Errorf("getting circulating supply: %w", err)
+	}
+
+	initialPledge, err := rewardState.InitialPledgeForPower(
+		sectorWeight,
+		pledgeCollateral,
+		&powerSmoothed,
+		circSupply.FilCirculating,
+	)
+	if err != nil {
+		return big.Zero(), xerrors.Errorf("calculating initial pledge: %w", err)
+	}
+
+	return types.BigDiv(types.BigMul(initialPledge, initialPledgeNum), initialPledgeDen), nil
+}
+
+func (a *StateAPI) StateMinerAvailableBalance(ctx context.Context, maddr address.Address, tsk types.TipSetKey) (types.BigInt, error) {
+	ts, err := a.Chain.GetTipSetFromKey(tsk)
+	if err != nil {
+		return types.EmptyInt, xerrors.Errorf("loading tipset %s: %w", tsk, err)
+	}
+
+	act, err := a.StateManager.LoadActor(ctx, maddr, ts)
+	if err != nil {
+		return types.EmptyInt, xerrors.Errorf("failed to load miner actor: %w", err)
+	}
+
+	mas, err := miner.Load(a.StateManager.ChainStore().Store(ctx), act)
+	if err != nil {
+		return types.EmptyInt, xerrors.Errorf("failed to load miner actor state: %w", err)
+	}
+
+	vested, err := mas.VestedFunds(ts.Height())
+	if err != nil {
+		return types.EmptyInt, err
+	}
+
+	abal, err := mas.AvailableBalance(act.Balance)
+	if err != nil {
+		return types.EmptyInt, err
+	}
+
+	return types.BigAdd(abal, vested), nil
+}
+
+// StateVerifiedClientStatus returns the data cap for the given address.
+// Returns zero if there is no entry in the data cap table for the
+// address.
+func (a *StateAPI) StateVerifiedClientStatus(ctx context.Context, addr address.Address, tsk types.TipSetKey) (*abi.StoragePower, error) {
+	act, err := a.StateGetActor(ctx, builtin0.VerifiedRegistryActorAddr, tsk)
+	if err != nil {
+		return nil, err
+	}
+
+	aid, err := a.StateLookupID(ctx, addr, tsk)
+	if err != nil {
+		log.Warnf("lookup failure %v", err)
+		return nil, err
+	}
+
+	vrs, err := verifreg.Load(a.StateManager.ChainStore().Store(ctx), act)
+	if err != nil {
+		return nil, xerrors.Errorf("failed to load verified registry state: %w", err)
+	}
+
+	verified, dcap, err := vrs.VerifiedClientDataCap(aid)
+	if err != nil {
+		return nil, xerrors.Errorf("looking up verified client: %w", err)
+	}
+	if !verified {
+		return nil, nil
+	}
+
+	return &dcap, nil
+}
+
+var dealProviderCollateralNum = types.NewInt(110)
+var dealProviderCollateralDen = types.NewInt(100)
+
+// StateDealProviderCollateralBounds returns the min and max collateral a storage provider
+// can issue. It takes the deal size and verified status as parameters.
+func (a *StateAPI) StateDealProviderCollateralBounds(ctx context.Context, size abi.PaddedPieceSize, verified bool, tsk types.TipSetKey) (api.DealCollateralBounds, error) {
+	ts, err := a.Chain.GetTipSetFromKey(tsk)
+	if err != nil {
+		return api.DealCollateralBounds{}, xerrors.Errorf("loading tipset %s: %w", tsk, err)
+	}
+
+	pact, err := a.StateGetActor(ctx, builtin0.StoragePowerActorAddr, tsk)
+	if err != nil {
+		return api.DealCollateralBounds{}, xerrors.Errorf("failed to load power actor: %w", err)
+	}
+
+	ract, err := a.StateGetActor(ctx, builtin0.RewardActorAddr, tsk)
+	if err != nil {
+		return api.DealCollateralBounds{}, xerrors.Errorf("failed to load reward actor: %w", err)
+	}
+
+	pst, err := power.Load(a.StateManager.ChainStore().Store(ctx), pact)
+	if err != nil {
+		return api.DealCollateralBounds{}, xerrors.Errorf("failed to load power actor state: %w", err)
+	}
+
+	rst, err := reward.Load(a.StateManager.ChainStore().Store(ctx), ract)
+	if err != nil {
+		return api.DealCollateralBounds{}, xerrors.Errorf("failed to load reward actor state: %w", err)
+	}
+
+	circ, err := a.StateCirculatingSupply(ctx, ts.Key())
+	if err != nil {
+		return api.DealCollateralBounds{}, xerrors.Errorf("getting total circulating supply: %w", err)
+	}
+
+	powClaim, err := pst.TotalPower()
+	if err != nil {
+		return api.DealCollateralBounds{}, xerrors.Errorf("getting total power: %w", err)
+	}
+
+	rewPow, err := rst.ThisEpochBaselinePower()
+	if err != nil {
+		return api.DealCollateralBounds{}, xerrors.Errorf("getting reward baseline power: %w", err)
+	}
+
+	min, max := market0.DealProviderCollateralBounds(size,
+		verified,
+		powClaim.RawBytePower,
+		powClaim.QualityAdjPower,
+		rewPow,
+		circ.FilCirculating,
+		a.StateManager.GetNtwkVersion(ctx, ts.Height()))
+	return api.DealCollateralBounds{
+		Min: types.BigDiv(types.BigMul(min, dealProviderCollateralNum), dealProviderCollateralDen),
+		Max: max,
+	}, nil
+}
+
+func (a *StateAPI) StateCirculatingSupply(ctx context.Context, tsk types.TipSetKey) (api.CirculatingSupply, error) {
+	ts, err := a.Chain.GetTipSetFromKey(tsk)
+	if err != nil {
+		return api.CirculatingSupply{}, xerrors.Errorf("loading tipset %s: %w", tsk, err)
+	}
+
+	sTree, err := a.stateForTs(ctx, ts)
+	if err != nil {
+		return api.CirculatingSupply{}, err
+	}
+	return a.StateManager.GetCirculatingSupplyDetailed(ctx, ts.Height(), sTree)
+}
+
+func (a *StateAPI) StateNetworkVersion(ctx context.Context, tsk types.TipSetKey) (network.Version, error) {
+	ts, err := a.Chain.GetTipSetFromKey(tsk)
+	if err != nil {
+		return network.VersionMax, xerrors.Errorf("loading tipset %s: %w", tsk, err)
+	}
+
+	return a.StateManager.GetNtwkVersion(ctx, ts.Height()), nil
+}
+
+func (a *StateAPI) StateMsgGasCost(ctx context.Context, inputMsg cid.Cid, tsk types.TipSetKey) (*api.MsgGasCost, error) {
+	var msg cid.Cid
+	var ts *types.TipSet
+	var err error
+	if tsk != types.EmptyTSK {
+		msg = inputMsg
+		ts, err = a.Chain.LoadTipSet(tsk)
+		if err != nil {
+			return nil, xerrors.Errorf("loading tipset %s: %w", tsk, err)
+		}
+	} else {
+		mlkp, err := a.StateSearchMsg(ctx, inputMsg)
+		if err != nil {
+			return nil, xerrors.Errorf("searching for msg %s: %w", inputMsg, err)
+		}
+		if mlkp == nil {
+			return nil, xerrors.Errorf("didn't find msg %s", inputMsg)
+		}
+
+		executionTs, err := a.Chain.GetTipSetFromKey(mlkp.TipSet)
+		if err != nil {
+			return nil, xerrors.Errorf("loading tipset %s: %w", mlkp.TipSet, err)
+		}
+
+		ts, err = a.Chain.LoadTipSet(executionTs.Parents())
+		if err != nil {
+			return nil, xerrors.Errorf("loading parent tipset %s: %w", mlkp.TipSet, err)
+		}
+
+		msg = mlkp.Message
+	}
+
+	m, r, err := a.StateManager.Replay(ctx, ts, msg)
+	if err != nil {
+		return nil, err
+	}
+
+	return &api.MsgGasCost{
+		Message:            msg,
+		GasUsed:            big.NewInt(r.GasUsed),
+		BaseFeeBurn:        r.GasCosts.BaseFeeBurn,
+		OverEstimationBurn: r.GasCosts.OverEstimationBurn,
+		MinerPenalty:       r.GasCosts.MinerPenalty,
+		MinerTip:           r.GasCosts.MinerTip,
+		Refund:             r.GasCosts.Refund,
+		TotalCost:          big.Sub(m.RequiredFunds(), r.GasCosts.Refund),
+	}, nil
+}
diff --git a/node/impl/full/sync.go b/node/impl/full/sync.go
index 250837ab3..dc3bfe230 100644
--- a/node/impl/full/sync.go
+++ b/node/impl/full/sync.go
@@ -2,31 +2,40 @@ package full
 
 import (
 	"context"
+	"sync/atomic"
 
-	"github.com/filecoin-project/lotus/api"
-	"github.com/filecoin-project/lotus/chain"
-	"github.com/filecoin-project/lotus/chain/types"
 	cid "github.com/ipfs/go-cid"
-	"github.com/prometheus/common/log"
-
 	pubsub "github.com/libp2p/go-libp2p-pubsub"
 	"go.uber.org/fx"
 	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain"
+	"github.com/filecoin-project/lotus/chain/gen/slashfilter"
+	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/chain/vm"
+	"github.com/filecoin-project/lotus/node/modules/dtypes"
 )
 
 type SyncAPI struct {
 	fx.In
 
-	Syncer *chain.Syncer
-	PubSub *pubsub.PubSub
+	SlashFilter *slashfilter.SlashFilter
+	Syncer      *chain.Syncer
+	PubSub      *pubsub.PubSub
+	NetName     dtypes.NetworkName
 }
 
 func (a *SyncAPI) SyncState(ctx context.Context) (*api.SyncState, error) {
 	states := a.Syncer.State()
 
-	out := &api.SyncState{}
+	out := &api.SyncState{
+		VMApplied: atomic.LoadUint64(&vm.StatApplied),
+	}
 
-	for _, ss := range states {
+	for i := range states {
+		ss := &states[i]
 		out.ActiveSyncs = append(out.ActiveSyncs, api.ActiveSync{
 			Base:    ss.Base,
 			Target:  ss.Target,
@@ -41,6 +50,16 @@ func (a *SyncAPI) SyncState(ctx context.Context) (*api.SyncState, error) {
 }
 
 func (a *SyncAPI) SyncSubmitBlock(ctx context.Context, blk *types.BlockMsg) error {
+	parent, err := a.Syncer.ChainStore().GetBlock(blk.Header.Parents[0])
+	if err != nil {
+		return xerrors.Errorf("loading parent block: %w", err)
+	}
+
+	if err := a.SlashFilter.MinedBlock(blk.Header, parent.Height); err != nil {
+		log.Errorf("<!!> SLASH FILTER ERROR: %s", err)
+		return xerrors.Errorf("<!!> SLASH FILTER ERROR: %w", err)
+	}
+
 	// TODO: should we have some sort of fast path to adding a local block?
 	bmsgs, err := a.Syncer.ChainStore().LoadMessagesFromCids(blk.BlsMessages)
 	if err != nil {
@@ -75,16 +94,35 @@ func (a *SyncAPI) SyncSubmitBlock(ctx context.Context, blk *types.BlockMsg) erro
 		return xerrors.Errorf("serializing block for pubsub publishing failed: %w", err)
 	}
 
-	// TODO: anything else to do here?
-	return a.PubSub.Publish("/fil/blocks", b)
+	return a.PubSub.Publish(build.BlocksTopic(a.NetName), b) //nolint:staticcheck
 }
 
 func (a *SyncAPI) SyncIncomingBlocks(ctx context.Context) (<-chan *types.BlockHeader, error) {
 	return a.Syncer.IncomingBlocks(ctx)
 }
 
+func (a *SyncAPI) SyncCheckpoint(ctx context.Context, tsk types.TipSetKey) error {
+	log.Warnf("Marking tipset %s as checkpoint", tsk)
+	return a.Syncer.SetCheckpoint(tsk)
+}
+
 func (a *SyncAPI) SyncMarkBad(ctx context.Context, bcid cid.Cid) error {
 	log.Warnf("Marking block %s as bad", bcid)
 	a.Syncer.MarkBad(bcid)
 	return nil
 }
+
+func (a *SyncAPI) SyncUnmarkBad(ctx context.Context, bcid cid.Cid) error {
+	log.Warnf("Unmarking block %s as bad", bcid)
+	a.Syncer.UnmarkBad(bcid)
+	return nil
+}
+
+func (a *SyncAPI) SyncCheckBad(ctx context.Context, bcid cid.Cid) (string, error) {
+	reason, ok := a.Syncer.CheckBadBlockCache(bcid)
+	if !ok {
+		return "", nil
+	}
+
+	return reason, nil
+}
diff --git a/node/impl/full/wallet.go b/node/impl/full/wallet.go
index b30a55f38..64231b74e 100644
--- a/node/impl/full/wallet.go
+++ b/node/impl/full/wallet.go
@@ -4,12 +4,16 @@ import (
 	"context"
 
 	"github.com/filecoin-project/go-address"
+	"go.uber.org/fx"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-state-types/big"
+	"github.com/filecoin-project/go-state-types/crypto"
+
 	"github.com/filecoin-project/lotus/chain/stmgr"
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/chain/wallet"
-
-	"go.uber.org/fx"
-	"golang.org/x/xerrors"
+	"github.com/filecoin-project/lotus/lib/sigs"
 )
 
 type WalletAPI struct {
@@ -19,7 +23,7 @@ type WalletAPI struct {
 	Wallet       *wallet.Wallet
 }
 
-func (a *WalletAPI) WalletNew(ctx context.Context, typ string) (address.Address, error) {
+func (a *WalletAPI) WalletNew(ctx context.Context, typ crypto.SigType) (address.Address, error) {
 	return a.Wallet.GenerateKey(typ)
 }
 
@@ -32,11 +36,21 @@ func (a *WalletAPI) WalletList(ctx context.Context) ([]address.Address, error) {
 }
 
 func (a *WalletAPI) WalletBalance(ctx context.Context, addr address.Address) (types.BigInt, error) {
-	return a.StateManager.GetBalance(addr, nil)
+	act, err := a.StateManager.LoadActorTsk(ctx, addr, types.EmptyTSK)
+	if xerrors.Is(err, types.ErrActorNotFound) {
+		return big.Zero(), nil
+	} else if err != nil {
+		return big.Zero(), err
+	}
+	return act.Balance, nil
 }
 
-func (a *WalletAPI) WalletSign(ctx context.Context, k address.Address, msg []byte) (*types.Signature, error) {
-	return a.Wallet.Sign(ctx, k, msg)
+func (a *WalletAPI) WalletSign(ctx context.Context, k address.Address, msg []byte) (*crypto.Signature, error) {
+	keyAddr, err := a.StateManager.ResolveToKeyAddress(ctx, k, nil)
+	if err != nil {
+		return nil, xerrors.Errorf("failed to resolve ID address: %w", keyAddr)
+	}
+	return a.Wallet.Sign(ctx, keyAddr, msg)
 }
 
 func (a *WalletAPI) WalletSignMessage(ctx context.Context, k address.Address, msg *types.Message) (*types.SignedMessage, error) {
@@ -53,6 +67,10 @@ func (a *WalletAPI) WalletSignMessage(ctx context.Context, k address.Address, ms
 	}, nil
 }
 
+func (a *WalletAPI) WalletVerify(ctx context.Context, k address.Address, msg []byte, sig *crypto.Signature) (bool, error) {
+	return sigs.Verify(sig, k, msg) == nil, nil
+}
+
 func (a *WalletAPI) WalletDefaultAddress(ctx context.Context) (address.Address, error) {
 	return a.Wallet.GetDefault()
 }
@@ -68,3 +86,7 @@ func (a *WalletAPI) WalletExport(ctx context.Context, addr address.Address) (*ty
 func (a *WalletAPI) WalletImport(ctx context.Context, ki *types.KeyInfo) (address.Address, error) {
 	return a.Wallet.Import(ki)
 }
+
+func (a *WalletAPI) WalletDelete(ctx context.Context, addr address.Address) error {
+	return a.Wallet.DeleteKey(addr)
+}
diff --git a/node/impl/market/market.go b/node/impl/market/market.go
index fceb75781..26d4a9edc 100644
--- a/node/impl/market/market.go
+++ b/node/impl/market/market.go
@@ -8,6 +8,7 @@ import (
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/lotus/chain/market"
 	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/ipfs/go-cid"
 )
 
 type MarketAPI struct {
@@ -16,6 +17,6 @@ type MarketAPI struct {
 	FMgr *market.FundMgr
 }
 
-func (a *MarketAPI) MarketEnsureAvailable(ctx context.Context, addr address.Address, amt types.BigInt) error {
-	return a.FMgr.EnsureAvailable(ctx, addr, amt)
+func (a *MarketAPI) MarketEnsureAvailable(ctx context.Context, addr, wallet address.Address, amt types.BigInt) (cid.Cid, error) {
+	return a.FMgr.EnsureAvailable(ctx, addr, wallet, amt)
 }
diff --git a/node/impl/paych/paych.go b/node/impl/paych/paych.go
index 92ffdd9f5..af0a1db15 100644
--- a/node/impl/paych/paych.go
+++ b/node/impl/paych/paych.go
@@ -2,18 +2,19 @@ package paych
 
 import (
 	"context"
-	"fmt"
+
+	"golang.org/x/xerrors"
 
 	"github.com/ipfs/go-cid"
 	"go.uber.org/fx"
-	"golang.org/x/xerrors"
 
 	"github.com/filecoin-project/go-address"
+
 	"github.com/filecoin-project/lotus/api"
-	"github.com/filecoin-project/lotus/chain/actors"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/paych"
 	"github.com/filecoin-project/lotus/chain/types"
 	full "github.com/filecoin-project/lotus/node/impl/full"
-	"github.com/filecoin-project/lotus/paych"
+	"github.com/filecoin-project/lotus/paychmgr"
 )
 
 type PaychAPI struct {
@@ -23,21 +24,33 @@ type PaychAPI struct {
 	full.WalletAPI
 	full.ChainAPI
 
-	PaychMgr *paych.Manager
+	PaychMgr *paychmgr.Manager
 }
 
-func (a *PaychAPI) PaychGet(ctx context.Context, from, to address.Address, ensureFunds types.BigInt) (*api.ChannelInfo, error) {
-	ch, mcid, err := a.PaychMgr.GetPaych(ctx, from, to, ensureFunds)
+func (a *PaychAPI) PaychGet(ctx context.Context, from, to address.Address, amt types.BigInt) (*api.ChannelInfo, error) {
+	ch, mcid, err := a.PaychMgr.GetPaych(ctx, from, to, amt)
 	if err != nil {
 		return nil, err
 	}
 
 	return &api.ChannelInfo{
-		Channel:        ch,
-		ChannelMessage: mcid,
+		Channel:      ch,
+		WaitSentinel: mcid,
 	}, nil
 }
 
+func (a *PaychAPI) PaychAvailableFunds(ctx context.Context, ch address.Address) (*api.ChannelAvailableFunds, error) {
+	return a.PaychMgr.AvailableFunds(ch)
+}
+
+func (a *PaychAPI) PaychAvailableFundsByFromTo(ctx context.Context, from, to address.Address) (*api.ChannelAvailableFunds, error) {
+	return a.PaychMgr.AvailableFundsByFromTo(from, to)
+}
+
+func (a *PaychAPI) PaychGetWaitReady(ctx context.Context, sentinel cid.Cid) (address.Address, error) {
+	return a.PaychMgr.GetPaychWaitReady(ctx, sentinel)
+}
+
 func (a *PaychAPI) PaychAllocateLane(ctx context.Context, ch address.Address) (uint64, error) {
 	return a.PaychMgr.AllocateLane(ch)
 }
@@ -57,33 +70,32 @@ func (a *PaychAPI) PaychNewPayment(ctx context.Context, from, to address.Address
 		return nil, err
 	}
 
-	svs := make([]*types.SignedVoucher, len(vouchers))
+	svs := make([]*paych.SignedVoucher, len(vouchers))
 
 	for i, v := range vouchers {
-		sv, err := a.paychVoucherCreate(ctx, ch.Channel, types.SignedVoucher{
+		sv, err := a.PaychMgr.CreateVoucher(ctx, ch.Channel, paych.SignedVoucher{
 			Amount: v.Amount,
 			Lane:   lane,
 
-			Extra:          v.Extra,
-			TimeLock:       v.TimeLock,
-			MinCloseHeight: v.MinClose,
+			Extra:           v.Extra,
+			TimeLockMin:     v.TimeLockMin,
+			TimeLockMax:     v.TimeLockMax,
+			MinSettleHeight: v.MinSettle,
 		})
 		if err != nil {
 			return nil, err
 		}
+		if sv.Voucher == nil {
+			return nil, xerrors.Errorf("Could not create voucher - shortfall of %d", sv.Shortfall)
+		}
 
-		svs[i] = sv
-	}
-
-	var pchCid *cid.Cid
-	if ch.ChannelMessage != cid.Undef {
-		pchCid = &ch.ChannelMessage
+		svs[i] = sv.Voucher
 	}
 
 	return &api.PaymentInfo{
-		Channel:        ch.Channel,
-		ChannelMessage: pchCid,
-		Vouchers:       svs,
+		Channel:      ch.Channel,
+		WaitSentinel: ch.WaitSentinel,
+		Vouchers:     svs,
 	}, nil
 }
 
@@ -102,52 +114,24 @@ func (a *PaychAPI) PaychStatus(ctx context.Context, pch address.Address) (*api.P
 	}, nil
 }
 
-func (a *PaychAPI) PaychClose(ctx context.Context, addr address.Address) (cid.Cid, error) {
-	ci, err := a.PaychMgr.GetChannelInfo(addr)
-	if err != nil {
-		return cid.Undef, err
-	}
-
-	nonce, err := a.MpoolGetNonce(ctx, ci.Control)
-	if err != nil {
-		return cid.Undef, err
-	}
-
-	msg := &types.Message{
-		To:     addr,
-		From:   ci.Control,
-		Value:  types.NewInt(0),
-		Method: actors.PCAMethods.Close,
-		Nonce:  nonce,
-
-		GasLimit: types.NewInt(500),
-		GasPrice: types.NewInt(0),
-	}
-
-	smsg, err := a.WalletSignMessage(ctx, ci.Control, msg)
-	if err != nil {
-		return cid.Undef, err
-	}
-
-	if _, err := a.MpoolPush(ctx, smsg); err != nil {
-		return cid.Undef, err
-	}
-
-	return smsg.Cid(), nil
+func (a *PaychAPI) PaychSettle(ctx context.Context, addr address.Address) (cid.Cid, error) {
+	return a.PaychMgr.Settle(ctx, addr)
 }
 
-func (a *PaychAPI) PaychVoucherCheckValid(ctx context.Context, ch address.Address, sv *types.SignedVoucher) error {
+func (a *PaychAPI) PaychCollect(ctx context.Context, addr address.Address) (cid.Cid, error) {
+	return a.PaychMgr.Collect(ctx, addr)
+}
+
+func (a *PaychAPI) PaychVoucherCheckValid(ctx context.Context, ch address.Address, sv *paych.SignedVoucher) error {
 	return a.PaychMgr.CheckVoucherValid(ctx, ch, sv)
 }
 
-func (a *PaychAPI) PaychVoucherCheckSpendable(ctx context.Context, ch address.Address, sv *types.SignedVoucher, secret []byte, proof []byte) (bool, error) {
+func (a *PaychAPI) PaychVoucherCheckSpendable(ctx context.Context, ch address.Address, sv *paych.SignedVoucher, secret []byte, proof []byte) (bool, error) {
 	return a.PaychMgr.CheckVoucherSpendable(ctx, ch, sv, secret, proof)
 }
 
-func (a *PaychAPI) PaychVoucherAdd(ctx context.Context, ch address.Address, sv *types.SignedVoucher, proof []byte, minDelta types.BigInt) (types.BigInt, error) {
-	_ = a.PaychMgr.TrackInboundChannel(ctx, ch) // TODO: expose those calls
-
-	return a.PaychMgr.AddVoucher(ctx, ch, sv, proof, minDelta)
+func (a *PaychAPI) PaychVoucherAdd(ctx context.Context, ch address.Address, sv *paych.SignedVoucher, proof []byte, minDelta types.BigInt) (types.BigInt, error) {
+	return a.PaychMgr.AddVoucherInbound(ctx, ch, sv, proof, minDelta)
 }
 
 // PaychVoucherCreate creates a new signed voucher on the given payment channel
@@ -155,50 +139,19 @@ func (a *PaychAPI) PaychVoucherAdd(ctx context.Context, ch address.Address, sv *
 // that will be used to create the voucher, so if previous vouchers exist, the
 // actual additional value of this voucher will only be the difference between
 // the two.
-func (a *PaychAPI) PaychVoucherCreate(ctx context.Context, pch address.Address, amt types.BigInt, lane uint64) (*types.SignedVoucher, error) {
-	return a.paychVoucherCreate(ctx, pch, types.SignedVoucher{Amount: amt, Lane: lane})
+// If there are insufficient funds in the channel to create the voucher,
+// returns a nil voucher and the shortfall.
+func (a *PaychAPI) PaychVoucherCreate(ctx context.Context, pch address.Address, amt types.BigInt, lane uint64) (*api.VoucherCreateResult, error) {
+	return a.PaychMgr.CreateVoucher(ctx, pch, paych.SignedVoucher{Amount: amt, Lane: lane})
 }
 
-func (a *PaychAPI) paychVoucherCreate(ctx context.Context, pch address.Address, voucher types.SignedVoucher) (*types.SignedVoucher, error) {
-	ci, err := a.PaychMgr.GetChannelInfo(pch)
-	if err != nil {
-		return nil, xerrors.Errorf("get channel info: %w", err)
-	}
-
-	nonce, err := a.PaychMgr.NextNonceForLane(ctx, pch, voucher.Lane)
-	if err != nil {
-		return nil, xerrors.Errorf("getting next nonce for lane: %w", err)
-	}
-
-	sv := &voucher
-	sv.Nonce = nonce
-
-	vb, err := sv.SigningBytes()
-	if err != nil {
-		return nil, err
-	}
-
-	sig, err := a.WalletSign(ctx, ci.Control, vb)
-	if err != nil {
-		return nil, err
-	}
-
-	sv.Signature = sig
-
-	if _, err := a.PaychMgr.AddVoucher(ctx, pch, sv, nil, types.NewInt(0)); err != nil {
-		return nil, xerrors.Errorf("failed to persist voucher: %w", err)
-	}
-
-	return sv, nil
-}
-
-func (a *PaychAPI) PaychVoucherList(ctx context.Context, pch address.Address) ([]*types.SignedVoucher, error) {
+func (a *PaychAPI) PaychVoucherList(ctx context.Context, pch address.Address) ([]*paych.SignedVoucher, error) {
 	vi, err := a.PaychMgr.ListVouchers(ctx, pch)
 	if err != nil {
 		return nil, err
 	}
 
-	out := make([]*types.SignedVoucher, len(vi))
+	out := make([]*paych.SignedVoucher, len(vi))
 	for k, v := range vi {
 		out[k] = v.Voucher
 	}
@@ -206,48 +159,6 @@ func (a *PaychAPI) PaychVoucherList(ctx context.Context, pch address.Address) ([
 	return out, nil
 }
 
-func (a *PaychAPI) PaychVoucherSubmit(ctx context.Context, ch address.Address, sv *types.SignedVoucher) (cid.Cid, error) {
-	ci, err := a.PaychMgr.GetChannelInfo(ch)
-	if err != nil {
-		return cid.Undef, err
-	}
-
-	nonce, err := a.MpoolGetNonce(ctx, ci.Control)
-	if err != nil {
-		return cid.Undef, err
-	}
-
-	if sv.Extra != nil || len(sv.SecretPreimage) > 0 {
-		return cid.Undef, fmt.Errorf("cant handle more advanced payment channel stuff yet")
-	}
-
-	enc, err := actors.SerializeParams(&actors.PCAUpdateChannelStateParams{
-		Sv: *sv,
-	})
-	if err != nil {
-		return cid.Undef, err
-	}
-
-	msg := &types.Message{
-		From:     ci.Control,
-		To:       ch,
-		Value:    types.NewInt(0),
-		Nonce:    nonce,
-		Method:   actors.PCAMethods.UpdateChannelState,
-		Params:   enc,
-		GasLimit: types.NewInt(100000),
-		GasPrice: types.NewInt(0),
-	}
-
-	smsg, err := a.WalletSignMessage(ctx, ci.Control, msg)
-	if err != nil {
-		return cid.Undef, err
-	}
-
-	if _, err := a.MpoolPush(ctx, smsg); err != nil {
-		return cid.Undef, err
-	}
-
-	// TODO: should we wait for it...?
-	return smsg.Cid(), nil
+func (a *PaychAPI) PaychVoucherSubmit(ctx context.Context, ch address.Address, sv *paych.SignedVoucher, secret []byte, proof []byte) (cid.Cid, error) {
+	return a.PaychMgr.SubmitVoucher(ctx, ch, sv, secret, proof)
 }
diff --git a/node/impl/remoteworker.go b/node/impl/remoteworker.go
new file mode 100644
index 000000000..b6ef43c7c
--- /dev/null
+++ b/node/impl/remoteworker.go
@@ -0,0 +1,49 @@
+package impl
+
+import (
+	"context"
+	"net/http"
+
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-jsonrpc"
+	"github.com/filecoin-project/go-jsonrpc/auth"
+	"github.com/filecoin-project/go-state-types/abi"
+
+	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/api/client"
+	sectorstorage "github.com/filecoin-project/lotus/extern/sector-storage"
+)
+
+type remoteWorker struct {
+	api.WorkerAPI
+	closer jsonrpc.ClientCloser
+}
+
+func (r *remoteWorker) NewSector(ctx context.Context, sector abi.SectorID) error {
+	return xerrors.New("unsupported")
+}
+
+func connectRemoteWorker(ctx context.Context, fa api.Common, url string) (*remoteWorker, error) {
+	token, err := fa.AuthNew(ctx, []auth.Permission{"admin"})
+	if err != nil {
+		return nil, xerrors.Errorf("creating auth token for remote connection: %w", err)
+	}
+
+	headers := http.Header{}
+	headers.Add("Authorization", "Bearer "+string(token))
+
+	wapi, closer, err := client.NewWorkerRPC(context.TODO(), url, headers)
+	if err != nil {
+		return nil, xerrors.Errorf("creating jsonrpc client: %w", err)
+	}
+
+	return &remoteWorker{wapi, closer}, nil
+}
+
+func (r *remoteWorker) Close() error {
+	r.closer()
+	return nil
+}
+
+var _ sectorstorage.Worker = &remoteWorker{}
diff --git a/node/impl/storminer.go b/node/impl/storminer.go
index 5568ed529..5634c140b 100644
--- a/node/impl/storminer.go
+++ b/node/impl/storminer.go
@@ -3,191 +3,220 @@ package impl
 import (
 	"context"
 	"encoding/json"
-	"github.com/filecoin-project/lotus/api/apistruct"
-	"io"
-	"mime"
 	"net/http"
 	"os"
+	"strconv"
+	"time"
 
-	"github.com/gorilla/mux"
-	files "github.com/ipfs/go-ipfs-files"
+	datatransfer "github.com/filecoin-project/go-data-transfer"
+	"github.com/filecoin-project/go-state-types/big"
+	"github.com/ipfs/go-cid"
+	"github.com/libp2p/go-libp2p-core/host"
+	"golang.org/x/xerrors"
 
 	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-sectorbuilder"
+	"github.com/filecoin-project/go-fil-markets/piecestore"
+	retrievalmarket "github.com/filecoin-project/go-fil-markets/retrievalmarket"
+	storagemarket "github.com/filecoin-project/go-fil-markets/storagemarket"
+	"github.com/filecoin-project/go-jsonrpc/auth"
+	"github.com/filecoin-project/go-state-types/abi"
+
+	sectorstorage "github.com/filecoin-project/lotus/extern/sector-storage"
+	"github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper"
+	"github.com/filecoin-project/lotus/extern/sector-storage/fsutil"
+	"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/api"
-	"github.com/filecoin-project/lotus/lib/tarutil"
+	"github.com/filecoin-project/lotus/api/apistruct"
+	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/miner"
+	"github.com/filecoin-project/lotus/node/impl/common"
+	"github.com/filecoin-project/lotus/node/modules/dtypes"
 	"github.com/filecoin-project/lotus/storage"
 	"github.com/filecoin-project/lotus/storage/sectorblocks"
 )
 
 type StorageMinerAPI struct {
-	CommonAPI
+	common.CommonAPI
 
-	SectorBuilderConfig *sectorbuilder.Config
-	SectorBuilder       *sectorbuilder.SectorBuilder
-	SectorBlocks        *sectorblocks.SectorBlocks
+	ProofsConfig *ffiwrapper.Config
+	SectorBlocks *sectorblocks.SectorBlocks
 
-	Miner      *storage.Miner
-	BlockMiner *miner.Miner
-	Full       api.FullNode
+	PieceStore        dtypes.ProviderPieceStore
+	StorageProvider   storagemarket.StorageProvider
+	RetrievalProvider retrievalmarket.RetrievalProvider
+	Miner             *storage.Miner
+	BlockMiner        *miner.Miner
+	Full              api.FullNode
+	StorageMgr        *sectorstorage.Manager `optional:"true"`
+	IStorageMgr       sectorstorage.SectorManager
+	*stores.Index
+	DataTransfer dtypes.ProviderDataTransfer
+	Host         host.Host
+
+	ConsiderOnlineStorageDealsConfigFunc       dtypes.ConsiderOnlineStorageDealsConfigFunc
+	SetConsiderOnlineStorageDealsConfigFunc    dtypes.SetConsiderOnlineStorageDealsConfigFunc
+	ConsiderOnlineRetrievalDealsConfigFunc     dtypes.ConsiderOnlineRetrievalDealsConfigFunc
+	SetConsiderOnlineRetrievalDealsConfigFunc  dtypes.SetConsiderOnlineRetrievalDealsConfigFunc
+	StorageDealPieceCidBlocklistConfigFunc     dtypes.StorageDealPieceCidBlocklistConfigFunc
+	SetStorageDealPieceCidBlocklistConfigFunc  dtypes.SetStorageDealPieceCidBlocklistConfigFunc
+	ConsiderOfflineStorageDealsConfigFunc      dtypes.ConsiderOfflineStorageDealsConfigFunc
+	SetConsiderOfflineStorageDealsConfigFunc   dtypes.SetConsiderOfflineStorageDealsConfigFunc
+	ConsiderOfflineRetrievalDealsConfigFunc    dtypes.ConsiderOfflineRetrievalDealsConfigFunc
+	SetConsiderOfflineRetrievalDealsConfigFunc dtypes.SetConsiderOfflineRetrievalDealsConfigFunc
+	SetSealingConfigFunc                       dtypes.SetSealingConfigFunc
+	GetSealingConfigFunc                       dtypes.GetSealingConfigFunc
+	GetExpectedSealDurationFunc                dtypes.GetExpectedSealDurationFunc
+	SetExpectedSealDurationFunc                dtypes.SetExpectedSealDurationFunc
 }
 
 func (sm *StorageMinerAPI) ServeRemote(w http.ResponseWriter, r *http.Request) {
-	if !apistruct.HasPerm(r.Context(), apistruct.PermAdmin) {
+	if !auth.HasPerm(r.Context(), nil, apistruct.PermAdmin) {
 		w.WriteHeader(401)
-		json.NewEncoder(w).Encode(struct{ Error string }{"unauthorized: missing write permission"})
+		_ = json.NewEncoder(w).Encode(struct{ Error string }{"unauthorized: missing write permission"})
 		return
 	}
 
-	mux := mux.NewRouter()
-
-	mux.HandleFunc("/remote/{type}/{sname}", sm.remoteGetSector).Methods("GET")
-	mux.HandleFunc("/remote/{type}/{sname}", sm.remotePutSector).Methods("PUT")
-
-	log.Infof("SERVEGETREMOTE %s", r.URL)
-
-	mux.ServeHTTP(w, r)
+	sm.StorageMgr.ServeHTTP(w, r)
 }
 
-func (sm *StorageMinerAPI) remoteGetSector(w http.ResponseWriter, r *http.Request) {
-	vars := mux.Vars(r)
-
-	path, err := sm.SectorBuilder.GetPath(vars["type"], vars["sname"])
-	if err != nil {
-		log.Error(err)
-		w.WriteHeader(500)
-		return
-	}
-
-	stat, err := os.Stat(path)
-	if err != nil {
-		log.Error(err)
-		w.WriteHeader(500)
-		return
-	}
-
-	var rd io.Reader
-	if stat.IsDir() {
-		rd, err = tarutil.TarDirectory(path)
-		w.Header().Set("Content-Type", "application/x-tar")
-	} else {
-		rd, err = os.OpenFile(path, os.O_RDONLY, 0644)
-		w.Header().Set("Content-Type", "application/octet-stream")
-	}
-	if err != nil {
-		log.Error(err)
-		w.WriteHeader(500)
-		return
-	}
-
-	w.WriteHeader(200)
-	if _, err := io.Copy(w, rd); err != nil {
-		log.Error(err)
-		return
-	}
+func (sm *StorageMinerAPI) WorkerStats(context.Context) (map[uint64]storiface.WorkerStats, error) {
+	return sm.StorageMgr.WorkerStats(), nil
 }
 
-func (sm *StorageMinerAPI) remotePutSector(w http.ResponseWriter, r *http.Request) {
-	vars := mux.Vars(r)
-
-	path, err := sm.SectorBuilder.GetPath(vars["type"], vars["sname"])
-	if err != nil {
-		log.Error(err)
-		w.WriteHeader(500)
-		return
-	}
-
-	mediatype, _, err := mime.ParseMediaType(r.Header.Get("Content-Type"))
-	if err != nil {
-		log.Error(err)
-		w.WriteHeader(500)
-		return
-	}
-
-	if err := os.RemoveAll(path); err != nil {
-		log.Error(err)
-		w.WriteHeader(500)
-		return
-	}
-
-	switch mediatype {
-	case "application/x-tar":
-		if err := tarutil.ExtractTar(r.Body, path); err != nil {
-			log.Error(err)
-			w.WriteHeader(500)
-			return
-		}
-	default:
-		if err := files.WriteTo(files.NewReaderFile(r.Body), path); err != nil {
-			log.Error(err)
-			w.WriteHeader(500)
-			return
-		}
-	}
-
-	w.WriteHeader(200)
-
-	log.Infof("received %s sector (%s): %d bytes", vars["type"], vars["sname"], r.ContentLength)
-}
-
-func (sm *StorageMinerAPI) WorkerStats(context.Context) (sectorbuilder.WorkerStats, error) {
-	stat := sm.SectorBuilder.WorkerStats()
-	return stat, nil
+func (sm *StorageMinerAPI) WorkerJobs(ctx context.Context) (map[uint64][]storiface.WorkerJob, error) {
+	return sm.StorageMgr.WorkerJobs(), nil
 }
 
 func (sm *StorageMinerAPI) ActorAddress(context.Context) (address.Address, error) {
-	return sm.SectorBuilderConfig.Miner, nil
+	return sm.Miner.Address(), nil
 }
 
-func (sm *StorageMinerAPI) ActorSectorSize(ctx context.Context, addr address.Address) (uint64, error) {
-	return sm.Full.StateMinerSectorSize(ctx, addr, nil)
+func (sm *StorageMinerAPI) MiningBase(ctx context.Context) (*types.TipSet, error) {
+	mb, err := sm.BlockMiner.GetBestMiningCandidate(ctx)
+	if err != nil {
+		return nil, err
+	}
+	return mb.TipSet, nil
+}
+
+func (sm *StorageMinerAPI) ActorSectorSize(ctx context.Context, addr address.Address) (abi.SectorSize, error) {
+	mi, err := sm.Full.StateMinerInfo(ctx, addr, types.EmptyTSK)
+	if err != nil {
+		return 0, err
+	}
+	return mi.SectorSize, nil
 }
 
 func (sm *StorageMinerAPI) PledgeSector(ctx context.Context) error {
 	return sm.Miner.PledgeSector()
 }
 
-func (sm *StorageMinerAPI) SectorsStatus(ctx context.Context, sid uint64) (api.SectorInfo, error) {
+func (sm *StorageMinerAPI) SectorsStatus(ctx context.Context, sid abi.SectorNumber, showOnChainInfo bool) (api.SectorInfo, error) {
 	info, err := sm.Miner.GetSectorInfo(sid)
 	if err != nil {
 		return api.SectorInfo{}, err
 	}
 
-	deals := make([]uint64, len(info.Pieces))
+	deals := make([]abi.DealID, len(info.Pieces))
 	for i, piece := range info.Pieces {
-		deals[i] = piece.DealID
+		if piece.DealInfo == nil {
+			continue
+		}
+		deals[i] = piece.DealInfo.DealID
 	}
 
-	return api.SectorInfo{
+	log := make([]api.SectorLog, len(info.Log))
+	for i, l := range info.Log {
+		log[i] = api.SectorLog{
+			Kind:      l.Kind,
+			Timestamp: l.Timestamp,
+			Trace:     l.Trace,
+			Message:   l.Message,
+		}
+	}
+
+	sInfo := api.SectorInfo{
 		SectorID: sid,
-		State:    info.State,
+		State:    api.SectorState(info.State),
 		CommD:    info.CommD,
 		CommR:    info.CommR,
 		Proof:    info.Proof,
 		Deals:    deals,
-		Ticket:   info.Ticket.SB(),
-		Seed:     info.Seed.SB(),
-		Retries:  info.Nonce,
+		Ticket: api.SealTicket{
+			Value: info.TicketValue,
+			Epoch: info.TicketEpoch,
+		},
+		Seed: api.SealSeed{
+			Value: info.SeedValue,
+			Epoch: info.SeedEpoch,
+		},
+		PreCommitMsg: info.PreCommitMessage,
+		CommitMsg:    info.CommitMessage,
+		Retries:      info.InvalidProofs,
+		ToUpgrade:    sm.Miner.IsMarkedForUpgrade(sid),
 
 		LastErr: info.LastErr,
-	}, nil
+		Log:     log,
+		// on chain info
+		SealProof:          0,
+		Activation:         0,
+		Expiration:         0,
+		DealWeight:         big.Zero(),
+		VerifiedDealWeight: big.Zero(),
+		InitialPledge:      big.Zero(),
+		OnTime:             0,
+		Early:              0,
+	}
+
+	if !showOnChainInfo {
+		return sInfo, nil
+	}
+
+	onChainInfo, err := sm.Full.StateSectorGetInfo(ctx, sm.Miner.Address(), sid, types.EmptyTSK)
+	if err != nil {
+		return sInfo, err
+	}
+	if onChainInfo == nil {
+		return sInfo, nil
+	}
+	sInfo.SealProof = onChainInfo.SealProof
+	sInfo.Activation = onChainInfo.Activation
+	sInfo.Expiration = onChainInfo.Expiration
+	sInfo.DealWeight = onChainInfo.DealWeight
+	sInfo.VerifiedDealWeight = onChainInfo.VerifiedDealWeight
+	sInfo.InitialPledge = onChainInfo.InitialPledge
+
+	ex, err := sm.Full.StateSectorExpiration(ctx, sm.Miner.Address(), sid, types.EmptyTSK)
+	if err != nil {
+		return sInfo, nil
+	}
+	sInfo.OnTime = ex.OnTime
+	sInfo.Early = ex.Early
+
+	return sInfo, nil
 }
 
 // List all staged sectors
-func (sm *StorageMinerAPI) SectorsList(context.Context) ([]uint64, error) {
+func (sm *StorageMinerAPI) SectorsList(context.Context) ([]abi.SectorNumber, error) {
 	sectors, err := sm.Miner.ListSectors()
 	if err != nil {
 		return nil, err
 	}
 
-	out := make([]uint64, len(sectors))
+	out := make([]abi.SectorNumber, len(sectors))
 	for i, sector := range sectors {
-		out[i] = sector.SectorID
+		out[i] = sector.SectorNumber
 	}
 	return out, nil
 }
 
+func (sm *StorageMinerAPI) StorageLocal(ctx context.Context) (map[stores.ID]string, error) {
+	return sm.StorageMgr.StorageLocal(ctx)
+}
+
 func (sm *StorageMinerAPI) SectorsRefs(context.Context) (map[string][]api.SealedRef, error) {
 	// json can't handle cids as map keys
 	out := map[string][]api.SealedRef{}
@@ -198,22 +227,293 @@ func (sm *StorageMinerAPI) SectorsRefs(context.Context) (map[string][]api.Sealed
 	}
 
 	for k, v := range refs {
-		out[k.String()] = v
+		out[strconv.FormatUint(k, 10)] = v
 	}
 
 	return out, nil
 }
 
-func (sm *StorageMinerAPI) SectorsUpdate(ctx context.Context, id uint64, state api.SectorState) error {
-	return sm.Miner.UpdateSectorState(ctx, id, storage.NonceIncrement, state)
+func (sm *StorageMinerAPI) StorageStat(ctx context.Context, id stores.ID) (fsutil.FsStat, error) {
+	return sm.StorageMgr.FsStat(ctx, id)
 }
 
-func (sm *StorageMinerAPI) WorkerQueue(ctx context.Context, cfg sectorbuilder.WorkerCfg) (<-chan sectorbuilder.WorkerTask, error) {
-	return sm.SectorBuilder.AddWorker(ctx, cfg)
+func (sm *StorageMinerAPI) SectorStartSealing(ctx context.Context, number abi.SectorNumber) error {
+	return sm.Miner.StartPackingSector(number)
 }
 
-func (sm *StorageMinerAPI) WorkerDone(ctx context.Context, task uint64, res sectorbuilder.SealRes) error {
-	return sm.SectorBuilder.TaskDone(ctx, task, res)
+func (sm *StorageMinerAPI) SectorSetSealDelay(ctx context.Context, delay time.Duration) error {
+	cfg, err := sm.GetSealingConfigFunc()
+	if err != nil {
+		return xerrors.Errorf("get config: %w", err)
+	}
+
+	cfg.WaitDealsDelay = delay
+
+	return sm.SetSealingConfigFunc(cfg)
+}
+
+func (sm *StorageMinerAPI) SectorGetSealDelay(ctx context.Context) (time.Duration, error) {
+	cfg, err := sm.GetSealingConfigFunc()
+	if err != nil {
+		return 0, err
+	}
+	return cfg.WaitDealsDelay, nil
+}
+
+func (sm *StorageMinerAPI) SectorSetExpectedSealDuration(ctx context.Context, delay time.Duration) error {
+	return sm.SetExpectedSealDurationFunc(delay)
+}
+
+func (sm *StorageMinerAPI) SectorGetExpectedSealDuration(ctx context.Context) (time.Duration, error) {
+	return sm.GetExpectedSealDurationFunc()
+}
+
+func (sm *StorageMinerAPI) SectorsUpdate(ctx context.Context, id abi.SectorNumber, state api.SectorState) error {
+	return sm.Miner.ForceSectorState(ctx, id, sealing.SectorState(state))
+}
+
+func (sm *StorageMinerAPI) SectorRemove(ctx context.Context, id abi.SectorNumber) error {
+	return sm.Miner.RemoveSector(ctx, id)
+}
+
+func (sm *StorageMinerAPI) SectorMarkForUpgrade(ctx context.Context, id abi.SectorNumber) error {
+	return sm.Miner.MarkForUpgrade(id)
+}
+
+func (sm *StorageMinerAPI) WorkerConnect(ctx context.Context, url string) error {
+	w, err := connectRemoteWorker(ctx, sm, url)
+	if err != nil {
+		return xerrors.Errorf("connecting remote storage failed: %w", err)
+	}
+
+	log.Infof("Connected to a remote worker at %s", url)
+
+	return sm.StorageMgr.AddWorker(ctx, w)
+}
+
+func (sm *StorageMinerAPI) SealingSchedDiag(ctx context.Context) (interface{}, error) {
+	return sm.StorageMgr.SchedDiag(ctx)
+}
+
+func (sm *StorageMinerAPI) MarketImportDealData(ctx context.Context, propCid cid.Cid, path string) error {
+	fi, err := os.Open(path)
+	if err != nil {
+		return xerrors.Errorf("failed to open file: %w", err)
+	}
+	defer fi.Close() //nolint:errcheck
+
+	return sm.StorageProvider.ImportDataForDeal(ctx, propCid, fi)
+}
+
+func (sm *StorageMinerAPI) listDeals(ctx context.Context) ([]api.MarketDeal, error) {
+	ts, err := sm.Full.ChainHead(ctx)
+	if err != nil {
+		return nil, err
+	}
+	tsk := ts.Key()
+	allDeals, err := sm.Full.StateMarketDeals(ctx, tsk)
+	if err != nil {
+		return nil, err
+	}
+
+	var out []api.MarketDeal
+
+	for _, deal := range allDeals {
+		if deal.Proposal.Provider == sm.Miner.Address() {
+			out = append(out, deal)
+		}
+	}
+
+	return out, nil
+}
+
+func (sm *StorageMinerAPI) MarketListDeals(ctx context.Context) ([]api.MarketDeal, error) {
+	return sm.listDeals(ctx)
+}
+
+func (sm *StorageMinerAPI) MarketListRetrievalDeals(ctx context.Context) ([]retrievalmarket.ProviderDealState, error) {
+	var out []retrievalmarket.ProviderDealState
+	deals := sm.RetrievalProvider.ListDeals()
+
+	for _, deal := range deals {
+		out = append(out, deal)
+	}
+
+	return out, nil
+}
+
+func (sm *StorageMinerAPI) MarketGetDealUpdates(ctx context.Context) (<-chan storagemarket.MinerDeal, error) {
+	results := make(chan storagemarket.MinerDeal)
+	unsub := sm.StorageProvider.SubscribeToEvents(func(evt storagemarket.ProviderEvent, deal storagemarket.MinerDeal) {
+		select {
+		case results <- deal:
+		case <-ctx.Done():
+		}
+	})
+	go func() {
+		<-ctx.Done()
+		unsub()
+		close(results)
+	}()
+	return results, nil
+}
+
+func (sm *StorageMinerAPI) MarketListIncompleteDeals(ctx context.Context) ([]storagemarket.MinerDeal, error) {
+	return sm.StorageProvider.ListLocalDeals()
+}
+
+func (sm *StorageMinerAPI) MarketSetAsk(ctx context.Context, price types.BigInt, verifiedPrice types.BigInt, duration abi.ChainEpoch, minPieceSize abi.PaddedPieceSize, maxPieceSize abi.PaddedPieceSize) error {
+	options := []storagemarket.StorageAskOption{
+		storagemarket.MinPieceSize(minPieceSize),
+		storagemarket.MaxPieceSize(maxPieceSize),
+	}
+
+	return sm.StorageProvider.SetAsk(price, verifiedPrice, duration, options...)
+}
+
+func (sm *StorageMinerAPI) MarketGetAsk(ctx context.Context) (*storagemarket.SignedStorageAsk, error) {
+	return sm.StorageProvider.GetAsk(), nil
+}
+
+func (sm *StorageMinerAPI) MarketSetRetrievalAsk(ctx context.Context, rask *retrievalmarket.Ask) error {
+	sm.RetrievalProvider.SetAsk(rask)
+	return nil
+}
+
+func (sm *StorageMinerAPI) MarketGetRetrievalAsk(ctx context.Context) (*retrievalmarket.Ask, error) {
+	return sm.RetrievalProvider.GetAsk(), nil
+}
+
+func (sm *StorageMinerAPI) MarketListDataTransfers(ctx context.Context) ([]api.DataTransferChannel, error) {
+	inProgressChannels, err := sm.DataTransfer.InProgressChannels(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	apiChannels := make([]api.DataTransferChannel, 0, len(inProgressChannels))
+	for _, channelState := range inProgressChannels {
+		apiChannels = append(apiChannels, api.NewDataTransferChannel(sm.Host.ID(), channelState))
+	}
+
+	return apiChannels, nil
+}
+
+func (sm *StorageMinerAPI) MarketDataTransferUpdates(ctx context.Context) (<-chan api.DataTransferChannel, error) {
+	channels := make(chan api.DataTransferChannel)
+
+	unsub := sm.DataTransfer.SubscribeToEvents(func(evt datatransfer.Event, channelState datatransfer.ChannelState) {
+		channel := api.NewDataTransferChannel(sm.Host.ID(), channelState)
+		select {
+		case <-ctx.Done():
+		case channels <- channel:
+		}
+	})
+
+	go func() {
+		defer unsub()
+		<-ctx.Done()
+	}()
+
+	return channels, nil
+}
+
+func (sm *StorageMinerAPI) DealsList(ctx context.Context) ([]api.MarketDeal, error) {
+	return sm.listDeals(ctx)
+}
+
+func (sm *StorageMinerAPI) RetrievalDealsList(ctx context.Context) (map[retrievalmarket.ProviderDealIdentifier]retrievalmarket.ProviderDealState, error) {
+	return sm.RetrievalProvider.ListDeals(), nil
+}
+
+func (sm *StorageMinerAPI) DealsConsiderOnlineStorageDeals(ctx context.Context) (bool, error) {
+	return sm.ConsiderOnlineStorageDealsConfigFunc()
+}
+
+func (sm *StorageMinerAPI) DealsSetConsiderOnlineStorageDeals(ctx context.Context, b bool) error {
+	return sm.SetConsiderOnlineStorageDealsConfigFunc(b)
+}
+
+func (sm *StorageMinerAPI) DealsConsiderOnlineRetrievalDeals(ctx context.Context) (bool, error) {
+	return sm.ConsiderOnlineRetrievalDealsConfigFunc()
+}
+
+func (sm *StorageMinerAPI) DealsSetConsiderOnlineRetrievalDeals(ctx context.Context, b bool) error {
+	return sm.SetConsiderOnlineRetrievalDealsConfigFunc(b)
+}
+
+func (sm *StorageMinerAPI) DealsConsiderOfflineStorageDeals(ctx context.Context) (bool, error) {
+	return sm.ConsiderOfflineStorageDealsConfigFunc()
+}
+
+func (sm *StorageMinerAPI) DealsSetConsiderOfflineStorageDeals(ctx context.Context, b bool) error {
+	return sm.SetConsiderOfflineStorageDealsConfigFunc(b)
+}
+
+func (sm *StorageMinerAPI) DealsConsiderOfflineRetrievalDeals(ctx context.Context) (bool, error) {
+	return sm.ConsiderOfflineRetrievalDealsConfigFunc()
+}
+
+func (sm *StorageMinerAPI) DealsSetConsiderOfflineRetrievalDeals(ctx context.Context, b bool) error {
+	return sm.SetConsiderOfflineRetrievalDealsConfigFunc(b)
+}
+
+func (sm *StorageMinerAPI) DealsGetExpectedSealDurationFunc(ctx context.Context) (time.Duration, error) {
+	return sm.GetExpectedSealDurationFunc()
+}
+
+func (sm *StorageMinerAPI) DealsSetExpectedSealDurationFunc(ctx context.Context, d time.Duration) error {
+	return sm.SetExpectedSealDurationFunc(d)
+}
+
+func (sm *StorageMinerAPI) DealsImportData(ctx context.Context, deal cid.Cid, fname string) error {
+	fi, err := os.Open(fname)
+	if err != nil {
+		return xerrors.Errorf("failed to open given file: %w", err)
+	}
+	defer fi.Close() //nolint:errcheck
+
+	return sm.StorageProvider.ImportDataForDeal(ctx, deal, fi)
+}
+
+func (sm *StorageMinerAPI) DealsPieceCidBlocklist(ctx context.Context) ([]cid.Cid, error) {
+	return sm.StorageDealPieceCidBlocklistConfigFunc()
+}
+
+func (sm *StorageMinerAPI) DealsSetPieceCidBlocklist(ctx context.Context, cids []cid.Cid) error {
+	return sm.SetStorageDealPieceCidBlocklistConfigFunc(cids)
+}
+
+func (sm *StorageMinerAPI) StorageAddLocal(ctx context.Context, path string) error {
+	if sm.StorageMgr == nil {
+		return xerrors.Errorf("no storage manager")
+	}
+
+	return sm.StorageMgr.AddLocalStorage(ctx, path)
+}
+
+func (sm *StorageMinerAPI) PiecesListPieces(ctx context.Context) ([]cid.Cid, error) {
+	return sm.PieceStore.ListPieceInfoKeys()
+}
+
+func (sm *StorageMinerAPI) PiecesListCidInfos(ctx context.Context) ([]cid.Cid, error) {
+	return sm.PieceStore.ListCidInfoKeys()
+}
+
+func (sm *StorageMinerAPI) PiecesGetPieceInfo(ctx context.Context, pieceCid cid.Cid) (*piecestore.PieceInfo, error) {
+	pi, err := sm.PieceStore.GetPieceInfo(pieceCid)
+	if err != nil {
+		return nil, err
+	}
+	return &pi, nil
+}
+
+func (sm *StorageMinerAPI) PiecesGetCIDInfo(ctx context.Context, payloadCid cid.Cid) (*piecestore.CIDInfo, error) {
+	ci, err := sm.PieceStore.GetCIDInfo(payloadCid)
+	if err != nil {
+		return nil, err
+	}
+
+	return &ci, nil
 }
 
 var _ api.StorageMiner = &StorageMinerAPI{}
diff --git a/node/modules/chain.go b/node/modules/chain.go
index bc0ff3ce2..66f54a76a 100644
--- a/node/modules/chain.go
+++ b/node/modules/chain.go
@@ -3,35 +3,45 @@ package modules
 import (
 	"bytes"
 	"context"
+	"os"
 
 	"github.com/ipfs/go-bitswap"
 	"github.com/ipfs/go-bitswap/network"
 	"github.com/ipfs/go-blockservice"
-	"github.com/ipfs/go-car"
 	"github.com/ipfs/go-datastore"
-	blockstore "github.com/ipfs/go-ipfs-blockstore"
+	"github.com/ipld/go-car"
 	"github.com/libp2p/go-libp2p-core/host"
 	"github.com/libp2p/go-libp2p-core/routing"
 	pubsub "github.com/libp2p/go-libp2p-pubsub"
 	"go.uber.org/fx"
 	"golang.org/x/xerrors"
 
+	"github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper"
+
+	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain"
-	"github.com/filecoin-project/lotus/chain/blocksync"
+	"github.com/filecoin-project/lotus/chain/beacon"
+	"github.com/filecoin-project/lotus/chain/exchange"
+	"github.com/filecoin-project/lotus/chain/gen/slashfilter"
 	"github.com/filecoin-project/lotus/chain/messagepool"
 	"github.com/filecoin-project/lotus/chain/stmgr"
 	"github.com/filecoin-project/lotus/chain/store"
 	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/chain/vm"
+	"github.com/filecoin-project/lotus/lib/blockstore"
 	"github.com/filecoin-project/lotus/node/modules/dtypes"
 	"github.com/filecoin-project/lotus/node/modules/helpers"
 	"github.com/filecoin-project/lotus/node/repo"
 )
 
-func ChainExchange(mctx helpers.MetricsCtx, lc fx.Lifecycle, host host.Host, rt routing.Routing, bs dtypes.ChainGCBlockstore) dtypes.ChainExchange {
+func ChainBitswap(mctx helpers.MetricsCtx, lc fx.Lifecycle, host host.Host, rt routing.Routing, bs dtypes.ChainGCBlockstore) dtypes.ChainBitswap {
 	// prefix protocol for chain bitswap
 	// (so bitswap uses /chain/ipfs/bitswap/1.0.0 internally for chain sync stuff)
 	bitswapNetwork := network.NewFromIpfsHost(host, rt, network.Prefix("/chain"))
-	exch := bitswap.New(helpers.LifecycleCtx(mctx, lc), bitswapNetwork, bs)
+	bitswapOptions := []bitswap.Option{bitswap.ProvideEnabled(false)}
+
+	// Use just exch.Close(), closing the context is not needed
+	exch := bitswap.New(mctx, bitswapNetwork, bs, bitswapOptions...)
 	lc.Append(fx.Hook{
 		OnStop: func(ctx context.Context) error {
 			return exch.Close()
@@ -41,9 +51,9 @@ func ChainExchange(mctx helpers.MetricsCtx, lc fx.Lifecycle, host host.Host, rt
 	return exch
 }
 
-func MessagePool(lc fx.Lifecycle, sm *stmgr.StateManager, ps *pubsub.PubSub, ds dtypes.MetadataDS) (*messagepool.MessagePool, error) {
+func MessagePool(lc fx.Lifecycle, sm *stmgr.StateManager, ps *pubsub.PubSub, ds dtypes.MetadataDS, nn dtypes.NetworkName) (*messagepool.MessagePool, error) {
 	mpp := messagepool.NewProvider(sm, ps)
-	mp, err := messagepool.New(mpp, ds)
+	mp, err := messagepool.New(mpp, ds, nn)
 	if err != nil {
 		return nil, xerrors.Errorf("constructing mpool: %w", err)
 	}
@@ -55,26 +65,31 @@ func MessagePool(lc fx.Lifecycle, sm *stmgr.StateManager, ps *pubsub.PubSub, ds
 	return mp, nil
 }
 
-func ChainBlockstore(r repo.LockedRepo) (dtypes.ChainBlockstore, error) {
-	blocks, err := r.Datastore("/blocks")
+func ChainBlockstore(lc fx.Lifecycle, mctx helpers.MetricsCtx, r repo.LockedRepo) (dtypes.ChainBlockstore, error) {
+	blocks, err := r.Datastore("/chain")
 	if err != nil {
 		return nil, err
 	}
 
 	bs := blockstore.NewBlockstore(blocks)
-	return blockstore.NewIdStore(bs), nil
+	cbs, err := blockstore.CachedBlockstore(helpers.LifecycleCtx(mctx, lc), bs, blockstore.DefaultCacheOpts())
+	if err != nil {
+		return nil, err
+	}
+
+	return cbs, nil
 }
 
 func ChainGCBlockstore(bs dtypes.ChainBlockstore, gcl dtypes.ChainGCLocker) dtypes.ChainGCBlockstore {
 	return blockstore.NewGCBlockstore(bs, gcl)
 }
 
-func ChainBlockservice(bs dtypes.ChainBlockstore, rem dtypes.ChainExchange) dtypes.ChainBlockService {
+func ChainBlockService(bs dtypes.ChainBlockstore, rem dtypes.ChainBitswap) dtypes.ChainBlockService {
 	return blockservice.New(bs, rem)
 }
 
-func ChainStore(lc fx.Lifecycle, bs dtypes.ChainBlockstore, ds dtypes.MetadataDS) *store.ChainStore {
-	chain := store.NewChainStore(bs, ds)
+func ChainStore(lc fx.Lifecycle, bs dtypes.ChainBlockstore, ds dtypes.MetadataDS, syscalls vm.SyscallBuilder) *store.ChainStore {
+	chain := store.NewChainStore(bs, ds, syscalls)
 
 	if err := chain.Load(); err != nil {
 		log.Warnf("loading chain state from disk: %s", err)
@@ -94,40 +109,90 @@ func LoadGenesis(genBytes []byte) func(dtypes.ChainBlockstore) Genesis {
 		return func() (header *types.BlockHeader, e error) {
 			c, err := car.LoadCar(bs, bytes.NewReader(genBytes))
 			if err != nil {
-				return nil, err
+				return nil, xerrors.Errorf("loading genesis car file failed: %w", err)
 			}
 			if len(c.Roots) != 1 {
 				return nil, xerrors.New("expected genesis file to have one root")
 			}
 			root, err := bs.Get(c.Roots[0])
 			if err != nil {
-				return &types.BlockHeader{}, err
+				return nil, err
 			}
 
-			return types.DecodeBlock(root.RawData())
+			h, err := types.DecodeBlock(root.RawData())
+			if err != nil {
+				return nil, xerrors.Errorf("decoding block failed: %w", err)
+			}
+			return h, nil
 		}
 	}
 }
 
-func SetGenesis(cs *store.ChainStore, g Genesis) error {
-	_, err := cs.GetGenesis()
+func DoSetGenesis(_ dtypes.AfterGenesisSet) {}
+
+func SetGenesis(cs *store.ChainStore, g Genesis) (dtypes.AfterGenesisSet, error) {
+	genFromRepo, err := cs.GetGenesis()
 	if err == nil {
-		return nil // already set, noop
+		if os.Getenv("LOTUS_SKIP_GENESIS_CHECK") != "_yes_" {
+			expectedGenesis, err := g()
+			if err != nil {
+				return dtypes.AfterGenesisSet{}, xerrors.Errorf("getting expected genesis failed: %w", err)
+			}
+
+			if genFromRepo.Cid() != expectedGenesis.Cid() {
+				return dtypes.AfterGenesisSet{}, xerrors.Errorf("genesis in the repo is not the one expected by this version of Lotus!")
+			}
+		}
+		return dtypes.AfterGenesisSet{}, nil // already set, noop
 	}
 	if err != datastore.ErrNotFound {
-		return err
+		return dtypes.AfterGenesisSet{}, xerrors.Errorf("getting genesis block failed: %w", err)
 	}
 
 	genesis, err := g()
 	if err != nil {
-		return err
+		return dtypes.AfterGenesisSet{}, xerrors.Errorf("genesis func failed: %w", err)
 	}
 
-	return cs.SetGenesis(genesis)
+	return dtypes.AfterGenesisSet{}, cs.SetGenesis(genesis)
 }
 
-func NewSyncer(lc fx.Lifecycle, sm *stmgr.StateManager, bsync *blocksync.BlockSync, h host.Host) (*chain.Syncer, error) {
-	syncer, err := chain.NewSyncer(sm, bsync, h.ConnManager(), h.ID())
+func NetworkName(mctx helpers.MetricsCtx, lc fx.Lifecycle, cs *store.ChainStore, _ dtypes.AfterGenesisSet) (dtypes.NetworkName, error) {
+	if !build.Devnet {
+		return "testnetnet", nil
+	}
+
+	ctx := helpers.LifecycleCtx(mctx, lc)
+
+	netName, err := stmgr.GetNetworkName(ctx, stmgr.NewStateManager(cs), cs.GetHeaviestTipSet().ParentState())
+	return netName, err
+}
+
+type SyncerParams struct {
+	fx.In
+
+	Lifecycle    fx.Lifecycle
+	MetadataDS   dtypes.MetadataDS
+	StateManager *stmgr.StateManager
+	ChainXchg    exchange.Client
+	SyncMgrCtor  chain.SyncManagerCtor
+	Host         host.Host
+	Beacon       beacon.Schedule
+	Verifier     ffiwrapper.Verifier
+}
+
+func NewSyncer(params SyncerParams) (*chain.Syncer, error) {
+	var (
+		lc     = params.Lifecycle
+		ds     = params.MetadataDS
+		sm     = params.StateManager
+		ex     = params.ChainXchg
+		smCtor = params.SyncMgrCtor
+		h      = params.Host
+		b      = params.Beacon
+		v      = params.Verifier
+	)
+	syncer, err := chain.NewSyncer(ds, sm, ex, smCtor, h.ConnManager(), h.ID(), b, v)
 	if err != nil {
 		return nil, err
 	}
@@ -144,3 +209,7 @@ func NewSyncer(lc fx.Lifecycle, sm *stmgr.StateManager, bsync *blocksync.BlockSy
 	})
 	return syncer, nil
 }
+
+func NewSlashFilter(ds dtypes.MetadataDS) *slashfilter.SlashFilter {
+	return slashfilter.New(ds)
+}
diff --git a/node/modules/client.go b/node/modules/client.go
index 205d39a6d..6aa3cbb0e 100644
--- a/node/modules/client.go
+++ b/node/modules/client.go
@@ -2,81 +2,166 @@ package modules
 
 import (
 	"context"
-	"path/filepath"
-	"reflect"
+	"time"
 
-	"github.com/filecoin-project/go-statestore"
-	"github.com/filecoin-project/lotus/node/modules/helpers"
-	"github.com/ipfs/go-bitswap"
-	"github.com/ipfs/go-bitswap/network"
-	"github.com/libp2p/go-libp2p-core/host"
-	"github.com/libp2p/go-libp2p-core/routing"
+	"github.com/filecoin-project/go-multistore"
+	"golang.org/x/xerrors"
 
-	"github.com/ipfs/go-blockservice"
-	"github.com/ipfs/go-datastore"
-	"github.com/ipfs/go-datastore/namespace"
-	"github.com/ipfs/go-filestore"
-	blockstore "github.com/ipfs/go-ipfs-blockstore"
-	"github.com/ipfs/go-merkledag"
 	"go.uber.org/fx"
 
-	"github.com/filecoin-project/lotus/chain/deals"
-	"github.com/filecoin-project/lotus/datatransfer"
+	dtimpl "github.com/filecoin-project/go-data-transfer/impl"
+	dtnet "github.com/filecoin-project/go-data-transfer/network"
+	dtgstransport "github.com/filecoin-project/go-data-transfer/transport/graphsync"
+	"github.com/filecoin-project/go-fil-markets/retrievalmarket"
+	"github.com/filecoin-project/go-fil-markets/retrievalmarket/discovery"
+	retrievalimpl "github.com/filecoin-project/go-fil-markets/retrievalmarket/impl"
+	rmnet "github.com/filecoin-project/go-fil-markets/retrievalmarket/network"
+	"github.com/filecoin-project/go-fil-markets/storagemarket"
+	storageimpl "github.com/filecoin-project/go-fil-markets/storagemarket/impl"
+	"github.com/filecoin-project/go-fil-markets/storagemarket/impl/funds"
+	"github.com/filecoin-project/go-fil-markets/storagemarket/impl/requestvalidation"
+	smnet "github.com/filecoin-project/go-fil-markets/storagemarket/network"
+	"github.com/filecoin-project/go-storedcounter"
+	"github.com/ipfs/go-datastore"
+	"github.com/ipfs/go-datastore/namespace"
+	"github.com/libp2p/go-libp2p-core/host"
+
+	"github.com/filecoin-project/lotus/journal"
+	"github.com/filecoin-project/lotus/lib/blockstore"
+	"github.com/filecoin-project/lotus/markets"
+	marketevents "github.com/filecoin-project/lotus/markets/loggers"
+	"github.com/filecoin-project/lotus/markets/retrievaladapter"
+	"github.com/filecoin-project/lotus/node/impl/full"
+	payapi "github.com/filecoin-project/lotus/node/impl/paych"
 	"github.com/filecoin-project/lotus/node/modules/dtypes"
 	"github.com/filecoin-project/lotus/node/repo"
+	"github.com/filecoin-project/lotus/node/repo/importmgr"
+	"github.com/filecoin-project/lotus/node/repo/retrievalstoremgr"
 )
 
-func ClientFstore(r repo.LockedRepo) (dtypes.ClientFilestore, error) {
-	clientds, err := r.Datastore("/client")
+func ClientMultiDatastore(lc fx.Lifecycle, r repo.LockedRepo) (dtypes.ClientMultiDstore, error) {
+	ds, err := r.Datastore("/client")
+	if err != nil {
+		return nil, xerrors.Errorf("getting datastore out of reop: %w", err)
+	}
+
+	mds, err := multistore.NewMultiDstore(ds)
 	if err != nil {
 		return nil, err
 	}
-	blocks := namespace.Wrap(clientds, datastore.NewKey("blocks"))
 
-	fm := filestore.NewFileManager(clientds, filepath.Dir(r.Path()))
-	fm.AllowFiles = true
-	// TODO: fm.AllowUrls (needs more code in client import)
+	lc.Append(fx.Hook{
+		OnStop: func(ctx context.Context) error {
+			return mds.Close()
+		},
+	})
 
-	bs := blockstore.NewBlockstore(blocks)
-	return filestore.NewFilestore(bs, fm), nil
+	return mds, nil
 }
 
-func ClientBlockstore(fstore dtypes.ClientFilestore) dtypes.ClientBlockstore {
-	return blockstore.NewIdStore((*filestore.Filestore)(fstore))
+func ClientImportMgr(mds dtypes.ClientMultiDstore, ds dtypes.MetadataDS) dtypes.ClientImportMgr {
+	return importmgr.New(mds, namespace.Wrap(ds, datastore.NewKey("/client")))
+}
+
+func ClientBlockstore(imgr dtypes.ClientImportMgr) dtypes.ClientBlockstore {
+	// in most cases this is now unused in normal operations -- however, it's important to preserve for the IPFS use case
+	return blockstore.WrapIDStore(imgr.Blockstore)
 }
 
 // RegisterClientValidator is an initialization hook that registers the client
 // request validator with the data transfer module as the validator for
 // StorageDataTransferVoucher types
-func RegisterClientValidator(crv *deals.ClientRequestValidator, dtm dtypes.ClientDataTransfer) {
-	if err := dtm.RegisterVoucherType(reflect.TypeOf(deals.StorageDataTransferVoucher{}), crv); err != nil {
+func RegisterClientValidator(crv dtypes.ClientRequestValidator, dtm dtypes.ClientDataTransfer) {
+	if err := dtm.RegisterVoucherType(&requestvalidation.StorageDataTransferVoucher{}, (*requestvalidation.UnifiedRequestValidator)(crv)); err != nil {
 		panic(err)
 	}
 }
 
-// NewClientDAGServiceDataTransfer returns a data transfer manager that just
+// NewClientGraphsyncDataTransfer returns a data transfer manager that just
 // uses the clients's Client DAG service for transfers
-func NewClientDAGServiceDataTransfer(dag dtypes.ClientDAG) dtypes.ClientDataTransfer {
-	return datatransfer.NewDAGServiceDataTransfer(dag)
-}
+func NewClientGraphsyncDataTransfer(lc fx.Lifecycle, h host.Host, gs dtypes.Graphsync, ds dtypes.MetadataDS) (dtypes.ClientDataTransfer, error) {
+	sc := storedcounter.New(ds, datastore.NewKey("/datatransfer/client/counter"))
+	net := dtnet.NewFromLibp2pHost(h)
 
-// NewClientDealStore creates a statestore for the client to store its deals
-func NewClientDealStore(ds dtypes.MetadataDS) dtypes.ClientDealStore {
-	return statestore.New(namespace.Wrap(ds, datastore.NewKey("/deals/client")))
-}
-
-func ClientDAG(mctx helpers.MetricsCtx, lc fx.Lifecycle, ibs dtypes.ClientBlockstore, rt routing.Routing, h host.Host) dtypes.ClientDAG {
-	bitswapNetwork := network.NewFromIpfsHost(h, rt)
-	exch := bitswap.New(helpers.LifecycleCtx(mctx, lc), bitswapNetwork, ibs)
-
-	bsvc := blockservice.New(ibs, exch)
-	dag := merkledag.NewDAGService(bsvc)
+	dtDs := namespace.Wrap(ds, datastore.NewKey("/datatransfer/client/transfers"))
+	transport := dtgstransport.NewTransport(h.ID(), gs)
+	dt, err := dtimpl.NewDataTransfer(dtDs, net, transport, sc)
+	if err != nil {
+		return nil, err
+	}
 
 	lc.Append(fx.Hook{
-		OnStop: func(_ context.Context) error {
-			return bsvc.Close()
+		OnStart: func(ctx context.Context) error {
+			return dt.Start(ctx)
+		},
+		OnStop: func(ctx context.Context) error {
+			return dt.Stop(ctx)
 		},
 	})
-
-	return dag
+	return dt, nil
+}
+
+// NewClientDatastore creates a datastore for the client to store its deals
+func NewClientDatastore(ds dtypes.MetadataDS) dtypes.ClientDatastore {
+	return namespace.Wrap(ds, datastore.NewKey("/deals/client"))
+}
+
+type ClientDealFunds funds.DealFunds
+
+func NewClientDealFunds(ds dtypes.MetadataDS) (ClientDealFunds, error) {
+	return funds.NewDealFunds(ds, datastore.NewKey("/marketfunds/client"))
+}
+
+func StorageClient(lc fx.Lifecycle, h host.Host, ibs dtypes.ClientBlockstore, mds dtypes.ClientMultiDstore, r repo.LockedRepo, dataTransfer dtypes.ClientDataTransfer, discovery *discovery.Local, deals dtypes.ClientDatastore, scn storagemarket.StorageClientNode, dealFunds ClientDealFunds) (storagemarket.StorageClient, error) {
+	net := smnet.NewFromLibp2pHost(h)
+	c, err := storageimpl.NewClient(net, ibs, mds, dataTransfer, discovery, deals, scn, dealFunds, storageimpl.DealPollingInterval(time.Second))
+	if err != nil {
+		return nil, err
+	}
+	lc.Append(fx.Hook{
+		OnStart: func(ctx context.Context) error {
+			c.SubscribeToEvents(marketevents.StorageClientLogger)
+
+			evtType := journal.J.RegisterEventType("markets/storage/client", "state_change")
+			c.SubscribeToEvents(markets.StorageClientJournaler(evtType))
+
+			return c.Start(ctx)
+		},
+		OnStop: func(context.Context) error {
+			return c.Stop()
+		},
+	})
+	return c, nil
+}
+
+// RetrievalClient creates a new retrieval client attached to the client blockstore
+func RetrievalClient(lc fx.Lifecycle, h host.Host, mds dtypes.ClientMultiDstore, dt dtypes.ClientDataTransfer, payAPI payapi.PaychAPI, resolver retrievalmarket.PeerResolver, ds dtypes.MetadataDS, chainAPI full.ChainAPI, stateAPI full.StateAPI) (retrievalmarket.RetrievalClient, error) {
+	adapter := retrievaladapter.NewRetrievalClientNode(payAPI, chainAPI, stateAPI)
+	network := rmnet.NewFromLibp2pHost(h)
+	sc := storedcounter.New(ds, datastore.NewKey("/retr"))
+	client, err := retrievalimpl.NewClient(network, mds, dt, adapter, resolver, namespace.Wrap(ds, datastore.NewKey("/retrievals/client")), sc)
+	if err != nil {
+		return nil, err
+	}
+	lc.Append(fx.Hook{
+		OnStart: func(ctx context.Context) error {
+			client.SubscribeToEvents(marketevents.RetrievalClientLogger)
+
+			evtType := journal.J.RegisterEventType("markets/retrieval/client", "state_change")
+			client.SubscribeToEvents(markets.RetrievalClientJournaler(evtType))
+
+			return nil
+		},
+	})
+	return client, nil
+}
+
+// ClientRetrievalStoreManager is the default version of the RetrievalStoreManager that runs on multistore
+func ClientRetrievalStoreManager(imgr dtypes.ClientImportMgr) dtypes.ClientRetrievalStoreManager {
+	return retrievalstoremgr.NewMultiStoreRetrievalStoreManager(imgr)
+}
+
+// ClientBlockstoreRetrievalStoreManager is the default version of the RetrievalStoreManager that runs on multistore
+func ClientBlockstoreRetrievalStoreManager(bs dtypes.ClientBlockstore) dtypes.ClientRetrievalStoreManager {
+	return retrievalstoremgr.NewBlockstoreRetrievalStoreManager(bs)
 }
diff --git a/node/modules/core.go b/node/modules/core.go
index 186ad9936..a695d8651 100644
--- a/node/modules/core.go
+++ b/node/modules/core.go
@@ -3,20 +3,25 @@ package modules
 import (
 	"context"
 	"crypto/rand"
-	"github.com/filecoin-project/lotus/api/apistruct"
+	"errors"
 	"io"
 	"io/ioutil"
 
+	"github.com/gbrlsnchs/jwt/v3"
+	logging "github.com/ipfs/go-log/v2"
+	"github.com/libp2p/go-libp2p-core/peer"
+	"github.com/libp2p/go-libp2p-core/peerstore"
+	record "github.com/libp2p/go-libp2p-record"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-jsonrpc/auth"
+
+	"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/lib/addrutil"
 	"github.com/filecoin-project/lotus/node/modules/dtypes"
 	"github.com/filecoin-project/lotus/node/repo"
-	"github.com/gbrlsnchs/jwt/v3"
-	logging "github.com/ipfs/go-log"
-	"github.com/libp2p/go-libp2p-core/peerstore"
-	record "github.com/libp2p/go-libp2p-record"
-	"golang.org/x/xerrors"
 )
 
 var log = logging.Logger("modules")
@@ -30,15 +35,17 @@ func RecordValidator(ps peerstore.Peerstore) record.Validator {
 	}
 }
 
-const JWTSecretName = "auth-jwt-private"
+const JWTSecretName = "auth-jwt-private"  //nolint:gosec
+const KTJwtHmacSecret = "jwt-hmac-secret" //nolint:gosec
 
-type jwtPayload struct {
-	Allow []string
+type JwtPayload struct {
+	Allow []auth.Permission
 }
 
 func APISecret(keystore types.KeyStore, lr repo.LockedRepo) (*dtypes.APIAlg, error) {
 	key, err := keystore.Get(JWTSecretName)
-	if err != nil {
+
+	if errors.Is(err, types.ErrKeyInfoNotFound) {
 		log.Warn("Generating new API secret")
 
 		sk, err := ioutil.ReadAll(io.LimitReader(rand.Reader, 32))
@@ -47,7 +54,7 @@ func APISecret(keystore types.KeyStore, lr repo.LockedRepo) (*dtypes.APIAlg, err
 		}
 
 		key = types.KeyInfo{
-			Type:       "jwt-hmac-secret",
+			Type:       KTJwtHmacSecret,
 			PrivateKey: sk,
 		}
 
@@ -56,7 +63,7 @@ func APISecret(keystore types.KeyStore, lr repo.LockedRepo) (*dtypes.APIAlg, err
 		}
 
 		// TODO: make this configurable
-		p := jwtPayload{
+		p := JwtPayload{
 			Allow: apistruct.AllPermissions,
 		}
 
@@ -68,6 +75,8 @@ func APISecret(keystore types.KeyStore, lr repo.LockedRepo) (*dtypes.APIAlg, err
 		if err := lr.SetAPIToken(cliToken); err != nil {
 			return nil, err
 		}
+	} else if err != nil {
+		return nil, xerrors.Errorf("could not get JWT Token: %w", err)
 	}
 
 	return (*dtypes.APIAlg)(jwt.NewHS256(key.PrivateKey)), nil
@@ -82,3 +91,17 @@ func ConfigBootstrap(peers []string) func() (dtypes.BootstrapPeers, error) {
 func BuiltinBootstrap() (dtypes.BootstrapPeers, error) {
 	return build.BuiltinBootstrap()
 }
+
+func DrandBootstrap(ds dtypes.DrandSchedule) (dtypes.DrandBootstrap, error) {
+	// TODO: retry resolving, don't fail if at least one resolve succeeds
+	res := []peer.AddrInfo{}
+	for _, d := range ds {
+		addrs, err := addrutil.ParseAddresses(context.TODO(), d.Config.Relays)
+		if err != nil {
+			log.Errorf("reoslving drand relays addresses: %+v", err)
+			return res, nil
+		}
+		res = append(res, addrs...)
+	}
+	return res, nil
+}
diff --git a/node/modules/dtypes/api.go b/node/modules/dtypes/api.go
index c0e57d911..d57b05cfa 100644
--- a/node/modules/dtypes/api.go
+++ b/node/modules/dtypes/api.go
@@ -1,5 +1,10 @@
 package dtypes
 
-import "github.com/gbrlsnchs/jwt/v3"
+import (
+	"github.com/gbrlsnchs/jwt/v3"
+	"github.com/multiformats/go-multiaddr"
+)
 
 type APIAlg jwt.HMACSHA
+
+type APIEndpoint multiaddr.Multiaddr
diff --git a/node/modules/dtypes/beacon.go b/node/modules/dtypes/beacon.go
new file mode 100644
index 000000000..28bbdf281
--- /dev/null
+++ b/node/modules/dtypes/beacon.go
@@ -0,0 +1,16 @@
+package dtypes
+
+import "github.com/filecoin-project/go-state-types/abi"
+
+type DrandSchedule []DrandPoint
+
+type DrandPoint struct {
+	Start  abi.ChainEpoch
+	Config DrandConfig
+}
+
+type DrandConfig struct {
+	Servers       []string
+	Relays        []string
+	ChainInfoJSON string
+}
diff --git a/node/modules/dtypes/bootstrap.go b/node/modules/dtypes/bootstrap.go
index 0b46f63c3..96cd2f673 100644
--- a/node/modules/dtypes/bootstrap.go
+++ b/node/modules/dtypes/bootstrap.go
@@ -3,3 +3,6 @@ package dtypes
 import "github.com/libp2p/go-libp2p-core/peer"
 
 type BootstrapPeers []peer.AddrInfo
+type DrandBootstrap []peer.AddrInfo
+
+type Bootstrapper bool
diff --git a/node/modules/dtypes/chain.go b/node/modules/dtypes/chain.go
new file mode 100644
index 000000000..0c924c12a
--- /dev/null
+++ b/node/modules/dtypes/chain.go
@@ -0,0 +1,4 @@
+package dtypes
+
+type NetworkName string
+type AfterGenesisSet struct{}
diff --git a/node/modules/dtypes/miner.go b/node/modules/dtypes/miner.go
new file mode 100644
index 000000000..5bb439b4d
--- /dev/null
+++ b/node/modules/dtypes/miner.go
@@ -0,0 +1,74 @@
+package dtypes
+
+import (
+	"context"
+	"time"
+
+	"github.com/ipfs/go-cid"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-fil-markets/storagemarket"
+	"github.com/filecoin-project/go-state-types/abi"
+
+	"github.com/filecoin-project/lotus/extern/storage-sealing/sealiface"
+)
+
+type MinerAddress address.Address
+type MinerID abi.ActorID
+
+// ConsiderOnlineStorageDealsConfigFunc is a function which reads from miner
+// config to determine if the user has disabled storage deals (or not).
+type ConsiderOnlineStorageDealsConfigFunc func() (bool, error)
+
+// SetConsiderOnlineStorageDealsConfigFunc is a function which is used to
+// disable or enable storage deal acceptance.
+type SetConsiderOnlineStorageDealsConfigFunc func(bool) error
+
+// ConsiderOnlineRetrievalDealsConfigFunc is a function which reads from miner
+// config to determine if the user has disabled retrieval acceptance (or not).
+type ConsiderOnlineRetrievalDealsConfigFunc func() (bool, error)
+
+// SetConsiderOnlineRetrievalDealsConfigFunc is a function which is used to
+// disable or enable retrieval deal acceptance.
+type SetConsiderOnlineRetrievalDealsConfigFunc func(bool) error
+
+// StorageDealPieceCidBlocklistConfigFunc is a function which reads from miner
+// config to obtain a list of CIDs for which the miner will not accept
+// storage proposals.
+type StorageDealPieceCidBlocklistConfigFunc func() ([]cid.Cid, error)
+
+// SetStorageDealPieceCidBlocklistConfigFunc is a function which is used to set a
+// list of CIDs for which the miner will reject deal proposals.
+type SetStorageDealPieceCidBlocklistConfigFunc func([]cid.Cid) error
+
+// ConsiderOfflineStorageDealsConfigFunc is a function which reads from miner
+// config to determine if the user has disabled storage deals (or not).
+type ConsiderOfflineStorageDealsConfigFunc func() (bool, error)
+
+// SetConsiderOfflineStorageDealsConfigFunc is a function which is used to
+// disable or enable storage deal acceptance.
+type SetConsiderOfflineStorageDealsConfigFunc func(bool) error
+
+// ConsiderOfflineRetrievalDealsConfigFunc is a function which reads from miner
+// config to determine if the user has disabled retrieval acceptance (or not).
+type ConsiderOfflineRetrievalDealsConfigFunc func() (bool, error)
+
+// SetConsiderOfflineRetrievalDealsConfigFunc is a function which is used to
+// disable or enable retrieval deal acceptance.
+type SetConsiderOfflineRetrievalDealsConfigFunc func(bool) error
+
+// SetSealingDelay sets how long a sector waits for more deals before sealing begins.
+type SetSealingConfigFunc func(sealiface.Config) error
+
+// GetSealingDelay returns how long a sector waits for more deals before sealing begins.
+type GetSealingConfigFunc func() (sealiface.Config, error)
+
+// SetExpectedSealDurationFunc is a function which is used to set how long sealing is expected to take.
+// Deals that would need to start earlier than this duration will be rejected.
+type SetExpectedSealDurationFunc func(time.Duration) error
+
+// GetExpectedSealDurationFunc is a function which reads from miner
+// too determine how long sealing is expected to take
+type GetExpectedSealDurationFunc func() (time.Duration, error)
+
+type DealFilter func(ctx context.Context, deal storagemarket.MinerDeal) (bool, string, error)
diff --git a/node/modules/dtypes/mpool.go b/node/modules/dtypes/mpool.go
new file mode 100644
index 000000000..1c64449f8
--- /dev/null
+++ b/node/modules/dtypes/mpool.go
@@ -0,0 +1,35 @@
+package dtypes
+
+import (
+	"context"
+	"sync"
+
+	"github.com/filecoin-project/go-address"
+)
+
+type MpoolLocker struct {
+	m  map[address.Address]chan struct{}
+	lk sync.Mutex
+}
+
+func (ml *MpoolLocker) TakeLock(ctx context.Context, a address.Address) (func(), error) {
+	ml.lk.Lock()
+	if ml.m == nil {
+		ml.m = make(map[address.Address]chan struct{})
+	}
+	lk, ok := ml.m[a]
+	if !ok {
+		lk = make(chan struct{}, 1)
+		ml.m[a] = lk
+	}
+	ml.lk.Unlock()
+
+	select {
+	case lk <- struct{}{}:
+	case <-ctx.Done():
+		return nil, ctx.Err()
+	}
+	return func() {
+		<-lk
+	}, nil
+}
diff --git a/node/modules/dtypes/scorekeeper.go b/node/modules/dtypes/scorekeeper.go
new file mode 100644
index 000000000..7999d19e5
--- /dev/null
+++ b/node/modules/dtypes/scorekeeper.go
@@ -0,0 +1,25 @@
+package dtypes
+
+import (
+	"sync"
+
+	peer "github.com/libp2p/go-libp2p-core/peer"
+	pubsub "github.com/libp2p/go-libp2p-pubsub"
+)
+
+type ScoreKeeper struct {
+	lk     sync.Mutex
+	scores map[peer.ID]*pubsub.PeerScoreSnapshot
+}
+
+func (sk *ScoreKeeper) Update(scores map[peer.ID]*pubsub.PeerScoreSnapshot) {
+	sk.lk.Lock()
+	sk.scores = scores
+	sk.lk.Unlock()
+}
+
+func (sk *ScoreKeeper) Get() map[peer.ID]*pubsub.PeerScoreSnapshot {
+	sk.lk.Lock()
+	defer sk.lk.Unlock()
+	return sk.scores
+}
diff --git a/node/modules/dtypes/shutdown.go b/node/modules/dtypes/shutdown.go
new file mode 100644
index 000000000..d87c2129a
--- /dev/null
+++ b/node/modules/dtypes/shutdown.go
@@ -0,0 +1,5 @@
+package dtypes
+
+// ShutdownChan is a channel to which you send a value if you intend to shut
+// down the daemon (or miner), including the node and RPC server.
+type ShutdownChan chan struct{}
diff --git a/node/modules/dtypes/storage.go b/node/modules/dtypes/storage.go
index 32b97767d..13defda8d 100644
--- a/node/modules/dtypes/storage.go
+++ b/node/modules/dtypes/storage.go
@@ -3,13 +3,20 @@ package dtypes
 import (
 	bserv "github.com/ipfs/go-blockservice"
 	"github.com/ipfs/go-datastore"
-	"github.com/ipfs/go-filestore"
-	blockstore "github.com/ipfs/go-ipfs-blockstore"
+	"github.com/ipfs/go-graphsync"
 	exchange "github.com/ipfs/go-ipfs-exchange-interface"
-	ipld "github.com/ipfs/go-ipld-format"
+	format "github.com/ipfs/go-ipld-format"
 
+	"github.com/filecoin-project/go-fil-markets/storagemarket/impl/requestvalidation"
+	"github.com/filecoin-project/go-multistore"
+
+	datatransfer "github.com/filecoin-project/go-data-transfer"
+	"github.com/filecoin-project/go-fil-markets/piecestore"
 	"github.com/filecoin-project/go-statestore"
-	"github.com/filecoin-project/lotus/datatransfer"
+
+	"github.com/filecoin-project/lotus/lib/blockstore"
+	"github.com/filecoin-project/lotus/node/repo/importmgr"
+	"github.com/filecoin-project/lotus/node/repo/retrievalstoremgr"
 )
 
 // MetadataDS stores metadata
@@ -20,20 +27,30 @@ type ChainBlockstore blockstore.Blockstore
 
 type ChainGCLocker blockstore.GCLocker
 type ChainGCBlockstore blockstore.GCBlockstore
-type ChainExchange exchange.Interface
+type ChainBitswap exchange.Interface
 type ChainBlockService bserv.BlockService
 
-type ClientFilestore *filestore.Filestore
+type ClientMultiDstore *multistore.MultiStore
+type ClientImportMgr *importmgr.Mgr
 type ClientBlockstore blockstore.Blockstore
-type ClientDAG ipld.DAGService
 type ClientDealStore *statestore.StateStore
+type ClientRequestValidator *requestvalidation.UnifiedRequestValidator
+type ClientDatastore datastore.Batching
+type ClientRetrievalStoreManager retrievalstoremgr.RetrievalStoreManager
+
+type Graphsync graphsync.GraphExchange
 
 // ClientDataTransfer is a data transfer manager for the client
 type ClientDataTransfer datatransfer.Manager
 
 type ProviderDealStore *statestore.StateStore
+type ProviderPieceStore piecestore.PieceStore
+type ProviderRequestValidator *requestvalidation.UnifiedRequestValidator
 
 // ProviderDataTransfer is a data transfer manager for the provider
 type ProviderDataTransfer datatransfer.Manager
 
-type StagingDAG ipld.DAGService
+type StagingDAG format.DAGService
+type StagingBlockstore blockstore.Blockstore
+type StagingGraphsync graphsync.GraphExchange
+type StagingMultiDstore *multistore.MultiStore
diff --git a/node/modules/graphsync.go b/node/modules/graphsync.go
new file mode 100644
index 000000000..9bdc9bcca
--- /dev/null
+++ b/node/modules/graphsync.go
@@ -0,0 +1,43 @@
+package modules
+
+import (
+	"github.com/filecoin-project/lotus/node/modules/dtypes"
+	"github.com/filecoin-project/lotus/node/modules/helpers"
+	"github.com/ipfs/go-graphsync"
+	graphsyncimpl "github.com/ipfs/go-graphsync/impl"
+	gsnet "github.com/ipfs/go-graphsync/network"
+	"github.com/ipfs/go-graphsync/storeutil"
+	"github.com/libp2p/go-libp2p-core/host"
+	"github.com/libp2p/go-libp2p-core/peer"
+	"go.uber.org/fx"
+)
+
+// Graphsync creates a graphsync instance from the given loader and storer
+func Graphsync(mctx helpers.MetricsCtx, lc fx.Lifecycle, clientBs dtypes.ClientBlockstore, chainBs dtypes.ChainBlockstore, h host.Host) (dtypes.Graphsync, error) {
+	graphsyncNetwork := gsnet.NewFromLibp2pHost(h)
+	loader := storeutil.LoaderForBlockstore(clientBs)
+	storer := storeutil.StorerForBlockstore(clientBs)
+	gs := graphsyncimpl.New(helpers.LifecycleCtx(mctx, lc), graphsyncNetwork, loader, storer, graphsyncimpl.RejectAllRequestsByDefault())
+	chainLoader := storeutil.LoaderForBlockstore(chainBs)
+	chainStorer := storeutil.StorerForBlockstore(chainBs)
+	err := gs.RegisterPersistenceOption("chainstore", chainLoader, chainStorer)
+	if err != nil {
+		return nil, err
+	}
+	gs.RegisterIncomingRequestHook(func(p peer.ID, requestData graphsync.RequestData, hookActions graphsync.IncomingRequestHookActions) {
+		_, has := requestData.Extension("chainsync")
+		if has {
+			// TODO: we should confirm the selector is a reasonable one before we validate
+			// TODO: this code will get more complicated and should probably not live here eventually
+			hookActions.ValidateRequest()
+			hookActions.UsePersistenceOption("chainstore")
+		}
+	})
+	gs.RegisterOutgoingRequestHook(func(p peer.ID, requestData graphsync.RequestData, hookActions graphsync.OutgoingRequestHookActions) {
+		_, has := requestData.Extension("chainsync")
+		if has {
+			hookActions.UsePersistenceOption("chainstore")
+		}
+	})
+	return gs, nil
+}
diff --git a/node/modules/ipfsclient.go b/node/modules/ipfsclient.go
new file mode 100644
index 000000000..24e595fdb
--- /dev/null
+++ b/node/modules/ipfsclient.go
@@ -0,0 +1,38 @@
+package modules
+
+import (
+	"go.uber.org/fx"
+	"golang.org/x/xerrors"
+
+	"github.com/multiformats/go-multiaddr"
+
+	"github.com/filecoin-project/lotus/lib/blockstore"
+	"github.com/filecoin-project/lotus/lib/ipfsbstore"
+	"github.com/filecoin-project/lotus/node/modules/dtypes"
+	"github.com/filecoin-project/lotus/node/modules/helpers"
+)
+
+// IpfsClientBlockstore returns a ClientBlockstore implementation backed by an IPFS node.
+// If ipfsMaddr is empty, a local IPFS node is assumed considering IPFS_PATH configuration.
+// If ipfsMaddr is not empty, it will connect to the remote IPFS node with the provided multiaddress.
+// The flag useForRetrieval indicates if the IPFS node will also be used for storing retrieving deals.
+func IpfsClientBlockstore(ipfsMaddr string) func(helpers.MetricsCtx, fx.Lifecycle, dtypes.ClientImportMgr) (dtypes.ClientBlockstore, error) {
+	return func(mctx helpers.MetricsCtx, lc fx.Lifecycle, localStore dtypes.ClientImportMgr) (dtypes.ClientBlockstore, error) {
+		var err error
+		var ipfsbs blockstore.Blockstore
+		if ipfsMaddr != "" {
+			var ma multiaddr.Multiaddr
+			ma, err = multiaddr.NewMultiaddr(ipfsMaddr)
+			if err != nil {
+				return nil, xerrors.Errorf("parsing ipfs multiaddr: %w", err)
+			}
+			ipfsbs, err = ipfsbstore.NewRemoteIpfsBstore(helpers.LifecycleCtx(mctx, lc), ma)
+		} else {
+			ipfsbs, err = ipfsbstore.NewIpfsBstore(helpers.LifecycleCtx(mctx, lc))
+		}
+		if err != nil {
+			return nil, xerrors.Errorf("constructing ipfs blockstore: %w", err)
+		}
+		return blockstore.WrapIDStore(ipfsbs), nil
+	}
+}
diff --git a/node/modules/lp2p/addrs.go b/node/modules/lp2p/addrs.go
index 95971449d..afb8ce910 100644
--- a/node/modules/lp2p/addrs.go
+++ b/node/modules/lp2p/addrs.go
@@ -18,7 +18,7 @@ func AddrFilters(filters []string) func() (opts Libp2pOpts, err error) {
 			if err != nil {
 				return opts, fmt.Errorf("incorrectly formatted address filter in config: %s", s)
 			}
-			opts.Opts = append(opts.Opts, libp2p.FilterAddresses(f))
+			opts.Opts = append(opts.Opts, libp2p.FilterAddresses(f)) //nolint:staticcheck
 		}
 		return opts, nil
 	}
diff --git a/node/modules/lp2p/host.go b/node/modules/lp2p/host.go
index ccb579763..b0436e9c9 100644
--- a/node/modules/lp2p/host.go
+++ b/node/modules/lp2p/host.go
@@ -10,7 +10,6 @@ import (
 	"github.com/libp2p/go-libp2p-core/peer"
 	"github.com/libp2p/go-libp2p-core/peerstore"
 	dht "github.com/libp2p/go-libp2p-kad-dht"
-	dhtopts "github.com/libp2p/go-libp2p-kad-dht/opts"
 	record "github.com/libp2p/go-libp2p-record"
 	routedhost "github.com/libp2p/go-libp2p/p2p/host/routed"
 	mocknet "github.com/libp2p/go-libp2p/p2p/net/mock"
@@ -47,7 +46,8 @@ func Host(mctx helpers.MetricsCtx, lc fx.Lifecycle, params P2PHostIn) (RawHost,
 		libp2p.Peerstore(params.Peerstore),
 		libp2p.NoListenAddrs,
 		libp2p.Ping(true),
-		libp2p.UserAgent("lotus-" + build.UserVersion)}
+		libp2p.UserAgent("lotus-" + build.UserVersion()),
+	}
 	for _, o := range params.Opts {
 		opts = append(opts, o...)
 	}
@@ -70,15 +70,24 @@ func MockHost(mn mocknet.Mocknet, id peer.ID, ps peerstore.Peerstore) (RawHost,
 	return mn.AddPeerWithPeerstore(id, ps)
 }
 
-func DHTRouting(client bool) interface{} {
-	return func(mctx helpers.MetricsCtx, lc fx.Lifecycle, host RawHost, dstore dtypes.MetadataDS, validator record.Validator) (BaseIpfsRouting, error) {
+func DHTRouting(mode dht.ModeOpt) interface{} {
+	return func(mctx helpers.MetricsCtx, lc fx.Lifecycle, host RawHost, dstore dtypes.MetadataDS, validator record.Validator, nn dtypes.NetworkName, bs dtypes.Bootstrapper) (BaseIpfsRouting, error) {
 		ctx := helpers.LifecycleCtx(mctx, lc)
 
+		if bs {
+			mode = dht.ModeServer
+		}
+
+		opts := []dht.Option{dht.Mode(mode),
+			dht.Datastore(dstore),
+			dht.Validator(validator),
+			dht.ProtocolPrefix(build.DhtProtocolName(nn)),
+			dht.QueryFilter(dht.PublicQueryFilter),
+			dht.RoutingTableFilter(dht.PublicRoutingTableFilter),
+			dht.DisableProviders(),
+			dht.DisableValues()}
 		d, err := dht.New(
-			ctx, host,
-			dhtopts.Client(client),
-			dhtopts.Datastore(dstore),
-			dhtopts.Validator(validator),
+			ctx, host, opts...,
 		)
 
 		if err != nil {
diff --git a/node/modules/lp2p/libp2p.go b/node/modules/lp2p/libp2p.go
index f14368aa4..5a1666cb6 100644
--- a/node/modules/lp2p/libp2p.go
+++ b/node/modules/lp2p/libp2p.go
@@ -8,7 +8,7 @@ import (
 	"github.com/filecoin-project/lotus/chain/types"
 	"golang.org/x/xerrors"
 
-	logging "github.com/ipfs/go-log"
+	logging "github.com/ipfs/go-log/v2"
 	"github.com/libp2p/go-libp2p"
 	connmgr "github.com/libp2p/go-libp2p-connmgr"
 	"github.com/libp2p/go-libp2p-core/crypto"
@@ -19,7 +19,10 @@ import (
 
 var log = logging.Logger("p2pnode")
 
-const kstorePrivkey = "libp2p-host"
+const (
+	KLibp2pHost  = "libp2p-host"
+	KTLibp2pHost = KLibp2pHost
+)
 
 type Libp2pOpts struct {
 	fx.Out
@@ -28,7 +31,7 @@ type Libp2pOpts struct {
 }
 
 func PrivKey(ks types.KeyStore) (crypto.PrivKey, error) {
-	k, err := ks.Get(kstorePrivkey)
+	k, err := ks.Get(KLibp2pHost)
 	if err == nil {
 		return crypto.UnmarshalPrivateKey(k.PrivateKey)
 	}
@@ -44,8 +47,8 @@ func PrivKey(ks types.KeyStore) (crypto.PrivKey, error) {
 		return nil, err
 	}
 
-	if err := ks.Put(kstorePrivkey, types.KeyInfo{
-		Type:       kstorePrivkey,
+	if err := ks.Put(KLibp2pHost, types.KeyInfo{
+		Type:       KTLibp2pHost,
 		PrivateKey: kbytes,
 	}); err != nil {
 		return nil, err
diff --git a/node/modules/lp2p/nat.go b/node/modules/lp2p/nat.go
index 553cc27ce..f6c541ef7 100644
--- a/node/modules/lp2p/nat.go
+++ b/node/modules/lp2p/nat.go
@@ -35,4 +35,6 @@ func AutoNATService(quic bool) func(repo repo.Repo, mctx helpers.MetricsCtx, lc
 }
 */
 
+var AutoNATService = simpleOpt(libp2p.EnableNATService())
+
 var NatPortMap = simpleOpt(libp2p.NATPortMap())
diff --git a/node/modules/lp2p/pnet.go b/node/modules/lp2p/pnet.go
deleted file mode 100644
index f182be125..000000000
--- a/node/modules/lp2p/pnet.go
+++ /dev/null
@@ -1,63 +0,0 @@
-package lp2p
-
-import (
-	"fmt"
-	"strings"
-
-	"github.com/libp2p/go-libp2p"
-	pnet "github.com/libp2p/go-libp2p-pnet"
-)
-
-var LotusKey = "/key/swarm/psk/1.0.0/\n/base16/\n20c72388e6299c7bbc1b501fdcc8abe4f89f798e9b93b2d2bc02e3c29b6a088e"
-
-type PNetFingerprint []byte
-
-func PNet() (opts Libp2pOpts, fp PNetFingerprint, err error) {
-	protec, err := pnet.NewProtector(strings.NewReader(LotusKey))
-	if err != nil {
-		return opts, nil, fmt.Errorf("failed to configure private network: %s", err)
-	}
-	fp = protec.Fingerprint()
-
-	opts.Opts = append(opts.Opts, libp2p.PrivateNetwork(protec))
-	return opts, fp, nil
-}
-
-/*
-func PNetChecker(repo repo.Repo, ph host.Host, lc fx.Lifecycle) error {
-	// TODO: better check?
-	swarmkey, err := repo.SwarmKey()
-	if err != nil || swarmkey == nil {
-		return err
-	}
-
-	done := make(chan struct{})
-	lc.Append(fx.Hook{
-		OnStart: func(_ context.Context) error {
-			go func() {
-				t := time.NewTicker(30 * time.Second)
-				defer t.Stop()
-
-				<-t.C // swallow one tick
-				for {
-					select {
-					case <-t.C:
-						if len(ph.Network().Peers()) == 0 {
-							log.Warn("We are in private network and have no peers.")
-							log.Warn("This might be configuration mistake.")
-						}
-					case <-done:
-						return
-					}
-				}
-			}()
-			return nil
-		},
-		OnStop: func(_ context.Context) error {
-			close(done)
-			return nil
-		},
-	})
-	return nil
-}
-*/
diff --git a/node/modules/lp2p/pubsub.go b/node/modules/lp2p/pubsub.go
index 657c714f1..aefb06d89 100644
--- a/node/modules/lp2p/pubsub.go
+++ b/node/modules/lp2p/pubsub.go
@@ -2,44 +2,416 @@ package lp2p
 
 import (
 	"context"
+	"encoding/json"
+	"time"
 
 	host "github.com/libp2p/go-libp2p-core/host"
 	peer "github.com/libp2p/go-libp2p-core/peer"
 	pubsub "github.com/libp2p/go-libp2p-pubsub"
+	pubsub_pb "github.com/libp2p/go-libp2p-pubsub/pb"
+	blake2b "github.com/minio/blake2b-simd"
 	ma "github.com/multiformats/go-multiaddr"
+	"go.opencensus.io/stats"
 	"go.uber.org/fx"
+	"golang.org/x/xerrors"
 
+	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/metrics"
+	"github.com/filecoin-project/lotus/node/config"
+	"github.com/filecoin-project/lotus/node/modules/dtypes"
 	"github.com/filecoin-project/lotus/node/modules/helpers"
 )
 
-type PubsubOpt func(host.Host) pubsub.Option
+func init() {
+	// configure larger overlay parameters
+	pubsub.GossipSubD = 8
+	pubsub.GossipSubDscore = 6
+	pubsub.GossipSubDout = 3
+	pubsub.GossipSubDlo = 6
+	pubsub.GossipSubDhi = 12
+	pubsub.GossipSubDlazy = 12
+	pubsub.GossipSubDirectConnectInitialDelay = 30 * time.Second
+	pubsub.GossipSubIWantFollowupTime = 5 * time.Second
+	pubsub.GossipSubHistoryLength = 10
+	pubsub.GossipSubGossipFactor = 0.1
+}
+func ScoreKeeper() *dtypes.ScoreKeeper {
+	return new(dtypes.ScoreKeeper)
+}
 
-func PubsubTracer() PubsubOpt {
-	return func(host host.Host) pubsub.Option {
-		pi, err := peer.AddrInfoFromP2pAddr(ma.StringCast("/ip4/147.75.67.199/tcp/4001/p2p/QmTd6UvR47vUidRNZ1ZKXHrAFhqTJAD27rKL9XYghEKgKX"))
+type GossipIn struct {
+	fx.In
+	Mctx helpers.MetricsCtx
+	Lc   fx.Lifecycle
+	Host host.Host
+	Nn   dtypes.NetworkName
+	Bp   dtypes.BootstrapPeers
+	Db   dtypes.DrandBootstrap
+	Cfg  *config.Pubsub
+	Sk   *dtypes.ScoreKeeper
+	Dr   dtypes.DrandSchedule
+}
+
+func getDrandTopic(chainInfoJSON string) (string, error) {
+	var drandInfo = struct {
+		Hash string `json:"hash"`
+	}{}
+	err := json.Unmarshal([]byte(chainInfoJSON), &drandInfo)
+	if err != nil {
+		return "", xerrors.Errorf("could not unmarshal drand chain info: %w", err)
+	}
+	return "/drand/pubsub/v0.0.0/" + drandInfo.Hash, nil
+}
+
+func GossipSub(in GossipIn) (service *pubsub.PubSub, err error) {
+	bootstrappers := make(map[peer.ID]struct{})
+	for _, pi := range in.Bp {
+		bootstrappers[pi.ID] = struct{}{}
+	}
+	drandBootstrappers := make(map[peer.ID]struct{})
+	for _, pi := range in.Db {
+		drandBootstrappers[pi.ID] = struct{}{}
+	}
+
+	isBootstrapNode := in.Cfg.Bootstrapper
+
+	drandTopicParams := &pubsub.TopicScoreParams{
+		// expected 2 beaconsn/min
+		TopicWeight: 0.5, // 5x block topic; max cap is 62.5
+
+		// 1 tick per second, maxes at 1 after 1 hour
+		TimeInMeshWeight:  0.00027, // ~1/3600
+		TimeInMeshQuantum: time.Second,
+		TimeInMeshCap:     1,
+
+		// deliveries decay after 1 hour, cap at 25 beacons
+		FirstMessageDeliveriesWeight: 5, // max value is 125
+		FirstMessageDeliveriesDecay:  pubsub.ScoreParameterDecay(time.Hour),
+		FirstMessageDeliveriesCap:    25, // the maximum expected in an hour is ~26, including the decay
+
+		// Mesh Delivery Failure is currently turned off for beacons
+		// This is on purpose as
+		// - the traffic is very low for meaningful distribution of incoming edges.
+		// - the reaction time needs to be very slow -- in the order of 10 min at least
+		//   so we might as well let opportunistic grafting repair the mesh on its own
+		//   pace.
+		// - the network is too small, so large asymmetries can be expected between mesh
+		//   edges.
+		// We should revisit this once the network grows.
+
+		// invalid messages decay after 1 hour
+		InvalidMessageDeliveriesWeight: -1000,
+		InvalidMessageDeliveriesDecay:  pubsub.ScoreParameterDecay(time.Hour),
+	}
+
+	topicParams := map[string]*pubsub.TopicScoreParams{
+		build.BlocksTopic(in.Nn): {
+			// expected 10 blocks/min
+			TopicWeight: 0.1, // max cap is 50, max mesh penalty is -10, single invalid message is -100
+
+			// 1 tick per second, maxes at 1 after 1 hour
+			TimeInMeshWeight:  0.00027, // ~1/3600
+			TimeInMeshQuantum: time.Second,
+			TimeInMeshCap:     1,
+
+			// deliveries decay after 1 hour, cap at 100 blocks
+			FirstMessageDeliveriesWeight: 5, // max value is 500
+			FirstMessageDeliveriesDecay:  pubsub.ScoreParameterDecay(time.Hour),
+			FirstMessageDeliveriesCap:    100, // 100 blocks in an hour
+
+			// Mesh Delivery Failure is currently turned off for blocks
+			// This is on purpose as
+			// - the traffic is very low for meaningful distribution of incoming edges.
+			// - the reaction time needs to be very slow -- in the order of 10 min at least
+			//   so we might as well let opportunistic grafting repair the mesh on its own
+			//   pace.
+			// - the network is too small, so large asymmetries can be expected between mesh
+			//   edges.
+			// We should revisit this once the network grows.
+			//
+			// // tracks deliveries in the last minute
+			// // penalty activates at 1 minute and expects ~0.4 blocks
+			// MeshMessageDeliveriesWeight:     -576, // max penalty is -100
+			// MeshMessageDeliveriesDecay:      pubsub.ScoreParameterDecay(time.Minute),
+			// MeshMessageDeliveriesCap:        10,      // 10 blocks in a minute
+			// MeshMessageDeliveriesThreshold:  0.41666, // 10/12/2 blocks/min
+			// MeshMessageDeliveriesWindow:     10 * time.Millisecond,
+			// MeshMessageDeliveriesActivation: time.Minute,
+			//
+			// // decays after 15 min
+			// MeshFailurePenaltyWeight: -576,
+			// MeshFailurePenaltyDecay:  pubsub.ScoreParameterDecay(15 * time.Minute),
+
+			// invalid messages decay after 1 hour
+			InvalidMessageDeliveriesWeight: -1000,
+			InvalidMessageDeliveriesDecay:  pubsub.ScoreParameterDecay(time.Hour),
+		},
+		build.MessagesTopic(in.Nn): {
+			// expected > 1 tx/second
+			TopicWeight: 0.1, // max cap is 5, single invalid message is -100
+
+			// 1 tick per second, maxes at 1 hour
+			TimeInMeshWeight:  0.0002778, // ~1/3600
+			TimeInMeshQuantum: time.Second,
+			TimeInMeshCap:     1,
+
+			// deliveries decay after 10min, cap at 100 tx
+			FirstMessageDeliveriesWeight: 0.5, // max value is 50
+			FirstMessageDeliveriesDecay:  pubsub.ScoreParameterDecay(10 * time.Minute),
+			FirstMessageDeliveriesCap:    100, // 100 messages in 10 minutes
+
+			// Mesh Delivery Failure is currently turned off for messages
+			// This is on purpose as the network is still too small, which results in
+			// asymmetries and potential unmeshing from negative scores.
+			// // tracks deliveries in the last minute
+			// // penalty activates at 1 min and expects 2.5 txs
+			// MeshMessageDeliveriesWeight:     -16, // max penalty is -100
+			// MeshMessageDeliveriesDecay:      pubsub.ScoreParameterDecay(time.Minute),
+			// MeshMessageDeliveriesCap:        100, // 100 txs in a minute
+			// MeshMessageDeliveriesThreshold:  2.5, // 60/12/2 txs/minute
+			// MeshMessageDeliveriesWindow:     10 * time.Millisecond,
+			// MeshMessageDeliveriesActivation: time.Minute,
+
+			// // decays after 5min
+			// MeshFailurePenaltyWeight: -16,
+			// MeshFailurePenaltyDecay:  pubsub.ScoreParameterDecay(5 * time.Minute),
+
+			// invalid messages decay after 1 hour
+			InvalidMessageDeliveriesWeight: -1000,
+			InvalidMessageDeliveriesDecay:  pubsub.ScoreParameterDecay(time.Hour),
+		},
+	}
+
+	pgTopicWeights := map[string]float64{
+		build.BlocksTopic(in.Nn):   10,
+		build.MessagesTopic(in.Nn): 1,
+	}
+
+	for _, d := range in.Dr {
+		topic, err := getDrandTopic(d.Config.ChainInfoJSON)
 		if err != nil {
-			panic(err)
+			return nil, err
+		}
+		topicParams[topic] = drandTopicParams
+		pgTopicWeights[topic] = 5
+	}
+
+	options := []pubsub.Option{
+		// Gossipsubv1.1 configuration
+		pubsub.WithFloodPublish(true),
+		pubsub.WithMessageIdFn(HashMsgId),
+		pubsub.WithPeerScore(
+			&pubsub.PeerScoreParams{
+				AppSpecificScore: func(p peer.ID) float64 {
+					// return a heavy positive score for bootstrappers so that we don't unilaterally prune
+					// them and accept PX from them.
+					// we don't do that in the bootstrappers themselves to avoid creating a closed mesh
+					// between them (however we might want to consider doing just that)
+					_, ok := bootstrappers[p]
+					if ok && !isBootstrapNode {
+						return 2500
+					}
+
+					_, ok = drandBootstrappers[p]
+					if ok && !isBootstrapNode {
+						return 1500
+					}
+
+					// TODO: we want to  plug the application specific score to the node itself in order
+					//       to provide feedback to the pubsub system based on observed behaviour
+					return 0
+				},
+				AppSpecificWeight: 1,
+
+				// This sets the IP colocation threshold to 1 peer per
+				IPColocationFactorThreshold: 1,
+				IPColocationFactorWeight:    -100,
+				// TODO we want to whitelist IPv6 /64s that belong to datacenters etc
+				// IPColocationFactorWhitelist: map[string]struct{}{},
+
+				// P7: behavioural penalties, decay after 1hr
+				BehaviourPenaltyThreshold: 6,
+				BehaviourPenaltyWeight:    -10,
+				BehaviourPenaltyDecay:     pubsub.ScoreParameterDecay(time.Hour),
+
+				DecayInterval: pubsub.DefaultDecayInterval,
+				DecayToZero:   pubsub.DefaultDecayToZero,
+
+				// this retains non-positive scores for 6 hours
+				RetainScore: 6 * time.Hour,
+
+				// topic parameters
+				Topics: topicParams,
+			},
+			&pubsub.PeerScoreThresholds{
+				GossipThreshold:             -500,
+				PublishThreshold:            -1000,
+				GraylistThreshold:           -2500,
+				AcceptPXThreshold:           1000,
+				OpportunisticGraftThreshold: 3.5,
+			},
+		),
+		pubsub.WithPeerScoreInspect(in.Sk.Update, 10*time.Second),
+	}
+
+	// enable Peer eXchange on bootstrappers
+	if isBootstrapNode {
+		// turn off the mesh in bootstrappers -- only do gossip and PX
+		pubsub.GossipSubD = 0
+		pubsub.GossipSubDscore = 0
+		pubsub.GossipSubDlo = 0
+		pubsub.GossipSubDhi = 0
+		pubsub.GossipSubDout = 0
+		pubsub.GossipSubDlazy = 64
+		pubsub.GossipSubGossipFactor = 0.25
+		pubsub.GossipSubPruneBackoff = 5 * time.Minute
+		// turn on PX
+		options = append(options, pubsub.WithPeerExchange(true))
+	}
+
+	// direct peers
+	if in.Cfg.DirectPeers != nil {
+		var directPeerInfo []peer.AddrInfo
+
+		for _, addr := range in.Cfg.DirectPeers {
+			a, err := ma.NewMultiaddr(addr)
+			if err != nil {
+				return nil, err
+			}
+
+			pi, err := peer.AddrInfoFromP2pAddr(a)
+			if err != nil {
+				return nil, err
+			}
+
+			directPeerInfo = append(directPeerInfo, *pi)
 		}
 
-		tr, err := pubsub.NewRemoteTracer(context.TODO(), host, *pi)
+		options = append(options, pubsub.WithDirectPeers(directPeerInfo))
+	}
+
+	// validation queue RED
+	var pgParams *pubsub.PeerGaterParams
+
+	if isBootstrapNode {
+		pgParams = pubsub.NewPeerGaterParams(
+			0.33,
+			pubsub.ScoreParameterDecay(2*time.Minute),
+			pubsub.ScoreParameterDecay(10*time.Minute),
+		).WithTopicDeliveryWeights(pgTopicWeights)
+	} else {
+		pgParams = pubsub.NewPeerGaterParams(
+			0.33,
+			pubsub.ScoreParameterDecay(2*time.Minute),
+			pubsub.ScoreParameterDecay(time.Hour),
+		).WithTopicDeliveryWeights(pgTopicWeights)
+	}
+
+	options = append(options, pubsub.WithPeerGater(pgParams))
+
+	// tracer
+	if in.Cfg.RemoteTracer != "" {
+		a, err := ma.NewMultiaddr(in.Cfg.RemoteTracer)
 		if err != nil {
-			panic(err)
+			return nil, err
 		}
 
-		return pubsub.WithEventTracer(tr)
+		pi, err := peer.AddrInfoFromP2pAddr(a)
+		if err != nil {
+			return nil, err
+		}
+
+		tr, err := pubsub.NewRemoteTracer(context.TODO(), in.Host, *pi)
+		if err != nil {
+			return nil, err
+		}
+
+		trw := newTracerWrapper(tr, build.BlocksTopic(in.Nn))
+		options = append(options, pubsub.WithEventTracer(trw))
+	} else {
+		// still instantiate a tracer for collecting metrics
+		trw := newTracerWrapper(nil)
+		options = append(options, pubsub.WithEventTracer(trw))
 	}
+
+	return pubsub.NewGossipSub(helpers.LifecycleCtx(in.Mctx, in.Lc), in.Host, options...)
 }
 
-func GossipSub(pubsubOptions ...PubsubOpt) interface{} {
-	return func(mctx helpers.MetricsCtx, lc fx.Lifecycle, host host.Host) (service *pubsub.PubSub, err error) {
-		return pubsub.NewGossipSub(helpers.LifecycleCtx(mctx, lc), host, paresOpts(host, pubsubOptions)...)
-	}
+func HashMsgId(m *pubsub_pb.Message) string {
+	hash := blake2b.Sum256(m.Data)
+	return string(hash[:])
 }
 
-func paresOpts(host host.Host, in []PubsubOpt) []pubsub.Option {
-	out := make([]pubsub.Option, len(in))
-	for k, v := range in {
-		out[k] = v(host)
+func newTracerWrapper(tr pubsub.EventTracer, topics ...string) pubsub.EventTracer {
+	var topicsMap map[string]struct{}
+	if len(topics) > 0 {
+		topicsMap = make(map[string]struct{})
+		for _, topic := range topics {
+			topicsMap[topic] = struct{}{}
+		}
+	}
+
+	return &tracerWrapper{tr: tr, topics: topicsMap}
+}
+
+type tracerWrapper struct {
+	tr     pubsub.EventTracer
+	topics map[string]struct{}
+}
+
+func (trw *tracerWrapper) traceMessage(topics []string) bool {
+	for _, topic := range topics {
+		_, ok := trw.topics[topic]
+		if ok {
+			return true
+		}
+	}
+	return false
+}
+
+func (trw *tracerWrapper) Trace(evt *pubsub_pb.TraceEvent) {
+	// this filters the trace events reported to the remote tracer to include only
+	// JOIN/LEAVE/GRAFT/PRUNE/PUBLISH/DELIVER. This significantly reduces bandwidth usage and still
+	// collects enough data to recover the state of the mesh and compute message delivery latency
+	// distributions.
+	// Furthermore, we only trace message publication and deliveries for specified topics
+	// (here just the blocks topic).
+	switch evt.GetType() {
+	case pubsub_pb.TraceEvent_PUBLISH_MESSAGE:
+		stats.Record(context.TODO(), metrics.PubsubPublishMessage.M(1))
+		if trw.tr != nil && trw.traceMessage(evt.GetPublishMessage().Topics) {
+			trw.tr.Trace(evt)
+		}
+	case pubsub_pb.TraceEvent_DELIVER_MESSAGE:
+		stats.Record(context.TODO(), metrics.PubsubDeliverMessage.M(1))
+		if trw.tr != nil && trw.traceMessage(evt.GetDeliverMessage().Topics) {
+			trw.tr.Trace(evt)
+		}
+	case pubsub_pb.TraceEvent_REJECT_MESSAGE:
+		stats.Record(context.TODO(), metrics.PubsubRejectMessage.M(1))
+	case pubsub_pb.TraceEvent_DUPLICATE_MESSAGE:
+		stats.Record(context.TODO(), metrics.PubsubDuplicateMessage.M(1))
+	case pubsub_pb.TraceEvent_JOIN:
+		if trw.tr != nil {
+			trw.tr.Trace(evt)
+		}
+	case pubsub_pb.TraceEvent_LEAVE:
+		if trw.tr != nil {
+			trw.tr.Trace(evt)
+		}
+	case pubsub_pb.TraceEvent_GRAFT:
+		if trw.tr != nil {
+			trw.tr.Trace(evt)
+		}
+	case pubsub_pb.TraceEvent_PRUNE:
+		if trw.tr != nil {
+			trw.tr.Trace(evt)
+		}
+	case pubsub_pb.TraceEvent_RECV_RPC:
+		stats.Record(context.TODO(), metrics.PubsubRecvRPC.M(1))
+	case pubsub_pb.TraceEvent_SEND_RPC:
+		stats.Record(context.TODO(), metrics.PubsubSendRPC.M(1))
+	case pubsub_pb.TraceEvent_DROP_RPC:
+		stats.Record(context.TODO(), metrics.PubsubDropRPC.M(1))
 	}
-	return out
 }
diff --git a/node/modules/lp2p/relay.go b/node/modules/lp2p/relay.go
index 10e776c83..a6bedb12b 100644
--- a/node/modules/lp2p/relay.go
+++ b/node/modules/lp2p/relay.go
@@ -4,29 +4,15 @@ import (
 	"fmt"
 
 	"github.com/libp2p/go-libp2p"
-	circuit "github.com/libp2p/go-libp2p-circuit"
 	coredisc "github.com/libp2p/go-libp2p-core/discovery"
 	routing "github.com/libp2p/go-libp2p-core/routing"
 	discovery "github.com/libp2p/go-libp2p-discovery"
-	basichost "github.com/libp2p/go-libp2p/p2p/host/basic"
-	relay "github.com/libp2p/go-libp2p/p2p/host/relay"
-	"go.uber.org/fx"
-
-	"github.com/filecoin-project/lotus/node/modules/helpers"
 )
 
-func Relay(disable, enableHop bool) func() (opts Libp2pOpts, err error) {
+func NoRelay() func() (opts Libp2pOpts, err error) {
 	return func() (opts Libp2pOpts, err error) {
-		if disable {
-			// Enabled by default.
-			opts.Opts = append(opts.Opts, libp2p.DisableRelay())
-		} else {
-			relayOpts := []circuit.RelayOpt{circuit.OptDiscovery}
-			if enableHop {
-				relayOpts = append(relayOpts, circuit.OptHop)
-			}
-			opts.Opts = append(opts.Opts, libp2p.EnableRelay(relayOpts...))
-		}
+		// always disabled, it's an eclipse attack vector
+		opts.Opts = append(opts.Opts, libp2p.DisableRelay())
 		return
 	}
 }
@@ -40,17 +26,3 @@ func Discovery(router BaseIpfsRouting) (coredisc.Discovery, error) {
 
 	return discovery.NewRoutingDiscovery(crouter), nil
 }
-
-// NOTE: only set when relayHop is set
-func AdvertiseRelay(mctx helpers.MetricsCtx, d coredisc.Discovery) {
-	relay.Advertise(mctx, d)
-}
-
-// NOTE: only set when relayHop is not set
-func AutoRelay(mctx helpers.MetricsCtx, lc fx.Lifecycle, router BaseIpfsRouting, h RawHost, d coredisc.Discovery) error {
-	ctx := helpers.LifecycleCtx(mctx, lc)
-
-	// TODO: review: LibP2P doesn't set this as host in config.go, why?
-	_ = relay.NewAutoRelay(ctx, h.(*basichost.BasicHost), d, router)
-	return nil
-}
diff --git a/node/modules/lp2p/transport.go b/node/modules/lp2p/transport.go
index e4bb515fc..5ea2d1c83 100644
--- a/node/modules/lp2p/transport.go
+++ b/node/modules/lp2p/transport.go
@@ -3,8 +3,8 @@ package lp2p
 import (
 	"github.com/libp2p/go-libp2p"
 	metrics "github.com/libp2p/go-libp2p-core/metrics"
+	noise "github.com/libp2p/go-libp2p-noise"
 	libp2pquic "github.com/libp2p/go-libp2p-quic-transport"
-	secio "github.com/libp2p/go-libp2p-secio"
 	tls "github.com/libp2p/go-libp2p-tls"
 )
 
@@ -15,7 +15,7 @@ func Security(enabled, preferTLS bool) interface{} {
 	if !enabled {
 		return func() (opts Libp2pOpts) {
 			// TODO: shouldn't this be Errorf to guarantee visibility?
-			log.Warnf(`Your IPFS node has been configured to run WITHOUT ENCRYPTED CONNECTIONS.
+			log.Warnf(`Your lotus node has been configured to run WITHOUT ENCRYPTED CONNECTIONS.
 		You will not be able to connect to any nodes configured to use encrypted connections`)
 			opts.Opts = append(opts.Opts, libp2p.NoSecurity)
 			return opts
@@ -23,9 +23,9 @@ func Security(enabled, preferTLS bool) interface{} {
 	}
 	return func() (opts Libp2pOpts) {
 		if preferTLS {
-			opts.Opts = append(opts.Opts, libp2p.ChainOptions(libp2p.Security(tls.ID, tls.New), libp2p.Security(secio.ID, secio.New)))
+			opts.Opts = append(opts.Opts, libp2p.ChainOptions(libp2p.Security(tls.ID, tls.New), libp2p.Security(noise.ID, noise.New)))
 		} else {
-			opts.Opts = append(opts.Opts, libp2p.ChainOptions(libp2p.Security(secio.ID, secio.New), libp2p.Security(tls.ID, tls.New)))
+			opts.Opts = append(opts.Opts, libp2p.ChainOptions(libp2p.Security(noise.ID, noise.New), libp2p.Security(tls.ID, tls.New)))
 		}
 		return opts
 	}
diff --git a/node/modules/services.go b/node/modules/services.go
index 92b6264e8..7bef434be 100644
--- a/node/modules/services.go
+++ b/node/modules/services.go
@@ -3,83 +3,167 @@ package modules
 import (
 	"context"
 
+	"github.com/ipfs/go-datastore"
+	"github.com/ipfs/go-datastore/namespace"
+	eventbus "github.com/libp2p/go-eventbus"
+	event "github.com/libp2p/go-libp2p-core/event"
 	"github.com/libp2p/go-libp2p-core/host"
-	inet "github.com/libp2p/go-libp2p-core/network"
+	"github.com/libp2p/go-libp2p-core/peer"
 	pubsub "github.com/libp2p/go-libp2p-pubsub"
 	"go.uber.org/fx"
+	"golang.org/x/xerrors"
 
+	"github.com/filecoin-project/go-fil-markets/retrievalmarket"
+	"github.com/filecoin-project/go-fil-markets/retrievalmarket/discovery"
+	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain"
-	"github.com/filecoin-project/lotus/chain/blocksync"
-	"github.com/filecoin-project/lotus/chain/deals"
+	"github.com/filecoin-project/lotus/chain/beacon"
+	"github.com/filecoin-project/lotus/chain/beacon/drand"
+	"github.com/filecoin-project/lotus/chain/exchange"
 	"github.com/filecoin-project/lotus/chain/messagepool"
+	"github.com/filecoin-project/lotus/chain/stmgr"
+	"github.com/filecoin-project/lotus/chain/store"
 	"github.com/filecoin-project/lotus/chain/sub"
+	"github.com/filecoin-project/lotus/journal"
+	"github.com/filecoin-project/lotus/lib/peermgr"
 	"github.com/filecoin-project/lotus/node/hello"
+	"github.com/filecoin-project/lotus/node/modules/dtypes"
 	"github.com/filecoin-project/lotus/node/modules/helpers"
-	"github.com/filecoin-project/lotus/peermgr"
-	"github.com/filecoin-project/lotus/retrieval/discovery"
+	"github.com/filecoin-project/lotus/node/repo"
 )
 
-func RunHello(mctx helpers.MetricsCtx, lc fx.Lifecycle, h host.Host, svc *hello.Service) {
+func RunHello(mctx helpers.MetricsCtx, lc fx.Lifecycle, h host.Host, svc *hello.Service) error {
 	h.SetStreamHandler(hello.ProtocolID, svc.HandleStream)
 
-	bundle := inet.NotifyBundle{
-		ConnectedF: func(_ inet.Network, c inet.Conn) {
+	sub, err := h.EventBus().Subscribe(new(event.EvtPeerIdentificationCompleted), eventbus.BufSize(1024))
+	if err != nil {
+		return xerrors.Errorf("failed to subscribe to event bus: %w", err)
+	}
+
+	go func() {
+		for evt := range sub.Out() {
+			pic := evt.(event.EvtPeerIdentificationCompleted)
 			go func() {
-				if err := svc.SayHello(helpers.LifecycleCtx(mctx, lc), c.RemotePeer()); err != nil {
-					log.Warnw("failed to say hello", "error", err)
+				if err := svc.SayHello(helpers.LifecycleCtx(mctx, lc), pic.Peer); err != nil {
+					protos, _ := h.Peerstore().GetProtocols(pic.Peer)
+					agent, _ := h.Peerstore().Get(pic.Peer, "AgentVersion")
+					if protosContains(protos, hello.ProtocolID) {
+						log.Warnw("failed to say hello", "error", err, "peer", pic.Peer, "supported", protos, "agent", agent)
+					} else {
+						log.Debugw("failed to say hello", "error", err, "peer", pic.Peer, "supported", protos, "agent", agent)
+					}
 					return
 				}
 			}()
-		},
+		}
+	}()
+	return nil
+}
+
+func protosContains(protos []string, search string) bool {
+	for _, p := range protos {
+		if p == search {
+			return true
+		}
 	}
-	h.Network().Notify(&bundle)
+	return false
 }
 
 func RunPeerMgr(mctx helpers.MetricsCtx, lc fx.Lifecycle, pmgr *peermgr.PeerMgr) {
 	go pmgr.Run(helpers.LifecycleCtx(mctx, lc))
 }
 
-func RunBlockSync(h host.Host, svc *blocksync.BlockSyncService) {
-	h.SetStreamHandler(blocksync.BlockSyncProtocolID, svc.HandleStream)
+func RunChainExchange(h host.Host, svc exchange.Server) {
+	h.SetStreamHandler(exchange.BlockSyncProtocolID, svc.HandleStream)     // old
+	h.SetStreamHandler(exchange.ChainExchangeProtocolID, svc.HandleStream) // new
 }
 
-func HandleIncomingBlocks(mctx helpers.MetricsCtx, lc fx.Lifecycle, pubsub *pubsub.PubSub, s *chain.Syncer, h host.Host) {
+func HandleIncomingBlocks(mctx helpers.MetricsCtx, lc fx.Lifecycle, ps *pubsub.PubSub, s *chain.Syncer, bserv dtypes.ChainBlockService, chain *store.ChainStore, stmgr *stmgr.StateManager, h host.Host, nn dtypes.NetworkName) {
 	ctx := helpers.LifecycleCtx(mctx, lc)
 
-	blocksub, err := pubsub.Subscribe("/fil/blocks")
+	blocksub, err := ps.Subscribe(build.BlocksTopic(nn)) //nolint
 	if err != nil {
 		panic(err)
 	}
 
-	go sub.HandleIncomingBlocks(ctx, blocksub, s, h.ConnManager())
+	v := sub.NewBlockValidator(
+		h.ID(), chain, stmgr,
+		func(p peer.ID) {
+			ps.BlacklistPeer(p)
+			h.ConnManager().TagPeer(p, "badblock", -1000)
+		})
+
+	if err := ps.RegisterTopicValidator(build.BlocksTopic(nn), v.Validate); err != nil {
+		panic(err)
+	}
+
+	go sub.HandleIncomingBlocks(ctx, blocksub, s, bserv, h.ConnManager())
 }
 
-func HandleIncomingMessages(mctx helpers.MetricsCtx, lc fx.Lifecycle, pubsub *pubsub.PubSub, mpool *messagepool.MessagePool) {
+func HandleIncomingMessages(mctx helpers.MetricsCtx, lc fx.Lifecycle, ps *pubsub.PubSub, mpool *messagepool.MessagePool, h host.Host, nn dtypes.NetworkName) {
 	ctx := helpers.LifecycleCtx(mctx, lc)
 
-	msgsub, err := pubsub.Subscribe("/fil/messages")
+	msgsub, err := ps.Subscribe(build.MessagesTopic(nn)) //nolint:staticcheck
 	if err != nil {
 		panic(err)
 	}
 
+	v := sub.NewMessageValidator(h.ID(), mpool)
+
+	if err := ps.RegisterTopicValidator(build.MessagesTopic(nn), v.Validate); err != nil {
+		panic(err)
+	}
+
 	go sub.HandleIncomingMessages(ctx, mpool, msgsub)
 }
 
-func RunDealClient(mctx helpers.MetricsCtx, lc fx.Lifecycle, c *deals.Client) {
-	ctx := helpers.LifecycleCtx(mctx, lc)
-
-	lc.Append(fx.Hook{
-		OnStart: func(context.Context) error {
-			c.Run(ctx)
-			return nil
-		},
-		OnStop: func(context.Context) error {
-			c.Stop()
-			return nil
-		},
-	})
+func NewLocalDiscovery(ds dtypes.MetadataDS) *discovery.Local {
+	return discovery.NewLocal(namespace.Wrap(ds, datastore.NewKey("/deals/local")))
 }
 
-func RetrievalResolver(l *discovery.Local) discovery.PeerResolver {
+func RetrievalResolver(l *discovery.Local) retrievalmarket.PeerResolver {
 	return discovery.Multi(l)
 }
+
+type RandomBeaconParams struct {
+	fx.In
+
+	PubSub      *pubsub.PubSub `optional:"true"`
+	Cs          *store.ChainStore
+	DrandConfig dtypes.DrandSchedule
+}
+
+func BuiltinDrandConfig() dtypes.DrandSchedule {
+	return build.DrandConfigSchedule()
+}
+
+func RandomSchedule(p RandomBeaconParams, _ dtypes.AfterGenesisSet) (beacon.Schedule, error) {
+	gen, err := p.Cs.GetGenesis()
+	if err != nil {
+		return nil, err
+	}
+
+	shd := beacon.Schedule{}
+	for _, dc := range p.DrandConfig {
+		bc, err := drand.NewDrandBeacon(gen.Timestamp, build.BlockDelaySecs, p.PubSub, dc.Config)
+		if err != nil {
+			return nil, xerrors.Errorf("creating drand beacon: %w", err)
+		}
+		shd = append(shd, beacon.BeaconPoint{Start: dc.Start, Beacon: bc})
+	}
+
+	return shd, nil
+}
+
+func OpenFilesystemJournal(lr repo.LockedRepo, lc fx.Lifecycle, disabled journal.DisabledEvents) (journal.Journal, error) {
+	jrnl, err := journal.OpenFSJournal(lr, disabled)
+	if err != nil {
+		return nil, err
+	}
+
+	lc.Append(fx.Hook{
+		OnStop: func(_ context.Context) error { return jrnl.Close() },
+	})
+
+	return jrnl, err
+}
diff --git a/node/modules/storageminer.go b/node/modules/storageminer.go
index 436686995..de466b004 100644
--- a/node/modules/storageminer.go
+++ b/node/modules/storageminer.go
@@ -2,39 +2,74 @@ package modules
 
 import (
 	"context"
-	"math"
-	"reflect"
+	"errors"
+	"fmt"
+	"net/http"
+	"time"
+
+	"go.uber.org/fx"
+	"go.uber.org/multierr"
+	"golang.org/x/xerrors"
 
-	paramfetch "github.com/filecoin-project/go-paramfetch"
 	"github.com/ipfs/go-bitswap"
 	"github.com/ipfs/go-bitswap/network"
 	"github.com/ipfs/go-blockservice"
+	"github.com/ipfs/go-cid"
 	"github.com/ipfs/go-datastore"
 	"github.com/ipfs/go-datastore/namespace"
-	blockstore "github.com/ipfs/go-ipfs-blockstore"
+	graphsync "github.com/ipfs/go-graphsync/impl"
+	gsnet "github.com/ipfs/go-graphsync/network"
+	"github.com/ipfs/go-graphsync/storeutil"
 	"github.com/ipfs/go-merkledag"
 	"github.com/libp2p/go-libp2p-core/host"
 	"github.com/libp2p/go-libp2p-core/routing"
-	"github.com/mitchellh/go-homedir"
-	"go.uber.org/fx"
-	"golang.org/x/xerrors"
 
 	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-sectorbuilder"
-	"github.com/filecoin-project/go-statestore"
-	"github.com/filecoin-project/lotus/api"
+	dtimpl "github.com/filecoin-project/go-data-transfer/impl"
+	dtnet "github.com/filecoin-project/go-data-transfer/network"
+	dtgstransport "github.com/filecoin-project/go-data-transfer/transport/graphsync"
+	piecefilestore "github.com/filecoin-project/go-fil-markets/filestore"
+	"github.com/filecoin-project/go-fil-markets/piecestore"
+	"github.com/filecoin-project/go-fil-markets/retrievalmarket"
+	retrievalimpl "github.com/filecoin-project/go-fil-markets/retrievalmarket/impl"
+	rmnet "github.com/filecoin-project/go-fil-markets/retrievalmarket/network"
+	"github.com/filecoin-project/go-fil-markets/storagemarket"
+	storageimpl "github.com/filecoin-project/go-fil-markets/storagemarket/impl"
+	"github.com/filecoin-project/go-fil-markets/storagemarket/impl/funds"
+	"github.com/filecoin-project/go-fil-markets/storagemarket/impl/storedask"
+	smnet "github.com/filecoin-project/go-fil-markets/storagemarket/network"
+	"github.com/filecoin-project/go-jsonrpc/auth"
+	"github.com/filecoin-project/go-multistore"
+	paramfetch "github.com/filecoin-project/go-paramfetch"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-storedcounter"
+
+	sectorstorage "github.com/filecoin-project/lotus/extern/sector-storage"
+	"github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper"
+	"github.com/filecoin-project/lotus/extern/sector-storage/stores"
+	sealing "github.com/filecoin-project/lotus/extern/storage-sealing"
+	"github.com/filecoin-project/lotus/extern/storage-sealing/sealiface"
+	"github.com/filecoin-project/lotus/journal"
+	"github.com/filecoin-project/lotus/markets"
+
+	lapi "github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/build"
-	"github.com/filecoin-project/lotus/chain/deals"
 	"github.com/filecoin-project/lotus/chain/gen"
-	"github.com/filecoin-project/lotus/datatransfer"
+	"github.com/filecoin-project/lotus/chain/gen/slashfilter"
+	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/lib/blockstore"
+	marketevents "github.com/filecoin-project/lotus/markets/loggers"
+	"github.com/filecoin-project/lotus/markets/retrievaladapter"
 	"github.com/filecoin-project/lotus/miner"
+	"github.com/filecoin-project/lotus/node/config"
 	"github.com/filecoin-project/lotus/node/modules/dtypes"
 	"github.com/filecoin-project/lotus/node/modules/helpers"
 	"github.com/filecoin-project/lotus/node/repo"
-	"github.com/filecoin-project/lotus/retrieval"
 	"github.com/filecoin-project/lotus/storage"
 )
 
+var StorageCounterDSPrefix = "/storage/nextid"
+
 func minerAddrFromDS(ds dtypes.MetadataDS) (address.Address, error) {
 	maddrb, err := ds.Get(datastore.NewKey("miner-address"))
 	if err != nil {
@@ -44,137 +79,249 @@ func minerAddrFromDS(ds dtypes.MetadataDS) (address.Address, error) {
 	return address.NewFromBytes(maddrb)
 }
 
-func GetParams(sbc *sectorbuilder.Config) error {
-	if err := paramfetch.GetParams(build.ParametersJson, sbc.SectorSize); err != nil {
+func GetParams(sbc *ffiwrapper.Config) error {
+	ssize, err := sbc.SealProofType.SectorSize()
+	if err != nil {
+		return err
+	}
+
+	// If built-in assets are disabled, we expect the user to have placed the right
+	// parameters in the right location on the filesystem (/var/tmp/filecoin-proof-parameters).
+	if build.DisableBuiltinAssets {
+		return nil
+	}
+
+	if err := paramfetch.GetParams(context.TODO(), build.ParametersJSON(), uint64(ssize)); err != nil {
 		return xerrors.Errorf("fetching proof parameters: %w", err)
 	}
 
 	return nil
 }
 
-func SectorBuilderConfig(storagePath string, threads uint, noprecommit, nocommit bool) func(dtypes.MetadataDS, api.FullNode) (*sectorbuilder.Config, error) {
-	return func(ds dtypes.MetadataDS, api api.FullNode) (*sectorbuilder.Config, error) {
-		minerAddr, err := minerAddrFromDS(ds)
-		if err != nil {
-			return nil, err
-		}
-
-		ssize, err := api.StateMinerSectorSize(context.TODO(), minerAddr, nil)
-		if err != nil {
-			return nil, err
-		}
-
-		sp, err := homedir.Expand(storagePath)
-		if err != nil {
-			return nil, err
-		}
-
-		if threads > math.MaxUint8 {
-			return nil, xerrors.Errorf("too many sectorbuilder threads specified: %d, max allowed: %d", threads, math.MaxUint8)
-		}
-
-		sb := &sectorbuilder.Config{
-			Miner:      minerAddr,
-			SectorSize: ssize,
-
-			WorkerThreads: uint8(threads),
-			NoPreCommit:   noprecommit,
-			NoCommit:      nocommit,
-
-			Dir: sp,
-		}
-
-		return sb, nil
-	}
+func MinerAddress(ds dtypes.MetadataDS) (dtypes.MinerAddress, error) {
+	ma, err := minerAddrFromDS(ds)
+	return dtypes.MinerAddress(ma), err
 }
 
-func StorageMiner(mctx helpers.MetricsCtx, lc fx.Lifecycle, api api.FullNode, h host.Host, ds dtypes.MetadataDS, sb *sectorbuilder.SectorBuilder, tktFn storage.TicketFn) (*storage.Miner, error) {
-	maddr, err := minerAddrFromDS(ds)
+func MinerID(ma dtypes.MinerAddress) (dtypes.MinerID, error) {
+	id, err := address.IDFromAddress(address.Address(ma))
+	return dtypes.MinerID(id), err
+}
+
+func StorageNetworkName(ctx helpers.MetricsCtx, a lapi.FullNode) (dtypes.NetworkName, error) {
+	if !build.Devnet {
+		return "testnetnet", nil
+	}
+	return a.StateNetworkName(ctx)
+}
+
+func ProofsConfig(maddr dtypes.MinerAddress, fnapi lapi.FullNode) (*ffiwrapper.Config, error) {
+	mi, err := fnapi.StateMinerInfo(context.TODO(), address.Address(maddr), types.EmptyTSK)
 	if err != nil {
 		return nil, err
 	}
 
-	sm, err := storage.NewMiner(api, maddr, h, ds, sb, tktFn)
+	spt, err := ffiwrapper.SealProofTypeFromSectorSize(mi.SectorSize)
 	if err != nil {
-		return nil, err
+		return nil, xerrors.Errorf("bad sector size: %w", err)
 	}
 
-	ctx := helpers.LifecycleCtx(mctx, lc)
+	sb := &ffiwrapper.Config{
+		SealProofType: spt,
+	}
 
-	lc.Append(fx.Hook{
-		OnStart: func(context.Context) error {
-			return sm.Run(ctx)
-		},
-		OnStop: sm.Stop,
-	})
-
-	return sm, nil
+	return sb, nil
 }
 
-func HandleRetrieval(host host.Host, lc fx.Lifecycle, m *retrieval.Miner) {
-	lc.Append(fx.Hook{
-		OnStart: func(context.Context) error {
-			host.SetStreamHandler(retrieval.QueryProtocolID, m.HandleQueryStream)
-			host.SetStreamHandler(retrieval.ProtocolID, m.HandleDealStream)
-			return nil
-		},
-	})
+type sidsc struct {
+	sc *storedcounter.StoredCounter
 }
 
-func HandleDeals(mctx helpers.MetricsCtx, lc fx.Lifecycle, host host.Host, h *deals.Provider) {
-	ctx := helpers.LifecycleCtx(mctx, lc)
+func (s *sidsc) Next() (abi.SectorNumber, error) {
+	i, err := s.sc.Next()
+	return abi.SectorNumber(i), err
+}
 
+func SectorIDCounter(ds dtypes.MetadataDS) sealing.SectorIDCounter {
+	sc := storedcounter.New(ds, datastore.NewKey(StorageCounterDSPrefix))
+	return &sidsc{sc}
+}
+
+type StorageMinerParams struct {
+	fx.In
+
+	Lifecycle          fx.Lifecycle
+	MetricsCtx         helpers.MetricsCtx
+	API                lapi.FullNode
+	Host               host.Host
+	MetadataDS         dtypes.MetadataDS
+	Sealer             sectorstorage.SectorManager
+	SectorIDCounter    sealing.SectorIDCounter
+	Verifier           ffiwrapper.Verifier
+	GetSealingConfigFn dtypes.GetSealingConfigFunc
+}
+
+func StorageMiner(fc config.MinerFeeConfig) func(params StorageMinerParams) (*storage.Miner, error) {
+	return func(params StorageMinerParams) (*storage.Miner, error) {
+		var (
+			ds     = params.MetadataDS
+			mctx   = params.MetricsCtx
+			lc     = params.Lifecycle
+			api    = params.API
+			sealer = params.Sealer
+			h      = params.Host
+			sc     = params.SectorIDCounter
+			verif  = params.Verifier
+			gsd    = params.GetSealingConfigFn
+		)
+
+		maddr, err := minerAddrFromDS(ds)
+		if err != nil {
+			return nil, err
+		}
+
+		ctx := helpers.LifecycleCtx(mctx, lc)
+
+		mi, err := api.StateMinerInfo(ctx, maddr, types.EmptyTSK)
+		if err != nil {
+			return nil, err
+		}
+
+		worker, err := api.StateAccountKey(ctx, mi.Worker, types.EmptyTSK)
+		if err != nil {
+			return nil, err
+		}
+
+		fps, err := storage.NewWindowedPoStScheduler(api, fc, sealer, sealer, maddr, worker)
+		if err != nil {
+			return nil, err
+		}
+
+		sm, err := storage.NewMiner(api, maddr, worker, h, ds, sealer, sc, verif, gsd, fc)
+		if err != nil {
+			return nil, err
+		}
+
+		lc.Append(fx.Hook{
+			OnStart: func(context.Context) error {
+				go fps.Run(ctx)
+				return sm.Run(ctx)
+			},
+			OnStop: sm.Stop,
+		})
+
+		return sm, nil
+	}
+}
+
+func HandleRetrieval(host host.Host, lc fx.Lifecycle, m retrievalmarket.RetrievalProvider) {
 	lc.Append(fx.Hook{
 		OnStart: func(context.Context) error {
-			h.Run(ctx)
-			host.SetStreamHandler(deals.DealProtocolID, h.HandleStream)
-			host.SetStreamHandler(deals.AskProtocolID, h.HandleAskStream)
-			return nil
+			m.SubscribeToEvents(marketevents.RetrievalProviderLogger)
+
+			evtType := journal.J.RegisterEventType("markets/retrieval/provider", "state_change")
+			m.SubscribeToEvents(markets.RetrievalProviderJournaler(evtType))
+
+			return m.Start()
 		},
 		OnStop: func(context.Context) error {
-			h.Stop()
-			return nil
+			return m.Stop()
 		},
 	})
 }
 
-// RegisterProviderValidator is an initialization hook that registers the provider
-// request validator with the data transfer module as the validator for
-// StorageDataTransferVoucher types
-func RegisterProviderValidator(mrv *deals.ProviderRequestValidator, dtm dtypes.ProviderDataTransfer) {
-	if err := dtm.RegisterVoucherType(reflect.TypeOf(deals.StorageDataTransferVoucher{}), mrv); err != nil {
-		panic(err)
-	}
+func HandleDeals(mctx helpers.MetricsCtx, lc fx.Lifecycle, host host.Host, h storagemarket.StorageProvider) {
+	ctx := helpers.LifecycleCtx(mctx, lc)
+
+	lc.Append(fx.Hook{
+		OnStart: func(context.Context) error {
+			h.SubscribeToEvents(marketevents.StorageProviderLogger)
+
+			evtType := journal.J.RegisterEventType("markets/storage/provider", "state_change")
+			h.SubscribeToEvents(markets.StorageProviderJournaler(evtType))
+
+			return h.Start(ctx)
+		},
+		OnStop: func(context.Context) error {
+			return h.Stop()
+		},
+	})
 }
 
 // NewProviderDAGServiceDataTransfer returns a data transfer manager that just
 // uses the provider's Staging DAG service for transfers
-func NewProviderDAGServiceDataTransfer(dag dtypes.StagingDAG) dtypes.ProviderDataTransfer {
-	return datatransfer.NewDAGServiceDataTransfer(dag)
+func NewProviderDAGServiceDataTransfer(lc fx.Lifecycle, h host.Host, gs dtypes.StagingGraphsync, ds dtypes.MetadataDS) (dtypes.ProviderDataTransfer, error) {
+	sc := storedcounter.New(ds, datastore.NewKey("/datatransfer/provider/counter"))
+	net := dtnet.NewFromLibp2pHost(h)
+
+	dtDs := namespace.Wrap(ds, datastore.NewKey("/datatransfer/provider/transfers"))
+	transport := dtgstransport.NewTransport(h.ID(), gs)
+	dt, err := dtimpl.NewDataTransfer(dtDs, net, transport, sc)
+	if err != nil {
+		return nil, err
+	}
+
+	lc.Append(fx.Hook{
+		OnStart: func(ctx context.Context) error {
+			return dt.Start(ctx)
+		},
+		OnStop: func(ctx context.Context) error {
+			return dt.Stop(ctx)
+		},
+	})
+	return dt, nil
 }
 
-// NewProviderDealStore creates a statestore for the client to store its deals
-func NewProviderDealStore(ds dtypes.MetadataDS) dtypes.ProviderDealStore {
-	return statestore.New(namespace.Wrap(ds, datastore.NewKey("/deals/client")))
+// NewProviderPieceStore creates a statestore for storing metadata about pieces
+// shared by the storage and retrieval providers
+func NewProviderPieceStore(ds dtypes.MetadataDS) dtypes.ProviderPieceStore {
+	return piecestore.NewPieceStore(namespace.Wrap(ds, datastore.NewKey("/storagemarket")))
 }
 
-func StagingDAG(mctx helpers.MetricsCtx, lc fx.Lifecycle, r repo.LockedRepo, rt routing.Routing, h host.Host) (dtypes.StagingDAG, error) {
+func StagingMultiDatastore(lc fx.Lifecycle, r repo.LockedRepo) (dtypes.StagingMultiDstore, error) {
+	ds, err := r.Datastore("/staging")
+	if err != nil {
+		return nil, xerrors.Errorf("getting datastore out of reop: %w", err)
+	}
+
+	mds, err := multistore.NewMultiDstore(ds)
+	if err != nil {
+		return nil, err
+	}
+
+	lc.Append(fx.Hook{
+		OnStop: func(ctx context.Context) error {
+			return mds.Close()
+		},
+	})
+
+	return mds, nil
+}
+
+// StagingBlockstore creates a blockstore for staging blocks for a miner
+// in a storage deal, prior to sealing
+func StagingBlockstore(r repo.LockedRepo) (dtypes.StagingBlockstore, error) {
 	stagingds, err := r.Datastore("/staging")
 	if err != nil {
 		return nil, err
 	}
 
-	bs := blockstore.NewBlockstore(stagingds)
-	ibs := blockstore.NewIdStore(bs)
+	return blockstore.NewBlockstore(stagingds), nil
+}
+
+// StagingDAG is a DAGService for the StagingBlockstore
+func StagingDAG(mctx helpers.MetricsCtx, lc fx.Lifecycle, ibs dtypes.StagingBlockstore, rt routing.Routing, h host.Host) (dtypes.StagingDAG, error) {
 
 	bitswapNetwork := network.NewFromIpfsHost(h, rt)
-	exch := bitswap.New(helpers.LifecycleCtx(mctx, lc), bitswapNetwork, bs)
+	bitswapOptions := []bitswap.Option{bitswap.ProvideEnabled(false)}
+	exch := bitswap.New(mctx, bitswapNetwork, ibs, bitswapOptions...)
 
 	bsvc := blockservice.New(ibs, exch)
 	dag := merkledag.NewDAGService(bsvc)
 
 	lc.Append(fx.Hook{
 		OnStop: func(_ context.Context) error {
+			// blockservice closes the exchange
 			return bsvc.Close()
 		},
 	})
@@ -182,58 +329,384 @@ func StagingDAG(mctx helpers.MetricsCtx, lc fx.Lifecycle, r repo.LockedRepo, rt
 	return dag, nil
 }
 
-func SetupBlockProducer(lc fx.Lifecycle, ds dtypes.MetadataDS, api api.FullNode, epp gen.ElectionPoStProver) (*miner.Miner, error) {
+// StagingGraphsync creates a graphsync instance which reads and writes blocks
+// to the StagingBlockstore
+func StagingGraphsync(mctx helpers.MetricsCtx, lc fx.Lifecycle, ibs dtypes.StagingBlockstore, h host.Host) dtypes.StagingGraphsync {
+	graphsyncNetwork := gsnet.NewFromLibp2pHost(h)
+	loader := storeutil.LoaderForBlockstore(ibs)
+	storer := storeutil.StorerForBlockstore(ibs)
+	gs := graphsync.New(helpers.LifecycleCtx(mctx, lc), graphsyncNetwork, loader, storer, graphsync.RejectAllRequestsByDefault())
+
+	return gs
+}
+
+func SetupBlockProducer(lc fx.Lifecycle, ds dtypes.MetadataDS, api lapi.FullNode, epp gen.WinningPoStProver, sf *slashfilter.SlashFilter) (*miner.Miner, error) {
 	minerAddr, err := minerAddrFromDS(ds)
 	if err != nil {
 		return nil, err
 	}
 
-	m := miner.NewMiner(api, epp)
+	m := miner.NewMiner(api, epp, minerAddr, sf)
 
 	lc.Append(fx.Hook{
 		OnStart: func(ctx context.Context) error {
-			if err := m.Register(minerAddr); err != nil {
+			if err := m.Start(ctx); err != nil {
 				return err
 			}
 			return nil
 		},
 		OnStop: func(ctx context.Context) error {
-			return m.Unregister(ctx, minerAddr)
+			return m.Stop(ctx)
 		},
 	})
 
 	return m, nil
 }
 
-func SectorBuilder(cfg *sectorbuilder.Config, ds dtypes.MetadataDS) (*sectorbuilder.SectorBuilder, error) {
-	sb, err := sectorbuilder.New(cfg, namespace.Wrap(ds, datastore.NewKey("/sectorbuilder")))
+func NewStorageAsk(ctx helpers.MetricsCtx, fapi lapi.FullNode, ds dtypes.MetadataDS, minerAddress dtypes.MinerAddress, spn storagemarket.StorageProviderNode) (*storedask.StoredAsk, error) {
+
+	mi, err := fapi.StateMinerInfo(ctx, address.Address(minerAddress), types.EmptyTSK)
 	if err != nil {
 		return nil, err
 	}
 
-	return sb, nil
+	storedAsk, err := storedask.NewStoredAsk(namespace.Wrap(ds, datastore.NewKey("/deals/provider")), datastore.NewKey("latest-ask"), spn, address.Address(minerAddress))
+	if err != nil {
+		return nil, err
+	}
+	// Hacky way to set max piece size to the sector size
+	a := storedAsk.GetAsk().Ask
+	err = storedAsk.SetAsk(a.Price, a.VerifiedPrice, a.Expiry-a.Timestamp, storagemarket.MaxPieceSize(abi.PaddedPieceSize(mi.SectorSize)))
+	if err != nil {
+		return storedAsk, err
+	}
+	return storedAsk, nil
 }
 
-func SealTicketGen(api api.FullNode) storage.TicketFn {
-	return func(ctx context.Context) (*sectorbuilder.SealTicket, error) {
-		ts, err := api.ChainHead(ctx)
-		if err != nil {
-			return nil, xerrors.Errorf("getting head ts for SealTicket failed: %w", err)
-		}
+type ProviderDealFunds funds.DealFunds
 
-		r, err := api.ChainGetRandomness(ctx, ts.Key(), int64(ts.Height())-build.SealRandomnessLookback)
-		if err != nil {
-			return nil, xerrors.Errorf("getting randomness for SealTicket failed: %w", err)
-		}
+func NewProviderDealFunds(ds dtypes.MetadataDS) (ProviderDealFunds, error) {
+	return funds.NewDealFunds(ds, datastore.NewKey("/marketfunds/provider"))
+}
 
-		var tkt [sectorbuilder.CommLen]byte
-		if n := copy(tkt[:], r); n != sectorbuilder.CommLen {
-			return nil, xerrors.Errorf("unexpected randomness len: %d (expected %d)", n, sectorbuilder.CommLen)
-		}
+func BasicDealFilter(user dtypes.DealFilter) func(onlineOk dtypes.ConsiderOnlineStorageDealsConfigFunc,
+	offlineOk dtypes.ConsiderOfflineStorageDealsConfigFunc,
+	blocklistFunc dtypes.StorageDealPieceCidBlocklistConfigFunc,
+	expectedSealTimeFunc dtypes.GetExpectedSealDurationFunc,
+	spn storagemarket.StorageProviderNode) dtypes.DealFilter {
+	return func(onlineOk dtypes.ConsiderOnlineStorageDealsConfigFunc,
+		offlineOk dtypes.ConsiderOfflineStorageDealsConfigFunc,
+		blocklistFunc dtypes.StorageDealPieceCidBlocklistConfigFunc,
+		expectedSealTimeFunc dtypes.GetExpectedSealDurationFunc,
+		spn storagemarket.StorageProviderNode) dtypes.DealFilter {
 
-		return &sectorbuilder.SealTicket{
-			BlockHeight: ts.Height(),
-			TicketBytes: tkt,
-		}, nil
+		return func(ctx context.Context, deal storagemarket.MinerDeal) (bool, string, error) {
+			b, err := onlineOk()
+			if err != nil {
+				return false, "miner error", err
+			}
+
+			if deal.Ref != nil && deal.Ref.TransferType != storagemarket.TTManual && !b {
+				log.Warnf("online storage deal consideration disabled; rejecting storage deal proposal from client: %s", deal.Client.String())
+				return false, "miner is not considering online storage deals", nil
+			}
+
+			b, err = offlineOk()
+			if err != nil {
+				return false, "miner error", err
+			}
+
+			if deal.Ref != nil && deal.Ref.TransferType == storagemarket.TTManual && !b {
+				log.Warnf("offline storage deal consideration disabled; rejecting storage deal proposal from client: %s", deal.Client.String())
+				return false, "miner is not accepting offline storage deals", nil
+			}
+
+			blocklist, err := blocklistFunc()
+			if err != nil {
+				return false, "miner error", err
+			}
+
+			for idx := range blocklist {
+				if deal.Proposal.PieceCID.Equals(blocklist[idx]) {
+					log.Warnf("piece CID in proposal %s is blocklisted; rejecting storage deal proposal from client: %s", deal.Proposal.PieceCID, deal.Client.String())
+					return false, fmt.Sprintf("miner has blocklisted piece CID %s", deal.Proposal.PieceCID), nil
+				}
+			}
+
+			sealDuration, err := expectedSealTimeFunc()
+			if err != nil {
+				return false, "miner error", err
+			}
+
+			sealEpochs := sealDuration / (time.Duration(build.BlockDelaySecs) * time.Second)
+			_, ht, err := spn.GetChainHead(ctx)
+			if err != nil {
+				return false, "failed to get chain head", err
+			}
+			earliest := abi.ChainEpoch(sealEpochs) + ht
+			if deal.Proposal.StartEpoch < earliest {
+				log.Warnw("proposed deal would start before sealing can be completed; rejecting storage deal proposal from client", "piece_cid", deal.Proposal.PieceCID, "client", deal.Client.String(), "seal_duration", sealDuration, "earliest", earliest, "curepoch", ht)
+				return false, fmt.Sprintf("cannot seal a sector before %s", deal.Proposal.StartEpoch), nil
+			}
+
+			if user != nil {
+				return user(ctx, deal)
+			}
+
+			return true, "", nil
+		}
 	}
 }
+
+func StorageProvider(minerAddress dtypes.MinerAddress,
+	ffiConfig *ffiwrapper.Config,
+	storedAsk *storedask.StoredAsk,
+	h host.Host, ds dtypes.MetadataDS,
+	mds dtypes.StagingMultiDstore,
+	r repo.LockedRepo,
+	pieceStore dtypes.ProviderPieceStore,
+	dataTransfer dtypes.ProviderDataTransfer,
+	spn storagemarket.StorageProviderNode,
+	df dtypes.DealFilter,
+	funds ProviderDealFunds,
+) (storagemarket.StorageProvider, error) {
+	net := smnet.NewFromLibp2pHost(h)
+	store, err := piecefilestore.NewLocalFileStore(piecefilestore.OsPath(r.Path()))
+	if err != nil {
+		return nil, err
+	}
+
+	opt := storageimpl.CustomDealDecisionLogic(storageimpl.DealDeciderFunc(df))
+
+	return storageimpl.NewProvider(net, namespace.Wrap(ds, datastore.NewKey("/deals/provider")), store, mds, pieceStore, dataTransfer, spn, address.Address(minerAddress), ffiConfig.SealProofType, storedAsk, funds, opt)
+}
+
+// RetrievalProvider creates a new retrieval provider attached to the provider blockstore
+func RetrievalProvider(h host.Host, miner *storage.Miner, sealer sectorstorage.SectorManager, full lapi.FullNode, ds dtypes.MetadataDS, pieceStore dtypes.ProviderPieceStore, mds dtypes.StagingMultiDstore, dt dtypes.ProviderDataTransfer, onlineOk dtypes.ConsiderOnlineRetrievalDealsConfigFunc, offlineOk dtypes.ConsiderOfflineRetrievalDealsConfigFunc) (retrievalmarket.RetrievalProvider, error) {
+	adapter := retrievaladapter.NewRetrievalProviderNode(miner, sealer, full)
+
+	maddr, err := minerAddrFromDS(ds)
+	if err != nil {
+		return nil, err
+	}
+
+	netwk := rmnet.NewFromLibp2pHost(h)
+
+	opt := retrievalimpl.DealDeciderOpt(func(ctx context.Context, state retrievalmarket.ProviderDealState) (bool, string, error) {
+		b, err := onlineOk()
+		if err != nil {
+			return false, "miner error", err
+		}
+
+		if !b {
+			log.Warn("online retrieval deal consideration disabled; rejecting retrieval deal proposal from client")
+			return false, "miner is not accepting online retrieval deals", nil
+		}
+
+		b, err = offlineOk()
+		if err != nil {
+			return false, "miner error", err
+		}
+
+		if !b {
+			log.Info("offline retrieval has not been implemented yet")
+		}
+
+		return true, "", nil
+	})
+
+	return retrievalimpl.NewProvider(maddr, adapter, netwk, pieceStore, mds, dt, namespace.Wrap(ds, datastore.NewKey("/retrievals/provider")), opt)
+}
+
+func SectorStorage(mctx helpers.MetricsCtx, lc fx.Lifecycle, ls stores.LocalStorage, si stores.SectorIndex, cfg *ffiwrapper.Config, sc sectorstorage.SealerConfig, urls sectorstorage.URLs, sa sectorstorage.StorageAuth) (*sectorstorage.Manager, error) {
+	ctx := helpers.LifecycleCtx(mctx, lc)
+
+	sst, err := sectorstorage.New(ctx, ls, si, cfg, sc, urls, sa)
+	if err != nil {
+		return nil, err
+	}
+
+	lc.Append(fx.Hook{
+		OnStop: sst.Close,
+	})
+
+	return sst, nil
+}
+
+func StorageAuth(ctx helpers.MetricsCtx, ca lapi.Common) (sectorstorage.StorageAuth, error) {
+	token, err := ca.AuthNew(ctx, []auth.Permission{"admin"})
+	if err != nil {
+		return nil, xerrors.Errorf("creating storage auth header: %w", err)
+	}
+
+	headers := http.Header{}
+	headers.Add("Authorization", "Bearer "+string(token))
+	return sectorstorage.StorageAuth(headers), nil
+}
+
+func NewConsiderOnlineStorageDealsConfigFunc(r repo.LockedRepo) (dtypes.ConsiderOnlineStorageDealsConfigFunc, error) {
+	return func() (out bool, err error) {
+		err = readCfg(r, func(cfg *config.StorageMiner) {
+			out = cfg.Dealmaking.ConsiderOnlineStorageDeals
+		})
+		return
+	}, nil
+}
+
+func NewSetConsideringOnlineStorageDealsFunc(r repo.LockedRepo) (dtypes.SetConsiderOnlineStorageDealsConfigFunc, error) {
+	return func(b bool) (err error) {
+		err = mutateCfg(r, func(cfg *config.StorageMiner) {
+			cfg.Dealmaking.ConsiderOnlineStorageDeals = b
+		})
+		return
+	}, nil
+}
+
+func NewConsiderOnlineRetrievalDealsConfigFunc(r repo.LockedRepo) (dtypes.ConsiderOnlineRetrievalDealsConfigFunc, error) {
+	return func() (out bool, err error) {
+		err = readCfg(r, func(cfg *config.StorageMiner) {
+			out = cfg.Dealmaking.ConsiderOnlineRetrievalDeals
+		})
+		return
+	}, nil
+}
+
+func NewSetConsiderOnlineRetrievalDealsConfigFunc(r repo.LockedRepo) (dtypes.SetConsiderOnlineRetrievalDealsConfigFunc, error) {
+	return func(b bool) (err error) {
+		err = mutateCfg(r, func(cfg *config.StorageMiner) {
+			cfg.Dealmaking.ConsiderOnlineRetrievalDeals = b
+		})
+		return
+	}, nil
+}
+
+func NewStorageDealPieceCidBlocklistConfigFunc(r repo.LockedRepo) (dtypes.StorageDealPieceCidBlocklistConfigFunc, error) {
+	return func() (out []cid.Cid, err error) {
+		err = readCfg(r, func(cfg *config.StorageMiner) {
+			out = cfg.Dealmaking.PieceCidBlocklist
+		})
+		return
+	}, nil
+}
+
+func NewSetStorageDealPieceCidBlocklistConfigFunc(r repo.LockedRepo) (dtypes.SetStorageDealPieceCidBlocklistConfigFunc, error) {
+	return func(blocklist []cid.Cid) (err error) {
+		err = mutateCfg(r, func(cfg *config.StorageMiner) {
+			cfg.Dealmaking.PieceCidBlocklist = blocklist
+		})
+		return
+	}, nil
+}
+
+func NewConsiderOfflineStorageDealsConfigFunc(r repo.LockedRepo) (dtypes.ConsiderOfflineStorageDealsConfigFunc, error) {
+	return func() (out bool, err error) {
+		err = readCfg(r, func(cfg *config.StorageMiner) {
+			out = cfg.Dealmaking.ConsiderOfflineStorageDeals
+		})
+		return
+	}, nil
+}
+
+func NewSetConsideringOfflineStorageDealsFunc(r repo.LockedRepo) (dtypes.SetConsiderOfflineStorageDealsConfigFunc, error) {
+	return func(b bool) (err error) {
+		err = mutateCfg(r, func(cfg *config.StorageMiner) {
+			cfg.Dealmaking.ConsiderOfflineStorageDeals = b
+		})
+		return
+	}, nil
+}
+
+func NewConsiderOfflineRetrievalDealsConfigFunc(r repo.LockedRepo) (dtypes.ConsiderOfflineRetrievalDealsConfigFunc, error) {
+	return func() (out bool, err error) {
+		err = readCfg(r, func(cfg *config.StorageMiner) {
+			out = cfg.Dealmaking.ConsiderOfflineRetrievalDeals
+		})
+		return
+	}, nil
+}
+
+func NewSetConsiderOfflineRetrievalDealsConfigFunc(r repo.LockedRepo) (dtypes.SetConsiderOfflineRetrievalDealsConfigFunc, error) {
+	return func(b bool) (err error) {
+		err = mutateCfg(r, func(cfg *config.StorageMiner) {
+			cfg.Dealmaking.ConsiderOfflineRetrievalDeals = b
+		})
+		return
+	}, nil
+}
+
+func NewSetSealConfigFunc(r repo.LockedRepo) (dtypes.SetSealingConfigFunc, error) {
+	return func(cfg sealiface.Config) (err error) {
+		err = mutateCfg(r, func(c *config.StorageMiner) {
+			c.Sealing = config.SealingConfig{
+				MaxWaitDealsSectors: cfg.MaxWaitDealsSectors,
+				MaxSealingSectors:   cfg.MaxSealingSectors,
+				WaitDealsDelay:      config.Duration(cfg.WaitDealsDelay),
+			}
+		})
+		return
+	}, nil
+}
+
+func NewGetSealConfigFunc(r repo.LockedRepo) (dtypes.GetSealingConfigFunc, error) {
+	return func() (out sealiface.Config, err error) {
+		err = readCfg(r, func(cfg *config.StorageMiner) {
+			out = sealiface.Config{
+				MaxWaitDealsSectors:       cfg.Sealing.MaxWaitDealsSectors,
+				MaxSealingSectors:         cfg.Sealing.MaxSealingSectors,
+				MaxSealingSectorsForDeals: cfg.Sealing.MaxSealingSectorsForDeals,
+				WaitDealsDelay:            time.Duration(cfg.Sealing.WaitDealsDelay),
+			}
+		})
+		return
+	}, nil
+}
+
+func NewSetExpectedSealDurationFunc(r repo.LockedRepo) (dtypes.SetExpectedSealDurationFunc, error) {
+	return func(delay time.Duration) (err error) {
+		err = mutateCfg(r, func(cfg *config.StorageMiner) {
+			cfg.Dealmaking.ExpectedSealDuration = config.Duration(delay)
+		})
+		return
+	}, nil
+}
+
+func NewGetExpectedSealDurationFunc(r repo.LockedRepo) (dtypes.GetExpectedSealDurationFunc, error) {
+	return func() (out time.Duration, err error) {
+		err = readCfg(r, func(cfg *config.StorageMiner) {
+			out = time.Duration(cfg.Dealmaking.ExpectedSealDuration)
+		})
+		return
+	}, nil
+}
+
+func readCfg(r repo.LockedRepo, accessor func(*config.StorageMiner)) error {
+	raw, err := r.Config()
+	if err != nil {
+		return err
+	}
+
+	cfg, ok := raw.(*config.StorageMiner)
+	if !ok {
+		return xerrors.New("expected address of config.StorageMiner")
+	}
+
+	accessor(cfg)
+
+	return nil
+}
+
+func mutateCfg(r repo.LockedRepo, mutator func(*config.StorageMiner)) error {
+	var typeErr error
+
+	setConfigErr := r.SetConfig(func(raw interface{}) {
+		cfg, ok := raw.(*config.StorageMiner)
+		if !ok {
+			typeErr = errors.New("expected miner config")
+			return
+		}
+
+		mutator(cfg)
+	})
+
+	return multierr.Combine(typeErr, setConfigErr)
+}
diff --git a/node/modules/testing/beacon.go b/node/modules/testing/beacon.go
new file mode 100644
index 000000000..7876e1d05
--- /dev/null
+++ b/node/modules/testing/beacon.go
@@ -0,0 +1,15 @@
+package testing
+
+import (
+	"time"
+
+	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/beacon"
+)
+
+func RandomBeacon() (beacon.Schedule, error) {
+	return beacon.Schedule{
+		{Start: 0,
+			Beacon: beacon.NewMockBeacon(time.Duration(build.BlockDelaySecs) * time.Second),
+		}}, nil
+}
diff --git a/node/modules/testing/genesis.go b/node/modules/testing/genesis.go
index 6d13612ab..40df68bf3 100644
--- a/node/modules/testing/genesis.go
+++ b/node/modules/testing/genesis.go
@@ -7,22 +7,21 @@ import (
 	"io"
 	"io/ioutil"
 	"os"
-	"time"
 
 	"github.com/ipfs/go-blockservice"
-	"github.com/ipfs/go-car"
 	"github.com/ipfs/go-cid"
 	offline "github.com/ipfs/go-ipfs-exchange-offline"
-	logging "github.com/ipfs/go-log"
+	logging "github.com/ipfs/go-log/v2"
 	"github.com/ipfs/go-merkledag"
-	"github.com/libp2p/go-libp2p-core/peer"
+	"github.com/ipld/go-car"
 	"github.com/mitchellh/go-homedir"
 	"golang.org/x/xerrors"
 
-	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain/gen"
+	genesis2 "github.com/filecoin-project/lotus/chain/gen/genesis"
 	"github.com/filecoin-project/lotus/chain/types"
-	"github.com/filecoin-project/lotus/chain/wallet"
+	"github.com/filecoin-project/lotus/chain/vm"
 	"github.com/filecoin-project/lotus/genesis"
 	"github.com/filecoin-project/lotus/node/modules"
 	"github.com/filecoin-project/lotus/node/modules/dtypes"
@@ -30,37 +29,20 @@ import (
 
 var glog = logging.Logger("genesis")
 
-func MakeGenesisMem(out io.Writer, gmc *gen.GenMinerCfg) func(bs dtypes.ChainBlockstore, w *wallet.Wallet) modules.Genesis {
-	return func(bs dtypes.ChainBlockstore, w *wallet.Wallet) modules.Genesis {
+func MakeGenesisMem(out io.Writer, template genesis.Template) func(bs dtypes.ChainBlockstore, syscalls vm.SyscallBuilder) modules.Genesis {
+	return func(bs dtypes.ChainBlockstore, syscalls vm.SyscallBuilder) modules.Genesis {
 		return func() (*types.BlockHeader, error) {
 			glog.Warn("Generating new random genesis block, note that this SHOULD NOT happen unless you are setting up new network")
-			defk, err := w.GenerateKey(types.KTBLS)
+			b, err := genesis2.MakeGenesisBlock(context.TODO(), bs, syscalls, template)
 			if err != nil {
-				return nil, err
-			}
-
-			alloc := map[address.Address]types.BigInt{
-				defk: types.FromFil(1000),
-			}
-
-			for _, genm := range gmc.PreSeals {
-				waddr, err := w.Import(&genm.Key)
-				if err != nil {
-					return nil, err
-				}
-				alloc[waddr] = types.FromFil(10000)
-			}
-
-			b, err := gen.MakeGenesisBlock(bs, alloc, gmc, 100000)
-			if err != nil {
-				return nil, err
+				return nil, xerrors.Errorf("make genesis block failed: %w", err)
 			}
 			offl := offline.Exchange(bs)
 			blkserv := blockservice.New(bs, offl)
 			dserv := merkledag.NewDAGService(blkserv)
 
-			if err := car.WriteCar(context.TODO(), dserv, []cid.Cid{b.Genesis.Cid()}, out); err != nil {
-				return nil, err
+			if err := car.WriteCarWithWalker(context.TODO(), dserv, []cid.Cid{b.Genesis.Cid()}, out, gen.CarWalkFunc); err != nil {
+				return nil, xerrors.Errorf("failed to write car file: %w", err)
 			}
 
 			return b.Genesis, nil
@@ -68,74 +50,35 @@ func MakeGenesisMem(out io.Writer, gmc *gen.GenMinerCfg) func(bs dtypes.ChainBlo
 	}
 }
 
-func MakeGenesis(outFile, presealInfo, timestamp string) func(bs dtypes.ChainBlockstore, w *wallet.Wallet) modules.Genesis {
-	return func(bs dtypes.ChainBlockstore, w *wallet.Wallet) modules.Genesis {
+func MakeGenesis(outFile, genesisTemplate string) func(bs dtypes.ChainBlockstore, syscalls vm.SyscallBuilder) modules.Genesis {
+	return func(bs dtypes.ChainBlockstore, syscalls vm.SyscallBuilder) modules.Genesis {
 		return func() (*types.BlockHeader, error) {
 			glog.Warn("Generating new random genesis block, note that this SHOULD NOT happen unless you are setting up new network")
-			presealInfo, err := homedir.Expand(presealInfo)
+			genesisTemplate, err := homedir.Expand(genesisTemplate)
 			if err != nil {
 				return nil, err
 			}
 
-			fdata, err := ioutil.ReadFile(presealInfo)
+			fdata, err := ioutil.ReadFile(genesisTemplate)
 			if err != nil {
 				return nil, xerrors.Errorf("reading preseals json: %w", err)
 			}
 
-			var preseals map[string]genesis.GenesisMiner
-			if err := json.Unmarshal(fdata, &preseals); err != nil {
+			var template genesis.Template
+			if err := json.Unmarshal(fdata, &template); err != nil {
 				return nil, err
 			}
 
-			var fakePeerIDs []peer.ID
-			minerAddresses := make([]address.Address, 0, len(preseals))
-			for s := range preseals {
-				a, err := address.NewFromString(s)
-				if err != nil {
-					return nil, err
-				}
-				if a.Protocol() != address.ID {
-					return nil, xerrors.New("expected ID address")
-				}
-				minerAddresses = append(minerAddresses, a)
-				fakePeerIDs = append(fakePeerIDs, peer.ID("peer"+a.String()))
+			if template.Timestamp == 0 {
+				template.Timestamp = uint64(build.Clock.Now().Unix())
 			}
 
-			gmc := &gen.GenMinerCfg{
-				PeerIDs:    fakePeerIDs,
-				PreSeals:   preseals,
-				MinerAddrs: minerAddresses,
-			}
-
-			addrs := map[address.Address]types.BigInt{}
-
-			for _, miner := range preseals {
-				if _, err := w.Import(&miner.Key); err != nil {
-					return nil, xerrors.Errorf("importing miner key: %w", err)
-				}
-
-				_ = w.SetDefault(miner.Worker)
-
-				addrs[miner.Worker] = types.FromFil(100000)
-			}
-
-			ts := uint64(time.Now().Unix())
-			if timestamp != "" {
-				t, err := time.Parse(time.RFC3339, timestamp)
-				if err != nil {
-					return nil, xerrors.Errorf("parsing input genesis timestamp: %w", err)
-				}
-
-				glog.Infof("will use %s as the genesis timestamp", t)
-				ts = uint64(t.Unix())
-			}
-
-			b, err := gen.MakeGenesisBlock(bs, addrs, gmc, ts)
+			b, err := genesis2.MakeGenesisBlock(context.TODO(), bs, syscalls, template)
 			if err != nil {
-				return nil, err
+				return nil, xerrors.Errorf("make genesis block: %w", err)
 			}
 
-			fmt.Println("GENESIS MINER ADDRESS: ", gmc.MinerAddrs[0].String())
+			fmt.Printf("GENESIS MINER ADDRESS: t0%d\n", genesis2.MinerStart)
 
 			f, err := os.OpenFile(outFile, os.O_CREATE|os.O_WRONLY, 0644)
 			if err != nil {
@@ -146,7 +89,7 @@ func MakeGenesis(outFile, presealInfo, timestamp string) func(bs dtypes.ChainBlo
 			blkserv := blockservice.New(bs, offl)
 			dserv := merkledag.NewDAGService(blkserv)
 
-			if err := car.WriteCar(context.TODO(), dserv, []cid.Cid{b.Genesis.Cid()}, f); err != nil {
+			if err := car.WriteCarWithWalker(context.TODO(), dserv, []cid.Cid{b.Genesis.Cid()}, f, gen.CarWalkFunc); err != nil {
 				return nil, err
 			}
 
diff --git a/node/modules/testing/storage.go b/node/modules/testing/storage.go
deleted file mode 100644
index 525d86b06..000000000
--- a/node/modules/testing/storage.go
+++ /dev/null
@@ -1,39 +0,0 @@
-package testing
-
-import (
-	"context"
-
-	"github.com/ipfs/go-blockservice"
-	"github.com/ipfs/go-datastore"
-	dsync "github.com/ipfs/go-datastore/sync"
-	blockstore "github.com/ipfs/go-ipfs-blockstore"
-	offline "github.com/ipfs/go-ipfs-exchange-offline"
-	ipld "github.com/ipfs/go-ipld-format"
-	"github.com/ipfs/go-merkledag"
-	"go.uber.org/fx"
-)
-
-func MapBlockstore() blockstore.Blockstore {
-	// TODO: proper datastore
-	bds := dsync.MutexWrap(datastore.NewMapDatastore())
-	bs := blockstore.NewBlockstore(bds)
-	return blockstore.NewIdStore(bs)
-}
-
-func MapDatastore() datastore.Batching {
-	return dsync.MutexWrap(datastore.NewMapDatastore())
-}
-
-func MemoryClientDag(lc fx.Lifecycle) ipld.DAGService {
-	ibs := blockstore.NewBlockstore(datastore.NewMapDatastore())
-	bsvc := blockservice.New(ibs, offline.Exchange(ibs))
-	dag := merkledag.NewDAGService(bsvc)
-
-	lc.Append(fx.Hook{
-		OnStop: func(_ context.Context) error {
-			return bsvc.Close()
-		},
-	})
-
-	return dag
-}
diff --git a/node/node_test.go b/node/node_test.go
index 4c372aa1a..001b99c04 100644
--- a/node/node_test.go
+++ b/node/node_test.go
@@ -1,296 +1,153 @@
 package node_test
 
 import (
-	"bytes"
-	"context"
-	"crypto/rand"
-	"io/ioutil"
-	"net/http/httptest"
-	"path/filepath"
+	"os"
 	"testing"
+	"time"
 
-	"github.com/filecoin-project/go-address"
-	sectorbuilder "github.com/filecoin-project/go-sectorbuilder"
-	"github.com/filecoin-project/lotus/build"
-	"github.com/ipfs/go-datastore"
-	"github.com/ipfs/go-datastore/namespace"
-	badger "github.com/ipfs/go-ds-badger"
-	logging "github.com/ipfs/go-log"
-	"github.com/libp2p/go-libp2p-core/crypto"
-	"github.com/libp2p/go-libp2p-core/peer"
-	mocknet "github.com/libp2p/go-libp2p/p2p/net/mock"
-	"github.com/stretchr/testify/require"
+	builder "github.com/filecoin-project/lotus/node/test"
+
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/lotus/lib/lotuslog"
+	logging "github.com/ipfs/go-log/v2"
 
-	"github.com/filecoin-project/lotus/api"
-	"github.com/filecoin-project/lotus/api/client"
 	"github.com/filecoin-project/lotus/api/test"
-	"github.com/filecoin-project/lotus/chain/actors"
-	"github.com/filecoin-project/lotus/chain/gen"
-	"github.com/filecoin-project/lotus/chain/types"
-	"github.com/filecoin-project/lotus/cmd/lotus-seed/seed"
-	"github.com/filecoin-project/lotus/genesis"
-	"github.com/filecoin-project/lotus/lib/jsonrpc"
-	"github.com/filecoin-project/lotus/miner"
-	"github.com/filecoin-project/lotus/node"
-	"github.com/filecoin-project/lotus/node/impl"
-	"github.com/filecoin-project/lotus/node/modules"
-	modtest "github.com/filecoin-project/lotus/node/modules/testing"
-	"github.com/filecoin-project/lotus/node/repo"
+	"github.com/filecoin-project/lotus/chain/actors/policy"
 )
 
 func init() {
 	_ = logging.SetLogLevel("*", "INFO")
 
-	build.SectorSizes = []uint64{1024}
-	build.MinimumMinerPower = 1024
-}
-
-func testStorageNode(ctx context.Context, t *testing.T, waddr address.Address, act address.Address, pk crypto.PrivKey, tnd test.TestNode, mn mocknet.Mocknet) test.TestStorageNode {
-	r := repo.NewMemory(nil)
-
-	lr, err := r.Lock(repo.StorageMiner)
-	require.NoError(t, err)
-
-	ks, err := lr.KeyStore()
-	require.NoError(t, err)
-
-	kbytes, err := pk.Bytes()
-	require.NoError(t, err)
-
-	err = ks.Put("libp2p-host", types.KeyInfo{
-		Type:       "libp2p-host",
-		PrivateKey: kbytes,
-	})
-	require.NoError(t, err)
-
-	ds, err := lr.Datastore("/metadata")
-	require.NoError(t, err)
-	err = ds.Put(datastore.NewKey("miner-address"), act.Bytes())
-	require.NoError(t, err)
-
-	err = lr.Close()
-	require.NoError(t, err)
-
-	peerid, err := peer.IDFromPrivateKey(pk)
-	require.NoError(t, err)
-
-	enc, err := actors.SerializeParams(&actors.UpdatePeerIDParams{PeerID: peerid})
-	require.NoError(t, err)
-
-	msg := &types.Message{
-		To:       act,
-		From:     waddr,
-		Method:   actors.MAMethods.UpdatePeerID,
-		Params:   enc,
-		Value:    types.NewInt(0),
-		GasPrice: types.NewInt(0),
-		GasLimit: types.NewInt(1000000),
-	}
-
-	_, err = tnd.MpoolPushMessage(ctx, msg)
-	require.NoError(t, err)
-
-	// start node
-	var minerapi api.StorageMiner
-
-	mineBlock := make(chan struct{})
-	// TODO: use stop
-	_, err = node.New(ctx,
-		node.StorageMiner(&minerapi),
-		node.Online(),
-		node.Repo(r),
-		node.Test(),
-
-		node.MockHost(mn),
-
-		node.Override(new(api.FullNode), tnd),
-		node.Override(new(*miner.Miner), miner.NewTestMiner(mineBlock, act)),
-	)
-	if err != nil {
-		t.Fatalf("failed to construct node: %v", err)
-	}
-
-	/*// Bootstrap with full node
-	remoteAddrs, err := tnd.NetAddrsListen(ctx)
-	require.NoError(t, err)
-
-	err = minerapi.NetConnect(ctx, remoteAddrs)
-	require.NoError(t, err)*/
-	mineOne := func(ctx context.Context) error {
-		select {
-		case mineBlock <- struct{}{}:
-			return nil
-		case <-ctx.Done():
-			return ctx.Err()
-		}
-	}
-
-	return test.TestStorageNode{StorageMiner: minerapi, MineOne: mineOne}
-}
-
-func builder(t *testing.T, nFull int, storage []int) ([]test.TestNode, []test.TestStorageNode) {
-	ctx := context.Background()
-	mn := mocknet.New(ctx)
-
-	fulls := make([]test.TestNode, nFull)
-	storers := make([]test.TestStorageNode, len(storage))
-
-	pk, _, err := crypto.GenerateEd25519Key(rand.Reader)
-	require.NoError(t, err)
-
-	minerPid, err := peer.IDFromPrivateKey(pk)
-	require.NoError(t, err)
-
-	var genbuf bytes.Buffer
-
-	if len(storage) > 1 {
-		panic("need more peer IDs")
-	}
-	// PRESEAL SECTION, TRY TO REPLACE WITH BETTER IN THE FUTURE
-	// TODO: would be great if there was a better way to fake the preseals
-	gmc := &gen.GenMinerCfg{
-		PeerIDs:  []peer.ID{minerPid}, // TODO: if we have more miners, need more peer IDs
-		PreSeals: map[string]genesis.GenesisMiner{},
-	}
-
-	var presealDirs []string
-	for i := 0; i < len(storage); i++ {
-		maddr, err := address.NewIDAddress(300 + uint64(i))
-		if err != nil {
-			t.Fatal(err)
-		}
-		tdir, err := ioutil.TempDir("", "preseal-memgen")
-		if err != nil {
-			t.Fatal(err)
-		}
-		genm, err := seed.PreSeal(maddr, 1024, 0, 1, tdir, []byte("make genesis mem random"))
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		presealDirs = append(presealDirs, tdir)
-		gmc.MinerAddrs = append(gmc.MinerAddrs, maddr)
-		gmc.PreSeals[maddr.String()] = *genm
-	}
-
-	// END PRESEAL SECTION
-
-	for i := 0; i < nFull; i++ {
-		var genesis node.Option
-		if i == 0 {
-			genesis = node.Override(new(modules.Genesis), modtest.MakeGenesisMem(&genbuf, gmc))
-		} else {
-			genesis = node.Override(new(modules.Genesis), modules.LoadGenesis(genbuf.Bytes()))
-		}
-
-		var err error
-		// TODO: Don't ignore stop
-		_, err = node.New(ctx,
-			node.FullAPI(&fulls[i].FullNode),
-			node.Online(),
-			node.Repo(repo.NewMemory(nil)),
-			node.MockHost(mn),
-			node.Test(),
-
-			genesis,
-		)
-		if err != nil {
-			t.Fatal(err)
-		}
-
-	}
-
-	for i, full := range storage {
-		// TODO: support non-bootstrap miners
-		if i != 0 {
-			t.Fatal("only one storage node supported")
-		}
-		if full != 0 {
-			t.Fatal("storage nodes only supported on the first full node")
-		}
-
-		f := fulls[full]
-
-		genMiner := gmc.MinerAddrs[i]
-		wa := gmc.PreSeals[genMiner.String()].Worker
-
-		storers[i] = testStorageNode(ctx, t, wa, genMiner, pk, f, mn)
-
-		sma := storers[i].StorageMiner.(*impl.StorageMinerAPI)
-
-		psd := presealDirs[i]
-		mds, err := badger.NewDatastore(filepath.Join(psd, "badger"), nil)
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		osb, err := sectorbuilder.New(&sectorbuilder.Config{
-			SectorSize:    1024,
-			WorkerThreads: 2,
-			Miner:         genMiner,
-			Dir:           psd,
-		}, namespace.Wrap(mds, datastore.NewKey("/sectorbuilder")))
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		if err := sma.SectorBuilder.ImportFrom(osb, false); err != nil {
-			t.Fatal(err)
-		}
-
-	}
-
-	if err := mn.LinkAll(); err != nil {
-		t.Fatal(err)
-	}
-
-	return fulls, storers
+	policy.SetConsensusMinerMinPower(abi.NewStoragePower(2048))
+	policy.SetSupportedProofTypes(abi.RegisteredSealProof_StackedDrg2KiBV1)
+	policy.SetMinVerifiedDealSize(abi.NewStoragePower(256))
 }
 
 func TestAPI(t *testing.T) {
-	test.TestApis(t, builder)
-}
-
-func rpcBuilder(t *testing.T, nFull int, storage []int) ([]test.TestNode, []test.TestStorageNode) {
-	fullApis, storaApis := builder(t, nFull, storage)
-	fulls := make([]test.TestNode, nFull)
-	storers := make([]test.TestStorageNode, len(storage))
-
-	for i, a := range fullApis {
-		rpcServer := jsonrpc.NewServer()
-		rpcServer.Register("Filecoin", a)
-		testServ := httptest.NewServer(rpcServer) //  todo: close
-
-		var err error
-		fulls[i].FullNode, _, err = client.NewFullNodeRPC("ws://"+testServ.Listener.Addr().String(), nil)
-		if err != nil {
-			t.Fatal(err)
-		}
-	}
-
-	for i, a := range storaApis {
-		rpcServer := jsonrpc.NewServer()
-		rpcServer.Register("Filecoin", a)
-		testServ := httptest.NewServer(rpcServer) //  todo: close
-
-		var err error
-		storers[i].StorageMiner, _, err = client.NewStorageMinerRPC("ws://"+testServ.Listener.Addr().String(), nil)
-		if err != nil {
-			t.Fatal(err)
-		}
-		storers[i].MineOne = a.MineOne
-	}
-
-	return fulls, storers
+	test.TestApis(t, builder.Builder)
 }
 
 func TestAPIRPC(t *testing.T) {
-	test.TestApis(t, rpcBuilder)
+	test.TestApis(t, builder.RPCBuilder)
 }
 
 func TestAPIDealFlow(t *testing.T) {
+	logging.SetLogLevel("miner", "ERROR")
+	logging.SetLogLevel("chainstore", "ERROR")
+	logging.SetLogLevel("chain", "ERROR")
+	logging.SetLogLevel("sub", "ERROR")
+	logging.SetLogLevel("storageminer", "ERROR")
+
+	t.Run("TestDealFlow", func(t *testing.T) {
+		test.TestDealFlow(t, builder.MockSbBuilder, 10*time.Millisecond, false, false)
+	})
+	t.Run("WithExportedCAR", func(t *testing.T) {
+		test.TestDealFlow(t, builder.MockSbBuilder, 10*time.Millisecond, true, false)
+	})
+	t.Run("TestDoubleDealFlow", func(t *testing.T) {
+		test.TestDoubleDealFlow(t, builder.MockSbBuilder, 10*time.Millisecond)
+	})
+	t.Run("TestFastRetrievalDealFlow", func(t *testing.T) {
+		test.TestFastRetrievalDealFlow(t, builder.MockSbBuilder, 10*time.Millisecond)
+	})
+}
+
+func TestAPIDealFlowReal(t *testing.T) {
 	if testing.Short() {
 		t.Skip("skipping test in short mode")
 	}
-	test.TestDealFlow(t, builder)
+	lotuslog.SetupLogLevels()
+	logging.SetLogLevel("miner", "ERROR")
+	logging.SetLogLevel("chainstore", "ERROR")
+	logging.SetLogLevel("chain", "ERROR")
+	logging.SetLogLevel("sub", "ERROR")
+	logging.SetLogLevel("storageminer", "ERROR")
+
+	// TODO: just set this globally?
+	oldDelay := policy.GetPreCommitChallengeDelay()
+	policy.SetPreCommitChallengeDelay(5)
+	t.Cleanup(func() {
+		policy.SetPreCommitChallengeDelay(oldDelay)
+	})
+
+	t.Run("basic", func(t *testing.T) {
+		test.TestDealFlow(t, builder.Builder, time.Second, false, false)
+	})
+
+	t.Run("fast-retrieval", func(t *testing.T) {
+		test.TestDealFlow(t, builder.Builder, time.Second, false, true)
+	})
+
+	t.Run("retrieval-second", func(t *testing.T) {
+		test.TestSenondDealRetrieval(t, builder.Builder, time.Second)
+	})
+}
+
+func TestDealMining(t *testing.T) {
+	logging.SetLogLevel("miner", "ERROR")
+	logging.SetLogLevel("chainstore", "ERROR")
+	logging.SetLogLevel("chain", "ERROR")
+	logging.SetLogLevel("sub", "ERROR")
+	logging.SetLogLevel("storageminer", "ERROR")
+
+	test.TestDealMining(t, builder.MockSbBuilder, 50*time.Millisecond, false)
+}
+
+func TestPledgeSectors(t *testing.T) {
+	logging.SetLogLevel("miner", "ERROR")
+	logging.SetLogLevel("chainstore", "ERROR")
+	logging.SetLogLevel("chain", "ERROR")
+	logging.SetLogLevel("sub", "ERROR")
+	logging.SetLogLevel("storageminer", "ERROR")
+
+	t.Run("1", func(t *testing.T) {
+		test.TestPledgeSector(t, builder.MockSbBuilder, 50*time.Millisecond, 1)
+	})
+
+	t.Run("100", func(t *testing.T) {
+		test.TestPledgeSector(t, builder.MockSbBuilder, 50*time.Millisecond, 100)
+	})
+
+	t.Run("1000", func(t *testing.T) {
+		if testing.Short() { // takes ~16s
+			t.Skip("skipping test in short mode")
+		}
+
+		test.TestPledgeSector(t, builder.MockSbBuilder, 50*time.Millisecond, 1000)
+	})
+}
+
+func TestWindowedPost(t *testing.T) {
+	if os.Getenv("LOTUS_TEST_WINDOW_POST") != "1" {
+		t.Skip("this takes a few minutes, set LOTUS_TEST_WINDOW_POST=1 to run")
+	}
+
+	logging.SetLogLevel("miner", "ERROR")
+	logging.SetLogLevel("chainstore", "ERROR")
+	logging.SetLogLevel("chain", "ERROR")
+	logging.SetLogLevel("sub", "ERROR")
+	logging.SetLogLevel("storageminer", "ERROR")
+
+	test.TestWindowPost(t, builder.MockSbBuilder, 2*time.Millisecond, 10)
+}
+
+func TestCCUpgrade(t *testing.T) {
+	logging.SetLogLevel("miner", "ERROR")
+	logging.SetLogLevel("chainstore", "ERROR")
+	logging.SetLogLevel("chain", "ERROR")
+	logging.SetLogLevel("sub", "ERROR")
+	logging.SetLogLevel("storageminer", "ERROR")
+
+	test.TestCCUpgrade(t, builder.MockSbBuilder, 5*time.Millisecond)
+}
+
+func TestPaymentChannels(t *testing.T) {
+	logging.SetLogLevel("miner", "ERROR")
+	logging.SetLogLevel("chainstore", "ERROR")
+	logging.SetLogLevel("chain", "ERROR")
+	logging.SetLogLevel("sub", "ERROR")
+	logging.SetLogLevel("pubsub", "ERROR")
+	logging.SetLogLevel("storageminer", "ERROR")
+
+	test.TestPaymentChannels(t, builder.MockSbBuilder, 5*time.Millisecond)
 }
diff --git a/node/options.go b/node/options.go
index 75a57cb9b..c92e209be 100644
--- a/node/options.go
+++ b/node/options.go
@@ -84,6 +84,15 @@ func Unset(typ interface{}) Option {
 	}
 }
 
+// From(*T) -> func(t T) T {return t}
+func From(typ interface{}) interface{} {
+	rt := []reflect.Type{reflect.TypeOf(typ).Elem()}
+	ft := reflect.FuncOf(rt, rt, false)
+	return reflect.MakeFunc(ft, func(args []reflect.Value) (results []reflect.Value) {
+		return args
+	}).Interface()
+}
+
 // from go-ipfs
 // as casts input constructor to a given interface (if a value is given, it
 // wraps it into a constructor).
@@ -129,8 +138,17 @@ func as(in interface{}, as interface{}) interface{} {
 
 	return reflect.MakeFunc(ctype, func(args []reflect.Value) (results []reflect.Value) {
 		outs := reflect.ValueOf(in).Call(args)
+
 		out := reflect.New(outType.Elem())
-		out.Elem().Set(outs[0])
+		if outs[0].Type().AssignableTo(outType.Elem()) {
+			// Out: Iface = In: *Struct; Out: Iface = In: OtherIface
+			out.Elem().Set(outs[0])
+		} else {
+			// Out: Iface = &(In: Struct)
+			t := reflect.New(outs[0].Type())
+			t.Elem().Set(outs[0])
+			out.Elem().Set(t)
+		}
 		outs[0] = out.Elem()
 
 		return outs
diff --git a/node/repo/fsrepo.go b/node/repo/fsrepo.go
index b41024e5d..709d78d3a 100644
--- a/node/repo/fsrepo.go
+++ b/node/repo/fsrepo.go
@@ -1,6 +1,7 @@
 package repo
 
 import (
+	"bytes"
 	"encoding/json"
 	"fmt"
 	"io"
@@ -10,27 +11,30 @@ import (
 	"strings"
 	"sync"
 
+	"github.com/BurntSushi/toml"
 	"github.com/ipfs/go-datastore"
-	"github.com/ipfs/go-datastore/namespace"
-	badger "github.com/ipfs/go-ds-badger"
 	fslock "github.com/ipfs/go-fs-lock"
-	logging "github.com/ipfs/go-log"
+	logging "github.com/ipfs/go-log/v2"
 	"github.com/mitchellh/go-homedir"
 	"github.com/multiformats/go-base32"
 	"github.com/multiformats/go-multiaddr"
 	"golang.org/x/xerrors"
 
+	"github.com/filecoin-project/lotus/extern/sector-storage/fsutil"
+	"github.com/filecoin-project/lotus/extern/sector-storage/stores"
+
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/node/config"
 )
 
 const (
-	fsAPI       = "api"
-	fsAPIToken  = "token"
-	fsConfig    = "config.toml"
-	fsDatastore = "datastore"
-	fsLock      = "repo.lock"
-	fsKeystore  = "keystore"
+	fsAPI           = "api"
+	fsAPIToken      = "token"
+	fsConfig        = "config.toml"
+	fsStorageConfig = "storage.json"
+	fsDatastore     = "datastore"
+	fsLock          = "repo.lock"
+	fsKeystore      = "keystore"
 )
 
 type RepoType int
@@ -39,6 +43,7 @@ const (
 	_                 = iota // Default is invalid
 	FullNode RepoType = iota
 	StorageMiner
+	Worker
 )
 
 func defConfForType(t RepoType) interface{} {
@@ -47,6 +52,8 @@ func defConfForType(t RepoType) interface{} {
 		return config.DefaultFullNode()
 	case StorageMiner:
 		return config.DefaultStorageMiner()
+	case Worker:
+		return &struct{}{}
 	default:
 		panic(fmt.Sprintf("unknown RepoType(%d)", int(t)))
 	}
@@ -58,8 +65,7 @@ var ErrRepoExists = xerrors.New("repo exists")
 
 // FsRepo is struct for repo, use NewFS to create
 type FsRepo struct {
-	path     string
-	repoType RepoType
+	path string
 }
 
 var _ Repo = &FsRepo{}
@@ -95,7 +101,7 @@ func (fsr *FsRepo) Init(t RepoType) error {
 	}
 
 	log.Infof("Initializing repo at '%s'", fsr.path)
-	err = os.Mkdir(fsr.path, 0755) //nolint: gosec
+	err = os.MkdirAll(fsr.path, 0755) //nolint: gosec
 	if err != nil && !os.IsExist(err) {
 		return err
 	}
@@ -186,7 +192,12 @@ func (fsr *FsRepo) APIToken() ([]byte, error) {
 	}
 	defer f.Close() //nolint: errcheck // Read only op
 
-	return ioutil.ReadAll(f)
+	tb, err := ioutil.ReadAll(f)
+	if err != nil {
+		return nil, err
+	}
+
+	return bytes.TrimSpace(tb), nil
 }
 
 // Lock acquires exclusive lock on this repo
@@ -215,9 +226,12 @@ type fsLockedRepo struct {
 	repoType RepoType
 	closer   io.Closer
 
-	ds     datastore.Batching
+	ds     map[string]datastore.Batching
 	dsErr  error
 	dsOnce sync.Once
+
+	storageLk sync.Mutex
+	configLk  sync.Mutex
 }
 
 func (fsr *fsLockedRepo) Path() string {
@@ -231,8 +245,10 @@ func (fsr *fsLockedRepo) Close() error {
 		return xerrors.Errorf("could not remove API file: %w", err)
 	}
 	if fsr.ds != nil {
-		if err := fsr.ds.Close(); err != nil {
-			return xerrors.Errorf("could not close datastore: %w", err)
+		for _, ds := range fsr.ds {
+			if err := ds.Close(); err != nil {
+				return xerrors.Errorf("could not close datastore: %w", err)
+			}
 		}
 	}
 
@@ -253,29 +269,92 @@ func (fsr *fsLockedRepo) stillValid() error {
 	return nil
 }
 
-func (fsr *fsLockedRepo) Datastore(ns string) (datastore.Batching, error) {
-	fsr.dsOnce.Do(func() {
-		opts := badger.DefaultOptions
-		opts.Truncate = true
+func (fsr *fsLockedRepo) Config() (interface{}, error) {
+	fsr.configLk.Lock()
+	defer fsr.configLk.Unlock()
 
-		fsr.ds, fsr.dsErr = badger.NewDatastore(fsr.join(fsDatastore), &opts)
-		/*if fsr.dsErr == nil {
-			fsr.ds = datastore.NewLogDatastore(fsr.ds, "fsrepo")
-		}*/
-	})
-	if fsr.dsErr != nil {
-		return nil, fsr.dsErr
-	}
-	return namespace.Wrap(fsr.ds, datastore.NewKey(ns)), nil
+	return fsr.loadConfigFromDisk()
 }
 
-func (fsr *fsLockedRepo) Config() (interface{}, error) {
-	if err := fsr.stillValid(); err != nil {
-		return nil, err
-	}
+func (fsr *fsLockedRepo) loadConfigFromDisk() (interface{}, error) {
 	return config.FromFile(fsr.join(fsConfig), defConfForType(fsr.repoType))
 }
 
+func (fsr *fsLockedRepo) SetConfig(c func(interface{})) error {
+	if err := fsr.stillValid(); err != nil {
+		return err
+	}
+
+	fsr.configLk.Lock()
+	defer fsr.configLk.Unlock()
+
+	cfg, err := fsr.loadConfigFromDisk()
+	if err != nil {
+		return err
+	}
+
+	// mutate in-memory representation of config
+	c(cfg)
+
+	// buffer into which we write TOML bytes
+	buf := new(bytes.Buffer)
+
+	// encode now-mutated config as TOML and write to buffer
+	err = toml.NewEncoder(buf).Encode(cfg)
+	if err != nil {
+		return err
+	}
+
+	// write buffer of TOML bytes to config file
+	err = ioutil.WriteFile(fsr.join(fsConfig), buf.Bytes(), 0644)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (fsr *fsLockedRepo) GetStorage() (stores.StorageConfig, error) {
+	fsr.storageLk.Lock()
+	defer fsr.storageLk.Unlock()
+
+	return fsr.getStorage(nil)
+}
+
+func (fsr *fsLockedRepo) getStorage(def *stores.StorageConfig) (stores.StorageConfig, error) {
+	c, err := config.StorageFromFile(fsr.join(fsStorageConfig), def)
+	if err != nil {
+		return stores.StorageConfig{}, err
+	}
+	return *c, nil
+}
+
+func (fsr *fsLockedRepo) SetStorage(c func(*stores.StorageConfig)) error {
+	fsr.storageLk.Lock()
+	defer fsr.storageLk.Unlock()
+
+	sc, err := fsr.getStorage(&stores.StorageConfig{})
+	if err != nil {
+		return xerrors.Errorf("get storage: %w", err)
+	}
+
+	c(&sc)
+
+	return config.WriteStorageFile(fsr.join(fsStorageConfig), sc)
+}
+
+func (fsr *fsLockedRepo) Stat(path string) (fsutil.FsStat, error) {
+	return fsutil.Statfs(path)
+}
+
+func (fsr *fsLockedRepo) DiskUsage(path string) (int64, error) {
+	si, err := fsutil.FileSize(path)
+	if err != nil {
+		return 0, err
+	}
+	return si.OnDisk, nil
+}
+
 func (fsr *fsLockedRepo) SetAPIEndpoint(ma multiaddr.Multiaddr) error {
 	if err := fsr.stillValid(); err != nil {
 		return err
@@ -311,6 +390,7 @@ func (fsr *fsLockedRepo) List() ([]string, error) {
 	if err != nil {
 		return nil, xerrors.Errorf("opening dir to list keystore: %w", err)
 	}
+	defer dir.Close() //nolint:errcheck
 	files, err := dir.Readdir(-1)
 	if err != nil {
 		return nil, xerrors.Errorf("reading keystore dir: %w", err)
@@ -346,7 +426,7 @@ func (fsr *fsLockedRepo) Get(name string) (types.KeyInfo, error) {
 	}
 
 	if fstat.Mode()&0077 != 0 {
-		return types.KeyInfo{}, xerrors.Errorf(kstrPermissionMsg, name, err)
+		return types.KeyInfo{}, xerrors.Errorf(kstrPermissionMsg, name, fstat.Mode())
 	}
 
 	file, err := os.Open(keyPath)
diff --git a/node/repo/fsrepo_ds.go b/node/repo/fsrepo_ds.go
new file mode 100644
index 000000000..f4afe0dee
--- /dev/null
+++ b/node/repo/fsrepo_ds.go
@@ -0,0 +1,92 @@
+package repo
+
+import (
+	"os"
+	"path/filepath"
+
+	"github.com/ipfs/go-datastore"
+	"golang.org/x/xerrors"
+
+	dgbadger "github.com/dgraph-io/badger/v2"
+	badger "github.com/ipfs/go-ds-badger2"
+	levelds "github.com/ipfs/go-ds-leveldb"
+	measure "github.com/ipfs/go-ds-measure"
+	ldbopts "github.com/syndtr/goleveldb/leveldb/opt"
+)
+
+type dsCtor func(path string) (datastore.Batching, error)
+
+var fsDatastores = map[string]dsCtor{
+	"chain":    chainBadgerDs,
+	"metadata": levelDs,
+
+	// Those need to be fast for large writes... but also need a really good GC :c
+	"staging": badgerDs, // miner specific
+
+	"client": badgerDs, // client specific
+}
+
+func chainBadgerDs(path string) (datastore.Batching, error) {
+	opts := badger.DefaultOptions
+	opts.GcInterval = 0 // disable GC for chain datastore
+
+	opts.Options = dgbadger.DefaultOptions("").WithTruncate(true).
+		WithValueThreshold(1 << 10)
+
+	return badger.NewDatastore(path, &opts)
+}
+
+func badgerDs(path string) (datastore.Batching, error) {
+	opts := badger.DefaultOptions
+	opts.Options = dgbadger.DefaultOptions("").WithTruncate(true).
+		WithValueThreshold(1 << 10)
+
+	return badger.NewDatastore(path, &opts)
+}
+
+func levelDs(path string) (datastore.Batching, error) {
+	return levelds.NewDatastore(path, &levelds.Options{
+		Compression: ldbopts.NoCompression,
+		NoSync:      false,
+		Strict:      ldbopts.StrictAll,
+	})
+}
+
+func (fsr *fsLockedRepo) openDatastores() (map[string]datastore.Batching, error) {
+	if err := os.MkdirAll(fsr.join(fsDatastore), 0755); err != nil {
+		return nil, xerrors.Errorf("mkdir %s: %w", fsr.join(fsDatastore), err)
+	}
+
+	out := map[string]datastore.Batching{}
+
+	for p, ctor := range fsDatastores {
+		prefix := datastore.NewKey(p)
+
+		// TODO: optimization: don't init datastores we don't need
+		ds, err := ctor(fsr.join(filepath.Join(fsDatastore, p)))
+		if err != nil {
+			return nil, xerrors.Errorf("opening datastore %s: %w", prefix, err)
+		}
+
+		ds = measure.New("fsrepo."+p, ds)
+
+		out[datastore.NewKey(p).String()] = ds
+	}
+
+	return out, nil
+}
+
+func (fsr *fsLockedRepo) Datastore(ns string) (datastore.Batching, error) {
+	fsr.dsOnce.Do(func() {
+		fsr.ds, fsr.dsErr = fsr.openDatastores()
+	})
+
+	if fsr.dsErr != nil {
+		return nil, fsr.dsErr
+	}
+	ds, ok := fsr.ds[ns]
+	if ok {
+		return ds, nil
+	}
+	return nil, xerrors.Errorf("no such datastore: %s", ns)
+}
diff --git a/node/repo/importmgr/mgr.go b/node/repo/importmgr/mgr.go
new file mode 100644
index 000000000..31991617a
--- /dev/null
+++ b/node/repo/importmgr/mgr.go
@@ -0,0 +1,111 @@
+package importmgr
+
+import (
+	"encoding/json"
+	"fmt"
+
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-multistore"
+	"github.com/filecoin-project/lotus/lib/blockstore"
+	"github.com/ipfs/go-datastore"
+	"github.com/ipfs/go-datastore/namespace"
+)
+
+type Mgr struct {
+	mds *multistore.MultiStore
+	ds  datastore.Batching
+
+	Blockstore blockstore.Blockstore
+}
+
+type Label string
+
+const (
+	LSource   = "source"   // Function which created the import
+	LRootCid  = "root"     // Root CID
+	LFileName = "filename" // Local file path
+	LMTime    = "mtime"    // File modification timestamp
+)
+
+func New(mds *multistore.MultiStore, ds datastore.Batching) *Mgr {
+	return &Mgr{
+		mds:        mds,
+		Blockstore: mds.MultiReadBlockstore(),
+
+		ds: datastore.NewLogDatastore(namespace.Wrap(ds, datastore.NewKey("/stores")), "storess"),
+	}
+}
+
+type StoreMeta struct {
+	Labels map[string]string
+}
+
+func (m *Mgr) NewStore() (multistore.StoreID, *multistore.Store, error) {
+	id := m.mds.Next()
+	st, err := m.mds.Get(id)
+	if err != nil {
+		return 0, nil, err
+	}
+
+	meta, err := json.Marshal(&StoreMeta{Labels: map[string]string{
+		"source": "unknown",
+	}})
+	if err != nil {
+		return 0, nil, xerrors.Errorf("marshaling empty store metadata: %w", err)
+	}
+
+	err = m.ds.Put(datastore.NewKey(fmt.Sprintf("%d", id)), meta)
+	return id, st, err
+}
+
+func (m *Mgr) AddLabel(id multistore.StoreID, key, value string) error { // source, file path, data CID..
+	meta, err := m.ds.Get(datastore.NewKey(fmt.Sprintf("%d", id)))
+	if err != nil {
+		return xerrors.Errorf("getting metadata form datastore: %w", err)
+	}
+
+	var sm StoreMeta
+	if err := json.Unmarshal(meta, &sm); err != nil {
+		return xerrors.Errorf("unmarshaling store meta: %w", err)
+	}
+
+	sm.Labels[key] = value
+
+	meta, err = json.Marshal(&sm)
+	if err != nil {
+		return xerrors.Errorf("marshaling store meta: %w", err)
+	}
+
+	return m.ds.Put(datastore.NewKey(fmt.Sprintf("%d", id)), meta)
+}
+
+func (m *Mgr) List() []multistore.StoreID {
+	return m.mds.List()
+}
+
+func (m *Mgr) Info(id multistore.StoreID) (*StoreMeta, error) {
+	meta, err := m.ds.Get(datastore.NewKey(fmt.Sprintf("%d", id)))
+	if err != nil {
+		return nil, xerrors.Errorf("getting metadata form datastore: %w", err)
+	}
+
+	var sm StoreMeta
+	if err := json.Unmarshal(meta, &sm); err != nil {
+		return nil, xerrors.Errorf("unmarshaling store meta: %w", err)
+	}
+
+	return &sm, nil
+}
+
+func (m *Mgr) Remove(id multistore.StoreID) error {
+	if err := m.mds.Delete(id); err != nil {
+		return xerrors.Errorf("removing import: %w", err)
+	}
+
+	if err := m.ds.Delete(datastore.NewKey(fmt.Sprintf("%d", id))); err != nil {
+		return xerrors.Errorf("removing import metadata: %w", err)
+	}
+
+	return nil
+}
diff --git a/node/repo/interface.go b/node/repo/interface.go
index b4c2b0950..c25bcb534 100644
--- a/node/repo/interface.go
+++ b/node/repo/interface.go
@@ -6,13 +6,16 @@ import (
 	"github.com/ipfs/go-datastore"
 	"github.com/multiformats/go-multiaddr"
 
+	"github.com/filecoin-project/lotus/extern/sector-storage/fsutil"
+	"github.com/filecoin-project/lotus/extern/sector-storage/stores"
+
 	"github.com/filecoin-project/lotus/chain/types"
 )
 
 var (
 	ErrNoAPIEndpoint     = errors.New("API not running (no endpoint)")
 	ErrNoAPIToken        = errors.New("API token not set")
-	ErrRepoAlreadyLocked = errors.New("repo is already locked")
+	ErrRepoAlreadyLocked = errors.New("repo is already locked (lotus daemon already running)")
 	ErrClosedRepo        = errors.New("repo is no longer open")
 )
 
@@ -36,6 +39,12 @@ type LockedRepo interface {
 
 	// Returns config in this repo
 	Config() (interface{}, error)
+	SetConfig(func(interface{})) error
+
+	GetStorage() (stores.StorageConfig, error)
+	SetStorage(func(*stores.StorageConfig)) error
+	Stat(path string) (fsutil.FsStat, error)
+	DiskUsage(path string) (int64, error)
 
 	// SetAPIEndpoint sets the endpoint of the current API
 	// so it can be read by API clients
diff --git a/node/repo/memrepo.go b/node/repo/memrepo.go
index 6cc54ddb9..34e3637eb 100644
--- a/node/repo/memrepo.go
+++ b/node/repo/memrepo.go
@@ -1,17 +1,24 @@
 package repo
 
 import (
+	"encoding/json"
 	"io/ioutil"
 	"os"
+	"path/filepath"
 	"sync"
 
+	"github.com/google/uuid"
 	"github.com/ipfs/go-datastore"
 	"github.com/ipfs/go-datastore/namespace"
 	dssync "github.com/ipfs/go-datastore/sync"
 	"github.com/multiformats/go-multiaddr"
 	"golang.org/x/xerrors"
 
+	"github.com/filecoin-project/lotus/extern/sector-storage/fsutil"
+
 	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/extern/sector-storage/stores"
+	"github.com/filecoin-project/lotus/node/config"
 )
 
 type MemRepo struct {
@@ -25,8 +32,16 @@ type MemRepo struct {
 	token    *byte
 
 	datastore datastore.Datastore
-	configF   func(t RepoType) interface{}
 	keystore  map[string]types.KeyInfo
+
+	// given a repo type, produce the default config
+	configF func(t RepoType) interface{}
+
+	// holds the current config value
+	config struct {
+		sync.Mutex
+		val interface{}
+	}
 }
 
 type lockedMemRepo struct {
@@ -36,17 +51,83 @@ type lockedMemRepo struct {
 
 	tempDir string
 	token   *byte
+	sc      *stores.StorageConfig
+}
+
+func (lmem *lockedMemRepo) GetStorage() (stores.StorageConfig, error) {
+	if err := lmem.checkToken(); err != nil {
+		return stores.StorageConfig{}, err
+	}
+
+	if lmem.sc == nil {
+		lmem.sc = &stores.StorageConfig{StoragePaths: []stores.LocalPath{
+			{Path: lmem.Path()},
+		}}
+	}
+
+	return *lmem.sc, nil
+}
+
+func (lmem *lockedMemRepo) SetStorage(c func(*stores.StorageConfig)) error {
+	if err := lmem.checkToken(); err != nil {
+		return err
+	}
+
+	_, _ = lmem.GetStorage()
+
+	c(lmem.sc)
+	return nil
+}
+
+func (lmem *lockedMemRepo) Stat(path string) (fsutil.FsStat, error) {
+	return fsutil.Statfs(path)
+}
+
+func (lmem *lockedMemRepo) DiskUsage(path string) (int64, error) {
+	si, err := fsutil.FileSize(path)
+	if err != nil {
+		return 0, err
+	}
+	return si.OnDisk, nil
 }
 
 func (lmem *lockedMemRepo) Path() string {
+	lmem.Lock()
+	defer lmem.Unlock()
+
+	if lmem.tempDir != "" {
+		return lmem.tempDir
+	}
+
 	t, err := ioutil.TempDir(os.TempDir(), "lotus-memrepo-temp-")
 	if err != nil {
 		panic(err) // only used in tests, probably fine
 	}
 
-	lmem.Lock()
+	if lmem.t == StorageMiner {
+		if err := config.WriteStorageFile(filepath.Join(t, fsStorageConfig), stores.StorageConfig{
+			StoragePaths: []stores.LocalPath{
+				{Path: t},
+			}}); err != nil {
+			panic(err)
+		}
+
+		b, err := json.MarshalIndent(&stores.LocalStorageMeta{
+			ID:       stores.ID(uuid.New().String()),
+			Weight:   10,
+			CanSeal:  true,
+			CanStore: true,
+		}, "", "  ")
+		if err != nil {
+			panic(err)
+		}
+
+		if err := ioutil.WriteFile(filepath.Join(t, "sectorstore.json"), b, 0644); err != nil {
+			panic(err)
+		}
+	}
+
 	lmem.tempDir = t
-	lmem.Unlock()
 	return t
 }
 
@@ -162,11 +243,45 @@ func (lmem *lockedMemRepo) Datastore(ns string) (datastore.Batching, error) {
 	return namespace.Wrap(lmem.mem.datastore, datastore.NewKey(ns)), nil
 }
 
+func (lmem *lockedMemRepo) ListDatastores(ns string) ([]int64, error) {
+	return nil, nil
+}
+
+func (lmem *lockedMemRepo) DeleteDatastore(ns string) error {
+	/** poof **/
+	return nil
+}
+
 func (lmem *lockedMemRepo) Config() (interface{}, error) {
 	if err := lmem.checkToken(); err != nil {
 		return nil, err
 	}
-	return lmem.mem.configF(lmem.t), nil
+
+	lmem.mem.config.Lock()
+	defer lmem.mem.config.Unlock()
+
+	if lmem.mem.config.val == nil {
+		lmem.mem.config.val = lmem.mem.configF(lmem.t)
+	}
+
+	return lmem.mem.config.val, nil
+}
+
+func (lmem *lockedMemRepo) SetConfig(c func(interface{})) error {
+	if err := lmem.checkToken(); err != nil {
+		return err
+	}
+
+	lmem.mem.config.Lock()
+	defer lmem.mem.config.Unlock()
+
+	if lmem.mem.config.val == nil {
+		lmem.mem.config.val = lmem.mem.configF(lmem.t)
+	}
+
+	c(lmem.mem.config.val)
+
+	return nil
 }
 
 func (lmem *lockedMemRepo) SetAPIEndpoint(ma multiaddr.Multiaddr) error {
diff --git a/node/repo/repo_test.go b/node/repo/repo_test.go
index 9c43e8f4b..444fab267 100644
--- a/node/repo/repo_test.go
+++ b/node/repo/repo_test.go
@@ -9,6 +9,8 @@ import (
 
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/node/config"
+
+	"github.com/stretchr/testify/require"
 )
 
 func basicTest(t *testing.T, repo Repo) {
@@ -47,10 +49,23 @@ func basicTest(t *testing.T, repo Repo) {
 	assert.NoError(t, err, "setting multiaddr shouldn't error")
 	assert.Equal(t, ma, apima, "returned API multiaddr should be the same")
 
-	cfg, err := lrepo.Config()
-	assert.Equal(t, config.DefaultFullNode(), cfg, "there should be a default config")
+	c1, err := lrepo.Config()
+	assert.Equal(t, config.DefaultFullNode(), c1, "there should be a default config")
 	assert.NoError(t, err, "config should not error")
 
+	// mutate config and persist back to repo
+	err = lrepo.SetConfig(func(c interface{}) {
+		cfg := c.(*config.FullNode)
+		cfg.Client.IpfsMAddr = "duvall"
+	})
+	assert.NoError(t, err)
+
+	// load config and verify changes
+	c2, err := lrepo.Config()
+	require.NoError(t, err)
+	cfg2 := c2.(*config.FullNode)
+	require.Equal(t, cfg2.Client.IpfsMAddr, "duvall")
+
 	err = lrepo.Close()
 	assert.NoError(t, err, "should be able to close")
 
diff --git a/node/repo/retrievalstoremgr/retrievalstoremgr.go b/node/repo/retrievalstoremgr/retrievalstoremgr.go
new file mode 100644
index 000000000..e791150d9
--- /dev/null
+++ b/node/repo/retrievalstoremgr/retrievalstoremgr.go
@@ -0,0 +1,110 @@
+package retrievalstoremgr
+
+import (
+	"errors"
+
+	"github.com/filecoin-project/go-multistore"
+	"github.com/filecoin-project/lotus/lib/blockstore"
+	"github.com/filecoin-project/lotus/node/repo/importmgr"
+	"github.com/ipfs/go-blockservice"
+	offline "github.com/ipfs/go-ipfs-exchange-offline"
+	ipldformat "github.com/ipfs/go-ipld-format"
+	"github.com/ipfs/go-merkledag"
+)
+
+// RetrievalStore references a store for a retrieval deal
+// which may or may not have a multistore ID associated with it
+type RetrievalStore interface {
+	StoreID() *multistore.StoreID
+	DAGService() ipldformat.DAGService
+}
+
+// RetrievalStoreManager manages stores for retrieval deals, abstracting
+// the underlying storage mechanism
+type RetrievalStoreManager interface {
+	NewStore() (RetrievalStore, error)
+	ReleaseStore(RetrievalStore) error
+}
+
+// MultiStoreRetrievalStoreManager manages stores on top of the import manager
+type MultiStoreRetrievalStoreManager struct {
+	imgr *importmgr.Mgr
+}
+
+var _ RetrievalStoreManager = &MultiStoreRetrievalStoreManager{}
+
+// NewMultiStoreRetrievalStoreManager returns a new multstore based RetrievalStoreManager
+func NewMultiStoreRetrievalStoreManager(imgr *importmgr.Mgr) RetrievalStoreManager {
+	return &MultiStoreRetrievalStoreManager{
+		imgr: imgr,
+	}
+}
+
+// NewStore creates a new store (uses multistore)
+func (mrsm *MultiStoreRetrievalStoreManager) NewStore() (RetrievalStore, error) {
+	storeID, store, err := mrsm.imgr.NewStore()
+	if err != nil {
+		return nil, err
+	}
+	return &multiStoreRetrievalStore{storeID, store}, nil
+}
+
+// ReleaseStore releases a store (uses multistore remove)
+func (mrsm *MultiStoreRetrievalStoreManager) ReleaseStore(retrievalStore RetrievalStore) error {
+	mrs, ok := retrievalStore.(*multiStoreRetrievalStore)
+	if !ok {
+		return errors.New("Cannot release this store type")
+	}
+	return mrsm.imgr.Remove(mrs.storeID)
+}
+
+type multiStoreRetrievalStore struct {
+	storeID multistore.StoreID
+	store   *multistore.Store
+}
+
+func (mrs *multiStoreRetrievalStore) StoreID() *multistore.StoreID {
+	return &mrs.storeID
+}
+
+func (mrs *multiStoreRetrievalStore) DAGService() ipldformat.DAGService {
+	return mrs.store.DAG
+}
+
+// BlockstoreRetrievalStoreManager manages a single blockstore as if it were multiple stores
+type BlockstoreRetrievalStoreManager struct {
+	bs blockstore.Blockstore
+}
+
+var _ RetrievalStoreManager = &BlockstoreRetrievalStoreManager{}
+
+// NewBlockstoreRetrievalStoreManager returns a new blockstore based RetrievalStoreManager
+func NewBlockstoreRetrievalStoreManager(bs blockstore.Blockstore) RetrievalStoreManager {
+	return &BlockstoreRetrievalStoreManager{
+		bs: bs,
+	}
+}
+
+// NewStore creates a new store (just uses underlying blockstore)
+func (brsm *BlockstoreRetrievalStoreManager) NewStore() (RetrievalStore, error) {
+	return &blockstoreRetrievalStore{
+		dagService: merkledag.NewDAGService(blockservice.New(brsm.bs, offline.Exchange(brsm.bs))),
+	}, nil
+}
+
+// ReleaseStore for this implementation does nothing
+func (brsm *BlockstoreRetrievalStoreManager) ReleaseStore(RetrievalStore) error {
+	return nil
+}
+
+type blockstoreRetrievalStore struct {
+	dagService ipldformat.DAGService
+}
+
+func (brs *blockstoreRetrievalStore) StoreID() *multistore.StoreID {
+	return nil
+}
+
+func (brs *blockstoreRetrievalStore) DAGService() ipldformat.DAGService {
+	return brs.dagService
+}
diff --git a/node/repo/retrievalstoremgr/retrievalstoremgr_test.go b/node/repo/retrievalstoremgr/retrievalstoremgr_test.go
new file mode 100644
index 000000000..044a8cc27
--- /dev/null
+++ b/node/repo/retrievalstoremgr/retrievalstoremgr_test.go
@@ -0,0 +1,137 @@
+package retrievalstoremgr_test
+
+import (
+	"context"
+	"math/rand"
+	"testing"
+
+	"github.com/ipfs/go-cid"
+	"github.com/ipfs/go-datastore"
+	"github.com/ipfs/go-datastore/query"
+	dss "github.com/ipfs/go-datastore/sync"
+	blockstore "github.com/ipfs/go-ipfs-blockstore"
+	format "github.com/ipfs/go-ipld-format"
+	dag "github.com/ipfs/go-merkledag"
+	"github.com/stretchr/testify/require"
+
+	"github.com/filecoin-project/go-multistore"
+
+	"github.com/filecoin-project/lotus/node/repo/importmgr"
+	"github.com/filecoin-project/lotus/node/repo/retrievalstoremgr"
+)
+
+func TestMultistoreRetrievalStoreManager(t *testing.T) {
+	ctx := context.Background()
+	ds := dss.MutexWrap(datastore.NewMapDatastore())
+	multiDS, err := multistore.NewMultiDstore(ds)
+	require.NoError(t, err)
+	imgr := importmgr.New(multiDS, ds)
+	retrievalStoreMgr := retrievalstoremgr.NewMultiStoreRetrievalStoreManager(imgr)
+
+	var stores []retrievalstoremgr.RetrievalStore
+	for i := 0; i < 5; i++ {
+		store, err := retrievalStoreMgr.NewStore()
+		require.NoError(t, err)
+		stores = append(stores, store)
+		nds := generateNodesOfSize(5, 100)
+		err = store.DAGService().AddMany(ctx, nds)
+		require.NoError(t, err)
+	}
+
+	t.Run("creates all keys", func(t *testing.T) {
+		qres, err := ds.Query(query.Query{KeysOnly: true})
+		require.NoError(t, err)
+		all, err := qres.Rest()
+		require.NoError(t, err)
+		require.Len(t, all, 31)
+	})
+
+	t.Run("loads DAG services", func(t *testing.T) {
+		for _, store := range stores {
+			mstore, err := multiDS.Get(*store.StoreID())
+			require.NoError(t, err)
+			require.Equal(t, mstore.DAG, store.DAGService())
+		}
+	})
+
+	t.Run("delete stores", func(t *testing.T) {
+		err := retrievalStoreMgr.ReleaseStore(stores[4])
+		require.NoError(t, err)
+		storeIndexes := multiDS.List()
+		require.Len(t, storeIndexes, 4)
+
+		qres, err := ds.Query(query.Query{KeysOnly: true})
+		require.NoError(t, err)
+		all, err := qres.Rest()
+		require.NoError(t, err)
+		require.Len(t, all, 25)
+	})
+}
+
+func TestBlockstoreRetrievalStoreManager(t *testing.T) {
+	ctx := context.Background()
+	ds := dss.MutexWrap(datastore.NewMapDatastore())
+	bs := blockstore.NewBlockstore(ds)
+	retrievalStoreMgr := retrievalstoremgr.NewBlockstoreRetrievalStoreManager(bs)
+	var stores []retrievalstoremgr.RetrievalStore
+	var cids []cid.Cid
+	for i := 0; i < 5; i++ {
+		store, err := retrievalStoreMgr.NewStore()
+		require.NoError(t, err)
+		stores = append(stores, store)
+		nds := generateNodesOfSize(5, 100)
+		err = store.DAGService().AddMany(ctx, nds)
+		require.NoError(t, err)
+		for _, nd := range nds {
+			cids = append(cids, nd.Cid())
+		}
+	}
+
+	t.Run("creates all keys", func(t *testing.T) {
+		qres, err := ds.Query(query.Query{KeysOnly: true})
+		require.NoError(t, err)
+		all, err := qres.Rest()
+		require.NoError(t, err)
+		require.Len(t, all, 25)
+	})
+
+	t.Run("loads DAG services, all DAG has all nodes", func(t *testing.T) {
+		for _, store := range stores {
+			dagService := store.DAGService()
+			for _, cid := range cids {
+				_, err := dagService.Get(ctx, cid)
+				require.NoError(t, err)
+			}
+		}
+	})
+
+	t.Run("release store has no effect", func(t *testing.T) {
+		err := retrievalStoreMgr.ReleaseStore(stores[4])
+		require.NoError(t, err)
+		qres, err := ds.Query(query.Query{KeysOnly: true})
+		require.NoError(t, err)
+		all, err := qres.Rest()
+		require.NoError(t, err)
+		require.Len(t, all, 25)
+	})
+}
+
+var seedSeq int64 = 0
+
+func randomBytes(n int64) []byte {
+	randBytes := make([]byte, n)
+	r := rand.New(rand.NewSource(seedSeq))
+	_, _ = r.Read(randBytes)
+	seedSeq++
+	return randBytes
+}
+
+func generateNodesOfSize(n int, size int64) []format.Node {
+	generatedNodes := make([]format.Node, 0, n)
+	for i := 0; i < n; i++ {
+		b := dag.NewRawNode(randomBytes(size))
+		generatedNodes = append(generatedNodes, b)
+
+	}
+	return generatedNodes
+}
diff --git a/node/test/builder.go b/node/test/builder.go
new file mode 100644
index 000000000..c496b1e4c
--- /dev/null
+++ b/node/test/builder.go
@@ -0,0 +1,501 @@
+package test
+
+import (
+	"bytes"
+	"context"
+	"crypto/rand"
+	"io/ioutil"
+	"net"
+	"net/http/httptest"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-jsonrpc"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/big"
+	"github.com/filecoin-project/go-storedcounter"
+	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/api/client"
+	"github.com/filecoin-project/lotus/api/test"
+	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/actors"
+	"github.com/filecoin-project/lotus/chain/gen"
+	genesis2 "github.com/filecoin-project/lotus/chain/gen/genesis"
+	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/chain/wallet"
+	"github.com/filecoin-project/lotus/cmd/lotus-seed/seed"
+	sectorstorage "github.com/filecoin-project/lotus/extern/sector-storage"
+	"github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper"
+	"github.com/filecoin-project/lotus/extern/sector-storage/mock"
+	"github.com/filecoin-project/lotus/genesis"
+	miner2 "github.com/filecoin-project/lotus/miner"
+	"github.com/filecoin-project/lotus/node"
+	"github.com/filecoin-project/lotus/node/modules"
+	testing2 "github.com/filecoin-project/lotus/node/modules/testing"
+	"github.com/filecoin-project/lotus/node/repo"
+	"github.com/filecoin-project/lotus/storage/mockstorage"
+	"github.com/filecoin-project/specs-actors/actors/builtin"
+	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
+	"github.com/ipfs/go-datastore"
+	"github.com/libp2p/go-libp2p-core/crypto"
+	"github.com/libp2p/go-libp2p-core/peer"
+	mocknet "github.com/libp2p/go-libp2p/p2p/net/mock"
+	"github.com/multiformats/go-multiaddr"
+	"github.com/stretchr/testify/require"
+)
+
+func CreateTestStorageNode(ctx context.Context, t *testing.T, waddr address.Address, act address.Address, pk crypto.PrivKey, tnd test.TestNode, mn mocknet.Mocknet, opts node.Option) test.TestStorageNode {
+	r := repo.NewMemory(nil)
+
+	lr, err := r.Lock(repo.StorageMiner)
+	require.NoError(t, err)
+
+	ks, err := lr.KeyStore()
+	require.NoError(t, err)
+
+	kbytes, err := pk.Bytes()
+	require.NoError(t, err)
+
+	err = ks.Put("libp2p-host", types.KeyInfo{
+		Type:       "libp2p-host",
+		PrivateKey: kbytes,
+	})
+	require.NoError(t, err)
+
+	ds, err := lr.Datastore("/metadata")
+	require.NoError(t, err)
+	err = ds.Put(datastore.NewKey("miner-address"), act.Bytes())
+	require.NoError(t, err)
+
+	nic := storedcounter.New(ds, datastore.NewKey(modules.StorageCounterDSPrefix))
+	for i := 0; i < test.GenesisPreseals; i++ {
+		_, err := nic.Next()
+		require.NoError(t, err)
+	}
+	_, err = nic.Next()
+	require.NoError(t, err)
+
+	err = lr.Close()
+	require.NoError(t, err)
+
+	peerid, err := peer.IDFromPrivateKey(pk)
+	require.NoError(t, err)
+
+	enc, err := actors.SerializeParams(&miner0.ChangePeerIDParams{NewID: abi.PeerID(peerid)})
+	require.NoError(t, err)
+
+	msg := &types.Message{
+		To:     act,
+		From:   waddr,
+		Method: builtin.MethodsMiner.ChangePeerID,
+		Params: enc,
+		Value:  types.NewInt(0),
+	}
+
+	_, err = tnd.MpoolPushMessage(ctx, msg, nil)
+	require.NoError(t, err)
+
+	// start node
+	var minerapi api.StorageMiner
+
+	mineBlock := make(chan miner2.MineReq)
+	// TODO: use stop
+	_, err = node.New(ctx,
+		node.StorageMiner(&minerapi),
+		node.Online(),
+		node.Repo(r),
+		node.Test(),
+
+		node.MockHost(mn),
+
+		node.Override(new(api.FullNode), tnd),
+		node.Override(new(*miner2.Miner), miner2.NewTestMiner(mineBlock, act)),
+
+		opts,
+	)
+	if err != nil {
+		t.Fatalf("failed to construct node: %v", err)
+	}
+
+	/*// Bootstrap with full node
+	remoteAddrs, err := tnd.NetAddrsListen(ctx)
+	require.NoError(t, err)
+
+	err = minerapi.NetConnect(ctx, remoteAddrs)
+	require.NoError(t, err)*/
+	mineOne := func(ctx context.Context, req miner2.MineReq) error {
+		select {
+		case mineBlock <- req:
+			return nil
+		case <-ctx.Done():
+			return ctx.Err()
+		}
+	}
+
+	return test.TestStorageNode{StorageMiner: minerapi, MineOne: mineOne}
+}
+
+func Builder(t *testing.T, nFull int, storage []test.StorageMiner) ([]test.TestNode, []test.TestStorageNode) {
+	ctx := context.Background()
+	mn := mocknet.New(ctx)
+
+	fulls := make([]test.TestNode, nFull)
+	storers := make([]test.TestStorageNode, len(storage))
+
+	pk, _, err := crypto.GenerateEd25519Key(rand.Reader)
+	require.NoError(t, err)
+
+	minerPid, err := peer.IDFromPrivateKey(pk)
+	require.NoError(t, err)
+
+	var genbuf bytes.Buffer
+
+	if len(storage) > 1 {
+		panic("need more peer IDs")
+	}
+	// PRESEAL SECTION, TRY TO REPLACE WITH BETTER IN THE FUTURE
+	// TODO: would be great if there was a better way to fake the preseals
+
+	var genms []genesis.Miner
+	var maddrs []address.Address
+	var genaccs []genesis.Actor
+	var keys []*wallet.Key
+
+	var presealDirs []string
+	for i := 0; i < len(storage); i++ {
+		maddr, err := address.NewIDAddress(genesis2.MinerStart + uint64(i))
+		if err != nil {
+			t.Fatal(err)
+		}
+		tdir, err := ioutil.TempDir("", "preseal-memgen")
+		if err != nil {
+			t.Fatal(err)
+		}
+		genm, k, err := seed.PreSeal(maddr, abi.RegisteredSealProof_StackedDrg2KiBV1, 0, test.GenesisPreseals, tdir, []byte("make genesis mem random"), nil, true)
+		if err != nil {
+			t.Fatal(err)
+		}
+		genm.PeerId = minerPid
+
+		wk, err := wallet.NewKey(*k)
+		if err != nil {
+			return nil, nil
+		}
+
+		genaccs = append(genaccs, genesis.Actor{
+			Type:    genesis.TAccount,
+			Balance: big.Mul(big.NewInt(400000000), types.NewInt(build.FilecoinPrecision)),
+			Meta:    (&genesis.AccountMeta{Owner: wk.Address}).ActorMeta(),
+		})
+
+		keys = append(keys, wk)
+		presealDirs = append(presealDirs, tdir)
+		maddrs = append(maddrs, maddr)
+		genms = append(genms, *genm)
+	}
+	templ := &genesis.Template{
+		Accounts:         genaccs,
+		Miners:           genms,
+		Timestamp:        uint64(time.Now().Unix() - 10000), // some time sufficiently far in the past
+		VerifregRootKey:  gen.DefaultVerifregRootkeyActor,
+		RemainderAccount: gen.DefaultRemainderAccountActor,
+	}
+
+	// END PRESEAL SECTION
+
+	for i := 0; i < nFull; i++ {
+		var genesis node.Option
+		if i == 0 {
+			genesis = node.Override(new(modules.Genesis), testing2.MakeGenesisMem(&genbuf, *templ))
+		} else {
+			genesis = node.Override(new(modules.Genesis), modules.LoadGenesis(genbuf.Bytes()))
+		}
+
+		var err error
+		// TODO: Don't ignore stop
+		_, err = node.New(ctx,
+			node.FullAPI(&fulls[i].FullNode),
+			node.Online(),
+			node.Repo(repo.NewMemory(nil)),
+			node.MockHost(mn),
+			node.Test(),
+
+			genesis,
+		)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+	}
+
+	for i, def := range storage {
+		// TODO: support non-bootstrap miners
+		if i != 0 {
+			t.Fatal("only one storage node supported")
+		}
+		if def.Full != 0 {
+			t.Fatal("storage nodes only supported on the first full node")
+		}
+
+		f := fulls[def.Full]
+		if _, err := f.FullNode.WalletImport(ctx, &keys[i].KeyInfo); err != nil {
+			t.Fatal(err)
+		}
+		if err := f.FullNode.WalletSetDefault(ctx, keys[i].Address); err != nil {
+			t.Fatal(err)
+		}
+
+		genMiner := maddrs[i]
+		wa := genms[i].Worker
+
+		storers[i] = CreateTestStorageNode(ctx, t, wa, genMiner, pk, f, mn, node.Options())
+		if err := storers[i].StorageAddLocal(ctx, presealDirs[i]); err != nil {
+			t.Fatalf("%+v", err)
+		}
+		/*
+			sma := storers[i].StorageMiner.(*impl.StorageMinerAPI)
+
+			psd := presealDirs[i]
+		*/
+	}
+
+	if err := mn.LinkAll(); err != nil {
+		t.Fatal(err)
+	}
+
+	if len(storers) > 0 {
+		// Mine 2 blocks to setup some CE stuff in some actors
+		var wait sync.Mutex
+		wait.Lock()
+
+		test.MineUntilBlock(ctx, t, fulls[0], storers[0], func(epoch abi.ChainEpoch) {
+			wait.Unlock()
+		})
+
+		wait.Lock()
+		test.MineUntilBlock(ctx, t, fulls[0], storers[0], func(epoch abi.ChainEpoch) {
+			wait.Unlock()
+		})
+		wait.Lock()
+	}
+
+	return fulls, storers
+}
+
+func MockSbBuilder(t *testing.T, nFull int, storage []test.StorageMiner) ([]test.TestNode, []test.TestStorageNode) {
+	ctx := context.Background()
+	mn := mocknet.New(ctx)
+
+	fulls := make([]test.TestNode, nFull)
+	storers := make([]test.TestStorageNode, len(storage))
+
+	var genbuf bytes.Buffer
+
+	// PRESEAL SECTION, TRY TO REPLACE WITH BETTER IN THE FUTURE
+	// TODO: would be great if there was a better way to fake the preseals
+
+	var genms []genesis.Miner
+	var genaccs []genesis.Actor
+	var maddrs []address.Address
+	var keys []*wallet.Key
+	var pidKeys []crypto.PrivKey
+	for i := 0; i < len(storage); i++ {
+		maddr, err := address.NewIDAddress(genesis2.MinerStart + uint64(i))
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		preseals := storage[i].Preseal
+		if preseals == test.PresealGenesis {
+			preseals = test.GenesisPreseals
+		}
+
+		genm, k, err := mockstorage.PreSeal(2048, maddr, preseals)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		pk, _, err := crypto.GenerateEd25519Key(rand.Reader)
+		require.NoError(t, err)
+
+		minerPid, err := peer.IDFromPrivateKey(pk)
+		require.NoError(t, err)
+
+		genm.PeerId = minerPid
+
+		wk, err := wallet.NewKey(*k)
+		if err != nil {
+			return nil, nil
+		}
+
+		genaccs = append(genaccs, genesis.Actor{
+			Type:    genesis.TAccount,
+			Balance: big.Mul(big.NewInt(400000000), types.NewInt(build.FilecoinPrecision)),
+			Meta:    (&genesis.AccountMeta{Owner: wk.Address}).ActorMeta(),
+		})
+
+		keys = append(keys, wk)
+		pidKeys = append(pidKeys, pk)
+		maddrs = append(maddrs, maddr)
+		genms = append(genms, *genm)
+	}
+	templ := &genesis.Template{
+		Accounts:         genaccs,
+		Miners:           genms,
+		Timestamp:        uint64(time.Now().Unix()) - (build.BlockDelaySecs * 20000),
+		VerifregRootKey:  gen.DefaultVerifregRootkeyActor,
+		RemainderAccount: gen.DefaultRemainderAccountActor,
+	}
+
+	// END PRESEAL SECTION
+
+	for i := 0; i < nFull; i++ {
+		var genesis node.Option
+		if i == 0 {
+			genesis = node.Override(new(modules.Genesis), testing2.MakeGenesisMem(&genbuf, *templ))
+		} else {
+			genesis = node.Override(new(modules.Genesis), modules.LoadGenesis(genbuf.Bytes()))
+		}
+
+		var err error
+		// TODO: Don't ignore stop
+		_, err = node.New(ctx,
+			node.FullAPI(&fulls[i].FullNode),
+			node.Online(),
+			node.Repo(repo.NewMemory(nil)),
+			node.MockHost(mn),
+			node.Test(),
+
+			node.Override(new(ffiwrapper.Verifier), mock.MockVerifier),
+
+			genesis,
+		)
+		if err != nil {
+			t.Fatalf("%+v", err)
+		}
+	}
+
+	for i, def := range storage {
+		// TODO: support non-bootstrap miners
+
+		minerID := abi.ActorID(genesis2.MinerStart + uint64(i))
+
+		if def.Full != 0 {
+			t.Fatal("storage nodes only supported on the first full node")
+		}
+
+		f := fulls[def.Full]
+		if _, err := f.FullNode.WalletImport(ctx, &keys[i].KeyInfo); err != nil {
+			return nil, nil
+		}
+		if err := f.FullNode.WalletSetDefault(ctx, keys[i].Address); err != nil {
+			return nil, nil
+		}
+
+		sectors := make([]abi.SectorID, len(genms[i].Sectors))
+		for i, sector := range genms[i].Sectors {
+			sectors[i] = abi.SectorID{
+				Miner:  minerID,
+				Number: sector.SectorID,
+			}
+		}
+
+		storers[i] = CreateTestStorageNode(ctx, t, genms[i].Worker, maddrs[i], pidKeys[i], f, mn, node.Options(
+			node.Override(new(sectorstorage.SectorManager), func() (sectorstorage.SectorManager, error) {
+				return mock.NewMockSectorMgr(build.DefaultSectorSize(), sectors), nil
+			}),
+			node.Override(new(ffiwrapper.Verifier), mock.MockVerifier),
+			node.Unset(new(*sectorstorage.Manager)),
+		))
+	}
+
+	if err := mn.LinkAll(); err != nil {
+		t.Fatal(err)
+	}
+
+	if len(storers) > 0 {
+		// Mine 2 blocks to setup some CE stuff in some actors
+		var wait sync.Mutex
+		wait.Lock()
+
+		test.MineUntilBlock(ctx, t, fulls[0], storers[0], func(abi.ChainEpoch) {
+			wait.Unlock()
+		})
+		wait.Lock()
+		test.MineUntilBlock(ctx, t, fulls[0], storers[0], func(abi.ChainEpoch) {
+			wait.Unlock()
+		})
+		wait.Lock()
+	}
+
+	return fulls, storers
+}
+
+func RPCBuilder(t *testing.T, nFull int, storage []test.StorageMiner) ([]test.TestNode, []test.TestStorageNode) {
+	return rpcWithBuilder(t, Builder, nFull, storage)
+}
+
+func RPCMockSbBuilder(t *testing.T, nFull int, storage []test.StorageMiner) ([]test.TestNode, []test.TestStorageNode) {
+	return rpcWithBuilder(t, MockSbBuilder, nFull, storage)
+}
+
+func rpcWithBuilder(t *testing.T, b test.APIBuilder, nFull int, storage []test.StorageMiner) ([]test.TestNode, []test.TestStorageNode) {
+	fullApis, storaApis := b(t, nFull, storage)
+	fulls := make([]test.TestNode, nFull)
+	storers := make([]test.TestStorageNode, len(storage))
+
+	for i, a := range fullApis {
+		rpcServer := jsonrpc.NewServer()
+		rpcServer.Register("Filecoin", a)
+		testServ := httptest.NewServer(rpcServer) //  todo: close
+
+		addr := testServ.Listener.Addr()
+		listenAddr := "ws://" + addr.String()
+		var err error
+		fulls[i].FullNode, _, err = client.NewFullNodeRPC(context.Background(), listenAddr, nil)
+		if err != nil {
+			t.Fatal(err)
+		}
+		ma, err := parseWSSMultiAddr(addr)
+		if err != nil {
+			t.Fatal(err)
+		}
+		fulls[i].ListenAddr = ma
+	}
+
+	for i, a := range storaApis {
+		rpcServer := jsonrpc.NewServer()
+		rpcServer.Register("Filecoin", a)
+		testServ := httptest.NewServer(rpcServer) //  todo: close
+
+		addr := testServ.Listener.Addr()
+		listenAddr := "ws://" + addr.String()
+		var err error
+		storers[i].StorageMiner, _, err = client.NewStorageMinerRPC(context.Background(), listenAddr, nil)
+		if err != nil {
+			t.Fatal(err)
+		}
+		ma, err := parseWSSMultiAddr(addr)
+		if err != nil {
+			t.Fatal(err)
+		}
+		storers[i].ListenAddr = ma
+		storers[i].MineOne = a.MineOne
+	}
+
+	return fulls, storers
+}
+
+func parseWSSMultiAddr(addr net.Addr) (multiaddr.Multiaddr, error) {
+	host, port, err := net.SplitHostPort(addr.String())
+	if err != nil {
+		return nil, err
+	}
+	ma, err := multiaddr.NewMultiaddr("/ip4/" + host + "/" + addr.Network() + "/" + port + "/wss")
+	if err != nil {
+		return nil, err
+	}
+	return ma, nil
+}
diff --git a/paych/cbor_gen.go b/paych/cbor_gen.go
deleted file mode 100644
index 30bed0439..000000000
--- a/paych/cbor_gen.go
+++ /dev/null
@@ -1,240 +0,0 @@
-package paych
-
-import (
-	"fmt"
-	"io"
-
-	"github.com/filecoin-project/lotus/chain/types"
-	cbg "github.com/whyrusleeping/cbor-gen"
-	xerrors "golang.org/x/xerrors"
-)
-
-// Code generated by github.com/whyrusleeping/cbor-gen. DO NOT EDIT.
-
-var _ = xerrors.Errorf
-
-func (t *VoucherInfo) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{130}); err != nil {
-		return err
-	}
-
-	// t.Voucher (types.SignedVoucher) (struct)
-	if err := t.Voucher.MarshalCBOR(w); err != nil {
-		return err
-	}
-
-	// t.Proof ([]uint8) (slice)
-	if len(t.Proof) > cbg.ByteArrayMaxLen {
-		return xerrors.Errorf("Byte array in field t.Proof was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajByteString, uint64(len(t.Proof)))); err != nil {
-		return err
-	}
-	if _, err := w.Write(t.Proof); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *VoucherInfo) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 2 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	// t.Voucher (types.SignedVoucher) (struct)
-
-	{
-
-		pb, err := br.PeekByte()
-		if err != nil {
-			return err
-		}
-		if pb == cbg.CborNull[0] {
-			var nbuf [1]byte
-			if _, err := br.Read(nbuf[:]); err != nil {
-				return err
-			}
-		} else {
-			t.Voucher = new(types.SignedVoucher)
-			if err := t.Voucher.UnmarshalCBOR(br); err != nil {
-				return err
-			}
-		}
-
-	}
-	// t.Proof ([]uint8) (slice)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-
-	if extra > cbg.ByteArrayMaxLen {
-		return fmt.Errorf("t.Proof: byte array too large (%d)", extra)
-	}
-	if maj != cbg.MajByteString {
-		return fmt.Errorf("expected byte array")
-	}
-	t.Proof = make([]byte, extra)
-	if _, err := io.ReadFull(br, t.Proof); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *ChannelInfo) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{134}); err != nil {
-		return err
-	}
-
-	// t.Channel (address.Address) (struct)
-	if err := t.Channel.MarshalCBOR(w); err != nil {
-		return err
-	}
-
-	// t.Control (address.Address) (struct)
-	if err := t.Control.MarshalCBOR(w); err != nil {
-		return err
-	}
-
-	// t.Target (address.Address) (struct)
-	if err := t.Target.MarshalCBOR(w); err != nil {
-		return err
-	}
-
-	// t.Direction (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.Direction))); err != nil {
-		return err
-	}
-
-	// t.Vouchers ([]*paych.VoucherInfo) (slice)
-	if len(t.Vouchers) > cbg.MaxLength {
-		return xerrors.Errorf("Slice value in field t.Vouchers was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajArray, uint64(len(t.Vouchers)))); err != nil {
-		return err
-	}
-	for _, v := range t.Vouchers {
-		if err := v.MarshalCBOR(w); err != nil {
-			return err
-		}
-	}
-
-	// t.NextLane (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.NextLane))); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *ChannelInfo) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 6 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	// t.Channel (address.Address) (struct)
-
-	{
-
-		if err := t.Channel.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-	}
-	// t.Control (address.Address) (struct)
-
-	{
-
-		if err := t.Control.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-	}
-	// t.Target (address.Address) (struct)
-
-	{
-
-		if err := t.Target.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-	}
-	// t.Direction (uint64) (uint64)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.Direction = uint64(extra)
-	// t.Vouchers ([]*paych.VoucherInfo) (slice)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-
-	if extra > cbg.MaxLength {
-		return fmt.Errorf("t.Vouchers: array too large (%d)", extra)
-	}
-
-	if maj != cbg.MajArray {
-		return fmt.Errorf("expected cbor array")
-	}
-	if extra > 0 {
-		t.Vouchers = make([]*VoucherInfo, extra)
-	}
-	for i := 0; i < int(extra); i++ {
-
-		var v VoucherInfo
-		if err := v.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-		t.Vouchers[i] = &v
-	}
-
-	// t.NextLane (uint64) (uint64)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.NextLane = uint64(extra)
-	return nil
-}
diff --git a/paych/paych.go b/paych/paych.go
deleted file mode 100644
index 255d6c786..000000000
--- a/paych/paych.go
+++ /dev/null
@@ -1,348 +0,0 @@
-package paych
-
-import (
-	"bytes"
-	"context"
-	"fmt"
-	"math"
-	"strconv"
-
-	"golang.org/x/xerrors"
-
-	logging "github.com/ipfs/go-log"
-	"go.uber.org/fx"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/lotus/chain/actors"
-	"github.com/filecoin-project/lotus/chain/stmgr"
-	"github.com/filecoin-project/lotus/chain/types"
-	"github.com/filecoin-project/lotus/node/impl/full"
-)
-
-var log = logging.Logger("paych")
-
-type ManagerApi struct {
-	fx.In
-
-	full.MpoolAPI
-	full.WalletAPI
-	full.StateAPI
-}
-
-type Manager struct {
-	store *Store
-	sm    *stmgr.StateManager
-
-	mpool  full.MpoolAPI
-	wallet full.WalletAPI
-	state  full.StateAPI
-}
-
-func NewManager(sm *stmgr.StateManager, pchstore *Store, api ManagerApi) *Manager {
-	return &Manager{
-		store: pchstore,
-		sm:    sm,
-
-		mpool:  api.MpoolAPI,
-		wallet: api.WalletAPI,
-		state:  api.StateAPI,
-	}
-}
-
-func maxLaneFromState(st *actors.PaymentChannelActorState) (uint64, error) {
-	maxLane := uint64(math.MaxUint64)
-	for lane := range st.LaneStates {
-		ilane, err := strconv.ParseUint(lane, 10, 64)
-		if err != nil {
-			return 0, err
-		}
-		if ilane+1 > maxLane+1 {
-			maxLane = ilane
-		}
-	}
-	return maxLane, nil
-}
-
-func (pm *Manager) TrackInboundChannel(ctx context.Context, ch address.Address) error {
-	_, st, err := pm.loadPaychState(ctx, ch)
-	if err != nil {
-		return err
-	}
-
-	maxLane, err := maxLaneFromState(st)
-	if err != nil {
-		return err
-	}
-
-	return pm.store.TrackChannel(&ChannelInfo{
-		Channel: ch,
-		Control: st.To,
-		Target:  st.From,
-
-		Direction: DirInbound,
-		NextLane:  maxLane + 1,
-	})
-}
-
-func (pm *Manager) loadOutboundChannelInfo(ctx context.Context, ch address.Address) (*ChannelInfo, error) {
-	_, st, err := pm.loadPaychState(ctx, ch)
-	if err != nil {
-		return nil, err
-	}
-
-	maxLane, err := maxLaneFromState(st)
-	if err != nil {
-		return nil, err
-	}
-
-	return &ChannelInfo{
-		Channel: ch,
-		Control: st.From,
-		Target:  st.To,
-
-		Direction: DirOutbound,
-		NextLane:  maxLane + 1,
-	}, nil
-}
-
-func (pm *Manager) TrackOutboundChannel(ctx context.Context, ch address.Address) error {
-	ci, err := pm.loadOutboundChannelInfo(ctx, ch)
-	if err != nil {
-		return err
-	}
-
-	return pm.store.TrackChannel(ci)
-}
-
-func (pm *Manager) ListChannels() ([]address.Address, error) {
-	return pm.store.ListChannels()
-}
-
-func (pm *Manager) GetChannelInfo(addr address.Address) (*ChannelInfo, error) {
-	return pm.store.getChannelInfo(addr)
-}
-
-// checks if the given voucher is valid (is or could become spendable at some point)
-func (pm *Manager) CheckVoucherValid(ctx context.Context, ch address.Address, sv *types.SignedVoucher) error {
-	act, pca, err := pm.loadPaychState(ctx, ch)
-	if err != nil {
-		return err
-	}
-
-	// verify signature
-	vb, err := sv.SigningBytes()
-	if err != nil {
-		return err
-	}
-
-	// TODO: technically, either party may create and sign a voucher.
-	// However, for now, we only accept them from the channel creator.
-	// More complex handling logic can be added later
-	if err := sv.Signature.Verify(pca.From, vb); err != nil {
-		return err
-	}
-
-	sendAmount := sv.Amount
-
-	// now check the lane state
-	// TODO: should check against vouchers in our local store too
-	// there might be something conflicting
-	ls, ok := pca.LaneStates[fmt.Sprint(sv.Lane)]
-	if !ok {
-	} else {
-		if ls.Closed {
-			return fmt.Errorf("voucher is on a closed lane")
-		}
-		if ls.Nonce >= sv.Nonce {
-			return fmt.Errorf("nonce too low")
-		}
-
-		sendAmount = types.BigSub(sv.Amount, ls.Redeemed)
-	}
-
-	// TODO: also account for vouchers on other lanes we've received
-	newTotal := types.BigAdd(sendAmount, pca.ToSend)
-	if act.Balance.LessThan(newTotal) {
-		return fmt.Errorf("not enough funds in channel to cover voucher")
-	}
-
-	if len(sv.Merges) != 0 {
-		return fmt.Errorf("dont currently support paych lane merges")
-	}
-
-	return nil
-}
-
-// checks if the given voucher is currently spendable
-func (pm *Manager) CheckVoucherSpendable(ctx context.Context, ch address.Address, sv *types.SignedVoucher, secret []byte, proof []byte) (bool, error) {
-	owner, err := pm.getPaychOwner(ctx, ch)
-	if err != nil {
-		return false, err
-	}
-
-	if sv.Extra != nil && proof == nil {
-		known, err := pm.ListVouchers(ctx, ch)
-		if err != nil {
-			return false, err
-		}
-
-		for _, v := range known {
-			if v.Proof != nil && v.Voucher.Equals(sv) {
-				log.Info("CheckVoucherSpendable: using stored proof")
-				proof = v.Proof
-				break
-			}
-		}
-		if proof == nil {
-			log.Warn("CheckVoucherSpendable: nil proof for voucher with validation")
-		}
-	}
-
-	enc, err := actors.SerializeParams(&actors.PCAUpdateChannelStateParams{
-		Sv:     *sv,
-		Secret: secret,
-		Proof:  proof,
-	})
-	if err != nil {
-		return false, err
-	}
-
-	ret, err := pm.sm.Call(ctx, &types.Message{
-		From:   owner,
-		To:     ch,
-		Method: actors.PCAMethods.UpdateChannelState,
-		Params: enc,
-	}, nil)
-	if err != nil {
-		return false, err
-	}
-
-	if ret.ExitCode != 0 {
-		return false, nil
-	}
-
-	return true, nil
-}
-
-func (pm *Manager) getPaychOwner(ctx context.Context, ch address.Address) (address.Address, error) {
-	ret, err := pm.sm.Call(ctx, &types.Message{
-		From:   ch,
-		To:     ch,
-		Method: actors.PCAMethods.GetOwner,
-	}, nil)
-	if err != nil {
-		return address.Undef, err
-	}
-
-	if ret.ExitCode != 0 {
-		return address.Undef, fmt.Errorf("failed to get payment channel owner (exit code %d)", ret.ExitCode)
-	}
-
-	return address.NewFromBytes(ret.Return)
-}
-
-func (pm *Manager) AddVoucher(ctx context.Context, ch address.Address, sv *types.SignedVoucher, proof []byte, minDelta types.BigInt) (types.BigInt, error) {
-	if err := pm.CheckVoucherValid(ctx, ch, sv); err != nil {
-		return types.NewInt(0), err
-	}
-
-	pm.store.lk.Lock()
-	defer pm.store.lk.Unlock()
-
-	ci, err := pm.store.getChannelInfo(ch)
-	if err != nil {
-		return types.NewInt(0), err
-	}
-
-	laneState, err := pm.laneState(ctx, ch, sv.Lane)
-	if err != nil {
-		return types.NewInt(0), err
-	}
-
-	if laneState.Closed {
-		return types.NewInt(0), xerrors.New("lane closed")
-	}
-
-	if minDelta.GreaterThan(types.NewInt(0)) && laneState.Nonce > sv.Nonce {
-		return types.NewInt(0), xerrors.Errorf("already storing voucher with higher nonce; %d > %d", laneState.Nonce, sv.Nonce)
-	}
-
-	// look for duplicates
-	for i, v := range ci.Vouchers {
-		if !sv.Equals(v.Voucher) {
-			continue
-		}
-		if v.Proof != nil {
-			if !bytes.Equal(v.Proof, proof) {
-				log.Warnf("AddVoucher: multiple proofs for single voucher, storing both")
-				break
-			}
-			log.Warnf("AddVoucher: voucher re-added with matching proof")
-			return types.NewInt(0), nil
-		}
-
-		log.Warnf("AddVoucher: adding proof to stored voucher")
-		ci.Vouchers[i] = &VoucherInfo{
-			Voucher: v.Voucher,
-			Proof:   proof,
-		}
-
-		return types.NewInt(0), pm.store.putChannelInfo(ci)
-	}
-
-	delta := types.BigSub(sv.Amount, laneState.Redeemed)
-	if minDelta.GreaterThan(delta) {
-		return delta, xerrors.Errorf("addVoucher: supplied token amount too low; minD=%s, D=%s; laneAmt=%s; v.Amt=%s", minDelta, delta, laneState.Redeemed, sv.Amount)
-	}
-
-	ci.Vouchers = append(ci.Vouchers, &VoucherInfo{
-		Voucher: sv,
-		Proof:   proof,
-	})
-
-	if ci.NextLane <= sv.Lane {
-		ci.NextLane = sv.Lane + 1
-	}
-
-	return delta, pm.store.putChannelInfo(ci)
-}
-
-func (pm *Manager) AllocateLane(ch address.Address) (uint64, error) {
-	return pm.store.AllocateLane(ch)
-}
-
-func (pm *Manager) ListVouchers(ctx context.Context, ch address.Address) ([]*VoucherInfo, error) {
-	// TODO: just having a passthrough method like this feels odd. Seems like
-	// there should be some filtering we're doing here
-	return pm.store.VouchersForPaych(ch)
-}
-
-func (pm *Manager) OutboundChanTo(from, to address.Address) (address.Address, error) {
-	pm.store.lk.Lock()
-	defer pm.store.lk.Unlock()
-
-	return pm.store.findChan(func(ci *ChannelInfo) bool {
-		if ci.Direction != DirOutbound {
-			return false
-		}
-		return ci.Control == from && ci.Target == to
-	})
-}
-
-func (pm *Manager) NextNonceForLane(ctx context.Context, ch address.Address, lane uint64) (uint64, error) {
-	vouchers, err := pm.store.VouchersForPaych(ch)
-	if err != nil {
-		return 0, err
-	}
-
-	var maxnonce uint64
-	for _, v := range vouchers {
-		if v.Voucher.Lane == lane {
-			if v.Voucher.Nonce > maxnonce {
-				maxnonce = v.Voucher.Nonce
-			}
-		}
-	}
-
-	return maxnonce + 1, nil
-}
diff --git a/paych/simple.go b/paych/simple.go
deleted file mode 100644
index 0c5844545..000000000
--- a/paych/simple.go
+++ /dev/null
@@ -1,120 +0,0 @@
-package paych
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/ipfs/go-cid"
-	"golang.org/x/xerrors"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/lotus/chain/actors"
-	"github.com/filecoin-project/lotus/chain/types"
-)
-
-func (pm *Manager) createPaych(ctx context.Context, from, to address.Address, amt types.BigInt) (address.Address, cid.Cid, error) {
-	params, aerr := actors.SerializeParams(&actors.PCAConstructorParams{To: to})
-	if aerr != nil {
-		return address.Undef, cid.Undef, aerr
-	}
-
-	enc, aerr := actors.SerializeParams(&actors.ExecParams{
-		Params: params,
-		Code:   actors.PaymentChannelCodeCid,
-	})
-	if aerr != nil {
-		return address.Undef, cid.Undef, aerr
-	}
-
-	msg := &types.Message{
-		To:       actors.InitAddress,
-		From:     from,
-		Value:    amt,
-		Method:   actors.IAMethods.Exec,
-		Params:   enc,
-		GasLimit: types.NewInt(1000000),
-		GasPrice: types.NewInt(0),
-	}
-
-	smsg, err := pm.mpool.MpoolPushMessage(ctx, msg)
-	if err != nil {
-		return address.Undef, cid.Undef, xerrors.Errorf("initializing paych actor: %w", err)
-	}
-
-	mcid := smsg.Cid()
-
-	// TODO: wait outside the store lock!
-	//  (tricky because we need to setup channel tracking before we know it's address)
-	mwait, err := pm.state.StateWaitMsg(ctx, mcid)
-	if err != nil {
-		return address.Undef, cid.Undef, xerrors.Errorf("wait msg: %w", err)
-	}
-
-	if mwait.Receipt.ExitCode != 0 {
-		return address.Undef, cid.Undef, fmt.Errorf("payment channel creation failed (exit code %d)", mwait.Receipt.ExitCode)
-	}
-
-	paychaddr, err := address.NewFromBytes(mwait.Receipt.Return)
-	if err != nil {
-		return address.Undef, cid.Undef, err
-	}
-
-	ci, err := pm.loadOutboundChannelInfo(ctx, paychaddr)
-	if err != nil {
-		return address.Undef, cid.Undef, xerrors.Errorf("loading channel info: %w", err)
-	}
-
-	if err := pm.store.trackChannel(ci); err != nil {
-		return address.Undef, cid.Undef, xerrors.Errorf("tracking channel: %w", err)
-	}
-
-	return paychaddr, mcid, nil
-}
-
-func (pm *Manager) addFunds(ctx context.Context, ch address.Address, from address.Address, amt types.BigInt) error {
-	msg := &types.Message{
-		To:       ch,
-		From:     from,
-		Value:    amt,
-		Method:   0,
-		GasLimit: types.NewInt(1000000),
-		GasPrice: types.NewInt(0),
-	}
-
-	smsg, err := pm.mpool.MpoolPushMessage(ctx, msg)
-	if err != nil {
-		return err
-	}
-
-	mwait, err := pm.state.StateWaitMsg(ctx, smsg.Cid()) // TODO: wait outside the store lock!
-	if err != nil {
-		return err
-	}
-
-	if mwait.Receipt.ExitCode != 0 {
-		return fmt.Errorf("voucher channel creation failed: adding funds (exit code %d)", mwait.Receipt.ExitCode)
-	}
-
-	return nil
-}
-
-func (pm *Manager) GetPaych(ctx context.Context, from, to address.Address, ensureFree types.BigInt) (address.Address, cid.Cid, error) {
-	pm.store.lk.Lock()
-	defer pm.store.lk.Unlock()
-
-	ch, err := pm.store.findChan(func(ci *ChannelInfo) bool {
-		if ci.Direction != DirOutbound {
-			return false
-		}
-		return ci.Control == from && ci.Target == to
-	})
-	if err != nil {
-		return address.Undef, cid.Undef, xerrors.Errorf("findChan: %w", err)
-	}
-	if ch != address.Undef {
-		// TODO: Track available funds
-		return ch, cid.Undef, pm.addFunds(ctx, ch, from, ensureFree)
-	}
-
-	return pm.createPaych(ctx, from, to, ensureFree)
-}
diff --git a/paych/state.go b/paych/state.go
deleted file mode 100644
index bd9521864..000000000
--- a/paych/state.go
+++ /dev/null
@@ -1,73 +0,0 @@
-package paych
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/lotus/chain/actors"
-	"github.com/filecoin-project/lotus/chain/types"
-	xerrors "golang.org/x/xerrors"
-)
-
-func (pm *Manager) loadPaychState(ctx context.Context, ch address.Address) (*types.Actor, *actors.PaymentChannelActorState, error) {
-	var pcast actors.PaymentChannelActorState
-	act, err := pm.sm.LoadActorState(ctx, ch, &pcast, nil)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	return act, &pcast, nil
-}
-
-func (pm *Manager) laneState(ctx context.Context, ch address.Address, lane uint64) (actors.LaneState, error) {
-	_, state, err := pm.loadPaychState(ctx, ch)
-	if err != nil {
-		return actors.LaneState{}, err
-	}
-
-	// TODO: we probably want to call UpdateChannelState with all vouchers to be fully correct
-	//  (but technically dont't need to)
-	// TODO: make sure this is correct
-
-	ls, ok := state.LaneStates[fmt.Sprintf("%d", lane)]
-	if !ok {
-		ls = &actors.LaneState{
-			Closed:   false,
-			Redeemed: types.NewInt(0),
-			Nonce:    0,
-		}
-	}
-
-	if ls.Closed {
-		return *ls, nil
-	}
-
-	vouchers, err := pm.store.VouchersForPaych(ch)
-	if err != nil {
-		if err == ErrChannelNotTracked {
-			return *ls, nil
-		}
-		return actors.LaneState{}, err
-	}
-
-	for _, v := range vouchers {
-		for range v.Voucher.Merges {
-			return actors.LaneState{}, xerrors.Errorf("paych merges not handled yet")
-		}
-
-		if v.Voucher.Lane != lane {
-			continue
-		}
-
-		if v.Voucher.Nonce < ls.Nonce {
-			log.Warnf("Found outdated voucher: ch=%s, lane=%d, v.nonce=%d lane.nonce=%d", ch, lane, v.Voucher.Nonce, ls.Nonce)
-			continue
-		}
-
-		ls.Nonce = v.Voucher.Nonce
-		ls.Redeemed = v.Voucher.Amount
-	}
-
-	return *ls, nil
-}
diff --git a/paych/store.go b/paych/store.go
deleted file mode 100644
index f5e74b843..000000000
--- a/paych/store.go
+++ /dev/null
@@ -1,201 +0,0 @@
-package paych
-
-import (
-	"bytes"
-	"errors"
-	"fmt"
-	"strings"
-	"sync"
-
-	"github.com/ipfs/go-datastore"
-	"github.com/ipfs/go-datastore/namespace"
-	dsq "github.com/ipfs/go-datastore/query"
-	"golang.org/x/xerrors"
-
-	"github.com/filecoin-project/go-address"
-	cborrpc "github.com/filecoin-project/go-cbor-util"
-	"github.com/filecoin-project/lotus/chain/types"
-	"github.com/filecoin-project/lotus/node/modules/dtypes"
-)
-
-var ErrChannelNotTracked = errors.New("channel not tracked")
-
-type Store struct {
-	lk sync.Mutex // TODO: this can be split per paych
-
-	ds datastore.Batching
-}
-
-func NewStore(ds dtypes.MetadataDS) *Store {
-	ds = namespace.Wrap(ds, datastore.NewKey("/paych/"))
-	return &Store{
-		ds: ds,
-	}
-}
-
-const (
-	DirInbound  = 1
-	DirOutbound = 2
-)
-
-type VoucherInfo struct {
-	Voucher *types.SignedVoucher
-	Proof   []byte
-}
-
-type ChannelInfo struct {
-	Channel address.Address
-	Control address.Address
-	Target  address.Address
-
-	Direction uint64
-	Vouchers  []*VoucherInfo
-	NextLane  uint64
-}
-
-func dskeyForChannel(addr address.Address) datastore.Key {
-	return datastore.NewKey(addr.String())
-}
-
-func (ps *Store) putChannelInfo(ci *ChannelInfo) error {
-	k := dskeyForChannel(ci.Channel)
-
-	b, err := cborrpc.Dump(ci)
-	if err != nil {
-		return err
-	}
-
-	return ps.ds.Put(k, b)
-}
-
-func (ps *Store) getChannelInfo(addr address.Address) (*ChannelInfo, error) {
-	k := dskeyForChannel(addr)
-
-	b, err := ps.ds.Get(k)
-	if err == datastore.ErrNotFound {
-		return nil, ErrChannelNotTracked
-	}
-	if err != nil {
-		return nil, err
-	}
-
-	var ci ChannelInfo
-	if err := ci.UnmarshalCBOR(bytes.NewReader(b)); err != nil {
-		return nil, err
-	}
-
-	return &ci, nil
-}
-
-func (ps *Store) TrackChannel(ch *ChannelInfo) error {
-	ps.lk.Lock()
-	defer ps.lk.Unlock()
-
-	return ps.trackChannel(ch)
-}
-
-func (ps *Store) trackChannel(ch *ChannelInfo) error {
-	_, err := ps.getChannelInfo(ch.Channel)
-	switch err {
-	default:
-		return err
-	case nil:
-		return fmt.Errorf("already tracking channel: %s", ch.Channel)
-	case ErrChannelNotTracked:
-		return ps.putChannelInfo(ch)
-	}
-}
-
-func (ps *Store) ListChannels() ([]address.Address, error) {
-	ps.lk.Lock()
-	defer ps.lk.Unlock()
-
-	res, err := ps.ds.Query(dsq.Query{KeysOnly: true})
-	if err != nil {
-		return nil, err
-	}
-	defer res.Close()
-
-	var out []address.Address
-	for {
-		res, ok := res.NextSync()
-		if !ok {
-			break
-		}
-
-		if res.Error != nil {
-			return nil, err
-		}
-
-		addr, err := address.NewFromString(strings.TrimPrefix(res.Key, "/"))
-		if err != nil {
-			return nil, xerrors.Errorf("failed reading paych key (%q) from datastore: %w", res.Key, err)
-		}
-
-		out = append(out, addr)
-	}
-
-	return out, nil
-}
-
-func (ps *Store) findChan(filter func(*ChannelInfo) bool) (address.Address, error) {
-	res, err := ps.ds.Query(dsq.Query{})
-	if err != nil {
-		return address.Undef, err
-	}
-	defer res.Close()
-
-	var ci ChannelInfo
-
-	for {
-		res, ok := res.NextSync()
-		if !ok {
-			break
-		}
-
-		if res.Error != nil {
-			return address.Undef, err
-		}
-
-		if err := ci.UnmarshalCBOR(bytes.NewReader(res.Value)); err != nil {
-			return address.Undef, err
-		}
-
-		if !filter(&ci) {
-			continue
-		}
-
-		addr, err := address.NewFromString(strings.TrimPrefix(res.Key, "/"))
-		if err != nil {
-			return address.Undef, xerrors.Errorf("failed reading paych key (%q) from datastore: %w", res.Key, err)
-		}
-
-		return addr, nil
-	}
-
-	return address.Undef, nil
-}
-
-func (ps *Store) AllocateLane(ch address.Address) (uint64, error) {
-	ps.lk.Lock()
-	defer ps.lk.Unlock()
-
-	ci, err := ps.getChannelInfo(ch)
-	if err != nil {
-		return 0, err
-	}
-
-	out := ci.NextLane
-	ci.NextLane++
-
-	return out, ps.putChannelInfo(ci)
-}
-
-func (ps *Store) VouchersForPaych(ch address.Address) ([]*VoucherInfo, error) {
-	ci, err := ps.getChannelInfo(ch)
-	if err != nil {
-		return nil, err
-	}
-
-	return ci.Vouchers, nil
-}
diff --git a/paychmgr/accessorcache.go b/paychmgr/accessorcache.go
new file mode 100644
index 000000000..176fbdd11
--- /dev/null
+++ b/paychmgr/accessorcache.go
@@ -0,0 +1,67 @@
+package paychmgr
+
+import "github.com/filecoin-project/go-address"
+
+// accessorByFromTo gets a channel accessor for a given from / to pair.
+// The channel accessor facilitates locking a channel so that operations
+// must be performed sequentially on a channel (but can be performed at
+// the same time on different channels).
+func (pm *Manager) accessorByFromTo(from address.Address, to address.Address) (*channelAccessor, error) {
+	key := pm.accessorCacheKey(from, to)
+
+	// First take a read lock and check the cache
+	pm.lk.RLock()
+	ca, ok := pm.channels[key]
+	pm.lk.RUnlock()
+	if ok {
+		return ca, nil
+	}
+
+	// Not in cache, so take a write lock
+	pm.lk.Lock()
+	defer pm.lk.Unlock()
+
+	// Need to check cache again in case it was updated between releasing read
+	// lock and taking write lock
+	ca, ok = pm.channels[key]
+	if !ok {
+		// Not in cache, so create a new one and store in cache
+		ca = pm.addAccessorToCache(from, to)
+	}
+
+	return ca, nil
+}
+
+// accessorByAddress gets a channel accessor for a given channel address.
+// The channel accessor facilitates locking a channel so that operations
+// must be performed sequentially on a channel (but can be performed at
+// the same time on different channels).
+func (pm *Manager) accessorByAddress(ch address.Address) (*channelAccessor, error) {
+	// Get the channel from / to
+	pm.lk.RLock()
+	channelInfo, err := pm.store.ByAddress(ch)
+	pm.lk.RUnlock()
+	if err != nil {
+		return nil, err
+	}
+
+	// TODO: cache by channel address so we can get by address instead of using from / to
+	return pm.accessorByFromTo(channelInfo.Control, channelInfo.Target)
+}
+
+// accessorCacheKey returns the cache key use to reference a channel accessor
+func (pm *Manager) accessorCacheKey(from address.Address, to address.Address) string {
+	return from.String() + "->" + to.String()
+}
+
+// addAccessorToCache adds a channel accessor to the cache. Note that the
+// channel may not have been created yet, but we still want to reference
+// the same channel accessor for a given from/to, so that all attempts to
+// access a channel use the same lock (the lock on the accessor)
+func (pm *Manager) addAccessorToCache(from address.Address, to address.Address) *channelAccessor {
+	key := pm.accessorCacheKey(from, to)
+	ca := newChannelAccessor(pm, from, to)
+	// TODO: Use LRU
+	pm.channels[key] = ca
+	return ca
+}
diff --git a/paychmgr/cbor_gen.go b/paychmgr/cbor_gen.go
new file mode 100644
index 000000000..4c9259f06
--- /dev/null
+++ b/paychmgr/cbor_gen.go
@@ -0,0 +1,840 @@
+// Code generated by github.com/whyrusleeping/cbor-gen. DO NOT EDIT.
+
+package paychmgr
+
+import (
+	"fmt"
+	"io"
+
+	address "github.com/filecoin-project/go-address"
+	paych "github.com/filecoin-project/specs-actors/actors/builtin/paych"
+	cbg "github.com/whyrusleeping/cbor-gen"
+	xerrors "golang.org/x/xerrors"
+)
+
+var _ = xerrors.Errorf
+
+func (t *VoucherInfo) MarshalCBOR(w io.Writer) error {
+	if t == nil {
+		_, err := w.Write(cbg.CborNull)
+		return err
+	}
+	if _, err := w.Write([]byte{163}); err != nil {
+		return err
+	}
+
+	scratch := make([]byte, 9)
+
+	// t.Voucher (paych.SignedVoucher) (struct)
+	if len("Voucher") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"Voucher\" was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("Voucher"))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string("Voucher")); err != nil {
+		return err
+	}
+
+	if err := t.Voucher.MarshalCBOR(w); err != nil {
+		return err
+	}
+
+	// t.Proof ([]uint8) (slice)
+	if len("Proof") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"Proof\" was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("Proof"))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string("Proof")); err != nil {
+		return err
+	}
+
+	if len(t.Proof) > cbg.ByteArrayMaxLen {
+		return xerrors.Errorf("Byte array in field t.Proof was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajByteString, uint64(len(t.Proof))); err != nil {
+		return err
+	}
+
+	if _, err := w.Write(t.Proof[:]); err != nil {
+		return err
+	}
+
+	// t.Submitted (bool) (bool)
+	if len("Submitted") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"Submitted\" was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("Submitted"))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string("Submitted")); err != nil {
+		return err
+	}
+
+	if err := cbg.WriteBool(w, t.Submitted); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (t *VoucherInfo) UnmarshalCBOR(r io.Reader) error {
+	*t = VoucherInfo{}
+
+	br := cbg.GetPeeker(r)
+	scratch := make([]byte, 8)
+
+	maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
+	if err != nil {
+		return err
+	}
+	if maj != cbg.MajMap {
+		return fmt.Errorf("cbor input should be of type map")
+	}
+
+	if extra > cbg.MaxLength {
+		return fmt.Errorf("VoucherInfo: map struct too large (%d)", extra)
+	}
+
+	var name string
+	n := extra
+
+	for i := uint64(0); i < n; i++ {
+
+		{
+			sval, err := cbg.ReadStringBuf(br, scratch)
+			if err != nil {
+				return err
+			}
+
+			name = string(sval)
+		}
+
+		switch name {
+		// t.Voucher (paych.SignedVoucher) (struct)
+		case "Voucher":
+
+			{
+
+				b, err := br.ReadByte()
+				if err != nil {
+					return err
+				}
+				if b != cbg.CborNull[0] {
+					if err := br.UnreadByte(); err != nil {
+						return err
+					}
+					t.Voucher = new(paych.SignedVoucher)
+					if err := t.Voucher.UnmarshalCBOR(br); err != nil {
+						return xerrors.Errorf("unmarshaling t.Voucher pointer: %w", err)
+					}
+				}
+
+			}
+			// t.Proof ([]uint8) (slice)
+		case "Proof":
+
+			maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
+			if err != nil {
+				return err
+			}
+
+			if extra > cbg.ByteArrayMaxLen {
+				return fmt.Errorf("t.Proof: byte array too large (%d)", extra)
+			}
+			if maj != cbg.MajByteString {
+				return fmt.Errorf("expected byte array")
+			}
+
+			if extra > 0 {
+				t.Proof = make([]uint8, extra)
+			}
+
+			if _, err := io.ReadFull(br, t.Proof[:]); err != nil {
+				return err
+			}
+			// t.Submitted (bool) (bool)
+		case "Submitted":
+
+			maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
+			if err != nil {
+				return err
+			}
+			if maj != cbg.MajOther {
+				return fmt.Errorf("booleans must be major type 7")
+			}
+			switch extra {
+			case 20:
+				t.Submitted = false
+			case 21:
+				t.Submitted = true
+			default:
+				return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
+			}
+
+		default:
+			return fmt.Errorf("unknown struct field %d: '%s'", i, name)
+		}
+	}
+
+	return nil
+}
+func (t *ChannelInfo) MarshalCBOR(w io.Writer) error {
+	if t == nil {
+		_, err := w.Write(cbg.CborNull)
+		return err
+	}
+	if _, err := w.Write([]byte{172}); err != nil {
+		return err
+	}
+
+	scratch := make([]byte, 9)
+
+	// t.ChannelID (string) (string)
+	if len("ChannelID") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"ChannelID\" was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("ChannelID"))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string("ChannelID")); err != nil {
+		return err
+	}
+
+	if len(t.ChannelID) > cbg.MaxLength {
+		return xerrors.Errorf("Value in field t.ChannelID was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len(t.ChannelID))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string(t.ChannelID)); err != nil {
+		return err
+	}
+
+	// t.Channel (address.Address) (struct)
+	if len("Channel") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"Channel\" was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("Channel"))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string("Channel")); err != nil {
+		return err
+	}
+
+	if err := t.Channel.MarshalCBOR(w); err != nil {
+		return err
+	}
+
+	// t.Control (address.Address) (struct)
+	if len("Control") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"Control\" was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("Control"))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string("Control")); err != nil {
+		return err
+	}
+
+	if err := t.Control.MarshalCBOR(w); err != nil {
+		return err
+	}
+
+	// t.Target (address.Address) (struct)
+	if len("Target") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"Target\" was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("Target"))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string("Target")); err != nil {
+		return err
+	}
+
+	if err := t.Target.MarshalCBOR(w); err != nil {
+		return err
+	}
+
+	// t.Direction (uint64) (uint64)
+	if len("Direction") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"Direction\" was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("Direction"))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string("Direction")); err != nil {
+		return err
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.Direction)); err != nil {
+		return err
+	}
+
+	// t.Vouchers ([]*paychmgr.VoucherInfo) (slice)
+	if len("Vouchers") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"Vouchers\" was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("Vouchers"))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string("Vouchers")); err != nil {
+		return err
+	}
+
+	if len(t.Vouchers) > cbg.MaxLength {
+		return xerrors.Errorf("Slice value in field t.Vouchers was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajArray, uint64(len(t.Vouchers))); err != nil {
+		return err
+	}
+	for _, v := range t.Vouchers {
+		if err := v.MarshalCBOR(w); err != nil {
+			return err
+		}
+	}
+
+	// t.NextLane (uint64) (uint64)
+	if len("NextLane") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"NextLane\" was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("NextLane"))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string("NextLane")); err != nil {
+		return err
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.NextLane)); err != nil {
+		return err
+	}
+
+	// t.Amount (big.Int) (struct)
+	if len("Amount") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"Amount\" was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("Amount"))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string("Amount")); err != nil {
+		return err
+	}
+
+	if err := t.Amount.MarshalCBOR(w); err != nil {
+		return err
+	}
+
+	// t.PendingAmount (big.Int) (struct)
+	if len("PendingAmount") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"PendingAmount\" was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("PendingAmount"))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string("PendingAmount")); err != nil {
+		return err
+	}
+
+	if err := t.PendingAmount.MarshalCBOR(w); err != nil {
+		return err
+	}
+
+	// t.CreateMsg (cid.Cid) (struct)
+	if len("CreateMsg") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"CreateMsg\" was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("CreateMsg"))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string("CreateMsg")); err != nil {
+		return err
+	}
+
+	if t.CreateMsg == nil {
+		if _, err := w.Write(cbg.CborNull); err != nil {
+			return err
+		}
+	} else {
+		if err := cbg.WriteCidBuf(scratch, w, *t.CreateMsg); err != nil {
+			return xerrors.Errorf("failed to write cid field t.CreateMsg: %w", err)
+		}
+	}
+
+	// t.AddFundsMsg (cid.Cid) (struct)
+	if len("AddFundsMsg") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"AddFundsMsg\" was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("AddFundsMsg"))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string("AddFundsMsg")); err != nil {
+		return err
+	}
+
+	if t.AddFundsMsg == nil {
+		if _, err := w.Write(cbg.CborNull); err != nil {
+			return err
+		}
+	} else {
+		if err := cbg.WriteCidBuf(scratch, w, *t.AddFundsMsg); err != nil {
+			return xerrors.Errorf("failed to write cid field t.AddFundsMsg: %w", err)
+		}
+	}
+
+	// t.Settling (bool) (bool)
+	if len("Settling") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"Settling\" was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("Settling"))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string("Settling")); err != nil {
+		return err
+	}
+
+	if err := cbg.WriteBool(w, t.Settling); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (t *ChannelInfo) UnmarshalCBOR(r io.Reader) error {
+	*t = ChannelInfo{}
+
+	br := cbg.GetPeeker(r)
+	scratch := make([]byte, 8)
+
+	maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
+	if err != nil {
+		return err
+	}
+	if maj != cbg.MajMap {
+		return fmt.Errorf("cbor input should be of type map")
+	}
+
+	if extra > cbg.MaxLength {
+		return fmt.Errorf("ChannelInfo: map struct too large (%d)", extra)
+	}
+
+	var name string
+	n := extra
+
+	for i := uint64(0); i < n; i++ {
+
+		{
+			sval, err := cbg.ReadStringBuf(br, scratch)
+			if err != nil {
+				return err
+			}
+
+			name = string(sval)
+		}
+
+		switch name {
+		// t.ChannelID (string) (string)
+		case "ChannelID":
+
+			{
+				sval, err := cbg.ReadStringBuf(br, scratch)
+				if err != nil {
+					return err
+				}
+
+				t.ChannelID = string(sval)
+			}
+			// t.Channel (address.Address) (struct)
+		case "Channel":
+
+			{
+
+				b, err := br.ReadByte()
+				if err != nil {
+					return err
+				}
+				if b != cbg.CborNull[0] {
+					if err := br.UnreadByte(); err != nil {
+						return err
+					}
+					t.Channel = new(address.Address)
+					if err := t.Channel.UnmarshalCBOR(br); err != nil {
+						return xerrors.Errorf("unmarshaling t.Channel pointer: %w", err)
+					}
+				}
+
+			}
+			// t.Control (address.Address) (struct)
+		case "Control":
+
+			{
+
+				if err := t.Control.UnmarshalCBOR(br); err != nil {
+					return xerrors.Errorf("unmarshaling t.Control: %w", err)
+				}
+
+			}
+			// t.Target (address.Address) (struct)
+		case "Target":
+
+			{
+
+				if err := t.Target.UnmarshalCBOR(br); err != nil {
+					return xerrors.Errorf("unmarshaling t.Target: %w", err)
+				}
+
+			}
+			// t.Direction (uint64) (uint64)
+		case "Direction":
+
+			{
+
+				maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
+				if err != nil {
+					return err
+				}
+				if maj != cbg.MajUnsignedInt {
+					return fmt.Errorf("wrong type for uint64 field")
+				}
+				t.Direction = uint64(extra)
+
+			}
+			// t.Vouchers ([]*paychmgr.VoucherInfo) (slice)
+		case "Vouchers":
+
+			maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
+			if err != nil {
+				return err
+			}
+
+			if extra > cbg.MaxLength {
+				return fmt.Errorf("t.Vouchers: array too large (%d)", extra)
+			}
+
+			if maj != cbg.MajArray {
+				return fmt.Errorf("expected cbor array")
+			}
+
+			if extra > 0 {
+				t.Vouchers = make([]*VoucherInfo, extra)
+			}
+
+			for i := 0; i < int(extra); i++ {
+
+				var v VoucherInfo
+				if err := v.UnmarshalCBOR(br); err != nil {
+					return err
+				}
+
+				t.Vouchers[i] = &v
+			}
+
+			// t.NextLane (uint64) (uint64)
+		case "NextLane":
+
+			{
+
+				maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
+				if err != nil {
+					return err
+				}
+				if maj != cbg.MajUnsignedInt {
+					return fmt.Errorf("wrong type for uint64 field")
+				}
+				t.NextLane = uint64(extra)
+
+			}
+			// t.Amount (big.Int) (struct)
+		case "Amount":
+
+			{
+
+				if err := t.Amount.UnmarshalCBOR(br); err != nil {
+					return xerrors.Errorf("unmarshaling t.Amount: %w", err)
+				}
+
+			}
+			// t.PendingAmount (big.Int) (struct)
+		case "PendingAmount":
+
+			{
+
+				if err := t.PendingAmount.UnmarshalCBOR(br); err != nil {
+					return xerrors.Errorf("unmarshaling t.PendingAmount: %w", err)
+				}
+
+			}
+			// t.CreateMsg (cid.Cid) (struct)
+		case "CreateMsg":
+
+			{
+
+				b, err := br.ReadByte()
+				if err != nil {
+					return err
+				}
+				if b != cbg.CborNull[0] {
+					if err := br.UnreadByte(); err != nil {
+						return err
+					}
+
+					c, err := cbg.ReadCid(br)
+					if err != nil {
+						return xerrors.Errorf("failed to read cid field t.CreateMsg: %w", err)
+					}
+
+					t.CreateMsg = &c
+				}
+
+			}
+			// t.AddFundsMsg (cid.Cid) (struct)
+		case "AddFundsMsg":
+
+			{
+
+				b, err := br.ReadByte()
+				if err != nil {
+					return err
+				}
+				if b != cbg.CborNull[0] {
+					if err := br.UnreadByte(); err != nil {
+						return err
+					}
+
+					c, err := cbg.ReadCid(br)
+					if err != nil {
+						return xerrors.Errorf("failed to read cid field t.AddFundsMsg: %w", err)
+					}
+
+					t.AddFundsMsg = &c
+				}
+
+			}
+			// t.Settling (bool) (bool)
+		case "Settling":
+
+			maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
+			if err != nil {
+				return err
+			}
+			if maj != cbg.MajOther {
+				return fmt.Errorf("booleans must be major type 7")
+			}
+			switch extra {
+			case 20:
+				t.Settling = false
+			case 21:
+				t.Settling = true
+			default:
+				return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
+			}
+
+		default:
+			return fmt.Errorf("unknown struct field %d: '%s'", i, name)
+		}
+	}
+
+	return nil
+}
+func (t *MsgInfo) MarshalCBOR(w io.Writer) error {
+	if t == nil {
+		_, err := w.Write(cbg.CborNull)
+		return err
+	}
+	if _, err := w.Write([]byte{164}); err != nil {
+		return err
+	}
+
+	scratch := make([]byte, 9)
+
+	// t.ChannelID (string) (string)
+	if len("ChannelID") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"ChannelID\" was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("ChannelID"))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string("ChannelID")); err != nil {
+		return err
+	}
+
+	if len(t.ChannelID) > cbg.MaxLength {
+		return xerrors.Errorf("Value in field t.ChannelID was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len(t.ChannelID))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string(t.ChannelID)); err != nil {
+		return err
+	}
+
+	// t.MsgCid (cid.Cid) (struct)
+	if len("MsgCid") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"MsgCid\" was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("MsgCid"))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string("MsgCid")); err != nil {
+		return err
+	}
+
+	if err := cbg.WriteCidBuf(scratch, w, t.MsgCid); err != nil {
+		return xerrors.Errorf("failed to write cid field t.MsgCid: %w", err)
+	}
+
+	// t.Received (bool) (bool)
+	if len("Received") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"Received\" was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("Received"))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string("Received")); err != nil {
+		return err
+	}
+
+	if err := cbg.WriteBool(w, t.Received); err != nil {
+		return err
+	}
+
+	// t.Err (string) (string)
+	if len("Err") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"Err\" was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("Err"))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string("Err")); err != nil {
+		return err
+	}
+
+	if len(t.Err) > cbg.MaxLength {
+		return xerrors.Errorf("Value in field t.Err was too long")
+	}
+
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len(t.Err))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string(t.Err)); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (t *MsgInfo) UnmarshalCBOR(r io.Reader) error {
+	*t = MsgInfo{}
+
+	br := cbg.GetPeeker(r)
+	scratch := make([]byte, 8)
+
+	maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
+	if err != nil {
+		return err
+	}
+	if maj != cbg.MajMap {
+		return fmt.Errorf("cbor input should be of type map")
+	}
+
+	if extra > cbg.MaxLength {
+		return fmt.Errorf("MsgInfo: map struct too large (%d)", extra)
+	}
+
+	var name string
+	n := extra
+
+	for i := uint64(0); i < n; i++ {
+
+		{
+			sval, err := cbg.ReadStringBuf(br, scratch)
+			if err != nil {
+				return err
+			}
+
+			name = string(sval)
+		}
+
+		switch name {
+		// t.ChannelID (string) (string)
+		case "ChannelID":
+
+			{
+				sval, err := cbg.ReadStringBuf(br, scratch)
+				if err != nil {
+					return err
+				}
+
+				t.ChannelID = string(sval)
+			}
+			// t.MsgCid (cid.Cid) (struct)
+		case "MsgCid":
+
+			{
+
+				c, err := cbg.ReadCid(br)
+				if err != nil {
+					return xerrors.Errorf("failed to read cid field t.MsgCid: %w", err)
+				}
+
+				t.MsgCid = c
+
+			}
+			// t.Received (bool) (bool)
+		case "Received":
+
+			maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
+			if err != nil {
+				return err
+			}
+			if maj != cbg.MajOther {
+				return fmt.Errorf("booleans must be major type 7")
+			}
+			switch extra {
+			case 20:
+				t.Received = false
+			case 21:
+				t.Received = true
+			default:
+				return fmt.Errorf("booleans are either major type 7, value 20 or 21 (got %d)", extra)
+			}
+			// t.Err (string) (string)
+		case "Err":
+
+			{
+				sval, err := cbg.ReadStringBuf(br, scratch)
+				if err != nil {
+					return err
+				}
+
+				t.Err = string(sval)
+			}
+
+		default:
+			return fmt.Errorf("unknown struct field %d: '%s'", i, name)
+		}
+	}
+
+	return nil
+}
diff --git a/paychmgr/channellock.go b/paychmgr/channellock.go
new file mode 100644
index 000000000..0dc785ec0
--- /dev/null
+++ b/paychmgr/channellock.go
@@ -0,0 +1,33 @@
+package paychmgr
+
+import "sync"
+
+type rwlock interface {
+	RLock()
+	RUnlock()
+}
+
+// channelLock manages locking for a specific channel.
+// Some operations update the state of a single channel, and need to block
+// other operations only on the same channel's state.
+// Some operations update state that affects all channels, and need to block
+// any operation against any channel.
+type channelLock struct {
+	globalLock rwlock
+	chanLock   sync.Mutex
+}
+
+func (l *channelLock) Lock() {
+	// Wait for other operations by this channel to finish.
+	// Exclusive per-channel (no other ops by this channel allowed).
+	l.chanLock.Lock()
+	// Wait for operations affecting all channels to finish.
+	// Allows ops by other channels in parallel, but blocks all operations
+	// if global lock is taken exclusively (eg when adding a channel)
+	l.globalLock.RLock()
+}
+
+func (l *channelLock) Unlock() {
+	l.globalLock.RUnlock()
+	l.chanLock.Unlock()
+}
diff --git a/paychmgr/manager.go b/paychmgr/manager.go
new file mode 100644
index 000000000..d9c568cbe
--- /dev/null
+++ b/paychmgr/manager.go
@@ -0,0 +1,377 @@
+package paychmgr
+
+import (
+	"context"
+	"sync"
+
+	"github.com/ipfs/go-cid"
+	"github.com/ipfs/go-datastore"
+	logging "github.com/ipfs/go-log/v2"
+	"go.uber.org/fx"
+	xerrors "golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/crypto"
+	paych0 "github.com/filecoin-project/specs-actors/actors/builtin/paych"
+
+	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/chain/actors/adt"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/paych"
+	"github.com/filecoin-project/lotus/chain/stmgr"
+	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/node/impl/full"
+	"github.com/filecoin-project/lotus/node/modules/helpers"
+)
+
+var log = logging.Logger("paych")
+
+// PaychAPI is used by dependency injection to pass the consituent APIs to NewManager()
+type PaychAPI struct {
+	fx.In
+
+	full.MpoolAPI
+	full.StateAPI
+}
+
+// stateManagerAPI defines the methods needed from StateManager
+type stateManagerAPI interface {
+	ResolveToKeyAddress(ctx context.Context, addr address.Address, ts *types.TipSet) (address.Address, error)
+	GetPaychState(ctx context.Context, addr address.Address, ts *types.TipSet) (*types.Actor, paych.State, error)
+	Call(ctx context.Context, msg *types.Message, ts *types.TipSet) (*api.InvocResult, error)
+}
+
+// paychAPI defines the API methods needed by the payment channel manager
+type paychAPI interface {
+	StateAccountKey(context.Context, address.Address, types.TipSetKey) (address.Address, error)
+	StateWaitMsg(ctx context.Context, msg cid.Cid, confidence uint64) (*api.MsgLookup, error)
+	MpoolPushMessage(ctx context.Context, msg *types.Message, maxFee *api.MessageSendSpec) (*types.SignedMessage, error)
+	WalletHas(ctx context.Context, addr address.Address) (bool, error)
+	WalletSign(ctx context.Context, k address.Address, msg []byte) (*crypto.Signature, error)
+}
+
+// managerAPI defines all methods needed by the manager
+type managerAPI interface {
+	stateManagerAPI
+	paychAPI
+}
+
+// managerAPIImpl is used to create a composite that implements managerAPI
+type managerAPIImpl struct {
+	*stmgr.StateManager
+	paychAPI
+}
+
+func (m *managerAPIImpl) AdtStore(ctx context.Context) adt.Store {
+	return m.ChainStore().Store(ctx)
+}
+
+type Manager struct {
+	// The Manager context is used to terminate wait operations on shutdown
+	ctx      context.Context
+	shutdown context.CancelFunc
+
+	store  *Store
+	sa     *stateAccessor
+	pchapi managerAPI
+
+	lk       sync.RWMutex
+	channels map[string]*channelAccessor
+}
+
+func NewManager(mctx helpers.MetricsCtx, lc fx.Lifecycle, sm *stmgr.StateManager, pchstore *Store, api PaychAPI) *Manager {
+	ctx := helpers.LifecycleCtx(mctx, lc)
+	ctx, shutdown := context.WithCancel(ctx)
+
+	impl := &managerAPIImpl{StateManager: sm, paychAPI: &api}
+	return &Manager{
+		ctx:      ctx,
+		shutdown: shutdown,
+		store:    pchstore,
+		sa:       &stateAccessor{sm: impl},
+		channels: make(map[string]*channelAccessor),
+		pchapi:   impl,
+	}
+}
+
+// newManager is used by the tests to supply mocks
+func newManager(pchstore *Store, pchapi managerAPI) (*Manager, error) {
+	pm := &Manager{
+		store:    pchstore,
+		sa:       &stateAccessor{sm: pchapi},
+		channels: make(map[string]*channelAccessor),
+		pchapi:   pchapi,
+	}
+	return pm, pm.Start()
+}
+
+// HandleManager is called by dependency injection to set up hooks
+func HandleManager(lc fx.Lifecycle, pm *Manager) {
+	lc.Append(fx.Hook{
+		OnStart: func(ctx context.Context) error {
+			return pm.Start()
+		},
+		OnStop: func(context.Context) error {
+			return pm.Stop()
+		},
+	})
+}
+
+// Start restarts tracking of any messages that were sent to chain.
+func (pm *Manager) Start() error {
+	return pm.restartPending()
+}
+
+// Stop shuts down any processes used by the manager
+func (pm *Manager) Stop() error {
+	pm.shutdown()
+	return nil
+}
+
+func (pm *Manager) GetPaych(ctx context.Context, from, to address.Address, amt types.BigInt) (address.Address, cid.Cid, error) {
+	chanAccessor, err := pm.accessorByFromTo(from, to)
+	if err != nil {
+		return address.Undef, cid.Undef, err
+	}
+
+	return chanAccessor.getPaych(ctx, amt)
+}
+
+func (pm *Manager) AvailableFunds(ch address.Address) (*api.ChannelAvailableFunds, error) {
+	ca, err := pm.accessorByAddress(ch)
+	if err != nil {
+		return nil, err
+	}
+
+	ci, err := ca.getChannelInfo(ch)
+	if err != nil {
+		return nil, err
+	}
+
+	return ca.availableFunds(ci.ChannelID)
+}
+
+func (pm *Manager) AvailableFundsByFromTo(from address.Address, to address.Address) (*api.ChannelAvailableFunds, error) {
+	ca, err := pm.accessorByFromTo(from, to)
+	if err != nil {
+		return nil, err
+	}
+
+	ci, err := ca.outboundActiveByFromTo(from, to)
+	if err == ErrChannelNotTracked {
+		// If there is no active channel between from / to we still want to
+		// return an empty ChannelAvailableFunds, so that clients can check
+		// for the existence of a channel between from / to without getting
+		// an error.
+		return &api.ChannelAvailableFunds{
+			Channel:             nil,
+			From:                from,
+			To:                  to,
+			ConfirmedAmt:        types.NewInt(0),
+			PendingAmt:          types.NewInt(0),
+			PendingWaitSentinel: nil,
+			QueuedAmt:           types.NewInt(0),
+			VoucherReedeemedAmt: types.NewInt(0),
+		}, nil
+	}
+	if err != nil {
+		return nil, err
+	}
+
+	return ca.availableFunds(ci.ChannelID)
+}
+
+// GetPaychWaitReady waits until the create channel / add funds message with the
+// given message CID arrives.
+// The returned channel address can safely be used against the Manager methods.
+func (pm *Manager) GetPaychWaitReady(ctx context.Context, mcid cid.Cid) (address.Address, error) {
+	// Find the channel associated with the message CID
+	pm.lk.Lock()
+	ci, err := pm.store.ByMessageCid(mcid)
+	pm.lk.Unlock()
+
+	if err != nil {
+		if err == datastore.ErrNotFound {
+			return address.Undef, xerrors.Errorf("Could not find wait msg cid %s", mcid)
+		}
+		return address.Undef, err
+	}
+
+	chanAccessor, err := pm.accessorByFromTo(ci.Control, ci.Target)
+	if err != nil {
+		return address.Undef, err
+	}
+
+	return chanAccessor.getPaychWaitReady(ctx, mcid)
+}
+
+func (pm *Manager) ListChannels() ([]address.Address, error) {
+	// Need to take an exclusive lock here so that channel operations can't run
+	// in parallel (see channelLock)
+	pm.lk.Lock()
+	defer pm.lk.Unlock()
+
+	return pm.store.ListChannels()
+}
+
+func (pm *Manager) GetChannelInfo(addr address.Address) (*ChannelInfo, error) {
+	ca, err := pm.accessorByAddress(addr)
+	if err != nil {
+		return nil, err
+	}
+	return ca.getChannelInfo(addr)
+}
+
+func (pm *Manager) CreateVoucher(ctx context.Context, ch address.Address, voucher paych0.SignedVoucher) (*api.VoucherCreateResult, error) {
+	ca, err := pm.accessorByAddress(ch)
+	if err != nil {
+		return nil, err
+	}
+
+	return ca.createVoucher(ctx, ch, voucher)
+}
+
+// CheckVoucherValid checks if the given voucher is valid (is or could become spendable at some point).
+// If the channel is not in the store, fetches the channel from state (and checks that
+// the channel To address is owned by the wallet).
+func (pm *Manager) CheckVoucherValid(ctx context.Context, ch address.Address, sv *paych0.SignedVoucher) error {
+	// Get an accessor for the channel, creating it from state if necessary
+	ca, err := pm.inboundChannelAccessor(ctx, ch)
+	if err != nil {
+		return err
+	}
+
+	_, err = ca.checkVoucherValid(ctx, ch, sv)
+	return err
+}
+
+// CheckVoucherSpendable checks if the given voucher is currently spendable
+func (pm *Manager) CheckVoucherSpendable(ctx context.Context, ch address.Address, sv *paych0.SignedVoucher, secret []byte, proof []byte) (bool, error) {
+	ca, err := pm.accessorByAddress(ch)
+	if err != nil {
+		return false, err
+	}
+
+	return ca.checkVoucherSpendable(ctx, ch, sv, secret, proof)
+}
+
+// AddVoucherOutbound adds a voucher for an outbound channel.
+// Returns an error if the channel is not already in the store.
+func (pm *Manager) AddVoucherOutbound(ctx context.Context, ch address.Address, sv *paych0.SignedVoucher, proof []byte, minDelta types.BigInt) (types.BigInt, error) {
+	ca, err := pm.accessorByAddress(ch)
+	if err != nil {
+		return types.NewInt(0), err
+	}
+	return ca.addVoucher(ctx, ch, sv, proof, minDelta)
+}
+
+// AddVoucherInbound adds a voucher for an inbound channel.
+// If the channel is not in the store, fetches the channel from state (and checks that
+// the channel To address is owned by the wallet).
+func (pm *Manager) AddVoucherInbound(ctx context.Context, ch address.Address, sv *paych0.SignedVoucher, proof []byte, minDelta types.BigInt) (types.BigInt, error) {
+	// Get an accessor for the channel, creating it from state if necessary
+	ca, err := pm.inboundChannelAccessor(ctx, ch)
+	if err != nil {
+		return types.BigInt{}, err
+	}
+	return ca.addVoucher(ctx, ch, sv, proof, minDelta)
+}
+
+// inboundChannelAccessor gets an accessor for the given channel. The channel
+// must either exist in the store, or be an inbound channel that can be created
+// from state.
+func (pm *Manager) inboundChannelAccessor(ctx context.Context, ch address.Address) (*channelAccessor, error) {
+	// Make sure channel is in store, or can be fetched from state, and that
+	// the channel To address is owned by the wallet
+	ci, err := pm.trackInboundChannel(ctx, ch)
+	if err != nil {
+		return nil, err
+	}
+
+	// This is an inbound channel, so To is the Control address (this node)
+	from := ci.Target
+	to := ci.Control
+	return pm.accessorByFromTo(from, to)
+}
+
+func (pm *Manager) trackInboundChannel(ctx context.Context, ch address.Address) (*ChannelInfo, error) {
+	// Need to take an exclusive lock here so that channel operations can't run
+	// in parallel (see channelLock)
+	pm.lk.Lock()
+	defer pm.lk.Unlock()
+
+	// Check if channel is in store
+	ci, err := pm.store.ByAddress(ch)
+	if err == nil {
+		// Channel is in store, so it's already being tracked
+		return ci, nil
+	}
+
+	// If there's an error (besides channel not in store) return err
+	if err != ErrChannelNotTracked {
+		return nil, err
+	}
+
+	// Channel is not in store, so get channel from state
+	stateCi, err := pm.sa.loadStateChannelInfo(ctx, ch, DirInbound)
+	if err != nil {
+		return nil, err
+	}
+
+	// Check that channel To address is in wallet
+	to := stateCi.Control // Inbound channel so To addr is Control (this node)
+	toKey, err := pm.pchapi.StateAccountKey(ctx, to, types.EmptyTSK)
+	if err != nil {
+		return nil, err
+	}
+	has, err := pm.pchapi.WalletHas(ctx, toKey)
+	if err != nil {
+		return nil, err
+	}
+	if !has {
+		msg := "cannot add voucher for channel %s: wallet does not have key for address %s"
+		return nil, xerrors.Errorf(msg, ch, to)
+	}
+
+	// Save channel to store
+	return pm.store.TrackChannel(stateCi)
+}
+
+func (pm *Manager) SubmitVoucher(ctx context.Context, ch address.Address, sv *paych0.SignedVoucher, secret []byte, proof []byte) (cid.Cid, error) {
+	ca, err := pm.accessorByAddress(ch)
+	if err != nil {
+		return cid.Undef, err
+	}
+	return ca.submitVoucher(ctx, ch, sv, secret, proof)
+}
+
+func (pm *Manager) AllocateLane(ch address.Address) (uint64, error) {
+	ca, err := pm.accessorByAddress(ch)
+	if err != nil {
+		return 0, err
+	}
+	return ca.allocateLane(ch)
+}
+
+func (pm *Manager) ListVouchers(ctx context.Context, ch address.Address) ([]*VoucherInfo, error) {
+	ca, err := pm.accessorByAddress(ch)
+	if err != nil {
+		return nil, err
+	}
+	return ca.listVouchers(ctx, ch)
+}
+
+func (pm *Manager) Settle(ctx context.Context, addr address.Address) (cid.Cid, error) {
+	ca, err := pm.accessorByAddress(addr)
+	if err != nil {
+		return cid.Undef, err
+	}
+	return ca.settle(ctx, addr)
+}
+
+func (pm *Manager) Collect(ctx context.Context, addr address.Address) (cid.Cid, error) {
+	ca, err := pm.accessorByAddress(addr)
+	if err != nil {
+		return cid.Undef, err
+	}
+	return ca.collect(ctx, addr)
+}
diff --git a/paychmgr/mock_test.go b/paychmgr/mock_test.go
new file mode 100644
index 000000000..c761221d2
--- /dev/null
+++ b/paychmgr/mock_test.go
@@ -0,0 +1,243 @@
+package paychmgr
+
+import (
+	"context"
+	"errors"
+	"sync"
+
+	"github.com/ipfs/go-cid"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/crypto"
+
+	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/paych"
+	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/lib/sigs"
+)
+
+type mockManagerAPI struct {
+	*mockStateManager
+	*mockPaychAPI
+}
+
+func newMockManagerAPI() *mockManagerAPI {
+	return &mockManagerAPI{
+		mockStateManager: newMockStateManager(),
+		mockPaychAPI:     newMockPaychAPI(),
+	}
+}
+
+type mockPchState struct {
+	actor *types.Actor
+	state paych.State
+}
+
+type mockStateManager struct {
+	lk           sync.Mutex
+	accountState map[address.Address]address.Address
+	paychState   map[address.Address]mockPchState
+	response     *api.InvocResult
+	lastCall     *types.Message
+}
+
+func newMockStateManager() *mockStateManager {
+	return &mockStateManager{
+		accountState: make(map[address.Address]address.Address),
+		paychState:   make(map[address.Address]mockPchState),
+	}
+}
+
+func (sm *mockStateManager) setAccountAddress(a address.Address, lookup address.Address) {
+	sm.lk.Lock()
+	defer sm.lk.Unlock()
+	sm.accountState[a] = lookup
+}
+
+func (sm *mockStateManager) setPaychState(a address.Address, actor *types.Actor, state paych.State) {
+	sm.lk.Lock()
+	defer sm.lk.Unlock()
+	sm.paychState[a] = mockPchState{actor, state}
+}
+
+func (sm *mockStateManager) ResolveToKeyAddress(ctx context.Context, addr address.Address, ts *types.TipSet) (address.Address, error) {
+	sm.lk.Lock()
+	defer sm.lk.Unlock()
+	keyAddr, ok := sm.accountState[addr]
+	if !ok {
+		return address.Undef, errors.New("not found")
+	}
+	return keyAddr, nil
+}
+
+func (sm *mockStateManager) GetPaychState(ctx context.Context, addr address.Address, ts *types.TipSet) (*types.Actor, paych.State, error) {
+	sm.lk.Lock()
+	defer sm.lk.Unlock()
+	info, ok := sm.paychState[addr]
+	if !ok {
+		return nil, nil, errors.New("not found")
+	}
+	return info.actor, info.state, nil
+}
+
+func (sm *mockStateManager) setCallResponse(response *api.InvocResult) {
+	sm.lk.Lock()
+	defer sm.lk.Unlock()
+
+	sm.response = response
+}
+
+func (sm *mockStateManager) getLastCall() *types.Message {
+	sm.lk.Lock()
+	defer sm.lk.Unlock()
+
+	return sm.lastCall
+}
+
+func (sm *mockStateManager) Call(ctx context.Context, msg *types.Message, ts *types.TipSet) (*api.InvocResult, error) {
+	sm.lk.Lock()
+	defer sm.lk.Unlock()
+
+	sm.lastCall = msg
+
+	return sm.response, nil
+}
+
+type waitingCall struct {
+	response chan types.MessageReceipt
+}
+
+type waitingResponse struct {
+	receipt types.MessageReceipt
+	done    chan struct{}
+}
+
+type mockPaychAPI struct {
+	lk               sync.Mutex
+	messages         map[cid.Cid]*types.SignedMessage
+	waitingCalls     map[cid.Cid]*waitingCall
+	waitingResponses map[cid.Cid]*waitingResponse
+	wallet           map[address.Address]struct{}
+	signingKey       []byte
+}
+
+func newMockPaychAPI() *mockPaychAPI {
+	return &mockPaychAPI{
+		messages:         make(map[cid.Cid]*types.SignedMessage),
+		waitingCalls:     make(map[cid.Cid]*waitingCall),
+		waitingResponses: make(map[cid.Cid]*waitingResponse),
+		wallet:           make(map[address.Address]struct{}),
+	}
+}
+
+func (pchapi *mockPaychAPI) StateWaitMsg(ctx context.Context, mcid cid.Cid, confidence uint64) (*api.MsgLookup, error) {
+	pchapi.lk.Lock()
+
+	response := make(chan types.MessageReceipt)
+
+	if response, ok := pchapi.waitingResponses[mcid]; ok {
+		defer pchapi.lk.Unlock()
+		defer func() {
+			go close(response.done)
+		}()
+
+		delete(pchapi.waitingResponses, mcid)
+		return &api.MsgLookup{Receipt: response.receipt}, nil
+	}
+
+	pchapi.waitingCalls[mcid] = &waitingCall{response: response}
+	pchapi.lk.Unlock()
+
+	receipt := <-response
+	return &api.MsgLookup{Receipt: receipt}, nil
+}
+
+func (pchapi *mockPaychAPI) receiveMsgResponse(mcid cid.Cid, receipt types.MessageReceipt) {
+	pchapi.lk.Lock()
+
+	if call, ok := pchapi.waitingCalls[mcid]; ok {
+		defer pchapi.lk.Unlock()
+
+		delete(pchapi.waitingCalls, mcid)
+		call.response <- receipt
+		return
+	}
+
+	done := make(chan struct{})
+	pchapi.waitingResponses[mcid] = &waitingResponse{receipt: receipt, done: done}
+
+	pchapi.lk.Unlock()
+
+	<-done
+}
+
+// Send success response for any waiting calls
+func (pchapi *mockPaychAPI) close() {
+	pchapi.lk.Lock()
+	defer pchapi.lk.Unlock()
+
+	success := types.MessageReceipt{
+		ExitCode: 0,
+		Return:   []byte{},
+	}
+	for mcid, call := range pchapi.waitingCalls {
+		delete(pchapi.waitingCalls, mcid)
+		call.response <- success
+	}
+}
+
+func (pchapi *mockPaychAPI) MpoolPushMessage(ctx context.Context, msg *types.Message, spec *api.MessageSendSpec) (*types.SignedMessage, error) {
+	pchapi.lk.Lock()
+	defer pchapi.lk.Unlock()
+
+	smsg := &types.SignedMessage{Message: *msg}
+	pchapi.messages[smsg.Cid()] = smsg
+	return smsg, nil
+}
+
+func (pchapi *mockPaychAPI) pushedMessages(c cid.Cid) *types.SignedMessage {
+	pchapi.lk.Lock()
+	defer pchapi.lk.Unlock()
+
+	return pchapi.messages[c]
+}
+
+func (pchapi *mockPaychAPI) pushedMessageCount() int {
+	pchapi.lk.Lock()
+	defer pchapi.lk.Unlock()
+
+	return len(pchapi.messages)
+}
+
+func (pchapi *mockPaychAPI) StateAccountKey(ctx context.Context, addr address.Address, tsk types.TipSetKey) (address.Address, error) {
+	return addr, nil
+}
+
+func (pchapi *mockPaychAPI) WalletHas(ctx context.Context, addr address.Address) (bool, error) {
+	pchapi.lk.Lock()
+	defer pchapi.lk.Unlock()
+
+	_, ok := pchapi.wallet[addr]
+	return ok, nil
+}
+
+func (pchapi *mockPaychAPI) addWalletAddress(addr address.Address) {
+	pchapi.lk.Lock()
+	defer pchapi.lk.Unlock()
+
+	pchapi.wallet[addr] = struct{}{}
+}
+
+func (pchapi *mockPaychAPI) WalletSign(ctx context.Context, k address.Address, msg []byte) (*crypto.Signature, error) {
+	pchapi.lk.Lock()
+	defer pchapi.lk.Unlock()
+
+	return sigs.Sign(crypto.SigTypeSecp256k1, pchapi.signingKey, msg)
+}
+
+func (pchapi *mockPaychAPI) addSigningKey(key []byte) {
+	pchapi.lk.Lock()
+	defer pchapi.lk.Unlock()
+
+	pchapi.signingKey = key
+}
diff --git a/paychmgr/msglistener.go b/paychmgr/msglistener.go
new file mode 100644
index 000000000..d1204e486
--- /dev/null
+++ b/paychmgr/msglistener.go
@@ -0,0 +1,56 @@
+package paychmgr
+
+import (
+	"golang.org/x/xerrors"
+
+	"github.com/hannahhoward/go-pubsub"
+
+	"github.com/ipfs/go-cid"
+)
+
+type msgListeners struct {
+	ps *pubsub.PubSub
+}
+
+type msgCompleteEvt struct {
+	mcid cid.Cid
+	err  error
+}
+
+type subscriberFn func(msgCompleteEvt)
+
+func newMsgListeners() msgListeners {
+	ps := pubsub.New(func(event pubsub.Event, subFn pubsub.SubscriberFn) error {
+		evt, ok := event.(msgCompleteEvt)
+		if !ok {
+			return xerrors.Errorf("wrong type of event")
+		}
+		sub, ok := subFn.(subscriberFn)
+		if !ok {
+			return xerrors.Errorf("wrong type of subscriber")
+		}
+		sub(evt)
+		return nil
+	})
+	return msgListeners{ps: ps}
+}
+
+// onMsgComplete registers a callback for when the message with the given cid
+// completes
+func (ml *msgListeners) onMsgComplete(mcid cid.Cid, cb func(error)) pubsub.Unsubscribe {
+	var fn subscriberFn = func(evt msgCompleteEvt) {
+		if mcid.Equals(evt.mcid) {
+			cb(evt.err)
+		}
+	}
+	return ml.ps.Subscribe(fn)
+}
+
+// fireMsgComplete is called when a message completes
+func (ml *msgListeners) fireMsgComplete(mcid cid.Cid, err error) {
+	e := ml.ps.Publish(msgCompleteEvt{mcid: mcid, err: err})
+	if e != nil {
+		// In theory we shouldn't ever get an error here
+		log.Errorf("unexpected error publishing message complete: %s", e)
+	}
+}
diff --git a/paychmgr/msglistener_test.go b/paychmgr/msglistener_test.go
new file mode 100644
index 000000000..4b8ae6f30
--- /dev/null
+++ b/paychmgr/msglistener_test.go
@@ -0,0 +1,94 @@
+package paychmgr
+
+import (
+	"testing"
+
+	"github.com/ipfs/go-cid"
+	"github.com/stretchr/testify/require"
+	"golang.org/x/xerrors"
+)
+
+func testCids() []cid.Cid {
+	c1, _ := cid.Decode("QmdmGQmRgRjazArukTbsXuuxmSHsMCcRYPAZoGhd6e3MuS")
+	c2, _ := cid.Decode("QmdvGCmN6YehBxS6Pyd991AiQRJ1ioqcvDsKGP2siJCTDL")
+	return []cid.Cid{c1, c2}
+}
+
+func TestMsgListener(t *testing.T) {
+	ml := newMsgListeners()
+
+	done := false
+	experr := xerrors.Errorf("some err")
+	cids := testCids()
+	ml.onMsgComplete(cids[0], func(err error) {
+		require.Equal(t, experr, err)
+		done = true
+	})
+
+	ml.fireMsgComplete(cids[0], experr)
+
+	if !done {
+		t.Fatal("failed to fire event")
+	}
+}
+
+func TestMsgListenerNilErr(t *testing.T) {
+	ml := newMsgListeners()
+
+	done := false
+	cids := testCids()
+	ml.onMsgComplete(cids[0], func(err error) {
+		require.Nil(t, err)
+		done = true
+	})
+
+	ml.fireMsgComplete(cids[0], nil)
+
+	if !done {
+		t.Fatal("failed to fire event")
+	}
+}
+
+func TestMsgListenerUnsub(t *testing.T) {
+	ml := newMsgListeners()
+
+	done := false
+	experr := xerrors.Errorf("some err")
+	cids := testCids()
+	unsub := ml.onMsgComplete(cids[0], func(err error) {
+		t.Fatal("should not call unsubscribed listener")
+	})
+	ml.onMsgComplete(cids[0], func(err error) {
+		require.Equal(t, experr, err)
+		done = true
+	})
+
+	unsub()
+	ml.fireMsgComplete(cids[0], experr)
+
+	if !done {
+		t.Fatal("failed to fire event")
+	}
+}
+
+func TestMsgListenerMulti(t *testing.T) {
+	ml := newMsgListeners()
+
+	count := 0
+	cids := testCids()
+	ml.onMsgComplete(cids[0], func(err error) {
+		count++
+	})
+	ml.onMsgComplete(cids[0], func(err error) {
+		count++
+	})
+	ml.onMsgComplete(cids[1], func(err error) {
+		count++
+	})
+
+	ml.fireMsgComplete(cids[0], nil)
+	require.Equal(t, 2, count)
+
+	ml.fireMsgComplete(cids[1], nil)
+	require.Equal(t, 3, count)
+}
diff --git a/paychmgr/paych.go b/paychmgr/paych.go
new file mode 100644
index 000000000..f856b9890
--- /dev/null
+++ b/paychmgr/paych.go
@@ -0,0 +1,670 @@
+package paychmgr
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+
+	"github.com/ipfs/go-cid"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-address"
+	cborutil "github.com/filecoin-project/go-cbor-util"
+	"github.com/filecoin-project/go-state-types/big"
+	"github.com/filecoin-project/specs-actors/actors/builtin"
+	paych0 "github.com/filecoin-project/specs-actors/actors/builtin/paych"
+
+	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/chain/actors"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/paych"
+	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/lib/sigs"
+)
+
+// insufficientFundsErr indicates that there are not enough funds in the
+// channel to create a voucher
+type insufficientFundsErr interface {
+	Shortfall() types.BigInt
+}
+
+type ErrInsufficientFunds struct {
+	shortfall types.BigInt
+}
+
+func newErrInsufficientFunds(shortfall types.BigInt) *ErrInsufficientFunds {
+	return &ErrInsufficientFunds{shortfall: shortfall}
+}
+
+func (e *ErrInsufficientFunds) Error() string {
+	return fmt.Sprintf("not enough funds in channel to cover voucher - shortfall: %d", e.shortfall)
+}
+
+func (e *ErrInsufficientFunds) Shortfall() types.BigInt {
+	return e.shortfall
+}
+
+type laneState struct {
+	redeemed big.Int
+	nonce    uint64
+}
+
+func (ls laneState) Redeemed() (big.Int, error) {
+	return ls.redeemed, nil
+}
+
+func (ls laneState) Nonce() (uint64, error) {
+	return ls.nonce, nil
+}
+
+// channelAccessor is used to simplify locking when accessing a channel
+type channelAccessor struct {
+	from address.Address
+	to   address.Address
+
+	// chctx is used by background processes (eg when waiting for things to be
+	// confirmed on chain)
+	chctx         context.Context
+	sa            *stateAccessor
+	api           managerAPI
+	store         *Store
+	lk            *channelLock
+	fundsReqQueue []*fundsReq
+	msgListeners  msgListeners
+}
+
+func newChannelAccessor(pm *Manager, from address.Address, to address.Address) *channelAccessor {
+	return &channelAccessor{
+		from:         from,
+		to:           to,
+		chctx:        pm.ctx,
+		sa:           pm.sa,
+		api:          pm.pchapi,
+		store:        pm.store,
+		lk:           &channelLock{globalLock: &pm.lk},
+		msgListeners: newMsgListeners(),
+	}
+}
+
+func (ca *channelAccessor) getChannelInfo(addr address.Address) (*ChannelInfo, error) {
+	ca.lk.Lock()
+	defer ca.lk.Unlock()
+
+	return ca.store.ByAddress(addr)
+}
+
+func (ca *channelAccessor) outboundActiveByFromTo(from, to address.Address) (*ChannelInfo, error) {
+	ca.lk.Lock()
+	defer ca.lk.Unlock()
+
+	return ca.store.OutboundActiveByFromTo(from, to)
+}
+
+// createVoucher creates a voucher with the given specification, setting its
+// nonce, signing the voucher and storing it in the local datastore.
+// If there are not enough funds in the channel to create the voucher, returns
+// the shortfall in funds.
+func (ca *channelAccessor) createVoucher(ctx context.Context, ch address.Address, voucher paych0.SignedVoucher) (*api.VoucherCreateResult, error) {
+	ca.lk.Lock()
+	defer ca.lk.Unlock()
+
+	// Find the channel for the voucher
+	ci, err := ca.store.ByAddress(ch)
+	if err != nil {
+		return nil, xerrors.Errorf("failed to get channel info by address: %w", err)
+	}
+
+	// Set the voucher channel
+	sv := &voucher
+	sv.ChannelAddr = ch
+
+	// Get the next nonce on the given lane
+	sv.Nonce = ca.nextNonceForLane(ci, voucher.Lane)
+
+	// Sign the voucher
+	vb, err := sv.SigningBytes()
+	if err != nil {
+		return nil, xerrors.Errorf("failed to get voucher signing bytes: %w", err)
+	}
+
+	sig, err := ca.api.WalletSign(ctx, ci.Control, vb)
+	if err != nil {
+		return nil, xerrors.Errorf("failed to sign voucher: %w", err)
+	}
+	sv.Signature = sig
+
+	// Store the voucher
+	if _, err := ca.addVoucherUnlocked(ctx, ch, sv, nil, types.NewInt(0)); err != nil {
+		// If there are not enough funds in the channel to cover the voucher,
+		// return a voucher create result with the shortfall
+		var ife insufficientFundsErr
+		if xerrors.As(err, &ife) {
+			return &api.VoucherCreateResult{
+				Shortfall: ife.Shortfall(),
+			}, nil
+		}
+
+		return nil, xerrors.Errorf("failed to persist voucher: %w", err)
+	}
+
+	return &api.VoucherCreateResult{Voucher: sv, Shortfall: types.NewInt(0)}, nil
+}
+
+func (ca *channelAccessor) nextNonceForLane(ci *ChannelInfo, lane uint64) uint64 {
+	var maxnonce uint64
+	for _, v := range ci.Vouchers {
+		if v.Voucher.Lane == lane {
+			if v.Voucher.Nonce > maxnonce {
+				maxnonce = v.Voucher.Nonce
+			}
+		}
+	}
+
+	return maxnonce + 1
+}
+
+func (ca *channelAccessor) checkVoucherValid(ctx context.Context, ch address.Address, sv *paych0.SignedVoucher) (map[uint64]paych.LaneState, error) {
+	ca.lk.Lock()
+	defer ca.lk.Unlock()
+
+	return ca.checkVoucherValidUnlocked(ctx, ch, sv)
+}
+
+func (ca *channelAccessor) checkVoucherValidUnlocked(ctx context.Context, ch address.Address, sv *paych0.SignedVoucher) (map[uint64]paych.LaneState, error) {
+	if sv.ChannelAddr != ch {
+		return nil, xerrors.Errorf("voucher ChannelAddr doesn't match channel address, got %s, expected %s", sv.ChannelAddr, ch)
+	}
+
+	// Load payment channel actor state
+	act, pchState, err := ca.sa.loadPaychActorState(ctx, ch)
+	if err != nil {
+		return nil, err
+	}
+
+	// Load channel "From" account actor state
+	f, err := pchState.From()
+	if err != nil {
+		return nil, err
+	}
+
+	from, err := ca.api.ResolveToKeyAddress(ctx, f, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	// verify voucher signature
+	vb, err := sv.SigningBytes()
+	if err != nil {
+		return nil, err
+	}
+
+	// TODO: technically, either party may create and sign a voucher.
+	// However, for now, we only accept them from the channel creator.
+	// More complex handling logic can be added later
+	if err := sigs.Verify(sv.Signature, from, vb); err != nil {
+		return nil, err
+	}
+
+	// Check the voucher against the highest known voucher nonce / value
+	laneStates, err := ca.laneState(ctx, pchState, ch)
+	if err != nil {
+		return nil, err
+	}
+
+	// If the new voucher nonce value is less than the highest known
+	// nonce for the lane
+	ls, lsExists := laneStates[sv.Lane]
+	if lsExists {
+		n, err := ls.Nonce()
+		if err != nil {
+			return nil, err
+		}
+
+		if sv.Nonce <= n {
+			return nil, fmt.Errorf("nonce too low")
+		}
+
+		// If the voucher amount is less than the highest known voucher amount
+		r, err := ls.Redeemed()
+		if err != nil {
+			return nil, err
+		}
+		if sv.Amount.LessThanEqual(r) {
+			return nil, fmt.Errorf("voucher amount is lower than amount for voucher with lower nonce")
+		}
+	}
+
+	// Total redeemed is the total redeemed amount for all lanes, including
+	// the new voucher
+	// eg
+	//
+	// lane 1 redeemed:            3
+	// lane 2 redeemed:            2
+	// voucher for lane 1:         5
+	//
+	// Voucher supersedes lane 1 redeemed, therefore
+	// effective lane 1 redeemed:  5
+	//
+	// lane 1:  5
+	// lane 2:  2
+	//          -
+	// total:   7
+	totalRedeemed, err := ca.totalRedeemedWithVoucher(laneStates, sv)
+	if err != nil {
+		return nil, err
+	}
+
+	// Total required balance = total redeemed + toSend
+	// Must not exceed actor balance
+	ts, err := pchState.ToSend()
+	if err != nil {
+		return nil, err
+	}
+
+	newTotal := types.BigAdd(totalRedeemed, ts)
+	if act.Balance.LessThan(newTotal) {
+		return nil, newErrInsufficientFunds(types.BigSub(newTotal, act.Balance))
+	}
+
+	if len(sv.Merges) != 0 {
+		return nil, fmt.Errorf("dont currently support paych lane merges")
+	}
+
+	return laneStates, nil
+}
+
+func (ca *channelAccessor) checkVoucherSpendable(ctx context.Context, ch address.Address, sv *paych0.SignedVoucher, secret []byte, proof []byte) (bool, error) {
+	ca.lk.Lock()
+	defer ca.lk.Unlock()
+
+	recipient, err := ca.getPaychRecipient(ctx, ch)
+	if err != nil {
+		return false, err
+	}
+
+	ci, err := ca.store.ByAddress(ch)
+	if err != nil {
+		return false, err
+	}
+
+	// Check if voucher has already been submitted
+	submitted, err := ci.wasVoucherSubmitted(sv)
+	if err != nil {
+		return false, err
+	}
+	if submitted {
+		return false, nil
+	}
+
+	// If proof is needed and wasn't supplied as a parameter, get it from the
+	// datastore
+	if sv.Extra != nil && proof == nil {
+		vi, err := ci.infoForVoucher(sv)
+		if err != nil {
+			return false, err
+		}
+
+		if vi.Proof != nil {
+			log.Info("CheckVoucherSpendable: using stored proof")
+			proof = vi.Proof
+		} else {
+			log.Warn("CheckVoucherSpendable: nil proof for voucher with validation")
+		}
+	}
+
+	enc, err := actors.SerializeParams(&paych0.UpdateChannelStateParams{
+		Sv:     *sv,
+		Secret: secret,
+		Proof:  proof,
+	})
+	if err != nil {
+		return false, err
+	}
+
+	ret, err := ca.api.Call(ctx, &types.Message{
+		From:   recipient,
+		To:     ch,
+		Method: builtin.MethodsPaych.UpdateChannelState,
+		Params: enc,
+	}, nil)
+	if err != nil {
+		return false, err
+	}
+
+	if ret.MsgRct.ExitCode != 0 {
+		return false, nil
+	}
+
+	return true, nil
+}
+
+func (ca *channelAccessor) getPaychRecipient(ctx context.Context, ch address.Address) (address.Address, error) {
+	_, state, err := ca.api.GetPaychState(ctx, ch, nil)
+	if err != nil {
+		return address.Address{}, err
+	}
+
+	return state.To()
+}
+
+func (ca *channelAccessor) addVoucher(ctx context.Context, ch address.Address, sv *paych0.SignedVoucher, proof []byte, minDelta types.BigInt) (types.BigInt, error) {
+	ca.lk.Lock()
+	defer ca.lk.Unlock()
+
+	return ca.addVoucherUnlocked(ctx, ch, sv, proof, minDelta)
+}
+
+func (ca *channelAccessor) addVoucherUnlocked(ctx context.Context, ch address.Address, sv *paych0.SignedVoucher, proof []byte, minDelta types.BigInt) (types.BigInt, error) {
+	ci, err := ca.store.ByAddress(ch)
+	if err != nil {
+		return types.BigInt{}, err
+	}
+
+	// Check if the voucher has already been added
+	for i, v := range ci.Vouchers {
+		eq, err := cborutil.Equals(sv, v.Voucher)
+		if err != nil {
+			return types.BigInt{}, err
+		}
+		if !eq {
+			continue
+		}
+
+		// This is a duplicate voucher.
+		// Update the proof on the existing voucher
+		if len(proof) > 0 && !bytes.Equal(v.Proof, proof) {
+			log.Warnf("AddVoucher: adding proof to stored voucher")
+			ci.Vouchers[i] = &VoucherInfo{
+				Voucher: v.Voucher,
+				Proof:   proof,
+			}
+
+			return types.NewInt(0), ca.store.putChannelInfo(ci)
+		}
+
+		// Otherwise just ignore the duplicate voucher
+		log.Warnf("AddVoucher: voucher re-added with matching proof")
+		return types.NewInt(0), nil
+	}
+
+	// Check voucher validity
+	laneStates, err := ca.checkVoucherValidUnlocked(ctx, ch, sv)
+	if err != nil {
+		return types.NewInt(0), err
+	}
+
+	// The change in value is the delta between the voucher amount and
+	// the highest previous voucher amount for the lane
+	laneState, exists := laneStates[sv.Lane]
+	redeemed := big.NewInt(0)
+	if exists {
+		redeemed, err = laneState.Redeemed()
+		if err != nil {
+			return types.NewInt(0), err
+		}
+	}
+
+	delta := types.BigSub(sv.Amount, redeemed)
+	if minDelta.GreaterThan(delta) {
+		return delta, xerrors.Errorf("addVoucher: supplied token amount too low; minD=%s, D=%s; laneAmt=%s; v.Amt=%s", minDelta, delta, redeemed, sv.Amount)
+	}
+
+	ci.Vouchers = append(ci.Vouchers, &VoucherInfo{
+		Voucher: sv,
+		Proof:   proof,
+	})
+
+	if ci.NextLane <= sv.Lane {
+		ci.NextLane = sv.Lane + 1
+	}
+
+	return delta, ca.store.putChannelInfo(ci)
+}
+
+func (ca *channelAccessor) submitVoucher(ctx context.Context, ch address.Address, sv *paych0.SignedVoucher, secret []byte, proof []byte) (cid.Cid, error) {
+	ca.lk.Lock()
+	defer ca.lk.Unlock()
+
+	ci, err := ca.store.ByAddress(ch)
+	if err != nil {
+		return cid.Undef, err
+	}
+
+	// If voucher needs proof, and none was supplied, check datastore for proof
+	if sv.Extra != nil && proof == nil {
+		vi, err := ci.infoForVoucher(sv)
+		if err != nil {
+			return cid.Undef, err
+		}
+
+		if vi.Proof != nil {
+			log.Info("SubmitVoucher: using stored proof")
+			proof = vi.Proof
+		} else {
+			log.Warn("SubmitVoucher: nil proof for voucher with validation")
+		}
+	}
+
+	has, err := ci.hasVoucher(sv)
+	if err != nil {
+		return cid.Undef, err
+	}
+
+	// If the channel has the voucher
+	if has {
+		// Check that the voucher hasn't already been submitted
+		submitted, err := ci.wasVoucherSubmitted(sv)
+		if err != nil {
+			return cid.Undef, err
+		}
+		if submitted {
+			return cid.Undef, xerrors.Errorf("cannot submit voucher that has already been submitted")
+		}
+	}
+
+	enc, err := actors.SerializeParams(&paych0.UpdateChannelStateParams{
+		Sv:     *sv,
+		Secret: secret,
+		Proof:  proof,
+	})
+	if err != nil {
+		return cid.Undef, err
+	}
+
+	msg := &types.Message{
+		From:   ci.Control,
+		To:     ch,
+		Value:  types.NewInt(0),
+		Method: builtin.MethodsPaych.UpdateChannelState,
+		Params: enc,
+	}
+
+	smsg, err := ca.api.MpoolPushMessage(ctx, msg, nil)
+	if err != nil {
+		return cid.Undef, err
+	}
+
+	// If the channel didn't already have the voucher
+	if !has {
+		// Add the voucher to the channel
+		ci.Vouchers = append(ci.Vouchers, &VoucherInfo{
+			Voucher: sv,
+			Proof:   proof,
+		})
+	}
+
+	// Mark the voucher and any lower-nonce vouchers as having been submitted
+	err = ca.store.MarkVoucherSubmitted(ci, sv)
+	if err != nil {
+		return cid.Undef, err
+	}
+
+	return smsg.Cid(), nil
+}
+
+func (ca *channelAccessor) allocateLane(ch address.Address) (uint64, error) {
+	ca.lk.Lock()
+	defer ca.lk.Unlock()
+
+	// TODO: should this take into account lane state?
+	return ca.store.AllocateLane(ch)
+}
+
+func (ca *channelAccessor) listVouchers(ctx context.Context, ch address.Address) ([]*VoucherInfo, error) {
+	ca.lk.Lock()
+	defer ca.lk.Unlock()
+
+	// TODO: just having a passthrough method like this feels odd. Seems like
+	// there should be some filtering we're doing here
+	return ca.store.VouchersForPaych(ch)
+}
+
+// laneState gets the LaneStates from chain, then applies all vouchers in
+// the data store over the chain state
+func (ca *channelAccessor) laneState(ctx context.Context, state paych.State, ch address.Address) (map[uint64]paych.LaneState, error) {
+	// TODO: we probably want to call UpdateChannelState with all vouchers to be fully correct
+	//  (but technically dont't need to)
+
+	laneCount, err := state.LaneCount()
+	if err != nil {
+		return nil, 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.
+	laneStates := make(map[uint64]paych.LaneState, laneCount)
+	err = state.ForEachLaneState(func(idx uint64, ls paych.LaneState) error {
+		laneStates[idx] = ls
+		return nil
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	// Apply locally stored vouchers
+	vouchers, err := ca.store.VouchersForPaych(ch)
+	if err != nil && err != ErrChannelNotTracked {
+		return nil, err
+	}
+
+	for _, v := range vouchers {
+		for range v.Voucher.Merges {
+			return nil, xerrors.Errorf("paych merges not handled yet")
+		}
+
+		// If there's a voucher for a lane that isn't in chain state just
+		// create it
+		ls, ok := laneStates[v.Voucher.Lane]
+		if ok {
+			n, err := ls.Nonce()
+			if err != nil {
+				return nil, err
+			}
+			if v.Voucher.Nonce < n {
+				continue
+			}
+		}
+
+		laneStates[v.Voucher.Lane] = laneState{v.Voucher.Amount, v.Voucher.Nonce}
+	}
+
+	return laneStates, nil
+}
+
+// Get the total redeemed amount across all lanes, after applying the voucher
+func (ca *channelAccessor) totalRedeemedWithVoucher(laneStates map[uint64]paych.LaneState, sv *paych0.SignedVoucher) (big.Int, error) {
+	// TODO: merges
+	if len(sv.Merges) != 0 {
+		return big.Int{}, xerrors.Errorf("dont currently support paych lane merges")
+	}
+
+	total := big.NewInt(0)
+	for _, ls := range laneStates {
+		r, err := ls.Redeemed()
+		if err != nil {
+			return big.Int{}, err
+		}
+		total = big.Add(total, r)
+	}
+
+	lane, ok := laneStates[sv.Lane]
+	if ok {
+		// If the voucher is for an existing lane, and the voucher nonce
+		// is higher than the lane nonce
+		n, err := lane.Nonce()
+		if err != nil {
+			return big.Int{}, err
+		}
+
+		if sv.Nonce > n {
+			// Add the delta between the redeemed amount and the voucher
+			// amount to the total
+			r, err := lane.Redeemed()
+			if err != nil {
+				return big.Int{}, err
+			}
+
+			delta := big.Sub(sv.Amount, r)
+			total = big.Add(total, delta)
+		}
+	} else {
+		// If the voucher is *not* for an existing lane, just add its
+		// value (implicitly a new lane will be created for the voucher)
+		total = big.Add(total, sv.Amount)
+	}
+
+	return total, nil
+}
+
+func (ca *channelAccessor) settle(ctx context.Context, ch address.Address) (cid.Cid, error) {
+	ca.lk.Lock()
+	defer ca.lk.Unlock()
+
+	ci, err := ca.store.ByAddress(ch)
+	if err != nil {
+		return cid.Undef, err
+	}
+
+	msg := &types.Message{
+		To:     ch,
+		From:   ci.Control,
+		Value:  types.NewInt(0),
+		Method: builtin.MethodsPaych.Settle,
+	}
+	smgs, err := ca.api.MpoolPushMessage(ctx, msg, nil)
+	if err != nil {
+		return cid.Undef, err
+	}
+
+	ci.Settling = true
+	err = ca.store.putChannelInfo(ci)
+	if err != nil {
+		log.Errorf("Error marking channel as settled: %s", err)
+	}
+
+	return smgs.Cid(), err
+}
+
+func (ca *channelAccessor) collect(ctx context.Context, ch address.Address) (cid.Cid, error) {
+	ca.lk.Lock()
+	defer ca.lk.Unlock()
+
+	ci, err := ca.store.ByAddress(ch)
+	if err != nil {
+		return cid.Undef, err
+	}
+
+	msg := &types.Message{
+		To:     ch,
+		From:   ci.Control,
+		Value:  types.NewInt(0),
+		Method: builtin.MethodsPaych.Collect,
+	}
+
+	smsg, err := ca.api.MpoolPushMessage(ctx, msg, nil)
+	if err != nil {
+		return cid.Undef, err
+	}
+
+	return smsg.Cid(), nil
+}
diff --git a/paychmgr/paych_test.go b/paychmgr/paych_test.go
new file mode 100644
index 000000000..b27b1e540
--- /dev/null
+++ b/paychmgr/paych_test.go
@@ -0,0 +1,1029 @@
+package paychmgr
+
+import (
+	"bytes"
+	"context"
+	"testing"
+
+	"github.com/ipfs/go-cid"
+	ds "github.com/ipfs/go-datastore"
+	ds_sync "github.com/ipfs/go-datastore/sync"
+	"github.com/stretchr/testify/require"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/big"
+	"github.com/filecoin-project/go-state-types/crypto"
+	"github.com/filecoin-project/specs-actors/actors/builtin"
+	paych0 "github.com/filecoin-project/specs-actors/actors/builtin/paych"
+	tutils "github.com/filecoin-project/specs-actors/support/testing"
+
+	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/paych"
+	paychmock "github.com/filecoin-project/lotus/chain/actors/builtin/paych/mock"
+	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/lib/sigs"
+)
+
+func TestCheckVoucherValid(t *testing.T) {
+	ctx := context.Background()
+
+	fromKeyPrivate, fromKeyPublic := testGenerateKeyPair(t)
+	toKeyPrivate, toKeyPublic := testGenerateKeyPair(t)
+	randKeyPrivate, _ := testGenerateKeyPair(t)
+
+	ch := tutils.NewIDAddr(t, 100)
+	from := tutils.NewSECP256K1Addr(t, string(fromKeyPublic))
+	to := tutils.NewSECP256K1Addr(t, string(toKeyPublic))
+	fromAcct := tutils.NewActorAddr(t, "fromAct")
+	toAcct := tutils.NewActorAddr(t, "toAct")
+
+	mock := newMockManagerAPI()
+	mock.setAccountAddress(fromAcct, from)
+	mock.setAccountAddress(toAcct, to)
+
+	tcases := []struct {
+		name          string
+		expectError   bool
+		key           []byte
+		actorBalance  big.Int
+		toSend        big.Int
+		voucherAmount big.Int
+		voucherLane   uint64
+		voucherNonce  uint64
+		laneStates    map[uint64]paych.LaneState
+	}{{
+		name:          "passes when voucher amount < balance",
+		key:           fromKeyPrivate,
+		actorBalance:  big.NewInt(10),
+		toSend:        big.NewInt(0),
+		voucherAmount: big.NewInt(5),
+	}, {
+		name:          "fails when funds too low",
+		expectError:   true,
+		key:           fromKeyPrivate,
+		actorBalance:  big.NewInt(5),
+		toSend:        big.NewInt(0),
+		voucherAmount: big.NewInt(10),
+	}, {
+		name:          "fails when invalid signature",
+		expectError:   true,
+		key:           randKeyPrivate,
+		actorBalance:  big.NewInt(10),
+		toSend:        big.NewInt(0),
+		voucherAmount: big.NewInt(5),
+	}, {
+		name:          "fails when signed by channel To account (instead of From account)",
+		expectError:   true,
+		key:           toKeyPrivate,
+		actorBalance:  big.NewInt(10),
+		toSend:        big.NewInt(0),
+		voucherAmount: big.NewInt(5),
+	}, {
+		name:          "fails when nonce too low",
+		expectError:   true,
+		key:           fromKeyPrivate,
+		actorBalance:  big.NewInt(10),
+		toSend:        big.NewInt(0),
+		voucherAmount: big.NewInt(5),
+		voucherLane:   1,
+		voucherNonce:  2,
+		laneStates: map[uint64]paych.LaneState{
+			1: paychmock.NewMockLaneState(big.NewInt(2), 3),
+		},
+	}, {
+		name:          "passes when nonce higher",
+		key:           fromKeyPrivate,
+		actorBalance:  big.NewInt(10),
+		toSend:        big.NewInt(0),
+		voucherAmount: big.NewInt(5),
+		voucherLane:   1,
+		voucherNonce:  3,
+		laneStates: map[uint64]paych.LaneState{
+			1: paychmock.NewMockLaneState(big.NewInt(2), 2),
+		},
+	}, {
+		name:          "passes when nonce for different lane",
+		key:           fromKeyPrivate,
+		actorBalance:  big.NewInt(10),
+		toSend:        big.NewInt(0),
+		voucherAmount: big.NewInt(5),
+		voucherLane:   2,
+		voucherNonce:  2,
+		laneStates: map[uint64]paych.LaneState{
+			1: paychmock.NewMockLaneState(big.NewInt(2), 3),
+		},
+	}, {
+		name:          "fails when voucher has higher nonce but lower value than lane state",
+		expectError:   true,
+		key:           fromKeyPrivate,
+		actorBalance:  big.NewInt(10),
+		toSend:        big.NewInt(0),
+		voucherAmount: big.NewInt(5),
+		voucherLane:   1,
+		voucherNonce:  3,
+		laneStates: map[uint64]paych.LaneState{
+			1: paychmock.NewMockLaneState(big.NewInt(6), 2),
+		},
+	}, {
+		name:          "fails when voucher + ToSend > balance",
+		expectError:   true,
+		key:           fromKeyPrivate,
+		actorBalance:  big.NewInt(10),
+		toSend:        big.NewInt(9),
+		voucherAmount: big.NewInt(2),
+	}, {
+		// voucher supersedes lane 1 redeemed so
+		// lane 1 effective redeemed = voucher amount
+		//
+		// required balance = toSend + total redeemed
+		//                  = 1 + 6 (lane1)
+		//                  = 7
+		// So required balance: 7 < actor balance: 10
+		name:          "passes when voucher + total redeemed <= balance",
+		key:           fromKeyPrivate,
+		actorBalance:  big.NewInt(10),
+		toSend:        big.NewInt(1),
+		voucherAmount: big.NewInt(6),
+		voucherLane:   1,
+		voucherNonce:  2,
+		laneStates: map[uint64]paych.LaneState{
+			// Lane 1 (same as voucher lane 1)
+			1: paychmock.NewMockLaneState(big.NewInt(4), 1),
+		},
+	}, {
+		// required balance = toSend + total redeemed
+		//                  = 1 + 4 (lane 2) + 6 (voucher lane 1)
+		//                  = 11
+		// So required balance: 11 > actor balance: 10
+		name:          "fails when voucher + total redeemed > balance",
+		expectError:   true,
+		key:           fromKeyPrivate,
+		actorBalance:  big.NewInt(10),
+		toSend:        big.NewInt(1),
+		voucherAmount: big.NewInt(6),
+		voucherLane:   1,
+		voucherNonce:  1,
+		laneStates: map[uint64]paych.LaneState{
+			// Lane 2 (different from voucher lane 1)
+			2: paychmock.NewMockLaneState(big.NewInt(4), 1),
+		},
+	}}
+
+	for _, tcase := range tcases {
+		tcase := tcase
+		t.Run(tcase.name, func(t *testing.T) {
+			store := NewStore(ds_sync.MutexWrap(ds.NewMapDatastore()))
+
+			// Create an actor for the channel with the test case balance
+			act := &types.Actor{
+				Code:    builtin.AccountActorCodeID,
+				Head:    cid.Cid{},
+				Nonce:   0,
+				Balance: tcase.actorBalance,
+			}
+
+			mock.setPaychState(ch, act, paychmock.NewMockPayChState(
+				fromAcct, toAcct, abi.ChainEpoch(0), tcase.toSend, tcase.laneStates))
+
+			// Create a manager
+			mgr, err := newManager(store, mock)
+			require.NoError(t, err)
+
+			// Add channel To address to wallet
+			mock.addWalletAddress(to)
+
+			// Create a signed voucher
+			sv := createTestVoucher(t, ch, tcase.voucherLane, tcase.voucherNonce, tcase.voucherAmount, tcase.key)
+
+			// Check the voucher's validity
+			err = mgr.CheckVoucherValid(ctx, ch, sv)
+			if tcase.expectError {
+				require.Error(t, err)
+			} else {
+				require.NoError(t, err)
+			}
+		})
+	}
+}
+
+func TestCheckVoucherValidCountingAllLanes(t *testing.T) {
+	ctx := context.Background()
+
+	fromKeyPrivate, fromKeyPublic := testGenerateKeyPair(t)
+
+	ch := tutils.NewIDAddr(t, 100)
+	from := tutils.NewSECP256K1Addr(t, string(fromKeyPublic))
+	to := tutils.NewSECP256K1Addr(t, "secpTo")
+	fromAcct := tutils.NewActorAddr(t, "fromAct")
+	toAcct := tutils.NewActorAddr(t, "toAct")
+	minDelta := big.NewInt(0)
+
+	mock := newMockManagerAPI()
+	mock.setAccountAddress(fromAcct, from)
+	mock.setAccountAddress(toAcct, to)
+
+	store := NewStore(ds_sync.MutexWrap(ds.NewMapDatastore()))
+
+	actorBalance := big.NewInt(10)
+	toSend := big.NewInt(1)
+	laneStates := map[uint64]paych.LaneState{
+		1: paychmock.NewMockLaneState(big.NewInt(3), 1),
+		2: paychmock.NewMockLaneState(big.NewInt(4), 1),
+	}
+
+	act := &types.Actor{
+		Code:    builtin.AccountActorCodeID,
+		Head:    cid.Cid{},
+		Nonce:   0,
+		Balance: actorBalance,
+	}
+
+	mock.setPaychState(ch, act, paychmock.NewMockPayChState(fromAcct, toAcct, abi.ChainEpoch(0), toSend, laneStates))
+
+	mgr, err := newManager(store, mock)
+	require.NoError(t, err)
+
+	// Add channel To address to wallet
+	mock.addWalletAddress(to)
+
+	//
+	// Should not be possible to add a voucher with a value such that
+	// <total lane Redeemed> + toSend > <actor balance>
+	//
+	// lane 1 redeemed:                   3
+	// voucher amount (lane 1):           6
+	// lane 1 redeemed (with voucher):    6
+	//
+	// Lane 1:             6
+	// Lane 2:             4
+	// toSend:             1
+	//                     --
+	// total:              11
+	//
+	// actor balance is 10 so total is too high.
+	//
+	voucherLane := uint64(1)
+	voucherNonce := uint64(2)
+	voucherAmount := big.NewInt(6)
+	sv := createTestVoucher(t, ch, voucherLane, voucherNonce, voucherAmount, fromKeyPrivate)
+	err = mgr.CheckVoucherValid(ctx, ch, sv)
+	require.Error(t, err)
+
+	//
+	// lane 1 redeemed:                   3
+	// voucher amount (lane 1):           4
+	// lane 1 redeemed (with voucher):    4
+	//
+	// Lane 1:             4
+	// Lane 2:             4
+	// toSend:             1
+	//                     --
+	// total:              9
+	//
+	// actor balance is 10 so total is ok.
+	//
+	voucherAmount = big.NewInt(4)
+	sv = createTestVoucher(t, ch, voucherLane, voucherNonce, voucherAmount, fromKeyPrivate)
+	err = mgr.CheckVoucherValid(ctx, ch, sv)
+	require.NoError(t, err)
+
+	// Add voucher to lane 1, so Lane 1 effective redeemed
+	// (with first voucher) is now 4
+	_, err = mgr.AddVoucherOutbound(ctx, ch, sv, nil, minDelta)
+	require.NoError(t, err)
+
+	//
+	// lane 1 redeemed:                   4
+	// voucher amount (lane 1):           6
+	// lane 1 redeemed (with voucher):    6
+	//
+	// Lane 1:             6
+	// Lane 2:             4
+	// toSend:             1
+	//                     --
+	// total:              11
+	//
+	// actor balance is 10 so total is too high.
+	//
+	voucherNonce++
+	voucherAmount = big.NewInt(6)
+	sv = createTestVoucher(t, ch, voucherLane, voucherNonce, voucherAmount, fromKeyPrivate)
+	err = mgr.CheckVoucherValid(ctx, ch, sv)
+	require.Error(t, err)
+
+	//
+	// lane 1 redeemed:                   4
+	// voucher amount (lane 1):           5
+	// lane 1 redeemed (with voucher):    5
+	//
+	// Lane 1:             5
+	// Lane 2:             4
+	// toSend:             1
+	//                     --
+	// total:              10
+	//
+	// actor balance is 10 so total is ok.
+	//
+	voucherAmount = big.NewInt(5)
+	sv = createTestVoucher(t, ch, voucherLane, voucherNonce, voucherAmount, fromKeyPrivate)
+	err = mgr.CheckVoucherValid(ctx, ch, sv)
+	require.NoError(t, err)
+}
+
+func TestCreateVoucher(t *testing.T) {
+	ctx := context.Background()
+
+	// Set up a manager with a single payment channel
+	s := testSetupMgrWithChannel(ctx, t)
+
+	// Create a voucher in lane 1
+	voucherLane1Amt := big.NewInt(5)
+	voucher := paych0.SignedVoucher{
+		Lane:   1,
+		Amount: voucherLane1Amt,
+	}
+	res, err := s.mgr.CreateVoucher(ctx, s.ch, voucher)
+	require.NoError(t, err)
+	require.NotNil(t, res.Voucher)
+	require.Equal(t, s.ch, res.Voucher.ChannelAddr)
+	require.Equal(t, voucherLane1Amt, res.Voucher.Amount)
+	require.EqualValues(t, 0, res.Shortfall.Int64())
+
+	nonce := res.Voucher.Nonce
+
+	// Create a voucher in lane 1 again, with a higher amount
+	voucherLane1Amt = big.NewInt(8)
+	voucher = paych0.SignedVoucher{
+		Lane:   1,
+		Amount: voucherLane1Amt,
+	}
+	res, err = s.mgr.CreateVoucher(ctx, s.ch, voucher)
+	require.NoError(t, err)
+	require.NotNil(t, res.Voucher)
+	require.Equal(t, s.ch, res.Voucher.ChannelAddr)
+	require.Equal(t, voucherLane1Amt, res.Voucher.Amount)
+	require.EqualValues(t, 0, res.Shortfall.Int64())
+	require.Equal(t, nonce+1, res.Voucher.Nonce)
+
+	// Create a voucher in lane 2 that covers all the remaining funds
+	// in the channel
+	voucherLane2Amt := big.Sub(s.amt, voucherLane1Amt)
+	voucher = paych0.SignedVoucher{
+		Lane:   2,
+		Amount: voucherLane2Amt,
+	}
+	res, err = s.mgr.CreateVoucher(ctx, s.ch, voucher)
+	require.NoError(t, err)
+	require.NotNil(t, res.Voucher)
+	require.Equal(t, s.ch, res.Voucher.ChannelAddr)
+	require.Equal(t, voucherLane2Amt, res.Voucher.Amount)
+	require.EqualValues(t, 0, res.Shortfall.Int64())
+
+	// Create a voucher in lane 2 that exceeds the remaining funds in the
+	// channel
+	voucherLane2Amt = big.Add(voucherLane2Amt, big.NewInt(1))
+	voucher = paych0.SignedVoucher{
+		Lane:   2,
+		Amount: voucherLane2Amt,
+	}
+	res, err = s.mgr.CreateVoucher(ctx, s.ch, voucher)
+	require.NoError(t, err)
+
+	// Expect a shortfall value equal to the amount required to add the voucher
+	// to the channel
+	require.Nil(t, res.Voucher)
+	require.EqualValues(t, 1, res.Shortfall.Int64())
+}
+
+func TestAddVoucherDelta(t *testing.T) {
+	ctx := context.Background()
+
+	// Set up a manager with a single payment channel
+	s := testSetupMgrWithChannel(ctx, t)
+
+	voucherLane := uint64(1)
+
+	// Expect error when adding a voucher whose amount is less than minDelta
+	minDelta := big.NewInt(2)
+	nonce := uint64(1)
+	voucherAmount := big.NewInt(1)
+	sv := createTestVoucher(t, s.ch, voucherLane, nonce, voucherAmount, s.fromKeyPrivate)
+	_, err := s.mgr.AddVoucherOutbound(ctx, s.ch, sv, nil, minDelta)
+	require.Error(t, err)
+
+	// Expect success when adding a voucher whose amount is equal to minDelta
+	nonce++
+	voucherAmount = big.NewInt(2)
+	sv = createTestVoucher(t, s.ch, voucherLane, nonce, voucherAmount, s.fromKeyPrivate)
+	delta, err := s.mgr.AddVoucherOutbound(ctx, s.ch, sv, nil, minDelta)
+	require.NoError(t, err)
+	require.EqualValues(t, delta.Int64(), 2)
+
+	// Check that delta is correct when there's an existing voucher
+	nonce++
+	voucherAmount = big.NewInt(5)
+	sv = createTestVoucher(t, s.ch, voucherLane, nonce, voucherAmount, s.fromKeyPrivate)
+	delta, err = s.mgr.AddVoucherOutbound(ctx, s.ch, sv, nil, minDelta)
+	require.NoError(t, err)
+	require.EqualValues(t, delta.Int64(), 3)
+
+	// Check that delta is correct when voucher added to a different lane
+	nonce = uint64(1)
+	voucherAmount = big.NewInt(6)
+	voucherLane = uint64(2)
+	sv = createTestVoucher(t, s.ch, voucherLane, nonce, voucherAmount, s.fromKeyPrivate)
+	delta, err = s.mgr.AddVoucherOutbound(ctx, s.ch, sv, nil, minDelta)
+	require.NoError(t, err)
+	require.EqualValues(t, delta.Int64(), 6)
+}
+
+func TestAddVoucherNextLane(t *testing.T) {
+	ctx := context.Background()
+
+	// Set up a manager with a single payment channel
+	s := testSetupMgrWithChannel(ctx, t)
+
+	minDelta := big.NewInt(0)
+	voucherAmount := big.NewInt(2)
+
+	// Add a voucher in lane 2
+	nonce := uint64(1)
+	voucherLane := uint64(2)
+	sv := createTestVoucher(t, s.ch, voucherLane, nonce, voucherAmount, s.fromKeyPrivate)
+	_, err := s.mgr.AddVoucherOutbound(ctx, s.ch, sv, nil, minDelta)
+	require.NoError(t, err)
+
+	ci, err := s.mgr.GetChannelInfo(s.ch)
+	require.NoError(t, err)
+	require.EqualValues(t, ci.NextLane, 3)
+
+	// Allocate a lane (should be lane 3)
+	lane, err := s.mgr.AllocateLane(s.ch)
+	require.NoError(t, err)
+	require.EqualValues(t, lane, 3)
+
+	ci, err = s.mgr.GetChannelInfo(s.ch)
+	require.NoError(t, err)
+	require.EqualValues(t, ci.NextLane, 4)
+
+	// Add a voucher in lane 1
+	voucherLane = uint64(1)
+	sv = createTestVoucher(t, s.ch, voucherLane, nonce, voucherAmount, s.fromKeyPrivate)
+	_, err = s.mgr.AddVoucherOutbound(ctx, s.ch, sv, nil, minDelta)
+	require.NoError(t, err)
+
+	ci, err = s.mgr.GetChannelInfo(s.ch)
+	require.NoError(t, err)
+	require.EqualValues(t, ci.NextLane, 4)
+
+	// Add a voucher in lane 7
+	voucherLane = uint64(7)
+	sv = createTestVoucher(t, s.ch, voucherLane, nonce, voucherAmount, s.fromKeyPrivate)
+	_, err = s.mgr.AddVoucherOutbound(ctx, s.ch, sv, nil, minDelta)
+	require.NoError(t, err)
+
+	ci, err = s.mgr.GetChannelInfo(s.ch)
+	require.NoError(t, err)
+	require.EqualValues(t, ci.NextLane, 8)
+}
+
+func TestAllocateLane(t *testing.T) {
+	ctx := context.Background()
+
+	// Set up a manager with a single payment channel
+	s := testSetupMgrWithChannel(ctx, t)
+
+	// First lane should be 0
+	lane, err := s.mgr.AllocateLane(s.ch)
+	require.NoError(t, err)
+	require.EqualValues(t, lane, 0)
+
+	// Next lane should be 1
+	lane, err = s.mgr.AllocateLane(s.ch)
+	require.NoError(t, err)
+	require.EqualValues(t, lane, 1)
+}
+
+func TestAllocateLaneWithExistingLaneState(t *testing.T) {
+	ctx := context.Background()
+
+	fromKeyPrivate, fromKeyPublic := testGenerateKeyPair(t)
+
+	ch := tutils.NewIDAddr(t, 100)
+	from := tutils.NewSECP256K1Addr(t, string(fromKeyPublic))
+	to := tutils.NewSECP256K1Addr(t, "secpTo")
+	fromAcct := tutils.NewActorAddr(t, "fromAct")
+	toAcct := tutils.NewActorAddr(t, "toAct")
+
+	mock := newMockManagerAPI()
+	mock.setAccountAddress(fromAcct, from)
+	mock.setAccountAddress(toAcct, to)
+	mock.addWalletAddress(to)
+
+	store := NewStore(ds_sync.MutexWrap(ds.NewMapDatastore()))
+
+	// Create a channel that will be retrieved from state
+	actorBalance := big.NewInt(10)
+	toSend := big.NewInt(1)
+
+	act := &types.Actor{
+		Code:    builtin.AccountActorCodeID,
+		Head:    cid.Cid{},
+		Nonce:   0,
+		Balance: actorBalance,
+	}
+
+	mock.setPaychState(ch, act, paychmock.NewMockPayChState(fromAcct, toAcct, abi.ChainEpoch(0), toSend, make(map[uint64]paych.LaneState)))
+
+	mgr, err := newManager(store, mock)
+	require.NoError(t, err)
+
+	// Create a voucher on lane 2
+	// (also reads the channel from state and puts it in the store)
+	voucherLane := uint64(2)
+	minDelta := big.NewInt(0)
+	nonce := uint64(2)
+	voucherAmount := big.NewInt(5)
+	sv := createTestVoucher(t, ch, voucherLane, nonce, voucherAmount, fromKeyPrivate)
+	_, err = mgr.AddVoucherInbound(ctx, ch, sv, nil, minDelta)
+	require.NoError(t, err)
+
+	// Allocate lane should return the next lane (lane 3)
+	lane, err := mgr.AllocateLane(ch)
+	require.NoError(t, err)
+	require.EqualValues(t, 3, lane)
+}
+
+func TestAddVoucherProof(t *testing.T) {
+	ctx := context.Background()
+
+	// Set up a manager with a single payment channel
+	s := testSetupMgrWithChannel(ctx, t)
+
+	nonce := uint64(1)
+	voucherAmount := big.NewInt(1)
+	minDelta := big.NewInt(0)
+	voucherAmount = big.NewInt(2)
+	voucherLane := uint64(1)
+
+	// Add a voucher with no proof
+	var proof []byte
+	sv := createTestVoucher(t, s.ch, voucherLane, nonce, voucherAmount, s.fromKeyPrivate)
+	_, err := s.mgr.AddVoucherOutbound(ctx, s.ch, sv, nil, minDelta)
+	require.NoError(t, err)
+
+	// Expect one voucher with no proof
+	ci, err := s.mgr.GetChannelInfo(s.ch)
+	require.NoError(t, err)
+	require.Len(t, ci.Vouchers, 1)
+	require.Len(t, ci.Vouchers[0].Proof, 0)
+
+	// Add same voucher with no proof
+	voucherLane = uint64(1)
+	_, err = s.mgr.AddVoucherOutbound(ctx, s.ch, sv, proof, minDelta)
+	require.NoError(t, err)
+
+	// Expect one voucher with no proof
+	ci, err = s.mgr.GetChannelInfo(s.ch)
+	require.NoError(t, err)
+	require.Len(t, ci.Vouchers, 1)
+	require.Len(t, ci.Vouchers[0].Proof, 0)
+
+	// Add same voucher with proof
+	proof = []byte{1}
+	_, err = s.mgr.AddVoucherOutbound(ctx, s.ch, sv, proof, minDelta)
+	require.NoError(t, err)
+
+	// Should add proof to existing voucher
+	ci, err = s.mgr.GetChannelInfo(s.ch)
+	require.NoError(t, err)
+	require.Len(t, ci.Vouchers, 1)
+	require.Len(t, ci.Vouchers[0].Proof, 1)
+}
+
+func TestAddVoucherInboundWalletKey(t *testing.T) {
+	ctx := context.Background()
+
+	fromKeyPrivate, fromKeyPublic := testGenerateKeyPair(t)
+
+	ch := tutils.NewIDAddr(t, 100)
+	from := tutils.NewSECP256K1Addr(t, string(fromKeyPublic))
+	to := tutils.NewSECP256K1Addr(t, "secpTo")
+	fromAcct := tutils.NewActorAddr(t, "fromAct")
+	toAcct := tutils.NewActorAddr(t, "toAct")
+
+	// Create an actor for the channel in state
+	act := &types.Actor{
+		Code:    builtin.AccountActorCodeID,
+		Head:    cid.Cid{},
+		Nonce:   0,
+		Balance: types.NewInt(20),
+	}
+
+	mock := newMockManagerAPI()
+	mock.setAccountAddress(fromAcct, from)
+	mock.setAccountAddress(toAcct, to)
+
+	mock.setPaychState(ch, act, paychmock.NewMockPayChState(fromAcct, toAcct, abi.ChainEpoch(0), types.NewInt(0), make(map[uint64]paych.LaneState)))
+
+	// Create a manager
+	store := NewStore(ds_sync.MutexWrap(ds.NewMapDatastore()))
+	mgr, err := newManager(store, mock)
+	require.NoError(t, err)
+
+	// Add a voucher
+	nonce := uint64(1)
+	voucherLane := uint64(1)
+	minDelta := big.NewInt(0)
+	voucherAmount := big.NewInt(2)
+	sv := createTestVoucher(t, ch, voucherLane, nonce, voucherAmount, fromKeyPrivate)
+	_, err = mgr.AddVoucherInbound(ctx, ch, sv, nil, minDelta)
+
+	// Should fail because there is no wallet key matching the channel To
+	// address (ie, the channel is not "owned" by this node)
+	require.Error(t, err)
+
+	// Add wallet key for To address
+	mock.addWalletAddress(to)
+
+	// Add voucher again
+	sv = createTestVoucher(t, ch, voucherLane, nonce, voucherAmount, fromKeyPrivate)
+	_, err = mgr.AddVoucherInbound(ctx, ch, sv, nil, minDelta)
+
+	// Should now pass because there is a wallet key matching the channel To
+	// address
+	require.NoError(t, err)
+}
+
+func TestBestSpendable(t *testing.T) {
+	ctx := context.Background()
+
+	// Set up a manager with a single payment channel
+	s := testSetupMgrWithChannel(ctx, t)
+
+	// Add vouchers to lane 1 with amounts: [1, 2, 3]
+	voucherLane := uint64(1)
+	minDelta := big.NewInt(0)
+	nonce := uint64(1)
+	voucherAmount := big.NewInt(1)
+	svL1V1 := createTestVoucher(t, s.ch, voucherLane, nonce, voucherAmount, s.fromKeyPrivate)
+	_, err := s.mgr.AddVoucherInbound(ctx, s.ch, svL1V1, nil, minDelta)
+	require.NoError(t, err)
+
+	nonce++
+	voucherAmount = big.NewInt(2)
+	svL1V2 := createTestVoucher(t, s.ch, voucherLane, nonce, voucherAmount, s.fromKeyPrivate)
+	_, err = s.mgr.AddVoucherInbound(ctx, s.ch, svL1V2, nil, minDelta)
+	require.NoError(t, err)
+
+	nonce++
+	voucherAmount = big.NewInt(3)
+	svL1V3 := createTestVoucher(t, s.ch, voucherLane, nonce, voucherAmount, s.fromKeyPrivate)
+	_, err = s.mgr.AddVoucherInbound(ctx, s.ch, svL1V3, nil, minDelta)
+	require.NoError(t, err)
+
+	// Add voucher to lane 2 with amounts: [2]
+	voucherLane = uint64(2)
+	nonce = uint64(1)
+	voucherAmount = big.NewInt(2)
+	svL2V1 := createTestVoucher(t, s.ch, voucherLane, nonce, voucherAmount, s.fromKeyPrivate)
+	_, err = s.mgr.AddVoucherInbound(ctx, s.ch, svL2V1, nil, minDelta)
+	require.NoError(t, err)
+
+	// Return success exit code from calls to check if voucher is spendable
+	bsapi := newMockBestSpendableAPI(s.mgr)
+	s.mock.setCallResponse(&api.InvocResult{
+		MsgRct: &types.MessageReceipt{
+			ExitCode: 0,
+		},
+	})
+
+	// Verify best spendable vouchers on each lane
+	vouchers, err := BestSpendableByLane(ctx, bsapi, s.ch)
+	require.NoError(t, err)
+	require.Len(t, vouchers, 2)
+
+	vchr, ok := vouchers[1]
+	require.True(t, ok)
+	require.EqualValues(t, 3, vchr.Amount.Int64())
+
+	vchr, ok = vouchers[2]
+	require.True(t, ok)
+	require.EqualValues(t, 2, vchr.Amount.Int64())
+
+	// Submit voucher from lane 2
+	_, err = s.mgr.SubmitVoucher(ctx, s.ch, svL2V1, nil, nil)
+	require.NoError(t, err)
+
+	// Best spendable voucher should no longer include lane 2
+	// (because voucher has not been submitted)
+	vouchers, err = BestSpendableByLane(ctx, bsapi, s.ch)
+	require.NoError(t, err)
+	require.Len(t, vouchers, 1)
+
+	// Submit first voucher from lane 1
+	_, err = s.mgr.SubmitVoucher(ctx, s.ch, svL1V1, nil, nil)
+	require.NoError(t, err)
+
+	// Best spendable voucher for lane 1 should still be highest value voucher
+	vouchers, err = BestSpendableByLane(ctx, bsapi, s.ch)
+	require.NoError(t, err)
+	require.Len(t, vouchers, 1)
+
+	vchr, ok = vouchers[1]
+	require.True(t, ok)
+	require.EqualValues(t, 3, vchr.Amount.Int64())
+}
+
+func TestCheckSpendable(t *testing.T) {
+	ctx := context.Background()
+
+	// Set up a manager with a single payment channel
+	s := testSetupMgrWithChannel(ctx, t)
+
+	// Create voucher with Extra
+	voucherLane := uint64(1)
+	nonce := uint64(1)
+	voucherAmount := big.NewInt(1)
+	voucher := createTestVoucherWithExtra(t, s.ch, voucherLane, nonce, voucherAmount, s.fromKeyPrivate)
+
+	// Add voucher with proof
+	minDelta := big.NewInt(0)
+	proof := []byte("proof")
+	_, err := s.mgr.AddVoucherInbound(ctx, s.ch, voucher, proof, minDelta)
+	require.NoError(t, err)
+
+	// Return success exit code from VM call, which indicates that voucher is
+	// spendable
+	successResponse := &api.InvocResult{
+		MsgRct: &types.MessageReceipt{
+			ExitCode: 0,
+		},
+	}
+	s.mock.setCallResponse(successResponse)
+
+	// Check that spendable is true
+	secret := []byte("secret")
+	otherProof := []byte("other proof")
+	spendable, err := s.mgr.CheckVoucherSpendable(ctx, s.ch, voucher, secret, otherProof)
+	require.NoError(t, err)
+	require.True(t, spendable)
+
+	// Check that the secret and proof were passed through correctly
+	lastCall := s.mock.getLastCall()
+	var p paych0.UpdateChannelStateParams
+	err = p.UnmarshalCBOR(bytes.NewReader(lastCall.Params))
+	require.NoError(t, err)
+	require.Equal(t, otherProof, p.Proof)
+	require.Equal(t, secret, p.Secret)
+
+	// Check that if no proof is supplied, the proof supplied to add voucher
+	// above is used
+	secret2 := []byte("secret2")
+	spendable, err = s.mgr.CheckVoucherSpendable(ctx, s.ch, voucher, secret2, nil)
+	require.NoError(t, err)
+	require.True(t, spendable)
+
+	lastCall = s.mock.getLastCall()
+	var p2 paych0.UpdateChannelStateParams
+	err = p2.UnmarshalCBOR(bytes.NewReader(lastCall.Params))
+	require.NoError(t, err)
+	require.Equal(t, proof, p2.Proof)
+	require.Equal(t, secret2, p2.Secret)
+
+	// Check that if VM call returns non-success exit code, spendable is false
+	s.mock.setCallResponse(&api.InvocResult{
+		MsgRct: &types.MessageReceipt{
+			ExitCode: 1,
+		},
+	})
+	spendable, err = s.mgr.CheckVoucherSpendable(ctx, s.ch, voucher, secret, nil)
+	require.NoError(t, err)
+	require.False(t, spendable)
+
+	// Return success exit code (indicating voucher is spendable)
+	s.mock.setCallResponse(successResponse)
+	spendable, err = s.mgr.CheckVoucherSpendable(ctx, s.ch, voucher, secret, nil)
+	require.NoError(t, err)
+	require.True(t, spendable)
+
+	// Check that voucher is no longer spendable once it has been submitted
+	_, err = s.mgr.SubmitVoucher(ctx, s.ch, voucher, nil, nil)
+	require.NoError(t, err)
+
+	spendable, err = s.mgr.CheckVoucherSpendable(ctx, s.ch, voucher, secret, nil)
+	require.NoError(t, err)
+	require.False(t, spendable)
+}
+
+func TestSubmitVoucher(t *testing.T) {
+	ctx := context.Background()
+
+	// Set up a manager with a single payment channel
+	s := testSetupMgrWithChannel(ctx, t)
+
+	// Create voucher with Extra
+	voucherLane := uint64(1)
+	nonce := uint64(1)
+	voucherAmount := big.NewInt(1)
+	voucher := createTestVoucherWithExtra(t, s.ch, voucherLane, nonce, voucherAmount, s.fromKeyPrivate)
+
+	// Add voucher with proof
+	minDelta := big.NewInt(0)
+	addVoucherProof := []byte("proof")
+	_, err := s.mgr.AddVoucherInbound(ctx, s.ch, voucher, addVoucherProof, minDelta)
+	require.NoError(t, err)
+
+	// Submit voucher
+	secret := []byte("secret")
+	submitProof := []byte("submit proof")
+	submitCid, err := s.mgr.SubmitVoucher(ctx, s.ch, voucher, secret, submitProof)
+	require.NoError(t, err)
+
+	// Check that the secret and proof were passed through correctly
+	msg := s.mock.pushedMessages(submitCid)
+	var p paych0.UpdateChannelStateParams
+	err = p.UnmarshalCBOR(bytes.NewReader(msg.Message.Params))
+	require.NoError(t, err)
+	require.Equal(t, submitProof, p.Proof)
+	require.Equal(t, secret, p.Secret)
+
+	// Check that if no proof is supplied to submit voucher, the proof supplied
+	// to add voucher is used
+	nonce++
+	voucherAmount = big.NewInt(2)
+	addVoucherProof2 := []byte("proof2")
+	secret2 := []byte("secret2")
+	voucher = createTestVoucherWithExtra(t, s.ch, voucherLane, nonce, voucherAmount, s.fromKeyPrivate)
+	_, err = s.mgr.AddVoucherInbound(ctx, s.ch, voucher, addVoucherProof2, minDelta)
+	require.NoError(t, err)
+
+	submitCid, err = s.mgr.SubmitVoucher(ctx, s.ch, voucher, secret2, nil)
+	require.NoError(t, err)
+
+	msg = s.mock.pushedMessages(submitCid)
+	var p2 paych0.UpdateChannelStateParams
+	err = p2.UnmarshalCBOR(bytes.NewReader(msg.Message.Params))
+	require.NoError(t, err)
+	require.Equal(t, addVoucherProof2, p2.Proof)
+	require.Equal(t, secret2, p2.Secret)
+
+	// Submit a voucher without first adding it
+	nonce++
+	voucherAmount = big.NewInt(3)
+	secret3 := []byte("secret2")
+	proof3 := []byte("proof3")
+	voucher = createTestVoucherWithExtra(t, s.ch, voucherLane, nonce, voucherAmount, s.fromKeyPrivate)
+	submitCid, err = s.mgr.SubmitVoucher(ctx, s.ch, voucher, secret3, proof3)
+	require.NoError(t, err)
+
+	msg = s.mock.pushedMessages(submitCid)
+	var p3 paych0.UpdateChannelStateParams
+	err = p3.UnmarshalCBOR(bytes.NewReader(msg.Message.Params))
+	require.NoError(t, err)
+	require.Equal(t, proof3, p3.Proof)
+	require.Equal(t, secret3, p3.Secret)
+
+	// Verify that vouchers are marked as submitted
+	vis, err := s.mgr.ListVouchers(ctx, s.ch)
+	require.NoError(t, err)
+	require.Len(t, vis, 3)
+
+	for _, vi := range vis {
+		require.True(t, vi.Submitted)
+	}
+
+	// Attempting to submit the same voucher again should fail
+	_, err = s.mgr.SubmitVoucher(ctx, s.ch, voucher, secret2, nil)
+	require.Error(t, err)
+}
+
+type testScaffold struct {
+	mgr            *Manager
+	mock           *mockManagerAPI
+	ch             address.Address
+	amt            big.Int
+	fromAcct       address.Address
+	fromKeyPrivate []byte
+}
+
+func testSetupMgrWithChannel(ctx context.Context, t *testing.T) *testScaffold {
+	fromKeyPrivate, fromKeyPublic := testGenerateKeyPair(t)
+
+	ch := tutils.NewIDAddr(t, 100)
+	from := tutils.NewSECP256K1Addr(t, string(fromKeyPublic))
+	to := tutils.NewSECP256K1Addr(t, "secpTo")
+	fromAcct := tutils.NewActorAddr(t, "fromAct")
+	toAcct := tutils.NewActorAddr(t, "toAct")
+
+	mock := newMockManagerAPI()
+	mock.setAccountAddress(fromAcct, from)
+	mock.setAccountAddress(toAcct, to)
+
+	// Create channel in state
+	balance := big.NewInt(20)
+	act := &types.Actor{
+		Code:    builtin.AccountActorCodeID,
+		Head:    cid.Cid{},
+		Nonce:   0,
+		Balance: balance,
+	}
+	mock.setPaychState(ch, act, paychmock.NewMockPayChState(fromAcct, toAcct, abi.ChainEpoch(0), big.NewInt(0), make(map[uint64]paych.LaneState)))
+
+	store := NewStore(ds_sync.MutexWrap(ds.NewMapDatastore()))
+	mgr, err := newManager(store, mock)
+	require.NoError(t, err)
+
+	// Create the channel in the manager's store
+	ci := &ChannelInfo{
+		Channel:   &ch,
+		Control:   fromAcct,
+		Target:    toAcct,
+		Direction: DirOutbound,
+	}
+	err = mgr.store.putChannelInfo(ci)
+	require.NoError(t, err)
+
+	// Add the from signing key to the wallet
+	mock.addSigningKey(fromKeyPrivate)
+
+	return &testScaffold{
+		mgr:            mgr,
+		mock:           mock,
+		ch:             ch,
+		amt:            balance,
+		fromAcct:       fromAcct,
+		fromKeyPrivate: fromKeyPrivate,
+	}
+}
+
+func testGenerateKeyPair(t *testing.T) ([]byte, []byte) {
+	priv, err := sigs.Generate(crypto.SigTypeSecp256k1)
+	require.NoError(t, err)
+	pub, err := sigs.ToPublic(crypto.SigTypeSecp256k1, priv)
+	require.NoError(t, err)
+	return priv, pub
+}
+
+func createTestVoucher(t *testing.T, ch address.Address, voucherLane uint64, nonce uint64, voucherAmount big.Int, key []byte) *paych0.SignedVoucher {
+	sv := &paych0.SignedVoucher{
+		ChannelAddr: ch,
+		Lane:        voucherLane,
+		Nonce:       nonce,
+		Amount:      voucherAmount,
+	}
+
+	signingBytes, err := sv.SigningBytes()
+	require.NoError(t, err)
+	sig, err := sigs.Sign(crypto.SigTypeSecp256k1, key, signingBytes)
+	require.NoError(t, err)
+	sv.Signature = sig
+	return sv
+}
+
+func createTestVoucherWithExtra(t *testing.T, ch address.Address, voucherLane uint64, nonce uint64, voucherAmount big.Int, key []byte) *paych0.SignedVoucher {
+	sv := &paych0.SignedVoucher{
+		ChannelAddr: ch,
+		Lane:        voucherLane,
+		Nonce:       nonce,
+		Amount:      voucherAmount,
+		Extra: &paych0.ModVerifyParams{
+			Actor: tutils.NewActorAddr(t, "act"),
+		},
+	}
+
+	signingBytes, err := sv.SigningBytes()
+	require.NoError(t, err)
+	sig, err := sigs.Sign(crypto.SigTypeSecp256k1, key, signingBytes)
+	require.NoError(t, err)
+	sv.Signature = sig
+
+	return sv
+}
+
+type mockBestSpendableAPI struct {
+	mgr *Manager
+}
+
+func (m *mockBestSpendableAPI) PaychVoucherList(ctx context.Context, ch address.Address) ([]*paych0.SignedVoucher, error) {
+	vi, err := m.mgr.ListVouchers(ctx, ch)
+	if err != nil {
+		return nil, err
+	}
+
+	out := make([]*paych0.SignedVoucher, len(vi))
+	for k, v := range vi {
+		out[k] = v.Voucher
+	}
+
+	return out, nil
+}
+
+func (m *mockBestSpendableAPI) PaychVoucherCheckSpendable(ctx context.Context, ch address.Address, voucher *paych0.SignedVoucher, secret []byte, proof []byte) (bool, error) {
+	return m.mgr.CheckVoucherSpendable(ctx, ch, voucher, secret, proof)
+}
+
+func newMockBestSpendableAPI(mgr *Manager) BestSpendableAPI {
+	return &mockBestSpendableAPI{mgr: mgr}
+}
diff --git a/paychmgr/paychget_test.go b/paychmgr/paychget_test.go
new file mode 100644
index 000000000..430e66c67
--- /dev/null
+++ b/paychmgr/paychget_test.go
@@ -0,0 +1,1062 @@
+package paychmgr
+
+import (
+	"context"
+	"sync"
+	"testing"
+	"time"
+
+	cborrpc "github.com/filecoin-project/go-cbor-util"
+	"github.com/ipfs/go-cid"
+	ds "github.com/ipfs/go-datastore"
+	ds_sync "github.com/ipfs/go-datastore/sync"
+	"github.com/stretchr/testify/require"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/big"
+	"github.com/filecoin-project/specs-actors/actors/builtin"
+	init_ "github.com/filecoin-project/specs-actors/actors/builtin/init"
+	tutils "github.com/filecoin-project/specs-actors/support/testing"
+
+	lotusinit "github.com/filecoin-project/lotus/chain/actors/builtin/init"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/paych"
+	paychmock "github.com/filecoin-project/lotus/chain/actors/builtin/paych/mock"
+	"github.com/filecoin-project/lotus/chain/types"
+)
+
+func testChannelResponse(t *testing.T, ch address.Address) types.MessageReceipt {
+	createChannelRet := init_.ExecReturn{
+		IDAddress:     ch,
+		RobustAddress: ch,
+	}
+	createChannelRetBytes, err := cborrpc.Dump(&createChannelRet)
+	require.NoError(t, err)
+	createChannelResponse := types.MessageReceipt{
+		ExitCode: 0,
+		Return:   createChannelRetBytes,
+	}
+	return createChannelResponse
+}
+
+// TestPaychGetCreateChannelMsg tests that GetPaych sends a message to create
+// a new channel with the correct funds
+func TestPaychGetCreateChannelMsg(t *testing.T) {
+	ctx := context.Background()
+	store := NewStore(ds_sync.MutexWrap(ds.NewMapDatastore()))
+
+	from := tutils.NewIDAddr(t, 101)
+	to := tutils.NewIDAddr(t, 102)
+
+	mock := newMockManagerAPI()
+	defer mock.close()
+
+	mgr, err := newManager(store, mock)
+	require.NoError(t, err)
+
+	amt := big.NewInt(10)
+	ch, mcid, err := mgr.GetPaych(ctx, from, to, amt)
+	require.NoError(t, err)
+	require.Equal(t, address.Undef, ch)
+
+	pushedMsg := mock.pushedMessages(mcid)
+	require.Equal(t, from, pushedMsg.Message.From)
+	require.Equal(t, lotusinit.Address, pushedMsg.Message.To)
+	require.Equal(t, amt, pushedMsg.Message.Value)
+}
+
+// TestPaychGetCreateChannelThenAddFunds tests creating a channel and then
+// adding funds to it
+func TestPaychGetCreateChannelThenAddFunds(t *testing.T) {
+	ctx := context.Background()
+	store := NewStore(ds_sync.MutexWrap(ds.NewMapDatastore()))
+
+	ch := tutils.NewIDAddr(t, 100)
+	from := tutils.NewIDAddr(t, 101)
+	to := tutils.NewIDAddr(t, 102)
+
+	mock := newMockManagerAPI()
+	defer mock.close()
+
+	mgr, err := newManager(store, mock)
+	require.NoError(t, err)
+
+	// Send create message for a channel with value 10
+	amt := big.NewInt(10)
+	_, createMsgCid, err := mgr.GetPaych(ctx, from, to, amt)
+	require.NoError(t, err)
+
+	// Should have no channels yet (message sent but channel not created)
+	cis, err := mgr.ListChannels()
+	require.NoError(t, err)
+	require.Len(t, cis, 0)
+
+	// 1. Set up create channel response (sent in response to WaitForMsg())
+	response := testChannelResponse(t, ch)
+
+	done := make(chan struct{})
+	go func() {
+		defer close(done)
+
+		// 2. Request add funds - should block until create channel has completed
+		amt2 := big.NewInt(5)
+		ch2, addFundsMsgCid, err := mgr.GetPaych(ctx, from, to, amt2)
+
+		// 4. This GetPaych should return after create channel from first
+		//    GetPaych completes
+		require.NoError(t, err)
+
+		// Expect the channel to be the same
+		require.Equal(t, ch, ch2)
+		// Expect add funds message CID to be different to create message cid
+		require.NotEqual(t, createMsgCid, addFundsMsgCid)
+
+		// Should have one channel, whose address is the channel that was created
+		cis, err := mgr.ListChannels()
+		require.NoError(t, err)
+		require.Len(t, cis, 1)
+		require.Equal(t, ch, cis[0])
+
+		// Amount should be amount sent to first GetPaych (to create
+		// channel).
+		// PendingAmount should be amount sent in second GetPaych
+		// (second GetPaych triggered add funds, which has not yet been confirmed)
+		ci, err := mgr.GetChannelInfo(ch)
+		require.NoError(t, err)
+		require.EqualValues(t, 10, ci.Amount.Int64())
+		require.EqualValues(t, 5, ci.PendingAmount.Int64())
+		require.Nil(t, ci.CreateMsg)
+
+		// Trigger add funds confirmation
+		mock.receiveMsgResponse(addFundsMsgCid, types.MessageReceipt{ExitCode: 0})
+
+		// Wait for add funds confirmation to be processed by manager
+		_, err = mgr.GetPaychWaitReady(ctx, addFundsMsgCid)
+		require.NoError(t, err)
+
+		// Should still have one channel
+		cis, err = mgr.ListChannels()
+		require.NoError(t, err)
+		require.Len(t, cis, 1)
+		require.Equal(t, ch, cis[0])
+
+		// Channel amount should include last amount sent to GetPaych
+		ci, err = mgr.GetChannelInfo(ch)
+		require.NoError(t, err)
+		require.EqualValues(t, 15, ci.Amount.Int64())
+		require.EqualValues(t, 0, ci.PendingAmount.Int64())
+		require.Nil(t, ci.AddFundsMsg)
+	}()
+
+	// 3. Send create channel response
+	mock.receiveMsgResponse(createMsgCid, response)
+
+	<-done
+}
+
+// TestPaychGetCreateChannelWithErrorThenCreateAgain tests that if an
+// operation is queued up behind a create channel operation, and the create
+// channel fails, then the waiting operation can succeed.
+func TestPaychGetCreateChannelWithErrorThenCreateAgain(t *testing.T) {
+	ctx := context.Background()
+	store := NewStore(ds_sync.MutexWrap(ds.NewMapDatastore()))
+
+	from := tutils.NewIDAddr(t, 101)
+	to := tutils.NewIDAddr(t, 102)
+
+	mock := newMockManagerAPI()
+	defer mock.close()
+
+	mgr, err := newManager(store, mock)
+	require.NoError(t, err)
+
+	// Send create message for a channel
+	amt := big.NewInt(10)
+	_, mcid1, err := mgr.GetPaych(ctx, from, to, amt)
+	require.NoError(t, err)
+
+	// 1. Set up create channel response (sent in response to WaitForMsg())
+	//    This response indicates an error.
+	errResponse := types.MessageReceipt{
+		ExitCode: 1, // error
+		Return:   []byte{},
+	}
+
+	done := make(chan struct{})
+	go func() {
+		defer close(done)
+
+		// 2. Should block until create channel has completed.
+		//    Because first channel create fails, this request
+		//    should be for channel create again.
+		amt2 := big.NewInt(5)
+		ch2, mcid2, err := mgr.GetPaych(ctx, from, to, amt2)
+		require.NoError(t, err)
+		require.Equal(t, address.Undef, ch2)
+
+		// 4. Send a success response
+		ch := tutils.NewIDAddr(t, 100)
+		successResponse := testChannelResponse(t, ch)
+		mock.receiveMsgResponse(mcid2, successResponse)
+
+		_, err = mgr.GetPaychWaitReady(ctx, mcid2)
+		require.NoError(t, err)
+
+		// Should have one channel, whose address is the channel that was created
+		cis, err := mgr.ListChannels()
+		require.NoError(t, err)
+		require.Len(t, cis, 1)
+		require.Equal(t, ch, cis[0])
+
+		ci, err := mgr.GetChannelInfo(ch)
+		require.NoError(t, err)
+		require.Equal(t, amt2, ci.Amount)
+	}()
+
+	// 3. Send error response to first channel create
+	mock.receiveMsgResponse(mcid1, errResponse)
+
+	<-done
+}
+
+// TestPaychGetRecoverAfterError tests that after a create channel fails, the
+// next attempt to create channel can succeed.
+func TestPaychGetRecoverAfterError(t *testing.T) {
+	ctx := context.Background()
+	store := NewStore(ds_sync.MutexWrap(ds.NewMapDatastore()))
+
+	ch := tutils.NewIDAddr(t, 100)
+	from := tutils.NewIDAddr(t, 101)
+	to := tutils.NewIDAddr(t, 102)
+
+	mock := newMockManagerAPI()
+	defer mock.close()
+
+	mgr, err := newManager(store, mock)
+	require.NoError(t, err)
+
+	// Send create message for a channel
+	amt := big.NewInt(10)
+	_, mcid, err := mgr.GetPaych(ctx, from, to, amt)
+	require.NoError(t, err)
+
+	// Send error create channel response
+	mock.receiveMsgResponse(mcid, types.MessageReceipt{
+		ExitCode: 1, // error
+		Return:   []byte{},
+	})
+
+	// Send create message for a channel again
+	amt2 := big.NewInt(7)
+	_, mcid2, err := mgr.GetPaych(ctx, from, to, amt2)
+	require.NoError(t, err)
+
+	// Send success create channel response
+	response := testChannelResponse(t, ch)
+	mock.receiveMsgResponse(mcid2, response)
+
+	_, err = mgr.GetPaychWaitReady(ctx, mcid2)
+	require.NoError(t, err)
+
+	// Should have one channel, whose address is the channel that was created
+	cis, err := mgr.ListChannels()
+	require.NoError(t, err)
+	require.Len(t, cis, 1)
+	require.Equal(t, ch, cis[0])
+
+	ci, err := mgr.GetChannelInfo(ch)
+	require.NoError(t, err)
+	require.Equal(t, amt2, ci.Amount)
+	require.EqualValues(t, 0, ci.PendingAmount.Int64())
+	require.Nil(t, ci.CreateMsg)
+}
+
+// TestPaychGetRecoverAfterAddFundsError tests that after an add funds fails, the
+// next attempt to add funds can succeed.
+func TestPaychGetRecoverAfterAddFundsError(t *testing.T) {
+	ctx := context.Background()
+	store := NewStore(ds_sync.MutexWrap(ds.NewMapDatastore()))
+
+	ch := tutils.NewIDAddr(t, 100)
+	from := tutils.NewIDAddr(t, 101)
+	to := tutils.NewIDAddr(t, 102)
+
+	mock := newMockManagerAPI()
+	defer mock.close()
+
+	mgr, err := newManager(store, mock)
+	require.NoError(t, err)
+
+	// Send create message for a channel
+	amt := big.NewInt(10)
+	_, mcid1, err := mgr.GetPaych(ctx, from, to, amt)
+	require.NoError(t, err)
+
+	// Send success create channel response
+	response := testChannelResponse(t, ch)
+	mock.receiveMsgResponse(mcid1, response)
+
+	// Send add funds message for channel
+	amt2 := big.NewInt(5)
+	_, mcid2, err := mgr.GetPaych(ctx, from, to, amt2)
+	require.NoError(t, err)
+
+	// Send error add funds response
+	mock.receiveMsgResponse(mcid2, types.MessageReceipt{
+		ExitCode: 1, // error
+		Return:   []byte{},
+	})
+
+	_, err = mgr.GetPaychWaitReady(ctx, mcid2)
+	require.Error(t, err)
+
+	// Should have one channel, whose address is the channel that was created
+	cis, err := mgr.ListChannels()
+	require.NoError(t, err)
+	require.Len(t, cis, 1)
+	require.Equal(t, ch, cis[0])
+
+	ci, err := mgr.GetChannelInfo(ch)
+	require.NoError(t, err)
+	require.Equal(t, amt, ci.Amount)
+	require.EqualValues(t, 0, ci.PendingAmount.Int64())
+	require.Nil(t, ci.CreateMsg)
+	require.Nil(t, ci.AddFundsMsg)
+
+	// Send add funds message for channel again
+	amt3 := big.NewInt(2)
+	_, mcid3, err := mgr.GetPaych(ctx, from, to, amt3)
+	require.NoError(t, err)
+
+	// Send success add funds response
+	mock.receiveMsgResponse(mcid3, types.MessageReceipt{
+		ExitCode: 0,
+		Return:   []byte{},
+	})
+
+	_, err = mgr.GetPaychWaitReady(ctx, mcid3)
+	require.NoError(t, err)
+
+	// Should have one channel, whose address is the channel that was created
+	cis, err = mgr.ListChannels()
+	require.NoError(t, err)
+	require.Len(t, cis, 1)
+	require.Equal(t, ch, cis[0])
+
+	// Amount should include amount for successful add funds msg
+	ci, err = mgr.GetChannelInfo(ch)
+	require.NoError(t, err)
+	require.Equal(t, amt.Int64()+amt3.Int64(), ci.Amount.Int64())
+	require.EqualValues(t, 0, ci.PendingAmount.Int64())
+	require.Nil(t, ci.CreateMsg)
+	require.Nil(t, ci.AddFundsMsg)
+}
+
+// TestPaychGetRestartAfterCreateChannelMsg tests that if the system stops
+// right after the create channel message is sent, the channel will be
+// created when the system restarts.
+func TestPaychGetRestartAfterCreateChannelMsg(t *testing.T) {
+	ctx := context.Background()
+	store := NewStore(ds_sync.MutexWrap(ds.NewMapDatastore()))
+
+	ch := tutils.NewIDAddr(t, 100)
+	from := tutils.NewIDAddr(t, 101)
+	to := tutils.NewIDAddr(t, 102)
+
+	mock := newMockManagerAPI()
+
+	mgr, err := newManager(store, mock)
+	require.NoError(t, err)
+
+	// Send create message for a channel with value 10
+	amt := big.NewInt(10)
+	_, createMsgCid, err := mgr.GetPaych(ctx, from, to, amt)
+	require.NoError(t, err)
+
+	// Simulate shutting down system
+	mock.close()
+
+	// Create a new manager with the same datastore
+	mock2 := newMockManagerAPI()
+	defer mock2.close()
+
+	mgr2, err := newManager(store, mock2)
+	require.NoError(t, err)
+
+	// Should have no channels yet (message sent but channel not created)
+	cis, err := mgr2.ListChannels()
+	require.NoError(t, err)
+	require.Len(t, cis, 0)
+
+	// 1. Set up create channel response (sent in response to WaitForMsg())
+	response := testChannelResponse(t, ch)
+
+	done := make(chan struct{})
+	go func() {
+		defer close(done)
+
+		// 2. Request add funds - should block until create channel has completed
+		amt2 := big.NewInt(5)
+		ch2, addFundsMsgCid, err := mgr2.GetPaych(ctx, from, to, amt2)
+
+		// 4. This GetPaych should return after create channel from first
+		//    GetPaych completes
+		require.NoError(t, err)
+
+		// Expect the channel to have been created
+		require.Equal(t, ch, ch2)
+		// Expect add funds message CID to be different to create message cid
+		require.NotEqual(t, createMsgCid, addFundsMsgCid)
+
+		// Should have one channel, whose address is the channel that was created
+		cis, err := mgr2.ListChannels()
+		require.NoError(t, err)
+		require.Len(t, cis, 1)
+		require.Equal(t, ch, cis[0])
+
+		// Amount should be amount sent to first GetPaych (to create
+		// channel).
+		// PendingAmount should be amount sent in second GetPaych
+		// (second GetPaych triggered add funds, which has not yet been confirmed)
+		ci, err := mgr2.GetChannelInfo(ch)
+		require.NoError(t, err)
+		require.EqualValues(t, 10, ci.Amount.Int64())
+		require.EqualValues(t, 5, ci.PendingAmount.Int64())
+		require.Nil(t, ci.CreateMsg)
+	}()
+
+	// 3. Send create channel response
+	mock2.receiveMsgResponse(createMsgCid, response)
+
+	<-done
+}
+
+// TestPaychGetRestartAfterAddFundsMsg tests that if the system stops
+// right after the add funds message is sent, the add funds will be
+// processed when the system restarts.
+func TestPaychGetRestartAfterAddFundsMsg(t *testing.T) {
+	ctx := context.Background()
+	store := NewStore(ds_sync.MutexWrap(ds.NewMapDatastore()))
+
+	ch := tutils.NewIDAddr(t, 100)
+	from := tutils.NewIDAddr(t, 101)
+	to := tutils.NewIDAddr(t, 102)
+
+	mock := newMockManagerAPI()
+
+	mgr, err := newManager(store, mock)
+	require.NoError(t, err)
+
+	// Send create message for a channel
+	amt := big.NewInt(10)
+	_, mcid1, err := mgr.GetPaych(ctx, from, to, amt)
+	require.NoError(t, err)
+
+	// Send success create channel response
+	response := testChannelResponse(t, ch)
+	mock.receiveMsgResponse(mcid1, response)
+
+	// Send add funds message for channel
+	amt2 := big.NewInt(5)
+	_, mcid2, err := mgr.GetPaych(ctx, from, to, amt2)
+	require.NoError(t, err)
+
+	// Simulate shutting down system
+	mock.close()
+
+	// Create a new manager with the same datastore
+	mock2 := newMockManagerAPI()
+	defer mock2.close()
+
+	mgr2, err := newManager(store, mock2)
+	require.NoError(t, err)
+
+	// Send success add funds response
+	mock2.receiveMsgResponse(mcid2, types.MessageReceipt{
+		ExitCode: 0,
+		Return:   []byte{},
+	})
+
+	_, err = mgr2.GetPaychWaitReady(ctx, mcid2)
+	require.NoError(t, err)
+
+	// Should have one channel, whose address is the channel that was created
+	cis, err := mgr2.ListChannels()
+	require.NoError(t, err)
+	require.Len(t, cis, 1)
+	require.Equal(t, ch, cis[0])
+
+	// Amount should include amount for successful add funds msg
+	ci, err := mgr2.GetChannelInfo(ch)
+	require.NoError(t, err)
+	require.Equal(t, amt.Int64()+amt2.Int64(), ci.Amount.Int64())
+	require.EqualValues(t, 0, ci.PendingAmount.Int64())
+	require.Nil(t, ci.CreateMsg)
+	require.Nil(t, ci.AddFundsMsg)
+}
+
+// TestPaychGetWait tests that GetPaychWaitReady correctly waits for the
+// channel to be created or funds to be added
+func TestPaychGetWait(t *testing.T) {
+	ctx := context.Background()
+	store := NewStore(ds_sync.MutexWrap(ds.NewMapDatastore()))
+
+	from := tutils.NewIDAddr(t, 101)
+	to := tutils.NewIDAddr(t, 102)
+
+	mock := newMockManagerAPI()
+	defer mock.close()
+
+	mgr, err := newManager(store, mock)
+	require.NoError(t, err)
+
+	// 1. Get
+	amt := big.NewInt(10)
+	_, createMsgCid, err := mgr.GetPaych(ctx, from, to, amt)
+	require.NoError(t, err)
+
+	expch := tutils.NewIDAddr(t, 100)
+	go func() {
+		// 3. Send response
+		response := testChannelResponse(t, expch)
+		mock.receiveMsgResponse(createMsgCid, response)
+	}()
+
+	// 2. Wait till ready
+	ch, err := mgr.GetPaychWaitReady(ctx, createMsgCid)
+	require.NoError(t, err)
+	require.Equal(t, expch, ch)
+
+	// 4. Wait again - message has already been received so should
+	//    return immediately
+	ch, err = mgr.GetPaychWaitReady(ctx, createMsgCid)
+	require.NoError(t, err)
+	require.Equal(t, expch, ch)
+
+	// Request add funds
+	amt2 := big.NewInt(15)
+	_, addFundsMsgCid, err := mgr.GetPaych(ctx, from, to, amt2)
+	require.NoError(t, err)
+
+	go func() {
+		// 6. Send add funds response
+		addFundsResponse := types.MessageReceipt{
+			ExitCode: 0,
+			Return:   []byte{},
+		}
+		mock.receiveMsgResponse(addFundsMsgCid, addFundsResponse)
+	}()
+
+	// 5. Wait for add funds
+	ch, err = mgr.GetPaychWaitReady(ctx, addFundsMsgCid)
+	require.NoError(t, err)
+	require.Equal(t, expch, ch)
+}
+
+// TestPaychGetWaitErr tests that GetPaychWaitReady correctly handles errors
+func TestPaychGetWaitErr(t *testing.T) {
+	ctx := context.Background()
+	store := NewStore(ds_sync.MutexWrap(ds.NewMapDatastore()))
+
+	from := tutils.NewIDAddr(t, 101)
+	to := tutils.NewIDAddr(t, 102)
+
+	mock := newMockManagerAPI()
+	defer mock.close()
+
+	mgr, err := newManager(store, mock)
+	require.NoError(t, err)
+
+	// 1. Create channel
+	amt := big.NewInt(10)
+	_, mcid, err := mgr.GetPaych(ctx, from, to, amt)
+	require.NoError(t, err)
+
+	done := make(chan address.Address)
+	go func() {
+		defer close(done)
+
+		// 2. Wait for channel to be created
+		_, err := mgr.GetPaychWaitReady(ctx, mcid)
+
+		// 4. Channel creation should have failed
+		require.NotNil(t, err)
+
+		// 5. Call wait again with the same message CID
+		_, err = mgr.GetPaychWaitReady(ctx, mcid)
+
+		// 6. Should return immediately with the same error
+		require.NotNil(t, err)
+	}()
+
+	// 3. Send error response to create channel
+	response := types.MessageReceipt{
+		ExitCode: 1, // error
+		Return:   []byte{},
+	}
+	mock.receiveMsgResponse(mcid, response)
+
+	<-done
+}
+
+// TestPaychGetWaitCtx tests that GetPaychWaitReady returns early if the context
+// is cancelled
+func TestPaychGetWaitCtx(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	store := NewStore(ds_sync.MutexWrap(ds.NewMapDatastore()))
+
+	from := tutils.NewIDAddr(t, 101)
+	to := tutils.NewIDAddr(t, 102)
+
+	mock := newMockManagerAPI()
+	defer mock.close()
+
+	mgr, err := newManager(store, mock)
+	require.NoError(t, err)
+
+	amt := big.NewInt(10)
+	_, mcid, err := mgr.GetPaych(ctx, from, to, amt)
+	require.NoError(t, err)
+
+	// When the context is cancelled, should unblock wait
+	go func() {
+		cancel()
+	}()
+
+	_, err = mgr.GetPaychWaitReady(ctx, mcid)
+	require.Error(t, ctx.Err(), err)
+}
+
+// TestPaychGetMergeAddFunds tests that if a create channel is in
+// progress and two add funds are queued up behind it, the two add funds
+// will be merged
+func TestPaychGetMergeAddFunds(t *testing.T) {
+	ctx := context.Background()
+	store := NewStore(ds_sync.MutexWrap(ds.NewMapDatastore()))
+
+	ch := tutils.NewIDAddr(t, 100)
+	from := tutils.NewIDAddr(t, 101)
+	to := tutils.NewIDAddr(t, 102)
+
+	mock := newMockManagerAPI()
+	defer mock.close()
+
+	mgr, err := newManager(store, mock)
+	require.NoError(t, err)
+
+	// Send create message for a channel with value 10
+	createAmt := big.NewInt(10)
+	_, createMsgCid, err := mgr.GetPaych(ctx, from, to, createAmt)
+	require.NoError(t, err)
+
+	// Queue up two add funds requests behind create channel
+	var addFundsSent sync.WaitGroup
+	addFundsSent.Add(2)
+
+	addFundsAmt1 := big.NewInt(5)
+	addFundsAmt2 := big.NewInt(3)
+	var addFundsCh1 address.Address
+	var addFundsCh2 address.Address
+	var addFundsMcid1 cid.Cid
+	var addFundsMcid2 cid.Cid
+	go func() {
+		defer addFundsSent.Done()
+
+		// Request add funds - should block until create channel has completed
+		addFundsCh1, addFundsMcid1, err = mgr.GetPaych(ctx, from, to, addFundsAmt1)
+		require.NoError(t, err)
+	}()
+
+	go func() {
+		defer addFundsSent.Done()
+
+		// Request add funds again - should merge with waiting add funds request
+		addFundsCh2, addFundsMcid2, err = mgr.GetPaych(ctx, from, to, addFundsAmt2)
+		require.NoError(t, err)
+	}()
+	// Wait for add funds requests to be queued up
+	waitForQueueSize(t, mgr, from, to, 2)
+
+	// Send create channel response
+	response := testChannelResponse(t, ch)
+	mock.receiveMsgResponse(createMsgCid, response)
+
+	// Wait for create channel response
+	chres, err := mgr.GetPaychWaitReady(ctx, createMsgCid)
+	require.NoError(t, err)
+	require.Equal(t, ch, chres)
+
+	// Wait for add funds requests to be sent
+	addFundsSent.Wait()
+
+	// Expect add funds requests to have same channel as create channel and
+	// same message cid as each other (because they should have been merged)
+	require.Equal(t, ch, addFundsCh1)
+	require.Equal(t, ch, addFundsCh2)
+	require.Equal(t, addFundsMcid1, addFundsMcid2)
+
+	// Send success add funds response
+	mock.receiveMsgResponse(addFundsMcid1, types.MessageReceipt{
+		ExitCode: 0,
+		Return:   []byte{},
+	})
+
+	// Wait for add funds response
+	addFundsCh, err := mgr.GetPaychWaitReady(ctx, addFundsMcid1)
+	require.NoError(t, err)
+	require.Equal(t, ch, addFundsCh)
+
+	// Make sure that one create channel message and one add funds message was
+	// sent
+	require.Equal(t, 2, mock.pushedMessageCount())
+
+	// Check create message amount is correct
+	createMsg := mock.pushedMessages(createMsgCid)
+	require.Equal(t, from, createMsg.Message.From)
+	require.Equal(t, lotusinit.Address, createMsg.Message.To)
+	require.Equal(t, createAmt, createMsg.Message.Value)
+
+	// Check merged add funds amount is the sum of the individual
+	// amounts
+	addFundsMsg := mock.pushedMessages(addFundsMcid1)
+	require.Equal(t, from, addFundsMsg.Message.From)
+	require.Equal(t, ch, addFundsMsg.Message.To)
+	require.Equal(t, types.BigAdd(addFundsAmt1, addFundsAmt2), addFundsMsg.Message.Value)
+}
+
+// TestPaychGetMergeAddFundsCtxCancelOne tests that when a queued add funds
+// request is cancelled, its amount is removed from the total merged add funds
+func TestPaychGetMergeAddFundsCtxCancelOne(t *testing.T) {
+	ctx := context.Background()
+	store := NewStore(ds_sync.MutexWrap(ds.NewMapDatastore()))
+
+	ch := tutils.NewIDAddr(t, 100)
+	from := tutils.NewIDAddr(t, 101)
+	to := tutils.NewIDAddr(t, 102)
+
+	mock := newMockManagerAPI()
+	defer mock.close()
+
+	mgr, err := newManager(store, mock)
+	require.NoError(t, err)
+
+	// Send create message for a channel with value 10
+	createAmt := big.NewInt(10)
+	_, createMsgCid, err := mgr.GetPaych(ctx, from, to, createAmt)
+	require.NoError(t, err)
+
+	// Queue up two add funds requests behind create channel
+	var addFundsSent sync.WaitGroup
+	addFundsSent.Add(2)
+
+	addFundsAmt1 := big.NewInt(5)
+	addFundsAmt2 := big.NewInt(3)
+	var addFundsCh2 address.Address
+	var addFundsMcid2 cid.Cid
+	var addFundsErr1 error
+	addFundsCtx1, cancelAddFundsCtx1 := context.WithCancel(ctx)
+	go func() {
+		defer addFundsSent.Done()
+
+		// Request add funds - should block until create channel has completed
+		_, _, addFundsErr1 = mgr.GetPaych(addFundsCtx1, from, to, addFundsAmt1)
+	}()
+
+	go func() {
+		defer addFundsSent.Done()
+
+		// Request add funds again - should merge with waiting add funds request
+		addFundsCh2, addFundsMcid2, err = mgr.GetPaych(ctx, from, to, addFundsAmt2)
+		require.NoError(t, err)
+	}()
+	// Wait for add funds requests to be queued up
+	waitForQueueSize(t, mgr, from, to, 2)
+
+	// Cancel the first add funds request
+	cancelAddFundsCtx1()
+
+	// Send create channel response
+	response := testChannelResponse(t, ch)
+	mock.receiveMsgResponse(createMsgCid, response)
+
+	// Wait for create channel response
+	chres, err := mgr.GetPaychWaitReady(ctx, createMsgCid)
+	require.NoError(t, err)
+	require.Equal(t, ch, chres)
+
+	// Wait for add funds requests to be sent
+	addFundsSent.Wait()
+
+	// Expect first add funds request to have been cancelled
+	require.NotNil(t, addFundsErr1)
+	require.Equal(t, ch, addFundsCh2)
+
+	// Send success add funds response
+	mock.receiveMsgResponse(addFundsMcid2, types.MessageReceipt{
+		ExitCode: 0,
+		Return:   []byte{},
+	})
+
+	// Wait for add funds response
+	addFundsCh, err := mgr.GetPaychWaitReady(ctx, addFundsMcid2)
+	require.NoError(t, err)
+	require.Equal(t, ch, addFundsCh)
+
+	// Make sure that one create channel message and one add funds message was
+	// sent
+	require.Equal(t, 2, mock.pushedMessageCount())
+
+	// Check create message amount is correct
+	createMsg := mock.pushedMessages(createMsgCid)
+	require.Equal(t, from, createMsg.Message.From)
+	require.Equal(t, lotusinit.Address, createMsg.Message.To)
+	require.Equal(t, createAmt, createMsg.Message.Value)
+
+	// Check merged add funds amount only includes the second add funds amount
+	// (because first was cancelled)
+	addFundsMsg := mock.pushedMessages(addFundsMcid2)
+	require.Equal(t, from, addFundsMsg.Message.From)
+	require.Equal(t, ch, addFundsMsg.Message.To)
+	require.Equal(t, addFundsAmt2, addFundsMsg.Message.Value)
+}
+
+// TestPaychGetMergeAddFundsCtxCancelAll tests that when all queued add funds
+// requests are cancelled, no add funds message is sent
+func TestPaychGetMergeAddFundsCtxCancelAll(t *testing.T) {
+	ctx := context.Background()
+	store := NewStore(ds_sync.MutexWrap(ds.NewMapDatastore()))
+
+	ch := tutils.NewIDAddr(t, 100)
+	from := tutils.NewIDAddr(t, 101)
+	to := tutils.NewIDAddr(t, 102)
+
+	mock := newMockManagerAPI()
+	defer mock.close()
+
+	mgr, err := newManager(store, mock)
+	require.NoError(t, err)
+
+	// Send create message for a channel with value 10
+	createAmt := big.NewInt(10)
+	_, createMsgCid, err := mgr.GetPaych(ctx, from, to, createAmt)
+	require.NoError(t, err)
+
+	// Queue up two add funds requests behind create channel
+	var addFundsSent sync.WaitGroup
+	addFundsSent.Add(2)
+
+	var addFundsErr1 error
+	var addFundsErr2 error
+	addFundsCtx1, cancelAddFundsCtx1 := context.WithCancel(ctx)
+	addFundsCtx2, cancelAddFundsCtx2 := context.WithCancel(ctx)
+	go func() {
+		defer addFundsSent.Done()
+
+		// Request add funds - should block until create channel has completed
+		_, _, addFundsErr1 = mgr.GetPaych(addFundsCtx1, from, to, big.NewInt(5))
+	}()
+
+	go func() {
+		defer addFundsSent.Done()
+
+		// Request add funds again - should merge with waiting add funds request
+		_, _, addFundsErr2 = mgr.GetPaych(addFundsCtx2, from, to, big.NewInt(3))
+		require.NoError(t, err)
+	}()
+	// Wait for add funds requests to be queued up
+	waitForQueueSize(t, mgr, from, to, 2)
+
+	// Cancel all add funds requests
+	cancelAddFundsCtx1()
+	cancelAddFundsCtx2()
+
+	// Send create channel response
+	response := testChannelResponse(t, ch)
+	mock.receiveMsgResponse(createMsgCid, response)
+
+	// Wait for create channel response
+	chres, err := mgr.GetPaychWaitReady(ctx, createMsgCid)
+	require.NoError(t, err)
+	require.Equal(t, ch, chres)
+
+	// Wait for add funds requests to error out
+	addFundsSent.Wait()
+
+	require.NotNil(t, addFundsErr1)
+	require.NotNil(t, addFundsErr2)
+
+	// Make sure that just the create channel message was sent
+	require.Equal(t, 1, mock.pushedMessageCount())
+
+	// Check create message amount is correct
+	createMsg := mock.pushedMessages(createMsgCid)
+	require.Equal(t, from, createMsg.Message.From)
+	require.Equal(t, lotusinit.Address, createMsg.Message.To)
+	require.Equal(t, createAmt, createMsg.Message.Value)
+}
+
+// TestPaychAvailableFunds tests that PaychAvailableFunds returns the correct
+// channel state
+func TestPaychAvailableFunds(t *testing.T) {
+	ctx := context.Background()
+	store := NewStore(ds_sync.MutexWrap(ds.NewMapDatastore()))
+
+	fromKeyPrivate, fromKeyPublic := testGenerateKeyPair(t)
+	ch := tutils.NewIDAddr(t, 100)
+	from := tutils.NewSECP256K1Addr(t, string(fromKeyPublic))
+	to := tutils.NewIDAddr(t, 102)
+	fromAcct := tutils.NewActorAddr(t, "fromAct")
+	toAcct := tutils.NewActorAddr(t, "toAct")
+
+	mock := newMockManagerAPI()
+	defer mock.close()
+
+	mgr, err := newManager(store, mock)
+	require.NoError(t, err)
+
+	// No channel created yet so available funds should be all zeroes
+	av, err := mgr.AvailableFundsByFromTo(from, to)
+	require.NoError(t, err)
+	require.Nil(t, av.Channel)
+	require.Nil(t, av.PendingWaitSentinel)
+	require.EqualValues(t, 0, av.ConfirmedAmt.Int64())
+	require.EqualValues(t, 0, av.PendingAmt.Int64())
+	require.EqualValues(t, 0, av.QueuedAmt.Int64())
+	require.EqualValues(t, 0, av.VoucherReedeemedAmt.Int64())
+
+	// Send create message for a channel with value 10
+	createAmt := big.NewInt(10)
+	_, createMsgCid, err := mgr.GetPaych(ctx, from, to, createAmt)
+	require.NoError(t, err)
+
+	// Available funds should reflect create channel message sent
+	av, err = mgr.AvailableFundsByFromTo(from, to)
+	require.NoError(t, err)
+	require.Nil(t, av.Channel)
+	require.EqualValues(t, 0, av.ConfirmedAmt.Int64())
+	require.EqualValues(t, createAmt, av.PendingAmt)
+	require.EqualValues(t, 0, av.QueuedAmt.Int64())
+	require.EqualValues(t, 0, av.VoucherReedeemedAmt.Int64())
+	// Should now have a pending wait sentinel
+	require.NotNil(t, av.PendingWaitSentinel)
+
+	// Queue up an add funds request behind create channel
+	var addFundsSent sync.WaitGroup
+	addFundsSent.Add(1)
+
+	addFundsAmt := big.NewInt(5)
+	var addFundsMcid cid.Cid
+	go func() {
+		defer addFundsSent.Done()
+
+		// Request add funds - should block until create channel has completed
+		_, addFundsMcid, err = mgr.GetPaych(ctx, from, to, addFundsAmt)
+		require.NoError(t, err)
+	}()
+
+	// Wait for add funds request to be queued up
+	waitForQueueSize(t, mgr, from, to, 1)
+
+	// Available funds should now include queued funds
+	av, err = mgr.AvailableFundsByFromTo(from, to)
+	require.NoError(t, err)
+	require.Nil(t, av.Channel)
+	require.NotNil(t, av.PendingWaitSentinel)
+	require.EqualValues(t, 0, av.ConfirmedAmt.Int64())
+	// create amount is still pending
+	require.EqualValues(t, createAmt, av.PendingAmt)
+	// queued amount now includes add funds amount
+	require.EqualValues(t, addFundsAmt, av.QueuedAmt)
+	require.EqualValues(t, 0, av.VoucherReedeemedAmt.Int64())
+
+	// Create channel in state
+	mock.setAccountAddress(fromAcct, from)
+	mock.setAccountAddress(toAcct, to)
+	act := &types.Actor{
+		Code:    builtin.AccountActorCodeID,
+		Head:    cid.Cid{},
+		Nonce:   0,
+		Balance: createAmt,
+	}
+	mock.setPaychState(ch, act, paychmock.NewMockPayChState(fromAcct, toAcct, abi.ChainEpoch(0), big.NewInt(0), make(map[uint64]paych.LaneState)))
+	// Send create channel response
+	response := testChannelResponse(t, ch)
+	mock.receiveMsgResponse(createMsgCid, response)
+
+	// Wait for create channel response
+	chres, err := mgr.GetPaychWaitReady(ctx, *av.PendingWaitSentinel)
+	require.NoError(t, err)
+	require.Equal(t, ch, chres)
+
+	// Wait for add funds request to be sent
+	addFundsSent.Wait()
+
+	// Available funds should now include the channel and also a wait sentinel
+	// for the add funds message
+	av, err = mgr.AvailableFunds(ch)
+	require.NoError(t, err)
+	require.NotNil(t, av.Channel)
+	require.NotNil(t, av.PendingWaitSentinel)
+	// create amount is now confirmed
+	require.EqualValues(t, createAmt, av.ConfirmedAmt)
+	// add funds amount it now pending
+	require.EqualValues(t, addFundsAmt, av.PendingAmt)
+	require.EqualValues(t, 0, av.QueuedAmt.Int64())
+	require.EqualValues(t, 0, av.VoucherReedeemedAmt.Int64())
+
+	// Send success add funds response
+	mock.receiveMsgResponse(addFundsMcid, types.MessageReceipt{
+		ExitCode: 0,
+		Return:   []byte{},
+	})
+
+	// Wait for add funds response
+	_, err = mgr.GetPaychWaitReady(ctx, *av.PendingWaitSentinel)
+	require.NoError(t, err)
+
+	// Available funds should no longer have a wait sentinel
+	av, err = mgr.AvailableFunds(ch)
+	require.NoError(t, err)
+	require.NotNil(t, av.Channel)
+	require.Nil(t, av.PendingWaitSentinel)
+	// confirmed amount now includes create and add funds amounts
+	require.EqualValues(t, types.BigAdd(createAmt, addFundsAmt), av.ConfirmedAmt)
+	require.EqualValues(t, 0, av.PendingAmt.Int64())
+	require.EqualValues(t, 0, av.QueuedAmt.Int64())
+	require.EqualValues(t, 0, av.VoucherReedeemedAmt.Int64())
+
+	// Add some vouchers
+	voucherAmt1 := types.NewInt(3)
+	voucher := createTestVoucher(t, ch, 1, 1, voucherAmt1, fromKeyPrivate)
+	_, err = mgr.AddVoucherOutbound(ctx, ch, voucher, nil, types.NewInt(0))
+	require.NoError(t, err)
+
+	voucherAmt2 := types.NewInt(2)
+	voucher = createTestVoucher(t, ch, 2, 1, voucherAmt2, fromKeyPrivate)
+	_, err = mgr.AddVoucherOutbound(ctx, ch, voucher, nil, types.NewInt(0))
+	require.NoError(t, err)
+
+	av, err = mgr.AvailableFunds(ch)
+	require.NoError(t, err)
+	require.NotNil(t, av.Channel)
+	require.Nil(t, av.PendingWaitSentinel)
+	require.EqualValues(t, types.BigAdd(createAmt, addFundsAmt), av.ConfirmedAmt)
+	require.EqualValues(t, 0, av.PendingAmt.Int64())
+	require.EqualValues(t, 0, av.QueuedAmt.Int64())
+	// voucher redeemed amount now includes vouchers
+	require.EqualValues(t, types.BigAdd(voucherAmt1, voucherAmt2), av.VoucherReedeemedAmt)
+}
+
+// waitForQueueSize waits for the funds request queue to be of the given size
+func waitForQueueSize(t *testing.T, mgr *Manager, from address.Address, to address.Address, size int) {
+	ca, err := mgr.accessorByFromTo(from, to)
+	require.NoError(t, err)
+
+	for {
+		if ca.queueSize() == size {
+			return
+		}
+
+		time.Sleep(time.Millisecond)
+	}
+}
diff --git a/paychmgr/settle_test.go b/paychmgr/settle_test.go
new file mode 100644
index 000000000..f17f961e2
--- /dev/null
+++ b/paychmgr/settle_test.go
@@ -0,0 +1,69 @@
+package paychmgr
+
+import (
+	"context"
+	"testing"
+
+	"github.com/ipfs/go-cid"
+
+	"github.com/filecoin-project/go-state-types/big"
+	tutils "github.com/filecoin-project/specs-actors/support/testing"
+	ds "github.com/ipfs/go-datastore"
+	ds_sync "github.com/ipfs/go-datastore/sync"
+	"github.com/stretchr/testify/require"
+)
+
+func TestPaychSettle(t *testing.T) {
+	ctx := context.Background()
+	store := NewStore(ds_sync.MutexWrap(ds.NewMapDatastore()))
+
+	expch := tutils.NewIDAddr(t, 100)
+	expch2 := tutils.NewIDAddr(t, 101)
+	from := tutils.NewIDAddr(t, 101)
+	to := tutils.NewIDAddr(t, 102)
+
+	mock := newMockManagerAPI()
+	defer mock.close()
+
+	mgr, err := newManager(store, mock)
+	require.NoError(t, err)
+
+	amt := big.NewInt(10)
+	_, mcid, err := mgr.GetPaych(ctx, from, to, amt)
+	require.NoError(t, err)
+
+	// Send channel create response
+	response := testChannelResponse(t, expch)
+	mock.receiveMsgResponse(mcid, response)
+
+	// Get the channel address
+	ch, err := mgr.GetPaychWaitReady(ctx, mcid)
+	require.NoError(t, err)
+	require.Equal(t, expch, ch)
+
+	// Settle the channel
+	_, err = mgr.Settle(ctx, ch)
+	require.NoError(t, err)
+
+	// Send another request for funds to the same from/to
+	// (should create a new channel because the previous channel
+	// is settling)
+	amt2 := big.NewInt(5)
+	_, mcid2, err := mgr.GetPaych(ctx, from, to, amt2)
+	require.NoError(t, err)
+	require.NotEqual(t, cid.Undef, mcid2)
+
+	// Send new channel create response
+	response2 := testChannelResponse(t, expch2)
+	mock.receiveMsgResponse(mcid2, response2)
+
+	// Make sure the new channel is different from the old channel
+	ch2, err := mgr.GetPaychWaitReady(ctx, mcid2)
+	require.NoError(t, err)
+	require.NotEqual(t, ch, ch2)
+
+	// There should now be two channels
+	cis, err := mgr.ListChannels()
+	require.NoError(t, err)
+	require.Len(t, cis, 2)
+}
diff --git a/paychmgr/settler/settler.go b/paychmgr/settler/settler.go
new file mode 100644
index 000000000..654ed66cc
--- /dev/null
+++ b/paychmgr/settler/settler.go
@@ -0,0 +1,131 @@
+package settler
+
+import (
+	"context"
+	"sync"
+
+	"github.com/filecoin-project/lotus/paychmgr"
+
+	"go.uber.org/fx"
+
+	"github.com/ipfs/go-cid"
+	logging "github.com/ipfs/go-log/v2"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/abi"
+
+	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
+	paych0 "github.com/filecoin-project/specs-actors/actors/builtin/paych"
+
+	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/events"
+	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/node/impl/full"
+	payapi "github.com/filecoin-project/lotus/node/impl/paych"
+)
+
+var log = logging.Logger("payment-channel-settler")
+
+// API are the dependencies need to run the payment channel settler
+type API struct {
+	fx.In
+
+	full.ChainAPI
+	full.StateAPI
+	payapi.PaychAPI
+}
+
+type settlerAPI interface {
+	PaychList(context.Context) ([]address.Address, error)
+	PaychStatus(context.Context, address.Address) (*api.PaychStatus, error)
+	PaychVoucherCheckSpendable(context.Context, address.Address, *paych0.SignedVoucher, []byte, []byte) (bool, error)
+	PaychVoucherList(context.Context, address.Address) ([]*paych0.SignedVoucher, error)
+	PaychVoucherSubmit(context.Context, address.Address, *paych0.SignedVoucher, []byte, []byte) (cid.Cid, error)
+	StateWaitMsg(ctx context.Context, cid cid.Cid, confidence uint64) (*api.MsgLookup, error)
+}
+
+type paymentChannelSettler struct {
+	ctx context.Context
+	api settlerAPI
+}
+
+// SettlePaymentChannels checks the chain for events related to payment channels settling and
+// submits any vouchers for inbound channels tracked for this node
+func SettlePaymentChannels(lc fx.Lifecycle, api API) error {
+	lc.Append(fx.Hook{
+		OnStart: func(ctx context.Context) error {
+			pcs := newPaymentChannelSettler(ctx, &api)
+			ev := events.NewEvents(ctx, &api)
+			return ev.Called(pcs.check, pcs.messageHandler, pcs.revertHandler, int(build.MessageConfidence+1), events.NoTimeout, pcs.matcher)
+		},
+	})
+	return nil
+}
+
+func newPaymentChannelSettler(ctx context.Context, api settlerAPI) *paymentChannelSettler {
+	return &paymentChannelSettler{
+		ctx: ctx,
+		api: api,
+	}
+}
+
+func (pcs *paymentChannelSettler) check(ts *types.TipSet) (done bool, more bool, err error) {
+	return false, true, nil
+}
+
+func (pcs *paymentChannelSettler) messageHandler(msg *types.Message, rec *types.MessageReceipt, ts *types.TipSet, curH abi.ChainEpoch) (more bool, err error) {
+	bestByLane, err := paychmgr.BestSpendableByLane(pcs.ctx, pcs.api, msg.To)
+	if err != nil {
+		return true, err
+	}
+	var wg sync.WaitGroup
+	wg.Add(len(bestByLane))
+	for _, voucher := range bestByLane {
+		submitMessageCID, err := pcs.api.PaychVoucherSubmit(pcs.ctx, msg.To, voucher, nil, nil)
+		if err != nil {
+			return true, err
+		}
+		go func(voucher *paych0.SignedVoucher, submitMessageCID cid.Cid) {
+			defer wg.Done()
+			msgLookup, err := pcs.api.StateWaitMsg(pcs.ctx, submitMessageCID, build.MessageConfidence)
+			if err != nil {
+				log.Errorf("submitting voucher: %s", err.Error())
+			}
+			if msgLookup.Receipt.ExitCode != 0 {
+				log.Errorf("failed submitting voucher: %+v", voucher)
+			}
+		}(voucher, submitMessageCID)
+	}
+	wg.Wait()
+	return true, nil
+}
+
+func (pcs *paymentChannelSettler) revertHandler(ctx context.Context, ts *types.TipSet) error {
+	return nil
+}
+
+func (pcs *paymentChannelSettler) matcher(msg *types.Message) (matchOnce bool, matched bool, err error) {
+	// Check if this is a settle payment channel message
+	if msg.Method != builtin0.MethodsPaych.Settle {
+		return false, false, nil
+	}
+	// Check if this payment channel is of concern to this node (i.e. tracked in payment channel store),
+	// and its inbound (i.e. we're getting vouchers that we may need to redeem)
+	trackedAddresses, err := pcs.api.PaychList(pcs.ctx)
+	if err != nil {
+		return false, false, err
+	}
+	for _, addr := range trackedAddresses {
+		if msg.To == addr {
+			status, err := pcs.api.PaychStatus(pcs.ctx, addr)
+			if err != nil {
+				return false, false, err
+			}
+			if status.Direction == api.PCHInbound {
+				return false, true, nil
+			}
+		}
+	}
+	return false, false, nil
+}
diff --git a/paychmgr/simple.go b/paychmgr/simple.go
new file mode 100644
index 000000000..d49ccafe6
--- /dev/null
+++ b/paychmgr/simple.go
@@ -0,0 +1,713 @@
+package paychmgr
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"sync"
+
+	"github.com/ipfs/go-cid"
+	"golang.org/x/sync/errgroup"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/big"
+	"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/api"
+	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/actors"
+	lotusinit "github.com/filecoin-project/lotus/chain/actors/builtin/init"
+	"github.com/filecoin-project/lotus/chain/types"
+)
+
+// paychFundsRes is the response to a create channel or add funds request
+type paychFundsRes struct {
+	channel address.Address
+	mcid    cid.Cid
+	err     error
+}
+
+// fundsReq is a request to create a channel or add funds to a channel
+type fundsReq struct {
+	ctx     context.Context
+	promise chan *paychFundsRes
+	amt     types.BigInt
+
+	lk sync.Mutex
+	// merge parent, if this req is part of a merge
+	merge *mergedFundsReq
+	// whether the req's context has been cancelled
+	active bool
+}
+
+func newFundsReq(ctx context.Context, amt types.BigInt) *fundsReq {
+	promise := make(chan *paychFundsRes)
+	return &fundsReq{
+		ctx:     ctx,
+		promise: promise,
+		amt:     amt,
+		active:  true,
+	}
+}
+
+// onComplete is called when the funds request has been executed
+func (r *fundsReq) onComplete(res *paychFundsRes) {
+	select {
+	case <-r.ctx.Done():
+	case r.promise <- res:
+	}
+}
+
+// cancel is called when the req's context is cancelled
+func (r *fundsReq) cancel() {
+	r.lk.Lock()
+
+	r.active = false
+	m := r.merge
+
+	r.lk.Unlock()
+
+	// If there's a merge parent, tell the merge parent to check if it has any
+	// active reqs left
+	if m != nil {
+		m.checkActive()
+	}
+}
+
+// isActive indicates whether the req's context has been cancelled
+func (r *fundsReq) isActive() bool {
+	r.lk.Lock()
+	defer r.lk.Unlock()
+
+	return r.active
+}
+
+// setMergeParent sets the merge that this req is part of
+func (r *fundsReq) setMergeParent(m *mergedFundsReq) {
+	r.lk.Lock()
+	defer r.lk.Unlock()
+
+	r.merge = m
+}
+
+// mergedFundsReq merges together multiple add funds requests that are queued
+// up, so that only one message is sent for all the requests (instead of one
+// message for each request)
+type mergedFundsReq struct {
+	ctx    context.Context
+	cancel context.CancelFunc
+	reqs   []*fundsReq
+}
+
+func newMergedFundsReq(reqs []*fundsReq) *mergedFundsReq {
+	ctx, cancel := context.WithCancel(context.Background())
+	m := &mergedFundsReq{
+		ctx:    ctx,
+		cancel: cancel,
+		reqs:   reqs,
+	}
+
+	for _, r := range m.reqs {
+		r.setMergeParent(m)
+	}
+
+	// If the requests were all cancelled while being added, cancel the context
+	// immediately
+	m.checkActive()
+
+	return m
+}
+
+// Called when a fundsReq is cancelled
+func (m *mergedFundsReq) checkActive() {
+	// Check if there are any active fundsReqs
+	for _, r := range m.reqs {
+		if r.isActive() {
+			return
+		}
+	}
+
+	// If all fundsReqs have been cancelled, cancel the context
+	m.cancel()
+}
+
+// onComplete is called when the queue has executed the mergeFundsReq.
+// Calls onComplete on each fundsReq in the mergeFundsReq.
+func (m *mergedFundsReq) onComplete(res *paychFundsRes) {
+	for _, r := range m.reqs {
+		if r.isActive() {
+			r.onComplete(res)
+		}
+	}
+}
+
+// sum is the sum of the amounts in all requests in the merge
+func (m *mergedFundsReq) sum() types.BigInt {
+	sum := types.NewInt(0)
+	for _, r := range m.reqs {
+		if r.isActive() {
+			sum = types.BigAdd(sum, r.amt)
+		}
+	}
+	return sum
+}
+
+// getPaych ensures that a channel exists between the from and to addresses,
+// and adds the given amount of funds.
+// If the channel does not exist a create channel message is sent and the
+// message CID is returned.
+// If the channel does exist an add funds message is sent and both the channel
+// address and message CID are returned.
+// If there is an in progress operation (create channel / add funds), getPaych
+// blocks until the previous operation completes, then returns both the channel
+// address and the CID of the new add funds message.
+// If an operation returns an error, subsequent waiting operations will still
+// be attempted.
+func (ca *channelAccessor) getPaych(ctx context.Context, amt types.BigInt) (address.Address, cid.Cid, error) {
+	// Add the request to add funds to a queue and wait for the result
+	freq := newFundsReq(ctx, amt)
+	ca.enqueue(freq)
+	select {
+	case res := <-freq.promise:
+		return res.channel, res.mcid, res.err
+	case <-ctx.Done():
+		freq.cancel()
+		return address.Undef, cid.Undef, ctx.Err()
+	}
+}
+
+// Queue up an add funds operation
+func (ca *channelAccessor) enqueue(task *fundsReq) {
+	ca.lk.Lock()
+	defer ca.lk.Unlock()
+
+	ca.fundsReqQueue = append(ca.fundsReqQueue, task)
+	go ca.processQueue("") // nolint: errcheck
+}
+
+// Run the operations in the queue
+func (ca *channelAccessor) processQueue(channelID string) (*api.ChannelAvailableFunds, error) {
+	ca.lk.Lock()
+	defer ca.lk.Unlock()
+
+	// Remove cancelled requests
+	ca.filterQueue()
+
+	// If there's nothing in the queue, bail out
+	if len(ca.fundsReqQueue) == 0 {
+		return ca.currentAvailableFunds(channelID, types.NewInt(0))
+	}
+
+	// Merge all pending requests into one.
+	// For example if there are pending requests for 3, 2, 4 then
+	// amt = 3 + 2 + 4 = 9
+	merged := newMergedFundsReq(ca.fundsReqQueue[:])
+	amt := merged.sum()
+	if amt.IsZero() {
+		// Note: The amount can be zero if requests are cancelled as we're
+		// building the mergedFundsReq
+		return ca.currentAvailableFunds(channelID, amt)
+	}
+
+	res := ca.processTask(merged.ctx, amt)
+
+	// If the task is waiting on an external event (eg something to appear on
+	// chain) it will return nil
+	if res == nil {
+		// Stop processing the fundsReqQueue and wait. When the event occurs it will
+		// call processQueue() again
+		return ca.currentAvailableFunds(channelID, amt)
+	}
+
+	// Finished processing so clear the queue
+	ca.fundsReqQueue = nil
+
+	// Call the task callback with its results
+	merged.onComplete(res)
+
+	return ca.currentAvailableFunds(channelID, types.NewInt(0))
+}
+
+// filterQueue filters cancelled requests out of the queue
+func (ca *channelAccessor) filterQueue() {
+	if len(ca.fundsReqQueue) == 0 {
+		return
+	}
+
+	// Remove cancelled requests
+	i := 0
+	for _, r := range ca.fundsReqQueue {
+		if r.isActive() {
+			ca.fundsReqQueue[i] = r
+			i++
+		}
+	}
+
+	// Allow GC of remaining slice elements
+	for rem := i; rem < len(ca.fundsReqQueue); rem++ {
+		ca.fundsReqQueue[i] = nil
+	}
+
+	// Resize slice
+	ca.fundsReqQueue = ca.fundsReqQueue[:i]
+}
+
+// queueSize is the size of the funds request queue (used by tests)
+func (ca *channelAccessor) queueSize() int {
+	ca.lk.Lock()
+	defer ca.lk.Unlock()
+
+	return len(ca.fundsReqQueue)
+}
+
+// msgWaitComplete is called when the message for a previous task is confirmed
+// or there is an error.
+func (ca *channelAccessor) msgWaitComplete(mcid cid.Cid, err error) {
+	ca.lk.Lock()
+	defer ca.lk.Unlock()
+
+	// Save the message result to the store
+	dserr := ca.store.SaveMessageResult(mcid, err)
+	if dserr != nil {
+		log.Errorf("saving message result: %s", dserr)
+	}
+
+	// Inform listeners that the message has completed
+	ca.msgListeners.fireMsgComplete(mcid, err)
+
+	// The queue may have been waiting for msg completion to proceed, so
+	// process the next queue item
+	if len(ca.fundsReqQueue) > 0 {
+		go ca.processQueue("") // nolint: errcheck
+	}
+}
+
+func (ca *channelAccessor) currentAvailableFunds(channelID string, queuedAmt types.BigInt) (*api.ChannelAvailableFunds, error) {
+	if len(channelID) == 0 {
+		return nil, nil
+	}
+
+	channelInfo, err := ca.store.ByChannelID(channelID)
+	if err != nil {
+		return nil, err
+	}
+
+	// The channel may have a pending create or add funds message
+	waitSentinel := channelInfo.CreateMsg
+	if waitSentinel == nil {
+		waitSentinel = channelInfo.AddFundsMsg
+	}
+
+	// Get the total amount redeemed by vouchers.
+	// This includes vouchers that have been submitted, and vouchers that are
+	// in the datastore but haven't yet been submitted.
+	totalRedeemed := types.NewInt(0)
+	if channelInfo.Channel != nil {
+		ch := *channelInfo.Channel
+		_, pchState, err := ca.sa.loadPaychActorState(ca.chctx, ch)
+		if err != nil {
+			return nil, err
+		}
+
+		laneStates, err := ca.laneState(ca.chctx, pchState, ch)
+		if err != nil {
+			return nil, err
+		}
+
+		for _, ls := range laneStates {
+			r, err := ls.Redeemed()
+			if err != nil {
+				return nil, err
+			}
+			totalRedeemed = types.BigAdd(totalRedeemed, r)
+		}
+	}
+
+	return &api.ChannelAvailableFunds{
+		Channel:             channelInfo.Channel,
+		From:                channelInfo.from(),
+		To:                  channelInfo.to(),
+		ConfirmedAmt:        channelInfo.Amount,
+		PendingAmt:          channelInfo.PendingAmount,
+		PendingWaitSentinel: waitSentinel,
+		QueuedAmt:           queuedAmt,
+		VoucherReedeemedAmt: totalRedeemed,
+	}, nil
+}
+
+// processTask checks the state of the channel and takes appropriate action
+// (see description of getPaych).
+// Note that processTask may be called repeatedly in the same state, and should
+// return nil if there is no state change to be made (eg when waiting for a
+// message to be confirmed on chain)
+func (ca *channelAccessor) processTask(ctx context.Context, amt types.BigInt) *paychFundsRes {
+	// Get the payment channel for the from/to addresses.
+	// Note: It's ok if we get ErrChannelNotTracked. It just means we need to
+	// create a channel.
+	channelInfo, err := ca.store.OutboundActiveByFromTo(ca.from, ca.to)
+	if err != nil && err != ErrChannelNotTracked {
+		return &paychFundsRes{err: err}
+	}
+
+	// If a channel has not yet been created, create one.
+	if channelInfo == nil {
+		mcid, err := ca.createPaych(ctx, amt)
+		if err != nil {
+			return &paychFundsRes{err: err}
+		}
+
+		return &paychFundsRes{mcid: mcid}
+	}
+
+	// If the create channel message has been sent but the channel hasn't
+	// been created on chain yet
+	if channelInfo.CreateMsg != nil {
+		// Wait for the channel to be created before trying again
+		return nil
+	}
+
+	// If an add funds message was sent to the chain but hasn't been confirmed
+	// on chain yet
+	if channelInfo.AddFundsMsg != nil {
+		// Wait for the add funds message to be confirmed before trying again
+		return nil
+	}
+
+	// We need to add more funds, so send an add funds message to
+	// cover the amount for this request
+	mcid, err := ca.addFunds(ctx, channelInfo, amt)
+	if err != nil {
+		return &paychFundsRes{err: err}
+	}
+	return &paychFundsRes{channel: *channelInfo.Channel, mcid: *mcid}
+}
+
+// createPaych sends a message to create the channel and returns the message cid
+func (ca *channelAccessor) createPaych(ctx context.Context, amt types.BigInt) (cid.Cid, error) {
+	params, aerr := actors.SerializeParams(&paych0.ConstructorParams{From: ca.from, To: ca.to})
+	if aerr != nil {
+		return cid.Undef, aerr
+	}
+
+	enc, aerr := actors.SerializeParams(&init0.ExecParams{
+		CodeCID:           builtin.PaymentChannelActorCodeID,
+		ConstructorParams: params,
+	})
+	if aerr != nil {
+		return cid.Undef, aerr
+	}
+
+	msg := &types.Message{
+		To:     lotusinit.Address,
+		From:   ca.from,
+		Value:  amt,
+		Method: builtin.MethodsInit.Exec,
+		Params: enc,
+	}
+
+	smsg, err := ca.api.MpoolPushMessage(ctx, msg, nil)
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("initializing paych actor: %w", err)
+	}
+	mcid := smsg.Cid()
+
+	// Create a new channel in the store
+	ci, err := ca.store.CreateChannel(ca.from, ca.to, mcid, amt)
+	if err != nil {
+		log.Errorf("creating channel: %s", err)
+		return cid.Undef, err
+	}
+
+	// Wait for the channel to be created on chain
+	go ca.waitForPaychCreateMsg(ci.ChannelID, mcid)
+
+	return mcid, nil
+}
+
+// waitForPaychCreateMsg waits for mcid to appear on chain and stores the robust address of the
+// created payment channel
+func (ca *channelAccessor) waitForPaychCreateMsg(channelID string, mcid cid.Cid) {
+	err := ca.waitPaychCreateMsg(channelID, mcid)
+	ca.msgWaitComplete(mcid, err)
+}
+
+func (ca *channelAccessor) waitPaychCreateMsg(channelID string, mcid cid.Cid) error {
+	mwait, err := ca.api.StateWaitMsg(ca.chctx, mcid, build.MessageConfidence)
+	if err != nil {
+		log.Errorf("wait msg: %w", err)
+		return err
+	}
+
+	// If channel creation failed
+	if mwait.Receipt.ExitCode != 0 {
+		ca.lk.Lock()
+		defer ca.lk.Unlock()
+
+		// Channel creation failed, so remove the channel from the datastore
+		dserr := ca.store.RemoveChannel(channelID)
+		if dserr != nil {
+			log.Errorf("failed to remove channel %s: %s", channelID, dserr)
+		}
+
+		err := xerrors.Errorf("payment channel creation failed (exit code %d)", mwait.Receipt.ExitCode)
+		log.Error(err)
+		return err
+	}
+
+	var decodedReturn init0.ExecReturn
+	err = decodedReturn.UnmarshalCBOR(bytes.NewReader(mwait.Receipt.Return))
+	if err != nil {
+		log.Error(err)
+		return err
+	}
+
+	ca.lk.Lock()
+	defer ca.lk.Unlock()
+
+	// Store robust address of channel
+	ca.mutateChannelInfo(channelID, func(channelInfo *ChannelInfo) {
+		channelInfo.Channel = &decodedReturn.RobustAddress
+		channelInfo.Amount = channelInfo.PendingAmount
+		channelInfo.PendingAmount = big.NewInt(0)
+		channelInfo.CreateMsg = nil
+	})
+
+	return nil
+}
+
+// addFunds sends a message to add funds to the channel and returns the message cid
+func (ca *channelAccessor) addFunds(ctx context.Context, channelInfo *ChannelInfo, amt types.BigInt) (*cid.Cid, error) {
+	msg := &types.Message{
+		To:     *channelInfo.Channel,
+		From:   channelInfo.Control,
+		Value:  amt,
+		Method: 0,
+	}
+
+	smsg, err := ca.api.MpoolPushMessage(ctx, msg, nil)
+	if err != nil {
+		return nil, err
+	}
+	mcid := smsg.Cid()
+
+	// Store the add funds message CID on the channel
+	ca.mutateChannelInfo(channelInfo.ChannelID, func(ci *ChannelInfo) {
+		ci.PendingAmount = amt
+		ci.AddFundsMsg = &mcid
+	})
+
+	// Store a reference from the message CID to the channel, so that we can
+	// look up the channel from the message CID
+	err = ca.store.SaveNewMessage(channelInfo.ChannelID, mcid)
+	if err != nil {
+		log.Errorf("saving add funds message CID %s: %s", mcid, err)
+	}
+
+	go ca.waitForAddFundsMsg(channelInfo.ChannelID, mcid)
+
+	return &mcid, nil
+}
+
+// waitForAddFundsMsg waits for mcid to appear on chain and returns error, if any
+func (ca *channelAccessor) waitForAddFundsMsg(channelID string, mcid cid.Cid) {
+	err := ca.waitAddFundsMsg(channelID, mcid)
+	ca.msgWaitComplete(mcid, err)
+}
+
+func (ca *channelAccessor) waitAddFundsMsg(channelID string, mcid cid.Cid) error {
+	mwait, err := ca.api.StateWaitMsg(ca.chctx, mcid, build.MessageConfidence)
+	if err != nil {
+		log.Error(err)
+		return err
+	}
+
+	if mwait.Receipt.ExitCode != 0 {
+		err := xerrors.Errorf("voucher channel creation failed: adding funds (exit code %d)", mwait.Receipt.ExitCode)
+		log.Error(err)
+
+		ca.lk.Lock()
+		defer ca.lk.Unlock()
+
+		ca.mutateChannelInfo(channelID, func(channelInfo *ChannelInfo) {
+			channelInfo.PendingAmount = big.NewInt(0)
+			channelInfo.AddFundsMsg = nil
+		})
+
+		return err
+	}
+
+	ca.lk.Lock()
+	defer ca.lk.Unlock()
+
+	// Store updated amount
+	ca.mutateChannelInfo(channelID, func(channelInfo *ChannelInfo) {
+		channelInfo.Amount = types.BigAdd(channelInfo.Amount, channelInfo.PendingAmount)
+		channelInfo.PendingAmount = big.NewInt(0)
+		channelInfo.AddFundsMsg = nil
+	})
+
+	return nil
+}
+
+// Change the state of the channel in the store
+func (ca *channelAccessor) mutateChannelInfo(channelID string, mutate func(*ChannelInfo)) {
+	channelInfo, err := ca.store.ByChannelID(channelID)
+
+	// If there's an error reading or writing to the store just log an error.
+	// For now we're assuming it's unlikely to happen in practice.
+	// Later we may want to implement a transactional approach, whereby
+	// we record to the store that we're going to send a message, send
+	// the message, and then record that the message was sent.
+	if err != nil {
+		log.Errorf("Error reading channel info from store: %s", err)
+		return
+	}
+
+	mutate(channelInfo)
+
+	err = ca.store.putChannelInfo(channelInfo)
+	if err != nil {
+		log.Errorf("Error writing channel info to store: %s", err)
+	}
+}
+
+// restartPending checks the datastore to see if there are any channels that
+// have outstanding create / add funds messages, and if so, waits on the
+// messages.
+// Outstanding messages can occur if a create / add funds message was sent and
+// then the system was shut down or crashed before the result was received.
+func (pm *Manager) restartPending() error {
+	cis, err := pm.store.WithPendingAddFunds()
+	if err != nil {
+		return err
+	}
+
+	group := errgroup.Group{}
+	for _, chanInfo := range cis {
+		ci := chanInfo
+		if ci.CreateMsg != nil {
+			group.Go(func() error {
+				ca, err := pm.accessorByFromTo(ci.Control, ci.Target)
+				if err != nil {
+					return xerrors.Errorf("error initializing payment channel manager %s -> %s: %s", ci.Control, ci.Target, err)
+				}
+				go ca.waitForPaychCreateMsg(ci.ChannelID, *ci.CreateMsg)
+				return nil
+			})
+		} else if ci.AddFundsMsg != nil {
+			group.Go(func() error {
+				ca, err := pm.accessorByAddress(*ci.Channel)
+				if err != nil {
+					return xerrors.Errorf("error initializing payment channel manager %s: %s", ci.Channel, err)
+				}
+				go ca.waitForAddFundsMsg(ci.ChannelID, *ci.AddFundsMsg)
+				return nil
+			})
+		}
+	}
+
+	return group.Wait()
+}
+
+// getPaychWaitReady waits for a the response to the message with the given cid
+func (ca *channelAccessor) getPaychWaitReady(ctx context.Context, mcid cid.Cid) (address.Address, error) {
+	ca.lk.Lock()
+
+	// First check if the message has completed
+	msgInfo, err := ca.store.GetMessage(mcid)
+	if err != nil {
+		ca.lk.Unlock()
+
+		return address.Undef, err
+	}
+
+	// If the create channel / add funds message failed, return an error
+	if len(msgInfo.Err) > 0 {
+		ca.lk.Unlock()
+
+		return address.Undef, xerrors.New(msgInfo.Err)
+	}
+
+	// If the message has completed successfully
+	if msgInfo.Received {
+		ca.lk.Unlock()
+
+		// Get the channel address
+		ci, err := ca.store.ByMessageCid(mcid)
+		if err != nil {
+			return address.Undef, err
+		}
+
+		if ci.Channel == nil {
+			panic(fmt.Sprintf("create / add funds message %s succeeded but channelInfo.Channel is nil", mcid))
+		}
+		return *ci.Channel, nil
+	}
+
+	// The message hasn't completed yet so wait for it to complete
+	promise := ca.msgPromise(ctx, mcid)
+
+	// Unlock while waiting
+	ca.lk.Unlock()
+
+	select {
+	case res := <-promise:
+		return res.channel, res.err
+	case <-ctx.Done():
+		return address.Undef, ctx.Err()
+	}
+}
+
+type onMsgRes struct {
+	channel address.Address
+	err     error
+}
+
+// msgPromise returns a channel that receives the result of the message with
+// the given CID
+func (ca *channelAccessor) msgPromise(ctx context.Context, mcid cid.Cid) chan onMsgRes {
+	promise := make(chan onMsgRes)
+	triggerUnsub := make(chan struct{})
+	unsub := ca.msgListeners.onMsgComplete(mcid, func(err error) {
+		close(triggerUnsub)
+
+		// Use a go-routine so as not to block the event handler loop
+		go func() {
+			res := onMsgRes{err: err}
+			if res.err == nil {
+				// Get the channel associated with the message cid
+				ci, err := ca.store.ByMessageCid(mcid)
+				if err != nil {
+					res.err = err
+				} else {
+					res.channel = *ci.Channel
+				}
+			}
+
+			// Pass the result to the caller
+			select {
+			case promise <- res:
+			case <-ctx.Done():
+			}
+		}()
+	})
+
+	// Unsubscribe when the message is received or the context is done
+	go func() {
+		select {
+		case <-ctx.Done():
+		case <-triggerUnsub:
+		}
+
+		unsub()
+	}()
+
+	return promise
+}
+
+func (ca *channelAccessor) availableFunds(channelID string) (*api.ChannelAvailableFunds, error) {
+	return ca.processQueue(channelID)
+}
diff --git a/paychmgr/state.go b/paychmgr/state.go
new file mode 100644
index 000000000..65963d2a0
--- /dev/null
+++ b/paychmgr/state.go
@@ -0,0 +1,86 @@
+package paychmgr
+
+import (
+	"context"
+
+	"github.com/filecoin-project/go-address"
+
+	"github.com/filecoin-project/lotus/chain/actors/builtin/paych"
+	"github.com/filecoin-project/lotus/chain/types"
+)
+
+type stateAccessor struct {
+	sm stateManagerAPI
+}
+
+func (ca *stateAccessor) loadPaychActorState(ctx context.Context, ch address.Address) (*types.Actor, paych.State, error) {
+	return ca.sm.GetPaychState(ctx, ch, nil)
+}
+
+func (ca *stateAccessor) loadStateChannelInfo(ctx context.Context, ch address.Address, dir uint64) (*ChannelInfo, error) {
+	_, st, err := ca.loadPaychActorState(ctx, ch)
+	if err != nil {
+		return nil, err
+	}
+
+	// Load channel "From" account actor state
+	f, err := st.From()
+	if err != nil {
+		return nil, err
+	}
+	from, err := ca.sm.ResolveToKeyAddress(ctx, f, nil)
+	if err != nil {
+		return nil, err
+	}
+	t, err := st.To()
+	if err != nil {
+		return nil, err
+	}
+	to, err := ca.sm.ResolveToKeyAddress(ctx, t, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	nextLane, err := ca.nextLaneFromState(ctx, st)
+	if err != nil {
+		return nil, err
+	}
+
+	ci := &ChannelInfo{
+		Channel:   &ch,
+		Direction: dir,
+		NextLane:  nextLane,
+	}
+
+	if dir == DirOutbound {
+		ci.Control = from
+		ci.Target = to
+	} else {
+		ci.Control = to
+		ci.Target = from
+	}
+
+	return ci, nil
+}
+
+func (ca *stateAccessor) nextLaneFromState(ctx context.Context, st paych.State) (uint64, error) {
+	laneCount, err := st.LaneCount()
+	if err != nil {
+		return 0, err
+	}
+	if laneCount == 0 {
+		return 0, nil
+	}
+
+	maxID := uint64(0)
+	if err := st.ForEachLaneState(func(idx uint64, _ paych.LaneState) error {
+		if idx > maxID {
+			maxID = idx
+		}
+		return nil
+	}); err != nil {
+		return 0, err
+	}
+
+	return maxID + 1, nil
+}
diff --git a/paychmgr/store.go b/paychmgr/store.go
new file mode 100644
index 000000000..23916669e
--- /dev/null
+++ b/paychmgr/store.go
@@ -0,0 +1,504 @@
+package paychmgr
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+
+	"golang.org/x/xerrors"
+
+	"github.com/google/uuid"
+
+	"github.com/filecoin-project/lotus/chain/types"
+
+	cborutil "github.com/filecoin-project/go-cbor-util"
+	"github.com/ipfs/go-cid"
+	"github.com/ipfs/go-datastore"
+	"github.com/ipfs/go-datastore/namespace"
+	dsq "github.com/ipfs/go-datastore/query"
+
+	paych0 "github.com/filecoin-project/specs-actors/actors/builtin/paych"
+
+	"github.com/filecoin-project/go-address"
+	cborrpc "github.com/filecoin-project/go-cbor-util"
+
+	"github.com/filecoin-project/lotus/node/modules/dtypes"
+)
+
+var ErrChannelNotTracked = errors.New("channel not tracked")
+
+type Store struct {
+	ds datastore.Batching
+}
+
+func NewStore(ds dtypes.MetadataDS) *Store {
+	ds = namespace.Wrap(ds, datastore.NewKey("/paych/"))
+	return &Store{
+		ds: ds,
+	}
+}
+
+const (
+	DirInbound  = 1
+	DirOutbound = 2
+)
+
+const (
+	dsKeyChannelInfo = "ChannelInfo"
+	dsKeyMsgCid      = "MsgCid"
+)
+
+type VoucherInfo struct {
+	Voucher   *paych0.SignedVoucher
+	Proof     []byte
+	Submitted bool
+}
+
+// ChannelInfo keeps track of information about a channel
+type ChannelInfo struct {
+	// ChannelID is a uuid set at channel creation
+	ChannelID string
+	// Channel address - may be nil if the channel hasn't been created yet
+	Channel *address.Address
+	// Control is the address of the local node
+	Control address.Address
+	// Target is the address of the remote node (on the other end of the channel)
+	Target address.Address
+	// Direction indicates if the channel is inbound (Control is the "to" address)
+	// or outbound (Control is the "from" address)
+	Direction uint64
+	// Vouchers is a list of all vouchers sent on the channel
+	Vouchers []*VoucherInfo
+	// NextLane is the number of the next lane that should be used when the
+	// client requests a new lane (eg to create a voucher for a new deal)
+	NextLane uint64
+	// Amount added to the channel.
+	// Note: This amount is only used by GetPaych to keep track of how much
+	// has locally been added to the channel. It should reflect the channel's
+	// Balance on chain as long as all operations occur on the same datastore.
+	Amount types.BigInt
+	// PendingAmount is the amount that we're awaiting confirmation of
+	PendingAmount types.BigInt
+	// CreateMsg is the CID of a pending create message (while waiting for confirmation)
+	CreateMsg *cid.Cid
+	// AddFundsMsg is the CID of a pending add funds message (while waiting for confirmation)
+	AddFundsMsg *cid.Cid
+	// Settling indicates whether the channel has entered into the settling state
+	Settling bool
+}
+
+func (ci *ChannelInfo) from() address.Address {
+	if ci.Direction == DirOutbound {
+		return ci.Control
+	}
+	return ci.Target
+}
+
+func (ci *ChannelInfo) to() address.Address {
+	if ci.Direction == DirOutbound {
+		return ci.Target
+	}
+	return ci.Control
+}
+
+// infoForVoucher gets the VoucherInfo for the given voucher.
+// returns nil if the channel doesn't have the voucher.
+func (ci *ChannelInfo) infoForVoucher(sv *paych0.SignedVoucher) (*VoucherInfo, error) {
+	for _, v := range ci.Vouchers {
+		eq, err := cborutil.Equals(sv, v.Voucher)
+		if err != nil {
+			return nil, err
+		}
+		if eq {
+			return v, nil
+		}
+	}
+	return nil, nil
+}
+
+func (ci *ChannelInfo) hasVoucher(sv *paych0.SignedVoucher) (bool, error) {
+	vi, err := ci.infoForVoucher(sv)
+	return vi != nil, err
+}
+
+// markVoucherSubmitted marks the voucher, and any vouchers of lower nonce
+// in the same lane, as being submitted.
+// Note: This method doesn't write anything to the store.
+func (ci *ChannelInfo) markVoucherSubmitted(sv *paych0.SignedVoucher) error {
+	vi, err := ci.infoForVoucher(sv)
+	if err != nil {
+		return err
+	}
+	if vi == nil {
+		return xerrors.Errorf("cannot submit voucher that has not been added to channel")
+	}
+
+	// Mark the voucher as submitted
+	vi.Submitted = true
+
+	// Mark lower-nonce vouchers in the same lane as submitted (lower-nonce
+	// vouchers are superseded by the submitted voucher)
+	for _, vi := range ci.Vouchers {
+		if vi.Voucher.Lane == sv.Lane && vi.Voucher.Nonce < sv.Nonce {
+			vi.Submitted = true
+		}
+	}
+
+	return nil
+}
+
+// wasVoucherSubmitted returns true if the voucher has been submitted
+func (ci *ChannelInfo) wasVoucherSubmitted(sv *paych0.SignedVoucher) (bool, error) {
+	vi, err := ci.infoForVoucher(sv)
+	if err != nil {
+		return false, err
+	}
+	if vi == nil {
+		return false, xerrors.Errorf("cannot submit voucher that has not been added to channel")
+	}
+	return vi.Submitted, nil
+}
+
+// TrackChannel stores a channel, returning an error if the channel was already
+// being tracked
+func (ps *Store) TrackChannel(ci *ChannelInfo) (*ChannelInfo, error) {
+	_, err := ps.ByAddress(*ci.Channel)
+	switch err {
+	default:
+		return nil, err
+	case nil:
+		return nil, fmt.Errorf("already tracking channel: %s", ci.Channel)
+	case ErrChannelNotTracked:
+		err = ps.putChannelInfo(ci)
+		if err != nil {
+			return nil, err
+		}
+
+		return ps.ByAddress(*ci.Channel)
+	}
+}
+
+// ListChannels returns the addresses of all channels that have been created
+func (ps *Store) ListChannels() ([]address.Address, error) {
+	cis, err := ps.findChans(func(ci *ChannelInfo) bool {
+		return ci.Channel != nil
+	}, 0)
+	if err != nil {
+		return nil, err
+	}
+
+	addrs := make([]address.Address, 0, len(cis))
+	for _, ci := range cis {
+		addrs = append(addrs, *ci.Channel)
+	}
+
+	return addrs, nil
+}
+
+// findChan finds a single channel using the given filter.
+// If there isn't a channel that matches the filter, returns ErrChannelNotTracked
+func (ps *Store) findChan(filter func(ci *ChannelInfo) bool) (*ChannelInfo, error) {
+	cis, err := ps.findChans(filter, 1)
+	if err != nil {
+		return nil, err
+	}
+
+	if len(cis) == 0 {
+		return nil, ErrChannelNotTracked
+	}
+
+	return &cis[0], err
+}
+
+// findChans loops over all channels, only including those that pass the filter.
+// max is the maximum number of channels to return. Set to zero to return unlimited channels.
+func (ps *Store) findChans(filter func(*ChannelInfo) bool, max int) ([]ChannelInfo, error) {
+	res, err := ps.ds.Query(dsq.Query{Prefix: dsKeyChannelInfo})
+	if err != nil {
+		return nil, err
+	}
+	defer res.Close() //nolint:errcheck
+
+	var stored ChannelInfo
+	var matches []ChannelInfo
+
+	for {
+		res, ok := res.NextSync()
+		if !ok {
+			break
+		}
+
+		if res.Error != nil {
+			return nil, err
+		}
+
+		ci, err := unmarshallChannelInfo(&stored, res.Value)
+		if err != nil {
+			return nil, err
+		}
+
+		if !filter(ci) {
+			continue
+		}
+
+		matches = append(matches, *ci)
+
+		// If we've reached the maximum number of matches, return.
+		// Note that if max is zero we return an unlimited number of matches
+		// because len(matches) will always be at least 1.
+		if len(matches) == max {
+			return matches, nil
+		}
+	}
+
+	return matches, nil
+}
+
+// AllocateLane allocates a new lane for the given channel
+func (ps *Store) AllocateLane(ch address.Address) (uint64, error) {
+	ci, err := ps.ByAddress(ch)
+	if err != nil {
+		return 0, err
+	}
+
+	out := ci.NextLane
+	ci.NextLane++
+
+	return out, ps.putChannelInfo(ci)
+}
+
+// VouchersForPaych gets the vouchers for the given channel
+func (ps *Store) VouchersForPaych(ch address.Address) ([]*VoucherInfo, error) {
+	ci, err := ps.ByAddress(ch)
+	if err != nil {
+		return nil, err
+	}
+
+	return ci.Vouchers, nil
+}
+
+func (ps *Store) MarkVoucherSubmitted(ci *ChannelInfo, sv *paych0.SignedVoucher) error {
+	err := ci.markVoucherSubmitted(sv)
+	if err != nil {
+		return err
+	}
+	return ps.putChannelInfo(ci)
+}
+
+// ByAddress gets the channel that matches the given address
+func (ps *Store) ByAddress(addr address.Address) (*ChannelInfo, error) {
+	return ps.findChan(func(ci *ChannelInfo) bool {
+		return ci.Channel != nil && *ci.Channel == addr
+	})
+}
+
+// MsgInfo stores information about a create channel / add funds message
+// that has been sent
+type MsgInfo struct {
+	// ChannelID links the message to a channel
+	ChannelID string
+	// MsgCid is the CID of the message
+	MsgCid cid.Cid
+	// Received indicates whether a response has been received
+	Received bool
+	// Err is the error received in the response
+	Err string
+}
+
+// The datastore key used to identify the message
+func dskeyForMsg(mcid cid.Cid) datastore.Key {
+	return datastore.KeyWithNamespaces([]string{dsKeyMsgCid, mcid.String()})
+}
+
+// SaveNewMessage is called when a message is sent
+func (ps *Store) SaveNewMessage(channelID string, mcid cid.Cid) error {
+	k := dskeyForMsg(mcid)
+
+	b, err := cborrpc.Dump(&MsgInfo{ChannelID: channelID, MsgCid: mcid})
+	if err != nil {
+		return err
+	}
+
+	return ps.ds.Put(k, b)
+}
+
+// SaveMessageResult is called when the result of a message is received
+func (ps *Store) SaveMessageResult(mcid cid.Cid, msgErr error) error {
+	minfo, err := ps.GetMessage(mcid)
+	if err != nil {
+		return err
+	}
+
+	k := dskeyForMsg(mcid)
+	minfo.Received = true
+	if msgErr != nil {
+		minfo.Err = msgErr.Error()
+	}
+
+	b, err := cborrpc.Dump(minfo)
+	if err != nil {
+		return err
+	}
+
+	return ps.ds.Put(k, b)
+}
+
+// ByMessageCid gets the channel associated with a message
+func (ps *Store) ByMessageCid(mcid cid.Cid) (*ChannelInfo, error) {
+	minfo, err := ps.GetMessage(mcid)
+	if err != nil {
+		return nil, err
+	}
+
+	ci, err := ps.findChan(func(ci *ChannelInfo) bool {
+		return ci.ChannelID == minfo.ChannelID
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	return ci, err
+}
+
+// GetMessage gets the message info for a given message CID
+func (ps *Store) GetMessage(mcid cid.Cid) (*MsgInfo, error) {
+	k := dskeyForMsg(mcid)
+
+	val, err := ps.ds.Get(k)
+	if err != nil {
+		return nil, err
+	}
+
+	var minfo MsgInfo
+	if err := minfo.UnmarshalCBOR(bytes.NewReader(val)); err != nil {
+		return nil, err
+	}
+
+	return &minfo, nil
+}
+
+// OutboundActiveByFromTo looks for outbound channels that have not been
+// settled, with the given from / to addresses
+func (ps *Store) OutboundActiveByFromTo(from address.Address, to address.Address) (*ChannelInfo, error) {
+	return ps.findChan(func(ci *ChannelInfo) bool {
+		if ci.Direction != DirOutbound {
+			return false
+		}
+		if ci.Settling {
+			return false
+		}
+		return ci.Control == from && ci.Target == to
+	})
+}
+
+// WithPendingAddFunds is used on startup to find channels for which a
+// create channel or add funds message has been sent, but lotus shut down
+// before the response was received.
+func (ps *Store) WithPendingAddFunds() ([]ChannelInfo, error) {
+	return ps.findChans(func(ci *ChannelInfo) bool {
+		if ci.Direction != DirOutbound {
+			return false
+		}
+		return ci.CreateMsg != nil || ci.AddFundsMsg != nil
+	}, 0)
+}
+
+// ByChannelID gets channel info by channel ID
+func (ps *Store) ByChannelID(channelID string) (*ChannelInfo, error) {
+	var stored ChannelInfo
+
+	res, err := ps.ds.Get(dskeyForChannel(channelID))
+	if err != nil {
+		if err == datastore.ErrNotFound {
+			return nil, ErrChannelNotTracked
+		}
+		return nil, err
+	}
+
+	return unmarshallChannelInfo(&stored, res)
+}
+
+// CreateChannel creates an outbound channel for the given from / to
+func (ps *Store) CreateChannel(from address.Address, to address.Address, createMsgCid cid.Cid, amt types.BigInt) (*ChannelInfo, error) {
+	ci := &ChannelInfo{
+		Direction:     DirOutbound,
+		NextLane:      0,
+		Control:       from,
+		Target:        to,
+		CreateMsg:     &createMsgCid,
+		PendingAmount: amt,
+	}
+
+	// Save the new channel
+	err := ps.putChannelInfo(ci)
+	if err != nil {
+		return nil, err
+	}
+
+	// Save a reference to the create message
+	err = ps.SaveNewMessage(ci.ChannelID, createMsgCid)
+	if err != nil {
+		return nil, err
+	}
+
+	return ci, err
+}
+
+// RemoveChannel removes the channel with the given channel ID
+func (ps *Store) RemoveChannel(channelID string) error {
+	return ps.ds.Delete(dskeyForChannel(channelID))
+}
+
+// The datastore key used to identify the channel info
+func dskeyForChannel(channelID string) datastore.Key {
+	return datastore.KeyWithNamespaces([]string{dsKeyChannelInfo, channelID})
+}
+
+// putChannelInfo stores the channel info in the datastore
+func (ps *Store) putChannelInfo(ci *ChannelInfo) error {
+	if len(ci.ChannelID) == 0 {
+		ci.ChannelID = uuid.New().String()
+	}
+	k := dskeyForChannel(ci.ChannelID)
+
+	b, err := marshallChannelInfo(ci)
+	if err != nil {
+		return err
+	}
+
+	return ps.ds.Put(k, b)
+}
+
+// TODO: This is a hack to get around not being able to CBOR marshall a nil
+// address.Address. It's been fixed in address.Address but we need to wait
+// for the change to propagate to specs-actors before we can remove this hack.
+var emptyAddr address.Address
+
+func init() {
+	addr, err := address.NewActorAddress([]byte("empty"))
+	if err != nil {
+		panic(err)
+	}
+	emptyAddr = addr
+}
+
+func marshallChannelInfo(ci *ChannelInfo) ([]byte, error) {
+	// See note above about CBOR marshalling address.Address
+	if ci.Channel == nil {
+		ci.Channel = &emptyAddr
+	}
+	return cborrpc.Dump(ci)
+}
+
+func unmarshallChannelInfo(stored *ChannelInfo, value []byte) (*ChannelInfo, error) {
+	if err := stored.UnmarshalCBOR(bytes.NewReader(value)); err != nil {
+		return nil, err
+	}
+
+	// See note above about CBOR marshalling address.Address
+	if stored.Channel != nil && *stored.Channel == emptyAddr {
+		stored.Channel = nil
+	}
+
+	return stored, nil
+}
diff --git a/paychmgr/store_test.go b/paychmgr/store_test.go
new file mode 100644
index 000000000..36ff7a5b0
--- /dev/null
+++ b/paychmgr/store_test.go
@@ -0,0 +1,89 @@
+package paychmgr
+
+import (
+	"testing"
+
+	"github.com/filecoin-project/go-address"
+
+	tutils "github.com/filecoin-project/specs-actors/support/testing"
+	ds "github.com/ipfs/go-datastore"
+	ds_sync "github.com/ipfs/go-datastore/sync"
+	"github.com/stretchr/testify/require"
+)
+
+func TestStore(t *testing.T) {
+	store := NewStore(ds_sync.MutexWrap(ds.NewMapDatastore()))
+	addrs, err := store.ListChannels()
+	require.NoError(t, err)
+	require.Len(t, addrs, 0)
+
+	ch := tutils.NewIDAddr(t, 100)
+	ci := &ChannelInfo{
+		Channel: &ch,
+		Control: tutils.NewIDAddr(t, 101),
+		Target:  tutils.NewIDAddr(t, 102),
+
+		Direction: DirOutbound,
+		Vouchers:  []*VoucherInfo{{Voucher: nil, Proof: []byte{}}},
+	}
+
+	ch2 := tutils.NewIDAddr(t, 200)
+	ci2 := &ChannelInfo{
+		Channel: &ch2,
+		Control: tutils.NewIDAddr(t, 201),
+		Target:  tutils.NewIDAddr(t, 202),
+
+		Direction: DirOutbound,
+		Vouchers:  []*VoucherInfo{{Voucher: nil, Proof: []byte{}}},
+	}
+
+	// Track the channel
+	_, err = store.TrackChannel(ci)
+	require.NoError(t, err)
+
+	// Tracking same channel again should error
+	_, err = store.TrackChannel(ci)
+	require.Error(t, err)
+
+	// Track another channel
+	_, err = store.TrackChannel(ci2)
+	require.NoError(t, err)
+
+	// List channels should include all channels
+	addrs, err = store.ListChannels()
+	require.NoError(t, err)
+	require.Len(t, addrs, 2)
+	require.Contains(t, addrsStrings(addrs), "t0100")
+	require.Contains(t, addrsStrings(addrs), "t0200")
+
+	// Request vouchers for channel
+	vouchers, err := store.VouchersForPaych(*ci.Channel)
+	require.NoError(t, err)
+	require.Len(t, vouchers, 1)
+
+	// Requesting voucher for non-existent channel should error
+	_, err = store.VouchersForPaych(tutils.NewIDAddr(t, 300))
+	require.Equal(t, err, ErrChannelNotTracked)
+
+	// Allocate lane for channel
+	lane, err := store.AllocateLane(*ci.Channel)
+	require.NoError(t, err)
+	require.Equal(t, lane, uint64(0))
+
+	// Allocate next lane for channel
+	lane, err = store.AllocateLane(*ci.Channel)
+	require.NoError(t, err)
+	require.Equal(t, lane, uint64(1))
+
+	// Allocate next lane for non-existent channel should error
+	_, err = store.AllocateLane(tutils.NewIDAddr(t, 300))
+	require.Equal(t, err, ErrChannelNotTracked)
+}
+
+func addrsStrings(addrs []address.Address) []string {
+	str := make([]string, len(addrs))
+	for i, a := range addrs {
+		str[i] = a.String()
+	}
+	return str
+}
diff --git a/paychmgr/util.go b/paychmgr/util.go
new file mode 100644
index 000000000..2a8181c15
--- /dev/null
+++ b/paychmgr/util.go
@@ -0,0 +1,35 @@
+package paychmgr
+
+import (
+	"context"
+
+	"github.com/filecoin-project/go-address"
+
+	paych0 "github.com/filecoin-project/specs-actors/actors/builtin/paych"
+)
+
+type BestSpendableAPI interface {
+	PaychVoucherList(context.Context, address.Address) ([]*paych0.SignedVoucher, error)
+	PaychVoucherCheckSpendable(context.Context, address.Address, *paych0.SignedVoucher, []byte, []byte) (bool, error)
+}
+
+func BestSpendableByLane(ctx context.Context, api BestSpendableAPI, ch address.Address) (map[uint64]*paych0.SignedVoucher, error) {
+	vouchers, err := api.PaychVoucherList(ctx, ch)
+	if err != nil {
+		return nil, err
+	}
+
+	bestByLane := make(map[uint64]*paych0.SignedVoucher)
+	for _, voucher := range vouchers {
+		spendable, err := api.PaychVoucherCheckSpendable(ctx, ch, voucher, nil, nil)
+		if err != nil {
+			return nil, err
+		}
+		if spendable {
+			if bestByLane[voucher.Lane] == nil || voucher.Amount.GreaterThan(bestByLane[voucher.Lane].Amount) {
+				bestByLane[voucher.Lane] = voucher
+			}
+		}
+	}
+	return bestByLane, nil
+}
diff --git a/retrieval/cbor_gen.go b/retrieval/cbor_gen.go
deleted file mode 100644
index c80ab66d6..000000000
--- a/retrieval/cbor_gen.go
+++ /dev/null
@@ -1,476 +0,0 @@
-package retrieval
-
-import (
-	"fmt"
-	"io"
-
-	cbg "github.com/whyrusleeping/cbor-gen"
-	xerrors "golang.org/x/xerrors"
-)
-
-// Code generated by github.com/whyrusleeping/cbor-gen. DO NOT EDIT.
-
-var _ = xerrors.Errorf
-
-func (t *RetParams) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{129}); err != nil {
-		return err
-	}
-
-	// t.Unixfs0 (retrieval.Unixfs0Offer) (struct)
-	if err := t.Unixfs0.MarshalCBOR(w); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *RetParams) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 1 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	// t.Unixfs0 (retrieval.Unixfs0Offer) (struct)
-
-	{
-
-		pb, err := br.PeekByte()
-		if err != nil {
-			return err
-		}
-		if pb == cbg.CborNull[0] {
-			var nbuf [1]byte
-			if _, err := br.Read(nbuf[:]); err != nil {
-				return err
-			}
-		} else {
-			t.Unixfs0 = new(Unixfs0Offer)
-			if err := t.Unixfs0.UnmarshalCBOR(br); err != nil {
-				return err
-			}
-		}
-
-	}
-	return nil
-}
-
-func (t *Query) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{129}); err != nil {
-		return err
-	}
-
-	// t.Piece (cid.Cid) (struct)
-
-	if err := cbg.WriteCid(w, t.Piece); err != nil {
-		return xerrors.Errorf("failed to write cid field t.Piece: %w", err)
-	}
-
-	return nil
-}
-
-func (t *Query) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 1 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	// t.Piece (cid.Cid) (struct)
-
-	{
-
-		c, err := cbg.ReadCid(br)
-		if err != nil {
-			return xerrors.Errorf("failed to read cid field t.Piece: %w", err)
-		}
-
-		t.Piece = c
-
-	}
-	return nil
-}
-
-func (t *QueryResponse) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{131}); err != nil {
-		return err
-	}
-
-	// t.Status (retrieval.QueryResponseStatus) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.Status))); err != nil {
-		return err
-	}
-
-	// t.Size (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.Size))); err != nil {
-		return err
-	}
-
-	// t.MinPrice (types.BigInt) (struct)
-	if err := t.MinPrice.MarshalCBOR(w); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *QueryResponse) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 3 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	// t.Status (retrieval.QueryResponseStatus) (uint64)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.Status = QueryResponseStatus(extra)
-	// t.Size (uint64) (uint64)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.Size = uint64(extra)
-	// t.MinPrice (types.BigInt) (struct)
-
-	{
-
-		if err := t.MinPrice.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-	}
-	return nil
-}
-
-func (t *Unixfs0Offer) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{130}); err != nil {
-		return err
-	}
-
-	// t.Offset (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.Offset))); err != nil {
-		return err
-	}
-
-	// t.Size (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.Size))); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *Unixfs0Offer) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 2 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	// t.Offset (uint64) (uint64)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.Offset = uint64(extra)
-	// t.Size (uint64) (uint64)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.Size = uint64(extra)
-	return nil
-}
-
-func (t *DealProposal) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{131}); err != nil {
-		return err
-	}
-
-	// t.Payment (api.PaymentInfo) (struct)
-	if err := t.Payment.MarshalCBOR(w); err != nil {
-		return err
-	}
-
-	// t.Ref (cid.Cid) (struct)
-
-	if err := cbg.WriteCid(w, t.Ref); err != nil {
-		return xerrors.Errorf("failed to write cid field t.Ref: %w", err)
-	}
-
-	// t.Params (retrieval.RetParams) (struct)
-	if err := t.Params.MarshalCBOR(w); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *DealProposal) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 3 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	// t.Payment (api.PaymentInfo) (struct)
-
-	{
-
-		if err := t.Payment.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-	}
-	// t.Ref (cid.Cid) (struct)
-
-	{
-
-		c, err := cbg.ReadCid(br)
-		if err != nil {
-			return xerrors.Errorf("failed to read cid field t.Ref: %w", err)
-		}
-
-		t.Ref = c
-
-	}
-	// t.Params (retrieval.RetParams) (struct)
-
-	{
-
-		if err := t.Params.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-	}
-	return nil
-}
-
-func (t *DealResponse) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{130}); err != nil {
-		return err
-	}
-
-	// t.Status (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.Status))); err != nil {
-		return err
-	}
-
-	// t.Message (string) (string)
-	if len(t.Message) > cbg.MaxLength {
-		return xerrors.Errorf("Value in field t.Message was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len(t.Message)))); err != nil {
-		return err
-	}
-	if _, err := w.Write([]byte(t.Message)); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *DealResponse) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 2 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	// t.Status (uint64) (uint64)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.Status = uint64(extra)
-	// t.Message (string) (string)
-
-	{
-		sval, err := cbg.ReadString(br)
-		if err != nil {
-			return err
-		}
-
-		t.Message = string(sval)
-	}
-	return nil
-}
-
-func (t *Block) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{130}); err != nil {
-		return err
-	}
-
-	// t.Prefix ([]uint8) (slice)
-	if len(t.Prefix) > cbg.ByteArrayMaxLen {
-		return xerrors.Errorf("Byte array in field t.Prefix was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajByteString, uint64(len(t.Prefix)))); err != nil {
-		return err
-	}
-	if _, err := w.Write(t.Prefix); err != nil {
-		return err
-	}
-
-	// t.Data ([]uint8) (slice)
-	if len(t.Data) > cbg.ByteArrayMaxLen {
-		return xerrors.Errorf("Byte array in field t.Data was too long")
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajByteString, uint64(len(t.Data)))); err != nil {
-		return err
-	}
-	if _, err := w.Write(t.Data); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *Block) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajArray {
-		return fmt.Errorf("cbor input should be of type array")
-	}
-
-	if extra != 2 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	// t.Prefix ([]uint8) (slice)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-
-	if extra > cbg.ByteArrayMaxLen {
-		return fmt.Errorf("t.Prefix: byte array too large (%d)", extra)
-	}
-	if maj != cbg.MajByteString {
-		return fmt.Errorf("expected byte array")
-	}
-	t.Prefix = make([]byte, extra)
-	if _, err := io.ReadFull(br, t.Prefix); err != nil {
-		return err
-	}
-	// t.Data ([]uint8) (slice)
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-
-	if extra > cbg.ByteArrayMaxLen {
-		return fmt.Errorf("t.Data: byte array too large (%d)", extra)
-	}
-	if maj != cbg.MajByteString {
-		return fmt.Errorf("expected byte array")
-	}
-	t.Data = make([]byte, extra)
-	if _, err := io.ReadFull(br, t.Data); err != nil {
-		return err
-	}
-	return nil
-}
diff --git a/retrieval/client.go b/retrieval/client.go
deleted file mode 100644
index bd06c4d3b..000000000
--- a/retrieval/client.go
+++ /dev/null
@@ -1,272 +0,0 @@
-package retrieval
-
-import (
-	"context"
-	"io"
-
-	blocks "github.com/ipfs/go-block-format"
-	"github.com/ipfs/go-cid"
-	logging "github.com/ipfs/go-log"
-	"github.com/libp2p/go-libp2p-core/host"
-	"github.com/libp2p/go-libp2p-core/network"
-	"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-cbor-util"
-	"github.com/filecoin-project/lotus/api"
-	"github.com/filecoin-project/lotus/build"
-	"github.com/filecoin-project/lotus/chain/types"
-	payapi "github.com/filecoin-project/lotus/node/impl/paych"
-	"github.com/filecoin-project/lotus/paych"
-	"github.com/filecoin-project/lotus/retrieval/discovery"
-)
-
-var log = logging.Logger("retrieval")
-
-type Client struct {
-	h host.Host
-
-	pmgr   *paych.Manager
-	payapi payapi.PaychAPI
-}
-
-func NewClient(h host.Host, pmgr *paych.Manager, payapi payapi.PaychAPI) *Client {
-	return &Client{h: h, pmgr: pmgr, payapi: payapi}
-}
-
-func (c *Client) Query(ctx context.Context, p discovery.RetrievalPeer, data cid.Cid) api.QueryOffer {
-	s, err := c.h.NewStream(ctx, p.ID, QueryProtocolID)
-	if err != nil {
-		log.Warn(err)
-		return api.QueryOffer{Err: err.Error(), Miner: p.Address, MinerPeerID: p.ID}
-	}
-	defer s.Close()
-
-	err = cborutil.WriteCborRPC(s, &Query{
-		Piece: data,
-	})
-	if err != nil {
-		log.Warn(err)
-		return api.QueryOffer{Err: err.Error(), Miner: p.Address, MinerPeerID: p.ID}
-	}
-
-	var resp QueryResponse
-	if err := resp.UnmarshalCBOR(s); err != nil {
-		log.Warn(err)
-		return api.QueryOffer{Err: err.Error(), Miner: p.Address, MinerPeerID: p.ID}
-	}
-
-	return api.QueryOffer{
-		Root:        data,
-		Size:        resp.Size,
-		MinPrice:    resp.MinPrice,
-		Miner:       p.Address, // TODO: check
-		MinerPeerID: p.ID,
-	}
-}
-
-type clientStream struct {
-	payapi payapi.PaychAPI
-	stream network.Stream
-	peeker cbg.BytePeeker
-
-	root   cid.Cid
-	size   types.BigInt
-	offset uint64
-
-	paych       address.Address
-	lane        uint64
-	total       types.BigInt
-	transferred types.BigInt
-
-	windowSize uint64 // how much we "trust" the peer
-	verifier   BlockVerifier
-}
-
-// C > S
-//
-// Offset MUST be aligned on chunking boundaries, size is rounded up to leaf size
-//
-// > DealProposal{Mode: Unixfs0, RootCid, Offset, Size, Payment(nil if free)}
-// < Resp{Accept}
-// < ..(Intermediate Block)
-// < ..Blocks
-// < ..(Intermediate Block)
-// < ..Blocks
-// > DealProposal(...)
-// < ...
-func (c *Client) RetrieveUnixfs(ctx context.Context, root cid.Cid, size uint64, total types.BigInt, miner peer.ID, client, minerAddr address.Address, out io.Writer) error {
-	s, err := c.h.NewStream(ctx, miner, ProtocolID)
-	if err != nil {
-		return xerrors.Errorf("failed to open stream to miner for retrieval query: %w", err)
-	}
-	defer s.Close()
-
-	initialOffset := uint64(0) // TODO: Check how much data we have locally
-	// TODO: Support in handler
-	// TODO: Allow client to specify this
-
-	paych, _, err := c.pmgr.GetPaych(ctx, client, minerAddr, total)
-	if err != nil {
-		return xerrors.Errorf("getting payment channel: %w", err)
-	}
-	lane, err := c.pmgr.AllocateLane(paych)
-	if err != nil {
-		return xerrors.Errorf("allocating payment lane: %w", err)
-	}
-
-	cst := clientStream{
-		payapi: c.payapi,
-		stream: s,
-		peeker: cbg.GetPeeker(s),
-
-		root:   root,
-		size:   types.NewInt(size),
-		offset: initialOffset,
-
-		paych:       paych,
-		lane:        lane,
-		total:       total,
-		transferred: types.NewInt(0),
-
-		windowSize: build.UnixfsChunkSize,
-		verifier:   &UnixFs0Verifier{Root: root},
-	}
-
-	for cst.offset != size+initialOffset {
-		toFetch := cst.windowSize
-		if toFetch+cst.offset > size {
-			toFetch = size - cst.offset
-		}
-		log.Infof("Retrieve %dB @%d", toFetch, cst.offset)
-
-		err := cst.doOneExchange(ctx, toFetch, out)
-		if err != nil {
-			return xerrors.Errorf("retrieval exchange: %w", err)
-		}
-
-		cst.offset += toFetch
-	}
-	return nil
-}
-
-func (cst *clientStream) doOneExchange(ctx context.Context, toFetch uint64, out io.Writer) error {
-	payAmount := types.BigDiv(types.BigMul(cst.total, types.NewInt(toFetch)), cst.size)
-
-	payment, err := cst.setupPayment(ctx, payAmount)
-	if err != nil {
-		return xerrors.Errorf("setting up retrieval payment: %w", err)
-	}
-
-	deal := &DealProposal{
-		Payment: payment,
-		Ref:     cst.root,
-		Params: RetParams{
-			Unixfs0: &Unixfs0Offer{
-				Offset: cst.offset,
-				Size:   toFetch,
-			},
-		},
-	}
-
-	if err := cborutil.WriteCborRPC(cst.stream, deal); err != nil {
-		return xerrors.Errorf("sending incremental retrieval request: %w", err)
-	}
-
-	var resp DealResponse
-	if err := cborutil.ReadCborRPC(cst.peeker, &resp); err != nil {
-		return xerrors.Errorf("reading retrieval response: %w", err)
-	}
-
-	if resp.Status != Accepted {
-		cst.windowSize = build.UnixfsChunkSize
-		// TODO: apply some 'penalty' to miner 'reputation' (needs to be the same in both cases)
-
-		if resp.Status == Error {
-			return xerrors.Errorf("storage deal error: %s", resp.Message)
-		}
-		if resp.Status == Rejected {
-			return xerrors.Errorf("storage deal rejected: %s", resp.Message)
-		}
-		return xerrors.New("storage deal response had no Accepted section")
-	}
-
-	log.Info("Retrieval accepted, fetching blocks")
-
-	return cst.fetchBlocks(toFetch, out)
-
-	// TODO: maybe increase miner window size after success
-}
-
-func (cst *clientStream) fetchBlocks(toFetch uint64, out io.Writer) error {
-	blocksToFetch := (toFetch + build.UnixfsChunkSize - 1) / build.UnixfsChunkSize
-
-	for i := uint64(0); i < blocksToFetch; {
-		log.Infof("block %d of %d", i+1, blocksToFetch)
-
-		var block Block
-		if err := cborutil.ReadCborRPC(cst.peeker, &block); err != nil {
-			return xerrors.Errorf("reading fetchBlock response: %w", err)
-		}
-
-		dataBlocks, err := cst.consumeBlockMessage(block, out)
-		if err != nil {
-			return xerrors.Errorf("consuming retrieved blocks: %w", err)
-		}
-
-		i += dataBlocks
-	}
-
-	return nil
-}
-
-func (cst *clientStream) consumeBlockMessage(block Block, out io.Writer) (uint64, error) {
-	prefix, err := cid.PrefixFromBytes(block.Prefix)
-	if err != nil {
-		return 0, err
-	}
-
-	cid, err := prefix.Sum(block.Data)
-	if err != nil {
-		return 0, err
-	}
-
-	blk, err := blocks.NewBlockWithCid(block.Data, cid)
-	if err != nil {
-		return 0, err
-	}
-
-	internal, err := cst.verifier.Verify(context.TODO(), blk, out)
-	if err != nil {
-		log.Warnf("block verify failed: %s", err)
-		return 0, err
-	}
-
-	// TODO: Smarter out, maybe add to filestore automagically
-	//  (Also, persist intermediate nodes)
-
-	if internal {
-		return 0, nil
-	}
-
-	return 1, nil
-}
-
-func (cst *clientStream) setupPayment(ctx context.Context, toSend types.BigInt) (api.PaymentInfo, error) {
-	amount := types.BigAdd(cst.transferred, toSend)
-
-	sv, err := cst.payapi.PaychVoucherCreate(ctx, cst.paych, amount, cst.lane)
-	if err != nil {
-		return api.PaymentInfo{}, err
-	}
-
-	cst.transferred = amount
-
-	return api.PaymentInfo{
-		Channel:        cst.paych,
-		ChannelMessage: nil,
-		Vouchers:       []*types.SignedVoucher{sv},
-	}, nil
-}
diff --git a/retrieval/discovery/discovery.go b/retrieval/discovery/discovery.go
deleted file mode 100644
index 9933ad793..000000000
--- a/retrieval/discovery/discovery.go
+++ /dev/null
@@ -1,25 +0,0 @@
-package discovery
-
-import (
-	"github.com/filecoin-project/go-address"
-	"github.com/ipfs/go-cid"
-	cbor "github.com/ipfs/go-ipld-cbor"
-	"github.com/libp2p/go-libp2p-core/peer"
-)
-
-func init() {
-	cbor.RegisterCborType(RetrievalPeer{})
-}
-
-type RetrievalPeer struct {
-	Address address.Address
-	ID      peer.ID // optional
-}
-
-type PeerResolver interface {
-	GetPeers(data cid.Cid) ([]RetrievalPeer, error) // TODO: channel
-}
-
-func Multi(r PeerResolver) PeerResolver { // TODO: actually support multiple mechanisms
-	return r
-}
diff --git a/retrieval/discovery/local.go b/retrieval/discovery/local.go
deleted file mode 100644
index 1ca99db9c..000000000
--- a/retrieval/discovery/local.go
+++ /dev/null
@@ -1,53 +0,0 @@
-package discovery
-
-import (
-	"github.com/ipfs/go-cid"
-	"github.com/ipfs/go-datastore"
-	"github.com/ipfs/go-datastore/namespace"
-	dshelp "github.com/ipfs/go-ipfs-ds-help"
-	cbor "github.com/ipfs/go-ipld-cbor"
-	logging "github.com/ipfs/go-log"
-
-	"github.com/filecoin-project/lotus/node/modules/dtypes"
-)
-
-var log = logging.Logger("ret-discovery")
-
-type Local struct {
-	ds datastore.Datastore
-}
-
-func NewLocal(ds dtypes.MetadataDS) *Local {
-	return &Local{ds: namespace.Wrap(ds, datastore.NewKey("/deals/local"))}
-}
-
-func (l *Local) AddPeer(cid cid.Cid, peer RetrievalPeer) error {
-	// TODO: allow multiple peers here
-	//  (implement an util for tracking map[thing][]otherThing, use in sectorBlockstore too)
-
-	log.Warn("Tracking multiple retrieval peers not implemented")
-
-	entry, err := cbor.DumpObject(peer)
-	if err != nil {
-		return err
-	}
-
-	return l.ds.Put(dshelp.CidToDsKey(cid), entry)
-}
-
-func (l *Local) GetPeers(data cid.Cid) ([]RetrievalPeer, error) {
-	entry, err := l.ds.Get(dshelp.CidToDsKey(data))
-	if err == datastore.ErrNotFound {
-		return []RetrievalPeer{}, nil
-	}
-	if err != nil {
-		return nil, err
-	}
-	var peer RetrievalPeer
-	if err := cbor.DecodeInto(entry, &peer); err != nil {
-		return nil, err
-	}
-	return []RetrievalPeer{peer}, nil
-}
-
-var _ PeerResolver = &Local{}
diff --git a/retrieval/miner.go b/retrieval/miner.go
deleted file mode 100644
index c9b54c5ec..000000000
--- a/retrieval/miner.go
+++ /dev/null
@@ -1,245 +0,0 @@
-package retrieval
-
-import (
-	"context"
-	"io"
-
-	"github.com/ipfs/go-blockservice"
-	"github.com/ipfs/go-cid"
-	"github.com/ipfs/go-merkledag"
-	unixfile "github.com/ipfs/go-unixfs/file"
-	"github.com/libp2p/go-libp2p-core/network"
-	"golang.org/x/xerrors"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-cbor-util"
-	"github.com/filecoin-project/lotus/api"
-	"github.com/filecoin-project/lotus/build"
-	"github.com/filecoin-project/lotus/chain/types"
-	"github.com/filecoin-project/lotus/storage/sectorblocks"
-)
-
-type RetrMinerApi interface {
-	PaychVoucherAdd(context.Context, address.Address, *types.SignedVoucher, []byte, types.BigInt) (types.BigInt, error)
-}
-
-type Miner struct {
-	sectorBlocks *sectorblocks.SectorBlocks
-	full         RetrMinerApi
-
-	pricePerByte types.BigInt
-	// TODO: Unseal price
-}
-
-func NewMiner(sblks *sectorblocks.SectorBlocks, full api.FullNode) *Miner {
-	return &Miner{
-		sectorBlocks: sblks,
-		full:         full,
-
-		pricePerByte: types.NewInt(2), // TODO: allow setting
-	}
-}
-
-func writeErr(stream network.Stream, err error) {
-	log.Errorf("Retrieval deal error: %+v", err)
-	_ = cborutil.WriteCborRPC(stream, &DealResponse{
-		Status:  Error,
-		Message: err.Error(),
-	})
-}
-
-func (m *Miner) HandleQueryStream(stream network.Stream) {
-	defer stream.Close()
-
-	var query Query
-	if err := cborutil.ReadCborRPC(stream, &query); err != nil {
-		writeErr(stream, err)
-		return
-	}
-
-	size, err := m.sectorBlocks.GetSize(query.Piece)
-	if err != nil && err != sectorblocks.ErrNotFound {
-		log.Errorf("Retrieval query: GetRefs: %s", err)
-		return
-	}
-
-	answer := &QueryResponse{
-		Status: Unavailable,
-	}
-	if err == nil {
-		answer.Status = Available
-
-		// TODO: get price, look for already unsealed ref to reduce work
-		answer.MinPrice = types.BigMul(types.NewInt(uint64(size)), m.pricePerByte)
-		answer.Size = uint64(size) // TODO: verify on intermediate
-	}
-
-	if err := cborutil.WriteCborRPC(stream, answer); err != nil {
-		log.Errorf("Retrieval query: WriteCborRPC: %s", err)
-		return
-	}
-}
-
-type handlerDeal struct {
-	m      *Miner
-	stream network.Stream
-
-	ufsr sectorblocks.UnixfsReader
-	open cid.Cid
-	at   uint64
-	size uint64
-}
-
-func (m *Miner) HandleDealStream(stream network.Stream) {
-	defer stream.Close()
-
-	hnd := &handlerDeal{
-		m: m,
-
-		stream: stream,
-	}
-
-	var err error
-	more := true
-
-	for more {
-		more, err = hnd.handleNext() // TODO: 'more' bool
-		if err != nil {
-			writeErr(stream, err)
-			return
-		}
-	}
-
-}
-
-func (hnd *handlerDeal) handleNext() (bool, error) {
-	var deal DealProposal
-	if err := cborutil.ReadCborRPC(hnd.stream, &deal); err != nil {
-		if err == io.EOF { // client sent all deals
-			err = nil
-		}
-		return false, err
-	}
-
-	if deal.Params.Unixfs0 == nil {
-		return false, xerrors.New("unknown deal type")
-	}
-
-	unixfs0 := deal.Params.Unixfs0
-
-	if len(deal.Payment.Vouchers) != 1 {
-		return false, xerrors.Errorf("expected one signed voucher, got %d", len(deal.Payment.Vouchers))
-	}
-
-	expPayment := types.BigMul(hnd.m.pricePerByte, types.NewInt(deal.Params.Unixfs0.Size))
-	if _, err := hnd.m.full.PaychVoucherAdd(context.TODO(), deal.Payment.Channel, deal.Payment.Vouchers[0], nil, expPayment); err != nil {
-		return false, xerrors.Errorf("processing retrieval payment: %w", err)
-	}
-
-	// If the file isn't open (new deal stream), isn't the right file, or isn't
-	// at the right offset, (re)open it
-	if hnd.open != deal.Ref || hnd.at != unixfs0.Offset {
-		log.Infof("opening file for sending (open '%s') (@%d, want %d)", deal.Ref, hnd.at, unixfs0.Offset)
-		if err := hnd.openFile(deal); err != nil {
-			return false, err
-		}
-	}
-
-	if unixfs0.Offset+unixfs0.Size > hnd.size {
-		return false, xerrors.Errorf("tried to read too much %d+%d > %d", unixfs0.Offset, unixfs0.Size, hnd.size)
-	}
-
-	err := hnd.accept(deal)
-	if err != nil {
-		return false, err
-	}
-	return true, nil
-}
-
-func (hnd *handlerDeal) openFile(deal DealProposal) error {
-	unixfs0 := deal.Params.Unixfs0
-
-	if unixfs0.Offset != 0 {
-		// TODO: Implement SeekBlock (like ReadBlock) in go-unixfs
-		return xerrors.New("sending merkle proofs for nonzero offset not supported yet")
-	}
-	hnd.at = unixfs0.Offset
-
-	bstore := hnd.m.sectorBlocks.SealedBlockstore(func() error {
-		return nil // TODO: approve unsealing based on amount paid
-	})
-
-	ds := merkledag.NewDAGService(blockservice.New(bstore, nil))
-	rootNd, err := ds.Get(context.TODO(), deal.Ref)
-	if err != nil {
-		return err
-	}
-
-	fsr, err := unixfile.NewUnixfsFile(context.TODO(), ds, rootNd)
-	if err != nil {
-		return err
-	}
-
-	var ok bool
-	hnd.ufsr, ok = fsr.(sectorblocks.UnixfsReader)
-	if !ok {
-		return xerrors.Errorf("file %s didn't implement sectorblocks.UnixfsReader", deal.Ref)
-	}
-
-	isize, err := hnd.ufsr.Size()
-	if err != nil {
-		return err
-	}
-	hnd.size = uint64(isize)
-
-	hnd.open = deal.Ref
-
-	return nil
-}
-
-func (hnd *handlerDeal) accept(deal DealProposal) error {
-	unixfs0 := deal.Params.Unixfs0
-
-	resp := &DealResponse{
-		Status: Accepted,
-	}
-	if err := cborutil.WriteCborRPC(hnd.stream, resp); err != nil {
-		log.Errorf("Retrieval query: Write Accepted resp: %s", err)
-		return err
-	}
-
-	blocksToSend := (unixfs0.Size + build.UnixfsChunkSize - 1) / build.UnixfsChunkSize
-	for i := uint64(0); i < blocksToSend; {
-		data, offset, nd, err := hnd.ufsr.ReadBlock(context.TODO())
-		if err != nil {
-			return err
-		}
-
-		log.Infof("sending block for a deal: %s", nd.Cid())
-
-		if offset != unixfs0.Offset {
-			return xerrors.Errorf("ReadBlock on wrong offset: want %d, got %d", unixfs0.Offset, offset)
-		}
-
-		/*if uint64(len(data)) != deal.Unixfs0.Size { // TODO: Fix for internal nodes (and any other node too)
-			writeErr(stream, xerrors.Errorf("ReadBlock data with wrong size: want %d, got %d", deal.Unixfs0.Size, len(data)))
-			return
-		}*/
-
-		block := &Block{
-			Prefix: nd.Cid().Prefix().Bytes(),
-			Data:   nd.RawData(),
-		}
-
-		if err := cborutil.WriteCborRPC(hnd.stream, block); err != nil {
-			return err
-		}
-
-		if len(data) > 0 { // don't count internal nodes
-			hnd.at += uint64(len(data))
-			i++
-		}
-	}
-
-	return nil
-}
diff --git a/retrieval/types.go b/retrieval/types.go
deleted file mode 100644
index 28343e6b2..000000000
--- a/retrieval/types.go
+++ /dev/null
@@ -1,66 +0,0 @@
-package retrieval
-
-import (
-	"github.com/filecoin-project/lotus/api"
-	"github.com/ipfs/go-cid"
-
-	"github.com/filecoin-project/lotus/chain/types"
-)
-
-const ProtocolID = "/fil/retrieval/-1.0.0"          // TODO: spec
-const QueryProtocolID = "/fil/retrieval/qry/-1.0.0" // TODO: spec
-
-type QueryResponseStatus uint64
-
-const (
-	Available QueryResponseStatus = iota
-	Unavailable
-)
-
-const (
-	Accepted = iota
-	Error
-	Rejected
-	Unsealing
-)
-
-type Query struct {
-	Piece cid.Cid
-	// TODO: payment
-}
-
-type QueryResponse struct {
-	Status QueryResponseStatus
-
-	Size uint64 // TODO: spec
-	// TODO: unseal price (+spec)
-	// TODO: sectors to unseal
-	// TODO: address to send money for the deal?
-	MinPrice types.BigInt
-}
-
-type Unixfs0Offer struct {
-	Offset uint64
-	Size   uint64
-}
-
-type RetParams struct {
-	Unixfs0 *Unixfs0Offer
-}
-
-type DealProposal struct {
-	Payment api.PaymentInfo
-
-	Ref    cid.Cid
-	Params RetParams
-}
-
-type DealResponse struct {
-	Status  uint64
-	Message string
-}
-
-type Block struct { // TODO: put in spec
-	Prefix []byte // TODO: fix cid.Prefix marshaling somehow
-	Data   []byte
-}
diff --git a/retrieval/verify.go b/retrieval/verify.go
deleted file mode 100644
index 88fa0dfed..000000000
--- a/retrieval/verify.go
+++ /dev/null
@@ -1,143 +0,0 @@
-package retrieval
-
-import (
-	"context"
-	"io"
-
-	blocks "github.com/ipfs/go-block-format"
-	"github.com/ipfs/go-cid"
-	ipld "github.com/ipfs/go-ipld-format"
-	"github.com/ipfs/go-merkledag"
-	"github.com/ipfs/go-unixfs"
-	pb "github.com/ipfs/go-unixfs/pb"
-	"golang.org/x/xerrors"
-
-	"github.com/filecoin-project/lotus/build"
-)
-
-type BlockVerifier interface {
-	Verify(context.Context, blocks.Block, io.Writer) (internal bool, err error)
-}
-
-type OptimisticVerifier struct {
-}
-
-func (o *OptimisticVerifier) Verify(context.Context, blocks.Block, io.Writer) (bool, error) {
-	// It's probably fine
-	return false, nil
-}
-
-type UnixFs0Verifier struct {
-	Root    cid.Cid
-	rootBlk blocks.Block
-
-	expect int
-	seen   int
-
-	sub *UnixFs0Verifier
-}
-
-func (b *UnixFs0Verifier) verify(ctx context.Context, blk blocks.Block, out io.Writer) (last bool, internal bool, err error) {
-	if b.sub != nil {
-		// TODO: check links here (iff b.sub.sub == nil)
-
-		subLast, internal, err := b.sub.verify(ctx, blk, out)
-		if err != nil {
-			return false, false, err
-		}
-		if subLast {
-			b.sub = nil
-			b.seen++
-		}
-
-		return b.seen == b.expect, internal, nil
-	}
-
-	if b.seen >= b.expect { // this is probably impossible
-		return false, false, xerrors.New("unixfs verifier: too many nodes in level")
-	}
-
-	links, err := b.checkInternal(blk, out)
-	if err != nil {
-		return false, false, err
-	}
-
-	if links > 0 { // TODO: check if all links are intermediate (or all aren't)
-		if links > build.UnixfsLinksPerLevel {
-			return false, false, xerrors.New("unixfs verifier: too many links in intermediate node")
-		}
-
-		if b.seen+1 == b.expect && links != build.UnixfsLinksPerLevel {
-			return false, false, xerrors.New("unixfs verifier: too few nodes in level")
-		}
-
-		b.sub = &UnixFs0Verifier{
-			Root:    blk.Cid(),
-			rootBlk: blk,
-			expect:  links,
-		}
-
-		// don't mark as seen yet
-		return false, true, nil
-	}
-
-	b.seen++
-	return b.seen == b.expect, false, nil
-}
-
-func (b *UnixFs0Verifier) checkInternal(blk blocks.Block, out io.Writer) (int, error) {
-	nd, err := ipld.Decode(blk)
-	if err != nil {
-		log.Warnf("IPLD Decode failed: %s", err)
-		return 0, err
-	}
-
-	// TODO: check size
-	switch nd := nd.(type) {
-	case *merkledag.ProtoNode:
-		fsn, err := unixfs.FSNodeFromBytes(nd.Data())
-		if err != nil {
-			log.Warnf("unixfs.FSNodeFromBytes failed: %s", err)
-			return 0, err
-		}
-		if fsn.Type() != pb.Data_File {
-			return 0, xerrors.New("internal nodes must be a file")
-		}
-		if len(fsn.Data()) > 0 {
-			return 0, xerrors.New("internal node with data")
-		}
-		if len(nd.Links()) == 0 {
-			return 0, xerrors.New("internal node with no links")
-		}
-		return len(nd.Links()), nil
-
-	case *merkledag.RawNode:
-		_, err := out.Write(nd.RawData())
-		return 0, err
-	default:
-		return 0, xerrors.New("verifier: unknown node type")
-	}
-}
-
-func (b *UnixFs0Verifier) Verify(ctx context.Context, blk blocks.Block, w io.Writer) (bool, error) {
-	// root is special
-	if b.rootBlk == nil {
-		if !b.Root.Equals(blk.Cid()) {
-			return false, xerrors.Errorf("unixfs verifier: root block CID didn't match: valid %s, got %s", b.Root, blk.Cid())
-		}
-		b.rootBlk = blk
-		links, err := b.checkInternal(blk, w)
-		if err != nil {
-			return false, err
-		}
-
-		b.expect = links
-		return links != 0, nil
-	}
-
-	_, internal, err := b.verify(ctx, blk, w)
-	return internal, err
-}
-
-var _ BlockVerifier = &OptimisticVerifier{}
-var _ BlockVerifier = &UnixFs0Verifier{}
diff --git a/scripts/README b/scripts/README
deleted file mode 100644
index 43eedb800..000000000
--- a/scripts/README
+++ /dev/null
@@ -1,3 +0,0 @@
-From https://github.com/filecoin-project/go-filecoin/tree/master/scripts
-
-Try to keep in sync
\ No newline at end of file
diff --git a/scripts/archive-branches.sh b/scripts/archive-branches.sh
new file mode 100755
index 000000000..98fdfaeb8
--- /dev/null
+++ b/scripts/archive-branches.sh
@@ -0,0 +1,66 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+
+org=filecoin-project
+repo=lotus
+arch_repo="$org/lotus-archived"
+api_repo="repos/$org/$repo"
+
+exclusions=(
+	'master'
+)
+
+gh_api_next() {
+	links=$(grep '^Link:' | sed -e 's/Link: //' -e 's/, /\n/g')
+	echo "$links" | grep '; rel="next"' >/dev/null || return
+	link=$(echo "$links" | grep '; rel="next"' | sed -e 's/^<//' -e 's/>.*//')
+
+	curl -n -f -sD >(gh_api_next) "$link"
+}
+
+gh_api() {
+	curl -n -f -sD >(gh_api_next) "https://api.github.com/$1" | jq -s '[.[] | .[]]'
+}
+
+pr_branches() {
+	gh_api "$api_repo/pulls" |  jq -r '.[].head.label | select(test("^'"$org"':"))' \
+		| sed 's/^'"$org"'://'
+}
+
+origin_refs() {
+	format=${1-'%(refname:short)'}
+
+	git for-each-ref --format "$format" refs/remotes/origin | sed 's|^origin/||'
+}
+
+active_branches() {
+	origin_refs '%(refname:short) %(committerdate:unix)' |awk \
+'	BEGIN { monthAgo = systime() - 31*24*60*60 }
+	{ if ($2 > monthAgo) print $1 }
+'
+}
+
+git remote add archived "git@github.com:$arch_repo.git" || true
+
+branches_to_move="$(cat <(active_branches) <(pr_branches) <((IFS=$'\n'; echo "${exclusions[*]}")) | sort -u | comm - <(origin_refs | sort) -13)"
+
+echo "================"
+printf "%s\n" "$branches_to_move"
+echo "================"
+
+echo "Please confirm move of above branches [y/N]:"
+
+read -r line
+case "$line" in
+  [Yy]|[Yy][Ee][Ss]) ;;
+  *) exit 1 ;;
+esac
+
+
+printf "%s\n" "$branches_to_move" | \
+while read -r ref; do
+		git push archived "origin/$ref:refs/heads/$ref/$(date --rfc-3339=date)"
+		git push origin --delete "$ref"
+	done
+
diff --git a/scripts/bash-completion/lotus b/scripts/bash-completion/lotus
new file mode 100644
index 000000000..20c312b6c
--- /dev/null
+++ b/scripts/bash-completion/lotus
@@ -0,0 +1,10 @@
+#!/usr/bin/env bash
+_cli_bash_autocomplete() {
+     local cur opts base;
+     COMPREPLY=();
+     cur="${COMP_WORDS[COMP_CWORD]}";
+     opts=$( ${COMP_WORDS[@]:0:$COMP_CWORD} --generate-completion );
+     COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) );
+     return 0;
+};
+complete -F _cli_bash_autocomplete lotus
\ No newline at end of file
diff --git a/scripts/bash-completion/lotus-miner b/scripts/bash-completion/lotus-miner
new file mode 100644
index 000000000..df5cc01cc
--- /dev/null
+++ b/scripts/bash-completion/lotus-miner
@@ -0,0 +1,10 @@
+#!/usr/bin/env bash
+_cli_bash_autocomplete() {
+     local cur opts base;
+     COMPREPLY=();
+     cur="${COMP_WORDS[COMP_CWORD]}";
+     opts=$( ${COMP_WORDS[@]:0:$COMP_CWORD} --generate-completion );
+     COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) );
+     return 0;
+};
+complete -F _cli_bash_autocomplete lotus-miner
\ No newline at end of file
diff --git a/scripts/build-bundle.sh b/scripts/build-bundle.sh
new file mode 100755
index 000000000..7d37edff8
--- /dev/null
+++ b/scripts/build-bundle.sh
@@ -0,0 +1,52 @@
+#!/usr/bin/env bash
+set -ex
+
+ARCHS=(
+    "darwin"
+    "linux"
+)
+
+REQUIRED=(
+    "ipfs"
+    "sha512sum"
+)
+for REQUIRE in "${REQUIRED[@]}"
+do
+    command -v "${REQUIRE}" >/dev/null 2>&1 || echo >&2 "'${REQUIRE}' must be installed"
+done
+
+mkdir bundle
+pushd bundle
+
+BINARIES=(
+    "lotus"
+    "lotus-miner"
+    "lotus-worker"
+)
+
+export IPFS_PATH=`mktemp -d`
+ipfs init
+ipfs daemon &
+PID="$!"
+trap "kill -9 ${PID}" EXIT
+sleep 30
+
+for ARCH in "${ARCHS[@]}"
+do
+    mkdir -p "${ARCH}/lotus"
+    pushd "${ARCH}"
+    for BINARY in "${BINARIES[@]}"
+    do
+        cp "../../${ARCH}/${BINARY}" "lotus/"
+        chmod +x "lotus/${BINARY}"
+    done
+
+    tar -zcvf "../lotus_${CIRCLE_TAG}_${ARCH}-amd64.tar.gz" lotus
+    popd
+    rm -rf "${ARCH}"
+
+    sha512sum "lotus_${CIRCLE_TAG}_${ARCH}-amd64.tar.gz" > "lotus_${CIRCLE_TAG}_${ARCH}-amd64.tar.gz.sha512"
+
+    ipfs add -q "lotus_${CIRCLE_TAG}_${ARCH}-amd64.tar.gz" > "lotus_${CIRCLE_TAG}_${ARCH}-amd64.tar.gz.cid"
+done
+popd
diff --git a/scripts/deploy-bootstrapper.sh b/scripts/deploy-bootstrapper.sh
index 98e2cd798..3ca0d51a2 100755
--- a/scripts/deploy-bootstrapper.sh
+++ b/scripts/deploy-bootstrapper.sh
@@ -10,15 +10,15 @@ log "> Deploying bootstrap node $host"
 log "Stopping lotus daemon"
 
 ssh "$host" 'systemctl stop lotus-daemon' &
-ssh "$host" 'systemctl stop lotus-storage-miner' &
+ssh "$host" 'systemctl stop lotus-miner' &
 
 wait
 
 ssh "$host" 'rm -rf .lotus' &
-ssh "$host" 'rm -rf .lotusstorage' &
+ssh "$host" 'rm -rf .lotusminer' &
 
 scp -C lotus "${host}":/usr/local/bin/lotus &
-scp -C lotus-storage-miner "${host}":/usr/local/bin/lotus-storage-miner &
+scp -C lotus-miner "${host}":/usr/local/bin/lotus-miner &
 
 wait
 
diff --git a/scripts/deploy-miner.sh b/scripts/deploy-miner.sh
index b1603aca6..5ce5069e4 100755
--- a/scripts/deploy-miner.sh
+++ b/scripts/deploy-miner.sh
@@ -2,7 +2,7 @@
 
 HOST=$1
 
-ssh "$HOST" '[ -e ~/.lotusstorage/token ]' && exit 0
+ssh "$HOST" '[ -e ~/.lotusminer/token ]' && exit 0
 
 ssh "$HOST" 'lotus wallet new bls > addr'
 ssh "$HOST" 'curl http://147.75.80.29:777/sendcoll?address=$(cat addr)' &
@@ -14,5 +14,5 @@ echo "SYNC WAIT"
 sleep 30
 
 ssh "$HOST" 'lotus sync wait'
-ssh "$HOST" 'lotus-storage-miner init --owner=$(cat addr)'
-ssh "$HOST" 'systemctl start lotus-storage-miner' &
+ssh "$HOST" 'lotus-miner init --owner=$(cat addr)'
+ssh "$HOST" 'systemctl start lotus-miner' &
diff --git a/scripts/deploy-node.sh b/scripts/deploy-node.sh
index 4fc3d9aff..fa6efa4d9 100755
--- a/scripts/deploy-node.sh
+++ b/scripts/deploy-node.sh
@@ -10,8 +10,8 @@ HOST=$1
 # TODO: destroy
 
 FILES_TO_SEND=(
-	./louts
-	./lotus-storage-miner
+	./lotus
+	./lotus-miner
 	scripts/lotus-daemon.service
 	scripts/louts-miner.service
 )
@@ -21,14 +21,14 @@ rsync -P "${FILES_TO_SEND[@]}" "$HOST:~/lotus-stage/"
 ssh "$HOST" 'bash -s' << 'EOF'
 set -euo pipefail
 
-systemctl stop lotus-storage-miner
+systemctl stop lotus-miner
 systemctl stop lotus-daemon
-mkdir -p .lotus .lotusstorage
+mkdir -p .lotus .lotusminer
 
 cd "$HOME/lotus-stage/"
-cp -f louts lotus-storage-miner /usr/local/bin
+cp -f lotus lotus-miner /usr/local/bin
 cp -f lotus-daemon.service /etc/systemd/system/lotus-daemon.service
-cp -f lotus-miner.service /etc/systemd/system/lotus-storage-miner.service
+cp -f lotus-miner.service /etc/systemd/system/lotus-miner.service
 
 systemctl daemon-reload
 systemctl start lotus-daemon
diff --git a/scripts/dev/api.bash b/scripts/dev/api.bash
new file mode 100644
index 000000000..5539e4fef
--- /dev/null
+++ b/scripts/dev/api.bash
@@ -0,0 +1,11 @@
+#!/bin/bash
+# vim: set expandtab ts=2 sw=2:
+
+token=$(lotus auth create-token --perm admin)
+
+runAPI() {
+  curl -X POST \
+    -H "Content-Type: application/json" \
+    --data '{"jsonrpc":"2.0","id":2,"method":"Filecoin.'"$1"'","params":'"${2:-null}"'}' \
+    'http://127.0.0.1:1234/rpc/v0?token='"$token"
+}
diff --git a/scripts/dev/drop-local-repos b/scripts/dev/drop-local-repos
index 939030bad..a0e7a5512 100755
--- a/scripts/dev/drop-local-repos
+++ b/scripts/dev/drop-local-repos
@@ -2,4 +2,4 @@
 
 set -o xtrace
 
-rm -rf ~/.lotus ~/.lotusstorage/ ~/.genesis-sectors ~/.lotusworker
+rm -rf ~/.lotus ~/.lotusminer/ ~/.genesis-sectors ~/.lotusworker
diff --git a/scripts/dev/gen-daemon b/scripts/dev/gen-daemon
index fdadc180f..af25123d3 100755
--- a/scripts/dev/gen-daemon
+++ b/scripts/dev/gen-daemon
@@ -3,6 +3,9 @@
 set -o xtrace
 
 export TRUST_PARAMS=1
+tag=${TAG:-debug}
 
-go run -tags=debug ./cmd/lotus-seed pre-seal
-go run -tags=debug ./cmd/lotus daemon --lotus-make-random-genesis=devel.gen --genesis-presealed-sectors=~/.genesis-sectors/pre-seal-t0101.json
+go run -tags=$tag ./cmd/lotus-seed pre-seal --sector-size 2KiB --num-sectors 2
+go run -tags=$tag ./cmd/lotus-seed genesis new localnet.json
+go run -tags=$tag ./cmd/lotus-seed genesis add-miner localnet.json ~/.genesis-sectors/pre-seal-t01000.json
+go run -tags=$tag ./cmd/lotus daemon --lotus-make-genesis=devel.gen --genesis-template=localnet.json --bootstrap=false
diff --git a/scripts/dev/sminer-init b/scripts/dev/sminer-init
index b14e6e14b..2f4a3f7af 100755
--- a/scripts/dev/sminer-init
+++ b/scripts/dev/sminer-init
@@ -4,4 +4,7 @@ set -o xtrace
 
 export TRUST_PARAMS=1
 
-go run -tags=debug ./cmd/lotus-storage-miner init --actor=t0101 --genesis-miner --pre-sealed-sectors=~/.genesis-sectors
+tag=${TAG:-debug}
+
+go run -tags=$tag ./cmd/lotus wallet import ~/.genesis-sectors/pre-seal-t01000.key
+go run -tags=$tag ./cmd/lotus-storage-miner init --actor=t01000 --genesis-miner --pre-sealed-sectors=~/.genesis-sectors --pre-sealed-metadata=~/.genesis-sectors/pre-seal-t01000.json
diff --git a/scripts/devnet.bash b/scripts/devnet.bash
new file mode 100755
index 000000000..8ffddaea4
--- /dev/null
+++ b/scripts/devnet.bash
@@ -0,0 +1,196 @@
+#!/usr/bin/env bash
+
+session="lotus-interop"
+wdaemon="daemon"
+wminer="miner"
+wsetup="setup"
+wpledging="pledging"
+wcli="cli"
+wshell="cli"
+faucet="http://t01000.miner.interopnet.kittyhawk.wtf"
+
+
+PLEDGE_COUNT="${1:-20}"
+
+if [ -z "$BRANCH" ]; then
+  BRANCH="interopnet"
+fi
+
+if [ -z "$BUILD" ]; then
+  BUILD="no"
+fi
+
+if [ -z "$DEVNET" ]; then
+  DEVNET="yes"
+fi
+
+BASEDIR=$(mktemp -d -t "lotus-interopnet.XXXX")
+
+if [ "$BUILD" == "yes" ]; then
+  git clone --branch "$BRANCH" https://github.com/filecoin-project/lotus.git "${BASEDIR}/build"
+fi
+
+
+mkdir -p "${BASEDIR}/scripts"
+mkdir -p "${BASEDIR}/bin"
+
+cat > "${BASEDIR}/scripts/build.bash" <<EOF
+#!/usr/bin/env bash
+set -x
+
+SCRIPTDIR="\$( cd "\$( dirname "\${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
+pushd \$SCRIPTDIR/../build
+
+pwd
+env RUSTFLAGS="-C target-cpu=native -g" FFI_BUILD_FROM_SOURCE=1 make clean deps lotus lotus-miner lotus-shed
+cp lotus lotus-miner lotus-shed ../bin/
+
+popd
+EOF
+
+cat > "${BASEDIR}/scripts/env.fish" <<EOF
+set -x PATH ${BASEDIR}/bin \$PATH
+set -x LOTUS_PATH ${BASEDIR}/.lotus
+set -x LOTUS_MINER_PATH ${BASEDIR}/.lotusminer
+EOF
+
+cat > "${BASEDIR}/scripts/env.bash" <<EOF
+export PATH=${BASEDIR}/bin:\$PATH
+export LOTUS_PATH=${BASEDIR}/.lotus
+export LOTUS_MINER_PATH=${BASEDIR}/.lotusminer
+EOF
+
+cat > "${BASEDIR}/scripts/create_miner.bash" <<EOF
+#!/usr/bin/env bash
+set -x
+
+lotus wallet import ~/.genesis-sectors/pre-seal-t01000.key
+lotus-miner init --genesis-miner --actor=t01000 --sector-size=2KiB --pre-sealed-sectors=~/.genesis-sectors --pre-sealed-metadata=~/.genesis-sectors/pre-seal-t01000.json --nosync
+EOF
+
+cat > "${BASEDIR}/scripts/pledge_sectors.bash" <<EOF
+#!/usr/bin/env bash
+
+set -x
+
+while [ ! -d ${BASEDIR}/.lotusminer ]; do
+  sleep 5
+done
+
+while [ ! -f ${BASEDIR}/.lotusminer/api ]; do
+  sleep 5
+done
+
+sleep 30
+
+sector=\$(lotus-miner sectors list | tail -n1 | awk '{print \$1}' | tr -d ':')
+current="\$sector"
+
+while true; do
+  if (( \$(lotus-miner sectors list | wc -l) > ${PLEDGE_COUNT} )); then
+    break
+  fi
+
+  while true; do
+    state=\$(lotus-miner sectors list | tail -n1 | awk '{print \$2}')
+
+    if [ -z "\$state" ]; then
+      break
+    fi
+
+    case \$state in
+      PreCommit1 | PreCommit2 | Packing | Unsealed | PreCommitting | Committing | CommitWait | FinalizeSector ) sleep 30 ;;
+      WaitSeed | Proving ) break ;;
+      * ) echo "Unknown Sector State: \$state"
+          lotus-miner sectors status --log \$current
+          break ;;
+    esac
+  done
+
+  lotus-miner sectors pledge
+
+  while [ "\$current" == "\$sector" ]; do
+    sector=\$(lotus-miner sectors list | tail -n1 | awk '{print \$1}' | tr -d ':')
+    sleep 5
+  done
+
+  current="\$sector"
+done
+EOF
+
+cat > "${BASEDIR}/scripts/monitor.bash" <<EOF
+#!/usr/bin/env bash
+
+while true; do
+  clear
+  lotus sync status
+
+  echo
+  echo
+  echo Miner Info
+  lotus-miner info
+
+  echo
+  echo
+  echo Sector List
+  lotus-miner sectors list | tail -n4
+
+  sleep 25
+
+  lotus-shed noncefix --addr \$(lotus wallet list) --auto
+
+done
+EOF
+
+chmod +x "${BASEDIR}/scripts/build.bash"
+chmod +x "${BASEDIR}/scripts/create_miner.bash"
+chmod +x "${BASEDIR}/scripts/pledge_sectors.bash"
+chmod +x "${BASEDIR}/scripts/monitor.bash"
+
+if [ "$BUILD" == "yes" ]; then
+  bash "${BASEDIR}/scripts/build.bash"
+else
+  cp ./lotus ${BASEDIR}/bin/
+  cp ./lotus-miner ${BASEDIR}/bin/
+  cp ./lotus-seed ${BASEDIR}/bin/
+  cp ./lotus-shed ${BASEDIR}/bin/
+fi
+
+tmux new-session -d -s $session -n $wsetup
+
+tmux set-environment -t $session BASEDIR "$BASEDIR"
+
+tmux new-window -t $session -n $wcli
+tmux new-window -t $session -n $wdaemon
+tmux new-window -t $session -n $wminer
+tmux new-window -t $session -n $wpledging
+
+tmux kill-window -t $session:$wsetup
+
+case $(basename $SHELL) in
+  fish ) shell=fish ;;
+  *    ) shell=bash ;;
+esac
+
+tmux send-keys -t $session:$wdaemon   "source ${BASEDIR}/scripts/env.$shell" C-m
+tmux send-keys -t $session:$wminer    "source ${BASEDIR}/scripts/env.$shell" C-m
+tmux send-keys -t $session:$wcli      "source ${BASEDIR}/scripts/env.$shell" C-m
+tmux send-keys -t $session:$wpledging "source ${BASEDIR}/scripts/env.$shell" C-m
+tmux send-keys -t $session:$wshell "source ${BASEDIR}/scripts/env.$shell" C-m
+
+tmux send-keys -t $session:$wdaemon "lotus-seed genesis new devnet.json" C-m
+tmux send-keys -t $session:$wdaemon "lotus-seed genesis add-miner devnet.json ~/.genesis-sectors/pre-seal-t01000.json" C-m
+tmux send-keys -t $session:$wdaemon "lotus daemon --api 48010 --lotus-make-genesis=dev.gen --genesis-template=devnet.json --bootstrap=false 2>&1 | tee -a ${BASEDIR}/daemon.log" C-m
+
+export LOTUS_PATH="${BASEDIR}/.lotus"
+${BASEDIR}/bin/lotus wait-api
+
+tmux send-keys -t $session:$wminer   "${BASEDIR}/scripts/create_miner.bash" C-m
+tmux send-keys -t $session:$wminer   "lotus-miner run --api 48020 --nosync 2>&1 | tee -a ${BASEDIR}/miner.log" C-m
+tmux send-keys -t $session:$wcli     "${BASEDIR}/scripts/monitor.bash" C-m
+tmux send-keys -t $session:$wpleding "${BASEDIR}/scripts/pledge_sectors.bash" C-m
+
+tmux select-window -t $session:$wcli
+
+tmux attach-session -t $session
+
diff --git a/scripts/filebeat.yml b/scripts/filebeat.yml
index 38c9adbc7..e33ca0e87 100644
--- a/scripts/filebeat.yml
+++ b/scripts/filebeat.yml
@@ -4,7 +4,7 @@ filebeat.inputs:
 
 - type: log
   paths:
-    - /root/.lotusstorage/logs
+    - /root/.lotusminer/logs
   fields:
     logzio_codec: json
     token: <API TOKEN>
diff --git a/scripts/init-network.sh b/scripts/init-network.sh
index 873417f7f..10693bb0e 100755
--- a/scripts/init-network.sh
+++ b/scripts/init-network.sh
@@ -3,7 +3,7 @@
 set -xeo
 
 NUM_SECTORS=2
-SECTOR_SIZE=1024
+SECTOR_SIZE=2KiB
 
 
 sdt0111=$(mktemp -d)
@@ -14,9 +14,9 @@ staging=$(mktemp -d)
 
 make debug
 
-./lotus-seed --sectorbuilder-dir="${sdt0111}" pre-seal --miner-addr=t0111 --sector-offset=0 --sector-size=${SECTOR_SIZE} --num-sectors=${NUM_SECTORS} &
-./lotus-seed --sectorbuilder-dir="${sdt0222}" pre-seal --miner-addr=t0222 --sector-offset=0 --sector-size=${SECTOR_SIZE} --num-sectors=${NUM_SECTORS} &
-./lotus-seed --sectorbuilder-dir="${sdt0333}" pre-seal --miner-addr=t0333 --sector-offset=0 --sector-size=${SECTOR_SIZE} --num-sectors=${NUM_SECTORS} &
+./lotus-seed --sector-dir="${sdt0111}" pre-seal --miner-addr=t0111 --sector-offset=0 --sector-size=${SECTOR_SIZE} --num-sectors=${NUM_SECTORS} &
+./lotus-seed --sector-dir="${sdt0222}" pre-seal --miner-addr=t0222 --sector-offset=0 --sector-size=${SECTOR_SIZE} --num-sectors=${NUM_SECTORS} &
+./lotus-seed --sector-dir="${sdt0333}" pre-seal --miner-addr=t0333 --sector-offset=0 --sector-size=${SECTOR_SIZE} --num-sectors=${NUM_SECTORS} &
 
 wait
 
@@ -86,12 +86,12 @@ mdt0111=$(mktemp -d)
 mdt0222=$(mktemp -d)
 mdt0333=$(mktemp -d)
 
-env LOTUS_PATH="${ldt0111}" LOTUS_STORAGE_PATH="${mdt0111}" ./lotus-storage-miner init --genesis-miner --actor=t0111 --pre-sealed-sectors="${sdt0111}" --nosync=true --sector-size="${SECTOR_SIZE}" || true
-env LOTUS_PATH="${ldt0111}" LOTUS_STORAGE_PATH="${mdt0111}" ./lotus-storage-miner run --nosync &
+env LOTUS_PATH="${ldt0111}" LOTUS_MINER_PATH="${mdt0111}" ./lotus-miner init --genesis-miner --actor=t0111 --pre-sealed-sectors="${sdt0111}" --pre-sealed-metadata="${sdt0111}/pre-seal-t0111.json" --nosync=true --sector-size="${SECTOR_SIZE}" || true
+env LOTUS_PATH="${ldt0111}" LOTUS_MINER_PATH="${mdt0111}" ./lotus-miner run --nosync &
 mpid=$!
 
-env LOTUS_PATH="${ldt0222}" LOTUS_STORAGE_PATH="${mdt0222}" ./lotus-storage-miner init                 --actor=t0222 --pre-sealed-sectors="${sdt0222}" --nosync=true --sector-size="${SECTOR_SIZE}" || true
-env LOTUS_PATH="${ldt0333}" LOTUS_STORAGE_PATH="${mdt0333}" ./lotus-storage-miner init                 --actor=t0333 --pre-sealed-sectors="${sdt0333}" --nosync=true --sector-size="${SECTOR_SIZE}" || true
+env LOTUS_PATH="${ldt0222}" LOTUS_MINER_PATH="${mdt0222}" ./lotus-miner init                 --actor=t0222 --pre-sealed-sectors="${sdt0222}" --pre-sealed-metadata="${sdt0222}/pre-seal-t0222.json" --nosync=true --sector-size="${SECTOR_SIZE}" || true
+env LOTUS_PATH="${ldt0333}" LOTUS_MINER_PATH="${mdt0333}" ./lotus-miner init                 --actor=t0333 --pre-sealed-sectors="${sdt0333}" --pre-sealed-metadata="${sdt0333}/pre-seal-t0333.json" --nosync=true --sector-size="${SECTOR_SIZE}" || true
 
 kill $mpid
 wait $mpid
diff --git a/scripts/lotus-chainwatch.service b/scripts/lotus-chainwatch.service
new file mode 100644
index 000000000..e121cb1d1
--- /dev/null
+++ b/scripts/lotus-chainwatch.service
@@ -0,0 +1,15 @@
+[Unit]
+Description=Chainwatch
+After=lotus-daemon.service
+Requires=lotus-daemon.service
+
+[Service]
+Environment=GOLOG_FILE="/var/log/lotus/chainwatch.log"
+Environment=GOLOG_LOG_FMT="json"
+Environment=LOTUS_DB=""
+Environment=LOTUS_PATH="%h/.lotus"
+EnvironmentFile=-/etc/lotus/chainwatch.env
+ExecStart=/usr/local/bin/lotus-chainwatch run
+
+[Install]
+WantedBy=multi-user.target
diff --git a/scripts/lotus-daemon.service b/scripts/lotus-daemon.service
index 44b2058b0..af35a027c 100644
--- a/scripts/lotus-daemon.service
+++ b/scripts/lotus-daemon.service
@@ -1,11 +1,19 @@
 [Unit]
 Description=Lotus Daemon
-After=network.target
+After=network-online.target
+Requires=network-online.target
 
 [Service]
-ExecStart=/usr/local/bin/lotus daemon
-Environment=GOLOG_FILE="/var/log/lotus-daemon"
+Environment=GOLOG_FILE="/var/log/lotus/daemon.log"
 Environment=GOLOG_LOG_FMT="json"
+ExecStart=/usr/local/bin/lotus daemon
+Restart=always
+RestartSec=10
+
+MemoryAccounting=true
+MemoryHigh=8G
+MemoryMax=10G
+LimitNOFILE=8192:10240
 
 [Install]
-WantedBy=multiuser.target
+WantedBy=multi-user.target
diff --git a/scripts/lotus-miner.service b/scripts/lotus-miner.service
index 7b866e043..54c48d411 100644
--- a/scripts/lotus-miner.service
+++ b/scripts/lotus-miner.service
@@ -1,12 +1,13 @@
 [Unit]
-Description=Lotus Storage Miner
+Description=Lotus Miner
 After=network.target
 After=lotus-daemon.service
+Wants=lotus-daemon.service
 
 [Service]
-ExecStart=/usr/local/bin/lotus-storage-miner run
-Environment=GOLOG_FILE="/var/log/lotus-miner"
+ExecStart=/usr/local/bin/lotus-miner run
+Environment=GOLOG_FILE="/var/log/lotus/miner.log"
 Environment=GOLOG_LOG_FMT="json"
 
 [Install]
-WantedBy=multiuser.target
+WantedBy=multi-user.target
diff --git a/scripts/make-completions.sh b/scripts/make-completions.sh
new file mode 100755
index 000000000..1bfd59bf3
--- /dev/null
+++ b/scripts/make-completions.sh
@@ -0,0 +1,9 @@
+#!/usr/bin/env bash
+
+# scripts/make-completions.sh [progname]
+
+echo '#!/usr/bin/env bash' > "scripts/bash-completion/$1"
+echo '#!/usr/bin/env zsh' > "scripts/zsh-completion/$1"
+
+$1 --init-completion=bash >> "scripts/bash-completion/$1"
+$1 --init-completion=zsh >> "scripts/zsh-completion/$1"
diff --git a/scripts/miner-mon.sh b/scripts/miner-mon.sh
new file mode 100755
index 000000000..8b6cc75c1
--- /dev/null
+++ b/scripts/miner-mon.sh
@@ -0,0 +1,23 @@
+#!/usr/bin/env bash
+
+SESSION=$(cat /proc/sys/kernel/random/uuid)
+
+tmux -2 new-session -d -s $SESSION
+
+tmux new-window -t $SESSION:1 -n 'Miner'
+
+tmux split-window -h
+
+tmux select-pane -t 0
+tmux send-keys "watch -n1 './lotus-miner info'" C-m
+
+tmux split-window -v
+
+tmux select-pane -t 1
+tmux send-keys "watch -n1 './lotus-miner workers list'" C-m
+
+tmux select-pane -t 2
+tmux send-keys "watch -n1 './lotus-miner storage list'" C-m
+
+
+tmux -2 attach-session -t $SESSION
diff --git a/scripts/publish-release.sh b/scripts/publish-release.sh
new file mode 100755
index 000000000..103de1f0f
--- /dev/null
+++ b/scripts/publish-release.sh
@@ -0,0 +1,94 @@
+#!/usr/bin/env bash
+set -e
+
+pushd bundle
+
+# make sure we have a token set, api requests won't work otherwise
+if [ -z "${GITHUB_TOKEN}" ]; then
+  echo "\${GITHUB_TOKEN} not set, publish failed"
+  exit 1
+fi
+
+REQUIRED=(
+    "jq"
+    "curl"
+)
+for REQUIRE in "${REQUIRED[@]}"
+do
+    command -v "${REQUIRE}" >/dev/null 2>&1 || echo >&2 "'${REQUIRE}' must be installed"
+done
+
+#see if the release already exists by tag
+RELEASE_RESPONSE=`
+  curl \
+    --header "Authorization: token ${GITHUB_TOKEN}" \
+    "https://api.github.com/repos/${CIRCLE_PROJECT_USERNAME}/${CIRCLE_PROJECT_REPONAME}/releases/tags/${CIRCLE_TAG}"
+`
+RELEASE_ID=`echo "${RELEASE_RESPONSE}" | jq '.id'`
+
+if [ "${RELEASE_ID}" = "null" ]; then
+  echo "creating release"
+
+  RELEASE_DATA="{
+    \"tag_name\": \"${CIRCLE_TAG}\",
+    \"target_commitish\": \"${CIRCLE_SHA1}\",
+    \"name\": \"${CIRCLE_TAG}\",
+    \"body\": \"\",
+    \"prerelease\": false
+  }"
+
+  # create it if it doesn't exist yet
+  RELEASE_RESPONSE=`
+    curl \
+        --request POST \
+        --header "Authorization: token ${GITHUB_TOKEN}" \
+        --header "Content-Type: application/json" \
+        --data "${RELEASE_DATA}" \
+        "https://api.github.com/repos/$CIRCLE_PROJECT_USERNAME/${CIRCLE_PROJECT_REPONAME}/releases"
+  `
+else
+  echo "release already exists"
+fi
+
+RELEASE_UPLOAD_URL=`echo "${RELEASE_RESPONSE}" | jq -r '.upload_url' | cut -d'{' -f1`
+
+bundles=(
+  "lotus_${CIRCLE_TAG}_linux-amd64.tar.gz"
+  "lotus_${CIRCLE_TAG}_linux-amd64.tar.gz.cid"
+  "lotus_${CIRCLE_TAG}_linux-amd64.tar.gz.sha512"
+  "lotus_${CIRCLE_TAG}_darwin-amd64.tar.gz"
+  "lotus_${CIRCLE_TAG}_darwin-amd64.tar.gz.cid"
+  "lotus_${CIRCLE_TAG}_darwin-amd64.tar.gz.sha512"
+)
+for RELEASE_FILE in "${bundles[@]}"
+do
+  echo "Uploading release bundle: ${RELEASE_FILE}"
+  curl \
+    --request POST \
+    --header "Authorization: token ${GITHUB_TOKEN}" \
+    --header "Content-Type: application/octet-stream" \
+    --data-binary "@${RELEASE_FILE}" \
+    "$RELEASE_UPLOAD_URL?name=$(basename "${RELEASE_FILE}")"
+
+  echo "Release bundle uploaded: ${RELEASE_FILE}"
+done
+
+popd
+
+miscellaneous=(
+  "README.md"
+  "LICENSE-MIT"
+  "LICENSE-APACHE"
+)
+for MISC in "${miscellaneous[@]}"
+do
+  echo "Uploading release bundle: ${MISC}"
+  curl \
+    --request POST \
+    --header "Authorization: token ${GITHUB_TOKEN}" \
+    --header "Content-Type: application/octet-stream" \
+    --data-binary "@${MISC}" \
+    "$RELEASE_UPLOAD_URL?name=$(basename "${MISC}")"
+
+  echo "Release bundle uploaded: ${MISC}"
+done
diff --git a/scripts/quick-network-join.bash b/scripts/quick-network-join.bash
new file mode 100755
index 000000000..c1ab1aa28
--- /dev/null
+++ b/scripts/quick-network-join.bash
@@ -0,0 +1,180 @@
+#!/usr/bin/env bash
+
+session="lotus-interop"
+wdaemon="daemon"
+wminer="miner"
+wsetup="setup"
+wpledging="pledging"
+wcli="cli"
+faucet="https://t01000.miner.interopnet.kittyhawk.wtf"
+
+PLEDGE_COUNT="${1:-20}"
+BRANCH="interopnet"
+BASEDIR=$(mktemp -d -t "lotus-interopnet.XXXX")
+
+git clone --branch "$BRANCH" https://github.com/filecoin-project/lotus.git "${BASEDIR}/build"
+
+mkdir -p "${BASEDIR}/scripts"
+mkdir -p "${BASEDIR}/bin"
+
+cat > "${BASEDIR}/scripts/build.bash" <<EOF
+#!/usr/bin/env bash
+set -x
+
+SCRIPTDIR="\$( cd "\$( dirname "\${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
+pushd \$SCRIPTDIR/../build
+
+pwd
+env RUSTFLAGS="-C target-cpu=native -g" FFI_BUILD_FROM_SOURCE=1 make clean deps lotus lotus-miner lotus-shed
+cp lotus lotus-miner lotus-shed ../bin/
+
+popd
+EOF
+
+cat > "${BASEDIR}/scripts/env.fish" <<EOF
+set -x PATH ${BASEDIR}/bin \$PATH
+set -x LOTUS_PATH ${BASEDIR}/.lotus
+set -x LOTUS_MINER_PATH ${BASEDIR}/.lotusminer
+EOF
+
+cat > "${BASEDIR}/scripts/env.bash" <<EOF
+export PATH=${BASEDIR}/bin:\$PATH
+export LOTUS_PATH=${BASEDIR}/.lotus
+export LOTUS_MINER_PATH=${BASEDIR}/.lotusminer
+EOF
+
+cat > "${BASEDIR}/scripts/create_miner.bash" <<EOF
+#!/usr/bin/env bash
+set -x
+
+owner=\$(lotus wallet new bls)
+result=\$(curl -D - -XPOST -F "sectorSize=536870912" -F "address=\$owner" $faucet/mkminer | grep Location)
+query_string=\$(grep -o "\bf=.*\b" <<<\$(echo \$result))
+
+declare -A param
+while IFS='=' read -r -d '&' key value && [[ -n "\$key" ]]; do
+    param["\$key"]=\$value
+done <<<"\${query_string}&"
+
+lotus state wait-msg "\${param[f]}"
+
+maddr=\$(curl "$faucet/msgwaitaddr?cid=\${param[f]}" | jq -r '.addr')
+
+lotus-miner init --actor=\$maddr --owner=\$owner
+EOF
+
+cat > "${BASEDIR}/scripts/pledge_sectors.bash" <<EOF
+#!/usr/bin/env bash
+
+set -x
+
+while [ ! -d ${BASEDIR}/.lotusminer ]; do
+  sleep 5
+done
+
+while [ ! -f ${BASEDIR}/.lotusminer/api ]; do
+  sleep 5
+done
+
+sleep 30
+
+sector=\$(lotus-miner sectors list | tail -n1 | awk '{print \$1}' | tr -d ':')
+current="\$sector"
+
+while true; do
+  if (( \$(lotus-miner sectors list | wc -l) > ${PLEDGE_COUNT} )); then
+    break
+  fi
+
+  while true; do
+    state=\$(lotus-miner sectors list | tail -n1 | awk '{print \$2}')
+
+    if [ -z "\$state" ]; then
+      break
+    fi
+
+    case \$state in
+      PreCommit1 | PreCommit2 | Packing | Unsealed | PreCommitting | Committing | CommitWait | FinalizeSector ) sleep 30 ;;
+      WaitSeed | Proving ) break ;;
+      * ) echo "Unknown Sector State: \$state"
+          lotus-miner sectors status --log \$current
+          break ;;
+    esac
+  done
+
+  lotus-miner sectors pledge
+
+  while [ "\$current" == "\$sector" ]; do
+    sector=\$(lotus-miner sectors list | tail -n1 | awk '{print \$1}' | tr -d ':')
+    sleep 5
+  done
+
+  current="\$sector"
+done
+EOF
+
+cat > "${BASEDIR}/scripts/monitor.bash" <<EOF
+#!/usr/bin/env bash
+
+while true; do
+  clear
+  lotus sync status
+
+  echo
+  echo
+  echo Miner Info
+  lotus-miner info
+
+  echo
+  echo
+  echo Sector List
+  lotus-miner sectors list | tail -n4
+
+  sleep 25
+
+  lotus-shed noncefix --addr \$(lotus wallet list) --auto
+
+done
+EOF
+
+chmod +x "${BASEDIR}/scripts/build.bash"
+chmod +x "${BASEDIR}/scripts/create_miner.bash"
+chmod +x "${BASEDIR}/scripts/pledge_sectors.bash"
+chmod +x "${BASEDIR}/scripts/monitor.bash"
+
+bash "${BASEDIR}/scripts/build.bash"
+
+tmux new-session -d -s $session -n $wsetup
+
+tmux set-environment -t $session BASEDIR "$BASEDIR"
+
+tmux new-window -t $session -n $wcli
+tmux new-window -t $session -n $wdaemon
+tmux new-window -t $session -n $wminer
+tmux new-window -t $session -n $wpledging
+
+tmux kill-window -t $session:$wsetup
+
+case $(basename $SHELL) in
+  fish ) shell=fish ;;
+  *    ) shell=bash ;;
+esac
+
+tmux send-keys -t $session:$wdaemon   "source ${BASEDIR}/scripts/env.$shell" C-m
+tmux send-keys -t $session:$wminer    "source ${BASEDIR}/scripts/env.$shell" C-m
+tmux send-keys -t $session:$wcli      "source ${BASEDIR}/scripts/env.$shell" C-m
+tmux send-keys -t $session:$wpledging "source ${BASEDIR}/scripts/env.$shell" C-m
+
+tmux send-keys -t $session:$wdaemon "lotus daemon --api 48010 daemon 2>&1 | tee -a ${BASEDIR}/daemon.log" C-m
+
+sleep 30
+
+tmux send-keys -t $session:$wminer   "${BASEDIR}/scripts/create_miner.bash" C-m
+tmux send-keys -t $session:$wminer   "lotus-miner run --api 48020 2>&1 | tee -a ${BASEDIR}/miner.log" C-m
+tmux send-keys -t $session:$wcli     "${BASEDIR}/scripts/monitor.bash" C-m
+tmux send-keys -t $session:$wpleding "${BASEDIR}/scripts/pledge_sectors.bash" C-m
+
+tmux select-window -t $session:$wcli
+
+tmux attach-session -t $session
+
diff --git a/scripts/setup-host.sh b/scripts/setup-host.sh
index bda0a2c98..fe36be8fa 100755
--- a/scripts/setup-host.sh
+++ b/scripts/setup-host.sh
@@ -3,4 +3,4 @@
 HOST=$1
 
 scp scripts/lotus-daemon.service "${HOST}:/etc/systemd/system/lotus-daemon.service"
-scp scripts/lotus-miner.service "${HOST}:/etc/systemd/system/lotus-storage-miner.service"
+scp scripts/lotus-miner.service "${HOST}:/etc/systemd/system/lotus-miner.service"
diff --git a/scripts/zsh-completion/lotus b/scripts/zsh-completion/lotus
new file mode 100644
index 000000000..bbd886ae4
--- /dev/null
+++ b/scripts/zsh-completion/lotus
@@ -0,0 +1,12 @@
+#!/usr/bin/env zsh
+autoload -U compinit && compinit;
+autoload -U bashcompinit && bashcompinit;
+_cli_bash_autocomplete() {
+     local cur opts base;
+     COMPREPLY=();
+     cur="${COMP_WORDS[COMP_CWORD]}";
+     opts=$( ${COMP_WORDS[@]:0:$COMP_CWORD} --generate-completion );
+     COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) );
+     return 0;
+};
+complete -F _cli_bash_autocomplete lotus
\ No newline at end of file
diff --git a/scripts/zsh-completion/lotus-miner b/scripts/zsh-completion/lotus-miner
new file mode 100644
index 000000000..3e23749e6
--- /dev/null
+++ b/scripts/zsh-completion/lotus-miner
@@ -0,0 +1,12 @@
+#!/usr/bin/env zsh
+autoload -U compinit && compinit;
+autoload -U bashcompinit && bashcompinit;
+_cli_bash_autocomplete() {
+     local cur opts base;
+     COMPREPLY=();
+     cur="${COMP_WORDS[COMP_CWORD]}";
+     opts=$( ${COMP_WORDS[@]:0:$COMP_CWORD} --generate-completion );
+     COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) );
+     return 0;
+};
+complete -F _cli_bash_autocomplete lotus-miner
\ No newline at end of file
diff --git a/storage/adapter_events.go b/storage/adapter_events.go
new file mode 100644
index 000000000..ff69c1e51
--- /dev/null
+++ b/storage/adapter_events.go
@@ -0,0 +1,29 @@
+package storage
+
+import (
+	"context"
+
+	"github.com/filecoin-project/go-state-types/abi"
+
+	"github.com/filecoin-project/lotus/chain/events"
+	"github.com/filecoin-project/lotus/chain/types"
+	sealing "github.com/filecoin-project/lotus/extern/storage-sealing"
+)
+
+var _ sealing.Events = new(EventsAdapter)
+
+type EventsAdapter struct {
+	delegate *events.Events
+}
+
+func NewEventsAdapter(api *events.Events) EventsAdapter {
+	return EventsAdapter{delegate: api}
+}
+
+func (e EventsAdapter) ChainAt(hnd sealing.HeightHandler, rev sealing.RevertHandler, confidence int, h abi.ChainEpoch) error {
+	return e.delegate.ChainAt(func(ctx context.Context, ts *types.TipSet, curH abi.ChainEpoch) error {
+		return hnd(ctx, ts.Key().Bytes(), curH)
+	}, func(ctx context.Context, ts *types.TipSet) error {
+		return rev(ctx, ts.Key().Bytes())
+	}, confidence, h)
+}
diff --git a/storage/adapter_storage_miner.go b/storage/adapter_storage_miner.go
new file mode 100644
index 000000000..380fb4471
--- /dev/null
+++ b/storage/adapter_storage_miner.go
@@ -0,0 +1,307 @@
+package storage
+
+import (
+	"bytes"
+	"context"
+
+	"github.com/filecoin-project/go-state-types/network"
+
+	"github.com/ipfs/go-cid"
+	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/big"
+	"github.com/filecoin-project/go-state-types/crypto"
+
+	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
+	market0 "github.com/filecoin-project/specs-actors/actors/builtin/market"
+
+	"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"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/market"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
+	"github.com/filecoin-project/lotus/chain/store"
+	"github.com/filecoin-project/lotus/chain/types"
+	sealing "github.com/filecoin-project/lotus/extern/storage-sealing"
+)
+
+var _ sealing.SealingAPI = new(SealingAPIAdapter)
+
+type SealingAPIAdapter struct {
+	delegate storageMinerApi
+}
+
+func NewSealingAPIAdapter(api storageMinerApi) SealingAPIAdapter {
+	return SealingAPIAdapter{delegate: api}
+}
+
+func (s SealingAPIAdapter) StateMinerSectorSize(ctx context.Context, maddr address.Address, tok sealing.TipSetToken) (abi.SectorSize, error) {
+	tsk, err := types.TipSetKeyFromBytes(tok)
+	if err != nil {
+		return 0, xerrors.Errorf("failed to unmarshal TipSetToken to TipSetKey: %w", err)
+	}
+
+	// TODO: update storage-fsm to just StateMinerInfo
+	mi, err := s.delegate.StateMinerInfo(ctx, maddr, tsk)
+	if err != nil {
+		return 0, err
+	}
+	return mi.SectorSize, nil
+}
+
+func (s SealingAPIAdapter) StateMinerPreCommitDepositForPower(ctx context.Context, a address.Address, pci miner.SectorPreCommitInfo, tok sealing.TipSetToken) (big.Int, error) {
+	tsk, err := types.TipSetKeyFromBytes(tok)
+	if err != nil {
+		return big.Zero(), xerrors.Errorf("failed to unmarshal TipSetToken to TipSetKey: %w", err)
+	}
+
+	return s.delegate.StateMinerPreCommitDepositForPower(ctx, a, pci, tsk)
+}
+
+func (s SealingAPIAdapter) StateMinerInitialPledgeCollateral(ctx context.Context, a address.Address, pci miner.SectorPreCommitInfo, tok sealing.TipSetToken) (big.Int, error) {
+	tsk, err := types.TipSetKeyFromBytes(tok)
+	if err != nil {
+		return big.Zero(), xerrors.Errorf("failed to unmarshal TipSetToken to TipSetKey: %w", err)
+	}
+
+	return s.delegate.StateMinerInitialPledgeCollateral(ctx, a, pci, tsk)
+}
+
+func (s SealingAPIAdapter) StateMinerWorkerAddress(ctx context.Context, maddr address.Address, tok sealing.TipSetToken) (address.Address, error) {
+	tsk, err := types.TipSetKeyFromBytes(tok)
+	if err != nil {
+		return address.Undef, xerrors.Errorf("failed to unmarshal TipSetToken to TipSetKey: %w", err)
+	}
+
+	// TODO: update storage-fsm to just StateMinerInfo
+	mi, err := s.delegate.StateMinerInfo(ctx, maddr, tsk)
+	if err != nil {
+		return address.Undef, err
+	}
+	return mi.Worker, nil
+}
+
+func (s SealingAPIAdapter) StateMinerDeadlines(ctx context.Context, maddr address.Address, tok sealing.TipSetToken) ([]api.Deadline, error) {
+	tsk, err := types.TipSetKeyFromBytes(tok)
+	if err != nil {
+		return nil, xerrors.Errorf("failed to unmarshal TipSetToken to TipSetKey: %w", err)
+	}
+
+	return s.delegate.StateMinerDeadlines(ctx, maddr, tsk)
+}
+
+func (s SealingAPIAdapter) StateWaitMsg(ctx context.Context, mcid cid.Cid) (sealing.MsgLookup, error) {
+	wmsg, err := s.delegate.StateWaitMsg(ctx, mcid, build.MessageConfidence)
+	if err != nil {
+		return sealing.MsgLookup{}, err
+	}
+
+	return sealing.MsgLookup{
+		Receipt: sealing.MessageReceipt{
+			ExitCode: wmsg.Receipt.ExitCode,
+			Return:   wmsg.Receipt.Return,
+			GasUsed:  wmsg.Receipt.GasUsed,
+		},
+		TipSetTok: wmsg.TipSet.Bytes(),
+		Height:    wmsg.Height,
+	}, nil
+}
+
+func (s SealingAPIAdapter) StateSearchMsg(ctx context.Context, c cid.Cid) (*sealing.MsgLookup, error) {
+	wmsg, err := s.delegate.StateSearchMsg(ctx, c)
+	if err != nil {
+		return nil, err
+	}
+
+	if wmsg == nil {
+		return nil, nil
+	}
+
+	return &sealing.MsgLookup{
+		Receipt: sealing.MessageReceipt{
+			ExitCode: wmsg.Receipt.ExitCode,
+			Return:   wmsg.Receipt.Return,
+			GasUsed:  wmsg.Receipt.GasUsed,
+		},
+		TipSetTok: wmsg.TipSet.Bytes(),
+		Height:    wmsg.Height,
+	}, nil
+}
+
+func (s SealingAPIAdapter) StateComputeDataCommitment(ctx context.Context, maddr address.Address, sectorType abi.RegisteredSealProof, deals []abi.DealID, tok sealing.TipSetToken) (cid.Cid, error) {
+	tsk, err := types.TipSetKeyFromBytes(tok)
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("failed to unmarshal TipSetToken to TipSetKey: %w", err)
+	}
+
+	ccparams, err := actors.SerializeParams(&market0.ComputeDataCommitmentParams{
+		DealIDs:    deals,
+		SectorType: sectorType,
+	})
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("computing params for ComputeDataCommitment: %w", err)
+	}
+
+	ccmt := &types.Message{
+		To:     market.Address,
+		From:   maddr,
+		Value:  types.NewInt(0),
+		Method: builtin0.MethodsMarket.ComputeDataCommitment,
+		Params: ccparams,
+	}
+	r, err := s.delegate.StateCall(ctx, ccmt, tsk)
+	if err != nil {
+		return cid.Undef, xerrors.Errorf("calling ComputeDataCommitment: %w", err)
+	}
+	if r.MsgRct.ExitCode != 0 {
+		return cid.Undef, xerrors.Errorf("receipt for ComputeDataCommitment had exit code %d", r.MsgRct.ExitCode)
+	}
+
+	var c cbg.CborCid
+	if err := c.UnmarshalCBOR(bytes.NewReader(r.MsgRct.Return)); err != nil {
+		return cid.Undef, xerrors.Errorf("failed to unmarshal CBOR to CborCid: %w", err)
+	}
+
+	return cid.Cid(c), nil
+}
+
+func (s SealingAPIAdapter) StateSectorPreCommitInfo(ctx context.Context, maddr address.Address, sectorNumber abi.SectorNumber, tok sealing.TipSetToken) (*miner.SectorPreCommitOnChainInfo, error) {
+	tsk, err := types.TipSetKeyFromBytes(tok)
+	if err != nil {
+		return nil, xerrors.Errorf("failed to unmarshal TipSetToken to TipSetKey: %w", err)
+	}
+
+	act, err := s.delegate.StateGetActor(ctx, maddr, tsk)
+	if err != nil {
+		return nil, xerrors.Errorf("handleSealFailed(%d): temp error: %+v", sectorNumber, err)
+	}
+
+	stor := store.ActorStore(ctx, apibstore.NewAPIBlockstore(s.delegate))
+
+	state, err := miner.Load(stor, act)
+	if err != nil {
+		return nil, xerrors.Errorf("handleSealFailed(%d): temp error: loading miner state: %+v", sectorNumber, err)
+	}
+
+	pci, err := state.GetPrecommittedSector(sectorNumber)
+	if err != nil {
+		return nil, err
+	}
+	if pci == nil {
+		set, err := state.IsAllocated(sectorNumber)
+		if err != nil {
+			return nil, xerrors.Errorf("checking if sector is allocated: %w", err)
+		}
+		if set {
+			return nil, sealing.ErrSectorAllocated
+		}
+
+		return nil, nil
+	}
+
+	return pci, nil
+}
+
+func (s SealingAPIAdapter) StateSectorGetInfo(ctx context.Context, maddr address.Address, sectorNumber abi.SectorNumber, tok sealing.TipSetToken) (*miner.SectorOnChainInfo, error) {
+	tsk, err := types.TipSetKeyFromBytes(tok)
+	if err != nil {
+		return nil, xerrors.Errorf("failed to unmarshal TipSetToken to TipSetKey: %w", err)
+	}
+
+	return s.delegate.StateSectorGetInfo(ctx, maddr, sectorNumber, tsk)
+}
+
+func (s SealingAPIAdapter) StateSectorPartition(ctx context.Context, maddr address.Address, sectorNumber abi.SectorNumber, tok sealing.TipSetToken) (*sealing.SectorLocation, error) {
+	tsk, err := types.TipSetKeyFromBytes(tok)
+	if err != nil {
+		return nil, xerrors.Errorf("failed to unmarshal TipSetToken to TipSetKey: %w", err)
+	}
+
+	l, err := s.delegate.StateSectorPartition(ctx, maddr, sectorNumber, tsk)
+	if err != nil {
+		return nil, err
+	}
+	if l != nil {
+		return &sealing.SectorLocation{
+			Deadline:  l.Deadline,
+			Partition: l.Partition,
+		}, nil
+	}
+
+	return nil, nil // not found
+}
+
+func (s SealingAPIAdapter) StateMarketStorageDeal(ctx context.Context, dealID abi.DealID, tok sealing.TipSetToken) (market.DealProposal, error) {
+	tsk, err := types.TipSetKeyFromBytes(tok)
+	if err != nil {
+		return market.DealProposal{}, err
+	}
+
+	deal, err := s.delegate.StateMarketStorageDeal(ctx, dealID, tsk)
+	if err != nil {
+		return market.DealProposal{}, err
+	}
+
+	return deal.Proposal, nil
+}
+
+func (s SealingAPIAdapter) StateNetworkVersion(ctx context.Context, tok sealing.TipSetToken) (network.Version, error) {
+	tsk, err := types.TipSetKeyFromBytes(tok)
+	if err != nil {
+		return network.VersionMax, err
+	}
+
+	return s.delegate.StateNetworkVersion(ctx, tsk)
+}
+
+func (s SealingAPIAdapter) SendMsg(ctx context.Context, from, to address.Address, method abi.MethodNum, value, maxFee abi.TokenAmount, params []byte) (cid.Cid, error) {
+	msg := types.Message{
+		To:     to,
+		From:   from,
+		Value:  value,
+		Method: method,
+		Params: params,
+	}
+
+	smsg, err := s.delegate.MpoolPushMessage(ctx, &msg, &api.MessageSendSpec{MaxFee: maxFee})
+	if err != nil {
+		return cid.Undef, err
+	}
+
+	return smsg.Cid(), nil
+}
+
+func (s SealingAPIAdapter) ChainHead(ctx context.Context) (sealing.TipSetToken, abi.ChainEpoch, error) {
+	head, err := s.delegate.ChainHead(ctx)
+	if err != nil {
+		return nil, 0, err
+	}
+
+	return head.Key().Bytes(), head.Height(), nil
+}
+
+func (s SealingAPIAdapter) ChainGetRandomnessFromBeacon(ctx context.Context, tok sealing.TipSetToken, personalization crypto.DomainSeparationTag, randEpoch abi.ChainEpoch, entropy []byte) (abi.Randomness, error) {
+	tsk, err := types.TipSetKeyFromBytes(tok)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.delegate.ChainGetRandomnessFromBeacon(ctx, tsk, personalization, randEpoch, entropy)
+}
+
+func (s SealingAPIAdapter) ChainGetRandomnessFromTickets(ctx context.Context, tok sealing.TipSetToken, personalization crypto.DomainSeparationTag, randEpoch abi.ChainEpoch, entropy []byte) (abi.Randomness, error) {
+	tsk, err := types.TipSetKeyFromBytes(tok)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.delegate.ChainGetRandomnessFromTickets(ctx, tsk, personalization, randEpoch, entropy)
+}
+
+func (s SealingAPIAdapter) ChainReadObj(ctx context.Context, ocid cid.Cid) ([]byte, error) {
+	return s.delegate.ChainReadObj(ctx, ocid)
+}
diff --git a/storage/addresses.go b/storage/addresses.go
new file mode 100644
index 000000000..f5640794e
--- /dev/null
+++ b/storage/addresses.go
@@ -0,0 +1,94 @@
+package storage
+
+import (
+	"context"
+
+	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
+
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/abi"
+
+	"github.com/filecoin-project/lotus/chain/types"
+)
+
+type AddrUse int
+
+const (
+	PreCommitAddr AddrUse = iota
+	CommitAddr
+	PoStAddr
+)
+
+type addrSelectApi interface {
+	WalletBalance(context.Context, address.Address) (types.BigInt, error)
+	WalletHas(context.Context, address.Address) (bool, error)
+
+	StateAccountKey(context.Context, address.Address, types.TipSetKey) (address.Address, error)
+}
+
+func AddressFor(ctx context.Context, a addrSelectApi, mi miner.MinerInfo, use AddrUse, minFunds abi.TokenAmount) (address.Address, error) {
+	switch use {
+	case PreCommitAddr, CommitAddr:
+		// always use worker, at least for now
+		return mi.Worker, nil
+	}
+
+	for _, addr := range mi.ControlAddresses {
+		b, err := a.WalletBalance(ctx, addr)
+		if err != nil {
+			return address.Undef, xerrors.Errorf("checking control address balance: %w", err)
+		}
+
+		if b.GreaterThanEqual(minFunds) {
+			k, err := a.StateAccountKey(ctx, addr, types.EmptyTSK)
+			if err != nil {
+				log.Errorw("getting account key", "error", err)
+				continue
+			}
+
+			have, err := a.WalletHas(ctx, k)
+			if err != nil {
+				return address.Undef, xerrors.Errorf("failed to check control address: %w", err)
+			}
+
+			if !have {
+				log.Errorw("don't have key", "key", k)
+				continue
+			}
+
+			return addr, nil
+		}
+
+		log.Warnw("control address didn't have enough funds for window post message", "address", addr, "required", types.FIL(minFunds), "balance", types.FIL(b))
+	}
+
+	// Try to use the owner account if we can, fallback to worker if we can't
+
+	b, err := a.WalletBalance(ctx, mi.Owner)
+	if err != nil {
+		return address.Undef, xerrors.Errorf("checking owner balance: %w", err)
+	}
+
+	if !b.GreaterThanEqual(minFunds) {
+		return mi.Worker, nil
+	}
+
+	k, err := a.StateAccountKey(ctx, mi.Owner, types.EmptyTSK)
+	if err != nil {
+		log.Errorw("getting owner account key", "error", err)
+		return mi.Worker, nil
+	}
+
+	have, err := a.WalletHas(ctx, k)
+	if err != nil {
+		return address.Undef, xerrors.Errorf("failed to check owner address: %w", err)
+	}
+
+	if !have {
+		return mi.Worker, nil
+	}
+
+	return mi.Owner, nil
+}
diff --git a/storage/cbor_gen.go b/storage/cbor_gen.go
deleted file mode 100644
index 43262ad2b..000000000
--- a/storage/cbor_gen.go
+++ /dev/null
@@ -1,980 +0,0 @@
-package storage
-
-import (
-	"fmt"
-	"io"
-
-	cbg "github.com/whyrusleeping/cbor-gen"
-	xerrors "golang.org/x/xerrors"
-)
-
-// Code generated by github.com/whyrusleeping/cbor-gen. DO NOT EDIT.
-
-var _ = xerrors.Errorf
-
-func (t *SealTicket) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{162}); err != nil {
-		return err
-	}
-
-	// t.BlockHeight (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len("BlockHeight")))); err != nil {
-		return err
-	}
-	if _, err := w.Write([]byte("BlockHeight")); err != nil {
-		return err
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.BlockHeight))); err != nil {
-		return err
-	}
-
-	// t.TicketBytes ([]uint8) (slice)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len("TicketBytes")))); err != nil {
-		return err
-	}
-	if _, err := w.Write([]byte("TicketBytes")); err != nil {
-		return err
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajByteString, uint64(len(t.TicketBytes)))); err != nil {
-		return err
-	}
-	if _, err := w.Write(t.TicketBytes); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *SealTicket) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajMap {
-		return fmt.Errorf("cbor input should be of type map")
-	}
-
-	if extra != 2 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	var name string
-
-	// t.BlockHeight (uint64) (uint64)
-
-	{
-		sval, err := cbg.ReadString(br)
-		if err != nil {
-			return err
-		}
-
-		name = string(sval)
-	}
-
-	if name != "BlockHeight" {
-		return fmt.Errorf("expected struct map entry %s to be BlockHeight", name)
-	}
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.BlockHeight = uint64(extra)
-	// t.TicketBytes ([]uint8) (slice)
-
-	{
-		sval, err := cbg.ReadString(br)
-		if err != nil {
-			return err
-		}
-
-		name = string(sval)
-	}
-
-	if name != "TicketBytes" {
-		return fmt.Errorf("expected struct map entry %s to be TicketBytes", name)
-	}
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-
-	if extra > cbg.ByteArrayMaxLen {
-		return fmt.Errorf("t.TicketBytes: byte array too large (%d)", extra)
-	}
-	if maj != cbg.MajByteString {
-		return fmt.Errorf("expected byte array")
-	}
-	t.TicketBytes = make([]byte, extra)
-	if _, err := io.ReadFull(br, t.TicketBytes); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *SealSeed) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{162}); err != nil {
-		return err
-	}
-
-	// t.BlockHeight (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len("BlockHeight")))); err != nil {
-		return err
-	}
-	if _, err := w.Write([]byte("BlockHeight")); err != nil {
-		return err
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.BlockHeight))); err != nil {
-		return err
-	}
-
-	// t.TicketBytes ([]uint8) (slice)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len("TicketBytes")))); err != nil {
-		return err
-	}
-	if _, err := w.Write([]byte("TicketBytes")); err != nil {
-		return err
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajByteString, uint64(len(t.TicketBytes)))); err != nil {
-		return err
-	}
-	if _, err := w.Write(t.TicketBytes); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *SealSeed) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajMap {
-		return fmt.Errorf("cbor input should be of type map")
-	}
-
-	if extra != 2 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	var name string
-
-	// t.BlockHeight (uint64) (uint64)
-
-	{
-		sval, err := cbg.ReadString(br)
-		if err != nil {
-			return err
-		}
-
-		name = string(sval)
-	}
-
-	if name != "BlockHeight" {
-		return fmt.Errorf("expected struct map entry %s to be BlockHeight", name)
-	}
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.BlockHeight = uint64(extra)
-	// t.TicketBytes ([]uint8) (slice)
-
-	{
-		sval, err := cbg.ReadString(br)
-		if err != nil {
-			return err
-		}
-
-		name = string(sval)
-	}
-
-	if name != "TicketBytes" {
-		return fmt.Errorf("expected struct map entry %s to be TicketBytes", name)
-	}
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-
-	if extra > cbg.ByteArrayMaxLen {
-		return fmt.Errorf("t.TicketBytes: byte array too large (%d)", extra)
-	}
-	if maj != cbg.MajByteString {
-		return fmt.Errorf("expected byte array")
-	}
-	t.TicketBytes = make([]byte, extra)
-	if _, err := io.ReadFull(br, t.TicketBytes); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *Piece) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{163}); err != nil {
-		return err
-	}
-
-	// t.DealID (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len("DealID")))); err != nil {
-		return err
-	}
-	if _, err := w.Write([]byte("DealID")); err != nil {
-		return err
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.DealID))); err != nil {
-		return err
-	}
-
-	// t.Size (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len("Size")))); err != nil {
-		return err
-	}
-	if _, err := w.Write([]byte("Size")); err != nil {
-		return err
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.Size))); err != nil {
-		return err
-	}
-
-	// t.CommP ([]uint8) (slice)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len("CommP")))); err != nil {
-		return err
-	}
-	if _, err := w.Write([]byte("CommP")); err != nil {
-		return err
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajByteString, uint64(len(t.CommP)))); err != nil {
-		return err
-	}
-	if _, err := w.Write(t.CommP); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *Piece) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajMap {
-		return fmt.Errorf("cbor input should be of type map")
-	}
-
-	if extra != 3 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	var name string
-
-	// t.DealID (uint64) (uint64)
-
-	{
-		sval, err := cbg.ReadString(br)
-		if err != nil {
-			return err
-		}
-
-		name = string(sval)
-	}
-
-	if name != "DealID" {
-		return fmt.Errorf("expected struct map entry %s to be DealID", name)
-	}
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.DealID = uint64(extra)
-	// t.Size (uint64) (uint64)
-
-	{
-		sval, err := cbg.ReadString(br)
-		if err != nil {
-			return err
-		}
-
-		name = string(sval)
-	}
-
-	if name != "Size" {
-		return fmt.Errorf("expected struct map entry %s to be Size", name)
-	}
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.Size = uint64(extra)
-	// t.CommP ([]uint8) (slice)
-
-	{
-		sval, err := cbg.ReadString(br)
-		if err != nil {
-			return err
-		}
-
-		name = string(sval)
-	}
-
-	if name != "CommP" {
-		return fmt.Errorf("expected struct map entry %s to be CommP", name)
-	}
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-
-	if extra > cbg.ByteArrayMaxLen {
-		return fmt.Errorf("t.CommP: byte array too large (%d)", extra)
-	}
-	if maj != cbg.MajByteString {
-		return fmt.Errorf("expected byte array")
-	}
-	t.CommP = make([]byte, extra)
-	if _, err := io.ReadFull(br, t.CommP); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *SectorInfo) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
-	if _, err := w.Write([]byte{173}); err != nil {
-		return err
-	}
-
-	// t.State (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len("State")))); err != nil {
-		return err
-	}
-	if _, err := w.Write([]byte("State")); err != nil {
-		return err
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.State))); err != nil {
-		return err
-	}
-
-	// t.SectorID (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len("SectorID")))); err != nil {
-		return err
-	}
-	if _, err := w.Write([]byte("SectorID")); err != nil {
-		return err
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.SectorID))); err != nil {
-		return err
-	}
-
-	// t.Nonce (uint64) (uint64)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len("Nonce")))); err != nil {
-		return err
-	}
-	if _, err := w.Write([]byte("Nonce")); err != nil {
-		return err
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajUnsignedInt, uint64(t.Nonce))); err != nil {
-		return err
-	}
-
-	// t.Pieces ([]storage.Piece) (slice)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len("Pieces")))); err != nil {
-		return err
-	}
-	if _, err := w.Write([]byte("Pieces")); err != nil {
-		return err
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajArray, uint64(len(t.Pieces)))); err != nil {
-		return err
-	}
-	for _, v := range t.Pieces {
-		if err := v.MarshalCBOR(w); err != nil {
-			return err
-		}
-	}
-
-	// t.CommD ([]uint8) (slice)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len("CommD")))); err != nil {
-		return err
-	}
-	if _, err := w.Write([]byte("CommD")); err != nil {
-		return err
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajByteString, uint64(len(t.CommD)))); err != nil {
-		return err
-	}
-	if _, err := w.Write(t.CommD); err != nil {
-		return err
-	}
-
-	// t.CommR ([]uint8) (slice)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len("CommR")))); err != nil {
-		return err
-	}
-	if _, err := w.Write([]byte("CommR")); err != nil {
-		return err
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajByteString, uint64(len(t.CommR)))); err != nil {
-		return err
-	}
-	if _, err := w.Write(t.CommR); err != nil {
-		return err
-	}
-
-	// t.Proof ([]uint8) (slice)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len("Proof")))); err != nil {
-		return err
-	}
-	if _, err := w.Write([]byte("Proof")); err != nil {
-		return err
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajByteString, uint64(len(t.Proof)))); err != nil {
-		return err
-	}
-	if _, err := w.Write(t.Proof); err != nil {
-		return err
-	}
-
-	// t.Ticket (storage.SealTicket) (struct)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len("Ticket")))); err != nil {
-		return err
-	}
-	if _, err := w.Write([]byte("Ticket")); err != nil {
-		return err
-	}
-
-	if err := t.Ticket.MarshalCBOR(w); err != nil {
-		return err
-	}
-
-	// t.PreCommitMessage (cid.Cid) (struct)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len("PreCommitMessage")))); err != nil {
-		return err
-	}
-	if _, err := w.Write([]byte("PreCommitMessage")); err != nil {
-		return err
-	}
-
-	if t.PreCommitMessage == nil {
-		if _, err := w.Write(cbg.CborNull); err != nil {
-			return err
-		}
-	} else {
-		if err := cbg.WriteCid(w, *t.PreCommitMessage); err != nil {
-			return xerrors.Errorf("failed to write cid field t.PreCommitMessage: %w", err)
-		}
-	}
-
-	// t.Seed (storage.SealSeed) (struct)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len("Seed")))); err != nil {
-		return err
-	}
-	if _, err := w.Write([]byte("Seed")); err != nil {
-		return err
-	}
-
-	if err := t.Seed.MarshalCBOR(w); err != nil {
-		return err
-	}
-
-	// t.CommitMessage (cid.Cid) (struct)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len("CommitMessage")))); err != nil {
-		return err
-	}
-	if _, err := w.Write([]byte("CommitMessage")); err != nil {
-		return err
-	}
-
-	if t.CommitMessage == nil {
-		if _, err := w.Write(cbg.CborNull); err != nil {
-			return err
-		}
-	} else {
-		if err := cbg.WriteCid(w, *t.CommitMessage); err != nil {
-			return xerrors.Errorf("failed to write cid field t.CommitMessage: %w", err)
-		}
-	}
-
-	// t.FaultReportMsg (cid.Cid) (struct)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len("FaultReportMsg")))); err != nil {
-		return err
-	}
-	if _, err := w.Write([]byte("FaultReportMsg")); err != nil {
-		return err
-	}
-
-	if t.FaultReportMsg == nil {
-		if _, err := w.Write(cbg.CborNull); err != nil {
-			return err
-		}
-	} else {
-		if err := cbg.WriteCid(w, *t.FaultReportMsg); err != nil {
-			return xerrors.Errorf("failed to write cid field t.FaultReportMsg: %w", err)
-		}
-	}
-
-	// t.LastErr (string) (string)
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len("LastErr")))); err != nil {
-		return err
-	}
-	if _, err := w.Write([]byte("LastErr")); err != nil {
-		return err
-	}
-
-	if _, err := w.Write(cbg.CborEncodeMajorType(cbg.MajTextString, uint64(len(t.LastErr)))); err != nil {
-		return err
-	}
-	if _, err := w.Write([]byte(t.LastErr)); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *SectorInfo) UnmarshalCBOR(r io.Reader) error {
-	br := cbg.GetPeeker(r)
-
-	maj, extra, err := cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajMap {
-		return fmt.Errorf("cbor input should be of type map")
-	}
-
-	if extra != 13 {
-		return fmt.Errorf("cbor input had wrong number of fields")
-	}
-
-	var name string
-
-	// t.State (uint64) (uint64)
-
-	{
-		sval, err := cbg.ReadString(br)
-		if err != nil {
-			return err
-		}
-
-		name = string(sval)
-	}
-
-	if name != "State" {
-		return fmt.Errorf("expected struct map entry %s to be State", name)
-	}
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.State = uint64(extra)
-	// t.SectorID (uint64) (uint64)
-
-	{
-		sval, err := cbg.ReadString(br)
-		if err != nil {
-			return err
-		}
-
-		name = string(sval)
-	}
-
-	if name != "SectorID" {
-		return fmt.Errorf("expected struct map entry %s to be SectorID", name)
-	}
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.SectorID = uint64(extra)
-	// t.Nonce (uint64) (uint64)
-
-	{
-		sval, err := cbg.ReadString(br)
-		if err != nil {
-			return err
-		}
-
-		name = string(sval)
-	}
-
-	if name != "Nonce" {
-		return fmt.Errorf("expected struct map entry %s to be Nonce", name)
-	}
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-	if maj != cbg.MajUnsignedInt {
-		return fmt.Errorf("wrong type for uint64 field")
-	}
-	t.Nonce = uint64(extra)
-	// t.Pieces ([]storage.Piece) (slice)
-
-	{
-		sval, err := cbg.ReadString(br)
-		if err != nil {
-			return err
-		}
-
-		name = string(sval)
-	}
-
-	if name != "Pieces" {
-		return fmt.Errorf("expected struct map entry %s to be Pieces", name)
-	}
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-
-	if extra > cbg.MaxLength {
-		return fmt.Errorf("t.Pieces: array too large (%d)", extra)
-	}
-
-	if maj != cbg.MajArray {
-		return fmt.Errorf("expected cbor array")
-	}
-	if extra > 0 {
-		t.Pieces = make([]Piece, extra)
-	}
-	for i := 0; i < int(extra); i++ {
-
-		var v Piece
-		if err := v.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-		t.Pieces[i] = v
-	}
-
-	// t.CommD ([]uint8) (slice)
-
-	{
-		sval, err := cbg.ReadString(br)
-		if err != nil {
-			return err
-		}
-
-		name = string(sval)
-	}
-
-	if name != "CommD" {
-		return fmt.Errorf("expected struct map entry %s to be CommD", name)
-	}
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-
-	if extra > cbg.ByteArrayMaxLen {
-		return fmt.Errorf("t.CommD: byte array too large (%d)", extra)
-	}
-	if maj != cbg.MajByteString {
-		return fmt.Errorf("expected byte array")
-	}
-	t.CommD = make([]byte, extra)
-	if _, err := io.ReadFull(br, t.CommD); err != nil {
-		return err
-	}
-	// t.CommR ([]uint8) (slice)
-
-	{
-		sval, err := cbg.ReadString(br)
-		if err != nil {
-			return err
-		}
-
-		name = string(sval)
-	}
-
-	if name != "CommR" {
-		return fmt.Errorf("expected struct map entry %s to be CommR", name)
-	}
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-
-	if extra > cbg.ByteArrayMaxLen {
-		return fmt.Errorf("t.CommR: byte array too large (%d)", extra)
-	}
-	if maj != cbg.MajByteString {
-		return fmt.Errorf("expected byte array")
-	}
-	t.CommR = make([]byte, extra)
-	if _, err := io.ReadFull(br, t.CommR); err != nil {
-		return err
-	}
-	// t.Proof ([]uint8) (slice)
-
-	{
-		sval, err := cbg.ReadString(br)
-		if err != nil {
-			return err
-		}
-
-		name = string(sval)
-	}
-
-	if name != "Proof" {
-		return fmt.Errorf("expected struct map entry %s to be Proof", name)
-	}
-
-	maj, extra, err = cbg.CborReadHeader(br)
-	if err != nil {
-		return err
-	}
-
-	if extra > cbg.ByteArrayMaxLen {
-		return fmt.Errorf("t.Proof: byte array too large (%d)", extra)
-	}
-	if maj != cbg.MajByteString {
-		return fmt.Errorf("expected byte array")
-	}
-	t.Proof = make([]byte, extra)
-	if _, err := io.ReadFull(br, t.Proof); err != nil {
-		return err
-	}
-	// t.Ticket (storage.SealTicket) (struct)
-
-	{
-		sval, err := cbg.ReadString(br)
-		if err != nil {
-			return err
-		}
-
-		name = string(sval)
-	}
-
-	if name != "Ticket" {
-		return fmt.Errorf("expected struct map entry %s to be Ticket", name)
-	}
-
-	{
-
-		if err := t.Ticket.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-	}
-	// t.PreCommitMessage (cid.Cid) (struct)
-
-	{
-		sval, err := cbg.ReadString(br)
-		if err != nil {
-			return err
-		}
-
-		name = string(sval)
-	}
-
-	if name != "PreCommitMessage" {
-		return fmt.Errorf("expected struct map entry %s to be PreCommitMessage", name)
-	}
-
-	{
-
-		pb, err := br.PeekByte()
-		if err != nil {
-			return err
-		}
-		if pb == cbg.CborNull[0] {
-			var nbuf [1]byte
-			if _, err := br.Read(nbuf[:]); err != nil {
-				return err
-			}
-		} else {
-
-			c, err := cbg.ReadCid(br)
-			if err != nil {
-				return xerrors.Errorf("failed to read cid field t.PreCommitMessage: %w", err)
-			}
-
-			t.PreCommitMessage = &c
-		}
-
-	}
-	// t.Seed (storage.SealSeed) (struct)
-
-	{
-		sval, err := cbg.ReadString(br)
-		if err != nil {
-			return err
-		}
-
-		name = string(sval)
-	}
-
-	if name != "Seed" {
-		return fmt.Errorf("expected struct map entry %s to be Seed", name)
-	}
-
-	{
-
-		if err := t.Seed.UnmarshalCBOR(br); err != nil {
-			return err
-		}
-
-	}
-	// t.CommitMessage (cid.Cid) (struct)
-
-	{
-		sval, err := cbg.ReadString(br)
-		if err != nil {
-			return err
-		}
-
-		name = string(sval)
-	}
-
-	if name != "CommitMessage" {
-		return fmt.Errorf("expected struct map entry %s to be CommitMessage", name)
-	}
-
-	{
-
-		pb, err := br.PeekByte()
-		if err != nil {
-			return err
-		}
-		if pb == cbg.CborNull[0] {
-			var nbuf [1]byte
-			if _, err := br.Read(nbuf[:]); err != nil {
-				return err
-			}
-		} else {
-
-			c, err := cbg.ReadCid(br)
-			if err != nil {
-				return xerrors.Errorf("failed to read cid field t.CommitMessage: %w", err)
-			}
-
-			t.CommitMessage = &c
-		}
-
-	}
-	// t.FaultReportMsg (cid.Cid) (struct)
-
-	{
-		sval, err := cbg.ReadString(br)
-		if err != nil {
-			return err
-		}
-
-		name = string(sval)
-	}
-
-	if name != "FaultReportMsg" {
-		return fmt.Errorf("expected struct map entry %s to be FaultReportMsg", name)
-	}
-
-	{
-
-		pb, err := br.PeekByte()
-		if err != nil {
-			return err
-		}
-		if pb == cbg.CborNull[0] {
-			var nbuf [1]byte
-			if _, err := br.Read(nbuf[:]); err != nil {
-				return err
-			}
-		} else {
-
-			c, err := cbg.ReadCid(br)
-			if err != nil {
-				return xerrors.Errorf("failed to read cid field t.FaultReportMsg: %w", err)
-			}
-
-			t.FaultReportMsg = &c
-		}
-
-	}
-	// t.LastErr (string) (string)
-
-	{
-		sval, err := cbg.ReadString(br)
-		if err != nil {
-			return err
-		}
-
-		name = string(sval)
-	}
-
-	if name != "LastErr" {
-		return fmt.Errorf("expected struct map entry %s to be LastErr", name)
-	}
-
-	{
-		sval, err := cbg.ReadString(br)
-		if err != nil {
-			return err
-		}
-
-		t.LastErr = string(sval)
-	}
-	return nil
-}
diff --git a/storage/fpost_run.go b/storage/fpost_run.go
deleted file mode 100644
index 9e23d1149..000000000
--- a/storage/fpost_run.go
+++ /dev/null
@@ -1,208 +0,0 @@
-package storage
-
-import (
-	"context"
-	"time"
-
-	ffi "github.com/filecoin-project/filecoin-ffi"
-	sectorbuilder "github.com/filecoin-project/go-sectorbuilder"
-	"go.opencensus.io/trace"
-	"golang.org/x/xerrors"
-
-	"github.com/filecoin-project/lotus/build"
-	"github.com/filecoin-project/lotus/chain/actors"
-	"github.com/filecoin-project/lotus/chain/types"
-)
-
-func (s *fpostScheduler) failPost(eps uint64) {
-	s.failLk.Lock()
-	if eps > s.failed {
-		s.failed = eps
-	}
-	s.failLk.Unlock()
-}
-
-func (s *fpostScheduler) doPost(ctx context.Context, eps uint64, ts *types.TipSet) {
-	ctx, abort := context.WithCancel(ctx)
-
-	s.abort = abort
-	s.activeEPS = eps
-
-	go func() {
-		defer abort()
-
-		ctx, span := trace.StartSpan(ctx, "fpostScheduler.doPost")
-		defer span.End()
-
-		proof, err := s.runPost(ctx, eps, ts)
-		if err != nil {
-			log.Errorf("runPost failed: %+v", err)
-			s.failPost(eps)
-			return
-		}
-
-		if err := s.submitPost(ctx, proof); err != nil {
-			log.Errorf("submitPost failed: %+v", err)
-			s.failPost(eps)
-			return
-		}
-
-	}()
-}
-
-func (s *fpostScheduler) checkFaults(ctx context.Context, ssi sectorbuilder.SortedPublicSectorInfo) ([]uint64, error) {
-	faults := s.sb.Scrub(ssi)
-	var faultIDs []uint64
-
-	if len(faults) > 0 {
-		params := &actors.DeclareFaultsParams{Faults: types.NewBitField()}
-
-		for _, fault := range faults {
-			log.Warnf("fault detected: sector %d: %s", fault.SectorID, fault.Err)
-			faultIDs = append(faultIDs, fault.SectorID)
-
-			// TODO: omit already declared (with finality in mind though..)
-			params.Faults.Set(fault.SectorID)
-		}
-
-		log.Warnf("DECLARING %d FAULTS", len(faults))
-
-		enc, aerr := actors.SerializeParams(params)
-		if aerr != nil {
-			return nil, xerrors.Errorf("could not serialize declare faults parameters: %w", aerr)
-		}
-
-		msg := &types.Message{
-			To:       s.actor,
-			From:     s.worker,
-			Method:   actors.MAMethods.DeclareFaults,
-			Params:   enc,
-			Value:    types.NewInt(0),
-			GasLimit: types.NewInt(10000000), // i dont know help
-			GasPrice: types.NewInt(1),
-		}
-
-		sm, err := s.api.MpoolPushMessage(ctx, msg)
-		if err != nil {
-			return nil, xerrors.Errorf("pushing faults message to mpool: %w", err)
-		}
-
-		rec, err := s.api.StateWaitMsg(ctx, sm.Cid())
-		if err != nil {
-			return nil, xerrors.Errorf("waiting for declare faults: %w", err)
-		}
-
-		if rec.Receipt.ExitCode != 0 {
-			return nil, xerrors.Errorf("declare faults exit %d", rec.Receipt.ExitCode)
-		}
-		log.Infof("Faults declared successfully")
-	}
-
-	return faultIDs, nil
-}
-
-func (s *fpostScheduler) runPost(ctx context.Context, eps uint64, ts *types.TipSet) (*actors.SubmitFallbackPoStParams, error) {
-	ctx, span := trace.StartSpan(ctx, "storage.runPost")
-	defer span.End()
-
-	challengeRound := int64(eps + build.FallbackPoStDelay)
-
-	rand, err := s.api.ChainGetRandomness(ctx, ts.Key(), challengeRound)
-	if err != nil {
-		return nil, xerrors.Errorf("failed to get chain randomness for fpost (ts=%d; eps=%d): %w", ts.Height(), eps, err)
-	}
-
-	ssi, err := s.sortedSectorInfo(ctx, ts)
-	if err != nil {
-		return nil, xerrors.Errorf("getting sorted sector info: %w", err)
-	}
-
-	log.Infow("running fPoSt", "chain-random", rand, "eps", eps, "height", ts.Height())
-
-	faults, err := s.checkFaults(ctx, ssi)
-	if err != nil {
-		log.Errorf("Failed to declare faults: %+v", err)
-	}
-
-	tsStart := time.Now()
-
-	var seed [32]byte
-	copy(seed[:], rand)
-
-	scandidates, proof, err := s.sb.GenerateFallbackPoSt(ssi, seed, faults)
-	if err != nil {
-		return nil, xerrors.Errorf("running post failed: %w", err)
-	}
-
-	elapsed := time.Since(tsStart)
-	log.Infow("submitting PoSt", "pLen", len(proof), "elapsed", elapsed)
-
-	candidates := make([]types.EPostTicket, len(scandidates))
-	for i, sc := range scandidates {
-		part := make([]byte, 32)
-		copy(part, sc.PartialTicket[:])
-		candidates[i] = types.EPostTicket{
-			Partial:        part,
-			SectorID:       sc.SectorID,
-			ChallengeIndex: sc.SectorChallengeIndex,
-		}
-	}
-
-	return &actors.SubmitFallbackPoStParams{
-		Proof:      proof,
-		Candidates: candidates,
-	}, nil
-}
-
-func (s *fpostScheduler) sortedSectorInfo(ctx context.Context, ts *types.TipSet) (sectorbuilder.SortedPublicSectorInfo, error) {
-	sset, err := s.api.StateMinerProvingSet(ctx, s.actor, ts)
-	if err != nil {
-		return sectorbuilder.SortedPublicSectorInfo{}, xerrors.Errorf("failed to get proving set for miner (tsH: %d): %w", ts.Height(), err)
-	}
-	if len(sset) == 0 {
-		log.Warn("empty proving set! (ts.H: %d)", ts.Height())
-	}
-
-	sbsi := make([]ffi.PublicSectorInfo, len(sset))
-	for k, sector := range sset {
-		var commR [sectorbuilder.CommLen]byte
-		copy(commR[:], sector.CommR)
-
-		sbsi[k] = ffi.PublicSectorInfo{
-			SectorID: sector.SectorID,
-			CommR:    commR,
-		}
-	}
-
-	return sectorbuilder.NewSortedPublicSectorInfo(sbsi), nil
-}
-
-func (s *fpostScheduler) submitPost(ctx context.Context, proof *actors.SubmitFallbackPoStParams) error {
-	ctx, span := trace.StartSpan(ctx, "storage.commitPost")
-	defer span.End()
-
-	enc, aerr := actors.SerializeParams(proof)
-	if aerr != nil {
-		return xerrors.Errorf("could not serialize submit post parameters: %w", aerr)
-	}
-
-	msg := &types.Message{
-		To:       s.actor,
-		From:     s.worker,
-		Method:   actors.MAMethods.SubmitFallbackPoSt,
-		Params:   enc,
-		Value:    types.NewInt(1000),     // currently hard-coded late fee in actor, returned if not late
-		GasLimit: types.NewInt(10000000), // i dont know help
-		GasPrice: types.NewInt(1),
-	}
-
-	// TODO: consider maybe caring about the output
-	sm, err := s.api.MpoolPushMessage(ctx, msg)
-	if err != nil {
-		return xerrors.Errorf("pushing message to mpool: %w", err)
-	}
-
-	log.Infof("Submitted fallback post: %s", sm.Cid())
-
-	return nil
-}
diff --git a/storage/fpost_sched.go b/storage/fpost_sched.go
deleted file mode 100644
index fc192ebee..000000000
--- a/storage/fpost_sched.go
+++ /dev/null
@@ -1,163 +0,0 @@
-package storage
-
-import (
-	"context"
-	"sync"
-
-	sectorbuilder "github.com/filecoin-project/go-sectorbuilder"
-	"go.opencensus.io/trace"
-	"golang.org/x/xerrors"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/lotus/build"
-	"github.com/filecoin-project/lotus/chain/store"
-	"github.com/filecoin-project/lotus/chain/types"
-)
-
-const Inactive = 0
-
-const StartConfidence = 4 // TODO: config
-
-type fpostScheduler struct {
-	api storageMinerApi
-	sb  *sectorbuilder.SectorBuilder
-
-	actor  address.Address
-	worker address.Address
-
-	cur *types.TipSet
-
-	// if a post is in progress, this indicates for which ElectionPeriodStart
-	activeEPS uint64
-	abort     context.CancelFunc
-
-	failed uint64 // eps
-	failLk sync.Mutex
-}
-
-func (s *fpostScheduler) run(ctx context.Context) {
-	notifs, err := s.api.ChainNotify(ctx)
-	if err != nil {
-		return
-	}
-
-	current := <-notifs
-	if len(current) != 1 {
-		panic("expected first notif to have len = 1")
-	}
-	if current[0].Type != store.HCCurrent {
-		panic("expected first notif to tell current ts")
-	}
-
-	if err := s.update(ctx, current[0].Val); err != nil {
-		panic(err)
-	}
-
-	defer s.abortActivePoSt()
-
-	// not fine to panic after this point
-	for {
-		select {
-		case changes, ok := <-notifs:
-			if !ok {
-				log.Warn("fpostScheduler notifs channel closed")
-				return
-			}
-
-			ctx, span := trace.StartSpan(ctx, "fpostScheduler.headChange")
-
-			var lowest, highest *types.TipSet = s.cur, nil
-
-			for _, change := range changes {
-				switch change.Type {
-				case store.HCRevert:
-					lowest = change.Val
-				case store.HCApply:
-					highest = change.Val
-				}
-			}
-
-			if err := s.revert(ctx, lowest); err != nil {
-				log.Error("handling head reverts in fallbackPost sched: %+v", err)
-			}
-			if err := s.update(ctx, highest); err != nil {
-				log.Error("handling head updates in fallbackPost sched: %+v", err)
-			}
-
-			span.End()
-		case <-ctx.Done():
-			return
-		}
-	}
-}
-
-func (s *fpostScheduler) revert(ctx context.Context, newLowest *types.TipSet) error {
-	if s.cur == newLowest {
-		return nil
-	}
-	s.cur = newLowest
-
-	newEPS, _, err := s.shouldFallbackPost(ctx, newLowest)
-	if err != nil {
-		return err
-	}
-
-	if newEPS != s.activeEPS {
-		s.abortActivePoSt()
-	}
-
-	return nil
-}
-
-func (s *fpostScheduler) update(ctx context.Context, new *types.TipSet) error {
-	newEPS, start, err := s.shouldFallbackPost(ctx, new)
-	if err != nil {
-		return err
-	}
-
-	s.failLk.Lock()
-	if s.failed > 0 {
-		s.failed = 0
-		s.activeEPS = 0
-	}
-	s.failLk.Unlock()
-
-	if newEPS == s.activeEPS {
-		return nil
-	}
-
-	s.abortActivePoSt()
-
-	if newEPS != Inactive && start {
-		s.doPost(ctx, newEPS, new)
-	}
-
-	return nil
-}
-
-func (s *fpostScheduler) abortActivePoSt() {
-	if s.activeEPS == Inactive {
-		return // noop
-	}
-
-	if s.abort != nil {
-		s.abort()
-	}
-
-	log.Warnf("Aborting Fallback PoSt (EPS: %d)", s.activeEPS)
-
-	s.activeEPS = Inactive
-	s.abort = nil
-}
-
-func (s *fpostScheduler) shouldFallbackPost(ctx context.Context, ts *types.TipSet) (uint64, bool, error) {
-	eps, err := s.api.StateMinerElectionPeriodStart(ctx, s.actor, ts)
-	if err != nil {
-		return 0, false, xerrors.Errorf("getting ElectionPeriodStart: %w", err)
-	}
-
-	if ts.Height() >= eps+build.FallbackPoStDelay {
-		return eps, ts.Height() >= eps+build.FallbackPoStDelay+StartConfidence, nil
-	}
-	return 0, false, nil
-}
diff --git a/storage/garbage.go b/storage/garbage.go
deleted file mode 100644
index d128413bd..000000000
--- a/storage/garbage.go
+++ /dev/null
@@ -1,132 +0,0 @@
-package storage
-
-import (
-	"bytes"
-	"context"
-	"io"
-	"math"
-	"math/rand"
-
-	sectorbuilder "github.com/filecoin-project/go-sectorbuilder"
-	"golang.org/x/xerrors"
-
-	"github.com/filecoin-project/lotus/api"
-	"github.com/filecoin-project/lotus/chain/actors"
-	"github.com/filecoin-project/lotus/chain/types"
-)
-
-func (m *Miner) pledgeSector(ctx context.Context, sectorID uint64, existingPieceSizes []uint64, sizes ...uint64) ([]Piece, error) {
-	if len(sizes) == 0 {
-		return nil, nil
-	}
-
-	deals := make([]actors.StorageDealProposal, len(sizes))
-	for i, size := range sizes {
-		release := m.sb.RateLimit()
-		commP, err := sectorbuilder.GeneratePieceCommitment(io.LimitReader(rand.New(rand.NewSource(42)), int64(size)), size)
-		release()
-
-		if err != nil {
-			return nil, err
-		}
-
-		sdp := actors.StorageDealProposal{
-			PieceRef:             commP[:],
-			PieceSize:            size,
-			Client:               m.worker,
-			Provider:             m.maddr,
-			ProposalExpiration:   math.MaxUint64,
-			Duration:             math.MaxUint64 / 2, // /2 because overflows
-			StoragePricePerEpoch: types.NewInt(0),
-			StorageCollateral:    types.NewInt(0),
-			ProposerSignature:    nil,
-		}
-
-		if err := api.SignWith(ctx, m.api.WalletSign, m.worker, &sdp); err != nil {
-			return nil, xerrors.Errorf("signing storage deal failed: ", err)
-		}
-
-		deals[i] = sdp
-	}
-
-	params, aerr := actors.SerializeParams(&actors.PublishStorageDealsParams{
-		Deals: deals,
-	})
-	if aerr != nil {
-		return nil, xerrors.Errorf("serializing PublishStorageDeals params failed: ", aerr)
-	}
-
-	smsg, err := m.api.MpoolPushMessage(ctx, &types.Message{
-		To:       actors.StorageMarketAddress,
-		From:     m.worker,
-		Value:    types.NewInt(0),
-		GasPrice: types.NewInt(0),
-		GasLimit: types.NewInt(1000000),
-		Method:   actors.SMAMethods.PublishStorageDeals,
-		Params:   params,
-	})
-	if err != nil {
-		return nil, err
-	}
-	r, err := m.api.StateWaitMsg(ctx, smsg.Cid())
-	if err != nil {
-		return nil, err
-	}
-	if r.Receipt.ExitCode != 0 {
-		log.Error(xerrors.Errorf("publishing deal failed: exit %d", r.Receipt.ExitCode))
-	}
-	var resp actors.PublishStorageDealResponse
-	if err := resp.UnmarshalCBOR(bytes.NewReader(r.Receipt.Return)); err != nil {
-		return nil, err
-	}
-	if len(resp.DealIDs) != len(sizes) {
-		return nil, xerrors.New("got unexpected number of DealIDs from PublishStorageDeals")
-	}
-
-	out := make([]Piece, len(sizes))
-
-	for i, size := range sizes {
-		ppi, err := m.sb.AddPiece(size, sectorID, io.LimitReader(rand.New(rand.NewSource(42)), int64(size)), existingPieceSizes)
-		if err != nil {
-			return nil, err
-		}
-
-		existingPieceSizes = append(existingPieceSizes, size)
-
-		out[i] = Piece{
-			DealID: resp.DealIDs[i],
-			Size:   ppi.Size,
-			CommP:  ppi.CommP[:],
-		}
-	}
-
-	return out, nil
-}
-
-func (m *Miner) PledgeSector() error {
-	go func() {
-		ctx := context.TODO() // we can't use the context from command which invokes
-		// this, as we run everything here async, and it's cancelled when the
-		// command exits
-
-		size := sectorbuilder.UserBytesForSectorSize(m.sb.SectorSize())
-
-		sid, err := m.sb.AcquireSectorId()
-		if err != nil {
-			log.Errorf("%+v", err)
-			return
-		}
-
-		pieces, err := m.pledgeSector(ctx, sid, []uint64{}, size)
-		if err != nil {
-			log.Errorf("%+v", err)
-			return
-		}
-
-		if err := m.newSector(context.TODO(), sid, pieces[0].DealID, pieces[0].ppi()); err != nil {
-			log.Errorf("%+v", err)
-			return
-		}
-	}()
-	return nil
-}
diff --git a/storage/miner.go b/storage/miner.go
index 3265aa2ae..c1b50fe89 100644
--- a/storage/miner.go
+++ b/storage/miner.go
@@ -5,88 +5,128 @@ import (
 	"errors"
 	"time"
 
+	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
+	proof0 "github.com/filecoin-project/specs-actors/actors/runtime/proof"
+
+	"github.com/filecoin-project/go-state-types/network"
+
+	"github.com/filecoin-project/go-state-types/dline"
+
+	"github.com/filecoin-project/go-bitfield"
+
 	"github.com/ipfs/go-cid"
 	"github.com/ipfs/go-datastore"
-	"github.com/ipfs/go-datastore/namespace"
-	logging "github.com/ipfs/go-log"
+	logging "github.com/ipfs/go-log/v2"
 	"github.com/libp2p/go-libp2p-core/host"
 	"golang.org/x/xerrors"
 
 	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-sectorbuilder"
-	"github.com/filecoin-project/go-statestore"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/crypto"
+	sectorstorage "github.com/filecoin-project/lotus/extern/sector-storage"
+	"github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper"
+	"github.com/filecoin-project/specs-storage/storage"
+
 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
 	"github.com/filecoin-project/lotus/chain/events"
 	"github.com/filecoin-project/lotus/chain/gen"
-	"github.com/filecoin-project/lotus/chain/store"
 	"github.com/filecoin-project/lotus/chain/types"
+	sealing "github.com/filecoin-project/lotus/extern/storage-sealing"
+	"github.com/filecoin-project/lotus/journal"
+	"github.com/filecoin-project/lotus/node/config"
+	"github.com/filecoin-project/lotus/node/modules/dtypes"
 )
 
 var log = logging.Logger("storageminer")
 
-const SectorStorePrefix = "/sectors"
-
 type Miner struct {
 	api    storageMinerApi
-	events *events.Events
+	feeCfg config.MinerFeeConfig
 	h      host.Host
+	sealer sectorstorage.SectorManager
+	ds     datastore.Batching
+	sc     sealing.SectorIDCounter
+	verif  ffiwrapper.Verifier
 
 	maddr  address.Address
 	worker address.Address
 
-	// Sealing
-	sb      *sectorbuilder.SectorBuilder
-	sectors *statestore.StateStore
-	tktFn   TicketFn
+	getSealConfig dtypes.GetSealingConfigFunc
+	sealing       *sealing.Sealing
 
-	sectorIncoming chan *SectorInfo
-	sectorUpdated  chan sectorUpdate
-	stop           chan struct{}
-	stopped        chan struct{}
+	sealingEvtType journal.EventType
+}
+
+// SealingStateEvt is a journal event that records a sector state transition.
+type SealingStateEvt struct {
+	SectorNumber abi.SectorNumber
+	SectorType   abi.RegisteredSealProof
+	From         sealing.SectorState
+	After        sealing.SectorState
+	Error        string
 }
 
 type storageMinerApi interface {
 	// Call a read only method on actors (no interaction with the chain required)
-	StateCall(ctx context.Context, msg *types.Message, ts *types.TipSet) (*types.MessageReceipt, error)
-	StateMinerWorker(context.Context, address.Address, *types.TipSet) (address.Address, error)
-	StateMinerElectionPeriodStart(ctx context.Context, actor address.Address, ts *types.TipSet) (uint64, error)
-	StateMinerSectors(context.Context, address.Address, *types.TipSet) ([]*api.ChainSectorInfo, error)
-	StateMinerProvingSet(context.Context, address.Address, *types.TipSet) ([]*api.ChainSectorInfo, error)
-	StateMinerSectorSize(context.Context, address.Address, *types.TipSet) (uint64, error)
-	StateWaitMsg(context.Context, cid.Cid) (*api.MsgWait, error) // TODO: removeme eventually
-	StateGetActor(ctx context.Context, actor address.Address, ts *types.TipSet) (*types.Actor, error)
-	StateGetReceipt(context.Context, cid.Cid, *types.TipSet) (*types.MessageReceipt, error)
+	StateCall(context.Context, *types.Message, types.TipSetKey) (*api.InvocResult, error)
+	StateMinerSectors(context.Context, address.Address, *bitfield.BitField, types.TipSetKey) ([]*miner.SectorOnChainInfo, error)
+	StateSectorPreCommitInfo(context.Context, address.Address, abi.SectorNumber, types.TipSetKey) (miner.SectorPreCommitOnChainInfo, error)
+	StateSectorGetInfo(context.Context, address.Address, abi.SectorNumber, types.TipSetKey) (*miner.SectorOnChainInfo, error)
+	StateSectorPartition(ctx context.Context, maddr address.Address, sectorNumber abi.SectorNumber, tok types.TipSetKey) (*miner.SectorLocation, error)
+	StateMinerInfo(context.Context, address.Address, types.TipSetKey) (miner.MinerInfo, error)
+	StateMinerDeadlines(context.Context, address.Address, types.TipSetKey) ([]api.Deadline, error)
+	StateMinerPartitions(context.Context, address.Address, uint64, types.TipSetKey) ([]api.Partition, error)
+	StateMinerProvingDeadline(context.Context, address.Address, types.TipSetKey) (*dline.Info, error)
+	StateMinerPreCommitDepositForPower(context.Context, address.Address, miner.SectorPreCommitInfo, types.TipSetKey) (types.BigInt, error)
+	StateMinerInitialPledgeCollateral(context.Context, address.Address, miner.SectorPreCommitInfo, types.TipSetKey) (types.BigInt, error)
+	StateSearchMsg(context.Context, cid.Cid) (*api.MsgLookup, error)
+	StateWaitMsg(ctx context.Context, cid cid.Cid, confidence uint64) (*api.MsgLookup, error) // TODO: removeme eventually
+	StateGetActor(ctx context.Context, actor address.Address, ts types.TipSetKey) (*types.Actor, error)
+	StateGetReceipt(context.Context, cid.Cid, types.TipSetKey) (*types.MessageReceipt, error)
+	StateMarketStorageDeal(context.Context, abi.DealID, types.TipSetKey) (*api.MarketDeal, error)
+	StateMinerFaults(context.Context, address.Address, types.TipSetKey) (bitfield.BitField, error)
+	StateMinerRecoveries(context.Context, address.Address, types.TipSetKey) (bitfield.BitField, error)
+	StateAccountKey(context.Context, address.Address, types.TipSetKey) (address.Address, error)
+	StateNetworkVersion(context.Context, types.TipSetKey) (network.Version, error)
 
-	MpoolPushMessage(context.Context, *types.Message) (*types.SignedMessage, error)
+	MpoolPushMessage(context.Context, *types.Message, *api.MessageSendSpec) (*types.SignedMessage, error)
+
+	GasEstimateMessageGas(context.Context, *types.Message, *api.MessageSendSpec, types.TipSetKey) (*types.Message, error)
 
 	ChainHead(context.Context) (*types.TipSet, error)
-	ChainNotify(context.Context) (<-chan []*store.HeadChange, error)
-	ChainGetRandomness(context.Context, types.TipSetKey, int64) ([]byte, error)
-	ChainGetTipSetByHeight(context.Context, uint64, *types.TipSet) (*types.TipSet, error)
+	ChainNotify(context.Context) (<-chan []*api.HeadChange, error)
+	ChainGetRandomnessFromTickets(ctx context.Context, tsk types.TipSetKey, personalization crypto.DomainSeparationTag, randEpoch abi.ChainEpoch, entropy []byte) (abi.Randomness, error)
+	ChainGetRandomnessFromBeacon(ctx context.Context, tsk types.TipSetKey, personalization crypto.DomainSeparationTag, randEpoch abi.ChainEpoch, entropy []byte) (abi.Randomness, error)
+	ChainGetTipSetByHeight(context.Context, abi.ChainEpoch, types.TipSetKey) (*types.TipSet, error)
 	ChainGetBlockMessages(context.Context, cid.Cid) (*api.BlockMessages, error)
+	ChainReadObj(context.Context, cid.Cid) ([]byte, error)
+	ChainHasObj(context.Context, cid.Cid) (bool, error)
+	ChainGetTipSet(ctx context.Context, key types.TipSetKey) (*types.TipSet, error)
 
-	WalletSign(context.Context, address.Address, []byte) (*types.Signature, error)
+	WalletSign(context.Context, address.Address, []byte) (*crypto.Signature, error)
 	WalletBalance(context.Context, address.Address) (types.BigInt, error)
 	WalletHas(context.Context, address.Address) (bool, error)
 }
 
-func NewMiner(api storageMinerApi, addr address.Address, h host.Host, ds datastore.Batching, sb *sectorbuilder.SectorBuilder, tktFn TicketFn) (*Miner, error) {
-	return &Miner{
-		api: api,
+func NewMiner(api storageMinerApi, maddr, worker address.Address, h host.Host, ds datastore.Batching, sealer sectorstorage.SectorManager, sc sealing.SectorIDCounter, verif ffiwrapper.Verifier, gsd dtypes.GetSealingConfigFunc, feeCfg config.MinerFeeConfig) (*Miner, error) {
+	m := &Miner{
+		api:    api,
+		feeCfg: feeCfg,
+		h:      h,
+		sealer: sealer,
+		ds:     ds,
+		sc:     sc,
+		verif:  verif,
 
-		maddr: addr,
-		h:     h,
-		sb:    sb,
-		tktFn: tktFn,
+		maddr:          maddr,
+		worker:         worker,
+		getSealConfig:  gsd,
+		sealingEvtType: journal.J.RegisterEventType("storage", "sealing_states"),
+	}
 
-		sectors: statestore.New(namespace.Wrap(ds, datastore.NewKey(SectorStorePrefix))),
-
-		sectorIncoming: make(chan *SectorInfo),
-		sectorUpdated:  make(chan sectorUpdate),
-		stop:           make(chan struct{}),
-		stopped:        make(chan struct{}),
-	}, nil
+	return m, nil
 }
 
 func (m *Miner) Run(ctx context.Context) error {
@@ -94,43 +134,45 @@ func (m *Miner) Run(ctx context.Context) error {
 		return xerrors.Errorf("miner preflight checks failed: %w", err)
 	}
 
-	m.events = events.NewEvents(ctx, m.api)
-
-	fps := &fpostScheduler{
-		api:    m.api,
-		sb:     m.sb,
-		actor:  m.maddr,
-		worker: m.worker,
+	md, err := m.api.StateMinerProvingDeadline(ctx, m.maddr, types.EmptyTSK)
+	if err != nil {
+		return xerrors.Errorf("getting miner info: %w", err)
 	}
 
-	go fps.run(ctx)
-	if err := m.sectorStateLoop(ctx); err != nil {
-		log.Errorf("%+v", err)
-		return xerrors.Errorf("failed to startup sector state loop: %w", err)
+	fc := sealing.FeeConfig{
+		MaxPreCommitGasFee: abi.TokenAmount(m.feeCfg.MaxPreCommitGasFee),
+		MaxCommitGasFee:    abi.TokenAmount(m.feeCfg.MaxCommitGasFee),
 	}
 
+	evts := events.NewEvents(ctx, m.api)
+	adaptedAPI := NewSealingAPIAdapter(m.api)
+	// TODO: Maybe we update this policy after actor upgrades?
+	pcp := sealing.NewBasicPreCommitPolicy(adaptedAPI, miner0.MaxSectorExpirationExtension-(miner0.WPoStProvingPeriod*2), md.PeriodStart%miner0.WPoStProvingPeriod)
+	m.sealing = sealing.New(adaptedAPI, fc, NewEventsAdapter(evts), m.maddr, m.ds, m.sealer, m.sc, m.verif, &pcp, sealing.GetSealingConfigFunc(m.getSealConfig), m.handleSealingNotifications)
+
+	go m.sealing.Run(ctx) //nolint:errcheck // logged intside the function
+
 	return nil
 }
 
+func (m *Miner) handleSealingNotifications(before, after sealing.SectorInfo) {
+	journal.J.RecordEvent(m.sealingEvtType, func() interface{} {
+		return SealingStateEvt{
+			SectorNumber: before.SectorNumber,
+			SectorType:   before.SectorType,
+			From:         before.State,
+			After:        after.State,
+			Error:        after.LastErr,
+		}
+	})
+}
+
 func (m *Miner) Stop(ctx context.Context) error {
-	close(m.stop)
-	select {
-	case <-m.stopped:
-		return nil
-	case <-ctx.Done():
-		return ctx.Err()
-	}
+	return m.sealing.Stop(ctx)
 }
 
 func (m *Miner) runPreflightChecks(ctx context.Context) error {
-	worker, err := m.api.StateMinerWorker(ctx, m.maddr, nil)
-	if err != nil {
-		return err
-	}
-
-	m.worker = worker
-
-	has, err := m.api.WalletHas(ctx, worker)
+	has, err := m.api.WalletHas(ctx, m.worker)
 	if err != nil {
 		return xerrors.Errorf("failed to check wallet for worker key: %w", err)
 	}
@@ -143,40 +185,68 @@ func (m *Miner) runPreflightChecks(ctx context.Context) error {
 	return nil
 }
 
-type SectorBuilderEpp struct {
-	sb *sectorbuilder.SectorBuilder
+type StorageWpp struct {
+	prover   storage.Prover
+	verifier ffiwrapper.Verifier
+	miner    abi.ActorID
+	winnRpt  abi.RegisteredPoStProof
 }
 
-func NewElectionPoStProver(sb *sectorbuilder.SectorBuilder) *SectorBuilderEpp {
-	return &SectorBuilderEpp{sb}
-}
-
-var _ gen.ElectionPoStProver = (*SectorBuilderEpp)(nil)
-
-func (epp *SectorBuilderEpp) GenerateCandidates(ctx context.Context, ssi sectorbuilder.SortedPublicSectorInfo, rand []byte) ([]sectorbuilder.EPostCandidate, error) {
-	start := time.Now()
-	var faults []uint64 // TODO
-
-	var randbuf [32]byte
-	copy(randbuf[:], rand)
-	cds, err := epp.sb.GenerateEPostCandidates(ssi, randbuf, faults)
+func NewWinningPoStProver(api api.FullNode, prover storage.Prover, verifier ffiwrapper.Verifier, miner dtypes.MinerID) (*StorageWpp, error) {
+	ma, err := address.NewIDAddress(uint64(miner))
 	if err != nil {
 		return nil, err
 	}
-	log.Infof("Generate candidates took %s", time.Since(start))
+
+	mi, err := api.StateMinerInfo(context.TODO(), ma, types.EmptyTSK)
+	if err != nil {
+		return nil, xerrors.Errorf("getting sector size: %w", err)
+	}
+
+	spt, err := ffiwrapper.SealProofTypeFromSectorSize(mi.SectorSize)
+	if err != nil {
+		return nil, err
+	}
+
+	wpt, err := spt.RegisteredWinningPoStProof()
+	if err != nil {
+		return nil, err
+	}
+
+	if build.InsecurePoStValidation {
+		log.Warn("*****************************************************************************")
+		log.Warn(" Generating fake PoSt proof! You should only see this while running tests! ")
+		log.Warn("*****************************************************************************")
+	}
+
+	return &StorageWpp{prover, verifier, abi.ActorID(miner), wpt}, nil
+}
+
+var _ gen.WinningPoStProver = (*StorageWpp)(nil)
+
+func (wpp *StorageWpp) GenerateCandidates(ctx context.Context, randomness abi.PoStRandomness, eligibleSectorCount uint64) ([]uint64, error) {
+	start := build.Clock.Now()
+
+	cds, err := wpp.verifier.GenerateWinningPoStSectorChallenge(ctx, wpp.winnRpt, wpp.miner, randomness, eligibleSectorCount)
+	if err != nil {
+		return nil, xerrors.Errorf("failed to generate candidates: %w", err)
+	}
+	log.Infof("Generate candidates took %s (C: %+v)", time.Since(start), cds)
 	return cds, nil
 }
 
-func (epp *SectorBuilderEpp) ComputeProof(ctx context.Context, ssi sectorbuilder.SortedPublicSectorInfo, rand []byte, winners []sectorbuilder.EPostCandidate) ([]byte, error) {
+func (wpp *StorageWpp) ComputeProof(ctx context.Context, ssi []proof0.SectorInfo, rand abi.PoStRandomness) ([]proof0.PoStProof, error) {
 	if build.InsecurePoStValidation {
-		log.Warn("Generating fake EPost proof! You should only see this while running tests!")
-		return []byte("valid proof"), nil
+		return []proof0.PoStProof{{ProofBytes: []byte("valid proof")}}, nil
 	}
-	start := time.Now()
-	proof, err := epp.sb.ComputeElectionPoSt(ssi, rand, winners)
+
+	log.Infof("Computing WinningPoSt ;%+v; %v", ssi, rand)
+
+	start := build.Clock.Now()
+	proof, err := wpp.prover.GenerateWinningPoSt(ctx, wpp.miner, ssi, rand)
 	if err != nil {
 		return nil, err
 	}
-	log.Infof("ComputeElectionPost took %s", time.Since(start))
+	log.Infof("GenerateWinningPoSt took %s", time.Since(start))
 	return proof, nil
 }
diff --git a/storage/mockstorage/preseal.go b/storage/mockstorage/preseal.go
new file mode 100644
index 000000000..8ca789ba6
--- /dev/null
+++ b/storage/mockstorage/preseal.go
@@ -0,0 +1,69 @@
+package mockstorage
+
+import (
+	"fmt"
+
+	"github.com/filecoin-project/go-address"
+	commcid "github.com/filecoin-project/go-fil-commcid"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/big"
+	"github.com/filecoin-project/go-state-types/crypto"
+	"github.com/filecoin-project/lotus/extern/sector-storage/mock"
+
+	market0 "github.com/filecoin-project/specs-actors/actors/builtin/market"
+
+	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/chain/wallet"
+	"github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper"
+	"github.com/filecoin-project/lotus/extern/sector-storage/zerocomm"
+	"github.com/filecoin-project/lotus/genesis"
+)
+
+func PreSeal(ssize abi.SectorSize, maddr address.Address, sectors int) (*genesis.Miner, *types.KeyInfo, error) {
+	k, err := wallet.GenerateKey(crypto.SigTypeBLS)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	genm := &genesis.Miner{
+		ID:            maddr,
+		Owner:         k.Address,
+		Worker:        k.Address,
+		MarketBalance: big.NewInt(0),
+		PowerBalance:  big.NewInt(0),
+		SectorSize:    ssize,
+		Sectors:       make([]*genesis.PreSeal, sectors),
+	}
+
+	st, err := ffiwrapper.SealProofTypeFromSectorSize(ssize)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	for i := range genm.Sectors {
+		preseal := &genesis.PreSeal{}
+
+		preseal.ProofType = st
+		preseal.CommD = zerocomm.ZeroPieceCommitment(abi.PaddedPieceSize(ssize).Unpadded())
+		d, _ := commcid.CIDToPieceCommitmentV1(preseal.CommD)
+		r := mock.CommDR(d)
+		preseal.CommR, _ = commcid.ReplicaCommitmentV1ToCID(r[:])
+		preseal.SectorID = abi.SectorNumber(i + 1)
+		preseal.Deal = market0.DealProposal{
+			PieceCID:             preseal.CommD,
+			PieceSize:            abi.PaddedPieceSize(ssize),
+			Client:               k.Address,
+			Provider:             maddr,
+			Label:                fmt.Sprintf("%d", i),
+			StartEpoch:           1,
+			EndEpoch:             10000,
+			StoragePricePerEpoch: big.Zero(),
+			ProviderCollateral:   big.Zero(),
+			ClientCollateral:     big.Zero(),
+		}
+
+		genm.Sectors[i] = preseal
+	}
+
+	return genm, &k.KeyInfo, nil
+}
diff --git a/storage/sealing.go b/storage/sealing.go
new file mode 100644
index 000000000..2cd454e5b
--- /dev/null
+++ b/storage/sealing.go
@@ -0,0 +1,53 @@
+package storage
+
+import (
+	"context"
+	"io"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/abi"
+
+	sealing "github.com/filecoin-project/lotus/extern/storage-sealing"
+)
+
+// TODO: refactor this to be direct somehow
+
+func (m *Miner) Address() address.Address {
+	return m.sealing.Address()
+}
+
+func (m *Miner) AddPieceToAnySector(ctx context.Context, size abi.UnpaddedPieceSize, r io.Reader, d sealing.DealInfo) (abi.SectorNumber, abi.PaddedPieceSize, error) {
+	return m.sealing.AddPieceToAnySector(ctx, size, r, d)
+}
+
+func (m *Miner) StartPackingSector(sectorNum abi.SectorNumber) error {
+	return m.sealing.StartPacking(sectorNum)
+}
+
+func (m *Miner) ListSectors() ([]sealing.SectorInfo, error) {
+	return m.sealing.ListSectors()
+}
+
+func (m *Miner) GetSectorInfo(sid abi.SectorNumber) (sealing.SectorInfo, error) {
+	return m.sealing.GetSectorInfo(sid)
+}
+
+func (m *Miner) PledgeSector() error {
+	return m.sealing.PledgeSector()
+}
+
+func (m *Miner) ForceSectorState(ctx context.Context, id abi.SectorNumber, state sealing.SectorState) error {
+	return m.sealing.ForceSectorState(ctx, id, state)
+}
+
+func (m *Miner) RemoveSector(ctx context.Context, id abi.SectorNumber) error {
+	return m.sealing.Remove(ctx, id)
+}
+
+func (m *Miner) MarkForUpgrade(id abi.SectorNumber) error {
+	return m.sealing.MarkForUpgrade(id)
+}
+
+func (m *Miner) IsMarkedForUpgrade(id abi.SectorNumber) bool {
+	return m.sealing.IsMarkedForUpgrade(id)
+}
diff --git a/storage/sector_states.go b/storage/sector_states.go
deleted file mode 100644
index 0b86a3059..000000000
--- a/storage/sector_states.go
+++ /dev/null
@@ -1,289 +0,0 @@
-package storage
-
-import (
-	"context"
-
-	sectorbuilder "github.com/filecoin-project/go-sectorbuilder"
-	"golang.org/x/xerrors"
-
-	"github.com/filecoin-project/lotus/api"
-	"github.com/filecoin-project/lotus/build"
-	"github.com/filecoin-project/lotus/chain/actors"
-	"github.com/filecoin-project/lotus/chain/types"
-)
-
-type providerHandlerFunc func(ctx context.Context, deal SectorInfo) *sectorUpdate
-
-func (m *Miner) handleSectorUpdate(ctx context.Context, sector SectorInfo, cb providerHandlerFunc) {
-	go func() {
-		update := cb(ctx, sector)
-
-		if update == nil {
-			return // async
-		}
-
-		select {
-		case m.sectorUpdated <- *update:
-		case <-m.stop:
-		}
-	}()
-}
-
-func (m *Miner) handlePacking(ctx context.Context, sector SectorInfo) *sectorUpdate {
-	log.Infow("performing filling up rest of the sector...", "sector", sector.SectorID)
-
-	var allocated uint64
-	for _, piece := range sector.Pieces {
-		allocated += piece.Size
-	}
-
-	ubytes := sectorbuilder.UserBytesForSectorSize(m.sb.SectorSize())
-
-	if allocated > ubytes {
-		return sector.upd().fatal(xerrors.Errorf("too much data in sector: %d > %d", allocated, ubytes))
-	}
-
-	fillerSizes, err := fillersFromRem(ubytes - allocated)
-	if err != nil {
-		return sector.upd().fatal(err)
-	}
-
-	if len(fillerSizes) > 0 {
-		log.Warnf("Creating %d filler pieces for sector %d", len(fillerSizes), sector.SectorID)
-	}
-
-	pieces, err := m.pledgeSector(ctx, sector.SectorID, sector.existingPieces(), fillerSizes...)
-	if err != nil {
-		return sector.upd().fatal(xerrors.Errorf("filling up the sector (%v): %w", fillerSizes, err))
-	}
-
-	return sector.upd().to(api.Unsealed).state(func(info *SectorInfo) {
-		info.Pieces = append(info.Pieces, pieces...)
-	})
-}
-
-func (m *Miner) handleUnsealed(ctx context.Context, sector SectorInfo) *sectorUpdate {
-	log.Infow("performing sector replication...", "sector", sector.SectorID)
-	ticket, err := m.tktFn(ctx)
-	if err != nil {
-		return sector.upd().fatal(err)
-	}
-
-	rspco, err := m.sb.SealPreCommit(sector.SectorID, *ticket, sector.pieceInfos())
-	if err != nil {
-		return sector.upd().to(api.SealFailed).error(xerrors.Errorf("seal pre commit failed: %w", err))
-	}
-
-	return sector.upd().to(api.PreCommitting).state(func(info *SectorInfo) {
-		info.CommD = rspco.CommD[:]
-		info.CommR = rspco.CommR[:]
-		info.Ticket = SealTicket{
-			BlockHeight: ticket.BlockHeight,
-			TicketBytes: ticket.TicketBytes[:],
-		}
-	})
-}
-
-func (m *Miner) handlePreCommitting(ctx context.Context, sector SectorInfo) *sectorUpdate {
-	params := &actors.SectorPreCommitInfo{
-		SectorNumber: sector.SectorID,
-
-		CommR:     sector.CommR,
-		SealEpoch: sector.Ticket.BlockHeight,
-		DealIDs:   sector.deals(),
-	}
-	enc, aerr := actors.SerializeParams(params)
-	if aerr != nil {
-		return sector.upd().to(api.PreCommitFailed).error(xerrors.Errorf("could not serialize commit sector parameters: %w", aerr))
-	}
-
-	msg := &types.Message{
-		To:       m.maddr,
-		From:     m.worker,
-		Method:   actors.MAMethods.PreCommitSector,
-		Params:   enc,
-		Value:    types.NewInt(0), // TODO: need to ensure sufficient collateral
-		GasLimit: types.NewInt(1000000 /* i dont know help */),
-		GasPrice: types.NewInt(1),
-	}
-
-	log.Info("submitting precommit for sector: ", sector.SectorID)
-	smsg, err := m.api.MpoolPushMessage(ctx, msg)
-	if err != nil {
-		return sector.upd().to(api.PreCommitFailed).error(xerrors.Errorf("pushing message to mpool: %w", err))
-	}
-
-	return sector.upd().to(api.PreCommitted).state(func(info *SectorInfo) {
-		mcid := smsg.Cid()
-		info.PreCommitMessage = &mcid
-	})
-}
-
-func (m *Miner) handlePreCommitted(ctx context.Context, sector SectorInfo) *sectorUpdate {
-	// would be ideal to just use the events.Called handler, but it wouldnt be able to handle individual message timeouts
-	log.Info("Sector precommitted: ", sector.SectorID)
-	mw, err := m.api.StateWaitMsg(ctx, *sector.PreCommitMessage)
-	if err != nil {
-		return sector.upd().to(api.PreCommitFailed).error(err)
-	}
-
-	if mw.Receipt.ExitCode != 0 {
-		log.Error("sector precommit failed: ", mw.Receipt.ExitCode)
-		err := xerrors.Errorf("sector precommit failed: %d", mw.Receipt.ExitCode)
-		return sector.upd().to(api.PreCommitFailed).error(err)
-	}
-	log.Info("precommit message landed on chain: ", sector.SectorID)
-
-	randHeight := mw.TipSet.Height() + build.InteractivePoRepDelay - 1 // -1 because of how the messages are applied
-	log.Infof("precommit for sector %d made it on chain, will start proof computation at height %d", sector.SectorID, randHeight)
-
-	updateNonce := sector.Nonce
-
-	err = m.events.ChainAt(func(ctx context.Context, ts *types.TipSet, curH uint64) error {
-		rand, err := m.api.ChainGetRandomness(ctx, ts.Key(), int64(randHeight))
-		if err != nil {
-			err = xerrors.Errorf("failed to get randomness for computing seal proof: %w", err)
-
-			m.sectorUpdated <- *sector.upd().fatal(err)
-			return err
-		}
-
-		m.sectorUpdated <- *sector.upd().to(api.Committing).setNonce(updateNonce).state(func(info *SectorInfo) {
-			info.Seed = SealSeed{
-				BlockHeight: randHeight,
-				TicketBytes: rand,
-			}
-		})
-
-		updateNonce++
-
-		return nil
-	}, func(ctx context.Context, ts *types.TipSet) error {
-		log.Warn("revert in interactive commit sector step")
-		// TODO: need to cancel running process and restart...
-		return nil
-	}, build.InteractivePoRepConfidence, mw.TipSet.Height()+build.InteractivePoRepDelay)
-	if err != nil {
-		log.Warn("waitForPreCommitMessage ChainAt errored: ", err)
-	}
-
-	return nil
-}
-
-func (m *Miner) handleCommitting(ctx context.Context, sector SectorInfo) *sectorUpdate {
-	log.Info("scheduling seal proof computation...")
-
-	proof, err := m.sb.SealCommit(sector.SectorID, sector.Ticket.SB(), sector.Seed.SB(), sector.pieceInfos(), sector.rspco())
-	if err != nil {
-		return sector.upd().to(api.SealCommitFailed).error(xerrors.Errorf("computing seal proof failed: %w", err))
-	}
-
-	// TODO: Consider splitting states and persist proof for faster recovery
-
-	params := &actors.SectorProveCommitInfo{
-		Proof:    proof,
-		SectorID: sector.SectorID,
-		DealIDs:  sector.deals(),
-	}
-
-	enc, aerr := actors.SerializeParams(params)
-	if aerr != nil {
-		return sector.upd().to(api.CommitFailed).error(xerrors.Errorf("could not serialize commit sector parameters: %w", aerr))
-	}
-
-	msg := &types.Message{
-		To:       m.maddr,
-		From:     m.worker,
-		Method:   actors.MAMethods.ProveCommitSector,
-		Params:   enc,
-		Value:    types.NewInt(0), // TODO: need to ensure sufficient collateral
-		GasLimit: types.NewInt(1000000 /* i dont know help */),
-		GasPrice: types.NewInt(1),
-	}
-
-	smsg, err := m.api.MpoolPushMessage(ctx, msg)
-	if err != nil {
-		return sector.upd().to(api.CommitFailed).error(xerrors.Errorf("pushing message to mpool: %w", err))
-	}
-
-	// TODO: Separate state before this wait, so we persist message cid?
-	return sector.upd().to(api.CommitWait).state(func(info *SectorInfo) {
-		mcid := smsg.Cid()
-		info.CommitMessage = &mcid
-		info.Proof = proof
-	})
-}
-
-func (m *Miner) handleCommitWait(ctx context.Context, sector SectorInfo) *sectorUpdate {
-	if sector.CommitMessage == nil {
-		log.Errorf("sector %d entered commit wait state without a message cid", sector.SectorID)
-		return sector.upd().to(api.CommitFailed).error(xerrors.Errorf("entered commit wait with no commit cid"))
-	}
-
-	mw, err := m.api.StateWaitMsg(ctx, *sector.CommitMessage)
-	if err != nil {
-		return sector.upd().to(api.CommitFailed).error(xerrors.Errorf("failed to wait for porep inclusion: %w", err))
-	}
-
-	if mw.Receipt.ExitCode != 0 {
-		log.Errorf("UNHANDLED: submitting sector proof failed (exit=%d, msg=%s) (t:%x; s:%x(%d); p:%x)", mw.Receipt.ExitCode, sector.CommitMessage, sector.Ticket.TicketBytes, sector.Seed.TicketBytes, sector.Seed.BlockHeight, sector.Proof)
-		return sector.upd().fatal(xerrors.Errorf("UNHANDLED: submitting sector proof failed (exit: %d)", mw.Receipt.ExitCode))
-	}
-
-	return sector.upd().to(api.Proving).state(func(info *SectorInfo) {
-	})
-}
-
-func (m *Miner) handleFaulty(ctx context.Context, sector SectorInfo) *sectorUpdate {
-	// TODO: check if the fault has already been reported, and that this sector is even valid
-
-	// TODO: coalesce faulty sector reporting
-	bf := types.NewBitField()
-	bf.Set(sector.SectorID)
-
-	fp := &actors.DeclareFaultsParams{bf}
-	_ = fp
-	enc, aerr := actors.SerializeParams(nil)
-	if aerr != nil {
-		return sector.upd().fatal(xerrors.Errorf("failed to serialize declare fault params: %w", aerr))
-	}
-
-	msg := &types.Message{
-		To:       m.maddr,
-		From:     m.worker,
-		Method:   actors.MAMethods.DeclareFaults,
-		Params:   enc,
-		Value:    types.NewInt(0), // TODO: need to ensure sufficient collateral
-		GasLimit: types.NewInt(1000000 /* i dont know help */),
-		GasPrice: types.NewInt(1),
-	}
-
-	smsg, err := m.api.MpoolPushMessage(ctx, msg)
-	if err != nil {
-		return sector.upd().to(api.FailedUnrecoverable).error(xerrors.Errorf("failed to push declare faults message to network: %w", err))
-	}
-
-	return sector.upd().to(api.FaultReported).state(func(info *SectorInfo) {
-		c := smsg.Cid()
-		info.FaultReportMsg = &c
-	})
-}
-
-func (m *Miner) handleFaultReported(ctx context.Context, sector SectorInfo) *sectorUpdate {
-	if sector.FaultReportMsg == nil {
-		return sector.upd().to(api.FailedUnrecoverable).error(xerrors.Errorf("entered fault reported state without a FaultReportMsg cid"))
-	}
-
-	mw, err := m.api.StateWaitMsg(ctx, *sector.FaultReportMsg)
-	if err != nil {
-		return sector.upd().to(api.CommitFailed).error(xerrors.Errorf("failed to wait for fault declaration: %w", err))
-	}
-
-	if mw.Receipt.ExitCode != 0 {
-		log.Errorf("UNHANDLED: declaring sector fault failed (exit=%d, msg=%s) (id: %d)", mw.Receipt.ExitCode, *sector.FaultReportMsg, sector.SectorID)
-		return sector.upd().fatal(xerrors.Errorf("UNHANDLED: submitting fault declaration failed (exit %d)", mw.Receipt.ExitCode))
-	}
-
-	return sector.upd().to(api.FaultedFinal).state(func(info *SectorInfo) {})
-
-}
diff --git a/storage/sector_types.go b/storage/sector_types.go
deleted file mode 100644
index 2a6f49066..000000000
--- a/storage/sector_types.go
+++ /dev/null
@@ -1,114 +0,0 @@
-package storage
-
-import (
-	"context"
-
-	sectorbuilder "github.com/filecoin-project/go-sectorbuilder"
-	"github.com/ipfs/go-cid"
-
-	"github.com/filecoin-project/lotus/api"
-)
-
-type TicketFn func(context.Context) (*sectorbuilder.SealTicket, error)
-
-type SealTicket struct {
-	BlockHeight uint64
-	TicketBytes []byte
-}
-
-func (t *SealTicket) SB() sectorbuilder.SealTicket {
-	out := sectorbuilder.SealTicket{BlockHeight: t.BlockHeight}
-	copy(out.TicketBytes[:], t.TicketBytes)
-	return out
-}
-
-type SealSeed struct {
-	BlockHeight uint64
-	TicketBytes []byte
-}
-
-func (t *SealSeed) SB() sectorbuilder.SealSeed {
-	out := sectorbuilder.SealSeed{BlockHeight: t.BlockHeight}
-	copy(out.TicketBytes[:], t.TicketBytes)
-	return out
-}
-
-type Piece struct {
-	DealID uint64
-
-	Size  uint64
-	CommP []byte
-}
-
-func (p *Piece) ppi() (out sectorbuilder.PublicPieceInfo) {
-	out.Size = p.Size
-	copy(out.CommP[:], p.CommP)
-	return out
-}
-
-type SectorInfo struct {
-	State    api.SectorState
-	SectorID uint64
-	Nonce    uint64
-
-	// Packing
-
-	Pieces []Piece
-
-	// PreCommit
-	CommD  []byte
-	CommR  []byte
-	Proof  []byte
-	Ticket SealTicket
-
-	PreCommitMessage *cid.Cid
-
-	// PreCommitted
-	Seed SealSeed
-
-	// Committing
-	CommitMessage *cid.Cid
-
-	// Faults
-	FaultReportMsg *cid.Cid
-
-	// Debug
-	LastErr string
-}
-
-func (t *SectorInfo) upd() *sectorUpdate {
-	return &sectorUpdate{id: t.SectorID, nonce: t.Nonce}
-}
-
-func (t *SectorInfo) pieceInfos() []sectorbuilder.PublicPieceInfo {
-	out := make([]sectorbuilder.PublicPieceInfo, len(t.Pieces))
-	for i, piece := range t.Pieces {
-		out[i] = piece.ppi()
-	}
-	return out
-}
-
-func (t *SectorInfo) deals() []uint64 {
-	out := make([]uint64, len(t.Pieces))
-	for i, piece := range t.Pieces {
-		out[i] = piece.DealID
-	}
-	return out
-}
-
-func (t *SectorInfo) existingPieces() []uint64 {
-	out := make([]uint64, len(t.Pieces))
-	for i, piece := range t.Pieces {
-		out[i] = piece.Size
-	}
-	return out
-}
-
-func (t *SectorInfo) rspco() sectorbuilder.RawSealPreCommitOutput {
-	var out sectorbuilder.RawSealPreCommitOutput
-
-	copy(out.CommD[:], t.CommD)
-	copy(out.CommR[:], t.CommR)
-
-	return out
-}
diff --git a/storage/sector_utils_test.go b/storage/sector_utils_test.go
deleted file mode 100644
index 9ab38241c..000000000
--- a/storage/sector_utils_test.go
+++ /dev/null
@@ -1,46 +0,0 @@
-package storage
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-
-	sectorbuilder "github.com/filecoin-project/go-sectorbuilder"
-)
-
-func testFill(t *testing.T, n uint64, exp []uint64) {
-	f, err := fillersFromRem(n)
-	assert.NoError(t, err)
-	assert.Equal(t, exp, f)
-
-	var sum uint64
-	for _, u := range f {
-		sum += u
-	}
-	assert.Equal(t, n, sum)
-}
-
-func TestFillersFromRem(t *testing.T) {
-	for i := 8; i < 32; i++ {
-		// single
-		ub := sectorbuilder.UserBytesForSectorSize(uint64(1) << i)
-		testFill(t, ub, []uint64{ub})
-
-		// 2
-		ub = sectorbuilder.UserBytesForSectorSize(uint64(5) << i)
-		ub1 := sectorbuilder.UserBytesForSectorSize(uint64(1) << i)
-		ub3 := sectorbuilder.UserBytesForSectorSize(uint64(4) << i)
-		testFill(t, ub, []uint64{ub1, ub3})
-
-		// 4
-		ub = sectorbuilder.UserBytesForSectorSize(uint64(15) << i)
-		ub2 := sectorbuilder.UserBytesForSectorSize(uint64(2) << i)
-		ub4 := sectorbuilder.UserBytesForSectorSize(uint64(8) << i)
-		testFill(t, ub, []uint64{ub1, ub2, ub3, ub4})
-
-		// different 2
-		ub = sectorbuilder.UserBytesForSectorSize(uint64(9) << i)
-		testFill(t, ub, []uint64{ub1, ub4})
-	}
-
-}
diff --git a/storage/sectorblocks/blocks.go b/storage/sectorblocks/blocks.go
index 9d12e0537..bc8456a1f 100644
--- a/storage/sectorblocks/blocks.go
+++ b/storage/sectorblocks/blocks.go
@@ -3,25 +3,22 @@ package sectorblocks
 import (
 	"bytes"
 	"context"
+	"encoding/binary"
 	"errors"
 	"io"
 	"sync"
 
-	sectorbuilder "github.com/filecoin-project/go-sectorbuilder"
-	"github.com/ipfs/go-cid"
 	"github.com/ipfs/go-datastore"
 	"github.com/ipfs/go-datastore/namespace"
 	"github.com/ipfs/go-datastore/query"
-	blockstore "github.com/ipfs/go-ipfs-blockstore"
 	dshelp "github.com/ipfs/go-ipfs-ds-help"
-	files "github.com/ipfs/go-ipfs-files"
-	ipld "github.com/ipfs/go-ipld-format"
-	"github.com/ipfs/go-unixfs"
 	"golang.org/x/xerrors"
 
-	"github.com/filecoin-project/go-cbor-util"
+	cborutil "github.com/filecoin-project/go-cbor-util"
+	"github.com/filecoin-project/go-state-types/abi"
+	sealing "github.com/filecoin-project/lotus/extern/storage-sealing"
+
 	"github.com/filecoin-project/lotus/api"
-	"github.com/filecoin-project/lotus/lib/padreader"
 	"github.com/filecoin-project/lotus/node/modules/dtypes"
 	"github.com/filecoin-project/lotus/storage"
 )
@@ -33,54 +30,45 @@ const (
 )
 
 var dsPrefix = datastore.NewKey("/sealedblocks")
-var imBlocksPrefix = datastore.NewKey("/intermediate")
 
 var ErrNotFound = errors.New("not found")
 
+func DealIDToDsKey(dealID abi.DealID) datastore.Key {
+	buf := make([]byte, binary.MaxVarintLen64)
+	size := binary.PutUvarint(buf, uint64(dealID))
+	return dshelp.NewKeyFromBinary(buf[:size])
+}
+
+func DsKeyToDealID(key datastore.Key) (uint64, error) {
+	buf, err := dshelp.BinaryFromDsKey(key)
+	if err != nil {
+		return 0, err
+	}
+	dealID, _ := binary.Uvarint(buf)
+	return dealID, nil
+}
+
 type SectorBlocks struct {
 	*storage.Miner
-	sb *sectorbuilder.SectorBuilder
-
-	intermediate blockstore.Blockstore // holds intermediate nodes TODO: consider combining with the staging blockstore
 
 	keys  datastore.Batching
 	keyLk sync.Mutex
 }
 
-func NewSectorBlocks(miner *storage.Miner, ds dtypes.MetadataDS, sb *sectorbuilder.SectorBuilder) *SectorBlocks {
+func NewSectorBlocks(miner *storage.Miner, ds dtypes.MetadataDS) *SectorBlocks {
 	sbc := &SectorBlocks{
 		Miner: miner,
-		sb:    sb,
-
-		intermediate: blockstore.NewBlockstore(namespace.Wrap(ds, imBlocksPrefix)),
-
-		keys: namespace.Wrap(ds, dsPrefix),
+		keys:  namespace.Wrap(ds, dsPrefix),
 	}
 
 	return sbc
 }
 
-type UnixfsReader interface {
-	files.File
-
-	// ReadBlock reads data from a single unixfs block. Data is nil
-	// for intermediate nodes
-	ReadBlock(context.Context) (data []byte, offset uint64, nd ipld.Node, err error)
-}
-
-type refStorer struct {
-	blockReader  UnixfsReader
-	writeRef     func(cid cid.Cid, offset uint64, size uint64) error
-	intermediate blockstore.Blockstore
-
-	remaining []byte
-}
-
-func (st *SectorBlocks) writeRef(cid cid.Cid, sectorID uint64, offset uint64, size uint64) error {
+func (st *SectorBlocks) writeRef(dealID abi.DealID, sectorID abi.SectorNumber, offset abi.PaddedPieceSize, size abi.UnpaddedPieceSize) error {
 	st.keyLk.Lock() // TODO: make this multithreaded
 	defer st.keyLk.Unlock()
 
-	v, err := st.keys.Get(dshelp.CidToDsKey(cid))
+	v, err := st.keys.Get(DealIDToDsKey(dealID))
 	if err == datastore.ErrNotFound {
 		err = nil
 	}
@@ -105,80 +93,25 @@ func (st *SectorBlocks) writeRef(cid cid.Cid, sectorID uint64, offset uint64, si
 	if err != nil {
 		return xerrors.Errorf("serializing refs: %w", err)
 	}
-	return st.keys.Put(dshelp.CidToDsKey(cid), newRef) // TODO: batch somehow
+	return st.keys.Put(DealIDToDsKey(dealID), newRef) // TODO: batch somehow
 }
 
-func (r *refStorer) Read(p []byte) (n int, err error) {
-	offset := 0
-	if len(r.remaining) > 0 {
-		offset += len(r.remaining)
-		read := copy(p, r.remaining)
-		if read == len(r.remaining) {
-			r.remaining = nil
-		} else {
-			r.remaining = r.remaining[read:]
-		}
-		return read, nil
-	}
-
-	for {
-		data, offset, nd, err := r.blockReader.ReadBlock(context.TODO())
-		if err != nil {
-			if err == io.EOF {
-				return 0, io.EOF
-			}
-			return 0, xerrors.Errorf("reading block: %w", err)
-		}
-
-		if len(data) == 0 {
-			// TODO: batch
-			// TODO: GC
-			if err := r.intermediate.Put(nd); err != nil {
-				return 0, xerrors.Errorf("storing intermediate node: %w", err)
-			}
-			continue
-		}
-
-		if err := r.writeRef(nd.Cid(), offset, uint64(len(data))); err != nil {
-			return 0, xerrors.Errorf("writing ref: %w", err)
-		}
-
-		read := copy(p, data)
-		if read < len(data) {
-			r.remaining = data[read:]
-		}
-		// TODO: read multiple
-		return read, nil
-	}
-}
-
-func (st *SectorBlocks) AddUnixfsPiece(ctx context.Context, r UnixfsReader, dealID uint64) (sectorID uint64, err error) {
-	size, err := r.Size()
+func (st *SectorBlocks) AddPiece(ctx context.Context, size abi.UnpaddedPieceSize, r io.Reader, d sealing.DealInfo) (abi.SectorNumber, abi.PaddedPieceSize, error) {
+	sn, offset, err := st.Miner.AddPieceToAnySector(ctx, size, r, d)
 	if err != nil {
-		return 0, err
+		return 0, 0, err
 	}
 
-	sectorID, pieceOffset, err := st.Miner.AllocatePiece(padreader.PaddedSize(uint64(size)))
+	// TODO: DealID has very low finality here
+	err = st.writeRef(d.DealID, sn, offset, size)
 	if err != nil {
-		return 0, err
+		return 0, 0, xerrors.Errorf("writeRef: %w", err)
 	}
 
-	refst := &refStorer{
-		blockReader: r,
-		writeRef: func(cid cid.Cid, offset uint64, size uint64) error {
-			offset += pieceOffset
-
-			return st.writeRef(cid, sectorID, offset, size)
-		},
-		intermediate: st.intermediate,
-	}
-
-	pr, psize := padreader.New(refst, uint64(size))
-
-	return sectorID, st.Miner.SealPiece(ctx, psize, pr, sectorID, dealID)
+	return sn, offset, nil
 }
 
-func (st *SectorBlocks) List() (map[cid.Cid][]api.SealedRef, error) {
+func (st *SectorBlocks) List() (map[uint64][]api.SealedRef, error) {
 	res, err := st.keys.Query(query.Query{})
 	if err != nil {
 		return nil, err
@@ -189,9 +122,9 @@ func (st *SectorBlocks) List() (map[cid.Cid][]api.SealedRef, error) {
 		return nil, err
 	}
 
-	out := map[cid.Cid][]api.SealedRef{}
+	out := map[uint64][]api.SealedRef{}
 	for _, ent := range ents {
-		refCid, err := dshelp.DsKeyToCid(datastore.RawKey(ent.Key))
+		dealID, err := DsKeyToDealID(datastore.RawKey(ent.Key))
 		if err != nil {
 			return nil, err
 		}
@@ -201,14 +134,14 @@ func (st *SectorBlocks) List() (map[cid.Cid][]api.SealedRef, error) {
 			return nil, err
 		}
 
-		out[refCid] = refs.Refs
+		out[dealID] = refs.Refs
 	}
 
 	return out, nil
 }
 
-func (st *SectorBlocks) GetRefs(k cid.Cid) ([]api.SealedRef, error) { // TODO: track local sectors
-	ent, err := st.keys.Get(dshelp.CidToDsKey(k))
+func (st *SectorBlocks) GetRefs(dealID abi.DealID) ([]api.SealedRef, error) { // TODO: track local sectors
+	ent, err := st.keys.Get(DealIDToDsKey(dealID))
 	if err == datastore.ErrNotFound {
 		err = ErrNotFound
 	}
@@ -224,42 +157,16 @@ func (st *SectorBlocks) GetRefs(k cid.Cid) ([]api.SealedRef, error) { // TODO: t
 	return refs.Refs, nil
 }
 
-func (st *SectorBlocks) GetSize(k cid.Cid) (uint64, error) {
-	blk, err := st.intermediate.Get(k)
-	if err == blockstore.ErrNotFound {
-		refs, err := st.GetRefs(k)
-		if err != nil {
-			return 0, err
-		}
-
-		return uint64(refs[0].Size), nil
-	}
+func (st *SectorBlocks) GetSize(dealID abi.DealID) (uint64, error) {
+	refs, err := st.GetRefs(dealID)
 	if err != nil {
 		return 0, err
 	}
 
-	nd, err := ipld.Decode(blk)
-	if err != nil {
-		return 0, err
-	}
-
-	fsn, err := unixfs.ExtractFSNode(nd)
-	if err != nil {
-		return 0, err
-	}
-
-	return fsn.FileSize(), nil
+	return uint64(refs[0].Size), nil
 }
 
-func (st *SectorBlocks) Has(k cid.Cid) (bool, error) {
+func (st *SectorBlocks) Has(dealID abi.DealID) (bool, error) {
 	// TODO: ensure sector is still there
-	return st.keys.Has(dshelp.CidToDsKey(k))
-}
-
-func (st *SectorBlocks) SealedBlockstore(approveUnseal func() error) *SectorBlockStore {
-	return &SectorBlockStore{
-		intermediate:  st.intermediate,
-		sectorBlocks:  st,
-		approveUnseal: approveUnseal,
-	}
+	return st.keys.Has(DealIDToDsKey(dealID))
 }
diff --git a/storage/sectorblocks/blockstore.go b/storage/sectorblocks/blockstore.go
deleted file mode 100644
index b0807ef3a..000000000
--- a/storage/sectorblocks/blockstore.go
+++ /dev/null
@@ -1,125 +0,0 @@
-package sectorblocks
-
-import (
-	"context"
-	"github.com/filecoin-project/lotus/api"
-	"github.com/filecoin-project/lotus/storage"
-	"io/ioutil"
-
-	blocks "github.com/ipfs/go-block-format"
-	"github.com/ipfs/go-cid"
-	blockstore "github.com/ipfs/go-ipfs-blockstore"
-	logging "github.com/ipfs/go-log"
-	"golang.org/x/xerrors"
-)
-
-var log = logging.Logger("sectorblocks")
-
-type SectorBlockStore struct {
-	intermediate blockstore.Blockstore
-	sectorBlocks *SectorBlocks
-
-	approveUnseal func() error
-}
-
-func (s *SectorBlockStore) DeleteBlock(cid.Cid) error {
-	panic("not supported")
-}
-func (s *SectorBlockStore) GetSize(cid.Cid) (int, error) {
-	panic("not supported")
-}
-
-func (s *SectorBlockStore) Put(blocks.Block) error {
-	panic("not supported")
-}
-
-func (s *SectorBlockStore) PutMany([]blocks.Block) error {
-	panic("not supported")
-}
-
-func (s *SectorBlockStore) AllKeysChan(ctx context.Context) (<-chan cid.Cid, error) {
-	panic("not supported")
-}
-
-func (s *SectorBlockStore) HashOnRead(enabled bool) {
-	panic("not supported")
-}
-
-func (s *SectorBlockStore) Has(c cid.Cid) (bool, error) {
-	has, err := s.intermediate.Has(c)
-	if err != nil {
-		return false, err
-	}
-	if has {
-		return true, nil
-	}
-
-	return s.sectorBlocks.Has(c)
-}
-
-func (s *SectorBlockStore) Get(c cid.Cid) (blocks.Block, error) {
-	val, err := s.intermediate.Get(c)
-	if err == nil {
-		return val, nil
-	}
-	if err != blockstore.ErrNotFound {
-		return nil, err
-	}
-
-	refs, err := s.sectorBlocks.GetRefs(c)
-	if err != nil {
-		return nil, err
-	}
-	if len(refs) == 0 {
-		return nil, blockstore.ErrNotFound
-	}
-
-	// TODO: better strategy (e.g. look for already unsealed)
-	var best api.SealedRef
-	var bestSi storage.SectorInfo
-	for _, r := range refs {
-		si, err := s.sectorBlocks.Miner.GetSectorInfo(r.SectorID)
-		if err != nil {
-			return nil, xerrors.Errorf("getting sector info: %w", err)
-		}
-		if si.State == api.Proving {
-			best = r
-			bestSi = si
-			break
-		}
-	}
-	if bestSi.State == api.UndefinedSectorState {
-		return nil, xerrors.New("no sealed sector found")
-	}
-
-	log.Infof("reading block %s from sector %d(+%d;%d)", c, best.SectorID, best.Offset, best.Size)
-
-	r, err := s.sectorBlocks.sb.ReadPieceFromSealedSector(
-		best.SectorID,
-		best.Offset,
-		best.Size,
-		bestSi.Ticket.TicketBytes,
-		bestSi.CommD,
-	)
-	if err != nil {
-		return nil, xerrors.Errorf("unsealing block: %w", err)
-	}
-	defer r.Close()
-
-	data, err := ioutil.ReadAll(r)
-	if err != nil {
-		return nil, xerrors.Errorf("reading block data: %w", err)
-	}
-	if uint64(len(data)) != best.Size {
-		return nil, xerrors.Errorf("got wrong amount of data: %d != !d", len(data), best.Size)
-	}
-
-	b, err := blocks.NewBlockWithCid(data, c)
-	if err != nil {
-		return nil, xerrors.Errorf("sbs get (%d[%d:%d]): %w", best.SectorID, best.Offset, best.Offset+best.Size, err)
-	}
-
-	return b, nil
-}
-
-var _ blockstore.Blockstore = &SectorBlockStore{}
diff --git a/storage/sectors.go b/storage/sectors.go
deleted file mode 100644
index e8894749e..000000000
--- a/storage/sectors.go
+++ /dev/null
@@ -1,318 +0,0 @@
-package storage
-
-import (
-	"context"
-	"fmt"
-	"io"
-	"math"
-
-	sectorbuilder "github.com/filecoin-project/go-sectorbuilder"
-	xerrors "golang.org/x/xerrors"
-
-	"github.com/filecoin-project/lotus/api"
-	"github.com/filecoin-project/lotus/lib/padreader"
-)
-
-const NonceIncrement = math.MaxUint64
-
-type sectorUpdate struct {
-	newState api.SectorState
-	id       uint64
-	err      error
-	nonce    uint64
-	mut      func(*SectorInfo)
-}
-
-func (u *sectorUpdate) fatal(err error) *sectorUpdate {
-	u.newState = api.FailedUnrecoverable
-	u.err = err
-	return u
-}
-
-func (u *sectorUpdate) error(err error) *sectorUpdate {
-	u.err = err
-	return u
-}
-
-func (u *sectorUpdate) state(m func(*SectorInfo)) *sectorUpdate {
-	u.mut = m
-	return u
-}
-
-func (u *sectorUpdate) to(newState api.SectorState) *sectorUpdate {
-	u.newState = newState
-	return u
-}
-
-func (u *sectorUpdate) setNonce(nc uint64) *sectorUpdate {
-	u.nonce = nc
-	return u
-}
-
-func (m *Miner) UpdateSectorState(ctx context.Context, sector uint64, snonce uint64, state api.SectorState) error {
-	select {
-	case m.sectorUpdated <- sectorUpdate{
-		newState: state,
-		nonce:    snonce,
-		id:       sector,
-	}:
-		return nil
-	case <-ctx.Done():
-		return ctx.Err()
-	}
-}
-
-func (m *Miner) sectorStateLoop(ctx context.Context) error {
-	trackedSectors, err := m.ListSectors()
-	if err != nil {
-		log.Errorf("loading sector list: %+v", err)
-	}
-
-	go func() {
-		for _, si := range trackedSectors {
-			select {
-			case m.sectorUpdated <- sectorUpdate{
-				newState: si.State,
-				nonce:    si.Nonce,
-				id:       si.SectorID,
-				err:      nil,
-				mut:      nil,
-			}:
-			case <-ctx.Done():
-				log.Warn("didn't restart processing for all sectors: ", ctx.Err())
-				return
-			}
-		}
-	}()
-
-	{
-		// verify on-chain state
-		trackedByID := map[uint64]*SectorInfo{}
-		for _, si := range trackedSectors {
-			i := si
-			trackedByID[si.SectorID] = &i
-		}
-
-		curTs, err := m.api.ChainHead(ctx)
-		if err != nil {
-			return xerrors.Errorf("getting chain head: %w", err)
-		}
-
-		ps, err := m.api.StateMinerProvingSet(ctx, m.maddr, curTs)
-		if err != nil {
-			return xerrors.Errorf("getting miner proving set: %w", err)
-		}
-		for _, ocs := range ps {
-			if _, ok := trackedByID[ocs.SectorID]; ok {
-				continue // TODO: check state
-			}
-
-			// TODO: attempt recovery
-			log.Warnf("untracked sector %d found on chain", ocs.SectorID)
-		}
-	}
-
-	go func() {
-		defer log.Warn("quitting deal provider loop")
-		defer close(m.stopped)
-
-		for {
-			select {
-			case sector := <-m.sectorIncoming:
-				m.onSectorIncoming(sector)
-			case update := <-m.sectorUpdated:
-				m.onSectorUpdated(ctx, update)
-			case <-m.stop:
-				return
-			}
-		}
-	}()
-
-	return nil
-}
-
-func (m *Miner) onSectorIncoming(sector *SectorInfo) {
-	has, err := m.sectors.Has(sector.SectorID)
-	if err != nil {
-		return
-	}
-	if has {
-		log.Warnf("SealPiece called more than once for sector %d", sector.SectorID)
-		return
-	}
-
-	if err := m.sectors.Begin(sector.SectorID, sector); err != nil {
-		log.Errorf("sector tracking failed: %s", err)
-		return
-	}
-
-	go func() {
-		select {
-		case m.sectorUpdated <- sectorUpdate{
-			newState: api.Packing,
-			id:       sector.SectorID,
-		}:
-		case <-m.stop:
-			log.Warn("failed to send incoming sector update, miner shutting down")
-		}
-	}()
-}
-
-func (m *Miner) onSectorUpdated(ctx context.Context, update sectorUpdate) {
-	log.Infof("Sector %d updated state to %s", update.id, api.SectorStates[update.newState])
-	var sector SectorInfo
-	err := m.sectors.Mutate(update.id, func(s *SectorInfo) error {
-		if update.nonce < s.Nonce {
-			return xerrors.Errorf("update nonce too low, ignoring (%d < %d)", update.nonce, s.Nonce)
-		}
-
-		if update.nonce != NonceIncrement {
-			s.Nonce = update.nonce
-		} else {
-			s.Nonce++ // forced update
-		}
-		s.State = update.newState
-		if update.err != nil {
-			if s.LastErr != "" {
-				s.LastErr += "---------\n\n"
-			}
-			s.LastErr += fmt.Sprintf("entering state %s: %+v", api.SectorStates[update.newState], update.err)
-		}
-
-		if update.mut != nil {
-			update.mut(s)
-		}
-		sector = *s
-		return nil
-	})
-	if update.err != nil {
-		log.Errorf("sector %d failed: %+v", update.id, update.err)
-	}
-	if err != nil {
-		log.Errorf("sector %d update error: %+v", update.id, err)
-		return
-	}
-
-	/*
-
-		*   Empty
-		|   |
-		|   v
-		*<- Packing <- incoming
-		|   |
-		|   v
-		*<- Unsealed <--> SealFailed
-		|   |
-		|   v
-		*   PreCommitting <--> PreCommitFailed
-		|   |                  ^
-		|   v                  |
-		*<- PreCommitted ------/
-		|   |||
-		|   vvv      v--> SealCommitFailed
-		*<- Committing
-		|   |        ^--> CommitFailed
-		|   v             ^
-		*<- CommitWait ---/
-		|   |
-		|   v
-		*<- Proving
-		|
-		v
-		FailedUnrecoverable
-
-		UndefinedSectorState <- ¯\_(ツ)_/¯
-		    |                     ^
-		    *---------------------/
-
-	*/
-
-	switch update.newState {
-	// Happy path
-	case api.Packing:
-		m.handleSectorUpdate(ctx, sector, m.handlePacking)
-	case api.Unsealed:
-		m.handleSectorUpdate(ctx, sector, m.handleUnsealed)
-	case api.PreCommitting:
-		m.handleSectorUpdate(ctx, sector, m.handlePreCommitting)
-	case api.PreCommitted:
-		m.handleSectorUpdate(ctx, sector, m.handlePreCommitted)
-	case api.Committing:
-		m.handleSectorUpdate(ctx, sector, m.handleCommitting)
-	case api.CommitWait:
-		m.handleSectorUpdate(ctx, sector, m.handleCommitWait)
-	case api.Proving:
-		// TODO: track sector health / expiration
-		log.Infof("Proving sector %d", update.id)
-
-	// Handled failure modes
-	case api.SealFailed:
-		log.Warnf("sector %d entered unimplemented state 'SealFailed'", update.id)
-	case api.PreCommitFailed:
-		log.Warnf("sector %d entered unimplemented state 'PreCommitFailed'", update.id)
-	case api.SealCommitFailed:
-		log.Warnf("sector %d entered unimplemented state 'SealCommitFailed'", update.id)
-	case api.CommitFailed:
-		log.Warnf("sector %d entered unimplemented state 'CommitFailed'", update.id)
-
-		// Faults
-	case api.Faulty:
-		m.handleSectorUpdate(ctx, sector, m.handleFaulty)
-	case api.FaultReported:
-		m.handleSectorUpdate(ctx, sector, m.handleFaultReported)
-
-	// Fatal errors
-	case api.UndefinedSectorState:
-		log.Error("sector update with undefined state!")
-	case api.FailedUnrecoverable:
-		log.Errorf("sector %d failed unrecoverably", update.id)
-	default:
-		log.Errorf("unexpected sector update state: %d", update.newState)
-	}
-}
-
-func (m *Miner) AllocatePiece(size uint64) (sectorID uint64, offset uint64, err error) {
-	if padreader.PaddedSize(size) != size {
-		return 0, 0, xerrors.Errorf("cannot allocate unpadded piece")
-	}
-
-	sid, err := m.sb.AcquireSectorId() // TODO: Put more than one thing in a sector
-	if err != nil {
-		return 0, 0, xerrors.Errorf("acquiring sector ID: %w", err)
-	}
-
-	// offset hard-coded to 0 since we only put one thing in a sector for now
-	return sid, 0, nil
-}
-
-func (m *Miner) SealPiece(ctx context.Context, size uint64, r io.Reader, sectorID uint64, dealID uint64) error {
-	log.Infof("Seal piece for deal %d", dealID)
-
-	ppi, err := m.sb.AddPiece(size, sectorID, r, []uint64{})
-	if err != nil {
-		return xerrors.Errorf("adding piece to sector: %w", err)
-	}
-
-	return m.newSector(ctx, sectorID, dealID, ppi)
-}
-
-func (m *Miner) newSector(ctx context.Context, sid uint64, dealID uint64, ppi sectorbuilder.PublicPieceInfo) error {
-	si := &SectorInfo{
-		SectorID: sid,
-
-		Pieces: []Piece{
-			{
-				DealID: dealID,
-
-				Size:  ppi.Size,
-				CommP: ppi.CommP[:],
-			},
-		},
-	}
-	select {
-	case m.sectorIncoming <- si:
-		return nil
-	case <-ctx.Done():
-		return xerrors.Errorf("failed to submit sector for sealing, queue full: %w", ctx.Err())
-	}
-}
diff --git a/storage/sectors_test.go b/storage/sectors_test.go
deleted file mode 100644
index 111a00aed..000000000
--- a/storage/sectors_test.go
+++ /dev/null
@@ -1,56 +0,0 @@
-package storage
-
-import (
-	"bytes"
-	"testing"
-
-	"gotest.tools/assert"
-
-	"github.com/filecoin-project/go-cbor-util"
-)
-
-func TestSectorInfoSelialization(t *testing.T) {
-	si := &SectorInfo{
-		State:    123,
-		SectorID: 234,
-		Nonce:    345,
-		Pieces: []Piece{{
-			DealID: 1234,
-			Size:   5,
-			CommP:  []byte{3},
-		}},
-		CommD: []byte{32, 4},
-		CommR: nil,
-		Proof: nil,
-		Ticket: SealTicket{
-			BlockHeight: 345,
-			TicketBytes: []byte{87, 78, 7, 87},
-		},
-		PreCommitMessage: nil,
-		Seed:             SealSeed{},
-		CommitMessage:    nil,
-		FaultReportMsg:   nil,
-		LastErr:          "hi",
-	}
-
-	b, err := cborutil.Dump(si)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	var si2 SectorInfo
-	if err := cborutil.ReadCborRPC(bytes.NewReader(b), &si); err != nil {
-		return
-	}
-
-	assert.Equal(t, si.State, si2.State)
-	assert.Equal(t, si.Nonce, si2.Nonce)
-	assert.Equal(t, si.SectorID, si2.SectorID)
-
-	assert.Equal(t, si.Pieces, si2.Pieces)
-	assert.Equal(t, si.CommD, si2.CommD)
-	assert.Equal(t, si.Ticket, si2.Ticket)
-
-	assert.Equal(t, si, si2)
-
-}
diff --git a/storage/wdpost_journal.go b/storage/wdpost_journal.go
new file mode 100644
index 000000000..48eb2f2b1
--- /dev/null
+++ b/storage/wdpost_journal.go
@@ -0,0 +1,75 @@
+package storage
+
+import (
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/dline"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
+
+	"github.com/ipfs/go-cid"
+)
+
+// SchedulerState defines the possible states in which the scheduler could be,
+// for the purposes of journalling.
+type SchedulerState string
+
+const (
+	// SchedulerStateStarted gets recorded when a WdPoSt cycle for an
+	// epoch begins.
+	SchedulerStateStarted = SchedulerState("started")
+	// SchedulerStateAborted gets recorded when a WdPoSt cycle for an
+	// epoch is aborted, normally because of a chain reorg or advancement.
+	SchedulerStateAborted = SchedulerState("aborted")
+	// SchedulerStateFaulted gets recorded when a WdPoSt cycle for an
+	// epoch terminates abnormally, in which case the error is also recorded.
+	SchedulerStateFaulted = SchedulerState("faulted")
+	// SchedulerStateSucceeded gets recorded when a WdPoSt cycle for an
+	// epoch ends successfully.
+	SchedulerStateSucceeded = SchedulerState("succeeded")
+)
+
+// Journal event types.
+const (
+	evtTypeWdPoStScheduler = iota
+	evtTypeWdPoStProofs
+	evtTypeWdPoStRecoveries
+	evtTypeWdPoStFaults
+)
+
+// evtCommon is a common set of attributes for Windowed PoSt journal events.
+type evtCommon struct {
+	Deadline *dline.Info
+	Height   abi.ChainEpoch
+	TipSet   []cid.Cid
+	Error    error `json:",omitempty"`
+}
+
+// WdPoStSchedulerEvt is the journal event that gets recorded on scheduler
+// actions.
+type WdPoStSchedulerEvt struct {
+	evtCommon
+	State SchedulerState
+}
+
+// WdPoStProofsProcessedEvt is the journal event that gets recorded when
+// Windowed PoSt proofs have been processed.
+type WdPoStProofsProcessedEvt struct {
+	evtCommon
+	Partitions []miner.PoStPartition
+	MessageCID cid.Cid `json:",omitempty"`
+}
+
+// WdPoStRecoveriesProcessedEvt is the journal event that gets recorded when
+// Windowed PoSt recoveries have been processed.
+type WdPoStRecoveriesProcessedEvt struct {
+	evtCommon
+	Declarations []miner.RecoveryDeclaration
+	MessageCID   cid.Cid `json:",omitempty"`
+}
+
+// WdPoStFaultsProcessedEvt is the journal event that gets recorded when
+// Windowed PoSt faults have been processed.
+type WdPoStFaultsProcessedEvt struct {
+	evtCommon
+	Declarations []miner.FaultDeclaration
+	MessageCID   cid.Cid `json:",omitempty"`
+}
diff --git a/storage/wdpost_run.go b/storage/wdpost_run.go
new file mode 100644
index 000000000..59ffcb74c
--- /dev/null
+++ b/storage/wdpost_run.go
@@ -0,0 +1,714 @@
+package storage
+
+import (
+	"bytes"
+	"context"
+	"time"
+
+	"github.com/filecoin-project/go-bitfield"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/big"
+	"github.com/filecoin-project/go-state-types/crypto"
+	"github.com/filecoin-project/go-state-types/dline"
+	"github.com/ipfs/go-cid"
+
+	"go.opencensus.io/trace"
+	"golang.org/x/xerrors"
+
+	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
+	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
+	"github.com/filecoin-project/specs-actors/actors/runtime/proof"
+
+	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/actors"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
+	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/journal"
+)
+
+func (s *WindowPoStScheduler) failPost(err error, deadline *dline.Info) {
+	journal.J.RecordEvent(s.evtTypes[evtTypeWdPoStScheduler], func() interface{} {
+		return WdPoStSchedulerEvt{
+			evtCommon: s.getEvtCommon(err),
+			State:     SchedulerStateFaulted,
+		}
+	})
+
+	log.Errorf("TODO")
+	/*s.failLk.Lock()
+	if eps > s.failed {
+		s.failed = eps
+	}
+	s.failLk.Unlock()*/
+}
+
+func (s *WindowPoStScheduler) doPost(ctx context.Context, deadline *dline.Info, ts *types.TipSet) {
+	ctx, abort := context.WithCancel(ctx)
+
+	s.abort = abort
+	s.activeDeadline = deadline
+
+	journal.J.RecordEvent(s.evtTypes[evtTypeWdPoStScheduler], func() interface{} {
+		return WdPoStSchedulerEvt{
+			evtCommon: s.getEvtCommon(nil),
+			State:     SchedulerStateStarted,
+		}
+	})
+
+	go func() {
+		defer abort()
+
+		ctx, span := trace.StartSpan(ctx, "WindowPoStScheduler.doPost")
+		defer span.End()
+
+		// recordProofsEvent records a successful proofs_processed event in the
+		// journal, even if it was a noop (no partitions).
+		recordProofsEvent := func(partitions []miner.PoStPartition, mcid cid.Cid) {
+			journal.J.RecordEvent(s.evtTypes[evtTypeWdPoStProofs], func() interface{} {
+				return &WdPoStProofsProcessedEvt{
+					evtCommon:  s.getEvtCommon(nil),
+					Partitions: partitions,
+					MessageCID: mcid,
+				}
+			})
+		}
+
+		posts, err := s.runPost(ctx, *deadline, ts)
+		if err != nil {
+			log.Errorf("run window post failed: %+v", err)
+			s.failPost(err, deadline)
+			return
+		}
+
+		if len(posts) == 0 {
+			recordProofsEvent(nil, cid.Undef)
+			return
+		}
+
+		for i := range posts {
+			post := &posts[i]
+			sm, err := s.submitPost(ctx, post)
+			if err != nil {
+				log.Errorf("submit window post failed: %+v", err)
+				s.failPost(err, deadline)
+			} else {
+				recordProofsEvent(post.Partitions, sm.Cid())
+			}
+		}
+
+		journal.J.RecordEvent(s.evtTypes[evtTypeWdPoStScheduler], func() interface{} {
+			return WdPoStSchedulerEvt{
+				evtCommon: s.getEvtCommon(nil),
+				State:     SchedulerStateSucceeded,
+			}
+		})
+	}()
+}
+
+func (s *WindowPoStScheduler) checkSectors(ctx context.Context, check bitfield.BitField) (bitfield.BitField, error) {
+	spt, err := s.proofType.RegisteredSealProof()
+	if err != nil {
+		return bitfield.BitField{}, xerrors.Errorf("getting seal proof type: %w", err)
+	}
+
+	mid, err := address.IDFromAddress(s.actor)
+	if err != nil {
+		return bitfield.BitField{}, err
+	}
+
+	sectors := make(map[abi.SectorID]struct{})
+	var tocheck []abi.SectorID
+	err = check.ForEach(func(snum uint64) error {
+		s := abi.SectorID{
+			Miner:  abi.ActorID(mid),
+			Number: abi.SectorNumber(snum),
+		}
+
+		tocheck = append(tocheck, s)
+		sectors[s] = struct{}{}
+		return nil
+	})
+	if err != nil {
+		return bitfield.BitField{}, xerrors.Errorf("iterating over bitfield: %w", err)
+	}
+
+	bad, err := s.faultTracker.CheckProvable(ctx, spt, tocheck)
+	if err != nil {
+		return bitfield.BitField{}, xerrors.Errorf("checking provable sectors: %w", err)
+	}
+	for _, id := range bad {
+		delete(sectors, id)
+	}
+
+	log.Warnw("Checked sectors", "checked", len(tocheck), "good", len(sectors))
+
+	sbf := bitfield.New()
+	for s := range sectors {
+		sbf.Set(uint64(s.Number))
+	}
+
+	return sbf, nil
+}
+
+func (s *WindowPoStScheduler) checkNextRecoveries(ctx context.Context, dlIdx uint64, partitions []api.Partition) ([]miner.RecoveryDeclaration, *types.SignedMessage, error) {
+	ctx, span := trace.StartSpan(ctx, "storage.checkNextRecoveries")
+	defer span.End()
+
+	faulty := uint64(0)
+	params := &miner.DeclareFaultsRecoveredParams{
+		Recoveries: []miner.RecoveryDeclaration{},
+	}
+
+	for partIdx, partition := range partitions {
+		unrecovered, err := bitfield.SubtractBitField(partition.FaultySectors, partition.RecoveringSectors)
+		if err != nil {
+			return nil, nil, xerrors.Errorf("subtracting recovered set from fault set: %w", err)
+		}
+
+		uc, err := unrecovered.Count()
+		if err != nil {
+			return nil, nil, xerrors.Errorf("counting unrecovered sectors: %w", err)
+		}
+
+		if uc == 0 {
+			continue
+		}
+
+		faulty += uc
+
+		recovered, err := s.checkSectors(ctx, unrecovered)
+		if err != nil {
+			return nil, nil, xerrors.Errorf("checking unrecovered sectors: %w", err)
+		}
+
+		// if all sectors failed to recover, don't declare recoveries
+		recoveredCount, err := recovered.Count()
+		if err != nil {
+			return nil, nil, xerrors.Errorf("counting recovered sectors: %w", err)
+		}
+
+		if recoveredCount == 0 {
+			continue
+		}
+
+		params.Recoveries = append(params.Recoveries, miner.RecoveryDeclaration{
+			Deadline:  dlIdx,
+			Partition: uint64(partIdx),
+			Sectors:   recovered,
+		})
+	}
+
+	recoveries := params.Recoveries
+	if len(recoveries) == 0 {
+		if faulty != 0 {
+			log.Warnw("No recoveries to declare", "deadline", dlIdx, "faulty", faulty)
+		}
+
+		return recoveries, nil, nil
+	}
+
+	enc, aerr := actors.SerializeParams(params)
+	if aerr != nil {
+		return recoveries, nil, xerrors.Errorf("could not serialize declare recoveries parameters: %w", aerr)
+	}
+
+	msg := &types.Message{
+		To:     s.actor,
+		From:   s.worker,
+		Method: builtin0.MethodsMiner.DeclareFaultsRecovered,
+		Params: enc,
+		Value:  types.NewInt(0),
+	}
+	spec := &api.MessageSendSpec{MaxFee: abi.TokenAmount(s.feeCfg.MaxWindowPoStGasFee)}
+	s.setSender(ctx, msg, spec)
+
+	sm, err := s.api.MpoolPushMessage(ctx, msg, &api.MessageSendSpec{MaxFee: abi.TokenAmount(s.feeCfg.MaxWindowPoStGasFee)})
+	if err != nil {
+		return recoveries, sm, xerrors.Errorf("pushing message to mpool: %w", err)
+	}
+
+	log.Warnw("declare faults recovered Message CID", "cid", sm.Cid())
+
+	rec, err := s.api.StateWaitMsg(context.TODO(), sm.Cid(), build.MessageConfidence)
+	if err != nil {
+		return recoveries, sm, xerrors.Errorf("declare faults recovered wait error: %w", err)
+	}
+
+	if rec.Receipt.ExitCode != 0 {
+		return recoveries, sm, xerrors.Errorf("declare faults recovered wait non-0 exit code: %d", rec.Receipt.ExitCode)
+	}
+
+	return recoveries, sm, nil
+}
+
+func (s *WindowPoStScheduler) checkNextFaults(ctx context.Context, dlIdx uint64, partitions []api.Partition) ([]miner.FaultDeclaration, *types.SignedMessage, error) {
+	ctx, span := trace.StartSpan(ctx, "storage.checkNextFaults")
+	defer span.End()
+
+	bad := uint64(0)
+	params := &miner.DeclareFaultsParams{
+		Faults: []miner.FaultDeclaration{},
+	}
+
+	for partIdx, partition := range partitions {
+		good, err := s.checkSectors(ctx, partition.ActiveSectors)
+		if err != nil {
+			return nil, nil, xerrors.Errorf("checking sectors: %w", err)
+		}
+
+		faulty, err := bitfield.SubtractBitField(partition.ActiveSectors, good)
+		if err != nil {
+			return nil, nil, xerrors.Errorf("calculating faulty sector set: %w", err)
+		}
+
+		c, err := faulty.Count()
+		if err != nil {
+			return nil, nil, xerrors.Errorf("counting faulty sectors: %w", err)
+		}
+
+		if c == 0 {
+			continue
+		}
+
+		bad += c
+
+		params.Faults = append(params.Faults, miner.FaultDeclaration{
+			Deadline:  dlIdx,
+			Partition: uint64(partIdx),
+			Sectors:   faulty,
+		})
+	}
+
+	faults := params.Faults
+	if len(faults) == 0 {
+		return faults, nil, nil
+	}
+
+	log.Errorw("DETECTED FAULTY SECTORS, declaring faults", "count", bad)
+
+	enc, aerr := actors.SerializeParams(params)
+	if aerr != nil {
+		return faults, nil, xerrors.Errorf("could not serialize declare faults parameters: %w", aerr)
+	}
+
+	msg := &types.Message{
+		To:     s.actor,
+		From:   s.worker,
+		Method: builtin0.MethodsMiner.DeclareFaults,
+		Params: enc,
+		Value:  types.NewInt(0), // TODO: Is there a fee?
+	}
+	spec := &api.MessageSendSpec{MaxFee: abi.TokenAmount(s.feeCfg.MaxWindowPoStGasFee)}
+	s.setSender(ctx, msg, spec)
+
+	sm, err := s.api.MpoolPushMessage(ctx, msg, spec)
+	if err != nil {
+		return faults, sm, xerrors.Errorf("pushing message to mpool: %w", err)
+	}
+
+	log.Warnw("declare faults Message CID", "cid", sm.Cid())
+
+	rec, err := s.api.StateWaitMsg(context.TODO(), sm.Cid(), build.MessageConfidence)
+	if err != nil {
+		return faults, sm, xerrors.Errorf("declare faults wait error: %w", err)
+	}
+
+	if rec.Receipt.ExitCode != 0 {
+		return faults, sm, xerrors.Errorf("declare faults wait non-0 exit code: %d", rec.Receipt.ExitCode)
+	}
+
+	return faults, sm, nil
+}
+
+func (s *WindowPoStScheduler) runPost(ctx context.Context, di dline.Info, ts *types.TipSet) ([]miner.SubmitWindowedPoStParams, error) {
+	ctx, span := trace.StartSpan(ctx, "storage.runPost")
+	defer span.End()
+
+	go func() {
+		// TODO: extract from runPost, run on fault cutoff boundaries
+
+		// check faults / recoveries for the *next* deadline. It's already too
+		// late to declare them for this deadline
+		declDeadline := (di.Index + 2) % di.WPoStPeriodDeadlines
+
+		partitions, err := s.api.StateMinerPartitions(context.TODO(), s.actor, declDeadline, ts.Key())
+		if err != nil {
+			log.Errorf("getting partitions: %v", err)
+			return
+		}
+
+		var (
+			sigmsg     *types.SignedMessage
+			recoveries []miner.RecoveryDeclaration
+			faults     []miner.FaultDeclaration
+
+			// optionalCid returns the CID of the message, or cid.Undef is the
+			// message is nil. We don't need the argument (could capture the
+			// pointer), but it's clearer and purer like that.
+			optionalCid = func(sigmsg *types.SignedMessage) cid.Cid {
+				if sigmsg == nil {
+					return cid.Undef
+				}
+				return sigmsg.Cid()
+			}
+		)
+
+		if recoveries, sigmsg, err = s.checkNextRecoveries(context.TODO(), declDeadline, partitions); err != nil {
+			// TODO: This is potentially quite bad, but not even trying to post when this fails is objectively worse
+			log.Errorf("checking sector recoveries: %v", err)
+		}
+
+		journal.J.RecordEvent(s.evtTypes[evtTypeWdPoStRecoveries], func() interface{} {
+			j := WdPoStRecoveriesProcessedEvt{
+				evtCommon:    s.getEvtCommon(err),
+				Declarations: recoveries,
+				MessageCID:   optionalCid(sigmsg),
+			}
+			j.Error = err
+			return j
+		})
+
+		if ts.Height() > build.UpgradeIgnitionHeight {
+			return // FORK: declaring faults after ignition upgrade makes no sense
+		}
+
+		if faults, sigmsg, err = s.checkNextFaults(context.TODO(), declDeadline, partitions); err != nil {
+			// TODO: This is also potentially really bad, but we try to post anyways
+			log.Errorf("checking sector faults: %v", err)
+		}
+
+		journal.J.RecordEvent(s.evtTypes[evtTypeWdPoStFaults], func() interface{} {
+			return WdPoStFaultsProcessedEvt{
+				evtCommon:    s.getEvtCommon(err),
+				Declarations: faults,
+				MessageCID:   optionalCid(sigmsg),
+			}
+		})
+	}()
+
+	buf := new(bytes.Buffer)
+	if err := s.actor.MarshalCBOR(buf); err != nil {
+		return nil, xerrors.Errorf("failed to marshal address to cbor: %w", err)
+	}
+
+	rand, err := s.api.ChainGetRandomnessFromBeacon(ctx, ts.Key(), crypto.DomainSeparationTag_WindowedPoStChallengeSeed, di.Challenge, buf.Bytes())
+	if err != nil {
+		return nil, xerrors.Errorf("failed to get chain randomness for window post (ts=%d; deadline=%d): %w", ts.Height(), di, err)
+	}
+
+	// Get the partitions for the given deadline
+	partitions, err := s.api.StateMinerPartitions(ctx, s.actor, di.Index, ts.Key())
+	if err != nil {
+		return nil, xerrors.Errorf("getting partitions: %w", err)
+	}
+
+	// Split partitions into batches, so as not to exceed the number of sectors
+	// allowed in a single message
+	partitionBatches, err := s.batchPartitions(partitions)
+	if err != nil {
+		return nil, err
+	}
+
+	// Generate proofs in batches
+	posts := make([]miner.SubmitWindowedPoStParams, 0, len(partitionBatches))
+	for batchIdx, batch := range partitionBatches {
+		batchPartitionStartIdx := 0
+		for _, batch := range partitionBatches[:batchIdx] {
+			batchPartitionStartIdx += len(batch)
+		}
+
+		params := miner.SubmitWindowedPoStParams{
+			Deadline:   di.Index,
+			Partitions: make([]miner.PoStPartition, 0, len(batch)),
+			Proofs:     nil,
+		}
+
+		skipCount := uint64(0)
+		postSkipped := bitfield.New()
+		var postOut []proof.PoStProof
+		somethingToProve := true
+
+		for retries := 0; retries < 5; retries++ {
+			var partitions []miner.PoStPartition
+			var sinfos []proof.SectorInfo
+			for partIdx, partition := range batch {
+				// TODO: Can do this in parallel
+				toProve, err := bitfield.MergeBitFields(partition.ActiveSectors, partition.RecoveringSectors)
+				if err != nil {
+					return nil, xerrors.Errorf("adding recoveries to set of sectors to prove: %w", err)
+				}
+
+				good, err := s.checkSectors(ctx, toProve)
+				if err != nil {
+					return nil, xerrors.Errorf("checking sectors to skip: %w", err)
+				}
+
+				good, err = bitfield.SubtractBitField(good, postSkipped)
+				if err != nil {
+					return nil, xerrors.Errorf("toProve - postSkipped: %w", err)
+				}
+
+				skipped, err := bitfield.SubtractBitField(toProve, good)
+				if err != nil {
+					return nil, xerrors.Errorf("toProve - good: %w", err)
+				}
+
+				sc, err := skipped.Count()
+				if err != nil {
+					return nil, xerrors.Errorf("getting skipped sector count: %w", err)
+				}
+
+				skipCount += sc
+
+				ssi, err := s.sectorsForProof(ctx, good, partition.AllSectors, ts)
+				if err != nil {
+					return nil, xerrors.Errorf("getting sorted sector info: %w", err)
+				}
+
+				if len(ssi) == 0 {
+					continue
+				}
+
+				sinfos = append(sinfos, ssi...)
+				partitions = append(partitions, miner.PoStPartition{
+					Index:   uint64(batchPartitionStartIdx + partIdx),
+					Skipped: skipped,
+				})
+			}
+
+			if len(sinfos) == 0 {
+				// nothing to prove for this batch
+				somethingToProve = false
+				break
+			}
+
+			// Generate proof
+			log.Infow("running window post",
+				"chain-random", rand,
+				"deadline", di,
+				"height", ts.Height(),
+				"skipped", skipCount)
+
+			tsStart := build.Clock.Now()
+
+			mid, err := address.IDFromAddress(s.actor)
+			if err != nil {
+				return nil, err
+			}
+
+			var ps []abi.SectorID
+			postOut, ps, err = s.prover.GenerateWindowPoSt(ctx, abi.ActorID(mid), sinfos, abi.PoStRandomness(rand))
+			elapsed := time.Since(tsStart)
+
+			log.Infow("computing window post", "batch", batchIdx, "elapsed", elapsed)
+
+			if err == nil {
+				// Proof generation successful, stop retrying
+				params.Partitions = append(params.Partitions, partitions...)
+
+				break
+			}
+
+			// Proof generation failed, so retry
+
+			if len(ps) == 0 {
+				return nil, xerrors.Errorf("running window post failed: %w", err)
+			}
+
+			log.Warnw("generate window post skipped sectors", "sectors", ps, "error", err, "try", retries)
+
+			skipCount += uint64(len(ps))
+			for _, sector := range ps {
+				postSkipped.Set(uint64(sector.Number))
+			}
+		}
+
+		// Nothing to prove for this batch, try the next batch
+		if !somethingToProve {
+			continue
+		}
+
+		if len(postOut) == 0 {
+			return nil, xerrors.Errorf("received no proofs back from generate window post")
+		}
+
+		params.Proofs = postOut
+
+		posts = append(posts, params)
+	}
+
+	// Compute randomness after generating proofs so as to reduce the impact
+	// of chain reorgs (which change randomness)
+	commEpoch := di.Open
+	commRand, err := s.api.ChainGetRandomnessFromTickets(ctx, ts.Key(), crypto.DomainSeparationTag_PoStChainCommit, commEpoch, nil)
+	if err != nil {
+		return nil, xerrors.Errorf("failed to get chain randomness for window post (ts=%d; deadline=%d): %w", ts.Height(), commEpoch, err)
+	}
+
+	for i := range posts {
+		posts[i].ChainCommitEpoch = commEpoch
+		posts[i].ChainCommitRand = commRand
+	}
+
+	return posts, nil
+}
+
+func (s *WindowPoStScheduler) batchPartitions(partitions []api.Partition) ([][]api.Partition, error) {
+	// Get the number of sectors allowed in a partition, for this proof size
+	sectorsPerPartition, err := builtin0.PoStProofWindowPoStPartitionSectors(s.proofType)
+	if err != nil {
+		return nil, xerrors.Errorf("getting sectors per partition: %w", err)
+	}
+
+	// We don't want to exceed the number of sectors allowed in a message.
+	// So given the number of sectors in a partition, work out the number of
+	// partitions that can be in a message without exceeding sectors per
+	// message:
+	// floor(number of sectors allowed in a message / sectors per partition)
+	// eg:
+	// max sectors per message  7:  ooooooo
+	// sectors per partition    3:  ooo
+	// partitions per message   2:  oooOOO
+	//                              <1><2> (3rd doesn't fit)
+	// TODO(NETUPGRADE): we're going to need some form of policy abstraction
+	// where we can get policy from the future. Unfortunately, we can't just get this from the state.
+	partitionsPerMsg := int(miner0.AddressedSectorsMax / sectorsPerPartition)
+
+	// The number of messages will be:
+	// ceiling(number of partitions / partitions per message)
+	batchCount := len(partitions) / partitionsPerMsg
+	if len(partitions)%partitionsPerMsg != 0 {
+		batchCount++
+	}
+
+	// Split the partitions into batches
+	batches := make([][]api.Partition, 0, batchCount)
+	for i := 0; i < len(partitions); i += partitionsPerMsg {
+		end := i + partitionsPerMsg
+		if end > len(partitions) {
+			end = len(partitions)
+		}
+		batches = append(batches, partitions[i:end])
+	}
+	return batches, nil
+}
+
+func (s *WindowPoStScheduler) sectorsForProof(ctx context.Context, goodSectors, allSectors bitfield.BitField, ts *types.TipSet) ([]proof.SectorInfo, error) {
+	sset, err := s.api.StateMinerSectors(ctx, s.actor, &goodSectors, ts.Key())
+	if err != nil {
+		return nil, err
+	}
+
+	if len(sset) == 0 {
+		return nil, nil
+	}
+
+	substitute := proof.SectorInfo{
+		SectorNumber: sset[0].SectorNumber,
+		SealedCID:    sset[0].SealedCID,
+		SealProof:    sset[0].SealProof,
+	}
+
+	sectorByID := make(map[uint64]proof.SectorInfo, len(sset))
+	for _, sector := range sset {
+		sectorByID[uint64(sector.SectorNumber)] = proof.SectorInfo{
+			SectorNumber: sector.SectorNumber,
+			SealedCID:    sector.SealedCID,
+			SealProof:    sector.SealProof,
+		}
+	}
+
+	proofSectors := make([]proof.SectorInfo, 0, len(sset))
+	if err := allSectors.ForEach(func(sectorNo uint64) error {
+		if info, found := sectorByID[sectorNo]; found {
+			proofSectors = append(proofSectors, info)
+		} else {
+			proofSectors = append(proofSectors, substitute)
+		}
+		return nil
+	}); err != nil {
+		return nil, xerrors.Errorf("iterating partition sector bitmap: %w", err)
+	}
+
+	return proofSectors, nil
+}
+
+func (s *WindowPoStScheduler) submitPost(ctx context.Context, proof *miner.SubmitWindowedPoStParams) (*types.SignedMessage, error) {
+	ctx, span := trace.StartSpan(ctx, "storage.commitPost")
+	defer span.End()
+
+	var sm *types.SignedMessage
+
+	enc, aerr := actors.SerializeParams(proof)
+	if aerr != nil {
+		return nil, xerrors.Errorf("could not serialize submit window post parameters: %w", aerr)
+	}
+
+	msg := &types.Message{
+		To:     s.actor,
+		From:   s.worker,
+		Method: builtin0.MethodsMiner.SubmitWindowedPoSt,
+		Params: enc,
+		Value:  types.NewInt(0),
+	}
+	spec := &api.MessageSendSpec{MaxFee: abi.TokenAmount(s.feeCfg.MaxWindowPoStGasFee)}
+	s.setSender(ctx, msg, spec)
+
+	// TODO: consider maybe caring about the output
+	sm, err := s.api.MpoolPushMessage(ctx, msg, spec)
+
+	if err != nil {
+		return nil, xerrors.Errorf("pushing message to mpool: %w", err)
+	}
+
+	log.Infof("Submitted window post: %s", sm.Cid())
+
+	go func() {
+		rec, err := s.api.StateWaitMsg(context.TODO(), sm.Cid(), build.MessageConfidence)
+		if err != nil {
+			log.Error(err)
+			return
+		}
+
+		if rec.Receipt.ExitCode == 0 {
+			return
+		}
+
+		log.Errorf("Submitting window post %s failed: exit %d", sm.Cid(), rec.Receipt.ExitCode)
+	}()
+
+	return sm, nil
+}
+
+func (s *WindowPoStScheduler) setSender(ctx context.Context, msg *types.Message, spec *api.MessageSendSpec) {
+	mi, err := s.api.StateMinerInfo(ctx, s.actor, types.EmptyTSK)
+	if err != nil {
+		log.Errorw("error getting miner info", "error", err)
+
+		// better than just failing
+		msg.From = s.worker
+		return
+	}
+
+	gm, err := s.api.GasEstimateMessageGas(ctx, msg, spec, types.EmptyTSK)
+	if err != nil {
+		log.Errorw("estimating gas", "error", err)
+		msg.From = s.worker
+		return
+	}
+	*msg = *gm
+
+	minFunds := big.Add(msg.RequiredFunds(), msg.Value)
+
+	pa, err := AddressFor(ctx, s.api, mi, PoStAddr, minFunds)
+	if err != nil {
+		log.Errorw("error selecting address for window post", "error", err)
+		msg.From = s.worker
+		return
+	}
+
+	msg.From = pa
+}
diff --git a/storage/wdpost_run_test.go b/storage/wdpost_run_test.go
new file mode 100644
index 000000000..10be2fbcd
--- /dev/null
+++ b/storage/wdpost_run_test.go
@@ -0,0 +1,345 @@
+package storage
+
+import (
+	"bytes"
+	"context"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/ipfs/go-cid"
+
+	"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/big"
+	"github.com/filecoin-project/go-state-types/crypto"
+	"github.com/filecoin-project/go-state-types/dline"
+	"github.com/filecoin-project/go-state-types/network"
+	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
+	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
+	proof0 "github.com/filecoin-project/specs-actors/actors/runtime/proof"
+	tutils "github.com/filecoin-project/specs-actors/support/testing"
+
+	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
+	"github.com/filecoin-project/lotus/chain/types"
+)
+
+type mockStorageMinerAPI struct {
+	partitions     []api.Partition
+	pushedMessages chan *types.Message
+}
+
+func newMockStorageMinerAPI() *mockStorageMinerAPI {
+	return &mockStorageMinerAPI{
+		pushedMessages: make(chan *types.Message),
+	}
+}
+
+func (m *mockStorageMinerAPI) StateMinerInfo(ctx context.Context, a address.Address, key types.TipSetKey) (miner.MinerInfo, error) {
+	return miner.MinerInfo{
+		Worker: tutils.NewIDAddr(nil, 101),
+		Owner:  tutils.NewIDAddr(nil, 101),
+	}, nil
+}
+
+func (m *mockStorageMinerAPI) StateNetworkVersion(ctx context.Context, key types.TipSetKey) (network.Version, error) {
+	panic("implement me")
+}
+
+func (m *mockStorageMinerAPI) ChainGetRandomnessFromTickets(ctx context.Context, tsk types.TipSetKey, personalization crypto.DomainSeparationTag, randEpoch abi.ChainEpoch, entropy []byte) (abi.Randomness, error) {
+	return abi.Randomness("ticket rand"), nil
+}
+
+func (m *mockStorageMinerAPI) ChainGetRandomnessFromBeacon(ctx context.Context, tsk types.TipSetKey, personalization crypto.DomainSeparationTag, randEpoch abi.ChainEpoch, entropy []byte) (abi.Randomness, error) {
+	return abi.Randomness("beacon rand"), nil
+}
+
+func (m *mockStorageMinerAPI) setPartitions(ps []api.Partition) {
+	m.partitions = append(m.partitions, ps...)
+}
+
+func (m *mockStorageMinerAPI) StateMinerPartitions(ctx context.Context, a address.Address, dlIdx uint64, tsk types.TipSetKey) ([]api.Partition, error) {
+	return m.partitions, nil
+}
+
+func (m *mockStorageMinerAPI) StateMinerSectors(ctx context.Context, address address.Address, snos *bitfield.BitField, key types.TipSetKey) ([]*miner.SectorOnChainInfo, error) {
+	var sis []*miner.SectorOnChainInfo
+	if snos == nil {
+		panic("unsupported")
+	}
+	_ = snos.ForEach(func(i uint64) error {
+		sis = append(sis, &miner.SectorOnChainInfo{
+			SectorNumber: abi.SectorNumber(i),
+		})
+		return nil
+	})
+	return sis, nil
+}
+
+func (m *mockStorageMinerAPI) MpoolPushMessage(ctx context.Context, message *types.Message, spec *api.MessageSendSpec) (*types.SignedMessage, error) {
+	m.pushedMessages <- message
+	return &types.SignedMessage{
+		Message: *message,
+	}, nil
+}
+
+func (m *mockStorageMinerAPI) StateWaitMsg(ctx context.Context, cid cid.Cid, confidence uint64) (*api.MsgLookup, error) {
+	return &api.MsgLookup{
+		Receipt: types.MessageReceipt{
+			ExitCode: 0,
+		},
+	}, nil
+}
+
+type mockProver struct {
+}
+
+func (m *mockProver) GenerateWinningPoSt(context.Context, abi.ActorID, []proof0.SectorInfo, abi.PoStRandomness) ([]proof0.PoStProof, error) {
+	panic("implement me")
+}
+
+func (m *mockProver) GenerateWindowPoSt(ctx context.Context, aid abi.ActorID, sis []proof0.SectorInfo, pr abi.PoStRandomness) ([]proof0.PoStProof, []abi.SectorID, error) {
+	return []proof0.PoStProof{
+		{
+			PoStProof:  abi.RegisteredPoStProof_StackedDrgWindow2KiBV1,
+			ProofBytes: []byte("post-proof"),
+		},
+	}, nil, nil
+}
+
+type mockFaultTracker struct {
+}
+
+func (m mockFaultTracker) CheckProvable(ctx context.Context, spt abi.RegisteredSealProof, sectors []abi.SectorID) ([]abi.SectorID, error) {
+	// Returns "bad" sectors so just return nil meaning all sectors are good
+	return nil, nil
+}
+
+// TestWDPostDoPost verifies that doPost will send the correct number of window
+// PoST messages for a given number of partitions
+func TestWDPostDoPost(t *testing.T) {
+	ctx := context.Background()
+	expectedMsgCount := 5
+
+	proofType := abi.RegisteredPoStProof_StackedDrgWindow2KiBV1
+	postAct := tutils.NewIDAddr(t, 100)
+	workerAct := tutils.NewIDAddr(t, 101)
+
+	mockStgMinerAPI := newMockStorageMinerAPI()
+
+	// Get the number of sectors allowed in a partition for this proof type
+	sectorsPerPartition, err := builtin0.PoStProofWindowPoStPartitionSectors(proofType)
+	require.NoError(t, err)
+	// Work out the number of partitions that can be included in a message
+	// without exceeding the message sector limit
+
+	require.NoError(t, err)
+	partitionsPerMsg := int(miner0.AddressedSectorsMax / sectorsPerPartition)
+
+	// Enough partitions to fill expectedMsgCount-1 messages
+	partitionCount := (expectedMsgCount - 1) * partitionsPerMsg
+	// Add an extra partition that should be included in the last message
+	partitionCount++
+
+	var partitions []api.Partition
+	for p := 0; p < partitionCount; p++ {
+		sectors := bitfield.New()
+		for s := uint64(0); s < sectorsPerPartition; s++ {
+			sectors.Set(s)
+		}
+		partitions = append(partitions, api.Partition{
+			AllSectors:        sectors,
+			FaultySectors:     bitfield.New(),
+			RecoveringSectors: bitfield.New(),
+			LiveSectors:       sectors,
+			ActiveSectors:     sectors,
+		})
+	}
+	mockStgMinerAPI.setPartitions(partitions)
+
+	// Run window PoST
+	scheduler := &WindowPoStScheduler{
+		api:          mockStgMinerAPI,
+		prover:       &mockProver{},
+		faultTracker: &mockFaultTracker{},
+		proofType:    proofType,
+		actor:        postAct,
+		worker:       workerAct,
+	}
+
+	di := &dline.Info{
+		WPoStPeriodDeadlines:   miner0.WPoStPeriodDeadlines,
+		WPoStProvingPeriod:     miner0.WPoStProvingPeriod,
+		WPoStChallengeWindow:   miner0.WPoStChallengeWindow,
+		WPoStChallengeLookback: miner0.WPoStChallengeLookback,
+		FaultDeclarationCutoff: miner0.FaultDeclarationCutoff,
+	}
+	ts := mockTipSet(t)
+	scheduler.doPost(ctx, di, ts)
+
+	// Read the window PoST messages
+	for i := 0; i < expectedMsgCount; i++ {
+		msg := <-mockStgMinerAPI.pushedMessages
+		require.Equal(t, builtin0.MethodsMiner.SubmitWindowedPoSt, msg.Method)
+		var params miner.SubmitWindowedPoStParams
+		err := params.UnmarshalCBOR(bytes.NewReader(msg.Params))
+		require.NoError(t, err)
+
+		if i == expectedMsgCount-1 {
+			// In the last message we only included a single partition (see above)
+			require.Len(t, params.Partitions, 1)
+		} else {
+			// All previous messages should include the full number of partitions
+			require.Len(t, params.Partitions, partitionsPerMsg)
+		}
+	}
+}
+
+func mockTipSet(t *testing.T) *types.TipSet {
+	minerAct := tutils.NewActorAddr(t, "miner")
+	c, err := cid.Decode("QmbFMke1KXqnYyBBWxB74N4c5SBnJMVAiMNRcGu6x1AwQH")
+	require.NoError(t, err)
+	blks := []*types.BlockHeader{
+		{
+			Miner:                 minerAct,
+			Height:                abi.ChainEpoch(1),
+			ParentStateRoot:       c,
+			ParentMessageReceipts: c,
+			Messages:              c,
+		},
+	}
+	ts, err := types.NewTipSet(blks)
+	require.NoError(t, err)
+	return ts
+}
+
+//
+// All the mock methods below here are unused
+//
+
+func (m *mockStorageMinerAPI) StateCall(ctx context.Context, message *types.Message, key types.TipSetKey) (*api.InvocResult, error) {
+	panic("implement me")
+}
+
+func (m *mockStorageMinerAPI) StateMinerDeadlines(ctx context.Context, maddr address.Address, tok types.TipSetKey) ([]api.Deadline, error) {
+	panic("implement me")
+}
+
+func (m *mockStorageMinerAPI) StateSectorPreCommitInfo(ctx context.Context, address address.Address, number abi.SectorNumber, key types.TipSetKey) (miner.SectorPreCommitOnChainInfo, error) {
+	panic("implement me")
+}
+
+func (m *mockStorageMinerAPI) StateSectorGetInfo(ctx context.Context, address address.Address, number abi.SectorNumber, key types.TipSetKey) (*miner.SectorOnChainInfo, error) {
+	panic("implement me")
+}
+
+func (m *mockStorageMinerAPI) StateSectorPartition(ctx context.Context, maddr address.Address, sectorNumber abi.SectorNumber, tok types.TipSetKey) (*miner.SectorLocation, error) {
+	panic("implement me")
+}
+
+func (m *mockStorageMinerAPI) StateMinerProvingDeadline(ctx context.Context, address address.Address, key types.TipSetKey) (*dline.Info, error) {
+	return &dline.Info{
+		CurrentEpoch:           0,
+		PeriodStart:            0,
+		Index:                  0,
+		Open:                   0,
+		Close:                  0,
+		Challenge:              0,
+		FaultCutoff:            0,
+		WPoStPeriodDeadlines:   miner0.WPoStPeriodDeadlines,
+		WPoStProvingPeriod:     miner0.WPoStProvingPeriod,
+		WPoStChallengeWindow:   miner0.WPoStChallengeWindow,
+		WPoStChallengeLookback: miner0.WPoStChallengeLookback,
+		FaultDeclarationCutoff: miner0.FaultDeclarationCutoff,
+	}, nil
+}
+
+func (m *mockStorageMinerAPI) StateMinerPreCommitDepositForPower(ctx context.Context, address address.Address, info miner.SectorPreCommitInfo, key types.TipSetKey) (types.BigInt, error) {
+	panic("implement me")
+}
+
+func (m *mockStorageMinerAPI) StateMinerInitialPledgeCollateral(ctx context.Context, address address.Address, info miner.SectorPreCommitInfo, key types.TipSetKey) (types.BigInt, error) {
+	panic("implement me")
+}
+
+func (m *mockStorageMinerAPI) StateSearchMsg(ctx context.Context, cid cid.Cid) (*api.MsgLookup, error) {
+	panic("implement me")
+}
+
+func (m *mockStorageMinerAPI) StateGetActor(ctx context.Context, actor address.Address, ts types.TipSetKey) (*types.Actor, error) {
+	return &types.Actor{
+		Code: builtin0.StorageMinerActorCodeID,
+	}, nil
+}
+
+func (m *mockStorageMinerAPI) StateGetReceipt(ctx context.Context, cid cid.Cid, key types.TipSetKey) (*types.MessageReceipt, error) {
+	panic("implement me")
+}
+
+func (m *mockStorageMinerAPI) StateMarketStorageDeal(ctx context.Context, id abi.DealID, key types.TipSetKey) (*api.MarketDeal, error) {
+	panic("implement me")
+}
+
+func (m *mockStorageMinerAPI) StateMinerFaults(ctx context.Context, address address.Address, key types.TipSetKey) (bitfield.BitField, error) {
+	panic("implement me")
+}
+
+func (m *mockStorageMinerAPI) StateMinerRecoveries(ctx context.Context, address address.Address, key types.TipSetKey) (bitfield.BitField, error) {
+	panic("implement me")
+}
+
+func (m *mockStorageMinerAPI) StateAccountKey(ctx context.Context, address address.Address, key types.TipSetKey) (address.Address, error) {
+	return address, nil
+}
+
+func (m *mockStorageMinerAPI) GasEstimateMessageGas(ctx context.Context, message *types.Message, spec *api.MessageSendSpec, key types.TipSetKey) (*types.Message, error) {
+	msg := *message
+	msg.GasFeeCap = big.NewInt(1)
+	msg.GasPremium = big.NewInt(1)
+	msg.GasLimit = 2
+	return &msg, nil
+}
+
+func (m *mockStorageMinerAPI) ChainHead(ctx context.Context) (*types.TipSet, error) {
+	panic("implement me")
+}
+
+func (m *mockStorageMinerAPI) ChainNotify(ctx context.Context) (<-chan []*api.HeadChange, error) {
+	panic("implement me")
+}
+
+func (m *mockStorageMinerAPI) ChainGetTipSetByHeight(ctx context.Context, epoch abi.ChainEpoch, key types.TipSetKey) (*types.TipSet, error) {
+	panic("implement me")
+}
+
+func (m *mockStorageMinerAPI) ChainGetBlockMessages(ctx context.Context, cid cid.Cid) (*api.BlockMessages, error) {
+	panic("implement me")
+}
+
+func (m *mockStorageMinerAPI) ChainReadObj(ctx context.Context, cid cid.Cid) ([]byte, error) {
+	panic("implement me")
+}
+
+func (m *mockStorageMinerAPI) ChainHasObj(ctx context.Context, cid cid.Cid) (bool, error) {
+	panic("implement me")
+}
+
+func (m *mockStorageMinerAPI) ChainGetTipSet(ctx context.Context, key types.TipSetKey) (*types.TipSet, error) {
+	panic("implement me")
+}
+
+func (m *mockStorageMinerAPI) WalletSign(ctx context.Context, address address.Address, bytes []byte) (*crypto.Signature, error) {
+	return nil, nil
+}
+
+func (m *mockStorageMinerAPI) WalletBalance(ctx context.Context, address address.Address) (types.BigInt, error) {
+	return big.NewInt(333), nil
+}
+
+func (m *mockStorageMinerAPI) WalletHas(ctx context.Context, address address.Address) (bool, error) {
+	return true, nil
+}
+
+var _ storageMinerApi = &mockStorageMinerAPI{}
diff --git a/storage/wdpost_sched.go b/storage/wdpost_sched.go
new file mode 100644
index 000000000..7e60fd9ee
--- /dev/null
+++ b/storage/wdpost_sched.go
@@ -0,0 +1,257 @@
+package storage
+
+import (
+	"context"
+	"time"
+
+	"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/dline"
+	"github.com/filecoin-project/specs-storage/storage"
+
+	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/store"
+	"github.com/filecoin-project/lotus/chain/types"
+	sectorstorage "github.com/filecoin-project/lotus/extern/sector-storage"
+	"github.com/filecoin-project/lotus/journal"
+	"github.com/filecoin-project/lotus/node/config"
+
+	"go.opencensus.io/trace"
+)
+
+const StartConfidence = 4 // TODO: config
+
+type WindowPoStScheduler struct {
+	api              storageMinerApi
+	feeCfg           config.MinerFeeConfig
+	prover           storage.Prover
+	faultTracker     sectorstorage.FaultTracker
+	proofType        abi.RegisteredPoStProof
+	partitionSectors uint64
+
+	actor  address.Address
+	worker address.Address
+
+	cur *types.TipSet
+
+	// if a post is in progress, this indicates for which ElectionPeriodStart
+	activeDeadline *dline.Info
+	abort          context.CancelFunc
+
+	evtTypes [4]journal.EventType
+
+	// failed abi.ChainEpoch // eps
+	// failLk sync.Mutex
+}
+
+func NewWindowedPoStScheduler(api storageMinerApi, fc config.MinerFeeConfig, sb storage.Prover, ft sectorstorage.FaultTracker, actor address.Address, worker address.Address) (*WindowPoStScheduler, error) {
+	mi, err := api.StateMinerInfo(context.TODO(), actor, types.EmptyTSK)
+	if err != nil {
+		return nil, xerrors.Errorf("getting sector size: %w", err)
+	}
+
+	rt, err := mi.SealProofType.RegisteredWindowPoStProof()
+	if err != nil {
+		return nil, err
+	}
+
+	return &WindowPoStScheduler{
+		api:              api,
+		feeCfg:           fc,
+		prover:           sb,
+		faultTracker:     ft,
+		proofType:        rt,
+		partitionSectors: mi.WindowPoStPartitionSectors,
+
+		actor:  actor,
+		worker: worker,
+		evtTypes: [...]journal.EventType{
+			evtTypeWdPoStScheduler:  journal.J.RegisterEventType("wdpost", "scheduler"),
+			evtTypeWdPoStProofs:     journal.J.RegisterEventType("wdpost", "proofs_processed"),
+			evtTypeWdPoStRecoveries: journal.J.RegisterEventType("wdpost", "recoveries_processed"),
+			evtTypeWdPoStFaults:     journal.J.RegisterEventType("wdpost", "faults_processed"),
+		},
+	}, nil
+}
+
+func deadlineEquals(a, b *dline.Info) bool {
+	if a == nil || b == nil {
+		return b == a
+	}
+
+	return a.PeriodStart == b.PeriodStart && a.Index == b.Index && a.Challenge == b.Challenge
+}
+
+func (s *WindowPoStScheduler) Run(ctx context.Context) {
+	defer s.abortActivePoSt()
+
+	var notifs <-chan []*api.HeadChange
+	var err error
+	var gotCur bool
+
+	// not fine to panic after this point
+	for {
+		if notifs == nil {
+			notifs, err = s.api.ChainNotify(ctx)
+			if err != nil {
+				log.Errorf("ChainNotify error: %+v", err)
+
+				build.Clock.Sleep(10 * time.Second)
+				continue
+			}
+
+			gotCur = false
+		}
+
+		select {
+		case changes, ok := <-notifs:
+			if !ok {
+				log.Warn("window post scheduler notifs channel closed")
+				notifs = nil
+				continue
+			}
+
+			if !gotCur {
+				if len(changes) != 1 {
+					log.Errorf("expected first notif to have len = 1")
+					continue
+				}
+				chg := changes[0]
+				if chg.Type != store.HCCurrent {
+					log.Errorf("expected first notif to tell current ts")
+					continue
+				}
+
+				if err := s.update(ctx, chg.Val); err != nil {
+					log.Errorf("%+v", err)
+				}
+
+				gotCur = true
+				continue
+			}
+
+			ctx, span := trace.StartSpan(ctx, "WindowPoStScheduler.headChange")
+
+			var lowest, highest *types.TipSet = s.cur, nil
+
+			for _, change := range changes {
+				if change.Val == nil {
+					log.Errorf("change.Val was nil")
+				}
+				switch change.Type {
+				case store.HCRevert:
+					lowest = change.Val
+				case store.HCApply:
+					highest = change.Val
+				}
+			}
+
+			if err := s.revert(ctx, lowest); err != nil {
+				log.Error("handling head reverts in window post sched: %+v", err)
+			}
+			if err := s.update(ctx, highest); err != nil {
+				log.Error("handling head updates in window post sched: %+v", err)
+			}
+
+			span.End()
+		case <-ctx.Done():
+			return
+		}
+	}
+}
+
+func (s *WindowPoStScheduler) revert(ctx context.Context, newLowest *types.TipSet) error {
+	if s.cur == newLowest {
+		return nil
+	}
+	s.cur = newLowest
+
+	newDeadline, err := s.api.StateMinerProvingDeadline(ctx, s.actor, newLowest.Key())
+	if err != nil {
+		return err
+	}
+
+	if !deadlineEquals(s.activeDeadline, newDeadline) {
+		s.abortActivePoSt()
+	}
+
+	return nil
+}
+
+func (s *WindowPoStScheduler) update(ctx context.Context, new *types.TipSet) error {
+	if new == nil {
+		return xerrors.Errorf("no new tipset in window post sched update")
+	}
+
+	di, err := s.api.StateMinerProvingDeadline(ctx, s.actor, new.Key())
+	if err != nil {
+		return err
+	}
+
+	if deadlineEquals(s.activeDeadline, di) {
+		return nil // already working on this deadline
+	}
+
+	if !di.PeriodStarted() {
+		return nil // not proving anything yet
+	}
+
+	s.abortActivePoSt()
+
+	// TODO: wait for di.Challenge here, will give us ~10min more to compute windowpost
+	//  (Need to get correct deadline above, which is tricky)
+
+	if di.Open+StartConfidence >= new.Height() {
+		log.Info("not starting window post yet, waiting for startconfidence", di.Open, di.Open+StartConfidence, new.Height())
+		return nil
+	}
+
+	/*s.failLk.Lock()
+	if s.failed > 0 {
+		s.failed = 0
+		s.activeEPS = 0
+	}
+	s.failLk.Unlock()*/
+	log.Infof("at %d, do window post for P %d, dd %d", new.Height(), di.PeriodStart, di.Index)
+
+	s.doPost(ctx, di, new)
+
+	return nil
+}
+
+func (s *WindowPoStScheduler) abortActivePoSt() {
+	if s.activeDeadline == nil {
+		return // noop
+	}
+
+	if s.abort != nil {
+		s.abort()
+
+		journal.J.RecordEvent(s.evtTypes[evtTypeWdPoStScheduler], func() interface{} {
+			return WdPoStSchedulerEvt{
+				evtCommon: s.getEvtCommon(nil),
+				State:     SchedulerStateAborted,
+			}
+		})
+
+		log.Warnf("Aborting window post (Deadline: %+v)", s.activeDeadline)
+	}
+
+	s.activeDeadline = nil
+	s.abort = nil
+}
+
+// getEvtCommon populates and returns common attributes from state, for a
+// WdPoSt journal event.
+func (s *WindowPoStScheduler) getEvtCommon(err error) evtCommon {
+	c := evtCommon{Error: err}
+	if s.cur != nil {
+		c.Deadline = s.activeDeadline
+		c.Height = s.cur.Height()
+		c.TipSet = s.cur.Cids()
+	}
+	return c
+}
diff --git a/tools/dockers/README.md b/tools/dockers/README.md
new file mode 100644
index 000000000..66bfdc2e3
--- /dev/null
+++ b/tools/dockers/README.md
@@ -0,0 +1,3 @@
+## About 
+
+In [docker-examples/](docker-examples/) are community-contributed Docker and Docker Compose examples.
diff --git a/tools/dockers/docker-examples/README.md b/tools/dockers/docker-examples/README.md
new file mode 100644
index 000000000..28553653c
--- /dev/null
+++ b/tools/dockers/docker-examples/README.md
@@ -0,0 +1,34 @@
+## About 
+
+In this `docker-examples/` directory are community-contributed Docker and Docker Compose examples.
+
+#### Example Use Cases
+
+- **For a miner**
+   - basic miner (`miner-basic-`)
+   - distributed miner
+- **For API endpoints for building apps**
+   - local node for a developer (`api-local-`)
+   - hosted endpoint for apps / multiple developers (`api-hosted-`)
+- **For a local devnet or shared devnet**
+   - basic local devnet (also see [lotus docs on setting up a local devnet](https://lotu.sh/en+setup-local-dev-net))
+   - shared devnet
+  
+
+## Contributions
+
+- `miner-basic-busybox` - from @ldoublewood ([lotus PR 745](https://github.com/filecoin-project/lotus/pull/745))
+- `api-local-arch` - from @mateodelnorte
+- `api-hosted-debian-nginx` - from @RTradeLtd
+
+#### More examples:
+- [Issue 1143](https://github.com/filecoin-project/lotus/issues/1143)
+- [PR 1047](https://github.com/filecoin-project/lotus/pull/1047/files)
+
+## Contributing
+
+:whale: Have a new type of Docker to share?
+
+Make a PR with a new folder for it, describe its purpose and link to the repo or provide the Docker files. Add it to *Contributions* above.
+
+:beetle: See a bug? File an Issue so we can keep these up-to-date.
diff --git a/tools/dockers/docker-examples/api-hosted-debian-nginx/README.md b/tools/dockers/docker-examples/api-hosted-debian-nginx/README.md
new file mode 100644
index 000000000..b41e399d4
--- /dev/null
+++ b/tools/dockers/docker-examples/api-hosted-debian-nginx/README.md
@@ -0,0 +1,10 @@
+## Description
+
+- **For API endpoints for building apps**
+  - hosted endpoint for multiple developers
+
+Another container spins up a simple block explorer.
+
+## Repo
+
+https://github.com/RTradeLtd/lotus-infra
\ No newline at end of file
diff --git a/tools/dockers/docker-examples/api-local-arch/README.md b/tools/dockers/docker-examples/api-local-arch/README.md
new file mode 100644
index 000000000..a31403f68
--- /dev/null
+++ b/tools/dockers/docker-examples/api-local-arch/README.md
@@ -0,0 +1,8 @@
+## Description
+
+- **For API endpoints for building apps**
+  - local node for a developer
+
+## Repo
+
+https://github.com/mateodelnorte/filecoin-lotus-docker
\ No newline at end of file
diff --git a/tools/dockers/docker-examples/basic-miner-busybox/Dockerfile b/tools/dockers/docker-examples/basic-miner-busybox/Dockerfile
new file mode 100644
index 000000000..5464a81bf
--- /dev/null
+++ b/tools/dockers/docker-examples/basic-miner-busybox/Dockerfile
@@ -0,0 +1,95 @@
+FROM golang:1.14.1-buster
+MAINTAINER ldoublewood <ldoublewood@gmail.com>
+
+ENV SRC_DIR /lotus
+
+RUN apt-get update && apt-get install -y ca-certificates llvm clang mesa-opencl-icd ocl-icd-opencl-dev jq
+
+RUN curl -sSf https://sh.rustup.rs | sh -s -- -y
+
+
+# Get su-exec, a very minimal tool for dropping privileges,
+# and tini, a very minimal init daemon for containers
+ENV SUEXEC_VERSION v0.2
+ENV TINI_VERSION v0.18.0
+RUN set -x \
+  && cd /tmp \
+  && git clone https://github.com/ncopa/su-exec.git \
+  && cd su-exec \
+  && git checkout -q $SUEXEC_VERSION \
+  && make \
+  && cd /tmp \
+  && wget -q -O tini https://github.com/krallin/tini/releases/download/$TINI_VERSION/tini \
+  && chmod +x tini
+
+# Download packages first so they can be cached.
+COPY go.mod go.sum $SRC_DIR/
+COPY extern/ $SRC_DIR/extern/
+RUN cd $SRC_DIR \
+  && go mod download
+
+COPY Makefile $SRC_DIR
+
+# Because extern/filecoin-ffi building script need to get version number from git
+COPY .git/ $SRC_DIR/.git/
+COPY .gitmodules $SRC_DIR/
+
+# Download dependence first
+RUN cd $SRC_DIR \
+  && mkdir $SRC_DIR/build \
+  && . $HOME/.cargo/env \
+  && make clean \
+  && make deps
+
+
+COPY . $SRC_DIR
+
+ARG MAKE_TARGET=all
+
+# Build the thing.
+RUN cd $SRC_DIR \
+  && . $HOME/.cargo/env \
+  && make $MAKE_TARGET
+
+# Now comes the actual target image, which aims to be as small as possible.
+FROM busybox:1-glibc
+MAINTAINER ldoublewood <ldoublewood@gmail.com>
+
+# Get the executable binary and TLS CAs from the build container.
+ENV SRC_DIR /lotus
+COPY --from=0 $SRC_DIR/lotus /usr/local/bin/lotus
+COPY --from=0 $SRC_DIR/lotus-* /usr/local/bin/
+COPY --from=0 /tmp/su-exec/su-exec /sbin/su-exec
+COPY --from=0 /tmp/tini /sbin/tini
+COPY --from=0 /etc/ssl/certs /etc/ssl/certs
+
+
+# This shared lib (part of glibc) doesn't seem to be included with busybox.
+COPY --from=0 /lib/x86_64-linux-gnu/libdl-2.28.so /lib/libdl.so.2
+COPY --from=0 /lib/x86_64-linux-gnu/libutil-2.28.so /lib/libutil.so.1 
+COPY --from=0 /usr/lib/x86_64-linux-gnu/libOpenCL.so.1.0.0 /lib/libOpenCL.so.1
+COPY --from=0 /lib/x86_64-linux-gnu/librt-2.28.so /lib/librt.so.1
+COPY --from=0 /lib/x86_64-linux-gnu/libgcc_s.so.1 /lib/libgcc_s.so.1
+
+# WS port
+EXPOSE 1234
+# P2P port
+EXPOSE 5678
+
+
+# Create the home directory and switch to a non-privileged user.
+ENV HOME_PATH /data
+ENV PARAMCACHE_PATH /var/tmp/filecoin-proof-parameters
+
+RUN mkdir -p $HOME_PATH $PARAMCACHE_PATH \
+  && adduser -D -h $HOME_PATH -u 1000 -G users lotus \
+  && chown lotus:users $HOME_PATH $PARAMCACHE_PATH
+
+
+VOLUME $HOME_PATH
+VOLUME $PARAMCACHE_PATH
+
+USER lotus
+
+# Execute the daemon subcommand by default
+CMD ["/sbin/tini", "--", "lotus", "daemon"]
diff --git a/tools/dockers/docker-examples/basic-miner-busybox/README.md b/tools/dockers/docker-examples/basic-miner-busybox/README.md
new file mode 100644
index 000000000..e5a66b306
--- /dev/null
+++ b/tools/dockers/docker-examples/basic-miner-busybox/README.md
@@ -0,0 +1,4 @@
+## Description
+
+- **For a miner**
+  - basic miner
diff --git a/tools/stats/collect.go b/tools/stats/collect.go
new file mode 100644
index 000000000..221dc37e2
--- /dev/null
+++ b/tools/stats/collect.go
@@ -0,0 +1,63 @@
+package stats
+
+import (
+	"context"
+	"time"
+
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/lotus/api"
+	client "github.com/influxdata/influxdb1-client/v2"
+)
+
+func Collect(ctx context.Context, api api.FullNode, influx client.Client, database string, height int64, headlag int) {
+	tipsetsCh, err := GetTips(ctx, api, abi.ChainEpoch(height), headlag)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	wq := NewInfluxWriteQueue(ctx, influx)
+	defer wq.Close()
+
+	for tipset := range tipsetsCh {
+		log.Infow("Collect stats", "height", tipset.Height())
+		pl := NewPointList()
+		height := tipset.Height()
+
+		if err := RecordTipsetPoints(ctx, api, pl, tipset); err != nil {
+			log.Warnw("Failed to record tipset", "height", height, "error", err)
+			continue
+		}
+
+		if err := RecordTipsetMessagesPoints(ctx, api, pl, tipset); err != nil {
+			log.Warnw("Failed to record messages", "height", height, "error", err)
+			continue
+		}
+
+		if err := RecordTipsetStatePoints(ctx, api, pl, tipset); err != nil {
+			log.Warnw("Failed to record state", "height", height, "error", err)
+			continue
+		}
+
+		// Instead of having to pass around a bunch of generic stuff we want for each point
+		// we will just add them at the end.
+
+		tsTimestamp := time.Unix(int64(tipset.MinTimestamp()), int64(0))
+
+		nb, err := InfluxNewBatch()
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		for _, pt := range pl.Points() {
+			pt.SetTime(tsTimestamp)
+
+			nb.AddPoint(NewPointFrom(pt))
+		}
+
+		nb.SetDatabase(database)
+
+		log.Infow("Adding points", "count", len(nb.Points()), "height", tipset.Height())
+
+		wq.AddBatch(nb)
+	}
+}
diff --git a/tools/stats/head_buffer.go b/tools/stats/head_buffer.go
new file mode 100644
index 000000000..0a7c63e6e
--- /dev/null
+++ b/tools/stats/head_buffer.go
@@ -0,0 +1,47 @@
+package stats
+
+import (
+	"container/list"
+
+	"github.com/filecoin-project/lotus/api"
+)
+
+type headBuffer struct {
+	buffer *list.List
+	size   int
+}
+
+func newHeadBuffer(size int) *headBuffer {
+	buffer := list.New()
+	buffer.Init()
+
+	return &headBuffer{
+		buffer: buffer,
+		size:   size,
+	}
+}
+
+func (h *headBuffer) push(hc *api.HeadChange) (rethc *api.HeadChange) {
+	if h.buffer.Len() == h.size {
+		var ok bool
+
+		el := h.buffer.Front()
+		rethc, ok = el.Value.(*api.HeadChange)
+		if !ok {
+			panic("Value from list is not the correct type")
+		}
+
+		h.buffer.Remove(el)
+	}
+
+	h.buffer.PushBack(hc)
+
+	return
+}
+
+func (h *headBuffer) pop() {
+	el := h.buffer.Back()
+	if el != nil {
+		h.buffer.Remove(el)
+	}
+}
diff --git a/tools/stats/head_buffer_test.go b/tools/stats/head_buffer_test.go
new file mode 100644
index 000000000..4059f730e
--- /dev/null
+++ b/tools/stats/head_buffer_test.go
@@ -0,0 +1,43 @@
+package stats
+
+import (
+	"testing"
+
+	"github.com/filecoin-project/lotus/api"
+	"github.com/stretchr/testify/require"
+)
+
+func TestHeadBuffer(t *testing.T) {
+
+	t.Run("Straight push through", func(t *testing.T) {
+		hb := newHeadBuffer(5)
+		require.Nil(t, hb.push(&api.HeadChange{Type: "1"}))
+		require.Nil(t, hb.push(&api.HeadChange{Type: "2"}))
+		require.Nil(t, hb.push(&api.HeadChange{Type: "3"}))
+		require.Nil(t, hb.push(&api.HeadChange{Type: "4"}))
+		require.Nil(t, hb.push(&api.HeadChange{Type: "5"}))
+
+		hc := hb.push(&api.HeadChange{Type: "6"})
+		require.Equal(t, hc.Type, "1")
+	})
+
+	t.Run("Reverts", func(t *testing.T) {
+		hb := newHeadBuffer(5)
+		require.Nil(t, hb.push(&api.HeadChange{Type: "1"}))
+		require.Nil(t, hb.push(&api.HeadChange{Type: "2"}))
+		require.Nil(t, hb.push(&api.HeadChange{Type: "3"}))
+		hb.pop()
+		require.Nil(t, hb.push(&api.HeadChange{Type: "3a"}))
+		hb.pop()
+		require.Nil(t, hb.push(&api.HeadChange{Type: "3b"}))
+		require.Nil(t, hb.push(&api.HeadChange{Type: "4"}))
+		require.Nil(t, hb.push(&api.HeadChange{Type: "5"}))
+
+		hc := hb.push(&api.HeadChange{Type: "6"})
+		require.Equal(t, hc.Type, "1")
+		hc = hb.push(&api.HeadChange{Type: "7"})
+		require.Equal(t, hc.Type, "2")
+		hc = hb.push(&api.HeadChange{Type: "8"})
+		require.Equal(t, hc.Type, "3b")
+	})
+}
diff --git a/tools/stats/main.go b/tools/stats/main.go
deleted file mode 100644
index 7c0f12e97..000000000
--- a/tools/stats/main.go
+++ /dev/null
@@ -1,118 +0,0 @@
-package main
-
-import (
-	"context"
-	"flag"
-	"os"
-	"time"
-
-	logging "github.com/ipfs/go-log"
-)
-
-var log = logging.Logger("stats")
-
-const (
-	INFLUX_ADDR = "INFLUX_ADDR"
-	INFLUX_USER = "INFLUX_USER"
-	INFLUX_PASS = "INFLUX_PASS"
-)
-
-func main() {
-	var repo string = "~/.lotus"
-	var database string = "lotus"
-	var reset bool = false
-	var height int64 = 0
-
-	flag.StringVar(&repo, "repo", repo, "lotus repo path")
-	flag.StringVar(&database, "database", database, "influx database")
-	flag.Int64Var(&height, "height", height, "block height to start syncing from (0 will resume)")
-	flag.BoolVar(&reset, "reset", reset, "truncate database before starting stats gathering")
-
-	flag.Parse()
-
-	influxAddr := os.Getenv(INFLUX_ADDR)
-	influxUser := os.Getenv(INFLUX_USER)
-	influxPass := os.Getenv(INFLUX_PASS)
-
-	ctx := context.Background()
-
-	influx, err := InfluxClient(influxAddr, influxUser, influxPass)
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	if reset {
-		if err := ResetDatabase(influx, database); err != nil {
-			log.Fatal(err)
-		}
-	}
-
-	if !reset && height == 0 {
-		h, err := GetLastRecordedHeight(influx, database)
-		if err != nil {
-			log.Info(err)
-		}
-
-		height = h
-	}
-
-	api, closer, err := GetFullNodeAPI(repo)
-	if err != nil {
-		log.Fatal(err)
-	}
-	defer closer()
-
-	if err := WaitForSyncComplete(ctx, api); err != nil {
-		log.Fatal(err)
-	}
-
-	tipsetsCh, err := GetTips(ctx, api, uint64(height))
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	wq := NewInfluxWriteQueue(ctx, influx)
-	defer wq.Close()
-
-	for tipset := range tipsetsCh {
-		pl := NewPointList()
-		height := tipset.Height()
-
-		if err := RecordTipsetPoints(ctx, api, pl, tipset); err != nil {
-			log.Warnw("Failed to record tipset", "height", height, "error", err)
-			continue
-		}
-
-		if err := RecordTipsetMessagesPoints(ctx, api, pl, tipset); err != nil {
-			log.Warnw("Failed to record messages", "height", height, "error", err)
-			continue
-		}
-
-		if err := RecordTipsetStatePoints(ctx, api, pl, tipset); err != nil {
-			log.Warnw("Failed to record state", "height", height, "error", err)
-			continue
-		}
-
-		// Instead of having to pass around a bunch of generic stuff we want for each point
-		// we will just add them at the end.
-
-		tsTimestamp := time.Unix(int64(tipset.MinTimestamp()), int64(0))
-
-		nb, err := InfluxNewBatch()
-		if err != nil {
-			log.Fatal(err)
-		}
-
-		for _, pt := range pl.Points() {
-			pt.SetTime(tsTimestamp)
-
-			nb.AddPoint(NewPointFrom(pt))
-		}
-
-		nb.SetDatabase(database)
-
-		log.Infow("Adding points", "count", len(nb.Points()), "height", tipset.Height())
-
-		wq.AddBatch(nb)
-	}
-}
diff --git a/tools/stats/metrics.go b/tools/stats/metrics.go
index ebdd5b205..22069c3d0 100644
--- a/tools/stats/metrics.go
+++ b/tools/stats/metrics.go
@@ -1,26 +1,36 @@
-package main
+package stats
 
 import (
+	"bytes"
 	"context"
 	"encoding/json"
 	"fmt"
+	"math"
 	"math/big"
 	"strings"
 	"time"
 
-	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/build"
-	"github.com/filecoin-project/lotus/chain/actors"
+	"github.com/filecoin-project/lotus/chain/actors/builtin/reward"
+	"github.com/filecoin-project/lotus/chain/store"
 	"github.com/filecoin-project/lotus/chain/types"
+
 	"github.com/ipfs/go-cid"
 	"github.com/multiformats/go-multihash"
+	"golang.org/x/xerrors"
+
+	cbg "github.com/whyrusleeping/cbor-gen"
 
 	_ "github.com/influxdata/influxdb1-client"
 	models "github.com/influxdata/influxdb1-client/models"
 	client "github.com/influxdata/influxdb1-client/v2"
+
+	logging "github.com/ipfs/go-log/v2"
 )
 
+var log = logging.Logger("stats")
+
 type PointList struct {
 	points []models.Point
 }
@@ -38,8 +48,7 @@ func (pl *PointList) Points() []models.Point {
 }
 
 type InfluxWriteQueue struct {
-	influx client.Client
-	ch     chan client.BatchPoints
+	ch chan client.BatchPoints
 }
 
 func NewInfluxWriteQueue(ctx context.Context, influx client.Client) *InfluxWriteQueue {
@@ -57,7 +66,7 @@ func NewInfluxWriteQueue(ctx context.Context, influx client.Client) *InfluxWrite
 				for i := 0; i < maxRetries; i++ {
 					if err := influx.Write(batch); err != nil {
 						log.Warnw("Failed to write batch", "error", err)
-						time.Sleep(time.Second * 15)
+						build.Clock.Sleep(15 * time.Second)
 						continue
 					}
 
@@ -95,7 +104,8 @@ func InfluxNewBatch() (client.BatchPoints, error) {
 }
 
 func NewPoint(name string, value interface{}) models.Point {
-	pt, _ := models.NewPoint(name, models.Tags{}, map[string]interface{}{"value": value}, time.Now())
+	pt, _ := models.NewPoint(name, models.Tags{},
+		map[string]interface{}{"value": value}, build.Clock.Now().UTC())
 	return pt
 }
 
@@ -120,63 +130,144 @@ func RecordTipsetPoints(ctx context.Context, api api.FullNode, pl *PointList, ti
 	p = NewPoint("chain.blocktime", tsTime.Unix())
 	pl.AddPoint(p)
 
+	totalGasLimit := int64(0)
+	totalUniqGasLimit := int64(0)
+	seen := make(map[cid.Cid]struct{})
 	for _, blockheader := range tipset.Blocks() {
 		bs, err := blockheader.Serialize()
 		if err != nil {
 			return err
 		}
-		p := NewPoint("chain.election", 1)
+		p := NewPoint("chain.election", blockheader.ElectionProof.WinCount)
 		p.AddTag("miner", blockheader.Miner.String())
 		pl.AddPoint(p)
 
 		p = NewPoint("chain.blockheader_size", len(bs))
 		pl.AddPoint(p)
+
+		msgs, err := api.ChainGetBlockMessages(ctx, blockheader.Cid())
+		if err != nil {
+			return xerrors.Errorf("ChainGetBlockMessages failed: %w", msgs)
+		}
+		for _, m := range msgs.BlsMessages {
+			c := m.Cid()
+			totalGasLimit += m.GasLimit
+			if _, ok := seen[c]; !ok {
+				totalUniqGasLimit += m.GasLimit
+				seen[c] = struct{}{}
+			}
+		}
+		for _, m := range msgs.SecpkMessages {
+			c := m.Cid()
+			totalGasLimit += m.Message.GasLimit
+			if _, ok := seen[c]; !ok {
+				totalUniqGasLimit += m.Message.GasLimit
+				seen[c] = struct{}{}
+			}
+		}
+	}
+	p = NewPoint("chain.gas_limit_total", totalGasLimit)
+	pl.AddPoint(p)
+	p = NewPoint("chain.gas_limit_uniq_total", totalUniqGasLimit)
+	pl.AddPoint(p)
+
+	{
+		baseFeeIn := tipset.Blocks()[0].ParentBaseFee
+		newBaseFee := store.ComputeNextBaseFee(baseFeeIn, totalUniqGasLimit, len(tipset.Blocks()), tipset.Height())
+
+		baseFeeRat := new(big.Rat).SetFrac(newBaseFee.Int, new(big.Int).SetUint64(build.FilecoinPrecision))
+		baseFeeFloat, _ := baseFeeRat.Float64()
+		p = NewPoint("chain.basefee", baseFeeFloat)
+		pl.AddPoint(p)
+
+		baseFeeChange := new(big.Rat).SetFrac(newBaseFee.Int, baseFeeIn.Int)
+		baseFeeChangeF, _ := baseFeeChange.Float64()
+		p = NewPoint("chain.basefee_change_log", math.Log(baseFeeChangeF)/math.Log(1.125))
+		pl.AddPoint(p)
+	}
+	{
+		blks := int64(len(cids))
+		p = NewPoint("chain.gas_fill_ratio", float64(totalGasLimit)/float64(blks*build.BlockGasTarget))
+		pl.AddPoint(p)
+		p = NewPoint("chain.gas_capacity_ratio", float64(totalUniqGasLimit)/float64(blks*build.BlockGasTarget))
+		pl.AddPoint(p)
+		p = NewPoint("chain.gas_waste_ratio", float64(totalGasLimit-totalUniqGasLimit)/float64(blks*build.BlockGasTarget))
+		pl.AddPoint(p)
 	}
 
 	return nil
 }
 
-func RecordTipsetStatePoints(ctx context.Context, api api.FullNode, pl *PointList, tipset *types.TipSet) error {
-	pc, err := api.StatePledgeCollateral(ctx, tipset)
+type apiIpldStore struct {
+	ctx context.Context
+	api api.FullNode
+}
+
+func (ht *apiIpldStore) Context() context.Context {
+	return ht.ctx
+}
+
+func (ht *apiIpldStore) Get(ctx context.Context, c cid.Cid, out interface{}) error {
+	raw, err := ht.api.ChainReadObj(ctx, c)
 	if err != nil {
 		return err
 	}
 
+	cu, ok := out.(cbg.CBORUnmarshaler)
+	if ok {
+		if err := cu.UnmarshalCBOR(bytes.NewReader(raw)); err != nil {
+			return err
+		}
+		return nil
+	}
+
+	return fmt.Errorf("Object does not implement CBORUnmarshaler")
+}
+
+func (ht *apiIpldStore) Put(ctx context.Context, v interface{}) (cid.Cid, error) {
+	return cid.Undef, fmt.Errorf("Put is not implemented on apiIpldStore")
+}
+
+func RecordTipsetStatePoints(ctx context.Context, api api.FullNode, pl *PointList, tipset *types.TipSet) error {
 	attoFil := types.NewInt(build.FilecoinPrecision).Int
 
-	pcFil := new(big.Rat).SetFrac(pc.Int, attoFil)
-	pcFilFloat, _ := pcFil.Float64()
-	p := NewPoint("chain.pledge_collateral", pcFilFloat)
-	pl.AddPoint(p)
+	//TODO: StatePledgeCollateral API is not implemented and is commented out - re-enable this block once the API is implemented again.
+	//pc, err := api.StatePledgeCollateral(ctx, tipset.Key())
+	//if err != nil {
+	//return err
+	//}
 
-	netBal, err := api.WalletBalance(ctx, actors.NetworkAddress)
+	//pcFil := new(big.Rat).SetFrac(pc.Int, attoFil)
+	//pcFilFloat, _ := pcFil.Float64()
+	//p := NewPoint("chain.pledge_collateral", pcFilFloat)
+	//pl.AddPoint(p)
+
+	netBal, err := api.WalletBalance(ctx, reward.Address)
 	if err != nil {
 		return err
 	}
 
 	netBalFil := new(big.Rat).SetFrac(netBal.Int, attoFil)
 	netBalFilFloat, _ := netBalFil.Float64()
-	p = NewPoint("network.balance", netBalFilFloat)
+	p := NewPoint("network.balance", netBalFilFloat)
 	pl.AddPoint(p)
 
-	power, err := api.StateMinerPower(ctx, address.Address{}, tipset)
+	miners, err := api.StateListMiners(ctx, tipset.Key())
 	if err != nil {
 		return err
 	}
 
-	p = NewPoint("chain.power", power.TotalPower.Int64())
-	pl.AddPoint(p)
-
-	miners, err := api.StateListMiners(ctx, tipset)
-	for _, miner := range miners {
-		power, err := api.StateMinerPower(ctx, miner, tipset)
+	for _, addr := range miners {
+		mp, err := api.StateMinerPower(ctx, addr, tipset.Key())
 		if err != nil {
 			return err
 		}
 
-		p = NewPoint("chain.miner_power", power.MinerPower.Int64())
-		p.AddTag("miner", miner.String())
-		pl.AddPoint(p)
+		if !mp.MinerPower.QualityAdjPower.IsZero() {
+			p = NewPoint("chain.miner_power", mp.MinerPower.QualityAdjPower.Int64())
+			p.AddTag("miner", addr.String())
+			pl.AddPoint(p)
+		}
 	}
 
 	return nil
@@ -206,8 +297,19 @@ func RecordTipsetMessagesPoints(ctx context.Context, api api.FullNode, pl *Point
 
 	msgn := make(map[msgTag][]cid.Cid)
 
+	totalGasUsed := int64(0)
+	for _, r := range recp {
+		totalGasUsed += r.GasUsed
+	}
+	p := NewPoint("chain.gas_used_total", totalGasUsed)
+	pl.AddPoint(p)
+
 	for i, msg := range msgs {
-		p := NewPoint("chain.message_gasprice", msg.Message.GasPrice.Int64())
+		// FIXME: use float so this doesn't overflow
+		// FIXME: this doesn't work as time points get overridden
+		p := NewPoint("chain.message_gaspremium", msg.Message.GasPremium.Int64())
+		pl.AddPoint(p)
+		p = NewPoint("chain.message_gasfeecap", msg.Message.GasFeeCap.Int64())
 		pl.AddPoint(p)
 
 		bs, err := msg.Message.Serialize()
@@ -218,7 +320,7 @@ func RecordTipsetMessagesPoints(ctx context.Context, api api.FullNode, pl *Point
 		p = NewPoint("chain.message_size", len(bs))
 		pl.AddPoint(p)
 
-		actor, err := api.StateGetActor(ctx, msg.Message.To, tipset)
+		actor, err := api.StateGetActor(ctx, msg.Message.To, tipset.Key())
 		if err != nil {
 			return err
 		}
@@ -229,8 +331,8 @@ func RecordTipsetMessagesPoints(ctx context.Context, api api.FullNode, pl *Point
 		}
 		tag := msgTag{
 			actor:    string(dm.Digest),
-			method:   msg.Message.Method,
-			exitcode: recp[i].ExitCode,
+			method:   uint64(msg.Message.Method),
+			exitcode: uint8(recp[i].ExitCode),
 		}
 
 		found := false
diff --git a/tools/stats/rpc.go b/tools/stats/rpc.go
index 860ffc95f..b01c07a35 100644
--- a/tools/stats/rpc.go
+++ b/tools/stats/rpc.go
@@ -1,21 +1,21 @@
-package main
+package stats
 
 import (
 	"context"
 	"net/http"
 	"time"
 
-	manet "github.com/multiformats/go-multiaddr-net"
+	"github.com/filecoin-project/go-jsonrpc"
+	"github.com/filecoin-project/go-state-types/abi"
+	manet "github.com/multiformats/go-multiaddr/net"
 
 	"golang.org/x/xerrors"
 
 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/api/client"
 	"github.com/filecoin-project/lotus/build"
-	"github.com/filecoin-project/lotus/chain"
 	"github.com/filecoin-project/lotus/chain/store"
 	"github.com/filecoin-project/lotus/chain/types"
-	"github.com/filecoin-project/lotus/lib/jsonrpc"
 	"github.com/filecoin-project/lotus/node/repo"
 )
 
@@ -51,7 +51,7 @@ sync_complete:
 		select {
 		case <-ctx.Done():
 			return ctx.Err()
-		case <-time.After(5 * time.Second):
+		case <-build.Clock.After(5 * time.Second):
 			state, err := napi.SyncState(ctx)
 			if err != nil {
 				return err
@@ -71,7 +71,7 @@ sync_complete:
 						"target_height", w.Target.Height(),
 						"height", w.Height,
 						"error", w.Message,
-						"stage", chain.SyncStageString(w.Stage),
+						"stage", w.Stage.String(),
 					)
 				} else {
 					log.Infow(
@@ -81,7 +81,7 @@ sync_complete:
 						"target", w.Target.Key(),
 						"target_height", w.Target.Height(),
 						"height", w.Height,
-						"stage", chain.SyncStageString(w.Stage),
+						"stage", w.Stage.String(),
 					)
 				}
 
@@ -96,13 +96,13 @@ sync_complete:
 		select {
 		case <-ctx.Done():
 			return ctx.Err()
-		case <-time.After(5 * time.Second):
+		case <-build.Clock.After(5 * time.Second):
 			head, err := napi.ChainHead(ctx)
 			if err != nil {
 				return err
 			}
 
-			timestampDelta := time.Now().Unix() - int64(head.MinTimestamp())
+			timestampDelta := build.Clock.Now().Unix() - int64(head.MinTimestamp())
 
 			log.Infow(
 				"Waiting for reasonable head height",
@@ -113,16 +113,18 @@ sync_complete:
 			// If we get within 20 blocks of the current exected block height we
 			// consider sync complete. Block propagation is not always great but we still
 			// want to be recording stats as soon as we can
-			if timestampDelta < build.BlockDelay*20 {
+			if timestampDelta < int64(build.BlockDelaySecs)*20 {
 				return nil
 			}
 		}
 	}
 }
 
-func GetTips(ctx context.Context, api api.FullNode, lastHeight uint64) (<-chan *types.TipSet, error) {
+func GetTips(ctx context.Context, api api.FullNode, lastHeight abi.ChainEpoch, headlag int) (<-chan *types.TipSet, error) {
 	chmain := make(chan *types.TipSet)
 
+	hb := newHeadBuffer(headlag)
+
 	notif, err := api.ChainNotify(ctx)
 	if err != nil {
 		return nil, err
@@ -131,7 +133,8 @@ func GetTips(ctx context.Context, api api.FullNode, lastHeight uint64) (<-chan *
 	go func() {
 		defer close(chmain)
 
-		ping := time.Tick(30 * time.Second)
+		ticker := time.NewTicker(30 * time.Second)
+		defer ticker.Stop()
 
 		for {
 			select {
@@ -151,15 +154,21 @@ func GetTips(ctx context.Context, api api.FullNode, lastHeight uint64) (<-chan *
 							chmain <- tipset
 						}
 					case store.HCApply:
-						chmain <- change.Val
+						if out := hb.push(change); out != nil {
+							chmain <- out.Val
+						}
+					case store.HCRevert:
+						hb.pop()
 					}
 				}
-			case <-ping:
+			case <-ticker.C:
 				log.Info("Running health check")
 
 				cctx, cancel := context.WithTimeout(ctx, 5*time.Second)
+
 				if _, err := api.ID(cctx); err != nil {
 					log.Error("Health check failed")
+					cancel()
 					return
 				}
 
@@ -175,7 +184,7 @@ func GetTips(ctx context.Context, api api.FullNode, lastHeight uint64) (<-chan *
 	return chmain, nil
 }
 
-func loadTipsets(ctx context.Context, api api.FullNode, curr *types.TipSet, lowestHeight uint64) ([]*types.TipSet, error) {
+func loadTipsets(ctx context.Context, api api.FullNode, curr *types.TipSet, lowestHeight abi.ChainEpoch) ([]*types.TipSet, error) {
 	tipsets := []*types.TipSet{}
 	for {
 		if curr.Height() == 0 {
@@ -205,11 +214,11 @@ func loadTipsets(ctx context.Context, api api.FullNode, curr *types.TipSet, lowe
 	return tipsets, nil
 }
 
-func GetFullNodeAPI(repo string) (api.FullNode, jsonrpc.ClientCloser, error) {
+func GetFullNodeAPI(ctx context.Context, repo string) (api.FullNode, jsonrpc.ClientCloser, error) {
 	addr, headers, err := getAPI(repo)
 	if err != nil {
 		return nil, nil, err
 	}
 
-	return client.NewFullNodeRPC(addr, headers)
+	return client.NewFullNodeRPC(ctx, addr, headers)
 }