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

foundry_evm/executors/
trace.rs
