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

Lotus version 0.7.1
2020-09-17 21:32:04 -04:00 · 2020-09-17 21:31:47 -04:00 · 2020-09-18 03:14:05 +02:00 · 2020-09-18 03:00:31 +02:00 · 2020-09-18 02:40:01 +02:00 · 2020-09-18 02:39:08 +02:00
621 changed files with 75507 additions and 16496 deletions
@@ -1,11 +1,11 @@
 version: 2.1
 orbs:
-  go: gotest/tools@0.0.9
+  go: gotest/tools@0.0.13

 executors:
  golang:
    docker:
-      - image: circleci/golang:1.14.2
+      - image: circleci/golang:1.14.6
    resource_class: 2xlarge
  ubuntu:
    docker:
@@ -45,7 +45,7 @@ commands:
            - 'v25-2k-lotus-params'
          paths:
            - /var/tmp/filecoin-proof-parameters/
-      - run:  ./lotus fetch-params --proving-params 2048
+      - run:  ./lotus fetch-params 2048
      - save_cache:
          name: Save parameters cache
          key: 'v25-2k-lotus-params'
@@ -79,7 +79,6 @@ jobs:
    steps:
      - install-deps
      - prepare
-      - go/mod-download
      - go/mod-tidy-check

  build-all:
@@ -87,21 +86,17 @@ 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-seal-worker
-      - run: mkdir linux && mv lotus lotus-storage-miner lotus-seal-worker linux/
+          path: lotus-worker
+      - run: mkdir linux && mv lotus lotus-miner lotus-worker linux/
      - persist_to_workspace:
          root: "."
          paths:
@@ -112,17 +107,13 @@ 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 debug

  test: &test
    description: |
      Run tests with gotestsum.
-    parameters:
+    parameters: &test-params
      executor:
        type: executor
        default: golang
@@ -134,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
@@ -156,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:
@@ -189,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
+  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
@@ -225,24 +299,22 @@ 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-seal-worker
-      - run: mkdir darwin && mv lotus lotus-storage-miner lotus-seal-worker darwin/
+          path: lotus-worker
+      - run: mkdir darwin && mv lotus lotus-miner lotus-worker darwin/
      - persist_to_workspace:
          root: "."
          paths:
@@ -259,10 +331,30 @@ jobs:
    steps:
      - install-deps
      - prepare
-      - go/mod-download
      - 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.
@@ -272,7 +364,7 @@ jobs:
        default: golang
      golangci-lint-version:
        type: string
-        default: 1.23.8
+        default: 1.27.0
      concurrency:
        type: string
        default: '2'
@@ -288,7 +380,6 @@ jobs:
    steps:
      - install-deps
      - prepare
-      - go/mod-download
      - run:
          command: make deps
          no_output_timeout: 30m
@@ -298,11 +389,8 @@ 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

@@ -331,18 +419,35 @@ workflows:
  version: 2.1
  ci:
    jobs:
-      - lint-changes:
-          args: "--new-from-rev origin/master"
-      - test:
-          codecov-upload: true
+      - 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"
+          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:
@@ -1,3 +1,5 @@
 comment: off
 ignore:
  - "cbor_gen.go"
