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.
@@ -474,17 +473,16 @@ 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")
+				require.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.NoError(t, err, "EVM Call produced unexpected error")
+			require.Equal(t, test.expectedResult, ret, "unexpected return value")
+			if test.stateDBCheck != nil {
+				test.stateDBCheck(t, stateDB)
 			}
 		})
 	}

network/network_test.go

@@ -22,7 +22,6 @@ 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"
 
 	"github.com/ava-labs/coreth/plugin/evm/message"
@@ -113,16 +112,16 @@ func TestRequestAnyRequestsRoutingAndResponse(t *testing.T) {
 		go func(wg *sync.WaitGroup) {
 			defer wg.Done()
 			requestBytes, err := message.RequestToBytes(codecManager, requestMessage)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			responseBytes, _, err := net.SendSyncedAppRequestAny(context.Background(), defaultPeerVersion, requestBytes)
-			assert.NoError(t, err)
-			assert.NotNil(t, responseBytes)
+			require.NoError(t, err)
+			require.NotNil(t, responseBytes)
 
 			var response TestMessage
 			if _, err = codecManager.Unmarshal(responseBytes, &response); err != nil {
 				panic(fmt.Errorf("unexpected error during unmarshal: %w", err))
 			}
-			assert.Equal(t, "Hi", response.Message)
+			require.Equal(t, "Hi", response.Message)
 		}(requestWg)
 	}
 
@@ -227,16 +226,16 @@ func TestRequestRequestsRoutingAndResponse(t *testing.T) {
 		go func(wg *sync.WaitGroup, nodeID ids.NodeID) {
 			defer wg.Done()
 			requestBytes, err := message.RequestToBytes(codecManager, requestMessage)
-			assert.NoError(t, err)
+			require.NoError(t, err)
 			responseBytes, err := net.SendSyncedAppRequest(context.Background(), nodeID, requestBytes)
-			assert.NoError(t, err)
-			assert.NotNil(t, responseBytes)
+			require.NoError(t, err)
+			require.NotNil(t, responseBytes)
 
 			var response TestMessage
 			if _, err = codecManager.Unmarshal(responseBytes, &response); err != nil {
 				panic(fmt.Errorf("unexpected error during unmarshal: %w", err))
 			}
-			assert.Equal(t, "Hi", response.Message)
+			require.Equal(t, "Hi", response.Message)
 		}(requestWg, nodeID)
 	}
 
@@ -289,10 +288,10 @@ func TestAppRequestOnShutdown(t *testing.T) {
 	go func() {
 		defer wg.Done()
 		requestBytes, err := message.RequestToBytes(codecManager, requestMessage)
-		assert.NoError(t, err)
+		require.NoError(t, err)
 		responseBytes, _, err := net.SendSyncedAppRequestAny(context.Background(), defaultPeerVersion, requestBytes)
-		assert.ErrorIs(t, err, errRequestFailed)
-		assert.Nil(t, responseBytes)
+		require.ErrorIs(t, err, errRequestFailed)
+		require.Nil(t, responseBytes)
 	}()
 	wg.Wait()
 	require.True(t, called)
@@ -358,7 +357,7 @@ func TestSyncedAppRequestAnyOnCtxCancellation(t *testing.T) {
 	doneChan := make(chan struct{})
 	go func() {
 		_, _, err = net.SendSyncedAppRequestAny(ctx, defaultPeerVersion, requestBytes)
-		assert.ErrorIs(t, err, context.Canceled)
+		require.ErrorIs(t, err, context.Canceled)
 		close(doneChan)
 	}()
 	// Wait until we've "sent" the app request over the network
@@ -396,7 +395,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)
 		})
 	}
 }

params/protocol_params_test.go

@@ -7,7 +7,7 @@ import (
 	"testing"
 
 	"github.com/ava-labs/libevm/common"
-	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 
 	ethparams "github.com/ava-labs/libevm/params"
 )
@@ -138,6 +138,6 @@ func TestUpstreamParamsValues(t *testing.T) {
 	}
 
 	for name, test := range tests {
-		assert.Equal(t, test.want, test.param, name)
+		require.Equal(t, test.want, test.param, name)
 	}
 }

plugin/evm/atomic/txpool/tx_heap_test.go

@@ -7,7 +7,7 @@ import (
 	"testing"
 
 	"github.com/holiman/uint256"
-	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 
 	"github.com/ava-labs/coreth/plugin/evm/atomic"
 )
