@nomicfoundation/edr 0.6.5 → 0.8.0

package/index.d.ts

@@ -149,8 +149,6 @@ export interface LoggerConfig {
   /** Whether to enable the logger. */
   enable: boolean
   decodeConsoleLogInputsCallback: (inputs: Buffer[]) => string[]
-  /** Used to resolve the contract and function name when logging. */
-  getContractAndFunctionNameCallback: (code: Buffer, calldata?: Buffer) => ContractAndFunctionName
   printLineCallback: (message: string, replace: boolean) => void
 }
 /** Configuration for a chain */
@@ -256,6 +254,27 @@ export interface ProviderConfig {
   /** The network ID of the blockchain */
   networkId: bigint
 }
+/** Tracing config for Solidity stack trace generation. */
+export interface TracingConfigWithBuffers {
+  /**
+   * Build information to use for decoding contracts. Either a Hardhat v2
+   * build info file that contains both input and output or a Hardhat v3
+   * build info file that doesn't contain output and a separate output file.
+   */
+  buildInfos?: Array<Uint8Array> | Array<BuildInfoAndOutput>
+  /** Whether to ignore contracts whose name starts with "Ignored". */
+  ignoreContracts?: boolean
+}
+/**
+ * Hardhat V3 build info where the compiler output is not part of the build
+ * info file.
+ */
+export interface BuildInfoAndOutput {
+  /** The build info input file */
+  buildInfo: Uint8Array
+  /** The build info output file */
+  output: Uint8Array
+}
 /** The possible reasons for successful termination of the EVM. */
 export const enum SuccessReason {
   /** The opcode `STOP` was called */
@@ -346,18 +365,7 @@ export interface SubscriptionEvent {
   filterId: bigint
   result: any
 }
-export declare function createModelsAndDecodeBytecodes(solcVersion: string, compilerInput: any, compilerOutput: any): Array<BytecodeWrapper>
 export declare function linkHexStringBytecode(code: string, address: string, position: number): string
-export const enum ContractFunctionType {
-  CONSTRUCTOR = 0,
-  FUNCTION = 1,
-  FALLBACK = 2,
-  RECEIVE = 3,
-  GETTER = 4,
-  MODIFIER = 5,
-  FREE_FUNCTION = 6
-}
-export declare function printMessageTrace(trace: PrecompileMessageTrace | CallMessageTrace | CreateMessageTrace, depth?: number | undefined | null): void
 export declare function printStackTrace(trace: SolidityStackTrace): void
 /** Represents the exit code of the EVM. */
 export const enum ExitCode {
@@ -380,51 +388,14 @@ export const enum ExitCode {
   /** Unknown halt reason. */
   UNKNOWN_HALT_REASON = 8
 }
-export interface EvmStep {
-  pc: number
-}
-export interface PrecompileMessageTrace {
-  value: bigint
-  returnData: Uint8Array
-  exit: Exit
-  gasUsed: bigint
-  depth: number
-  precompile: number
-  calldata: Uint8Array
-}
-export interface CreateMessageTrace {
-  value: bigint
-  returnData: Uint8Array
-  exit: Exit
-  gasUsed: bigint
-  depth: number
-  code: Uint8Array
-  steps: Array<EvmStep | PrecompileMessageTrace | CallMessageTrace | CreateMessageTrace>
-  /**
-   * Reference to the resolved `Bytecode` EDR data.
-   * Only used on the JS side by the `VmTraceDecoder` class.
-   */
-  bytecode?: BytecodeWrapper
-  numberOfSubtraces: number
-  deployedContract?: Uint8Array | undefined
-}
-export interface CallMessageTrace {
-  value: bigint
-  returnData: Uint8Array
-  exit: Exit
-  gasUsed: bigint
-  depth: number
-  code: Uint8Array
-  steps: Array<EvmStep | PrecompileMessageTrace | CallMessageTrace | CreateMessageTrace>
-  /**
-   * Reference to the resolved `Bytecode` EDR data.
-   * Only used on the JS side by the `VmTraceDecoder` class.
-   */
-  bytecode?: BytecodeWrapper
-  numberOfSubtraces: number
-  calldata: Uint8Array
-  address: Uint8Array
-  codeAddress: Uint8Array
+export const enum ContractFunctionType {
+  CONSTRUCTOR = 0,
+  FUNCTION = 1,
+  FALLBACK = 2,
+  RECEIVE = 3,
+  GETTER = 4,
+  MODIFIER = 5,
+  FREE_FUNCTION = 6
 }
 export const enum StackTraceEntryType {
   CALLSTACK_ENTRY = 0,
@@ -580,11 +551,6 @@ export interface ContractCallRunOutOfGasError {
   type: StackTraceEntryType.CONTRACT_CALL_RUN_OUT_OF_GAS_ERROR
   sourceReference?: SourceReference
 }
-export interface ContractAndFunctionName {
-  contractName: string
-  functionName: string | undefined
-}
-export declare function initializeVmTraceDecoder(vmTraceDecoder: VmTraceDecoder, tracingConfig: any): void
 export interface TracingMessage {
   /** Sender address */
   readonly caller: Buffer
@@ -628,6 +594,11 @@ 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
@@ -645,7 +616,7 @@ export declare class EdrContext {
 /** A JSON-RPC provider for Ethereum. */
 export declare class Provider {
   /**Constructs a new provider with the provided configuration. */
-  static withConfig(context: EdrContext, config: ProviderConfig, loggerConfig: LoggerConfig, subscriberCallback: (event: SubscriptionEvent) => void): Promise<Provider>
+  static withConfig(context: EdrContext, config: ProviderConfig, loggerConfig: LoggerConfig, tracingConfig: TracingConfigWithBuffers, subscriberCallback: (event: SubscriptionEvent) => void): Promise<Provider>
   /**Handles a JSON-RPC request and returns a JSON-RPC response. */
   handleRequest(jsonRequest: string): Promise<Response>
   setCallOverrideCallback(callOverrideCallback: (contract_address: Buffer, data: Buffer) => Promise<CallOverrideResult | undefined>): void
@@ -660,19 +631,20 @@ export declare class Provider {
 export declare class Response {
   /** Returns the response data as a JSON string or a JSON object. */
   get data(): string | any
-  get solidityTrace(): RawTrace | null
   get traces(): Array<RawTrace>
+  /**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
 }
-/**
- * Opaque handle to the `Bytecode` struct.
- * Only used on the JS side by the `VmTraceDecoder` class.
- */
-export declare class BytecodeWrapper { }
 export declare class Exit {
   get kind(): ExitCode
   isError(): boolean
   getReason(): string
 }
+/**
+ * Opaque handle to the `Bytecode` struct.
+ * Only used on the JS side by the `VmTraceDecoder` class.
+ */
+export declare class BytecodeWrapper { }
 export declare class ReturnData {
   readonly value: Uint8Array
   constructor(value: Uint8Array)
@@ -682,26 +654,6 @@ export declare class ReturnData {
   decodeError(): string
   decodePanic(): bigint
 }
-export declare class SolidityTracer {
-  
-  constructor()
-  getStackTrace(trace: PrecompileMessageTrace | CallMessageTrace | CreateMessageTrace): SolidityStackTrace
-}
-export declare class VmTraceDecoder {
-  constructor()
-  addBytecode(bytecode: BytecodeWrapper): void
-  tryToDecodeMessageTrace(messageTrace: PrecompileMessageTrace | CallMessageTrace | CreateMessageTrace): PrecompileMessageTrace | CallMessageTrace | CreateMessageTrace
-  getContractAndFunctionNamesForCall(code: Uint8Array, calldata: Uint8Array | undefined): ContractAndFunctionName
-}
-export type VMTracer = VmTracer
-/** N-API bindings for the Rust port of `VMTracer` from Hardhat. */
-export declare class VmTracer {
-  constructor()
-  /** Observes a trace, collecting information about the execution of the EVM. */
-  observe(trace: RawTrace): void
-  getLastTopLevelMessageTrace(): PrecompileMessageTrace | CallMessageTrace | CreateMessageTrace | undefined
-  getLastError(): Error | undefined
-}
 export declare class RawTrace {
   trace(): Array<TracingMessage | TracingStep | TracingMessageResult>
 }

package/index.js

@@ -310,7 +310,7 @@ if (!nativeBinding) {
   throw new Error(`Failed to load native binding`)
 }
 
-const { SpecId, EdrContext, MineOrdering, Provider, Response, SuccessReason, ExceptionalHalt, createModelsAndDecodeBytecodes, linkHexStringBytecode, BytecodeWrapper, ContractFunctionType, printMessageTrace, printStackTrace, Exit, ExitCode, ReturnData, StackTraceEntryType, stackTraceEntryTypeToString, FALLBACK_FUNCTION_NAME, RECEIVE_FUNCTION_NAME, CONSTRUCTOR_FUNCTION_NAME, UNRECOGNIZED_FUNCTION_NAME, UNKNOWN_FUNCTION_NAME, PRECOMPILE_FUNCTION_NAME, UNRECOGNIZED_CONTRACT_NAME, SolidityTracer, VmTraceDecoder, initializeVmTraceDecoder, VmTracer, RawTrace } = nativeBinding
+const { SpecId, EdrContext, MineOrdering, Provider, Response, SuccessReason, ExceptionalHalt, 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.SpecId = SpecId
 module.exports.EdrContext = EdrContext
@@ -319,14 +319,12 @@ module.exports.Provider = Provider
 module.exports.Response = Response
 module.exports.SuccessReason = SuccessReason
 module.exports.ExceptionalHalt = ExceptionalHalt
-module.exports.createModelsAndDecodeBytecodes = createModelsAndDecodeBytecodes
 module.exports.linkHexStringBytecode = linkHexStringBytecode
-module.exports.BytecodeWrapper = BytecodeWrapper
-module.exports.ContractFunctionType = ContractFunctionType
-module.exports.printMessageTrace = printMessageTrace
 module.exports.printStackTrace = printStackTrace
 module.exports.Exit = Exit
 module.exports.ExitCode = ExitCode
+module.exports.BytecodeWrapper = BytecodeWrapper
+module.exports.ContractFunctionType = ContractFunctionType
 module.exports.ReturnData = ReturnData
 module.exports.StackTraceEntryType = StackTraceEntryType
 module.exports.stackTraceEntryTypeToString = stackTraceEntryTypeToString
@@ -337,8 +335,5 @@ module.exports.UNRECOGNIZED_FUNCTION_NAME = UNRECOGNIZED_FUNCTION_NAME
 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.SolidityTracer = SolidityTracer
-module.exports.VmTraceDecoder = VmTraceDecoder
-module.exports.initializeVmTraceDecoder = initializeVmTraceDecoder
-module.exports.VmTracer = VmTracer
 module.exports.RawTrace = RawTrace
+module.exports.getLatestSupportedSolcVersion = getLatestSupportedSolcVersion

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nomicfoundation/edr",
-  "version": "0.6.5",
+  "version": "0.8.0",
   "devDependencies": {
     "@napi-rs/cli": "^2.18.4",
     "@types/chai": "^4.2.0",
@@ -52,13 +52,13 @@
   "repository": "NomicFoundation/edr.git",
   "types": "index.d.ts",
   "dependencies": {
-    "@nomicfoundation/edr-darwin-arm64": "0.6.5",
-    "@nomicfoundation/edr-darwin-x64": "0.6.5",
-    "@nomicfoundation/edr-linux-arm64-gnu": "0.6.5",
-    "@nomicfoundation/edr-linux-arm64-musl": "0.6.5",
-    "@nomicfoundation/edr-linux-x64-gnu": "0.6.5",
-    "@nomicfoundation/edr-linux-x64-musl": "0.6.5",
-    "@nomicfoundation/edr-win32-x64-msvc": "0.6.5"
+    "@nomicfoundation/edr-darwin-arm64": "0.8.0",
+    "@nomicfoundation/edr-darwin-x64": "0.8.0",
+    "@nomicfoundation/edr-linux-arm64-gnu": "0.8.0",
+    "@nomicfoundation/edr-linux-arm64-musl": "0.8.0",
+    "@nomicfoundation/edr-linux-x64-gnu": "0.8.0",
+    "@nomicfoundation/edr-linux-x64-musl": "0.8.0",
+    "@nomicfoundation/edr-win32-x64-msvc": "0.8.0"
   },
   "scripts": {
     "artifacts": "napi artifacts",

package/src/logger.rs

@@ -1,4 +1,7 @@
-use std::{fmt::Display, sync::mpsc::channel};
+use std::{
+    fmt::Display,
+    sync::{mpsc::channel, Arc},
+};
 
 use ansi_term::{Color, Style};
 use edr_eth::{
@@ -14,6 +17,7 @@ use edr_evm::{
     ExecutionResult, SyncBlock,
 };
 use edr_provider::{ProviderError, TransactionFailure};
+use edr_solidity::contract_decoder::ContractDecoder;
 use itertools::izip;
 use napi::{
     threadsafe_function::{
@@ -41,21 +45,12 @@ impl TryCast<(String, Option<String>)> for ContractAndFunctionName {
     }
 }
 
-struct ContractAndFunctionNameCall {
-    code: Bytes,
-    /// Only present for calls.
-    calldata: Option<Bytes>,
-}
-
 #[napi(object)]
 pub struct LoggerConfig {
     /// Whether to enable the logger.
     pub enable: bool,
     #[napi(ts_type = "(inputs: Buffer[]) => string[]")]
     pub decode_console_log_inputs_callback: JsFunction,
-    #[napi(ts_type = "(code: Buffer, calldata?: Buffer) => ContractAndFunctionName")]
-    /// Used to resolve the contract and function name when logging.
-    pub get_contract_and_function_name_callback: JsFunction,
     #[napi(ts_type = "(message: string, replace: boolean) => void")]
     pub print_line_callback: JsFunction,
 }
@@ -118,9 +113,13 @@ pub struct Logger {
 }
 
 impl Logger {
-    pub fn new(env: &Env, config: LoggerConfig) -> napi::Result<Self> {
+    pub fn new(
+        env: &Env,
+        config: LoggerConfig,
+        contract_decoder: Arc<ContractDecoder>,
+    ) -> napi::Result<Self> {
         Ok(Self {
-            collector: LogCollector::new(env, config)?,
+            collector: LogCollector::new(env, config, contract_decoder)?,
         })
     }
 }
@@ -235,6 +234,15 @@ impl edr_provider::Logger for Logger {
 
         Ok(())
     }
+
+    fn print_contract_decoding_error(&mut self, error: &str) -> Result<(), Self::LoggerError> {
+        self.collector.log(
+            "Contract decoder failed to be updated. Please report this to help us improve Hardhat.",
+        );
+        self.collector.print_empty_line()?;
+        self.collector.log(error);
+        Ok(())
+    }
 }
 
 #[derive(Clone)]
@@ -245,9 +253,8 @@ pub struct CollapsedMethod {
 
 #[derive(Clone)]
 struct LogCollector {
+    contract_decoder: Arc<ContractDecoder>,
     decode_console_log_inputs_fn: ThreadsafeFunction<Vec<Bytes>, ErrorStrategy::Fatal>,
-    get_contract_and_function_name_fn:
-        ThreadsafeFunction<ContractAndFunctionNameCall, ErrorStrategy::Fatal>,
     indentation: usize,
     is_enabled: bool,
     logs: Vec<LogLine>,
@@ -257,7 +264,11 @@ struct LogCollector {
 }
 
 impl LogCollector {
-    pub fn new(env: &Env, config: LoggerConfig) -> napi::Result<Self> {
+    pub fn new(
+        env: &Env,
+        config: LoggerConfig,
+        contract_decoder: Arc<ContractDecoder>,
+    ) -> napi::Result<Self> {
         let mut decode_console_log_inputs_fn = config
             .decode_console_log_inputs_callback
             .create_threadsafe_function(0, |ctx: ThreadSafeCallContext<Vec<Bytes>>| {
@@ -281,34 +292,6 @@ impl LogCollector {
         // exiting.
         decode_console_log_inputs_fn.unref(env)?;
 
-        let mut get_contract_and_function_name_fn = config
-            .get_contract_and_function_name_callback
-            .create_threadsafe_function(
-                0,
-                |ctx: ThreadSafeCallContext<ContractAndFunctionNameCall>| {
-                    // Buffer
-                    let code = ctx
-                        .env
-                        .create_buffer_with_data(ctx.value.code.to_vec())?
-                        .into_unknown();
-
-                    // Option<Buffer>
-                    let calldata = if let Some(calldata) = ctx.value.calldata {
-                        ctx.env
-                            .create_buffer_with_data(calldata.to_vec())?
-                            .into_unknown()
-                    } else {
-                        ctx.env.get_undefined()?.into_unknown()
-                    };
-
-                    Ok(vec![code, calldata])
-                },
-            )?;
-
-        // Maintain a weak reference to the function to avoid the event loop from
-        // exiting.
-        get_contract_and_function_name_fn.unref(env)?;
-
         let mut print_line_fn = config.print_line_callback.create_threadsafe_function(
             0,
             |ctx: ThreadSafeCallContext<(String, bool)>| {
@@ -327,8 +310,8 @@ impl LogCollector {
         print_line_fn.unref(env)?;
 
         Ok(Self {
+            contract_decoder,
             decode_console_log_inputs_fn,
-            get_contract_and_function_name_fn,
             indentation: 0,
             is_enabled: config.enable,
             logs: Vec::new(),
@@ -560,29 +543,13 @@ impl LogCollector {
         code: Bytes,
         calldata: Option<Bytes>,
     ) -> (String, Option<String>) {
-        let (sender, receiver) = channel();
-
-        let status = self
-            .get_contract_and_function_name_fn
-            .call_with_return_value(
-                ContractAndFunctionNameCall { code, calldata },
-                ThreadsafeFunctionCallMode::Blocking,
-                move |result: ContractAndFunctionName| {
-                    let contract_and_function_name = result.try_cast();
-                    sender.send(contract_and_function_name).map_err(|_error| {
-                        napi::Error::new(
-                            Status::GenericFailure,
-                            "Failed to send result from get_contract_and_function_name",
-                        )
-                    })
-                },
-            );
-        assert_eq!(status, Status::Ok);
-
-        receiver
-            .recv()
-            .unwrap()
-            .expect("Failed call to get_contract_and_function_name")
+        let edr_solidity::contract_decoder::ContractAndFunctionName {
+            contract_name,
+            function_name,
+        } = self
+            .contract_decoder
+            .get_contract_and_function_names_for_call(&code, calldata.as_ref());
+        (contract_name, function_name)
     }
 
     fn format(&self, message: impl ToString) -> String {

package/src/provider.rs

@@ -4,7 +4,10 @@ use std::sync::Arc;
 
 use edr_provider::{time::CurrentTime, InvalidRequestReason};
 use edr_rpc_eth::jsonrpc;
-use napi::{tokio::runtime, Either, Env, JsFunction, JsObject, Status};
+use edr_solidity::contract_decoder::ContractDecoder;
+use napi::{
+    bindgen_prelude::Uint8Array, tokio::runtime, Either, Env, JsFunction, JsObject, Status,
+};
 use napi_derive::napi;
 
 use self::config::ProviderConfig;
@@ -13,7 +16,7 @@ use crate::{
     context::EdrContext,
     logger::{Logger, LoggerConfig, LoggerError},
     subscribe::SubscriberCallback,
-    trace::RawTrace,
+    trace::{solidity_stack_trace::SolidityStackTrace, RawTrace},
 };
 
 /// A JSON-RPC provider for Ethereum.
@@ -21,6 +24,7 @@ use crate::{
 pub struct Provider {
     provider: Arc<edr_provider::Provider<LoggerError>>,
     runtime: runtime::Handle,
+    contract_decoder: Arc<ContractDecoder>,
     #[cfg(feature = "scenarios")]
     scenario_file: Option<napi::tokio::sync::Mutex<napi::tokio::fs::File>>,
 }
@@ -35,12 +39,26 @@ impl Provider {
         _context: &EdrContext,
         config: ProviderConfig,
         logger_config: LoggerConfig,
+        tracing_config: TracingConfigWithBuffers,
         #[napi(ts_arg_type = "(event: SubscriptionEvent) => void")] subscriber_callback: JsFunction,
     ) -> napi::Result<JsObject> {
-        let config = edr_provider::ProviderConfig::try_from(config)?;
         let runtime = runtime::Handle::current();
 
-        let logger = Box::new(Logger::new(&env, logger_config)?);
+        let config = edr_provider::ProviderConfig::try_from(config)?;
+
+        // TODO https://github.com/NomicFoundation/edr/issues/760
+        let build_info_config =
+            edr_solidity::artifacts::BuildInfoConfig::parse_from_buffers((&tracing_config).into())
+                .map_err(|err| napi::Error::from_reason(err.to_string()))?;
+        let contract_decoder = ContractDecoder::new(&build_info_config)
+            .map_err(|error| napi::Error::from_reason(error.to_string()))?;
+        let contract_decoder = Arc::new(contract_decoder);
+
+        let logger = Box::new(Logger::new(
+            &env,
+            logger_config,
+            Arc::clone(&contract_decoder),
+        )?);
         let subscriber_callback = SubscriberCallback::new(&env, subscriber_callback)?;
         let subscriber_callback = Box::new(move |event| subscriber_callback.call(event));
 
@@ -58,6 +76,7 @@ impl Provider {
                 logger,
                 subscriber_callback,
                 config,
+                Arc::clone(&contract_decoder),
                 CurrentTime,
             )
             .map_or_else(
@@ -66,6 +85,7 @@ impl Provider {
                     Ok(Provider {
                         provider: Arc::new(provider),
                         runtime,
+                        contract_decoder,
                         #[cfg(feature = "scenarios")]
                         scenario_file,
                     })
@@ -184,10 +204,16 @@ impl Provider {
                 }
             })
             .map_err(|error| napi::Error::new(Status::GenericFailure, error.to_string()))
-            .map(|data| Response {
-                solidity_trace,
-                data,
-                traces: traces.into_iter().map(Arc::new).collect(),
+            .map(|data| {
+                let solidity_trace = solidity_trace.map(|trace| SolidityTraceData {
+                    trace,
+                    contract_decoder: Arc::clone(&self.contract_decoder),
+                });
+                Response {
+                    solidity_trace,
+                    data,
+                    traces: traces.into_iter().map(Arc::new).collect(),
+                }
             })
     }
 
@@ -222,6 +248,72 @@ impl Provider {
     }
 }
 
+/// Tracing config for Solidity stack trace generation.
+#[napi(object)]
+pub struct TracingConfigWithBuffers {
+    /// Build information to use for decoding contracts. Either a Hardhat v2
+    /// build info file that contains both input and output or a Hardhat v3
+    /// build info file that doesn't contain output and a separate output file.
+    pub build_infos: Option<Either<Vec<Uint8Array>, Vec<BuildInfoAndOutput>>>,
+    /// Whether to ignore contracts whose name starts with "Ignored".
+    pub ignore_contracts: Option<bool>,
+}
+
+/// Hardhat V3 build info where the compiler output is not part of the build
+/// info file.
+#[napi(object)]
+pub struct BuildInfoAndOutput {
+    /// The build info input file
+    pub build_info: Uint8Array,
+    /// The build info output file
+    pub output: Uint8Array,
+}
+
+impl<'a> From<&'a BuildInfoAndOutput>
+    for edr_solidity::artifacts::BuildInfoBufferSeparateOutput<'a>
+{
+    fn from(value: &'a BuildInfoAndOutput) -> Self {
+        Self {
+            build_info: value.build_info.as_ref(),
+            output: value.output.as_ref(),
+        }
+    }
+}
+
+impl<'a> From<&'a TracingConfigWithBuffers>
+    for edr_solidity::artifacts::BuildInfoConfigWithBuffers<'a>
+{
+    fn from(value: &'a TracingConfigWithBuffers) -> Self {
+        use edr_solidity::artifacts::{BuildInfoBufferSeparateOutput, BuildInfoBuffers};
+
+        let build_infos = value.build_infos.as_ref().map(|infos| match infos {
+            Either::A(with_output) => BuildInfoBuffers::WithOutput(
+                with_output
+                    .iter()
+                    .map(std::convert::AsRef::as_ref)
+                    .collect(),
+            ),
+            Either::B(separate_output) => BuildInfoBuffers::SeparateInputOutput(
+                separate_output
+                    .iter()
+                    .map(BuildInfoBufferSeparateOutput::from)
+                    .collect(),
+            ),
+        });
+
+        Self {
+            build_infos,
+            ignore_contracts: value.ignore_contracts,
+        }
+    }
+}
+
+#[derive(Debug)]
+struct SolidityTraceData {
+    trace: Arc<edr_evm::trace::Trace>,
+    contract_decoder: Arc<ContractDecoder>,
+}
+
 #[napi]
 pub struct Response {
     // N-API is known to be slow when marshalling `serde_json::Value`s, so we try to return a
@@ -230,7 +322,7 @@ pub struct Response {
     data: Either<String, serde_json::Value>,
     /// When a transaction fails to execute, the provider returns a trace of the
     /// transaction.
-    solidity_trace: Option<Arc<edr_evm::trace::Trace>>,
+    solidity_trace: Option<SolidityTraceData>,
     /// This may contain zero or more traces, depending on the (batch) request
     traces: Vec<Arc<edr_evm::trace::Trace>>,
 }
@@ -243,13 +335,6 @@ impl Response {
         self.data.clone()
     }
 
-    #[napi(getter)]
-    pub fn solidity_trace(&self) -> Option<RawTrace> {
-        self.solidity_trace
-            .as_ref()
-            .map(|trace| RawTrace::new(trace.clone()))
-    }
-
     #[napi(getter)]
     pub fn traces(&self) -> Vec<RawTrace> {
         self.traces
@@ -257,4 +342,35 @@ impl Response {
             .map(|trace| RawTrace::new(trace.clone()))
             .collect()
     }
+
+    // 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]
+    pub fn stack_trace(&self) -> napi::Result<Option<SolidityStackTrace>> {
+        let Some(SolidityTraceData {
+            trace,
+            contract_decoder,
+        }) = &self.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_message_trace(vm_trace);
+            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(super::cast::TryCast::try_cast)
+                .collect::<Result<Vec<_>, _>>()?;
+
+            Ok(Some(stack_trace))
+        } else {
+            Ok(None)
+        }
+    }
 }