+github_checks:
+  annotations: false
@@ -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
@@ -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.
@@ -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`.
@@ -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"
@@ -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 }}
@@ -1,19 +1,23 @@
 /lotus
-/lotus-storage-miner
-/lotus-seal-worker
+/lotus-miner
+/lotus-worker
 /lotus-seed
 /lotus-health
+/lotus-chainwatch
 /lotus-shed
-/pond
-/townhall
-/fountain
-/stats
-/bench
+/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
 **/*.a
 **/*.pc
@@ -24,7 +28,6 @@ build/paramfetch.sh
 /vendor
 /blocks.dot
 /blocks.svg
-/chainwatch
 /chainwatch.db
 /bundle
 /darwin
@@ -35,3 +38,4 @@ build/paramfetch.sh
 bin/ipget
 bin/tmp/*
 .idea
+scratchpad
@@ -5,3 +5,12 @@
 [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
@@ -22,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
@@ -1,7 +1,477 @@
-# lotus changelog
+# Lotus changelog

-## 0.1.0 / 2019-12-11
+# 0.7.1 / 2020-09-17

-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 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.

-A huge thank you to all contributors for this testnet release!
+## 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!
@@ -6,7 +6,7 @@ all: build
 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
@@ -17,7 +17,7 @@ MODULES:=
 CLEAN:=
 BINS:=

-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
@@ -58,10 +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-storage-miner lotus-seal-worker lotus-seed
+2k: lotus lotus-miner lotus-worker lotus-seed

 lotus: $(BUILD_DEPS)
 	rm -f lotus
@@ -71,19 +71,19 @@ 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
@@ -92,16 +92,28 @@ lotus-shed: $(BUILD_DEPS)
 .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

@@ -119,55 +131,124 @@ 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 -i ./build
-.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 -i ./build
-.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
-	go run github.com/GeertJohan/go.rice/rice append --exec stats -i ./build
-.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

-health:
+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

-.PHONY: health
-BINS+=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

@@ -175,15 +256,15 @@ buildall: $(BINS)

 completions:
 	./scripts/make-completions.sh lotus
-	./scripts/make-completions.sh lotus-storage-miner
+	./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-storage-miner /usr/share/bash-completion/completions/lotus-storage-miner
+	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-storage-miner /usr/local/share/zsh/site-functions/_lotus-storage-miner
+	install -C ./scripts/zsh-completion/lotus-miner /usr/local/share/zsh/site-functions/_lotus-miner

 clean:
 	rm -rf $(CLEAN) $(BINS)
@@ -197,11 +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 $*=$($*)
@@ -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 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 [https://lotu.sh](https://lotu.sh) or read the source [here](https://github.com/filecoin-project/lotus/tree/master/documentation).
+
+## Reporting a Vulnerability
+
+Please send an email to security@filecoin.org. See our [security policy](SECURITY.md) for more details.
+
+## 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

@@ -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: |
@@ -4,19 +4,23 @@ 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)
@@ -24,6 +28,23 @@ type Common interface {
 	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)
@@ -33,6 +54,11 @@ type Common interface {

 	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
@@ -54,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
+}
@@ -2,23 +2,32 @@ package api

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

+	"github.com/filecoin-project/go-state-types/dline"
+
+	"github.com/filecoin-project/specs-actors/actors/runtime/proof"
+
 	"github.com/ipfs/go-cid"
-	"github.com/ipfs/go-filestore"
 	"github.com/libp2p/go-libp2p-core/peer"

 	"github.com/filecoin-project/go-address"
+	"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/specs-actors/actors/abi"
-	"github.com/filecoin-project/specs-actors/actors/abi/big"
+	"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/specs-actors/actors/builtin/market"
 	"github.com/filecoin-project/specs-actors/actors/builtin/miner"
 	"github.com/filecoin-project/specs-actors/actors/builtin/paych"
 	"github.com/filecoin-project/specs-actors/actors/builtin/power"
-	"github.com/filecoin-project/specs-actors/actors/crypto"
+	"github.com/filecoin-project/specs-actors/actors/builtin/verifreg"

 	"github.com/filecoin-project/lotus/chain/types"
+	marketevents "github.com/filecoin-project/lotus/markets/loggers"
 	"github.com/filecoin-project/lotus/node/modules/dtypes"
 )

@@ -26,83 +35,257 @@ import (
 type FullNode interface {
 	Common

-	// TODO: TipSetKeys
+	// MethodGroup: Chain
+	// The Chain method group contains methods for interacting with the
+	// blockchain, but that do not require any form of state computation.

-	// chain
-
-	// ChainNotify returns channel with chain head updates
-	// First message is guaranteed to be of len == 1, and type == 'current'
+	// 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(ctx context.Context, tsk types.TipSetKey, personalization crypto.DomainSeparationTag, randEpoch abi.ChainEpoch, entropy []byte) (abi.Randomness, 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)
+
+	// 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)
+
+	// ChainHasObj checks if a given CID exists in the chain blockstore.
 	ChainHasObj(context.Context, cid.Cid) (bool, error)
-	ChainStatObj(context.Context, cid.Cid, cid.Cid) (ObjStat, 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 computes weight for the specified tipset.
 	ChainTipSetWeight(context.Context, types.TipSetKey) (types.BigInt, error)
 	ChainGetNode(ctx context.Context, p string) (*IpldObject, error)
-	ChainGetMessage(context.Context, cid.Cid) (*types.Message, error)
-	ChainGetPath(ctx context.Context, from types.TipSetKey, to types.TipSetKey) ([]*HeadChange, error)
-	ChainExport(context.Context, types.TipSetKey) (<-chan []byte, error)

-	// syncer
+	// ChainGetMessage reads a message referenced by the specified CID from the
+	// chain blockstore.
+	ChainGetMessage(context.Context, cid.Cid) (*types.Message, error)
+
+	// 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
+
+	// 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)

-	// messages
+	// 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)
-	MpoolEstimateGasPrice(context.Context, uint64, address.Address, int64, types.TipSetKey) (types.BigInt, 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
+
+	// 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 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 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
+	// 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, ref FileRef) (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, ref FileRef) 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(ctx context.Context, inpath string, miner address.Address) (*CommPRet, 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)
@@ -112,61 +295,179 @@ type FullNode interface {

 	//ClientListAsks() []Ask

-	// if tipset is nil, we'll use heaviest
+	// 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.
+
+	// 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(ctx context.Context, act *types.Actor, tsk types.TipSetKey) (*ActorState, 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(context.Context, address.Address, *abi.BitField, bool, types.TipSetKey) ([]*ChainSectorInfo, error)
-	StateMinerProvingSet(context.Context, address.Address, types.TipSetKey) ([]*ChainSectorInfo, error)
-	StateMinerProvingDeadline(context.Context, address.Address, types.TipSetKey) (*miner.DeadlineInfo, error)
+	// StateMinerSectors returns info about the given miner's sectors. If the filter bitfield is nil, all sectors are included.
+	// If the filterOut boolean is set to true, any sectors in the filter are excluded.
+	// If false, only those sectors in the filter are included.
+	StateMinerSectors(context.Context, address.Address, *bitfield.BitField, bool, types.TipSetKey) ([]*ChainSectorInfo, error)
+	// StateMinerActiveSectors returns info about sectors that a given miner is actively proving.
+	StateMinerActiveSectors(context.Context, address.Address, types.TipSetKey) ([]*ChainSectorInfo, error)
+	// StateMinerProvingDeadline calculates the deadline at some epoch for a proving period
+	// and returns the deadline-related calculations.
+	StateMinerProvingDeadline(context.Context, address.Address, types.TipSetKey) (*dline.Info, error)
+	// StateMinerPower returns the power of the indicated miner
 	StateMinerPower(context.Context, address.Address, types.TipSetKey) (*MinerPower, error)
-	StateMinerInfo(context.Context, address.Address, types.TipSetKey) (miner.MinerInfo, error)
-	StateMinerDeadlines(context.Context, address.Address, types.TipSetKey) (*miner.Deadlines, error)
-	StateMinerFaults(context.Context, address.Address, types.TipSetKey) ([]abi.SectorNumber, error)
-	StateMinerInitialPledgeCollateral(context.Context, address.Address, abi.SectorNumber, types.TipSetKey) (types.BigInt, error)
+	// StateMinerInfo returns info about the indicated miner
+	StateMinerInfo(context.Context, address.Address, types.TipSetKey) (MinerInfo, error)
+	// StateMinerDeadlines returns all the proving deadlines for the given miner
+	StateMinerDeadlines(context.Context, address.Address, types.TipSetKey) ([]*miner.Deadline, error)
+	// StateMinerPartitions loads miner partitions for the specified miner/deadline
+	StateMinerPartitions(context.Context, address.Address, uint64, types.TipSetKey) ([]*miner.Partition, error)
+	// StateMinerFaults returns a bitfield indicating the faulty sectors of the given miner
+	StateMinerFaults(context.Context, address.Address, types.TipSetKey) (bitfield.BitField, error)
+	// StateAllMinerFaults returns all non-expired Faults that occur within lookback epochs of the given tipset
+	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)
-	StatePledgeCollateral(context.Context, types.TipSetKey) (types.BigInt, error)
-	StateWaitMsg(context.Context, cid.Cid) (*MsgLookup, 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) (*SectorExpiration, error)
+	// StateSectorPartition finds deadline/partition with the specified sector
+	StateSectorPartition(ctx context.Context, maddr address.Address, sectorNumber abi.SectorNumber, tok types.TipSetKey) (*SectorLocation, error)
+	// StateSearchMsg searches for a message in the chain, and returns its receipt and the tipset where it was executed
 	StateSearchMsg(context.Context, cid.Cid) (*MsgLookup, error)
+	// StateMsgGasCost searches for a message in the chain, and returns details of the messages gas costs, including the penalty and miner tip
+	StateMsgGasCost(context.Context, cid.Cid, types.TipSetKey) (*MsgGasCost, error)
+	// StateWaitMsg looks back in the chain for a message. If not found, it blocks until the
+	// message arrives on chain, and gets to the indicated confidence depth.
+	StateWaitMsg(ctx context.Context, cid cid.Cid, confidence uint64) (*MsgLookup, error)
+	// 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 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) (*verifreg.DataCap, error)
+	// StateDealProviderCollateralBounds returns the min and max collateral a storage provider
+	// can issue. It takes the deal size and verified status as parameters.
+	StateDealProviderCollateralBounds(context.Context, abi.PaddedPieceSize, bool, types.TipSetKey) (DealCollateralBounds, error)

+	// StateCirculatingSupply returns the circulating supply of Filecoin at the given tipset
+	StateCirculatingSupply(context.Context, types.TipSetKey) (CirculatingSupply, error)
+
+	// MethodGroup: Msig
+	// The Msig methods are used to interact with multisig wallets on the
+	// 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)
-	MsigCreate(context.Context, int64, []address.Address, types.BigInt, address.Address, types.BigInt) (cid.Cid, 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(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, *paych.SignedVoucher) error
 	PaychVoucherCheckSpendable(context.Context, address.Address, *paych.SignedVoucher, []byte, []byte) (bool, error)
-	PaychVoucherCreate(context.Context, address.Address, types.BigInt, uint64) (*paych.SignedVoucher, 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) (cid.Cid, error)
+	PaychVoucherSubmit(context.Context, address.Address, *paych.SignedVoucher, []byte, []byte) (cid.Cid, error)
 }

 type FileRef struct {
@@ -175,15 +476,35 @@ type FileRef struct {
 }

 type MinerSectors struct {
-	Sset uint64
-	Pset uint64
+	Sectors uint64
+	Active  uint64
+}
+
+type SectorExpiration struct {
+	OnTime abi.ChainEpoch
+
+	// non-zero if sector is faulty, epoch at which it will be permanently
+	// removed if it doesn't recover
+	Early abi.ChainEpoch
+}
+
+type SectorLocation struct {
+	Deadline  uint64
+	Partition uint64
+}
+
+type ImportRes struct {
+	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 {
@@ -192,6 +513,7 @@ type DealInfo struct {
 	Message     string // more information about deal state, particularly errors
 	Provider    address.Address

+	DataRef  *storagemarket.DataRef
 	PieceCID cid.Cid
 	Size     uint64

@@ -199,11 +521,27 @@ type DealInfo struct {
 	Duration      uint64

 	DealID abi.DealID
+
+	CreationTime time.Time
 }

 type MsgLookup struct {
-	Receipt types.MessageReceipt
-	TipSet  *types.TipSet
+	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 {
@@ -242,14 +580,36 @@ 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       []*paych.SignedVoucher
+	Channel      address.Address
+	WaitSentinel cid.Cid
+	Vouchers     []*paych.SignedVoucher
 }

 type VoucherSpec struct {
@@ -261,6 +621,16 @@ type VoucherSpec struct {
 	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 power.Claim
 	TotalPower power.Claim
@@ -269,27 +639,31 @@ type MinerPower struct {
 type QueryOffer struct {
 	Err string

-	Root cid.Cid
+	Root  cid.Cid
+	Piece *cid.Cid

 	Size                    uint64
 	MinPrice                types.BigInt
+	UnsealPrice             types.BigInt
 	PaymentInterval         uint64
 	PaymentIntervalIncrease uint64
 	Miner                   address.Address
-	MinerPeerID             peer.ID
+	MinerPeer               retrievalmarket.RetrievalPeer
 }

 func (o *QueryOffer) Order(client address.Address) RetrievalOrder {
 	return RetrievalOrder{
 		Root:                    o.Root,
+		Piece:                   o.Piece,
 		Size:                    o.Size,
 		Total:                   o.MinPrice,
+		UnsealPrice:             o.UnsealPrice,
 		PaymentInterval:         o.PaymentInterval,
 		PaymentIntervalIncrease: o.PaymentIntervalIncrease,
 		Client:                  client,

-		Miner:       o.Miner,
-		MinerPeerID: o.MinerPeerID,
+		Miner:     o.Miner,
+		MinerPeer: o.MinerPeer,
 	}
 }

@@ -305,23 +679,25 @@ type MarketDeal struct {

 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
+	UnsealPrice             types.BigInt
 	PaymentInterval         uint64
 	PaymentIntervalIncrease uint64
 	Client                  address.Address
 	Miner                   address.Address
-	MinerPeerID             peer.ID
+	MinerPeer               retrievalmarket.RetrievalPeer
 }

 type InvocResult struct {
-	Msg                *types.Message
-	MsgRct             *types.MessageReceipt
-	InternalExecutions []*types.ExecutionResult
-	Error              string
-	Duration           time.Duration
+	Msg            *types.Message
+	MsgRct         *types.MessageReceipt
+	ExecutionTrace types.ExecutionTrace
+	Error          string
+	Duration       time.Duration
 }

 type MethodCall struct {
@@ -330,12 +706,15 @@ type MethodCall struct {
 }

 type StartDealParams struct {
-	Data              *storagemarket.DataRef
-	Wallet            address.Address
-	Miner             address.Address
-	EpochPrice        types.BigInt
-	MinBlocksDuration uint64
-	DealStartEpoch    abi.ChainEpoch
+	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 {
@@ -368,8 +747,28 @@ const (
 	StageMessages
 	StageSyncComplete
 	StageSyncErrored
+	StageFetchingMessages
 )

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

 const (
@@ -387,14 +786,28 @@ type ComputeStateOutput struct {
 	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         []abi.SectorInfo
+	Sectors         []proof.SectorInfo
 	WorkerKey       address.Address
 	SectorSize      abi.SectorSize
 	PrevBeaconEntry types.BeaconEntry
 	BeaconEntries   []types.BeaconEntry
+	HasMinPower     bool
 }

 type BlockTemplate struct {
@@ -406,7 +819,12 @@ type BlockTemplate struct {
 	Messages         []*types.SignedMessage
 	Epoch            abi.ChainEpoch
 	Timestamp        uint64
-	WinningPoStProof []abi.PoStProof
+	WinningPoStProof []proof.PoStProof
+}
+
+type DataSize struct {
+	PayloadSize int64
+	PieceSize   abi.PaddedPieceSize
 }

 type CommPRet struct {
@@ -424,3 +842,8 @@ const (
 	MsigApprove MsigProposeResponse = iota
 	MsigCancel
 )
+
+type Fault struct {
+	Miner address.Address
+	Epoch abi.ChainEpoch
+}
@@ -3,16 +3,19 @@ package api
 import (
 	"bytes"
 	"context"
+	"time"

 	"github.com/ipfs/go-cid"

 	"github.com/filecoin-project/go-address"
+	"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/sector-storage/stores"
-	"github.com/filecoin-project/sector-storage/storiface"
-	"github.com/filecoin-project/specs-actors/actors/abi"
-
+	"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"
 )

 // StorageMiner is a low-level interface to the Filecoin network storage miner node
@@ -29,34 +32,75 @@ type StorageMiner interface {
 	PledgeSector(context.Context) error

 	// Get the status of a given sector by ID
-	SectorsStatus(context.Context, abi.SectorNumber) (SectorInfo, error)
+	SectorsStatus(ctx context.Context, sid abi.SectorNumber, showOnChainInfo bool) (SectorInfo, error)

 	// List all staged sectors
 	SectorsList(context.Context) ([]abi.SectorNumber, error)

 	SectorsRefs(context.Context) (map[string][]SealedRef, 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

 	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) (stores.FsStat, error)
+	StorageStat(ctx context.Context, id stores.ID) (fsutil.FsStat, 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)
+
+	// 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) ([]storagemarket.StorageDeal, error)
+	MarketListRetrievalDeals(ctx context.Context) ([]retrievalmarket.ProviderDealState, error)
+	MarketGetDealUpdates(ctx context.Context) (<-chan storagemarket.MinerDeal, error)
 	MarketListIncompleteDeals(ctx context.Context) ([]storagemarket.MinerDeal, error)
-	MarketSetPrice(context.Context, types.BigInt) 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) ([]storagemarket.StorageDeal, 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 {
@@ -76,24 +120,40 @@ type SectorLog struct {
 }

 type SectorInfo struct {
-	SectorID abi.SectorNumber
-	State    SectorState
-	CommD    *cid.Cid
-	CommR    *cid.Cid
-	Proof    []byte
-	Deals    []abi.DealID
-	Ticket   SealTicket
-	Seed     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 abi.SectorNumber
-	Offset   uint64
+	Offset   abi.PaddedPieceSize
 	Size     abi.UnpaddedPieceSize
 }

@@ -2,17 +2,20 @@ package api

 import (
 	"context"
+	"io"

-	"github.com/filecoin-project/sector-storage/sealtasks"
-	"github.com/filecoin-project/sector-storage/stores"
-	"github.com/filecoin-project/sector-storage/storiface"
-	"github.com/filecoin-project/specs-actors/actors/abi"
+	"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 {
+type WorkerAPI interface {
 	Version(context.Context) (build.Version, error)
 	// TODO: Info() (name, ...) ?

@@ -20,8 +23,18 @@ type WorkerApi interface {
 	Paths(context.Context) ([]stores.StoragePath, error)
 	Info(context.Context) (storiface.WorkerInfo, error)

+	AddPiece(ctx context.Context, sector abi.SectorID, pieceSizes []abi.UnpaddedPieceSize, newPieceSize abi.UnpaddedPieceSize, pieceData storage.Data) (abi.PieceInfo, error)
+
 	storage.Sealer
-	Fetch(context.Context, abi.SectorID, stores.SectorFileType, bool) error
+
+	MoveStorage(ctx context.Context, sector abi.SectorID, types stores.SectorFileType) error
+
+	UnsealPiece(context.Context, abi.SectorID, storiface.UnpaddedByteIndex, abi.UnpaddedPieceSize, abi.SealRandomness, cid.Cid) error
+	ReadPiece(context.Context, io.Writer, abi.SectorID, storiface.UnpaddedByteIndex, abi.UnpaddedPieceSize) (bool, error)
+
+	StorageAddLocal(ctx context.Context, path string) error
+
+	Fetch(context.Context, abi.SectorID, stores.SectorFileType, stores.PathType, stores.AcquireMode) error

 	Closing(context.Context) (<-chan struct{}, error)
 }
@@ -5,8 +5,9 @@ import (

 	blocks "github.com/ipfs/go-block-format"
 	"github.com/ipfs/go-cid"
-	blockstore "github.com/ipfs/go-ipfs-blockstore"
 	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/lotus/lib/blockstore"
 )

 type ChainIO interface {
@@ -1,111 +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 PermissionedWorkerAPI(a api.WorkerApi) api.WorkerApi {
+func PermissionedWorkerAPI(a api.WorkerAPI) api.WorkerAPI {
 	var out WorkerStruct
-	permissionedAny(a, &out.Internal)
+	auth.PermissionedProxy(AllPermissions, DefaultPerms, a, &out.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}
-			}
-		}))
-
-	}
-}
@@ -6,8 +6,8 @@ import (
 	"fmt"
 	"io"

-	"github.com/filecoin-project/specs-actors/actors/abi"
-	"github.com/filecoin-project/specs-actors/actors/builtin/paych"
+	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"
 )
@@ -33,7 +33,7 @@ func (t *PaymentInfo) MarshalCBOR(w io.Writer) error {
 	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("Channel"))); err != nil {
 		return err
 	}
-	if _, err := io.WriteString(w, "Channel"); err != nil {
+	if _, err := io.WriteString(w, string("Channel")); err != nil {
 		return err
 	}

@@ -41,26 +41,20 @@ func (t *PaymentInfo) MarshalCBOR(w io.Writer) error {
 		return err
 	}

-	// t.ChannelMessage (cid.Cid) (struct)
-	if len("ChannelMessage") > cbg.MaxLength {
-		return xerrors.Errorf("Value in field \"ChannelMessage\" was too long")
+	// 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("ChannelMessage"))); err != nil {
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("WaitSentinel"))); err != nil {
 		return err
 	}
-	if _, err := io.WriteString(w, "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.WriteCidBuf(scratch, 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 ([]*paych.SignedVoucher) (slice)
@@ -71,7 +65,7 @@ func (t *PaymentInfo) MarshalCBOR(w io.Writer) error {
 	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("Vouchers"))); err != nil {
 		return err
 	}
-	if _, err := io.WriteString(w, "Vouchers"); err != nil {
+	if _, err := io.WriteString(w, string("Vouchers")); err != nil {
 		return err
 	}

@@ -91,6 +85,8 @@ func (t *PaymentInfo) MarshalCBOR(w io.Writer) error {
 }

 func (t *PaymentInfo) UnmarshalCBOR(r io.Reader) error {
+	*t = PaymentInfo{}
+
 	br := cbg.GetPeeker(r)
 	scratch := make([]byte, 8)

@@ -131,29 +127,17 @@ func (t *PaymentInfo) UnmarshalCBOR(r io.Reader) error {
 				}

 			}
-			// t.ChannelMessage (cid.Cid) (struct)
-		case "ChannelMessage":
+			// t.WaitSentinel (cid.Cid) (struct)
+		case "WaitSentinel":

 			{

-				pb, err := br.PeekByte()
+				c, err := cbg.ReadCid(br)
 				if err != nil {
-					return err
+					return xerrors.Errorf("failed to read cid field t.WaitSentinel: %w", 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.WaitSentinel = c

 			}
 			// t.Vouchers ([]*paych.SignedVoucher) (slice)
@@ -212,7 +196,7 @@ func (t *SealedRef) MarshalCBOR(w io.Writer) error {
 	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("SectorID"))); err != nil {
 		return err
 	}
-	if _, err := io.WriteString(w, "SectorID"); err != nil {
+	if _, err := io.WriteString(w, string("SectorID")); err != nil {
 		return err
 	}

@@ -220,7 +204,7 @@ func (t *SealedRef) MarshalCBOR(w io.Writer) error {
 		return err
 	}

-	// t.Offset (uint64) (uint64)
+	// t.Offset (abi.PaddedPieceSize) (uint64)
 	if len("Offset") > cbg.MaxLength {
 		return xerrors.Errorf("Value in field \"Offset\" was too long")
 	}
@@ -228,7 +212,7 @@ func (t *SealedRef) MarshalCBOR(w io.Writer) error {
 	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("Offset"))); err != nil {
 		return err
 	}
-	if _, err := io.WriteString(w, "Offset"); err != nil {
+	if _, err := io.WriteString(w, string("Offset")); err != nil {
 		return err
 	}

@@ -244,7 +228,7 @@ func (t *SealedRef) MarshalCBOR(w io.Writer) error {
 	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("Size"))); err != nil {
 		return err
 	}
-	if _, err := io.WriteString(w, "Size"); err != nil {
+	if _, err := io.WriteString(w, string("Size")); err != nil {
 		return err
 	}

@@ -256,6 +240,8 @@ func (t *SealedRef) MarshalCBOR(w io.Writer) error {
 }

 func (t *SealedRef) UnmarshalCBOR(r io.Reader) error {
+	*t = SealedRef{}
+
 	br := cbg.GetPeeker(r)
 	scratch := make([]byte, 8)

@@ -301,7 +287,7 @@ func (t *SealedRef) UnmarshalCBOR(r io.Reader) error {
 				t.SectorID = abi.SectorNumber(extra)

 			}
-			// t.Offset (uint64) (uint64)
+			// t.Offset (abi.PaddedPieceSize) (uint64)
 		case "Offset":

 			{
@@ -313,7 +299,7 @@ func (t *SealedRef) UnmarshalCBOR(r io.Reader) error {
 				if maj != cbg.MajUnsignedInt {
 					return fmt.Errorf("wrong type for uint64 field")
 				}
-				t.Offset = uint64(extra)
+				t.Offset = abi.PaddedPieceSize(extra)

 			}
 			// t.Size (abi.UnpaddedPieceSize) (uint64)
@@ -358,7 +344,7 @@ func (t *SealedRefs) MarshalCBOR(w io.Writer) error {
 	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("Refs"))); err != nil {
 		return err
 	}
-	if _, err := io.WriteString(w, "Refs"); err != nil {
+	if _, err := io.WriteString(w, string("Refs")); err != nil {
 		return err
 	}

@@ -378,6 +364,8 @@ func (t *SealedRefs) MarshalCBOR(w io.Writer) error {
 }

 func (t *SealedRefs) UnmarshalCBOR(r io.Reader) error {
+	*t = SealedRefs{}
+
 	br := cbg.GetPeeker(r)
 	scratch := make([]byte, 8)

@@ -464,7 +452,7 @@ func (t *SealTicket) MarshalCBOR(w io.Writer) error {
 	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("Value"))); err != nil {
 		return err
 	}
-	if _, err := io.WriteString(w, "Value"); err != nil {
+	if _, err := io.WriteString(w, string("Value")); err != nil {
 		return err
 	}

@@ -476,7 +464,7 @@ func (t *SealTicket) MarshalCBOR(w io.Writer) error {
 		return err
 	}

-	if _, err := w.Write(t.Value); err != nil {
+	if _, err := w.Write(t.Value[:]); err != nil {
 		return err
 	}

@@ -488,7 +476,7 @@ func (t *SealTicket) MarshalCBOR(w io.Writer) error {
 	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("Epoch"))); err != nil {
 		return err
 	}
-	if _, err := io.WriteString(w, "Epoch"); err != nil {
+	if _, err := io.WriteString(w, string("Epoch")); err != nil {
 		return err
 	}

@@ -505,6 +493,8 @@ func (t *SealTicket) MarshalCBOR(w io.Writer) error {
 }

 func (t *SealTicket) UnmarshalCBOR(r io.Reader) error {
+	*t = SealTicket{}
+
 	br := cbg.GetPeeker(r)
 	scratch := make([]byte, 8)

@@ -549,8 +539,12 @@ func (t *SealTicket) UnmarshalCBOR(r io.Reader) error {
 			if maj != cbg.MajByteString {
 				return fmt.Errorf("expected byte array")
 			}
-			t.Value = make([]byte, extra)
-			if _, err := io.ReadFull(br, t.Value); err != nil {
+
+			if extra > 0 {
+				t.Value = make([]uint8, extra)
+			}
+
+			if _, err := io.ReadFull(br, t.Value[:]); err != nil {
 				return err
 			}
 			// t.Epoch (abi.ChainEpoch) (int64)
@@ -606,7 +600,7 @@ func (t *SealSeed) MarshalCBOR(w io.Writer) error {
 	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("Value"))); err != nil {
 		return err
 	}
-	if _, err := io.WriteString(w, "Value"); err != nil {
+	if _, err := io.WriteString(w, string("Value")); err != nil {
 		return err
 	}

@@ -618,7 +612,7 @@ func (t *SealSeed) MarshalCBOR(w io.Writer) error {
 		return err
 	}

-	if _, err := w.Write(t.Value); err != nil {
+	if _, err := w.Write(t.Value[:]); err != nil {
 		return err
 	}

@@ -630,7 +624,7 @@ func (t *SealSeed) MarshalCBOR(w io.Writer) error {
 	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("Epoch"))); err != nil {
 		return err
 	}
-	if _, err := io.WriteString(w, "Epoch"); err != nil {
+	if _, err := io.WriteString(w, string("Epoch")); err != nil {
 		return err
 	}

@@ -647,6 +641,8 @@ func (t *SealSeed) MarshalCBOR(w io.Writer) error {
 }

 func (t *SealSeed) UnmarshalCBOR(r io.Reader) error {
+	*t = SealSeed{}
+
 	br := cbg.GetPeeker(r)
 	scratch := make([]byte, 8)

@@ -691,8 +687,12 @@ func (t *SealSeed) UnmarshalCBOR(r io.Reader) error {
 			if maj != cbg.MajByteString {
 				return fmt.Errorf("expected byte array")
 			}
-			t.Value = make([]byte, extra)
-			if _, err := io.ReadFull(br, t.Value); err != nil {
+
+			if extra > 0 {
+				t.Value = make([]uint8, extra)
+			}
+
+			if _, err := io.ReadFull(br, t.Value[:]); err != nil {
 				return err
 			}
 			// t.Epoch (abi.ChainEpoch) (int64)
@@ -1,17 +1,23 @@
 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,
 		},
@@ -22,9 +28,9 @@ func NewCommonRPC(addr string, requestHeader http.Header) (api.Common, jsonrpc.C
 }

 // 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,
@@ -33,27 +39,45 @@ 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,
+		opts...,
 	)

 	return &res, closer, err
 }

-func NewWorkerRPC(addr string, requestHeader http.Header) (api.WorkerApi, jsonrpc.ClientCloser, error) {
+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(addr, "Filecoin",
+	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
@@ -0,0 +1,419 @@
+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(&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)
+			}
+		}
+	}
+}
@@ -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
+}
@@ -0,0 +1,99 @@
+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.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))
+	}
+
+	fmt.Println("shutting down mining")
+	atomic.AddInt64(&mine, -1)
+	<-done
+}
@@ -8,18 +8,23 @@ import (
 	"math/rand"
 	"os"
 	"path/filepath"
+	"sync/atomic"
 	"testing"
 	"time"

-	"github.com/ipfs/go-cid"
+	"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"
@@ -29,16 +34,21 @@ import (
 	ipld "github.com/ipfs/go-ipld-format"
 )

+var MineNext = miner.MineReq{
+	InjectNulls: 0,
+	Done:        func(bool, abi.ChainEpoch, error) {},
+}
+
 func init() {
 	logging.SetAllLoggers(logging.LevelInfo)
 	build.InsecurePoStValidation = true
 }

-func TestDealFlow(t *testing.T, b APIBuilder, blocktime time.Duration, carExport bool) {
-	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, oneMiner)
+	n, sn := b(t, 1, OneMiner)
 	client := n[0].FullNode.(*impl.FullNodeAPI)
 	miner := sn[0]

@@ -52,30 +62,30 @@ func TestDealFlow(t *testing.T, b APIBuilder, blocktime time.Duration, carExport
 	}
 	time.Sleep(time.Second)

-	mine := true
+	mine := int64(1)
 	done := make(chan struct{})
 	go func() {
 		defer close(done)
-		for mine {
+		for atomic.LoadInt64(&mine) == 1 {
 			time.Sleep(blocktime)
-			if err := sn[0].MineOne(ctx, func(bool) {}); err != nil {
+			if err := sn[0].MineOne(ctx, MineNext); err != nil {
 				t.Error(err)
 			}
 		}
 	}()

-	makeDeal(t, ctx, 6, client, miner, carExport)
+	makeDeal(t, ctx, 6, client, miner, carExport, fastRet)

-	mine = false
+	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")
+	_ = os.Setenv("BELLMAN_NO_GPU", "1")

 	ctx := context.Background()
-	n, sn := b(t, 1, oneMiner)
+	n, sn := b(t, 1, OneMiner)
 	client := n[0].FullNode.(*impl.FullNodeAPI)
 	miner := sn[0]

@@ -89,28 +99,28 @@ func TestDoubleDealFlow(t *testing.T, b APIBuilder, blocktime time.Duration) {
 	}
 	time.Sleep(time.Second)

-	mine := true
+	mine := int64(1)
 	done := make(chan struct{})

 	go func() {
 		defer close(done)
-		for mine {
+		for atomic.LoadInt64(&mine) == 1 {
 			time.Sleep(blocktime)
-			if err := sn[0].MineOne(ctx, func(bool) {}); err != nil {
+			if err := sn[0].MineOne(ctx, MineNext); err != nil {
 				t.Error(err)
 			}
 		}
 	}()

-	makeDeal(t, ctx, 6, client, miner, false)
-	makeDeal(t, ctx, 7, client, miner, false)
+	makeDeal(t, ctx, 6, client, miner, false, false)
+	makeDeal(t, ctx, 7, client, miner, false, false)

-	mine = 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 bool) {
+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)

@@ -122,18 +132,151 @@ func makeDeal(t *testing.T, ctx context.Context, rseed int, client *impl.FullNod

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

-	deal := startDeal(t, ctx, miner, client, 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, client, deal)
+	waitDealSealed(t, ctx, miner, client, deal, false)

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

-	testRetrieval(t, ctx, err, client, fcid, carExport, data)
+	testRetrieval(t, ctx, client, fcid, &info.PieceCID, carExport, data)
 }

-func startDeal(t *testing.T, ctx context.Context, miner TestStorageNode, client *impl.FullNodeAPI, fcid cid.Cid) *cid.Cid {
+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)
+
+	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 atomic.LoadInt64(&mine) == 1 {
+			time.Sleep(blocktime)
+			if err := sn[0].MineOne(ctx, MineNext); err != nil {
+				t.Error(err)
+			}
+		}
+	}()
+
+	{
+		data1 := make([]byte, 800)
+		rand.New(rand.NewSource(int64(3))).Read(data1)
+		r := bytes.NewReader(data1)
+
+		fcid1, err := 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)
+	}
+
+	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)
@@ -144,11 +287,15 @@ func startDeal(t *testing.T, ctx context.Context, miner TestStorageNode, client
 		t.Fatal(err)
 	}
 	deal, err := client.ClientStartDeal(ctx, &api.StartDealParams{
-		Data:              &storagemarket.DataRef{Root: fcid},
+		Data: &storagemarket.DataRef{
+			TransferType: storagemarket.TTGraphsync,
+			Root:         fcid,
+		},
 		Wallet:            addr,
 		Miner:             maddr,
 		EpochPrice:        types.NewInt(1000000),
-		MinBlocksDuration: 100,
+		MinBlocksDuration: uint64(build.MinDealDuration),
+		FastRetrieval:     fastRet,
 	})
 	if err != nil {
 		t.Fatalf("%+v", err)
@@ -156,7 +303,7 @@ func startDeal(t *testing.T, ctx context.Context, miner TestStorageNode, client
 	return deal
 }

-func waitDealSealed(t *testing.T, ctx context.Context, client *impl.FullNodeAPI, deal *cid.Cid) {
+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)
@@ -164,6 +311,11 @@ loop:
 			t.Fatal(err)
 		}
 		switch di.State {
+		case storagemarket.StorageDealSealing:
+			if noseal {
+				return
+			}
+			startSealingWaiting(t, ctx, miner)
 		case storagemarket.StorageDealProposalRejected:
 			t.Fatal("deal rejected")
 		case storagemarket.StorageDealFailing:
@@ -179,8 +331,53 @@ loop:
 	}
 }

-func testRetrieval(t *testing.T, ctx context.Context, err error, client *impl.FullNodeAPI, fcid cid.Cid, carExport bool, data []byte) {
-	offers, err := client.ClientFindData(ctx, fcid)
+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])
+			}
+		}
+	}
+}
+
+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)
 	}
@@ -193,20 +390,22 @@ func testRetrieval(t *testing.T, ctx context.Context, err error, client *impl.Fu
 	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)
 	}

-	ref := api.FileRef{
+	ref := &api.FileRef{
 		Path:  filepath.Join(rpath, "ret"),
 		IsCAR: carExport,
 	}
-	err = client.ClientRetrieve(ctx, offers[0].Order(caddr), ref)
-	if err != nil {
-		t.Fatalf("%+v", err)
+	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"))
@@ -12,36 +12,39 @@ import (

 	logging "github.com/ipfs/go-log/v2"

-	"github.com/filecoin-project/specs-actors/actors/abi"
+	"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, oneMiner)
+	apis, sn := ts.makeNodes(t, 1, OneMiner)
 	api := apis[0]

-	h1, err := api.ChainHead(ctx)
-	require.NoError(t, err)
-	require.Equal(t, abi.ChainEpoch(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, func(bool) {})
+	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, abi.ChainEpoch(1), h2.Height())
+	require.Greater(t, int64(h2.Height()), int64(h1.Height()))
 }

 func (ts *testSuite) testMiningReal(t *testing.T) {
@@ -51,45 +54,48 @@ func (ts *testSuite) testMiningReal(t *testing.T) {
 	}()

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

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

-	err = sn[0].MineOne(ctx, func(bool) {})
+	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(1), h2.Height())
+	require.Equal(t, abi.ChainEpoch(3), h2.Height())

-	err = sn[0].MineOne(ctx, func(bool) {})
+	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(2), h2.Height())
+	require.Equal(t, abi.ChainEpoch(4), h2.Height())
 }

 func TestDealMining(t *testing.T, b APIBuilder, blocktime time.Duration, carExport bool) {
-	os.Setenv("BELLMAN_NO_GPU", "1")
+	_ = 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 storage miners on non-first full node
+		{Full: 0, Preseal: 0}, // TODO: Add support for miners on non-first full node
 	})
 	client := n[0].FullNode.(*impl.FullNodeAPI)
 	provider := sn[1]
@@ -125,27 +131,30 @@ func TestDealMining(t *testing.T, b APIBuilder, blocktime time.Duration, carExpo
 	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)

-		prevExpect := 0
+		complChan := minedTwo
 		for atomic.LoadInt32(&mine) != 0 {
-			wait := make(chan int, 2)
-			mdone := func(mined bool) {
-				go func() {
-					n := 0
-					if mined {
-						n = 1
-					}
-					wait <- n
-				}()
+			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, mdone); err != nil {
+			if err := sn[0].MineOne(ctx, miner.MineReq{Done: mdone}); err != nil {
 				t.Error(err)
 			}

-			if err := sn[1].MineOne(ctx, mdone); err != nil {
+			if err := sn[1].MineOne(ctx, miner.MineReq{Done: mdone}); err != nil {
 				t.Error(err)
 			}

@@ -153,43 +162,42 @@ func TestDealMining(t *testing.T, b APIBuilder, blocktime time.Duration, carExpo
 			expect += <-wait

 			time.Sleep(blocktime)
-
-			for {
-				n := 0
-				for i, node := range sn {
-					mb, err := node.MiningBase(ctx)
-					if err != nil {
-						t.Error(err)
-						return
-					}
-
-					if len(mb.Cids()) != expect {
-						log.Warnf("node %d mining base not complete (%d, want %d)", i, len(mb.Cids()), expect)
-						continue
-					}
-					n++
-				}
-				if n == len(sn) {
-					break
-				}
-				time.Sleep(blocktime)
+			if expect == 0 {
+				// null block
+				continue
 			}

-			if prevExpect == 2 && expect == 2 && minedTwo != nil {
-				close(minedTwo)
-				minedTwo = nil
+			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
 			}

-			prevExpect = expect
 		}
 	}()

-	deal := startDeal(t, ctx, provider, client, fcid)
+	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, client, deal)
+	waitDealSealed(t, ctx, provider, client, deal, false)

 	<-minedTwo

@@ -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
+}
@@ -4,23 +4,36 @@ 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, func(bool)) error
+	MineOne func(context.Context, miner.MineReq) error
 }

 var PresealGenesis = -1

+const GenesisPreseals = 2
+
 type StorageMiner struct {
 	Full    int
 	Preseal int
@@ -49,25 +62,25 @@ func TestApis(t *testing.T, b APIBuilder) {
 	t.Run("testMiningReal", ts.testMiningReal)
 }

-var oneMiner = []StorageMiner{{Full: 0, Preseal: PresealGenesis}}
+var OneMiner = []StorageMiner{{Full: 0, Preseal: PresealGenesis}}

 func (ts *testSuite) testVersion(t *testing.T) {
+	build.RunningNodeType = build.NodeFull
+
 	ctx := context.Background()
-	apis, _ := ts.makeNodes(t, 1, oneMiner)
+	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, oneMiner)
+	apis, _ := ts.makeNodes(t, 1, OneMiner)
 	api := apis[0]

 	id, err := api.ID(ctx)
@@ -79,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, oneMiner)
+	apis, _ := ts.makeNodes(t, 2, OneMiner)

 	p, err := apis[0].NetPeers(ctx)
 	if err != nil {
@@ -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...")
+}
@@ -0,0 +1,321 @@
+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"
+	miner2 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
+
+	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/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+(miner2.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)
+
+		n, err := parts[0].Sectors.Count()
+		require.NoError(t, err)
+		require.Equal(t, uint64(2), n)
+
+		// Drop the partition
+		err = parts[0].Sectors.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)
+
+		n, err := parts[0].Sectors.Count()
+		require.NoError(t, err)
+		require.Equal(t, uint64(2), n)
+
+		// Drop the sector
+		sn, err := parts[0].Sectors.First()
+		require.NoError(t, err)
+
+		all, err := parts[0].Sectors.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+(miner2.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+(miner2.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
+}
@@ -2,11 +2,22 @@ package api

 import (
 	"encoding/json"
+	"fmt"

+	"github.com/filecoin-project/go-address"
+	datatransfer "github.com/filecoin-project/go-data-transfer"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/specs-actors/actors/builtin/miner"
+	"github.com/ipfs/go-cid"
+
+	"github.com/libp2p/go-libp2p-core/peer"
+	pubsub "github.com/libp2p/go-libp2p-pubsub"
 	ma "github.com/multiformats/go-multiaddr"
 )

 // TODO: check if this exists anywhere else
+
 type MultiaddrSlice []ma.Multiaddr

 func (m *MultiaddrSlice) UnmarshalJSON(raw []byte) (err error) {
@@ -32,3 +43,111 @@ type ObjStat struct {
 	Size  uint64
 	Links uint64
 }
+
+type PubsubScore struct {
+	ID    peer.ID
+	Score *pubsub.PeerScoreSnapshot
+}
+
+type MinerInfo struct {
+	Owner                      address.Address   // Must be an ID-address.
+	Worker                     address.Address   // Must be an ID-address.
+	NewWorker                  address.Address   // Must be an ID-address.
+	ControlAddresses           []address.Address // Must be an ID-addresses.
+	WorkerChangeEpoch          abi.ChainEpoch
+	PeerId                     *peer.ID
+	Multiaddrs                 []abi.Multiaddrs
+	SealProofType              abi.RegisteredSealProof
+	SectorSize                 abi.SectorSize
+	WindowPoStPartitionSectors uint64
+}
+
+func NewApiMinerInfo(info *miner.MinerInfo) MinerInfo {
+	var pid *peer.ID
+	if peerID, err := peer.IDFromBytes(info.PeerId); err == nil {
+		pid = &peerID
+	}
+
+	mi := MinerInfo{
+		Owner:            info.Owner,
+		Worker:           info.Worker,
+		ControlAddresses: info.ControlAddresses,
+
+		NewWorker:         address.Undef,
+		WorkerChangeEpoch: -1,
+
+		PeerId:                     pid,
+		Multiaddrs:                 info.Multiaddrs,
+		SealProofType:              info.SealProofType,
+		SectorSize:                 info.SectorSize,
+		WindowPoStPartitionSectors: info.WindowPoStPartitionSectors,
+	}
+
+	if info.PendingWorkerKey != nil {
+		mi.NewWorker = info.PendingWorkerKey.NewWorker
+		mi.WorkerChangeEpoch = info.PendingWorkerKey.EffectiveAt
+	}
+
+	return mi
+}
+
+type MessageSendSpec struct {
+	MaxFee abi.TokenAmount
+}
+
+var DefaultMessageSendSpec = MessageSendSpec{
+	// MaxFee of 0.1FIL
+	MaxFee: abi.NewTokenAmount(int64(build.FilecoinPrecision) / 10),
+}
+
+func (ms *MessageSendSpec) Get() MessageSendSpec {
+	if ms == nil {
+		return DefaultMessageSendSpec
+	}
+
+	return *ms
+}
+
+type DataTransferChannel struct {
+	TransferID  datatransfer.TransferID
+	Status      datatransfer.Status
+	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
+}
@@ -4,7 +4,7 @@ import (
 	"context"

 	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/specs-actors/actors/crypto"
+	"github.com/filecoin-project/go-state-types/crypto"
 )

 type SignFunc = func(context.Context, []byte) (*crypto.Signature, error)
@@ -13,6 +13,10 @@ import (
 )

 func BuiltinBootstrap() ([]peer.AddrInfo, error) {
+	if DisableBuiltinAssets {
+		return nil, nil
+	}
+
 	var out []peer.AddrInfo

 	b := rice.MustFindBox("bootstrap")
@@ -1,12 +1,6 @@
-/dns4/bootstrap-0-sin.fil-test.net/tcp/1347/p2p/12D3KooWKNF7vNFEhnvB45E9mw2B5z6t419W3ziZPLdUDVnLLKGs
-/ip4/86.109.15.57/tcp/1347/p2p/12D3KooWKNF7vNFEhnvB45E9mw2B5z6t419W3ziZPLdUDVnLLKGs
-/dns4/bootstrap-0-dfw.fil-test.net/tcp/1347/p2p/12D3KooWECJTm7RUPyGfNbRwm6y2fK4wA7EB8rDJtWsq5AKi7iDr
-/ip4/139.178.84.45/tcp/1347/p2p/12D3KooWECJTm7RUPyGfNbRwm6y2fK4wA7EB8rDJtWsq5AKi7iDr
-/dns4/bootstrap-0-fra.fil-test.net/tcp/1347/p2p/12D3KooWC7MD6m7iNCuDsYtNr7xVtazihyVUizBbhmhEiyMAm9ym
-/ip4/136.144.49.17/tcp/1347/p2p/12D3KooWC7MD6m7iNCuDsYtNr7xVtazihyVUizBbhmhEiyMAm9ym
-/dns4/bootstrap-1-sin.fil-test.net/tcp/1347/p2p/12D3KooWD8eYqsKcEMFax6EbWN3rjA7qFsxCez2rmN8dWqkzgNaN
-/ip4/86.109.15.55/tcp/1347/p2p/12D3KooWD8eYqsKcEMFax6EbWN3rjA7qFsxCez2rmN8dWqkzgNaN
-/dns4/bootstrap-1-dfw.fil-test.net/tcp/1347/p2p/12D3KooWLB3RR8frLAmaK4ntHC2dwrAjyGzQgyUzWxAum1FxyyqD
-/ip4/139.178.84.41/tcp/1347/p2p/12D3KooWLB3RR8frLAmaK4ntHC2dwrAjyGzQgyUzWxAum1FxyyqD
-/dns4/bootstrap-1-fra.fil-test.net/tcp/1347/p2p/12D3KooWGPDJAw3HW4uVU3JEQBfFaZ1kdpg4HvvwRMVpUYbzhsLQ
-/ip4/136.144.49.131/tcp/1347/p2p/12D3KooWGPDJAw3HW4uVU3JEQBfFaZ1kdpg4HvvwRMVpUYbzhsLQ
+/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
@@ -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()
@@ -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"}`,
+	},
+}
@@ -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
@@ -2,6 +2,6 @@ package build

 import rice "github.com/GeertJohan/go.rice"

