Merge branch 'master' into klkvr/internal-fns-in-traces

Author: klkvr

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

@@ -1,8 +1,9 @@
 use alloy_primitives::{hex, Address};
 use alloy_signer::{k256::ecdsa::SigningKey, utils::secret_key_to_address};
 use alloy_signer_local::PrivateKeySigner;
-use clap::{builder::TypedValueParser, Parser};
+use clap::Parser;
 use eyre::Result;
+use itertools::Either;
 use rayon::iter::{self, ParallelIterator};
 use regex::Regex;
 use serde::{Deserialize, Serialize};
@@ -19,16 +20,11 @@ pub type GeneratedWallet = (SigningKey, Address);
 #[derive(Clone, Debug, Parser)]
 pub struct VanityArgs {
     /// Prefix regex pattern or hex string.
-    #[arg(
-        long,
-        required_unless_present = "ends_with",
-        value_parser = HexAddressValidator,
-        value_name = "HEX"
-    )]
+    #[arg(long, value_name = "PATTERN", required_unless_present = "ends_with")]
     pub starts_with: Option<String>,
 
     /// Suffix regex pattern or hex string.
-    #[arg(long, value_parser = HexAddressValidator, value_name = "HEX")]
+    #[arg(long, value_name = "PATTERN")]
     pub ends_with: Option<String>,
 
     // 2^64-1 is max possible nonce per [eip-2681](https://eips.ethereum.org/EIPS/eip-2681).
