Merge branch 'master' into ntwk-calibration

.circleci/config.yml

@@ -5,7 +5,7 @@ orbs:
 executors:
   golang:
     docker:
-      - image: circleci/golang:1.15.5
+      - image: circleci/golang:1.14.6
     resource_class: 2xlarge
   ubuntu:
     docker:
@@ -264,44 +264,22 @@ jobs:
           path: /tmp/test-artifacts/conformance-coverage.html
   build-lotus-soup:
     description: |
-      Compile `lotus-soup` Testground test plan
+      Compile `lotus-soup` Testground test plan using the current version of Lotus.
     parameters:
       <<: *test-params
     executor: << parameters.executor >>
     steps:
       - install-deps
       - prepare
+      - run: cd extern/oni && git submodule sync
+      - run: cd extern/oni && git submodule update --init
       - run: cd extern/filecoin-ffi && make
+      - run:
+          name: "replace lotus, filecoin-ffi, blst and fil-blst deps"
+          command: cd extern/oni/lotus-soup && go mod edit -replace github.com/filecoin-project/lotus=../../../ && go mod edit -replace github.com/filecoin-project/filecoin-ffi=../../filecoin-ffi && go mod edit -replace github.com/supranational/blst=../../blst
       - run:
           name: "build lotus-soup testplan"
-          command: pushd testplans/lotus-soup && go build -tags=testground .
-  trigger-testplans:
-    description: |
-      Trigger `lotus-soup` test cases on TaaS
-    parameters:
-      <<: *test-params
-    executor: << parameters.executor >>
-    steps:
-      - install-deps
-      - prepare
-      - run:
-          name: "download testground"
-          command: wget https://gist.github.com/nonsense/5fbf3167cac79945f658771aed32fc44/raw/2e17eb0debf7ec6bdf027c1bdafc2c92dd97273b/testground-d3e9603 -O ~/testground-cli && chmod +x ~/testground-cli
-      - run:
-          name: "prepare .env.toml"
-          command: pushd testplans/lotus-soup && mkdir -p $HOME/testground && cp env-ci.toml $HOME/testground/.env.toml && echo 'endpoint="https://ci.testground.ipfs.team"' >> $HOME/testground/.env.toml && echo 'user="circleci"' >> $HOME/testground/.env.toml
-      - run:
-          name: "prepare testground home dir"
-          command: mkdir -p $HOME/testground/plans && mv testplans/lotus-soup testplans/graphsync $HOME/testground/plans/
-      - run:
-          name: "trigger deals baseline testplan on taas"
-          command: ~/testground-cli run composition -f $HOME/testground/plans/lotus-soup/_compositions/baseline-k8s-3-1.toml --metadata-commit=$CIRCLE_SHA1 --metadata-repo=filecoin-project/lotus --metadata-branch=$CIRCLE_BRANCH
-      - run:
-          name: "trigger payment channel stress testplan on taas"
-          command: ~/testground-cli run composition -f $HOME/testground/plans/lotus-soup/_compositions/paych-stress-k8s.toml --metadata-commit=$CIRCLE_SHA1 --metadata-repo=filecoin-project/lotus --metadata-branch=$CIRCLE_BRANCH
-      - run:
-          name: "trigger graphsync testplan on taas"
-          command: ~/testground-cli run composition -f $HOME/testground/plans/graphsync/_compositions/stress-k8s.toml --metadata-commit=$CIRCLE_SHA1 --metadata-repo=filecoin-project/lotus --metadata-branch=$CIRCLE_BRANCH
+          command: pushd extern/oni/lotus-soup && go build -tags=testground .
 
 
   build-macos:
@@ -316,8 +294,8 @@ jobs:
       - run:
           name: Install go
           command: |
-            curl -O https://dl.google.com/go/go1.15.5.darwin-amd64.pkg && \
-            sudo installer -pkg go1.15.5.darwin-amd64.pkg -target /
+            curl -O https://dl.google.com/go/go1.14.2.darwin-amd64.pkg && \
+            sudo installer -pkg go1.14.2.darwin-amd64.pkg -target /
       - run:
           name: Install pkg-config
           command: HOMEBREW_NO_AUTO_UPDATE=1 brew install pkg-config
@@ -495,11 +473,6 @@ workflows:
           packages: "./conformance"
           vectors-branch: master
       - build-lotus-soup
-      - trigger-testplans:
-          filters:
-            branches:
-              only:
-                - master
       - build-debug
       - build-all:
           requires:

.gitignore

@@ -13,7 +13,6 @@
 /lotus-gateway
 /lotus-pcr
 /lotus-wallet
-/lotus-keygen
 /bench.json
 /lotuspond/front/node_modules
 /lotuspond/front/build

.gitmodules

@@ -7,6 +7,9 @@
 [submodule "extern/test-vectors"]
 	path = extern/test-vectors
 	url = https://github.com/filecoin-project/test-vectors.git
+[submodule "extern/oni"]
+	path = extern/oni
+	url = https://github.com/filecoin-project/oni.git
 [submodule "extern/blst"]
 	path = extern/blst
 	url = https://github.com/supranational/blst.git

CHANGELOG.md

@@ -1,162 +1,5 @@
 # Lotus changelog
 
