@nomicfoundation/edr 0.12.0-next.6 → 0.12.0-next.7

package/index.d.ts

@@ -169,11 +169,11 @@ export interface BaseFeeParamActivation {
   elasticityMultiplier: bigint
 }
 export interface BaseFeeActivationByBlockNumber {
-  /** The block number at which the base_fee_params is activated */
+  /** The block number at which the `base_fee_params` is activated */
   blockNumber: bigint
 }
 export interface BaseFeeActivationByHardfork {
-  /** The hardfork at which the base_fee_params is activated */
+  /** The hardfork at which the `base_fee_params` is activated */
   hardfork: string
 }
 /** Specification of a chain with possible overrides. */
@@ -273,7 +273,7 @@ export interface ProviderConfig {
    * EIP-1559 base fee parameters activations to be used to calculate the
    * block base fee.
    *
-   * Provide an ordered list of base_fee_params to be
+   * Provide an ordered list of `base_fee_params` to be
    * used starting from the specified activation point (hardfork or block
    * number).
    * If not provided, the default values from the chain spec
@@ -644,7 +644,7 @@ export interface SolidityTestRunnerConfigArgs {
   disableBlockGasLimit?: boolean
   /**
    * The memory limit of the EVM in bytes.
-   * Defaults to 33_554_432 (2^25 = 32MiB).
+   * Defaults to `33_554_432` (2^25 = 32MiB).
    */
   memoryLimit?: bigint
   /**
@@ -689,6 +689,8 @@ export interface SolidityTestRunnerConfigArgs {
    * config value is set, then the fuzz config value will be used.
    */
   invariant?: InvariantConfigArgs
+  /** Whether to collect stack traces. */
+  collectStackTraces?: CollectStackTraces
   /**
    * Controls which test results should include execution traces. Defaults to
    * None.
@@ -865,6 +867,19 @@ export interface AddressLabel {
   /** The label to assign to the address */
   label: string
 }
+/** A type that controls when stack traces are collected. */
+export enum CollectStackTraces {
+  /** Always collects stack traces, adding performance overhead. */
+  Always = 0,
+  /**
+   * Only collects stack traces upon failure, re-executing the test. This
+   * minimizes performance overhead.
+   *
+   * Not all tests can be re-executed since certain cheatcodes contain
+   * non-deterministic side-effects.
+   */
+  OnFailure = 1
+}
 /**
  * Configuration for [`SolidityTestRunnerConfigArgs::include_traces`] that
  * controls execution trace decoding and inclusion in test results.
@@ -948,21 +963,21 @@ export enum TestStatus {
   /**Test skipped */
   Skipped = 'Skipped'
 }
-/** See [edr_solidity_tests::result::TestKind::Standard] */
+/** See [`edr_solidity_tests::result::TestKind::Standard`] */
 export interface StandardTestKind {
   /** The gas consumed by the test. */
   readonly consumedGas: bigint
 }
-/** See [edr_solidity_tests::result::TestKind::Fuzz] */
+/** See [`edr_solidity_tests::result::TestKind::Fuzz`] */
 export interface FuzzTestKind {
-  /** See [edr_solidity_tests::result::TestKind::Fuzz] */
+  /** See [`edr_solidity_tests::result::TestKind::Fuzz`] */
   readonly runs: bigint
-  /** See [edr_solidity_tests::result::TestKind::Fuzz] */
+  /** See [`edr_solidity_tests::result::TestKind::Fuzz`] */
   readonly meanGas: bigint
-  /** See [edr_solidity_tests::result::TestKind::Fuzz] */
+  /** See [`edr_solidity_tests::result::TestKind::Fuzz`] */
   readonly medianGas: bigint
 }
-/** See [edr_solidity_tests::fuzz::FuzzCase] */
+/** See [`edr_solidity_tests::fuzz::FuzzCase`] */
 export interface FuzzCase {
   /** The calldata used for this fuzz test */
   readonly calldata: Uint8Array
@@ -971,13 +986,13 @@ export interface FuzzCase {
   /** The initial gas stipend for the transaction */
   readonly stipend: bigint
 }
-/** See [edr_solidity_tests::result::TestKind::Invariant] */
+/** See [`edr_solidity_tests::result::TestKind::Invariant`] */
 export interface InvariantTestKind {
-  /** See [edr_solidity_tests::result::TestKind::Invariant] */
+  /** See [`edr_solidity_tests::result::TestKind::Invariant`] */
   readonly runs: bigint
-  /** See [edr_solidity_tests::result::TestKind::Invariant] */
+  /** See [`edr_solidity_tests::result::TestKind::Invariant`] */
   readonly calls: bigint
-  /** See [edr_solidity_tests::result::TestKind::Invariant] */
+  /** See [`edr_solidity_tests::result::TestKind::Invariant`] */
   readonly reverts: bigint
 }
 /**
@@ -990,19 +1005,19 @@ export interface CounterExampleSequence {
   /** The shrunk counterexample sequence. */
   sequence: Array<BaseCounterExample>
 }
