fix setup of burnt funds actor state

.circleci/config.yml

@@ -113,7 +113,7 @@ jobs:
   test: &test
     description: |
       Run tests with gotestsum.
-    parameters: &test-params
+    parameters:
       executor:
         type: executor
         default: golang
@@ -161,7 +161,6 @@ jobs:
           name: go test
           environment:
             LOTUS_TEST_WINDOW_POST: << parameters.winpost-test >>
-            SKIP_CONFORMANCE: "1"
           command: |
             mkdir -p /tmp/test-reports/<< parameters.test-suite-name >>
             mkdir -p /tmp/test-artifacts
@@ -192,87 +191,6 @@ jobs:
     <<: *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
@@ -334,27 +252,6 @@ jobs:
       - 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.
@@ -391,6 +288,9 @@ jobs:
           command: |
             $HOME/.local/bin/golangci-lint run -v --timeout 2m \
               --concurrency << parameters.concurrency >> << parameters.args >>
+  lint-changes:
+    <<: *lint
+
   lint-all:
     <<: *lint
 
@@ -419,12 +319,10 @@ workflows:
   version: 2.1
   ci:
     jobs:
-      - lint-all:
-          concurrency: "16"   # expend all docker 2xlarge CPUs.
+      - lint-changes:
+          args: "--new-from-rev origin/next"
       - mod-tidy-check
       - gofmt
-      - cbor-gen-check
-      - docs-check
       - test:
           codecov-upload: true
           test-suite-name: full
@@ -439,15 +337,6 @@ workflows:
             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:

.codecov.yml

@@ -1,5 +1,3 @@
 comment: off
 ignore:
   - "cbor_gen.go"
-github_checks:
-  annotations: false

.github/CODEOWNERS

@@ -1,16 +0,0 @@
-## 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
-cmd/tvx                 @raulk

.github/labels.yml

@@ -26,14 +26,11 @@
   color: 00A4E2
   description: "Area: Chain/VM"
 - name: area/chain/sync
-  color: 00A4E4
+  color: 00A4E2
   description: "Area: Chain/Sync"
 - name: area/chain/misc
-  color: 00A4E6
+  color: 00A4E2
   description: "Area: Chain/Misc"
-- name: area/markets
-  color: 00A4E8
-  description: "Area: Markets"  
 - name: area/sealing/fsm
   color: 0bb1ed
   description: "Area: Sealing/FSM"
@@ -152,9 +149,6 @@
 - name: impact/test-flakiness
   color: DDE1E4
   description: "Impact: Test Flakiness"
-- name: impact/consensus
-  color: b20014
-  description: "Impact: Consensus"
 
 ###
 ### Topics

.gitignore

@@ -10,8 +10,6 @@
 /lotus-fountain
 /lotus-stats
 /lotus-bench
-/lotus-gateway
-/lotus-pcr
 /bench.json
 /lotuspond/front/node_modules
 /lotuspond/front/build

.gitmodules

