@nomicfoundation/edr 0.12.0-alpha.0 → 0.12.0-next.0

package/src/context.rs

@@ -1,19 +1,37 @@
 use std::sync::Arc;
 
 use edr_eth::HashMap;
-use edr_napi_core::provider::{self, SyncProviderFactory};
+use edr_napi_core::{
+    provider::{self, SyncProviderFactory},
+    solidity,
+};
 use edr_solidity::contract_decoder::ContractDecoder;
+use edr_solidity_tests::{
+    decode::RevertDecoder,
+    multi_runner::{SuiteResultAndArtifactId, TestContract, TestContracts},
+    TestFilterConfig,
+};
 use napi::{
-    Env, JsObject,
+    threadsafe_function::{
+        ErrorStrategy, ThreadSafeCallContext, ThreadsafeFunction, ThreadsafeFunctionCallMode,
+    },
     tokio::{runtime, sync::Mutex as AsyncMutex},
+    Env, JsFunction, JsObject,
 };
 use napi_derive::napi;
-use tracing_subscriber::{EnvFilter, Registry, prelude::*};
+use tracing_subscriber::{prelude::*, EnvFilter, Registry};
 
 use crate::{
     config::{ProviderConfig, TracingConfigWithBuffers},
     logger::LoggerConfig,
     provider::{Provider, ProviderFactory},
+    solidity_tests::{
+        artifact::{Artifact, ArtifactId},
+        config::SolidityTestRunnerConfigArgs,
+        factory::SolidityTestRunnerFactory,
+        test_results::SuiteResult,
+        LinkingOutput,
+    },
     subscription::SubscriptionConfig,
 };
 
