@nomicfoundation/edr 0.12.0-next.23 → 0.12.0-next.25

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 {
@@ -587,6 +594,20 @@ export interface LinkReference {
   start: number
   length: number
 }
+/**Error codes that can be returned by cheatcodes in Solidity tests. */
+export enum CheatcodeErrorCode {
+  /**The specified cheatcode is not supported. */
+  UnsupportedCheatcode = 'UnsupportedCheatcode',
+  /**The specified cheatcode is missing. */
+  MissingCheatcode = 'MissingCheatcode'
+}
+/**Error returned by a cheatcode in Solidity tests. */
+export interface CheatcodeErrorDetails {
+  /**The error code representing the type of cheatcode error. */
+  code: CheatcodeErrorCode
+  /**The name of the cheatcode that caused the error. */
+  cheatcode: string
+}
 /**
  * Solidity test runner configuration arguments exposed through the ffi.
  * Docs based on <https://book.getfoundry.sh/reference/config/testing>.
@@ -646,6 +667,8 @@ export interface SolidityTestRunnerConfigArgs {
    * Defaults to `31337`.
    */
   chainId?: bigint
+  /** The hardfork to use for EVM execution. */
+  hardfork: string
   /**
    * The gas limit for each test case.
    * Defaults to `9_223_372_036_854_775_807` (`i64::MAX`).
@@ -686,6 +709,11 @@ export interface SolidityTestRunnerConfigArgs {
    * Defaults to false.
    */
   disableBlockGasLimit?: boolean
+  /**
+   * Whether to enable the EIP-7825 (Osaka) transaction gas limit cap.
+   * Defaults to false.
+   */
+  enableTxGasLimitCap?: boolean
   /**
    * The memory limit of the EVM in bytes.
    * Defaults to `33_554_432` (2^25 = 32MiB).
@@ -953,15 +981,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. */
@@ -1457,6 +1491,7 @@ export interface CheatcodeErrorStackTraceEntry {
   type: StackTraceEntryType.CHEATCODE_ERROR
   message: string
   sourceReference: SourceReference
+  details?: CheatcodeErrorDetails
 }
 export interface TracingMessage {
   /** Sender address */
@@ -1501,11 +1536,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
@@ -1564,9 +1594,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, 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
@@ -369,6 +369,7 @@ module.exports.Response = Response
 module.exports.Provider = Provider
 module.exports.SuccessReason = SuccessReason
 module.exports.ExceptionalHalt = ExceptionalHalt
+module.exports.CheatcodeErrorCode = CheatcodeErrorCode
 module.exports.CachedChains = CachedChains
 module.exports.CachedEndpoints = CachedEndpoints
 module.exports.FsAccessPermission = FsAccessPermission
@@ -399,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.23",
+  "version": "0.12.0-next.25",
   "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.23",
-    "@nomicfoundation/edr-darwin-x64": "0.12.0-next.23",
-    "@nomicfoundation/edr-linux-arm64-gnu": "0.12.0-next.23",
-    "@nomicfoundation/edr-linux-arm64-musl": "0.12.0-next.23",
-    "@nomicfoundation/edr-linux-x64-gnu": "0.12.0-next.23",
-    "@nomicfoundation/edr-linux-x64-musl": "0.12.0-next.23",
-    "@nomicfoundation/edr-win32-x64-msvc": "0.12.0-next.23"
+    "@nomicfoundation/edr-darwin-arm64": "0.12.0-next.25",
+    "@nomicfoundation/edr-darwin-x64": "0.12.0-next.25",
+    "@nomicfoundation/edr-linux-arm64-gnu": "0.12.0-next.25",
+    "@nomicfoundation/edr-linux-arm64-musl": "0.12.0-next.25",
+    "@nomicfoundation/edr-linux-x64-gnu": "0.12.0-next.25",
+    "@nomicfoundation/edr-linux-x64-musl": "0.12.0-next.25",
+    "@nomicfoundation/edr-win32-x64-msvc": "0.12.0-next.25"
   },
   "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/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/cheatcode_errors.rs

@@ -0,0 +1,37 @@
+use napi_derive::napi;
+use serde::Serialize;
+
+#[napi(string_enum)]
+#[derive(Serialize)]
+#[doc = "Error codes that can be returned by cheatcodes in Solidity tests."]
+pub enum CheatcodeErrorCode {
+    #[doc = "The specified cheatcode is not supported."]
+    UnsupportedCheatcode,
+    #[doc = "The specified cheatcode is missing."]
+    MissingCheatcode,
+}
+
+#[napi(object)]
+#[derive(Clone, Serialize)]
+#[doc = "Error returned by a cheatcode in Solidity tests."]
+pub struct CheatcodeErrorDetails {
+    #[doc = "The error code representing the type of cheatcode error."]
+    pub code: CheatcodeErrorCode,
+    #[doc = "The name of the cheatcode that caused the error."]
+    pub cheatcode: String,
+}
+
+impl From<edr_solidity::return_data::CheatcodeErrorCode> for CheatcodeErrorCode {
+    fn from(value: edr_solidity::return_data::CheatcodeErrorCode) -> Self {
+        match value {
+            edr_solidity::return_data::CheatcodeErrorCode::UnsupportedCheatcode => {
+                CheatcodeErrorCode::UnsupportedCheatcode
+            }
+            // __Invalid is generated by alloy_sol_types for invalid encoded values.
+            edr_solidity::return_data::CheatcodeErrorCode::MissingCheatcode
+            | edr_solidity::return_data::CheatcodeErrorCode::__Invalid => {
+                CheatcodeErrorCode::MissingCheatcode
+            }
+        }
+    }
+}