@@ -45,79 +45,79 @@ func TestTxHeap(t *testing.T) {
 
 	t.Run("add/remove single entry", func(t *testing.T) {
 		h := newTxHeap(3)
-		assert.Zero(t, h.Len())
+		require.Zero(t, h.Len())
 
-		assert := assert.New(t)
+		require := require.New(t)
 		h.Push(tx0, *uint256.NewInt(5))
-		assert.True(h.Has(id0))
+		require.True(h.Has(id0))
 		gTx0, gHas0 := h.Get(id0)
-		assert.Equal(tx0, gTx0)
-		assert.True(gHas0)
+		require.Equal(tx0, gTx0)
+		require.True(gHas0)
 		h.Remove(id0)
-		assert.False(h.Has(id0))
-		assert.Zero(h.Len())
+		require.False(h.Has(id0))
+		require.Zero(h.Len())
 		h.Push(tx0, *uint256.NewInt(5))
-		assert.True(h.Has(id0))
-		assert.Equal(1, h.Len())
+		require.True(h.Has(id0))
+		require.Equal(1, h.Len())
 	})
 
 	t.Run("add other items", func(t *testing.T) {
 		h := newTxHeap(3)
-		assert.Zero(t, h.Len())
+		require.Zero(t, h.Len())
 
-		assert := assert.New(t)
+		require := require.New(t)
 		h.Push(tx1, *uint256.NewInt(10))
-		assert.True(h.Has(id1))
+		require.True(h.Has(id1))
 		gTx1, gHas1 := h.Get(id1)
-		assert.Equal(tx1, gTx1)
-		assert.True(gHas1)
+		require.Equal(tx1, gTx1)
+		require.True(gHas1)
 
 		h.Push(tx2, *uint256.NewInt(2))
-		assert.True(h.Has(id2))
+		require.True(h.Has(id2))
 		gTx2, gHas2 := h.Get(id2)
-		assert.Equal(tx2, gTx2)
-		assert.True(gHas2)
+		require.Equal(tx2, gTx2)
+		require.True(gHas2)
 
-		assert.Equal(id1, h.PopMax().ID())
-		assert.Equal(id2, h.PopMax().ID())
+		require.Equal(id1, h.PopMax().ID())
+		require.Equal(id2, h.PopMax().ID())
 
-		assert.False(h.Has(id0))
+		require.False(h.Has(id0))
 		gTx0, gHas0 := h.Get(id0)
-		assert.Nil(gTx0)
-		assert.False(gHas0)
+		require.Nil(gTx0)
+		require.False(gHas0)
 
-		assert.False(h.Has(id1))
+		require.False(h.Has(id1))
 		gTx1, gHas1 = h.Get(id1)
-		assert.Nil(gTx1)
-		assert.False(gHas1)
+		require.Nil(gTx1)
+		require.False(gHas1)
 
-		assert.False(h.Has(id2))
+		require.False(h.Has(id2))
 		gTx2, gHas2 = h.Get(id2)
-		assert.Nil(gTx2)
-		assert.False(gHas2)
+		require.Nil(gTx2)
+		require.False(gHas2)
 	})
 
 	verifyRemovalOrder := func(t *testing.T, h *txHeap) {
 		t.Helper()
 
-		assert := assert.New(t)
-		assert.Equal(id2, h.PopMin().ID())
-		assert.True(h.Has(id0))
-		assert.True(h.Has(id1))
-		assert.False(h.Has(id2))
-		assert.Equal(id0, h.PopMin().ID())
-		assert.False(h.Has(id0))
-		assert.True(h.Has(id1))
-		assert.False(h.Has(id2))
-		assert.Equal(id1, h.PopMin().ID())
-		assert.False(h.Has(id0))
-		assert.False(h.Has(id1))
-		assert.False(h.Has(id2))
+		require := require.New(t)
+		require.Equal(id2, h.PopMin().ID())
+		require.True(h.Has(id0))
+		require.True(h.Has(id1))
+		require.False(h.Has(id2))
+		require.Equal(id0, h.PopMin().ID())
+		require.False(h.Has(id0))
+		require.True(h.Has(id1))
+		require.False(h.Has(id2))
+		require.Equal(id1, h.PopMin().ID())
+		require.False(h.Has(id0))
+		require.False(h.Has(id1))
+		require.False(h.Has(id2))
 	}
 
 	t.Run("drop", func(t *testing.T) {
 		h := newTxHeap(3)
-		assert.Zero(t, h.Len())
+		require.Zero(t, h.Len())
 
 		h.Push(tx0, *uint256.NewInt(5))
 		h.Push(tx1, *uint256.NewInt(10))
@@ -126,7 +126,7 @@ func TestTxHeap(t *testing.T) {
 	})
 	t.Run("drop (alt order)", func(t *testing.T) {
 		h := newTxHeap(3)
-		assert.Zero(t, h.Len())
+		require.Zero(t, h.Len())
 
 		h.Push(tx0, *uint256.NewInt(5))
 		h.Push(tx2, *uint256.NewInt(2))
@@ -135,7 +135,7 @@ func TestTxHeap(t *testing.T) {
 	})
 	t.Run("drop (alt order 2)", func(t *testing.T) {
 		h := newTxHeap(3)
-		assert.Zero(t, h.Len())
+		require.Zero(t, h.Len())
 
 		h.Push(tx2, *uint256.NewInt(2))
 		h.Push(tx0, *uint256.NewInt(5))