@nomicfoundation/edr 0.12.0-next.24 → 0.12.0-next.26

package/index.d.ts

@@ -273,6 +273,13 @@ export interface ObservabilityConfig {
   codeCoverage?: CodeCoverageConfig
   /** If present, configures runtime observability to collect gas reports. */
   gasReport?: GasReportConfig
+  /**
+   * Controls when to include call traces in the results of transaction
+   * execution.
+   *
+   * Defaults to `IncludeTraces.None`.
+   */
+  includeCallTraces?: IncludeTraces
 }
 /** Configuration for a provider */
 export interface ProviderConfig {
@@ -415,6 +422,13 @@ export interface DeploymentGasReport {
 export interface FunctionGasReport {
   gas: bigint
   status: GasReportExecutionStatus
+  /**
+   * The proxy delegation chain for this call, if the called contract is a
+   * proxy. Contains contract identifiers from outermost proxy to final
+   * implementation, e.g. `["Proxy", "Implementation"]`.
+   * Empty if the call is not through a proxy.
+   */
+  proxyChain: Array<string>
 }
 export interface InstrumentationResult {
   /** The generated source code with coverage instrumentation. */
@@ -974,15 +988,21 @@ export enum CollectStackTraces {
   OnFailure = 1
 }
 /**
- * Configuration for [`SolidityTestRunnerConfigArgs::include_traces`] that
- * controls execution trace decoding and inclusion in test results.
+ * Configuration that controls whether execution traces are decoded and
+ * included in results.
+ *
+ * This can either be for Solidity test results or provider transaction
+ * execution results.
  */
 export enum IncludeTraces {
-  /** No traces will be included in any test result. */
+  /** No traces will be included at all. */
   None = 0,
-  /** Traces will be included only on the results of failed tests. */
+  /**
+   * Traces will be included only on the results of failed tests or
+   * execution.
+   */
   Failing = 1,
-  /** Traces will be included in all test results. */
+  /** Traces will be included for all test results or executed transactions. */
   All = 2
 }
 /** Test function level config override. */
@@ -1523,11 +1543,6 @@ export interface TracingMessageResult {
   /** Execution result */
   readonly executionResult: ExecutionResult
 }
-/**
- * Returns the latest version of solc that EDR officially
- * supports and is tested against.
- */
-export declare function getLatestSupportedSolcVersion(): string
 export interface Withdrawal {
   /** The index of withdrawal */
   index: bigint
@@ -1586,9 +1601,15 @@ export declare class Response {
   /**Returns the response data as a JSON string or a JSON object. */
   get data(): string | any
   /**Compute the error stack trace. Return the stack trace if it can be decoded, otherwise returns none. Throws if there was an error computing the stack trace. */
-  stackTrace(): SolidityStackTrace | null
-  /**Returns the raw traces of executed contracts. This maybe contain zero or more traces. */
-  get traces(): Array<RawTrace>
+  stackTrace(): StackTrace | UnexpectedError | HeuristicFailed | null
+  /**
+   * Constructs the execution traces for the request. Returns an empty array
+   * if traces are not enabled for this provider according to
+   * [`crate::solidity_tests::config::SolidityTestRunnerConfigArgs::include_traces`]. Otherwise, returns
+   * an array of the root calls of the trace, which always includes the
+   * request's call itself.
+   */
+  callTraces(): Array<CallTrace>
 }
 /** A JSON-RPC provider for Ethereum. */
 export declare class Provider {

package/index.js

@@ -310,7 +310,7 @@ if (!nativeBinding) {
   throw new Error(`Failed to load native binding`)
 }
 
-const { GENERIC_CHAIN_TYPE, genericChainProviderFactory, L1_CHAIN_TYPE, l1GenesisState, l1ProviderFactory, SpecId, l1HardforkFromString, l1HardforkToString, l1HardforkLatest, FRONTIER, FRONTIER_THAWING, HOMESTEAD, DAO_FORK, TANGERINE, SPURIOUS_DRAGON, BYZANTIUM, CONSTANTINOPLE, PETERSBURG, ISTANBUL, MUIR_GLACIER, BERLIN, LONDON, ARROW_GLACIER, GRAY_GLACIER, MERGE, SHANGHAI, CANCUN, PRAGUE, OSAKA, OpHardfork, opHardforkFromString, opHardforkToString, opLatestHardfork, OP_CHAIN_TYPE, opGenesisState, opProviderFactory, BEDROCK, REGOLITH, CANYON, ECOTONE, FJORD, GRANITE, HOLOCENE, ISTHMUS, MineOrdering, EdrContext, ContractDecoder, GasReportExecutionStatus, addStatementCoverageInstrumentation, latestSupportedSolidityVersion, Precompile, precompileP256Verify, ProviderFactory, Response, Provider, SuccessReason, ExceptionalHalt, CheatcodeErrorCode, CachedChains, CachedEndpoints, FsAccessPermission, CollectStackTraces, IncludeTraces, SolidityTestRunnerFactory, l1SolidityTestRunnerFactory, opSolidityTestRunnerFactory, SuiteResult, TestResult, TestStatus, CallKind, LogKind, linkHexStringBytecode, printStackTrace, Exit, ExitCode, BytecodeWrapper, ContractFunctionType, ReturnData, StackTraceEntryType, stackTraceEntryTypeToString, FALLBACK_FUNCTION_NAME, RECEIVE_FUNCTION_NAME, CONSTRUCTOR_FUNCTION_NAME, UNRECOGNIZED_FUNCTION_NAME, UNKNOWN_FUNCTION_NAME, PRECOMPILE_FUNCTION_NAME, UNRECOGNIZED_CONTRACT_NAME, RawTrace, getLatestSupportedSolcVersion } = nativeBinding
+const { GENERIC_CHAIN_TYPE, genericChainProviderFactory, L1_CHAIN_TYPE, l1GenesisState, l1ProviderFactory, SpecId, l1HardforkFromString, l1HardforkToString, l1HardforkLatest, FRONTIER, FRONTIER_THAWING, HOMESTEAD, DAO_FORK, TANGERINE, SPURIOUS_DRAGON, BYZANTIUM, CONSTANTINOPLE, PETERSBURG, ISTANBUL, MUIR_GLACIER, BERLIN, LONDON, ARROW_GLACIER, GRAY_GLACIER, MERGE, SHANGHAI, CANCUN, PRAGUE, OSAKA, OpHardfork, opHardforkFromString, opHardforkToString, opLatestHardfork, OP_CHAIN_TYPE, opGenesisState, opProviderFactory, BEDROCK, REGOLITH, CANYON, ECOTONE, FJORD, GRANITE, HOLOCENE, ISTHMUS, MineOrdering, EdrContext, ContractDecoder, GasReportExecutionStatus, addStatementCoverageInstrumentation, latestSupportedSolidityVersion, Precompile, precompileP256Verify, ProviderFactory, Response, Provider, SuccessReason, ExceptionalHalt, CheatcodeErrorCode, CachedChains, CachedEndpoints, FsAccessPermission, CollectStackTraces, IncludeTraces, SolidityTestRunnerFactory, l1SolidityTestRunnerFactory, opSolidityTestRunnerFactory, SuiteResult, TestResult, TestStatus, CallKind, LogKind, linkHexStringBytecode, printStackTrace, Exit, ExitCode, BytecodeWrapper, ContractFunctionType, ReturnData, StackTraceEntryType, stackTraceEntryTypeToString, FALLBACK_FUNCTION_NAME, RECEIVE_FUNCTION_NAME, CONSTRUCTOR_FUNCTION_NAME, UNRECOGNIZED_FUNCTION_NAME, UNKNOWN_FUNCTION_NAME, PRECOMPILE_FUNCTION_NAME, UNRECOGNIZED_CONTRACT_NAME, RawTrace } = nativeBinding
 
 module.exports.GENERIC_CHAIN_TYPE = GENERIC_CHAIN_TYPE
 module.exports.genericChainProviderFactory = genericChainProviderFactory
@@ -400,4 +400,3 @@ module.exports.UNKNOWN_FUNCTION_NAME = UNKNOWN_FUNCTION_NAME
 module.exports.PRECOMPILE_FUNCTION_NAME = PRECOMPILE_FUNCTION_NAME
 module.exports.UNRECOGNIZED_CONTRACT_NAME = UNRECOGNIZED_CONTRACT_NAME
 module.exports.RawTrace = RawTrace
-module.exports.getLatestSupportedSolcVersion = getLatestSupportedSolcVersion

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nomicfoundation/edr",
-  "version": "0.12.0-next.24",
+  "version": "0.12.0-next.26",
   "devDependencies": {
     "@napi-rs/cli": "^2.18.4",
     "@nomicfoundation/ethereumjs-util": "^9.0.4",
@@ -58,13 +58,13 @@
   "repository": "NomicFoundation/edr.git",
   "types": "index.d.ts",
   "dependencies": {
-    "@nomicfoundation/edr-darwin-arm64": "0.12.0-next.24",
-    "@nomicfoundation/edr-darwin-x64": "0.12.0-next.24",
-    "@nomicfoundation/edr-linux-arm64-gnu": "0.12.0-next.24",
-    "@nomicfoundation/edr-linux-arm64-musl": "0.12.0-next.24",
-    "@nomicfoundation/edr-linux-x64-gnu": "0.12.0-next.24",
-    "@nomicfoundation/edr-linux-x64-musl": "0.12.0-next.24",
-    "@nomicfoundation/edr-win32-x64-msvc": "0.12.0-next.24"
+    "@nomicfoundation/edr-darwin-arm64": "0.12.0-next.26",
+    "@nomicfoundation/edr-darwin-x64": "0.12.0-next.26",
+    "@nomicfoundation/edr-linux-arm64-gnu": "0.12.0-next.26",
+    "@nomicfoundation/edr-linux-arm64-musl": "0.12.0-next.26",
+    "@nomicfoundation/edr-linux-x64-gnu": "0.12.0-next.26",
+    "@nomicfoundation/edr-linux-x64-musl": "0.12.0-next.26",
+    "@nomicfoundation/edr-win32-x64-msvc": "0.12.0-next.26"
   },
   "scripts": {
     "artifacts": "napi artifacts",

package/src/chains/generic.rs

@@ -10,6 +10,7 @@ use edr_provider::time::CurrentTime;
 use edr_solidity::contract_decoder::ContractDecoder;
 use napi::tokio::runtime;
 use napi_derive::napi;
+use parking_lot::RwLock;
 
 use crate::provider::ProviderFactory;
 
@@ -22,7 +23,7 @@ impl SyncProviderFactory for GenericChainProviderFactory {
         provider_config: edr_napi_core::provider::Config,
         logger_config: edr_napi_core::logger::Config,
         subscription_callback: edr_napi_core::subscription::Callback,
-        contract_decoder: Arc<ContractDecoder>,
+        contract_decoder: Arc<RwLock<ContractDecoder>>,
     ) -> napi::Result<Arc<dyn SyncProvider>> {
         let logger = Logger::<GenericChainSpec, CurrentTime>::new(
             logger_config,

package/src/chains/l1.rs

@@ -17,6 +17,7 @@ use napi::{
     tokio::runtime,
 };
 use napi_derive::napi;
+use parking_lot::RwLock;
 
 use crate::{account::AccountOverride, provider::ProviderFactory};
 
@@ -29,7 +30,7 @@ impl SyncProviderFactory for L1ProviderFactory {
         provider_config: edr_napi_core::provider::Config,
         logger_config: edr_napi_core::logger::Config,
         subscription_callback: edr_napi_core::subscription::Callback,
-        contract_decoder: Arc<ContractDecoder>,
+        contract_decoder: Arc<RwLock<ContractDecoder>>,
     ) -> napi::Result<Arc<dyn SyncProvider>> {
         let logger =
             Logger::<L1ChainSpec, CurrentTime>::new(logger_config, Arc::clone(&contract_decoder))?;

package/src/chains/op.rs

@@ -21,6 +21,7 @@ use napi::{
     tokio::runtime,
 };
 use napi_derive::napi;
+use parking_lot::RwLock;
 
 use crate::{
     account::{AccountOverride, StorageSlot},
@@ -36,7 +37,7 @@ impl SyncProviderFactory for OpProviderFactory {
         provider_config: edr_napi_core::provider::Config,
         logger_config: edr_napi_core::logger::Config,
         subscription_callback: edr_napi_core::subscription::Callback,
-        contract_decoder: Arc<ContractDecoder>,
+        contract_decoder: Arc<RwLock<ContractDecoder>>,
     ) -> napi::Result<Arc<dyn SyncProvider>> {
         let logger =
             Logger::<OpChainSpec, CurrentTime>::new(logger_config, Arc::clone(&contract_decoder))?;

package/src/config.rs

@@ -22,7 +22,8 @@ use napi_derive::napi;
 
 use crate::{
     account::AccountOverride, block::BlobGas, cast::TryCast, gas_report::GasReport,
-    logger::LoggerConfig, precompile::Precompile, subscription::SubscriptionConfig,
+    logger::LoggerConfig, precompile::Precompile, solidity_tests::config::IncludeTraces,
+    subscription::SubscriptionConfig,
 };
 
 /// Configuration for EIP-1559 parameters
@@ -183,6 +184,11 @@ pub struct ObservabilityConfig {
     pub code_coverage: Option<CodeCoverageConfig>,
     /// If present, configures runtime observability to collect gas reports.
     pub gas_report: Option<GasReportConfig>,
+    /// Controls when to include call traces in the results of transaction
+    /// execution.
+    ///
+    /// Defaults to `IncludeTraces.None`.
+    pub include_call_traces: Option<IncludeTraces>,
 }
 
 /// Configuration for a provider
@@ -524,10 +530,16 @@ impl ObservabilityConfig {
             },
         ).transpose()?;
 
+        let default_config = edr_provider::observability::Config::default();
         Ok(edr_provider::observability::Config {
+            call_override: default_config.call_override,
+            include_call_traces: self.include_call_traces.map_or(
+                default_config.include_call_traces,
+                edr_solidity::config::IncludeTraces::from,
+            ),
             on_collected_coverage_fn,
             on_collected_gas_report_fn,
-            ..edr_provider::observability::Config::default()
+            verbose_raw_tracing: default_config.verbose_raw_tracing,
         })
     }
 }

package/src/context.rs

@@ -1,9 +1,9 @@
 use std::sync::Arc;
 
+use edr_decoder_revert::RevertDecoder;
 use edr_napi_core::{provider::SyncProviderFactory, solidity};
 use edr_primitives::HashMap;
 use edr_solidity_tests::{
-    decode::RevertDecoder,
     multi_runner::{SuiteResultAndArtifactId, TestContract, TestContracts},
     TestFilterConfig,
 };
@@ -251,7 +251,7 @@ impl EdrContext {
 
             let test_suites = try_or_reject_deferred!(test_suites
                 .into_iter()
-                .map(edr_solidity::artifacts::ArtifactId::try_from)
+                .map(edr_artifact::ArtifactId::try_from)
                 .collect::<Result<Vec<_>, _>>());
 
             let contracts = try_or_reject_deferred!(test_suites

package/src/contract_decoder.rs

@@ -1,12 +1,13 @@
 use std::sync::Arc;
 
 use napi_derive::napi;
+use parking_lot::RwLock;
 
 use crate::config::TracingConfigWithBuffers;
 
 #[napi]
 pub struct ContractDecoder {
-    inner: Arc<edr_solidity::contract_decoder::ContractDecoder>,
+    inner: Arc<RwLock<edr_solidity::contract_decoder::ContractDecoder>>,
 }
 
 #[napi]
@@ -17,7 +18,7 @@ impl ContractDecoder {
     #[allow(clippy::new_without_default)]
     pub fn new() -> Self {
         Self {
-            inner: Arc::new(edr_solidity::contract_decoder::ContractDecoder::default()),
+            inner: Arc::default(),
         }
     }
 
@@ -32,7 +33,7 @@ impl ContractDecoder {
         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)),
+                |contract_decoder| Ok(Arc::new(RwLock::new(contract_decoder))),
             )?;
 
         Ok(Self {
@@ -43,13 +44,15 @@ impl ContractDecoder {
 
 impl ContractDecoder {
     /// Returns a reference to the inner contract decoder.
-    pub fn as_inner(&self) -> &Arc<edr_solidity::contract_decoder::ContractDecoder> {
+    pub fn as_inner(&self) -> &Arc<RwLock<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 {
+impl From<Arc<RwLock<edr_solidity::contract_decoder::ContractDecoder>>> for ContractDecoder {
+    fn from(
+        contract_decoder: Arc<RwLock<edr_solidity::contract_decoder::ContractDecoder>>,
+    ) -> Self {
         Self {
             inner: contract_decoder,
         }

package/src/gas_report.rs

@@ -32,6 +32,11 @@ pub struct DeploymentGasReport {
 pub struct FunctionGasReport {
     pub gas: BigInt,
     pub status: GasReportExecutionStatus,
+    /// The proxy delegation chain for this call, if the called contract is a
+    /// proxy. Contains contract identifiers from outermost proxy to final
+    /// implementation, e.g. `["Proxy", "Implementation"]`.
+    /// Empty if the call is not through a proxy.
+    pub proxy_chain: Vec<String>,
 }
 
 impl From<edr_gas_report::GasReport> for GasReport {
@@ -87,6 +92,7 @@ impl From<edr_gas_report::FunctionGasReport> for FunctionGasReport {
         Self {
             gas: BigInt::from(value.gas),
             status: value.status.into(),
+            proxy_chain: value.proxy_chain,
         }
     }
 }

package/src/mock.rs

@@ -2,10 +2,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;
 use napi::tokio::runtime;
 use napi_derive::napi;
 
@@ -23,19 +21,15 @@ impl MockProvider {
 }
 
 impl SyncProvider for MockProvider {
-    fn handle_request(
-        &self,
-        _request: String,
-        _contract_decoder: Arc<ContractDecoder>,
-    ) -> napi::Result<edr_napi_core::spec::Response<EvmHaltReason>> {
+    fn handle_request(&self, _request: String) -> napi::Result<edr_napi_core::spec::Response> {
         let response = jsonrpc::ResponseData::Success {
             result: self.mocked_response.clone(),
         };
         edr_napi_core::spec::marshal_response_data(response)
             .map(|data| edr_napi_core::spec::Response {
-                solidity_trace: None,
                 data,
-                traces: Vec::new(),
+                stack_trace_result: None,
+                call_trace_arenas: Vec::new(),
             })
             .map_err(|error| napi::Error::new(napi::Status::GenericFailure, error.to_string()))
     }
@@ -61,7 +55,7 @@ impl EdrContext {
         let provider = Provider::new(
             Arc::new(MockProvider::new(mocked_response)),
             runtime::Handle::current(),
-            Arc::new(ContractDecoder::default()),
+            Arc::default(),
             #[cfg(feature = "scenarios")]
             None,
         );

package/src/provider/response.rs

@@ -1,21 +1,22 @@
-use edr_chain_spec::EvmHaltReason;
-use edr_napi_core::spec::SolidityTraceData;
-use edr_solidity::contract_decoder::NestedTraceDecoder as _;
-use napi::Either;
+use edr_solidity::solidity_stack_trace::StackTraceCreationResult;
+use napi::{bindgen_prelude::Either3, Either};
 use napi_derive::napi;
 
 use crate::{
-    cast::TryCast,
-    trace::{solidity_stack_trace::SolidityStackTrace, RawTrace},
+    solidity_tests::test_results::{CallTrace, HeuristicFailed, StackTrace, UnexpectedError},
+    trace::solidity_stack_trace::{
+        solidity_stack_trace_error_to_napi, solidity_stack_trace_heuristic_failed_to_napi,
+        solidity_stack_trace_success_to_napi,
+    },
 };
 
 #[napi]
 pub struct Response {
-    inner: edr_napi_core::spec::Response<EvmHaltReason>,
+    inner: edr_napi_core::spec::Response,
 }
 
-impl From<edr_napi_core::spec::Response<EvmHaltReason>> for Response {
-    fn from(value: edr_napi_core::spec::Response<EvmHaltReason>) -> Self {
+impl From<edr_napi_core::spec::Response> for Response {
+    fn from(value: edr_napi_core::spec::Response) -> Self {
         Self { inner: value }
     }
 }
@@ -28,46 +29,47 @@ impl Response {
         self.inner.data.clone()
     }
 
-    // Rust port of https://github.com/NomicFoundation/hardhat/blob/c20bf195a6efdc2d74e778b7a4a7799aac224841/packages/hardhat-core/src/internal/hardhat-network/provider/provider.ts#L590
     #[doc = "Compute the error stack trace. Return the stack trace if it can be decoded, otherwise returns none. Throws if there was an error computing the stack trace."]
     #[napi(catch_unwind)]
-    pub fn stack_trace(&self) -> napi::Result<Option<SolidityStackTrace>> {
-        let Some(SolidityTraceData {
-            trace,
-            contract_decoder,
-        }) = &self.inner.solidity_trace
-        else {
-            return Ok(None);
-        };
-        let nested_trace = edr_solidity::nested_tracer::convert_trace_messages_to_nested_trace(
-            trace.as_ref().clone(),
-        )
-        .map_err(|err| napi::Error::from_reason(err.to_string()))?;
-
-        if let Some(vm_trace) = nested_trace {
-            let decoded_trace = contract_decoder
-                .try_to_decode_nested_trace(vm_trace)
-                .map_err(|err| napi::Error::from_reason(err.to_string()))?;
-            let stack_trace = edr_solidity::solidity_tracer::get_stack_trace(decoded_trace)
-                .map_err(|err| napi::Error::from_reason(err.to_string()))?;
-            let stack_trace = stack_trace
-                .into_iter()
-                .map(TryCast::try_cast)
-                .collect::<Result<Vec<_>, _>>()?;
-
-            Ok(Some(stack_trace))
-        } else {
-            Ok(None)
-        }
+    pub fn stack_trace(&self) -> Option<Either3<StackTrace, UnexpectedError, HeuristicFailed>> {
+        self.inner
+            .stack_trace_result
+            .as_ref()
+            .map(|stack_trace_result| match stack_trace_result {
+                StackTraceCreationResult::Success(stack_trace) => {
+                    Either3::A(solidity_stack_trace_success_to_napi(stack_trace))
+                }
+                StackTraceCreationResult::Error(error) => {
+                    Either3::B(solidity_stack_trace_error_to_napi(error))
+                }
+                StackTraceCreationResult::HeuristicFailed => {
+                    Either3::C(solidity_stack_trace_heuristic_failed_to_napi())
+                }
+            })
     }
 
-    #[doc = "Returns the raw traces of executed contracts. This maybe contain zero or more traces."]
-    #[napi(catch_unwind, getter)]
-    pub fn traces(&self) -> Vec<RawTrace> {
+    /// Constructs the execution traces for the request. Returns an empty array
+    /// if traces are not enabled for this provider according to
+    /// [`crate::solidity_tests::config::SolidityTestRunnerConfigArgs::include_traces`]. Otherwise, returns
+    /// an array of the root calls of the trace, which always includes the
+    /// request's call itself.
+    #[napi(catch_unwind)]
+    pub fn call_traces(&self) -> Vec<CallTrace> {
         self.inner
-            .traces
+            .call_trace_arenas
             .iter()
-            .map(|trace| RawTrace::from(trace.clone()))
+            .map(|call_trace_arena| CallTrace::from_arena_node(call_trace_arena, 0))
             .collect()
     }
+
+    // TODO(#1288): Add backwards compatibility layer for Hardhat 2
+    // #[doc = "Returns the raw traces of executed contracts. This maybe contain
+    // zero or more traces."] #[napi(catch_unwind, getter)]
+    // pub fn traces(&self) -> Vec<RawTrace> {
+    //     self.inner
+    //         .call_trace_arenas
+    //         .iter()
+    //         .map(|trace| RawTrace::from(trace.clone()))
+    //         .collect()
+    // }
 }

package/src/provider.rs

@@ -8,6 +8,7 @@ use edr_napi_core::provider::SyncProvider;
 use edr_solidity::compiler::create_models_and_decode_bytecodes;
 use napi::{tokio::runtime, Env, JsFunction, JsObject, Status};
 use napi_derive::napi;
+use parking_lot::RwLock;
 
 pub use self::factory::ProviderFactory;
 use self::response::Response;
@@ -16,7 +17,7 @@ use crate::{call_override::CallOverrideCallback, contract_decoder::ContractDecod
 /// A JSON-RPC provider for Ethereum.
 #[napi]
 pub struct Provider {
-    contract_decoder: Arc<edr_solidity::contract_decoder::ContractDecoder>,
+    contract_decoder: Arc<RwLock<edr_solidity::contract_decoder::ContractDecoder>>,
     provider: Arc<dyn SyncProvider>,
     runtime: runtime::Handle,
     #[cfg(feature = "scenarios")]
@@ -28,7 +29,7 @@ impl Provider {
     pub fn new(
         provider: Arc<dyn SyncProvider>,
         runtime: runtime::Handle,
-        contract_decoder: Arc<edr_solidity::contract_decoder::ContractDecoder>,
+        contract_decoder: Arc<RwLock<edr_solidity::contract_decoder::ContractDecoder>>,
         #[cfg(feature = "scenarios")] scenario_file: Option<
             napi::tokio::sync::Mutex<napi::tokio::fs::File>,
         >,
@@ -76,6 +77,7 @@ impl Provider {
                     }
                 };
 
+                let mut contract_decoder = contract_decoder.write();
                 for contract in contracts {
                     contract_decoder.add_contract_metadata(contract);
                 }
@@ -102,10 +104,8 @@ impl Provider {
             crate::scenarios::write_request(scenario_file, &request).await?;
         }
 
-        let contract_decoder = Arc::clone(&self.contract_decoder);
-
         self.runtime
-            .spawn_blocking(move || provider.handle_request(request, contract_decoder))
+            .spawn_blocking(move || provider.handle_request(request))
             .await
             .map_err(|error| napi::Error::new(Status::GenericFailure, error.to_string()))?
             .map(Response::from)

package/src/solidity_tests/artifact.rs

@@ -27,8 +27,8 @@ pub struct ArtifactId {
     pub solc_version: String,
 }
 
-impl From<edr_solidity::artifacts::ArtifactId> for ArtifactId {
-    fn from(value: edr_solidity::artifacts::ArtifactId) -> Self {
+impl From<edr_artifact::ArtifactId> for ArtifactId {
+    fn from(value: edr_artifact::ArtifactId) -> Self {
         Self {
             name: value.name,
             source: value.source.to_string_lossy().to_string(),
@@ -37,11 +37,11 @@ impl From<edr_solidity::artifacts::ArtifactId> for ArtifactId {
     }
 }
 
-impl TryFrom<ArtifactId> for edr_solidity::artifacts::ArtifactId {
+impl TryFrom<ArtifactId> for edr_artifact::ArtifactId {
     type Error = napi::Error;
 
     fn try_from(value: ArtifactId) -> napi::Result<Self> {
-        Ok(edr_solidity::artifacts::ArtifactId {
+        Ok(edr_artifact::ArtifactId {
             name: value.name,
             source: value.source.parse().map_err(|_err| {
                 napi::Error::new(napi::Status::GenericFailure, "Invalid source path")

package/src/solidity_tests/config.rs

@@ -822,36 +822,40 @@ impl From<CollectStackTraces> for edr_solidity_tests::CollectStackTraces {
     }
 }
 
-/// Configuration for [`SolidityTestRunnerConfigArgs::include_traces`] that
-/// controls execution trace decoding and inclusion in test results.
+/// Configuration that controls whether execution traces are decoded and
+/// included in results.
+///
+/// This can either be for Solidity test results or provider transaction
+/// execution results.
 #[napi]
 #[derive(Debug, Default, PartialEq, Eq, serde::Serialize)]
 pub enum IncludeTraces {
-    /// No traces will be included in any test result.
+    /// No traces will be included at all.
     #[default]
     None,
-    /// Traces will be included only on the results of failed tests.
+    /// Traces will be included only on the results of failed tests or
+    /// execution.
     Failing,
-    /// Traces will be included in all test results.
+    /// Traces will be included for all test results or executed transactions.
     All,
 }
 
-impl From<IncludeTraces> for edr_solidity_tests::IncludeTraces {
+impl From<IncludeTraces> for edr_solidity::config::IncludeTraces {
     fn from(value: IncludeTraces) -> Self {
         match value {
-            IncludeTraces::None => edr_solidity_tests::IncludeTraces::None,
-            IncludeTraces::Failing => edr_solidity_tests::IncludeTraces::Failing,
-            IncludeTraces::All => edr_solidity_tests::IncludeTraces::All,
+            IncludeTraces::None => edr_solidity::config::IncludeTraces::None,
+            IncludeTraces::Failing => edr_solidity::config::IncludeTraces::Failing,
+            IncludeTraces::All => edr_solidity::config::IncludeTraces::All,
         }
     }
 }
 
-impl From<edr_solidity_tests::IncludeTraces> for IncludeTraces {
-    fn from(value: edr_solidity_tests::IncludeTraces) -> Self {
+impl From<edr_solidity::config::IncludeTraces> for IncludeTraces {
+    fn from(value: edr_solidity::config::IncludeTraces) -> Self {
         match value {
-            edr_solidity_tests::IncludeTraces::None => IncludeTraces::None,
-            edr_solidity_tests::IncludeTraces::Failing => IncludeTraces::Failing,
-            edr_solidity_tests::IncludeTraces::All => IncludeTraces::All,
+            edr_solidity::config::IncludeTraces::None => IncludeTraces::None,
+            edr_solidity::config::IncludeTraces::Failing => IncludeTraces::Failing,
+            edr_solidity::config::IncludeTraces::All => IncludeTraces::All,
         }
     }
 }

package/src/solidity_tests/l1.rs

@@ -1,14 +1,14 @@
 use std::{collections::BTreeMap, sync::Arc};
 
+use edr_artifact::ArtifactId;
+use edr_decoder_revert::RevertDecoder;
 use edr_napi_core::solidity::{
     config::{TestRunnerConfig, TracingConfigWithBuffers},
     SyncTestRunner, SyncTestRunnerFactory,
 };
 use edr_primitives::Bytes;
-use edr_solidity::artifacts::ArtifactId;
 use edr_solidity_tests::{
     contracts::ContractsByArtifact,
-    decode::RevertDecoder,
     evm_context::L1EvmBuilder,
     multi_runner::TestContract,
     revm::context::{BlockEnv, TxEnv},

package/src/solidity_tests/op.rs

@@ -1,15 +1,15 @@
 use std::{collections::BTreeMap, sync::Arc};
 
+use edr_artifact::ArtifactId;
+use edr_decoder_revert::RevertDecoder;
 use edr_napi_core::solidity::{
     config::{TestRunnerConfig, TracingConfigWithBuffers},
     SyncTestRunner, SyncTestRunnerFactory,
 };
 use edr_op::{solidity_tests::OpEvmBuilder, transaction::OpTxEnv};
 use edr_primitives::Bytes;
-use edr_solidity::artifacts::ArtifactId;
 use edr_solidity_tests::{
     contracts::ContractsByArtifact,
-    decode::RevertDecoder,
     multi_runner::TestContract,
     revm::context::{BlockEnv, TxEnv},
     MultiContractRunner,

package/src/solidity_tests/runner.rs

@@ -4,9 +4,12 @@ use edr_chain_spec::HaltReasonTrait;
 use edr_napi_core::solidity::config::TracingConfigWithBuffers;
 use edr_solidity::{
     artifacts::BuildInfoConfigWithBuffers,
-    contract_decoder::{ContractDecoder, ContractDecoderError, NestedTraceDecoder},
+    contract_decoder::{
+        ContractDecoder, ContractDecoderError, NestedTraceDecoder, NestedTraceDecoderMut as _,
+    },
     nested_trace::NestedTrace,
 };
+use parking_lot::RwLock;
 
 /// Only parses the tracing config which is very expensive if the contract
 /// decoder is used.
@@ -15,7 +18,7 @@ pub(crate) struct LazyContractDecoder {
     // We need the `Mutex`, because `Uint8Array` is not `Sync`
     tracing_config: Mutex<TracingConfigWithBuffers>,
     // Storing the result so that we can propagate the error
-    contract_decoder: OnceLock<Result<ContractDecoder, ContractDecoderError>>,
+    contract_decoder: OnceLock<Result<RwLock<ContractDecoder>, ContractDecoderError>>,
 }
 
 impl LazyContractDecoder {
@@ -42,10 +45,10 @@ impl<HaltReasonT: HaltReasonTrait> NestedTraceDecoder<HaltReasonT> for LazyContr
                     BuildInfoConfigWithBuffers::from(&*tracing_config),
                 )
                 .map_err(|err| ContractDecoderError::Initialization(err.to_string()))
-                .and_then(|config| ContractDecoder::new(&config))
+                .and_then(|config| ContractDecoder::new(&config).map(RwLock::new))
             })
             .as_ref()
             .map_err(Clone::clone)
-            .and_then(|decoder| decoder.try_to_decode_nested_trace(nested_trace))
+            .and_then(|decoder| decoder.write().try_to_decode_nested_trace_mut(nested_trace))
     }
 }

package/src/solidity_tests/test_results.rs

@@ -1,13 +1,12 @@
 use std::{
     borrow::Cow,
-    convert::Infallible,
     fmt::{Debug, Formatter},
     sync::Arc,
 };
 
 use edr_solidity_tests::{
     constants::CHEATCODE_ADDRESS,
-    executors::stack_trace::StackTraceResult,
+    executors::stack_trace::SolidityTestStackTraceResult,
     traces::{self, CallTraceArena, SparsedTraceArena},
 };
 use napi::{
@@ -17,10 +16,15 @@ use napi::{
 use napi_derive::napi;
 
 use crate::{
-    cast::TryCast,
     gas_report::GasReport,
     solidity_tests::{artifact::ArtifactId, config::IncludeTraces},
-    trace::{solidity_stack_trace::SolidityStackTraceEntry, u256_to_bigint},
+    trace::{
+        solidity_stack_trace::{
+            solidity_stack_trace_error_to_napi, solidity_stack_trace_heuristic_failed_to_napi,
+            solidity_stack_trace_success_to_napi, SolidityStackTraceEntry,
+        },
+        u256_to_bigint,
+    },
 };
 
 /// A grouping of value snapshot entries for a test.
@@ -64,7 +68,7 @@ pub struct SuiteResult {
 
 impl SuiteResult {
     pub fn new(
-        id: edr_solidity::artifacts::ArtifactId,
+        id: edr_artifact::ArtifactId,
         suite_result: edr_solidity_tests::result::SuiteResult<String>,
         include_traces: IncludeTraces,
     ) -> Self {
@@ -113,7 +117,7 @@ pub struct TestResult {
     #[napi(readonly)]
     pub value_snapshot_groups: Option<Vec<ValueSnapshotGroup>>,
 
-    stack_trace_result: Option<Arc<StackTraceResult<String>>>,
+    stack_trace_result: Option<Arc<SolidityTestStackTraceResult<String>>>,
     call_trace_arenas: Vec<(traces::TraceKind, SparsedTraceArena)>,
 }
 
@@ -180,23 +184,16 @@ impl TestResult {
     ) -> Option<Either4<StackTrace, UnexpectedError, HeuristicFailed, UnsafeToReplay>> {
         self.stack_trace_result.as_ref().map(|stack_trace_result| {
             match stack_trace_result.as_ref() {
-                StackTraceResult::Success(stack_trace) => Either4::A(StackTrace {
-                    kind: "StackTrace",
-                    entries: stack_trace
-                        .iter()
-                        .cloned()
-                        .map(TryCast::try_cast)
-                        .collect::<Result<Vec<_>, Infallible>>()
-                        .expect("infallible"),
-                }),
-                StackTraceResult::Error(error) => Either4::B(UnexpectedError {
-                    kind: "UnexpectedError",
-                    error_message: error.to_string(),
-                }),
-                StackTraceResult::HeuristicFailed => Either4::C(HeuristicFailed {
-                    kind: "HeuristicFailed",
-                }),
-                StackTraceResult::UnsafeToReplay {
+                SolidityTestStackTraceResult::Success(stack_trace) => {
+                    Either4::A(solidity_stack_trace_success_to_napi(stack_trace))
+                }
+                SolidityTestStackTraceResult::Error(error) => {
+                    Either4::B(solidity_stack_trace_error_to_napi(error))
+                }
+                SolidityTestStackTraceResult::HeuristicFailed => {
+                    Either4::C(solidity_stack_trace_heuristic_failed_to_napi())
+                }
+                SolidityTestStackTraceResult::UnsafeToReplay {
                     global_fork_latest,
                     impure_cheatcodes,
                 } => Either4::D(UnsafeToReplay {
@@ -636,7 +633,7 @@ impl CallTrace {
     }
 
     /// Creates a tree of `CallTrace` rooted at some node in a trace arena.
-    fn from_arena_node(arena: &CallTraceArena, arena_index: usize) -> Self {
+    pub(crate) fn from_arena_node(arena: &CallTraceArena, arena_index: usize) -> Self {
         struct StackItem {
             visited: bool,
             parent_stack_index: Option<usize>,

package/src/trace/solidity_stack_trace.rs

@@ -1,8 +1,6 @@
 //! Naive rewrite of `hardhat-network/stack-traces/solidity-stack-traces.ts`
 //! from Hardhat.
 
-use std::convert::Infallible;
-
 use edr_primitives::{hex, U256};
 use napi::bindgen_prelude::{BigInt, Either25, FromNapiValue, ToNapiValue, Uint8Array, Undefined};
 use napi_derive::napi;
@@ -10,7 +8,11 @@ use serde::{Serialize, Serializer};
 
 use super::model::ContractFunctionType;
 use crate::{
-    cast::TryCast, solidity_tests::cheatcode_errors::CheatcodeErrorDetails, trace::u256_to_bigint,
+    solidity_tests::{
+        cheatcode_errors::CheatcodeErrorDetails,
+        test_results::{HeuristicFailed, StackTrace, UnexpectedError},
+    },
+    trace::u256_to_bigint,
 };
 
 #[napi]
@@ -637,219 +639,247 @@ pub type SolidityStackTraceEntry = Either25<
     CheatcodeErrorStackTraceEntry,
 >;
 
-impl TryCast<SolidityStackTraceEntry> for edr_solidity::solidity_stack_trace::StackTraceEntry {
-    type Error = Infallible;
-
-    fn try_cast(self) -> Result<SolidityStackTraceEntry, Self::Error> {
-        use edr_solidity::solidity_stack_trace::StackTraceEntry;
-        let result = match self {
-            StackTraceEntry::CallstackEntry {
-                source_reference,
-                function_type,
-            } => CallstackEntryStackTraceEntry {
+/// Converts an `edr_solidity::solidity_stack_trace::StackTraceEntry` to an
+/// N-API compatible `SolidityStackTraceEntry`.
+fn solidity_stack_trace_entry_to_napi(
+    entry: edr_solidity::solidity_stack_trace::StackTraceEntry,
+) -> SolidityStackTraceEntry {
+    use edr_solidity::solidity_stack_trace::StackTraceEntry;
+    match entry {
+        StackTraceEntry::CallstackEntry {
+            source_reference,
+            function_type,
+        } => CallstackEntryStackTraceEntry {
+            type_: StackTraceEntryTypeConst,
+            source_reference: source_reference.into(),
+            function_type: function_type.into(),
+        }
+        .into(),
+        StackTraceEntry::UnrecognizedCreateCallstackEntry => {
+            UnrecognizedCreateCallstackEntryStackTraceEntry {
                 type_: StackTraceEntryTypeConst,
-                source_reference: source_reference.into(),
-                function_type: function_type.into(),
-            }
-            .into(),
-            StackTraceEntry::UnrecognizedCreateCallstackEntry => {
-                UnrecognizedCreateCallstackEntryStackTraceEntry {
-                    type_: StackTraceEntryTypeConst,
-                    source_reference: None,
-                }
-                .into()
-            }
-            StackTraceEntry::UnrecognizedContractCallstackEntry { address } => {
-                UnrecognizedContractCallstackEntryStackTraceEntry {
-                    type_: StackTraceEntryTypeConst,
-                    address: Uint8Array::with_data_copied(address),
-                    source_reference: None,
-                }
-                .into()
+                source_reference: None,
             }
-            StackTraceEntry::PrecompileError { precompile } => PrecompileErrorStackTraceEntry {
+            .into()
+        }
+        StackTraceEntry::UnrecognizedContractCallstackEntry { address } => {
+            UnrecognizedContractCallstackEntryStackTraceEntry {
                 type_: StackTraceEntryTypeConst,
-                precompile,
+                address: Uint8Array::with_data_copied(address),
                 source_reference: None,
             }
-            .into(),
-            StackTraceEntry::RevertError {
-                return_data,
-                source_reference,
-                is_invalid_opcode_error,
-            } => RevertErrorStackTraceEntry {
+            .into()
+        }
+        StackTraceEntry::PrecompileError { precompile } => PrecompileErrorStackTraceEntry {
+            type_: StackTraceEntryTypeConst,
+            precompile,
+            source_reference: None,
+        }
+        .into(),
+        StackTraceEntry::RevertError {
+            return_data,
+            source_reference,
+            is_invalid_opcode_error,
+        } => RevertErrorStackTraceEntry {
+            type_: StackTraceEntryTypeConst,
+            return_data: return_data.into(),
+            source_reference: source_reference.into(),
+            is_invalid_opcode_error,
+        }
+        .into(),
+        StackTraceEntry::PanicError {
+            error_code,
+            source_reference,
+        } => PanicErrorStackTraceEntry {
+            type_: StackTraceEntryTypeConst,
+            error_code: u256_to_bigint(&error_code),
+            source_reference: source_reference.map(std::convert::Into::into),
+        }
+        .into(),
+        StackTraceEntry::CheatCodeError {
+            message,
+            source_reference,
+            details,
+        } => CheatcodeErrorStackTraceEntry {
+            type_: StackTraceEntryTypeConst,
+            message,
+            source_reference: source_reference.into(),
+            details: details.map(std::convert::Into::into),
+        }
+        .into(),
+        StackTraceEntry::CustomError {
+            message,
+            source_reference,
+        } => CustomErrorStackTraceEntry {
+            type_: StackTraceEntryTypeConst,
+            message,
+            source_reference: source_reference.into(),
+        }
+        .into(),
+        StackTraceEntry::FunctionNotPayableError {
+            value,
+            source_reference,
+        } => FunctionNotPayableErrorStackTraceEntry {
+            type_: StackTraceEntryTypeConst,
+            value: u256_to_bigint(&value),
+            source_reference: source_reference.into(),
+        }
+        .into(),
+        StackTraceEntry::InvalidParamsError { source_reference } => {
+            InvalidParamsErrorStackTraceEntry {
                 type_: StackTraceEntryTypeConst,
-                return_data: return_data.into(),
                 source_reference: source_reference.into(),
-                is_invalid_opcode_error,
             }
-            .into(),
-            StackTraceEntry::PanicError {
-                error_code,
-                source_reference,
-            } => PanicErrorStackTraceEntry {
-                type_: StackTraceEntryTypeConst,
-                error_code: u256_to_bigint(&error_code),
-                source_reference: source_reference.map(std::convert::Into::into),
-            }
-            .into(),
-            StackTraceEntry::CheatCodeError {
-                message,
-                source_reference,
-                details,
-            } => CheatcodeErrorStackTraceEntry {
+            .into()
+        }
+        StackTraceEntry::FallbackNotPayableError {
+            value,
+            source_reference,
+        } => FallbackNotPayableErrorStackTraceEntry {
+            type_: StackTraceEntryTypeConst,
+            value: u256_to_bigint(&value),
+            source_reference: source_reference.into(),
+        }
+        .into(),
+        StackTraceEntry::FallbackNotPayableAndNoReceiveError {
+            value,
+            source_reference,
+        } => FallbackNotPayableAndNoReceiveErrorStackTraceEntry {
+            type_: StackTraceEntryTypeConst,
+            value: u256_to_bigint(&value),
+            source_reference: source_reference.into(),
+        }
+        .into(),
+        StackTraceEntry::UnrecognizedFunctionWithoutFallbackError { source_reference } => {
+            UnrecognizedFunctionWithoutFallbackErrorStackTraceEntry {
                 type_: StackTraceEntryTypeConst,
-                message,
                 source_reference: source_reference.into(),
-                details: details.map(std::convert::Into::into),
             }
-            .into(),
-            StackTraceEntry::CustomError {
-                message,
-                source_reference,
-            } => CustomErrorStackTraceEntry {
+            .into()
+        }
+        StackTraceEntry::MissingFallbackOrReceiveError { source_reference } => {
+            MissingFallbackOrReceiveErrorStackTraceEntry {
                 type_: StackTraceEntryTypeConst,
-                message,
                 source_reference: source_reference.into(),
             }
-            .into(),
-            StackTraceEntry::FunctionNotPayableError {
-                value,
-                source_reference,
-            } => FunctionNotPayableErrorStackTraceEntry {
+            .into()
+        }
+        StackTraceEntry::ReturndataSizeError { source_reference } => {
+            ReturndataSizeErrorStackTraceEntry {
                 type_: StackTraceEntryTypeConst,
-                value: u256_to_bigint(&value),
                 source_reference: source_reference.into(),
             }
-            .into(),
-            StackTraceEntry::InvalidParamsError { source_reference } => {
-                InvalidParamsErrorStackTraceEntry {
-                    type_: StackTraceEntryTypeConst,
-                    source_reference: source_reference.into(),
-                }
-                .into()
-            }
-            StackTraceEntry::FallbackNotPayableError {
-                value,
-                source_reference,
-            } => FallbackNotPayableErrorStackTraceEntry {
+            .into()
+        }
+        StackTraceEntry::NoncontractAccountCalledError { source_reference } => {
+            NonContractAccountCalledErrorStackTraceEntry {
                 type_: StackTraceEntryTypeConst,
-                value: u256_to_bigint(&value),
                 source_reference: source_reference.into(),
             }
-            .into(),
-            StackTraceEntry::FallbackNotPayableAndNoReceiveError {
-                value,
-                source_reference,
-            } => FallbackNotPayableAndNoReceiveErrorStackTraceEntry {
+            .into()
+        }
+        StackTraceEntry::CallFailedError { source_reference } => CallFailedErrorStackTraceEntry {
+            type_: StackTraceEntryTypeConst,
+            source_reference: source_reference.into(),
+        }
+        .into(),
+        StackTraceEntry::DirectLibraryCallError { source_reference } => {
+            DirectLibraryCallErrorStackTraceEntry {
                 type_: StackTraceEntryTypeConst,
-                value: u256_to_bigint(&value),
                 source_reference: source_reference.into(),
             }
-            .into(),
-            StackTraceEntry::UnrecognizedFunctionWithoutFallbackError { source_reference } => {
-                UnrecognizedFunctionWithoutFallbackErrorStackTraceEntry {
-                    type_: StackTraceEntryTypeConst,
-                    source_reference: source_reference.into(),
-                }
-                .into()
-            }
-            StackTraceEntry::MissingFallbackOrReceiveError { source_reference } => {
-                MissingFallbackOrReceiveErrorStackTraceEntry {
-                    type_: StackTraceEntryTypeConst,
-                    source_reference: source_reference.into(),
-                }
-                .into()
-            }
-            StackTraceEntry::ReturndataSizeError { source_reference } => {
-                ReturndataSizeErrorStackTraceEntry {
-                    type_: StackTraceEntryTypeConst,
-                    source_reference: source_reference.into(),
-                }
-                .into()
-            }
-            StackTraceEntry::NoncontractAccountCalledError { source_reference } => {
-                NonContractAccountCalledErrorStackTraceEntry {
-                    type_: StackTraceEntryTypeConst,
-                    source_reference: source_reference.into(),
-                }
-                .into()
-            }
-            StackTraceEntry::CallFailedError { source_reference } => {
-                CallFailedErrorStackTraceEntry {
-                    type_: StackTraceEntryTypeConst,
-                    source_reference: source_reference.into(),
-                }
-                .into()
-            }
-            StackTraceEntry::DirectLibraryCallError { source_reference } => {
-                DirectLibraryCallErrorStackTraceEntry {
-                    type_: StackTraceEntryTypeConst,
-                    source_reference: source_reference.into(),
-                }
-                .into()
-            }
-            StackTraceEntry::UnrecognizedCreateError {
-                return_data,
-                is_invalid_opcode_error,
-            } => UnrecognizedCreateErrorStackTraceEntry {
+            .into()
+        }
+        StackTraceEntry::UnrecognizedCreateError {
+            return_data,
+            is_invalid_opcode_error,
+        } => UnrecognizedCreateErrorStackTraceEntry {
+            type_: StackTraceEntryTypeConst,
+            return_data: return_data.into(),
+            is_invalid_opcode_error,
+            source_reference: None,
+        }
+        .into(),
+        StackTraceEntry::UnrecognizedContractError {
+            address,
+            return_data,
+            is_invalid_opcode_error,
+        } => UnrecognizedContractErrorStackTraceEntry {
+            type_: StackTraceEntryTypeConst,
+            address: Uint8Array::with_data_copied(address),
+            return_data: return_data.into(),
+            is_invalid_opcode_error,
+            source_reference: None,
+        }
+        .into(),
+        StackTraceEntry::OtherExecutionError { source_reference } => {
+            OtherExecutionErrorStackTraceEntry {
                 type_: StackTraceEntryTypeConst,
-                return_data: return_data.into(),
-                is_invalid_opcode_error,
-                source_reference: None,
+                source_reference: source_reference.map(std::convert::Into::into),
             }
-            .into(),
-            StackTraceEntry::UnrecognizedContractError {
-                address,
-                return_data,
-                is_invalid_opcode_error,
-            } => UnrecognizedContractErrorStackTraceEntry {
+            .into()
+        }
+        StackTraceEntry::UnmappedSolc0_6_3RevertError { source_reference } => {
+            UnmappedSolc063RevertErrorStackTraceEntry {
                 type_: StackTraceEntryTypeConst,
-                address: Uint8Array::with_data_copied(address),
-                return_data: return_data.into(),
-                is_invalid_opcode_error,
-                source_reference: None,
-            }
-            .into(),
-            StackTraceEntry::OtherExecutionError { source_reference } => {
-                OtherExecutionErrorStackTraceEntry {
-                    type_: StackTraceEntryTypeConst,
-                    source_reference: source_reference.map(std::convert::Into::into),
-                }
-                .into()
-            }
-            StackTraceEntry::UnmappedSolc0_6_3RevertError { source_reference } => {
-                UnmappedSolc063RevertErrorStackTraceEntry {
-                    type_: StackTraceEntryTypeConst,
-                    source_reference: source_reference.map(std::convert::Into::into),
-                }
-                .into()
-            }
-            StackTraceEntry::ContractTooLargeError { source_reference } => {
-                ContractTooLargeErrorStackTraceEntry {
-                    type_: StackTraceEntryTypeConst,
-                    source_reference: source_reference.map(std::convert::Into::into),
-                }
-                .into()
+                source_reference: source_reference.map(std::convert::Into::into),
             }
-            StackTraceEntry::InternalFunctionCallstackEntry {
-                pc,
-                source_reference,
-            } => InternalFunctionCallStackEntry {
+            .into()
+        }
+        StackTraceEntry::ContractTooLargeError { source_reference } => {
+            ContractTooLargeErrorStackTraceEntry {
                 type_: StackTraceEntryTypeConst,
-                pc,
-                source_reference: source_reference.into(),
+                source_reference: source_reference.map(std::convert::Into::into),
             }
-            .into(),
-            StackTraceEntry::ContractCallRunOutOfGasError { source_reference } => {
-                ContractCallRunOutOfGasError {
-                    type_: StackTraceEntryTypeConst,
-                    source_reference: source_reference.map(std::convert::Into::into),
-                }
-                .into()
+            .into()
+        }
+        StackTraceEntry::InternalFunctionCallstackEntry {
+            pc,
+            source_reference,
+        } => InternalFunctionCallStackEntry {
+            type_: StackTraceEntryTypeConst,
+            pc,
+            source_reference: source_reference.into(),
+        }
+        .into(),
+        StackTraceEntry::ContractCallRunOutOfGasError { source_reference } => {
+            ContractCallRunOutOfGasError {
+                type_: StackTraceEntryTypeConst,
+                source_reference: source_reference.map(std::convert::Into::into),
             }
-        };
-        Ok(result)
+            .into()
+        }
+    }
+}
+
+/// Converts the contents of a `SolidityTestStackTraceResult::Success` to an
+/// N-API compatible `StackTrace`.
+pub fn solidity_stack_trace_success_to_napi(
+    stack_trace: &[edr_solidity::solidity_stack_trace::StackTraceEntry],
+) -> StackTrace {
+    StackTrace {
+        kind: "StackTrace",
+        entries: stack_trace
+            .iter()
+            .cloned()
+            .map(solidity_stack_trace_entry_to_napi)
+            .collect(),
+    }
+}
+
+/// Converts an error from `SolidityTestStackTraceResult::UnexpectedError` to
+/// an N-API compatible `UnexpectedError`.
+pub fn solidity_stack_trace_error_to_napi<ErrorT: ToString>(error: ErrorT) -> UnexpectedError {
+    UnexpectedError {
+        kind: "UnexpectedError",
+        error_message: error.to_string(),
+    }
+}
+
+/// Constructs a `HeuristicFailed` N-API object.
+pub fn solidity_stack_trace_heuristic_failed_to_napi() -> HeuristicFailed {
+    HeuristicFailed {
+        kind: "HeuristicFailed",
     }
 }
 

package/src/trace.rs

@@ -190,10 +190,3 @@ impl RawTrace {
             .collect()
     }
 }
-
-#[napi]
-/// Returns the latest version of solc that EDR officially
-/// supports and is tested against.
-pub fn get_latest_supported_solc_version() -> String {
-    "0.8.28".to_string()
-}