Lint everything

We were ignoring quite a few error cases, and had one case where we weren't actually updating state where we wanted to. Unfortunately, if the linter doesn't pass, nobody has any reason to actually check lint failures in CI. There are three remaining XXXs marked in the code for lint.
2020-08-19 21:49:10 -07:00 · 2020-08-19 21:49:10 -07:00 · 5733c71c50
commit 5733c71c50
parent 659babc6b3
95 changed files with 372 additions and 347 deletions
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@ -288,9 +288,6 @@ jobs:
          command: |
            $HOME/.local/bin/golangci-lint run -v --timeout 2m \
              --concurrency << parameters.concurrency >> << parameters.args >>
-  lint-changes:
-    <<: *lint
-
  lint-all:
    <<: *lint

@ -319,8 +316,7 @@ workflows:
  version: 2.1
  ci:
    jobs:
-      - lint-changes:
-          args: "--new-from-rev origin/next"
+      - lint-all
      - mod-tidy-check
      - gofmt
      - test:
--- a/.golangci.yml
+++ b/.golangci.yml
@ -23,6 +23,14 @@ 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:
@ -46,6 +54,19 @@ 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
--- a/api/docgen/docgen.go
+++ b/api/docgen/docgen.go
@ -26,7 +26,7 @@ import (
 	"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/libp2p/go-libp2p-core/peer"
 	"github.com/multiformats/go-multiaddr"
 )

@ -66,7 +66,7 @@ func init() {

 	ExampleValues[reflect.TypeOf(addr)] = addr

-	pid, err := peer.IDB58Decode("12D3KooWGzxzKZYveHXtpG6AsrUJBcWxHBFS2HsEoGTxrMLvKXtf")
+	pid, err := peer.Decode("12D3KooWGzxzKZYveHXtpG6AsrUJBcWxHBFS2HsEoGTxrMLvKXtf")
 	if err != nil {
 		panic(err)
 	}
--- a/api/test/deals.go
+++ b/api/test/deals.go
@ -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, err, client, fcid, &info.PieceCID, carExport, data)
+	testRetrieval(t, ctx, 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, err, client, fcid, &info.PieceCID, false, data)
+	testRetrieval(t, ctx, 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, err, client, fcid2, &info.PieceCID, false, data2)
+		testRetrieval(t, ctx, 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, err error, client *impl.FullNodeAPI, fcid cid.Cid, piece *cid.Cid, carExport bool, data []byte) {
+func testRetrieval(t *testing.T, ctx context.Context, 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)
--- a/api/test/mining.go
+++ b/api/test/mining.go
@ -20,6 +20,7 @@ import (
 	"github.com/filecoin-project/lotus/node/impl"
 )

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

 func (ts *testSuite) testMining(t *testing.T) {
--- a/api/test/paych.go
+++ b/api/test/paych.go
@ -153,6 +153,9 @@ 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:
--- a/api/test/window_post.go
+++ b/api/test/window_post.go
@ -24,9 +24,14 @@ import (
 	"github.com/filecoin-project/lotus/node/impl"
 )

-func TestPledgeSector(t *testing.T, b APIBuilder, blocktime time.Duration, nSectors int) {
-	os.Setenv("BELLMAN_NO_GPU", "1")
+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) {
 	ctx := context.Background()
 	n, sn := b(t, 1, OneMiner)
 	client := n[0].FullNode.(*impl.FullNodeAPI)
@ -110,8 +115,6 @@ 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)
--- a/chain/block_receipt_tracker.go
+++ b/chain/block_receipt_tracker.go
@ -7,8 +7,8 @@ import (

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

 type blockReceiptTracker struct {
--- a/chain/blocksync/client.go
+++ b/chain/blocksync/client.go
@ -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: %s", res.Status)
+		return nil, xerrors.Errorf("got less than requested without a proper status: %d", 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): %w", i)
+				return nil, xerrors.Errorf("no messages included for tipset at height (head - %d)", i)
 			}
 			validRes.messages[i] = res.Chain[i].Messages
 		}
--- a/chain/blocksync/protocol.go
+++ b/chain/blocksync/protocol.go
@ -1,9 +1,10 @@
 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"
--- a/chain/events/state/diff_adt.go
+++ b/chain/events/state/diff_adt.go
@ -2,6 +2,7 @@ package state

 import (
 	"bytes"
+
 	"github.com/filecoin-project/specs-actors/actors/util/adt"
 	typegen "github.com/whyrusleeping/cbor-gen"
 )
--- a/chain/events/state/predicates.go
+++ b/chain/events/state/predicates.go
@ -3,6 +3,7 @@ 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"
--- a/chain/events/state/predicates_test.go
+++ b/chain/events/state/predicates_test.go
@ -114,10 +114,10 @@ func TestMarketPredicates(t *testing.T) {
 	}

 	oldBalances := map[address.Address]balance{
-		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)},
+		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)},
 	}

 	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): 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)},
+		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)},
 	}

 	newStateC := createMarketState(ctx, t, store, newDeals, newProps, newBalances)
@ -505,6 +505,7 @@ 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))
@ -542,6 +543,7 @@ 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)
--- a/chain/gen/gen.go
+++ b/chain/gen/gen.go
@ -41,10 +41,11 @@ import (
 	"github.com/filecoin-project/lotus/node/repo"
 )

-var log = logging.Logger("gen")
-
 const msgsPerBlock = 20

+//nolint:deadcode,varcheck
+var log = logging.Logger("gen")
+
 var ValidWpostForTesting = []abi.PoStProof{{
 	ProofBytes: []byte("valid proof"),
 }}
@ -605,7 +606,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")
+		return nil, xerrors.Errorf("failed to cbor marshal address: %w", err)
 	}

 	electionRand, err := store.DrawRandomness(brand.Data, crypto.DomainSeparationTag_ElectionProofProduction, round, buf.Bytes())
--- a/chain/gen/genesis/miners.go
+++ b/chain/gen/genesis/miners.go
@ -129,6 +129,9 @@ 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
@ -217,9 +220,12 @@ 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 {
@ -244,7 +250,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)
+					st.TotalQualityAdjPower = types.BigSub(st.TotalQualityAdjPower, sectorWeight) //nolint:scopelint
 					st.TotalRawBytePower = types.BigSub(st.TotalRawBytePower, types.NewInt(uint64(m.SectorSize)))
 					return nil
 				})