-# 1.2.3 / 2020-12-15
-
-This is an optional Lotus release that introduces many performance improvements, bugfixes, and UX improvements.
-
-## Changes
-
-- When waiting for deal commit messages, ignore unsuccessful messages (https://github.com/filecoin-project/lotus/pull/5189)
-- Bigger copy buffer size for stores (https://github.com/filecoin-project/lotus/pull/5177)
-- Print MinPieceSize when querying ask (https://github.com/filecoin-project/lotus/pull/5178)
-- Optimize miner info & sectors list loading (https://github.com/filecoin-project/lotus/pull/5176)
-- Allow miners to filter (un)verified deals (https://github.com/filecoin-project/lotus/pull/5094)
-- Fix curSealing out of MaxSealingSectors limit (https://github.com/filecoin-project/lotus/pull/5166)
-- Add mpool pending from / to filter (https://github.com/filecoin-project/lotus/pull/5169)
-- Add metrics for delayed blocks (https://github.com/filecoin-project/lotus/pull/5171)
-- Fix PushUntrusted publishing -- the message is local (https://github.com/filecoin-project/lotus/pull/5173)
-- Avoid potential hang in events API when starting event listener (https://github.com/filecoin-project/lotus/pull/5159)
-- Show data transfer ID in list-deals (https://github.com/filecoin-project/lotus/pull/5150)
-- Fix events API mutex locking (https://github.com/filecoin-project/lotus/pull/5160)
-- Message pool refactors (https://github.com/filecoin-project/lotus/pull/5162)
-- Fix lotus-shed cid output (https://github.com/filecoin-project/lotus/pull/5072)
-- Use FundManager to withdraw funds, add MarketWithdraw API (https://github.com/filecoin-project/lotus/pull/5112)
-- Add keygen outfile (https://github.com/filecoin-project/lotus/pull/5118)
-- Update sr2 stat aggregation (https://github.com/filecoin-project/lotus/pull/5114)
-- Fix miner control address lookup (https://github.com/filecoin-project/lotus/pull/5119)
-- Fix send with declared nonce 0 (https://github.com/filecoin-project/lotus/pull/5111)
-- Introduce memory watchdog; LOTUS_MAX_HEAP (https://github.com/filecoin-project/lotus/pull/5101)
-- Miner control address config for (pre)commits (https://github.com/filecoin-project/lotus/pull/5103)
-- Delete repeated call func (https://github.com/filecoin-project/lotus/pull/5099)
-- lotus-shed ledger show command (https://github.com/filecoin-project/lotus/pull/5098)
-- Log a message when there aren't enough peers for sync (https://github.com/filecoin-project/lotus/pull/5105)
-- Miner code cleanup (https://github.com/filecoin-project/lotus/pull/5107)
-
-# 1.2.2 / 2020-12-03
-
-This is an optional Lotus release that introduces various improvements to the mining logic and deal-making workflow, as well as several new UX features.
-
-## Changes
-
-- Set lower feecap on PoSt messages with low balance (https://github.com/filecoin-project/lotus/pull/4217)
-- Add options to set BlockProfileRate and MutexProfileFraction (https://github.com/filecoin-project/lotus/pull/4140)
-- Shed/post find (https://github.com/filecoin-project/lotus/pull/4355)
-- tvx extract: make it work with secp messages.(https://github.com/filecoin-project/lotus/pull/4583)
-- update go from 1.14 to 1.15 (https://github.com/filecoin-project/lotus/pull/4909)
-- print multiple blocks from miner cid (https://github.com/filecoin-project/lotus/pull/4767)
-- Connection Gater support (https://github.com/filecoin-project/lotus/pull/4849)
-- just return storedask.NewStoredAsk to reduce unuseful code (https://github.com/filecoin-project/lotus/pull/4902)
-- add go main version (https://github.com/filecoin-project/lotus/pull/4910)
-- Use version0 when pre-sealing (https://github.com/filecoin-project/lotus/pull/4911)
-- optimize code UpgradeTapeHeight and go fmt (https://github.com/filecoin-project/lotus/pull/4913)
-- CLI to get network version (https://github.com/filecoin-project/lotus/pull/4914)
-- Improve error for ActorsVersionPredicate (https://github.com/filecoin-project/lotus/pull/4915)
-- upgrade to go-fil-markets 1.0.5 (https://github.com/filecoin-project/lotus/pull/4916)
-- bug:replace with func recordFailure (https://github.com/filecoin-project/lotus/pull/4919)
-- Remove unused key (https://github.com/filecoin-project/lotus/pull/4924)
-- change typeV7 make len (https://github.com/filecoin-project/lotus/pull/4943)
-- emit events for peer disconnections and act upon them in the blocksync tracker (https://github.com/filecoin-project/lotus/pull/4754)
-- Fix lotus bench error (https://github.com/filecoin-project/lotus/pull/4305)
-- Reduce badger ValueTreshold to 128 (https://github.com/filecoin-project/lotus/pull/4629)
-- Downgrade duplicate nonce logs to debug (https://github.com/filecoin-project/lotus/pull/4933)
-- readme update golang version from 1.14.7 to 1.15.5 (https://github.com/filecoin-project/lotus/pull/4974)
-- add data transfer logging (https://github.com/filecoin-project/lotus/pull/4975)
-- Remove all temp file generation for deals (https://github.com/filecoin-project/lotus/pull/4929)
-- fix get sector bug (https://github.com/filecoin-project/lotus/pull/4976)
-- fix nil pointer in StateSectorPreCommitInfo (https://github.com/filecoin-project/lotus/pull/4082)
-- Add logging on data-transfer to miner (https://github.com/filecoin-project/lotus/pull/4980)
-- bugfix: fixup devnet script (https://github.com/filecoin-project/lotus/pull/4956)
-- modify for unsafe (https://github.com/filecoin-project/lotus/pull/4024)
-- move testground/lotus-soup testplan from oni to lotus (https://github.com/filecoin-project/lotus/pull/4727)
-- Setup remainder msig signers when parsing genesis template (https://github.com/filecoin-project/lotus/pull/4904)
-- Update JSON RPC server to enforce a maximum request size (https://github.com/filecoin-project/lotus/pull/4923)
-- New SR-specific lotus-shed cmd (https://github.com/filecoin-project/lotus/pull/4971)
-- update index to sectorNumber (https://github.com/filecoin-project/lotus/pull/4987)
-- storagefsm: Fix expired ticket retry loop (https://github.com/filecoin-project/lotus/pull/4876)
-- add .sec scale to measurements; humanize for metric tags (https://github.com/filecoin-project/lotus/pull/4989)
-- Support seal proof type switching (https://github.com/filecoin-project/lotus/pull/4873)
-- fix log format (https://github.com/filecoin-project/lotus/pull/4984)
-- Format workerID as string (https://github.com/filecoin-project/lotus/pull/4973)
-- miner: Winning PoSt Warmup (https://github.com/filecoin-project/lotus/pull/4824)
-- Default StartDealParams's fast retrieval field to true over JSON (https://github.com/filecoin-project/lotus/pull/4998)
-- Fix actor not found in chain inspect-usage (https://github.com/filecoin-project/lotus/pull/5010)
-- storagefsm: Improve new deal sector logic (https://github.com/filecoin-project/lotus/pull/5007)
-- Configure simultaneous requests (https://github.com/filecoin-project/lotus/pull/4996)
-- miner: log winningPoSt duration separately (https://github.com/filecoin-project/lotus/pull/5005)
-- fix wallet dead lock (https://github.com/filecoin-project/lotus/pull/5002)
-- Update go-jsonrpc to v0.1.2 (https://github.com/filecoin-project/lotus/pull/5015)
-- markets - separate watching for pre-commit from prove-commit (https://github.com/filecoin-project/lotus/pull/4945)
-- storagefsm: Add missing planners (https://github.com/filecoin-project/lotus/pull/5016)
-- fix wallet delete address where address is default (https://github.com/filecoin-project/lotus/pull/5019)
-- worker: More robust remote checks (https://github.com/filecoin-project/lotus/pull/5008)
-- Add new booststrappers (https://github.com/filecoin-project/lotus/pull/4007)
-- add a tooling to make filecoin accounting a little easier (https://github.com/filecoin-project/lotus/pull/5025)
-- fix: start a new line in print miner-info to avoid ambiguous display (https://github.com/filecoin-project/lotus/pull/5029)
-- Print gas limit sum in mpool stat (https://github.com/filecoin-project/lotus/pull/5035)
-- Fix chainstore tipset leak (https://github.com/filecoin-project/lotus/pull/5037)
-- shed rpc: Allow calling with args (https://github.com/filecoin-project/lotus/pull/5036)
-- Make --gas-limit optional in mpool replace cli (https://github.com/filecoin-project/lotus/pull/5059)
-- client list-asks --by-ping (https://github.com/filecoin-project/lotus/pull/5060)
-- Ledger signature verification (https://github.com/filecoin-project/lotus/pull/5068)
-- Fix helptext for verified-deal default in client deal (https://github.com/filecoin-project/lotus/pull/5074)
-- worker: Support setting task types at runtime (https://github.com/filecoin-project/lotus/pull/5023)
-- Enable Callers tracing when GasTracing is enabled (https://github.com/filecoin-project/lotus/pull/5080)
-- Cancel transfer cancels storage deal (https://github.com/filecoin-project/lotus/pull/5032)
-- Sector check command (https://github.com/filecoin-project/lotus/pull/5041)
-- add commp-to-cid base64 decode (https://github.com/filecoin-project/lotus/pull/5079)
-- miner info cli improvements (https://github.com/filecoin-project/lotus/pull/5083)
-- miner: Add slow mode to proving check (https://github.com/filecoin-project/lotus/pull/5086)
-- Error out deals that are not activated by proposed deal start epoch (https://github.com/filecoin-project/lotus/pull/5061)
-
-# 1.2.1 / 2020-11-20
-          
-This is a very small release of Lotus that fixes an issue users are experiencing when importing snapshots. There is no need to upgrade unless you experience an issue with creating a new datastore directory in the Lotus repo.
-          
-## Changes
-
-- fix blockstore directory not created automatically (https://github.com/filecoin-project/lotus/pull/4922)
-- WindowPoStScheduler.checkSectors() delete useless judgment (https://github.com/filecoin-project/lotus/pull/4918)
-
-
-# 1.2.0 / 2020-11-18
-
-This is a mandatory release of Lotus that introduces the second post-liftoff upgrade to the Filecoin network. The network upgrade occurs at height 265200, before which time all nodes must have update to this release (or later). This release also bumps the required version of Go to 1.15.
-
-The changes that break consensus are:
-
-- Upgrading to sepcs-actors 2.3.2 (https://github.com/filecoin-project/specs-actors/releases/tag/v2.3.2)
-- Introducing proofs v5.4.0 (https://github.com/filecoin-project/rust-fil-proofs/releases/tag/storage-proofs-v5.4.0), and switching between the proof types (https://github.com/filecoin-project/lotus/pull/4873)
-- Don't use terminated sectors for winning PoSt (https://github.com/filecoin-project/lotus/pull/4770)
-- Various small VM-level edge-case handling (https://github.com/filecoin-project/lotus/pull/4783)
-- Correction of the VM circulating supply calculation (https://github.com/filecoin-project/lotus/pull/4862)
-- Retuning gas costs (https://github.com/filecoin-project/lotus/pull/4830)
-- Avoid sending messages to the zero BLS address (https://github.com/filecoin-project/lotus/pull/4888)
-                                     
-## Other Changes
-
-- delayed pubsub subscribe for messages topic (https://github.com/filecoin-project/lotus/pull/3646)
-- add chain base64 decode params (https://github.com/filecoin-project/lotus/pull/4748)
-- chore(dep): update bitswap to fix an initialization race that could panic (https://github.com/filecoin-project/lotus/pull/4855)
-- Chore/blockstore nits (https://github.com/filecoin-project/lotus/pull/4813)
-- Print Consensus Faults in miner info (https://github.com/filecoin-project/lotus/pull/4853)
-- Truncate genesis file before generating (https://github.com/filecoin-project/lotus/pull/4851)
-- miner: Winning PoSt Warmup (https://github.com/filecoin-project/lotus/pull/4824)
-- Fix init actor address map diffing (https://github.com/filecoin-project/lotus/pull/4875)
-- Bump API versions to 1.0.0 (https://github.com/filecoin-project/lotus/pull/4884)
-- Fix cid recording issue (https://github.com/filecoin-project/lotus/pull/4874)
-- Speed up worker key retrieval (https://github.com/filecoin-project/lotus/pull/4885)
-- Add error codes to worker return (https://github.com/filecoin-project/lotus/pull/4890)
-- Update go to 1.15.5 (https://github.com/filecoin-project/lotus/pull/4896)
-- Fix MaxSealingSectrosForDeals getting reset to 0 (https://github.com/filecoin-project/lotus/pull/4879)
-- add sanity check for maximum block size (https://github.com/filecoin-project/lotus/pull/3171)
-- Check (pre)commit receipt before other checks in failed states (https://github.com/filecoin-project/lotus/pull/4712)
-- fix badger double open on daemon --import-snapshot; chainstore lifecycle (https://github.com/filecoin-project/lotus/pull/4872)
-- Update to ipfs-blockstore 1.0.3 (https://github.com/filecoin-project/lotus/pull/4897)
-- break loop when found warm up sector (https://github.com/filecoin-project/lotus/pull/4869)
-- Tweak handling of bad beneficaries in DeleteActor (https://github.com/filecoin-project/lotus/pull/4903)
-- cap maximum number of messages per block in selection (https://github.com/filecoin-project/lotus/pull/4905)
-- Set Calico epoch (https://github.com/filecoin-project/lotus/pull/4889)
-
 # 1.1.3 / 2020-11-13
 
 This is an optional release of Lotus that upgrades Lotus dependencies, and includes many performance enhancements, bugfixes, and UX improvements.

Makefile

@@ -5,10 +5,10 @@ all: build
 
 unexport GOFLAGS
 
-GOVERSION:=$(shell go version | cut -d' ' -f 3 | sed 's/^go//' | awk -F. '{printf "%d%03d%03d", $$1, $$2, $$3}')
-ifeq ($(shell expr $(GOVERSION) \< 1015005), 1)
-$(warning Your Golang version is go$(shell expr $(GOVERSION) / 1000000).$(shell expr $(GOVERSION) % 1000000 / 1000).$(shell expr $(GOVERSION) % 1000))
-$(error Update Golang to version to at least 1.15.5)
+GOVERSION:=$(shell go version | cut -d' ' -f 3 | cut -d. -f 2)
+ifeq ($(shell expr $(GOVERSION) \< 14), 1)
+$(warning Your Golang version is go 1.$(GOVERSION))
+$(error Update Golang to version $(shell grep '^go' go.mod))
 endif
 
 # git modules that need to be loaded
@@ -204,12 +204,6 @@ lotus-wallet:
 .PHONY: lotus-wallet
 BINS+=lotus-wallet
 
-lotus-keygen:
-	rm -f lotus-keygen
-	go build -o lotus-keygen ./cmd/lotus-keygen
-.PHONY: lotus-keygen
-BINS+=lotus-keygen
-
 testground:
 	go build -tags testground -o /dev/null ./cmd/lotus
 .PHONY: testground

README.md

@@ -10,7 +10,7 @@
   <a href="https://circleci.com/gh/filecoin-project/lotus"><img src="https://circleci.com/gh/filecoin-project/lotus.svg?style=svg"></a>
   <a href="https://codecov.io/gh/filecoin-project/lotus"><img src="https://codecov.io/gh/filecoin-project/lotus/branch/master/graph/badge.svg"></a>
   <a href="https://goreportcard.com/report/github.com/filecoin-project/lotus"><img src="https://goreportcard.com/badge/github.com/filecoin-project/lotus" /></a>  
-  <a href=""><img src="https://img.shields.io/badge/golang-%3E%3D1.15.5-blue.svg" /></a>
+  <a href=""><img src="https://img.shields.io/badge/golang-%3E%3D1.14.7-blue.svg" /></a>
   <br>
 </p>
 

api/api_common.go

@@ -46,11 +46,6 @@ type Common interface {
 	// usage and current rate per protocol
 	NetBandwidthStatsByProtocol(ctx context.Context) (map[protocol.ID]metrics.Stats, error)
 
-	// ConnectionGater API
-	NetBlockAdd(ctx context.Context, acl NetBlockList) error
-	NetBlockRemove(ctx context.Context, acl NetBlockList) error
-	NetBlockList(ctx context.Context) (NetBlockList, error)
-
 	// MethodGroup: Common
 
 	// ID returns peerID of libp2p node backing this API

api/api_full.go

@@ -2,7 +2,6 @@ package api
 
 import (
 	"context"
-	"encoding/json"
 	"fmt"
 	"time"
 
@@ -519,8 +518,6 @@ type FullNode interface {
 	MarketReserveFunds(ctx context.Context, wallet address.Address, addr address.Address, amt types.BigInt) (cid.Cid, error)
 	// MarketReleaseFunds releases funds reserved by MarketReserveFunds
 	MarketReleaseFunds(ctx context.Context, addr address.Address, amt types.BigInt) error
-	// MarketWithdraw withdraws unlocked funds from the market actor
-	MarketWithdraw(ctx context.Context, wallet, addr address.Address, amt types.BigInt) (cid.Cid, error)
 
 	// MethodGroup: Paych
 	// The Paych methods are for interacting with and managing payment channels
@@ -594,9 +591,6 @@ type DealInfo struct {
 
 	CreationTime time.Time
 	Verified     bool
-
-	TransferChannelID *datatransfer.ChannelID
-	DataTransfer      *DataTransferChannel
 }
 
 type MsgLookup struct {
@@ -791,22 +785,6 @@ type StartDealParams struct {
 	VerifiedDeal       bool
 }
 
-func (s *StartDealParams) UnmarshalJSON(raw []byte) (err error) {
-	type sdpAlias StartDealParams
-
-	sdp := sdpAlias{
-		FastRetrieval: true,
-	}
-
-	if err := json.Unmarshal(raw, &sdp); err != nil {
-		return err
-	}
-
-	*s = StartDealParams(sdp)
-
-	return nil
-}
-
 type IpldObject struct {
 	Cid cid.Cid
 	Obj interface{}

api/api_gateway.go

@@ -39,7 +39,6 @@ type GatewayAPI interface {
 	StateMinerProvingDeadline(ctx context.Context, addr address.Address, tsk types.TipSetKey) (*dline.Info, error)
 	StateMinerPower(context.Context, address.Address, types.TipSetKey) (*MinerPower, error)
 	StateNetworkVersion(context.Context, types.TipSetKey) (network.Version, error)
-	StateSectorGetInfo(ctx context.Context, maddr address.Address, n abi.SectorNumber, tsk types.TipSetKey) (*miner.SectorOnChainInfo, error)
 	StateVerifiedClientStatus(ctx context.Context, addr address.Address, tsk types.TipSetKey) (*abi.StoragePower, error)
 	StateWaitMsg(ctx context.Context, msg cid.Cid, confidence uint64) (*MsgLookup, error)
 }

api/api_storage.go

@@ -5,18 +5,16 @@ import (
 	"context"
 	"time"
 
+	datatransfer "github.com/filecoin-project/go-data-transfer"
 	"github.com/google/uuid"
 	"github.com/ipfs/go-cid"
 	"github.com/libp2p/go-libp2p-core/peer"
 
 	"github.com/filecoin-project/go-address"
-	datatransfer "github.com/filecoin-project/go-data-transfer"
 	"github.com/filecoin-project/go-fil-markets/piecestore"
 	"github.com/filecoin-project/go-fil-markets/retrievalmarket"
 	"github.com/filecoin-project/go-fil-markets/storagemarket"
 	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/specs-storage/storage"
-
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/extern/sector-storage/fsutil"
 	"github.com/filecoin-project/lotus/extern/sector-storage/stores"
@@ -30,7 +28,6 @@ type StorageMiner interface {
 	ActorAddress(context.Context) (address.Address, error)
 
 	ActorSectorSize(context.Context, address.Address) (abi.SectorSize, error)
-	ActorAddressConfig(ctx context.Context) (AddressConfig, error)
 
 	MiningBase(context.Context) (*types.TipSet, error)
 
@@ -43,12 +40,6 @@ type StorageMiner interface {
 	// List all staged sectors
 	SectorsList(context.Context) ([]abi.SectorNumber, error)
 
-	// Get summary info of sectors
-	SectorsSummary(ctx context.Context) (map[SectorState]int, error)
-
-	// List sectors in particular states
-	SectorsListInStates(context.Context, []SectorState) ([]abi.SectorNumber, error)
-
 	SectorsRefs(context.Context) (map[string][]SealedRef, error)
 
 	// SectorStartSealing can be called on sectors in Empty or WaitDeals states
@@ -112,10 +103,6 @@ type StorageMiner interface {
 	DealsSetConsiderOfflineStorageDeals(context.Context, bool) error
 	DealsConsiderOfflineRetrievalDeals(context.Context) (bool, error)
 	DealsSetConsiderOfflineRetrievalDeals(context.Context, bool) error
-	DealsConsiderVerifiedStorageDeals(context.Context) (bool, error)
-	DealsSetConsiderVerifiedStorageDeals(context.Context, bool) error
-	DealsConsiderUnverifiedStorageDeals(context.Context) (bool, error)
-	DealsSetConsiderUnverifiedStorageDeals(context.Context, bool) error
 
 	StorageAddLocal(ctx context.Context, path string) error
 
@@ -129,8 +116,6 @@ type StorageMiner interface {
 	// LOTUS_BACKUP_BASE_PATH environment variable set to some path, and that
 	// the path specified when calling CreateBackup is within the base path
 	CreateBackup(ctx context.Context, fpath string) error
-
-	CheckProvable(ctx context.Context, pp abi.RegisteredPoStProof, sectors []storage.SectorRef, expensive bool) (map[abi.SectorNumber]string, error)
 }
 
 type SealRes struct {
@@ -210,16 +195,3 @@ func (st *SealSeed) Equals(ost *SealSeed) bool {
 }
 
 type SectorState string
-
-type AddrUse int
-
-const (
-	PreCommitAddr AddrUse = iota
-	CommitAddr
-	PoStAddr
-)
-
-type AddressConfig struct {
-	PreCommitControl []address.Address
-	CommitControl    []address.Address
-}

api/api_worker.go

@@ -23,9 +23,6 @@ type WorkerAPI interface {
 
 	storiface.WorkerCalls
 
-	TaskDisable(ctx context.Context, tt sealtasks.TaskType) error
-	TaskEnable(ctx context.Context, tt sealtasks.TaskType) error
-
 	// Storage / Other
 	Remove(ctx context.Context, sector abi.SectorID) error
 

api/apistruct/struct.go

@@ -60,9 +60,6 @@ type CommonStruct struct {
 		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"`
-		NetBlockAdd                 func(ctx context.Context, acl api.NetBlockList) error            `perm:"admin"`
-		NetBlockRemove              func(ctx context.Context, acl api.NetBlockList) error            `perm:"admin"`
-		NetBlockList                func(ctx context.Context) (api.NetBlockList, error)              `perm:"read"`
 
 		ID      func(context.Context) (peer.ID, error)     `perm:"read"`
 		Version func(context.Context) (api.Version, error) `perm:"read"`
@@ -246,7 +243,6 @@ type FullNodeStruct struct {
 
 		MarketReserveFunds func(ctx context.Context, wallet address.Address, addr address.Address, amt types.BigInt) (cid.Cid, error) `perm:"sign"`
 		MarketReleaseFunds func(ctx context.Context, addr address.Address, amt types.BigInt) error                                    `perm:"sign"`
-		MarketWithdraw     func(ctx context.Context, wallet, addr address.Address, amt 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"`
@@ -278,9 +274,8 @@ type StorageMinerStruct struct {
 	CommonStruct
 
 	Internal struct {
-		ActorAddress       func(context.Context) (address.Address, error)                 `perm:"read"`
-		ActorSectorSize    func(context.Context, address.Address) (abi.SectorSize, error) `perm:"read"`
-		ActorAddressConfig func(ctx context.Context) (api.AddressConfig, error)           `perm:"read"`
+		ActorAddress    func(context.Context) (address.Address, error)                 `perm:"read"`
+		ActorSectorSize func(context.Context, address.Address) (abi.SectorSize, error) `perm:"read"`
 
 		MiningBase func(context.Context) (*types.TipSet, error) `perm:"read"`
 
@@ -302,8 +297,6 @@ type StorageMinerStruct struct {
 
 		SectorsStatus                 func(ctx context.Context, sid abi.SectorNumber, showOnChainInfo bool) (api.SectorInfo, error) `perm:"read"`
 		SectorsList                   func(context.Context) ([]abi.SectorNumber, error)                                             `perm:"read"`
-		SectorsListInStates           func(context.Context, []api.SectorState) ([]abi.SectorNumber, error)                          `perm:"read"`
-		SectorsSummary                func(ctx context.Context) (map[api.SectorState]int, error)                                    `perm:"read"`
 		SectorsRefs                   func(context.Context) (map[string][]api.SealedRef, error)                                     `perm:"read"`
 		SectorStartSealing            func(context.Context, abi.SectorNumber) error                                                 `perm:"write"`
 		SectorSetSealDelay            func(context.Context, time.Duration) error                                                    `perm:"write"`
@@ -318,17 +311,17 @@ type StorageMinerStruct struct {
 		WorkerStats   func(context.Context) (map[uuid.UUID]storiface.WorkerStats, error) `perm:"admin"`
 		WorkerJobs    func(context.Context) (map[uuid.UUID][]storiface.WorkerJob, error) `perm:"admin"`
 
-		ReturnAddPiece        func(ctx context.Context, callID storiface.CallID, pi abi.PieceInfo, err *storiface.CallError) error          `perm:"admin" retry:"true"`
-		ReturnSealPreCommit1  func(ctx context.Context, callID storiface.CallID, p1o storage.PreCommit1Out, err *storiface.CallError) error `perm:"admin" retry:"true"`
-		ReturnSealPreCommit2  func(ctx context.Context, callID storiface.CallID, sealed storage.SectorCids, err *storiface.CallError) error `perm:"admin" retry:"true"`
-		ReturnSealCommit1     func(ctx context.Context, callID storiface.CallID, out storage.Commit1Out, err *storiface.CallError) error    `perm:"admin" retry:"true"`
-		ReturnSealCommit2     func(ctx context.Context, callID storiface.CallID, proof storage.Proof, err *storiface.CallError) error       `perm:"admin" retry:"true"`
-		ReturnFinalizeSector  func(ctx context.Context, callID storiface.CallID, err *storiface.CallError) error                            `perm:"admin" retry:"true"`
-		ReturnReleaseUnsealed func(ctx context.Context, callID storiface.CallID, err *storiface.CallError) error                            `perm:"admin" retry:"true"`
-		ReturnMoveStorage     func(ctx context.Context, callID storiface.CallID, err *storiface.CallError) error                            `perm:"admin" retry:"true"`
-		ReturnUnsealPiece     func(ctx context.Context, callID storiface.CallID, err *storiface.CallError) error                            `perm:"admin" retry:"true"`
-		ReturnReadPiece       func(ctx context.Context, callID storiface.CallID, ok bool, err *storiface.CallError) error                   `perm:"admin" retry:"true"`
-		ReturnFetch           func(ctx context.Context, callID storiface.CallID, err *storiface.CallError) error                            `perm:"admin" retry:"true"`
+		ReturnAddPiece        func(ctx context.Context, callID storiface.CallID, pi abi.PieceInfo, err string) error          `perm:"admin" retry:"true"`
+		ReturnSealPreCommit1  func(ctx context.Context, callID storiface.CallID, p1o storage.PreCommit1Out, err string) error `perm:"admin" retry:"true"`
+		ReturnSealPreCommit2  func(ctx context.Context, callID storiface.CallID, sealed storage.SectorCids, err string) error `perm:"admin" retry:"true"`
+		ReturnSealCommit1     func(ctx context.Context, callID storiface.CallID, out storage.Commit1Out, err string) error    `perm:"admin" retry:"true"`
+		ReturnSealCommit2     func(ctx context.Context, callID storiface.CallID, proof storage.Proof, err string) error       `perm:"admin" retry:"true"`
+		ReturnFinalizeSector  func(ctx context.Context, callID storiface.CallID, err string) error                            `perm:"admin" retry:"true"`
+		ReturnReleaseUnsealed func(ctx context.Context, callID storiface.CallID, err string) error                            `perm:"admin" retry:"true"`
+		ReturnMoveStorage     func(ctx context.Context, callID storiface.CallID, err string) error                            `perm:"admin" retry:"true"`
+		ReturnUnsealPiece     func(ctx context.Context, callID storiface.CallID, err string) error                            `perm:"admin" retry:"true"`
+		ReturnReadPiece       func(ctx context.Context, callID storiface.CallID, ok bool, err string) error                   `perm:"admin" retry:"true"`
+		ReturnFetch           func(ctx context.Context, callID storiface.CallID, err string) error                            `perm:"admin" retry:"true"`
 
 		SealingSchedDiag func(context.Context, bool) (interface{}, error)       `perm:"admin"`
 		SealingAbort     func(ctx context.Context, call storiface.CallID) error `perm:"admin"`
@@ -346,22 +339,18 @@ type StorageMinerStruct struct {
 		StorageLock          func(ctx context.Context, sector abi.SectorID, read storiface.SectorFileType, write storiface.SectorFileType) error                          `perm:"admin"`
 		StorageTryLock       func(ctx context.Context, sector abi.SectorID, read storiface.SectorFileType, write storiface.SectorFileType) (bool, error)                  `perm:"admin"`
 
-		DealsImportData                        func(ctx context.Context, dealPropCid cid.Cid, file string) error `perm:"write"`
-		DealsList                              func(ctx context.Context) ([]api.MarketDeal, error)               `perm:"read"`
-		DealsConsiderOnlineStorageDeals        func(context.Context) (bool, error)                               `perm:"read"`
-		DealsSetConsiderOnlineStorageDeals     func(context.Context, bool) error                                 `perm:"admin"`
-		DealsConsiderOnlineRetrievalDeals      func(context.Context) (bool, error)                               `perm:"read"`
-		DealsSetConsiderOnlineRetrievalDeals   func(context.Context, bool) error                                 `perm:"admin"`
-		DealsConsiderOfflineStorageDeals       func(context.Context) (bool, error)                               `perm:"read"`
-		DealsSetConsiderOfflineStorageDeals    func(context.Context, bool) error                                 `perm:"admin"`
-		DealsConsiderOfflineRetrievalDeals     func(context.Context) (bool, error)                               `perm:"read"`
-		DealsSetConsiderOfflineRetrievalDeals  func(context.Context, bool) error                                 `perm:"admin"`
-		DealsConsiderVerifiedStorageDeals      func(context.Context) (bool, error)                               `perm:"read"`
-		DealsSetConsiderVerifiedStorageDeals   func(context.Context, bool) error                                 `perm:"admin"`
-		DealsConsiderUnverifiedStorageDeals    func(context.Context) (bool, error)                               `perm:"read"`
-		DealsSetConsiderUnverifiedStorageDeals func(context.Context, bool) error                                 `perm:"admin"`
-		DealsPieceCidBlocklist                 func(context.Context) ([]cid.Cid, error)                          `perm:"read"`
-		DealsSetPieceCidBlocklist              func(context.Context, []cid.Cid) error                            `perm:"admin"`
+		DealsImportData                       func(ctx context.Context, dealPropCid cid.Cid, file string) error `perm:"write"`
+		DealsList                             func(ctx context.Context) ([]api.MarketDeal, error)               `perm:"read"`
+		DealsConsiderOnlineStorageDeals       func(context.Context) (bool, error)                               `perm:"read"`
+		DealsSetConsiderOnlineStorageDeals    func(context.Context, bool) error                                 `perm:"admin"`
+		DealsConsiderOnlineRetrievalDeals     func(context.Context) (bool, error)                               `perm:"read"`
+		DealsSetConsiderOnlineRetrievalDeals  func(context.Context, bool) error                                 `perm:"admin"`
+		DealsConsiderOfflineStorageDeals      func(context.Context) (bool, error)                               `perm:"read"`
+		DealsSetConsiderOfflineStorageDeals   func(context.Context, bool) error                                 `perm:"admin"`
+		DealsConsiderOfflineRetrievalDeals    func(context.Context) (bool, error)                               `perm:"read"`
+		DealsSetConsiderOfflineRetrievalDeals func(context.Context, bool) error                                 `perm:"admin"`
+		DealsPieceCidBlocklist                func(context.Context) ([]cid.Cid, error)                          `perm:"read"`
+		DealsSetPieceCidBlocklist             func(context.Context, []cid.Cid) error                            `perm:"admin"`
 
 		StorageAddLocal func(ctx context.Context, path string) error `perm:"admin"`
 
@@ -371,8 +360,6 @@ type StorageMinerStruct struct {
 		PiecesGetCIDInfo   func(ctx context.Context, payloadCid cid.Cid) (*piecestore.CIDInfo, error) `perm:"read"`
 
 		CreateBackup func(ctx context.Context, fpath string) error `perm:"admin"`
-
-		CheckProvable func(ctx context.Context, pp abi.RegisteredPoStProof, sectors []storage.SectorRef, expensive bool) (map[abi.SectorNumber]string, error) `perm:"admin"`
 	}
 }
 
@@ -386,20 +373,17 @@ 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 storage.SectorRef, pieceSizes []abi.UnpaddedPieceSize, newPieceSize abi.UnpaddedPieceSize, pieceData storage.Data) (storiface.CallID, error)                 `perm:"admin"`
-		SealPreCommit1  func(ctx context.Context, sector storage.SectorRef, ticket abi.SealRandomness, pieces []abi.PieceInfo) (storiface.CallID, error)                                                              `perm:"admin"`
-		SealPreCommit2  func(ctx context.Context, sector storage.SectorRef, pc1o storage.PreCommit1Out) (storiface.CallID, error)                                                                                     `perm:"admin"`
-		SealCommit1     func(ctx context.Context, sector storage.SectorRef, ticket abi.SealRandomness, seed abi.InteractiveSealRandomness, pieces []abi.PieceInfo, cids storage.SectorCids) (storiface.CallID, error) `perm:"admin"`
-		SealCommit2     func(ctx context.Context, sector storage.SectorRef, c1o storage.Commit1Out) (storiface.CallID, error)                                                                                         `perm:"admin"`
-		FinalizeSector  func(ctx context.Context, sector storage.SectorRef, keepUnsealed []storage.Range) (storiface.CallID, error)                                                                                   `perm:"admin"`
-		ReleaseUnsealed func(ctx context.Context, sector storage.SectorRef, safeToFree []storage.Range) (storiface.CallID, error)                                                                                     `perm:"admin"`
-		MoveStorage     func(ctx context.Context, sector storage.SectorRef, types storiface.SectorFileType) (storiface.CallID, error)                                                                                 `perm:"admin"`
-		UnsealPiece     func(context.Context, storage.SectorRef, storiface.UnpaddedByteIndex, abi.UnpaddedPieceSize, abi.SealRandomness, cid.Cid) (storiface.CallID, error)                                           `perm:"admin"`
-		ReadPiece       func(context.Context, io.Writer, storage.SectorRef, storiface.UnpaddedByteIndex, abi.UnpaddedPieceSize) (storiface.CallID, error)                                                             `perm:"admin"`
-		Fetch           func(context.Context, storage.SectorRef, storiface.SectorFileType, storiface.PathType, storiface.AcquireMode) (storiface.CallID, error)                                                       `perm:"admin"`
-
-		TaskDisable func(ctx context.Context, tt sealtasks.TaskType) error `perm:"admin"`
-		TaskEnable  func(ctx context.Context, tt sealtasks.TaskType) error `perm:"admin"`
+		AddPiece        func(ctx context.Context, sector abi.SectorID, pieceSizes []abi.UnpaddedPieceSize, newPieceSize abi.UnpaddedPieceSize, pieceData storage.Data) (storiface.CallID, error)                 `perm:"admin"`
+		SealPreCommit1  func(ctx context.Context, sector abi.SectorID, ticket abi.SealRandomness, pieces []abi.PieceInfo) (storiface.CallID, error)                                                              `perm:"admin"`
+		SealPreCommit2  func(ctx context.Context, sector abi.SectorID, pc1o storage.PreCommit1Out) (storiface.CallID, error)                                                                                     `perm:"admin"`
+		SealCommit1     func(ctx context.Context, sector abi.SectorID, ticket abi.SealRandomness, seed abi.InteractiveSealRandomness, pieces []abi.PieceInfo, cids storage.SectorCids) (storiface.CallID, error) `perm:"admin"`
+		SealCommit2     func(ctx context.Context, sector abi.SectorID, c1o storage.Commit1Out) (storiface.CallID, error)                                                                                         `perm:"admin"`
+		FinalizeSector  func(ctx context.Context, sector abi.SectorID, keepUnsealed []storage.Range) (storiface.CallID, error)                                                                                   `perm:"admin"`
+		ReleaseUnsealed func(ctx context.Context, sector abi.SectorID, safeToFree []storage.Range) (storiface.CallID, error)                                                                                     `perm:"admin"`
+		MoveStorage     func(ctx context.Context, sector abi.SectorID, types storiface.SectorFileType) (storiface.CallID, error)                                                                                 `perm:"admin"`
+		UnsealPiece     func(context.Context, abi.SectorID, storiface.UnpaddedByteIndex, abi.UnpaddedPieceSize, abi.SealRandomness, cid.Cid) (storiface.CallID, error)                                           `perm:"admin"`
+		ReadPiece       func(context.Context, io.Writer, abi.SectorID, storiface.UnpaddedByteIndex, abi.UnpaddedPieceSize) (storiface.CallID, error)                                                             `perm:"admin"`
+		Fetch           func(context.Context, abi.SectorID, storiface.SectorFileType, storiface.PathType, storiface.AcquireMode) (storiface.CallID, error)                                                       `perm:"admin"`
 
 		Remove          func(ctx context.Context, sector abi.SectorID) error `perm:"admin"`
 		StorageAddLocal func(ctx context.Context, path string) error         `perm:"admin"`
@@ -440,7 +424,6 @@ type GatewayStruct struct {
 		StateMarketBalance                func(ctx context.Context, addr address.Address, tsk types.TipSetKey) (api.MarketBalance, error)
 		StateMarketStorageDeal            func(ctx context.Context, dealId abi.DealID, tsk types.TipSetKey) (*api.MarketDeal, error)
 		StateNetworkVersion               func(ctx context.Context, tsk types.TipSetKey) (stnetwork.Version, error)
-		StateSectorGetInfo                func(ctx context.Context, maddr address.Address, n abi.SectorNumber, tsk types.TipSetKey) (*miner.SectorOnChainInfo, error)
 		StateVerifiedClientStatus         func(ctx context.Context, addr address.Address, tsk types.TipSetKey) (*abi.StoragePower, error)
 		StateWaitMsg                      func(ctx context.Context, msg cid.Cid, confidence uint64) (*api.MsgLookup, error)
 	}
@@ -512,18 +495,6 @@ func (c *CommonStruct) NetBandwidthStatsByProtocol(ctx context.Context) (map[pro
 	return c.Internal.NetBandwidthStatsByProtocol(ctx)
 }
 
-func (c *CommonStruct) NetBlockAdd(ctx context.Context, acl api.NetBlockList) error {
-	return c.Internal.NetBlockAdd(ctx, acl)
-}
-
-func (c *CommonStruct) NetBlockRemove(ctx context.Context, acl api.NetBlockList) error {
-	return c.Internal.NetBlockRemove(ctx, acl)
-}
-
-func (c *CommonStruct) NetBlockList(ctx context.Context) (api.NetBlockList, error) {
-	return c.Internal.NetBlockList(ctx)
-}
-
 func (c *CommonStruct) NetAgentVersion(ctx context.Context, p peer.ID) (string, error) {
 	return c.Internal.NetAgentVersion(ctx, p)
 }
@@ -1156,10 +1127,6 @@ func (c *FullNodeStruct) MarketReleaseFunds(ctx context.Context, addr address.Ad
 	return c.Internal.MarketReleaseFunds(ctx, addr, amt)
 }
 
-func (c *FullNodeStruct) MarketWithdraw(ctx context.Context, wallet, addr address.Address, amt types.BigInt) (cid.Cid, error) {
-	return c.Internal.MarketWithdraw(ctx, wallet, addr, amt)
-}
-
 func (c *FullNodeStruct) PaychGet(ctx context.Context, from, to address.Address, amt types.BigInt) (*api.ChannelInfo, error) {
 	return c.Internal.PaychGet(ctx, from, to, amt)
 }
@@ -1242,10 +1209,6 @@ func (c *StorageMinerStruct) ActorSectorSize(ctx context.Context, addr address.A
 	return c.Internal.ActorSectorSize(ctx, addr)
 }
 
-func (c *StorageMinerStruct) ActorAddressConfig(ctx context.Context) (api.AddressConfig, error) {
-	return c.Internal.ActorAddressConfig(ctx)
-}
-
 func (c *StorageMinerStruct) PledgeSector(ctx context.Context) error {
 	return c.Internal.PledgeSector(ctx)
 }
@@ -1260,14 +1223,6 @@ func (c *StorageMinerStruct) SectorsList(ctx context.Context) ([]abi.SectorNumbe
 	return c.Internal.SectorsList(ctx)
 }
 
-func (c *StorageMinerStruct) SectorsListInStates(ctx context.Context, states []api.SectorState) ([]abi.SectorNumber, error) {
-	return c.Internal.SectorsListInStates(ctx, states)
-}
-
-func (c *StorageMinerStruct) SectorsSummary(ctx context.Context) (map[api.SectorState]int, error) {
-	return c.Internal.SectorsSummary(ctx)
-}
-
 func (c *StorageMinerStruct) SectorsRefs(ctx context.Context) (map[string][]api.SealedRef, error) {
 	return c.Internal.SectorsRefs(ctx)
 }
@@ -1316,47 +1271,47 @@ func (c *StorageMinerStruct) WorkerJobs(ctx context.Context) (map[uuid.UUID][]st
 	return c.Internal.WorkerJobs(ctx)
 }
 
-func (c *StorageMinerStruct) ReturnAddPiece(ctx context.Context, callID storiface.CallID, pi abi.PieceInfo, err *storiface.CallError) error {
+func (c *StorageMinerStruct) ReturnAddPiece(ctx context.Context, callID storiface.CallID, pi abi.PieceInfo, err string) error {
 	return c.Internal.ReturnAddPiece(ctx, callID, pi, err)
 }
 
-func (c *StorageMinerStruct) ReturnSealPreCommit1(ctx context.Context, callID storiface.CallID, p1o storage.PreCommit1Out, err *storiface.CallError) error {
+func (c *StorageMinerStruct) ReturnSealPreCommit1(ctx context.Context, callID storiface.CallID, p1o storage.PreCommit1Out, err string) error {
 	return c.Internal.ReturnSealPreCommit1(ctx, callID, p1o, err)
 }
 
-func (c *StorageMinerStruct) ReturnSealPreCommit2(ctx context.Context, callID storiface.CallID, sealed storage.SectorCids, err *storiface.CallError) error {
+func (c *StorageMinerStruct) ReturnSealPreCommit2(ctx context.Context, callID storiface.CallID, sealed storage.SectorCids, err string) error {
 	return c.Internal.ReturnSealPreCommit2(ctx, callID, sealed, err)
 }
 
-func (c *StorageMinerStruct) ReturnSealCommit1(ctx context.Context, callID storiface.CallID, out storage.Commit1Out, err *storiface.CallError) error {
+func (c *StorageMinerStruct) ReturnSealCommit1(ctx context.Context, callID storiface.CallID, out storage.Commit1Out, err string) error {
 	return c.Internal.ReturnSealCommit1(ctx, callID, out, err)
 }
 
-func (c *StorageMinerStruct) ReturnSealCommit2(ctx context.Context, callID storiface.CallID, proof storage.Proof, err *storiface.CallError) error {
+func (c *StorageMinerStruct) ReturnSealCommit2(ctx context.Context, callID storiface.CallID, proof storage.Proof, err string) error {
 	return c.Internal.ReturnSealCommit2(ctx, callID, proof, err)
 }
 
-func (c *StorageMinerStruct) ReturnFinalizeSector(ctx context.Context, callID storiface.CallID, err *storiface.CallError) error {
+func (c *StorageMinerStruct) ReturnFinalizeSector(ctx context.Context, callID storiface.CallID, err string) error {
 	return c.Internal.ReturnFinalizeSector(ctx, callID, err)
 }
 
-func (c *StorageMinerStruct) ReturnReleaseUnsealed(ctx context.Context, callID storiface.CallID, err *storiface.CallError) error {
+func (c *StorageMinerStruct) ReturnReleaseUnsealed(ctx context.Context, callID storiface.CallID, err string) error {
 	return c.Internal.ReturnReleaseUnsealed(ctx, callID, err)
 }
 
-func (c *StorageMinerStruct) ReturnMoveStorage(ctx context.Context, callID storiface.CallID, err *storiface.CallError) error {
+func (c *StorageMinerStruct) ReturnMoveStorage(ctx context.Context, callID storiface.CallID, err string) error {
 	return c.Internal.ReturnMoveStorage(ctx, callID, err)
 }
 
-func (c *StorageMinerStruct) ReturnUnsealPiece(ctx context.Context, callID storiface.CallID, err *storiface.CallError) error {
+func (c *StorageMinerStruct) ReturnUnsealPiece(ctx context.Context, callID storiface.CallID, err string) error {
 	return c.Internal.ReturnUnsealPiece(ctx, callID, err)
 }
 
-func (c *StorageMinerStruct) ReturnReadPiece(ctx context.Context, callID storiface.CallID, ok bool, err *storiface.CallError) error {
+func (c *StorageMinerStruct) ReturnReadPiece(ctx context.Context, callID storiface.CallID, ok bool, err string) error {
 	return c.Internal.ReturnReadPiece(ctx, callID, ok, err)
 }
 
-func (c *StorageMinerStruct) ReturnFetch(ctx context.Context, callID storiface.CallID, err *storiface.CallError) error {
+func (c *StorageMinerStruct) ReturnFetch(ctx context.Context, callID storiface.CallID, err string) error {
 	return c.Internal.ReturnFetch(ctx, callID, err)
 }
 
@@ -1516,22 +1471,6 @@ func (c *StorageMinerStruct) DealsSetConsiderOfflineRetrievalDeals(ctx context.C
 	return c.Internal.DealsSetConsiderOfflineRetrievalDeals(ctx, b)
 }
 
-func (c *StorageMinerStruct) DealsConsiderVerifiedStorageDeals(ctx context.Context) (bool, error) {
-	return c.Internal.DealsConsiderVerifiedStorageDeals(ctx)
-}
-
-func (c *StorageMinerStruct) DealsSetConsiderVerifiedStorageDeals(ctx context.Context, b bool) error {
-	return c.Internal.DealsSetConsiderVerifiedStorageDeals(ctx, b)
-}
-
-func (c *StorageMinerStruct) DealsConsiderUnverifiedStorageDeals(ctx context.Context) (bool, error) {
-	return c.Internal.DealsConsiderUnverifiedStorageDeals(ctx)
-}
-
-func (c *StorageMinerStruct) DealsSetConsiderUnverifiedStorageDeals(ctx context.Context, b bool) error {
-	return c.Internal.DealsSetConsiderUnverifiedStorageDeals(ctx, b)
-}
-
 func (c *StorageMinerStruct) StorageAddLocal(ctx context.Context, path string) error {
 	return c.Internal.StorageAddLocal(ctx, path)
 }
@@ -1556,10 +1495,6 @@ func (c *StorageMinerStruct) CreateBackup(ctx context.Context, fpath string) err
 	return c.Internal.CreateBackup(ctx, fpath)
 }
 
-func (c *StorageMinerStruct) CheckProvable(ctx context.Context, pp abi.RegisteredPoStProof, sectors []storage.SectorRef, expensive bool) (map[abi.SectorNumber]string, error) {
-	return c.Internal.CheckProvable(ctx, pp, sectors, expensive)
-}
-
 // WorkerStruct
 
 func (w *WorkerStruct) Version(ctx context.Context) (build.Version, error) {
@@ -1578,58 +1513,50 @@ func (w *WorkerStruct) Info(ctx context.Context) (storiface.WorkerInfo, error) {
 	return w.Internal.Info(ctx)
 }
 
-func (w *WorkerStruct) AddPiece(ctx context.Context, sector storage.SectorRef, pieceSizes []abi.UnpaddedPieceSize, newPieceSize abi.UnpaddedPieceSize, pieceData storage.Data) (storiface.CallID, error) {
+func (w *WorkerStruct) AddPiece(ctx context.Context, sector abi.SectorID, pieceSizes []abi.UnpaddedPieceSize, newPieceSize abi.UnpaddedPieceSize, pieceData storage.Data) (storiface.CallID, error) {
 	return w.Internal.AddPiece(ctx, sector, pieceSizes, newPieceSize, pieceData)
 }
 
-func (w *WorkerStruct) SealPreCommit1(ctx context.Context, sector storage.SectorRef, ticket abi.SealRandomness, pieces []abi.PieceInfo) (storiface.CallID, error) {
+func (w *WorkerStruct) SealPreCommit1(ctx context.Context, sector abi.SectorID, ticket abi.SealRandomness, pieces []abi.PieceInfo) (storiface.CallID, error) {
 	return w.Internal.SealPreCommit1(ctx, sector, ticket, pieces)
 }
 
-func (w *WorkerStruct) SealPreCommit2(ctx context.Context, sector storage.SectorRef, pc1o storage.PreCommit1Out) (storiface.CallID, error) {
+func (w *WorkerStruct) SealPreCommit2(ctx context.Context, sector abi.SectorID, pc1o storage.PreCommit1Out) (storiface.CallID, error) {
 	return w.Internal.SealPreCommit2(ctx, sector, pc1o)
 }
 
-func (w *WorkerStruct) SealCommit1(ctx context.Context, sector storage.SectorRef, ticket abi.SealRandomness, seed abi.InteractiveSealRandomness, pieces []abi.PieceInfo, cids storage.SectorCids) (storiface.CallID, error) {
+func (w *WorkerStruct) SealCommit1(ctx context.Context, sector abi.SectorID, ticket abi.SealRandomness, seed abi.InteractiveSealRandomness, pieces []abi.PieceInfo, cids storage.SectorCids) (storiface.CallID, error) {
 	return w.Internal.SealCommit1(ctx, sector, ticket, seed, pieces, cids)
 }
 
-func (w *WorkerStruct) SealCommit2(ctx context.Context, sector storage.SectorRef, c1o storage.Commit1Out) (storiface.CallID, error) {
+func (w *WorkerStruct) SealCommit2(ctx context.Context, sector abi.SectorID, c1o storage.Commit1Out) (storiface.CallID, error) {
 	return w.Internal.SealCommit2(ctx, sector, c1o)
 }
 
-func (w *WorkerStruct) FinalizeSector(ctx context.Context, sector storage.SectorRef, keepUnsealed []storage.Range) (storiface.CallID, error) {
+func (w *WorkerStruct) FinalizeSector(ctx context.Context, sector abi.SectorID, keepUnsealed []storage.Range) (storiface.CallID, error) {
 	return w.Internal.FinalizeSector(ctx, sector, keepUnsealed)
 }
 
-func (w *WorkerStruct) ReleaseUnsealed(ctx context.Context, sector storage.SectorRef, safeToFree []storage.Range) (storiface.CallID, error) {
+func (w *WorkerStruct) ReleaseUnsealed(ctx context.Context, sector abi.SectorID, safeToFree []storage.Range) (storiface.CallID, error) {
 	return w.Internal.ReleaseUnsealed(ctx, sector, safeToFree)
 }
 
-func (w *WorkerStruct) MoveStorage(ctx context.Context, sector storage.SectorRef, types storiface.SectorFileType) (storiface.CallID, error) {
+func (w *WorkerStruct) MoveStorage(ctx context.Context, sector abi.SectorID, types storiface.SectorFileType) (storiface.CallID, error) {
 	return w.Internal.MoveStorage(ctx, sector, types)
 }
 
-func (w *WorkerStruct) UnsealPiece(ctx context.Context, sector storage.SectorRef, offset storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize, ticket abi.SealRandomness, c cid.Cid) (storiface.CallID, error) {
+func (w *WorkerStruct) UnsealPiece(ctx context.Context, sector abi.SectorID, offset storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize, ticket abi.SealRandomness, c cid.Cid) (storiface.CallID, error) {
 	return w.Internal.UnsealPiece(ctx, sector, offset, size, ticket, c)
 }
 
-func (w *WorkerStruct) ReadPiece(ctx context.Context, sink io.Writer, sector storage.SectorRef, offset storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize) (storiface.CallID, error) {
+func (w *WorkerStruct) ReadPiece(ctx context.Context, sink io.Writer, sector abi.SectorID, offset storiface.UnpaddedByteIndex, size abi.UnpaddedPieceSize) (storiface.CallID, error) {
 	return w.Internal.ReadPiece(ctx, sink, sector, offset, size)
 }
 
-func (w *WorkerStruct) Fetch(ctx context.Context, id storage.SectorRef, fileType storiface.SectorFileType, ptype storiface.PathType, am storiface.AcquireMode) (storiface.CallID, error) {
+func (w *WorkerStruct) Fetch(ctx context.Context, id abi.SectorID, fileType storiface.SectorFileType, ptype storiface.PathType, am storiface.AcquireMode) (storiface.CallID, error) {
 	return w.Internal.Fetch(ctx, id, fileType, ptype, am)
 }
 
-func (w *WorkerStruct) TaskDisable(ctx context.Context, tt sealtasks.TaskType) error {
-	return w.Internal.TaskDisable(ctx, tt)
-}
-
-func (w *WorkerStruct) TaskEnable(ctx context.Context, tt sealtasks.TaskType) error {
-	return w.Internal.TaskEnable(ctx, tt)
-}
-
 func (w *WorkerStruct) Remove(ctx context.Context, sector abi.SectorID) error {
 	return w.Internal.Remove(ctx, sector)
 }
@@ -1754,10 +1681,6 @@ func (g GatewayStruct) StateNetworkVersion(ctx context.Context, tsk types.TipSet
 	return g.Internal.StateNetworkVersion(ctx, tsk)
 }
 
-func (g GatewayStruct) StateSectorGetInfo(ctx context.Context, maddr address.Address, n abi.SectorNumber, tsk types.TipSetKey) (*miner.SectorOnChainInfo, error) {
-	return g.Internal.StateSectorGetInfo(ctx, maddr, n, tsk)
-}
-
 func (g GatewayStruct) StateVerifiedClientStatus(ctx context.Context, addr address.Address, tsk types.TipSetKey) (*abi.StoragePower, error) {
 	return g.Internal.StateVerifiedClientStatus(ctx, addr, tsk)
 }

api/docgen/docgen.go

@@ -90,7 +90,7 @@ func init() {
 	addExample(&pid)
 
 	addExample(bitfield.NewFromSet([]uint64{5}))
-	addExample(abi.RegisteredSealProof_StackedDrg32GiBV1_1)
+	addExample(abi.RegisteredSealProof_StackedDrg32GiBV1)
 	addExample(abi.RegisteredPoStProof_StackedDrgWindow32GiBV1)
 	addExample(abi.ChainEpoch(10101))
 	addExample(crypto.SigTypeBLS)
@@ -233,14 +233,6 @@ func init() {
 			CpuUse:     0,
 		},
 	})
-	addExample(storiface.ErrorCode(0))
-	addExample(map[abi.SectorNumber]string{
-		123: "can't acquire read lock",
-	})
-	addExample(map[api.SectorState]int{
-		api.SectorState(sealing.Proving): 120,
-	})
-	addExample([]abi.SectorNumber{123, 124})
 
 	// worker specific
 	addExample(storiface.AcquireMove)
@@ -248,7 +240,6 @@ func init() {
 	addExample(map[sealtasks.TaskType]struct{}{
 		sealtasks.TTPreCommit2: {},
 	})
-	addExample(sealtasks.TTCommit2)
 }
 
 func exampleValue(method string, t, parent reflect.Type) interface{} {

api/test/ccupgrade.go

@@ -31,7 +31,7 @@ func TestCCUpgrade(t *testing.T, b APIBuilder, blocktime time.Duration) {
 
 func testCCUpgrade(t *testing.T, b APIBuilder, blocktime time.Duration, upgradeHeight abi.ChainEpoch) {
 	ctx := context.Background()
-	n, sn := b(t, []FullNodeOpts{FullNodeWithActorsV2At(upgradeHeight)}, OneMiner)
+	n, sn := b(t, []FullNodeOpts{FullNodeWithUpgradeAt(upgradeHeight)}, OneMiner)
 	client := n[0].FullNode.(*impl.FullNodeAPI)
 	miner := sn[0]
 
@@ -89,7 +89,7 @@ func testCCUpgrade(t *testing.T, b APIBuilder, blocktime time.Duration, upgradeH
 		t.Fatal(err)
 	}
 
-	MakeDeal(t, ctx, 6, client, miner, false, false, 0)
+	MakeDeal(t, ctx, 6, client, miner, false, false)
 
 	// Validate upgrade
 

api/test/deals.go

@@ -12,8 +12,6 @@ import (
 	"testing"
 	"time"
 
-	"github.com/filecoin-project/go-state-types/abi"
-
 	"github.com/stretchr/testify/require"
 
 	"github.com/ipfs/go-cid"
@@ -33,7 +31,7 @@ import (
 	ipld "github.com/ipfs/go-ipld-format"
 )
 
-func TestDealFlow(t *testing.T, b APIBuilder, blocktime time.Duration, carExport, fastRet bool, startEpoch abi.ChainEpoch) {
+func TestDealFlow(t *testing.T, b APIBuilder, blocktime time.Duration, carExport, fastRet bool) {
 
 	ctx := context.Background()
 	n, sn := b(t, OneFull, OneMiner)
@@ -62,14 +60,14 @@ func TestDealFlow(t *testing.T, b APIBuilder, blocktime time.Duration, carExport
 		}
 	}()
 
-	MakeDeal(t, ctx, 6, client, miner, carExport, fastRet, startEpoch)
+	MakeDeal(t, ctx, 6, client, miner, carExport, fastRet)
 
 	atomic.AddInt64(&mine, -1)
 	fmt.Println("shutting down mining")
 	<-done
 }
 
-func TestDoubleDealFlow(t *testing.T, b APIBuilder, blocktime time.Duration, startEpoch abi.ChainEpoch) {
+func TestDoubleDealFlow(t *testing.T, b APIBuilder, blocktime time.Duration) {
 
 	ctx := context.Background()
 	n, sn := b(t, OneFull, OneMiner)
@@ -99,15 +97,15 @@ func TestDoubleDealFlow(t *testing.T, b APIBuilder, blocktime time.Duration, sta
 		}
 	}()
 
-	MakeDeal(t, ctx, 6, client, miner, false, false, startEpoch)
-	MakeDeal(t, ctx, 7, client, miner, false, false, startEpoch)
+	MakeDeal(t, ctx, 6, client, miner, false, false)
+	MakeDeal(t, ctx, 7, client, miner, false, false)
 
 	atomic.AddInt64(&mine, -1)
 	fmt.Println("shutting down mining")
 	<-done
 }
 
-func MakeDeal(t *testing.T, ctx context.Context, rseed int, client api.FullNode, miner TestStorageNode, carExport, fastRet bool, startEpoch abi.ChainEpoch) {
+func MakeDeal(t *testing.T, ctx context.Context, rseed int, client api.FullNode, miner TestStorageNode, carExport, fastRet bool) {
 	res, data, err := CreateClientFile(ctx, client, rseed)
 	if err != nil {
 		t.Fatal(err)
@@ -116,7 +114,7 @@ func MakeDeal(t *testing.T, ctx context.Context, rseed int, client api.FullNode,
 	fcid := res.Root
 	fmt.Println("FILE CID: ", fcid)
 
-	deal := startDeal(t, ctx, miner, client, fcid, fastRet, startEpoch)
+	deal := startDeal(t, ctx, miner, client, fcid, fastRet)
 
 	// TODO: this sleep is only necessary because deals don't immediately get logged in the dealstore, we should fix this
 	time.Sleep(time.Second)
@@ -151,7 +149,7 @@ func CreateClientFile(ctx context.Context, client api.FullNode, rseed int) (*api
 	return res, data, nil
 }
 
-func TestFastRetrievalDealFlow(t *testing.T, b APIBuilder, blocktime time.Duration, startEpoch abi.ChainEpoch) {
+func TestFastRetrievalDealFlow(t *testing.T, b APIBuilder, blocktime time.Duration) {
 
 	ctx := context.Background()
 	n, sn := b(t, OneFull, OneMiner)
@@ -191,7 +189,7 @@ func TestFastRetrievalDealFlow(t *testing.T, b APIBuilder, blocktime time.Durati
 
 	fmt.Println("FILE CID: ", fcid)
 
-	deal := startDeal(t, ctx, miner, client, fcid, true, startEpoch)
+	deal := startDeal(t, ctx, miner, client, fcid, true)
 
 	waitDealPublished(t, ctx, miner, deal)
 	fmt.Println("deal published, retrieving")
@@ -205,7 +203,7 @@ func TestFastRetrievalDealFlow(t *testing.T, b APIBuilder, blocktime time.Durati
 	<-done
 }
 
-func TestSecondDealRetrieval(t *testing.T, b APIBuilder, blocktime time.Duration) {
+func TestSenondDealRetrieval(t *testing.T, b APIBuilder, blocktime time.Duration) {
 
 	ctx := context.Background()
 	n, sn := b(t, OneFull, OneMiner)
@@ -254,13 +252,13 @@ func TestSecondDealRetrieval(t *testing.T, b APIBuilder, blocktime time.Duration
 			t.Fatal(err)
 		}
 
-		deal1 := startDeal(t, ctx, miner, client, fcid1, true, 0)
+		deal1 := startDeal(t, ctx, miner, client, fcid1, true)
 
 		// TODO: this sleep is only necessary because deals don't immediately get logged in the dealstore, we should fix this
 		time.Sleep(time.Second)
 		waitDealSealed(t, ctx, miner, client, deal1, true)
 
-		deal2 := startDeal(t, ctx, miner, client, fcid2, true, 0)
+		deal2 := startDeal(t, ctx, miner, client, fcid2, true)
 
 		time.Sleep(time.Second)
 		waitDealSealed(t, ctx, miner, client, deal2, false)
@@ -280,7 +278,7 @@ func TestSecondDealRetrieval(t *testing.T, b APIBuilder, blocktime time.Duration
 	<-done
 }
 
-func startDeal(t *testing.T, ctx context.Context, miner TestStorageNode, client api.FullNode, fcid cid.Cid, fastRet bool, startEpoch abi.ChainEpoch) *cid.Cid {
+func startDeal(t *testing.T, ctx context.Context, miner TestStorageNode, client api.FullNode, fcid cid.Cid, fastRet bool) *cid.Cid {
 	maddr, err := miner.ActorAddress(ctx)
 	if err != nil {
 		t.Fatal(err)
@@ -298,7 +296,6 @@ func startDeal(t *testing.T, ctx context.Context, miner TestStorageNode, client
 		Wallet:            addr,
 		Miner:             maddr,
 		EpochPrice:        types.NewInt(1000000),
-		DealStartEpoch:    startEpoch,
 		MinBlocksDuration: uint64(build.MinDealDuration),
 		FastRetrieval:     fastRet,
 	})
@@ -316,7 +313,7 @@ loop:
 			t.Fatal(err)
 		}
 		switch di.State {
-		case storagemarket.StorageDealAwaitingPreCommit, storagemarket.StorageDealSealing:
+		case storagemarket.StorageDealSealing:
 			if noseal {
 				return
 			}
@@ -356,7 +353,7 @@ func waitDealPublished(t *testing.T, ctx context.Context, miner TestStorageNode,
 					t.Fatal("deal failed")
 				case storagemarket.StorageDealError:
 					t.Fatal("deal errored", di.Message)
-				case storagemarket.StorageDealFinalizing, storagemarket.StorageDealAwaitingPreCommit, storagemarket.StorageDealSealing, storagemarket.StorageDealActive:
+				case storagemarket.StorageDealFinalizing, storagemarket.StorageDealSealing, storagemarket.StorageDealActive:
 					fmt.Println("COMPLETE", di)
 					return
 				}

api/test/mining.go

@@ -186,7 +186,7 @@ func TestDealMining(t *testing.T, b APIBuilder, blocktime time.Duration, carExpo
 		}
 	}()
 
-	deal := startDeal(t, ctx, provider, client, fcid, false, 0)
+	deal := startDeal(t, ctx, provider, client, fcid, false)
 
 	// TODO: this sleep is only necessary because deals don't immediately get logged in the dealstore, we should fix this
 	time.Sleep(time.Second)

api/test/test.go

@@ -109,7 +109,7 @@ var OneMiner = []StorageMiner{{Full: 0, Preseal: PresealGenesis}}
 var OneFull = DefaultFullOpts(1)
 var TwoFull = DefaultFullOpts(2)
 
-var FullNodeWithActorsV2At = func(upgradeHeight abi.ChainEpoch) FullNodeOpts {
+var FullNodeWithUpgradeAt = func(upgradeHeight abi.ChainEpoch) FullNodeOpts {
 	return FullNodeOpts{
 		Opts: func(nodes []TestNode) node.Option {
 			return node.Override(new(stmgr.UpgradeSchedule), stmgr.UpgradeSchedule{{
@@ -122,25 +122,6 @@ var FullNodeWithActorsV2At = func(upgradeHeight abi.ChainEpoch) FullNodeOpts {
 	}
 }
 
-var FullNodeWithSDRAt = func(calico, persian abi.ChainEpoch) FullNodeOpts {
-	return FullNodeOpts{
-		Opts: func(nodes []TestNode) node.Option {
-			return node.Override(new(stmgr.UpgradeSchedule), stmgr.UpgradeSchedule{{
-				Network:   network.Version6,
-				Height:    1,
-				Migration: stmgr.UpgradeActorsV2,
-			}, {
-				Network:   network.Version7,
-				Height:    calico,
-				Migration: stmgr.UpgradeCalico,
-			}, {
-				Network: network.Version8,
-				Height:  persian,
-			}})
-		},
-	}
-}
-
 var MineNext = miner.MineReq{
 	InjectNulls: 0,
 	Done:        func(bool, abi.ChainEpoch, error) {},

api/test/window_post.go

@@ -3,22 +3,18 @@ package test
 import (
 	"context"
 	"fmt"
-	"sort"
 	"sync/atomic"
 
 	"strings"
 	"testing"
 	"time"
 
-	"github.com/stretchr/testify/assert"
 	"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/network"
 	"github.com/filecoin-project/lotus/extern/sector-storage/mock"
 	sealing "github.com/filecoin-project/lotus/extern/storage-sealing"
-	"github.com/filecoin-project/specs-storage/storage"
 
 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/build"
@@ -27,90 +23,6 @@ import (
 	"github.com/filecoin-project/lotus/node/impl"
 )
 
-func TestSDRUpgrade(t *testing.T, b APIBuilder, blocktime time.Duration) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	n, sn := b(t, []FullNodeOpts{FullNodeWithSDRAt(500, 1000)}, OneMiner)
-	client := n[0].FullNode.(*impl.FullNodeAPI)
-	miner := sn[0]
-
-	addrinfo, err := client.NetAddrsListen(ctx)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if err := miner.NetConnect(ctx, addrinfo); err != nil {
-		t.Fatal(err)
-	}
-	build.Clock.Sleep(time.Second)
-
-	pledge := make(chan struct{})
-	mine := int64(1)
-	done := make(chan struct{})
-	go func() {
-		defer close(done)
-		round := 0
-		for atomic.LoadInt64(&mine) != 0 {
-			build.Clock.Sleep(blocktime)
-			if err := sn[0].MineOne(ctx, bminer.MineReq{Done: func(bool, abi.ChainEpoch, error) {
-
-			}}); err != nil {
-				t.Error(err)
-			}
-
-			// 3 sealing rounds: before, during after.
-			if round >= 3 {
-				continue
-			}
-
-			head, err := client.ChainHead(ctx)
-			assert.NoError(t, err)
-
-			// rounds happen every 100 blocks, with a 50 block offset.
-			if head.Height() >= abi.ChainEpoch(round*500+50) {
-				round++
-				pledge <- struct{}{}
-
-				ver, err := client.StateNetworkVersion(ctx, head.Key())
-				assert.NoError(t, err)
-				switch round {
-				case 1:
-					assert.Equal(t, network.Version6, ver)
-				case 2:
-					assert.Equal(t, network.Version7, ver)
-				case 3:
-					assert.Equal(t, network.Version8, ver)
-				}
-			}
-
-		}
-	}()
-
-	// before.
-	pledgeSectors(t, ctx, miner, 9, 0, pledge)
-
-	s, err := miner.SectorsList(ctx)
-	require.NoError(t, err)
-	sort.Slice(s, func(i, j int) bool {
-		return s[i] < s[j]
-	})
-
-	for i, id := range s {
-		info, err := miner.SectorsStatus(ctx, id, true)
-		require.NoError(t, err)
-		expectProof := abi.RegisteredSealProof_StackedDrg2KiBV1
-		if i >= 3 {
-			// after
-			expectProof = abi.RegisteredSealProof_StackedDrg2KiBV1_1
-		}
-		assert.Equal(t, expectProof, info.SealProof, "sector %d, id %d", i, id)
-	}
-
-	atomic.StoreInt64(&mine, 0)
-	<-done
-}
-
 func TestPledgeSector(t *testing.T, b APIBuilder, blocktime time.Duration, nSectors int) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
@@ -151,13 +63,11 @@ func TestPledgeSector(t *testing.T, b APIBuilder, blocktime time.Duration, nSect
 
 func pledgeSectors(t *testing.T, ctx context.Context, miner TestStorageNode, n, existing int, blockNotif <-chan struct{}) {
 	for i := 0; i < n; i++ {
-		if i%3 == 0 && blockNotif != nil {
-			<-blockNotif
-			log.Errorf("WAIT")
-		}
-		log.Errorf("PLEDGING %d", i)
 		err := miner.PledgeSector(ctx)
 		require.NoError(t, err)
+		if i%3 == 0 && blockNotif != nil {
+			<-blockNotif
+		}
 	}
 
 	for {
@@ -216,7 +126,7 @@ func testWindowPostUpgrade(t *testing.T, b APIBuilder, blocktime time.Duration,
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	n, sn := b(t, []FullNodeOpts{FullNodeWithActorsV2At(upgradeHeight)}, OneMiner)
+	n, sn := b(t, []FullNodeOpts{FullNodeWithUpgradeAt(upgradeHeight)}, OneMiner)
 
 	client := n[0].FullNode.(*impl.FullNodeAPI)
 	miner := sn[0]
@@ -299,17 +209,15 @@ func testWindowPostUpgrade(t *testing.T, b APIBuilder, blocktime time.Duration,
 
 		// Drop the partition
 		err = secs.ForEach(func(sid uint64) error {
-			return miner.StorageMiner.(*impl.StorageMinerAPI).IStorageMgr.(*mock.SectorMgr).MarkCorrupted(storage.SectorRef{
-				ID: abi.SectorID{
-					Miner:  abi.ActorID(mid),
-					Number: abi.SectorNumber(sid),
-				},
+			return miner.StorageMiner.(*impl.StorageMinerAPI).IStorageMgr.(*mock.SectorMgr).MarkCorrupted(abi.SectorID{
+				Miner:  abi.ActorID(mid),
+				Number: abi.SectorNumber(sid),
 			}, true)
 		})
 		require.NoError(t, err)
 	}
 
-	var s storage.SectorRef
+	var s abi.SectorID
 
 	// Drop 1 sectors from deadline 3 partition 0
 	{
@@ -330,11 +238,9 @@ func testWindowPostUpgrade(t *testing.T, b APIBuilder, blocktime time.Duration,
 		require.NoError(t, err)
 		fmt.Println("the sectors", all)
 
-		s = storage.SectorRef{
-			ID: abi.SectorID{
-				Miner:  abi.ActorID(mid),
-				Number: abi.SectorNumber(sn),
-			},
+		s = abi.SectorID{
+			Miner:  abi.ActorID(mid),
+			Number: abi.SectorNumber(sn),
 		}
 
 		err = miner.StorageMiner.(*impl.StorageMinerAPI).IStorageMgr.(*mock.SectorMgr).MarkFailed(s, true)

api/types.go

@@ -6,6 +6,7 @@ import (
 
 	datatransfer "github.com/filecoin-project/go-data-transfer"
 	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/lotus/build"
 	"github.com/ipfs/go-cid"
 
 	"github.com/libp2p/go-libp2p-core/peer"
@@ -50,6 +51,19 @@ type MessageSendSpec struct {
 	MaxFee abi.TokenAmount
 }
 
+var DefaultMessageSendSpec = MessageSendSpec{
+	// MaxFee of 0.1FIL
+	MaxFee: abi.NewTokenAmount(int64(build.FilecoinPrecision) / 10),
+}
+
+func (ms *MessageSendSpec) Get() MessageSendSpec {
+	if ms == nil {
+		return DefaultMessageSendSpec
+	}
+
+	return *ms
+}
+
 type DataTransferChannel struct {
 	TransferID  datatransfer.TransferID
 	Status      datatransfer.Status
@@ -93,9 +107,3 @@ func NewDataTransferChannel(hostID peer.ID, channelState datatransfer.ChannelSta
 	}
 	return channel
 }
-
-type NetBlockList struct {
-	Peers     []peer.ID
-	IPAddrs   []string
-	IPSubnets []string
-}

build/bootstrap/bootstrappers.pi

@@ -1,15 +1,4 @@
-/dns4/bootstrap-0.mainnet.filops.net/tcp/1347/p2p/12D3KooWCVe8MmsEMes2FzgTpt9fXtmCY7wrq91GRiaC8PHSCCBj
-/dns4/bootstrap-1.mainnet.filops.net/tcp/1347/p2p/12D3KooWCwevHg1yLCvktf2nvLu7L9894mcrJR4MsBCcm4syShVc
-/dns4/bootstrap-2.mainnet.filops.net/tcp/1347/p2p/12D3KooWEWVwHGn2yR36gKLozmb4YjDJGerotAPGxmdWZx2nxMC4
-/dns4/bootstrap-3.mainnet.filops.net/tcp/1347/p2p/12D3KooWKhgq8c7NQ9iGjbyK7v7phXvG6492HQfiDaGHLHLQjk7R
-/dns4/bootstrap-4.mainnet.filops.net/tcp/1347/p2p/12D3KooWL6PsFNPhYftrJzGgF5U18hFoaVhfGk7xwzD8yVrHJ3Uc
-/dns4/bootstrap-5.mainnet.filops.net/tcp/1347/p2p/12D3KooWLFynvDQiUpXoHroV1YxKHhPJgysQGH2k3ZGwtWzR4dFH
-/dns4/bootstrap-6.mainnet.filops.net/tcp/1347/p2p/12D3KooWP5MwCiqdMETF9ub1P3MbCvQCcfconnYHbWg6sUJcDRQQ
-/dns4/bootstrap-7.mainnet.filops.net/tcp/1347/p2p/12D3KooWRs3aY1p3juFjPy8gPN95PEQChm2QKGUCAdcDCC4EBMKf
-/dns4/bootstrap-8.mainnet.filops.net/tcp/1347/p2p/12D3KooWScFR7385LTyR4zU1bYdzSiiAb5rnNABfVahPvVSzyTkR
-/dns4/lotus-bootstrap.forceup.cn/tcp/41778/p2p/12D3KooWFQsv3nRMUevZNWWsY1Wu6NUzUbawnWU5NcRhgKuJA37C
-/dns4/bootstrap-0.starpool.in/tcp/12757/p2p/12D3KooWGHpBMeZbestVEWkfdnC9u7p6uFHXL1n7m1ZBqsEmiUzz
-/dns4/bootstrap-1.starpool.in/tcp/12757/p2p/12D3KooWQZrGH1PxSNZPum99M1zNvjNFM33d1AAu5DcvdHptuU7u
-/dns4/node.glif.io/tcp/1235/p2p/12D3KooWBF8cpp65hp2u9LK5mh19x67ftAam84z9LsfaquTDSBpt
-/dns4/bootstrap-0.ipfsmain.cn/tcp/34721/p2p/12D3KooWQnwEGNqcM2nAcPtRR9rAX8Hrg4k9kJLCHoTR5chJfz6d
-/dns4/bootstrap-1.ipfsmain.cn/tcp/34723/p2p/12D3KooWMKxMkD5DMpSWsW7dBddKxKT7L2GgbNuckz9otxvkvByP
+/dns4/bootstrap-0.calibration.fildev.network/tcp/1347/p2p/12D3KooWK1QYsm6iqyhgH7vqsbeoNoKHbT368h1JLHS1qYN36oyc
+/dns4/bootstrap-1.calibration.fildev.network/tcp/1347/p2p/12D3KooWKDyJZoPsNak1iYNN1GGmvGnvhyVbWBL6iusYfP3RpgYs
+/dns4/bootstrap-2.calibration.fildev.network/tcp/1347/p2p/12D3KooWJRSTnzABB6MYYEBbSTT52phQntVD1PpRTMh1xt9mh6yH
+/dns4/bootstrap-3.calibration.fildev.network/tcp/1347/p2p/12D3KooWQLi3kY6HnMYLUtwCe26zWMdNhniFgHVNn1DioQc7NiWv

build/params_2k.go

@@ -22,9 +22,6 @@ var UpgradeActorsV2Height = abi.ChainEpoch(10)
 var UpgradeLiftoffHeight = abi.ChainEpoch(-5)
 
 const UpgradeKumquatHeight = 15
-const UpgradeCalicoHeight = 20
-const UpgradePersianHeight = 25
-const UpgradeClausHeight = 30
 
 var DrandSchedule = map[abi.ChainEpoch]DrandEnum{
 	0: DrandMainnet,

build/params_mainnet.go

@@ -5,9 +5,6 @@
 package build
 
 import (
-	"math"
-	"os"
-
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/lotus/chain/actors/policy"
@@ -15,52 +12,43 @@ import (
 )
 
 var DrandSchedule = map[abi.ChainEpoch]DrandEnum{
-	0:                  DrandIncentinet,
-	UpgradeSmokeHeight: DrandMainnet,
+	0: DrandMainnet,
 }
 
-const UpgradeBreezeHeight = 41280
+const UpgradeBreezeHeight = -1
 const BreezeGasTampingDuration = 120
 
-const UpgradeSmokeHeight = 51000
+const UpgradeSmokeHeight = -2
 
-const UpgradeIgnitionHeight = 94000
-const UpgradeRefuelHeight = 130800
+const UpgradeIgnitionHeight = -3
+const UpgradeRefuelHeight = -4
 
-var UpgradeActorsV2Height = abi.ChainEpoch(138720)
+var UpgradeActorsV2Height = abi.ChainEpoch(30)
 
-const UpgradeTapeHeight = 140760
+const UpgradeTapeHeight = 60
 
 // This signals our tentative epoch for mainnet launch. Can make it later, but not earlier.
 // Miners, clients, developers, custodians all need time to prepare.
 // We still have upgrades and state changes to do, but can happen after signaling timing here.
-const UpgradeLiftoffHeight = 148888
+const UpgradeLiftoffHeight = -5
 
-const UpgradeKumquatHeight = 170000
-
-const UpgradeCalicoHeight = 265200
-const UpgradePersianHeight = UpgradeCalicoHeight + (builtin2.EpochsInHour * 60)
-
-// 2020-12-22T02:00:00Z
-const UpgradeClausHeight = 343200
+const UpgradeKumquatHeight = 90
 
 func init() {
-	policy.SetConsensusMinerMinPower(abi.NewStoragePower(10 << 40))
+	policy.SetConsensusMinerMinPower(abi.NewStoragePower(10 << 30))
+	policy.SetSupportedProofTypes(
+		abi.RegisteredSealProof_StackedDrg512MiBV1,
+		abi.RegisteredSealProof_StackedDrg32GiBV1,
+		abi.RegisteredSealProof_StackedDrg64GiBV1,
+	)
 
-	if os.Getenv("LOTUS_USE_TEST_ADDRESSES") != "1" {
-		SetAddressNetwork(address.Mainnet)
-	}
+	SetAddressNetwork(address.Testnet)
 
-	if os.Getenv("LOTUS_DISABLE_V2_ACTOR_MIGRATION") == "1" {
-		UpgradeActorsV2Height = math.MaxInt64
-	}
-
-	Devnet = false
+	Devnet = true
 }
 
 const BlockDelaySecs = uint64(builtin2.EpochDurationSeconds)
 
 const PropagationDelaySecs = uint64(6)
 
-// BootstrapPeerThreshold is the minimum number peers we need to track for a sync worker to start
 const BootstrapPeerThreshold = 4

build/params_shared_funcs.go

@@ -19,12 +19,3 @@ func DhtProtocolName(netName dtypes.NetworkName) protocol.ID {
 func SetAddressNetwork(n address.Network) {
 	address.CurrentNetwork = n
 }
-
-func MustParseAddress(addr string) address.Address {
-	ret, err := address.NewFromString(addr)
-	if err != nil {
-		panic(err)
-	}
-
-	return ret
-}

build/params_shared_vals.go

@@ -25,7 +25,7 @@ const UnixfsLinksPerLevel = 1024
 // Consensus / Network
 
 const AllowableClockDriftSecs = uint64(1)
-const NewestNetworkVersion = network.Version8
+const NewestNetworkVersion = network.Version6
 const ActorUpgradeNetworkVersion = network.Version4
 
 // Epochs
@@ -61,9 +61,6 @@ const TicketRandomnessLookback = abi.ChainEpoch(1)
 
 const AddressMainnetEnvVar = "_mainnet_"
 
-// the 'f' prefix doesn't matter
-var ZeroAddress = MustParseAddress("f3yaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaby2smx7a")
-
 // /////
 // Devnet settings
 

build/params_testground.go

@@ -88,19 +88,15 @@ var (
 	UpgradeActorsV2Height abi.ChainEpoch = 10
 	UpgradeLiftoffHeight  abi.ChainEpoch = -5
 	UpgradeKumquatHeight  abi.ChainEpoch = -6
-	UpgradeCalicoHeight   abi.ChainEpoch = -7
-	UpgradePersianHeight  abi.ChainEpoch = -8
-	UpgradeClausHeight    abi.ChainEpoch = -9
 
 	DrandSchedule = map[abi.ChainEpoch]DrandEnum{
 		0: DrandMainnet,
 	}
 
-	NewestNetworkVersion       = network.Version8
+	NewestNetworkVersion       = network.Version5
 	ActorUpgradeNetworkVersion = network.Version4
 
-	Devnet      = true
-	ZeroAddress = MustParseAddress("f3yaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaby2smx7a")
+	Devnet = true
 )
 
 const BootstrapPeerThreshold = 1

build/version.go

@@ -29,7 +29,7 @@ func buildType() string {
 }
 
 // BuildVersion is the local build version, set by build system
-const BuildVersion = "1.2.3"
+const BuildVersion = "1.1.3"
 
 func UserVersion() string {
 	return BuildVersion + buildType() + CurrentCommit
@@ -83,9 +83,9 @@ func VersionForType(nodeType NodeType) (Version, error) {
 
 // semver versions of the rpc api exposed
 var (
-	FullAPIVersion   = newVer(1, 0, 0)
-	MinerAPIVersion  = newVer(1, 0, 0)
-	WorkerAPIVersion = newVer(1, 0, 0)
+	FullAPIVersion   = newVer(0, 17, 0)
+	MinerAPIVersion  = newVer(0, 17, 0)
+	WorkerAPIVersion = newVer(0, 16, 0)
 )
 
 //nolint:varcheck,deadcode

chain/actors/builtin/init/diff.go

@@ -1,152 +0,0 @@
-package init
-
-import (
-	"bytes"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-state-types/abi"
-	typegen "github.com/whyrusleeping/cbor-gen"
-
-	"github.com/filecoin-project/lotus/chain/actors/adt"
-)
-
-func DiffAddressMap(pre, cur State) (*AddressMapChanges, error) {
-	prem, err := pre.addressMap()
-	if err != nil {
-		return nil, err
-	}
-
-	curm, err := cur.addressMap()
-	if err != nil {
-		return nil, err
-	}
-
-	preRoot, err := prem.Root()
-	if err != nil {
-		return nil, err
-	}
-
-	curRoot, err := curm.Root()
-	if err != nil {
-		return nil, err
-	}
-
-	results := new(AddressMapChanges)
-	// no change.
-	if curRoot.Equals(preRoot) {
-		return results, nil
-	}
-
-	err = adt.DiffAdtMap(prem, curm, &addressMapDiffer{results, pre, cur})
-	if err != nil {
-		return nil, err
-	}
-
-	return results, nil
-}
-
-type addressMapDiffer struct {
-	Results    *AddressMapChanges
-	pre, adter State
-}
-
-type AddressMapChanges struct {
-	Added    []AddressPair
-	Modified []AddressChange
-	Removed  []AddressPair
-}
-
-func (i *addressMapDiffer) AsKey(key string) (abi.Keyer, error) {
-	addr, err := address.NewFromBytes([]byte(key))
-	if err != nil {
-		return nil, err
-	}
-	return abi.AddrKey(addr), nil
-}
-
-func (i *addressMapDiffer) Add(key string, val *typegen.Deferred) error {
-	pkAddr, err := address.NewFromBytes([]byte(key))
-	if err != nil {
-		return err
-	}
-	id := new(typegen.CborInt)
-	if err := id.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil {
-		return err
-	}
-	idAddr, err := address.NewIDAddress(uint64(*id))
-	if err != nil {
-		return err
-	}
-	i.Results.Added = append(i.Results.Added, AddressPair{
-		ID: idAddr,
-		PK: pkAddr,
-	})
-	return nil
-}
-
-func (i *addressMapDiffer) Modify(key string, from, to *typegen.Deferred) error {
-	pkAddr, err := address.NewFromBytes([]byte(key))
-	if err != nil {
-		return err
-	}
-
-	fromID := new(typegen.CborInt)
-	if err := fromID.UnmarshalCBOR(bytes.NewReader(from.Raw)); err != nil {
-		return err
-	}
-	fromIDAddr, err := address.NewIDAddress(uint64(*fromID))
-	if err != nil {
-		return err
-	}
-
-	toID := new(typegen.CborInt)
-	if err := toID.UnmarshalCBOR(bytes.NewReader(to.Raw)); err != nil {
-		return err
-	}
-	toIDAddr, err := address.NewIDAddress(uint64(*toID))
-	if err != nil {
-		return err
-	}
-
-	i.Results.Modified = append(i.Results.Modified, AddressChange{
-		From: AddressPair{
-			ID: fromIDAddr,
-			PK: pkAddr,
-		},
-		To: AddressPair{
-			ID: toIDAddr,
-			PK: pkAddr,
-		},
-	})
-	return nil
-}
-
-func (i *addressMapDiffer) Remove(key string, val *typegen.Deferred) error {
-	pkAddr, err := address.NewFromBytes([]byte(key))
-	if err != nil {
-		return err
-	}
-	id := new(typegen.CborInt)
-	if err := id.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil {
-		return err
-	}
-	idAddr, err := address.NewIDAddress(uint64(*id))
-	if err != nil {
-		return err
-	}
-	i.Results.Removed = append(i.Results.Removed, AddressPair{
-		ID: idAddr,
-		PK: pkAddr,
-	})
-	return nil
-}
-
-type AddressChange struct {
-	From AddressPair
-	To   AddressPair
-}
-
-type AddressPair struct {
-	ID address.Address
-	PK address.Address
-}

chain/actors/builtin/init/init.go

@@ -57,6 +57,4 @@ type State interface {
 
 	// Sets the network's name. This should only be used on upgrade/fork.
 	SetNetworkName(name string) error
-
-	addressMap() (adt.Map, error)
 }

chain/actors/builtin/init/v0.go

@@ -79,7 +79,3 @@ func (s *state0) Remove(addrs ...address.Address) (err error) {
 	s.State.AddressMap = amr
 	return nil
 }
-
-func (s *state0) addressMap() (adt.Map, error) {
-	return adt0.AsMap(s.store, s.AddressMap)
-}

chain/actors/builtin/init/v2.go

@@ -79,7 +79,3 @@ func (s *state2) Remove(addrs ...address.Address) (err error) {
 	s.State.AddressMap = amr
 	return nil
 }
-
-func (s *state2) addressMap() (adt.Map, error) {
-	return adt2.AsMap(s.store, s.AddressMap)
-}

chain/actors/builtin/miner/utils.go

@@ -4,8 +4,6 @@ import (
 	"golang.org/x/xerrors"
 
 	"github.com/filecoin-project/go-bitfield"
-	"github.com/filecoin-project/go-state-types/abi"
-	"github.com/filecoin-project/go-state-types/network"
 )
 
 func AllPartSectors(mas State, sget func(Partition) (bitfield.BitField, error)) (bitfield.BitField, error) {
@@ -28,42 +26,3 @@ func AllPartSectors(mas State, sget func(Partition) (bitfield.BitField, error))
 
 	return bitfield.MultiMerge(parts...)
 }
-
-// SealProofTypeFromSectorSize returns preferred seal proof type for creating
-// new miner actors and new sectors
-func SealProofTypeFromSectorSize(ssize abi.SectorSize, nv network.Version) (abi.RegisteredSealProof, error) {
-	switch {
-	case nv < network.Version7:
-		switch ssize {
-		case 2 << 10:
-			return abi.RegisteredSealProof_StackedDrg2KiBV1, nil
-		case 8 << 20:
-			return abi.RegisteredSealProof_StackedDrg8MiBV1, nil
-		case 512 << 20:
-			return abi.RegisteredSealProof_StackedDrg512MiBV1, nil
-		case 32 << 30:
-			return abi.RegisteredSealProof_StackedDrg32GiBV1, nil
-		case 64 << 30:
-			return abi.RegisteredSealProof_StackedDrg64GiBV1, nil
-		default:
-			return 0, xerrors.Errorf("unsupported sector size for miner: %v", ssize)
-		}
-	case nv >= network.Version7:
-		switch ssize {
-		case 2 << 10:
-			return abi.RegisteredSealProof_StackedDrg2KiBV1_1, nil
-		case 8 << 20:
-			return abi.RegisteredSealProof_StackedDrg8MiBV1_1, nil
-		case 512 << 20:
-			return abi.RegisteredSealProof_StackedDrg512MiBV1_1, nil
-		case 32 << 30:
-			return abi.RegisteredSealProof_StackedDrg32GiBV1_1, nil
-		case 64 << 30:
-			return abi.RegisteredSealProof_StackedDrg64GiBV1_1, nil
-		default:
-			return 0, xerrors.Errorf("unsupported sector size for miner: %v", ssize)
-		}
-	}
-
-	return 0, xerrors.Errorf("unsupported network version")
-}

chain/actors/params.go

@@ -3,8 +3,6 @@ package actors
 import (
 	"bytes"
 
-	"github.com/filecoin-project/go-state-types/exitcode"
-
 	"github.com/filecoin-project/lotus/chain/actors/aerrors"
 	cbg "github.com/whyrusleeping/cbor-gen"
 )
@@ -13,7 +11,7 @@ func SerializeParams(i cbg.CBORMarshaler) ([]byte, aerrors.ActorError) {
 	buf := new(bytes.Buffer)
 	if err := i.MarshalCBOR(buf); err != nil {
 		// TODO: shouldnt this be a fatal error?
-		return nil, aerrors.Absorb(err, exitcode.ErrSerialization, "failed to encode parameter")
+		return nil, aerrors.Absorb(err, 1, "failed to encode parameter")
 	}
 	return buf.Bytes(), nil
 }

chain/actors/policy/policy.go

@@ -26,29 +26,22 @@ const (
 // SetSupportedProofTypes sets supported proof types, across all actor versions.
 // This should only be used for testing.
 func SetSupportedProofTypes(types ...abi.RegisteredSealProof) {
-	miner0.SupportedProofTypes = make(map[abi.RegisteredSealProof]struct{}, len(types))
-	miner2.PreCommitSealProofTypesV0 = make(map[abi.RegisteredSealProof]struct{}, len(types))
-	miner2.PreCommitSealProofTypesV7 = make(map[abi.RegisteredSealProof]struct{}, len(types)*2)
-	miner2.PreCommitSealProofTypesV8 = make(map[abi.RegisteredSealProof]struct{}, len(types))
-
-	AddSupportedProofTypes(types...)
+	newTypes := make(map[abi.RegisteredSealProof]struct{}, len(types))
+	for _, t := range types {
+		newTypes[t] = struct{}{}
+	}
+	// Set for all miner versions.
+	miner0.SupportedProofTypes = newTypes
+	miner2.SupportedProofTypes = newTypes
 }
 
 // AddSupportedProofTypes sets supported proof types, across all actor versions.
 // This should only be used for testing.
 func AddSupportedProofTypes(types ...abi.RegisteredSealProof) {
 	for _, t := range types {
-		if t >= abi.RegisteredSealProof_StackedDrg2KiBV1_1 {
-			panic("must specify v1 proof types only")
-		}
 		// Set for all miner versions.
 		miner0.SupportedProofTypes[t] = struct{}{}
-		miner2.PreCommitSealProofTypesV0[t] = struct{}{}
-
-		miner2.PreCommitSealProofTypesV7[t] = struct{}{}
-		miner2.PreCommitSealProofTypesV7[t+abi.RegisteredSealProof_StackedDrg2KiBV1_1] = struct{}{}
-
-		miner2.PreCommitSealProofTypesV8[t+abi.RegisteredSealProof_StackedDrg2KiBV1_1] = struct{}{}
+		miner2.SupportedProofTypes[t] = struct{}{}
 	}
 }
 
@@ -140,9 +133,9 @@ func GetMaxPoStPartitions(p abi.RegisteredPoStProof) (int, error) {
 }
 
 func GetDefaultSectorSize() abi.SectorSize {
-	// supported sector sizes are the same across versions.
-	szs := make([]abi.SectorSize, 0, len(miner2.PreCommitSealProofTypesV8))
-	for spt := range miner2.PreCommitSealProofTypesV8 {
+	// supported proof types are the same across versions.
+	szs := make([]abi.SectorSize, 0, len(miner2.SupportedProofTypes))
+	for spt := range miner2.SupportedProofTypes {
 		ss, err := spt.SectorSize()
 		if err != nil {
 			panic(err)

chain/actors/policy/policy_test.go

@@ -44,7 +44,7 @@ func TestSupportedProofTypes(t *testing.T) {
 
 // Tests assumptions about policies being the same between actor versions.
 func TestAssumptions(t *testing.T) {
-	require.EqualValues(t, miner0.SupportedProofTypes, miner2.PreCommitSealProofTypesV0)
+	require.EqualValues(t, miner0.SupportedProofTypes, miner2.SupportedProofTypes)
 	require.Equal(t, miner0.PreCommitChallengeDelay, miner2.PreCommitChallengeDelay)
 	require.Equal(t, miner0.MaxSectorExpirationExtension, miner2.MaxSectorExpirationExtension)
 	require.Equal(t, miner0.ChainFinality, miner2.ChainFinality)
@@ -57,10 +57,10 @@ func TestAssumptions(t *testing.T) {
 }
 
 func TestPartitionSizes(t *testing.T) {
-	for _, p := range abi.SealProofInfos {
-		sizeNew, err := builtin2.PoStProofWindowPoStPartitionSectors(p.WindowPoStProof)
+	for p := range abi.PoStSealProofTypes {
+		sizeNew, err := builtin2.PoStProofWindowPoStPartitionSectors(p)
 		require.NoError(t, err)
-		sizeOld, err := builtin0.PoStProofWindowPoStPartitionSectors(p.WindowPoStProof)
+		sizeOld, err := builtin0.PoStProofWindowPoStPartitionSectors(p)
 		if err != nil {
 			// new proof type.
 			continue

chain/actors/version.go

@@ -18,7 +18,7 @@ func VersionForNetwork(version network.Version) Version {
 	switch version {
 	case network.Version0, network.Version1, network.Version2, network.Version3:
 		return Version0
-	case network.Version4, network.Version5, network.Version6, network.Version7, network.Version8:
+	case network.Version4, network.Version5, network.Version6:
 		return Version2
 	default:
 		panic(fmt.Sprintf("unsupported network version %d", version))

chain/events/events.go

@@ -20,10 +20,8 @@ import (
 var log = logging.Logger("events")
 
 // HeightHandler `curH`-`ts.Height` = `confidence`
-type (
-	HeightHandler func(ctx context.Context, ts *types.TipSet, curH abi.ChainEpoch) error
-	RevertHandler func(ctx context.Context, ts *types.TipSet) error
-)
+type HeightHandler func(ctx context.Context, ts *types.TipSet, curH abi.ChainEpoch) error
+type RevertHandler func(ctx context.Context, ts *types.TipSet) error
 
 type heightHandler struct {
 	confidence int
@@ -50,7 +48,7 @@ type Events struct {
 	tsc *tipSetCache
 	lk  sync.Mutex
 
-	ready     chan struct{}
+	ready     sync.WaitGroup
 	readyOnce sync.Once
 
 	heightEvents
@@ -78,16 +76,15 @@ func NewEvents(ctx context.Context, api eventAPI) *Events {
 		},
 
 		hcEvents: newHCEvents(ctx, api, tsc, uint64(gcConfidence)),
-		ready:    make(chan struct{}),
 	}
 
+	e.ready.Add(1)
+
 	go e.listenHeadChanges(ctx)
 
-	// Wait for the first tipset to be seen or bail if shutting down
-	select {
-	case <-e.ready:
-	case <-ctx.Done():
-	}
+	e.ready.Wait()
+
+	// TODO: cleanup/gc goroutine
 
 	return e
 }
@@ -114,21 +111,13 @@ func (e *Events) listenHeadChangesOnce(ctx context.Context) error {
 
 	notifs, err := e.api.ChainNotify(ctx)
 	if err != nil {
-		// Retry is handled by caller
+		// TODO: retry
 		return xerrors.Errorf("listenHeadChanges ChainNotify call failed: %w", err)
 	}
 
-	var cur []*api.HeadChange
-	var ok bool
-
-	// Wait for first tipset or bail
-	select {
-	case cur, ok = <-notifs:
-		if !ok {
-			return xerrors.Errorf("notification channel closed")
-		}
-	case <-ctx.Done():
-		return ctx.Err()
+	cur, ok := <-notifs // TODO: timeout?
+	if !ok {
+		return xerrors.Errorf("notification channel closed")
 	}
 
 	if len(cur) != 1 {
@@ -140,13 +129,13 @@ func (e *Events) listenHeadChangesOnce(ctx context.Context) error {
 	}
 
 	if err := e.tsc.add(cur[0].Val); err != nil {
-		log.Warnf("tsc.add: adding current tipset failed: %v", err)
+		log.Warn("tsc.add: adding current tipset failed: %w", err)
 	}
 
 	e.readyOnce.Do(func() {
 		e.lastTs = cur[0].Val
-		// Signal that we have seen first tipset
-		close(e.ready)
+
+		e.ready.Done()
 	})
 
 	for notif := range notifs {

chain/events/events_height.go

@@ -153,7 +153,6 @@ func (e *heightEvents) ChainAt(hnd HeightHandler, rev RevertHandler, confidence
 
 	best, err := e.tsc.best()
 	if err != nil {
-		e.lk.Unlock()
 		return xerrors.Errorf("error getting best tipset: %w", err)
 	}
 
@@ -178,7 +177,6 @@ func (e *heightEvents) ChainAt(hnd HeightHandler, rev RevertHandler, confidence
 		e.lk.Lock()
 		best, err = e.tsc.best()
 		if err != nil {
-			e.lk.Unlock()
 			return xerrors.Errorf("error getting best tipset: %w", err)
 		}
 		bestH = best.Height()

chain/events/state/predicates.go

@@ -1,6 +1,7 @@
 package state
 
 import (
+	"bytes"
 	"context"
 
 	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
@@ -9,6 +10,7 @@ import (
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/big"
 	cbor "github.com/ipfs/go-ipld-cbor"
+	typegen "github.com/whyrusleeping/cbor-gen"
 
 	"github.com/filecoin-project/lotus/api/apibstore"
 	"github.com/filecoin-project/lotus/chain/actors/adt"
@@ -417,17 +419,179 @@ type AddressPair struct {
 	PK address.Address
 }
 
+type InitActorAddressChanges struct {
+	Added    []AddressPair
+	Modified []AddressChange
+	Removed  []AddressPair
+}
+
+type AddressChange struct {
+	From AddressPair
+	To   AddressPair
+}
+
 type DiffInitActorStateFunc func(ctx context.Context, oldState init_.State, newState init_.State) (changed bool, user UserData, err error)
 
+func (i *InitActorAddressChanges) AsKey(key string) (abi.Keyer, error) {
+	addr, err := address.NewFromBytes([]byte(key))
+	if err != nil {
+		return nil, err
+	}
+	return abi.AddrKey(addr), nil
+}
+
+func (i *InitActorAddressChanges) Add(key string, val *typegen.Deferred) error {
+	pkAddr, err := address.NewFromBytes([]byte(key))
+	if err != nil {
+		return err
+	}
+	id := new(typegen.CborInt)
+	if err := id.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil {
+		return err
+	}
+	idAddr, err := address.NewIDAddress(uint64(*id))
+	if err != nil {
+		return err
+	}
+	i.Added = append(i.Added, AddressPair{
+		ID: idAddr,
+		PK: pkAddr,
+	})
+	return nil
+}
+
+func (i *InitActorAddressChanges) Modify(key string, from, to *typegen.Deferred) error {
+	pkAddr, err := address.NewFromBytes([]byte(key))
+	if err != nil {
+		return err
+	}
+
+	fromID := new(typegen.CborInt)
+	if err := fromID.UnmarshalCBOR(bytes.NewReader(from.Raw)); err != nil {
+		return err
+	}
+	fromIDAddr, err := address.NewIDAddress(uint64(*fromID))
+	if err != nil {
+		return err
+	}
+
+	toID := new(typegen.CborInt)
+	if err := toID.UnmarshalCBOR(bytes.NewReader(to.Raw)); err != nil {
+		return err
+	}
+	toIDAddr, err := address.NewIDAddress(uint64(*toID))
+	if err != nil {
+		return err
+	}
+
+	i.Modified = append(i.Modified, AddressChange{
+		From: AddressPair{
+			ID: fromIDAddr,
+			PK: pkAddr,
+		},
+		To: AddressPair{
+			ID: toIDAddr,
+			PK: pkAddr,
+		},
+	})
+	return nil
+}
+
+func (i *InitActorAddressChanges) Remove(key string, val *typegen.Deferred) error {
+	pkAddr, err := address.NewFromBytes([]byte(key))
+	if err != nil {
+		return err
+	}
+	id := new(typegen.CborInt)
+	if err := id.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil {
+		return err
+	}
+	idAddr, err := address.NewIDAddress(uint64(*id))
+	if err != nil {
+		return err
+	}
+	i.Removed = append(i.Removed, AddressPair{
+		ID: idAddr,
+		PK: pkAddr,
+	})
+	return nil
+}
+
 func (sp *StatePredicates) OnAddressMapChange() DiffInitActorStateFunc {
 	return func(ctx context.Context, oldState, newState init_.State) (changed bool, user UserData, err error) {
-		addressChanges, err := init_.DiffAddressMap(oldState, newState)
+		addressChanges := &InitActorAddressChanges{
+			Added:    []AddressPair{},
+			Modified: []AddressChange{},
+			Removed:  []AddressPair{},
+		}
+
+		err = oldState.ForEachActor(func(oldId abi.ActorID, oldAddress address.Address) error {
+			oldIdAddress, err := address.NewIDAddress(uint64(oldId))
+			if err != nil {
+				return err
+			}
+
+			newIdAddress, found, err := newState.ResolveAddress(oldAddress)
+			if err != nil {
+				return err
+			}
+
+			if !found {
+				addressChanges.Removed = append(addressChanges.Removed, AddressPair{
+					ID: oldIdAddress,
+					PK: oldAddress,
+				})
+			}
+
+			if oldIdAddress != newIdAddress {
+				addressChanges.Modified = append(addressChanges.Modified, AddressChange{
+					From: AddressPair{
+						ID: oldIdAddress,
+						PK: oldAddress,
+					},
+					To: AddressPair{
+						ID: newIdAddress,
+						PK: oldAddress,
+					},
+				})
+			}
+
+			return nil
+		})
+
 		if err != nil {
 			return false, nil, err
 		}
-		if len(addressChanges.Added)+len(addressChanges.Modified)+len(addressChanges.Removed) == 0 {
+
+		err = newState.ForEachActor(func(newId abi.ActorID, newAddress address.Address) error {
+			newIdAddress, err := address.NewIDAddress(uint64(newId))
+			if err != nil {
+				return err
+			}
+
+			_, found, err := newState.ResolveAddress(newAddress)
+			if err != nil {
+				return err
+			}
+
+			if !found {
+				addressChanges.Added = append(addressChanges.Added, AddressPair{
+					ID: newIdAddress,
+					PK: newAddress,
+				})
+			}
+
+			return nil
+		})
+
+		if err != nil {
+			return false, nil, err
+		}
+
+		if len(addressChanges.Added)+len(addressChanges.Removed)+len(addressChanges.Modified) == 0 {
 			return false, nil, nil
 		}
+
 		return true, addressChanges, nil
 	}
 }

chain/exchange/peer_tracker.go

@@ -38,26 +38,20 @@ func newPeerTracker(lc fx.Lifecycle, h host.Host, pmgr *peermgr.PeerMgr) *bsPeer
 		pmgr:  pmgr,
 	}
 
-	evtSub, err := h.EventBus().Subscribe(new(peermgr.FilPeerEvt))
+	sub, err := h.EventBus().Subscribe(new(peermgr.NewFilPeer))
 	if err != nil {
 		panic(err)
 	}
 
 	go func() {
-		for evt := range evtSub.Out() {
-			pEvt := evt.(peermgr.FilPeerEvt)
-			switch pEvt.Type {
-			case peermgr.AddFilPeerEvt:
-				bsPt.addPeer(pEvt.ID)
-			case peermgr.RemoveFilPeerEvt:
-				bsPt.removePeer(pEvt.ID)
-			}
+		for newPeer := range sub.Out() {
+			bsPt.addPeer(newPeer.(peermgr.NewFilPeer).Id)
 		}
 	}()
 
 	lc.Append(fx.Hook{
 		OnStop: func(ctx context.Context) error {
-			return evtSub.Close()
+			return sub.Close()
 		},
 	})
 

chain/gen/gen.go

@@ -347,8 +347,14 @@ func (cg *ChainGen) nextBlockProof(ctx context.Context, pts *types.TipSet, m add
 		return nil, nil, nil, xerrors.Errorf("get miner base info: %w", err)
 	}
 
-	entries := mbi.BeaconEntries
-	rbase := mbi.PrevBeaconEntry
+	prev := mbi.PrevBeaconEntry
+
+	entries, err := beacon.BeaconEntriesForBlock(ctx, cg.beacon, round, pts.Height(), prev)
+	if err != nil {
+		return nil, nil, nil, xerrors.Errorf("get beacon entries for block: %w", err)
+	}
+
+	rbase := prev
 	if len(entries) > 0 {
 		rbase = entries[len(entries)-1]
 	}

chain/gen/genesis/f01_init.go

@@ -21,7 +21,7 @@ import (
 	bstore "github.com/filecoin-project/lotus/lib/blockstore"
 )
 
-func SetupInitActor(bs bstore.Blockstore, netname string, initialActors []genesis.Actor, rootVerifier genesis.Actor, remainder genesis.Actor) (int64, *types.Actor, map[address.Address]address.Address, error) {
+func SetupInitActor(bs bstore.Blockstore, netname string, initialActors []genesis.Actor, rootVerifier genesis.Actor) (int64, *types.Actor, map[address.Address]address.Address, error) {
 	if len(initialActors) > MaxAccounts {
 		return 0, nil, nil, xerrors.New("too many initial actors")
 	}
@@ -90,33 +90,6 @@ func SetupInitActor(bs bstore.Blockstore, netname string, initialActors []genesi
 		}
 	}
 
-	setupMsig := func(meta json.RawMessage) error {
-		var ainfo genesis.MultisigMeta
-		if err := json.Unmarshal(meta, &ainfo); err != nil {
-			return xerrors.Errorf("unmarshaling account meta: %w", err)
-		}
-		for _, e := range ainfo.Signers {
-			if _, ok := keyToId[e]; ok {
-				continue
-			}
-			fmt.Printf("init set %s t0%d\n", e, counter)
-
-			value := cbg.CborInt(counter)
-			if err := amap.Put(abi.AddrKey(e), &value); err != nil {
-				return err
-			}
-			counter = counter + 1
-			var err error
-			keyToId[e], err = address.NewIDAddress(uint64(value))
-			if err != nil {
-				return err
-			}
-
-		}
-
-		return nil
-	}
-
 	if rootVerifier.Type == genesis.TAccount {
 		var ainfo genesis.AccountMeta
 		if err := json.Unmarshal(rootVerifier.Meta, &ainfo); err != nil {
@@ -127,15 +100,28 @@ func SetupInitActor(bs bstore.Blockstore, netname string, initialActors []genesi
 			return 0, nil, nil, err
 		}
 	} else if rootVerifier.Type == genesis.TMultisig {
-		err := setupMsig(rootVerifier.Meta)
-		if err != nil {
-			return 0, nil, nil, xerrors.Errorf("setting up root verifier msig: %w", err)
+		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)
 
-	err := setupMsig(remainder.Meta)
-	if err != nil {
-		return 0, nil, nil, xerrors.Errorf("setting up remainder msig: %w", err)
+			value := cbg.CborInt(counter)
+			if err := amap.Put(abi.AddrKey(e), &value); err != nil {
+				return 0, nil, nil, err
+			}
+			counter = counter + 1
+			var err error
+			keyToId[e], err = address.NewIDAddress(uint64(value))
+			if err != nil {
+				return 0, nil, nil, err
+			}
+
+		}
 	}
 
 	amapaddr, err := amap.Root()

chain/gen/genesis/genesis.go

@@ -134,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, template.RemainderAccount)
+	idStart, initact, keyIDs, err := SetupInitActor(bs, template.NetworkName, template.Accounts, template.VerifregRootKey)
 	if err != nil {
 		return nil, nil, xerrors.Errorf("setup init actor: %w", err)
 	}

chain/gen/genesis/miners.go

@@ -23,6 +23,8 @@ import (
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/big"
 	"github.com/filecoin-project/go-state-types/crypto"
+	"github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper"
+
 	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
 	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
 	power0 "github.com/filecoin-project/specs-actors/actors/builtin/power"
@@ -99,7 +101,7 @@ func SetupStorageMiners(ctx context.Context, cs *store.ChainStore, sroot cid.Cid
 		i := i
 		m := m
 
-		spt, err := miner.SealProofTypeFromSectorSize(m.SectorSize, GenesisNetworkVersion)
+		spt, err := ffiwrapper.SealProofTypeFromSectorSize(m.SectorSize)
 		if err != nil {
 			return cid.Undef, err
 		}

chain/messagepool/messagepool.go

@@ -181,20 +181,7 @@ func ComputeMinRBF(curPrem abi.TokenAmount) abi.TokenAmount {
 	return types.BigAdd(minPrice, types.NewInt(1))
 }
 
-func CapGasFee(mff dtypes.DefaultMaxFeeFunc, msg *types.Message, sendSepc *api.MessageSendSpec) {
-	var maxFee abi.TokenAmount
-	if sendSepc != nil {
-		maxFee = sendSepc.MaxFee
-	}
-	if maxFee.Int == nil || maxFee.Equals(big.Zero()) {
-		mf, err := mff()
-		if err != nil {
-			log.Errorf("failed to get default max gas fee: %+v", err)
-			mf = big.Zero()
-		}
-		maxFee = mf
-	}
-
+func CapGasFee(mff dtypes.DefaultMaxFeeFunc, msg *types.Message, maxFee abi.TokenAmount) {
 	if maxFee.Equals(big.Zero()) {
 		mf, err := mff()
 		if err != nil {
@@ -253,13 +240,10 @@ func (ms *msgSet) add(m *types.SignedMessage, mp *MessagePool, strict, untrusted
 			// check if RBF passes
 			minPrice := ComputeMinRBF(exms.Message.GasPremium)
 			if types.BigCmp(m.Message.GasPremium, minPrice) >= 0 {
-				log.Debugw("add with RBF", "oldpremium", exms.Message.GasPremium,
+				log.Infow("add with RBF", "oldpremium", exms.Message.GasPremium,
 					"newpremium", m.Message.GasPremium, "addr", m.Message.From, "nonce", m.Message.Nonce)
 			} else {
-				log.Debugf("add with duplicate nonce. message from %s with nonce %d already in mpool,"+
-					" increase GasPremium to %s from %s to trigger replace by fee: %s",
-					m.Message.From, m.Message.Nonce, minPrice, m.Message.GasPremium,
-					ErrRBFTooLowPremium)
+				log.Info("add with duplicate nonce")
 				return false, xerrors.Errorf("message from %s with nonce %d already in mpool,"+
 					" increase GasPremium to %s from %s to trigger replace by fee: %w",
 					m.Message.From, m.Message.Nonce, minPrice, m.Message.GasPremium,
@@ -481,7 +465,7 @@ func (mp *MessagePool) verifyMsgBeforeAdd(m *types.SignedMessage, curTs *types.T
 	epoch := curTs.Height()
 	minGas := vm.PricelistByEpoch(epoch).OnChainMessage(m.ChainLength())
 
-	if err := m.VMMessage().ValidForBlockInclusion(minGas.Total(), build.NewestNetworkVersion); err != nil {
+	if err := m.VMMessage().ValidForBlockInclusion(minGas.Total()); err != nil {
 		return false, xerrors.Errorf("message will not be included in a block: %w", err)
 	}
 
@@ -562,7 +546,7 @@ func (mp *MessagePool) checkMessage(m *types.SignedMessage) error {
 	}
 
 	// Perform syntactic validation, minGas=0 as we check the actual mingas before we add it
-	if err := m.Message.ValidForBlockInclusion(0, build.NewestNetworkVersion); err != nil {
+	if err := m.Message.ValidForBlockInclusion(0); err != nil {
 		return xerrors.Errorf("message not valid for block inclusion: %w", err)
 	}
 
@@ -871,7 +855,7 @@ func (mp *MessagePool) PushUntrusted(m *types.SignedMessage) (cid.Cid, error) {
 	}()
 
 	mp.curTsLk.Lock()
-	publish, err := mp.addTs(m, mp.curTs, true, true)
+	publish, err := mp.addTs(m, mp.curTs, false, true)
 	if err != nil {
 		mp.curTsLk.Unlock()
 		return cid.Undef, err

chain/messagepool/repub.go

@@ -100,7 +100,7 @@ loop:
 			// 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 m.Message.GasFeeCap.LessThan(baseFeeLowerBound) {
+				if !allowNegativeChains(ts.Height()) && m.Message.GasFeeCap.LessThan(baseFeeLowerBound) {
 					chain.Invalidate()
 					continue loop
 				}
@@ -115,7 +115,7 @@ loop:
 
 		// we can't fit the current chain but there is gas to spare
 		// trim it and push it down
-		chain.Trim(gasLimit, mp, baseFee)
+		chain.Trim(gasLimit, mp, baseFee, true)
 		for j := i; j < len(chains)-1; j++ {
 			if chains[j].Before(chains[j+1]) {
 				break

chain/messagepool/selection.go

@@ -10,6 +10,7 @@ import (
 	"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"
@@ -20,7 +21,11 @@ import (
 
 var bigBlockGasLimit = big.NewInt(build.BlockGasLimit)
 
-var MaxBlockMessages = 16000
+// 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
 
@@ -38,7 +43,7 @@ type msgChain struct {
 	prev         *msgChain
 }
 
-func (mp *MessagePool) SelectMessages(ts *types.TipSet, tq float64) (msgs []*types.SignedMessage, err error) {
+func (mp *MessagePool) SelectMessages(ts *types.TipSet, tq float64) ([]*types.SignedMessage, error) {
 	mp.curTsLk.Lock()
 	defer mp.curTsLk.Unlock()
 
@@ -49,20 +54,10 @@ func (mp *MessagePool) SelectMessages(ts *types.TipSet, tq float64) (msgs []*typ
 	// 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 {
-		msgs, err = mp.selectMessagesGreedy(mp.curTs, ts)
-	} else {
-		msgs, err = mp.selectMessagesOptimal(mp.curTs, ts, tq)
+		return mp.selectMessagesGreedy(mp.curTs, ts)
 	}
 
-	if err != nil {
-		return nil, err
-	}
-
-	if len(msgs) > MaxBlockMessages {
-		msgs = msgs[:MaxBlockMessages]
-	}
-
-	return msgs, nil
+	return mp.selectMessagesOptimal(mp.curTs, ts, tq)
 }
 
 func (mp *MessagePool) selectMessagesOptimal(curTs, ts *types.TipSet, tq float64) ([]*types.SignedMessage, error) {
@@ -114,7 +109,7 @@ func (mp *MessagePool) selectMessagesOptimal(curTs, ts *types.TipSet, tq float64
 		return chains[i].Before(chains[j])
 	})
 
-	if len(chains) != 0 && chains[0].gasPerf < 0 {
+	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
 	}
@@ -167,7 +162,7 @@ func (mp *MessagePool) selectMessagesOptimal(curTs, ts *types.TipSet, tq float64
 	last := len(chains)
 	for i, chain := range chains {
 		// did we run out of performing chains?
-		if chain.gasPerf < 0 {
+		if !allowNegativeChains(curTs.Height()) && chain.gasPerf < 0 {
 			break
 		}
 
@@ -233,7 +228,7 @@ tailLoop:
 	for gasLimit >= minGas && last < len(chains) {
 		// trim if necessary
 		if chains[last].gasLimit > gasLimit {
-			chains[last].Trim(gasLimit, mp, baseFee)
+			chains[last].Trim(gasLimit, mp, baseFee, allowNegativeChains(curTs.Height()))
 		}
 
 		// push down if it hasn't been invalidated
@@ -259,7 +254,7 @@ tailLoop:
 			}
 
 			// if gasPerf < 0 we have no more profitable chains
-			if chain.gasPerf < 0 {
+			if !allowNegativeChains(curTs.Height()) && chain.gasPerf < 0 {
 				break tailLoop
 			}
 
@@ -300,7 +295,7 @@ tailLoop:
 			}
 
 			// dependencies fit, just trim it
-			chain.Trim(gasLimit-depGasLimit, mp, baseFee)
+			chain.Trim(gasLimit-depGasLimit, mp, baseFee, allowNegativeChains(curTs.Height()))
 			last += i
 			continue tailLoop
 		}
@@ -333,7 +328,7 @@ tailLoop:
 			}
 
 			// is it negative?
-			if chain.gasPerf < 0 {
+			if !allowNegativeChains(curTs.Height()) && chain.gasPerf < 0 {
 				continue
 			}
 
@@ -355,7 +350,7 @@ tailLoop:
 
 			// 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)
+				chain.Trim(gasLimit-depGasLimit, mp, baseFee, allowNegativeChains(curTs.Height()))
 
 				if !chain.valid {
 					continue
@@ -438,7 +433,7 @@ func (mp *MessagePool) selectMessagesGreedy(curTs, ts *types.TipSet) ([]*types.S
 		return chains[i].Before(chains[j])
 	})
 
-	if len(chains) != 0 && chains[0].gasPerf < 0 {
+	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
 	}
@@ -449,7 +444,7 @@ func (mp *MessagePool) selectMessagesGreedy(curTs, ts *types.TipSet) ([]*types.S
 	last := len(chains)
 	for i, chain := range chains {
 		// did we run out of performing chains?
-		if chain.gasPerf < 0 {
+		if !allowNegativeChains(curTs.Height()) && chain.gasPerf < 0 {
 			break
 		}
 
@@ -478,7 +473,7 @@ func (mp *MessagePool) selectMessagesGreedy(curTs, ts *types.TipSet) ([]*types.S
 tailLoop:
 	for gasLimit >= minGas && last < len(chains) {
 		// trim
-		chains[last].Trim(gasLimit, mp, baseFee)
+		chains[last].Trim(gasLimit, mp, baseFee, allowNegativeChains(curTs.Height()))
 
 		// push down if it hasn't been invalidated
 		if chains[last].valid {
@@ -498,7 +493,7 @@ tailLoop:
 			}
 
 			// if gasPerf < 0 we have no more profitable chains
-			if chain.gasPerf < 0 {
+			if !allowNegativeChains(curTs.Height()) && chain.gasPerf < 0 {
 				break tailLoop
 			}
 
@@ -560,7 +555,7 @@ func (mp *MessagePool) selectPriorityMessages(pending map[address.Address]map[ui
 		return chains[i].Before(chains[j])
 	})
 
-	if len(chains) != 0 && chains[0].gasPerf < 0 {
+	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
 	}
@@ -568,7 +563,7 @@ func (mp *MessagePool) selectPriorityMessages(pending map[address.Address]map[ui
 	// 3. Merge chains until the block limit, as long as they have non-negative gas performance
 	last := len(chains)
 	for i, chain := range chains {
-		if chain.gasPerf < 0 {
+		if !allowNegativeChains(ts.Height()) && chain.gasPerf < 0 {
 			break
 		}
 
@@ -586,7 +581,7 @@ 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)
+		chains[last].Trim(gasLimit, mp, baseFee, allowNegativeChains(ts.Height()))
 
 		// push down if it hasn't been invalidated
 		if chains[last].valid {
@@ -606,7 +601,7 @@ tailLoop:
 			}
 
 			// if gasPerf < 0 we have no more profitable chains
-			if chain.gasPerf < 0 {
+			if !allowNegativeChains(ts.Height()) && chain.gasPerf < 0 {
 				break tailLoop
 			}
 
@@ -682,10 +677,6 @@ func (*MessagePool) getGasReward(msg *types.SignedMessage, baseFee types.BigInt)
 	}
 
 	gasReward := tbig.Mul(maxPremium, types.NewInt(uint64(msg.Message.GasLimit)))
-	if gasReward.Sign() == -1 {
-		// penalty multiplier
-		gasReward = tbig.Mul(gasReward, types.NewInt(3))
-	}
 	return gasReward.Int
 }
 
@@ -761,6 +752,9 @@ func (mp *MessagePool) createMessageChains(actor address.Address, mset map[uint6
 		balance = new(big.Int).Sub(balance, required)
 
 		value := m.Message.Value.Int
+		if balance.Cmp(value) < 0 {
+			break
+		}
 		balance = new(big.Int).Sub(balance, value)
 
 		gasReward := mp.getGasReward(m, baseFee)
@@ -864,9 +858,9 @@ 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) {
+func (mc *msgChain) Trim(gasLimit int64, mp *MessagePool, baseFee types.BigInt, allowNegative bool) {
 	i := len(mc.msgs) - 1
-	for i >= 0 && (mc.gasLimit > gasLimit || mc.gasPerf < 0) {
+	for i >= 0 && (mc.gasLimit > gasLimit || (!allowNegative && mc.gasPerf < 0)) {
 		gasReward := mp.getGasReward(mc.msgs[i], baseFee)
 		mc.gasReward = new(big.Int).Sub(mc.gasReward, gasReward)
 		mc.gasLimit -= mc.msgs[i].Message.GasLimit

chain/messagepool/selection_test.go

@@ -736,6 +736,8 @@ func TestPriorityMessageSelection2(t *testing.T) {
 }
 
 func TestPriorityMessageSelection3(t *testing.T) {
+	t.Skip("reenable after removing allow negative")
+
 	mp, tma := makeTestMpool()
 
 	// the actors
@@ -1239,9 +1241,6 @@ func TestCompetitiveMessageSelectionExp(t *testing.T) {
 }
 
 func TestCompetitiveMessageSelectionZipf(t *testing.T) {
-	if testing.Short() {
-		t.Skip("skipping in short mode")
-	}
 	var capacityBoost, rewardBoost, tqReward float64
 	seeds := []int64{1947, 1976, 2020, 2100, 10000, 143324, 432432, 131, 32, 45}
 	for _, seed := range seeds {
@@ -1269,9 +1268,9 @@ func TestGasReward(t *testing.T) {
 		GasReward int64
 	}{
 		{Premium: 100, FeeCap: 200, BaseFee: 100, GasReward: 100},
-		{Premium: 100, FeeCap: 200, BaseFee: 210, GasReward: -10 * 3},
+		{Premium: 100, FeeCap: 200, BaseFee: 210, GasReward: -10},
 		{Premium: 200, FeeCap: 250, BaseFee: 210, GasReward: 40},
-		{Premium: 200, FeeCap: 250, BaseFee: 2000, GasReward: -1750 * 3},
+		{Premium: 200, FeeCap: 250, BaseFee: 2000, GasReward: -1750},
 	}
 
 	mp := new(MessagePool)

chain/stmgr/forks.go

@@ -6,13 +6,27 @@ import (
 	"encoding/binary"
 	"math"
 
+	"github.com/filecoin-project/lotus/chain/actors/builtin"
+
 	"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/network"
+	"github.com/ipfs/go-cid"
+	cbor "github.com/ipfs/go-ipld-cbor"
+	"golang.org/x/xerrors"
+
+	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
+	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
+	multisig0 "github.com/filecoin-project/specs-actors/actors/builtin/multisig"
+	power0 "github.com/filecoin-project/specs-actors/actors/builtin/power"
+	adt0 "github.com/filecoin-project/specs-actors/actors/util/adt"
+
+	"github.com/filecoin-project/specs-actors/actors/migration/nv3"
+	m2 "github.com/filecoin-project/specs-actors/v2/actors/migration"
+
 	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain/actors/adt"
-	"github.com/filecoin-project/lotus/chain/actors/builtin"
 	init_ "github.com/filecoin-project/lotus/chain/actors/builtin/init"
 	"github.com/filecoin-project/lotus/chain/actors/builtin/multisig"
 	"github.com/filecoin-project/lotus/chain/state"
@@ -21,17 +35,6 @@ import (
 	"github.com/filecoin-project/lotus/chain/vm"
 	bstore "github.com/filecoin-project/lotus/lib/blockstore"
 	"github.com/filecoin-project/lotus/lib/bufbstore"
-	builtin0 "github.com/filecoin-project/specs-actors/actors/builtin"
-	miner0 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
-	multisig0 "github.com/filecoin-project/specs-actors/actors/builtin/multisig"
-	power0 "github.com/filecoin-project/specs-actors/actors/builtin/power"
-	"github.com/filecoin-project/specs-actors/actors/migration/nv3"
-	adt0 "github.com/filecoin-project/specs-actors/actors/util/adt"
-	"github.com/filecoin-project/specs-actors/v2/actors/migration/nv4"
-	"github.com/filecoin-project/specs-actors/v2/actors/migration/nv7"
-	"github.com/ipfs/go-cid"
-	cbor "github.com/ipfs/go-ipld-cbor"
-	"golang.org/x/xerrors"
 )
 
 // UpgradeFunc is a migration function run at every upgrade.
@@ -77,9 +80,8 @@ func DefaultUpgradeSchedule() UpgradeSchedule {
 		Expensive: true,
 		Migration: UpgradeActorsV2,
 	}, {
-		Height:    build.UpgradeTapeHeight,
-		Network:   network.Version5,
-		Migration: nil,
+		Height:  build.UpgradeTapeHeight,
+		Network: network.Version5,
 	}, {
 		Height:    build.UpgradeLiftoffHeight,
 		Network:   network.Version5,
@@ -88,14 +90,6 @@ func DefaultUpgradeSchedule() UpgradeSchedule {
 		Height:    build.UpgradeKumquatHeight,
 		Network:   network.Version6,
 		Migration: nil,
-	}, {
-		Height:    build.UpgradeCalicoHeight,
-		Network:   network.Version7,
-		Migration: UpgradeCalico,
-	}, {
-		Height:    build.UpgradePersianHeight,
-		Network:   network.Version8,
-		Migration: nil,
 	}}
 
 	if build.UpgradeActorsV2Height == math.MaxInt64 { // disable actors upgrade
@@ -607,7 +601,7 @@ func UpgradeActorsV2(ctx context.Context, sm *StateManager, cb ExecCallback, roo
 		return cid.Undef, xerrors.Errorf("failed to create new state info for actors v2: %w", err)
 	}
 
-	newHamtRoot, err := nv4.MigrateStateTree(ctx, store, root, epoch, nv4.DefaultConfig())
+	newHamtRoot, err := m2.MigrateStateTree(ctx, store, root, epoch, m2.DefaultConfig())
 	if err != nil {
 		return cid.Undef, xerrors.Errorf("upgrading to actors v2: %w", err)
 	}
@@ -658,48 +652,6 @@ func UpgradeLiftoff(ctx context.Context, sm *StateManager, cb ExecCallback, root
 	return tree.Flush(ctx)
 }
 
-func UpgradeCalico(ctx context.Context, sm *StateManager, cb ExecCallback, root cid.Cid, epoch abi.ChainEpoch, ts *types.TipSet) (cid.Cid, error) {
-	store := sm.cs.Store(ctx)
-	var stateRoot types.StateRoot
-	if err := store.Get(ctx, root, &stateRoot); err != nil {
-		return cid.Undef, xerrors.Errorf("failed to decode state root: %w", err)
-	}
-
-	if stateRoot.Version != types.StateTreeVersion1 {
-		return cid.Undef, xerrors.Errorf(
-			"expected state root version 1 for calico upgrade, got %d",
-			stateRoot.Version,
-		)
-	}
-
-	newHamtRoot, err := nv7.MigrateStateTree(ctx, store, stateRoot.Actors, epoch, nv7.DefaultConfig())
-	if err != nil {
-		return cid.Undef, xerrors.Errorf("running nv7 migration: %w", err)
-	}
-
-	newRoot, err := store.Put(ctx, &types.StateRoot{
-		Version: stateRoot.Version,
-		Actors:  newHamtRoot,
-		Info:    stateRoot.Info,
-	})
-	if err != nil {
-		return cid.Undef, xerrors.Errorf("failed to persist new state root: %w", err)
-	}
-
-	// perform some basic sanity checks to make sure everything still works.
-	if newSm, err := state.LoadStateTree(store, newRoot); err != nil {
-		return cid.Undef, xerrors.Errorf("state tree sanity load failed: %w", err)
-	} else if newRoot2, err := newSm.Flush(ctx); err != nil {
-		return cid.Undef, xerrors.Errorf("state tree sanity flush failed: %w", err)
-	} else if newRoot2 != newRoot {
-		return cid.Undef, xerrors.Errorf("state-root mismatch: %s != %s", newRoot, newRoot2)
-	} else if _, err := newSm.GetActor(builtin0.InitActorAddr); err != nil {
-		return cid.Undef, xerrors.Errorf("failed to load init actor after upgrade: %w", err)
-	}
-
-	return newRoot, nil
-}
-
 func setNetworkName(ctx context.Context, store adt.Store, tree *state.StateTree, name string) error {
 	ia, err := tree.GetActor(builtin0.InitActorAddr)
 	if err != nil {

chain/stmgr/stmgr.go

@@ -72,17 +72,13 @@ type StateManager struct {
 	// ErrExpensiveFork.
 	expensiveUpgrades map[abi.ChainEpoch]struct{}
 
-	stCache             map[string][]cid.Cid
-	compWait            map[string]chan struct{}
-	stlk                sync.Mutex
-	genesisMsigLk       sync.Mutex
-	newVM               func(context.Context, *vm.VMOpts) (*vm.VM, error)
-	preIgnitionVesting  []msig0.State
-	postIgnitionVesting []msig0.State
-	postCalicoVesting   []msig0.State
-
-	genesisPledge      abi.TokenAmount
-	genesisMarketFunds abi.TokenAmount
+	stCache              map[string][]cid.Cid
+	compWait             map[string]chan struct{}
+	stlk                 sync.Mutex
+	genesisMsigLk        sync.Mutex
+	newVM                func(context.Context, *vm.VMOpts) (*vm.VM, error)
+	preIgnitionGenInfos  *genesisInfo
+	postIgnitionGenInfos *genesisInfo
 }
 
 func NewStateManager(cs *store.ChainStore) *StateManager {
@@ -893,8 +889,23 @@ func (sm *StateManager) SetVMConstructor(nvm func(context.Context, *vm.VMOpts) (
 	sm.newVM = nvm
 }
 
-// sets up information about the vesting schedule
-func (sm *StateManager) setupGenesisVestingSchedule(ctx context.Context) error {
+type genesisInfo struct {
+	genesisMsigs []msig0.State
+	// info about the Accounts in the genesis state
+	genesisActors      []genesisActor
+	genesisPledge      abi.TokenAmount
+	genesisMarketFunds abi.TokenAmount
+}
+
+type genesisActor struct {
+	addr    address.Address
+	initBal abi.TokenAmount
+}
+
+// sets up information about the actors in the genesis state
+func (sm *StateManager) setupGenesisActors(ctx context.Context) error {
+
+	gi := genesisInfo{}
 
 	gb, err := sm.cs.GetGenesis()
 	if err != nil {
@@ -917,58 +928,127 @@ func (sm *StateManager) setupGenesisVestingSchedule(ctx context.Context) error {
 		return xerrors.Errorf("loading state tree: %w", err)
 	}
 
-	gmf, err := getFilMarketLocked(ctx, sTree)
+	gi.genesisMarketFunds, err = getFilMarketLocked(ctx, sTree)
 	if err != nil {
 		return xerrors.Errorf("setting up genesis market funds: %w", err)
 	}
 
-	gp, err := getFilPowerLocked(ctx, sTree)
+	gi.genesisPledge, err = getFilPowerLocked(ctx, sTree)
 	if err != nil {
 		return xerrors.Errorf("setting up genesis pledge: %w", err)
 	}
 
-	sm.genesisMarketFunds = gmf
-	sm.genesisPledge = gp
-
 	totalsByEpoch := make(map[abi.ChainEpoch]abi.TokenAmount)
+	err = sTree.ForEach(func(kaddr address.Address, act *types.Actor) error {
+		if builtin.IsMultisigActor(act.Code) {
+			s, err := multisig.Load(sm.cs.Store(ctx), act)
+			if err != nil {
+				return err
+			}
 
-	// 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))
+			se, err := s.StartEpoch()
+			if err != nil {
+				return err
+			}
 
-	// 1 year
-	oneYear := abi.ChainEpoch(365 * builtin.EpochsInDay)
-	totalsByEpoch[oneYear] = big.NewInt(22_421_712)
+			if se != 0 {
+				return xerrors.New("genesis multisig doesn't start vesting at epoch 0!")
+			}
 
-	// 2 years
-	twoYears := abi.ChainEpoch(2 * 365 * builtin.EpochsInDay)
-	totalsByEpoch[twoYears] = big.NewInt(7_223_364)
+			ud, err := s.UnlockDuration()
+			if err != nil {
+				return err
+			}
 
-	// 3 years
-	threeYears := abi.ChainEpoch(3 * 365 * builtin.EpochsInDay)
-	totalsByEpoch[threeYears] = big.NewInt(87_637_883)
+			ib, err := s.InitialBalance()
+			if err != nil {
+				return err
+			}
 
-	// 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))
+			ot, f := totalsByEpoch[ud]
+			if f {
+				totalsByEpoch[ud] = big.Add(ot, ib)
+			} else {
+				totalsByEpoch[ud] = ib
+			}
 
-	sm.preIgnitionVesting = make([]msig0.State, 0, len(totalsByEpoch))
+		} else if builtin.IsAccountActor(act.Code) {
+			// should exclude burnt funds actor and "remainder account actor"
+			// should only ever be "faucet" accounts in testnets
+			if kaddr == builtin.BurntFundsActorAddr {
+				return nil
+			}
+
+			kid, err := sTree.LookupID(kaddr)
+			if err != nil {
+				return xerrors.Errorf("resolving address: %w", err)
+			}
+
+			gi.genesisActors = append(gi.genesisActors, genesisActor{
+				addr:    kid,
+				initBal: act.Balance,
+			})
+		}
+		return nil
+	})
+
+	if err != nil {
+		return xerrors.Errorf("error setting up genesis infos: %w", err)
+	}
+
+	// TODO: use network upgrade abstractions or always start at actors v0?
+	gi.genesisMsigs = make([]msig0.State, 0, len(totalsByEpoch))
 	for k, v := range totalsByEpoch {
 		ns := msig0.State{
 			InitialBalance: v,
 			UnlockDuration: k,
 			PendingTxns:    cid.Undef,
 		}
-		sm.preIgnitionVesting = append(sm.preIgnitionVesting, ns)
+		gi.genesisMsigs = append(gi.genesisMsigs, ns)
 	}
 
+	sm.preIgnitionGenInfos = &gi
+
 	return nil
 }
 
-// sets up information about the vesting schedule post the ignition upgrade
-func (sm *StateManager) setupPostIgnitionVesting(ctx context.Context) error {
+// sets up information about the actors in the genesis state
+// For testnet we use a hardcoded set of multisig states, instead of what's actually in the genesis multisigs
+// We also do not consider ANY account actors (including the faucet)
+func (sm *StateManager) setupPreIgnitionGenesisActorsTestnet(ctx context.Context) error {
+
+	gi := genesisInfo{}
+
+	gb, err := sm.cs.GetGenesis()
+	if err != nil {
+		return xerrors.Errorf("getting genesis block: %w", err)
+	}
+
+	gts, err := types.NewTipSet([]*types.BlockHeader{gb})
+	if err != nil {
+		return xerrors.Errorf("getting genesis tipset: %w", err)
+	}
+
+	st, _, err := sm.TipSetState(ctx, gts)
+	if err != nil {
+		return xerrors.Errorf("getting genesis tipset state: %w", err)
+	}
+
+	cst := cbor.NewCborStore(sm.cs.Blockstore())
+	sTree, err := state.LoadStateTree(cst, st)
+	if err != nil {
+		return xerrors.Errorf("loading state tree: %w", err)
+	}
+
+	gi.genesisMarketFunds, err = getFilMarketLocked(ctx, sTree)
+	if err != nil {
+		return xerrors.Errorf("setting up genesis market funds: %w", err)
+	}
+
+	gi.genesisPledge, err = getFilPowerLocked(ctx, sTree)
+	if err != nil {
+		return xerrors.Errorf("setting up genesis pledge: %w", err)
+	}
 
 	totalsByEpoch := make(map[abi.ChainEpoch]abi.TokenAmount)
 
@@ -994,7 +1074,84 @@ func (sm *StateManager) setupPostIgnitionVesting(ctx context.Context) error {
 	totalsByEpoch[sixYears] = big.NewInt(100_000_000)
 	totalsByEpoch[sixYears] = big.Add(totalsByEpoch[sixYears], big.NewInt(300_000_000))
 
-	sm.postIgnitionVesting = make([]msig0.State, 0, len(totalsByEpoch))
+	gi.genesisMsigs = make([]msig0.State, 0, len(totalsByEpoch))
+	for k, v := range totalsByEpoch {
+		ns := msig0.State{
+			InitialBalance: v,
+			UnlockDuration: k,
+			PendingTxns:    cid.Undef,
+		}
+		gi.genesisMsigs = append(gi.genesisMsigs, ns)
+	}
+
+	sm.preIgnitionGenInfos = &gi
+
+	return nil
+}
+
+// sets up information about the actors in the genesis state, post the ignition fork
+func (sm *StateManager) setupPostIgnitionGenesisActors(ctx context.Context) error {
+
+	gi := genesisInfo{}
+
+	gb, err := sm.cs.GetGenesis()
+	if err != nil {
+		return xerrors.Errorf("getting genesis block: %w", err)
+	}
+
+	gts, err := types.NewTipSet([]*types.BlockHeader{gb})
+	if err != nil {
+		return xerrors.Errorf("getting genesis tipset: %w", err)
+	}
+
+	st, _, err := sm.TipSetState(ctx, gts)
+	if err != nil {
+		return xerrors.Errorf("getting genesis tipset state: %w", err)
+	}
+
+	cst := cbor.NewCborStore(sm.cs.Blockstore())
+	sTree, err := state.LoadStateTree(cst, st)
+	if err != nil {
+		return xerrors.Errorf("loading state tree: %w", err)
+	}
+
+	// Unnecessary, should be removed
+	gi.genesisMarketFunds, err = getFilMarketLocked(ctx, sTree)
+	if err != nil {
+		return xerrors.Errorf("setting up genesis market funds: %w", err)
+	}
+
+	// Unnecessary, should be removed
+	gi.genesisPledge, err = getFilPowerLocked(ctx, sTree)
+	if err != nil {
+		return xerrors.Errorf("setting up genesis pledge: %w", err)
+	}
+
+	totalsByEpoch := make(map[abi.ChainEpoch]abi.TokenAmount)
+
+	// 6 months
+	sixMonths := abi.ChainEpoch(183 * 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([]msig0.State, 0, len(totalsByEpoch))
 	for k, v := range totalsByEpoch {
 		ns := msig0.State{
 			// In the pre-ignition logic, we incorrectly set this value in Fil, not attoFil, an off-by-10^18 error
@@ -1004,56 +1161,10 @@ func (sm *StateManager) setupPostIgnitionVesting(ctx context.Context) error {
 			// In the pre-ignition logic, the start epoch was 0. This changes in the fork logic of the Ignition upgrade itself.
 			StartEpoch: build.UpgradeLiftoffHeight,
 		}
-		sm.postIgnitionVesting = append(sm.postIgnitionVesting, ns)
+		gi.genesisMsigs = append(gi.genesisMsigs, ns)
 	}
 
-	return nil
-}
-
-// sets up information about the vesting schedule post the calico upgrade
-func (sm *StateManager) setupPostCalicoVesting(ctx context.Context) error {
-
-	totalsByEpoch := make(map[abi.ChainEpoch]abi.TokenAmount)
-
-	// 0 days
-	zeroDays := abi.ChainEpoch(0)
-	totalsByEpoch[zeroDays] = big.NewInt(10_632_000)
-
-	// 6 months
-	sixMonths := abi.ChainEpoch(183 * builtin.EpochsInDay)
-	totalsByEpoch[sixMonths] = big.NewInt(19_015_887)
-	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)
-	totalsByEpoch[oneYear] = big.Add(totalsByEpoch[oneYear], big.NewInt(9_400_000))
-
-	// 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)
-	totalsByEpoch[threeYears] = big.Add(totalsByEpoch[threeYears], big.NewInt(898_958))
-
-	// 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))
-	totalsByEpoch[sixYears] = big.Add(totalsByEpoch[sixYears], big.NewInt(9_805_053))
-
-	sm.postCalicoVesting = make([]msig0.State, 0, len(totalsByEpoch))
-	for k, v := range totalsByEpoch {
-		ns := msig0.State{
-			InitialBalance: big.Mul(v, big.NewInt(int64(build.FilecoinPrecision))),
-			UnlockDuration: k,
-			PendingTxns:    cid.Undef,
-			StartEpoch:     build.UpgradeLiftoffHeight,
-		}
-		sm.postCalicoVesting = append(sm.postCalicoVesting, ns)
-	}
+	sm.postIgnitionGenInfos = &gi
 
 	return nil
 }
@@ -1064,19 +1175,12 @@ func (sm *StateManager) setupPostCalicoVesting(ctx context.Context) error {
 func (sm *StateManager) GetFilVested(ctx context.Context, height abi.ChainEpoch, st *state.StateTree) (abi.TokenAmount, error) {
 	vf := big.Zero()
 	if height <= build.UpgradeIgnitionHeight {
-		for _, v := range sm.preIgnitionVesting {
+		for _, v := range sm.preIgnitionGenInfos.genesisMsigs {
 			au := big.Sub(v.InitialBalance, v.AmountLocked(height))
 			vf = big.Add(vf, au)
 		}
-	} else if height <= build.UpgradeCalicoHeight {
-		for _, v := range sm.postIgnitionVesting {
-			// In the pre-ignition logic, we simply called AmountLocked(height), assuming startEpoch was 0.
-			// The start epoch changed in the Ignition upgrade.
-			au := big.Sub(v.InitialBalance, v.AmountLocked(height-v.StartEpoch))
-			vf = big.Add(vf, au)
-		}
 	} else {
-		for _, v := range sm.postCalicoVesting {
+		for _, v := range sm.postIgnitionGenInfos.genesisMsigs {
 			// In the pre-ignition logic, we simply called AmountLocked(height), assuming startEpoch was 0.
 			// The start epoch changed in the Ignition upgrade.
 			au := big.Sub(v.InitialBalance, v.AmountLocked(height-v.StartEpoch))
@@ -1084,12 +1188,26 @@ func (sm *StateManager) GetFilVested(ctx context.Context, height abi.ChainEpoch,
 		}
 	}
 
+	// there should not be any such accounts in testnet (and also none in mainnet?)
+	// continue to use preIgnitionGenInfos, nothing changed at the Ignition epoch
+	for _, v := range sm.preIgnitionGenInfos.genesisActors {
+		act, err := st.GetActor(v.addr)
+		if err != nil {
+			return big.Zero(), xerrors.Errorf("failed to get actor: %w", err)
+		}
+
+		diff := big.Sub(v.initBal, act.Balance)
+		if diff.GreaterThan(big.Zero()) {
+			vf = big.Add(vf, diff)
+		}
+	}
+
 	// After UpgradeActorsV2Height these funds are accounted for in GetFilReserveDisbursed
 	if height <= build.UpgradeActorsV2Height {
 		// continue to use preIgnitionGenInfos, nothing changed at the Ignition epoch
-		vf = big.Add(vf, sm.genesisPledge)
+		vf = big.Add(vf, sm.preIgnitionGenInfos.genesisPledge)
 		// continue to use preIgnitionGenInfos, nothing changed at the Ignition epoch
-		vf = big.Add(vf, sm.genesisMarketFunds)
+		vf = big.Add(vf, sm.preIgnitionGenInfos.genesisMarketFunds)
 	}
 
 	return vf, nil
@@ -1183,22 +1301,16 @@ func (sm *StateManager) GetVMCirculatingSupply(ctx context.Context, height abi.C
 func (sm *StateManager) GetVMCirculatingSupplyDetailed(ctx context.Context, height abi.ChainEpoch, st *state.StateTree) (api.CirculatingSupply, error) {
 	sm.genesisMsigLk.Lock()
 	defer sm.genesisMsigLk.Unlock()
-	if sm.preIgnitionVesting == nil || sm.genesisPledge.IsZero() || sm.genesisMarketFunds.IsZero() {
-		err := sm.setupGenesisVestingSchedule(ctx)
+	if sm.preIgnitionGenInfos == nil {
+		err := sm.setupPreIgnitionGenesisActorsTestnet(ctx)
 		if err != nil {
-			return api.CirculatingSupply{}, xerrors.Errorf("failed to setup pre-ignition vesting schedule: %w", err)
+			return api.CirculatingSupply{}, xerrors.Errorf("failed to setup pre-ignition genesis information: %w", err)
 		}
 	}
-	if sm.postIgnitionVesting == nil {
-		err := sm.setupPostIgnitionVesting(ctx)
+	if sm.postIgnitionGenInfos == nil {
+		err := sm.setupPostIgnitionGenesisActors(ctx)
 		if err != nil {
-			return api.CirculatingSupply{}, xerrors.Errorf("failed to setup post-ignition vesting schedule: %w", err)
-		}
-	}
-	if sm.postCalicoVesting == nil {
-		err := sm.setupPostCalicoVesting(ctx)
-		if err != nil {
-			return api.CirculatingSupply{}, xerrors.Errorf("failed to setup post-calico vesting schedule: %w", err)
+			return api.CirculatingSupply{}, xerrors.Errorf("failed to setup post-ignition genesis information: %w", err)
 		}
 	}
 

chain/stmgr/utils.go

@@ -158,7 +158,7 @@ func GetMinerSectorSet(ctx context.Context, sm *StateManager, ts *types.TipSet,
 	return mas.LoadSectors(snos)
 }
 
-func GetSectorsForWinningPoSt(ctx context.Context, nv network.Version, pv ffiwrapper.Verifier, sm *StateManager, st cid.Cid, maddr address.Address, rand abi.PoStRandomness) ([]builtin.SectorInfo, error) {
+func GetSectorsForWinningPoSt(ctx context.Context, pv ffiwrapper.Verifier, sm *StateManager, st cid.Cid, maddr address.Address, rand abi.PoStRandomness) ([]builtin.SectorInfo, error) {
 	act, err := sm.LoadActorRaw(ctx, maddr, st)
 	if err != nil {
 		return nil, xerrors.Errorf("failed to load miner actor: %w", err)
@@ -169,27 +169,21 @@ func GetSectorsForWinningPoSt(ctx context.Context, nv network.Version, pv ffiwra
 		return nil, xerrors.Errorf("failed to load miner actor state: %w", err)
 	}
 
-	var provingSectors bitfield.BitField
-	if nv < network.Version7 {
-		allSectors, err := miner.AllPartSectors(mas, miner.Partition.AllSectors)
-		if err != nil {
-			return nil, xerrors.Errorf("get all sectors: %w", err)
-		}
+	// TODO (!!): Actor Update: Make this active sectors
 
-		faultySectors, err := miner.AllPartSectors(mas, miner.Partition.FaultySectors)
-		if err != nil {
-			return nil, xerrors.Errorf("get faulty sectors: %w", err)
-		}
+	allSectors, err := miner.AllPartSectors(mas, miner.Partition.AllSectors)
+	if err != nil {
+		return nil, xerrors.Errorf("get all sectors: %w", err)
+	}
 
-		provingSectors, err = bitfield.SubtractBitField(allSectors, faultySectors)
-		if err != nil {
-			return nil, xerrors.Errorf("calc proving sectors: %w", err)
-		}
-	} else {
-		provingSectors, err = miner.AllPartSectors(mas, miner.Partition.ActiveSectors)
-		if err != nil {
-			return nil, xerrors.Errorf("get active sectors sectors: %w", err)
-		}
+	faultySectors, err := miner.AllPartSectors(mas, miner.Partition.FaultySectors)
+	if err != nil {
+		return nil, xerrors.Errorf("get faulty sectors: %w", err)
+	}
+
+	provingSectors, err := bitfield.SubtractBitField(allSectors, faultySectors) // TODO: This is wrong, as it can contain faaults, change to just ActiveSectors in an upgrade
+	if err != nil {
+		return nil, xerrors.Errorf("calc proving sectors: %w", err)
 	}
 
 	numProvSect, err := provingSectors.Count()
@@ -207,7 +201,12 @@ func GetSectorsForWinningPoSt(ctx context.Context, nv network.Version, pv ffiwra
 		return nil, xerrors.Errorf("getting miner info: %w", err)
 	}
 
-	wpt, err := info.SealProofType.RegisteredWinningPoStProof()
+	spt, err := ffiwrapper.SealProofTypeFromSectorSize(info.SectorSize)
+	if err != nil {
+		return nil, xerrors.Errorf("getting seal proof type: %w", err)
+	}
+
+	wpt, err := spt.RegisteredWinningPoStProof()
 	if err != nil {
 		return nil, xerrors.Errorf("getting window proof type: %w", err)
 	}
@@ -247,7 +246,7 @@ func GetSectorsForWinningPoSt(ctx context.Context, nv network.Version, pv ffiwra
 	out := make([]builtin.SectorInfo, len(sectors))
 	for i, sinfo := range sectors {
 		out[i] = builtin.SectorInfo{
-			SealProof:    sinfo.SealProof,
+			SealProof:    spt,
 			SectorNumber: sinfo.SectorNumber,
 			SealedCID:    sinfo.SealedCID,
 		}
@@ -300,11 +299,7 @@ func GetStorageDeal(ctx context.Context, sm *StateManager, dealID abi.DealID, ts
 	if err != nil {
 		return nil, err
 	} else if !found {
-		return nil, xerrors.Errorf(
-			"deal %d not found "+
-				"- deal may not have completed sealing before deal proposal "+
-				"start epoch, or deal may have been slashed",
-			dealID)
+		return nil, xerrors.Errorf("deal %d not found", dealID)
 	}
 
 	states, err := state.States()
@@ -502,9 +497,7 @@ func MinerGetBaseInfo(ctx context.Context, sm *StateManager, bcs beacon.Schedule
 		return nil, xerrors.Errorf("failed to get randomness for winning post: %w", err)
 	}
 
-	nv := sm.GetNtwkVersion(ctx, ts.Height())
-
-	sectors, err := GetSectorsForWinningPoSt(ctx, nv, pv, sm, lbst, maddr, prand)
+	sectors, err := GetSectorsForWinningPoSt(ctx, pv, sm, lbst, maddr, prand)
 	if err != nil {
 		return nil, xerrors.Errorf("getting winning post proving set: %w", err)
 	}

chain/store/index_test.go

@@ -32,7 +32,6 @@ func TestIndexSeeks(t *testing.T) {
 
 	nbs := blockstore.NewTemporarySync()
 	cs := store.NewChainStore(nbs, nbs, syncds.MutexWrap(datastore.NewMapDatastore()), nil, nil)
-	defer cs.Close() //nolint:errcheck
 
 	_, err = cs.Import(bytes.NewReader(gencar))
 	if err != nil {

chain/store/store.go

@@ -134,30 +134,24 @@ type ChainStore struct {
 
 	evtTypes [1]journal.EventType
 	journal  journal.Journal
-
-	cancelFn context.CancelFunc
-	wg       sync.WaitGroup
 }
 
 // localbs is guaranteed to fail Get* if requested block isn't stored locally
 func NewChainStore(bs bstore.Blockstore, localbs bstore.Blockstore, ds dstore.Batching, vmcalls vm.SyscallBuilder, j journal.Journal) *ChainStore {
-	mmCache, _ := lru.NewARC(DefaultMsgMetaCacheSize)
-	tsCache, _ := lru.NewARC(DefaultTipSetCacheSize)
+	c, _ := lru.NewARC(DefaultMsgMetaCacheSize)
+	tsc, _ := lru.NewARC(DefaultTipSetCacheSize)
 	if j == nil {
 		j = journal.NilJournal()
 	}
-
-	ctx, cancel := context.WithCancel(context.Background())
 	cs := &ChainStore{
 		bs:       bs,
 		localbs:  localbs,
 		ds:       ds,
 		bestTips: pubsub.New(64),
 		tipsets:  make(map[abi.ChainEpoch][]cid.Cid),
-		mmCache:  mmCache,
-		tsCache:  tsCache,
+		mmCache:  c,
+		tsCache:  tsc,
 		vmcalls:  vmcalls,
-		cancelFn: cancel,
 		journal:  j,
 	}
 
@@ -197,24 +191,19 @@ func NewChainStore(bs bstore.Blockstore, localbs bstore.Blockstore, ds dstore.Ba
 	}
 
 	hcmetric := func(rev, app []*types.TipSet) error {
+		ctx := context.Background()
 		for _, r := range app {
-			stats.Record(context.Background(), metrics.ChainNodeHeight.M(int64(r.Height())))
+			stats.Record(ctx, metrics.ChainNodeHeight.M(int64(r.Height())))
 		}
 		return nil
 	}
 
 	cs.reorgNotifeeCh = make(chan ReorgNotifee)
-	cs.reorgCh = cs.reorgWorker(ctx, []ReorgNotifee{hcnf, hcmetric})
+	cs.reorgCh = cs.reorgWorker(context.TODO(), []ReorgNotifee{hcnf, hcmetric})
 
 	return cs
 }
 
-func (cs *ChainStore) Close() error {
-	cs.cancelFn()
-	cs.wg.Wait()
-	return nil
-}
-
 func (cs *ChainStore) Load() error {
 	head, err := cs.ds.Get(chainHeadKey)
 	if err == dstore.ErrNotFound {
@@ -394,7 +383,7 @@ func (cs *ChainStore) MaybeTakeHeavierTipSet(ctx context.Context, ts *types.TipS
 // particular tipset to carry out a benchmark, verification, etc. on a chain
 // segment.
 func (cs *ChainStore) ForceHeadSilent(_ context.Context, ts *types.TipSet) error {
-	log.Warnf("(!!!) forcing a new head silently; new head: %s", ts)
+	log.Warnf("(!!!) forcing a new head silently; only use this only for testing; new head: %s", ts)
 
 	cs.heaviestLk.Lock()
 	defer cs.heaviestLk.Unlock()
@@ -417,9 +406,7 @@ func (cs *ChainStore) reorgWorker(ctx context.Context, initialNotifees []ReorgNo
 	notifees := make([]ReorgNotifee, len(initialNotifees))
 	copy(notifees, initialNotifees)
 
-	cs.wg.Add(1)
 	go func() {
-		defer cs.wg.Done()
 		defer log.Warn("reorgWorker quit")
 
 		for {
@@ -726,32 +713,12 @@ func (cs *ChainStore) AddToTipSetTracker(b *types.BlockHeader) error {
 			log.Debug("tried to add block to tipset tracker that was already there")
 			return nil
 		}
-		h, err := cs.GetBlock(oc)
-		if err == nil && h != nil {
-			if h.Miner == b.Miner {
-				log.Warnf("Have multiple blocks from miner %s at height %d in our tipset cache %s-%s", b.Miner, b.Height, b.Cid(), h.Cid())
-			}
-		}
-	}
-	// This function is called 5 times per epoch on average
-	// It is also called with tipsets that are done with initial validation
-	// so they cannot be from the future.
-	// We are guaranteed not to use tipsets older than 900 epochs (fork limit)
-	// This means that we ideally want to keep only most recent 900 epochs in here
-	// Golang's map iteration starts at a random point in a map.
-	// With 5 tries per epoch, and 900 entries to keep, on average we will have
-	// ~136 garbage entires in the `cs.tipsets` map. (solve for 1-(1-x/(900+x))^5 == 0.5)
-	// Seems good enough to me
-
-	for height := range cs.tipsets {
-		if height < b.Height-build.Finality {
-			delete(cs.tipsets, height)
-		}
-		break
 	}
 
 	cs.tipsets[b.Height] = append(tss, b.Cid())
 
+	// TODO: do we want to look for slashable submissions here? might as well...
+
 	return nil
 }
 
@@ -817,7 +784,7 @@ func (cs *ChainStore) expandTipset(b *types.BlockHeader) (*types.TipSet, error)
 		return types.NewTipSet(all)
 	}
 
-	inclMiners := map[address.Address]cid.Cid{b.Miner: b.Cid()}
+	inclMiners := map[address.Address]bool{b.Miner: true}
 	for _, bhc := range tsets {
 		if bhc == b.Cid() {
 			continue
@@ -828,14 +795,14 @@ func (cs *ChainStore) expandTipset(b *types.BlockHeader) (*types.TipSet, error)
 			return nil, xerrors.Errorf("failed to load block (%s) for tipset expansion: %w", bhc, err)
 		}
 
-		if cid, found := inclMiners[h.Miner]; found {
-			log.Warnf("Have multiple blocks from miner %s at height %d in our tipset cache %s-%s", h.Miner, h.Height, h.Cid(), cid)
+		if inclMiners[h.Miner] {
+			log.Warnf("Have multiple blocks from miner %s at height %d in our tipset cache", h.Miner, h.Height)
 			continue
 		}
 
 		if types.CidArrsEqual(h.Parents, b.Parents) {
 			all = append(all, h)
-			inclMiners[h.Miner] = bhc
+			inclMiners[h.Miner] = true
 		}
 	}
 

chain/store/store_test.go

@@ -71,7 +71,6 @@ func BenchmarkGetRandomness(b *testing.B) {
 	}
 
 	cs := store.NewChainStore(bs, bs, mds, nil, nil)
-	defer cs.Close() //nolint:errcheck
 
 	b.ResetTimer()
 
@@ -106,7 +105,6 @@ func TestChainExportImport(t *testing.T) {
 
 	nbs := blockstore.NewTemporary()
 	cs := store.NewChainStore(nbs, nbs, datastore.NewMapDatastore(), nil, nil)
-	defer cs.Close() //nolint:errcheck
 
 	root, err := cs.Import(buf)
 	if err != nil {
@@ -141,8 +139,6 @@ func TestChainExportImportFull(t *testing.T) {
 
 	nbs := blockstore.NewTemporary()
 	cs := store.NewChainStore(nbs, nbs, datastore.NewMapDatastore(), nil, nil)
-	defer cs.Close() //nolint:errcheck
-
 	root, err := cs.Import(buf)
 	if err != nil {
 		t.Fatal(err)

chain/sub/incoming.go

@@ -6,18 +6,9 @@ import (
 	"fmt"
 	"time"
 
+	"golang.org/x/xerrors"
+
 	address "github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/lotus/build"
-	"github.com/filecoin-project/lotus/chain"
-	"github.com/filecoin-project/lotus/chain/messagepool"
-	"github.com/filecoin-project/lotus/chain/stmgr"
-	"github.com/filecoin-project/lotus/chain/store"
-	"github.com/filecoin-project/lotus/chain/types"
-	"github.com/filecoin-project/lotus/lib/blockstore"
-	"github.com/filecoin-project/lotus/lib/sigs"
-	"github.com/filecoin-project/lotus/metrics"
-	"github.com/filecoin-project/lotus/node/impl/client"
-	blockadt "github.com/filecoin-project/specs-actors/actors/util/adt"
 	lru "github.com/hashicorp/golang-lru"
 	blocks "github.com/ipfs/go-block-format"
 	bserv "github.com/ipfs/go-blockservice"
@@ -30,7 +21,19 @@ import (
 	cbg "github.com/whyrusleeping/cbor-gen"
 	"go.opencensus.io/stats"
 	"go.opencensus.io/tag"
-	"golang.org/x/xerrors"
+
+	blockadt "github.com/filecoin-project/specs-actors/actors/util/adt"
+
+	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain"
+	"github.com/filecoin-project/lotus/chain/messagepool"
+	"github.com/filecoin-project/lotus/chain/stmgr"
+	"github.com/filecoin-project/lotus/chain/store"
+	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/lib/blockstore"
+	"github.com/filecoin-project/lotus/lib/sigs"
+	"github.com/filecoin-project/lotus/metrics"
+	"github.com/filecoin-project/lotus/node/impl/client"
 )
 
 var log = logging.Logger("sub")
@@ -97,10 +100,6 @@ func HandleIncomingBlocks(ctx context.Context, bsub *pubsub.Subscription, s *cha
 				log.Warnw("Slow msg fetch", "cid", blk.Header.Cid(), "source", msg.GetFrom(), "msgfetch", took)
 			}
 			if delay := build.Clock.Now().Unix() - int64(blk.Header.Timestamp); delay > 5 {
-				_ = stats.RecordWithTags(ctx,
-					[]tag.Mutator{tag.Insert(metrics.MinerID, blk.Header.Miner.String())},
-					metrics.BlockDelay.M(delay),
-				)
 				log.Warnf("Received block with large delay %d from miner %s", delay, blk.Header.Miner)
 			}
 
@@ -341,16 +340,11 @@ func (bv *BlockValidator) Validate(ctx context.Context, pid peer.ID, msg *pubsub
 func (bv *BlockValidator) validateLocalBlock(ctx context.Context, msg *pubsub.Message) pubsub.ValidationResult {
 	stats.Record(ctx, metrics.BlockPublished.M(1))
 
-	if size := msg.Size(); size > 1<<20-1<<15 {
-		log.Errorf("ignoring oversize block (%dB)", size)
-		recordFailure(ctx, metrics.BlockValidationFailure, "oversize_block")
-		return pubsub.ValidationIgnore
-	}
-
 	blk, what, err := bv.decodeAndCheckBlock(msg)
 	if err != nil {
 		log.Errorf("got invalid local block: %s", err)
-		recordFailure(ctx, metrics.BlockValidationFailure, what)
+		ctx, _ = tag.New(ctx, tag.Insert(metrics.FailureType, what))
+		stats.Record(ctx, metrics.BlockValidationFailure.M(1))
 		return pubsub.ValidationIgnore
 	}
 

chain/sync.go

@@ -32,7 +32,6 @@ import (
 	"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/go-state-types/network"
 	"github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper"
 	blst "github.com/supranational/blst/bindings/go"
 
@@ -732,8 +731,6 @@ func (syncer *Syncer) ValidateBlock(ctx context.Context, b *types.FullBlock, use
 		return xerrors.Errorf("load parent tipset failed (%s): %w", h.Parents, err)
 	}
 
-	winPoStNv := syncer.sm.GetNtwkVersion(ctx, baseTs.Height())
-
 	lbts, lbst, err := stmgr.GetLookbackTipSetForRound(ctx, syncer.sm, baseTs, h.Height)
 	if err != nil {
 		return xerrors.Errorf("failed to get lookback tipset for block: %w", err)
@@ -927,7 +924,7 @@ func (syncer *Syncer) ValidateBlock(ctx context.Context, b *types.FullBlock, use
 	})
 
 	wproofCheck := async.Err(func() error {
-		if err := syncer.VerifyWinningPoStProof(ctx, winPoStNv, h, *prevBeacon, lbst, waddr); err != nil {
+		if err := syncer.VerifyWinningPoStProof(ctx, h, *prevBeacon, lbst, waddr); err != nil {
 			return xerrors.Errorf("invalid election post: %w", err)
 		}
 		return nil
@@ -979,7 +976,7 @@ func (syncer *Syncer) ValidateBlock(ctx context.Context, b *types.FullBlock, use
 	return nil
 }
 
-func (syncer *Syncer) VerifyWinningPoStProof(ctx context.Context, nv network.Version, h *types.BlockHeader, prevBeacon types.BeaconEntry, lbst cid.Cid, waddr address.Address) error {
+func (syncer *Syncer) VerifyWinningPoStProof(ctx context.Context, h *types.BlockHeader, prevBeacon types.BeaconEntry, lbst cid.Cid, waddr address.Address) error {
 	if build.InsecurePoStValidation {
 		if len(h.WinPoStProof) == 0 {
 			return xerrors.Errorf("[INSECURE-POST-VALIDATION] No winning post proof given")
@@ -1011,7 +1008,7 @@ func (syncer *Syncer) VerifyWinningPoStProof(ctx context.Context, nv network.Ver
 		return xerrors.Errorf("failed to get ID from miner address %s: %w", h.Miner, err)
 	}
 
-	sectors, err := stmgr.GetSectorsForWinningPoSt(ctx, nv, syncer.verifier, syncer.sm, lbst, h.Miner, rand)
+	sectors, err := stmgr.GetSectorsForWinningPoSt(ctx, syncer.verifier, syncer.sm, lbst, h.Miner, rand)
 	if err != nil {
 		return xerrors.Errorf("getting winning post sector set: %w", err)
 	}
@@ -1075,7 +1072,7 @@ func (syncer *Syncer) checkBlockMessages(ctx context.Context, b *types.FullBlock
 
 		// Phase 1: syntactic validation, as defined in the spec
 		minGas := pl.OnChainMessage(msg.ChainLength())
-		if err := m.ValidForBlockInclusion(minGas.Total(), syncer.sm.GetNtwkVersion(ctx, b.Header.Height)); err != nil {
+		if err := m.ValidForBlockInclusion(minGas.Total()); err != nil {
 			return err
 		}
 
@@ -1331,7 +1328,7 @@ loop:
 			continue
 		}
 		if !xerrors.Is(err, bstore.ErrNotFound) {
-			log.Warnf("loading local tipset: %s", err)
+			log.Warn("loading local tipset: %s", err)
 		}
 
 		// NB: GetBlocks validates that the blocks are in-fact the ones we

chain/sync_manager.go

@@ -203,7 +203,6 @@ func (sm *syncManager) handlePeerHead(head peerHead) {
 
 		// not yet; do we have enough peers?
 		if len(sm.heads) < BootstrapPeerThreshold {
-			log.Debugw("not tracking enough peers to start sync worker", "have", len(sm.heads), "need", BootstrapPeerThreshold)
 			// not enough peers; track it and wait
 			return
 		}

chain/types/fil.go

@@ -23,29 +23,6 @@ func (f FIL) Unitless() string {
 	return strings.TrimRight(strings.TrimRight(r.FloatString(18), "0"), ".")
 }
 
-var unitPrefixes = []string{"a", "f", "p", "n", "μ", "m"}
-
-func (f FIL) Short() string {
-	n := BigInt(f)
-
-	dn := uint64(1)
-	var prefix string
-	for _, p := range unitPrefixes {
-		if n.LessThan(NewInt(dn * 1000)) {
-			prefix = p
-			break
-		}
-		dn *= 1000
-	}
-
-	r := new(big.Rat).SetFrac(f.Int, big.NewInt(int64(dn)))
-	if r.Sign() == 0 {
-		return "0"
-	}
-
-	return strings.TrimRight(strings.TrimRight(r.FloatString(3), "0"), ".") + " " + prefix + "FIL"
-}
-
 func (f FIL) Format(s fmt.State, ch rune) {
 	switch ch {
 	case 's', 'v':

chain/types/fil_test.go

@@ -1,68 +0,0 @@
-package types
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/require"
-)
-
-func TestFilShort(t *testing.T) {
-	for _, s := range []struct {
-		fil    string
-		expect string
-	}{
-
-		{fil: "1", expect: "1 FIL"},
-		{fil: "1.1", expect: "1.1 FIL"},
-		{fil: "12", expect: "12 FIL"},
-		{fil: "123", expect: "123 FIL"},
-		{fil: "123456", expect: "123456 FIL"},
-		{fil: "123.23", expect: "123.23 FIL"},
-		{fil: "123456.234", expect: "123456.234 FIL"},
-		{fil: "123456.2341234", expect: "123456.234 FIL"},
-		{fil: "123456.234123445", expect: "123456.234 FIL"},
-
-		{fil: "0.1", expect: "100 mFIL"},
-		{fil: "0.01", expect: "10 mFIL"},
-		{fil: "0.001", expect: "1 mFIL"},
-
-		{fil: "0.0001", expect: "100 μFIL"},
-		{fil: "0.00001", expect: "10 μFIL"},
-		{fil: "0.000001", expect: "1 μFIL"},
-
-		{fil: "0.0000001", expect: "100 nFIL"},
-		{fil: "0.00000001", expect: "10 nFIL"},
-		{fil: "0.000000001", expect: "1 nFIL"},
-
-		{fil: "0.0000000001", expect: "100 pFIL"},
-		{fil: "0.00000000001", expect: "10 pFIL"},
-		{fil: "0.000000000001", expect: "1 pFIL"},
-
-		{fil: "0.0000000000001", expect: "100 fFIL"},
-		{fil: "0.00000000000001", expect: "10 fFIL"},
-		{fil: "0.000000000000001", expect: "1 fFIL"},
-
-		{fil: "0.0000000000000001", expect: "100 aFIL"},
-		{fil: "0.00000000000000001", expect: "10 aFIL"},
-		{fil: "0.000000000000000001", expect: "1 aFIL"},
-
-		{fil: "0.0000012", expect: "1.2 μFIL"},
-		{fil: "0.00000123", expect: "1.23 μFIL"},
-		{fil: "0.000001234", expect: "1.234 μFIL"},
-		{fil: "0.0000012344", expect: "1.234 μFIL"},
-		{fil: "0.00000123444", expect: "1.234 μFIL"},
-
-		{fil: "0.0002212", expect: "221.2 μFIL"},
-		{fil: "0.00022123", expect: "221.23 μFIL"},
-		{fil: "0.000221234", expect: "221.234 μFIL"},
-		{fil: "0.0002212344", expect: "221.234 μFIL"},
-		{fil: "0.00022123444", expect: "221.234 μFIL"},
-	} {
-		s := s
-		t.Run(s.fil, func(t *testing.T) {
-			f, err := ParseFIL(s.fil)
-			require.NoError(t, err)
-			require.Equal(t, s.expect, f.Short())
-		})
-	}
-}

chain/types/message.go

@@ -5,8 +5,6 @@ import (
 	"encoding/json"
 	"fmt"
 
-	"github.com/filecoin-project/go-state-types/network"
-
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/big"
 	"github.com/filecoin-project/lotus/build"
@@ -146,7 +144,7 @@ func (m *Message) EqualCall(o *Message) bool {
 	return (&m1).Equals(&m2)
 }
 
-func (m *Message) ValidForBlockInclusion(minGas int64, version network.Version) error {
+func (m *Message) ValidForBlockInclusion(minGas int64) error {
 	if m.Version != 0 {
 		return xerrors.New("'Version' unsupported")
 	}
@@ -155,10 +153,6 @@ func (m *Message) ValidForBlockInclusion(minGas int64, version network.Version)
 		return xerrors.New("'To' address cannot be empty")
 	}
 
-	if m.To == build.ZeroAddress && version >= network.Version7 {
-		return xerrors.New("invalid 'To' address")
-	}
-
 	if m.From == address.Undef {
 		return xerrors.New("'From' address cannot be empty")
 	}

chain/vm/burn.go

@@ -67,7 +67,7 @@ func ComputeGasOverestimationBurn(gasUsed, gasLimit int64) (int64, int64) {
 	return gasLimit - gasUsed - gasToBurn.Int64(), gasToBurn.Int64()
 }
 
-func ComputeGasOutputs(gasUsed, gasLimit int64, baseFee, feeCap, gasPremium abi.TokenAmount, chargeNetworkFee bool) GasOutputs {
+func ComputeGasOutputs(gasUsed, gasLimit int64, baseFee, feeCap, gasPremium abi.TokenAmount) GasOutputs {
 	gasUsedBig := big.NewInt(gasUsed)
 	out := ZeroGasOutputs()
 
@@ -76,12 +76,7 @@ func ComputeGasOutputs(gasUsed, gasLimit int64, baseFee, feeCap, gasPremium abi.
 		baseFeeToPay = feeCap
 		out.MinerPenalty = big.Mul(big.Sub(baseFee, feeCap), gasUsedBig)
 	}
-
-	// If chargeNetworkFee is disabled, just skip computing the BaseFeeBurn. However,
-	// we charge all the other fees regardless.
-	if chargeNetworkFee {
-		out.BaseFeeBurn = big.Mul(baseFeeToPay, gasUsedBig)
-	}
+	out.BaseFeeBurn = big.Mul(baseFeeToPay, gasUsedBig)
 
 	minerTip := gasPremium
 	if big.Cmp(big.Add(baseFeeToPay, minerTip), feeCap) > 0 {

chain/vm/burn_test.go

@@ -63,7 +63,7 @@ func TestGasOutputs(t *testing.T) {
 	for _, test := range tests {
 		test := test
 		t.Run(fmt.Sprintf("%v", test), func(t *testing.T) {
-			output := ComputeGasOutputs(test.used, test.limit, baseFee, types.NewInt(test.feeCap), types.NewInt(test.premium), true)
+			output := ComputeGasOutputs(test.used, test.limit, baseFee, types.NewInt(test.feeCap), types.NewInt(test.premium))
 			i2s := func(i uint64) string {
 				return fmt.Sprintf("%d", i)
 			}

chain/vm/gas.go

@@ -3,17 +3,21 @@ package vm
 import (
 	"fmt"
 
-	"github.com/filecoin-project/lotus/build"
+	vmr2 "github.com/filecoin-project/specs-actors/v2/actors/runtime"
+	proof2 "github.com/filecoin-project/specs-actors/v2/actors/runtime/proof"
 
 	"github.com/filecoin-project/go-address"
 	addr "github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/crypto"
-	vmr2 "github.com/filecoin-project/specs-actors/v2/actors/runtime"
-	proof2 "github.com/filecoin-project/specs-actors/v2/actors/runtime/proof"
 	"github.com/ipfs/go-cid"
 )
 
+const (
+	GasStorageMulti = 1000
+	GasComputeMulti = 1
+)
+
 type GasCharge struct {
 	Name  string
 	Extra interface{}
@@ -128,54 +132,6 @@ var prices = map[abi.ChainEpoch]Pricelist{
 		verifyPostDiscount:   true,
 		verifyConsensusFault: 495422,
 	},
-	abi.ChainEpoch(build.UpgradeCalicoHeight): &pricelistV0{
-		computeGasMulti: 1,
-		storageGasMulti: 1300,
-
-		onChainMessageComputeBase:    38863,
-		onChainMessageStorageBase:    36,
-		onChainMessageStoragePerByte: 1,
-
-		onChainReturnValuePerByte: 1,
-
-		sendBase:                29233,
-		sendTransferFunds:       27500,
-		sendTransferOnlyPremium: 159672,
-		sendInvokeMethod:        -5377,
-
-		ipldGetBase:    114617,
-		ipldPutBase:    353640,
-		ipldPutPerByte: 1,
-
-		createActorCompute: 1108454,
-		createActorStorage: 36 + 40,
-		deleteActor:        -(36 + 40), // -createActorStorage
-
-		verifySignature: map[crypto.SigType]int64{
-			crypto.SigTypeBLS:       16598605,
-			crypto.SigTypeSecp256k1: 1637292,
-		},
-
-		hashingBase:                  31355,
-		computeUnsealedSectorCidBase: 98647,
-		verifySealBase:               2000, // TODO gas , it VerifySeal syscall is not used
-		verifyPostLookup: map[abi.RegisteredPoStProof]scalingCost{
-			abi.RegisteredPoStProof_StackedDrgWindow512MiBV1: {
-				flat:  117680921,
-				scale: 43780,
-			},
-			abi.RegisteredPoStProof_StackedDrgWindow32GiBV1: {
-				flat:  117680921,
-				scale: 43780,
-			},
-			abi.RegisteredPoStProof_StackedDrgWindow64GiBV1: {
-				flat:  117680921,
-				scale: 43780,
-			},
-		},
-		verifyPostDiscount:   false,
-		verifyConsensusFault: 495422,
-	},
 }
 
 // PricelistByEpoch finds the latest prices for the given epoch

chain/vm/gas_v0.go

@@ -133,13 +133,13 @@ func (pl *pricelistV0) OnMethodInvocation(value abi.TokenAmount, methodNum abi.M
 
 // OnIpldGet returns the gas used for storing an object
 func (pl *pricelistV0) OnIpldGet() GasCharge {
-	return newGasCharge("OnIpldGet", pl.ipldGetBase, 0).WithVirtual(114617, 0)
+	return newGasCharge("OnIpldGet", pl.ipldGetBase, 0)
 }
 
 // OnIpldPut returns the gas used for storing an object
 func (pl *pricelistV0) OnIpldPut(dataSize int) GasCharge {
 	return newGasCharge("OnIpldPut", pl.ipldPutBase, int64(dataSize)*pl.ipldPutPerByte*pl.storageGasMulti).
-		WithExtra(dataSize).WithVirtual(400000, int64(dataSize)*1300)
+		WithExtra(dataSize)
 }
 
 // OnCreateActor returns the gas used for creating an actor
@@ -209,7 +209,6 @@ func (pl *pricelistV0) OnVerifyPost(info proof2.WindowPoStVerifyInfo) GasCharge
 	}
 
 	return newGasCharge("OnVerifyPost", gasUsed, 0).
-		WithVirtual(117680921+43780*int64(len(info.ChallengedSectors)), 0).
 		WithExtra(map[string]interface{}{
 			"type": sectorSize,
 			"size": len(info.ChallengedSectors),

chain/vm/invoker.go

@@ -6,8 +6,6 @@ import (
 	"fmt"
 	"reflect"
 
-	"github.com/filecoin-project/go-state-types/network"
-
 	"github.com/filecoin-project/lotus/chain/actors/builtin"
 
 	"github.com/ipfs/go-cid"
@@ -36,9 +34,9 @@ type ActorPredicate func(vmr.Runtime, rtt.VMActor) error
 
 func ActorsVersionPredicate(ver actors.Version) ActorPredicate {
 	return func(rt vmr.Runtime, v rtt.VMActor) error {
-		aver := actors.VersionForNetwork(rt.NetworkVersion())
-		if aver != ver {
-			return xerrors.Errorf("actor %s is a version %d actor; chain only supports actor version %d at height %d and nver %d", v.Code(), ver, aver, rt.CurrEpoch(), rt.NetworkVersion())
+		nver := actors.VersionForNetwork(rt.NetworkVersion())
+		if nver != ver {
+			return xerrors.Errorf("actor %s is a version %d actor; chain only supports actor version %d at height %d", v.Code(), ver, nver, rt.CurrEpoch())
 		}
 		return nil
 	}
@@ -175,14 +173,9 @@ func (*ActorRegistry) transform(instance invokee) (nativeCode, error) {
 				paramT := meth.Type().In(1).Elem()
 				param := reflect.New(paramT)
 
-				rt := in[0].Interface().(*Runtime)
 				inBytes := in[1].Interface().([]byte)
 				if err := DecodeParams(inBytes, param.Interface()); err != nil {
-					ec := exitcode.ErrSerialization
-					if rt.NetworkVersion() < network.Version7 {
-						ec = 1
-					}
-					aerr := aerrors.Absorb(err, ec, "failed to decode parameters")
+					aerr := aerrors.Absorb(err, 1, "failed to decode parameters")
 					return []reflect.Value{
 						reflect.ValueOf([]byte{}),
 						// Below is a hack, fixed in Go 1.13
@@ -190,6 +183,7 @@ func (*ActorRegistry) transform(instance invokee) (nativeCode, error) {
 						reflect.ValueOf(&aerr).Elem(),
 					}
 				}
+				rt := in[0].Interface().(*Runtime)
 				rval, aerror := rt.shimCall(func() interface{} {
 					ret := meth.Call([]reflect.Value{
 						reflect.ValueOf(rt),

chain/vm/invoker_test.go

@@ -1,13 +1,10 @@
 package vm
 
 import (
-	"context"
 	"fmt"
 	"io"
 	"testing"
 
-	"github.com/filecoin-project/go-state-types/network"
-
 	cbor "github.com/ipfs/go-ipld-cbor"
 	"github.com/stretchr/testify/assert"
 	cbg "github.com/whyrusleeping/cbor-gen"
@@ -108,27 +105,10 @@ func TestInvokerBasic(t *testing.T) {
 		}
 	}
 
-	{
-		_, aerr := code[1](&Runtime{
-			vm: &VM{ntwkVersion: func(ctx context.Context, epoch abi.ChainEpoch) network.Version {
-				return network.Version0
-			}},
-		}, []byte{99})
-		if aerrors.IsFatal(aerr) {
-			t.Fatal("err should not be fatal")
-		}
-		assert.Equal(t, exitcode.ExitCode(1), aerrors.RetCode(aerr), "return code should be 1")
+	_, aerr := code[1](&Runtime{}, []byte{99})
+	if aerrors.IsFatal(aerr) {
+		t.Fatal("err should not be fatal")
 	}
+	assert.Equal(t, exitcode.ExitCode(1), aerrors.RetCode(aerr), "return code should be 1")
 
-	{
-		_, aerr := code[1](&Runtime{
-			vm: &VM{ntwkVersion: func(ctx context.Context, epoch abi.ChainEpoch) network.Version {
-				return network.Version7
-			}},
-		}, []byte{99})
-		if aerrors.IsFatal(aerr) {
-			t.Fatal("err should not be fatal")
-		}
-		assert.Equal(t, exitcode.ErrSerialization, aerrors.RetCode(aerr), "return code should be %s", 1)
-	}
 }

chain/vm/runtime.go

@@ -5,7 +5,6 @@ import (
 	"context"
 	"encoding/binary"
 	"fmt"
-	gruntime "runtime"
 	"time"
 
 	"github.com/filecoin-project/go-address"
@@ -245,23 +244,20 @@ func (rt *Runtime) NewActorAddress() address.Address {
 	return addr
 }
 
-func (rt *Runtime) CreateActor(codeID cid.Cid, addr address.Address) {
-	if addr == address.Undef && rt.NetworkVersion() >= network.Version7 {
-		rt.Abortf(exitcode.SysErrorIllegalArgument, "CreateActor with Undef address")
-	}
+func (rt *Runtime) CreateActor(codeID cid.Cid, address address.Address) {
 	act, aerr := rt.vm.areg.Create(codeID, rt)
 	if aerr != nil {
 		rt.Abortf(aerr.RetCode(), aerr.Error())
 	}
 
-	_, err := rt.state.GetActor(addr)
+	_, err := rt.state.GetActor(address)
 	if err == nil {
 		rt.Abortf(exitcode.SysErrorIllegalArgument, "Actor address already exists")
 	}
 
 	rt.chargeGas(rt.Pricelist().OnCreateActor())
 
-	err = rt.state.SetActor(addr, act)
+	err = rt.state.SetActor(address, act)
 	if err != nil {
 		panic(aerrors.Fatalf("creating actor entry: %v", err))
 	}
@@ -270,7 +266,7 @@ func (rt *Runtime) CreateActor(codeID cid.Cid, addr address.Address) {
 
 // DeleteActor deletes the executing actor from the state tree, transferring
 // any balance to beneficiary.
-// Aborts if the beneficiary does not exist or is the calling actor.
+// Aborts if the beneficiary does not exist.
 // May only be called by the actor itself.
 func (rt *Runtime) DeleteActor(beneficiary address.Address) {
 	rt.chargeGas(rt.Pricelist().OnDeleteActor())
@@ -282,19 +278,6 @@ func (rt *Runtime) DeleteActor(beneficiary address.Address) {
 		panic(aerrors.Fatalf("failed to get actor: %s", err))
 	}
 	if !act.Balance.IsZero() {
-		// TODO: Should be safe to drop the version-check,
-		//  since only the paych actor called this pre-version 7, but let's leave it for now
-		if rt.NetworkVersion() >= network.Version7 {
-			beneficiaryId, found := rt.ResolveAddress(beneficiary)
-			if !found {
-				rt.Abortf(exitcode.SysErrorIllegalArgument, "beneficiary doesn't exist")
-			}
-
-			if beneficiaryId == rt.Receiver() {
-				rt.Abortf(exitcode.SysErrorIllegalArgument, "benefactor cannot be beneficiary")
-			}
-		}
-
 		// Transfer the executing actor's balance to the beneficiary
 		if err := rt.vm.transfer(rt.Receiver(), beneficiary, act.Balance); err != nil {
 			panic(aerrors.Fatalf("failed to transfer balance to beneficiary actor: %s", err))
@@ -535,7 +518,7 @@ func (rt *Runtime) chargeGasInternal(gas GasCharge, skip int) aerrors.ActorError
 	if EnableGasTracing {
 		var callers [10]uintptr
 
-		cout := gruntime.Callers(2+skip, callers[:])
+		cout := 0 //gruntime.Callers(2+skip, callers[:])
 
 		now := build.Clock.Now()
 		if rt.lastGasCharge != nil {
@@ -550,19 +533,12 @@ func (rt *Runtime) chargeGasInternal(gas GasCharge, skip int) aerrors.ActorError
 			ComputeGas: gas.ComputeGas,
 			StorageGas: gas.StorageGas,
 
+			TotalVirtualGas:   gas.VirtualCompute*GasComputeMulti + gas.VirtualStorage*GasStorageMulti,
 			VirtualComputeGas: gas.VirtualCompute,
 			VirtualStorageGas: gas.VirtualStorage,
 
 			Callers: callers[:cout],
 		}
-		if gasTrace.VirtualStorageGas == 0 {
-			gasTrace.VirtualStorageGas = gasTrace.StorageGas
-		}
-		if gasTrace.VirtualComputeGas == 0 {
-			gasTrace.VirtualComputeGas = gasTrace.ComputeGas
-		}
-		gasTrace.TotalVirtualGas = gasTrace.VirtualComputeGas + gasTrace.VirtualStorageGas
-
 		rt.executionTrace.GasCharges = append(rt.executionTrace.GasCharges, &gasTrace)
 		rt.lastGasChargeTime = now
 		rt.lastGasCharge = &gasTrace

chain/vm/syscalls.go

@@ -7,26 +7,25 @@ import (
 	goruntime "runtime"
 	"sync"
 
+	"github.com/filecoin-project/go-address"
 	"github.com/ipfs/go-cid"
 	cbor "github.com/ipfs/go-ipld-cbor"
 	"github.com/minio/blake2b-simd"
 	mh "github.com/multiformats/go-multihash"
 	"golang.org/x/xerrors"
 
-	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/crypto"
-	"github.com/filecoin-project/go-state-types/network"
 	"github.com/filecoin-project/lotus/chain/actors/adt"
 	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
-	"github.com/filecoin-project/lotus/chain/actors/policy"
 	"github.com/filecoin-project/lotus/chain/state"
 	"github.com/filecoin-project/lotus/chain/types"
-	"github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper"
 	"github.com/filecoin-project/lotus/lib/sigs"
 
 	runtime2 "github.com/filecoin-project/specs-actors/v2/actors/runtime"
 	proof2 "github.com/filecoin-project/specs-actors/v2/actors/runtime/proof"
+
+	"github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper"
 )
 
 func init() {
@@ -41,9 +40,7 @@ func Syscalls(verifier ffiwrapper.Verifier) SyscallBuilder {
 	return func(ctx context.Context, rt *Runtime) runtime2.Syscalls {
 
 		return &syscallShim{
-			ctx:            ctx,
-			epoch:          rt.CurrEpoch(),
-			networkVersion: rt.NetworkVersion(),
+			ctx: ctx,
 
 			actor:   rt.Receiver(),
 			cstate:  rt.state,
@@ -58,13 +55,11 @@ func Syscalls(verifier ffiwrapper.Verifier) SyscallBuilder {
 type syscallShim struct {
 	ctx context.Context
 
-	epoch          abi.ChainEpoch
-	networkVersion network.Version
-	lbState        LookbackStateGetter
-	actor          address.Address
-	cstate         *state.StateTree
-	cst            cbor.IpldStore
-	verifier       ffiwrapper.Verifier
+	lbState  LookbackStateGetter
+	actor    address.Address
+	cstate   *state.StateTree
+	cst      cbor.IpldStore
+	verifier ffiwrapper.Verifier
 }
 
 func (ss *syscallShim) ComputeUnsealedSectorCID(st abi.RegisteredSealProof, pieces []abi.PieceInfo) (cid.Cid, error) {
@@ -207,10 +202,6 @@ func (ss *syscallShim) VerifyBlockSig(blk *types.BlockHeader) error {
 }
 
 func (ss *syscallShim) workerKeyAtLookback(height abi.ChainEpoch) (address.Address, error) {
-	if ss.networkVersion >= network.Version7 && height < ss.epoch-policy.ChainFinality {
-		return address.Undef, xerrors.Errorf("cannot get worker key (currEpoch %d, height %d)", ss.epoch, height)
-	}
-
 	lbState, err := ss.lbState(ss.ctx, height)
 	if err != nil {
 		return address.Undef, err
@@ -303,7 +294,7 @@ func (ss *syscallShim) BatchVerifySeals(inp map[address.Address][]proof2.SealVer
 				sema <- struct{}{}
 
 				if err := ss.VerifySeal(svi); err != nil {
-					log.Warnw("seal verify in batch failed", "miner", ma, "sectorNumber", svi.SectorID.Number, "err", err)
+					log.Warnw("seal verify in batch failed", "miner", ma, "index", ix, "err", err)
 					res[ix] = false
 				} else {
 					res[ix] = true

chain/vm/vm.go

@@ -9,7 +9,6 @@ import (
 	"time"
 
 	"github.com/filecoin-project/lotus/chain/actors/builtin"
-	"github.com/filecoin-project/lotus/metrics"
 
 	block "github.com/ipfs/go-block-format"
 	cid "github.com/ipfs/go-cid"
@@ -17,7 +16,6 @@ import (
 	logging "github.com/ipfs/go-log/v2"
 	mh "github.com/multiformats/go-multihash"
 	cbg "github.com/whyrusleeping/cbor-gen"
-	"go.opencensus.io/stats"
 	"go.opencensus.io/trace"
 	"golang.org/x/xerrors"
 
@@ -32,7 +30,6 @@ import (
 	"github.com/filecoin-project/lotus/chain/actors/adt"
 	"github.com/filecoin-project/lotus/chain/actors/aerrors"
 	"github.com/filecoin-project/lotus/chain/actors/builtin/account"
-	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
 	"github.com/filecoin-project/lotus/chain/actors/builtin/reward"
 	"github.com/filecoin-project/lotus/chain/state"
 	"github.com/filecoin-project/lotus/chain/types"
@@ -141,10 +138,6 @@ func (vm *VM) makeRuntime(ctx context.Context, msg *types.Message, parent *Runti
 	}
 
 	if parent != nil {
-		// TODO: The version check here should be unnecessary, but we can wait to take it out
-		if !parent.allowInternal && rt.NetworkVersion() >= network.Version7 {
-			rt.Abortf(exitcode.SysErrForbidden, "internal calls currently disabled")
-		}
 		rt.gasUsed = parent.gasUsed
 		rt.origin = parent.origin
 		rt.originNonce = parent.originNonce
@@ -562,13 +555,7 @@ func (vm *VM) ApplyMessage(ctx context.Context, cmsg types.ChainMsg) (*ApplyRet,
 	if gasUsed < 0 {
 		gasUsed = 0
 	}
-
-	burn, err := vm.shouldBurn(st, msg, errcode)
-	if err != nil {
-		return nil, xerrors.Errorf("deciding whether should burn failed: %w", err)
-	}
-
-	gasOutputs := ComputeGasOutputs(gasUsed, msg.GasLimit, vm.baseFee, msg.GasFeeCap, msg.GasPremium, burn)
+	gasOutputs := ComputeGasOutputs(gasUsed, msg.GasLimit, vm.baseFee, msg.GasFeeCap, msg.GasPremium)
 
 	if err := vm.transferFromGasHolder(builtin.BurntFundsActorAddr, gasHolder,
 		gasOutputs.BaseFeeBurn); err != nil {
@@ -606,29 +593,6 @@ func (vm *VM) ApplyMessage(ctx context.Context, cmsg types.ChainMsg) (*ApplyRet,
 	}, nil
 }
 
-func (vm *VM) shouldBurn(st *state.StateTree, msg *types.Message, errcode exitcode.ExitCode) (bool, error) {
-	// Check to see if we should burn funds. We avoid burning on successful
-	// window post. This won't catch _indirect_ window post calls, but this
-	// is the best we can get for now.
-	if vm.blockHeight > build.UpgradeClausHeight && errcode == exitcode.Ok && msg.Method == miner.Methods.SubmitWindowedPoSt {
-		// Ok, we've checked the _method_, but we still need to check
-		// the target actor. It would be nice if we could just look at
-		// the trace, but I'm not sure if that's safe?
-		if toActor, err := st.GetActor(msg.To); err != nil {
-			// If the actor wasn't found, we probably deleted it or something. Move on.
-			if !xerrors.Is(err, types.ErrActorNotFound) {
-				// Otherwise, this should never fail and something is very wrong.
-				return false, xerrors.Errorf("failed to lookup target actor: %w", err)
-			}
-		} else if builtin.IsStorageMinerActor(toActor.Code) {
-			// Ok, this is a storage miner and we've processed a window post. Remove the burn.
-			return false, nil
-		}
-	}
-
-	return true, nil
-}
-
 func (vm *VM) ActorBalance(addr address.Address) (types.BigInt, aerrors.ActorError) {
 	act, err := vm.cstate.GetActor(addr)
 	if err != nil {
@@ -638,8 +602,6 @@ func (vm *VM) ActorBalance(addr address.Address) (types.BigInt, aerrors.ActorErr
 	return act.Balance, nil
 }
 
-type vmFlushKey struct{}
-
 func (vm *VM) Flush(ctx context.Context) (cid.Cid, error) {
 	_, span := trace.StartSpan(ctx, "vm.Flush")
 	defer span.End()
@@ -652,7 +614,7 @@ func (vm *VM) Flush(ctx context.Context) (cid.Cid, error) {
 		return cid.Undef, xerrors.Errorf("flushing vm: %w", err)
 	}
 
-	if err := Copy(context.WithValue(ctx, vmFlushKey{}, true), from, to, root); err != nil {
+	if err := Copy(ctx, from, to, root); err != nil {
 		return cid.Undef, xerrors.Errorf("copying tree: %w", err)
 	}
 
@@ -709,48 +671,21 @@ func linksForObj(blk block.Block, cb func(cid.Cid)) error {
 func Copy(ctx context.Context, from, to blockstore.Blockstore, root cid.Cid) error {
 	ctx, span := trace.StartSpan(ctx, "vm.Copy") // nolint
 	defer span.End()
-	start := time.Now()
 
 	var numBlocks int
 	var totalCopySize int
 
-	const batchSize = 128
-	const bufCount = 3
-	freeBufs := make(chan []block.Block, bufCount)
-	toFlush := make(chan []block.Block, bufCount)
-	for i := 0; i < bufCount; i++ {
-		freeBufs <- make([]block.Block, 0, batchSize)
-	}
-
-	errFlushChan := make(chan error)
-
-	go func() {
-		for b := range toFlush {
-			if err := to.PutMany(b); err != nil {
-				close(freeBufs)
-				errFlushChan <- xerrors.Errorf("batch put in copy: %w", err)
-				return
-			}
-			freeBufs <- b[:0]
-		}
-		close(errFlushChan)
-		close(freeBufs)
-	}()
-
-	var batch = <-freeBufs
+	var batch []block.Block
 	batchCp := func(blk block.Block) error {
 		numBlocks++
 		totalCopySize += len(blk.RawData())
 
 		batch = append(batch, blk)
-
-		if len(batch) >= batchSize {
-			toFlush <- batch
-			var ok bool
-			batch, ok = <-freeBufs
-			if !ok {
-				return <-errFlushChan
+		if len(batch) > 100 {
+			if err := to.PutMany(batch); err != nil {
+				return xerrors.Errorf("batch put in copy: %w", err)
 			}
+			batch = batch[:0]
 		}
 		return nil
 	}
@@ -760,22 +695,15 @@ func Copy(ctx context.Context, from, to blockstore.Blockstore, root cid.Cid) err
 	}
 
 	if len(batch) > 0 {
-		toFlush <- batch
-	}
-	close(toFlush)        // close the toFlush triggering the loop to end
-	err := <-errFlushChan // get error out or get nil if it was closed
-	if err != nil {
-		return err
+		if err := to.PutMany(batch); err != nil {
+			return xerrors.Errorf("batch put in copy: %w", err)
+		}
 	}
 
 	span.AddAttributes(
 		trace.Int64Attribute("numBlocks", int64(numBlocks)),
 		trace.Int64Attribute("copySize", int64(totalCopySize)),
 	)
-	if yes, ok := ctx.Value(vmFlushKey{}).(bool); yes && ok {
-		took := metrics.SinceInMilliseconds(start)
-		stats.Record(ctx, metrics.VMFlushCopyCount.M(int64(numBlocks)), metrics.VMFlushCopyDuration.M(took))
-	}
 
 	return nil
 }

chain/wallet/wallet.go

@@ -6,16 +6,18 @@ import (
 	"strings"
 	"sync"
 
-	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/crypto"
 	logging "github.com/ipfs/go-log/v2"
 	"golang.org/x/xerrors"
 
+	"github.com/filecoin-project/go-address"
+
 	"github.com/filecoin-project/lotus/api"
-	"github.com/filecoin-project/lotus/chain/types"
-	"github.com/filecoin-project/lotus/lib/sigs"
 	_ "github.com/filecoin-project/lotus/lib/sigs/bls"  // enable bls signatures
 	_ "github.com/filecoin-project/lotus/lib/sigs/secp" // enable secp signatures
+
+	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/lib/sigs"
 )
 
 var log = logging.Logger("wallet")
@@ -268,7 +270,7 @@ func (w *LocalWallet) WalletHas(ctx context.Context, addr address.Address) (bool
 	return k != nil, nil
 }
 
-func (w *LocalWallet) walletDelete(ctx context.Context, addr address.Address) error {
+func (w *LocalWallet) WalletDelete(ctx context.Context, addr address.Address) error {
 	k, err := w.findKey(addr)
 
 	if err != nil {
@@ -303,29 +305,18 @@ func (w *LocalWallet) walletDelete(ctx context.Context, addr address.Address) er
 
 	delete(w.keys, addr)
 
-	return nil
-}
+	def, err := w.GetDefault()
+	if err != nil {
+		return xerrors.Errorf("getting default address: %w", err)
+	}
 
-func (w *LocalWallet) deleteDefault() {
-	w.lk.Lock()
-	defer w.lk.Unlock()
-	if err := w.keystore.Delete(KDefault); err != nil {
-		if !xerrors.Is(err, types.ErrKeyInfoNotFound) {
-			log.Warnf("failed to unregister current default key: %s", err)
+	if def == addr {
+		err = w.SetDefault(address.Undef)
+		if err != nil {
+			return xerrors.Errorf("unsetting default address: %w", err)
 		}
 	}
-}
 
-func (w *LocalWallet) WalletDelete(ctx context.Context, addr address.Address) error {
-	if err := w.walletDelete(ctx, addr); err != nil {
-		return xerrors.Errorf("wallet delete: %w", err)
-	}
-
-	if def, err := w.GetDefault(); err == nil {
-		if def == addr {
-			w.deleteDefault()
-		}
-	}
 	return nil
 }
 

cli/chain.go

@@ -466,9 +466,6 @@ var chainInspectUsage = &cli.Command{
 
 			code, err := lookupActorCode(m.Message.To)
 			if err != nil {
-				if strings.Contains(err.Error(), types.ErrActorNotFound.Error()) {
-					continue
-				}
 				return err
 			}
 

cli/client.go

@@ -326,9 +326,9 @@ var clientDealCmd = &cli.Command{
 			Value: true,
 		},
 		&cli.BoolFlag{
-			Name:        "verified-deal",
-			Usage:       "indicate that the deal counts towards verified client total",
-			DefaultText: "true if client is verified, false otherwise",
+			Name:  "verified-deal",
+			Usage: "indicate that the deal counts towards verified client total",
+			Value: false,
 		},
 		&cli.StringFlag{
 			Name:  "provider-collateral",
@@ -655,19 +655,19 @@ uiLoop:
 				state = "find"
 			}
 		case "find":
-			asks, err := GetAsks(ctx, api)
+			asks, err := getAsks(ctx, api)
 			if err != nil {
 				return err
 			}
 
 			for _, ask := range asks {
-				if ask.Ask.MinPieceSize > ds.PieceSize {
+				if ask.MinPieceSize > ds.PieceSize {
 					continue
 				}
-				if ask.Ask.MaxPieceSize < ds.PieceSize {
+				if ask.MaxPieceSize < ds.PieceSize {
 					continue
 				}
-				candidateAsks = append(candidateAsks, ask.Ask)
+				candidateAsks = append(candidateAsks, ask)
 			}
 
 			afmt.Printf("Found %d candidate asks\n", len(candidateAsks))
@@ -1191,11 +1191,6 @@ var clientDealStatsCmd = &cli.Command{
 var clientListAsksCmd = &cli.Command{
 	Name:  "list-asks",
 	Usage: "List asks for top miners",
-	Flags: []cli.Flag{
-		&cli.BoolFlag{
-			Name: "by-ping",
-		},
-	},
 	Action: func(cctx *cli.Context) error {
 		api, closer, err := GetFullNodeAPI(cctx)
 		if err != nil {
@@ -1204,26 +1199,17 @@ var clientListAsksCmd = &cli.Command{
 		defer closer()
 		ctx := ReqContext(cctx)
 
-		asks, err := GetAsks(ctx, api)
+		asks, err := getAsks(ctx, api)
 		if err != nil {
 			return err
 		}
 
-		if cctx.Bool("by-ping") {
-			sort.Slice(asks, func(i, j int) bool {
-				return asks[i].Ping < asks[j].Ping
-			})
-		}
-
-		for _, a := range asks {
-			ask := a.Ask
-
-			fmt.Printf("%s: min:%s max:%s price:%s/GiB/Epoch verifiedPrice:%s/GiB/Epoch ping:%s\n", ask.Miner,
+		for _, ask := range asks {
+			fmt.Printf("%s: min:%s max:%s price:%s/GiB/Epoch verifiedPrice:%s/GiB/Epoch\n", ask.Miner,
 				types.SizeStr(types.NewInt(uint64(ask.MinPieceSize))),
 				types.SizeStr(types.NewInt(uint64(ask.MaxPieceSize))),
 				types.FIL(ask.Price),
 				types.FIL(ask.VerifiedPrice),
-				a.Ping,
 			)
 		}
 
@@ -1231,12 +1217,7 @@ var clientListAsksCmd = &cli.Command{
 	},
 }
 
-type QueriedAsk struct {
-	Ask  *storagemarket.StorageAsk
-	Ping time.Duration
-}
-
-func GetAsks(ctx context.Context, api lapi.FullNode) ([]QueriedAsk, error) {
+func getAsks(ctx context.Context, api lapi.FullNode) ([]*storagemarket.StorageAsk, error) {
 	color.Blue(".. getting miner list")
 	miners, err := api.StateListMiners(ctx, types.EmptyTSK)
 	if err != nil {
@@ -1291,7 +1272,7 @@ loop:
 
 	color.Blue(".. querying asks")
 
-	var asks []QueriedAsk
+	var asks []*storagemarket.StorageAsk
 	var queried, got int64
 
 	done = make(chan struct{})
@@ -1327,19 +1308,9 @@ loop:
 					return
 				}
 
-				rt := time.Now()
-
-				_, err = api.ClientQueryAsk(ctx, *mi.PeerId, miner)
-				if err != nil {
-					return
-				}
-
 				atomic.AddInt64(&got, 1)
 				lk.Lock()
-				asks = append(asks, QueriedAsk{
-					Ask:  ask,
-					Ping: time.Now().Sub(rt),
-				})
+				asks = append(asks, ask)
 				lk.Unlock()
 			}(miner)
 		}
@@ -1357,7 +1328,7 @@ loop2:
 	fmt.Printf("\r* Queried %d asks, got %d responses\n", atomic.LoadInt64(&queried), atomic.LoadInt64(&got))
 
 	sort.Slice(asks, func(i, j int) bool {
-		return asks[i].Ask.Price.LessThan(asks[j].Ask.Price)
+		return asks[i].Price.LessThan(asks[j].Price)
 	})
 
 	return asks, nil
@@ -1429,7 +1400,6 @@ var clientQueryAskCmd = &cli.Command{
 		afmt.Printf("Price per GiB: %s\n", types.FIL(ask.Price))
 		afmt.Printf("Verified Price per GiB: %s\n", types.FIL(ask.VerifiedPrice))
 		afmt.Printf("Max Piece size: %s\n", types.SizeStr(types.NewInt(uint64(ask.MaxPieceSize))))
-		afmt.Printf("Min Piece size: %s\n", types.SizeStr(types.NewInt(uint64(ask.MinPieceSize))))
 
 		size := cctx.Int64("size")
 		if size == 0 {
@@ -1525,7 +1495,7 @@ var clientListDeals = &cli.Command{
 			}
 		}
 
-		return outputStorageDeals(ctx, cctx.App.Writer, api, localDeals, verbose, color, showFailed)
+		return outputStorageDeals(ctx, cctx.App.Writer, api, localDeals, cctx.Bool("verbose"), cctx.Bool("color"), showFailed)
 	},
 }
 
@@ -1567,7 +1537,7 @@ func outputStorageDeals(ctx context.Context, out io.Writer, full lapi.FullNode,
 
 	if verbose {
 		w := tabwriter.NewWriter(out, 2, 4, 2, ' ', 0)
-		fmt.Fprintf(w, "Created\tDealCid\tDealId\tProvider\tState\tOn Chain?\tSlashed?\tPieceCID\tSize\tPrice\tDuration\tTransferChannelID\tTransferStatus\tVerified\tMessage\n")
+		fmt.Fprintf(w, "Created\tDealCid\tDealId\tProvider\tState\tOn Chain?\tSlashed?\tPieceCID\tSize\tPrice\tDuration\tVerified\tMessage\n")
 		for _, d := range deals {
 			onChain := "N"
 			if d.OnChainDealState.SectorStartEpoch != -1 {
@@ -1580,37 +1550,7 @@ func outputStorageDeals(ctx context.Context, out io.Writer, full lapi.FullNode,
 			}
 
 			price := types.FIL(types.BigMul(d.LocalDeal.PricePerEpoch, types.NewInt(d.LocalDeal.Duration)))
-			transferChannelID := ""
-			if d.LocalDeal.TransferChannelID != nil {
-				transferChannelID = d.LocalDeal.TransferChannelID.String()
-			}
-			transferStatus := ""
-			if d.LocalDeal.DataTransfer != nil {
-				transferStatus = datatransfer.Statuses[d.LocalDeal.DataTransfer.Status]
-				// TODO: Include the transferred percentage once this bug is fixed:
-				// https://github.com/ipfs/go-graphsync/issues/126
-				//fmt.Printf("transferred: %d / size: %d\n", d.LocalDeal.DataTransfer.Transferred, d.LocalDeal.Size)
-				//if d.LocalDeal.Size > 0 {
-				//	pct := (100 * d.LocalDeal.DataTransfer.Transferred) / d.LocalDeal.Size
-				//	transferPct = fmt.Sprintf("%d%%", pct)
-				//}
-			}
-			fmt.Fprintf(w, "%s\t%s\t%d\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%d\t%s\t%s\t%v\t%s\n",
-				d.LocalDeal.CreationTime.Format(time.Stamp),
-				d.LocalDeal.ProposalCid,
-				d.LocalDeal.DealID,
-				d.LocalDeal.Provider,
-				dealStateString(color, d.LocalDeal.State),
-				onChain,
-				slashed,
-				d.LocalDeal.PieceCID,
-				types.SizeStr(types.NewInt(d.LocalDeal.Size)),
-				price,
-				d.LocalDeal.Duration,
-				transferChannelID,
-				transferStatus,
-				d.LocalDeal.Verified,
-				d.LocalDeal.Message)
+			fmt.Fprintf(w, "%s\t%s\t%d\t%s\t%s\t%s\t%s\t%s\t%s\t%s\t%d\t%v\t%s\n", d.LocalDeal.CreationTime.Format(time.Stamp), d.LocalDeal.ProposalCid, d.LocalDeal.DealID, d.LocalDeal.Provider, dealStateString(color, d.LocalDeal.State), onChain, slashed, d.LocalDeal.PieceCID, types.SizeStr(types.NewInt(d.LocalDeal.Size)), price, d.LocalDeal.Duration, d.LocalDeal.Verified, d.LocalDeal.Message)
 		}
 		return w.Flush()
 	}
@@ -1885,11 +1825,6 @@ var clientCancelTransfer = &cli.Command{
 			Usage: "specify only transfers where peer is/is not initiator",
 			Value: true,
 		},
-		&cli.DurationFlag{
-			Name:  "cancel-timeout",
-			Usage: "time to wait for cancel to be sent to storage provider",
-			Value: 5 * time.Second,
-		},
 	},
 	Action: func(cctx *cli.Context) error {
 		if !cctx.Args().Present() {
@@ -1933,9 +1868,7 @@ var clientCancelTransfer = &cli.Command{
 			}
 		}
 
-		timeoutCtx, cancel := context.WithTimeout(ctx, cctx.Duration("cancel-timeout"))
-		defer cancel()
-		return api.ClientCancelDataTransfer(timeoutCtx, transferID, other, initiator)
+		return api.ClientCancelDataTransfer(ctx, transferID, other, initiator)
 	},
 }
 

cli/mpool.go

@@ -49,14 +49,6 @@ var mpoolPending = &cli.Command{
 			Name:  "cids",
 			Usage: "only print cids of messages in output",
 		},
-		&cli.StringFlag{
-			Name:  "to",
-			Usage: "return messages to a given address",
-		},
-		&cli.StringFlag{
-			Name:  "from",
-			Usage: "return messages from a given address",
-		},
 	},
 	Action: func(cctx *cli.Context) error {
 		api, closer, err := GetFullNodeAPI(cctx)
@@ -67,23 +59,6 @@ var mpoolPending = &cli.Command{
 
 		ctx := ReqContext(cctx)
 
-		var toa, froma address.Address
-		if tos := cctx.String("to"); tos != "" {
-			a, err := address.NewFromString(tos)
-			if err != nil {
-				return fmt.Errorf("given 'to' address %q was invalid: %w", tos, err)
-			}
-			toa = a
-		}
-
-		if froms := cctx.String("from"); froms != "" {
-			a, err := address.NewFromString(froms)
-			if err != nil {
-				return fmt.Errorf("given 'from' address %q was invalid: %w", froms, err)
-			}
-			froma = a
-		}
-
 		var filter map[address.Address]struct{}
 		if cctx.Bool("local") {
 			filter = map[address.Address]struct{}{}
@@ -110,13 +85,6 @@ var mpoolPending = &cli.Command{
 				}
 			}
 
-			if toa != address.Undef && msg.Message.To != toa {
-				continue
-			}
-			if froma != address.Undef && msg.Message.From != froma {
-				continue
-			}
-
 			if cctx.Bool("cids") {
 				fmt.Println(msg.Cid())
 			} else {
@@ -265,7 +233,6 @@ var mpoolStat = &cli.Command{
 			addr                 string
 			past, cur, future    uint64
 			belowCurr, belowPast uint64
-			gasLimit             big.Int
 		}
 
 		buckets := map[address.Address]*statBucket{}
@@ -307,7 +274,6 @@ var mpoolStat = &cli.Command{
 
 			var s mpStat
 			s.addr = a.String()
-			s.gasLimit = big.Zero()
 
 			for _, m := range bkt.msgs {
 				if m.Message.Nonce < act.Nonce {
@@ -324,8 +290,6 @@ var mpoolStat = &cli.Command{
 				if m.Message.GasFeeCap.LessThan(minBF) {
 					s.belowPast++
 				}
-
-				s.gasLimit = big.Add(s.gasLimit, types.NewInt(uint64(m.Message.GasLimit)))
 			}
 
 			out = append(out, s)
@@ -336,7 +300,6 @@ var mpoolStat = &cli.Command{
 		})
 
 		var total mpStat
-		total.gasLimit = big.Zero()
 
 		for _, stat := range out {
 			total.past += stat.past
@@ -344,13 +307,12 @@ var mpoolStat = &cli.Command{
 			total.future += stat.future
 			total.belowCurr += stat.belowCurr
 			total.belowPast += stat.belowPast
-			total.gasLimit = big.Add(total.gasLimit, stat.gasLimit)
 
-			fmt.Printf("%s: Nonce past: %d, cur: %d, future: %d; FeeCap cur: %d, min-%d: %d, gasLimit: %s\n", stat.addr, stat.past, stat.cur, stat.future, stat.belowCurr, cctx.Int("basefee-lookback"), stat.belowPast, stat.gasLimit)
+			fmt.Printf("%s: Nonce past: %d, cur: %d, future: %d; FeeCap cur: %d, min-%d: %d \n", stat.addr, stat.past, stat.cur, stat.future, stat.belowCurr, cctx.Int("basefee-lookback"), stat.belowPast)
 		}
 
 		fmt.Println("-----")
-		fmt.Printf("total: Nonce past: %d, cur: %d, future: %d; FeeCap cur: %d, min-%d: %d, gasLimit: %s\n", total.past, total.cur, total.future, total.belowCurr, cctx.Int("basefee-lookback"), total.belowPast, total.gasLimit)
+		fmt.Printf("total: Nonce past: %d, cur: %d, future: %d; FeeCap cur: %d, min-%d: %d \n", total.past, total.cur, total.future, total.belowCurr, cctx.Int("basefee-lookback"), total.belowPast)
 
 		return nil
 	},
@@ -478,11 +440,9 @@ var mpoolReplaceCmd = &cli.Command{
 				return abi.TokenAmount(config.DefaultDefaultMaxFee), nil
 			}
 
-			messagepool.CapGasFee(mff, &msg, mss)
+			messagepool.CapGasFee(mff, &msg, mss.Get().MaxFee)
 		} else {
-			if cctx.IsSet("gas-limit") {
-				msg.GasLimit = cctx.Int64("gas-limit")
-			}
+			msg.GasLimit = cctx.Int64("gas-limit")
 			msg.GasPremium, err = types.BigFromString(cctx.String("gas-premium"))
 			if err != nil {
 				return fmt.Errorf("parsing gas-premium: %w", err)

cli/multisig.go

@@ -1178,7 +1178,7 @@ var msigLockProposeCmd = &cli.Command{
 		params, actErr := actors.SerializeParams(&msig2.LockBalanceParams{
 			StartEpoch:     abi.ChainEpoch(start),
 			UnlockDuration: abi.ChainEpoch(duration),
-			Amount:         big.Int(amount),
+			Amount:         abi.NewTokenAmount(amount.Int64()),
 		})
 
 		if actErr != nil {

cli/net.go

@@ -18,7 +18,6 @@ import (
 
 	"github.com/filecoin-project/go-address"
 
-	atypes "github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/lib/addrutil"
 )
@@ -35,7 +34,6 @@ var netCmd = &cli.Command{
 		netScores,
 		NetReachability,
 		NetBandwidthCmd,
-		NetBlockCmd,
 	},
 }
 
@@ -377,202 +375,3 @@ var NetBandwidthCmd = &cli.Command{
 
 	},
 }
-
-var NetBlockCmd = &cli.Command{
-	Name:  "block",
-	Usage: "Manage network connection gating rules",
-	Subcommands: []*cli.Command{
-		NetBlockAddCmd,
-		NetBlockRemoveCmd,
-		NetBlockListCmd,
-	},
-}
-
-var NetBlockAddCmd = &cli.Command{
-	Name:  "add",
-	Usage: "Add connection gating rules",
-	Subcommands: []*cli.Command{
-		NetBlockAddPeer,
-		NetBlockAddIP,
-		NetBlockAddSubnet,
-	},
-}
-
-var NetBlockAddPeer = &cli.Command{
-	Name:      "peer",
-	Usage:     "Block a peer",
-	ArgsUsage: "<Peer> ...",
-	Action: func(cctx *cli.Context) error {
-		api, closer, err := GetAPI(cctx)
-		if err != nil {
-			return err
-		}
-		defer closer()
-		ctx := ReqContext(cctx)
-
-		var peers []peer.ID
-		for _, s := range cctx.Args().Slice() {
-			p, err := peer.Decode(s)
-			if err != nil {
-				return err
-			}
-
-			peers = append(peers, p)
-		}
-
-		return api.NetBlockAdd(ctx, atypes.NetBlockList{Peers: peers})
-	},
-}
-
-var NetBlockAddIP = &cli.Command{
-	Name:      "ip",
-	Usage:     "Block an IP address",
-	ArgsUsage: "<IP> ...",
-	Action: func(cctx *cli.Context) error {
-		api, closer, err := GetAPI(cctx)
-		if err != nil {
-			return err
-		}
-		defer closer()
-		ctx := ReqContext(cctx)
-
-		return api.NetBlockAdd(ctx, atypes.NetBlockList{IPAddrs: cctx.Args().Slice()})
-	},
-}
-
-var NetBlockAddSubnet = &cli.Command{
-	Name:      "subnet",
-	Usage:     "Block an IP subnet",
-	ArgsUsage: "<CIDR> ...",
-	Action: func(cctx *cli.Context) error {
-		api, closer, err := GetAPI(cctx)
-		if err != nil {
-			return err
-		}
-		defer closer()
-		ctx := ReqContext(cctx)
-
-		return api.NetBlockAdd(ctx, atypes.NetBlockList{IPSubnets: cctx.Args().Slice()})
-	},
-}
-
-var NetBlockRemoveCmd = &cli.Command{
-	Name:  "remove",
-	Usage: "Remove connection gating rules",
-	Subcommands: []*cli.Command{
-		NetBlockRemovePeer,
-		NetBlockRemoveIP,
-		NetBlockRemoveSubnet,
-	},
-}
-
-var NetBlockRemovePeer = &cli.Command{
-	Name:      "peer",
-	Usage:     "Unblock a peer",
-	ArgsUsage: "<Peer> ...",
-	Action: func(cctx *cli.Context) error {
-		api, closer, err := GetAPI(cctx)
-		if err != nil {
-			return err
-		}
-		defer closer()
-		ctx := ReqContext(cctx)
-
-		var peers []peer.ID
-		for _, s := range cctx.Args().Slice() {
-			p, err := peer.Decode(s)
-			if err != nil {
-				return err
-			}
-
-			peers = append(peers, p)
-		}
-
-		return api.NetBlockRemove(ctx, atypes.NetBlockList{Peers: peers})
-	},
-}
-
-var NetBlockRemoveIP = &cli.Command{
-	Name:      "ip",
-	Usage:     "Unblock an IP address",
-	ArgsUsage: "<IP> ...",
-	Action: func(cctx *cli.Context) error {
-		api, closer, err := GetAPI(cctx)
-		if err != nil {
-			return err
-		}
-		defer closer()
-		ctx := ReqContext(cctx)
-
-		return api.NetBlockRemove(ctx, atypes.NetBlockList{IPAddrs: cctx.Args().Slice()})
-	},
-}
-
-var NetBlockRemoveSubnet = &cli.Command{
-	Name:      "subnet",
-	Usage:     "Unblock an IP subnet",
-	ArgsUsage: "<CIDR> ...",
-	Action: func(cctx *cli.Context) error {
-		api, closer, err := GetAPI(cctx)
-		if err != nil {
-			return err
-		}
-		defer closer()
-		ctx := ReqContext(cctx)
-
-		return api.NetBlockRemove(ctx, atypes.NetBlockList{IPSubnets: cctx.Args().Slice()})
-	},
-}
-
-var NetBlockListCmd = &cli.Command{
-	Name:  "list",
-	Usage: "list connection gating rules",
-	Action: func(cctx *cli.Context) error {
-		api, closer, err := GetAPI(cctx)
-		if err != nil {
-			return err
-		}
-		defer closer()
-		ctx := ReqContext(cctx)
-
-		acl, err := api.NetBlockList(ctx)
-		if err != nil {
-			return err
-		}
-
-		if len(acl.Peers) != 0 {
-			sort.Slice(acl.Peers, func(i, j int) bool {
-				return strings.Compare(string(acl.Peers[i]), string(acl.Peers[j])) > 0
-			})
-
-			fmt.Println("Blocked Peers:")
-			for _, p := range acl.Peers {
-				fmt.Printf("\t%s\n", p)
-			}
-		}
-
-		if len(acl.IPAddrs) != 0 {
-			sort.Slice(acl.IPAddrs, func(i, j int) bool {
-				return strings.Compare(acl.IPAddrs[i], acl.IPAddrs[j]) < 0
-			})
-
-			fmt.Println("Blocked IPs:")
-			for _, a := range acl.IPAddrs {
-				fmt.Printf("\t%s\n", a)
-			}
-		}
-
-		if len(acl.IPSubnets) != 0 {
-			sort.Slice(acl.IPSubnets, func(i, j int) bool {
-				return strings.Compare(acl.IPSubnets[i], acl.IPSubnets[j]) < 0
-			})
-
-			fmt.Println("Blocked Subnets:")
-			for _, n := range acl.IPSubnets {
-				fmt.Printf("\t%s\n", n)
-			}
-		}
-
-		return nil
-	},
-}

cli/send.go

@@ -43,10 +43,10 @@ var sendCmd = &cli.Command{
 			Usage: "specify gas limit",
 			Value: 0,
 		},
-		&cli.Uint64Flag{
+		&cli.Int64Flag{
 			Name:  "nonce",
 			Usage: "specify the nonce to use",
-			Value: 0,
+			Value: -1,
 		},
 		&cli.Uint64Flag{
 			Name:  "method",
@@ -143,8 +143,8 @@ var sendCmd = &cli.Command{
 			Params:     params,
 		}
 
-		if cctx.IsSet("nonce") {
-			msg.Nonce = cctx.Uint64("nonce")
+		if cctx.Int64("nonce") > 0 {
+			msg.Nonce = uint64(cctx.Int64("nonce"))
 			sm, err := api.WalletSignMessage(ctx, fromAddr, msg)
 			if err != nil {
 				return err

cli/state.go

@@ -72,7 +72,6 @@ var stateCmd = &cli.Command{
 		stateMinerInfo,
 		stateMarketCmd,
 		stateExecTraceCmd,
-		stateNtwkVersionCmd,
 	},
 }
 
@@ -120,7 +119,7 @@ var stateMinerInfo = &cli.Command{
 		}
 
 		fmt.Printf("PeerID:\t%s\n", mi.PeerId)
-		fmt.Printf("Multiaddrs:\t")
+		fmt.Printf("Multiaddrs: \t")
 		for _, addr := range mi.Multiaddrs {
 			a, err := multiaddr.NewMultiaddrBytes(addr)
 			if err != nil {
@@ -128,8 +127,6 @@ var stateMinerInfo = &cli.Command{
 			}
 			fmt.Printf("%s ", a)
 		}
-		fmt.Println()
-		fmt.Printf("Consensus Fault End:\t%d\n", mi.ConsensusFaultElapsed)
 
 		fmt.Printf("SectorSize:\t%s (%d)\n", types.SizeStr(types.NewInt(uint64(mi.SectorSize))), mi.SectorSize)
 		pow, err := api.StateMinerPower(ctx, addr, ts.Key())
@@ -1760,9 +1757,6 @@ var stateSectorCmd = &cli.Command{
 		if err != nil {
 			return err
 		}
-		if si == nil {
-			return xerrors.Errorf("sector %d for miner %s not found", sid, maddr)
-		}
 
 		fmt.Println("SectorNumber: ", si.SectorNumber)
 		fmt.Println("SealProof: ", si.SealProof)
@@ -1836,35 +1830,3 @@ var stateMarketBalanceCmd = &cli.Command{
 		return nil
 	},
 }
-
-var stateNtwkVersionCmd = &cli.Command{
-	Name:  "network-version",
-	Usage: "Returns the network version",
-	Action: func(cctx *cli.Context) error {
-		if cctx.Args().Present() {
-			return ShowHelp(cctx, fmt.Errorf("doesn't expect any arguments"))
-		}
-
-		api, closer, err := GetFullNodeAPI(cctx)
-		if err != nil {
-			return err
-		}
-		defer closer()
-
-		ctx := ReqContext(cctx)
-
-		ts, err := LoadTipSet(ctx, cctx, api)
-		if err != nil {
-			return err
-		}
-
-		nv, err := api.StateNetworkVersion(ctx, ts.Key())
-		if err != nil {
-			return err
-		}
-
-		fmt.Printf("Network Version: %d\n", nv)
-
-		return nil
-	},
-}

cli/test/client.go

@@ -43,14 +43,13 @@ func RunClientTest(t *testing.T, cmds []*lcli.Command, clientNode test.TestNode)
 	require.Regexp(t, regexp.MustCompile("Ask:"), out)
 
 	// Create a deal (non-interactive)
-	// client deal --start-epoch=<start epoch> <cid> <miner addr> 1000000attofil <duration>
+	// client deal <cid> <miner addr> 1000000attofil <duration>
 	res, _, err := test.CreateClientFile(ctx, clientNode, 1)
 	require.NoError(t, err)
-	startEpoch := fmt.Sprintf("--start-epoch=%d", 2<<12)
 	dataCid := res.Root
 	price := "1000000attofil"
 	duration := fmt.Sprintf("%d", build.MinDealDuration)
-	out = clientCLI.RunCmd("client", "deal", startEpoch, dataCid.String(), minerAddr.String(), price, duration)
+	out = clientCLI.RunCmd("client", "deal", dataCid.String(), minerAddr.String(), price, duration)
 	fmt.Println("client deal", out)
 
 	// Create a deal (interactive)
@@ -83,7 +82,7 @@ func RunClientTest(t *testing.T, cmds []*lcli.Command, clientNode test.TestNode)
 		fmt.Println("list-deals:\n", out)
 
 		lines := strings.Split(out, "\n")
-		require.GreaterOrEqual(t, len(lines), 2)
+		require.Len(t, lines, 2)
 		re := regexp.MustCompile(`\s+`)
 		parts := re.Split(lines[1], -1)
 		if len(parts) < 4 {
@@ -112,7 +111,7 @@ func dealComplete(t *testing.T, dealStatus string) bool {
 	switch dealStatus {
 	case "StorageDealFailing", "StorageDealError":
 		t.Fatal(xerrors.Errorf("Storage deal failed with status: " + dealStatus))
-	case "StorageDealStaged", "StorageDealAwaitingPreCommit", "StorageDealSealing", "StorageDealActive", "StorageDealExpired", "StorageDealSlashed":
+	case "StorageDealStaged", "StorageDealSealing", "StorageDealActive", "StorageDealExpired", "StorageDealSlashed":
 		return true
 	}
 

cli/wallet.go

@@ -16,8 +16,11 @@ import (
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/big"
 	"github.com/filecoin-project/go-state-types/crypto"
+	"github.com/filecoin-project/specs-actors/actors/builtin/market"
+	"github.com/filecoin-project/specs-actors/v2/actors/builtin"
 
-	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/chain/actors"
+	types "github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/lib/tablewriter"
 )
 
@@ -582,13 +585,27 @@ var walletMarketWithdraw = &cli.Command{
 			return xerrors.Errorf("zero unlocked funds available to withdraw")
 		}
 
-		fmt.Printf("Submitting WithdrawBalance message for amount %s for address %s\n", types.FIL(amt), from.String())
-		smsg, err := api.MarketWithdraw(ctx, from, addr, amt)
+		params, err := actors.SerializeParams(&market.WithdrawBalanceParams{
+			ProviderOrClientAddress: addr,
+			Amount:                  amt,
+		})
 		if err != nil {
-			return xerrors.Errorf("fund manager withdraw error: %w", err)
+			return xerrors.Errorf("serializing params: %w", err)
 		}
 
-		fmt.Printf("WithdrawBalance message cid: %s\n", smsg)
+		fmt.Printf("Submitting WithdrawBalance message for amount %s for address %s\n", types.FIL(amt), from.String())
+		smsg, err := api.MpoolPushMessage(ctx, &types.Message{
+			To:     builtin.StorageMarketActorAddr,
+			From:   from,
+			Value:  types.NewInt(0),
+			Method: builtin.MethodsMarket.WithdrawBalance,
+			Params: params,
+		}, nil)
+		if err != nil {
+			return xerrors.Errorf("submitting WithdrawBalance message: %w", err)
+		}
+
+		fmt.Printf("WithdrawBalance message cid: %s\n", smsg.Cid())
 
 		return nil
 	},

cmd/lotus-bench/import.go

@@ -60,7 +60,7 @@ type TipSetExec struct {
 
 var importBenchCmd = &cli.Command{
 	Name:  "import",
-	Usage: "Benchmark chain import and validation",
+	Usage: "benchmark chain import and validation",
 	Subcommands: []*cli.Command{
 		importAnalyzeCmd,
 	},
@@ -263,8 +263,6 @@ var importBenchCmd = &cli.Command{
 
 		metadataDs := datastore.NewMapDatastore()
 		cs := store.NewChainStore(bs, bs, metadataDs, vm.Syscalls(verifier), nil)
-		defer cs.Close() //nolint:errcheck
-
 		stm := stmgr.NewStateManager(cs)
 
 		startTime := time.Now()

cmd/lotus-bench/main.go

@@ -31,7 +31,6 @@ import (
 
 	lapi "github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/build"
-	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
 	"github.com/filecoin-project/lotus/chain/actors/policy"
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/genesis"
@@ -40,10 +39,8 @@ import (
 var log = logging.Logger("lotus-bench")
 
 type BenchResults struct {
-	SectorSize   abi.SectorSize
-	SectorNumber int
+	SectorSize abi.SectorSize
 
-	SealingSum     SealingResult
 	SealingResults []SealingResult
 
 	PostGenerateCandidates time.Duration
@@ -58,26 +55,6 @@ type BenchResults struct {
 	VerifyWindowPostHot  time.Duration
 }
 
-func (bo *BenchResults) SumSealingTime() error {
-	if len(bo.SealingResults) <= 0 {
-		return xerrors.Errorf("BenchResults SealingResults len <= 0")
-	}
-	if len(bo.SealingResults) != bo.SectorNumber {
-		return xerrors.Errorf("BenchResults SealingResults len(%d) != bo.SectorNumber(%d)", len(bo.SealingResults), bo.SectorNumber)
-	}
-
-	for _, sealing := range bo.SealingResults {
-		bo.SealingSum.AddPiece += sealing.AddPiece
-		bo.SealingSum.PreCommit1 += sealing.PreCommit1
-		bo.SealingSum.PreCommit2 += sealing.PreCommit2
-		bo.SealingSum.Commit1 += sealing.Commit1
-		bo.SealingSum.Commit2 += sealing.Commit2
-		bo.SealingSum.Verify += sealing.Verify
-		bo.SealingSum.Unseal += sealing.Unseal
-	}
-	return nil
-}
-
 type SealingResult struct {
 	AddPiece   time.Duration
 	PreCommit1 time.Duration
@@ -117,13 +94,12 @@ func main() {
 }
 
 var sealBenchCmd = &cli.Command{
-	Name:  "sealing",
-	Usage: "Benchmark seal and winning post and window post",
+	Name: "sealing",
 	Flags: []cli.Flag{
 		&cli.StringFlag{
 			Name:  "storage-dir",
 			Value: "~/.lotus-bench",
-			Usage: "path to the storage directory that will store sectors long term",
+			Usage: "Path to the storage directory that will store sectors long term",
 		},
 		&cli.StringFlag{
 			Name:  "sector-size",
@@ -155,22 +131,16 @@ var sealBenchCmd = &cli.Command{
 			Name:  "skip-unseal",
 			Usage: "skip the unseal portion of the benchmark",
 		},
-		&cli.StringFlag{
-			Name:  "ticket-preimage",
-			Usage: "ticket random",
-		},
 		&cli.StringFlag{
 			Name:  "save-commit2-input",
-			Usage: "save commit2 input to a file",
+			Usage: "Save commit2 input to a file",
 		},
 		&cli.IntFlag{
 			Name:  "num-sectors",
-			Usage: "select number of sectors to seal",
 			Value: 1,
 		},
 		&cli.IntFlag{
 			Name:  "parallel",
-			Usage: "num run in parallel",
 			Value: 1,
 		},
 	},
@@ -241,9 +211,17 @@ var sealBenchCmd = &cli.Command{
 		}
 		sectorSize := abi.SectorSize(sectorSizeInt)
 
+		spt, err := ffiwrapper.SealProofTypeFromSectorSize(sectorSize)
+		if err != nil {
+			return err
+		}
+
+		cfg := &ffiwrapper.Config{
+			SealProofType: spt,
+		}
+
 		// Only fetch parameters if actually needed
-		skipc2 := c.Bool("skip-commit2")
-		if !skipc2 {
+		if !c.Bool("skip-commit2") {
 			if err := paramfetch.GetParams(lcli.ReqContext(c), build.ParametersJSON(), uint64(sectorSize)); err != nil {
 				return xerrors.Errorf("getting params: %w", err)
 			}
@@ -253,13 +231,11 @@ var sealBenchCmd = &cli.Command{
 			Root: sbdir,
 		}
 
-		sb, err := ffiwrapper.New(sbfs)
+		sb, err := ffiwrapper.New(sbfs, cfg)
 		if err != nil {
 			return err
 		}
 
-		sectorNumber := c.Int("num-sectors")
-
 		var sealTimings []SealingResult
 		var sealedSectors []saproof2.SectorInfo
 
@@ -270,11 +246,18 @@ var sealBenchCmd = &cli.Command{
 				PreCommit2: 1,
 				Commit:     1,
 			}
-			sealTimings, sealedSectors, err = runSeals(sb, sbfs, sectorNumber, parCfg, mid, sectorSize, []byte(c.String("ticket-preimage")), c.String("save-commit2-input"), skipc2, c.Bool("skip-unseal"))
+			sealTimings, sealedSectors, err = runSeals(sb, sbfs, c.Int("num-sectors"), parCfg, mid, sectorSize, []byte(c.String("ticket-preimage")), c.String("save-commit2-input"), c.Bool("skip-commit2"), c.Bool("skip-unseal"))
 			if err != nil {
 				return xerrors.Errorf("failed to run seals: %w", err)
 			}
-		} else {
+		}
+
+		beforePost := time.Now()
+
+		var challenge [32]byte
+		rand.Read(challenge[:])
+
+		if robench != "" {
 			// TODO: implement sbfs.List() and use that for all cases (preexisting sectorbuilder or not)
 
 			// TODO: this assumes we only ever benchmark a preseal
@@ -307,21 +290,12 @@ var sealBenchCmd = &cli.Command{
 
 		bo := BenchResults{
 			SectorSize:     sectorSize,
-			SectorNumber:   sectorNumber,
 			SealingResults: sealTimings,
 		}
-		if err := bo.SumSealingTime(); err != nil {
-			return err
-		}
 
-		var challenge [32]byte
-		rand.Read(challenge[:])
-
-		beforePost := time.Now()
-
-		if !skipc2 {
+		if !c.Bool("skip-commit2") {
 			log.Info("generating winning post candidates")
-			wipt, err := spt(sectorSize).RegisteredWinningPoStProof()
+			wipt, err := spt.RegisteredWinningPoStProof()
 			if err != nil {
 				return err
 			}
@@ -454,21 +428,21 @@ var sealBenchCmd = &cli.Command{
 
 			fmt.Println(string(data))
 		} else {
-			fmt.Printf("----\nresults (v28) SectorSize:(%d), SectorNumber:(%d)\n", sectorSize, sectorNumber)
+			fmt.Printf("----\nresults (v27) (%d)\n", sectorSize)
 			if robench == "" {
-				fmt.Printf("seal: addPiece: %s (%s)\n", bo.SealingSum.AddPiece, bps(bo.SectorSize, bo.SectorNumber, bo.SealingSum.AddPiece))
-				fmt.Printf("seal: preCommit phase 1: %s (%s)\n", bo.SealingSum.PreCommit1, bps(bo.SectorSize, bo.SectorNumber, bo.SealingSum.PreCommit1))
-				fmt.Printf("seal: preCommit phase 2: %s (%s)\n", bo.SealingSum.PreCommit2, bps(bo.SectorSize, bo.SectorNumber, bo.SealingSum.PreCommit2))
-				fmt.Printf("seal: commit phase 1: %s (%s)\n", bo.SealingSum.Commit1, bps(bo.SectorSize, bo.SectorNumber, bo.SealingSum.Commit1))
-				fmt.Printf("seal: commit phase 2: %s (%s)\n", bo.SealingSum.Commit2, bps(bo.SectorSize, bo.SectorNumber, bo.SealingSum.Commit2))
-				fmt.Printf("seal: verify: %s\n", bo.SealingSum.Verify)
+				fmt.Printf("seal: addPiece: %s (%s)\n", bo.SealingResults[0].AddPiece, bps(bo.SectorSize, bo.SealingResults[0].AddPiece)) // TODO: average across multiple sealings
+				fmt.Printf("seal: preCommit phase 1: %s (%s)\n", bo.SealingResults[0].PreCommit1, bps(bo.SectorSize, bo.SealingResults[0].PreCommit1))
+				fmt.Printf("seal: preCommit phase 2: %s (%s)\n", bo.SealingResults[0].PreCommit2, bps(bo.SectorSize, bo.SealingResults[0].PreCommit2))
+				fmt.Printf("seal: commit phase 1: %s (%s)\n", bo.SealingResults[0].Commit1, bps(bo.SectorSize, bo.SealingResults[0].Commit1))
+				fmt.Printf("seal: commit phase 2: %s (%s)\n", bo.SealingResults[0].Commit2, bps(bo.SectorSize, bo.SealingResults[0].Commit2))
+				fmt.Printf("seal: verify: %s\n", bo.SealingResults[0].Verify)
 				if !c.Bool("skip-unseal") {
-					fmt.Printf("unseal: %s  (%s)\n", bo.SealingSum.Unseal, bps(bo.SectorSize, bo.SectorNumber, bo.SealingSum.Unseal))
+					fmt.Printf("unseal: %s  (%s)\n", bo.SealingResults[0].Unseal, bps(bo.SectorSize, bo.SealingResults[0].Unseal))
 				}
 				fmt.Println("")
 			}
-			if !skipc2 {
-				fmt.Printf("generate candidates: %s (%s)\n", bo.PostGenerateCandidates, bps(bo.SectorSize, len(bo.SealingResults), bo.PostGenerateCandidates))
+			if !c.Bool("skip-commit2") {
+				fmt.Printf("generate candidates: %s (%s)\n", bo.PostGenerateCandidates, bps(bo.SectorSize*abi.SectorSize(len(bo.SealingResults)), bo.PostGenerateCandidates))
 				fmt.Printf("compute winning post proof (cold): %s\n", bo.PostWinningProofCold)
 				fmt.Printf("compute winning post proof (hot): %s\n", bo.PostWinningProofHot)
 				fmt.Printf("verify winning post proof (cold): %s\n", bo.VerifyWinningPostCold)
@@ -501,13 +475,11 @@ func runSeals(sb *ffiwrapper.Sealer, sbfs *basicfs.Provider, numSectors int, par
 	if numSectors%par.PreCommit1 != 0 {
 		return nil, nil, fmt.Errorf("parallelism factor must cleanly divide numSectors")
 	}
-	for i := abi.SectorNumber(0); i < abi.SectorNumber(numSectors); i++ {
-		sid := storage.SectorRef{
-			ID: abi.SectorID{
-				Miner:  mid,
-				Number: i,
-			},
-			ProofType: spt(sectorSize),
+
+	for i := abi.SectorNumber(1); i <= abi.SectorNumber(numSectors); i++ {
+		sid := abi.SectorID{
+			Miner:  mid,
+			Number: i,
 		}
 
 		start := time.Now()
@@ -522,7 +494,7 @@ func runSeals(sb *ffiwrapper.Sealer, sbfs *basicfs.Provider, numSectors int, par
 
 		pieces = append(pieces, pi)
 
-		sealTimings[i].AddPiece = time.Since(start)
+		sealTimings[i-1].AddPiece = time.Since(start)
 	}
 
 	sectorsPerWorker := numSectors / par.PreCommit1
@@ -531,15 +503,13 @@ func runSeals(sb *ffiwrapper.Sealer, sbfs *basicfs.Provider, numSectors int, par
 	for wid := 0; wid < par.PreCommit1; wid++ {
 		go func(worker int) {
 			sealerr := func() error {
-				start := worker * sectorsPerWorker
+				start := 1 + (worker * sectorsPerWorker)
 				end := start + sectorsPerWorker
 				for i := abi.SectorNumber(start); i < abi.SectorNumber(end); i++ {
-					sid := storage.SectorRef{
-						ID: abi.SectorID{
-							Miner:  mid,
-							Number: i,
-						},
-						ProofType: spt(sectorSize),
+					ix := int(i - 1)
+					sid := abi.SectorID{
+						Miner:  mid,
+						Number: i,
 					}
 
 					start := time.Now()
@@ -548,8 +518,8 @@ func runSeals(sb *ffiwrapper.Sealer, sbfs *basicfs.Provider, numSectors int, par
 					ticket := abi.SealRandomness(trand[:])
 
 					log.Infof("[%d] Running replication(1)...", i)
-					piece := []abi.PieceInfo{pieces[i]}
-					pc1o, err := sb.SealPreCommit1(context.TODO(), sid, ticket, piece)
+					pieces := []abi.PieceInfo{pieces[ix]}
+					pc1o, err := sb.SealPreCommit1(context.TODO(), sid, ticket, pieces)
 					if err != nil {
 						return xerrors.Errorf("commit: %w", err)
 					}
@@ -567,8 +537,8 @@ func runSeals(sb *ffiwrapper.Sealer, sbfs *basicfs.Provider, numSectors int, par
 					precommit2 := time.Now()
 					<-preCommit2Sema
 
-					sealedSectors[i] = saproof2.SectorInfo{
-						SealProof:    sid.ProofType,
+					sealedSectors[ix] = saproof2.SectorInfo{
+						SealProof:    sb.SealProofType(),
 						SectorNumber: i,
 						SealedCID:    cids.Sealed,
 					}
@@ -581,7 +551,7 @@ func runSeals(sb *ffiwrapper.Sealer, sbfs *basicfs.Provider, numSectors int, par
 					commitSema <- struct{}{}
 					commitStart := time.Now()
 					log.Infof("[%d] Generating PoRep for sector (1)", i)
-					c1o, err := sb.SealCommit1(context.TODO(), sid, ticket, seed.Value, piece, cids)
+					c1o, err := sb.SealCommit1(context.TODO(), sid, ticket, seed.Value, pieces, cids)
 					if err != nil {
 						return err
 					}
@@ -622,7 +592,7 @@ func runSeals(sb *ffiwrapper.Sealer, sbfs *basicfs.Provider, numSectors int, par
 						svi := saproof2.SealVerifyInfo{
 							SectorID:              abi.SectorID{Miner: mid, Number: i},
 							SealedCID:             cids.Sealed,
-							SealProof:             sid.ProofType,
+							SealProof:             sb.SealProofType(),
 							Proof:                 proof,
 							DealIDs:               nil,
 							Randomness:            ticket,
@@ -644,7 +614,7 @@ func runSeals(sb *ffiwrapper.Sealer, sbfs *basicfs.Provider, numSectors int, par
 					if !skipunseal {
 						log.Infof("[%d] Unsealing sector", i)
 						{
-							p, done, err := sbfs.AcquireSector(context.TODO(), sid, storiface.FTUnsealed, storiface.FTNone, storiface.PathSealing)
+							p, done, err := sbfs.AcquireSector(context.TODO(), abi.SectorID{Miner: mid, Number: 1}, storiface.FTUnsealed, storiface.FTNone, storiface.PathSealing)
 							if err != nil {
 								return xerrors.Errorf("acquire unsealed sector for removing: %w", err)
 							}
@@ -655,19 +625,19 @@ func runSeals(sb *ffiwrapper.Sealer, sbfs *basicfs.Provider, numSectors int, par
 							}
 						}
 
-						err := sb.UnsealPiece(context.TODO(), sid, 0, abi.PaddedPieceSize(sectorSize).Unpadded(), ticket, cids.Unsealed)
+						err := sb.UnsealPiece(context.TODO(), abi.SectorID{Miner: mid, Number: 1}, 0, abi.PaddedPieceSize(sectorSize).Unpadded(), ticket, cids.Unsealed)
 						if err != nil {
 							return err
 						}
 					}
 					unseal := time.Now()
 
-					sealTimings[i].PreCommit1 = precommit1.Sub(start)
-					sealTimings[i].PreCommit2 = precommit2.Sub(pc2Start)
-					sealTimings[i].Commit1 = sealcommit1.Sub(commitStart)
-					sealTimings[i].Commit2 = sealcommit2.Sub(sealcommit1)
-					sealTimings[i].Verify = verifySeal.Sub(sealcommit2)
-					sealTimings[i].Unseal = unseal.Sub(verifySeal)
+					sealTimings[ix].PreCommit1 = precommit1.Sub(start)
+					sealTimings[ix].PreCommit2 = precommit2.Sub(pc2Start)
+					sealTimings[ix].Commit1 = sealcommit1.Sub(commitStart)
+					sealTimings[ix].Commit2 = sealcommit2.Sub(sealcommit1)
+					sealTimings[ix].Verify = verifySeal.Sub(sealcommit2)
+					sealTimings[ix].Unseal = unseal.Sub(verifySeal)
 				}
 				return nil
 			}()
@@ -690,9 +660,8 @@ func runSeals(sb *ffiwrapper.Sealer, sbfs *basicfs.Provider, numSectors int, par
 }
 
 var proveCmd = &cli.Command{
-	Name:      "prove",
-	Usage:     "Benchmark a proof computation",
-	ArgsUsage: "[input.json]",
+	Name:  "prove",
+	Usage: "Benchmark a proof computation",
 	Flags: []cli.Flag{
 		&cli.BoolFlag{
 			Name:  "no-gpu",
@@ -739,23 +708,23 @@ var proveCmd = &cli.Command{
 			return err
 		}
 
-		sb, err := ffiwrapper.New(nil)
+		spt, err := ffiwrapper.SealProofTypeFromSectorSize(abi.SectorSize(c2in.SectorSize))
 		if err != nil {
 			return err
 		}
 
-		ref := storage.SectorRef{
-			ID: abi.SectorID{
-				Miner:  abi.ActorID(mid),
-				Number: abi.SectorNumber(c2in.SectorNum),
-			},
-			ProofType: spt(abi.SectorSize(c2in.SectorSize)),
+		cfg := &ffiwrapper.Config{
+			SealProofType: spt,
+		}
+
+		sb, err := ffiwrapper.New(nil, cfg)
+		if err != nil {
+			return err
 		}
 
-		fmt.Printf("----\nstart proof computation\n")
 		start := time.Now()
 
-		proof, err := sb.SealCommit2(context.TODO(), ref, c2in.Phase1Out)
+		proof, err := sb.SealCommit2(context.TODO(), abi.SectorID{Miner: abi.ActorID(mid), Number: abi.SectorNumber(c2in.SectorNum)}, c2in.Phase1Out)
 		if err != nil {
 			return err
 		}
@@ -764,27 +733,17 @@ var proveCmd = &cli.Command{
 
 		fmt.Printf("proof: %x\n", proof)
 
-		fmt.Printf("----\nresults (v28) (%d)\n", c2in.SectorSize)
+		fmt.Printf("----\nresults (v27) (%d)\n", c2in.SectorSize)
 		dur := sealCommit2.Sub(start)
 
-		fmt.Printf("seal: commit phase 2: %s (%s)\n", dur, bps(abi.SectorSize(c2in.SectorSize), 1, dur))
+		fmt.Printf("seal: commit phase 2: %s (%s)\n", dur, bps(abi.SectorSize(c2in.SectorSize), dur))
 		return nil
 	},
 }
 
-func bps(sectorSize abi.SectorSize, sectorNum int, d time.Duration) string {
-	bdata := new(big.Int).SetUint64(uint64(sectorSize))
-	bdata = bdata.Mul(bdata, big.NewInt(int64(sectorNum)))
+func bps(data abi.SectorSize, d time.Duration) string {
+	bdata := new(big.Int).SetUint64(uint64(data))
 	bdata = bdata.Mul(bdata, big.NewInt(time.Second.Nanoseconds()))
 	bps := bdata.Div(bdata, big.NewInt(d.Nanoseconds()))
 	return types.SizeStr(types.BigInt{Int: bps}) + "/s"
 }
-
-func spt(ssize abi.SectorSize) abi.RegisteredSealProof {
-	spt, err := miner.SealProofTypeFromSectorSize(ssize, build.NewestNetworkVersion)
-	if err != nil {
-		panic(err)
-	}
-
-	return spt
-}

cmd/lotus-fountain/main.go

@@ -87,7 +87,7 @@ var runCmd = &cli.Command{
 			return err
 		}
 
-		log.Infof("Remote version: %s", v.Version)
+		log.Info("Remote version: %s", v.Version)
 
 		from, err := address.NewFromString(cctx.String("from"))
 		if err != nil {

cmd/lotus-gateway/api.go

@@ -67,7 +67,6 @@ type gatewayDepsAPI interface {
 	StateMinerAvailableBalance(context.Context, address.Address, types.TipSetKey) (types.BigInt, error)
 	StateMinerProvingDeadline(context.Context, address.Address, types.TipSetKey) (*dline.Info, error)
 	StateCirculatingSupply(context.Context, types.TipSetKey) (abi.TokenAmount, error)
-	StateSectorGetInfo(ctx context.Context, maddr address.Address, n abi.SectorNumber, tsk types.TipSetKey) (*miner.SectorOnChainInfo, error)
 	StateVerifiedClientStatus(ctx context.Context, addr address.Address, tsk types.TipSetKey) (*abi.StoragePower, error)
 	StateVMCirculatingSupplyInternal(context.Context, types.TipSetKey) (api.CirculatingSupply, error)
 }
@@ -363,13 +362,7 @@ func (a *GatewayAPI) StateCirculatingSupply(ctx context.Context, tsk types.TipSe
 		return types.BigInt{}, err
 	}
 	return a.api.StateCirculatingSupply(ctx, tsk)
-}
 
-func (a *GatewayAPI) StateSectorGetInfo(ctx context.Context, maddr address.Address, n abi.SectorNumber, tsk types.TipSetKey) (*miner.SectorOnChainInfo, error) {
-	if err := a.checkTipsetKey(ctx, tsk); err != nil {
-		return nil, err
-	}
-	return a.api.StateSectorGetInfo(ctx, maddr, n, tsk)
 }
 
 func (a *GatewayAPI) StateVerifiedClientStatus(ctx context.Context, addr address.Address, tsk types.TipSetKey) (*abi.StoragePower, error) {

cmd/lotus-gateway/endtoend_test.go

@@ -171,11 +171,7 @@ func TestDealFlow(t *testing.T) {
 	nodes := startNodesWithFunds(ctx, t, blocktime, maxLookbackCap, maxStateWaitLookbackLimit)
 	defer nodes.closer()
 
-	// For these tests where the block time is artificially short, just use
-	// a deal start epoch that is guaranteed to be far enough in the future
-	// so that the deal starts sealing in time
-	dealStartEpoch := abi.ChainEpoch(2 << 12)
-	test.MakeDeal(t, ctx, 6, nodes.lite, nodes.miner, false, false, dealStartEpoch)
+	test.MakeDeal(t, ctx, 6, nodes.lite, nodes.miner, false, false)
 }
 
 func TestCLIDealFlow(t *testing.T) {

cmd/lotus-gateway/main.go

@@ -61,10 +61,6 @@ var runCmd = &cli.Command{
 			Usage: "host address and port the api server will listen on",
 			Value: "0.0.0.0:2346",
 		},
-		&cli.IntFlag{
-			Name:  "api-max-req-size",
-			Usage: "maximum API request size accepted by the JSON RPC server",
-		},
 	},
 	Action: func(cctx *cli.Context) error {
 		log.Info("Starting lotus gateway")
@@ -91,11 +87,7 @@ var runCmd = &cli.Command{
 
 		log.Info("Setting up API endpoint at " + address)
 
-		serverOptions := make([]jsonrpc.ServerOption, 0)
-		if maxRequestSize := cctx.Int("api-max-req-size"); maxRequestSize != 0 {
-			serverOptions = append(serverOptions, jsonrpc.WithMaxRequestSize(int64(maxRequestSize)))
-		}
-		rpcServer := jsonrpc.NewServer(serverOptions...)
+		rpcServer := jsonrpc.NewServer()
 		rpcServer.Register("Filecoin", metrics.MetricedGatewayAPI(NewGatewayAPI(api)))
 
 		mux.Handle("/rpc/v0", rpcServer)

cmd/lotus-keygen/main.go

@@ -22,11 +22,6 @@ func main() {
 			Value:   "bls",
 			Usage:   "specify key type to generate (bls or secp256k1)",
 		},
-		&cli.StringFlag{
-			Name:    "out",
-			Aliases: []string{"o"},
-			Usage:   "specify key file name to generate",
-		},
 	}
 	app.Action = func(cctx *cli.Context) error {
 		memks := wallet.NewMemKeyStore()
@@ -55,11 +50,7 @@ func main() {
 			return err
 		}
 
-		outFile := fmt.Sprintf("%s.key", kaddr)
-		if cctx.IsSet("out") {
-			outFile = fmt.Sprintf("%s.key", cctx.String("out"))
-		}
-		fi, err := os.Create(outFile)
+		fi, err := os.Create(fmt.Sprintf("%s.key", kaddr))
 		if err != nil {
 			return err
 		}

cmd/lotus-seal-worker/info.go

@@ -2,14 +2,12 @@ package main
 
 import (
 	"fmt"
-	"sort"
 
 	"github.com/urfave/cli/v2"
 	"golang.org/x/xerrors"
 
 	"github.com/filecoin-project/lotus/chain/types"
 	lcli "github.com/filecoin-project/lotus/cli"
-	"github.com/filecoin-project/lotus/extern/sector-storage/sealtasks"
 )
 
 var infoCmd = &cli.Command{
@@ -51,22 +49,10 @@ var infoCmd = &cli.Command{
 			return xerrors.Errorf("getting info: %w", err)
 		}
 
-		tt, err := api.TaskTypes(ctx)
-		if err != nil {
-			return xerrors.Errorf("getting task types: %w", err)
-		}
-
 		fmt.Printf("Hostname: %s\n", info.Hostname)
 		fmt.Printf("CPUs: %d; GPUs: %v\n", info.Resources.CPUs, info.Resources.GPUs)
 		fmt.Printf("RAM: %s; Swap: %s\n", types.SizeStr(types.NewInt(info.Resources.MemPhysical)), types.SizeStr(types.NewInt(info.Resources.MemSwap)))
 		fmt.Printf("Reserved memory: %s\n", types.SizeStr(types.NewInt(info.Resources.MemReserved)))
-
-		fmt.Printf("Task types: ")
-		for _, t := range ttList(tt) {
-			fmt.Printf("%s ", t.Short())
-		}
-		fmt.Println()
-
 		fmt.Println()
 
 		paths, err := api.Paths(ctx)
@@ -94,14 +80,3 @@ var infoCmd = &cli.Command{
 		return nil
 	},
 }
-
-func ttList(tt map[sealtasks.TaskType]struct{}) []sealtasks.TaskType {
-	tasks := make([]sealtasks.TaskType, 0, len(tt))
-	for taskType := range tt {
-		tasks = append(tasks, taskType)
-	}
-	sort.Slice(tasks, func(i, j int) bool {
-		return tasks[i].Less(tasks[j])
-	})
-	return tasks
-}

cmd/lotus-seal-worker/main.go

@@ -32,6 +32,7 @@ import (
 	"github.com/filecoin-project/lotus/build"
 	lcli "github.com/filecoin-project/lotus/cli"
 	sectorstorage "github.com/filecoin-project/lotus/extern/sector-storage"
+	"github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper"
 	"github.com/filecoin-project/lotus/extern/sector-storage/sealtasks"
 	"github.com/filecoin-project/lotus/extern/sector-storage/stores"
 	"github.com/filecoin-project/lotus/lib/lotuslog"
@@ -59,7 +60,6 @@ func main() {
 		storageCmd,
 		setCmd,
 		waitQuietCmd,
-		tasksCmd,
 	}
 
 	app := &cli.App{
@@ -356,6 +356,11 @@ var runCmd = &cli.Command{
 		}
 
 		// Setup remote sector store
+		spt, err := ffiwrapper.SealProofTypeFromSectorSize(ssize)
+		if err != nil {
+			return xerrors.Errorf("getting proof type: %w", err)
+		}
+
 		sminfo, err := lcli.GetAPIInfo(cctx, repo.StorageMiner)
 		if err != nil {
 			return xerrors.Errorf("could not get api info: %w", err)
@@ -363,23 +368,13 @@ var runCmd = &cli.Command{
 
 		remote := stores.NewRemote(localStore, nodeApi, sminfo.AuthHeader(), cctx.Int("parallel-fetch-limit"))
 
-		fh := &stores.FetchHandler{Local: localStore}
-		remoteHandler := func(w http.ResponseWriter, r *http.Request) {
-			if !auth.HasPerm(r.Context(), nil, apistruct.PermAdmin) {
-				w.WriteHeader(401)
-				_ = json.NewEncoder(w).Encode(struct{ Error string }{"unauthorized: missing admin permission"})
-				return
-			}
-
-			fh.ServeHTTP(w, r)
-		}
-
 		// Create / expose the worker
 
 		wsts := statestore.New(namespace.Wrap(ds, modules.WorkerCallsPrefix))
 
 		workerApi := &worker{
 			LocalWorker: sectorstorage.NewLocalWorker(sectorstorage.WorkerConfig{
+				SealProof: spt,
 				TaskTypes: taskTypes,
 				NoSwap:    cctx.Bool("no-swap"),
 			}, remote, localStore, nodeApi, nodeApi, wsts),
@@ -397,7 +392,7 @@ var runCmd = &cli.Command{
 
 		mux.Handle("/rpc/v0", rpcServer)
 		mux.Handle("/rpc/streams/v0/push/{uuid}", readerHandler)
-		mux.PathPrefix("/remote").HandlerFunc(remoteHandler)
+		mux.PathPrefix("/remote").HandlerFunc((&stores.FetchHandler{Local: localStore}).ServeHTTP)
 		mux.PathPrefix("/").Handler(http.DefaultServeMux) // pprof
 
 		ah := &auth.Handler{

cmd/lotus-seal-worker/tasks.go

@@ -1,82 +0,0 @@
-package main
-
-import (
-	"context"
-	"strings"
-
-	"github.com/urfave/cli/v2"
-	"golang.org/x/xerrors"
-
-	"github.com/filecoin-project/lotus/api"
-	lcli "github.com/filecoin-project/lotus/cli"
-	"github.com/filecoin-project/lotus/extern/sector-storage/sealtasks"
-)
-
-var tasksCmd = &cli.Command{
-	Name:  "tasks",
-	Usage: "Manage task processing",
-	Subcommands: []*cli.Command{
-		tasksEnableCmd,
-		tasksDisableCmd,
-	},
-}
-
-var allowSetting = map[sealtasks.TaskType]struct{}{
-	sealtasks.TTAddPiece:   {},
-	sealtasks.TTPreCommit1: {},
-	sealtasks.TTPreCommit2: {},
-	sealtasks.TTCommit2:    {},
-	sealtasks.TTUnseal:     {},
-}
-
-var settableStr = func() string {
-	var s []string
-	for _, tt := range ttList(allowSetting) {
-		s = append(s, tt.Short())
-	}
-	return strings.Join(s, "|")
-}()
-
-var tasksEnableCmd = &cli.Command{
-	Name:      "enable",
-	Usage:     "Enable a task type",
-	ArgsUsage: "[" + settableStr + "]",
-	Action:    taskAction(api.WorkerAPI.TaskEnable),
-}
-
-var tasksDisableCmd = &cli.Command{
-	Name:      "disable",
-	Usage:     "Disable a task type",
-	ArgsUsage: "[" + settableStr + "]",
-	Action:    taskAction(api.WorkerAPI.TaskDisable),
-}
-
-func taskAction(tf func(a api.WorkerAPI, ctx context.Context, tt sealtasks.TaskType) error) func(cctx *cli.Context) error {
-	return func(cctx *cli.Context) error {
-		if cctx.NArg() != 1 {
-			return xerrors.Errorf("expected 1 argument")
-		}
-
-		var tt sealtasks.TaskType
-		for taskType := range allowSetting {
-			if taskType.Short() == cctx.Args().First() {
-				tt = taskType
-				break
-			}
-		}
-
-		if tt == "" {
-			return xerrors.Errorf("unknown task type '%s'", cctx.Args().First())
-		}
-
-		api, closer, err := lcli.GetWorkerAPI(cctx)
-		if err != nil {
-			return err
-		}
-		defer closer()
-
-		ctx := lcli.ReqContext(cctx)
-
-		return tf(api, ctx, tt)
-	}
-}

cmd/lotus-seed/main.go

@@ -7,9 +7,9 @@ import (
 	"io/ioutil"
 	"os"
 
-	"github.com/filecoin-project/go-state-types/network"
-
 	"github.com/docker/go-units"
+	"github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper"
+
 	logging "github.com/ipfs/go-log/v2"
 	"github.com/mitchellh/go-homedir"
 	"github.com/urfave/cli/v2"
@@ -19,7 +19,6 @@ import (
 	"github.com/filecoin-project/go-state-types/big"
 
 	"github.com/filecoin-project/lotus/build"
-	"github.com/filecoin-project/lotus/chain/actors/builtin/miner"
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/cmd/lotus-seed/seed"
 	"github.com/filecoin-project/lotus/genesis"
@@ -129,12 +128,12 @@ var preSealCmd = &cli.Command{
 		}
 		sectorSize := abi.SectorSize(sectorSizeInt)
 
-		spt, err := miner.SealProofTypeFromSectorSize(sectorSize, network.Version0)
+		rp, err := ffiwrapper.SealProofTypeFromSectorSize(sectorSize)
 		if err != nil {
 			return err
 		}
 
-		gm, key, err := seed.PreSeal(maddr, spt, abi.SectorNumber(c.Uint64("sector-offset")), c.Int("num-sectors"), sbroot, []byte(c.String("ticket-preimage")), k, c.Bool("fake-sectors"))
+		gm, key, err := seed.PreSeal(maddr, rp, abi.SectorNumber(c.Uint64("sector-offset")), c.Int("num-sectors"), sbroot, []byte(c.String("ticket-preimage")), k, c.Bool("fake-sectors"))
 		if err != nil {
 			return err
 		}

cmd/lotus-seed/seed/seed.go

@@ -19,10 +19,9 @@ import (
 
 	ffi "github.com/filecoin-project/filecoin-ffi"
 	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/go-commp-utils/zerocomm"
 	"github.com/filecoin-project/go-state-types/abi"
 	"github.com/filecoin-project/go-state-types/big"
-	"github.com/filecoin-project/specs-storage/storage"
+	"github.com/filecoin-project/lotus/extern/sector-storage/zerocomm"
 
 	market2 "github.com/filecoin-project/specs-actors/v2/actors/builtin/market"
 
@@ -43,6 +42,10 @@ func PreSeal(maddr address.Address, spt abi.RegisteredSealProof, offset abi.Sect
 		return nil, nil, err
 	}
 
+	cfg := &ffiwrapper.Config{
+		SealProofType: spt,
+	}
+
 	if err := os.MkdirAll(sbroot, 0775); err != nil { //nolint:gosec
 		return nil, nil, err
 	}
@@ -53,7 +56,7 @@ func PreSeal(maddr address.Address, spt abi.RegisteredSealProof, offset abi.Sect
 		Root: sbroot,
 	}
 
-	sb, err := ffiwrapper.New(sbfs)
+	sb, err := ffiwrapper.New(sbfs, cfg)
 	if err != nil {
 		return nil, nil, err
 	}
@@ -66,17 +69,16 @@ func PreSeal(maddr address.Address, spt abi.RegisteredSealProof, offset abi.Sect
 	var sealedSectors []*genesis.PreSeal
 	for i := 0; i < sectors; i++ {
 		sid := abi.SectorID{Miner: abi.ActorID(mid), Number: next}
-		ref := storage.SectorRef{ID: sid, ProofType: spt}
 		next++
 
 		var preseal *genesis.PreSeal
 		if !fakeSectors {
-			preseal, err = presealSector(sb, sbfs, ref, ssize, preimage)
+			preseal, err = presealSector(sb, sbfs, sid, spt, ssize, preimage)
 			if err != nil {
 				return nil, nil, err
 			}
 		} else {
-			preseal, err = presealSectorFake(sbfs, ref, ssize)
+			preseal, err = presealSectorFake(sbfs, sid, spt, ssize)
 			if err != nil {
 				return nil, nil, err
 			}
@@ -146,7 +148,7 @@ func PreSeal(maddr address.Address, spt abi.RegisteredSealProof, offset abi.Sect
 	return miner, &minerAddr.KeyInfo, nil
 }
 
-func presealSector(sb *ffiwrapper.Sealer, sbfs *basicfs.Provider, sid storage.SectorRef, ssize abi.SectorSize, preimage []byte) (*genesis.PreSeal, error) {
+func presealSector(sb *ffiwrapper.Sealer, sbfs *basicfs.Provider, sid abi.SectorID, spt abi.RegisteredSealProof, ssize abi.SectorSize, preimage []byte) (*genesis.PreSeal, error) {
 	pi, err := sb.AddPiece(context.TODO(), sid, nil, abi.PaddedPieceSize(ssize).Unpadded(), rand.Reader)
 	if err != nil {
 		return nil, err
@@ -180,12 +182,12 @@ func presealSector(sb *ffiwrapper.Sealer, sbfs *basicfs.Provider, sid storage.Se
 	return &genesis.PreSeal{
 		CommR:     cids.Sealed,
 		CommD:     cids.Unsealed,
-		SectorID:  sid.ID.Number,
-		ProofType: sid.ProofType,
+		SectorID:  sid.Number,
+		ProofType: spt,
 	}, nil
 }
 
-func presealSectorFake(sbfs *basicfs.Provider, sid storage.SectorRef, ssize abi.SectorSize) (*genesis.PreSeal, error) {
+func presealSectorFake(sbfs *basicfs.Provider, sid abi.SectorID, spt abi.RegisteredSealProof, ssize abi.SectorSize) (*genesis.PreSeal, error) {
 	paths, done, err := sbfs.AcquireSector(context.TODO(), sid, 0, storiface.FTSealed|storiface.FTCache, storiface.PathSealing)
 	if err != nil {
 		return nil, xerrors.Errorf("acquire unsealed sector: %w", err)
@@ -196,7 +198,7 @@ func presealSectorFake(sbfs *basicfs.Provider, sid storage.SectorRef, ssize abi.
 		return nil, xerrors.Errorf("mkdir cache: %w", err)
 	}
 
-	commr, err := ffi.FauxRep(sid.ProofType, paths.Cache, paths.Sealed)
+	commr, err := ffi.FauxRep(spt, paths.Cache, paths.Sealed)
 	if err != nil {
 		return nil, xerrors.Errorf("fauxrep: %w", err)
 	}
@@ -204,13 +206,13 @@ func presealSectorFake(sbfs *basicfs.Provider, sid storage.SectorRef, ssize abi.
 	return &genesis.PreSeal{
 		CommR:     commr,
 		CommD:     zerocomm.ZeroPieceCommitment(abi.PaddedPieceSize(ssize).Unpadded()),
-		SectorID:  sid.ID.Number,
-		ProofType: sid.ProofType,
+		SectorID:  sid.Number,
+		ProofType: spt,
 	}, nil
 }
 
-func cleanupUnsealed(sbfs *basicfs.Provider, ref storage.SectorRef) error {
-	paths, done, err := sbfs.AcquireSector(context.TODO(), ref, storiface.FTUnsealed, storiface.FTNone, storiface.PathSealing)
+func cleanupUnsealed(sbfs *basicfs.Provider, sid abi.SectorID) error {
+	paths, done, err := sbfs.AcquireSector(context.TODO(), sid, storiface.FTUnsealed, storiface.FTNone, storiface.PathSealing)
 	if err != nil {
 		return err
 	}

cmd/lotus-shed/balances.go

@@ -2,13 +2,9 @@ package main
 
 import (
 	"context"
-	"encoding/csv"
 	"fmt"
 	"io"
-	"os"
 	"strconv"
-	"strings"
-	"time"
 
 	"github.com/filecoin-project/lotus/chain/gen/genesis"
 
@@ -66,7 +62,6 @@ var auditsCmd = &cli.Command{
 		chainBalanceCmd,
 		chainBalanceStateCmd,
 		chainPledgeCmd,
-		fillBalancesCmd,
 	},
 }
 
@@ -194,7 +189,6 @@ var chainBalanceStateCmd = &cli.Command{
 		}
 
 		cs := store.NewChainStore(bs, bs, mds, vm.Syscalls(ffiwrapper.ProofVerifier), nil)
-		defer cs.Close() //nolint:errcheck
 
 		cst := cbor.NewCborStore(bs)
 		store := adt.WrapStore(ctx, cst)
@@ -415,7 +409,6 @@ var chainPledgeCmd = &cli.Command{
 		}
 
 		cs := store.NewChainStore(bs, bs, mds, vm.Syscalls(ffiwrapper.ProofVerifier), nil)
-		defer cs.Close() //nolint:errcheck
 
 		cst := cbor.NewCborStore(bs)
 		store := adt.WrapStore(ctx, cst)
@@ -492,119 +485,3 @@ var chainPledgeCmd = &cli.Command{
 		return nil
 	},
 }
-
-const dateFmt = "1/02/06"
-
-func parseCsv(inp string) ([]time.Time, []address.Address, error) {
-	fi, err := os.Open(inp)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	r := csv.NewReader(fi)
-	recs, err := r.ReadAll()
-	if err != nil {
-		return nil, nil, err
-	}
-
-	var addrs []address.Address
-	for _, rec := range recs[1:] {
-		a, err := address.NewFromString(rec[0])
-		if err != nil {
-			return nil, nil, err
-		}
-		addrs = append(addrs, a)
-	}
-
-	var dates []time.Time
-	for _, d := range recs[0][1:] {
-		if len(d) == 0 {
-			continue
-		}
-		p := strings.Split(d, " ")
-		t, err := time.Parse(dateFmt, p[len(p)-1])
-		if err != nil {
-			return nil, nil, err
-		}
-
-		dates = append(dates, t)
-	}
-
-	return dates, addrs, nil
-}
-
-func heightForDate(d time.Time, ts *types.TipSet) abi.ChainEpoch {
-	secs := d.Unix()
-	gents := ts.Blocks()[0].Timestamp
-	gents -= uint64(30 * ts.Height())
-	return abi.ChainEpoch((secs - int64(gents)) / 30)
-}
-
-var fillBalancesCmd = &cli.Command{
-	Name:        "fill-balances",
-	Description: "fill out balances for addresses on dates in given spreadsheet",
-	Flags:       []cli.Flag{},
-	Action: func(cctx *cli.Context) error {
-		api, closer, err := lcli.GetFullNodeAPI(cctx)
-		if err != nil {
-			return err
-		}
-
-		defer closer()
-		ctx := lcli.ReqContext(cctx)
-
-		dates, addrs, err := parseCsv(cctx.Args().First())
-		if err != nil {
-			return err
-		}
-
-		ts, err := api.ChainHead(ctx)
-		if err != nil {
-			return err
-		}
-
-		var tipsets []*types.TipSet
-		for _, d := range dates {
-			h := heightForDate(d, ts)
-			hts, err := api.ChainGetTipSetByHeight(ctx, h, ts.Key())
-			if err != nil {
-				return err
-			}
-			tipsets = append(tipsets, hts)
-		}
-
-		var balances [][]abi.TokenAmount
-		for _, a := range addrs {
-			var b []abi.TokenAmount
-			for _, hts := range tipsets {
-				act, err := api.StateGetActor(ctx, a, hts.Key())
-				if err != nil {
-					if !strings.Contains(err.Error(), "actor not found") {
-						return fmt.Errorf("error for %s at %s: %w", a, hts.Key(), err)
-					}
-					b = append(b, types.NewInt(0))
-					continue
-				}
-				b = append(b, act.Balance)
-			}
-			balances = append(balances, b)
-		}
-
-		var datestrs []string
-		for _, d := range dates {
-			datestrs = append(datestrs, "Balance at "+d.Format(dateFmt))
-		}
-
-		w := csv.NewWriter(os.Stdout)
-		w.Write(append([]string{"Wallet Address"}, datestrs...)) // nolint:errcheck
-		for i := 0; i < len(addrs); i++ {
-			row := []string{addrs[i].String()}
-			for _, b := range balances[i] {
-				row = append(row, types.FIL(b).String())
-			}
-			w.Write(row) // nolint:errcheck
-		}
-		w.Flush()
-		return nil
-	},
-}

cmd/lotus-shed/blockmsgid.go

@@ -1,70 +0,0 @@
-package main
-
-import (
-	"encoding/base64"
-	"fmt"
-
-	blake2b "github.com/minio/blake2b-simd"
-	"github.com/urfave/cli/v2"
-
-	"github.com/ipfs/go-cid"
-
-	"github.com/filecoin-project/lotus/chain/types"
-	lcli "github.com/filecoin-project/lotus/cli"
-)
-
-var blockmsgidCmd = &cli.Command{
-	Name:      "blockmsgid",
-	Usage:     "Print a block's pubsub message ID",
-	ArgsUsage: "<blockCid> ...",
-	Action: func(cctx *cli.Context) error {
-		api, closer, err := lcli.GetFullNodeAPI(cctx)
-		if err != nil {
-			return err
-		}
-
-		defer closer()
-		ctx := lcli.ReqContext(cctx)
-
-		for _, arg := range cctx.Args().Slice() {
-			blkcid, err := cid.Decode(arg)
-			if err != nil {
-				return fmt.Errorf("error decoding block cid: %w", err)
-			}
-
-			blkhdr, err := api.ChainGetBlock(ctx, blkcid)
-			if err != nil {
-				return fmt.Errorf("error retrieving block header: %w", err)
-			}
-
-			blkmsgs, err := api.ChainGetBlockMessages(ctx, blkcid)
-			if err != nil {
-				return fmt.Errorf("error retrieving block messages: %w", err)
-			}
-
-			blkmsg := &types.BlockMsg{
-				Header: blkhdr,
-			}
-
-			for _, m := range blkmsgs.BlsMessages {
-				blkmsg.BlsMessages = append(blkmsg.BlsMessages, m.Cid())
-			}
-
-			for _, m := range blkmsgs.SecpkMessages {
-				blkmsg.SecpkMessages = append(blkmsg.SecpkMessages, m.Cid())
-			}
-
-			bytes, err := blkmsg.Serialize()
-			if err != nil {
-				return fmt.Errorf("error serializing BlockMsg: %w", err)
-			}
-
-			msgId := blake2b.Sum256(bytes)
-			msgId64 := base64.StdEncoding.EncodeToString(msgId[:])
-
-			fmt.Println(msgId64)
-		}
-
-		return nil
-	},
-}

cmd/lotus-shed/cid.go

@@ -5,78 +5,44 @@ import (
 	"encoding/hex"
 	"fmt"
 
-	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/urfave/cli/v2"
+
 	"github.com/ipfs/go-cid"
 	mh "github.com/multiformats/go-multihash"
-	"github.com/urfave/cli/v2"
-	"golang.org/x/xerrors"
 )
 
 var cidCmd = &cli.Command{
-	Name:  "cid",
-	Usage: "Cid command",
+	Name: "cid",
 	Subcommands: cli.Commands{
 		cidIdCmd,
 	},
 }
 
 var cidIdCmd = &cli.Command{
-	Name:      "id",
-	Usage:     "Create identity CID from hex or base64 data",
-	ArgsUsage: "[data]",
-	Flags: []cli.Flag{
-		&cli.StringFlag{
-			Name:  "encoding",
-			Value: "base64",
-			Usage: "specify input encoding to parse",
-		},
-		&cli.StringFlag{
-			Name:  "codec",
-			Value: "id",
-			Usage: "multicodec-packed content types: abi or id",
-		},
-	},
+	Name:  "id",
+	Usage: "create identity CID from hex or base64 data",
 	Action: func(cctx *cli.Context) error {
 		if !cctx.Args().Present() {
 			return fmt.Errorf("must specify data")
 		}
 
-		var dec []byte
-		switch cctx.String("encoding") {
-		case "base64":
-			data, err := base64.StdEncoding.DecodeString(cctx.Args().First())
+		dec, err := hex.DecodeString(cctx.Args().First())
+		if err != nil {
+			dec, err = base64.StdEncoding.DecodeString(cctx.Args().First())
 			if err != nil {
-				return xerrors.Errorf("decoding base64 value: %w", err)
+				return err
 			}
-			dec = data
-		case "hex":
-			data, err := hex.DecodeString(cctx.Args().First())
-			if err != nil {
-				return xerrors.Errorf("decoding hex value: %w", err)
-			}
-			dec = data
-		default:
-			return xerrors.Errorf("unrecognized encoding: %s", cctx.String("encoding"))
+
 		}
 
-		switch cctx.String("codec") {
-		case "abi":
-			aCid, err := abi.CidBuilder.Sum(dec)
-			if err != nil {
-				return xerrors.Errorf("cidBuilder abi: %w", err)
-			}
-			fmt.Println(aCid)
-		case "id":
-			builder := cid.V1Builder{Codec: cid.Raw, MhType: mh.IDENTITY}
-			rCid, err := builder.Sum(dec)
-			if err != nil {
-				return xerrors.Errorf("cidBuilder raw: %w", err)
-			}
-			fmt.Println(rCid)
-		default:
-			return xerrors.Errorf("unrecognized codec: %s", cctx.String("codec"))
+		builder := cid.V1Builder{Codec: cid.Raw, MhType: mh.IDENTITY}
+
+		c, err := builder.Sum(dec)
+		if err != nil {
+			return err
 		}
 
+		fmt.Println(c)
 		return nil
 	},
 }

cmd/lotus-shed/commp.go

@@ -1,55 +1,27 @@
 package main
 
 import (
-	"encoding/base64"
 	"encoding/hex"
 	"fmt"
 
 	commcid "github.com/filecoin-project/go-fil-commcid"
 	"github.com/urfave/cli/v2"
-	"golang.org/x/xerrors"
 )
 
 var commpToCidCmd = &cli.Command{
 	Name:        "commp-to-cid",
-	Usage:       "Convert commP to Cid",
 	Description: "Convert a raw commP to a piece-Cid",
-	ArgsUsage:   "[data]",
-	Flags: []cli.Flag{
-		&cli.StringFlag{
-			Name:  "encoding",
-			Value: "base64",
-			Usage: "specify input encoding to parse",
-		},
-	},
 	Action: func(cctx *cli.Context) error {
 		if !cctx.Args().Present() {
 			return fmt.Errorf("must specify commP to convert")
 		}
 
-		var dec []byte
-		switch cctx.String("encoding") {
-		case "base64":
-			data, err := base64.StdEncoding.DecodeString(cctx.Args().First())
-			if err != nil {
-				return xerrors.Errorf("decoding base64 value: %w", err)
-			}
-			dec = data
-		case "hex":
-			data, err := hex.DecodeString(cctx.Args().First())
-			if err != nil {
-				return xerrors.Errorf("decoding hex value: %w", err)
-			}
-			dec = data
-		default:
-			return xerrors.Errorf("unrecognized encoding: %s", cctx.String("encoding"))
+		dec, err := hex.DecodeString(cctx.Args().First())
+		if err != nil {
+			return fmt.Errorf("failed to decode input as hex string: %w", err)
 		}
 
-		cid, err := commcid.PieceCommitmentV1ToCID(dec)
-		if err != nil {
-			return err
-		}
-		fmt.Println(cid)
+		fmt.Println(commcid.PieceCommitmentV1ToCID(dec))
 		return nil
 	},
 }

cmd/lotus-shed/dealtracker.go

@@ -0,0 +1,325 @@
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"net"
+	"net/http"
+	"sync"
+
+	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/go-state-types/abi"
+	"github.com/filecoin-project/lotus/api"
+	lcli "github.com/filecoin-project/lotus/cli"
+	"github.com/ipfs/go-cid"
+	"github.com/urfave/cli/v2"
+)
+
+type dealStatsServer struct {
+	api api.FullNode
+}
+
+// Requested by @jbenet
+// How many epochs back to look at for dealstats
+var epochLookback = abi.ChainEpoch(10)
+
+// these lists grow continuously with the network
+// TODO: need to switch this to an LRU of sorts, to ensure refreshes
+var knownFiltered = new(sync.Map)
+var resolvedWallets = new(sync.Map)
+
+func init() {
+	for _, a := range []string{
+		"t0100", // client for genesis miner
+		"t0101", // client for genesis miner
+		"t0102", // client for genesis miner
+		"t0112", // client for genesis miner
+		"t0113", // client for genesis miner
+		"t0114", // client for genesis miner
+		"t1nslxql4pck5pq7hddlzym3orxlx35wkepzjkm3i", // SR1 dealbot wallet
+		"t1stghxhdp2w53dym2nz2jtbpk6ccd4l2lxgmezlq", // SR1 dealbot wallet
+		"t1mcr5xkgv4jdl3rnz77outn6xbmygb55vdejgbfi", // SR1 dealbot wallet
+		"t1qiqdbbmrdalbntnuapriirduvxu5ltsc5mhy7si", // SR1 dealbot wallet
+	} {
+		a, err := address.NewFromString(a)
+		if err != nil {
+			panic(err)
+		}
+		knownFiltered.Store(a, true)
+	}
+}
+
+type dealCountResp struct {
+	Epoch    int64  `json:"epoch"`
+	Endpoint string `json:"endpoint"`
+	Payload  int64  `json:"payload"`
+}
+
+func (dss *dealStatsServer) handleStorageDealCount(w http.ResponseWriter, r *http.Request) {
+
+	epoch, deals := dss.filteredDealList()
+	if epoch == 0 {
+		w.WriteHeader(500)
+		return
+	}
+
+	if err := json.NewEncoder(w).Encode(&dealCountResp{
+		Endpoint: "COUNT_DEALS",
+		Payload:  int64(len(deals)),
+		Epoch:    epoch,
+	}); err != nil {
+		log.Warnf("failed to write back deal count response: %s", err)
+		return
+	}
+}
+
+type dealAverageResp struct {
+	Epoch    int64  `json:"epoch"`
+	Endpoint string `json:"endpoint"`
+	Payload  int64  `json:"payload"`
+}
+
+func (dss *dealStatsServer) handleStorageDealAverageSize(w http.ResponseWriter, r *http.Request) {
+
+	epoch, deals := dss.filteredDealList()
+	if epoch == 0 {
+		w.WriteHeader(500)
+		return
+	}
+
+	var totalBytes int64
+	for _, d := range deals {
+		totalBytes += int64(d.deal.Proposal.PieceSize.Unpadded())
+	}
+
+	if err := json.NewEncoder(w).Encode(&dealAverageResp{
+		Endpoint: "AVERAGE_DEAL_SIZE",
+		Payload:  totalBytes / int64(len(deals)),
+		Epoch:    epoch,
+	}); err != nil {
+		log.Warnf("failed to write back deal average response: %s", err)
+		return
+	}
+}
+
+type dealTotalResp struct {
+	Epoch    int64  `json:"epoch"`
+	Endpoint string `json:"endpoint"`
+	Payload  int64  `json:"payload"`
+}
+
+func (dss *dealStatsServer) handleStorageDealTotalReal(w http.ResponseWriter, r *http.Request) {
+	epoch, deals := dss.filteredDealList()
+	if epoch == 0 {
+		w.WriteHeader(500)
+		return
+	}
+
+	var totalBytes int64
+	for _, d := range deals {
+		totalBytes += int64(d.deal.Proposal.PieceSize.Unpadded())
+	}
+
+	if err := json.NewEncoder(w).Encode(&dealTotalResp{
+		Endpoint: "DEAL_BYTES",
+		Payload:  totalBytes,
+		Epoch:    epoch,
+	}); err != nil {
+		log.Warnf("failed to write back deal average response: %s", err)
+		return
+	}
+
+}
+
+type clientStatsOutput struct {
+	Epoch    int64          `json:"epoch"`
+	Endpoint string         `json:"endpoint"`
+	Payload  []*clientStats `json:"payload"`
+}
+
+type clientStats struct {
+	Client    address.Address `json:"client"`
+	DataSize  int64           `json:"data_size"`
+	NumCids   int             `json:"num_cids"`
+	NumDeals  int             `json:"num_deals"`
+	NumMiners int             `json:"num_miners"`
+
+	cids      map[cid.Cid]bool
+	providers map[address.Address]bool
+}
+
+func (dss *dealStatsServer) handleStorageClientStats(w http.ResponseWriter, r *http.Request) {
+	epoch, deals := dss.filteredDealList()
+	if epoch == 0 {
+		w.WriteHeader(500)
+		return
+	}
+
+	stats := make(map[address.Address]*clientStats)
+
+	for _, d := range deals {
+
+		st, ok := stats[d.deal.Proposal.Client]
+		if !ok {
+			st = &clientStats{
+				Client:    d.resolvedWallet,
+				cids:      make(map[cid.Cid]bool),
+				providers: make(map[address.Address]bool),
+			}
+			stats[d.deal.Proposal.Client] = st
+		}
+
+		st.DataSize += int64(d.deal.Proposal.PieceSize.Unpadded())
+		st.cids[d.deal.Proposal.PieceCID] = true
+		st.providers[d.deal.Proposal.Provider] = true
+		st.NumDeals++
+	}
+
+	out := clientStatsOutput{
+		Epoch:    epoch,
+		Endpoint: "CLIENT_DEAL_STATS",
+		Payload:  make([]*clientStats, 0, len(stats)),
+	}
+	for _, cs := range stats {
+		cs.NumCids = len(cs.cids)
+		cs.NumMiners = len(cs.providers)
+		out.Payload = append(out.Payload, cs)
+	}
+
+	if err := json.NewEncoder(w).Encode(out); err != nil {
+		log.Warnf("failed to write back client stats response: %s", err)
+		return
+	}
+}
+
+type dealInfo struct {
+	deal           api.MarketDeal
+	resolvedWallet address.Address
+}
+
+// filteredDealList returns the current epoch and a list of filtered deals
+// on error returns an epoch of 0
+func (dss *dealStatsServer) filteredDealList() (int64, map[string]dealInfo) {
+	ctx := context.Background()
+
+	head, err := dss.api.ChainHead(ctx)
+	if err != nil {
+		log.Warnf("failed to get chain head: %s", err)
+		return 0, nil
+	}
+
+	head, err = dss.api.ChainGetTipSetByHeight(ctx, head.Height()-epochLookback, head.Key())
+	if err != nil {
+		log.Warnf("failed to walk back %s epochs: %s", epochLookback, err)
+		return 0, nil
+	}
+
+	// Disabled as per @pooja's request
+	//
+	// // Exclude any address associated with a miner
+	// miners, err := dss.api.StateListMiners(ctx, head.Key())
+	// if err != nil {
+	// 	log.Warnf("failed to get miner list: %s", err)
+	// 	return 0, nil
+	// }
+	// for _, m := range miners {
+	// 	info, err := dss.api.StateMinerInfo(ctx, m, head.Key())
+	// 	if err != nil {
+	// 		log.Warnf("failed to get info for known miner '%s': %s", m, err)
+	// 		continue
+	// 	}
+
+	// 	knownFiltered.Store(info.Owner, true)
+	// 	knownFiltered.Store(info.Worker, true)
+	// 	for _, a := range info.ControlAddresses {
+	// 		knownFiltered.Store(a, true)
+	// 	}
+	// }
+
+	deals, err := dss.api.StateMarketDeals(ctx, head.Key())
+	if err != nil {
+		log.Warnf("failed to get market deals: %s", err)
+		return 0, nil
+	}
+
+	ret := make(map[string]dealInfo, len(deals))
+	for dealKey, d := range deals {
+
+		// Counting no-longer-active deals as per Pooja's request
+		// // https://github.com/filecoin-project/specs-actors/blob/v0.9.9/actors/builtin/market/deal.go#L81-L85
+		// if d.State.SectorStartEpoch < 0 {
+		// 	continue
+		// }
+
+		if _, isFiltered := knownFiltered.Load(d.Proposal.Client); isFiltered {
+			continue
+		}
+
+		if _, wasSeen := resolvedWallets.Load(d.Proposal.Client); !wasSeen {
+			w, err := dss.api.StateAccountKey(ctx, d.Proposal.Client, head.Key())
+			if err != nil {
+				log.Warnf("failed to resolve id '%s' to wallet address: %s", d.Proposal.Client, err)
+				continue
+			} else {
+				resolvedWallets.Store(d.Proposal.Client, w)
+			}
+		}
+
+		w, _ := resolvedWallets.Load(d.Proposal.Client)
+		if _, isFiltered := knownFiltered.Load(w); isFiltered {
+			continue
+		}
+
+		ret[dealKey] = dealInfo{
+			deal:           d,
+			resolvedWallet: w.(address.Address),
+		}
+	}
+
+	return int64(head.Height()), ret
+}
+
+var serveDealStatsCmd = &cli.Command{
+	Name:  "serve-deal-stats",
+	Flags: []cli.Flag{},
+	Action: func(cctx *cli.Context) error {
+		api, closer, err := lcli.GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+
+		defer closer()
+		ctx := lcli.ReqContext(cctx)
+
+		_ = ctx
+
+		dss := &dealStatsServer{api}
+
+		mux := &http.ServeMux{}
+		mux.HandleFunc("/api/storagedeal/count", dss.handleStorageDealCount)
+		mux.HandleFunc("/api/storagedeal/averagesize", dss.handleStorageDealAverageSize)
+		mux.HandleFunc("/api/storagedeal/totalreal", dss.handleStorageDealTotalReal)
+		mux.HandleFunc("/api/storagedeal/clientstats", dss.handleStorageClientStats)
+
+		s := &http.Server{
+			Addr:    ":7272",
+			Handler: mux,
+		}
+
+		go func() {
+			<-ctx.Done()
+			if err := s.Shutdown(context.TODO()); err != nil {
+				log.Error(err)
+			}
+		}()
+
+		list, err := net.Listen("tcp", ":7272") // nolint
+		if err != nil {
+			panic(err)
+		}
+
+		log.Warnf("deal-stat server listening on %s\n== NOTE: QUERIES ARE EXPENSIVE - YOU MUST FRONT-CACHE THIS SERVICE\n", list.Addr().String())
+
+		return s.Serve(list)
+	},
+}

cmd/lotus-shed/export.go

@@ -91,8 +91,6 @@ var exportChainCmd = &cli.Command{
 		}
 
 		cs := store.NewChainStore(bs, bs, mds, nil, nil)
-		defer cs.Close() //nolint:errcheck
-
 		if err := cs.Load(); err != nil {
 			return err
 		}

cmd/lotus-shed/genesis-verify.go

@@ -53,7 +53,6 @@ var genesisVerifyCmd = &cli.Command{
 		bs := blockstore.NewBlockstore(datastore.NewMapDatastore())
 
 		cs := store.NewChainStore(bs, bs, datastore.NewMapDatastore(), nil, nil)
-		defer cs.Close() //nolint:errcheck
 
 		cf := cctx.Args().Get(0)
 		f, err := os.Open(cf)

cmd/lotus-shed/ledger.go

@@ -8,7 +8,6 @@ import (
 
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/big"
-	"github.com/filecoin-project/go-state-types/crypto"
 	"github.com/urfave/cli/v2"
 	ledgerfil "github.com/whyrusleeping/ledger-filecoin-go"
 
@@ -26,7 +25,6 @@ var ledgerCmd = &cli.Command{
 		ledgerListAddressesCmd,
 		ledgerKeyInfoCmd,
 		ledgerSignTestCmd,
-		ledgerShowCmd,
 	},
 }
 
@@ -59,7 +57,6 @@ var ledgerListAddressesCmd = &cli.Command{
 		if err != nil {
 			return err
 		}
-		defer fl.Close() // nolint
 
 		end := 20
 		for i := 0; i < end; i++ {
@@ -169,7 +166,6 @@ var ledgerKeyInfoCmd = &cli.Command{
 		if err != nil {
 			return err
 		}
-		defer fl.Close() // nolint
 
 		p, err := parseHDPath(cctx.Args().First())
 		if err != nil {
@@ -246,46 +242,13 @@ var ledgerSignTestCmd = &cli.Command{
 		if err != nil {
 			return err
 		}
-		fmt.Printf("Message: %x\n", b.RawData())
 
 		sig, err := fl.SignSECP256K1(p, b.RawData())
 		if err != nil {
 			return err
 		}
 
-		sigBytes := append([]byte{byte(crypto.SigTypeSecp256k1)}, sig.SignatureBytes()...)
-
-		fmt.Printf("Signature: %x\n", sigBytes)
-
-		return nil
-	},
-}
-
-var ledgerShowCmd = &cli.Command{
-	Name:      "show",
-	ArgsUsage: "[hd path]",
-	Action: func(cctx *cli.Context) error {
-		if !cctx.Args().Present() {
-			return cli.ShowCommandHelp(cctx, cctx.Command.Name)
-		}
-
-		fl, err := ledgerfil.FindLedgerFilecoinApp()
-		if err != nil {
-			return err
-		}
-		defer fl.Close() // nolint
-
-		p, err := parseHDPath(cctx.Args().First())
-		if err != nil {
-			return err
-		}
-
-		_, _, a, err := fl.ShowAddressPubKeySECP256K1(p)
-		if err != nil {
-			return err
-		}
-
-		fmt.Println(a)
+		fmt.Println(sig.SignatureBytes())
 
 		return nil
 	},

cmd/lotus-shed/main.go

@@ -30,7 +30,6 @@ func main() {
 		importObjectCmd,
 		commpToCidCmd,
 		fetchParamCmd,
-		postFindCmd,
 		proofsCmd,
 		verifRegCmd,
 		miscCmd,
@@ -40,7 +39,7 @@ func main() {
 		mpoolStatsCmd,
 		exportChainCmd,
 		consensusCmd,
-		rollupDealStatsCmd,
+		serveDealStatsCmd,
 		syncCmd,
 		stateTreePruneCmd,
 		datastoreCmd,
@@ -50,7 +49,6 @@ func main() {
 		electionCmd,
 		rpcCmd,
 		cidCmd,
-		blockmsgidCmd,
 	}
 
 	app := &cli.App{