@nomicfoundation/edr 0.10.0 → 0.12.0-alpha.0

package/src/cast.rs

@@ -1,7 +1,7 @@
-use edr_eth::{Address, Bytes, B256, B64, U256};
+use edr_eth::{Address, B64, B256, Bytecode, Bytes, U256};
 use napi::{
-    bindgen_prelude::{BigInt, Buffer},
     Status,
+    bindgen_prelude::{BigInt, Buffer, Uint8Array},
 };
 
 /// An attempted conversion that consumes `self`, which may or may not be
@@ -29,6 +29,20 @@ impl TryCast<Address> for Buffer {
     }
 }
 
+impl TryCast<Address> for Uint8Array {
+    type Error = napi::Error;
+
+    fn try_cast(self) -> std::result::Result<Address, Self::Error> {
+        if self.len() != 20 {
+            return Err(napi::Error::new(
+                Status::InvalidArg,
+                "Uint8Array was expected to be 20 bytes.".to_string(),
+            ));
+        }
+        Ok(Address::from_slice(&self))
+    }
+}
+
 impl TryCast<B64> for Buffer {
     type Error = napi::Error;
 
@@ -57,6 +71,20 @@ impl TryCast<B256> for Buffer {
     }
 }
 
+impl TryCast<Bytecode> for Uint8Array {
+    type Error = napi::Error;
+
+    fn try_cast(self) -> std::result::Result<Bytecode, Self::Error> {
+        let bytes = Bytes::copy_from_slice(&self);
+        Bytecode::new_raw_checked(bytes).map_err(|error| {
+            napi::Error::new(
+                Status::InvalidArg,
+                format!("Uint8Array was not valid bytecode: {error}"),
+            )
+        })
+    }
+}
+
 impl TryCast<u64> for BigInt {
     type Error = napi::Error;
 
@@ -81,6 +109,30 @@ impl TryCast<u64> for BigInt {
     }
 }
 
+impl TryCast<u128> for BigInt {
+    type Error = napi::Error;
+
+    fn try_cast(self) -> std::result::Result<u128, Self::Error> {
+        let (signed, value, lossless) = self.get_u128();
+
+        if signed {
+            return Err(napi::Error::new(
+                Status::InvalidArg,
+                "BigInt was expected to be unsigned.".to_string(),
+            ));
+        }
+
+        if !lossless {
+            return Err(napi::Error::new(
+                Status::InvalidArg,
+                "BigInt was expected to fit within 128 bits.".to_string(),
+            ));
+        }
+
+        Ok(value)
+    }
+}
+
 impl TryCast<usize> for BigInt {
     type Error = napi::Error;
 

package/src/chains/generic.rs

@@ -0,0 +1,51 @@
+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,
+};
+use edr_solidity::contract_decoder::ContractDecoder;
+use napi_derive::napi;
+
+use crate::provider::ProviderFactory;
+
+pub struct GenericChainProviderFactory;
+
+impl SyncProviderFactory for GenericChainProviderFactory {
+    fn create_provider_builder(
+        &self,
+        env: &napi::Env,
+        provider_config: edr_napi_core::provider::Config,
+        logger_config: logger::Config,
+        subscription_config: subscription::Config,
+        contract_decoder: Arc<ContractDecoder>,
+    ) -> napi::Result<Box<dyn provider::Builder>> {
+        let logger = Logger::<GenericChainSpec>::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)?;
+
+        Ok(Box::new(ProviderBuilder::new(
+            contract_decoder,
+            Box::new(logger),
+            provider_config,
+            subscription_callback,
+        )))
+    }
+}
+
+#[napi]
+pub const GENERIC_CHAIN_TYPE: &str = GenericChainSpec::CHAIN_TYPE;
+
+#[napi]
+pub fn generic_chain_provider_factory() -> ProviderFactory {
+    let factory: Arc<dyn SyncProviderFactory> = Arc::new(GenericChainProviderFactory);
+    factory.into()
+}

package/src/chains/l1.rs

