@nomicfoundation/edr 0.12.0-next.1 → 0.12.0-next.14

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> {
@@ -136,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::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),
             _ => Err(napi::Error::new(
                 napi::Status::InvalidArg,
                 format!("The provided hardfork `{s}` is not supported."),
@@ -163,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,
         }
     }
 }
@@ -200,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::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,
     }
 }
 
@@ -234,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::chains::name::$variant;
         )*
     };
 }

package/src/chains/op.rs

@@ -1,14 +1,24 @@
 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_code_ecotone, gas_price_oracle_code_fjord, gas_price_oracle_code_isthmus,
+        GAS_PRICE_ORACLE_ADDRESS,
+    },
+    OpChainSpec,
+};
+use edr_primitives::hex;
+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::{
@@ -19,27 +29,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>> {
-        let logger = Logger::<OpChainSpec>::new(logger_config, Arc::clone(&contract_decoder))?;
-
-        let provider_config = edr_provider::ProviderConfig::<OpSpecId>::try_from(provider_config)?;
+    ) -> napi::Result<Arc<dyn SyncProvider>> {
+        let logger =
+            Logger::<OpChainSpec, CurrentTime>::new(logger_config, Arc::clone(&contract_decoder))?;
 
-        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))
     }
 }
 
@@ -56,17 +70,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,
         }
     }
 }
@@ -328,10 +342,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()
@@ -339,16 +353,11 @@ fn gas_price_oracle_override(hardfork: OpSpecId) -> AccountOverride {
 }
 
 fn gas_price_oracle_ecotone() -> AccountOverride {
-    let gas_price_oracle_code = hex::decode(include_str!(
-        "../../data/op/predeploys/gas_price_oracle/ecotone.txt"
-    ))
-    .expect("The bytecode for the GasPriceOracle predeploy should be a valid hex string");
-
     AccountOverride {
         address: Uint8Array::with_data_copied(GAS_PRICE_ORACLE_ADDRESS),
         balance: None,
         nonce: None,
-        code: Some(gas_price_oracle_code.into()),
+        code: Some(gas_price_oracle_code_ecotone().into()),
         storage: Some(vec![StorageSlot {
             index: BigInt::from(0u64),
             // bool isEcotone = true
@@ -360,16 +369,11 @@ fn gas_price_oracle_ecotone() -> AccountOverride {
 }
 
 fn gas_price_oracle_fjord() -> AccountOverride {
-    let gas_price_oracle_code = hex::decode(include_str!(
-        "../../data/op/predeploys/gas_price_oracle/fjord.txt"
-    ))
-    .expect("The bytecode for the GasPriceOracle predeploy should be a valid hex string");
-
     AccountOverride {
         address: Uint8Array::with_data_copied(GAS_PRICE_ORACLE_ADDRESS),
         balance: None,
         nonce: None,
-        code: Some(gas_price_oracle_code.into()),
+        code: Some(gas_price_oracle_code_fjord().into()),
         storage: Some(vec![StorageSlot {
             index: BigInt::from(0u64),
             // bool isEcotone = true
@@ -382,16 +386,11 @@ fn gas_price_oracle_fjord() -> AccountOverride {
 }
 
 fn gas_price_oracle_isthmus() -> AccountOverride {
-    let gas_price_oracle_code = hex::decode(include_str!(
-        "../../data/op/predeploys/gas_price_oracle/isthmus.txt"
-    ))
-    .expect("The bytecode for the GasPriceOracle predeploy should be a valid hex string");
-
     AccountOverride {
         address: Uint8Array::with_data_copied(GAS_PRICE_ORACLE_ADDRESS),
         balance: None,
         nonce: None,
-        code: Some(gas_price_oracle_code.into()),
+        code: Some(gas_price_oracle_code_isthmus().into()),
         storage: Some(vec![StorageSlot {
             index: BigInt::from(0u64),
             // bool isEcotone = true