Rename SequenceAt (#14855)

* Rename SequenceAt

* More changes

* Add changeset

* Return uint64 instead of nonce

* Fixes

* Disable G115

.changeset/two-snails-mix.md

@@ -0,0 +1,5 @@
+---
+"chainlink": minor
+---
+
+Rename SequenceAt to NonceAt #internal

core/chains/evm/client/chain_client.go

@@ -70,7 +70,7 @@ type Client interface {
 	CodeAt(ctx context.Context, account common.Address, blockNumber *big.Int) ([]byte, error)
 	PendingCodeAt(ctx context.Context, account common.Address) ([]byte, error)
 	PendingNonceAt(ctx context.Context, account common.Address) (uint64, error)
-	SequenceAt(ctx context.Context, account common.Address, blockNumber *big.Int) (evmtypes.Nonce, error)
+	NonceAt(ctx context.Context, account common.Address, blockNumber *big.Int) (uint64, error)
 	TransactionByHash(ctx context.Context, txHash common.Hash) (*types.Transaction, error)
 	TransactionReceipt(ctx context.Context, txHash common.Hash) (*types.Receipt, error)
 	BlockByNumber(ctx context.Context, number *big.Int) (*types.Block, error)
@@ -397,12 +397,12 @@ func (c *chainClient) SendTransactionReturnCode(ctx context.Context, tx *types.T
 	return returnCode, err
 }
 
-func (c *chainClient) SequenceAt(ctx context.Context, account common.Address, blockNumber *big.Int) (evmtypes.Nonce, error) {
+func (c *chainClient) NonceAt(ctx context.Context, account common.Address, blockNumber *big.Int) (uint64, error) {
 	r, err := c.multiNode.SelectRPC()
 	if err != nil {
 		return 0, err
 	}
-	return r.SequenceAt(ctx, account, blockNumber)
+	return r.NonceAt(ctx, account, blockNumber)
 }
 
 func (c *chainClient) SubscribeFilterLogs(ctx context.Context, q ethereum.FilterQuery, ch chan<- types.Log) (s ethereum.Subscription, err error) {

core/chains/evm/client/chain_client_test.go

@@ -867,7 +867,7 @@ func TestEthClient_ErroringClient(t *testing.T) {
 	require.Equal(t, code, commonclient.Unknown)
 	require.Equal(t, err, txSenderNotStarted)
 
-	_, err = erroringClient.SequenceAt(ctx, common.Address{}, nil)
+	_, err = erroringClient.NonceAt(ctx, common.Address{}, nil)
 	require.Equal(t, err, commonclient.ErroringNodeError)
 
 	_, err = erroringClient.SubscribeFilterLogs(ctx, ethereum.FilterQuery{}, nil)

core/chains/evm/client/null_client.go

@@ -142,8 +142,8 @@ func (nc *NullClient) PendingNonceAt(ctx context.Context, account common.Address
 	return 0, nil
 }
 
-func (nc *NullClient) SequenceAt(ctx context.Context, account common.Address, blockNumber *big.Int) (evmtypes.Nonce, error) {
-	nc.lggr.Debug("SequenceAt")
+func (nc *NullClient) NonceAt(ctx context.Context, account common.Address, blockNumber *big.Int) (uint64, error) {
+	nc.lggr.Debug("NonceAt")
 	return 0, nil
 }
 

core/chains/evm/client/null_client_test.go

@@ -99,10 +99,10 @@ func TestNullClient(t *testing.T) {
 		require.Zero(t, n)
 		require.Equal(t, 1, logs.FilterMessage("PendingNonceAt").Len())
 
-		s, err := nc.SequenceAt(ctx, common.Address{}, nil)
+		s, err := nc.NonceAt(ctx, common.Address{}, nil)
 		require.NoError(t, err)
 		require.Zero(t, s)
-		require.Equal(t, 1, logs.FilterMessage("SequenceAt").Len())
+		require.Equal(t, 1, logs.FilterMessage("NonceAt").Len())
 
 		r, err := nc.TransactionReceipt(ctx, common.Hash{})
 		require.NoError(t, err)

core/chains/evm/client/rpc_client.go

@@ -854,24 +854,21 @@ func (r *RPCClient) PendingSequenceAt(ctx context.Context, account common.Addres
 	return
 }
 
-// SequenceAt is a bit of a misnomer. You might expect it to return the highest
+// NonceAt is a bit of a misnomer. You might expect it to return the highest
 // mined nonce at the given block number, but it actually returns the total
 // transaction count which is the highest mined nonce + 1
-func (r *RPCClient) SequenceAt(ctx context.Context, account common.Address, blockNumber *big.Int) (nonce evmtypes.Nonce, err error) {
+func (r *RPCClient) NonceAt(ctx context.Context, account common.Address, blockNumber *big.Int) (nonce uint64, err error) {
 	ctx, cancel, ws, http := r.makeLiveQueryCtxAndSafeGetClients(ctx, r.rpcTimeout)
 	defer cancel()
 	lggr := r.newRqLggr().With("account", account, "blockNumber", blockNumber)
 
 	lggr.Debug("RPC call: evmclient.Client#NonceAt")
 	start := time.Now()
-	var n uint64
 	if http != nil {
-		n, err = http.geth.NonceAt(ctx, account, blockNumber)
-		nonce = evmtypes.Nonce(int64(n))
+		nonce, err = http.geth.NonceAt(ctx, account, blockNumber)
 		err = r.wrapHTTP(err)
 	} else {
-		n, err = ws.geth.NonceAt(ctx, account, blockNumber)
-		nonce = evmtypes.Nonce(int64(n))
+		nonce, err = ws.geth.NonceAt(ctx, account, blockNumber)
 		err = r.wrapWS(err)
 	}
 	duration := time.Since(start)

core/chains/evm/client/simulated_backend_client.go

@@ -271,9 +271,8 @@ func (c *SimulatedBackendClient) PendingNonceAt(ctx context.Context, account com
 }
 
 // NonceAt gets nonce as of a specified block.
-func (c *SimulatedBackendClient) SequenceAt(ctx context.Context, account common.Address, blockNumber *big.Int) (evmtypes.Nonce, error) {
-	nonce, err := c.b.NonceAt(ctx, account, blockNumber)
-	return evmtypes.Nonce(nonce), err
+func (c *SimulatedBackendClient) NonceAt(ctx context.Context, account common.Address, blockNumber *big.Int) (uint64, error) {
+	return c.b.NonceAt(ctx, account, blockNumber)
 }
 
 // BalanceAt gets balance as of a specified block.

core/chains/evm/txmgr/broadcaster_test.go

@@ -1904,7 +1904,7 @@ func TestEthBroadcaster_HederaBroadcastValidation(t *testing.T) {
 		ethClient.On("SendTransactionReturnCode", mock.Anything, mock.MatchedBy(func(tx *gethTypes.Transaction) bool {
 			return tx.Nonce() == localNonce
 		}), fromAddress).Return(commonclient.Successful, nil).Once()
-		ethClient.On("SequenceAt", mock.Anything, fromAddress, mock.Anything).Return(evmtypes.Nonce(1), nil).Once()
+		ethClient.On("NonceAt", mock.Anything, fromAddress, mock.Anything).Return(uint64(1), nil).Once()
 
 		mustInsertInProgressEthTxWithAttempt(t, txStore, evmtypes.Nonce(localNonce), fromAddress)
 		nonceTracker := txmgr.NewNonceTracker(lggr, txStore, txmgr.NewEvmTxmClient(ethClient, nil))
@@ -1924,8 +1924,8 @@ func TestEthBroadcaster_HederaBroadcastValidation(t *testing.T) {
 		ethClient.On("SendTransactionReturnCode", mock.Anything, mock.MatchedBy(func(tx *gethTypes.Transaction) bool {
 			return tx.Nonce() == localNonce
 		}), fromAddress).Return(commonclient.Successful, nil).Twice()
-		ethClient.On("SequenceAt", mock.Anything, fromAddress, mock.Anything).Return(evmtypes.Nonce(0), nil).Once()
-		ethClient.On("SequenceAt", mock.Anything, fromAddress, mock.Anything).Return(evmtypes.Nonce(1), nil).Once()
+		ethClient.On("NonceAt", mock.Anything, fromAddress, mock.Anything).Return(uint64(0), nil).Once()
+		ethClient.On("NonceAt", mock.Anything, fromAddress, mock.Anything).Return(uint64(1), nil).Once()
 
 		mustInsertInProgressEthTxWithAttempt(t, txStore, evmtypes.Nonce(localNonce), fromAddress)
 		nonceTracker := txmgr.NewNonceTracker(lggr, txStore, txmgr.NewEvmTxmClient(ethClient, nil))
@@ -1946,7 +1946,7 @@ func TestEthBroadcaster_HederaBroadcastValidation(t *testing.T) {
 		ethClient.On("SendTransactionReturnCode", mock.Anything, mock.MatchedBy(func(tx *gethTypes.Transaction) bool {
 			return tx.Nonce() == localNonce
 		}), fromAddress).Return(commonclient.Successful, nil).Times(4)
-		ethClient.On("SequenceAt", mock.Anything, fromAddress, mock.Anything).Return(evmtypes.Nonce(0), nil).Times(4)
+		ethClient.On("NonceAt", mock.Anything, fromAddress, mock.Anything).Return(uint64(0), nil).Times(4)
 
 		etx := mustInsertInProgressEthTxWithAttempt(t, txStore, evmtypes.Nonce(localNonce), fromAddress)
 		nonceTracker := txmgr.NewNonceTracker(lggr, txStore, txmgr.NewEvmTxmClient(ethClient, nil))

core/chains/evm/txmgr/client.go

@@ -117,7 +117,12 @@ func (c *evmTxmClient) PendingNonceAt(ctx context.Context, fromAddress common.Ad
 }
 
 func (c *evmTxmClient) SequenceAt(ctx context.Context, addr common.Address, blockNum *big.Int) (evmtypes.Nonce, error) {
-	return c.client.SequenceAt(ctx, addr, blockNum)
+	nonce, err := c.client.NonceAt(ctx, addr, blockNum)
+	if nonce > math.MaxInt64 {
+		return 0, fmt.Errorf("overflow for nonce: %d", nonce)
+	}
+	//nolint:gosec // disable G115
+	return evmtypes.Nonce(nonce), err
 }
 
 func (c *evmTxmClient) BatchGetReceipts(ctx context.Context, attempts []TxAttempt) (txReceipt []*evmtypes.Receipt, txErr []error, funcErr error) {