@nomicfoundation/edr 0.12.0-next.5 → 0.12.0-next.7

package/src/config.rs

@@ -2,16 +2,13 @@ use core::fmt::{Debug, Display};
 use std::{
     num::NonZeroU64,
     path::PathBuf,
-    sync::Arc,
     time::{Duration, SystemTime},
 };
 
 use edr_coverage::reporter::SyncOnCollectedCoverageCallback;
-use edr_eth::{
-    signature::{secret_key_from_str, SecretKey},
-    Bytes, HashMap, HashSet,
-};
-use edr_solidity::contract_decoder::ContractDecoder;
+use edr_eip1559::{BaseFeeActivation, ConstantBaseFeeParams};
+use edr_eth::{Bytes, HashMap, HashSet};
+use edr_signer::{secret_key_from_str, SecretKey};
 use napi::{
     bindgen_prelude::{BigInt, Promise, Reference, Uint8Array},
     threadsafe_function::{
@@ -27,6 +24,49 @@ use crate::{
     precompile::Precompile, subscription::SubscriptionConfig,
 };
 
+/// Configuration for EIP-1559 parameters
+#[napi(object)]
+pub struct BaseFeeParamActivation {
+    pub activation: Either<BaseFeeActivationByBlockNumber, BaseFeeActivationByHardfork>,
+    pub max_change_denominator: BigInt,
+    pub elasticity_multiplier: BigInt,
+}
+
+#[napi(object)]
+pub struct BaseFeeActivationByBlockNumber {
+    /// The block number at which the `base_fee_params` is activated
+    pub block_number: BigInt,
+}
+#[napi(object)]
+pub struct BaseFeeActivationByHardfork {
+    /// The hardfork at which the `base_fee_params` is activated
+    pub hardfork: String,
+}
+
+impl TryFrom<BaseFeeParamActivation> for (BaseFeeActivation<String>, ConstantBaseFeeParams) {
+    type Error = napi::Error;
+
+    fn try_from(value: BaseFeeParamActivation) -> Result<Self, Self::Error> {
+        let base_fee_params = ConstantBaseFeeParams {
+            max_change_denominator: value.max_change_denominator.try_cast()?,
+            elasticity_multiplier: value.elasticity_multiplier.try_cast()?,
+        };
+
+        match value.activation {
+            Either::A(BaseFeeActivationByBlockNumber { block_number }) => {
+                let activation_block_number: u64 = block_number.try_cast()?;
+                Ok((
+                    BaseFeeActivation::BlockNumber(activation_block_number),
+                    base_fee_params,
+                ))
+            }
+            Either::B(BaseFeeActivationByHardfork { hardfork }) => {
+                Ok((BaseFeeActivation::Hardfork(hardfork), base_fee_params))
+            }
+        }
+    }
+}
+
 /// Specification of a chain with possible overrides.
 #[napi(object)]
 pub struct ChainOverride {
@@ -142,6 +182,15 @@ pub struct ProviderConfig {
     pub bail_on_call_failure: bool,
     /// Whether to return an `Err` when a `eth_sendTransaction` fails
     pub bail_on_transaction_failure: bool,
+    /// EIP-1559 base fee parameters activations to be used to calculate the
+    /// block base fee.
+    ///
+    /// Provide an ordered list of `base_fee_params` to be
+    /// used starting from the specified activation point (hardfork or block
+    /// number).
+    /// If not provided, the default values from the chain spec
+    /// will be used.
+    pub base_fee_config: Option<Vec<BaseFeeParamActivation>>,
     /// The gas limit of each block
     pub block_gas_limit: BigInt,
     /// The chain ID of the blockchain
@@ -423,7 +472,7 @@ impl ProviderConfig {
                 // This is the only place in production code where it's allowed to use
                 // `DangerousSecretKeyStr`.
                 #[allow(deprecated)]
-                use edr_eth::signature::DangerousSecretKeyStr;
+                use edr_signer::DangerousSecretKeyStr;
 
                 static_assertions::assert_not_impl_all!(JsString: Debug, Display, serde::Serialize);
                 static_assertions::assert_not_impl_all!(JsStringUtf8: Debug, Display, serde::Serialize);
@@ -443,6 +492,11 @@ impl ProviderConfig {
             })
             .collect::<napi::Result<Vec<_>>>()?;
 
+        let base_fee_params: Option<Vec<(BaseFeeActivation<String>, ConstantBaseFeeParams)>> = self
+            .base_fee_config
+            .map(|vec| vec.into_iter().map(TryInto::try_into).collect())
+            .transpose()?;
+
         let block_gas_limit =
             NonZeroU64::new(self.block_gas_limit.try_cast()?).ok_or_else(|| {
                 napi::Error::new(
@@ -468,6 +522,7 @@ impl ProviderConfig {
             allow_unlimited_contract_size: self.allow_unlimited_contract_size,
             bail_on_call_failure: self.bail_on_call_failure,
             bail_on_transaction_failure: self.bail_on_transaction_failure,
+            base_fee_params,
             block_gas_limit,
             chain_id: self.chain_id.try_cast()?,
             coinbase: self.coinbase.try_cast()?,
@@ -549,7 +604,6 @@ impl From<BuildInfoAndOutput> for edr_napi_core::solidity::config::BuildInfoAndO
 
 /// Result of [`resolve_configs`].
 pub struct ConfigResolution {
-    pub contract_decoder: Arc<ContractDecoder>,
     pub logger_config: edr_napi_core::logger::Config,
     pub provider_config: edr_napi_core::provider::Config,
     pub subscription_callback: edr_napi_core::subscription::Callback,
@@ -562,28 +616,15 @@ pub fn resolve_configs(
     provider_config: ProviderConfig,
     logger_config: LoggerConfig,
     subscription_config: SubscriptionConfig,
-    tracing_config: TracingConfigWithBuffers,
 ) -> napi::Result<ConfigResolution> {
     let provider_config = provider_config.resolve(env, runtime)?;
     let logger_config = logger_config.resolve(env)?;
 
-    // TODO: https://github.com/NomicFoundation/edr/issues/760
-    let build_info_config = edr_solidity::artifacts::BuildInfoConfig::parse_from_buffers(
-        (&edr_napi_core::solidity::config::TracingConfigWithBuffers::from(tracing_config)).into(),
-    )
-    .map_err(|error| napi::Error::from_reason(error.to_string()))?;
-
-    let contract_decoder = ContractDecoder::new(&build_info_config).map_or_else(
-        |error| Err(napi::Error::from_reason(error.to_string())),
-        |contract_decoder| Ok(Arc::new(contract_decoder)),
-    )?;
-
     let subscription_config = edr_napi_core::subscription::Config::from(subscription_config);
     let subscription_callback =
         edr_napi_core::subscription::Callback::new(env, subscription_config.subscription_callback)?;
 
     Ok(ConfigResolution {
-        contract_decoder,
         logger_config,
         provider_config,
         subscription_callback,

package/src/context.rs

@@ -19,6 +19,7 @@ use tracing_subscriber::{prelude::*, EnvFilter, Registry};
 
 use crate::{
     config::{resolve_configs, ConfigResolution, ProviderConfig, TracingConfigWithBuffers},
+    contract_decoder::ContractDecoder,
     logger::LoggerConfig,
     provider::{Provider, ProviderFactory},
     solidity_tests::{
@@ -57,7 +58,7 @@ impl EdrContext {
         provider_config: ProviderConfig,
         logger_config: LoggerConfig,
         subscription_config: SubscriptionConfig,
-        tracing_config: TracingConfigWithBuffers,
+        contract_decoder: &ContractDecoder,
     ) -> napi::Result<JsObject> {
         let (deferred, promise) = env.create_deferred()?;
 
@@ -76,7 +77,6 @@ impl EdrContext {
         let runtime = runtime::Handle::current();
 
         let ConfigResolution {
-            contract_decoder,
             logger_config,
             provider_config,
             subscription_callback,
@@ -86,7 +86,6 @@ impl EdrContext {
             provider_config,
             logger_config,
             subscription_config,
-            tracing_config
         ));
 
         #[cfg(feature = "scenarios")]
@@ -105,6 +104,7 @@ impl EdrContext {
             try_or_reject_promise!(context.get_provider_factory(&chain_type))
         };
 
+        let contract_decoder = Arc::clone(contract_decoder.as_inner());
         runtime.clone().spawn_blocking(move || {
             let result = factory
                 .create_provider(

package/src/contract_decoder.rs

@@ -0,0 +1,57 @@
+use std::sync::Arc;
+
+use napi_derive::napi;
+
+use crate::config::TracingConfigWithBuffers;
+
+#[napi]
+pub struct ContractDecoder {
+    inner: Arc<edr_solidity::contract_decoder::ContractDecoder>,
+}
+
+#[napi]
+impl ContractDecoder {
+    #[doc = "Creates an empty instance."]
+    #[napi(constructor, catch_unwind)]
+    // Following TS convention for the constructor without arguments to be `new()`.
+    #[allow(clippy::new_without_default)]
+    pub fn new() -> Self {
+        Self {
+            inner: Arc::new(edr_solidity::contract_decoder::ContractDecoder::default()),
+        }
+    }
+
+    #[doc = "Creates a new instance with the provided configuration."]
+    #[napi(factory, catch_unwind)]
+    pub fn with_contracts(config: TracingConfigWithBuffers) -> napi::Result<Self> {
+        let build_info_config = edr_solidity::artifacts::BuildInfoConfig::parse_from_buffers(
+            (&edr_napi_core::solidity::config::TracingConfigWithBuffers::from(config)).into(),
+        )
+        .map_err(|error| napi::Error::from_reason(error.to_string()))?;
+
+        let contract_decoder =
+            edr_solidity::contract_decoder::ContractDecoder::new(&build_info_config).map_or_else(
+                |error| Err(napi::Error::from_reason(error.to_string())),
+                |contract_decoder| Ok(Arc::new(contract_decoder)),
+            )?;
+
+        Ok(Self {
+            inner: contract_decoder,
+        })
+    }
+}
+
+impl ContractDecoder {
+    /// Returns a reference to the inner contract decoder.
+    pub fn as_inner(&self) -> &Arc<edr_solidity::contract_decoder::ContractDecoder> {
+        &self.inner
+    }
+}
+
+impl From<Arc<edr_solidity::contract_decoder::ContractDecoder>> for ContractDecoder {
+    fn from(contract_decoder: Arc<edr_solidity::contract_decoder::ContractDecoder>) -> Self {
+        Self {
+            inner: contract_decoder,
+        }
+    }
+}

package/src/debug_trace.rs

@@ -3,6 +3,8 @@ use std::collections::HashMap;
 use napi::bindgen_prelude::{BigInt, Uint8Array};
 use napi_derive::napi;
 
+// False positive: imported by HH2
+#[allow(dead_code)]
 #[napi(object)]
 pub struct DebugTraceResult {
     pub pass: bool,

package/src/lib.rs

@@ -17,6 +17,8 @@ pub mod chains;
 pub mod config;
 /// Types related to an EDR N-API context.
 pub mod context;
+/// Types for decoding smart contract data.
+pub mod contract_decoder;
 mod debug_trace;
 /// Types and functions related to code coverage instrumentation.
 pub mod instrument;

package/src/log.rs

@@ -9,8 +9,8 @@ pub struct ExecutionLog {
     pub data: Uint8Array,
 }
 
-impl From<&edr_eth::log::ExecutionLog> for ExecutionLog {
-    fn from(value: &edr_eth::log::ExecutionLog) -> Self {
+impl From<&edr_receipt::log::ExecutionLog> for ExecutionLog {
+    fn from(value: &edr_receipt::log::ExecutionLog) -> Self {
         let topics = value
             .topics()
             .iter()

package/src/mock/time.rs

@@ -1,7 +1,8 @@
 use std::sync::Arc;
 
-use edr_eth::{spec::ChainSpec, B256};
+use edr_eth::B256;
 use edr_evm::spec::RuntimeSpec;
+use edr_evm_spec::ChainSpec;
 use edr_generic::GenericChainSpec;
 use edr_napi_core::logger::Logger;
 use edr_rpc_eth::RpcSpec;
@@ -10,7 +11,8 @@ use napi_derive::napi;
 
 use crate::{
     cast::TryCast as _,
-    config::{resolve_configs, ConfigResolution, ProviderConfig, TracingConfigWithBuffers},
+    config::{resolve_configs, ConfigResolution, ProviderConfig},
+    contract_decoder::ContractDecoder,
     logger::LoggerConfig,
     provider::Provider,
     subscription::SubscriptionConfig,
@@ -49,7 +51,7 @@ pub fn create_provider_with_mock_timer(
     provider_config: ProviderConfig,
     logger_config: LoggerConfig,
     subscription_config: SubscriptionConfig,
-    tracing_config: TracingConfigWithBuffers,
+    contract_decoder: &ContractDecoder,
     time: &MockTime,
 ) -> napi::Result<JsObject> {
     let (deferred, promise) = env.create_deferred()?;
@@ -69,7 +71,6 @@ pub fn create_provider_with_mock_timer(
     let runtime = runtime::Handle::current();
 
     let ConfigResolution {
-        contract_decoder,
         logger_config,
         provider_config,
         subscription_callback,
@@ -79,9 +80,9 @@ pub fn create_provider_with_mock_timer(
         provider_config,
         logger_config,
         subscription_config,
-        tracing_config,
     ));
 
+    let contract_decoder = Arc::clone(contract_decoder.as_inner());
     let timer = Arc::clone(&time.inner);
 
     runtime.clone().spawn_blocking(move || {
@@ -95,7 +96,7 @@ pub fn create_provider_with_mock_timer(
             )?;
 
             let provider_config =
-                edr_provider::ProviderConfig::<edr_eth::l1::SpecId>::try_from(provider_config)?;
+                edr_provider::ProviderConfig::<edr_chain_l1::Hardfork>::try_from(provider_config)?;
 
             let provider =
                 edr_provider::Provider::<GenericChainSpec, Arc<edr_provider::time::MockTime>>::new(
@@ -111,7 +112,7 @@ pub fn create_provider_with_mock_timer(
                         subscription_callback.call(event);
                     }),
                     provider_config,
-                    contract_decoder.clone(),
+                    Arc::clone(&contract_decoder),
                     timer,
                 )
                 .map_err(|error| napi::Error::from_reason(error.to_string()))?;

package/src/mock.rs

@@ -2,6 +2,7 @@ pub mod time;
 
 use std::sync::Arc;
 
+use edr_evm_spec::EvmHaltReason;
 use edr_napi_core::provider::SyncProvider;
 use edr_rpc_client::jsonrpc;
 use edr_solidity::contract_decoder::ContractDecoder;
@@ -22,20 +23,11 @@ impl MockProvider {
 }
 
 impl SyncProvider for MockProvider {
-    fn add_compilation_result(
-        &self,
-        _solc_version: String,
-        _compiler_input: edr_solidity::artifacts::CompilerInput,
-        _compiler_output: edr_solidity::artifacts::CompilerOutput,
-    ) -> napi::Result<bool> {
-        Ok(false) // Mock provider does not handle compilation results
-    }
-
     fn handle_request(
         &self,
         _request: String,
         _contract_decoder: Arc<ContractDecoder>,
-    ) -> napi::Result<edr_napi_core::spec::Response<edr_eth::l1::HaltReason>> {
+    ) -> napi::Result<edr_napi_core::spec::Response<EvmHaltReason>> {
         let response = jsonrpc::ResponseData::Success {
             result: self.mocked_response.clone(),
         };

package/src/provider/response.rs

@@ -1,4 +1,4 @@
-use edr_eth::l1;
+use edr_evm_spec::EvmHaltReason;
 use edr_napi_core::spec::SolidityTraceData;
 use edr_solidity::contract_decoder::NestedTraceDecoder as _;
 use napi::Either;
@@ -11,11 +11,11 @@ use crate::{
 
 #[napi]
 pub struct Response {
-    inner: edr_napi_core::spec::Response<l1::HaltReason>,
+    inner: edr_napi_core::spec::Response<EvmHaltReason>,
 }
 
-impl From<edr_napi_core::spec::Response<l1::HaltReason>> for Response {
-    fn from(value: edr_napi_core::spec::Response<l1::HaltReason>) -> Self {
+impl From<edr_napi_core::spec::Response<EvmHaltReason>> for Response {
+    fn from(value: edr_napi_core::spec::Response<EvmHaltReason>) -> Self {
         Self { inner: value }
     }
 }

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>,
         >,
@@ -54,8 +54,8 @@ impl Provider {
         solc_version: String,
         compiler_input: serde_json::Value,
         compiler_output: serde_json::Value,
-    ) -> napi::Result<bool> {
-        let provider = self.provider.clone();
+    ) -> napi::Result<()> {
+        let contract_decoder = self.contract_decoder.clone();
 
         self.runtime
             .spawn_blocking(move || {
@@ -65,12 +65,33 @@ impl Provider {
                 let compiler_output = serde_json::from_value(compiler_output)
                     .map_err(|error| napi::Error::from_reason(error.to_string()))?;
 
-                provider.add_compilation_result(solc_version, compiler_input, compiler_output)
+                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_evm_spec::EvmHaltReason;
 use napi::{
     bindgen_prelude::{BigInt, Either3, Uint8Array},
     Either,
@@ -99,61 +100,36 @@ pub enum ExceptionalHalt {
     CreateInitCodeSizeLimit,
 }
 
-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
-            }
-            edr_eth::l1::HaltReason::CreateContractStartingWithEF => {
+            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 => ExceptionalHalt::PrecompileError,
+            EvmHaltReason::NonceOverflow => ExceptionalHalt::NonceOverflow,
+            EvmHaltReason::CreateContractSizeLimit => ExceptionalHalt::CreateContractSizeLimit,
+            EvmHaltReason::CreateContractStartingWithEF => {
                 ExceptionalHalt::CreateContractStartingWithEF
             }
-            edr_eth::l1::HaltReason::CreateInitCodeSizeLimit => {
-                ExceptionalHalt::CreateInitCodeSizeLimit
-            }
-            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,
-        }
-    }
-}
-
 /// The result when the EVM terminates due to an exceptional halt.
 #[napi(object)]
 pub struct HaltResult {
@@ -173,8 +149,8 @@ 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,

package/src/solidity_tests/config.rs

@@ -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>,
@@ -194,6 +196,7 @@ impl SolidityTestRunnerConfigArgs {
             prompt_timeout,
             fuzz,
             invariant,
+            collect_stack_traces,
             include_traces,
             observability,
             test_pattern,
@@ -296,6 +299,10 @@ 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,
         };
@@ -721,6 +728,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

@@ -8,7 +8,7 @@ use edr_napi_core::solidity::{
 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,