Merge branch 'master' into release/v1.2.0

2020-11-15 19:03:18 -05:00 · 2020-11-15 19:03:18 -05:00 · 6d0b3978b9
commit 6d0b3978b9
parent 5d9c79811f afe6c51016
40 changed files with 3225 additions and 145 deletions
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@ -359,6 +359,7 @@ jobs:
    steps:
      - install-deps
      - prepare
+      - run: make deps
      - run: make docsgen
      - run: git --no-pager diff
      - run: git --no-pager diff --quiet
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -1,5 +1,132 @@
 # Lotus changelog

+# 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.
+
+## Highlights
+
+- Refactored much of the miner code (https://github.com/filecoin-project/lotus/pull/3618), improving its recovery from restarts and overall sector success rate
+- Updated [proofs](https://github.com/filecoin-project/rust-fil-proofs) to v5.3.0, which brings significant performance improvements
+- Updated [markets](https://github.com/filecoin-project/go-fil-markets/releases/tag/v1.0.4) to v1.0.4, which reduces failures due to reorgs (https://github.com/filecoin-project/lotus/pull/4730) and uses the newly refactored fund manager (https://github.com/filecoin-project/lotus/pull/4736)
+
+## Changes
+
+#### Core Lotus
+
+- polish: add Equals method to MinerInfo shim (https://github.com/filecoin-project/lotus/pull/4604)
+- Fix messagepool accounting (https://github.com/filecoin-project/lotus/pull/4668)
+- Prep for gas balancing (https://github.com/filecoin-project/lotus/pull/4651)
+- Reduce badger ValueThreshold to 128 (https://github.com/filecoin-project/lotus/pull/4629)
+- Config for default max gas fee (https://github.com/filecoin-project/lotus/pull/4652)
+- bootstrap: don't return early when one drand resolution fails (https://github.com/filecoin-project/lotus/pull/4626)
+- polish: add ClaimsChanged and DiffClaims method to power shim (https://github.com/filecoin-project/lotus/pull/4628)
+- Simplify chain event Called API (https://github.com/filecoin-project/lotus/pull/4664)
+- Cache deal states for most recent old/new tipset (https://github.com/filecoin-project/lotus/pull/4623)
+- Add miner available balance and power info to state miner info (https://github.com/filecoin-project/lotus/pull/4618)
+- Call GetHeaviestTipSet() only once when syncing (https://github.com/filecoin-project/lotus/pull/4696)
+- modify runtime gasUsed printf (https://github.com/filecoin-project/lotus/pull/4704)
+- Rename builtin actor generators (https://github.com/filecoin-project/lotus/pull/4697)
+- Move gas multiplier as property of pricelist (https://github.com/filecoin-project/lotus/pull/4728)
+- polish: add msig pendingtxn diffing and comp (https://github.com/filecoin-project/lotus/pull/4719)
+- Optional chain Bitswap (https://github.com/filecoin-project/lotus/pull/4717)
+- rewrite sync manager (https://github.com/filecoin-project/lotus/pull/4599)
+- async connect to bootstrappers (https://github.com/filecoin-project/lotus/pull/4785)
+- head change coalescer (https://github.com/filecoin-project/lotus/pull/4688)
+- move to native badger blockstore; leverage zero-copy View() to deserialize in-place (https://github.com/filecoin-project/lotus/pull/4681)
+- badger blockstore: minor improvements (https://github.com/filecoin-project/lotus/pull/4811)
+- Do not fail wallet delete because of pre-existing trashed key (https://github.com/filecoin-project/lotus/pull/4589)
+- Correctly delete the default wallet address (https://github.com/filecoin-project/lotus/pull/4705)
+- Reduce badger ValueTreshold to 128 (https://github.com/filecoin-project/lotus/pull/4629)
+- predicates: Fast StateGetActor wrapper (https://github.com/filecoin-project/lotus/pull/4835)
+
+#### Mining
+
+- worker key should change when set sender found key not equal with the value on chain (https://github.com/filecoin-project/lotus/pull/4595)
+- extern/sector-storage: fix GPU usage overwrite bug (https://github.com/filecoin-project/lotus/pull/4627)
+- sectorstorage: Fix manager restart edge-case (https://github.com/filecoin-project/lotus/pull/4645)
+- storagefsm: Fix GetTicket loop when the sector is already precommitted (https://github.com/filecoin-project/lotus/pull/4643)
+- Debug flag to force running sealing scheduler (https://github.com/filecoin-project/lotus/pull/4662)
+- Fix worker reenabling, handle multiple restarts in worker (https://github.com/filecoin-project/lotus/pull/4666)
+- keep retrying the proof until we run out of sectors to skip (https://github.com/filecoin-project/lotus/pull/4633)
+- worker: Commands to pause/resume task processing (https://github.com/filecoin-project/lotus/pull/4615)
+- struct name incorrect (https://github.com/filecoin-project/lotus/pull/4699)
+- optimize code replace strings with constants (https://github.com/filecoin-project/lotus/pull/4769)
+- optimize pledge sector (https://github.com/filecoin-project/lotus/pull/4765)
+- Track sealing processes across lotus-miner restarts (https://github.com/filecoin-project/lotus/pull/3618)
+- Fix scheduler lockups after storage is freed (https://github.com/filecoin-project/lotus/pull/4778)
+- storage: Track worker hostnames with work (https://github.com/filecoin-project/lotus/pull/4779)
+- Expand sched-diag; Command to abort sealing calls (https://github.com/filecoin-project/lotus/pull/4804)
+- miner: Winning PoSt Warmup (https://github.com/filecoin-project/lotus/pull/4824)
+- docsgen: Support miner/worker (https://github.com/filecoin-project/lotus/pull/4817)
+- miner: Basic storage cleanup command (https://github.com/filecoin-project/lotus/pull/4834)
+
+#### Markets and Data Transfer
+
+- Flesh out data transfer features (https://github.com/filecoin-project/lotus/pull/4572)
+- Fix memory leaks in data transfer (https://github.com/filecoin-project/lotus/pull/4619)
+- Handle deal id changes in OnDealSectorCommitted (https://github.com/filecoin-project/lotus/pull/4730)
+- Refactor FundManager (https://github.com/filecoin-project/lotus/pull/4736)
+- refactor: integrate new FundManager (https://github.com/filecoin-project/lotus/pull/4787)
+- Fix race in paych manager when req context is cancelled (https://github.com/filecoin-project/lotus/pull/4803)
+- fix race in paych manager add funds (https://github.com/filecoin-project/lotus/pull/4597)
+- Fix panic in FundManager (https://github.com/filecoin-project/lotus/pull/4808)
+- Fix: dont crash on startup if funds migration fails (https://github.com/filecoin-project/lotus/pull/4827)
+
+#### UX
+
+- Make EarlyExpiration in sectors list less scary (https://github.com/filecoin-project/lotus/pull/4600)
+- Add commands to change the worker key (https://github.com/filecoin-project/lotus/pull/4513)
+- Expose ClientDealSize via CLI (https://github.com/filecoin-project/lotus/pull/4569)
+- client deal: Cache CommD when creating multiple deals (https://github.com/filecoin-project/lotus/pull/4535)
+- miner sectors list: flags for events/seal time (https://github.com/filecoin-project/lotus/pull/4649)
+- make IPFS online mode configurable (https://github.com/filecoin-project/lotus/pull/4650)
+- Add sync status to miner info command (https://github.com/filecoin-project/lotus/pull/4669)
+- Add a StateDecodeParams method (https://github.com/filecoin-project/lotus/pull/4105)
+- sched: Interactive RPC Shell (https://github.com/filecoin-project/lotus/pull/4692)
+- Add api for getting status given a code (https://github.com/filecoin-project/lotus/pull/4210)
+- Update lotus-stats with a richer cli (https://github.com/filecoin-project/lotus/pull/4718)
+- Use TSK passed to GasEstimateGasLimit (https://github.com/filecoin-project/lotus/pull/4739)
+- match data type for reward state api (https://github.com/filecoin-project/lotus/pull/4745)
+- Add `termination-estimate` to get an estimation for how much a termination penalty will be (https://github.com/filecoin-project/lotus/pull/4617)
+- Restrict `ParseFIL` input length (https://github.com/filecoin-project/lotus/pull/4780)
+- cmd sectors commitIDs len debug (https://github.com/filecoin-project/lotus/pull/4786)
+- Add client deal-stats CLI (https://github.com/filecoin-project/lotus/pull/4788)
+- Modify printf format (https://github.com/filecoin-project/lotus/pull/4795)
+- Updated msig inspect (https://github.com/filecoin-project/lotus/pull/4533)
+- Delete the duplicate output (https://github.com/filecoin-project/lotus/pull/4819)
+- miner: Storage list sectors command (https://github.com/filecoin-project/lotus/pull/4831)
+- drop a few logs down to debug (https://github.com/filecoin-project/lotus/pull/4832)
+
+#### Testing and Tooling
+
+- refactor: share code between CLI tests (https://github.com/filecoin-project/lotus/pull/4598)
+- Fix flaky TestCLIDealFlow (https://github.com/filecoin-project/lotus/pull/4608)
+- Fix flaky testMiningReal (https://github.com/filecoin-project/lotus/pull/4609)
+- Add election run-dummy command (https://github.com/filecoin-project/lotus/pull/4498)
+- Fix .gitmodules (https://github.com/filecoin-project/lotus/pull/4713)
+- fix metrics wiring.(https://github.com/filecoin-project/lotus/pull/4691)
+- shed: Util for creating ID CIDs (https://github.com/filecoin-project/lotus/pull/4726)
+- Run kumquat upgrade on devnets (https://github.com/filecoin-project/lotus/pull/4734)
+- Make pond work again (https://github.com/filecoin-project/lotus/pull/4775)
+- lotus-stats: fix influx flags (https://github.com/filecoin-project/lotus/pull/4810)
+- 2k sync BootstrapPeerThreshold (https://github.com/filecoin-project/lotus/pull/4797)
+- test for FundManager panic to ensure it is fixed (https://github.com/filecoin-project/lotus/pull/4825)
+- Stop mining at the end of tests (https://github.com/filecoin-project/lotus/pull/4826)
+- Make some logs quieter (https://github.com/filecoin-project/lotus/pull/4709)
+
+#### Dependencies
+
+- update filecoin-ffi in go mod (https://github.com/filecoin-project/lotus/pull/4584)
+- Update FFI (https://github.com/filecoin-project/lotus/pull/4613)
+- feat: integrate new optional blst backend and verification optimizations from proofs (https://github.com/filecoin-project/lotus/pull/4630)
+- Use https for blst submodule (https://github.com/filecoin-project/lotus/pull/4710)
+- Update go-bitfield (https://github.com/filecoin-project/lotus/pull/4756)
+- Update Yamux (https://github.com/filecoin-project/lotus/pull/4758)
+- Update to latest go-bitfield (https://github.com/filecoin-project/lotus/pull/4793)
+- Update to latest go-address (https://github.com/filecoin-project/lotus/pull/4798)
+- update libp2p for stream interface changes (https://github.com/filecoin-project/lotus/pull/4814)
+
 # 1.1.2 / 2020-10-24

 This is a patch release of Lotus that builds on the fixes involving worker keys that was introduced in v1.1.1. Miners and node operators should update to this release as soon as possible in order to ensure their blocks are propagated and validated.
--- a/4
+++ b/4
@ -304,7 +304,9 @@ method-gen:
 gen: type-gen method-gen

 docsgen:
-	go run ./api/docgen > documentation/en/api-methods.md
+	go run ./api/docgen "api/api_full.go" "FullNode" > documentation/en/api-methods.md
+	go run ./api/docgen "api/api_storage.go" "StorageMiner" > documentation/en/api-methods-miner.md
+	go run ./api/docgen "api/api_worker.go" "WorkerAPI" > documentation/en/api-methods-worker.md

 print-%:
 	@echo $*=$($*)
--- a/api/docgen/docgen.go
+++ b/api/docgen/docgen.go
@ -6,12 +6,14 @@ import (
 	"go/ast"
 	"go/parser"
 	"go/token"
+	"os"
 	"reflect"
 	"sort"
 	"strings"
 	"time"
 	"unicode"

+	"github.com/google/uuid"
 	"github.com/ipfs/go-cid"
 	"github.com/ipfs/go-filestore"
 	metrics "github.com/libp2p/go-libp2p-core/metrics"
@ -24,6 +26,7 @@ import (
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-bitfield"
 	datatransfer "github.com/filecoin-project/go-data-transfer"
+	filestore2 "github.com/filecoin-project/go-fil-markets/filestore"
 	"github.com/filecoin-project/go-fil-markets/retrievalmarket"
 	"github.com/filecoin-project/go-jsonrpc/auth"
 	"github.com/filecoin-project/go-multistore"
@ -36,6 +39,10 @@ import (
 	"github.com/filecoin-project/lotus/api/apistruct"
 	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/filecoin-project/lotus/extern/sector-storage/sealtasks"
+	"github.com/filecoin-project/lotus/extern/sector-storage/stores"
+	"github.com/filecoin-project/lotus/extern/sector-storage/storiface"
+	sealing "github.com/filecoin-project/lotus/extern/storage-sealing"
 	"github.com/filecoin-project/lotus/node/modules/dtypes"
 )

@ -117,17 +124,17 @@ func init() {
 	addExample(network.ReachabilityPublic)
 	addExample(build.NewestNetworkVersion)
 	addExample(&types.ExecutionTrace{
-		Msg:    exampleValue(reflect.TypeOf(&types.Message{}), nil).(*types.Message),
-		MsgRct: exampleValue(reflect.TypeOf(&types.MessageReceipt{}), nil).(*types.MessageReceipt),
+		Msg:    exampleValue("init", reflect.TypeOf(&types.Message{}), nil).(*types.Message),
+		MsgRct: exampleValue("init", reflect.TypeOf(&types.MessageReceipt{}), nil).(*types.MessageReceipt),
 	})
 	addExample(map[string]types.Actor{
-		"t01236": exampleValue(reflect.TypeOf(types.Actor{}), nil).(types.Actor),
+		"t01236": exampleValue("init", reflect.TypeOf(types.Actor{}), nil).(types.Actor),
 	})
 	addExample(map[string]api.MarketDeal{
-		"t026363": exampleValue(reflect.TypeOf(api.MarketDeal{}), nil).(api.MarketDeal),
+		"t026363": exampleValue("init", reflect.TypeOf(api.MarketDeal{}), nil).(api.MarketDeal),
 	})
 	addExample(map[string]api.MarketBalance{
-		"t026363": exampleValue(reflect.TypeOf(api.MarketBalance{}), nil).(api.MarketBalance),
+		"t026363": exampleValue("init", reflect.TypeOf(api.MarketBalance{}), nil).(api.MarketBalance),
 	})
 	addExample(map[string]*pubsub.TopicScoreSnapshot{
 		"/blocks": {
@ -162,9 +169,80 @@ func init() {
 	// because reflect.TypeOf(maddr) returns the concrete type...
 	ExampleValues[reflect.TypeOf(struct{ A multiaddr.Multiaddr }{}).Field(0).Type] = maddr

+	// miner specific
+	addExample(filestore2.Path(".lotusminer/fstmp123"))
+	si := multistore.StoreID(12)
+	addExample(&si)
+	addExample(retrievalmarket.DealID(5))
+	addExample(abi.ActorID(1000))
+	addExample(map[string][]api.SealedRef{
+		"98000": {
+			api.SealedRef{
+				SectorID: 100,
+				Offset:   10 << 20,
+				Size:     1 << 20,
+			},
+		},
+	})
+	addExample(api.SectorState(sealing.Proving))
+	addExample(stores.ID("76f1988b-ef30-4d7e-b3ec-9a627f4ba5a8"))
+	addExample(storiface.FTUnsealed)
+	addExample(storiface.PathSealing)
+	addExample(map[stores.ID][]stores.Decl{
+		"76f1988b-ef30-4d7e-b3ec-9a627f4ba5a8": {
+			{
+				SectorID:       abi.SectorID{Miner: 1000, Number: 100},
+				SectorFileType: storiface.FTSealed,
+			},
+		},
+	})
+	addExample(map[stores.ID]string{
+		"76f1988b-ef30-4d7e-b3ec-9a627f4ba5a8": "/data/path",
+	})
+	addExample(map[uuid.UUID][]storiface.WorkerJob{
+		uuid.MustParse("ef8d99a2-6865-4189-8ffa-9fef0f806eee"): {
+			{
+				ID: storiface.CallID{
+					Sector: abi.SectorID{Miner: 1000, Number: 100},
+					ID:     uuid.MustParse("76081ba0-61bd-45a5-bc08-af05f1c26e5d"),
+				},
+				Sector:   abi.SectorID{Miner: 1000, Number: 100},
+				Task:     sealtasks.TTPreCommit2,
+				RunWait:  0,
+				Start:    time.Unix(1605172927, 0).UTC(),
+				Hostname: "host",
+			},
+		},
+	})
+	addExample(map[uuid.UUID]storiface.WorkerStats{
+		uuid.MustParse("ef8d99a2-6865-4189-8ffa-9fef0f806eee"): {
+			Info: storiface.WorkerInfo{
+				Hostname: "host",
+				Resources: storiface.WorkerResources{
+					MemPhysical: 256 << 30,
+					MemSwap:     120 << 30,
+					MemReserved: 2 << 30,
+					CPUs:        64,
+					GPUs:        []string{"aGPU 1337"},
+				},
+			},
+			Enabled:    true,
+			MemUsedMin: 0,
+			MemUsedMax: 0,
+			GpuUsed:    false,
+			CpuUse:     0,
+		},
+	})
+
+	// worker specific
+	addExample(storiface.AcquireMove)
+	addExample(storiface.UnpaddedByteIndex(abi.PaddedPieceSize(1 << 20).Unpadded()))
+	addExample(map[sealtasks.TaskType]struct{}{
+		sealtasks.TTPreCommit2: {},
+	})
 }

-func exampleValue(t, parent reflect.Type) interface{} {
+func exampleValue(method string, t, parent reflect.Type) interface{} {
 	v, ok := ExampleValues[t]
 	if ok {
 		return v
@ -173,25 +251,25 @@ func exampleValue(t, parent reflect.Type) interface{} {
 	switch t.Kind() {
 	case reflect.Slice:
 		out := reflect.New(t).Elem()
-		reflect.Append(out, reflect.ValueOf(exampleValue(t.Elem(), t)))
+		reflect.Append(out, reflect.ValueOf(exampleValue(method, t.Elem(), t)))
 		return out.Interface()
 	case reflect.Chan:
-		return exampleValue(t.Elem(), nil)
+		return exampleValue(method, t.Elem(), nil)
 	case reflect.Struct:
-		es := exampleStruct(t, parent)
+		es := exampleStruct(method, t, parent)
 		v := reflect.ValueOf(es).Elem().Interface()
 		ExampleValues[t] = v
 		return v
 	case reflect.Array:
 		out := reflect.New(t).Elem()
 		for i := 0; i < t.Len(); i++ {
-			out.Index(i).Set(reflect.ValueOf(exampleValue(t.Elem(), t)))
+			out.Index(i).Set(reflect.ValueOf(exampleValue(method, t.Elem(), t)))
 		}
 		return out.Interface()

 	case reflect.Ptr:
 		if t.Elem().Kind() == reflect.Struct {
-			es := exampleStruct(t.Elem(), t)
+			es := exampleStruct(method, t.Elem(), t)
 			//ExampleValues[t] = es
 			return es
 		}
@ -199,10 +277,10 @@ func exampleValue(t, parent reflect.Type) interface{} {
 		return struct{}{}
 	}

-	panic(fmt.Sprintf("No example value for type: %s", t))
+	panic(fmt.Sprintf("No example value for type: %s (method '%s')", t, method))
 }

-func exampleStruct(t, parent reflect.Type) interface{} {
+func exampleStruct(method string, t, parent reflect.Type) interface{} {
 	ns := reflect.New(t)
 	for i := 0; i < t.NumField(); i++ {
 		f := t.Field(i)
@ -210,7 +288,7 @@ func exampleStruct(t, parent reflect.Type) interface{} {
 			continue
 		}
 		if strings.Title(f.Name) == f.Name {
-			ns.Elem().Field(i).Set(reflect.ValueOf(exampleValue(f.Type, t)))
+			ns.Elem().Field(i).Set(reflect.ValueOf(exampleValue(method, f.Type, t)))
 		}
 	}

@ -218,6 +296,7 @@ func exampleStruct(t, parent reflect.Type) interface{} {
 }

 type Visitor struct {
+	Root    string
 	Methods map[string]ast.Node
 }

@ -227,7 +306,7 @@ func (v *Visitor) Visit(node ast.Node) ast.Visitor {
 		return v
 	}

-	if st.Name.Name != "FullNode" {
+	if st.Name.Name != v.Root {
 		return nil
 	}

@ -243,7 +322,7 @@ func (v *Visitor) Visit(node ast.Node) ast.Visitor {

 const noComment = "There are not yet any comments for this method."

-func parseApiASTInfo() (map[string]string, map[string]string) { //nolint:golint
+func parseApiASTInfo(apiFile, iface string) (map[string]string, map[string]string) { //nolint:golint
 	fset := token.NewFileSet()
 	pkgs, err := parser.ParseDir(fset, "./api", nil, parser.AllErrors|parser.ParseComments)
 	if err != nil {
@ -252,11 +331,11 @@ func parseApiASTInfo() (map[string]string, map[string]string) { //nolint:golint

 	ap := pkgs["api"]

-	f := ap.Files["api/api_full.go"]
+	f := ap.Files[apiFile]

 	cmap := ast.NewCommentMap(fset, f, f.Comments)

-	v := &Visitor{make(map[string]ast.Node)}
+	v := &Visitor{iface, make(map[string]ast.Node)}
 	ast.Walk(v, pkgs["api"])

 	groupDocs := make(map[string]string)
@ -312,13 +391,30 @@ func methodGroupFromName(mn string) string {
 }

 func main() {
-
-	comments, groupComments := parseApiASTInfo()
+	comments, groupComments := parseApiASTInfo(os.Args[1], os.Args[2])

 	groups := make(map[string]*MethodGroup)

-	var api struct{ api.FullNode }
-	t := reflect.TypeOf(api)
+	var t reflect.Type
+	var permStruct, commonPermStruct reflect.Type
+
+	switch os.Args[2] {
+	case "FullNode":
+		t = reflect.TypeOf(new(struct{ api.FullNode })).Elem()
+		permStruct = reflect.TypeOf(apistruct.FullNodeStruct{}.Internal)
+		commonPermStruct = reflect.TypeOf(apistruct.CommonStruct{}.Internal)
+	case "StorageMiner":
+		t = reflect.TypeOf(new(struct{ api.StorageMiner })).Elem()
+		permStruct = reflect.TypeOf(apistruct.StorageMinerStruct{}.Internal)
+		commonPermStruct = reflect.TypeOf(apistruct.CommonStruct{}.Internal)
+	case "WorkerAPI":
+		t = reflect.TypeOf(new(struct{ api.WorkerAPI })).Elem()
+		permStruct = reflect.TypeOf(apistruct.WorkerStruct{}.Internal)
+		commonPermStruct = reflect.TypeOf(apistruct.WorkerStruct{}.Internal)
+	default:
+		panic("unknown type")
+	}
+
 	for i := 0; i < t.NumMethod(); i++ {
 		m := t.Method(i)

@ -336,7 +432,7 @@ func main() {
 		ft := m.Func.Type()
 		for j := 2; j < ft.NumIn(); j++ {
 			inp := ft.In(j)
-			args = append(args, exampleValue(inp, nil))
+			args = append(args, exampleValue(m.Name, inp, nil))
 		}

 		v, err := json.MarshalIndent(args, "", "  ")
@ -344,7 +440,7 @@ func main() {
 			panic(err)
 		}

-		outv := exampleValue(ft.Out(0), nil)
+		outv := exampleValue(m.Name, ft.Out(0), nil)

 		ov, err := json.MarshalIndent(outv, "", "  ")
 		if err != nil {
@ -377,9 +473,6 @@ func main() {
 		}
 	}

-	permStruct := reflect.TypeOf(apistruct.FullNodeStruct{}.Internal)
-	commonPermStruct := reflect.TypeOf(apistruct.CommonStruct{}.Internal)
-
 	for _, g := range groupslice {
 		g := g
 		fmt.Printf("## %s\n", g.GroupName)
--- a/build/version.go
+++ b/build/version.go
@ -29,7 +29,7 @@ func buildType() string {
 }

 // BuildVersion is the local build version, set by build system
-const BuildVersion = "1.1.2"
+const BuildVersion = "1.1.3"

 func UserVersion() string {
 	return BuildVersion + buildType() + CurrentCommit
--- a/chain/events/state/fastapi.go
+++ b/chain/events/state/fastapi.go
@ -0,0 +1,34 @@
+package state
+
+import (
+	"context"
+
+	"github.com/filecoin-project/go-address"
+
+	"github.com/filecoin-project/lotus/chain/types"
+)
+
+type FastChainApiAPI interface {
+	ChainAPI
+
+	ChainGetTipSet(context.Context, types.TipSetKey) (*types.TipSet, error)
+}
+
+type fastAPI struct {
+	FastChainApiAPI
+}
+
+func WrapFastAPI(api FastChainApiAPI) ChainAPI {
+	return &fastAPI{
+		api,
+	}
+}
+
+func (a *fastAPI) StateGetActor(ctx context.Context, actor address.Address, tsk types.TipSetKey) (*types.Actor, error) {
+	ts, err := a.FastChainApiAPI.ChainGetTipSet(ctx, tsk)
+	if err != nil {
+		return nil, err
+	}
+
+	return a.FastChainApiAPI.StateGetActor(ctx, actor, ts.Parents())
+}
--- a/chain/exchange/client.go
+++ b/chain/exchange/client.go
@ -7,7 +7,6 @@ import (
 	"math/rand"
 	"time"

-	"github.com/libp2p/go-libp2p-core/helpers"
 	"github.com/libp2p/go-libp2p-core/host"
 	"github.com/libp2p/go-libp2p-core/network"
 	"github.com/libp2p/go-libp2p-core/peer"
@ -412,11 +411,7 @@ func (c *client) sendRequestToPeer(ctx context.Context, peer peer.ID, req *Reque
 		return nil, xerrors.Errorf("failed to open stream to peer: %w", err)
 	}

-	defer func() {
-		// Note: this will become just stream.Close once we've completed the go-libp2p migration to
-		//       go-libp2p-core 0.7.0
-		go helpers.FullClose(stream) //nolint:errcheck
-	}()
+	defer stream.Close() //nolint:errcheck

 	// Write request.
 	_ = stream.SetWriteDeadline(time.Now().Add(WriteReqDeadline))
--- a/chain/exchange/server.go
+++ b/chain/exchange/server.go
@ -15,7 +15,6 @@ import (
 	"github.com/filecoin-project/lotus/chain/types"

 	"github.com/ipfs/go-cid"
-	"github.com/libp2p/go-libp2p-core/helpers"
 	inet "github.com/libp2p/go-libp2p-core/network"
 )

@ -40,16 +39,14 @@ func (s *server) HandleStream(stream inet.Stream) {
 	ctx, span := trace.StartSpan(context.Background(), "chainxchg.HandleStream")
 	defer span.End()

-	// Note: this will become just stream.Close once we've completed the go-libp2p migration to
-	//       go-libp2p-core 0.7.0
-	defer helpers.FullClose(stream) //nolint:errcheck
+	defer stream.Close() //nolint:errcheck

 	var req Request
 	if err := cborutil.ReadCborRPC(bufio.NewReader(stream), &req); err != nil {
 		log.Warnf("failed to read block sync request: %s", err)
 		return
 	}
-	log.Infow("block sync request",
+	log.Debugw("block sync request",
 		"start", req.Head, "len", req.Length)

 	resp, err := s.processRequest(ctx, &req)
--- a/chain/messagepool/messagepool.go
+++ b/chain/messagepool/messagepool.go
@ -264,7 +264,7 @@ func (ms *msgSet) add(m *types.SignedMessage, mp *MessagePool, strict, untrusted
 	}

 	if strict && nonceGap {
-		log.Warnf("adding nonce-gapped message from %s (nonce: %d, nextNonce: %d)",
+		log.Debugf("adding nonce-gapped message from %s (nonce: %d, nextNonce: %d)",
 			m.Message.From, m.Message.Nonce, nextNonce)
 	}

@ -1219,7 +1219,7 @@ func (mp *MessagePool) MessagesForBlocks(blks []*types.BlockHeader) ([]*types.Si
 			if smsg != nil {
 				out = append(out, smsg)
 			} else {
-				log.Warnf("could not recover signature for bls message %s", msg.Cid())
+				log.Debugf("could not recover signature for bls message %s", msg.Cid())
 			}
 		}
 	}
--- a/chain/store/store.go
+++ b/chain/store/store.go
@ -5,6 +5,7 @@ import (
 	"context"
 	"encoding/binary"
 	"encoding/json"
+	"errors"
 	"io"
 	"os"
 	"strconv"
@ -59,6 +60,8 @@ var blockValidationCacheKeyPrefix = dstore.NewKey("blockValidation")
 var DefaultTipSetCacheSize = 8192
 var DefaultMsgMetaCacheSize = 2048

+var ErrNotifeeDone = errors.New("notifee is done and should be removed")
+
 func init() {
 	if s := os.Getenv("LOTUS_CHAIN_TIPSET_CACHE"); s != "" {
 		tscs, err := strconv.Atoi(s)
@ -268,7 +271,7 @@ func (cs *ChainStore) SubHeadChanges(ctx context.Context) chan []*api.HeadChange
 					log.Warn("chain head sub exit loop")
 					return
 				}
-				if len(out) > 0 {
+				if len(out) > 5 {
 					log.Warnf("head change sub is slow, has %d buffered entries", len(out))
 				}
 				select {
@ -435,11 +438,36 @@ func (cs *ChainStore) reorgWorker(ctx context.Context, initialNotifees []ReorgNo
 					apply[i], apply[opp] = apply[opp], apply[i]
 				}

-				for _, hcf := range notifees {
-					if err := hcf(revert, apply); err != nil {
+				var toremove map[int]struct{}
+				for i, hcf := range notifees {
+					err := hcf(revert, apply)
+
+					switch err {
+					case nil:
+
+					case ErrNotifeeDone:
+						if toremove == nil {
+							toremove = make(map[int]struct{})
+						}
+						toremove[i] = struct{}{}
+
+					default:
 						log.Error("head change func errored (BAD): ", err)
 					}
 				}
+
+				if len(toremove) > 0 {
+					newNotifees := make([]ReorgNotifee, 0, len(notifees)-len(toremove))
+					for i, hcf := range notifees {
+						_, remove := toremove[i]
+						if remove {
+							continue
+						}
+						newNotifees = append(newNotifees, hcf)
+					}
+					notifees = newNotifees
+				}
+
 			case <-ctx.Done():
 				return
 			}
--- a/chain/sub/incoming.go
+++ b/chain/sub/incoming.go
@ -95,7 +95,10 @@ func HandleIncomingBlocks(ctx context.Context, bsub *pubsub.Subscription, s *cha
 			}

 			took := build.Clock.Since(start)
-			log.Infow("new block over pubsub", "cid", blk.Header.Cid(), "source", msg.GetFrom(), "msgfetch", took)
+			log.Debugw("new block over pubsub", "cid", blk.Header.Cid(), "source", msg.GetFrom(), "msgfetch", took)
+			if took > 3*time.Second {
+				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 {
 				log.Warnf("Received block with large delay %d from miner %s", delay, blk.Header.Miner)
 			}
--- a/chain/sync.go
+++ b/chain/sync.go
@ -278,7 +278,7 @@ func (syncer *Syncer) InformNewHead(from peer.ID, fts *store.FullTipSet) bool {
 		for _, blk := range fts.TipSet().Blocks() {
 			miners = append(miners, blk.Miner.String())
 		}
-		log.Infow("incoming tipset does not appear to be better than our best chain, ignoring for now", "miners", miners, "bestPweight", bestPweight, "bestTS", hts.Cids(), "incomingWeight", targetWeight, "incomingTS", fts.TipSet().Cids())
+		log.Debugw("incoming tipset does not appear to be better than our best chain, ignoring for now", "miners", miners, "bestPweight", bestPweight, "bestTS", hts.Cids(), "incomingWeight", targetWeight, "incomingTS", fts.TipSet().Cids())
 		return false
 	}

--- a/chain/sync_manager.go
+++ b/chain/sync_manager.go
@ -194,7 +194,7 @@ func (sm *syncManager) scheduler() {
 }

 func (sm *syncManager) handlePeerHead(head peerHead) {
-	log.Infof("new peer head: %s %s", head.p, head.ts)
+	log.Debugf("new peer head: %s %s", head.p, head.ts)

 	// have we started syncing yet?
 	if sm.nextWorker == 0 {
@ -410,7 +410,7 @@ func (sm *syncManager) addSyncTarget(ts *types.TipSet) (*types.TipSet, bool, err
 	// if we have not finished the initial sync or have too many workers, add it to the deferred queue;
 	// it will be processed once a worker is freed from syncing a chain (or the initial sync finishes)
 	if !sm.initialSyncDone || len(sm.state) >= MaxSyncWorkers {
-		log.Infof("deferring sync on %s", ts)
+		log.Debugf("deferring sync on %s", ts)
 		sm.deferred.Insert(ts)
 		return nil, false, nil
 	}
--- a/cli/chain.go
+++ b/cli/chain.go
@ -3,6 +3,7 @@ package cli
 import (
 	"bytes"
 	"context"
+	"encoding/base64"
 	"encoding/hex"
 	"encoding/json"
 	"fmt"
@ -1246,14 +1247,19 @@ var chainDecodeCmd = &cli.Command{
 }

 var chainDecodeParamsCmd = &cli.Command{
-	Name:  "params",
-	Usage: "Decode message params",
+	Name:      "params",
+	Usage:     "Decode message params",
+	ArgsUsage: "[toAddr method params]",
 	Flags: []cli.Flag{
 		&cli.StringFlag{
 			Name: "tipset",
 		},
+		&cli.StringFlag{
+			Name:  "encoding",
+			Value: "base64",
+			Usage: "specify input encoding to parse",
+		},
 	},
-	ArgsUsage: "[toAddr method hexParams]",
 	Action: func(cctx *cli.Context) error {
 		api, closer, err := GetFullNodeAPI(cctx)
 		if err != nil {
@ -1276,11 +1282,21 @@ var chainDecodeParamsCmd = &cli.Command{
 			return xerrors.Errorf("parsing method id: %w", err)
 		}

-		params, err := hex.DecodeString(cctx.Args().Get(2))
-		if err != nil {
-			return xerrors.Errorf("parsing hex params: %w", err)
+		var params []byte
+		switch cctx.String("encoding") {
+		case "base64":
+			params, err = base64.StdEncoding.DecodeString(cctx.Args().Get(2))
+			if err != nil {
+				return xerrors.Errorf("decoding base64 value: %w", err)
+			}
+		case "hex":
+			params, err = hex.DecodeString(cctx.Args().Get(2))
+			if err != nil {
+				return xerrors.Errorf("decoding hex value: %w", err)
+			}
+		default:
+			return xerrors.Errorf("unrecognized encoding: %s", cctx.String("encoding"))
 		}
-
 		ts, err := LoadTipSet(ctx, cctx, api)
 		if err != nil {
 			return err
--- a/cmd/lotus-storage-miner/storage.go
+++ b/cmd/lotus-storage-miner/storage.go
@ -1,6 +1,7 @@
 package main

 import (
+	"context"
 	"encoding/json"
 	"fmt"
 	"io/ioutil"
@ -20,11 +21,14 @@ import (
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"

+	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/chain/types"
 	lcli "github.com/filecoin-project/lotus/cli"
 	"github.com/filecoin-project/lotus/extern/sector-storage/fsutil"
 	"github.com/filecoin-project/lotus/extern/sector-storage/stores"
 	"github.com/filecoin-project/lotus/extern/sector-storage/storiface"
+	sealing "github.com/filecoin-project/lotus/extern/storage-sealing"
+	"github.com/filecoin-project/lotus/lib/tablewriter"
 )

 const metaFile = "sectorstore.json"
@ -40,6 +44,7 @@ stored while moving through the sealing pipeline (references as 'seal').`,
 		storageAttachCmd,
 		storageListCmd,
 		storageFindCmd,
+		storageCleanupCmd,
 	},
 }

@ -147,6 +152,9 @@ var storageListCmd = &cli.Command{
 	Flags: []cli.Flag{
 		&cli.BoolFlag{Name: "color"},
 	},
+	Subcommands: []*cli.Command{
+		storageListSectorsCmd,
+	},
 	Action: func(cctx *cli.Context) error {
 		color.NoColor = !cctx.Bool("color")

@ -408,3 +416,263 @@ var storageFindCmd = &cli.Command{
 		return nil
 	},
 }
+
+var storageListSectorsCmd = &cli.Command{
+	Name:  "sectors",
+	Usage: "get list of all sector files",
+	Flags: []cli.Flag{
+		&cli.BoolFlag{
+			Name:  "color",
+			Value: true,
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		color.NoColor = !cctx.Bool("color")
+
+		nodeApi, closer, err := lcli.GetStorageMinerAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+
+		napi, closer2, err := lcli.GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer2()
+
+		ctx := lcli.ReqContext(cctx)
+
+		sectors, err := nodeApi.SectorsList(ctx)
+		if err != nil {
+			return xerrors.Errorf("listing sectors: %w", err)
+		}
+
+		maddr, err := nodeApi.ActorAddress(ctx)
+		if err != nil {
+			return err
+		}
+
+		aid, err := address.IDFromAddress(maddr)
+		if err != nil {
+			return err
+		}
+
+		mi, err := napi.StateMinerInfo(ctx, maddr, types.EmptyTSK)
+		if err != nil {
+			return err
+		}
+
+		sid := func(sn abi.SectorNumber) abi.SectorID {
+			return abi.SectorID{
+				Miner:  abi.ActorID(aid),
+				Number: sn,
+			}
+		}
+
+		type entry struct {
+			id      abi.SectorNumber
+			storage stores.ID
+			ft      storiface.SectorFileType
+			urls    string
+
+			primary, seal, store bool
+
+			state api.SectorState
+		}
+
+		var list []entry
+
+		for _, sector := range sectors {
+			st, err := nodeApi.SectorsStatus(ctx, sector, false)
+			if err != nil {
+				return xerrors.Errorf("getting sector status for sector %d: %w", sector, err)
+			}
+
+			for _, ft := range storiface.PathTypes {
+				si, err := nodeApi.StorageFindSector(ctx, sid(sector), ft, mi.SectorSize, false)
+				if err != nil {
+					return xerrors.Errorf("find sector %d: %w", sector, err)
+				}
+
+				for _, info := range si {
+
+					list = append(list, entry{
+						id:      sector,
+						storage: info.ID,
+						ft:      ft,
+						urls:    strings.Join(info.URLs, ";"),
+
+						primary: info.Primary,
+						seal:    info.CanSeal,
+						store:   info.CanStore,
+
+						state: st.State,
+					})
+				}
+			}
+
+		}
+
+		sort.Slice(list, func(i, j int) bool {
+			if list[i].store != list[j].store {
+				return list[i].store
+			}
+
+			if list[i].storage != list[j].storage {
+				return list[i].storage < list[j].storage
+			}
+
+			if list[i].id != list[j].id {
+				return list[i].id < list[j].id
+			}
+
+			return list[i].ft < list[j].ft
+		})
+
+		tw := tablewriter.New(
+			tablewriter.Col("Storage"),
+			tablewriter.Col("Sector"),
+			tablewriter.Col("Type"),
+			tablewriter.Col("State"),
+			tablewriter.Col("Primary"),
+			tablewriter.Col("Path use"),
+			tablewriter.Col("URLs"),
+		)
+
+		if len(list) == 0 {
+			return nil
+		}
+
+		lastS := list[0].storage
+		sc1, sc2 := color.FgBlue, color.FgCyan
+
+		for _, e := range list {
+			if e.storage != lastS {
+				lastS = e.storage
+				sc1, sc2 = sc2, sc1
+			}
+
+			m := map[string]interface{}{
+				"Storage":  color.New(sc1).Sprint(e.storage),
+				"Sector":   e.id,
+				"Type":     e.ft.String(),
+				"State":    color.New(stateOrder[sealing.SectorState(e.state)].col).Sprint(e.state),
+				"Primary":  maybeStr(e.seal, color.FgGreen, "primary"),
+				"Path use": maybeStr(e.seal, color.FgMagenta, "seal ") + maybeStr(e.store, color.FgCyan, "store"),
+				"URLs":     e.urls,
+			}
+			tw.Write(m)
+		}
+
+		return tw.Flush(os.Stdout)
+	},
+}
+
+func maybeStr(c bool, col color.Attribute, s string) string {
+	if !c {
+		return ""
+	}
+
+	return color.New(col).Sprint(s)
+}
+
+var storageCleanupCmd = &cli.Command{
+	Name:  "cleanup",
+	Usage: "trigger cleanup actions",
+	Flags: []cli.Flag{
+		&cli.BoolFlag{
+			Name:  "removed",
+			Usage: "cleanup remaining files from removed sectors",
+			Value: true,
+		},
+	},
+	Action: func(cctx *cli.Context) error {
+		api, closer, err := lcli.GetStorageMinerAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer()
+
+		napi, closer2, err := lcli.GetFullNodeAPI(cctx)
+		if err != nil {
+			return err
+		}
+		defer closer2()
+
+		ctx := lcli.ReqContext(cctx)
+
+		if cctx.Bool("removed") {
+			if err := cleanupRemovedSectorData(ctx, api, napi); err != nil {
+				return err
+			}
+		}
+
+		// TODO: proving sectors in sealing storage
+
+		return nil
+	},
+}
+
+func cleanupRemovedSectorData(ctx context.Context, api api.StorageMiner, napi api.FullNode) error {
+	sectors, err := api.SectorsList(ctx)
+	if err != nil {
+		return err
+	}
+
+	maddr, err := api.ActorAddress(ctx)
+	if err != nil {
+		return err
+	}
+
+	aid, err := address.IDFromAddress(maddr)
+	if err != nil {
+		return err
+	}
+
+	sid := func(sn abi.SectorNumber) abi.SectorID {
+		return abi.SectorID{
+			Miner:  abi.ActorID(aid),
+			Number: sn,
+		}
+	}
+
+	mi, err := napi.StateMinerInfo(ctx, maddr, types.EmptyTSK)
+	if err != nil {
+		return err
+	}
+
+	toRemove := map[abi.SectorNumber]struct{}{}
+
+	for _, sector := range sectors {
+		st, err := api.SectorsStatus(ctx, sector, false)
+		if err != nil {
+			return xerrors.Errorf("getting sector status for sector %d: %w", sector, err)
+		}
+
+		if sealing.SectorState(st.State) != sealing.Removed {
+			continue
+		}
+
+		for _, ft := range storiface.PathTypes {
+			si, err := api.StorageFindSector(ctx, sid(sector), ft, mi.SectorSize, false)
+			if err != nil {
+				return xerrors.Errorf("find sector %d: %w", sector, err)
+			}
+
+			if len(si) > 0 {
+				toRemove[sector] = struct{}{}
+			}
+		}
+	}
+
+	for sn := range toRemove {
+		fmt.Printf("cleaning up data for sector %d\n", sn)
+		err := api.SectorRemove(ctx, sn)
+		if err != nil {
+			log.Error(err)
+		}
+	}
+
+	return nil
+}
--- a/documentation/en/api-methods-miner.md
+++ b/documentation/en/api-methods-miner.md
--- a/documentation/en/api-methods-worker.md
+++ b/documentation/en/api-methods-worker.md
@ -0,0 +1,537 @@
+# Groups
+* [](#)
+  * [Enabled](#Enabled)
+  * [Fetch](#Fetch)
+  * [Info](#Info)
+  * [Paths](#Paths)
+  * [Remove](#Remove)
+  * [Session](#Session)
+  * [Version](#Version)
+* [Add](#Add)
+  * [AddPiece](#AddPiece)
+* [Finalize](#Finalize)
+  * [FinalizeSector](#FinalizeSector)
+* [Move](#Move)
+  * [MoveStorage](#MoveStorage)
+* [Process](#Process)
+  * [ProcessSession](#ProcessSession)
+* [Read](#Read)
+  * [ReadPiece](#ReadPiece)
+* [Release](#Release)
+  * [ReleaseUnsealed](#ReleaseUnsealed)
+* [Seal](#Seal)
+  * [SealCommit1](#SealCommit1)
+  * [SealCommit2](#SealCommit2)
+  * [SealPreCommit1](#SealPreCommit1)
+  * [SealPreCommit2](#SealPreCommit2)
+* [Set](#Set)
+  * [SetEnabled](#SetEnabled)
+* [Storage](#Storage)
+  * [StorageAddLocal](#StorageAddLocal)
+* [Task](#Task)
+  * [TaskTypes](#TaskTypes)
+* [Unseal](#Unseal)
+  * [UnsealPiece](#UnsealPiece)
+* [Wait](#Wait)
+  * [WaitQuiet](#WaitQuiet)
+## 
+
+
+### Enabled
+There are not yet any comments for this method.
+
+Perms: admin
+
+Inputs: `null`
+
+Response: `true`
+
+### Fetch
+
+
+Perms: admin
+
+Inputs:
+```json
+[
+  {
+    "Miner": 1000,
+    "Number": 9
+  },
+  1,
+  "sealing",
+  "move"
+]
+```
+
+Response:
+```json
+{
+  "Sector": {
+    "Miner": 1000,
+    "Number": 9
+  },
+  "ID": "07070707-0707-0707-0707-070707070707"
+}
+```
+
+### Info
+There are not yet any comments for this method.
+
+Perms: admin
+
+Inputs: `null`
+
+Response:
+```json
+{
+  "Hostname": "string value",
+  "Resources": {
+    "MemPhysical": 42,
+    "MemSwap": 42,
+    "MemReserved": 42,
+    "CPUs": 42,
+    "GPUs": null
+  }
+}
+```
+
+### Paths
+There are not yet any comments for this method.
+
+Perms: admin
+
+Inputs: `null`
+
+Response: `null`
+
+### Remove
+Storage / Other
+
+
+Perms: admin
+
+Inputs:
+```json
+[
+  {
+    "Miner": 1000,
+    "Number": 9
+  }
+]
+```
+
+Response: `{}`
+
+### Session
+Like ProcessSession, but returns an error when worker is disabled
+
+
+Perms: admin
+
+Inputs: `null`
+
+Response: `"07070707-0707-0707-0707-070707070707"`
+
+### Version
+TODO: Info() (name, ...) ?
+
+
+Perms: admin
+
+Inputs: `null`
+
+Response: `4352`
+
+## Add
+
+
+### AddPiece
+
+
+Perms: admin
+
+Inputs:
+```json
+[
+  {
+    "Miner": 1000,
+    "Number": 9
+  },
+  null,
+  1024,
+  {}
+]
+```
+
+Response:
+```json
+{
+  "Sector": {
+    "Miner": 1000,
+    "Number": 9
+  },
+  "ID": "07070707-0707-0707-0707-070707070707"
+}
+```
+
+## Finalize
+
+
+### FinalizeSector
+
+
+Perms: admin
+
+Inputs:
+```json
+[
+  {
+    "Miner": 1000,
+    "Number": 9
+  },
+  null
+]
+```
+
+Response:
+```json
+{
+  "Sector": {
+    "Miner": 1000,
+    "Number": 9
+  },
+  "ID": "07070707-0707-0707-0707-070707070707"
+}
+```
+
+## Move
+
+
+### MoveStorage
+
+
+Perms: admin
+
+Inputs:
+```json
+[
+  {
+    "Miner": 1000,
+    "Number": 9
+  },
+  1
+]
+```
+
+Response:
+```json
+{
+  "Sector": {
+    "Miner": 1000,
+    "Number": 9
+  },
+  "ID": "07070707-0707-0707-0707-070707070707"
+}
+```
+
+## Process
+
+
+### ProcessSession
+returns a random UUID of worker session, generated randomly when worker
+process starts
+
+
+Perms: admin
+
+Inputs: `null`
+
+Response: `"07070707-0707-0707-0707-070707070707"`
+
+## Read
+
+
+### ReadPiece
+
+
+Perms: admin
+
+Inputs:
+```json
+[
+  {},
+  {
+    "Miner": 1000,
+    "Number": 9
+  },
+  1040384,
+  1024
+]
+```
+
+Response:
+```json
+{
+  "Sector": {
+    "Miner": 1000,
+    "Number": 9
+  },
+  "ID": "07070707-0707-0707-0707-070707070707"
+}
+```
+
+## Release
+
+
+### ReleaseUnsealed
+
+
+Perms: admin
+
+Inputs:
+```json
+[
+  {
+    "Miner": 1000,
+    "Number": 9
+  },
+  null
+]
+```
+
+Response:
+```json
+{
+  "Sector": {
+    "Miner": 1000,
+    "Number": 9
+  },
+  "ID": "07070707-0707-0707-0707-070707070707"
+}
+```
+
+## Seal
+
+
+### SealCommit1
+
+
+Perms: admin
+
+Inputs:
+```json
+[
+  {
+    "Miner": 1000,
+    "Number": 9
+  },
+  null,
+  null,
+  null,
+  {
+    "Unsealed": {
+      "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+    },
+    "Sealed": {
+      "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+    }
+  }
+]
+```
+
+Response:
+```json
+{
+  "Sector": {
+    "Miner": 1000,
+    "Number": 9
+  },
+  "ID": "07070707-0707-0707-0707-070707070707"
+}
+```
+
+### SealCommit2
+
+
+Perms: admin
+
+Inputs:
+```json
+[
+  {
+    "Miner": 1000,
+    "Number": 9
+  },
+  null
+]
+```
+
+Response:
+```json
+{
+  "Sector": {
+    "Miner": 1000,
+    "Number": 9
+  },
+  "ID": "07070707-0707-0707-0707-070707070707"
+}
+```
+
+### SealPreCommit1
+
+
+Perms: admin
+
+Inputs:
+```json
+[
+  {
+    "Miner": 1000,
+    "Number": 9
+  },
+  null,
+  null
+]
+```
+
+Response:
+```json
+{
+  "Sector": {
+    "Miner": 1000,
+    "Number": 9
+  },
+  "ID": "07070707-0707-0707-0707-070707070707"
+}
+```
+
+### SealPreCommit2
+
+
+Perms: admin
+
+Inputs:
+```json
+[
+  {
+    "Miner": 1000,
+    "Number": 9
+  },
+  null
+]
+```
+
+Response:
+```json
+{
+  "Sector": {
+    "Miner": 1000,
+    "Number": 9
+  },
+  "ID": "07070707-0707-0707-0707-070707070707"
+}
+```
+
+## Set
+
+
+### SetEnabled
+SetEnabled marks the worker as enabled/disabled. Not that this setting
+may take a few seconds to propagate to task scheduler
+
+
+Perms: admin
+
+Inputs:
+```json
+[
+  true
+]
+```
+
+Response: `{}`
+
+## Storage
+
+
+### StorageAddLocal
+There are not yet any comments for this method.
+
+Perms: admin
+
+Inputs:
+```json
+[
+  "string value"
+]
+```
+
+Response: `{}`
+
+## Task
+
+
+### TaskTypes
+TaskType -> Weight
+
+
+Perms: admin
+
+Inputs: `null`
+
+Response:
+```json
+{
+  "seal/v0/precommit/2": {}
+}
+```
+
+## Unseal
+
+
+### UnsealPiece
+
+
+Perms: admin
+
+Inputs:
+```json
+[
+  {
+    "Miner": 1000,
+    "Number": 9
+  },
+  1040384,
+  1024,
+  null,
+  {
+    "/": "bafy2bzacea3wsdh6y3a36tb3skempjoxqpuyompjbmfeyf34fi3uy6uue42v4"
+  }
+]
+```
+
+Response:
+```json
+{
+  "Sector": {
+    "Miner": 1000,
+    "Number": 9
+  },
+  "ID": "07070707-0707-0707-0707-070707070707"
+}
+```
+
+## Wait
+
+
+### WaitQuiet
+WaitQuiet blocks until there are no tasks running
+
+
+Perms: admin
+
+Inputs: `null`
+
+Response: `{}`
+
--- a/documentation/en/architecture/architecture.md
+++ b/documentation/en/architecture/architecture.md
@ -311,7 +311,7 @@ FIXME: Maybe mention the `Batching` interface as the developer will stumble upon

 FIXME: IPFS blocks vs Filecoin blocks ideally happens before this / here

-The [`Blockstore` interface](`github.com/ipfs/go-ipfs-blockstore/blockstore.go`) structures the key-value pair
+The [`Blockstore` interface](`github.com/filecoin-project/lotus/lib/blockstore.go`) structures the key-value pair
 into the CID format for the key and the [`Block` interface](`github.com/ipfs/go-block-format/blocks.go`) for the value.
 The `Block` value is just a raw string of bytes addressed by its hash, which is included in the CID key.

--- a/extern/sector-storage/stores/index.go
+++ b/extern/sector-storage/stores/index.go
@ -2,6 +2,7 @@ package stores

 import (
 	"context"
+	"errors"
 	"net/url"
 	gopath "path"
 	"sort"
@ -35,7 +36,7 @@ type StorageInfo struct {

 type HealthReport struct {
 	Stat fsutil.FsStat
-	Err  error
+	Err  string
 }

 type SectorStorageInfo struct {
@ -175,7 +176,9 @@ func (i *Index) StorageReportHealth(ctx context.Context, id ID, report HealthRep
 	}

 	ent.fsi = report.Stat
-	ent.heartbeatErr = report.Err
+	if report.Err != "" {
+		ent.heartbeatErr = errors.New(report.Err)
+	}
 	ent.lastHeartbeat = time.Now()

 	return nil
--- a/extern/sector-storage/stores/local.go
+++ b/extern/sector-storage/stores/local.go
@ -308,11 +308,12 @@ func (st *Local) reportStorage(ctx context.Context) {
 	toReport := map[ID]HealthReport{}
 	for id, p := range st.paths {
 		stat, err := p.stat(st.localStorage)
-
-		toReport[id] = HealthReport{
-			Stat: stat,
-			Err:  err,
+		r := HealthReport{Stat: stat}
+		if err != nil {
+			r.Err = err.Error()
 		}
+
+		toReport[id] = r
 	}

 	st.localLk.RUnlock()
--- a/extern/storage-sealing/fsm.go
+++ b/extern/storage-sealing/fsm.go
@ -443,6 +443,13 @@ func (m *Sealing) ForceSectorState(ctx context.Context, id abi.SectorNumber, sta
 }

 func final(events []statemachine.Event, state *SectorInfo) (uint64, error) {
+	if len(events) > 0 {
+		if gm, ok := events[0].User.(globalMutator); ok {
+			gm.applyGlobal(state)
+			return 1, nil
+		}
+	}
+
 	return 0, xerrors.Errorf("didn't expect any events in state %s, got %+v", state.State, events)
 }

--- a/go.mod
+++ b/go.mod
@ -28,7 +28,7 @@ require (
 	github.com/filecoin-project/go-bitfield v0.2.3-0.20201110211213-fe2c1862e816
 	github.com/filecoin-project/go-cbor-util v0.0.0-20191219014500-08c40a1e63a2
 	github.com/filecoin-project/go-crypto v0.0.0-20191218222705-effae4ea9f03
-	github.com/filecoin-project/go-data-transfer v1.0.1
+	github.com/filecoin-project/go-data-transfer v1.1.0
 	github.com/filecoin-project/go-fil-commcid v0.0.0-20200716160307-8f644712406f
 	github.com/filecoin-project/go-fil-markets v1.0.4
 	github.com/filecoin-project/go-jsonrpc v0.1.2-0.20201008195726-68c6a2704e49
@ -46,7 +46,7 @@ require (
 	github.com/gbrlsnchs/jwt/v3 v3.0.0-beta.1
 	github.com/go-kit/kit v0.10.0
 	github.com/go-ole/go-ole v1.2.4 // indirect
-	github.com/google/uuid v1.1.1
+	github.com/google/uuid v1.1.2
 	github.com/gorilla/mux v1.7.4
 	github.com/gorilla/websocket v1.4.2
 	github.com/hako/durafmt v0.0.0-20200710122514-c0fb7b4da026
@ -55,9 +55,9 @@ require (
 	github.com/hashicorp/golang-lru v0.5.4
 	github.com/influxdata/influxdb1-client v0.0.0-20191209144304-8bf82d3c094d
 	github.com/ipfs/bbloom v0.0.4
-	github.com/ipfs/go-bitswap v0.2.20
+	github.com/ipfs/go-bitswap v0.3.2
 	github.com/ipfs/go-block-format v0.0.2
-	github.com/ipfs/go-blockservice v0.1.4-0.20200624145336-a978cec6e834
+	github.com/ipfs/go-blockservice v0.1.4
 	github.com/ipfs/go-cid v0.0.7
 	github.com/ipfs/go-cidutil v0.0.2
 	github.com/ipfs/go-datastore v0.4.5
@ -67,7 +67,7 @@ require (
 	github.com/ipfs/go-ds-pebble v0.0.2-0.20200921225637-ce220f8ac459
 	github.com/ipfs/go-filestore v1.0.0
 	github.com/ipfs/go-fs-lock v0.0.6
-	github.com/ipfs/go-graphsync v0.4.3
+	github.com/ipfs/go-graphsync v0.5.0
 	github.com/ipfs/go-ipfs-blockstore v1.0.2
 	github.com/ipfs/go-ipfs-chunker v0.0.5
 	github.com/ipfs/go-ipfs-ds-help v1.0.0
@ -93,23 +93,22 @@ require (
 	github.com/lib/pq v1.7.0
 	github.com/libp2p/go-buffer-pool v0.0.2
 	github.com/libp2p/go-eventbus v0.2.1
-	github.com/libp2p/go-libp2p v0.11.0
+	github.com/libp2p/go-libp2p v0.12.0
 	github.com/libp2p/go-libp2p-connmgr v0.2.4
-	github.com/libp2p/go-libp2p-core v0.6.1
+	github.com/libp2p/go-libp2p-core v0.7.0
 	github.com/libp2p/go-libp2p-discovery v0.5.0
-	github.com/libp2p/go-libp2p-kad-dht v0.8.3
-	github.com/libp2p/go-libp2p-mplex v0.2.4
+	github.com/libp2p/go-libp2p-kad-dht v0.11.0
+	github.com/libp2p/go-libp2p-mplex v0.3.0
 	github.com/libp2p/go-libp2p-noise v0.1.2
 	github.com/libp2p/go-libp2p-peerstore v0.2.6
-	github.com/libp2p/go-libp2p-pubsub v0.3.6
-	github.com/libp2p/go-libp2p-quic-transport v0.8.2
+	github.com/libp2p/go-libp2p-pubsub v0.4.0
+	github.com/libp2p/go-libp2p-quic-transport v0.9.0
 	github.com/libp2p/go-libp2p-record v0.1.3
 	github.com/libp2p/go-libp2p-routing-helpers v0.2.3
-	github.com/libp2p/go-libp2p-swarm v0.2.8
+	github.com/libp2p/go-libp2p-swarm v0.3.1
 	github.com/libp2p/go-libp2p-tls v0.1.3
-	github.com/libp2p/go-libp2p-yamux v0.2.8
+	github.com/libp2p/go-libp2p-yamux v0.4.1
 	github.com/libp2p/go-maddr-filter v0.1.0
-	github.com/libp2p/go-yamux v1.3.10 // indirect
 	github.com/mattn/go-colorable v0.1.6 // indirect
 	github.com/minio/blake2b-simd v0.0.0-20160723061019-3f5f724cb5b1
 	github.com/mitchellh/go-homedir v1.1.0
@ -136,7 +135,7 @@ require (
 	go.uber.org/dig v1.10.0 // indirect
 	go.uber.org/fx v1.9.0
 	go.uber.org/multierr v1.5.0
-	go.uber.org/zap v1.15.0
+	go.uber.org/zap v1.16.0
 	golang.org/x/net v0.0.0-20200707034311-ab3426394381
 	golang.org/x/sync v0.0.0-20200625203802-6e8e738ad208
 	golang.org/x/sys v0.0.0-20200926100807-9d91bd62050c
--- a/go.sum
+++ b/go.sum
@ -249,6 +249,8 @@ github.com/filecoin-project/go-crypto v0.0.0-20191218222705-effae4ea9f03 h1:2pMX
 github.com/filecoin-project/go-crypto v0.0.0-20191218222705-effae4ea9f03/go.mod h1:+viYnvGtUTgJRdy6oaeF4MTFKAfatX071MPDPBL11EQ=
 github.com/filecoin-project/go-data-transfer v1.0.1 h1:5sYKDbstyDsdJpVP4UGUW6+BgCNfgnH8hQgf0E3ZAno=
 github.com/filecoin-project/go-data-transfer v1.0.1/go.mod h1:UxvfUAY9v3ub0a21BSK9u3pB2aq30Y0KMsG+w9/ysyo=
+github.com/filecoin-project/go-data-transfer v1.1.0 h1:eRciNLKKbAMkKUdNgLKSHQljQUwe12c4UirGlJ7DDBI=
+github.com/filecoin-project/go-data-transfer v1.1.0/go.mod h1:ZAH51JZFR8NZC4FPiDPG+swjgui0q6zTMJbztc6pHhY=
 github.com/filecoin-project/go-ds-versioning v0.1.0 h1:y/X6UksYTsK8TLCI7rttCKEvl8btmWxyFMEeeWGUxIQ=
 github.com/filecoin-project/go-ds-versioning v0.1.0/go.mod h1:mp16rb4i2QPmxBnmanUx8i/XANp+PFCCJWiAb+VW4/s=
 github.com/filecoin-project/go-fil-commcid v0.0.0-20200716160307-8f644712406f h1:GxJzR3oRIMTPtpZ0b7QF8FKPK6/iPAc7trhlL5k/g+s=
@ -401,6 +403,8 @@ github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm4
 github.com/google/uuid v1.0.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/google/uuid v1.1.1 h1:Gkbcsh/GbpXz7lPftLA3P6TYMwjCLYm83jiFQZF/3gY=
 github.com/google/uuid v1.1.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/google/uuid v1.1.2 h1:EVhdT+1Kseyi1/pUmXKaFxYsDNy9RQYkMWRH68J/W7Y=
+github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/googleapis/gax-go v2.0.0+incompatible/go.mod h1:SFVmujtThgffbyetf+mdk2eWhX2bMyUtNHzFKcPA9HY=
 github.com/googleapis/gax-go/v2 v2.0.3/go.mod h1:LLvjysVCY1JZeum8Z6l8qUty8fiNwE08qbEPm1M08qg=
 github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg=
@ -488,8 +492,8 @@ github.com/ipfs/go-bitswap v0.0.9/go.mod h1:kAPf5qgn2W2DrgAcscZ3HrM9qh4pH+X8Fkk3
 github.com/ipfs/go-bitswap v0.1.0/go.mod h1:FFJEf18E9izuCqUtHxbWEvq+reg7o4CW5wSAE1wsxj0=
 github.com/ipfs/go-bitswap v0.1.2/go.mod h1:qxSWS4NXGs7jQ6zQvoPY3+NmOfHHG47mhkiLzBpJQIs=
 github.com/ipfs/go-bitswap v0.1.8/go.mod h1:TOWoxllhccevbWFUR2N7B1MTSVVge1s6XSMiCSA4MzM=
-github.com/ipfs/go-bitswap v0.2.20 h1:Zfi5jDUoqxDThORUznqdeL77DdGniAzlccNJ4vr+Itc=
-github.com/ipfs/go-bitswap v0.2.20/go.mod h1:C7TwBgHnu89Q8sHsTJP7IhUqF9XYLe71P4tT5adgmYo=
+github.com/ipfs/go-bitswap v0.3.2 h1:TdKx7lpidYe2dMAKfdeNS26y6Pc/AZX/i8doI1GV210=
+github.com/ipfs/go-bitswap v0.3.2/go.mod h1:AyWWfN3moBzQX0banEtfKOfbXb3ZeoOeXnZGNPV9S6w=
 github.com/ipfs/go-block-format v0.0.1/go.mod h1:DK/YYcsSUIVAFNwo/KZCdIIbpN0ROH/baNLgayt4pFc=
 github.com/ipfs/go-block-format v0.0.2 h1:qPDvcP19izTjU8rgo6p7gTXZlkMkF5bz5G3fqIsSCPE=
 github.com/ipfs/go-block-format v0.0.2/go.mod h1:AWR46JfpcObNfg3ok2JHDUfdiHRgWhJgCQF+KIgOPJY=
@ -499,6 +503,8 @@ github.com/ipfs/go-blockservice v0.1.0/go.mod h1:hzmMScl1kXHg3M2BjTymbVPjv627N7s
 github.com/ipfs/go-blockservice v0.1.3/go.mod h1:OTZhFpkgY48kNzbgyvcexW9cHrpjBYIjSR0KoDOFOLU=
 github.com/ipfs/go-blockservice v0.1.4-0.20200624145336-a978cec6e834 h1:hFJoI1D2a3MqiNkSb4nKwrdkhCngUxUTFNwVwovZX2s=
 github.com/ipfs/go-blockservice v0.1.4-0.20200624145336-a978cec6e834/go.mod h1:OTZhFpkgY48kNzbgyvcexW9cHrpjBYIjSR0KoDOFOLU=
+github.com/ipfs/go-blockservice v0.1.4 h1:Vq+MlsH8000KbbUciRyYMEw/NNP8UAGmcqKi4uWmFGA=
+github.com/ipfs/go-blockservice v0.1.4/go.mod h1:OTZhFpkgY48kNzbgyvcexW9cHrpjBYIjSR0KoDOFOLU=
 github.com/ipfs/go-cid v0.0.1/go.mod h1:GHWU/WuQdMPmIosc4Yn1bcCT7dSeX4lBafM7iqUPQvM=
 github.com/ipfs/go-cid v0.0.2/go.mod h1:GHWU/WuQdMPmIosc4Yn1bcCT7dSeX4lBafM7iqUPQvM=
 github.com/ipfs/go-cid v0.0.3/go.mod h1:GHWU/WuQdMPmIosc4Yn1bcCT7dSeX4lBafM7iqUPQvM=
@ -553,6 +559,8 @@ github.com/ipfs/go-graphsync v0.4.2 h1:Y/jt5r619yj0LI7OLtGKh4jYm8goYUcuJ09y7TZ3z
 github.com/ipfs/go-graphsync v0.4.2/go.mod h1:/VmbZTUdUMTbNkgzAiCEucIIAU3BkLE2cZrDCVUhyi0=
 github.com/ipfs/go-graphsync v0.4.3 h1:2t+oCpufufs1oqChoWiIK7V5uC1XCtf06PK9nqMV6pM=
 github.com/ipfs/go-graphsync v0.4.3/go.mod h1:mPOwDYv128gf8gxPFgXnz4fNrSYPsWyqisJ7ych+XDY=
+github.com/ipfs/go-graphsync v0.5.0 h1:iaByvxq88Ys1KcaQzTS1wmRhNsNEo3SaUiSGqTSbGmM=
+github.com/ipfs/go-graphsync v0.5.0/go.mod h1:e2ZxnClqBBYAtd901g9vXMJzS47labjAtOzsWtOzKNk=
 github.com/ipfs/go-hamt-ipld v0.1.1 h1:0IQdvwnAAUKmDE+PMJa5y1QiwOPHpI9+eAbQEEEYthk=
 github.com/ipfs/go-hamt-ipld v0.1.1/go.mod h1:1EZCr2v0jlCnhpa+aZ0JZYp8Tt2w16+JJOAVz17YcDk=
 github.com/ipfs/go-ipfs-blockstore v0.0.1/go.mod h1:d3WClOmRQKFnJ0Jz/jj/zmksX0ma1gROTlovZKBmN08=
@ -755,6 +763,8 @@ github.com/libp2p/go-addr-util v0.0.2/go.mod h1:Ecd6Fb3yIuLzq4bD7VcywcVSBtefcAwn
 github.com/libp2p/go-buffer-pool v0.0.1/go.mod h1:xtyIz9PMobb13WaxR6Zo1Pd1zXJKYg0a8KiIvDp3TzQ=
 github.com/libp2p/go-buffer-pool v0.0.2 h1:QNK2iAFa8gjAe1SPz6mHSMuCcjs+X1wlHzeOSqcmlfs=
 github.com/libp2p/go-buffer-pool v0.0.2/go.mod h1:MvaB6xw5vOrDl8rYZGLFdKAuk/hRoRZd1Vi32+RXyFM=
+github.com/libp2p/go-cidranger v1.1.0 h1:ewPN8EZ0dd1LSnrtuwd4709PXVcITVeuwbag38yPW7c=
+github.com/libp2p/go-cidranger v1.1.0/go.mod h1:KWZTfSr+r9qEo9OkI9/SIEeAtw+NNoU0dXIXt15Okic=
 github.com/libp2p/go-conn-security v0.0.1/go.mod h1:bGmu51N0KU9IEjX7kl2PQjgZa40JQWnayTvNMgD/vyk=
 github.com/libp2p/go-conn-security-multistream v0.0.1/go.mod h1:nc9vud7inQ+d6SO0I/6dSWrdMnHnzZNHeyUQqrAJulE=
 github.com/libp2p/go-conn-security-multistream v0.0.2/go.mod h1:nc9vud7inQ+d6SO0I/6dSWrdMnHnzZNHeyUQqrAJulE=
@ -783,8 +793,10 @@ github.com/libp2p/go-libp2p v0.8.1/go.mod h1:QRNH9pwdbEBpx5DTJYg+qxcVaDMAz3Ee/qD
 github.com/libp2p/go-libp2p v0.8.3/go.mod h1:EsH1A+8yoWK+L4iKcbPYu6MPluZ+CHWI9El8cTaefiM=
 github.com/libp2p/go-libp2p v0.9.2/go.mod h1:cunHNLDVus66Ct9iXXcjKRLdmHdFdHVe1TAnbubJQqQ=
 github.com/libp2p/go-libp2p v0.10.0/go.mod h1:yBJNpb+mGJdgrwbKAKrhPU0u3ogyNFTfjJ6bdM+Q/G8=
-github.com/libp2p/go-libp2p v0.11.0 h1:jb5mqdqYEBAybTEhD8io43Cz5LzVKuWxOK7znSN69jE=
-github.com/libp2p/go-libp2p v0.11.0/go.mod h1:3/ogJDXsbbepEfqtZKBR/DedzxJXCeK17t2Z9RE9bEE=
+github.com/libp2p/go-libp2p v0.12.0 h1:+xai9RQnQ9l5elFOKvp5wRyjyWisSwEx+6nU2+onpUA=
+github.com/libp2p/go-libp2p v0.12.0/go.mod h1:FpHZrfC1q7nA8jitvdjKBDF31hguaC676g/nT9PgQM0=
+github.com/libp2p/go-libp2p-asn-util v0.0.0-20200825225859-85005c6cf052 h1:BM7aaOF7RpmNn9+9g6uTjGJ0cTzWr5j9i9IKeun2M8U=
+github.com/libp2p/go-libp2p-asn-util v0.0.0-20200825225859-85005c6cf052/go.mod h1:nRMRTab+kZuk0LnKZpxhOVH/ndsdr2Nr//Zltc/vwgo=
 github.com/libp2p/go-libp2p-autonat v0.0.2/go.mod h1:fs71q5Xk+pdnKU014o2iq1RhMs9/PMaG5zXRFNnIIT4=
 github.com/libp2p/go-libp2p-autonat v0.0.6/go.mod h1:uZneLdOkZHro35xIhpbtTzLlgYturpu4J5+0cZK3MqE=
 github.com/libp2p/go-libp2p-autonat v0.1.0/go.mod h1:1tLf2yXxiE/oKGtDwPYWTSYG3PtvYlJmg7NeVtPRqH8=
@ -793,8 +805,8 @@ github.com/libp2p/go-libp2p-autonat v0.2.0/go.mod h1:DX+9teU4pEEoZUqR1PiMlqliONQ
 github.com/libp2p/go-libp2p-autonat v0.2.1/go.mod h1:MWtAhV5Ko1l6QBsHQNSuM6b1sRkXrpk0/LqCr+vCVxI=
 github.com/libp2p/go-libp2p-autonat v0.2.2/go.mod h1:HsM62HkqZmHR2k1xgX34WuWDzk/nBwNHoeyyT4IWV6A=
 github.com/libp2p/go-libp2p-autonat v0.2.3/go.mod h1:2U6bNWCNsAG9LEbwccBDQbjzQ8Krdjge1jLTE9rdoMM=
-github.com/libp2p/go-libp2p-autonat v0.3.2 h1:OhDSwVVaq7liTaRIsFFYvsaPp0pn2yi0WazejZ4DUmo=
-github.com/libp2p/go-libp2p-autonat v0.3.2/go.mod h1:0OzOi1/cVc7UcxfOddemYD5vzEqi4fwRbnZcJGLi68U=
+github.com/libp2p/go-libp2p-autonat v0.4.0 h1:3y8XQbpr+ssX8QfZUHekjHCYK64sj6/4hnf/awD4+Ug=
+github.com/libp2p/go-libp2p-autonat v0.4.0/go.mod h1:YxaJlpr81FhdOv3W3BTconZPfhaYivRdf53g+S2wobk=
 github.com/libp2p/go-libp2p-autonat-svc v0.1.0/go.mod h1:fqi8Obl/z3R4PFVLm8xFtZ6PBL9MlV/xumymRFkKq5A=
 github.com/libp2p/go-libp2p-blankhost v0.0.1/go.mod h1:Ibpbw/7cPPYwFb7PACIWdvxxv0t0XCCI10t7czjAjTc=
 github.com/libp2p/go-libp2p-blankhost v0.1.1/go.mod h1:pf2fvdLJPsC1FsVrNP3DUUvMzUts2dsLLBEpo1vW1ro=
@ -812,8 +824,8 @@ github.com/libp2p/go-libp2p-circuit v0.1.4/go.mod h1:CY67BrEjKNDhdTk8UgBX1Y/H5c3
 github.com/libp2p/go-libp2p-circuit v0.2.1/go.mod h1:BXPwYDN5A8z4OEY9sOfr2DUQMLQvKt/6oku45YUmjIo=
 github.com/libp2p/go-libp2p-circuit v0.2.2/go.mod h1:nkG3iE01tR3FoQ2nMm06IUrCpCyJp1Eo4A1xYdpjfs4=
 github.com/libp2p/go-libp2p-circuit v0.2.3/go.mod h1:nkG3iE01tR3FoQ2nMm06IUrCpCyJp1Eo4A1xYdpjfs4=
-github.com/libp2p/go-libp2p-circuit v0.3.1 h1:69ENDoGnNN45BNDnBd+8SXSetDuw0eJFcGmOvvtOgBw=
-github.com/libp2p/go-libp2p-circuit v0.3.1/go.mod h1:8RMIlivu1+RxhebipJwFDA45DasLx+kkrp4IlJj53F4=
+github.com/libp2p/go-libp2p-circuit v0.4.0 h1:eqQ3sEYkGTtybWgr6JLqJY6QLtPWRErvFjFDfAOO1wc=
+github.com/libp2p/go-libp2p-circuit v0.4.0/go.mod h1:t/ktoFIUzM6uLQ+o1G6NuBl2ANhBKN9Bc8jRIk31MoA=
 github.com/libp2p/go-libp2p-connmgr v0.1.1/go.mod h1:wZxh8veAmU5qdrfJ0ZBLcU8oJe9L82ciVP/fl1VHjXk=
 github.com/libp2p/go-libp2p-connmgr v0.2.3/go.mod h1:Gqjg29zI8CwXX21zRxy6gOg8VYu3zVerJRt2KyktzH4=
 github.com/libp2p/go-libp2p-connmgr v0.2.4 h1:TMS0vc0TCBomtQJyWr7fYxcVYYhx+q/2gF++G5Jkl/w=
@ -842,6 +854,8 @@ github.com/libp2p/go-libp2p-core v0.5.7/go.mod h1:txwbVEhHEXikXn9gfC7/UDDw7rkxuX
 github.com/libp2p/go-libp2p-core v0.6.0/go.mod h1:txwbVEhHEXikXn9gfC7/UDDw7rkxuX0bJvM49Ykaswo=
 github.com/libp2p/go-libp2p-core v0.6.1 h1:XS+Goh+QegCDojUZp00CaPMfiEADCrLjNZskWE7pvqs=
 github.com/libp2p/go-libp2p-core v0.6.1/go.mod h1:FfewUH/YpvWbEB+ZY9AQRQ4TAD8sJBt/G1rVvhz5XT8=
+github.com/libp2p/go-libp2p-core v0.7.0 h1:4a0TMjrWNTZlNvcqxZmrMRDi/NQWrhwO2pkTuLSQ/IQ=
+github.com/libp2p/go-libp2p-core v0.7.0/go.mod h1:FfewUH/YpvWbEB+ZY9AQRQ4TAD8sJBt/G1rVvhz5XT8=
 github.com/libp2p/go-libp2p-crypto v0.0.1/go.mod h1:yJkNyDmO341d5wwXxDUGO0LykUVT72ImHNUqh5D/dBE=
 github.com/libp2p/go-libp2p-crypto v0.0.2/go.mod h1:eETI5OUfBnvARGOHrJz2eWNyTUxEGZnBxMcbUjfIj4I=
 github.com/libp2p/go-libp2p-crypto v0.1.0 h1:k9MFy+o2zGDNGsaoZl0MA3iZ75qXxr9OOoAZF+sD5OQ=
@ -862,11 +876,11 @@ github.com/libp2p/go-libp2p-interface-connmgr v0.0.4/go.mod h1:GarlRLH0LdeWcLnYM
 github.com/libp2p/go-libp2p-interface-connmgr v0.0.5/go.mod h1:GarlRLH0LdeWcLnYM/SaBykKFl9U5JFnbBGruAk/D5k=
 github.com/libp2p/go-libp2p-interface-pnet v0.0.1/go.mod h1:el9jHpQAXK5dnTpKA4yfCNBZXvrzdOU75zz+C6ryp3k=
 github.com/libp2p/go-libp2p-kad-dht v0.2.1/go.mod h1:k7ONOlup7HKzQ68dE6lSnp07cdxdkmnRa+6B4Fh9/w0=
-github.com/libp2p/go-libp2p-kad-dht v0.8.3 h1:ceK5ML6s/I8UAcw6veoNsuEHdHvfo88leU/5uWOIFWs=
-github.com/libp2p/go-libp2p-kad-dht v0.8.3/go.mod h1:HnYYy8taJWESkqiESd1ngb9XX/XGGsMA5G0Vj2HoSh4=
+github.com/libp2p/go-libp2p-kad-dht v0.11.0 h1:ZLhlmDKsFiOkPhTzfEqBrMy/1Tqx+Dk6UgbHM5//IQM=
+github.com/libp2p/go-libp2p-kad-dht v0.11.0/go.mod h1:5ojtR2acDPqh/jXf5orWy8YGb8bHQDS+qeDcoscL/PI=
 github.com/libp2p/go-libp2p-kbucket v0.2.1/go.mod h1:/Rtu8tqbJ4WQ2KTCOMJhggMukOLNLNPY1EtEWWLxUvc=
-github.com/libp2p/go-libp2p-kbucket v0.4.2 h1:wg+VPpCtY61bCasGRexCuXOmEmdKjN+k1w+JtTwu9gA=
-github.com/libp2p/go-libp2p-kbucket v0.4.2/go.mod h1:7sCeZx2GkNK1S6lQnGUW5JYZCFPnXzAZCCBBS70lytY=
+github.com/libp2p/go-libp2p-kbucket v0.4.7 h1:spZAcgxifvFZHBD8tErvppbnNiKA5uokDu3CV7axu70=
+github.com/libp2p/go-libp2p-kbucket v0.4.7/go.mod h1:XyVo99AfQH0foSf176k4jY1xUJ2+jUJIZCSDm7r2YKk=
 github.com/libp2p/go-libp2p-loggables v0.0.1/go.mod h1:lDipDlBNYbpyqyPX/KcoO+eq0sJYEVR2JgOexcivchg=
 github.com/libp2p/go-libp2p-loggables v0.1.0 h1:h3w8QFfCt2UJl/0/NW4K829HX/0S4KD31PQ7m8UXXO8=
 github.com/libp2p/go-libp2p-loggables v0.1.0/go.mod h1:EyumB2Y6PrYjr55Q3/tiJ/o3xoDasoRYM7nOzEpoa90=
@ -876,8 +890,8 @@ github.com/libp2p/go-libp2p-mplex v0.2.0/go.mod h1:Ejl9IyjvXJ0T9iqUTE1jpYATQ9NM3
 github.com/libp2p/go-libp2p-mplex v0.2.1/go.mod h1:SC99Rxs8Vuzrf/6WhmH41kNn13TiYdAWNYHrwImKLnE=
 github.com/libp2p/go-libp2p-mplex v0.2.2/go.mod h1:74S9eum0tVQdAfFiKxAyKzNdSuLqw5oadDq7+L/FELo=
 github.com/libp2p/go-libp2p-mplex v0.2.3/go.mod h1:CK3p2+9qH9x+7ER/gWWDYJ3QW5ZxWDkm+dVvjfuG3ek=
-github.com/libp2p/go-libp2p-mplex v0.2.4 h1:XFFXaN4jhqnIuJVjYOR3k6bnRj0mFfJOlIuDVww+4Zo=
-github.com/libp2p/go-libp2p-mplex v0.2.4/go.mod h1:mI7iOezdWFOisvUwaYd3IDrJ4oVmgoXK8H331ui39CE=
+github.com/libp2p/go-libp2p-mplex v0.3.0 h1:CZyqqKP0BSGQyPLvpRQougbfXaaaJZdGgzhCpJNuNSk=
+github.com/libp2p/go-libp2p-mplex v0.3.0/go.mod h1:l9QWxRbbb5/hQMECEb908GbS9Sm2UAR2KFZKUJEynEs=
 github.com/libp2p/go-libp2p-nat v0.0.2/go.mod h1:QrjXQSD5Dj4IJOdEcjHRkWTSomyxRo6HnUkf/TfQpLQ=
 github.com/libp2p/go-libp2p-nat v0.0.4/go.mod h1:N9Js/zVtAXqaeT99cXgTV9e75KpnWCvVOiGzlcHmBbY=
 github.com/libp2p/go-libp2p-nat v0.0.5/go.mod h1:1qubaE5bTZMJE+E/uu2URroMbzdubFz1ChgiN79yKPE=
@ -914,12 +928,12 @@ github.com/libp2p/go-libp2p-protocol v0.0.1/go.mod h1:Af9n4PiruirSDjHycM1QuiMi/1
 github.com/libp2p/go-libp2p-protocol v0.1.0/go.mod h1:KQPHpAabB57XQxGrXCNvbL6UEXfQqUgC/1adR2Xtflk=
 github.com/libp2p/go-libp2p-pubsub v0.1.1/go.mod h1:ZwlKzRSe1eGvSIdU5bD7+8RZN/Uzw0t1Bp9R1znpR/Q=
 github.com/libp2p/go-libp2p-pubsub v0.3.2-0.20200527132641-c0712c6e92cf/go.mod h1:TxPOBuo1FPdsTjFnv+FGZbNbWYsp74Culx+4ViQpato=
-github.com/libp2p/go-libp2p-pubsub v0.3.6 h1:9oO8W7qIWCYQYyz5z8nUsPcb3rrFehBlkbqvbSVjBxY=
-github.com/libp2p/go-libp2p-pubsub v0.3.6/go.mod h1:DTMSVmZZfXodB/pvdTGrY2eHPZ9W2ev7hzTH83OKHrI=
+github.com/libp2p/go-libp2p-pubsub v0.4.0 h1:YNVRyXqBgv9i4RG88jzoTtkSOaSB45CqHkL29NNBZb4=
+github.com/libp2p/go-libp2p-pubsub v0.4.0/go.mod h1:izkeMLvz6Ht8yAISXjx60XUQZMq9ZMe5h2ih4dLIBIQ=
 github.com/libp2p/go-libp2p-quic-transport v0.1.1/go.mod h1:wqG/jzhF3Pu2NrhJEvE+IE0NTHNXslOPn9JQzyCAxzU=
 github.com/libp2p/go-libp2p-quic-transport v0.5.0/go.mod h1:IEcuC5MLxvZ5KuHKjRu+dr3LjCT1Be3rcD/4d8JrX8M=
-github.com/libp2p/go-libp2p-quic-transport v0.8.2 h1:FDaXBCBJ1e5hY6gnWEJ4NbYyLk8eezr4J6AY3q3KqwM=
-github.com/libp2p/go-libp2p-quic-transport v0.8.2/go.mod h1:L+e0q15ZNaYm3seHgbsXjWP8kXLEqz+elLWKk9l8DhM=
+github.com/libp2p/go-libp2p-quic-transport v0.9.0 h1:WPuq5nV/chmIZIzvrkC2ulSdAQ0P0BDvgvAhZFOZ59E=
+github.com/libp2p/go-libp2p-quic-transport v0.9.0/go.mod h1:xyY+IgxL0qsW7Kiutab0+NlxM0/p9yRtrGTYsuMWf70=
 github.com/libp2p/go-libp2p-record v0.0.1/go.mod h1:grzqg263Rug/sRex85QrDOLntdFAymLDLm7lxMgU79Q=
 github.com/libp2p/go-libp2p-record v0.1.0/go.mod h1:ujNc8iuE5dlKWVy6wuL6dd58t0n7xI4hAIl8pE6wu5Q=
 github.com/libp2p/go-libp2p-record v0.1.1/go.mod h1:VRgKajOyMVgP/F0L5g3kH7SVskp17vFi2xheb5uMJtg=
@ -946,6 +960,9 @@ github.com/libp2p/go-libp2p-swarm v0.2.4/go.mod h1:/xIpHFPPh3wmSthtxdGbkHZ0OET1h
 github.com/libp2p/go-libp2p-swarm v0.2.7/go.mod h1:ZSJ0Q+oq/B1JgfPHJAT2HTall+xYRNYp1xs4S2FBWKA=
 github.com/libp2p/go-libp2p-swarm v0.2.8 h1:cIUUvytBzNQmGSjnXFlI6UpoBGsaud82mJPIJVfkDlg=
 github.com/libp2p/go-libp2p-swarm v0.2.8/go.mod h1:JQKMGSth4SMqonruY0a8yjlPVIkb0mdNSwckW7OYziM=
+github.com/libp2p/go-libp2p-swarm v0.3.0/go.mod h1:hdv95GWCTmzkgeJpP+GK/9D9puJegb7H57B5hWQR5Kk=
+github.com/libp2p/go-libp2p-swarm v0.3.1 h1:UTobu+oQHGdXTOGpZ4RefuVqYoJXcT0EBtSR74m2LkI=
+github.com/libp2p/go-libp2p-swarm v0.3.1/go.mod h1:hdv95GWCTmzkgeJpP+GK/9D9puJegb7H57B5hWQR5Kk=
 github.com/libp2p/go-libp2p-testing v0.0.1/go.mod h1:gvchhf3FQOtBdr+eFUABet5a4MBLK8jM3V4Zghvmi+E=
 github.com/libp2p/go-libp2p-testing v0.0.2/go.mod h1:gvchhf3FQOtBdr+eFUABet5a4MBLK8jM3V4Zghvmi+E=
 github.com/libp2p/go-libp2p-testing v0.0.3/go.mod h1:gvchhf3FQOtBdr+eFUABet5a4MBLK8jM3V4Zghvmi+E=
@ -954,6 +971,8 @@ github.com/libp2p/go-libp2p-testing v0.1.0/go.mod h1:xaZWMJrPUM5GlDBxCeGUi7kI4eq
 github.com/libp2p/go-libp2p-testing v0.1.1/go.mod h1:xaZWMJrPUM5GlDBxCeGUi7kI4eqnjVyavGroI2nxEM0=
 github.com/libp2p/go-libp2p-testing v0.1.2-0.20200422005655-8775583591d8 h1:v4dvk7YEW8buwCdIVWnhpv0Hp/AAJKRWIxBhmLRZrsk=
 github.com/libp2p/go-libp2p-testing v0.1.2-0.20200422005655-8775583591d8/go.mod h1:Qy8sAncLKpwXtS2dSnDOP8ktexIAHKu+J+pnZOFZLTc=
+github.com/libp2p/go-libp2p-testing v0.3.0 h1:ZiBYstPamsi7y6NJZebRudUzsYmVkt998hltyLqf8+g=
+github.com/libp2p/go-libp2p-testing v0.3.0/go.mod h1:efZkql4UZ7OVsEfaxNHZPzIehtsBXMrXnCfJIgDti5g=
 github.com/libp2p/go-libp2p-tls v0.1.3 h1:twKMhMu44jQO+HgQK9X8NHO5HkeJu2QbhLzLJpa8oNM=
 github.com/libp2p/go-libp2p-tls v0.1.3/go.mod h1:wZfuewxOndz5RTnCAxFliGjvYSDA40sKitV4c50uI1M=
 github.com/libp2p/go-libp2p-transport v0.0.1/go.mod h1:UzbUs9X+PHOSw7S3ZmeOxfnwaQY5vGDzZmKPod3N3tk=
@ -974,6 +993,10 @@ github.com/libp2p/go-libp2p-yamux v0.2.5/go.mod h1:Zpgj6arbyQrmZ3wxSZxfBmbdnWtbZ
 github.com/libp2p/go-libp2p-yamux v0.2.7/go.mod h1:X28ENrBMU/nm4I3Nx4sZ4dgjZ6VhLEn0XhIoZ5viCwU=
 github.com/libp2p/go-libp2p-yamux v0.2.8 h1:0s3ELSLu2O7hWKfX1YjzudBKCP0kZ+m9e2+0veXzkn4=
 github.com/libp2p/go-libp2p-yamux v0.2.8/go.mod h1:/t6tDqeuZf0INZMTgd0WxIRbtK2EzI2h7HbFm9eAKI4=
+github.com/libp2p/go-libp2p-yamux v0.4.0 h1:qunEZzWwwmfSBYTtSyd81PlD1TjB5uuWcGYHWVXLbUg=
+github.com/libp2p/go-libp2p-yamux v0.4.0/go.mod h1:+DWDjtFMzoAwYLVkNZftoucn7PelNoy5nm3tZ3/Zw30=
+github.com/libp2p/go-libp2p-yamux v0.4.1 h1:TJxRVPY9SjH7TNrNC80l1OJMBiWhs1qpKmeB+1Ug3xU=
+github.com/libp2p/go-libp2p-yamux v0.4.1/go.mod h1:FA/NjRYRVNjqOzpGuGqcruH7jAU2mYIjtKBicVOL3dc=
 github.com/libp2p/go-maddr-filter v0.0.1/go.mod h1:6eT12kSQMA9x2pvFQa+xesMKUBlj9VImZbj3B9FBH/Q=
 github.com/libp2p/go-maddr-filter v0.0.4/go.mod h1:6eT12kSQMA9x2pvFQa+xesMKUBlj9VImZbj3B9FBH/Q=
 github.com/libp2p/go-maddr-filter v0.0.5/go.mod h1:Jk+36PMfIqCJhAnaASRH83bdAvfDRp/w6ENFaC9bG+M=
@ -986,6 +1009,8 @@ github.com/libp2p/go-mplex v0.1.0/go.mod h1:SXgmdki2kwCUlCCbfGLEgHjC4pFqhTp0ZoV6
 github.com/libp2p/go-mplex v0.1.1/go.mod h1:Xgz2RDCi3co0LeZfgjm4OgUF15+sVR8SRcu3SFXI1lk=
 github.com/libp2p/go-mplex v0.1.2 h1:qOg1s+WdGLlpkrczDqmhYzyk3vCfsQ8+RxRTQjOZWwI=
 github.com/libp2p/go-mplex v0.1.2/go.mod h1:Xgz2RDCi3co0LeZfgjm4OgUF15+sVR8SRcu3SFXI1lk=
+github.com/libp2p/go-mplex v0.2.0 h1:Ov/D+8oBlbRkjBs1R1Iua8hJ8cUfbdiW8EOdZuxcgaI=
+github.com/libp2p/go-mplex v0.2.0/go.mod h1:0Oy/A9PQlwBytDRp4wSkFnzHYDKcpLot35JQ6msjvYQ=
 github.com/libp2p/go-msgio v0.0.1/go.mod h1:63lBBgOTDKQL6EWazRMCwXsEeEeK9O2Cd+0+6OOuipQ=
 github.com/libp2p/go-msgio v0.0.2/go.mod h1:63lBBgOTDKQL6EWazRMCwXsEeEeK9O2Cd+0+6OOuipQ=
 github.com/libp2p/go-msgio v0.0.3/go.mod h1:63lBBgOTDKQL6EWazRMCwXsEeEeK9O2Cd+0+6OOuipQ=
@ -1048,8 +1073,10 @@ github.com/libp2p/go-yamux v1.3.5/go.mod h1:FGTiPvoV/3DVdgWpX+tM0OW3tsM+W5bSE3gZ
 github.com/libp2p/go-yamux v1.3.6/go.mod h1:FGTiPvoV/3DVdgWpX+tM0OW3tsM+W5bSE3gZwqQTcow=
 github.com/libp2p/go-yamux v1.3.7 h1:v40A1eSPJDIZwz2AvrV3cxpTZEGDP11QJbukmEhYyQI=
 github.com/libp2p/go-yamux v1.3.7/go.mod h1:fr7aVgmdNGJK+N1g+b6DW6VxzbRCjCOejR/hkmpooHE=
-github.com/libp2p/go-yamux v1.3.10 h1:usox3zyxreg0MPnosecUH/3eJAUHIlgwp7IB/3aUT/s=
-github.com/libp2p/go-yamux v1.3.10/go.mod h1:fr7aVgmdNGJK+N1g+b6DW6VxzbRCjCOejR/hkmpooHE=
+github.com/libp2p/go-yamux v1.4.0 h1:7nqe0T95T2CWh40IdJ/tp8RMor4ubc9/wYZpB2a/Hx0=
+github.com/libp2p/go-yamux v1.4.0/go.mod h1:fr7aVgmdNGJK+N1g+b6DW6VxzbRCjCOejR/hkmpooHE=
+github.com/libp2p/go-yamux v1.4.1 h1:P1Fe9vF4th5JOxxgQvfbOHkrGqIZniTLf+ddhZp8YTI=
+github.com/libp2p/go-yamux v1.4.1/go.mod h1:fr7aVgmdNGJK+N1g+b6DW6VxzbRCjCOejR/hkmpooHE=
 github.com/lightstep/lightstep-tracer-common/golang/gogo v0.0.0-20190605223551-bc2310a04743/go.mod h1:qklhhLq1aX+mtWk9cPHPzaBjWImj5ULL6C7HFJtXQMM=
 github.com/lightstep/lightstep-tracer-go v0.18.1/go.mod h1:jlF1pusYV4pidLvZ+XD0UBX0ZE6WURAspgAczcDHrL4=
 github.com/lucas-clemente/quic-go v0.11.2/go.mod h1:PpMmPfPKO9nKJ/psF49ESTAGQSdfXxlg1otPbEB2nOw=
@ -1181,8 +1208,8 @@ github.com/multiformats/go-multistream v0.0.1/go.mod h1:fJTiDfXJVmItycydCnNx4+wS
 github.com/multiformats/go-multistream v0.0.4/go.mod h1:fJTiDfXJVmItycydCnNx4+wSzZ5NwG2FEVAI30fiovg=
 github.com/multiformats/go-multistream v0.1.0/go.mod h1:fJTiDfXJVmItycydCnNx4+wSzZ5NwG2FEVAI30fiovg=
 github.com/multiformats/go-multistream v0.1.1/go.mod h1:KmHZ40hzVxiaiwlj3MEbYgK9JFk2/9UktWZAF54Du38=
-github.com/multiformats/go-multistream v0.1.2 h1:knyamLYMPFPngQjGQ0lhnlys3jtVR/3xV6TREUJr+fE=
-github.com/multiformats/go-multistream v0.1.2/go.mod h1:5GZPQZbkWOLOn3J2y4Y99vVW7vOfsAflxARk3x14o6k=
+github.com/multiformats/go-multistream v0.2.0 h1:6AuNmQVKUkRnddw2YiDjt5Elit40SFxMJkVnhmETXtU=
+github.com/multiformats/go-multistream v0.2.0/go.mod h1:5GZPQZbkWOLOn3J2y4Y99vVW7vOfsAflxARk3x14o6k=
 github.com/multiformats/go-varint v0.0.1/go.mod h1:3Ls8CIEsrijN6+B7PbrXRPxHRPuXSrVKRY101jdMZYE=
 github.com/multiformats/go-varint v0.0.2/go.mod h1:3Ls8CIEsrijN6+B7PbrXRPxHRPuXSrVKRY101jdMZYE=
 github.com/multiformats/go-varint v0.0.5/go.mod h1:3Ls8CIEsrijN6+B7PbrXRPxHRPuXSrVKRY101jdMZYE=
@ -1420,7 +1447,6 @@ github.com/valyala/fasttemplate v1.0.1 h1:tY9CJiPnMXf1ERmG2EyK7gNUd+c6RKGD0IfU8W
 github.com/valyala/fasttemplate v1.0.1/go.mod h1:UQGH1tvbgY+Nz5t2n7tXsz52dQxojPUpymEIMZ47gx8=
 github.com/viant/assertly v0.4.8/go.mod h1:aGifi++jvCrUaklKEKT0BU95igDNaqkvz+49uaYMPRU=
 github.com/viant/toolbox v0.24.0/go.mod h1:OxMCG57V0PXuIP2HNQrtJf2CjqdmbrOx5EkMILuUhzM=
-github.com/wangjia184/sortedset v0.0.0-20160527075905-f5d03557ba30/go.mod h1:YkocrP2K2tcw938x9gCOmT5G5eCD6jsTz0SZuyAqwIE=
 github.com/warpfork/go-wish v0.0.0-20180510122957-5ad1f5abf436/go.mod h1:x6AKhvSSexNrVSrViXSHUEbICjmGXhtgABaHIySUSGw=
 github.com/warpfork/go-wish v0.0.0-20190328234359-8b3e70f8e830/go.mod h1:x6AKhvSSexNrVSrViXSHUEbICjmGXhtgABaHIySUSGw=
 github.com/warpfork/go-wish v0.0.0-20200122115046-b9ea61034e4a h1:G++j5e0OC488te356JvdhaM8YS6nMsjLAYF7JxCv07w=
@ -1531,6 +1557,8 @@ go.uber.org/zap v1.13.0/go.mod h1:zwrFLgMcdUuIBviXEYEH1YKNaOBnKXsx2IPda5bBwHM=
 go.uber.org/zap v1.14.1/go.mod h1:Mb2vm2krFEG5DV0W9qcHBYFtp/Wku1cvYaqPsS/WYfc=
 go.uber.org/zap v1.15.0 h1:ZZCA22JRF2gQE5FoNmhmrf7jeJJ2uhqDUNRYKm8dvmM=
 go.uber.org/zap v1.15.0/go.mod h1:Mb2vm2krFEG5DV0W9qcHBYFtp/Wku1cvYaqPsS/WYfc=
+go.uber.org/zap v1.16.0 h1:uFRZXykJGK9lLY4HtgSw44DnIcAM+kRBP7x5m+NpAOM=
+go.uber.org/zap v1.16.0/go.mod h1:MA8QOfq0BHJwdXa996Y4dYkAqRKB8/1K1QMMZVaNZjQ=
 go4.org v0.0.0-20180809161055-417644f6feb5/go.mod h1:MkTOUMDaeVYJUOUsaDXIhWPZYa1yOyC1qaOBpL57BhE=
 go4.org v0.0.0-20200411211856-f5505b9728dd h1:BNJlw5kRTzdmyfh5U8F93HA2OwkP7ZGwA51eJ/0wKOU=
 go4.org v0.0.0-20200411211856-f5505b9728dd/go.mod h1:CIiUVy99QCPfoE13bO4EZaz5GZMZXMSBGhxRdsvzbkg=
@ -1840,8 +1868,11 @@ google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQ
 google.golang.org/grpc v1.26.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
 google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
 google.golang.org/grpc v1.27.1/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
+google.golang.org/grpc v1.28.1/go.mod h1:rpkK4SK4GF4Ach/+MFLZUBavHOvF2JJB5uozKKal+60=
 google.golang.org/grpc v1.29.1 h1:EC2SB8S04d2r73uptxphDSUG+kTKVgjRPF+N3xpxRB4=
 google.golang.org/grpc v1.29.1/go.mod h1:itym6AZVZYACWQqET3MqgPpjcuV5QH3BxFS3IjizoKk=
+google.golang.org/grpc v1.31.1 h1:SfXqXS5hkufcdZ/mHtYCh53P2b+92WQq/DZcKLgsFRs=
+google.golang.org/grpc v1.31.1/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak=
 google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
 google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=
 google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM=
--- a/lib/blockstore/blockstore.go
+++ b/lib/blockstore/blockstore.go
@ -45,12 +45,8 @@ func NewBlockstore(dstore ds.Batching) blockstore.Blockstore {
 // Alias so other packages don't have to import go-ipfs-blockstore
 type Blockstore = blockstore.Blockstore
 type Viewer = blockstore.Viewer
-type GCBlockstore = blockstore.GCBlockstore
 type CacheOpts = blockstore.CacheOpts
-type GCLocker = blockstore.GCLocker

-var NewGCLocker = blockstore.NewGCLocker
-var NewGCBlockstore = blockstore.NewGCBlockstore
 var ErrNotFound = blockstore.ErrNotFound

 func DefaultCacheOpts() CacheOpts {
--- a/lib/blockstore/memstore.go
+++ b/lib/blockstore/memstore.go
@ -5,7 +5,6 @@ import (

 	blocks "github.com/ipfs/go-block-format"
 	"github.com/ipfs/go-cid"
-	blockstore "github.com/ipfs/go-ipfs-blockstore"
 )

 // MemStore is a terminal blockstore that keeps blocks in memory.
@ -24,7 +23,7 @@ func (m MemStore) Has(k cid.Cid) (bool, error) {
 func (m MemStore) View(k cid.Cid, callback func([]byte) error) error {
 	b, ok := m[k]
 	if !ok {
-		return blockstore.ErrNotFound
+		return ErrNotFound
 	}
 	return callback(b.RawData())
 }
@ -32,7 +31,7 @@ func (m MemStore) View(k cid.Cid, callback func([]byte) error) error {
 func (m MemStore) Get(k cid.Cid) (blocks.Block, error) {
 	b, ok := m[k]
 	if !ok {
-		return nil, blockstore.ErrNotFound
+		return nil, ErrNotFound
 	}
 	return b, nil
 }
@ -41,7 +40,7 @@ func (m MemStore) Get(k cid.Cid) (blocks.Block, error) {
 func (m MemStore) GetSize(k cid.Cid) (int, error) {
 	b, ok := m[k]
 	if !ok {
-		return 0, blockstore.ErrNotFound
+		return 0, ErrNotFound
 	}
 	return len(b.RawData()), nil
 }
--- a/markets/storageadapter/client.go
+++ b/markets/storageadapter/client.go
@ -57,7 +57,7 @@ func NewClientNodeAdapter(stateapi full.StateAPI, chain full.ChainAPI, mpool ful

 		fundmgr:   fundmgr,
 		ev:        events.NewEvents(context.TODO(), capi),
-		dsMatcher: newDealStateMatcher(state.NewStatePredicates(capi)),
+		dsMatcher: newDealStateMatcher(state.NewStatePredicates(state.WrapFastAPI(capi))),
 	}
 }

--- a/markets/storageadapter/provider.go
+++ b/markets/storageadapter/provider.go
@ -60,7 +60,7 @@ func NewProviderNodeAdapter(fc *config.MinerFeeConfig) func(dag dtypes.StagingDA
 			dag:       dag,
 			secb:      secb,
 			ev:        events.NewEvents(context.TODO(), full),
-			dsMatcher: newDealStateMatcher(state.NewStatePredicates(full)),
+			dsMatcher: newDealStateMatcher(state.NewStatePredicates(state.WrapFastAPI(full))),
 		}
 		if fc != nil {
 			na.publishSpec = &api.MessageSendSpec{MaxFee: abi.TokenAmount(fc.MaxPublishDealsFee)}
--- a/miner/miner.go
+++ b/miner/miner.go
@ -150,6 +150,8 @@ func (m *Miner) mine(ctx context.Context) {
 	ctx, span := trace.StartSpan(ctx, "/mine")
 	defer span.End()

+	go m.doWinPoStWarmup(ctx)
+
 	var lastBase MiningBase
 minerLoop:
 	for {
--- a/miner/warmup.go
+++ b/miner/warmup.go
@ -0,0 +1,82 @@
+package miner
+
+import (
+	"context"
+	"crypto/rand"
+	"math"
+	"time"
+
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/go-bitfield"
+	"github.com/filecoin-project/go-state-types/abi"
+
+	proof2 "github.com/filecoin-project/specs-actors/v2/actors/runtime/proof"
+
+	"github.com/filecoin-project/lotus/chain/types"
+)
+
+func (m *Miner) winPoStWarmup(ctx context.Context) error {
+	deadlines, err := m.api.StateMinerDeadlines(ctx, m.address, types.EmptyTSK)
+	if err != nil {
+		return xerrors.Errorf("getting deadlines: %w", err)
+	}
+
+	var sector abi.SectorNumber = math.MaxUint64
+
+	for dlIdx := range deadlines {
+		partitions, err := m.api.StateMinerPartitions(ctx, m.address, uint64(dlIdx), types.EmptyTSK)
+		if err != nil {
+			return xerrors.Errorf("getting partitions for deadline %d: %w", dlIdx, err)
+		}
+
+		for _, partition := range partitions {
+			b, err := partition.ActiveSectors.First()
+			if err == bitfield.ErrNoBitsSet {
+				continue
+			}
+			if err != nil {
+				return err
+			}
+
+			sector = abi.SectorNumber(b)
+		}
+	}
+
+	if sector == math.MaxUint64 {
+		log.Info("skipping winning PoSt warmup, no sectors")
+		return nil
+	}
+
+	log.Infow("starting winning PoSt warmup", "sector", sector)
+	start := time.Now()
+
+	var r abi.PoStRandomness = make([]byte, abi.RandomnessLength)
+	_, _ = rand.Read(r)
+
+	si, err := m.api.StateSectorGetInfo(ctx, m.address, sector, types.EmptyTSK)
+	if err != nil {
+		return xerrors.Errorf("getting sector info: %w", err)
+	}
+
+	_, err = m.epp.ComputeProof(ctx, []proof2.SectorInfo{
+		{
+			SealProof:    si.SealProof,
+			SectorNumber: sector,
+			SealedCID:    si.SealedCID,
+		},
+	}, r)
+	if err != nil {
+		return xerrors.Errorf("failed to compute proof: %w", err)
+	}
+
+	log.Infow("winning PoSt warmup successful", "took", time.Now().Sub(start))
+	return nil
+}
+
+func (m *Miner) doWinPoStWarmup(ctx context.Context) {
+	err := m.winPoStWarmup(ctx)
+	if err != nil {
+		log.Errorw("winning PoSt warmup failed", "error", err)
+	}
+}
--- a/node/builder.go
+++ b/node/builder.go
@ -55,7 +55,6 @@ import (
 	"github.com/filecoin-project/lotus/extern/sector-storage/storiface"
 	sealing "github.com/filecoin-project/lotus/extern/storage-sealing"
 	"github.com/filecoin-project/lotus/journal"
-	"github.com/filecoin-project/lotus/lib/blockstore"
 	"github.com/filecoin-project/lotus/lib/peermgr"
 	_ "github.com/filecoin-project/lotus/lib/sigs/bls"
 	_ "github.com/filecoin-project/lotus/lib/sigs/secp"
@ -264,8 +263,6 @@ func Online() Option {
 			Override(new(api.WalletAPI), From(new(wallet.MultiWallet))),
 			Override(new(*messagesigner.MessageSigner), messagesigner.NewMessageSigner),

-			Override(new(dtypes.ChainGCLocker), blockstore.NewGCLocker),
-			Override(new(dtypes.ChainGCBlockstore), modules.ChainGCBlockstore),
 			Override(new(dtypes.ChainBitswap), modules.ChainBitswap),
 			Override(new(dtypes.ChainBlockService), modules.ChainBlockService),

--- a/node/hello/hello.go
+++ b/node/hello/hello.go
@ -118,7 +118,7 @@ func (hs *Service) HandleStream(s inet.Stream) {
 		hs.h.ConnManager().TagPeer(s.Conn().RemotePeer(), "fcpeer", 10)

 		// don't bother informing about genesis
-		log.Infof("Got new tipset through Hello: %s from %s", ts.Cids(), s.Conn().RemotePeer())
+		log.Debugf("Got new tipset through Hello: %s from %s", ts.Cids(), s.Conn().RemotePeer())
 		hs.syncer.InformNewHead(s.Conn().RemotePeer(), ts)
 	}

@ -161,7 +161,7 @@ func (hs *Service) SayHello(ctx context.Context, pid peer.ID) error {
 		_ = s.SetReadDeadline(build.Clock.Now().Add(10 * time.Second))
 		err := cborutil.ReadCborRPC(s, lmsg)
 		if err != nil {
-			log.Infow("reading latency message", "error", err)
+			log.Debugw("reading latency message", "error", err)
 		}

 		t3 := build.Clock.Now()
@ -177,7 +177,9 @@ func (hs *Service) SayHello(ctx context.Context, pid peer.ID) error {
 				t2 := time.Unix(0, lmsg.TSent)
 				offset := t0.Sub(t1) + t3.Sub(t2)
 				offset /= 2
-				log.Infow("time offset", "offset", offset.Seconds(), "peerid", pid.String())
+				if offset > 5*time.Second || offset < -5*time.Second {
+					log.Infow("time offset", "offset", offset.Seconds(), "peerid", pid.String())
+				}
 			}
 		}
 	}()
--- a/node/modules/chain.go
+++ b/node/modules/chain.go
@ -38,7 +38,7 @@ import (
 	"github.com/filecoin-project/lotus/node/repo"
 )

-func ChainBitswap(mctx helpers.MetricsCtx, lc fx.Lifecycle, host host.Host, rt routing.Routing, bs dtypes.ChainGCBlockstore) dtypes.ChainBitswap {
+func ChainBitswap(mctx helpers.MetricsCtx, lc fx.Lifecycle, host host.Host, rt routing.Routing, bs dtypes.ChainBlockstore) dtypes.ChainBitswap {
 	// prefix protocol for chain bitswap
 	// (so bitswap uses /chain/ipfs/bitswap/1.0.0 internally for chain sync stuff)
 	bitswapNetwork := network.NewFromIpfsHost(host, rt, network.Prefix("/chain"))
@ -91,10 +91,6 @@ func ChainRawBlockstore(lc fx.Lifecycle, mctx helpers.MetricsCtx, r repo.LockedR
 	return cbs, nil
 }

-func ChainGCBlockstore(bs dtypes.ChainRawBlockstore, gcl dtypes.ChainGCLocker) dtypes.ChainGCBlockstore {
-	return blockstore.NewGCBlockstore(bs, gcl)
-}
-
 func ChainBlockService(bs dtypes.ChainRawBlockstore, rem dtypes.ChainBitswap) dtypes.ChainBlockService {
 	return blockservice.New(bs, rem)
 }
--- a/node/modules/client.go
+++ b/node/modules/client.go
@ -55,16 +55,20 @@ func HandleMigrateClientFunds(lc fx.Lifecycle, ds dtypes.MetadataDS, wallet full
 				if xerrors.Is(err, datastore.ErrNotFound) {
 					return nil
 				}
-				return err
+				log.Errorf("client funds migration - getting datastore value: %w", err)
+				return nil
 			}

 			var value abi.TokenAmount
 			if err = value.UnmarshalCBOR(bytes.NewReader(b)); err != nil {
-				return err
+				log.Errorf("client funds migration - unmarshalling datastore value: %w", err)
+				return nil
 			}
 			_, err = fundMgr.Reserve(ctx, addr, addr, value)
 			if err != nil {
-				return err
+				log.Errorf("client funds migration - reserving funds (wallet %s, addr %s, funds %d): %w",
+					addr, addr, value, err)
+				return nil
 			}

 			return ds.Delete(datastore.NewKey("/marketfunds/client"))
--- a/node/modules/dtypes/storage.go
+++ b/node/modules/dtypes/storage.go
@ -26,8 +26,6 @@ type MetadataDS datastore.Batching
 type ChainRawBlockstore blockstore.Blockstore
 type ChainBlockstore blockstore.Blockstore // optionally bitswap backed

-type ChainGCLocker blockstore.GCLocker
-type ChainGCBlockstore blockstore.GCBlockstore
 type ChainBitswap exchange.Interface
 type ChainBlockService bserv.BlockService

--- a/node/modules/services.go
+++ b/node/modules/services.go
@ -2,6 +2,9 @@ package modules

 import (
 	"context"
+	"os"
+	"strconv"
+	"time"

 	"github.com/ipfs/go-datastore"
 	"github.com/ipfs/go-datastore/namespace"
@ -25,6 +28,7 @@ import (
 	"github.com/filecoin-project/lotus/chain/stmgr"
 	"github.com/filecoin-project/lotus/chain/store"
 	"github.com/filecoin-project/lotus/chain/sub"
+	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/journal"
 	"github.com/filecoin-project/lotus/lib/peermgr"
 	marketevents "github.com/filecoin-project/lotus/markets/loggers"
@ -34,6 +38,19 @@ import (
 	"github.com/filecoin-project/lotus/node/repo"
 )

+var pubsubMsgsSyncEpochs = 10
+
+func init() {
+	if s := os.Getenv("LOTUS_MSGS_SYNC_EPOCHS"); s != "" {
+		val, err := strconv.Atoi(s)
+		if err != nil {
+			log.Errorf("failed to parse LOTUS_MSGS_SYNC_EPOCHS: %s", err)
+			return
+		}
+		pubsubMsgsSyncEpochs = val
+	}
+}
+
 func RunHello(mctx helpers.MetricsCtx, lc fx.Lifecycle, h host.Host, svc *hello.Service) error {
 	h.SetStreamHandler(hello.ProtocolID, svc.HandleStream)

@ -82,14 +99,45 @@ func RunChainExchange(h host.Host, svc exchange.Server) {
 	h.SetStreamHandler(exchange.ChainExchangeProtocolID, svc.HandleStream) // new
 }

+func waitForSync(stmgr *stmgr.StateManager, epochs int, subscribe func()) {
+	nearsync := time.Duration(epochs*int(build.BlockDelaySecs)) * time.Second
+
+	// early check, are we synced at start up?
+	ts := stmgr.ChainStore().GetHeaviestTipSet()
+	timestamp := ts.MinTimestamp()
+	timestampTime := time.Unix(int64(timestamp), 0)
+	if build.Clock.Since(timestampTime) < nearsync {
+		subscribe()
+		return
+	}
+
+	// we are not synced, subscribe to head changes and wait for sync
+	stmgr.ChainStore().SubscribeHeadChanges(func(rev, app []*types.TipSet) error {
+		if len(app) == 0 {
+			return nil
+		}
+
+		latest := app[0].MinTimestamp()
+		for _, ts := range app[1:] {
+			timestamp := ts.MinTimestamp()
+			if timestamp > latest {
+				latest = timestamp
+			}
+		}
+
+		latestTime := time.Unix(int64(latest), 0)
+		if build.Clock.Since(latestTime) < nearsync {
+			subscribe()
+			return store.ErrNotifeeDone
+		}
+
+		return nil
+	})
+}
+
 func HandleIncomingBlocks(mctx helpers.MetricsCtx, lc fx.Lifecycle, ps *pubsub.PubSub, s *chain.Syncer, bserv dtypes.ChainBlockService, chain *store.ChainStore, stmgr *stmgr.StateManager, h host.Host, nn dtypes.NetworkName) {
 	ctx := helpers.LifecycleCtx(mctx, lc)

-	blocksub, err := ps.Subscribe(build.BlocksTopic(nn)) //nolint
-	if err != nil {
-		panic(err)
-	}
-
 	v := sub.NewBlockValidator(
 		h.ID(), chain, stmgr,
 		func(p peer.ID) {
@ -101,24 +149,43 @@ func HandleIncomingBlocks(mctx helpers.MetricsCtx, lc fx.Lifecycle, ps *pubsub.P
 		panic(err)
 	}

-	go sub.HandleIncomingBlocks(ctx, blocksub, s, bserv, h.ConnManager())
-}
+	log.Infof("subscribing to pubsub topic %s", build.BlocksTopic(nn))

-func HandleIncomingMessages(mctx helpers.MetricsCtx, lc fx.Lifecycle, ps *pubsub.PubSub, mpool *messagepool.MessagePool, h host.Host, nn dtypes.NetworkName) {
-	ctx := helpers.LifecycleCtx(mctx, lc)
-
-	msgsub, err := ps.Subscribe(build.MessagesTopic(nn)) //nolint:staticcheck
+	blocksub, err := ps.Subscribe(build.BlocksTopic(nn)) //nolint
 	if err != nil {
 		panic(err)
 	}

+	go sub.HandleIncomingBlocks(ctx, blocksub, s, bserv, h.ConnManager())
+}
+
+func HandleIncomingMessages(mctx helpers.MetricsCtx, lc fx.Lifecycle, ps *pubsub.PubSub, stmgr *stmgr.StateManager, mpool *messagepool.MessagePool, h host.Host, nn dtypes.NetworkName, bootstrapper dtypes.Bootstrapper) {
+	ctx := helpers.LifecycleCtx(mctx, lc)
+
 	v := sub.NewMessageValidator(h.ID(), mpool)

 	if err := ps.RegisterTopicValidator(build.MessagesTopic(nn), v.Validate); err != nil {
 		panic(err)
 	}

-	go sub.HandleIncomingMessages(ctx, mpool, msgsub)
+	subscribe := func() {
+		log.Infof("subscribing to pubsub topic %s", build.MessagesTopic(nn))
+
+		msgsub, err := ps.Subscribe(build.MessagesTopic(nn)) //nolint
+		if err != nil {
+			panic(err)
+		}
+
+		go sub.HandleIncomingMessages(ctx, mpool, msgsub)
+	}
+
+	if bootstrapper {
+		subscribe()
+		return
+	}
+
+	// wait until we are synced within 10 epochs -- env var can override
+	waitForSync(stmgr, pubsubMsgsSyncEpochs, subscribe)
 }

 func NewLocalDiscovery(lc fx.Lifecycle, ds dtypes.MetadataDS) (*discoveryimpl.Local, error) {
--- a/node/modules/storageminer.go
+++ b/node/modules/storageminer.go
@ -263,17 +263,21 @@ func HandleMigrateProviderFunds(lc fx.Lifecycle, ds dtypes.MetadataDS, node api.
 			}
 			ts, err := node.ChainHead(ctx)
 			if err != nil {
-				return err
+				log.Errorf("provider funds migration - getting chain head: %w", err)
+				return nil
 			}

 			mi, err := node.StateMinerInfo(ctx, address.Address(minerAddress), ts.Key())
 			if err != nil {
-				return err
+				log.Errorf("provider funds migration - getting miner info %s: %w", minerAddress, err)
+				return nil
 			}

 			_, err = node.MarketReserveFunds(ctx, mi.Worker, address.Address(minerAddress), value)
 			if err != nil {
-				return err
+				log.Errorf("provider funds migration - reserving funds (wallet %s, addr %s, funds %d): %w",
+					mi.Worker, minerAddress, value, err)
+				return nil
 			}

 			return ds.Delete(datastore.NewKey("/marketfunds/provider"))
--- a/node/repo/fsrepo.go
+++ b/node/repo/fsrepo.go
@ -12,9 +12,9 @@ import (
 	"sync"

 	"github.com/BurntSushi/toml"
+	"github.com/filecoin-project/lotus/lib/blockstore"
 	"github.com/ipfs/go-datastore"
 	fslock "github.com/ipfs/go-fs-lock"
-	blockstore "github.com/ipfs/go-ipfs-blockstore"
 	logging "github.com/ipfs/go-log/v2"
 	"github.com/mitchellh/go-homedir"
 	"github.com/multiformats/go-base32"
--- a/node/repo/interface.go
+++ b/node/repo/interface.go
@ -3,8 +3,8 @@ package repo
 import (
 	"errors"

+	"github.com/filecoin-project/lotus/lib/blockstore"
 	"github.com/ipfs/go-datastore"
-	blockstore "github.com/ipfs/go-ipfs-blockstore"
 	"github.com/multiformats/go-multiaddr"

 	"github.com/filecoin-project/lotus/extern/sector-storage/fsutil"
--- a/node/repo/retrievalstoremgr/retrievalstoremgr_test.go
+++ b/node/repo/retrievalstoremgr/retrievalstoremgr_test.go
@ -9,13 +9,13 @@ import (
 	"github.com/ipfs/go-datastore"
 	"github.com/ipfs/go-datastore/query"
 	dss "github.com/ipfs/go-datastore/sync"
-	blockstore "github.com/ipfs/go-ipfs-blockstore"
 	format "github.com/ipfs/go-ipld-format"
 	dag "github.com/ipfs/go-merkledag"
 	"github.com/stretchr/testify/require"

 	"github.com/filecoin-project/go-multistore"

+	"github.com/filecoin-project/lotus/lib/blockstore"
 	"github.com/filecoin-project/lotus/node/repo/importmgr"
 	"github.com/filecoin-project/lotus/node/repo/retrievalstoremgr"
 )
--- a/node/test/builder.go
+++ b/node/test/builder.go
@ -40,6 +40,7 @@ import (
 	lotusminer "github.com/filecoin-project/lotus/miner"
 	"github.com/filecoin-project/lotus/node"
 	"github.com/filecoin-project/lotus/node/modules"
+	"github.com/filecoin-project/lotus/node/modules/dtypes"
 	testing2 "github.com/filecoin-project/lotus/node/modules/testing"
 	"github.com/filecoin-project/lotus/node/repo"
 	"github.com/filecoin-project/lotus/storage/mockstorage"
@ -412,6 +413,9 @@ func mockSbBuilderOpts(t *testing.T, fullOpts []test.FullNodeOpts, storage []tes

 			node.Override(new(ffiwrapper.Verifier), mock.MockVerifier),

+			// so that we subscribe to pubsub topics immediately
+			node.Override(new(dtypes.Bootstrapper), dtypes.Bootstrapper(true)),
+
 			genesis,

 			fullOpts[i].Opts(fulls),