generic cast run

figtracer · figtracer · commit 3aa03f575299 · 2026-04-03T17:01:41.000+01:00
diff --git a/crates/cast/src/cmd/run.rs b/crates/cast/src/cmd/run.rs
@@ -2,10 +2,10 @@ use crate::{
     debug::handle_traces,
     utils::{apply_chain_and_block_specific_env_changes, block_env_from_header},
 };
-use alloy_consensus::{BlockHeader, Transaction};
+use alloy_consensus::{BlockHeader, Transaction, transaction::SignerRecoverable};
 
 use alloy_evm::FromRecoveredTx;
-use alloy_network::{AnyNetwork, TransactionResponse};
+use alloy_network::{BlockResponse, TransactionResponse};
 use alloy_primitives::{
     Address, Bytes, U256,
     map::{AddressSet, HashMap},
@@ -18,7 +18,9 @@ use foundry_cli::{
     opts::{EtherscanOpts, RpcOpts},
     utils::{TraceResult, init_progress},
 };
-use foundry_common::{SYSTEM_TRANSACTION_TYPE, is_impersonated_tx, is_known_system_sender, shell};
+use foundry_common::{
+    SYSTEM_TRANSACTION_TYPE, is_known_system_sender, provider::ProviderBuilder, shell,
+};
 use foundry_compilers::artifacts::EvmVersion;
 use foundry_config::{
     Config,
@@ -28,13 +30,16 @@ use foundry_config::{
     },
 };
 use foundry_evm::{
-    core::evm::EthEvmNetwork,
+    core::{
+        FoundryBlock as _,
+        evm::{EthEvmNetwork, FoundryEvmNetwork, TempoEvmNetwork, TxEnvFor},
+    },
     executors::{EvmError, Executor, TracingExecutor},
     opts::EvmOpts,
     traces::{InternalTraceMode, TraceMode, Traces},
 };
 use futures::TryFutureExt;
-use revm::{DatabaseRef, context::TxEnv};
+use revm::{DatabaseRef, context::Block};
 
 /// CLI arguments for `cast run`.
 #[derive(Clone, Debug, Parser)]
@@ -126,6 +131,16 @@ impl RunArgs {
     ///
     /// Note: This executes the transaction(s) as is: Cheatcodes are disabled
     pub async fn run(self) -> Result<()> {
+        let figment = self.rpc.clone().into_figment(self.with_local_artifacts).merge(&self);
+        let evm_opts = figment.extract::<EvmOpts>()?;
+        if evm_opts.networks.is_tempo() {
+            self.run_with_evm::<TempoEvmNetwork>().await
+        } else {
+            self.run_with_evm::<EthEvmNetwork>().await
+        }
+    }
+
+    async fn run_with_evm<FEN: FoundryEvmNetwork>(self) -> Result<()> {
         let figment = self.rpc.clone().into_figment(self.with_local_artifacts).merge(&self);
         let evm_opts = figment.extract::<EvmOpts>()?;
         let mut config = Config::from_provider(figment)?.sanitized();
@@ -138,7 +153,7 @@ impl RunArgs {
         let compute_units_per_second =
             if self.no_rate_limit { Some(u64::MAX) } else { self.compute_units_per_second };
 
-        let provider = foundry_cli::utils::get_provider_builder(&config)?
+        let provider = ProviderBuilder::<FEN::Network>::from_config(&config)?
             .compute_units_per_second_opt(compute_units_per_second)
             .build()?;
 
@@ -160,8 +175,9 @@ impl RunArgs {
             ));
         }
 
-        let tx_block_number =
-            tx.block_number.ok_or_else(|| eyre::eyre!("tx may still be pending: {:?}", tx_hash))?;
+        let tx_block_number = tx
+            .block_number()
+            .ok_or_else(|| eyre::eyre!("tx may still be pending: {:?}", tx_hash))?;
 
         // we need to fork off the parent block
         config.fork_block_number = Some(tx_block_number - 1);
@@ -170,7 +186,7 @@ impl RunArgs {
         let (block, (mut evm_env, tx_env, fork, chain, networks)) = tokio::try_join!(
             // fetch the block the transaction was mined in
             provider.get_block(tx_block_number.into()).full().into_future().map_err(Into::into),
-            TracingExecutor::<EthEvmNetwork>::get_fork_material(&mut config, evm_opts)
+            TracingExecutor::<FEN>::get_fork_material(&mut config, evm_opts)
         )?;
 
         let mut evm_version = self.evm_version;
@@ -184,20 +200,20 @@ impl RunArgs {
         }
 
         evm_env.cfg_env.limit_contract_code_size = None;
-        evm_env.block_env.number = U256::from(tx_block_number);
+        evm_env.block_env.set_number(U256::from(tx_block_number));
 
         if let Some(block) = &block {
-            evm_env.block_env = block_env_from_header(&block.header);
+            evm_env.block_env = block_env_from_header(block.header());
 
             // TODO: we need a smarter way to map the block to the corresponding evm_version for
             // commonly used chains
             if evm_version.is_none() {
                 // if the block has the excess_blob_gas field, we assume it's a Cancun block
-                if block.header.excess_blob_gas().is_some() {
+                if block.header().excess_blob_gas().is_some() {
                     evm_version = Some(EvmVersion::Prague);
                 }
             }
-            apply_chain_and_block_specific_env_changes::<AnyNetwork, _, _>(
+            apply_chain_and_block_specific_env_changes::<FEN::Network, _, _>(
                 &mut evm_env,
                 block,
                 config.networks,
@@ -212,7 +228,7 @@ impl RunArgs {
                 InternalTraceMode::None
             })
             .with_state_changes(shell::verbosity() > 4);
-        let mut executor = TracingExecutor::<EthEvmNetwork>::new(
+        let mut executor = TracingExecutor::<FEN>::new(
             (evm_env.clone(), tx_env),
             fork,
             evm_version,
@@ -231,10 +247,10 @@ impl RunArgs {
             }
 
             if let Some(block) = block {
-                let pb = init_progress(block.transactions.len() as u64, "tx");
+                let pb = init_progress(block.transactions().len() as u64, "tx");
                 pb.set_position(0);
 
-                let BlockTransactions::Full(ref txs) = block.transactions else {
+                let BlockTransactions::Full(ref txs) = *block.transactions() else {
                     return Err(eyre::eyre!("Could not get block txs"));
                 };
 
@@ -253,9 +269,7 @@ impl RunArgs {
                         break;
                     }
 
-                    let tx_env = tx.as_envelope().map_or(Default::default(), |tx_envelope| {
-                        TxEnv::from_recovered_tx(tx_envelope, tx.from())
-                    });
+                    let tx_env = TxEnvFor::<FEN>::from_recovered_tx(tx.as_ref(), tx.from());
 
                     evm_env.cfg_env.disable_balance_check = true;
 
@@ -266,7 +280,7 @@ impl RunArgs {
                                 format!(
                                     "Failed to execute transaction: {:?} in block {}",
                                     tx.tx_hash(),
-                                    evm_env.block_env.number
+                                    evm_env.block_env.number()
                                 )
                             },
                         )?;
@@ -283,7 +297,7 @@ impl RunArgs {
                                         format!(
                                             "Failed to deploy transaction: {:?} in block {}",
                                             tx.tx_hash(),
-                                            evm_env.block_env.number
+                                            evm_env.block_env.number()
                                         )
                                     });
                                 }
@@ -300,17 +314,15 @@ impl RunArgs {
         let result = {
             executor.set_trace_printer(self.trace_printer);
 
-            let tx_env = tx.as_envelope().map_or(Default::default(), |tx_envelope| {
-                TxEnv::from_recovered_tx(tx_envelope, tx.from())
-            });
+            let tx_env = TxEnvFor::<FEN>::from_recovered_tx(tx.as_ref(), tx.from());
 
-            if is_impersonated_tx(tx.as_ref()) {
+            if tx.as_ref().recover_signer().is_ok_and(|signer| signer != tx.from()) {
                 evm_env.cfg_env.disable_balance_check = true;
             }
 
             if let Some(to) = Transaction::to(&tx) {
                 trace!(tx=?tx.tx_hash(), to=?to, "executing call transaction");
-                TraceResult::try_from(executor.transact_with_env(evm_env, tx_env))?
+                TraceResult::from(executor.transact_with_env(evm_env, tx_env)?)
             } else {
                 trace!(tx=?tx.tx_hash(), "executing create transaction");
                 TraceResult::try_from(executor.deploy_with_env(evm_env, tx_env, None))?
@@ -336,8 +348,8 @@ impl RunArgs {
     }
 }
 
-pub fn fetch_contracts_bytecode_from_trace(
-    executor: &Executor<EthEvmNetwork>,
+pub fn fetch_contracts_bytecode_from_trace<FEN: FoundryEvmNetwork>(
+    executor: &Executor<FEN>,
     result: &TraceResult,
 ) -> Result<HashMap<Address, Bytes>> {
     let mut contracts_bytecode = HashMap::default();
diff --git a/crates/cli/src/utils/cmd.rs b/crates/cli/src/utils/cmd.rs
@@ -6,6 +6,7 @@ use foundry_compilers::{
 };
 use foundry_config::{Chain, Config, NamedChain, error::ExtractConfigError, figment::Figment};
 use foundry_evm::{
+    core::evm::FoundryEvmNetwork,
     executors::{DeployResult, EvmError, RawCallResult},
     opts::EvmOpts,
     traces::{
@@ -244,22 +245,25 @@ pub struct TraceResult {
 
 impl TraceResult {
     /// Create a new [`TraceResult`] from a [`RawCallResult`].
-    pub fn from_raw(raw: RawCallResult, trace_kind: TraceKind) -> Self {
+    pub fn from_raw<FEN: FoundryEvmNetwork>(
+        raw: RawCallResult<FEN>,
+        trace_kind: TraceKind,
+    ) -> Self {
         let RawCallResult { gas_used, traces, reverted, .. } = raw;
         Self { success: !reverted, traces: traces.map(|arena| vec![(trace_kind, arena)]), gas_used }
     }
 }
 
-impl From<DeployResult> for TraceResult {
-    fn from(result: DeployResult) -> Self {
+impl<FEN: FoundryEvmNetwork> From<DeployResult<FEN>> for TraceResult {
+    fn from(result: DeployResult<FEN>) -> Self {
         Self::from_raw(result.raw, TraceKind::Deployment)
     }
 }
 
-impl TryFrom<Result<DeployResult, EvmError>> for TraceResult {
-    type Error = EvmError;
+impl<FEN: FoundryEvmNetwork> TryFrom<Result<DeployResult<FEN>, EvmError<FEN>>> for TraceResult {
+    type Error = EvmError<FEN>;
 
-    fn try_from(value: Result<DeployResult, EvmError>) -> Result<Self, Self::Error> {
+    fn try_from(value: Result<DeployResult<FEN>, EvmError<FEN>>) -> Result<Self, Self::Error> {
         match value {
             Ok(result) => Ok(Self::from(result)),
             Err(EvmError::Execution(err)) => Ok(Self::from_raw(err.raw, TraceKind::Deployment)),
@@ -268,23 +272,12 @@ impl TryFrom<Result<DeployResult, EvmError>> for TraceResult {
     }
 }
 
-impl From<RawCallResult> for TraceResult {
-    fn from(result: RawCallResult) -> Self {
+impl<FEN: FoundryEvmNetwork> From<RawCallResult<FEN>> for TraceResult {
+    fn from(result: RawCallResult<FEN>) -> Self {
         Self::from_raw(result, TraceKind::Execution)
     }
 }
 
-impl TryFrom<Result<RawCallResult>> for TraceResult {
-    type Error = EvmError;
-
-    fn try_from(value: Result<RawCallResult>) -> Result<Self, Self::Error> {
-        match value {
-            Ok(result) => Ok(Self::from(result)),
-            Err(err) => Err(EvmError::from(err)),
-        }
-    }
-}
-
 pub async fn print_traces(
     result: &mut TraceResult,
     decoder: &CallTraceDecoder,
