foundry_evm/executors/invariant/
replay.rs

1use super::{call_after_invariant_function, call_invariant_function, execute_tx};
2use crate::executors::{EarlyExit, Executor, invariant::shrink::shrink_sequence};
3use alloy_dyn_abi::JsonAbiExt;
4use alloy_primitives::{Log, map::HashMap};
5use eyre::Result;
6use foundry_common::{ContractsByAddress, ContractsByArtifact};
7use foundry_config::InvariantConfig;
8use foundry_evm_coverage::HitMaps;
9use foundry_evm_fuzz::{BaseCounterExample, BasicTxDetails, invariant::InvariantContract};
10use foundry_evm_traces::{TraceKind, TraceMode, Traces, load_contracts};
11use indicatif::ProgressBar;
12use parking_lot::RwLock;
13use std::sync::Arc;
14
15/// Replays a call sequence for collecting logs and traces.
16/// Returns counterexample to be used when the call sequence is a failed scenario.
17#[expect(clippy::too_many_arguments)]
18pub fn replay_run(
19    invariant_contract: &InvariantContract<'_>,
20    mut executor: Executor,
21    known_contracts: &ContractsByArtifact,
22    mut ided_contracts: ContractsByAddress,
23    logs: &mut Vec<Log>,
24    traces: &mut Traces,
25    line_coverage: &mut Option<HitMaps>,
26    deprecated_cheatcodes: &mut HashMap<&'static str, Option<&'static str>>,
27    inputs: &[BasicTxDetails],
28    show_solidity: bool,
29) -> Result<Vec<BaseCounterExample>> {
30    // We want traces for a failed case.
31    if executor.inspector().tracer.is_none() {
32        executor.set_tracing(TraceMode::Call);
33    }
34
35    let mut counterexample_sequence = vec![];
36
37    // Replay each call from the sequence, collect logs, traces and coverage.
38    for tx in inputs {
39        let call_result = execute_tx(&mut executor, tx)?;
40        logs.extend(call_result.logs);
41        traces.push((TraceKind::Execution, call_result.traces.clone().unwrap()));
42        HitMaps::merge_opt(line_coverage, call_result.line_coverage);
43
44        // Identify newly generated contracts, if they exist.
45        ided_contracts
46            .extend(load_contracts(call_result.traces.iter().map(|a| &a.arena), known_contracts));
47
48        // Create counter example to be used in failed case.
49        counterexample_sequence.push(BaseCounterExample::from_invariant_call(
50            tx,
51            &ided_contracts,
52            call_result.traces,
53            show_solidity,
54        ));
55    }
56
57    // Replay invariant to collect logs and traces.
58    // We do this only once at the end of the replayed sequence.
59    // Checking after each call doesn't add valuable info for passing scenario
60    // (invariant call result is always success) nor for failed scenarios
61    // (invariant call result is always success until the last call that breaks it).
62    let (invariant_result, invariant_success) = call_invariant_function(
63        &executor,
64        invariant_contract.address,
65        invariant_contract.invariant_function.abi_encode_input(&[])?.into(),
66    )?;
67    traces.push((TraceKind::Execution, invariant_result.traces.clone().unwrap()));
68    logs.extend(invariant_result.logs);
69    deprecated_cheatcodes.extend(
70        invariant_result
71            .cheatcodes
72            .as_ref()
73            .map_or_else(Default::default, |cheats| cheats.deprecated.clone()),
74    );
75
76    // Collect after invariant logs and traces.
77    if invariant_contract.call_after_invariant && invariant_success {
78        let (after_invariant_result, _) =
79            call_after_invariant_function(&executor, invariant_contract.address)?;
80        traces.push((TraceKind::Execution, after_invariant_result.traces.clone().unwrap()));
81        logs.extend(after_invariant_result.logs);
82    }
83
84    Ok(counterexample_sequence)
85}
86
87/// Replays the error case, shrinks the failing sequence and collects all necessary traces.
88#[expect(clippy::too_many_arguments)]
89pub fn replay_error(
90    config: InvariantConfig,
91    mut executor: Executor,
92    calls: &[BasicTxDetails],
93    inner_sequence: Option<Vec<Option<BasicTxDetails>>>,
94    invariant_contract: &InvariantContract<'_>,
95    known_contracts: &ContractsByArtifact,
96    ided_contracts: ContractsByAddress,
97    logs: &mut Vec<Log>,
98    traces: &mut Traces,
99    line_coverage: &mut Option<HitMaps>,
100    deprecated_cheatcodes: &mut HashMap<&'static str, Option<&'static str>>,
101    progress: Option<&ProgressBar>,
102    early_exit: &EarlyExit,
103) -> Result<Vec<BaseCounterExample>> {
104    // Shrink sequence of failed calls.
105    let calls =
106        shrink_sequence(&config, invariant_contract, calls, &executor, progress, early_exit)?;
107
108    if let Some(sequence) = inner_sequence {
109        set_up_inner_replay(&mut executor, &sequence);
110    }
111
112    // Replay calls to get the counterexample and to collect logs, traces and coverage.
113    replay_run(
114        invariant_contract,
115        executor,
116        known_contracts,
117        ided_contracts,
118        logs,
119        traces,
120        line_coverage,
121        deprecated_cheatcodes,
122        &calls,
123        config.show_solidity,
124    )
125}
126
127/// Sets up the calls generated by the internal fuzzer, if they exist.
128fn set_up_inner_replay(executor: &mut Executor, inner_sequence: &[Option<BasicTxDetails>]) {
129    if let Some(fuzzer) = &mut executor.inspector_mut().fuzzer
130        && let Some(call_generator) = &mut fuzzer.call_generator
131    {
132        call_generator.last_sequence = Arc::new(RwLock::new(inner_sequence.to_owned()));
133        call_generator.set_replay(true);
134    }
135}
foundry_evm/executors/invariant/replay.rs

foundry_evm/executors/invariant/
replay.rs
