style: enable errcheck linter

.avalanche-golangci.yml

@@ -55,7 +55,7 @@ linters:
     - bodyclose
     - copyloopvar
     # - depguard
-    # - errcheck
+    - errcheck
     - errorlint
     # - forbidigo
     - goconst

core/blockchain_ext_test.go

@@ -1886,7 +1886,7 @@ func ReexecCorruptedStateTest(t *testing.T, create ReexecTestFunc) {
 	}
 
 	// Simulate a crash by updating the acceptor tip
-	blockchain.writeBlockAcceptedIndices(chain[1])
+	_ = blockchain.writeBlockAcceptedIndices(chain[1])
 	blockchain.Stop()
 
 	// Restart blockchain with existing state

core/fifo_cache.go

@@ -44,7 +44,7 @@ func (f *BufferFIFOCache[K, V]) Put(key K, val V) {
 	f.l.Lock()
 	defer f.l.Unlock()
 
-	f.buffer.Insert(key) // Insert will remove the oldest [K] if we are at the [limit]
+	_ = f.buffer.Insert(key) // Insert will remove the oldest [K] if we are at the [limit]
 	f.m[key] = val
 }
 

core/state_manager_test.go

@@ -57,7 +57,8 @@ func TestCappedMemoryTrieWriter(t *testing.T) {
 		assert.Equal(common.Hash{}, m.LastDereference, "should not have dereferenced block on insert")
 		assert.Equal(common.Hash{}, m.LastCommit, "should not have committed block on insert")
 
-		w.AcceptTrie(block)
+		err := w.AcceptTrie(block)
+		assert.NoError(err)
 		if i <= tipBufferSize {
 			assert.Equal(common.Hash{}, m.LastDereference, "should not have dereferenced block on accept")
 		} else {
@@ -71,7 +72,8 @@ func TestCappedMemoryTrieWriter(t *testing.T) {
 			m.LastCommit = common.Hash{}
 		}
 
-		w.RejectTrie(block)
+		err = w.RejectTrie(block)
+		assert.NoError(err)
 		assert.Equal(block.Root(), m.LastDereference, "should have dereferenced block on reject")
 		assert.Equal(common.Hash{}, m.LastCommit, "should not have committed block on reject")
 		m.LastDereference = common.Hash{}
@@ -96,12 +98,14 @@ func TestNoPruningTrieWriter(t *testing.T) {
 		assert.Equal(common.Hash{}, m.LastDereference, "should not have dereferenced block on insert")
 		assert.Equal(common.Hash{}, m.LastCommit, "should not have committed block on insert")
 
-		w.AcceptTrie(block)
+		err := w.AcceptTrie(block)
+		assert.NoError(err)
 		assert.Equal(common.Hash{}, m.LastDereference, "should not have dereferenced block on accept")
 		assert.Equal(block.Root(), m.LastCommit, "should have committed block on accept")
 		m.LastCommit = common.Hash{}
 
-		w.RejectTrie(block)
+		err = w.RejectTrie(block)
+		assert.NoError(err)
 		assert.Equal(block.Root(), m.LastDereference, "should have dereferenced block on reject")
 		assert.Equal(common.Hash{}, m.LastCommit, "should not have committed block on reject")
 		m.LastDereference = common.Hash{}

plugin/evm/atomic/state/atomic_trie.go

@@ -244,7 +244,10 @@ func (a *AtomicTrie) InsertTrie(nodes *trienode.NodeSet, root common.Hash) error
 			return err
 		}
 	}
-	a.trieDB.Reference(root, common.Hash{})
+	err := a.trieDB.Reference(root, common.Hash{})
+	if err != nil {
+		return err
+	}
 
 	// The use of [Cap] in [insertTrie] prevents exceeding the configured memory
 	// limit (and OOM) in case there is a large backlog of processing (unaccepted) blocks.
@@ -285,12 +288,18 @@ func (a *AtomicTrie) AcceptTrie(height uint64, root common.Hash) (bool, error) {
 	// - not committted, in which case the current root we are inserting contains
 	//   references to all the relevant data from the previous root, so the previous
 	//   root can be dereferenced.
-	a.trieDB.Dereference(a.lastAcceptedRoot)
+	err := a.trieDB.Dereference(a.lastAcceptedRoot)
+	if err != nil {
+		return false, err
+	}
 	a.lastAcceptedRoot = root
 	return hasCommitted, nil
 }
 
 func (a *AtomicTrie) RejectTrie(root common.Hash) error {
-	a.trieDB.Dereference(root)
+	err := a.trieDB.Dereference(root)
+	if err != nil {
+		return err
+	}
 	return nil
 }

plugin/evm/atomic/state/atomic_trie_test.go

@@ -644,7 +644,8 @@ func TestAtomicTrie_AcceptTrie(t *testing.T) {
 				_, storageSize, _ := atomicTrie.trieDB.Size()
 				require.NotZero(t, storageSize, "there should be a dirty node taking up storage space")
 			}
-			atomicTrie.updateLastCommitted(testCase.lastCommittedRoot, testCase.lastCommittedHeight)
+			err = atomicTrie.updateLastCommitted(testCase.lastCommittedRoot, testCase.lastCommittedHeight)
+			require.NoError(t, err)
 
 			hasCommitted, err := atomicTrie.AcceptTrie(testCase.height, testCase.root)
 			require.NoError(t, err)

plugin/evm/atomic/vm/block_extension.go

@@ -229,7 +229,10 @@ func (be *blockExtension) Reject() error {
 func (be *blockExtension) CleanupVerified() {
 	vm := be.blockExtender.vm
 	if atomicState, err := vm.AtomicBackend.GetVerifiedAtomicState(be.block.GetEthBlock().Hash()); err == nil {
-		atomicState.Reject()
+		err = atomicState.Reject()
+		if err != nil {
+			log.Error("failed to reject atomic state", "err", err)
+		}
 	}
 }
 

plugin/evm/atomic/vm/gossiper_atomic_gossiping_test.go

@@ -143,7 +143,8 @@ func TestMempoolAtmTxsAppGossipHandlingDiscardedTx(t *testing.T) {
 	tx, conflictingTx := importTxs[0], importTxs[1]
 	txID := tx.ID()
 
-	vm.AtomicMempool.AddRemoteTx(tx)
+	err := vm.AtomicMempool.AddRemoteTx(tx)
+	assert.NoError(err)
 	vm.AtomicMempool.NextTx()
 	vm.AtomicMempool.DiscardCurrentTx(txID)
 
@@ -177,7 +178,8 @@ func TestMempoolAtmTxsAppGossipHandlingDiscardedTx(t *testing.T) {
 	// Conflicting tx must be submitted over the API to be included in push gossip.
 	// (i.e., txs received via p2p are not included in push gossip)
 	// This test adds it directly to the mempool + gossiper to simulate that.
-	vm.AtomicMempool.AddRemoteTx(conflictingTx)
+	err = vm.AtomicMempool.AddRemoteTx(conflictingTx)
+	assert.NoError(err)
 	vm.AtomicTxPushGossiper.Add(conflictingTx)
 	time.Sleep(500 * time.Millisecond)
 

plugin/evm/atomic/vm/vm_test.go

@@ -190,42 +190,26 @@ func testIssueAtomicTxs(t *testing.T, scheme string) {
 	utxos := map[ids.ShortID]uint64{
 		vmtest.TestShortIDAddrs[0]: importAmount,
 	}
-	addUTXOs(tvm.AtomicMemory, vm.Ctx, utxos)
+	require.NoError(t, addUTXOs(tvm.AtomicMemory, vm.Ctx, utxos))
 	defer func() {
 		if err := vm.Shutdown(context.Background()); err != nil {
 			t.Fatal(err)
 		}
 	}()
 
 	importTx, err := vm.newImportTx(vm.Ctx.XChainID, vmtest.TestEthAddrs[0], vmtest.InitialBaseFee, vmtest.TestKeys[0:1])
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if err := vm.AtomicMempool.AddLocalTx(importTx); err != nil {
-		t.Fatal(err)
-	}
-
+	require.NoError(t, err)
+	require.NoError(t, vm.AtomicMempool.AddLocalTx(importTx))
 	msg, err := vm.WaitForEvent(context.Background())
 	require.NoError(t, err)
 	require.Equal(t, commonEng.PendingTxs, msg)
 
 	blk, err := vm.BuildBlock(context.Background())
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if err := blk.Verify(context.Background()); err != nil {
-		t.Fatal(err)
-	}
-
-	if err := vm.SetPreference(context.Background(), blk.ID()); err != nil {
-		t.Fatal(err)
-	}
-
-	if err := blk.Accept(context.Background()); err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
+	require.NoError(t, blk.Verify(context.Background()))
+	require.NoError(t, vm.SetPreference(context.Background(), blk.ID()))
+	require.NoError(t, vm.SetPreference(context.Background(), blk.ID()))
+	require.NoError(t, blk.Accept(context.Background()))
 
 	if lastAcceptedID, err := vm.LastAccepted(context.Background()); err != nil {
 		t.Fatal(err)
@@ -235,36 +219,21 @@ func testIssueAtomicTxs(t *testing.T, scheme string) {
 	vm.Ethereum().BlockChain().DrainAcceptorQueue()
 
 	state, err := vm.Ethereum().BlockChain().State()
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 
 	wrappedState := extstate.New(state)
 	exportTx, err := atomic.NewExportTx(vm.Ctx, vm.CurrentRules(), wrappedState, vm.Ctx.AVAXAssetID, importAmount-(2*ap0.AtomicTxFee), vm.Ctx.XChainID, vmtest.TestShortIDAddrs[0], vmtest.InitialBaseFee, vmtest.TestKeys[0:1])
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if err := vm.AtomicMempool.AddLocalTx(exportTx); err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
+	require.NoError(t, vm.AtomicMempool.AddLocalTx(exportTx))
 
 	msg, err = vm.WaitForEvent(context.Background())
 	require.NoError(t, err)
 	require.Equal(t, commonEng.PendingTxs, msg)
 
 	blk2, err := vm.BuildBlock(context.Background())
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if err := blk2.Verify(context.Background()); err != nil {
-		t.Fatal(err)
-	}
-
-	if err := blk2.Accept(context.Background()); err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
+	require.NoError(t, blk2.Verify(context.Background()))
+	require.NoError(t, blk2.Accept(context.Background()))
 
 	if lastAcceptedID, err := vm.LastAccepted(context.Background()); err != nil {
 		t.Fatal(err)
@@ -1102,8 +1071,14 @@ func TestConsecutiveAtomicTransactionsRevertSnapshot(t *testing.T) {
 
 	// Add the two conflicting transactions directly to the mempool, so that two consecutive transactions
 	// will fail verification when build block is called.
-	vm.AtomicMempool.AddRemoteTx(importTxs[1])
-	vm.AtomicMempool.AddRemoteTx(importTxs[2])
+	err = vm.AtomicMempool.AddRemoteTx(importTxs[1])
+	if err != nil {
+		t.Fatal(err)
+	}
+	err = vm.AtomicMempool.AddRemoteTx(importTxs[2])
+	if err != nil {
+		t.Fatal(err)
+	}
 
 	if _, err := vm.BuildBlock(context.Background()); err == nil {
 		t.Fatal("Expected build block to fail due to empty block")
@@ -1149,7 +1124,10 @@ func TestAtomicTxBuildBlockDropsConflicts(t *testing.T) {
 			t.Fatal("should conflict with the utxoSet in the mempool")
 		}
 		// force add the tx
-		vm.AtomicMempool.ForceAddTx(conflictTx)
+		err = vm.AtomicMempool.ForceAddTx(conflictTx)
+		if err != nil {
+			t.Fatal(err)
+		}
 		conflictSets[index].Add(conflictTx.ID())
 	}
 	msg, err := vm.WaitForEvent(context.Background())
@@ -2116,7 +2094,8 @@ func TestWaitForEvent(t *testing.T) {
 				},
 			}}}}))
 			testCase.testCase(t, vm, address, key)
-			vm.Shutdown(context.Background())
+			err = vm.Shutdown(context.Background())
+			require.NoError(t, err)
 		})
 	}
 }