-/** See [edr_solidity_tests::fuzz::BaseCounterExample] */
+/** See [`edr_solidity_tests::fuzz::BaseCounterExample`] */
 export interface BaseCounterExample {
-  /** See [edr_solidity_tests::fuzz::BaseCounterExample::sender] */
+  /** See [`edr_solidity_tests::fuzz::BaseCounterExample::sender`] */
   readonly sender?: Uint8Array
-  /** See [edr_solidity_tests::fuzz::BaseCounterExample::addr] */
+  /** See [`edr_solidity_tests::fuzz::BaseCounterExample::addr`] */
   readonly address?: Uint8Array
-  /** See [edr_solidity_tests::fuzz::BaseCounterExample::calldata] */
+  /** See [`edr_solidity_tests::fuzz::BaseCounterExample::calldata`] */
   readonly calldata: Uint8Array
-  /** See [edr_solidity_tests::fuzz::BaseCounterExample::contract_name] */
+  /** See [`edr_solidity_tests::fuzz::BaseCounterExample::contract_name`] */
   readonly contractName?: string
-  /** See [edr_solidity_tests::fuzz::BaseCounterExample::signature] */
+  /** See [`edr_solidity_tests::fuzz::BaseCounterExample::signature`] */
   readonly signature?: string
-  /** See [edr_solidity_tests::fuzz::BaseCounterExample::args] */
+  /** See [`edr_solidity_tests::fuzz::BaseCounterExample::args`] */
   readonly args?: string
 }
 /**
@@ -1351,7 +1366,7 @@ export declare class EdrContext {
   /**Creates a new [`EdrContext`] instance. Should only be called once! */
   constructor()
   /**Constructs a new provider with the provided configuration. */
-  createProvider(chainType: string, providerConfig: ProviderConfig, loggerConfig: LoggerConfig, subscriptionConfig: SubscriptionConfig, tracingConfig: TracingConfigWithBuffers): Promise<Provider>
+  createProvider(chainType: string, providerConfig: ProviderConfig, loggerConfig: LoggerConfig, subscriptionConfig: SubscriptionConfig, contractDecoder: ContractDecoder): Promise<Provider>
   /**Registers a new provider factory for the provided chain type. */
   registerProviderFactory(chainType: string, factory: ProviderFactory): Promise<void>
   registerSolidityTestRunnerFactory(chainType: string, factory: SolidityTestRunnerFactory): Promise<void>
@@ -1365,6 +1380,12 @@ export declare class EdrContext {
    */
   runSolidityTests(chainType: string, artifacts: Array<Artifact>, testSuites: Array<ArtifactId>, configArgs: SolidityTestRunnerConfigArgs, tracingConfig: TracingConfigWithBuffers, onTestSuiteCompletedCallback: (result: SuiteResult) => void): Promise<void>
 }
