@nomicfoundation/edr 0.6.4 → 0.7.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 */
@@ -346,18 +344,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 {
@@ -376,53 +363,18 @@ export const enum ExitCode {
   /** Create init code size exceeds limit (runtime). */
   CODESIZE_EXCEEDS_MAXIMUM = 6,
   /** Create collision. */
-  CREATE_COLLISION = 7
-}
-export interface EvmStep {
-  pc: number
+  CREATE_COLLISION = 7,
+  /** Unknown halt reason. */
+  UNKNOWN_HALT_REASON = 8
 }
-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,
@@ -578,11 +530,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
@@ -626,6 +573,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
@@ -643,7 +595,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: any, 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
@@ -658,19 +610,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)
@@ -680,26 +633,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.4",
+  "version": "0.7.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.4",
-    "@nomicfoundation/edr-darwin-x64": "0.6.4",
-    "@nomicfoundation/edr-linux-arm64-gnu": "0.6.4",
-    "@nomicfoundation/edr-linux-arm64-musl": "0.6.4",
-    "@nomicfoundation/edr-linux-x64-gnu": "0.6.4",
-    "@nomicfoundation/edr-linux-x64-musl": "0.6.4",
-    "@nomicfoundation/edr-win32-x64-msvc": "0.6.4"
+    "@nomicfoundation/edr-darwin-arm64": "0.7.0",
+    "@nomicfoundation/edr-darwin-x64": "0.7.0",
+    "@nomicfoundation/edr-linux-arm64-gnu": "0.7.0",
+    "@nomicfoundation/edr-linux-arm64-musl": "0.7.0",
+    "@nomicfoundation/edr-linux-x64-gnu": "0.7.0",
+    "@nomicfoundation/edr-linux-x64-musl": "0.7.0",
+    "@nomicfoundation/edr-win32-x64-msvc": "0.7.0"
   },
   "scripts": {
     "artifacts": "napi artifacts",

package/src/context.rs

@@ -1,5 +1,6 @@
-use std::{io, ops::Deref, sync::Arc};
+use std::{ops::Deref, sync::Arc};
 
+#[cfg(feature = "tracing")]
 use napi::Status;
 use napi_derive::napi;
 use tracing_subscriber::{prelude::*, EnvFilter, Registry};
@@ -23,8 +24,7 @@ impl EdrContext {
     #[doc = "Creates a new [`EdrContext`] instance. Should only be called once!"]
     #[napi(constructor)]
     pub fn new() -> napi::Result<Self> {
-        let context =
-            Context::new().map_err(|e| napi::Error::new(Status::GenericFailure, e.to_string()))?;
+        let context = Context::new()?;
 
         Ok(Self {
             inner: Arc::new(context),
@@ -34,14 +34,13 @@ impl EdrContext {
 
 #[derive(Debug)]
 pub struct Context {
-    _subscriber_guard: tracing::subscriber::DefaultGuard,
     #[cfg(feature = "tracing")]
     _tracing_write_guard: tracing_flame::FlushGuard<std::io::BufWriter<std::fs::File>>,
 }
 
 impl Context {
     /// Creates a new [`Context`] instance. Should only be called once!
-    pub fn new() -> io::Result<Self> {
+    pub fn new() -> napi::Result<Self> {
         let fmt_layer = tracing_subscriber::fmt::layer()
             .with_file(true)
             .with_line_number(true)
@@ -54,8 +53,13 @@ impl Context {
 
         #[cfg(feature = "tracing")]
         let (flame_layer, guard) = {
-            let (flame_layer, guard) =
-                tracing_flame::FlameLayer::with_file("tracing.folded").unwrap();
+            let (flame_layer, guard) = tracing_flame::FlameLayer::with_file("tracing.folded")
+                .map_err(|err| {
+                    napi::Error::new(
+                        Status::GenericFailure,
+                        format!("Failed to create tracing.folded file with error: {err:?}"),
+                    )
+                })?;
 
             let flame_layer = flame_layer.with_empty_samples(false);
             (flame_layer, guard)
@@ -64,10 +68,14 @@ impl Context {
         #[cfg(feature = "tracing")]
         let subscriber = subscriber.with(flame_layer);
 
-        let subscriber_guard = tracing::subscriber::set_default(subscriber);
+        if let Err(error) = tracing::subscriber::set_global_default(subscriber) {
+            println!(
+                "Failed to set global tracing subscriber with error: {error}\n\
+                Please only initialize EdrContext once per process to avoid this error."
+            );
+        }
 
         Ok(Self {
-            _subscriber_guard: subscriber_guard,
             #[cfg(feature = "tracing")]
             _tracing_write_guard: guard,
         })

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,6 +4,7 @@ use std::sync::Arc;
 
 use edr_provider::{time::CurrentTime, InvalidRequestReason};
 use edr_rpc_eth::jsonrpc;
+use edr_solidity::contract_decoder::ContractDecoder;
 use napi::{tokio::runtime, Either, Env, JsFunction, JsObject, Status};
 use napi_derive::napi;
 
@@ -13,7 +14,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 +22,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 +37,25 @@ impl Provider {
         _context: &EdrContext,
         config: ProviderConfig,
         logger_config: LoggerConfig,
+        tracing_config: serde_json::Value,
         #[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::contract_decoder::BuildInfoConfig =
+            serde_json::from_value(tracing_config)?;
+        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 +73,7 @@ impl Provider {
                 logger,
                 subscriber_callback,
                 config,
+                Arc::clone(&contract_decoder),
                 CurrentTime,
             )
             .map_or_else(
@@ -66,6 +82,7 @@ impl Provider {
                     Ok(Provider {
                         provider: Arc::new(provider),
                         runtime,
+                        contract_decoder,
                         #[cfg(feature = "scenarios")]
                         scenario_file,
                     })
@@ -184,10 +201,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 +245,12 @@ impl Provider {
     }
 }
 
+#[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 +259,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 +272,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 +279,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)
+        }
+    }
 }