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

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
@@ -331,6 +399,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 +455,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 +466,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 +540,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 +560,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 +577,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 +590,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()?,
@@ -541,3 +669,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,
+    })
+}

package/src/context.rs

@@ -1,11 +1,7 @@
 use std::sync::Arc;
 
-use edr_eth::HashMap;
-use edr_napi_core::{
-    provider::{self, SyncProviderFactory},
-    solidity,
-};
-use edr_solidity::contract_decoder::ContractDecoder;
+use edr_napi_core::{provider::SyncProviderFactory, solidity};
+use edr_primitives::HashMap;
 use edr_solidity_tests::{
     decode::RevertDecoder,
     multi_runner::{SuiteResultAndArtifactId, TestContract, TestContracts},
@@ -22,14 +18,15 @@ use napi_derive::napi;
 use tracing_subscriber::{prelude::*, EnvFilter, Registry};
 
 use crate::{
-    config::{ProviderConfig, TracingConfigWithBuffers},
+    config::{resolve_configs, ConfigResolution, ProviderConfig, TracingConfigWithBuffers},
+    contract_decoder::ContractDecoder,
     logger::LoggerConfig,
     provider::{Provider, ProviderFactory},
     solidity_tests::{
         artifact::{Artifact, ArtifactId},
         config::SolidityTestRunnerConfigArgs,
         factory::SolidityTestRunnerFactory,
-        test_results::SuiteResult,
+        test_results::{SolidityTestResult, SuiteResult},
         LinkingOutput,
     },
     subscription::SubscriptionConfig,
@@ -42,7 +39,7 @@ pub struct EdrContext {
 
 #[napi]
 impl EdrContext {
-    #[doc = "Creates a new [`EdrContext`] instance. Should only be called once!"]
+    /// Creates a new [`EdrContext`] instance. Should only be called once!
     #[napi(catch_unwind, constructor)]
     pub fn new() -> napi::Result<Self> {
         let context = Context::new()?;
@@ -52,7 +49,7 @@ impl EdrContext {
         })
     }
 
-    #[doc = "Constructs a new provider with the provided configuration."]
+    /// Constructs a new provider with the provided configuration.
     #[napi(catch_unwind, ts_return_type = "Promise<Provider>")]
     pub fn create_provider(
         &self,
@@ -61,7 +58,7 @@ impl EdrContext {
         provider_config: ProviderConfig,
         logger_config: LoggerConfig,
         subscription_config: SubscriptionConfig,
-        tracing_config: TracingConfigWithBuffers,
+        contract_decoder: &ContractDecoder,
     ) -> napi::Result<JsObject> {
         let (deferred, promise) = env.create_deferred()?;
 
@@ -78,25 +75,18 @@ impl EdrContext {
         }
 
         let runtime = runtime::Handle::current();
-        let provider_config =
-            try_or_reject_promise!(provider_config.resolve(&env, runtime.clone()));
-
-        let logger_config = try_or_reject_promise!(logger_config.resolve(&env));
-
-        // TODO: https://github.com/NomicFoundation/edr/issues/760
-        let build_info_config = try_or_reject_promise!(
-            edr_solidity::artifacts::BuildInfoConfig::parse_from_buffers(
-                (&edr_napi_core::solidity::config::TracingConfigWithBuffers::from(tracing_config))
-                    .into(),
-            )
-            .map_err(|error| napi::Error::from_reason(error.to_string()))
-        );
-
-        let contract_decoder = try_or_reject_promise!(ContractDecoder::new(&build_info_config)
-            .map_or_else(
-                |error| Err(napi::Error::from_reason(error.to_string())),
-                |contract_decoder| Ok(Arc::new(contract_decoder))
-            ));
+
+        let ConfigResolution {
+            logger_config,
+            provider_config,
+            subscription_callback,
+        } = try_or_reject_promise!(resolve_configs(
+            &env,
+            runtime.clone(),
+            provider_config,
+            logger_config,
+            subscription_config,
+        ));
 
         #[cfg(feature = "scenarios")]
         let scenario_file =
@@ -106,31 +96,33 @@ impl EdrContext {
                 logger_config.enable,
             )));
 
-        let builder = {
+        let factory = {
             // TODO: https://github.com/NomicFoundation/edr/issues/760
             // TODO: Don't block the JS event loop
             let context = runtime.block_on(async { self.inner.lock().await });
 
-            try_or_reject_promise!(context.create_provider_builder(
-                &env,
-                &chain_type,
-                provider_config,
-                logger_config,
-                subscription_config.into(),
-                &contract_decoder,
-            ))
+            try_or_reject_promise!(context.get_provider_factory(&chain_type))
         };
 
+        let contract_decoder = Arc::clone(contract_decoder.as_inner());
         runtime.clone().spawn_blocking(move || {
-            let result = builder.build(runtime.clone()).map(|provider| {
-                Provider::new(
-                    provider,
-                    runtime,
-                    contract_decoder,
-                    #[cfg(feature = "scenarios")]
-                    scenario_file,
+            let result = factory
+                .create_provider(
+                    runtime.clone(),
+                    provider_config,
+                    logger_config,
+                    subscription_callback,
+                    Arc::clone(&contract_decoder),
                 )
-            });
+                .map(|provider| {
+                    Provider::new(
+                        provider,
+                        runtime,
+                        contract_decoder,
+                        #[cfg(feature = "scenarios")]
+                        scenario_file,
+                    )
+                });
 
             deferred.resolve(|_env| result);
         });
@@ -138,7 +130,7 @@ impl EdrContext {
         Ok(promise)
     }
 
-    #[doc = "Registers a new provider factory for the provided chain type."]
+    /// Registers a new provider factory for the provided chain type.
     #[napi(catch_unwind)]
     pub async fn register_provider_factory(
         &self,
@@ -161,14 +153,29 @@ impl EdrContext {
         Ok(())
     }
 
-    #[doc = "Executes Solidity tests."]
-    #[doc = ""]
-    #[doc = "The function will return as soon as test execution is started."]
-    #[doc = "The progress callback will be called with the results of each test"]
-    #[doc = "suite. It is up to the caller to track how many times the callback"]
-    #[doc = "is called to know when all tests are done."]
+    /// Executes Solidity tests
+    ///
+    /// The function will return a promise that resolves to a
+    /// [`SolidityTestResult`].
+    ///
+    /// Arguments:
+    /// - `chainType`: the same chain type that was passed to
+    ///   `registerProviderFactory`.
+    /// - `artifacts`: the project's compilation output artifacts. It's
+    ///   important to include include all artifacts here, otherwise cheatcodes
+    ///   that access artifacts and other functionality (e.g. auto-linking, gas
+    ///   reports) can break.
+    /// - `testSuites`: the test suite ids that specify which test suites to
+    ///   execute. The test suite artifacts must be present in `artifacts`.
+    /// - `configArgs`: solidity test runner configuration. See the struct docs
+    ///   for details.
+    /// - `tracingConfig`: the build infos used for stack trace generation.
+    ///   These are lazily parsed and it's important that they're passed as
+    ///   Uint8 arrays for performance.
+    /// - `onTestSuiteCompletedCallback`: The progress callback will be called
+    ///   with the results of each test suite as soon as it finished executing.
     #[allow(clippy::too_many_arguments)]
-    #[napi(catch_unwind, ts_return_type = "Promise<void>")]
+    #[napi(catch_unwind, ts_return_type = "Promise<SolidityTestResult>")]
     pub fn run_solidity_tests(
         &self,
         env: Env,
@@ -281,11 +288,12 @@ impl EdrContext {
 
             let include_traces = config.include_traces.into();
 
+            let runtime_for_factory = runtime.clone();
             let test_runner = try_or_reject_deferred!(runtime
                 .clone()
                 .spawn_blocking(move || {
                     factory.create_test_runner(
-                        runtime,
+                        runtime_for_factory,
                         config,
                         contracts,
                         linking_output.known_contracts,
@@ -297,30 +305,40 @@ impl EdrContext {
                 .await
                 .expect("Failed to join test runner factory thread"));
 
-            let () = try_or_reject_deferred!(test_runner.run_tests(
-                test_filter,
-                Arc::new(
-                    move |SuiteResultAndArtifactId {
-                              artifact_id,
-                              result,
-                          }| {
-                        let suite_result = SuiteResult::new(artifact_id, result, include_traces);
-
-                        let status = on_test_suite_completed_callback
-                            .call(suite_result, ThreadsafeFunctionCallMode::Blocking);
-
-                        // This should always succeed since we're using an unbounded queue. We add
-                        // an assertion for completeness.
-                        assert_eq!(
+            let runtime_for_runner = runtime.clone();
+            let test_result = try_or_reject_deferred!(runtime
+                .clone()
+                .spawn_blocking(move || {
+                    test_runner.run_tests(
+                        runtime_for_runner,
+                        test_filter,
+                        Arc::new(
+                            move |SuiteResultAndArtifactId {
+                                      artifact_id,
+                                      result,
+                                  }| {
+                                let suite_result =
+                                    SuiteResult::new(artifact_id, result, include_traces);
+
+                                let status = on_test_suite_completed_callback
+                                    .call(suite_result, ThreadsafeFunctionCallMode::Blocking);
+
+                                // This should always succeed since we're using an unbounded queue.
+                                // We add an assertion for
+                                // completeness.
+                                assert_eq!(
                             status,
                             napi::Status::Ok,
                             "Failed to call on_test_suite_completed_callback with status: {status}"
                         );
-                    }
-                ),
-            ));
+                            },
+                        ),
+                    )
+                })
+                .await
+                .expect("Failed to join test runner thread"));
 
-            deferred.resolve(move |_env| Ok(()));
+            deferred.resolve(move |_env| Ok(SolidityTestResult::from(test_result)));
         });
 
         Ok(promise)
@@ -399,23 +417,12 @@ impl Context {
 
     /// Tries to create a new provider for the provided chain type and
     /// configuration.
-    pub fn create_provider_builder(
+    pub fn get_provider_factory(
         &self,
-        env: &napi::Env,
         chain_type: &str,
-        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>> {
+    ) -> napi::Result<Arc<dyn SyncProviderFactory>> {
         if let Some(factory) = self.provider_factories.get(chain_type) {
-            factory.create_provider_builder(
-                env,
-                provider_config,
-                logger_config,
-                subscription_config,
-                contract_decoder.clone(),
-            )
+            Ok(Arc::clone(factory))
         } else {
             Err(napi::Error::new(
                 napi::Status::GenericFailure,

package/src/contract_decoder.rs

@@ -0,0 +1,57 @@
+use std::sync::Arc;
+
+use napi_derive::napi;
+
+use crate::config::TracingConfigWithBuffers;
+
+#[napi]
+pub struct ContractDecoder {
+    inner: Arc<edr_solidity::contract_decoder::ContractDecoder>,
+}
+
+#[napi]
+impl ContractDecoder {
+    #[doc = "Creates an empty instance."]
+    #[napi(constructor, catch_unwind)]
+    // Following TS convention for the constructor without arguments to be `new()`.
+    #[allow(clippy::new_without_default)]
+    pub fn new() -> Self {
+        Self {
+            inner: Arc::new(edr_solidity::contract_decoder::ContractDecoder::default()),
+        }
+    }
+
+    #[doc = "Creates a new instance with the provided configuration."]
+    #[napi(factory, catch_unwind)]
+    pub fn with_contracts(config: TracingConfigWithBuffers) -> napi::Result<Self> {
+        let build_info_config = edr_solidity::artifacts::BuildInfoConfig::parse_from_buffers(
+            (&edr_napi_core::solidity::config::TracingConfigWithBuffers::from(config)).into(),
+        )
+        .map_err(|error| napi::Error::from_reason(error.to_string()))?;
+
+        let contract_decoder =
+            edr_solidity::contract_decoder::ContractDecoder::new(&build_info_config).map_or_else(
+                |error| Err(napi::Error::from_reason(error.to_string())),
+                |contract_decoder| Ok(Arc::new(contract_decoder)),
+            )?;
+
+        Ok(Self {
+            inner: contract_decoder,
+        })
+    }
+}
+
+impl ContractDecoder {
+    /// Returns a reference to the inner contract decoder.
+    pub fn as_inner(&self) -> &Arc<edr_solidity::contract_decoder::ContractDecoder> {
+        &self.inner
+    }
+}
+
+impl From<Arc<edr_solidity::contract_decoder::ContractDecoder>> for ContractDecoder {
+    fn from(contract_decoder: Arc<edr_solidity::contract_decoder::ContractDecoder>) -> Self {
+        Self {
+            inner: contract_decoder,
+        }
+    }
+}

package/src/debug_trace.rs

@@ -3,6 +3,8 @@ use std::collections::HashMap;
 use napi::bindgen_prelude::{BigInt, Uint8Array};
 use napi_derive::napi;
 
+// False positive: imported by HH2
+#[allow(dead_code)]
 #[napi(object)]
 pub struct DebugTraceResult {
     pub pass: bool,