@@ -25,7 +43,7 @@ pub struct EdrContext {
 #[napi]
 impl EdrContext {
     #[doc = "Creates a new [`EdrContext`] instance. Should only be called once!"]
-    #[napi(constructor)]
+    #[napi(catch_unwind, constructor)]
     pub fn new() -> napi::Result<Self> {
         let context = Context::new()?;
 
@@ -35,7 +53,7 @@ impl EdrContext {
     }
 
     #[doc = "Constructs a new provider with the provided configuration."]
-    #[napi(ts_return_type = "Promise<Provider>")]
+    #[napi(catch_unwind, ts_return_type = "Promise<Provider>")]
     pub fn create_provider(
         &self,
         env: Env,
@@ -45,44 +63,64 @@ impl EdrContext {
         subscription_config: SubscriptionConfig,
         tracing_config: TracingConfigWithBuffers,
     ) -> napi::Result<JsObject> {
-        let provider_config = edr_napi_core::provider::Config::try_from(provider_config)?;
-        let logger_config = logger_config.resolve(&env)?;
+        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 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 =
-            edr_solidity::artifacts::BuildInfoConfig::parse_from_buffers((&tracing_config).into())
-                .map_err(|err| napi::Error::from_reason(err.to_string()))?;
+        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 = 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 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))
+            ));
 
         #[cfg(feature = "scenarios")]
         let scenario_file =
-            runtime::Handle::current().block_on(crate::scenarios::scenario_file(
+            try_or_reject_promise!(runtime.clone().block_on(crate::scenarios::scenario_file(
                 chain_type.clone(),
                 provider_config.clone(),
                 logger_config.enable,
-            ))?;
+            )));
 
-        let runtime = runtime::Handle::current();
         let builder = {
             // 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 });
 
-            context.create_provider_builder(
+            try_or_reject_promise!(context.create_provider_builder(
                 &env,
                 &chain_type,
                 provider_config,
                 logger_config,
                 subscription_config.into(),
                 &contract_decoder,
-            )?
+            ))
         };
 
-        let (deferred, promise) = env.create_deferred()?;
         runtime.clone().spawn_blocking(move || {
             let result = builder.build(runtime.clone()).map(|provider| {
                 Provider::new(
@@ -101,7 +139,7 @@ impl EdrContext {
     }
 
     #[doc = "Registers a new provider factory for the provided chain type."]
-    #[napi]
+    #[napi(catch_unwind)]
     pub async fn register_provider_factory(
         &self,
         chain_type: String,
@@ -111,10 +149,187 @@ impl EdrContext {
         context.register_provider_factory(chain_type, factory.as_inner().clone());
         Ok(())
     }
+
+    #[napi(catch_unwind)]
+    pub async fn register_solidity_test_runner_factory(
+        &self,
+        chain_type: String,
+        factory: &SolidityTestRunnerFactory,
+    ) -> napi::Result<()> {
+        let mut context = self.inner.lock().await;
+        context.register_solidity_test_runner(chain_type, factory.as_inner().clone());
+        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."]
+    #[allow(clippy::too_many_arguments)]
+    #[napi(catch_unwind, ts_return_type = "Promise<void>")]
+    pub fn run_solidity_tests(
+        &self,
+        env: Env,
+        chain_type: String,
+        artifacts: Vec<Artifact>,
+        test_suites: Vec<ArtifactId>,
+        config_args: SolidityTestRunnerConfigArgs,
+        tracing_config: TracingConfigWithBuffers,
+        #[napi(ts_arg_type = "(result: SuiteResult) => void")]
+        on_test_suite_completed_callback: JsFunction,
+    ) -> napi::Result<JsObject> {
+        let (deferred, promise) = env.create_deferred()?;
+
+        let on_test_suite_completed_callback: ThreadsafeFunction<_, ErrorStrategy::Fatal> =
+            match on_test_suite_completed_callback.create_threadsafe_function(
+                // Unbounded queue size
+                0,
+                |ctx: ThreadSafeCallContext<SuiteResult>| Ok(vec![ctx.value]),
+            ) {
+                Ok(value) => value,
+                Err(error) => {
+                    deferred.reject(error);
+                    return Ok(promise);
+                }
+            };
+
+        let test_filter: Arc<TestFilterConfig> =
+            Arc::new(match config_args.try_get_test_filter() {
+                Ok(test_filter) => test_filter,
+                Err(error) => {
+                    deferred.reject(error);
+                    return Ok(promise);
+                }
+            });
+
+        let runtime = runtime::Handle::current();
+        let config = match config_args.resolve(&env, runtime.clone()) {
+            Ok(config) => config,
+            Err(error) => {
+                deferred.reject(error);
+                return Ok(promise);
+            }
+        };
+
+        let context = self.inner.clone();
+        runtime.clone().spawn(async move {
+            macro_rules! try_or_reject_deferred {
+                ($expr:expr) => {
+                    match $expr {
+                        Ok(value) => value,
+                        Err(error) => {
+                            deferred.reject(error);
+                            return;
+                        }
+                    }
+                };
+            }
+            let factory = {
+                let context = context.lock().await;
+                try_or_reject_deferred!(context.solidity_test_runner_factory(&chain_type).await)
+            };
+
+            let linking_output =
+                try_or_reject_deferred!(LinkingOutput::link(&config.project_root, artifacts));
+
+            // Build revert decoder from ABIs of all artifacts.
+            let abis = linking_output
+                .known_contracts
+                .iter()
+                .map(|(_, contract)| &contract.abi);
+
+            let revert_decoder = RevertDecoder::new().with_abis(abis);
+
+            let test_suites = try_or_reject_deferred!(test_suites
+                .into_iter()
+                .map(edr_solidity::artifacts::ArtifactId::try_from)
+                .collect::<Result<Vec<_>, _>>());
+
+            let contracts = try_or_reject_deferred!(test_suites
+                .iter()
+                .map(|artifact_id| {
+                    let contract_data = linking_output
+                        .known_contracts
+                        .get(artifact_id)
+                        .ok_or_else(|| {
+                            napi::Error::new(
+                                napi::Status::GenericFailure,
+                                format!("Unknown contract: {}", artifact_id.identifier()),
+                            )
+                        })?;
+
+                    let bytecode = contract_data.bytecode.clone().ok_or_else(|| {
+                        napi::Error::new(
+                            napi::Status::GenericFailure,
+                            format!(
+                                "No bytecode for test suite contract: {}",
+                                artifact_id.identifier()
+                            ),
+                        )
+                    })?;
+
+                    let test_contract = TestContract {
+                        abi: contract_data.abi.clone(),
+                        bytecode,
+                    };
+
+                    Ok((artifact_id.clone(), test_contract))
+                })
+                .collect::<napi::Result<TestContracts>>());
+
+            let include_traces = config.include_traces.into();
+
+            let test_runner = try_or_reject_deferred!(runtime
+                .clone()
+                .spawn_blocking(move || {
+                    factory.create_test_runner(
+                        runtime,
+                        config,
+                        contracts,
+                        linking_output.known_contracts,
+                        linking_output.libs_to_deploy,
+                        revert_decoder,
+                        tracing_config.into(),
+                    )
+                })
+                .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!(
+                            status,
+                            napi::Status::Ok,
+                            "Failed to call on_test_suite_completed_callback with status: {status}"
+                        );
+                    }
+                ),
+            ));
+
+            deferred.resolve(move |_env| Ok(()));
+        });
+
+        Ok(promise)
+    }
 }
 
 pub struct Context {
     provider_factories: HashMap<String, Arc<dyn SyncProviderFactory>>,
+    solidity_test_runner_factories: HashMap<String, Arc<dyn solidity::SyncTestRunnerFactory>>,
     #[cfg(feature = "tracing")]
     _tracing_write_guard: tracing_flame::FlushGuard<std::io::BufWriter<std::fs::File>>,
 }
@@ -158,6 +373,7 @@ impl Context {
 
         Ok(Self {
             provider_factories: HashMap::new(),
+            solidity_test_runner_factories: HashMap::new(),
             #[cfg(feature = "tracing")]
             _tracing_write_guard: guard,
         })
@@ -172,6 +388,15 @@ impl Context {
         self.provider_factories.insert(chain_type, factory);
     }
 
+    pub fn register_solidity_test_runner(
+        &mut self,
+        chain_type: String,
+        factory: Arc<dyn solidity::SyncTestRunnerFactory>,
+    ) {
+        self.solidity_test_runner_factories
+            .insert(chain_type, factory);
+    }
+
     /// Tries to create a new provider for the provided chain type and
     /// configuration.
     pub fn create_provider_builder(
@@ -198,4 +423,18 @@ impl Context {
             ))
         }
     }
+
+    pub async fn solidity_test_runner_factory(
+        &self,
+        chain_type: &str,
+    ) -> napi::Result<Arc<dyn solidity::SyncTestRunnerFactory>> {
+        if let Some(factory) = self.solidity_test_runner_factories.get(chain_type) {
+            Ok(Arc::clone(factory))
+        } else {
+            Err(napi::Error::new(
+                napi::Status::GenericFailure,
+                "Solidity test runner for provided chain type does not exist",
+            ))
+        }
+    }
 }

package/src/debug_trace.rs

@@ -1,13 +1,13 @@
 use std::collections::HashMap;
 
-use napi::bindgen_prelude::{BigInt, Buffer};
+use napi::bindgen_prelude::{BigInt, Uint8Array};
 use napi_derive::napi;
 
 #[napi(object)]
 pub struct DebugTraceResult {
     pub pass: bool,
     pub gas_used: BigInt,
-    pub output: Option<Buffer>,
+    pub output: Option<Uint8Array>,
     pub struct_logs: Vec<DebugTraceLogItem>,
 }
 

package/src/instrument.rs

@@ -0,0 +1,109 @@
+use edr_instrument::coverage::{self, Version};
+use napi::bindgen_prelude::Uint8Array;
+use napi_derive::napi;
+
+#[napi(object)]
+pub struct InstrumentationResult {
+    /// The generated source code with coverage instrumentation.
+    #[napi(readonly)]
+    pub source: String,
+    /// The metadata for each instrumented code segment.
+    #[napi(readonly)]
+    pub metadata: Vec<InstrumentationMetadata>,
+}
+
+impl TryFrom<edr_instrument::coverage::InstrumentationResult> for InstrumentationResult {
+    type Error = usize;
+
+    fn try_from(
+        value: edr_instrument::coverage::InstrumentationResult,
+    ) -> Result<Self, Self::Error> {
+        let metadata = value
+            .metadata
+            .into_iter()
+            .map(InstrumentationMetadata::try_from)
+            .collect::<Result<Vec<_>, _>>()?;
+
+        Ok(InstrumentationResult {
+            source: value.source,
+            metadata,
+        })
+    }
+}
+
+#[napi(object)]
+pub struct InstrumentationMetadata {
+    /// The tag that identifies the instrumented code. Tags are
+    /// deterministically generated from the source code, source id, and
+    /// Solidity version.
+    #[napi(readonly)]
+    pub tag: Uint8Array,
+    /// The kind of instrumented code. Currently, the only supported kind
+    /// is "statement".
+    #[napi(readonly)]
+    pub kind: String,
+    /// The starting position of the instrumented code - including trivia such
+    /// as whitespace - in the source code, in UTF-16 code units.
+    #[napi(readonly)]
+    pub start_utf16: i64,
+    /// The ending position of the instrumented code - including trivia such as
+    /// whitespace - in the source code, in UTF-16 code units.
+    #[napi(readonly)]
+    pub end_utf16: i64,
+}
+
+impl TryFrom<edr_instrument::coverage::InstrumentationMetadata> for InstrumentationMetadata {
+    type Error = usize;
+
+    fn try_from(
+        value: edr_instrument::coverage::InstrumentationMetadata,
+    ) -> Result<Self, Self::Error> {
+        let start_utf16 = value
+            .start_utf16
+            .try_into()
+            .map_err(|_error| value.start_utf16)?;
+        let end_utf16 = value
+            .end_utf16
+            .try_into()
+            .map_err(|_error| value.end_utf16)?;
+
+        Ok(InstrumentationMetadata {
+            tag: Uint8Array::with_data_copied(value.tag),
+            kind: value.kind.to_owned(),
+            start_utf16,
+            end_utf16,
+        })
+    }
+}
+
+/// Adds per-statement coverage instrumentation to the given Solidity source
+/// code.
+#[napi(catch_unwind)]
+pub fn add_statement_coverage_instrumentation(
+    source_code: String,
+    source_id: String,
+    solidity_version: String,
+    coverage_library_path: String,
+) -> napi::Result<InstrumentationResult> {
+    let solidity_version = Version::parse(&solidity_version).map_err(|error| {
+        napi::Error::new(
+            napi::Status::InvalidArg,
+            format!("Invalid Solidity version: {error}"),
+        )
+    })?;
+
+    let instrumented = coverage::instrument_code(
+        &source_code,
+        &source_id,
+        solidity_version,
+        &coverage_library_path,
+    )
+    .map_err(|error| napi::Error::new(napi::Status::GenericFailure, error))?;
+
+    instrumented.try_into().map_err(|location| {
+        napi::Error::new(
+            napi::Status::GenericFailure,
+            format!("Cannot represent source locations in JavaScript: {location}."),
+        )
+    })
+}

package/src/lib.rs

@@ -18,10 +18,17 @@ pub mod config;
 /// Types related to an EDR N-API context.
 pub mod context;
 mod debug_trace;
+/// Types and functions related to code coverage instrumentation.
+pub mod instrument;
 /// Types for EVM execution logs.
 pub mod log;
 /// Types for an RPC request logger.
 pub mod logger;
+/// Types for mocking provider behavior.
+#[cfg(feature = "test-mock")]
+mod mock;
+/// Types for precompiles.
+pub mod precompile;
 /// Types for Ethereum RPC providers.
 pub mod provider;
 /// Types for EVM execution results.
@@ -29,6 +36,9 @@ pub mod result;
 /// Types relating to benchmark scenarios.
 #[cfg(feature = "scenarios")]
 pub mod scenarios;
+mod serde;
+/// Solidity test runner.
+pub mod solidity_tests;
 /// Types for subscribing to events.
 pub mod subscription;
 /// Types for EVM traces.

package/src/log.rs

@@ -1,30 +1,28 @@
-use napi::{Env, JsBuffer, JsBufferValue, bindgen_prelude::Buffer};
+use napi::bindgen_prelude::Uint8Array;
 use napi_derive::napi;
 
 /// Ethereum execution log.
 #[napi(object)]
 pub struct ExecutionLog {
-    pub address: Buffer,
-    pub topics: Vec<Buffer>,
-    pub data: JsBuffer,
+    pub address: Uint8Array,
+    pub topics: Vec<Uint8Array>,
+    pub data: Uint8Array,
 }
 
-impl ExecutionLog {
-    pub fn new(env: &Env, log: &edr_eth::log::ExecutionLog) -> napi::Result<Self> {
-        let topics = log
+impl From<&edr_eth::log::ExecutionLog> for ExecutionLog {
+    fn from(value: &edr_eth::log::ExecutionLog) -> Self {
+        let topics = value
             .topics()
             .iter()
-            .map(|topic| Buffer::from(topic.as_slice()))
+            .map(Uint8Array::with_data_copied)
             .collect();
 
-        let data = env
-            .create_buffer_with_data(log.data.data.to_vec())
-            .map(JsBufferValue::into_raw)?;
+        let data = Uint8Array::with_data_copied(&value.data.data);
 
-        Ok(Self {
-            address: Buffer::from(log.address.as_slice()),
+        Self {
+            address: Uint8Array::with_data_copied(value.address),
             topics,
             data,
-        })
+        }
     }
 }

package/src/logger.rs

@@ -1,38 +1,20 @@
-use std::sync::{Arc, mpsc::channel};
+use std::sync::{mpsc::channel, Arc};
 
 use edr_eth::Bytes;
 use edr_napi_core::logger::LoggerError;
 use napi::{
-    JsFunction, Status,
     threadsafe_function::{
         ErrorStrategy, ThreadSafeCallContext, ThreadsafeFunction, ThreadsafeFunctionCallMode,
     },
+    JsFunction, Status,
 };
 use napi_derive::napi;
 
-use crate::cast::TryCast;
-
-#[napi(object)]
-pub struct ContractAndFunctionName {
-    /// The contract name.
-    pub contract_name: String,
-    /// The function name. Only present for calls.
-    pub function_name: Option<String>,
-}
-
-impl TryCast<(String, Option<String>)> for ContractAndFunctionName {
-    type Error = napi::Error;
-
-    fn try_cast(self) -> std::result::Result<(String, Option<String>), Self::Error> {
-        Ok((self.contract_name, self.function_name))
-    }
-}
-
 #[napi(object)]
 pub struct LoggerConfig {
     /// Whether to enable the logger.
     pub enable: bool,
-    #[napi(ts_type = "(inputs: Buffer[]) => string[]")]
+    #[napi(ts_type = "(inputs: ArrayBuffer[]) => string[]")]
     pub decode_console_log_inputs_callback: JsFunction,
     #[napi(ts_type = "(message: string, replace: boolean) => void")]
     pub print_line_callback: JsFunction,
@@ -48,9 +30,11 @@ impl LoggerConfig {
                     let inputs = ctx.env.create_array_with_length(ctx.value.len()).and_then(
                         |mut inputs| {
                             for (idx, input) in ctx.value.into_iter().enumerate() {
-                                ctx.env.create_buffer_with_data(input.to_vec()).and_then(
-                                    |input| inputs.set_element(idx as u32, input.into_raw()),
-                                )?;
+                                ctx.env
+                                    .create_arraybuffer_with_data(input.to_vec())
+                                    .and_then(|input| {
+                                        inputs.set_element(idx as u32, input.into_raw())
+                                    })?;
                             }
 
                             Ok(inputs)
@@ -60,8 +44,8 @@ impl LoggerConfig {
                     Ok(vec![inputs])
                 })?;
 
-        // Maintain a weak reference to the function to avoid the event loop from
-        // exiting.
+        // Maintain a weak reference to the function to avoid blocking the event loop
+        // from exiting.
         decode_console_log_inputs_callback.unref(env)?;
 
         let decode_console_log_inputs_fn = Arc::new(move |console_log_inputs| {
@@ -96,13 +80,27 @@ impl LoggerConfig {
                 Ok(vec![message.into_unknown(), replace.into_unknown()])
             })?;
 
-        // Maintain a weak reference to the function to avoid the event loop from
-        // exiting.
+        // Maintain a weak reference to the function to avoid blocking the event loop
+        // from exiting.
         print_line_callback.unref(env)?;
 
         let print_line_fn = Arc::new(move |message, replace| {
-            let status =
-                print_line_callback.call((message, replace), ThreadsafeFunctionCallMode::Blocking);
+            let (sender, receiver) = channel();
+
+            let status = print_line_callback.call_with_return_value(
+                (message, replace),
+                ThreadsafeFunctionCallMode::Blocking,
+                move |()| {
+                    sender.send(()).map_err(|_error| {
+                        napi::Error::new(
+                            Status::GenericFailure,
+                            "Failed to send result from decode_console_log_inputs",
+                        )
+                    })
+                },
+            );
+
+            let () = receiver.recv().unwrap();
 
             if status == napi::Status::Ok {
                 Ok(())