fix setup of burnt funds actor state

randomize ticket in genesis creation
2020-08-24 18:45:09 +00:00 · 2020-08-24 18:40:51 +00:00
158 changed files with 1356 additions and 6365 deletions
@@ -252,27 +252,6 @@ jobs:
      - run:
          command: "! go fmt ./... 2>&1 | read"

-  cbor-gen-check:
-    executor: golang
-    steps:
-      - install-deps
-      - prepare
-      - run: make deps
-      - run: go install golang.org/x/tools/cmd/goimports
-      - run: go install github.com/hannahhoward/cbor-gen-for
-      - run: go generate ./...
-      - run: git --no-pager diff
-      - run: git --no-pager diff --quiet
-
-  docs-check:
-    executor: golang
-    steps:
-      - install-deps
-      - prepare
-      - run: make docsgen
-      - run: git --no-pager diff
-      - run: git --no-pager diff --quiet
-
  lint: &lint
    description: |
      Run golangci-lint.
@@ -309,6 +288,9 @@ jobs:
          command: |
            $HOME/.local/bin/golangci-lint run -v --timeout 2m \
              --concurrency << parameters.concurrency >> << parameters.args >>
+  lint-changes:
+    <<: *lint
+
  lint-all:
    <<: *lint

@@ -337,11 +319,10 @@ workflows:
  version: 2.1
  ci:
    jobs:
-      - lint-all
+      - lint-changes:
+          args: "--new-from-rev origin/next"
      - mod-tidy-check
      - gofmt
-      - cbor-gen-check
-      - docs-check
      - test:
          codecov-upload: true
          test-suite-name: full
@@ -23,14 +23,6 @@ issues:
    - "Potential file inclusion via variable"
    - "should have( a package)? comment"
    - "Error return value of `logging.SetLogLevel` is not checked"
-    - "comment on exported"
-    - "(func|method) \\w+ should be \\w+"
-    - "(type|var|struct field|(method|func) parameter) `\\w+` should be `\\w+`"
-    - "(G306|G301|G307|G108|G302|G204|G104)"
-    - "don't use ALL_CAPS in Go names"
-    - "string .* has .* occurrences, make it a constant"
-    - "a blank import should be only in a main or test package, or have a comment justifying it"
-    - "package comment should be of the form"

  exclude-use-default: false
  exclude-rules:
@@ -54,19 +46,6 @@ issues:
      linters:
        - gosec

-    - path: chain/vectors/gen/.*
-      linters:
-        - gosec
-
-    - path: cmd/lotus-bench/.*
-      linters:
-        - gosec
-
-    - path: api/test/.*
-      text: "context.Context should be the first parameter"
-      linters:
-        - golint
-
 linters-settings:
  goconst:
    min-occurrences: 6
@@ -1,53 +1,12 @@
 # Lotus changelog

-# 0.5.4
-
-A patch release, containing a few nice bugfixes and improvements:
-
- Fix parsing of peer ID in `lotus-miner actor set-peer-id` (@whyrusleeping)
- Update dependencies, fixing several bugs (@Stebalien)
- Fix remaining linter warnings (@Stebalien)
- Use safe string truncation (@Ingar)
- Allow tweaking of blocksync message window size (@whyrusleeping)
- Add some additional gas stats to metrics (@Kubuxu)
- Fix an edge case bug in message selection, add many tests (@vyzo)
-
-# 0.5.3
-
-Yet another hotfix release. 
-A lesson for readers, having people who have been awake for 12+ hours review
-your hotfix PR is not a good idea. Find someone who has enough slept recently
-enough to give you good code review, otherwise you'll end up quickly bumping
-versions again.
-
- Fixed a bug in the mempool that was introduced in v0.5.2
-
-# 0.5.2 / 2020-08-24
-
-This is a hotfix release.
-
- Fix message selection to not include messages that are invalid for block
-  inclusion.
- Improve SelectMessage handling of the case where the message pools tipset
-  differs from our mining base.
-
-# 0.5.1 / 2020-08-24
-
-The Space Race release! 
-This release contains the genesis car file and bootstrap peers for the space
-race network. 
-
-Additionally, we included two small fixes to genesis creation:
- Randomize ticket value in genesis generation
- Correctly set t099 (burnt funds actor) to have valid account actor state
-
-# 0.5.0 / 2020-08-20
+## 0.5.0 / 2020-08-2020

 This version of Lotus will be used for the incentivized testnet Space Race competition,
 and can be considered mainnet-ready code. It includes some protocol
 changes, upgrades of core dependencies, and various bugfixes and UX/performance improvements.

-## Highlights
+# Highlights

 Among the highlights included in this release are:

@@ -57,7 +16,7 @@ and the packing of multiple deals into a single sector.
 - Renamed features: We renamed some of the binaries, environment variables, and default
 paths associated with a Lotus node.

-### Gas changes
+## Gas changes

 We made some significant changes to the mechanics of gas in this release.

@@ -114,7 +73,7 @@ data can be quickly served in a retrieval deal, since it will not need to be uns
 Miners can now pack multiple deals into a single sector, so long as all the deals
 fit into the sector capacity. This should increase the packing efficiency of miners.

-### Renamed features
+## Renamed features

 To improve the user experience, we updated several names to mainatin
 standard prefixing, and to better reflect the meaning of the features being referenced.