plugin/evm/message/codec.go

@@ -38,7 +38,7 @@ func init() {
 	// See https://github.com/ava-labs/coreth/pull/999
 	c.SkipRegistrations(3)
 
-	Codec.RegisterCodec(Version, c)
+	errs.Add(Codec.RegisterCodec(Version, c))
 
 	if errs.Errored() {
 		panic(errs.Err)

plugin/evm/vm.go

@@ -468,7 +468,10 @@ func (vm *VM) Initialize(
 
 	// Add p2p warp message warpHandler
 	warpHandler := acp118.NewCachedHandler(meteredCache, vm.warpBackend, vm.ctx.WarpSigner)
-	vm.Network.AddHandler(p2p.SignatureRequestHandlerID, warpHandler)
+	err = vm.Network.AddHandler(p2p.SignatureRequestHandlerID, warpHandler)
+	if err != nil {
+		return err
+	}
 
 	vm.stateSyncDone = make(chan struct{})
 
@@ -891,7 +894,10 @@ func (vm *VM) Shutdown(context.Context) error {
 	for _, handler := range vm.rpcHandlers {
 		handler.Stop()
 	}
-	vm.eth.Stop()
+	err := vm.eth.Stop()
+	if err != nil {
+		return fmt.Errorf("error stopping eth: %w", err)
+	}
 	vm.shutdownWg.Wait()
 	return nil
 }

plugin/evm/vm_test.go

@@ -2027,7 +2027,8 @@ func TestWaitForEvent(t *testing.T) {
 				Fork: &fork,
 			})
 			testCase.testCase(t, vm)
-			vm.Shutdown(context.Background())
+			err := vm.Shutdown(context.Background())
+			require.NoError(t, err)
 		})
 	}
 }