--- a/chain/gen/genesis/util.go
+++ b/chain/gen/genesis/util.go
@ -21,10 +21,6 @@ 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 {
--- a/chain/market/fundmgr_test.go
+++ b/chain/market/fundmgr_test.go
@ -147,6 +147,7 @@ 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()
--- a/chain/messagepool/block_proba.go
+++ b/chain/messagepool/block_proba.go
@ -56,7 +56,7 @@ func binomialCoefficient(n, k float64) float64 {
 	for d := 1.0; d <= k; d++ {
 		r *= n
 		r /= d
-		n -= 1
+		n--
 	}
 	return r
 }
--- a/chain/messagepool/provider.go
+++ b/chain/messagepool/provider.go
@ -43,7 +43,7 @@ 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)
+	return mpp.ps.Publish(k, v) //nolint
 }

 func (mpp *mpoolProvider) StateGetActor(addr address.Address, ts *types.TipSet) (*types.Actor, error) {
--- a/chain/metrics/consensus.go
+++ b/chain/metrics/consensus.go
@ -44,7 +44,7 @@ func SendHeadNotifs(nickname string) func(mctx helpers.MetricsCtx, lc fx.Lifecyc
 					}
 				}()
 				go func() {
-					sub, err := ps.Subscribe(topic)
+					sub, err := ps.Subscribe(topic) //nolint
 					if err != nil {
 						return
 					}
@ -116,6 +116,7 @@ func sendHeadNotifs(ctx context.Context, ps *pubsub.PubSub, topic string, chain
 				return err
 			}

+			//nolint
 			if err := ps.Publish(topic, b); err != nil {
 				return err
 			}
--- a/chain/state/statetree.go
+++ b/chain/state/statetree.go
@ -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")
+	ctx, span := trace.StartSpan(ctx, "stateTree.Flush") //nolint:staticcheck
 	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")
+	ctx, span := trace.StartSpan(ctx, "stateTree.SnapShot") //nolint:staticcheck
 	defer span.End()

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

 	// Put 113 blocks from genesis
 	for i := 0; i < 113; i++ {
--- a/chain/store/store.go
+++ b/chain/store/store.go
@ -925,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", err, c, i)
+			return nil, xerrors.Errorf("failed to get message: (%s):%d: %w", c, i, err)
 		}

 		msgs = append(msgs, m)
@ -939,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", err, c, i)
+			return nil, xerrors.Errorf("failed to get message: (%s):%d: %w", c, i, err)
 		}

 		msgs = append(msgs, m)
--- a/chain/sub/incoming.go
+++ b/chain/sub/incoming.go
@ -292,11 +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
 	}
-	}

 	err = sigs.CheckBlockSignature(ctx, blk.Header, key)
 	if err != nil {
--- a/chain/sync_manager.go
+++ b/chain/sync_manager.go
@ -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?
-		}
+		log.Error("failed to sync chain but have new unconnected blocks from chain")
 	}

 	if sm.nextSyncTarget == nil && !sm.syncQueue.Empty() {
--- a/chain/sync_test.go
+++ b/chain/sync_test.go
@ -3,11 +3,12 @@ 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"
@ -36,7 +37,10 @@ import (

 func init() {
 	build.InsecurePoStValidation = true
-	os.Setenv("TRUST_PARAMS", "1")
+	err := os.Setenv("TRUST_PARAMS", "1")
+	if err != nil {
+		panic(err)
+	}
 	miner.SupportedProofTypes = map[abi.RegisteredSealProof]struct{}{
 		abi.RegisteredSealProof_StackedDrg2KiBV1: {},
 	}
@ -212,20 +216,6 @@ 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")
@ -454,7 +444,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"),
 		},
@ -587,7 +577,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])}
 	}

--- a/chain/types/signedmessage.go
+++ b/chain/types/signedmessage.go
@ -62,8 +62,8 @@ func (sm *SignedMessage) Serialize() ([]byte, error) {
 	return buf.Bytes(), nil
 }

-func (m *SignedMessage) ChainLength() int {
-	ser, err := m.Serialize()
+func (sm *SignedMessage) ChainLength() int {
+	ser, err := sm.Serialize()
 	if err != nil {
 		panic(err)
 	}
--- a/chain/types/tipset.go
+++ b/chain/types/tipset.go
@ -238,3 +238,7 @@ 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)
+}
--- a/chain/validation/factories.go
+++ b/chain/validation/factories.go
@ -2,6 +2,7 @@ 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"
--- a/chain/validation/keymanager.go
+++ b/chain/validation/keymanager.go
@ -2,9 +2,10 @@ package validation

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

+	"github.com/minio/blake2b-simd"
+
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-crypto"
 	acrypto "github.com/filecoin-project/specs-actors/actors/crypto"
--- a/chain/vectors/vectors_test.go
+++ b/chain/vectors/vectors_test.go
@ -18,7 +18,7 @@ func LoadVector(t *testing.T, f string, out interface{}) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	defer fi.Close()
+	defer fi.Close() //nolint:errcheck

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

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

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

 	c := ssh.rt.Put(obj)

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

 func (rt *Runtime) GetBalance(a address.Address) (types.BigInt, aerrors.ActorError) {
--- a/chain/vm/vm.go
+++ b/chain/vm/vm.go
@ -254,6 +254,9 @@ 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 {
--- a/cli/auth.go
+++ b/cli/auth.go
@ -2,6 +2,7 @@ package cli

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

--- a/cli/chain.go
+++ b/cli/chain.go
@ -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(api, ctx, cctx.Args().Slice())
+			ts, err = parseTipSet(ctx, api, cctx.Args().Slice())
 		}
 		if err != nil {
 			return err
@ -337,7 +337,7 @@ var chainSetHeadCmd = &cli.Command{
 	},
 }

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

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

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

 		ask, err := api.ClientQueryAsk(ctx, pid, maddr)
@ -1045,7 +1045,8 @@ 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"),
@ -1093,7 +1094,6 @@ var clientListDeals = &cli.Command{
 		}

 		return w.Flush(os.Stdout)
-		}
 	},
 }

@ -1318,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)
+	w.Flush(out) //nolint:errcheck

 	fmt.Fprintf(out, "\nReceiving Channels\n\n")
 	w = tablewriter.New(tablewriter.Col("ID"),
@ -1332,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)
+	w.Flush(out) //nolint:errcheck
 }

 func channelStatusString(useColor bool, status datatransfer.Status) string {
--- a/cli/helper.go
+++ b/cli/helper.go
@ -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)
 	}
--- a/cli/mpool.go
+++ b/cli/mpool.go
@ -313,7 +313,7 @@ var mpoolReplaceCmd = &cli.Command{
 		if err != nil {
 			return fmt.Errorf("parsing gas-premium: %w", err)
 		}
-		// TODO: estiamte fee cap here
+		// TODO: estimate fee cap here
 		msg.GasFeeCap, err = types.BigFromString(cctx.String("gas-feecap"))
 		if err != nil {
 			return fmt.Errorf("parsing gas-feecap: %w", err)
--- a/cli/net.go
+++ b/cli/net.go
@ -180,7 +180,7 @@ var netFindPeer = &cli.Command{
 			return nil
 		}

-		pid, err := peer.IDB58Decode(cctx.Args().First())
+		pid, err := peer.Decode(cctx.Args().First())
 		if err != nil {
 			return err
 		}
--- a/cli/pprof.go
+++ b/cli/pprof.go
@ -44,7 +44,7 @@ var PprofGoroutines = &cli.Command{

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

-		r, err := http.Get(addr)
+		r, err := http.Get(addr) //nolint:gosec
 		if err != nil {
 			return err
 		}
--- a/cli/state.go
+++ b/cli/state.go
@ -353,6 +353,9 @@ 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)
@ -365,10 +368,10 @@ var stateReplaySetCmd = &cli.Command{
 					return xerrors.Errorf("loading tipset: %w", err)
 				}
 				ts, err = fapi.ChainGetTipSet(ctx, childTs.Parents())
-			}
 				if err != nil {
 					return err
 				}
+			}

 		}

