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

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},
-    spec::SyncNapiSpec as _,
-    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,33 +16,40 @@ 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>> {
-        let logger = Logger::<GenericChainSpec>::new(logger_config, Arc::clone(&contract_decoder))?;
+    ) -> 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))
     }
 }
 
 #[napi]
-pub const GENERIC_CHAIN_TYPE: &str = GenericChainSpec::CHAIN_TYPE;
+pub const GENERIC_CHAIN_TYPE: &str = edr_generic::CHAIN_TYPE;
 
 #[napi(catch_unwind)]
 pub fn generic_chain_provider_factory() -> ProviderFactory {

package/src/chains/l1.rs

@@ -1,18 +1,21 @@
 use std::{str::FromStr, sync::Arc};
 
-use edr_eth::l1::{self, L1ChainSpec};
-use edr_evm::eips::{
+use edr_blockchain_fork::eips::{
     eip2935::{HISTORY_STORAGE_ADDRESS, HISTORY_STORAGE_UNSUPPORTED_BYTECODE},
     eip4788::{BEACON_ROOTS_ADDRESS, BEACON_ROOTS_BYTECODE},
 };
+use edr_chain_l1::L1ChainSpec;
 use edr_napi_core::{
     logger::Logger,
-    provider::{self, ProviderBuilder, SyncProviderFactory},
-    spec::SyncNapiSpec as _,
-    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,33 +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>> {
-        let logger = Logger::<L1ChainSpec>::new(logger_config, Arc::clone(&contract_decoder))?;
+    ) -> 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 = L1ChainSpec::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> {
@@ -129,6 +135,8 @@ pub enum SpecId {
     Cancun = 17,
     /// Prague
     Prague = 18,
+    /// Osaka
+    Osaka = 19,
 }
 
 impl FromStr for SpecId {
@@ -136,25 +144,26 @@ 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::chains::name::FRONTIER => Ok(SpecId::Frontier),
+            edr_chain_l1::chains::name::FRONTIER_THAWING => Ok(SpecId::FrontierThawing),
+            edr_chain_l1::chains::name::HOMESTEAD => Ok(SpecId::Homestead),
+            edr_chain_l1::chains::name::DAO_FORK => Ok(SpecId::DaoFork),
+            edr_chain_l1::chains::name::TANGERINE => Ok(SpecId::Tangerine),
+            edr_chain_l1::chains::name::SPURIOUS_DRAGON => Ok(SpecId::SpuriousDragon),
+            edr_chain_l1::chains::name::BYZANTIUM => Ok(SpecId::Byzantium),
+            edr_chain_l1::chains::name::CONSTANTINOPLE => Ok(SpecId::Constantinople),
+            edr_chain_l1::chains::name::PETERSBURG => Ok(SpecId::Petersburg),
+            edr_chain_l1::chains::name::ISTANBUL => Ok(SpecId::Istanbul),
+            edr_chain_l1::chains::name::MUIR_GLACIER => Ok(SpecId::MuirGlacier),
+            edr_chain_l1::chains::name::BERLIN => Ok(SpecId::Berlin),
+            edr_chain_l1::chains::name::LONDON => Ok(SpecId::London),
+            edr_chain_l1::chains::name::ARROW_GLACIER => Ok(SpecId::ArrowGlacier),
+            edr_chain_l1::chains::name::GRAY_GLACIER => Ok(SpecId::GrayGlacier),
+            edr_chain_l1::chains::name::MERGE => Ok(SpecId::Merge),
+            edr_chain_l1::chains::name::SHANGHAI => Ok(SpecId::Shanghai),
+            edr_chain_l1::chains::name::CANCUN => Ok(SpecId::Cancun),
+            edr_chain_l1::chains::name::PRAGUE => Ok(SpecId::Prague),
+            edr_chain_l1::chains::name::OSAKA => Ok(SpecId::Osaka),
             _ => Err(napi::Error::new(
                 napi::Status::InvalidArg,
                 format!("The provided hardfork `{s}` is not supported."),
@@ -163,28 +172,29 @@ 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,
+            SpecId::Osaka => edr_chain_l1::Hardfork::OSAKA,
         }
     }
 }
@@ -200,25 +210,26 @@ 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::chains::name::FRONTIER,
+        SpecId::FrontierThawing => edr_chain_l1::chains::name::FRONTIER_THAWING,
+        SpecId::Homestead => edr_chain_l1::chains::name::HOMESTEAD,
+        SpecId::DaoFork => edr_chain_l1::chains::name::DAO_FORK,
+        SpecId::Tangerine => edr_chain_l1::chains::name::TANGERINE,
+        SpecId::SpuriousDragon => edr_chain_l1::chains::name::SPURIOUS_DRAGON,
+        SpecId::Byzantium => edr_chain_l1::chains::name::BYZANTIUM,
+        SpecId::Constantinople => edr_chain_l1::chains::name::CONSTANTINOPLE,
+        SpecId::Petersburg => edr_chain_l1::chains::name::PETERSBURG,
+        SpecId::Istanbul => edr_chain_l1::chains::name::ISTANBUL,
+        SpecId::MuirGlacier => edr_chain_l1::chains::name::MUIR_GLACIER,
+        SpecId::Berlin => edr_chain_l1::chains::name::BERLIN,
+        SpecId::London => edr_chain_l1::chains::name::LONDON,
+        SpecId::ArrowGlacier => edr_chain_l1::chains::name::ARROW_GLACIER,
+        SpecId::GrayGlacier => edr_chain_l1::chains::name::GRAY_GLACIER,
+        SpecId::Merge => edr_chain_l1::chains::name::MERGE,
+        SpecId::Shanghai => edr_chain_l1::chains::name::SHANGHAI,
+        SpecId::Cancun => edr_chain_l1::chains::name::CANCUN,
+        SpecId::Prague => edr_chain_l1::chains::name::PRAGUE,
+        SpecId::Osaka => edr_chain_l1::chains::name::OSAKA,
     }
 }
 
@@ -227,14 +238,14 @@ pub fn l1_hardfork_to_string(harfork: SpecId) -> &'static str {
 /// The returned value will be updated after each network upgrade.
 #[napi]
 pub fn l1_hardfork_latest() -> SpecId {
-    SpecId::Prague
+    SpecId::Osaka
 }
 
 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::chains::name::$variant;
         )*
     };
 }
@@ -258,5 +269,6 @@ export_spec_id!(
     MERGE,
     SHANGHAI,
     CANCUN,
-    PRAGUE
+    PRAGUE,
+    OSAKA
 );