@nomicfoundation/edr 0.12.0-next.4 → 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 */
@@ -405,8 +430,7 @@ export enum SuccessReason {
   /** The opcode `RETURN` was called */
   Return = 1,
   /** The opcode `SELFDESTRUCT` was called */
-  SelfDestruct = 2,
-  EofReturnContract = 3
+  SelfDestruct = 2
 }
 export interface CallOutput {
   /** Return value */
@@ -459,15 +483,7 @@ export enum ExceptionalHalt {
   /** Error on created contract that begins with EF */
   CreateContractStartingWithEF = 12,
   /** EIP-3860: Limit and meter initcode. Initcode size limit exceeded. */
-  CreateInitCodeSizeLimit = 13,
-  /** Aux data overflow, new aux data is larger tha u16 max size. */
-  EofAuxDataOverflow = 14,
-  /** Aud data is smaller then already present data size. */
-  EofAuxDataTooSmall = 15,
-  /** EOF Subroutine stack overflow */
-  SubRoutineStackOverflow = 16,
-  /** Check for target address validity is only done inside subcall. */
-  InvalidEXTCALLTarget = 17
+  CreateInitCodeSizeLimit = 13
 }
 /** The result when the EVM terminates due to an exceptional halt. */
 export interface HaltResult {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nomicfoundation/edr",
-  "version": "0.12.0-next.4",
+  "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.4",
-    "@nomicfoundation/edr-darwin-x64": "0.12.0-next.4",
-    "@nomicfoundation/edr-linux-arm64-gnu": "0.12.0-next.4",
-    "@nomicfoundation/edr-linux-arm64-musl": "0.12.0-next.4",
-    "@nomicfoundation/edr-linux-x64-gnu": "0.12.0-next.4",
-    "@nomicfoundation/edr-linux-x64-musl": "0.12.0-next.4",
-    "@nomicfoundation/edr-win32-x64-msvc": "0.12.0-next.4"
+    "@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/account.rs

@@ -53,7 +53,7 @@ impl TryFrom<AccountOverride> for (edr_eth::Address, edr_provider::AccountOverri
                     .into_iter()
                     .map(|StorageSlot { index, value }| {
                         let value = value.try_cast()?;
-                        let slot = edr_evm::state::EvmStorageSlot::new(value);
+                        let slot = edr_evm::state::EvmStorageSlot::new(value, 0);
 
                         let index: edr_eth::U256 = index.try_cast()?;
                         Ok((index, slot))

package/src/chains/generic.rs

@@ -1,14 +1,14 @@
 use std::sync::Arc;
 
-use edr_eth::l1;
 use edr_generic::GenericChainSpec;
 use edr_napi_core::{
-    logger::{self, Logger},
-    provider::{self, ProviderBuilder, SyncProviderFactory},
-    subscription,
+    logger::Logger,
+    provider::{SyncProvider, SyncProviderFactory},
+    subscription::subscriber_callback_for_chain_spec,
 };
 use edr_provider::time::CurrentTime;
 use edr_solidity::contract_decoder::ContractDecoder;
+use napi::tokio::runtime;
 use napi_derive::napi;
 
 use crate::provider::ProviderFactory;
@@ -16,31 +16,35 @@ use crate::provider::ProviderFactory;
 pub struct GenericChainProviderFactory;
 
 impl SyncProviderFactory for GenericChainProviderFactory {
-    fn create_provider_builder(
+    fn create_provider(
         &self,
-        env: &napi::Env,
+        runtime: runtime::Handle,
         provider_config: edr_napi_core::provider::Config,
-        logger_config: logger::Config,
-        subscription_config: subscription::Config,
+        logger_config: edr_napi_core::logger::Config,
+        subscription_callback: edr_napi_core::subscription::Callback,
         contract_decoder: Arc<ContractDecoder>,
-    ) -> napi::Result<Box<dyn provider::Builder>> {
+    ) -> napi::Result<Arc<dyn SyncProvider>> {
         let logger = Logger::<GenericChainSpec, 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 subscription_callback =
-            subscription::Callback::new(env, subscription_config.subscription_callback)?;
-
-        Ok(Box::new(ProviderBuilder::new(
-            contract_decoder,
+        let provider = edr_provider::Provider::<GenericChainSpec>::new(
+            runtime.clone(),
             Box::new(logger),
+            subscriber_callback_for_chain_spec::<GenericChainSpec, CurrentTime>(
+                subscription_callback,
+            ),
             provider_config,
-            subscription_callback,
-        )))
+            contract_decoder,
+            CurrentTime,
+        )
+        .map_err(|error| napi::Error::new(napi::Status::GenericFailure, error.to_string()))?;
+
+        Ok(Arc::new(provider))
     }
 }
 

package/src/chains/l1.rs

@@ -1,18 +1,21 @@
 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},
 };
 use edr_napi_core::{
     logger::Logger,
-    provider::{self, ProviderBuilder, SyncProviderFactory},
-    subscription,
+    provider::{SyncProvider, SyncProviderFactory},
+    subscription::subscriber_callback_for_chain_spec,
 };
 use edr_provider::time::CurrentTime;
 use edr_solidity::contract_decoder::ContractDecoder;
-use napi::bindgen_prelude::{BigInt, Uint8Array};
+use napi::{
+    bindgen_prelude::{BigInt, Uint8Array},
+    tokio::runtime,
+};
 use napi_derive::napi;
 
 use crate::{account::AccountOverride, provider::ProviderFactory};
@@ -20,34 +23,36 @@ use crate::{account::AccountOverride, provider::ProviderFactory};
 pub struct L1ProviderFactory;
 
 impl SyncProviderFactory for L1ProviderFactory {
-    fn create_provider_builder(
+    fn create_provider(
         &self,
-        env: &napi::Env,
+        runtime: runtime::Handle,
         provider_config: edr_napi_core::provider::Config,
         logger_config: edr_napi_core::logger::Config,
-        subscription_config: edr_napi_core::subscription::Config,
+        subscription_callback: edr_napi_core::subscription::Callback,
         contract_decoder: Arc<ContractDecoder>,
-    ) -> napi::Result<Box<dyn provider::Builder>> {
+    ) -> napi::Result<Arc<dyn SyncProvider>> {
         let logger =
             Logger::<L1ChainSpec, CurrentTime>::new(logger_config, Arc::clone(&contract_decoder))?;
 
         let provider_config =
-            edr_provider::ProviderConfig::<l1::SpecId>::try_from(provider_config)?;
-
-        let subscription_callback =
-            subscription::Callback::new(env, subscription_config.subscription_callback)?;
+            edr_provider::ProviderConfig::<edr_chain_l1::Hardfork>::try_from(provider_config)?;
 
-        Ok(Box::new(ProviderBuilder::new(
-            contract_decoder,
+        let provider = edr_provider::Provider::<L1ChainSpec>::new(
+            runtime.clone(),
             Box::new(logger),
+            subscriber_callback_for_chain_spec::<L1ChainSpec, CurrentTime>(subscription_callback),
             provider_config,
-            subscription_callback,
-        )))
+            contract_decoder,
+            CurrentTime,
+        )
+        .map_err(|error| napi::Error::new(napi::Status::GenericFailure, error.to_string()))?;
+
+        Ok(Arc::new(provider))
     }
 }
 
 #[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> {
@@ -137,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."),
@@ -164,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,
         }
     }
 }
@@ -201,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,
     }
 }
 