@ -1499,7 +1502,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.IDB58Decode(args[i])
+			pid, err := peer.Decode(args[i])
 			if err != nil {
 				return nil, fmt.Errorf("failed to parse peer ID: %s", err)
 			}
@ -1584,6 +1587,9 @@ 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))
--- a/cli/wallet.go
+++ b/cli/wallet.go
@ -385,10 +385,9 @@ 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")
-		}
 	},
 }

--- a/cmd/lotus-bench/import.go
+++ b/cmd/lotus-bench/import.go
@ -214,7 +214,7 @@ func countGasCosts(et *types.ExecutionTrace) (int64, int64) {
 	}

 	for _, sub := range et.Subcalls {
-		c, v := countGasCosts(&sub)
+		c, v := countGasCosts(&sub) //nolint
 		cgas += c
 		vgas += v
 	}
@ -222,24 +222,6 @@ 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
@ -264,20 +246,20 @@ func (cov1 *covar) VarianceX() float64 {
 	return cov1.m2x / (cov1.n - 1)
 }

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

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

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

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

 	dx := x - cov1.meanX
 	cov1.meanX += dx / cov1.n
@ -344,7 +326,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 += 1
+	v1.n++
 	delta := value - v1.mean
 	v1.mean += delta / v1.n
 	delta2 := value - v1.mean
@ -481,7 +463,7 @@ var importAnalyzeCmd = &cli.Command{
 		}

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

 		fi, err := os.Open(cctx.Args().First())
--- a/cmd/lotus-chainwatch/processor/reward.go
+++ b/cmd/lotus-chainwatch/processor/reward.go
@ -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)
+	grp, ctx := errgroup.WithContext(ctx) //nolint

 	grp.Go(func() error {
 		if err := p.storeChainPower(rewards); err != nil {
--- a/cmd/lotus-chainwatch/run.go
+++ b/cmd/lotus-chainwatch/run.go
@ -29,7 +29,7 @@ var runCmd = &cli.Command{
 	},
 	Action: func(cctx *cli.Context) error {
 		go func() {
-			http.ListenAndServe(":6060", nil)
+			http.ListenAndServe(":6060", nil) //nolint:errcheck
 		}()
 		ll := cctx.String("log-level")
 		if err := logging.SetLogLevel("*", ll); err != nil {
--- a/cmd/lotus-chainwatch/scheduler/refresh_top_miners_by_base_reward.go
+++ b/cmd/lotus-chainwatch/scheduler/refresh_top_miners_by_base_reward.go
@ -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", err)
+		return xerrors.Errorf("create top_miner_by_base_reward views: %w", err)
 	}

 	if err := tx.Commit(); err != nil {
-		return xerrors.Errorf("commiting top_miner_by_base_reward views", err)
+		return xerrors.Errorf("committing top_miner_by_base_reward views; %w", err)
 	}
 	return nil
 }
--- a/cmd/lotus-chainwatch/scheduler/scheduler.go
+++ b/cmd/lotus-chainwatch/scheduler/scheduler.go
@ -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", err)
+		return xerrors.Errorf("setup top miners by reward schema: %w", 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", err)
+		log.Fatalw("applying scheduling schema", "error", 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.Errorf(err.Error())
+			log.Errorw("failed to refresh top miner", "error", err)
 		}
 		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.Errorf(err.Error())
+					log.Errorw("failed to refresh top miner", "error", err)
 				}
 			case <-ctx.Done():
 				return
--- a/cmd/lotus-fountain/main.go
+++ b/cmd/lotus-fountain/main.go
@ -47,7 +47,7 @@ var supportedSectors struct {
 }

 func init() {
-	for supportedSector, _ := range miner.SupportedProofTypes {
+	for supportedSector := range miner.SupportedProofTypes {
 		sectorSize, err := supportedSector.SectorSize()
 		if err != nil {
 			panic(err)
@ -207,24 +207,24 @@ type handler struct {
 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()))
+		http.Error(w, err.Error(), http.StatusInternalServerError)
 		return
 	}

 	tmpl, err := ioutil.ReadAll(f)
 	if err != nil {
-		w.WriteHeader(500)
-		_, _ = w.Write([]byte(err.Error()))
+		http.Error(w, err.Error(), http.StatusInternalServerError)
 		return
 	}

 	var executedTmpl bytes.Buffer

 	t, err := template.New("miner.html").Parse(string(tmpl))
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+	}
 	if err := t.Execute(&executedTmpl, supportedSectors); err != nil {
-		w.WriteHeader(500)
-		_, _ = w.Write([]byte(err.Error()))
+		http.Error(w, err.Error(), http.StatusInternalServerError)
 		return
 	}

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

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

@ -293,15 +291,15 @@ func (h *handler) send(w http.ResponseWriter, r *http.Request) {
 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()))
+		http.Error(w, err.Error(), http.StatusBadRequest)
 		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."))
+		http.Error(w,
+			"Miner address must use BLS. A BLS address starts with the prefix 't3'."+
+				"Please create a BLS address by running \"lotus wallet new bls\" while connected to a Lotus node.",
+			http.StatusBadRequest)
 		return
 	}

@ -346,16 +344,14 @@ func (h *handler) mkminer(w http.ResponseWriter, r *http.Request) {
 		To:    owner,
 	}, nil)
 	if err != nil {
-		w.WriteHeader(400)
-		w.Write([]byte("pushfunds: " + err.Error()))
+		http.Error(w, "pushfunds: "+err.Error(), http.StatusBadRequest)
 		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()))
+		http.Error(w, "sealprooftype: "+err.Error(), http.StatusBadRequest)
 		return
 	}

@ -366,8 +362,7 @@ func (h *handler) mkminer(w http.ResponseWriter, r *http.Request) {
 		Peer:          abi.PeerID(h.defaultMinerPeer),
 	})
 	if err != nil {
-		w.WriteHeader(400)
-		w.Write([]byte(err.Error()))
+		http.Error(w, err.Error(), http.StatusBadRequest)
 		return
 	}

@ -382,66 +377,58 @@ func (h *handler) mkminer(w http.ResponseWriter, r *http.Request) {

 	signed, err := h.api.MpoolPushMessage(r.Context(), createStorageMinerMsg, nil)
 	if err != nil {
-		w.WriteHeader(400)
-		w.Write([]byte(err.Error()))
+		http.Error(w, err.Error(), http.StatusBadRequest)
 		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)
+	http.Redirect(w, r, fmt.Sprintf("/wait.html?f=%s&m=%s&o=%s", signed.Cid(), smsg.Cid(), owner), http.StatusSeeOther)
 }

 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()))
+		http.Error(w, err.Error(), http.StatusBadRequest)
 		return
 	}

 	mw, err := h.api.StateWaitMsg(r.Context(), c, build.MessageConfidence)
 	if err != nil {
-		w.WriteHeader(400)
-		w.Write([]byte(err.Error()))
+		http.Error(w, err.Error(), http.StatusBadRequest)
 		return
 	}

 	if mw.Receipt.ExitCode != 0 {
-		w.WriteHeader(400)
-		w.Write([]byte(xerrors.Errorf("create miner failed: exit code %d", mw.Receipt.ExitCode).Error()))
+		http.Error(w, err.Error(), http.StatusBadRequest)
 		return
 	}