+export declare class ContractDecoder {
+  /**Creates an empty instance. */
+  constructor()
+  /**Creates a new instance with the provided configuration. */
+  static withContracts(config: TracingConfigWithBuffers): ContractDecoder
+}
 export declare class Precompile {
   /** Returns the address of the precompile. */
   get address(): Uint8Array
@@ -1385,7 +1406,9 @@ export declare class Provider {
    *
    *For internal use only. Support for this method may be removed in the future.
    */
-  addCompilationResult(solcVersion: string, compilerInput: any, compilerOutput: any): Promise<boolean>
+  addCompilationResult(solcVersion: string, compilerInput: any, compilerOutput: any): Promise<void>
+  /**Retrieves the instance's contract decoder. */
+  contractDecoder(): ContractDecoder
   /**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>
@@ -1398,35 +1421,35 @@ export declare class Provider {
   setVerboseTracing(verboseTracing: boolean): Promise<void>
 }
 export declare class SolidityTestRunnerFactory { }
-/** See [edr_solidity_tests::result::SuiteResult] */
+/** See [`edr_solidity_tests::result::SuiteResult`] */
 export declare class SuiteResult {
   /**
    * The artifact id can be used to match input to result in the progress
    * callback
    */
   readonly id: ArtifactId
-  /** See [edr_solidity_tests::result::SuiteResult::duration] */
+  /** See [`edr_solidity_tests::result::SuiteResult::duration`] */
   readonly durationNs: bigint
-  /** See [edr_solidity_tests::result::SuiteResult::test_results] */
+  /** See [`edr_solidity_tests::result::SuiteResult::test_results`] */
   readonly testResults: Array<TestResult>
-  /** See [edr_solidity_tests::result::SuiteResult::warnings] */
+  /** See [`edr_solidity_tests::result::SuiteResult::warnings`] */
   readonly warnings: Array<string>
 }
-/** See [edr_solidity_tests::result::TestResult] */
+/** See [`edr_solidity_tests::result::TestResult`] */
 export declare class TestResult {
   /** The name of the test. */
   readonly name: string
-  /** See [edr_solidity_tests::result::TestResult::status] */
+  /** See [`edr_solidity_tests::result::TestResult::status`] */
   readonly status: TestStatus
-  /** See [edr_solidity_tests::result::TestResult::reason] */
+  /** See [`edr_solidity_tests::result::TestResult::reason`] */
   readonly reason?: string
-  /** See [edr_solidity_tests::result::TestResult::counterexample] */
+  /** See [`edr_solidity_tests::result::TestResult::counterexample`] */
   readonly counterexample?: BaseCounterExample | CounterExampleSequence
-  /** See [edr_solidity_tests::result::TestResult::decoded_logs] */
+  /** See [`edr_solidity_tests::result::TestResult::decoded_logs`] */
   readonly decodedLogs: Array<string>
-  /** See [edr_solidity_tests::result::TestResult::kind] */
+  /** See [`edr_solidity_tests::result::TestResult::kind`] */
   readonly kind: StandardTestKind | FuzzTestKind | InvariantTestKind
-  /** See [edr_solidity_tests::result::TestResult::duration] */
+  /** See [`edr_solidity_tests::result::TestResult::duration`] */
   readonly durationNs: bigint
   /**
    * Groups of value snapshot entries (incl. gas).

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, OpHardfork, opHardforkFromString, opHardforkToString, opLatestHardfork, OP_CHAIN_TYPE, opGenesisState, opProviderFactory, BEDROCK, REGOLITH, CANYON, ECOTONE, FJORD, GRANITE, HOLOCENE, ISTHMUS, MineOrdering, EdrContext, addStatementCoverageInstrumentation, Precompile, precompileP256Verify, ProviderFactory, Response, Provider, SuccessReason, ExceptionalHalt, CachedChains, CachedEndpoints, FsAccessPermission, 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, OpHardfork, opHardforkFromString, opHardforkToString, opLatestHardfork, OP_CHAIN_TYPE, opGenesisState, opProviderFactory, BEDROCK, REGOLITH, CANYON, ECOTONE, FJORD, GRANITE, HOLOCENE, ISTHMUS, MineOrdering, EdrContext, ContractDecoder, addStatementCoverageInstrumentation, 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
 
 module.exports.GENERIC_CHAIN_TYPE = GENERIC_CHAIN_TYPE
 module.exports.genericChainProviderFactory = genericChainProviderFactory
@@ -357,6 +357,7 @@ module.exports.HOLOCENE = HOLOCENE
 module.exports.ISTHMUS = ISTHMUS
 module.exports.MineOrdering = MineOrdering
 module.exports.EdrContext = EdrContext
+module.exports.ContractDecoder = ContractDecoder
 module.exports.addStatementCoverageInstrumentation = addStatementCoverageInstrumentation
 module.exports.Precompile = Precompile
 module.exports.precompileP256Verify = precompileP256Verify
@@ -368,6 +369,7 @@ module.exports.ExceptionalHalt = ExceptionalHalt
 module.exports.CachedChains = CachedChains
 module.exports.CachedEndpoints = CachedEndpoints
 module.exports.FsAccessPermission = FsAccessPermission
+module.exports.CollectStackTraces = CollectStackTraces
 module.exports.IncludeTraces = IncludeTraces
 module.exports.SolidityTestRunnerFactory = SolidityTestRunnerFactory
 module.exports.l1SolidityTestRunnerFactory = l1SolidityTestRunnerFactory

package/package.json

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

package/src/config.rs

@@ -2,7 +2,6 @@ use core::fmt::{Debug, Display};
 use std::{
     num::NonZeroU64,
     path::PathBuf,
-    sync::Arc,
     time::{Duration, SystemTime},
 };
 
@@ -10,7 +9,6 @@ use edr_coverage::reporter::SyncOnCollectedCoverageCallback;
 use edr_eip1559::{BaseFeeActivation, ConstantBaseFeeParams};
 use edr_eth::{Bytes, HashMap, HashSet};
 use edr_signer::{secret_key_from_str, SecretKey};
-use edr_solidity::contract_decoder::ContractDecoder;
 use napi::{
     bindgen_prelude::{BigInt, Promise, Reference, Uint8Array},
     threadsafe_function::{
@@ -36,12 +34,12 @@ pub struct BaseFeeParamActivation {
 
 #[napi(object)]
 pub struct BaseFeeActivationByBlockNumber {
-    /// The block number at which the base_fee_params is activated
+    /// The block number at which the `base_fee_params` is activated
     pub block_number: BigInt,
 }
 #[napi(object)]
 pub struct BaseFeeActivationByHardfork {
-    /// The hardfork at which the base_fee_params is activated
+    /// The hardfork at which the `base_fee_params` is activated
     pub hardfork: String,
 }
 
@@ -187,7 +185,7 @@ pub struct ProviderConfig {
     /// EIP-1559 base fee parameters activations to be used to calculate the
     /// block base fee.
     ///
-    /// Provide an ordered list of base_fee_params to be
+    /// Provide an ordered list of `base_fee_params` to be
     /// used starting from the specified activation point (hardfork or block
     /// number).
     /// If not provided, the default values from the chain spec
@@ -606,7 +604,6 @@ impl From<BuildInfoAndOutput> for edr_napi_core::solidity::config::BuildInfoAndO
 
 /// Result of [`resolve_configs`].
 pub struct ConfigResolution {
-    pub contract_decoder: Arc<ContractDecoder>,
     pub logger_config: edr_napi_core::logger::Config,
     pub provider_config: edr_napi_core::provider::Config,
     pub subscription_callback: edr_napi_core::subscription::Callback,
@@ -619,28 +616,15 @@ pub fn resolve_configs(
     provider_config: ProviderConfig,
     logger_config: LoggerConfig,
     subscription_config: SubscriptionConfig,
-    tracing_config: TracingConfigWithBuffers,
 ) -> napi::Result<ConfigResolution> {
     let provider_config = provider_config.resolve(env, runtime)?;
     let logger_config = logger_config.resolve(env)?;
 
-    // TODO: https://github.com/NomicFoundation/edr/issues/760
-    let build_info_config = edr_solidity::artifacts::BuildInfoConfig::parse_from_buffers(
-        (&edr_napi_core::solidity::config::TracingConfigWithBuffers::from(tracing_config)).into(),
-    )
-    .map_err(|error| napi::Error::from_reason(error.to_string()))?;
-
-    let contract_decoder = ContractDecoder::new(&build_info_config).map_or_else(
-        |error| Err(napi::Error::from_reason(error.to_string())),
-        |contract_decoder| Ok(Arc::new(contract_decoder)),
-    )?;
-
     let subscription_config = edr_napi_core::subscription::Config::from(subscription_config);
     let subscription_callback =
         edr_napi_core::subscription::Callback::new(env, subscription_config.subscription_callback)?;
 
     Ok(ConfigResolution {
-        contract_decoder,
         logger_config,
         provider_config,
         subscription_callback,

package/src/context.rs

@@ -19,6 +19,7 @@ use tracing_subscriber::{prelude::*, EnvFilter, Registry};
 
 use crate::{
     config::{resolve_configs, ConfigResolution, ProviderConfig, TracingConfigWithBuffers},
+    contract_decoder::ContractDecoder,
     logger::LoggerConfig,
     provider::{Provider, ProviderFactory},
     solidity_tests::{
@@ -57,7 +58,7 @@ impl EdrContext {
         provider_config: ProviderConfig,
         logger_config: LoggerConfig,
         subscription_config: SubscriptionConfig,
-        tracing_config: TracingConfigWithBuffers,
+        contract_decoder: &ContractDecoder,
     ) -> napi::Result<JsObject> {
         let (deferred, promise) = env.create_deferred()?;
 
@@ -76,7 +77,6 @@ impl EdrContext {
         let runtime = runtime::Handle::current();
 
         let ConfigResolution {
-            contract_decoder,
             logger_config,
             provider_config,
             subscription_callback,
@@ -86,7 +86,6 @@ impl EdrContext {
             provider_config,
             logger_config,
             subscription_config,
-            tracing_config
         ));
 
         #[cfg(feature = "scenarios")]
@@ -105,6 +104,7 @@ impl EdrContext {
             try_or_reject_promise!(context.get_provider_factory(&chain_type))
         };
 
+        let contract_decoder = Arc::clone(contract_decoder.as_inner());
         runtime.clone().spawn_blocking(move || {
             let result = factory
                 .create_provider(

package/src/contract_decoder.rs

@@ -0,0 +1,57 @@
+use std::sync::Arc;
+
+use napi_derive::napi;
+
+use crate::config::TracingConfigWithBuffers;
+
+#[napi]
+pub struct ContractDecoder {
+    inner: Arc<edr_solidity::contract_decoder::ContractDecoder>,
+}
+
+#[napi]
+impl ContractDecoder {
+    #[doc = "Creates an empty instance."]
+    #[napi(constructor, catch_unwind)]
+    // Following TS convention for the constructor without arguments to be `new()`.
+    #[allow(clippy::new_without_default)]
+    pub fn new() -> Self {
+        Self {
+            inner: Arc::new(edr_solidity::contract_decoder::ContractDecoder::default()),
+        }
+    }
+
+    #[doc = "Creates a new instance with the provided configuration."]
+    #[napi(factory, catch_unwind)]
+    pub fn with_contracts(config: TracingConfigWithBuffers) -> napi::Result<Self> {
+        let build_info_config = edr_solidity::artifacts::BuildInfoConfig::parse_from_buffers(
+            (&edr_napi_core::solidity::config::TracingConfigWithBuffers::from(config)).into(),
+        )
+        .map_err(|error| napi::Error::from_reason(error.to_string()))?;
+
+        let contract_decoder =
+            edr_solidity::contract_decoder::ContractDecoder::new(&build_info_config).map_or_else(
+                |error| Err(napi::Error::from_reason(error.to_string())),
+                |contract_decoder| Ok(Arc::new(contract_decoder)),
+            )?;
+
+        Ok(Self {
+            inner: contract_decoder,
+        })
+    }
+}
+
+impl ContractDecoder {
+    /// Returns a reference to the inner contract decoder.
+    pub fn as_inner(&self) -> &Arc<edr_solidity::contract_decoder::ContractDecoder> {
+        &self.inner
+    }
+}
+
+impl From<Arc<edr_solidity::contract_decoder::ContractDecoder>> for ContractDecoder {
+    fn from(contract_decoder: Arc<edr_solidity::contract_decoder::ContractDecoder>) -> Self {
+        Self {
+            inner: contract_decoder,
+        }
+    }
+}

package/src/debug_trace.rs

@@ -3,6 +3,8 @@ use std::collections::HashMap;
 use napi::bindgen_prelude::{BigInt, Uint8Array};
 use napi_derive::napi;
 
+// False positive: imported by HH2
+#[allow(dead_code)]
 #[napi(object)]
 pub struct DebugTraceResult {
     pub pass: bool,

package/src/lib.rs

@@ -17,6 +17,8 @@ pub mod chains;
 pub mod config;
 /// Types related to an EDR N-API context.
 pub mod context;
+/// Types for decoding smart contract data.
+pub mod contract_decoder;
 mod debug_trace;
 /// Types and functions related to code coverage instrumentation.
 pub mod instrument;

package/src/mock/time.rs

@@ -11,7 +11,8 @@ use napi_derive::napi;
 
 use crate::{
     cast::TryCast as _,
-    config::{resolve_configs, ConfigResolution, ProviderConfig, TracingConfigWithBuffers},
+    config::{resolve_configs, ConfigResolution, ProviderConfig},
+    contract_decoder::ContractDecoder,
     logger::LoggerConfig,
     provider::Provider,
     subscription::SubscriptionConfig,
@@ -50,7 +51,7 @@ pub fn create_provider_with_mock_timer(
     provider_config: ProviderConfig,
     logger_config: LoggerConfig,
     subscription_config: SubscriptionConfig,
-    tracing_config: TracingConfigWithBuffers,
+    contract_decoder: &ContractDecoder,
     time: &MockTime,
 ) -> napi::Result<JsObject> {
     let (deferred, promise) = env.create_deferred()?;
@@ -70,7 +71,6 @@ pub fn create_provider_with_mock_timer(
     let runtime = runtime::Handle::current();
 
     let ConfigResolution {
-        contract_decoder,
         logger_config,
         provider_config,
         subscription_callback,
@@ -80,9 +80,9 @@ pub fn create_provider_with_mock_timer(
         provider_config,
         logger_config,
         subscription_config,
-        tracing_config,
     ));
 
+    let contract_decoder = Arc::clone(contract_decoder.as_inner());
     let timer = Arc::clone(&time.inner);
 
     runtime.clone().spawn_blocking(move || {
@@ -112,7 +112,7 @@ pub fn create_provider_with_mock_timer(
                         subscription_callback.call(event);
                     }),
                     provider_config,
-                    contract_decoder.clone(),
+                    Arc::clone(&contract_decoder),
                     timer,
                 )
                 .map_err(|error| napi::Error::from_reason(error.to_string()))?;

package/src/mock.rs

@@ -23,15 +23,6 @@ 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

@@ -5,18 +5,18 @@ mod response;
 use std::sync::Arc;
 
 use edr_napi_core::provider::SyncProvider;
-use edr_solidity::contract_decoder::ContractDecoder;
+use edr_solidity::compiler::create_models_and_decode_bytecodes;
 use napi::{tokio::runtime, Env, JsFunction, JsObject, Status};
 use napi_derive::napi;
 
 pub use self::factory::ProviderFactory;
 use self::response::Response;
-use crate::call_override::CallOverrideCallback;
+use crate::{call_override::CallOverrideCallback, contract_decoder::ContractDecoder};
 
 /// A JSON-RPC provider for Ethereum.
 #[napi]
 pub struct Provider {
-    contract_decoder: Arc<ContractDecoder>,
+    contract_decoder: Arc<edr_solidity::contract_decoder::ContractDecoder>,
     provider: Arc<dyn SyncProvider>,
     runtime: runtime::Handle,
     #[cfg(feature = "scenarios")]
@@ -28,7 +28,7 @@ impl Provider {
     pub fn new(
         provider: Arc<dyn SyncProvider>,
         runtime: runtime::Handle,
-        contract_decoder: Arc<ContractDecoder>,
+        contract_decoder: Arc<edr_solidity::contract_decoder::ContractDecoder>,
         #[cfg(feature = "scenarios")] scenario_file: Option<
             napi::tokio::sync::Mutex<napi::tokio::fs::File>,
         >,
@@ -54,8 +54,8 @@ impl Provider {
         solc_version: String,
         compiler_input: serde_json::Value,
         compiler_output: serde_json::Value,
-    ) -> napi::Result<bool> {
-        let provider = self.provider.clone();
+    ) -> napi::Result<()> {
+        let contract_decoder = self.contract_decoder.clone();
 
         self.runtime
             .spawn_blocking(move || {
@@ -65,12 +65,33 @@ impl Provider {
                 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)
+                let contracts = match create_models_and_decode_bytecodes(
+                    solc_version,
+                    &compiler_input,
+                    &compiler_output,
+                ) {
+                    Ok(contracts) => contracts,
+                    Err(error) => {
+                        return Err(napi::Error::from_reason(format!("Contract decoder failed to be updated. Please report this to help us improve Hardhat.\n{error}")));
+                    }
+                };
+
+                for contract in contracts {
+                    contract_decoder.add_contract_metadata(contract);
+                }
+
+                Ok(())
             })
             .await
             .map_err(|error| napi::Error::new(Status::GenericFailure, error.to_string()))?
     }
 
+    #[doc = "Retrieves the instance's contract decoder."]
+    #[napi(catch_unwind)]
+    pub fn contract_decoder(&self) -> ContractDecoder {
+        ContractDecoder::from(Arc::clone(&self.contract_decoder))
+    }
+
     #[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/config.rs

@@ -109,7 +109,7 @@ pub struct SolidityTestRunnerConfigArgs {
     /// Defaults to false.
     pub disable_block_gas_limit: Option<bool>,
     /// The memory limit of the EVM in bytes.
-    /// Defaults to 33_554_432 (2^25 = 32MiB).
+    /// Defaults to `33_554_432` (2^25 = 32MiB).
     #[serde(serialize_with = "serialize_optional_bigint_as_struct")]
     pub memory_limit: Option<BigInt>,
     /// The predeploys applied in local mode. Defaults to no predeploys.
@@ -143,6 +143,8 @@ pub struct SolidityTestRunnerConfigArgs {
     /// If an invariant config setting is not set, but a corresponding fuzz
     /// config value is set, then the fuzz config value will be used.
     pub invariant: Option<InvariantConfigArgs>,
+    /// Whether to collect stack traces.
+    pub collect_stack_traces: Option<CollectStackTraces>,
     /// Controls which test results should include execution traces. Defaults to
     /// None.
     pub include_traces: Option<IncludeTraces>,
@@ -194,6 +196,7 @@ impl SolidityTestRunnerConfigArgs {
             prompt_timeout,
             fuzz,
             invariant,
+            collect_stack_traces,
             include_traces,
             observability,
             test_pattern,
@@ -296,6 +299,10 @@ impl SolidityTestRunnerConfigArgs {
             cheatcode,
             fuzz,
             invariant,
+            collect_stack_traces: collect_stack_traces.map_or(
+                edr_solidity_tests::CollectStackTraces::OnFailure,
+                edr_solidity_tests::CollectStackTraces::from,
+            ),
             on_collected_coverage_fn,
             test_pattern,
         };
@@ -721,6 +728,29 @@ pub struct AddressLabel {
     pub label: String,
 }
 
+/// A type that controls when stack traces are collected.
+#[napi]
+#[derive(Debug, serde::Serialize)]
+pub enum CollectStackTraces {
+    /// Always collects stack traces, adding performance overhead.
+    Always,
+    /// Only collects stack traces upon failure, re-executing the test. This
+    /// minimizes performance overhead.
+    ///
+    /// Not all tests can be re-executed since certain cheatcodes contain
+    /// non-deterministic side-effects.
+    OnFailure,
+}
+
+impl From<CollectStackTraces> for edr_solidity_tests::CollectStackTraces {
+    fn from(value: CollectStackTraces) -> Self {
+        match value {
+            CollectStackTraces::Always => edr_solidity_tests::CollectStackTraces::Always,
+            CollectStackTraces::OnFailure => edr_solidity_tests::CollectStackTraces::OnFailure,
+        }
+    }
+}
+
 /// Configuration for [`SolidityTestRunnerConfigArgs::include_traces`] that
 /// controls execution trace decoding and inclusion in test results.
 #[napi]

package/src/solidity_tests/test_results.rs

@@ -42,7 +42,7 @@ pub struct ValueSnapshotEntry {
     pub value: String,
 }
 
-/// See [edr_solidity_tests::result::SuiteResult]
+/// See [`edr_solidity_tests::result::SuiteResult`]
 #[napi]
 #[derive(Clone, Debug)]
 pub struct SuiteResult {
@@ -50,13 +50,13 @@ pub struct SuiteResult {
     /// callback
     #[napi(readonly)]
     pub id: ArtifactId,
-    /// See [edr_solidity_tests::result::SuiteResult::duration]
+    /// See [`edr_solidity_tests::result::SuiteResult::duration`]
     #[napi(readonly)]
     pub duration_ns: BigInt,
-    /// See [edr_solidity_tests::result::SuiteResult::test_results]
+    /// See [`edr_solidity_tests::result::SuiteResult::test_results`]
     #[napi(readonly)]
     pub test_results: Vec<TestResult>,
-    /// See [edr_solidity_tests::result::SuiteResult::warnings]
+    /// See [`edr_solidity_tests::result::SuiteResult::warnings`]
     #[napi(readonly)]
     pub warnings: Vec<String>,
 }
@@ -80,29 +80,29 @@ impl SuiteResult {
     }
 }
 
-/// See [edr_solidity_tests::result::TestResult]
+/// See [`edr_solidity_tests::result::TestResult`]
 #[napi]
 #[derive(Clone, Debug)]
 pub struct TestResult {
     /// The name of the test.
     #[napi(readonly)]
     pub name: String,
-    /// See [edr_solidity_tests::result::TestResult::status]
+    /// See [`edr_solidity_tests::result::TestResult::status`]
     #[napi(readonly)]
     pub status: TestStatus,
-    /// See [edr_solidity_tests::result::TestResult::reason]
+    /// See [`edr_solidity_tests::result::TestResult::reason`]
     #[napi(readonly)]
     pub reason: Option<String>,
-    /// See [edr_solidity_tests::result::TestResult::counterexample]
+    /// See [`edr_solidity_tests::result::TestResult::counterexample`]
     #[napi(readonly)]
     pub counterexample: Option<Either<BaseCounterExample, CounterExampleSequence>>,
-    /// See [edr_solidity_tests::result::TestResult::decoded_logs]
+    /// See [`edr_solidity_tests::result::TestResult::decoded_logs`]
     #[napi(readonly)]
     pub decoded_logs: Vec<String>,
-    /// See [edr_solidity_tests::result::TestResult::kind]
+    /// See [`edr_solidity_tests::result::TestResult::kind`]
     #[napi(readonly)]
     pub kind: Either3<StandardTestKind, FuzzTestKind, InvariantTestKind>,
-    /// See [edr_solidity_tests::result::TestResult::duration]
+    /// See [`edr_solidity_tests::result::TestResult::duration`]
     #[napi(readonly)]
     pub duration_ns: BigInt,
     /// Groups of value snapshot entries (incl. gas).
@@ -335,7 +335,7 @@ impl From<edr_solidity_tests::result::TestStatus> for TestStatus {
     }
 }
 
-/// See [edr_solidity_tests::result::TestKind::Standard]
+/// See [`edr_solidity_tests::result::TestKind::Standard`]
 #[napi(object)]
 #[derive(Debug, Clone)]
 pub struct StandardTestKind {
@@ -344,22 +344,22 @@ pub struct StandardTestKind {
     pub consumed_gas: BigInt,
 }
 
-/// See [edr_solidity_tests::result::TestKind::Fuzz]
+/// See [`edr_solidity_tests::result::TestKind::Fuzz`]
 #[napi(object)]
 #[derive(Debug, Clone)]
 pub struct FuzzTestKind {
-    /// See [edr_solidity_tests::result::TestKind::Fuzz]
+    /// See [`edr_solidity_tests::result::TestKind::Fuzz`]
     #[napi(readonly)]
     pub runs: BigInt,
-    /// See [edr_solidity_tests::result::TestKind::Fuzz]
+    /// See [`edr_solidity_tests::result::TestKind::Fuzz`]
     #[napi(readonly)]
     pub mean_gas: BigInt,
-    /// See [edr_solidity_tests::result::TestKind::Fuzz]
+    /// See [`edr_solidity_tests::result::TestKind::Fuzz`]
     #[napi(readonly)]
     pub median_gas: BigInt,
 }
 
-/// See [edr_solidity_tests::fuzz::FuzzCase]
+/// See [`edr_solidity_tests::fuzz::FuzzCase`]
 #[napi(object)]
 #[derive(Clone)]
 pub struct FuzzCase {
@@ -383,17 +383,17 @@ impl Debug for FuzzCase {
     }
 }
 
-/// See [edr_solidity_tests::result::TestKind::Invariant]
+/// See [`edr_solidity_tests::result::TestKind::Invariant`]
 #[napi(object)]
 #[derive(Debug, Clone)]
 pub struct InvariantTestKind {
-    /// See [edr_solidity_tests::result::TestKind::Invariant]
+    /// See [`edr_solidity_tests::result::TestKind::Invariant`]
     #[napi(readonly)]
     pub runs: BigInt,
-    /// See [edr_solidity_tests::result::TestKind::Invariant]
+    /// See [`edr_solidity_tests::result::TestKind::Invariant`]
     #[napi(readonly)]
     pub calls: BigInt,
-    /// See [edr_solidity_tests::result::TestKind::Invariant]
+    /// See [`edr_solidity_tests::result::TestKind::Invariant`]
     #[napi(readonly)]
     pub reverts: BigInt,
 }
@@ -409,26 +409,26 @@ pub struct CounterExampleSequence {
     pub sequence: Vec<BaseCounterExample>,
 }
 
-/// See [edr_solidity_tests::fuzz::BaseCounterExample]
+/// See [`edr_solidity_tests::fuzz::BaseCounterExample`]
 #[napi(object)]
 #[derive(Clone)]
 pub struct BaseCounterExample {
-    /// See [edr_solidity_tests::fuzz::BaseCounterExample::sender]
+    /// See [`edr_solidity_tests::fuzz::BaseCounterExample::sender`]
     #[napi(readonly)]
     pub sender: Option<Uint8Array>,
-    /// See [edr_solidity_tests::fuzz::BaseCounterExample::addr]
+    /// See [`edr_solidity_tests::fuzz::BaseCounterExample::addr`]
     #[napi(readonly)]
     pub address: Option<Uint8Array>,
-    /// See [edr_solidity_tests::fuzz::BaseCounterExample::calldata]
+    /// See [`edr_solidity_tests::fuzz::BaseCounterExample::calldata`]
     #[napi(readonly)]
     pub calldata: Uint8Array,
-    /// See [edr_solidity_tests::fuzz::BaseCounterExample::contract_name]
+    /// See [`edr_solidity_tests::fuzz::BaseCounterExample::contract_name`]
     #[napi(readonly)]
     pub contract_name: Option<String>,
-    /// See [edr_solidity_tests::fuzz::BaseCounterExample::signature]
+    /// See [`edr_solidity_tests::fuzz::BaseCounterExample::signature`]
     #[napi(readonly)]
     pub signature: Option<String>,
-    /// See [edr_solidity_tests::fuzz::BaseCounterExample::args]
+    /// See [`edr_solidity_tests::fuzz::BaseCounterExample::args`]
     #[napi(readonly)]
     pub args: Option<String>,
 }
@@ -604,7 +604,10 @@ impl CallTrace {
         loop {
             // We will break out of the loop before the stack goes empty.
             let mut item = stack.pop().unwrap();
-            let node = &arena.nodes()[item.arena_index];
+            let node = arena
+                .nodes()
+                .get(item.arena_index)
+                .expect("Arena index should be valid");
 
             if item.visited {
                 let mut logs = node
@@ -618,11 +621,20 @@ impl CallTrace {
                     .iter()
                     .filter_map(|ord| match *ord {
                         traces::TraceMemberOrder::Log(i) => {
-                            let log = logs[i].take().unwrap();
+                            let log = logs
+                                .get_mut(i)
+                                .expect("Log index should be valid")
+                                .take()
+                                .unwrap();
                             Some(Either::B(log))
                         }
                         traces::TraceMemberOrder::Call(i) => {
-                            let child_trace = item.child_traces[i].take().unwrap();
+                            let child_trace = item
+                                .child_traces
+                                .get_mut(i)
+                                .expect("Child trace index should be valid")
+                                .take()
+                                .unwrap();
                             Some(Either::A(child_trace))
                         }
                         traces::TraceMemberOrder::Step(_) => None,
@@ -632,7 +644,9 @@ impl CallTrace {
                 let trace = CallTrace::new(node, children);
 
                 if let Some(parent_stack_index) = item.parent_stack_index {
-                    let parent = &mut stack[parent_stack_index];
+                    let parent = stack
+                        .get_mut(parent_stack_index)
+                        .expect("Parent stack index should be valid");
                     parent.child_traces.push(Some(trace));
                 } else {
                     return trace;

package/src/trace/debug.rs

@@ -46,7 +46,9 @@ fn print_stack_trace(trace: SolidityStackTrace) -> napi::Result<()> {
                 })?;
 
                 let mut value = serde_json::to_value(entry)?;
-                value["message"] = decoded_error_msg.into();
+                if let Some(obj) = value.as_object_mut() {
+                    obj.insert("message".to_string(), decoded_error_msg.into());
+                }
                 Ok(value)
             }
         })

package/src/trace/return_data.rs

@@ -22,11 +22,9 @@ pub struct ReturnData {
 impl ReturnData {
     #[napi(catch_unwind, constructor)]
     pub fn new(value: Uint8Array) -> Self {
-        let selector = if value.len() >= 4 {
-            Some(value[0..4].try_into().unwrap())
-        } else {
-            None
-        };
+        let selector = value
+            .get(0..4)
+            .map(|selector| selector.try_into().expect("selector is 4 bytes"));
 
         Self { value, selector }
     }