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

package/src/config.rs

@@ -2,14 +2,15 @@ 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_eip1559::{BaseFeeActivation, ConstantBaseFeeParams};
+use edr_eth::{Bytes, HashMap, HashSet};
+use edr_signer::{secret_key_from_str, SecretKey};
+use edr_solidity::contract_decoder::ContractDecoder;
 use napi::{
     bindgen_prelude::{BigInt, Promise, Reference, Uint8Array},
     threadsafe_function::{
@@ -20,7 +21,53 @@ use napi::{
 };
 use napi_derive::napi;
 
-use crate::{account::AccountOverride, block::BlobGas, cast::TryCast, precompile::Precompile};
+use crate::{
+    account::AccountOverride, block::BlobGas, cast::TryCast, logger::LoggerConfig,
+    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)]
@@ -137,6 +184,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
@@ -418,7 +474,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);
@@ -438,6 +494,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(
@@ -463,6 +524,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()?,
@@ -541,3 +603,46 @@ 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,
+}
+
+/// Helper function for resolving the provided N-API configs.
+pub fn resolve_configs(
+    env: &napi::Env,
+    runtime: runtime::Handle,
+    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

@@ -1,11 +1,7 @@
 use std::sync::Arc;
 
 use edr_eth::HashMap;
-use edr_napi_core::{
-    provider::{self, SyncProviderFactory},
-    solidity,
-};
-use edr_solidity::contract_decoder::ContractDecoder;
+use edr_napi_core::{provider::SyncProviderFactory, solidity};
 use edr_solidity_tests::{
     decode::RevertDecoder,
     multi_runner::{SuiteResultAndArtifactId, TestContract, TestContracts},
@@ -22,7 +18,7 @@ use napi_derive::napi;
 use tracing_subscriber::{prelude::*, EnvFilter, Registry};
 
 use crate::{
-    config::{ProviderConfig, TracingConfigWithBuffers},
+    config::{resolve_configs, ConfigResolution, ProviderConfig, TracingConfigWithBuffers},
     logger::LoggerConfig,
     provider::{Provider, ProviderFactory},
     solidity_tests::{
@@ -78,25 +74,20 @@ impl EdrContext {
         }
 
         let runtime = runtime::Handle::current();
-        let provider_config =
-            try_or_reject_promise!(provider_config.resolve(&env, runtime.clone()));
-
-        let logger_config = try_or_reject_promise!(logger_config.resolve(&env));
-
-        // TODO: https://github.com/NomicFoundation/edr/issues/760
-        let build_info_config = try_or_reject_promise!(
-            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 = try_or_reject_promise!(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 ConfigResolution {
+            contract_decoder,
+            logger_config,
+            provider_config,
+            subscription_callback,
+        } = try_or_reject_promise!(resolve_configs(
+            &env,
+            runtime.clone(),
+            provider_config,
+            logger_config,
+            subscription_config,
+            tracing_config
+        ));
 
         #[cfg(feature = "scenarios")]
         let scenario_file =
@@ -106,31 +97,32 @@ impl EdrContext {
                 logger_config.enable,
             )));
 
-        let builder = {
+        let factory = {
             // TODO: https://github.com/NomicFoundation/edr/issues/760
             // TODO: Don't block the JS event loop
             let context = runtime.block_on(async { self.inner.lock().await });
 
-            try_or_reject_promise!(context.create_provider_builder(
-                &env,
-                &chain_type,
-                provider_config,
-                logger_config,
-                subscription_config.into(),
-                &contract_decoder,
-            ))
+            try_or_reject_promise!(context.get_provider_factory(&chain_type))
         };
 
         runtime.clone().spawn_blocking(move || {
-            let result = builder.build(runtime.clone()).map(|provider| {
-                Provider::new(
-                    provider,
-                    runtime,
-                    contract_decoder,
-                    #[cfg(feature = "scenarios")]
-                    scenario_file,
+            let result = factory
+                .create_provider(
+                    runtime.clone(),
+                    provider_config,
+                    logger_config,
+                    subscription_callback,
+                    Arc::clone(&contract_decoder),
                 )
-            });
+                .map(|provider| {
+                    Provider::new(
+                        provider,
+                        runtime,
+                        contract_decoder,
+                        #[cfg(feature = "scenarios")]
+                        scenario_file,
+                    )
+                });
 
             deferred.resolve(|_env| result);
         });
@@ -410,23 +402,12 @@ impl Context {
 
     /// Tries to create a new provider for the provided chain type and
     /// configuration.
-    pub fn create_provider_builder(
+    pub fn get_provider_factory(
         &self,
-        env: &napi::Env,
         chain_type: &str,
-        provider_config: edr_napi_core::provider::Config,
-        logger_config: edr_napi_core::logger::Config,
-        subscription_config: edr_napi_core::subscription::Config,
-        contract_decoder: &Arc<ContractDecoder>,
-    ) -> napi::Result<Box<dyn provider::Builder>> {
+    ) -> napi::Result<Arc<dyn SyncProviderFactory>> {
         if let Some(factory) = self.provider_factories.get(chain_type) {
-            factory.create_provider_builder(
-                env,
-                provider_config,
-                logger_config,
-                subscription_config,
-                contract_decoder.clone(),
-            )
+            Ok(Arc::clone(factory))
         } else {
             Err(napi::Error::new(
                 napi::Status::GenericFailure,

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,17 +1,17 @@
 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;
-use edr_solidity::contract_decoder::ContractDecoder;
 use napi::{bindgen_prelude::BigInt, tokio::runtime, Env, JsObject};
 use napi_derive::napi;
 
 use crate::{
     cast::TryCast as _,
-    config::{ProviderConfig, TracingConfigWithBuffers},
+    config::{resolve_configs, ConfigResolution, ProviderConfig, TracingConfigWithBuffers},
     logger::LoggerConfig,
     provider::Provider,
     subscription::SubscriptionConfig,
@@ -68,73 +68,65 @@ pub fn create_provider_with_mock_timer(
     }
 
     let runtime = runtime::Handle::current();
-    let provider_config = try_or_reject_promise!(provider_config.resolve(&env, runtime.clone()));
-
-    let logger_config = try_or_reject_promise!(logger_config.resolve(&env));
-
-    // TODO: https://github.com/NomicFoundation/edr/issues/760
-    let build_info_config = try_or_reject_promise!(
-        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 = try_or_reject_promise!(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 = try_or_reject_promise!(edr_napi_core::subscription::Callback::new(
+
+    let ConfigResolution {
+        contract_decoder,
+        logger_config,
+        provider_config,
+        subscription_callback,
+    } = try_or_reject_promise!(resolve_configs(
         &env,
-        subscription_config.subscription_callback,
+        runtime.clone(),
+        provider_config,
+        logger_config,
+        subscription_config,
+        tracing_config,
     ));
 
-    let logger = try_or_reject_promise!(Logger::<
-        GenericChainSpec,
-        Arc<edr_provider::time::MockTime>,
-    >::new(logger_config, Arc::clone(&contract_decoder),));
-
-    let provider_config = try_or_reject_promise!(
-        edr_provider::ProviderConfig::<edr_eth::l1::SpecId>::try_from(provider_config)
-    );
-
     let timer = Arc::clone(&time.inner);
 
     runtime.clone().spawn_blocking(move || {
-        let result =
-            edr_provider::Provider::<GenericChainSpec, Arc<edr_provider::time::MockTime>>::new(
-                runtime.clone(),
-                Box::new(logger),
-                Box::new(move |event| {
-                    let event = edr_napi_core::subscription::SubscriptionEvent::new::<
-                        <GenericChainSpec as RuntimeSpec>::Block,
-                        <GenericChainSpec as RpcSpec>::RpcBlock<B256>,
-                        <GenericChainSpec as ChainSpec>::SignedTransaction,
-                    >(event);
-
-                    subscription_callback.call(event);
-                }),
-                provider_config,
-                contract_decoder.clone(),
-                timer,
-            )
-            .map_or_else(
-                |error| Err(napi::Error::from_reason(error.to_string())),
-                |provider| {
-                    Ok(Provider::new(
-                        Arc::new(provider),
-                        runtime,
-                        contract_decoder,
-                        #[cfg(feature = "scenarios")]
-                        None,
-                    ))
-                },
-            );
+        // Using a closure to limit the scope, allowing us to use `?` for error
+        // handling. This is necessary because the result of the closure is used
+        // to resolve the deferred promise.
+        let create_provider = move || -> napi::Result<Provider> {
+            let logger = Logger::<GenericChainSpec, Arc<edr_provider::time::MockTime>>::new(
+                logger_config,
+                Arc::clone(&contract_decoder),
+            )?;
+
+            let 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(
+                    runtime.clone(),
+                    Box::new(logger),
+                    Box::new(move |event| {
+                        let event = edr_napi_core::subscription::SubscriptionEvent::new::<
+                            <GenericChainSpec as RuntimeSpec>::Block,
+                            <GenericChainSpec as RpcSpec>::RpcBlock<B256>,
+                            <GenericChainSpec as ChainSpec>::SignedTransaction,
+                        >(event);
+
+                        subscription_callback.call(event);
+                    }),
+                    provider_config,
+                    contract_decoder.clone(),
+                    timer,
+                )
+                .map_err(|error| napi::Error::from_reason(error.to_string()))?;
+
+            Ok(Provider::new(
+                Arc::new(provider),
+                runtime,
+                contract_decoder,
+                #[cfg(feature = "scenarios")]
+                None,
+            ))
+        };
 
+        let result = create_provider();
         deferred.resolve(|_env| result);
     });
 

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;
@@ -35,7 +36,7 @@ impl SyncProvider for MockProvider {
         &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/result.rs

@@ -1,4 +1,5 @@
 use edr_evm::trace::AfterMessage;
+use edr_evm_spec::EvmHaltReason;
 use napi::{
     bindgen_prelude::{BigInt, Either3, Uint8Array},
     Either,
@@ -16,7 +17,6 @@ pub enum SuccessReason {
     Return,
     /// The opcode `SELFDESTRUCT` was called
     SelfDestruct,
-    EofReturnContract,
 }
 
 impl From<edr_eth::result::SuccessReason> for SuccessReason {
@@ -25,7 +25,6 @@ impl From<edr_eth::result::SuccessReason> for SuccessReason {
             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,
         }
     }
 }
@@ -36,7 +35,6 @@ impl From<SuccessReason> for edr_eth::result::SuccessReason {
             SuccessReason::Stop => Self::Stop,
             SuccessReason::Return => Self::Return,
             SuccessReason::SelfDestruct => Self::SelfDestruct,
-            SuccessReason::EofReturnContract => Self::EofReturnContract,
         }
     }
 }
@@ -100,81 +98,38 @@ 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
-            }
-            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::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,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,