Merge branch 'foundry-rs:master' into master

Author: Dargon789

Cargo.lock

@@ -30,6 +30,7 @@ alloy-rlp.workspace = true
 alloy-eips.workspace = true
 alloy-eip5792.workspace = true
 alloy-consensus = { workspace = true, features = ["k256", "kzg"] }
+alloy-network.workspace = true
 alloy-dyn-abi = { workspace = true, features = ["std", "eip712"] }
 serde.workspace = true
 serde_json.workspace = true

crates/anvil/core/Cargo.toml

@@ -2,20 +2,25 @@ use super::transaction::TransactionInfo;
 use alloy_consensus::{
     BlockBody, EMPTY_OMMER_ROOT_HASH, Header, proofs::calculate_transaction_root,
 };
-use foundry_primitives::FoundryReceiptEnvelope;
+use alloy_eips::eip2718::Encodable2718;
+use alloy_network::Network;
+use foundry_primitives::FoundryNetwork;
+use std::fmt::Debug;
 
-// Type alias to optionally support impersonated transactions
-type Transaction = crate::eth::transaction::MaybeImpersonatedTransaction;
+use crate::eth::transaction::{ImpersonatedTransaction, MaybeImpersonatedTransaction};
 
 /// Type alias for Ethereum Block with Anvil's transaction type
-pub type Block = alloy_consensus::Block<Transaction>;
+pub type Block = alloy_consensus::Block<MaybeImpersonatedTransaction>;
 
-/// Container type that gathers all block data
+/// Anvil's concrete block info type.
+pub type BlockInfo = TypedBlockInfo<FoundryNetwork>;
+
+/// Container type that gathers all block data, generic over a [`Network`].
 #[derive(Clone, Debug)]
