feat(evm): collect logs from execution result (#8231)

Author: DaniPopes

crates/config/src/providers/remappings.rs

@@ -151,7 +151,7 @@ impl<'a> RemappingsProvider<'a> {
         let mut all_remappings = Remappings::new_with_remappings(user_remappings);
 
         // scan all library dirs and autodetect remappings
-        // todo: if a lib specifies contexts for remappings manually, we need to figure out how to
+        // TODO: if a lib specifies contexts for remappings manually, we need to figure out how to
         // resolve that
         if self.auto_detect_remappings {
             let mut lib_remappings = BTreeMap::new();

crates/evm/core/src/fork/init.rs

@@ -10,7 +10,6 @@ use revm::primitives::{BlockEnv, CfgEnv, Env, TxEnv};
 
 /// Initializes a REVM block environment based on a forked
 /// ethereum provider.
-// todo(onbjerg): these bounds needed cus of the bounds in `Provider`, can simplify?
 pub async fn environment<N: Network, T: Transport + Clone, P: Provider<T, N>>(
     provider: &P,
     memory_limit: u64,

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

@@ -236,7 +236,7 @@ impl<'a> InvariantExecutor<'a> {
                     }
                 } else {
                     // Collect data for fuzzing from the state changeset.
-                    let mut state_changeset = call_result.state_changeset.clone().unwrap();
+                    let mut state_changeset = call_result.state_changeset.clone();
 
                     if !call_result.reverted {
                         collect_data(

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

@@ -274,11 +274,10 @@ impl Executor {
         // and also the chainid, which can be set manually
         self.env.cfg.chain_id = res.env.cfg.chain_id;
 
-        if let Some(changeset) = &res.state_changeset {
-            let success = self.is_raw_call_success(to, Cow::Borrowed(changeset), &res, false);
-            if !success {
-                return Err(res.into_execution_error("execution error".to_string()).into());
-            }
+        let success =
+            self.is_raw_call_success(to, Cow::Borrowed(&res.state_changeset), &res, false);
+        if !success {
+            return Err(res.into_execution_error("execution error".to_string()).into());
         }
 
         Ok(res)
@@ -380,9 +379,7 @@ impl Executor {
     /// This should not be exposed to the user, as it should be called only by `transact*`.
     fn commit(&mut self, result: &mut RawCallResult) {
         // Persist changes to db.
-        if let Some(changes) = &result.state_changeset {
-            self.backend.commit(changes.clone());
-        }
+        self.backend.commit(result.state_changeset.clone());
 
         // Persist cheatcode state.
         self.inspector.cheatcodes = result.cheatcodes.take();
@@ -411,7 +408,7 @@ impl Executor {
     ) -> bool {
         self.is_raw_call_success(
             address,
-            Cow::Owned(call_result.state_changeset.take().unwrap_or_default()),
+            Cow::Owned(std::mem::take(&mut call_result.state_changeset)),
             call_result,
             should_fail,
         )
@@ -667,7 +664,7 @@ pub struct RawCallResult {
     /// Scripted transactions generated from this call
     pub transactions: Option<BroadcastableTransactions>,
     /// The changeset of the state.
-    pub state_changeset: Option<StateChangeset>,
+    pub state_changeset: StateChangeset,
     /// The `revm::Env` after the call
     pub env: EnvWithHandlerCfg,
     /// The cheatcode states after execution
@@ -694,7 +691,7 @@ impl Default for RawCallResult {
             coverage: None,
             debug: None,
             transactions: None,
-            state_changeset: None,
+            state_changeset: HashMap::default(),
             env: EnvWithHandlerCfg::new_with_spec_id(Box::default(), SpecId::LATEST),
             cheatcodes: Default::default(),
             out: None,
@@ -778,19 +775,20 @@ impl std::ops::DerefMut for CallResult {
 fn convert_executed_result(
     env: EnvWithHandlerCfg,
     inspector: InspectorStack,
-    result: ResultAndState,
+    ResultAndState { result, state: state_changeset }: ResultAndState,
     has_snapshot_failure: bool,
 ) -> eyre::Result<RawCallResult> {
-    let ResultAndState { result: exec_result, state: state_changeset } = result;
-    let (exit_reason, gas_refunded, gas_used, out) = match exec_result {
-        ExecutionResult::Success { reason, gas_used, gas_refunded, output, .. } => {
-            (reason.into(), gas_refunded, gas_used, Some(output))
+    let (exit_reason, gas_refunded, gas_used, out, exec_logs) = match result {
+        ExecutionResult::Success { reason, gas_used, gas_refunded, output, logs, .. } => {
+            (reason.into(), gas_refunded, gas_used, Some(output), logs)
         }
         ExecutionResult::Revert { gas_used, output } => {
             // Need to fetch the unused gas
-            (InstructionResult::Revert, 0_u64, gas_used, Some(Output::Call(output)))
+            (InstructionResult::Revert, 0_u64, gas_used, Some(Output::Call(output)), vec![])
+        }
+        ExecutionResult::Halt { reason, gas_used } => {
+            (reason.into(), 0_u64, gas_used, None, vec![])
         }
-        ExecutionResult::Halt { reason, gas_used } => (reason.into(), 0_u64, gas_used, None),
     };
     let stipend = revm::interpreter::gas::validate_initial_tx_gas(
         env.spec_id(),
@@ -804,15 +802,17 @@ fn convert_executed_result(
         _ => Bytes::new(),
     };
 
-    let InspectorData { logs, labels, traces, coverage, debug, cheatcodes, chisel_state } =
+    let InspectorData { mut logs, labels, traces, coverage, debug, cheatcodes, chisel_state } =
         inspector.collect();
 
-    let transactions = match cheatcodes.as_ref() {
-        Some(cheats) if !cheats.broadcastable_transactions.is_empty() => {
-            Some(cheats.broadcastable_transactions.clone())
-        }
-        _ => None,
-    };
+    if logs.is_empty() {
+        logs = exec_logs;
+    }
+
+    let transactions = cheatcodes
+        .as_ref()
+        .map(|c| c.broadcastable_transactions.clone())
+        .filter(|txs| !txs.is_empty());
 
     Ok(RawCallResult {
         exit_reason,
@@ -828,7 +828,7 @@ fn convert_executed_result(
         coverage,
         debug,
         transactions,
-        state_changeset: Some(state_changeset),
+        state_changeset,
         env,
         cheatcodes,
         out,

crates/evm/evm/src/inspectors/logs.rs

@@ -42,7 +42,6 @@ impl<DB: Database> Inspector<DB> for LogCollector {
         self.logs.push(log.clone());
     }
 
-    #[inline]
     fn call(
         &mut self,
         _context: &mut EvmContext<DB>,