style: enable depguard linter

.avalanche-golangci.yml

@@ -54,7 +54,7 @@ linters:
     - asciicheck
     - bodyclose
     - copyloopvar
-    # - depguard
+    - depguard
     # - errcheck
     - errorlint
     # - forbidigo

core/coretest/test_indices.go

@@ -9,7 +9,6 @@ import (
 
 	"github.com/ava-labs/libevm/core/rawdb"
 	"github.com/ava-labs/libevm/ethdb"
-	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
@@ -25,10 +24,10 @@ func CheckTxIndices(t *testing.T, expectedTail *uint64, indexedFrom uint64, inde
 		var stored uint64
 		tailValue := *expectedTail
 
-		require.EventuallyWithTf(t,
-			func(c *assert.CollectT) {
+		require.Eventually(t,
+			func() bool {
 				stored = *rawdb.ReadTxIndexTail(db)
-				assert.Equalf(c, tailValue, stored, "expected tail to be %d, found %d", tailValue, stored)
+				return tailValue == stored
 			},
 			30*time.Second, 500*time.Millisecond, "expected tail to be %d eventually", tailValue)
 	}

core/extstate/state_object_test.go

@@ -7,7 +7,7 @@ import (
 	"testing"
 
 	"github.com/ava-labs/libevm/common"
-	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestStateKeyPartition(t *testing.T) {
@@ -61,11 +61,11 @@ func TestStateKeyPartition(t *testing.T) {
 		t.Run(test.key.Hex(), func(t *testing.T) {
 			coin := test.key
 			normalizeCoinID(&coin)
-			assert.Equal(t, test.wantCoinID, coin)
+			require.Equal(t, test.wantCoinID, coin)
 
 			state := test.key
 			normalizeStateKey(&state)
-			assert.Equal(t, test.wantStateKey, state)
+			require.Equal(t, test.wantStateKey, state)
 		})
 	}
 }
@@ -81,6 +81,6 @@ func FuzzStateKeyPartition(f *testing.F) {
 		)
 		normalizeCoinID(&coin)
 		normalizeStateKey(&state)
-		assert.NotEqual(t, coin, state)
+		require.NotEqual(t, coin, state)
 	})
 }

internal/ethapi/api_extra_test.go

@@ -12,7 +12,6 @@ import (
 	"github.com/ava-labs/libevm/common"
 	"github.com/ava-labs/libevm/common/hexutil"
 	"github.com/ava-labs/libevm/core/types"
-	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"go.uber.org/mock/gomock"
 
@@ -39,7 +38,7 @@ func TestBlockchainAPI_GetChainConfig(t *testing.T) {
 	api := NewBlockChainAPI(backend)
 
 	gotConfig := api.GetChainConfig(context.Background())
-	assert.Equal(t, wantConfig, gotConfig)
+	require.Equal(t, wantConfig, gotConfig)
 }
 
 // Copy one test case from TestCall
@@ -196,9 +195,9 @@ func TestBlockChainAPI_stateQueryBlockNumberAllowed(t *testing.T) {
 
 			err := api.stateQueryBlockNumberAllowed(testCase.blockNumOrHash)
 			if testCase.wantErrMessage == "" {
-				assert.NoError(t, err)
+				require.NoError(t, err)
 			} else {
-				assert.EqualError(t, err, testCase.wantErrMessage)
+				require.EqualError(t, err, testCase.wantErrMessage)
 			}
 		})
 	}

nativeasset/contract_test.go

