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

package/index.d.ts

@@ -982,11 +982,10 @@ export interface CallTrace {
   gasUsed: bigint
   /** The amount of native token that was included with the call. */
   value: bigint
-  /**
-   * The target of the call. Provided as a contract name if known, otherwise
-   * a checksum address.
-   */
-  contract: string
+  /** The target address of the call. */
+  address: string
+  /** The name of the contract that is the target of the call, if known. */
+  contract?: string
   /**
    * The input (calldata) to the call. If it encodes a known function call,
    * it will be decoded into the function name and a list of arguments.
@@ -1116,7 +1115,8 @@ export enum StackTraceEntryType {
   UNMAPPED_SOLC_0_6_3_REVERT_ERROR = 20,
   CONTRACT_TOO_LARGE_ERROR = 21,
   INTERNAL_FUNCTION_CALLSTACK_ENTRY = 22,
-  CONTRACT_CALL_RUN_OUT_OF_GAS_ERROR = 23
+  CONTRACT_CALL_RUN_OUT_OF_GAS_ERROR = 23,
+  CHEATCODE_ERROR = 24
 }
 export declare function stackTraceEntryTypeToString(val: StackTraceEntryType): string
 export const FALLBACK_FUNCTION_NAME: string
@@ -1246,6 +1246,11 @@ export interface ContractCallRunOutOfGasError {
   type: StackTraceEntryType.CONTRACT_CALL_RUN_OUT_OF_GAS_ERROR
   sourceReference?: SourceReference
 }
+export interface CheatcodeErrorStackTraceEntry {
+  type: StackTraceEntryType.CHEATCODE_ERROR
+  message: string
+  sourceReference: SourceReference
+}
 export interface TracingMessage {
   /** Sender address */
   readonly caller: Uint8Array
@@ -1337,6 +1342,12 @@ export declare class Response {
 }
 /** A JSON-RPC provider for Ethereum. */
 export declare class Provider {
+  /**
+   *Adds a compilation result to the instance.
+   *
+   *For internal use only. Support for this method may be removed in the future.
+   */
+  addCompilationResult(solcVersion: string, compilerInput: any, compilerOutput: any): Promise<boolean>
   /**Handles a JSON-RPC request and returns a JSON-RPC response. */
   handleRequest(request: string): Promise<Response>
   setCallOverrideCallback(callOverrideCallback: (contract_address: ArrayBuffer, data: ArrayBuffer) => Promise<CallOverrideResult | undefined>): Promise<void>

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "@nomicfoundation/edr",
-  "version": "0.12.0-next.1",
+  "version": "0.12.0-next.3",
   "devDependencies": {
     "@napi-rs/cli": "^2.18.4",
     "@nomicfoundation/ethereumjs-util": "^9.0.4",
+    "@tsconfig/node20": "^20.1.6",
     "@types/chai": "^4.2.0",
     "@types/chai-as-promised": "^7.1.8",
     "@types/mocha": ">=9.1.0",
@@ -12,6 +13,7 @@
     "@typescript-eslint/parser": "5.61.0",
     "chai": "^4.3.6",
     "chai-as-promised": "^7.1.1",
+    "chalk": "^2.4.2",
     "eslint": "^8.44.0",
     "eslint-config-prettier": "9.1.0",
     "eslint-plugin-import": "2.27.5",
@@ -25,14 +27,17 @@
     "typescript": "~5.8.2"
   },
   "engines": {
-    "node": ">= 18"
+    "node": ">= 20"
+  },
+  "exports": {
+    ".": "./index.js",
+    "./solidity-tests": "./dist/src/ts/solidity_tests.js"
   },
   "files": [
     "index.js",
     "index.d.ts",
-    "Cargo.toml",
-    "build.rs",
-    "src/"
+    "src/",
+    "dist/src/"
   ],
   "license": "MIT",
   "main": "index.js",
@@ -54,31 +59,31 @@
   "repository": "NomicFoundation/edr.git",
   "types": "index.d.ts",
   "optionalDependencies": {
-    "@nomicfoundation/edr-darwin-arm64": "0.12.0-next.1",
-    "@nomicfoundation/edr-darwin-x64": "0.12.0-next.1",
-    "@nomicfoundation/edr-linux-arm64-gnu": "0.12.0-next.1",
-    "@nomicfoundation/edr-linux-arm64-musl": "0.12.0-next.1",
-    "@nomicfoundation/edr-linux-x64-gnu": "0.12.0-next.1",
-    "@nomicfoundation/edr-linux-x64-musl": "0.12.0-next.1",
-    "@nomicfoundation/edr-win32-x64-msvc": "0.12.0-next.1"
+    "@nomicfoundation/edr-darwin-arm64": "0.12.0-next.3",
+    "@nomicfoundation/edr-darwin-x64": "0.12.0-next.3",
+    "@nomicfoundation/edr-linux-arm64-gnu": "0.12.0-next.3",
+    "@nomicfoundation/edr-linux-arm64-musl": "0.12.0-next.3",
+    "@nomicfoundation/edr-linux-x64-gnu": "0.12.0-next.3",
+    "@nomicfoundation/edr-linux-x64-musl": "0.12.0-next.3",
+    "@nomicfoundation/edr-win32-x64-msvc": "0.12.0-next.3"
   },
   "scripts": {
     "artifacts": "napi artifacts",
     "build": "pnpm run build:publish",
-    "build:debug": "napi build --platform  --no-const-enum --features op",
-    "build:dev": "napi build --platform --release --no-const-enum --features op,test-mock",
-    "build:publish": "napi build --platform --profile napi-publish --no-const-enum --features op",
-    "build:scenarios": "napi build --platform --release --no-const-enum --features op,scenarios",
-    "build:tracing": "napi build --platform --release --no-const-enum --features op,tracing",
-    "build:typingFile": "napi build --platform --no-const-enum --features op",
+    "build:debug": "bash ../../scripts/build_edr_napi.sh --features op",
+    "build:dev": "bash ../../scripts/build_edr_napi.sh --release --features op,test-mock",
+    "build:publish": "bash ../../scripts/build_edr_napi.sh --profile napi-publish --features op",
+    "build:scenarios": "bash ../../scripts/build_edr_napi.sh --release --features op,scenarios",
+    "build:tracing": "bash ../../scripts/build_edr_napi.sh --release --features op,tracing",
+    "build:typingFile": "bash ../../scripts/build_edr_napi.sh --features op",
     "clean": "rm -rf @nomicfoundation/edr.node",
     "eslint": "eslint 'test/**/*.ts'",
     "lint": "pnpm run prettier && pnpm run eslint",
     "lint:fix": "pnpm run prettier --write",
     "pretest": "pnpm build:dev",
     "prettier": "prettier --check \"test/**.ts\"",
-    "test": "pnpm tsc && node --max-old-space-size=8192 node_modules/mocha/bin/_mocha --recursive \"test/**/*.ts\"",
-    "testNoBuild": "pnpm tsc && node --max-old-space-size=8192 node_modules/mocha/bin/_mocha --recursive \"test/**/{,!(mock)}.ts\"",
+    "test": "node --max-old-space-size=8192 node_modules/mocha/bin/_mocha --recursive \"test/**/*.ts\"",
+    "testNoBuild": "node --max-old-space-size=8192 node_modules/mocha/bin/_mocha --recursive \"test/**/{,!(logs|mock)}.ts\"",
     "universal": "napi universal",
     "version": "napi version"
   }

package/src/chains/generic.rs

@@ -5,9 +5,9 @@ use edr_generic::GenericChainSpec;
 use edr_napi_core::{
     logger::{self, Logger},
     provider::{self, ProviderBuilder, SyncProviderFactory},
-    spec::SyncNapiSpec as _,
     subscription,
 };
+use edr_provider::time::CurrentTime;
 use edr_solidity::contract_decoder::ContractDecoder;
 use napi_derive::napi;
 
@@ -24,7 +24,10 @@ impl SyncProviderFactory for GenericChainProviderFactory {
         subscription_config: subscription::Config,
         contract_decoder: Arc<ContractDecoder>,
     ) -> napi::Result<Box<dyn provider::Builder>> {
-        let logger = Logger::<GenericChainSpec>::new(logger_config, Arc::clone(&contract_decoder))?;
+        let logger = Logger::<GenericChainSpec, CurrentTime>::new(
+            logger_config,
+            Arc::clone(&contract_decoder),
+        )?;
 
         let provider_config =
             edr_provider::ProviderConfig::<l1::SpecId>::try_from(provider_config)?;
@@ -42,7 +45,7 @@ impl SyncProviderFactory for GenericChainProviderFactory {
 }
 
 #[napi]
-pub const GENERIC_CHAIN_TYPE: &str = GenericChainSpec::CHAIN_TYPE;
+pub const GENERIC_CHAIN_TYPE: &str = edr_generic::CHAIN_TYPE;
 
 #[napi(catch_unwind)]
 pub fn generic_chain_provider_factory() -> ProviderFactory {

package/src/chains/l1.rs

@@ -8,9 +8,9 @@ use edr_evm::eips::{
 use edr_napi_core::{
     logger::Logger,
     provider::{self, ProviderBuilder, SyncProviderFactory},
-    spec::SyncNapiSpec as _,
     subscription,
 };
+use edr_provider::time::CurrentTime;
 use edr_solidity::contract_decoder::ContractDecoder;
 use napi::bindgen_prelude::{BigInt, Uint8Array};
 use napi_derive::napi;
@@ -28,7 +28,8 @@ impl SyncProviderFactory for L1ProviderFactory {
         subscription_config: edr_napi_core::subscription::Config,
         contract_decoder: Arc<ContractDecoder>,
     ) -> napi::Result<Box<dyn provider::Builder>> {
-        let logger = Logger::<L1ChainSpec>::new(logger_config, Arc::clone(&contract_decoder))?;
+        let logger =
+            Logger::<L1ChainSpec, CurrentTime>::new(logger_config, Arc::clone(&contract_decoder))?;
 
         let provider_config =
             edr_provider::ProviderConfig::<l1::SpecId>::try_from(provider_config)?;
@@ -46,7 +47,7 @@ impl SyncProviderFactory for L1ProviderFactory {
 }
 
 #[napi]
-pub const L1_CHAIN_TYPE: &str = L1ChainSpec::CHAIN_TYPE;
+pub const L1_CHAIN_TYPE: &str = edr_eth::l1::CHAIN_TYPE;
 
 #[napi(catch_unwind)]
 pub fn l1_genesis_state(hardfork: SpecId) -> Vec<AccountOverride> {

package/src/chains/op.rs

@@ -7,6 +7,7 @@ use edr_napi_core::{
     subscription,
 };
 use edr_op::{predeploys::GAS_PRICE_ORACLE_ADDRESS, OpChainSpec, OpSpecId};
+use edr_provider::time::CurrentTime;
 use edr_solidity::contract_decoder::ContractDecoder;
 use napi::bindgen_prelude::{BigInt, Uint8Array};
 use napi_derive::napi;
@@ -27,7 +28,8 @@ impl SyncProviderFactory for OpProviderFactory {
         subscription_config: subscription::Config,
         contract_decoder: Arc<ContractDecoder>,
     ) -> napi::Result<Box<dyn provider::Builder>> {
-        let logger = Logger::<OpChainSpec>::new(logger_config, Arc::clone(&contract_decoder))?;
+        let logger =
+            Logger::<OpChainSpec, CurrentTime>::new(logger_config, Arc::clone(&contract_decoder))?;
 
         let provider_config = edr_provider::ProviderConfig::<OpSpecId>::try_from(provider_config)?;
 

package/src/config.rs

@@ -385,10 +385,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(())
                         });
 

package/src/context.rs

@@ -281,11 +281,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,28 +298,38 @@ 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 () = 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(()));
         });

package/src/lib.rs

@@ -26,7 +26,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/logger.rs

@@ -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,131 @@
+use std::sync::Arc;
+
+use edr_generic::GenericChainSpec;
+use edr_napi_core::logger::Logger;
+use edr_solidity::contract_decoder::ContractDecoder;
+use napi::{bindgen_prelude::BigInt, tokio::runtime, Env, JsObject};
+use napi_derive::napi;
+
+use crate::{
+    cast::TryCast as _,
+    config::{ProviderConfig, TracingConfigWithBuffers},
+    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,
+    tracing_config: TracingConfigWithBuffers,
+    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 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 subscription_config = edr_napi_core::subscription::Config::from(subscription_config);
+    let subscription_callback = try_or_reject_promise!(edr_napi_core::subscription::Callback::new(
+        &env,
+        subscription_config.subscription_callback,
+    ));
+
+    let logger = try_or_reject_promise!(Logger::<
+        GenericChainSpec,
+        Arc<edr_provider::time::MockTime>,
+    >::new(logger_config, Arc::clone(&contract_decoder),));
+
+    let provider_config = try_or_reject_promise!(
+        edr_provider::ProviderConfig::<edr_eth::l1::SpecId>::try_from(provider_config)
+    );
+
+    let timer = Arc::clone(&time.inner);
+
+    runtime.clone().spawn_blocking(move || {
+        let result =
+            edr_provider::Provider::<GenericChainSpec, Arc<edr_provider::time::MockTime>>::new(
+                runtime.clone(),
+                Box::new(logger),
+                Box::new(move |event| subscription_callback.call(event)),
+                provider_config,
+                contract_decoder.clone(),
+                timer,
+            )
+            .map_or_else(
+                |error| Err(napi::Error::from_reason(error.to_string())),
+                |provider| {
+                    Ok(Provider::new(
+                        Arc::new(provider),
+                        runtime,
+                        contract_decoder,
+                        #[cfg(feature = "scenarios")]
+                        None,
+                    ))
+                },
+            );
+
+        deferred.resolve(|_env| result);
+    });
+
+    Ok(promise)
+}

package/src/mock.rs

@@ -1,3 +1,5 @@
+pub mod time;
+
 use std::sync::Arc;
 
 use edr_napi_core::provider::SyncProvider;
@@ -20,6 +22,15 @@ impl MockProvider {
 }
 
 impl SyncProvider for MockProvider {
+    fn add_compilation_result(
+        &self,
+        _solc_version: String,
+        _compiler_input: edr_solidity::artifacts::CompilerInput,
+        _compiler_output: edr_solidity::artifacts::CompilerOutput,
+    ) -> napi::Result<bool> {
+        Ok(false) // Mock provider does not handle compilation results
+    }
+
     fn handle_request(
         &self,
         _request: String,

package/src/provider.rs

@@ -45,6 +45,32 @@ impl Provider {
 
 #[napi]
 impl Provider {
+    #[doc = "Adds a compilation result to the instance."]
+    #[doc = ""]
+    #[doc = "For internal use only. Support for this method may be removed in the future."]
+    #[napi(catch_unwind)]
+    pub async fn add_compilation_result(
+        &self,
+        solc_version: String,
+        compiler_input: serde_json::Value,
+        compiler_output: serde_json::Value,
+    ) -> napi::Result<bool> {
+        let provider = self.provider.clone();
+
+        self.runtime
+            .spawn_blocking(move || {
+                let compiler_input = serde_json::from_value(compiler_input)
+                    .map_err(|error| napi::Error::from_reason(error.to_string()))?;
+
+                let compiler_output = serde_json::from_value(compiler_output)
+                    .map_err(|error| napi::Error::from_reason(error.to_string()))?;
+
+                provider.add_compilation_result(solc_version, compiler_input, compiler_output)
+            })
+            .await
+            .map_err(|error| napi::Error::new(Status::GenericFailure, error.to_string()))?
+    }
+
     #[doc = "Handles a JSON-RPC request and returns a JSON-RPC response."]
     #[napi(catch_unwind)]
     pub async fn handle_request(&self, request: String) -> napi::Result<Response> {

package/src/solidity_tests/test_results.rs

@@ -470,9 +470,10 @@ pub struct CallTrace {
     pub gas_used: BigInt,
     /// The amount of native token that was included with the call.
     pub value: BigInt,
-    /// The target of the call. Provided as a contract name if known, otherwise
-    /// a checksum address.
-    pub contract: String,
+    /// The target address of the call.
+    pub address: String,
+    /// The name of the contract that is the target of the call, if known.
+    pub contract: Option<String>,
     /// The input (calldata) to the call. If it encodes a known function call,
     /// it will be decoded into the function name and a list of arguments.
     /// For example, `{ name: "ownerOf", arguments: ["1"] }`. Note that the
@@ -541,12 +542,8 @@ impl CallTrace {
     /// Instantiates a `CallTrace` with the details from a node and the supplied
     /// children.
     fn new(node: &traces::CallTraceNode, children: Vec<Either<CallTrace, LogTrace>>) -> Self {
-        let contract = node
-            .trace
-            .decoded
-            .label
-            .clone()
-            .unwrap_or(node.trace.address.to_checksum(None));
+        let contract = node.trace.decoded.label.clone();
+        let address = node.trace.address.to_checksum(None);
 
         let inputs = match &node.trace.decoded.call_data {
             Some(traces::DecodedCallData { signature, args }) => {
@@ -579,6 +576,7 @@ impl CallTrace {
             gas_used: node.trace.gas_used.into(),
             value: u256_to_bigint(&node.trace.value),
             contract,
+            address,
             inputs,
             outputs,
             children,

package/src/trace/debug.rs

@@ -1,6 +1,6 @@
 //! Port of `hardhat-network/stack-traces/debug.ts` from Hardhat.
 
-use napi::bindgen_prelude::Either24;
+use napi::bindgen_prelude::Either25;
 use napi_derive::napi;
 
 use super::solidity_stack_trace::{RevertErrorStackTraceEntry, SolidityStackTrace};
@@ -11,31 +11,32 @@ fn print_stack_trace(trace: SolidityStackTrace) -> napi::Result<()> {
     let entry_values = trace
         .into_iter()
         .map(|entry| match entry {
-            Either24::A(entry) => serde_json::to_value(entry),
-            Either24::B(entry) => serde_json::to_value(entry),
-            Either24::C(entry) => serde_json::to_value(entry),
-            Either24::D(entry) => serde_json::to_value(entry),
-            Either24::F(entry) => serde_json::to_value(entry),
-            Either24::G(entry) => serde_json::to_value(entry),
-            Either24::H(entry) => serde_json::to_value(entry),
-            Either24::I(entry) => serde_json::to_value(entry),
-            Either24::J(entry) => serde_json::to_value(entry),
-            Either24::K(entry) => serde_json::to_value(entry),
-            Either24::L(entry) => serde_json::to_value(entry),
-            Either24::M(entry) => serde_json::to_value(entry),
-            Either24::N(entry) => serde_json::to_value(entry),
-            Either24::O(entry) => serde_json::to_value(entry),
-            Either24::P(entry) => serde_json::to_value(entry),
-            Either24::Q(entry) => serde_json::to_value(entry),
-            Either24::R(entry) => serde_json::to_value(entry),
-            Either24::S(entry) => serde_json::to_value(entry),
-            Either24::T(entry) => serde_json::to_value(entry),
-            Either24::U(entry) => serde_json::to_value(entry),
-            Either24::V(entry) => serde_json::to_value(entry),
-            Either24::W(entry) => serde_json::to_value(entry),
-            Either24::X(entry) => serde_json::to_value(entry),
+            Either25::A(entry) => serde_json::to_value(entry),
+            Either25::B(entry) => serde_json::to_value(entry),
+            Either25::C(entry) => serde_json::to_value(entry),
+            Either25::D(entry) => serde_json::to_value(entry),
+            Either25::F(entry) => serde_json::to_value(entry),
+            Either25::G(entry) => serde_json::to_value(entry),
+            Either25::H(entry) => serde_json::to_value(entry),
+            Either25::I(entry) => serde_json::to_value(entry),
+            Either25::J(entry) => serde_json::to_value(entry),
+            Either25::K(entry) => serde_json::to_value(entry),
+            Either25::L(entry) => serde_json::to_value(entry),
+            Either25::M(entry) => serde_json::to_value(entry),
+            Either25::N(entry) => serde_json::to_value(entry),
+            Either25::O(entry) => serde_json::to_value(entry),
+            Either25::P(entry) => serde_json::to_value(entry),
+            Either25::Q(entry) => serde_json::to_value(entry),
+            Either25::R(entry) => serde_json::to_value(entry),
+            Either25::S(entry) => serde_json::to_value(entry),
+            Either25::T(entry) => serde_json::to_value(entry),
+            Either25::U(entry) => serde_json::to_value(entry),
+            Either25::V(entry) => serde_json::to_value(entry),
+            Either25::W(entry) => serde_json::to_value(entry),
+            Either25::X(entry) => serde_json::to_value(entry),
+            Either25::Y(entry) => serde_json::to_value(entry),
             // Decode the error message from the return data
-            Either24::E(entry @ RevertErrorStackTraceEntry { .. }) => {
+            Either25::E(entry @ RevertErrorStackTraceEntry { .. }) => {
                 use serde::de::Error;
 
                 let decoded_error_msg = ReturnData::new(entry.return_data.clone())

package/src/trace/solidity_stack_trace.rs

@@ -4,7 +4,7 @@
 use std::convert::Infallible;
 
 use edr_eth::{hex, U256};
-use napi::bindgen_prelude::{BigInt, Either24, FromNapiValue, ToNapiValue, Uint8Array, Undefined};
+use napi::bindgen_prelude::{BigInt, Either25, FromNapiValue, ToNapiValue, Uint8Array, Undefined};
 use napi_derive::napi;
 use serde::{Serialize, Serializer};
 
@@ -45,6 +45,7 @@ pub enum StackTraceEntryType {
     CONTRACT_TOO_LARGE_ERROR,
     INTERNAL_FUNCTION_CALLSTACK_ENTRY,
     CONTRACT_CALL_RUN_OUT_OF_GAS_ERROR,
+    CHEATCODE_ERROR,
 }
 
 #[napi(catch_unwind)]
@@ -155,7 +156,7 @@ pub struct CallstackEntryStackTraceEntry {
 
 impl From<CallstackEntryStackTraceEntry> for SolidityStackTraceEntry {
     fn from(val: CallstackEntryStackTraceEntry) -> Self {
-        Either24::A(val)
+        Either25::A(val)
     }
 }
 
@@ -174,7 +175,7 @@ pub struct UnrecognizedCreateCallstackEntryStackTraceEntry {
 
 impl From<UnrecognizedCreateCallstackEntryStackTraceEntry> for SolidityStackTraceEntry {
     fn from(val: UnrecognizedCreateCallstackEntryStackTraceEntry) -> Self {
-        Either24::B(val)
+        Either25::B(val)
     }
 }
 
@@ -195,7 +196,7 @@ pub struct UnrecognizedContractCallstackEntryStackTraceEntry {
 
 impl From<UnrecognizedContractCallstackEntryStackTraceEntry> for SolidityStackTraceEntry {
     fn from(val: UnrecognizedContractCallstackEntryStackTraceEntry) -> Self {
-        Either24::C(val)
+        Either25::C(val)
     }
 }
 
@@ -210,7 +211,7 @@ pub struct PrecompileErrorStackTraceEntry {
 
 impl From<PrecompileErrorStackTraceEntry> for SolidityStackTraceEntry {
     fn from(val: PrecompileErrorStackTraceEntry) -> Self {
-        Either24::D(val)
+        Either25::D(val)
     }
 }
 
@@ -227,7 +228,7 @@ pub struct RevertErrorStackTraceEntry {
 
 impl From<RevertErrorStackTraceEntry> for SolidityStackTraceEntry {
     fn from(val: RevertErrorStackTraceEntry) -> Self {
-        Either24::E(val)
+        Either25::E(val)
     }
 }
 
@@ -243,7 +244,7 @@ pub struct PanicErrorStackTraceEntry {
 
 impl From<PanicErrorStackTraceEntry> for SolidityStackTraceEntry {
     fn from(val: PanicErrorStackTraceEntry) -> Self {
-        Either24::F(val)
+        Either25::F(val)
     }
 }
 
@@ -259,7 +260,7 @@ pub struct CustomErrorStackTraceEntry {
 
 impl From<CustomErrorStackTraceEntry> for SolidityStackTraceEntry {
     fn from(val: CustomErrorStackTraceEntry) -> Self {
-        Either24::G(val)
+        Either25::G(val)
     }
 }
 
@@ -278,7 +279,7 @@ pub struct FunctionNotPayableErrorStackTraceEntry {
 
 impl From<FunctionNotPayableErrorStackTraceEntry> for SolidityStackTraceEntry {
     fn from(val: FunctionNotPayableErrorStackTraceEntry) -> Self {
-        Either24::H(val)
+        Either25::H(val)
     }
 }
 
@@ -292,7 +293,7 @@ pub struct InvalidParamsErrorStackTraceEntry {
 
 impl From<InvalidParamsErrorStackTraceEntry> for SolidityStackTraceEntry {
     fn from(val: InvalidParamsErrorStackTraceEntry) -> Self {
-        Either24::I(val)
+        Either25::I(val)
     }
 }
 
@@ -311,7 +312,7 @@ pub struct FallbackNotPayableErrorStackTraceEntry {
 
 impl From<FallbackNotPayableErrorStackTraceEntry> for SolidityStackTraceEntry {
     fn from(val: FallbackNotPayableErrorStackTraceEntry) -> Self {
-        Either24::J(val)
+        Either25::J(val)
     }
 }
 
@@ -332,7 +333,7 @@ pub struct FallbackNotPayableAndNoReceiveErrorStackTraceEntry {
 
 impl From<FallbackNotPayableAndNoReceiveErrorStackTraceEntry> for SolidityStackTraceEntry {
     fn from(val: FallbackNotPayableAndNoReceiveErrorStackTraceEntry) -> Self {
-        Either24::K(val)
+        Either25::K(val)
     }
 }
 
@@ -351,7 +352,7 @@ pub struct UnrecognizedFunctionWithoutFallbackErrorStackTraceEntry {
 
 impl From<UnrecognizedFunctionWithoutFallbackErrorStackTraceEntry> for SolidityStackTraceEntry {
     fn from(val: UnrecognizedFunctionWithoutFallbackErrorStackTraceEntry) -> Self {
-        Either24::L(val)
+        Either25::L(val)
     }
 }
 
@@ -369,7 +370,7 @@ pub struct MissingFallbackOrReceiveErrorStackTraceEntry {
 
 impl From<MissingFallbackOrReceiveErrorStackTraceEntry> for SolidityStackTraceEntry {
     fn from(val: MissingFallbackOrReceiveErrorStackTraceEntry) -> Self {
-        Either24::M(val)
+        Either25::M(val)
     }
 }
 
@@ -386,7 +387,7 @@ pub struct ReturndataSizeErrorStackTraceEntry {
 
 impl From<ReturndataSizeErrorStackTraceEntry> for SolidityStackTraceEntry {
     fn from(val: ReturndataSizeErrorStackTraceEntry) -> Self {
-        Either24::N(val)
+        Either25::N(val)
     }
 }
 
@@ -404,7 +405,7 @@ pub struct NonContractAccountCalledErrorStackTraceEntry {
 
 impl From<NonContractAccountCalledErrorStackTraceEntry> for SolidityStackTraceEntry {
     fn from(val: NonContractAccountCalledErrorStackTraceEntry) -> Self {
-        Either24::O(val)
+        Either25::O(val)
     }
 }
 
@@ -418,7 +419,7 @@ pub struct CallFailedErrorStackTraceEntry {
 
 impl From<CallFailedErrorStackTraceEntry> for SolidityStackTraceEntry {
     fn from(val: CallFailedErrorStackTraceEntry) -> Self {
-        Either24::P(val)
+        Either25::P(val)
     }
 }
 
@@ -435,7 +436,7 @@ pub struct DirectLibraryCallErrorStackTraceEntry {
 
 impl From<DirectLibraryCallErrorStackTraceEntry> for SolidityStackTraceEntry {
     fn from(val: DirectLibraryCallErrorStackTraceEntry) -> Self {
-        Either24::Q(val)
+        Either25::Q(val)
     }
 }
 
@@ -455,7 +456,7 @@ pub struct UnrecognizedCreateErrorStackTraceEntry {
 
 impl From<UnrecognizedCreateErrorStackTraceEntry> for SolidityStackTraceEntry {
     fn from(val: UnrecognizedCreateErrorStackTraceEntry) -> Self {
-        Either24::R(val)
+        Either25::R(val)
     }
 }
 
@@ -477,7 +478,7 @@ pub struct UnrecognizedContractErrorStackTraceEntry {
 
 impl From<UnrecognizedContractErrorStackTraceEntry> for SolidityStackTraceEntry {
     fn from(val: UnrecognizedContractErrorStackTraceEntry) -> Self {
-        Either24::S(val)
+        Either25::S(val)
     }
 }
 
@@ -494,7 +495,7 @@ pub struct OtherExecutionErrorStackTraceEntry {
 
 impl From<OtherExecutionErrorStackTraceEntry> for SolidityStackTraceEntry {
     fn from(val: OtherExecutionErrorStackTraceEntry) -> Self {
-        Either24::T(val)
+        Either25::T(val)
     }
 }
 
@@ -512,7 +513,7 @@ pub struct UnmappedSolc063RevertErrorStackTraceEntry {
 
 impl From<UnmappedSolc063RevertErrorStackTraceEntry> for SolidityStackTraceEntry {
     fn from(val: UnmappedSolc063RevertErrorStackTraceEntry) -> Self {
-        Either24::U(val)
+        Either25::U(val)
     }
 }
 
@@ -529,7 +530,7 @@ pub struct ContractTooLargeErrorStackTraceEntry {
 
 impl From<ContractTooLargeErrorStackTraceEntry> for SolidityStackTraceEntry {
     fn from(val: ContractTooLargeErrorStackTraceEntry) -> Self {
-        Either24::V(val)
+        Either25::V(val)
     }
 }
 
@@ -548,7 +549,7 @@ pub struct InternalFunctionCallStackEntry {
 
 impl From<InternalFunctionCallStackEntry> for SolidityStackTraceEntry {
     fn from(val: InternalFunctionCallStackEntry) -> Self {
-        Either24::W(val)
+        Either25::W(val)
     }
 }
 
@@ -566,7 +567,23 @@ pub struct ContractCallRunOutOfGasError {
 
 impl From<ContractCallRunOutOfGasError> for SolidityStackTraceEntry {
     fn from(val: ContractCallRunOutOfGasError) -> Self {
-        Either24::X(val)
+        Either25::X(val)
+    }
+}
+
+#[napi(object)]
+#[derive(Clone, Serialize)]
+pub struct CheatcodeErrorStackTraceEntry {
+    #[napi(js_name = "type", ts_type = "StackTraceEntryType.CHEATCODE_ERROR")]
+    pub type_: StackTraceEntryTypeConst<{ StackTraceEntryType::CHEATCODE_ERROR as u8 }>,
+    // The parsed cheatcode error message that can be displayed to the user
+    pub message: String,
+    pub source_reference: SourceReference,
+}
+
+impl From<CheatcodeErrorStackTraceEntry> for SolidityStackTraceEntry {
+    fn from(val: CheatcodeErrorStackTraceEntry) -> Self {
+        Either25::Y(val)
     }
 }
 
@@ -580,7 +597,7 @@ impl From<ContractCallRunOutOfGasError> for SolidityStackTraceEntry {
 // Rather, we just bite the bullet for now and use the type alias directly
 // (which falls back to `any` as it's not recognized in the context of the
 // index.d.ts file) until we finish the porting work.
-pub type SolidityStackTraceEntry = Either24<
+pub type SolidityStackTraceEntry = Either25<
     CallstackEntryStackTraceEntry,
     UnrecognizedCreateCallstackEntryStackTraceEntry,
     UnrecognizedContractCallstackEntryStackTraceEntry,
@@ -605,6 +622,7 @@ pub type SolidityStackTraceEntry = Either24<
     ContractTooLargeErrorStackTraceEntry,
     InternalFunctionCallStackEntry,
     ContractCallRunOutOfGasError,
+    CheatcodeErrorStackTraceEntry,
 >;
 
 impl TryCast<SolidityStackTraceEntry> for edr_solidity::solidity_stack_trace::StackTraceEntry {
@@ -663,6 +681,15 @@ impl TryCast<SolidityStackTraceEntry> for edr_solidity::solidity_stack_trace::St
                 source_reference: source_reference.map(std::convert::Into::into),
             }
             .into(),
+            StackTraceEntry::CheatCodeError {
+                message,
+                source_reference,
+            } => CheatcodeErrorStackTraceEntry {
+                type_: StackTraceEntryTypeConst,
+                message,
+                source_reference: source_reference.into(),
+            }
+            .into(),
             StackTraceEntry::CustomError {
                 message,
                 source_reference,

package/src/ts/solidity_tests.ts

@@ -0,0 +1,46 @@
+import { StandardTestKind, FuzzTestKind, InvariantTestKind } from "../../index";
+
+export enum SortOrder {
+  Ascending,
+  Descending,
+}
+
+export interface GasUsageFilter {
+  minThreshold?: bigint;
+  maxThreshold?: bigint;
+}
+
+export function extractGasUsage(
+  testResults: {
+    name: string;
+    kind: StandardTestKind | FuzzTestKind | InvariantTestKind;
+  }[],
+  filter?: GasUsageFilter,
+  ordering?: SortOrder
+): { name: string; gas: bigint }[] {
+  const gasUsage: { name: string; gas: bigint }[] = [];
+
+  for (const result of testResults) {
+    // Default to zero gas for invariant tests
+    const gas = "consumedGas" in result.kind
+      ? result.kind.consumedGas
+      : "medianGas" in result.kind
+        ? result.kind.medianGas
+        : BigInt(0);
+
+    if (
+      (!filter?.minThreshold || gas >= filter.minThreshold) &&
+      (!filter?.maxThreshold || gas <= filter.maxThreshold)
+    ) {
+      gasUsage.push({ name: result.name, gas });
+    }
+  }
+
+  if (ordering === SortOrder.Ascending) {
+    gasUsage.sort((a, b) => (a.gas < b.gas ? -1 : a.gas > b.gas ? 1 : 0));
+  } else if (ordering === SortOrder.Descending) {
+    gasUsage.sort((a, b) => (a.gas > b.gas ? -1 : a.gas < b.gas ? 1 : 0));
+  }
+
+  return gasUsage;
+}

package/Cargo.toml

@@ -1,92 +0,0 @@
-[package]
-name = "edr_napi"
-version.workspace = true
-edition.workspace = true
-
-[lib]
-crate-type = ["cdylib"]
-
-[dependencies]
-alloy-dyn-abi.workspace = true
-alloy-json-abi.workspace = true
-alloy-sol-types.workspace = true
-derive_more.workspace = true
-derive-where.workspace = true
-edr_coverage.workspace = true
-edr_defaults = { path = "../edr_defaults" }
-edr_eth = { path = "../edr_eth" }
-edr_evm = { path = "../edr_evm" }
-edr_generic = { path = "../edr_generic" }
-edr_instrument = { path = "../edr_instrument" }
-edr_napi_core = { path = "../edr_napi_core" }
-edr_op = { path = "../edr_op", optional = true }
-edr_provider = { path = "../edr_provider" }
-edr_rpc_client = { path = "../edr_rpc_client" }
-edr_scenarios = { version = "0.3.5", path = "../edr_scenarios", optional = true }
-edr_solidity = { version = "0.3.5", path = "../edr_solidity" }
-k256 = { version = "0.13.1", default-features = false, features = [
-    "arithmetic",
-    "ecdsa",
-    "pkcs8",
-] }
-mimalloc = { version = "0.1.39", default-features = false, features = [
-    "local_dynamic_tls",
-] }
-# The `async` feature ensures that a tokio runtime is available
-napi = { version = "2.16.17", default-features = false, features = [
-    "async",
-    "error_anyhow",
-    "napi8",
-    "serde-json",
-] }
-napi-derive = "2.16.13"
-rand = { version = "0.8.4", optional = true }
-semver = "1.0.22"
-serde.workspace = true
-serde_json.workspace = true
-static_assertions = "1.1.0"
-strum = { version = "0.26.0", features = ["derive"] }
-thiserror = { version = "1.0.37", default-features = false }
-tracing = { version = "0.1.37", default-features = false, features = ["std"] }
-tracing-flame = { version = "0.2.0", default-features = false, features = [
-    "smallvec",
-] }
-tracing-subscriber = { version = "0.3.18", default-features = false, features = [
-    "ansi",
-    "env-filter",
-    "fmt",
-    "parking_lot",
-    "smallvec",
-    "std",
-] }
-
-# Solidity tests
-edr_solidity_tests.workspace = true
-foundry-cheatcodes.workspace = true
-foundry-compilers.workspace = true
-edr_common.workspace = true
-tempfile = "3.10.1"
-
-[target.x86_64-unknown-linux-gnu.dependencies]
-openssl-sys = { version = "0.9.93", features = ["vendored"] }
-
-[target.x86_64-unknown-linux-musl.dependencies]
-openssl-sys = { version = "0.9.93", features = ["vendored"] }
-
-[target.aarch64-unknown-linux-gnu.dependencies]
-openssl-sys = { version = "0.9.93", features = ["vendored"] }
-
-[target.aarch64-unknown-linux-musl.dependencies]
-openssl-sys = { version = "0.9.93", features = ["vendored"] }
-
-[build-dependencies]
-napi-build = "2.0.1"
-
-[features]
-op = ["dep:edr_op"]
-scenarios = ["dep:edr_scenarios", "dep:rand"]
-tracing = ["edr_evm/tracing", "edr_napi_core/tracing", "edr_provider/tracing"]
-test-mock = []
-
-[lints]
-workspace = true

package/build.rs

@@ -1,3 +0,0 @@
-fn main() {
-    napi_build::setup();
-}