-func ParametersJson() []byte {
+func ParametersJSON() []byte {
 	return rice.MustFindBox("proof-params").MustBytes("parameters.json")
 }
@@ -3,25 +3,35 @@
 package build

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

-func init() {
-	power.ConsensusMinerMinPower = big.NewInt(2048)
-	miner.SupportedProofTypes = map[abi.RegisteredProof]struct{}{
-		abi.RegisteredProof_StackedDRG2KiBSeal: {},
-	}
-	verifreg.MinVerifiedDealSize = big.NewInt(256)
+const UpgradeBreezeHeight = -1
+const BreezeGasTampingDuration = 0
+
+const UpgradeSmokeHeight = -1
+
+var DrandSchedule = map[abi.ChainEpoch]DrandEnum{
+	0: DrandMainnet,
 }

-// Seconds
-const BlockDelay = 2
+func init() {
+	power.ConsensusMinerMinPower = big.NewInt(2048)
+	miner.SupportedProofTypes = map[abi.RegisteredSealProof]struct{}{
+		abi.RegisteredSealProof_StackedDrg2KiBV1: {},
+	}
+	verifreg.MinVerifiedDealSize = big.NewInt(256)

-const PropagationDelay = 3
+	BuildType |= Build2k
+}
+
+const BlockDelaySecs = uint64(4)
+
+const PropagationDelaySecs = uint64(1)

 // SlashablePowerDelay is the number of epochs after ElectionPeriodStart, after
 // which the miner is slashed
@@ -4,6 +4,7 @@ package build

 func init() {
 	InsecurePoStValidation = true
+	BuildType |= BuildDebug
 }

 // NOTE: Also includes settings from params_2k
@@ -1,124 +0,0 @@
-package build
-
-import (
-	"math/big"
-	"sort"
-
-	"github.com/libp2p/go-libp2p-core/protocol"
-
-	"github.com/filecoin-project/specs-actors/actors/abi"
-	"github.com/filecoin-project/specs-actors/actors/builtin"
-	"github.com/filecoin-project/specs-actors/actors/builtin/miner"
-
-	"github.com/filecoin-project/lotus/node/modules/dtypes"
-)
-
-func DefaultSectorSize() abi.SectorSize {
-	szs := make([]abi.SectorSize, 0, len(miner.SupportedProofTypes))
-	for spt := range miner.SupportedProofTypes {
-		ss, err := spt.SectorSize()
-		if err != nil {
-			panic(err)
-		}
-
-		szs = append(szs, ss)
-	}
-
-	sort.Slice(szs, func(i, j int) bool {
-		return szs[i] < szs[j]
-	})
-
-	return szs[0]
-}
-
-// Core network constants
-
-func BlocksTopic(netName dtypes.NetworkName) string   { return "/fil/blocks/" + string(netName) }
-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))
-}
-
-// /////
-// Storage
-
-const UnixfsChunkSize uint64 = 1 << 20
-const UnixfsLinksPerLevel = 1024
-
-// /////
-// Consensus / Network
-
-// Seconds
-const AllowableClockDrift = 1
-
-// Epochs
-const ForkLengthThreshold = Finality
-
-// Blocks (e)
-var BlocksPerEpoch = uint64(builtin.ExpectedLeadersPerEpoch)
-
-// Epochs
-const Finality = miner.ChainFinalityish
-
-// 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 // 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 = 1
-
-const WinningPoStSectorSetLookback = 10
-
-// /////
-// Devnet settings
-
-const TotalFilecoin = 2_000_000_000
-const MiningRewardTotal = 1_400_000_000
-
-const FilecoinPrecision = 1_000_000_000_000_000_000
-
-var InitialRewardBalance *big.Int
-
-// TODO: Move other important consts here
-
-func init() {
-	InitialRewardBalance = big.NewInt(MiningRewardTotal)
-	InitialRewardBalance = InitialRewardBalance.Mul(InitialRewardBalance, big.NewInt(FilecoinPrecision))
-}
-
-// 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
-
-// ///////
-// Limits
-
-// TODO: If this is gonna stay, it should move to specs-actors
-const BlockMessageLimit = 512
-const BlockGasLimit = 100_000_000
-
-var DrandCoeffs = []string{
-	"82c279cce744450e68de98ee08f9698a01dd38f8e3be3c53f2b840fb9d09ad62a0b6b87981e179e1b14bc9a2d284c985",
-	"82d51308ad346c686f81b8094551597d7b963295cbf313401a93df9baf52d5ae98a87745bee70839a4d6e65c342bd15b",
-	"94eebfd53f4ba6a3b8304236400a12e73885e5a781509a5c8d41d2e8b476923d8ea6052649b3c17282f596217f96c5de",
-	"8dc4231e42b4edf39e86ef1579401692480647918275da767d3e558c520d6375ad953530610fd27daf110187877a65d0",
-}
@@ -0,0 +1,46 @@
+package build
+
+import (
+	"sort"
+
+	"github.com/libp2p/go-libp2p-core/protocol"
+
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/specs-actors/actors/builtin/miner"
+
+	"github.com/filecoin-project/lotus/node/modules/dtypes"
+)
+
+func DefaultSectorSize() abi.SectorSize {
+	szs := make([]abi.SectorSize, 0, len(miner.SupportedProofTypes))
+	for spt := range miner.SupportedProofTypes {
+		ss, err := spt.SectorSize()
+		if err != nil {
+			panic(err)
+		}
+
+		szs = append(szs, ss)
+	}
+
+	sort.Slice(szs, func(i, j int) bool {
+		return szs[i] < szs[j]
+	})
+
+	return szs[0]
+}
+
+// Core network constants
+
+func BlocksTopic(netName dtypes.NetworkName) string   { return "/fil/blocks/" + string(netName) }
+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
+}
@@ -0,0 +1,106 @@
+// +build !testground
+
+package build
+
+import (
+	"math/big"
+
+	"github.com/filecoin-project/go-state-types/network"
+
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/specs-actors/actors/builtin"
+	"github.com/filecoin-project/specs-actors/actors/builtin/miner"
+)
+
+// /////
+// Storage
+
+const UnixfsChunkSize uint64 = 1 << 20
+const UnixfsLinksPerLevel = 1024
+
+// /////
+// Consensus / Network
+
+const AllowableClockDriftSecs = uint64(1)
+const NewestNetworkVersion = network.Version2
+
+// Epochs
+const ForkLengthThreshold = Finality
+
+// Blocks (e)
+var BlocksPerEpoch = uint64(builtin.ExpectedLeadersPerEpoch)
+
+// Epochs
+const Finality = miner.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)
+
+// /////
+// Devnet settings
+
+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)))
+}
+
+// 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)
@@ -0,0 +1,84 @@
+// +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"
+	"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            = miner.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
+
+	DrandSchedule = map[abi.ChainEpoch]DrandEnum{
+		0: DrandMainnet,
+	}
+
+	NewestNetworkVersion = network.Version2
+)
@@ -1,25 +1,35 @@
 // +build !debug
 // +build !2k
+// +build !testground

 package build

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

