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])
+	require.NoError(t, 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

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

plugin/evm/atomic/state/atomic_trie.go

@@ -244,7 +244,9 @@ func (a *AtomicTrie) InsertTrie(nodes *trienode.NodeSet, root common.Hash) error
 			return err
 		}
 	}
-	a.trieDB.Reference(root, common.Hash{})
+	if err := a.trieDB.Reference(root, common.Hash{}); 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 +287,16 @@ 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)
+	if err := a.trieDB.Dereference(a.lastAcceptedRoot); err != nil {
+		return false, err
+	}
 	a.lastAcceptedRoot = root
 	return hasCommitted, nil
 }
 
 func (a *AtomicTrie) RejectTrie(root common.Hash) error {
-	a.trieDB.Dereference(root)
+	if err := a.trieDB.Dereference(root); err != nil {
+		return err
+	}
 	return nil
 }

plugin/evm/atomic/state/atomic_trie_test.go

@@ -630,7 +630,7 @@ 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)
+			require.NoError(t, atomicTrie.updateLastCommitted(testCase.lastCommittedRoot, testCase.lastCommittedHeight))
 
 			hasCommitted, err := atomicTrie.AcceptTrie(testCase.height, testCase.root)
 			require.NoError(t, err)

plugin/evm/atomic/vm/block_extension.go

@@ -227,11 +227,16 @@ func (be *blockExtension) Reject() error {
 }
 
 // CleanupVerified is called when the block is cleaned up after a failed insertion.
-func (be *blockExtension) CleanupVerified() {
+func (be *blockExtension) CleanupVerified() error {
 	vm := be.blockExtender.vm
-	if atomicState, err := vm.AtomicBackend.GetVerifiedAtomicState(be.block.GetEthBlock().Hash()); err == nil {
-		atomicState.Reject()
+	atomicState, err := vm.AtomicBackend.GetVerifiedAtomicState(be.block.GetEthBlock().Hash())
+	if err == nil {
+		err = atomicState.Reject()
+		if err != nil {
+			return fmt.Errorf("failed to reject atomic state: %w", err)
+		}
 	}
+	return nil
 }
 
 // AtomicTxs returns the atomic transactions in this block.

plugin/evm/atomic/vm/gossiper_atomic_gossiping_test.go

@@ -143,7 +143,7 @@ func TestMempoolAtmTxsAppGossipHandlingDiscardedTx(t *testing.T) {
 	tx, conflictingTx := importTxs[0], importTxs[1]
 	txID := tx.ID()
 
-	vm.AtomicMempool.AddRemoteTx(tx)
+	require.NoError(vm.AtomicMempool.AddRemoteTx(tx))
 	vm.AtomicMempool.NextTx()
 	vm.AtomicMempool.DiscardCurrentTx(txID)
 
@@ -177,7 +177,7 @@ 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)
+	require.NoError(vm.AtomicMempool.AddRemoteTx(conflictingTx))
 	vm.AtomicTxPushGossiper.Add(conflictingTx)
 	time.Sleep(500 * time.Millisecond)
 

plugin/evm/atomic/vm/vm_test.go

@@ -190,42 +190,25 @@ 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, blk.Accept(context.Background()))
 
 	if lastAcceptedID, err := vm.LastAccepted(context.Background()); err != nil {
 		t.Fatal(err)
@@ -235,36 +218,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)
@@ -1067,30 +1035,18 @@ func TestConsecutiveAtomicTransactionsRevertSnapshot(t *testing.T) {
 	importTxs := createImportTxOptions(t, vm, tvm.AtomicMemory)
 
 	// Issue the first import transaction, build, and accept the block.
-	if err := vm.AtomicMempool.AddLocalTx(importTxs[0]); err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, vm.AtomicMempool.AddLocalTx(importTxs[0]))
 
 	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)
-	}
+	require.NoError(t, err)
 
-	if err := blk.Accept(context.Background()); err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, blk.Verify(context.Background()))
+	require.NoError(t, vm.SetPreference(context.Background(), blk.ID()))
+	require.NoError(t, blk.Accept(context.Background()))
 
 	newHead := <-newTxPoolHeadChan
 	if newHead.Head.Hash() != common.Hash(blk.ID()) {
@@ -1099,8 +1055,8 @@ 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])
+	require.NoError(t, vm.AtomicMempool.ForceAddTx(importTxs[1]))
+	require.NoError(t, vm.AtomicMempool.ForceAddTx(importTxs[2]))
 
 	if _, err := vm.BuildBlock(context.Background()); err == nil {
 		t.Fatal("Expected build block to fail due to empty block")
@@ -1146,7 +1102,9 @@ func TestAtomicTxBuildBlockDropsConflicts(t *testing.T) {
 			t.Fatal("should conflict with the utxoSet in the mempool")
 		}
 		// force add the tx
-		vm.AtomicMempool.ForceAddTx(conflictTx)
+		if err := vm.AtomicMempool.ForceAddTx(conflictTx); err != nil {
+			t.Fatal(err)
+		}
 		conflictSets[index].Add(conflictTx.ID())
 	}
 	msg, err := vm.WaitForEvent(context.Background())
@@ -2112,7 +2070,7 @@ func TestWaitForEvent(t *testing.T) {
 				},
 			}}}}))
 			testCase.testCase(t, vm, address, key)
-			vm.Shutdown(context.Background())
+			require.NoError(t, vm.Shutdown(context.Background()))
 		})
 	}
 }

plugin/evm/extension/config.go

@@ -103,7 +103,7 @@ type BlockExtension interface {
 	// CleanupVerified is called when a block has passed SemanticVerify and SynctacticVerify,
 	// and should be cleaned up due to error or verification runs under non-write mode. This
 	// does not return an error because the block has already been verified.
-	CleanupVerified()
+	CleanupVerified() error
 	// Accept is called when a block is accepted by the block manager. Accept takes a
 	// database.Batch that contains the changes that were made to the database as a result
 	// of accepting the block. The changes in the batch should be flushed to the database in this method.

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

@@ -466,7 +466,9 @@ func (vm *VM) Initialize(
 
 	// Add p2p warp message warpHandler
 	warpHandler := acp118.NewCachedHandler(meteredCache, vm.warpBackend, vm.ctx.WarpSigner)
-	vm.Network.AddHandler(p2p.SignatureRequestHandlerID, warpHandler)
+	if err = vm.Network.AddHandler(p2p.SignatureRequestHandlerID, warpHandler); err != nil {
+		return err
+	}
 
 	vm.stateSyncDone = make(chan struct{})
 
@@ -888,7 +890,9 @@ func (vm *VM) Shutdown(context.Context) error {
 	for _, handler := range vm.rpcHandlers {
 		handler.Stop()
 	}
-	vm.eth.Stop()
+	if err := vm.eth.Stop(); err != nil {
+		log.Error("error stopping eth", "err", err)
+	}
 	vm.shutdownWg.Wait()
 	return nil
 }