@@ -12,7 +12,6 @@ import (
 	"github.com/ava-labs/libevm/core/state"
 	"github.com/ava-labs/libevm/core/vm"
 	"github.com/holiman/uint256"
-	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
 	// Force import core to register the VM hooks.
@@ -86,6 +85,7 @@ func TestStatefulPrecompile(t *testing.T) {
 	assetID := common.BytesToHash([]byte("ScoobyCoin"))
 	zeroBytes := make([]byte, 32)
 	big0 := uint256.NewInt(0)
+	bigZero := big.NewInt(0)
 	bigHundred := big.NewInt(100)
 	u256Hundred := uint256.NewInt(100)
 	oneHundredBytes := make([]byte, 32)
@@ -256,7 +256,7 @@ func TestStatefulPrecompile(t *testing.T) {
 
 				expectedBalance := big.NewInt(50)
 				require.Equal(t, u256Hundred, user1Balance, "user 1 balance")
-				require.Equal(t, big0, user2Balance, "user 2 balance")
+				require.True(t, user2Balance.IsZero(), "user 2 balance should be zero")
 				require.Equal(t, expectedBalance, user1AssetBalance, "user 1 asset balance")
 				require.Equal(t, expectedBalance, user2AssetBalance, "user 2 asset balance")
 			},
@@ -292,7 +292,7 @@ func TestStatefulPrecompile(t *testing.T) {
 				expectedBalance := big.NewInt(50)
 
 				require.Equal(t, uint256.NewInt(51), user1Balance, "user 1 balance")
-				require.Equal(t, big0, user2Balance, "user 2 balance")
+				require.True(t, user2Balance.IsZero(), "user 2 balance should be zero")
 				require.Equal(t, uint256.NewInt(49), nativeAssetCallAddrBalance, "native asset call addr balance")
 				require.Equal(t, expectedBalance, user1AssetBalance, "user 1 asset balance")
 				require.Equal(t, expectedBalance, user2AssetBalance, "user 2 asset balance")
@@ -326,10 +326,10 @@ func TestStatefulPrecompile(t *testing.T) {
 				user1AssetBalance := wrappedStateDB.GetBalanceMultiCoin(userAddr1, assetID)
 				user2AssetBalance := wrappedStateDB.GetBalanceMultiCoin(userAddr2, assetID)
 
-				require.Equal(t, bigHundred, user1Balance, "user 1 balance")
-				require.Equal(t, big0, user2Balance, "user 2 balance")
-				require.Equal(t, big.NewInt(51), user1AssetBalance, "user 1 asset balance")
-				require.Equal(t, big0, user2AssetBalance, "user 2 asset balance")
+				require.Equal(t, u256Hundred, user1Balance, "user 1 balance")
+				require.True(t, user2Balance.IsZero(), "user 2 balance should be zero")
+				require.Equal(t, big.NewInt(50), user1AssetBalance, "user 1 asset balance")
+				require.Equal(t, 0, user2AssetBalance.Cmp(bigZero), "user 2 asset balance should be zero")
 			},
 		},
 		{
@@ -360,10 +360,10 @@ func TestStatefulPrecompile(t *testing.T) {
 				user1AssetBalance := wrappedStateDB.GetBalanceMultiCoin(userAddr1, assetID)
 				user2AssetBalance := wrappedStateDB.GetBalanceMultiCoin(userAddr2, assetID)
 
-				require.Equal(t, big.NewInt(50), user1Balance, "user 1 balance")
-				require.Equal(t, big0, user2Balance, "user 2 balance")
+				require.Equal(t, uint256.NewInt(50), user1Balance, "user 1 balance")
+				require.True(t, user2Balance.IsZero(), "user 2 balance should be zero")
 				require.Equal(t, big.NewInt(50), user1AssetBalance, "user 1 asset balance")
-				require.Equal(t, big0, user2AssetBalance, "user 2 asset balance")
+				require.Equal(t, 0, user2AssetBalance.Cmp(bigZero), "user 2 asset balance should be zero")
 			},
 		},
 		{
@@ -416,10 +416,10 @@ func TestStatefulPrecompile(t *testing.T) {
 				user1AssetBalance := wrappedStateDB.GetBalanceMultiCoin(userAddr1, assetID)
 				user2AssetBalance := wrappedStateDB.GetBalanceMultiCoin(userAddr2, assetID)
 
-				require.Equal(t, bigHundred, user1Balance, "user 1 balance")
-				require.Equal(t, big0, user2Balance, "user 2 balance")
+				require.Equal(t, u256Hundred, user1Balance, "user 1 balance")
+				require.True(t, user2Balance.IsZero(), "user 2 balance should be zero")
 				require.Equal(t, bigHundred, user1AssetBalance, "user 1 asset balance")
-				require.Equal(t, big0, user2AssetBalance, "user 2 asset balance")
+				require.Equal(t, 0, user2AssetBalance.Cmp(bigZero), "user 2 asset balance should be zero")
 			},
 		},
 		{
@@ -474,17 +474,12 @@ func TestStatefulPrecompile(t *testing.T) {
 			evm := vm.NewEVM(vmCtx, vm.TxContext{}, stateDB, params.TestApricotPhase5Config, vm.Config{}) // Use ApricotPhase5Config because these precompiles are deprecated in ApricotPhase6.
 			ret, gasRemaining, err := evm.Call(vm.AccountRef(test.from), test.precompileAddr, test.input, test.gasInput, test.value)
 			// Place gas remaining check before error check, so that it is not skipped when there is an error
-			assert.Equalf(t, test.expectedGasRemaining, gasRemaining, "unexpected gas remaining (%d of %d)", gasRemaining, test.gasInput)
+			require.Equalf(t, test.expectedGasRemaining, gasRemaining, "unexpected gas remaining (%d of %d)", gasRemaining, test.gasInput)
 
-			if test.expectedErr != nil {
-				assert.Equal(t, test.expectedErr, err, "expected error to match")
-				return
-			}
-			if assert.NoError(t, err, "EVM Call produced unexpected error") {
-				assert.Equal(t, test.expectedResult, ret, "unexpected return value")
-				if test.stateDBCheck != nil {
-					test.stateDBCheck(t, stateDB)
-				}
+			require.ErrorIs(t, err, test.expectedErr)
+			require.Equal(t, test.expectedResult, ret, "unexpected return value")
+			if test.stateDBCheck != nil {
+				test.stateDBCheck(t, stateDB)
 			}
 		})
 	}

network/network_test.go

@@ -22,8 +22,8 @@ import (
 	"github.com/ava-labs/avalanchego/utils/set"
 	"github.com/ava-labs/avalanchego/version"
 	"github.com/prometheus/client_golang/prometheus"
-	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+	"golang.org/x/sync/errgroup"
 
 	"github.com/ava-labs/coreth/plugin/evm/message"
 )
@@ -107,26 +107,33 @@ func TestRequestAnyRequestsRoutingAndResponse(t *testing.T) {
 	numCallsPerRequest := 1 // on sending response
 	totalCalls := totalRequests * numCallsPerRequest
 
-	requestWg := &sync.WaitGroup{}
-	requestWg.Add(totalCalls)
+	eg := errgroup.Group{}
 	for i := 0; i < totalCalls; i++ {
-		go func(wg *sync.WaitGroup) {
-			defer wg.Done()
+		eg.Go(func() error {
 			requestBytes, err := message.RequestToBytes(codecManager, requestMessage)
-			assert.NoError(t, err)
+			if err != nil {
+				return fmt.Errorf("failed to convert request to bytes: %w", err)
+			}
 			responseBytes, _, err := net.SendSyncedAppRequestAny(context.Background(), defaultPeerVersion, requestBytes)
-			assert.NoError(t, err)
-			assert.NotNil(t, responseBytes)
+			if err != nil {
+				return fmt.Errorf("failed to send synced app request: %w", err)
+			}
+			if responseBytes == nil {
+				return errors.New("response bytes should not be nil")
+			}
 
 			var response TestMessage
 			if _, err = codecManager.Unmarshal(responseBytes, &response); err != nil {
-				panic(fmt.Errorf("unexpected error during unmarshal: %w", err))
+				return fmt.Errorf("unexpected error during unmarshal: %w", err)
+			}
+			if response.Message != "Hi" {
+				return fmt.Errorf("expected response message 'Hi', got %q", response.Message)
 			}
-			assert.Equal(t, "Hi", response.Message)
-		}(requestWg)
+			return nil
+		})
 	}
 
-	requestWg.Wait()
+	require.NoError(t, eg.Wait())
 	senderWg.Wait()
 	require.Equal(t, totalCalls, int(atomic.LoadUint32(&callNum)))
 }
@@ -218,29 +225,36 @@ func TestRequestRequestsRoutingAndResponse(t *testing.T) {
 	numCallsPerRequest := 1 // on sending response
 	totalCalls := totalRequests * numCallsPerRequest
 
-	requestWg := &sync.WaitGroup{}
-	requestWg.Add(totalCalls)
+	eg := errgroup.Group{}
 	nodeIdx := 0
 	for i := 0; i < totalCalls; i++ {
 		nodeIdx = (nodeIdx + 1) % (len(nodes))
 		nodeID := nodes[nodeIdx]
-		go func(wg *sync.WaitGroup, nodeID ids.NodeID) {
-			defer wg.Done()
+		eg.Go(func() error {
 			requestBytes, err := message.RequestToBytes(codecManager, requestMessage)
-			assert.NoError(t, err)
+			if err != nil {
+				return fmt.Errorf("failed to convert request to bytes: %w", err)
+			}
 			responseBytes, err := net.SendSyncedAppRequest(context.Background(), nodeID, requestBytes)
-			assert.NoError(t, err)
-			assert.NotNil(t, responseBytes)
+			if err != nil {
+				return fmt.Errorf("failed to send synced app request: %w", err)
+			}
+			if responseBytes == nil {
+				return errors.New("response bytes should not be nil")
+			}
 
 			var response TestMessage
 			if _, err = codecManager.Unmarshal(responseBytes, &response); err != nil {
-				panic(fmt.Errorf("unexpected error during unmarshal: %w", err))
+				return fmt.Errorf("unexpected error during unmarshal: %w", err)
+			}
+			if response.Message != "Hi" {
+				return fmt.Errorf("expected response message 'Hi', got %q", response.Message)
 			}
-			assert.Equal(t, "Hi", response.Message)
-		}(requestWg, nodeID)
+			return nil
+		})
 	}
 
-	requestWg.Wait()
+	require.NoError(t, eg.Wait())
 	senderWg.Wait()
 	require.Equal(t, totalCalls, int(atomic.LoadUint32(&callNum)))
 	for _, nodeID := range nodes {
@@ -285,16 +299,25 @@ func TestAppRequestOnShutdown(t *testing.T) {
 	requestMessage := HelloRequest{Message: "this is a request"}
 	require.NoError(t, net.Connected(context.Background(), nodeID, defaultPeerVersion))
 
-	wg.Add(1)
+	doneChan := make(chan error, 1)
 	go func() {
-		defer wg.Done()
 		requestBytes, err := message.RequestToBytes(codecManager, requestMessage)
-		assert.NoError(t, err)
+		if err != nil {
+			doneChan <- fmt.Errorf("failed to convert request to bytes: %w", err)
+			return
+		}
 		responseBytes, _, err := net.SendSyncedAppRequestAny(context.Background(), defaultPeerVersion, requestBytes)
-		assert.ErrorIs(t, err, errRequestFailed)
-		assert.Nil(t, responseBytes)
+		if !errors.Is(err, errRequestFailed) {
+			doneChan <- fmt.Errorf("expected errRequestFailed, got: %w", err)
+			return
+		}
+		if responseBytes != nil {
+			doneChan <- errors.New("response bytes should be nil")
+			return
+		}
+		doneChan <- nil
 	}()
-	wg.Wait()
+	require.NoError(t, <-doneChan)
 	require.True(t, called)
 }
 
@@ -355,18 +378,21 @@ func TestSyncedAppRequestAnyOnCtxCancellation(t *testing.T) {
 	// Cancel context after sending
 	require.Empty(t, net.(*network).outstandingRequestHandlers) // no outstanding requests
 	ctx, cancel = context.WithCancel(context.Background())
-	doneChan := make(chan struct{})
+	doneChan := make(chan error, 1)
 	go func() {
 		_, _, err = net.SendSyncedAppRequestAny(ctx, defaultPeerVersion, requestBytes)
-		assert.ErrorIs(t, err, context.Canceled)
-		close(doneChan)
+		if !errors.Is(err, context.Canceled) {
+			doneChan <- fmt.Errorf("expected context.Canceled, got: %w", err)
+			return
+		}
+		doneChan <- nil
 	}()
 	// Wait until we've "sent" the app request over the network
 	// before cancelling context.
 	sentAppRequestInfo := <-sentAppRequest
 	require.Len(t, net.(*network).outstandingRequestHandlers, 1)
 	cancel()
-	<-doneChan
+	require.NoError(t, <-doneChan)
 	// Should still be able to process a response after cancelling.
 	require.Len(t, net.(*network).outstandingRequestHandlers, 1) // context cancellation SendAppRequestAny failure doesn't clear
 	require.NoError(t, net.AppResponse(
@@ -396,7 +422,7 @@ func TestRequestMinVersion(t *testing.T) {
 				if err != nil {
 					panic(err)
 				}
-				assert.NoError(t, net.AppResponse(context.Background(), nodeID, reqID, responseBytes))
+				require.NoError(t, net.AppResponse(context.Background(), nodeID, reqID, responseBytes))
 			}()
 			return nil
 		},

params/extras/config_extra_test.go

@@ -6,7 +6,7 @@ package extras
 import (
 	"testing"
 
-	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 
 	"github.com/ava-labs/coreth/utils"
 )
@@ -52,7 +52,7 @@ func TestIsTimestampForked(t *testing.T) {
 	} {
 		t.Run(name, func(t *testing.T) {
 			res := isTimestampForked(test.fork, test.block)
-			assert.Equal(t, test.isForked, res)
+			require.Equal(t, test.isForked, res)
 		})
 	}
 }
@@ -122,7 +122,7 @@ func TestIsForkTransition(t *testing.T) {
 	} {
 		t.Run(name, func(t *testing.T) {
 			res := IsForkTransition(test.fork, test.parent, test.current)
-			assert.Equal(t, test.transitioned, res)
+			require.Equal(t, test.transitioned, res)
 		})
 	}
 }