-pub struct BlockInfo {
-    pub block: Block,
+pub struct TypedBlockInfo<N: Network> {
+    pub block: alloy_consensus::Block<ImpersonatedTransaction<N::TxEnvelope>>,
     pub transactions: Vec<TransactionInfo>,
-    pub receipts: Vec<FoundryReceiptEnvelope>,
+    pub receipts: Vec<N::ReceiptEnvelope>,
 }
 
 /// Helper function to create a new block with Header and Anvil transactions
@@ -24,7 +29,7 @@ pub struct BlockInfo {
 /// `MaybeImpersonatedTransaction`.
 pub fn create_block<T>(mut header: Header, transactions: impl IntoIterator<Item = T>) -> Block
 where
-    T: Into<Transaction>,
+    T: Into<MaybeImpersonatedTransaction>,
 {
     let transactions: Vec<_> = transactions.into_iter().map(Into::into).collect();
     let transactions_root = calculate_transaction_root(&transactions);
@@ -36,6 +41,24 @@ where
     Block::new(header, body)
 }
 
+/// Generic helper function to create a block with any transaction type that supports encoding.
+pub fn create_typed_block<T>(
+    mut header: Header,
+    transactions: impl IntoIterator<Item = T>,
+) -> alloy_consensus::Block<T>
+where
+    T: Encodable2718,
+{
+    let transactions: Vec<_> = transactions.into_iter().collect();
+    let transactions_root = calculate_transaction_root(&transactions);
+
+    header.transactions_root = transactions_root;
+    header.ommers_hash = EMPTY_OMMER_ROOT_HASH;
+
+    let body = BlockBody { transactions, ommers: Vec::new(), withdrawals: None };
+    alloy_consensus::Block::new(header, body)
+}
+
 #[cfg(test)]
 mod tests {
     use alloy_primitives::{

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

@@ -1,46 +1,58 @@
 //! Transaction related types
-use alloy_consensus::{
-    Signed, Transaction, Typed2718, crypto::RecoveryError, transaction::Recovered,
-};
+use alloy_consensus::{Transaction, Typed2718, crypto::RecoveryError};
 
 use alloy_eips::eip2718::Encodable2718;
 use alloy_primitives::{Address, B256, Bytes, TxHash};
 use alloy_rlp::{Decodable, Encodable};
-use alloy_rpc_types::Transaction as RpcTransaction;
 use bytes::BufMut;
 use foundry_evm::traces::CallTraceNode;
 use foundry_primitives::FoundryTxEnvelope;
 use revm::interpreter::InstructionResult;
 use serde::{Deserialize, Serialize};
 use std::ops::Deref;
 
-/// A wrapper for [FoundryTxEnvelope] that allows impersonating accounts.
+/// Anvil's concrete impersonated transaction type.
+pub type MaybeImpersonatedTransaction = ImpersonatedTransaction<FoundryTxEnvelope>;
+
+/// A wrapper for a transaction envelope that allows impersonating accounts.
 ///
 /// This is a helper that carries the `impersonated` sender so that the right hash
-/// [FoundryTxEnvelope::impersonated_hash] can be created.
+/// can be created.
 #[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
-pub struct MaybeImpersonatedTransaction {
-    transaction: FoundryTxEnvelope,
+pub struct ImpersonatedTransaction<T> {
+    transaction: T,
     impersonated_sender: Option<Address>,
 }
 
-impl Typed2718 for MaybeImpersonatedTransaction {
+impl<T: Typed2718> Typed2718 for ImpersonatedTransaction<T> {
     fn ty(&self) -> u8 {
         self.transaction.ty()
     }
 }
 
-impl MaybeImpersonatedTransaction {
+impl<T> ImpersonatedTransaction<T> {
     /// Creates a new wrapper for the given transaction
-    pub fn new(transaction: FoundryTxEnvelope) -> Self {
+    pub fn new(transaction: T) -> Self {
         Self { transaction, impersonated_sender: None }
     }
 
     /// Creates a new impersonated transaction wrapper using the given sender
-    pub fn impersonated(transaction: FoundryTxEnvelope, impersonated_sender: Address) -> Self {
+    pub fn impersonated(transaction: T, impersonated_sender: Address) -> Self {
         Self { transaction, impersonated_sender: Some(impersonated_sender) }
     }
 
+    /// Returns whether the transaction is impersonated
+    pub fn is_impersonated(&self) -> bool {
+        self.impersonated_sender.is_some()
+    }
+
+    /// Returns the inner transaction.
+    pub fn into_inner(self) -> T {
+        self.transaction
+    }
+}
+
+impl ImpersonatedTransaction<FoundryTxEnvelope> {
     /// Recovers the Ethereum address which was used to sign the transaction.
     pub fn recover(&self) -> Result<Address, RecoveryError> {
         if let Some(sender) = self.impersonated_sender {
@@ -49,41 +61,16 @@ impl MaybeImpersonatedTransaction {
         self.transaction.recover()
     }
 
-    /// Returns whether the transaction is impersonated
-    pub fn is_impersonated(&self) -> bool {
-        self.impersonated_sender.is_some()
-    }
-
     /// Returns the hash of the transaction
     pub fn hash(&self) -> B256 {
         if let Some(sender) = self.impersonated_sender {
             return self.transaction.impersonated_hash(sender);
         }
         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 (typed_tx, signature, _) = Into::<Signed<_>>::into(envelope).into_parts();
-        let inner_envelope = Signed::new_unchecked(typed_tx, signature, hash).into();
-
-        RpcTransaction {
-            block_hash: None,
-            block_number: None,
-            transaction_index: None,
-            effective_gas_price: None,
-            inner: Recovered::new_unchecked(inner_envelope, from),
-        }
-    }
 }
 
-impl Encodable2718 for MaybeImpersonatedTransaction {
+impl<T: Encodable2718> Encodable2718 for ImpersonatedTransaction<T> {
     fn encode_2718_len(&self) -> usize {
         self.transaction.encode_2718_len()
     }
@@ -93,7 +80,7 @@ impl Encodable2718 for MaybeImpersonatedTransaction {
     }
 }
 
-impl Encodable for MaybeImpersonatedTransaction {
+impl<T: Encodable> Encodable for ImpersonatedTransaction<T> {
     fn encode(&self, out: &mut dyn bytes::BufMut) {
         self.transaction.encode(out)
     }
@@ -111,32 +98,26 @@ impl From<FoundryTxEnvelope> for MaybeImpersonatedTransaction {
     }
 }
 
-impl Decodable for MaybeImpersonatedTransaction {
+impl<T: Decodable> Decodable for ImpersonatedTransaction<T> {
     fn decode(buf: &mut &[u8]) -> alloy_rlp::Result<Self> {
-        FoundryTxEnvelope::decode(buf).map(Self::new)
+        T::decode(buf).map(Self::new)
     }
 }
 
-impl AsRef<FoundryTxEnvelope> for MaybeImpersonatedTransaction {
-    fn as_ref(&self) -> &FoundryTxEnvelope {
+impl<T> AsRef<T> for ImpersonatedTransaction<T> {
+    fn as_ref(&self) -> &T {
         &self.transaction
     }
 }
 
-impl Deref for MaybeImpersonatedTransaction {
-    type Target = FoundryTxEnvelope;
+impl<T> Deref for ImpersonatedTransaction<T> {
+    type Target = T;
 
     fn deref(&self) -> &Self::Target {
         &self.transaction
     }
 }
 
-impl From<MaybeImpersonatedTransaction> for RpcTransaction {
-    fn from(value: MaybeImpersonatedTransaction) -> Self {
-        value.into_rpc_transaction()
-    }
-}
-
 /// Queued transaction
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct PendingTransaction {

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

@@ -3862,20 +3862,23 @@ pub fn transaction_build(
         }
     }
 
-    let transaction = eth_transaction.into_rpc_transaction();
-    let effective_gas_price = transaction.effective_gas_price(base_fee);
-
-    let envelope = transaction.inner;
-    let from = envelope.signer();
+    let from = eth_transaction.recover().unwrap_or_default();
+    let effective_gas_price = eth_transaction.effective_gas_price(base_fee);
 
     // if a specific hash was provided we update the transaction's hash
     // This is important for impersonated transactions since they all use the
     // `BYPASS_SIGNATURE` which would result in different hashes
     // Note: for impersonated transactions this only concerns pending transactions because
-    // there's // no `info` yet.
-    let hash = tx_hash.unwrap_or(*envelope.tx_hash());
+    // there's no `info` yet.
+    let hash = tx_hash.unwrap_or_else(|| eth_transaction.hash());
+
+    // TODO: this panics for non-standard tx types (e.g. Tempo) that aren't handled above
+    // (pre-existing issue from the original `into_rpc_transaction`).
+    let eth_envelope = FoundryTxEnvelope::from(eth_transaction)
+        .try_into_eth()
+        .expect("deposit transactions are handled above");
 
-    let envelope = match envelope.into_inner() {
+    let envelope = match eth_envelope {
         TxEnvelope::Legacy(signed_tx) => {
             let (t, sig, _) = signed_tx.into_parts();
             let new_signed = Signed::new_unchecked(t, sig, hash);