chore(evm): clean up executor methods some more (#8104)

* chore(evm): clean up executor methods some more

* fix: rename _committing to transact_, further clarify the separation

* chore: simplify is_success further

* chore: don't clone executor in unit tests

crates/cast/bin/cmd/call.rs

@@ -170,7 +170,7 @@ impl CallArgs {
                     TraceResult::try_from(deploy_result)?
                 }
                 TxKind::Call(to) => TraceResult::from_raw(
-                    executor.call_raw_committing(sender, to, input, value)?,
+                    executor.transact_raw(sender, to, input, value)?,
                     TraceKind::Execution,
                 ),
             };

crates/cast/bin/cmd/run.rs

@@ -176,7 +176,7 @@ impl RunArgs {
 
                     if let Some(to) = tx.to {
                         trace!(tx=?tx.hash,?to, "executing previous call transaction");
-                        executor.commit_tx_with_env(env.clone()).wrap_err_with(|| {
+                        executor.transact_with_env(env.clone()).wrap_err_with(|| {
                             format!(
                                 "Failed to execute transaction: {:?} in block {}",
                                 tx.hash, env.block.number
@@ -213,7 +213,7 @@ impl RunArgs {
 
             if let Some(to) = tx.to {
                 trace!(tx=?tx.hash, to=?to, "executing call transaction");
-                TraceResult::from_raw(executor.commit_tx_with_env(env)?, TraceKind::Execution)
+                TraceResult::from_raw(executor.transact_with_env(env)?, TraceKind::Execution)
             } else {
                 trace!(tx=?tx.hash, "executing create transaction");
                 TraceResult::try_from(executor.deploy_with_env(env, None))?

crates/chisel/src/runner.rs

@@ -189,7 +189,7 @@ impl ChiselRunner {
 
         if commit {
             // if explicitly requested we can now commit the call
-            res = self.executor.call_raw_committing(from, to, calldata, value)?;
+            res = self.executor.transact_raw(from, to, calldata, value)?;
         }
 
         let RawCallResult { result, reverted, logs, traces, labels, chisel_state, .. } = res;

crates/evm/evm/src/executors/fuzz/mod.rs

@@ -16,7 +16,7 @@ use foundry_evm_fuzz::{
 use foundry_evm_traces::CallTraceArena;
 use indicatif::ProgressBar;
 use proptest::test_runner::{TestCaseError, TestError, TestRunner};
-use std::{borrow::Cow, cell::RefCell};
+use std::cell::RefCell;
 
 mod types;
 pub use types::{CaseOutcome, CounterExampleOutcome, FuzzOutcome};
@@ -202,7 +202,6 @@ impl FuzzedExecutor {
             .executor
             .call_raw(self.sender, address, calldata.clone(), U256::ZERO)
             .map_err(|_| TestCaseError::fail(FuzzError::FailedContractCall))?;
-        let state_changeset = call.state_changeset.take().unwrap();
 
         // When the `assume` cheatcode is called it returns a special string
         if call.result.as_ref() == MAGIC_ASSUME {
@@ -214,13 +213,7 @@ impl FuzzedExecutor {
             .as_ref()
             .map_or_else(Default::default, |cheats| cheats.breakpoints.clone());
 
-        let success = self.executor.is_raw_call_success(
-            address,
-            Cow::Owned(state_changeset),
-            &call,
-            should_fail,
-        );
-
+        let success = self.executor.is_raw_call_mut_success(address, &mut call, should_fail);
         if success {
             Ok(FuzzOutcome::Case(CaseOutcome {
                 case: FuzzCase { calldata, gas: call.gas_used, stipend: call.stipend },

crates/evm/evm/src/executors/invariant/mod.rs

@@ -155,7 +155,7 @@ impl<'a> InvariantExecutor<'a> {
         let failures = RefCell::new(InvariantFailures::new());
 
         // Stores the calldata in the last run.
-        let last_run_calldata: RefCell<Vec<BasicTxDetails>> = RefCell::new(vec![]);
+        let last_run_inputs: RefCell<Vec<BasicTxDetails>> = RefCell::new(vec![]);
 
         // Stores additional traces for gas report.
         let gas_report_traces: RefCell<Vec<Vec<CallTraceArena>>> = RefCell::default();
@@ -212,7 +212,7 @@ impl<'a> InvariantExecutor<'a> {
 
                 // Execute call from the randomly generated sequence and commit state changes.
                 let call_result = executor
-                    .call_raw_committing(
+                    .transact_raw(
                         tx.sender,
                         tx.call_details.target,
                         tx.call_details.calldata.clone(),
@@ -233,7 +233,7 @@ impl<'a> InvariantExecutor<'a> {
                     }
                 } else {
                     // Collect data for fuzzing from the state changeset.
-                    let mut state_changeset = call_result.state_changeset.to_owned().unwrap();
+                    let mut state_changeset = call_result.state_changeset.clone().unwrap();
 
                     if !call_result.reverted {
                         collect_data(
@@ -281,7 +281,7 @@ impl<'a> InvariantExecutor<'a> {
                     .map_err(|e| TestCaseError::fail(e.to_string()))?;
 
                     if !result.can_continue || current_run == self.config.depth - 1 {
-                        last_run_calldata.borrow_mut().clone_from(&inputs);
+                        last_run_inputs.borrow_mut().clone_from(&inputs);
                     }
 
                     if !result.can_continue {
@@ -335,7 +335,7 @@ impl<'a> InvariantExecutor<'a> {
             error,
             cases: fuzz_cases.into_inner(),
             reverts,
-            last_run_inputs: last_run_calldata.take(),
+            last_run_inputs: last_run_inputs.into_inner(),
             gas_report_traces: gas_report_traces.into_inner(),
         })
     }

crates/evm/evm/src/executors/invariant/replay.rs

@@ -37,7 +37,7 @@ pub fn replay_run(
 
     // Replay each call from the sequence, collect logs, traces and coverage.
     for tx in inputs.iter() {
-        let call_result = executor.call_raw_committing(
+        let call_result = executor.transact_raw(
             tx.sender,
             tx.call_details.target,
             tx.call_details.calldata.clone(),

crates/evm/evm/src/executors/invariant/result.rs

@@ -68,12 +68,8 @@ pub(crate) fn assert_invariants(
         U256::ZERO,
     )?;
 
-    let success = executor.is_raw_call_success(
-        invariant_contract.address,
-        Cow::Owned(call_result.state_changeset.take().unwrap()),
-        &call_result,
-        false,
-    );
+    let success =
+        executor.is_raw_call_mut_success(invariant_contract.address, &mut call_result, false);
     if !success {
         // We only care about invariants which we haven't broken yet.
         if invariant_failures.error.is_none() {
@@ -111,7 +107,7 @@ pub(crate) fn can_continue(
     let mut call_results = None;
 
     let handlers_succeeded = || {
-        targeted_contracts.targets.lock().iter().all(|(address, ..)| {
+        targeted_contracts.targets.lock().keys().all(|address| {
             executor.is_success(*address, false, Cow::Borrowed(state_changeset), false)
         })
     };

crates/evm/evm/src/executors/invariant/shrink.rs

@@ -4,7 +4,7 @@ use foundry_evm_core::constants::CALLER;
 use foundry_evm_fuzz::invariant::BasicTxDetails;
 use indicatif::ProgressBar;
 use proptest::bits::{BitSetLike, VarBitSet};
-use std::{borrow::Cow, cmp::min};
+use std::cmp::min;
 
 #[derive(Clone, Copy, Debug)]
 struct Shrink {
@@ -145,7 +145,7 @@ pub fn check_sequence(
     // Apply the call sequence.
     for call_index in sequence {
         let tx = &calls[call_index];
-        let call_result = executor.call_raw_committing(
+        let call_result = executor.transact_raw(
             tx.sender,
             tx.call_details.target,
             tx.call_details.calldata.clone(),
@@ -160,13 +160,6 @@ pub fn check_sequence(
 
     // Check the invariant for call sequence.
     let mut call_result = executor.call_raw(CALLER, test_address, calldata, U256::ZERO)?;
-    Ok((
-        executor.is_raw_call_success(
-            test_address,
-            Cow::Owned(call_result.state_changeset.take().unwrap()),
-            &call_result,
-            false,
-        ),
-        true,
-    ))
+    let success = executor.is_raw_call_mut_success(test_address, &mut call_result, false);
+    Ok((success, true))
 }