@nomicfoundation/edr 0.12.0-next.6 → 0.12.0-next.8

package/src/result.rs

@@ -19,17 +19,17 @@ pub enum SuccessReason {
     SelfDestruct,
 }
 
-impl From<edr_eth::result::SuccessReason> for SuccessReason {
-    fn from(eval: edr_eth::result::SuccessReason) -> Self {
+impl From<edr_evm::result::SuccessReason> for SuccessReason {
+    fn from(eval: edr_evm::result::SuccessReason) -> Self {
         match eval {
-            edr_eth::result::SuccessReason::Stop => Self::Stop,
-            edr_eth::result::SuccessReason::Return => Self::Return,
-            edr_eth::result::SuccessReason::SelfDestruct => Self::SelfDestruct,
+            edr_evm::result::SuccessReason::Stop => Self::Stop,
+            edr_evm::result::SuccessReason::Return => Self::Return,
+            edr_evm::result::SuccessReason::SelfDestruct => Self::SelfDestruct,
         }
     }
 }
 
-impl From<SuccessReason> for edr_eth::result::SuccessReason {
+impl From<SuccessReason> for edr_evm::result::SuccessReason {
     fn from(value: SuccessReason) -> Self {
         match value {
             SuccessReason::Stop => Self::Stop,
@@ -157,7 +157,7 @@ impl From<&AfterMessage<EvmHaltReason>> for ExecutionResult {
         } = value;
 
         let result = match execution_result {
-            edr_eth::result::ExecutionResult::Success {
+            edr_evm::result::ExecutionResult::Success {
                 reason,
                 gas_used,
                 gas_refunded,
@@ -172,12 +172,12 @@ impl From<&AfterMessage<EvmHaltReason>> for ExecutionResult {
                     gas_refunded: BigInt::from(*gas_refunded),
                     logs,
                     output: match output {
-                        edr_eth::result::Output::Call(return_value) => {
+                        edr_evm::result::Output::Call(return_value) => {
                             let return_value = Uint8Array::with_data_copied(return_value);
 
                             Either::A(CallOutput { return_value })
                         }
-                        edr_eth::result::Output::Create(return_value, address) => {
+                        edr_evm::result::Output::Create(return_value, address) => {
                             let return_value = Uint8Array::with_data_copied(return_value);
 
                             Either::B(CreateOutput {
@@ -188,7 +188,7 @@ impl From<&AfterMessage<EvmHaltReason>> for ExecutionResult {
                     },
                 })
             }
-            edr_eth::result::ExecutionResult::Revert { gas_used, output } => {
+            edr_evm::result::ExecutionResult::Revert { gas_used, output } => {
                 let output = Uint8Array::with_data_copied(output);
 
                 Either3::B(RevertResult {
@@ -196,7 +196,7 @@ impl From<&AfterMessage<EvmHaltReason>> for ExecutionResult {
                     output,
                 })
             }
-            edr_eth::result::ExecutionResult::Halt { reason, gas_used } => Either3::C(HaltResult {
+            edr_evm::result::ExecutionResult::Halt { reason, gas_used } => Either3::C(HaltResult {
                 reason: ExceptionalHalt::from(*reason),
                 gas_used: BigInt::from(*gas_used),
             }),

package/src/serde.rs

@@ -1,4 +1,4 @@
-use edr_eth::hex;
+use edr_primitives::hex;
 use napi::bindgen_prelude::{BigInt, Uint8Array};
 use serde::Serializer;
 

package/src/solidity_tests/config.rs

@@ -1,7 +1,7 @@
 use std::{collections::HashMap, path::PathBuf};
 
 use derive_more::Debug;
-use edr_eth::hex;
+use edr_primitives::hex;
 use edr_solidity_tests::{
     executors::invariant::InvariantConfig,
     fuzz::FuzzConfig,
@@ -109,7 +109,7 @@ pub struct SolidityTestRunnerConfigArgs {
     /// Defaults to false.
     pub disable_block_gas_limit: Option<bool>,
     /// The memory limit of the EVM in bytes.
-    /// Defaults to 33_554_432 (2^25 = 32MiB).
+    /// Defaults to `33_554_432` (2^25 = 32MiB).
     #[serde(serialize_with = "serialize_optional_bigint_as_struct")]
     pub memory_limit: Option<BigInt>,
     /// The predeploys applied in local mode. Defaults to no predeploys.
@@ -143,6 +143,8 @@ pub struct SolidityTestRunnerConfigArgs {
     /// If an invariant config setting is not set, but a corresponding fuzz
     /// config value is set, then the fuzz config value will be used.
     pub invariant: Option<InvariantConfigArgs>,
+    /// Whether to collect stack traces.
+    pub collect_stack_traces: Option<CollectStackTraces>,
     /// Controls which test results should include execution traces. Defaults to
     /// None.
     pub include_traces: Option<IncludeTraces>,
@@ -153,6 +155,11 @@ pub struct SolidityTestRunnerConfigArgs {
     /// A regex pattern to filter tests. If provided, only test methods that
     /// match the pattern will be executed and reported as a test result.
     pub test_pattern: Option<String>,
+    /// Controls whether to generate a gas report after running the tests.
+    /// Enabling this also enables collection of all traces and EVM isolation
+    /// mode.
+    /// Defaults to false.
+    pub generate_gas_report: Option<bool>,
 }
 
 impl SolidityTestRunnerConfigArgs {
@@ -194,9 +201,11 @@ impl SolidityTestRunnerConfigArgs {
             prompt_timeout,
             fuzz,
             invariant,
+            collect_stack_traces,
             include_traces,
             observability,
             test_pattern,
+            generate_gas_report,
         } = self;
 
         let test_pattern = TestFilterConfig {
@@ -296,8 +305,13 @@ impl SolidityTestRunnerConfigArgs {
             cheatcode,
             fuzz,
             invariant,
+            collect_stack_traces: collect_stack_traces.map_or(
+                edr_solidity_tests::CollectStackTraces::OnFailure,
+                edr_solidity_tests::CollectStackTraces::from,
+            ),
             on_collected_coverage_fn,
             test_pattern,
+            generate_gas_report,
         };
 
         Ok(config)
@@ -721,6 +735,29 @@ pub struct AddressLabel {
     pub label: String,
 }
 
+/// A type that controls when stack traces are collected.
+#[napi]
+#[derive(Debug, serde::Serialize)]
+pub enum CollectStackTraces {
+    /// Always collects stack traces, adding performance overhead.
+    Always,
+    /// Only collects stack traces upon failure, re-executing the test. This
+    /// minimizes performance overhead.
+    ///
+    /// Not all tests can be re-executed since certain cheatcodes contain
+    /// non-deterministic side-effects.
+    OnFailure,
+}
+
+impl From<CollectStackTraces> for edr_solidity_tests::CollectStackTraces {
+    fn from(value: CollectStackTraces) -> Self {
+        match value {
+            CollectStackTraces::Always => edr_solidity_tests::CollectStackTraces::Always,
+            CollectStackTraces::OnFailure => edr_solidity_tests::CollectStackTraces::OnFailure,
+        }
+    }
+}
+
 /// Configuration for [`SolidityTestRunnerConfigArgs::include_traces`] that
 /// controls execution trace decoding and inclusion in test results.
 #[napi]

package/src/solidity_tests/l1.rs

@@ -1,10 +1,10 @@
 use std::{collections::BTreeMap, sync::Arc};
 
-use edr_eth::Bytes;
 use edr_napi_core::solidity::{
     config::{TestRunnerConfig, TracingConfigWithBuffers},
     SyncTestRunner, SyncTestRunnerFactory,
 };
+use edr_primitives::Bytes;
 use edr_solidity::artifacts::ArtifactId;
 use edr_solidity_tests::{
     contracts::ContractsByArtifact, decode::RevertDecoder, evm_context::L1EvmBuilder,

package/src/solidity_tests/op.rs

@@ -1,11 +1,11 @@
 use std::{collections::BTreeMap, sync::Arc};
 
-use edr_eth::Bytes;
 use edr_napi_core::solidity::{
     config::{TestRunnerConfig, TracingConfigWithBuffers},
     SyncTestRunner, SyncTestRunnerFactory,
 };
 use edr_op::solidity_tests::OpEvmBuilder;
+use edr_primitives::Bytes;
 use edr_solidity::artifacts::ArtifactId;
 use edr_solidity_tests::{
     contracts::ContractsByArtifact, decode::RevertDecoder, multi_runner::TestContract,

package/src/solidity_tests/test_results.rs

@@ -18,6 +18,7 @@ use napi_derive::napi;
 
 use crate::{
     cast::TryCast,
+    gas_report::GasReport,
     solidity_tests::{artifact::ArtifactId, config::IncludeTraces},
     trace::{solidity_stack_trace::SolidityStackTraceEntry, u256_to_bigint},
 };
@@ -42,7 +43,7 @@ pub struct ValueSnapshotEntry {
     pub value: String,
 }
 
-/// See [edr_solidity_tests::result::SuiteResult]
+/// See [`edr_solidity_tests::result::SuiteResult`]
 #[napi]
 #[derive(Clone, Debug)]
 pub struct SuiteResult {
@@ -50,13 +51,13 @@ pub struct SuiteResult {
     /// callback
     #[napi(readonly)]
     pub id: ArtifactId,
-    /// See [edr_solidity_tests::result::SuiteResult::duration]
+    /// See [`edr_solidity_tests::result::SuiteResult::duration`]
     #[napi(readonly)]
     pub duration_ns: BigInt,
-    /// See [edr_solidity_tests::result::SuiteResult::test_results]
+    /// See [`edr_solidity_tests::result::SuiteResult::test_results`]
     #[napi(readonly)]
     pub test_results: Vec<TestResult>,
-    /// See [edr_solidity_tests::result::SuiteResult::warnings]
+    /// See [`edr_solidity_tests::result::SuiteResult::warnings`]
     #[napi(readonly)]
     pub warnings: Vec<String>,
 }
@@ -80,29 +81,29 @@ impl SuiteResult {
     }
 }
 
-/// See [edr_solidity_tests::result::TestResult]
+/// See [`edr_solidity_tests::result::TestResult`]
 #[napi]
 #[derive(Clone, Debug)]
 pub struct TestResult {
     /// The name of the test.
     #[napi(readonly)]
     pub name: String,
-    /// See [edr_solidity_tests::result::TestResult::status]
+    /// See [`edr_solidity_tests::result::TestResult::status`]
     #[napi(readonly)]
     pub status: TestStatus,
-    /// See [edr_solidity_tests::result::TestResult::reason]
+    /// See [`edr_solidity_tests::result::TestResult::reason`]
     #[napi(readonly)]
     pub reason: Option<String>,
-    /// See [edr_solidity_tests::result::TestResult::counterexample]
+    /// See [`edr_solidity_tests::result::TestResult::counterexample`]
     #[napi(readonly)]
     pub counterexample: Option<Either<BaseCounterExample, CounterExampleSequence>>,
-    /// See [edr_solidity_tests::result::TestResult::decoded_logs]
+    /// See [`edr_solidity_tests::result::TestResult::decoded_logs`]
     #[napi(readonly)]
     pub decoded_logs: Vec<String>,
-    /// See [edr_solidity_tests::result::TestResult::kind]
+    /// See [`edr_solidity_tests::result::TestResult::kind`]
     #[napi(readonly)]
     pub kind: Either3<StandardTestKind, FuzzTestKind, InvariantTestKind>,
-    /// See [edr_solidity_tests::result::TestResult::duration]
+    /// See [`edr_solidity_tests::result::TestResult::duration`]
     #[napi(readonly)]
     pub duration_ns: BigInt,
     /// Groups of value snapshot entries (incl. gas).
@@ -335,7 +336,7 @@ impl From<edr_solidity_tests::result::TestStatus> for TestStatus {
     }
 }
 
-/// See [edr_solidity_tests::result::TestKind::Standard]
+/// See [`edr_solidity_tests::result::TestKind::Standard`]
 #[napi(object)]
 #[derive(Debug, Clone)]
 pub struct StandardTestKind {
@@ -344,22 +345,22 @@ pub struct StandardTestKind {
     pub consumed_gas: BigInt,
 }
 
-/// See [edr_solidity_tests::result::TestKind::Fuzz]
+/// See [`edr_solidity_tests::result::TestKind::Fuzz`]
 #[napi(object)]
 #[derive(Debug, Clone)]
 pub struct FuzzTestKind {
-    /// See [edr_solidity_tests::result::TestKind::Fuzz]
+    /// See [`edr_solidity_tests::result::TestKind::Fuzz`]
     #[napi(readonly)]
     pub runs: BigInt,
-    /// See [edr_solidity_tests::result::TestKind::Fuzz]
+    /// See [`edr_solidity_tests::result::TestKind::Fuzz`]
     #[napi(readonly)]
     pub mean_gas: BigInt,
-    /// See [edr_solidity_tests::result::TestKind::Fuzz]
+    /// See [`edr_solidity_tests::result::TestKind::Fuzz`]
     #[napi(readonly)]
     pub median_gas: BigInt,
 }
 
-/// See [edr_solidity_tests::fuzz::FuzzCase]
+/// See [`edr_solidity_tests::fuzz::FuzzCase`]
 #[napi(object)]
 #[derive(Clone)]
 pub struct FuzzCase {
@@ -383,17 +384,17 @@ impl Debug for FuzzCase {
     }
 }
 
-/// See [edr_solidity_tests::result::TestKind::Invariant]
+/// See [`edr_solidity_tests::result::TestKind::Invariant`]
 #[napi(object)]
 #[derive(Debug, Clone)]
 pub struct InvariantTestKind {
-    /// See [edr_solidity_tests::result::TestKind::Invariant]
+    /// See [`edr_solidity_tests::result::TestKind::Invariant`]
     #[napi(readonly)]
     pub runs: BigInt,
-    /// See [edr_solidity_tests::result::TestKind::Invariant]
+    /// See [`edr_solidity_tests::result::TestKind::Invariant`]
     #[napi(readonly)]
     pub calls: BigInt,
-    /// See [edr_solidity_tests::result::TestKind::Invariant]
+    /// See [`edr_solidity_tests::result::TestKind::Invariant`]
     #[napi(readonly)]
     pub reverts: BigInt,
 }
@@ -409,26 +410,26 @@ pub struct CounterExampleSequence {
     pub sequence: Vec<BaseCounterExample>,
 }
 
-/// See [edr_solidity_tests::fuzz::BaseCounterExample]
+/// See [`edr_solidity_tests::fuzz::BaseCounterExample`]
 #[napi(object)]
 #[derive(Clone)]
 pub struct BaseCounterExample {
-    /// See [edr_solidity_tests::fuzz::BaseCounterExample::sender]
+    /// See [`edr_solidity_tests::fuzz::BaseCounterExample::sender`]
     #[napi(readonly)]
     pub sender: Option<Uint8Array>,
-    /// See [edr_solidity_tests::fuzz::BaseCounterExample::addr]
+    /// See [`edr_solidity_tests::fuzz::BaseCounterExample::addr`]
     #[napi(readonly)]
     pub address: Option<Uint8Array>,
-    /// See [edr_solidity_tests::fuzz::BaseCounterExample::calldata]
+    /// See [`edr_solidity_tests::fuzz::BaseCounterExample::calldata`]
     #[napi(readonly)]
     pub calldata: Uint8Array,
-    /// See [edr_solidity_tests::fuzz::BaseCounterExample::contract_name]
+    /// See [`edr_solidity_tests::fuzz::BaseCounterExample::contract_name`]
     #[napi(readonly)]
     pub contract_name: Option<String>,
-    /// See [edr_solidity_tests::fuzz::BaseCounterExample::signature]
+    /// See [`edr_solidity_tests::fuzz::BaseCounterExample::signature`]
     #[napi(readonly)]
     pub signature: Option<String>,
-    /// See [edr_solidity_tests::fuzz::BaseCounterExample::args]
+    /// See [`edr_solidity_tests::fuzz::BaseCounterExample::args`]
     #[napi(readonly)]
     pub args: Option<String>,
 }
@@ -604,7 +605,10 @@ impl CallTrace {
         loop {
             // We will break out of the loop before the stack goes empty.
             let mut item = stack.pop().unwrap();
-            let node = &arena.nodes()[item.arena_index];
+            let node = arena
+                .nodes()
+                .get(item.arena_index)
+                .expect("Arena index should be valid");
 
             if item.visited {
                 let mut logs = node
@@ -618,11 +622,20 @@ impl CallTrace {
                     .iter()
                     .filter_map(|ord| match *ord {
                         traces::TraceMemberOrder::Log(i) => {
-                            let log = logs[i].take().unwrap();
+                            let log = logs
+                                .get_mut(i)
+                                .expect("Log index should be valid")
+                                .take()
+                                .unwrap();
                             Some(Either::B(log))
                         }
                         traces::TraceMemberOrder::Call(i) => {
-                            let child_trace = item.child_traces[i].take().unwrap();
+                            let child_trace = item
+                                .child_traces
+                                .get_mut(i)
+                                .expect("Child trace index should be valid")
+                                .take()
+                                .unwrap();
                             Some(Either::A(child_trace))
                         }
                         traces::TraceMemberOrder::Step(_) => None,
@@ -632,7 +645,9 @@ impl CallTrace {
                 let trace = CallTrace::new(node, children);
 
                 if let Some(parent_stack_index) = item.parent_stack_index {
-                    let parent = &mut stack[parent_stack_index];
+                    let parent = stack
+                        .get_mut(parent_stack_index)
+                        .expect("Parent stack index should be valid");
                     parent.child_traces.push(Some(trace));
                 } else {
                     return trace;
@@ -703,3 +718,19 @@ impl From<traces::CallKind> for CallKind {
         }
     }
 }
+
+/// The result of a Solidity test run.
+#[napi(object)]
+pub struct SolidityTestResult {
+    /// Gas report, if it was generated.
+    #[napi(readonly)]
+    pub gas_report: Option<GasReport>,
+}
+
+impl From<edr_solidity_tests::multi_runner::SolidityTestResult> for SolidityTestResult {
+    fn from(value: edr_solidity_tests::multi_runner::SolidityTestResult) -> Self {
+        Self {
+            gas_report: value.gas_report.map(GasReport::from),
+        }
+    }
+}

package/src/solidity_tests.rs

@@ -9,7 +9,7 @@ pub mod test_results;
 
 use std::path::Path;
 
-use edr_eth::Bytes;
+use edr_primitives::Bytes;
 use edr_solidity::linker::{LinkOutput, Linker};
 use edr_solidity_tests::{constants::LIBRARY_DEPLOYER, contracts::ContractsByArtifact};
 use foundry_compilers::artifacts::Libraries;

package/src/trace/debug.rs

@@ -46,7 +46,9 @@ fn print_stack_trace(trace: SolidityStackTrace) -> napi::Result<()> {
                 })?;
 
                 let mut value = serde_json::to_value(entry)?;
-                value["message"] = decoded_error_msg.into();
+                if let Some(obj) = value.as_object_mut() {
+                    obj.insert("message".to_string(), decoded_error_msg.into());
+                }
                 Ok(value)
             }
         })

package/src/trace/return_data.rs

@@ -22,11 +22,9 @@ pub struct ReturnData {
 impl ReturnData {
     #[napi(catch_unwind, constructor)]
     pub fn new(value: Uint8Array) -> Self {
-        let selector = if value.len() >= 4 {
-            Some(value[0..4].try_into().unwrap())
-        } else {
-            None
-        };
+        let selector = value
+            .get(0..4)
+            .map(|selector| selector.try_into().expect("selector is 4 bytes"));
 
         Self { value, selector }
     }

package/src/trace/solidity_stack_trace.rs

@@ -3,7 +3,7 @@
 
 use std::convert::Infallible;
 
-use edr_eth::{hex, U256};
+use edr_primitives::{hex, U256};
 use napi::bindgen_prelude::{BigInt, Either25, FromNapiValue, ToNapiValue, Uint8Array, Undefined};
 use napi_derive::napi;
 use serde::{Serialize, Serializer};
@@ -848,7 +848,8 @@ const _: () = {
     assert_to_from_napi_value::<SolidityStackTraceEntry>();
 };
 
-/// Serializes a [`BigInt`] that represents an EVM value as a [`edr_eth::U256`].
+/// Serializes a [`BigInt`] that represents an EVM value as a
+/// [`edr_primitives::U256`].
 fn serialize_evm_value_bigint_using_u256<S>(bigint: &BigInt, s: S) -> Result<S::Ok, S::Error>
 where
     S: Serializer,

package/src/trace.rs

@@ -7,9 +7,9 @@
 
 use std::sync::Arc;
 
-use edr_eth::bytecode::opcode::OpCode;
 use edr_evm::trace::BeforeMessage;
 use edr_evm_spec::EvmHaltReason;
+use edr_primitives::bytecode::opcode::OpCode;
 use napi::bindgen_prelude::{BigInt, Either3, Uint8Array};
 use napi_derive::napi;
 
@@ -145,7 +145,7 @@ impl TracingStep {
     }
 }
 
-pub(crate) fn u256_to_bigint(v: &edr_eth::U256) -> BigInt {
+pub(crate) fn u256_to_bigint(v: &edr_primitives::U256) -> BigInt {
     BigInt {
         sign_bit: false,
         words: v.into_limbs().to_vec(),

package/src/withdrawal.rs

@@ -1,4 +1,4 @@
-use edr_eth::Address;
+use edr_primitives::Address;
 use napi::bindgen_prelude::{BigInt, Uint8Array};
 use napi_derive::napi;
 
@@ -16,21 +16,21 @@ pub struct Withdrawal {
     pub amount: BigInt,
 }
 
-impl From<edr_eth::withdrawal::Withdrawal> for Withdrawal {
-    fn from(withdrawal: edr_eth::withdrawal::Withdrawal) -> Self {
+impl From<edr_block_header::Withdrawal> for Withdrawal {
+    fn from(withdrawal: edr_block_header::Withdrawal) -> Self {
         Self {
             index: BigInt::from(withdrawal.index),
             validator_index: BigInt::from(withdrawal.validator_index),
             address: Uint8Array::with_data_copied(withdrawal.address),
             amount: BigInt {
                 sign_bit: false,
-                words: withdrawal.amount.as_limbs().to_vec(),
+                words: vec![withdrawal.amount],
             },
         }
     }
 }
 
-impl TryFrom<Withdrawal> for edr_eth::withdrawal::Withdrawal {
+impl TryFrom<Withdrawal> for edr_block_header::Withdrawal {
     type Error = napi::Error;
 
     fn try_from(value: Withdrawal) -> Result<Self, Self::Error> {