@@ -0,0 +1,260 @@
+use std::{str::FromStr, sync::Arc};
+
+use edr_eth::l1::{self, 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},
+    spec::SyncNapiSpec as _,
+    subscription,
+};
+use edr_solidity::contract_decoder::ContractDecoder;
+use napi::bindgen_prelude::{BigInt, Uint8Array};
+use napi_derive::napi;
+
+use crate::{account::Account, provider::ProviderFactory};
+
+pub struct L1ProviderFactory;
+
+impl SyncProviderFactory for L1ProviderFactory {
+    fn create_provider_builder(
+        &self,
+        env: &napi::Env,
+        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>> {
+        let logger = Logger::<L1ChainSpec>::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)?;
+
+        Ok(Box::new(ProviderBuilder::new(
+            contract_decoder,
+            Box::new(logger),
+            provider_config,
+            subscription_callback,
+        )))
+    }
+}
+
+#[napi]
+pub const L1_CHAIN_TYPE: &str = L1ChainSpec::CHAIN_TYPE;
+
+#[napi]
+pub fn l1_genesis_state(hardfork: SpecId) -> Vec<Account> {
+    // Use closures for lazy execution
+    let beacon_roots_account_constructor = || Account {
+        address: Uint8Array::from(BEACON_ROOTS_ADDRESS.as_slice()),
+        balance: BigInt::from(0u64),
+        nonce: BigInt::from(0u64),
+        code: Some(Uint8Array::from(BEACON_ROOTS_BYTECODE)),
+        storage: Vec::new(),
+    };
+
+    let history_storage_account_constructor = || Account {
+        address: Uint8Array::from(HISTORY_STORAGE_ADDRESS.as_slice()),
+        balance: BigInt::from(0u64),
+        nonce: BigInt::from(0u64),
+        code: Some(Uint8Array::from(HISTORY_STORAGE_UNSUPPORTED_BYTECODE)),
+        storage: Vec::new(),
+    };
+
+    if hardfork < SpecId::Cancun {
+        Vec::new()
+    } else if hardfork < SpecId::Prague {
+        vec![beacon_roots_account_constructor()]
+    } else {
+        vec![
+            beacon_roots_account_constructor(),
+            history_storage_account_constructor(),
+        ]
+    }
+}
+
+#[napi]
+pub fn l1_provider_factory() -> ProviderFactory {
+    let factory: Arc<dyn SyncProviderFactory> = Arc::new(L1ProviderFactory);
+    factory.into()
+}
+
+/// Identifier for the Ethereum spec.
+#[napi]
+#[derive(PartialEq, Eq, PartialOrd, Ord)]
+pub enum SpecId {
+    /// Frontier
+    Frontier = 0,
+    /// Frontier Thawing
+    FrontierThawing = 1,
+    /// Homestead
+    Homestead = 2,
+    /// DAO Fork
+    DaoFork = 3,
+    /// Tangerine
+    Tangerine = 4,
+    /// Spurious Dragon
+    SpuriousDragon = 5,
+    /// Byzantium
+    Byzantium = 6,
+    /// Constantinople
+    Constantinople = 7,
+    /// Petersburg
+    Petersburg = 8,
+    /// Istanbul
+    Istanbul = 9,
+    /// Muir Glacier
+    MuirGlacier = 10,
+    /// Berlin
+    Berlin = 11,
+    /// London
+    London = 12,
+    /// Arrow Glacier
+    ArrowGlacier = 13,
+    /// Gray Glacier
+    GrayGlacier = 14,
+    /// Merge
+    Merge = 15,
+    /// Shanghai
+    Shanghai = 16,
+    /// Cancun
+    Cancun = 17,
+    /// Prague
+    Prague = 18,
+}
+
+impl FromStr for SpecId {
+    type Err = napi::Error;
+
+    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),
+            _ => Err(napi::Error::new(
+                napi::Status::InvalidArg,
+                format!("The provided hardfork `{s}` is not supported."),
+            )),
+        }
+    }
+}
+
+impl From<SpecId> for edr_eth::l1::SpecId {
+    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,
+        }
+    }
+}
+
+/// Tries to parse the provided string to create a [`SpecId`] instance.
+///
+/// Returns an error if the string does not match any known hardfork.
+#[napi]
+pub fn l1_hardfork_from_string(hardfork: String) -> napi::Result<SpecId> {
+    hardfork.parse()
+}
+
+#[napi]
+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,
+    }
+}
+
+/// Returns the latest supported OP hardfork.
+///
+/// The returned value will be updated after each network upgrade.
+#[napi]
+pub fn l1_hardfork_latest() -> SpecId {
+    SpecId::Prague
+}
+
+macro_rules! export_spec_id {
+    ($($variant:ident),*) => {
+        $(
+            #[napi]
+            pub const $variant: &str = edr_eth::l1::hardfork::name::$variant;
+        )*
+    };
+}
+
+export_spec_id!(
+    FRONTIER,
+    FRONTIER_THAWING,
+    HOMESTEAD,
+    DAO_FORK,
+    TANGERINE,
+    SPURIOUS_DRAGON,
+    BYZANTIUM,
+    CONSTANTINOPLE,
+    PETERSBURG,
+    ISTANBUL,
+    MUIR_GLACIER,
+    BERLIN,
+    LONDON,
+    ARROW_GLACIER,
+    GRAY_GLACIER,
+    MERGE,
+    SHANGHAI,
+    CANCUN,
+    PRAGUE
+);