feat: add eth_getTransactionByHash support (#4577)

Co-authored-by: Patricio Palladino <email@patriciopalladino.com>

Author: agostbiro

crates/edr_eth/src/access_list.rs

@@ -30,6 +30,12 @@ impl From<Vec<AccessListItem>> for AccessList {
     }
 }
 
+impl From<AccessList> for Vec<AccessListItem> {
+    fn from(src: AccessList) -> Vec<AccessListItem> {
+        src.0
+    }
+}
+
 /// Access list item
 #[derive(Debug, Default, Clone, PartialEq, Eq, Hash)]
 #[cfg_attr(

crates/edr_eth/src/remote/eth.rs

@@ -74,8 +74,13 @@ pub struct Transaction {
     pub chain_id: Option<u64>,
     /// integer of the transaction type, 0x0 for legacy transactions, 0x1 for
     /// access list types, 0x2 for dynamic fees
-    #[serde(rename = "type", default, with = "crate::serde::u64")]
-    pub transaction_type: u64,
+    #[serde(
+        rename = "type",
+        default,
+        skip_serializing_if = "Option::is_none",
+        with = "crate::serde::optional_u64"
+    )]
+    pub transaction_type: Option<u64>,
     /// access list
     #[serde(default)]
     pub access_list: Option<Vec<AccessListItem>>,
@@ -103,7 +108,7 @@ impl Transaction {
 
     /// Returns whether the transaction is a legacy transaction.
     pub fn is_legacy(&self) -> bool {
-        self.transaction_type == 0 && (self.v == 27 || self.v == 28)
+        self.transaction_type == Some(0) && (self.v == 27 || self.v == 28)
     }
 }
 