@@ -235,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

@@ -2,14 +2,17 @@ use std::{str::FromStr, sync::Arc};
 
 use edr_eth::hex;
 use edr_napi_core::{
-    logger::{self, Logger},
-    provider::{self, ProviderBuilder, SyncProviderFactory},
-    subscription,
+    logger::Logger,
+    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::bindgen_prelude::{BigInt, Uint8Array};
+use napi::{
+    bindgen_prelude::{BigInt, Uint8Array},
+    tokio::runtime,
+};
 use napi_derive::napi;
 
 use crate::{
@@ -20,28 +23,31 @@ use crate::{
 pub struct OpProviderFactory;
 
 impl SyncProviderFactory for OpProviderFactory {
-    fn create_provider_builder(
+    fn create_provider(
         &self,
-        env: &napi::Env,
-        provider_config: provider::Config,
-        logger_config: logger::Config,
-        subscription_config: subscription::Config,
+        runtime: runtime::Handle,
+        provider_config: edr_napi_core::provider::Config,
+        logger_config: edr_napi_core::logger::Config,
+        subscription_callback: edr_napi_core::subscription::Callback,
         contract_decoder: Arc<ContractDecoder>,
-    ) -> napi::Result<Box<dyn provider::Builder>> {
+    ) -> napi::Result<Arc<dyn SyncProvider>> {
         let logger =
             Logger::<OpChainSpec, CurrentTime>::new(logger_config, Arc::clone(&contract_decoder))?;
 
-        let provider_config = edr_provider::ProviderConfig::<OpSpecId>::try_from(provider_config)?;
-
-        let subscription_callback =
-            subscription::Callback::new(env, subscription_config.subscription_callback)?;
+        let provider_config =
+            edr_provider::ProviderConfig::<edr_op::Hardfork>::try_from(provider_config)?;
 
-        Ok(Box::new(ProviderBuilder::new(
-            contract_decoder,
+        let provider = edr_provider::Provider::<OpChainSpec>::new(
+            runtime.clone(),
             Box::new(logger),
+            subscriber_callback_for_chain_spec::<OpChainSpec, CurrentTime>(subscription_callback),
             provider_config,
-            subscription_callback,
-        )))
+            contract_decoder,
+            CurrentTime,
+        )
+        .map_err(|error| napi::Error::new(napi::Status::GenericFailure, error.to_string()))?;
+
+        Ok(Arc::new(provider))
     }
 }
 
@@ -58,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,
         }
     }
 }
@@ -330,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()