-	w.WriteHeader(200)
+	w.WriteHeader(http.StatusOK)
 }

 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()))
+		http.Error(w, err.Error(), http.StatusBadRequest)
 		return
 	}

 	mw, err := h.api.StateWaitMsg(r.Context(), c, build.MessageConfidence)
 	if err != nil {
-		w.WriteHeader(400)
-		w.Write([]byte(err.Error()))
+		http.Error(w, err.Error(), http.StatusBadRequest)
 		return
 	}

 	if mw.Receipt.ExitCode != 0 {
-		w.WriteHeader(400)
-		w.Write([]byte(xerrors.Errorf("create miner failed: exit code %d", mw.Receipt.ExitCode).Error()))
+		http.Error(w, xerrors.Errorf("create miner failed: exit code %d", mw.Receipt.ExitCode).Error(), http.StatusBadRequest)
 		return
 	}
-	w.WriteHeader(200)
+	w.WriteHeader(http.StatusOK)

 	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()))
+		http.Error(w, err.Error(), http.StatusBadRequest)
 		return
 	}

--- a/cmd/lotus-keygen/main.go
+++ b/cmd/lotus-keygen/main.go
@ -54,7 +54,12 @@ func main() {
 		if err != nil {
 			return err
 		}
-		defer fi.Close()
+		defer func() {
+			err2 := fi.Close()
+			if err == nil {
+				err = err2
+			}
+		}()

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

 		ctx := context.Background()
@ -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 sufficent funds to cover refunds", "balance", balance, "refund_sum", refundSum, "minimum_required", minBalance)
+		log.Errorw("not sufficient 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)
--- a/cmd/lotus-seal-worker/main.go
+++ b/cmd/lotus-seal-worker/main.go
@ -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: ", api.Version{APIVersion: build.APIVersion})
+			return xerrors.Errorf("lotus-miner API version doesn't match: local: %s", api.Version{APIVersion: build.APIVersion})
 		}
 		log.Infof("Remote version %s", v)

@ -420,10 +420,11 @@ 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")),
@ -450,7 +451,7 @@ func extractRoutableIP(timeout time.Duration) (string, error) {
 	env, ok := os.LookupEnv(minerMultiAddrKey)
 	if !ok {
 		// TODO remove after deprecation period
-		env, ok = os.LookupEnv(deprecatedMinerMultiAddrKey)
+		_, ok = os.LookupEnv(deprecatedMinerMultiAddrKey)
 		if ok {
 			log.Warnf("Using a deprecated env(%s) value, please use env(%s) instead.", deprecatedMinerMultiAddrKey, minerMultiAddrKey)
 		}
@ -461,7 +462,7 @@ func extractRoutableIP(timeout time.Duration) (string, error) {
 	if err != nil {
 		return "", err
 	}
-	defer conn.Close()
+	defer conn.Close() //nolint:errcheck

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

--- a/cmd/lotus-seed/main.go
+++ b/cmd/lotus-seed/main.go
@ -114,6 +114,9 @@ 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
 			}
--- a/cmd/lotus-shed/keyinfo.go
+++ b/cmd/lotus-shed/keyinfo.go
@ -69,7 +69,7 @@ var keyinfoImportCmd = &cli.Command{
 			if err != nil {
 				return err
 			}
-			defer inputFile.Close()
+			defer inputFile.Close() //nolint:errcheck
 			input = bufio.NewReader(inputFile)
 		}

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

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

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

   Examples

-   Retreive the address of a lotus wallet
+   Retrieve 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()
+			defer inputFile.Close() //nolint:errcheck
 			input = bufio.NewReader(inputFile)
 		}

--- a/cmd/lotus-storage-miner/info_all.go
+++ b/cmd/lotus-storage-miner/info_all.go
@ -126,7 +126,9 @@ var infoAllCmd = &cli.Command{

 			fs := &flag.FlagSet{}
 			for _, f := range sectorsStatusCmd.Flags {
-				f.Apply(fs)
+				if err := f.Apply(fs); err != nil {
+					return err
+				}
 			}
 			if err := fs.Parse([]string{"--log", "--on-chain-info", fmt.Sprint(s)}); err != nil {
 				return err
--- a/cmd/lotus-storage-miner/run.go
+++ b/cmd/lotus-storage-miner/run.go
@ -53,7 +53,10 @@ var runCmd = &cli.Command{
 	},
 	Action: func(cctx *cli.Context) error {
 		if !cctx.Bool("enable-gpu-proving") {
-			os.Setenv("BELLMAN_NO_GPU", "true")
+			err := os.Setenv("BELLMAN_NO_GPU", "true")
+			if err != nil {
+				return err
+			}
 		}

 		nodeApi, ncloser, err := lcli.GetFullNodeAPI(cctx)
--- a/cmd/lotus-storage-miner/sealing.go
+++ b/cmd/lotus-storage-miner/sealing.go
@ -3,13 +3,14 @@ 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"

--- a/cmd/lotus-storage-miner/sectors.go
+++ b/cmd/lotus-storage-miner/sectors.go
@ -2,13 +2,14 @@ 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"

--- a/cmd/lotus-townhall/main.go
+++ b/cmd/lotus-townhall/main.go
@ -106,10 +106,11 @@ func handler(ps *pubsub.PubSub) func(w http.ResponseWriter, r *http.Request) {
 			return
 		}

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

 		fmt.Println("new conn")

--- a/extern/sector-storage/ffiwrapper/partialfile.go
+++ b/extern/sector-storage/ffiwrapper/partialfile.go
@ -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 '%d' 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 '%s' 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)
--- a/extern/sector-storage/fsutil/statfs_unix.go
+++ b/extern/sector-storage/fsutil/statfs_unix.go
@ -12,6 +12,8 @@ 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),
--- a/extern/sector-storage/mock/mock.go
+++ b/extern/sector-storage/mock/mock.go
@ -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/extern/sector-storage/tarutil/systar.go
+++ b/extern/sector-storage/tarutil/systar.go
@ -36,6 +36,8 @@ func ExtractTar(body io.Reader, dir string) error {
 			return xerrors.Errorf("creating file %s: %w", filepath.Join(dir, header.Name), err)
 		}

+		// This data is coming from a trusted source, no need to check the size.
+		//nolint:gosec
 		if _, err := io.Copy(f, tr); err != nil {
 			return err
 		}
--- a/extern/storage-sealing/fsm.go
+++ b/extern/storage-sealing/fsm.go
@ -348,7 +348,9 @@ func (m *Sealing) restartSectors(ctx context.Context) error {
 				timer := time.NewTimer(cfg.WaitDealsDelay)
 				go func() {
 					<-timer.C
-					m.StartPacking(sector.SectorNumber)
+					if err := m.StartPacking(sector.SectorNumber); err != nil {
+						log.Errorf("starting sector %d: %+v", sector.SectorNumber, err)
+					}
 				}()
 			}
 		}
--- a/extern/storage-sealing/sealing.go
+++ b/extern/storage-sealing/sealing.go
@ -355,7 +355,9 @@ func (m *Sealing) newDealSector() (abi.SectorNumber, error) {
 		timer := time.NewTimer(cf.WaitDealsDelay)
 		go func() {
 			<-timer.C
-			m.StartPacking(sid)
+			if err := m.StartPacking(sid); err != nil {
+				log.Errorf("starting sector %d: %+v", sid, err)
+			}
 		}()
 	}

@ -396,7 +398,6 @@ func (m *Sealing) Address() address.Address {
 func getDealPerSectorLimit(size abi.SectorSize) uint64 {
 	if size < 64<<30 {
 		return 256
-	} else {
-		return 512
 	}
+	return 512
 }
--- a/extern/storage-sealing/types.go
+++ b/extern/storage-sealing/types.go
@ -3,6 +3,7 @@ package sealing
 import (
 	"bytes"
 	"context"
+
 	"github.com/ipfs/go-cid"

 	"github.com/filecoin-project/specs-actors/actors/abi"
--- a/go.mod
+++ b/go.mod
@ -92,7 +92,6 @@ require (
 	github.com/libp2p/go-libp2p-kad-dht v0.8.3
 	github.com/libp2p/go-libp2p-mplex v0.2.4
 	github.com/libp2p/go-libp2p-noise v0.1.1
-	github.com/libp2p/go-libp2p-peer v0.2.0
 	github.com/libp2p/go-libp2p-peerstore v0.2.6
 	github.com/libp2p/go-libp2p-pubsub v0.3.5-0.20200820194335-bfc96c2cd081
 	github.com/libp2p/go-libp2p-quic-transport v0.7.1
--- a/journal/journal.go
+++ b/journal/journal.go
@ -5,7 +5,6 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
-	"sync"
 	"time"

 	logging "github.com/ipfs/go-log"
@ -48,8 +47,6 @@ type fsJournal struct {
 	fi    *os.File
 	fSize int64

-	lk sync.Mutex
-
 	journalDir string

 	incoming         chan *JournalEntry
@ -58,7 +55,7 @@ type fsJournal struct {
 	closing chan struct{}
 }

-func OpenFSJournal(dir string) (*fsJournal, error) {
+func OpenFSJournal(dir string) (Journal, error) {
 	fsj := &fsJournal{
 		journalDir:       dir,
 		incoming:         make(chan *JournalEntry, 32),
@ -94,7 +91,7 @@ func (fsj *fsJournal) putEntry(je *JournalEntry) error {
 	fsj.fSize += int64(n)

 	if fsj.fSize >= fsj.journalSizeLimit {
-		fsj.rollJournalFile()
+		return fsj.rollJournalFile()
 	}

 	return nil
@ -104,7 +101,10 @@ const RFC3339nocolon = "2006-01-02T150405Z0700"

 func (fsj *fsJournal) rollJournalFile() error {
 	if fsj.fi != nil {
-		fsj.fi.Close()
+		err := fsj.fi.Close()
+		if err != nil {
+			return err
+		}
 	}

 	nfi, err := os.Create(filepath.Join(fsj.journalDir, fmt.Sprintf("lotus-journal-%s.ndjson", build.Clock.Now().Format(RFC3339nocolon))))
@ -125,7 +125,9 @@ func (fsj *fsJournal) runLoop() {
 				log.Errorw("failed to write out journal entry", "entry", je, "err", err)
 			}
 		case <-fsj.closing:
-			fsj.fi.Close()
+			if err := fsj.fi.Close(); err != nil {
+				log.Errorw("failed to close journal", "err", err)
+			}
 			return
 		}
 	}
--- a/lib/blockstore/blockstore.go
+++ b/lib/blockstore/blockstore.go
@ -28,12 +28,12 @@ func NewTemporary() blockstore.Blockstore {
 	return NewBlockstore(ds.NewMapDatastore())
 }

-// NewTemporary returns a thread-safe temporary blockstore.
+// NewTemporarySync returns a thread-safe temporary blockstore.
 func NewTemporarySync() blockstore.Blockstore {
 	return NewBlockstore(dssync.MutexWrap(ds.NewMapDatastore()))
 }

-// Wraps the underlying blockstore in an "identity" blockstore.
+// WrapIDStore wraps the underlying blockstore in an "identity" blockstore.
 func WrapIDStore(bstore blockstore.Blockstore) blockstore.Blockstore {
 	return blockstore.NewIdStore(bstore)
 }
--- a/lib/cachebs/cachebs.go
+++ b/lib/cachebs/cachebs.go
@ -11,6 +11,7 @@ import (
 	bstore "github.com/filecoin-project/lotus/lib/blockstore"
 )

+//nolint:deadcode,varcheck
 var log = logging.Logger("cachebs")

 type CacheBS struct {
--- a/lib/rpcenc/reader.go
+++ b/lib/rpcenc/reader.go
@ -64,7 +64,7 @@ func ReaderParamEncoder(addr string) jsonrpc.Option {
 				return
 			}

-			defer resp.Body.Close()
+			defer resp.Body.Close() //nolint:errcheck

 			if resp.StatusCode != 200 {
 				b, _ := ioutil.ReadAll(resp.Body)
--- a/lib/rpcenc/reader_test.go
+++ b/lib/rpcenc/reader_test.go
@ -56,7 +56,7 @@ func TestReaderProxy(t *testing.T) {

 	read, err := client.ReadAll(context.TODO(), strings.NewReader("pooooootato"))
 	require.NoError(t, err)
-	require.Equal(t, "pooooootato", string(read), "potatos weren't equal")
+	require.Equal(t, "pooooootato", string(read), "potatoes weren't equal")
 }

 func TestNullReaderProxy(t *testing.T) {
--- a/lib/sigs/bls/bls_bench_test.go
+++ b/lib/sigs/bls/bls_bench_test.go
@ -2,8 +2,9 @@ package bls

 import (
 	"crypto/rand"
-	"github.com/filecoin-project/go-address"
 	"testing"
+
+	"github.com/filecoin-project/go-address"
 )

 func BenchmarkBLSSign(b *testing.B) {
@ -12,7 +13,7 @@ func BenchmarkBLSSign(b *testing.B) {
 		b.StopTimer()
 		pk, _ := signer.GenPrivate()
 		randMsg := make([]byte, 32)
-		rand.Read(randMsg)
+		_, _ = rand.Read(randMsg)
 		b.StartTimer()

 		_, _ = signer.Sign(pk, randMsg)
@ -24,7 +25,7 @@ func BenchmarkBLSVerify(b *testing.B) {
 	for i := 0; i < b.N; i++ {
 		b.StopTimer()
 		randMsg := make([]byte, 32)
-		rand.Read(randMsg)
+		_, _ = rand.Read(randMsg)

 		priv, _ := signer.GenPrivate()
 		pk, _ := signer.ToPublic(priv)
--- a/lotuspond/api.go
+++ b/lotuspond/api.go
@ -17,7 +17,7 @@ import (
 type NodeState int

 const (
-	NodeUnknown = iota
+	NodeUnknown = iota //nolint:deadcode
 	NodeRunning
 	NodeStopped
 )
--- a/lotuspond/outmux.go
+++ b/lotuspond/outmux.go
@ -73,7 +73,7 @@ func (m *outmux) run() {
 		case msg := <-stdout:
 			for k, out := range m.outs {
 				if err := out.WriteMessage(websocket.BinaryMessage, msg); err != nil {
-					out.Close()
+					_ = out.Close()
 					fmt.Printf("outmux write failed: %s\n", err)
 					delete(m.outs, k)
 				}
--- a/markets/storageadapter/client.go
+++ b/markets/storageadapter/client.go
@ -266,7 +266,7 @@ func (c *ClientNodeAdapter) OnDealSectorCommitted(ctx context.Context, provider
 			return false, nil
 		}

-		sd, err := stmgr.GetStorageDeal(ctx, c.StateManager, abi.DealID(dealId), ts)
+		sd, err := stmgr.GetStorageDeal(ctx, c.StateManager, dealId, ts)
 		if err != nil {
 			return false, xerrors.Errorf("failed to look up deal on chain: %w", err)
 		}
@ -303,7 +303,7 @@ func (c *ClientNodeAdapter) OnDealSectorCommitted(ctx context.Context, provider
 			}

 			for _, did := range params.DealIDs {
-				if did == abi.DealID(dealId) {
+				if did == dealId {
 					sectorNumber = params.SectorNumber
 					sectorFound = true
 					return true, false, nil
@ -464,7 +464,7 @@ func (c *ClientNodeAdapter) ValidateAskSignature(ctx context.Context, ask *stora

 	mi, err := c.StateMinerInfo(ctx, ask.Ask.Miner, tsk)
 	if err != nil {
-		return false, xerrors.Errorf("failed to get worker for miner in ask", err)
+		return false, xerrors.Errorf("failed to get worker for miner in ask: %w", err)
 	}

 	sigb, err := cborutil.Dump(ask.Ask)
--- a/markets/storageadapter/provider.go
+++ b/markets/storageadapter/provider.go
@ -69,7 +69,7 @@ func (n *ProviderNodeAdapter) PublishDeals(ctx context.Context, deal storagemark
 	})

 	if err != nil {
-		return cid.Undef, xerrors.Errorf("serializing PublishStorageDeals params failed: ", err)
+		return cid.Undef, xerrors.Errorf("serializing PublishStorageDeals params failed: %w", err)
 	}

 	// TODO: We may want this to happen after fetching data
@ -267,7 +267,7 @@ func (n *ProviderNodeAdapter) OnDealSectorCommitted(ctx context.Context, provide
 			return false, nil
 		}

-		sd, err := n.StateMarketStorageDeal(ctx, abi.DealID(dealID), ts.Key())
+		sd, err := n.StateMarketStorageDeal(ctx, dealID, ts.Key())
 		if err != nil {
 			return false, xerrors.Errorf("failed to look up deal on chain: %w", err)
 		}
@ -305,7 +305,7 @@ func (n *ProviderNodeAdapter) OnDealSectorCommitted(ctx context.Context, provide
 			}

 			for _, did := range params.DealIDs {
-				if did == abi.DealID(dealID) {
+				if did == dealID {
 					sectorNumber = params.SectorNumber
 					sectorFound = true
 					return true, false, nil
--- a/miner/miner.go
+++ b/miner/miner.go
@ -36,7 +36,7 @@ type waitFunc func(ctx context.Context, baseTime uint64) (func(bool, error), abi

 func randTimeOffset(width time.Duration) time.Duration {
 	buf := make([]byte, 8)
-	rand.Reader.Read(buf)
+	rand.Reader.Read(buf) //nolint:errcheck
 	val := time.Duration(binary.BigEndian.Uint64(buf) % uint64(width))

 	return val - (width / 2)
@ -508,12 +508,3 @@ func (c *cachedActorLookup) StateGetActor(ctx context.Context, a address.Address
 }

 type ActorLookup func(context.Context, address.Address, types.TipSetKey) (*types.Actor, error)
-
-func countFrom(msgs []*types.SignedMessage, from address.Address) (out int) {
-	for _, msg := range msgs {
-		if msg.Message.From == from {
-			out++
-		}
-	}
-	return out
-}
--- a/node/builder.go
+++ b/node/builder.go
@ -67,6 +67,7 @@ import (
 	"github.com/filecoin-project/lotus/storage/sectorblocks"
 )

+//nolint:deadcode,varcheck
 var log = logging.Logger("builder")

 // special is a type used to give keys to modules which
--- a/node/impl/client/client.go
+++ b/node/impl/client/client.go
@ -109,7 +109,7 @@ func (a *API) ClientStartDeal(ctx context.Context, params *api.StartDealParams)
 				continue
 			}
 			if c.Equals(params.Data.Root) {
-				storeID = &importID
+				storeID = &importID //nolint
 				break
 			}
 		}
@ -614,7 +614,7 @@ func (a *API) ClientCalcCommP(ctx context.Context, inpath string) (*api.CommPRet
 	if err != nil {
 		return nil, err
 	}
-	defer rdr.Close()
+	defer rdr.Close() //nolint:errcheck

 	stat, err := rdr.Stat()
 	if err != nil {
@ -700,7 +700,7 @@ func (a *API) clientImport(ctx context.Context, ref api.FileRef, store *multisto
 	if err != nil {
 		return cid.Undef, err
 	}
-	defer f.Close()
+	defer f.Close() //nolint:errcheck

 	stat, err := f.Stat()
 	if err != nil {
--- a/node/impl/full/mpool.go
+++ b/node/impl/full/mpool.go
@ -2,14 +2,15 @@ package full

 import (
 	"context"
-	"github.com/filecoin-project/specs-actors/actors/abi"
-	"github.com/filecoin-project/specs-actors/actors/abi/big"

+	"github.com/filecoin-project/go-address"
 	"github.com/ipfs/go-cid"
 	"go.uber.org/fx"
 	"golang.org/x/xerrors"

-	"github.com/filecoin-project/go-address"
+	"github.com/filecoin-project/specs-actors/actors/abi"
+	"github.com/filecoin-project/specs-actors/actors/abi/big"
+
 	"github.com/filecoin-project/lotus/api"
 	"github.com/filecoin-project/lotus/chain/messagepool"
 	"github.com/filecoin-project/lotus/chain/store"
--- a/node/impl/full/multisig.go
+++ b/node/impl/full/multisig.go
@ -28,7 +28,7 @@ type MsigAPI struct {
 	MpoolAPI  MpoolAPI
 }

-// TODO: remove gp (gasPrice) from arguemnts
+// TODO: remove gp (gasPrice) from arguments
 func (a *MsigAPI) MsigCreate(ctx context.Context, req uint64, addrs []address.Address, duration abi.ChainEpoch, val types.BigInt, src address.Address, gp types.BigInt) (cid.Cid, error) {

 	lenAddrs := uint64(len(addrs))
--- a/node/impl/full/state.go
+++ b/node/impl/full/state.go
@ -443,9 +443,8 @@ func (a *StateAPI) StateSearchMsg(ctx context.Context, msg cid.Cid) (*api.MsgLoo
 			TipSet:  ts.Key(),
 			Height:  ts.Height(),
 		}, nil
-	} else {
-		return nil, nil
 	}
+	return nil, nil
 }

 func (a *StateAPI) StateGetReceipt(ctx context.Context, msg cid.Cid, tsk types.TipSetKey) (*types.MessageReceipt, error) {
@ -557,7 +556,7 @@ func (a *StateAPI) StateMarketDeals(ctx context.Context, tsk types.TipSetKey) (m
 		} else if !found {
 			s.SectorStartEpoch = -1
 		}
-		out[strconv.FormatInt(int64(i), 10)] = api.MarketDeal{
+		out[strconv.FormatInt(i, 10)] = api.MarketDeal{
 			Proposal: d,
 			State:    s,
 		}
@ -785,10 +784,6 @@ func (a *StateAPI) StateSectorPartition(ctx context.Context, maddr address.Addre
 		return nil, err
 	}

-	if found == nil {
-
-	}
-
 	return found, nil
 }

@ -1147,12 +1142,12 @@ func (a *StateAPI) StateDealProviderCollateralBounds(ctx context.Context, size a
 	})

 	if err != nil {
-		return api.DealCollateralBounds{}, xerrors.Errorf("getting power and reward actor states: %w")
+		return api.DealCollateralBounds{}, xerrors.Errorf("getting power and reward actor states: %w", err)
 	}

 	circ, err := a.StateCirculatingSupply(ctx, ts.Key())
 	if err != nil {
-		return api.DealCollateralBounds{}, xerrors.Errorf("getting total circulating supply: %w")
+		return api.DealCollateralBounds{}, xerrors.Errorf("getting total circulating supply: %w", err)
 	}

 	min, max := market.DealProviderCollateralBounds(size, verified, powerState.ThisEpochQualityAdjPower, rewardState.ThisEpochBaselinePower, circ.FilCirculating)
@ -1175,6 +1170,9 @@ func (a *StateAPI) StateCirculatingSupply(ctx context.Context, tsk types.TipSetK

 	cst := cbor.NewCborStore(a.Chain.Blockstore())
 	sTree, err := state.LoadStateTree(cst, st)
+	if err != nil {
+		return api.CirculatingSupply{}, err
+	}

 	return a.StateManager.GetCirculatingSupplyDetailed(ctx, ts.Height(), sTree)
 }
--- a/node/impl/full/sync.go
+++ b/node/impl/full/sync.go
@ -90,8 +90,7 @@ func (a *SyncAPI) SyncSubmitBlock(ctx context.Context, blk *types.BlockMsg) erro
 		return xerrors.Errorf("serializing block for pubsub publishing failed: %w", err)
 	}

-	// TODO: anything else to do here?
-	return a.PubSub.Publish(build.BlocksTopic(a.NetName), b)
+	return a.PubSub.Publish(build.BlocksTopic(a.NetName), b) //nolint:staticcheck
 }

 func (a *SyncAPI) SyncIncomingBlocks(ctx context.Context) (<-chan *types.BlockHeader, error) {
--- a/node/impl/full/wallet.go
+++ b/node/impl/full/wallet.go
@ -2,19 +2,18 @@ package full

 import (
 	"context"
-	"github.com/filecoin-project/specs-actors/actors/abi/big"
-
-	"github.com/filecoin-project/lotus/lib/sigs"

 	"github.com/filecoin-project/go-address"
+	"go.uber.org/fx"
+	"golang.org/x/xerrors"
+
+	"github.com/filecoin-project/specs-actors/actors/abi/big"
 	"github.com/filecoin-project/specs-actors/actors/crypto"

 	"github.com/filecoin-project/lotus/chain/stmgr"
 	"github.com/filecoin-project/lotus/chain/types"
 	"github.com/filecoin-project/lotus/chain/wallet"
-
-	"go.uber.org/fx"
-	"golang.org/x/xerrors"
+	"github.com/filecoin-project/lotus/lib/sigs"
 )

 type WalletAPI struct {
@ -45,9 +44,8 @@ func (a *WalletAPI) WalletBalance(ctx context.Context, addr address.Address) (ty

 	if xerrors.Is(err, types.ErrActorNotFound) {
 		return big.Zero(), nil
-	} else {
-		return bal, err
 	}
+	return bal, err
 }

 func (a *WalletAPI) WalletSign(ctx context.Context, k address.Address, msg []byte) (*crypto.Signature, error) {
--- a/node/modules/client.go
+++ b/node/modules/client.go
@ -123,8 +123,7 @@ func StorageClient(lc fx.Lifecycle, h host.Host, ibs dtypes.ClientBlockstore, md
 			return c.Start(ctx)
 		},
 		OnStop: func(context.Context) error {
-			c.Stop()
-			return nil
+			return c.Stop()
 		},
 	})
 	return c, nil
--- a/node/modules/core.go
+++ b/node/modules/core.go
@ -37,7 +37,7 @@ func RecordValidator(ps peerstore.Peerstore) record.Validator {
 }

 const JWTSecretName = "auth-jwt-private"  //nolint:gosec
-const KTJwtHmacSecret = "jwt-hmac-secret"
+const KTJwtHmacSecret = "jwt-hmac-secret" //nolint:gosec

 type JwtPayload struct {
 	Allow []auth.Permission
--- a/node/modules/graphsync.go
+++ b/node/modules/graphsync.go
@ -8,7 +8,7 @@ import (
 	gsnet "github.com/ipfs/go-graphsync/network"
 	"github.com/ipfs/go-graphsync/storeutil"
 	"github.com/libp2p/go-libp2p-core/host"
-	peer "github.com/libp2p/go-libp2p-peer"
+	"github.com/libp2p/go-libp2p-core/peer"
 	"go.uber.org/fx"
 )

--- a/node/modules/services.go
+++ b/node/modules/services.go
@ -76,7 +76,7 @@ func RunBlockSync(h host.Host, svc *blocksync.BlockSyncService) {
 func HandleIncomingBlocks(mctx helpers.MetricsCtx, lc fx.Lifecycle, ps *pubsub.PubSub, s *chain.Syncer, bserv dtypes.ChainBlockService, chain *store.ChainStore, stmgr *stmgr.StateManager, h host.Host, nn dtypes.NetworkName) {
 	ctx := helpers.LifecycleCtx(mctx, lc)

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

-	msgsub, err := ps.Subscribe(build.MessagesTopic(nn))
+	msgsub, err := ps.Subscribe(build.MessagesTopic(nn)) //nolint:staticcheck
 	if err != nil {
 		panic(err)
 	}
--- a/storage/adapter_storage_miner.go
+++ b/storage/adapter_storage_miner.go
@ -3,7 +3,6 @@ package storage
 import (
 	"bytes"
 	"context"
-	"github.com/filecoin-project/lotus/api"

 	"github.com/ipfs/go-cid"
 	cbg "github.com/whyrusleeping/cbor-gen"
@ -18,6 +17,7 @@ import (
 	"github.com/filecoin-project/specs-actors/actors/crypto"
 	"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/actors"
--- a/storage/addresses.go
+++ b/storage/addresses.go
@ -2,6 +2,7 @@ package storage

 import (
 	"context"
+
 	"golang.org/x/xerrors"

 	"github.com/filecoin-project/go-address"
--- a/storage/wdpost_run.go
+++ b/storage/wdpost_run.go
@ -4,13 +4,13 @@ import (
 	"bytes"
 	"context"
 	"errors"
-	"github.com/filecoin-project/specs-actors/actors/abi/big"
 	"time"

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

 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/specs-actors/actors/abi"
+	"github.com/filecoin-project/specs-actors/actors/abi/big"
 	"github.com/filecoin-project/specs-actors/actors/builtin"
 	"github.com/filecoin-project/specs-actors/actors/builtin/miner"
 	"github.com/filecoin-project/specs-actors/actors/crypto"
--- a/tools/stats/head_buffer.go
+++ b/tools/stats/head_buffer.go
@ -11,7 +11,7 @@ type headBuffer struct {
 	size   int
 }

-func NewHeadBuffer(size int) *headBuffer {
+func newHeadBuffer(size int) *headBuffer {
 	buffer := list.New()
 	buffer.Init()

@ -21,7 +21,7 @@ func NewHeadBuffer(size int) *headBuffer {
 	}
 }

-func (h *headBuffer) Push(hc *api.HeadChange) (rethc *api.HeadChange) {
+func (h *headBuffer) push(hc *api.HeadChange) (rethc *api.HeadChange) {
 	if h.buffer.Len() == h.size {
 		var ok bool

@ -39,7 +39,7 @@ func (h *headBuffer) Push(hc *api.HeadChange) (rethc *api.HeadChange) {
 	return
 }

-func (h *headBuffer) Pop() {
+func (h *headBuffer) pop() {
 	el := h.buffer.Back()
 	if el != nil {
 		h.buffer.Remove(el)
--- a/tools/stats/head_buffer_test.go
+++ b/tools/stats/head_buffer_test.go
@ -10,34 +10,34 @@ import (
 func TestHeadBuffer(t *testing.T) {

 	t.Run("Straight push through", func(t *testing.T) {
-		hb := NewHeadBuffer(5)
-		require.Nil(t, hb.Push(&api.HeadChange{Type: "1"}))
-		require.Nil(t, hb.Push(&api.HeadChange{Type: "2"}))
-		require.Nil(t, hb.Push(&api.HeadChange{Type: "3"}))
-		require.Nil(t, hb.Push(&api.HeadChange{Type: "4"}))
-		require.Nil(t, hb.Push(&api.HeadChange{Type: "5"}))
+		hb := newHeadBuffer(5)
+		require.Nil(t, hb.push(&api.HeadChange{Type: "1"}))
+		require.Nil(t, hb.push(&api.HeadChange{Type: "2"}))
+		require.Nil(t, hb.push(&api.HeadChange{Type: "3"}))
+		require.Nil(t, hb.push(&api.HeadChange{Type: "4"}))
+		require.Nil(t, hb.push(&api.HeadChange{Type: "5"}))

-		hc := hb.Push(&api.HeadChange{Type: "6"})
+		hc := hb.push(&api.HeadChange{Type: "6"})
 		require.Equal(t, hc.Type, "1")
 	})

 	t.Run("Reverts", func(t *testing.T) {
-		hb := NewHeadBuffer(5)
-		require.Nil(t, hb.Push(&api.HeadChange{Type: "1"}))
-		require.Nil(t, hb.Push(&api.HeadChange{Type: "2"}))
-		require.Nil(t, hb.Push(&api.HeadChange{Type: "3"}))
-		hb.Pop()
-		require.Nil(t, hb.Push(&api.HeadChange{Type: "3a"}))
-		hb.Pop()
-		require.Nil(t, hb.Push(&api.HeadChange{Type: "3b"}))
-		require.Nil(t, hb.Push(&api.HeadChange{Type: "4"}))
-		require.Nil(t, hb.Push(&api.HeadChange{Type: "5"}))
+		hb := newHeadBuffer(5)
+		require.Nil(t, hb.push(&api.HeadChange{Type: "1"}))
+		require.Nil(t, hb.push(&api.HeadChange{Type: "2"}))
+		require.Nil(t, hb.push(&api.HeadChange{Type: "3"}))
+		hb.pop()
+		require.Nil(t, hb.push(&api.HeadChange{Type: "3a"}))
+		hb.pop()
+		require.Nil(t, hb.push(&api.HeadChange{Type: "3b"}))
+		require.Nil(t, hb.push(&api.HeadChange{Type: "4"}))
+		require.Nil(t, hb.push(&api.HeadChange{Type: "5"}))

-		hc := hb.Push(&api.HeadChange{Type: "6"})
+		hc := hb.push(&api.HeadChange{Type: "6"})
 		require.Equal(t, hc.Type, "1")
-		hc = hb.Push(&api.HeadChange{Type: "7"})
+		hc = hb.push(&api.HeadChange{Type: "7"})
 		require.Equal(t, hc.Type, "2")
-		hc = hb.Push(&api.HeadChange{Type: "8"})
+		hc = hb.push(&api.HeadChange{Type: "8"})
 		require.Equal(t, hc.Type, "3b")
 	})
 }
--- a/tools/stats/metrics.go
+++ b/tools/stats/metrics.go
@ -251,16 +251,13 @@ func RecordTipsetStatePoints(ctx context.Context, api api.FullNode, pl *PointLis
 		return err
 	}

-	err = mp.ForEach(nil, func(key string) error {
+	var claim power.Claim
+	err = mp.ForEach(&claim, func(key string) error {
 		addr, err := address.NewFromBytes([]byte(key))
 		if err != nil {
 			return err
 		}

-		var claim power.Claim
-		keyerAddr := adt.AddrKey(addr)
-		mp.Get(keyerAddr, &claim)
-
 		if claim.QualityAdjPower.Int64() == 0 {
 			return nil
 		}
@ -311,7 +308,7 @@ func RecordTipsetMessagesPoints(ctx context.Context, api api.FullNode, pl *Point

 	for i, msg := range msgs {
 		// FIXME: use float so this doesn't overflow
-		// FIXME: this doesn't work as time points get overriden
+		// FIXME: this doesn't work as time points get overridden
 		p := NewPoint("chain.message_gaspremium", msg.Message.GasPremium.Int64())
 		pl.AddPoint(p)
 		p = NewPoint("chain.message_gasfeecap", msg.Message.GasFeeCap.Int64())
--- a/tools/stats/rpc.go
+++ b/tools/stats/rpc.go
@ -124,7 +124,7 @@ sync_complete:
 func GetTips(ctx context.Context, api api.FullNode, lastHeight abi.ChainEpoch, headlag int) (<-chan *types.TipSet, error) {
 	chmain := make(chan *types.TipSet)

-	hb := NewHeadBuffer(headlag)
+	hb := newHeadBuffer(headlag)

 	notif, err := api.ChainNotify(ctx)
 	if err != nil {
@ -134,7 +134,8 @@ func GetTips(ctx context.Context, api api.FullNode, lastHeight abi.ChainEpoch, h
 	go func() {
 		defer close(chmain)

-		ping := time.Tick(30 * time.Second)
+		ticker := time.NewTicker(30 * time.Second)
+		defer ticker.Stop()

 		for {
 			select {
@ -154,14 +155,14 @@ func GetTips(ctx context.Context, api api.FullNode, lastHeight abi.ChainEpoch, h
 							chmain <- tipset
 						}
 					case store.HCApply:
-						if out := hb.Push(change); out != nil {
+						if out := hb.push(change); out != nil {
 							chmain <- out.Val
 						}
 					case store.HCRevert:
-						hb.Pop()
+						hb.pop()
 					}
 				}
-			case <-ping:
+			case <-ticker.C:
 				log.Info("Running health check")

 				cctx, cancel := context.WithTimeout(ctx, 5*time.Second)