@@ -147,7 +152,7 @@ impl TryFrom<Transaction> for (SignedTransaction, Address) {
         };
 
         let transaction = match value.transaction_type {
-            0 => {
+            Some(0) | None => {
                 if value.is_legacy() {
                     SignedTransaction::PreEip155Legacy(LegacySignedTransaction {
                         nonce: value.nonce,
@@ -180,7 +185,7 @@ impl TryFrom<Transaction> for (SignedTransaction, Address) {
                     })
                 }
             }
-            1 => SignedTransaction::Eip2930(Eip2930SignedTransaction {
+            Some(1) => SignedTransaction::Eip2930(Eip2930SignedTransaction {
                 odd_y_parity: value.odd_y_parity(),
                 chain_id: value
                     .chain_id
@@ -199,7 +204,7 @@ impl TryFrom<Transaction> for (SignedTransaction, Address) {
                 s: value.s,
                 hash: OnceLock::from(value.hash),
             }),
-            2 => SignedTransaction::Eip1559(Eip1559SignedTransaction {
+            Some(2) => SignedTransaction::Eip1559(Eip1559SignedTransaction {
                 odd_y_parity: value.odd_y_parity(),
                 chain_id: value
                     .chain_id
@@ -223,7 +228,7 @@ impl TryFrom<Transaction> for (SignedTransaction, Address) {
                 s: value.s,
                 hash: OnceLock::from(value.hash),
             }),
-            3 => SignedTransaction::Eip4844(Eip4844SignedTransaction {
+            Some(3) => SignedTransaction::Eip4844(Eip4844SignedTransaction {
                 odd_y_parity: value.odd_y_parity(),
                 chain_id: value
                     .chain_id
@@ -255,7 +260,7 @@ impl TryFrom<Transaction> for (SignedTransaction, Address) {
                 s: value.s,
                 hash: OnceLock::from(value.hash),
             }),
-            r#type => {
+            Some(r#type) => {
                 return Err(TransactionConversionError::UnsupportedType(r#type));
             }
         };

crates/edr_eth/src/transaction/signed.rs

@@ -94,6 +94,17 @@ impl SignedTransaction {
     }
 
     /// Retrieves the max fee per gas of the transaction, if any.
+    pub fn max_fee_per_gas(&self) -> Option<U256> {
+        match self {
+            SignedTransaction::PreEip155Legacy(_)
+            | SignedTransaction::PostEip155Legacy(_)
+            | SignedTransaction::Eip2930(_) => None,
+            SignedTransaction::Eip1559(tx) => Some(tx.max_priority_fee_per_gas),
+            SignedTransaction::Eip4844(tx) => Some(tx.max_priority_fee_per_gas),
+        }
+    }
+
+    /// Retrieves the max priority fee per gas of the transaction, if any.
     pub fn max_priority_fee_per_gas(&self) -> Option<U256> {
         match self {
             SignedTransaction::PreEip155Legacy(_)
@@ -104,6 +115,28 @@ impl SignedTransaction {
         }
     }
 
+    /// Retrieves the max fee per blob gas of the transaction, if any.
+    pub fn max_fee_per_blob_gas(&self) -> Option<U256> {
+        match self {
+            SignedTransaction::PreEip155Legacy(_)
+            | SignedTransaction::PostEip155Legacy(_)
+            | SignedTransaction::Eip2930(_)
+            | SignedTransaction::Eip1559(_) => None,
+            SignedTransaction::Eip4844(tx) => Some(tx.max_fee_per_blob_gas),
+        }
+    }
+
+    /// Retrieves the blob hashes of the transaction, if any.
+    pub fn blob_hashes(&self) -> Option<Vec<B256>> {
+        match self {
+            SignedTransaction::PreEip155Legacy(_)
+            | SignedTransaction::PostEip155Legacy(_)
+            | SignedTransaction::Eip2930(_)
+            | SignedTransaction::Eip1559(_) => None,
+            SignedTransaction::Eip4844(tx) => Some(tx.blob_hashes.clone()),
+        }
+    }
+
     /// Upfront cost of the transaction
     pub fn upfront_cost(&self) -> U256 {
         self.max_cost().saturating_add(self.value())
@@ -208,6 +241,15 @@ impl SignedTransaction {
             },
         }
     }
+
+    pub fn transaction_type(&self) -> u64 {
+        match self {
+            SignedTransaction::PreEip155Legacy(_) | SignedTransaction::PostEip155Legacy(_) => 0,
+            SignedTransaction::Eip2930(_) => 1,
+            SignedTransaction::Eip1559(_) => 2,
+            SignedTransaction::Eip4844(_) => 3,
+        }
+    }
 }
 
 impl rlp::Encodable for SignedTransaction {

crates/edr_evm/src/transaction/pending.rs

@@ -91,6 +91,11 @@ impl PendingTransaction {
         &self.caller
     }
 
+    /// Returns the inner [`SignedTransaction`]
+    pub fn transaction(&self) -> &SignedTransaction {
+        &self.transaction
+    }
+
     /// Returns the inner transaction and caller
     pub fn into_inner(self) -> (SignedTransaction, Address) {
         (self.transaction, self.caller)

crates/edr_provider/src/data.rs

@@ -72,7 +72,7 @@ impl ProviderData {
             network_id: config.network_id,
             beneficiary: config.coinbase,
             // TODO: Add config option (https://github.com/NomicFoundation/edr/issues/111)
-            min_gas_price: U256::MAX,
+            min_gas_price: U256::from(1),
             prevrandao_generator,
             block_time_offset_seconds: block_time_offset_seconds(config)?,
             next_block_timestamp: None,
@@ -411,6 +411,51 @@ impl ProviderData {
         self.impersonated_accounts.remove(&address)
     }
 
+    /// Get a transaction by hash from the blockchain or from the mempool if
+    /// it's not mined yet.
+    pub async fn transaction_by_hash(
+        &self,
+        hash: &B256,
+    ) -> Result<Option<GetTransactionResult>, ProviderError> {
+        let transaction = if let Some(tx) = self.mem_pool.transaction_by_hash(hash) {
+            let signed_transaction = tx.pending().transaction().clone();
+
+            Some(GetTransactionResult {
+                signed_transaction,
+                spec_id: self.blockchain.spec_id(),
+                block_metadata: None,
+            })
+        } else if let Some(tx_block) = self.blockchain.block_by_transaction_hash(hash).await? {
+            let tx_index = self
+                .blockchain
+                .receipt_by_transaction_hash(hash)
+                .await?
+                .expect("If the transaction was inserted in a block, it must have a receipt")
+                .transaction_index;
+
+            let tx_index_usize =
+                usize::try_from(tx_index).expect("Indices cannot be larger than usize::MAX");
+            let signed_transaction = tx_block.transactions()[tx_index_usize].clone();
+
+            let block_metadata = BlockMetadataForTransaction {
+                base_fee_per_gas: tx_block.header().base_fee_per_gas,
+                block_hash: *tx_block.hash(),
+                block_number: tx_block.header().number,
+                transaction_index: tx_index,
+            };
+
+            Some(GetTransactionResult {
+                signed_transaction,
+                spec_id: self.blockchain.spec_id(),
+                block_metadata: Some(block_metadata),
+            })
+        } else {
+            None
+        };
+
+        Ok(transaction)
+    }
+
     fn add_pending_transaction(
         &mut self,
         transaction: PendingTransaction,
@@ -738,23 +783,45 @@ async fn create_blockchain_and_state(
     }
 }
 
+/// The result returned by requesting a transaction.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct GetTransactionResult {
+    /// The signed transaction.
+    pub signed_transaction: SignedTransaction,
+    /// Information about the active hardforks.
+    pub spec_id: SpecId,
+    /// The block metadata for the transaction. None if the transaction is
+    /// pending.
+    pub block_metadata: Option<BlockMetadataForTransaction>,
+}
+
+/// Block metadata for a transaction.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct BlockMetadataForTransaction {
+    pub base_fee_per_gas: Option<U256>,
+    pub block_hash: B256,
+    pub block_number: u64,
+    pub transaction_index: u64,
+}
+
 #[cfg(test)]
 mod tests {
+    use anyhow::Context;
     use tempfile::TempDir;
 
     use super::*;
     use crate::{test_utils::create_test_config_with_impersonated_accounts, ProviderConfig};
 
-    struct NodeTestFixture {
+    struct ProviderTestFixture {
         // We need to keep the tempdir alive for the duration of the test
         _cache_dir: TempDir,
         config: ProviderConfig,
         provider_data: ProviderData,
         impersonated_account: Address,
     }
 
-    impl NodeTestFixture {
-        pub(crate) async fn new(runtime: &runtime::Handle) -> anyhow::Result<Self> {
+    impl ProviderTestFixture {
+        pub(crate) async fn new() -> anyhow::Result<Self> {
             let cache_dir = TempDir::new()?;
 
             let impersonated_account = Address::random();
@@ -763,7 +830,8 @@ mod tests {
                 vec![impersonated_account],
             );
 
-            let mut provider_data = ProviderData::new(runtime, &config).await?;
+            let runtime = runtime::Handle::try_current()?;
+            let mut provider_data = ProviderData::new(&runtime, &config).await?;
             provider_data
                 .impersonated_accounts
                 .insert(impersonated_account);
@@ -786,7 +854,7 @@ mod tests {
                     .expect("there are local accounts"),
                 to: Some(Address::zero()),
                 gas: Some(100_000),
-                gas_price: Some(U256::from(1)),
+                gas_price: Some(U256::from(42_000_000_000_u64)),
                 value: Some(U256::from(1)),
                 data: None,
                 nonce: None,
@@ -813,7 +881,7 @@ mod tests {
 
     #[tokio::test]
     async fn test_sign_transaction_request() -> anyhow::Result<()> {
-        let fixture = NodeTestFixture::new(&runtime::Handle::current()).await?;
+        let fixture = ProviderTestFixture::new().await?;
 
         let transaction = fixture.signed_dummy_transaction()?;
         let recovered_address = transaction.recover()?;
@@ -828,7 +896,7 @@ mod tests {
 
     #[tokio::test]
     async fn test_sign_transaction_request_impersonated_account() -> anyhow::Result<()> {
-        let fixture = NodeTestFixture::new(&runtime::Handle::current()).await?;
+        let fixture = ProviderTestFixture::new().await?;
 
         let transaction = fixture.impersonated_dummy_transaction()?;
 
@@ -838,7 +906,7 @@ mod tests {
     }
 
     fn test_add_pending_transaction(
-        fixture: &mut NodeTestFixture,
+        fixture: &mut ProviderTestFixture,
         transaction: PendingTransaction,
     ) -> anyhow::Result<()> {
         let filter_id = fixture.provider_data.new_pending_transaction_filter();
@@ -869,23 +937,23 @@ mod tests {
 
     #[tokio::test]
     async fn add_pending_transaction() -> anyhow::Result<()> {
-        let mut fixture = NodeTestFixture::new(&runtime::Handle::current()).await?;
+        let mut fixture = ProviderTestFixture::new().await?;
         let transaction = fixture.signed_dummy_transaction()?;
 
         test_add_pending_transaction(&mut fixture, transaction)
     }
 
     #[tokio::test]
     async fn add_pending_transaction_from_impersonated_account() -> anyhow::Result<()> {
-        let mut fixture = NodeTestFixture::new(&runtime::Handle::current()).await?;
+        let mut fixture = ProviderTestFixture::new().await?;
         let transaction = fixture.impersonated_dummy_transaction()?;
 
         test_add_pending_transaction(&mut fixture, transaction)
     }
 
     #[tokio::test]
     async fn chain_id() -> anyhow::Result<()> {
-        let fixture = NodeTestFixture::new(&runtime::Handle::current()).await?;
+        let fixture = ProviderTestFixture::new().await?;
 
         let chain_id = fixture.provider_data.chain_id().await;
         assert_eq!(chain_id, fixture.config.chain_id);
@@ -895,7 +963,7 @@ mod tests {
 
     #[tokio::test]
     async fn next_filter_id() -> anyhow::Result<()> {
-        let mut fixture = NodeTestFixture::new(&runtime::Handle::current()).await?;
+        let mut fixture = ProviderTestFixture::new().await?;
 
         let mut prev_filter_id = fixture.provider_data.last_filter_id;
         for _ in 0..10 {
@@ -909,7 +977,7 @@ mod tests {
 
     #[tokio::test]
     async fn set_balance_updates_mem_pool() -> anyhow::Result<()> {
-        let mut fixture = NodeTestFixture::new(&runtime::Handle::current()).await?;
+        let mut fixture = ProviderTestFixture::new().await?;
 
         let transaction = {
             let mut request = fixture.dummy_transaction_request();
@@ -942,7 +1010,7 @@ mod tests {
 
     #[tokio::test]
     async fn set_nonce_updates_mem_pool() -> anyhow::Result<()> {
-        let mut fixture = NodeTestFixture::new(&runtime::Handle::current()).await?;
+        let mut fixture = ProviderTestFixture::new().await?;
 
         // Artificially raise the nonce, to ensure the transaction is not rejected
         fixture
@@ -990,4 +1058,75 @@ mod tests {
 
         Ok(())
     }
+
+    #[tokio::test]
+    async fn transaction_by_invalid_hash() -> anyhow::Result<()> {
+        let fixture = ProviderTestFixture::new().await?;
+
+        let non_existing_tx = fixture
+            .provider_data
+            .transaction_by_hash(&B256::zero())
+            .await?;
+
+        assert_eq!(non_existing_tx, None);
+
+        Ok(())
+    }
+
+    #[tokio::test]
+    async fn pending_transaction_by_hash() -> anyhow::Result<()> {
+        let mut fixture = ProviderTestFixture::new().await?;
+
+        let transaction_request = fixture.signed_dummy_transaction()?;
+        let transaction_hash = fixture
+            .provider_data
+            .add_pending_transaction(transaction_request)?;
+
+        let transaction_result = fixture
+            .provider_data
+            .transaction_by_hash(&transaction_hash)
+            .await?
+            .context("transaction not found")?;
+
+        assert_eq!(
+            transaction_result.signed_transaction.hash(),
+            &transaction_hash
+        );
+
+        Ok(())
+    }
+
+    #[tokio::test]
+    async fn transaction_by_hash() -> anyhow::Result<()> {
+        let mut fixture = ProviderTestFixture::new().await?;
+
+        let transaction_request = fixture.signed_dummy_transaction()?;
+        let transaction_hash = fixture
+            .provider_data
+            .add_pending_transaction(transaction_request)?;
+
+        let results = fixture.provider_data.mine_and_commit_block(None).await?;
+
+        // Make sure transaction was mined successfully.
+        assert!(results
+            .transaction_results
+            .first()
+            .context("failed to mine transaction")?
+            .is_success());
+        // Sanity check that the mempool is empty.
+        assert_eq!(fixture.provider_data.mem_pool.transactions().count(), 0);
+
+        let transaction_result = fixture
+            .provider_data
+            .transaction_by_hash(&transaction_hash)
+            .await?
+            .context("transaction not found")?;
+
+        assert_eq!(
+            transaction_result.signed_transaction.hash(),
+            &transaction_hash
+        );
+
+        Ok(())
+    }
 }

crates/edr_provider/src/lib.rs

@@ -23,43 +23,39 @@ pub use self::{
 };
 
 /// A JSON-RPC provider for Ethereum.
+///
+/// Add a layer in front that handles this
+///
+/// ```rust,ignore
+/// let RpcRequest {
+///     version,
+///     method: request,
+///     id,
+/// } = request;
+///
+/// if version != jsonrpc::Version::V2_0 {
+///     return Err(ProviderError::RpcVersion(version));
+/// }
+///
+/// fn to_response(
+///     id: jsonrpc::Id,
+///     result: Result<serde_json::Value, ProviderError>,
+/// ) -> jsonrpc::Response<serde_json::Value> { let data = match result {
+///   Ok(result) => jsonrpc::ResponseData::Success { result }, Err(error) =>
+///   jsonrpc::ResponseData::Error { error: jsonrpc::Error { code: -32000,
+///   message: error.to_string(), data: None, }, }, };
+///
+///     jsonrpc::Response {
+///         jsonrpc: jsonrpc::Version::V2_0,
+///         id,
+///         data,
+///     }
+/// }
+/// ```
 pub struct Provider {
     data: Mutex<ProviderData>,
 }
 
-// Add a layer in front that handles this
-// let RpcRequest {
-//     version,
-//     method: request,
-//     id,
-// } = request;
-
-// if version != jsonrpc::Version::V2_0 {
-//     return Err(ProviderError::RpcVersion(version));
-// }
-//
-// fn to_response(
-//     id: jsonrpc::Id,
-//     result: Result<serde_json::Value, ProviderError>,
-// ) -> jsonrpc::Response<serde_json::Value> {
-//     let data = match result {
-//         Ok(result) => jsonrpc::ResponseData::Success { result },
-//         Err(error) => jsonrpc::ResponseData::Error {
-//             error: jsonrpc::Error {
-//                 code: -32000,
-//                 message: error.to_string(),
-//                 data: None,
-//             },
-//         },
-//     };
-
-//     jsonrpc::Response {
-//         jsonrpc: jsonrpc::Version::V2_0,
-//         id,
-//         data,
-//     }
-// }
-
 impl Provider {
     pub async fn handle_request(
         &self,
@@ -155,7 +151,11 @@ async fn handle_eth_request(
         EthRequest::GetTransactionByBlockNumberAndIndex(_, _) => {
             Err(ProviderError::Unimplemented("".to_string()))
         }
-        EthRequest::GetTransactionByHash(_) => Err(ProviderError::Unimplemented("".to_string())),
+        EthRequest::GetTransactionByHash(transaction_hash) => {
+            eth::handle_get_transaction_by_hash(data, transaction_hash)
+                .await
+                .and_then(to_json)
+        }
         EthRequest::GetTransactionCount(address, block_spec) => {
             eth::handle_get_transaction_count_request(data, address, block_spec)
                 .await

crates/edr_provider/src/requests/eth/transactions.rs

@@ -1,6 +1,117 @@
-use edr_eth::{serde::ZeroXPrefixedBytes, transaction::EthTransactionRequest, B256};
+use edr_eth::{
+    remote,
+    serde::ZeroXPrefixedBytes,
+    transaction::{EthTransactionRequest, SignedTransaction},
+    SpecId, B256, U256,
+};
 
-use crate::{data::ProviderData, ProviderError};
+use crate::{
+    data::{BlockMetadataForTransaction, GetTransactionResult, ProviderData},
+    ProviderError,
+};
+
+const FIRST_HARDFORK_WITH_TRANSACTION_TYPE: SpecId = SpecId::BERLIN;
+
+pub async fn handle_get_transaction_by_hash(
+    data: &ProviderData,
+    transaction_hash: B256,
+) -> Result<Option<remote::eth::Transaction>, ProviderError> {
+    data.transaction_by_hash(&transaction_hash)
+        .await?
+        .map(get_transaction_result_to_rpc_result)
+        .transpose()
+}
+
+fn get_transaction_result_to_rpc_result(
+    result: GetTransactionResult,
+) -> Result<remote::eth::Transaction, ProviderError> {
+    fn gas_price_for_post_eip1559(
+        signed_transaction: &SignedTransaction,
+        block_metadata: Option<&BlockMetadataForTransaction>,
+    ) -> U256 {
+        let max_fee_per_gas = signed_transaction
+            .max_fee_per_gas()
+            .expect("Transaction must be post EIP-1559 transaction.");
+        let max_priority_fee_per_gas = signed_transaction
+            .max_priority_fee_per_gas()
+            .expect("Transaction must be post EIP-1559 transaction.");
+
+        if let Some(block_metadata) = block_metadata {
+            let base_fee_per_gas = block_metadata.base_fee_per_gas.expect(
+                "Transaction must have base fee per gas in block metadata if EIP-1559 is active.",
+            );
+            let priority_fee_per_gas =
+                max_priority_fee_per_gas.min(max_fee_per_gas - base_fee_per_gas);
+            base_fee_per_gas + priority_fee_per_gas
+        } else {
+            // We are following Hardhat's behavior of returning the max fee per gas for
+            // pending transactions.
+            max_fee_per_gas
+        }
+    }
+
+    let GetTransactionResult {
+        signed_transaction,
+        spec_id,
+        block_metadata,
+    } = result;
+
+    let gas_price = match &signed_transaction {
+        SignedTransaction::PreEip155Legacy(tx) => tx.gas_price,
+        SignedTransaction::PostEip155Legacy(tx) => tx.gas_price,
+        SignedTransaction::Eip2930(tx) => tx.gas_price,
+        SignedTransaction::Eip1559(_) | SignedTransaction::Eip4844(_) => {
+            gas_price_for_post_eip1559(&signed_transaction, block_metadata.as_ref())
+        }
+    };
+
+    let chain_id = match &signed_transaction {
+        // Following Hardhat in not returning `chain_id` for `PostEip155Legacy` legacy transactions
+        // even though the chain id would be recoverable.
+        SignedTransaction::PreEip155Legacy(_) | SignedTransaction::PostEip155Legacy(_) => None,
+        SignedTransaction::Eip2930(tx) => Some(tx.chain_id),
+        SignedTransaction::Eip1559(tx) => Some(tx.chain_id),
+        SignedTransaction::Eip4844(tx) => Some(tx.chain_id),
+    };
+
+    let show_transaction_type = spec_id >= FIRST_HARDFORK_WITH_TRANSACTION_TYPE;
+    let is_typed_transaction = signed_transaction.transaction_type() > 0;
+    let transaction_type = if show_transaction_type || is_typed_transaction {
+        Some(signed_transaction.transaction_type())
+    } else {
+        None
+    };
+
+    let signature = signed_transaction.signature();
+
+    Ok(remote::eth::Transaction {
+        hash: *signed_transaction.hash(),
+        nonce: signed_transaction.nonce(),
+        block_hash: block_metadata.as_ref().map(|m| m.block_hash),
+        block_number: block_metadata.as_ref().map(|m| U256::from(m.block_number)),
+        transaction_index: block_metadata.map(|m| m.transaction_index),
+        from: signed_transaction.recover()?,
+        to: signed_transaction.to(),
+        value: signed_transaction.value(),
+        gas_price,
+        gas: U256::from(signed_transaction.gas_limit()),
+        input: signed_transaction.data().clone(),
+        v: signature.v,
+        // Following Hardhat in always returning `v` instead of `y_parity`.
+        y_parity: None,
+        r: signature.r,
+        s: signature.s,
+        chain_id,
+        transaction_type,
+        access_list: signed_transaction
+            .access_list()
+            .map(|access_list| access_list.clone().into()),
+        max_fee_per_gas: signed_transaction.max_fee_per_gas(),
+        max_priority_fee_per_gas: signed_transaction.max_priority_fee_per_gas(),
+        max_fee_per_blob_gas: signed_transaction.max_fee_per_blob_gas(),
+        blob_versioned_hashes: signed_transaction.blob_hashes(),
+    })
+}
 
 pub fn handle_send_transaction_request(
     data: &mut ProviderData,