plugin/evm/vmtest/genesis.go

@@ -67,7 +67,10 @@ func NewTestGenesis(cfg *params.ChainConfig) *core.Genesis {
 	g.Config = &cpy
 
 	allocStr := `{"0100000000000000000000000000000000000000":{"code":"0x7300000000000000000000000000000000000000003014608060405260043610603d5760003560e01c80631e010439146042578063b6510bb314606e575b600080fd5b605c60048036036020811015605657600080fd5b503560b1565b60408051918252519081900360200190f35b818015607957600080fd5b5060af60048036036080811015608e57600080fd5b506001600160a01b03813516906020810135906040810135906060013560b6565b005b30cd90565b836001600160a01b031681836108fc8690811502906040516000604051808303818888878c8acf9550505050505015801560f4573d6000803e3d6000fd5b505050505056fea26469706673582212201eebce970fe3f5cb96bf8ac6ba5f5c133fc2908ae3dcd51082cfee8f583429d064736f6c634300060a0033","balance":"0x0"}}`
-	json.Unmarshal([]byte(allocStr), &g.Alloc)
+	err := json.Unmarshal([]byte(allocStr), &g.Alloc)
+	if err != nil {
+		panic(err)
+	}
 	// After Durango, an additional account is funded in tests to use
 	// with warp messages.
 	if params.GetExtra(cfg).IsDurango(0) {

plugin/evm/vmtest/test_syncervm.go

@@ -161,7 +161,11 @@ func StateSyncToggleEnabledToDisabledTest(t *testing.T, testSetup *SyncTestSetup
 		if !hasItem {
 			t.Fatal("expected nodeSet to contain at least 1 nodeID")
 		}
-		go testSyncVMSetup.serverVM.VM.AppRequest(ctx, nodeID, requestID, time.Now().Add(1*time.Second), request)
+		go func() {
+			if err := testSyncVMSetup.serverVM.VM.AppRequest(ctx, nodeID, requestID, time.Now().Add(1*time.Second), request); err != nil {
+				panic(err)
+			}
+		}()
 		return nil
 	}
 	ResetMetrics(testSyncVMSetup.syncerVM.SnowCtx)
@@ -246,7 +250,11 @@ func StateSyncToggleEnabledToDisabledTest(t *testing.T, testSetup *SyncTestSetup
 	// override [serverVM]'s SendAppResponse function to trigger AppResponse on [syncerVM]
 	testSyncVMSetup.serverVM.AppSender.SendAppResponseF = func(ctx context.Context, nodeID ids.NodeID, requestID uint32, response []byte) error {
 		if test.responseIntercept == nil {
-			go syncReEnabledVM.AppResponse(ctx, nodeID, requestID, response)
+			go func() {
+				if err := syncReEnabledVM.AppResponse(ctx, nodeID, requestID, response); err != nil {
+					panic(err)
+				}
+			}()
 		} else {
 			go test.responseIntercept(syncReEnabledVM, nodeID, requestID, response)
 		}
@@ -387,7 +395,11 @@ func initSyncServerAndClientVMs(t *testing.T, test SyncTestParams, numBlocks int
 	// override [serverVM]'s SendAppResponse function to trigger AppResponse on [syncerVM]
 	serverTest.AppSender.SendAppResponseF = func(ctx context.Context, nodeID ids.NodeID, requestID uint32, response []byte) error {
 		if test.responseIntercept == nil {
-			go syncerVM.AppResponse(ctx, nodeID, requestID, response)
+			go func() {
+				if err := syncerVM.AppResponse(ctx, nodeID, requestID, response); err != nil {
+					panic(err)
+				}
+			}()
 		} else {
 			go test.responseIntercept(syncerVM, nodeID, requestID, response)
 		}

plugin/main.go

@@ -30,5 +30,9 @@ func main() {
 		fmt.Printf("failed to set fd limit correctly due to: %s\n", err)
 		os.Exit(1)
 	}
-	rpcchainvm.Serve(context.Background(), factory.NewPluginVM())
+	err = rpcchainvm.Serve(context.Background(), factory.NewPluginVM())
+	if err != nil {
+		fmt.Printf("failed to serve rpc chain vm: %s\n", err)
+		os.Exit(1)
+	}
 }

sync/statesync/trie_sync_tasks.go

@@ -75,7 +75,10 @@ func (m *mainTrieTask) OnLeafs(db ethdb.KeyValueWriter, keys, vals [][]byte) err
 
 		// check if this account has storage root that we need to fetch
 		if acc.Root != (common.Hash{}) && acc.Root != types.EmptyRootHash {
-			m.sync.trieQueue.RegisterStorageTrie(acc.Root, accountHash)
+			err := m.sync.trieQueue.RegisterStorageTrie(acc.Root, accountHash)
+			if err != nil {
+				return err
+			}
 		}
 
 		// check if this account has code and add it to codeHashes to fetch