feat: eth_getTransactionByHash returns executed, but not mined transactions (#1240)

Author: dinhani-cw

src/eth/primitives/mod.rs

@@ -43,6 +43,7 @@ mod storage_point_in_time;
 mod transaction_execution;
 mod transaction_input;
 mod transaction_mined;
+mod transaction_stage;
 mod unix_time;
 mod wei;
 
@@ -98,6 +99,7 @@ pub use transaction_execution::LocalTransactionExecution;
 pub use transaction_execution::TransactionExecution;
 pub use transaction_input::TransactionInput;
 pub use transaction_mined::TransactionMined;
+pub use transaction_stage::TransactionStage;
 pub use unix_time::UnixTime;
 pub use wei::Wei;
 

src/eth/primitives/transaction_mined.rs

@@ -3,7 +3,6 @@ use std::hash::Hash as HashTrait;
 use ethers_core::types::Transaction as EthersTransaction;
 use ethers_core::types::TransactionReceipt as EthersReceipt;
 use itertools::Itertools;
-use serde_json::Value as JsonValue;
 
 use crate::eth::primitives::BlockNumber;
 use crate::eth::primitives::EvmExecution;
@@ -14,7 +13,6 @@ use crate::eth::primitives::Index;
 use crate::eth::primitives::LogMined;
 use crate::eth::primitives::TransactionInput;
 use crate::ext::OptionExt;
-use crate::ext::ResultExt;
 use crate::if_else;
 
 /// Transaction that was executed by the EVM and added to a block.
@@ -76,18 +74,6 @@ impl TransactionMined {
     pub fn is_success(&self) -> bool {
         self.execution.is_success()
     }
-
-    /// Serializes itself to JSON-RPC transaction format.
-    pub fn to_json_rpc_transaction(self) -> JsonValue {
-        let json_rpc_format: EthersTransaction = self.into();
-        serde_json::to_value(json_rpc_format).expect_infallible()
-    }
-
-    /// Serializes itself to JSON-RPC receipt format.
-    pub fn to_json_rpc_receipt(self) -> JsonValue {
-        let json_rpc_format: EthersReceipt = self.into();
-        serde_json::to_value(json_rpc_format).expect_infallible()
-    }
 }
 
 // -----------------------------------------------------------------------------

src/eth/primitives/transaction_stage.rs

@@ -0,0 +1,52 @@
+use ethers_core::types::Transaction as EthersTransaction;
+use ethers_core::types::TransactionReceipt as EthersReceipt;
+use serde_json::Value as JsonValue;
+
+use crate::eth::primitives::TransactionExecution;
+use crate::eth::primitives::TransactionMined;
+use crate::ext::ResultExt;
+
+/// Stages that a transaction can be in.
+#[allow(clippy::large_enum_variant)]
+#[derive(Debug, Clone, derive_new::new)]
+pub enum TransactionStage {
+    /// Transaction was executed, but is awaiting to be mined to a block.
+    Executed(TransactionExecution),
+
+    /// Transaction that was added to a mined block.
+    Mined(TransactionMined),
+}
+
+impl TransactionStage {
+    /// Serializes itself to JSON-RPC transaction format.
+    pub fn to_json_rpc_transaction(self) -> JsonValue {
+        match self {
+            TransactionStage::Executed(TransactionExecution::Local(tx)) => {
+                let json_rpc_payload: EthersTransaction = tx.input.into();
+                serde_json::to_value(json_rpc_payload).expect_infallible()
+            }
+            TransactionStage::Executed(TransactionExecution::External(tx)) => {
+                // remove block information because we don't know to which local block the transaction will be added to.
+                let mut ethers_tx = tx.tx.0;
+                ethers_tx.block_number = None;
+                ethers_tx.block_hash = None;
+                serde_json::to_value(ethers_tx).expect_infallible()
+            }
+            TransactionStage::Mined(tx) => {
+                let json_rpc_payload: EthersTransaction = tx.into();
+                serde_json::to_value(json_rpc_payload).expect_infallible()
+            }
+        }
+    }
+
+    /// Serializes itself to JSON-RPC receipt format.
+    pub fn to_json_rpc_receipt(self) -> JsonValue {
+        match self {
+            TransactionStage::Executed(_) => JsonValue::Null,
+            TransactionStage::Mined(tx) => {
+                let json_rpc_format: EthersReceipt = tx.into();
+                serde_json::to_value(json_rpc_format).expect_infallible()
+            }
+        }
+    }
+}

src/eth/rpc/rpc_server.rs

@@ -393,19 +393,18 @@ fn eth_get_uncle_by_block_hash_and_index(_: Params<'_>, _: &RpcContext, _: &Exte
 // Transaction
 // -----------------------------------------------------------------------------
 
-#[tracing::instrument(name = "rpc::eth_getTransactionByHash", skip_all, fields(hash))]
+#[tracing::instrument(name = "rpc::eth_getTransactionByHash", skip_all, fields(hash, found))]
 fn eth_get_transaction_by_hash(params: Params<'_>, ctx: Arc<RpcContext>, _: Extensions) -> anyhow::Result<JsonValue, RpcError> {
     let (_, hash) = next_rpc_param::<Hash>(params.sequence())?;
-
     Span::with(|s| s.rec_str("hash", &hash));
 
-    let mined = ctx.storage.read_mined_transaction(&hash)?;
+    let tx = ctx.storage.read_transaction(&hash)?;
     Span::with(|s| {
-        s.record("found", mined.is_some());
+        s.record("found", tx.is_some());
     });
 
-    match mined {
-        Some(mined) => Ok(mined.to_json_rpc_transaction()),
+    match tx {
+        Some(tx) => Ok(tx.to_json_rpc_transaction()),
         None => Ok(JsonValue::Null),
     }
 }
@@ -415,12 +414,12 @@ fn eth_get_transaction_receipt(params: Params<'_>, ctx: Arc<RpcContext>, _: Exte
     let (_, hash) = next_rpc_param::<Hash>(params.sequence())?;
     Span::with(|s| s.rec_str("hash", &hash));
 
-    let mined = ctx.storage.read_mined_transaction(&hash)?;
+    let tx = ctx.storage.read_transaction(&hash)?;
     Span::with(|s| {
-        s.record("found", mined.is_some());
+        s.record("found", tx.is_some());
     });
 
-    match mined {
+    match tx {
         Some(mined_transaction) => Ok(mined_transaction.to_json_rpc_receipt()),
         None => Ok(JsonValue::Null),
     }

src/eth/storage/stratus_storage.rs

@@ -18,7 +18,7 @@ use crate::eth::primitives::SlotIndex;
 use crate::eth::primitives::SlotSample;
 use crate::eth::primitives::StoragePointInTime;
 use crate::eth::primitives::TransactionExecution;
-use crate::eth::primitives::TransactionMined;
+use crate::eth::primitives::TransactionStage;
 use crate::eth::storage::PermanentStorage;
 use crate::eth::storage::TemporaryStorage;
 use crate::infra::metrics;
@@ -226,21 +226,21 @@ impl StratusStorage {
         // read from temp only if present
         if point_in_time.is_present() {
             tracing::debug!(storage = %label::TEMP, %address, "reading account");
-            let result = timed(|| self.temp.read_account(address)).with(|m| {
+            let temp_account = timed(|| self.temp.read_account(address)).with(|m| {
                 metrics::inc_storage_read_account(m.elapsed, label::TEMP, point_in_time, m.result.is_ok());
-            });
-            if let Some(account) = result? {
+            })?;
+            if let Some(account) = temp_account {
                 tracing::debug!(storage = %label::TEMP, %address, "account found in temporary storage");
                 return Ok(account);
             }
         }
 
         // always read from perm if necessary
         tracing::debug!(storage = %label::PERM, %address, "reading account");
-        let result = timed(|| self.perm.read_account(address, point_in_time)).with(|m| {
+        let perm_account = timed(|| self.perm.read_account(address, point_in_time)).with(|m| {
             metrics::inc_storage_read_account(m.elapsed, label::PERM, point_in_time, m.result.is_ok());
-        });
-        match result? {
+        })?;
+        match perm_account {
             Some(account) => {
                 tracing::debug!(%address, "account found in permanent storage");
                 Ok(account)
@@ -263,21 +263,21 @@ impl StratusStorage {
         // read from temp only if present
         if point_in_time.is_present() {
             tracing::debug!(storage = %label::TEMP, %address, %index, "reading slot");
-            let result = timed(|| self.temp.read_slot(address, index)).with(|m| {
+            let temp_slot = timed(|| self.temp.read_slot(address, index)).with(|m| {
                 metrics::inc_storage_read_slot(m.elapsed, label::TEMP, point_in_time, m.result.is_ok());
-            });
-            if let Some(slot) = result? {
+            })?;
+            if let Some(slot) = temp_slot {
                 tracing::debug!(storage = %label::TEMP, %address, %index, value = %slot.value, "slot found in temporary storage");
                 return Ok(slot);
             }
         }
 
         // always read from perm if necessary
         tracing::debug!(storage = %label::PERM, %address, %index, ?point_in_time, "reading slot");
-        let result = timed(|| self.perm.read_slot(address, index, point_in_time)).with(|m| {
+        let perm_slot = timed(|| self.perm.read_slot(address, index, point_in_time)).with(|m| {
             metrics::inc_storage_read_slot(m.elapsed, label::PERM, point_in_time, m.result.is_ok());
-        });
-        match result? {
+        })?;
+        match perm_slot {
             Some(slot) => {
                 tracing::debug!(%address, %index, value = %slot.value, "slot found in permanent storage");
                 Ok(slot)
@@ -347,13 +347,27 @@ impl StratusStorage {
     }
 
     #[tracing::instrument(name = "storage::read_transaction", skip_all, fields(hash))]
-    pub fn read_mined_transaction(&self, hash: &Hash) -> anyhow::Result<Option<TransactionMined>> {
+    pub fn read_transaction(&self, hash: &Hash) -> anyhow::Result<Option<TransactionStage>> {
         Span::with(|s| s.rec_str("hash", hash));
-        tracing::debug!(storage = %label::PERM, %hash, "reading transaction");
 
-        timed(|| self.perm.read_transaction(hash)).with(|m| {
-            metrics::inc_storage_read_mined_transaction(m.elapsed, label::PERM, m.result.is_ok());
-        })
+        // read from temp
+        tracing::debug!(storage = %label::TEMP, %hash, "reading transaction");
+        let temp_tx = timed(|| self.temp.read_transaction(hash)).with(|m| {
+            metrics::inc_storage_read_transaction(m.elapsed, label::TEMP, m.result.is_ok());
+        })?;
+        if let Some(tx_temp) = temp_tx {
+            return Ok(Some(TransactionStage::new_executed(tx_temp)));
+        }
+
+        // read from perm
+        tracing::debug!(storage = %label::PERM, %hash, "reading transaction");
+        let perm_tx = timed(|| self.perm.read_transaction(hash)).with(|m| {
+            metrics::inc_storage_read_transaction(m.elapsed, label::PERM, m.result.is_ok());
+        })?;
+        match perm_tx {
+            Some(tx) => Ok(Some(TransactionStage::new_mined(tx))),
+            None => Ok(None),
+        }
     }
 
     #[tracing::instrument(name = "storage::read_logs", skip_all)]

src/infra/metrics/metrics_definitions.rs

@@ -42,8 +42,8 @@ metrics! {
     "Time to execute storage read_slot operation."
     histogram_duration storage_read_slot{storage, point_in_time, success},
 
-    "Time to execute storage read_mined_transaction operation."
-    histogram_duration storage_read_mined_transaction{storage, success}
+    "Time to execute storage read_transaction operation."
+    histogram_duration storage_read_transaction{storage, success}
 }
 
 // Storage writes.