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

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,
@@ -299,7 +306,7 @@ impl EdrContext {
                 .expect("Failed to join test runner factory thread"));
 
             let runtime_for_runner = runtime.clone();
-            let () = try_or_reject_deferred!(runtime
+            let test_result = try_or_reject_deferred!(runtime
                 .clone()
                 .spawn_blocking(move || {
                     test_runner.run_tests(
@@ -331,7 +338,7 @@ impl EdrContext {
                 .await
                 .expect("Failed to join test runner thread"));
 
-            deferred.resolve(move |_env| Ok(()));
+            deferred.resolve(move |_env| Ok(SolidityTestResult::from(test_result)));
         });
 
         Ok(promise)
@@ -383,8 +390,8 @@ impl Context {
         }
 
         Ok(Self {
-            provider_factories: HashMap::new(),
-            solidity_test_runner_factories: HashMap::new(),
+            provider_factories: HashMap::default(),
+            solidity_test_runner_factories: HashMap::default(),
             #[cfg(feature = "tracing")]
             _tracing_write_guard: guard,
         })
@@ -410,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,

package/src/gas_report.rs

@@ -0,0 +1,92 @@
+use std::collections::HashMap;
+
+use napi::bindgen_prelude::BigInt;
+use napi_derive::napi;
+
+#[napi(object)]
+pub struct GasReport {
+    pub contracts: HashMap<String, ContractGasReport>,
+}
+
+#[napi(object)]
+pub struct ContractGasReport {
+    pub deployments: Vec<DeploymentGasReport>,
+    pub functions: HashMap<String, Vec<FunctionGasReport>>,
+}
+
+#[napi]
+pub enum GasReportExecutionStatus {
+    Success,
+    Revert,
+    Halt,
+}
+
+#[napi(object)]
+pub struct DeploymentGasReport {
+    pub gas: BigInt,
+    pub size: BigInt,
+    pub status: GasReportExecutionStatus,
+}
+
+#[napi(object)]
+pub struct FunctionGasReport {
+    pub gas: BigInt,
+    pub status: GasReportExecutionStatus,
+}
+
+impl From<edr_gas_report::GasReport> for GasReport {
+    fn from(value: edr_gas_report::GasReport) -> Self {
+        Self {
+            contracts: value
+                .into_inner()
+                .into_iter()
+                .map(|(k, v)| (k, v.into()))
+                .collect(),
+        }
+    }
+}
+
+impl From<edr_gas_report::ContractGasReport> for ContractGasReport {
+    fn from(value: edr_gas_report::ContractGasReport) -> Self {
+        Self {
+            deployments: value.deployments.into_iter().map(Into::into).collect(),
+            functions: value
+                .functions
+                .into_iter()
+                .map(|(k, v)| {
+                    let function_reports = v.into_iter().map(FunctionGasReport::from).collect();
+                    (k, function_reports)
+                })
+                .collect(),
+        }
+    }
+}
+
+impl From<edr_gas_report::GasReportExecutionStatus> for GasReportExecutionStatus {
+    fn from(value: edr_gas_report::GasReportExecutionStatus) -> Self {
+        match value {
+            edr_gas_report::GasReportExecutionStatus::Success => Self::Success,
+            edr_gas_report::GasReportExecutionStatus::Revert => Self::Revert,
+            edr_gas_report::GasReportExecutionStatus::Halt => Self::Halt,
+        }
+    }
+}
+
+impl From<edr_gas_report::DeploymentGasReport> for DeploymentGasReport {
+    fn from(value: edr_gas_report::DeploymentGasReport) -> Self {
+        Self {
+            gas: BigInt::from(value.gas),
+            size: BigInt::from(value.size),
+            status: value.status.into(),
+        }
+    }
+}
+
+impl From<edr_gas_report::FunctionGasReport> for FunctionGasReport {
+    fn from(value: edr_gas_report::FunctionGasReport) -> Self {
+        Self {
+            gas: BigInt::from(value.gas),
+            status: value.status.into(),
+        }
+    }
+}

package/src/lib.rs

@@ -17,7 +17,10 @@ pub mod chains;
 pub mod config;
 /// Types related to an EDR N-API context.
 pub mod context;
+/// Types for decoding smart contract data.
+pub mod contract_decoder;
 mod debug_trace;
+pub mod gas_report;
 /// Types and functions related to code coverage instrumentation.
 pub mod instrument;
 /// Types for EVM execution logs.
@@ -26,7 +29,7 @@ pub mod log;
 pub mod logger;
 /// Types for mocking provider behavior.
 #[cfg(feature = "test-mock")]
-mod mock;
+pub mod mock;
 /// Types for precompiles.
 pub mod precompile;
 /// Types for Ethereum RPC providers.

package/src/log.rs

@@ -9,8 +9,8 @@ pub struct ExecutionLog {
     pub data: Uint8Array,
 }
 
-impl From<&edr_eth::log::ExecutionLog> for ExecutionLog {
-    fn from(value: &edr_eth::log::ExecutionLog) -> Self {
+impl From<&edr_receipt::log::ExecutionLog> for ExecutionLog {
+    fn from(value: &edr_receipt::log::ExecutionLog) -> Self {
         let topics = value
             .topics()
             .iter()

package/src/logger.rs

@@ -1,7 +1,7 @@
 use std::sync::{mpsc::channel, Arc};
 
-use edr_eth::Bytes;
 use edr_napi_core::logger::LoggerError;
+use edr_primitives::Bytes;
 use napi::{
     threadsafe_function::{
         ErrorStrategy, ThreadSafeCallContext, ThreadsafeFunction, ThreadsafeFunctionCallMode,
@@ -65,7 +65,9 @@ impl LoggerConfig {
             );
             assert_eq!(status, Status::Ok);
 
-            receiver.recv().unwrap()
+            receiver
+                .recv()
+                .expect("Receive can only fail if the channel is closed")
         });
 
         let mut print_line_callback: ThreadsafeFunction<_, ErrorStrategy::Fatal> = self

package/src/mock/time.rs

@@ -0,0 +1,134 @@
+use std::sync::Arc;
+
+use edr_chain_spec::ChainSpec;
+use edr_chain_spec_block::BlockChainSpec;
+use edr_chain_spec_rpc::RpcBlockChainSpec;
+use edr_generic::GenericChainSpec;
+use edr_napi_core::logger::Logger;
+use edr_primitives::B256;
+use napi::{bindgen_prelude::BigInt, tokio::runtime, Env, JsObject};
+use napi_derive::napi;
+
+use crate::{
+    cast::TryCast as _,
+    config::{resolve_configs, ConfigResolution, ProviderConfig},
+    contract_decoder::ContractDecoder,
+    logger::LoggerConfig,
+    provider::Provider,
+    subscription::SubscriptionConfig,
+};
+
+#[napi]
+pub struct MockTime {
+    inner: Arc<edr_provider::time::MockTime>,
+}
+
+#[napi]
+impl MockTime {
+    #[doc = "Creates a new instance of `MockTime` with the current time."]
+    #[napi(factory, catch_unwind)]
+    pub fn now() -> Self {
+        Self {
+            inner: Arc::new(edr_provider::time::MockTime::now()),
+        }
+    }
+
+    #[doc = "Adds the specified number of seconds to the current time."]
+    #[napi(catch_unwind)]
+    pub fn add_seconds(&self, seconds: BigInt) -> napi::Result<()> {
+        let seconds = seconds.try_cast()?;
+
+        self.inner.add_seconds(seconds);
+        Ok(())
+    }
+}
+
+#[doc = "Creates a provider with a mock timer."]
+#[doc = "For testing purposes."]
+#[napi(catch_unwind, ts_return_type = "Promise<Provider>")]
+pub fn create_provider_with_mock_timer(
+    env: Env,
+    provider_config: ProviderConfig,
+    logger_config: LoggerConfig,
+    subscription_config: SubscriptionConfig,
+    contract_decoder: &ContractDecoder,
+    time: &MockTime,
+) -> napi::Result<JsObject> {
+    let (deferred, promise) = env.create_deferred()?;
+
+    macro_rules! try_or_reject_promise {
+        ($expr:expr) => {
+            match $expr {
+                Ok(value) => value,
+                Err(error) => {
+                    deferred.reject(error);
+                    return Ok(promise);
+                }
+            }
+        };
+    }
+
+    let runtime = runtime::Handle::current();
+
+    let ConfigResolution {
+        logger_config,
+        provider_config,
+        subscription_callback,
+    } = try_or_reject_promise!(resolve_configs(
+        &env,
+        runtime.clone(),
+        provider_config,
+        logger_config,
+        subscription_config,
+    ));
+
+    let contract_decoder = Arc::clone(contract_decoder.as_inner());
+    let timer = Arc::clone(&time.inner);
+
+    runtime.clone().spawn_blocking(move || {
+        // Using a closure to limit the scope, allowing us to use `?` for error
+        // handling. This is necessary because the result of the closure is used
+        // to resolve the deferred promise.
+        let create_provider = move || -> napi::Result<Provider> {
+            let logger = Logger::<GenericChainSpec, Arc<edr_provider::time::MockTime>>::new(
+                logger_config,
+                Arc::clone(&contract_decoder),
+            )?;
+
+            let provider_config =
+                edr_provider::ProviderConfig::<edr_chain_l1::Hardfork>::try_from(provider_config)?;
+
+            let provider =
+                edr_provider::Provider::<GenericChainSpec, Arc<edr_provider::time::MockTime>>::new(
+                    runtime.clone(),
+                    Box::new(logger),
+                    Box::new(move |event| {
+                        let event = edr_napi_core::subscription::SubscriptionEvent::new::<
+                            <GenericChainSpec as BlockChainSpec>::Block,
+                            <GenericChainSpec as RpcBlockChainSpec>::RpcBlock<B256>,
+                            <GenericChainSpec as ChainSpec>::SignedTransaction,
+                        >(event);
+
+                        subscription_callback.call(event);
+                    }),
+                    provider_config,
+                    Arc::clone(&contract_decoder),
+                    timer,
+                )
+                .map_err(|error| napi::Error::from_reason(error.to_string()))?;
+
+            Ok(Provider::new(
+                Arc::new(provider),
+                runtime,
+                contract_decoder,
+                #[cfg(feature = "scenarios")]
+                None,
+            ))
+        };
+
+        let result = create_provider();
+        deferred.resolve(|_env| result);
+    });
+
+    Ok(promise)
+}

package/src/mock.rs

@@ -1,5 +1,8 @@
+pub mod time;
+
 use std::sync::Arc;
 
+use edr_chain_spec::EvmHaltReason;
 use edr_napi_core::provider::SyncProvider;
 use edr_rpc_client::jsonrpc;
 use edr_solidity::contract_decoder::ContractDecoder;
@@ -24,7 +27,7 @@ impl SyncProvider for MockProvider {
         &self,
         _request: String,
         _contract_decoder: Arc<ContractDecoder>,
-    ) -> napi::Result<edr_napi_core::spec::Response<edr_eth::l1::HaltReason>> {
+    ) -> napi::Result<edr_napi_core::spec::Response<EvmHaltReason>> {
         let response = jsonrpc::ResponseData::Success {
             result: self.mocked_response.clone(),
         };

package/src/precompile.rs

@@ -1,5 +1,5 @@
-use edr_eth::Address;
-use edr_evm::precompile::{self, PrecompileFn, PrecompileWithAddress};
+use edr_precompile::PrecompileFn;
+use edr_primitives::Address;
 use napi::bindgen_prelude::Uint8Array;
 use napi_derive::napi;
 
@@ -24,11 +24,11 @@ impl Precompile {
     }
 }
 
-impl From<PrecompileWithAddress> for Precompile {
-    fn from(value: PrecompileWithAddress) -> Self {
+impl From<edr_precompile::Precompile> for Precompile {
+    fn from(value: edr_precompile::Precompile) -> Self {
         Self {
-            address: value.0,
-            precompile_fn: value.1,
+            address: *value.address(),
+            precompile_fn: value.into_precompile(),
         }
     }
 }
@@ -46,5 +46,5 @@ impl Precompile {
 /// secp256r1 precompile.
 #[napi(catch_unwind)]
 pub fn precompile_p256_verify() -> Precompile {
-    Precompile::from(precompile::secp256r1::P256VERIFY)
+    Precompile::from(edr_precompile::secp256r1::P256VERIFY)
 }

package/src/provider/response.rs

@@ -1,4 +1,4 @@
-use edr_eth::l1;
+use edr_chain_spec::EvmHaltReason;
 use edr_napi_core::spec::SolidityTraceData;
 use edr_solidity::contract_decoder::NestedTraceDecoder as _;
 use napi::Either;
@@ -11,11 +11,11 @@ use crate::{
 
 #[napi]
 pub struct Response {
-    inner: edr_napi_core::spec::Response<l1::HaltReason>,
+    inner: edr_napi_core::spec::Response<EvmHaltReason>,
 }
 
-impl From<edr_napi_core::spec::Response<l1::HaltReason>> for Response {
-    fn from(value: edr_napi_core::spec::Response<l1::HaltReason>) -> Self {
+impl From<edr_napi_core::spec::Response<EvmHaltReason>> for Response {
+    fn from(value: edr_napi_core::spec::Response<EvmHaltReason>) -> Self {
         Self { inner: value }
     }
 }