chore(deps): bump revm-inspectors (#8300)

* chore(deps): bump revm-inspectors

* fix

* fix2

* inline

* fix3

Author: DaniPopes

Cargo.lock

@@ -155,7 +155,7 @@ solang-parser = "=0.3.3"
 # no default features to avoid c-kzg
 revm = { version = "10.0.0", default-features = false }
 revm-primitives = { version = "5.0.0", default-features = false }
-revm-inspectors = { version = "0.2", features = ["serde"] }
+revm-inspectors = { version = "0.3", features = ["serde"] }
 
 ## ethers
 ethers-contract-abigen = { version = "2.0.14", default-features = false }

Cargo.toml

@@ -306,11 +306,13 @@ impl OtsInternalOperation {
                 };
                 let mut from = node.trace.caller;
                 let mut to = node.trace.address;
+                let mut value = node.trace.value;
                 if node.is_selfdestruct() {
                     from = node.trace.address;
                     to = node.trace.selfdestruct_refund_target.unwrap_or_default();
+                    value = node.trace.selfdestruct_transferred_value.unwrap_or_default();
                 }
-                Some(Self { r#type, from, to, value: node.trace.value })
+                Some(Self { r#type, from, to, value })
             })
             .collect()
     }

crates/anvil/src/eth/otterscan/types.rs

@@ -129,7 +129,7 @@ impl<'a> DebuggerContext<'a> {
 
     fn active_buffer(&self) -> &[u8] {
         match self.active_buffer {
-            BufferKind::Memory => self.current_step().memory.as_bytes(),
+            BufferKind::Memory => self.current_step().memory.as_ref().unwrap().as_bytes(),
             BufferKind::Calldata => &self.debug_call().calldata,
             BufferKind::Returndata => &self.current_step().returndata,
         }

crates/debugger/src/tui/context.rs

@@ -502,7 +502,7 @@ impl DebuggerContext<'_> {
         let call = self.debug_call();
         let step = self.current_step();
         let buf = match self.active_buffer {
-            BufferKind::Memory => step.memory.as_ref(),
+            BufferKind::Memory => step.memory.as_ref().unwrap().as_ref(),
             BufferKind::Calldata => call.calldata.as_ref(),
             BufferKind::Returndata => step.returndata.as_ref(),
         };

crates/debugger/src/tui/draw.rs

@@ -415,22 +415,24 @@ impl InspectorStack {
     /// Set whether to enable the tracer.
     #[inline]
     pub fn tracing(&mut self, yes: bool, debug: bool) {
-        self.tracer = yes.then(|| {
-            TracingInspector::new(TracingInspectorConfig {
-                record_steps: debug,
-                record_memory_snapshots: debug,
-                record_stack_snapshots: if debug {
-                    StackSnapshotType::Full
-                } else {
-                    StackSnapshotType::None
-                },
-                record_state_diff: false,
-                exclude_precompile_calls: false,
-                record_logs: true,
-                record_opcodes_filter: None,
-                record_returndata_snapshots: debug,
-            })
-        });
+        if !yes {
+            self.tracer = None;
+            return;
+        }
+        *self.tracer.get_or_insert_with(Default::default).config_mut() = TracingInspectorConfig {
+            record_steps: debug,
+            record_memory_snapshots: debug,
+            record_stack_snapshots: if debug {
+                StackSnapshotType::Full
+            } else {
+                StackSnapshotType::None
+            },
+            record_state_diff: false,
+            exclude_precompile_calls: false,
+            record_logs: true,
+            record_opcodes_filter: None,
+            record_returndata_snapshots: debug,
+        };
     }
 
     /// Collects all the data gathered during inspection into a single struct.
@@ -447,13 +449,14 @@ impl InspectorStack {
                 .as_ref()
                 .map(|cheatcodes| cheatcodes.labels.clone())
                 .unwrap_or_default(),
-            traces: tracer.map(|tracer| tracer.get_traces().clone()),
+            traces: tracer.map(|tracer| tracer.into_traces()),
             coverage: coverage.map(|coverage| coverage.maps),
             cheatcodes,
             chisel_state: chisel_state.and_then(|state| state.state),
         }
     }
 
+    #[inline(always)]
     fn as_mut(&mut self) -> InspectorStackRefMut<'_> {
         InspectorStackRefMut { cheatcodes: self.cheatcodes.as_mut(), inner: &mut self.inner }
     }

crates/evm/evm/src/inspectors/stack.rs

@@ -575,7 +575,7 @@ impl CallTraceDecoder {
 
         let events_it = nodes
             .iter()
-            .flat_map(|node| node.logs.iter().filter_map(|log| log.topics().first()))
+            .flat_map(|node| node.logs.iter().filter_map(|log| log.raw_log.topics().first()))
             .unique();
         identifier.write().await.identify_events(events_it).await;
 

crates/evm/traces/src/decoder/mod.rs

@@ -95,7 +95,7 @@ pub async fn render_trace_arena(
             for child in &node.ordering {
                 match child {
                     TraceMemberOrder::Log(index) => {
-                        let log = render_trace_log(&node.logs[*index], decoder).await?;
+                        let log = render_trace_log(&node.logs[*index].raw_log, decoder).await?;
 
                         // Prepend our tree structure symbols to each line of the displayed log
                         log.lines().enumerate().try_for_each(|(i, line)| {

crates/evm/traces/src/lib.rs

@@ -307,18 +307,16 @@ impl<'a> ContractRunner<'a> {
         });
 
         // Invariant testing requires tracing to figure out what contracts were created.
+        // We also want to disable `debug` for setup since we won't be using those traces.
         let has_invariants = self.contract.abi.functions().any(|func| func.is_invariant_test());
-        let tmp_tracing =
-            self.executor.inspector().tracer.is_none() && has_invariants && call_setup;
-        if tmp_tracing {
-            self.executor.set_tracing(true, false);
-        }
+        let prev_tracer = self.executor.inspector_mut().tracer.take();
+        self.executor.set_tracing(prev_tracer.is_some() || has_invariants, false);
+
         let setup_time = Instant::now();
         let setup = self.setup(call_setup);
         debug!("finished setting up in {:?}", setup_time.elapsed());
-        if tmp_tracing {
-            self.executor.set_tracing(false, false);
-        }
+
+        self.executor.inspector_mut().tracer = prev_tracer;
 
         if setup.reason.is_some() {
             // The setup failed, so we return a single test result for `setUp`