Genesis

.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,68 +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-macos:
     description: build darwin lotus binary
@@ -315,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.
@@ -372,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
 
@@ -400,11 +319,10 @@ workflows:
   version: 2.1
   ci:
     jobs:
-      - lint-all
+      - 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
@@ -419,14 +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-debug
       - build-all:
           requires:

.codecov.yml

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

.github/CODEOWNERS

@@ -1,15 +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

.github/ISSUE_TEMPLATE/sealingfailed.md

@@ -17,27 +17,18 @@ A brief description of the problem you encountered while proving (sealing) a sec
 
 Including what commands you ran, and a description of your setup, is very helpful.
 
+**Sectors list**
+
+The output of `./lotus-miner sectors list`.
+
 **Sectors status**
 
-The output of `lotus-miner sectors status --log <sectorId>` for the failed sector(s).
+The output of `./lotus-miner sectors status --log <sectorId>` for the failed sector(s).
 
 **Lotus miner logs**
 
 Please go through the logs of your miner, and include screenshots of any error-like messages you find.
 
-Alternatively please upload full log files and share a link here
-
-**Lotus miner diagnostic info**
-
-Please collect the following diagnostic information, and share a link here
-
-* lotus-miner diagnostic info `lotus-miner info all > allinfo`
-
-** Code modifications **
-
-If you have modified parts of lotus, please describe which areas were modified,
-and the scope of those modifications
-
 **Version**
 
-The output of `lotus --version`.
+The output of `./lotus --version`.

.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

.gitmodules

@@ -5,6 +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

.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,399 +1,7 @@
-# Lotus changelog
+# lotus changelog
 
-# 0.6.2 / 2020-09-09
+## 0.1.0 / 2019-12-11
 
-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.
+We are very excited to release **lotus** 0.1.0. This is our testnet release. To install lotus and join the testnet, please visit [docs.lotu.sh](docs.lotu.sh). Please file bug reports as [issues](https://github.com/filecoin-project/lotus/issues).
 
-## Changes
-
-#### Messagepool 
-
-- Warn when optimal selection fails to pack a block and we fall back to random selection (https://github.com/filecoin-project/lotus/pull/3708)
-- Add basic command for printing gas performance of messages in the mpool (https://github.com/filecoin-project/lotus/pull/3701)
-- Adjust optimal selection to always try to fill blocks (https://github.com/filecoin-project/lotus/pull/3685)
-- Fix very minor bug in repub baseFeeLowerBound (https://github.com/filecoin-project/lotus/pull/3663)
-- Add an auto flag to mpool replace (https://github.com/filecoin-project/lotus/pull/3676)
-- Fix mpool optimal selection packing failure (https://github.com/filecoin-project/lotus/pull/3698)
-
-#### Core Lotus
-
-- Don't use latency as initital estimate for blocksync (https://github.com/filecoin-project/lotus/pull/3648)
-- Add niceSleep 1 second when drand errors (https://github.com/filecoin-project/lotus/pull/3664)
-- Fix isChainNearSync check in block validator (https://github.com/filecoin-project/lotus/pull/3650)
-- Add peer to peer manager before fetching the tipset (https://github.com/filecoin-project/lotus/pull/3667)
-- Add StageFetchingMessages to sync status (https://github.com/filecoin-project/lotus/pull/3668)
-- Pass tipset through upgrade logic (https://github.com/filecoin-project/lotus/pull/3673)
-- Allow nodes to mark tipsets as checkpointed (https://github.com/filecoin-project/lotus/pull/3680)
-- Remove hard-coded late-fee in window PoSt (https://github.com/filecoin-project/lotus/pull/3702)
-- Gas: Fix median calc (https://github.com/filecoin-project/lotus/pull/3686)
-
-#### Storage
-
-- Storage manager: bail out with an error if unsealed cid is undefined (https://github.com/filecoin-project/lotus/pull/3655)
-- Storage: return true from Sealer.ReadPiece() on success (https://github.com/filecoin-project/lotus/pull/3657)
-
-#### Maintenance
-
-- Resolve lotus, test-vectors, statediff dependency cycle (https://github.com/filecoin-project/lotus/pull/3688)
-- Paych: add docs on how to use paych status (https://github.com/filecoin-project/lotus/pull/3690)
-- Initial CODEOWNERS (https://github.com/filecoin-project/lotus/pull/3691)
-
-
-# 0.6.1 / 2020-09-08
-
-This optional release introduces a minor improvement to the sync process, ensuring nodes don't fall behind and then resync.
-
-## Changes
-
-- Update `test-vectors` (https://github.com/filecoin-project/lotus/pull/3645)
-- Revert "only subscribe to pubsub topics once we are synced" (https://github.com/filecoin-project/lotus/pull/3643)
-
-# 0.6.0 / 2020-09-07
-
-This consensus-breaking release of Lotus is designed to test a network upgrade on the space race testnet. The changes that break consensus are:
-
-- Tweaking of some cryptoecon parameters in specs-actors 0.9.7 (https://github.com/filecoin-project/specs-actors/releases/tag/v0.9.7)
-- Rebalancing FIL distribution to make testnet FIL scarce, which prevents base fee spikes and sets better expectations for mainnet
-
-This release also introduces many improvements to Lotus! Among them are a new version of go-fil-markets that supports non-blocking retrieval, various spam reduction measures in the messagepool and p2p logic, and UX improvements to payment channels, dealmaking, and state inspection.
-
-## Changes
-
-#### Core Lotus and dependencies
-
-- Implement faucet funds reallocation logic (https://github.com/filecoin-project/lotus/pull/3632)
-- Network upgrade: Upgrade to correct fork threshold (https://github.com/filecoin-project/lotus/pull/3628)
-- Update to specs 0.9.7 and markets 0.6.0 (https://github.com/filecoin-project/lotus/pull/3627)
-- Network upgrade: Perform base fee tamping (https://github.com/filecoin-project/lotus/pull/3623)
-- Chain events: if cache best() is nil, return chain head (https://github.com/filecoin-project/lotus/pull/3611)
-- Update to specs actors v0.9.6 (https://github.com/filecoin-project/lotus/pull/3603)
-
-#### Messagepool
-
-- Temporarily allow negative chains (https://github.com/filecoin-project/lotus/pull/3625)
-- Improve publish/republish logic (https://github.com/filecoin-project/lotus/pull/3592)
-- Fix selection bug; priority messages were not included if other chains were negative (https://github.com/filecoin-project/lotus/pull/3580)
-- Add defensive check for minimum GasFeeCap for inclusion within the next 20 blocks (https://github.com/filecoin-project/lotus/pull/3579)
-- Add additional info about gas premium (https://github.com/filecoin-project/lotus/pull/3578)
-- Fix GasPremium capping logic  (https://github.com/filecoin-project/lotus/pull/3552)
-
-#### Payment channels 
-
-- Get available funds by address or by from/to (https://github.com/filecoin-project/lotus/pull/3547)
-- Create `lotus paych status` command (https://github.com/filecoin-project/lotus/pull/3523)
-- Rename CLI command from "paych get" to "paych add-funds" (https://github.com/filecoin-project/lotus/pull/3520)
-
-#### Peer-to-peer
-
-- Only subscribe to pubsub topics once we are synced (https://github.com/filecoin-project/lotus/pull/3602)
-- Reduce mpool add failure log spam (https://github.com/filecoin-project/lotus/pull/3562)
-- Republish messages even if the chains have negative performance(https://github.com/filecoin-project/lotus/pull/3557)
-- Adjust gossipsub gossip factor (https://github.com/filecoin-project/lotus/pull/3556)
-- Integrate pubsub Random Early Drop (https://github.com/filecoin-project/lotus/pull/3518)
-
-#### Miscellaneous
-
-- Fix panic in OnDealExpiredSlashed (https://github.com/filecoin-project/lotus/pull/3553)
-- Robustify state manager against holes in actor method numbers (https://github.com/filecoin-project/lotus/pull/3538)
-
-#### UX
-
-- VM: Fix an error message (https://github.com/filecoin-project/lotus/pull/3608)
-- Documentation: Batch replacement,update lotus-storage-miner to lotus-miner (https://github.com/filecoin-project/lotus/pull/3571)
-- CLI: Robust actor lookup (https://github.com/filecoin-project/lotus/pull/3535)
-- Add agent flag to net peers (https://github.com/filecoin-project/lotus/pull/3534)
-- Add watch option to storage-deals list (https://github.com/filecoin-project/lotus/pull/3527)
-
-#### Testing & tooling
-
-- Decommission chain-validation (https://github.com/filecoin-project/lotus/pull/3606)
-- Metrics: add expected height metric (https://github.com/filecoin-project/lotus/pull/3586)
-- PCR: Use current tipset during refund (https://github.com/filecoin-project/lotus/pull/3570)
-- Lotus-shed: Add math command (https://github.com/filecoin-project/lotus/pull/3568)
-- PCR: Add tipset aggergation (https://github.com/filecoin-project/lotus/pull/3565)- Fix broken paych tests (https://github.com/filecoin-project/lotus/pull/3551)
-- Make chain export ~1000x times faster (https://github.com/filecoin-project/lotus/pull/3533)
-- Chainwatch: Stop SyncIncomingBlocks from leaking into chainwatch processing; No panics during processing (https://github.com/filecoin-project/lotus/pull/3526)
-- Conformance: various changes (https://github.com/filecoin-project/lotus/pull/3521)
-
-# 0.5.10 / 2020-09-03
-
-This patch includes a crucial fix to the message pool selection logic, strongly disfavouring messages that might cause a miner penalty.
-
-## Changes
-
-- Fix calculation of GasReward in messagepool (https://github.com/filecoin-project/lotus/pull/3528)
-
-# 0.5.9 / 2020-09-03
-
-This patch includes a hotfix to the `GasEstimateFeeCap` method, capping the estimated fee to a reasonable level by default.
-
-## Changes 
-
-- Added target height to sync wait (https://github.com/filecoin-project/lotus/pull/3502)
-- Disable codecov annotations (https://github.com/filecoin-project/lotus/pull/3514)
-- Cap fees to reasonable level by default (https://github.com/filecoin-project/lotus/pull/3516)
-- Add APIs and command to inspect bandwidth usage (https://github.com/filecoin-project/lotus/pull/3497)
-- Track expected nonce in mpool, ignore messages with large nonce gaps (https://github.com/filecoin-project/lotus/pull/3450)
-
-# 0.5.8 / 2020-09-02
-
-This patch includes some bugfixes to the sector sealing process, and updates go-fil-markets. It also improves the performance of blocksync, adds a method to export chain state trees, and improves chainwatch.
-
-## Changes
-
-- Upgrade markets to v0.5.9 (https://github.com/filecoin-project/lotus/pull/3496)
-- Improve blocksync to load fewer messages: (https://github.com/filecoin-project/lotus/pull/3494)
-- Fix a panic in the ffi-wrapper's `ReadPiece` (https://github.com/filecoin-project/lotus/pull/3492/files)
-- Fix a deadlock in the sealing scheduler (https://github.com/filecoin-project/lotus/pull/3489)
-- Add test vectors for tipset tests (https://github.com/filecoin-project/lotus/pull/3485/files)
-- Improve the advance-block debug command (https://github.com/filecoin-project/lotus/pull/3476)
-- Add toggle for message processing to Lotus PCR (https://github.com/filecoin-project/lotus/pull/3470)
-- Allow exporting recent chain state trees (https://github.com/filecoin-project/lotus/pull/3463)
-- Remove height from chain rand (https://github.com/filecoin-project/lotus/pull/3458)
-- Disable GC on chain badger datastore (https://github.com/filecoin-project/lotus/pull/3457)
-- Account for `GasPremium` in `GasEstimateFeeCap` (https://github.com/filecoin-project/lotus/pull/3456)
-- Update go-libp2p-pubsub to `master` (https://github.com/filecoin-project/lotus/pull/3455)
-- Chainwatch improvements (https://github.com/filecoin-project/lotus/pull/3442)
-
-# 0.5.7 / 2020-08-31
-
-This patch release includes some bugfixes and enhancements to the sector lifecycle and message pool logic. 
-
-## Changes
-
-- Rebuild unsealed infos on miner restart (https://github.com/filecoin-project/lotus/pull/3401)
-- CLI to attach storage paths to workers (https://github.com/filecoin-project/lotus/pull/3405)
-- Do not select negative performing message chains for inclusion (https://github.com/filecoin-project/lotus/pull/3392)
-- Remove a redundant error-check (https://github.com/filecoin-project/lotus/pull/3421)
-- Correctly move unsealed sectors in `FinalizeSectors` (https://github.com/filecoin-project/lotus/pull/3424)
-- Improve worker selection logic (https://github.com/filecoin-project/lotus/pull/3425)
-- Don't use context to close bitswap (https://github.com/filecoin-project/lotus/pull/3430)
-- Correctly estimate gas premium when there is only one message on chain (https://github.com/filecoin-project/lotus/pull/3428)
-
-# 0.5.6 / 2020-08-29
-
-Hotfix release that fixes a panic in the sealing scheduler (https://github.com/filecoin-project/lotus/pull/3389).
-
-# 0.5.5
-
-This patch release introduces a large number of improvements to the sealing process.
-It also updates go-fil-markets to 
-[version 0.5.8](https://github.com/filecoin-project/go-fil-markets/releases/tag/v0.5.8),
-and go-libp2p-pubsub to [v0.3.5](https://github.com/libp2p/go-libp2p-pubsub/releases/tag/v0.3.5).
-
-#### Downstream upgrades
-
-- Upgrades markets to v0.5.8 (https://github.com/filecoin-project/lotus/pull/3384)
-- Upgrades go-libp2p-pubsub to v0.3.5 (https://github.com/filecoin-project/lotus/pull/3305)
-
-#### Sector sealing
-
-- The following improvements were introduced in https://github.com/filecoin-project/lotus/pull/3350.
-
-    - Allow `lotus-miner sectors remove` to remove a sector in any state.
-    - Create a separate state in the storage FSM dedicated to submitting the Commit message.
-    - Recovery for when the Deal IDs of deals in a sector get changed in a reorg.
-    - Auto-retry sending Precommit and Commit messages if they run out of gas
-    - Auto-retry sector remove tasks when they fail
-    - Compact worker windows, and allow their tasks to be executed in any order
-
-- Don't simply skip PoSt for bad sectors (https://github.com/filecoin-project/lotus/pull/3323)
-
-#### Message Pool 
-
-- Spam Protection: Track required funds for pending messages (https://github.com/filecoin-project/lotus/pull/3313)
-
-#### Chainwatch
-
-- Add more power and reward metrics (https://github.com/filecoin-project/lotus/pull/3367)
-- Fix raciness in sector deal table (https://github.com/filecoin-project/lotus/pull/3275)
-- Parallelize miner processing (https://github.com/filecoin-project/lotus/pull/3380)
-- Accept Lotus API and token (https://github.com/filecoin-project/lotus/pull/3337)
-
-# 0.5.4
-
-A patch release, containing a few nice bugfixes and improvements:
-
-- Fix parsing of peer ID in `lotus-miner actor set-peer-id` (@whyrusleeping)
-- Update dependencies, fixing several bugs (@Stebalien)
-- Fix remaining linter warnings (@Stebalien)
-- Use safe string truncation (@Ingar)
-- Allow tweaking of blocksync message window size (@whyrusleeping)
-- Add some additional gas stats to metrics (@Kubuxu)
-- Fix an edge case bug in message selection, add many tests (@vyzo)
-
-# 0.5.3
-
-Yet another hotfix release. 
-A lesson for readers, having people who have been awake for 12+ hours review
-your hotfix PR is not a good idea. Find someone who has enough slept recently
-enough to give you good code review, otherwise you'll end up quickly bumping
-versions again.
-
-- Fixed a bug in the mempool that was introduced in v0.5.2
-
-# 0.5.2 / 2020-08-24
-
-This is a hotfix release.
-
-- Fix message selection to not include messages that are invalid for block
-  inclusion.
-- Improve SelectMessage handling of the case where the message pools tipset
-  differs from our mining base.
-
-# 0.5.1 / 2020-08-24
-
-The Space Race release! 
-This release contains the genesis car file and bootstrap peers for the space
-race network. 
-
-Additionally, we included two small fixes to genesis creation:
-- Randomize ticket value in genesis generation
-- Correctly set t099 (burnt funds actor) to have valid account actor state
-
-# 0.5.0 / 2020-08-20
-
-This version of Lotus will be used for the incentivized testnet Space Race competition,
-and can be considered mainnet-ready code. It includes some protocol
-changes, upgrades of core dependencies, and various bugfixes and UX/performance improvements.
-
-## Highlights
-
-Among the highlights included in this release are:
-
-- Gas changes: We implemented EIP-1559 and introduced real gas values.
-- Deal-making: We now support "Committed Capacity" sectors, "fast-retrieval" deals,
-and the packing of multiple deals into a single sector.
-- Renamed features: We renamed some of the binaries, environment variables, and default
-paths associated with a Lotus node.
-
-### Gas changes
-
-We made some significant changes to the mechanics of gas in this release.
-
-#### Network fee
-
-We implemented something similar to 
-[Ethereum's EIP-1559](https://github.com/ethereum/EIPs/blob/master/EIPS/eip-1559.md).
-The `Message` structure had three changes:
-- The `GasPrice` field has been removed
-- A new `GasFeeCap` field has been added, which controls the maximum cost
-the sender incurs for the message
-- A new `GasPremium` field has been added, which controls the reward a miner
-earns for including the message
-
-A sender will never be charged more than `GasFeeCap * GasLimit`. 
-A miner will typically earn `GasPremium * GasLimit` as a reward.
-
-The `Blockheader` structure has one new field, called `ParentBaseFee`. 
-Informally speaking,the `ParentBaseFee`
-is increased when blocks are densely packed with messages, and decreased otherwise.
-
-The `ParentBaseFee` is used when calculating how much a sender burns when executing a message. _Burning_ simply refers to sending attoFIL to a dedicated, unreachable account.
-A message causes `ParentBaseFee * GasUsed` attoFIL to be burnt.
-
-#### Real gas values
-
-This release also includes our first "real" gas costs for primitive operations.
-The costs were designed to account for both the _time_ that message execution takes,
-as well as the _space_ a message adds to the state tree.
-
-## Deal-making changes
-
-There are three key changes to the deal-making process.
-
-#### Committed Capacity sectors
-
-Miners can now pledge "Committed Capacity" (CC) sectors, which are explicitly
-stated as containing junk data, and must not include any deals. Miners can do this
-to increase their storage power, and win block rewards from this pledged storage.
-
-They can mark these sectors as "upgradable" with `lotus-miner sectors mark-for-upgrade`.
-If the miner receives and accepts one or more storage deals, the sector that includes
-those deals will _replace_ the CC sector. This is intended to maximize the amount of useful
-storage on the Filecoin network.
-
-#### Fast-retrieval deals
-
-Clients can now include a `fast-retrieval` flag when proposing deals with storage miners.
-If set to true, the miner will include an extra copy of the deal data. This
-data can be quickly served in a retrieval deal, since it will not need to be unsealed.
-
-#### Multiple deals per sector
-
-Miners can now pack multiple deals into a single sector, so long as all the deals
-fit into the sector capacity. This should increase the packing efficiency of miners.
-
-### Renamed features
-
-To improve the user experience, we updated several names to mainatin
-standard prefixing, and to better reflect the meaning of the features being referenced.
-
-In particular, the Lotus miner binary is now called `lotus-miner`, the default
-path for miner data is now `~/.lotusminer`, and the environment variable
-that sets the path for miner data is now `$LOTUS_MINER_PATH`. A full list of renamed
-features can be found [here](https://github.com/filecoin-project/lotus/issues/2304).
-
-## Changelog
-
-#### Downstream upgrades
-- Upgrades markets to v0.5.6 (https://github.com/filecoin-project/lotus/pull/3058)
-- Upgrades specs-actors to v0.9.3 (https://github.com/filecoin-project/lotus/pull/3151)
-
-#### Core protocol
-- Introduces gas values, replacing placeholders (https://github.com/filecoin-project/lotus/pull/2343)
-- Implements EIP-1559, introducing a network base fee, message gas fee cap, and message gas fee premium (https://github.com/filecoin-project/lotus/pull/2874)
-- Implements Poisson Sortition for elections (https://github.com/filecoin-project/lotus/pull/2084)
-
-#### Deal-making lifecycle
-- Introduces "Committed Capacity" sectors (https://github.com/filecoin-project/lotus/pull/2220)
-- Introduces "fast-retrieval" flag for deals (https://github.com/filecoin-project/lotus/pull/2323
-- Supports packing multiple deals into one sector (https://github.com/filecoin-project/storage-fsm/pull/38)
-
-#### Enhancements
-
-- Optimized message pool selection logic (https://github.com/filecoin-project/lotus/pull/2838)
-- Window-based scheduling of sealing tasks (https://github.com/filecoin-project/sector-storage/pull/67)
-- Faster window PoSt (https://github.com/filecoin-project/lotus/pull/2209/files)
-- Refactors the payment channel manager (https://github.com/filecoin-project/lotus/pull/2640)
-- Refactors blocksync (https://github.com/filecoin-project/lotus/pull/2715/files)
-
-#### UX
-
-- Provide status updates for data-transfer (https://github.com/filecoin-project/lotus/pull/3162, https://github.com/filecoin-project/lotus/pull/3191)
-- Miners can customise asks (https://github.com/filecoin-project/lotus/pull/2046)
-- Miners can toggle auto-acceptance of deals (https://github.com/filecoin-project/lotus/pull/1994)
-- Miners can maintain a blocklist of piece CIDs (https://github.com/filecoin-project/lotus/pull/2069)
-
-## Contributors
-
-The following contributors had 10 or more commits go into this release.
-We are grateful for every contribution!
-
-| Contributor        | Commits | Lines ±       |
-|--------------------|---------|---------------|
-| magik6k            | 361     | +13197/-6136  |
-| Kubuxu             | 227     | +5670/-2587   |
-| arajasek           | 120     | +2916/-1264   |
-| whyrusleeping      | 112     | +3979/-1089   |
-| vyzo               | 99      | +3343/-1305   |
-| dirkmc             | 68      | +8732/-3621   |
-| laser              | 45      | +1489/-501    |
-| hannahhoward       | 43      | +2654/-990    |
-| frrist             | 37      | +6630/-4338   |
-| schomatis          | 28      | +3016/-1368   |
-| placer14           | 27      | +824/-350     |
-| raulk              | 25      | +28718/-29849 |
-| mrsmkl             | 22      | +560/-368     |
-| travisperson       | 18      | +1354/-314    |
-| nonsense           | 16      | +2956/-2842   |
-| ingar              | 13      | +331/-123     |
-| daviddias          | 11      | +311/-11      |
-| Stebalien          | 11      | +1204/-980    |
-| RobQuistNL         | 10      | +69/-74       |
-
-# 0.1.0 / 2019-12-11
-
-We are very excited to release **lotus** 0.1.0. This is our testnet release. To install lotus and join the testnet, please visit [lotu.sh](lotu.sh). Please file bug reports as [issues](https://github.com/filecoin-project/lotus/issues).
-
-A huge thank you to all contributors for this testnet release!
+A huge thank you to all contributors for this testnet release!

Makefile

@@ -148,7 +148,7 @@ BINS+=lotus-fountain
 
 lotus-chainwatch:
 	rm -f lotus-chainwatch
-	go build $(GOFLAGS) -o lotus-chainwatch ./cmd/lotus-chainwatch
+	go build -o lotus-chainwatch ./cmd/lotus-chainwatch
 .PHONY: lotus-chainwatch
 BINS+=lotus-chainwatch
 
@@ -272,15 +272,11 @@ dist-clean:
 
 type-gen:
 	go run ./gen/main.go
-	go generate ./...
 
 method-gen:
 	(cd ./lotuspond/front/src/chain && go run ./methodgen.go)
 
 gen: type-gen method-gen
 
-docsgen:
-	go run ./api/docgen > documentation/en/api-methods.md
-
 print-%:
 	@echo $*=$($*)

README.md

@@ -1,24 +1,16 @@
 <p align="center">
-  <a href="https://lotu.sh/" title="Lotus Docs">
+  <a href="https://docs.lotu.sh/" title="Lotus Docs">
     <img src="documentation/images/lotus_logo_h.png" alt="Project Lotus Logo" width="244" />
   </a>
 </p>
 
 <h1 align="center">Project Lotus - 莲</h1>
 
-<p align="center">
-  <a href="https://circleci.com/gh/filecoin-project/lotus"><img src="https://circleci.com/gh/filecoin-project/lotus.svg?style=svg"></a>
-  <a href="https://codecov.io/gh/filecoin-project/lotus"><img src="https://codecov.io/gh/filecoin-project/lotus/branch/master/graph/badge.svg"></a>
-  <a href="https://goreportcard.com/report/github.com/filecoin-project/lotus"><img src="https://goreportcard.com/badge/github.com/filecoin-project/lotus" /></a>  
-  <a href=""><img src="https://img.shields.io/badge/golang-%3E%3D1.14.7-blue.svg" /></a>
-  <br>
-</p>
-
 Lotus is an implementation of the Filecoin Distributed Storage Network. For more details about Filecoin, check out the [Filecoin Spec](https://spec.filecoin.io).
 
 ## Building & Documentation
 
-For instructions on how to build lotus from source, please visit [https://lotu.sh](https://lotu.sh) or read the source [here](https://github.com/filecoin-project/lotus/tree/master/documentation).
+For instructions on how to build lotus from source, please visit [https://docs.lotu.sh](https://docs.lotu.sh) or read the source [here](https://github.com/filecoin-project/lotus/tree/master/documentation).
 
 ## Reporting a Vulnerability
 
@@ -40,6 +32,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

@@ -4,11 +4,10 @@ import (
 	"context"
 	"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/go-jsonrpc/auth"
 
 	"github.com/filecoin-project/lotus/build"
 )
@@ -29,20 +28,6 @@ type Common interface {
 	NetDisconnect(context.Context, peer.ID) error
 	NetFindPeer(context.Context, peer.ID) (peer.AddrInfo, error)
 	NetPubsubScores(context.Context) ([]PubsubScore, error)
-	NetAutoNatStatus(context.Context) (NatInfo, error)
-	NetAgentVersion(ctx context.Context, p peer.ID) (string, error)
-
-	// NetBandwidthStats returns statistics about the nodes total bandwidth
-	// usage and current rate across all peers and protocols.
-	NetBandwidthStats(ctx context.Context) (metrics.Stats, error)
-
-	// NetBandwidthStatsByPeer returns statistics about the nodes bandwidth
-	// usage and current rate per peer
-	NetBandwidthStatsByPeer(ctx context.Context) (map[string]metrics.Stats, error)
-
-	// NetBandwidthStatsByProtocol returns statistics about the nodes bandwidth
-	// usage and current rate per protocol
-	NetBandwidthStatsByProtocol(ctx context.Context) (map[protocol.ID]metrics.Stats, error)
 
 	// MethodGroup: Common
 
@@ -80,8 +65,3 @@ type Version struct {
 func (v Version) String() string {
 	return fmt.Sprintf("%s+api%s", v.Version, v.APIVersion.String())
 }
-
-type NatInfo struct {
-	Reachability network.Reachability
-	PublicAddr   string
-}

api/api_full.go

@@ -2,32 +2,25 @@ package api
 
 import (
 	"context"
-	"fmt"
 	"time"
 
-	"github.com/filecoin-project/go-state-types/dline"
-
-	"github.com/filecoin-project/specs-actors/actors/runtime/proof"
-
 	"github.com/ipfs/go-cid"
 	"github.com/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/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/types"
-	marketevents "github.com/filecoin-project/lotus/markets/loggers"
 	"github.com/filecoin-project/lotus/node/modules/dtypes"
 )
 
@@ -46,11 +39,8 @@ type FullNode interface {
 	// ChainHead returns the current head of the chain.
 	ChainHead(context.Context) (*types.TipSet, error)
 
-	// ChainGetRandomnessFromTickets is used to sample the chain for randomness.
-	ChainGetRandomnessFromTickets(ctx context.Context, tsk types.TipSetKey, personalization crypto.DomainSeparationTag, randEpoch abi.ChainEpoch, entropy []byte) (abi.Randomness, error)
-
-	// ChainGetRandomnessFromBeacon is used to sample the beacon for randomness.
-	ChainGetRandomnessFromBeacon(ctx context.Context, tsk types.TipSetKey, personalization crypto.DomainSeparationTag, randEpoch abi.ChainEpoch, entropy []byte) (abi.Randomness, error)
+	// ChainGetRandomness is used to sample the chain for randomness.
+	ChainGetRandomness(ctx context.Context, tsk types.TipSetKey, personalization crypto.DomainSeparationTag, randEpoch abi.ChainEpoch, entropy []byte) (abi.Randomness, error)
 
 	// ChainGetBlock returns the block specified by the given CID.
 	ChainGetBlock(context.Context, cid.Cid) (*types.BlockHeader, error)
@@ -115,10 +105,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.
-	ChainExport(ctx context.Context, nroots abi.ChainEpoch, 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)
@@ -135,15 +122,12 @@ type FullNode interface {
 	// It fails if message fails to execute.
 	GasEstimateGasLimit(context.Context, *types.Message, types.TipSetKey) (int64, error)
 
-	// GasEstimateGasPremium estimates what gas price should be used for a
+	// GasEsitmateGasPremium estimates what gas price should be used for a
 	// message to have high likelihood of inclusion in `nblocksincl` epochs.
 
-	GasEstimateGasPremium(_ context.Context, nblocksincl uint64,
+	GasEsitmateGasPremium(_ context.Context, nblocksincl uint64,
 		sender address.Address, gaslimit int64, tsk types.TipSetKey) (types.BigInt, error)
 
-	// GasEstimateMessageGas estimates gas values for unset message gas fields
-	GasEstimateMessageGas(context.Context, *types.Message, *MessageSendSpec, types.TipSetKey) (*types.Message, error)
-
 	// MethodGroup: Sync
 	// The Sync method group contains methods for interacting with and
 	// observing the lotus sync service.
@@ -159,16 +143,10 @@ 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)
@@ -181,27 +159,20 @@ type FullNode interface {
 	MpoolPending(context.Context, types.TipSetKey) ([]*types.SignedMessage, error)
 
 	// MpoolSelect returns a list of pending messages for inclusion in the next block
-	MpoolSelect(context.Context, types.TipSetKey, float64) ([]*types.SignedMessage, error)
+	MpoolSelect(context.Context, types.TipSetKey) ([]*types.SignedMessage, error)
 
 	// MpoolPush pushes a signed message to mempool.
 	MpoolPush(context.Context, *types.SignedMessage) (cid.Cid, error)
 
 	// MpoolPushMessage atomically assigns a nonce, signs, and pushes a message
 	// to mempool.
-	// maxFee is only used when GasFeeCap/GasPremium fields aren't specified
-	//
-	// When maxFee is set to 0, MpoolPushMessage will guess appropriate fee
-	// based on current chain conditions
-	MpoolPushMessage(ctx context.Context, msg *types.Message, spec *MessageSendSpec) (*types.SignedMessage, error)
+	MpoolPushMessage(context.Context, *types.Message) (*types.SignedMessage, error)
 
 	// MpoolGetNonce gets next nonce for the specified sender.
 	// Note that this method may not be atomic. Use MpoolPushMessage instead.
 	MpoolGetNonce(context.Context, address.Address) (uint64, error)
 	MpoolSub(context.Context) (<-chan MpoolUpdate, error)
 
-	// MpoolClear clears pending messages from the mpool
-	MpoolClear(context.Context, bool) error
-
 	// MpoolGetConfig returns (a copy of) the current mpool config
 	MpoolGetConfig(context.Context) (*types.MpoolConfig, error)
 	// MpoolSetConfig sets the mpool config to (a copy of) the supplied config
@@ -258,8 +229,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).
@@ -268,23 +237,14 @@ type FullNode interface {
 	ClientMinerQueryOffer(ctx context.Context, miner address.Address, root cid.Cid, piece *cid.Cid) (QueryOffer, error)
 	// ClientRetrieve initiates the retrieval of a file, as specified in the order.
 	ClientRetrieve(ctx context.Context, order RetrievalOrder, ref *FileRef) error
-	// ClientRetrieveWithEvents initiates the retrieval of a file, as specified in the order, and provides a channel
-	// of status updates.
-	ClientRetrieveWithEvents(ctx context.Context, order RetrievalOrder, ref *FileRef) (<-chan marketevents.RetrievalEvent, error)
 	// ClientQueryAsk returns a signed StorageAsk from the specified miner.
 	ClientQueryAsk(ctx context.Context, p peer.ID, miner address.Address) (*storagemarket.SignedStorageAsk, error)
-	// ClientCalcCommP calculates the CommP for a specified file
-	ClientCalcCommP(ctx context.Context, inpath string) (*CommPRet, error)
+	// ClientCalcCommP calculates the CommP for a specified file, based on the sector size of the provided miner.
+	ClientCalcCommP(ctx context.Context, inpath string, miner address.Address) (*CommPRet, error)
 	// ClientGenCar generates a CAR file for the specified file.
 	ClientGenCar(ctx context.Context, ref FileRef, outpath string) error
 	// ClientDealSize calculates real deal data size
 	ClientDealSize(ctx context.Context, root cid.Cid) (DataSize, error)
-	// ClientListTransfers returns the status of all ongoing transfers of data
-	ClientListDataTransfers(ctx context.Context) ([]DataTransferChannel, error)
-	ClientDataTransferUpdates(ctx context.Context) (<-chan DataTransferChannel, error)
-	// ClientRetrieveTryRestartInsufficientFunds attempts to restart stalled retrievals on a given payment channel
-	// which are stuck due to insufficient funds
-	ClientRetrieveTryRestartInsufficientFunds(ctx context.Context, paymentChannel address.Address) error
 
 	// ClientUnimport removes references to the specified file from filestore
 	//ClientUnimport(path string)
@@ -315,12 +275,12 @@ type FullNode interface {
 	// StateMinerSectors returns info about the given miner's sectors. If the filter bitfield is nil, all sectors are included.
 	// If the filterOut boolean is set to true, any sectors in the filter are excluded.
 	// If false, only those sectors in the filter are included.
-	StateMinerSectors(context.Context, address.Address, *bitfield.BitField, bool, types.TipSetKey) ([]*ChainSectorInfo, error)
+	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) ([]*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
@@ -330,11 +290,11 @@ type FullNode interface {
 	// 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
@@ -343,7 +303,7 @@ 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)
@@ -351,6 +311,7 @@ type FullNode interface {
 	StateSectorExpiration(context.Context, address.Address, abi.SectorNumber, types.TipSetKey) (*SectorExpiration, error)
 	// StateSectorPartition finds deadline/partition with the specified sector
 	StateSectorPartition(ctx context.Context, maddr address.Address, sectorNumber abi.SectorNumber, tok types.TipSetKey) (*SectorLocation, error)
+	StatePledgeCollateral(context.Context, types.TipSetKey) (types.BigInt, 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)
 	// StateWaitMsg looks back in the chain for a message. If not found, it blocks until the
@@ -391,7 +352,7 @@ type FullNode interface {
 	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)
+	StateCirculatingSupply(context.Context, types.TipSetKey) (abi.TokenAmount, error)
 
 	// MethodGroup: Msig
 	// The Msig methods are used to interact with multisig wallets on the
@@ -399,9 +360,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>
@@ -418,29 +376,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)
@@ -451,8 +397,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(ch address.Address) (*ChannelAvailableFunds, error)
-	PaychAvailableFundsByFromTo(from, to address.Address) (*ChannelAvailableFunds, error)
 	PaychList(context.Context) ([]address.Address, error)
 	PaychStatus(context.Context, address.Address) (*PaychStatus, error)
 	PaychSettle(context.Context, address.Address) (cid.Cid, error)
@@ -461,10 +405,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 {
@@ -518,12 +462,9 @@ type DealInfo struct {
 	Duration      uint64
 
 	DealID abi.DealID
-
-	CreationTime time.Time
 }
 
 type MsgLookup struct {
-	Message   cid.Cid // Can be different than requested, in case it was replaced, but only gas values changed
 	Receipt   types.MessageReceipt
 	ReturnDec interface{}
 	TipSet    types.TipSetKey
@@ -566,36 +507,14 @@ type PaychStatus struct {
 }
 
 type ChannelInfo struct {
-	Channel      address.Address
-	WaitSentinel cid.Cid
-}
-
-type ChannelAvailableFunds struct {
-	// Channel is the address of the channel
-	Channel *address.Address
-	// From is the from address of the channel (channel creator)
-	From address.Address
-	// To is the to address of the channel
-	To address.Address
-	// ConfirmedAmt is the amount of funds that have been confirmed on-chain
-	// for the channel
-	ConfirmedAmt types.BigInt
-	// PendingAmt is the amount of funds that are pending confirmation on-chain
-	PendingAmt types.BigInt
-	// PendingWaitSentinel can be used with PaychGetWaitReady to wait for
-	// confirmation of pending funds
-	PendingWaitSentinel *cid.Cid
-	// QueuedAmt is the amount that is queued up behind a pending request
-	QueuedAmt types.BigInt
-	// VoucherRedeemedAmt is the amount that is redeemed by vouchers on-chain
-	// and in the local datastore
-	VoucherReedeemedAmt types.BigInt
+	Channel        address.Address
+	ChannelMessage cid.Cid
 }
 
 type PaymentInfo struct {
-	Channel      address.Address
-	WaitSentinel cid.Cid
-	Vouchers     []*paych.SignedVoucher
+	Channel        address.Address
+	ChannelMessage *cid.Cid
+	Vouchers       []*paych.SignedVoucher
 }
 
 type VoucherSpec struct {
@@ -607,16 +526,6 @@ 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
@@ -692,15 +601,14 @@ type MethodCall struct {
 }
 
 type StartDealParams struct {
-	Data               *storagemarket.DataRef
-	Wallet             address.Address
-	Miner              address.Address
-	EpochPrice         types.BigInt
-	MinBlocksDuration  uint64
-	ProviderCollateral big.Int
-	DealStartEpoch     abi.ChainEpoch
-	FastRetrieval      bool
-	VerifiedDeal       bool
+	Data              *storagemarket.DataRef
+	Wallet            address.Address
+	Miner             address.Address
+	EpochPrice        types.BigInt
+	MinBlocksDuration uint64
+	DealStartEpoch    abi.ChainEpoch
+	FastRetrieval     bool
+	VerifiedDeal      bool
 }
 
 type IpldObject struct {
@@ -733,28 +641,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 (
@@ -777,18 +665,10 @@ type DealCollateralBounds struct {
 	Max abi.TokenAmount
 }
 
-type CirculatingSupply struct {
-	FilVested      abi.TokenAmount
-	FilMined       abi.TokenAmount
-	FilBurnt       abi.TokenAmount
-	FilLocked      abi.TokenAmount
-	FilCirculating abi.TokenAmount
-}
-
 type MiningBaseInfo struct {
 	MinerPower      types.BigInt
 	NetworkPower    types.BigInt
-	Sectors         []proof.SectorInfo
+	Sectors         []abi.SectorInfo
 	WorkerKey       address.Address
 	SectorSize      abi.SectorSize
 	PrevBeaconEntry types.BeaconEntry
@@ -805,7 +685,7 @@ type BlockTemplate struct {
 	Messages         []*types.SignedMessage
 	Epoch            abi.ChainEpoch
 	Timestamp        uint64
-	WinningPoStProof []proof.PoStProof
+	WinningPoStProof []abi.PoStProof
 }
 
 type DataSize struct {

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/sector-storage/fsutil"
+	"github.com/filecoin-project/sector-storage/stores"
+	"github.com/filecoin-project/sector-storage/storiface"
+	"github.com/filecoin-project/specs-actors/actors/abi"
 )
 
 // StorageMiner is a low-level interface to the Filecoin network storage miner node
@@ -73,14 +73,12 @@ type StorageMiner interface {
 	MarketImportDealData(ctx context.Context, propcid cid.Cid, path string) error
 	MarketListDeals(ctx context.Context) ([]storagemarket.StorageDeal, error)
 	MarketListRetrievalDeals(ctx context.Context) ([]retrievalmarket.ProviderDealState, error)
-	MarketGetDealUpdates(ctx context.Context) (<-chan storagemarket.MinerDeal, error)
+	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)
 	MarketSetRetrievalAsk(ctx context.Context, rask *retrievalmarket.Ask) error
 	MarketGetRetrievalAsk(ctx context.Context) (*retrievalmarket.Ask, error)
-	MarketListDataTransfers(ctx context.Context) ([]DataTransferChannel, error)
-	MarketDataTransferUpdates(ctx context.Context) (<-chan DataTransferChannel, error)
 
 	DealsImportData(ctx context.Context, dealPropCid cid.Cid, file string) error
 	DealsList(ctx context.Context) ([]storagemarket.StorageDeal, error)
@@ -120,18 +118,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_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/sector-storage/sealtasks"
+	"github.com/filecoin-project/sector-storage/stores"
+	"github.com/filecoin-project/sector-storage/storiface"
+	"github.com/filecoin-project/specs-actors/actors/abi"
 	"github.com/filecoin-project/specs-storage/storage"
 
 	"github.com/filecoin-project/lotus/build"
@@ -23,17 +23,13 @@ type WorkerAPI interface {
 	Paths(context.Context) ([]stores.StoragePath, error)
 	Info(context.Context) (storiface.WorkerInfo, error)
 
-	AddPiece(ctx context.Context, sector abi.SectorID, pieceSizes []abi.UnpaddedPieceSize, newPieceSize abi.UnpaddedPieceSize, pieceData storage.Data) (abi.PieceInfo, error)
-
 	storage.Sealer
 
-	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,32 +5,26 @@ import (
 	"io"
 	"time"
 
-	"github.com/filecoin-project/go-state-types/dline"
-
 	"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/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/sector-storage/fsutil"
+	"github.com/filecoin-project/sector-storage/sealtasks"
+	"github.com/filecoin-project/sector-storage/stores"
+	"github.com/filecoin-project/sector-storage/storiface"
+	"github.com/filecoin-project/specs-actors/actors/abi"
+	"github.com/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"
@@ -47,18 +41,13 @@ 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"`
 
 		ID      func(context.Context) (peer.ID, error)     `perm:"read"`
 		Version func(context.Context) (api.Version, error) `perm:"read"`
@@ -76,54 +65,46 @@ type FullNodeStruct struct {
 	CommonStruct
 
 	Internal struct {
-		ChainNotify                   func(context.Context) (<-chan []*api.HeadChange, error)                                                            `perm:"read"`
-		ChainHead                     func(context.Context) (*types.TipSet, error)                                                                       `perm:"read"`
-		ChainGetRandomnessFromTickets func(context.Context, types.TipSetKey, crypto.DomainSeparationTag, abi.ChainEpoch, []byte) (abi.Randomness, error) `perm:"read"`
-		ChainGetRandomnessFromBeacon  func(context.Context, types.TipSetKey, crypto.DomainSeparationTag, abi.ChainEpoch, []byte) (abi.Randomness, error) `perm:"read"`
-		ChainGetBlock                 func(context.Context, cid.Cid) (*types.BlockHeader, error)                                                         `perm:"read"`
-		ChainGetTipSet                func(context.Context, types.TipSetKey) (*types.TipSet, error)                                                      `perm:"read"`
-		ChainGetBlockMessages         func(context.Context, cid.Cid) (*api.BlockMessages, error)                                                         `perm:"read"`
-		ChainGetParentReceipts        func(context.Context, cid.Cid) ([]*types.MessageReceipt, error)                                                    `perm:"read"`
-		ChainGetParentMessages        func(context.Context, cid.Cid) ([]api.Message, error)                                                              `perm:"read"`
-		ChainGetTipSetByHeight        func(context.Context, abi.ChainEpoch, types.TipSetKey) (*types.TipSet, error)                                      `perm:"read"`
-		ChainReadObj                  func(context.Context, cid.Cid) ([]byte, error)                                                                     `perm:"read"`
-		ChainHasObj                   func(context.Context, cid.Cid) (bool, error)                                                                       `perm:"read"`
-		ChainStatObj                  func(context.Context, cid.Cid, cid.Cid) (api.ObjStat, error)                                                       `perm:"read"`
-		ChainSetHead                  func(context.Context, types.TipSetKey) error                                                                       `perm:"admin"`
-		ChainGetGenesis               func(context.Context) (*types.TipSet, error)                                                                       `perm:"read"`
-		ChainTipSetWeight             func(context.Context, types.TipSetKey) (types.BigInt, error)                                                       `perm:"read"`
-		ChainGetNode                  func(ctx context.Context, p string) (*api.IpldObject, error)                                                       `perm:"read"`
-		ChainGetMessage               func(context.Context, cid.Cid) (*types.Message, error)                                                             `perm:"read"`
-		ChainGetPath                  func(context.Context, types.TipSetKey, types.TipSetKey) ([]*api.HeadChange, error)                                 `perm:"read"`
-		ChainExport                   func(context.Context, abi.ChainEpoch, types.TipSetKey) (<-chan []byte, error)                                      `perm:"read"`
+		ChainNotify            func(context.Context) (<-chan []*api.HeadChange, error)                                                            `perm:"read"`
+		ChainHead              func(context.Context) (*types.TipSet, error)                                                                       `perm:"read"`
+		ChainGetRandomness     func(context.Context, types.TipSetKey, crypto.DomainSeparationTag, abi.ChainEpoch, []byte) (abi.Randomness, error) `perm:"read"`
+		ChainGetBlock          func(context.Context, cid.Cid) (*types.BlockHeader, error)                                                         `perm:"read"`
+		ChainGetTipSet         func(context.Context, types.TipSetKey) (*types.TipSet, error)                                                      `perm:"read"`
+		ChainGetBlockMessages  func(context.Context, cid.Cid) (*api.BlockMessages, error)                                                         `perm:"read"`
+		ChainGetParentReceipts func(context.Context, cid.Cid) ([]*types.MessageReceipt, error)                                                    `perm:"read"`
+		ChainGetParentMessages func(context.Context, cid.Cid) ([]api.Message, error)                                                              `perm:"read"`
+		ChainGetTipSetByHeight func(context.Context, abi.ChainEpoch, types.TipSetKey) (*types.TipSet, error)                                      `perm:"read"`
+		ChainReadObj           func(context.Context, cid.Cid) ([]byte, error)                                                                     `perm:"read"`
+		ChainHasObj            func(context.Context, cid.Cid) (bool, error)                                                                       `perm:"read"`
+		ChainStatObj           func(context.Context, cid.Cid, cid.Cid) (api.ObjStat, error)                                                       `perm:"read"`
+		ChainSetHead           func(context.Context, types.TipSetKey) error                                                                       `perm:"admin"`
+		ChainGetGenesis        func(context.Context) (*types.TipSet, error)                                                                       `perm:"read"`
+		ChainTipSetWeight      func(context.Context, types.TipSetKey) (types.BigInt, error)                                                       `perm:"read"`
+		ChainGetNode           func(ctx context.Context, p string) (*api.IpldObject, error)                                                       `perm:"read"`
+		ChainGetMessage        func(context.Context, cid.Cid) (*types.Message, error)                                                             `perm:"read"`
+		ChainGetPath           func(context.Context, types.TipSetKey, types.TipSetKey) ([]*api.HeadChange, error)                                 `perm:"read"`
+		ChainExport            func(context.Context, types.TipSetKey) (<-chan []byte, error)                                                      `perm:"read"`
 
 		BeaconGetEntry func(ctx context.Context, epoch abi.ChainEpoch) (*types.BeaconEntry, error) `perm:"read"`
 
-		GasEstimateGasPremium func(context.Context, uint64, address.Address, int64, types.TipSetKey) (types.BigInt, error)         `perm:"read"`
-		GasEstimateGasLimit   func(context.Context, *types.Message, types.TipSetKey) (int64, error)                                `perm:"read"`
-		GasEstimateFeeCap     func(context.Context, *types.Message, int64, types.TipSetKey) (types.BigInt, error)                  `perm:"read"`
-		GasEstimateMessageGas func(context.Context, *types.Message, *api.MessageSendSpec, types.TipSetKey) (*types.Message, error) `perm:"read"`
+		GasEsitmateGasPremium func(context.Context, uint64, address.Address, int64, types.TipSetKey) (types.BigInt, error) `perm:"read"`
+		GasEstimateGasLimit   func(context.Context, *types.Message, types.TipSetKey) (int64, error)                        `perm:"read"`
+		GasEstimateFeeCap     func(context.Context, *types.Message, int64, types.TipSetKey) (types.BigInt, error)          `perm:"read"`
 
 		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"`
 
-		MpoolGetConfig func(context.Context) (*types.MpoolConfig, error) `perm:"read"`
-		MpoolSetConfig func(context.Context, *types.MpoolConfig) error   `perm:"write"`
-
-		MpoolSelect func(context.Context, types.TipSetKey, float64) ([]*types.SignedMessage, error) `perm:"read"`
-
-		MpoolPending func(context.Context, types.TipSetKey) ([]*types.SignedMessage, error) `perm:"read"`
-		MpoolClear   func(context.Context, bool) error                                      `perm:"write"`
-
-		MpoolPush        func(context.Context, *types.SignedMessage) (cid.Cid, error)                              `perm:"write"`
-		MpoolPushMessage func(context.Context, *types.Message, *api.MessageSendSpec) (*types.SignedMessage, error) `perm:"sign"`
-		MpoolGetNonce    func(context.Context, address.Address) (uint64, error)                                    `perm:"read"`
-		MpoolSub         func(context.Context) (<-chan api.MpoolUpdate, error)                                     `perm:"read"`
+		MpoolGetConfig   func(context.Context) (*types.MpoolConfig, error)                      `perm:"read"`
+		MpoolSetConfig   func(context.Context, *types.MpoolConfig) error                        `perm:"write"`
+		MpoolSelect      func(context.Context, types.TipSetKey) ([]*types.SignedMessage, error) `perm:"read"`
+		MpoolPending     func(context.Context, types.TipSetKey) ([]*types.SignedMessage, error) `perm:"read"`
+		MpoolPush        func(context.Context, *types.SignedMessage) (cid.Cid, error)           `perm:"write"`
+		MpoolPushMessage func(context.Context, *types.Message) (*types.SignedMessage, error)    `perm:"sign"`
+		MpoolGetNonce    func(context.Context, address.Address) (uint64, error)                 `perm:"read"`
+		MpoolSub         func(context.Context) (<-chan api.MpoolUpdate, error)                  `perm:"read"`
 
 		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"`
@@ -141,37 +122,32 @@ type FullNodeStruct struct {
 		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.SignedStorageAsk, error)              `perm:"read"`
-		ClientCalcCommP                           func(ctx context.Context, inpath string) (*api.CommPRet, error)                                                   `perm:"read"`
-		ClientGenCar                              func(ctx context.Context, ref api.FileRef, outpath string) error                                                  `perm:"write"`
-		ClientDealSize                            func(ctx context.Context, root cid.Cid) (api.DataSize, error)                                                     `perm:"read"`
-		ClientListDataTransfers                   func(ctx context.Context) ([]api.DataTransferChannel, error)                                                      `perm:"write"`
-		ClientDataTransferUpdates                 func(ctx context.Context) (<-chan api.DataTransferChannel, error)                                                 `perm:"write"`
-		ClientRetrieveTryRestartInsufficientFunds func(ctx context.Context, paymentChannel address.Address) error                                                   `perm:"write"`
+		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"`
+		ClientQueryAsk        func(ctx context.Context, p peer.ID, miner address.Address) (*storagemarket.SignedStorageAsk, error)   `perm:"read"`
+		ClientCalcCommP       func(ctx context.Context, inpath string, miner address.Address) (*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"`
 
 		StateNetworkName                   func(context.Context) (dtypes.NetworkName, error)                                                                   `perm:"read"`
-		StateMinerSectors                  func(context.Context, address.Address, *bitfield.BitField, bool, types.TipSetKey) ([]*api.ChainSectorInfo, 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) (*dline.Info, 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) (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) (bitfield.BitField, 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"`
@@ -183,6 +159,7 @@ type FullNodeStruct struct {
 		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"`
+		StatePledgeCollateral              func(context.Context, types.TipSetKey) (types.BigInt, 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"`
@@ -200,40 +177,34 @@ type FullNodeStruct struct {
 		StateCompute                       func(context.Context, abi.ChainEpoch, []*types.Message, types.TipSetKey) (*api.ComputeStateOutput, 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"`
+		StateCirculatingSupply             func(context.Context, types.TipSetKey) (abi.TokenAmount, 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(address.Address) (*api.ChannelAvailableFunds, error)                                                 `perm:"sign"`
-		PaychAvailableFundsByFromTo func(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"`
 	}
 }
 
@@ -253,14 +224,12 @@ type StorageMinerStruct struct {
 		MarketImportDealData      func(context.Context, cid.Cid, string) error                                                                                                                                 `perm:"write"`
 		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"`
 		MarketSetRetrievalAsk     func(ctx context.Context, rask *retrievalmarket.Ask) error                                                                                                                   `perm:"admin"`
 		MarketGetRetrievalAsk     func(ctx context.Context) (*retrievalmarket.Ask, error)                                                                                                                      `perm:"read"`
-		MarketListDataTransfers   func(ctx context.Context) ([]api.DataTransferChannel, error)                                                                                                                 `perm:"write"`
-		MarketDataTransferUpdates func(ctx context.Context) (<-chan api.DataTransferChannel, error)                                                                                                            `perm:"write"`
 
 		PledgeSector func(context.Context) error `perm:"write"`
 
@@ -288,7 +257,7 @@ type StorageMinerStruct struct {
 		StorageAttach        func(context.Context, stores.StorageInfo, fsutil.FsStat) error                                                                                `perm:"admin"`
 		StorageDeclareSector func(context.Context, stores.ID, abi.SectorID, stores.SectorFileType, bool) error                                                             `perm:"admin"`
 		StorageDropSector    func(context.Context, stores.ID, abi.SectorID, stores.SectorFileType) error                                                                   `perm:"admin"`
-		StorageFindSector    func(context.Context, abi.SectorID, stores.SectorFileType, abi.RegisteredSealProof, bool) ([]stores.SectorStorageInfo, error)                 `perm:"admin"`
+		StorageFindSector    func(context.Context, abi.SectorID, stores.SectorFileType, bool) ([]stores.SectorStorageInfo, error)                                          `perm:"admin"`
 		StorageInfo          func(context.Context, stores.ID) (stores.StorageInfo, error)                                                                                  `perm:"admin"`
 		StorageBestAlloc     func(ctx context.Context, allocate stores.SectorFileType, spt abi.RegisteredSealProof, sealing stores.PathType) ([]stores.StorageInfo, error) `perm:"admin"`
 		StorageReportHealth  func(ctx context.Context, id stores.ID, report stores.HealthReport) error                                                                     `perm:"admin"`
@@ -327,7 +296,6 @@ type WorkerStruct struct {
 		Paths     func(context.Context) ([]stores.StoragePath, error)            `perm:"admin"`
 		Info      func(context.Context) (storiface.WorkerInfo, error)            `perm:"admin"`
 
-		AddPiece        func(ctx context.Context, sector abi.SectorID, pieceSizes []abi.UnpaddedPieceSize, newPieceSize abi.UnpaddedPieceSize, pieceData storage.Data) (abi.PieceInfo, error)                      `perm:"admin"`
 		SealPreCommit1  func(ctx context.Context, sector abi.SectorID, ticket abi.SealRandomness, pieces []abi.PieceInfo) (storage.PreCommit1Out, error)                                                           `perm:"admin"`
 		SealPreCommit2  func(context.Context, abi.SectorID, storage.PreCommit1Out) (cids storage.SectorCids, err error)                                                                                            `perm:"admin"`
 		SealCommit1     func(ctx context.Context, sector abi.SectorID, ticket abi.SealRandomness, seed abi.InteractiveSealRandomness, pieces []abi.PieceInfo, cids storage.SectorCids) (storage.Commit1Out, error) `perm:"admin"`
@@ -335,8 +303,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"`
@@ -360,7 +327,6 @@ func (c *CommonStruct) AuthNew(ctx context.Context, perms []auth.Permission) ([]
 func (c *CommonStruct) NetPubsubScores(ctx context.Context) ([]api.PubsubScore, error) {
 	return c.Internal.NetPubsubScores(ctx)
 }
-
 func (c *CommonStruct) NetConnectedness(ctx context.Context, pid peer.ID) (network.Connectedness, error) {
 	return c.Internal.NetConnectedness(ctx, pid)
 }
@@ -385,26 +351,6 @@ func (c *CommonStruct) NetFindPeer(ctx context.Context, p peer.ID) (peer.AddrInf
 	return c.Internal.NetFindPeer(ctx, p)
 }
 
-func (c *CommonStruct) NetAutoNatStatus(ctx context.Context) (api.NatInfo, error) {
-	return c.Internal.NetAutoNatStatus(ctx)
-}
-
-func (c *CommonStruct) NetBandwidthStats(ctx context.Context) (metrics.Stats, error) {
-	return c.Internal.NetBandwidthStats(ctx)
-}
-
-func (c *CommonStruct) NetBandwidthStatsByPeer(ctx context.Context) (map[string]metrics.Stats, error) {
-	return c.Internal.NetBandwidthStatsByPeer(ctx)
-}
-
-func (c *CommonStruct) NetBandwidthStatsByProtocol(ctx context.Context) (map[protocol.ID]metrics.Stats, error) {
-	return c.Internal.NetBandwidthStatsByProtocol(ctx)
-}
-
-func (c *CommonStruct) NetAgentVersion(ctx context.Context, p peer.ID) (string, error) {
-	return c.Internal.NetAgentVersion(ctx, p)
-}
-
 // ID implements API.ID
 func (c *CommonStruct) ID(ctx context.Context) (peer.ID, error) {
 	return c.Internal.ID(ctx)
@@ -469,23 +415,15 @@ 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)
 }
 
-func (c *FullNodeStruct) ClientRetrieveWithEvents(ctx context.Context, order api.RetrievalOrder, ref *api.FileRef) (<-chan marketevents.RetrievalEvent, error) {
-	return c.Internal.ClientRetrieveWithEvents(ctx, order, ref)
-}
-
 func (c *FullNodeStruct) ClientQueryAsk(ctx context.Context, p peer.ID, miner address.Address) (*storagemarket.SignedStorageAsk, error) {
 	return c.Internal.ClientQueryAsk(ctx, p, miner)
 }
-func (c *FullNodeStruct) ClientCalcCommP(ctx context.Context, inpath string) (*api.CommPRet, error) {
-	return c.Internal.ClientCalcCommP(ctx, inpath)
+func (c *FullNodeStruct) ClientCalcCommP(ctx context.Context, inpath string, miner address.Address) (*api.CommPRet, error) {
+	return c.Internal.ClientCalcCommP(ctx, inpath, miner)
 }
 
 func (c *FullNodeStruct) ClientGenCar(ctx context.Context, ref api.FileRef, outpath string) error {
@@ -496,31 +434,17 @@ func (c *FullNodeStruct) ClientDealSize(ctx context.Context, root cid.Cid) (api.
 	return c.Internal.ClientDealSize(ctx, root)
 }
 
-func (c *FullNodeStruct) ClientListDataTransfers(ctx context.Context) ([]api.DataTransferChannel, error) {
-	return c.Internal.ClientListDataTransfers(ctx)
+func (c *FullNodeStruct) GasEsitmateGasPremium(ctx context.Context, nblocksincl uint64,
+	sender address.Address, gaslimit int64, tsk types.TipSetKey) (types.BigInt, error) {
+	return c.Internal.GasEsitmateGasPremium(ctx, nblocksincl, sender, gaslimit, tsk)
 }
-
-func (c *FullNodeStruct) ClientDataTransferUpdates(ctx context.Context) (<-chan api.DataTransferChannel, error) {
-	return c.Internal.ClientDataTransferUpdates(ctx)
-}
-
-func (c *FullNodeStruct) ClientRetrieveTryRestartInsufficientFunds(ctx context.Context, paymentChannel address.Address) error {
-	return c.Internal.ClientRetrieveTryRestartInsufficientFunds(ctx, paymentChannel)
-}
-
-func (c *FullNodeStruct) GasEstimateGasPremium(ctx context.Context, nblocksincl uint64, sender address.Address, gaslimit int64, tsk types.TipSetKey) (types.BigInt, error) {
-	return c.Internal.GasEstimateGasPremium(ctx, nblocksincl, sender, gaslimit, tsk)
-}
-
-func (c *FullNodeStruct) GasEstimateFeeCap(ctx context.Context, msg *types.Message, maxqueueblks int64, tsk types.TipSetKey) (types.BigInt, error) {
+func (c *FullNodeStruct) GasEstimateFeeCap(ctx context.Context, msg *types.Message,
+	maxqueueblks int64, tsk types.TipSetKey) (types.BigInt, error) {
 	return c.Internal.GasEstimateFeeCap(ctx, msg, maxqueueblks, tsk)
 }
 
-func (c *FullNodeStruct) GasEstimateMessageGas(ctx context.Context, msg *types.Message, spec *api.MessageSendSpec, tsk types.TipSetKey) (*types.Message, error) {
-	return c.Internal.GasEstimateMessageGas(ctx, msg, spec, tsk)
-}
-
-func (c *FullNodeStruct) GasEstimateGasLimit(ctx context.Context, msg *types.Message, tsk types.TipSetKey) (int64, error) {
+func (c *FullNodeStruct) GasEstimateGasLimit(ctx context.Context, msg *types.Message,
+	tsk types.TipSetKey) (int64, error) {
 	return c.Internal.GasEstimateGasLimit(ctx, msg, tsk)
 }
 
@@ -532,24 +456,20 @@ func (c *FullNodeStruct) MpoolSetConfig(ctx context.Context, cfg *types.MpoolCon
 	return c.Internal.MpoolSetConfig(ctx, cfg)
 }
 
-func (c *FullNodeStruct) MpoolSelect(ctx context.Context, tsk types.TipSetKey, tq float64) ([]*types.SignedMessage, error) {
-	return c.Internal.MpoolSelect(ctx, tsk, tq)
+func (c *FullNodeStruct) MpoolSelect(ctx context.Context, tsk types.TipSetKey) ([]*types.SignedMessage, error) {
+	return c.Internal.MpoolSelect(ctx, tsk)
 }
 
 func (c *FullNodeStruct) MpoolPending(ctx context.Context, tsk types.TipSetKey) ([]*types.SignedMessage, error) {
 	return c.Internal.MpoolPending(ctx, tsk)
 }
 
-func (c *FullNodeStruct) MpoolClear(ctx context.Context, local bool) error {
-	return c.Internal.MpoolClear(ctx, local)
-}
-
 func (c *FullNodeStruct) MpoolPush(ctx context.Context, smsg *types.SignedMessage) (cid.Cid, error) {
 	return c.Internal.MpoolPush(ctx, smsg)
 }
 
-func (c *FullNodeStruct) MpoolPushMessage(ctx context.Context, msg *types.Message, spec *api.MessageSendSpec) (*types.SignedMessage, error) {
-	return c.Internal.MpoolPushMessage(ctx, msg, spec)
+func (c *FullNodeStruct) MpoolPushMessage(ctx context.Context, msg *types.Message) (*types.SignedMessage, error) {
+	return c.Internal.MpoolPushMessage(ctx, msg)
 }
 
 func (c *FullNodeStruct) MpoolSub(ctx context.Context) (<-chan api.MpoolUpdate, error) {
@@ -568,12 +488,8 @@ func (c *FullNodeStruct) ChainHead(ctx context.Context) (*types.TipSet, error) {
 	return c.Internal.ChainHead(ctx)
 }
 
-func (c *FullNodeStruct) ChainGetRandomnessFromTickets(ctx context.Context, tsk types.TipSetKey, personalization crypto.DomainSeparationTag, randEpoch abi.ChainEpoch, entropy []byte) (abi.Randomness, error) {
-	return c.Internal.ChainGetRandomnessFromTickets(ctx, tsk, personalization, randEpoch, entropy)
-}
-
-func (c *FullNodeStruct) ChainGetRandomnessFromBeacon(ctx context.Context, tsk types.TipSetKey, personalization crypto.DomainSeparationTag, randEpoch abi.ChainEpoch, entropy []byte) (abi.Randomness, error) {
-	return c.Internal.ChainGetRandomnessFromBeacon(ctx, tsk, personalization, randEpoch, entropy)
+func (c *FullNodeStruct) ChainGetRandomness(ctx context.Context, tsk types.TipSetKey, personalization crypto.DomainSeparationTag, randEpoch abi.ChainEpoch, entropy []byte) (abi.Randomness, error) {
+	return c.Internal.ChainGetRandomness(ctx, tsk, personalization, randEpoch, entropy)
 }
 
 func (c *FullNodeStruct) ChainGetTipSetByHeight(ctx context.Context, h abi.ChainEpoch, tsk types.TipSetKey) (*types.TipSet, error) {
@@ -692,8 +608,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, tsk types.TipSetKey) (<-chan []byte, error) {
-	return c.Internal.ChainExport(ctx, nroots, 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) {
@@ -712,18 +628,10 @@ 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)
 }
@@ -732,7 +640,7 @@ func (c *FullNodeStruct) StateNetworkName(ctx context.Context) (dtypes.NetworkNa
 	return c.Internal.StateNetworkName(ctx)
 }
 
-func (c *FullNodeStruct) StateMinerSectors(ctx context.Context, addr address.Address, filter *bitfield.BitField, filterOut bool, tsk types.TipSetKey) ([]*api.ChainSectorInfo, error) {
+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)
 }
 
@@ -740,7 +648,7 @@ func (c *FullNodeStruct) StateMinerActiveSectors(ctx context.Context, addr addre
 	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)
 }
 
@@ -760,7 +668,7 @@ func (c *FullNodeStruct) StateMinerPartitions(ctx context.Context, m address.Add
 	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)
 }
 
@@ -768,7 +676,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)
 }
 
@@ -816,6 +724,10 @@ func (c *FullNodeStruct) StateReadState(ctx context.Context, addr address.Addres
 	return c.Internal.StateReadState(ctx, addr, tsk)
 }
 
+func (c *FullNodeStruct) StatePledgeCollateral(ctx context.Context, tsk types.TipSetKey) (types.BigInt, error) {
+	return c.Internal.StatePledgeCollateral(ctx, tsk)
+}
+
 func (c *FullNodeStruct) StateWaitMsg(ctx context.Context, msgc cid.Cid, confidence uint64) (*api.MsgLookup, error) {
 	return c.Internal.StateWaitMsg(ctx, msgc, confidence)
 }
@@ -880,7 +792,7 @@ func (c *FullNodeStruct) StateDealProviderCollateralBounds(ctx context.Context,
 	return c.Internal.StateDealProviderCollateralBounds(ctx, size, verified, tsk)
 }
 
-func (c *FullNodeStruct) StateCirculatingSupply(ctx context.Context, tsk types.TipSetKey) (api.CirculatingSupply, error) {
+func (c *FullNodeStruct) StateCirculatingSupply(ctx context.Context, tsk types.TipSetKey) (abi.TokenAmount, error) {
 	return c.Internal.StateCirculatingSupply(ctx, tsk)
 }
 
@@ -888,10 +800,6 @@ func (c *FullNodeStruct) MsigGetAvailableBalance(ctx context.Context, a address.
 	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)
 }
@@ -908,18 +816,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)
 }
@@ -940,16 +836,8 @@ func (c *FullNodeStruct) PaychGet(ctx context.Context, from, to address.Address,
 	return c.Internal.PaychGet(ctx, from, to, amt)
 }
 
-func (c *FullNodeStruct) PaychGetWaitReady(ctx context.Context, sentinel cid.Cid) (address.Address, error) {
-	return c.Internal.PaychGetWaitReady(ctx, sentinel)
-}
-
-func (c *FullNodeStruct) PaychAvailableFunds(ch address.Address) (*api.ChannelAvailableFunds, error) {
-	return c.Internal.PaychAvailableFunds(ch)
-}
-
-func (c *FullNodeStruct) PaychAvailableFundsByFromTo(from, to address.Address) (*api.ChannelAvailableFunds, error) {
-	return c.Internal.PaychAvailableFundsByFromTo(from, to)
+func (c *FullNodeStruct) PaychGetWaitReady(ctx context.Context, mcid cid.Cid) (address.Address, error) {
+	return c.Internal.PaychGetWaitReady(ctx, mcid)
 }
 
 func (c *FullNodeStruct) PaychList(ctx context.Context) ([]address.Address, error) {
@@ -972,7 +860,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)
 }
 
@@ -996,8 +884,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
@@ -1092,8 +980,8 @@ func (c *StorageMinerStruct) StorageDropSector(ctx context.Context, storageId st
 	return c.Internal.StorageDropSector(ctx, storageId, s, ft)
 }
 
-func (c *StorageMinerStruct) StorageFindSector(ctx context.Context, si abi.SectorID, types stores.SectorFileType, spt abi.RegisteredSealProof, allowFetch bool) ([]stores.SectorStorageInfo, error) {
-	return c.Internal.StorageFindSector(ctx, si, types, spt, allowFetch)
+func (c *StorageMinerStruct) StorageFindSector(ctx context.Context, si abi.SectorID, types stores.SectorFileType, allowFetch bool) ([]stores.SectorStorageInfo, error) {
+	return c.Internal.StorageFindSector(ctx, si, types, allowFetch)
 }
 
 func (c *StorageMinerStruct) StorageList(ctx context.Context) (map[stores.ID][]stores.Decl, error) {
@@ -1140,8 +1028,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) {
@@ -1164,14 +1052,6 @@ func (c *StorageMinerStruct) MarketGetRetrievalAsk(ctx context.Context) (*retrie
 	return c.Internal.MarketGetRetrievalAsk(ctx)
 }
 
-func (c *StorageMinerStruct) MarketListDataTransfers(ctx context.Context) ([]api.DataTransferChannel, error) {
-	return c.Internal.MarketListDataTransfers(ctx)
-}
-
-func (c *StorageMinerStruct) MarketDataTransferUpdates(ctx context.Context) (<-chan api.DataTransferChannel, error) {
-	return c.Internal.MarketDataTransferUpdates(ctx)
-}
-
 func (c *StorageMinerStruct) DealsImportData(ctx context.Context, dealPropCid cid.Cid, file string) error {
 	return c.Internal.DealsImportData(ctx, dealPropCid, file)
 }
@@ -1258,10 +1138,6 @@ func (w *WorkerStruct) Info(ctx context.Context) (storiface.WorkerInfo, error) {
 	return w.Internal.Info(ctx)
 }
 
-func (w *WorkerStruct) AddPiece(ctx context.Context, sector abi.SectorID, pieceSizes []abi.UnpaddedPieceSize, newPieceSize abi.UnpaddedPieceSize, pieceData storage.Data) (abi.PieceInfo, error) {
-	return w.Internal.AddPiece(ctx, sector, pieceSizes, newPieceSize, pieceData)
-}
-
 func (w *WorkerStruct) SealPreCommit1(ctx context.Context, sector abi.SectorID, ticket abi.SealRandomness, pieces []abi.PieceInfo) (storage.PreCommit1Out, error) {
 	return w.Internal.SealPreCommit1(ctx, sector, ticket, pieces)
 }
@@ -1290,12 +1166,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"
 )
@@ -41,20 +41,26 @@ func (t *PaymentInfo) MarshalCBOR(w io.Writer) error {
 		return err
 	}
 
-	// t.WaitSentinel (cid.Cid) (struct)
-	if len("WaitSentinel") > cbg.MaxLength {
-		return xerrors.Errorf("Value in field \"WaitSentinel\" was too long")
+	// t.ChannelMessage (cid.Cid) (struct)
+	if len("ChannelMessage") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"ChannelMessage\" was too long")
 	}
 
-	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("WaitSentinel"))); err != nil {
+	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajTextString, uint64(len("ChannelMessage"))); err != nil {
 		return err
 	}
-	if _, err := io.WriteString(w, string("WaitSentinel")); err != nil {
+	if _, err := io.WriteString(w, string("ChannelMessage")); err != nil {
 		return err
 	}
 
-	if err := cbg.WriteCidBuf(scratch, w, t.WaitSentinel); err != nil {
-		return xerrors.Errorf("failed to write cid field t.WaitSentinel: %w", err)
+	if t.ChannelMessage == nil {
+		if _, err := w.Write(cbg.CborNull); err != nil {
+			return err
+		}
+	} else {
+		if err := cbg.WriteCidBuf(scratch, w, *t.ChannelMessage); err != nil {
+			return xerrors.Errorf("failed to write cid field t.ChannelMessage: %w", err)
+		}
 	}
 
 	// t.Vouchers ([]*paych.SignedVoucher) (slice)
@@ -127,17 +133,29 @@ func (t *PaymentInfo) UnmarshalCBOR(r io.Reader) error {
 				}
 
 			}
-			// t.WaitSentinel (cid.Cid) (struct)
-		case "WaitSentinel":
+			// t.ChannelMessage (cid.Cid) (struct)
+		case "ChannelMessage":
 
 			{
 
-				c, err := cbg.ReadCid(br)
+				pb, err := br.PeekByte()
 				if err != nil {
-					return xerrors.Errorf("failed to read cid field t.WaitSentinel: %w", err)
+					return err
 				}
+				if pb == cbg.CborNull[0] {
+					var nbuf [1]byte
+					if _, err := br.Read(nbuf[:]); err != nil {
+						return err
+					}
+				} else {
 
-				t.WaitSentinel = c
+					c, err := cbg.ReadCid(br)
+					if err != nil {
+						return xerrors.Errorf("failed to read cid field t.ChannelMessage: %w", err)
+					}
+
+					t.ChannelMessage = &c
+				}
 
 			}
 			// t.Vouchers ([]*paych.SignedVoucher) (slice)

api/client/client.go

@@ -1,23 +1,18 @@
 package client
 
 import (
-	"context"
 	"net/http"
-	"net/url"
-	"path"
-	"time"
 
 	"github.com/filecoin-project/go-jsonrpc"
 
 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/api/apistruct"
-	"github.com/filecoin-project/lotus/lib/rpcenc"
 )
 
 // 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 +23,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,44 +35,26 @@ 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) (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,
 		},
 		requestHeader,
-		opts...,
 	)
 
 	return &res, closer, err
 }
 
-func NewWorkerRPC(ctx context.Context, addr string, requestHeader http.Header) (api.WorkerAPI, jsonrpc.ClientCloser, error) {
-	u, err := url.Parse(addr)
-	if err != nil {
-		return nil, nil, err
-	}
-	switch u.Scheme {
-	case "ws":
-		u.Scheme = "http"
-	case "wss":
-		u.Scheme = "https"
-	}
-	///rpc/v0 -> /rpc/streams/v0/push
-
-	u.Path = path.Join(u.Path, "../streams/v0/push")
-
+func NewWorkerRPC(addr string, requestHeader http.Header) (api.WorkerAPI, jsonrpc.ClientCloser, error) {
 	var res apistruct.WorkerStruct
-	closer, err := jsonrpc.NewMergeClient(ctx, addr, "Filecoin",
+	closer, err := jsonrpc.NewMergeClient(addr, "Filecoin",
 		[]interface{}{
 			&res.Internal,
 		},
 		requestHeader,
-		rpcenc.ReaderParamEncoder(u.String()),
-		jsonrpc.WithNoReconnect(),
-		jsonrpc.WithTimeout(30*time.Second),
 	)
 
 	return &res, closer, err

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,15 +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(&types.ExecutionTrace{
 		Msg:    exampleValue(reflect.TypeOf(&types.Message{}), nil).(*types.Message),
 		MsgRct: exampleValue(reflect.TypeOf(&types.MessageReceipt{}), nil).(*types.MessageReceipt),
@@ -127,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

@@ -1,56 +0,0 @@
-package test
-
-import (
-	"context"
-	"fmt"
-	"sync/atomic"
-	"testing"
-	"time"
-
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/lotus/miner"
-)
-
-type BlockMiner struct {
-	ctx       context.Context
-	t         *testing.T
-	miner     TestStorageNode
-	blocktime time.Duration
-	mine      int64
-	nulls     int64
-	done      chan struct{}
-}
-
-func NewBlockMiner(ctx context.Context, t *testing.T, miner TestStorageNode, blocktime time.Duration) *BlockMiner {
-	return &BlockMiner{
-		ctx:       ctx,
-		t:         t,
-		miner:     miner,
-		blocktime: blocktime,
-		mine:      int64(1),
-		done:      make(chan struct{}),
-	}
-}
-
-func (bm *BlockMiner) MineBlocks() {
-	time.Sleep(time.Second)
-	go func() {
-		defer close(bm.done)
-		for atomic.LoadInt64(&bm.mine) == 1 {
-			time.Sleep(bm.blocktime)
-			nulls := atomic.SwapInt64(&bm.nulls, 0)
-			if err := bm.miner.MineOne(bm.ctx, miner.MineReq{
-				InjectNulls: abi.ChainEpoch(nulls),
-				Done:        func(bool, abi.ChainEpoch, error) {},
-			}); err != nil {
-				bm.t.Error(err)
-			}
-		}
-	}()
-}
-
-func (bm *BlockMiner) Stop() {
-	atomic.AddInt64(&bm.mine, -1)
-	fmt.Println("shutting down mining")
-	<-bm.done
-}

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"
@@ -20,7 +20,7 @@ func TestCCUpgrade(t *testing.T, b APIBuilder, blocktime time.Duration) {
 	_ = os.Setenv("BELLMAN_NO_GPU", "1")
 
 	ctx := context.Background()
-	n, sn := b(t, 1, OneMiner)
+	n, sn := b(t, 1, oneMiner)
 	client := n[0].FullNode.(*impl.FullNodeAPI)
 	miner := sn[0]
 

api/test/deals.go

@@ -20,11 +20,10 @@ 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"
 	"github.com/filecoin-project/lotus/miner"
+	sealing "github.com/filecoin-project/storage-fsm"
 	dag "github.com/ipfs/go-merkledag"
 	dstest "github.com/ipfs/go-merkledag/test"
 	unixfile "github.com/ipfs/go-unixfs/file"
@@ -36,7 +35,7 @@ import (
 
 var MineNext = miner.MineReq{
 	InjectNulls: 0,
-	Done:        func(bool, abi.ChainEpoch, error) {},
+	Done:        func(bool, error) {},
 }
 
 func init() {
@@ -48,7 +47,7 @@ func TestDealFlow(t *testing.T, b APIBuilder, blocktime time.Duration, carExport
 	_ = os.Setenv("BELLMAN_NO_GPU", "1")
 
 	ctx := context.Background()
-	n, sn := b(t, 1, OneMiner)
+	n, sn := b(t, 1, oneMiner)
 	client := n[0].FullNode.(*impl.FullNodeAPI)
 	miner := sn[0]
 
@@ -85,7 +84,7 @@ func TestDoubleDealFlow(t *testing.T, b APIBuilder, blocktime time.Duration) {
 	_ = os.Setenv("BELLMAN_NO_GPU", "1")
 
 	ctx := context.Background()
-	n, sn := b(t, 1, OneMiner)
+	n, sn := b(t, 1, oneMiner)
 	client := n[0].FullNode.(*impl.FullNodeAPI)
 	miner := sn[0]
 
@@ -142,14 +141,14 @@ 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) {
 	_ = os.Setenv("BELLMAN_NO_GPU", "1")
 
 	ctx := context.Background()
-	n, sn := b(t, 1, OneMiner)
+	n, sn := b(t, 1, oneMiner)
 	client := n[0].FullNode.(*impl.FullNodeAPI)
 	miner := sn[0]
 
@@ -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
@@ -204,7 +203,7 @@ func TestSenondDealRetrieval(t *testing.T, b APIBuilder, blocktime time.Duration
 	_ = os.Setenv("BELLMAN_NO_GPU", "1")
 
 	ctx := context.Background()
-	n, sn := b(t, 1, OneMiner)
+	n, sn := b(t, 1, oneMiner)
 	client := n[0].FullNode.(*impl.FullNodeAPI)
 	miner := sn[0]
 
@@ -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)
@@ -401,11 +398,9 @@ func testRetrieval(t *testing.T, ctx context.Context, client *impl.FullNodeAPI,
 		Path:  filepath.Join(rpath, "ret"),
 		IsCAR: carExport,
 	}
-	updates, err := client.ClientRetrieveWithEvents(ctx, offers[0].Order(caddr), ref)
-	for update := range updates {
-		if update.Err != "" {
-			t.Fatalf("%v", err)
-		}
+	err = client.ClientRetrieve(ctx, offers[0].Order(caddr), ref)
+	if err != nil {
+		t.Fatalf("%+v", err)
 	}
 
 	rdata, err := ioutil.ReadFile(filepath.Join(rpath, "ret"))

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,41 +20,11 @@ import (
 	"github.com/filecoin-project/lotus/node/impl"
 )
 
-//nolint:deadcode,varcheck
 var log = logging.Logger("apitest")
 
 func (ts *testSuite) testMining(t *testing.T) {
 	ctx := context.Background()
-	apis, sn := ts.makeNodes(t, 1, OneMiner)
-	api := apis[0]
-
-	newHeads, err := api.ChainNotify(ctx)
-	require.NoError(t, err)
-	initHead := (<-newHeads)[0]
-	baseHeight := initHead.Val.Height()
-
-	h1, err := api.ChainHead(ctx)
-	require.NoError(t, err)
-	require.Equal(t, int64(h1.Height()), int64(baseHeight))
-
-	MineUntilBlock(ctx, t, apis[0], sn[0], nil)
-	require.NoError(t, err)
-
-	<-newHeads
-
-	h2, err := api.ChainHead(ctx)
-	require.NoError(t, err)
-	require.Greater(t, int64(h2.Height()), int64(h1.Height()))
-}
-
-func (ts *testSuite) testMiningReal(t *testing.T) {
-	build.InsecurePoStValidation = false
-	defer func() {
-		build.InsecurePoStValidation = true
-	}()
-
-	ctx := context.Background()
-	apis, sn := ts.makeNodes(t, 1, OneMiner)
+	apis, sn := ts.makeNodes(t, 1, oneMiner)
 	api := apis[0]
 
 	newHeads, err := api.ChainNotify(ctx)
@@ -68,7 +38,38 @@ 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
+
+	h2, err := api.ChainHead(ctx)
+	require.NoError(t, err)
+	require.Equal(t, abi.ChainEpoch(3), h2.Height())
+}
+
+func (ts *testSuite) testMiningReal(t *testing.T) {
+	build.InsecurePoStValidation = false
+	defer func() {
+		build.InsecurePoStValidation = true
+	}()
+
+	ctx := context.Background()
+	apis, sn := ts.makeNodes(t, 1, oneMiner)
+	api := apis[0]
+
+	newHeads, err := api.ChainNotify(ctx)
+	require.NoError(t, err)
+	initHead := (<-newHeads)[0]
+	if initHead.Val.Height() != 2 {
+		<-newHeads
+	}
+
+	h1, err := api.ChainHead(ctx)
+	require.NoError(t, err)
+	require.Equal(t, abi.ChainEpoch(2), h1.Height())
+
+	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

@@ -10,8 +10,8 @@ import (
 
 	"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"
 
@@ -23,13 +23,14 @@ import (
 	"github.com/filecoin-project/lotus/chain/events/state"
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/chain/wallet"
+	"github.com/filecoin-project/lotus/miner"
 )
 
 func TestPaymentChannels(t *testing.T, b APIBuilder, blocktime time.Duration) {
 	_ = os.Setenv("BELLMAN_NO_GPU", "1")
 
 	ctx := context.Background()
-	n, sn := b(t, 2, OneMiner)
+	n, sn := b(t, 2, oneMiner)
 
 	paymentCreator := n[0]
 	paymentReceiver := n[1]
@@ -50,8 +51,8 @@ func TestPaymentChannels(t *testing.T, b APIBuilder, blocktime time.Duration) {
 	}
 
 	// start mining blocks
-	bm := NewBlockMiner(ctx, t, miner, blocktime)
-	bm.MineBlocks()
+	bm := newBlockMiner(ctx, t, miner, blocktime)
+	bm.mineBlocks()
 
 	// send some funds to register the receiver
 	receiverAddr, err := paymentReceiver.WalletNew(ctx, wallet.ActSigType("secp256k1"))
@@ -59,7 +60,7 @@ func TestPaymentChannels(t *testing.T, b APIBuilder, blocktime time.Duration) {
 		t.Fatal(err)
 	}
 
-	SendFunds(ctx, t, paymentCreator, receiverAddr, abi.NewTokenAmount(1e18))
+	sendFunds(ctx, t, paymentCreator, receiverAddr, abi.NewTokenAmount(1e18))
 
 	// setup the payment channel
 	createrAddr, err := paymentCreator.WalletDefaultAddress(ctx)
@@ -73,7 +74,7 @@ func TestPaymentChannels(t *testing.T, b APIBuilder, blocktime time.Duration) {
 		t.Fatal(err)
 	}
 
-	channel, err := paymentCreator.PaychGetWaitReady(ctx, channelInfo.WaitSentinel)
+	channel, err := paymentCreator.PaychGetWaitReady(ctx, channelInfo.ChannelMessage)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -96,24 +97,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)
 		}
@@ -159,9 +154,6 @@ func TestPaymentChannels(t *testing.T, b APIBuilder, blocktime time.Duration) {
 	}, 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:
@@ -209,10 +201,10 @@ func TestPaymentChannels(t *testing.T, b APIBuilder, blocktime time.Duration) {
 	}
 
 	// shut down mining
-	bm.Stop()
+	bm.stop()
 }
 
-func waitForBlocks(ctx context.Context, t *testing.T, bm *BlockMiner, paymentReceiver TestNode, receiverAddr address.Address, count int) {
+func waitForBlocks(ctx context.Context, t *testing.T, bm *blockMiner, paymentReceiver TestNode, receiverAddr address.Address, count int) {
 	// We need to add null blocks in batches, if we add too many the chain can't sync
 	batchSize := 60
 	for i := 0; i < count; i += batchSize {
@@ -229,7 +221,7 @@ func waitForBlocks(ctx context.Context, t *testing.T, bm *BlockMiner, paymentRec
 			To:    builtin.BurntFundsActorAddr,
 			From:  receiverAddr,
 			Value: types.NewInt(0),
-		}, nil)
+		})
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -257,3 +249,73 @@ func waitForMessage(ctx context.Context, t *testing.T, paymentCreator TestNode,
 	fmt.Println("Confirmed", desc)
 	return res
 }
+
+type blockMiner struct {
+	ctx       context.Context
+	t         *testing.T
+	miner     TestStorageNode
+	blocktime time.Duration
+	mine      int64
+	nulls     int64
+	done      chan struct{}
+}
+
+func newBlockMiner(ctx context.Context, t *testing.T, miner TestStorageNode, blocktime time.Duration) *blockMiner {
+	return &blockMiner{
+		ctx:       ctx,
+		t:         t,
+		miner:     miner,
+		blocktime: blocktime,
+		mine:      int64(1),
+		done:      make(chan struct{}),
+	}
+}
+
+func (bm *blockMiner) mineBlocks() {
+	time.Sleep(time.Second)
+	go func() {
+		defer close(bm.done)
+		for atomic.LoadInt64(&bm.mine) == 1 {
+			time.Sleep(bm.blocktime)
+			nulls := atomic.SwapInt64(&bm.nulls, 0)
+			if err := bm.miner.MineOne(bm.ctx, miner.MineReq{
+				InjectNulls: abi.ChainEpoch(nulls),
+				Done:        func(bool, error) {},
+			}); err != nil {
+				bm.t.Error(err)
+			}
+		}
+	}()
+}
+
+func (bm *blockMiner) stop() {
+	atomic.AddInt64(&bm.mine, -1)
+	fmt.Println("shutting down mining")
+	<-bm.done
+}
+
+func sendFunds(ctx context.Context, t *testing.T, sender TestNode, addr address.Address, amount abi.TokenAmount) {
+
+	senderAddr, err := sender.WalletDefaultAddress(ctx)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	msg := &types.Message{
+		From:  senderAddr,
+		To:    addr,
+		Value: amount,
+	}
+
+	sm, err := sender.MpoolPushMessage(ctx, msg)
+	if err != nil {
+		t.Fatal(err)
+	}
+	res, err := sender.StateWaitMsg(ctx, sm.Cid(), 1)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if res.Receipt.ExitCode != 0 {
+		t.Fatal("did not successfully send money")
+	}
+}

api/test/test.go

@@ -4,8 +4,6 @@ import (
 	"context"
 	"testing"
 
-	"github.com/multiformats/go-multiaddr"
-
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
@@ -16,16 +14,10 @@ import (
 
 type TestNode struct {
 	api.FullNode
-	// ListenAddr is the address on which an API server is listening, if an
-	// API server is created for this Node
-	ListenAddr multiaddr.Multiaddr
 }
 
 type TestStorageNode struct {
 	api.StorageMiner
-	// ListenAddr is the address on which an API server is listening, if an
-	// API server is created for this Node
-	ListenAddr multiaddr.Multiaddr
 
 	MineOne func(context.Context, miner.MineReq) error
 }
@@ -62,13 +54,11 @@ func TestApis(t *testing.T, b APIBuilder) {
 	t.Run("testMiningReal", ts.testMiningReal)
 }
 
-var OneMiner = []StorageMiner{{Full: 0, Preseal: PresealGenesis}}
+var oneMiner = []StorageMiner{{Full: 0, Preseal: PresealGenesis}}
 
 func (ts *testSuite) testVersion(t *testing.T) {
-	build.RunningNodeType = build.NodeFull
-
 	ctx := context.Background()
-	apis, _ := ts.makeNodes(t, 1, OneMiner)
+	apis, _ := ts.makeNodes(t, 1, oneMiner)
 	api := apis[0]
 
 	v, err := api.Version(ctx)
@@ -80,7 +70,7 @@ func (ts *testSuite) testVersion(t *testing.T) {
 
 func (ts *testSuite) testID(t *testing.T) {
 	ctx := context.Background()
-	apis, _ := ts.makeNodes(t, 1, OneMiner)
+	apis, _ := ts.makeNodes(t, 1, oneMiner)
 	api := apis[0]
 
 	id, err := api.ID(ctx)
@@ -92,7 +82,7 @@ func (ts *testSuite) testID(t *testing.T) {
 
 func (ts *testSuite) testConnectTwo(t *testing.T) {
 	ctx := context.Background()
-	apis, _ := ts.makeNodes(t, 2, OneMiner)
+	apis, _ := ts.makeNodes(t, 2, oneMiner)
 
 	p, err := apis[0].NetPeers(ctx)
 	if err != nil {

api/test/util.go

@@ -1,86 +0,0 @@
-package test
-
-import (
-	"context"
-	"testing"
-	"time"
-
-	"github.com/filecoin-project/go-state-types/abi"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/lotus/chain/types"
-	"github.com/filecoin-project/lotus/miner"
-)
-
-func SendFunds(ctx context.Context, t *testing.T, sender TestNode, addr address.Address, amount abi.TokenAmount) {
-	senderAddr, err := sender.WalletDefaultAddress(ctx)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	msg := &types.Message{
-		From:  senderAddr,
-		To:    addr,
-		Value: amount,
-	}
-
-	sm, err := sender.MpoolPushMessage(ctx, msg, nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-	res, err := sender.StateWaitMsg(ctx, sm.Cid(), 1)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if res.Receipt.ExitCode != 0 {
-		t.Fatal("did not successfully send money")
-	}
-}
-
-func MineUntilBlock(ctx context.Context, t *testing.T, fn TestNode, sn TestStorageNode, cb func(abi.ChainEpoch)) {
-	for i := 0; i < 1000; i++ {
-		var success bool
-		var err error
-		var epoch abi.ChainEpoch
-		wait := make(chan struct{})
-		mineErr := sn.MineOne(ctx, miner.MineReq{
-			Done: func(win bool, ep abi.ChainEpoch, e error) {
-				success = win
-				err = e
-				epoch = ep
-				wait <- struct{}{}
-			},
-		})
-		if mineErr != nil {
-			t.Fatal(mineErr)
-		}
-		<-wait
-		if err != nil {
-			t.Fatal(err)
-		}
-		if success {
-			// Wait until it shows up on the given full nodes ChainHead
-			nloops := 50
-			for i := 0; i < nloops; i++ {
-				ts, err := fn.ChainHead(ctx)
-				if err != nil {
-					t.Fatal(err)
-				}
-				if ts.Height() == epoch {
-					break
-				}
-				if i == nloops-1 {
-					t.Fatal("block never managed to sync to node")
-				}
-				time.Sleep(time.Millisecond * 10)
-			}
-
-			if cb != nil {
-				cb(epoch)
-			}
-			return
-		}
-		t.Log("did not mine block, trying again", i)
-	}
-	t.Fatal("failed to mine 1000 times in a row...")
-}

api/test/window_post.go

@@ -12,10 +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/sector-storage/mock"
+	"github.com/filecoin-project/specs-actors/actors/abi"
 	miner2 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
+	sealing "github.com/filecoin-project/storage-fsm"
 
 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/build"
@@ -24,16 +24,11 @@ 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)
+	n, sn := b(t, 1, oneMiner)
 	client := n[0].FullNode.(*impl.FullNodeAPI)
 	miner := sn[0]
 
@@ -49,11 +44,16 @@ func TestPledgeSector(t *testing.T, b APIBuilder, blocktime time.Duration, nSect
 
 	mine := true
 	done := make(chan struct{})
+	blockNotif := make(chan struct{}, 1)
 	go func() {
 		defer close(done)
 		for mine {
 			build.Clock.Sleep(blocktime)
-			if err := sn[0].MineOne(ctx, bminer.MineReq{Done: func(bool, abi.ChainEpoch, error) {
+			if err := sn[0].MineOne(ctx, bminer.MineReq{Done: func(bool, error) {
+				select {
+				case blockNotif <- struct{}{}:
+				default:
+				}
 
 			}}); err != nil {
 				t.Error(err)
@@ -61,7 +61,7 @@ func TestPledgeSector(t *testing.T, b APIBuilder, blocktime time.Duration, nSect
 		}
 	}()
 
-	pledgeSectors(t, ctx, miner, nSectors, 0, nil)
+	pledgeSectors(t, ctx, miner, nSectors, 0, blockNotif)
 
 	mine = false
 	<-done
@@ -115,8 +115,10 @@ 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)
+	n, sn := b(t, 1, oneMiner)
 	client := n[0].FullNode.(*impl.FullNodeAPI)
 	miner := sn[0]
 
@@ -216,10 +218,6 @@ func TestWindowPost(t *testing.T, b APIBuilder, blocktime time.Duration, nSector
 		sn, err := parts[0].Sectors.First()
 		require.NoError(t, err)
 
-		all, err := parts[0].Sectors.All(2)
-		require.NoError(t, err)
-		fmt.Println("the sectors", all)
-
 		s = abi.SectorID{
 			Miner:  abi.ActorID(mid),
 			Number: abi.SectorNumber(sn),

api/types.go

@@ -2,14 +2,9 @@ package api
 
 import (
 	"encoding/json"
-	"fmt"
-
 	"github.com/filecoin-project/go-address"
-	datatransfer "github.com/filecoin-project/go-data-transfer"
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/specs-actors/actors/abi"
 	"github.com/filecoin-project/specs-actors/actors/builtin/miner"
-	"github.com/ipfs/go-cid"
 
 	"github.com/libp2p/go-libp2p-core/peer"
 	pubsub "github.com/libp2p/go-libp2p-pubsub"
@@ -50,12 +45,11 @@ type PubsubScore struct {
 }
 
 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.
+	Owner                      address.Address // Must be an ID-address.
+	Worker                     address.Address // Must be an ID-address.
+	NewWorker                  address.Address // Must be an ID-address.
 	WorkerChangeEpoch          abi.ChainEpoch
-	PeerId                     *peer.ID
+	PeerId                     peer.ID
 	Multiaddrs                 []abi.Multiaddrs
 	SealProofType              abi.RegisteredSealProof
 	SectorSize                 abi.SectorSize
@@ -63,20 +57,12 @@ type MinerInfo struct {
 }
 
 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,
+		Owner:                      info.Owner,
+		Worker:                     info.Worker,
+		NewWorker:                  address.Undef,
+		WorkerChangeEpoch:          -1,
+		PeerId:                     peer.ID(info.PeerId),
 		Multiaddrs:                 info.Multiaddrs,
 		SealProofType:              info.SealProofType,
 		SectorSize:                 info.SectorSize,
@@ -90,64 +76,3 @@ func NewApiMinerInfo(info *miner.MinerInfo) MinerInfo {
 
 	return mi
 }
-
-type MessageSendSpec struct {
-	MaxFee abi.TokenAmount
-}
-
-var DefaultMessageSendSpec = MessageSendSpec{
-	// MaxFee of 0.1FIL
-	MaxFee: abi.NewTokenAmount(int64(build.FilecoinPrecision) / 10),
-}
-
-func (ms *MessageSendSpec) Get() MessageSendSpec {
-	if ms == nil {
-		return DefaultMessageSendSpec
-	}
-
-	return *ms
-}
-
-type DataTransferChannel struct {
-	TransferID  datatransfer.TransferID
-	Status      datatransfer.Status
-	BaseCID     cid.Cid
-	IsInitiator bool
-	IsSender    bool
-	Voucher     string
-	Message     string
-	OtherPeer   peer.ID
-	Transferred uint64
-}
-
-// NewDataTransferChannel constructs an API DataTransferChannel type from full channel state snapshot and a host id
-func NewDataTransferChannel(hostID peer.ID, channelState datatransfer.ChannelState) DataTransferChannel {
-	channel := DataTransferChannel{
-		TransferID: channelState.TransferID(),
-		Status:     channelState.Status(),
-		BaseCID:    channelState.BaseCID(),
-		IsSender:   channelState.Sender() == hostID,
-		Message:    channelState.Message(),
-	}
-	stringer, ok := channelState.Voucher().(fmt.Stringer)
-	if ok {
-		channel.Voucher = stringer.String()
-	} else {
-		voucherJSON, err := json.Marshal(channelState.Voucher())
-		if err != nil {
-			channel.Voucher = fmt.Errorf("Voucher Serialization: %w", err).Error()
-		} else {
-			channel.Voucher = string(voucherJSON)
-		}
-	}
-	if channel.IsSender {
-		channel.IsInitiator = !channelState.IsPull()
-		channel.Transferred = channelState.Sent()
-		channel.OtherPeer = channelState.Recipient()
-	} else {
-		channel.IsInitiator = channelState.IsPull()
-		channel.Transferred = channelState.Received()
-		channel.OtherPeer = channelState.Sender()
-	}
-	return channel
-}

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,6 +1,4 @@
-/dns4/bootstrap-0.testnet.fildev.network/tcp/1347/p2p/12D3KooWJTUBUjtzWJGWU1XSiY21CwmHaCNLNYn2E7jqHEHyZaP7
-/dns4/bootstrap-1.testnet.fildev.network/tcp/1347/p2p/12D3KooW9yeKXha4hdrJKq74zEo99T8DhriQdWNoojWnnQbsgB3v
-/dns4/bootstrap-2.testnet.fildev.network/tcp/1347/p2p/12D3KooWCrx8yVG9U9Kf7w8KLN3Edkj5ZKDhgCaeMqQbcQUoB6CT
-/dns4/bootstrap-4.testnet.fildev.network/tcp/1347/p2p/12D3KooWPkL9LrKRQgHtq7kn9ecNhGU9QaziG8R5tX8v9v7t3h34
-/dns4/bootstrap-3.testnet.fildev.network/tcp/1347/p2p/12D3KooWKYSsbpgZ3HAjax5M1BXCwXLa6gVkUARciz7uN3FNtr7T
-/dns4/bootstrap-5.testnet.fildev.network/tcp/1347/p2p/12D3KooWQYzqnLASJAabyMpPb1GcWZvNSe7JDcRuhdRqonFoiK9W
+/dns4/bootstrap-0.calibration.fildev.network/tcp/1347/p2p/12D3KooWPmhFGJkE7wDUdtzDYr7ReML9vgzJ8Tv7ubh9T6Le1Bmn
+/dns4/bootstrap-2.calibration.fildev.network/tcp/1347/p2p/12D3KooWPWUw5yEet6NWpxhxoibXFbLprG4k5PMLKLeubGBLf6nd
+/dns4/bootstrap-1.calibration.fildev.network/tcp/1347/p2p/12D3KooWGwv2YtXyYPrEKssttUT3TKZknPkCWKR6WVTvt9LW4hdf
+/dns4/bootstrap-3.calibration.fildev.network/tcp/1347/p2p/12D3KooWHgMU953YxD5skVG3RKa58TXwVL9z5ycGKrZdaFzGpouT

build/drand.go

@@ -1,32 +1,20 @@
 package build
 
-import (
-	"sort"
+import "github.com/filecoin-project/lotus/node/modules/dtypes"
 
-	"github.com/filecoin-project/lotus/node/modules/dtypes"
-)
+var DrandNetwork = DrandMainnet
+
+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
 	DrandDevnet
 	DrandLocalnet
-	DrandIncentinet
 )
 
 var DrandConfigs = map[DrandEnum]dtypes.DrandConfig{
@@ -67,17 +55,4 @@ var DrandConfigs = map[DrandEnum]dtypes.DrandConfig{
 		},
 		ChainInfoJSON: `{"public_key":"8cda589f88914aa728fd183f383980b35789ce81b274e5daee1f338b77d02566ef4d3fb0098af1f844f10f9c803c1827","period":25,"genesis_time":1595348225,"hash":"e73b7dc3c4f6a236378220c0dd6aa110eb16eed26c11259606e07ee122838d4f","groupHash":"567d4785122a5a3e75a9bc9911d7ea807dd85ff76b78dc4ff06b075712898607"}`,
 	},
-	DrandIncentinet: {
-		Servers: []string{
-			"https://pl-eu.incentinet.drand.sh",
-			"https://pl-us.incentinet.drand.sh",
-			"https://pl-sin.incentinet.drand.sh",
-		},
-		Relays: []string{
-			"/dnsaddr/pl-eu.incentinet.drand.sh/",
-			"/dnsaddr/pl-us.incentinet.drand.sh/",
-			"/dnsaddr/pl-sin.incentinet.drand.sh/",
-		},
-		ChainInfoJSON: `{"public_key":"8cad0c72c606ab27d36ee06de1d5b2db1faf92e447025ca37575ab3a8aac2eaae83192f846fc9e158bc738423753d000","period":30,"genesis_time":1595873820,"hash":"80c8b872c714f4c00fdd3daa465d5514049f457f01f85a4caf68cdcd394ba039","groupHash":"d9406aaed487f7af71851b4399448e311f2328923d454e971536c05398ce2d9b"}`,
-	},
 }

build/params_2k.go

@@ -3,22 +3,13 @@
 package build
 
 import (
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/go-state-types/big"
+	"github.com/filecoin-project/specs-actors/actors/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
-
-var DrandSchedule = map[abi.ChainEpoch]DrandEnum{
-	0: DrandMainnet,
-}
-
 func init() {
 	power.ConsensusMinerMinPower = big.NewInt(2048)
 	miner.SupportedProofTypes = map[abi.RegisteredSealProof]struct{}{
@@ -29,7 +20,7 @@ func init() {
 	BuildType |= Build2k
 }
 
-const BlockDelaySecs = uint64(30)
+const BlockDelaySecs = uint64(4)
 
 const PropagationDelaySecs = uint64(1)
 

build/params_shared_funcs.go

@@ -5,7 +5,7 @@ import (
 
 	"github.com/libp2p/go-libp2p-core/protocol"
 
-	"github.com/filecoin-project/go-state-types/abi"
+	"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"
@@ -36,11 +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 {
-		return true
-	}
-	return false
-}

build/params_shared_vals.go

@@ -5,9 +5,7 @@ package build
 import (
 	"math/big"
 
-	"github.com/filecoin-project/go-state-types/network"
-
-	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/specs-actors/actors/abi"
 	"github.com/filecoin-project/specs-actors/actors/builtin"
 	"github.com/filecoin-project/specs-actors/actors/builtin/miner"
 )
@@ -22,7 +20,6 @@ const UnixfsLinksPerLevel = 1024
 // Consensus / Network
 
 const AllowableClockDriftSecs = uint64(1)
-const NewestNetworkVersion = network.Version2
 
 // Epochs
 const ForkLengthThreshold = Finality
@@ -92,14 +89,11 @@ const VerifSigCacheSize = 32000
 
 // TODO: If this is gonna stay, it should move to specs-actors
 const BlockMessageLimit = 10000
-
 const BlockGasLimit = 10_000_000_000
 const BlockGasTarget = BlockGasLimit / 2
 const BaseFeeMaxChangeDenom = 8 // 12.5%
 const InitialBaseFee = 100e6
 const MinimumBaseFee = 100
-const PackingEfficiencyNum = 4
-const PackingEfficiencyDenom = 5
 
 // Actor consts
 // TODO: Pull from actors when its made not private

build/params_testground.go

@@ -10,8 +10,7 @@ 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/specs-actors/actors/builtin/miner"
 )
@@ -67,18 +66,4 @@ var (
 	// Actor consts
 	// TODO: Pull from actors when its made not private
 	MinDealDuration = abi.ChainEpoch(180 * builtin.EpochsInDay)
-
-	PackingEfficiencyNum   int64 = 4
-	PackingEfficiencyDenom int64 = 5
-
-	UpgradeBreezeHeight      abi.ChainEpoch = -1
-	BreezeGasTampingDuration abi.ChainEpoch = 0
-
-	UpgradeSmokeHeight abi.ChainEpoch = -1
-
-	DrandSchedule = map[abi.ChainEpoch]DrandEnum{
-		0: DrandMainnet,
-	}
-
-	NewestNetworkVersion = network.Version2
 )

build/params_testnet.go

@@ -5,28 +5,19 @@
 package build
 
 import (
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/go-state-types/big"
+	"github.com/filecoin-project/specs-actors/actors/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:                  DrandIncentinet,
-	UpgradeSmokeHeight: DrandMainnet,
-}
-
-const UpgradeBreezeHeight = 41280
-const BreezeGasTampingDuration = 120
-
-const UpgradeSmokeHeight = 51000
-
 func init() {
-	power.ConsensusMinerMinPower = big.NewInt(10 << 40)
+	power.ConsensusMinerMinPower = big.NewInt(512 << 30)
 	miner.SupportedProofTypes = map[abi.RegisteredSealProof]struct{}{
-		abi.RegisteredSealProof_StackedDrg32GiBV1: {},
-		abi.RegisteredSealProof_StackedDrg64GiBV1: {},
+		abi.RegisteredSealProof_StackedDrg512MiBV1: {},
+		abi.RegisteredSealProof_StackedDrg32GiBV1:  {},
+		abi.RegisteredSealProof_StackedDrg64GiBV1:  {},
 	}
 }
 

build/proof-params/parameters.json

@@ -1,152 +1,152 @@
 {
-  "v28-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-0-0-0170db1f394b35d995252228ee359194b13199d259380541dc529fb0099096b0.params": {
-    "cid": "QmVxjFRyhmyQaZEtCh7nk2abc7LhFkzhnRX4rcHqCCpikR",
-    "digest": "7610b9f82bfc88405b7a832b651ce2f6",
+  "v27-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-0-0-0170db1f394b35d995252228ee359194b13199d259380541dc529fb0099096b0.params": {
+    "cid": "QmeDRyxek34F1H6xJY6AkFdWvPsy5F6dKTrebV3ZtWT4ky",
+    "digest": "f5827f2d8801c62c831e0f972f6dc8bb",
     "sector_size": 2048
   },
-  "v28-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-0-0-0170db1f394b35d995252228ee359194b13199d259380541dc529fb0099096b0.vk": {
-    "cid": "QmcS5JZs8X3TdtkEBpHAdUYjdNDqcL7fWQFtQz69mpnu2X",
-    "digest": "0e0958009936b9d5e515ec97b8cb792d",
+  "v27-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-0-0-0170db1f394b35d995252228ee359194b13199d259380541dc529fb0099096b0.vk": {
+    "cid": "QmUw1ZmG4BBbX19MsbH3zAEGKUc42iFJc5ZAyomDHeJTsA",
+    "digest": "398fecdb4b2de445125852bc3c080b35",
     "sector_size": 2048
   },
-  "v28-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-0-0-0cfb4f178bbb71cf2ecfcd42accce558b27199ab4fb59cb78f2483fe21ef36d9.params": {
-    "cid": "QmUiRx71uxfmUE8V3H9sWAsAXoM88KR4eo1ByvvcFNeTLR",
-    "digest": "1a7d4a9c8a502a497ed92a54366af33f",
+  "v27-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-0-0-0cfb4f178bbb71cf2ecfcd42accce558b27199ab4fb59cb78f2483fe21ef36d9.params": {
+    "cid": "QmUeNKp9YZpiAFm81RV5KuxH1FDGJx2DuwcbU2XNSZLLSv",
+    "digest": "2b6d2972ac9e862e8134d98fb695b0c5",
     "sector_size": 536870912
   },
-  "v28-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-0-0-0cfb4f178bbb71cf2ecfcd42accce558b27199ab4fb59cb78f2483fe21ef36d9.vk": {
-    "cid": "QmfCeddjFpWtavzfEzZpJfzSajGNwfL4RjFXWAvA9TSnTV",
-    "digest": "4dae975de4f011f101f5a2f86d1daaba",
+  "v27-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-0-0-0cfb4f178bbb71cf2ecfcd42accce558b27199ab4fb59cb78f2483fe21ef36d9.vk": {
+    "cid": "QmQaQmTXX995Akd66ggtJY5bNx6Gkxk8P34JTdMMq8393G",
+    "digest": "3688c9eb256b7b17f411dad78d5ef74a",
     "sector_size": 536870912
   },
-  "v28-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-0-0-3ea05428c9d11689f23529cde32fd30aabd50f7d2c93657c1d3650bca3e8ea9e.params": {
-    "cid": "QmcSTqDcFVLGGVYz1njhUZ7B6fkKtBumsLUwx4nkh22TzS",
-    "digest": "82c88066be968bb550a05e30ff6c2413",
+  "v27-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-0-0-3ea05428c9d11689f23529cde32fd30aabd50f7d2c93657c1d3650bca3e8ea9e.params": {
+    "cid": "QmfEYTMSkwGJTumQx26iKXGNKiYh3mmAC4SkdybZpJCj5p",
+    "digest": "09bff16aed893349d94485cfae366a9c",
     "sector_size": 2048
   },
-  "v28-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-0-0-3ea05428c9d11689f23529cde32fd30aabd50f7d2c93657c1d3650bca3e8ea9e.vk": {
-    "cid": "QmSTCXF2ipGA3f6muVo6kHc2URSx6PzZxGUqu7uykaH5KU",
-    "digest": "ffd79788d614d27919ae5bd2d94eacb6",
+  "v27-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-0-0-3ea05428c9d11689f23529cde32fd30aabd50f7d2c93657c1d3650bca3e8ea9e.vk": {
+    "cid": "QmP4ThPieSUJyRanjibWpT5R5cCMzMAU4j8Y7kBn7CSW1Q",
+    "digest": "142f2f7e8f1b1779290315cabfd2c803",
     "sector_size": 2048
   },
-  "v28-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-0-0-50c7368dea9593ed0989e70974d28024efa9d156d585b7eea1be22b2e753f331.params": {
-    "cid": "QmU9SBzJNrcjRFDiFc4GcApqdApN6z9X7MpUr66mJ2kAJP",
-    "digest": "700171ecf7334e3199437c930676af82",
+  "v27-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-0-0-50c7368dea9593ed0989e70974d28024efa9d156d585b7eea1be22b2e753f331.params": {
+    "cid": "QmcAixrHsz29DgvtZiMc2kQjvPRvWxYUp36QYmRDZbmREm",
+    "digest": "8f987f64d434365562180b96ec12e299",
     "sector_size": 8388608
   },
-  "v28-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-0-0-50c7368dea9593ed0989e70974d28024efa9d156d585b7eea1be22b2e753f331.vk": {
-    "cid": "QmbmUMa3TbbW3X5kFhExs6WgC4KeWT18YivaVmXDkB6ANG",
-    "digest": "79ebb55f56fda427743e35053edad8fc",
+  "v27-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-0-0-50c7368dea9593ed0989e70974d28024efa9d156d585b7eea1be22b2e753f331.vk": {
+    "cid": "QmT4iFnbL6r4txS5PXsiV7NTzbhCxHy54PvdkJJGV2VFXb",
+    "digest": "94b6c24ac01924f4feeecedd16b5d77d",
     "sector_size": 8388608
   },
-  "v28-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-0-0-5294475db5237a2e83c3e52fd6c2b03859a1831d45ed08c4f35dbf9a803165a9.params": {
-    "cid": "QmdNEL2RtqL52GQNuj8uz6mVj5Z34NVnbaJ1yMyh1oXtBx",
-    "digest": "c49499bb76a0762884896f9683403f55",
+  "v27-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-0-0-5294475db5237a2e83c3e52fd6c2b03859a1831d45ed08c4f35dbf9a803165a9.params": {
+    "cid": "QmbjFst6SFCK1KsTQrfwPdxf3VTNa1raed574tEZZ9PoyQ",
+    "digest": "2c245fe8179839dd6c6cdea207c67ae8",
     "sector_size": 8388608
   },
-  "v28-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-0-0-5294475db5237a2e83c3e52fd6c2b03859a1831d45ed08c4f35dbf9a803165a9.vk": {
-    "cid": "QmUiVYCQUgr6Y13pZFr8acWpSM4xvTXUdcvGmxyuHbKhsc",
-    "digest": "34d4feeacd9abf788d69ef1bb4d8fd00",
+  "v27-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-0-0-5294475db5237a2e83c3e52fd6c2b03859a1831d45ed08c4f35dbf9a803165a9.vk": {
+    "cid": "QmQJKmvZN1a5cQ1Nw6CDyXs3nuRPzvyU5NvCFMUL2BfcZC",
+    "digest": "56ae47bfda53bb8d22981ed8d8d27d72",
     "sector_size": 8388608
   },
-  "v28-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-0-0-7d739b8cf60f1b0709eeebee7730e297683552e4b69cab6984ec0285663c5781.params": {
-    "cid": "QmVgCsJFRXKLuuUhT3aMYwKVGNA9rDeR6DCrs7cAe8riBT",
-    "digest": "827359440349fe8f5a016e7598993b79",
+  "v27-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-0-0-7d739b8cf60f1b0709eeebee7730e297683552e4b69cab6984ec0285663c5781.params": {
+    "cid": "QmQCABxeTpdvXTyjDyk7nPBxkQzCh7MXfGztWnSXEPKMLW",
+    "digest": "7e6b2eb5ecbb11ac651ad66ebbb2075a",
     "sector_size": 536870912
   },
-  "v28-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-0-0-7d739b8cf60f1b0709eeebee7730e297683552e4b69cab6984ec0285663c5781.vk": {
-    "cid": "QmfA31fbCWojSmhSGvvfxmxaYCpMoXP95zEQ9sLvBGHNaN",
-    "digest": "bd2cd62f65c1ab84f19ca27e97b7c731",
+  "v27-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-0-0-7d739b8cf60f1b0709eeebee7730e297683552e4b69cab6984ec0285663c5781.vk": {
+    "cid": "QmPBweyugh5Sx4umk8ULhgEGbjY8xmWLfU6M7EMpc8Mad6",
+    "digest": "94a8d9e25a9ab9674d339833664eba25",
     "sector_size": 536870912
   },
-  "v28-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-8-0-0377ded656c6f524f1618760bffe4e0a1c51d5a70c4509eedae8a27555733edc.params": {
-    "cid": "QmaUmfcJt6pozn8ndq1JVBzLRjRJdHMTPd4foa8iw5sjBZ",
-    "digest": "2cf49eb26f1fee94c85781a390ddb4c8",
+  "v27-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-8-0-0377ded656c6f524f1618760bffe4e0a1c51d5a70c4509eedae8a27555733edc.params": {
+    "cid": "QmY5yax1E9KymBnCeHksE9Zi8NieZbmwcpoDGoabkeeb9h",
+    "digest": "c909ea9e3fe25ab9b391a64593afdbba",
     "sector_size": 34359738368
   },
-  "v28-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-8-0-0377ded656c6f524f1618760bffe4e0a1c51d5a70c4509eedae8a27555733edc.vk": {
-    "cid": "QmR9i9KL3vhhAqTBGj1bPPC7LvkptxrH9RvxJxLN1vvsBE",
-    "digest": "0f8ec542485568fa3468c066e9fed82b",
+  "v27-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-8-0-0377ded656c6f524f1618760bffe4e0a1c51d5a70c4509eedae8a27555733edc.vk": {
+    "cid": "QmXnPo4yH5mwMguwrvqgRfduSttbmPrXtbBfbwU21wQWHt",
+    "digest": "caf900461e988bbf86dbcaca087b7864",
     "sector_size": 34359738368
   },
-  "v28-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-8-0-559e581f022bb4e4ec6e719e563bf0e026ad6de42e56c18714a2c692b1b88d7e.params": {
-    "cid": "Qmdtczp7p4wrbDofmHdGhiixn9irAcN77mV9AEHZBaTt1i",
-    "digest": "d84f79a16fe40e9e25a36e2107bb1ba0",
+  "v27-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-8-0-559e581f022bb4e4ec6e719e563bf0e026ad6de42e56c18714a2c692b1b88d7e.params": {
+    "cid": "QmZtzzPWwmZEgR7MSMvXRbt9KVK8k4XZ5RLWHybHJW9SdE",
+    "digest": "a2844f0703f186d143a06146a04577d8",
     "sector_size": 34359738368
   },
-  "v28-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-8-0-559e581f022bb4e4ec6e719e563bf0e026ad6de42e56c18714a2c692b1b88d7e.vk": {
-    "cid": "QmZCvxKcKP97vDAk8Nxs9R1fWtqpjQrAhhfXPoCi1nkDoF",
-    "digest": "fc02943678dd119e69e7fab8420e8819",
+  "v27-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-8-0-559e581f022bb4e4ec6e719e563bf0e026ad6de42e56c18714a2c692b1b88d7e.vk": {
+    "cid": "QmWxEA7EdQCUJTzjNpxg5XTF45D2uVyYnN1QRUb5TRYU8M",
+    "digest": "2306247a1e616dbe07f01b88196c2044",
     "sector_size": 34359738368
   },
-  "v28-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-8-2-2627e4006b67f99cef990c0a47d5426cb7ab0a0ad58fc1061547bf2d28b09def.params": {
-    "cid": "QmeAN4vuANhXsF8xP2Lx5j2L6yMSdogLzpcvqCJThRGK1V",
-    "digest": "3810b7780ac0e299b22ae70f1f94c9bc",
+  "v27-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-8-2-2627e4006b67f99cef990c0a47d5426cb7ab0a0ad58fc1061547bf2d28b09def.params": {
+    "cid": "QmP676KwuvyF9Y64uJnXvLtvD1xcuWQ6wD23RzYtQ6dd4f",
+    "digest": "215b1c667a4f46a1d0178338df568615",
     "sector_size": 68719476736
   },
-  "v28-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-8-2-2627e4006b67f99cef990c0a47d5426cb7ab0a0ad58fc1061547bf2d28b09def.vk": {
-    "cid": "QmWV8rqZLxs1oQN9jxNWmnT1YdgLwCcscv94VARrhHf1T7",
-    "digest": "59d2bf1857adc59a4f08fcf2afaa916b",
+  "v27-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-8-2-2627e4006b67f99cef990c0a47d5426cb7ab0a0ad58fc1061547bf2d28b09def.vk": {
+    "cid": "QmPvPwbJtcSGyqB1rQJhSF5yvFbX9ZBSsHVej5F8JUyHUJ",
+    "digest": "0c9c423b28b1455fcbc329a1045fd4dd",
     "sector_size": 68719476736
   },
-  "v28-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-8-2-b62098629d07946e9028127e70295ed996fe3ed25b0f9f88eb610a0ab4385a3c.params": {
-    "cid": "QmVkrXc1SLcpgcudK5J25HH93QvR9tNsVhVTYHm5UymXAz",
-    "digest": "2170a91ad5bae22ea61f2ea766630322",
+  "v27-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-8-2-b62098629d07946e9028127e70295ed996fe3ed25b0f9f88eb610a0ab4385a3c.params": {
+    "cid": "QmUxPQfvckzm1t6MFRdDZ1fDK5UJzAjK7pTZ97cwyachdr",
+    "digest": "965132f51ae445b0e6d32692b7561995",
     "sector_size": 68719476736
   },
-  "v28-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-8-2-b62098629d07946e9028127e70295ed996fe3ed25b0f9f88eb610a0ab4385a3c.vk": {
-    "cid": "QmbfQjPD7EpzjhWGmvWAsyN2mAZ4PcYhsf3ujuhU9CSuBm",
-    "digest": "6d3789148fb6466d07ee1e24d6292fd6",
+  "v27-proof-of-spacetime-fallback-merkletree-poseidon_hasher-8-8-2-b62098629d07946e9028127e70295ed996fe3ed25b0f9f88eb610a0ab4385a3c.vk": {
+    "cid": "QmTxq2EBnQWb5R8tS4MHdchj4vNfLYGoSXxwJFvs5xgW4K",
+    "digest": "fc8c3d26e0e56373ad96cb41520d55a6",
     "sector_size": 68719476736
   },
-  "v28-stacked-proof-of-replication-merkletree-poseidon_hasher-8-0-0-sha256_hasher-032d3138d22506ec0082ed72b2dcba18df18477904e35bafee82b3793b06832f.params": {
-    "cid": "QmWceMgnWYLopMuM4AoGMvGEau7tNe5UK83XFjH5V9B17h",
-    "digest": "434fb1338ecfaf0f59256f30dde4968f",
+  "v27-stacked-proof-of-replication-merkletree-poseidon_hasher-8-0-0-sha256_hasher-032d3138d22506ec0082ed72b2dcba18df18477904e35bafee82b3793b06832f.params": {
+    "cid": "QmRjgZHERgqGoRagR788Kh6ybi26csVYa8mqbqhmZm57Jx",
+    "digest": "cfc7b0897d1eee48c586f7beb89e67f7",
     "sector_size": 2048
   },
-  "v28-stacked-proof-of-replication-merkletree-poseidon_hasher-8-0-0-sha256_hasher-032d3138d22506ec0082ed72b2dcba18df18477904e35bafee82b3793b06832f.vk": {
-    "cid": "QmamahpFCstMUqHi2qGtVoDnRrsXhid86qsfvoyCTKJqHr",
-    "digest": "dc1ade9929ade1708238f155343044ac",
+  "v27-stacked-proof-of-replication-merkletree-poseidon_hasher-8-0-0-sha256_hasher-032d3138d22506ec0082ed72b2dcba18df18477904e35bafee82b3793b06832f.vk": {
+    "cid": "QmNjvnvFP7KgovHUddULoB19fBHT81iz7NcUbzEHZUUPsm",
+    "digest": "fb59bd061c987eac7068008c44de346b",
     "sector_size": 2048
   },
-  "v28-stacked-proof-of-replication-merkletree-poseidon_hasher-8-0-0-sha256_hasher-6babf46ce344ae495d558e7770a585b2382d54f225af8ed0397b8be7c3fcd472.params": {
-    "cid": "QmYBpTt7LWNAWr1JXThV5VxX7wsQFLd1PHrGYVbrU1EZjC",
-    "digest": "6c77597eb91ab936c1cef4cf19eba1b3",
+  "v27-stacked-proof-of-replication-merkletree-poseidon_hasher-8-0-0-sha256_hasher-6babf46ce344ae495d558e7770a585b2382d54f225af8ed0397b8be7c3fcd472.params": {
+    "cid": "QmTpRPBA4dt8fgGpcVzi4L1KA1U2eBHCE8WVmS2GUygMvT",
+    "digest": "36d465915b0afbf96bd08e7915e00952",
     "sector_size": 536870912
   },
-  "v28-stacked-proof-of-replication-merkletree-poseidon_hasher-8-0-0-sha256_hasher-6babf46ce344ae495d558e7770a585b2382d54f225af8ed0397b8be7c3fcd472.vk": {
-    "cid": "QmWionkqH2B6TXivzBSQeSyBxojaiAFbzhjtwYRrfwd8nH",
-    "digest": "065179da19fbe515507267677f02823e",
+  "v27-stacked-proof-of-replication-merkletree-poseidon_hasher-8-0-0-sha256_hasher-6babf46ce344ae495d558e7770a585b2382d54f225af8ed0397b8be7c3fcd472.vk": {
+    "cid": "QmRzDyVfQCLsxspoVsed5bcQRsG6KiktngJfcNBL3TJPZe",
+    "digest": "99d16df0eb6a7e227a4f4570c4f6b6f1",
     "sector_size": 536870912
   },
-  "v28-stacked-proof-of-replication-merkletree-poseidon_hasher-8-0-0-sha256_hasher-ecd683648512ab1765faa2a5f14bab48f676e633467f0aa8aad4b55dcb0652bb.params": {
-    "cid": "QmPXAPPuQtuQz7Zz3MHMAMEtsYwqM1o9H1csPLeiMUQwZH",
-    "digest": "09e612e4eeb7a0eb95679a88404f960c",
+  "v27-stacked-proof-of-replication-merkletree-poseidon_hasher-8-0-0-sha256_hasher-ecd683648512ab1765faa2a5f14bab48f676e633467f0aa8aad4b55dcb0652bb.params": {
+    "cid": "QmV8ZjTSGzDUWmFvsq9NSyPBR7eDDUcvCPNgj2yE7HMAFu",
+    "digest": "34f3ddf1d1c9f41c0cd73b91e8b4bc27",
     "sector_size": 8388608
   },
-  "v28-stacked-proof-of-replication-merkletree-poseidon_hasher-8-0-0-sha256_hasher-ecd683648512ab1765faa2a5f14bab48f676e633467f0aa8aad4b55dcb0652bb.vk": {
-    "cid": "QmYCuipFyvVW1GojdMrjK1JnMobXtT4zRCZs1CGxjizs99",
-    "digest": "b687beb9adbd9dabe265a7e3620813e4",
+  "v27-stacked-proof-of-replication-merkletree-poseidon_hasher-8-0-0-sha256_hasher-ecd683648512ab1765faa2a5f14bab48f676e633467f0aa8aad4b55dcb0652bb.vk": {
+    "cid": "QmTa3VbjTiqJWU6r4WKayaQrUaaBsrpp5UDqYvPDd2C5hs",
+    "digest": "ec62d59651daa5631d3d1e9c782dd940",
     "sector_size": 8388608
   },
-  "v28-stacked-proof-of-replication-merkletree-poseidon_hasher-8-8-0-sha256_hasher-82a357d2f2ca81dc61bb45f4a762807aedee1b0a53fd6c4e77b46a01bfef7820.params": {
-    "cid": "QmengpM684XLQfG8754ToonszgEg2bQeAGUan5uXTHUQzJ",
-    "digest": "6a388072a518cf46ebd661f5cc46900a",
+  "v27-stacked-proof-of-replication-merkletree-poseidon_hasher-8-8-0-sha256_hasher-82a357d2f2ca81dc61bb45f4a762807aedee1b0a53fd6c4e77b46a01bfef7820.params": {
+    "cid": "Qmf8ngfArxrv9tFWDqBcNegdBMymvuakwyHKd1pbW3pbsb",
+    "digest": "a16d6f4c6424fb280236739f84b24f97",
     "sector_size": 34359738368
   },
-  "v28-stacked-proof-of-replication-merkletree-poseidon_hasher-8-8-0-sha256_hasher-82a357d2f2ca81dc61bb45f4a762807aedee1b0a53fd6c4e77b46a01bfef7820.vk": {
-    "cid": "Qmf93EMrADXAK6CyiSfE8xx45fkMfR3uzKEPCvZC1n2kzb",
-    "digest": "0c7b4aac1c40fdb7eb82bc355b41addf",
+  "v27-stacked-proof-of-replication-merkletree-poseidon_hasher-8-8-0-sha256_hasher-82a357d2f2ca81dc61bb45f4a762807aedee1b0a53fd6c4e77b46a01bfef7820.vk": {
+    "cid": "QmfQgVFerArJ6Jupwyc9tKjLD9n1J9ajLHBdpY465tRM7M",
+    "digest": "7a139d82b8a02e35279d657e197f5c1f",
     "sector_size": 34359738368
   },
-  "v28-stacked-proof-of-replication-merkletree-poseidon_hasher-8-8-2-sha256_hasher-96f1b4a04c5c51e4759bbf224bbc2ef5a42c7100f16ec0637123f16a845ddfb2.params": {
-    "cid": "QmS7ye6Ri2MfFzCkcUJ7FQ6zxDKuJ6J6B8k5PN7wzSR9sX",
-    "digest": "1801f8a6e1b00bceb00cc27314bb5ce3",
+  "v27-stacked-proof-of-replication-merkletree-poseidon_hasher-8-8-2-sha256_hasher-96f1b4a04c5c51e4759bbf224bbc2ef5a42c7100f16ec0637123f16a845ddfb2.params": {
+    "cid": "QmfDha8271nXJn14Aq3qQeghjMBWbs6HNSGa6VuzCVk4TW",
+    "digest": "5d3cd3f107a3bea8a96d1189efd2965c",
     "sector_size": 68719476736
   },
-  "v28-stacked-proof-of-replication-merkletree-poseidon_hasher-8-8-2-sha256_hasher-96f1b4a04c5c51e4759bbf224bbc2ef5a42c7100f16ec0637123f16a845ddfb2.vk": {
-    "cid": "QmehSmC6BhrgRZakPDta2ewoH9nosNzdjCqQRXsNFNUkLN",
-    "digest": "a89884252c04c298d0b3c81bfd884164",
+  "v27-stacked-proof-of-replication-merkletree-poseidon_hasher-8-8-2-sha256_hasher-96f1b4a04c5c51e4759bbf224bbc2ef5a42c7100f16ec0637123f16a845ddfb2.vk": {
+    "cid": "QmRVtTtiFzHJTHurYzaCvetGAchux9cktixT4aGHthN6Zt",
+    "digest": "62c366405404e60f171e661492740b1c",
     "sector_size": 68719476736
   }
-}
+}

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.6.2"
+const BuildVersion = "0.4.3"
 
 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, 14, 0)
-	MinerAPIVersion  = newVer(0, 14, 0)
-	WorkerAPIVersion = newVer(0, 14, 0)
-)
+// APIVersion is a semver version of the rpc api exposed
+var APIVersion Version = newVer(0, 9, 0)
 
 //nolint:varcheck,deadcode
 const (

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/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"
@@ -171,10 +171,6 @@ func (db *DrandBeacon) VerifyEntry(curr types.BeaconEntry, prev types.BeaconEntr
 		// TODO handle genesis better
 		return nil
 	}
-	if be := db.getCachedValue(curr.Round); be != nil {
-		// return no error if the value is in the cache already
-		return nil
-	}
 	b := &dchain.Beacon{
 		PreviousSig: prev.Data,
 		Round:       curr.Round,
@@ -187,7 +183,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,12 +1,12 @@
 // 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"
+	"github.com/filecoin-project/lotus/chain/types"
 	cid "github.com/ipfs/go-cid"
 	cbg "github.com/whyrusleeping/cbor-gen"
 	xerrors "golang.org/x/xerrors"
@@ -625,14 +625,16 @@ func (t *BSTipSet) UnmarshalCBOR(r io.Reader) error {
 
 	{
 
-		b, err := br.ReadByte()
+		pb, err := br.PeekByte()
 		if err != nil {
 			return err
 		}
-		if b != cbg.CborNull[0] {
-			if err := br.UnreadByte(); err != nil {
+		if pb == cbg.CborNull[0] {
+			var nbuf [1]byte
+			if _, err := br.Read(nbuf[:]); err != nil {
 				return err
 			}
+		} else {
 			t.Messages = new(CompactedMessages)
 			if err := t.Messages.UnmarshalCBOR(br); err != nil {
 				return xerrors.Errorf("unmarshaling t.Messages pointer: %w", err)

chain/blocksync/client.go

@@ -1,4 +1,4 @@
-package exchange
+package blocksync
 
 import (
 	"bufio"
@@ -7,16 +7,13 @@ import (
 	"math/rand"
 	"time"
 
-	"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"
@@ -24,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*
@@ -36,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),
 	}
 }
 
@@ -64,7 +62,11 @@ 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(ctx context.Context, req *Request, singlePeer *peer.ID) (*validatedResponse, error) {
+func (client *BlockSync) doRequest(
+	ctx context.Context,
+	req *Request,
+	singlePeer *peer.ID,
+) (*validatedResponse, error) {
 	// Validate request.
 	if req.Length == 0 {
 		return nil, xerrors.Errorf("invalid request of length 0")
@@ -84,7 +86,7 @@ func (c *client) doRequest(ctx context.Context, req *Request, singlePeer *peer.I
 	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")
 		}
@@ -105,9 +107,9 @@ func (c *client) doRequest(ctx context.Context, req *Request, singlePeer *peer.I
 		}
 
 		// 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)
 			}
@@ -115,15 +117,15 @@ func (c *client) doRequest(ctx context.Context, req *Request, singlePeer *peer.I
 		}
 
 		// Process and validate response.
-		validRes, err := c.processResponse(req, res)
+		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
 	}
 
@@ -142,8 +144,11 @@ func (c *client) doRequest(ctx context.Context, req *Request, singlePeer *peer.I
 // We are conflating in the single error returned both status and validation
 // errors. Peer penalization should happen here then, before returning, so
 // we can apply the correct penalties depending on the cause of the error.
-// FIXME: Add the `peer` as argument once we implement penalties.
-func (c *client) processResponse(req *Request, res *Response) (*validatedResponse, error) {
+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)
@@ -167,7 +172,7 @@ func (c *client) processResponse(req *Request, res *Response) (*validatedRespons
 			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{}
@@ -200,7 +205,7 @@ func (c *client) processResponse(req *Request, res *Response) (*validatedRespons
 		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
 		}
@@ -241,8 +246,16 @@ func (c *client) processResponse(req *Request, res *Response) (*validatedRespons
 	return validRes, nil
 }
 
-// GetBlocks implements Client.GetBlocks(). Refer to the godocs there.
-func (c *client) GetBlocks(ctx context.Context, tsk types.TipSetKey, count int) ([]*types.TipSet, error) {
+// 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() {
@@ -258,7 +271,7 @@ func (c *client) GetBlocks(ctx context.Context, tsk types.TipSetKey, count int)
 		Options: Headers,
 	}
 
-	validRes, err := c.doRequest(ctx, req, nil)
+	validRes, err := client.doRequest(ctx, req, nil)
 	if err != nil {
 		return nil, err
 	}
@@ -266,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{
@@ -276,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)
+	validRes, err := client.doRequest(ctx, req, &peer)
 	if err != nil {
 		return nil, err
 	}
@@ -286,15 +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, head *types.TipSet, length uint64) ([]*CompactedMessages, error) {
+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{
@@ -303,7 +316,7 @@ func (c *client) GetChainMessages(ctx context.Context, head *types.TipSet, lengt
 		Options: Messages,
 	}
 
-	validRes, err := c.doRequest(ctx, req, nil)
+	validRes, err := client.doRequest(ctx, req, nil)
 	if err != nil {
 		return nil, err
 	}
@@ -314,7 +327,11 @@ func (c *client) GetChainMessages(ctx context.Context, head *types.TipSet, lengt
 // 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()
@@ -335,33 +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)
 	}
 
 	// 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
 	}
@@ -371,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, err
 	}
 
 	// FIXME: Move all this together at the top using a defer as done elsewhere.
@@ -388,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  = 5
-	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:

chain/blocksync/server.go

@@ -1,4 +1,4 @@
-package exchange
+package blocksync
 
 import (
 	"bufio"
@@ -18,25 +18,38 @@ import (
 	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()
 
 	defer stream.Close() //nolint:errcheck
@@ -49,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",
@@ -67,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
@@ -75,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{}
@@ -128,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{
@@ -152,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
@@ -196,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)
@@ -233,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)

chain/events/events_height.go

@@ -4,9 +4,8 @@ import (
 	"context"
 	"sync"
 
-	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/specs-actors/actors/abi"
 	"go.opencensus.io/trace"
-	"golang.org/x/xerrors"
 
 	"github.com/filecoin-project/lotus/chain/types"
 )
@@ -153,12 +152,8 @@ func (e *heightEvents) ChainAt(hnd HeightHandler, rev RevertHandler, confidence
 
 	e.lk.Lock() // Tricky locking, check your locks if you modify this function!
 
-	best, err := e.tsc.best()
-	if err != nil {
-		return xerrors.Errorf("error getting best tipset: %w", err)
-	}
+	bestH := e.tsc.best().Height()
 
-	bestH := best.Height()
 	if bestH >= h+abi.ChainEpoch(confidence) {
 		ts, err := e.tsc.getNonNull(h)
 		if err != nil {
@@ -177,11 +172,7 @@ func (e *heightEvents) ChainAt(hnd HeightHandler, rev RevertHandler, confidence
 		}
 
 		e.lk.Lock()
-		best, err = e.tsc.best()
-		if err != nil {
-			return xerrors.Errorf("error getting best tipset: %w", err)
-		}
-		bestH = best.Height()
+		bestH = e.tsc.best().Height()
 	}
 
 	defer e.lk.Unlock()

chain/events/events_test.go

@@ -11,8 +11,8 @@ import (
 	"github.com/stretchr/testify/require"
 
 	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/go-state-types/crypto"
+	"github.com/filecoin-project/specs-actors/actors/abi"
+	"github.com/filecoin-project/specs-actors/actors/crypto"
 
 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/build"
@@ -46,10 +46,6 @@ type fakeCS struct {
 	sub func(rev, app []*types.TipSet)
 }
 
-func (fcs *fakeCS) ChainHead(ctx context.Context) (*types.TipSet, error) {
-	panic("implement me")
-}
-
 func (fcs *fakeCS) ChainGetTipSet(ctx context.Context, key types.TipSetKey) (*types.TipSet, error) {
 	return fcs.tipsets[key], nil
 }
@@ -114,11 +110,7 @@ func (fcs *fakeCS) makeTs(t *testing.T, parents []cid.Cid, h abi.ChainEpoch, msg
 
 func (fcs *fakeCS) ChainNotify(context.Context) (<-chan []*api.HeadChange, error) {
 	out := make(chan []*api.HeadChange, 1)
-	best, err := fcs.tsc.best()
-	if err != nil {
-		return nil, err
-	}
-	out <- []*api.HeadChange{{Type: store.HCCurrent, Val: best}}
+	out <- []*api.HeadChange{{Type: store.HCCurrent, Val: fcs.tsc.best()}}
 
 	fcs.sub = func(rev, app []*types.TipSet) {
 		notif := make([]*api.HeadChange, len(rev)+len(app))
@@ -182,8 +174,7 @@ func (fcs *fakeCS) advance(rev, app int, msgs map[int]cid.Cid, nulls ...int) { /
 
 	var revs []*types.TipSet
 	for i := 0; i < rev; i++ {
-		ts, err := fcs.tsc.best()
-		require.NoError(fcs.t, err)
+		ts := fcs.tsc.best()
 
 		if _, ok := nullm[int(ts.Height())]; !ok {
 			revs = append(revs, ts)
@@ -205,9 +196,7 @@ func (fcs *fakeCS) advance(rev, app int, msgs map[int]cid.Cid, nulls ...int) { /
 			continue
 		}
 
-		best, err := fcs.tsc.best()
-		require.NoError(fcs.t, err)
-		ts := fcs.makeTs(fcs.t, best.Key().Cids(), fcs.h, mc)
+		ts := fcs.makeTs(fcs.t, fcs.tsc.best().Key().Cids(), fcs.h, mc)
 		require.NoError(fcs.t, fcs.tsc.add(ts))
 
 		if hasMsgs {

chain/events/state/diff_adt.go

@@ -1,8 +1,6 @@
 package state
 
 import (
-	"bytes"
-
 	"github.com/filecoin-project/specs-actors/actors/util/adt"
 	typegen "github.com/whyrusleeping/cbor-gen"
 )
@@ -41,11 +39,8 @@ func DiffAdtArray(preArr, curArr *adt.Array, out AdtArrayDiff) error {
 			return nil
 		}
 
-		// no modification
-		if !bytes.Equal(prevVal.Raw, curVal.Raw) {
-			if err := out.Modify(uint64(i), prevVal, curVal); err != nil {
-				return err
-			}
+		if err := out.Modify(uint64(i), prevVal, curVal); err != nil {
+			return err
 		}
 
 		return curArr.Delete(uint64(i))
@@ -95,11 +90,8 @@ func DiffAdtMap(preMap, curMap *adt.Map, out AdtMapDiff) error {
 			return nil
 		}
 
-		// no modification
-		if !bytes.Equal(prevVal.Raw, curVal.Raw) {
-			if err := out.Modify(key, prevVal, curVal); err != nil {
-				return err
-			}
+		if err := out.Modify(key, prevVal, curVal); err != nil {
+			return err
 		}
 
 		return curMap.Delete(k)

chain/events/state/diff_adt_test.go

@@ -40,7 +40,7 @@ func TestDiffAdtArray(t *testing.T) {
 	require.NoError(t, arrB.Set(5, runtime.CBORBytes{8})) // add
 	require.NoError(t, arrB.Set(6, runtime.CBORBytes{9})) // add
 
-	changes := new(TestDiffArray)
+	changes := new(TestAdtDiff)
 
 	assert.NoError(t, DiffAdtArray(arrA, arrB, changes))
 	assert.NotNil(t, changes)
@@ -71,186 +71,38 @@ func TestDiffAdtArray(t *testing.T) {
 	assert.EqualValues(t, []byte{1}, changes.Removed[1].val)
 }
 
-func TestDiffAdtMap(t *testing.T) {
-	ctxstoreA := newContextStore()
-	ctxstoreB := newContextStore()
-
-	mapA := adt.MakeEmptyMap(ctxstoreA)
-	mapB := adt.MakeEmptyMap(ctxstoreB)
-
-	require.NoError(t, mapA.Put(adt.UIntKey(0), runtime.CBORBytes([]byte{0}))) // delete
-
-	require.NoError(t, mapA.Put(adt.UIntKey(1), runtime.CBORBytes([]byte{0}))) // modify
-	require.NoError(t, mapB.Put(adt.UIntKey(1), runtime.CBORBytes([]byte{1})))
-
-	require.NoError(t, mapA.Put(adt.UIntKey(2), runtime.CBORBytes([]byte{1}))) // delete
-
-	require.NoError(t, mapA.Put(adt.UIntKey(3), runtime.CBORBytes([]byte{0}))) // noop
-	require.NoError(t, mapB.Put(adt.UIntKey(3), runtime.CBORBytes([]byte{0})))
-
-	require.NoError(t, mapA.Put(adt.UIntKey(4), runtime.CBORBytes([]byte{0}))) // modify
-	require.NoError(t, mapB.Put(adt.UIntKey(4), runtime.CBORBytes([]byte{6})))
-
-	require.NoError(t, mapB.Put(adt.UIntKey(5), runtime.CBORBytes{8})) // add
-	require.NoError(t, mapB.Put(adt.UIntKey(6), runtime.CBORBytes{9})) // add
-
-	changes := new(TestDiffMap)
-
-	assert.NoError(t, DiffAdtMap(mapA, mapB, changes))
-	assert.NotNil(t, changes)
-
-	assert.Equal(t, 2, len(changes.Added))
-	// keys 5 and 6 were added
-	assert.EqualValues(t, uint64(6), changes.Added[0].key)
-	assert.EqualValues(t, []byte{9}, changes.Added[0].val)
-	assert.EqualValues(t, uint64(5), changes.Added[1].key)
-	assert.EqualValues(t, []byte{8}, changes.Added[1].val)
-
-	assert.Equal(t, 2, len(changes.Modified))
-	// keys 1 and 4 were modified
-	assert.EqualValues(t, uint64(1), changes.Modified[0].From.key)
-	assert.EqualValues(t, []byte{0}, changes.Modified[0].From.val)
-	assert.EqualValues(t, uint64(1), changes.Modified[0].To.key)
-	assert.EqualValues(t, []byte{1}, changes.Modified[0].To.val)
-	assert.EqualValues(t, uint64(4), changes.Modified[1].From.key)
-	assert.EqualValues(t, []byte{0}, changes.Modified[1].From.val)
-	assert.EqualValues(t, uint64(4), changes.Modified[1].To.key)
-	assert.EqualValues(t, []byte{6}, changes.Modified[1].To.val)
-
-	assert.Equal(t, 2, len(changes.Removed))
-	// keys 0 and 2 were deleted
-	assert.EqualValues(t, uint64(0), changes.Removed[0].key)
-	assert.EqualValues(t, []byte{0}, changes.Removed[0].val)
-	assert.EqualValues(t, uint64(2), changes.Removed[1].key)
-	assert.EqualValues(t, []byte{1}, changes.Removed[1].val)
-
-}
-
-type TestDiffMap struct {
-	Added    []adtMapDiffResult
-	Modified []TestAdtMapDiffModified
-	Removed  []adtMapDiffResult
-}
-
-var _ AdtMapDiff = &TestDiffMap{}
-
-func (t *TestDiffMap) AsKey(key string) (adt.Keyer, error) {
-	k, err := adt.ParseUIntKey(key)
-	if err != nil {
-		return nil, err
-	}
-	return adt.UIntKey(k), nil
-}
-
-func (t *TestDiffMap) Add(key string, val *typegen.Deferred) error {
-	v := new(runtime.CBORBytes)
-	err := v.UnmarshalCBOR(bytes.NewReader(val.Raw))
-	if err != nil {
-		return err
-	}
-	k, err := adt.ParseUIntKey(key)
-	if err != nil {
-		return err
-	}
-	t.Added = append(t.Added, adtMapDiffResult{
-		key: k,
-		val: *v,
-	})
-	return nil
-}
-
-func (t *TestDiffMap) Modify(key string, from, to *typegen.Deferred) error {
-	vFrom := new(runtime.CBORBytes)
-	err := vFrom.UnmarshalCBOR(bytes.NewReader(from.Raw))
-	if err != nil {
-		return err
-	}
-
-	vTo := new(runtime.CBORBytes)
-	err = vTo.UnmarshalCBOR(bytes.NewReader(to.Raw))
-	if err != nil {
-		return err
-	}
-
-	k, err := adt.ParseUIntKey(key)
-	if err != nil {
-		return err
-	}
-
-	if !bytes.Equal(*vFrom, *vTo) {
-		t.Modified = append(t.Modified, TestAdtMapDiffModified{
-			From: adtMapDiffResult{
-				key: k,
-				val: *vFrom,
-			},
-			To: adtMapDiffResult{
-				key: k,
-				val: *vTo,
-			},
-		})
-	}
-	return nil
-}
-
-func (t *TestDiffMap) Remove(key string, val *typegen.Deferred) error {
-	v := new(runtime.CBORBytes)
-	err := v.UnmarshalCBOR(bytes.NewReader(val.Raw))
-	if err != nil {
-		return err
-	}
-	k, err := adt.ParseUIntKey(key)
-	if err != nil {
-		return err
-	}
-	t.Removed = append(t.Removed, adtMapDiffResult{
-		key: k,
-		val: *v,
-	})
-	return nil
-}
-
-type adtMapDiffResult struct {
+type adtDiffResult struct {
 	key uint64
 	val runtime.CBORBytes
 }
 
-type TestAdtMapDiffModified struct {
-	From adtMapDiffResult
-	To   adtMapDiffResult
+type TestAdtDiff struct {
+	Added    []adtDiffResult
+	Modified []TestAdtDiffModified
+	Removed  []adtDiffResult
 }
 
-type adtArrayDiffResult struct {
-	key uint64
-	val runtime.CBORBytes
+var _ AdtArrayDiff = &TestAdtDiff{}
+
+type TestAdtDiffModified struct {
+	From adtDiffResult
+	To   adtDiffResult
 }
 
-type TestDiffArray struct {
-	Added    []adtArrayDiffResult
-	Modified []TestAdtArrayDiffModified
-	Removed  []adtArrayDiffResult
-}
-
-var _ AdtArrayDiff = &TestDiffArray{}
-
-type TestAdtArrayDiffModified struct {
-	From adtArrayDiffResult
-	To   adtArrayDiffResult
-}
-
-func (t *TestDiffArray) Add(key uint64, val *typegen.Deferred) error {
+func (t *TestAdtDiff) Add(key uint64, val *typegen.Deferred) error {
 	v := new(runtime.CBORBytes)
 	err := v.UnmarshalCBOR(bytes.NewReader(val.Raw))
 	if err != nil {
 		return err
 	}
-	t.Added = append(t.Added, adtArrayDiffResult{
+	t.Added = append(t.Added, adtDiffResult{
 		key: key,
 		val: *v,
 	})
 	return nil
 }
 
-func (t *TestDiffArray) Modify(key uint64, from, to *typegen.Deferred) error {
+func (t *TestAdtDiff) Modify(key uint64, from, to *typegen.Deferred) error {
 	vFrom := new(runtime.CBORBytes)
 	err := vFrom.UnmarshalCBOR(bytes.NewReader(from.Raw))
 	if err != nil {
@@ -264,12 +116,12 @@ func (t *TestDiffArray) Modify(key uint64, from, to *typegen.Deferred) error {
 	}
 
 	if !bytes.Equal(*vFrom, *vTo) {
-		t.Modified = append(t.Modified, TestAdtArrayDiffModified{
-			From: adtArrayDiffResult{
+		t.Modified = append(t.Modified, TestAdtDiffModified{
+			From: adtDiffResult{
 				key: key,
 				val: *vFrom,
 			},
-			To: adtArrayDiffResult{
+			To: adtDiffResult{
 				key: key,
 				val: *vTo,
 			},
@@ -278,13 +130,13 @@ func (t *TestDiffArray) Modify(key uint64, from, to *typegen.Deferred) error {
 	return nil
 }
 
-func (t *TestDiffArray) Remove(key uint64, val *typegen.Deferred) error {
+func (t *TestAdtDiff) Remove(key uint64, val *typegen.Deferred) error {
 	v := new(runtime.CBORBytes)
 	err := v.UnmarshalCBOR(bytes.NewReader(val.Raw))
 	if err != nil {
 		return err
 	}
-	t.Removed = append(t.Removed, adtArrayDiffResult{
+	t.Removed = append(t.Removed, adtDiffResult{
 		key: key,
 		val: *v,
 	})

chain/events/state/predicates.go

@@ -5,17 +5,17 @@ import (
 	"context"
 
 	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/go-state-types/big"
+	"github.com/ipfs/go-cid"
+	cbor "github.com/ipfs/go-ipld-cbor"
+	typegen "github.com/whyrusleeping/cbor-gen"
+
+	"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"
-	init_ "github.com/filecoin-project/specs-actors/actors/builtin/init"
 	"github.com/filecoin-project/specs-actors/actors/builtin/market"
 	"github.com/filecoin-project/specs-actors/actors/builtin/miner"
 	"github.com/filecoin-project/specs-actors/actors/builtin/paych"
 	"github.com/filecoin-project/specs-actors/actors/util/adt"
-	"github.com/ipfs/go-cid"
-	cbor "github.com/ipfs/go-ipld-cbor"
-	typegen "github.com/whyrusleeping/cbor-gen"
 
 	"github.com/filecoin-project/lotus/api/apibstore"
 	"github.com/filecoin-project/lotus/chain/types"
@@ -407,21 +407,6 @@ func (sp *StatePredicates) AvailableBalanceChangedForAddresses(getAddrs func() [
 
 type DiffMinerActorStateFunc func(ctx context.Context, oldState *miner.State, newState *miner.State) (changed bool, user UserData, err error)
 
-func (sp *StatePredicates) OnInitActorChange(diffInitActorState DiffInitActorStateFunc) DiffTipSetKeyFunc {
-	return sp.OnActorStateChanged(builtin.InitActorAddr, func(ctx context.Context, oldActorStateHead, newActorStateHead cid.Cid) (changed bool, user UserData, err error) {
-		var oldState init_.State
-		if err := sp.cst.Get(ctx, oldActorStateHead, &oldState); err != nil {
-			return false, nil, err
-		}
-		var newState init_.State
-		if err := sp.cst.Get(ctx, newActorStateHead, &newState); err != nil {
-			return false, nil, err
-		}
-		return diffInitActorState(ctx, &oldState, &newState)
-	})
-
-}
-
 func (sp *StatePredicates) OnMinerActorChange(minerAddr address.Address, diffMinerActorState DiffMinerActorStateFunc) DiffTipSetKeyFunc {
 	return sp.OnActorStateChanged(minerAddr, func(ctx context.Context, oldActorStateHead, newActorStateHead cid.Cid) (changed bool, user UserData, err error) {
 		var oldState miner.State
@@ -643,145 +628,3 @@ func (sp *StatePredicates) OnToSendAmountChanges() DiffPaymentChannelStateFunc {
 		}, nil
 	}
 }
-
-type AddressPair struct {
-	ID address.Address
-	PK address.Address
-}
-
-type InitActorAddressChanges struct {
-	Added    []AddressPair
-	Modified []AddressChange
-	Removed  []AddressPair
-}
-
-type AddressChange struct {
-	From AddressPair
-	To   AddressPair
-}
-
-type DiffInitActorStateFunc func(ctx context.Context, oldState *init_.State, newState *init_.State) (changed bool, user UserData, err error)
-
-func (i *InitActorAddressChanges) AsKey(key string) (adt.Keyer, error) {
-	addr, err := address.NewFromBytes([]byte(key))
-	if err != nil {
-		return nil, err
-	}
-	return adt.AddrKey(addr), nil
-}
-
-func (i *InitActorAddressChanges) Add(key string, val *typegen.Deferred) error {
-	pkAddr, err := address.NewFromBytes([]byte(key))
-	if err != nil {
-		return err
-	}
-	id := new(typegen.CborInt)
-	if err := id.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil {
-		return err
-	}
-	idAddr, err := address.NewIDAddress(uint64(*id))
-	if err != nil {
-		return err
-	}
-	i.Added = append(i.Added, AddressPair{
-		ID: idAddr,
-		PK: pkAddr,
-	})
-	return nil
-}
-
-func (i *InitActorAddressChanges) Modify(key string, from, to *typegen.Deferred) error {
-	pkAddr, err := address.NewFromBytes([]byte(key))
-	if err != nil {
-		return err
-	}
-
-	fromID := new(typegen.CborInt)
-	if err := fromID.UnmarshalCBOR(bytes.NewReader(from.Raw)); err != nil {
-		return err
-	}
-	fromIDAddr, err := address.NewIDAddress(uint64(*fromID))
-	if err != nil {
-		return err
-	}
-
-	toID := new(typegen.CborInt)
-	if err := toID.UnmarshalCBOR(bytes.NewReader(to.Raw)); err != nil {
-		return err
-	}
-	toIDAddr, err := address.NewIDAddress(uint64(*toID))
-	if err != nil {
-		return err
-	}
-
-	i.Modified = append(i.Modified, AddressChange{
-		From: AddressPair{
-			ID: fromIDAddr,
-			PK: pkAddr,
-		},
-		To: AddressPair{
-			ID: toIDAddr,
-			PK: pkAddr,
-		},
-	})
-	return nil
-}
-
-func (i *InitActorAddressChanges) Remove(key string, val *typegen.Deferred) error {
-	pkAddr, err := address.NewFromBytes([]byte(key))
-	if err != nil {
-		return err
-	}
-	id := new(typegen.CborInt)
-	if err := id.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil {
-		return err
-	}
-	idAddr, err := address.NewIDAddress(uint64(*id))
-	if err != nil {
-		return err
-	}
-	i.Removed = append(i.Removed, AddressPair{
-		ID: idAddr,
-		PK: pkAddr,
-	})
-	return nil
-}
-
-func (sp *StatePredicates) OnAddressMapChange() DiffInitActorStateFunc {
-	return func(ctx context.Context, oldState, newState *init_.State) (changed bool, user UserData, err error) {
-		ctxStore := &contextStore{
-			ctx: ctx,
-			cst: sp.cst,
-		}
-
-		addressChanges := &InitActorAddressChanges{
-			Added:    []AddressPair{},
-			Modified: []AddressChange{},
-			Removed:  []AddressPair{},
-		}
-
-		if oldState.AddressMap.Equals(newState.AddressMap) {
-			return false, nil, nil
-		}
-
-		oldAddrs, err := adt.AsMap(ctxStore, oldState.AddressMap)
-		if err != nil {
-			return false, nil, err
-		}
-
-		newAddrs, err := adt.AsMap(ctxStore, newState.AddressMap)
-		if err != nil {
-			return false, nil, err
-		}
-
-		if err := DiffAdtMap(oldAddrs, newAddrs, addressChanges); err != nil {
-			return false, nil, err
-		}
-
-		if len(addressChanges.Added)+len(addressChanges.Removed)+len(addressChanges.Modified) == 0 {
-			return false, nil, nil
-		}
-
-		return true, addressChanges, nil
-	}
-}

chain/events/state/predicates_test.go

@@ -13,11 +13,11 @@ import (
 	cbornode "github.com/ipfs/go-ipld-cbor"
 
 	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/go-state-types/big"
-	"github.com/filecoin-project/go-state-types/crypto"
+	"github.com/filecoin-project/specs-actors/actors/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/crypto"
 	"github.com/filecoin-project/specs-actors/actors/util/adt"
 	tutils "github.com/filecoin-project/specs-actors/support/testing"
 
@@ -114,10 +114,10 @@ func TestMarketPredicates(t *testing.T) {
 	}
 
 	oldBalances := map[address.Address]balance{
-		tutils.NewIDAddr(t, 1): {abi.NewTokenAmount(1000), abi.NewTokenAmount(1000)},
-		tutils.NewIDAddr(t, 2): {abi.NewTokenAmount(2000), abi.NewTokenAmount(500)},
-		tutils.NewIDAddr(t, 3): {abi.NewTokenAmount(3000), abi.NewTokenAmount(2000)},
-		tutils.NewIDAddr(t, 5): {abi.NewTokenAmount(3000), abi.NewTokenAmount(1000)},
+		tutils.NewIDAddr(t, 1): balance{abi.NewTokenAmount(1000), abi.NewTokenAmount(1000)},
+		tutils.NewIDAddr(t, 2): balance{abi.NewTokenAmount(2000), abi.NewTokenAmount(500)},
+		tutils.NewIDAddr(t, 3): balance{abi.NewTokenAmount(3000), abi.NewTokenAmount(2000)},
+		tutils.NewIDAddr(t, 5): balance{abi.NewTokenAmount(3000), abi.NewTokenAmount(1000)},
 	}
 
 	oldStateC := createMarketState(ctx, t, store, oldDeals, oldProps, oldBalances)
@@ -162,10 +162,10 @@ func TestMarketPredicates(t *testing.T) {
 		// NB: DealProposals cannot be modified, so don't test that case.
 	}
 	newBalances := map[address.Address]balance{
-		tutils.NewIDAddr(t, 1): {abi.NewTokenAmount(3000), abi.NewTokenAmount(0)},
-		tutils.NewIDAddr(t, 2): {abi.NewTokenAmount(2000), abi.NewTokenAmount(500)},
-		tutils.NewIDAddr(t, 4): {abi.NewTokenAmount(5000), abi.NewTokenAmount(0)},
-		tutils.NewIDAddr(t, 5): {abi.NewTokenAmount(1000), abi.NewTokenAmount(3000)},
+		tutils.NewIDAddr(t, 1): balance{abi.NewTokenAmount(3000), abi.NewTokenAmount(0)},
+		tutils.NewIDAddr(t, 2): balance{abi.NewTokenAmount(2000), abi.NewTokenAmount(500)},
+		tutils.NewIDAddr(t, 4): balance{abi.NewTokenAmount(5000), abi.NewTokenAmount(0)},
+		tutils.NewIDAddr(t, 5): balance{abi.NewTokenAmount(1000), abi.NewTokenAmount(3000)},
 	}
 
 	newStateC := createMarketState(ctx, t, store, newDeals, newProps, newBalances)
@@ -505,7 +505,6 @@ func createBalanceTable(ctx context.Context, t *testing.T, store adt.Store, bala
 	lockedMapRootCid, err := lockedMapRoot.Root()
 	require.NoError(t, err)
 	lockedRoot, err := adt.AsBalanceTable(store, lockedMapRootCid)
-	require.NoError(t, err)
 
 	for addr, balance := range balances {
 		err := escrowRoot.Add(addr, big.Add(balance.available, balance.locked))
@@ -538,24 +537,26 @@ func createEmptyMinerState(ctx context.Context, t *testing.T, store adt.Store, o
 	emptyMap, err := adt.MakeEmptyMap(store).Root()
 	require.NoError(t, err)
 
-	emptyDeadline, err := store.Put(store.Context(), miner.ConstructDeadline(emptyArrayCid))
-	require.NoError(t, err)
-
-	emptyVestingFunds := miner.ConstructVestingFunds()
-	emptyVestingFundsCid, err := store.Put(store.Context(), emptyVestingFunds)
+	emptyDeadline, err := store.Put(context.TODO(), &miner.Deadline{
+		Partitions:        emptyArrayCid,
+		ExpirationsEpochs: emptyArrayCid,
+		PostSubmissions:   abi.NewBitField(),
+		EarlyTerminations: abi.NewBitField(),
+		LiveSectors:       0,
+	})
 	require.NoError(t, err)
 
 	emptyDeadlines := miner.ConstructDeadlines(emptyDeadline)
-	emptyDeadlinesCid, err := store.Put(store.Context(), emptyDeadlines)
+	emptyDeadlinesCid, err := store.Put(context.Background(), emptyDeadlines)
 	require.NoError(t, err)
 
 	minerInfo := emptyMap
 
 	emptyBitfield := bitfield.NewFromSet(nil)
-	emptyBitfieldCid, err := store.Put(store.Context(), emptyBitfield)
+	emptyBitfieldCid, err := store.Put(context.Background(), emptyBitfield)
 	require.NoError(t, err)
 
-	state, err := miner.ConstructState(minerInfo, 123, emptyBitfieldCid, emptyArrayCid, emptyMap, emptyDeadlinesCid, emptyVestingFundsCid)
+	state, err := miner.ConstructState(minerInfo, 123, emptyBitfieldCid, emptyArrayCid, emptyMap, emptyDeadlinesCid)
 	require.NoError(t, err)
 	return state
 

chain/events/tscache.go

@@ -3,16 +3,13 @@ package events
 import (
 	"context"
 
-	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/specs-actors/actors/abi"
 	"golang.org/x/xerrors"
 
 	"github.com/filecoin-project/lotus/chain/types"
 )
 
-type tsCacheAPI interface {
-	ChainGetTipSetByHeight(context.Context, abi.ChainEpoch, types.TipSetKey) (*types.TipSet, error)
-	ChainHead(context.Context) (*types.TipSet, error)
-}
+type tsByHFunc func(context.Context, abi.ChainEpoch, types.TipSetKey) (*types.TipSet, error)
 
 // tipSetCache implements a simple ring-buffer cache to keep track of recent
 // tipsets
@@ -21,10 +18,10 @@ type tipSetCache struct {
 	start int
 	len   int
 
-	storage tsCacheAPI
+	storage tsByHFunc
 }
 
-func newTSCache(cap abi.ChainEpoch, storage tsCacheAPI) *tipSetCache {
+func newTSCache(cap abi.ChainEpoch, storage tsByHFunc) *tipSetCache {
 	return &tipSetCache{
 		cache: make([]*types.TipSet, cap),
 		start: 0,
@@ -97,7 +94,7 @@ func (tsc *tipSetCache) getNonNull(height abi.ChainEpoch) (*types.TipSet, error)
 func (tsc *tipSetCache) get(height abi.ChainEpoch) (*types.TipSet, error) {
 	if tsc.len == 0 {
 		log.Warnf("tipSetCache.get: cache is empty, requesting from storage (h=%d)", height)
-		return tsc.storage.ChainGetTipSetByHeight(context.TODO(), height, types.EmptyTSK)
+		return tsc.storage(context.TODO(), height, types.EmptyTSK)
 	}
 
 	headH := tsc.cache[tsc.start].Height()
@@ -117,18 +114,14 @@ func (tsc *tipSetCache) get(height abi.ChainEpoch) (*types.TipSet, error) {
 
 	if height < tail.Height() {
 		log.Warnf("tipSetCache.get: requested tipset not in cache, requesting from storage (h=%d; tail=%d)", height, tail.Height())
-		return tsc.storage.ChainGetTipSetByHeight(context.TODO(), height, tail.Key())
+		return tsc.storage(context.TODO(), height, tail.Key())
 	}
 
 	return tsc.cache[normalModulo(tsc.start-int(headH-height), clen)], nil
 }
 
-func (tsc *tipSetCache) best() (*types.TipSet, error) {
-	best := tsc.cache[tsc.start]
-	if best == nil {
-		return tsc.storage.ChainHead(context.TODO())
-	}
-	return best, nil
+func (tsc *tipSetCache) best() *types.TipSet {
+	return tsc.cache[tsc.start]
 }
 
 func normalModulo(n, m int) int {

chain/events/tscache_test.go

@@ -4,8 +4,8 @@ import (
 	"context"
 	"testing"
 
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/go-state-types/crypto"
+	"github.com/filecoin-project/specs-actors/actors/abi"
+	"github.com/filecoin-project/specs-actors/actors/crypto"
 	"github.com/stretchr/testify/require"
 
 	"github.com/filecoin-project/go-address"
@@ -13,7 +13,10 @@ import (
 )
 
 func TestTsCache(t *testing.T) {
-	tsc := newTSCache(50, &tsCacheAPIFailOnStorageCall{t: t})
+	tsc := newTSCache(50, func(context.Context, abi.ChainEpoch, types.TipSetKey) (*types.TipSet, error) {
+		t.Fatal("storage call")
+		return &types.TipSet{}, nil
+	})
 
 	h := abi.ChainEpoch(75)
 
@@ -40,12 +43,7 @@ func TestTsCache(t *testing.T) {
 
 	for i := 0; i < 9000; i++ {
 		if i%90 > 60 {
-			best, err := tsc.best()
-			if err != nil {
-				t.Fatal(err, "; i:", i)
-				return
-			}
-			if err := tsc.revert(best); err != nil {
+			if err := tsc.revert(tsc.best()); err != nil {
 				t.Fatal(err, "; i:", i)
 				return
 			}
@@ -57,21 +55,11 @@ func TestTsCache(t *testing.T) {
 
 }
 
-type tsCacheAPIFailOnStorageCall struct {
-	t *testing.T
-}
-
-func (tc *tsCacheAPIFailOnStorageCall) ChainGetTipSetByHeight(ctx context.Context, epoch abi.ChainEpoch, key types.TipSetKey) (*types.TipSet, error) {
-	tc.t.Fatal("storage call")
-	return &types.TipSet{}, nil
-}
-func (tc *tsCacheAPIFailOnStorageCall) ChainHead(ctx context.Context) (*types.TipSet, error) {
-	tc.t.Fatal("storage call")
-	return &types.TipSet{}, nil
-}
-
 func TestTsCacheNulls(t *testing.T) {
-	tsc := newTSCache(50, &tsCacheAPIFailOnStorageCall{t: t})
+	tsc := newTSCache(50, func(context.Context, abi.ChainEpoch, types.TipSetKey) (*types.TipSet, error) {
+		t.Fatal("storage call")
+		return &types.TipSet{}, nil
+	})
 
 	h := abi.ChainEpoch(75)
 
@@ -103,9 +91,7 @@ func TestTsCacheNulls(t *testing.T) {
 	add()
 	add()
 
-	best, err := tsc.best()
-	require.NoError(t, err)
-	require.Equal(t, h-1, best.Height())
+	require.Equal(t, h-1, tsc.best().Height())
 
 	ts, err := tsc.get(h - 1)
 	require.NoError(t, err)
@@ -123,17 +109,9 @@ func TestTsCacheNulls(t *testing.T) {
 	require.NoError(t, err)
 	require.Equal(t, h-8, ts.Height())
 
-	best, err = tsc.best()
-	require.NoError(t, err)
-	require.NoError(t, tsc.revert(best))
-
-	best, err = tsc.best()
-	require.NoError(t, err)
-	require.NoError(t, tsc.revert(best))
-
-	best, err = tsc.best()
-	require.NoError(t, err)
-	require.Equal(t, h-8, best.Height())
+	require.NoError(t, tsc.revert(tsc.best()))
+	require.NoError(t, tsc.revert(tsc.best()))
+	require.Equal(t, h-8, tsc.best().Height())
 
 	h += 50
 	add()
@@ -142,27 +120,3 @@ func TestTsCacheNulls(t *testing.T) {
 	require.NoError(t, err)
 	require.Equal(t, h-1, ts.Height())
 }
-
-type tsCacheAPIStorageCallCounter struct {
-	t                      *testing.T
-	chainGetTipSetByHeight int
-	chainHead              int
-}
-
-func (tc *tsCacheAPIStorageCallCounter) ChainGetTipSetByHeight(ctx context.Context, epoch abi.ChainEpoch, key types.TipSetKey) (*types.TipSet, error) {
-	tc.chainGetTipSetByHeight++
-	return &types.TipSet{}, nil
-}
-func (tc *tsCacheAPIStorageCallCounter) ChainHead(ctx context.Context) (*types.TipSet, error) {
-	tc.chainHead++
-	return &types.TipSet{}, nil
-}
-
-func TestTsCacheEmpty(t *testing.T) {
-	// Calling best on an empty cache should just call out to the chain API
-	callCounter := &tsCacheAPIStorageCallCounter{t: t}
-	tsc := newTSCache(50, callCounter)
-	_, err := tsc.best()
-	require.NoError(t, err)
-	require.Equal(t, 1, callCounter.chainHead)
-}

chain/exchange/doc.go

@@ -1,19 +0,0 @@
-// Package exchange contains the ChainExchange server and client components.
-//
-// ChainExchange is the basic chain synchronization protocol of Filecoin.
-// ChainExchange is an RPC-oriented protocol, with a single operation to
-// request blocks for now.
-//
-// A request contains a start anchor block (referred to with a CID), and a
-// amount of blocks requested beyond the anchor (including the anchor itself).
-//
-// A client can also pass options, encoded as a 64-bit bitfield. Lotus supports
-// two options at the moment:
-//
-//  - include block contents
-//  - include block messages
-//
-// The response will include a status code, an optional message, and the
-// response payload in case of success. The payload is a slice of serialized
-// tipsets.
-package exchange

chain/exchange/interfaces.go

@@ -1,51 +0,0 @@
-package exchange
-
-import (
-	"context"
-
-	"github.com/libp2p/go-libp2p-core/network"
-	"github.com/libp2p/go-libp2p-core/peer"
-
-	"github.com/filecoin-project/lotus/chain/store"
-	"github.com/filecoin-project/lotus/chain/types"
-)
-
-// Server is the responder side of the ChainExchange protocol. It accepts
-// requests from clients and services them by returning the requested
-// chain data.
-type Server interface {
-	// HandleStream is the protocol handler to be registered on a libp2p
-	// protocol router.
-	//
-	// In the current version of the protocol, streams are single-use. The
-	// server will read a single Request, and will respond with a single
-	// Response. It will dispose of the stream straight after.
-	HandleStream(stream network.Stream)
-}
-
-// Client is the requesting side of the ChainExchange protocol. It acts as
-// a proxy for other components to request chain data from peers. It is chiefly
-// used by the Syncer.
-type Client interface {
-	// GetBlocks fetches block headers from the network, from the provided
-	// tipset *backwards*, returning as many tipsets as the count parameter,
-	// or less.
-	GetBlocks(ctx context.Context, tsk types.TipSetKey, count int) ([]*types.TipSet, error)
-
-	// GetChainMessages fetches messages from the network, from the provided
-	// tipset *backwards*, returning the messages from as many tipsets as the
-	// count parameter, or less.
-	GetChainMessages(ctx context.Context, head *types.TipSet, length uint64) ([]*CompactedMessages, error)
-
-	// GetFullTipSet fetches a full tipset from a given peer. If successful,
-	// the fetched object contains block headers and all messages in full form.
-	GetFullTipSet(ctx context.Context, peer peer.ID, tsk types.TipSetKey) (*store.FullTipSet, error)
-
-	// AddPeer adds a peer to the pool of peers that the Client requests
-	// data from.
-	AddPeer(peer peer.ID)
-
-	// RemovePeer removes a peer from the pool of peers that the Client
-	// requests data from.
-	RemovePeer(peer peer.ID)
-}

chain/gen/gen.go

@@ -8,13 +8,11 @@ import (
 	"sync/atomic"
 	"time"
 
-	"github.com/filecoin-project/specs-actors/actors/runtime/proof"
-
 	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/go-state-types/big"
-	"github.com/filecoin-project/go-state-types/crypto"
+	"github.com/filecoin-project/specs-actors/actors/abi"
+	"github.com/filecoin-project/specs-actors/actors/abi/big"
 	saminer "github.com/filecoin-project/specs-actors/actors/builtin/miner"
+	"github.com/filecoin-project/specs-actors/actors/crypto"
 	block "github.com/ipfs/go-block-format"
 	"github.com/ipfs/go-blockservice"
 	"github.com/ipfs/go-cid"
@@ -36,19 +34,18 @@ import (
 	"github.com/filecoin-project/lotus/chain/vm"
 	"github.com/filecoin-project/lotus/chain/wallet"
 	"github.com/filecoin-project/lotus/cmd/lotus-seed/seed"
-	"github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper"
 	"github.com/filecoin-project/lotus/genesis"
 	"github.com/filecoin-project/lotus/lib/blockstore"
 	"github.com/filecoin-project/lotus/lib/sigs"
 	"github.com/filecoin-project/lotus/node/repo"
+	"github.com/filecoin-project/sector-storage/ffiwrapper"
 )
 
+var log = logging.Logger("gen")
+
 const msgsPerBlock = 20
 
-//nolint:deadcode,varcheck
-var log = logging.Logger("gen")
-
-var ValidWpostForTesting = []proof.PoStProof{{
+var ValidWpostForTesting = []abi.PoStProof{{
 	ProofBytes: []byte("valid proof"),
 }}
 
@@ -59,7 +56,7 @@ type ChainGen struct {
 
 	cs *store.ChainStore
 
-	beacon beacon.Schedule
+	beacon beacon.RandomBeacon
 
 	sm *stmgr.StateManager
 
@@ -95,8 +92,10 @@ func (m mybs) Get(c cid.Cid) (block.Block, error) {
 	return b, nil
 }
 
+var rootkey, _ = address.NewIDAddress(80)
+
 var rootkeyMultisig = genesis.MultisigMeta{
-	Signers:         []address.Address{remAccTestKey},
+	Signers:         []address.Address{rootkey},
 	Threshold:       1,
 	VestingDuration: 0,
 	VestingStart:    0,
@@ -108,18 +107,6 @@ var DefaultVerifregRootkeyActor = genesis.Actor{
 	Meta:    rootkeyMultisig.ActorMeta(),
 }
 
-var remAccTestKey, _ = address.NewFromString("t1ceb34gnsc6qk5dt6n7xg6ycwzasjhbxm3iylkiy")
-var remAccMeta = genesis.MultisigMeta{
-	Signers:   []address.Address{remAccTestKey},
-	Threshold: 1,
-}
-
-var DefaultRemainderAccountActor = genesis.Actor{
-	Type:    genesis.TMultisig,
-	Balance: big.NewInt(0),
-	Meta:    remAccMeta.ActorMeta(),
-}
-
 func NewGeneratorWithSectors(numSectors int) (*ChainGen, error) {
 	saminer.SupportedProofTypes = map[abi.RegisteredSealProof]struct{}{
 		abi.RegisteredSealProof_StackedDrg2KiBV1: {},
@@ -223,10 +210,9 @@ func NewGeneratorWithSectors(numSectors int) (*ChainGen, error) {
 			*genm1,
 			*genm2,
 		},
-		VerifregRootKey:  DefaultVerifregRootkeyActor,
-		RemainderAccount: DefaultRemainderAccountActor,
-		NetworkName:      "",
-		Timestamp:        uint64(build.Clock.Now().Add(-500 * time.Duration(build.BlockDelaySecs) * time.Second).Unix()),
+		VerifregRootKey: DefaultVerifregRootkeyActor,
+		NetworkName:     "",
+		Timestamp:       uint64(build.Clock.Now().Add(-500 * time.Duration(build.BlockDelaySecs) * time.Second).Unix()),
 	}
 
 	genb, err := genesis2.MakeGenesisBlock(context.TODO(), bs, sys, tpl)
@@ -252,7 +238,7 @@ func NewGeneratorWithSectors(numSectors int) (*ChainGen, error) {
 
 	miners := []address.Address{maddr1, maddr2}
 
-	beac := beacon.Schedule{{Start: 0, Beacon: beacon.NewMockBeacon(time.Second)}}
+	beac := beacon.NewMockBeacon(time.Second)
 	//beac, err := drand.NewDrandBeacon(tpl.Timestamp, build.BlockDelaySecs)
 	//if err != nil {
 	//return nil, xerrors.Errorf("creating drand beacon: %w", err)
@@ -286,10 +272,6 @@ func NewGenerator() (*ChainGen, error) {
 	return NewGeneratorWithSectors(1)
 }
 
-func (cg *ChainGen) StateManager() *stmgr.StateManager {
-	return cg.sm
-}
-
 func (cg *ChainGen) SetStateManager(sm *stmgr.StateManager) {
 	cg.sm = sm
 }
@@ -318,8 +300,7 @@ func (cg *ChainGen) GenesisCar() ([]byte, error) {
 
 func CarWalkFunc(nd format.Node) (out []*format.Link, err error) {
 	for _, link := range nd.Links() {
-		pref := link.Cid.Prefix()
-		if pref.Codec == cid.FilCommitmentSealed || pref.Codec == cid.FilCommitmentUnsealed {
+		if link.Cid.Prefix().Codec == cid.FilCommitmentSealed || link.Cid.Prefix().Codec == cid.FilCommitmentUnsealed {
 			continue
 		}
 		out = append(out, link)
@@ -338,7 +319,7 @@ func (cg *ChainGen) nextBlockProof(ctx context.Context, pts *types.TipSet, m add
 
 	prev := mbi.PrevBeaconEntry
 
-	entries, err := beacon.BeaconEntriesForBlock(ctx, cg.beacon, round, pts.Height(), prev)
+	entries, err := beacon.BeaconEntriesForBlock(ctx, cg.beacon, round, prev)
 	if err != nil {
 		return nil, nil, nil, xerrors.Errorf("get beacon entries for block: %w", err)
 	}
@@ -402,32 +383,15 @@ func (cg *ChainGen) SetWinningPoStProver(m address.Address, wpp WinningPoStProve
 }
 
 func (cg *ChainGen) NextTipSetFromMiners(base *types.TipSet, miners []address.Address) (*MinedTipSet, error) {
-	ms, err := cg.GetMessages(cg)
+	var blks []*types.FullBlock
+
+	msgs, err := cg.GetMessages(cg)
 	if err != nil {
 		return nil, xerrors.Errorf("get random messages: %w", err)
 	}
 
-	msgs := make([][]*types.SignedMessage, len(miners))
-	for i := range msgs {
-		msgs[i] = ms
-	}
-
-	fts, err := cg.NextTipSetFromMinersWithMessages(base, miners, msgs)
-	if err != nil {
-		return nil, err
-	}
-
-	return &MinedTipSet{
-		TipSet:   fts,
-		Messages: ms,
-	}, nil
-}
-
-func (cg *ChainGen) NextTipSetFromMinersWithMessages(base *types.TipSet, miners []address.Address, msgs [][]*types.SignedMessage) (*store.FullTipSet, error) {
-	var blks []*types.FullBlock
-
 	for round := base.Height() + 1; len(blks) == 0; round++ {
-		for mi, m := range miners {
+		for _, m := range miners {
 			bvals, et, ticket, err := cg.nextBlockProof(context.TODO(), base, m, round)
 			if err != nil {
 				return nil, xerrors.Errorf("next block proof: %w", err)
@@ -440,7 +404,7 @@ func (cg *ChainGen) NextTipSetFromMinersWithMessages(base *types.TipSet, miners
 					return nil, err
 				}
 
-				fblk, err := cg.makeBlock(base, m, ticket, et, bvals, round, wpost, msgs[mi])
+				fblk, err := cg.makeBlock(base, m, ticket, et, bvals, round, wpost, msgs)
 				if err != nil {
 					return nil, xerrors.Errorf("making a block for next tipset failed: %w", err)
 				}
@@ -454,12 +418,17 @@ func (cg *ChainGen) NextTipSetFromMinersWithMessages(base *types.TipSet, miners
 		}
 	}
 
-	return store.NewFullTipSet(blks), nil
+	fts := store.NewFullTipSet(blks)
+
+	return &MinedTipSet{
+		TipSet:   fts,
+		Messages: msgs,
+	}, nil
 }
 
 func (cg *ChainGen) makeBlock(parents *types.TipSet, m address.Address, vrfticket *types.Ticket,
 	eticket *types.ElectionProof, bvals []types.BeaconEntry, height abi.ChainEpoch,
-	wpost []proof.PoStProof, msgs []*types.SignedMessage) (*types.FullBlock, error) {
+	wpost []abi.PoStProof, msgs []*types.SignedMessage) (*types.FullBlock, error) {
 
 	var ts uint64
 	if cg.Timestamper != nil {
@@ -547,8 +516,7 @@ func (cg *ChainGen) YieldRepo() (repo.Repo, error) {
 }
 
 type MiningCheckAPI interface {
-	ChainGetRandomnessFromBeacon(ctx context.Context, tsk types.TipSetKey, personalization crypto.DomainSeparationTag, randEpoch abi.ChainEpoch, entropy []byte) (abi.Randomness, error)
-	ChainGetRandomnessFromTickets(ctx context.Context, tsk types.TipSetKey, personalization crypto.DomainSeparationTag, randEpoch abi.ChainEpoch, entropy []byte) (abi.Randomness, error)
+	ChainGetRandomness(ctx context.Context, tsk types.TipSetKey, personalization crypto.DomainSeparationTag, randEpoch abi.ChainEpoch, entropy []byte) (abi.Randomness, error)
 
 	MinerGetBaseInfo(context.Context, address.Address, abi.ChainEpoch, types.TipSetKey) (*api.MiningBaseInfo, error)
 
@@ -559,25 +527,16 @@ type mca struct {
 	w   *wallet.Wallet
 	sm  *stmgr.StateManager
 	pv  ffiwrapper.Verifier
-	bcn beacon.Schedule
+	bcn beacon.RandomBeacon
 }
 
-func (mca mca) ChainGetRandomnessFromTickets(ctx context.Context, tsk types.TipSetKey, personalization crypto.DomainSeparationTag, randEpoch abi.ChainEpoch, entropy []byte) (abi.Randomness, error) {
+func (mca mca) ChainGetRandomness(ctx context.Context, tsk types.TipSetKey, personalization crypto.DomainSeparationTag, randEpoch abi.ChainEpoch, entropy []byte) (abi.Randomness, error) {
 	pts, err := mca.sm.ChainStore().LoadTipSet(tsk)
 	if err != nil {
 		return nil, xerrors.Errorf("loading tipset key: %w", err)
 	}
 
-	return mca.sm.ChainStore().GetChainRandomness(ctx, pts.Cids(), personalization, randEpoch, entropy)
-}
-
-func (mca mca) ChainGetRandomnessFromBeacon(ctx context.Context, tsk types.TipSetKey, personalization crypto.DomainSeparationTag, randEpoch abi.ChainEpoch, entropy []byte) (abi.Randomness, error) {
-	pts, err := mca.sm.ChainStore().LoadTipSet(tsk)
-	if err != nil {
-		return nil, xerrors.Errorf("loading tipset key: %w", err)
-	}
-
-	return mca.sm.ChainStore().GetBeaconRandomness(ctx, pts.Cids(), personalization, randEpoch, entropy)
+	return mca.sm.ChainStore().GetRandomness(ctx, pts.Cids(), personalization, randEpoch, entropy)
 }
 
 func (mca mca) MinerGetBaseInfo(ctx context.Context, maddr address.Address, epoch abi.ChainEpoch, tsk types.TipSetKey) (*api.MiningBaseInfo, error) {
@@ -590,7 +549,7 @@ func (mca mca) WalletSign(ctx context.Context, a address.Address, v []byte) (*cr
 
 type WinningPoStProver interface {
 	GenerateCandidates(context.Context, abi.PoStRandomness, uint64) ([]uint64, error)
-	ComputeProof(context.Context, []proof.SectorInfo, abi.PoStRandomness) ([]proof.PoStProof, error)
+	ComputeProof(context.Context, []abi.SectorInfo, abi.PoStRandomness) ([]abi.PoStProof, error)
 }
 
 type wppProvider struct{}
@@ -599,7 +558,7 @@ func (wpp *wppProvider) GenerateCandidates(ctx context.Context, _ abi.PoStRandom
 	return []uint64{0}, nil
 }
 
-func (wpp *wppProvider) ComputeProof(context.Context, []proof.SectorInfo, abi.PoStRandomness) ([]proof.PoStProof, error) {
+func (wpp *wppProvider) ComputeProof(context.Context, []abi.SectorInfo, abi.PoStRandomness) ([]abi.PoStProof, error) {
 	return ValidWpostForTesting, nil
 }
 
@@ -608,7 +567,7 @@ func IsRoundWinner(ctx context.Context, ts *types.TipSet, round abi.ChainEpoch,
 
 	buf := new(bytes.Buffer)
 	if err := miner.MarshalCBOR(buf); err != nil {
-		return nil, xerrors.Errorf("failed to cbor marshal address: %w", err)
+		return nil, xerrors.Errorf("failed to cbor marshal address: %w")
 	}
 
 	electionRand, err := store.DrawRandomness(brand.Data, crypto.DomainSeparationTag_ElectionProofProduction, round, buf.Bytes())
@@ -666,15 +625,15 @@ type genFakeVerifier struct{}
 
 var _ ffiwrapper.Verifier = (*genFakeVerifier)(nil)
 
-func (m genFakeVerifier) VerifySeal(svi proof.SealVerifyInfo) (bool, error) {
+func (m genFakeVerifier) VerifySeal(svi abi.SealVerifyInfo) (bool, error) {
 	return true, nil
 }
 
-func (m genFakeVerifier) VerifyWinningPoSt(ctx context.Context, info proof.WinningPoStVerifyInfo) (bool, error) {
+func (m genFakeVerifier) VerifyWinningPoSt(ctx context.Context, info abi.WinningPoStVerifyInfo) (bool, error) {
 	panic("not supported")
 }
 
-func (m genFakeVerifier) VerifyWindowPoSt(ctx context.Context, info proof.WindowPoStVerifyInfo) (bool, error) {
+func (m genFakeVerifier) VerifyWindowPoSt(ctx context.Context, info abi.WindowPoStVerifyInfo) (bool, error) {
 	panic("not supported")
 }
 

chain/gen/gen_test.go

@@ -3,8 +3,8 @@ package gen
 import (
 	"testing"
 
-	"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/miner"
 	"github.com/filecoin-project/specs-actors/actors/builtin/power"
 	"github.com/filecoin-project/specs-actors/actors/builtin/verifreg"

chain/gen/genesis/genblock.go

@@ -1,41 +0,0 @@
-package genesis
-
-import (
-	"encoding/hex"
-
-	blocks "github.com/ipfs/go-block-format"
-	"github.com/ipfs/go-cid"
-	"github.com/multiformats/go-multihash"
-)
-
-const genesisMultihashString = "1220107d821c25dc0735200249df94a8bebc9c8e489744f86a4ca8919e81f19dcd72"
-const genesisBlockHex = "a5684461746574696d6573323031372d30352d30352030313a32373a3531674e6574776f726b6846696c65636f696e65546f6b656e6846696c65636f696e6c546f6b656e416d6f756e7473a36b546f74616c537570706c796d322c3030302c3030302c303030664d696e6572736d312c3430302c3030302c3030306c50726f746f636f6c4c616273a36b446576656c6f706d656e746b3330302c3030302c3030306b46756e6472616973696e676b3230302c3030302c3030306a466f756e646174696f6e6b3130302c3030302c303030674d657373616765784854686973206973207468652047656e6573697320426c6f636b206f66207468652046696c65636f696e20446563656e7472616c697a65642053746f72616765204e6574776f726b2e"
-
-var cidBuilder = cid.V1Builder{Codec: cid.DagCBOR, MhType: multihash.SHA2_256}
-
-func expectedCid() cid.Cid {
-	mh, err := multihash.FromHexString(genesisMultihashString)
-	if err != nil {
-		panic(err)
-	}
-	return cid.NewCidV1(cidBuilder.Codec, mh)
-}
-
-func getGenesisBlock() (blocks.Block, error) {
-	genesisBlockData, err := hex.DecodeString(genesisBlockHex)
-	if err != nil {
-		return nil, err
-	}
-
-	genesisCid, err := cidBuilder.Sum(genesisBlockData)
-	if err != nil {
-		return nil, err
-	}
-
-	block, err := blocks.NewBlockWithCid(genesisBlockData, genesisCid)
-	if err != nil {
-		return nil, err
-	}
-
-	return block, nil
-}

chain/gen/genesis/genesis.go

@@ -2,11 +2,7 @@ package genesis
 
 import (
 	"context"
-	"crypto/rand"
 	"encoding/json"
-	"fmt"
-
-	"github.com/filecoin-project/go-state-types/network"
 
 	"github.com/ipfs/go-cid"
 	"github.com/ipfs/go-datastore"
@@ -16,13 +12,13 @@ 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/go-state-types/crypto"
+	"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/account"
 	"github.com/filecoin-project/specs-actors/actors/builtin/multisig"
 	"github.com/filecoin-project/specs-actors/actors/builtin/verifreg"
+	"github.com/filecoin-project/specs-actors/actors/crypto"
 	"github.com/filecoin-project/specs-actors/actors/util/adt"
 
 	"github.com/filecoin-project/lotus/build"
@@ -121,6 +117,11 @@ func MakeInitialStateTree(ctx context.Context, bs bstore.Blockstore, template ge
 		return nil, nil, xerrors.Errorf("making new state tree: %w", err)
 	}
 
+	emptyobject, err := cst.Put(context.TODO(), []struct{}{})
+	if err != nil {
+		return nil, nil, xerrors.Errorf("failed putting empty object: %w", err)
+	}
+
 	// Create system actor
 
 	sysact, err := SetupSystemActor(bs)
@@ -133,7 +134,7 @@ func MakeInitialStateTree(ctx context.Context, bs bstore.Blockstore, template ge
 
 	// Create init actor
 
-	idStart, initact, keyIDs, err := SetupInitActor(bs, template.NetworkName, template.Accounts, template.VerifregRootKey)
+	initact, keyIDs, err := SetupInitActor(bs, template.NetworkName, template.Accounts, template.VerifregRootKey)
 	if err != nil {
 		return nil, nil, xerrors.Errorf("setup init actor: %w", err)
 	}
@@ -189,47 +190,31 @@ func MakeInitialStateTree(ctx context.Context, bs bstore.Blockstore, template ge
 		return nil, nil, xerrors.Errorf("set market actor: %w", err)
 	}
 
-	burntRoot, err := cst.Put(ctx, &account.State{
-		Address: builtin.BurntFundsActorAddr,
-	})
-	if err != nil {
-		return nil, nil, xerrors.Errorf("failed to setup burnt funds actor state: %w", err)
-	}
-
 	// Setup burnt-funds
 	err = state.SetActor(builtin.BurntFundsActorAddr, &types.Actor{
 		Code:    builtin.AccountActorCodeID,
 		Balance: types.NewInt(0),
-		Head:    burntRoot,
+		Head:    emptyobject,
 	})
 	if err != nil {
 		return nil, nil, xerrors.Errorf("set burnt funds account actor: %w", err)
 	}
 
 	// Create accounts
-	for _, info := range template.Accounts {
-
-		switch info.Type {
-		case genesis.TAccount:
-			if err := createAccountActor(ctx, cst, state, info, keyIDs); err != nil {
-				return nil, nil, xerrors.Errorf("failed to create account actor: %w", err)
-			}
-
-		case genesis.TMultisig:
-
-			ida, err := address.NewIDAddress(uint64(idStart))
-			if err != nil {
-				return nil, nil, err
-			}
-			idStart++
-
-			if err := createMultisigAccount(ctx, bs, cst, state, ida, info, keyIDs); err != nil {
-				return nil, nil, err
-			}
-		default:
+	for id, info := range template.Accounts {
+		if info.Type != genesis.TAccount && info.Type != genesis.TMultisig {
 			return nil, nil, xerrors.New("unsupported account type")
 		}
 
+		ida, err := address.NewIDAddress(uint64(AccountStart + id))
+		if err != nil {
+			return nil, nil, err
+		}
+
+		if err = createAccount(ctx, bs, cst, state, ida, info); err != nil {
+			return nil, nil, err
+		}
+
 	}
 
 	vregroot, err := address.NewIDAddress(80)
@@ -237,8 +222,8 @@ func MakeInitialStateTree(ctx context.Context, bs bstore.Blockstore, template ge
 		return nil, nil, err
 	}
 
-	if err = createMultisigAccount(ctx, bs, cst, state, vregroot, template.VerifregRootKey, keyIDs); err != nil {
-		return nil, nil, xerrors.Errorf("failed to set up verified registry signer: %w", err)
+	if err = createAccount(ctx, bs, cst, state, vregroot, template.VerifregRootKey); err != nil {
+		return nil, nil, err
 	}
 
 	// Setup the first verifier as ID-address 81
@@ -273,132 +258,63 @@ func MakeInitialStateTree(ctx context.Context, bs bstore.Blockstore, template ge
 		Balance: types.NewInt(0),
 		Head:    verifierState,
 	})
+
 	if err != nil {
 		return nil, nil, xerrors.Errorf("setting account from actmap: %w", err)
 	}
 
-	totalFilAllocated := big.Zero()
-
-	// flush as ForEach works on the HAMT
-	if _, err := state.Flush(ctx); err != nil {
-		return nil, nil, err
-	}
-	err = state.ForEach(func(addr address.Address, act *types.Actor) error {
-		totalFilAllocated = big.Add(totalFilAllocated, act.Balance)
-		return nil
-	})
-	if err != nil {
-		return nil, nil, xerrors.Errorf("summing account balances in state tree: %w", err)
-	}
-
-	totalFil := big.Mul(big.NewInt(int64(build.FilBase)), big.NewInt(int64(build.FilecoinPrecision)))
-	remainingFil := big.Sub(totalFil, totalFilAllocated)
-	if remainingFil.Sign() < 0 {
-		return nil, nil, xerrors.Errorf("somehow overallocated filecoin (allocated = %s)", types.FIL(totalFilAllocated))
-	}
-
-	remAccKey, err := address.NewIDAddress(90)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	template.RemainderAccount.Balance = remainingFil
-
-	if err := createMultisigAccount(ctx, bs, cst, state, remAccKey, template.RemainderAccount, keyIDs); err != nil {
-		return nil, nil, xerrors.Errorf("failed to set up remainder account: %w", err)
-	}
-
 	return state, keyIDs, nil
 }
 
-func createAccountActor(ctx context.Context, cst cbor.IpldStore, state *state.StateTree, info genesis.Actor, keyIDs map[address.Address]address.Address) error {
-	var ainfo genesis.AccountMeta
-	if err := json.Unmarshal(info.Meta, &ainfo); err != nil {
-		return xerrors.Errorf("unmarshaling account meta: %w", err)
-	}
-	st, err := cst.Put(ctx, &account.State{Address: ainfo.Owner})
-	if err != nil {
-		return err
-	}
-
-	ida, ok := keyIDs[ainfo.Owner]
-	if !ok {
-		return fmt.Errorf("no registered ID for account actor: %s", ainfo.Owner)
-	}
-
-	err = state.SetActor(ida, &types.Actor{
-		Code:    builtin.AccountActorCodeID,
-		Balance: info.Balance,
-		Head:    st,
-	})
-	if err != nil {
-		return xerrors.Errorf("setting account from actmap: %w", err)
-	}
-	return nil
-}
-
-func createMultisigAccount(ctx context.Context, bs bstore.Blockstore, cst cbor.IpldStore, state *state.StateTree, ida address.Address, info genesis.Actor, keyIDs map[address.Address]address.Address) error {
-	if info.Type != genesis.TMultisig {
-		return fmt.Errorf("can only call createMultisigAccount with multisig Actor info")
-	}
-	var ainfo genesis.MultisigMeta
-	if err := json.Unmarshal(info.Meta, &ainfo); err != nil {
-		return xerrors.Errorf("unmarshaling account meta: %w", err)
-	}
-	pending, err := adt.MakeEmptyMap(adt.WrapStore(ctx, cst)).Root()
-	if err != nil {
-		return xerrors.Errorf("failed to create empty map: %v", err)
-	}
-
-	var signers []address.Address
-
-	for _, e := range ainfo.Signers {
-		idAddress, ok := keyIDs[e]
-		if !ok {
-			return fmt.Errorf("no registered key ID for signer: %s", e)
+func createAccount(ctx context.Context, bs bstore.Blockstore, cst cbor.IpldStore, state *state.StateTree, ida address.Address, info genesis.Actor) error {
+	if info.Type == genesis.TAccount {
+		var ainfo genesis.AccountMeta
+		if err := json.Unmarshal(info.Meta, &ainfo); err != nil {
+			return xerrors.Errorf("unmarshaling account meta: %w", err)
 		}
-
-		// Check if actor already exists
-		_, err := state.GetActor(e)
-		if err == nil {
-			signers = append(signers, idAddress)
-			continue
-		}
-
-		st, err := cst.Put(ctx, &account.State{Address: e})
+		st, err := cst.Put(ctx, &account.State{Address: ainfo.Owner})
 		if err != nil {
 			return err
 		}
-		err = state.SetActor(idAddress, &types.Actor{
+		err = state.SetActor(ida, &types.Actor{
 			Code:    builtin.AccountActorCodeID,
-			Balance: types.NewInt(0),
+			Balance: info.Balance,
+			Head:    st,
+		})
+		if err != nil {
+			return xerrors.Errorf("setting account from actmap: %w", err)
+		}
+	} else if info.Type == genesis.TMultisig {
+		var ainfo genesis.MultisigMeta
+		if err := json.Unmarshal(info.Meta, &ainfo); err != nil {
+			return xerrors.Errorf("unmarshaling account meta: %w", err)
+		}
+		pending, err := adt.MakeEmptyMap(adt.WrapStore(ctx, cst)).Root()
+		if err != nil {
+			return xerrors.Errorf("failed to create empty map: %v", err)
+		}
+
+		st, err := cst.Put(ctx, &multisig.State{
+			Signers:               ainfo.Signers,
+			NumApprovalsThreshold: uint64(ainfo.Threshold),
+			StartEpoch:            abi.ChainEpoch(ainfo.VestingStart),
+			UnlockDuration:        abi.ChainEpoch(ainfo.VestingDuration),
+			PendingTxns:           pending,
+			InitialBalance:        info.Balance,
+		})
+		if err != nil {
+			return err
+		}
+		err = state.SetActor(ida, &types.Actor{
+			Code:    builtin.MultisigActorCodeID,
+			Balance: info.Balance,
 			Head:    st,
 		})
 		if err != nil {
 			return xerrors.Errorf("setting account from actmap: %w", err)
 		}
-		signers = append(signers, idAddress)
 	}
 
-	st, err := cst.Put(ctx, &multisig.State{
-		Signers:               signers,
-		NumApprovalsThreshold: uint64(ainfo.Threshold),
-		StartEpoch:            abi.ChainEpoch(ainfo.VestingStart),
-		UnlockDuration:        abi.ChainEpoch(ainfo.VestingDuration),
-		PendingTxns:           pending,
-		InitialBalance:        info.Balance,
-	})
-	if err != nil {
-		return err
-	}
-	err = state.SetActor(ida, &types.Actor{
-		Code:    builtin.MultisigActorCodeID,
-		Balance: info.Balance,
-		Head:    st,
-	})
-	if err != nil {
-		return xerrors.Errorf("setting account from actmap: %w", err)
-	}
 	return nil
 }
 
@@ -406,31 +322,25 @@ func VerifyPreSealedData(ctx context.Context, cs *store.ChainStore, stateroot ci
 	verifNeeds := make(map[address.Address]abi.PaddedPieceSize)
 	var sum abi.PaddedPieceSize
 
-	nwv := func(context.Context, abi.ChainEpoch) network.Version {
-		return build.NewestNetworkVersion
-	}
-
 	vmopt := vm.VMOpts{
-		StateBase:      stateroot,
-		Epoch:          0,
-		Rand:           &fakeRand{},
-		Bstore:         cs.Blockstore(),
-		Syscalls:       mkFakedSigSyscalls(cs.VMSys()),
-		CircSupplyCalc: nil,
-		NtwkVersion:    nwv,
-		BaseFee:        types.NewInt(0),
+		StateBase:  stateroot,
+		Epoch:      0,
+		Rand:       &fakeRand{},
+		Bstore:     cs.Blockstore(),
+		Syscalls:   mkFakedSigSyscalls(cs.VMSys()),
+		VestedCalc: nil,
+		BaseFee:    types.NewInt(0),
 	}
 	vm, err := vm.NewVM(&vmopt)
 	if err != nil {
 		return cid.Undef, xerrors.Errorf("failed to create NewVM: %w", err)
 	}
 
-	for mi, m := range template.Miners {
-		for si, s := range m.Sectors {
-			if s.Deal.Provider != m.ID {
-				return cid.Undef, xerrors.Errorf("Sector %d in miner %d in template had mismatch in provider and miner ID: %s != %s", si, mi, s.Deal.Provider, m.ID)
-			}
+	for _, m := range template.Miners {
 
+		// Add the miner to the market actor's balance table
+		_, err = doExec(ctx, vm, builtin.StorageMarketActorAddr, m.Owner, builtin.MethodsMarket.AddBalance, mustEnc(adt.Empty))
+		for _, s := range m.Sectors {
 			amt := s.Deal.PieceSize
 			verifNeeds[keyIDs[s.Deal.Client]] += amt
 			sum += amt
@@ -520,38 +430,14 @@ func MakeGenesisBlock(ctx context.Context, bs bstore.Blockstore, sys vm.SyscallB
 
 	log.Infof("Empty Genesis root: %s", emptyroot)
 
-	tickBuf := make([]byte, 32)
-	_, _ = rand.Read(tickBuf)
 	genesisticket := &types.Ticket{
-		VRFProof: tickBuf,
-	}
-
-	filecoinGenesisCid, err := cid.Decode("bafyreiaqpwbbyjo4a42saasj36kkrpv4tsherf2e7bvezkert2a7dhonoi")
-	if err != nil {
-		return nil, xerrors.Errorf("failed to decode filecoin genesis block CID: %w", err)
-	}
-
-	if !expectedCid().Equals(filecoinGenesisCid) {
-		return nil, xerrors.Errorf("expectedCid != filecoinGenesisCid")
-	}
-
-	gblk, err := getGenesisBlock()
-	if err != nil {
-		return nil, xerrors.Errorf("failed to construct filecoin genesis block: %w", err)
-	}
-
-	if !filecoinGenesisCid.Equals(gblk.Cid()) {
-		return nil, xerrors.Errorf("filecoinGenesisCid != gblk.Cid")
-	}
-
-	if err := bs.Put(gblk); err != nil {
-		return nil, xerrors.Errorf("failed writing filecoin genesis block to blockstore: %w", err)
+		VRFProof: []byte("vrf proof0000000vrf proof0000000"),
 	}
 
 	b := &types.BlockHeader{
 		Miner:                 builtin.SystemActorAddr,
 		Ticket:                genesisticket,
-		Parents:               []cid.Cid{filecoinGenesisCid},
+		Parents:               []cid.Cid{},
 		Height:                0,
 		ParentWeight:          types.NewInt(0),
 		ParentStateRoot:       stateroot,

chain/gen/genesis/miners.go

@@ -6,10 +6,6 @@ import (
 	"fmt"
 	"math/rand"
 
-	"github.com/filecoin-project/lotus/build"
-
-	"github.com/filecoin-project/go-state-types/network"
-
 	"github.com/filecoin-project/lotus/chain/state"
 
 	"github.com/ipfs/go-cid"
@@ -18,15 +14,15 @@ 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/big"
-	"github.com/filecoin-project/go-state-types/crypto"
-	"github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper"
+	"github.com/filecoin-project/sector-storage/ffiwrapper"
+	"github.com/filecoin-project/specs-actors/actors/abi"
+	"github.com/filecoin-project/specs-actors/actors/abi/big"
 	"github.com/filecoin-project/specs-actors/actors/builtin"
 	"github.com/filecoin-project/specs-actors/actors/builtin/market"
 	"github.com/filecoin-project/specs-actors/actors/builtin/miner"
 	"github.com/filecoin-project/specs-actors/actors/builtin/power"
 	"github.com/filecoin-project/specs-actors/actors/builtin/reward"
+	"github.com/filecoin-project/specs-actors/actors/crypto"
 	"github.com/filecoin-project/specs-actors/actors/runtime"
 
 	"github.com/filecoin-project/lotus/chain/store"
@@ -61,23 +57,18 @@ func mkFakedSigSyscalls(base vm.SyscallBuilder) vm.SyscallBuilder {
 }
 
 func SetupStorageMiners(ctx context.Context, cs *store.ChainStore, sroot cid.Cid, miners []genesis.Miner) (cid.Cid, error) {
-	csc := func(context.Context, abi.ChainEpoch, *state.StateTree) (abi.TokenAmount, error) {
+	vc := func(context.Context, abi.ChainEpoch) (abi.TokenAmount, error) {
 		return big.Zero(), nil
 	}
 
-	nwv := func(context.Context, abi.ChainEpoch) network.Version {
-		return build.NewestNetworkVersion
-	}
-
 	vmopt := &vm.VMOpts{
-		StateBase:      sroot,
-		Epoch:          0,
-		Rand:           &fakeRand{},
-		Bstore:         cs.Blockstore(),
-		Syscalls:       mkFakedSigSyscalls(cs.VMSys()),
-		CircSupplyCalc: csc,
-		NtwkVersion:    nwv,
-		BaseFee:        types.NewInt(0),
+		StateBase:  sroot,
+		Epoch:      0,
+		Rand:       &fakeRand{},
+		Bstore:     cs.Blockstore(),
+		Syscalls:   mkFakedSigSyscalls(cs.VMSys()),
+		VestedCalc: vc,
+		BaseFee:    types.NewInt(0),
 	}
 
 	vm, err := vm.NewVM(vmopt)
@@ -138,9 +129,6 @@ func SetupStorageMiners(ctx context.Context, cs *store.ChainStore, sroot cid.Cid
 
 				return nil
 			})
-			if err != nil {
-				return cid.Undef, xerrors.Errorf("mutating state: %w", err)
-			}
 		}
 
 		// Add market funds
@@ -149,7 +137,7 @@ func SetupStorageMiners(ctx context.Context, cs *store.ChainStore, sroot cid.Cid
 			params := mustEnc(&minerInfos[i].maddr)
 			_, err := doExecValue(ctx, vm, builtin.StorageMarketActorAddr, m.Worker, m.MarketBalance, builtin.MethodsMarket.AddBalance, params)
 			if err != nil {
-				return cid.Undef, xerrors.Errorf("failed to create genesis miner (add balance): %w", err)
+				return cid.Undef, xerrors.Errorf("failed to create genesis miner: %w", err)
 			}
 		}
 
@@ -161,7 +149,7 @@ func SetupStorageMiners(ctx context.Context, cs *store.ChainStore, sroot cid.Cid
 
 				ret, err := doExecValue(ctx, vm, builtin.StorageMarketActorAddr, m.Worker, big.Zero(), builtin.MethodsMarket.PublishStorageDeals, mustEnc(params))
 				if err != nil {
-					return xerrors.Errorf("failed to create genesis miner (publish deals): %w", err)
+					return xerrors.Errorf("failed to create genesis miner: %w", err)
 				}
 				var ids market.PublishStorageDealsReturn
 				if err := ids.UnmarshalCBOR(bytes.NewReader(ret)); err != nil {
@@ -229,12 +217,9 @@ func SetupStorageMiners(ctx context.Context, cs *store.ChainStore, sroot cid.Cid
 		}
 
 		err = vm.MutateState(ctx, builtin.RewardActorAddr, func(sct cbor.IpldStore, st *reward.State) error {
-			*st = *reward.ConstructState(qaPow)
+			st = reward.ConstructState(qaPow)
 			return nil
 		})
-		if err != nil {
-			return cid.Undef, xerrors.Errorf("mutating state: %w", err)
-		}
 	}
 
 	for i, m := range miners {
@@ -259,7 +244,7 @@ func SetupStorageMiners(ctx context.Context, cs *store.ChainStore, sroot cid.Cid
 
 				// we've added fake power for this sector above, remove it now
 				err = vm.MutateState(ctx, builtin.StoragePowerActorAddr, func(cst cbor.IpldStore, st *power.State) error {
-					st.TotalQualityAdjPower = types.BigSub(st.TotalQualityAdjPower, sectorWeight) //nolint:scopelint
+					st.TotalQualityAdjPower = types.BigSub(st.TotalQualityAdjPower, sectorWeight)
 					st.TotalRawBytePower = types.BigSub(st.TotalRawBytePower, types.NewInt(uint64(m.SectorSize)))
 					return nil
 				})
@@ -277,8 +262,6 @@ func SetupStorageMiners(ctx context.Context, cs *store.ChainStore, sroot cid.Cid
 					return cid.Undef, xerrors.Errorf("getting current total power: %w", err)
 				}
 
-				pcd := miner.PreCommitDepositForPower(epochReward.ThisEpochRewardSmoothed, tpow.QualityAdjPowerSmoothed, sectorWeight)
-
 				pledge := miner.InitialPledgeForPower(
 					sectorWeight,
 					epochReward.ThisEpochBaselinePower,
@@ -288,8 +271,6 @@ func SetupStorageMiners(ctx context.Context, cs *store.ChainStore, sroot cid.Cid
 					circSupply(ctx, vm, minerInfos[i].maddr),
 				)
 
-				pledge = big.Add(pcd, pledge)
-
 				fmt.Println(types.FIL(pledge))
 				_, err = doExecValue(ctx, vm, minerInfos[i].maddr, m.Worker, pledge, builtin.MethodsMiner.PreCommitSector, mustEnc(params))
 				if err != nil {
@@ -337,15 +318,9 @@ func SetupStorageMiners(ctx context.Context, cs *store.ChainStore, sroot cid.Cid
 // TODO: copied from actors test harness, deduplicate or remove from here
 type fakeRand struct{}
 
-func (fr *fakeRand) GetChainRandomness(ctx context.Context, personalization crypto.DomainSeparationTag, randEpoch abi.ChainEpoch, entropy []byte) ([]byte, error) {
+func (fr *fakeRand) GetRandomness(ctx context.Context, personalization crypto.DomainSeparationTag, randEpoch abi.ChainEpoch, entropy []byte) ([]byte, error) {
 	out := make([]byte, 32)
-	_, _ = rand.New(rand.NewSource(int64(randEpoch * 1000))).Read(out) //nolint
-	return out, nil
-}
-
-func (fr *fakeRand) GetBeaconRandomness(ctx context.Context, personalization crypto.DomainSeparationTag, randEpoch abi.ChainEpoch, entropy []byte) ([]byte, error) {
-	out := make([]byte, 32)
-	_, _ = rand.New(rand.NewSource(int64(randEpoch))).Read(out) //nolint
+	_, _ = rand.New(rand.NewSource(int64(randEpoch))).Read(out)
 	return out, nil
 }
 

chain/gen/genesis/t01_init.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
-
 	"github.com/filecoin-project/go-address"
 
 	"github.com/filecoin-project/specs-actors/actors/builtin"
@@ -20,9 +19,9 @@ import (
 	bstore "github.com/filecoin-project/lotus/lib/blockstore"
 )
 
-func SetupInitActor(bs bstore.Blockstore, netname string, initialActors []genesis.Actor, rootVerifier genesis.Actor) (int64, *types.Actor, map[address.Address]address.Address, error) {
+func SetupInitActor(bs bstore.Blockstore, netname string, initialActors []genesis.Actor, rootVerifier genesis.Actor) (*types.Actor, map[address.Address]address.Address, error) {
 	if len(initialActors) > MaxAccounts {
-		return 0, nil, nil, xerrors.New("too many initial actors")
+		return nil, nil, xerrors.New("too many initial actors")
 	}
 
 	var ias init_.State
@@ -33,105 +32,55 @@ func SetupInitActor(bs bstore.Blockstore, netname string, initialActors []genesi
 	amap := adt.MakeEmptyMap(store)
 
 	keyToId := map[address.Address]address.Address{}
-	counter := int64(AccountStart)
 
-	for _, a := range initialActors {
+	for i, a := range initialActors {
 		if a.Type == genesis.TMultisig {
-			var ainfo genesis.MultisigMeta
-			if err := json.Unmarshal(a.Meta, &ainfo); err != nil {
-				return 0, nil, nil, xerrors.Errorf("unmarshaling account meta: %w", err)
-			}
-			for _, e := range ainfo.Signers {
-
-				if _, ok := keyToId[e]; ok {
-					continue
-				}
-
-				fmt.Printf("init set %s t0%d\n", e, counter)
-
-				value := cbg.CborInt(counter)
-				if err := amap.Put(adt.AddrKey(e), &value); err != nil {
-					return 0, nil, nil, err
-				}
-				counter = counter + 1
-				var err error
-				keyToId[e], err = address.NewIDAddress(uint64(value))
-				if err != nil {
-					return 0, nil, nil, err
-				}
-
-			}
-			// Need to add actors for all multisigs too
 			continue
 		}
 
 		if a.Type != genesis.TAccount {
-			return 0, nil, nil, xerrors.Errorf("unsupported account type: %s", a.Type)
+			return nil, nil, xerrors.Errorf("unsupported account type: %s", a.Type) // TODO: Support msig (skip here)
 		}
 
 		var ainfo genesis.AccountMeta
 		if err := json.Unmarshal(a.Meta, &ainfo); err != nil {
-			return 0, nil, nil, xerrors.Errorf("unmarshaling account meta: %w", err)
+			return nil, nil, xerrors.Errorf("unmarshaling account meta: %w", err)
 		}
 
-		fmt.Printf("init set %s t0%d\n", ainfo.Owner, counter)
+		fmt.Printf("init set %s t0%d\n", ainfo.Owner, AccountStart+int64(i))
 
-		value := cbg.CborInt(counter)
+		value := cbg.CborInt(AccountStart + int64(i))
 		if err := amap.Put(adt.AddrKey(ainfo.Owner), &value); err != nil {
-			return 0, nil, nil, err
+			return nil, nil, err
 		}
-		counter = counter + 1
 
 		var err error
 		keyToId[ainfo.Owner], err = address.NewIDAddress(uint64(value))
 		if err != nil {
-			return 0, nil, nil, err
+			return nil, nil, err
 		}
 	}
 
 	if rootVerifier.Type == genesis.TAccount {
 		var ainfo genesis.AccountMeta
 		if err := json.Unmarshal(rootVerifier.Meta, &ainfo); err != nil {
-			return 0, nil, nil, xerrors.Errorf("unmarshaling account meta: %w", err)
+			return nil, nil, xerrors.Errorf("unmarshaling account meta: %w", err)
 		}
 		value := cbg.CborInt(80)
 		if err := amap.Put(adt.AddrKey(ainfo.Owner), &value); err != nil {
-			return 0, nil, nil, err
-		}
-	} else if rootVerifier.Type == genesis.TMultisig {
-		var ainfo genesis.MultisigMeta
-		if err := json.Unmarshal(rootVerifier.Meta, &ainfo); err != nil {
-			return 0, nil, nil, xerrors.Errorf("unmarshaling account meta: %w", err)
-		}
-		for _, e := range ainfo.Signers {
-			if _, ok := keyToId[e]; ok {
-				continue
-			}
-			fmt.Printf("init set %s t0%d\n", e, counter)
-
-			value := cbg.CborInt(counter)
-			if err := amap.Put(adt.AddrKey(e), &value); err != nil {
-				return 0, nil, nil, err
-			}
-			counter = counter + 1
-			var err error
-			keyToId[e], err = address.NewIDAddress(uint64(value))
-			if err != nil {
-				return 0, nil, nil, err
-			}
-
+			return nil, nil, err
 		}
 	}
 
 	amapaddr, err := amap.Root()
 	if err != nil {
-		return 0, nil, nil, err
+		return nil, nil, err
 	}
 	ias.AddressMap = amapaddr
 
 	statecid, err := store.Put(store.Context(), &ias)
 	if err != nil {
-		return 0, nil, nil, err
+		return nil, nil, err
 	}
 
 	act := &types.Actor{
@@ -139,5 +88,5 @@ func SetupInitActor(bs bstore.Blockstore, netname string, initialActors []genesi
 		Head: statecid,
 	}
 
-	return counter, act, keyToId, nil
+	return act, keyToId, nil
 }

chain/gen/genesis/t02_reward.go

@@ -3,7 +3,7 @@ package genesis
 import (
 	"context"
 
-	"github.com/filecoin-project/go-state-types/big"
+	"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/reward"

chain/gen/genesis/util.go

@@ -4,7 +4,7 @@ import (
 	"context"
 
 	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/specs-actors/actors/abi"
 	cbg "github.com/whyrusleeping/cbor-gen"
 	"golang.org/x/xerrors"
 
@@ -21,10 +21,14 @@ func mustEnc(i cbg.CBORMarshaler) []byte {
 	return enc
 }
 
+func doExec(ctx context.Context, vm *vm.VM, to, from address.Address, method abi.MethodNum, params []byte) ([]byte, error) {
+	return doExecValue(ctx, vm, to, from, types.NewInt(0), method, params)
+}
+
 func doExecValue(ctx context.Context, vm *vm.VM, to, from address.Address, value types.BigInt, method abi.MethodNum, params []byte) ([]byte, error) {
 	act, err := vm.StateTree().GetActor(from)
 	if err != nil {
-		return nil, xerrors.Errorf("doExec failed to get from actor (%s): %w", from, err)
+		return nil, xerrors.Errorf("doExec failed to get from actor: %w", err)
 	}
 
 	ret, err := vm.ApplyImplicitMessage(ctx, &types.Message{

chain/gen/mining.go

@@ -3,7 +3,7 @@ package gen
 import (
 	"context"
 
-	"github.com/filecoin-project/go-state-types/crypto"
+	"github.com/filecoin-project/specs-actors/actors/crypto"
 	"github.com/filecoin-project/specs-actors/actors/util/adt"
 	cid "github.com/ipfs/go-cid"
 	cbor "github.com/ipfs/go-ipld-cbor"

chain/gen/slashfilter/slashfilter.go

@@ -9,8 +9,8 @@ import (
 	ds "github.com/ipfs/go-datastore"
 	"github.com/ipfs/go-datastore/namespace"
 
-	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/specs-actors/actors/abi"
 )
 
 type SlashFilter struct {

chain/market/fundmgr.go

@@ -4,8 +4,8 @@ import (
 	"context"
 	"sync"
 
-	"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"
 	"go.uber.org/fx"
 
 	"github.com/filecoin-project/specs-actors/actors/builtin"
@@ -14,6 +14,7 @@ import (
 
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/lotus/api"
+	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain/actors"
 	"github.com/filecoin-project/lotus/chain/events"
 	"github.com/filecoin-project/lotus/chain/events/state"
@@ -51,7 +52,7 @@ func StartFundManager(lc fx.Lifecycle, api API) *FundMgr {
 			match := func(oldTs, newTs *types.TipSet) (bool, events.StateChange, error) {
 				return dealDiffFn(ctx, oldTs.Key(), newTs.Key())
 			}
-			return ev.StateChanged(fm.checkFunc, fm.stateChanged, fm.revert, 0, events.NoTimeout, match)
+			return ev.StateChanged(fm.checkFunc, fm.stateChanged, fm.revert, int(build.MessageConfidence), events.NoTimeout, match)
 		},
 	})
 	return fm
@@ -59,7 +60,7 @@ func StartFundManager(lc fx.Lifecycle, api API) *FundMgr {
 
 type fundMgrAPI interface {
 	StateMarketBalance(context.Context, address.Address, types.TipSetKey) (api.MarketBalance, error)
-	MpoolPushMessage(context.Context, *types.Message, *api.MessageSendSpec) (*types.SignedMessage, error)
+	MpoolPushMessage(context.Context, *types.Message) (*types.SignedMessage, error)
 	StateLookupID(context.Context, address.Address, types.TipSetKey) (address.Address, error)
 }
 
@@ -91,10 +92,6 @@ func (fm *FundMgr) stateChanged(ts *types.TipSet, ts2 *types.TipSet, states even
 	// overwrite our in memory cache with new values from chain (chain is canonical)
 	fm.lk.Lock()
 	for addr, balanceChange := range changedBalances {
-		if fm.available[addr].Int != nil {
-			log.Infof("State balance change recorded, prev: %s, new: %s", fm.available[addr].String(), balanceChange.To.String())
-		}
-
 		fm.available[addr] = balanceChange.To
 	}
 	fm.lk.Unlock()
@@ -119,17 +116,15 @@ func (fm *FundMgr) EnsureAvailable(ctx context.Context, addr, wallet address.Add
 		return cid.Undef, err
 	}
 	fm.lk.Lock()
-	bal, err := fm.api.StateMarketBalance(ctx, addr, types.EmptyTSK)
-	if err != nil {
-		fm.lk.Unlock()
-		return cid.Undef, err
-	}
-
-	stateAvail := types.BigSub(bal.Escrow, bal.Locked)
-
 	avail, ok := fm.available[idAddr]
 	if !ok {
-		avail = stateAvail
+		bal, err := fm.api.StateMarketBalance(ctx, addr, types.EmptyTSK)
+		if err != nil {
+			fm.lk.Unlock()
+			return cid.Undef, err
+		}
+
+		avail = types.BigSub(bal.Escrow, bal.Locked)
 	}
 
 	toAdd := types.BigSub(amt, avail)
@@ -139,8 +134,6 @@ func (fm *FundMgr) EnsureAvailable(ctx context.Context, addr, wallet address.Add
 	fm.available[idAddr] = big.Add(avail, toAdd)
 	fm.lk.Unlock()
 
-	log.Infof("Funds operation w/ Expected Balance: %s, In State: %s, Requested: %s, Adding: %s", avail.String(), stateAvail.String(), amt.String(), toAdd.String())
-
 	if toAdd.LessThanEqual(big.Zero()) {
 		return cid.Undef, nil
 	}
@@ -156,7 +149,7 @@ func (fm *FundMgr) EnsureAvailable(ctx context.Context, addr, wallet address.Add
 		Value:  toAdd,
 		Method: builtin.MethodsMarket.AddBalance,
 		Params: params,
-	}, nil)
+	})
 	if err != nil {
 		return cid.Undef, err
 	}

chain/market/fundmgr_test.go

@@ -10,9 +10,9 @@ import (
 	"github.com/stretchr/testify/require"
 
 	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/go-state-types/crypto"
+	"github.com/filecoin-project/specs-actors/actors/abi"
 	"github.com/filecoin-project/specs-actors/actors/builtin"
+	"github.com/filecoin-project/specs-actors/actors/crypto"
 	tutils "github.com/filecoin-project/specs-actors/support/testing"
 
 	"github.com/filecoin-project/lotus/api"
@@ -36,7 +36,7 @@ func (fapi *fakeAPI) StateMarketBalance(context.Context, address.Address, types.
 	return fapi.returnedBalance, fapi.returnedBalanceErr
 }
 
-func (fapi *fakeAPI) MpoolPushMessage(ctx context.Context, msg *types.Message, spec *api.MessageSendSpec) (*types.SignedMessage, error) {
+func (fapi *fakeAPI) MpoolPushMessage(ctx context.Context, msg *types.Message) (*types.SignedMessage, error) {
 	fapi.receivedMessage = msg
 	return &types.SignedMessage{
 		Message:   *msg,
@@ -147,7 +147,6 @@ func TestAddFunds(t *testing.T) {
 	}
 
 	for testCase, data := range testCases {
-		//nolint:scopelint
 		t.Run(testCase, func(t *testing.T) {
 			ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
 			defer cancel()

chain/messagepool/block_proba.go

@@ -1,102 +0,0 @@
-package messagepool
-
-import (
-	"math"
-	"sync"
-)
-
-var noWinnersProbCache []float64
-var noWinnersProbOnce sync.Once
-
-func noWinnersProb() []float64 {
-	noWinnersProbOnce.Do(func() {
-		poissPdf := func(x float64) float64 {
-			const Mu = 5
-			lg, _ := math.Lgamma(x + 1)
-			result := math.Exp((math.Log(Mu) * x) - lg - Mu)
-			return result
-		}
-
-		out := make([]float64, 0, MaxBlocks)
-		for i := 0; i < MaxBlocks; i++ {
-			out = append(out, poissPdf(float64(i)))
-		}
-		noWinnersProbCache = out
-	})
-	return noWinnersProbCache
-}
-
-var noWinnersProbAssumingCache []float64
-var noWinnersProbAssumingOnce sync.Once
-
-func noWinnersProbAssumingMoreThanOne() []float64 {
-	noWinnersProbAssumingOnce.Do(func() {
-		cond := math.Log(-1 + math.Exp(5))
-		poissPdf := func(x float64) float64 {
-			const Mu = 5
-			lg, _ := math.Lgamma(x + 1)
-			result := math.Exp((math.Log(Mu) * x) - lg - cond)
-			return result
-		}
-
-		out := make([]float64, 0, MaxBlocks)
-		for i := 0; i < MaxBlocks; i++ {
-			out = append(out, poissPdf(float64(i+1)))
-		}
-		noWinnersProbAssumingCache = out
-	})
-	return noWinnersProbAssumingCache
-}
-
-func binomialCoefficient(n, k float64) float64 {
-	if k > n {
-		return math.NaN()
-	}
-	r := 1.0
-	for d := 1.0; d <= k; d++ {
-		r *= n
-		r /= d
-		n--
-	}
-	return r
-}
-
-func (mp *MessagePool) blockProbabilities(tq float64) []float64 {
-	noWinners := noWinnersProbAssumingMoreThanOne()
-
-	p := 1 - tq
-	binoPdf := func(x, trials float64) float64 {
-		// based on https://github.com/atgjack/prob
-		if x > trials {
-			return 0
-		}
-		if p == 0 {
-			if x == 0 {
-				return 1.0
-			}
-			return 0.0
-		}
-		if p == 1 {
-			if x == trials {
-				return 1.0
-			}
-			return 0.0
-		}
-		coef := binomialCoefficient(trials, x)
-		pow := math.Pow(p, x) * math.Pow(1-p, trials-x)
-		if math.IsInf(coef, 0) {
-			return 0
-		}
-		return coef * pow
-	}
-
-	out := make([]float64, 0, MaxBlocks)
-	for place := 0; place < MaxBlocks; place++ {
-		var pPlace float64
-		for otherWinners, pCase := range noWinners {
-			pPlace += pCase * binoPdf(float64(place), float64(otherWinners))
-		}
-		out = append(out, pPlace)
-	}
-	return out
-}

chain/messagepool/block_proba_test.go

@@ -1,43 +0,0 @@
-package messagepool
-
-import (
-	"math"
-	"math/rand"
-	"testing"
-	"time"
-)
-
-func TestBlockProbability(t *testing.T) {
-	mp := &MessagePool{}
-	bp := mp.blockProbabilities(1 - 0.15)
-	t.Logf("%+v\n", bp)
-	for i := 0; i < len(bp)-1; i++ {
-		if bp[i] < bp[i+1] {
-			t.Fatalf("expected decreasing block probabilities for this quality: %d %f %f",
-				i, bp[i], bp[i+1])
-		}
-	}
-}
-
-func TestWinnerProba(t *testing.T) {
-	rand.Seed(time.Now().UnixNano())
-	const N = 1000000
-	winnerProba := noWinnersProb()
-	sum := 0
-	for i := 0; i < N; i++ {
-		minersRand := rand.Float64()
-		j := 0
-		for ; j < MaxBlocks; j++ {
-			minersRand -= winnerProba[j]
-			if minersRand < 0 {
-				break
-			}
-		}
-		sum += j
-	}
-
-	if avg := float64(sum) / N; math.Abs(avg-5) > 0.01 {
-		t.Fatalf("avg too far off: %f", avg)
-	}
-
-}

chain/messagepool/config.go

@@ -2,7 +2,6 @@ package messagepool
 
 import (
 	"encoding/json"
-	"fmt"
 	"time"
 
 	"github.com/filecoin-project/lotus/chain/types"
@@ -15,7 +14,6 @@ var (
 	MemPoolSizeLimitHiDefault = 30000
 	MemPoolSizeLimitLoDefault = 20000
 	PruneCooldownDefault      = time.Minute
-	GasLimitOverestimation    = 1.25
 
 	ConfigKey = datastore.NewKey("/mpool/config")
 )
@@ -53,40 +51,23 @@ func (mp *MessagePool) GetConfig() *types.MpoolConfig {
 	return mp.cfg.Clone()
 }
 
-func validateConfg(cfg *types.MpoolConfig) error {
-	if cfg.ReplaceByFeeRatio < ReplaceByFeeRatioDefault {
-		return fmt.Errorf("'ReplaceByFeeRatio' is less than required %f < %f",
-			cfg.ReplaceByFeeRatio, ReplaceByFeeRatioDefault)
-	}
-	if cfg.GasLimitOverestimation < 1 {
-		return fmt.Errorf("'GasLimitOverestimation' cannot be less than 1")
-	}
-	return nil
-}
-
-func (mp *MessagePool) SetConfig(cfg *types.MpoolConfig) error {
-	if err := validateConfg(cfg); err != nil {
-		return err
-	}
+func (mp *MessagePool) SetConfig(cfg *types.MpoolConfig) {
 	cfg = cfg.Clone()
-
 	mp.cfgLk.Lock()
 	mp.cfg = cfg
+	mp.rbfNum = types.NewInt(uint64((cfg.ReplaceByFeeRatio - 1) * RbfDenom))
 	err := saveConfig(cfg, mp.ds)
 	if err != nil {
 		log.Warnf("error persisting mpool config: %s", err)
 	}
 	mp.cfgLk.Unlock()
-
-	return nil
 }
 
 func DefaultConfig() *types.MpoolConfig {
 	return &types.MpoolConfig{
-		SizeLimitHigh:          MemPoolSizeLimitHiDefault,
-		SizeLimitLow:           MemPoolSizeLimitLoDefault,
-		ReplaceByFeeRatio:      ReplaceByFeeRatioDefault,
-		PruneCooldown:          PruneCooldownDefault,
-		GasLimitOverestimation: GasLimitOverestimation,
+		SizeLimitHigh:     MemPoolSizeLimitHiDefault,
+		SizeLimitLow:      MemPoolSizeLimitLoDefault,
+		ReplaceByFeeRatio: ReplaceByFeeRatioDefault,
+		PruneCooldown:     PruneCooldownDefault,
 	}
 }

chain/messagepool/gasguess/guessgas.go

@@ -9,7 +9,7 @@ import (
 	"github.com/filecoin-project/lotus/chain/types"
 
 	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/specs-actors/actors/abi"
 	"github.com/filecoin-project/specs-actors/actors/builtin"
 )
 

chain/messagepool/messagepool_test.go

@@ -3,19 +3,16 @@ package messagepool
 import (
 	"context"
 	"fmt"
-	"sort"
 	"testing"
 
 	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/go-state-types/crypto"
-	"github.com/filecoin-project/lotus/chain/messagepool/gasguess"
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/chain/types/mock"
 	"github.com/filecoin-project/lotus/chain/wallet"
 	_ "github.com/filecoin-project/lotus/lib/sigs/bls"
 	_ "github.com/filecoin-project/lotus/lib/sigs/secp"
 	"github.com/filecoin-project/specs-actors/actors/builtin"
+	"github.com/filecoin-project/specs-actors/actors/crypto"
 	"github.com/ipfs/go-cid"
 	"github.com/ipfs/go-datastore"
 	logging "github.com/ipfs/go-log/v2"
@@ -33,35 +30,14 @@ type testMpoolAPI struct {
 	balance    map[address.Address]types.BigInt
 
 	tipsets []*types.TipSet
-
-	published int
-
-	baseFee types.BigInt
 }
 
 func newTestMpoolAPI() *testMpoolAPI {
-	tma := &testMpoolAPI{
+	return &testMpoolAPI{
 		bmsgs:      make(map[cid.Cid][]*types.SignedMessage),
 		statenonce: make(map[address.Address]uint64),
 		balance:    make(map[address.Address]types.BigInt),
-		baseFee:    types.NewInt(100),
 	}
-	genesis := mock.MkBlock(nil, 1, 1)
-	tma.tipsets = append(tma.tipsets, mock.TipSet(genesis))
-	return tma
-}
-
-func (tma *testMpoolAPI) nextBlock() *types.BlockHeader {
-	newBlk := mock.MkBlock(tma.tipsets[len(tma.tipsets)-1], 1, 1)
-	tma.tipsets = append(tma.tipsets, mock.TipSet(newBlk))
-	return newBlk
-}
-
-func (tma *testMpoolAPI) nextBlockWithHeight(height uint64) *types.BlockHeader {
-	newBlk := mock.MkBlock(tma.tipsets[len(tma.tipsets)-1], 1, 1)
-	newBlk.Height = abi.ChainEpoch(height)
-	tma.tipsets = append(tma.tipsets, mock.TipSet(newBlk))
-	return newBlk
 }
 
 func (tma *testMpoolAPI) applyBlock(t *testing.T, b *types.BlockHeader) {
@@ -92,11 +68,12 @@ func (tma *testMpoolAPI) setBalanceRaw(addr address.Address, v types.BigInt) {
 
 func (tma *testMpoolAPI) setBlockMessages(h *types.BlockHeader, msgs ...*types.SignedMessage) {
 	tma.bmsgs[h.Cid()] = msgs
+	tma.tipsets = append(tma.tipsets, mock.TipSet(h))
 }
 
 func (tma *testMpoolAPI) SubscribeHeadChanges(cb func(rev, app []*types.TipSet) error) *types.TipSet {
 	tma.cb = cb
-	return tma.tipsets[0]
+	return nil
 }
 
 func (tma *testMpoolAPI) PutMessage(m types.ChainMsg) (cid.Cid, error) {
@@ -104,47 +81,18 @@ func (tma *testMpoolAPI) PutMessage(m types.ChainMsg) (cid.Cid, error) {
 }
 
 func (tma *testMpoolAPI) PubSubPublish(string, []byte) error {
-	tma.published++
 	return nil
 }
 
-func (tma *testMpoolAPI) GetActorAfter(addr address.Address, ts *types.TipSet) (*types.Actor, error) {
-	// regression check for load bug
-	if ts == nil {
-		panic("GetActorAfter called with nil tipset")
-	}
-
+func (tma *testMpoolAPI) StateGetActor(addr address.Address, ts *types.TipSet) (*types.Actor, error) {
 	balance, ok := tma.balance[addr]
 	if !ok {
 		balance = types.NewInt(1000e6)
 		tma.balance[addr] = balance
 	}
-
-	msgs := make([]*types.SignedMessage, 0)
-	for _, b := range ts.Blocks() {
-		for _, m := range tma.bmsgs[b.Cid()] {
-			if m.Message.From == addr {
-				msgs = append(msgs, m)
-			}
-		}
-	}
-
-	sort.Slice(msgs, func(i, j int) bool {
-		return msgs[i].Message.Nonce < msgs[j].Message.Nonce
-	})
-
-	nonce := tma.statenonce[addr]
-
-	for _, m := range msgs {
-		if m.Message.Nonce != nonce {
-			break
-		}
-		nonce++
-	}
-
 	return &types.Actor{
 		Code:    builtin.StorageMarketActorCodeID,
-		Nonce:   nonce,
+		Nonce:   tma.statenonce[addr],
 		Balance: balance,
 	}, nil
 }
@@ -193,7 +141,7 @@ func (tma *testMpoolAPI) LoadTipSet(tsk types.TipSetKey) (*types.TipSet, error)
 }
 
 func (tma *testMpoolAPI) ChainComputeBaseFee(ctx context.Context, ts *types.TipSet) (types.BigInt, error) {
-	return tma.baseFee, nil
+	return types.NewInt(100), nil
 }
 
 func assertNonce(t *testing.T, mp *MessagePool, addr address.Address, val uint64) {
@@ -230,7 +178,7 @@ func TestMessagePool(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	a := tma.nextBlock()
+	a := mock.MkBlock(nil, 1, 1)
 
 	sender, err := w.GenerateKey(crypto.SigTypeBLS)
 	if err != nil {
@@ -256,56 +204,7 @@ func TestMessagePool(t *testing.T) {
 	assertNonce(t, mp, sender, 2)
 }
 
-func TestMessagePoolMessagesInEachBlock(t *testing.T) {
-	tma := newTestMpoolAPI()
-
-	w, err := wallet.NewWallet(wallet.NewMemKeyStore())
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	ds := datastore.NewMapDatastore()
-
-	mp, err := New(tma, ds, "mptest")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	a := tma.nextBlock()
-
-	sender, err := w.GenerateKey(crypto.SigTypeBLS)
-	if err != nil {
-		t.Fatal(err)
-	}
-	target := mock.Address(1001)
-
-	var msgs []*types.SignedMessage
-	for i := 0; i < 5; i++ {
-		m := mock.MkMessage(sender, target, uint64(i), w)
-		msgs = append(msgs, m)
-		mustAdd(t, mp, m)
-	}
-
-	tma.setStateNonce(sender, 0)
-
-	tma.setBlockMessages(a, msgs[0], msgs[1])
-	tma.applyBlock(t, a)
-	tsa := mock.TipSet(a)
-
-	_, _ = mp.Pending()
-
-	selm, _ := mp.SelectMessages(tsa, 1)
-	if len(selm) == 0 {
-		t.Fatal("should have returned the rest of the messages")
-	}
-}
-
 func TestRevertMessages(t *testing.T) {
-	futureDebug = true
-	defer func() {
-		futureDebug = false
-	}()
-
 	tma := newTestMpoolAPI()
 
 	w, err := wallet.NewWallet(wallet.NewMemKeyStore())
@@ -320,8 +219,8 @@ func TestRevertMessages(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	a := tma.nextBlock()
-	b := tma.nextBlock()
+	a := mock.MkBlock(nil, 1, 1)
+	b := mock.MkBlock(mock.TipSet(a), 1, 1)
 
 	sender, err := w.GenerateKey(crypto.SigTypeBLS)
 	if err != nil {
@@ -355,7 +254,6 @@ func TestRevertMessages(t *testing.T) {
 	assertNonce(t, mp, sender, 4)
 
 	p, _ := mp.Pending()
-	fmt.Printf("%+v\n", p)
 	if len(p) != 3 {
 		t.Fatal("expected three messages in mempool")
 	}
@@ -363,12 +261,6 @@ func TestRevertMessages(t *testing.T) {
 }
 
 func TestPruningSimple(t *testing.T) {
-	oldMaxNonceGap := MaxNonceGap
-	MaxNonceGap = 1000
-	defer func() {
-		MaxNonceGap = oldMaxNonceGap
-	}()
-
 	tma := newTestMpoolAPI()
 
 	w, err := wallet.NewWallet(wallet.NewMemKeyStore())
@@ -383,14 +275,13 @@ func TestPruningSimple(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	a := tma.nextBlock()
+	a := mock.MkBlock(nil, 1, 1)
 	tma.applyBlock(t, a)
 
 	sender, err := w.GenerateKey(crypto.SigTypeBLS)
 	if err != nil {
 		t.Fatal(err)
 	}
-	tma.setBalance(sender, 1) // in FIL
 	target := mock.Address(1001)
 
 	for i := 0; i < 5; i++ {
@@ -417,257 +308,3 @@ func TestPruningSimple(t *testing.T) {
 		t.Fatal("expected only 5 messages in pool, got: ", len(msgs))
 	}
 }
-
-func TestLoadLocal(t *testing.T) {
-	tma := newTestMpoolAPI()
-	ds := datastore.NewMapDatastore()
-
-	mp, err := New(tma, ds, "mptest")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	// the actors
-	w1, err := wallet.NewWallet(wallet.NewMemKeyStore())
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	a1, err := w1.GenerateKey(crypto.SigTypeSecp256k1)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	w2, err := wallet.NewWallet(wallet.NewMemKeyStore())
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	a2, err := w2.GenerateKey(crypto.SigTypeSecp256k1)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	tma.setBalance(a1, 1) // in FIL
-	tma.setBalance(a2, 1) // in FIL
-	gasLimit := gasguess.Costs[gasguess.CostKey{Code: builtin.StorageMarketActorCodeID, M: 2}]
-	msgs := make(map[cid.Cid]struct{})
-	for i := 0; i < 10; i++ {
-		m := makeTestMessage(w1, a1, a2, uint64(i), gasLimit, uint64(i+1))
-		cid, err := mp.Push(m)
-		if err != nil {
-			t.Fatal(err)
-		}
-		msgs[cid] = struct{}{}
-	}
-	err = mp.Close()
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	mp, err = New(tma, ds, "mptest")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	pmsgs, _ := mp.Pending()
-	if len(msgs) != len(pmsgs) {
-		t.Fatalf("expected %d messages, but got %d", len(msgs), len(pmsgs))
-	}
-
-	for _, m := range pmsgs {
-		cid := m.Cid()
-		_, ok := msgs[cid]
-		if !ok {
-			t.Fatal("unknown message")
-		}
-
-		delete(msgs, cid)
-	}
-
-	if len(msgs) > 0 {
-		t.Fatalf("not all messages were laoded; missing %d messages", len(msgs))
-	}
-}
-
-func TestClearAll(t *testing.T) {
-	tma := newTestMpoolAPI()
-	ds := datastore.NewMapDatastore()
-
-	mp, err := New(tma, ds, "mptest")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	// the actors
-	w1, err := wallet.NewWallet(wallet.NewMemKeyStore())
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	a1, err := w1.GenerateKey(crypto.SigTypeSecp256k1)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	w2, err := wallet.NewWallet(wallet.NewMemKeyStore())
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	a2, err := w2.GenerateKey(crypto.SigTypeSecp256k1)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	tma.setBalance(a1, 1) // in FIL
-	tma.setBalance(a2, 1) // in FIL
-	gasLimit := gasguess.Costs[gasguess.CostKey{Code: builtin.StorageMarketActorCodeID, M: 2}]
-	for i := 0; i < 10; i++ {
-		m := makeTestMessage(w1, a1, a2, uint64(i), gasLimit, uint64(i+1))
-		_, err := mp.Push(m)
-		if err != nil {
-			t.Fatal(err)
-		}
-	}
-
-	for i := 0; i < 10; i++ {
-		m := makeTestMessage(w2, a2, a1, uint64(i), gasLimit, uint64(i+1))
-		mustAdd(t, mp, m)
-	}
-
-	mp.Clear(true)
-
-	pending, _ := mp.Pending()
-	if len(pending) > 0 {
-		t.Fatalf("cleared the mpool, but got %d pending messages", len(pending))
-	}
-}
-
-func TestClearNonLocal(t *testing.T) {
-	tma := newTestMpoolAPI()
-	ds := datastore.NewMapDatastore()
-
-	mp, err := New(tma, ds, "mptest")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	// the actors
-	w1, err := wallet.NewWallet(wallet.NewMemKeyStore())
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	a1, err := w1.GenerateKey(crypto.SigTypeSecp256k1)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	w2, err := wallet.NewWallet(wallet.NewMemKeyStore())
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	a2, err := w2.GenerateKey(crypto.SigTypeSecp256k1)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	tma.setBalance(a1, 1) // in FIL
-	tma.setBalance(a2, 1) // in FIL
-
-	gasLimit := gasguess.Costs[gasguess.CostKey{Code: builtin.StorageMarketActorCodeID, M: 2}]
-	for i := 0; i < 10; i++ {
-		m := makeTestMessage(w1, a1, a2, uint64(i), gasLimit, uint64(i+1))
-		_, err := mp.Push(m)
-		if err != nil {
-			t.Fatal(err)
-		}
-	}
-
-	for i := 0; i < 10; i++ {
-		m := makeTestMessage(w2, a2, a1, uint64(i), gasLimit, uint64(i+1))
-		mustAdd(t, mp, m)
-	}
-
-	mp.Clear(false)
-
-	pending, _ := mp.Pending()
-	if len(pending) != 10 {
-		t.Fatalf("expected 10 pending messages, but got %d instead", len(pending))
-	}
-
-	for _, m := range pending {
-		if m.Message.From != a1 {
-			t.Fatalf("expected message from %s but got one from %s instead", a1, m.Message.From)
-		}
-	}
-}
-
-func TestUpdates(t *testing.T) {
-	tma := newTestMpoolAPI()
-	ds := datastore.NewMapDatastore()
-
-	mp, err := New(tma, ds, "mptest")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	// the actors
-	w1, err := wallet.NewWallet(wallet.NewMemKeyStore())
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	a1, err := w1.GenerateKey(crypto.SigTypeSecp256k1)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	w2, err := wallet.NewWallet(wallet.NewMemKeyStore())
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	a2, err := w2.GenerateKey(crypto.SigTypeSecp256k1)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	ctx, cancel := context.WithCancel(context.TODO())
-	defer cancel()
-
-	ch, err := mp.Updates(ctx)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	gasLimit := gasguess.Costs[gasguess.CostKey{Code: builtin.StorageMarketActorCodeID, M: 2}]
-
-	tma.setBalance(a1, 1) // in FIL
-	tma.setBalance(a2, 1) // in FIL
-
-	for i := 0; i < 10; i++ {
-		m := makeTestMessage(w1, a1, a2, uint64(i), gasLimit, uint64(i+1))
-		_, err := mp.Push(m)
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		_, ok := <-ch
-		if !ok {
-			t.Fatal("expected update, but got a closed channel instead")
-		}
-	}
-
-	err = mp.Close()
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	_, ok := <-ch
-	if ok {
-		t.Fatal("expected closed channel, but got an update instead")
-	}
-}

chain/messagepool/provider.go

@@ -1,81 +0,0 @@
-package messagepool
-
-import (
-	"context"
-
-	"github.com/ipfs/go-cid"
-	pubsub "github.com/libp2p/go-libp2p-pubsub"
-	"golang.org/x/xerrors"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/lotus/chain/stmgr"
-	"github.com/filecoin-project/lotus/chain/types"
-)
-
-type Provider interface {
-	SubscribeHeadChanges(func(rev, app []*types.TipSet) error) *types.TipSet
-	PutMessage(m types.ChainMsg) (cid.Cid, error)
-	PubSubPublish(string, []byte) error
-	GetActorAfter(address.Address, *types.TipSet) (*types.Actor, error)
-	StateAccountKey(context.Context, address.Address, *types.TipSet) (address.Address, error)
-	MessagesForBlock(*types.BlockHeader) ([]*types.Message, []*types.SignedMessage, error)
-	MessagesForTipset(*types.TipSet) ([]types.ChainMsg, error)
-	LoadTipSet(tsk types.TipSetKey) (*types.TipSet, error)
-	ChainComputeBaseFee(ctx context.Context, ts *types.TipSet) (types.BigInt, error)
-}
-
-type mpoolProvider struct {
-	sm *stmgr.StateManager
-	ps *pubsub.PubSub
-}
-
-func NewProvider(sm *stmgr.StateManager, ps *pubsub.PubSub) Provider {
-	return &mpoolProvider{sm: sm, ps: ps}
-}
-
-func (mpp *mpoolProvider) SubscribeHeadChanges(cb func(rev, app []*types.TipSet) error) *types.TipSet {
-	mpp.sm.ChainStore().SubscribeHeadChanges(cb)
-	return mpp.sm.ChainStore().GetHeaviestTipSet()
-}
-
-func (mpp *mpoolProvider) PutMessage(m types.ChainMsg) (cid.Cid, error) {
-	return mpp.sm.ChainStore().PutMessage(m)
-}
-
-func (mpp *mpoolProvider) PubSubPublish(k string, v []byte) error {
-	return mpp.ps.Publish(k, v) //nolint
-}
-
-func (mpp *mpoolProvider) GetActorAfter(addr address.Address, ts *types.TipSet) (*types.Actor, error) {
-	var act types.Actor
-	stcid, _, err := mpp.sm.TipSetState(context.TODO(), ts)
-	if err != nil {
-		return nil, xerrors.Errorf("computing tipset state for GetActor: %w", err)
-	}
-
-	return &act, mpp.sm.WithStateTree(stcid, mpp.sm.WithActor(addr, stmgr.GetActor(&act)))
-}
-
-func (mpp *mpoolProvider) StateAccountKey(ctx context.Context, addr address.Address, ts *types.TipSet) (address.Address, error) {
-	return mpp.sm.ResolveToKeyAddress(ctx, addr, ts)
-}
-
-func (mpp *mpoolProvider) MessagesForBlock(h *types.BlockHeader) ([]*types.Message, []*types.SignedMessage, error) {
-	return mpp.sm.ChainStore().MessagesForBlock(h)
-}
-
-func (mpp *mpoolProvider) MessagesForTipset(ts *types.TipSet) ([]types.ChainMsg, error) {
-	return mpp.sm.ChainStore().MessagesForTipset(ts)
-}
-
-func (mpp *mpoolProvider) LoadTipSet(tsk types.TipSetKey) (*types.TipSet, error) {
-	return mpp.sm.ChainStore().LoadTipSet(tsk)
-}
-
-func (mpp *mpoolProvider) ChainComputeBaseFee(ctx context.Context, ts *types.TipSet) (types.BigInt, error) {
-	baseFee, err := mpp.sm.ChainStore().ComputeBaseFee(ctx, ts)
-	if err != nil {
-		return types.NewInt(0), xerrors.Errorf("computing base fee at %s: %w", ts, err)
-	}
-	return baseFee, nil
-}

chain/messagepool/pruning.go

@@ -98,7 +98,7 @@ keepLoop:
 	// and remove all messages that are still in pruneMsgs after processing the chains
 	log.Infof("Pruning %d messages", len(pruneMsgs))
 	for _, m := range pruneMsgs {
-		mp.remove(m.Message.From, m.Message.Nonce, false)
+		mp.remove(m.Message.From, m.Message.Nonce)
 	}
 
 	return nil

chain/messagepool/repub.go

@@ -1,165 +0,0 @@
-package messagepool
-
-import (
-	"context"
-	"sort"
-	"time"
-
-	"golang.org/x/xerrors"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/lotus/build"
-	"github.com/filecoin-project/lotus/chain/messagepool/gasguess"
-	"github.com/filecoin-project/lotus/chain/types"
-	"github.com/ipfs/go-cid"
-)
-
-const repubMsgLimit = 30
-
-var RepublishBatchDelay = 100 * time.Millisecond
-
-func (mp *MessagePool) republishPendingMessages() error {
-	mp.curTsLk.Lock()
-	ts := mp.curTs
-
-	baseFee, err := mp.api.ChainComputeBaseFee(context.TODO(), ts)
-	if err != nil {
-		mp.curTsLk.Unlock()
-		return xerrors.Errorf("computing basefee: %w", err)
-	}
-
-	baseFeeLowerBound := types.BigDiv(baseFee, baseFeeLowerBoundFactor)
-	if baseFeeLowerBoundFactor.LessThan(minimumBaseFee) {
-		baseFeeLowerBound = minimumBaseFee
-	}
-
-	pending := make(map[address.Address]map[uint64]*types.SignedMessage)
-	mp.lk.Lock()
-	mp.republished = nil // clear this to avoid races triggering an early republish
-	for actor := range mp.localAddrs {
-		mset, ok := mp.pending[actor]
-		if !ok {
-			continue
-		}
-		if len(mset.msgs) == 0 {
-			continue
-		}
-		// we need to copy this while holding the lock to avoid races with concurrent modification
-		pend := make(map[uint64]*types.SignedMessage, len(mset.msgs))
-		for nonce, m := range mset.msgs {
-			pend[nonce] = m
-		}
-		pending[actor] = pend
-	}
-	mp.lk.Unlock()
-	mp.curTsLk.Unlock()
-
-	if len(pending) == 0 {
-		return nil
-	}
-
-	var chains []*msgChain
-	for actor, mset := range pending {
-		// We use the baseFee lower bound for createChange so that we optimistically include
-		// chains that might become profitable in the next 20 blocks.
-		// We still check the lowerBound condition for individual messages so that we don't send
-		// messages that will be rejected by the mpool spam protector, so this is safe to do.
-		next := mp.createMessageChains(actor, mset, baseFeeLowerBound, ts)
-		chains = append(chains, next...)
-	}
-
-	if len(chains) == 0 {
-		return nil
-	}
-
-	sort.Slice(chains, func(i, j int) bool {
-		return chains[i].Before(chains[j])
-	})
-
-	gasLimit := int64(build.BlockGasLimit)
-	minGas := int64(gasguess.MinGas)
-	var msgs []*types.SignedMessage
-loop:
-	for i := 0; i < len(chains); {
-		chain := chains[i]
-
-		// we can exceed this if we have picked (some) longer chain already
-		if len(msgs) > repubMsgLimit {
-			break
-		}
-
-		// there is not enough gas for any message
-		if gasLimit <= minGas {
-			break
-		}
-
-		// has the chain been invalidated?
-		if !chain.valid {
-			i++
-			continue
-		}
-
-		// does it fit in a block?
-		if chain.gasLimit <= gasLimit {
-			// check the baseFee lower bound -- only republish messages that can be included in the chain
-			// within the next 20 blocks.
-			for _, m := range chain.msgs {
-				if !allowNegativeChains(ts.Height()) && m.Message.GasFeeCap.LessThan(baseFeeLowerBound) {
-					chain.Invalidate()
-					continue loop
-				}
-				gasLimit -= m.Message.GasLimit
-				msgs = append(msgs, m)
-			}
-
-			// we processed the whole chain, advance
-			i++
-			continue
-		}
-
-		// we can't fit the current chain but there is gas to spare
-		// trim it and push it down
-		chain.Trim(gasLimit, mp, baseFee, true)
-		for j := i; j < len(chains)-1; j++ {
-			if chains[j].Before(chains[j+1]) {
-				break
-			}
-			chains[j], chains[j+1] = chains[j+1], chains[j]
-		}
-	}
-
-	count := 0
-	log.Infof("republishing %d messages", len(msgs))
-	for _, m := range msgs {
-		mb, err := m.Serialize()
-		if err != nil {
-			return xerrors.Errorf("cannot serialize message: %w", err)
-		}
-
-		err = mp.api.PubSubPublish(build.MessagesTopic(mp.netName), mb)
-		if err != nil {
-			return xerrors.Errorf("cannot publish: %w", err)
-		}
-
-		count++
-
-		if count < len(msgs) {
-			// this delay is here to encourage the pubsub subsystem to process the messages serially
-			// and avoid creating nonce gaps because of concurrent validation.
-			time.Sleep(RepublishBatchDelay)
-		}
-	}
-
-	// track most recently republished messages
-	republished := make(map[cid.Cid]struct{})
-	for _, m := range msgs[:count] {
-		republished[m.Cid()] = struct{}{}
-	}
-
-	mp.lk.Lock()
-	// update the republished set so that we can trigger early republish from head changes
-	mp.republished = republished
-	mp.lk.Unlock()
-
-	return nil
-}

chain/messagepool/repub_test.go

@@ -1,72 +0,0 @@
-package messagepool
-
-import (
-	"testing"
-	"time"
-
-	"github.com/filecoin-project/go-state-types/crypto"
-	"github.com/filecoin-project/lotus/chain/messagepool/gasguess"
-	"github.com/filecoin-project/lotus/chain/wallet"
-	"github.com/filecoin-project/specs-actors/actors/builtin"
-	"github.com/ipfs/go-datastore"
-)
-
-func TestRepubMessages(t *testing.T) {
-	oldRepublishBatchDelay := RepublishBatchDelay
-	RepublishBatchDelay = time.Microsecond
-	defer func() {
-		RepublishBatchDelay = oldRepublishBatchDelay
-	}()
-
-	tma := newTestMpoolAPI()
-	ds := datastore.NewMapDatastore()
-
-	mp, err := New(tma, ds, "mptest")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	// the actors
-	w1, err := wallet.NewWallet(wallet.NewMemKeyStore())
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	a1, err := w1.GenerateKey(crypto.SigTypeSecp256k1)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	w2, err := wallet.NewWallet(wallet.NewMemKeyStore())
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	a2, err := w2.GenerateKey(crypto.SigTypeSecp256k1)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	gasLimit := gasguess.Costs[gasguess.CostKey{Code: builtin.StorageMarketActorCodeID, M: 2}]
-
-	tma.setBalance(a1, 1) // in FIL
-
-	for i := 0; i < 10; i++ {
-		m := makeTestMessage(w1, a1, a2, uint64(i), gasLimit, uint64(i+1))
-		_, err := mp.Push(m)
-		if err != nil {
-			t.Fatal(err)
-		}
-	}
-
-	if tma.published != 10 {
-		t.Fatalf("expected to have published 10 messages, but got %d instead", tma.published)
-	}
-
-	mp.repubTrigger <- struct{}{}
-	time.Sleep(100 * time.Millisecond)
-
-	if tma.published != 20 {
-		t.Fatalf("expected to have published 20 messages, but got %d instead", tma.published)
-	}
-}

chain/messagepool/selection.go

@@ -3,387 +3,42 @@ package messagepool
 import (
 	"context"
 	"math/big"
-	"math/rand"
 	"sort"
 	"time"
 
 	"golang.org/x/xerrors"
 
 	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/abi"
-	tbig "github.com/filecoin-project/go-state-types/big"
 	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain/messagepool/gasguess"
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/chain/vm"
+	abig "github.com/filecoin-project/specs-actors/actors/abi/big"
+	"github.com/ipfs/go-cid"
 )
 
 var bigBlockGasLimit = big.NewInt(build.BlockGasLimit)
 
-// this is *temporary* mutilation until we have implemented uncapped miner penalties -- it will go
-// away in the next fork.
-func allowNegativeChains(epoch abi.ChainEpoch) bool {
-	return epoch < build.UpgradeBreezeHeight+5
-}
-
-const MaxBlocks = 15
-
 type msgChain struct {
-	msgs         []*types.SignedMessage
-	gasReward    *big.Int
-	gasLimit     int64
-	gasPerf      float64
-	effPerf      float64
-	bp           float64
-	parentOffset float64
-	valid        bool
-	merged       bool
-	next         *msgChain
-	prev         *msgChain
+	msgs      []*types.SignedMessage
+	gasReward *big.Int
+	gasLimit  int64
+	gasPerf   float64
+	valid     bool
+	next      *msgChain
 }
 
-func (mp *MessagePool) SelectMessages(ts *types.TipSet, tq float64) ([]*types.SignedMessage, error) {
+func (mp *MessagePool) SelectMessages(ts *types.TipSet) ([]*types.SignedMessage, error) {
 	mp.curTsLk.Lock()
 	defer mp.curTsLk.Unlock()
 
 	mp.lk.Lock()
 	defer mp.lk.Unlock()
 
-	// if the ticket quality is high enough that the first block has higher probability
-	// than any other block, then we don't bother with optimal selection because the
-	// first block will always have higher effective performance
-	if tq > 0.84 {
-		return mp.selectMessagesGreedy(mp.curTs, ts)
-	}
-
-	return mp.selectMessagesOptimal(mp.curTs, ts, tq)
+	return mp.selectMessages(mp.curTs, ts)
 }
 
-func (mp *MessagePool) selectMessagesOptimal(curTs, ts *types.TipSet, tq float64) ([]*types.SignedMessage, error) {
-	start := time.Now()
-
-	baseFee, err := mp.api.ChainComputeBaseFee(context.TODO(), ts)
-	if err != nil {
-		return nil, xerrors.Errorf("computing basefee: %w", err)
-	}
-
-	// 0. Load messages from the target tipset; if it is the same as the current tipset in
-	//    the mpool, then this is just the pending messages
-	pending, err := mp.getPendingMessages(curTs, ts)
-	if err != nil {
-		return nil, err
-	}
-
-	if len(pending) == 0 {
-		return nil, nil
-	}
-
-	// defer only here so if we have no pending messages we don't spam
-	defer func() {
-		log.Infow("message selection done", "took", time.Since(start))
-	}()
-
-	// 0b. Select all priority messages that fit in the block
-	minGas := int64(gasguess.MinGas)
-	result, gasLimit := mp.selectPriorityMessages(pending, baseFee, ts)
-
-	// have we filled the block?
-	if gasLimit < minGas {
-		return result, nil
-	}
-
-	// 1. Create a list of dependent message chains with maximal gas reward per limit consumed
-	startChains := time.Now()
-	var chains []*msgChain
-	for actor, mset := range pending {
-		next := mp.createMessageChains(actor, mset, baseFee, ts)
-		chains = append(chains, next...)
-	}
-	if dt := time.Since(startChains); dt > time.Millisecond {
-		log.Infow("create message chains done", "took", dt)
-	}
-
-	// 2. Sort the chains
-	sort.Slice(chains, func(i, j int) bool {
-		return chains[i].Before(chains[j])
-	})
-
-	if !allowNegativeChains(curTs.Height()) && len(chains) != 0 && chains[0].gasPerf < 0 {
-		log.Warnw("all messages in mpool have non-positive gas performance", "bestGasPerf", chains[0].gasPerf)
-		return result, nil
-	}
-
-	// 3. Parition chains into blocks (without trimming)
-	//    we use the full blockGasLimit (as opposed to the residual gas limit from the
-	//    priority message selection) as we have to account for what other miners are doing
-	nextChain := 0
-	partitions := make([][]*msgChain, MaxBlocks)
-	for i := 0; i < MaxBlocks && nextChain < len(chains); i++ {
-		gasLimit := int64(build.BlockGasLimit)
-		for nextChain < len(chains) {
-			chain := chains[nextChain]
-			nextChain++
-			partitions[i] = append(partitions[i], chain)
-			gasLimit -= chain.gasLimit
-			if gasLimit < minGas {
-				break
-			}
-		}
-
-	}
-
-	// 4. Compute effective performance for each chain, based on the partition they fall into
-	//    The effective performance is the gasPerf of the chain * block probability
-	blockProb := mp.blockProbabilities(tq)
-	effChains := 0
-	for i := 0; i < MaxBlocks; i++ {
-		for _, chain := range partitions[i] {
-			chain.SetEffectivePerf(blockProb[i])
-		}
-		effChains += len(partitions[i])
-	}
-
-	// nullify the effective performance of chains that don't fit in any partition
-	for _, chain := range chains[effChains:] {
-		chain.SetNullEffectivePerf()
-	}
-
-	// 5. Resort the chains based on effective performance
-	sort.Slice(chains, func(i, j int) bool {
-		return chains[i].BeforeEffective(chains[j])
-	})
-
-	// 6. Merge the head chains to produce the list of messages selected for inclusion
-	//    subject to the residual gas limit
-	//    When a chain is merged in, all its previous dependent chains *must* also be
-	//    merged in or we'll have a broken block
-	startMerge := time.Now()
-	last := len(chains)
-	for i, chain := range chains {
-		// did we run out of performing chains?
-		if !allowNegativeChains(curTs.Height()) && chain.gasPerf < 0 {
-			break
-		}
-
-		// has it already been merged?
-		if chain.merged {
-			continue
-		}
-
-		// compute the dependencies that must be merged and the gas limit including deps
-		chainGasLimit := chain.gasLimit
-		var chainDeps []*msgChain
-		for curChain := chain.prev; curChain != nil && !curChain.merged; curChain = curChain.prev {
-			chainDeps = append(chainDeps, curChain)
-			chainGasLimit += curChain.gasLimit
-		}
-
-		// does it all fit in the block?
-		if chainGasLimit <= gasLimit {
-			// include it together with all dependencies
-			for i := len(chainDeps) - 1; i >= 0; i-- {
-				curChain := chainDeps[i]
-				curChain.merged = true
-				result = append(result, curChain.msgs...)
-			}
-
-			chain.merged = true
-			// adjust the effective pefromance for all subsequent chains
-			if next := chain.next; next != nil && next.effPerf > 0 {
-				next.effPerf += next.parentOffset
-				for next = next.next; next != nil && next.effPerf > 0; next = next.next {
-					next.setEffPerf()
-				}
-			}
-			result = append(result, chain.msgs...)
-			gasLimit -= chainGasLimit
-
-			// resort to account for already merged chains and effective performance adjustments
-			// the sort *must* be stable or we end up getting negative gasPerfs pushed up.
-			sort.SliceStable(chains[i+1:], func(i, j int) bool {
-				return chains[i].BeforeEffective(chains[j])
-			})
-
-			continue
-		}
-
-		// we can't fit this chain and its dependencies because of block gasLimit -- we are
-		// at the edge
-		last = i
-		break
-	}
-	if dt := time.Since(startMerge); dt > time.Millisecond {
-		log.Infow("merge message chains done", "took", dt)
-	}
-
-	// 7. We have reached the edge of what can fit wholesale; if we still hae available
-	//    gasLimit to pack some more chains, then trim the last chain and push it down.
-	//    Trimming invalidaates subsequent dependent chains so that they can't be selected
-	//    as their dependency cannot be (fully) included.
-	//    We do this in a loop because the blocker might have been inordinately large and
-	//    we might have to do it multiple times to satisfy tail packing
-	startTail := time.Now()
-tailLoop:
-	for gasLimit >= minGas && last < len(chains) {
-		// trim if necessary
-		if chains[last].gasLimit > gasLimit {
-			chains[last].Trim(gasLimit, mp, baseFee, allowNegativeChains(curTs.Height()))
-		}
-
-		// push down if it hasn't been invalidated
-		if chains[last].valid {
-			for i := last; i < len(chains)-1; i++ {
-				if chains[i].BeforeEffective(chains[i+1]) {
-					break
-				}
-				chains[i], chains[i+1] = chains[i+1], chains[i]
-			}
-		}
-
-		// select the next (valid and fitting) chain and its dependencies for inclusion
-		for i, chain := range chains[last:] {
-			// has the chain been invalidated?
-			if !chain.valid {
-				continue
-			}
-
-			// has it already been merged?
-			if chain.merged {
-				continue
-			}
-
-			// if gasPerf < 0 we have no more profitable chains
-			if !allowNegativeChains(curTs.Height()) && chain.gasPerf < 0 {
-				break tailLoop
-			}
-
-			// compute the dependencies that must be merged and the gas limit including deps
-			chainGasLimit := chain.gasLimit
-			depGasLimit := int64(0)
-			var chainDeps []*msgChain
-			for curChain := chain.prev; curChain != nil && !curChain.merged; curChain = curChain.prev {
-				chainDeps = append(chainDeps, curChain)
-				chainGasLimit += curChain.gasLimit
-				depGasLimit += curChain.gasLimit
-			}
-
-			// does it all fit in the bock
-			if chainGasLimit <= gasLimit {
-				// include it together with all dependencies
-				for i := len(chainDeps) - 1; i >= 0; i-- {
-					curChain := chainDeps[i]
-					curChain.merged = true
-					result = append(result, curChain.msgs...)
-				}
-
-				chain.merged = true
-				result = append(result, chain.msgs...)
-				gasLimit -= chainGasLimit
-				continue
-			}
-
-			// it doesn't all fit; now we have to take into account the dependent chains before
-			// making a decision about trimming or invalidating.
-			// if the dependencies exceed the gas limit, then we must invalidate the chain
-			// as it can never be included.
-			// Otherwise we can just trim and continue
-			if depGasLimit > gasLimit {
-				chain.Invalidate()
-				last += i + 1
-				continue tailLoop
-			}
-
-			// dependencies fit, just trim it
-			chain.Trim(gasLimit-depGasLimit, mp, baseFee, allowNegativeChains(curTs.Height()))
-			last += i
-			continue tailLoop
-		}
-
-		// the merge loop ended after processing all the chains and we we probably have still
-		// gas to spare; end the loop.
-		break
-	}
-	if dt := time.Since(startTail); dt > time.Millisecond {
-		log.Infow("pack tail chains done", "took", dt)
-	}
-
-	// if we have gasLimit to spare, pick some random (non-negative) chains to fill the block
-	// we pick randomly so that we minimize the probability of duplication among all miners
-	if gasLimit >= minGas {
-		randomCount := 0
-
-		startRandom := time.Now()
-		shuffleChains(chains)
-
-		for _, chain := range chains {
-			// have we filled the block
-			if gasLimit < minGas {
-				break
-			}
-
-			// has it been merged or invalidated?
-			if chain.merged || !chain.valid {
-				continue
-			}
-
-			// is it negative?
-			if !allowNegativeChains(curTs.Height()) && chain.gasPerf < 0 {
-				continue
-			}
-
-			// compute the dependencies that must be merged and the gas limit including deps
-			chainGasLimit := chain.gasLimit
-			depGasLimit := int64(0)
-			var chainDeps []*msgChain
-			for curChain := chain.prev; curChain != nil && !curChain.merged; curChain = curChain.prev {
-				chainDeps = append(chainDeps, curChain)
-				chainGasLimit += curChain.gasLimit
-				depGasLimit += curChain.gasLimit
-			}
-
-			// do the deps fit? if the deps won't fit, invalidate the chain
-			if depGasLimit > gasLimit {
-				chain.Invalidate()
-				continue
-			}
-
-			// do they fit as is? if it doesn't, trim to make it fit if possible
-			if chainGasLimit > gasLimit {
-				chain.Trim(gasLimit-depGasLimit, mp, baseFee, allowNegativeChains(curTs.Height()))
-
-				if !chain.valid {
-					continue
-				}
-			}
-
-			// include it together with all dependencies
-			for i := len(chainDeps) - 1; i >= 0; i-- {
-				curChain := chainDeps[i]
-				curChain.merged = true
-				result = append(result, curChain.msgs...)
-				randomCount += len(curChain.msgs)
-			}
-
-			chain.merged = true
-			result = append(result, chain.msgs...)
-			randomCount += len(chain.msgs)
-			gasLimit -= chainGasLimit
-		}
-
-		if dt := time.Since(startRandom); dt > time.Millisecond {
-			log.Infow("pack random tail chains done", "took", dt)
-		}
-
-		if randomCount > 0 {
-			log.Warnf("optimal selection failed to pack a block; picked %d messages with random selection",
-				randomCount)
-		}
-	}
-
-	return result, nil
-}
-
-func (mp *MessagePool) selectMessagesGreedy(curTs, ts *types.TipSet) ([]*types.SignedMessage, error) {
+func (mp *MessagePool) selectMessages(curTs, ts *types.TipSet) ([]*types.SignedMessage, error) {
 	start := time.Now()
 
 	baseFee, err := mp.api.ChainComputeBaseFee(context.TODO(), ts)
@@ -404,7 +59,7 @@ func (mp *MessagePool) selectMessagesGreedy(curTs, ts *types.TipSet) ([]*types.S
 
 	// defer only here so if we have no pending messages we don't spam
 	defer func() {
-		log.Infow("message selection done", "took", time.Since(start))
+		log.Infof("message selection took %s", time.Since(start))
 	}()
 
 	// 0b. Select all priority messages that fit in the block
@@ -417,50 +72,42 @@ func (mp *MessagePool) selectMessagesGreedy(curTs, ts *types.TipSet) ([]*types.S
 	}
 
 	// 1. Create a list of dependent message chains with maximal gas reward per limit consumed
-	startChains := time.Now()
 	var chains []*msgChain
 	for actor, mset := range pending {
 		next := mp.createMessageChains(actor, mset, baseFee, ts)
 		chains = append(chains, next...)
 	}
-	if dt := time.Since(startChains); dt > time.Millisecond {
-		log.Infow("create message chains done", "took", dt)
-	}
 
 	// 2. Sort the chains
 	sort.Slice(chains, func(i, j int) bool {
 		return chains[i].Before(chains[j])
 	})
 
-	if !allowNegativeChains(curTs.Height()) && len(chains) != 0 && chains[0].gasPerf < 0 {
+	if len(chains) != 0 && chains[0].gasPerf < 0 {
 		log.Warnw("all messages in mpool have non-positive gas performance", "bestGasPerf", chains[0].gasPerf)
-		return result, nil
+		return nil, nil
 	}
 
 	// 3. Merge the head chains to produce the list of messages selected for inclusion, subject to
 	//    the block gas limit.
-	startMerge := time.Now()
 	last := len(chains)
 	for i, chain := range chains {
-		// did we run out of performing chains?
-		if !allowNegativeChains(curTs.Height()) && chain.gasPerf < 0 {
-			break
-		}
-
 		// does it fit in the block?
-		if chain.gasLimit <= gasLimit {
+		if chain.gasLimit <= gasLimit && chain.gasPerf >= 0 {
 			gasLimit -= chain.gasLimit
 			result = append(result, chain.msgs...)
 			continue
 		}
 
+		// did we run out of performing chains?
+		if chain.gasPerf < 0 {
+			break
+		}
+
 		// we can't fit this chain because of block gasLimit -- we are at the edge
 		last = i
 		break
 	}
-	if dt := time.Since(startMerge); dt > time.Millisecond {
-		log.Infow("merge message chains done", "took", dt)
-	}
 
 	// 4. We have reached the edge of what we can fit wholesale; if we still have available gasLimit
 	// to pack some more chains, then trim the last chain and push it down.
@@ -468,11 +115,10 @@ func (mp *MessagePool) selectMessagesGreedy(curTs, ts *types.TipSet) ([]*types.S
 	// dependency cannot be (fully) included.
 	// We do this in a loop because the blocker might have been inordinately large and we might
 	// have to do it multiple times to satisfy tail packing.
-	startTail := time.Now()
 tailLoop:
 	for gasLimit >= minGas && last < len(chains) {
 		// trim
-		chains[last].Trim(gasLimit, mp, baseFee, allowNegativeChains(curTs.Height()))
+		chains[last].Trim(gasLimit, mp, baseFee, ts, false)
 
 		// push down if it hasn't been invalidated
 		if chains[last].valid {
@@ -486,47 +132,36 @@ tailLoop:
 
 		// select the next (valid and fitting) chain for inclusion
 		for i, chain := range chains[last:] {
-			// has the chain been invalidated?
+			// has the chain been invalidated
 			if !chain.valid {
 				continue
 			}
+			// does it fit in the bock?
+			if chain.gasLimit <= gasLimit && chain.gasPerf >= 0 {
+				gasLimit -= chain.gasLimit
+				result = append(result, chain.msgs...)
+				continue
+			}
 
 			// if gasPerf < 0 we have no more profitable chains
-			if !allowNegativeChains(curTs.Height()) && chain.gasPerf < 0 {
+			if chain.gasPerf < 0 {
 				break tailLoop
 			}
 
-			// does it fit in the bock?
-			if chain.gasLimit <= gasLimit {
-				gasLimit -= chain.gasLimit
-				result = append(result, chain.msgs...)
-				continue
-			}
-
 			// this chain needs to be trimmed
 			last += i
 			continue tailLoop
 		}
 
-		// the merge loop ended after processing all the chains and we probably still have
-		// gas to spare; end the loop
-		break
-	}
-	if dt := time.Since(startTail); dt > time.Millisecond {
-		log.Infow("pack tail chains done", "took", dt)
+		// the merge loop ended after processing all the chains and we probably still have gas to spare
+		// -- mark the end.
+		last = len(chains)
 	}
 
 	return result, nil
 }
 
 func (mp *MessagePool) selectPriorityMessages(pending map[address.Address]map[uint64]*types.SignedMessage, baseFee types.BigInt, ts *types.TipSet) ([]*types.SignedMessage, int64) {
-	start := time.Now()
-	defer func() {
-		if dt := time.Since(start); dt > time.Millisecond {
-			log.Infow("select priority messages done", "took", dt)
-		}
-	}()
-
 	result := make([]*types.SignedMessage, 0, mp.cfg.SizeLimitLow)
 	gasLimit := int64(build.BlockGasLimit)
 	minGas := int64(gasguess.MinGas)
@@ -545,27 +180,15 @@ func (mp *MessagePool) selectPriorityMessages(pending map[address.Address]map[ui
 		}
 	}
 
-	if len(chains) == 0 {
-		return nil, gasLimit
-	}
-
 	// 2. Sort the chains
 	sort.Slice(chains, func(i, j int) bool {
 		return chains[i].Before(chains[j])
 	})
 
-	if !allowNegativeChains(ts.Height()) && len(chains) != 0 && chains[0].gasPerf < 0 {
-		log.Warnw("all priority messages in mpool have negative gas performance", "bestGasPerf", chains[0].gasPerf)
-		return nil, gasLimit
-	}
-
-	// 3. Merge chains until the block limit, as long as they have non-negative gas performance
+	// 3. Merge chains until the block limit; we are willing to include negative performing chains
+	//    as these are messages from our own miners
 	last := len(chains)
 	for i, chain := range chains {
-		if !allowNegativeChains(ts.Height()) && chain.gasPerf < 0 {
-			break
-		}
-
 		if chain.gasLimit <= gasLimit {
 			gasLimit -= chain.gasLimit
 			result = append(result, chain.msgs...)
@@ -579,8 +202,8 @@ func (mp *MessagePool) selectPriorityMessages(pending map[address.Address]map[ui
 
 tailLoop:
 	for gasLimit >= minGas && last < len(chains) {
-		// trim, discarding negative performing messages
-		chains[last].Trim(gasLimit, mp, baseFee, allowNegativeChains(ts.Height()))
+		// trim, without discarding negative performing messages
+		chains[last].Trim(gasLimit, mp, baseFee, ts, true)
 
 		// push down if it hasn't been invalidated
 		if chains[last].valid {
@@ -598,12 +221,6 @@ tailLoop:
 			if !chain.valid {
 				continue
 			}
-
-			// if gasPerf < 0 we have no more profitable chains
-			if !allowNegativeChains(ts.Height()) && chain.gasPerf < 0 {
-				break tailLoop
-			}
-
 			// does it fit in the bock?
 			if chain.gasLimit <= gasLimit {
 				gasLimit -= chain.gasLimit
@@ -616,23 +233,17 @@ tailLoop:
 			continue tailLoop
 		}
 
-		// the merge loop ended after processing all the chains and we probably still have gas to spare;
-		// end the loop
-		break
+		// the merge loop ended after processing all the chains and we probably still have gas to spare
+		// -- mark the end.
+		last = len(chains)
 	}
 
 	return result, gasLimit
 }
 
 func (mp *MessagePool) getPendingMessages(curTs, ts *types.TipSet) (map[address.Address]map[uint64]*types.SignedMessage, error) {
-	start := time.Now()
-
 	result := make(map[address.Address]map[uint64]*types.SignedMessage)
-	defer func() {
-		if dt := time.Since(start); dt > time.Millisecond {
-			log.Infow("get pending messages done", "took", dt)
-		}
-	}()
+	haveCids := make(map[cid.Cid]struct{})
 
 	// are we in sync?
 	inSync := false
@@ -653,6 +264,10 @@ func (mp *MessagePool) getPendingMessages(curTs, ts *types.TipSet) (map[address.
 			}
 			result[a] = msetCopy
 
+			// mark the messages as seen
+			for _, m := range mset.msgs {
+				haveCids[m.Cid()] = struct{}{}
+			}
 		}
 	}
 
@@ -661,25 +276,84 @@ func (mp *MessagePool) getPendingMessages(curTs, ts *types.TipSet) (map[address.
 		return result, nil
 	}
 
-	if err := mp.runHeadChange(curTs, ts, result); err != nil {
-		return nil, xerrors.Errorf("failed to process difference between mpool head and given head: %w", err)
-	}
+	// nope, we need to sync the tipsets
+	for {
+		if curTs.Height() == ts.Height() {
+			if curTs.Equals(ts) {
+				return result, nil
+			}
 
-	return result, nil
+			// different blocks in tipsets -- we mark them as seen so that they are not included in
+			// in the message set we return, but *neither me (vyzo) nor why understand why*
+			// this code is also probably completely untested in production, so I am adding a big fat
+			// warning to revisit this case and sanity check this decision.
+			log.Warnf("mpool tipset has same height as target tipset but it's not equal; beware of dragons!")
+
+			have, err := mp.MessagesForBlocks(ts.Blocks())
+			if err != nil {
+				return nil, xerrors.Errorf("error retrieving messages for tipset: %w", err)
+			}
+
+			for _, m := range have {
+				haveCids[m.Cid()] = struct{}{}
+			}
+		}
+
+		msgs, err := mp.MessagesForBlocks(ts.Blocks())
+		if err != nil {
+			return nil, xerrors.Errorf("error retrieving messages for tipset: %w", err)
+		}
+
+		for _, m := range msgs {
+			if _, have := haveCids[m.Cid()]; have {
+				continue
+			}
+
+			haveCids[m.Cid()] = struct{}{}
+			mset, ok := result[m.Message.From]
+			if !ok {
+				mset = make(map[uint64]*types.SignedMessage)
+				result[m.Message.From] = mset
+			}
+
+			other, dupNonce := mset[m.Message.Nonce]
+			if dupNonce {
+				// duplicate nonce, selfishly keep the message with the highest GasPrice
+				// if the gas prices are the same, keep the one with the highest GasLimit
+				switch m.Message.GasPremium.Int.Cmp(other.Message.GasPremium.Int) {
+				case 0:
+					if m.Message.GasLimit > other.Message.GasLimit {
+						mset[m.Message.Nonce] = m
+					}
+				case 1:
+					mset[m.Message.Nonce] = m
+				}
+			} else {
+				mset[m.Message.Nonce] = m
+			}
+		}
+
+		if curTs.Height() >= ts.Height() {
+			return result, nil
+		}
+
+		ts, err = mp.api.LoadTipSet(ts.Parents())
+		if err != nil {
+			return nil, xerrors.Errorf("error loading parent tipset: %w", err)
+		}
+	}
 }
 
-func (*MessagePool) getGasReward(msg *types.SignedMessage, baseFee types.BigInt) *big.Int {
-	maxPremium := types.BigSub(msg.Message.GasFeeCap, baseFee)
-
-	if types.BigCmp(maxPremium, msg.Message.GasPremium) > 0 {
-		maxPremium = msg.Message.GasPremium
+func (mp *MessagePool) getGasReward(msg *types.SignedMessage, baseFee types.BigInt, ts *types.TipSet) *big.Int {
+	gasReward := abig.Mul(msg.Message.GasPremium, types.NewInt(uint64(msg.Message.GasLimit)))
+	maxReward := types.BigSub(msg.Message.GasFeeCap, baseFee)
+	if types.BigCmp(maxReward, gasReward) < 0 {
+		gasReward = maxReward
 	}
-
-	gasReward := tbig.Mul(maxPremium, types.NewInt(uint64(msg.Message.GasLimit)))
 	return gasReward.Int
 }
 
-func (*MessagePool) getGasPerf(gasReward *big.Int, gasLimit int64) float64 {
+func (mp *MessagePool) getGasPerf(gasReward *big.Int, gasLimit int64) float64 {
 	// gasPerf = gasReward * build.BlockGasLimit / gasLimit
 	a := new(big.Rat).SetInt(new(big.Int).Mul(gasReward, bigBlockGasLimit))
 	b := big.NewRat(1, gasLimit)
@@ -707,12 +381,7 @@ func (mp *MessagePool) createMessageChains(actor address.Address, mset map[uint6
 	//   cannot exceed the block limit; drop all messages that exceed the limit
 	// - the total gasReward cannot exceed the actor's balance; drop all messages that exceed
 	//   the balance
-	a, err := mp.api.GetActorAfter(actor, ts)
-	if err != nil {
-		log.Errorf("failed to load actor state, not building chain for %s: %w", actor, err)
-		return nil
-	}
-
+	a, _ := mp.api.StateGetActor(actor, ts)
 	curNonce := a.Nonce
 	balance := a.Balance.Int
 	gasLimit := int64(0)
@@ -757,12 +426,12 @@ func (mp *MessagePool) createMessageChains(actor address.Address, mset map[uint6
 			balance = new(big.Int).Sub(balance, value)
 		}
 
-		gasReward := mp.getGasReward(m, baseFee)
+		gasReward := mp.getGasReward(m, baseFee, ts)
 		rewards = append(rewards, gasReward)
 	}
 
 	// check we have a sane set of messages to construct the chains
-	if i > skip {
+	if i > 0 {
 		msgs = msgs[skip:i]
 	} else {
 		return nil
@@ -846,10 +515,6 @@ func (mp *MessagePool) createMessageChains(actor address.Address, mset map[uint6
 		chains[i].next = chains[i+1]
 	}
 
-	for i := len(chains) - 1; i > 0; i-- {
-		chains[i].prev = chains[i-1]
-	}
-
 	return chains
 }
 
@@ -858,20 +523,16 @@ func (mc *msgChain) Before(other *msgChain) bool {
 		(mc.gasPerf == other.gasPerf && mc.gasReward.Cmp(other.gasReward) > 0)
 }
 
-func (mc *msgChain) Trim(gasLimit int64, mp *MessagePool, baseFee types.BigInt, allowNegative bool) {
+func (mc *msgChain) Trim(gasLimit int64, mp *MessagePool, baseFee types.BigInt, ts *types.TipSet, priority bool) {
 	i := len(mc.msgs) - 1
-	for i >= 0 && (mc.gasLimit > gasLimit || (!allowNegative && mc.gasPerf < 0)) {
-		gasReward := mp.getGasReward(mc.msgs[i], baseFee)
+	for i >= 0 && (mc.gasLimit > gasLimit || (!priority && mc.gasPerf < 0)) {
+		gasReward := mp.getGasReward(mc.msgs[i], baseFee, ts)
 		mc.gasReward = new(big.Int).Sub(mc.gasReward, gasReward)
 		mc.gasLimit -= mc.msgs[i].Message.GasLimit
 		if mc.gasLimit > 0 {
 			mc.gasPerf = mp.getGasPerf(mc.gasReward, mc.gasLimit)
-			if mc.bp != 0 {
-				mc.setEffPerf()
-			}
 		} else {
 			mc.gasPerf = 0
-			mc.effPerf = 0
 		}
 		i--
 	}
@@ -884,56 +545,16 @@ func (mc *msgChain) Trim(gasLimit int64, mp *MessagePool, baseFee types.BigInt,
 	}
 
 	if mc.next != nil {
-		mc.next.Invalidate()
+		mc.next.invalidate()
 		mc.next = nil
 	}
 }
 
-func (mc *msgChain) Invalidate() {
+func (mc *msgChain) invalidate() {
 	mc.valid = false
 	mc.msgs = nil
 	if mc.next != nil {
-		mc.next.Invalidate()
+		mc.next.invalidate()
 		mc.next = nil
 	}
 }
-
-func (mc *msgChain) SetEffectivePerf(bp float64) {
-	mc.bp = bp
-	mc.setEffPerf()
-}
-
-func (mc *msgChain) setEffPerf() {
-	effPerf := mc.gasPerf * mc.bp
-	if effPerf > 0 && mc.prev != nil {
-		effPerfWithParent := (effPerf*float64(mc.gasLimit) + mc.prev.effPerf*float64(mc.prev.gasLimit)) / float64(mc.gasLimit+mc.prev.gasLimit)
-		mc.parentOffset = effPerf - effPerfWithParent
-		effPerf = effPerfWithParent
-	}
-	mc.effPerf = effPerf
-
-}
-
-func (mc *msgChain) SetNullEffectivePerf() {
-	if mc.gasPerf < 0 {
-		mc.effPerf = mc.gasPerf
-	} else {
-		mc.effPerf = 0
-	}
-}
-
-func (mc *msgChain) BeforeEffective(other *msgChain) bool {
-	// move merged chains to the front so we can discard them earlier
-	return (mc.merged && !other.merged) ||
-		(mc.gasPerf >= 0 && other.gasPerf < 0) ||
-		mc.effPerf > other.effPerf ||
-		(mc.effPerf == other.effPerf && mc.gasPerf > other.gasPerf) ||
-		(mc.effPerf == other.effPerf && mc.gasPerf == other.gasPerf && mc.gasReward.Cmp(other.gasReward) > 0)
-}
-
-func shuffleChains(lst []*msgChain) {
-	for i := range lst {
-		j := rand.Intn(i + 1)
-		lst[i], lst[j] = lst[j], lst[i]
-	}
-}

chain/metrics/consensus.go

@@ -4,7 +4,7 @@ import (
 	"context"
 	"encoding/json"
 
-	"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"
 	pubsub "github.com/libp2p/go-libp2p-pubsub"
@@ -44,7 +44,7 @@ func SendHeadNotifs(nickname string) func(mctx helpers.MetricsCtx, lc fx.Lifecyc
 					}
 				}()
 				go func() {
-					sub, err := ps.Subscribe(topic) //nolint
+					sub, err := ps.Subscribe(topic)
 					if err != nil {
 						return
 					}
@@ -116,7 +116,6 @@ func sendHeadNotifs(ctx context.Context, ps *pubsub.PubSub, topic string, chain
 				return err
 			}
 
-			//nolint
 			if err := ps.Publish(topic, b); err != nil {
 				return err
 			}

chain/state/statetree.go

@@ -170,10 +170,7 @@ func (st *StateTree) LookupID(addr address.Address) (address.Address, error) {
 		return address.Undef, xerrors.Errorf("loading init actor state: %w", err)
 	}
 
-	a, found, err := ias.ResolveAddress(&AdtStore{st.Store}, addr)
-	if err == nil && !found {
-		err = types.ErrActorNotFound
-	}
+	a, err := ias.ResolveAddress(&AdtStore{st.Store}, addr)
 	if err != nil {
 		return address.Undef, xerrors.Errorf("resolve address %s: %w", addr, err)
 	}
@@ -192,7 +189,7 @@ func (st *StateTree) GetActor(addr address.Address) (*types.Actor, error) {
 	// Transform `addr` to its ID format.
 	iaddr, err := st.LookupID(addr)
 	if err != nil {
-		if xerrors.Is(err, types.ErrActorNotFound) {
+		if xerrors.Is(err, init_.ErrAddressNotFound) {
 			return nil, xerrors.Errorf("resolution lookup failed (%s): %w", addr, err)
 		}
 		return nil, xerrors.Errorf("address resolution: %w", err)
@@ -227,7 +224,7 @@ func (st *StateTree) DeleteActor(addr address.Address) error {
 
 	iaddr, err := st.LookupID(addr)
 	if err != nil {
-		if xerrors.Is(err, types.ErrActorNotFound) {
+		if xerrors.Is(err, init_.ErrAddressNotFound) {
 			return xerrors.Errorf("resolution lookup failed (%s): %w", addr, err)
 		}
 		return xerrors.Errorf("address resolution: %w", err)
@@ -246,7 +243,7 @@ func (st *StateTree) DeleteActor(addr address.Address) error {
 }
 
 func (st *StateTree) Flush(ctx context.Context) (cid.Cid, error) {
-	ctx, span := trace.StartSpan(ctx, "stateTree.Flush") //nolint:staticcheck
+	ctx, span := trace.StartSpan(ctx, "stateTree.Flush")
 	defer span.End()
 	if len(st.snaps.layers) != 1 {
 		return cid.Undef, xerrors.Errorf("tried to flush state tree with snapshots on the stack")
@@ -268,7 +265,7 @@ func (st *StateTree) Flush(ctx context.Context) (cid.Cid, error) {
 }
 
 func (st *StateTree) Snapshot(ctx context.Context) error {
-	ctx, span := trace.StartSpan(ctx, "stateTree.SnapShot") //nolint:staticcheck
+	ctx, span := trace.StartSpan(ctx, "stateTree.SnapShot")
 	defer span.End()
 
 	st.snaps.addLayer()
@@ -336,15 +333,3 @@ func (st *StateTree) MutateActor(addr address.Address, f func(*types.Actor) erro
 
 	return st.SetActor(addr, act)
 }
-
-func (st *StateTree) ForEach(f func(address.Address, *types.Actor) error) error {
-	var act types.Actor
-	return st.root.ForEach(&act, func(k string) error {
-		addr, err := address.NewFromBytes([]byte(k))
-		if err != nil {
-			return xerrors.Errorf("invalid address (%x) found in state tree key: %w", []byte(k), err)
-		}
-
-		return f(addr, &act)
-	})
-}

chain/stmgr/call.go

@@ -5,8 +5,8 @@ import (
 	"fmt"
 
 	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/go-state-types/crypto"
+	"github.com/filecoin-project/specs-actors/actors/abi"
+	"github.com/filecoin-project/specs-actors/actors/crypto"
 	"github.com/ipfs/go-cid"
 	"go.opencensus.io/trace"
 	"golang.org/x/xerrors"
@@ -23,14 +23,13 @@ func (sm *StateManager) CallRaw(ctx context.Context, msg *types.Message, bstate
 	defer span.End()
 
 	vmopt := &vm.VMOpts{
-		StateBase:      bstate,
-		Epoch:          bheight,
-		Rand:           r,
-		Bstore:         sm.cs.Blockstore(),
-		Syscalls:       sm.cs.VMSys(),
-		CircSupplyCalc: sm.GetCirculatingSupply,
-		NtwkVersion:    sm.GetNtwkVersion,
-		BaseFee:        types.NewInt(0),
+		StateBase:  bstate,
+		Epoch:      bheight,
+		Rand:       r,
+		Bstore:     sm.cs.Blockstore(),
+		Syscalls:   sm.cs.VMSys(),
+		VestedCalc: sm.GetVestedFunds,
+		BaseFee:    types.NewInt(0),
 	}
 
 	vmi, err := vm.NewVM(vmopt)
@@ -96,7 +95,7 @@ func (sm *StateManager) Call(ctx context.Context, msg *types.Message, ts *types.
 
 	state := ts.ParentState()
 
-	r := store.NewChainRand(sm.cs, ts.Cids())
+	r := store.NewChainRand(sm.cs, ts.Cids(), ts.Height())
 
 	return sm.CallRaw(ctx, msg, state, r, ts.Height())
 }
@@ -109,12 +108,9 @@ func (sm *StateManager) CallWithGas(ctx context.Context, msg *types.Message, pri
 		ts = sm.cs.GetHeaviestTipSet()
 	}
 
-	state, _, err := sm.TipSetState(ctx, ts)
-	if err != nil {
-		return nil, xerrors.Errorf("computing tipset state: %w", err)
-	}
+	state := ts.ParentState()
 
-	r := store.NewChainRand(sm.cs, ts.Cids())
+	r := store.NewChainRand(sm.cs, ts.Cids(), ts.Height())
 
 	if span.IsRecordingEvents() {
 		span.AddAttributes(
@@ -125,14 +121,13 @@ func (sm *StateManager) CallWithGas(ctx context.Context, msg *types.Message, pri
 	}
 
 	vmopt := &vm.VMOpts{
-		StateBase:      state,
-		Epoch:          ts.Height() + 1,
-		Rand:           r,
-		Bstore:         sm.cs.Blockstore(),
-		Syscalls:       sm.cs.VMSys(),
-		CircSupplyCalc: sm.GetCirculatingSupply,
-		NtwkVersion:    sm.GetNtwkVersion,
-		BaseFee:        ts.Blocks()[0].ParentBaseFee,
+		StateBase:  state,
+		Epoch:      ts.Height(),
+		Rand:       r,
+		Bstore:     sm.cs.Blockstore(),
+		Syscalls:   sm.cs.VMSys(),
+		VestedCalc: sm.GetVestedFunds,
+		BaseFee:    ts.Blocks()[0].ParentBaseFee,
 	}
 	vmi, err := vm.NewVM(vmopt)
 	if err != nil {
@@ -198,7 +193,7 @@ func (sm *StateManager) Replay(ctx context.Context, ts *types.TipSet, mcid cid.C
 	var outm *types.Message
 	var outr *vm.ApplyRet
 
-	_, _, err := sm.computeTipSetState(ctx, ts, func(c cid.Cid, m *types.Message, ret *vm.ApplyRet) error {
+	_, _, err := sm.computeTipSetState(ctx, ts.Blocks(), func(c cid.Cid, m *types.Message, ret *vm.ApplyRet) error {
 		if c == mcid {
 			outm = m
 			outr = ret

chain/stmgr/forks.go

@@ -3,28 +3,16 @@ package stmgr
 import (
 	"context"
 
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/go-state-types/big"
-	"github.com/filecoin-project/lotus/build"
-	"github.com/filecoin-project/lotus/chain/state"
 	"github.com/filecoin-project/lotus/chain/types"
-	"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"
-	"github.com/filecoin-project/specs-actors/actors/util/adt"
-	cbor "github.com/ipfs/go-ipld-cbor"
-	"golang.org/x/xerrors"
+	"github.com/filecoin-project/specs-actors/actors/abi"
 )
 
-var ForksAtHeight = map[abi.ChainEpoch]func(context.Context, *StateManager, types.StateTree, *types.TipSet) error{
-	build.UpgradeBreezeHeight: UpgradeFaucetBurnRecovery,
-}
+var ForksAtHeight = map[abi.ChainEpoch]func(context.Context, *StateManager, types.StateTree) error{}
 
-func (sm *StateManager) handleStateForks(ctx context.Context, st types.StateTree, height abi.ChainEpoch, ts *types.TipSet) (err error) {
+func (sm *StateManager) handleStateForks(ctx context.Context, st types.StateTree, height abi.ChainEpoch) (err error) {
 	f, ok := ForksAtHeight[height]
 	if ok {
-		err := f(ctx, sm, st, ts)
+		err := f(ctx, sm, st)
 		if err != nil {
 			return err
 		}
@@ -32,291 +20,3 @@ func (sm *StateManager) handleStateForks(ctx context.Context, st types.StateTree
 
 	return nil
 }
-
-type forEachTree interface {
-	ForEach(func(address.Address, *types.Actor) error) error
-}
-
-func doTransfer(tree types.StateTree, from, to address.Address, amt abi.TokenAmount) error {
-	fromAct, err := tree.GetActor(from)
-	if err != nil {
-		return xerrors.Errorf("failed to get 'from' actor for transfer: %w", err)
-	}
-
-	fromAct.Balance = types.BigSub(fromAct.Balance, amt)
-	if fromAct.Balance.Sign() < 0 {
-		return xerrors.Errorf("(sanity) deducted more funds from target account than it had (%s, %s)", from, types.FIL(amt))
-	}
-
-	if err := tree.SetActor(from, fromAct); err != nil {
-		return xerrors.Errorf("failed to persist from actor: %w", err)
-	}
-
-	toAct, err := tree.GetActor(to)
-	if err != nil {
-		return xerrors.Errorf("failed to get 'to' actor for transfer: %w", err)
-	}
-
-	toAct.Balance = types.BigAdd(toAct.Balance, amt)
-
-	if err := tree.SetActor(to, toAct); err != nil {
-		return xerrors.Errorf("failed to persist to actor: %w", err)
-	}
-
-	return nil
-}
-
-func UpgradeFaucetBurnRecovery(ctx context.Context, sm *StateManager, tree types.StateTree, ts *types.TipSet) error {
-	// Some initial parameters
-	FundsForMiners := types.FromFil(1_000_000)
-	LookbackEpoch := abi.ChainEpoch(32000)
-	AccountCap := types.FromFil(0)
-	BaseMinerBalance := types.FromFil(20)
-	DesiredReimbursementBalance := types.FromFil(5_000_000)
-
-	isSystemAccount := func(addr address.Address) (bool, error) {
-		id, err := address.IDFromAddress(addr)
-		if err != nil {
-			return false, xerrors.Errorf("id address: %w", err)
-		}
-
-		if id < 1000 {
-			return true, nil
-		}
-		return false, nil
-	}
-
-	minerFundsAlloc := func(pow, tpow abi.StoragePower) abi.TokenAmount {
-		return types.BigDiv(types.BigMul(pow, FundsForMiners), tpow)
-	}
-
-	// Grab lookback state for account checks
-	lbts, err := sm.ChainStore().GetTipsetByHeight(ctx, LookbackEpoch, ts, false)
-	if err != nil {
-		return xerrors.Errorf("failed to get tipset at lookback height: %w", err)
-	}
-
-	var lbtree *state.StateTree
-	if err = sm.WithStateTree(lbts.ParentState(), func(state *state.StateTree) error {
-		lbtree = state
-		return nil
-	}); err != nil {
-		return xerrors.Errorf("loading state tree failed: %w", err)
-	}
-
-	ReserveAddress, err := address.NewFromString("t090")
-	if err != nil {
-		return xerrors.Errorf("failed to parse reserve address: %w", err)
-	}
-
-	fetree, ok := tree.(forEachTree)
-	if !ok {
-		return xerrors.Errorf("fork transition state tree doesnt support ForEach (%T)", tree)
-	}
-
-	type transfer struct {
-		From address.Address
-		To   address.Address
-		Amt  abi.TokenAmount
-	}
-
-	var transfers []transfer
-
-	// Take all excess funds away, put them into the reserve account
-	err = fetree.ForEach(func(addr address.Address, act *types.Actor) error {
-		switch act.Code {
-		case builtin.AccountActorCodeID, builtin.MultisigActorCodeID, builtin.PaymentChannelActorCodeID:
-			sysAcc, err := isSystemAccount(addr)
-			if err != nil {
-				return xerrors.Errorf("checking system account: %w", err)
-			}
-
-			if !sysAcc {
-				transfers = append(transfers, transfer{
-					From: addr,
-					To:   ReserveAddress,
-					Amt:  act.Balance,
-				})
-			}
-		case builtin.StorageMinerActorCodeID:
-			var st miner.State
-			if err := sm.WithActorState(ctx, &st)(act); err != nil {
-				return xerrors.Errorf("failed to load miner state: %w", err)
-			}
-
-			var available abi.TokenAmount
-			{
-				defer func() {
-					if err := recover(); err != nil {
-						log.Warnf("Get available balance failed (%s, %s, %s): %s", addr, act.Head, act.Balance, err)
-					}
-					available = abi.NewTokenAmount(0)
-				}()
-				// this panics if the miner doesnt have enough funds to cover their locked pledge
-				available = st.GetAvailableBalance(act.Balance)
-			}
-
-			transfers = append(transfers, transfer{
-				From: addr,
-				To:   ReserveAddress,
-				Amt:  available,
-			})
-		}
-		return nil
-	})
-	if err != nil {
-		return xerrors.Errorf("foreach over state tree failed: %w", err)
-	}
-
-	// Execute transfers from previous step
-	for _, t := range transfers {
-		if err := doTransfer(tree, t.From, t.To, t.Amt); err != nil {
-			return xerrors.Errorf("transfer %s %s->%s failed: %w", t.Amt, t.From, t.To, err)
-		}
-	}
-
-	// pull up power table to give miners back some funds proportional to their power
-	var ps power.State
-	powAct, err := tree.GetActor(builtin.StoragePowerActorAddr)
-	if err != nil {
-		return xerrors.Errorf("failed to load power actor: %w", err)
-	}
-
-	cst := cbor.NewCborStore(sm.ChainStore().Blockstore())
-	if err := cst.Get(ctx, powAct.Head, &ps); err != nil {
-		return xerrors.Errorf("failed to get power actor state: %w", err)
-	}
-
-	totalPower := ps.TotalBytesCommitted
-
-	var transfersBack []transfer
-	// Now, we return some funds to places where they are needed
-	err = fetree.ForEach(func(addr address.Address, act *types.Actor) error {
-		lbact, err := lbtree.GetActor(addr)
-		if err != nil {
-			if !xerrors.Is(err, types.ErrActorNotFound) {
-				return xerrors.Errorf("failed to get actor in lookback state")
-			}
-		}
-
-		prevBalance := abi.NewTokenAmount(0)
-		if lbact != nil {
-			prevBalance = lbact.Balance
-		}
-
-		switch act.Code {
-		case builtin.AccountActorCodeID, builtin.MultisigActorCodeID, builtin.PaymentChannelActorCodeID:
-			nbalance := big.Min(prevBalance, AccountCap)
-			if nbalance.Sign() != 0 {
-				transfersBack = append(transfersBack, transfer{
-					From: ReserveAddress,
-					To:   addr,
-					Amt:  nbalance,
-				})
-			}
-		case builtin.StorageMinerActorCodeID:
-			var st miner.State
-			if err := sm.WithActorState(ctx, &st)(act); err != nil {
-				return xerrors.Errorf("failed to load miner state: %w", err)
-			}
-
-			var minfo miner.MinerInfo
-			if err := cst.Get(ctx, st.Info, &minfo); err != nil {
-				return xerrors.Errorf("failed to get miner info: %w", err)
-			}
-
-			sectorsArr, err := adt.AsArray(sm.ChainStore().Store(ctx), st.Sectors)
-			if err != nil {
-				return xerrors.Errorf("failed to load sectors array: %w", err)
-			}
-
-			slen := sectorsArr.Length()
-
-			power := types.BigMul(types.NewInt(slen), types.NewInt(uint64(minfo.SectorSize)))
-
-			mfunds := minerFundsAlloc(power, totalPower)
-			transfersBack = append(transfersBack, transfer{
-				From: ReserveAddress,
-				To:   minfo.Worker,
-				Amt:  mfunds,
-			})
-
-			// Now make sure to give each miner who had power at the lookback some FIL
-			lbact, err := lbtree.GetActor(addr)
-			if err == nil {
-				var lbst miner.State
-				if err := sm.WithActorState(ctx, &lbst)(lbact); err != nil {
-					return xerrors.Errorf("failed to load miner state: %w", err)
-				}
-
-				lbsectors, err := adt.AsArray(sm.ChainStore().Store(ctx), lbst.Sectors)
-				if err != nil {
-					return xerrors.Errorf("failed to load lb sectors array: %w", err)
-				}
-
-				if lbsectors.Length() > 0 {
-					transfersBack = append(transfersBack, transfer{
-						From: ReserveAddress,
-						To:   minfo.Worker,
-						Amt:  BaseMinerBalance,
-					})
-				}
-
-			} else {
-				log.Warnf("failed to get miner in lookback state: %s", err)
-			}
-		}
-		return nil
-	})
-	if err != nil {
-		return xerrors.Errorf("foreach over state tree failed: %w", err)
-	}
-
-	for _, t := range transfersBack {
-		if err := doTransfer(tree, t.From, t.To, t.Amt); err != nil {
-			return xerrors.Errorf("transfer %s %s->%s failed: %w", t.Amt, t.From, t.To, err)
-		}
-	}
-
-	// transfer all burnt funds back to the reserve account
-	burntAct, err := tree.GetActor(builtin.BurntFundsActorAddr)
-	if err != nil {
-		return xerrors.Errorf("failed to load burnt funds actor: %w", err)
-	}
-	if err := doTransfer(tree, builtin.BurntFundsActorAddr, ReserveAddress, burntAct.Balance); err != nil {
-		return xerrors.Errorf("failed to unburn funds: %w", err)
-	}
-
-	// Top up the reimbursement service
-	reimbAddr, err := address.NewFromString("t0111")
-	if err != nil {
-		return xerrors.Errorf("failed to parse reimbursement service address")
-	}
-
-	reimb, err := tree.GetActor(reimbAddr)
-	if err != nil {
-		return xerrors.Errorf("failed to load reimbursement account actor: %w", err)
-	}
-
-	difference := types.BigSub(DesiredReimbursementBalance, reimb.Balance)
-	if err := doTransfer(tree, ReserveAddress, reimbAddr, difference); err != nil {
-		return xerrors.Errorf("failed to top up reimbursement account: %w", err)
-	}
-
-	// Now, a final sanity check to make sure the balances all check out
-	total := abi.NewTokenAmount(0)
-	err = fetree.ForEach(func(addr address.Address, act *types.Actor) error {
-		total = types.BigAdd(total, act.Balance)
-		return nil
-	})
-	if err != nil {
-		return xerrors.Errorf("checking final state balance failed: %w", err)
-	}
-
-	exp := types.FromFil(build.FilBase)
-	if !exp.Equals(total) {
-		return xerrors.Errorf("resultant state tree account balance was not correct: %s", total)
-	}
-
-	return nil
-}

chain/stmgr/forks_test.go

@@ -7,14 +7,15 @@ import (
 	"testing"
 
 	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/go-state-types/big"
+	"github.com/filecoin-project/specs-actors/actors/abi"
+	"github.com/filecoin-project/specs-actors/actors/abi/big"
 	"github.com/filecoin-project/specs-actors/actors/builtin"
 	init_ "github.com/filecoin-project/specs-actors/actors/builtin/init"
 	"github.com/filecoin-project/specs-actors/actors/builtin/miner"
 	"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/runtime"
+	"github.com/filecoin-project/specs-actors/actors/util/adt"
 	"golang.org/x/xerrors"
 
 	"github.com/filecoin-project/lotus/chain/actors"
@@ -72,15 +73,15 @@ func (ta *testActor) Exports() []interface{} {
 	}
 }
 
-func (ta *testActor) Constructor(rt runtime.Runtime, params *abi.EmptyValue) *abi.EmptyValue {
+func (ta *testActor) Constructor(rt runtime.Runtime, params *adt.EmptyValue) *adt.EmptyValue {
 	rt.ValidateImmediateCallerAcceptAny()
 	rt.State().Create(&testActorState{11})
 	fmt.Println("NEW ACTOR ADDRESS IS: ", rt.Message().Receiver())
 
-	return abi.Empty
+	return adt.Empty
 }
 
-func (ta *testActor) TestMethod(rt runtime.Runtime, params *abi.EmptyValue) *abi.EmptyValue {
+func (ta *testActor) TestMethod(rt runtime.Runtime, params *adt.EmptyValue) *adt.EmptyValue {
 	rt.ValidateImmediateCallerAcceptAny()
 	var st testActorState
 	rt.State().Readonly(&st)
@@ -95,7 +96,7 @@ func (ta *testActor) TestMethod(rt runtime.Runtime, params *abi.EmptyValue) *abi
 		}
 	}
 
-	return abi.Empty
+	return adt.Empty
 }
 
 func TestForkHeightTriggers(t *testing.T) {
@@ -118,7 +119,7 @@ func TestForkHeightTriggers(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	stmgr.ForksAtHeight[testForkHeight] = func(ctx context.Context, sm *StateManager, st types.StateTree, ts *types.TipSet) error {
+	stmgr.ForksAtHeight[testForkHeight] = func(ctx context.Context, sm *StateManager, st types.StateTree) error {
 		cst := cbor.NewCborStore(sm.ChainStore().Blockstore())
 
 		act, err := st.GetActor(taddr)

chain/stmgr/stmgr.go

@@ -5,10 +5,6 @@ import (
 	"fmt"
 	"sync"
 
-	"github.com/filecoin-project/go-state-types/network"
-
-	"github.com/filecoin-project/specs-actors/actors/builtin/power"
-
 	"github.com/filecoin-project/specs-actors/actors/builtin/multisig"
 
 	"github.com/filecoin-project/go-address"
@@ -20,8 +16,8 @@ import (
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/chain/vm"
 
-	"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"
 	"github.com/filecoin-project/specs-actors/actors/builtin/market"
 	"github.com/filecoin-project/specs-actors/actors/builtin/reward"
@@ -46,7 +42,7 @@ type StateManager struct {
 	stlk          sync.Mutex
 	genesisMsigLk sync.Mutex
 	newVM         func(*vm.VMOpts) (*vm.VM, error)
-	genInfo       *genesisInfo
+	genesisMsigs  []multisig.State
 }
 
 func NewStateManager(cs *store.ChainStore) *StateManager {
@@ -115,7 +111,7 @@ func (sm *StateManager) TipSetState(ctx context.Context, ts *types.TipSet) (st c
 		return ts.Blocks()[0].ParentStateRoot, ts.Blocks()[0].ParentMessageReceipts, nil
 	}
 
-	st, rec, err = sm.computeTipSetState(ctx, ts, nil)
+	st, rec, err = sm.computeTipSetState(ctx, ts.Blocks(), nil)
 	if err != nil {
 		return cid.Undef, cid.Undef, err
 	}
@@ -125,7 +121,7 @@ func (sm *StateManager) TipSetState(ctx context.Context, ts *types.TipSet) (st c
 
 func (sm *StateManager) ExecutionTrace(ctx context.Context, ts *types.TipSet) (cid.Cid, []*api.InvocResult, error) {
 	var trace []*api.InvocResult
-	st, _, err := sm.computeTipSetState(ctx, ts, func(mcid cid.Cid, msg *types.Message, ret *vm.ApplyRet) error {
+	st, _, err := sm.computeTipSetState(ctx, ts.Blocks(), func(mcid cid.Cid, msg *types.Message, ret *vm.ApplyRet) error {
 		ir := &api.InvocResult{
 			Msg:            msg,
 			MsgRct:         &ret.MessageReceipt,
@@ -145,19 +141,25 @@ func (sm *StateManager) ExecutionTrace(ctx context.Context, ts *types.TipSet) (c
 	return st, trace, nil
 }
 
+type BlockMessages struct {
+	Miner         address.Address
+	BlsMessages   []types.ChainMsg
+	SecpkMessages []types.ChainMsg
+	WinCount      int64
+}
+
 type ExecCallback func(cid.Cid, *types.Message, *vm.ApplyRet) error
 
-func (sm *StateManager) ApplyBlocks(ctx context.Context, parentEpoch abi.ChainEpoch, pstate cid.Cid, bms []store.BlockMessages, epoch abi.ChainEpoch, r vm.Rand, cb ExecCallback, baseFee abi.TokenAmount, ts *types.TipSet) (cid.Cid, cid.Cid, error) {
+func (sm *StateManager) ApplyBlocks(ctx context.Context, parentEpoch abi.ChainEpoch, pstate cid.Cid, bms []BlockMessages, epoch abi.ChainEpoch, r vm.Rand, cb ExecCallback, baseFee abi.TokenAmount) (cid.Cid, cid.Cid, error) {
 
 	vmopt := &vm.VMOpts{
-		StateBase:      pstate,
-		Epoch:          epoch,
-		Rand:           r,
-		Bstore:         sm.cs.Blockstore(),
-		Syscalls:       sm.cs.VMSys(),
-		CircSupplyCalc: sm.GetCirculatingSupply,
-		NtwkVersion:    sm.GetNtwkVersion,
-		BaseFee:        baseFee,
+		StateBase:  pstate,
+		Epoch:      epoch,
+		Rand:       r,
+		Bstore:     sm.cs.Blockstore(),
+		Syscalls:   sm.cs.VMSys(),
+		VestedCalc: sm.GetVestedFunds,
+		BaseFee:    baseFee,
 	}
 
 	vmi, err := sm.newVM(vmopt)
@@ -201,7 +203,7 @@ func (sm *StateManager) ApplyBlocks(ctx context.Context, parentEpoch abi.ChainEp
 
 	for i := parentEpoch; i < epoch; i++ {
 		// handle state forks
-		err = sm.handleStateForks(ctx, vmi.StateTree(), i, ts)
+		err = sm.handleStateForks(ctx, vmi.StateTree(), i)
 		if err != nil {
 			return cid.Undef, cid.Undef, xerrors.Errorf("error handling state forks: %w", err)
 		}
@@ -309,12 +311,10 @@ func (sm *StateManager) ApplyBlocks(ctx context.Context, parentEpoch abi.ChainEp
 	return st, rectroot, nil
 }
 
-func (sm *StateManager) computeTipSetState(ctx context.Context, ts *types.TipSet, cb ExecCallback) (cid.Cid, cid.Cid, error) {
+func (sm *StateManager) computeTipSetState(ctx context.Context, blks []*types.BlockHeader, cb ExecCallback) (cid.Cid, cid.Cid, error) {
 	ctx, span := trace.StartSpan(ctx, "computeTipSetState")
 	defer span.End()
 
-	blks := ts.Blocks()
-
 	for i := 0; i < len(blks); i++ {
 		for j := i + 1; j < len(blks); j++ {
 			if blks[i].Miner == blks[j].Miner {
@@ -327,7 +327,7 @@ func (sm *StateManager) computeTipSetState(ctx context.Context, ts *types.TipSet
 
 	var parentEpoch abi.ChainEpoch
 	pstate := blks[0].ParentStateRoot
-	if blks[0].Height > 0 {
+	if len(blks[0].Parents) > 0 {
 		parent, err := sm.cs.GetBlock(blks[0].Parents[0])
 		if err != nil {
 			return cid.Undef, cid.Undef, xerrors.Errorf("getting parent block: %w", err)
@@ -341,16 +341,35 @@ func (sm *StateManager) computeTipSetState(ctx context.Context, ts *types.TipSet
 		cids[i] = v.Cid()
 	}
 
-	r := store.NewChainRand(sm.cs, cids)
+	r := store.NewChainRand(sm.cs, cids, blks[0].Height)
 
-	blkmsgs, err := sm.cs.BlockMsgsForTipset(ts)
-	if err != nil {
-		return cid.Undef, cid.Undef, xerrors.Errorf("getting block messages for tipset: %w", err)
+	var blkmsgs []BlockMessages
+	for _, b := range blks {
+		bms, sms, err := sm.cs.MessagesForBlock(b)
+		if err != nil {
+			return cid.Undef, cid.Undef, xerrors.Errorf("failed to get messages for block: %w", err)
+		}
+
+		bm := BlockMessages{
+			Miner:         b.Miner,
+			BlsMessages:   make([]types.ChainMsg, 0, len(bms)),
+			SecpkMessages: make([]types.ChainMsg, 0, len(sms)),
+			WinCount:      b.ElectionProof.WinCount,
+		}
+
+		for _, m := range bms {
+			bm.BlsMessages = append(bm.BlsMessages, m)
+		}
+
+		for _, m := range sms {
+			bm.SecpkMessages = append(bm.SecpkMessages, m)
+		}
+
+		blkmsgs = append(blkmsgs, bm)
 	}
-
 	baseFee := blks[0].ParentBaseFee
 
-	return sm.ApplyBlocks(ctx, parentEpoch, pstate, blkmsgs, blks[0].Height, r, cb, baseFee, ts)
+	return sm.ApplyBlocks(ctx, parentEpoch, pstate, blkmsgs, blks[0].Height, r, cb, baseFee)
 }
 
 func (sm *StateManager) parentState(ts *types.TipSet) cid.Cid {
@@ -422,7 +441,7 @@ func (sm *StateManager) GetReceipt(ctx context.Context, msg cid.Cid, ts *types.T
 		return nil, fmt.Errorf("failed to load message: %w", err)
 	}
 
-	r, _, err := sm.tipsetExecutedMessage(ts, msg, m.VMMessage())
+	r, err := sm.tipsetExecutedMessage(ts, msg, m.VMMessage())
 	if err != nil {
 		return nil, err
 	}
@@ -431,7 +450,7 @@ func (sm *StateManager) GetReceipt(ctx context.Context, msg cid.Cid, ts *types.T
 		return r, nil
 	}
 
-	_, r, _, err = sm.searchBackForMsg(ctx, ts, m)
+	_, r, err = sm.searchBackForMsg(ctx, ts, m)
 	if err != nil {
 		return nil, fmt.Errorf("failed to look back through chain for message: %w", err)
 	}
@@ -442,45 +461,44 @@ func (sm *StateManager) GetReceipt(ctx context.Context, msg cid.Cid, ts *types.T
 // WaitForMessage blocks until a message appears on chain. It looks backwards in the chain to see if this has already
 // happened. It guarantees that the message has been on chain for at least confidence epochs without being reverted
 // before returning.
-func (sm *StateManager) WaitForMessage(ctx context.Context, mcid cid.Cid, confidence uint64) (*types.TipSet, *types.MessageReceipt, cid.Cid, error) {
+func (sm *StateManager) WaitForMessage(ctx context.Context, mcid cid.Cid, confidence uint64) (*types.TipSet, *types.MessageReceipt, error) {
 	ctx, cancel := context.WithCancel(ctx)
 	defer cancel()
 
 	msg, err := sm.cs.GetCMessage(mcid)
 	if err != nil {
-		return nil, nil, cid.Undef, fmt.Errorf("failed to load message: %w", err)
+		return nil, nil, fmt.Errorf("failed to load message: %w", err)
 	}
 
 	tsub := sm.cs.SubHeadChanges(ctx)
 
 	head, ok := <-tsub
 	if !ok {
-		return nil, nil, cid.Undef, fmt.Errorf("SubHeadChanges stream was invalid")
+		return nil, nil, fmt.Errorf("SubHeadChanges stream was invalid")
 	}
 
 	if len(head) != 1 {
-		return nil, nil, cid.Undef, fmt.Errorf("SubHeadChanges first entry should have been one item")
+		return nil, nil, fmt.Errorf("SubHeadChanges first entry should have been one item")
 	}
 
 	if head[0].Type != store.HCCurrent {
-		return nil, nil, cid.Undef, fmt.Errorf("expected current head on SHC stream (got %s)", head[0].Type)
+		return nil, nil, fmt.Errorf("expected current head on SHC stream (got %s)", head[0].Type)
 	}
 
-	r, foundMsg, err := sm.tipsetExecutedMessage(head[0].Val, mcid, msg.VMMessage())
+	r, err := sm.tipsetExecutedMessage(head[0].Val, mcid, msg.VMMessage())
 	if err != nil {
-		return nil, nil, cid.Undef, err
+		return nil, nil, err
 	}
 
 	if r != nil {
-		return head[0].Val, r, foundMsg, nil
+		return head[0].Val, r, nil
 	}
 
 	var backTs *types.TipSet
 	var backRcp *types.MessageReceipt
-	var backFm cid.Cid
 	backSearchWait := make(chan struct{})
 	go func() {
-		fts, r, foundMsg, err := sm.searchBackForMsg(ctx, head[0].Val, msg)
+		fts, r, err := sm.searchBackForMsg(ctx, head[0].Val, msg)
 		if err != nil {
 			log.Warnf("failed to look back through chain for message: %w", err)
 			return
@@ -488,13 +506,11 @@ func (sm *StateManager) WaitForMessage(ctx context.Context, mcid cid.Cid, confid
 
 		backTs = fts
 		backRcp = r
-		backFm = foundMsg
 		close(backSearchWait)
 	}()
 
 	var candidateTs *types.TipSet
 	var candidateRcp *types.MessageReceipt
-	var candidateFm cid.Cid
 	heightOfHead := head[0].Val.Height()
 	reverts := map[types.TipSetKey]bool{}
 
@@ -502,7 +518,7 @@ func (sm *StateManager) WaitForMessage(ctx context.Context, mcid cid.Cid, confid
 		select {
 		case notif, ok := <-tsub:
 			if !ok {
-				return nil, nil, cid.Undef, ctx.Err()
+				return nil, nil, ctx.Err()
 			}
 			for _, val := range notif {
 				switch val.Type {
@@ -510,26 +526,24 @@ func (sm *StateManager) WaitForMessage(ctx context.Context, mcid cid.Cid, confid
 					if val.Val.Equals(candidateTs) {
 						candidateTs = nil
 						candidateRcp = nil
-						candidateFm = cid.Undef
 					}
 					if backSearchWait != nil {
 						reverts[val.Val.Key()] = true
 					}
 				case store.HCApply:
 					if candidateTs != nil && val.Val.Height() >= candidateTs.Height()+abi.ChainEpoch(confidence) {
-						return candidateTs, candidateRcp, candidateFm, nil
+						return candidateTs, candidateRcp, nil
 					}
-					r, foundMsg, err := sm.tipsetExecutedMessage(val.Val, mcid, msg.VMMessage())
+					r, err := sm.tipsetExecutedMessage(val.Val, mcid, msg.VMMessage())
 					if err != nil {
-						return nil, nil, cid.Undef, err
+						return nil, nil, err
 					}
 					if r != nil {
 						if confidence == 0 {
-							return val.Val, r, foundMsg, err
+							return val.Val, r, err
 						}
 						candidateTs = val.Val
 						candidateRcp = r
-						candidateFm = foundMsg
 					}
 					heightOfHead = val.Val.Height()
 				}
@@ -539,112 +553,111 @@ func (sm *StateManager) WaitForMessage(ctx context.Context, mcid cid.Cid, confid
 			if backTs != nil && !reverts[backTs.Key()] {
 				// if head is at or past confidence interval, return immediately
 				if heightOfHead >= backTs.Height()+abi.ChainEpoch(confidence) {
-					return backTs, backRcp, backFm, nil
+					return backTs, backRcp, nil
 				}
 
 				// wait for confidence interval
 				candidateTs = backTs
 				candidateRcp = backRcp
-				candidateFm = backFm
 			}
 			reverts = nil
 			backSearchWait = nil
 		case <-ctx.Done():
-			return nil, nil, cid.Undef, ctx.Err()
+			return nil, nil, ctx.Err()
 		}
 	}
 }
 
-func (sm *StateManager) SearchForMessage(ctx context.Context, mcid cid.Cid) (*types.TipSet, *types.MessageReceipt, cid.Cid, error) {
+func (sm *StateManager) SearchForMessage(ctx context.Context, mcid cid.Cid) (*types.TipSet, *types.MessageReceipt, error) {
 	msg, err := sm.cs.GetCMessage(mcid)
 	if err != nil {
-		return nil, nil, cid.Undef, fmt.Errorf("failed to load message: %w", err)
+		return nil, nil, fmt.Errorf("failed to load message: %w", err)
 	}
 
 	head := sm.cs.GetHeaviestTipSet()
 
-	r, foundMsg, err := sm.tipsetExecutedMessage(head, mcid, msg.VMMessage())
+	r, err := sm.tipsetExecutedMessage(head, mcid, msg.VMMessage())
 	if err != nil {
-		return nil, nil, cid.Undef, err
+		return nil, nil, err
 	}
 
 	if r != nil {
-		return head, r, foundMsg, nil
+		return head, r, nil
 	}
 
-	fts, r, foundMsg, err := sm.searchBackForMsg(ctx, head, msg)
+	fts, r, err := sm.searchBackForMsg(ctx, head, msg)
 
 	if err != nil {
 		log.Warnf("failed to look back through chain for message %s", mcid)
-		return nil, nil, cid.Undef, err
+		return nil, nil, err
 	}
 
 	if fts == nil {
-		return nil, nil, cid.Undef, nil
+		return nil, nil, nil
 	}
 
-	return fts, r, foundMsg, nil
+	return fts, r, nil
 }
 
-func (sm *StateManager) searchBackForMsg(ctx context.Context, from *types.TipSet, m types.ChainMsg) (*types.TipSet, *types.MessageReceipt, cid.Cid, error) {
+func (sm *StateManager) searchBackForMsg(ctx context.Context, from *types.TipSet, m types.ChainMsg) (*types.TipSet, *types.MessageReceipt, error) {
 
 	cur := from
 	for {
 		if cur.Height() == 0 {
 			// it ain't here!
-			return nil, nil, cid.Undef, nil
+			return nil, nil, nil
 		}
 
 		select {
 		case <-ctx.Done():
-			return nil, nil, cid.Undef, nil
+			return nil, nil, nil
 		default:
 		}
 
 		var act types.Actor
 		err := sm.WithParentState(cur, sm.WithActor(m.VMMessage().From, GetActor(&act)))
 		if err != nil {
-			return nil, nil, cid.Undef, err
+			return nil, nil, err
 		}
 
 		// we either have no messages from the sender, or the latest message we found has a lower nonce than the one being searched for,
 		// either way, no reason to lookback, it ain't there
 		if act.Nonce == 0 || act.Nonce < m.VMMessage().Nonce {
-			return nil, nil, cid.Undef, nil
+			return nil, nil, nil
 		}
 
 		ts, err := sm.cs.LoadTipSet(cur.Parents())
 		if err != nil {
-			return nil, nil, cid.Undef, fmt.Errorf("failed to load tipset during msg wait searchback: %w", err)
+			return nil, nil, fmt.Errorf("failed to load tipset during msg wait searchback: %w", err)
 		}
 
-		r, foundMsg, err := sm.tipsetExecutedMessage(ts, m.Cid(), m.VMMessage())
+		r, err := sm.tipsetExecutedMessage(ts, m.Cid(), m.VMMessage())
 		if err != nil {
-			return nil, nil, cid.Undef, fmt.Errorf("checking for message execution during lookback: %w", err)
+			return nil, nil, fmt.Errorf("checking for message execution during lookback: %w", err)
 		}
 
 		if r != nil {
-			return ts, r, foundMsg, nil
+			return ts, r, nil
 		}
 
 		cur = ts
 	}
 }
 
-func (sm *StateManager) tipsetExecutedMessage(ts *types.TipSet, msg cid.Cid, vmm *types.Message) (*types.MessageReceipt, cid.Cid, error) {
+func (sm *StateManager) tipsetExecutedMessage(ts *types.TipSet, msg cid.Cid, vmm *types.Message) (*types.MessageReceipt, error) {
 	// The genesis block did not execute any messages
 	if ts.Height() == 0 {
-		return nil, cid.Undef, nil
+		return nil, nil
 	}
 
 	pts, err := sm.cs.LoadTipSet(ts.Parents())
 	if err != nil {
-		return nil, cid.Undef, err
+		return nil, err
 	}
 
 	cm, err := sm.cs.MessagesForTipset(pts)
 	if err != nil {
-		return nil, cid.Undef, err
+		return nil, err
 	}
 
 	for ii := range cm {
@@ -654,30 +667,21 @@ func (sm *StateManager) tipsetExecutedMessage(ts *types.TipSet, msg cid.Cid, vmm
 
 		if m.VMMessage().From == vmm.From { // cheaper to just check origin first
 			if m.VMMessage().Nonce == vmm.Nonce {
-				if m.VMMessage().EqualCall(vmm) {
-					if m.Cid() != msg {
-						log.Warnw("found message with equal nonce and call params but different CID",
-							"wanted", msg, "found", m.Cid(), "nonce", vmm.Nonce, "from", vmm.From)
-					}
-
-					pr, err := sm.cs.GetParentReceipt(ts.Blocks()[0], i)
-					if err != nil {
-						return nil, cid.Undef, err
-					}
-					return pr, m.Cid(), nil
+				if m.Cid() == msg {
+					return sm.cs.GetParentReceipt(ts.Blocks()[0], i)
 				}
 
 				// this should be that message
-				return nil, cid.Undef, xerrors.Errorf("found message with equal nonce as the one we are looking for (F:%s n %d, TS: %s n%d)",
+				return nil, xerrors.Errorf("found message with equal nonce as the one we are looking for (F:%s n %d, TS: %s n%d)",
 					msg, vmm.Nonce, m.Cid(), m.VMMessage().Nonce)
 			}
 			if m.VMMessage().Nonce < vmm.Nonce {
-				return nil, cid.Undef, nil // don't bother looking further
+				return nil, nil // don't bother looking further
 			}
 		}
 	}
 
-	return nil, cid.Undef, nil
+	return nil, nil
 }
 
 func (sm *StateManager) ListAllActors(ctx context.Context, ts *types.TipSet) ([]address.Address, error) {
@@ -778,24 +782,12 @@ func (sm *StateManager) SetVMConstructor(nvm func(*vm.VMOpts) (*vm.VM, error)) {
 	sm.newVM = nvm
 }
 
-type genesisInfo struct {
-	genesisMsigs []multisig.State
-	// info about the Accounts in the genesis state
-	genesisActors      []genesisActor
-	genesisPledge      abi.TokenAmount
-	genesisMarketFunds abi.TokenAmount
+type GenesisMsigEntry struct {
+	totalFunds abi.TokenAmount
+	unitVest   abi.TokenAmount
 }
 
-type genesisActor struct {
-	addr    address.Address
-	initBal abi.TokenAmount
-}
-
-// sets up information about the actors in the genesis state
-func (sm *StateManager) setupGenesisActors(ctx context.Context) error {
-
-	gi := genesisInfo{}
-
+func (sm *StateManager) setupGenesisMsigs(ctx context.Context) error {
 	gb, err := sm.cs.GetGenesis()
 	if err != nil {
 		return xerrors.Errorf("getting genesis block: %w", err)
@@ -811,22 +803,6 @@ func (sm *StateManager) setupGenesisActors(ctx context.Context) error {
 		return xerrors.Errorf("getting genesis tipset state: %w", err)
 	}
 
-	cst := cbor.NewCborStore(sm.cs.Blockstore())
-	sTree, err := state.LoadStateTree(cst, st)
-	if err != nil {
-		return xerrors.Errorf("loading state tree: %w", err)
-	}
-
-	gi.genesisMarketFunds, err = getFilMarketLocked(ctx, sTree)
-	if err != nil {
-		return xerrors.Errorf("setting up genesis market funds: %w", err)
-	}
-
-	gi.genesisPledge, err = getFilPowerLocked(ctx, sTree)
-	if err != nil {
-		return xerrors.Errorf("setting up genesis pledge: %w", err)
-	}
-
 	r, err := adt.AsMap(sm.cs.Store(ctx), st)
 	if err != nil {
 		return xerrors.Errorf("getting genesis actors: %w", err)
@@ -853,289 +829,40 @@ func (sm *StateManager) setupGenesisActors(ctx context.Context) error {
 				totalsByEpoch[s.UnlockDuration] = s.InitialBalance
 			}
 
-		} else if act.Code == builtin.AccountActorCodeID {
-			// should exclude burnt funds actor and "remainder account actor"
-			// should only ever be "faucet" accounts in testnets
-			kaddr, err := address.NewFromBytes([]byte(k))
-			if err != nil {
-				return xerrors.Errorf("decoding address: %w", err)
-			}
-
-			if kaddr != builtin.BurntFundsActorAddr {
-				kid, err := sTree.LookupID(kaddr)
-				if err != nil {
-					return xerrors.Errorf("resolving address: %w", err)
-				}
-
-				gi.genesisActors = append(gi.genesisActors, genesisActor{
-					addr:    kid,
-					initBal: act.Balance,
-				})
-			}
 		}
 		return nil
 	})
 
 	if err != nil {
-		return xerrors.Errorf("error setting up genesis infos: %w", err)
+		return xerrors.Errorf("error setting up composite genesis multisigs: %w", err)
 	}
 
-	gi.genesisMsigs = make([]multisig.State, 0, len(totalsByEpoch))
+	sm.genesisMsigs = make([]multisig.State, 0, len(totalsByEpoch))
 	for k, v := range totalsByEpoch {
 		ns := multisig.State{
 			InitialBalance: v,
 			UnlockDuration: k,
 			PendingTxns:    cid.Undef,
 		}
-		gi.genesisMsigs = append(gi.genesisMsigs, ns)
+		sm.genesisMsigs = append(sm.genesisMsigs, ns)
 	}
 
-	sm.genInfo = &gi
-
 	return nil
 }
 
-// sets up information about the actors in the genesis state
-// For testnet we use a hardcoded set of multisig states, instead of what's actually in the genesis multisigs
-// We also do not consider ANY account actors (including the faucet)
-func (sm *StateManager) setupGenesisActorsTestnet(ctx context.Context) error {
-
-	gi := genesisInfo{}
-
-	gb, err := sm.cs.GetGenesis()
-	if err != nil {
-		return xerrors.Errorf("getting genesis block: %w", err)
-	}
-
-	gts, err := types.NewTipSet([]*types.BlockHeader{gb})
-	if err != nil {
-		return xerrors.Errorf("getting genesis tipset: %w", err)
-	}
-
-	st, _, err := sm.TipSetState(ctx, gts)
-	if err != nil {
-		return xerrors.Errorf("getting genesis tipset state: %w", err)
-	}
-
-	cst := cbor.NewCborStore(sm.cs.Blockstore())
-	sTree, err := state.LoadStateTree(cst, st)
-	if err != nil {
-		return xerrors.Errorf("loading state tree: %w", err)
-	}
-
-	gi.genesisMarketFunds, err = getFilMarketLocked(ctx, sTree)
-	if err != nil {
-		return xerrors.Errorf("setting up genesis market funds: %w", err)
-	}
-
-	gi.genesisPledge, err = getFilPowerLocked(ctx, sTree)
-	if err != nil {
-		return xerrors.Errorf("setting up genesis pledge: %w", err)
-	}
-
-	totalsByEpoch := make(map[abi.ChainEpoch]abi.TokenAmount)
-
-	// 6 months
-	sixMonths := abi.ChainEpoch(183 * builtin.EpochsInDay)
-	totalsByEpoch[sixMonths] = big.NewInt(49_929_341)
-	totalsByEpoch[sixMonths] = big.Add(totalsByEpoch[sixMonths], big.NewInt(32_787_700))
-
-	// 1 year
-	oneYear := abi.ChainEpoch(365 * builtin.EpochsInDay)
-	totalsByEpoch[oneYear] = big.NewInt(22_421_712)
-
-	// 2 years
-	twoYears := abi.ChainEpoch(2 * 365 * builtin.EpochsInDay)
-	totalsByEpoch[twoYears] = big.NewInt(7_223_364)
-
-	// 3 years
-	threeYears := abi.ChainEpoch(3 * 365 * builtin.EpochsInDay)
-	totalsByEpoch[threeYears] = big.NewInt(87_637_883)
-
-	// 6 years
-	sixYears := abi.ChainEpoch(6 * 365 * builtin.EpochsInDay)
-	totalsByEpoch[sixYears] = big.NewInt(100_000_000)
-	totalsByEpoch[sixYears] = big.Add(totalsByEpoch[sixYears], big.NewInt(300_000_000))
-
-	gi.genesisMsigs = make([]multisig.State, 0, len(totalsByEpoch))
-	for k, v := range totalsByEpoch {
-		ns := multisig.State{
-			InitialBalance: v,
-			UnlockDuration: k,
-			PendingTxns:    cid.Undef,
+func (sm *StateManager) GetVestedFunds(ctx context.Context, height abi.ChainEpoch) (abi.TokenAmount, error) {
+	sm.genesisMsigLk.Lock()
+	defer sm.genesisMsigLk.Unlock()
+	if sm.genesisMsigs == nil {
+		err := sm.setupGenesisMsigs(ctx)
+		if err != nil {
+			return big.Zero(), xerrors.Errorf("failed to setup genesis msig entries: %w", err)
 		}
-		gi.genesisMsigs = append(gi.genesisMsigs, ns)
 	}
-
-	sm.genInfo = &gi
-
-	return nil
-}
-
-// GetVestedFunds returns all funds that have "left" actors that are in the genesis state:
-// - For Multisigs, it counts the actual amounts that have vested at the given epoch
-// - For Accounts, it counts max(currentBalance - genesisBalance, 0).
-func (sm *StateManager) GetFilVested(ctx context.Context, height abi.ChainEpoch, st *state.StateTree) (abi.TokenAmount, error) {
 	vf := big.Zero()
-	for _, v := range sm.genInfo.genesisMsigs {
+	for _, v := range sm.genesisMsigs {
 		au := big.Sub(v.InitialBalance, v.AmountLocked(height))
 		vf = big.Add(vf, au)
 	}
-
-	// there should not be any such accounts in testnet (and also none in mainnet?)
-	for _, v := range sm.genInfo.genesisActors {
-		act, err := st.GetActor(v.addr)
-		if err != nil {
-			return big.Zero(), xerrors.Errorf("failed to get actor: %w", err)
-		}
-
-		diff := big.Sub(v.initBal, act.Balance)
-		if diff.GreaterThan(big.Zero()) {
-			vf = big.Add(vf, diff)
-		}
-	}
-
-	vf = big.Add(vf, sm.genInfo.genesisPledge)
-	vf = big.Add(vf, sm.genInfo.genesisMarketFunds)
-
 	return vf, nil
 }
-
-func GetFilMined(ctx context.Context, st *state.StateTree) (abi.TokenAmount, error) {
-	ractor, err := st.GetActor(builtin.RewardActorAddr)
-	if err != nil {
-		return big.Zero(), xerrors.Errorf("failed to load reward actor state: %w", err)
-	}
-
-	var rst reward.State
-	if err := st.Store.Get(ctx, ractor.Head, &rst); err != nil {
-		return big.Zero(), xerrors.Errorf("failed to load reward state: %w", err)
-	}
-
-	return rst.TotalMined, nil
-}
-
-func getFilMarketLocked(ctx context.Context, st *state.StateTree) (abi.TokenAmount, error) {
-	mactor, err := st.GetActor(builtin.StorageMarketActorAddr)
-	if err != nil {
-		return big.Zero(), xerrors.Errorf("failed to load market actor: %w", err)
-	}
-
-	var mst market.State
-	if err := st.Store.Get(ctx, mactor.Head, &mst); err != nil {
-		return big.Zero(), xerrors.Errorf("failed to load market state: %w", err)
-	}
-
-	fml := types.BigAdd(mst.TotalClientLockedCollateral, mst.TotalProviderLockedCollateral)
-	fml = types.BigAdd(fml, mst.TotalClientStorageFee)
-	return fml, nil
-}
-
-func getFilPowerLocked(ctx context.Context, st *state.StateTree) (abi.TokenAmount, error) {
-	pactor, err := st.GetActor(builtin.StoragePowerActorAddr)
-	if err != nil {
-		return big.Zero(), xerrors.Errorf("failed to load power actor: %w", err)
-	}
-
-	var pst power.State
-	if err := st.Store.Get(ctx, pactor.Head, &pst); err != nil {
-		return big.Zero(), xerrors.Errorf("failed to load power state: %w", err)
-	}
-	return pst.TotalPledgeCollateral, nil
-}
-
-func (sm *StateManager) GetFilLocked(ctx context.Context, st *state.StateTree) (abi.TokenAmount, error) {
-
-	filMarketLocked, err := getFilMarketLocked(ctx, st)
-	if err != nil {
-		return big.Zero(), xerrors.Errorf("failed to get filMarketLocked: %w", err)
-	}
-
-	filPowerLocked, err := getFilPowerLocked(ctx, st)
-	if err != nil {
-		return big.Zero(), xerrors.Errorf("failed to get filPowerLocked: %w", err)
-	}
-
-	return types.BigAdd(filMarketLocked, filPowerLocked), nil
-}
-
-func GetFilBurnt(ctx context.Context, st *state.StateTree) (abi.TokenAmount, error) {
-	burnt, err := st.GetActor(builtin.BurntFundsActorAddr)
-	if err != nil {
-		return big.Zero(), xerrors.Errorf("failed to load burnt actor: %w", err)
-	}
-
-	return burnt.Balance, nil
-}
-
-func (sm *StateManager) GetCirculatingSupplyDetailed(ctx context.Context, height abi.ChainEpoch, st *state.StateTree) (api.CirculatingSupply, error) {
-	sm.genesisMsigLk.Lock()
-	defer sm.genesisMsigLk.Unlock()
-	if sm.genInfo == nil {
-		err := sm.setupGenesisActorsTestnet(ctx)
-		if err != nil {
-			return api.CirculatingSupply{}, xerrors.Errorf("failed to setup genesis information: %w", err)
-		}
-	}
-
-	filVested, err := sm.GetFilVested(ctx, height, st)
-	if err != nil {
-		return api.CirculatingSupply{}, xerrors.Errorf("failed to calculate filVested: %w", err)
-	}
-
-	filMined, err := GetFilMined(ctx, st)
-	if err != nil {
-		return api.CirculatingSupply{}, xerrors.Errorf("failed to calculate filMined: %w", err)
-	}
-
-	filBurnt, err := GetFilBurnt(ctx, st)
-	if err != nil {
-		return api.CirculatingSupply{}, xerrors.Errorf("failed to calculate filBurnt: %w", err)
-	}
-
-	filLocked, err := sm.GetFilLocked(ctx, st)
-	if err != nil {
-		return api.CirculatingSupply{}, xerrors.Errorf("failed to calculate filLocked: %w", err)
-	}
-
-	ret := types.BigAdd(filVested, filMined)
-	ret = types.BigSub(ret, filBurnt)
-	ret = types.BigSub(ret, filLocked)
-
-	if ret.LessThan(big.Zero()) {
-		ret = big.Zero()
-	}
-
-	return api.CirculatingSupply{
-		FilVested:      filVested,
-		FilMined:       filMined,
-		FilBurnt:       filBurnt,
-		FilLocked:      filLocked,
-		FilCirculating: ret,
-	}, nil
-}
-
-func (sm *StateManager) GetCirculatingSupply(ctx context.Context, height abi.ChainEpoch, st *state.StateTree) (abi.TokenAmount, error) {
-	csi, err := sm.GetCirculatingSupplyDetailed(ctx, height, st)
-	if err != nil {
-		return big.Zero(), err
-	}
-
-	return csi.FilCirculating, nil
-}
-
-func (sm *StateManager) GetNtwkVersion(ctx context.Context, height abi.ChainEpoch) network.Version {
-	if build.UseNewestNetwork() {
-		return build.NewestNetworkVersion
-	}
-
-	if height <= build.UpgradeBreezeHeight {
-		return network.Version0
-	}
-
-	if height <= build.UpgradeSmokeHeight {
-		return network.Version1
-	}
-
-	return build.NewestNetworkVersion
-}

chain/stmgr/utils.go

@@ -3,14 +3,8 @@ package stmgr
 import (
 	"bytes"
 	"context"
-	"fmt"
 	"os"
 	"reflect"
-	"runtime"
-	"strings"
-
-	saruntime "github.com/filecoin-project/specs-actors/actors/runtime"
-	"github.com/filecoin-project/specs-actors/actors/runtime/proof"
 
 	cid "github.com/ipfs/go-cid"
 	cbor "github.com/ipfs/go-ipld-cbor"
@@ -19,9 +13,9 @@ import (
 
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-bitfield"
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/go-state-types/crypto"
-	"github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper"
+	"github.com/filecoin-project/sector-storage/ffiwrapper"
+	"github.com/filecoin-project/specs-actors/actors/abi"
+	"github.com/filecoin-project/specs-actors/actors/abi/big"
 	"github.com/filecoin-project/specs-actors/actors/builtin"
 	"github.com/filecoin-project/specs-actors/actors/builtin/account"
 	"github.com/filecoin-project/specs-actors/actors/builtin/cron"
@@ -33,6 +27,7 @@ import (
 	"github.com/filecoin-project/specs-actors/actors/builtin/power"
 	"github.com/filecoin-project/specs-actors/actors/builtin/reward"
 	"github.com/filecoin-project/specs-actors/actors/builtin/verifreg"
+	"github.com/filecoin-project/specs-actors/actors/crypto"
 	"github.com/filecoin-project/specs-actors/actors/util/adt"
 
 	"github.com/filecoin-project/lotus/api"
@@ -163,13 +158,13 @@ func MinerSectorInfo(ctx context.Context, sm *StateManager, maddr address.Addres
 		return nil, err
 	}
 	if !ok {
-		return nil, nil
+		return nil, xerrors.New("sector not found")
 	}
 
 	return sectorInfo, nil
 }
 
-func GetMinerSectorSet(ctx context.Context, sm *StateManager, ts *types.TipSet, maddr address.Address, filter *bitfield.BitField, filterOut bool) ([]*api.ChainSectorInfo, error) {
+func GetMinerSectorSet(ctx context.Context, sm *StateManager, ts *types.TipSet, maddr address.Address, filter *abi.BitField, filterOut bool) ([]*api.ChainSectorInfo, error) {
 	var mas miner.State
 	_, err := sm.LoadActorState(ctx, maddr, &mas, ts)
 	if err != nil {
@@ -179,8 +174,8 @@ func GetMinerSectorSet(ctx context.Context, sm *StateManager, ts *types.TipSet,
 	return LoadSectorsFromSet(ctx, sm.ChainStore().Blockstore(), mas.Sectors, filter, filterOut)
 }
 
-func GetSectorsForWinningPoSt(ctx context.Context, pv ffiwrapper.Verifier, sm *StateManager, st cid.Cid, maddr address.Address, rand abi.PoStRandomness) ([]proof.SectorInfo, error) {
-	var partsProving []bitfield.BitField
+func GetSectorsForWinningPoSt(ctx context.Context, pv ffiwrapper.Verifier, sm *StateManager, st cid.Cid, maddr address.Address, rand abi.PoStRandomness) ([]abi.SectorInfo, error) {
+	var partsProving []*abi.BitField
 	var mas *miner.State
 	var info *miner.MinerInfo
 
@@ -267,7 +262,7 @@ func GetSectorsForWinningPoSt(ctx context.Context, pv ffiwrapper.Verifier, sm *S
 		return nil, xerrors.Errorf("failed to load sectors amt: %w", err)
 	}
 
-	out := make([]proof.SectorInfo, len(ids))
+	out := make([]abi.SectorInfo, len(ids))
 	for i, n := range ids {
 		sid := sectors[n]
 
@@ -278,7 +273,7 @@ func GetSectorsForWinningPoSt(ctx context.Context, pv ffiwrapper.Verifier, sm *S
 			return nil, xerrors.Errorf("failed to find sector %d", sid)
 		}
 
-		out[i] = proof.SectorInfo{
+		out[i] = abi.SectorInfo{
 			SealProof:    spt,
 			SectorNumber: sinfo.SectorNumber,
 			SealedCID:    sinfo.SealedCID,
@@ -299,8 +294,14 @@ func StateMinerInfo(ctx context.Context, sm *StateManager, ts *types.TipSet, mad
 }
 
 func GetMinerSlashed(ctx context.Context, sm *StateManager, ts *types.TipSet, maddr address.Address) (bool, error) {
+	var mas miner.State
+	_, err := sm.LoadActorState(ctx, maddr, &mas, ts)
+	if err != nil {
+		return false, xerrors.Errorf("(get miner slashed) failed to load miner actor state")
+	}
+
 	var spas power.State
-	_, err := sm.LoadActorState(ctx, builtin.StoragePowerActorAddr, &spas, ts)
+	_, err = sm.LoadActorState(ctx, builtin.StoragePowerActorAddr, &spas, ts)
 	if err != nil {
 		return false, xerrors.Errorf("(get miner slashed) failed to load power actor state")
 	}
@@ -393,7 +394,7 @@ func ListMinerActors(ctx context.Context, sm *StateManager, ts *types.TipSet) ([
 	return miners, nil
 }
 
-func LoadSectorsFromSet(ctx context.Context, bs blockstore.Blockstore, ssc cid.Cid, filter *bitfield.BitField, filterOut bool) ([]*api.ChainSectorInfo, error) {
+func LoadSectorsFromSet(ctx context.Context, bs blockstore.Blockstore, ssc cid.Cid, filter *abi.BitField, filterOut bool) ([]*api.ChainSectorInfo, error) {
 	a, err := adt.AsArray(store.ActorStore(ctx, bs), ssc)
 	if err != nil {
 		return nil, err
@@ -438,16 +439,15 @@ func ComputeState(ctx context.Context, sm *StateManager, height abi.ChainEpoch,
 		return cid.Undef, nil, err
 	}
 
-	r := store.NewChainRand(sm.cs, ts.Cids())
+	r := store.NewChainRand(sm.cs, ts.Cids(), height)
 	vmopt := &vm.VMOpts{
-		StateBase:      base,
-		Epoch:          height,
-		Rand:           r,
-		Bstore:         sm.cs.Blockstore(),
-		Syscalls:       sm.cs.VMSys(),
-		CircSupplyCalc: sm.GetCirculatingSupply,
-		NtwkVersion:    sm.GetNtwkVersion,
-		BaseFee:        ts.Blocks()[0].ParentBaseFee,
+		StateBase:  base,
+		Epoch:      height,
+		Rand:       r,
+		Bstore:     sm.cs.Blockstore(),
+		Syscalls:   sm.cs.VMSys(),
+		VestedCalc: sm.GetVestedFunds,
+		BaseFee:    ts.Blocks()[0].ParentBaseFee,
 	}
 	vmi, err := vm.NewVM(vmopt)
 	if err != nil {
@@ -456,7 +456,7 @@ func ComputeState(ctx context.Context, sm *StateManager, height abi.ChainEpoch,
 
 	for i := ts.Height(); i < height; i++ {
 		// handle state forks
-		err = sm.handleStateForks(ctx, vmi.StateTree(), i, ts)
+		err = sm.handleStateForks(ctx, vmi.StateTree(), i)
 		if err != nil {
 			return cid.Undef, nil, xerrors.Errorf("error handling state forks: %w", err)
 		}
@@ -502,7 +502,7 @@ func GetLookbackTipSetForRound(ctx context.Context, sm *StateManager, ts *types.
 	return lbts, nil
 }
 
-func MinerGetBaseInfo(ctx context.Context, sm *StateManager, bcs beacon.Schedule, tsk types.TipSetKey, round abi.ChainEpoch, maddr address.Address, pv ffiwrapper.Verifier) (*api.MiningBaseInfo, error) {
+func MinerGetBaseInfo(ctx context.Context, sm *StateManager, bcn beacon.RandomBeacon, tsk types.TipSetKey, round abi.ChainEpoch, maddr address.Address, pv ffiwrapper.Verifier) (*api.MiningBaseInfo, error) {
 	ts, err := sm.ChainStore().LoadTipSet(tsk)
 	if err != nil {
 		return nil, xerrors.Errorf("failed to load tipset for mining base: %w", err)
@@ -517,7 +517,7 @@ func MinerGetBaseInfo(ctx context.Context, sm *StateManager, bcs beacon.Schedule
 		prev = &types.BeaconEntry{}
 	}
 
-	entries, err := beacon.BeaconEntriesForBlock(ctx, bcs, round, ts.Height(), *prev)
+	entries, err := beacon.BeaconEntriesForBlock(ctx, bcn, round, *prev)
 	if err != nil {
 		return nil, err
 	}
@@ -593,14 +593,48 @@ func MinerGetBaseInfo(ctx context.Context, sm *StateManager, bcs beacon.Schedule
 	}, nil
 }
 
-type MethodMeta struct {
+func (sm *StateManager) CirculatingSupply(ctx context.Context, ts *types.TipSet) (abi.TokenAmount, error) {
+	if ts == nil {
+		ts = sm.cs.GetHeaviestTipSet()
+	}
+
+	st, _, err := sm.TipSetState(ctx, ts)
+	if err != nil {
+		return big.Zero(), err
+	}
+
+	r := store.NewChainRand(sm.cs, ts.Cids(), ts.Height())
+	vmopt := &vm.VMOpts{
+		StateBase:  st,
+		Epoch:      ts.Height(),
+		Rand:       r,
+		Bstore:     sm.cs.Blockstore(),
+		Syscalls:   sm.cs.VMSys(),
+		VestedCalc: sm.GetVestedFunds,
+		BaseFee:    ts.Blocks()[0].ParentBaseFee,
+	}
+	vmi, err := vm.NewVM(vmopt)
+	if err != nil {
+		return big.Zero(), err
+	}
+
+	unsafeVM := &vm.UnsafeVM{VM: vmi}
+	rt := unsafeVM.MakeRuntime(ctx, &types.Message{
+		GasLimit: 100e6,
+		From:     builtin.SystemActorAddr,
+	}, builtin.SystemActorAddr, 0, 0, 0)
+
+	return rt.TotalFilCircSupply(), nil
+}
+
+type methodMeta struct {
 	Name string
 
 	Params reflect.Type
 	Ret    reflect.Type
 }
 
-var MethodsMap = map[cid.Cid]map[abi.MethodNum]MethodMeta{}
+var MethodsMap = map[cid.Cid][]methodMeta{}
 
 func init() {
 	cidToMethods := map[cid.Cid][2]interface{}{
@@ -618,65 +652,25 @@ func init() {
 	}
 
 	for c, m := range cidToMethods {
-		exports := m[1].(saruntime.Invokee).Exports()
-		methods := make(map[abi.MethodNum]MethodMeta, len(exports))
-
-		// Explicitly add send, it's special.
-		methods[builtin.MethodSend] = MethodMeta{
-			Name:   "Send",
-			Params: reflect.TypeOf(new(abi.EmptyValue)),
-			Ret:    reflect.TypeOf(new(abi.EmptyValue)),
-		}
-
-		// Learn method names from the builtin.Methods* structs.
-		rv := reflect.ValueOf(m[0])
-		rt := rv.Type()
+		rt := reflect.TypeOf(m[0])
 		nf := rt.NumField()
-		methodToName := make([]string, len(exports))
+
+		MethodsMap[c] = append(MethodsMap[c], methodMeta{
+			Name:   "Send",
+			Params: reflect.TypeOf(new(adt.EmptyValue)),
+			Ret:    reflect.TypeOf(new(adt.EmptyValue)),
+		})
+
+		exports := m[1].(abi.Invokee).Exports()
 		for i := 0; i < nf; i++ {
-			name := rt.Field(i).Name
-			number := rv.Field(i).Interface().(abi.MethodNum)
-			methodToName[number] = name
+			export := reflect.TypeOf(exports[i+1])
+
+			MethodsMap[c] = append(MethodsMap[c], methodMeta{
+				Name:   rt.Field(i).Name,
+				Params: export.In(1),
+				Ret:    export.Out(0),
+			})
 		}
-
-		// Iterate over exported methods. Some of these _may_ be nil and
-		// must be skipped.
-		for number, export := range exports {
-			if export == nil {
-				continue
-			}
-
-			ev := reflect.ValueOf(export)
-			et := ev.Type()
-
-			// Make sure the method name is correct.
-			// This is just a nice sanity check.
-			fnName := runtime.FuncForPC(ev.Pointer()).Name()
-			fnName = strings.TrimSuffix(fnName[strings.LastIndexByte(fnName, '.')+1:], "-fm")
-			mName := methodToName[number]
-			if mName != fnName {
-				panic(fmt.Sprintf(
-					"actor method name is %s but exported method name is %s",
-					fnName, mName,
-				))
-			}
-
-			switch abi.MethodNum(number) {
-			case builtin.MethodSend:
-				panic("method 0 is reserved for Send")
-			case builtin.MethodConstructor:
-				if fnName != "Constructor" {
-					panic("method 1 is reserved for Constructor")
-				}
-			}
-
-			methods[abi.MethodNum(number)] = MethodMeta{
-				Name:   fnName,
-				Params: et.In(1),
-				Ret:    et.Out(0),
-			}
-		}
-		MethodsMap[c] = methods
 	}
 }
 
@@ -686,10 +680,7 @@ func GetReturnType(ctx context.Context, sm *StateManager, to address.Address, me
 		return nil, xerrors.Errorf("getting actor: %w", err)
 	}
 
-	m, found := MethodsMap[act.Code][method]
-	if !found {
-		return nil, fmt.Errorf("unknown method %d for actor %s", method, act.Code)
-	}
+	m := MethodsMap[act.Code][method]
 	return reflect.New(m.Ret.Elem()).Interface().(cbg.CBORUnmarshaler), nil
 }
 
@@ -703,20 +694,29 @@ func MinerHasMinPower(ctx context.Context, sm *StateManager, addr address.Addres
 	return ps.MinerNominalPowerMeetsConsensusMinimum(sm.ChainStore().Store(ctx), addr)
 }
 
-func CheckTotalFIL(ctx context.Context, sm *StateManager, ts *types.TipSet) (abi.TokenAmount, error) {
-	str, err := state.LoadStateTree(sm.ChainStore().Store(ctx), ts.ParentState())
-	if err != nil {
-		return abi.TokenAmount{}, err
+func GetCirculatingSupply(ctx context.Context, sm *StateManager, ts *types.TipSet) (abi.TokenAmount, error) {
+	if ts == nil {
+		ts = sm.cs.GetHeaviestTipSet()
 	}
 
-	sum := types.NewInt(0)
-	err = str.ForEach(func(a address.Address, act *types.Actor) error {
-		sum = types.BigAdd(sum, act.Balance)
-		return nil
-	})
+	r := store.NewChainRand(sm.cs, ts.Cids(), ts.Height())
+	vmopt := &vm.VMOpts{
+		StateBase:  ts.ParentState(),
+		Epoch:      ts.Height(),
+		Rand:       r,
+		Bstore:     sm.cs.Blockstore(),
+		Syscalls:   sm.cs.VMSys(),
+		VestedCalc: sm.GetVestedFunds,
+		BaseFee:    ts.Blocks()[0].ParentBaseFee,
+	}
+	vmi, err := vm.NewVM(vmopt)
 	if err != nil {
-		return abi.TokenAmount{}, err
+		return abi.NewTokenAmount(0), err
 	}
 
-	return sum, nil
+	uvm := &vm.UnsafeVM{vmi}
+
+	rt := uvm.MakeRuntime(ctx, &types.Message{From: builtin.InitActorAddr, GasLimit: 10000000}, builtin.InitActorAddr, 0, 0, 0)
+
+	return rt.TotalFilCircSupply(), nil
 }

chain/store/basefee.go

@@ -3,30 +3,15 @@ package store
 import (
 	"context"
 
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/go-state-types/big"
 	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain/types"
-	"github.com/ipfs/go-cid"
+	"github.com/filecoin-project/specs-actors/actors/abi"
+	"github.com/filecoin-project/specs-actors/actors/abi/big"
 	"golang.org/x/xerrors"
 )
 
 func computeNextBaseFee(baseFee types.BigInt, gasLimitUsed int64, noOfBlocks int) types.BigInt {
-	// deta := 1/PackingEfficiency * gasLimitUsed/noOfBlocks - build.BlockGasTarget
-	// change := baseFee * deta / BlockGasTarget / BaseFeeMaxChangeDenom
-	// nextBaseFee = baseFee + change
-	// nextBaseFee = max(nextBaseFee, build.MinimumBaseFee)
-
-	delta := build.PackingEfficiencyDenom * gasLimitUsed / (int64(noOfBlocks) * build.PackingEfficiencyNum)
-	delta -= build.BlockGasTarget
-
-	// cap change at 12.5% (BaseFeeMaxChangeDenom) by capping delta
-	if delta > build.BlockGasTarget {
-		delta = build.BlockGasTarget
-	}
-	if delta < -build.BlockGasTarget {
-		delta = -build.BlockGasTarget
-	}
+	delta := gasLimitUsed/int64(noOfBlocks) - build.BlockGasTarget
 
 	change := big.Mul(baseFee, big.NewInt(delta))
 	change = big.Div(change, big.NewInt(build.BlockGasTarget))
@@ -40,35 +25,18 @@ func computeNextBaseFee(baseFee types.BigInt, gasLimitUsed int64, noOfBlocks int
 }
 
 func (cs *ChainStore) ComputeBaseFee(ctx context.Context, ts *types.TipSet) (abi.TokenAmount, error) {
-	if ts.Height() > build.UpgradeBreezeHeight && ts.Height() < build.UpgradeBreezeHeight+build.BreezeGasTampingDuration {
-		return abi.NewTokenAmount(100), nil
-	}
-
 	zero := abi.NewTokenAmount(0)
-
-	// totalLimit is sum of GasLimits of unique messages in a tipset
 	totalLimit := int64(0)
-
-	seen := make(map[cid.Cid]struct{})
-
 	for _, b := range ts.Blocks() {
 		msg1, msg2, err := cs.MessagesForBlock(b)
 		if err != nil {
 			return zero, xerrors.Errorf("error getting messages for: %s: %w", b.Cid(), err)
 		}
 		for _, m := range msg1 {
-			c := m.Cid()
-			if _, ok := seen[c]; !ok {
-				totalLimit += m.GasLimit
-				seen[c] = struct{}{}
-			}
+			totalLimit += m.GasLimit
 		}
 		for _, m := range msg2 {
-			c := m.Cid()
-			if _, ok := seen[c]; !ok {
-				totalLimit += m.Message.GasLimit
-				seen[c] = struct{}{}
-			}
+			totalLimit += m.Message.GasLimit
 		}
 	}
 	parentBaseFee := ts.Blocks()[0].ParentBaseFee

chain/store/basefee_test.go

@@ -18,10 +18,10 @@ func TestBaseFee(t *testing.T) {
 	}{
 		{100e6, 0, 1, 87.5e6},
 		{100e6, 0, 5, 87.5e6},
-		{100e6, build.BlockGasTarget, 1, 103.125e6},
-		{100e6, build.BlockGasTarget * 2, 2, 103.125e6},
+		{100e6, build.BlockGasTarget, 1, 100e6},
+		{100e6, build.BlockGasTarget * 2, 2, 100e6},
 		{100e6, build.BlockGasLimit * 2, 2, 112.5e6},
-		{100e6, build.BlockGasLimit * 1.5, 2, 110937500},
+		{100e6, build.BlockGasLimit * 1.5, 2, 106.25e6},
 	}
 
 	for _, test := range tests {

chain/store/index.go

@@ -2,28 +2,13 @@ package store
 
 import (
 	"context"
-	"os"
-	"strconv"
 
-	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/specs-actors/actors/abi"
 	lru "github.com/hashicorp/golang-lru"
 	"golang.org/x/xerrors"
 )
 
-var DefaultChainIndexCacheSize = 32 << 10
-
-func init() {
-	if s := os.Getenv("LOTUS_CHAIN_INDEX_CACHE"); s != "" {
-		lcic, err := strconv.Atoi(s)
-		if err != nil {
-			log.Errorf("failed to parse 'LOTUS_CHAIN_INDEX_CACHE' env var: %s", err)
-		}
-		DefaultChainIndexCacheSize = lcic
-	}
-
-}
-
 type ChainIndex struct {
 	skipCache *lru.ARCCache
 
@@ -34,7 +19,7 @@ type ChainIndex struct {
 type loadTipSetFunc func(types.TipSetKey) (*types.TipSet, error)
 
 func NewChainIndex(lts loadTipSetFunc) *ChainIndex {
-	sc, _ := lru.NewARC(DefaultChainIndexCacheSize)
+	sc, _ := lru.NewARC(8192)
 	return &ChainIndex{
 		skipCache:  sc,
 		loadTipSet: lts,