@@ -74,24 +70,22 @@ impl WalletData {
 impl VanityArgs {
     pub fn run(self) -> Result<PrivateKeySigner> {
         let Self { starts_with, ends_with, nonce, save_path } = self;
+
         let mut left_exact_hex = None;
         let mut left_regex = None;
-        let mut right_exact_hex = None;
-        let mut right_regex = None;
-
         if let Some(prefix) = starts_with {
-            if let Ok(decoded) = hex::decode(&prefix) {
-                left_exact_hex = Some(decoded)
-            } else {
-                left_regex = Some(Regex::new(&format!(r"^{prefix}"))?);
+            match parse_pattern(&prefix, true)? {
+                Either::Left(left) => left_exact_hex = Some(left),
+                Either::Right(re) => left_regex = Some(re),
             }
         }
 
+        let mut right_exact_hex = None;
+        let mut right_regex = None;
         if let Some(suffix) = ends_with {
-            if let Ok(decoded) = hex::decode(&suffix) {
-                right_exact_hex = Some(decoded)
-            } else {
-                right_regex = Some(Regex::new(&format!(r"{suffix}$"))?);
+            match parse_pattern(&suffix, false)? {
+                Either::Left(right) => right_exact_hex = Some(right),
+                Either::Right(re) => right_regex = Some(re),
             }
         }
 
@@ -331,29 +325,15 @@ impl VanityMatcher for RegexMatcher {
     }
 }
 
-/// Parse 40 byte addresses
-#[derive(Clone, Copy, Debug, Default)]
-pub struct HexAddressValidator;
-
-impl TypedValueParser for HexAddressValidator {
-    type Value = String;
-
-    fn parse_ref(
-        &self,
-        _cmd: &clap::Command,
-        _arg: Option<&clap::Arg>,
-        value: &std::ffi::OsStr,
-    ) -> Result<Self::Value, clap::Error> {
-        if value.len() > 40 {
-            return Err(clap::Error::raw(
-                clap::error::ErrorKind::InvalidValue,
-                "vanity patterns length exceeded. cannot be more than 40 characters",
-            ))
+fn parse_pattern(pattern: &str, is_start: bool) -> Result<Either<Vec<u8>, Regex>> {
+    if let Ok(decoded) = hex::decode(pattern) {
+        if decoded.len() > 20 {
+            return Err(eyre::eyre!("Hex pattern must be less than 20 bytes"));
         }
-        let value = value.to_str().ok_or_else(|| {
-            clap::Error::raw(clap::error::ErrorKind::InvalidUtf8, "address must be valid utf8")
-        })?;
-        Ok(value.to_string())
+        Ok(Either::Left(decoded))
+    } else {
+        let (prefix, suffix) = if is_start { ("^", "") } else { ("", "$") };
+        Ok(Either::Right(Regex::new(&format!("{prefix}{pattern}{suffix}"))?))
     }
 }
 

crates/cast/bin/cmd/wallet/vanity.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

@@ -452,7 +452,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

@@ -407,7 +407,11 @@ impl InspectorStack {
     /// Set whether to enable the tracer.
     #[inline]
     pub fn tracing(&mut self, mode: TraceMode) {
-        self.tracer = mode.into_config().map(TracingInspector::new);
+        if let Some(config) = mode.into_config() {
+            *self.tracer.get_or_insert_with(Default::default).config_mut() = config;
+        } else {
+            self.tracer = None;
+        }
     }
 
     /// Collects all the data gathered during inspection into a single struct.
@@ -424,13 +428,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

@@ -281,7 +281,7 @@ fn try_decode_args_from_step(args: &Parameters<'_>, step: &CallTraceStep) -> Opt
                         (DynSolType::Uint(8), Some(Storage::Memory | Storage::Storage)) => None,
                         (_, Some(Storage::Memory)) => decode_from_memory(
                             type_,
-                            step.memory.as_bytes(),
+                            step.memory.as_ref().unwrap().as_bytes(),
                             input.try_into().ok()?,
                         ),
                         // Read other types from stack

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

@@ -589,7 +589,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

@@ -108,18 +108,23 @@ pub async fn render_trace_arena(
                 let child = &node.ordering[ordering_idx];
                 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)| {
-                            writeln!(s, "{}{}", if i == 0 { left } else { right }, line)
+                            writeln!(
+                                s,
+                                "{}{}",
+                                if i == 0 { left } else { right },
+                                line
+                            )
                         })?;
                     }
                     TraceMemberOrder::Call(index) => {
                         inner(
                             arena,
                             decoder,
-                            identified_internals,
+                            &identified_internals,
                             s,
                             node.children[*index],
                             left,

crates/evm/traces/src/lib.rs

@@ -307,18 +307,19 @@ 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 {
+
+        let prev_tracer = self.executor.inspector_mut().tracer.take();
+        if prev_tracer.is_some() || has_invariants {
             self.executor.set_tracing(TraceMode::Call);
         }
+
         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(TraceMode::None);
-        }
+
+        self.executor.inspector_mut().tracer = prev_tracer;
 
         if setup.reason.is_some() {
             // The setup failed, so we return a single test result for `setUp`

crates/forge/src/runner.rs

@@ -2,7 +2,7 @@ No files changed, compilation skipped
 
 Ran 2 tests for test/Counter.t.sol:CounterTest
 [PASS] testFuzz_SetNumber(uint256) (runs: 256, μ: 26521, ~: 28387)
-[PASS] test_Increment() (gas: 31325)
+[PASS] test_Increment() (gas: 31303)
 Suite result: ok. 2 passed; 0 failed; 0 skipped; finished in 9.42ms
 
 Ran 1 test suite: 2 tests passed, 0 failed, 0 skipped (2 total tests)

crates/forge/tests/fixtures/can_test_repeatedly.stdout

@@ -3,14 +3,14 @@ Solc 0.8.23 finished in 798.51ms
 Compiler run successful!
 
 Ran 2 tests for test/Contract.t.sol:CustomTypesTest
-[FAIL. Reason: PoolNotInitialized()] testErr() (gas: 231)
+[FAIL. Reason: PoolNotInitialized()] testErr() (gas: 254)
 Traces:
-  [231] CustomTypesTest::testErr()
+  [254] CustomTypesTest::testErr()
     └─ ← [Revert] PoolNotInitialized()
 
-[PASS] testEvent() (gas: 1312)
+[PASS] testEvent() (gas: 1268)
 Traces:
-  [1312] CustomTypesTest::testEvent()
+  [1268] CustomTypesTest::testEvent()
     ├─ emit MyEvent(a: 100)
     └─ ← [Stop] 
 
@@ -20,6 +20,6 @@ Ran 1 test suite: 1 tests passed, 1 failed, 0 skipped (2 total tests)
 
 Failing tests:
 Encountered 1 failing test in test/Contract.t.sol:CustomTypesTest
-[FAIL. Reason: PoolNotInitialized()] testErr() (gas: 231)
+[FAIL. Reason: PoolNotInitialized()] testErr() (gas: 254)
 
 Encountered a total of 1 failing tests, 1 tests succeeded

crates/forge/tests/fixtures/include_custom_types_in_traces.stdout

@@ -3,9 +3,9 @@ Compiling 1 files with 0.8.23
 Compiler run successful!
 
 Ran 1 test for test/Contract.t.sol:USDTCallingTest
-[PASS] test() (gas: 9559)
+[PASS] test() (gas: 9537)
 Traces:
-  [9559] USDTCallingTest::test()
+  [9537] USDTCallingTest::test()
     ├─ [0] VM::createSelectFork("<url>")
     │   └─ ← [Return] 0
     ├─ [3110] 0xdAC17F958D2ee523a2206206994597C13D831ec7::name() [staticcall]