feat(evm, forge): use alloy TransactionRequest for saving BroadcastableTransactions

crates/anvil/src/eth/backend/fork.rs

@@ -241,7 +241,7 @@ impl ClientFork {
         index: U256,
         number: Option<BlockNumber>,
     ) -> Result<StorageValue, TransportError> {
-        self.provider().get_storage_at(address, index, number.map(Into::into)).await
+        self.provider().get_storage_at(address, index.into(), number.map(Into::into)).await
     }
 
     pub async fn logs(&self, filter: &Filter) -> Result<Vec<Log>, TransportError> {

crates/cheatcodes/src/inspector.rs

@@ -14,13 +14,11 @@ use crate::{
     },
     CheatsConfig, CheatsCtxt, Error, Result, Vm,
 };
-use alloy_primitives::{Address, Bytes, B256, U256};
+use alloy_primitives::{Address, Bytes, B256, U256, U64};
+use alloy_rpc_types::request::TransactionRequest;
 use alloy_sol_types::{SolInterface, SolValue};
-use ethers_core::types::{
-    transaction::eip2718::TypedTransaction, NameOrAddress, TransactionRequest,
-};
 use ethers_signers::LocalWallet;
-use foundry_common::{evm::Breakpoints, provider::alloy::RpcUrl, types::ToEthers};
+use foundry_common::{evm::Breakpoints, provider::alloy::RpcUrl};
 use foundry_evm_core::{
     backend::{DatabaseError, DatabaseExt, RevertDiagnostic},
     constants::{CHEATCODE_ADDRESS, DEFAULT_CREATE2_DEPLOYER, HARDHAT_CONSOLE_ADDRESS},
@@ -80,7 +78,7 @@ pub struct BroadcastableTransaction {
     /// The optional RPC URL.
     pub rpc: Option<RpcUrl>,
     /// The transaction to broadcast.
-    pub transaction: TypedTransaction,
+    pub transaction: TransactionRequest,
 }
 
 /// List of transactions that can be broadcasted.
@@ -834,19 +832,19 @@ impl<DB: DatabaseExt> Inspector<DB> for Cheatcodes {
 
                     self.broadcastable_transactions.push_back(BroadcastableTransaction {
                         rpc: data.db.active_fork_url(),
-                        transaction: TypedTransaction::Legacy(TransactionRequest {
-                            from: Some(broadcast.new_origin.to_ethers()),
-                            to: Some(NameOrAddress::Address(call.contract.to_ethers())),
-                            value: Some(call.transfer.value.to_ethers()),
-                            data: Some(call.input.clone().to_ethers()),
-                            nonce: Some(account.info.nonce.into()),
+                        transaction: TransactionRequest {
+                            from: Some(broadcast.new_origin),
+                            to: Some(call.contract),
+                            value: Some(call.transfer.value),
+                            data: Some(call.input.clone()),
+                            nonce: Some(U64::from(account.info.nonce)),
                             gas: if is_fixed_gas_limit {
-                                Some(call.gas_limit.into())
+                                Some(U256::from(call.gas_limit))
                             } else {
                                 None
                             },
                             ..Default::default()
-                        }),
+                        },
                     });
                     debug!(target: "cheatcodes", tx=?self.broadcastable_transactions.back().unwrap(), "broadcastable call");
 
@@ -1220,19 +1218,19 @@ impl<DB: DatabaseExt> Inspector<DB> for Cheatcodes {
 
                     self.broadcastable_transactions.push_back(BroadcastableTransaction {
                         rpc: data.db.active_fork_url(),
-                        transaction: TypedTransaction::Legacy(TransactionRequest {
-                            from: Some(broadcast.new_origin.to_ethers()),
-                            to: to.map(|a| NameOrAddress::Address(a.to_ethers())),
-                            value: Some(call.value.to_ethers()),
-                            data: Some(bytecode.to_ethers()),
-                            nonce: Some(nonce.into()),
+                        transaction: TransactionRequest {
+                            from: Some(broadcast.new_origin),
+                            to,
+                            value: Some(call.value),
+                            data: Some(bytecode),
+                            nonce: Some(U64::from(nonce)),
                             gas: if is_fixed_gas_limit {
-                                Some(call.gas_limit.into())
+                                Some(U256::from(call.gas_limit))
                             } else {
                                 None
                             },
                             ..Default::default()
-                        }),
+                        },
                     });
                     let kind = match call.scheme {
                         CreateScheme::Create => "create",

crates/evm/core/src/fork/backend.rs

@@ -179,8 +179,10 @@ where
                 let provider = self.provider.clone();
                 let block_id = self.block_id;
                 let fut = Box::pin(async move {
-                    let storage =
-                        provider.get_storage_at(address, idx, block_id).await.map_err(Into::into);
+                    let storage = provider
+                        .get_storage_at(address, idx.into(), block_id)
+                        .await
+                        .map_err(Into::into);
                     (storage, address, idx)
                 });
                 self.pending_requests.push(ProviderRequest::Storage(fut));

crates/forge/bin/cmd/script/broadcast.rs

@@ -3,6 +3,7 @@ use super::{
     sequence::ScriptSequence, transaction::TransactionWithMetadata, verify::VerifyBundle, *,
 };
 use alloy_primitives::{utils::format_units, TxHash};
+use ethers_core::types::transaction::eip2718::TypedTransaction;
 use ethers_providers::{JsonRpcClient, Middleware, Provider};
 use ethers_signers::Signer;
 use eyre::{bail, ContextCompat, Result, WrapErr};
@@ -407,7 +408,7 @@ impl ScriptArgs {
             shell::println("\nSKIPPING ON CHAIN SIMULATION.")?;
             txs.into_iter()
                 .map(|btx| {
-                    let mut tx = TransactionWithMetadata::from_typed_transaction(btx.transaction);
+                    let mut tx = TransactionWithMetadata::from_tx_request(btx.transaction);
                     tx.rpc = btx.rpc;
                     tx
                 })

crates/forge/bin/cmd/script/cmd.rs

@@ -1,6 +1,6 @@
 use super::{multi::MultiChainSequence, sequence::ScriptSequence, verify::VerifyBundle, *};
 use alloy_primitives::Bytes;
-use ethers_core::types::transaction::eip2718::TypedTransaction;
+
 use ethers_providers::Middleware;
 use ethers_signers::Signer;
 use eyre::Result;
@@ -171,7 +171,7 @@ impl ScriptArgs {
             for tx in txs.iter() {
                 lib_deploy.push_back(BroadcastableTransaction {
                     rpc: tx.rpc.clone(),
-                    transaction: TypedTransaction::Legacy(tx.transaction.clone().into()),
+                    transaction: tx.transaction.clone(),
                 });
             }
             *txs = lib_deploy;
@@ -336,7 +336,7 @@ impl ScriptArgs {
             for new_tx in new_txs.iter() {
                 txs.push_back(BroadcastableTransaction {
                     rpc: new_tx.rpc.clone(),
-                    transaction: TypedTransaction::Legacy(new_tx.transaction.clone().into()),
+                    transaction: new_tx.transaction.clone(),
                 });
             }
         }

crates/forge/bin/cmd/script/executor.rs

@@ -5,7 +5,7 @@ use super::{
     *,
 };
 use alloy_primitives::{Address, Bytes, U256};
-use ethers_core::types::transaction::eip2718::TypedTransaction;
+
 use eyre::Result;
 use forge::{
     backend::Backend,
@@ -14,11 +14,7 @@ use forge::{
     traces::CallTraceDecoder,
 };
 use foundry_cli::utils::{ensure_clean_constructor, needs_setup};
-use foundry_common::{
-    provider::ethers::RpcUrl,
-    shell,
-    types::{ToAlloy, ToEthers},
-};
+use foundry_common::{provider::ethers::RpcUrl, shell};
 use foundry_compilers::artifacts::CompactContractBytecode;
 use futures::future::join_all;
 use parking_lot::RwLock;
@@ -142,17 +138,14 @@ impl ScriptArgs {
                 let rpc = transaction.rpc.as_ref().expect("missing broadcastable tx rpc url");
                 let mut runner = runners.get(rpc).expect("invalid rpc url").write();
 
-                let TypedTransaction::Legacy(mut tx) = transaction.transaction else {
-                    unreachable!()
-                };
+                let mut tx = transaction.transaction;
                 let result = runner
                     .simulate(
                         tx.from
-                            .expect("transaction doesn't have a `from` address at execution time")
-                            .to_alloy(),
-                        tx.to.clone(),
-                        tx.data.clone().map(|b| b.to_alloy()),
-                        tx.value.map(|v| v.to_alloy()),
+                            .expect("transaction doesn't have a `from` address at execution time"),
+                        tx.to,
+                        tx.data.clone(),
+                        tx.value,
                     )
                     .wrap_err("Internal EVM error during simulation")?;
 
@@ -191,12 +184,12 @@ impl ScriptArgs {
                     // We inflate the gas used by the user specified percentage
                     None => {
                         let gas = U256::from(result.gas_used * self.gas_estimate_multiplier / 100);
-                        tx.gas = Some(gas.to_ethers());
+                        tx.gas = Some(gas);
                     }
                 }
 
                 let tx = TransactionWithMetadata::new(
-                    tx.into(),
+                    tx,
                     transaction.rpc,
                     &result,
                     &address_to_abi,

crates/forge/bin/cmd/script/mod.rs

@@ -2,12 +2,10 @@ use self::{build::BuildOutput, runner::ScriptRunner};
 use super::{build::BuildArgs, retry::RetryArgs};
 use alloy_dyn_abi::FunctionExt;
 use alloy_json_abi::{Function, InternalType, JsonAbi};
-use alloy_primitives::{Address, Bytes, Log, U256};
+use alloy_primitives::{Address, Bytes, Log, U256, U64};
+use alloy_rpc_types::request::TransactionRequest;
 use clap::{Parser, ValueHint};
 use dialoguer::Confirm;
-use ethers_core::types::{
-    transaction::eip2718::TypedTransaction, NameOrAddress, TransactionRequest,
-};
 use ethers_providers::{Http, Middleware};
 use ethers_signers::LocalWallet;
 use eyre::{ContextCompat, Result, WrapErr};
@@ -29,9 +27,7 @@ use foundry_common::{
     evm::{Breakpoints, EvmArgs},
     fmt::{format_token, format_token_raw},
     provider::ethers::RpcUrl,
-    shell,
-    types::{ToAlloy, ToEthers},
-    ContractsByArtifact, CONTRACT_MAX_SIZE, SELECTOR_LEN,
+    shell, ContractsByArtifact, CONTRACT_MAX_SIZE, SELECTOR_LEN,
 };
 use foundry_compilers::{
     artifacts::{ContractBytecodeSome, Libraries},
@@ -387,21 +383,16 @@ impl ScriptArgs {
             // If the user passed a `--sender` don't check anything.
             if !predeploy_libraries.is_empty() && self.evm_opts.sender.is_none() {
                 for tx in txs.iter() {
-                    match &tx.transaction {
-                        TypedTransaction::Legacy(tx) => {
-                            if tx.to.is_none() {
-                                let sender = tx.from.expect("no sender").to_alloy();
-                                if let Some(ns) = new_sender {
-                                    if sender != ns {
-                                        shell::println("You have more than one deployer who could predeploy libraries. Using `--sender` instead.")?;
-                                        return Ok(None);
-                                    }
-                                } else if sender != evm_opts.sender {
-                                    new_sender = Some(sender);
-                                }
+                    if tx.transaction.to.is_none() {
+                        let sender = tx.transaction.from.expect("no sender");
+                        if let Some(ns) = new_sender {
+                            if sender != ns {
+                                shell::println("You have more than one deployer who could predeploy libraries. Using `--sender` instead.")?;
+                                return Ok(None);
                             }
+                        } else if sender != evm_opts.sender {
+                            new_sender = Some(sender);
                         }
-                        _ => unreachable!(),
                     }
                 }
             }
@@ -422,12 +413,12 @@ impl ScriptArgs {
             .enumerate()
             .map(|(i, bytes)| BroadcastableTransaction {
                 rpc: fork_url.clone(),
-                transaction: TypedTransaction::Legacy(TransactionRequest {
-                    from: Some(from.to_ethers()),
-                    data: Some(bytes.clone().to_ethers()),
-                    nonce: Some((nonce + i as u64).into()),
+                transaction: TransactionRequest {
+                    from: Some(from),
+                    data: Some(bytes.clone()),
+                    nonce: Some(U64::from(nonce + i as u64)),
                     ..Default::default()
-                }),
+                },
             })
             .collect()
     }
@@ -519,16 +510,17 @@ impl ScriptArgs {
         for (data, to) in result.transactions.iter().flat_map(|txes| {
             txes.iter().filter_map(|tx| {
                 tx.transaction
-                    .data()
+                    .data
+                    .clone()
                     .filter(|data| data.len() > max_size)
-                    .map(|data| (data, tx.transaction.to()))
+                    .map(|data| (data, tx.transaction.to))
             })
         }) {
             let mut offset = 0;
 
             // Find if it's a CREATE or CREATE2. Otherwise, skip transaction.
-            if let Some(NameOrAddress::Address(to)) = to {
-                if to.to_alloy() == DEFAULT_CREATE2_DEPLOYER {
+            if let Some(to) = to {
+                if to == DEFAULT_CREATE2_DEPLOYER {
                     // Size of the salt prefix.
                     offset = 32;
                 }

crates/forge/bin/cmd/script/runner.rs

@@ -1,6 +1,5 @@
 use super::*;
 use alloy_primitives::{Address, Bytes, U256};
-use ethers_core::types::NameOrAddress;
 use eyre::Result;
 use forge::{
     constants::CALLER,
@@ -204,18 +203,12 @@ impl ScriptRunner {
     pub fn simulate(
         &mut self,
         from: Address,
-        to: Option<NameOrAddress>,
+        to: Option<Address>,
         calldata: Option<Bytes>,
         value: Option<U256>,
     ) -> Result<ScriptResult> {
-        if let Some(NameOrAddress::Address(to)) = to {
-            self.call(
-                from,
-                to.to_alloy(),
-                calldata.unwrap_or_default(),
-                value.unwrap_or(U256::ZERO),
-                true,
-            )
+        if let Some(to) = to {
+            self.call(from, to, calldata.unwrap_or_default(), value.unwrap_or(U256::ZERO), true)
         } else if to.is_none() {
             let (address, gas_used, logs, traces, debug) = match self.executor.deploy(
                 from,

crates/forge/bin/cmd/script/transaction.rs

@@ -2,7 +2,11 @@ use super::{artifacts::ArtifactInfo, ScriptResult};
 use alloy_dyn_abi::JsonAbiExt;
 use alloy_json_abi::Function;
 use alloy_primitives::{Address, Bytes, B256};
-use ethers_core::types::{transaction::eip2718::TypedTransaction, NameOrAddress};
+use alloy_rpc_types::request::TransactionRequest;
+use ethers_core::types::{
+    transaction::eip2718::TypedTransaction, NameOrAddress,
+    TransactionRequest as EthersTransactionRequest,
+};
 use eyre::{ContextCompat, Result, WrapErr};
 use foundry_common::{
     fmt::format_token_raw,
@@ -59,20 +63,33 @@ fn default_vec_of_strings() -> Option<Vec<String>> {
 }
 
 impl TransactionWithMetadata {
-    pub fn from_typed_transaction(transaction: TypedTransaction) -> Self {
-        Self { transaction, ..Default::default() }
+    pub fn from_tx_request(transaction: TransactionRequest) -> Self {
+        Self {
+            transaction: TypedTransaction::Legacy(EthersTransactionRequest {
+                from: transaction.from.map(ToEthers::to_ethers),
+                to: transaction.to.map(ToEthers::to_ethers).map(Into::into),
+                value: transaction.value.map(ToEthers::to_ethers),
+                data: transaction.data.map(ToEthers::to_ethers),
+                nonce: transaction.nonce.map(|n| n.to::<u64>().into()),
+                gas: transaction.gas.map(ToEthers::to_ethers),
+                ..Default::default()
+            }),
+            ..Default::default()
+        }
     }
 
     pub fn new(
-        transaction: TypedTransaction,
+        transaction: TransactionRequest,
         rpc: Option<RpcUrl>,
         result: &ScriptResult,
         local_contracts: &BTreeMap<Address, ArtifactInfo>,
         decoder: &CallTraceDecoder,
         additional_contracts: Vec<AdditionalContract>,
         is_fixed_gas_limit: bool,
     ) -> Result<Self> {
-        let mut metadata = Self { transaction, rpc, is_fixed_gas_limit, ..Default::default() };
+        let mut metadata = Self::from_tx_request(transaction);
+        metadata.rpc = rpc;
+        metadata.is_fixed_gas_limit = is_fixed_gas_limit;
 
         // Specify if any contract was directly created with this transaction
         if let Some(NameOrAddress::Address(to)) = metadata.transaction.to().cloned() {