@nomicfoundation/edr 0.12.0-next.0 → 0.12.0-next.10

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)
@@ -657,24 +671,55 @@ impl From<PathPermission> for foundry_cheatcodes::PathPermission {
     }
 }
 
-/// Determines the status of file system access
+/**
+ * Determines the level of file system access for the given path.
+ *
+ * Exact path matching is used for file permissions. Prefix matching is used
+ * for directory permissions.
+ *
+ * Giving write access to configuration files, source files or executables
+ * in a project is considered dangerous, because it can be used by malicious
+ * Solidity dependencies to escape the EVM sandbox. It is therefore
+ * recommended to give write access to specific safe files only. If write
+ * access to a directory is needed, please make sure that it doesn't contain
+ * configuration files, source files or executables neither in the top level
+ * directory, nor in any subdirectories.
+ */
 #[napi]
 #[derive(Debug, serde::Serialize)]
 pub enum FsAccessPermission {
-    /// FS access is allowed with `read` + `write` permission
-    ReadWrite,
-    /// Only reading is allowed
-    Read,
-    /// Only writing is allowed
-    Write,
+    /// Allows reading and writing the file
+    ReadWriteFile,
+    /// Only allows reading the file
+    ReadFile,
+    /// Only allows writing the file
+    WriteFile,
+    /// Allows reading and writing all files in the directory and its
+    /// subdirectories
+    DangerouslyReadWriteDirectory,
+    /// Allows reading all files in the directory and its subdirectories
+    ReadDirectory,
+    /// Allows writing all files in the directory and its subdirectories
+    DangerouslyWriteDirectory,
 }
 
 impl From<FsAccessPermission> for foundry_cheatcodes::FsAccessPermission {
     fn from(value: FsAccessPermission) -> Self {
         match value {
-            FsAccessPermission::ReadWrite => foundry_cheatcodes::FsAccessPermission::ReadWrite,
-            FsAccessPermission::Read => foundry_cheatcodes::FsAccessPermission::Read,
-            FsAccessPermission::Write => foundry_cheatcodes::FsAccessPermission::Write,
+            FsAccessPermission::ReadWriteFile => {
+                foundry_cheatcodes::FsAccessPermission::ReadWriteFile
+            }
+            FsAccessPermission::ReadFile => foundry_cheatcodes::FsAccessPermission::ReadFile,
+            FsAccessPermission::WriteFile => foundry_cheatcodes::FsAccessPermission::WriteFile,
+            FsAccessPermission::DangerouslyReadWriteDirectory => {
+                foundry_cheatcodes::FsAccessPermission::DangerouslyReadWriteDirectory
+            }
+            FsAccessPermission::ReadDirectory => {
+                foundry_cheatcodes::FsAccessPermission::ReadDirectory
+            }
+            FsAccessPermission::DangerouslyWriteDirectory => {
+                foundry_cheatcodes::FsAccessPermission::DangerouslyWriteDirectory
+            }
         }
     }
 }
@@ -690,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,14 +1,14 @@
 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,
-    multi_runner::TestContract, revm::context::TxEnv, MultiContractRunner,
+    multi_runner::TestContract, MultiContractRunner,
 };
 use napi::tokio;
 use napi_derive::napi;
