foundry_evm/executors/
trace.rs

1use crate::executors::{Executor, ExecutorBuilder};
2use alloy_primitives::{Address, U256, map::HashMap};
3use alloy_rpc_types::state::StateOverride;
4use eyre::Context;
5use foundry_compilers::artifacts::EvmVersion;
6use foundry_config::{Chain, Config, evm_spec_id};
7use foundry_evm_core::{
8    backend::Backend,
9    evm::{BlockEnvFor, EvmEnvFor, FoundryEvmNetwork, SpecFor, TxEnvFor},
10    fork::CreateFork,
11    opts::EvmOpts,
12};
13use foundry_evm_hardforks::TempoHardfork;
14use foundry_evm_networks::NetworkConfigs;
15use foundry_evm_traces::TraceMode;
16use revm::{context::Transaction, state::Bytecode};
17use std::ops::{Deref, DerefMut};
18
19/// A default executor with tracing enabled
20pub struct TracingExecutor<FEN: FoundryEvmNetwork> {
21    executor: Executor<FEN>,
22}
23
24impl<FEN: FoundryEvmNetwork> TracingExecutor<FEN> {
25    pub fn new(
26        env: (EvmEnvFor<FEN>, TxEnvFor<FEN>),
27        fork: CreateFork,
28        version: Option<EvmVersion>,
29        trace_mode: TraceMode,
30        networks: NetworkConfigs,
31        create2_deployer: Address,
32        state_overrides: Option<StateOverride>,
33    ) -> eyre::Result<Self> {
34        let db = Backend::spawn(Some(fork))?;
35        // configures a bare version of the evm executor: no cheatcode and log_collector inspector
36        // is enabled, tracing will be enabled only for the targeted transaction
37        let mut executor = ExecutorBuilder::default()
38            .inspectors(|stack| {
39                stack.trace_mode(trace_mode).networks(networks).create2_deployer(create2_deployer)
40            })
41            .spec_id_opt(version.map(evm_spec_id::<SpecFor<FEN>>))
42            .build(env.0, env.1, db);
43
44        // Apply the state overrides.
45        if let Some(state_overrides) = state_overrides {
46            for (address, overrides) in state_overrides {
47                if let Some(balance) = overrides.balance {
48                    executor.set_balance(address, balance)?;
49                }
50                if let Some(nonce) = overrides.nonce {
51                    executor.set_nonce(address, nonce)?;
52                }
53                if let Some(code) = overrides.code {
54                    let bytecode = Bytecode::new_raw_checked(code)
55                        .wrap_err("invalid bytecode in state override")?;
56                    executor.set_code(address, bytecode)?;
57                }
58                if let Some(state) = overrides.state {
59                    let state: HashMap<U256, U256> = state
60                        .into_iter()
61                        .map(|(slot, value)| (slot.into(), value.into()))
62                        .collect();
63                    executor.set_storage(address, state)?;
64                }
65                if let Some(state_diff) = overrides.state_diff {
66                    for (slot, value) in state_diff {
67                        executor.set_storage_slot(address, slot.into(), value.into())?;
68                    }
69                }
70            }
71        }
72
73        Ok(Self { executor })
74    }
75
76    /// Returns the spec id of the executor
77    pub const fn spec_id(&self) -> SpecFor<FEN> {
78        self.executor.spec_id()
79    }
80
81    /// uses the fork block number from the config
82    pub async fn get_fork_material(
83        config: &mut Config,
84        mut evm_opts: EvmOpts,
85    ) -> eyre::Result<(EvmEnvFor<FEN>, TxEnvFor<FEN>, CreateFork, Chain, NetworkConfigs)> {
86        evm_opts.fork_url = Some(config.get_rpc_url_or_localhost_http()?.into_owned());
87        evm_opts.fork_block_number = config.fork_block_number;
88
89        let (evm_env, tx_env, fork_block) =
90            evm_opts.env::<SpecFor<FEN>, BlockEnvFor<FEN>, TxEnvFor<FEN>>().await?;
91
92        let fork = evm_opts.get_fork(config, evm_env.cfg_env.chain_id, fork_block).unwrap();
93        let networks = evm_opts.networks.with_chain_id(evm_env.cfg_env.chain_id);
94        config
95            .labels
96            .extend(networks.precompiles_label(Some(config.evm_spec_id::<TempoHardfork>())));
97
98        let chain = tx_env.chain_id().unwrap().into();
99        Ok((evm_env, tx_env, fork, chain, networks))
100    }
101}
102
103impl<FEN: FoundryEvmNetwork> Deref for TracingExecutor<FEN> {
104    type Target = Executor<FEN>;
105
106    fn deref(&self) -> &Self::Target {
107        &self.executor
108    }
109}
110
111impl<FEN: FoundryEvmNetwork> DerefMut for TracingExecutor<FEN> {
112    fn deref_mut(&mut self) -> &mut Self::Target {
113        &mut self.executor
114    }
115}
foundry_evm/executors/trace.rs

foundry_evm/executors/
trace.rs