@@ -5,12 +5,3 @@
 [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

.golangci.yml

@@ -23,14 +23,6 @@ issues:
     - "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:
@@ -54,19 +46,6 @@ issues:
       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

CHANGELOG.md

@@ -1,433 +1,12 @@
 # Lotus changelog
 
-# 0.8.0 / 2020-09-26
-
-This consensus-breaking release of Lotus introduces an upgrade to the network. The changes that break consensus are:
-
-- Upgrading to specs-actors v0.9.11, which reduces WindowPoSt faults per [FIP 0002](https://github.com/filecoin-project/FIPs/blob/master/FIPS/fip-0002.md) to reduce cost for honest miners with occasional faults (see https://github.com/filecoin-project/specs-actors/pull/1181)
-- Revisions to some cryptoeconomics and network params
-
-This release also updates go-fil-markets to fix an incompatibility issue between v0.7.2 and earlier versions.
-
-## Changes 
-
-#### Dependencies
-
-- Update spec actors to 0.9.11 (https://github.com/filecoin-project/lotus/pull/4039)
-- Update markets to 0.6.3 (https://github.com/filecoin-project/lotus/pull/4013)
-
-#### Core Lotus
-
-- Network upgrade (https://github.com/filecoin-project/lotus/pull/4039)
-- Fix AddSupportedProofTypes (https://github.com/filecoin-project/lotus/pull/4033)
-- Return an error when we fail to find a sector when checking sector expiration (https://github.com/filecoin-project/lotus/pull/4026)
-- Batch blockstore copies after block validation (https://github.com/filecoin-project/lotus/pull/3980)
-- Remove a misleading miner actor abstraction (https://github.com/filecoin-project/lotus/pull/3977)
-- Fix out-of-bounds when loading all sector infos (https://github.com/filecoin-project/lotus/pull/3976)
-- Fix break condition in the miner (https://github.com/filecoin-project/lotus/pull/3953)
-
-#### UX
-
-- Correct helptext around miners setting ask (https://github.com/filecoin-project/lotus/pull/4009)
-- Make sync wait nicer (https://github.com/filecoin-project/lotus/pull/3991)
-
-#### Tooling and validation
-
-- Small adjustments following network upgradability changes (https://github.com/filecoin-project/lotus/pull/3996)
-- Add some more big pictures stats to stateroot stat (https://github.com/filecoin-project/lotus/pull/3995)
-- Add some actors policy setters for testing (https://github.com/filecoin-project/lotus/pull/3975)
-
-## Contributors
-
-The following contributors had 5 or more commits go into this release.
-We are grateful for every contribution!
-
-| Contributor        | Commits | Lines ±       |
-|--------------------|---------|---------------|
-| arajasek           | 66       | +3140/-1261  |
-| Stebalien          | 64       | +3797/-3434  |
-| magik6k            | 48       | +1892/-976   |
-| raulk              | 40       | +2412/-1549  |
-| vyzo               | 22       | +287/-196    |
-| alanshaw           | 15       | +761/-146    |
-| whyrusleeping      | 15       | +736/-52     |
-| hannahhoward       | 14       | +1237/837-   | 
-| anton              | 6        | +32/-8       |
-| travisperson       | 5        | +502/-6      |
-| Frank              | 5        | +78/-39      |
-| Jennifer           | 5        | +148/-41     |
-
-# 0.7.2 / 2020-09-23
-
-This optional release of Lotus introduces a major refactor around how a Lotus node interacts with code from the specs-actors repo. We now use interfaces to read the state of actors, which is required to be able to reason about different versions of actors code at the same time.
-
-Additionally, this release introduces various improvements to the sync process, as well as changes to better the overall UX experience.
-
-## Changes
-
-#### Core Lotus
-
-- Network upgrade support (https://github.com/filecoin-project/lotus/pull/3781)
-- Upgrade markets to `v0.6.2` (https://github.com/filecoin-project/lotus/pull/3974)
-- Validate chain sync response indices when fetching messages (https://github.com/filecoin-project/lotus/pull/3939)
-- Add height diff to sync wait (https://github.com/filecoin-project/lotus/pull/3926)
-- Replace Requires with Wants (https://github.com/filecoin-project/lotus/pull/3898)
-- Update state diffing for market actor (https://github.com/filecoin-project/lotus/pull/3889)
-- Parallel fetch for sync (https://github.com/filecoin-project/lotus/pull/3887)
-- Fix SectorState (https://github.com/filecoin-project/lotus/pull/3881)
-
-#### User Experience
-
-- Add basic deal stats api server for spacerace slingshot (https://github.com/filecoin-project/lotus/pull/3963)
-- When doing `sectors update-state`, show a list of existing states if user inputs an invalid one (https://github.com/filecoin-project/lotus/pull/3944)
-- Fix `lotus-miner storage find` error (https://github.com/filecoin-project/lotus/pull/3927)
-- Log shutdown method for lotus daemon and miner (https://github.com/filecoin-project/lotus/pull/3925)
-- Update build and setup instruction link (https://github.com/filecoin-project/lotus/pull/3919)
-- Add an option to hide removed sectors from `sectors list` output (https://github.com/filecoin-project/lotus/pull/3903)
-
-#### Testing and validation
-
-- Add init.State#Remove() for testing (https://github.com/filecoin-project/lotus/pull/3971)
-- lotus-shed: add consensus check command (https://github.com/filecoin-project/lotus/pull/3933)
-- Add keyinfo verify and jwt token command to lotus-shed (https://github.com/filecoin-project/lotus/pull/3914)
-- Fix conformance gen (https://github.com/filecoin-project/lotus/pull/3892)
-
-# 0.7.1 / 2020-09-17
-
-This optional release of Lotus introduces some critical fixes to the window PoSt process. It also upgrades some core dependencies, and introduces many improvements to the mining process, deal-making cycle, and overall User Experience.
-
-## Changes
-
-#### Some notable improvements: 
-
-- Correctly construct params for `SubmitWindowedPoSt` messages (https://github.com/filecoin-project/lotus/pull/3909)
-- Skip sectors correctly for Window PoSt (https://github.com/filecoin-project/lotus/pull/3839)
-- Split window PoST submission into multiple messages (https://github.com/filecoin-project/lotus/pull/3689)
-- Improve journal coverage (https://github.com/filecoin-project/lotus/pull/2455)
-- Allow retrievals while sealing (https://github.com/filecoin-project/lotus/pull/3778)
-- Don't prune locally published messages (https://github.com/filecoin-project/lotus/pull/3772)
-- Add get-ask, set-ask retrieval commands (https://github.com/filecoin-project/lotus/pull/3886)
-- Consistently name winning and window post in logs (https://github.com/filecoin-project/lotus/pull/3873))
-- Add auto flag to mpool replace (https://github.com/filecoin-project/lotus/pull/3752))
-
-#### Dependencies
-
-- Upgrade markets to `v0.6.1` (https://github.com/filecoin-project/lotus/pull/3906)
-- Upgrade specs-actors to `v0.9.10` (https://github.com/filecoin-project/lotus/pull/3846)
-- Upgrade badger (https://github.com/filecoin-project/lotus/pull/3739)
-
-# 0.7.0 / 2020-09-10
-
-This consensus-breaking release of Lotus is designed to test a network upgrade on the space race testnet. The changes that break consensus are:
-
-- 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
+## 0.5.0 / 2020-08-2020
 
 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
+# Highlights
 
 Among the highlights included in this release are:
 
@@ -437,7 +16,7 @@ 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
+## Gas changes
 
 We made some significant changes to the mechanics of gas in this release.
 
@@ -494,7 +73,7 @@ data can be quickly served in a retrieval deal, since it will not need to be uns
 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
+## 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.
@@ -504,7 +83,7 @@ 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
+# Changelog
 
 #### Downstream upgrades
 - Upgrades markets to v0.5.6 (https://github.com/filecoin-project/lotus/pull/3058)
@@ -535,7 +114,7 @@ features can be found [here](https://github.com/filecoin-project/lotus/issues/23
 - 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
+# Contributors
 
 The following contributors had 10 or more commits go into this release.
 We are grateful for every contribution!
@@ -562,8 +141,8 @@ We are grateful for every contribution!
 | Stebalien          | 11      | +1204/-980    |
 | RobQuistNL         | 10      | +69/-74       |
 
-# 0.1.0 / 2019-12-11
+## 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!
+A huge thank you to all contributors for this testnet release!

Makefile

@@ -92,12 +92,6 @@ lotus-shed: $(BUILD_DEPS)
 .PHONY: lotus-shed
 BINS+=lotus-shed
 
-lotus-gateway: $(BUILD_DEPS)
-	rm -f lotus-gateway
-	go build $(GOFLAGS) -o lotus-gateway ./cmd/lotus-gateway
-.PHONY: lotus-gateway
-BINS+=lotus-gateway
-
 build: lotus lotus-miner lotus-worker
 	@[[ $$(type -P "lotus") ]] && echo "Caution: you have \
 an existing lotus binary in your PATH. This may cause problems if you don't run 'sudo make install'" || true
@@ -285,8 +279,5 @@ method-gen:
 
 gen: type-gen method-gen
 
-docsgen:
-	go run ./api/docgen > documentation/en/api-methods.md
-
 print-%:
 	@echo $*=$($*)

README.md

@@ -1,5 +1,5 @@
 <p align="center">
-  <a href="https://docs.filecoin.io/" title="Filecoin Docs">
+  <a href="https://lotu.sh/" title="Lotus Docs">
     <img src="documentation/images/lotus_logo_h.png" alt="Project Lotus Logo" width="244" />
   </a>
 </p>
@@ -18,7 +18,7 @@ Lotus is an implementation of the Filecoin Distributed Storage Network. For more
 
 ## Building & Documentation
 
-For instructions on how to build, install and setup lotus, please visit [https://docs.filecoin.io/get-started/lotus](https://docs.filecoin.io/get-started/lotus/).
+For instructions on how to build lotus from source, please visit [https://lotu.sh](https://lotu.sh) or read the source [here](https://github.com/filecoin-project/lotus/tree/master/documentation).
 
 ## Reporting a Vulnerability
 
@@ -40,6 +40,9 @@ All work is tracked via issues. An attempt at keeping an up-to-date view on rema
 The lotus Filecoin implementation unfolds into the following packages:
 
 - [This repo](https://github.com/filecoin-project/lotus)
+- [storage-fsm](https://github.com/filecoin-project/storage-fsm)
+- [sector-storage](https://github.com/filecoin-project/sector-storage)
+- [specs-storage](https://github.com/filecoin-project/specs-storage)
 - [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)
 

api/api_common.go

@@ -5,10 +5,8 @@ import (
 	"fmt"
 
 	"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"
 )
@@ -30,19 +28,6 @@ type Common interface {
 	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
 

api/api_full.go

@@ -2,29 +2,24 @@ package api
 
 import (
 	"context"
-	"fmt"
 	"time"
 
-	"github.com/filecoin-project/go-state-types/network"
-
 	"github.com/ipfs/go-cid"
 	"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/go-multistore"
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/go-state-types/big"
-	"github.com/filecoin-project/go-state-types/crypto"
-	"github.com/filecoin-project/go-state-types/dline"
-	"github.com/filecoin-project/lotus/chain/actors/builtin/market"
-	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
-	"github.com/filecoin-project/lotus/chain/actors/builtin/paych"
+	"github.com/filecoin-project/specs-actors/actors/abi"
+	"github.com/filecoin-project/specs-actors/actors/abi/big"
+	"github.com/filecoin-project/specs-actors/actors/builtin/market"
+	"github.com/filecoin-project/specs-actors/actors/builtin/miner"
+	"github.com/filecoin-project/specs-actors/actors/builtin/paych"
+	"github.com/filecoin-project/specs-actors/actors/builtin/power"
+	"github.com/filecoin-project/specs-actors/actors/builtin/verifreg"
+	"github.com/filecoin-project/specs-actors/actors/crypto"
 
-	"github.com/filecoin-project/lotus/chain/actors/builtin"
-	"github.com/filecoin-project/lotus/chain/actors/builtin/power"
 	"github.com/filecoin-project/lotus/chain/types"
 	marketevents "github.com/filecoin-project/lotus/markets/loggers"
 	"github.com/filecoin-project/lotus/node/modules/dtypes"
@@ -76,9 +71,6 @@ type FullNode interface {
 	// blockstore and returns raw bytes.
 	ChainReadObj(context.Context, cid.Cid) ([]byte, error)
 
-	// ChainDeleteObj deletes node referenced by the given CID
-	ChainDeleteObj(context.Context, cid.Cid) error
-
 	// ChainHasObj checks if a given CID exists in the chain blockstore.
 	ChainHasObj(context.Context, cid.Cid) (bool, error)
 
@@ -117,11 +109,7 @@ type FullNode interface {
 	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)
+	ChainExport(context.Context, types.TipSetKey) (<-chan []byte, error)
 
 	// MethodGroup: Beacon
 	// The Beacon method group contains methods for interacting with the random beacon (DRAND)
@@ -162,23 +150,14 @@ type FullNode interface {
 	// 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)
 
-	// SyncValidateTipset indicates whether the provided tipset is valid or not
-	SyncValidateTipset(ctx context.Context, tsk types.TipSetKey) (bool, error)
-
 	// MethodGroup: Mpool
 	// The Mpool methods are for interacting with the message pool. The message pool
 	// manages all incoming and outgoing 'messages' going over the network.
@@ -236,7 +215,7 @@ type FullNode interface {
 	WalletSignMessage(context.Context, address.Address, *types.Message) (*types.SignedMessage, error)
 	// WalletVerify takes an address, a signature, and some bytes, and indicates whether the signature is valid.
 	// The address does not have to be in the wallet.
-	WalletVerify(context.Context, address.Address, []byte, *crypto.Signature) (bool, error)
+	WalletVerify(context.Context, address.Address, []byte, *crypto.Signature) bool
 	// WalletDefaultAddress returns the address marked as default in the wallet.
 	WalletDefaultAddress(context.Context) (address.Address, error)
 	// WalletSetDefault marks the given address as as the default one.
@@ -247,8 +226,6 @@ type FullNode interface {
 	WalletImport(context.Context, *types.KeyInfo) (address.Address, error)
 	// WalletDelete deletes an address from the wallet.
 	WalletDelete(context.Context, address.Address) error
-	// WalletValidateAddress validates whether a given string can be decoded as a well-formed address
-	WalletValidateAddress(context.Context, string) (address.Address, error)
 
 	// Other
 
@@ -266,8 +243,6 @@ type FullNode interface {
 	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 identifies peers that have a certain file, and returns QueryOffers (one per peer).
@@ -280,7 +255,7 @@ type FullNode interface {
 	// of status updates.
 	ClientRetrieveWithEvents(ctx context.Context, order RetrievalOrder, ref *FileRef) (<-chan marketevents.RetrievalEvent, error)
 	// ClientQueryAsk returns a signed StorageAsk from the specified miner.
-	ClientQueryAsk(ctx context.Context, p peer.ID, miner address.Address) (*storagemarket.StorageAsk, error)
+	ClientQueryAsk(ctx context.Context, p peer.ID, miner address.Address) (*storagemarket.SignedStorageAsk, error)
 	// ClientCalcCommP calculates the CommP for a specified file
 	ClientCalcCommP(ctx context.Context, inpath string) (*CommPRet, error)
 	// ClientGenCar generates a CAR file for the specified file.
@@ -290,9 +265,6 @@ type FullNode interface {
 	// ClientListTransfers returns the status of all ongoing transfers of data
 	ClientListDataTransfers(ctx context.Context) ([]DataTransferChannel, error)
 	ClientDataTransferUpdates(ctx context.Context) (<-chan DataTransferChannel, error)
-	// 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)
@@ -321,26 +293,28 @@ type FullNode interface {
 	// StateNetworkName returns the name of the network the node is synced to
 	StateNetworkName(context.Context) (dtypes.NetworkName, error)
 	// StateMinerSectors returns info about the given miner's sectors. If the filter bitfield is nil, all sectors are included.
-	StateMinerSectors(context.Context, address.Address, *bitfield.BitField, types.TipSetKey) ([]*miner.SectorOnChainInfo, error)
+	// If the filterOut boolean is set to true, any sectors in the filter are excluded.
+	// If false, only those sectors in the filter are included.
+	StateMinerSectors(context.Context, address.Address, *abi.BitField, bool, types.TipSetKey) ([]*ChainSectorInfo, error)
 	// StateMinerActiveSectors returns info about sectors that a given miner is actively proving.
-	StateMinerActiveSectors(context.Context, address.Address, types.TipSetKey) ([]*miner.SectorOnChainInfo, error)
+	StateMinerActiveSectors(context.Context, address.Address, types.TipSetKey) ([]*ChainSectorInfo, error)
 	// StateMinerProvingDeadline calculates the deadline at some epoch for a proving period
 	// and returns the deadline-related calculations.
-	StateMinerProvingDeadline(context.Context, address.Address, types.TipSetKey) (*dline.Info, error)
+	StateMinerProvingDeadline(context.Context, address.Address, types.TipSetKey) (*miner.DeadlineInfo, error)
 	// StateMinerPower returns the power of the indicated miner
 	StateMinerPower(context.Context, address.Address, types.TipSetKey) (*MinerPower, error)
 	// StateMinerInfo returns info about the indicated miner
-	StateMinerInfo(context.Context, address.Address, types.TipSetKey) (miner.MinerInfo, error)
+	StateMinerInfo(context.Context, address.Address, types.TipSetKey) (MinerInfo, error)
 	// StateMinerDeadlines returns all the proving deadlines for the given miner
-	StateMinerDeadlines(context.Context, address.Address, types.TipSetKey) ([]Deadline, error)
-	// StateMinerPartitions returns all partitions in the specified deadline
-	StateMinerPartitions(ctx context.Context, m address.Address, dlIdx uint64, tsk types.TipSetKey) ([]Partition, error)
+	StateMinerDeadlines(context.Context, address.Address, types.TipSetKey) ([]*miner.Deadline, error)
+	// StateMinerPartitions loads miner partitions for the specified miner/deadline
+	StateMinerPartitions(context.Context, address.Address, uint64, types.TipSetKey) ([]*miner.Partition, error)
 	// StateMinerFaults returns a bitfield indicating the faulty sectors of the given miner
-	StateMinerFaults(context.Context, address.Address, types.TipSetKey) (bitfield.BitField, error)
+	StateMinerFaults(context.Context, address.Address, types.TipSetKey) (abi.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)
+	StateMinerRecoveries(context.Context, address.Address, types.TipSetKey) (abi.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
@@ -349,18 +323,16 @@ type FullNode interface {
 	StateMinerAvailableBalance(context.Context, address.Address, types.TipSetKey) (types.BigInt, error)
 	// StateSectorPreCommitInfo returns the PreCommit info for the specified miner's sector
 	StateSectorPreCommitInfo(context.Context, address.Address, abi.SectorNumber, types.TipSetKey) (miner.SectorPreCommitOnChainInfo, error)
-	// StateSectorGetInfo returns the on-chain info for the specified miner's sector. Returns null in case the sector info isn't found
+	// StateSectorGetInfo returns the on-chain info for the specified miner's sector
 	// NOTE: returned info.Expiration may not be accurate in some cases, use StateSectorExpiration to get accurate
 	// expiration epoch
 	StateSectorGetInfo(context.Context, address.Address, abi.SectorNumber, types.TipSetKey) (*miner.SectorOnChainInfo, error)
 	// StateSectorExpiration returns epoch at which given sector will expire
-	StateSectorExpiration(context.Context, address.Address, abi.SectorNumber, types.TipSetKey) (*miner.SectorExpiration, error)
+	StateSectorExpiration(context.Context, address.Address, abi.SectorNumber, types.TipSetKey) (*SectorExpiration, error)
 	// StateSectorPartition finds deadline/partition with the specified sector
-	StateSectorPartition(ctx context.Context, maddr address.Address, sectorNumber abi.SectorNumber, tok types.TipSetKey) (*miner.SectorLocation, error)
+	StateSectorPartition(ctx context.Context, maddr address.Address, sectorNumber abi.SectorNumber, tok types.TipSetKey) (*SectorLocation, error)
 	// StateSearchMsg searches for a message in the chain, and returns its receipt and the tipset where it was executed
 	StateSearchMsg(context.Context, cid.Cid) (*MsgLookup, error)
-	// 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)
@@ -393,15 +365,13 @@ type FullNode interface {
 	// StateVerifiedClientStatus returns the data cap for the given address.
 	// Returns nil if there is no entry in the data cap table for the
 	// address.
-	StateVerifiedClientStatus(ctx context.Context, addr address.Address, tsk types.TipSetKey) (*abi.StoragePower, error)
+	StateVerifiedClientStatus(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)
-	// StateNetworkVersion returns the network version at the given tipset
-	StateNetworkVersion(context.Context, types.TipSetKey) (network.Version, error)
 
 	// MethodGroup: Msig
 	// The Msig methods are used to interact with multisig wallets on the
@@ -409,9 +379,6 @@ type FullNode interface {
 
 	// MsigGetAvailableBalance returns the portion of a multisig's balance that can be withdrawn or spent
 	MsigGetAvailableBalance(context.Context, address.Address, types.TipSetKey) (types.BigInt, error)
-	// 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>
@@ -428,29 +395,17 @@ type FullNode interface {
 	// 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>
+	// <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>
+	// <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>
+	// <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)
@@ -461,8 +416,6 @@ type FullNode interface {
 
 	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)
 	PaychSettle(context.Context, address.Address) (cid.Cid, error)
@@ -471,10 +424,10 @@ type FullNode interface {
 	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) (*VoucherCreateResult, error)
+	PaychVoucherCreate(context.Context, address.Address, types.BigInt, uint64) (*paych.SignedVoucher, error)
 	PaychVoucherAdd(context.Context, address.Address, *paych.SignedVoucher, []byte, types.BigInt) (types.BigInt, error)
 	PaychVoucherList(context.Context, address.Address) ([]*paych.SignedVoucher, error)
-	PaychVoucherSubmit(context.Context, address.Address, *paych.SignedVoucher, []byte, []byte) (cid.Cid, error)
+	PaychVoucherSubmit(context.Context, address.Address, *paych.SignedVoucher) (cid.Cid, error)
 }
 
 type FileRef struct {
@@ -483,12 +436,21 @@ type FileRef struct {
 }
 
 type MinerSectors struct {
-	// Live sectors that should be proven.
-	Live uint64
-	// Sectors actively contributing to power.
-	Active uint64
-	// Sectors with failed proofs.
-	Faulty uint64
+	Sectors uint64
+	Active  uint64
+}
+
+type SectorExpiration struct {
+	OnTime abi.ChainEpoch
+
+	// non-zero if sector is faulty, epoch at which it will be permanently
+	// removed if it doesn't recover
+	Early abi.ChainEpoch
+}
+
+type SectorLocation struct {
+	Deadline  uint64
+	Partition uint64
 }
 
 type ImportRes struct {
@@ -531,17 +493,6 @@ type MsgLookup struct {
 	Height    abi.ChainEpoch
 }
 
-type MsgGasCost struct {
-	Message            cid.Cid // Can be different than requested, in case it was replaced, but only gas values changed
-	GasUsed            abi.TokenAmount
-	BaseFeeBurn        abi.TokenAmount
-	OverEstimationBurn abi.TokenAmount
-	MinerPenalty       abi.TokenAmount
-	MinerTip           abi.TokenAmount
-	Refund             abi.TokenAmount
-	TotalCost          abi.TokenAmount
-}
-
 type BlockMessages struct {
 	BlsMessages   []*types.Message
 	SecpkMessages []*types.SignedMessage
@@ -554,6 +505,11 @@ type Message struct {
 	Message *types.Message
 }
 
+type ChainSectorInfo struct {
+	Info miner.SectorOnChainInfo
+	ID   abi.SectorNumber
+}
+
 type ActorState struct {
 	Balance types.BigInt
 	State   interface{}
@@ -577,28 +533,6 @@ type ChannelInfo struct {
 	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
 	WaitSentinel cid.Cid
@@ -614,20 +548,9 @@ 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
-	HasMinPower bool
+	MinerPower power.Claim
+	TotalPower power.Claim
 }
 
 type QueryOffer struct {
@@ -730,8 +653,6 @@ type ActiveSync struct {
 
 type SyncState struct {
 	ActiveSyncs []ActiveSync
-
-	VMApplied uint64
 }
 
 type SyncStateStage int
@@ -743,28 +664,8 @@ 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 (
@@ -798,7 +699,7 @@ type CirculatingSupply struct {
 type MiningBaseInfo struct {
 	MinerPower      types.BigInt
 	NetworkPower    types.BigInt
-	Sectors         []builtin.SectorInfo
+	Sectors         []abi.SectorInfo
 	WorkerKey       address.Address
 	SectorSize      abi.SectorSize
 	PrevBeaconEntry types.BeaconEntry
@@ -815,7 +716,7 @@ type BlockTemplate struct {
 	Messages         []*types.SignedMessage
 	Epoch            abi.ChainEpoch
 	Timestamp        uint64
-	WinningPoStProof []builtin.PoStProof
+	WinningPoStProof []abi.PoStProof
 }
 
 type DataSize struct {
@@ -839,18 +740,6 @@ const (
 	MsigCancel
 )
 
-type Deadline struct {
-	PostSubmissions bitfield.BitField
-}
-
-type Partition struct {
-	AllSectors        bitfield.BitField
-	FaultySectors     bitfield.BitField
-	RecoveringSectors bitfield.BitField
-	LiveSectors       bitfield.BitField
-	ActiveSectors     bitfield.BitField
-}
-
 type Fault struct {
 	Miner address.Address
 	Epoch abi.ChainEpoch

api/api_storage.go

@@ -11,11 +11,11 @@ import (
 	"github.com/filecoin-project/go-fil-markets/piecestore"
 	"github.com/filecoin-project/go-fil-markets/retrievalmarket"
 	"github.com/filecoin-project/go-fil-markets/storagemarket"
-	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/extern/sector-storage/fsutil"
 	"github.com/filecoin-project/lotus/extern/sector-storage/stores"
 	"github.com/filecoin-project/lotus/extern/sector-storage/storiface"
+	"github.com/filecoin-project/specs-actors/actors/abi"
 )
 
 // StorageMiner is a low-level interface to the Filecoin network storage miner node
@@ -71,9 +71,9 @@ type StorageMiner interface {
 	stores.SectorIndex
 
 	MarketImportDealData(ctx context.Context, propcid cid.Cid, path string) error
-	MarketListDeals(ctx context.Context) ([]MarketDeal, error)
+	MarketListDeals(ctx context.Context) ([]storagemarket.StorageDeal, error)
 	MarketListRetrievalDeals(ctx context.Context) ([]retrievalmarket.ProviderDealState, error)
-	MarketGetDealUpdates(ctx context.Context) (<-chan storagemarket.MinerDeal, error)
+	MarketGetDealUpdates(ctx context.Context, d cid.Cid) (<-chan storagemarket.MinerDeal, error)
 	MarketListIncompleteDeals(ctx context.Context) ([]storagemarket.MinerDeal, error)
 	MarketSetAsk(ctx context.Context, price types.BigInt, verifiedPrice types.BigInt, duration abi.ChainEpoch, minPieceSize abi.PaddedPieceSize, maxPieceSize abi.PaddedPieceSize) error
 	MarketGetAsk(ctx context.Context) (*storagemarket.SignedStorageAsk, error)
@@ -83,7 +83,7 @@ type StorageMiner interface {
 	MarketDataTransferUpdates(ctx context.Context) (<-chan DataTransferChannel, error)
 
 	DealsImportData(ctx context.Context, dealPropCid cid.Cid, file string) error
-	DealsList(ctx context.Context) ([]MarketDeal, error)
+	DealsList(ctx context.Context) ([]storagemarket.StorageDeal, error)
 	DealsConsiderOnlineStorageDeals(context.Context) (bool, error)
 	DealsSetConsiderOnlineStorageDeals(context.Context, bool) error
 	DealsConsiderOnlineRetrievalDeals(context.Context) (bool, error)
@@ -120,18 +120,15 @@ 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
-	PreCommitMsg *cid.Cid
-	CommitMsg    *cid.Cid
-	Retries      uint64
-	ToUpgrade    bool
+	SectorID abi.SectorNumber
+	State    SectorState
+	CommD    *cid.Cid
+	CommR    *cid.Cid
+	Proof    []byte
+	Deals    []abi.DealID
+	Ticket   SealTicket
+	Seed     SealSeed
+	Retries  uint64
 
 	LastErr string
 

api/api_test.go

@@ -1,16 +1,12 @@
 package api
 
 import (
-	"encoding/json"
 	"os"
 	"os/exec"
 	"path/filepath"
-	"reflect"
 	"runtime"
 	"strings"
 	"testing"
-
-	"github.com/stretchr/testify/require"
 )
 
 func goCmd() string {
@@ -36,68 +32,3 @@ func TestDoesntDependOnFFI(t *testing.T) {
 		}
 	}
 }
-
-func TestReturnTypes(t *testing.T) {
-	errType := reflect.TypeOf(new(error)).Elem()
-	bareIface := reflect.TypeOf(new(interface{})).Elem()
-	jmarsh := reflect.TypeOf(new(json.Marshaler)).Elem()
-
-	tst := func(api interface{}) func(t *testing.T) {
-		return func(t *testing.T) {
-			ra := reflect.TypeOf(api).Elem()
-			for i := 0; i < ra.NumMethod(); i++ {
-				m := ra.Method(i)
-				switch m.Type.NumOut() {
-				case 1: // if 1 return value, it must be an error
-					require.Equal(t, errType, m.Type.Out(0), m.Name)
-
-				case 2: // if 2 return values, first cant be an interface/function, second must be an error
-					seen := map[reflect.Type]struct{}{}
-					todo := []reflect.Type{m.Type.Out(0)}
-					for len(todo) > 0 {
-						typ := todo[len(todo)-1]
-						todo = todo[:len(todo)-1]
-
-						if _, ok := seen[typ]; ok {
-							continue
-						}
-						seen[typ] = struct{}{}
-
-						if typ.Kind() == reflect.Interface && typ != bareIface && !typ.Implements(jmarsh) {
-							t.Error("methods can't return interfaces", m.Name)
-						}
-
-						switch typ.Kind() {
-						case reflect.Ptr:
-							fallthrough
-						case reflect.Array:
-							fallthrough
-						case reflect.Slice:
-							fallthrough
-						case reflect.Chan:
-							todo = append(todo, typ.Elem())
-						case reflect.Map:
-							todo = append(todo, typ.Elem())
-							todo = append(todo, typ.Key())
-						case reflect.Struct:
-							for i := 0; i < typ.NumField(); i++ {
-								todo = append(todo, typ.Field(i).Type)
-							}
-						}
-					}
-
-					require.NotEqual(t, reflect.Func.String(), m.Type.Out(0).Kind().String(), m.Name)
-					require.Equal(t, errType, m.Type.Out(1), m.Name)
-
-				default:
-					t.Error("methods can only have 1 or 2 return values", m.Name)
-				}
-			}
-		}
-	}
-
-	t.Run("common", tst(new(Common)))
-	t.Run("full", tst(new(FullNode)))
-	t.Run("miner", tst(new(StorageMiner)))
-	t.Run("worker", tst(new(WorkerAPI)))
-}

api/api_worker.go

@@ -6,10 +6,10 @@ import (
 
 	"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-actors/actors/abi"
 	"github.com/filecoin-project/specs-storage/storage"
 
 	"github.com/filecoin-project/lotus/build"
@@ -27,13 +27,11 @@ type WorkerAPI interface {
 
 	storage.Sealer
 
-	MoveStorage(ctx context.Context, sector abi.SectorID, types stores.SectorFileType) error
+	MoveStorage(ctx context.Context, sector abi.SectorID) 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)

api/apistruct/struct.go

@@ -5,36 +5,31 @@ import (
 	"io"
 	"time"
 
-	stnetwork "github.com/filecoin-project/go-state-types/network"
-
 	"github.com/ipfs/go-cid"
-	metrics "github.com/libp2p/go-libp2p-core/metrics"
 	"github.com/libp2p/go-libp2p-core/network"
 	"github.com/libp2p/go-libp2p-core/peer"
-	protocol "github.com/libp2p/go-libp2p-core/protocol"
 
 	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-bitfield"
 	"github.com/filecoin-project/go-fil-markets/piecestore"
 	"github.com/filecoin-project/go-fil-markets/retrievalmarket"
 	"github.com/filecoin-project/go-fil-markets/storagemarket"
 	"github.com/filecoin-project/go-jsonrpc/auth"
 	"github.com/filecoin-project/go-multistore"
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/go-state-types/big"
-	"github.com/filecoin-project/go-state-types/crypto"
-	"github.com/filecoin-project/go-state-types/dline"
 	"github.com/filecoin-project/lotus/extern/sector-storage/fsutil"
 	"github.com/filecoin-project/lotus/extern/sector-storage/sealtasks"
 	"github.com/filecoin-project/lotus/extern/sector-storage/stores"
 	"github.com/filecoin-project/lotus/extern/sector-storage/storiface"
 	marketevents "github.com/filecoin-project/lotus/markets/loggers"
+	"github.com/filecoin-project/specs-actors/actors/abi"
+	"github.com/filecoin-project/specs-actors/actors/abi/big"
+	"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/verifreg"
+	"github.com/filecoin-project/specs-actors/actors/crypto"
 	"github.com/filecoin-project/specs-storage/storage"
 
 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/build"
-	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
-	"github.com/filecoin-project/lotus/chain/actors/builtin/paych"
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/node/modules/dtypes"
 )
@@ -47,18 +42,14 @@ type CommonStruct struct {
 		AuthVerify func(ctx context.Context, token string) ([]auth.Permission, error) `perm:"read"`
 		AuthNew    func(ctx context.Context, perms []auth.Permission) ([]byte, error) `perm:"admin"`
 
-		NetConnectedness            func(context.Context, peer.ID) (network.Connectedness, error)    `perm:"read"`
-		NetPeers                    func(context.Context) ([]peer.AddrInfo, error)                   `perm:"read"`
-		NetConnect                  func(context.Context, peer.AddrInfo) error                       `perm:"write"`
-		NetAddrsListen              func(context.Context) (peer.AddrInfo, error)                     `perm:"read"`
-		NetDisconnect               func(context.Context, peer.ID) error                             `perm:"write"`
-		NetFindPeer                 func(context.Context, peer.ID) (peer.AddrInfo, error)            `perm:"read"`
-		NetPubsubScores             func(context.Context) ([]api.PubsubScore, error)                 `perm:"read"`
-		NetAutoNatStatus            func(context.Context) (api.NatInfo, error)                       `perm:"read"`
-		NetBandwidthStats           func(ctx context.Context) (metrics.Stats, error)                 `perm:"read"`
-		NetBandwidthStatsByPeer     func(ctx context.Context) (map[string]metrics.Stats, error)      `perm:"read"`
-		NetBandwidthStatsByProtocol func(ctx context.Context) (map[protocol.ID]metrics.Stats, error) `perm:"read"`
-		NetAgentVersion             func(ctx context.Context, p peer.ID) (string, error)             `perm:"read"`
+		NetConnectedness func(context.Context, peer.ID) (network.Connectedness, error) `perm:"read"`
+		NetPeers         func(context.Context) ([]peer.AddrInfo, error)                `perm:"read"`
+		NetConnect       func(context.Context, peer.AddrInfo) error                    `perm:"write"`
+		NetAddrsListen   func(context.Context) (peer.AddrInfo, error)                  `perm:"read"`
+		NetDisconnect    func(context.Context, peer.ID) error                          `perm:"write"`
+		NetFindPeer      func(context.Context, peer.ID) (peer.AddrInfo, error)         `perm:"read"`
+		NetPubsubScores  func(context.Context) ([]api.PubsubScore, error)              `perm:"read"`
+		NetAutoNatStatus func(context.Context) (api.NatInfo, error)                    `perm:"read"`
 
 		ID      func(context.Context) (peer.ID, error)     `perm:"read"`
 		Version func(context.Context) (api.Version, error) `perm:"read"`
@@ -87,7 +78,6 @@ type FullNodeStruct struct {
 		ChainGetParentMessages        func(context.Context, cid.Cid) ([]api.Message, error)                                                              `perm:"read"`
 		ChainGetTipSetByHeight        func(context.Context, abi.ChainEpoch, types.TipSetKey) (*types.TipSet, error)                                      `perm:"read"`
 		ChainReadObj                  func(context.Context, cid.Cid) ([]byte, error)                                                                     `perm:"read"`
-		ChainDeleteObj                func(context.Context, cid.Cid) error                                                                               `perm:"admin"`
 		ChainHasObj                   func(context.Context, cid.Cid) (bool, error)                                                                       `perm:"read"`
 		ChainStatObj                  func(context.Context, cid.Cid, cid.Cid) (api.ObjStat, error)                                                       `perm:"read"`
 		ChainSetHead                  func(context.Context, types.TipSetKey) error                                                                       `perm:"admin"`
@@ -96,7 +86,7 @@ type FullNodeStruct struct {
 		ChainGetNode                  func(ctx context.Context, p string) (*api.IpldObject, error)                                                       `perm:"read"`
 		ChainGetMessage               func(context.Context, cid.Cid) (*types.Message, error)                                                             `perm:"read"`
 		ChainGetPath                  func(context.Context, types.TipSetKey, types.TipSetKey) ([]*api.HeadChange, error)                                 `perm:"read"`
-		ChainExport                   func(context.Context, abi.ChainEpoch, bool, types.TipSetKey) (<-chan []byte, error)                                `perm:"read"`
+		ChainExport                   func(context.Context, types.TipSetKey) (<-chan []byte, error)                                                      `perm:"read"`
 
 		BeaconGetEntry func(ctx context.Context, epoch abi.ChainEpoch) (*types.BeaconEntry, error) `perm:"read"`
 
@@ -108,11 +98,8 @@ type FullNodeStruct struct {
 		SyncState          func(context.Context) (*api.SyncState, error)                `perm:"read"`
 		SyncSubmitBlock    func(ctx context.Context, blk *types.BlockMsg) error         `perm:"write"`
 		SyncIncomingBlocks func(ctx context.Context) (<-chan *types.BlockHeader, error) `perm:"read"`
-		SyncCheckpoint     func(ctx context.Context, key types.TipSetKey) error         `perm:"admin"`
 		SyncMarkBad        func(ctx context.Context, bcid cid.Cid) error                `perm:"admin"`
-		SyncUnmarkBad      func(ctx context.Context, bcid cid.Cid) error                `perm:"admin"`
 		SyncCheckBad       func(ctx context.Context, bcid cid.Cid) (string, error)      `perm:"read"`
-		SyncValidateTipset func(ctx context.Context, tsk types.TipSetKey) (bool, error) `perm:"read"`
 
 		MpoolGetConfig func(context.Context) (*types.MpoolConfig, error) `perm:"read"`
 		MpoolSetConfig func(context.Context, *types.MpoolConfig) error   `perm:"write"`
@@ -130,63 +117,59 @@ type FullNodeStruct struct {
 		MinerGetBaseInfo func(context.Context, address.Address, abi.ChainEpoch, types.TipSetKey) (*api.MiningBaseInfo, error) `perm:"read"`
 		MinerCreateBlock func(context.Context, *api.BlockTemplate) (*types.BlockMsg, error)                                   `perm:"write"`
 
-		WalletNew             func(context.Context, crypto.SigType) (address.Address, error)                       `perm:"write"`
-		WalletHas             func(context.Context, address.Address) (bool, error)                                 `perm:"write"`
-		WalletList            func(context.Context) ([]address.Address, error)                                     `perm:"write"`
-		WalletBalance         func(context.Context, address.Address) (types.BigInt, error)                         `perm:"read"`
-		WalletSign            func(context.Context, address.Address, []byte) (*crypto.Signature, error)            `perm:"sign"`
-		WalletSignMessage     func(context.Context, address.Address, *types.Message) (*types.SignedMessage, error) `perm:"sign"`
-		WalletVerify          func(context.Context, address.Address, []byte, *crypto.Signature) (bool, error)      `perm:"read"`
-		WalletDefaultAddress  func(context.Context) (address.Address, error)                                       `perm:"write"`
-		WalletSetDefault      func(context.Context, address.Address) error                                         `perm:"admin"`
-		WalletExport          func(context.Context, address.Address) (*types.KeyInfo, error)                       `perm:"admin"`
-		WalletImport          func(context.Context, *types.KeyInfo) (address.Address, error)                       `perm:"admin"`
-		WalletDelete          func(context.Context, address.Address) error                                         `perm:"write"`
-		WalletValidateAddress func(context.Context, string) (address.Address, error)                               `perm:"read"`
+		WalletNew            func(context.Context, crypto.SigType) (address.Address, error)                       `perm:"write"`
+		WalletHas            func(context.Context, address.Address) (bool, error)                                 `perm:"write"`
+		WalletList           func(context.Context) ([]address.Address, error)                                     `perm:"write"`
+		WalletBalance        func(context.Context, address.Address) (types.BigInt, error)                         `perm:"read"`
+		WalletSign           func(context.Context, address.Address, []byte) (*crypto.Signature, error)            `perm:"sign"`
+		WalletSignMessage    func(context.Context, address.Address, *types.Message) (*types.SignedMessage, error) `perm:"sign"`
+		WalletVerify         func(context.Context, address.Address, []byte, *crypto.Signature) bool               `perm:"read"`
+		WalletDefaultAddress func(context.Context) (address.Address, error)                                       `perm:"write"`
+		WalletSetDefault     func(context.Context, address.Address) error                                         `perm:"admin"`
+		WalletExport         func(context.Context, address.Address) (*types.KeyInfo, error)                       `perm:"admin"`
+		WalletImport         func(context.Context, *types.KeyInfo) (address.Address, error)                       `perm:"admin"`
+		WalletDelete         func(context.Context, address.Address) error                                         `perm:"write"`
 
-		ClientImport                              func(ctx context.Context, ref api.FileRef) (*api.ImportRes, error)                                                `perm:"admin"`
-		ClientListImports                         func(ctx context.Context) ([]api.Import, error)                                                                   `perm:"write"`
-		ClientRemoveImport                        func(ctx context.Context, importID multistore.StoreID) error                                                      `perm:"admin"`
-		ClientHasLocal                            func(ctx context.Context, root cid.Cid) (bool, error)                                                             `perm:"write"`
-		ClientFindData                            func(ctx context.Context, root cid.Cid, piece *cid.Cid) ([]api.QueryOffer, error)                                 `perm:"read"`
-		ClientMinerQueryOffer                     func(ctx context.Context, miner address.Address, root cid.Cid, piece *cid.Cid) (api.QueryOffer, error)            `perm:"read"`
-		ClientStartDeal                           func(ctx context.Context, params *api.StartDealParams) (*cid.Cid, error)                                          `perm:"admin"`
-		ClientGetDealInfo                         func(context.Context, cid.Cid) (*api.DealInfo, error)                                                             `perm:"read"`
-		ClientListDeals                           func(ctx context.Context) ([]api.DealInfo, error)                                                                 `perm:"write"`
-		ClientGetDealUpdates                      func(ctx context.Context) (<-chan api.DealInfo, error)                                                            `perm:"read"`
-		ClientRetrieve                            func(ctx context.Context, order api.RetrievalOrder, ref *api.FileRef) error                                       `perm:"admin"`
-		ClientRetrieveWithEvents                  func(ctx context.Context, order api.RetrievalOrder, ref *api.FileRef) (<-chan marketevents.RetrievalEvent, error) `perm:"admin"`
-		ClientQueryAsk                            func(ctx context.Context, p peer.ID, miner address.Address) (*storagemarket.StorageAsk, error)                    `perm:"read"`
-		ClientCalcCommP                           func(ctx context.Context, inpath string) (*api.CommPRet, error)                                                   `perm:"read"`
-		ClientGenCar                              func(ctx context.Context, ref api.FileRef, outpath string) error                                                  `perm:"write"`
-		ClientDealSize                            func(ctx context.Context, root cid.Cid) (api.DataSize, error)                                                     `perm:"read"`
-		ClientListDataTransfers                   func(ctx context.Context) ([]api.DataTransferChannel, error)                                                      `perm:"write"`
-		ClientDataTransferUpdates                 func(ctx context.Context) (<-chan api.DataTransferChannel, error)                                                 `perm:"write"`
-		ClientRetrieveTryRestartInsufficientFunds func(ctx context.Context, paymentChannel address.Address) error                                                   `perm:"write"`
+		ClientImport              func(ctx context.Context, ref api.FileRef) (*api.ImportRes, error)                                                `perm:"admin"`
+		ClientListImports         func(ctx context.Context) ([]api.Import, error)                                                                   `perm:"write"`
+		ClientRemoveImport        func(ctx context.Context, importID multistore.StoreID) error                                                      `perm:"admin"`
+		ClientHasLocal            func(ctx context.Context, root cid.Cid) (bool, error)                                                             `perm:"write"`
+		ClientFindData            func(ctx context.Context, root cid.Cid, piece *cid.Cid) ([]api.QueryOffer, error)                                 `perm:"read"`
+		ClientMinerQueryOffer     func(ctx context.Context, miner address.Address, root cid.Cid, piece *cid.Cid) (api.QueryOffer, error)            `perm:"read"`
+		ClientStartDeal           func(ctx context.Context, params *api.StartDealParams) (*cid.Cid, error)                                          `perm:"admin"`
+		ClientGetDealInfo         func(context.Context, cid.Cid) (*api.DealInfo, error)                                                             `perm:"read"`
+		ClientListDeals           func(ctx context.Context) ([]api.DealInfo, error)                                                                 `perm:"write"`
+		ClientRetrieve            func(ctx context.Context, order api.RetrievalOrder, ref *api.FileRef) error                                       `perm:"admin"`
+		ClientRetrieveWithEvents  func(ctx context.Context, order api.RetrievalOrder, ref *api.FileRef) (<-chan marketevents.RetrievalEvent, error) `perm:"admin"`
+		ClientQueryAsk            func(ctx context.Context, p peer.ID, miner address.Address) (*storagemarket.SignedStorageAsk, error)              `perm:"read"`
+		ClientCalcCommP           func(ctx context.Context, inpath string) (*api.CommPRet, error)                                                   `perm:"read"`
+		ClientGenCar              func(ctx context.Context, ref api.FileRef, outpath string) error                                                  `perm:"write"`
+		ClientDealSize            func(ctx context.Context, root cid.Cid) (api.DataSize, error)                                                     `perm:"read"`
+		ClientListDataTransfers   func(ctx context.Context) ([]api.DataTransferChannel, error)                                                      `perm:"write"`
+		ClientDataTransferUpdates func(ctx context.Context) (<-chan api.DataTransferChannel, error)                                                 `perm:"write"`
 
 		StateNetworkName                   func(context.Context) (dtypes.NetworkName, error)                                                                   `perm:"read"`
-		StateMinerSectors                  func(context.Context, address.Address, *bitfield.BitField, types.TipSetKey) ([]*miner.SectorOnChainInfo, error)     `perm:"read"`
-		StateMinerActiveSectors            func(context.Context, address.Address, types.TipSetKey) ([]*miner.SectorOnChainInfo, error)                         `perm:"read"`
-		StateMinerProvingDeadline          func(context.Context, address.Address, types.TipSetKey) (*dline.Info, error)                                        `perm:"read"`
+		StateMinerSectors                  func(context.Context, address.Address, *abi.BitField, bool, types.TipSetKey) ([]*api.ChainSectorInfo, error)        `perm:"read"`
+		StateMinerActiveSectors            func(context.Context, address.Address, types.TipSetKey) ([]*api.ChainSectorInfo, error)                             `perm:"read"`
+		StateMinerProvingDeadline          func(context.Context, address.Address, types.TipSetKey) (*miner.DeadlineInfo, error)                                `perm:"read"`
 		StateMinerPower                    func(context.Context, address.Address, types.TipSetKey) (*api.MinerPower, error)                                    `perm:"read"`
-		StateMinerInfo                     func(context.Context, address.Address, types.TipSetKey) (miner.MinerInfo, error)                                    `perm:"read"`
-		StateMinerDeadlines                func(context.Context, address.Address, types.TipSetKey) ([]api.Deadline, error)                                     `perm:"read"`
-		StateMinerPartitions               func(ctx context.Context, m address.Address, dlIdx uint64, tsk types.TipSetKey) ([]api.Partition, error)            `perm:"read"`
-		StateMinerFaults                   func(context.Context, address.Address, types.TipSetKey) (bitfield.BitField, error)                                  `perm:"read"`
+		StateMinerInfo                     func(context.Context, address.Address, types.TipSetKey) (api.MinerInfo, error)                                      `perm:"read"`
+		StateMinerDeadlines                func(context.Context, address.Address, types.TipSetKey) ([]*miner.Deadline, error)                                  `perm:"read"`
+		StateMinerPartitions               func(context.Context, address.Address, uint64, types.TipSetKey) ([]*miner.Partition, error)                         `perm:"read"`
+		StateMinerFaults                   func(context.Context, address.Address, types.TipSetKey) (abi.BitField, error)                                       `perm:"read"`
 		StateAllMinerFaults                func(context.Context, abi.ChainEpoch, types.TipSetKey) ([]*api.Fault, error)                                        `perm:"read"`
-		StateMinerRecoveries               func(context.Context, address.Address, types.TipSetKey) (bitfield.BitField, error)                                  `perm:"read"`
+		StateMinerRecoveries               func(context.Context, address.Address, types.TipSetKey) (abi.BitField, error)                                       `perm:"read"`
 		StateMinerPreCommitDepositForPower func(context.Context, address.Address, miner.SectorPreCommitInfo, types.TipSetKey) (types.BigInt, error)            `perm:"read"`
 		StateMinerInitialPledgeCollateral  func(context.Context, address.Address, miner.SectorPreCommitInfo, types.TipSetKey) (types.BigInt, error)            `perm:"read"`
 		StateMinerAvailableBalance         func(context.Context, address.Address, types.TipSetKey) (types.BigInt, error)                                       `perm:"read"`
 		StateSectorPreCommitInfo           func(context.Context, address.Address, abi.SectorNumber, types.TipSetKey) (miner.SectorPreCommitOnChainInfo, error) `perm:"read"`
 		StateSectorGetInfo                 func(context.Context, address.Address, abi.SectorNumber, types.TipSetKey) (*miner.SectorOnChainInfo, error)         `perm:"read"`
-		StateSectorExpiration              func(context.Context, address.Address, abi.SectorNumber, types.TipSetKey) (*miner.SectorExpiration, error)          `perm:"read"`
-		StateSectorPartition               func(context.Context, address.Address, abi.SectorNumber, types.TipSetKey) (*miner.SectorLocation, error)            `perm:"read"`
+		StateSectorExpiration              func(context.Context, address.Address, abi.SectorNumber, types.TipSetKey) (*api.SectorExpiration, error)            `perm:"read"`
+		StateSectorPartition               func(context.Context, address.Address, abi.SectorNumber, types.TipSetKey) (*api.SectorLocation, error)              `perm:"read"`
 		StateCall                          func(context.Context, *types.Message, types.TipSetKey) (*api.InvocResult, error)                                    `perm:"read"`
 		StateReplay                        func(context.Context, types.TipSetKey, cid.Cid) (*api.InvocResult, error)                                           `perm:"read"`
 		StateGetActor                      func(context.Context, address.Address, types.TipSetKey) (*types.Actor, error)                                       `perm:"read"`
 		StateReadState                     func(context.Context, address.Address, types.TipSetKey) (*api.ActorState, error)                                    `perm:"read"`
-		StateMsgGasCost                    func(context.Context, cid.Cid, types.TipSetKey) (*api.MsgGasCost, error)                                            `perm:"read"`
 		StateWaitMsg                       func(ctx context.Context, cid cid.Cid, confidence uint64) (*api.MsgLookup, error)                                   `perm:"read"`
 		StateSearchMsg                     func(context.Context, cid.Cid) (*api.MsgLookup, error)                                                              `perm:"read"`
 		StateListMiners                    func(context.Context, types.TipSetKey) ([]address.Address, error)                                                   `perm:"read"`
@@ -202,43 +185,36 @@ type FullNodeStruct struct {
 		StateMinerSectorCount              func(context.Context, address.Address, types.TipSetKey) (api.MinerSectors, error)                                   `perm:"read"`
 		StateListMessages                  func(ctx context.Context, match *types.Message, tsk types.TipSetKey, toht abi.ChainEpoch) ([]cid.Cid, error)        `perm:"read"`
 		StateCompute                       func(context.Context, abi.ChainEpoch, []*types.Message, types.TipSetKey) (*api.ComputeStateOutput, error)           `perm:"read"`
-		StateVerifiedClientStatus          func(context.Context, address.Address, types.TipSetKey) (*abi.StoragePower, error)                                  `perm:"read"`
+		StateVerifiedClientStatus          func(context.Context, address.Address, types.TipSetKey) (*verifreg.DataCap, error)                                  `perm:"read"`
 		StateDealProviderCollateralBounds  func(context.Context, abi.PaddedPieceSize, bool, types.TipSetKey) (api.DealCollateralBounds, error)                 `perm:"read"`
 		StateCirculatingSupply             func(context.Context, types.TipSetKey) (api.CirculatingSupply, error)                                               `perm:"read"`
-		StateNetworkVersion                func(context.Context, types.TipSetKey) (stnetwork.Version, error)                                                   `perm:"read"`
 
 		MsigGetAvailableBalance func(context.Context, address.Address, types.TipSetKey) (types.BigInt, error)                                                                    `perm:"read"`
-		MsigGetVested           func(context.Context, address.Address, types.TipSetKey, types.TipSetKey) (types.BigInt, error)                                                   `perm:"read"`
 		MsigCreate              func(context.Context, uint64, []address.Address, abi.ChainEpoch, types.BigInt, address.Address, types.BigInt) (cid.Cid, error)                   `perm:"sign"`
 		MsigPropose             func(context.Context, address.Address, address.Address, types.BigInt, address.Address, uint64, []byte) (cid.Cid, error)                          `perm:"sign"`
 		MsigApprove             func(context.Context, address.Address, uint64, address.Address, address.Address, types.BigInt, address.Address, uint64, []byte) (cid.Cid, error) `perm:"sign"`
 		MsigCancel              func(context.Context, address.Address, uint64, address.Address, types.BigInt, address.Address, uint64, []byte) (cid.Cid, error)                  `perm:"sign"`
-		MsigAddPropose          func(context.Context, address.Address, address.Address, address.Address, bool) (cid.Cid, error)                                                  `perm:"sign"`
-		MsigAddApprove          func(context.Context, address.Address, address.Address, uint64, address.Address, address.Address, bool) (cid.Cid, error)                         `perm:"sign"`
-		MsigAddCancel           func(context.Context, address.Address, address.Address, uint64, address.Address, bool) (cid.Cid, error)                                          `perm:"sign"`
 		MsigSwapPropose         func(context.Context, address.Address, address.Address, address.Address, address.Address) (cid.Cid, error)                                       `perm:"sign"`
 		MsigSwapApprove         func(context.Context, address.Address, address.Address, uint64, address.Address, address.Address, address.Address) (cid.Cid, error)              `perm:"sign"`
 		MsigSwapCancel          func(context.Context, address.Address, address.Address, uint64, address.Address, address.Address) (cid.Cid, error)                               `perm:"sign"`
 
 		MarketEnsureAvailable func(context.Context, address.Address, address.Address, types.BigInt) (cid.Cid, error) `perm:"sign"`
 
-		PaychGet                    func(ctx context.Context, from, to address.Address, amt types.BigInt) (*api.ChannelInfo, error)           `perm:"sign"`
-		PaychGetWaitReady           func(context.Context, cid.Cid) (address.Address, error)                                                   `perm:"sign"`
-		PaychAvailableFunds         func(context.Context, address.Address) (*api.ChannelAvailableFunds, error)                                `perm:"sign"`
-		PaychAvailableFundsByFromTo func(context.Context, address.Address, address.Address) (*api.ChannelAvailableFunds, error)               `perm:"sign"`
-		PaychList                   func(context.Context) ([]address.Address, error)                                                          `perm:"read"`
-		PaychStatus                 func(context.Context, address.Address) (*api.PaychStatus, error)                                          `perm:"read"`
-		PaychSettle                 func(context.Context, address.Address) (cid.Cid, error)                                                   `perm:"sign"`
-		PaychCollect                func(context.Context, address.Address) (cid.Cid, error)                                                   `perm:"sign"`
-		PaychAllocateLane           func(context.Context, address.Address) (uint64, error)                                                    `perm:"sign"`
-		PaychNewPayment             func(ctx context.Context, from, to address.Address, vouchers []api.VoucherSpec) (*api.PaymentInfo, error) `perm:"sign"`
-		PaychVoucherCheck           func(context.Context, *paych.SignedVoucher) error                                                         `perm:"read"`
-		PaychVoucherCheckValid      func(context.Context, address.Address, *paych.SignedVoucher) error                                        `perm:"read"`
-		PaychVoucherCheckSpendable  func(context.Context, address.Address, *paych.SignedVoucher, []byte, []byte) (bool, error)                `perm:"read"`
-		PaychVoucherAdd             func(context.Context, address.Address, *paych.SignedVoucher, []byte, types.BigInt) (types.BigInt, error)  `perm:"write"`
-		PaychVoucherCreate          func(context.Context, address.Address, big.Int, uint64) (*api.VoucherCreateResult, error)                 `perm:"sign"`
-		PaychVoucherList            func(context.Context, address.Address) ([]*paych.SignedVoucher, error)                                    `perm:"write"`
-		PaychVoucherSubmit          func(context.Context, address.Address, *paych.SignedVoucher, []byte, []byte) (cid.Cid, error)             `perm:"sign"`
+		PaychGet                   func(ctx context.Context, from, to address.Address, amt types.BigInt) (*api.ChannelInfo, error)           `perm:"sign"`
+		PaychGetWaitReady          func(context.Context, cid.Cid) (address.Address, error)                                                   `perm:"sign"`
+		PaychList                  func(context.Context) ([]address.Address, error)                                                          `perm:"read"`
+		PaychStatus                func(context.Context, address.Address) (*api.PaychStatus, error)                                          `perm:"read"`
+		PaychSettle                func(context.Context, address.Address) (cid.Cid, error)                                                   `perm:"sign"`
+		PaychCollect               func(context.Context, address.Address) (cid.Cid, error)                                                   `perm:"sign"`
+		PaychAllocateLane          func(context.Context, address.Address) (uint64, error)                                                    `perm:"sign"`
+		PaychNewPayment            func(ctx context.Context, from, to address.Address, vouchers []api.VoucherSpec) (*api.PaymentInfo, error) `perm:"sign"`
+		PaychVoucherCheck          func(context.Context, *paych.SignedVoucher) error                                                         `perm:"read"`
+		PaychVoucherCheckValid     func(context.Context, address.Address, *paych.SignedVoucher) error                                        `perm:"read"`
+		PaychVoucherCheckSpendable func(context.Context, address.Address, *paych.SignedVoucher, []byte, []byte) (bool, error)                `perm:"read"`
+		PaychVoucherAdd            func(context.Context, address.Address, *paych.SignedVoucher, []byte, types.BigInt) (types.BigInt, error)  `perm:"write"`
+		PaychVoucherCreate         func(context.Context, address.Address, big.Int, uint64) (*paych.SignedVoucher, error)                     `perm:"sign"`
+		PaychVoucherList           func(context.Context, address.Address) ([]*paych.SignedVoucher, error)                                    `perm:"write"`
+		PaychVoucherSubmit         func(context.Context, address.Address, *paych.SignedVoucher) (cid.Cid, error)                             `perm:"sign"`
 	}
 }
 
@@ -256,9 +232,9 @@ type StorageMinerStruct struct {
 		MiningBase func(context.Context) (*types.TipSet, error) `perm:"read"`
 
 		MarketImportDealData      func(context.Context, cid.Cid, string) error                                                                                                                                 `perm:"write"`
-		MarketListDeals           func(ctx context.Context) ([]api.MarketDeal, error)                                                                                                                          `perm:"read"`
+		MarketListDeals           func(ctx context.Context) ([]storagemarket.StorageDeal, error)                                                                                                               `perm:"read"`
 		MarketListRetrievalDeals  func(ctx context.Context) ([]retrievalmarket.ProviderDealState, error)                                                                                                       `perm:"read"`
-		MarketGetDealUpdates      func(ctx context.Context) (<-chan storagemarket.MinerDeal, error)                                                                                                            `perm:"read"`
+		MarketGetDealUpdates      func(ctx context.Context, d cid.Cid) (<-chan storagemarket.MinerDeal, error)                                                                                                 `perm:"read"`
 		MarketListIncompleteDeals func(ctx context.Context) ([]storagemarket.MinerDeal, error)                                                                                                                 `perm:"read"`
 		MarketSetAsk              func(ctx context.Context, price types.BigInt, verifiedPrice types.BigInt, duration abi.ChainEpoch, minPieceSize abi.PaddedPieceSize, maxPieceSize abi.PaddedPieceSize) error `perm:"admin"`
 		MarketGetAsk              func(ctx context.Context) (*storagemarket.SignedStorageAsk, error)                                                                                                           `perm:"read"`
@@ -301,7 +277,7 @@ type StorageMinerStruct struct {
 		StorageTryLock       func(ctx context.Context, sector abi.SectorID, read stores.SectorFileType, write stores.SectorFileType) (bool, error)                         `perm:"admin"`
 
 		DealsImportData                       func(ctx context.Context, dealPropCid cid.Cid, file string) error `perm:"write"`
-		DealsList                             func(ctx context.Context) ([]api.MarketDeal, error)               `perm:"read"`
+		DealsList                             func(ctx context.Context) ([]storagemarket.StorageDeal, error)    `perm:"read"`
 		DealsConsiderOnlineStorageDeals       func(context.Context) (bool, error)                               `perm:"read"`
 		DealsSetConsiderOnlineStorageDeals    func(context.Context, bool) error                                 `perm:"admin"`
 		DealsConsiderOnlineRetrievalDeals     func(context.Context) (bool, error)                               `perm:"read"`
@@ -340,8 +316,7 @@ type WorkerStruct struct {
 		FinalizeSector  func(context.Context, abi.SectorID, []storage.Range) error                                                                                                                                 `perm:"admin"`
 		ReleaseUnsealed func(ctx context.Context, sector abi.SectorID, safeToFree []storage.Range) error                                                                                                           `perm:"admin"`
 		Remove          func(ctx context.Context, sector abi.SectorID) error                                                                                                                                       `perm:"admin"`
-		MoveStorage     func(ctx context.Context, sector abi.SectorID, types stores.SectorFileType) error                                                                                                          `perm:"admin"`
-		StorageAddLocal func(ctx context.Context, path string) error                                                                                                                                               `perm:"admin"`
+		MoveStorage     func(ctx context.Context, sector abi.SectorID) error                                                                                                                                       `perm:"admin"`
 
 		UnsealPiece func(context.Context, abi.SectorID, storiface.UnpaddedByteIndex, abi.UnpaddedPieceSize, abi.SealRandomness, cid.Cid) error `perm:"admin"`
 		ReadPiece   func(context.Context, io.Writer, abi.SectorID, storiface.UnpaddedByteIndex, abi.UnpaddedPieceSize) (bool, error)           `perm:"admin"`
@@ -394,22 +369,6 @@ func (c *CommonStruct) NetAutoNatStatus(ctx context.Context) (api.NatInfo, error
 	return c.Internal.NetAutoNatStatus(ctx)
 }
 
-func (c *CommonStruct) NetBandwidthStats(ctx context.Context) (metrics.Stats, error) {
-	return c.Internal.NetBandwidthStats(ctx)
-}
-
-func (c *CommonStruct) NetBandwidthStatsByPeer(ctx context.Context) (map[string]metrics.Stats, error) {
-	return c.Internal.NetBandwidthStatsByPeer(ctx)
-}
-
-func (c *CommonStruct) NetBandwidthStatsByProtocol(ctx context.Context) (map[protocol.ID]metrics.Stats, error) {
-	return c.Internal.NetBandwidthStatsByProtocol(ctx)
-}
-
-func (c *CommonStruct) NetAgentVersion(ctx context.Context, p peer.ID) (string, error) {
-	return c.Internal.NetAgentVersion(ctx, p)
-}
-
 // ID implements API.ID
 func (c *CommonStruct) ID(ctx context.Context) (peer.ID, error) {
 	return c.Internal.ID(ctx)
@@ -474,10 +433,6 @@ func (c *FullNodeStruct) ClientListDeals(ctx context.Context) ([]api.DealInfo, e
 	return c.Internal.ClientListDeals(ctx)
 }
 
-func (c *FullNodeStruct) ClientGetDealUpdates(ctx context.Context) (<-chan api.DealInfo, error) {
-	return c.Internal.ClientGetDealUpdates(ctx)
-}
-
 func (c *FullNodeStruct) ClientRetrieve(ctx context.Context, order api.RetrievalOrder, ref *api.FileRef) error {
 	return c.Internal.ClientRetrieve(ctx, order, ref)
 }
@@ -486,7 +441,7 @@ func (c *FullNodeStruct) ClientRetrieveWithEvents(ctx context.Context, order api
 	return c.Internal.ClientRetrieveWithEvents(ctx, order, ref)
 }
 
-func (c *FullNodeStruct) ClientQueryAsk(ctx context.Context, p peer.ID, miner address.Address) (*storagemarket.StorageAsk, error) {
+func (c *FullNodeStruct) ClientQueryAsk(ctx context.Context, p peer.ID, miner address.Address) (*storagemarket.SignedStorageAsk, error) {
 	return c.Internal.ClientQueryAsk(ctx, p, miner)
 }
 func (c *FullNodeStruct) ClientCalcCommP(ctx context.Context, inpath string) (*api.CommPRet, error) {
@@ -509,10 +464,6 @@ func (c *FullNodeStruct) ClientDataTransferUpdates(ctx context.Context) (<-chan
 	return c.Internal.ClientDataTransferUpdates(ctx)
 }
 
-func (c *FullNodeStruct) ClientRetrieveTryRestartInsufficientFunds(ctx context.Context, paymentChannel address.Address) error {
-	return c.Internal.ClientRetrieveTryRestartInsufficientFunds(ctx, paymentChannel)
-}
-
 func (c *FullNodeStruct) GasEstimateGasPremium(ctx context.Context, nblocksincl uint64, sender address.Address, gaslimit int64, tsk types.TipSetKey) (types.BigInt, error) {
 	return c.Internal.GasEstimateGasPremium(ctx, nblocksincl, sender, gaslimit, tsk)
 }
@@ -609,7 +560,7 @@ func (c *FullNodeStruct) WalletSignMessage(ctx context.Context, k address.Addres
 	return c.Internal.WalletSignMessage(ctx, k, msg)
 }
 
-func (c *FullNodeStruct) WalletVerify(ctx context.Context, k address.Address, msg []byte, sig *crypto.Signature) (bool, error) {
+func (c *FullNodeStruct) WalletVerify(ctx context.Context, k address.Address, msg []byte, sig *crypto.Signature) bool {
 	return c.Internal.WalletVerify(ctx, k, msg, sig)
 }
 
@@ -633,10 +584,6 @@ func (c *FullNodeStruct) WalletDelete(ctx context.Context, addr address.Address)
 	return c.Internal.WalletDelete(ctx, addr)
 }
 
-func (c *FullNodeStruct) WalletValidateAddress(ctx context.Context, str string) (address.Address, error) {
-	return c.Internal.WalletValidateAddress(ctx, str)
-}
-
 func (c *FullNodeStruct) MpoolGetNonce(ctx context.Context, addr address.Address) (uint64, error) {
 	return c.Internal.MpoolGetNonce(ctx, addr)
 }
@@ -669,10 +616,6 @@ func (c *FullNodeStruct) ChainReadObj(ctx context.Context, obj cid.Cid) ([]byte,
 	return c.Internal.ChainReadObj(ctx, obj)
 }
 
-func (c *FullNodeStruct) ChainDeleteObj(ctx context.Context, obj cid.Cid) error {
-	return c.Internal.ChainDeleteObj(ctx, obj)
-}
-
 func (c *FullNodeStruct) ChainHasObj(ctx context.Context, o cid.Cid) (bool, error) {
 	return c.Internal.ChainHasObj(ctx, o)
 }
@@ -705,8 +648,8 @@ func (c *FullNodeStruct) ChainGetPath(ctx context.Context, from types.TipSetKey,
 	return c.Internal.ChainGetPath(ctx, from, to)
 }
 
-func (c *FullNodeStruct) ChainExport(ctx context.Context, nroots abi.ChainEpoch, iom bool, tsk types.TipSetKey) (<-chan []byte, error) {
-	return c.Internal.ChainExport(ctx, nroots, iom, tsk)
+func (c *FullNodeStruct) ChainExport(ctx context.Context, tsk types.TipSetKey) (<-chan []byte, error) {
+	return c.Internal.ChainExport(ctx, tsk)
 }
 
 func (c *FullNodeStruct) BeaconGetEntry(ctx context.Context, epoch abi.ChainEpoch) (*types.BeaconEntry, error) {
@@ -725,39 +668,27 @@ func (c *FullNodeStruct) SyncIncomingBlocks(ctx context.Context) (<-chan *types.
 	return c.Internal.SyncIncomingBlocks(ctx)
 }
 
-func (c *FullNodeStruct) SyncCheckpoint(ctx context.Context, tsk types.TipSetKey) error {
-	return c.Internal.SyncCheckpoint(ctx, tsk)
-}
-
 func (c *FullNodeStruct) SyncMarkBad(ctx context.Context, bcid cid.Cid) error {
 	return c.Internal.SyncMarkBad(ctx, bcid)
 }
 
-func (c *FullNodeStruct) SyncUnmarkBad(ctx context.Context, bcid cid.Cid) error {
-	return c.Internal.SyncUnmarkBad(ctx, bcid)
-}
-
 func (c *FullNodeStruct) SyncCheckBad(ctx context.Context, bcid cid.Cid) (string, error) {
 	return c.Internal.SyncCheckBad(ctx, bcid)
 }
 
-func (c *FullNodeStruct) SyncValidateTipset(ctx context.Context, tsk types.TipSetKey) (bool, error) {
-	return c.Internal.SyncValidateTipset(ctx, tsk)
-}
-
 func (c *FullNodeStruct) StateNetworkName(ctx context.Context) (dtypes.NetworkName, error) {
 	return c.Internal.StateNetworkName(ctx)
 }
 
-func (c *FullNodeStruct) StateMinerSectors(ctx context.Context, addr address.Address, sectorNos *bitfield.BitField, tsk types.TipSetKey) ([]*miner.SectorOnChainInfo, error) {
-	return c.Internal.StateMinerSectors(ctx, addr, sectorNos, tsk)
+func (c *FullNodeStruct) StateMinerSectors(ctx context.Context, addr address.Address, filter *abi.BitField, filterOut bool, tsk types.TipSetKey) ([]*api.ChainSectorInfo, error) {
+	return c.Internal.StateMinerSectors(ctx, addr, filter, filterOut, tsk)
 }
 
-func (c *FullNodeStruct) StateMinerActiveSectors(ctx context.Context, addr address.Address, tsk types.TipSetKey) ([]*miner.SectorOnChainInfo, error) {
+func (c *FullNodeStruct) StateMinerActiveSectors(ctx context.Context, addr address.Address, tsk types.TipSetKey) ([]*api.ChainSectorInfo, error) {
 	return c.Internal.StateMinerActiveSectors(ctx, addr, tsk)
 }
 
-func (c *FullNodeStruct) StateMinerProvingDeadline(ctx context.Context, addr address.Address, tsk types.TipSetKey) (*dline.Info, error) {
+func (c *FullNodeStruct) StateMinerProvingDeadline(ctx context.Context, addr address.Address, tsk types.TipSetKey) (*miner.DeadlineInfo, error) {
 	return c.Internal.StateMinerProvingDeadline(ctx, addr, tsk)
 }
 
@@ -765,19 +696,19 @@ func (c *FullNodeStruct) StateMinerPower(ctx context.Context, a address.Address,
 	return c.Internal.StateMinerPower(ctx, a, tsk)
 }
 
-func (c *FullNodeStruct) StateMinerInfo(ctx context.Context, actor address.Address, tsk types.TipSetKey) (miner.MinerInfo, error) {
+func (c *FullNodeStruct) StateMinerInfo(ctx context.Context, actor address.Address, tsk types.TipSetKey) (api.MinerInfo, error) {
 	return c.Internal.StateMinerInfo(ctx, actor, tsk)
 }
 
-func (c *FullNodeStruct) StateMinerDeadlines(ctx context.Context, actor address.Address, tsk types.TipSetKey) ([]api.Deadline, error) {
-	return c.Internal.StateMinerDeadlines(ctx, actor, tsk)
+func (c *FullNodeStruct) StateMinerDeadlines(ctx context.Context, m address.Address, tsk types.TipSetKey) ([]*miner.Deadline, error) {
+	return c.Internal.StateMinerDeadlines(ctx, m, tsk)
 }
 
-func (c *FullNodeStruct) StateMinerPartitions(ctx context.Context, m address.Address, dlIdx uint64, tsk types.TipSetKey) ([]api.Partition, error) {
+func (c *FullNodeStruct) StateMinerPartitions(ctx context.Context, m address.Address, dlIdx uint64, tsk types.TipSetKey) ([]*miner.Partition, error) {
 	return c.Internal.StateMinerPartitions(ctx, m, dlIdx, tsk)
 }
 
-func (c *FullNodeStruct) StateMinerFaults(ctx context.Context, actor address.Address, tsk types.TipSetKey) (bitfield.BitField, error) {
+func (c *FullNodeStruct) StateMinerFaults(ctx context.Context, actor address.Address, tsk types.TipSetKey) (abi.BitField, error) {
 	return c.Internal.StateMinerFaults(ctx, actor, tsk)
 }
 
@@ -785,7 +716,7 @@ func (c *FullNodeStruct) StateAllMinerFaults(ctx context.Context, cutoff abi.Cha
 	return c.Internal.StateAllMinerFaults(ctx, cutoff, endTsk)
 }
 
-func (c *FullNodeStruct) StateMinerRecoveries(ctx context.Context, actor address.Address, tsk types.TipSetKey) (bitfield.BitField, error) {
+func (c *FullNodeStruct) StateMinerRecoveries(ctx context.Context, actor address.Address, tsk types.TipSetKey) (abi.BitField, error) {
 	return c.Internal.StateMinerRecoveries(ctx, actor, tsk)
 }
 
@@ -809,11 +740,11 @@ func (c *FullNodeStruct) StateSectorGetInfo(ctx context.Context, maddr address.A
 	return c.Internal.StateSectorGetInfo(ctx, maddr, n, tsk)
 }
 
-func (c *FullNodeStruct) StateSectorExpiration(ctx context.Context, maddr address.Address, n abi.SectorNumber, tsk types.TipSetKey) (*miner.SectorExpiration, error) {
+func (c *FullNodeStruct) StateSectorExpiration(ctx context.Context, maddr address.Address, n abi.SectorNumber, tsk types.TipSetKey) (*api.SectorExpiration, error) {
 	return c.Internal.StateSectorExpiration(ctx, maddr, n, tsk)
 }
 
-func (c *FullNodeStruct) StateSectorPartition(ctx context.Context, maddr address.Address, sectorNumber abi.SectorNumber, tok types.TipSetKey) (*miner.SectorLocation, error) {
+func (c *FullNodeStruct) StateSectorPartition(ctx context.Context, maddr address.Address, sectorNumber abi.SectorNumber, tok types.TipSetKey) (*api.SectorLocation, error) {
 	return c.Internal.StateSectorPartition(ctx, maddr, sectorNumber, tok)
 }
 
@@ -833,10 +764,6 @@ func (c *FullNodeStruct) StateReadState(ctx context.Context, addr address.Addres
 	return c.Internal.StateReadState(ctx, addr, tsk)
 }
 
-func (c *FullNodeStruct) StateMsgGasCost(ctx context.Context, msgc cid.Cid, tsk types.TipSetKey) (*api.MsgGasCost, error) {
-	return c.Internal.StateMsgGasCost(ctx, msgc, tsk)
-}
-
 func (c *FullNodeStruct) StateWaitMsg(ctx context.Context, msgc cid.Cid, confidence uint64) (*api.MsgLookup, error) {
 	return c.Internal.StateWaitMsg(ctx, msgc, confidence)
 }
@@ -893,7 +820,7 @@ func (c *FullNodeStruct) StateCompute(ctx context.Context, height abi.ChainEpoch
 	return c.Internal.StateCompute(ctx, height, msgs, tsk)
 }
 
-func (c *FullNodeStruct) StateVerifiedClientStatus(ctx context.Context, addr address.Address, tsk types.TipSetKey) (*abi.StoragePower, error) {
+func (c *FullNodeStruct) StateVerifiedClientStatus(ctx context.Context, addr address.Address, tsk types.TipSetKey) (*verifreg.DataCap, error) {
 	return c.Internal.StateVerifiedClientStatus(ctx, addr, tsk)
 }
 
@@ -905,18 +832,10 @@ func (c *FullNodeStruct) StateCirculatingSupply(ctx context.Context, tsk types.T
 	return c.Internal.StateCirculatingSupply(ctx, tsk)
 }
 
-func (c *FullNodeStruct) StateNetworkVersion(ctx context.Context, tsk types.TipSetKey) (stnetwork.Version, error) {
-	return c.Internal.StateNetworkVersion(ctx, tsk)
-}
-
 func (c *FullNodeStruct) MsigGetAvailableBalance(ctx context.Context, a address.Address, tsk types.TipSetKey) (types.BigInt, error) {
 	return c.Internal.MsigGetAvailableBalance(ctx, a, tsk)
 }
 
-func (c *FullNodeStruct) MsigGetVested(ctx context.Context, a address.Address, sTsk types.TipSetKey, eTsk types.TipSetKey) (types.BigInt, error) {
-	return c.Internal.MsigGetVested(ctx, a, sTsk, eTsk)
-}
-
 func (c *FullNodeStruct) MsigCreate(ctx context.Context, req uint64, addrs []address.Address, duration abi.ChainEpoch, val types.BigInt, src address.Address, gp types.BigInt) (cid.Cid, error) {
 	return c.Internal.MsigCreate(ctx, req, addrs, duration, val, src, gp)
 }
@@ -933,18 +852,6 @@ func (c *FullNodeStruct) MsigCancel(ctx context.Context, msig address.Address, t
 	return c.Internal.MsigCancel(ctx, msig, txID, to, amt, src, method, params)
 }
 
-func (c *FullNodeStruct) MsigAddPropose(ctx context.Context, msig address.Address, src address.Address, newAdd address.Address, inc bool) (cid.Cid, error) {
-	return c.Internal.MsigAddPropose(ctx, msig, src, newAdd, inc)
-}
-
-func (c *FullNodeStruct) MsigAddApprove(ctx context.Context, msig address.Address, src address.Address, txID uint64, proposer address.Address, newAdd address.Address, inc bool) (cid.Cid, error) {
-	return c.Internal.MsigAddApprove(ctx, msig, src, txID, proposer, newAdd, inc)
-}
-
-func (c *FullNodeStruct) MsigAddCancel(ctx context.Context, msig address.Address, src address.Address, txID uint64, newAdd address.Address, inc bool) (cid.Cid, error) {
-	return c.Internal.MsigAddCancel(ctx, msig, src, txID, newAdd, inc)
-}
-
 func (c *FullNodeStruct) MsigSwapPropose(ctx context.Context, msig address.Address, src address.Address, oldAdd address.Address, newAdd address.Address) (cid.Cid, error) {
 	return c.Internal.MsigSwapPropose(ctx, msig, src, oldAdd, newAdd)
 }
@@ -969,14 +876,6 @@ func (c *FullNodeStruct) PaychGetWaitReady(ctx context.Context, sentinel cid.Cid
 	return c.Internal.PaychGetWaitReady(ctx, sentinel)
 }
 
-func (c *FullNodeStruct) PaychAvailableFunds(ctx context.Context, ch address.Address) (*api.ChannelAvailableFunds, error) {
-	return c.Internal.PaychAvailableFunds(ctx, ch)
-}
-
-func (c *FullNodeStruct) PaychAvailableFundsByFromTo(ctx context.Context, from, to address.Address) (*api.ChannelAvailableFunds, error) {
-	return c.Internal.PaychAvailableFundsByFromTo(ctx, from, to)
-}
-
 func (c *FullNodeStruct) PaychList(ctx context.Context) ([]address.Address, error) {
 	return c.Internal.PaychList(ctx)
 }
@@ -997,7 +896,7 @@ func (c *FullNodeStruct) PaychVoucherAdd(ctx context.Context, addr address.Addre
 	return c.Internal.PaychVoucherAdd(ctx, addr, sv, proof, minDelta)
 }
 
-func (c *FullNodeStruct) PaychVoucherCreate(ctx context.Context, pch address.Address, amt types.BigInt, lane uint64) (*api.VoucherCreateResult, error) {
+func (c *FullNodeStruct) PaychVoucherCreate(ctx context.Context, pch address.Address, amt types.BigInt, lane uint64) (*paych.SignedVoucher, error) {
 	return c.Internal.PaychVoucherCreate(ctx, pch, amt, lane)
 }
 
@@ -1021,8 +920,8 @@ func (c *FullNodeStruct) PaychNewPayment(ctx context.Context, from, to address.A
 	return c.Internal.PaychNewPayment(ctx, from, to, vouchers)
 }
 
-func (c *FullNodeStruct) PaychVoucherSubmit(ctx context.Context, ch address.Address, sv *paych.SignedVoucher, secret []byte, proof []byte) (cid.Cid, error) {
-	return c.Internal.PaychVoucherSubmit(ctx, ch, sv, secret, proof)
+func (c *FullNodeStruct) PaychVoucherSubmit(ctx context.Context, ch address.Address, sv *paych.SignedVoucher) (cid.Cid, error) {
+	return c.Internal.PaychVoucherSubmit(ctx, ch, sv)
 }
 
 // StorageMinerStruct
@@ -1157,7 +1056,7 @@ func (c *StorageMinerStruct) MarketImportDealData(ctx context.Context, propcid c
 	return c.Internal.MarketImportDealData(ctx, propcid, path)
 }
 
-func (c *StorageMinerStruct) MarketListDeals(ctx context.Context) ([]api.MarketDeal, error) {
+func (c *StorageMinerStruct) MarketListDeals(ctx context.Context) ([]storagemarket.StorageDeal, error) {
 	return c.Internal.MarketListDeals(ctx)
 }
 
@@ -1165,8 +1064,8 @@ func (c *StorageMinerStruct) MarketListRetrievalDeals(ctx context.Context) ([]re
 	return c.Internal.MarketListRetrievalDeals(ctx)
 }
 
-func (c *StorageMinerStruct) MarketGetDealUpdates(ctx context.Context) (<-chan storagemarket.MinerDeal, error) {
-	return c.Internal.MarketGetDealUpdates(ctx)
+func (c *StorageMinerStruct) MarketGetDealUpdates(ctx context.Context, d cid.Cid) (<-chan storagemarket.MinerDeal, error) {
+	return c.Internal.MarketGetDealUpdates(ctx, d)
 }
 
 func (c *StorageMinerStruct) MarketListIncompleteDeals(ctx context.Context) ([]storagemarket.MinerDeal, error) {
@@ -1201,7 +1100,7 @@ func (c *StorageMinerStruct) DealsImportData(ctx context.Context, dealPropCid ci
 	return c.Internal.DealsImportData(ctx, dealPropCid, file)
 }
 
-func (c *StorageMinerStruct) DealsList(ctx context.Context) ([]api.MarketDeal, error) {
+func (c *StorageMinerStruct) DealsList(ctx context.Context) ([]storagemarket.StorageDeal, error) {
 	return c.Internal.DealsList(ctx)
 }
 
@@ -1315,12 +1214,8 @@ func (w *WorkerStruct) Remove(ctx context.Context, sector abi.SectorID) error {
 	return w.Internal.Remove(ctx, sector)
 }
 
-func (w *WorkerStruct) MoveStorage(ctx context.Context, sector abi.SectorID, types stores.SectorFileType) error {
-	return w.Internal.MoveStorage(ctx, sector, types)
-}
-
-func (w *WorkerStruct) StorageAddLocal(ctx context.Context, path string) error {
-	return w.Internal.StorageAddLocal(ctx, path)
+func (w *WorkerStruct) MoveStorage(ctx context.Context, sector abi.SectorID) error {
+	return w.Internal.MoveStorage(ctx, sector)
 }
 
 func (w *WorkerStruct) UnsealPiece(ctx context.Context, id abi.SectorID, index storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize, randomness abi.SealRandomness, c cid.Cid) error {

api/cbor_gen.go

@@ -6,8 +6,8 @@ import (
 	"fmt"
 	"io"
 
-	abi "github.com/filecoin-project/go-state-types/abi"
-	paych "github.com/filecoin-project/specs-actors/actors/builtin/paych"
+	"github.com/filecoin-project/specs-actors/actors/abi"
+	"github.com/filecoin-project/specs-actors/actors/builtin/paych"
 	cbg "github.com/whyrusleeping/cbor-gen"
 	xerrors "golang.org/x/xerrors"
 )

api/client/client.go

@@ -1,7 +1,6 @@
 package client
 
 import (
-	"context"
 	"net/http"
 	"net/url"
 	"path"
@@ -15,9 +14,9 @@ import (
 )
 
 // NewCommonRPC creates a new http jsonrpc client.
-func NewCommonRPC(ctx context.Context, addr string, requestHeader http.Header) (api.Common, jsonrpc.ClientCloser, error) {
+func NewCommonRPC(addr string, requestHeader http.Header) (api.Common, jsonrpc.ClientCloser, error) {
 	var res apistruct.CommonStruct
-	closer, err := jsonrpc.NewMergeClient(ctx, addr, "Filecoin",
+	closer, err := jsonrpc.NewMergeClient(addr, "Filecoin",
 		[]interface{}{
 			&res.Internal,
 		},
@@ -28,9 +27,9 @@ func NewCommonRPC(ctx context.Context, addr string, requestHeader http.Header) (
 }
 
 // NewFullNodeRPC creates a new http jsonrpc client.
-func NewFullNodeRPC(ctx context.Context, addr string, requestHeader http.Header) (api.FullNode, jsonrpc.ClientCloser, error) {
+func NewFullNodeRPC(addr string, requestHeader http.Header) (api.FullNode, jsonrpc.ClientCloser, error) {
 	var res apistruct.FullNodeStruct
-	closer, err := jsonrpc.NewMergeClient(ctx, addr, "Filecoin",
+	closer, err := jsonrpc.NewMergeClient(addr, "Filecoin",
 		[]interface{}{
 			&res.CommonStruct.Internal,
 			&res.Internal,
@@ -40,9 +39,9 @@ func NewFullNodeRPC(ctx context.Context, addr string, requestHeader http.Header)
 }
 
 // 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) {
+func NewStorageMinerRPC(addr string, requestHeader http.Header, opts ...jsonrpc.Option) (api.StorageMiner, jsonrpc.ClientCloser, error) {
 	var res apistruct.StorageMinerStruct
-	closer, err := jsonrpc.NewMergeClient(ctx, addr, "Filecoin",
+	closer, err := jsonrpc.NewMergeClient(addr, "Filecoin",
 		[]interface{}{
 			&res.CommonStruct.Internal,
 			&res.Internal,
@@ -54,7 +53,7 @@ func NewStorageMinerRPC(ctx context.Context, addr string, requestHeader http.Hea
 	return &res, closer, err
 }
 
-func NewWorkerRPC(ctx context.Context, addr string, requestHeader http.Header) (api.WorkerAPI, jsonrpc.ClientCloser, error) {
+func NewWorkerRPC(addr string, requestHeader http.Header) (api.WorkerAPI, jsonrpc.ClientCloser, error) {
 	u, err := url.Parse(addr)
 	if err != nil {
 		return nil, nil, err
@@ -70,7 +69,7 @@ func NewWorkerRPC(ctx context.Context, addr string, requestHeader http.Header) (
 	u.Path = path.Join(u.Path, "../streams/v0/push")
 
 	var res apistruct.WorkerStruct
-	closer, err := jsonrpc.NewMergeClient(ctx, addr, "Filecoin",
+	closer, err := jsonrpc.NewMergeClient(addr, "Filecoin",
 		[]interface{}{
 			&res.Internal,
 		},

api/docgen/docgen.go

@@ -12,31 +12,22 @@ import (
 	"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"
+	"github.com/filecoin-project/specs-actors/actors/abi"
+	"github.com/filecoin-project/specs-actors/actors/crypto"
+	"github.com/filecoin-project/specs-actors/actors/runtime/exitcode"
+	"github.com/ipfs/go-cid"
+	"github.com/ipfs/go-filestore"
+	"github.com/libp2p/go-libp2p-core/network"
+	peer "github.com/libp2p/go-libp2p-peer"
+	"github.com/multiformats/go-multiaddr"
 )
 
 var ExampleValues = map[reflect.Type]interface{}{
@@ -75,12 +66,11 @@ func init() {
 
 	ExampleValues[reflect.TypeOf(addr)] = addr
 
-	pid, err := peer.Decode("12D3KooWGzxzKZYveHXtpG6AsrUJBcWxHBFS2HsEoGTxrMLvKXtf")
+	pid, err := peer.IDB58Decode("12D3KooWGzxzKZYveHXtpG6AsrUJBcWxHBFS2HsEoGTxrMLvKXtf")
 	if err != nil {
 		panic(err)
 	}
 	addExample(pid)
-	addExample(&pid)
 
 	addExample(bitfield.NewFromSet([]uint64{5}))
 	addExample(abi.RegisteredSealProof_StackedDrg32GiBV1)
@@ -105,16 +95,9 @@ func init() {
 	addExample(network.Connected)
 	addExample(dtypes.NetworkName("lotus"))
 	addExample(api.SyncStateStage(1))
-	addExample(build.FullAPIVersion)
+	addExample(build.APIVersion)
 	addExample(api.PCHInbound)
 	addExample(time.Minute)
-	addExample(datatransfer.TransferID(3))
-	addExample(datatransfer.Ongoing)
-	addExample(multistore.StoreID(50))
-	addExample(retrievalmarket.ClientEventDealAccepted)
-	addExample(retrievalmarket.DealStatusNew)
-	addExample(network.ReachabilityPublic)
-	addExample(build.NewestNetworkVersion)
 	addExample(&types.ExecutionTrace{
 		Msg:    exampleValue(reflect.TypeOf(&types.Message{}), nil).(*types.Message),
 		MsgRct: exampleValue(reflect.TypeOf(&types.MessageReceipt{}), nil).(*types.MessageReceipt),
@@ -128,30 +111,6 @@ func init() {
 	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 {

api/test/blockminer.go

@@ -7,8 +7,8 @@ import (
 	"testing"
 	"time"
 
-	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/lotus/miner"
+	"github.com/filecoin-project/specs-actors/actors/abi"
 )
 
 type BlockMiner struct {
@@ -41,7 +41,7 @@ func (bm *BlockMiner) MineBlocks() {
 			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) {},
+				Done:        func(bool, error) {},
 			}); err != nil {
 				bm.t.Error(err)
 			}

api/test/ccupgrade.go

@@ -10,7 +10,7 @@ import (
 
 	"github.com/stretchr/testify/require"
 
-	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/specs-actors/actors/abi"
 
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/node/impl"
@@ -85,7 +85,6 @@ func TestCCUpgrade(t *testing.T, b APIBuilder, blocktime time.Duration) {
 	{
 		exp, err := client.StateSectorExpiration(ctx, maddr, CC, types.EmptyTSK)
 		require.NoError(t, err)
-		require.NotNil(t, exp)
 		require.Greater(t, 50000, int(exp.OnTime))
 	}
 	{
@@ -94,22 +93,6 @@ func TestCCUpgrade(t *testing.T, b APIBuilder, blocktime time.Duration) {
 		require.Less(t, 50000, int(exp.OnTime))
 	}
 
-	dlInfo, err := client.StateMinerProvingDeadline(ctx, maddr, types.EmptyTSK)
-	require.NoError(t, err)
-
-	// Sector should expire.
-	for {
-		// Wait for the sector to expire.
-		status, err := miner.SectorsStatus(ctx, CC, true)
-		require.NoError(t, err)
-		if status.OnTime == 0 && status.Early == 0 {
-			break
-		}
-		t.Log("waiting for sector to expire")
-		// wait one deadline per loop.
-		time.Sleep(time.Duration(dlInfo.WPoStChallengeWindow) * blocktime)
-	}
-
 	fmt.Println("shutting down mining")
 	atomic.AddInt64(&mine, -1)
 	<-done

api/test/deals.go

@@ -20,7 +20,6 @@ import (
 	"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"
@@ -36,7 +35,7 @@ import (
 
 var MineNext = miner.MineReq{
 	InjectNulls: 0,
-	Done:        func(bool, abi.ChainEpoch, error) {},
+	Done:        func(bool, error) {},
 }
 
 func init() {
@@ -142,7 +141,7 @@ func makeDeal(t *testing.T, ctx context.Context, rseed int, client *impl.FullNod
 	info, err := client.ClientGetDealInfo(ctx, *deal)
 	require.NoError(t, err)
 
-	testRetrieval(t, ctx, client, fcid, &info.PieceCID, carExport, data)
+	testRetrieval(t, ctx, err, client, fcid, &info.PieceCID, carExport, data)
 }
 
 func TestFastRetrievalDealFlow(t *testing.T, b APIBuilder, blocktime time.Duration) {
@@ -194,7 +193,7 @@ func TestFastRetrievalDealFlow(t *testing.T, b APIBuilder, blocktime time.Durati
 	info, err := client.ClientGetDealInfo(ctx, *deal)
 	require.NoError(t, err)
 
-	testRetrieval(t, ctx, client, fcid, &info.PieceCID, false, data)
+	testRetrieval(t, ctx, err, client, fcid, &info.PieceCID, false, data)
 	atomic.AddInt64(&mine, -1)
 	fmt.Println("shutting down mining")
 	<-done
@@ -268,7 +267,7 @@ func TestSenondDealRetrieval(t *testing.T, b APIBuilder, blocktime time.Duration
 		rf, _ := miner.SectorsRefs(ctx)
 		fmt.Printf("refs: %+v\n", rf)
 
-		testRetrieval(t, ctx, client, fcid2, &info.PieceCID, false, data2)
+		testRetrieval(t, ctx, err, client, fcid2, &info.PieceCID, false, data2)
 	}
 
 	atomic.AddInt64(&mine, -1)
@@ -334,7 +333,7 @@ loop:
 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)
+	updates, err := miner.MarketGetDealUpdates(subCtx, *deal)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -343,20 +342,18 @@ func waitDealPublished(t *testing.T, ctx context.Context, miner TestStorageNode,
 		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])
+			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])
 		}
 	}
 }
@@ -376,7 +373,7 @@ func startSealingWaiting(t *testing.T, ctx context.Context, miner TestStorageNod
 	}
 }
 
-func testRetrieval(t *testing.T, ctx context.Context, client *impl.FullNodeAPI, fcid cid.Cid, piece *cid.Cid, carExport bool, data []byte) {
+func testRetrieval(t *testing.T, ctx context.Context, err error, 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)

api/test/mining.go

@@ -12,7 +12,7 @@ import (
 
 	logging "github.com/ipfs/go-log/v2"
 
-	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/specs-actors/actors/abi"
 	"github.com/stretchr/testify/require"
 
 	"github.com/filecoin-project/lotus/build"
@@ -20,7 +20,6 @@ import (
 	"github.com/filecoin-project/lotus/node/impl"
 )
 
-//nolint:deadcode,varcheck
 var log = logging.Logger("apitest")
 
 func (ts *testSuite) testMining(t *testing.T) {
@@ -31,20 +30,22 @@ func (ts *testSuite) testMining(t *testing.T) {
 	newHeads, err := api.ChainNotify(ctx)
 	require.NoError(t, err)
 	initHead := (<-newHeads)[0]
-	baseHeight := initHead.Val.Height()
+	if initHead.Val.Height() != 2 {
+		<-newHeads
+	}
 
 	h1, err := api.ChainHead(ctx)
 	require.NoError(t, err)
-	require.Equal(t, int64(h1.Height()), int64(baseHeight))
+	require.Equal(t, abi.ChainEpoch(2), h1.Height())
 
-	MineUntilBlock(ctx, t, apis[0], sn[0], nil)
+	err = sn[0].MineOne(ctx, MineNext)
 	require.NoError(t, err)
 
 	<-newHeads
 
 	h2, err := api.ChainHead(ctx)
 	require.NoError(t, err)
-	require.Greater(t, int64(h2.Height()), int64(h1.Height()))
+	require.Equal(t, abi.ChainEpoch(3), h2.Height())
 }
 
 func (ts *testSuite) testMiningReal(t *testing.T) {
@@ -68,7 +69,7 @@ func (ts *testSuite) testMiningReal(t *testing.T) {
 	require.NoError(t, err)
 	require.Equal(t, abi.ChainEpoch(2), h1.Height())
 
-	MineUntilBlock(ctx, t, apis[0], sn[0], nil)
+	err = sn[0].MineOne(ctx, MineNext)
 	require.NoError(t, err)
 
 	<-newHeads
@@ -77,7 +78,7 @@ func (ts *testSuite) testMiningReal(t *testing.T) {
 	require.NoError(t, err)
 	require.Equal(t, abi.ChainEpoch(3), h2.Height())
 
-	MineUntilBlock(ctx, t, apis[0], sn[0], nil)
+	err = sn[0].MineOne(ctx, MineNext)
 	require.NoError(t, err)
 
 	<-newHeads
@@ -142,7 +143,7 @@ func TestDealMining(t *testing.T, b APIBuilder, blocktime time.Duration, carExpo
 		complChan := minedTwo
 		for atomic.LoadInt32(&mine) != 0 {
 			wait := make(chan int)
-			mdone := func(mined bool, _ abi.ChainEpoch, err error) {
+			mdone := func(mined bool, err error) {
 				n := 0
 				if mined {
 					n = 1

api/test/paych.go

@@ -8,21 +8,17 @@ import (
 	"testing"
 	"time"
 
-	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
-	paych0 "github.com/filecoin-project/specs-actors/actors/builtin/paych"
+	"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/abi"
+	"github.com/filecoin-project/specs-actors/actors/abi/big"
+	"github.com/filecoin-project/specs-actors/actors/builtin/paych"
 	"github.com/ipfs/go-cid"
 
 	"github.com/filecoin-project/go-address"
-	cbor "github.com/ipfs/go-ipld-cbor"
 
 	"github.com/filecoin-project/lotus/api"
-	"github.com/filecoin-project/lotus/api/apibstore"
 	"github.com/filecoin-project/lotus/build"
-	"github.com/filecoin-project/lotus/chain/actors/adt"
-	"github.com/filecoin-project/lotus/chain/actors/builtin/paych"
 	"github.com/filecoin-project/lotus/chain/events"
 	"github.com/filecoin-project/lotus/chain/events/state"
 	"github.com/filecoin-project/lotus/chain/types"
@@ -100,24 +96,18 @@ func TestPaymentChannels(t *testing.T, b APIBuilder, blocktime time.Duration) {
 		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))
+		delta1, err := paymentReceiver.PaychVoucherAdd(ctx, channel, vouch1, 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))
+		delta2, err := paymentReceiver.PaychVoucherAdd(ctx, channel, vouch2, nil, abi.NewTokenAmount(1000))
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -137,26 +127,17 @@ func TestPaymentChannels(t *testing.T, b APIBuilder, blocktime time.Duration) {
 		t.Fatal("Unable to settle payment channel")
 	}
 
-	creatorStore := adt.WrapStore(ctx, cbor.NewCborStore(apibstore.NewAPIBlockstore(paymentCreator)))
-
 	// wait for the receiver to submit their vouchers
 	ev := events.NewEvents(ctx, paymentCreator)
 	preds := state.NewStatePredicates(paymentCreator)
 	finished := make(chan struct{})
 	err = ev.StateChanged(func(ts *types.TipSet) (done bool, more bool, err error) {
-		act, err := paymentCreator.StateGetActor(ctx, channel, ts.Key())
+		act, err := paymentCreator.StateReadState(ctx, channel, ts.Key())
 		if err != nil {
 			return false, false, err
 		}
-		state, err := paych.Load(creatorStore, act)
-		if err != nil {
-			return false, false, err
-		}
-		toSend, err := state.ToSend()
-		if err != nil {
-			return false, false, err
-		}
-		if toSend.GreaterThanEqual(abi.NewTokenAmount(6000)) {
+		state := act.State.(paych.State)
+		if state.ToSend.GreaterThanEqual(abi.NewTokenAmount(6000)) {
 			return true, false, nil
 		}
 		return false, true, nil
@@ -169,12 +150,9 @@ func TestPaymentChannels(t *testing.T, b APIBuilder, blocktime time.Duration) {
 		return true, nil
 	}, func(ctx context.Context, ts *types.TipSet) error {
 		return nil
-	}, int(build.MessageConfidence)+1, build.Finality, func(oldTs, newTs *types.TipSet) (bool, events.StateChange, error) {
+	}, int(build.MessageConfidence)+1, build.SealRandomnessLookbackLimit, func(oldTs, newTs *types.TipSet) (bool, events.StateChange, error) {
 		return preds.OnPaymentChannelActorChanged(channel, preds.OnToSendAmountChanges())(ctx, oldTs.Key(), newTs.Key())
 	})
-	if err != nil {
-		t.Fatal(err)
-	}
 
 	select {
 	case <-finished:
@@ -183,7 +161,7 @@ func TestPaymentChannels(t *testing.T, b APIBuilder, blocktime time.Duration) {
 	}
 
 	// wait for the settlement period to pass before collecting
-	waitForBlocks(ctx, t, bm, paymentReceiver, receiverAddr, paych0.SettleDelay)
+	waitForBlocks(ctx, t, bm, paymentReceiver, receiverAddr, paych.SettleDelay)
 
 	creatorPreCollectBalance, err := paymentCreator.WalletBalance(ctx, createrAddr)
 	if err != nil {
@@ -239,7 +217,7 @@ func waitForBlocks(ctx context.Context, t *testing.T, bm *BlockMiner, paymentRec
 
 		// Add a real block
 		m, err := paymentReceiver.MpoolPushMessage(ctx, &types.Message{
-			To:    builtin0.BurntFundsActorAddr,
+			To:    builtin.BurntFundsActorAddr,
 			From:  receiverAddr,
 			Value: types.NewInt(0),
 		}, nil)

api/test/test.go

@@ -65,8 +65,6 @@ func TestApis(t *testing.T, b APIBuilder) {
 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)
 	api := apis[0]

api/test/util.go

@@ -3,13 +3,11 @@ package test
 import (
 	"context"
 	"testing"
-	"time"
 
-	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/specs-actors/actors/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) {
@@ -36,51 +34,3 @@ func SendFunds(ctx context.Context, t *testing.T, sender TestNode, addr address.
 		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...")
-}

api/test/window_post.go

@@ -12,9 +12,10 @@ import (
 	"github.com/stretchr/testify/require"
 
 	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/lotus/extern/sector-storage/mock"
 	sealing "github.com/filecoin-project/lotus/extern/storage-sealing"
+	"github.com/filecoin-project/specs-actors/actors/abi"
+	miner2 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
 
 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/build"
@@ -23,14 +24,9 @@ import (
 	"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) {
+	os.Setenv("BELLMAN_NO_GPU", "1")
+
 	ctx := context.Background()
 	n, sn := b(t, 1, OneMiner)
 	client := n[0].FullNode.(*impl.FullNodeAPI)
@@ -52,7 +48,7 @@ func TestPledgeSector(t *testing.T, b APIBuilder, blocktime time.Duration, nSect
 		defer close(done)
 		for mine {
 			build.Clock.Sleep(blocktime)
-			if err := sn[0].MineOne(ctx, bminer.MineReq{Done: func(bool, abi.ChainEpoch, error) {
+			if err := sn[0].MineOne(ctx, bminer.MineReq{Done: func(bool, error) {
 
 			}}); err != nil {
 				t.Error(err)
@@ -114,6 +110,8 @@ func pledgeSectors(t *testing.T, ctx context.Context, miner TestStorageNode, n,
 }
 
 func TestWindowPost(t *testing.T, b APIBuilder, blocktime time.Duration, nSectors int) {
+	os.Setenv("BELLMAN_NO_GPU", "1")
+
 	ctx := context.Background()
 	n, sn := b(t, 1, OneMiner)
 	client := n[0].FullNode.(*impl.FullNodeAPI)
@@ -153,16 +151,18 @@ func TestWindowPost(t *testing.T, b APIBuilder, blocktime time.Duration, nSector
 	require.NoError(t, err)
 
 	fmt.Printf("Running one proving period\n")
-	fmt.Printf("End for head.Height > %d\n", di.PeriodStart+di.WPoStProvingPeriod+2)
 
 	for {
 		head, err := client.ChainHead(ctx)
 		require.NoError(t, err)
 
-		if head.Height() > di.PeriodStart+(di.WPoStProvingPeriod)+2 {
-			fmt.Printf("Now head.Height = %d\n", head.Height())
+		if head.Height() > di.PeriodStart+(miner2.WPoStProvingPeriod)+2 {
 			break
 		}
+
+		if head.Height()%100 == 0 {
+			fmt.Printf("@%d\n", head.Height())
+		}
 		build.Clock.Sleep(blocktime)
 	}
 
@@ -183,14 +183,13 @@ func TestWindowPost(t *testing.T, b APIBuilder, blocktime time.Duration, nSector
 		require.NoError(t, err)
 		require.Greater(t, len(parts), 0)
 
-		secs := parts[0].AllSectors
-		n, err := secs.Count()
+		n, err := parts[0].Sectors.Count()
 		require.NoError(t, err)
 		require.Equal(t, uint64(2), n)
 
 		// Drop the partition
-		err = secs.ForEach(func(sid uint64) error {
-			return miner.StorageMiner.(*impl.StorageMinerAPI).IStorageMgr.(*mock.SectorMgr).MarkCorrupted(abi.SectorID{
+		err = parts[0].Sectors.ForEach(func(sid uint64) error {
+			return miner.StorageMiner.(*impl.StorageMinerAPI).IStorageMgr.(*mock.SectorMgr).MarkFailed(abi.SectorID{
 				Miner:  abi.ActorID(mid),
 				Number: abi.SectorNumber(sid),
 			}, true)
@@ -206,19 +205,14 @@ func TestWindowPost(t *testing.T, b APIBuilder, blocktime time.Duration, nSector
 		require.NoError(t, err)
 		require.Greater(t, len(parts), 0)
 
-		secs := parts[0].AllSectors
-		n, err := secs.Count()
+		n, err := parts[0].Sectors.Count()
 		require.NoError(t, err)
 		require.Equal(t, uint64(2), n)
 
 		// Drop the sector
-		sn, err := secs.First()
+		sn, err := parts[0].Sectors.First()
 		require.NoError(t, err)
 
-		all, err := secs.All(2)
-		require.NoError(t, err)
-		fmt.Println("the sectors", all)
-
 		s = abi.SectorID{
 			Miner:  abi.ActorID(mid),
 			Number: abi.SectorNumber(sn),
@@ -232,17 +226,18 @@ func TestWindowPost(t *testing.T, b APIBuilder, blocktime time.Duration, nSector
 	require.NoError(t, err)
 
 	fmt.Printf("Go through another PP, wait for sectors to become faulty\n")
-	fmt.Printf("End for head.Height > %d\n", di.PeriodStart+di.WPoStProvingPeriod+2)
 
 	for {
 		head, err := client.ChainHead(ctx)
 		require.NoError(t, err)
 
-		if head.Height() > di.PeriodStart+(di.WPoStProvingPeriod)+2 {
-			fmt.Printf("Now head.Height = %d\n", head.Height())
+		if head.Height() > di.PeriodStart+(miner2.WPoStProvingPeriod)+2 {
 			break
 		}
 
+		if head.Height()%100 == 0 {
+			fmt.Printf("@%d\n", head.Height())
+		}
 		build.Clock.Sleep(blocktime)
 	}
 
@@ -262,17 +257,17 @@ func TestWindowPost(t *testing.T, b APIBuilder, blocktime time.Duration, nSector
 	di, err = client.StateMinerProvingDeadline(ctx, maddr, types.EmptyTSK)
 	require.NoError(t, err)
 
-	fmt.Printf("End for head.Height > %d\n", di.PeriodStart+di.WPoStProvingPeriod+2)
-
 	for {
 		head, err := client.ChainHead(ctx)
 		require.NoError(t, err)
 
-		if head.Height() > di.PeriodStart+di.WPoStProvingPeriod+2 {
-			fmt.Printf("Now head.Height = %d\n", head.Height())
+		if head.Height() > di.PeriodStart+(miner2.WPoStProvingPeriod)+2 {
 			break
 		}
 
+		if head.Height()%100 == 0 {
+			fmt.Printf("@%d\n", head.Height())
+		}
 		build.Clock.Sleep(blocktime)
 	}
 
@@ -295,14 +290,12 @@ func TestWindowPost(t *testing.T, b APIBuilder, blocktime time.Duration, nSector
 		require.NoError(t, err)
 
 		waitUntil := head.Height() + 10
-		fmt.Printf("End for head.Height > %d\n", waitUntil)
 
 		for {
 			head, err := client.ChainHead(ctx)
 			require.NoError(t, err)
 
 			if head.Height() > waitUntil {
-				fmt.Printf("Now head.Height = %d\n", head.Height())
 				break
 			}
 		}

api/types.go

@@ -4,9 +4,11 @@ import (
 	"encoding/json"
 	"fmt"
 
+	"github.com/filecoin-project/go-address"
 	datatransfer "github.com/filecoin-project/go-data-transfer"
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/specs-actors/actors/abi"
+	"github.com/filecoin-project/specs-actors/actors/abi/big"
+	"github.com/filecoin-project/specs-actors/actors/builtin/miner"
 	"github.com/ipfs/go-cid"
 
 	"github.com/libp2p/go-libp2p-core/peer"
@@ -47,13 +49,54 @@ type PubsubScore struct {
 	Score *pubsub.PeerScoreSnapshot
 }
 
+type MinerInfo struct {
+	Owner                      address.Address   // Must be an ID-address.
+	Worker                     address.Address   // Must be an ID-address.
+	NewWorker                  address.Address   // Must be an ID-address.
+	ControlAddresses           []address.Address // Must be an ID-addresses.
+	WorkerChangeEpoch          abi.ChainEpoch
+	PeerId                     *peer.ID
+	Multiaddrs                 []abi.Multiaddrs
+	SealProofType              abi.RegisteredSealProof
+	SectorSize                 abi.SectorSize
+	WindowPoStPartitionSectors uint64
+}
+
+func NewApiMinerInfo(info *miner.MinerInfo) MinerInfo {
+	var pid *peer.ID
+	if peerID, err := peer.IDFromBytes(info.PeerId); err == nil {
+		pid = &peerID
+	}
+
+	mi := MinerInfo{
+		Owner:            info.Owner,
+		Worker:           info.Worker,
+		ControlAddresses: info.ControlAddresses,
+
+		NewWorker:         address.Undef,
+		WorkerChangeEpoch: -1,
+
+		PeerId:                     pid,
+		Multiaddrs:                 info.Multiaddrs,
+		SealProofType:              info.SealProofType,
+		SectorSize:                 info.SectorSize,
+		WindowPoStPartitionSectors: info.WindowPoStPartitionSectors,
+	}
+
+	if info.PendingWorkerKey != nil {
+		mi.NewWorker = info.PendingWorkerKey.NewWorker
+		mi.WorkerChangeEpoch = info.PendingWorkerKey.EffectiveAt
+	}
+
+	return mi
+}
+
 type MessageSendSpec struct {
 	MaxFee abi.TokenAmount
 }
 
 var DefaultMessageSendSpec = MessageSendSpec{
-	// MaxFee of 0.1FIL
-	MaxFee: abi.NewTokenAmount(int64(build.FilecoinPrecision) / 10),
+	MaxFee: big.Zero(),
 }
 
 func (ms *MessageSendSpec) Get() MessageSendSpec {

api/utils.go

@@ -4,7 +4,7 @@ import (
 	"context"
 
 	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/crypto"
+	"github.com/filecoin-project/specs-actors/actors/crypto"
 )
 
 type SignFunc = func(context.Context, []byte) (*crypto.Signature, error)

build/bootstrap/bootstrappers.pi

@@ -1,4 +1,6 @@
-/dns4/bootstrap-0.calibration.fildev.network/tcp/1347/p2p/12D3KooWMEfi7K4zWWHP4dCf2iCeepUu9iNcVm6Xk8mTDq4E8rUi
-/dns4/bootstrap-1.calibration.fildev.network/tcp/1347/p2p/12D3KooWL4rBBKBRMr91Ej4b1WaSAaoHzPr2zBF9zJ4io8dDuHHT
-/dns4/bootstrap-2.calibration.fildev.network/tcp/1347/p2p/12D3KooWHTBk2eTBFf7F25Zdxue5iYzkwMRxN4sHApzTXq7siZ9g
-/dns4/bootstrap-3.calibration.fildev.network/tcp/1347/p2p/12D3KooWHRpygG9qTq2bP9SWVfgbD6KgbGxNZuEnpDjgRujJATV6
+/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

build/drand.go

@@ -1,26 +1,15 @@
 package build
 
-import (
-	"sort"
+import "github.com/filecoin-project/lotus/node/modules/dtypes"
 
-	"github.com/filecoin-project/lotus/node/modules/dtypes"
-)
+var DrandNetwork = DrandIncentinet
+
+func DrandConfig() dtypes.DrandConfig {
+	return DrandConfigs[DrandNetwork]
+}
 
 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

build/params_2k.go

@@ -3,27 +3,19 @@
 package build
 
 import (
-	"github.com/filecoin-project/go-state-types/abi"
-
-	"github.com/filecoin-project/lotus/chain/actors/policy"
+	"github.com/filecoin-project/specs-actors/actors/abi"
+	"github.com/filecoin-project/specs-actors/actors/abi/big"
+	"github.com/filecoin-project/specs-actors/actors/builtin/miner"
+	"github.com/filecoin-project/specs-actors/actors/builtin/power"
+	"github.com/filecoin-project/specs-actors/actors/builtin/verifreg"
 )
 
-const UpgradeBreezeHeight = -1
-const BreezeGasTampingDuration = 0
-
-const UpgradeSmokeHeight = -1
-const UpgradeIgnitionHeight = -2
-const UpgradeLiftoffHeight = -3
-const UpgradeActorsV2Height = 10
-
-var DrandSchedule = map[abi.ChainEpoch]DrandEnum{
-	0: DrandMainnet,
-}
-
 func init() {
-	policy.SetSupportedProofTypes(abi.RegisteredSealProof_StackedDrg2KiBV1)
-	policy.SetConsensusMinerMinPower(abi.NewStoragePower(2048))
-	policy.SetMinVerifiedDealSize(abi.NewStoragePower(256))
+	power.ConsensusMinerMinPower = big.NewInt(2048)
+	miner.SupportedProofTypes = map[abi.RegisteredSealProof]struct{}{
+		abi.RegisteredSealProof_StackedDrg2KiBV1: {},
+	}
+	verifreg.MinVerifiedDealSize = big.NewInt(256)
 
 	BuildType |= Build2k
 }

build/params_shared_funcs.go

@@ -3,19 +3,17 @@ package build
 import (
 	"sort"
 
-	"github.com/filecoin-project/go-address"
-
 	"github.com/libp2p/go-libp2p-core/protocol"
 
-	"github.com/filecoin-project/go-state-types/abi"
-	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
+	"github.com/filecoin-project/specs-actors/actors/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(miner0.SupportedProofTypes))
-	for spt := range miner0.SupportedProofTypes {
+	szs := make([]abi.SectorSize, 0, len(miner.SupportedProofTypes))
+	for spt := range miner.SupportedProofTypes {
 		ss, err := spt.SectorSize()
 		if err != nil {
 			panic(err)
@@ -38,15 +36,3 @@ func MessagesTopic(netName dtypes.NetworkName) string { return "/fil/msgs/" + st
 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 && UpgradeActorsV2Height <= 0 {
-		return true
-	}
-	return false
-}
-
-func SetAddressNetwork(n address.Network) {
-	address.CurrentNetwork = n
-}

build/params_shared_vals.go

@@ -4,15 +4,10 @@ package build
 
 import (
 	"math/big"
-	"os"
 
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/lotus/chain/actors/policy"
-
-	"github.com/filecoin-project/go-state-types/network"
-
-	"github.com/filecoin-project/go-state-types/abi"
+	"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"
 )
 
 // /////
@@ -25,8 +20,6 @@ const UnixfsLinksPerLevel = 1024
 // Consensus / Network
 
 const AllowableClockDriftSecs = uint64(1)
-const NewestNetworkVersion = network.Version4
-const ActorUpgradeNetworkVersion = network.Version4
 
 // Epochs
 const ForkLengthThreshold = Finality
@@ -35,7 +28,7 @@ const ForkLengthThreshold = Finality
 var BlocksPerEpoch = uint64(builtin.ExpectedLeadersPerEpoch)
 
 // Epochs
-const Finality = policy.ChainFinality
+const Finality = miner.ChainFinality
 const MessageConfidence = uint64(5)
 
 // constants for Weight calculation
@@ -47,8 +40,13 @@ const WRatioDen = uint64(2)
 // Proofs
 
 // Epochs
-// TODO: unused
-const SealRandomnessLookback = policy.SealRandomnessLookback
+const SealRandomnessLookback = Finality
+
+// Epochs
+const SealRandomnessLookbackLimit = SealRandomnessLookback + 2000 // TODO: Get from spec specs-actors
+
+// Maximum lookback that randomness can be sourced from for a seal proof submission
+const MaxSealLookback = SealRandomnessLookbackLimit + 2000 // TODO: Get from specs-actors
 
 // /////
 // Mining
@@ -58,16 +56,9 @@ const TicketRandomnessLookback = abi.ChainEpoch(1)
 
 const WinningPoStSectorSetLookback = abi.ChainEpoch(10)
 
-// /////
-// Address
-
-const AddressMainnetEnvVar = "_mainnet_"
-
 // /////
 // Devnet settings
 
-var Devnet = true
-
 const FilBase = uint64(2_000_000_000)
 const FilAllocStorageMining = uint64(1_100_000_000)
 
@@ -80,10 +71,6 @@ var InitialRewardBalance *big.Int
 func init() {
 	InitialRewardBalance = big.NewInt(int64(FilAllocStorageMining))
 	InitialRewardBalance = InitialRewardBalance.Mul(InitialRewardBalance, big.NewInt(int64(FilecoinPrecision)))
-
-	if os.Getenv("LOTUS_ADDRESS_TYPE") == AddressMainnetEnvVar {
-		SetAddressNetwork(address.Mainnet)
-	}
 }
 
 // Sync

build/params_testground.go

@@ -10,11 +10,9 @@ 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/abi"
 	"github.com/filecoin-project/specs-actors/actors/builtin"
-
-	"github.com/filecoin-project/lotus/chain/actors/policy"
+	"github.com/filecoin-project/specs-actors/actors/builtin/miner"
 )
 
 var (
@@ -33,7 +31,7 @@ var (
 
 	AllowableClockDriftSecs = uint64(1)
 
-	Finality            = policy.ChainFinality
+	Finality            = miner.ChainFinality
 	ForkLengthThreshold = Finality
 
 	SlashablePowerDelay        = 20
@@ -48,7 +46,9 @@ var (
 	BlsSignatureCacheSize = 40000
 	VerifSigCacheSize     = 32000
 
-	SealRandomnessLookback = policy.SealRandomnessLookback
+	SealRandomnessLookback      = Finality
+	SealRandomnessLookbackLimit = SealRandomnessLookback + 2000
+	MaxSealLookback             = SealRandomnessLookbackLimit + 2000
 
 	TicketRandomnessLookback     = abi.ChainEpoch(1)
 	WinningPoStSectorSetLookback = abi.ChainEpoch(10)
@@ -69,21 +69,4 @@ var (
 
 	PackingEfficiencyNum   int64 = 4
 	PackingEfficiencyDenom int64 = 5
-
-	UpgradeBreezeHeight      abi.ChainEpoch = -1
-	BreezeGasTampingDuration abi.ChainEpoch = 0
-
-	UpgradeSmokeHeight    abi.ChainEpoch = -1
-	UpgradeIgnitionHeight abi.ChainEpoch = -2
-	UpgradeLiftoffHeight  abi.ChainEpoch = -3
-	UpgradeActorsV2Height abi.ChainEpoch = 10
-
-	DrandSchedule = map[abi.ChainEpoch]DrandEnum{
-		0: DrandMainnet,
-	}
-
-	NewestNetworkVersion       = network.Version4
-	ActorUpgradeNetworkVersion = network.Version4
-
-	Devnet = true
 )

build/params_testnet.go

@@ -5,40 +5,21 @@
 package build
 
 import (
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/lotus/chain/actors/policy"
-
-	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
+	"github.com/filecoin-project/specs-actors/actors/abi"
+	"github.com/filecoin-project/specs-actors/actors/abi/big"
+	"github.com/filecoin-project/specs-actors/actors/builtin"
+	"github.com/filecoin-project/specs-actors/actors/builtin/miner"
+	"github.com/filecoin-project/specs-actors/actors/builtin/power"
 )
 
-var DrandSchedule = map[abi.ChainEpoch]DrandEnum{
-	0: DrandMainnet,
-}
-
-const UpgradeBreezeHeight = -1
-const BreezeGasTampingDuration = 120
-
-const UpgradeSmokeHeight = -2
-
-const UpgradeIgnitionHeight = -3
-
-const UpgradeActorsV2Height = 500
-
-// This signals our tentative epoch for mainnet launch. Can make it later, but not earlier.
-// Miners, clients, developers, custodians all need time to prepare.
-// We still have upgrades and state changes to do, but can happen after signaling timing here.
-const UpgradeLiftoffHeight = 148888
-
 func init() {
-	policy.SetConsensusMinerMinPower(abi.NewStoragePower(10 << 30))
-	policy.SetSupportedProofTypes(
-		abi.RegisteredSealProof_StackedDrg512MiBV1,
-		abi.RegisteredSealProof_StackedDrg32GiBV1,
-		abi.RegisteredSealProof_StackedDrg64GiBV1,
-	)
-	Devnet = false
+	power.ConsensusMinerMinPower = big.NewInt(10 << 40)
+	miner.SupportedProofTypes = map[abi.RegisteredSealProof]struct{}{
+		abi.RegisteredSealProof_StackedDrg32GiBV1: {},
+		abi.RegisteredSealProof_StackedDrg64GiBV1: {},
+	}
 }
 
-const BlockDelaySecs = uint64(builtin0.EpochDurationSeconds)
+const BlockDelaySecs = uint64(builtin.EpochDurationSeconds)
 
 const PropagationDelaySecs = uint64(6)

build/version.go

@@ -1,10 +1,6 @@
 package build
 
-import (
-	"fmt"
-
-	"golang.org/x/xerrors"
-)
+import "fmt"
 
 var CurrentCommit string
 var BuildType int
@@ -29,7 +25,7 @@ func buildType() string {
 }
 
 // BuildVersion is the local build version, set by build system
-const BuildVersion = "0.8.0"
+const BuildVersion = "0.4.6"
 
 func UserVersion() string {
 	return BuildVersion + buildType() + CurrentCommit
@@ -56,37 +52,8 @@ func (ve Version) EqMajorMinor(v2 Version) bool {
 	return ve&minorMask == v2&minorMask
 }
 
-type NodeType int
-
-const (
-	NodeUnknown NodeType = iota
-
-	NodeFull
-	NodeMiner
-	NodeWorker
-)
-
-var RunningNodeType NodeType
-
-func VersionForType(nodeType NodeType) (Version, error) {
-	switch nodeType {
-	case NodeFull:
-		return FullAPIVersion, nil
-	case NodeMiner:
-		return MinerAPIVersion, nil
-	case NodeWorker:
-		return WorkerAPIVersion, nil
-	default:
-		return Version(0), xerrors.Errorf("unknown node type %d", nodeType)
-	}
-}
-
-// semver versions of the rpc api exposed
-var (
-	FullAPIVersion   = newVer(0, 16, 0)
-	MinerAPIVersion  = newVer(0, 15, 0)
-	WorkerAPIVersion = newVer(0, 15, 0)
-)
+// APIVersion is a semver version of the rpc api exposed
+var APIVersion Version = newVer(0, 11, 0)
 
 //nolint:varcheck,deadcode
 const (

chain/actors/adt/adt.go

@@ -1,76 +0,0 @@
-package adt
-
-import (
-	"github.com/ipfs/go-cid"
-	"golang.org/x/xerrors"
-
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/go-state-types/cbor"
-	"github.com/filecoin-project/go-state-types/network"
-
-	"github.com/filecoin-project/lotus/chain/actors"
-
-	adt0 "github.com/filecoin-project/specs-actors/actors/util/adt"
-	adt2 "github.com/filecoin-project/specs-actors/v2/actors/util/adt"
-)
-
-type Map interface {
-	Root() (cid.Cid, error)
-
-	Put(k abi.Keyer, v cbor.Marshaler) error
-	Get(k abi.Keyer, v cbor.Unmarshaler) (bool, error)
-	Delete(k abi.Keyer) error
-
-	ForEach(v cbor.Unmarshaler, fn func(key string) error) error
-}
-
-func AsMap(store Store, root cid.Cid, version actors.Version) (Map, error) {
-	switch version {
-	case actors.Version0:
-		return adt0.AsMap(store, root)
-	case actors.Version2:
-		return adt2.AsMap(store, root)
-	}
-	return nil, xerrors.Errorf("unknown network version: %d", version)
-}
-
-func NewMap(store Store, version actors.Version) (Map, error) {
-	switch version {
-	case actors.Version0:
-		return adt0.MakeEmptyMap(store), nil
-	case actors.Version2:
-		return adt2.MakeEmptyMap(store), nil
-	}
-	return nil, xerrors.Errorf("unknown network version: %d", version)
-}
-
-type Array interface {
-	Root() (cid.Cid, error)
-
-	Set(idx uint64, v cbor.Marshaler) error
-	Get(idx uint64, v cbor.Unmarshaler) (bool, error)
-	Delete(idx uint64) error
-	Length() uint64
-
-	ForEach(v cbor.Unmarshaler, fn func(idx int64) error) error
-}
-
-func AsArray(store Store, root cid.Cid, version network.Version) (Array, error) {
-	switch actors.VersionForNetwork(version) {
-	case actors.Version0:
-		return adt0.AsArray(store, root)
-	case actors.Version2:
-		return adt2.AsArray(store, root)
-	}
-	return nil, xerrors.Errorf("unknown network version: %d", version)
-}
-
-func NewArray(store Store, version actors.Version) (Array, error) {
-	switch version {
-	case actors.Version0:
-		return adt0.MakeEmptyArray(store), nil
-	case actors.Version2:
-		return adt2.MakeEmptyArray(store), nil
-	}
-	return nil, xerrors.Errorf("unknown network version: %d", version)
-}

chain/actors/adt/store.go

@@ -1,17 +0,0 @@
-package adt
-
-import (
-	"context"
-
-	adt "github.com/filecoin-project/specs-actors/actors/util/adt"
-	cbor "github.com/ipfs/go-ipld-cbor"
-)
-
-type Store interface {
-	Context() context.Context
-	cbor.IpldStore
-}
-
-func WrapStore(ctx context.Context, store cbor.IpldStore) Store {
-	return adt.WrapStore(ctx, store)
-}

chain/actors/aerrors/error.go

@@ -3,7 +3,7 @@ package aerrors
 import (
 	"fmt"
 
-	"github.com/filecoin-project/go-state-types/exitcode"
+	"github.com/filecoin-project/specs-actors/actors/runtime/exitcode"
 	"golang.org/x/xerrors"
 )
 

chain/actors/aerrors/error_test.go

@@ -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"

chain/actors/aerrors/wrap.go

@@ -4,7 +4,7 @@ import (
 	"errors"
 	"fmt"
 
-	"github.com/filecoin-project/go-state-types/exitcode"
+	"github.com/filecoin-project/specs-actors/actors/runtime/exitcode"
 	cbor "github.com/ipfs/go-ipld-cbor"
 	"golang.org/x/xerrors"
 )

chain/actors/builtin/README.md

@@ -1,29 +0,0 @@
-# Actors
-
-This package contains shims for abstracting over different actor versions.
-
-## Design
-
-Shims in this package follow a few common design principles.
-
-### Structure Agnostic
-
-Shims interfaces defined in this package should (ideally) not change even if the
-structure of the underlying data changes. For example:
-
-* All shims store an internal "store" object. That way, state can be moved into
-  a separate object without needing to add a store to the function signature.
-* All functions must return an error, even if unused for now.
-
-### Minimal
-
-These interfaces should be expanded only as necessary to reduce maintenance burden.
-
-### Queries, not field assessors.
-
-When possible, functions should query the state instead of simply acting as
-field assessors. These queries are more likely to remain stable across
-specs-actor upgrades than specific state fields.
-
-Note: there is a trade-off here. Avoid implementing _complicated_ query logic
-inside these shims, as it will need to be replicated in every shim.

chain/actors/builtin/account/account.go

@@ -1,41 +0,0 @@
-package account
-
-import (
-	"golang.org/x/xerrors"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/cbor"
-	"github.com/ipfs/go-cid"
-
-	"github.com/filecoin-project/lotus/chain/actors/adt"
-	"github.com/filecoin-project/lotus/chain/actors/builtin"
-	"github.com/filecoin-project/lotus/chain/types"
-
-	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
-	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
-)
-
-func init() {
-	builtin.RegisterActorState(builtin0.AccountActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
-		return load0(store, root)
-	})
-	builtin.RegisterActorState(builtin2.AccountActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
-		return load2(store, root)
-	})
-}
-
-func Load(store adt.Store, act *types.Actor) (State, error) {
-	switch act.Code {
-	case builtin0.AccountActorCodeID:
-		return load0(store, act.Head)
-	case builtin2.AccountActorCodeID:
-		return load2(store, act.Head)
-	}
-	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
-}
-
-type State interface {
-	cbor.Marshaler
-
-	PubkeyAddress() (address.Address, error)
-}

chain/actors/builtin/account/v0.go

@@ -1,30 +0,0 @@
-package account
-
-import (
-	"github.com/filecoin-project/go-address"
-	"github.com/ipfs/go-cid"
-
-	"github.com/filecoin-project/lotus/chain/actors/adt"
-
-	account0 "github.com/filecoin-project/specs-actors/actors/builtin/account"
-)
-
-var _ State = (*state0)(nil)
-
-func load0(store adt.Store, root cid.Cid) (State, error) {
-	out := state0{store: store}
-	err := store.Get(store.Context(), root, &out)
-	if err != nil {
-		return nil, err
-	}
-	return &out, nil
-}
-
-type state0 struct {
-	account0.State
-	store adt.Store
-}
-
-func (s *state0) PubkeyAddress() (address.Address, error) {
-	return s.Address, nil
-}

chain/actors/builtin/account/v2.go

@@ -1,30 +0,0 @@
-package account
-
-import (
-	"github.com/filecoin-project/go-address"
-	"github.com/ipfs/go-cid"
-
-	"github.com/filecoin-project/lotus/chain/actors/adt"
-
-	account2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/account"
-)
-
-var _ State = (*state2)(nil)
-
-func load2(store adt.Store, root cid.Cid) (State, error) {
-	out := state2{store: store}
-	err := store.Get(store.Context(), root, &out)
-	if err != nil {
-		return nil, err
-	}
-	return &out, nil
-}
-
-type state2 struct {
-	account2.State
-	store adt.Store
-}
-
-func (s *state2) PubkeyAddress() (address.Address, error) {
-	return s.Address, nil
-}

chain/actors/builtin/builtin.go

@@ -1,88 +0,0 @@
-package builtin
-
-import (
-	"github.com/ipfs/go-cid"
-	"golang.org/x/xerrors"
-
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/go-state-types/cbor"
-
-	"github.com/filecoin-project/lotus/chain/actors/adt"
-	"github.com/filecoin-project/lotus/chain/types"
-
-	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
-	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
-	proof0 "github.com/filecoin-project/specs-actors/actors/runtime/proof"
-	smoothing0 "github.com/filecoin-project/specs-actors/actors/util/smoothing"
-	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
-	smoothing2 "github.com/filecoin-project/specs-actors/v2/actors/util/smoothing"
-)
-
-var SystemActorAddr = builtin0.SystemActorAddr
-var BurntFundsActorAddr = builtin0.BurntFundsActorAddr
-
-// TODO: Why does actors have 2 different versions of this?
-type SectorInfo = proof0.SectorInfo
-type PoStProof = proof0.PoStProof
-type FilterEstimate = smoothing0.FilterEstimate
-
-func FromV0FilterEstimate(v0 smoothing0.FilterEstimate) FilterEstimate {
-	return (FilterEstimate)(v0)
-}
-
-// Doesn't change between actors v0 and v1
-func QAPowerForWeight(size abi.SectorSize, duration abi.ChainEpoch, dealWeight, verifiedWeight abi.DealWeight) abi.StoragePower {
-	return miner0.QAPowerForWeight(size, duration, dealWeight, verifiedWeight)
-}
-
-func FromV2FilterEstimate(v1 smoothing2.FilterEstimate) FilterEstimate {
-	return (FilterEstimate)(v1)
-}
-
-type ActorStateLoader func(store adt.Store, root cid.Cid) (cbor.Marshaler, error)
-
-var ActorStateLoaders = make(map[cid.Cid]ActorStateLoader)
-
-func RegisterActorState(code cid.Cid, loader ActorStateLoader) {
-	ActorStateLoaders[code] = loader
-}
-
-func Load(store adt.Store, act *types.Actor) (cbor.Marshaler, error) {
-	loader, found := ActorStateLoaders[act.Code]
-	if !found {
-		return nil, xerrors.Errorf("unknown actor code %s", act.Code)
-	}
-	return loader(store, act.Head)
-}
-
-func ActorNameByCode(c cid.Cid) string {
-	switch {
-	case builtin0.IsBuiltinActor(c):
-		return builtin0.ActorNameByCode(c)
-	case builtin2.IsBuiltinActor(c):
-		return builtin2.ActorNameByCode(c)
-	default:
-		return "<unknown>"
-	}
-}
-
-func IsBuiltinActor(c cid.Cid) bool {
-	return builtin0.IsBuiltinActor(c) || builtin2.IsBuiltinActor(c)
-}
-
-func IsAccountActor(c cid.Cid) bool {
-	return c == builtin0.AccountActorCodeID || c == builtin2.AccountActorCodeID
-}
-
-func IsStorageMinerActor(c cid.Cid) bool {
-	return c == builtin0.StorageMinerActorCodeID || c == builtin2.StorageMinerActorCodeID
-}
-
-func IsMultisigActor(c cid.Cid) bool {
-	return c == builtin0.MultisigActorCodeID || c == builtin2.MultisigActorCodeID
-
-}
-
-func IsPaymentChannelActor(c cid.Cid) bool {
-	return c == builtin0.PaymentChannelActorCodeID || c == builtin2.PaymentChannelActorCodeID
-}

chain/actors/builtin/init/init.go

@@ -1,57 +0,0 @@
-package init
-
-import (
-	"golang.org/x/xerrors"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/go-state-types/cbor"
-	"github.com/ipfs/go-cid"
-
-	"github.com/filecoin-project/lotus/chain/actors/adt"
-	"github.com/filecoin-project/lotus/chain/actors/builtin"
-	"github.com/filecoin-project/lotus/chain/types"
-	"github.com/filecoin-project/lotus/node/modules/dtypes"
-
-	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
-	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
-)
-
-func init() {
-	builtin.RegisterActorState(builtin0.InitActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
-		return load0(store, root)
-	})
-	builtin.RegisterActorState(builtin2.InitActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
-		return load2(store, root)
-	})
-}
-
-var Address = builtin0.InitActorAddr
-
-func Load(store adt.Store, act *types.Actor) (State, error) {
-	switch act.Code {
-	case builtin0.InitActorCodeID:
-		return load0(store, act.Head)
-	case builtin2.InitActorCodeID:
-		return load2(store, act.Head)
-	}
-	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
-}
-
-type State interface {
-	cbor.Marshaler
-
-	ResolveAddress(address address.Address) (address.Address, bool, error)
-	MapAddressToNewID(address address.Address) (address.Address, error)
-	NetworkName() (dtypes.NetworkName, error)
-
-	ForEachActor(func(id abi.ActorID, address address.Address) error) error
-
-	// Remove exists to support tooling that manipulates state for testing.
-	// It should not be used in production code, as init actor entries are
-	// immutable.
-	Remove(addrs ...address.Address) error
-
-	// Sets the network's name. This should only be used on upgrade/fork.
-	SetNetworkName(name string) error
-}

chain/actors/builtin/init/v0.go

@@ -1,81 +0,0 @@
-package init
-
-import (
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/ipfs/go-cid"
-	cbg "github.com/whyrusleeping/cbor-gen"
-	"golang.org/x/xerrors"
-
-	"github.com/filecoin-project/lotus/chain/actors/adt"
-	"github.com/filecoin-project/lotus/node/modules/dtypes"
-
-	init0 "github.com/filecoin-project/specs-actors/actors/builtin/init"
-	adt0 "github.com/filecoin-project/specs-actors/actors/util/adt"
-)
-
-var _ State = (*state0)(nil)
-
-func load0(store adt.Store, root cid.Cid) (State, error) {
-	out := state0{store: store}
-	err := store.Get(store.Context(), root, &out)
-	if err != nil {
-		return nil, err
-	}
-	return &out, nil
-}
-
-type state0 struct {
-	init0.State
-	store adt.Store
-}
-
-func (s *state0) ResolveAddress(address address.Address) (address.Address, bool, error) {
-	return s.State.ResolveAddress(s.store, address)
-}
-
-func (s *state0) MapAddressToNewID(address address.Address) (address.Address, error) {
-	return s.State.MapAddressToNewID(s.store, address)
-}
-
-func (s *state0) ForEachActor(cb func(id abi.ActorID, address address.Address) error) error {
-	addrs, err := adt0.AsMap(s.store, s.State.AddressMap)
-	if err != nil {
-		return err
-	}
-	var actorID cbg.CborInt
-	return addrs.ForEach(&actorID, func(key string) error {
-		addr, err := address.NewFromBytes([]byte(key))
-		if err != nil {
-			return err
-		}
-		return cb(abi.ActorID(actorID), addr)
-	})
-}
-
-func (s *state0) NetworkName() (dtypes.NetworkName, error) {
-	return dtypes.NetworkName(s.State.NetworkName), nil
-}
-
-func (s *state0) SetNetworkName(name string) error {
-	s.State.NetworkName = name
-	return nil
-}
-
-func (s *state0) Remove(addrs ...address.Address) (err error) {
-	m, err := adt0.AsMap(s.store, s.State.AddressMap)
-	if err != nil {
-		return err
-	}
-	for _, addr := range addrs {
-		if err = m.Delete(abi.AddrKey(addr)); err != nil {
-			return xerrors.Errorf("failed to delete entry for address: %s; err: %w", addr, err)
-		}
-	}
-	amr, err := m.Root()
-	if err != nil {
-		return xerrors.Errorf("failed to get address map root: %w", err)
-	}
-	s.State.AddressMap = amr
-	return nil
-}

chain/actors/builtin/init/v2.go

@@ -1,81 +0,0 @@
-package init
-
-import (
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/ipfs/go-cid"
-	cbg "github.com/whyrusleeping/cbor-gen"
-	"golang.org/x/xerrors"
-
-	"github.com/filecoin-project/lotus/chain/actors/adt"
-	"github.com/filecoin-project/lotus/node/modules/dtypes"
-
-	init2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/init"
-	adt2 "github.com/filecoin-project/specs-actors/v2/actors/util/adt"
-)
-
-var _ State = (*state2)(nil)
-
-func load2(store adt.Store, root cid.Cid) (State, error) {
-	out := state2{store: store}
-	err := store.Get(store.Context(), root, &out)
-	if err != nil {
-		return nil, err
-	}
-	return &out, nil
-}
-
-type state2 struct {
-	init2.State
-	store adt.Store
-}
-
-func (s *state2) ResolveAddress(address address.Address) (address.Address, bool, error) {
-	return s.State.ResolveAddress(s.store, address)
-}
-
-func (s *state2) MapAddressToNewID(address address.Address) (address.Address, error) {
-	return s.State.MapAddressToNewID(s.store, address)
-}
-
-func (s *state2) ForEachActor(cb func(id abi.ActorID, address address.Address) error) error {
-	addrs, err := adt2.AsMap(s.store, s.State.AddressMap)
-	if err != nil {
-		return err
-	}
-	var actorID cbg.CborInt
-	return addrs.ForEach(&actorID, func(key string) error {
-		addr, err := address.NewFromBytes([]byte(key))
-		if err != nil {
-			return err
-		}
-		return cb(abi.ActorID(actorID), addr)
-	})
-}
-
-func (s *state2) NetworkName() (dtypes.NetworkName, error) {
-	return dtypes.NetworkName(s.State.NetworkName), nil
-}
-
-func (s *state2) SetNetworkName(name string) error {
-	s.State.NetworkName = name
-	return nil
-}
-
-func (s *state2) Remove(addrs ...address.Address) (err error) {
-	m, err := adt2.AsMap(s.store, s.State.AddressMap)
-	if err != nil {
-		return err
-	}
-	for _, addr := range addrs {
-		if err = m.Delete(abi.AddrKey(addr)); err != nil {
-			return xerrors.Errorf("failed to delete entry for address: %s; err: %w", addr, err)
-		}
-	}
-	amr, err := m.Root()
-	if err != nil {
-		return xerrors.Errorf("failed to get address map root: %w", err)
-	}
-	s.State.AddressMap = amr
-	return nil
-}

chain/actors/builtin/market/diff.go

@@ -1,91 +0,0 @@
-package market
-
-import (
-	"fmt"
-
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/lotus/chain/actors/adt"
-	cbg "github.com/whyrusleeping/cbor-gen"
-)
-
-func DiffDealProposals(pre, cur DealProposals) (*DealProposalChanges, error) {
-	results := new(DealProposalChanges)
-	if err := adt.DiffAdtArray(pre.array(), cur.array(), &marketProposalsDiffer{results, pre, cur}); err != nil {
-		return nil, fmt.Errorf("diffing deal states: %w", err)
-	}
-	return results, nil
-}
-
-type marketProposalsDiffer struct {
-	Results  *DealProposalChanges
-	pre, cur DealProposals
-}
-
-func (d *marketProposalsDiffer) Add(key uint64, val *cbg.Deferred) error {
-	dp, err := d.cur.decode(val)
-	if err != nil {
-		return err
-	}
-	d.Results.Added = append(d.Results.Added, ProposalIDState{abi.DealID(key), *dp})
-	return nil
-}
-
-func (d *marketProposalsDiffer) Modify(key uint64, from, to *cbg.Deferred) error {
-	// short circuit, DealProposals are static
-	return nil
-}
-
-func (d *marketProposalsDiffer) Remove(key uint64, val *cbg.Deferred) error {
-	dp, err := d.pre.decode(val)
-	if err != nil {
-		return err
-	}
-	d.Results.Removed = append(d.Results.Removed, ProposalIDState{abi.DealID(key), *dp})
-	return nil
-}
-
-func DiffDealStates(pre, cur DealStates) (*DealStateChanges, error) {
-	results := new(DealStateChanges)
-	if err := adt.DiffAdtArray(pre.array(), cur.array(), &marketStatesDiffer{results, pre, cur}); err != nil {
-		return nil, fmt.Errorf("diffing deal states: %w", err)
-	}
-	return results, nil
-}
-
-type marketStatesDiffer struct {
-	Results  *DealStateChanges
-	pre, cur DealStates
-}
-
-func (d *marketStatesDiffer) Add(key uint64, val *cbg.Deferred) error {
-	ds, err := d.cur.decode(val)
-	if err != nil {
-		return err
-	}
-	d.Results.Added = append(d.Results.Added, DealIDState{abi.DealID(key), *ds})
-	return nil
-}
-
-func (d *marketStatesDiffer) Modify(key uint64, from, to *cbg.Deferred) error {
-	dsFrom, err := d.pre.decode(from)
-	if err != nil {
-		return err
-	}
-	dsTo, err := d.cur.decode(to)
-	if err != nil {
-		return err
-	}
-	if *dsFrom != *dsTo {
-		d.Results.Modified = append(d.Results.Modified, DealStateChange{abi.DealID(key), dsFrom, dsTo})
-	}
-	return nil
-}
-
-func (d *marketStatesDiffer) Remove(key uint64, val *cbg.Deferred) error {
-	ds, err := d.pre.decode(val)
-	if err != nil {
-		return err
-	}
-	d.Results.Removed = append(d.Results.Removed, DealIDState{abi.DealID(key), *ds})
-	return nil
-}

chain/actors/builtin/market/market.go

@@ -1,138 +0,0 @@
-package market
-
-import (
-	"golang.org/x/xerrors"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/go-state-types/cbor"
-	"github.com/ipfs/go-cid"
-	cbg "github.com/whyrusleeping/cbor-gen"
-
-	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
-	market0 "github.com/filecoin-project/specs-actors/actors/builtin/market"
-	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
-
-	"github.com/filecoin-project/lotus/chain/actors/adt"
-	"github.com/filecoin-project/lotus/chain/actors/builtin"
-	"github.com/filecoin-project/lotus/chain/types"
-)
-
-func init() {
-	builtin.RegisterActorState(builtin0.StorageMarketActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
-		return load0(store, root)
-	})
-	builtin.RegisterActorState(builtin2.StorageMarketActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
-		return load2(store, root)
-	})
-}
-
-var Address = builtin0.StorageMarketActorAddr
-
-func Load(store adt.Store, act *types.Actor) (st State, err error) {
-	switch act.Code {
-	case builtin0.StorageMarketActorCodeID:
-		return load0(store, act.Head)
-	case builtin2.StorageMarketActorCodeID:
-		return load2(store, act.Head)
-	}
-	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
-}
-
-type State interface {
-	cbor.Marshaler
-	BalancesChanged(State) (bool, error)
-	EscrowTable() (BalanceTable, error)
-	LockedTable() (BalanceTable, error)
-	TotalLocked() (abi.TokenAmount, error)
-	StatesChanged(State) (bool, error)
-	States() (DealStates, error)
-	ProposalsChanged(State) (bool, error)
-	Proposals() (DealProposals, error)
-	VerifyDealsForActivation(
-		minerAddr address.Address, deals []abi.DealID, currEpoch, sectorExpiry abi.ChainEpoch,
-	) (weight, verifiedWeight abi.DealWeight, err error)
-}
-
-type BalanceTable interface {
-	ForEach(cb func(address.Address, abi.TokenAmount) error) error
-	Get(key address.Address) (abi.TokenAmount, error)
-}
-
-type DealStates interface {
-	ForEach(cb func(id abi.DealID, ds DealState) error) error
-	Get(id abi.DealID) (*DealState, bool, error)
-
-	array() adt.Array
-	decode(*cbg.Deferred) (*DealState, error)
-}
-
-type DealProposals interface {
-	ForEach(cb func(id abi.DealID, dp DealProposal) error) error
-	Get(id abi.DealID) (*DealProposal, bool, error)
-
-	array() adt.Array
-	decode(*cbg.Deferred) (*DealProposal, error)
-}
-
-type PublishStorageDealsParams = market0.PublishStorageDealsParams
-type PublishStorageDealsReturn = market0.PublishStorageDealsReturn
-type VerifyDealsForActivationParams = market0.VerifyDealsForActivationParams
-
-type ClientDealProposal = market0.ClientDealProposal
-
-type DealState struct {
-	SectorStartEpoch abi.ChainEpoch // -1 if not yet included in proven sector
-	LastUpdatedEpoch abi.ChainEpoch // -1 if deal state never updated
-	SlashEpoch       abi.ChainEpoch // -1 if deal never slashed
-}
-
-type DealProposal struct {
-	PieceCID             cid.Cid
-	PieceSize            abi.PaddedPieceSize
-	VerifiedDeal         bool
-	Client               address.Address
-	Provider             address.Address
-	Label                string
-	StartEpoch           abi.ChainEpoch
-	EndEpoch             abi.ChainEpoch
-	StoragePricePerEpoch abi.TokenAmount
-	ProviderCollateral   abi.TokenAmount
-	ClientCollateral     abi.TokenAmount
-}
-
-type DealStateChanges struct {
-	Added    []DealIDState
-	Modified []DealStateChange
-	Removed  []DealIDState
-}
-
-type DealIDState struct {
-	ID   abi.DealID
-	Deal DealState
-}
-
-// DealStateChange is a change in deal state from -> to
-type DealStateChange struct {
-	ID   abi.DealID
-	From *DealState
-	To   *DealState
-}
-
-type DealProposalChanges struct {
-	Added   []ProposalIDState
-	Removed []ProposalIDState
-}
-
-type ProposalIDState struct {
-	ID       abi.DealID
-	Proposal DealProposal
-}
-
-func EmptyDealState() *DealState {
-	return &DealState{
-		SectorStartEpoch: -1,
-		SlashEpoch:       -1,
-		LastUpdatedEpoch: -1,
-	}
-}

chain/actors/builtin/market/v0.go

@@ -1,204 +0,0 @@
-package market
-
-import (
-	"bytes"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/ipfs/go-cid"
-	cbg "github.com/whyrusleeping/cbor-gen"
-
-	"github.com/filecoin-project/lotus/chain/actors/adt"
-	"github.com/filecoin-project/lotus/chain/types"
-
-	market0 "github.com/filecoin-project/specs-actors/actors/builtin/market"
-	adt0 "github.com/filecoin-project/specs-actors/actors/util/adt"
-)
-
-var _ State = (*state0)(nil)
-
-func load0(store adt.Store, root cid.Cid) (State, error) {
-	out := state0{store: store}
-	err := store.Get(store.Context(), root, &out)
-	if err != nil {
-		return nil, err
-	}
-	return &out, nil
-}
-
-type state0 struct {
-	market0.State
-	store adt.Store
-}
-
-func (s *state0) TotalLocked() (abi.TokenAmount, error) {
-	fml := types.BigAdd(s.TotalClientLockedCollateral, s.TotalProviderLockedCollateral)
-	fml = types.BigAdd(fml, s.TotalClientStorageFee)
-	return fml, nil
-}
-
-func (s *state0) BalancesChanged(otherState State) (bool, error) {
-	otherState0, ok := otherState.(*state0)
-	if !ok {
-		// there's no way to compare different versions of the state, so let's
-		// just say that means the state of balances has changed
-		return true, nil
-	}
-	return !s.State.EscrowTable.Equals(otherState0.State.EscrowTable) || !s.State.LockedTable.Equals(otherState0.State.LockedTable), nil
-}
-
-func (s *state0) StatesChanged(otherState State) (bool, error) {
-	otherState0, ok := otherState.(*state0)
-	if !ok {
-		// there's no way to compare different versions of the state, so let's
-		// just say that means the state of balances has changed
-		return true, nil
-	}
-	return !s.State.States.Equals(otherState0.State.States), nil
-}
-
-func (s *state0) States() (DealStates, error) {
-	stateArray, err := adt0.AsArray(s.store, s.State.States)
-	if err != nil {
-		return nil, err
-	}
-	return &dealStates0{stateArray}, nil
-}
-
-func (s *state0) ProposalsChanged(otherState State) (bool, error) {
-	otherState0, ok := otherState.(*state0)
-	if !ok {
-		// there's no way to compare different versions of the state, so let's
-		// just say that means the state of balances has changed
-		return true, nil
-	}
-	return !s.State.Proposals.Equals(otherState0.State.Proposals), nil
-}
-
-func (s *state0) Proposals() (DealProposals, error) {
-	proposalArray, err := adt0.AsArray(s.store, s.State.Proposals)
-	if err != nil {
-		return nil, err
-	}
-	return &dealProposals0{proposalArray}, nil
-}
-
-func (s *state0) EscrowTable() (BalanceTable, error) {
-	bt, err := adt0.AsBalanceTable(s.store, s.State.EscrowTable)
-	if err != nil {
-		return nil, err
-	}
-	return &balanceTable0{bt}, nil
-}
-
-func (s *state0) LockedTable() (BalanceTable, error) {
-	bt, err := adt0.AsBalanceTable(s.store, s.State.LockedTable)
-	if err != nil {
-		return nil, err
-	}
-	return &balanceTable0{bt}, nil
-}
-
-func (s *state0) VerifyDealsForActivation(
-	minerAddr address.Address, deals []abi.DealID, currEpoch, sectorExpiry abi.ChainEpoch,
-) (weight, verifiedWeight abi.DealWeight, err error) {
-	return market0.ValidateDealsForActivation(&s.State, s.store, deals, minerAddr, sectorExpiry, currEpoch)
-}
-
-type balanceTable0 struct {
-	*adt0.BalanceTable
-}
-
-func (bt *balanceTable0) ForEach(cb func(address.Address, abi.TokenAmount) error) error {
-	asMap := (*adt0.Map)(bt.BalanceTable)
-	var ta abi.TokenAmount
-	return asMap.ForEach(&ta, func(key string) error {
-		a, err := address.NewFromBytes([]byte(key))
-		if err != nil {
-			return err
-		}
-		return cb(a, ta)
-	})
-}
-
-type dealStates0 struct {
-	adt.Array
-}
-
-func (s *dealStates0) Get(dealID abi.DealID) (*DealState, bool, error) {
-	var deal0 market0.DealState
-	found, err := s.Array.Get(uint64(dealID), &deal0)
-	if err != nil {
-		return nil, false, err
-	}
-	if !found {
-		return nil, false, nil
-	}
-	deal := fromV0DealState(deal0)
-	return &deal, true, nil
-}
-
-func (s *dealStates0) ForEach(cb func(dealID abi.DealID, ds DealState) error) error {
-	var ds0 market0.DealState
-	return s.Array.ForEach(&ds0, func(idx int64) error {
-		return cb(abi.DealID(idx), fromV0DealState(ds0))
-	})
-}
-
-func (s *dealStates0) decode(val *cbg.Deferred) (*DealState, error) {
-	var ds0 market0.DealState
-	if err := ds0.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil {
-		return nil, err
-	}
-	ds := fromV0DealState(ds0)
-	return &ds, nil
-}
-
-func (s *dealStates0) array() adt.Array {
-	return s.Array
-}
-
-func fromV0DealState(v0 market0.DealState) DealState {
-	return (DealState)(v0)
-}
-
-type dealProposals0 struct {
-	adt.Array
-}
-
-func (s *dealProposals0) Get(dealID abi.DealID) (*DealProposal, bool, error) {
-	var proposal0 market0.DealProposal
-	found, err := s.Array.Get(uint64(dealID), &proposal0)
-	if err != nil {
-		return nil, false, err
-	}
-	if !found {
-		return nil, false, nil
-	}
-	proposal := fromV0DealProposal(proposal0)
-	return &proposal, true, nil
-}
-
-func (s *dealProposals0) ForEach(cb func(dealID abi.DealID, dp DealProposal) error) error {
-	var dp0 market0.DealProposal
-	return s.Array.ForEach(&dp0, func(idx int64) error {
-		return cb(abi.DealID(idx), fromV0DealProposal(dp0))
-	})
-}
-
-func (s *dealProposals0) decode(val *cbg.Deferred) (*DealProposal, error) {
-	var dp0 market0.DealProposal
-	if err := dp0.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil {
-		return nil, err
-	}
-	dp := fromV0DealProposal(dp0)
-	return &dp, nil
-}
-
-func (s *dealProposals0) array() adt.Array {
-	return s.Array
-}
-
-func fromV0DealProposal(v0 market0.DealProposal) DealProposal {
-	return (DealProposal)(v0)
-}

chain/actors/builtin/market/v2.go

@@ -1,205 +0,0 @@
-package market
-
-import (
-	"bytes"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/ipfs/go-cid"
-	cbg "github.com/whyrusleeping/cbor-gen"
-
-	"github.com/filecoin-project/lotus/chain/actors/adt"
-	"github.com/filecoin-project/lotus/chain/types"
-
-	market2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/market"
-	adt2 "github.com/filecoin-project/specs-actors/v2/actors/util/adt"
-)
-
-var _ State = (*state2)(nil)
-
-func load2(store adt.Store, root cid.Cid) (State, error) {
-	out := state2{store: store}
-	err := store.Get(store.Context(), root, &out)
-	if err != nil {
-		return nil, err
-	}
-	return &out, nil
-}
-
-type state2 struct {
-	market2.State
-	store adt.Store
-}
-
-func (s *state2) TotalLocked() (abi.TokenAmount, error) {
-	fml := types.BigAdd(s.TotalClientLockedCollateral, s.TotalProviderLockedCollateral)
-	fml = types.BigAdd(fml, s.TotalClientStorageFee)
-	return fml, nil
-}
-
-func (s *state2) BalancesChanged(otherState State) (bool, error) {
-	otherState2, ok := otherState.(*state2)
-	if !ok {
-		// there's no way to compare different versions of the state, so let's
-		// just say that means the state of balances has changed
-		return true, nil
-	}
-	return !s.State.EscrowTable.Equals(otherState2.State.EscrowTable) || !s.State.LockedTable.Equals(otherState2.State.LockedTable), nil
-}
-
-func (s *state2) StatesChanged(otherState State) (bool, error) {
-	otherState2, ok := otherState.(*state2)
-	if !ok {
-		// there's no way to compare different versions of the state, so let's
-		// just say that means the state of balances has changed
-		return true, nil
-	}
-	return !s.State.States.Equals(otherState2.State.States), nil
-}
-
-func (s *state2) States() (DealStates, error) {
-	stateArray, err := adt2.AsArray(s.store, s.State.States)
-	if err != nil {
-		return nil, err
-	}
-	return &dealStates2{stateArray}, nil
-}
-
-func (s *state2) ProposalsChanged(otherState State) (bool, error) {
-	otherState2, ok := otherState.(*state2)
-	if !ok {
-		// there's no way to compare different versions of the state, so let's
-		// just say that means the state of balances has changed
-		return true, nil
-	}
-	return !s.State.Proposals.Equals(otherState2.State.Proposals), nil
-}
-
-func (s *state2) Proposals() (DealProposals, error) {
-	proposalArray, err := adt2.AsArray(s.store, s.State.Proposals)
-	if err != nil {
-		return nil, err
-	}
-	return &dealProposals2{proposalArray}, nil
-}
-
-func (s *state2) EscrowTable() (BalanceTable, error) {
-	bt, err := adt2.AsBalanceTable(s.store, s.State.EscrowTable)
-	if err != nil {
-		return nil, err
-	}
-	return &balanceTable2{bt}, nil
-}
-
-func (s *state2) LockedTable() (BalanceTable, error) {
-	bt, err := adt2.AsBalanceTable(s.store, s.State.LockedTable)
-	if err != nil {
-		return nil, err
-	}
-	return &balanceTable2{bt}, nil
-}
-
-func (s *state2) VerifyDealsForActivation(
-	minerAddr address.Address, deals []abi.DealID, currEpoch, sectorExpiry abi.ChainEpoch,
-) (weight, verifiedWeight abi.DealWeight, err error) {
-	w, vw, _, err := market2.ValidateDealsForActivation(&s.State, s.store, deals, minerAddr, sectorExpiry, currEpoch)
-	return w, vw, err
-}
-
-type balanceTable2 struct {
-	*adt2.BalanceTable
-}
-
-func (bt *balanceTable2) ForEach(cb func(address.Address, abi.TokenAmount) error) error {
-	asMap := (*adt2.Map)(bt.BalanceTable)
-	var ta abi.TokenAmount
-	return asMap.ForEach(&ta, func(key string) error {
-		a, err := address.NewFromBytes([]byte(key))
-		if err != nil {
-			return err
-		}
-		return cb(a, ta)
-	})
-}
-
-type dealStates2 struct {
-	adt.Array
-}
-
-func (s *dealStates2) Get(dealID abi.DealID) (*DealState, bool, error) {
-	var deal2 market2.DealState
-	found, err := s.Array.Get(uint64(dealID), &deal2)
-	if err != nil {
-		return nil, false, err
-	}
-	if !found {
-		return nil, false, nil
-	}
-	deal := fromV2DealState(deal2)
-	return &deal, true, nil
-}
-
-func (s *dealStates2) ForEach(cb func(dealID abi.DealID, ds DealState) error) error {
-	var ds1 market2.DealState
-	return s.Array.ForEach(&ds1, func(idx int64) error {
-		return cb(abi.DealID(idx), fromV2DealState(ds1))
-	})
-}
-
-func (s *dealStates2) decode(val *cbg.Deferred) (*DealState, error) {
-	var ds1 market2.DealState
-	if err := ds1.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil {
-		return nil, err
-	}
-	ds := fromV2DealState(ds1)
-	return &ds, nil
-}
-
-func (s *dealStates2) array() adt.Array {
-	return s.Array
-}
-
-func fromV2DealState(v1 market2.DealState) DealState {
-	return (DealState)(v1)
-}
-
-type dealProposals2 struct {
-	adt.Array
-}
-
-func (s *dealProposals2) Get(dealID abi.DealID) (*DealProposal, bool, error) {
-	var proposal2 market2.DealProposal
-	found, err := s.Array.Get(uint64(dealID), &proposal2)
-	if err != nil {
-		return nil, false, err
-	}
-	if !found {
-		return nil, false, nil
-	}
-	proposal := fromV2DealProposal(proposal2)
-	return &proposal, true, nil
-}
-
-func (s *dealProposals2) ForEach(cb func(dealID abi.DealID, dp DealProposal) error) error {
-	var dp1 market2.DealProposal
-	return s.Array.ForEach(&dp1, func(idx int64) error {
-		return cb(abi.DealID(idx), fromV2DealProposal(dp1))
-	})
-}
-
-func (s *dealProposals2) decode(val *cbg.Deferred) (*DealProposal, error) {
-	var dp1 market2.DealProposal
-	if err := dp1.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil {
-		return nil, err
-	}
-	dp := fromV2DealProposal(dp1)
-	return &dp, nil
-}
-
-func (s *dealProposals2) array() adt.Array {
-	return s.Array
-}
-
-func fromV2DealProposal(v1 market2.DealProposal) DealProposal {
-	return (DealProposal)(v1)
-}

chain/actors/builtin/miner/diff.go

@@ -1,127 +0,0 @@
-package miner
-
-import (
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/lotus/chain/actors/adt"
-	cbg "github.com/whyrusleeping/cbor-gen"
-)
-
-func DiffPreCommits(pre, cur State) (*PreCommitChanges, error) {
-	results := new(PreCommitChanges)
-
-	prep, err := pre.precommits()
-	if err != nil {
-		return nil, err
-	}
-
-	curp, err := cur.precommits()
-	if err != nil {
-		return nil, err
-	}
-
-	err = adt.DiffAdtMap(prep, curp, &preCommitDiffer{results, pre, cur})
-	if err != nil {
-		return nil, err
-	}
-
-	return results, nil
-}
-
-type preCommitDiffer struct {
-	Results    *PreCommitChanges
-	pre, after State
-}
-
-func (m *preCommitDiffer) AsKey(key string) (abi.Keyer, error) {
-	sector, err := abi.ParseUIntKey(key)
-	if err != nil {
-		return nil, err
-	}
-	return abi.UIntKey(sector), nil
-}
-
-func (m *preCommitDiffer) Add(key string, val *cbg.Deferred) error {
-	sp, err := m.after.decodeSectorPreCommitOnChainInfo(val)
-	if err != nil {
-		return err
-	}
-	m.Results.Added = append(m.Results.Added, sp)
-	return nil
-}
-
-func (m *preCommitDiffer) Modify(key string, from, to *cbg.Deferred) error {
-	return nil
-}
-
-func (m *preCommitDiffer) Remove(key string, val *cbg.Deferred) error {
-	sp, err := m.pre.decodeSectorPreCommitOnChainInfo(val)
-	if err != nil {
-		return err
-	}
-	m.Results.Removed = append(m.Results.Removed, sp)
-	return nil
-}
-
-func DiffSectors(pre, cur State) (*SectorChanges, error) {
-	results := new(SectorChanges)
-
-	pres, err := pre.sectors()
-	if err != nil {
-		return nil, err
-	}
-
-	curs, err := cur.sectors()
-	if err != nil {
-		return nil, err
-	}
-
-	err = adt.DiffAdtArray(pres, curs, &sectorDiffer{results, pre, cur})
-	if err != nil {
-		return nil, err
-	}
-
-	return results, nil
-}
-
-type sectorDiffer struct {
-	Results    *SectorChanges
-	pre, after State
-}
-
-func (m *sectorDiffer) Add(key uint64, val *cbg.Deferred) error {
-	si, err := m.after.decodeSectorOnChainInfo(val)
-	if err != nil {
-		return err
-	}
-	m.Results.Added = append(m.Results.Added, si)
-	return nil
-}
-
-func (m *sectorDiffer) Modify(key uint64, from, to *cbg.Deferred) error {
-	siFrom, err := m.pre.decodeSectorOnChainInfo(from)
-	if err != nil {
-		return err
-	}
-
-	siTo, err := m.after.decodeSectorOnChainInfo(to)
-	if err != nil {
-		return err
-	}
-
-	if siFrom.Expiration != siTo.Expiration {
-		m.Results.Extended = append(m.Results.Extended, SectorExtensions{
-			From: siFrom,
-			To:   siTo,
-		})
-	}
-	return nil
-}
-
-func (m *sectorDiffer) Remove(key uint64, val *cbg.Deferred) error {
-	si, err := m.pre.decodeSectorOnChainInfo(val)
-	if err != nil {
-		return err
-	}
-	m.Results.Removed = append(m.Results.Removed, si)
-	return nil
-}

chain/actors/builtin/miner/miner.go

@@ -1,182 +0,0 @@
-package miner
-
-import (
-	"github.com/ipfs/go-cid"
-	"github.com/libp2p/go-libp2p-core/peer"
-	cbg "github.com/whyrusleeping/cbor-gen"
-	"golang.org/x/xerrors"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-bitfield"
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/go-state-types/cbor"
-	"github.com/filecoin-project/go-state-types/dline"
-
-	"github.com/filecoin-project/lotus/chain/actors/adt"
-	"github.com/filecoin-project/lotus/chain/actors/builtin"
-	"github.com/filecoin-project/lotus/chain/types"
-
-	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
-	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
-	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
-)
-
-func init() {
-	builtin.RegisterActorState(builtin0.StorageMinerActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
-		return load0(store, root)
-	})
-	builtin.RegisterActorState(builtin2.StorageMinerActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
-		return load2(store, root)
-	})
-}
-
-// Unchanged between v0 and v2 actors
-var WPoStProvingPeriod = miner0.WPoStProvingPeriod
-var WPoStPeriodDeadlines = miner0.WPoStPeriodDeadlines
-var WPoStChallengeWindow = miner0.WPoStChallengeWindow
-var WPoStChallengeLookback = miner0.WPoStChallengeLookback
-var FaultDeclarationCutoff = miner0.FaultDeclarationCutoff
-
-const MinSectorExpiration = miner0.MinSectorExpiration
-
-func Load(store adt.Store, act *types.Actor) (st State, err error) {
-	switch act.Code {
-	case builtin0.StorageMinerActorCodeID:
-		return load0(store, act.Head)
-	case builtin2.StorageMinerActorCodeID:
-		return load2(store, act.Head)
-	}
-	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
-}
-
-type State interface {
-	cbor.Marshaler
-
-	// Total available balance to spend.
-	AvailableBalance(abi.TokenAmount) (abi.TokenAmount, error)
-	// Funds that will vest by the given epoch.
-	VestedFunds(abi.ChainEpoch) (abi.TokenAmount, error)
-	// Funds locked for various reasons.
-	LockedFunds() (LockedFunds, error)
-
-	GetSector(abi.SectorNumber) (*SectorOnChainInfo, error)
-	FindSector(abi.SectorNumber) (*SectorLocation, error)
-	GetSectorExpiration(abi.SectorNumber) (*SectorExpiration, error)
-	GetPrecommittedSector(abi.SectorNumber) (*SectorPreCommitOnChainInfo, error)
-	LoadSectors(sectorNos *bitfield.BitField) ([]*SectorOnChainInfo, error)
-	NumLiveSectors() (uint64, error)
-	IsAllocated(abi.SectorNumber) (bool, error)
-
-	LoadDeadline(idx uint64) (Deadline, error)
-	ForEachDeadline(cb func(idx uint64, dl Deadline) error) error
-	NumDeadlines() (uint64, error)
-	DeadlinesChanged(State) (bool, error)
-
-	Info() (MinerInfo, error)
-
-	DeadlineInfo(epoch abi.ChainEpoch) (*dline.Info, error)
-
-	// Diff helpers. Used by Diff* functions internally.
-	sectors() (adt.Array, error)
-	decodeSectorOnChainInfo(*cbg.Deferred) (SectorOnChainInfo, error)
-	precommits() (adt.Map, error)
-	decodeSectorPreCommitOnChainInfo(*cbg.Deferred) (SectorPreCommitOnChainInfo, error)
-}
-
-type Deadline interface {
-	LoadPartition(idx uint64) (Partition, error)
-	ForEachPartition(cb func(idx uint64, part Partition) error) error
-	PostSubmissions() (bitfield.BitField, error)
-
-	PartitionsChanged(Deadline) (bool, error)
-}
-
-type Partition interface {
-	AllSectors() (bitfield.BitField, error)
-	FaultySectors() (bitfield.BitField, error)
-	RecoveringSectors() (bitfield.BitField, error)
-	LiveSectors() (bitfield.BitField, error)
-	ActiveSectors() (bitfield.BitField, error)
-}
-
-type SectorOnChainInfo struct {
-	SectorNumber          abi.SectorNumber
-	SealProof             abi.RegisteredSealProof
-	SealedCID             cid.Cid
-	DealIDs               []abi.DealID
-	Activation            abi.ChainEpoch
-	Expiration            abi.ChainEpoch
-	DealWeight            abi.DealWeight
-	VerifiedDealWeight    abi.DealWeight
-	InitialPledge         abi.TokenAmount
-	ExpectedDayReward     abi.TokenAmount
-	ExpectedStoragePledge abi.TokenAmount
-}
-
-type SectorPreCommitInfo = miner0.SectorPreCommitInfo
-
-type SectorPreCommitOnChainInfo struct {
-	Info               SectorPreCommitInfo
-	PreCommitDeposit   abi.TokenAmount
-	PreCommitEpoch     abi.ChainEpoch
-	DealWeight         abi.DealWeight
-	VerifiedDealWeight abi.DealWeight
-}
-
-type PoStPartition = miner0.PoStPartition
-type RecoveryDeclaration = miner0.RecoveryDeclaration
-type FaultDeclaration = miner0.FaultDeclaration
-
-// Params
-type DeclareFaultsParams = miner0.DeclareFaultsParams
-type DeclareFaultsRecoveredParams = miner0.DeclareFaultsRecoveredParams
-type SubmitWindowedPoStParams = miner0.SubmitWindowedPoStParams
-type ProveCommitSectorParams = miner0.ProveCommitSectorParams
-
-type MinerInfo struct {
-	Owner                      address.Address   // Must be an ID-address.
-	Worker                     address.Address   // Must be an ID-address.
-	NewWorker                  address.Address   // Must be an ID-address.
-	ControlAddresses           []address.Address // Must be an ID-addresses.
-	WorkerChangeEpoch          abi.ChainEpoch
-	PeerId                     *peer.ID
-	Multiaddrs                 []abi.Multiaddrs
-	SealProofType              abi.RegisteredSealProof
-	SectorSize                 abi.SectorSize
-	WindowPoStPartitionSectors uint64
-}
-
-type SectorExpiration struct {
-	OnTime abi.ChainEpoch
-
-	// non-zero if sector is faulty, epoch at which it will be permanently
-	// removed if it doesn't recover
-	Early abi.ChainEpoch
-}
-
-type SectorLocation struct {
-	Deadline  uint64
-	Partition uint64
-}
-
-type SectorChanges struct {
-	Added    []SectorOnChainInfo
-	Extended []SectorExtensions
-	Removed  []SectorOnChainInfo
-}
-
-type SectorExtensions struct {
-	From SectorOnChainInfo
-	To   SectorOnChainInfo
-}
-
-type PreCommitChanges struct {
-	Added   []SectorPreCommitOnChainInfo
-	Removed []SectorPreCommitOnChainInfo
-}
-
-type LockedFunds struct {
-	VestingFunds             abi.TokenAmount
-	InitialPledgeRequirement abi.TokenAmount
-	PreCommitDeposits        abi.TokenAmount
-}

chain/actors/builtin/miner/utils.go

@@ -1,28 +0,0 @@
-package miner
-
-import (
-	"golang.org/x/xerrors"
-
-	"github.com/filecoin-project/go-bitfield"
-)
-
-func AllPartSectors(mas State, sget func(Partition) (bitfield.BitField, error)) (bitfield.BitField, error) {
-	var parts []bitfield.BitField
-
-	err := mas.ForEachDeadline(func(dlidx uint64, dl Deadline) error {
-		return dl.ForEachPartition(func(partidx uint64, part Partition) error {
-			s, err := sget(part)
-			if err != nil {
-				return xerrors.Errorf("getting sector list (dl: %d, part %d): %w", dlidx, partidx, err)
-			}
-
-			parts = append(parts, s)
-			return nil
-		})
-	})
-	if err != nil {
-		return bitfield.BitField{}, err
-	}
-
-	return bitfield.MultiMerge(parts...)
-}

chain/actors/builtin/miner/v0.go

@@ -1,383 +0,0 @@
-package miner
-
-import (
-	"bytes"
-	"errors"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-bitfield"
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/go-state-types/dline"
-	"github.com/ipfs/go-cid"
-	"github.com/libp2p/go-libp2p-core/peer"
-	cbg "github.com/whyrusleeping/cbor-gen"
-	"golang.org/x/xerrors"
-
-	"github.com/filecoin-project/lotus/chain/actors/adt"
-
-	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
-	adt0 "github.com/filecoin-project/specs-actors/actors/util/adt"
-)
-
-var _ State = (*state0)(nil)
-
-func load0(store adt.Store, root cid.Cid) (State, error) {
-	out := state0{store: store}
-	err := store.Get(store.Context(), root, &out)
-	if err != nil {
-		return nil, err
-	}
-	return &out, nil
-}
-
-type state0 struct {
-	miner0.State
-	store adt.Store
-}
-
-type deadline0 struct {
-	miner0.Deadline
-	store adt.Store
-}
-
-type partition0 struct {
-	miner0.Partition
-	store adt.Store
-}
-
-func (s *state0) AvailableBalance(bal abi.TokenAmount) (abi.TokenAmount, error) {
-	return s.GetAvailableBalance(bal), nil
-}
-
-func (s *state0) VestedFunds(epoch abi.ChainEpoch) (abi.TokenAmount, error) {
-	return s.CheckVestedFunds(s.store, epoch)
-}
-
-func (s *state0) LockedFunds() (LockedFunds, error) {
-	return LockedFunds{
-		VestingFunds:             s.State.LockedFunds,
-		InitialPledgeRequirement: s.State.InitialPledgeRequirement,
-		PreCommitDeposits:        s.State.PreCommitDeposits,
-	}, nil
-}
-
-func (s *state0) InitialPledge() (abi.TokenAmount, error) {
-	return s.State.InitialPledgeRequirement, nil
-}
-
-func (s *state0) PreCommitDeposits() (abi.TokenAmount, error) {
-	return s.State.PreCommitDeposits, nil
-}
-
-func (s *state0) GetSector(num abi.SectorNumber) (*SectorOnChainInfo, error) {
-	info, ok, err := s.State.GetSector(s.store, num)
-	if !ok || err != nil {
-		return nil, err
-	}
-
-	ret := fromV0SectorOnChainInfo(*info)
-	return &ret, nil
-}
-
-func (s *state0) FindSector(num abi.SectorNumber) (*SectorLocation, error) {
-	dlIdx, partIdx, err := s.State.FindSector(s.store, num)
-	if err != nil {
-		return nil, err
-	}
-	return &SectorLocation{
-		Deadline:  dlIdx,
-		Partition: partIdx,
-	}, nil
-}
-
-func (s *state0) NumLiveSectors() (uint64, error) {
-	dls, err := s.State.LoadDeadlines(s.store)
-	if err != nil {
-		return 0, err
-	}
-	var total uint64
-	if err := dls.ForEach(s.store, func(dlIdx uint64, dl *miner0.Deadline) error {
-		total += dl.LiveSectors
-		return nil
-	}); err != nil {
-		return 0, err
-	}
-	return total, nil
-}
-
-// GetSectorExpiration returns the effective expiration of the given sector.
-//
-// If the sector does not expire early, the Early expiration field is 0.
-func (s *state0) GetSectorExpiration(num abi.SectorNumber) (*SectorExpiration, error) {
-	dls, err := s.State.LoadDeadlines(s.store)
-	if err != nil {
-		return nil, err
-	}
-	// NOTE: this can be optimized significantly.
-	// 1. If the sector is non-faulty, it will either expire on-time (can be
-	// learned from the sector info), or in the next quantized expiration
-	// epoch (i.e., the first element in the partition's expiration queue.
-	// 2. If it's faulty, it will expire early within the first 14 entries
-	// of the expiration queue.
-	stopErr := errors.New("stop")
-	out := SectorExpiration{}
-	err = dls.ForEach(s.store, func(dlIdx uint64, dl *miner0.Deadline) error {
-		partitions, err := dl.PartitionsArray(s.store)
-		if err != nil {
-			return err
-		}
-		quant := s.State.QuantSpecForDeadline(dlIdx)
-		var part miner0.Partition
-		return partitions.ForEach(&part, func(partIdx int64) error {
-			if found, err := part.Sectors.IsSet(uint64(num)); err != nil {
-				return err
-			} else if !found {
-				return nil
-			}
-			if found, err := part.Terminated.IsSet(uint64(num)); err != nil {
-				return err
-			} else if found {
-				// already terminated
-				return stopErr
-			}
-
-			q, err := miner0.LoadExpirationQueue(s.store, part.ExpirationsEpochs, quant)
-			if err != nil {
-				return err
-			}
-			var exp miner0.ExpirationSet
-			return q.ForEach(&exp, func(epoch int64) error {
-				if early, err := exp.EarlySectors.IsSet(uint64(num)); err != nil {
-					return err
-				} else if early {
-					out.Early = abi.ChainEpoch(epoch)
-					return nil
-				}
-				if onTime, err := exp.OnTimeSectors.IsSet(uint64(num)); err != nil {
-					return err
-				} else if onTime {
-					out.OnTime = abi.ChainEpoch(epoch)
-					return stopErr
-				}
-				return nil
-			})
-		})
-	})
-	if err == stopErr {
-		err = nil
-	}
-	if err != nil {
-		return nil, err
-	}
-	if out.Early == 0 && out.OnTime == 0 {
-		return nil, xerrors.Errorf("failed to find sector %d", num)
-	}
-	return &out, nil
-}
-
-func (s *state0) GetPrecommittedSector(num abi.SectorNumber) (*SectorPreCommitOnChainInfo, error) {
-	info, ok, err := s.State.GetPrecommittedSector(s.store, num)
-	if !ok || err != nil {
-		return nil, err
-	}
-
-	ret := fromV0SectorPreCommitOnChainInfo(*info)
-	return &ret, nil
-}
-
-func (s *state0) LoadSectors(snos *bitfield.BitField) ([]*SectorOnChainInfo, error) {
-	sectors, err := miner0.LoadSectors(s.store, s.State.Sectors)
-	if err != nil {
-		return nil, err
-	}
-
-	// If no sector numbers are specified, load all.
-	if snos == nil {
-		infos := make([]*SectorOnChainInfo, 0, sectors.Length())
-		var info0 miner0.SectorOnChainInfo
-		if err := sectors.ForEach(&info0, func(_ int64) error {
-			info := fromV0SectorOnChainInfo(info0)
-			infos = append(infos, &info)
-			return nil
-		}); err != nil {
-			return nil, err
-		}
-		return infos, nil
-	}
-
-	// Otherwise, load selected.
-	infos0, err := sectors.Load(*snos)
-	if err != nil {
-		return nil, err
-	}
-	infos := make([]*SectorOnChainInfo, len(infos0))
-	for i, info0 := range infos0 {
-		info := fromV0SectorOnChainInfo(*info0)
-		infos[i] = &info
-	}
-	return infos, nil
-}
-
-func (s *state0) IsAllocated(num abi.SectorNumber) (bool, error) {
-	var allocatedSectors bitfield.BitField
-	if err := s.store.Get(s.store.Context(), s.State.AllocatedSectors, &allocatedSectors); err != nil {
-		return false, err
-	}
-
-	return allocatedSectors.IsSet(uint64(num))
-}
-
-func (s *state0) LoadDeadline(idx uint64) (Deadline, error) {
-	dls, err := s.State.LoadDeadlines(s.store)
-	if err != nil {
-		return nil, err
-	}
-	dl, err := dls.LoadDeadline(s.store, idx)
-	if err != nil {
-		return nil, err
-	}
-	return &deadline0{*dl, s.store}, nil
-}
-
-func (s *state0) ForEachDeadline(cb func(uint64, Deadline) error) error {
-	dls, err := s.State.LoadDeadlines(s.store)
-	if err != nil {
-		return err
-	}
-	return dls.ForEach(s.store, func(i uint64, dl *miner0.Deadline) error {
-		return cb(i, &deadline0{*dl, s.store})
-	})
-}
-
-func (s *state0) NumDeadlines() (uint64, error) {
-	return miner0.WPoStPeriodDeadlines, nil
-}
-
-func (s *state0) DeadlinesChanged(other State) (bool, error) {
-	other0, ok := other.(*state0)
-	if !ok {
-		// treat an upgrade as a change, always
-		return true, nil
-	}
-
-	return s.State.Deadlines.Equals(other0.Deadlines), nil
-}
-
-func (s *state0) Info() (MinerInfo, error) {
-	info, err := s.State.GetInfo(s.store)
-	if err != nil {
-		return MinerInfo{}, err
-	}
-
-	var pid *peer.ID
-	if peerID, err := peer.IDFromBytes(info.PeerId); err == nil {
-		pid = &peerID
-	}
-
-	mi := MinerInfo{
-		Owner:            info.Owner,
-		Worker:           info.Worker,
-		ControlAddresses: info.ControlAddresses,
-
-		NewWorker:         address.Undef,
-		WorkerChangeEpoch: -1,
-
-		PeerId:                     pid,
-		Multiaddrs:                 info.Multiaddrs,
-		SealProofType:              info.SealProofType,
-		SectorSize:                 info.SectorSize,
-		WindowPoStPartitionSectors: info.WindowPoStPartitionSectors,
-	}
-
-	if info.PendingWorkerKey != nil {
-		mi.NewWorker = info.PendingWorkerKey.NewWorker
-		mi.WorkerChangeEpoch = info.PendingWorkerKey.EffectiveAt
-	}
-
-	return mi, nil
-}
-
-func (s *state0) DeadlineInfo(epoch abi.ChainEpoch) (*dline.Info, error) {
-	return s.State.DeadlineInfo(epoch), nil
-}
-
-func (s *state0) sectors() (adt.Array, error) {
-	return adt0.AsArray(s.store, s.Sectors)
-}
-
-func (s *state0) decodeSectorOnChainInfo(val *cbg.Deferred) (SectorOnChainInfo, error) {
-	var si miner0.SectorOnChainInfo
-	err := si.UnmarshalCBOR(bytes.NewReader(val.Raw))
-	if err != nil {
-		return SectorOnChainInfo{}, err
-	}
-
-	return fromV0SectorOnChainInfo(si), nil
-}
-
-func (s *state0) precommits() (adt.Map, error) {
-	return adt0.AsMap(s.store, s.PreCommittedSectors)
-}
-
-func (s *state0) decodeSectorPreCommitOnChainInfo(val *cbg.Deferred) (SectorPreCommitOnChainInfo, error) {
-	var sp miner0.SectorPreCommitOnChainInfo
-	err := sp.UnmarshalCBOR(bytes.NewReader(val.Raw))
-	if err != nil {
-		return SectorPreCommitOnChainInfo{}, err
-	}
-
-	return fromV0SectorPreCommitOnChainInfo(sp), nil
-}
-
-func (d *deadline0) LoadPartition(idx uint64) (Partition, error) {
-	p, err := d.Deadline.LoadPartition(d.store, idx)
-	if err != nil {
-		return nil, err
-	}
-	return &partition0{*p, d.store}, nil
-}
-
-func (d *deadline0) ForEachPartition(cb func(uint64, Partition) error) error {
-	ps, err := d.Deadline.PartitionsArray(d.store)
-	if err != nil {
-		return err
-	}
-	var part miner0.Partition
-	return ps.ForEach(&part, func(i int64) error {
-		return cb(uint64(i), &partition0{part, d.store})
-	})
-}
-
-func (d *deadline0) PartitionsChanged(other Deadline) (bool, error) {
-	other0, ok := other.(*deadline0)
-	if !ok {
-		// treat an upgrade as a change, always
-		return true, nil
-	}
-
-	return d.Deadline.Partitions.Equals(other0.Deadline.Partitions), nil
-}
-
-func (d *deadline0) PostSubmissions() (bitfield.BitField, error) {
-	return d.Deadline.PostSubmissions, nil
-}
-
-func (p *partition0) AllSectors() (bitfield.BitField, error) {
-	return p.Partition.Sectors, nil
-}
-
-func (p *partition0) FaultySectors() (bitfield.BitField, error) {
-	return p.Partition.Faults, nil
-}
-
-func (p *partition0) RecoveringSectors() (bitfield.BitField, error) {
-	return p.Partition.Recoveries, nil
-}
-
-func fromV0SectorOnChainInfo(v0 miner0.SectorOnChainInfo) SectorOnChainInfo {
-	return (SectorOnChainInfo)(v0)
-}
-
-func fromV0SectorPreCommitOnChainInfo(v0 miner0.SectorPreCommitOnChainInfo) SectorPreCommitOnChainInfo {
-	return (SectorPreCommitOnChainInfo)(v0)
-}

chain/actors/builtin/miner/v2.go

@@ -1,403 +0,0 @@
-package miner
-
-import (
-	"bytes"
-	"errors"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-bitfield"
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/go-state-types/dline"
-	"github.com/ipfs/go-cid"
-	"github.com/libp2p/go-libp2p-core/peer"
-	cbg "github.com/whyrusleeping/cbor-gen"
-
-	"github.com/filecoin-project/lotus/chain/actors/adt"
-
-	miner2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/miner"
-	adt2 "github.com/filecoin-project/specs-actors/v2/actors/util/adt"
-)
-
-var _ State = (*state2)(nil)
-
-func load2(store adt.Store, root cid.Cid) (State, error) {
-	out := state2{store: store}
-	err := store.Get(store.Context(), root, &out)
-	if err != nil {
-		return nil, err
-	}
-	return &out, nil
-}
-
-type state2 struct {
-	miner2.State
-	store adt.Store
-}
-
-type deadline2 struct {
-	miner2.Deadline
-	store adt.Store
-}
-
-type partition2 struct {
-	miner2.Partition
-	store adt.Store
-}
-
-func (s *state2) AvailableBalance(bal abi.TokenAmount) (abi.TokenAmount, error) {
-	return s.GetAvailableBalance(bal), nil
-}
-
-func (s *state2) VestedFunds(epoch abi.ChainEpoch) (abi.TokenAmount, error) {
-	return s.CheckVestedFunds(s.store, epoch)
-}
-
-func (s *state2) LockedFunds() (LockedFunds, error) {
-	return LockedFunds{
-		VestingFunds:             s.State.LockedFunds,
-		InitialPledgeRequirement: s.State.InitialPledge,
-		PreCommitDeposits:        s.State.PreCommitDeposits,
-	}, nil
-}
-
-func (s *state2) InitialPledge() (abi.TokenAmount, error) {
-	return s.State.InitialPledge, nil
-}
-
-func (s *state2) PreCommitDeposits() (abi.TokenAmount, error) {
-	return s.State.PreCommitDeposits, nil
-}
-
-func (s *state2) GetSector(num abi.SectorNumber) (*SectorOnChainInfo, error) {
-	info, ok, err := s.State.GetSector(s.store, num)
-	if !ok || err != nil {
-		return nil, err
-	}
-
-	ret := fromV2SectorOnChainInfo(*info)
-	return &ret, nil
-}
-
-func (s *state2) FindSector(num abi.SectorNumber) (*SectorLocation, error) {
-	dlIdx, partIdx, err := s.State.FindSector(s.store, num)
-	if err != nil {
-		return nil, err
-	}
-	return &SectorLocation{
-		Deadline:  dlIdx,
-		Partition: partIdx,
-	}, nil
-}
-
-func (s *state2) NumLiveSectors() (uint64, error) {
-	dls, err := s.State.LoadDeadlines(s.store)
-	if err != nil {
-		return 0, err
-	}
-	var total uint64
-	if err := dls.ForEach(s.store, func(dlIdx uint64, dl *miner2.Deadline) error {
-		total += dl.LiveSectors
-		return nil
-	}); err != nil {
-		return 0, err
-	}
-	return total, nil
-}
-
-// GetSectorExpiration returns the effective expiration of the given sector.
-//
-// If the sector isn't found or has already been terminated, this method returns
-// nil and no error. If the sector does not expire early, the Early expiration
-// field is 0.
-func (s *state2) GetSectorExpiration(num abi.SectorNumber) (*SectorExpiration, error) {
-	dls, err := s.State.LoadDeadlines(s.store)
-	if err != nil {
-		return nil, err
-	}
-	// NOTE: this can be optimized significantly.
-	// 1. If the sector is non-faulty, it will either expire on-time (can be
-	// learned from the sector info), or in the next quantized expiration
-	// epoch (i.e., the first element in the partition's expiration queue.
-	// 2. If it's faulty, it will expire early within the first 14 entries
-	// of the expiration queue.
-	stopErr := errors.New("stop")
-	out := SectorExpiration{}
-	err = dls.ForEach(s.store, func(dlIdx uint64, dl *miner2.Deadline) error {
-		partitions, err := dl.PartitionsArray(s.store)
-		if err != nil {
-			return err
-		}
-		quant := s.State.QuantSpecForDeadline(dlIdx)
-		var part miner2.Partition
-		return partitions.ForEach(&part, func(partIdx int64) error {
-			if found, err := part.Sectors.IsSet(uint64(num)); err != nil {
-				return err
-			} else if !found {
-				return nil
-			}
-			if found, err := part.Terminated.IsSet(uint64(num)); err != nil {
-				return err
-			} else if found {
-				// already terminated
-				return stopErr
-			}
-
-			q, err := miner2.LoadExpirationQueue(s.store, part.ExpirationsEpochs, quant)
-			if err != nil {
-				return err
-			}
-			var exp miner2.ExpirationSet
-			return q.ForEach(&exp, func(epoch int64) error {
-				if early, err := exp.EarlySectors.IsSet(uint64(num)); err != nil {
-					return err
-				} else if early {
-					out.Early = abi.ChainEpoch(epoch)
-					return nil
-				}
-				if onTime, err := exp.OnTimeSectors.IsSet(uint64(num)); err != nil {
-					return err
-				} else if onTime {
-					out.OnTime = abi.ChainEpoch(epoch)
-					return stopErr
-				}
-				return nil
-			})
-		})
-	})
-	if err == stopErr {
-		err = nil
-	}
-	if err != nil {
-		return nil, err
-	}
-	if out.Early == 0 && out.OnTime == 0 {
-		return nil, nil
-	}
-	return &out, nil
-}
-
-func (s *state2) GetPrecommittedSector(num abi.SectorNumber) (*SectorPreCommitOnChainInfo, error) {
-	info, ok, err := s.State.GetPrecommittedSector(s.store, num)
-	if !ok || err != nil {
-		return nil, err
-	}
-
-	ret := fromV2SectorPreCommitOnChainInfo(*info)
-
-	return &ret, nil
-}
-
-func (s *state2) LoadSectors(snos *bitfield.BitField) ([]*SectorOnChainInfo, error) {
-	sectors, err := miner2.LoadSectors(s.store, s.State.Sectors)
-	if err != nil {
-		return nil, err
-	}
-
-	// If no sector numbers are specified, load all.
-	if snos == nil {
-		infos := make([]*SectorOnChainInfo, 0, sectors.Length())
-		var info2 miner2.SectorOnChainInfo
-		if err := sectors.ForEach(&info2, func(_ int64) error {
-			info := fromV2SectorOnChainInfo(info2)
-			infos = append(infos, &info)
-			return nil
-		}); err != nil {
-			return nil, err
-		}
-		return infos, nil
-	}
-
-	// Otherwise, load selected.
-	infos2, err := sectors.Load(*snos)
-	if err != nil {
-		return nil, err
-	}
-	infos := make([]*SectorOnChainInfo, len(infos2))
-	for i, info2 := range infos2 {
-		info := fromV2SectorOnChainInfo(*info2)
-		infos[i] = &info
-	}
-	return infos, nil
-}
-
-func (s *state2) IsAllocated(num abi.SectorNumber) (bool, error) {
-	var allocatedSectors bitfield.BitField
-	if err := s.store.Get(s.store.Context(), s.State.AllocatedSectors, &allocatedSectors); err != nil {
-		return false, err
-	}
-
-	return allocatedSectors.IsSet(uint64(num))
-}
-
-func (s *state2) LoadDeadline(idx uint64) (Deadline, error) {
-	dls, err := s.State.LoadDeadlines(s.store)
-	if err != nil {
-		return nil, err
-	}
-	dl, err := dls.LoadDeadline(s.store, idx)
-	if err != nil {
-		return nil, err
-	}
-	return &deadline2{*dl, s.store}, nil
-}
-
-func (s *state2) ForEachDeadline(cb func(uint64, Deadline) error) error {
-	dls, err := s.State.LoadDeadlines(s.store)
-	if err != nil {
-		return err
-	}
-	return dls.ForEach(s.store, func(i uint64, dl *miner2.Deadline) error {
-		return cb(i, &deadline2{*dl, s.store})
-	})
-}
-
-func (s *state2) NumDeadlines() (uint64, error) {
-	return miner2.WPoStPeriodDeadlines, nil
-}
-
-func (s *state2) DeadlinesChanged(other State) (bool, error) {
-	other2, ok := other.(*state2)
-	if !ok {
-		// treat an upgrade as a change, always
-		return true, nil
-	}
-
-	return s.State.Deadlines.Equals(other2.Deadlines), nil
-}
-
-func (s *state2) Info() (MinerInfo, error) {
-	info, err := s.State.GetInfo(s.store)
-	if err != nil {
-		return MinerInfo{}, err
-	}
-
-	var pid *peer.ID
-	if peerID, err := peer.IDFromBytes(info.PeerId); err == nil {
-		pid = &peerID
-	}
-
-	mi := MinerInfo{
-		Owner:            info.Owner,
-		Worker:           info.Worker,
-		ControlAddresses: info.ControlAddresses,
-
-		NewWorker:         address.Undef,
-		WorkerChangeEpoch: -1,
-
-		PeerId:                     pid,
-		Multiaddrs:                 info.Multiaddrs,
-		SealProofType:              info.SealProofType,
-		SectorSize:                 info.SectorSize,
-		WindowPoStPartitionSectors: info.WindowPoStPartitionSectors,
-	}
-
-	if info.PendingWorkerKey != nil {
-		mi.NewWorker = info.PendingWorkerKey.NewWorker
-		mi.WorkerChangeEpoch = info.PendingWorkerKey.EffectiveAt
-	}
-
-	return mi, nil
-}
-
-func (s *state2) DeadlineInfo(epoch abi.ChainEpoch) (*dline.Info, error) {
-	return s.State.DeadlineInfo(epoch), nil
-}
-
-func (s *state2) sectors() (adt.Array, error) {
-	return adt2.AsArray(s.store, s.Sectors)
-}
-
-func (s *state2) decodeSectorOnChainInfo(val *cbg.Deferred) (SectorOnChainInfo, error) {
-	var si miner2.SectorOnChainInfo
-	err := si.UnmarshalCBOR(bytes.NewReader(val.Raw))
-	if err != nil {
-		return SectorOnChainInfo{}, err
-	}
-
-	return fromV2SectorOnChainInfo(si), nil
-}
-
-func (s *state2) precommits() (adt.Map, error) {
-	return adt2.AsMap(s.store, s.PreCommittedSectors)
-}
-
-func (s *state2) decodeSectorPreCommitOnChainInfo(val *cbg.Deferred) (SectorPreCommitOnChainInfo, error) {
-	var sp miner2.SectorPreCommitOnChainInfo
-	err := sp.UnmarshalCBOR(bytes.NewReader(val.Raw))
-	if err != nil {
-		return SectorPreCommitOnChainInfo{}, err
-	}
-
-	return fromV2SectorPreCommitOnChainInfo(sp), nil
-}
-
-func (d *deadline2) LoadPartition(idx uint64) (Partition, error) {
-	p, err := d.Deadline.LoadPartition(d.store, idx)
-	if err != nil {
-		return nil, err
-	}
-	return &partition2{*p, d.store}, nil
-}
-
-func (d *deadline2) ForEachPartition(cb func(uint64, Partition) error) error {
-	ps, err := d.Deadline.PartitionsArray(d.store)
-	if err != nil {
-		return err
-	}
-	var part miner2.Partition
-	return ps.ForEach(&part, func(i int64) error {
-		return cb(uint64(i), &partition2{part, d.store})
-	})
-}
-
-func (d *deadline2) PartitionsChanged(other Deadline) (bool, error) {
-	other2, ok := other.(*deadline2)
-	if !ok {
-		// treat an upgrade as a change, always
-		return true, nil
-	}
-
-	return d.Deadline.Partitions.Equals(other2.Deadline.Partitions), nil
-}
-
-func (d *deadline2) PostSubmissions() (bitfield.BitField, error) {
-	return d.Deadline.PostSubmissions, nil
-}
-
-func (p *partition2) AllSectors() (bitfield.BitField, error) {
-	return p.Partition.Sectors, nil
-}
-
-func (p *partition2) FaultySectors() (bitfield.BitField, error) {
-	return p.Partition.Faults, nil
-}
-
-func (p *partition2) RecoveringSectors() (bitfield.BitField, error) {
-	return p.Partition.Recoveries, nil
-}
-
-func fromV2SectorOnChainInfo(v2 miner2.SectorOnChainInfo) SectorOnChainInfo {
-	return SectorOnChainInfo{
-		SectorNumber:          v2.SectorNumber,
-		SealProof:             v2.SealProof,
-		SealedCID:             v2.SealedCID,
-		DealIDs:               v2.DealIDs,
-		Activation:            v2.Activation,
-		Expiration:            v2.Expiration,
-		DealWeight:            v2.DealWeight,
-		VerifiedDealWeight:    v2.VerifiedDealWeight,
-		InitialPledge:         v2.InitialPledge,
-		ExpectedDayReward:     v2.ExpectedDayReward,
-		ExpectedStoragePledge: v2.ExpectedStoragePledge,
-	}
-}
-
-func fromV2SectorPreCommitOnChainInfo(v2 miner2.SectorPreCommitOnChainInfo) SectorPreCommitOnChainInfo {
-	return SectorPreCommitOnChainInfo{
-		Info:               (SectorPreCommitInfo)(v2.Info),
-		PreCommitDeposit:   v2.PreCommitDeposit,
-		PreCommitEpoch:     v2.PreCommitEpoch,
-		DealWeight:         v2.DealWeight,
-		VerifiedDealWeight: v2.VerifiedDealWeight,
-	}
-}

chain/actors/builtin/multisig/message.go

@@ -1,70 +0,0 @@
-package multisig
-
-import (
-	"fmt"
-
-	"github.com/minio/blake2b-simd"
-	"golang.org/x/xerrors"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/abi"
-
-	multisig2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/multisig"
-
-	"github.com/filecoin-project/lotus/chain/actors"
-	"github.com/filecoin-project/lotus/chain/types"
-)
-
-func Message(version actors.Version, from address.Address) MessageBuilder {
-	switch version {
-	case actors.Version0:
-		return message0{from}
-	case actors.Version2:
-		return message2{message0{from}}
-	default:
-		panic(fmt.Sprintf("unsupported actors version: %d", version))
-	}
-}
-
-type MessageBuilder interface {
-	// Create a new multisig with the specified parameters.
-	Create(signers []address.Address, threshold uint64,
-		vestingStart, vestingDuration abi.ChainEpoch,
-		initialAmount abi.TokenAmount) (*types.Message, error)
-
-	// Propose a transaction to the given multisig.
-	Propose(msig, target address.Address, amt abi.TokenAmount,
-		method abi.MethodNum, params []byte) (*types.Message, error)
-
-	// Approve a multisig transaction. The "hash" is optional.
-	Approve(msig address.Address, txID uint64, hash *ProposalHashData) (*types.Message, error)
-
-	// Cancel a multisig transaction. The "hash" is optional.
-	Cancel(msig address.Address, txID uint64, hash *ProposalHashData) (*types.Message, error)
-}
-
-// this type is the same between v0 and v2
-type ProposalHashData = multisig2.ProposalHashData
-
-func txnParams(id uint64, data *ProposalHashData) ([]byte, error) {
-	params := multisig2.TxnIDParams{ID: multisig2.TxnID(id)}
-	if data != nil {
-		if data.Requester.Protocol() != address.ID {
-			return nil, xerrors.Errorf("proposer address must be an ID address, was %s", data.Requester)
-		}
-		if data.Value.Sign() == -1 {
-			return nil, xerrors.Errorf("proposal value must be non-negative, was %s", data.Value)
-		}
-		if data.To == address.Undef {
-			return nil, xerrors.Errorf("proposed destination address must be set")
-		}
-		pser, err := data.Serialize()
-		if err != nil {
-			return nil, err
-		}
-		hash := blake2b.Sum256(pser)
-		params.ProposalHash = hash[:]
-	}
-
-	return actors.SerializeParams(&params)
-}

chain/actors/builtin/multisig/message0.go

@@ -1,142 +0,0 @@
-package multisig
-
-import (
-	"golang.org/x/xerrors"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/abi"
-
-	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
-	init0 "github.com/filecoin-project/specs-actors/actors/builtin/init"
-	multisig0 "github.com/filecoin-project/specs-actors/actors/builtin/multisig"
-
-	"github.com/filecoin-project/lotus/chain/actors"
-	init_ "github.com/filecoin-project/lotus/chain/actors/builtin/init"
-	"github.com/filecoin-project/lotus/chain/types"
-)
-
-type message0 struct{ from address.Address }
-
-func (m message0) Create(
-	signers []address.Address, threshold uint64,
-	unlockStart, unlockDuration abi.ChainEpoch,
-	initialAmount abi.TokenAmount,
-) (*types.Message, error) {
-
-	lenAddrs := uint64(len(signers))
-
-	if lenAddrs < threshold {
-		return nil, xerrors.Errorf("cannot require signing of more addresses than provided for multisig")
-	}
-
-	if threshold == 0 {
-		threshold = lenAddrs
-	}
-
-	if m.from == address.Undef {
-		return nil, xerrors.Errorf("must provide source address")
-	}
-
-	if unlockStart != 0 {
-		return nil, xerrors.Errorf("actors v0 does not support a non-zero vesting start time")
-	}
-
-	// Set up constructor parameters for multisig
-	msigParams := &multisig0.ConstructorParams{
-		Signers:               signers,
-		NumApprovalsThreshold: threshold,
-		UnlockDuration:        unlockDuration,
-	}
-
-	enc, actErr := actors.SerializeParams(msigParams)
-	if actErr != nil {
-		return nil, actErr
-	}
-
-	// new actors are created by invoking 'exec' on the init actor with the constructor params
-	execParams := &init0.ExecParams{
-		CodeCID:           builtin0.MultisigActorCodeID,
-		ConstructorParams: enc,
-	}
-
-	enc, actErr = actors.SerializeParams(execParams)
-	if actErr != nil {
-		return nil, actErr
-	}
-
-	return &types.Message{
-		To:     init_.Address,
-		From:   m.from,
-		Method: builtin0.MethodsInit.Exec,
-		Params: enc,
-		Value:  initialAmount,
-	}, nil
-}
-
-func (m message0) Propose(msig, to address.Address, amt abi.TokenAmount,
-	method abi.MethodNum, params []byte) (*types.Message, error) {
-
-	if msig == address.Undef {
-		return nil, xerrors.Errorf("must provide a multisig address for proposal")
-	}
-
-	if to == address.Undef {
-		return nil, xerrors.Errorf("must provide a target address for proposal")
-	}
-
-	if amt.Sign() == -1 {
-		return nil, xerrors.Errorf("must provide a non-negative amount for proposed send")
-	}
-
-	if m.from == address.Undef {
-		return nil, xerrors.Errorf("must provide source address")
-	}
-
-	enc, actErr := actors.SerializeParams(&multisig0.ProposeParams{
-		To:     to,
-		Value:  amt,
-		Method: method,
-		Params: params,
-	})
-	if actErr != nil {
-		return nil, xerrors.Errorf("failed to serialize parameters: %w", actErr)
-	}
-
-	return &types.Message{
-		To:     msig,
-		From:   m.from,
-		Value:  abi.NewTokenAmount(0),
-		Method: builtin0.MethodsMultisig.Propose,
-		Params: enc,
-	}, nil
-}
-
-func (m message0) Approve(msig address.Address, txID uint64, hashData *ProposalHashData) (*types.Message, error) {
-	enc, err := txnParams(txID, hashData)
-	if err != nil {
-		return nil, err
-	}
-
-	return &types.Message{
-		To:     msig,
-		From:   m.from,
-		Value:  types.NewInt(0),
-		Method: builtin0.MethodsMultisig.Approve,
-		Params: enc,
-	}, nil
-}
-
-func (m message0) Cancel(msig address.Address, txID uint64, hashData *ProposalHashData) (*types.Message, error) {
-	enc, err := txnParams(txID, hashData)
-	if err != nil {
-		return nil, err
-	}
-
-	return &types.Message{
-		To:     msig,
-		From:   m.from,
-		Value:  types.NewInt(0),
-		Method: builtin0.MethodsMultisig.Cancel,
-		Params: enc,
-	}, nil
-}

chain/actors/builtin/multisig/message2.go

@@ -1,71 +0,0 @@
-package multisig
-
-import (
-	"golang.org/x/xerrors"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/abi"
-
-	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
-	init2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/init"
-	multisig2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/multisig"
-
-	"github.com/filecoin-project/lotus/chain/actors"
-	init_ "github.com/filecoin-project/lotus/chain/actors/builtin/init"
-	"github.com/filecoin-project/lotus/chain/types"
-)
-
-type message2 struct{ message0 }
-
-func (m message2) Create(
-	signers []address.Address, threshold uint64,
-	unlockStart, unlockDuration abi.ChainEpoch,
-	initialAmount abi.TokenAmount,
-) (*types.Message, error) {
-
-	lenAddrs := uint64(len(signers))
-
-	if lenAddrs < threshold {
-		return nil, xerrors.Errorf("cannot require signing of more addresses than provided for multisig")
-	}
-
-	if threshold == 0 {
-		threshold = lenAddrs
-	}
-
-	if m.from == address.Undef {
-		return nil, xerrors.Errorf("must provide source address")
-	}
-
-	// Set up constructor parameters for multisig
-	msigParams := &multisig2.ConstructorParams{
-		Signers:               signers,
-		NumApprovalsThreshold: threshold,
-		UnlockDuration:        unlockDuration,
-		StartEpoch:            unlockStart,
-	}
-
-	enc, actErr := actors.SerializeParams(msigParams)
-	if actErr != nil {
-		return nil, actErr
-	}
-
-	// new actors are created by invoking 'exec' on the init actor with the constructor params
-	execParams := &init2.ExecParams{
-		CodeCID:           builtin2.MultisigActorCodeID,
-		ConstructorParams: enc,
-	}
-
-	enc, actErr = actors.SerializeParams(execParams)
-	if actErr != nil {
-		return nil, actErr
-	}
-
-	return &types.Message{
-		To:     init_.Address,
-		From:   m.from,
-		Method: builtin2.MethodsInit.Exec,
-		Params: enc,
-		Value:  initialAmount,
-	}, nil
-}

chain/actors/builtin/multisig/state.go

@@ -1,52 +0,0 @@
-package multisig
-
-import (
-	"golang.org/x/xerrors"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/go-state-types/cbor"
-	"github.com/ipfs/go-cid"
-
-	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
-	msig0 "github.com/filecoin-project/specs-actors/actors/builtin/multisig"
-	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
-
-	"github.com/filecoin-project/lotus/chain/actors/adt"
-	"github.com/filecoin-project/lotus/chain/actors/builtin"
-	"github.com/filecoin-project/lotus/chain/types"
-)
-
-func init() {
-	builtin.RegisterActorState(builtin0.MultisigActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
-		return load0(store, root)
-	})
-	builtin.RegisterActorState(builtin2.MultisigActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
-		return load2(store, root)
-	})
-}
-
-func Load(store adt.Store, act *types.Actor) (State, error) {
-	switch act.Code {
-	case builtin0.MultisigActorCodeID:
-		return load0(store, act.Head)
-	case builtin2.MultisigActorCodeID:
-		return load2(store, act.Head)
-	}
-	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
-}
-
-type State interface {
-	cbor.Marshaler
-
-	LockedBalance(epoch abi.ChainEpoch) (abi.TokenAmount, error)
-	StartEpoch() (abi.ChainEpoch, error)
-	UnlockDuration() (abi.ChainEpoch, error)
-	InitialBalance() (abi.TokenAmount, error)
-	Threshold() (uint64, error)
-	Signers() ([]address.Address, error)
-
-	ForEachPendingTxn(func(id int64, txn Transaction) error) error
-}
-
-type Transaction = msig0.Transaction

chain/actors/builtin/multisig/state0.go

@@ -1,70 +0,0 @@
-package multisig
-
-import (
-	"encoding/binary"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/ipfs/go-cid"
-	"golang.org/x/xerrors"
-
-	"github.com/filecoin-project/lotus/chain/actors/adt"
-
-	msig0 "github.com/filecoin-project/specs-actors/actors/builtin/multisig"
-	adt0 "github.com/filecoin-project/specs-actors/actors/util/adt"
-)
-
-var _ State = (*state0)(nil)
-
-func load0(store adt.Store, root cid.Cid) (State, error) {
-	out := state0{store: store}
-	err := store.Get(store.Context(), root, &out)
-	if err != nil {
-		return nil, err
-	}
-	return &out, nil
-}
-
-type state0 struct {
-	msig0.State
-	store adt.Store
-}
-
-func (s *state0) LockedBalance(currEpoch abi.ChainEpoch) (abi.TokenAmount, error) {
-	return s.State.AmountLocked(currEpoch - s.State.StartEpoch), nil
-}
-
-func (s *state0) StartEpoch() (abi.ChainEpoch, error) {
-	return s.State.StartEpoch, nil
-}
-
-func (s *state0) UnlockDuration() (abi.ChainEpoch, error) {
-	return s.State.UnlockDuration, nil
-}
-
-func (s *state0) InitialBalance() (abi.TokenAmount, error) {
-	return s.State.InitialBalance, nil
-}
-
-func (s *state0) Threshold() (uint64, error) {
-	return s.State.NumApprovalsThreshold, nil
-}
-
-func (s *state0) Signers() ([]address.Address, error) {
-	return s.State.Signers, nil
-}
-
-func (s *state0) ForEachPendingTxn(cb func(id int64, txn Transaction) error) error {
-	arr, err := adt0.AsMap(s.store, s.State.PendingTxns)
-	if err != nil {
-		return err
-	}
-	var out msig0.Transaction
-	return arr.ForEach(&out, func(key string) error {
-		txid, n := binary.Varint([]byte(key))
-		if n <= 0 {
-			return xerrors.Errorf("invalid pending transaction key: %v", key)
-		}
-		return cb(txid, (Transaction)(out))
-	})
-}

chain/actors/builtin/multisig/state2.go

@@ -1,70 +0,0 @@
-package multisig
-
-import (
-	"encoding/binary"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/ipfs/go-cid"
-	"golang.org/x/xerrors"
-
-	"github.com/filecoin-project/lotus/chain/actors/adt"
-
-	msig2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/multisig"
-	adt2 "github.com/filecoin-project/specs-actors/v2/actors/util/adt"
-)
-
-var _ State = (*state2)(nil)
-
-func load2(store adt.Store, root cid.Cid) (State, error) {
-	out := state2{store: store}
-	err := store.Get(store.Context(), root, &out)
-	if err != nil {
-		return nil, err
-	}
-	return &out, nil
-}
-
-type state2 struct {
-	msig2.State
-	store adt.Store
-}
-
-func (s *state2) LockedBalance(currEpoch abi.ChainEpoch) (abi.TokenAmount, error) {
-	return s.State.AmountLocked(currEpoch - s.State.StartEpoch), nil
-}
-
-func (s *state2) StartEpoch() (abi.ChainEpoch, error) {
-	return s.State.StartEpoch, nil
-}
-
-func (s *state2) UnlockDuration() (abi.ChainEpoch, error) {
-	return s.State.UnlockDuration, nil
-}
-
-func (s *state2) InitialBalance() (abi.TokenAmount, error) {
-	return s.State.InitialBalance, nil
-}
-
-func (s *state2) Threshold() (uint64, error) {
-	return s.State.NumApprovalsThreshold, nil
-}
-
-func (s *state2) Signers() ([]address.Address, error) {
-	return s.State.Signers, nil
-}
-
-func (s *state2) ForEachPendingTxn(cb func(id int64, txn Transaction) error) error {
-	arr, err := adt2.AsMap(s.store, s.State.PendingTxns)
-	if err != nil {
-		return err
-	}
-	var out msig2.Transaction
-	return arr.ForEach(&out, func(key string) error {
-		txid, n := binary.Varint([]byte(key))
-		if n <= 0 {
-			return xerrors.Errorf("invalid pending transaction key: %v", key)
-		}
-		return cb(txid, (Transaction)(out))
-	})
-}

chain/actors/builtin/paych/message.go

@@ -1,28 +0,0 @@
-package paych
-
-import (
-	"fmt"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/lotus/chain/actors"
-	"github.com/filecoin-project/lotus/chain/types"
-)
-
-func Message(version actors.Version, from address.Address) MessageBuilder {
-	switch version {
-	case actors.Version0:
-		return message0{from}
-	case actors.Version2:
-		return message2{from}
-	default:
-		panic(fmt.Sprintf("unsupported actors version: %d", version))
-	}
-}
-
-type MessageBuilder interface {
-	Create(to address.Address, initialAmount abi.TokenAmount) (*types.Message, error)
-	Update(paych address.Address, voucher *SignedVoucher, secret []byte) (*types.Message, error)
-	Settle(paych address.Address) (*types.Message, error)
-	Collect(paych address.Address) (*types.Message, error)
-}

chain/actors/builtin/paych/message0.go

@@ -1,74 +0,0 @@
-package paych
-
-import (
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/abi"
-
-	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
-	init0 "github.com/filecoin-project/specs-actors/actors/builtin/init"
-	paych0 "github.com/filecoin-project/specs-actors/actors/builtin/paych"
-
-	"github.com/filecoin-project/lotus/chain/actors"
-	init_ "github.com/filecoin-project/lotus/chain/actors/builtin/init"
-	"github.com/filecoin-project/lotus/chain/types"
-)
-
-type message0 struct{ from address.Address }
-
-func (m message0) Create(to address.Address, initialAmount abi.TokenAmount) (*types.Message, error) {
-	params, aerr := actors.SerializeParams(&paych0.ConstructorParams{From: m.from, To: to})
-	if aerr != nil {
-		return nil, aerr
-	}
-	enc, aerr := actors.SerializeParams(&init0.ExecParams{
-		CodeCID:           builtin0.PaymentChannelActorCodeID,
-		ConstructorParams: params,
-	})
-	if aerr != nil {
-		return nil, aerr
-	}
-
-	return &types.Message{
-		To:     init_.Address,
-		From:   m.from,
-		Value:  initialAmount,
-		Method: builtin0.MethodsInit.Exec,
-		Params: enc,
-	}, nil
-}
-
-func (m message0) Update(paych address.Address, sv *SignedVoucher, secret []byte) (*types.Message, error) {
-	params, aerr := actors.SerializeParams(&paych0.UpdateChannelStateParams{
-		Sv:     *sv,
-		Secret: secret,
-	})
-	if aerr != nil {
-		return nil, aerr
-	}
-
-	return &types.Message{
-		To:     paych,
-		From:   m.from,
-		Value:  abi.NewTokenAmount(0),
-		Method: builtin0.MethodsPaych.UpdateChannelState,
-		Params: params,
-	}, nil
-}
-
-func (m message0) Settle(paych address.Address) (*types.Message, error) {
-	return &types.Message{
-		To:     paych,
-		From:   m.from,
-		Value:  abi.NewTokenAmount(0),
-		Method: builtin0.MethodsPaych.Settle,
-	}, nil
-}
-
-func (m message0) Collect(paych address.Address) (*types.Message, error) {
-	return &types.Message{
-		To:     paych,
-		From:   m.from,
-		Value:  abi.NewTokenAmount(0),
-		Method: builtin0.MethodsPaych.Collect,
-	}, nil
-}

chain/actors/builtin/paych/message2.go

@@ -1,74 +0,0 @@
-package paych
-
-import (
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/abi"
-
-	builtin2 "github.com/filecoin-project/specs-actors/actors/builtin"
-	init2 "github.com/filecoin-project/specs-actors/actors/builtin/init"
-	paych2 "github.com/filecoin-project/specs-actors/actors/builtin/paych"
-
-	"github.com/filecoin-project/lotus/chain/actors"
-	init_ "github.com/filecoin-project/lotus/chain/actors/builtin/init"
-	"github.com/filecoin-project/lotus/chain/types"
-)
-
-type message2 struct{ from address.Address }
-
-func (m message2) Create(to address.Address, initialAmount abi.TokenAmount) (*types.Message, error) {
-	params, aerr := actors.SerializeParams(&paych2.ConstructorParams{From: m.from, To: to})
-	if aerr != nil {
-		return nil, aerr
-	}
-	enc, aerr := actors.SerializeParams(&init2.ExecParams{
-		CodeCID:           builtin2.PaymentChannelActorCodeID,
-		ConstructorParams: params,
-	})
-	if aerr != nil {
-		return nil, aerr
-	}
-
-	return &types.Message{
-		To:     init_.Address,
-		From:   m.from,
-		Value:  initialAmount,
-		Method: builtin2.MethodsInit.Exec,
-		Params: enc,
-	}, nil
-}
-
-func (m message2) Update(paych address.Address, sv *SignedVoucher, secret []byte) (*types.Message, error) {
-	params, aerr := actors.SerializeParams(&paych2.UpdateChannelStateParams{
-		Sv:     *sv,
-		Secret: secret,
-	})
-	if aerr != nil {
-		return nil, aerr
-	}
-
-	return &types.Message{
-		To:     paych,
-		From:   m.from,
-		Value:  abi.NewTokenAmount(0),
-		Method: builtin2.MethodsPaych.UpdateChannelState,
-		Params: params,
-	}, nil
-}
-
-func (m message2) Settle(paych address.Address) (*types.Message, error) {
-	return &types.Message{
-		To:     paych,
-		From:   m.from,
-		Value:  abi.NewTokenAmount(0),
-		Method: builtin2.MethodsPaych.Settle,
-	}, nil
-}
-
-func (m message2) Collect(paych address.Address) (*types.Message, error) {
-	return &types.Message{
-		To:     paych,
-		From:   m.from,
-		Value:  abi.NewTokenAmount(0),
-		Method: builtin2.MethodsPaych.Collect,
-	}, nil
-}

chain/actors/builtin/paych/mock/mock.go

@@ -1,89 +0,0 @@
-package mock
-
-import (
-	"io"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/go-state-types/big"
-	"github.com/filecoin-project/lotus/chain/actors/builtin/paych"
-)
-
-type mockState struct {
-	from       address.Address
-	to         address.Address
-	settlingAt abi.ChainEpoch
-	toSend     abi.TokenAmount
-	lanes      map[uint64]paych.LaneState
-}
-
-type mockLaneState struct {
-	redeemed big.Int
-	nonce    uint64
-}
-
-// NewMockPayChState constructs a state for a payment channel with the set fixed values
-// that satisfies the paych.State interface.
-func NewMockPayChState(from address.Address,
-	to address.Address,
-	settlingAt abi.ChainEpoch,
-	toSend abi.TokenAmount,
-	lanes map[uint64]paych.LaneState,
-) paych.State {
-	return &mockState{from, to, settlingAt, toSend, lanes}
-}
-
-// NewMockLaneState constructs a state for a payment channel lane with the set fixed values
-// that satisfies the paych.LaneState interface. Useful for populating lanes when
-// calling NewMockPayChState
-func NewMockLaneState(redeemed big.Int, nonce uint64) paych.LaneState {
-	return &mockLaneState{redeemed, nonce}
-}
-
-func (ms *mockState) MarshalCBOR(io.Writer) error {
-	panic("not implemented")
-}
-
-// Channel owner, who has funded the actor
-func (ms *mockState) From() (address.Address, error) {
-	return ms.from, nil
-}
-
-// Recipient of payouts from channel
-func (ms *mockState) To() (address.Address, error) {
-	return ms.to, nil
-}
-
-// Height at which the channel can be `Collected`
-func (ms *mockState) SettlingAt() (abi.ChainEpoch, error) {
-	return ms.settlingAt, nil
-}
-
-// Amount successfully redeemed through the payment channel, paid out on `Collect()`
-func (ms *mockState) ToSend() (abi.TokenAmount, error) {
-	return ms.toSend, nil
-}
-
-// Get total number of lanes
-func (ms *mockState) LaneCount() (uint64, error) {
-	return uint64(len(ms.lanes)), nil
-}
-
-// Iterate lane states
-func (ms *mockState) ForEachLaneState(cb func(idx uint64, dl paych.LaneState) error) error {
-	var lastErr error
-	for lane, state := range ms.lanes {
-		if err := cb(lane, state); err != nil {
-			lastErr = err
-		}
-	}
-	return lastErr
-}
-
-func (mls *mockLaneState) Redeemed() (big.Int, error) {
-	return mls.redeemed, nil
-}
-
-func (mls *mockLaneState) Nonce() (uint64, error) {
-	return mls.nonce, nil
-}

chain/actors/builtin/paych/state.go

@@ -1,88 +0,0 @@
-package paych
-
-import (
-	"encoding/base64"
-
-	"golang.org/x/xerrors"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/abi"
-	big "github.com/filecoin-project/go-state-types/big"
-	"github.com/filecoin-project/go-state-types/cbor"
-	"github.com/ipfs/go-cid"
-	ipldcbor "github.com/ipfs/go-ipld-cbor"
-
-	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
-	paych0 "github.com/filecoin-project/specs-actors/actors/builtin/paych"
-	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
-
-	"github.com/filecoin-project/lotus/chain/actors/adt"
-	"github.com/filecoin-project/lotus/chain/actors/builtin"
-	"github.com/filecoin-project/lotus/chain/types"
-)
-
-func init() {
-	builtin.RegisterActorState(builtin0.PaymentChannelActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
-		return load0(store, root)
-	})
-	builtin.RegisterActorState(builtin2.PaymentChannelActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
-		return load2(store, root)
-	})
-}
-
-// Load returns an abstract copy of payment channel state, irregardless of actor version
-func Load(store adt.Store, act *types.Actor) (State, error) {
-	switch act.Code {
-	case builtin0.PaymentChannelActorCodeID:
-		return load0(store, act.Head)
-	case builtin2.PaymentChannelActorCodeID:
-		return load2(store, act.Head)
-	}
-	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
-}
-
-// State is an abstract version of payment channel state that works across
-// versions
-type State interface {
-	cbor.Marshaler
-	// Channel owner, who has funded the actor
-	From() (address.Address, error)
-	// Recipient of payouts from channel
-	To() (address.Address, error)
-
-	// Height at which the channel can be `Collected`
-	SettlingAt() (abi.ChainEpoch, error)
-
-	// Amount successfully redeemed through the payment channel, paid out on `Collect()`
-	ToSend() (abi.TokenAmount, error)
-
-	// Get total number of lanes
-	LaneCount() (uint64, error)
-
-	// Iterate lane states
-	ForEachLaneState(cb func(idx uint64, dl LaneState) error) error
-}
-
-// LaneState is an abstract copy of the state of a single lane
-type LaneState interface {
-	Redeemed() (big.Int, error)
-	Nonce() (uint64, error)
-}
-
-type SignedVoucher = paych0.SignedVoucher
-type ModVerifyParams = paych0.ModVerifyParams
-
-// DecodeSignedVoucher decodes base64 encoded signed voucher.
-func DecodeSignedVoucher(s string) (*SignedVoucher, error) {
-	data, err := base64.RawURLEncoding.DecodeString(s)
-	if err != nil {
-		return nil, err
-	}
-
-	var sv SignedVoucher
-	if err := ipldcbor.DecodeInto(data, &sv); err != nil {
-		return nil, err
-	}
-
-	return &sv, nil
-}

chain/actors/builtin/paych/state0.go

@@ -1,104 +0,0 @@
-package paych
-
-import (
-	"github.com/ipfs/go-cid"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/go-state-types/big"
-
-	"github.com/filecoin-project/lotus/chain/actors/adt"
-
-	paych0 "github.com/filecoin-project/specs-actors/actors/builtin/paych"
-	adt0 "github.com/filecoin-project/specs-actors/actors/util/adt"
-)
-
-var _ State = (*state0)(nil)
-
-func load0(store adt.Store, root cid.Cid) (State, error) {
-	out := state0{store: store}
-	err := store.Get(store.Context(), root, &out)
-	if err != nil {
-		return nil, err
-	}
-	return &out, nil
-}
-
-type state0 struct {
-	paych0.State
-	store adt.Store
-	lsAmt *adt0.Array
-}
-
-// Channel owner, who has funded the actor
-func (s *state0) From() (address.Address, error) {
-	return s.State.From, nil
-}
-
-// Recipient of payouts from channel
-func (s *state0) To() (address.Address, error) {
-	return s.State.To, nil
-}
-
-// Height at which the channel can be `Collected`
-func (s *state0) SettlingAt() (abi.ChainEpoch, error) {
-	return s.State.SettlingAt, nil
-}
-
-// Amount successfully redeemed through the payment channel, paid out on `Collect()`
-func (s *state0) ToSend() (abi.TokenAmount, error) {
-	return s.State.ToSend, nil
-}
-
-func (s *state0) getOrLoadLsAmt() (*adt0.Array, error) {
-	if s.lsAmt != nil {
-		return s.lsAmt, nil
-	}
-
-	// Get the lane state from the chain
-	lsamt, err := adt0.AsArray(s.store, s.State.LaneStates)
-	if err != nil {
-		return nil, err
-	}
-
-	s.lsAmt = lsamt
-	return lsamt, nil
-}
-
-// Get total number of lanes
-func (s *state0) LaneCount() (uint64, error) {
-	lsamt, err := s.getOrLoadLsAmt()
-	if err != nil {
-		return 0, err
-	}
-	return lsamt.Length(), nil
-}
-
-// Iterate lane states
-func (s *state0) ForEachLaneState(cb func(idx uint64, dl LaneState) error) error {
-	// Get the lane state from the chain
-	lsamt, err := s.getOrLoadLsAmt()
-	if err != nil {
-		return err
-	}
-
-	// Note: we use a map instead of an array to store laneStates because the
-	// client sets the lane ID (the index) and potentially they could use a
-	// very large index.
-	var ls paych0.LaneState
-	return lsamt.ForEach(&ls, func(i int64) error {
-		return cb(uint64(i), &laneState0{ls})
-	})
-}
-
-type laneState0 struct {
-	paych0.LaneState
-}
-
-func (ls *laneState0) Redeemed() (big.Int, error) {
-	return ls.LaneState.Redeemed, nil
-}
-
-func (ls *laneState0) Nonce() (uint64, error) {
-	return ls.LaneState.Nonce, nil
-}

chain/actors/builtin/paych/state2.go

@@ -1,104 +0,0 @@
-package paych
-
-import (
-	"github.com/ipfs/go-cid"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/go-state-types/big"
-
-	"github.com/filecoin-project/lotus/chain/actors/adt"
-
-	paych2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/paych"
-	adt2 "github.com/filecoin-project/specs-actors/v2/actors/util/adt"
-)
-
-var _ State = (*state2)(nil)
-
-func load2(store adt.Store, root cid.Cid) (State, error) {
-	out := state2{store: store}
-	err := store.Get(store.Context(), root, &out)
-	if err != nil {
-		return nil, err
-	}
-	return &out, nil
-}
-
-type state2 struct {
-	paych2.State
-	store adt.Store
-	lsAmt *adt2.Array
-}
-
-// Channel owner, who has funded the actor
-func (s *state2) From() (address.Address, error) {
-	return s.State.From, nil
-}
-
-// Recipient of payouts from channel
-func (s *state2) To() (address.Address, error) {
-	return s.State.To, nil
-}
-
-// Height at which the channel can be `Collected`
-func (s *state2) SettlingAt() (abi.ChainEpoch, error) {
-	return s.State.SettlingAt, nil
-}
-
-// Amount successfully redeemed through the payment channel, paid out on `Collect()`
-func (s *state2) ToSend() (abi.TokenAmount, error) {
-	return s.State.ToSend, nil
-}
-
-func (s *state2) getOrLoadLsAmt() (*adt2.Array, error) {
-	if s.lsAmt != nil {
-		return s.lsAmt, nil
-	}
-
-	// Get the lane state from the chain
-	lsamt, err := adt2.AsArray(s.store, s.State.LaneStates)
-	if err != nil {
-		return nil, err
-	}
-
-	s.lsAmt = lsamt
-	return lsamt, nil
-}
-
-// Get total number of lanes
-func (s *state2) LaneCount() (uint64, error) {
-	lsamt, err := s.getOrLoadLsAmt()
-	if err != nil {
-		return 0, err
-	}
-	return lsamt.Length(), nil
-}
-
-// Iterate lane states
-func (s *state2) ForEachLaneState(cb func(idx uint64, dl LaneState) error) error {
-	// Get the lane state from the chain
-	lsamt, err := s.getOrLoadLsAmt()
-	if err != nil {
-		return err
-	}
-
-	// Note: we use a map instead of an array to store laneStates because the
-	// client sets the lane ID (the index) and potentially they could use a
-	// very large index.
-	var ls paych2.LaneState
-	return lsamt.ForEach(&ls, func(i int64) error {
-		return cb(uint64(i), &laneState2{ls})
-	})
-}
-
-type laneState2 struct {
-	paych2.LaneState
-}
-
-func (ls *laneState2) Redeemed() (big.Int, error) {
-	return ls.LaneState.Redeemed, nil
-}
-
-func (ls *laneState2) Nonce() (uint64, error) {
-	return ls.LaneState.Nonce, nil
-}

chain/actors/builtin/power/power.go

@@ -1,62 +0,0 @@
-package power
-
-import (
-	"github.com/filecoin-project/go-address"
-	"github.com/ipfs/go-cid"
-	"golang.org/x/xerrors"
-
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/go-state-types/cbor"
-
-	"github.com/filecoin-project/lotus/chain/actors/adt"
-	"github.com/filecoin-project/lotus/chain/actors/builtin"
-	"github.com/filecoin-project/lotus/chain/types"
-
-	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
-	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
-)
-
-func init() {
-	builtin.RegisterActorState(builtin0.StoragePowerActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
-		return load0(store, root)
-	})
-	builtin.RegisterActorState(builtin2.StoragePowerActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
-		return load2(store, root)
-	})
-}
-
-var Address = builtin0.StoragePowerActorAddr
-
-func Load(store adt.Store, act *types.Actor) (st State, err error) {
-	switch act.Code {
-	case builtin0.StoragePowerActorCodeID:
-		return load0(store, act.Head)
-	case builtin2.StoragePowerActorCodeID:
-		return load2(store, act.Head)
-	}
-	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
-}
-
-type State interface {
-	cbor.Marshaler
-
-	TotalLocked() (abi.TokenAmount, error)
-	TotalPower() (Claim, error)
-	TotalCommitted() (Claim, error)
-	TotalPowerSmoothed() (builtin.FilterEstimate, error)
-
-	// MinerCounts returns the number of miners. Participating is the number
-	// with power above the minimum miner threshold.
-	MinerCounts() (participating, total uint64, err error)
-	MinerPower(address.Address) (Claim, bool, error)
-	MinerNominalPowerMeetsConsensusMinimum(address.Address) (bool, error)
-	ListAllMiners() ([]address.Address, error)
-}
-
-type Claim struct {
-	// Sum of raw byte power for a miner's sectors.
-	RawBytePower abi.StoragePower
-
-	// Sum of quality adjusted power for a miner's sectors.
-	QualityAdjPower abi.StoragePower
-}

chain/actors/builtin/power/v0.go

@@ -1,98 +0,0 @@
-package power
-
-import (
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/ipfs/go-cid"
-
-	"github.com/filecoin-project/lotus/chain/actors/adt"
-	"github.com/filecoin-project/lotus/chain/actors/builtin"
-
-	power0 "github.com/filecoin-project/specs-actors/actors/builtin/power"
-	adt0 "github.com/filecoin-project/specs-actors/actors/util/adt"
-)
-
-var _ State = (*state0)(nil)
-
-func load0(store adt.Store, root cid.Cid) (State, error) {
-	out := state0{store: store}
-	err := store.Get(store.Context(), root, &out)
-	if err != nil {
-		return nil, err
-	}
-	return &out, nil
-}
-
-type state0 struct {
-	power0.State
-	store adt.Store
-}
-
-func (s *state0) TotalLocked() (abi.TokenAmount, error) {
-	return s.TotalPledgeCollateral, nil
-}
-
-func (s *state0) TotalPower() (Claim, error) {
-	return Claim{
-		RawBytePower:    s.TotalRawBytePower,
-		QualityAdjPower: s.TotalQualityAdjPower,
-	}, nil
-}
-
-// Committed power to the network. Includes miners below the minimum threshold.
-func (s *state0) TotalCommitted() (Claim, error) {
-	return Claim{
-		RawBytePower:    s.TotalBytesCommitted,
-		QualityAdjPower: s.TotalQABytesCommitted,
-	}, nil
-}
-
-func (s *state0) MinerPower(addr address.Address) (Claim, bool, error) {
-	claims, err := adt0.AsMap(s.store, s.Claims)
-	if err != nil {
-		return Claim{}, false, err
-	}
-	var claim power0.Claim
-	ok, err := claims.Get(abi.AddrKey(addr), &claim)
-	if err != nil {
-		return Claim{}, false, err
-	}
-	return Claim{
-		RawBytePower:    claim.RawBytePower,
-		QualityAdjPower: claim.QualityAdjPower,
-	}, ok, nil
-}
-
-func (s *state0) MinerNominalPowerMeetsConsensusMinimum(a address.Address) (bool, error) {
-	return s.State.MinerNominalPowerMeetsConsensusMinimum(s.store, a)
-}
-
-func (s *state0) TotalPowerSmoothed() (builtin.FilterEstimate, error) {
-	return builtin.FromV0FilterEstimate(*s.State.ThisEpochQAPowerSmoothed), nil
-}
-
-func (s *state0) MinerCounts() (uint64, uint64, error) {
-	return uint64(s.State.MinerAboveMinPowerCount), uint64(s.State.MinerCount), nil
-}
-
-func (s *state0) ListAllMiners() ([]address.Address, error) {
-	claims, err := adt0.AsMap(s.store, s.Claims)
-	if err != nil {
-		return nil, err
-	}
-
-	var miners []address.Address
-	err = claims.ForEach(nil, func(k string) error {
-		a, err := address.NewFromBytes([]byte(k))
-		if err != nil {
-			return err
-		}
-		miners = append(miners, a)
-		return nil
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	return miners, nil
-}

chain/actors/builtin/power/v2.go

@@ -1,98 +0,0 @@
-package power
-
-import (
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/ipfs/go-cid"
-
-	"github.com/filecoin-project/lotus/chain/actors/adt"
-	"github.com/filecoin-project/lotus/chain/actors/builtin"
-
-	power2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/power"
-	adt2 "github.com/filecoin-project/specs-actors/v2/actors/util/adt"
-)
-
-var _ State = (*state2)(nil)
-
-func load2(store adt.Store, root cid.Cid) (State, error) {
-	out := state2{store: store}
-	err := store.Get(store.Context(), root, &out)
-	if err != nil {
-		return nil, err
-	}
-	return &out, nil
-}
-
-type state2 struct {
-	power2.State
-	store adt.Store
-}
-
-func (s *state2) TotalLocked() (abi.TokenAmount, error) {
-	return s.TotalPledgeCollateral, nil
-}
-
-func (s *state2) TotalPower() (Claim, error) {
-	return Claim{
-		RawBytePower:    s.TotalRawBytePower,
-		QualityAdjPower: s.TotalQualityAdjPower,
-	}, nil
-}
-
-// Committed power to the network. Includes miners below the minimum threshold.
-func (s *state2) TotalCommitted() (Claim, error) {
-	return Claim{
-		RawBytePower:    s.TotalBytesCommitted,
-		QualityAdjPower: s.TotalQABytesCommitted,
-	}, nil
-}
-
-func (s *state2) MinerPower(addr address.Address) (Claim, bool, error) {
-	claims, err := adt2.AsMap(s.store, s.Claims)
-	if err != nil {
-		return Claim{}, false, err
-	}
-	var claim power2.Claim
-	ok, err := claims.Get(abi.AddrKey(addr), &claim)
-	if err != nil {
-		return Claim{}, false, err
-	}
-	return Claim{
-		RawBytePower:    claim.RawBytePower,
-		QualityAdjPower: claim.QualityAdjPower,
-	}, ok, nil
-}
-
-func (s *state2) MinerNominalPowerMeetsConsensusMinimum(a address.Address) (bool, error) {
-	return s.State.MinerNominalPowerMeetsConsensusMinimum(s.store, a)
-}
-
-func (s *state2) TotalPowerSmoothed() (builtin.FilterEstimate, error) {
-	return builtin.FromV2FilterEstimate(s.State.ThisEpochQAPowerSmoothed), nil
-}
-
-func (s *state2) MinerCounts() (uint64, uint64, error) {
-	return uint64(s.State.MinerAboveMinPowerCount), uint64(s.State.MinerCount), nil
-}
-
-func (s *state2) ListAllMiners() ([]address.Address, error) {
-	claims, err := adt2.AsMap(s.store, s.Claims)
-	if err != nil {
-		return nil, err
-	}
-
-	var miners []address.Address
-	err = claims.ForEach(nil, func(k string) error {
-		a, err := address.NewFromBytes([]byte(k))
-		if err != nil {
-			return err
-		}
-		miners = append(miners, a)
-		return nil
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	return miners, nil
-}

chain/actors/builtin/reward/reward.go

@@ -1,58 +0,0 @@
-package reward
-
-import (
-	"github.com/filecoin-project/go-state-types/abi"
-	reward0 "github.com/filecoin-project/specs-actors/actors/builtin/reward"
-	"github.com/ipfs/go-cid"
-	"golang.org/x/xerrors"
-
-	"github.com/filecoin-project/go-state-types/cbor"
-	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
-	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
-
-	"github.com/filecoin-project/lotus/chain/actors/adt"
-	"github.com/filecoin-project/lotus/chain/actors/builtin"
-	"github.com/filecoin-project/lotus/chain/types"
-)
-
-func init() {
-	builtin.RegisterActorState(builtin0.RewardActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
-		return load0(store, root)
-	})
-	builtin.RegisterActorState(builtin2.RewardActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
-		return load2(store, root)
-	})
-}
-
-var Address = builtin0.RewardActorAddr
-
-func Load(store adt.Store, act *types.Actor) (st State, err error) {
-	switch act.Code {
-	case builtin0.RewardActorCodeID:
-		return load0(store, act.Head)
-	case builtin2.RewardActorCodeID:
-		return load2(store, act.Head)
-	}
-	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
-}
-
-type State interface {
-	cbor.Marshaler
-
-	ThisEpochBaselinePower() (abi.StoragePower, error)
-	ThisEpochReward() (abi.StoragePower, error)
-	ThisEpochRewardSmoothed() (builtin.FilterEstimate, error)
-
-	EffectiveBaselinePower() (abi.StoragePower, error)
-	EffectiveNetworkTime() (abi.ChainEpoch, error)
-
-	TotalStoragePowerReward() (abi.TokenAmount, error)
-
-	CumsumBaseline() (abi.StoragePower, error)
-	CumsumRealized() (abi.StoragePower, error)
-
-	InitialPledgeForPower(abi.StoragePower, abi.TokenAmount, *builtin.FilterEstimate, abi.TokenAmount) (abi.TokenAmount, error)
-	PreCommitDepositForPower(builtin.FilterEstimate, abi.StoragePower) (abi.TokenAmount, error)
-}
-
-type AwardBlockRewardParams = reward0.AwardBlockRewardParams

chain/actors/builtin/reward/v0.go

@@ -1,83 +0,0 @@
-package reward
-
-import (
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/ipfs/go-cid"
-
-	"github.com/filecoin-project/lotus/chain/actors/adt"
-	"github.com/filecoin-project/lotus/chain/actors/builtin"
-
-	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
-	reward0 "github.com/filecoin-project/specs-actors/actors/builtin/reward"
-	smoothing0 "github.com/filecoin-project/specs-actors/actors/util/smoothing"
-)
-
-var _ State = (*state0)(nil)
-
-func load0(store adt.Store, root cid.Cid) (State, error) {
-	out := state0{store: store}
-	err := store.Get(store.Context(), root, &out)
-	if err != nil {
-		return nil, err
-	}
-	return &out, nil
-}
-
-type state0 struct {
-	reward0.State
-	store adt.Store
-}
-
-func (s *state0) ThisEpochReward() (abi.StoragePower, error) {
-	return s.State.ThisEpochReward, nil
-}
-
-func (s *state0) ThisEpochRewardSmoothed() (builtin.FilterEstimate, error) {
-	return builtin.FromV0FilterEstimate(*s.State.ThisEpochRewardSmoothed), nil
-}
-
-func (s *state0) ThisEpochBaselinePower() (abi.StoragePower, error) {
-	return s.State.ThisEpochBaselinePower, nil
-}
-
-func (s *state0) TotalStoragePowerReward() (abi.TokenAmount, error) {
-	return s.State.TotalMined, nil
-}
-
-func (s *state0) EffectiveBaselinePower() (abi.StoragePower, error) {
-	return s.State.EffectiveBaselinePower, nil
-}
-
-func (s *state0) EffectiveNetworkTime() (abi.ChainEpoch, error) {
-	return s.State.EffectiveNetworkTime, nil
-}
-
-func (s *state0) CumsumBaseline() (abi.StoragePower, error) {
-	return s.State.CumsumBaseline, nil
-}
-
-func (s *state0) CumsumRealized() (abi.StoragePower, error) {
-	return s.State.CumsumBaseline, nil
-}
-
-func (s *state0) InitialPledgeForPower(sectorWeight abi.StoragePower, networkTotalPledge abi.TokenAmount, networkQAPower *builtin.FilterEstimate, circSupply abi.TokenAmount) (abi.TokenAmount, error) {
-	return miner0.InitialPledgeForPower(
-		sectorWeight,
-		s.State.ThisEpochBaselinePower,
-		networkTotalPledge,
-		s.State.ThisEpochRewardSmoothed,
-		&smoothing0.FilterEstimate{
-			PositionEstimate: networkQAPower.PositionEstimate,
-			VelocityEstimate: networkQAPower.VelocityEstimate,
-		},
-		circSupply), nil
-}
-
-func (s *state0) PreCommitDepositForPower(networkQAPower builtin.FilterEstimate, sectorWeight abi.StoragePower) (abi.TokenAmount, error) {
-	return miner0.PreCommitDepositForPower(s.State.ThisEpochRewardSmoothed,
-		&smoothing0.FilterEstimate{
-			PositionEstimate: networkQAPower.PositionEstimate,
-			VelocityEstimate: networkQAPower.VelocityEstimate,
-		},
-		sectorWeight), nil
-}

chain/actors/builtin/reward/v2.go

@@ -1,86 +0,0 @@
-package reward
-
-import (
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/ipfs/go-cid"
-
-	"github.com/filecoin-project/lotus/chain/actors/adt"
-	"github.com/filecoin-project/lotus/chain/actors/builtin"
-
-	miner2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/miner"
-	reward2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/reward"
-	smoothing2 "github.com/filecoin-project/specs-actors/v2/actors/util/smoothing"
-)
-
-var _ State = (*state2)(nil)
-
-func load2(store adt.Store, root cid.Cid) (State, error) {
-	out := state2{store: store}
-	err := store.Get(store.Context(), root, &out)
-	if err != nil {
-		return nil, err
-	}
-	return &out, nil
-}
-
-type state2 struct {
-	reward2.State
-	store adt.Store
-}
-
-func (s *state2) ThisEpochReward() (abi.StoragePower, error) {
-	return s.State.ThisEpochReward, nil
-}
-
-func (s *state2) ThisEpochRewardSmoothed() (builtin.FilterEstimate, error) {
-	return builtin.FilterEstimate{
-		PositionEstimate: s.State.ThisEpochRewardSmoothed.PositionEstimate,
-		VelocityEstimate: s.State.ThisEpochRewardSmoothed.VelocityEstimate,
-	}, nil
-}
-
-func (s *state2) ThisEpochBaselinePower() (abi.StoragePower, error) {
-	return s.State.ThisEpochBaselinePower, nil
-}
-
-func (s *state2) TotalStoragePowerReward() (abi.TokenAmount, error) {
-	return s.State.TotalStoragePowerReward, nil
-}
-
-func (s *state2) EffectiveBaselinePower() (abi.StoragePower, error) {
-	return s.State.EffectiveBaselinePower, nil
-}
-
-func (s *state2) EffectiveNetworkTime() (abi.ChainEpoch, error) {
-	return s.State.EffectiveNetworkTime, nil
-}
-
-func (s *state2) CumsumBaseline() (abi.StoragePower, error) {
-	return s.State.CumsumBaseline, nil
-}
-
-func (s *state2) CumsumRealized() (abi.StoragePower, error) {
-	return s.State.CumsumBaseline, nil
-}
-
-func (s *state2) InitialPledgeForPower(qaPower abi.StoragePower, networkTotalPledge abi.TokenAmount, networkQAPower *builtin.FilterEstimate, circSupply abi.TokenAmount) (abi.TokenAmount, error) {
-	return miner2.InitialPledgeForPower(
-		qaPower,
-		s.State.ThisEpochBaselinePower,
-		s.State.ThisEpochRewardSmoothed,
-		smoothing2.FilterEstimate{
-			PositionEstimate: networkQAPower.PositionEstimate,
-			VelocityEstimate: networkQAPower.VelocityEstimate,
-		},
-		circSupply,
-	), nil
-}
-
-func (s *state2) PreCommitDepositForPower(networkQAPower builtin.FilterEstimate, sectorWeight abi.StoragePower) (abi.TokenAmount, error) {
-	return miner2.PreCommitDepositForPower(s.State.ThisEpochRewardSmoothed,
-		smoothing2.FilterEstimate{
-			PositionEstimate: networkQAPower.PositionEstimate,
-			VelocityEstimate: networkQAPower.VelocityEstimate,
-		},
-		sectorWeight), nil
-}

chain/actors/builtin/verifreg/util.go

@@ -1,46 +0,0 @@
-package verifreg
-
-import (
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/go-state-types/big"
-	"github.com/filecoin-project/lotus/chain/actors"
-	"github.com/filecoin-project/lotus/chain/actors/adt"
-	"github.com/ipfs/go-cid"
-	"golang.org/x/xerrors"
-)
-
-func getDataCap(store adt.Store, ver actors.Version, root cid.Cid, addr address.Address) (bool, abi.StoragePower, error) {
-	if addr.Protocol() != address.ID {
-		return false, big.Zero(), xerrors.Errorf("can only look up ID addresses")
-	}
-
-	vh, err := adt.AsMap(store, root, ver)
-	if err != nil {
-		return false, big.Zero(), xerrors.Errorf("loading verifreg: %w", err)
-	}
-
-	var dcap abi.StoragePower
-	if found, err := vh.Get(abi.AddrKey(addr), &dcap); err != nil {
-		return false, big.Zero(), xerrors.Errorf("looking up addr: %w", err)
-	} else if !found {
-		return false, big.Zero(), nil
-	}
-
-	return true, dcap, nil
-}
-
-func forEachCap(store adt.Store, ver actors.Version, root cid.Cid, cb func(addr address.Address, dcap abi.StoragePower) error) error {
-	vh, err := adt.AsMap(store, root, ver)
-	if err != nil {
-		return xerrors.Errorf("loading verified clients: %w", err)
-	}
-	var dcap abi.StoragePower
-	return vh.ForEach(&dcap, func(key string) error {
-		a, err := address.NewFromBytes([]byte(key))
-		if err != nil {
-			return err
-		}
-		return cb(a, dcap)
-	})
-}

chain/actors/builtin/verifreg/v0.go

@@ -1,44 +0,0 @@
-package verifreg
-
-import (
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/ipfs/go-cid"
-
-	"github.com/filecoin-project/lotus/chain/actors"
-	"github.com/filecoin-project/lotus/chain/actors/adt"
-
-	verifreg0 "github.com/filecoin-project/specs-actors/actors/builtin/verifreg"
-)
-
-var _ State = (*state0)(nil)
-
-func load0(store adt.Store, root cid.Cid) (State, error) {
-	out := state0{store: store}
-	err := store.Get(store.Context(), root, &out)
-	if err != nil {
-		return nil, err
-	}
-	return &out, nil
-}
-
-type state0 struct {
-	verifreg0.State
-	store adt.Store
-}
-
-func (s *state0) VerifiedClientDataCap(addr address.Address) (bool, abi.StoragePower, error) {
-	return getDataCap(s.store, actors.Version0, s.State.VerifiedClients, addr)
-}
-
-func (s *state0) VerifierDataCap(addr address.Address) (bool, abi.StoragePower, error) {
-	return getDataCap(s.store, actors.Version0, s.State.Verifiers, addr)
-}
-
-func (s *state0) ForEachVerifier(cb func(addr address.Address, dcap abi.StoragePower) error) error {
-	return forEachCap(s.store, actors.Version0, s.State.Verifiers, cb)
-}
-
-func (s *state0) ForEachClient(cb func(addr address.Address, dcap abi.StoragePower) error) error {
-	return forEachCap(s.store, actors.Version0, s.State.VerifiedClients, cb)
-}

chain/actors/builtin/verifreg/v2.go

@@ -1,44 +0,0 @@
-package verifreg
-
-import (
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/ipfs/go-cid"
-
-	"github.com/filecoin-project/lotus/chain/actors"
-	"github.com/filecoin-project/lotus/chain/actors/adt"
-
-	verifreg2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/verifreg"
-)
-
-var _ State = (*state2)(nil)
-
-func load2(store adt.Store, root cid.Cid) (State, error) {
-	out := state2{store: store}
-	err := store.Get(store.Context(), root, &out)
-	if err != nil {
-		return nil, err
-	}
-	return &out, nil
-}
-
-type state2 struct {
-	verifreg2.State
-	store adt.Store
-}
-
-func (s *state2) VerifiedClientDataCap(addr address.Address) (bool, abi.StoragePower, error) {
-	return getDataCap(s.store, actors.Version2, s.State.VerifiedClients, addr)
-}
-
-func (s *state2) VerifierDataCap(addr address.Address) (bool, abi.StoragePower, error) {
-	return getDataCap(s.store, actors.Version2, s.State.Verifiers, addr)
-}
-
-func (s *state2) ForEachVerifier(cb func(addr address.Address, dcap abi.StoragePower) error) error {
-	return forEachCap(s.store, actors.Version2, s.State.Verifiers, cb)
-}
-
-func (s *state2) ForEachClient(cb func(addr address.Address, dcap abi.StoragePower) error) error {
-	return forEachCap(s.store, actors.Version2, s.State.VerifiedClients, cb)
-}

chain/actors/builtin/verifreg/verifreg.go

@@ -1,46 +0,0 @@
-package verifreg
-
-import (
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/ipfs/go-cid"
-	"golang.org/x/xerrors"
-
-	"github.com/filecoin-project/go-state-types/cbor"
-	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
-	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
-
-	"github.com/filecoin-project/lotus/chain/actors/adt"
-	"github.com/filecoin-project/lotus/chain/actors/builtin"
-	"github.com/filecoin-project/lotus/chain/types"
-)
-
-func init() {
-	builtin.RegisterActorState(builtin0.VerifiedRegistryActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
-		return load0(store, root)
-	})
-	builtin.RegisterActorState(builtin2.VerifiedRegistryActorCodeID, func(store adt.Store, root cid.Cid) (cbor.Marshaler, error) {
-		return load2(store, root)
-	})
-}
-
-var Address = builtin0.VerifiedRegistryActorAddr
-
-func Load(store adt.Store, act *types.Actor) (State, error) {
-	switch act.Code {
-	case builtin0.VerifiedRegistryActorCodeID:
-		return load0(store, act.Head)
-	case builtin2.VerifiedRegistryActorCodeID:
-		return load2(store, act.Head)
-	}
-	return nil, xerrors.Errorf("unknown actor code %s", act.Code)
-}
-
-type State interface {
-	cbor.Marshaler
-
-	VerifiedClientDataCap(address.Address) (bool, abi.StoragePower, error)
-	VerifierDataCap(address.Address) (bool, abi.StoragePower, error)
-	ForEachVerifier(func(addr address.Address, dcap abi.StoragePower) error) error
-	ForEachClient(func(addr address.Address, dcap abi.StoragePower) error) error
-}

chain/actors/policy/policy.go

@@ -1,99 +0,0 @@
-package policy
-
-import (
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/go-state-types/network"
-	"github.com/filecoin-project/lotus/chain/actors"
-
-	market0 "github.com/filecoin-project/specs-actors/actors/builtin/market"
-	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
-	power0 "github.com/filecoin-project/specs-actors/actors/builtin/power"
-	verifreg0 "github.com/filecoin-project/specs-actors/actors/builtin/verifreg"
-	builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin"
-	market2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/market"
-	miner2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/miner"
-	verifreg2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/verifreg"
-)
-
-const (
-	ChainFinality          = miner0.ChainFinality
-	SealRandomnessLookback = ChainFinality
-)
-
-// SetSupportedProofTypes sets supported proof types, across all actor versions.
-// This should only be used for testing.
-func SetSupportedProofTypes(types ...abi.RegisteredSealProof) {
-	newTypes := make(map[abi.RegisteredSealProof]struct{}, len(types))
-	for _, t := range types {
-		newTypes[t] = struct{}{}
-	}
-	// Set for all miner versions.
-	miner0.SupportedProofTypes = newTypes
-	miner2.SupportedProofTypes = newTypes
-}
-
-// AddSupportedProofTypes sets supported proof types, across all actor versions.
-// This should only be used for testing.
-func AddSupportedProofTypes(types ...abi.RegisteredSealProof) {
-	for _, t := range types {
-		// Set for all miner versions.
-		miner0.SupportedProofTypes[t] = struct{}{}
-		miner2.SupportedProofTypes[t] = struct{}{}
-	}
-}
-
-// SetPreCommitChallengeDelay sets the pre-commit challenge delay across all
-// actors versions. Use for testing.
-func SetPreCommitChallengeDelay(delay abi.ChainEpoch) {
-	// Set for all miner versions.
-	miner0.PreCommitChallengeDelay = delay
-	miner2.PreCommitChallengeDelay = delay
-}
-
-// TODO: this function shouldn't really exist. Instead, the API should expose the precommit delay.
-func GetPreCommitChallengeDelay() abi.ChainEpoch {
-	return miner0.PreCommitChallengeDelay
-}
-
-// SetConsensusMinerMinPower sets the minimum power of an individual miner must
-// meet for leader election, across all actor versions. This should only be used
-// for testing.
-func SetConsensusMinerMinPower(p abi.StoragePower) {
-	power0.ConsensusMinerMinPower = p
-	for _, policy := range builtin2.SealProofPolicies {
-		policy.ConsensusMinerMinPower = p
-	}
-}
-
-// SetMinVerifiedDealSize sets the minimum size of a verified deal. This should
-// only be used for testing.
-func SetMinVerifiedDealSize(size abi.StoragePower) {
-	verifreg0.MinVerifiedDealSize = size
-	verifreg2.MinVerifiedDealSize = size
-}
-
-func GetMaxProveCommitDuration(ver actors.Version, t abi.RegisteredSealProof) abi.ChainEpoch {
-	switch ver {
-	case actors.Version0:
-		return miner0.MaxSealDuration[t]
-	case actors.Version2:
-		return miner2.MaxProveCommitDuration[t]
-	default:
-		panic("unsupported actors version")
-	}
-}
-
-func DealProviderCollateralBounds(
-	size abi.PaddedPieceSize, verified bool,
-	rawBytePower, qaPower, baselinePower abi.StoragePower,
-	circulatingFil abi.TokenAmount, nwVer network.Version,
-) (min, max abi.TokenAmount) {
-	switch actors.VersionForNetwork(nwVer) {
-	case actors.Version0:
-		return market0.DealProviderCollateralBounds(size, verified, rawBytePower, qaPower, baselinePower, circulatingFil, nwVer)
-	case actors.Version2:
-		return market2.DealProviderCollateralBounds(size, verified, rawBytePower, qaPower, baselinePower, circulatingFil)
-	default:
-		panic("unsupported network version")
-	}
-}

chain/actors/policy/policy_test.go

@@ -1,47 +0,0 @@
-package policy
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/require"
-
-	"github.com/filecoin-project/go-state-types/abi"
-	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
-	verifreg0 "github.com/filecoin-project/specs-actors/actors/builtin/verifreg"
-	miner2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/miner"
-	verifreg2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/verifreg"
-)
-
-func TestSupportedProofTypes(t *testing.T) {
-	var oldTypes []abi.RegisteredSealProof
-	for t := range miner0.SupportedProofTypes {
-		oldTypes = append(oldTypes, t)
-	}
-	t.Cleanup(func() {
-		SetSupportedProofTypes(oldTypes...)
-	})
-
-	SetSupportedProofTypes(abi.RegisteredSealProof_StackedDrg2KiBV1)
-	require.EqualValues(t,
-		miner0.SupportedProofTypes,
-		map[abi.RegisteredSealProof]struct{}{
-			abi.RegisteredSealProof_StackedDrg2KiBV1: {},
-		},
-	)
-	AddSupportedProofTypes(abi.RegisteredSealProof_StackedDrg8MiBV1)
-	require.EqualValues(t,
-		miner0.SupportedProofTypes,
-		map[abi.RegisteredSealProof]struct{}{
-			abi.RegisteredSealProof_StackedDrg2KiBV1: {},
-			abi.RegisteredSealProof_StackedDrg8MiBV1: {},
-		},
-	)
-}
-
-// Tests assumptions about policies being the same between actor versions.
-func TestAssumptions(t *testing.T) {
-	require.EqualValues(t, miner0.SupportedProofTypes, miner2.SupportedProofTypes)
-	require.Equal(t, miner0.PreCommitChallengeDelay, miner2.PreCommitChallengeDelay)
-	require.Equal(t, miner0.ChainFinality, miner2.ChainFinality)
-	require.True(t, verifreg0.MinVerifiedDealSize.Equals(verifreg2.MinVerifiedDealSize))
-}

chain/actors/version.go

@@ -1,26 +0,0 @@
-package actors
-
-import (
-	"fmt"
-
-	"github.com/filecoin-project/go-state-types/network"
-)
-
-type Version int
-
-const (
-	Version0 = 0
-	Version2 = 2
-)
-
-// Converts a network version into an actors adt version.
-func VersionForNetwork(version network.Version) Version {
-	switch version {
-	case network.Version0, network.Version1, network.Version2, network.Version3:
-		return Version0
-	case network.Version4:
-		return Version2
-	default:
-		panic(fmt.Sprintf("unsupported network version %d", version))
-	}
-}

chain/badtscache.go

@@ -56,10 +56,6 @@ func (bts *BadBlockCache) Add(c cid.Cid, bbr BadBlockReason) {
 	bts.badBlocks.Add(c, bbr)
 }
 
-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 {

chain/beacon/beacon.go

@@ -3,7 +3,7 @@ package beacon
 import (
 	"context"
 
-	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/specs-actors/actors/abi"
 	logging "github.com/ipfs/go-log"
 	"golang.org/x/xerrors"
 
@@ -18,23 +18,6 @@ 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
@@ -42,30 +25,11 @@ type BeaconPoint struct {
 type RandomBeacon interface {
 	Entry(context.Context, uint64) <-chan Response
 	VerifyEntry(types.BeaconEntry, types.BeaconEntry) error
-	MaxBeaconRoundForEpoch(abi.ChainEpoch) uint64
+	MaxBeaconRoundForEpoch(abi.ChainEpoch, types.BeaconEntry) uint64
 }
 
-func ValidateBlockValues(bSchedule Schedule, h *types.BlockHeader, parentEpoch abi.ChainEpoch,
-	prevEntry types.BeaconEntry) error {
-	{
-		parentBeacon := bSchedule.BeaconForEpoch(parentEpoch)
-		currBeacon := bSchedule.BeaconForEpoch(h.Height)
-		if parentBeacon != currBeacon {
-			if len(h.BeaconEntries) != 2 {
-				return xerrors.Errorf("expected two beacon entries at beacon fork, got %d", len(h.BeaconEntries))
-			}
-			err := currBeacon.VerifyEntry(h.BeaconEntries[1], h.BeaconEntries[0])
-			if err != nil {
-				return xerrors.Errorf("beacon at fork point invalid: (%v, %v): %w",
-					h.BeaconEntries[1], h.BeaconEntries[0], err)
-			}
-			return nil
-		}
-	}
-
-	// TODO: fork logic
-	b := bSchedule.BeaconForEpoch(h.Height)
-	maxRound := b.MaxBeaconRoundForEpoch(h.Height)
+func ValidateBlockValues(b RandomBeacon, h *types.BlockHeader, prevEntry types.BeaconEntry) error {
+	maxRound := b.MaxBeaconRoundForEpoch(h.Height, prevEntry)
 	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))
@@ -73,10 +37,6 @@ func ValidateBlockValues(bSchedule Schedule, h *types.BlockHeader, parentEpoch a
 		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)
@@ -92,35 +52,10 @@ func ValidateBlockValues(bSchedule Schedule, h *types.BlockHeader, parentEpoch a
 	return nil
 }
 
-func BeaconEntriesForBlock(ctx context.Context, bSchedule Schedule, epoch abi.ChainEpoch, parentEpoch abi.ChainEpoch, prev types.BeaconEntry) ([]types.BeaconEntry, error) {
-	{
-		parentBeacon := bSchedule.BeaconForEpoch(parentEpoch)
-		currBeacon := bSchedule.BeaconForEpoch(epoch)
-		if parentBeacon != currBeacon {
-			// Fork logic
-			round := currBeacon.MaxBeaconRoundForEpoch(epoch)
-			out := make([]types.BeaconEntry, 2)
-			rch := currBeacon.Entry(ctx, round-1)
-			res := <-rch
-			if res.Err != nil {
-				return nil, xerrors.Errorf("getting entry %d returned error: %w", round-1, res.Err)
-			}
-			out[0] = res.Entry
-			rch = currBeacon.Entry(ctx, round)
-			res = <-rch
-			if res.Err != nil {
-				return nil, xerrors.Errorf("getting entry %d returned error: %w", round, res.Err)
-			}
-			out[1] = res.Entry
-			return out, nil
-		}
-	}
-
-	beacon := bSchedule.BeaconForEpoch(epoch)
-
+func BeaconEntriesForBlock(ctx context.Context, beacon RandomBeacon, round abi.ChainEpoch, prev types.BeaconEntry) ([]types.BeaconEntry, error) {
 	start := build.Clock.Now()
 
-	maxRound := beacon.MaxBeaconRoundForEpoch(epoch)
+	maxRound := beacon.MaxBeaconRoundForEpoch(round, prev)
 	if maxRound == prev.Round {
 		return nil, nil
 	}
@@ -143,7 +78,7 @@ func BeaconEntriesForBlock(ctx context.Context, bSchedule Schedule, epoch abi.Ch
 			out = append(out, resp.Entry)
 			cur = resp.Entry.Round - 1
 		case <-ctx.Done():
-			return nil, xerrors.Errorf("context timed out waiting on beacon entry to come back for epoch %d: %w", epoch, ctx.Err())
+			return nil, xerrors.Errorf("context timed out waiting on beacon entry to come back for round %d: %w", round, ctx.Err())
 		}
 	}
 

chain/beacon/drand/drand.go

@@ -19,7 +19,7 @@ import (
 	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/specs-actors/actors/abi"
 
 	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain/beacon"
@@ -187,7 +187,7 @@ func (db *DrandBeacon) VerifyEntry(curr types.BeaconEntry, prev types.BeaconEntr
 	return err
 }
 
-func (db *DrandBeacon) MaxBeaconRoundForEpoch(filEpoch abi.ChainEpoch) uint64 {
+func (db *DrandBeacon) MaxBeaconRoundForEpoch(filEpoch abi.ChainEpoch, prevEntry types.BeaconEntry) 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())

chain/beacon/drand/drand_test.go

@@ -12,7 +12,7 @@ import (
 )
 
 func TestPrintGroupInfo(t *testing.T) {
-	server := build.DrandConfigs[build.DrandIncentinet].Servers[0]
+	server := build.DrandConfig().Servers[0]
 	c, err := hclient.New(server, nil, nil)
 	assert.NoError(t, err)
 	cg := c.(interface {

chain/beacon/mock.go

@@ -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,7 +53,11 @@ func (mb *mockBeacon) VerifyEntry(from types.BeaconEntry, to types.BeaconEntry)
 	return nil
 }
 
-func (mb *mockBeacon) MaxBeaconRoundForEpoch(epoch abi.ChainEpoch) uint64 {
+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 {
 	return uint64(epoch)
 }
 

chain/block_receipt_tracker.go

@@ -7,8 +7,8 @@ import (
 
 	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain/types"
-	lru "github.com/hashicorp/golang-lru"
-	"github.com/libp2p/go-libp2p-core/peer"
+	"github.com/hashicorp/golang-lru"
+	peer "github.com/libp2p/go-libp2p-core/peer"
 )
 
 type blockReceiptTracker struct {

chain/blocksync/cbor_gen.go

@@ -1,13 +1,13 @@
 // Code generated by github.com/whyrusleeping/cbor-gen. DO NOT EDIT.
 
-package exchange
+package blocksync
 
 import (
 	"fmt"
 	"io"
 
-	types "github.com/filecoin-project/lotus/chain/types"
-	cid "github.com/ipfs/go-cid"
+	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/ipfs/go-cid"
 	cbg "github.com/whyrusleeping/cbor-gen"
 	xerrors "golang.org/x/xerrors"
 )
@@ -146,7 +146,7 @@ func (t *Response) MarshalCBOR(w io.Writer) error {
 
 	scratch := make([]byte, 9)
 
-	// t.Status (exchange.status) (uint64)
+	// t.Status (blocksync.status) (uint64)
 
 	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.Status)); err != nil {
 		return err
@@ -164,7 +164,7 @@ func (t *Response) MarshalCBOR(w io.Writer) error {
 		return err
 	}
 
-	// t.Chain ([]*exchange.BSTipSet) (slice)
+	// t.Chain ([]*blocksync.BSTipSet) (slice)
 	if len(t.Chain) > cbg.MaxLength {
 		return xerrors.Errorf("Slice value in field t.Chain was too long")
 	}
@@ -198,7 +198,7 @@ func (t *Response) UnmarshalCBOR(r io.Reader) error {
 		return fmt.Errorf("cbor input had wrong number of fields")
 	}
 
-	// t.Status (exchange.status) (uint64)
+	// t.Status (blocksync.status) (uint64)
 
 	{
 
@@ -222,7 +222,7 @@ func (t *Response) UnmarshalCBOR(r io.Reader) error {
 
 		t.ErrorMessage = string(sval)
 	}
-	// t.Chain ([]*exchange.BSTipSet) (slice)
+	// t.Chain ([]*blocksync.BSTipSet) (slice)
 
 	maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
 	if err != nil {
@@ -567,7 +567,7 @@ func (t *BSTipSet) MarshalCBOR(w io.Writer) error {
 		}
 	}
 
-	// t.Messages (exchange.CompactedMessages) (struct)
+	// t.Messages (blocksync.CompactedMessages) (struct)
 	if err := t.Messages.MarshalCBOR(w); err != nil {
 		return err
 	}
@@ -621,7 +621,7 @@ func (t *BSTipSet) UnmarshalCBOR(r io.Reader) error {
 		t.Blocks[i] = &v
 	}
 
-	// t.Messages (exchange.CompactedMessages) (struct)
+	// t.Messages (blocksync.CompactedMessages) (struct)
 
 	{
 

chain/blocksync/client.go

@@ -1,4 +1,4 @@
-package exchange
+package blocksync
 
 import (
 	"bufio"
@@ -7,17 +7,13 @@ import (
 	"math/rand"
 	"time"
 
-	"github.com/libp2p/go-libp2p-core/helpers"
-	"github.com/libp2p/go-libp2p-core/host"
-	"github.com/libp2p/go-libp2p-core/network"
+	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"
-	"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"
@@ -25,9 +21,11 @@ import (
 	"github.com/filecoin-project/lotus/lib/peermgr"
 )
 
-// client implements exchange.Client, using the libp2p ChainExchange protocol
-// as the fetching mechanism.
-type client struct {
+// Protocol client.
+// FIXME: Rename to just `Client`. Not done at the moment to avoid
+//  disrupting too much of the consumer code, should be done along
+//  https://github.com/filecoin-project/lotus/issues/2612.
+type BlockSync 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*
@@ -37,14 +35,13 @@ type client struct {
 	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{
+func NewClient(
+	host host.Host,
+	pmgr peermgr.MaybePeerMgr,
+) *BlockSync {
+	return &BlockSync{
 		host:        host,
-		peerTracker: newPeerTracker(lc, host, pmgr.Mgr),
+		peerTracker: newPeerTracker(pmgr.Mgr),
 	}
 }
 
@@ -65,14 +62,10 @@ func NewClient(lc fx.Lifecycle, host host.Host, pmgr peermgr.MaybePeerMgr) Clien
 // 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(
+func (client *BlockSync) doRequest(
 	ctx context.Context,
 	req *Request,
 	singlePeer *peer.ID,
-	// In the `GetChainMessages` case, we won't request the headers but we still
-	// need them to check the integrity of the `CompactedMessages` in the response
-	// so the tipset blocks need to be provided by the caller.
-	tipsets []*types.TipSet,
 ) (*validatedResponse, error) {
 	// Validate request.
 	if req.Length == 0 {
@@ -93,7 +86,7 @@ func (c *client) doRequest(
 	if singlePeer != nil {
 		peers = []peer.ID{*singlePeer}
 	} else {
-		peers = c.getShuffledPeers()
+		peers = client.getShuffledPeers()
 		if len(peers) == 0 {
 			return nil, xerrors.Errorf("no peers available")
 		}
@@ -114,9 +107,9 @@ func (c *client) doRequest(
 		}
 
 		// Send request, read response.
-		res, err := c.sendRequestToPeer(ctx, peer, req)
+		res, err := client.sendRequestToPeer(ctx, peer, req)
 		if err != nil {
-			if !xerrors.Is(err, network.ErrNoConn) {
+			if !xerrors.Is(err, inet.ErrNoConn) {
 				log.Warnf("could not connect to peer %s: %s",
 					peer.String(), err)
 			}
@@ -124,15 +117,15 @@ func (c *client) doRequest(
 		}
 
 		// Process and validate response.
-		validRes, err := c.processResponse(req, res, tipsets)
+		validRes, err := client.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)
+		client.peerTracker.logGlobalSuccess(build.Clock.Since(globalTime))
+		client.host.ConnManager().TagPeer(peer, "bsync", SUCCESS_PEER_TAG_VALUE)
 		return validRes, nil
 	}
 
@@ -151,8 +144,11 @@ func (c *client) doRequest(
 // We are conflating in the single error returned both status and validation
 // errors. Peer penalization should happen here then, before returning, so
 // we can apply the correct penalties depending on the cause of the error.
-// FIXME: Add the `peer` as argument once we implement penalties.
-func (c *client) processResponse(req *Request, res *Response, tipsets []*types.TipSet) (*validatedResponse, error) {
+func (client *BlockSync) processResponse(
+	req *Request,
+	res *Response,
+	// FIXME: Add the `peer` as argument once we implement penalties.
+) (*validatedResponse, error) {
 	err := res.statusToError()
 	if err != nil {
 		return nil, xerrors.Errorf("status error: %s", err)
@@ -176,7 +172,7 @@ func (c *client) processResponse(req *Request, res *Response, tipsets []*types.T
 			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)
+		return nil, xerrors.Errorf("got less than requested without a proper status: %s", res.Status)
 	}
 
 	validRes := &validatedResponse{}
@@ -184,16 +180,6 @@ func (c *client) processResponse(req *Request, res *Response, tipsets []*types.T
 		// Check for valid block sets and extract them into `TipSet`s.
 		validRes.tipsets = make([]*types.TipSet, resLength)
 		for i := 0; i < resLength; i++ {
-			if res.Chain[i] == nil {
-				return nil, xerrors.Errorf("response with nil tipset in pos %d", i)
-			}
-			for blockIdx, block := range res.Chain[i].Blocks {
-				if block == nil {
-					return nil, xerrors.Errorf("tipset with nil block in pos %d", blockIdx)
-					// FIXME: Maybe we should move this check to `NewTipSet`.
-				}
-			}
-
 			validRes.tipsets[i], err = types.NewTipSet(res.Chain[i].Blocks)
 			if err != nil {
 				return nil, xerrors.Errorf("invalid tipset blocks at height (head - %d): %w", i, err)
@@ -219,7 +205,7 @@ func (c *client) processResponse(req *Request, res *Response, tipsets []*types.T
 		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)
+				return nil, xerrors.Errorf("no messages included for tipset at height (head - %d): %w", i)
 			}
 			validRes.messages[i] = res.Chain[i].Messages
 		}
@@ -228,28 +214,31 @@ func (c *client) processResponse(req *Request, res *Response, tipsets []*types.T
 			// If the headers were also returned check that the compression
 			// indexes are valid before `toFullTipSets()` is called by the
 			// consumer.
-			err := c.validateCompressedIndices(res.Chain)
-			if err != nil {
-				return nil, err
-			}
-		} else {
-			// If we didn't request the headers they should have been provided
-			// by the caller.
-			if len(tipsets) < len(res.Chain) {
-				return nil, xerrors.Errorf("not enought tipsets provided for message response validation, needed %d, have %d", len(res.Chain), len(tipsets))
-			}
-			chain := make([]*BSTipSet, 0, resLength)
-			for i, resChain := range res.Chain {
-				next := &BSTipSet{
-					Blocks:   tipsets[i].Blocks(),
-					Messages: resChain.Messages,
+			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))
+						}
+					}
 				}
-				chain = append(chain, next)
-			}
-
-			err := c.validateCompressedIndices(chain)
-			if err != nil {
-				return nil, err
 			}
 		}
 	}
@@ -257,44 +246,16 @@ func (c *client) processResponse(req *Request, res *Response, tipsets []*types.T
 	return validRes, nil
 }
 
-func (c *client) validateCompressedIndices(chain []*BSTipSet) error {
-	resLength := len(chain)
-	for tipsetIdx := 0; tipsetIdx < resLength; tipsetIdx++ {
-		msgs := chain[tipsetIdx].Messages
-		blocksNum := len(chain[tipsetIdx].Blocks)
-
-		if len(msgs.BlsIncludes) != blocksNum {
-			return xerrors.Errorf("BlsIncludes (%d) does not match number of blocks (%d)",
-				len(msgs.BlsIncludes), blocksNum)
-		}
-
-		if len(msgs.SecpkIncludes) != blocksNum {
-			return xerrors.Errorf("SecpkIncludes (%d) does not match number of blocks (%d)",
-				len(msgs.SecpkIncludes), blocksNum)
-		}
-
-		for blockIdx := 0; blockIdx < blocksNum; blockIdx++ {
-			for _, mi := range msgs.BlsIncludes[blockIdx] {
-				if int(mi) >= len(msgs.Bls) {
-					return xerrors.Errorf("index in BlsIncludes (%d) exceeds number of messages (%d)",
-						mi, len(msgs.Bls))
-				}
-			}
-
-			for _, mi := range msgs.SecpkIncludes[blockIdx] {
-				if int(mi) >= len(msgs.Secpk) {
-					return xerrors.Errorf("index in SecpkIncludes (%d) exceeds number of messages (%d)",
-						mi, len(msgs.Secpk))
-				}
-			}
-		}
-	}
-
-	return nil
-}
-
-// GetBlocks implements Client.GetBlocks(). Refer to the godocs there.
-func (c *client) GetBlocks(ctx context.Context, tsk types.TipSetKey, count int) ([]*types.TipSet, error) {
+// GetBlocks fetches count blocks from the network, from the provided tipset
+// *backwards*, returning as many tipsets as count.
+//
+// {hint/usage}: This is used by the Syncer during normal chain syncing and when
+// resolving forks.
+func (client *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() {
@@ -310,7 +271,7 @@ func (c *client) GetBlocks(ctx context.Context, tsk types.TipSetKey, count int)
 		Options: Headers,
 	}
 
-	validRes, err := c.doRequest(ctx, req, nil, nil)
+	validRes, err := client.doRequest(ctx, req, nil)
 	if err != nil {
 		return nil, err
 	}
@@ -318,8 +279,11 @@ func (c *client) GetBlocks(ctx context.Context, tsk types.TipSetKey, count int)
 	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) {
+func (client *BlockSync) GetFullTipSet(
+	ctx context.Context,
+	peer peer.ID,
+	tsk types.TipSetKey,
+) (*store.FullTipSet, error) {
 	// TODO: round robin through these peers on error
 
 	req := &Request{
@@ -328,7 +292,7 @@ func (c *client) GetFullTipSet(ctx context.Context, peer peer.ID, tsk types.TipS
 		Options: Headers | Messages,
 	}
 
-	validRes, err := c.doRequest(ctx, req, &peer, nil)
+	validRes, err := client.doRequest(ctx, req, &peer)
 	if err != nil {
 		return nil, err
 	}
@@ -338,18 +302,12 @@ func (c *client) GetFullTipSet(ctx context.Context, peer peer.ID, tsk types.TipS
 	//  *one* tipset here, so it's safe to index directly.
 }
 
-// GetChainMessages implements Client.GetChainMessages(). Refer to the godocs there.
-func (c *client) GetChainMessages(ctx context.Context, tipsets []*types.TipSet) ([]*CompactedMessages, error) {
-	head := tipsets[0]
-	length := uint64(len(tipsets))
-
+func (client *BlockSync) 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{
@@ -358,7 +316,7 @@ func (c *client) GetChainMessages(ctx context.Context, tipsets []*types.TipSet)
 		Options: Messages,
 	}
 
-	validRes, err := c.doRequest(ctx, req, nil, tipsets)
+	validRes, err := client.doRequest(ctx, req, nil)
 	if err != nil {
 		return nil, err
 	}
@@ -369,7 +327,11 @@ func (c *client) GetChainMessages(ctx context.Context, tipsets []*types.TipSet)
 // 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) {
+func (client *BlockSync) sendRequestToPeer(
+	ctx context.Context,
+	peer peer.ID,
+	req *Request,
+) (_ *Response, err error) {
 	// Trace code.
 	ctx, span := trace.StartSpan(ctx, "sendRequestToPeer")
 	defer span.End()
@@ -390,39 +352,34 @@ func (c *client) sendRequestToPeer(ctx context.Context, peer peer.ID, req *Reque
 	}()
 	// -- TRACE --
 
-	supported, err := c.host.Peerstore().SupportsProtocols(peer, BlockSyncProtocolID, ChainExchangeProtocolID)
+	supported, err := client.host.Peerstore().SupportsProtocols(peer, BlockSyncProtocolID)
 	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})
+	if len(supported) == 0 || supported[0] != BlockSyncProtocolID {
+		return nil, xerrors.Errorf("peer %s does not support protocol %s",
+			peer, BlockSyncProtocolID)
+		// FIXME: `ProtoBook` should support a *single* protocol check that returns
+		//  a bool instead of a list.
 	}
 
 	connectionStart := build.Clock.Now()
 
 	// Open stream to peer.
-	stream, err := c.host.NewStream(
-		network.WithNoDial(ctx, "should already have connection"),
+	stream, err := client.host.NewStream(
+		inet.WithNoDial(ctx, "should already have connection"),
 		peer,
-		ChainExchangeProtocolID, BlockSyncProtocolID)
+		BlockSyncProtocolID)
 	if err != nil {
-		c.RemovePeer(peer)
+		client.RemovePeer(peer)
 		return nil, xerrors.Errorf("failed to open stream to peer: %w", err)
 	}
 
-	defer func() {
-		// Note: this will become just stream.Close once we've completed the go-libp2p migration to
-		//       go-libp2p-core 0.7.0
-		go helpers.FullClose(stream) //nolint:errcheck
-	}()
-
 	// Write request.
-	_ = stream.SetWriteDeadline(time.Now().Add(WriteReqDeadline))
+	_ = stream.SetWriteDeadline(time.Now().Add(WRITE_REQ_DEADLINE))
 	if err := cborutil.WriteCborRPC(stream, req); err != nil {
 		_ = stream.SetWriteDeadline(time.Time{})
-		c.peerTracker.logFailure(peer, build.Clock.Since(connectionStart), req.Length)
+		client.peerTracker.logFailure(peer, build.Clock.Since(connectionStart))
 		// FIXME: Should we also remove peer here?
 		return nil, err
 	}
@@ -432,11 +389,11 @@ func (c *client) sendRequestToPeer(ctx context.Context, peer peer.ID, req *Reque
 	// Read response.
 	var res Response
 	err = cborutil.ReadCborRPC(
-		bufio.NewReader(incrt.New(stream, ReadResMinSpeed, ReadResDeadline)),
+		bufio.NewReader(incrt.New(stream, READ_RES_MIN_SPEED, READ_RES_DEADLINE)),
 		&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)
+		client.peerTracker.logFailure(peer, build.Clock.Since(connectionStart))
+		return nil, xerrors.Errorf("failed to read blocksync response: %w", err)
 	}
 
 	// FIXME: Move all this together at the top using a defer as done elsewhere.
@@ -449,34 +406,32 @@ func (c *client) sendRequestToPeer(ctx context.Context, peer peer.ID, req *Reque
 		)
 	}
 
-	c.peerTracker.logSuccess(peer, build.Clock.Since(connectionStart), uint64(len(res.Chain)))
+	client.peerTracker.logSuccess(peer, build.Clock.Since(connectionStart))
 	// 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)
+func (client *BlockSync) AddPeer(p peer.ID) {
+	client.peerTracker.addPeer(p)
 }
 
-// RemovePeer implements Client.RemovePeer(). Refer to the godocs there.
-func (c *client) RemovePeer(p peer.ID) {
-	c.peerTracker.removePeer(p)
+func (client *BlockSync) RemovePeer(p peer.ID) {
+	client.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()
+func (client *BlockSync) getShuffledPeers() []peer.ID {
+	peers := client.peerTracker.prefSortedPeers()
 	shufflePrefix(peers)
 	return peers
 }
 
 func shufflePrefix(peers []peer.ID) {
-	prefix := ShufflePeersPrefix
+	prefix := SHUFFLE_PEERS_PREFIX
 	if len(peers) < prefix {
 		prefix = len(peers)
 	}

chain/blocksync/peer_tracker.go

@@ -1,16 +1,13 @@
-package exchange
+package blocksync
 
 // 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"
@@ -32,30 +29,11 @@ type bsPeerTracker struct {
 	pmgr *peermgr.PeerMgr
 }
 
-func newPeerTracker(lc fx.Lifecycle, h host.Host, pmgr *peermgr.PeerMgr) *bsPeerTracker {
-	bsPt := &bsPeerTracker{
+func newPeerTracker(pmgr *peermgr.PeerMgr) *bsPeerTracker {
+	return &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) {
@@ -94,7 +72,16 @@ func (bpt *bsPeerTracker) prefSortedPeers() []peer.ID {
 		var costI, costJ float64
 
 		getPeerInitLat := func(p peer.ID) float64 {
-			return float64(bpt.avgGlobalTime) * newPeerMul
+			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 {
@@ -120,8 +107,8 @@ func (bpt *bsPeerTracker) prefSortedPeers() []peer.ID {
 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
+	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) {
@@ -146,7 +133,7 @@ func logTime(pi *peerStats, dur time.Duration) {
 
 }
 
-func (bpt *bsPeerTracker) logSuccess(p peer.ID, dur time.Duration, reqSize uint64) {
+func (bpt *bsPeerTracker) logSuccess(p peer.ID, dur time.Duration) {
 	bpt.lk.Lock()
 	defer bpt.lk.Unlock()
 
@@ -158,13 +145,10 @@ func (bpt *bsPeerTracker) logSuccess(p peer.ID, dur time.Duration, reqSize uint6
 	}
 
 	pi.successes++
-	if reqSize == 0 {
-		reqSize = 1
-	}
-	logTime(pi, dur/time.Duration(reqSize))
+	logTime(pi, dur)
 }
 
-func (bpt *bsPeerTracker) logFailure(p peer.ID, dur time.Duration, reqSize uint64) {
+func (bpt *bsPeerTracker) logFailure(p peer.ID, dur time.Duration) {
 	bpt.lk.Lock()
 	defer bpt.lk.Unlock()
 
@@ -176,10 +160,7 @@ func (bpt *bsPeerTracker) logFailure(p peer.ID, dur time.Duration, reqSize uint6
 	}
 
 	pi.failures++
-	if reqSize == 0 {
-		reqSize = 1
-	}
-	logTime(pi, dur/time.Duration(reqSize))
+	logTime(pi, dur)
 }
 
 func (bpt *bsPeerTracker) removePeer(p peer.ID) {

chain/blocksync/protocol.go

@@ -1,10 +1,9 @@
-package exchange
+package blocksync
 
 import (
-	"time"
-
 	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain/store"
+	"time"
 
 	"github.com/ipfs/go-cid"
 	logging "github.com/ipfs/go-log"
@@ -13,17 +12,9 @@ import (
 	"github.com/filecoin-project/lotus/chain/types"
 )
 
-var log = logging.Logger("chainxchg")
+var log = logging.Logger("blocksync")
 
-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"
-)
+const BlockSyncProtocolID = "/fil/sync/blk/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
@@ -33,16 +24,14 @@ const (
 //   qualifier to avoid "const initializer [...] is not a constant" error.)
 var MaxRequestLength = uint64(build.ForkLengthThreshold)
 
-const (
-	// Extracted constants from the code.
-	// FIXME: Should be reviewed and confirmed.
-	SuccessPeerTagValue = 25
-	WriteReqDeadline    = 5 * time.Second
-	ReadResDeadline     = WriteReqDeadline
-	ReadResMinSpeed     = 50 << 10
-	ShufflePeersPrefix  = 16
-	WriteResDeadline    = 60 * time.Second
-)
+// Extracted constants from the code.
+// FIXME: Should be reviewed and confirmed.
+const SUCCESS_PEER_TAG_VALUE = 25
+const WRITE_REQ_DEADLINE = 5 * time.Second
+const READ_RES_DEADLINE = WRITE_REQ_DEADLINE
+const READ_RES_MIN_SPEED = 50 << 10
+const SHUFFLE_PEERS_PREFIX = 5
+const WRITE_RES_DEADLINE = 60 * time.Second
 
 // FIXME: Rename. Make private.
 type Request struct {
@@ -127,7 +116,7 @@ func (res *Response) statusToError() error {
 	case NotFound:
 		return xerrors.Errorf("not found")
 	case GoAway:
-		return xerrors.Errorf("not handling 'go away' chainxchg responses yet")
+		return xerrors.Errorf("not handling 'go away' blocksync responses yet")
 	case InternalError:
 		return xerrors.Errorf("block sync peer errored: %s", res.ErrorMessage)
 	case BadRequest:
@@ -139,8 +128,6 @@ func (res *Response) statusToError() error {
 
 // FIXME: Rename.
 type BSTipSet struct {
-	// List of blocks belonging to a single tipset to which the
-	// `CompactedMessages` are linked.
 	Blocks   []*types.BlockHeader
 	Messages *CompactedMessages
 }

chain/blocksync/server.go

@@ -1,4 +1,4 @@
-package exchange
+package blocksync
 
 import (
 	"bufio"
@@ -15,34 +15,44 @@ import (
 	"github.com/filecoin-project/lotus/chain/types"
 
 	"github.com/ipfs/go-cid"
-	"github.com/libp2p/go-libp2p-core/helpers"
 	inet "github.com/libp2p/go-libp2p-core/network"
 )
 
-// server implements exchange.Server. It services requests for the
-// libp2p ChainExchange protocol.
-type server struct {
+// BlockSyncService is the component that services BlockSync requests from
+// peers.
+//
+// BlockSync is the basic chain synchronization protocol of Filecoin. BlockSync
+// is an RPC-oriented protocol, with a single operation to request blocks.
+//
+// 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.
+// FIXME: Rename to just `Server` (will be done later, see note on `BlockSync`).
+type BlockSyncService 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{
+func NewBlockSyncService(cs *store.ChainStore) *BlockSyncService {
+	return &BlockSyncService{
 		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")
+// Entry point of the service, handles `Request`s.
+func (server *BlockSyncService) HandleStream(stream inet.Stream) {
+	ctx, span := trace.StartSpan(context.Background(), "blocksync.HandleStream")
 	defer span.End()
 
-	// Note: this will become just stream.Close once we've completed the go-libp2p migration to
-	//       go-libp2p-core 0.7.0
-	defer helpers.FullClose(stream) //nolint:errcheck
+	defer stream.Close() //nolint:errcheck
 
 	var req Request
 	if err := cborutil.ReadCborRPC(bufio.NewReader(stream), &req); err != nil {
@@ -52,13 +62,13 @@ func (s *server) HandleStream(stream inet.Stream) {
 	log.Infow("block sync request",
 		"start", req.Head, "len", req.Length)
 
-	resp, err := s.processRequest(ctx, &req)
+	resp, err := server.processRequest(ctx, &req)
 	if err != nil {
 		log.Warn("failed to process request: ", err)
 		return
 	}
 
-	_ = stream.SetDeadline(time.Now().Add(WriteResDeadline))
+	_ = stream.SetDeadline(time.Now().Add(WRITE_RES_DEADLINE))
 	if err := cborutil.WriteCborRPC(stream, resp); err != nil {
 		_ = stream.SetDeadline(time.Time{})
 		log.Warnw("failed to write back response for handle stream",
@@ -70,7 +80,10 @@ func (s *server) HandleStream(stream inet.Stream) {
 
 // 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) {
+func (server *BlockSyncService) 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
@@ -78,14 +91,17 @@ func (s *server) processRequest(ctx context.Context, req *Request) (*Response, e
 		return errResponse, nil
 	}
 
-	return s.serviceRequest(ctx, validReq)
+	return server.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")
+func validateRequest(
+	ctx context.Context,
+	req *Request,
+) (*validatedRequest, *Response) {
+	_, span := trace.StartSpan(ctx, "blocksync.ValidateRequest")
 	defer span.End()
 
 	validReq := validatedRequest{}
@@ -131,11 +147,14 @@ func validateRequest(ctx context.Context, req *Request) (*validatedRequest, *Res
 	return &validReq, nil
 }
 
-func (s *server) serviceRequest(ctx context.Context, req *validatedRequest) (*Response, error) {
-	_, span := trace.StartSpan(ctx, "chainxchg.ServiceRequest")
+func (server *BlockSyncService) serviceRequest(
+	ctx context.Context,
+	req *validatedRequest,
+) (*Response, error) {
+	_, span := trace.StartSpan(ctx, "blocksync.ServiceRequest")
 	defer span.End()
 
-	chain, err := collectChainSegment(s.cs, req)
+	chain, err := collectChainSegment(server.cs, req)
 	if err != nil {
 		log.Warn("block sync request: collectChainSegment failed: ", err)
 		return &Response{
@@ -155,7 +174,10 @@ func (s *server) serviceRequest(ctx context.Context, req *validatedRequest) (*Re
 	}, nil
 }
 
-func collectChainSegment(cs *store.ChainStore, req *validatedRequest) ([]*BSTipSet, error) {
+func collectChainSegment(
+	cs *store.ChainStore,
+	req *validatedRequest,
+) ([]*BSTipSet, error) {
 	var bstips []*BSTipSet
 
 	cur := req.head
@@ -199,36 +221,37 @@ func collectChainSegment(cs *store.ChainStore, req *validatedRequest) ([]*BSTipS
 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
 
-	var blscids, secpkcids []cid.Cid
 	for _, block := range ts.Blocks() {
-		bc, sc, err := cs.ReadMsgMetaCids(block.Messages)
+		bmsgs, smsgs, err := cs.MessagesForBlock(block)
 		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]
+		bmi := make([]uint64, 0, len(bmsgs))
+		for _, m := range bmsgs {
+			i, ok := blsmsgmap[m.Cid()]
 			if !ok {
-				i = uint64(len(blscids))
-				blscids = append(blscids, m)
-				blsmsgmap[m] = i
+				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(sc))
-		for _, m := range sc {
-			i, ok := secpkmsgmap[m]
+		smi := make([]uint64, 0, len(smsgs))
+		for _, m := range smsgs {
+			i, ok := secpkmsgmap[m.Cid()]
 			if !ok {
-				i = uint64(len(secpkcids))
-				secpkcids = append(secpkcids, m)
-				secpkmsgmap[m] = i
+				i = uint64(len(secpkmsgs))
+				secpkmsgs = append(secpkmsgs, m)
+				secpkmsgmap[m.Cid()] = i
 			}
 
 			smi = append(smi, i)
@@ -236,15 +259,5 @@ func gatherMessages(cs *store.ChainStore, ts *types.TipSet) ([]*types.Message, [
 		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
 }

chain/checkpoint.go

@@ -1,81 +0,0 @@
-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
-}

chain/events/events.go

@@ -5,7 +5,7 @@ import (
 	"sync"
 	"time"
 
-	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/specs-actors/actors/abi"
 	"github.com/ipfs/go-cid"
 	logging "github.com/ipfs/go-log/v2"
 	"golang.org/x/xerrors"
@@ -35,7 +35,6 @@ 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)
 
@@ -58,7 +57,7 @@ type Events struct {
 func NewEvents(ctx context.Context, api eventAPI) *Events {
 	gcConfidence := 2 * build.ForkLengthThreshold
 
-	tsc := newTSCache(gcConfidence, api)
+	tsc := newTSCache(gcConfidence, api.ChainGetTipSetByHeight)
 
 	e := &Events{
 		api: api,

chain/events/events_called.go

@@ -5,7 +5,7 @@ import (
 	"math"
 	"sync"
 
-	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/specs-actors/actors/abi"
 	"github.com/ipfs/go-cid"
 	"golang.org/x/xerrors"
 
@@ -307,10 +307,7 @@ func (e *hcEvents) onHeadChanged(check CheckFunc, hnd EventHandler, rev RevertHa
 	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)
-	}
+	ts := e.tsc.best()
 	done, more, err := check(ts)
 	if err != nil {
 		return 0, xerrors.Errorf("called check error (h: %d): %w", ts.Height(), err)