+var DrandSchedule = map[abi.ChainEpoch]DrandEnum{
+	0:                  DrandIncentinet,
+	UpgradeSmokeHeight: DrandMainnet,
+}
+
+const UpgradeBreezeHeight = 41280
+const BreezeGasTampingDuration = 120
+
+const UpgradeSmokeHeight = 51000
+
 func init() {
-	power.ConsensusMinerMinPower = big.NewInt(1024 << 30)
-	miner.SupportedProofTypes = map[abi.RegisteredProof]struct{}{
-		abi.RegisteredProof_StackedDRG32GiBSeal: {},
-		abi.RegisteredProof_StackedDRG64GiBSeal: {},
+	power.ConsensusMinerMinPower = big.NewInt(10 << 40)
+	miner.SupportedProofTypes = map[abi.RegisteredSealProof]struct{}{
+		abi.RegisteredSealProof_StackedDrg32GiBV1: {},
+		abi.RegisteredSealProof_StackedDrg64GiBV1: {},
 	}
 }

-// Seconds
-const BlockDelay = builtin.EpochDurationSeconds
+const BlockDelaySecs = uint64(builtin.EpochDurationSeconds)

-const PropagationDelay = 6
+const PropagationDelaySecs = uint64(6)
@@ -1,152 +1,152 @@
 {
-  "v26-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-0-0-0170db1f394b35d995252228ee359194b13199d259380541dc529fb0099096b0.params": {
-    "cid": "QmYkygifkXnrnsN4MJsjBFHTQJHx294CyikDgDK8nYxdGh",
-    "digest": "df3f30442a6d6b4192f5071fb17e820c",
+  "v28-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-0-0-0170db1f394b35d995252228ee359194b13199d259380541dc529fb0099096b0.params": {
+    "cid": "QmVxjFRyhmyQaZEtCh7nk2abc7LhFkzhnRX4rcHqCCpikR",
+    "digest": "7610b9f82bfc88405b7a832b651ce2f6",
    "sector_size": 2048
  },
-  "v26-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-0-0-0170db1f394b35d995252228ee359194b13199d259380541dc529fb0099096b0.vk": {
-    "cid": "QmdXyqbmy2bkJA9Kyhh6z25GrTCq48LwX6c1mxPsm54wi7",
-    "digest": "0bea3951abf9557a3569f68e52a30c6c",
+  "v28-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-0-0-0170db1f394b35d995252228ee359194b13199d259380541dc529fb0099096b0.vk": {
+    "cid": "QmcS5JZs8X3TdtkEBpHAdUYjdNDqcL7fWQFtQz69mpnu2X",
+    "digest": "0e0958009936b9d5e515ec97b8cb792d",
    "sector_size": 2048
  },
-  "v26-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-0-0-0cfb4f178bbb71cf2ecfcd42accce558b27199ab4fb59cb78f2483fe21ef36d9.params": {
-    "cid": "Qmf5XZZtP5VcYTf65MbKjLVabcS6cYMbr2rFShmfJzh5e5",
-    "digest": "655e6277638edc8c658094f6f0b33d54",
+  "v28-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-0-0-0cfb4f178bbb71cf2ecfcd42accce558b27199ab4fb59cb78f2483fe21ef36d9.params": {
+    "cid": "QmUiRx71uxfmUE8V3H9sWAsAXoM88KR4eo1ByvvcFNeTLR",
+    "digest": "1a7d4a9c8a502a497ed92a54366af33f",
    "sector_size": 536870912
  },
-  "v26-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-0-0-0cfb4f178bbb71cf2ecfcd42accce558b27199ab4fb59cb78f2483fe21ef36d9.vk": {
-    "cid": "QmPuhdWnAXBks43emnkqi9FQzyU1gASKyz23zrD27BPGs8",
-    "digest": "57690e3a6a94c3f704802a674b34f36b",
+  "v28-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-0-0-0cfb4f178bbb71cf2ecfcd42accce558b27199ab4fb59cb78f2483fe21ef36d9.vk": {
+    "cid": "QmfCeddjFpWtavzfEzZpJfzSajGNwfL4RjFXWAvA9TSnTV",
+    "digest": "4dae975de4f011f101f5a2f86d1daaba",
    "sector_size": 536870912
  },
-  "v26-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-0-0-3ea05428c9d11689f23529cde32fd30aabd50f7d2c93657c1d3650bca3e8ea9e.params": {
-    "cid": "QmPNVgTN7N5vDtD5u7ERMTLcvUtrKRBfYVUDr6uW3pKhX7",
-    "digest": "3d390654f58e603b896ac70c653f5676",
+  "v28-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-0-0-3ea05428c9d11689f23529cde32fd30aabd50f7d2c93657c1d3650bca3e8ea9e.params": {
+    "cid": "QmcSTqDcFVLGGVYz1njhUZ7B6fkKtBumsLUwx4nkh22TzS",
+    "digest": "82c88066be968bb550a05e30ff6c2413",
    "sector_size": 2048
  },
-  "v26-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-0-0-3ea05428c9d11689f23529cde32fd30aabd50f7d2c93657c1d3650bca3e8ea9e.vk": {
-    "cid": "Qmbj61Zez7v5xA7nSCnmWbyLYznWJDWeusz7Yg8EcgVdoN",
-    "digest": "8c170a164743c39576a7f47a1b51e6f3",
+  "v28-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-0-0-3ea05428c9d11689f23529cde32fd30aabd50f7d2c93657c1d3650bca3e8ea9e.vk": {
+    "cid": "QmSTCXF2ipGA3f6muVo6kHc2URSx6PzZxGUqu7uykaH5KU",
+    "digest": "ffd79788d614d27919ae5bd2d94eacb6",
    "sector_size": 2048
  },
-  "v26-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-0-0-50c7368dea9593ed0989e70974d28024efa9d156d585b7eea1be22b2e753f331.params": {
-    "cid": "QmRApb8RZoBK3cqicT7V3ydXg8yVvqPFMPrQNXP33aBihp",
-    "digest": "b1b58ff9a297b82885e8a7dfb035f83c",
+  "v28-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-0-0-50c7368dea9593ed0989e70974d28024efa9d156d585b7eea1be22b2e753f331.params": {
+    "cid": "QmU9SBzJNrcjRFDiFc4GcApqdApN6z9X7MpUr66mJ2kAJP",
+    "digest": "700171ecf7334e3199437c930676af82",
    "sector_size": 8388608
  },
-  "v26-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-0-0-50c7368dea9593ed0989e70974d28024efa9d156d585b7eea1be22b2e753f331.vk": {
-    "cid": "QmcytF1dTdqMFoyXi931j1RgmGtLfR9LLLaBznRt1tPQyD",
-    "digest": "1a09e00c641f192f55af3433a028f050",
+  "v28-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-0-0-50c7368dea9593ed0989e70974d28024efa9d156d585b7eea1be22b2e753f331.vk": {
+    "cid": "QmbmUMa3TbbW3X5kFhExs6WgC4KeWT18YivaVmXDkB6ANG",
+    "digest": "79ebb55f56fda427743e35053edad8fc",
    "sector_size": 8388608
  },
-  "v26-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-0-0-5294475db5237a2e83c3e52fd6c2b03859a1831d45ed08c4f35dbf9a803165a9.params": {
-    "cid": "QmPvr54tWaVeP4WnekivzUAJitTqsQfvikBvAHNEaDNQSw",
-    "digest": "9380e41368ed4083dbc922b290d3b786",
+  "v28-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-0-0-5294475db5237a2e83c3e52fd6c2b03859a1831d45ed08c4f35dbf9a803165a9.params": {
+    "cid": "QmdNEL2RtqL52GQNuj8uz6mVj5Z34NVnbaJ1yMyh1oXtBx",
+    "digest": "c49499bb76a0762884896f9683403f55",
    "sector_size": 8388608
  },
-  "v26-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-0-0-5294475db5237a2e83c3e52fd6c2b03859a1831d45ed08c4f35dbf9a803165a9.vk": {
-    "cid": "QmXyVLVDRCcxA9SjT7PeK8HFtyxZ2ZH3SHa8KoGLw8VGJt",
-    "digest": "f0731a7e20f90704bd38fc5d27882f6d",
+  "v28-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-0-0-5294475db5237a2e83c3e52fd6c2b03859a1831d45ed08c4f35dbf9a803165a9.vk": {
+    "cid": "QmUiVYCQUgr6Y13pZFr8acWpSM4xvTXUdcvGmxyuHbKhsc",
+    "digest": "34d4feeacd9abf788d69ef1bb4d8fd00",
    "sector_size": 8388608
  },
-  "v26-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-0-0-7d739b8cf60f1b0709eeebee7730e297683552e4b69cab6984ec0285663c5781.params": {
-    "cid": "Qmf5f6ko3dqj7qauzXpZqxM9B2x2sL977K6gE2ppNwuJPv",
-    "digest": "273ebb8c896326b7c292bee8b775fd38",
+  "v28-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-0-0-7d739b8cf60f1b0709eeebee7730e297683552e4b69cab6984ec0285663c5781.params": {
+    "cid": "QmVgCsJFRXKLuuUhT3aMYwKVGNA9rDeR6DCrs7cAe8riBT",
+    "digest": "827359440349fe8f5a016e7598993b79",
    "sector_size": 536870912
  },
-  "v26-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-0-0-7d739b8cf60f1b0709eeebee7730e297683552e4b69cab6984ec0285663c5781.vk": {
-    "cid": "QmfP3MQe8koW63n5MkDENENVHxib78MJYYyZvbneCsuze8",
-    "digest": "3dd94da9da64e51b3445bc528d84e76d",
+  "v28-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-0-0-7d739b8cf60f1b0709eeebee7730e297683552e4b69cab6984ec0285663c5781.vk": {
+    "cid": "QmfA31fbCWojSmhSGvvfxmxaYCpMoXP95zEQ9sLvBGHNaN",
+    "digest": "bd2cd62f65c1ab84f19ca27e97b7c731",
    "sector_size": 536870912
  },
-  "v26-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-8-0-0377ded656c6f524f1618760bffe4e0a1c51d5a70c4509eedae8a27555733edc.params": {
-    "cid": "QmYEeeCE8uT2bsVkxcqqUYeMmMEbe6rfmo8wQCv7jFHqqm",
-    "digest": "c947f2021304ed43b7216f7a8436e294",
+  "v28-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-8-0-0377ded656c6f524f1618760bffe4e0a1c51d5a70c4509eedae8a27555733edc.params": {
+    "cid": "QmaUmfcJt6pozn8ndq1JVBzLRjRJdHMTPd4foa8iw5sjBZ",
+    "digest": "2cf49eb26f1fee94c85781a390ddb4c8",
    "sector_size": 34359738368
  },
-  "v26-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-8-0-0377ded656c6f524f1618760bffe4e0a1c51d5a70c4509eedae8a27555733edc.vk": {
-    "cid": "QmXB63ExriFjB4ywWnXTnFwCcLFfCeEP3h15qtL5i7F4aX",
-    "digest": "ab20d7b253e7e9a0d2ccdf7599ec8ec3",
+  "v28-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-8-0-0377ded656c6f524f1618760bffe4e0a1c51d5a70c4509eedae8a27555733edc.vk": {
+    "cid": "QmR9i9KL3vhhAqTBGj1bPPC7LvkptxrH9RvxJxLN1vvsBE",
+    "digest": "0f8ec542485568fa3468c066e9fed82b",
    "sector_size": 34359738368
  },
-  "v26-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-8-0-559e581f022bb4e4ec6e719e563bf0e026ad6de42e56c18714a2c692b1b88d7e.params": {
-    "cid": "QmW5Yxg3L1NSzuQVcRMHMbG3uvVoi4dTLzVaDpnEUPQpnA",
-    "digest": "079ba19645828ae42b22b0e3f4866e8d",
+  "v28-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-8-0-559e581f022bb4e4ec6e719e563bf0e026ad6de42e56c18714a2c692b1b88d7e.params": {
+    "cid": "Qmdtczp7p4wrbDofmHdGhiixn9irAcN77mV9AEHZBaTt1i",
+    "digest": "d84f79a16fe40e9e25a36e2107bb1ba0",
    "sector_size": 34359738368
  },
-  "v26-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-8-0-559e581f022bb4e4ec6e719e563bf0e026ad6de42e56c18714a2c692b1b88d7e.vk": {
-    "cid": "QmQzZ5dJ11tcSBees38WX41tZLXS9BqpEti253m5QcnTNs",
-    "digest": "c76125a50a7de315165de359b5174ae4",
+  "v28-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-8-0-559e581f022bb4e4ec6e719e563bf0e026ad6de42e56c18714a2c692b1b88d7e.vk": {
+    "cid": "QmZCvxKcKP97vDAk8Nxs9R1fWtqpjQrAhhfXPoCi1nkDoF",
+    "digest": "fc02943678dd119e69e7fab8420e8819",
    "sector_size": 34359738368
  },
-  "v26-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-8-2-2627e4006b67f99cef990c0a47d5426cb7ab0a0ad58fc1061547bf2d28b09def.params": {
-    "cid": "QmNk3wga1tS53FUu1QnkK8ehWA2cqpCnSEAPv3KLxdJxNa",
-    "digest": "421e4790c0b80e0107a7ff67acf14084",
+  "v28-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-8-2-2627e4006b67f99cef990c0a47d5426cb7ab0a0ad58fc1061547bf2d28b09def.params": {
+    "cid": "QmeAN4vuANhXsF8xP2Lx5j2L6yMSdogLzpcvqCJThRGK1V",
+    "digest": "3810b7780ac0e299b22ae70f1f94c9bc",
    "sector_size": 68719476736
  },
-  "v26-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-8-2-2627e4006b67f99cef990c0a47d5426cb7ab0a0ad58fc1061547bf2d28b09def.vk": {
-    "cid": "QmVQCHGsrUtbn9RjHs1e6GXfeXDW5m9w4ge48PSX3Z2as2",
-    "digest": "8b60e9cc1470a6729c687d6cf0a1f79c",
+  "v28-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-8-2-2627e4006b67f99cef990c0a47d5426cb7ab0a0ad58fc1061547bf2d28b09def.vk": {
+    "cid": "QmWV8rqZLxs1oQN9jxNWmnT1YdgLwCcscv94VARrhHf1T7",
+    "digest": "59d2bf1857adc59a4f08fcf2afaa916b",
    "sector_size": 68719476736
  },
-  "v26-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-8-2-b62098629d07946e9028127e70295ed996fe3ed25b0f9f88eb610a0ab4385a3c.params": {
-    "cid": "QmTL3VvydaMFWKvE5VzxjgKsJYgL9JMM4JVYNtQxdj9JK1",
-    "digest": "2685f31124b22ea6b2857e5a5e87ffa3",
+  "v28-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-8-2-b62098629d07946e9028127e70295ed996fe3ed25b0f9f88eb610a0ab4385a3c.params": {
+    "cid": "QmVkrXc1SLcpgcudK5J25HH93QvR9tNsVhVTYHm5UymXAz",
+    "digest": "2170a91ad5bae22ea61f2ea766630322",
    "sector_size": 68719476736
  },
-  "v26-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-8-2-b62098629d07946e9028127e70295ed996fe3ed25b0f9f88eb610a0ab4385a3c.vk": {
-    "cid": "QmSVWbLqQYbUbbJyfsRMzEib2rfSqMtnPks1Nw22omcBQm",
-    "digest": "efe703cd2839597c7ca5c2a906b74296",
+  "v28-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-8-2-b62098629d07946e9028127e70295ed996fe3ed25b0f9f88eb610a0ab4385a3c.vk": {
+    "cid": "QmbfQjPD7EpzjhWGmvWAsyN2mAZ4PcYhsf3ujuhU9CSuBm",
+    "digest": "6d3789148fb6466d07ee1e24d6292fd6",
    "sector_size": 68719476736
  },
-  "v26-stacked-proof-of-replication-merkletree-poseidon_hasher-8-0-0-sha256_hasher-032d3138d22506ec0082ed72b2dcba18df18477904e35bafee82b3793b06832f.params": {
-    "cid": "QmU9dH31nZZUJnsogR4Ld4ySUcH6wm2RgmGiujwnqtbU6k",
-    "digest": "fcef8e87ae2afd7a28aae44347b804cf",
+  "v28-stacked-proof-of-replication-merkletree-poseidon_hasher-8-0-0-sha256_hasher-032d3138d22506ec0082ed72b2dcba18df18477904e35bafee82b3793b06832f.params": {
+    "cid": "QmWceMgnWYLopMuM4AoGMvGEau7tNe5UK83XFjH5V9B17h",
+    "digest": "434fb1338ecfaf0f59256f30dde4968f",
    "sector_size": 2048
  },
-  "v26-stacked-proof-of-replication-merkletree-poseidon_hasher-8-0-0-sha256_hasher-032d3138d22506ec0082ed72b2dcba18df18477904e35bafee82b3793b06832f.vk": {
-    "cid": "QmdJ15DMGPooye5NaPcRfXUdHUDibcN7hKjbmTGuu1K4AQ",
-    "digest": "2ee2b3518229680db15161d4f582af37",
+  "v28-stacked-proof-of-replication-merkletree-poseidon_hasher-8-0-0-sha256_hasher-032d3138d22506ec0082ed72b2dcba18df18477904e35bafee82b3793b06832f.vk": {
+    "cid": "QmamahpFCstMUqHi2qGtVoDnRrsXhid86qsfvoyCTKJqHr",
+    "digest": "dc1ade9929ade1708238f155343044ac",
    "sector_size": 2048
  },
-  "v26-stacked-proof-of-replication-merkletree-poseidon_hasher-8-0-0-sha256_hasher-6babf46ce344ae495d558e7770a585b2382d54f225af8ed0397b8be7c3fcd472.params": {
-    "cid": "QmZgtxcY3tMXXQxZTA7ZTUDXLVUnfxNcerXgeW4gG2NnfP",
-    "digest": "3273c7135cb75684248b475781b738ee",
+  "v28-stacked-proof-of-replication-merkletree-poseidon_hasher-8-0-0-sha256_hasher-6babf46ce344ae495d558e7770a585b2382d54f225af8ed0397b8be7c3fcd472.params": {
+    "cid": "QmYBpTt7LWNAWr1JXThV5VxX7wsQFLd1PHrGYVbrU1EZjC",
+    "digest": "6c77597eb91ab936c1cef4cf19eba1b3",
    "sector_size": 536870912
  },
-  "v26-stacked-proof-of-replication-merkletree-poseidon_hasher-8-0-0-sha256_hasher-6babf46ce344ae495d558e7770a585b2382d54f225af8ed0397b8be7c3fcd472.vk": {
-    "cid": "QmSS6ZkAV2aGZcgKgdPpEEgihXF1ryZX8PSAZDWSoeL1d4",
-    "digest": "1519b5f61d9044a59f2bdc57537c094b",
+  "v28-stacked-proof-of-replication-merkletree-poseidon_hasher-8-0-0-sha256_hasher-6babf46ce344ae495d558e7770a585b2382d54f225af8ed0397b8be7c3fcd472.vk": {
+    "cid": "QmWionkqH2B6TXivzBSQeSyBxojaiAFbzhjtwYRrfwd8nH",
+    "digest": "065179da19fbe515507267677f02823e",
    "sector_size": 536870912
  },
-  "v26-stacked-proof-of-replication-merkletree-poseidon_hasher-8-0-0-sha256_hasher-ecd683648512ab1765faa2a5f14bab48f676e633467f0aa8aad4b55dcb0652bb.params": {
-    "cid": "QmQBGXeiNn6hVwbR6qFarQqiNGDdKk4h9ucfyvcXyfYz2N",
-    "digest": "7d5f896f435c38e93bcda6dd168d860b",
+  "v28-stacked-proof-of-replication-merkletree-poseidon_hasher-8-0-0-sha256_hasher-ecd683648512ab1765faa2a5f14bab48f676e633467f0aa8aad4b55dcb0652bb.params": {
+    "cid": "QmPXAPPuQtuQz7Zz3MHMAMEtsYwqM1o9H1csPLeiMUQwZH",
+    "digest": "09e612e4eeb7a0eb95679a88404f960c",
    "sector_size": 8388608
  },
-  "v26-stacked-proof-of-replication-merkletree-poseidon_hasher-8-0-0-sha256_hasher-ecd683648512ab1765faa2a5f14bab48f676e633467f0aa8aad4b55dcb0652bb.vk": {
-    "cid": "QmPrZgBVGMckEAeu5eSJnLmiAwcPQjKjZe5ir6VaQ5AxKs",
-    "digest": "fe6d2de44580a0db5a4934688899b92f",
+  "v28-stacked-proof-of-replication-merkletree-poseidon_hasher-8-0-0-sha256_hasher-ecd683648512ab1765faa2a5f14bab48f676e633467f0aa8aad4b55dcb0652bb.vk": {
+    "cid": "QmYCuipFyvVW1GojdMrjK1JnMobXtT4zRCZs1CGxjizs99",
+    "digest": "b687beb9adbd9dabe265a7e3620813e4",
    "sector_size": 8388608
  },
-  "v26-stacked-proof-of-replication-merkletree-poseidon_hasher-8-8-0-sha256_hasher-82a357d2f2ca81dc61bb45f4a762807aedee1b0a53fd6c4e77b46a01bfef7820.params": {
-    "cid": "QmZL2cq45XJn5BFzagAZwgFmLrcM1W6CXoiEF9C5j5tjEF",
-    "digest": "acdfed9f0512bc85a01a9fb871d475d5",
+  "v28-stacked-proof-of-replication-merkletree-poseidon_hasher-8-8-0-sha256_hasher-82a357d2f2ca81dc61bb45f4a762807aedee1b0a53fd6c4e77b46a01bfef7820.params": {
+    "cid": "QmengpM684XLQfG8754ToonszgEg2bQeAGUan5uXTHUQzJ",
+    "digest": "6a388072a518cf46ebd661f5cc46900a",
    "sector_size": 34359738368
  },
-  "v26-stacked-proof-of-replication-merkletree-poseidon_hasher-8-8-0-sha256_hasher-82a357d2f2ca81dc61bb45f4a762807aedee1b0a53fd6c4e77b46a01bfef7820.vk": {
-    "cid": "QmQ4zB7nNa1tDYNifBkExRnZtwtxZw775iaqvVsZyRi6Q2",
-    "digest": "524a2f3e9d6826593caebc41bb545c40",
+  "v28-stacked-proof-of-replication-merkletree-poseidon_hasher-8-8-0-sha256_hasher-82a357d2f2ca81dc61bb45f4a762807aedee1b0a53fd6c4e77b46a01bfef7820.vk": {
+    "cid": "Qmf93EMrADXAK6CyiSfE8xx45fkMfR3uzKEPCvZC1n2kzb",
+    "digest": "0c7b4aac1c40fdb7eb82bc355b41addf",
    "sector_size": 34359738368
  },
-  "v26-stacked-proof-of-replication-merkletree-poseidon_hasher-8-8-2-sha256_hasher-96f1b4a04c5c51e4759bbf224bbc2ef5a42c7100f16ec0637123f16a845ddfb2.params": {
-    "cid": "QmY7DitNKXFeLQt9QoVQkfjM1EvRnprqUVxjmkTXkHDNka",
-    "digest": "f27271c0537ba65ade2ec045f8fbd069",
+  "v28-stacked-proof-of-replication-merkletree-poseidon_hasher-8-8-2-sha256_hasher-96f1b4a04c5c51e4759bbf224bbc2ef5a42c7100f16ec0637123f16a845ddfb2.params": {
+    "cid": "QmS7ye6Ri2MfFzCkcUJ7FQ6zxDKuJ6J6B8k5PN7wzSR9sX",
+    "digest": "1801f8a6e1b00bceb00cc27314bb5ce3",
    "sector_size": 68719476736
  },
-  "v26-stacked-proof-of-replication-merkletree-poseidon_hasher-8-8-2-sha256_hasher-96f1b4a04c5c51e4759bbf224bbc2ef5a42c7100f16ec0637123f16a845ddfb2.vk": {
-    "cid": "QmUJsvoCuQ4LszPmeRVAkMYb5qY95ctz3UXKhu8xLzyFKo",
-    "digest": "576b292938c6c9d0a0e721bd867a543b",
+  "v28-stacked-proof-of-replication-merkletree-poseidon_hasher-8-8-2-sha256_hasher-96f1b4a04c5c51e4759bbf224bbc2ef5a42c7100f16ec0637123f16a845ddfb2.vk": {
+    "cid": "QmehSmC6BhrgRZakPDta2ewoH9nosNzdjCqQRXsNFNUkLN",
+    "digest": "a89884252c04c298d0b3c81bfd884164",
    "sector_size": 68719476736
  }
-}
+}
@@ -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.3.0"
+const BuildVersion = "0.7.1"

-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, 3, 0)
+type NodeType int

+const (
+	NodeUnknown NodeType = iota
+
+	NodeFull
+	NodeMiner
+	NodeWorker
+)
+
+var RunningNodeType NodeType
+
+func VersionForType(nodeType NodeType) (Version, error) {
+	switch nodeType {
+	case NodeFull:
+		return FullAPIVersion, nil
+	case NodeMiner:
+		return MinerAPIVersion, nil
+	case NodeWorker:
+		return WorkerAPIVersion, nil
+	default:
+		return Version(0), xerrors.Errorf("unknown node type %d", nodeType)
+	}
+}
+
+// semver versions of the rpc api exposed
+var (
+	FullAPIVersion   = newVer(0, 15, 0)
+	MinerAPIVersion  = newVer(0, 14, 0)
+	WorkerAPIVersion = newVer(0, 14, 0)
+)
+
+//nolint:varcheck,deadcode
 const (
 	majorMask = 0xff0000
 	minorMask = 0xffff00
@@ -3,7 +3,7 @@ package aerrors
 import (
 	"fmt"

-	"github.com/filecoin-project/specs-actors/actors/runtime/exitcode"
+	"github.com/filecoin-project/go-state-types/exitcode"
 	"golang.org/x/xerrors"
 )

@@ -3,8 +3,8 @@ package aerrors_test
 import (
 	"testing"

+	"github.com/filecoin-project/go-state-types/exitcode"
 	. "github.com/filecoin-project/lotus/chain/actors/aerrors"
-	"github.com/filecoin-project/specs-actors/actors/runtime/exitcode"

 	"github.com/stretchr/testify/assert"
 	"golang.org/x/xerrors"
@@ -4,7 +4,7 @@ import (
 	"errors"
 	"fmt"

-	"github.com/filecoin-project/specs-actors/actors/runtime/exitcode"
+	"github.com/filecoin-project/go-state-types/exitcode"
 	cbor "github.com/ipfs/go-ipld-cbor"
 	"golang.org/x/xerrors"
 )
@@ -50,6 +50,7 @@ func Newf(retCode exitcode.ExitCode, format string, args ...interface{}) ActorEr
 }

 // todo: bit hacky
+
 func NewfSkip(skip int, retCode exitcode.ExitCode, format string, args ...interface{}) ActorError {
 	if retCode == 0 {
 		return &actorError{
@@ -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,15 +52,19 @@ func NewBadBlockCache() *BadBlockCache {
 	}
 }

-func (bts *BadBlockCache) Add(c cid.Cid, reason string) {
-	bts.badBlocks.Add(c, reason)
+func (bts *BadBlockCache) Add(c cid.Cid, bbr BadBlockReason) {
+	bts.badBlocks.Add(c, bbr)
 }

-func (bts *BadBlockCache) Has(c cid.Cid) (string, bool) {
+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 "", false
+		return BadBlockReason{}, false
 	}

-	return rval.(string), true
+	return rval.(BadBlockReason), true
 }
@@ -2,12 +2,13 @@ package beacon

 import (
 	"context"
-	"time"

-	"github.com/filecoin-project/lotus/chain/types"
-	"github.com/filecoin-project/specs-actors/actors/abi"
+	"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")
@@ -17,14 +18,54 @@ type Response struct {
 	Err   error
 }

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

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

-func BeaconEntriesForBlock(ctx context.Context, beacon RandomBeacon, round abi.ChainEpoch, prev types.BeaconEntry) ([]types.BeaconEntry, error) {
-	start := time.Now()
+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
+		}
+	}

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

-	log.Debugw("fetching beacon entries", "took", time.Since(start), "numEntries", len(out))
+	log.Debugw("fetching beacon entries", "took", build.Clock.Since(start), "numEntries", len(out))
 	reverse(out)
 	return out, nil
 }
@@ -1,48 +1,34 @@
 package drand

 import (
+	"bytes"
 	"context"
-	"math/rand"
 	"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/specs-actors/actors/abi"
-	"golang.org/x/xerrors"
-
-	logging "github.com/ipfs/go-log"
-
-	dbeacon "github.com/drand/drand/beacon"
-	"github.com/drand/drand/core"
-	dkey "github.com/drand/drand/key"
-	dnet "github.com/drand/drand/net"
-	dproto "github.com/drand/drand/protobuf/drand"
+	"github.com/filecoin-project/lotus/node/modules/dtypes"
 )

 var log = logging.Logger("drand")

-var drandServers = []string{
-	"nicolas.drand.fil-test.net:443",
-	"philipp.drand.fil-test.net:443",
-	"mathilde.drand.fil-test.net:443",
-	"ludovic.drand.fil-test.net:443",
-	"gabbi.drand.fil-test.net:443",
-	"linus.drand.fil-test.net:443",
-	"jeff.drand.fil-test.net:443",
-}
-
-var drandPubKey *dkey.DistPublic
-
-func init() {
-	drandPubKey = new(dkey.DistPublic)
-	err := drandPubKey.FromTOML(&dkey.DistPublicTOML{Coefficients: build.DrandCoeffs})
-	if err != nil {
-		panic(err)
-	}
-}
-
 type drandPeer struct {
 	addr string
 	tls  bool
@@ -56,14 +42,17 @@ 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 dnet.Client
+	client dclient.Client

-	peers         []dnet.Peer
-	peersIndex    int
-	peersIndexMtx sync.Mutex
-
-	pubkey *dkey.DistPublic
+	pubkey kyber.Point

 	// seconds
 	interval time.Duration
@@ -76,120 +65,91 @@ type DrandBeacon struct {
 	localCache map[uint64]types.BeaconEntry
 }

-func NewDrandBeacon(genesisTs, interval uint64) (*DrandBeacon, error) {
+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:     dnet.NewGrpcClient(),
+		client:     client,
 		localCache: make(map[uint64]types.BeaconEntry),
 	}
-	for _, ds := range drandServers {
-		db.peers = append(db.peers, &drandPeer{addr: ds, tls: true})
-	}

-	db.peersIndex = rand.Intn(len(db.peers))
-
-	groupResp, err := db.client.Group(context.TODO(), db.peers[db.peersIndex], &dproto.GroupRequest{})
-	if err != nil {
-		return nil, xerrors.Errorf("failed to get group response from beacon peer: %w", err)
-	}
-
-	kgroup, err := core.ProtoToGroup(groupResp)
-	if err != nil {
-		return nil, xerrors.Errorf("failed to parse group response: %w", err)
-	}
-
-	// TODO: verify these values are what we expect them to be
-	if !kgroup.PublicKey.Equal(drandPubKey) {
-		return nil, xerrors.Errorf("public key does not match")
-	}
-	// fmt.Printf("Drand Pubkey:\n%#v\n", kgroup.PublicKey.TOML()) // use to print public key
-	db.pubkey = drandPubKey
-	db.interval = kgroup.Period
-	db.drandGenTime = uint64(kgroup.GenesisTime)
+	db.pubkey = drandChain.PublicKey
+	db.interval = drandChain.Period
+	db.drandGenTime = uint64(drandChain.GenesisTime)
 	db.filRoundTime = interval
 	db.filGenTime = genesisTs

-	// TODO: the stream currently gives you back *all* values since drand genesis.
-	// Having the stream in the background is merely an optimization, so not a big deal to disable it for now
-	// go db.handleStreamingUpdates()
-
 	return db, nil
 }

-func (db *DrandBeacon) rotatePeersIndex() {
-	db.peersIndexMtx.Lock()
-	nval := rand.Intn(len(db.peers))
-	db.peersIndex = nval
-	db.peersIndexMtx.Unlock()
-
-	log.Warnf("rotated to drand peer %d, %q", nval, db.peers[nval].Address())
-}
-
-func (db *DrandBeacon) getPeerIndex() int {
-	db.peersIndexMtx.Lock()
-	defer db.peersIndexMtx.Unlock()
-	return db.peersIndex
-}
-
-func (db *DrandBeacon) handleStreamingUpdates() {
-	for {
-		p := db.peers[db.getPeerIndex()]
-		ch, err := db.client.PublicRandStream(context.Background(), p, &dproto.PublicRandRequest{})
-		if err != nil {
-			log.Warnf("failed to get public rand stream to peer %q: %s", p.Address(), err)
-			log.Warnf("trying again in 10 seconds")
-			db.rotatePeersIndex()
-			time.Sleep(time.Second * 10)
-			continue
-		}
-
-		for e := range ch {
-			db.cacheValue(types.BeaconEntry{
-				Round: e.Round,
-				Data:  e.Signature,
-			})
-		}
-
-		log.Warnf("drand beacon stream to peer %q broke, reconnecting in 10 seconds", p.Address())
-		db.rotatePeersIndex()
-		time.Sleep(time.Second * 10)
-	}
-}
-
 func (db *DrandBeacon) Entry(ctx context.Context, round uint64) <-chan beacon.Response {
-	// check cache, it it if there, otherwise query the endpoint
-	cres := db.getCachedValue(round)
-	if cres != nil {
-		out := make(chan beacon.Response, 1)
-		out <- beacon.Response{Entry: *cres}
-		close(out)
-		return out
-	}
-
 	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() {
-		p := db.peers[db.getPeerIndex()]
-		resp, err := db.client.PublicRand(ctx, p, &dproto.PublicRandRequest{Round: round})
+		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 {
-			db.rotatePeersIndex()
-			br.Err = xerrors.Errorf("drand peer %q failed publicRand request: %w", p.Address(), err)
+			br.Err = xerrors.Errorf("drand failed Get request: %w", err)
 		} else {
-			br.Entry.Round = resp.GetRound()
-			br.Entry.Data = resp.GetSignature()
+			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()
@@ -211,20 +171,23 @@ func (db *DrandBeacon) VerifyEntry(curr types.BeaconEntry, prev types.BeaconEntr
 		// TODO handle genesis better
 		return nil
 	}
-	b := &dbeacon.Beacon{
+	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,
 	}
-	//log.Warnw("VerifyEntry", "beacon", b)
-	err := dbeacon.VerifyBeacon(db.pubkey.Key(), b)
+	err := dchain.VerifyBeacon(db.pubkey, b)
 	if err == nil {
 		db.cacheValue(curr)
 	}
 	return err
 }

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

 import (
-	"fmt"
+	"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 TestPrintDrandPubkey(t *testing.T) {
-	bc, err := NewDrandBeacon(1, 1)
-	if err != nil {
-		t.Fatal(err)
-	}
-	fmt.Printf("Drand Pubkey:\n%#v\n", bc.pubkey.TOML())
+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)
 }
@@ -6,8 +6,8 @@ import (
 	"encoding/binary"
 	"time"

+	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/lotus/chain/types"
-	"github.com/filecoin-project/specs-actors/actors/abi"
 	"github.com/minio/blake2b-simd"
 	"golang.org/x/xerrors"
 )
@@ -53,11 +53,7 @@ func (mb *mockBeacon) VerifyEntry(from types.BeaconEntry, to types.BeaconEntry)
 	return nil
 }

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

@@ -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 {
@@ -1,257 +0,0 @@
-package blocksync
-
-import (
-	"bufio"
-	"context"
-	"time"
-
-	"github.com/libp2p/go-libp2p-core/protocol"
-	"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"
-	logging "github.com/ipfs/go-log/v2"
-	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"
-
-const BlockSyncMaxRequestLength = 800
-
-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 << iota
-	BSOptMessages
-)
-
-const (
-	StatusOK            = uint64(0)
-	StatusPartial       = uint64(101)
-	StatusNotFound      = uint64(201)
-	StatusGoAway        = uint64(202)
-	StatusInternalError = uint64(203)
-	StatusBadRequest    = uint64(204)
-)
-
-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.Infow("block sync request", "start", req.Start, "len", req.RequestLength)
-
-	resp, err := bss.processRequest(ctx, s.Conn().RemotePeer(), &req)
-	if err != nil {
-		log.Warn("failed to process block sync request: ", err)
-		return
-	}
-
-	writeDeadline := 60 * time.Second
-	s.SetDeadline(time.Now().Add(writeDeadline))
-	if err := cborutil.WriteCborRPC(s, resp); err != nil {
-		log.Warnw("failed to write back response for handle stream", "err", err, "peer", s.Conn().RemotePeer())
-		return
-	}
-}
-
-func (bss *BlockSyncService) processRequest(ctx context.Context, p peer.ID, 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:  StatusBadRequest,
-			Message: "no cids given in blocksync request",
-		}, nil
-	}
-
-	span.AddAttributes(
-		trace.BoolAttribute("blocks", opts.IncludeBlocks),
-		trace.BoolAttribute("messages", opts.IncludeMessages),
-		trace.Int64Attribute("reqlen", int64(req.RequestLength)),
-	)
-
-	reqlen := req.RequestLength
-	if reqlen > BlockSyncMaxRequestLength {
-		log.Warnw("limiting blocksync request length", "orig", req.RequestLength, "peer", p)
-		reqlen = BlockSyncMaxRequestLength
-	}
-
-	chain, err := collectChainSegment(bss.cs, types.NewTipSetKey(req.Start...), reqlen, opts)
-	if err != nil {
-		log.Warn("encountered error while responding to block sync request: ", err)
-		return &BlockSyncResponse{
-			Status:  StatusInternalError,
-			Message: err.Error(),
-		}, nil
-	}
-
-	status := StatusOK
-	if reqlen < req.RequestLength {
-		status = StatusPartial
-	}
-
-	return &BlockSyncResponse{
-		Chain:  chain,
-		Status: status,
-	}, nil
-}
-
-func collectChainSegment(cs *store.ChainStore, start types.TipSetKey, length uint64, opts *BSOptions) ([]*BSTipSet, error) {
-	var bstips []*BSTipSet
-	cur := start
-	for {
-		var bst BSTipSet
-		ts, err := 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 := gatherMessages(cs, 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 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 secpkmsgs []*types.SignedMessage
-	var blsmsgs []*types.Message
-	var secpkincl, blsincl [][]uint64
-
-	for _, b := range ts.Blocks() {
-		bmsgs, smsgs, err := 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
-}
@@ -1,590 +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"
-	graphsync "github.com/ipfs/go-graphsync"
-	gsnet "github.com/ipfs/go-graphsync/network"
-	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"
-
-	cborutil "github.com/filecoin-project/go-cbor-util"
-	"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"
-	"github.com/filecoin-project/lotus/node/modules/dtypes"
-)
-
-type BlockSync struct {
-	bserv bserv.BlockService
-	gsync graphsync.GraphExchange
-	host  host.Host
-
-	syncPeers *bsPeerTracker
-	peerMgr   *peermgr.PeerMgr
-}
-
-func NewBlockSyncClient(bserv dtypes.ChainBlockService, h host.Host, pmgr peermgr.MaybePeerMgr, gs dtypes.Graphsync) *BlockSync {
-	return &BlockSync{
-		bserv:     bserv,
-		host:      h,
-		syncPeers: newPeerTracker(pmgr.Mgr),
-		peerMgr:   pmgr.Mgr,
-		gsync:     gs,
-	}
-}
-
-func (bs *BlockSync) processStatus(req *BlockSyncRequest, res *BlockSyncResponse) error {
-	switch res.Status {
-	case StatusPartial: // Partial Response
-		return xerrors.Errorf("not handling partial blocksync responses yet")
-	case StatusNotFound: // req.Start not found
-		return xerrors.Errorf("not found")
-	case StatusGoAway: // Go Away
-		return xerrors.Errorf("not handling 'go away' blocksync responses yet")
-	case StatusInternalError: // Internal Error
-		return xerrors.Errorf("block sync peer errored: %s", res.Message)
-	case StatusBadRequest:
-		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 == StatusOK || res.Status == StatusPartial {
-			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 for single tipset fetching")
-	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,
-	}
-
-	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 == StatusOK {
-			bs.syncPeers.logGlobalSuccess(time.Since(start))
-			return res.Chain, nil
-		}
-
-		if res.Status == StatusPartial {
-			// TODO: track partial response sizes to ensure we don't overrequest too often
-			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(),
-				})
-			}
-		}
-	}()
-
-	if span.IsRecordingEvents() {
-		span.AddAttributes(
-			trace.StringAttribute("peer", p.Pretty()),
-		)
-	}
-
-	gsproto := string(gsnet.ProtocolGraphsync)
-	supp, err := bs.host.Peerstore().SupportsProtocols(p, BlockSyncProtocolID, gsproto)
-	if err != nil {
-		return nil, xerrors.Errorf("failed to get protocols for peer: %w", err)
-	}
-
-	if len(supp) == 0 {
-		return nil, xerrors.Errorf("peer %s supports no known sync protocols", p)
-	}
-
-	switch supp[0] {
-	case BlockSyncProtocolID:
-		res, err := bs.fetchBlocksBlockSync(ctx, p, req)
-		if err != nil {
-			return nil, xerrors.Errorf("blocksync req failed: %w", err)
-		}
-		return res, nil
-	case gsproto:
-		res, err := bs.fetchBlocksGraphSync(ctx, p, req)
-		if err != nil {
-			return nil, xerrors.Errorf("graphsync req failed: %w", err)
-		}
-		return res, nil
-	default:
-		return nil, xerrors.Errorf("peerstore somehow returned unexpected protocols: %v", supp)
-	}
-
-}
-func (bs *BlockSync) fetchBlocksBlockSync(ctx context.Context, p peer.ID, req *BlockSyncRequest) (*BlockSyncResponse, error) {
-	ctx, span := trace.StartSpan(ctx, "blockSyncFetch")
-	defer span.End()
-
-	start := time.Now()
-	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.SetWriteDeadline(time.Now().Add(5 * time.Second))
-
-	if err := cborutil.WriteCborRPC(s, req); err != nil {
-		s.SetWriteDeadline(time.Time{})
-		bs.syncPeers.logFailure(p, time.Since(start))
-		return nil, err
-	}
-	s.SetWriteDeadline(time.Time{})
-
-	var res BlockSyncResponse
-	r := incrt.New(s, 50<<10, 5*time.Second)
-	if err := cborutil.ReadCborRPC(bufio.NewReader(r), &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(p); 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 {
-			costJ = getPeerInitLat(out[j])
-		}
-
-		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)
-}
@@ -1,151 +0,0 @@
-package blocksync
-
-import (
-	"context"
-
-	"github.com/ipfs/go-cid"
-	"github.com/ipfs/go-datastore"
-	"github.com/ipfs/go-graphsync"
-	"github.com/ipld/go-ipld-prime"
-	"github.com/libp2p/go-libp2p-core/peer"
-	"golang.org/x/xerrors"
-
-	store "github.com/filecoin-project/lotus/chain/store"
-	"github.com/filecoin-project/lotus/chain/types"
-
-	cidlink "github.com/ipld/go-ipld-prime/linking/cid"
-	basicnode "github.com/ipld/go-ipld-prime/node/basic"
-	ipldselector "github.com/ipld/go-ipld-prime/traversal/selector"
-	selectorbuilder "github.com/ipld/go-ipld-prime/traversal/selector/builder"
-)
-
-const (
-
-	// AMT selector recursion. An AMT has arity of 8 so this gives allows
-	// us to retrieve trees with 8^10 (1,073,741,824) elements.
-	amtRecursionDepth = uint32(10)
-
-	// some constants for looking up tuple encoded struct fields
-	// field index of Parents field in a block header
-	blockIndexParentsField = 5
-
-	// field index of Messages field in a block header
-	blockIndexMessagesField = 10
-
-	// field index of AMT node in AMT head
-	amtHeadNodeFieldIndex = 2
-
-	// field index of links array AMT node
-	amtNodeLinksFieldIndex = 1
-
-	// field index of values array AMT node
-	amtNodeValuesFieldIndex = 2
-
-	// maximum depth per traversal
-	maxRequestLength = 50
-)
-
-var amtSelector selectorbuilder.SelectorSpec
-
-func init() {
-	// builer for selectors
-	ssb := selectorbuilder.NewSelectorSpecBuilder(basicnode.Style.Any)
-	// amt selector -- needed to selector through a messages AMT
-	amtSelector = ssb.ExploreIndex(amtHeadNodeFieldIndex,
-		ssb.ExploreRecursive(ipldselector.RecursionLimitDepth(int(amtRecursionDepth)),
-			ssb.ExploreUnion(
-				ssb.ExploreIndex(amtNodeLinksFieldIndex,
-					ssb.ExploreAll(ssb.ExploreRecursiveEdge())),
-				ssb.ExploreIndex(amtNodeValuesFieldIndex,
-					ssb.ExploreAll(ssb.Matcher())))))
-}
-
-func selectorForRequest(req *BlockSyncRequest) ipld.Node {
-	// builer for selectors
-	ssb := selectorbuilder.NewSelectorSpecBuilder(basicnode.Style.Any)
-
-	bso := ParseBSOptions(req.Options)
-	if bso.IncludeMessages {
-		return ssb.ExploreRecursive(ipldselector.RecursionLimitDepth(int(req.RequestLength)),
-			ssb.ExploreIndex(blockIndexParentsField,
-				ssb.ExploreUnion(
-					ssb.ExploreAll(
-						ssb.ExploreIndex(blockIndexMessagesField,
-							ssb.ExploreRange(0, 2, amtSelector),
-						)),
-					ssb.ExploreIndex(0, ssb.ExploreRecursiveEdge()),
-				))).Node()
-	}
-	return ssb.ExploreRecursive(ipldselector.RecursionLimitDepth(int(req.RequestLength)), ssb.ExploreIndex(blockIndexParentsField,
-		ssb.ExploreUnion(
-			ssb.ExploreAll(
-				ssb.Matcher(),
-			),
-			ssb.ExploreIndex(0, ssb.ExploreRecursiveEdge()),
-		))).Node()
-}
-
-func firstTipsetSelector(req *BlockSyncRequest) ipld.Node {
-	// builer for selectors
-	ssb := selectorbuilder.NewSelectorSpecBuilder(basicnode.Style.Any)
-
-	bso := ParseBSOptions(req.Options)
-	if bso.IncludeMessages {
-		return ssb.ExploreIndex(blockIndexMessagesField,
-			ssb.ExploreRange(0, 2, amtSelector),
-		).Node()
-	}
-	return ssb.Matcher().Node()
-
-}
-
-func (bs *BlockSync) executeGsyncSelector(ctx context.Context, p peer.ID, root cid.Cid, sel ipld.Node) error {
-	extension := graphsync.ExtensionData{
-		Name: "chainsync",
-		Data: nil,
-	}
-	_, errs := bs.gsync.Request(ctx, p, cidlink.Link{Cid: root}, sel, extension)
-
-	for err := range errs {
-		return xerrors.Errorf("failed to complete graphsync request: %w", err)
-	}
-	return nil
-}
-
-// Fallback for interacting with other non-lotus nodes
-func (bs *BlockSync) fetchBlocksGraphSync(ctx context.Context, p peer.ID, req *BlockSyncRequest) (*BlockSyncResponse, error) {
-	ctx, cancel := context.WithCancel(ctx)
-	defer cancel()
-
-	immediateTsSelector := firstTipsetSelector(req)
-
-	// Do this because we can only request one root at a time
-	for _, r := range req.Start {
-		if err := bs.executeGsyncSelector(ctx, p, r, immediateTsSelector); err != nil {
-			return nil, err
-		}
-	}
-
-	if req.RequestLength > maxRequestLength {
-		req.RequestLength = maxRequestLength
-	}
-
-	sel := selectorForRequest(req)
-
-	// execute the selector forreal
-	if err := bs.executeGsyncSelector(ctx, p, req.Start[0], sel); err != nil {
-		return nil, err
-	}
-
-	// Now pull the data we fetched out of the chainstore (where it should now be persisted)
-	tempcs := store.NewChainStore(bs.bserv.Blockstore(), datastore.NewMapDatastore(), nil)
-
-	opts := ParseBSOptions(req.Options)
-	tsk := types.NewTipSetKey(req.Start...)
-	chain, err := collectChainSegment(tempcs, tsk, req.RequestLength, opts)
-	if err != nil {
-		return nil, xerrors.Errorf("failed to load chain data from chainstore after successful graphsync response (start = %v): %w", req.Start, err)
-	}
-
-	return &BlockSyncResponse{Chain: chain}, nil
-}
@@ -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
+}
@@ -5,7 +5,7 @@ import (
 	"sync"
 	"time"

-	"github.com/filecoin-project/specs-actors/actors/abi"
+	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/ipfs/go-cid"
 	logging "github.com/ipfs/go-log/v2"
 	"golang.org/x/xerrors"
@@ -19,7 +19,7 @@ import (

 var log = logging.Logger("events")

-// `curH`-`ts.Height` = `confidence`
+// 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

@@ -31,10 +31,11 @@ type heightHandler struct {
 	revert RevertHandler
 }

-type eventApi interface {
+type eventAPI interface {
 	ChainNotify(context.Context) (<-chan []*api.HeadChange, error)
 	ChainGetBlockMessages(context.Context, cid.Cid) (*api.BlockMessages, 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)

@@ -42,7 +43,7 @@ type eventApi interface {
 }

 type Events struct {
-	api eventApi
+	api eventAPI

 	tsc *tipSetCache
 	lk  sync.Mutex
@@ -51,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,
@@ -67,25 +68,14 @@ func NewEvents(ctx context.Context, api eventApi) *Events {
 		heightEvents: heightEvents{
 			tsc:          tsc,
 			ctx:          ctx,
-			gcConfidence: abi.ChainEpoch(gcConfidence),
+			gcConfidence: gcConfidence,

 			heightTriggers:   map[uint64]*heightHandler{},
 			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[abi.ChainEpoch]map[triggerId]int{},
-		},
+		hcEvents: newHCEvents(ctx, api, tsc, uint64(gcConfidence)),
 	}

 	e.ready.Add(1)
@@ -110,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")
 	}
 }
@@ -143,7 +133,7 @@ func (e *Events) listenHeadChangesOnce(ctx context.Context) error {
 	}

 	e.readyOnce.Do(func() {
-		e.at = cur[0].Val.Height()
+		e.lastTs = cur[0].Val

 		e.ready.Done()
 	})
@@ -166,7 +156,7 @@ func (e *Events) listenHeadChangesOnce(ctx context.Context) error {
 		}

 		// sync with fake chainstore (for tests)
-		if fcs, ok := e.api.(interface{notifDone()}); ok {
+		if fcs, ok := e.api.(interface{ notifDone() }); ok {
 			fcs.notifDone()
 		}
 	}
@@ -186,5 +176,5 @@ func (e *Events) headChange(rev, app []*types.TipSet) error {
 		return err
 	}

-	return e.headChangeCalled(rev, app)
+	return e.processHeadChangeEvent(rev, app)
 }
@@ -5,7 +5,7 @@ import (
 	"math"
 	"sync"

-	"github.com/filecoin-project/specs-actors/actors/abi"
+	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/ipfs/go-cid"
 	"golang.org/x/xerrors"

@@ -13,8 +13,9 @@ import (
 )

 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 = abi.ChainEpoch
@@ -23,53 +24,60 @@ type msgH = abi.ChainEpoch
 //  message (msgH+confidence)
 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 abi.ChainEpoch) (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    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   abi.ChainEpoch
-	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

-	at abi.ChainEpoch
+	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]
@@ -78,29 +86,81 @@ type calledEvents struct {
 	// [msgH][triggerH]
 	revertQueue map[msgH][]triggerH

-	// [timeoutH+confidence][triggerId]{calls}
-	timeouts map[abi.ChainEpoch]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.at = ts.Height()
+		e.lastTs = ts
 	}

 	for _, ts := range app {
-		// called triggers
-		e.checkNewCalls(ts)
-		for ; e.at <= ts.Height(); e.at++ {
-			e.applyWithConfidence(ts, e.at)
+		// Check if the head change caused any state changes that we were
+		// waiting for
+		stateChanges := e.watcherEvents.checkStateChanges(e.lastTs, 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
@@ -116,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())
@@ -124,42 +184,15 @@ func (e *calledEvents) handleReverts(ts *types.TipSet) {
 	delete(e.revertQueue, ts.Height())
 }

-func (e *calledEvents) checkNewCalls(ts *types.TipSet) {
-	pts, err := e.cs.ChainGetTipSet(e.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
+// 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]
+
+	prevH := NoHeight
+	if prevTs != nil {
+		prevH = prevTs.Height()
 	}
-
-	e.messagesForTs(pts, func(msg *types.Message) {
-		// TODO: provide receipts
-
-		for tid, matchFns := range e.matchers {
-			var matched bool
-			for _, matchFn := range matchFns {
-				ok, err := matchFn(msg)
-				if err != nil {
-					log.Errorf("event matcher failed: %s", err)
-					continue
-				}
-				matched = ok
-
-				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]
-
 	appliedH := ts.Height()

 	triggerH := appliedH + abi.ChainEpoch(trigger.confidence)
@@ -171,18 +204,20 @@ func (e *calledEvents) queueForConfidence(triggerId uint64, msg *types.Message,
 	}

 	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, height abi.ChainEpoch) {
+// 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 {
@@ -201,15 +236,20 @@ func (e *calledEvents) applyWithConfidence(ts *types.TipSet, height abi.ChainEpo
 				continue
 			}

-			rec, err := e.cs.StateGetReceipt(e.ctx, event.msg.Cid(), ts.Key())
-			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, 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, height, err)
+				log.Errorf("chain trigger (@H %d, triggered @ %d) failed: %s", origH, height, err)
 				continue // don't revert failed calls
 			}

@@ -225,17 +265,18 @@ func (e *calledEvents) applyWithConfidence(ts *types.TipSet, height abi.ChainEpo
 	}
 }

-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
 		}
@@ -255,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
@@ -289,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
@@ -313,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 abi.ChainEpoch, 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 + abi.ChainEpoch(confidence),
-
-		disabled: !more,
-
-		handle: hnd,
-		revert: rev,
-	}
-
-	e.matchers[id] = append(e.matchers[id], mf)
-
-	if timeout != NoTimeout {
-		if e.timeouts[timeout+abi.ChainEpoch(confidence)] == nil {
-			e.timeouts[timeout+abi.ChainEpoch(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+abi.ChainEpoch(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 abi.ChainEpoch, msg types.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()))
 }
@@ -4,8 +4,9 @@ import (
 	"context"
 	"sync"

-	"github.com/filecoin-project/specs-actors/actors/abi"
+	"github.com/filecoin-project/go-state-types/abi"
 	"go.opencensus.io/trace"
+	"golang.org/x/xerrors"

 	"github.com/filecoin-project/lotus/chain/types"
 )
@@ -15,12 +16,12 @@ type heightEvents struct {
 	tsc          *tipSetCache
 	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
 }
@@ -32,6 +33,8 @@ 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
@@ -40,7 +43,10 @@ func (e *heightEvents) headChangeAt(rev, app []*types.TipSet) error {
 			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()
@@ -87,7 +93,6 @@ func (e *heightEvents) headChangeAt(rev, app []*types.TipSet) error {
 				if hnd.called {
 					return nil
 				}
-				hnd.called = true

 				triggerH := h - abi.ChainEpoch(hnd.confidence)

@@ -98,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 {
@@ -136,16 +144,19 @@ func (e *heightEvents) headChangeAt(rev, app []*types.TipSet) error {
 }

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

-	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()
 	if bestH >= h+abi.ChainEpoch(confidence) {
 		ts, err := e.tsc.getNonNull(h)
 		if err != nil {
@@ -164,7 +175,11 @@ 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()
@@ -11,8 +11,8 @@ import (
 	"github.com/stretchr/testify/require"

 	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/specs-actors/actors/abi"
-	"github.com/filecoin-project/specs-actors/actors/crypto"
+	"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"
@@ -46,6 +46,10 @@ type fakeCS struct {
 	sub func(rev, app []*types.TipSet)
 }

+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
 }
@@ -110,7 +114,11 @@ func (fcs *fakeCS) makeTs(t *testing.T, parents []cid.Cid, h abi.ChainEpoch, msg

 func (fcs *fakeCS) ChainNotify(context.Context) (<-chan []*api.HeadChange, error) {
 	out := make(chan []*api.HeadChange, 1)
-	out <- []*api.HeadChange{{Type: store.HCCurrent, Val: fcs.tsc.best()}}
+	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([]*api.HeadChange, len(rev)+len(app))
@@ -174,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)
@@ -196,7 +205,9 @@ func (fcs *fakeCS) advance(rev, app int, msgs map[int]cid.Cid, nulls ...int) { /
 			continue
 		}

-		ts := fcs.makeTs(fcs.t, fcs.tsc.best().Key().Cids(), 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 {
@@ -211,15 +222,14 @@ func (fcs *fakeCS) advance(rev, app int, msgs map[int]cid.Cid, nulls ...int) { /
 	fcs.sub(revs, apps)

 	fcs.sync.Lock()
-	fcs.sync.Unlock()
-
+	fcs.sync.Unlock() //nolint:staticcheck
 }

 func (fcs *fakeCS) notifDone() {
 	fcs.sync.Unlock()
 }

-var _ eventApi = &fakeCS{}
+var _ eventAPI = &fakeCS{}

 func TestAt(t *testing.T) {
 	fcs := &fakeCS{
@@ -562,9 +572,9 @@ func TestAtChainedConfidenceNull(t *testing.T) {
 	require.Equal(t, false, reverted)
 }

-func matchAddrMethod(to address.Address, m abi.MethodNum) func(msg *types.Message) (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
 	}
 }

@@ -671,7 +681,7 @@ func TestCalled(t *testing.T) {
 		0: n2msg,
 	})

-	require.Equal(t, true, applied)  // msg from H=7, which had reverted execution
+	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
@@ -1005,8 +1015,6 @@ func TestRemoveTriggersOnMessage(t *testing.T) {
 		return false, true, nil
 	}, func(msg *types.Message, rec *types.MessageReceipt, ts *types.TipSet, curH abi.ChainEpoch) (bool, error) {
 		require.Equal(t, false, applied)
-		fmt.Println(msg == nil)
-		fmt.Println(curH)
 		applied = true
 		return more, nil
 	}, func(_ context.Context, ts *types.TipSet) error {
@@ -1068,3 +1076,250 @@ func TestRemoveTriggersOnMessage(t *testing.T) {
 	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)
+}
@@ -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)
+}
@@ -0,0 +1,115 @@
+package state
+
+import (
+	"bytes"
+
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/specs-actors/actors/util/adt"
+	typegen "github.com/whyrusleeping/cbor-gen"
+)
+
+// 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 *adt.Array, out AdtArrayDiff) error {
+	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
+			}
+		}
+
+		return curArr.Delete(uint64(i))
+	}); err != nil {
+		return err
+	}
+
+	curVal := new(typegen.Deferred)
+	return curArr.ForEach(curVal, func(i int64) error {
+		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 *adt.Map, out AdtMapDiff) error {
+	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
+			}
+		}
+
+		return curMap.Delete(k)
+	}); err != nil {
+		return err
+	}
+
+	curVal := new(typegen.Deferred)
+	return curMap.ForEach(curVal, func(key string) error {
+		return out.Add(key, curVal)
+	})
+}
@@ -0,0 +1,303 @@
+package state
+
+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"
+	"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 := adt.MakeEmptyArray(ctxstoreA)
+	arrB := adt.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 := adt.MakeEmptyMap(ctxstoreA)
+	mapB := adt.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() *contextStore {
+	ctx := context.Background()
+	bs := bstore.NewTemporarySync()
+	store := cbornode.NewCborStore(bs)
+	return &contextStore{
+		ctx: ctx,
+		cst: store,
+	}
+}
@@ -0,0 +1,787 @@
+package state
+
+import (
+	"bytes"
+	"context"
+
+	"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"
+	"github.com/filecoin-project/specs-actors/actors/builtin/market"
+	"github.com/filecoin-project/specs-actors/actors/builtin/miner"
+	"github.com/filecoin-project/specs-actors/actors/builtin/paych"
+	"github.com/filecoin-project/specs-actors/actors/util/adt"
+	"github.com/ipfs/go-cid"
+	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/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, oldActorStateHead, newActorStateHead cid.Cid) (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.Head, newActor.Head)
+	}
+}
+
+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(builtin.StorageMarketActorAddr, func(ctx context.Context, oldActorStateHead, newActorStateHead cid.Cid) (changed bool, user UserData, err error) {
+		var oldState market.State
+		if err := sp.cst.Get(ctx, oldActorStateHead, &oldState); err != nil {
+			return false, nil, err
+		}
+		var newState market.State
+		if err := sp.cst.Get(ctx, newActorStateHead, &newState); err != nil {
+			return false, nil, err
+		}
+		return diffStorageMarketState(ctx, &oldState, &newState)
+	})
+}
+
+type BalanceTables struct {
+	EscrowTable *adt.BalanceTable
+	LockedTable *adt.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) {
+		if oldState.EscrowTable.Equals(newState.EscrowTable) && oldState.LockedTable.Equals(newState.LockedTable) {
+			return false, nil, nil
+		}
+
+		ctxStore := &contextStore{
+			ctx: ctx,
+			cst: sp.cst,
+		}
+
+		oldEscrowRoot, err := adt.AsBalanceTable(ctxStore, oldState.EscrowTable)
+		if err != nil {
+			return false, nil, err
+		}
+
+		oldLockedRoot, err := adt.AsBalanceTable(ctxStore, oldState.LockedTable)
+		if err != nil {
+			return false, nil, err
+		}
+
+		newEscrowRoot, err := adt.AsBalanceTable(ctxStore, newState.EscrowTable)
+		if err != nil {
+			return false, nil, err
+		}
+
+		newLockedRoot, err := adt.AsBalanceTable(ctxStore, newState.LockedTable)
+		if err != nil {
+			return false, nil, err
+		}
+
+		return diffBalances(ctx, BalanceTables{oldEscrowRoot, oldLockedRoot}, BalanceTables{newEscrowRoot, newLockedRoot})
+	}
+}
+
+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 DiffAdtArraysFunc) DiffStorageMarketStateFunc {
+	return func(ctx context.Context, oldState *market.State, newState *market.State) (changed bool, user UserData, err error) {
+		if oldState.States.Equals(newState.States) {
+			return false, nil, nil
+		}
+
+		ctxStore := &contextStore{
+			ctx: ctx,
+			cst: sp.cst,
+		}
+
+		oldRoot, err := adt.AsArray(ctxStore, oldState.States)
+		if err != nil {
+			return false, nil, err
+		}
+		newRoot, err := adt.AsArray(ctxStore, 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 DiffAdtArraysFunc) DiffStorageMarketStateFunc {
+	return func(ctx context.Context, oldState *market.State, newState *market.State) (changed bool, user UserData, err error) {
+		if oldState.Proposals.Equals(newState.Proposals) {
+			return false, nil, nil
+		}
+
+		ctxStore := &contextStore{
+			ctx: ctx,
+			cst: sp.cst,
+		}
+
+		oldRoot, err := adt.AsArray(ctxStore, oldState.Proposals)
+		if err != nil {
+			return false, nil, err
+		}
+		newRoot, err := adt.AsArray(ctxStore, newState.Proposals)
+		if err != nil {
+			return false, nil, err
+		}
+
+		return diffDealProps(ctx, oldRoot, newRoot)
+	}
+}
+
+var _ AdtArrayDiff = &MarketDealProposalChanges{}
+
+type MarketDealProposalChanges struct {
+	Added   []ProposalIDState
+	Removed []ProposalIDState
+}
+
+type ProposalIDState struct {
+	ID       abi.DealID
+	Proposal market.DealProposal
+}
+
+func (m *MarketDealProposalChanges) Add(key uint64, val *typegen.Deferred) error {
+	dp := new(market.DealProposal)
+	err := dp.UnmarshalCBOR(bytes.NewReader(val.Raw))
+	if err != nil {
+		return err
+	}
+	m.Added = append(m.Added, ProposalIDState{abi.DealID(key), *dp})
+	return nil
+}
+
+func (m *MarketDealProposalChanges) Modify(key uint64, from, to *typegen.Deferred) error {
+	// short circuit, DealProposals are static
+	return nil
+}
+
+func (m *MarketDealProposalChanges) Remove(key uint64, val *typegen.Deferred) error {
+	dp := new(market.DealProposal)
+	err := dp.UnmarshalCBOR(bytes.NewReader(val.Raw))
+	if err != nil {
+		return err
+	}
+	m.Removed = append(m.Removed, ProposalIDState{abi.DealID(key), *dp})
+	return nil
+}
+
+// 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() DiffAdtArraysFunc {
+	return func(ctx context.Context, oldDealProps, newDealProps *adt.Array) (changed bool, user UserData, err error) {
+		proposalChanges := new(MarketDealProposalChanges)
+		if err := DiffAdtArray(oldDealProps, newDealProps, proposalChanges); err != nil {
+			return false, nil, err
+		}
+
+		if len(proposalChanges.Added)+len(proposalChanges.Removed) == 0 {
+			return false, nil, nil
+		}
+
+		return true, proposalChanges, nil
+	}
+}
+
+var _ AdtArrayDiff = &MarketDealStateChanges{}
+
+type MarketDealStateChanges struct {
+	Added    []DealIDState
+	Modified []DealStateChange
+	Removed  []DealIDState
+}
+
+type DealIDState struct {
+	ID   abi.DealID
+	Deal market.DealState
+}
+
+func (m *MarketDealStateChanges) Add(key uint64, val *typegen.Deferred) error {
+	ds := new(market.DealState)
+	err := ds.UnmarshalCBOR(bytes.NewReader(val.Raw))
+	if err != nil {
+		return err
+	}
+	m.Added = append(m.Added, DealIDState{abi.DealID(key), *ds})
+	return nil
+}
+
+func (m *MarketDealStateChanges) Modify(key uint64, from, to *typegen.Deferred) error {
+	dsFrom := new(market.DealState)
+	if err := dsFrom.UnmarshalCBOR(bytes.NewReader(from.Raw)); err != nil {
+		return err
+	}
+
+	dsTo := new(market.DealState)
+	if err := dsTo.UnmarshalCBOR(bytes.NewReader(to.Raw)); err != nil {
+		return err
+	}
+
+	if *dsFrom != *dsTo {
+		m.Modified = append(m.Modified, DealStateChange{abi.DealID(key), dsFrom, dsTo})
+	}
+	return nil
+}
+
+func (m *MarketDealStateChanges) Remove(key uint64, val *typegen.Deferred) error {
+	ds := new(market.DealState)
+	err := ds.UnmarshalCBOR(bytes.NewReader(val.Raw))
+	if err != nil {
+		return err
+	}
+	m.Removed = append(m.Removed, DealIDState{abi.DealID(key), *ds})
+	return 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() DiffAdtArraysFunc {
+	return func(ctx context.Context, oldDealStates, newDealStates *adt.Array) (changed bool, user UserData, err error) {
+		dealStateChanges := new(MarketDealStateChanges)
+		if err := DiffAdtArray(oldDealStates, newDealStates, dealStateChanges); 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]DealStateChange
+
+// DealStateChange is a change in deal state from -> to
+type DealStateChange struct {
+	ID   abi.DealID
+	From *market.DealState
+	To   *market.DealState
+}
+
+// DealStateChangedForIDs detects changes in the deal state AMT for the given deal IDs
+func (sp *StatePredicates) DealStateChangedForIDs(dealIds []abi.DealID) DiffAdtArraysFunc {
+	return func(ctx context.Context, oldDealStateArray, newDealStateArray *adt.Array) (changed bool, user UserData, err error) {
+		changedDeals := make(ChangedDeals)
+		for _, dealID := range dealIds {
+			var oldDealPtr, newDealPtr *market.DealState
+			var oldDeal, newDeal market.DealState
+
+			// If the deal has been removed, we just set it to nil
+			found, err := oldDealStateArray.Get(uint64(dealID), &oldDeal)
+			if err != nil {
+				return false, nil, err
+			}
+			if found {
+				oldDealPtr = &oldDeal
+			}
+
+			found, err = newDealStateArray.Get(uint64(dealID), &newDeal)
+			if err != nil {
+				return false, nil, err
+			}
+			if found {
+				newDealPtr = &newDeal
+			}
+
+			if oldDeal != newDeal {
+				changedDeals[dealID] = DealStateChange{dealID, oldDealPtr, newDealPtr}
+			}
+		}
+		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(builtin.InitActorAddr, func(ctx context.Context, oldActorStateHead, newActorStateHead cid.Cid) (changed bool, user UserData, err error) {
+		var oldState init_.State
+		if err := sp.cst.Get(ctx, oldActorStateHead, &oldState); err != nil {
+			return false, nil, err
+		}
+		var newState init_.State
+		if err := sp.cst.Get(ctx, newActorStateHead, &newState); 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, oldActorStateHead, newActorStateHead cid.Cid) (changed bool, user UserData, err error) {
+		var oldState miner.State
+		if err := sp.cst.Get(ctx, oldActorStateHead, &oldState); err != nil {
+			return false, nil, err
+		}
+		var newState miner.State
+		if err := sp.cst.Get(ctx, newActorStateHead, &newState); err != nil {
+			return false, nil, err
+		}
+		return diffMinerActorState(ctx, &oldState, &newState)
+	})
+}
+
+type MinerSectorChanges struct {
+	Added    []miner.SectorOnChainInfo
+	Extended []SectorExtensions
+	Removed  []miner.SectorOnChainInfo
+}
+
+var _ AdtArrayDiff = &MinerSectorChanges{}
+
+type SectorExtensions struct {
+	From miner.SectorOnChainInfo
+	To   miner.SectorOnChainInfo
+}
+
+func (m *MinerSectorChanges) Add(key uint64, val *typegen.Deferred) error {
+	si := new(miner.SectorOnChainInfo)
+	err := si.UnmarshalCBOR(bytes.NewReader(val.Raw))
+	if err != nil {
+		return err
+	}
+	m.Added = append(m.Added, *si)
+	return nil
+}
+
+func (m *MinerSectorChanges) Modify(key uint64, from, to *typegen.Deferred) error {
+	siFrom := new(miner.SectorOnChainInfo)
+	err := siFrom.UnmarshalCBOR(bytes.NewReader(from.Raw))
+	if err != nil {
+		return err
+	}
+
+	siTo := new(miner.SectorOnChainInfo)
+	err = siTo.UnmarshalCBOR(bytes.NewReader(to.Raw))
+	if err != nil {
+		return err
+	}
+
+	if siFrom.Expiration != siTo.Expiration {
+		m.Extended = append(m.Extended, SectorExtensions{
+			From: *siFrom,
+			To:   *siTo,
+		})
+	}
+	return nil
+}
+
+func (m *MinerSectorChanges) Remove(key uint64, val *typegen.Deferred) error {
+	si := new(miner.SectorOnChainInfo)
+	err := si.UnmarshalCBOR(bytes.NewReader(val.Raw))
+	if err != nil {
+		return err
+	}
+	m.Removed = append(m.Removed, *si)
+	return nil
+}
+
+func (sp *StatePredicates) OnMinerSectorChange() DiffMinerActorStateFunc {
+	return func(ctx context.Context, oldState, newState *miner.State) (changed bool, user UserData, err error) {
+		ctxStore := &contextStore{
+			ctx: ctx,
+			cst: sp.cst,
+		}
+
+		sectorChanges := &MinerSectorChanges{
+			Added:    []miner.SectorOnChainInfo{},
+			Extended: []SectorExtensions{},
+			Removed:  []miner.SectorOnChainInfo{},
+		}
+
+		// no sector changes
+		if oldState.Sectors.Equals(newState.Sectors) {
+			return false, nil, nil
+		}
+
+		oldSectors, err := adt.AsArray(ctxStore, oldState.Sectors)
+		if err != nil {
+			return false, nil, err
+		}
+
+		newSectors, err := adt.AsArray(ctxStore, newState.Sectors)
+		if err != nil {
+			return false, nil, err
+		}
+
+		if err := DiffAdtArray(oldSectors, newSectors, sectorChanges); 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
+	}
+}
+
+type MinerPreCommitChanges struct {
+	Added   []miner.SectorPreCommitOnChainInfo
+	Removed []miner.SectorPreCommitOnChainInfo
+}
+
+func (m *MinerPreCommitChanges) AsKey(key string) (abi.Keyer, error) {
+	sector, err := abi.ParseUIntKey(key)
+	if err != nil {
+		return nil, err
+	}
+	return miner.SectorKey(abi.SectorNumber(sector)), nil
+}
+
+func (m *MinerPreCommitChanges) Add(key string, val *typegen.Deferred) error {
+	sp := new(miner.SectorPreCommitOnChainInfo)
+	err := sp.UnmarshalCBOR(bytes.NewReader(val.Raw))
+	if err != nil {
+		return err
+	}
+	m.Added = append(m.Added, *sp)
+	return nil
+}
+
+func (m *MinerPreCommitChanges) Modify(key string, from, to *typegen.Deferred) error {
+	return nil
+}
+
+func (m *MinerPreCommitChanges) Remove(key string, val *typegen.Deferred) error {
+	sp := new(miner.SectorPreCommitOnChainInfo)
+	err := sp.UnmarshalCBOR(bytes.NewReader(val.Raw))
+	if err != nil {
+		return err
+	}
+	m.Removed = append(m.Removed, *sp)
+	return nil
+}
+
+func (sp *StatePredicates) OnMinerPreCommitChange() DiffMinerActorStateFunc {
+	return func(ctx context.Context, oldState, newState *miner.State) (changed bool, user UserData, err error) {
+		ctxStore := &contextStore{
+			ctx: ctx,
+			cst: sp.cst,
+		}
+
+		precommitChanges := &MinerPreCommitChanges{
+			Added:   []miner.SectorPreCommitOnChainInfo{},
+			Removed: []miner.SectorPreCommitOnChainInfo{},
+		}
+
+		if oldState.PreCommittedSectors.Equals(newState.PreCommittedSectors) {
+			return false, nil, nil
+		}
+
+		oldPrecommits, err := adt.AsMap(ctxStore, oldState.PreCommittedSectors)
+		if err != nil {
+			return false, nil, err
+		}
+
+		newPrecommits, err := adt.AsMap(ctxStore, newState.PreCommittedSectors)
+		if err != nil {
+			return false, nil, err
+		}
+
+		if err := DiffAdtMap(oldPrecommits, newPrecommits, precommitChanges); 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, oldActorStateHead, newActorStateHead cid.Cid) (changed bool, user UserData, err error) {
+		var oldState paych.State
+		if err := sp.cst.Get(ctx, oldActorStateHead, &oldState); err != nil {
+			return false, nil, err
+		}
+		var newState paych.State
+		if err := sp.cst.Get(ctx, newActorStateHead, &newState); 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) {
+		if oldState.ToSend.Equals(newState.ToSend) {
+			return false, nil, nil
+		}
+		return true, &PayChToSendChange{
+			OldToSend: oldState.ToSend,
+			NewToSend: newState.ToSend,
+		}, 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) {
+		ctxStore := &contextStore{
+			ctx: ctx,
+			cst: sp.cst,
+		}
+
+		addressChanges := &InitActorAddressChanges{
+			Added:    []AddressPair{},
+			Modified: []AddressChange{},
+			Removed:  []AddressPair{},
+		}
+
+		if oldState.AddressMap.Equals(newState.AddressMap) {
+			return false, nil, nil
+		}
+
+		oldAddrs, err := adt.AsMap(ctxStore, oldState.AddressMap)
+		if err != nil {
+			return false, nil, err
+		}
+
+		newAddrs, err := adt.AsMap(ctxStore, newState.AddressMap)
+		if err != nil {
+			return false, nil, err
+		}
+
+		if err := DiffAdtMap(oldAddrs, newAddrs, addressChanges); 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
+	}
+}
@@ -0,0 +1,609 @@
+package state
+
+import (
+	"context"
+	"testing"
+
+	"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/specs-actors/actors/builtin/market"
+	"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 := &market.DealState{
+		SectorStartEpoch: 1,
+		LastUpdatedEpoch: 2,
+		SlashEpoch:       0,
+	}
+	oldDeal2 := &market.DealState{
+		SectorStartEpoch: 4,
+		LastUpdatedEpoch: 5,
+		SlashEpoch:       0,
+	}
+	oldDeals := map[abi.DealID]*market.DealState{
+		abi.DealID(1): oldDeal1,
+		abi.DealID(2): oldDeal2,
+	}
+
+	oldProp1 := &market.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 := &market.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]*market.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 := &market.DealState{
+		SectorStartEpoch: 1,
+		LastUpdatedEpoch: 3,
+		SlashEpoch:       0,
+	}
+
+	// deal 2 removed
+
+	// added
+	newDeal3 := &market.DealState{
+		SectorStartEpoch: 1,
+		LastUpdatedEpoch: 2,
+		SlashEpoch:       3,
+	}
+	newDeals := map[abi.DealID]*market.DealState{
+		abi.DealID(1): newDeal1,
+		// deal 2 was removed
+		abi.DealID(3): newDeal3,
+	}
+
+	// added
+	newProp3 := &market.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]*market.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{Head: oldStateC})
+	api.setActor(newState.Key(), &types.Actor{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, cid.Cid, cid.Cid) (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, *adt.Array, *adt.Array) (bool, UserData, error) {
+			t.Fatal("No state change so this should not be called")
+			return false, nil, nil
+		})
+		marketState := createEmptyMarketState(t, store)
+		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.(*MarketDealStateChanges)
+		require.True(t, ok)
+		require.Len(t, changedDeals.Added, 1)
+		require.Equal(t, abi.DealID(3), changedDeals.Added[0].ID)
+		require.Equal(t, *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.Equal(t, newDeal1, changedDeals.Modified[0].To)
+		require.Equal(t, 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.(*MarketDealProposalChanges)
+		require.True(t, ok)
+		require.Len(t, changedProps.Added, 1)
+		require.Equal(t, abi.DealID(3), changedProps.Added[0].ID)
+		require.Equal(t, *newProp3, changedProps.Added[0].Proposal)
+
+		// proposals cannot be modified -- no modified testing
+
+		require.Len(t, changedProps.Removed, 1)
+		require.Equal(t, abi.DealID(2), changedProps.Removed[0].ID)
+		require.Equal(t, *oldProp2, changedProps.Removed[0].Proposal)
+	})
+
+	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
+		})
+		marketState := createEmptyMarketState(t, store)
+		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", &miner.SealedCIDPrefix), big.NewInt(0), abi.ChainEpoch(0), abi.ChainEpoch(10))
+	si1 := newSectorOnChainInfo(1, tutils.MakeCID("1", &miner.SealedCIDPrefix), big.NewInt(1), abi.ChainEpoch(1), abi.ChainEpoch(11))
+	si2 := newSectorOnChainInfo(2, tutils.MakeCID("2", &miner.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", &miner.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})
+	api.setActor(newState.Key(), &types.Actor{Head: newMinerC})
+
+	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.(*MinerSectorChanges)
+	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.(*MinerSectorChanges)
+	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]*market.DealState, props map[abi.DealID]*market.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) *market.State {
+	emptyArrayCid, err := adt.MakeEmptyArray(store).Root()
+	require.NoError(t, err)
+	emptyMap, err := adt.MakeEmptyMap(store).Root()
+	require.NoError(t, err)
+	return market.ConstructState(emptyArrayCid, emptyMap, emptyMap)
+}
+
+func createDealAMT(ctx context.Context, t *testing.T, store adt.Store, deals map[abi.DealID]*market.DealState) cid.Cid {
+	root := adt.MakeEmptyArray(store)
+	for dealID, dealState := range deals {
+		err := root.Set(uint64(dealID), dealState)
+		require.NoError(t, err)
+	}
+	rootCid, err := root.Root()
+	require.NoError(t, err)
+	return rootCid
+}
+
+func createProposalAMT(ctx context.Context, t *testing.T, store adt.Store, props map[abi.DealID]*market.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) *miner.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(), miner.ConstructDeadline(emptyArrayCid))
+	require.NoError(t, err)
+
+	emptyVestingFunds := miner.ConstructVestingFunds()
+	emptyVestingFundsCid, err := store.Put(store.Context(), emptyVestingFunds)
+	require.NoError(t, err)
+
+	emptyDeadlines := miner.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 := miner.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 := 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) *miner.SectorPreCommitInfo {
+	return &miner.SectorPreCommitInfo{
+		SealProof:     abi.RegisteredSealProof_StackedDrg32GiBV1,
+		SectorNumber:  sectorNo,
+		SealedCID:     sealed,
+		SealRandEpoch: sectorSealRandEpochValue,
+		DealIDs:       nil,
+		Expiration:    expiration,
+	}
+}
@@ -3,13 +3,16 @@ package events
 import (
 	"context"

-	"github.com/filecoin-project/specs-actors/actors/abi"
+	"github.com/filecoin-project/go-state-types/abi"
 	"golang.org/x/xerrors"

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

-type tsByHFunc func(context.Context, abi.ChainEpoch, types.TipSetKey) (*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
@@ -18,10 +21,10 @@ type tipSetCache struct {
 	start int
 	len   int

-	storage tsByHFunc
+	storage tsCacheAPI
 }

-func newTSCache(cap abi.ChainEpoch, storage tsByHFunc) *tipSetCache {
+func newTSCache(cap abi.ChainEpoch, storage tsCacheAPI) *tipSetCache {
 	return &tipSetCache{
 		cache: make([]*types.TipSet, cap),
 		start: 0,
@@ -94,7 +97,7 @@ func (tsc *tipSetCache) getNonNull(height abi.ChainEpoch) (*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, types.EmptyTSK)
+		return tsc.storage.ChainGetTipSetByHeight(context.TODO(), height, types.EmptyTSK)
 	}

 	headH := tsc.cache[tsc.start].Height()
@@ -114,14 +117,18 @@ func (tsc *tipSetCache) get(height abi.ChainEpoch) (*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.Key())
+		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 {
@@ -4,8 +4,8 @@ import (
 	"context"
 	"testing"

-	"github.com/filecoin-project/specs-actors/actors/abi"
-	"github.com/filecoin-project/specs-actors/actors/crypto"
+	"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"
@@ -13,10 +13,7 @@ import (
 )

 func TestTsCache(t *testing.T) {
-	tsc := newTSCache(50, func(context.Context, abi.ChainEpoch, types.TipSetKey) (*types.TipSet, error) {
-		t.Fatal("storage call")
-		return &types.TipSet{}, nil
-	})
+	tsc := newTSCache(50, &tsCacheAPIFailOnStorageCall{t: t})

 	h := abi.ChainEpoch(75)

@@ -43,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
 			}
@@ -55,11 +57,21 @@ func TestTsCache(t *testing.T) {

 }

+type tsCacheAPIFailOnStorageCall struct {
+	t *testing.T
+}
+
+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, func(context.Context, abi.ChainEpoch, types.TipSetKey) (*types.TipSet, error) {
-		t.Fatal("storage call")
-		return &types.TipSet{}, nil
-	})
+	tsc := newTSCache(50, &tsCacheAPIFailOnStorageCall{t: t})

 	h := abi.ChainEpoch(75)

@@ -91,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)
@@ -109,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()
@@ -120,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)
+}
@@ -8,11 +8,11 @@ import (
 	"github.com/filecoin-project/lotus/chain/types"
 )

-func (e *calledEvents) CheckMsg(ctx context.Context, smsg types.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.Key())
+		fa, err := me.cs.StateGetActor(ctx, msg.From, ts.Key())
 		if err != nil {
 			return false, true, err
 		}
@@ -22,7 +22,7 @@ func (e *calledEvents) CheckMsg(ctx context.Context, smsg types.ChainMsg, hnd Ca
 			return false, true, nil
 		}

-		rec, err := e.cs.StateGetReceipt(ctx, smsg.VMMessage().Cid(), ts.Key())
+		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)
 		}
@@ -33,12 +33,12 @@ func (e *calledEvents) CheckMsg(ctx context.Context, smsg types.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
 	}
 }
@@ -1,49 +1,49 @@
 // Code generated by github.com/whyrusleeping/cbor-gen. DO NOT EDIT.

-package blocksync
+package exchange

 import (
 	"fmt"
 	"io"

-	"github.com/filecoin-project/lotus/chain/types"
-	"github.com/ipfs/go-cid"
+	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 lengthBufBlockSyncRequest = []byte{131}
+var lengthBufRequest = []byte{131}

-func (t *BlockSyncRequest) MarshalCBOR(w io.Writer) error {
+func (t *Request) MarshalCBOR(w io.Writer) error {
 	if t == nil {
 		_, err := w.Write(cbg.CborNull)
 		return err
 	}
-	if _, err := w.Write(lengthBufBlockSyncRequest); err != nil {
+	if _, err := w.Write(lengthBufRequest); err != nil {
 		return err
 	}

 	scratch := make([]byte, 9)

-	// t.Start ([]cid.Cid) (slice)
-	if len(t.Start) > cbg.MaxLength {
-		return xerrors.Errorf("Slice value in field t.Start was too long")
+	// 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.Start))); err != nil {
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajArray, uint64(len(t.Head))); err != nil {
 		return err
 	}
-	for _, v := range t.Start {
+	for _, v := range t.Head {
 		if err := cbg.WriteCidBuf(scratch, w, v); err != nil {
-			return xerrors.Errorf("failed writing cid field t.Start: %w", err)
+			return xerrors.Errorf("failed writing cid field t.Head: %w", err)
 		}
 	}

-	// t.RequestLength (uint64) (uint64)
+	// t.Length (uint64) (uint64)

-	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.RequestLength)); err != nil {
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.Length)); err != nil {
 		return err
 	}

@@ -56,7 +56,9 @@ func (t *BlockSyncRequest) MarshalCBOR(w io.Writer) error {
 	return nil
 }

-func (t *BlockSyncRequest) UnmarshalCBOR(r io.Reader) error {
+func (t *Request) UnmarshalCBOR(r io.Reader) error {
+	*t = Request{}
+
 	br := cbg.GetPeeker(r)
 	scratch := make([]byte, 8)

@@ -72,7 +74,7 @@ func (t *BlockSyncRequest) UnmarshalCBOR(r io.Reader) error {
 		return fmt.Errorf("cbor input had wrong number of fields")
 	}

-	// t.Start ([]cid.Cid) (slice)
+	// t.Head ([]cid.Cid) (slice)

 	maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
 	if err != nil {
@@ -80,7 +82,7 @@ func (t *BlockSyncRequest) UnmarshalCBOR(r io.Reader) error {
 	}

 	if extra > cbg.MaxLength {
-		return fmt.Errorf("t.Start: array too large (%d)", extra)
+		return fmt.Errorf("t.Head: array too large (%d)", extra)
 	}

 	if maj != cbg.MajArray {
@@ -88,19 +90,19 @@ func (t *BlockSyncRequest) UnmarshalCBOR(r io.Reader) error {
 	}

 	if extra > 0 {
-		t.Start = make([]cid.Cid, extra)
+		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.Start failed: %w", err)
+			return xerrors.Errorf("reading cid field t.Head failed: %w", err)
 		}
-		t.Start[i] = c
+		t.Head[i] = c
 	}

-	// t.RequestLength (uint64) (uint64)
+	// t.Length (uint64) (uint64)

 	{

@@ -111,7 +113,7 @@ func (t *BlockSyncRequest) UnmarshalCBOR(r io.Reader) error {
 		if maj != cbg.MajUnsignedInt {
 			return fmt.Errorf("wrong type for uint64 field")
 		}
-		t.RequestLength = uint64(extra)
+		t.Length = uint64(extra)

 	}
 	// t.Options (uint64) (uint64)
@@ -131,19 +133,37 @@ func (t *BlockSyncRequest) UnmarshalCBOR(r io.Reader) error {
 	return nil
 }

-var lengthBufBlockSyncResponse = []byte{131}
+var lengthBufResponse = []byte{131}

-func (t *BlockSyncResponse) MarshalCBOR(w io.Writer) error {
+func (t *Response) MarshalCBOR(w io.Writer) error {
 	if t == nil {
 		_, err := w.Write(cbg.CborNull)
 		return err
 	}
-	if _, err := w.Write(lengthBufBlockSyncResponse); err != nil {
+	if _, err := w.Write(lengthBufResponse); err != nil {
 		return err
 	}

 	scratch := make([]byte, 9)

+	// t.Status (blocksync.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 ([]*blocksync.BSTipSet) (slice)
 	if len(t.Chain) > cbg.MaxLength {
 		return xerrors.Errorf("Slice value in field t.Chain was too long")
@@ -157,28 +177,12 @@ func (t *BlockSyncResponse) MarshalCBOR(w io.Writer) error {
 			return err
 		}
 	}
-
-	// t.Status (uint64) (uint64)
-
-	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, 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 := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len(t.Message))); err != nil {
-		return err
-	}
-	if _, err := io.WriteString(w, t.Message); err != nil {
-		return err
-	}
 	return nil
 }

-func (t *BlockSyncResponse) UnmarshalCBOR(r io.Reader) error {
+func (t *Response) UnmarshalCBOR(r io.Reader) error {
+	*t = Response{}
+
 	br := cbg.GetPeeker(r)
 	scratch := make([]byte, 8)

@@ -194,6 +198,30 @@ func (t *BlockSyncResponse) UnmarshalCBOR(r io.Reader) error {
 		return fmt.Errorf("cbor input had wrong number of fields")
 	}

+	// t.Status (blocksync.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 ([]*blocksync.BSTipSet) (slice)

 	maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
@@ -223,34 +251,296 @@ func (t *BlockSyncResponse) UnmarshalCBOR(r io.Reader) error {
 		t.Chain[i] = &v
 	}

-	// t.Status (uint64) (uint64)
+	return nil
+}

-	{
-
-		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 = uint64(extra)
+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
 	}
-	// t.Message (string) (string)

-	{
-		sval, err := cbg.ReadStringBuf(br, scratch)
-		if err != nil {
+	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.Message = string(sval)
+	// 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
 }

-var lengthBufBSTipSet = []byte{133}
+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 {
@@ -277,83 +567,16 @@ func (t *BSTipSet) MarshalCBOR(w io.Writer) error {
 		}
 	}

-	// 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 := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajArray, uint64(len(t.BlsMessages))); err != nil {
+	// t.Messages (blocksync.CompactedMessages) (struct)
+	if err := t.Messages.MarshalCBOR(w); 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 := cbg.WriteMajorTypeHeaderBuf(scratch, w, 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 := 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.SecpkMessages ([]*types.SignedMessage) (slice)
-	if len(t.SecpkMessages) > cbg.MaxLength {
-		return xerrors.Errorf("Slice value in field t.SecpkMessages was too long")
-	}
-
-	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, 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 := cbg.WriteMajorTypeHeaderBuf(scratch, w, 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 := 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 *BSTipSet) UnmarshalCBOR(r io.Reader) error {
+	*t = BSTipSet{}
+
 	br := cbg.GetPeeker(r)
 	scratch := make([]byte, 8)

@@ -365,7 +588,7 @@ func (t *BSTipSet) UnmarshalCBOR(r io.Reader) error {
 		return fmt.Errorf("cbor input should be of type array")
 	}

-	if extra != 5 {
+	if extra != 2 {
 		return fmt.Errorf("cbor input had wrong number of fields")
 	}

@@ -398,181 +621,24 @@ func (t *BSTipSet) UnmarshalCBOR(r io.Reader) error {
 		t.Blocks[i] = &v
 	}

-	// t.BlsMessages ([]*types.Message) (slice)
+	// t.Messages (blocksync.CompactedMessages) (struct)

-	maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
-	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 {
+		b, err := br.ReadByte()
+		if err != nil {
 			return err
 		}
-
-		t.BlsMessages[i] = &v
-	}
-
-	// t.BlsMsgIncludes ([][]uint64) (slice)
-
-	maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
-	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.CborReadHeaderBuf(br, scratch)
-			if err != nil {
+		if b != cbg.CborNull[0] {
+			if err := br.UnreadByte(); err != nil {
 				return err
 			}
-
-			if extra > cbg.MaxLength {
-				return fmt.Errorf("t.BlsMsgIncludes[i]: array too large (%d)", extra)
+			t.Messages = new(CompactedMessages)
+			if err := t.Messages.UnmarshalCBOR(br); err != nil {
+				return xerrors.Errorf("unmarshaling t.Messages pointer: %w", err)
 			}
-
-			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.CborReadHeaderBuf(br, scratch)
-				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] = uint64(val)
-			}
-
-		}
-	}
-
-	// t.SecpkMessages ([]*types.SignedMessage) (slice)
-
-	maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
-	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.CborReadHeaderBuf(br, scratch)
-	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.CborReadHeaderBuf(br, scratch)
-			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.CborReadHeaderBuf(br, scratch)
-				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] = uint64(val)
-			}
-
-		}
-	}
-
 	return nil
 }
@@ -0,0 +1,430 @@
+package exchange
+
+import (
+	"bufio"
+	"context"
+	"fmt"
+	"math/rand"
+	"time"
+
+	"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) (*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)
+		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) (*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++ {
+			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.
+			for tipsetIdx := 0; tipsetIdx < resLength; tipsetIdx++ {
+				msgs := res.Chain[tipsetIdx].Messages
+				blocksNum := len(res.Chain[tipsetIdx].Blocks)
+				if len(msgs.BlsIncludes) != blocksNum {
+					return nil, xerrors.Errorf("BlsIncludes (%d) does not match number of blocks (%d)",
+						len(msgs.BlsIncludes), blocksNum)
+				}
+				if len(msgs.SecpkIncludes) != blocksNum {
+					return nil, 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 nil, 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 nil, xerrors.Errorf("index in SecpkIncludes (%d) exceeds number of messages (%d)",
+								mi, len(msgs.Secpk))
+						}
+					}
+				}
+			}
+		}
+	}
+
+	return validRes, 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)
+	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)
+	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, head *types.TipSet, length uint64) ([]*CompactedMessages, error) {
+	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)
+	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)
+	}
+
+	// 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)
+}
@@ -0,0 +1,19 @@
+// Package exchange contains the ChainExchange server and client components.
+//
+// ChainExchange is the basic chain synchronization protocol of Filecoin.
+// ChainExchange is an RPC-oriented protocol, with a single operation to
+// request blocks for now.
+//
+// A request contains a start anchor block (referred to with a CID), and a
+// amount of blocks requested beyond the anchor (including the anchor itself).
+//
+// A client can also pass options, encoded as a 64-bit bitfield. Lotus supports
+// two options at the moment:
+//
+//  - include block contents
+//  - include block messages
+//
+// The response will include a status code, an optional message, and the
+// response payload in case of success. The payload is a slice of serialized
+// tipsets.
+package exchange
@@ -0,0 +1,51 @@
+package exchange
+
+import (
+	"context"
+
+	"github.com/libp2p/go-libp2p-core/network"
+	"github.com/libp2p/go-libp2p-core/peer"
+
+	"github.com/filecoin-project/lotus/chain/store"
+	"github.com/filecoin-project/lotus/chain/types"
+)
+
+// Server is the responder side of the ChainExchange protocol. It accepts
+// requests from clients and services them by returning the requested
+// chain data.
+type Server interface {
+	// HandleStream is the protocol handler to be registered on a libp2p
+	// protocol router.
+	//
+	// In the current version of the protocol, streams are single-use. The
+	// server will read a single Request, and will respond with a single
+	// Response. It will dispose of the stream straight after.
+	HandleStream(stream network.Stream)
+}
+
+// Client is the requesting side of the ChainExchange protocol. It acts as
+// a proxy for other components to request chain data from peers. It is chiefly
+// used by the Syncer.
+type Client interface {
+	// GetBlocks fetches block headers from the network, from the provided
+	// tipset *backwards*, returning as many tipsets as the count parameter,
+	// or less.
+	GetBlocks(ctx context.Context, tsk types.TipSetKey, count int) ([]*types.TipSet, error)
+
+	// GetChainMessages fetches messages from the network, from the provided
+	// tipset *backwards*, returning the messages from as many tipsets as the
+	// count parameter, or less.
+	GetChainMessages(ctx context.Context, head *types.TipSet, length uint64) ([]*CompactedMessages, error)
+
+	// GetFullTipSet fetches a full tipset from a given peer. If successful,
+	// the fetched object contains block headers and all messages in full form.
+	GetFullTipSet(ctx context.Context, peer peer.ID, tsk types.TipSetKey) (*store.FullTipSet, error)
+
+	// AddPeer adds a peer to the pool of peers that the Client requests
+	// data from.
+	AddPeer(peer peer.ID)
+
+	// RemovePeer removes a peer from the pool of peers that the Client
+	// requests data from.
+	RemovePeer(peer peer.ID)
+}
@@ -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)
+}
@@ -0,0 +1,205 @@
+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  = 5
+	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 {
+	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
+}
@@ -0,0 +1,247 @@
+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"
+	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()
+
+	defer stream.Close() //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
+}
@@ -8,15 +8,16 @@ import (
 	"sync/atomic"
 	"time"

+	"github.com/filecoin-project/specs-actors/actors/runtime/proof"
+
 	"github.com/filecoin-project/go-address"
-	commcid "github.com/filecoin-project/go-fil-commcid"
-	"github.com/filecoin-project/specs-actors/actors/abi"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/big"
+	"github.com/filecoin-project/go-state-types/crypto"
 	saminer "github.com/filecoin-project/specs-actors/actors/builtin/miner"
-	"github.com/filecoin-project/specs-actors/actors/crypto"
 	block "github.com/ipfs/go-block-format"
 	"github.com/ipfs/go-blockservice"
 	"github.com/ipfs/go-cid"
-	blockstore "github.com/ipfs/go-ipfs-blockstore"
 	offline "github.com/ipfs/go-ipfs-exchange-offline"
 	format "github.com/ipfs/go-ipld-format"
 	logging "github.com/ipfs/go-log/v2"
@@ -35,15 +36,21 @@ import (
 	"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"
-	"github.com/filecoin-project/sector-storage/ffiwrapper"
 )

+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
@@ -52,7 +59,7 @@ type ChainGen struct {

 	cs *store.ChainStore

-	beacon beacon.RandomBeacon
+	beacon beacon.Schedule

 	sm *stmgr.StateManager

@@ -88,9 +95,34 @@ func (m mybs) Get(c cid.Cid) (block.Block, error) {
 	return b, nil
 }

+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) {
-	saminer.SupportedProofTypes = map[abi.RegisteredProof]struct{}{
-		abi.RegisteredProof_StackedDRG2KiBSeal: {},
+	saminer.SupportedProofTypes = map[abi.RegisteredSealProof]struct{}{
+		abi.RegisteredSealProof_StackedDrg2KiBV1: {},
 	}

 	mr := repo.NewMemory(nil)
@@ -104,12 +136,12 @@ func NewGeneratorWithSectors(numSectors int) (*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 {
@@ -141,7 +173,7 @@ func NewGeneratorWithSectors(numSectors int) (*ChainGen, error) {
 		return nil, err
 	}

-	genm1, k1, err := seed.PreSeal(maddr1, abi.RegisteredProof_StackedDRG2KiBPoSt, 0, numSectors, m1temp, []byte("some randomness"), nil)
+	genm1, k1, err := seed.PreSeal(maddr1, abi.RegisteredSealProof_StackedDrg2KiBV1, 0, numSectors, m1temp, []byte("some randomness"), nil, true)
 	if err != nil {
 		return nil, err
 	}
@@ -153,7 +185,7 @@ func NewGeneratorWithSectors(numSectors int) (*ChainGen, error) {
 		return nil, err
 	}

-	genm2, k2, err := seed.PreSeal(maddr2, abi.RegisteredProof_StackedDRG2KiBPoSt, 0, numSectors, m2temp, []byte("some randomness"), nil)
+	genm2, k2, err := seed.PreSeal(maddr2, abi.RegisteredSealProof_StackedDrg2KiBV1, 0, numSectors, m2temp, []byte("some randomness"), nil, true)
 	if err != nil {
 		return nil, err
 	}
@@ -173,12 +205,12 @@ func NewGeneratorWithSectors(numSectors int) (*ChainGen, error) {
 		Accounts: []genesis.Actor{
 			{
 				Type:    genesis.TAccount,
-				Balance: types.FromFil(40000),
+				Balance: types.FromFil(20_000_000),
 				Meta:    (&genesis.AccountMeta{Owner: mk1}).ActorMeta(),
 			},
 			{
 				Type:    genesis.TAccount,
-				Balance: types.FromFil(40000),
+				Balance: types.FromFil(20_000_000),
 				Meta:    (&genesis.AccountMeta{Owner: mk2}).ActorMeta(),
 			},
 			{
@@ -191,8 +223,10 @@ func NewGeneratorWithSectors(numSectors int) (*ChainGen, error) {
 			*genm1,
 			*genm2,
 		},
-		NetworkName: "",
-		Timestamp:   uint64(time.Now().Add(-500 * build.BlockDelay * time.Second).Unix()),
+		VerifregRootKey:  DefaultVerifregRootkeyActor,
+		RemainderAccount: DefaultRemainderAccountActor,
+		NetworkName:      "",
+		Timestamp:        uint64(build.Clock.Now().Add(-500 * time.Duration(build.BlockDelaySecs) * time.Second).Unix()),
 	}

 	genb, err := genesis2.MakeGenesisBlock(context.TODO(), bs, sys, tpl)
@@ -218,7 +252,11 @@ func NewGeneratorWithSectors(numSectors int) (*ChainGen, error) {

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

-	beac := beacon.NewMockBeacon(time.Second)
+	beac := beacon.Schedule{{Start: 0, Beacon: beacon.NewMockBeacon(time.Second)}}
+	//beac, err := drand.NewDrandBeacon(tpl.Timestamp, build.BlockDelaySecs)
+	//if err != nil {
+	//return nil, xerrors.Errorf("creating drand beacon: %w", err)
+	//}

 	gen := &ChainGen{
 		bs:           bs,
@@ -248,6 +286,10 @@ 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
 }
@@ -276,7 +318,8 @@ func (cg *ChainGen) GenesisCar() ([]byte, error) {

 func CarWalkFunc(nd format.Node) (out []*format.Link, err error) {
 	for _, link := range nd.Links() {
-		if link.Cid.Prefix().MhType == uint64(commcid.FC_SEALED_V1) || link.Cid.Prefix().MhType == uint64(commcid.FC_UNSEALED_V1) {
+		pref := link.Cid.Prefix()
+		if pref.Codec == cid.FilCommitmentSealed || pref.Codec == cid.FilCommitmentUnsealed {
 			continue
 		}
 		out = append(out, link)
@@ -295,7 +338,7 @@ func (cg *ChainGen) nextBlockProof(ctx context.Context, pts *types.TipSet, m add

 	prev := mbi.PrevBeaconEntry

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

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

@@ -354,16 +397,37 @@ 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.GetMessages(cg)
+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)
 	}

+	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 _, m := range miners {
+		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)
@@ -376,7 +440,7 @@ func (cg *ChainGen) NextTipSetFromMiners(base *types.TipSet, miners []address.Ad
 					return nil, err
 				}

-				fblk, err := cg.makeBlock(base, m, ticket, et, bvals, round, wpost, msgs)
+				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)
 				}
@@ -390,23 +454,18 @@ 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, vrfticket *types.Ticket,
 	eticket *types.ElectionProof, bvals []types.BeaconEntry, height abi.ChainEpoch,
-	wpost []abi.PoStProof, msgs []*types.SignedMessage) (*types.FullBlock, error) {
+	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() + uint64((height-parents.Height())*build.BlockDelay)
+		ts = parents.MinTimestamp() + uint64(height-parents.Height())*build.BlockDelaySecs
 	}

 	fblk, err := MinerCreateBlock(context.TODO(), cg.sm, cg.w, &api.BlockTemplate{
@@ -427,10 +486,11 @@ func (cg *ChainGen) makeBlock(parents *types.TipSet, m address.Address, vrfticke
 	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)
+	var act types.Actor
+	err := cg.sm.WithParentState(ts, cg.sm.WithActor(cg.banker, stmgr.GetActor(&act)))
 	if err != nil {
 		return err
 	}
@@ -460,8 +520,9 @@ func getRandomMessages(cg *ChainGen) ([]*types.SignedMessage, error) {

 			Method: 0,

-			GasLimit: 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())
@@ -486,7 +547,8 @@ func (cg *ChainGen) YieldRepo() (repo.Repo, error) {
 }

 type MiningCheckAPI interface {
-	ChainGetRandomness(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)
+	ChainGetRandomnessFromTickets(ctx context.Context, tsk types.TipSetKey, personalization crypto.DomainSeparationTag, randEpoch abi.ChainEpoch, entropy []byte) (abi.Randomness, error)

 	MinerGetBaseInfo(context.Context, address.Address, abi.ChainEpoch, types.TipSetKey) (*api.MiningBaseInfo, error)

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

-func (mca mca) ChainGetRandomness(ctx context.Context, tsk types.TipSetKey, personalization crypto.DomainSeparationTag, randEpoch abi.ChainEpoch, entropy []byte) (abi.Randomness, error) {
+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 nil, xerrors.Errorf("loading tipset key: %w", err)
 	}

-	return mca.sm.ChainStore().GetRandomness(ctx, pts.Cids(), personalization, randEpoch, entropy)
+	return mca.sm.ChainStore().GetChainRandomness(ctx, pts.Cids(), personalization, randEpoch, entropy)
+}
+
+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) MinerGetBaseInfo(ctx context.Context, maddr address.Address, epoch abi.ChainEpoch, tsk types.TipSetKey) (*api.MiningBaseInfo, error) {
@@ -519,7 +590,7 @@ func (mca mca) WalletSign(ctx context.Context, a address.Address, v []byte) (*cr

 type WinningPoStProver interface {
 	GenerateCandidates(context.Context, abi.PoStRandomness, uint64) ([]uint64, error)
-	ComputeProof(context.Context, []abi.SectorInfo, abi.PoStRandomness) ([]abi.PoStProof, error)
+	ComputeProof(context.Context, []proof.SectorInfo, abi.PoStRandomness) ([]proof.PoStProof, error)
 }

 type wppProvider struct{}
@@ -528,17 +599,8 @@ func (wpp *wppProvider) GenerateCandidates(ctx context.Context, _ abi.PoStRandom
 	return []uint64{0}, nil
 }

-func (wpp *wppProvider) ComputeProof(context.Context, []abi.SectorInfo, abi.PoStRandomness) ([]abi.PoStProof, error) {
-	return []abi.PoStProof{{
-		ProofBytes: []byte("valid proof"),
-	}}, nil
-}
-
-type ProofInput struct {
-	sectors           []abi.SectorInfo
-	hvrf              []byte
-	challengedSectors []uint64
-	vrfout            []byte
+func (wpp *wppProvider) ComputeProof(context.Context, []proof.SectorInfo, abi.PoStRandomness) ([]proof.PoStProof, error) {
+	return ValidWpostForTesting, nil
 }

 func IsRoundWinner(ctx context.Context, ts *types.TipSet, round abi.ChainEpoch,
@@ -546,7 +608,7 @@ func IsRoundWinner(ctx context.Context, ts *types.TipSet, round abi.ChainEpoch,

 	buf := new(bytes.Buffer)
 	if err := miner.MarshalCBOR(buf); err != nil {
-		return nil, xerrors.Errorf("failed to cbor marshal address: %w")
+		return nil, xerrors.Errorf("failed to cbor marshal address: %w", err)
 	}

 	electionRand, err := store.DrawRandomness(brand.Data, crypto.DomainSeparationTag_ElectionProofProduction, round, buf.Bytes())
@@ -559,12 +621,14 @@ func IsRoundWinner(ctx context.Context, ts *types.TipSet, round abi.ChainEpoch,
 		return nil, xerrors.Errorf("failed to compute VRF: %w", err)
 	}

-	// TODO: wire in real power
-	if !types.IsTicketWinner(vrfout, mbi.MinerPower, mbi.NetworkPower) {
+	ep := &types.ElectionProof{VRFProof: vrfout}
+	j := ep.ComputeWinCount(mbi.MinerPower, mbi.NetworkPower)
+	ep.WinCount = j
+	if j < 1 {
 		return nil, nil
 	}

-	return &types.ElectionProof{VRFProof: vrfout}, nil
+	return ep, nil
 }

 type SignFunc func(context.Context, address.Address, []byte) (*crypto.Signature, error)
@@ -602,18 +666,18 @@ type genFakeVerifier struct{}

 var _ ffiwrapper.Verifier = (*genFakeVerifier)(nil)

-func (m genFakeVerifier) VerifySeal(svi abi.SealVerifyInfo) (bool, error) {
+func (m genFakeVerifier) VerifySeal(svi proof.SealVerifyInfo) (bool, error) {
 	return true, nil
 }

-func (m genFakeVerifier) VerifyWinningPoSt(ctx context.Context, info abi.WinningPoStVerifyInfo) (bool, error) {
+func (m genFakeVerifier) VerifyWinningPoSt(ctx context.Context, info proof.WinningPoStVerifyInfo) (bool, error) {
 	panic("not supported")
 }

-func (m genFakeVerifier) VerifyWindowPoSt(ctx context.Context, info abi.WindowPoStVerifyInfo) (bool, error) {
+func (m genFakeVerifier) VerifyWindowPoSt(ctx context.Context, info proof.WindowPoStVerifyInfo) (bool, error) {
 	panic("not supported")
 }

-func (m genFakeVerifier) GenerateWinningPoStSectorChallenge(ctx context.Context, proof abi.RegisteredProof, id abi.ActorID, randomness abi.PoStRandomness, u uint64) ([]uint64, error) {
+func (m genFakeVerifier) GenerateWinningPoStSectorChallenge(ctx context.Context, proof abi.RegisteredPoStProof, id abi.ActorID, randomness abi.PoStRandomness, u uint64) ([]uint64, error) {
 	panic("not supported")
 }
@@ -3,8 +3,8 @@ package gen
 import (
 	"testing"

-	"github.com/filecoin-project/specs-actors/actors/abi"
-	"github.com/filecoin-project/specs-actors/actors/abi/big"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/go-state-types/big"
 	"github.com/filecoin-project/specs-actors/actors/builtin/miner"
 	"github.com/filecoin-project/specs-actors/actors/builtin/power"
 	"github.com/filecoin-project/specs-actors/actors/builtin/verifreg"
@@ -14,8 +14,8 @@ import (
 )

 func init() {
-	miner.SupportedProofTypes = map[abi.RegisteredProof]struct{}{
-		abi.RegisteredProof_StackedDRG2KiBSeal: {},
+	miner.SupportedProofTypes = map[abi.RegisteredSealProof]struct{}{
+		abi.RegisteredSealProof_StackedDrg2KiBV1: {},
 	}
 	power.ConsensusMinerMinPower = big.NewInt(2048)
 	verifreg.MinVerifiedDealSize = big.NewInt(256)
@@ -39,8 +39,8 @@ func testGeneration(t testing.TB, n int, msgs int, sectors int) {
 }

 func TestChainGeneration(t *testing.T) {
-	testGeneration(t, 10, 20, 1)
-	testGeneration(t, 10, 20, 25)
+	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) {
@@ -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
+}
@@ -2,28 +2,37 @@ package genesis

 import (
 	"context"
+	"crypto/rand"
 	"encoding/json"
+	"fmt"
+
+	"github.com/filecoin-project/go-state-types/network"

-	"github.com/filecoin-project/go-amt-ipld/v2"
-	"github.com/filecoin-project/specs-actors/actors/abi"
-	"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/verifreg"
-	"github.com/filecoin-project/specs-actors/actors/runtime"
 	"github.com/ipfs/go-cid"
 	"github.com/ipfs/go-datastore"
-	bstore "github.com/ipfs/go-ipfs-blockstore"
 	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"
+	"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/multisig"
+	"github.com/filecoin-project/specs-actors/actors/builtin/verifreg"
+	"github.com/filecoin-project/specs-actors/actors/util/adt"
+
+	"github.com/filecoin-project/lotus/build"
 	"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
@@ -59,8 +68,15 @@ The process:
      - power.CreateMiner, set msg value to PowerBalance
      - market.AddFunds with correct value
      - market.PublishDeals for related sectors
-      - Set precommits
-      - Commit presealed 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:

@@ -91,184 +107,354 @@ Genesis: {

 */

-func MakeInitialStateTree(ctx context.Context, bs bstore.Blockstore, template genesis.Template) (*state.StateTree, error) {
+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, xerrors.Errorf("putting empty object: %w", err)
+		return nil, nil, xerrors.Errorf("putting empty object: %w", err)
 	}

 	state, err := state.NewStateTree(cst)
 	if err != nil {
-		return nil, xerrors.Errorf("making new state tree: %w", err)
-	}
-
-	emptyobject, err := cst.Put(context.TODO(), []struct{}{})
-	if err != nil {
-		return nil, xerrors.Errorf("failed putting empty object: %w", err)
+		return nil, nil, xerrors.Errorf("making new state tree: %w", err)
 	}

 	// Create system actor

 	sysact, err := SetupSystemActor(bs)
 	if err != nil {
-		return nil, xerrors.Errorf("setup init actor: %w", err)
+		return nil, nil, xerrors.Errorf("setup init actor: %w", err)
 	}
 	if err := state.SetActor(builtin.SystemActorAddr, sysact); err != nil {
-		return nil, xerrors.Errorf("set init actor: %w", err)
+		return nil, nil, xerrors.Errorf("set init actor: %w", err)
 	}

 	// Create init actor

-	initact, err := SetupInitActor(bs, template.NetworkName, template.Accounts)
+	idStart, initact, keyIDs, err := SetupInitActor(bs, template.NetworkName, template.Accounts, template.VerifregRootKey)
 	if err != nil {
-		return nil, xerrors.Errorf("setup init actor: %w", err)
+		return nil, nil, xerrors.Errorf("setup init actor: %w", err)
 	}
 	if err := state.SetActor(builtin.InitActorAddr, initact); err != nil {
-		return nil, xerrors.Errorf("set init actor: %w", err)
+		return nil, nil, xerrors.Errorf("set init actor: %w", err)
 	}

 	// Setup reward
-	rewact, err := SetupRewardActor(bs)
+	// RewardActor's state is overrwritten by SetupStorageMiners
+	rewact, err := SetupRewardActor(bs, big.Zero())
 	if err != nil {
-		return nil, xerrors.Errorf("setup init actor: %w", err)
+		return nil, nil, xerrors.Errorf("setup init actor: %w", err)
 	}

 	err = state.SetActor(builtin.RewardActorAddr, rewact)
 	if err != nil {
-		return nil, xerrors.Errorf("set network account actor: %w", err)
+		return nil, nil, xerrors.Errorf("set network account actor: %w", err)
 	}

 	// Setup cron
 	cronact, err := SetupCronActor(bs)
 	if err != nil {
-		return nil, xerrors.Errorf("setup cron actor: %w", err)
+		return nil, nil, xerrors.Errorf("setup cron actor: %w", err)
 	}
 	if err := state.SetActor(builtin.CronActorAddr, cronact); err != nil {
-		return nil, xerrors.Errorf("set cron actor: %w", err)
+		return nil, nil, xerrors.Errorf("set cron actor: %w", err)
 	}

 	// Create empty power actor
 	spact, err := SetupStoragePowerActor(bs)
 	if err != nil {
-		return nil, xerrors.Errorf("setup storage market actor: %w", err)
+		return nil, nil, xerrors.Errorf("setup storage market actor: %w", err)
 	}
 	if err := state.SetActor(builtin.StoragePowerActorAddr, spact); err != nil {
-		return nil, xerrors.Errorf("set storage market actor: %w", err)
+		return nil, nil, xerrors.Errorf("set storage market actor: %w", err)
 	}

 	// Create empty market actor
 	marketact, err := SetupStorageMarketActor(bs)
 	if err != nil {
-		return nil, xerrors.Errorf("setup storage market actor: %w", err)
+		return nil, nil, xerrors.Errorf("setup storage market actor: %w", err)
 	}
 	if err := state.SetActor(builtin.StorageMarketActorAddr, marketact); err != nil {
-		return nil, xerrors.Errorf("set market actor: %w", err)
+		return nil, nil, xerrors.Errorf("set market actor: %w", err)
 	}

 	// Create verified registry
 	verifact, err := SetupVerifiedRegistryActor(bs)
 	if err != nil {
-		return nil, xerrors.Errorf("setup storage market actor: %w", err)
+		return nil, nil, xerrors.Errorf("setup storage market actor: %w", err)
 	}
 	if err := state.SetActor(builtin.VerifiedRegistryActorAddr, verifact); err != nil {
-		return nil, xerrors.Errorf("set market actor: %w", err)
+		return nil, nil, xerrors.Errorf("set market actor: %w", err)
+	}
+
+	burntRoot, err := cst.Put(ctx, &account.State{
+		Address: builtin.BurntFundsActorAddr,
+	})
+	if err != nil {
+		return nil, nil, xerrors.Errorf("failed to setup burnt funds actor state: %w", err)
 	}

 	// Setup burnt-funds
 	err = state.SetActor(builtin.BurntFundsActorAddr, &types.Actor{
 		Code:    builtin.AccountActorCodeID,
 		Balance: types.NewInt(0),
-		Head:    emptyobject,
+		Head:    burntRoot,
 	})
 	if err != nil {
-		return nil, xerrors.Errorf("set burnt funds account actor: %w", err)
+		return nil, nil, xerrors.Errorf("set burnt funds account actor: %w", err)
 	}

 	// Create accounts
-	for id, info := range template.Accounts {
-		if info.Type != genesis.TAccount {
-			return nil, xerrors.New("unsupported account type") // TODO: msigs
+	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")
 		}

-		ida, err := address.NewIDAddress(uint64(AccountStart + id))
-		if err != nil {
-			return nil, err
-		}
-
-		var ainfo genesis.AccountMeta
-		if err := json.Unmarshal(info.Meta, &ainfo); err != nil {
-			return nil, xerrors.Errorf("unmarshaling account meta: %w", err)
-		}
-
-		st, err := cst.Put(ctx, &account.State{Address: ainfo.Owner})
-		if err != nil {
-			return nil, err
-		}
-
-		err = state.SetActor(ida, &types.Actor{
-			Code:    builtin.AccountActorCodeID,
-			Balance: info.Balance,
-			Head:    st,
-		})
-		if err != nil {
-			return nil, xerrors.Errorf("setting account from actmap: %w", err)
-		}
 	}

 	vregroot, err := address.NewIDAddress(80)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}

-	vrst, err := cst.Put(ctx, &account.State{Address: RootVerifierAddr})
+	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, err
+		return nil, nil, xerrors.Errorf("creating random verifier secret key: %w", err)
 	}

-	err = state.SetActor(vregroot, &types.Actor{
+	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, &account.State{Address: verifierAd})
+	if err != nil {
+		return nil, nil, err
+	}
+
+	err = state.SetActor(verifierId, &types.Actor{
 		Code:    builtin.AccountActorCodeID,
 		Balance: types.NewInt(0),
-		Head:    vrst,
+		Head:    verifierState,
 	})
-
 	if err != nil {
-		return nil, xerrors.Errorf("setting account from actmap: %w", err)
+		return nil, nil, xerrors.Errorf("setting account from actmap: %w", err)
 	}

-	return state, nil
+	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 VerifyPreSealedData(ctx context.Context, cs *store.ChainStore, stateroot cid.Cid, template genesis.Template) (cid.Cid, error) {
+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, &account.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:    builtin.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 := adt.MakeEmptyMap(adt.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, &account.State{Address: e})
+		if err != nil {
+			return err
+		}
+		err = state.SetActor(idAddress, &types.Actor{
+			Code:    builtin.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, &multisig.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:    builtin.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
-	for _, m := range template.Miners {
-		for _, s := range m.Sectors {
-			amt := s.Deal.PieceSize
-			verifNeeds[s.Deal.Client] += amt
-			sum += amt
-		}
+
+	nwv := func(context.Context, abi.ChainEpoch) network.Version {
+		return build.NewestNetworkVersion
 	}

-	verifier, err := address.NewIDAddress(80)
-	if err != nil {
-		return cid.Undef, err
+	vmopt := vm.VMOpts{
+		StateBase:      stateroot,
+		Epoch:          0,
+		Rand:           &fakeRand{},
+		Bstore:         cs.Blockstore(),
+		Syscalls:       mkFakedSigSyscalls(cs.VMSys()),
+		CircSupplyCalc: nil,
+		NtwkVersion:    nwv,
+		BaseFee:        types.NewInt(0),
 	}
-
-	vm, err := vm.NewVM(stateroot, 0, &fakeRand{}, cs.Blockstore(), &fakedSigSyscalls{cs.VMSys()})
+	vm, err := vm.NewVM(&vmopt)
 	if err != nil {
 		return cid.Undef, xerrors.Errorf("failed to create NewVM: %w", err)
 	}

-	_, err = doExecValue(ctx, vm, builtin.VerifiedRegistryActorAddr, RootVerifierAddr, types.NewInt(0), builtin.MethodsVerifiedRegistry.AddVerifier, mustEnc(&verifreg.AddVerifierParams{
+	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, builtin.VerifiedRegistryActorAddr, verifregRoot, types.NewInt(0), builtin.MethodsVerifiedRegistry.AddVerifier, mustEnc(&verifreg.AddVerifierParams{
+
 		Address:   verifier,
 		Allowance: abi.NewStoragePower(int64(sum)), // eh, close enough

 	}))
 	if err != nil {
-		return cid.Undef, xerrors.Errorf("failed to failed to create verifier: %w", err)
+		return cid.Undef, xerrors.Errorf("failed to create verifier: %w", err)
 	}

 	for c, amt := range verifNeeds {
@@ -281,11 +467,16 @@ func VerifyPreSealedData(ctx context.Context, cs *store.ChainStore, stateroot ci
 		}
 	}

-	return vm.Flush(ctx)
+	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 runtime.Syscalls, template genesis.Template) (*GenesisBootstrap, error) {
-	st, err := MakeInitialStateTree(ctx, bs, template)
+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)
 	}
@@ -299,19 +490,18 @@ func MakeGenesisBlock(ctx context.Context, bs bstore.Blockstore, sys runtime.Sys
 	cs := store.NewChainStore(bs, datastore.NewMapDatastore(), sys)

 	// Verify PreSealed Data
-	stateroot, err = VerifyPreSealedData(ctx, cs, stateroot, template)
+	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 storage miners failed: %w", err)
+		return nil, xerrors.Errorf("setup miners failed: %w", err)
 	}

-	cst := cbor.NewCborStore(bs)
-
-	emptyroot, err := amt.FromArray(ctx, cst, nil)
+	store := adt.WrapStore(ctx, cbor.NewCborStore(bs))
+	emptyroot, err := adt.MakeEmptyArray(store).Root()
 	if err != nil {
 		return nil, xerrors.Errorf("amt build failed: %w", err)
 	}
@@ -330,14 +520,38 @@ func MakeGenesisBlock(ctx context.Context, bs bstore.Blockstore, sys runtime.Sys

 	log.Infof("Empty Genesis root: %s", emptyroot)

+	tickBuf := make([]byte, 32)
+	_, _ = rand.Read(tickBuf)
 	genesisticket := &types.Ticket{
-		VRFProof: []byte("vrf proof0000000vrf proof0000000"),
+		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:                 builtin.SystemActorAddr,
 		Ticket:                genesisticket,
-		Parents:               []cid.Cid{},
+		Parents:               []cid.Cid{filecoinGenesisCid},
 		Height:                0,
 		ParentWeight:          types.NewInt(0),
 		ParentStateRoot:       stateroot,
@@ -353,6 +567,7 @@ func MakeGenesisBlock(ctx context.Context, bs bstore.Blockstore, sys runtime.Sys
 				Data:  make([]byte, 32),
 			},
 		},
+		ParentBaseFee: abi.NewTokenAmount(build.InitialBaseFee),
 	}

 	sb, err := b.ToStorageBlock()
@@ -6,23 +6,29 @@ import (
 	"fmt"
 	"math/rand"

+	"github.com/filecoin-project/lotus/build"
+
+	"github.com/filecoin-project/go-state-types/network"
+
+	"github.com/filecoin-project/lotus/chain/state"
+
 	"github.com/ipfs/go-cid"
 	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/sector-storage/ffiwrapper"
-	"github.com/filecoin-project/specs-actors/actors/abi"
-	"github.com/filecoin-project/specs-actors/actors/abi/big"
+	"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"
 	"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/crypto"
+	"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"
@@ -46,8 +52,35 @@ func (fss *fakedSigSyscalls) VerifySignature(signature crypto.Signature, signer
 	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) {
-	vm, err := vm.NewVM(sroot, 0, &fakeRand{}, cs.Blockstore(), &fakedSigSyscalls{cs.VMSys()})
+	csc := func(context.Context, abi.ChainEpoch, *state.StateTree) (abi.TokenAmount, error) {
+		return big.Zero(), nil
+	}
+
+	nwv := func(context.Context, abi.ChainEpoch) network.Version {
+		return build.NewestNetworkVersion
+	}
+
+	vmopt := &vm.VMOpts{
+		StateBase:      sroot,
+		Epoch:          0,
+		Rand:           &fakeRand{},
+		Bstore:         cs.Blockstore(),
+		Syscalls:       mkFakedSigSyscalls(cs.VMSys()),
+		CircSupplyCalc: csc,
+		NtwkVersion:    nwv,
+		BaseFee:        types.NewInt(0),
+	}
+
+	vm, err := vm.NewVM(vmopt)
 	if err != nil {
 		return cid.Undef, xerrors.Errorf("failed to create NewVM: %w", err)
 	}
@@ -56,20 +89,29 @@ func SetupStorageMiners(ctx context.Context, cs *store.ChainStore, sroot cid.Cid
 		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
 		}

-		var maddr address.Address
 		{
 			constructorParams := &power.CreateMinerParams{
 				Owner:         m.Worker,
 				Worker:        m.Worker,
-				Peer:          m.PeerId,
+				Peer:          []byte(m.PeerId),
 				SealProofType: spt,
 			}

@@ -88,49 +130,52 @@ func SetupStorageMiners(ctx context.Context, cs *store.ChainStore, sroot cid.Cid
 			if ma.IDAddress != expma {
 				return cid.Undef, xerrors.Errorf("miner assigned wrong address: %s != %s", ma.IDAddress, expma)
 			}
-			maddr = ma.IDAddress
+			minerInfos[i].maddr = ma.IDAddress
+
+			err = vm.MutateState(ctx, minerInfos[i].maddr, func(cst cbor.IpldStore, st *miner.State) error {
+				maxPeriods := miner.MaxSectorExpirationExtension / miner.WPoStProvingPeriod
+				minerInfos[i].presealExp = (maxPeriods-1)*miner.WPoStProvingPeriod + st.ProvingPeriodStart - 1
+
+				return nil
+			})
+			if err != nil {
+				return cid.Undef, xerrors.Errorf("mutating state: %w", err)
+			}
 		}

 		// Add market funds

-		{
-			params := mustEnc(&maddr)
+		if m.MarketBalance.GreaterThan(big.Zero()) {
+			params := mustEnc(&minerInfos[i].maddr)
 			_, err := doExecValue(ctx, vm, builtin.StorageMarketActorAddr, m.Worker, m.MarketBalance, builtin.MethodsMarket.AddBalance, params)
 			if err != nil {
-				return cid.Undef, xerrors.Errorf("failed to create genesis miner: %w", err)
-			}
-		}
-		{
-			params := mustEnc(&m.Worker)
-			_, err := doExecValue(ctx, vm, builtin.StorageMarketActorAddr, m.Worker, big.Zero(), builtin.MethodsMarket.AddBalance, params)
-			if err != nil {
-				return cid.Undef, xerrors.Errorf("failed to create genesis miner: %w", err)
+				return cid.Undef, xerrors.Errorf("failed to create genesis miner (add balance): %w", err)
 			}
 		}

 		// Publish preseal deals

-		var dealIDs []abi.DealID
 		{
 			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, builtin.StorageMarketActorAddr, m.Worker, big.Zero(), builtin.MethodsMarket.PublishStorageDeals, mustEnc(params))
 				if err != nil {
-					return xerrors.Errorf("failed to create genesis miner: %w", err)
+					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)
 				}

-				dealIDs = append(dealIDs, ids.IDs...)
+				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?
@@ -151,94 +196,136 @@ func SetupStorageMiners(ctx context.Context, cs *store.ChainStore, sroot cid.Cid
 				}
 			}
 		}
+	}

-		// Commit sectors
-		for pi, preseal := range m.Sectors {
-			// TODO: Maybe check seal (Can just be snark inputs, doesn't go into the genesis file)
+	// 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)))

-			// check deals, get dealWeight
-			var dealWeight market.VerifyDealsOnSectorProveCommitReturn
-			{
-				params := &market.VerifyDealsOnSectorProveCommitParams{
-					DealIDs:      []abi.DealID{dealIDs[pi]},
-					SectorExpiry: preseal.Deal.EndEpoch,
-				}
-
-				ret, err := doExecValue(ctx, vm, builtin.StorageMarketActorAddr, maddr, big.Zero(), builtin.MethodsMarket.VerifyDealsOnSectorProveCommit, mustEnc(params))
+				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("failed to verify preseal deals miner: %w", err)
-				}
-				if err := dealWeight.UnmarshalCBOR(bytes.NewReader(ret)); err != nil {
-					return cid.Undef, xerrors.Errorf("unmarshaling market onProveCommit result: %w", err)
-				}
-			}
-
-			// update power claims
-			{
-				err = vm.MutateState(ctx, builtin.StoragePowerActorAddr, func(cst cbor.IpldStore, st *power.State) error {
-					weight := &power.SectorStorageWeightDesc{
-						SectorSize:         m.SectorSize,
-						Duration:           preseal.Deal.Duration(),
-						DealWeight:         dealWeight.DealWeight,
-						VerifiedDealWeight: dealWeight.VerifiedDealWeight,
-					}
-
-					qapower := power.QAPowerForWeight(weight)
-
-					err := st.AddToClaim(&state.AdtStore{cst}, maddr, types.NewInt(uint64(weight.SectorSize)), qapower)
-					if err != nil {
-						return xerrors.Errorf("add to claim: %w", err)
-					}
-					fmt.Println("Added weight to claim: ", st.TotalRawBytePower, st.TotalQualityAdjPower)
-					return nil
-				})
-				if err != nil {
-					return cid.Undef, xerrors.Errorf("register power claim in power actor: %w", err)
-				}
-			}
-
-			// Put sectors to miner sector sets
-			{
-				newSectorInfo := &miner.SectorOnChainInfo{
-					Info: miner.SectorPreCommitInfo{
-						RegisteredProof: preseal.ProofType,
-						SectorNumber:    preseal.SectorID,
-						SealedCID:       preseal.CommR,
-						SealRandEpoch:   0,
-						DealIDs:         []abi.DealID{dealIDs[pi]},
-						Expiration:      preseal.Deal.EndEpoch,
-					},
-					ActivationEpoch:    0,
-					DealWeight:         dealWeight.DealWeight,
-					VerifiedDealWeight: dealWeight.VerifiedDealWeight,
+					return cid.Undef, xerrors.Errorf("getting deal weight: %w", err)
 				}

-				err = vm.MutateState(ctx, maddr, func(cst cbor.IpldStore, st *miner.State) error {
-					store := &state.AdtStore{cst}
+				sectorWeight := miner.QAPowerForWeight(m.SectorSize, minerInfos[i].presealExp, dweight.DealWeight, dweight.VerifiedDealWeight)

-					if err = st.PutSector(store, newSectorInfo); err != nil {
-						return xerrors.Errorf("failed to put sector: %v", err)
-					}
-
-					if err := st.AddNewSectors(newSectorInfo.Info.SectorNumber); err != nil {
-						return xerrors.Errorf("failed to add NewSector: %w", err)
-					}
-
-					return nil
-				})
-				if err != nil {
-					return cid.Cid{}, xerrors.Errorf("put to sset: %w", err)
-				}
+				qaPow = types.BigAdd(qaPow, sectorWeight)
 			}
 		}

+		err = vm.MutateState(ctx, builtin.StoragePowerActorAddr, func(cst cbor.IpldStore, st *power.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, builtin.RewardActorAddr, func(sct cbor.IpldStore, st *reward.State) error {
+			*st = *reward.ConstructState(qaPow)
+			return nil
+		})
+		if err != nil {
+			return cid.Undef, xerrors.Errorf("mutating state: %w", err)
+		}
 	}

-	// TODO: to avoid division by zero, we set the initial power actor power to 1, this adjusts that back down so the accounting is accurate.
+	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 := miner.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, builtin.StoragePowerActorAddr, func(cst cbor.IpldStore, st *power.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 := miner.PreCommitDepositForPower(epochReward.ThisEpochRewardSmoothed, tpow.QualityAdjPowerSmoothed, sectorWeight)
+
+				pledge := miner.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, builtin.StoragePowerActorAddr, 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, builtin.StoragePowerActorAddr, func(cst cbor.IpldStore, st *power.State) error {
-		st.TotalQualityAdjPower = big.Sub(st.TotalQualityAdjPower, big.NewInt(1))
+		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 {
@@ -250,8 +337,76 @@ func SetupStorageMiners(ctx context.Context, cs *store.ChainStore, sroot cid.Cid
 // TODO: copied from actors test harness, deduplicate or remove from here
 type fakeRand struct{}

-func (fr *fakeRand) GetRandomness(ctx context.Context, personalization crypto.DomainSeparationTag, randEpoch abi.ChainEpoch, entropy []byte) ([]byte, error) {
+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))).Read(out)
+	_, _ = 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) (*power.CurrentTotalPowerReturn, error) {
+	pwret, err := doExecValue(ctx, vm, builtin.StoragePowerActorAddr, maddr, big.Zero(), builtin.MethodsPower.CurrentTotalPower, nil)
+	if err != nil {
+		return nil, err
+	}
+	var pwr power.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) (market.VerifyDealsForActivationReturn, error) {
+	params := &market.VerifyDealsForActivationParams{
+		DealIDs:      dealIDs,
+		SectorStart:  sectorStart,
+		SectorExpiry: sectorExpiry,
+	}
+
+	var dealWeights market.VerifyDealsForActivationReturn
+	ret, err := doExecValue(ctx, vm,
+		builtin.StorageMarketActorAddr,
+		maddr,
+		abi.NewTokenAmount(0),
+		builtin.MethodsMarket.VerifyDealsForActivation,
+		mustEnc(params),
+	)
+	if err != nil {
+		return market.VerifyDealsForActivationReturn{}, err
+	}
+	if err := dealWeights.UnmarshalCBOR(bytes.NewReader(ret)); err != nil {
+		return market.VerifyDealsForActivationReturn{}, err
+	}
+
+	return dealWeights, nil
+}
+
+func currentEpochBlockReward(ctx context.Context, vm *vm.VM, maddr address.Address) (*reward.ThisEpochRewardReturn, error) {
+	rwret, err := doExecValue(ctx, vm, builtin.RewardActorAddr, maddr, big.Zero(), builtin.MethodsReward.ThisEpochReward, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	var epochReward reward.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()
+}
@@ -2,12 +2,14 @@ package genesis

 import (
 	"context"
+
 	"github.com/filecoin-project/specs-actors/actors/builtin/system"

-	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/specs-actors/actors/builtin"
-	bstore "github.com/ipfs/go-ipfs-blockstore"
 	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) {
@@ -5,64 +5,134 @@ import (
 	"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"
-	"github.com/ipfs/go-hamt-ipld"
-	bstore "github.com/ipfs/go-ipfs-blockstore"
 	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) (*types.Actor, error) {
+func SetupInitActor(bs bstore.Blockstore, netname string, initialActors []genesis.Actor, rootVerifier genesis.Actor) (int64, *types.Actor, map[address.Address]address.Address, error) {
 	if len(initialActors) > MaxAccounts {
-		return nil, xerrors.New("too many initial actors")
+		return 0, nil, nil, xerrors.New("too many initial actors")
 	}

 	var ias init_.State
 	ias.NextID = MinerStart
 	ias.NetworkName = netname

-	cst := cbor.NewCborStore(bs)
-	amap := hamt.NewNode(cst, hamt.UseTreeBitWidth(5)) // TODO: use spec adt map
+	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
+		}

-	for i, a := range initialActors {
 		if a.Type != genesis.TAccount {
-			return nil, xerrors.Errorf("unsupported account type: %s", a.Type) // TODO: Support msig (skip here)
+			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 nil, xerrors.Errorf("unmarshaling account meta: %w", err)
+			return 0, nil, nil, xerrors.Errorf("unmarshaling account meta: %w", err)
 		}

-		fmt.Printf("init set %s t0%d\n", ainfo.Owner, AccountStart+uint64(i))
+		fmt.Printf("init set %s t0%d\n", ainfo.Owner, counter)

-		if err := amap.Set(context.TODO(), string(ainfo.Owner.Bytes()), AccountStart+uint64(i)); err != nil {
-			return nil, err
+		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 err := amap.Set(context.TODO(), string(RootVerifierAddr.Bytes()), 80); err != nil {
-		return 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
+			}
+
+		}
 	}

-	if err := amap.Flush(context.TODO()); err != nil {
-		return nil, err
-	}
-	amapcid, err := cst.Put(context.TODO(), amap)
+	amapaddr, err := amap.Root()
 	if err != nil {
-		return nil, err
+		return 0, nil, nil, err
 	}
+	ias.AddressMap = amapaddr

-	ias.AddressMap = amapcid
-
-	statecid, err := cst.Put(context.TODO(), &ias)
+	statecid, err := store.Put(store.Context(), &ias)
 	if err != nil {
-		return nil, err
+		return 0, nil, nil, err
 	}

 	act := &types.Actor{
@@ -70,5 +140,5 @@ func SetupInitActor(bs bstore.Blockstore, netname string, initialActors []genesi
 		Head: statecid,
 	}

-	return act, nil
+	return counter, act, keyToId, nil
 }
@@ -3,19 +3,21 @@ package genesis
 import (
 	"context"

-	"github.com/filecoin-project/lotus/build"
-	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/go-state-types/big"
+
 	"github.com/filecoin-project/specs-actors/actors/builtin"
 	"github.com/filecoin-project/specs-actors/actors/builtin/reward"
-	bstore "github.com/ipfs/go-ipfs-blockstore"
 	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) (*types.Actor, error) {
+func SetupRewardActor(bs bstore.Blockstore, qaPower big.Int) (*types.Actor, error) {
 	cst := cbor.NewCborStore(bs)

-	st := reward.ConstructState()
-	st.LastPerEpochReward = types.FromFil(100)
+	st := reward.ConstructState(qaPower)

 	hcid, err := cst.Put(context.TODO(), st)
 	if err != nil {
@@ -5,10 +5,10 @@ import (

 	"github.com/filecoin-project/specs-actors/actors/builtin"
 	"github.com/filecoin-project/specs-actors/actors/builtin/cron"
-	bstore "github.com/ipfs/go-ipfs-blockstore"
 	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) {
@@ -2,38 +2,37 @@ package genesis

 import (
 	"context"
-	"github.com/filecoin-project/specs-actors/actors/builtin"

-	"github.com/filecoin-project/specs-actors/actors/abi/big"
+	"github.com/filecoin-project/specs-actors/actors/builtin"
+	"github.com/filecoin-project/specs-actors/actors/util/adt"
+
 	"github.com/filecoin-project/specs-actors/actors/builtin/power"
-	"github.com/ipfs/go-hamt-ipld"
-	bstore "github.com/ipfs/go-ipfs-blockstore"
 	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) {
-	ctx := context.TODO()
-	cst := cbor.NewCborStore(bs)
-	nd := hamt.NewNode(cst, hamt.UseTreeBitWidth(5))
-	emptyhamt, err := cst.Put(ctx, nd)
+	store := adt.WrapStore(context.TODO(), cbor.NewCborStore(bs))
+	emptyMap, err := adt.MakeEmptyMap(store).Root()
 	if err != nil {
 		return nil, err
 	}

-	sms := &power.State{
-		TotalRawBytePower:        big.NewInt(0),
-		TotalQualityAdjPower:     big.NewInt(1), // TODO: has to be 1 initially to avoid div by zero. Kinda annoying, should find a way to fix
-		TotalPledgeCollateral:    big.NewInt(0),
-		MinerCount:               0,
-		CronEventQueue:           emptyhamt,
-		LastEpochTick:            0,
-		Claims:                   emptyhamt,
-		NumMinersMeetingMinPower: 0,
+	multiMap, err := adt.AsMultimap(store, emptyMap)
+	if err != nil {
+		return nil, err
 	}

-	stcid, err := cst.Put(ctx, sms)
+	emptyMultiMap, err := multiMap.Root()
+	if err != nil {
+		return nil, err
+	}
+
+	sms := power.ConstructState(emptyMap, emptyMultiMap)
+
+	stcid, err := store.Put(store.Context(), sms)
 	if err != nil {
 		return nil, err
 	}
@@ -2,32 +2,31 @@ package genesis

 import (
 	"context"
-	"github.com/ipfs/go-hamt-ipld"

-	"github.com/filecoin-project/go-amt-ipld/v2"
 	"github.com/filecoin-project/specs-actors/actors/builtin"
 	"github.com/filecoin-project/specs-actors/actors/builtin/market"
-	bstore "github.com/ipfs/go-ipfs-blockstore"
+	"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) {
-	cst := cbor.NewCborStore(bs)
+	store := adt.WrapStore(context.TODO(), cbor.NewCborStore(bs))

-	a, err := amt.NewAMT(cst).Flush(context.TODO())
+	a, err := adt.MakeEmptyArray(store).Root()
 	if err != nil {
 		return nil, err
 	}
-	h, err := cst.Put(context.TODO(), hamt.NewNode(cst, hamt.UseTreeBitWidth(5)))
+	h, err := adt.MakeEmptyMap(store).Root()
 	if err != nil {
 		return nil, err
 	}

 	sms := market.ConstructState(a, h, h)

-	stcid, err := cst.Put(context.TODO(), sms)
+	stcid, err := store.Put(store.Context(), sms)
 	if err != nil {
 		return nil, err
 	}
@@ -4,27 +4,19 @@ import (
 	"context"

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

 	"github.com/filecoin-project/specs-actors/actors/builtin"
 	"github.com/filecoin-project/specs-actors/actors/builtin/verifreg"
+	"github.com/filecoin-project/specs-actors/actors/util/adt"

 	"github.com/filecoin-project/lotus/chain/types"
+	bstore "github.com/filecoin-project/lotus/lib/blockstore"
 )

-var RootVerifierAddr address.Address
-
 var RootVerifierID address.Address

 func init() {
-	k, err := address.NewFromString("t3qfoulel6fy6gn3hjmbhpdpf6fs5aqjb5fkurhtwvgssizq4jey5nw4ptq5up6h7jk7frdvvobv52qzmgjinq")
-	if err != nil {
-		panic(err)
-	}
-
-	RootVerifierAddr = k

 	idk, err := address.NewFromString("t080")
 	if err != nil {
@@ -35,16 +27,16 @@ func init() {
 }

 func SetupVerifiedRegistryActor(bs bstore.Blockstore) (*types.Actor, error) {
-	cst := cbor.NewCborStore(bs)
+	store := adt.WrapStore(context.TODO(), cbor.NewCborStore(bs))

-	h, err := cst.Put(context.TODO(), hamt.NewNode(cst, hamt.UseTreeBitWidth(5)))
+	h, err := adt.MakeEmptyMap(store).Root()
 	if err != nil {
 		return nil, err
 	}

 	sms := verifreg.ConstructState(h, RootVerifierID)

-	stcid, err := cst.Put(context.TODO(), sms)
+	stcid, err := store.Put(store.Context(), sms)
 	if err != nil {
 		return nil, err
 	}
@@ -4,7 +4,7 @@ import (
 	"context"

 	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/specs-actors/actors/abi"
+	"github.com/filecoin-project/go-state-types/abi"
 	cbg "github.com/whyrusleeping/cbor-gen"
 	"golang.org/x/xerrors"

@@ -21,14 +21,10 @@ func mustEnc(i cbg.CBORMarshaler) []byte {
 	return enc
 }

-func doExec(ctx context.Context, vm *vm.VM, to, from address.Address, method abi.MethodNum, 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 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: %w", err)
+		return nil, xerrors.Errorf("doExec failed to get from actor (%s): %w", from, err)
 	}

 	ret, err := vm.ApplyImplicitMessage(ctx, &types.Message{
@@ -37,7 +33,6 @@ func doExecValue(ctx context.Context, vm *vm.VM, to, from address.Address, value
 		Method:   method,
 		Params:   params,
 		GasLimit: 1_000_000_000_000_000,
-		GasPrice: types.NewInt(0),
 		Value:    value,
 		Nonce:    act.Nonce,
 	})
@@ -3,9 +3,8 @@ package gen
 import (
 	"context"

-	bls "github.com/filecoin-project/filecoin-ffi"
-	amt "github.com/filecoin-project/go-amt-ipld/v2"
-	"github.com/filecoin-project/specs-actors/actors/crypto"
+	"github.com/filecoin-project/go-state-types/crypto"
+	"github.com/filecoin-project/specs-actors/actors/util/adt"
 	cid "github.com/ipfs/go-cid"
 	cbor "github.com/ipfs/go-ipld-cbor"
 	cbg "github.com/whyrusleeping/cbor-gen"
@@ -17,6 +16,7 @@ import (
 	"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, bt *api.BlockTemplate) (*types.FullBlock, error) {
@@ -78,17 +78,17 @@ func MinerCreateBlock(ctx context.Context, sm *stmgr.StateManager, w *wallet.Wal
 		}
 	}

-	bs := cbor.NewCborStore(sm.ChainStore().Blockstore())
-	blsmsgroot, err := amt.FromArray(ctx, 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(ctx, bs, toIfArr(secpkMsgCids))
+	secpkmsgroot, err := toArray(store, secpkMsgCids)
 	if err != nil {
 		return nil, xerrors.Errorf("building secpk amt: %w", err)
 	}

-	mmcid, err := bs.Put(ctx, &types.MsgMeta{
+	mmcid, err := store.Put(store.Context(), &types.MsgMeta{
 		BlsMessages:   blsmsgroot,
 		SecpkMessages: secpkmsgroot,
 	})
@@ -109,6 +109,12 @@ func MinerCreateBlock(ctx context.Context, sm *stmgr.StateManager, w *wallet.Wal
 	}
 	next.ParentWeight = pweight

+	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 {
@@ -142,25 +148,45 @@ func MinerCreateBlock(ctx context.Context, sm *stmgr.StateManager, w *wallet.Wal
 }

 func aggregateSignatures(sigs []crypto.Signature) (*crypto.Signature, error) {
-	var blsSigs []bls.Signature
-	for _, s := range sigs {
-		var bsig bls.Signature
-		copy(bsig[:], s.Data)
-		blsSigs = append(blsSigs, bsig)
+	sigsS := make([][]byte, len(sigs))
+	for i := 0; i < len(sigs); i++ {
+		sigsS[i] = sigs[i].Data
 	}

-	aggSig := bls.Aggregate(blsSigs)
+	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[:],
+		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()
 }
@@ -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
+}
@@ -4,76 +4,159 @@ import (
 	"context"
 	"sync"

+	"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/events"
+	"github.com/filecoin-project/lotus/chain/events/state"
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/node/impl/full"
 )

 var log = logging.Logger("market_adapter")

-type FundMgr struct {
-	sm    *stmgr.StateManager
-	mpool full.MpoolAPI
+// API is the dependencies need to run a fund manager
+type API struct {
+	fx.In

-	lk        sync.Mutex
+	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, wallet address.Address, amt types.BigInt) (cid.Cid, error) {
-	fm.lk.Lock()
-	avail, ok := fm.available[addr]
+// 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
+}
+
+// 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 {
-		bal, err := fm.sm.MarketBalance(ctx, addr, nil)
-		if err != nil {
-			fm.lk.Unlock()
-			return cid.Undef, err
+		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())
 		}

-		avail = types.BigSub(bal.Escrow, bal.Locked)
+		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
 	}

-	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
+	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()

-	var err error
+	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.mpool.MpoolPushMessage(ctx, &types.Message{
-		To:       builtin.StorageMarketActorAddr,
-		From:     wallet,
-		Value:    toAdd,
-		GasPrice: types.NewInt(0),
-		GasLimit: 1000000,
-		Method:   builtin.MethodsMarket.AddBalance,
-		Params:   params,
-	})
+	smsg, err := fm.api.MpoolPushMessage(ctx, &types.Message{
+		To:     builtin.StorageMarketActorAddr,
+		From:   wallet,
+		Value:  toAdd,
+		Method: builtin.MethodsMarket.AddBalance,
+		Params: params,
+	}, nil)
 	if err != nil {
 		return cid.Undef, err
 	}
@@ -0,0 +1,188 @@
+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/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:     builtin.StorageMarketActorAddr,
+		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())
+				}
+			}
+		})
+	}
+}
@@ -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
+}
--- a/Show More
+++ b/Show More