@nomicfoundation/edr 0.12.0-next.2 → 0.12.0-next.4

package/index.d.ts

@@ -812,14 +812,36 @@ export interface PathPermission {
   /** The targeted path guarded by the permission */
   path: string
 }
-/** Determines the status of file system access */
+/**
+ * Determines the level of file system access for the given path.
+ *
+ * Exact path matching is used for file permissions. Prefix matching is used
+ * for directory permissions.
+ *
+ * Giving write access to configuration files, source files or executables
+ * in a project is considered dangerous, because it can be used by malicious
+ * Solidity dependencies to escape the EVM sandbox. It is therefore
+ * recommended to give write access to specific safe files only. If write
+ * access to a directory is needed, please make sure that it doesn't contain
+ * configuration files, source files or executables neither in the top level
+ * directory, nor in any subdirectories.
+*/
 export enum FsAccessPermission {
-  /** FS access is allowed with `read` + `write` permission */
-  ReadWrite = 0,
-  /** Only reading is allowed */
-  Read = 1,
-  /** Only writing is allowed */
-  Write = 2
+  /** Allows reading and writing the file */
+  ReadWriteFile = 0,
+  /** Only allows reading the file */
+  ReadFile = 1,
+  /** Only allows writing the file */
+  WriteFile = 2,
+  /**
+   * Allows reading and writing all files in the directory and its
+   * subdirectories
+   */
+  DangerouslyReadWriteDirectory = 3,
+  /** Allows reading all files in the directory and its subdirectories */
+  ReadDirectory = 4,
+  /** Allows writing all files in the directory and its subdirectories */
+  DangerouslyWriteDirectory = 5
 }
 export interface AddressLabel {
   /** The address to label */
@@ -1115,7 +1137,8 @@ export enum StackTraceEntryType {
   UNMAPPED_SOLC_0_6_3_REVERT_ERROR = 20,
   CONTRACT_TOO_LARGE_ERROR = 21,
   INTERNAL_FUNCTION_CALLSTACK_ENTRY = 22,
-  CONTRACT_CALL_RUN_OUT_OF_GAS_ERROR = 23
+  CONTRACT_CALL_RUN_OUT_OF_GAS_ERROR = 23,
+  CHEATCODE_ERROR = 24
 }
 export declare function stackTraceEntryTypeToString(val: StackTraceEntryType): string
 export const FALLBACK_FUNCTION_NAME: string
@@ -1245,6 +1268,11 @@ export interface ContractCallRunOutOfGasError {
   type: StackTraceEntryType.CONTRACT_CALL_RUN_OUT_OF_GAS_ERROR
   sourceReference?: SourceReference
 }
+export interface CheatcodeErrorStackTraceEntry {
+  type: StackTraceEntryType.CHEATCODE_ERROR
+  message: string
+  sourceReference: SourceReference
+}
 export interface TracingMessage {
   /** Sender address */
   readonly caller: Uint8Array
@@ -1336,6 +1364,12 @@ export declare class Response {
 }
 /** A JSON-RPC provider for Ethereum. */
 export declare class Provider {
+  /**
+   *Adds a compilation result to the instance.
+   *
+   *For internal use only. Support for this method may be removed in the future.
+   */
+  addCompilationResult(solcVersion: string, compilerInput: any, compilerOutput: any): Promise<boolean>
   /**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>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nomicfoundation/edr",
-  "version": "0.12.0-next.2",
+  "version": "0.12.0-next.4",
   "devDependencies": {
     "@napi-rs/cli": "^2.18.4",
     "@nomicfoundation/ethereumjs-util": "^9.0.4",
@@ -13,6 +13,7 @@
     "@typescript-eslint/parser": "5.61.0",
     "chai": "^4.3.6",
     "chai-as-promised": "^7.1.1",
+    "chalk": "^2.4.2",
     "eslint": "^8.44.0",
     "eslint-config-prettier": "9.1.0",
     "eslint-plugin-import": "2.27.5",
@@ -58,13 +59,13 @@
   "repository": "NomicFoundation/edr.git",
   "types": "index.d.ts",
   "optionalDependencies": {
-    "@nomicfoundation/edr-darwin-arm64": "0.12.0-next.2",
-    "@nomicfoundation/edr-darwin-x64": "0.12.0-next.2",
-    "@nomicfoundation/edr-linux-arm64-gnu": "0.12.0-next.2",
-    "@nomicfoundation/edr-linux-arm64-musl": "0.12.0-next.2",
-    "@nomicfoundation/edr-linux-x64-gnu": "0.12.0-next.2",
-    "@nomicfoundation/edr-linux-x64-musl": "0.12.0-next.2",
-    "@nomicfoundation/edr-win32-x64-msvc": "0.12.0-next.2"
+    "@nomicfoundation/edr-darwin-arm64": "0.12.0-next.4",
+    "@nomicfoundation/edr-darwin-x64": "0.12.0-next.4",
+    "@nomicfoundation/edr-linux-arm64-gnu": "0.12.0-next.4",
+    "@nomicfoundation/edr-linux-arm64-musl": "0.12.0-next.4",
+    "@nomicfoundation/edr-linux-x64-gnu": "0.12.0-next.4",
+    "@nomicfoundation/edr-linux-x64-musl": "0.12.0-next.4",
+    "@nomicfoundation/edr-win32-x64-msvc": "0.12.0-next.4"
   },
   "scripts": {
     "artifacts": "napi artifacts",
@@ -82,7 +83,7 @@
     "pretest": "pnpm build:dev",
     "prettier": "prettier --check \"test/**.ts\"",
     "test": "node --max-old-space-size=8192 node_modules/mocha/bin/_mocha --recursive \"test/**/*.ts\"",
-    "testNoBuild": "node --max-old-space-size=8192 node_modules/mocha/bin/_mocha --recursive \"test/**/{,!(mock)}.ts\"",
+    "testNoBuild": "node --max-old-space-size=8192 node_modules/mocha/bin/_mocha --recursive \"test/**/{,!(logs|mock)}.ts\"",
     "universal": "napi universal",
     "version": "napi version"
   }

package/src/chains/generic.rs

@@ -5,9 +5,9 @@ use edr_generic::GenericChainSpec;
 use edr_napi_core::{
     logger::{self, Logger},
     provider::{self, ProviderBuilder, SyncProviderFactory},
-    spec::SyncNapiSpec as _,
     subscription,
 };
+use edr_provider::time::CurrentTime;
 use edr_solidity::contract_decoder::ContractDecoder;
 use napi_derive::napi;
 
@@ -24,7 +24,10 @@ impl SyncProviderFactory for GenericChainProviderFactory {
         subscription_config: subscription::Config,
         contract_decoder: Arc<ContractDecoder>,
     ) -> napi::Result<Box<dyn provider::Builder>> {
-        let logger = Logger::<GenericChainSpec>::new(logger_config, Arc::clone(&contract_decoder))?;
+        let logger = Logger::<GenericChainSpec, CurrentTime>::new(
+            logger_config,
+            Arc::clone(&contract_decoder),
+        )?;
 
         let provider_config =
             edr_provider::ProviderConfig::<l1::SpecId>::try_from(provider_config)?;
@@ -42,7 +45,7 @@ impl SyncProviderFactory for GenericChainProviderFactory {
 }
 
 #[napi]
-pub const GENERIC_CHAIN_TYPE: &str = GenericChainSpec::CHAIN_TYPE;
+pub const GENERIC_CHAIN_TYPE: &str = edr_generic::CHAIN_TYPE;
 
 #[napi(catch_unwind)]
 pub fn generic_chain_provider_factory() -> ProviderFactory {

package/src/chains/l1.rs

@@ -8,9 +8,9 @@ use edr_evm::eips::{
 use edr_napi_core::{
     logger::Logger,
     provider::{self, ProviderBuilder, SyncProviderFactory},
-    spec::SyncNapiSpec as _,
     subscription,
 };
+use edr_provider::time::CurrentTime;
 use edr_solidity::contract_decoder::ContractDecoder;
 use napi::bindgen_prelude::{BigInt, Uint8Array};
 use napi_derive::napi;
@@ -28,7 +28,8 @@ impl SyncProviderFactory for L1ProviderFactory {
         subscription_config: edr_napi_core::subscription::Config,
         contract_decoder: Arc<ContractDecoder>,
     ) -> napi::Result<Box<dyn provider::Builder>> {
-        let logger = Logger::<L1ChainSpec>::new(logger_config, Arc::clone(&contract_decoder))?;
+        let logger =
+            Logger::<L1ChainSpec, CurrentTime>::new(logger_config, Arc::clone(&contract_decoder))?;
 
         let provider_config =
             edr_provider::ProviderConfig::<l1::SpecId>::try_from(provider_config)?;
@@ -46,7 +47,7 @@ impl SyncProviderFactory for L1ProviderFactory {
 }
 
 #[napi]
-pub const L1_CHAIN_TYPE: &str = L1ChainSpec::CHAIN_TYPE;
+pub const L1_CHAIN_TYPE: &str = edr_eth::l1::CHAIN_TYPE;
 
 #[napi(catch_unwind)]
 pub fn l1_genesis_state(hardfork: SpecId) -> Vec<AccountOverride> {

package/src/chains/op.rs

@@ -7,6 +7,7 @@ use edr_napi_core::{
     subscription,
 };
 use edr_op::{predeploys::GAS_PRICE_ORACLE_ADDRESS, OpChainSpec, OpSpecId};
+use edr_provider::time::CurrentTime;
 use edr_solidity::contract_decoder::ContractDecoder;
 use napi::bindgen_prelude::{BigInt, Uint8Array};
 use napi_derive::napi;
@@ -27,7 +28,8 @@ impl SyncProviderFactory for OpProviderFactory {
         subscription_config: subscription::Config,
         contract_decoder: Arc<ContractDecoder>,
     ) -> napi::Result<Box<dyn provider::Builder>> {
-        let logger = Logger::<OpChainSpec>::new(logger_config, Arc::clone(&contract_decoder))?;
+        let logger =
+            Logger::<OpChainSpec, CurrentTime>::new(logger_config, Arc::clone(&contract_decoder))?;
 
         let provider_config = edr_provider::ProviderConfig::<OpSpecId>::try_from(provider_config)?;
 

package/src/config.rs

@@ -385,10 +385,10 @@ impl ObservabilityConfig {
                                     Ok(())
                                 });
 
-                            let () = receiver.recv().expect("Receive can only fail if the channel is closed")?;
-
                             assert_eq!(status, napi::Status::Ok);
 
+                            let () = receiver.recv().expect("Receive can only fail if the channel is closed")?;
+
                             Ok(())
                         });
 

package/src/lib.rs

@@ -26,7 +26,7 @@ pub mod log;
 pub mod logger;
 /// Types for mocking provider behavior.
 #[cfg(feature = "test-mock")]
-mod mock;
+pub mod mock;
 /// Types for precompiles.
 pub mod precompile;
 /// Types for Ethereum RPC providers.

package/src/logger.rs

@@ -65,7 +65,9 @@ impl LoggerConfig {
             );
             assert_eq!(status, Status::Ok);
 
-            receiver.recv().unwrap()
+            receiver
+                .recv()
+                .expect("Receive can only fail if the channel is closed")
         });
 
         let mut print_line_callback: ThreadsafeFunction<_, ErrorStrategy::Fatal> = self

package/src/mock/time.rs

@@ -0,0 +1,142 @@
+use std::sync::Arc;
+
+use edr_eth::{spec::ChainSpec, B256};
+use edr_evm::spec::RuntimeSpec;
+use edr_generic::GenericChainSpec;
+use edr_napi_core::logger::Logger;
+use edr_rpc_eth::RpcSpec;
+use edr_solidity::contract_decoder::ContractDecoder;
+use napi::{bindgen_prelude::BigInt, tokio::runtime, Env, JsObject};
+use napi_derive::napi;
+
+use crate::{
+    cast::TryCast as _,
+    config::{ProviderConfig, TracingConfigWithBuffers},
+    logger::LoggerConfig,
+    provider::Provider,
+    subscription::SubscriptionConfig,
+};
+
+#[napi]
+pub struct MockTime {
+    inner: Arc<edr_provider::time::MockTime>,
+}
+
+#[napi]
+impl MockTime {
+    #[doc = "Creates a new instance of `MockTime` with the current time."]
+    #[napi(factory, catch_unwind)]
+    pub fn now() -> Self {
+        Self {
+            inner: Arc::new(edr_provider::time::MockTime::now()),
+        }
+    }
+
+    #[doc = "Adds the specified number of seconds to the current time."]
+    #[napi(catch_unwind)]
+    pub fn add_seconds(&self, seconds: BigInt) -> napi::Result<()> {
+        let seconds = seconds.try_cast()?;
+
+        self.inner.add_seconds(seconds);
+        Ok(())
+    }
+}
+
+#[doc = "Creates a provider with a mock timer."]
+#[doc = "For testing purposes."]
+#[napi(catch_unwind, ts_return_type = "Promise<Provider>")]
+pub fn create_provider_with_mock_timer(
+    env: Env,
+    provider_config: ProviderConfig,
+    logger_config: LoggerConfig,
+    subscription_config: SubscriptionConfig,
+    tracing_config: TracingConfigWithBuffers,
+    time: &MockTime,
+) -> napi::Result<JsObject> {
+    let (deferred, promise) = env.create_deferred()?;
+
+    macro_rules! try_or_reject_promise {
+        ($expr:expr) => {
+            match $expr {
+                Ok(value) => value,
+                Err(error) => {
+                    deferred.reject(error);
+                    return Ok(promise);
+                }
+            }
+        };
+    }
+
+    let runtime = runtime::Handle::current();
+    let provider_config = try_or_reject_promise!(provider_config.resolve(&env, runtime.clone()));
+
+    let logger_config = try_or_reject_promise!(logger_config.resolve(&env));
+
+    // TODO: https://github.com/NomicFoundation/edr/issues/760
+    let build_info_config = try_or_reject_promise!(
+        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 = try_or_reject_promise!(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 = try_or_reject_promise!(edr_napi_core::subscription::Callback::new(
+        &env,
+        subscription_config.subscription_callback,
+    ));
+
+    let logger = try_or_reject_promise!(Logger::<
+        GenericChainSpec,
+        Arc<edr_provider::time::MockTime>,
+    >::new(logger_config, Arc::clone(&contract_decoder),));
+
+    let provider_config = try_or_reject_promise!(
+        edr_provider::ProviderConfig::<edr_eth::l1::SpecId>::try_from(provider_config)
+    );
+
+    let timer = Arc::clone(&time.inner);
+
+    runtime.clone().spawn_blocking(move || {
+        let result =
+            edr_provider::Provider::<GenericChainSpec, Arc<edr_provider::time::MockTime>>::new(
+                runtime.clone(),
+                Box::new(logger),
+                Box::new(move |event| {
+                    let event = edr_napi_core::subscription::SubscriptionEvent::new::<
+                        <GenericChainSpec as RuntimeSpec>::Block,
+                        <GenericChainSpec as RpcSpec>::RpcBlock<B256>,
+                        <GenericChainSpec as ChainSpec>::SignedTransaction,
+                    >(event);
+
+                    subscription_callback.call(event);
+                }),
+                provider_config,
+                contract_decoder.clone(),
+                timer,
+            )
+            .map_or_else(
+                |error| Err(napi::Error::from_reason(error.to_string())),
+                |provider| {
+                    Ok(Provider::new(
+                        Arc::new(provider),
+                        runtime,
+                        contract_decoder,
+                        #[cfg(feature = "scenarios")]
+                        None,
+                    ))
+                },
+            );
+
+        deferred.resolve(|_env| result);
+    });
+
+    Ok(promise)
+}

package/src/mock.rs

@@ -1,3 +1,5 @@
+pub mod time;
+
 use std::sync::Arc;
 
 use edr_napi_core::provider::SyncProvider;
@@ -20,6 +22,15 @@ 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

@@ -45,6 +45,32 @@ impl Provider {
 
 #[napi]
 impl Provider {
+    #[doc = "Adds a compilation result to the instance."]
+    #[doc = ""]
+    #[doc = "For internal use only. Support for this method may be removed in the future."]
+    #[napi(catch_unwind)]
+    pub async fn add_compilation_result(
+        &self,
+        solc_version: String,
+        compiler_input: serde_json::Value,
+        compiler_output: serde_json::Value,
+    ) -> napi::Result<bool> {
+        let provider = self.provider.clone();
+
+        self.runtime
+            .spawn_blocking(move || {
+                let compiler_input = serde_json::from_value(compiler_input)
+                    .map_err(|error| napi::Error::from_reason(error.to_string()))?;
+
+                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)
+            })
+            .await
+            .map_err(|error| napi::Error::new(Status::GenericFailure, error.to_string()))?
+    }
+
     #[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

@@ -657,24 +657,55 @@ impl From<PathPermission> for foundry_cheatcodes::PathPermission {
     }
 }
 
-/// Determines the status of file system access
+/**
+ * Determines the level of file system access for the given path.
+ *
+ * Exact path matching is used for file permissions. Prefix matching is used
+ * for directory permissions.
+ *
+ * Giving write access to configuration files, source files or executables
+ * in a project is considered dangerous, because it can be used by malicious
+ * Solidity dependencies to escape the EVM sandbox. It is therefore
+ * recommended to give write access to specific safe files only. If write
+ * access to a directory is needed, please make sure that it doesn't contain
+ * configuration files, source files or executables neither in the top level
+ * directory, nor in any subdirectories.
+ */
 #[napi]
 #[derive(Debug, serde::Serialize)]
 pub enum FsAccessPermission {
-    /// FS access is allowed with `read` + `write` permission
-    ReadWrite,
-    /// Only reading is allowed
-    Read,
-    /// Only writing is allowed
-    Write,
+    /// Allows reading and writing the file
+    ReadWriteFile,
+    /// Only allows reading the file
+    ReadFile,
+    /// Only allows writing the file
+    WriteFile,
+    /// Allows reading and writing all files in the directory and its
+    /// subdirectories
+    DangerouslyReadWriteDirectory,
+    /// Allows reading all files in the directory and its subdirectories
+    ReadDirectory,
+    /// Allows writing all files in the directory and its subdirectories
+    DangerouslyWriteDirectory,
 }
 
 impl From<FsAccessPermission> for foundry_cheatcodes::FsAccessPermission {
     fn from(value: FsAccessPermission) -> Self {
         match value {
-            FsAccessPermission::ReadWrite => foundry_cheatcodes::FsAccessPermission::ReadWrite,
-            FsAccessPermission::Read => foundry_cheatcodes::FsAccessPermission::Read,
-            FsAccessPermission::Write => foundry_cheatcodes::FsAccessPermission::Write,
+            FsAccessPermission::ReadWriteFile => {
+                foundry_cheatcodes::FsAccessPermission::ReadWriteFile
+            }
+            FsAccessPermission::ReadFile => foundry_cheatcodes::FsAccessPermission::ReadFile,
+            FsAccessPermission::WriteFile => foundry_cheatcodes::FsAccessPermission::WriteFile,
+            FsAccessPermission::DangerouslyReadWriteDirectory => {
+                foundry_cheatcodes::FsAccessPermission::DangerouslyReadWriteDirectory
+            }
+            FsAccessPermission::ReadDirectory => {
+                foundry_cheatcodes::FsAccessPermission::ReadDirectory
+            }
+            FsAccessPermission::DangerouslyWriteDirectory => {
+                foundry_cheatcodes::FsAccessPermission::DangerouslyWriteDirectory
+            }
         }
     }
 }

package/src/trace/debug.rs

@@ -1,6 +1,6 @@
 //! Port of `hardhat-network/stack-traces/debug.ts` from Hardhat.
 
-use napi::bindgen_prelude::Either24;
+use napi::bindgen_prelude::Either25;
 use napi_derive::napi;
 
 use super::solidity_stack_trace::{RevertErrorStackTraceEntry, SolidityStackTrace};
@@ -11,31 +11,32 @@ fn print_stack_trace(trace: SolidityStackTrace) -> napi::Result<()> {
     let entry_values = trace
         .into_iter()
         .map(|entry| match entry {
-            Either24::A(entry) => serde_json::to_value(entry),
-            Either24::B(entry) => serde_json::to_value(entry),
-            Either24::C(entry) => serde_json::to_value(entry),
-            Either24::D(entry) => serde_json::to_value(entry),
-            Either24::F(entry) => serde_json::to_value(entry),
-            Either24::G(entry) => serde_json::to_value(entry),
-            Either24::H(entry) => serde_json::to_value(entry),
-            Either24::I(entry) => serde_json::to_value(entry),
-            Either24::J(entry) => serde_json::to_value(entry),
-            Either24::K(entry) => serde_json::to_value(entry),
-            Either24::L(entry) => serde_json::to_value(entry),
-            Either24::M(entry) => serde_json::to_value(entry),
-            Either24::N(entry) => serde_json::to_value(entry),
-            Either24::O(entry) => serde_json::to_value(entry),
-            Either24::P(entry) => serde_json::to_value(entry),
-            Either24::Q(entry) => serde_json::to_value(entry),
-            Either24::R(entry) => serde_json::to_value(entry),
-            Either24::S(entry) => serde_json::to_value(entry),
-            Either24::T(entry) => serde_json::to_value(entry),
-            Either24::U(entry) => serde_json::to_value(entry),
-            Either24::V(entry) => serde_json::to_value(entry),
-            Either24::W(entry) => serde_json::to_value(entry),
-            Either24::X(entry) => serde_json::to_value(entry),
+            Either25::A(entry) => serde_json::to_value(entry),
+            Either25::B(entry) => serde_json::to_value(entry),
+            Either25::C(entry) => serde_json::to_value(entry),
+            Either25::D(entry) => serde_json::to_value(entry),
+            Either25::F(entry) => serde_json::to_value(entry),
+            Either25::G(entry) => serde_json::to_value(entry),
+            Either25::H(entry) => serde_json::to_value(entry),
+            Either25::I(entry) => serde_json::to_value(entry),
+            Either25::J(entry) => serde_json::to_value(entry),
+            Either25::K(entry) => serde_json::to_value(entry),
+            Either25::L(entry) => serde_json::to_value(entry),
+            Either25::M(entry) => serde_json::to_value(entry),
+            Either25::N(entry) => serde_json::to_value(entry),
+            Either25::O(entry) => serde_json::to_value(entry),
+            Either25::P(entry) => serde_json::to_value(entry),
+            Either25::Q(entry) => serde_json::to_value(entry),
+            Either25::R(entry) => serde_json::to_value(entry),
+            Either25::S(entry) => serde_json::to_value(entry),
+            Either25::T(entry) => serde_json::to_value(entry),
+            Either25::U(entry) => serde_json::to_value(entry),
+            Either25::V(entry) => serde_json::to_value(entry),
+            Either25::W(entry) => serde_json::to_value(entry),
+            Either25::X(entry) => serde_json::to_value(entry),
+            Either25::Y(entry) => serde_json::to_value(entry),
             // Decode the error message from the return data
-            Either24::E(entry @ RevertErrorStackTraceEntry { .. }) => {
+            Either25::E(entry @ RevertErrorStackTraceEntry { .. }) => {
                 use serde::de::Error;
 
                 let decoded_error_msg = ReturnData::new(entry.return_data.clone())

package/src/trace/solidity_stack_trace.rs

@@ -4,7 +4,7 @@
 use std::convert::Infallible;
 
 use edr_eth::{hex, U256};
-use napi::bindgen_prelude::{BigInt, Either24, FromNapiValue, ToNapiValue, Uint8Array, Undefined};
+use napi::bindgen_prelude::{BigInt, Either25, FromNapiValue, ToNapiValue, Uint8Array, Undefined};
 use napi_derive::napi;
 use serde::{Serialize, Serializer};
 
@@ -45,6 +45,7 @@ pub enum StackTraceEntryType {
     CONTRACT_TOO_LARGE_ERROR,
     INTERNAL_FUNCTION_CALLSTACK_ENTRY,
     CONTRACT_CALL_RUN_OUT_OF_GAS_ERROR,
+    CHEATCODE_ERROR,
 }
 
 #[napi(catch_unwind)]
@@ -155,7 +156,7 @@ pub struct CallstackEntryStackTraceEntry {
 
 impl From<CallstackEntryStackTraceEntry> for SolidityStackTraceEntry {
     fn from(val: CallstackEntryStackTraceEntry) -> Self {
-        Either24::A(val)
+        Either25::A(val)
     }
 }
 
@@ -174,7 +175,7 @@ pub struct UnrecognizedCreateCallstackEntryStackTraceEntry {
 
 impl From<UnrecognizedCreateCallstackEntryStackTraceEntry> for SolidityStackTraceEntry {
     fn from(val: UnrecognizedCreateCallstackEntryStackTraceEntry) -> Self {
-        Either24::B(val)
+        Either25::B(val)
     }
 }
 
@@ -195,7 +196,7 @@ pub struct UnrecognizedContractCallstackEntryStackTraceEntry {
 
 impl From<UnrecognizedContractCallstackEntryStackTraceEntry> for SolidityStackTraceEntry {
     fn from(val: UnrecognizedContractCallstackEntryStackTraceEntry) -> Self {
-        Either24::C(val)
+        Either25::C(val)
     }
 }
 
@@ -210,7 +211,7 @@ pub struct PrecompileErrorStackTraceEntry {
 
 impl From<PrecompileErrorStackTraceEntry> for SolidityStackTraceEntry {
     fn from(val: PrecompileErrorStackTraceEntry) -> Self {
-        Either24::D(val)
+        Either25::D(val)
     }
 }
 
@@ -227,7 +228,7 @@ pub struct RevertErrorStackTraceEntry {
 
 impl From<RevertErrorStackTraceEntry> for SolidityStackTraceEntry {
     fn from(val: RevertErrorStackTraceEntry) -> Self {
-        Either24::E(val)
+        Either25::E(val)
     }
 }
 
@@ -243,7 +244,7 @@ pub struct PanicErrorStackTraceEntry {
 
 impl From<PanicErrorStackTraceEntry> for SolidityStackTraceEntry {
     fn from(val: PanicErrorStackTraceEntry) -> Self {
-        Either24::F(val)
+        Either25::F(val)
     }
 }
 
@@ -259,7 +260,7 @@ pub struct CustomErrorStackTraceEntry {
 
 impl From<CustomErrorStackTraceEntry> for SolidityStackTraceEntry {
     fn from(val: CustomErrorStackTraceEntry) -> Self {
-        Either24::G(val)
+        Either25::G(val)
     }
 }
 
@@ -278,7 +279,7 @@ pub struct FunctionNotPayableErrorStackTraceEntry {
 
 impl From<FunctionNotPayableErrorStackTraceEntry> for SolidityStackTraceEntry {
     fn from(val: FunctionNotPayableErrorStackTraceEntry) -> Self {
-        Either24::H(val)
+        Either25::H(val)
     }
 }
 
@@ -292,7 +293,7 @@ pub struct InvalidParamsErrorStackTraceEntry {
 
 impl From<InvalidParamsErrorStackTraceEntry> for SolidityStackTraceEntry {
     fn from(val: InvalidParamsErrorStackTraceEntry) -> Self {
-        Either24::I(val)
+        Either25::I(val)
     }
 }
 
@@ -311,7 +312,7 @@ pub struct FallbackNotPayableErrorStackTraceEntry {
 
 impl From<FallbackNotPayableErrorStackTraceEntry> for SolidityStackTraceEntry {
     fn from(val: FallbackNotPayableErrorStackTraceEntry) -> Self {
-        Either24::J(val)
+        Either25::J(val)
     }
 }
 
@@ -332,7 +333,7 @@ pub struct FallbackNotPayableAndNoReceiveErrorStackTraceEntry {
 
 impl From<FallbackNotPayableAndNoReceiveErrorStackTraceEntry> for SolidityStackTraceEntry {
     fn from(val: FallbackNotPayableAndNoReceiveErrorStackTraceEntry) -> Self {
-        Either24::K(val)
+        Either25::K(val)
     }
 }
 
@@ -351,7 +352,7 @@ pub struct UnrecognizedFunctionWithoutFallbackErrorStackTraceEntry {
 
 impl From<UnrecognizedFunctionWithoutFallbackErrorStackTraceEntry> for SolidityStackTraceEntry {
     fn from(val: UnrecognizedFunctionWithoutFallbackErrorStackTraceEntry) -> Self {
-        Either24::L(val)
+        Either25::L(val)
     }
 }
 
@@ -369,7 +370,7 @@ pub struct MissingFallbackOrReceiveErrorStackTraceEntry {
 
 impl From<MissingFallbackOrReceiveErrorStackTraceEntry> for SolidityStackTraceEntry {
     fn from(val: MissingFallbackOrReceiveErrorStackTraceEntry) -> Self {
-        Either24::M(val)
+        Either25::M(val)
     }
 }
 
@@ -386,7 +387,7 @@ pub struct ReturndataSizeErrorStackTraceEntry {
 
 impl From<ReturndataSizeErrorStackTraceEntry> for SolidityStackTraceEntry {
     fn from(val: ReturndataSizeErrorStackTraceEntry) -> Self {
-        Either24::N(val)
+        Either25::N(val)
     }
 }
 
@@ -404,7 +405,7 @@ pub struct NonContractAccountCalledErrorStackTraceEntry {
 
 impl From<NonContractAccountCalledErrorStackTraceEntry> for SolidityStackTraceEntry {
     fn from(val: NonContractAccountCalledErrorStackTraceEntry) -> Self {
-        Either24::O(val)
+        Either25::O(val)
     }
 }
 
@@ -418,7 +419,7 @@ pub struct CallFailedErrorStackTraceEntry {
 
 impl From<CallFailedErrorStackTraceEntry> for SolidityStackTraceEntry {
     fn from(val: CallFailedErrorStackTraceEntry) -> Self {
-        Either24::P(val)
+        Either25::P(val)
     }
 }
 
@@ -435,7 +436,7 @@ pub struct DirectLibraryCallErrorStackTraceEntry {
 
 impl From<DirectLibraryCallErrorStackTraceEntry> for SolidityStackTraceEntry {
     fn from(val: DirectLibraryCallErrorStackTraceEntry) -> Self {
-        Either24::Q(val)
+        Either25::Q(val)
     }
 }
 
@@ -455,7 +456,7 @@ pub struct UnrecognizedCreateErrorStackTraceEntry {
 
 impl From<UnrecognizedCreateErrorStackTraceEntry> for SolidityStackTraceEntry {
     fn from(val: UnrecognizedCreateErrorStackTraceEntry) -> Self {
-        Either24::R(val)
+        Either25::R(val)
     }
 }
 
@@ -477,7 +478,7 @@ pub struct UnrecognizedContractErrorStackTraceEntry {
 
 impl From<UnrecognizedContractErrorStackTraceEntry> for SolidityStackTraceEntry {
     fn from(val: UnrecognizedContractErrorStackTraceEntry) -> Self {
-        Either24::S(val)
+        Either25::S(val)
     }
 }
 
@@ -494,7 +495,7 @@ pub struct OtherExecutionErrorStackTraceEntry {
 
 impl From<OtherExecutionErrorStackTraceEntry> for SolidityStackTraceEntry {
     fn from(val: OtherExecutionErrorStackTraceEntry) -> Self {
-        Either24::T(val)
+        Either25::T(val)
     }
 }
 
@@ -512,7 +513,7 @@ pub struct UnmappedSolc063RevertErrorStackTraceEntry {
 
 impl From<UnmappedSolc063RevertErrorStackTraceEntry> for SolidityStackTraceEntry {
     fn from(val: UnmappedSolc063RevertErrorStackTraceEntry) -> Self {
-        Either24::U(val)
+        Either25::U(val)
     }
 }
 
@@ -529,7 +530,7 @@ pub struct ContractTooLargeErrorStackTraceEntry {
 
 impl From<ContractTooLargeErrorStackTraceEntry> for SolidityStackTraceEntry {
     fn from(val: ContractTooLargeErrorStackTraceEntry) -> Self {
-        Either24::V(val)
+        Either25::V(val)
     }
 }
 
@@ -548,7 +549,7 @@ pub struct InternalFunctionCallStackEntry {
 
 impl From<InternalFunctionCallStackEntry> for SolidityStackTraceEntry {
     fn from(val: InternalFunctionCallStackEntry) -> Self {
-        Either24::W(val)
+        Either25::W(val)
     }
 }
 
@@ -566,7 +567,23 @@ pub struct ContractCallRunOutOfGasError {
 
 impl From<ContractCallRunOutOfGasError> for SolidityStackTraceEntry {
     fn from(val: ContractCallRunOutOfGasError) -> Self {
-        Either24::X(val)
+        Either25::X(val)
+    }
+}
+
+#[napi(object)]
+#[derive(Clone, Serialize)]
+pub struct CheatcodeErrorStackTraceEntry {
+    #[napi(js_name = "type", ts_type = "StackTraceEntryType.CHEATCODE_ERROR")]
+    pub type_: StackTraceEntryTypeConst<{ StackTraceEntryType::CHEATCODE_ERROR as u8 }>,
+    // The parsed cheatcode error message that can be displayed to the user
+    pub message: String,
+    pub source_reference: SourceReference,
+}
+
+impl From<CheatcodeErrorStackTraceEntry> for SolidityStackTraceEntry {
+    fn from(val: CheatcodeErrorStackTraceEntry) -> Self {
+        Either25::Y(val)
     }
 }
 
@@ -580,7 +597,7 @@ impl From<ContractCallRunOutOfGasError> for SolidityStackTraceEntry {
 // Rather, we just bite the bullet for now and use the type alias directly
 // (which falls back to `any` as it's not recognized in the context of the
 // index.d.ts file) until we finish the porting work.
-pub type SolidityStackTraceEntry = Either24<
+pub type SolidityStackTraceEntry = Either25<
     CallstackEntryStackTraceEntry,
     UnrecognizedCreateCallstackEntryStackTraceEntry,
     UnrecognizedContractCallstackEntryStackTraceEntry,
@@ -605,6 +622,7 @@ pub type SolidityStackTraceEntry = Either24<
     ContractTooLargeErrorStackTraceEntry,
     InternalFunctionCallStackEntry,
     ContractCallRunOutOfGasError,
+    CheatcodeErrorStackTraceEntry,
 >;
 
 impl TryCast<SolidityStackTraceEntry> for edr_solidity::solidity_stack_trace::StackTraceEntry {
@@ -663,6 +681,15 @@ impl TryCast<SolidityStackTraceEntry> for edr_solidity::solidity_stack_trace::St
                 source_reference: source_reference.map(std::convert::Into::into),
             }
             .into(),
+            StackTraceEntry::CheatCodeError {
+                message,
+                source_reference,
+            } => CheatcodeErrorStackTraceEntry {
+                type_: StackTraceEntryTypeConst,
+                message,
+                source_reference: source_reference.into(),
+            }
+            .into(),
             StackTraceEntry::CustomError {
                 message,
                 source_reference,