@nomicfoundation/edr 0.12.0-next.2 → 0.12.0-next.20

package/src/provider.rs

@@ -5,18 +5,18 @@ mod response;
 use std::sync::Arc;
 
 use edr_napi_core::provider::SyncProvider;
-use edr_solidity::contract_decoder::ContractDecoder;
+use edr_solidity::compiler::create_models_and_decode_bytecodes;
 use napi::{tokio::runtime, Env, JsFunction, JsObject, Status};
 use napi_derive::napi;
 
 pub use self::factory::ProviderFactory;
 use self::response::Response;
-use crate::call_override::CallOverrideCallback;
+use crate::{call_override::CallOverrideCallback, contract_decoder::ContractDecoder};
 
 /// A JSON-RPC provider for Ethereum.
 #[napi]
 pub struct Provider {
-    contract_decoder: Arc<ContractDecoder>,
+    contract_decoder: Arc<edr_solidity::contract_decoder::ContractDecoder>,
     provider: Arc<dyn SyncProvider>,
     runtime: runtime::Handle,
     #[cfg(feature = "scenarios")]
@@ -28,7 +28,7 @@ impl Provider {
     pub fn new(
         provider: Arc<dyn SyncProvider>,
         runtime: runtime::Handle,
-        contract_decoder: Arc<ContractDecoder>,
+        contract_decoder: Arc<edr_solidity::contract_decoder::ContractDecoder>,
         #[cfg(feature = "scenarios")] scenario_file: Option<
             napi::tokio::sync::Mutex<napi::tokio::fs::File>,
         >,
@@ -45,6 +45,53 @@ impl Provider {
 
 #[napi]
 impl Provider {
+    #[doc = "Adds a compilation result to the instance."]
+    #[doc = ""]
+    #[doc = "For internal use only. Support for this method may be removed in the future."]
+    #[napi(catch_unwind)]
+    pub async fn add_compilation_result(
+        &self,
+        solc_version: String,
+        compiler_input: serde_json::Value,
+        compiler_output: serde_json::Value,
+    ) -> napi::Result<()> {
+        let contract_decoder = self.contract_decoder.clone();
+
+        self.runtime
+            .spawn_blocking(move || {
+                let compiler_input = serde_json::from_value(compiler_input)
+                    .map_err(|error| napi::Error::from_reason(error.to_string()))?;
+
+                let compiler_output = serde_json::from_value(compiler_output)
+                    .map_err(|error| napi::Error::from_reason(error.to_string()))?;
+
+                let contracts = match create_models_and_decode_bytecodes(
+                    solc_version,
+                    &compiler_input,
+                    &compiler_output,
+                ) {
+                    Ok(contracts) => contracts,
+                    Err(error) => {
+                        return Err(napi::Error::from_reason(format!("Contract decoder failed to be updated. Please report this to help us improve Hardhat.\n{error}")));
+                    }
+                };
+
+                for contract in contracts {
+                    contract_decoder.add_contract_metadata(contract);
+                }
+
+                Ok(())
+            })
+            .await
+            .map_err(|error| napi::Error::new(Status::GenericFailure, error.to_string()))?
+    }
+
+    #[doc = "Retrieves the instance's contract decoder."]
+    #[napi(catch_unwind)]
+    pub fn contract_decoder(&self) -> ContractDecoder {
+        ContractDecoder::from(Arc::clone(&self.contract_decoder))
+    }
+
     #[doc = "Handles a JSON-RPC request and returns a JSON-RPC response."]
     #[napi(catch_unwind)]
     pub async fn handle_request(&self, request: String) -> napi::Result<Response> {

package/src/result.rs

@@ -1,4 +1,5 @@
-use edr_evm::trace::AfterMessage;
+use edr_chain_spec::EvmHaltReason;
+use edr_tracing::AfterMessage;
 use napi::{
     bindgen_prelude::{BigInt, Either3, Uint8Array},
     Either,
@@ -16,27 +17,24 @@ pub enum SuccessReason {
     Return,
     /// The opcode `SELFDESTRUCT` was called
     SelfDestruct,
-    EofReturnContract,
 }
 
-impl From<edr_eth::result::SuccessReason> for SuccessReason {
-    fn from(eval: edr_eth::result::SuccessReason) -> Self {
+impl From<edr_chain_spec_evm::result::SuccessReason> for SuccessReason {
+    fn from(eval: edr_chain_spec_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_eth::result::SuccessReason::EofReturnContract => Self::EofReturnContract,
+            edr_chain_spec_evm::result::SuccessReason::Stop => Self::Stop,
+            edr_chain_spec_evm::result::SuccessReason::Return => Self::Return,
+            edr_chain_spec_evm::result::SuccessReason::SelfDestruct => Self::SelfDestruct,
         }
     }
 }
 
-impl From<SuccessReason> for edr_eth::result::SuccessReason {
+impl From<SuccessReason> for edr_chain_spec_evm::result::SuccessReason {
     fn from(value: SuccessReason) -> Self {
         match value {
             SuccessReason::Stop => Self::Stop,
             SuccessReason::Return => Self::Return,
             SuccessReason::SelfDestruct => Self::SelfDestruct,
-            SuccessReason::EofReturnContract => Self::EofReturnContract,
         }
     }
 }
@@ -100,81 +98,40 @@ pub enum ExceptionalHalt {
     CreateContractStartingWithEF,
     /// EIP-3860: Limit and meter initcode. Initcode size limit exceeded.
     CreateInitCodeSizeLimit,
-    /// Aux data overflow, new aux data is larger tha u16 max size.
-    EofAuxDataOverflow,
-    /// Aud data is smaller then already present data size.
-    EofAuxDataTooSmall,
-    /// EOF Subroutine stack overflow
-    SubRoutineStackOverflow,
-    /// Check for target address validity is only done inside subcall.
-    InvalidEXTCALLTarget,
 }
 
-impl From<edr_eth::l1::HaltReason> for ExceptionalHalt {
-    fn from(halt: edr_eth::l1::HaltReason) -> Self {
+impl From<EvmHaltReason> for ExceptionalHalt {
+    fn from(halt: EvmHaltReason) -> Self {
         match halt {
-            edr_eth::l1::HaltReason::OutOfGas(..) => ExceptionalHalt::OutOfGas,
-            edr_eth::l1::HaltReason::OpcodeNotFound => ExceptionalHalt::OpcodeNotFound,
-            edr_eth::l1::HaltReason::InvalidFEOpcode => ExceptionalHalt::InvalidFEOpcode,
-            edr_eth::l1::HaltReason::InvalidJump => ExceptionalHalt::InvalidJump,
-            edr_eth::l1::HaltReason::NotActivated => ExceptionalHalt::NotActivated,
-            edr_eth::l1::HaltReason::StackUnderflow => ExceptionalHalt::StackUnderflow,
-            edr_eth::l1::HaltReason::StackOverflow => ExceptionalHalt::StackOverflow,
-            edr_eth::l1::HaltReason::OutOfOffset => ExceptionalHalt::OutOfOffset,
-            edr_eth::l1::HaltReason::CreateCollision => ExceptionalHalt::CreateCollision,
-            edr_eth::l1::HaltReason::PrecompileError => ExceptionalHalt::PrecompileError,
-            edr_eth::l1::HaltReason::NonceOverflow => ExceptionalHalt::NonceOverflow,
-            edr_eth::l1::HaltReason::CreateContractSizeLimit => {
-                ExceptionalHalt::CreateContractSizeLimit
+            EvmHaltReason::OutOfGas(..) => ExceptionalHalt::OutOfGas,
+            EvmHaltReason::OpcodeNotFound => ExceptionalHalt::OpcodeNotFound,
+            EvmHaltReason::InvalidFEOpcode => ExceptionalHalt::InvalidFEOpcode,
+            EvmHaltReason::InvalidJump => ExceptionalHalt::InvalidJump,
+            EvmHaltReason::NotActivated => ExceptionalHalt::NotActivated,
+            EvmHaltReason::StackUnderflow => ExceptionalHalt::StackUnderflow,
+            EvmHaltReason::StackOverflow => ExceptionalHalt::StackOverflow,
+            EvmHaltReason::OutOfOffset => ExceptionalHalt::OutOfOffset,
+            EvmHaltReason::CreateCollision => ExceptionalHalt::CreateCollision,
+            EvmHaltReason::PrecompileError | EvmHaltReason::PrecompileErrorWithContext(_) => {
+                ExceptionalHalt::PrecompileError
             }
-            edr_eth::l1::HaltReason::CreateContractStartingWithEF => {
+            EvmHaltReason::NonceOverflow => ExceptionalHalt::NonceOverflow,
+            EvmHaltReason::CreateContractSizeLimit => ExceptionalHalt::CreateContractSizeLimit,
+            EvmHaltReason::CreateContractStartingWithEF => {
                 ExceptionalHalt::CreateContractStartingWithEF
             }
-            edr_eth::l1::HaltReason::CreateInitCodeSizeLimit => {
-                ExceptionalHalt::CreateInitCodeSizeLimit
-            }
-            edr_eth::l1::HaltReason::EofAuxDataOverflow => ExceptionalHalt::EofAuxDataOverflow,
-            edr_eth::l1::HaltReason::EofAuxDataTooSmall => ExceptionalHalt::EofAuxDataTooSmall,
-            edr_eth::l1::HaltReason::SubRoutineStackOverflow => {
-                ExceptionalHalt::SubRoutineStackOverflow
-            }
-            edr_eth::l1::HaltReason::InvalidEXTCALLTarget => ExceptionalHalt::InvalidEXTCALLTarget,
-            edr_eth::l1::HaltReason::OverflowPayment
-            | edr_eth::l1::HaltReason::StateChangeDuringStaticCall
-            | edr_eth::l1::HaltReason::CallNotAllowedInsideStatic
-            | edr_eth::l1::HaltReason::OutOfFunds
-            | edr_eth::l1::HaltReason::CallTooDeep => {
+            EvmHaltReason::CreateInitCodeSizeLimit => ExceptionalHalt::CreateInitCodeSizeLimit,
+            EvmHaltReason::OverflowPayment
+            | EvmHaltReason::StateChangeDuringStaticCall
+            | EvmHaltReason::CallNotAllowedInsideStatic
+            | EvmHaltReason::OutOfFunds
+            | EvmHaltReason::CallTooDeep => {
                 unreachable!("Internal halts that can be only found inside Inspector: {halt:?}")
             }
         }
     }
 }
 
-impl From<ExceptionalHalt> for edr_eth::l1::HaltReason {
-    fn from(value: ExceptionalHalt) -> Self {
-        match value {
-            ExceptionalHalt::OutOfGas => Self::OutOfGas(edr_eth::l1::OutOfGasError::Basic),
-            ExceptionalHalt::OpcodeNotFound => Self::OpcodeNotFound,
-            ExceptionalHalt::InvalidFEOpcode => Self::InvalidFEOpcode,
-            ExceptionalHalt::InvalidJump => Self::InvalidJump,
-            ExceptionalHalt::NotActivated => Self::NotActivated,
-            ExceptionalHalt::StackUnderflow => Self::StackUnderflow,
-            ExceptionalHalt::StackOverflow => Self::StackOverflow,
-            ExceptionalHalt::OutOfOffset => Self::OutOfOffset,
-            ExceptionalHalt::CreateCollision => Self::CreateCollision,
-            ExceptionalHalt::PrecompileError => Self::PrecompileError,
-            ExceptionalHalt::NonceOverflow => Self::NonceOverflow,
-            ExceptionalHalt::CreateContractSizeLimit => Self::CreateContractSizeLimit,
-            ExceptionalHalt::CreateContractStartingWithEF => Self::CreateContractStartingWithEF,
-            ExceptionalHalt::CreateInitCodeSizeLimit => Self::CreateInitCodeSizeLimit,
-            ExceptionalHalt::EofAuxDataOverflow => Self::EofAuxDataOverflow,
-            ExceptionalHalt::EofAuxDataTooSmall => Self::EofAuxDataTooSmall,
-            ExceptionalHalt::SubRoutineStackOverflow => Self::SubRoutineStackOverflow,
-            ExceptionalHalt::InvalidEXTCALLTarget => Self::InvalidEXTCALLTarget,
-        }
-    }
-}
-
 /// The result when the EVM terminates due to an exceptional halt.
 #[napi(object)]
 pub struct HaltResult {
@@ -194,15 +151,15 @@ pub struct ExecutionResult {
     pub contract_address: Option<Uint8Array>,
 }
 
-impl From<&AfterMessage<edr_eth::l1::HaltReason>> for ExecutionResult {
-    fn from(value: &AfterMessage<edr_eth::l1::HaltReason>) -> Self {
+impl From<&AfterMessage<EvmHaltReason>> for ExecutionResult {
+    fn from(value: &AfterMessage<EvmHaltReason>) -> Self {
         let AfterMessage {
             execution_result,
             contract_address,
         } = value;
 
         let result = match execution_result {
-            edr_eth::result::ExecutionResult::Success {
+            edr_chain_spec_evm::result::ExecutionResult::Success {
                 reason,
                 gas_used,
                 gas_refunded,
@@ -217,12 +174,12 @@ impl From<&AfterMessage<edr_eth::l1::HaltReason>> for ExecutionResult {
                     gas_refunded: BigInt::from(*gas_refunded),
                     logs,
                     output: match output {
-                        edr_eth::result::Output::Call(return_value) => {
+                        edr_chain_spec_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_chain_spec_evm::result::Output::Create(return_value, address) => {
                             let return_value = Uint8Array::with_data_copied(return_value);
 
                             Either::B(CreateOutput {
@@ -233,7 +190,7 @@ impl From<&AfterMessage<edr_eth::l1::HaltReason>> for ExecutionResult {
                     },
                 })
             }
-            edr_eth::result::ExecutionResult::Revert { gas_used, output } => {
+            edr_chain_spec_evm::result::ExecutionResult::Revert { gas_used, output } => {
                 let output = Uint8Array::with_data_copied(output);
 
                 Either3::B(RevertResult {
@@ -241,10 +198,12 @@ impl From<&AfterMessage<edr_eth::l1::HaltReason>> for ExecutionResult {
                     output,
                 })
             }
-            edr_eth::result::ExecutionResult::Halt { reason, gas_used } => Either3::C(HaltResult {
-                reason: ExceptionalHalt::from(*reason),
-                gas_used: BigInt::from(*gas_used),
-            }),
+            edr_chain_spec_evm::result::ExecutionResult::Halt { reason, gas_used } => {
+                Either3::C(HaltResult {
+                    reason: ExceptionalHalt::from(reason.clone()),
+                    gas_used: BigInt::from(*gas_used),
+                })
+            }
         };
 
         let contract_address = contract_address.as_ref().map(Uint8Array::with_data_copied);

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,14 +1,14 @@
 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,
     inspectors::cheatcodes::{CheatsConfigOptions, ExecutionContextConfig},
     TestFilterConfig,
 };
-use foundry_cheatcodes::{FsPermissions, RpcEndpoint, RpcEndpoints};
+use foundry_cheatcodes::{FsPermissions, RpcEndpointUrl, RpcEndpoints};
 use napi::{
     bindgen_prelude::{BigInt, Uint8Array},
     tokio::runtime,
@@ -36,8 +36,6 @@ pub struct SolidityTestRunnerConfigArgs {
     pub project_root: String,
     /// Configures the permissions of cheat codes that access the file system.
     pub fs_permissions: Option<Vec<PathPermission>>,
-    /// Whether to support the `testFail` prefix. Defaults to false.
-    pub test_fail: Option<bool>,
     /// Address labels for traces. Defaults to none.
     pub labels: Option<Vec<AddressLabel>>,
     /// Whether to enable isolation of calls. In isolation mode all top-level
@@ -109,7 +107,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 +141,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 +153,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 {
@@ -166,7 +171,6 @@ impl SolidityTestRunnerConfigArgs {
         let SolidityTestRunnerConfigArgs {
             project_root,
             fs_permissions,
-            test_fail,
             labels,
             isolate,
             ffi,
@@ -194,9 +198,11 @@ impl SolidityTestRunnerConfigArgs {
             prompt_timeout,
             fuzz,
             invariant,
+            collect_stack_traces,
             include_traces,
             observability,
             test_pattern,
+            generate_gas_report,
         } = self;
 
         let test_pattern = TestFilterConfig {
@@ -237,7 +243,7 @@ impl SolidityTestRunnerConfigArgs {
                     RpcEndpoints::new(
                         endpoints
                             .into_iter()
-                            .map(|(chain, url)| (chain, RpcEndpoint::Url(url))),
+                            .map(|(chain, url)| (chain, RpcEndpointUrl::new(url))),
                     )
                 })
                 .unwrap_or_default(),
@@ -258,6 +264,7 @@ impl SolidityTestRunnerConfigArgs {
                 .into_iter()
                 .map(|AddressLabel { address, label }| Ok((address.try_cast()?, label)))
                 .collect::<Result<_, napi::Error>>()?,
+            seed: fuzz.seed,
             allow_internal_expect_revert: allow_internal_expect_revert.unwrap_or(false),
         };
 
@@ -273,7 +280,6 @@ impl SolidityTestRunnerConfigArgs {
         let config = edr_napi_core::solidity::config::TestRunnerConfig {
             project_root: project_root.into(),
             include_traces: include_traces.unwrap_or_default().into(),
-            test_fail: test_fail.unwrap_or_default(),
             isolate,
             ffi,
             sender: sender.map(TryCast::try_cast).transpose()?,
@@ -296,8 +302,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)
@@ -356,7 +367,7 @@ impl TryFrom<FuzzConfigArgs> for FuzzConfig {
         } = value;
 
         let failure_persist_dir = failure_persist_dir.map(PathBuf::from);
-        let failure_persist_file = failure_persist_file.unwrap_or("failures".to_string());
+        let failure_persist_file = failure_persist_file.unwrap_or_else(|| "failures".to_string());
         let seed = seed
             .map(|s| {
                 s.parse().map_err(|_err| {
@@ -447,6 +458,10 @@ pub struct InvariantConfigArgs {
     /// process is disabled if set to 0.
     /// Defaults to 5000.
     pub shrink_run_limit: Option<u32>,
+    /// The maximum number of rejects via `vm.assume` which can be encountered
+    /// during a single invariant run.
+    /// Defaults to 65536.
+    pub max_assume_rejects: Option<u32>,
 }
 
 impl InvariantConfigArgs {
@@ -500,6 +515,7 @@ impl From<InvariantConfigArgs> for InvariantConfig {
             include_storage,
             include_push_bytes,
             shrink_run_limit,
+            max_assume_rejects,
         } = value;
 
         let failure_persist_dir = failure_persist_dir.map(PathBuf::from);
@@ -543,6 +559,10 @@ impl From<InvariantConfigArgs> for InvariantConfig {
             invariant.shrink_run_limit = shrink_run_limit;
         }
 
+        if let Some(max_assume_rejects) = max_assume_rejects {
+            invariant.max_assume_rejects = max_assume_rejects;
+        }
+
         invariant
     }
 }
@@ -657,24 +677,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 +741,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,18 @@
 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,
+    contracts::ContractsByArtifact,
+    decode::RevertDecoder,
+    evm_context::L1EvmBuilder,
+    multi_runner::TestContract,
+    revm::context::{BlockEnv, TxEnv},
+    MultiContractRunner,
 };
 use napi::tokio;
 use napi_derive::napi;
@@ -33,13 +37,13 @@ impl SyncTestRunnerFactory for L1TestRunnerFactory {
         let runner = tokio::task::block_in_place(|| {
             runtime
                 .block_on(MultiContractRunner::<
-                    edr_eth::l1::BlockEnv,
+                    BlockEnv,
                     (),
                     L1EvmBuilder,
-                    edr_eth::l1::HaltReason,
-                    edr_eth::l1::SpecId,
+                    edr_chain_l1::HaltReason,
+                    edr_chain_l1::Hardfork,
                     _,
-                    edr_eth::l1::InvalidTransaction,
+                    edr_chain_l1::InvalidTransaction,
                     TxEnv,
                 >::new(
                     config.try_into()?,

package/src/solidity_tests/op.rs

@@ -1,14 +1,17 @@
 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_op::{solidity_tests::OpEvmBuilder, transaction::OpTxEnv};
+use edr_primitives::Bytes;
 use edr_solidity::artifacts::ArtifactId;
 use edr_solidity_tests::{
-    contracts::ContractsByArtifact, decode::RevertDecoder, multi_runner::TestContract,
+    contracts::ContractsByArtifact,
+    decode::RevertDecoder,
+    multi_runner::TestContract,
+    revm::context::{BlockEnv, TxEnv},
     MultiContractRunner,
 };
 use napi::tokio;
@@ -34,14 +37,14 @@ impl SyncTestRunnerFactory for OpTestRunnerFactory {
         let runner = tokio::task::block_in_place(|| {
             runtime
                 .block_on(MultiContractRunner::<
-                    edr_eth::l1::BlockEnv,
+                    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::InvalidTransaction,
+                    OpTxEnv<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_chain_spec::HaltReasonTrait;
 use edr_napi_core::solidity::config::TracingConfigWithBuffers;
 use edr_solidity::{
     artifacts::BuildInfoConfigWithBuffers,