@@ -124,7 +83,7 @@ path for miner data is now `~/.lotusminer`, and the environment variable
 that sets the path for miner data is now `$LOTUS_MINER_PATH`. A full list of renamed
 features can be found [here](https://github.com/filecoin-project/lotus/issues/2304).

-## Changelog
+# Changelog

 #### Downstream upgrades
 - Upgrades markets to v0.5.6 (https://github.com/filecoin-project/lotus/pull/3058)
@@ -155,7 +114,7 @@ features can be found [here](https://github.com/filecoin-project/lotus/issues/23
 - Miners can toggle auto-acceptance of deals (https://github.com/filecoin-project/lotus/pull/1994)
 - Miners can maintain a blocklist of piece CIDs (https://github.com/filecoin-project/lotus/pull/2069)

-## Contributors
+# Contributors

 The following contributors had 10 or more commits go into this release.
 We are grateful for every contribution!
@@ -182,8 +141,8 @@ We are grateful for every contribution!
 | Stebalien          | 11      | +1204/-980    |
 | RobQuistNL         | 10      | +69/-74       |

-# 0.1.0 / 2019-12-11
+## 0.1.0 / 2019-12-11

 We are very excited to release **lotus** 0.1.0. This is our testnet release. To install lotus and join the testnet, please visit [lotu.sh](lotu.sh). Please file bug reports as [issues](https://github.com/filecoin-project/lotus/issues).

-A huge thank you to all contributors for this testnet release!
+A huge thank you to all contributors for this testnet release!
@@ -279,8 +279,5 @@ method-gen:

 gen: type-gen method-gen

-docsgen:
-	go run ./api/docgen > documentation/en/api-methods.md
-
 print-%:
 	@echo $*=$($*)
@@ -120,16 +120,15 @@ type SectorLog struct {
 }

 type SectorInfo struct {
-	SectorID  abi.SectorNumber
-	State     SectorState
-	CommD     *cid.Cid
-	CommR     *cid.Cid
-	Proof     []byte
-	Deals     []abi.DealID
-	Ticket    SealTicket
-	Seed      SealSeed
-	Retries   uint64
-	ToUpgrade bool
+	SectorID abi.SectorNumber
+	State    SectorState
+	CommD    *cid.Cid
+	CommR    *cid.Cid
+	Proof    []byte
+	Deals    []abi.DealID
+	Ticket   SealTicket
+	Seed     SealSeed
+	Retries  uint64

 	LastErr string

@@ -6,8 +6,8 @@ import (
 	"fmt"
 	"io"

-	abi "github.com/filecoin-project/specs-actors/actors/abi"
-	paych "github.com/filecoin-project/specs-actors/actors/builtin/paych"
+	"github.com/filecoin-project/specs-actors/actors/abi"
+	"github.com/filecoin-project/specs-actors/actors/builtin/paych"
 	cbg "github.com/whyrusleeping/cbor-gen"
 	xerrors "golang.org/x/xerrors"
 )
@@ -1,7 +1,6 @@
 package client

 import (
-	"context"
 	"net/http"
 	"net/url"
 	"path"
@@ -15,9 +14,9 @@ import (
 )

 // NewCommonRPC creates a new http jsonrpc client.
-func NewCommonRPC(ctx context.Context, addr string, requestHeader http.Header) (api.Common, jsonrpc.ClientCloser, error) {
+func NewCommonRPC(addr string, requestHeader http.Header) (api.Common, jsonrpc.ClientCloser, error) {
 	var res apistruct.CommonStruct
-	closer, err := jsonrpc.NewMergeClient(ctx, addr, "Filecoin",
+	closer, err := jsonrpc.NewMergeClient(addr, "Filecoin",
 		[]interface{}{
 			&res.Internal,
 		},
@@ -28,9 +27,9 @@ func NewCommonRPC(ctx context.Context, addr string, requestHeader http.Header) (
 }

 // NewFullNodeRPC creates a new http jsonrpc client.
-func NewFullNodeRPC(ctx context.Context, addr string, requestHeader http.Header) (api.FullNode, jsonrpc.ClientCloser, error) {
+func NewFullNodeRPC(addr string, requestHeader http.Header) (api.FullNode, jsonrpc.ClientCloser, error) {
 	var res apistruct.FullNodeStruct
-	closer, err := jsonrpc.NewMergeClient(ctx, addr, "Filecoin",
+	closer, err := jsonrpc.NewMergeClient(addr, "Filecoin",
 		[]interface{}{
 			&res.CommonStruct.Internal,
 			&res.Internal,
@@ -40,9 +39,9 @@ func NewFullNodeRPC(ctx context.Context, addr string, requestHeader http.Header)
 }

 // NewStorageMinerRPC creates a new http jsonrpc client for miner
-func NewStorageMinerRPC(ctx context.Context, addr string, requestHeader http.Header, opts ...jsonrpc.Option) (api.StorageMiner, jsonrpc.ClientCloser, error) {
+func NewStorageMinerRPC(addr string, requestHeader http.Header, opts ...jsonrpc.Option) (api.StorageMiner, jsonrpc.ClientCloser, error) {
 	var res apistruct.StorageMinerStruct
-	closer, err := jsonrpc.NewMergeClient(ctx, addr, "Filecoin",
+	closer, err := jsonrpc.NewMergeClient(addr, "Filecoin",
 		[]interface{}{
 			&res.CommonStruct.Internal,
 			&res.Internal,
@@ -54,7 +53,7 @@ func NewStorageMinerRPC(ctx context.Context, addr string, requestHeader http.Hea
 	return &res, closer, err
 }

-func NewWorkerRPC(ctx context.Context, addr string, requestHeader http.Header) (api.WorkerAPI, jsonrpc.ClientCloser, error) {
+func NewWorkerRPC(addr string, requestHeader http.Header) (api.WorkerAPI, jsonrpc.ClientCloser, error) {
 	u, err := url.Parse(addr)
 	if err != nil {
 		return nil, nil, err
@@ -70,7 +69,7 @@ func NewWorkerRPC(ctx context.Context, addr string, requestHeader http.Header) (
 	u.Path = path.Join(u.Path, "../streams/v0/push")

 	var res apistruct.WorkerStruct
-	closer, err := jsonrpc.NewMergeClient(ctx, addr, "Filecoin",
+	closer, err := jsonrpc.NewMergeClient(addr, "Filecoin",
 		[]interface{}{
 			&res.Internal,
 		},
@@ -12,29 +12,22 @@ import (
 	"time"
 	"unicode"

-	"github.com/ipfs/go-cid"
-	"github.com/ipfs/go-filestore"
-	"github.com/libp2p/go-libp2p-core/network"
-	"github.com/libp2p/go-libp2p-core/peer"
-	pubsub "github.com/libp2p/go-libp2p-pubsub"
-	"github.com/multiformats/go-multiaddr"
-
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-bitfield"
-	datatransfer "github.com/filecoin-project/go-data-transfer"
-	"github.com/filecoin-project/go-fil-markets/retrievalmarket"
 	"github.com/filecoin-project/go-jsonrpc/auth"
-	"github.com/filecoin-project/go-multistore"
-
-	"github.com/filecoin-project/specs-actors/actors/abi"
-	"github.com/filecoin-project/specs-actors/actors/crypto"
-	"github.com/filecoin-project/specs-actors/actors/runtime/exitcode"
-
 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/api/apistruct"
 	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/node/modules/dtypes"
+	"github.com/filecoin-project/specs-actors/actors/abi"
+	"github.com/filecoin-project/specs-actors/actors/crypto"
+	"github.com/filecoin-project/specs-actors/actors/runtime/exitcode"
+	"github.com/ipfs/go-cid"
+	"github.com/ipfs/go-filestore"
+	"github.com/libp2p/go-libp2p-core/network"
+	peer "github.com/libp2p/go-libp2p-peer"
+	"github.com/multiformats/go-multiaddr"
 )

 var ExampleValues = map[reflect.Type]interface{}{
@@ -73,12 +66,11 @@ func init() {

 	ExampleValues[reflect.TypeOf(addr)] = addr

-	pid, err := peer.Decode("12D3KooWGzxzKZYveHXtpG6AsrUJBcWxHBFS2HsEoGTxrMLvKXtf")
+	pid, err := peer.IDB58Decode("12D3KooWGzxzKZYveHXtpG6AsrUJBcWxHBFS2HsEoGTxrMLvKXtf")
 	if err != nil {
 		panic(err)
 	}
 	addExample(pid)
-	addExample(&pid)

 	addExample(bitfield.NewFromSet([]uint64{5}))
 	addExample(abi.RegisteredSealProof_StackedDrg32GiBV1)
@@ -106,12 +98,6 @@ func init() {
 	addExample(build.APIVersion)
 	addExample(api.PCHInbound)
 	addExample(time.Minute)
-	addExample(datatransfer.TransferID(3))
-	addExample(datatransfer.Ongoing)
-	addExample(multistore.StoreID(50))
-	addExample(retrievalmarket.ClientEventDealAccepted)
-	addExample(retrievalmarket.DealStatusNew)
-	addExample(network.ReachabilityPublic)
 	addExample(&types.ExecutionTrace{
 		Msg:    exampleValue(reflect.TypeOf(&types.Message{}), nil).(*types.Message),
 		MsgRct: exampleValue(reflect.TypeOf(&types.MessageReceipt{}), nil).(*types.MessageReceipt),
@@ -125,14 +111,6 @@ func init() {
 	addExample(map[string]api.MarketBalance{
 		"t026363": exampleValue(reflect.TypeOf(api.MarketBalance{}), nil).(api.MarketBalance),
 	})
-	addExample(map[string]*pubsub.TopicScoreSnapshot{
-		"/blocks": {
-			TimeInMesh:               time.Minute,
-			FirstMessageDeliveries:   122,
-			MeshMessageDeliveries:    1234,
-			InvalidMessageDeliveries: 3,
-		},
-	})

 	maddr, err := multiaddr.NewMultiaddr("/ip4/52.36.61.156/tcp/1347/p2p/12D3KooWFETiESTf1v4PGUvtnxMAcEFMzLZbJGg4tjWfGEimYior")
 	if err != nil {
@@ -141,7 +141,7 @@ func makeDeal(t *testing.T, ctx context.Context, rseed int, client *impl.FullNod
 	info, err := client.ClientGetDealInfo(ctx, *deal)
 	require.NoError(t, err)

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

 func TestFastRetrievalDealFlow(t *testing.T, b APIBuilder, blocktime time.Duration) {
@@ -193,7 +193,7 @@ func TestFastRetrievalDealFlow(t *testing.T, b APIBuilder, blocktime time.Durati
 	info, err := client.ClientGetDealInfo(ctx, *deal)
 	require.NoError(t, err)

-	testRetrieval(t, ctx, client, fcid, &info.PieceCID, false, data)
+	testRetrieval(t, ctx, err, client, fcid, &info.PieceCID, false, data)
 	atomic.AddInt64(&mine, -1)
 	fmt.Println("shutting down mining")
 	<-done
@@ -267,7 +267,7 @@ func TestSenondDealRetrieval(t *testing.T, b APIBuilder, blocktime time.Duration
 		rf, _ := miner.SectorsRefs(ctx)
 		fmt.Printf("refs: %+v\n", rf)

-		testRetrieval(t, ctx, client, fcid2, &info.PieceCID, false, data2)
+		testRetrieval(t, ctx, err, client, fcid2, &info.PieceCID, false, data2)
 	}

 	atomic.AddInt64(&mine, -1)
@@ -373,7 +373,7 @@ func startSealingWaiting(t *testing.T, ctx context.Context, miner TestStorageNod
 	}
 }

-func testRetrieval(t *testing.T, ctx context.Context, client *impl.FullNodeAPI, fcid cid.Cid, piece *cid.Cid, carExport bool, data []byte) {
+func testRetrieval(t *testing.T, ctx context.Context, err error, client *impl.FullNodeAPI, fcid cid.Cid, piece *cid.Cid, carExport bool, data []byte) {
 	offers, err := client.ClientFindData(ctx, fcid, piece)
 	if err != nil {
 		t.Fatal(err)
@@ -20,7 +20,6 @@ import (
 	"github.com/filecoin-project/lotus/node/impl"
 )

-//nolint:deadcode,varcheck
 var log = logging.Logger("apitest")

 func (ts *testSuite) testMining(t *testing.T) {
@@ -153,9 +153,6 @@ func TestPaymentChannels(t *testing.T, b APIBuilder, blocktime time.Duration) {
 	}, int(build.MessageConfidence)+1, build.SealRandomnessLookbackLimit, func(oldTs, newTs *types.TipSet) (bool, events.StateChange, error) {
 		return preds.OnPaymentChannelActorChanged(channel, preds.OnToSendAmountChanges())(ctx, oldTs.Key(), newTs.Key())
 	})
-	if err != nil {
-		t.Fatal(err)
-	}

 	select {
 	case <-finished:
@@ -24,14 +24,9 @@ import (
 	"github.com/filecoin-project/lotus/node/impl"
 )

-func init() {
-	err := os.Setenv("BELLMAN_NO_GPU", "1")
-	if err != nil {
-		panic(fmt.Sprintf("failed to set BELLMAN_NO_GPU env variable: %s", err))
-	}
-}
-
 func TestPledgeSector(t *testing.T, b APIBuilder, blocktime time.Duration, nSectors int) {
+	os.Setenv("BELLMAN_NO_GPU", "1")
+
 	ctx := context.Background()
 	n, sn := b(t, 1, OneMiner)
 	client := n[0].FullNode.(*impl.FullNodeAPI)
@@ -115,6 +110,8 @@ func pledgeSectors(t *testing.T, ctx context.Context, miner TestStorageNode, n,
 }

 func TestWindowPost(t *testing.T, b APIBuilder, blocktime time.Duration, nSectors int) {
+	os.Setenv("BELLMAN_NO_GPU", "1")
+
 	ctx := context.Background()
 	n, sn := b(t, 1, OneMiner)
 	client := n[0].FullNode.(*impl.FullNodeAPI)
@@ -1,4 +1,6 @@
-/dns4/bootstrap-0.nerpa.interplanetary.dev/tcp/1347/p2p/12D3KooWGabqJyhJEmqy4oKb5JD5KGXvuFZd5BuDUFc6xtroYAkN
-/dns4/bootstrap-1.nerpa.interplanetary.dev/tcp/1347/p2p/12D3KooWHdaQaxghNaDLhgHAvj2PbZf2CGXBCGLx56rsByLPZRAn
-/dns4/bootstrap-2.nerpa.interplanetary.dev/tcp/1347/p2p/12D3KooWE3mRxmtXzhL4u4b1XbXjR3zQAvGkdwiXf2BVCF9ZN9sR
-/dns4/bootstrap-3.nerpa.interplanetary.dev/tcp/1347/p2p/12D3KooWKmPjBYhWjKRv8rCQR7yhQYFifYg4axXbFQud1htPiAgh
+/dns4/bootstrap-0.testnet.fildev.network/tcp/1347/p2p/12D3KooWJTUBUjtzWJGWU1XSiY21CwmHaCNLNYn2E7jqHEHyZaP7
+/dns4/bootstrap-1.testnet.fildev.network/tcp/1347/p2p/12D3KooW9yeKXha4hdrJKq74zEo99T8DhriQdWNoojWnnQbsgB3v
+/dns4/bootstrap-2.testnet.fildev.network/tcp/1347/p2p/12D3KooWCrx8yVG9U9Kf7w8KLN3Edkj5ZKDhgCaeMqQbcQUoB6CT
+/dns4/bootstrap-4.testnet.fildev.network/tcp/1347/p2p/12D3KooWPkL9LrKRQgHtq7kn9ecNhGU9QaziG8R5tX8v9v7t3h34
+/dns4/bootstrap-3.testnet.fildev.network/tcp/1347/p2p/12D3KooWKYSsbpgZ3HAjax5M1BXCwXLa6gVkUARciz7uN3FNtr7T
+/dns4/bootstrap-5.testnet.fildev.network/tcp/1347/p2p/12D3KooWQYzqnLASJAabyMpPb1GcWZvNSe7JDcRuhdRqonFoiK9W
@@ -2,7 +2,7 @@ package build

 import "github.com/filecoin-project/lotus/node/modules/dtypes"

-var DrandNetwork = DrandMainnet
+var DrandNetwork = DrandIncentinet

 func DrandConfig() dtypes.DrandConfig {
 	return DrandConfigs[DrandNetwork]
@@ -13,11 +13,10 @@ import (
 )

 func init() {
-	power.ConsensusMinerMinPower = big.NewInt(4 << 40)
+	power.ConsensusMinerMinPower = big.NewInt(10 << 40)
 	miner.SupportedProofTypes = map[abi.RegisteredSealProof]struct{}{
-		abi.RegisteredSealProof_StackedDrg512MiBV1: {},
-		abi.RegisteredSealProof_StackedDrg32GiBV1:  {},
-		abi.RegisteredSealProof_StackedDrg64GiBV1:  {},
+		abi.RegisteredSealProof_StackedDrg32GiBV1: {},
+		abi.RegisteredSealProof_StackedDrg64GiBV1: {},
 	}
 }

@@ -25,7 +25,7 @@ func buildType() string {
 }

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

 func UserVersion() string {
 	return BuildVersion + buildType() + CurrentCommit
@@ -53,7 +53,7 @@ func (ve Version) EqMajorMinor(v2 Version) bool {
 }

 // APIVersion is a semver version of the rpc api exposed
-var APIVersion Version = newVer(0, 12, 0)
+var APIVersion Version = newVer(0, 11, 0)

 //nolint:varcheck,deadcode
 const (
@@ -7,8 +7,8 @@ import (

 	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain/types"
-	lru "github.com/hashicorp/golang-lru"
-	"github.com/libp2p/go-libp2p-core/peer"
+	"github.com/hashicorp/golang-lru"
+	peer "github.com/libp2p/go-libp2p-core/peer"
 )

 type blockReceiptTracker struct {
@@ -6,8 +6,8 @@ import (
 	"fmt"
 	"io"

-	types "github.com/filecoin-project/lotus/chain/types"
-	cid "github.com/ipfs/go-cid"
+	"github.com/filecoin-project/lotus/chain/types"
+	"github.com/ipfs/go-cid"
 	cbg "github.com/whyrusleeping/cbor-gen"
 	xerrors "golang.org/x/xerrors"
 )
@@ -172,7 +172,7 @@ func (client *BlockSync) processResponse(
 			resLength, req.Length)
 	}
 	if resLength < int(req.Length) && res.Status != Partial {
-		return nil, xerrors.Errorf("got less than requested without a proper status: %d", res.Status)
+		return nil, xerrors.Errorf("got less than requested without a proper status: %s", res.Status)
 	}

 	validRes := &validatedResponse{}
@@ -205,7 +205,7 @@ func (client *BlockSync) processResponse(
 		validRes.messages = make([]*CompactedMessages, resLength)
 		for i := 0; i < resLength; i++ {
 			if res.Chain[i].Messages == nil {
-				return nil, xerrors.Errorf("no messages included for tipset at height (head - %d)", i)
+				return nil, xerrors.Errorf("no messages included for tipset at height (head - %d): %w", i)
 			}
 			validRes.messages[i] = res.Chain[i].Messages
 		}
@@ -308,12 +308,6 @@ func (client *BlockSync) GetChainMessages(
 	length uint64,
 ) ([]*CompactedMessages, error) {
 	ctx, span := trace.StartSpan(ctx, "GetChainMessages")
-	if span.IsRecordingEvents() {
-		span.AddAttributes(
-			trace.StringAttribute("tipset", fmt.Sprint(head.Cids())),
-			trace.Int64Attribute("count", int64(length)),
-		)
-	}
 	defer span.End()

 	req := &Request{
@@ -1,10 +1,9 @@
 package blocksync

 import (
-	"time"
-
 	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain/store"
+	"time"

 	"github.com/ipfs/go-cid"
 	logging "github.com/ipfs/go-log"
@@ -2,7 +2,6 @@ package state

 import (
 	"bytes"
-
 	"github.com/filecoin-project/specs-actors/actors/util/adt"
 	typegen "github.com/whyrusleeping/cbor-gen"
 )
@@ -3,7 +3,6 @@ package state
 import (
 	"bytes"
 	"context"
-
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/specs-actors/actors/abi"
 	"github.com/filecoin-project/specs-actors/actors/abi/big"
@@ -114,10 +114,10 @@ func TestMarketPredicates(t *testing.T) {
 	}

 	oldBalances := map[address.Address]balance{
-		tutils.NewIDAddr(t, 1): {abi.NewTokenAmount(1000), abi.NewTokenAmount(1000)},
-		tutils.NewIDAddr(t, 2): {abi.NewTokenAmount(2000), abi.NewTokenAmount(500)},
-		tutils.NewIDAddr(t, 3): {abi.NewTokenAmount(3000), abi.NewTokenAmount(2000)},
-		tutils.NewIDAddr(t, 5): {abi.NewTokenAmount(3000), abi.NewTokenAmount(1000)},
+		tutils.NewIDAddr(t, 1): balance{abi.NewTokenAmount(1000), abi.NewTokenAmount(1000)},
+		tutils.NewIDAddr(t, 2): balance{abi.NewTokenAmount(2000), abi.NewTokenAmount(500)},
+		tutils.NewIDAddr(t, 3): balance{abi.NewTokenAmount(3000), abi.NewTokenAmount(2000)},
+		tutils.NewIDAddr(t, 5): balance{abi.NewTokenAmount(3000), abi.NewTokenAmount(1000)},
 	}

 	oldStateC := createMarketState(ctx, t, store, oldDeals, oldProps, oldBalances)
@@ -162,10 +162,10 @@ func TestMarketPredicates(t *testing.T) {
 		// NB: DealProposals cannot be modified, so don't test that case.
 	}
 	newBalances := map[address.Address]balance{
-		tutils.NewIDAddr(t, 1): {abi.NewTokenAmount(3000), abi.NewTokenAmount(0)},
-		tutils.NewIDAddr(t, 2): {abi.NewTokenAmount(2000), abi.NewTokenAmount(500)},
-		tutils.NewIDAddr(t, 4): {abi.NewTokenAmount(5000), abi.NewTokenAmount(0)},
-		tutils.NewIDAddr(t, 5): {abi.NewTokenAmount(1000), abi.NewTokenAmount(3000)},
+		tutils.NewIDAddr(t, 1): balance{abi.NewTokenAmount(3000), abi.NewTokenAmount(0)},
+		tutils.NewIDAddr(t, 2): balance{abi.NewTokenAmount(2000), abi.NewTokenAmount(500)},
+		tutils.NewIDAddr(t, 4): balance{abi.NewTokenAmount(5000), abi.NewTokenAmount(0)},
+		tutils.NewIDAddr(t, 5): balance{abi.NewTokenAmount(1000), abi.NewTokenAmount(3000)},
 	}

 	newStateC := createMarketState(ctx, t, store, newDeals, newProps, newBalances)
@@ -505,7 +505,6 @@ func createBalanceTable(ctx context.Context, t *testing.T, store adt.Store, bala
 	lockedMapRootCid, err := lockedMapRoot.Root()
 	require.NoError(t, err)
 	lockedRoot, err := adt.AsBalanceTable(store, lockedMapRootCid)
-	require.NoError(t, err)

 	for addr, balance := range balances {
 		err := escrowRoot.Add(addr, big.Add(balance.available, balance.locked))
@@ -543,7 +542,6 @@ func createEmptyMinerState(ctx context.Context, t *testing.T, store adt.Store, o

 	emptyVestingFunds := miner.ConstructVestingFunds()
 	emptyVestingFundsCid, err := store.Put(store.Context(), emptyVestingFunds)
-	require.NoError(t, err)

 	emptyDeadlines := miner.ConstructDeadlines(emptyDeadline)
 	emptyDeadlinesCid, err := store.Put(store.Context(), emptyDeadlines)
@@ -41,11 +41,10 @@ import (
 	"github.com/filecoin-project/lotus/node/repo"
 )

-const msgsPerBlock = 20
-
-//nolint:deadcode,varcheck
 var log = logging.Logger("gen")

+const msgsPerBlock = 20
+
 var ValidWpostForTesting = []abi.PoStProof{{
 	ProofBytes: []byte("valid proof"),
 }}
@@ -606,7 +605,7 @@ func IsRoundWinner(ctx context.Context, ts *types.TipSet, round abi.ChainEpoch,

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

 	electionRand, err := store.DrawRandomness(brand.Data, crypto.DomainSeparationTag_ElectionProofProduction, round, buf.Bytes())
@@ -129,9 +129,6 @@ func SetupStorageMiners(ctx context.Context, cs *store.ChainStore, sroot cid.Cid

 				return nil
 			})
-			if err != nil {
-				return cid.Undef, xerrors.Errorf("mutating state: %w", err)
-			}
 		}

 		// Add market funds
@@ -220,12 +217,9 @@ func SetupStorageMiners(ctx context.Context, cs *store.ChainStore, sroot cid.Cid
 		}

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

 	for i, m := range miners {
@@ -250,7 +244,7 @@ func SetupStorageMiners(ctx context.Context, cs *store.ChainStore, sroot cid.Cid

 				// we've added fake power for this sector above, remove it now
 				err = vm.MutateState(ctx, builtin.StoragePowerActorAddr, func(cst cbor.IpldStore, st *power.State) error {
-					st.TotalQualityAdjPower = types.BigSub(st.TotalQualityAdjPower, sectorWeight) //nolint:scopelint
+					st.TotalQualityAdjPower = types.BigSub(st.TotalQualityAdjPower, sectorWeight)
 					st.TotalRawBytePower = types.BigSub(st.TotalRawBytePower, types.NewInt(uint64(m.SectorSize)))
 					return nil
 				})
@@ -330,13 +324,13 @@ type fakeRand struct{}

 func (fr *fakeRand) GetChainRandomness(ctx context.Context, personalization crypto.DomainSeparationTag, randEpoch abi.ChainEpoch, entropy []byte) ([]byte, error) {
 	out := make([]byte, 32)
-	_, _ = rand.New(rand.NewSource(int64(randEpoch * 1000))).Read(out) //nolint
+	_, _ = rand.New(rand.NewSource(int64(randEpoch * 1000))).Read(out)
 	return out, nil
 }

 func (fr *fakeRand) GetBeaconRandomness(ctx context.Context, personalization crypto.DomainSeparationTag, randEpoch abi.ChainEpoch, entropy []byte) ([]byte, error) {
 	out := make([]byte, 32)
-	_, _ = rand.New(rand.NewSource(int64(randEpoch))).Read(out) //nolint
+	_, _ = rand.New(rand.NewSource(int64(randEpoch))).Read(out)
 	return out, nil
 }

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

+func doExec(ctx context.Context, vm *vm.VM, to, from address.Address, method abi.MethodNum, params []byte) ([]byte, error) {
+	return doExecValue(ctx, vm, to, from, types.NewInt(0), method, params)
+}
+
 func doExecValue(ctx context.Context, vm *vm.VM, to, from address.Address, value types.BigInt, method abi.MethodNum, params []byte) ([]byte, error) {
 	act, err := vm.StateTree().GetActor(from)
 	if err != nil {
@@ -147,7 +147,6 @@ func TestAddFunds(t *testing.T) {
 	}

 	for testCase, data := range testCases {
-		//nolint:scopelint
 		t.Run(testCase, func(t *testing.T) {
 			ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
 			defer cancel()
@@ -56,7 +56,7 @@ func binomialCoefficient(n, k float64) float64 {
 	for d := 1.0; d <= k; d++ {
 		r *= n
 		r /= d
-		n--
+		n -= 1
 	}
 	return r
 }
@@ -27,7 +27,6 @@ import (

 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/build"
-	"github.com/filecoin-project/lotus/chain/store"
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/chain/vm"
 	"github.com/filecoin-project/lotus/lib/sigs"
@@ -38,7 +37,7 @@ import (

 var log = logging.Logger("messagepool")

-var futureDebug = false
+const futureDebug = false

 var rbfNumBig = types.NewInt(uint64((ReplaceByFeeRatioDefault - 1) * RbfDenom))
 var rbfDenomBig = types.NewInt(RbfDenom)
@@ -190,7 +189,12 @@ func New(api Provider, ds dtypes.MetadataDS, netName dtypes.NetworkName) (*Messa
 	// enable initial prunes
 	mp.pruneCooldown <- struct{}{}

-	// load the current tipset and subscribe to head changes _before_ loading local messages
+	if err := mp.loadLocal(); err != nil {
+		log.Errorf("loading local messages: %+v", err)
+	}
+
+	go mp.runLoop()
+
 	mp.curTs = api.SubscribeHeadChanges(func(rev, app []*types.TipSet) error {
 		err := mp.HeadChange(rev, app)
 		if err != nil {
@@ -199,12 +203,6 @@ func New(api Provider, ds dtypes.MetadataDS, netName dtypes.NetworkName) (*Messa
 		return err
 	})

-	if err := mp.loadLocal(); err != nil {
-		log.Errorf("loading local messages: %+v", err)
-	}
-
-	go mp.runLoop()
-
 	return mp, nil
 }

@@ -319,11 +317,6 @@ func (mp *MessagePool) checkMessage(m *types.SignedMessage) error {
 		return xerrors.Errorf("mpool message too large (%dB): %w", m.Size(), ErrMessageTooBig)
 	}

-	// Perform syntaxtic validation, minGas=0 as we check if correctly in select messages
-	if err := m.Message.ValidForBlockInclusion(0); err != nil {
-		return xerrors.Errorf("message not valid for block inclusion: %w", err)
-	}
-
 	if m.Message.To == address.Undef {
 		return ErrInvalidToAddr
 	}
@@ -506,16 +499,42 @@ func (mp *MessagePool) getNonceLocked(addr address.Address, curTs *types.TipSet)
 }

 func (mp *MessagePool) getStateNonce(addr address.Address, curTs *types.TipSet) (uint64, error) {
-	act, err := mp.api.GetActorAfter(addr, curTs)
+	// TODO: this method probably should be cached
+
+	act, err := mp.api.StateGetActor(addr, curTs)
 	if err != nil {
 		return 0, err
 	}

-	return act.Nonce, nil
+	baseNonce := act.Nonce
+
+	// TODO: the correct thing to do here is probably to set curTs to chain.head
+	// but since we have an accurate view of the world until a head change occurs,
+	// this should be fine
+	if curTs == nil {
+		return baseNonce, nil
+	}
+
+	msgs, err := mp.api.MessagesForTipset(curTs)
+	if err != nil {
+		return 0, xerrors.Errorf("failed to check messages for tipset: %w", err)
+	}
+
+	for _, m := range msgs {
+		msg := m.VMMessage()
+		if msg.From == addr {
+			if msg.Nonce != baseNonce {
+				return 0, xerrors.Errorf("tipset %s has bad nonce ordering (%d != %d)", curTs.Cids(), msg.Nonce, baseNonce)
+			}
+			baseNonce++
+		}
+	}
+
+	return baseNonce, nil
 }

 func (mp *MessagePool) getStateBalance(addr address.Address, ts *types.TipSet) (types.BigInt, error) {
-	act, err := mp.api.GetActorAfter(addr, ts)
+	act, err := mp.api.StateGetActor(addr, ts)
 	if err != nil {
 		return types.EmptyInt, err
 	}
@@ -651,10 +670,6 @@ func (mp *MessagePool) Pending() ([]*types.SignedMessage, *types.TipSet) {
 	mp.lk.Lock()
 	defer mp.lk.Unlock()

-	return mp.allPending()
-}
-
-func (mp *MessagePool) allPending() ([]*types.SignedMessage, *types.TipSet) {
 	out := make([]*types.SignedMessage, 0)
 	for a := range mp.pending {
 		out = append(out, mp.pendingFor(a)...)
@@ -662,7 +677,6 @@ func (mp *MessagePool) allPending() ([]*types.SignedMessage, *types.TipSet) {

 	return out, mp.curTs
 }
-
 func (mp *MessagePool) PendingFor(a address.Address) ([]*types.SignedMessage, *types.TipSet) {
 	mp.curTsLk.Lock()
 	defer mp.curTsLk.Unlock()
@@ -795,9 +809,7 @@ func (mp *MessagePool) HeadChange(revert []*types.TipSet, apply []*types.TipSet)
 	}

 	if len(revert) > 0 && futureDebug {
-		mp.lk.Lock()
-		msgs, ts := mp.allPending()
-		mp.lk.Unlock()
+		msgs, ts := mp.Pending()

 		buckets := map[address.Address]*statBucket{}

@@ -814,8 +826,7 @@ func (mp *MessagePool) HeadChange(revert []*types.TipSet, apply []*types.TipSet)
 		}

 		for a, bkt := range buckets {
-			// TODO that might not be correct with GatActorAfter but it is only debug code
-			act, err := mp.api.GetActorAfter(a, ts)
+			act, err := mp.api.StateGetActor(a, ts)
 			if err != nil {
 				log.Debugf("%s, err: %s\n", a, err)
 				continue
@@ -865,71 +876,6 @@ func (mp *MessagePool) HeadChange(revert []*types.TipSet, apply []*types.TipSet)
 	return merr
 }

-func (mp *MessagePool) runHeadChange(from *types.TipSet, to *types.TipSet, rmsgs map[address.Address]map[uint64]*types.SignedMessage) error {
-	add := func(m *types.SignedMessage) {
-		s, ok := rmsgs[m.Message.From]
-		if !ok {
-			s = make(map[uint64]*types.SignedMessage)
-			rmsgs[m.Message.From] = s
-		}
-		s[m.Message.Nonce] = m
-	}
-	rm := func(from address.Address, nonce uint64) {
-		s, ok := rmsgs[from]
-		if !ok {
-			return
-		}
-
-		if _, ok := s[nonce]; ok {
-			delete(s, nonce)
-			return
-		}
-
-	}
-
-	revert, apply, err := store.ReorgOps(mp.api.LoadTipSet, from, to)
-	if err != nil {
-		return xerrors.Errorf("failed to compute reorg ops for mpool pending messages: %w", err)
-	}
-
-	var merr error
-
-	for _, ts := range revert {
-		msgs, err := mp.MessagesForBlocks(ts.Blocks())
-		if err != nil {
-			log.Errorf("error retrieving messages for reverted block: %s", err)
-			merr = multierror.Append(merr, err)
-			continue
-		}
-
-		for _, msg := range msgs {
-			add(msg)
-		}
-	}
-
-	for _, ts := range apply {
-		for _, b := range ts.Blocks() {
-			bmsgs, smsgs, err := mp.api.MessagesForBlock(b)
-			if err != nil {
-				xerr := xerrors.Errorf("failed to get messages for apply block %s(height %d) (msgroot = %s): %w", b.Cid(), b.Height, b.Messages, err)
-				log.Errorf("error retrieving messages for block: %s", xerr)
-				merr = multierror.Append(merr, xerr)
-				continue
-			}
-
-			for _, msg := range smsgs {
-				rm(msg.Message.From, msg.Message.Nonce)
-			}
-
-			for _, msg := range bmsgs {
-				rm(msg.From, msg.Nonce)
-			}
-		}
-	}
-
-	return merr
-}
-
 type statBucket struct {
 	msgs map[uint64]*types.SignedMessage
 }
@@ -980,7 +926,6 @@ func (mp *MessagePool) Updates(ctx context.Context) (<-chan api.MpoolUpdate, err

 	go func() {
 		defer mp.changes.Unsub(sub, localUpdates)
-		defer close(out)

 		for {
 			select {
@@ -989,13 +934,9 @@ func (mp *MessagePool) Updates(ctx context.Context) (<-chan api.MpoolUpdate, err
 				case out <- u.(api.MpoolUpdate):
 				case <-ctx.Done():
 					return
-				case <-mp.closer:
-					return
 				}
 			case <-ctx.Done():
 				return
-			case <-mp.closer:
-				return
 			}
 		}
 	}()
@@ -3,11 +3,9 @@ package messagepool
 import (
 	"context"
 	"fmt"
-	"sort"
 	"testing"

 	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/lotus/chain/messagepool/gasguess"
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/chain/types/mock"
 	"github.com/filecoin-project/lotus/chain/wallet"
@@ -32,25 +30,14 @@ type testMpoolAPI struct {
 	balance    map[address.Address]types.BigInt

 	tipsets []*types.TipSet
-
-	published int
 }

 func newTestMpoolAPI() *testMpoolAPI {
-	tma := &testMpoolAPI{
+	return &testMpoolAPI{
 		bmsgs:      make(map[cid.Cid][]*types.SignedMessage),
 		statenonce: make(map[address.Address]uint64),
 		balance:    make(map[address.Address]types.BigInt),
 	}
-	genesis := mock.MkBlock(nil, 1, 1)
-	tma.tipsets = append(tma.tipsets, mock.TipSet(genesis))
-	return tma
-}
-
-func (tma *testMpoolAPI) nextBlock() *types.BlockHeader {
-	newBlk := mock.MkBlock(tma.tipsets[len(tma.tipsets)-1], 1, 1)
-	tma.tipsets = append(tma.tipsets, mock.TipSet(newBlk))
-	return newBlk
 }

 func (tma *testMpoolAPI) applyBlock(t *testing.T, b *types.BlockHeader) {
@@ -81,11 +68,12 @@ func (tma *testMpoolAPI) setBalanceRaw(addr address.Address, v types.BigInt) {

 func (tma *testMpoolAPI) setBlockMessages(h *types.BlockHeader, msgs ...*types.SignedMessage) {
 	tma.bmsgs[h.Cid()] = msgs
+	tma.tipsets = append(tma.tipsets, mock.TipSet(h))
 }

 func (tma *testMpoolAPI) SubscribeHeadChanges(cb func(rev, app []*types.TipSet) error) *types.TipSet {
 	tma.cb = cb
-	return tma.tipsets[0]
+	return nil
 }

 func (tma *testMpoolAPI) PutMessage(m types.ChainMsg) (cid.Cid, error) {
@@ -93,47 +81,18 @@ func (tma *testMpoolAPI) PutMessage(m types.ChainMsg) (cid.Cid, error) {
 }

 func (tma *testMpoolAPI) PubSubPublish(string, []byte) error {
-	tma.published++
 	return nil
 }

-func (tma *testMpoolAPI) GetActorAfter(addr address.Address, ts *types.TipSet) (*types.Actor, error) {
-	// regression check for load bug
-	if ts == nil {
-		panic("GetActorAfter called with nil tipset")
-	}
-
+func (tma *testMpoolAPI) StateGetActor(addr address.Address, ts *types.TipSet) (*types.Actor, error) {
 	balance, ok := tma.balance[addr]
 	if !ok {
 		balance = types.NewInt(1000e6)
 		tma.balance[addr] = balance
 	}
-
-	msgs := make([]*types.SignedMessage, 0)
-	for _, b := range ts.Blocks() {
-		for _, m := range tma.bmsgs[b.Cid()] {
-			if m.Message.From == addr {
-				msgs = append(msgs, m)
-			}
-		}
-	}
-
-	sort.Slice(msgs, func(i, j int) bool {
-		return msgs[i].Message.Nonce < msgs[j].Message.Nonce
-	})
-
-	nonce := tma.statenonce[addr]
-
-	for _, m := range msgs {
-		if m.Message.Nonce != nonce {
-			break
-		}
-		nonce++
-	}
-
 	return &types.Actor{
 		Code:    builtin.StorageMarketActorCodeID,
-		Nonce:   nonce,
+		Nonce:   tma.statenonce[addr],
 		Balance: balance,
 	}, nil
 }
@@ -219,7 +178,7 @@ func TestMessagePool(t *testing.T) {
 		t.Fatal(err)
 	}

-	a := tma.nextBlock()
+	a := mock.MkBlock(nil, 1, 1)

 	sender, err := w.GenerateKey(crypto.SigTypeBLS)
 	if err != nil {
@@ -245,56 +204,7 @@ func TestMessagePool(t *testing.T) {
 	assertNonce(t, mp, sender, 2)
 }

-func TestMessagePoolMessagesInEachBlock(t *testing.T) {
-	tma := newTestMpoolAPI()
-
-	w, err := wallet.NewWallet(wallet.NewMemKeyStore())
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	ds := datastore.NewMapDatastore()
-
-	mp, err := New(tma, ds, "mptest")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	a := tma.nextBlock()
-
-	sender, err := w.GenerateKey(crypto.SigTypeBLS)
-	if err != nil {
-		t.Fatal(err)
-	}
-	target := mock.Address(1001)
-
-	var msgs []*types.SignedMessage
-	for i := 0; i < 5; i++ {
-		m := mock.MkMessage(sender, target, uint64(i), w)
-		msgs = append(msgs, m)
-		mustAdd(t, mp, m)
-	}
-
-	tma.setStateNonce(sender, 0)
-
-	tma.setBlockMessages(a, msgs[0], msgs[1])
-	tma.applyBlock(t, a)
-	tsa := mock.TipSet(a)
-
-	_, _ = mp.Pending()
-
-	selm, _ := mp.SelectMessages(tsa, 1)
-	if len(selm) == 0 {
-		t.Fatal("should have returned the rest of the messages")
-	}
-}
-
 func TestRevertMessages(t *testing.T) {
-	futureDebug = true
-	defer func() {
-		futureDebug = false
-	}()
-
 	tma := newTestMpoolAPI()

 	w, err := wallet.NewWallet(wallet.NewMemKeyStore())
@@ -309,8 +219,8 @@ func TestRevertMessages(t *testing.T) {
 		t.Fatal(err)
 	}

-	a := tma.nextBlock()
-	b := tma.nextBlock()
+	a := mock.MkBlock(nil, 1, 1)
+	b := mock.MkBlock(mock.TipSet(a), 1, 1)

 	sender, err := w.GenerateKey(crypto.SigTypeBLS)
 	if err != nil {
@@ -344,7 +254,6 @@ func TestRevertMessages(t *testing.T) {
 	assertNonce(t, mp, sender, 4)

 	p, _ := mp.Pending()
-	fmt.Printf("%+v\n", p)
 	if len(p) != 3 {
 		t.Fatal("expected three messages in mempool")
 	}
@@ -366,7 +275,7 @@ func TestPruningSimple(t *testing.T) {
 		t.Fatal(err)
 	}

-	a := tma.nextBlock()
+	a := mock.MkBlock(nil, 1, 1)
 	tma.applyBlock(t, a)

 	sender, err := w.GenerateKey(crypto.SigTypeBLS)
@@ -399,246 +308,3 @@ func TestPruningSimple(t *testing.T) {
 		t.Fatal("expected only 5 messages in pool, got: ", len(msgs))
 	}
 }
-
-func TestLoadLocal(t *testing.T) {
-	tma := newTestMpoolAPI()
-	ds := datastore.NewMapDatastore()
-
-	mp, err := New(tma, ds, "mptest")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	// the actors
-	w1, err := wallet.NewWallet(wallet.NewMemKeyStore())
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	a1, err := w1.GenerateKey(crypto.SigTypeSecp256k1)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	w2, err := wallet.NewWallet(wallet.NewMemKeyStore())
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	a2, err := w2.GenerateKey(crypto.SigTypeSecp256k1)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	gasLimit := gasguess.Costs[gasguess.CostKey{Code: builtin.StorageMarketActorCodeID, M: 2}]
-	msgs := make(map[cid.Cid]struct{})
-	for i := 0; i < 10; i++ {
-		m := makeTestMessage(w1, a1, a2, uint64(i), gasLimit, uint64(i+1))
-		cid, err := mp.Push(m)
-		if err != nil {
-			t.Fatal(err)
-		}
-		msgs[cid] = struct{}{}
-	}
-	err = mp.Close()
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	mp, err = New(tma, ds, "mptest")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	pmsgs, _ := mp.Pending()
-	if len(msgs) != len(pmsgs) {
-		t.Fatalf("expected %d messages, but got %d", len(msgs), len(pmsgs))
-	}
-
-	for _, m := range pmsgs {
-		cid := m.Cid()
-		_, ok := msgs[cid]
-		if !ok {
-			t.Fatal("unknown message")
-		}
-
-		delete(msgs, cid)
-	}
-
-	if len(msgs) > 0 {
-		t.Fatalf("not all messages were laoded; missing %d messages", len(msgs))
-	}
-}
-
-func TestClearAll(t *testing.T) {
-	tma := newTestMpoolAPI()
-	ds := datastore.NewMapDatastore()
-
-	mp, err := New(tma, ds, "mptest")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	// the actors
-	w1, err := wallet.NewWallet(wallet.NewMemKeyStore())
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	a1, err := w1.GenerateKey(crypto.SigTypeSecp256k1)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	w2, err := wallet.NewWallet(wallet.NewMemKeyStore())
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	a2, err := w2.GenerateKey(crypto.SigTypeSecp256k1)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	gasLimit := gasguess.Costs[gasguess.CostKey{Code: builtin.StorageMarketActorCodeID, M: 2}]
-	for i := 0; i < 10; i++ {
-		m := makeTestMessage(w1, a1, a2, uint64(i), gasLimit, uint64(i+1))
-		_, err := mp.Push(m)
-		if err != nil {
-			t.Fatal(err)
-		}
-	}
-
-	for i := 0; i < 10; i++ {
-		m := makeTestMessage(w2, a2, a1, uint64(i), gasLimit, uint64(i+1))
-		mustAdd(t, mp, m)
-	}
-
-	mp.Clear(true)
-
-	pending, _ := mp.Pending()
-	if len(pending) > 0 {
-		t.Fatalf("cleared the mpool, but got %d pending messages", len(pending))
-	}
-}
-
-func TestClearNonLocal(t *testing.T) {
-	tma := newTestMpoolAPI()
-	ds := datastore.NewMapDatastore()
-
-	mp, err := New(tma, ds, "mptest")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	// the actors
-	w1, err := wallet.NewWallet(wallet.NewMemKeyStore())
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	a1, err := w1.GenerateKey(crypto.SigTypeSecp256k1)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	w2, err := wallet.NewWallet(wallet.NewMemKeyStore())
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	a2, err := w2.GenerateKey(crypto.SigTypeSecp256k1)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	gasLimit := gasguess.Costs[gasguess.CostKey{Code: builtin.StorageMarketActorCodeID, M: 2}]
-	for i := 0; i < 10; i++ {
-		m := makeTestMessage(w1, a1, a2, uint64(i), gasLimit, uint64(i+1))
-		_, err := mp.Push(m)
-		if err != nil {
-			t.Fatal(err)
-		}
-	}
-
-	for i := 0; i < 10; i++ {
-		m := makeTestMessage(w2, a2, a1, uint64(i), gasLimit, uint64(i+1))
-		mustAdd(t, mp, m)
-	}
-
-	mp.Clear(false)
-
-	pending, _ := mp.Pending()
-	if len(pending) != 10 {
-		t.Fatalf("expected 10 pending messages, but got %d instead", len(pending))
-	}
-
-	for _, m := range pending {
-		if m.Message.From != a1 {
-			t.Fatalf("expected message from %s but got one from %s instead", a1, m.Message.From)
-		}
-	}
-}
-
-func TestUpdates(t *testing.T) {
-	tma := newTestMpoolAPI()
-	ds := datastore.NewMapDatastore()
-
-	mp, err := New(tma, ds, "mptest")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	// the actors
-	w1, err := wallet.NewWallet(wallet.NewMemKeyStore())
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	a1, err := w1.GenerateKey(crypto.SigTypeSecp256k1)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	w2, err := wallet.NewWallet(wallet.NewMemKeyStore())
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	a2, err := w2.GenerateKey(crypto.SigTypeSecp256k1)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	ctx, cancel := context.WithCancel(context.TODO())
-	defer cancel()
-
-	ch, err := mp.Updates(ctx)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	gasLimit := gasguess.Costs[gasguess.CostKey{Code: builtin.StorageMarketActorCodeID, M: 2}]
-	for i := 0; i < 10; i++ {
-		m := makeTestMessage(w1, a1, a2, uint64(i), gasLimit, uint64(i+1))
-		_, err := mp.Push(m)
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		_, ok := <-ch
-		if !ok {
-			t.Fatal("expected update, but got a closed channel instead")
-		}
-	}
-
-	err = mp.Close()
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	_, ok := <-ch
-	if ok {
-		t.Fatal("expected closed channel, but got an update instead")
-	}
-}
@@ -16,7 +16,7 @@ type Provider interface {
 	SubscribeHeadChanges(func(rev, app []*types.TipSet) error) *types.TipSet
 	PutMessage(m types.ChainMsg) (cid.Cid, error)
 	PubSubPublish(string, []byte) error
-	GetActorAfter(address.Address, *types.TipSet) (*types.Actor, error)
+	StateGetActor(address.Address, *types.TipSet) (*types.Actor, error)
 	StateAccountKey(context.Context, address.Address, *types.TipSet) (address.Address, error)
 	MessagesForBlock(*types.BlockHeader) ([]*types.Message, []*types.SignedMessage, error)
 	MessagesForTipset(*types.TipSet) ([]types.ChainMsg, error)
@@ -43,17 +43,12 @@ func (mpp *mpoolProvider) PutMessage(m types.ChainMsg) (cid.Cid, error) {
 }

 func (mpp *mpoolProvider) PubSubPublish(k string, v []byte) error {
-	return mpp.ps.Publish(k, v) //nolint
+	return mpp.ps.Publish(k, v)
 }

-func (mpp *mpoolProvider) GetActorAfter(addr address.Address, ts *types.TipSet) (*types.Actor, error) {
+func (mpp *mpoolProvider) StateGetActor(addr address.Address, ts *types.TipSet) (*types.Actor, error) {
 	var act types.Actor
-	stcid, _, err := mpp.sm.TipSetState(context.TODO(), ts)
-	if err != nil {
-		return nil, xerrors.Errorf("computing tipset state for GetActor: %w", err)
-	}
-
-	return &act, mpp.sm.WithStateTree(stcid, mpp.sm.WithActor(addr, stmgr.GetActor(&act)))
+	return &act, mpp.sm.WithParentState(ts, mpp.sm.WithActor(addr, stmgr.GetActor(&act)))
 }

 func (mpp *mpoolProvider) StateAccountKey(ctx context.Context, addr address.Address, ts *types.TipSet) (address.Address, error) {
@@ -1,66 +0,0 @@
-package messagepool
-
-import (
-	"testing"
-	"time"
-
-	"github.com/filecoin-project/lotus/chain/messagepool/gasguess"
-	"github.com/filecoin-project/lotus/chain/wallet"
-	"github.com/filecoin-project/specs-actors/actors/builtin"
-	"github.com/filecoin-project/specs-actors/actors/crypto"
-	"github.com/ipfs/go-datastore"
-)
-
-func TestRepubMessages(t *testing.T) {
-	tma := newTestMpoolAPI()
-	ds := datastore.NewMapDatastore()
-
-	mp, err := New(tma, ds, "mptest")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	// the actors
-	w1, err := wallet.NewWallet(wallet.NewMemKeyStore())
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	a1, err := w1.GenerateKey(crypto.SigTypeSecp256k1)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	w2, err := wallet.NewWallet(wallet.NewMemKeyStore())
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	a2, err := w2.GenerateKey(crypto.SigTypeSecp256k1)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	gasLimit := gasguess.Costs[gasguess.CostKey{Code: builtin.StorageMarketActorCodeID, M: 2}]
-
-	tma.setBalance(a1, 1) // in FIL
-
-	for i := 0; i < 10; i++ {
-		m := makeTestMessage(w1, a1, a2, uint64(i), gasLimit, uint64(i+1))
-		_, err := mp.Push(m)
-		if err != nil {
-			t.Fatal(err)
-		}
-	}
-
-	if tma.published != 10 {
-		t.Fatalf("expected to have published 10 messages, but got %d instead", tma.published)
-	}
-
-	mp.repubTrigger <- struct{}{}
-	time.Sleep(100 * time.Millisecond)
-
-	if tma.published != 20 {
-		t.Fatalf("expected to have published 20 messages, but got %d instead", tma.published)
-	}
-}
@@ -14,6 +14,7 @@ import (
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/chain/vm"
 	abig "github.com/filecoin-project/specs-actors/actors/abi/big"
+	"github.com/ipfs/go-cid"
 )

 var bigBlockGasLimit = big.NewInt(build.BlockGasLimit)
@@ -527,6 +528,7 @@ func (mp *MessagePool) getPendingMessages(curTs, ts *types.TipSet) (map[address.
 	start := time.Now()

 	result := make(map[address.Address]map[uint64]*types.SignedMessage)
+	haveCids := make(map[cid.Cid]struct{})
 	defer func() {
 		if dt := time.Since(start); dt > time.Millisecond {
 			log.Infow("get pending messages done", "took", dt)
@@ -552,6 +554,10 @@ func (mp *MessagePool) getPendingMessages(curTs, ts *types.TipSet) (map[address.
 			}
 			result[a] = msetCopy

+			// mark the messages as seen
+			for _, m := range mset.msgs {
+				haveCids[m.Cid()] = struct{}{}
+			}
 		}
 	}

@@ -560,11 +566,72 @@ func (mp *MessagePool) getPendingMessages(curTs, ts *types.TipSet) (map[address.
 		return result, nil
 	}

-	if err := mp.runHeadChange(curTs, ts, result); err != nil {
-		return nil, xerrors.Errorf("failed to process difference between mpool head and given head: %w", err)
-	}
+	// nope, we need to sync the tipsets
+	for {
+		if curTs.Height() == ts.Height() {
+			if curTs.Equals(ts) {
+				return result, nil
+			}

-	return result, nil
+			// different blocks in tipsets -- we mark them as seen so that they are not included in
+			// in the message set we return, but *neither me (vyzo) nor why understand why*
+			// this code is also probably completely untested in production, so I am adding a big fat
+			// warning to revisit this case and sanity check this decision.
+			log.Warnf("mpool tipset has same height as target tipset but it's not equal; beware of dragons!")
+
+			have, err := mp.MessagesForBlocks(ts.Blocks())
+			if err != nil {
+				return nil, xerrors.Errorf("error retrieving messages for tipset: %w", err)
+			}
+
+			for _, m := range have {
+				haveCids[m.Cid()] = struct{}{}
+			}
+		}
+
+		msgs, err := mp.MessagesForBlocks(ts.Blocks())
+		if err != nil {
+			return nil, xerrors.Errorf("error retrieving messages for tipset: %w", err)
+		}
+
+		for _, m := range msgs {
+			if _, have := haveCids[m.Cid()]; have {
+				continue
+			}
+
+			haveCids[m.Cid()] = struct{}{}
+			mset, ok := result[m.Message.From]
+			if !ok {
+				mset = make(map[uint64]*types.SignedMessage)
+				result[m.Message.From] = mset
+			}
+
+			other, dupNonce := mset[m.Message.Nonce]
+			if dupNonce {
+				// duplicate nonce, selfishly keep the message with the highest GasPrice
+				// if the gas prices are the same, keep the one with the highest GasLimit
+				switch m.Message.GasPremium.Int.Cmp(other.Message.GasPremium.Int) {
+				case 0:
+					if m.Message.GasLimit > other.Message.GasLimit {
+						mset[m.Message.Nonce] = m
+					}
+				case 1:
+					mset[m.Message.Nonce] = m
+				}
+			} else {
+				mset[m.Message.Nonce] = m
+			}
+		}
+
+		if curTs.Height() >= ts.Height() {
+			return result, nil
+		}
+
+		ts, err = mp.api.LoadTipSet(ts.Parents())
+		if err != nil {
+			return nil, xerrors.Errorf("error loading parent tipset: %w", err)
+		}
+	}
 }

 func (mp *MessagePool) getGasReward(msg *types.SignedMessage, baseFee types.BigInt, ts *types.TipSet) *big.Int {
@@ -604,12 +671,7 @@ func (mp *MessagePool) createMessageChains(actor address.Address, mset map[uint6
 	//   cannot exceed the block limit; drop all messages that exceed the limit
 	// - the total gasReward cannot exceed the actor's balance; drop all messages that exceed
 	//   the balance
-	a, err := mp.api.GetActorAfter(actor, ts)
-	if err != nil {
-		log.Errorf("failed to load actor state, not building chain for %s: %w", actor, err)
-		return nil
-	}
-
+	a, _ := mp.api.StateGetActor(actor, ts)
 	curNonce := a.Nonce
 	balance := a.Balance.Int
 	gasLimit := int64(0)
@@ -79,7 +79,7 @@ func TestMessageChains(t *testing.T) {
 		t.Fatal(err)
 	}

-	block := tma.nextBlock()
+	block := mock.MkBlock(nil, 1, 1)
 	ts := mock.TipSet(block)

 	gasLimit := gasguess.Costs[gasguess.CostKey{Code: builtin.StorageMarketActorCodeID, M: 2}]
@@ -317,7 +317,7 @@ func TestMessageChainSkipping(t *testing.T) {
 		t.Fatal(err)
 	}

-	block := tma.nextBlock()
+	block := mock.MkBlock(nil, 1, 1)
 	ts := mock.TipSet(block)

 	gasLimit := gasguess.Costs[gasguess.CostKey{Code: builtin.StorageMarketActorCodeID, M: 2}]
@@ -387,7 +387,7 @@ func TestBasicMessageSelection(t *testing.T) {
 		t.Fatal(err)
 	}

-	block := tma.nextBlock()
+	block := mock.MkBlock(nil, 1, 1)
 	ts := mock.TipSet(block)
 	tma.applyBlock(t, block)

@@ -440,12 +440,12 @@ func TestBasicMessageSelection(t *testing.T) {
 	}

 	// now we make a block with all the messages and advance the chain
-	block2 := tma.nextBlock()
+	block2 := mock.MkBlock(ts, 2, 2)
 	tma.setBlockMessages(block2, msgs...)
 	tma.applyBlock(t, block2)

 	// we should have no pending messages in the mpool
-	pend, _ := mp.Pending()
+	pend, ts2 := mp.Pending()
 	if len(pend) != 0 {
 		t.Fatalf("expected no pending messages, but got %d", len(pend))
 	}
@@ -458,13 +458,13 @@ func TestBasicMessageSelection(t *testing.T) {
 		m = makeTestMessage(w2, a2, a1, uint64(i), gasLimit, uint64(i+1))
 		msgs = append(msgs, m)
 	}
-	block3 := tma.nextBlock()
+	block3 := mock.MkBlock(ts2, 3, 3)
 	tma.setBlockMessages(block3, msgs...)
 	ts3 := mock.TipSet(block3)

 	// now create another set of messages and add them to the mpool
 	for i := 20; i < 30; i++ {
-		m := makeTestMessage(w1, a1, a2, uint64(i), gasLimit, uint64(2*i+200))
+		m := makeTestMessage(w1, a1, a2, uint64(i), gasLimit, uint64(2*i+1))
 		mustAdd(t, mp, m)
 		m = makeTestMessage(w2, a2, a1, uint64(i), gasLimit, uint64(i+1))
 		mustAdd(t, mp, m)
@@ -480,12 +480,12 @@ func TestBasicMessageSelection(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	if len(msgs) != 20 {
-		t.Fatalf("expected 20 messages, got %d", len(msgs))
+	if len(msgs) != 40 {
+		t.Fatalf("expected 40 messages, got %d", len(msgs))
 	}

-	nextNonce = 20
-	for i := 0; i < 10; i++ {
+	nextNonce = 10
+	for i := 0; i < 20; i++ {
 		if msgs[i].Message.From != a1 {
 			t.Fatalf("expected message from actor a1")
 		}
@@ -495,8 +495,8 @@ func TestBasicMessageSelection(t *testing.T) {
 		nextNonce++
 	}

-	nextNonce = 20
-	for i := 10; i < 20; i++ {
+	nextNonce = 10
+	for i := 20; i < 40; i++ {
 		if msgs[i].Message.From != a2 {
 			t.Fatalf("expected message from actor a2")
 		}
@@ -531,7 +531,7 @@ func TestMessageSelectionTrimming(t *testing.T) {
 		t.Fatal(err)
 	}

-	block := tma.nextBlock()
+	block := mock.MkBlock(nil, 1, 1)
 	ts := mock.TipSet(block)
 	tma.applyBlock(t, block)

@@ -594,7 +594,7 @@ func TestPriorityMessageSelection(t *testing.T) {
 		t.Fatal(err)
 	}

-	block := tma.nextBlock()
+	block := mock.MkBlock(nil, 1, 1)
 	ts := mock.TipSet(block)
 	tma.applyBlock(t, block)

@@ -649,73 +649,6 @@ func TestPriorityMessageSelection(t *testing.T) {
 	}
 }

-func TestPriorityMessageSelection2(t *testing.T) {
-	mp, tma := makeTestMpool()
-
-	// the actors
-	w1, err := wallet.NewWallet(wallet.NewMemKeyStore())
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	a1, err := w1.GenerateKey(crypto.SigTypeSecp256k1)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	w2, err := wallet.NewWallet(wallet.NewMemKeyStore())
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	a2, err := w2.GenerateKey(crypto.SigTypeSecp256k1)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	block := tma.nextBlock()
-	ts := mock.TipSet(block)
-	tma.applyBlock(t, block)
-
-	gasLimit := gasguess.Costs[gasguess.CostKey{Code: builtin.StorageMarketActorCodeID, M: 2}]
-
-	tma.setBalance(a1, 1) // in FIL
-	tma.setBalance(a2, 1) // in FIL
-
-	mp.cfg.PriorityAddrs = []address.Address{a1}
-
-	nMessages := int(2 * build.BlockGasLimit / gasLimit)
-	for i := 0; i < nMessages; i++ {
-		bias := (nMessages - i) / 3
-		m := makeTestMessage(w1, a1, a2, uint64(i), gasLimit, uint64(1+i%3+bias))
-		mustAdd(t, mp, m)
-		m = makeTestMessage(w2, a2, a1, uint64(i), gasLimit, uint64(1+i%3+bias))
-		mustAdd(t, mp, m)
-	}
-
-	msgs, err := mp.SelectMessages(ts, 1.0)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	expectedMsgs := int(build.BlockGasLimit / gasLimit)
-	if len(msgs) != expectedMsgs {
-		t.Fatalf("expected %d messages but got %d", expectedMsgs, len(msgs))
-	}
-
-	// all messages must be from a1
-	nextNonce := uint64(0)
-	for _, m := range msgs {
-		if m.Message.From != a1 {
-			t.Fatal("expected messages from a1 before messages from a2")
-		}
-		if m.Message.Nonce != nextNonce {
-			t.Fatalf("expected nonce %d but got %d", nextNonce, m.Message.Nonce)
-		}
-		nextNonce++
-	}
-}
-
 func TestOptimalMessageSelection1(t *testing.T) {
 	// this test uses just a single actor sending messages with a low tq
 	// the chain depenent merging algorithm should pick messages from the actor
@@ -743,7 +676,7 @@ func TestOptimalMessageSelection1(t *testing.T) {
 		t.Fatal(err)
 	}

-	block := tma.nextBlock()
+	block := mock.MkBlock(nil, 1, 1)
 	ts := mock.TipSet(block)
 	tma.applyBlock(t, block)

@@ -810,7 +743,7 @@ func TestOptimalMessageSelection2(t *testing.T) {
 		t.Fatal(err)
 	}

-	block := tma.nextBlock()
+	block := mock.MkBlock(nil, 1, 1)
 	ts := mock.TipSet(block)
 	tma.applyBlock(t, block)

@@ -888,7 +821,7 @@ func TestOptimalMessageSelection3(t *testing.T) {
 		wallets = append(wallets, w)
 	}

-	block := tma.nextBlock()
+	block := mock.MkBlock(nil, 1, 1)
 	ts := mock.TipSet(block)
 	tma.applyBlock(t, block)

@@ -946,6 +879,7 @@ func testCompetitiveMessageSelection(t *testing.T, rng *rand.Rand, getPremium fu
 	// actors send with an randomly distributed premium dictated by the getPremium function.
 	// a number of miners select with varying ticket quality and we compare the
 	// capacity and rewards of greedy selection -vs- optimal selection
+
 	mp, tma := makeTestMpool()

 	nActors := 300
@@ -968,7 +902,7 @@ func testCompetitiveMessageSelection(t *testing.T, rng *rand.Rand, getPremium fu
 		wallets = append(wallets, w)
 	}

-	block := tma.nextBlock()
+	block := mock.MkBlock(nil, 1, 1)
 	ts := mock.TipSet(block)
 	tma.applyBlock(t, block)

@@ -44,7 +44,7 @@ func SendHeadNotifs(nickname string) func(mctx helpers.MetricsCtx, lc fx.Lifecyc
 					}
 				}()
 				go func() {
-					sub, err := ps.Subscribe(topic) //nolint
+					sub, err := ps.Subscribe(topic)
 					if err != nil {
 						return
 					}
@@ -116,7 +116,6 @@ func sendHeadNotifs(ctx context.Context, ps *pubsub.PubSub, topic string, chain
 				return err
 			}

-			//nolint
 			if err := ps.Publish(topic, b); err != nil {
 				return err
 			}
@@ -246,7 +246,7 @@ func (st *StateTree) DeleteActor(addr address.Address) error {
 }

 func (st *StateTree) Flush(ctx context.Context) (cid.Cid, error) {
-	ctx, span := trace.StartSpan(ctx, "stateTree.Flush") //nolint:staticcheck
+	ctx, span := trace.StartSpan(ctx, "stateTree.Flush")
 	defer span.End()
 	if len(st.snaps.layers) != 1 {
 		return cid.Undef, xerrors.Errorf("tried to flush state tree with snapshots on the stack")
@@ -268,7 +268,7 @@ func (st *StateTree) Flush(ctx context.Context) (cid.Cid, error) {
 }

 func (st *StateTree) Snapshot(ctx context.Context) error {
-	ctx, span := trace.StartSpan(ctx, "stateTree.SnapShot") //nolint:staticcheck
+	ctx, span := trace.StartSpan(ctx, "stateTree.SnapShot")
 	defer span.End()

 	st.snaps.addLayer()
@@ -42,7 +42,7 @@ func TestIndexSeeks(t *testing.T) {
 	if err := cs.PutTipSet(ctx, mock.TipSet(gen)); err != nil {
 		t.Fatal(err)
 	}
-	assert.NoError(t, cs.SetGenesis(gen))
+	cs.SetGenesis(gen)

 	// Put 113 blocks from genesis
 	for i := 0; i < 113; i++ {
@@ -483,10 +483,6 @@ func (cs *ChainStore) NearestCommonAncestor(a, b *types.TipSet) (*types.TipSet,
 }

 func (cs *ChainStore) ReorgOps(a, b *types.TipSet) ([]*types.TipSet, []*types.TipSet, error) {
-	return ReorgOps(cs.LoadTipSet, a, b)
-}
-
-func ReorgOps(lts func(types.TipSetKey) (*types.TipSet, error), a, b *types.TipSet) ([]*types.TipSet, []*types.TipSet, error) {
 	left := a
 	right := b

@@ -494,7 +490,7 @@ func ReorgOps(lts func(types.TipSetKey) (*types.TipSet, error), a, b *types.TipS
 	for !left.Equals(right) {
 		if left.Height() > right.Height() {
 			leftChain = append(leftChain, left)
-			par, err := lts(left.Parents())
+			par, err := cs.LoadTipSet(left.Parents())
 			if err != nil {
 				return nil, nil, err
 			}
@@ -502,7 +498,7 @@ func ReorgOps(lts func(types.TipSetKey) (*types.TipSet, error), a, b *types.TipS
 			left = par
 		} else {
 			rightChain = append(rightChain, right)
-			par, err := lts(right.Parents())
+			par, err := cs.LoadTipSet(right.Parents())
 			if err != nil {
 				log.Infof("failed to fetch right.Parents: %s", err)
 				return nil, nil, err
@@ -513,7 +509,6 @@ func ReorgOps(lts func(types.TipSetKey) (*types.TipSet, error), a, b *types.TipS
 	}

 	return leftChain, rightChain, nil
-
 }

 // GetHeaviestTipSet returns the current heaviest tipset known (i.e. our head).
@@ -930,7 +925,7 @@ func (cs *ChainStore) LoadMessagesFromCids(cids []cid.Cid) ([]*types.Message, er
 	for i, c := range cids {
 		m, err := cs.GetMessage(c)
 		if err != nil {
-			return nil, xerrors.Errorf("failed to get message: (%s):%d: %w", c, i, err)
+			return nil, xerrors.Errorf("failed to get message: (%s):%d: %w", err, c, i)
 		}

 		msgs = append(msgs, m)
@@ -944,7 +939,7 @@ func (cs *ChainStore) LoadSignedMessagesFromCids(cids []cid.Cid) ([]*types.Signe
 	for i, c := range cids {
 		m, err := cs.GetSignedMessage(c)
 		if err != nil {
-			return nil, xerrors.Errorf("failed to get message: (%s):%d: %w", c, i, err)
+			return nil, xerrors.Errorf("failed to get message: (%s):%d: %w", err, c, i)
 		}

 		msgs = append(msgs, m)
@@ -292,9 +292,10 @@ func (bv *BlockValidator) Validate(ctx context.Context, pid peer.ID, msg *pubsub
 			log.Warnf("received block from unknown miner or miner that doesn't meet min power over pubsub; rejecting message")
 			recordFailure("unknown_miner")
 			return pubsub.ValidationReject
+		} else {
+			log.Warnf("cannot validate block message; unknown miner or miner that doesn't meet min power in unsynced chain")
+			return pubsub.ValidationIgnore
 		}
-		log.Warnf("cannot validate block message; unknown miner or miner that doesn't meet min power in unsynced chain")
-		return pubsub.ValidationIgnore
 	}

 	err = sigs.CheckBlockSignature(ctx, blk.Header, key)
@@ -7,7 +7,6 @@ import (
 	"fmt"
 	"os"
 	"sort"
-	"strconv"
 	"strings"
 	"time"

@@ -53,19 +52,6 @@ import (
 //the theoretical max height based on systime are quickly rejected
 const MaxHeightDrift = 5

-var defaultMessageFetchWindowSize = 200
-
-func init() {
-	if s := os.Getenv("LOTUS_BSYNC_MSG_WINDOW"); s != "" {
-		val, err := strconv.Atoi(s)
-		if err != nil {
-			log.Errorf("failed to parse LOTUS_BSYNC_MSG_WINDOW: %s", err)
-			return
-		}
-		defaultMessageFetchWindowSize = val
-	}
-}
-
 var log = logging.Logger("chain")

 var LocalIncoming = "incoming"
@@ -1413,7 +1399,7 @@ func (syncer *Syncer) iterFullTipsets(ctx context.Context, headers []*types.TipS

 	span.AddAttributes(trace.Int64Attribute("num_headers", int64(len(headers))))

-	windowSize := defaultMessageFetchWindowSize
+	windowSize := 200
 	for i := len(headers) - 1; i >= 0; {
 		fts, err := syncer.store.TryFillTipSet(headers[i])
 		if err != nil {
@@ -343,12 +343,12 @@ func (sm *SyncManager) scheduleProcessResult(res *syncResult) {
 				sm.syncQueue.buckets = append(sm.syncQueue.buckets, relbucket)
 			}
 			return
+		} else {
+			// TODO: this is the case where we try to sync a chain, and
+			// fail, and we have more blocks on top of that chain that
+			// have come in since.  The question is, should we try to
+			// sync these? or just drop them?
 		}
-		// TODO: this is the case where we try to sync a chain, and
-		// fail, and we have more blocks on top of that chain that
-		// have come in since.  The question is, should we try to
-		// sync these? or just drop them?
-		log.Error("failed to sync chain but have new unconnected blocks from chain")
 	}

 	if sm.nextSyncTarget == nil && !sm.syncQueue.Empty() {
@@ -3,12 +3,11 @@ package chain_test
 import (
 	"context"
 	"fmt"
+	"github.com/ipfs/go-cid"
 	"os"
 	"testing"
 	"time"

-	"github.com/ipfs/go-cid"
-
 	ds "github.com/ipfs/go-datastore"
 	logging "github.com/ipfs/go-log/v2"
 	"github.com/libp2p/go-libp2p-core/peer"
@@ -37,10 +36,7 @@ import (

 func init() {
 	build.InsecurePoStValidation = true
-	err := os.Setenv("TRUST_PARAMS", "1")
-	if err != nil {
-		panic(err)
-	}
+	os.Setenv("TRUST_PARAMS", "1")
 	miner.SupportedProofTypes = map[abi.RegisteredSealProof]struct{}{
 		abi.RegisteredSealProof_StackedDrg2KiBV1: {},
 	}
@@ -216,6 +212,20 @@ func (tu *syncTestUtil) mineNewBlock(src int, miners []int) {
 	tu.g.CurTipset = mts
 }

+func fblkToBlkMsg(fb *types.FullBlock) *types.BlockMsg {
+	out := &types.BlockMsg{
+		Header: fb.Header,
+	}
+
+	for _, msg := range fb.BlsMessages {
+		out.BlsMessages = append(out.BlsMessages, msg.Cid())
+	}
+	for _, msg := range fb.SecpkMessages {
+		out.SecpkMessages = append(out.SecpkMessages, msg.Cid())
+	}
+	return out
+}
+
 func (tu *syncTestUtil) addSourceNode(gen int) {
 	if tu.genesis != nil {
 		tu.t.Fatal("source node already exists")
@@ -444,7 +454,7 @@ func (wpp badWpp) GenerateCandidates(context.Context, abi.PoStRandomness, uint64

 func (wpp badWpp) ComputeProof(context.Context, []abi.SectorInfo, abi.PoStRandomness) ([]abi.PoStProof, error) {
 	return []abi.PoStProof{
-		{
+		abi.PoStProof{
 			PoStProof:  abi.RegisteredPoStProof_StackedDrgWinning2KiBV1,
 			ProofBytes: []byte("evil"),
 		},
@@ -577,7 +587,7 @@ func TestDuplicateNonce(t *testing.T) {

 	msgs := make([][]*types.SignedMessage, 2)
 	// Each miner includes a message from the banker with the same nonce, but to different addresses
-	for k := range msgs {
+	for k, _ := range msgs {
 		msgs[k] = []*types.SignedMessage{makeMsg(tu.g.Miners[k])}
 	}

@@ -6,10 +6,10 @@ import (
 	"fmt"
 	"io"

-	abi "github.com/filecoin-project/specs-actors/actors/abi"
-	crypto "github.com/filecoin-project/specs-actors/actors/crypto"
-	exitcode "github.com/filecoin-project/specs-actors/actors/runtime/exitcode"
-	cid "github.com/ipfs/go-cid"
+	"github.com/filecoin-project/specs-actors/actors/abi"
+	"github.com/filecoin-project/specs-actors/actors/crypto"
+	"github.com/filecoin-project/specs-actors/actors/runtime/exitcode"
+	"github.com/ipfs/go-cid"
 	cbg "github.com/whyrusleeping/cbor-gen"
 	xerrors "golang.org/x/xerrors"
 )
@@ -637,10 +637,15 @@ func (t *Message) MarshalCBOR(w io.Writer) error {

 	scratch := make([]byte, 9)

-	// t.Version (uint64) (uint64)
-
-	if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.Version)); err != nil {
-		return err
+	// t.Version (int64) (int64)
+	if t.Version >= 0 {
+		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajUnsignedInt, uint64(t.Version)); err != nil {
+			return err
+		}
+	} else {
+		if err := cbg.WriteMajorTypeHeaderBuf(scratch, w, cbg.MajNegativeInt, uint64(-t.Version-1)); err != nil {
+			return err
+		}
 	}

 	// t.To (address.Address) (struct)
@@ -724,19 +729,30 @@ func (t *Message) UnmarshalCBOR(r io.Reader) error {
 		return fmt.Errorf("cbor input had wrong number of fields")
 	}

-	// t.Version (uint64) (uint64)
-
+	// t.Version (int64) (int64)
 	{
-
-		maj, extra, err = cbg.CborReadHeaderBuf(br, scratch)
+		maj, extra, err := cbg.CborReadHeaderBuf(br, scratch)
+		var extraI int64
 		if err != nil {
 			return err
 		}
-		if maj != cbg.MajUnsignedInt {
-			return fmt.Errorf("wrong type for uint64 field")
+		switch maj {
+		case cbg.MajUnsignedInt:
+			extraI = int64(extra)
+			if extraI < 0 {
+				return fmt.Errorf("int64 positive overflow")
+			}
+		case cbg.MajNegativeInt:
+			extraI = int64(extra)
+			if extraI < 0 {
+				return fmt.Errorf("int64 negative oveflow")
+			}
+			extraI = -1 - extraI
+		default:
+			return fmt.Errorf("wrong type for int64 field: %d", maj)
 		}
-		t.Version = uint64(extra)

+		t.Version = int64(extraI)
 	}
 	// t.To (address.Address) (struct)

@@ -25,7 +25,7 @@ type ChainMsg interface {
 }

 type Message struct {
-	Version uint64
+	Version int64

 	To   address.Address
 	From address.Address
@@ -62,8 +62,8 @@ func (sm *SignedMessage) Serialize() ([]byte, error) {
 	return buf.Bytes(), nil
 }

-func (sm *SignedMessage) ChainLength() int {
-	ser, err := sm.Serialize()
+func (m *SignedMessage) ChainLength() int {
+	ser, err := m.Serialize()
 	if err != nil {
 		panic(err)
 	}
@@ -238,7 +238,3 @@ func (ts *TipSet) IsChildOf(parent *TipSet) bool {
 		//  height for their processing logic at the moment to obviate it.
 		ts.height > parent.height
 }
-
-func (ts *TipSet) String() string {
-	return fmt.Sprintf("%v", ts.cids)
-}
@@ -2,7 +2,6 @@ package validation

 import (
 	"context"
-
 	"github.com/filecoin-project/lotus/chain/state"
 	"github.com/filecoin-project/specs-actors/actors/runtime"
 	cbor "github.com/ipfs/go-ipld-cbor"
@@ -2,9 +2,8 @@ package validation

 import (
 	"fmt"
-	"math/rand"
-
 	"github.com/minio/blake2b-simd"
+	"math/rand"

 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-crypto"
@@ -70,7 +69,7 @@ func (k *KeyManager) Sign(addr address.Address, data []byte) (acrypto.Signature,
 }

 func (k *KeyManager) newSecp256k1Key() *wallet.Key {
-	randSrc := rand.New(rand.NewSource(k.secpSeed)) // nolint
+	randSrc := rand.New(rand.NewSource(k.secpSeed))
 	prv, err := crypto.GenerateKeyFromSeed(randSrc)
 	if err != nil {
 		panic(err)
@@ -18,7 +18,7 @@ func LoadVector(t *testing.T, f string, out interface{}) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	defer fi.Close() //nolint:errcheck
+	defer fi.Close()

 	if err := json.NewDecoder(fi).Decode(out); err != nil {
 		t.Fatal(err)
@@ -410,10 +410,8 @@ type shimStateHandle struct {

 func (ssh *shimStateHandle) Create(obj vmr.CBORMarshaler) {
 	c := ssh.rt.Put(obj)
-	err := ssh.rt.stateCommit(EmptyObjectCid, c)
-	if err != nil {
-		panic(fmt.Errorf("failed to commit state after creating object: %w", err))
-	}
+	// TODO: handle error below
+	ssh.rt.stateCommit(EmptyObjectCid, c)
 }

 func (ssh *shimStateHandle) Readonly(obj vmr.CBORUnmarshaler) {
@@ -442,10 +440,8 @@ func (ssh *shimStateHandle) Transaction(obj vmr.CBORer, f func()) {

 	c := ssh.rt.Put(obj)

-	err = ssh.rt.stateCommit(baseState, c)
-	if err != nil {
-		panic(fmt.Errorf("failed to commit state after transaction: %w", err))
-	}
+	// TODO: handle error below
+	ssh.rt.stateCommit(baseState, c)
 }

 func (rt *Runtime) GetBalance(a address.Address) (types.BigInt, aerrors.ActorError) {
@@ -254,9 +254,6 @@ func (vm *VM) send(ctx context.Context, msg *types.Message, parent *Runtime,
 		if aerr := rt.chargeGasSafe(rt.Pricelist().OnMethodInvocation(msg.Value, msg.Method)); aerr != nil {
 			return nil, aerrors.Wrap(aerr, "not enough gas for method invocation")
 		}
-
-		// not charging any gas, just logging
-		//nolint:errcheck
 		defer rt.chargeGasSafe(newGasCharge("OnMethodInvocationDone", 0, 0))

 		if types.BigCmp(msg.Value, types.NewInt(0)) != 0 {
@@ -2,7 +2,6 @@ package cli

 import (
 	"fmt"
-
 	"github.com/urfave/cli/v2"
 	"golang.org/x/xerrors"

@@ -319,7 +319,7 @@ var chainSetHeadCmd = &cli.Command{
 			ts, err = api.ChainGetTipSetByHeight(ctx, abi.ChainEpoch(cctx.Uint64("epoch")), types.EmptyTSK)
 		}
 		if ts == nil {
-			ts, err = parseTipSet(ctx, api, cctx.Args().Slice())
+			ts, err = parseTipSet(api, ctx, cctx.Args().Slice())
 		}
 		if err != nil {
 			return err
@@ -337,7 +337,7 @@ var chainSetHeadCmd = &cli.Command{
 	},
 }

-func parseTipSet(ctx context.Context, api api.FullNode, vals []string) (*types.TipSet, error) {
+func parseTipSet(api api.FullNode, ctx context.Context, vals []string) (*types.TipSet, error) {
 	var headers []*types.BlockHeader
 	for _, c := range vals {
 		blkc, err := cid.Decode(c)
@@ -930,11 +930,11 @@ var clientQueryAskCmd = &cli.Command{
 				return xerrors.Errorf("failed to get peerID for miner: %w", err)
 			}

-			if *mi.PeerId == peer.ID("SETME") {
+			if peer.ID(*mi.PeerId) == peer.ID("SETME") {
 				return fmt.Errorf("the miner hasn't initialized yet")
 			}

-			pid = *mi.PeerId
+			pid = peer.ID(*mi.PeerId)
 		}

 		ask, err := api.ClientQueryAsk(ctx, pid, maddr)
@@ -1045,53 +1045,55 @@ var clientListDeals = &cli.Command{
 				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\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.Message)
 			}
 			return w.Flush()
-		}
+		} else {
+			w := tablewriter.New(tablewriter.Col("DealCid"),
+				tablewriter.Col("DealId"),
+				tablewriter.Col("Provider"),
+				tablewriter.Col("State"),
+				tablewriter.Col("On Chain?"),
+				tablewriter.Col("Slashed?"),
+				tablewriter.Col("PieceCID"),
+				tablewriter.Col("Size"),
+				tablewriter.Col("Price"),
+				tablewriter.Col("Duration"),
+				tablewriter.NewLineCol("Message"))

-		w := tablewriter.New(tablewriter.Col("DealCid"),
-			tablewriter.Col("DealId"),
-			tablewriter.Col("Provider"),
-			tablewriter.Col("State"),
-			tablewriter.Col("On Chain?"),
-			tablewriter.Col("Slashed?"),
-			tablewriter.Col("PieceCID"),
-			tablewriter.Col("Size"),
-			tablewriter.Col("Price"),
-			tablewriter.Col("Duration"),
-			tablewriter.NewLineCol("Message"))
+			for _, d := range deals {
+				propcid := d.LocalDeal.ProposalCid.String()
+				propcid = "..." + propcid[len(propcid)-8:]

-		for _, d := range deals {
-			propcid := ellipsis(d.LocalDeal.ProposalCid.String(), 8)
+				onChain := "N"
+				if d.OnChainDealState.SectorStartEpoch != -1 {
+					onChain = fmt.Sprintf("Y (epoch %d)", d.OnChainDealState.SectorStartEpoch)
+				}

-			onChain := "N"
-			if d.OnChainDealState.SectorStartEpoch != -1 {
-				onChain = fmt.Sprintf("Y (epoch %d)", d.OnChainDealState.SectorStartEpoch)
+				slashed := "N"
+				if d.OnChainDealState.SlashEpoch != -1 {
+					slashed = fmt.Sprintf("Y (epoch %d)", d.OnChainDealState.SlashEpoch)
+				}
+
+				piece := d.LocalDeal.PieceCID.String()
+				piece = "..." + piece[len(piece)-8:]
+
+				price := types.FIL(types.BigMul(d.LocalDeal.PricePerEpoch, types.NewInt(d.LocalDeal.Duration)))
+
+				w.Write(map[string]interface{}{
+					"DealCid":   propcid,
+					"DealId":    d.LocalDeal.DealID,
+					"Provider":  d.LocalDeal.Provider,
+					"State":     dealStateString(color, d.LocalDeal.State),
+					"On Chain?": onChain,
+					"Slashed?":  slashed,
+					"PieceCID":  piece,
+					"Size":      types.SizeStr(types.NewInt(d.LocalDeal.Size)),
+					"Price":     price,
+					"Duration":  d.LocalDeal.Duration,
+					"Message":   d.LocalDeal.Message,
+				})
 			}

-			slashed := "N"
-			if d.OnChainDealState.SlashEpoch != -1 {
-				slashed = fmt.Sprintf("Y (epoch %d)", d.OnChainDealState.SlashEpoch)
-			}
-
-			piece := ellipsis(d.LocalDeal.PieceCID.String(), 8)
-
-			price := types.FIL(types.BigMul(d.LocalDeal.PricePerEpoch, types.NewInt(d.LocalDeal.Duration)))
-
-			w.Write(map[string]interface{}{
-				"DealCid":   propcid,
-				"DealId":    d.LocalDeal.DealID,
-				"Provider":  d.LocalDeal.Provider,
-				"State":     dealStateString(color, d.LocalDeal.State),
-				"On Chain?": onChain,
-				"Slashed?":  slashed,
-				"PieceCID":  piece,
-				"Size":      types.SizeStr(types.NewInt(d.LocalDeal.Size)),
-				"Price":     price,
-				"Duration":  d.LocalDeal.Duration,
-				"Message":   d.LocalDeal.Message,
-			})
+			return w.Flush(os.Stdout)
 		}
-
-		return w.Flush(os.Stdout)
 	},
 }

@@ -1316,7 +1318,7 @@ func OutputDataTransferChannels(out io.Writer, channels []lapi.DataTransferChann
 	for _, channel := range sendingChannels {
 		w.Write(toChannelOutput(color, "Sending To", channel))
 	}
-	w.Flush(out) //nolint:errcheck
+	w.Flush(out)

 	fmt.Fprintf(out, "\nReceiving Channels\n\n")
 	w = tablewriter.New(tablewriter.Col("ID"),
@@ -1330,7 +1332,7 @@ func OutputDataTransferChannels(out io.Writer, channels []lapi.DataTransferChann
 	for _, channel := range receivingChannels {
 		w.Write(toChannelOutput(color, "Receiving From", channel))
 	}
-	w.Flush(out) //nolint:errcheck
+	w.Flush(out)
 }

 func channelStatusString(useColor bool, status datatransfer.Status) string {
@@ -1350,8 +1352,11 @@ func channelStatusString(useColor bool, status datatransfer.Status) string {
 }

 func toChannelOutput(useColor bool, otherPartyColumn string, channel lapi.DataTransferChannel) map[string]interface{} {
-	rootCid := ellipsis(channel.BaseCID.String(), 8)
-	otherParty := ellipsis(channel.OtherPeer.String(), 8)
+	rootCid := channel.BaseCID.String()
+	rootCid = "..." + rootCid[len(rootCid)-8:]
+
+	otherParty := channel.OtherPeer.String()
+	otherParty = "..." + otherParty[len(otherParty)-8:]

 	initiated := "N"
 	if channel.IsInitiator {
@@ -1360,7 +1365,7 @@ func toChannelOutput(useColor bool, otherPartyColumn string, channel lapi.DataTr

 	voucher := channel.Voucher
 	if len(voucher) > 40 {
-		voucher = ellipsis(voucher, 37)
+		voucher = "..." + voucher[len(voucher)-37:]
 	}

 	return map[string]interface{}{
@@ -1374,10 +1379,3 @@ func toChannelOutput(useColor bool, otherPartyColumn string, channel lapi.DataTr
 		"Message":        channel.Message,
 	}
 }
-
-func ellipsis(s string, length int) string {
-	if length > 0 && len(s) > length {
-		return "..." + s[len(s)-length:]
-	}
-	return s
-}
@@ -12,7 +12,7 @@ import (
 	logging "github.com/ipfs/go-log/v2"
 	"github.com/mitchellh/go-homedir"
 	"github.com/multiformats/go-multiaddr"
-	manet "github.com/multiformats/go-multiaddr/net"
+	manet "github.com/multiformats/go-multiaddr-net"
 	"github.com/urfave/cli/v2"
 	"golang.org/x/xerrors"

@@ -213,7 +213,7 @@ func GetAPI(ctx *cli.Context) (api.Common, jsonrpc.ClientCloser, error) {
 		return nil, nil, err
 	}

-	return client.NewCommonRPC(ctx.Context, addr, headers)
+	return client.NewCommonRPC(addr, headers)
 }

 func GetFullNodeAPI(ctx *cli.Context) (api.FullNode, jsonrpc.ClientCloser, error) {
@@ -222,7 +222,7 @@ func GetFullNodeAPI(ctx *cli.Context) (api.FullNode, jsonrpc.ClientCloser, error
 		return nil, nil, err
 	}

-	return client.NewFullNodeRPC(ctx.Context, addr, headers)
+	return client.NewFullNodeRPC(addr, headers)
 }

 func GetStorageMinerAPI(ctx *cli.Context, opts ...jsonrpc.Option) (api.StorageMiner, jsonrpc.ClientCloser, error) {
@@ -231,7 +231,7 @@ func GetStorageMinerAPI(ctx *cli.Context, opts ...jsonrpc.Option) (api.StorageMi
 		return nil, nil, err
 	}

-	return client.NewStorageMinerRPC(ctx.Context, addr, headers, opts...)
+	return client.NewStorageMinerRPC(addr, headers, opts...)
 }

 func DaemonContext(cctx *cli.Context) context.Context {
@@ -39,7 +39,7 @@ func RunApp(app *cli.App) {
 		}
 		var phe *PrintHelpErr
 		if xerrors.As(err, &phe) {
-			_ = cli.ShowCommandHelp(phe.Ctx, phe.Ctx.Command.Name)
+			cli.ShowCommandHelp(phe.Ctx, phe.Ctx.Command.Name)
 		}
 		os.Exit(1)
 	}
@@ -60,8 +60,7 @@ var logSetLevel = &cli.Command{
   Environment Variables:
   GOLOG_LOG_LEVEL - Default log level for all log systems
   GOLOG_LOG_FMT   - Change output log format (json, nocolor)
-   GOLOG_FILE      - Write logs to file
-   GOLOG_OUTPUT    - Specify whether to output to file, stderr, stdout or a combination, i.e. file+stderr
+   GOLOG_FILE      - Write logs to file in addition to stderr
 `,
 	Flags: []cli.Flag{
 		&cli.StringSliceFlag{
@@ -106,8 +106,7 @@ var mpoolClear = &cli.Command{

 		really := cctx.Bool("really-do-it")
 		if !really {
-			//nolint:golint
-			return fmt.Errorf("--really-do-it must be specified for this action to have an effect; you have been warned")
+			return fmt.Errorf("--really-do-it must be specified for this action to have an effect; you have been warned.")
 		}

 		local := cctx.Bool("local")
@@ -347,7 +346,7 @@ var mpoolReplaceCmd = &cli.Command{
 		if err != nil {
 			return fmt.Errorf("parsing gas-premium: %w", err)
 		}
-		// TODO: estimate fee cap here
+		// TODO: estiamte fee cap here
 		msg.GasFeeCap, err = types.BigFromString(cctx.String("gas-feecap"))
 		if err != nil {
 			return fmt.Errorf("parsing gas-feecap: %w", err)
@@ -180,7 +180,7 @@ var netFindPeer = &cli.Command{
 			return nil
 		}

-		pid, err := peer.Decode(cctx.Args().First())
+		pid, err := peer.IDB58Decode(cctx.Args().First())
 		if err != nil {
 			return err
 		}
@@ -4,10 +4,6 @@ import (
 	"bytes"
 	"encoding/base64"
 	"fmt"
-	"io"
-	"sort"
-
-	"github.com/filecoin-project/lotus/paychmgr"

 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/lotus/build"
@@ -326,7 +322,7 @@ var paychVoucherListCmd = &cli.Command{
 	Flags: []cli.Flag{
 		&cli.BoolFlag{
 			Name:  "export",
-			Usage: "Print voucher as serialized string",
+			Usage: "Print export strings",
 		},
 	},
 	Action: func(cctx *cli.Context) error {
@@ -352,11 +348,16 @@ var paychVoucherListCmd = &cli.Command{
 			return err
 		}

-		for _, v := range sortVouchers(vouchers) {
-			export := cctx.Bool("export")
-			err := outputVoucher(cctx.App.Writer, v, export)
-			if err != nil {
-				return err
+		for _, v := range vouchers {
+			if cctx.Bool("export") {
+				enc, err := EncodedString(v)
+				if err != nil {
+					return err
+				}
+
+				fmt.Fprintf(cctx.App.Writer, "Lane %d, Nonce %d: %s; %s\n", v.Lane, v.Nonce, v.Amount.String(), enc)
+			} else {
+				fmt.Fprintf(cctx.App.Writer, "Lane %d, Nonce %d: %s\n", v.Lane, v.Nonce, v.Amount.String())
 			}
 		}

@@ -366,14 +367,8 @@ var paychVoucherListCmd = &cli.Command{

 var paychVoucherBestSpendableCmd = &cli.Command{
 	Name:      "best-spendable",
-	Usage:     "Print vouchers with highest value that is currently spendable for each lane",
+	Usage:     "Print voucher with highest value that is currently spendable",
 	ArgsUsage: "[channelAddress]",
-	Flags: []cli.Flag{
-		&cli.BoolFlag{
-			Name:  "export",
-			Usage: "Print voucher as serialized string",
-		},
-	},
 	Action: func(cctx *cli.Context) error {
 		if cctx.Args().Len() != 1 {
 			return ShowHelp(cctx, fmt.Errorf("must pass payment channel address"))
@@ -392,53 +387,37 @@ var paychVoucherBestSpendableCmd = &cli.Command{

 		ctx := ReqContext(cctx)

-		vouchersByLane, err := paychmgr.BestSpendableByLane(ctx, api, ch)
+		vouchers, err := api.PaychVoucherList(ctx, ch)
 		if err != nil {
 			return err
 		}

-		var vouchers []*paych.SignedVoucher
-		for _, vchr := range vouchersByLane {
-			vouchers = append(vouchers, vchr)
-		}
-		for _, best := range sortVouchers(vouchers) {
-			export := cctx.Bool("export")
-			err := outputVoucher(cctx.App.Writer, best, export)
+		var best *paych.SignedVoucher
+		for _, v := range vouchers {
+			spendable, err := api.PaychVoucherCheckSpendable(ctx, ch, v, nil, nil)
 			if err != nil {
 				return err
 			}
+			if spendable {
+				if best == nil || v.Amount.GreaterThan(best.Amount) {
+					best = v
+				}
+			}
 		}

-		return nil
-	},
-}
-
-func sortVouchers(vouchers []*paych.SignedVoucher) []*paych.SignedVoucher {
-	sort.Slice(vouchers, func(i, j int) bool {
-		if vouchers[i].Lane == vouchers[j].Lane {
-			return vouchers[i].Nonce < vouchers[j].Nonce
+		if best == nil {
+			return fmt.Errorf("No spendable vouchers for that channel")
 		}
-		return vouchers[i].Lane < vouchers[j].Lane
-	})
-	return vouchers
-}

-func outputVoucher(w io.Writer, v *paych.SignedVoucher, export bool) error {
-	var enc string
-	if export {
-		var err error
-		enc, err = EncodedString(v)
+		enc, err := EncodedString(best)
 		if err != nil {
 			return err
 		}
-	}

-	fmt.Fprintf(w, "Lane %d, Nonce %d: %s", v.Lane, v.Nonce, v.Amount.String())
-	if export {
-		fmt.Fprintf(w, "; %s", enc)
-	}
-	fmt.Fprintln(w)
-	return nil
+		fmt.Fprintln(cctx.App.Writer, enc)
+		fmt.Fprintf(cctx.App.Writer, "Amount: %s\n", best.Amount)
+		return nil
+	},
 }

 var paychVoucherSubmitCmd = &cli.Command{
@@ -4,7 +4,6 @@ import (
 	"bytes"
 	"context"
 	"flag"
-	"fmt"
 	"os"
 	"strconv"
 	"strings"
@@ -50,139 +49,6 @@ func TestPaymentChannels(t *testing.T) {

 	blocktime := 5 * time.Millisecond
 	ctx := context.Background()
-	nodes, addrs := startTwoNodesOneMiner(ctx, t, blocktime)
-	paymentCreator := nodes[0]
-	paymentReceiver := nodes[0]
-	creatorAddr := addrs[0]
-	receiverAddr := addrs[1]
-
-	// Create mock CLI
-	mockCLI := newMockCLI(t)
-	creatorCLI := mockCLI.client(paymentCreator.ListenAddr)
-	receiverCLI := mockCLI.client(paymentReceiver.ListenAddr)
-
-	// creator: paych get <creator> <receiver> <amount>
-	channelAmt := "100000"
-	cmd := []string{creatorAddr.String(), receiverAddr.String(), channelAmt}
-	chstr := creatorCLI.runCmd(paychGetCmd, cmd)
-
-	chAddr, err := address.NewFromString(chstr)
-	require.NoError(t, err)
-
-	// creator: paych voucher create <channel> <amount>
-	voucherAmt := 100
-	vamt := strconv.Itoa(voucherAmt)
-	cmd = []string{chAddr.String(), vamt}
-	voucher := creatorCLI.runCmd(paychVoucherCreateCmd, cmd)
-
-	// receiver: paych voucher add <channel> <voucher>
-	cmd = []string{chAddr.String(), voucher}
-	receiverCLI.runCmd(paychVoucherAddCmd, cmd)
-
-	// creator: paych settle <channel>
-	cmd = []string{chAddr.String()}
-	creatorCLI.runCmd(paychSettleCmd, cmd)
-
-	// Wait for the chain to reach the settle height
-	chState := getPaychState(ctx, t, paymentReceiver, chAddr)
-	waitForHeight(ctx, t, paymentReceiver, chState.SettlingAt)
-
-	// receiver: paych collect <channel>
-	cmd = []string{chAddr.String()}
-	receiverCLI.runCmd(paychCloseCmd, cmd)
-}
-
-type voucherSpec struct {
-	serialized string
-	amt        int
-	lane       int
-}
-
-// TestPaymentChannelVouchers does a basic test to exercise some payment
-// channel voucher commands
-func TestPaymentChannelVouchers(t *testing.T) {
-	_ = os.Setenv("BELLMAN_NO_GPU", "1")
-
-	blocktime := 5 * time.Millisecond
-	ctx := context.Background()
-	nodes, addrs := startTwoNodesOneMiner(ctx, t, blocktime)
-	paymentCreator := nodes[0]
-	creatorAddr := addrs[0]
-	receiverAddr := addrs[1]
-
-	// Create mock CLI
-	mockCLI := newMockCLI(t)
-	creatorCLI := mockCLI.client(paymentCreator.ListenAddr)
-
-	// creator: paych get <creator> <receiver> <amount>
-	channelAmt := "100000"
-	cmd := []string{creatorAddr.String(), receiverAddr.String(), channelAmt}
-	chstr := creatorCLI.runCmd(paychGetCmd, cmd)
-
-	chAddr, err := address.NewFromString(chstr)
-	require.NoError(t, err)
-
-	var vouchers []voucherSpec
-
-	// creator: paych voucher create <channel> <amount>
-	// Note: implied --lane=0
-	voucherAmt1 := 100
-	vamt1 := strconv.Itoa(voucherAmt1)
-	cmd = []string{chAddr.String(), vamt1}
-	voucher1 := creatorCLI.runCmd(paychVoucherCreateCmd, cmd)
-	vouchers = append(vouchers, voucherSpec{serialized: voucher1, lane: 0, amt: voucherAmt1})
-
-	// creator: paych voucher create <channel> <amount> --lane=5
-	lane5 := "--lane=5"
-	voucherAmt2 := 50
-	vamt2 := strconv.Itoa(voucherAmt2)
-	cmd = []string{lane5, chAddr.String(), vamt2}
-	voucher2 := creatorCLI.runCmd(paychVoucherCreateCmd, cmd)
-	vouchers = append(vouchers, voucherSpec{serialized: voucher2, lane: 5, amt: voucherAmt2})
-
-	// creator: paych voucher create <channel> <amount> --lane=5
-	voucherAmt3 := 70
-	vamt3 := strconv.Itoa(voucherAmt3)
-	cmd = []string{lane5, chAddr.String(), vamt3}
-	voucher3 := creatorCLI.runCmd(paychVoucherCreateCmd, cmd)
-	vouchers = append(vouchers, voucherSpec{serialized: voucher3, lane: 5, amt: voucherAmt3})
-
-	// creator: paych voucher list <channel> --export
-	cmd = []string{"--export", chAddr.String()}
-	list := creatorCLI.runCmd(paychVoucherListCmd, cmd)
-
-	// Check that voucher list output is correct
-	checkVoucherOutput(t, list, vouchers)
-
-	// creator: paych voucher best-spendable <channel>
-	cmd = []string{"--export", chAddr.String()}
-	bestSpendable := creatorCLI.runCmd(paychVoucherBestSpendableCmd, cmd)
-
-	// Check that best spendable output is correct
-	bestVouchers := []voucherSpec{
-		{serialized: voucher1, lane: 0, amt: voucherAmt1},
-		{serialized: voucher3, lane: 5, amt: voucherAmt3},
-	}
-	checkVoucherOutput(t, bestSpendable, bestVouchers)
-}
-
-func checkVoucherOutput(t *testing.T, list string, vouchers []voucherSpec) {
-	lines := strings.Split(list, "\n")
-	listVouchers := make(map[string]string)
-	for _, line := range lines {
-		parts := strings.Split(line, ";")
-		serialized := strings.TrimSpace(parts[1])
-		listVouchers[serialized] = strings.TrimSpace(parts[0])
-	}
-	for _, vchr := range vouchers {
-		res, ok := listVouchers[vchr.serialized]
-		require.True(t, ok)
-		require.Regexp(t, fmt.Sprintf("Lane %d", vchr.lane), res)
-		require.Regexp(t, fmt.Sprintf("%d", vchr.amt), res)
-	}
-}
-
-func startTwoNodesOneMiner(ctx context.Context, t *testing.T, blocktime time.Duration) ([]test.TestNode, []address.Address) {
 	n, sn := builder.RPCMockSbBuilder(t, 2, test.OneMiner)

 	paymentCreator := n[0]
@@ -222,7 +88,39 @@ func startTwoNodesOneMiner(ctx context.Context, t *testing.T, blocktime time.Dur
 	}

 	// Create mock CLI
-	return n, []address.Address{creatorAddr, receiverAddr}
+	mockCLI := newMockCLI(t)
+	creatorCLI := mockCLI.client(paymentCreator.ListenAddr)
+	receiverCLI := mockCLI.client(paymentReceiver.ListenAddr)
+
+	// creator: paych get <creator> <receiver> <amount>
+	channelAmt := "100000"
+	cmd := []string{creatorAddr.String(), receiverAddr.String(), channelAmt}
+	chstr := creatorCLI.runCmd(paychGetCmd, cmd)
+
+	chAddr, err := address.NewFromString(chstr)
+	require.NoError(t, err)
+
+	// creator: paych voucher create <channel> <amount>
+	voucherAmt := 100
+	vamt := strconv.Itoa(voucherAmt)
+	cmd = []string{chAddr.String(), vamt}
+	voucher := creatorCLI.runCmd(paychVoucherCreateCmd, cmd)
+
+	// receiver: paych voucher add <channel> <voucher>
+	cmd = []string{chAddr.String(), voucher}
+	receiverCLI.runCmd(paychVoucherAddCmd, cmd)
+
+	// creator: paych settle <channel>
+	cmd = []string{chAddr.String()}
+	creatorCLI.runCmd(paychSettleCmd, cmd)
+
+	// Wait for the chain to reach the settle height
+	chState := getPaychState(ctx, t, paymentReceiver, chAddr)
+	waitForHeight(ctx, t, paymentReceiver, chState.SettlingAt)
+
+	// receiver: paych collect <channel>
+	cmd = []string{chAddr.String()}
+	receiverCLI.runCmd(paychCloseCmd, cmd)
 }

 type mockCLI struct {
@@ -9,7 +9,7 @@ import (
 	"golang.org/x/xerrors"

 	"github.com/filecoin-project/lotus/node/repo"
-	manet "github.com/multiformats/go-multiaddr/net"
+	manet "github.com/multiformats/go-multiaddr-net"
 )

 var pprofCmd = &cli.Command{
@@ -44,7 +44,7 @@ var PprofGoroutines = &cli.Command{

 		addr = "http://" + addr + "/debug/pprof/goroutine?debug=2"

-		r, err := http.Get(addr) //nolint:gosec
+		r, err := http.Get(addr)
 		if err != nil {
 			return err
 		}
@@ -353,9 +353,6 @@ var stateReplaySetCmd = &cli.Command{
 				}

 				ts, err = types.NewTipSet(headers)
-				if err != nil {
-					return err
-				}
 			} else {
 				var r *api.MsgLookup
 				r, err = fapi.StateWaitMsg(ctx, mcid, build.MessageConfidence)
@@ -368,9 +365,9 @@ var stateReplaySetCmd = &cli.Command{
 					return xerrors.Errorf("loading tipset: %w", err)
 				}
 				ts, err = fapi.ChainGetTipSet(ctx, childTs.Parents())
-				if err != nil {
-					return err
-				}
+			}
+			if err != nil {
+				return err
 			}

 		}
@@ -1502,7 +1499,7 @@ func parseParamsForMethod(act cid.Cid, method uint64, args []string) ([]byte, er
 			}
 			p.Elem().Field(i).Set(reflect.ValueOf(val))
 		case reflect.TypeOf(peer.ID("")):
-			pid, err := peer.Decode(args[i])
+			pid, err := peer.IDB58Decode(args[i])
 			if err != nil {
 				return nil, fmt.Errorf("failed to parse peer ID: %s", err)
 			}
@@ -1587,9 +1584,6 @@ var stateMarketBalanceCmd = &cli.Command{
 		}

 		balance, err := api.StateMarketBalance(ctx, addr, ts.Key())
-		if err != nil {
-			return err
-		}

 		fmt.Printf("Escrow: %s\n", types.FIL(balance.Escrow))
 		fmt.Printf("Locked: %s\n", types.FIL(balance.Locked))
@@ -385,9 +385,10 @@ var walletVerify = &cli.Command{
 		if api.WalletVerify(ctx, addr, msg, &sig) {
 			fmt.Println("valid")
 			return nil
+		} else {
+			fmt.Println("invalid")
+			return NewCliError("CLI Verify called with invalid signature")
 		}
-		fmt.Println("invalid")
-		return NewCliError("CLI Verify called with invalid signature")
 	},
 }

@@ -214,7 +214,7 @@ func countGasCosts(et *types.ExecutionTrace) (int64, int64) {
 	}

 	for _, sub := range et.Subcalls {
-		c, v := countGasCosts(&sub) //nolint
+		c, v := countGasCosts(&sub)
 		cgas += c
 		vgas += v
 	}
@@ -222,6 +222,24 @@ func countGasCosts(et *types.ExecutionTrace) (int64, int64) {
 	return cgas, vgas
 }

+func compStats(vals []float64) (float64, float64) {
+	var sum float64
+
+	for _, v := range vals {
+		sum += v
+	}
+
+	av := sum / float64(len(vals))
+
+	var varsum float64
+	for _, v := range vals {
+		delta := av - v
+		varsum += delta * delta
+	}
+
+	return av, math.Sqrt(varsum / float64(len(vals)))
+}
+
 type stats struct {
 	timeTaken meanVar
 	gasRatio  meanVar
@@ -246,20 +264,20 @@ func (cov1 *covar) VarianceX() float64 {
 	return cov1.m2x / (cov1.n - 1)
 }

-func (cov1 *covar) StddevX() float64 {
-	return math.Sqrt(cov1.VarianceX())
+func (v1 *covar) StddevX() float64 {
+	return math.Sqrt(v1.VarianceX())
 }

 func (cov1 *covar) VarianceY() float64 {
 	return cov1.m2y / (cov1.n - 1)
 }

-func (cov1 *covar) StddevY() float64 {
-	return math.Sqrt(cov1.VarianceY())
+func (v1 *covar) StddevY() float64 {
+	return math.Sqrt(v1.VarianceY())
 }

 func (cov1 *covar) AddPoint(x, y float64) {
-	cov1.n++
+	cov1.n += 1

 	dx := x - cov1.meanX
 	cov1.meanX += dx / cov1.n
@@ -326,7 +344,7 @@ type meanVar struct {

 func (v1 *meanVar) AddPoint(value float64) {
 	// based on https://en.wikipedia.org/wiki/Algorithms_for_calculating_variance#Welford's_online_algorithm
-	v1.n++
+	v1.n += 1
 	delta := value - v1.mean
 	v1.mean += delta / v1.n
 	delta2 := value - v1.mean
@@ -463,7 +481,7 @@ var importAnalyzeCmd = &cli.Command{
 		}

 		go func() {
-			http.ListenAndServe("localhost:6060", nil) //nolint:errcheck
+			http.ListenAndServe("localhost:6060", nil)
 		}()

 		fi, err := os.Open(cctx.Args().First())
@@ -8,6 +8,7 @@ import (
 	"sync"
 	"time"

+	"golang.org/x/sync/errgroup"
 	"golang.org/x/xerrors"

 	"github.com/filecoin-project/go-address"
@@ -143,69 +144,60 @@ func (p *Processor) Start(ctx context.Context) {
 					"AccountChanges", len(actorChanges[builtin.AccountActorCodeID]),
 					"nullRounds", len(nullRounds))

-				grp := sync.WaitGroup{}
+				grp, ctx := errgroup.WithContext(ctx)

-				grp.Add(1)
-				go func() {
-					defer grp.Done()
+				grp.Go(func() error {
 					if err := p.HandleMarketChanges(ctx, actorChanges[builtin.StorageMarketActorCodeID]); err != nil {
-						log.Errorf("Failed to handle market changes: %w", err)
-						return
+						return xerrors.Errorf("Failed to handle market changes: %w", err)
 					}
 					log.Info("Processed Market Changes")
-				}()
+					return nil
+				})

-				grp.Add(1)
-				go func() {
-					defer grp.Done()
+				grp.Go(func() error {
 					if err := p.HandleMinerChanges(ctx, actorChanges[builtin.StorageMinerActorCodeID]); err != nil {
-						log.Errorf("Failed to handle miner changes: %w", err)
-						return
+						return xerrors.Errorf("Failed to handle miner changes: %w", err)
 					}
 					log.Info("Processed Miner Changes")
-				}()
+					return nil
+				})

-				grp.Add(1)
-				go func() {
-					defer grp.Done()
+				grp.Go(func() error {
 					if err := p.HandleRewardChanges(ctx, actorChanges[builtin.RewardActorCodeID], nullRounds); err != nil {
-						log.Errorf("Failed to handle reward changes: %w", err)
-						return
+						return xerrors.Errorf("Failed to handle reward changes: %w", err)
 					}
 					log.Info("Processed Reward Changes")
-				}()
+					return nil
+				})

-				grp.Add(1)
-				go func() {
-					defer grp.Done()
+				grp.Go(func() error {
 					if err := p.HandlePowerChanges(ctx, actorChanges[builtin.StoragePowerActorCodeID]); err != nil {
-						log.Errorf("Failed to handle power actor changes: %w", err)
-						return
+						return xerrors.Errorf("Failed to handle power actor changes: %w", err)
 					}
 					log.Info("Processes Power Changes")
-				}()
+					return nil
+				})

-				grp.Add(1)
-				go func() {
-					defer grp.Done()
+				grp.Go(func() error {
 					if err := p.HandleMessageChanges(ctx, toProcess); err != nil {
-						log.Errorf("Failed to handle message changes: %w", err)
-						return
+						return xerrors.Errorf("Failed to handle message changes: %w", err)
 					}
 					log.Info("Processed Message Changes")
-				}()
+					return nil
+				})

-				grp.Add(1)
-				go func() {
-					defer grp.Done()
+				grp.Go(func() error {
 					if err := p.HandleCommonActorsChanges(ctx, actorChanges); err != nil {
-						log.Errorf("Failed to handle common actor changes: %w", err)
-						return
+						return xerrors.Errorf("Failed to handle common actor changes: %w", err)
 					}
 					log.Info("Processed CommonActor Changes")
-				}()
+					return nil
+				})

-				grp.Wait()
+				if err := grp.Wait(); err != nil {
+					log.Errorw("Failed to handle actor changes...retrying", "error", err)
+					continue
+				}

 				if err := p.markBlocksProcessed(ctx, toProcess); err != nil {
 					log.Fatalw("Failed to mark blocks as processed", "error", err)
@@ -159,7 +159,7 @@ func (p *Processor) persistRewardActors(ctx context.Context, rewards []rewardAct
 		log.Debugw("Persisted Reward Actors", "duration", time.Since(start).String())
 	}()

-	grp, ctx := errgroup.WithContext(ctx) //nolint
+	grp, ctx := errgroup.WithContext(ctx)

 	grp.Go(func() error {
 		if err := p.storeChainPower(rewards); err != nil {
@@ -24,12 +24,12 @@ var runCmd = &cli.Command{
 	Flags: []cli.Flag{
 		&cli.IntFlag{
 			Name:  "max-batch",
-			Value: 50,
+			Value: 1000,
 		},
 	},
 	Action: func(cctx *cli.Context) error {
 		go func() {
-			http.ListenAndServe(":6060", nil) //nolint:errcheck
+			http.ListenAndServe(":6060", nil)
 		}()
 		ll := cctx.String("log-level")
 		if err := logging.SetLogLevel("*", ll); err != nil {
@@ -49,11 +49,11 @@ func setupTopMinerByBaseRewardSchema(ctx context.Context, db *sql.DB) error {
 			order by 1 desc
 			limit 1;
 	`); err != nil {
-		return xerrors.Errorf("create top_miner_by_base_reward views: %w", err)
+		return xerrors.Errorf("create top_miner_by_base_reward views", err)
 	}

 	if err := tx.Commit(); err != nil {
-		return xerrors.Errorf("committing top_miner_by_base_reward views; %w", err)
+		return xerrors.Errorf("commiting top_miner_by_base_reward views", err)
 	}
 	return nil
 }
@@ -25,7 +25,7 @@ func PrepareScheduler(db *sql.DB) *Scheduler {

 func (s *Scheduler) setupSchema(ctx context.Context) error {
 	if err := setupTopMinerByBaseRewardSchema(ctx, s.db); err != nil {
-		return xerrors.Errorf("setup top miners by reward schema: %w", err)
+		return xerrors.Errorf("setup top miners by reward schema", err)
 	}
 	return nil
 }
@@ -35,14 +35,14 @@ func (s *Scheduler) Start(ctx context.Context) {
 	log.Debug("Starting Scheduler")

 	if err := s.setupSchema(ctx); err != nil {
-		log.Fatalw("applying scheduling schema", "error", err)
+		log.Fatalw("applying scheduling schema", err)
 	}

 	go func() {
 		// run once on start after schema has initialized
 		time.Sleep(5 * time.Second)
 		if err := refreshTopMinerByBaseReward(ctx, s.db); err != nil {
-			log.Errorw("failed to refresh top miner", "error", err)
+			log.Errorf(err.Error())
 		}
 		refreshTopMinerCh := time.NewTicker(30 * time.Second)
 		defer refreshTopMinerCh.Stop()
@@ -50,7 +50,7 @@ func (s *Scheduler) Start(ctx context.Context) {
 			select {
 			case <-refreshTopMinerCh.C:
 				if err := refreshTopMinerByBaseReward(ctx, s.db); err != nil {
-					log.Errorw("failed to refresh top miner", "error", err)
+					log.Errorf(err.Error())
 				}
 			case <-ctx.Done():
 				return
@@ -1,27 +1,77 @@
 package main

 import (
+	"bytes"
 	"context"
 	"fmt"
+	"html/template"
+	"io"
+	"io/ioutil"
 	"net"
 	"net/http"
 	"os"
+	"sort"
+	"strconv"
 	"time"

 	rice "github.com/GeertJohan/go.rice"
+	"github.com/ipfs/go-cid"
 	logging "github.com/ipfs/go-log/v2"
+	"github.com/libp2p/go-libp2p-core/peer"
 	"github.com/urfave/cli/v2"
 	"golang.org/x/xerrors"

+	"github.com/filecoin-project/lotus/extern/sector-storage/ffiwrapper"
+	"github.com/filecoin-project/specs-actors/actors/abi"
+	"github.com/filecoin-project/specs-actors/actors/abi/big"
+	"github.com/filecoin-project/specs-actors/actors/builtin"
+	"github.com/filecoin-project/specs-actors/actors/builtin/power"
+
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/build"
+	"github.com/filecoin-project/lotus/chain/actors"
 	"github.com/filecoin-project/lotus/chain/types"
 	lcli "github.com/filecoin-project/lotus/cli"
+	"github.com/filecoin-project/specs-actors/actors/builtin/miner"
 )

 var log = logging.Logger("main")

+var supportedSectors struct {
+	SectorSizes []struct {
+		Name    string
+		Value   uint64
+		Default bool
+	}
+}
+
+func init() {
+	for supportedSector, _ := range miner.SupportedProofTypes {
+		sectorSize, err := supportedSector.SectorSize()
+		if err != nil {
+			panic(err)
+		}
+
+		supportedSectors.SectorSizes = append(supportedSectors.SectorSizes, struct {
+			Name    string
+			Value   uint64
+			Default bool
+		}{
+			Name:    sectorSize.ShortString(),
+			Value:   uint64(sectorSize),
+			Default: false,
+		})
+
+	}
+
+	sort.Slice(supportedSectors.SectorSizes[:], func(i, j int) bool {
+		return supportedSectors.SectorSizes[i].Value < supportedSectors.SectorSizes[j].Value
+	})
+
+	supportedSectors.SectorSizes[0].Default = true
+}
+
 func main() {
 	logging.SetLogLevel("*", "INFO")

@@ -94,6 +144,11 @@ var runCmd = &cli.Command{
 			return xerrors.Errorf("parsing source address (provide correct --from flag!): %w", err)
 		}

+		defaultMinerPeer, err := peer.Decode("12D3KooWJpBNhwgvoZ15EB1JwRTRpxgM9D2fwq6eEktrJJG74aP6")
+		if err != nil {
+			return err
+		}
+
 		h := &handler{
 			ctx:            ctx,
 			api:            nodeApi,
@@ -107,10 +162,23 @@ var runCmd = &cli.Command{
 				WalletRate:  15 * time.Minute,
 				WalletBurst: 2,
 			}),
+			minerLimiter: NewLimiter(LimiterConfig{
+				TotalRate:   500 * time.Millisecond,
+				TotalBurst:  build.BlockMessageLimit,
+				IPRate:      10 * time.Minute,
+				IPBurst:     2,
+				WalletRate:  1 * time.Hour,
+				WalletBurst: 2,
+			}),
+			defaultMinerPeer: defaultMinerPeer,
 		}

 		http.Handle("/", http.FileServer(rice.MustFindBox("site").HTTPBox()))
+		http.HandleFunc("/miner.html", h.minerhtml)
 		http.HandleFunc("/send", h.send)
+		http.HandleFunc("/mkminer", h.mkminer)
+		http.HandleFunc("/msgwait", h.msgwait)
+		http.HandleFunc("/msgwaitaddr", h.msgwaitaddr)

 		fmt.Printf("Open http://%s\n", cctx.String("front"))

@@ -130,13 +198,48 @@ type handler struct {
 	from           address.Address
 	sendPerRequest types.FIL

-	limiter *Limiter
+	limiter      *Limiter
+	minerLimiter *Limiter
+
+	defaultMinerPeer peer.ID
+}
+
+func (h *handler) minerhtml(w http.ResponseWriter, r *http.Request) {
+	f, err := rice.MustFindBox("site").Open("_miner.html")
+	if err != nil {
+		w.WriteHeader(500)
+		_, _ = w.Write([]byte(err.Error()))
+		return
+	}
+
+	tmpl, err := ioutil.ReadAll(f)
+	if err != nil {
+		w.WriteHeader(500)
+		_, _ = w.Write([]byte(err.Error()))
+		return
+	}
+
+	var executedTmpl bytes.Buffer
+
+	t, err := template.New("miner.html").Parse(string(tmpl))
+	if err := t.Execute(&executedTmpl, supportedSectors); err != nil {
+		w.WriteHeader(500)
+		_, _ = w.Write([]byte(err.Error()))
+		return
+	}
+
+	if _, err := io.Copy(w, &executedTmpl); err != nil {
+		log.Errorf("failed to write template to string %s", err)
+	}
+
+	return
 }

 func (h *handler) send(w http.ResponseWriter, r *http.Request) {
 	to, err := address.NewFromString(r.FormValue("address"))
 	if err != nil {
-		http.Error(w, err.Error(), http.StatusBadRequest)
+		w.WriteHeader(400)
+		_, _ = w.Write([]byte(err.Error()))
 		return
 	}

@@ -179,9 +282,168 @@ func (h *handler) send(w http.ResponseWriter, r *http.Request) {
 		To:    to,
 	}, nil)
 	if err != nil {
-		http.Error(w, err.Error(), http.StatusBadRequest)
+		w.WriteHeader(400)
+		_, _ = w.Write([]byte(err.Error()))
 		return
 	}

 	_, _ = w.Write([]byte(smsg.Cid().String()))
 }
+
+func (h *handler) mkminer(w http.ResponseWriter, r *http.Request) {
+	owner, err := address.NewFromString(r.FormValue("address"))
+	if err != nil {
+		w.WriteHeader(400)
+		_, _ = w.Write([]byte(err.Error()))
+		return
+	}
+
+	if owner.Protocol() != address.BLS {
+		w.WriteHeader(400)
+		_, _ = w.Write([]byte("Miner address must use BLS. A BLS address starts with the prefix 't3'."))
+		_, _ = w.Write([]byte("Please create a BLS address by running \"lotus wallet new bls\" while connected to a Lotus node."))
+		return
+	}
+
+	ssize, err := strconv.ParseInt(r.FormValue("sectorSize"), 10, 64)
+	if err != nil {
+		return
+	}
+
+	log.Infof("%s: create actor start", owner)
+
+	// Limit based on wallet address
+	limiter := h.minerLimiter.GetWalletLimiter(owner.String())
+	if !limiter.Allow() {
+		http.Error(w, http.StatusText(http.StatusTooManyRequests)+": wallet limit", http.StatusTooManyRequests)
+		return
+	}
+
+	// Limit based on IP
+	reqIP := r.Header.Get("X-Real-IP")
+	if reqIP == "" {
+		h, _, err := net.SplitHostPort(r.RemoteAddr)
+		if err != nil {
+			log.Errorf("could not get ip from: %s, err: %s", r.RemoteAddr, err)
+		}
+		reqIP = h
+	}
+	limiter = h.minerLimiter.GetIPLimiter(reqIP)
+	if !limiter.Allow() {
+		http.Error(w, http.StatusText(http.StatusTooManyRequests)+": IP limit", http.StatusTooManyRequests)
+		return
+	}
+
+	// General limiter owner allow throttling all messages that can make it into the mpool
+	if !h.minerLimiter.Allow() {
+		http.Error(w, http.StatusText(http.StatusTooManyRequests)+": global limit", http.StatusTooManyRequests)
+		return
+	}
+
+	smsg, err := h.api.MpoolPushMessage(h.ctx, &types.Message{
+		Value: types.BigInt(h.sendPerRequest),
+		From:  h.from,
+		To:    owner,
+	}, nil)
+	if err != nil {
+		w.WriteHeader(400)
+		w.Write([]byte("pushfunds: " + err.Error()))
+		return
+	}
+	log.Infof("%s: push funds %s", owner, smsg.Cid())
+
+	spt, err := ffiwrapper.SealProofTypeFromSectorSize(abi.SectorSize(ssize))
+	if err != nil {
+		w.WriteHeader(400)
+		w.Write([]byte("sealprooftype: " + err.Error()))
+		return
+	}
+
+	params, err := actors.SerializeParams(&power.CreateMinerParams{
+		Owner:         owner,
+		Worker:        owner,
+		SealProofType: spt,
+		Peer:          abi.PeerID(h.defaultMinerPeer),
+	})
+	if err != nil {
+		w.WriteHeader(400)
+		w.Write([]byte(err.Error()))
+		return
+	}
+
+	createStorageMinerMsg := &types.Message{
+		To:    builtin.StoragePowerActorAddr,
+		From:  h.from,
+		Value: big.Zero(),
+
+		Method: builtin.MethodsPower.CreateMiner,
+		Params: params,
+	}
+
+	signed, err := h.api.MpoolPushMessage(r.Context(), createStorageMinerMsg, nil)
+	if err != nil {
+		w.WriteHeader(400)
+		w.Write([]byte(err.Error()))
+		return
+	}
+
+	log.Infof("%s: create miner msg: %s", owner, signed.Cid())
+
+	http.Redirect(w, r, fmt.Sprintf("/wait.html?f=%s&m=%s&o=%s", signed.Cid(), smsg.Cid(), owner), 303)
+}
+
+func (h *handler) msgwait(w http.ResponseWriter, r *http.Request) {
+	c, err := cid.Parse(r.FormValue("cid"))
+	if err != nil {
+		w.WriteHeader(400)
+		w.Write([]byte(err.Error()))
+		return
+	}
+
+	mw, err := h.api.StateWaitMsg(r.Context(), c, build.MessageConfidence)
+	if err != nil {
+		w.WriteHeader(400)
+		w.Write([]byte(err.Error()))
+		return
+	}
+
+	if mw.Receipt.ExitCode != 0 {
+		w.WriteHeader(400)
+		w.Write([]byte(xerrors.Errorf("create miner failed: exit code %d", mw.Receipt.ExitCode).Error()))
+		return
+	}
+	w.WriteHeader(200)
+}
+
+func (h *handler) msgwaitaddr(w http.ResponseWriter, r *http.Request) {
+	c, err := cid.Parse(r.FormValue("cid"))
+	if err != nil {
+		w.WriteHeader(400)
+		w.Write([]byte(err.Error()))
+		return
+	}
+
+	mw, err := h.api.StateWaitMsg(r.Context(), c, build.MessageConfidence)
+	if err != nil {
+		w.WriteHeader(400)
+		w.Write([]byte(err.Error()))
+		return
+	}
+
+	if mw.Receipt.ExitCode != 0 {
+		w.WriteHeader(400)
+		w.Write([]byte(xerrors.Errorf("create miner failed: exit code %d", mw.Receipt.ExitCode).Error()))
+		return
+	}
+	w.WriteHeader(200)
+
+	var ma power.CreateMinerReturn
+	if err := ma.UnmarshalCBOR(bytes.NewReader(mw.Receipt.Return)); err != nil {
+		log.Errorf("%w", err)
+		w.WriteHeader(400)
+		w.Write([]byte(err.Error()))
+		return
+	}
+
+	fmt.Fprintf(w, "{\"addr\": \"%s\"}", ma.IDAddress)
+}
@@ -0,0 +1,51 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <title>Creating Miner - Lotus Fountain</title>
+    <link rel="stylesheet" type="text/css" href="main.css">
+</head>
+<body>
+<div class="Index">
+    <div class="Index-nodes">
+        <div class="Index-node">
+            [CREATING MINER]
+        </div>
+        <div class="Index-node" id="formnd">
+            <form id="f" action='/mkminer' method='POST'>
+                <span>Enter owner/worker address:</span>
+                <input type='text' name='address' style="width: 300px" placeholder="t3...">
+                <select name="sectorSize">
+                    {{range .SectorSizes}}
+                    <option {{if .Default}}selected{{end}} value="{{ .Value }}">{{ .Name }}</option>
+                    {{end}}
+                </select>
+                <button type='submit'>Create Miner</button>
+            </form>
+        </div>
+        <div id="plswait" style="display: none" class="Index-node">
+            <b>Waiting for transaction on chain..</b>
+        </div>
+        <div class="Index-node">
+            <span>When creating miner, DO NOT REFRESH THE PAGE, wait for it to load. This can take more than 5min.</span>
+        </div>
+        <div class="Index-node">
+            <span>If you don't have an owner/worker address, you can create it by following <a target="_blank" href="https://lotu.sh/en+mining#get-started-22083">these instructions</a>.</span>
+        </div>
+    </div>
+    <div class="Index-footer">
+        <div>
+            <a href="index.html">[Back]</a>
+            <span style="float: right">Not dispensing real Filecoin tokens</span>
+        </div>
+    </div>
+</div>
+<script>
+    let f = document.getElementById('f')
+    f.onsubmit = ev => {
+        document.getElementById('plswait').style.display = 'block'
+        document.getElementById('formnd').style.display = 'none'
+    }
+
+</script>
+</body>
+</html>
@@ -13,6 +13,9 @@
        <div class="Index-node">
            <a href="funds.html">[Send Funds]</a>
        </div>
+        <div class="Index-node">
+            <a href="miner.html">[Create Miner]</a>
+        </div>
    </div>
    <div class="Index-footer">
        <div>
@@ -0,0 +1,69 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <title>Creating Miner (wait) - Lotus Fountain</title>
+    <link rel="stylesheet" type="text/css" href="main.css">
+</head>
+<body>
+<div class="Index">
+    <div class="Index-nodes">
+        <div class="Index-node">
+            [CREATING MINER]
+        </div>
+        <div class="Index-node">
+            Gas Funds:&nbsp;&nbsp;&nbsp;<span id="fcid"></span> - <span id="fstate">WAIT</span>
+        </div>
+        <div class="Index-node">
+            Miner Actor:&nbsp;<span id="mcid"></span> - <span id="mstate">WAIT</span>
+        </div>
+        <div class="Index-node" style="display: none" id="fwait">
+            New miners address is: <b id="actaddr">t</b>
+        </div>
+        <div class="Index-node" style="display: none" id="mwait">
+            <div style="padding-bottom: 1em">To initialize the miner run the following command:</div>
+            <div style="overflow-x: visible; white-space: nowrap; background: #353500">
+                <code>lotus-miner init --actor=<span id="actaddr2">t</span> --owner=<span id="owner">t3</span></code>
+            </div>
+        </div>
+    </div>
+    <div class="Index-footer">
+        <div>
+            <a href="index.html">[Back]</a>
+            <span style="float: right">Not dispensing real Filecoin tokens</span>
+        </div>
+    </div>
+</div>
+<script>
+  const params = new URLSearchParams(window.location.search);
+
+  const fcid = document.getElementById('fcid')
+  const mcid = document.getElementById('mcid')
+
+  fcid.innerText = params.get('f')
+  mcid.innerText = params.get('m')
+
+  async function waitFunds() {
+    await fetch('/msgwait?cid=' + params.get('f'))
+    document.getElementById('fstate').innerText = "OK"
+
+    document.getElementById('fwait').style.display = 'block'
+  }
+
+  async function waitMiner() {
+    const resp = await fetch('/msgwaitaddr?cid=' + params.get('f'))
+    document.getElementById('mstate').innerText = "OK"
+
+    const addr = (await resp.json()).addr
+
+    document.getElementById('actaddr').innerText = addr
+    document.getElementById('actaddr2').innerText = addr
+    document.getElementById('owner').innerText = params.get('o')
+
+    document.getElementById('mwait').style.display = 'block'
+  }
+
+  waitFunds()
+  waitMiner()
+</script>
+</body>
+</html>
@@ -54,12 +54,7 @@ func main() {
 		if err != nil {
 			return err
 		}
-		defer func() {
-			err2 := fi.Close()
-			if err == nil {
-				err = err2
-			}
-		}()
+		defer fi.Close()

 		b, err := json.Marshal(ki)
 		if err != nil {
@@ -142,11 +142,11 @@ var runCmd = &cli.Command{
 	},
 	Action: func(cctx *cli.Context) error {
 		go func() {
-			http.ListenAndServe(":6060", nil) //nolint:errcheck
+			http.ListenAndServe(":6060", nil)
 		}()

 		ctx := context.Background()
-		api, closer, err := stats.GetFullNodeAPI(cctx.Context, cctx.String("lotus-path"))
+		api, closer, err := stats.GetFullNodeAPI(cctx.String("lotus-path"))
 		if err != nil {
 			log.Fatal(err)
 		}
@@ -445,7 +445,7 @@ func (r *refunder) Refund(ctx context.Context, tipset *types.TipSet, refunds *Mi
 	// Calculate the minimum balance as the total refund we need to issue plus 5% to cover fees
 	minBalance := types.BigAdd(refundSum, types.BigDiv(refundSum, types.NewInt(500)))
 	if balance.LessThan(minBalance) {
-		log.Errorw("not sufficient funds to cover refunds", "balance", balance, "refund_sum", refundSum, "minimum_required", minBalance)
+		log.Errorw("not sufficent funds to cover refunds", "balance", balance, "refund_sum", refundSum, "minimum_required", minBalance)
 		return xerrors.Errorf("wallet does not have enough balance to cover refund")
 	}

@@ -467,24 +467,24 @@ func (r *refunder) Refund(ctx context.Context, tipset *types.TipSet, refunds *Mi
 	return nil
 }

-type Repo struct {
+type repo struct {
 	last abi.ChainEpoch
 	path string
 }

-func NewRepo(path string) (*Repo, error) {
+func NewRepo(path string) (*repo, error) {
 	path, err := homedir.Expand(path)
 	if err != nil {
 		return nil, err
 	}

-	return &Repo{
+	return &repo{
 		last: 0,
 		path: path,
 	}, nil
 }

-func (r *Repo) exists() (bool, error) {
+func (r *repo) exists() (bool, error) {
 	_, err := os.Stat(r.path)
 	notexist := os.IsNotExist(err)
 	if notexist {
@@ -494,7 +494,7 @@ func (r *Repo) exists() (bool, error) {

 }

-func (r *Repo) init() error {
+func (r *repo) init() error {
 	exist, err := r.exists()
 	if err != nil {
 		return err
@@ -511,7 +511,7 @@ func (r *Repo) init() error {
 	return nil
 }

-func (r *Repo) Open() (err error) {
+func (r *repo) Open() (err error) {
 	if err = r.init(); err != nil {
 		return
 	}
@@ -542,11 +542,11 @@ func (r *Repo) Open() (err error) {
 	return
 }

-func (r *Repo) Height() abi.ChainEpoch {
+func (r *repo) Height() abi.ChainEpoch {
 	return r.last
 }

-func (r *Repo) SetHeight(last abi.ChainEpoch) (err error) {
+func (r *repo) SetHeight(last abi.ChainEpoch) (err error) {
 	r.last = last
 	var f *os.File
 	f, err = os.OpenFile(filepath.Join(r.path, "height"), os.O_RDWR, 0644)
@@ -185,7 +185,7 @@ var runCmd = &cli.Command{
 			return err
 		}
 		if v.APIVersion != build.APIVersion {
-			return xerrors.Errorf("lotus-miner API version doesn't match: local: %s", api.Version{APIVersion: build.APIVersion})
+			return xerrors.Errorf("lotus-miner API version doesn't match: local: ", api.Version{APIVersion: build.APIVersion})
 		}
 		log.Infof("Remote version %s", v)

@@ -420,11 +420,10 @@ func watchMinerConn(ctx context.Context, cctx *cli.Context, nodeApi api.StorageM
 			log.Errorf("getting executable for auto-restart: %+v", err)
 		}

-		_ = log.Sync()
+		log.Sync()

 		// TODO: there are probably cleaner/more graceful ways to restart,
 		//  but this is good enough for now (FSM can recover from the mess this creates)
-		//nolint:gosec
 		if err := syscall.Exec(exe, []string{exe,
 			fmt.Sprintf("--worker-repo=%s", cctx.String("worker-repo")),
 			fmt.Sprintf("--miner-repo=%s", cctx.String("miner-repo")),
@@ -451,7 +450,7 @@ func extractRoutableIP(timeout time.Duration) (string, error) {
 	env, ok := os.LookupEnv(minerMultiAddrKey)
 	if !ok {
 		// TODO remove after deprecation period
-		_, ok = os.LookupEnv(deprecatedMinerMultiAddrKey)
+		env, ok = os.LookupEnv(deprecatedMinerMultiAddrKey)
 		if ok {
 			log.Warnf("Using a deprecated env(%s) value, please use env(%s) instead.", deprecatedMinerMultiAddrKey, minerMultiAddrKey)
 		}
@@ -462,7 +461,7 @@ func extractRoutableIP(timeout time.Duration) (string, error) {
 	if err != nil {
 		return "", err
 	}
-	defer conn.Close() //nolint:errcheck
+	defer conn.Close()

 	localAddr := conn.LocalAddr().(*net.TCPAddr)

@@ -114,9 +114,6 @@ var preSealCmd = &cli.Command{
 				return err
 			}
 			kb, err := hex.DecodeString(string(kh))
-			if err != nil {
-				return err
-			}
 			if err := json.Unmarshal(kb, k); err != nil {
 				return err
 			}
@@ -1,160 +0,0 @@
-package main
-
-import (
-	"context"
-	"fmt"
-	"os"
-	"sort"
-
-	"github.com/fatih/color"
-	"github.com/ipfs/go-datastore"
-	cbor "github.com/ipfs/go-ipld-cbor"
-	"github.com/urfave/cli/v2"
-	"golang.org/x/xerrors"
-
-	"github.com/filecoin-project/go-address"
-	"github.com/filecoin-project/lotus/build"
-	"github.com/filecoin-project/lotus/chain/state"
-	"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/specs-actors/actors/abi/big"
-	"github.com/filecoin-project/specs-actors/actors/builtin"
-	saacc "github.com/filecoin-project/specs-actors/actors/builtin/account"
-	saminer "github.com/filecoin-project/specs-actors/actors/builtin/miner"
-	samsig "github.com/filecoin-project/specs-actors/actors/builtin/multisig"
-)
-
-type addrInfo struct {
-	Key     address.Address
-	Balance types.FIL
-}
-
-type msigInfo struct {
-	Signers   []address.Address
-	Balance   types.FIL
-	Threshold uint64
-}
-
-type minerInfo struct {
-}
-
-var genesisVerifyCmd = &cli.Command{
-	Name:        "verify-genesis",
-	Description: "verify some basic attributes of a genesis car file",
-	Action: func(cctx *cli.Context) error {
-		if !cctx.Args().Present() {
-			return fmt.Errorf("must pass genesis car file")
-		}
-		bs := blockstore.NewBlockstore(datastore.NewMapDatastore())
-
-		cs := store.NewChainStore(bs, datastore.NewMapDatastore(), nil)
-
-		cf := cctx.Args().Get(0)
-		f, err := os.Open(cf)
-		if err != nil {
-			return xerrors.Errorf("opening the car file: %w", err)
-		}
-
-		ts, err := cs.Import(f)
-		if err != nil {
-			return err
-		}
-
-		sm := stmgr.NewStateManager(cs)
-
-		total, err := stmgr.CheckTotalFIL(context.TODO(), sm, ts)
-		if err != nil {
-			return err
-		}
-
-		fmt.Println("Genesis: ", ts.Key())
-		expFIL := big.Mul(big.NewInt(int64(build.FilBase)), big.NewInt(int64(build.FilecoinPrecision)))
-		fmt.Printf("Total FIL: %s", types.FIL(total))
-		if !expFIL.Equals(total) {
-			color.Red("  INCORRECT!")
-		}
-		fmt.Println()
-
-		cst := cbor.NewCborStore(bs)
-
-		stree, err := state.LoadStateTree(cst, ts.ParentState())
-		if err != nil {
-			return err
-		}
-
-		var accAddrs, msigAddrs []address.Address
-		kaccounts := make(map[address.Address]addrInfo)
-		kmultisigs := make(map[address.Address]msigInfo)
-		kminers := make(map[address.Address]minerInfo)
-
-		ctx := context.TODO()
-
-		if err := stree.ForEach(func(addr address.Address, act *types.Actor) error {
-			switch act.Code {
-			case builtin.StorageMinerActorCodeID:
-				var st saminer.State
-				if err := cst.Get(ctx, act.Head, &st); err != nil {
-					return err
-				}
-
-				kminers[addr] = minerInfo{}
-			case builtin.MultisigActorCodeID:
-				var st samsig.State
-				if err := cst.Get(ctx, act.Head, &st); err != nil {
-					return xerrors.Errorf("multisig actor: %w", err)
-				}
-
-				kmultisigs[addr] = msigInfo{
-					Balance:   types.FIL(act.Balance),
-					Signers:   st.Signers,
-					Threshold: st.NumApprovalsThreshold,
-				}
-				msigAddrs = append(msigAddrs, addr)
-			case builtin.AccountActorCodeID:
-				var st saacc.State
-				if err := cst.Get(ctx, act.Head, &st); err != nil {
-					log.Warn(xerrors.Errorf("account actor %s: %w", addr, err))
-				}
-
-				kaccounts[addr] = addrInfo{
-					Key:     st.Address,
-					Balance: types.FIL(act.Balance.Copy()),
-				}
-				accAddrs = append(accAddrs, addr)
-			}
-			return nil
-		}); err != nil {
-			return err
-		}
-
-		sort.Slice(accAddrs, func(i, j int) bool {
-			return accAddrs[i].String() < accAddrs[j].String()
-		})
-
-		sort.Slice(msigAddrs, func(i, j int) bool {
-			return msigAddrs[i].String() < msigAddrs[j].String()
-		})
-
-		fmt.Println("Account Actors:")
-		for _, acc := range accAddrs {
-			a := kaccounts[acc]
-			fmt.Printf("%s\t%s\t%s\n", acc, a.Key, a.Balance)
-		}
-
-		fmt.Println("Multisig Actors:")
-		for _, acc := range msigAddrs {
-			m := kmultisigs[acc]
-			fmt.Printf("%s\t%s\t%d\t[", acc, m.Balance, m.Threshold)
-			for i, s := range m.Signers {
-				fmt.Print(s)
-				if i != len(m.Signers)-1 {
-					fmt.Print(",")
-				}
-			}
-			fmt.Printf("]\n")
-		}
-		return nil
-	},
-}
@@ -69,7 +69,7 @@ var keyinfoImportCmd = &cli.Command{
 			if err != nil {
 				return err
 			}
-			defer inputFile.Close() //nolint:errcheck
+			defer inputFile.Close()
 			input = bufio.NewReader(inputFile)
 		}

@@ -98,7 +98,7 @@ var keyinfoImportCmd = &cli.Command{
 			return err
 		}

-		defer lkrepo.Close() //nolint:errcheck
+		defer lkrepo.Close()

 		keystore, err := lkrepo.KeyStore()
 		if err != nil {
@@ -150,7 +150,7 @@ var keyinfoInfoCmd = &cli.Command{

   The 'format' flag takes a golang text/template template as its value.

-   The following fields can be retrieved through this command
+   The following fields can be retrived through this command
     Type
     Address
     PublicKey
@@ -159,7 +159,7 @@ var keyinfoInfoCmd = &cli.Command{

   Examples

-   Retrieve the address of a lotus wallet
+   Retreive the address of a lotus wallet
   lotus-shed keyinfo info --format '{{ .Address }}' wallet.keyinfo
   `,
 	Flags: []cli.Flag{
@@ -181,7 +181,7 @@ var keyinfoInfoCmd = &cli.Command{
 			if err != nil {
 				return err
 			}
-			defer inputFile.Close() //nolint:errcheck
+			defer inputFile.Close()
 			input = bufio.NewReader(inputFile)
 		}

@@ -30,7 +30,6 @@ func main() {
 		verifRegCmd,
 		miscCmd,
 		mpoolCmd,
-		genesisVerifyCmd,
 	}

 	app := &cli.App{
@@ -56,7 +56,7 @@ func main() {
 		height = h
 	}

-	api, closer, err := stats.GetFullNodeAPI(ctx, repo)
+	api, closer, err := stats.GetFullNodeAPI(repo)
 	if err != nil {
 		log.Fatal(err)
 	}
@@ -137,7 +137,7 @@ var actorSetPeeridCmd = &cli.Command{

 		ctx := lcli.ReqContext(cctx)

-		pid, err := peer.Decode(cctx.Args().Get(0))
+		pid, err := peer.IDFromString(cctx.Args().Get(0))
 		if err != nil {
 			return fmt.Errorf("failed to parse input as a peerId: %w", err)
 		}
@@ -11,22 +11,14 @@ import (
 	"github.com/urfave/cli/v2"
 	"golang.org/x/xerrors"

-	cbor "github.com/ipfs/go-ipld-cbor"
-
-	"github.com/filecoin-project/go-fil-markets/storagemarket"
 	sealing "github.com/filecoin-project/lotus/extern/storage-sealing"
-	"github.com/filecoin-project/specs-actors/actors/abi"
 	"github.com/filecoin-project/specs-actors/actors/builtin/miner"
 	"github.com/filecoin-project/specs-actors/actors/builtin/power"
-	"github.com/filecoin-project/specs-actors/actors/util/adt"

 	"github.com/filecoin-project/lotus/api"
-	"github.com/filecoin-project/lotus/api/apibstore"
 	"github.com/filecoin-project/lotus/build"
 	"github.com/filecoin-project/lotus/chain/types"
 	lcli "github.com/filecoin-project/lotus/cli"
-	"github.com/filecoin-project/lotus/lib/blockstore"
-	"github.com/filecoin-project/lotus/lib/bufbstore"
 )

 var infoCmd = &cli.Command{
@@ -55,11 +47,6 @@ func infoCmdAct(cctx *cli.Context) error {

 	ctx := lcli.ReqContext(cctx)

-	head, err := api.ChainHead(ctx)
-	if err != nil {
-		return xerrors.Errorf("getting chain head: %w", err)
-	}
-
 	maddr, err := getActorAddress(ctx, nodeApi, cctx.String("actor"))
 	if err != nil {
 		return err
@@ -154,43 +141,11 @@ func infoCmdAct(cctx *cli.Context) error {

 	fmt.Println()

-	deals, err := nodeApi.MarketListIncompleteDeals(ctx)
-	if err != nil {
-		return err
-	}
-
-	var nactiveDeals, nVerifDeals, ndeals uint64
-	var activeDealBytes, activeVerifDealBytes, dealBytes abi.PaddedPieceSize
-	for _, deal := range deals {
-		ndeals++
-		dealBytes += deal.Proposal.PieceSize
-
-		if deal.State == storagemarket.StorageDealActive {
-			nactiveDeals++
-			activeDealBytes += deal.Proposal.PieceSize
-
-			if deal.Proposal.VerifiedDeal {
-				nVerifDeals++
-				activeVerifDealBytes += deal.Proposal.PieceSize
-			}
-		}
-	}
-
-	fmt.Printf("Deals: %d, %s\n", ndeals, types.SizeStr(types.NewInt(uint64(dealBytes))))
-	fmt.Printf("\tActive: %d, %s (Verified: %d, %s)\n", nactiveDeals, types.SizeStr(types.NewInt(uint64(activeDealBytes))), nVerifDeals, types.SizeStr(types.NewInt(uint64(activeVerifDealBytes))))
-	fmt.Println()
-
-	tbs := bufbstore.NewTieredBstore(apibstore.NewAPIBlockstore(api), blockstore.NewTemporary())
-	_, err = mas.UnlockVestedFunds(adt.WrapStore(ctx, cbor.NewCborStore(tbs)), head.Height())
-	if err != nil {
-		return xerrors.Errorf("calculating vested funds: %w", err)
-	}
-
 	fmt.Printf("Miner Balance: %s\n", color.YellowString("%s", types.FIL(mact.Balance)))
 	fmt.Printf("\tPreCommit:   %s\n", types.FIL(mas.PreCommitDeposits))
 	fmt.Printf("\tPledge:      %s\n", types.FIL(mas.InitialPledgeRequirement))
 	fmt.Printf("\tLocked:      %s\n", types.FIL(mas.LockedFunds))
-	color.Green("\tAvailable:   %s", types.FIL(mas.GetAvailableBalance(mact.Balance)))
+	color.Green("\tAvailable:   %s", types.FIL(types.BigSub(mact.Balance, types.BigAdd(mas.LockedFunds, mas.PreCommitDeposits))))
 	wb, err := api.WalletBalance(ctx, mi.Worker)
 	if err != nil {
 		return xerrors.Errorf("getting worker balance: %w", err)
@@ -126,9 +126,7 @@ var infoAllCmd = &cli.Command{

 			fs := &flag.FlagSet{}
 			for _, f := range sectorsStatusCmd.Flags {
-				if err := f.Apply(fs); err != nil {
-					return err
-				}
+				f.Apply(fs)
 			}
 			if err := fs.Parse([]string{"--log", "--on-chain-info", fmt.Sprint(s)}); err != nil {
 				return err
@@ -183,13 +183,13 @@ var provingInfoCmd = &cli.Command{

 				fc, err := partition.Faults.Count()
 				if err != nil {
-					return xerrors.Errorf("count partition faults: %w", err)
+					return xerrors.Errorf("count partition sectors: %w", err)
 				}
 				faults += fc

-				rc, err := partition.Recoveries.Count()
+				rc, err := partition.Faults.Count()
 				if err != nil {
-					return xerrors.Errorf("count partition recoveries: %w", err)
+					return xerrors.Errorf("count partition sectors: %w", err)
 				}
 				recovering += rc
 			}
@@ -10,7 +10,7 @@ import (

 	mux "github.com/gorilla/mux"
 	"github.com/multiformats/go-multiaddr"
-	manet "github.com/multiformats/go-multiaddr/net"
+	manet "github.com/multiformats/go-multiaddr-net"
 	"github.com/urfave/cli/v2"
 	"golang.org/x/xerrors"

@@ -53,10 +53,7 @@ var runCmd = &cli.Command{
 	},
 	Action: func(cctx *cli.Context) error {
 		if !cctx.Bool("enable-gpu-proving") {
-			err := os.Setenv("BELLMAN_NO_GPU", "true")
-			if err != nil {
-				return err
-			}
+			os.Setenv("BELLMAN_NO_GPU", "true")
 		}

 		nodeApi, ncloser, err := lcli.GetFullNodeAPI(cctx)
@@ -3,14 +3,13 @@ package main
 import (
 	"encoding/json"
 	"fmt"
+	"golang.org/x/xerrors"
 	"os"
 	"sort"
 	"strings"
 	"text/tabwriter"
 	"time"

-	"golang.org/x/xerrors"
-
 	"github.com/fatih/color"
 	"github.com/urfave/cli/v2"

@@ -2,14 +2,13 @@ package main

 import (
 	"fmt"
+	"github.com/filecoin-project/specs-actors/actors/builtin/miner"
 	"os"
 	"sort"
 	"strconv"
 	"text/tabwriter"
 	"time"

-	"github.com/filecoin-project/specs-actors/actors/builtin/miner"
-
 	"github.com/urfave/cli/v2"
 	"golang.org/x/xerrors"

@@ -193,7 +192,7 @@ var sectorsListCmd = &cli.Command{
 			_, inSSet := commitedIDs[s]
 			_, inASet := activeIDs[s]

-			fmt.Fprintf(w, "%d: %s\tsSet: %s\tactive: %s\ttktH: %d\tseedH: %d\tdeals: %v\t toUpgrade:%t\n",
+			fmt.Fprintf(w, "%d: %s\tsSet: %s\tactive: %s\ttktH: %d\tseedH: %d\tdeals: %v\n",
 				s,
 				st.State,
 				yesno(inSSet),
@@ -201,7 +200,6 @@ var sectorsListCmd = &cli.Command{
 				st.Ticket.Epoch,
 				st.Seed.Epoch,
 				st.Deals,
-				st.ToUpgrade,
 			)
 		}

@@ -106,11 +106,10 @@ func handler(ps *pubsub.PubSub) func(w http.ResponseWriter, r *http.Request) {
 			return
 		}

-		sub, err := ps.Subscribe(topic) //nolint
+		sub, err := ps.Subscribe(topic)
 		if err != nil {
 			return
 		}
-		defer sub.Cancel() //nolint:errcheck

 		fmt.Println("new conn")

@@ -12,7 +12,7 @@ import (
 	"github.com/ipfs/go-cid"
 	logging "github.com/ipfs/go-log/v2"
 	"github.com/multiformats/go-multiaddr"
-	manet "github.com/multiformats/go-multiaddr/net"
+	manet "github.com/multiformats/go-multiaddr-net"
 	"golang.org/x/xerrors"

 	"contrib.go.opencensus.io/exporter/prometheus"
@@ -175,12 +175,6 @@
          "github": "en/api-scripting-support.md",
          "value": null
        },
-        {
-          "title": "API Methods",
-          "slug": "en+api-methods",
-          "github": "en/api-methods.md",
-          "value": null
-        },
        {
          "title": "API Troubleshooting",
          "slug": "en+api-troubleshooting",
@@ -48,11 +48,6 @@ block heights that are very far from the current chain height, you may want to
 increase this.


-### `LOTUS_BSYNC_MSG_WINDOW`
-
-Set the initial maximum window size for message fetching blocksync requests. If
-you have a slower internet connection and are having trouble syncing, you might
-try lowering this down to 10-20 for a 'poor' internet connection.

 ## Lotus Miner

@@ -58,8 +58,8 @@ t1aswwvjsae63tcrniz6x5ykvsuotlgkvlulnqpsi
 ```

 - Visit the [faucet](http://spacerace.faucet.glif.io/) to add funds.
- Paste the address you created under REQUEST.
- Press the Request button.
+- Paste the address you created.
+- Press the send button.

 ## Check wallet address balance

@@ -29,9 +29,28 @@ lotus wallet new bls
 With your wallet address:

 - Visit the [faucet](http://spacerace.faucet.glif.io/)
- Paste the address you created under REQUEST.
- Press the Request button.
- Run `/lotus-miner init --owner=<blsAddress> --worker=<blsAddress>`
+- Click "Create Miner"
+- DO NOT REFRESH THE PAGE. THIS OPERATION CAN TAKE SOME TIME.
+
+The task will be complete when you see:
+
+```sh
+New miners address is: <YOUR_NEW_MINING_ADDRESS>
+```
+
+## Initialize the miner
+
+In a CLI window, use the following command to start your miner:
+
+```sh
+lotus-miner init --actor=ACTOR_VALUE_RECEIVED --owner=OWNER_VALUE_RECEIVED
+```
+
+Example
+
+```sh
+lotus-miner init --actor=t01424 --owner=t3spmep2xxsl33o4gxk7yjxcobyohzgj3vejzerug25iinbznpzob6a6kexcbeix73th6vjtzfq7boakfdtd6a
+```

 You will have to wait some time for this operation to complete.

@@ -118,7 +118,7 @@ func openPartialFile(maxPieceSize abi.PaddedPieceSize, path string) (*partialFil
 		trailerLen := binary.LittleEndian.Uint32(tlen[:])
 		expectLen := int64(trailerLen) + int64(len(tlen)) + int64(maxPieceSize)
 		if expectLen != st.Size() {
-			return xerrors.Errorf("file '%s' has inconsistent length; has %d bytes; expected %d (%d trailer, %d sector data)", path, st.Size(), expectLen, int64(trailerLen)+int64(len(tlen)), maxPieceSize)
+			return xerrors.Errorf("file '%d' has inconsistent length; has %d bytes; expected %d (%d trailer, %d sector data)", path, st.Size(), expectLen, int64(trailerLen)+int64(len(tlen)), maxPieceSize)
 		}
 		if trailerLen > veryLargeRle {
 			log.Warnf("Partial file '%s' has a VERY large trailer with %d bytes", path, trailerLen)
@@ -12,8 +12,6 @@ func Statfs(path string) (FsStat, error) {
 		return FsStat{}, xerrors.Errorf("statfs: %w", err)
 	}

-	// force int64 to handle platform specific differences
-	//nolint:unconvert
 	return FsStat{
 		Capacity:  int64(stat.Blocks) * int64(stat.Bsize),
 		Available: int64(stat.Bavail) * int64(stat.Bsize),
@@ -438,7 +438,7 @@ func (m mockVerif) VerifyWindowPoSt(ctx context.Context, info abi.WindowPoStVeri
 		}

 		if !bytes.Equal(b1, b2) {
-			return false, xerrors.Errorf("proven and challenged sector sets didn't match: %s != %s", string(b1), string(b2))
+			return false, xerrors.Errorf("proven and challenged sector sets didn't match: %s != !s", string(b1), string(b2))
 		}
 	}

--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
whyrusleeping	e6f454ac33	fix setup of burnt funds actor state	2020-08-24 18:45:09 +00:00
whyrusleeping	ee20eec451	randomize ticket in genesis creation	2020-08-24 18:40:51 +00:00