@nomicfoundation/edr 0.11.0 → 0.12.0-alpha.0

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
+);

package/src/chains/op.rs

@@ -0,0 +1,368 @@
+use std::{str::FromStr, sync::Arc};
+
+use edr_eth::hex;
+use edr_napi_core::{
+    logger::{self, Logger},
+    provider::{self, ProviderBuilder, SyncProviderFactory},
+    subscription,
+};
+use edr_op::{OpChainSpec, OpSpecId};
+use edr_solidity::contract_decoder::ContractDecoder;
+use napi::bindgen_prelude::BigInt;
+use napi_derive::napi;
+
+use crate::{
+    account::{Account, StorageSlot},
+    provider::ProviderFactory,
+};
+
+pub struct OpProviderFactory;
+
+impl SyncProviderFactory for OpProviderFactory {
+    fn create_provider_builder(
+        &self,
+        env: &napi::Env,
+        provider_config: provider::Config,
+        logger_config: logger::Config,
+        subscription_config: subscription::Config,
+        contract_decoder: Arc<ContractDecoder>,
+    ) -> napi::Result<Box<dyn provider::Builder>> {
+        let logger = Logger::<OpChainSpec>::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)?;
+
+        Ok(Box::new(ProviderBuilder::new(
+            contract_decoder,
+            Box::new(logger),
+            provider_config,
+            subscription_callback,
+        )))
+    }
+}
+
+/// Enumeration of supported OP hardforks.
+#[napi]
+pub enum OpHardfork {
+    Bedrock = 100,
+    Regolith = 101,
+    Canyon = 102,
+    Ecotone = 103,
+    Fjord = 104,
+    Granite = 105,
+    Holocene = 106,
+    Isthmus = 107,
+}
+
+impl From<OpHardfork> for OpSpecId {
+    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,
+        }
+    }
+}
+
+impl FromStr for OpHardfork {
+    type Err = napi::Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            edr_op::hardfork::name::BEDROCK => Ok(OpHardfork::Bedrock),
+            edr_op::hardfork::name::REGOLITH => Ok(OpHardfork::Regolith),
+            edr_op::hardfork::name::CANYON => Ok(OpHardfork::Canyon),
+            edr_op::hardfork::name::ECOTONE => Ok(OpHardfork::Ecotone),
+            edr_op::hardfork::name::FJORD => Ok(OpHardfork::Fjord),
+            edr_op::hardfork::name::GRANITE => Ok(OpHardfork::Granite),
+            edr_op::hardfork::name::HOLOCENE => Ok(OpHardfork::Holocene),
+            edr_op::hardfork::name::ISTHMUS => Ok(OpHardfork::Isthmus),
+            _ => Err(napi::Error::new(
+                napi::Status::InvalidArg,
+                format!("The provided OP hardfork `{s}` is not supported."),
+            )),
+        }
+    }
+}
+
+/// Tries to parse the provided string to create an [`OpHardfork`]
+/// instance.
+///
+/// Returns an error if the string does not match any known hardfork.
+#[napi]
+pub fn op_hardfork_from_string(hardfork: String) -> napi::Result<OpHardfork> {
+    hardfork.parse()
+}
+
+/// Returns the string representation of the provided OP hardfork.
+#[napi]
+pub fn op_hardfork_to_string(hardfork: OpHardfork) -> &'static str {
+    match hardfork {
+        OpHardfork::Bedrock => edr_op::hardfork::name::BEDROCK,
+        OpHardfork::Regolith => edr_op::hardfork::name::REGOLITH,
+        OpHardfork::Canyon => edr_op::hardfork::name::CANYON,
+        OpHardfork::Ecotone => edr_op::hardfork::name::ECOTONE,
+        OpHardfork::Fjord => edr_op::hardfork::name::FJORD,
+        OpHardfork::Granite => edr_op::hardfork::name::GRANITE,
+        OpHardfork::Holocene => edr_op::hardfork::name::HOLOCENE,
+        OpHardfork::Isthmus => edr_op::hardfork::name::ISTHMUS,
+    }
+}
+
+/// Returns the latest supported OP hardfork.
+///
+/// The returned value will be updated after each network upgrade.
+#[napi]
+pub fn op_latest_hardfork() -> OpHardfork {
+    OpHardfork::Holocene
+}
+
+#[napi]
+pub const OP_CHAIN_TYPE: &str = edr_op::CHAIN_TYPE;
+
+#[napi]
+pub fn op_genesis_state(_hardfork: OpHardfork) -> Vec<Account> {
+    let gas_price_oracle_code = hex::decode(include_str!(
+        "../../data/op/predeploys/gas_price_oracle.txt"
+    ))
+    .expect("The bytecode for the GasPriceOracle predeploy should be a valid hex string");
+    let gas_price_oracle = Account {
+        address: hex!("420000000000000000000000000000000000000F").into(),
+        balance: BigInt::from(0u64),
+        nonce: BigInt::from(0u64),
+        code: Some(gas_price_oracle_code.into()),
+        storage: vec![StorageSlot {
+            index: BigInt::from(0u64),
+            // bool isEcotone = true
+            // bool isFjord = true
+            value: BigInt::from(
+                0x0000000000000000000000000000000000000000000000000000000000000101u64,
+            ),
+        }],
+    };
+
+    let l1_block_code = hex::decode(include_str!("../../data/op/predeploys/l1_block.txt"))
+        .expect("The bytecode for the L1Block predeploy should be a valid hex string");
+    let l1_block = Account {
+        address: hex!("4200000000000000000000000000000000000015").into(),
+        balance: BigInt::from(0u64),
+        nonce: BigInt::from(0u64),
+        code: Some(l1_block_code.into()),
+        storage: vec![
+            StorageSlot {
+                index: BigInt::from(0u64),
+                // uint64 public number = 1
+                // uint64 public timestamp = 1
+                value: BigInt {
+                    words: vec![
+                        0x0000000000000001_u64, // least significative
+                        0x0000000000000001_u64,
+                    ],
+                    sign_bit: false,
+                },
+            },
+            StorageSlot {
+                index: BigInt::from(1u64),
+                // uint256 baseFee = 10 gwei
+                value: BigInt::from(0x00000002540be400_u64),
+            },
+            StorageSlot {
+                index: BigInt::from(2u64),
+                // bytes32 hash = 0
+                value: BigInt::from(0u64),
+            },
+            StorageSlot {
+                index: BigInt::from(3u64),
+                // uint64 sequenceNumber = 0
+                // uint32 blobBaseFeeScalar = 1014213
+                // uint32 baseFeeScalar = 5227
+                value: BigInt {
+                    words: vec![
+                        0x0000000000000000_u64, // least significative
+                        0x0000000000000000_u64,
+                        0x00000000000f79c5_u64,
+                        0x000000000000146b_u64,
+                    ],
+                    sign_bit: false,
+                },
+            },
+            StorageSlot {
+                index: BigInt::from(4u64),
+                // bytes32 batcherHash = 0
+                value: BigInt::from(0u64),
+            },
+            StorageSlot {
+                index: BigInt::from(5u64),
+                // uint256 l1FeeOverhead = 0
+                value: BigInt::from(0u64),
+            },
+            StorageSlot {
+                index: BigInt::from(6u64),
+                // uint256 l1FeeScalar = 0
+                value: BigInt::from(0u64),
+            },
+            StorageSlot {
+                index: BigInt::from(7u64),
+                // uint256 blobBaseFee = 10 gwei
+                value: BigInt::from(0x00000002540be400_u64),
+            },
+        ],
+    };
+
+    /* The rest of the predeploys use a stubbed bytecode that reverts with a
+               message indicating that the predeploy is not supported. For each of
+               them, the Solidity code that generates the bytecode is:
+
+    // SPDX-License-Identifier: Unlicense
+    pragma solidity ^0.8.0;
+
+    contract NotSupported {
+        fallback() external payable {
+            revert("Predeploy <PredeployName> is not supported.");
+        }
+    }
+            */
+    let stubbed_predeploys_data = vec![
+        (
+            "LegacyMessagePasser",
+            hex!("4200000000000000000000000000000000000000"),
+            "0x60806040526040517f08c379a000000000000000000000000000000000000000000000000000000000815260040160349060a1565b60405180910390fd5b60006048602f8360bf565b91507f5072656465706c6f79204c65676163794d65737361676550617373657220697360008301527f206e6f7420737570706f727465642e00000000000000000000000000000000006020830152604082019050919050565b6000602082019050818103600083015260b881603d565b9050919050565b60008282526020820190509291505056fea26469706673582212206ba272e31c33ce6fe2612b534c5aa5ed8905e1bed8a757ff1a74cc06509a17f664736f6c63430008000033",
+        ),
+        (
+            "DeployerWhitelist",
+            hex!("4200000000000000000000000000000000000002"),
+            "0x60806040526040517f08c379a000000000000000000000000000000000000000000000000000000000815260040160349060a1565b60405180910390fd5b60006048602d8360bf565b91507f5072656465706c6f79204465706c6f79657257686974656c697374206973206e60008301527f6f7420737570706f727465642e000000000000000000000000000000000000006020830152604082019050919050565b6000602082019050818103600083015260b881603d565b9050919050565b60008282526020820190509291505056fea26469706673582212206af5fc0549e5db963a08cb2864cbbf5c4e27efb08219fc0e29bda83f84b121ac64736f6c63430008000033",
+        ),
+        (
+            "LegacyERC20ETH",
+            hex!("DeadDeAddeAddEAddeadDEaDDEAdDeaDDeAD0000"),
+            "0x60806040526040517f08c379a000000000000000000000000000000000000000000000000000000000815260040160349060a1565b60405180910390fd5b60006048602a8360bf565b91507f5072656465706c6f79204c65676163794552433230455448206973206e6f742060008301527f737570706f727465642e000000000000000000000000000000000000000000006020830152604082019050919050565b6000602082019050818103600083015260b881603d565b9050919050565b60008282526020820190509291505056fea264697066735822122054e7f9d6c12400d5b4b67aed39be8c44a8b1461519e96a0e7764c69417239c7964736f6c63430008000033",
+        ),
+        (
+            "WETH9",
+            hex!("4200000000000000000000000000000000000006"),
+            "0x60806040526040517f08c379a000000000000000000000000000000000000000000000000000000000815260040160349060a1565b60405180910390fd5b6000604860218360bf565b91507f5072656465706c6f79205745544839206973206e6f7420737570706f7274656460008301527f2e000000000000000000000000000000000000000000000000000000000000006020830152604082019050919050565b6000602082019050818103600083015260b881603d565b9050919050565b60008282526020820190509291505056fea2646970667358221220860ec43d585e1b040780713555b6fc492d748c73586bdb8f2b9af441c4452dbf64736f6c63430008000033",
+        ),
+        (
+            "L2CrossDomainMessenger",
+            hex!("4200000000000000000000000000000000000007"),
+            "0x60806040526040517f08c379a000000000000000000000000000000000000000000000000000000000815260040160349060a1565b60405180910390fd5b6000604860328360bf565b91507f5072656465706c6f79204c3243726f7373446f6d61696e4d657373656e67657260008301527f206973206e6f7420737570706f727465642e00000000000000000000000000006020830152604082019050919050565b6000602082019050818103600083015260b881603d565b9050919050565b60008282526020820190509291505056fea26469706673582212200fadec69889de49a1a3a14d4e7e477e00921681e12650f510863d0077c16f58864736f6c63430008000033",
+        ),
+        (
+            "L2StandardBridge",
+            hex!("4200000000000000000000000000000000000010"),
+            "0x60806040526040517f08c379a000000000000000000000000000000000000000000000000000000000815260040160349060a1565b60405180910390fd5b60006048602c8360bf565b91507f5072656465706c6f79204c325374616e64617264427269646765206973206e6f60008301527f7420737570706f727465642e00000000000000000000000000000000000000006020830152604082019050919050565b6000602082019050818103600083015260b881603d565b9050919050565b60008282526020820190509291505056fea2646970667358221220ce5c24ee894b04d974b95cd204ab35f85906430ba6f49d1ea70d3d0c9c204cb764736f6c63430008000033",
+        ),
+        (
+            "SequencerFeeVault",
+            hex!("4200000000000000000000000000000000000011"),
+            "0x60806040526040517f08c379a000000000000000000000000000000000000000000000000000000000815260040160349060a1565b60405180910390fd5b60006048602d8360bf565b91507f5072656465706c6f792053657175656e6365724665655661756c74206973206e60008301527f6f7420737570706f727465642e000000000000000000000000000000000000006020830152604082019050919050565b6000602082019050818103600083015260b881603d565b9050919050565b60008282526020820190509291505056fea26469706673582212203990ed752a94bb02bd5162fef116c1b62079e8207c5164b3ae5a115f5cf0b31164736f6c63430008000033",
+        ),
+        (
+            "OptimismMintableERC20Factory",
+            hex!("4200000000000000000000000000000000000012"),
+            "0x60806040526040517f08c379a000000000000000000000000000000000000000000000000000000000815260040160349060a1565b60405180910390fd5b6000604860388360bf565b91507f5072656465706c6f79204f7074696d69736d4d696e7461626c6545524332304660008301527f6163746f7279206973206e6f7420737570706f727465642e00000000000000006020830152604082019050919050565b6000602082019050818103600083015260b881603d565b9050919050565b60008282526020820190509291505056fea2646970667358221220240605543d69b93641a24f1d153969c3969089a04a162fc9f18f95de926b385564736f6c63430008000033",
+        ),
+        (
+            "L1BlockNumber",
+            hex!("4200000000000000000000000000000000000013"),
+            "0x60806040526040517f08c379a000000000000000000000000000000000000000000000000000000000815260040160349060a1565b60405180910390fd5b6000604860298360bf565b91507f5072656465706c6f79204c31426c6f636b4e756d626572206973206e6f74207360008301527f7570706f727465642e00000000000000000000000000000000000000000000006020830152604082019050919050565b6000602082019050818103600083015260b881603d565b9050919050565b60008282526020820190509291505056fea264697066735822122099ba6da366313d162bab19a497fab2200808ddd24935b9f8be496c3622110b1164736f6c63430008000033",
+        ),
+        (
+            "GovernanceToken",
+            hex!("4200000000000000000000000000000000000042"),
+            "0x60806040526040517f08c379a000000000000000000000000000000000000000000000000000000000815260040160349060a1565b60405180910390fd5b60006048602b8360bf565b91507f5072656465706c6f7920476f7665726e616e6365546f6b656e206973206e6f7460008301527f20737570706f727465642e0000000000000000000000000000000000000000006020830152604082019050919050565b6000602082019050818103600083015260b881603d565b9050919050565b60008282526020820190509291505056fea26469706673582212205a22322e97c15d3a28eb86abac215ed31bcf6e0cf562e2679ce5fb3495953cfc64736f6c63430008000033",
+        ),
+        (
+            "L2ToL1MessagePasser",
+            hex!("4200000000000000000000000000000000000016"),
+            "0x60806040526040517f08c379a000000000000000000000000000000000000000000000000000000000815260040160349060a1565b60405180910390fd5b60006048602f8360bf565b91507f5072656465706c6f79204c32546f4c314d65737361676550617373657220697360008301527f206e6f7420737570706f727465642e00000000000000000000000000000000006020830152604082019050919050565b6000602082019050818103600083015260b881603d565b9050919050565b60008282526020820190509291505056fea26469706673582212205b2ed2ecc932d0e4a45e97ae7ac256e58848453ac06733b27890587962871a1864736f6c63430008000033",
+        ),
+        (
+            "L2ERC721Bridge",
+            hex!("4200000000000000000000000000000000000014"),
+            "0x60806040526040517f08c379a000000000000000000000000000000000000000000000000000000000815260040160349060a1565b60405180910390fd5b60006048602a8360bf565b91507f5072656465706c6f79204c32455243373231427269646765206973206e6f742060008301527f737570706f727465642e000000000000000000000000000000000000000000006020830152604082019050919050565b6000602082019050818103600083015260b881603d565b9050919050565b60008282526020820190509291505056fea26469706673582212203f9de306b34383b29e9dfb174fd424d7e11d31e8859d0e96a2aa3a46609e826c64736f6c63430008000033",
+        ),
+        (
+            "OptimismMintableERC721Factory",
+            hex!("4200000000000000000000000000000000000017"),
+            "0x60806040526040517f08c379a000000000000000000000000000000000000000000000000000000000815260040160349060a1565b60405180910390fd5b6000604860398360bf565b91507f5072656465706c6f79204f7074696d69736d4d696e7461626c6545524337323160008301527f466163746f7279206973206e6f7420737570706f727465642e000000000000006020830152604082019050919050565b6000602082019050818103600083015260b881603d565b9050919050565b60008282526020820190509291505056fea264697066735822122033131ae0c34f3246f5031971388431bd1dfb1b92d6b08d92a0a905911c1eeeeb64736f6c63430008000033",
+        ),
+        (
+            "ProxyAdmin",
+            hex!("4200000000000000000000000000000000000018"),
+            "0x60806040526040517f08c379a000000000000000000000000000000000000000000000000000000000815260040160349060a1565b60405180910390fd5b6000604860268360bf565b91507f5072656465706c6f792050726f787941646d696e206973206e6f74207375707060008301527f6f727465642e00000000000000000000000000000000000000000000000000006020830152604082019050919050565b6000602082019050818103600083015260b881603d565b9050919050565b60008282526020820190509291505056fea2646970667358221220c7b191ff1b21c73fb6a26fd1e972d6844631a700b7a316ca2d9e04905af44dbb64736f6c63430008000033",
+        ),
+        (
+            "BaseFeeVault",
+            hex!("4200000000000000000000000000000000000019"),
+            "0x60806040526040517f08c379a000000000000000000000000000000000000000000000000000000000815260040160349060a1565b60405180910390fd5b6000604860288360bf565b91507f5072656465706c6f7920426173654665655661756c74206973206e6f7420737560008301527f70706f727465642e0000000000000000000000000000000000000000000000006020830152604082019050919050565b6000602082019050818103600083015260b881603d565b9050919050565b60008282526020820190509291505056fea2646970667358221220535ae2b8a6393c0be4de1dce095f5e17fc0c7a46b40ac7793db894328f1799e764736f6c63430008000033",
+        ),
+        (
+            "L1FeeVault",
+            hex!("420000000000000000000000000000000000001a"),
+            "0x60806040526040517f08c379a000000000000000000000000000000000000000000000000000000000815260040160349060a1565b60405180910390fd5b6000604860268360bf565b91507f5072656465706c6f79204c314665655661756c74206973206e6f74207375707060008301527f6f727465642e00000000000000000000000000000000000000000000000000006020830152604082019050919050565b6000602082019050818103600083015260b881603d565b9050919050565b60008282526020820190509291505056fea2646970667358221220dac6ab093c79da782b6e98ec67c48758f6c1cb80cba58e080c114a9b8c93befc64736f6c63430008000033",
+        ),
+        (
+            "SchemaRegistry",
+            hex!("4200000000000000000000000000000000000020"),
+            "0x60806040526040517f08c379a000000000000000000000000000000000000000000000000000000000815260040160349060a1565b60405180910390fd5b60006048602a8360bf565b91507f5072656465706c6f7920536368656d615265676973747279206973206e6f742060008301527f737570706f727465642e000000000000000000000000000000000000000000006020830152604082019050919050565b6000602082019050818103600083015260b881603d565b9050919050565b60008282526020820190509291505056fea2646970667358221220b3daf5355920b581943cabb92a7cc67123467fdd1b054cb0c5f0e587c08da1be64736f6c63430008000033",
+        ),
+        (
+            "EAS",
+            hex!("4200000000000000000000000000000000000021"),
+            "0x60806040526040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401603490607b565b60405180910390fd5b60006048601f836099565b91507f5072656465706c6f7920454153206973206e6f7420737570706f727465642e006000830152602082019050919050565b60006020820190508181036000830152609281603d565b9050919050565b60008282526020820190509291505056fea2646970667358221220afa6c1aa54a8b3f4f979e1297db5838a94353f3b77b5ecc164da19db26ea89f564736f6c63430008000033",
+        ),
+    ];
+
+    let stubbed_predeploys = stubbed_predeploys_data
+        .iter()
+        .map(|(name, address, code)| Account {
+            address: address.into(),
+            balance: BigInt::from(0u64),
+            nonce: BigInt::from(0u64),
+            code: Some(
+                hex::decode(code)
+                    .unwrap_or_else(|e| panic!("The bytecode for the {name} predeploy should be a valid hex string, got error: {e}"))
+                    .into(),
+            ),
+            storage: vec![],
+        });
+
+    let predeploys = vec![gas_price_oracle, l1_block];
+
+    predeploys.into_iter().chain(stubbed_predeploys).collect()
+}
+
+#[napi]
+pub fn op_provider_factory() -> ProviderFactory {
+    let factory: Arc<dyn SyncProviderFactory> = Arc::new(OpProviderFactory);
+    factory.into()
+}
+
+macro_rules! export_spec_id {
+    ($($variant:ident,)*) => {
+        $(
+            #[napi]
+            pub const $variant: &str = edr_op::hardfork::name::$variant;
+        )*
+    };
+}
+
+export_spec_id! {
+    BEDROCK,
+    REGOLITH,
+    CANYON,
+    ECOTONE,
+    FJORD,
+    GRANITE,
+    HOLOCENE,
+    ISTHMUS,
+}