feat(anvil): eth_getTransactionBySenderAndNonce RPC method (#12497)

* feat(anvil): implement eth_getTransactionBySenderAndNonce RPC method

* style: cargo fmt

* chore: fix typo

---------

Co-authored-by: Matthias Seitz <matthias.seitz@outlook.de>

Author: 0xChaddB

crates/anvil/core/src/eth/mod.rs

@@ -678,6 +678,14 @@ pub enum EthRequest {
         #[serde(deserialize_with = "deserialize_number")] U256,
     ),
 
+    /// Returns the transaction by sender and nonce
+    /// Returns the full transaction data.
+    #[serde(rename = "eth_getTransactionBySenderAndNonce")]
+    EthGetTransactionBySenderAndNonce(
+        Address,
+        #[serde(deserialize_with = "deserialize_number")] U256,
+    ),
+
     /// Otterscan's `ots_getTransactionBySenderAndNonce` endpoint
     /// Given an ETH contract address, returns the tx hash and the direct address who created the
     /// contract.

crates/anvil/src/eth/api.rs

@@ -30,7 +30,7 @@ use crate::{
     mem::transaction_build,
 };
 use alloy_consensus::{
-    Account, Blob,
+    Account, Blob, Transaction,
     transaction::{Recovered, eip4844::TxEip4844Variant},
 };
 use alloy_dyn_abi::TypedData;
@@ -501,6 +501,9 @@ impl EthApi {
             EthRequest::OtsGetTransactionBySenderAndNonce(address, nonce) => {
                 self.ots_get_transaction_by_sender_and_nonce(address, nonce).await.to_rpc_result()
             }
+            EthRequest::EthGetTransactionBySenderAndNonce(sender, nonce) => {
+                self.transaction_by_sender_and_nonce(sender, nonce).await.to_rpc_result()
+            }
             EthRequest::OtsGetContractCreator(address) => {
                 self.ots_get_contract_creator(address).await.to_rpc_result()
             }
@@ -1447,6 +1450,91 @@ impl EthApi {
         self.backend.transaction_by_block_number_and_index(block, idx).await
     }
 
+    /// Returns the transaction by sender and nonce.
+    ///
+    /// This will check the mempool for pending transactions first, then perform a binary search
+    /// over mined blocks to find the transaction.
+    ///
+    /// Handler for ETH RPC call: `eth_getTransactionBySenderAndNonce`
+    pub async fn transaction_by_sender_and_nonce(
+        &self,
+        sender: Address,
+        nonce: U256,
+    ) -> Result<Option<AnyRpcTransaction>> {
+        node_info!("eth_getTransactionBySenderAndNonce");
+
+        // check pending txs first
+        for pending_tx in self.pool.ready_transactions().chain(self.pool.pending_transactions()) {
+            if U256::from(pending_tx.pending_transaction.nonce()) == nonce
+                && *pending_tx.pending_transaction.sender() == sender
+            {
+                let tx = transaction_build(
+                    Some(*pending_tx.pending_transaction.hash()),
+                    pending_tx.pending_transaction.transaction.clone(),
+                    None,
+                    None,
+                    Some(self.backend.base_fee()),
+                );
+
+                let WithOtherFields { inner: mut tx, other } = tx.0;
+                // we set the from field here explicitly to the set sender of the pending
+                // transaction, in case the transaction is impersonated.
+                let from = *pending_tx.pending_transaction.sender();
+                tx.inner = Recovered::new_unchecked(tx.inner.into_inner(), from);
+
+                return Ok(Some(AnyRpcTransaction(WithOtherFields { inner: tx, other })));
+            }
+        }
+
+        let highest_nonce = self.transaction_count(sender, None).await?.saturating_to::<u64>();
+        let target_nonce = nonce.saturating_to::<u64>();
+
+        // if the nonce is higher or equal to the highest nonce, the transaction doesn't exist
+        if target_nonce >= highest_nonce {
+            return Ok(None);
+        }
+
+        // no mined blocks yet
+        let latest_block = self.backend.best_number();
+        if latest_block == 0 {
+            return Ok(None);
+        }
+
+        // binary search for the block containing the transaction
+        let mut low = 1u64;
+        let mut high = latest_block;
+
+        while low <= high {
+            let mid = low + (high - low) / 2;
+            let mid_nonce =
+                self.transaction_count(sender, Some(mid.into())).await?.saturating_to::<u64>();
+
+            if mid_nonce > target_nonce {
+                high = mid - 1;
+            } else {
+                low = mid + 1;
+            }
+        }
+
+        // search in the target block
+        let target_block = low;
+        if target_block <= latest_block
+            && let Some(txs) =
+                self.backend.mined_transactions_by_block_number(target_block.into()).await
+        {
+            for tx in txs {
+                if tx.from() == sender
+                    && tx.nonce() == target_nonce
+                    && let Some(mined_tx) = self.backend.transaction_by_hash(tx.tx_hash()).await?
+                {
+                    return Ok(Some(mined_tx));
+                }
+            }
+        }
+
+        Ok(None)
+    }
+
     /// Returns transaction receipt by transaction hash.
     ///
     /// Handler for ETH RPC call: `eth_getTransactionReceipt`

crates/anvil/tests/it/transaction.rs

@@ -2,6 +2,7 @@ use crate::{
     abi::{Greeter, Multicall, SimpleStorage},
     utils::{connect_pubsub, http_provider_with_signer},
 };
+use alloy_consensus::Transaction;
 use alloy_hardforks::EthereumHardfork;
 use alloy_network::{EthereumWallet, TransactionBuilder, TransactionResponse};
 use alloy_primitives::{Address, Bytes, FixedBytes, U256, address, hex, map::B256HashSet};
@@ -1381,3 +1382,96 @@ async fn can_send_tx_osaka_valid_with_limit_disabled() {
     let tx_receipt = pending_tx.get_receipt().await.unwrap();
     assert!(tx_receipt.inner.inner.is_success());
 }
+
+#[tokio::test(flavor = "multi_thread")]
+async fn can_get_tx_by_sender_and_nonce() {
+    let (api, handle) = spawn(NodeConfig::test()).await;
+    let provider = handle.http_provider();
+
+    let accounts = handle.dev_wallets().collect::<Vec<_>>();
+    let sender = accounts[0].address();
+    let recipient = accounts[1].address();
+
+    api.anvil_set_auto_mine(false).await.unwrap();
+
+    let mut tx_hashes = std::collections::BTreeMap::new();
+
+    // send 4 transactions from the same sender with consecutive nonces
+    for i in 0..4 {
+        let tx_request = TransactionRequest::default()
+            .to(recipient)
+            .value(U256::from(1000 + i))
+            .from(sender)
+            .nonce(i as u64);
+
+        let tx = WithOtherFields::new(tx_request);
+        let pending_tx = provider.send_transaction(tx).await.unwrap();
+        tx_hashes.insert(i as u64, *pending_tx.tx_hash());
+    }
+
+    // mine all transactions
+    api.mine_one().await;
+
+    for nonce in 0..4 {
+        let result: Option<alloy_network::AnyRpcTransaction> = provider
+            .client()
+            .request("eth_getTransactionBySenderAndNonce", (sender, U256::from(nonce)))
+            .await
+            .unwrap();
+
+        assert!(result.is_some());
+        let found_tx = result.unwrap();
+
+        assert_eq!(found_tx.inner.nonce(), nonce);
+        assert_eq!(found_tx.from(), sender);
+        assert_eq!(found_tx.inner.to(), Some(recipient));
+        assert_eq!(found_tx.inner.value(), U256::from(1000 + nonce));
+        assert_eq!(found_tx.inner.tx_hash(), tx_hashes[&nonce]);
+    }
+
+    let result: Option<alloy_network::AnyRpcTransaction> = provider
+        .client()
+        .request("eth_getTransactionBySenderAndNonce", (sender, U256::from(999)))
+        .await
+        .unwrap();
+    assert!(result.is_none());
+
+    let different_sender = accounts[2].address();
+    let result: Option<alloy_network::AnyRpcTransaction> = provider
+        .client()
+        .request("eth_getTransactionBySenderAndNonce", (different_sender, U256::from(0)))
+        .await
+        .unwrap();
+    assert!(result.is_none());
+
+    // send a pending transaction with explicit nonce 4
+    let pending_tx_request =
+        TransactionRequest::default().to(recipient).value(U256::from(5000)).from(sender).nonce(4);
+
+    let tx = WithOtherFields::new(pending_tx_request);
+    let pending_tx = provider.send_transaction(tx).await.unwrap();
+
+    // find the pending transaction with nonce 4
+    let result: Option<alloy_network::AnyRpcTransaction> = provider
+        .client()
+        .request("eth_getTransactionBySenderAndNonce", (sender, U256::from(4)))
+        .await
+        .unwrap();
+
+    assert!(result.is_some());
+    let found_tx = result.unwrap();
+    assert_eq!(found_tx.inner.nonce(), 4);
+    assert_eq!(found_tx.inner.tx_hash(), *pending_tx.tx_hash());
+
+    api.mine_one().await;
+
+    let result: Option<alloy_network::AnyRpcTransaction> = provider
+        .client()
+        .request("eth_getTransactionBySenderAndNonce", (sender, U256::from(4)))
+        .await
+        .unwrap();
+
+    assert!(result.is_some());
+    let found_tx = result.unwrap();
+    assert_eq!(found_tx.inner.nonce(), 4);
+}