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

package/index.d.ts

@@ -162,6 +162,20 @@ export const FJORD: string
 export const GRANITE: string
 export const HOLOCENE: string
 export const ISTHMUS: string
+/** Configuration for EIP-1559 parameters */
+export interface BaseFeeParamActivation {
+  activation: BaseFeeActivationByBlockNumber | BaseFeeActivationByHardfork
+  maxChangeDenominator: bigint
+  elasticityMultiplier: bigint
+}
+export interface BaseFeeActivationByBlockNumber {
+  /** The block number at which the base_fee_params is activated */
+  blockNumber: bigint
+}
+export interface BaseFeeActivationByHardfork {
+  /** The hardfork at which the base_fee_params is activated */
+  hardfork: string
+}
 /** Specification of a chain with possible overrides. */
 export interface ChainOverride {
   /** The chain ID */
@@ -255,6 +269,17 @@ export interface ProviderConfig {
   bailOnCallFailure: boolean
   /** Whether to return an `Err` when a `eth_sendTransaction` fails */
   bailOnTransactionFailure: boolean
+  /**
+   * 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.
+   */
+  baseFeeConfig?: Array<BaseFeeParamActivation>
   /** The gas limit of each block */
   blockGasLimit: bigint
   /** The chain ID of the blockchain */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nomicfoundation/edr",
-  "version": "0.12.0-next.5",
+  "version": "0.12.0-next.6",
   "devDependencies": {
     "@napi-rs/cli": "^2.18.4",
     "@nomicfoundation/ethereumjs-util": "^9.0.4",
@@ -59,13 +59,13 @@
   "repository": "NomicFoundation/edr.git",
   "types": "index.d.ts",
   "optionalDependencies": {
-    "@nomicfoundation/edr-darwin-arm64": "0.12.0-next.5",
-    "@nomicfoundation/edr-darwin-x64": "0.12.0-next.5",
-    "@nomicfoundation/edr-linux-arm64-gnu": "0.12.0-next.5",
-    "@nomicfoundation/edr-linux-arm64-musl": "0.12.0-next.5",
-    "@nomicfoundation/edr-linux-x64-gnu": "0.12.0-next.5",
-    "@nomicfoundation/edr-linux-x64-musl": "0.12.0-next.5",
-    "@nomicfoundation/edr-win32-x64-msvc": "0.12.0-next.5"
+    "@nomicfoundation/edr-darwin-arm64": "0.12.0-next.6",
+    "@nomicfoundation/edr-darwin-x64": "0.12.0-next.6",
+    "@nomicfoundation/edr-linux-arm64-gnu": "0.12.0-next.6",
+    "@nomicfoundation/edr-linux-arm64-musl": "0.12.0-next.6",
+    "@nomicfoundation/edr-linux-x64-gnu": "0.12.0-next.6",
+    "@nomicfoundation/edr-linux-x64-musl": "0.12.0-next.6",
+    "@nomicfoundation/edr-win32-x64-msvc": "0.12.0-next.6"
   },
   "scripts": {
     "artifacts": "napi artifacts",

package/src/chains/generic.rs

@@ -1,6 +1,5 @@
 use std::sync::Arc;
 
-use edr_eth::l1;
 use edr_generic::GenericChainSpec;
 use edr_napi_core::{
     logger::Logger,
@@ -31,7 +30,7 @@ impl SyncProviderFactory for GenericChainProviderFactory {
         )?;
 
         let provider_config =
-            edr_provider::ProviderConfig::<l1::SpecId>::try_from(provider_config)?;
+            edr_provider::ProviderConfig::<edr_chain_l1::Hardfork>::try_from(provider_config)?;
 
         let provider = edr_provider::Provider::<GenericChainSpec>::new(
             runtime.clone(),

package/src/chains/l1.rs

@@ -1,6 +1,6 @@
 use std::{str::FromStr, sync::Arc};
 
-use edr_eth::l1::{self, L1ChainSpec};
+use edr_chain_l1::L1ChainSpec;
 use edr_evm::eips::{
     eip2935::{HISTORY_STORAGE_ADDRESS, HISTORY_STORAGE_UNSUPPORTED_BYTECODE},
     eip4788::{BEACON_ROOTS_ADDRESS, BEACON_ROOTS_BYTECODE},
@@ -35,7 +35,7 @@ impl SyncProviderFactory for L1ProviderFactory {
             Logger::<L1ChainSpec, CurrentTime>::new(logger_config, Arc::clone(&contract_decoder))?;
 
         let provider_config =
-            edr_provider::ProviderConfig::<l1::SpecId>::try_from(provider_config)?;
+            edr_provider::ProviderConfig::<edr_chain_l1::Hardfork>::try_from(provider_config)?;
 
         let provider = edr_provider::Provider::<L1ChainSpec>::new(
             runtime.clone(),
@@ -52,7 +52,7 @@ impl SyncProviderFactory for L1ProviderFactory {
 }
 
 #[napi]
-pub const L1_CHAIN_TYPE: &str = edr_eth::l1::CHAIN_TYPE;
+pub const L1_CHAIN_TYPE: &str = edr_chain_l1::CHAIN_TYPE;
 
 #[napi(catch_unwind)]
 pub fn l1_genesis_state(hardfork: SpecId) -> Vec<AccountOverride> {
@@ -142,25 +142,25 @@ impl FromStr for SpecId {
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         match s {
-            edr_eth::l1::hardfork::name::FRONTIER => Ok(SpecId::Frontier),
-            edr_eth::l1::hardfork::name::FRONTIER_THAWING => Ok(SpecId::FrontierThawing),
-            edr_eth::l1::hardfork::name::HOMESTEAD => Ok(SpecId::Homestead),
-            edr_eth::l1::hardfork::name::DAO_FORK => Ok(SpecId::DaoFork),
-            edr_eth::l1::hardfork::name::TANGERINE => Ok(SpecId::Tangerine),
-            edr_eth::l1::hardfork::name::SPURIOUS_DRAGON => Ok(SpecId::SpuriousDragon),
-            edr_eth::l1::hardfork::name::BYZANTIUM => Ok(SpecId::Byzantium),
-            edr_eth::l1::hardfork::name::CONSTANTINOPLE => Ok(SpecId::Constantinople),
-            edr_eth::l1::hardfork::name::PETERSBURG => Ok(SpecId::Petersburg),
-            edr_eth::l1::hardfork::name::ISTANBUL => Ok(SpecId::Istanbul),
-            edr_eth::l1::hardfork::name::MUIR_GLACIER => Ok(SpecId::MuirGlacier),
-            edr_eth::l1::hardfork::name::BERLIN => Ok(SpecId::Berlin),
-            edr_eth::l1::hardfork::name::LONDON => Ok(SpecId::London),
-            edr_eth::l1::hardfork::name::ARROW_GLACIER => Ok(SpecId::ArrowGlacier),
-            edr_eth::l1::hardfork::name::GRAY_GLACIER => Ok(SpecId::GrayGlacier),
-            edr_eth::l1::hardfork::name::MERGE => Ok(SpecId::Merge),
-            edr_eth::l1::hardfork::name::SHANGHAI => Ok(SpecId::Shanghai),
-            edr_eth::l1::hardfork::name::CANCUN => Ok(SpecId::Cancun),
-            edr_eth::l1::hardfork::name::PRAGUE => Ok(SpecId::Prague),
+            edr_chain_l1::hardfork::name::FRONTIER => Ok(SpecId::Frontier),
+            edr_chain_l1::hardfork::name::FRONTIER_THAWING => Ok(SpecId::FrontierThawing),
+            edr_chain_l1::hardfork::name::HOMESTEAD => Ok(SpecId::Homestead),
+            edr_chain_l1::hardfork::name::DAO_FORK => Ok(SpecId::DaoFork),
+            edr_chain_l1::hardfork::name::TANGERINE => Ok(SpecId::Tangerine),
+            edr_chain_l1::hardfork::name::SPURIOUS_DRAGON => Ok(SpecId::SpuriousDragon),
+            edr_chain_l1::hardfork::name::BYZANTIUM => Ok(SpecId::Byzantium),
+            edr_chain_l1::hardfork::name::CONSTANTINOPLE => Ok(SpecId::Constantinople),
+            edr_chain_l1::hardfork::name::PETERSBURG => Ok(SpecId::Petersburg),
+            edr_chain_l1::hardfork::name::ISTANBUL => Ok(SpecId::Istanbul),
+            edr_chain_l1::hardfork::name::MUIR_GLACIER => Ok(SpecId::MuirGlacier),
+            edr_chain_l1::hardfork::name::BERLIN => Ok(SpecId::Berlin),
+            edr_chain_l1::hardfork::name::LONDON => Ok(SpecId::London),
+            edr_chain_l1::hardfork::name::ARROW_GLACIER => Ok(SpecId::ArrowGlacier),
+            edr_chain_l1::hardfork::name::GRAY_GLACIER => Ok(SpecId::GrayGlacier),
+            edr_chain_l1::hardfork::name::MERGE => Ok(SpecId::Merge),
+            edr_chain_l1::hardfork::name::SHANGHAI => Ok(SpecId::Shanghai),
+            edr_chain_l1::hardfork::name::CANCUN => Ok(SpecId::Cancun),
+            edr_chain_l1::hardfork::name::PRAGUE => Ok(SpecId::Prague),
             _ => Err(napi::Error::new(
                 napi::Status::InvalidArg,
                 format!("The provided hardfork `{s}` is not supported."),
@@ -169,28 +169,28 @@ impl FromStr for SpecId {
     }
 }
 
-impl From<SpecId> for edr_eth::l1::SpecId {
+impl From<SpecId> for edr_chain_l1::Hardfork {
     fn from(value: SpecId) -> Self {
         match value {
-            SpecId::Frontier => edr_eth::l1::SpecId::FRONTIER,
-            SpecId::FrontierThawing => edr_eth::l1::SpecId::FRONTIER_THAWING,
-            SpecId::Homestead => edr_eth::l1::SpecId::HOMESTEAD,
-            SpecId::DaoFork => edr_eth::l1::SpecId::DAO_FORK,
-            SpecId::Tangerine => edr_eth::l1::SpecId::TANGERINE,
-            SpecId::SpuriousDragon => edr_eth::l1::SpecId::SPURIOUS_DRAGON,
-            SpecId::Byzantium => edr_eth::l1::SpecId::BYZANTIUM,
-            SpecId::Constantinople => edr_eth::l1::SpecId::CONSTANTINOPLE,
-            SpecId::Petersburg => edr_eth::l1::SpecId::PETERSBURG,
-            SpecId::Istanbul => edr_eth::l1::SpecId::ISTANBUL,
-            SpecId::MuirGlacier => edr_eth::l1::SpecId::MUIR_GLACIER,
-            SpecId::Berlin => edr_eth::l1::SpecId::BERLIN,
-            SpecId::London => edr_eth::l1::SpecId::LONDON,
-            SpecId::ArrowGlacier => edr_eth::l1::SpecId::ARROW_GLACIER,
-            SpecId::GrayGlacier => edr_eth::l1::SpecId::GRAY_GLACIER,
-            SpecId::Merge => edr_eth::l1::SpecId::MERGE,
-            SpecId::Shanghai => edr_eth::l1::SpecId::SHANGHAI,
-            SpecId::Cancun => edr_eth::l1::SpecId::CANCUN,
-            SpecId::Prague => edr_eth::l1::SpecId::PRAGUE,
+            SpecId::Frontier => edr_chain_l1::Hardfork::FRONTIER,
+            SpecId::FrontierThawing => edr_chain_l1::Hardfork::FRONTIER_THAWING,
+            SpecId::Homestead => edr_chain_l1::Hardfork::HOMESTEAD,
+            SpecId::DaoFork => edr_chain_l1::Hardfork::DAO_FORK,
+            SpecId::Tangerine => edr_chain_l1::Hardfork::TANGERINE,
+            SpecId::SpuriousDragon => edr_chain_l1::Hardfork::SPURIOUS_DRAGON,
+            SpecId::Byzantium => edr_chain_l1::Hardfork::BYZANTIUM,
+            SpecId::Constantinople => edr_chain_l1::Hardfork::CONSTANTINOPLE,
+            SpecId::Petersburg => edr_chain_l1::Hardfork::PETERSBURG,
+            SpecId::Istanbul => edr_chain_l1::Hardfork::ISTANBUL,
+            SpecId::MuirGlacier => edr_chain_l1::Hardfork::MUIR_GLACIER,
+            SpecId::Berlin => edr_chain_l1::Hardfork::BERLIN,
+            SpecId::London => edr_chain_l1::Hardfork::LONDON,
+            SpecId::ArrowGlacier => edr_chain_l1::Hardfork::ARROW_GLACIER,
+            SpecId::GrayGlacier => edr_chain_l1::Hardfork::GRAY_GLACIER,
+            SpecId::Merge => edr_chain_l1::Hardfork::MERGE,
+            SpecId::Shanghai => edr_chain_l1::Hardfork::SHANGHAI,
+            SpecId::Cancun => edr_chain_l1::Hardfork::CANCUN,
+            SpecId::Prague => edr_chain_l1::Hardfork::PRAGUE,
         }
     }
 }
@@ -206,25 +206,25 @@ pub fn l1_hardfork_from_string(hardfork: String) -> napi::Result<SpecId> {
 #[napi(catch_unwind)]
 pub fn l1_hardfork_to_string(harfork: SpecId) -> &'static str {
     match harfork {
-        SpecId::Frontier => edr_eth::l1::hardfork::name::FRONTIER,
-        SpecId::FrontierThawing => edr_eth::l1::hardfork::name::FRONTIER_THAWING,
-        SpecId::Homestead => edr_eth::l1::hardfork::name::HOMESTEAD,
-        SpecId::DaoFork => edr_eth::l1::hardfork::name::DAO_FORK,
-        SpecId::Tangerine => edr_eth::l1::hardfork::name::TANGERINE,
-        SpecId::SpuriousDragon => edr_eth::l1::hardfork::name::SPURIOUS_DRAGON,
-        SpecId::Byzantium => edr_eth::l1::hardfork::name::BYZANTIUM,
-        SpecId::Constantinople => edr_eth::l1::hardfork::name::CONSTANTINOPLE,
-        SpecId::Petersburg => edr_eth::l1::hardfork::name::PETERSBURG,
-        SpecId::Istanbul => edr_eth::l1::hardfork::name::ISTANBUL,
-        SpecId::MuirGlacier => edr_eth::l1::hardfork::name::MUIR_GLACIER,
-        SpecId::Berlin => edr_eth::l1::hardfork::name::BERLIN,
-        SpecId::London => edr_eth::l1::hardfork::name::LONDON,
-        SpecId::ArrowGlacier => edr_eth::l1::hardfork::name::ARROW_GLACIER,
-        SpecId::GrayGlacier => edr_eth::l1::hardfork::name::GRAY_GLACIER,
-        SpecId::Merge => edr_eth::l1::hardfork::name::MERGE,
-        SpecId::Shanghai => edr_eth::l1::hardfork::name::SHANGHAI,
-        SpecId::Cancun => edr_eth::l1::hardfork::name::CANCUN,
-        SpecId::Prague => edr_eth::l1::hardfork::name::PRAGUE,
+        SpecId::Frontier => edr_chain_l1::hardfork::name::FRONTIER,
+        SpecId::FrontierThawing => edr_chain_l1::hardfork::name::FRONTIER_THAWING,
+        SpecId::Homestead => edr_chain_l1::hardfork::name::HOMESTEAD,
+        SpecId::DaoFork => edr_chain_l1::hardfork::name::DAO_FORK,
+        SpecId::Tangerine => edr_chain_l1::hardfork::name::TANGERINE,
+        SpecId::SpuriousDragon => edr_chain_l1::hardfork::name::SPURIOUS_DRAGON,
+        SpecId::Byzantium => edr_chain_l1::hardfork::name::BYZANTIUM,
+        SpecId::Constantinople => edr_chain_l1::hardfork::name::CONSTANTINOPLE,
+        SpecId::Petersburg => edr_chain_l1::hardfork::name::PETERSBURG,
+        SpecId::Istanbul => edr_chain_l1::hardfork::name::ISTANBUL,
+        SpecId::MuirGlacier => edr_chain_l1::hardfork::name::MUIR_GLACIER,
+        SpecId::Berlin => edr_chain_l1::hardfork::name::BERLIN,
+        SpecId::London => edr_chain_l1::hardfork::name::LONDON,
+        SpecId::ArrowGlacier => edr_chain_l1::hardfork::name::ARROW_GLACIER,
+        SpecId::GrayGlacier => edr_chain_l1::hardfork::name::GRAY_GLACIER,
+        SpecId::Merge => edr_chain_l1::hardfork::name::MERGE,
+        SpecId::Shanghai => edr_chain_l1::hardfork::name::SHANGHAI,
+        SpecId::Cancun => edr_chain_l1::hardfork::name::CANCUN,
+        SpecId::Prague => edr_chain_l1::hardfork::name::PRAGUE,
     }
 }
 
@@ -240,7 +240,7 @@ macro_rules! export_spec_id {
     ($($variant:ident),*) => {
         $(
             #[napi]
-            pub const $variant: &str = edr_eth::l1::hardfork::name::$variant;
+            pub const $variant: &str = edr_chain_l1::hardfork::name::$variant;
         )*
     };
 }

package/src/chains/op.rs

@@ -6,7 +6,7 @@ use edr_napi_core::{
     provider::{SyncProvider, SyncProviderFactory},
     subscription::subscriber_callback_for_chain_spec,
 };
-use edr_op::{predeploys::GAS_PRICE_ORACLE_ADDRESS, OpChainSpec, OpSpecId};
+use edr_op::{predeploys::GAS_PRICE_ORACLE_ADDRESS, OpChainSpec};
 use edr_provider::time::CurrentTime;
 use edr_solidity::contract_decoder::ContractDecoder;
 use napi::{
@@ -34,7 +34,8 @@ impl SyncProviderFactory for OpProviderFactory {
         let logger =
             Logger::<OpChainSpec, CurrentTime>::new(logger_config, Arc::clone(&contract_decoder))?;
 
-        let provider_config = edr_provider::ProviderConfig::<OpSpecId>::try_from(provider_config)?;
+        let provider_config =
+            edr_provider::ProviderConfig::<edr_op::Hardfork>::try_from(provider_config)?;
 
         let provider = edr_provider::Provider::<OpChainSpec>::new(
             runtime.clone(),
@@ -63,17 +64,17 @@ pub enum OpHardfork {
     Isthmus = 107,
 }
 
-impl From<OpHardfork> for OpSpecId {
+impl From<OpHardfork> for edr_op::Hardfork {
     fn from(hardfork: OpHardfork) -> Self {
         match hardfork {
-            OpHardfork::Bedrock => OpSpecId::BEDROCK,
-            OpHardfork::Regolith => OpSpecId::REGOLITH,
-            OpHardfork::Canyon => OpSpecId::CANYON,
-            OpHardfork::Ecotone => OpSpecId::ECOTONE,
-            OpHardfork::Fjord => OpSpecId::FJORD,
-            OpHardfork::Granite => OpSpecId::GRANITE,
-            OpHardfork::Holocene => OpSpecId::HOLOCENE,
-            OpHardfork::Isthmus => OpSpecId::ISTHMUS,
+            OpHardfork::Bedrock => edr_op::Hardfork::BEDROCK,
+            OpHardfork::Regolith => edr_op::Hardfork::REGOLITH,
+            OpHardfork::Canyon => edr_op::Hardfork::CANYON,
+            OpHardfork::Ecotone => edr_op::Hardfork::ECOTONE,
+            OpHardfork::Fjord => edr_op::Hardfork::FJORD,
+            OpHardfork::Granite => edr_op::Hardfork::GRANITE,
+            OpHardfork::Holocene => edr_op::Hardfork::HOLOCENE,
+            OpHardfork::Isthmus => edr_op::Hardfork::ISTHMUS,
         }
     }
 }
@@ -335,10 +336,10 @@ pub fn op_provider_factory() -> ProviderFactory {
     factory.into()
 }
 
-fn gas_price_oracle_override(hardfork: OpSpecId) -> AccountOverride {
-    if hardfork >= OpSpecId::ISTHMUS {
+fn gas_price_oracle_override(hardfork: edr_op::Hardfork) -> AccountOverride {
+    if hardfork >= edr_op::Hardfork::ISTHMUS {
         gas_price_oracle_isthmus()
-    } else if hardfork >= OpSpecId::FJORD {
+    } else if hardfork >= edr_op::Hardfork::FJORD {
         gas_price_oracle_fjord()
     } else {
         gas_price_oracle_ecotone()

package/src/config.rs

@@ -7,10 +7,9 @@ use std::{
 };
 
 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},
@@ -27,6 +26,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 +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
@@ -423,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);
@@ -443,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(
@@ -468,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()?,

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;
@@ -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(

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,
@@ -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/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,

package/src/solidity_tests/op.rs

@@ -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/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,
         }
     }

package/src/trace.rs

@@ -7,8 +7,9 @@
 
 use std::sync::Arc;
 
-use edr_eth::{bytecode::opcode::OpCode, l1};
+use edr_eth::bytecode::opcode::OpCode;
 use edr_evm::trace::BeforeMessage;
+use edr_evm_spec::EvmHaltReason;
 use napi::bindgen_prelude::{BigInt, Either3, Uint8Array};
 use napi_derive::napi;
 
@@ -161,11 +162,11 @@ pub struct TracingMessageResult {
 #[napi]
 #[derive(Clone)]
 pub struct RawTrace {
-    inner: Arc<edr_evm::trace::Trace<l1::HaltReason>>,
+    inner: Arc<edr_evm::trace::Trace<EvmHaltReason>>,
 }
 
-impl From<Arc<edr_evm::trace::Trace<l1::HaltReason>>> for RawTrace {
-    fn from(value: Arc<edr_evm::trace::Trace<l1::HaltReason>>) -> Self {
+impl From<Arc<edr_evm::trace::Trace<EvmHaltReason>>> for RawTrace {
+    fn from(value: Arc<edr_evm::trace::Trace<EvmHaltReason>>) -> Self {
         Self { inner: value }
     }
 }