@@ -33,14 +33,14 @@ impl SyncTestRunnerFactory for L1TestRunnerFactory {
         let runner = tokio::task::block_in_place(|| {
             runtime
                 .block_on(MultiContractRunner::<
-                    edr_eth::l1::BlockEnv,
+                    edr_chain_l1::BlockEnv,
                     (),
                     L1EvmBuilder,
-                    edr_eth::l1::HaltReason,
-                    edr_eth::l1::SpecId,
+                    edr_chain_l1::HaltReason,
+                    edr_chain_l1::Hardfork,
                     _,
-                    edr_eth::l1::InvalidTransaction,
-                    TxEnv,
+                    edr_chain_l1::InvalidTransaction,
+                    edr_chain_l1::TxEnv,
                 >::new(
                     config.try_into()?,
                     contracts,

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,
@@ -34,14 +34,14 @@ impl SyncTestRunnerFactory for OpTestRunnerFactory {
         let runner = tokio::task::block_in_place(|| {
             runtime
                 .block_on(MultiContractRunner::<
-                    edr_eth::l1::BlockEnv,
+                    edr_op::BlockEnv,
                     _,
                     OpEvmBuilder,
-                    edr_op::OpHaltReason,
-                    edr_op::OpSpecId,
+                    edr_op::HaltReason,
+                    edr_op::Hardfork,
                     _,
                     edr_op::transaction::InvalidTransaction,
-                    edr_op::transaction::OpTxEnv<edr_eth::l1::TxEnv>,
+                    edr_op::transaction::OpTxEnv<edr_chain_l1::TxEnv>,
                 >::new(
                     config.try_into()?,
                     contracts,

package/src/solidity_tests/runner.rs

@@ -1,6 +1,6 @@
 use std::sync::{Mutex, OnceLock};
 
-use edr_eth::spec::HaltReasonTrait;
+use edr_evm_spec::HaltReasonTrait;
 use edr_napi_core::solidity::config::TracingConfigWithBuffers;
 use edr_solidity::{
     artifacts::BuildInfoConfigWithBuffers,

package/src/solidity_tests/test_results.rs

@@ -18,11 +18,32 @@ 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},
 };
 
-/// See [edr_solidity_tests::result::SuiteResult]
+/// A grouping of value snapshot entries for a test.
+#[napi(object)]
+#[derive(Clone, Debug)]
+pub struct ValueSnapshotGroup {
+    /// The group name.
+    pub name: String,
+    /// The entries in the group.
+    pub entries: Vec<ValueSnapshotEntry>,
+}
+
+/// An entry in a value snapshot group.
+#[napi(object)]
+#[derive(Clone, Debug)]
+pub struct ValueSnapshotEntry {
+    /// The name of the entry.
+    pub name: String,
+    /// The value of the entry.
+    pub value: String,
+}
+
+/// See [`edr_solidity_tests::result::SuiteResult`]
 #[napi]
 #[derive(Clone, Debug)]
 pub struct SuiteResult {
@@ -30,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>,
 }
@@ -60,31 +81,37 @@ 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).
+    ///
+    /// Only present if the test runner collected scoped snapshots. Currently,
+    /// this is always the case.
+    #[napi(readonly)]
+    pub value_snapshot_groups: Option<Vec<ValueSnapshotGroup>>,
 
     stack_trace_result: Option<Arc<StackTraceResult<String>>>,
     call_trace_arenas: Vec<(traces::TraceKind, SparsedTraceArena)>,
@@ -264,6 +291,19 @@ impl TestResult {
                 }),
             },
             duration_ns: BigInt::from(test_result.duration.as_nanos()),
+            value_snapshot_groups: Some(
+                test_result
+                    .value_snapshots
+                    .into_iter()
+                    .map(|(group_name, entries)| ValueSnapshotGroup {
+                        name: group_name,
+                        entries: entries
+                            .into_iter()
+                            .map(|(name, value)| ValueSnapshotEntry { name, value })
+                            .collect(),
+                    })
+                    .collect(),
+            ),
             stack_trace_result: test_result.stack_trace_result.map(Arc::new),
             call_trace_arenas: if include_trace {
                 test_result.traces
@@ -296,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 {
@@ -305,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 {
@@ -344,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,
 }
@@ -370,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>,
 }
@@ -431,9 +471,10 @@ pub struct CallTrace {
     pub gas_used: BigInt,
     /// The amount of native token that was included with the call.
     pub value: BigInt,
-    /// The target of the call. Provided as a contract name if known, otherwise
-    /// a checksum address.
-    pub contract: String,
+    /// The target address of the call.
+    pub address: String,
+    /// The name of the contract that is the target of the call, if known.
+    pub contract: Option<String>,
     /// The input (calldata) to the call. If it encodes a known function call,
     /// it will be decoded into the function name and a list of arguments.
     /// For example, `{ name: "ownerOf", arguments: ["1"] }`. Note that the
@@ -502,12 +543,8 @@ impl CallTrace {
     /// Instantiates a `CallTrace` with the details from a node and the supplied
     /// children.
     fn new(node: &traces::CallTraceNode, children: Vec<Either<CallTrace, LogTrace>>) -> Self {
-        let contract = node
-            .trace
-            .decoded
-            .label
-            .clone()
-            .unwrap_or(node.trace.address.to_checksum(None));
+        let contract = node.trace.decoded.label.clone();
+        let address = node.trace.address.to_checksum(None);
 
         let inputs = match &node.trace.decoded.call_data {
             Some(traces::DecodedCallData { signature, args }) => {
@@ -540,6 +577,7 @@ impl CallTrace {
             gas_used: node.trace.gas_used.into(),
             value: u256_to_bigint(&node.trace.value),
             contract,
+            address,
             inputs,
             outputs,
             children,
@@ -567,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
@@ -581,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,
@@ -595,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;
@@ -666,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

@@ -1,6 +1,6 @@
 //! Port of `hardhat-network/stack-traces/debug.ts` from Hardhat.
 
-use napi::bindgen_prelude::Either24;
+use napi::bindgen_prelude::Either25;
 use napi_derive::napi;
 
 use super::solidity_stack_trace::{RevertErrorStackTraceEntry, SolidityStackTrace};
@@ -11,31 +11,32 @@ fn print_stack_trace(trace: SolidityStackTrace) -> napi::Result<()> {
     let entry_values = trace
         .into_iter()
         .map(|entry| match entry {
-            Either24::A(entry) => serde_json::to_value(entry),
-            Either24::B(entry) => serde_json::to_value(entry),
-            Either24::C(entry) => serde_json::to_value(entry),
-            Either24::D(entry) => serde_json::to_value(entry),
-            Either24::F(entry) => serde_json::to_value(entry),
-            Either24::G(entry) => serde_json::to_value(entry),
-            Either24::H(entry) => serde_json::to_value(entry),
-            Either24::I(entry) => serde_json::to_value(entry),
-            Either24::J(entry) => serde_json::to_value(entry),
-            Either24::K(entry) => serde_json::to_value(entry),
-            Either24::L(entry) => serde_json::to_value(entry),
-            Either24::M(entry) => serde_json::to_value(entry),
-            Either24::N(entry) => serde_json::to_value(entry),
-            Either24::O(entry) => serde_json::to_value(entry),
-            Either24::P(entry) => serde_json::to_value(entry),
-            Either24::Q(entry) => serde_json::to_value(entry),
-            Either24::R(entry) => serde_json::to_value(entry),
-            Either24::S(entry) => serde_json::to_value(entry),
-            Either24::T(entry) => serde_json::to_value(entry),
-            Either24::U(entry) => serde_json::to_value(entry),
-            Either24::V(entry) => serde_json::to_value(entry),
-            Either24::W(entry) => serde_json::to_value(entry),
-            Either24::X(entry) => serde_json::to_value(entry),
+            Either25::A(entry) => serde_json::to_value(entry),
+            Either25::B(entry) => serde_json::to_value(entry),
+            Either25::C(entry) => serde_json::to_value(entry),
+            Either25::D(entry) => serde_json::to_value(entry),
+            Either25::F(entry) => serde_json::to_value(entry),
+            Either25::G(entry) => serde_json::to_value(entry),
+            Either25::H(entry) => serde_json::to_value(entry),
+            Either25::I(entry) => serde_json::to_value(entry),
+            Either25::J(entry) => serde_json::to_value(entry),
+            Either25::K(entry) => serde_json::to_value(entry),
+            Either25::L(entry) => serde_json::to_value(entry),
+            Either25::M(entry) => serde_json::to_value(entry),
+            Either25::N(entry) => serde_json::to_value(entry),
+            Either25::O(entry) => serde_json::to_value(entry),
+            Either25::P(entry) => serde_json::to_value(entry),
+            Either25::Q(entry) => serde_json::to_value(entry),
+            Either25::R(entry) => serde_json::to_value(entry),
+            Either25::S(entry) => serde_json::to_value(entry),
+            Either25::T(entry) => serde_json::to_value(entry),
+            Either25::U(entry) => serde_json::to_value(entry),
+            Either25::V(entry) => serde_json::to_value(entry),
+            Either25::W(entry) => serde_json::to_value(entry),
+            Either25::X(entry) => serde_json::to_value(entry),
+            Either25::Y(entry) => serde_json::to_value(entry),
             // Decode the error message from the return data
-            Either24::E(entry @ RevertErrorStackTraceEntry { .. }) => {
+            Either25::E(entry @ RevertErrorStackTraceEntry { .. }) => {
                 use serde::de::Error;
 
                 let decoded_error_msg = ReturnData::new(entry.return_data.clone())
@@ -45,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/exit.rs

@@ -3,6 +3,7 @@
 
 use std::fmt;
 
+use edr_evm_spec::EvmHaltReason;
 use napi_derive::napi;
 
 #[napi]
@@ -50,20 +51,20 @@ impl fmt::Display for ExitCode {
 }
 
 #[allow(clippy::fallible_impl_from)] // naively ported for now
-impl From<edr_solidity::exit_code::ExitCode<edr_eth::l1::HaltReason>> for ExitCode {
-    fn from(code: edr_solidity::exit_code::ExitCode<edr_eth::l1::HaltReason>) -> Self {
+impl From<edr_solidity::exit_code::ExitCode<EvmHaltReason>> for ExitCode {
+    fn from(code: edr_solidity::exit_code::ExitCode<EvmHaltReason>) -> Self {
         use edr_solidity::exit_code::ExitCode;
 
         match code {
             ExitCode::Success => Self::SUCCESS,
             ExitCode::Revert => Self::REVERT,
-            ExitCode::Halt(edr_eth::l1::HaltReason::OutOfGas(_)) => Self::OUT_OF_GAS,
-            ExitCode::Halt(edr_eth::l1::HaltReason::OpcodeNotFound | edr_eth::l1::HaltReason::InvalidFEOpcode
+            ExitCode::Halt(EvmHaltReason::OutOfGas(_)) => Self::OUT_OF_GAS,
+            ExitCode::Halt(EvmHaltReason::OpcodeNotFound | EvmHaltReason::InvalidFEOpcode
               // Returned when an opcode is not implemented for the hardfork
-              | edr_eth::l1::HaltReason::NotActivated) => Self::INVALID_OPCODE,
-            ExitCode::Halt(edr_eth::l1::HaltReason::StackUnderflow) => Self::STACK_UNDERFLOW,
-            ExitCode::Halt(edr_eth::l1::HaltReason::CreateContractSizeLimit) => Self::CODESIZE_EXCEEDS_MAXIMUM,
-            ExitCode::Halt(edr_eth::l1::HaltReason::CreateCollision) => Self::CREATE_COLLISION,
+              | EvmHaltReason::NotActivated) => Self::INVALID_OPCODE,
+            ExitCode::Halt(EvmHaltReason::StackUnderflow) => Self::STACK_UNDERFLOW,
+            ExitCode::Halt(EvmHaltReason::CreateContractSizeLimit) => Self::CODESIZE_EXCEEDS_MAXIMUM,
+            ExitCode::Halt(EvmHaltReason::CreateCollision) => Self::CREATE_COLLISION,
             _ => Self::UNKNOWN_HALT_REASON,
         }
     }