refactor(anvil): simplify transaction conversion to RpcTransaction (#12391)

Added TypedTransaction::try_into_eth() to convert TypedTransaction to TxEnvelope, returning an error for Deposit transactions that are not part of standard Ethereum.

Added MaybeImpersonatedTransaction::into_rpc_transaction() method that encapsulates the conversion logic, making it more explicit and easier to use. The From<MaybeImpersonatedTransaction> for RpcTransaction trait now delegates to this method.

Removed the standalone to_alloy_transaction_with_hash_and_sender function since its logic is now part of the into_rpc_transaction method.

Updated transaction_build to use the new into_rpc_transaction() method, simplifying the conversion flow and eliminating redundant recovery calls.

Co-authored-by: Claude <[email protected]>

Author: mattsse

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

@@ -237,6 +237,46 @@ impl MaybeImpersonatedTransaction {
         }
         self.transaction.hash()
     }
+
+    /// Converts the transaction into an [`RpcTransaction`]
+    pub fn into_rpc_transaction(self) -> RpcTransaction {
+        let hash = self.hash();
+        let from = self.recover().unwrap_or_default();
+        let envelope = self.transaction.try_into_eth().expect("cant build deposit transactions");
+
+        // NOTE: we must update the hash because the tx can be impersonated, this requires forcing
+        // the hash
+        let inner_envelope = match envelope {
+            TxEnvelope::Legacy(t) => {
+                let (tx, sig, _) = t.into_parts();
+                TxEnvelope::Legacy(Signed::new_unchecked(tx, sig, hash))
+            }
+            TxEnvelope::Eip2930(t) => {
+                let (tx, sig, _) = t.into_parts();
+                TxEnvelope::Eip2930(Signed::new_unchecked(tx, sig, hash))
+            }
+            TxEnvelope::Eip1559(t) => {
+                let (tx, sig, _) = t.into_parts();
+                TxEnvelope::Eip1559(Signed::new_unchecked(tx, sig, hash))
+            }
+            TxEnvelope::Eip4844(t) => {
+                let (tx, sig, _) = t.into_parts();
+                TxEnvelope::Eip4844(Signed::new_unchecked(tx, sig, hash))
+            }
+            TxEnvelope::Eip7702(t) => {
+                let (tx, sig, _) = t.into_parts();
+                TxEnvelope::Eip7702(Signed::new_unchecked(tx, sig, hash))
+            }
+        };
+
+        RpcTransaction {
+            block_hash: None,
+            block_number: None,
+            transaction_index: None,
+            effective_gas_price: None,
+            inner: Recovered::new_unchecked(inner_envelope, from),
+        }
+    }
 }
 
 impl Encodable for MaybeImpersonatedTransaction {
@@ -279,86 +319,7 @@ impl Deref for MaybeImpersonatedTransaction {
 
 impl From<MaybeImpersonatedTransaction> for RpcTransaction {
     fn from(value: MaybeImpersonatedTransaction) -> Self {
-        let hash = value.hash();
-        let sender = value.recover().unwrap_or_default();
-        to_alloy_transaction_with_hash_and_sender(value.transaction, hash, sender)
-    }
-}
-
-pub fn to_alloy_transaction_with_hash_and_sender(
-    transaction: TypedTransaction,
-    hash: B256,
-    from: Address,
-) -> RpcTransaction {
-    match transaction {
-        TypedTransaction::Legacy(t) => {
-            let (tx, sig, _) = t.into_parts();
-            RpcTransaction {
-                block_hash: None,
-                block_number: None,
-                transaction_index: None,
-                effective_gas_price: None,
-                inner: Recovered::new_unchecked(
-                    TxEnvelope::Legacy(Signed::new_unchecked(tx, sig, hash)),
-                    from,
-                ),
-            }
-        }
-        TypedTransaction::EIP2930(t) => {
-            let (tx, sig, _) = t.into_parts();
-            RpcTransaction {
-                block_hash: None,
-                block_number: None,
-                transaction_index: None,
-                effective_gas_price: None,
-                inner: Recovered::new_unchecked(
-                    TxEnvelope::Eip2930(Signed::new_unchecked(tx, sig, hash)),
-                    from,
-                ),
-            }
-        }
-        TypedTransaction::EIP1559(t) => {
-            let (tx, sig, _) = t.into_parts();
-            RpcTransaction {
-                block_hash: None,
-                block_number: None,
-                transaction_index: None,
-                effective_gas_price: None,
-                inner: Recovered::new_unchecked(
-                    TxEnvelope::Eip1559(Signed::new_unchecked(tx, sig, hash)),
-                    from,
-                ),
-            }
-        }
-        TypedTransaction::EIP4844(t) => {
-            let (tx, sig, _) = t.into_parts();
-            RpcTransaction {
-                block_hash: None,
-                block_number: None,
-                transaction_index: None,
-                effective_gas_price: None,
-                inner: Recovered::new_unchecked(
-                    TxEnvelope::Eip4844(Signed::new_unchecked(tx, sig, hash)),
-                    from,
-                ),
-            }
-        }
-        TypedTransaction::EIP7702(t) => {
-            let (tx, sig, _) = t.into_parts();
-            RpcTransaction {
-                block_hash: None,
-                block_number: None,
-                transaction_index: None,
-                effective_gas_price: None,
-                inner: Recovered::new_unchecked(
-                    TxEnvelope::Eip7702(Signed::new_unchecked(tx, sig, hash)),
-                    from,
-                ),
-            }
-        }
-        TypedTransaction::Deposit(_t) => {
-            unreachable!("cannot reach here, handled in `transaction_build` ")
-        }
+        value.into_rpc_transaction()
     }
 }
 
@@ -655,6 +616,21 @@ impl TryFrom<AnyRpcTransaction> for TypedTransaction {
 }
 
 impl TypedTransaction {
+    /// Converts the transaction into a [`TxEnvelope`].
+    ///
+    /// Returns an error if the transaction is a Deposit transaction, which is not part of the
+    /// standard Ethereum transaction types.
+    pub fn try_into_eth(self) -> Result<TxEnvelope, Self> {
+        match self {
+            Self::Legacy(tx) => Ok(TxEnvelope::Legacy(tx)),
+            Self::EIP2930(tx) => Ok(TxEnvelope::Eip2930(tx)),
+            Self::EIP1559(tx) => Ok(TxEnvelope::Eip1559(tx)),
+            Self::EIP4844(tx) => Ok(TxEnvelope::Eip4844(tx)),
+            Self::EIP7702(tx) => Ok(TxEnvelope::Eip7702(tx)),
+            Self::Deposit(_) => Err(self),
+        }
+    }
+
     /// Returns true if the transaction uses dynamic fees: EIP1559, EIP4844 or EIP7702
     pub fn is_dynamic_fee(&self) -> bool {
         matches!(self, Self::EIP1559(_) | Self::EIP4844(_) | Self::EIP7702(_))

crates/anvil/src/eth/backend/mem/mod.rs

@@ -3851,9 +3851,9 @@ pub fn transaction_build(
         }
     }
 
-    let mut transaction: Transaction = eth_transaction.clone().into();
+    let mut transaction = eth_transaction.into_rpc_transaction();
 
-    let effective_gas_price = if !eth_transaction.is_dynamic_fee() {
+    let effective_gas_price = if !transaction.inner.is_dynamic_fee() {
         transaction.effective_gas_price(base_fee)
     } else if block.is_none() && info.is_none() {
         // transaction is not mined yet, gas price is considered just `max_fee_per_gas`
@@ -3870,6 +3870,7 @@ pub fn transaction_build(
     transaction.effective_gas_price = Some(effective_gas_price);
 
     let envelope = transaction.inner;
+    let from = envelope.signer();
 
     // if a specific hash was provided we update the transaction's hash
     // This is important for impersonated transactions since they all use the
@@ -3907,10 +3908,7 @@ pub fn transaction_build(
     };
 
     let tx = Transaction {
-        inner: Recovered::new_unchecked(
-            envelope,
-            eth_transaction.recover().expect("can recover signed tx"),
-        ),
+        inner: Recovered::new_unchecked(envelope, from),
         block_hash: block
             .as_ref()
             .map(|block| B256::from(keccak256(alloy_rlp::encode(&block.header)))),