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

package/src/chains/op.rs

@@ -1,14 +1,25 @@
 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,
+        l1_block_code_bedrock, l1_block_code_ecotone, l1_block_code_isthmus,
+        GAS_PRICE_ORACLE_ADDRESS, L1_BLOCK_PREDEPLOY_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 +30,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))?;
+    ) -> 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 provider_config =
+            edr_provider::ProviderConfig::<edr_op::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::<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 +71,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,
         }
     }
 }
@@ -121,7 +136,7 @@ pub fn op_hardfork_to_string(hardfork: OpHardfork) -> &'static str {
 /// The returned value will be updated after each network upgrade.
 #[napi(catch_unwind)]
 pub fn op_latest_hardfork() -> OpHardfork {
-    OpHardfork::Holocene
+    OpHardfork::Isthmus
 }
 
 #[napi]
@@ -129,72 +144,13 @@ pub const OP_CHAIN_TYPE: &str = edr_op::CHAIN_TYPE;
 
 #[napi(catch_unwind)]
 pub fn op_genesis_state(hardfork: OpHardfork) -> Vec<AccountOverride> {
-    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_code = l1_block_code(hardfork.into());
     let l1_block = AccountOverride {
-        address: hex!("4200000000000000000000000000000000000015").into(),
+        address: Uint8Array::with_data_copied(L1_BLOCK_PREDEPLOY_ADDRESS),
         balance: Some(BigInt::from(0u64)),
         nonce: Some(BigInt::from(0u64)),
-        code: Some(l1_block_code.into()),
-        storage: Some(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),
-            },
-        ]),
+        code: Some(l1_block_code),
+        storage: Some(l1_block_storage(hardfork.into())),
     };
 
     /* The rest of the predeploys use a stubbed bytecode that reverts with a
@@ -301,6 +257,11 @@ pub fn op_genesis_state(hardfork: OpHardfork) -> Vec<AccountOverride> {
             hex!("4200000000000000000000000000000000000021"),
             "0x60806040526040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401603490607b565b60405180910390fd5b60006048601f836099565b91507f5072656465706c6f7920454153206973206e6f7420737570706f727465642e006000830152602082019050919050565b60006020820190508181036000830152609281603d565b9050919050565b60008282526020820190509291505056fea2646970667358221220afa6c1aa54a8b3f4f979e1297db5838a94353f3b77b5ecc164da19db26ea89f564736f6c63430008000033",
         ),
+        (
+            "OperatorFeeVault",
+            hex!("0x420000000000000000000000000000000000001b"),
+            "0x60806040526040517f08c379a000000000000000000000000000000000000000000000000000000000815260040160349060b9565b60405180910390fd5b5f82825260208201905092915050565b7f5072656465706c6f79204f70657261746f724665655661756c74206973206e6f5f8201527f7420737570706f727465642e0000000000000000000000000000000000000000602082015250565b5f60a5602c83603d565b915060ae82604d565b604082019050919050565b5f6020820190508181035f83015260ce81609b565b905091905056fea2646970667358221220dc3131d0ea77326c36012aee5dd9a870b6f07d76e6f55c8029da9d70a83f50c364736f6c634300081e0033",
+        ),
     ];
 
     let stubbed_predeploys = stubbed_predeploys_data
@@ -328,10 +289,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 +300,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 +316,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 +333,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
@@ -403,6 +349,85 @@ fn gas_price_oracle_isthmus() -> AccountOverride {
         }]),
     }
 }
+fn l1_block_storage(hardfork: edr_op::Hardfork) -> Vec<StorageSlot> {
+    let mut base_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),
+        },
+    ];
+    if hardfork >= edr_op::Hardfork::ISTHMUS {
+        base_storage.push(StorageSlot {
+            // Operator fee parameters
+            index: BigInt::from(8u64),
+            value: BigInt::from(0u64),
+        });
+    }
+    base_storage
+}
+
+fn l1_block_code(hardfork: edr_op::Hardfork) -> Uint8Array {
+    if hardfork >= edr_op::Hardfork::ISTHMUS {
+        l1_block_code_isthmus().into()
+    } else if hardfork >= edr_op::Hardfork::ECOTONE {
+        l1_block_code_ecotone().into()
+    } else {
+        l1_block_code_bedrock().into()
+    }
+}
 
 macro_rules! export_spec_id {
     ($($variant:ident,)*) => {

package/src/config.rs

@@ -6,10 +6,10 @@ use std::{
 };
 
 use edr_coverage::reporter::SyncOnCollectedCoverageCallback;
-use edr_eth::{
-    signature::{secret_key_from_str, SecretKey},
-    Bytes, HashMap, HashSet,
-};
+use edr_eip1559::{BaseFeeActivation, ConstantBaseFeeParams};
+use edr_gas_report::SyncOnCollectedGasReportCallback;
+use edr_primitives::{Bytes, HashMap, HashSet};
+use edr_signer::{secret_key_from_str, SecretKey};
 use napi::{
     bindgen_prelude::{BigInt, Promise, Reference, Uint8Array},
     threadsafe_function::{
@@ -20,7 +20,53 @@ use napi::{
 };
 use napi_derive::napi;
 
-use crate::{account::AccountOverride, block::BlobGas, cast::TryCast, precompile::Precompile};
+use crate::{
+    account::AccountOverride, block::BlobGas, cast::TryCast, gas_report::GasReport,
+    logger::LoggerConfig, precompile::Precompile, subscription::SubscriptionConfig,
+};
+
+/// Configuration for EIP-1559 parameters
+#[napi(object)]
+pub struct BaseFeeParamActivation {
+    pub activation: Either<BaseFeeActivationByBlockNumber, BaseFeeActivationByHardfork>,
+    pub max_change_denominator: BigInt,
+    pub elasticity_multiplier: BigInt,
+}
+
+#[napi(object)]
+pub struct BaseFeeActivationByBlockNumber {
+    /// The block number at which the `base_fee_params` is activated
+    pub block_number: BigInt,
+}
+#[napi(object)]
+pub struct BaseFeeActivationByHardfork {
+    /// The hardfork at which the `base_fee_params` is activated
+    pub hardfork: String,
+}
+
+impl TryFrom<BaseFeeParamActivation> for (BaseFeeActivation<String>, ConstantBaseFeeParams) {
+    type Error = napi::Error;
+
+    fn try_from(value: BaseFeeParamActivation) -> Result<Self, Self::Error> {
+        let base_fee_params = ConstantBaseFeeParams {
+            max_change_denominator: value.max_change_denominator.try_cast()?,
+            elasticity_multiplier: value.elasticity_multiplier.try_cast()?,
+        };
+
+        match value.activation {
+            Either::A(BaseFeeActivationByBlockNumber { block_number }) => {
+                let activation_block_number: u64 = block_number.try_cast()?;
+                Ok((
+                    BaseFeeActivation::BlockNumber(activation_block_number),
+                    base_fee_params,
+                ))
+            }
+            Either::B(BaseFeeActivationByHardfork { hardfork }) => {
+                Ok((BaseFeeActivation::Hardfork(hardfork), base_fee_params))
+            }
+        }
+    }
+}
 
 /// Specification of a chain with possible overrides.
 #[napi(object)]
@@ -47,6 +93,17 @@ pub struct CodeCoverageConfig {
     pub on_collected_coverage_callback: JsFunction,
 }
 
+#[napi(object)]
+pub struct GasReportConfig {
+    /// Gas reports are collected after a block is mined or `eth_call` is
+    /// executed.
+    ///
+    /// Exceptions thrown in the callback will be propagated to the original
+    /// caller.
+    #[napi(ts_type = "(gasReport: GasReport) => Promise<void>")]
+    pub on_collected_gas_report_callback: JsFunction,
+}
+
 /// Configuration for forking a blockchain
 #[napi(object)]
 pub struct ForkConfig {
@@ -124,6 +181,8 @@ pub struct MiningConfig {
 pub struct ObservabilityConfig {
     /// If present, configures runtime observability to collect code coverage.
     pub code_coverage: Option<CodeCoverageConfig>,
+    /// If present, configures runtime observability to collect gas reports.
+    pub gas_report: Option<GasReportConfig>,
 }
 
 /// Configuration for a provider
@@ -137,6 +196,15 @@ pub struct ProviderConfig {
     pub bail_on_call_failure: bool,
     /// Whether to return an `Err` when a `eth_sendTransaction` fails
     pub bail_on_transaction_failure: bool,
+    /// 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.
+    pub base_fee_config: Option<Vec<BaseFeeParamActivation>>,
     /// The gas limit of each block
     pub block_gas_limit: BigInt,
     /// The chain ID of the blockchain
@@ -174,6 +242,12 @@ pub struct ProviderConfig {
     pub owned_accounts: Vec<JsString>,
     /// Overrides for precompiles
     pub precompile_overrides: Vec<Reference<Precompile>>,
+    /// Transaction gas cap, introduced in [EIP-7825].
+    ///
+    /// When not set, will default to value defined by the used hardfork
+    ///
+    /// [EIP-7825]: https://eips.ethereum.org/EIPS/eip-7825
+    pub transaction_gas_cap: Option<BigInt>,
 }
 
 impl TryFrom<ForkConfig> for edr_provider::ForkConfig<String> {
@@ -212,28 +286,28 @@ impl TryFrom<ForkConfig> for edr_provider::ForkConfig<String> {
                                         let condition = match condition {
                                             Either::A(HardforkActivationByBlockNumber {
                                                 block_number,
-                                            }) => edr_evm::hardfork::ForkCondition::Block(
+                                            }) => edr_chain_config::ForkCondition::Block(
                                                 block_number.try_cast()?,
                                             ),
                                             Either::B(HardforkActivationByTimestamp {
                                                 timestamp,
-                                            }) => edr_evm::hardfork::ForkCondition::Timestamp(
+                                            }) => edr_chain_config::ForkCondition::Timestamp(
                                                 timestamp.try_cast()?,
                                             ),
                                         };
 
-                                        Ok(edr_evm::hardfork::Activation {
+                                        Ok(edr_chain_config::HardforkActivation {
                                             condition,
                                             hardfork,
                                         })
                                     },
                                 )
                                 .collect::<napi::Result<Vec<_>>>()
-                                .map(edr_evm::hardfork::Activations::new)
+                                .map(edr_chain_config::HardforkActivations::new)
                                     })
                                     .transpose()?;
 
-                            let chain_config = edr_evm::hardfork::ChainOverride {
+                            let chain_config = edr_chain_config::ChainOverride {
                                 name,
                                 hardfork_activation_overrides,
                             };
@@ -271,7 +345,7 @@ impl From<MemPoolConfig> for edr_provider::MemPoolConfig {
     }
 }
 
-impl From<MineOrdering> for edr_evm::MineOrdering {
+impl From<MineOrdering> for edr_block_miner::MineOrdering {
     fn from(value: MineOrdering) -> Self {
         match value {
             MineOrdering::Fifo => Self::Fifo,
@@ -331,6 +405,8 @@ impl ObservabilityConfig {
             .code_coverage
             .map(
                 |code_coverage| -> napi::Result<Box<dyn SyncOnCollectedCoverageCallback>> {
+                    let runtime = runtime.clone();
+
                     let mut on_collected_coverage_callback: ThreadsafeFunction<
                         _,
                         ErrorStrategy::Fatal,
@@ -385,10 +461,10 @@ impl ObservabilityConfig {
                                     Ok(())
                                 });
 
-                            let () = receiver.recv().expect("Receive can only fail if the channel is closed")?;
-
                             assert_eq!(status, napi::Status::Ok);
 
+                            let () = receiver.recv().expect("Receive can only fail if the channel is closed")?;
+
                             Ok(())
                         });
 
@@ -396,9 +472,61 @@ impl ObservabilityConfig {
                 },
             )
             .transpose()?;
+        let on_collected_gas_report_fn = self.gas_report.map(
+            |gas_report| -> napi::Result<Box<dyn SyncOnCollectedGasReportCallback>> {
+                let mut on_collected_gas_report_callback: ThreadsafeFunction<
+                    _,
+                    ErrorStrategy::Fatal,
+                > = gas_report
+                    .on_collected_gas_report_callback
+                    .create_threadsafe_function(
+                        0,
+                        |ctx: ThreadSafeCallContext<GasReport>| {
+                            let report = ctx.value;
+                            Ok(vec![report])
+                        }
+                        ,
+                    )?;
+                // Maintain a weak reference to the function to avoid blocking the event loop
+                // from exiting.
+                on_collected_gas_report_callback.unref(env)?;
+
+                let on_collected_gas_report_fn: Box<dyn SyncOnCollectedGasReportCallback> =
+                    Box::new(move |report| {
+                        let runtime = runtime.clone();
+
+                        let (sender, receiver) = std::sync::mpsc::channel();
+
+                        // Convert the report to the N-API representation
+                        let status = on_collected_gas_report_callback
+                            .call_with_return_value(GasReport::from(report), ThreadsafeFunctionCallMode::Blocking, move |result: Promise<()>| {
+                                // We spawn a background task to handle the async callback
+                                runtime.spawn(async move {
+                                    let result = result.await;
+                                    sender.send(result).map_err(|_error| {
+                                        napi::Error::new(
+                                            napi::Status::GenericFailure,
+                                            "Failed to send result from on_collected_gas_report_callback",
+                                        )
+                                    })
+                                });
+                                Ok(())
+                            });
+
+                        assert_eq!(status, napi::Status::Ok);
+
+                        let () = receiver.recv().expect("Receive can only fail if the channel is closed")?;
+
+                        Ok(())
+                    });
+
+                Ok(on_collected_gas_report_fn)
+            },
+        ).transpose()?;
 
         Ok(edr_provider::observability::Config {
             on_collected_coverage_fn,
+            on_collected_gas_report_fn,
             ..edr_provider::observability::Config::default()
         })
     }
@@ -418,7 +546,7 @@ impl ProviderConfig {
                 // This is the only place in production code where it's allowed to use
                 // `DangerousSecretKeyStr`.
                 #[allow(deprecated)]
-                use edr_eth::signature::DangerousSecretKeyStr;
+                use edr_signer::DangerousSecretKeyStr;
 
                 static_assertions::assert_not_impl_all!(JsString: Debug, Display, serde::Serialize);
                 static_assertions::assert_not_impl_all!(JsStringUtf8: Debug, Display, serde::Serialize);
@@ -438,6 +566,11 @@ impl ProviderConfig {
             })
             .collect::<napi::Result<Vec<_>>>()?;
 
+        let base_fee_params: Option<Vec<(BaseFeeActivation<String>, ConstantBaseFeeParams)>> = self
+            .base_fee_config
+            .map(|vec| vec.into_iter().map(TryInto::try_into).collect())
+            .transpose()?;
+
         let block_gas_limit =
             NonZeroU64::new(self.block_gas_limit.try_cast()?).ok_or_else(|| {
                 napi::Error::new(
@@ -450,7 +583,7 @@ impl ProviderConfig {
             .genesis_state
             .into_iter()
             .map(TryInto::try_into)
-            .collect::<napi::Result<HashMap<edr_eth::Address, edr_provider::AccountOverride>>>()?;
+            .collect::<napi::Result<HashMap<edr_primitives::Address, edr_provider::AccountOverride>>>()?;
 
         let precompile_overrides = self
             .precompile_overrides
@@ -463,6 +596,7 @@ impl ProviderConfig {
             allow_unlimited_contract_size: self.allow_unlimited_contract_size,
             bail_on_call_failure: self.bail_on_call_failure,
             bail_on_transaction_failure: self.bail_on_transaction_failure,
+            base_fee_params,
             block_gas_limit,
             chain_id: self.chain_id.try_cast()?,
             coinbase: self.coinbase.try_cast()?,
@@ -491,6 +625,10 @@ impl ProviderConfig {
             observability: self.observability.resolve(env, runtime)?,
             owned_accounts,
             precompile_overrides,
+            transaction_gas_cap: self
+                .transaction_gas_cap
+                .map(TryCast::try_cast)
+                .transpose()?,
         })
     }
 }
@@ -541,3 +679,32 @@ impl From<BuildInfoAndOutput> for edr_napi_core::solidity::config::BuildInfoAndO
         }
     }
 }
+
+/// Result of [`resolve_configs`].
+pub struct ConfigResolution {
+    pub logger_config: edr_napi_core::logger::Config,
+    pub provider_config: edr_napi_core::provider::Config,
+    pub subscription_callback: edr_napi_core::subscription::Callback,
+}
+
+/// Helper function for resolving the provided N-API configs.
+pub fn resolve_configs(
+    env: &napi::Env,
+    runtime: runtime::Handle,
+    provider_config: ProviderConfig,
+    logger_config: LoggerConfig,
+    subscription_config: SubscriptionConfig,
+) -> napi::Result<ConfigResolution> {
+    let provider_config = provider_config.resolve(env, runtime)?;
+    let logger_config = logger_config.resolve(env)?;
+
+    let subscription_config = edr_napi_core::subscription::Config::from(subscription_config);
+    let subscription_callback =
+        edr_napi_core::subscription::Callback::new(env, subscription_config.subscription_callback)?;
+
+    Ok(ConfigResolution {
+        logger_config,
+        provider_config,
+        subscription_callback,
+    })
+}