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

package/index.d.ts

@@ -198,6 +198,16 @@ export interface CodeCoverageConfig {
    */
   onCollectedCoverageCallback: (coverageHits: Uint8Array[]) => Promise<void>
 }
+export interface GasReportConfig {
+  /**
+   * Gas reports are collected after a block is mined or `eth_call` is
+   * executed.
+   *
+   * Exceptions thrown in the callback will be propagated to the original
+   * caller.
+   */
+  onCollectedGasReportCallback: (gasReport: GasReport) => Promise<void>
+}
 /** Configuration for forking a blockchain */
 export interface ForkConfig {
   /**
@@ -258,6 +268,8 @@ export interface MiningConfig {
 export interface ObservabilityConfig {
   /** If present, configures runtime observability to collect code coverage. */
   codeCoverage?: CodeCoverageConfig
+  /** If present, configures runtime observability to collect gas reports. */
+  gasReport?: GasReportConfig
 }
 /** Configuration for a provider */
 export interface ProviderConfig {
@@ -372,6 +384,27 @@ export interface DebugTraceLogItem {
   /** Map of all stored values with keys and values encoded as hex strings. */
   storage?: Record<string, string>
 }
+export interface GasReport {
+  contracts: Record<string, ContractGasReport>
+}
+export interface ContractGasReport {
+  deployments: Array<DeploymentGasReport>
+  functions: Record<string, Array<FunctionGasReport>>
+}
+export enum GasReportExecutionStatus {
+  Success = 0,
+  Revert = 1,
+  Halt = 2
+}
+export interface DeploymentGasReport {
+  gas: bigint
+  size: bigint
+  status: GasReportExecutionStatus
+}
+export interface FunctionGasReport {
+  gas: bigint
+  status: GasReportExecutionStatus
+}
 export interface InstrumentationResult {
   /** The generated source code with coverage instrumentation. */
   readonly source: string
@@ -703,6 +736,13 @@ export interface SolidityTestRunnerConfigArgs {
    * match the pattern will be executed and reported as a test result.
    */
   testPattern?: string
+  /**
+   * Controls whether to generate a gas report after running the tests.
+   * Enabling this also enables collection of all traces and EVM isolation
+   * mode.
+   * Defaults to false.
+   */
+  generateGasReport?: boolean
 }
 /** Fuzz testing configuration */
 export interface FuzzConfigArgs {
@@ -1103,6 +1143,11 @@ export interface DecodedTraceParameters {
    */
   arguments: Array<string>
 }
+/** The result of a Solidity test run. */
+export interface SolidityTestResult {
+  /** Gas report, if it was generated. */
+  readonly gasReport?: GasReport
+}
 /** Configuration for subscriptions. */
 export interface SubscriptionConfig {
   /** Callback to be called when a new event is received. */
@@ -1363,22 +1408,37 @@ export interface Withdrawal {
   amount: bigint
 }
 export declare class EdrContext {
-  /**Creates a new [`EdrContext`] instance. Should only be called once! */
+  /** Creates a new [`EdrContext`] instance. Should only be called once! */
   constructor()
-  /**Constructs a new provider with the provided configuration. */
+  /** Constructs a new provider with the provided configuration. */
   createProvider(chainType: string, providerConfig: ProviderConfig, loggerConfig: LoggerConfig, subscriptionConfig: SubscriptionConfig, contractDecoder: ContractDecoder): Promise<Provider>
-  /**Registers a new provider factory for the provided chain type. */
+  /** Registers a new provider factory for the provided chain type. */
   registerProviderFactory(chainType: string, factory: ProviderFactory): Promise<void>
   registerSolidityTestRunnerFactory(chainType: string, factory: SolidityTestRunnerFactory): Promise<void>
   /**
-   *Executes Solidity tests.
+   * Executes Solidity tests
    *
-   *The function will return as soon as test execution is started.
-   *The progress callback will be called with the results of each test
-   *suite. It is up to the caller to track how many times the callback
-   *is called to know when all tests are done.
-   */
-  runSolidityTests(chainType: string, artifacts: Array<Artifact>, testSuites: Array<ArtifactId>, configArgs: SolidityTestRunnerConfigArgs, tracingConfig: TracingConfigWithBuffers, onTestSuiteCompletedCallback: (result: SuiteResult) => void): Promise<void>
+   * The function will return a promise that resolves to a
+   * [`SolidityTestResult`].
+   *
+   * Arguments:
+   * - `chainType`: the same chain type that was passed to
+   *   `registerProviderFactory`.
+   * - `artifacts`: the project's compilation output artifacts. It's
+   *   important to include include all artifacts here, otherwise cheatcodes
+   *   that access artifacts and other functionality (e.g. auto-linking, gas
+   *   reports) can break.
+   * - `testSuites`: the test suite ids that specify which test suites to
+   *   execute. The test suite artifacts must be present in `artifacts`.
+   * - `configArgs`: solidity test runner configuration. See the struct docs
+   *   for details.
+   * - `tracingConfig`: the build infos used for stack trace generation.
+   *   These are lazily parsed and it's important that they're passed as
+   *   Uint8 arrays for performance.
+   * - `onTestSuiteCompletedCallback`: The progress callback will be called
+   *   with the results of each test suite as soon as it finished executing.
+   */
+  runSolidityTests(chainType: string, artifacts: Array<Artifact>, testSuites: Array<ArtifactId>, configArgs: SolidityTestRunnerConfigArgs, tracingConfig: TracingConfigWithBuffers, onTestSuiteCompletedCallback: (result: SuiteResult) => void): Promise<SolidityTestResult>
 }
 export declare class ContractDecoder {
   /**Creates an empty instance. */

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, 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
+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, GasReportExecutionStatus, 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
@@ -358,6 +358,7 @@ module.exports.ISTHMUS = ISTHMUS
 module.exports.MineOrdering = MineOrdering
 module.exports.EdrContext = EdrContext
 module.exports.ContractDecoder = ContractDecoder
+module.exports.GasReportExecutionStatus = GasReportExecutionStatus
 module.exports.addStatementCoverageInstrumentation = addStatementCoverageInstrumentation
 module.exports.Precompile = Precompile
 module.exports.precompileP256Verify = precompileP256Verify

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nomicfoundation/edr",
-  "version": "0.12.0-next.7",
+  "version": "0.12.0-next.8",
   "devDependencies": {
     "@napi-rs/cli": "^2.18.4",
     "@nomicfoundation/ethereumjs-util": "^9.0.4",
@@ -58,15 +58,6 @@
   },
   "repository": "NomicFoundation/edr.git",
   "types": "index.d.ts",
-  "optionalDependencies": {
-    "@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",
     "build": "pnpm run build:publish",

package/src/account.rs

@@ -1,6 +1,7 @@
 use derive_more::Debug;
-use edr_eth::{hex, HashMap, U256};
+use edr_primitives::{hex, Address, HashMap, U256};
 use edr_solidity_tests::{backend::Predeploy, revm::state::AccountInfo};
+use edr_state_api::EvmStorageSlot;
 use napi::bindgen_prelude::{BigInt, Uint8Array};
 use napi_derive::napi;
 
@@ -36,7 +37,7 @@ pub struct AccountOverride {
     pub storage: Option<Vec<StorageSlot>>,
 }
 
-impl TryFrom<AccountOverride> for (edr_eth::Address, edr_provider::AccountOverride) {
+impl TryFrom<AccountOverride> for (Address, edr_provider::AccountOverride) {
     type Error = napi::Error;
 
     fn try_from(value: AccountOverride) -> Result<Self, Self::Error> {
@@ -53,9 +54,9 @@ impl TryFrom<AccountOverride> for (edr_eth::Address, edr_provider::AccountOverri
                     .into_iter()
                     .map(|StorageSlot { index, value }| {
                         let value = value.try_cast()?;
-                        let slot = edr_evm::state::EvmStorageSlot::new(value, 0);
+                        let slot = EvmStorageSlot::new(value, 0);
 
-                        let index: edr_eth::U256 = index.try_cast()?;
+                        let index: U256 = index.try_cast()?;
                         Ok((index, slot))
                     })
                     .collect::<napi::Result<_>>()
@@ -69,7 +70,7 @@ impl TryFrom<AccountOverride> for (edr_eth::Address, edr_provider::AccountOverri
             storage,
         };
 
-        let address: edr_eth::Address = address.try_cast()?;
+        let address: Address = address.try_cast()?;
 
         Ok((address, account_override))
     }

package/src/block.rs

@@ -16,7 +16,7 @@ pub struct BlobGas {
     pub excess_gas: BigInt,
 }
 
-impl TryFrom<BlobGas> for edr_eth::block::BlobGas {
+impl TryFrom<BlobGas> for edr_block_header::BlobGas {
     type Error = napi::Error;
 
     fn try_from(value: BlobGas) -> Result<Self, Self::Error> {

package/src/call_override.rs

@@ -1,6 +1,6 @@
 use std::sync::mpsc::channel;
 
-use edr_eth::{Address, Bytes};
+use edr_primitives::{Address, Bytes};
 use napi::{
     bindgen_prelude::{Promise, Uint8Array},
     threadsafe_function::{

package/src/cast.rs

@@ -1,4 +1,4 @@
-use edr_eth::{Address, Bytecode, Bytes, B256, B64, U256};
+use edr_primitives::{Address, Bytecode, Bytes, B256, B64, U256};
 use napi::{
     bindgen_prelude::{BigInt, Uint8Array},
     Status,

package/src/chains/op.rs

@@ -1,12 +1,18 @@
 use std::{str::FromStr, sync::Arc};
 
-use edr_eth::hex;
 use edr_napi_core::{
     logger::Logger,
     provider::{SyncProvider, SyncProviderFactory},
     subscription::subscriber_callback_for_chain_spec,
 };
-use edr_op::{predeploys::GAS_PRICE_ORACLE_ADDRESS, OpChainSpec};
+use edr_op::{
+    predeploys::{
+        gas_price_oracle_code_ecotone, gas_price_oracle_code_fjord, gas_price_oracle_code_isthmus,
+        GAS_PRICE_ORACLE_ADDRESS,
+    },
+    OpChainSpec,
+};
+use edr_primitives::hex;
 use edr_provider::time::CurrentTime;
 use edr_solidity::contract_decoder::ContractDecoder;
 use napi::{
@@ -347,16 +353,11 @@ fn gas_price_oracle_override(hardfork: edr_op::Hardfork) -> AccountOverride {
 }
 
 fn gas_price_oracle_ecotone() -> AccountOverride {
-    let gas_price_oracle_code = hex::decode(include_str!(
-        "../../data/op/predeploys/gas_price_oracle/ecotone.txt"
-    ))
-    .expect("The bytecode for the GasPriceOracle predeploy should be a valid hex string");
-
     AccountOverride {
         address: Uint8Array::with_data_copied(GAS_PRICE_ORACLE_ADDRESS),
         balance: None,
         nonce: None,
-        code: Some(gas_price_oracle_code.into()),
+        code: Some(gas_price_oracle_code_ecotone().into()),
         storage: Some(vec![StorageSlot {
             index: BigInt::from(0u64),
             // bool isEcotone = true
@@ -368,16 +369,11 @@ fn gas_price_oracle_ecotone() -> AccountOverride {
 }
 
 fn gas_price_oracle_fjord() -> AccountOverride {
-    let gas_price_oracle_code = hex::decode(include_str!(
-        "../../data/op/predeploys/gas_price_oracle/fjord.txt"
-    ))
-    .expect("The bytecode for the GasPriceOracle predeploy should be a valid hex string");
-
     AccountOverride {
         address: Uint8Array::with_data_copied(GAS_PRICE_ORACLE_ADDRESS),
         balance: None,
         nonce: None,
-        code: Some(gas_price_oracle_code.into()),
+        code: Some(gas_price_oracle_code_fjord().into()),
         storage: Some(vec![StorageSlot {
             index: BigInt::from(0u64),
             // bool isEcotone = true
@@ -390,16 +386,11 @@ fn gas_price_oracle_fjord() -> AccountOverride {
 }
 
 fn gas_price_oracle_isthmus() -> AccountOverride {
-    let gas_price_oracle_code = hex::decode(include_str!(
-        "../../data/op/predeploys/gas_price_oracle/isthmus.txt"
-    ))
-    .expect("The bytecode for the GasPriceOracle predeploy should be a valid hex string");
-
     AccountOverride {
         address: Uint8Array::with_data_copied(GAS_PRICE_ORACLE_ADDRESS),
         balance: None,
         nonce: None,
-        code: Some(gas_price_oracle_code.into()),
+        code: Some(gas_price_oracle_code_isthmus().into()),
         storage: Some(vec![StorageSlot {
             index: BigInt::from(0u64),
             // bool isEcotone = true

package/src/config.rs

@@ -7,7 +7,8 @@ use std::{
 
 use edr_coverage::reporter::SyncOnCollectedCoverageCallback;
 use edr_eip1559::{BaseFeeActivation, ConstantBaseFeeParams};
-use edr_eth::{Bytes, HashMap, HashSet};
+use edr_gas_report::SyncOnCollectedGasReportCallback;
+use edr_primitives::{Bytes, HashMap, HashSet};
 use edr_signer::{secret_key_from_str, SecretKey};
 use napi::{
     bindgen_prelude::{BigInt, Promise, Reference, Uint8Array},
@@ -20,8 +21,8 @@ use napi::{
 use napi_derive::napi;
 
 use crate::{
-    account::AccountOverride, block::BlobGas, cast::TryCast, logger::LoggerConfig,
-    precompile::Precompile, subscription::SubscriptionConfig,
+    account::AccountOverride, block::BlobGas, cast::TryCast, gas_report::GasReport,
+    logger::LoggerConfig, precompile::Precompile, subscription::SubscriptionConfig,
 };
 
 /// Configuration for EIP-1559 parameters
@@ -92,6 +93,17 @@ pub struct CodeCoverageConfig {
     pub on_collected_coverage_callback: JsFunction,
 }
 
+#[napi(object)]
+pub struct GasReportConfig {
+    /// Gas reports are collected after a block is mined or `eth_call` is
+    /// executed.
+    ///
+    /// Exceptions thrown in the callback will be propagated to the original
+    /// caller.
+    #[napi(ts_type = "(gasReport: GasReport) => Promise<void>")]
+    pub on_collected_gas_report_callback: JsFunction,
+}
+
 /// Configuration for forking a blockchain
 #[napi(object)]
 pub struct ForkConfig {
@@ -169,6 +181,8 @@ pub struct MiningConfig {
 pub struct ObservabilityConfig {
     /// If present, configures runtime observability to collect code coverage.
     pub code_coverage: Option<CodeCoverageConfig>,
+    /// If present, configures runtime observability to collect gas reports.
+    pub gas_report: Option<GasReportConfig>,
 }
 
 /// Configuration for a provider
@@ -385,6 +399,8 @@ impl ObservabilityConfig {
             .code_coverage
             .map(
                 |code_coverage| -> napi::Result<Box<dyn SyncOnCollectedCoverageCallback>> {
+                    let runtime = runtime.clone();
+
                     let mut on_collected_coverage_callback: ThreadsafeFunction<
                         _,
                         ErrorStrategy::Fatal,
@@ -450,9 +466,61 @@ impl ObservabilityConfig {
                 },
             )
             .transpose()?;
+        let on_collected_gas_report_fn = self.gas_report.map(
+            |gas_report| -> napi::Result<Box<dyn SyncOnCollectedGasReportCallback>> {
+                let mut on_collected_gas_report_callback: ThreadsafeFunction<
+                    _,
+                    ErrorStrategy::Fatal,
+                > = gas_report
+                    .on_collected_gas_report_callback
+                    .create_threadsafe_function(
+                        0,
+                        |ctx: ThreadSafeCallContext<GasReport>| {
+                            let report = ctx.value;
+                            Ok(vec![report])
+                        }
+                        ,
+                    )?;
+                // Maintain a weak reference to the function to avoid blocking the event loop
+                // from exiting.
+                on_collected_gas_report_callback.unref(env)?;
+
+                let on_collected_gas_report_fn: Box<dyn SyncOnCollectedGasReportCallback> =
+                    Box::new(move |report| {
+                        let runtime = runtime.clone();
+
+                        let (sender, receiver) = std::sync::mpsc::channel();
+
+                        // Convert the report to the N-API representation
+                        let status = on_collected_gas_report_callback
+                            .call_with_return_value(GasReport::from(report), ThreadsafeFunctionCallMode::Blocking, move |result: Promise<()>| {
+                                // We spawn a background task to handle the async callback
+                                runtime.spawn(async move {
+                                    let result = result.await;
+                                    sender.send(result).map_err(|_error| {
+                                        napi::Error::new(
+                                            napi::Status::GenericFailure,
+                                            "Failed to send result from on_collected_gas_report_callback",
+                                        )
+                                    })
+                                });
+                                Ok(())
+                            });
+
+                        assert_eq!(status, napi::Status::Ok);
+
+                        let () = receiver.recv().expect("Receive can only fail if the channel is closed")?;
+
+                        Ok(())
+                    });
+
+                Ok(on_collected_gas_report_fn)
+            },
+        ).transpose()?;
 
         Ok(edr_provider::observability::Config {
             on_collected_coverage_fn,
+            on_collected_gas_report_fn,
             ..edr_provider::observability::Config::default()
         })
     }
@@ -509,7 +577,7 @@ impl ProviderConfig {
             .genesis_state
             .into_iter()
             .map(TryInto::try_into)
-            .collect::<napi::Result<HashMap<edr_eth::Address, edr_provider::AccountOverride>>>()?;
+            .collect::<napi::Result<HashMap<edr_primitives::Address, edr_provider::AccountOverride>>>()?;
 
         let precompile_overrides = self
             .precompile_overrides

package/src/context.rs

@@ -1,7 +1,7 @@
 use std::sync::Arc;
 
-use edr_eth::HashMap;
 use edr_napi_core::{provider::SyncProviderFactory, solidity};
+use edr_primitives::HashMap;
 use edr_solidity_tests::{
     decode::RevertDecoder,
     multi_runner::{SuiteResultAndArtifactId, TestContract, TestContracts},
@@ -26,7 +26,7 @@ use crate::{
         artifact::{Artifact, ArtifactId},
         config::SolidityTestRunnerConfigArgs,
         factory::SolidityTestRunnerFactory,
-        test_results::SuiteResult,
+        test_results::{SolidityTestResult, SuiteResult},
         LinkingOutput,
     },
     subscription::SubscriptionConfig,
@@ -39,7 +39,7 @@ pub struct EdrContext {
 
 #[napi]
 impl EdrContext {
-    #[doc = "Creates a new [`EdrContext`] instance. Should only be called once!"]
+    /// Creates a new [`EdrContext`] instance. Should only be called once!
     #[napi(catch_unwind, constructor)]
     pub fn new() -> napi::Result<Self> {
         let context = Context::new()?;
@@ -49,7 +49,7 @@ impl EdrContext {
         })
     }
 
-    #[doc = "Constructs a new provider with the provided configuration."]
+    /// Constructs a new provider with the provided configuration.
     #[napi(catch_unwind, ts_return_type = "Promise<Provider>")]
     pub fn create_provider(
         &self,
@@ -130,7 +130,7 @@ impl EdrContext {
         Ok(promise)
     }
 
-    #[doc = "Registers a new provider factory for the provided chain type."]
+    /// Registers a new provider factory for the provided chain type.
     #[napi(catch_unwind)]
     pub async fn register_provider_factory(
         &self,
@@ -153,14 +153,29 @@ impl EdrContext {
         Ok(())
     }
 
-    #[doc = "Executes Solidity tests."]
-    #[doc = ""]
-    #[doc = "The function will return as soon as test execution is started."]
-    #[doc = "The progress callback will be called with the results of each test"]
-    #[doc = "suite. It is up to the caller to track how many times the callback"]
-    #[doc = "is called to know when all tests are done."]
+    /// Executes Solidity tests
+    ///
+    /// The function will return a promise that resolves to a
+    /// [`SolidityTestResult`].
+    ///
+    /// Arguments:
+    /// - `chainType`: the same chain type that was passed to
+    ///   `registerProviderFactory`.
+    /// - `artifacts`: the project's compilation output artifacts. It's
+    ///   important to include include all artifacts here, otherwise cheatcodes
+    ///   that access artifacts and other functionality (e.g. auto-linking, gas
+    ///   reports) can break.
+    /// - `testSuites`: the test suite ids that specify which test suites to
+    ///   execute. The test suite artifacts must be present in `artifacts`.
+    /// - `configArgs`: solidity test runner configuration. See the struct docs
+    ///   for details.
+    /// - `tracingConfig`: the build infos used for stack trace generation.
+    ///   These are lazily parsed and it's important that they're passed as
+    ///   Uint8 arrays for performance.
+    /// - `onTestSuiteCompletedCallback`: The progress callback will be called
+    ///   with the results of each test suite as soon as it finished executing.
     #[allow(clippy::too_many_arguments)]
-    #[napi(catch_unwind, ts_return_type = "Promise<void>")]
+    #[napi(catch_unwind, ts_return_type = "Promise<SolidityTestResult>")]
     pub fn run_solidity_tests(
         &self,
         env: Env,
@@ -291,7 +306,7 @@ impl EdrContext {
                 .expect("Failed to join test runner factory thread"));
 
             let runtime_for_runner = runtime.clone();
-            let () = try_or_reject_deferred!(runtime
+            let test_result = try_or_reject_deferred!(runtime
                 .clone()
                 .spawn_blocking(move || {
                     test_runner.run_tests(
@@ -323,7 +338,7 @@ impl EdrContext {
                 .await
                 .expect("Failed to join test runner thread"));
 
-            deferred.resolve(move |_env| Ok(()));
+            deferred.resolve(move |_env| Ok(SolidityTestResult::from(test_result)));
         });
 
         Ok(promise)

package/src/gas_report.rs

@@ -0,0 +1,92 @@
+use std::collections::HashMap;
+
+use napi::bindgen_prelude::BigInt;
+use napi_derive::napi;
+
+#[napi(object)]
+pub struct GasReport {
+    pub contracts: HashMap<String, ContractGasReport>,
+}
+
+#[napi(object)]
+pub struct ContractGasReport {
+    pub deployments: Vec<DeploymentGasReport>,
+    pub functions: HashMap<String, Vec<FunctionGasReport>>,
+}
+
+#[napi]
+pub enum GasReportExecutionStatus {
+    Success,
+    Revert,
+    Halt,
+}
+
+#[napi(object)]
+pub struct DeploymentGasReport {
+    pub gas: BigInt,
+    pub size: BigInt,
+    pub status: GasReportExecutionStatus,
+}
+
+#[napi(object)]
+pub struct FunctionGasReport {
+    pub gas: BigInt,
+    pub status: GasReportExecutionStatus,
+}
+
+impl From<edr_gas_report::GasReport> for GasReport {
+    fn from(value: edr_gas_report::GasReport) -> Self {
+        Self {
+            contracts: value
+                .into_inner()
+                .into_iter()
+                .map(|(k, v)| (k, v.into()))
+                .collect(),
+        }
+    }
+}
+
+impl From<edr_gas_report::ContractGasReport> for ContractGasReport {
+    fn from(value: edr_gas_report::ContractGasReport) -> Self {
+        Self {
+            deployments: value.deployments.into_iter().map(Into::into).collect(),
+            functions: value
+                .functions
+                .into_iter()
+                .map(|(k, v)| {
+                    let function_reports = v.into_iter().map(FunctionGasReport::from).collect();
+                    (k, function_reports)
+                })
+                .collect(),
+        }
+    }
+}
+
+impl From<edr_gas_report::GasReportExecutionStatus> for GasReportExecutionStatus {
+    fn from(value: edr_gas_report::GasReportExecutionStatus) -> Self {
+        match value {
+            edr_gas_report::GasReportExecutionStatus::Success => Self::Success,
+            edr_gas_report::GasReportExecutionStatus::Revert => Self::Revert,
+            edr_gas_report::GasReportExecutionStatus::Halt => Self::Halt,
+        }
+    }
+}
+
+impl From<edr_gas_report::DeploymentGasReport> for DeploymentGasReport {
+    fn from(value: edr_gas_report::DeploymentGasReport) -> Self {
+        Self {
+            gas: BigInt::from(value.gas),
+            size: BigInt::from(value.size),
+            status: value.status.into(),
+        }
+    }
+}
+
+impl From<edr_gas_report::FunctionGasReport> for FunctionGasReport {
+    fn from(value: edr_gas_report::FunctionGasReport) -> Self {
+        Self {
+            gas: BigInt::from(value.gas),
+            status: value.status.into(),
+        }
+    }
+}

package/src/lib.rs

@@ -20,6 +20,7 @@ pub mod context;
 /// Types for decoding smart contract data.
 pub mod contract_decoder;
 mod debug_trace;
+pub mod gas_report;
 /// Types and functions related to code coverage instrumentation.
 pub mod instrument;
 /// Types for EVM execution logs.

package/src/logger.rs

@@ -1,7 +1,7 @@
 use std::sync::{mpsc::channel, Arc};
 
-use edr_eth::Bytes;
 use edr_napi_core::logger::LoggerError;
+use edr_primitives::Bytes;
 use napi::{
     threadsafe_function::{
         ErrorStrategy, ThreadSafeCallContext, ThreadsafeFunction, ThreadsafeFunctionCallMode,

package/src/mock/time.rs

@@ -1,11 +1,11 @@
 use std::sync::Arc;
 
-use edr_eth::B256;
 use edr_evm::spec::RuntimeSpec;
 use edr_evm_spec::ChainSpec;
 use edr_generic::GenericChainSpec;
 use edr_napi_core::logger::Logger;
-use edr_rpc_eth::RpcSpec;
+use edr_primitives::B256;
+use edr_rpc_spec::RpcSpec;
 use napi::{bindgen_prelude::BigInt, tokio::runtime, Env, JsObject};
 use napi_derive::napi;
 

package/src/precompile.rs

@@ -1,5 +1,5 @@
-use edr_eth::Address;
 use edr_evm::precompile::{self, PrecompileFn, PrecompileWithAddress};
+use edr_primitives::Address;
 use napi::bindgen_prelude::Uint8Array;
 use napi_derive::napi;
 

package/src/result.rs

@@ -19,17 +19,17 @@ pub enum SuccessReason {
     SelfDestruct,
 }
 
-impl From<edr_eth::result::SuccessReason> for SuccessReason {
-    fn from(eval: edr_eth::result::SuccessReason) -> Self {
+impl From<edr_evm::result::SuccessReason> for SuccessReason {
+    fn from(eval: edr_evm::result::SuccessReason) -> Self {
         match eval {
-            edr_eth::result::SuccessReason::Stop => Self::Stop,
-            edr_eth::result::SuccessReason::Return => Self::Return,
-            edr_eth::result::SuccessReason::SelfDestruct => Self::SelfDestruct,
+            edr_evm::result::SuccessReason::Stop => Self::Stop,
+            edr_evm::result::SuccessReason::Return => Self::Return,
+            edr_evm::result::SuccessReason::SelfDestruct => Self::SelfDestruct,
         }
     }
 }
 
-impl From<SuccessReason> for edr_eth::result::SuccessReason {
+impl From<SuccessReason> for edr_evm::result::SuccessReason {
     fn from(value: SuccessReason) -> Self {
         match value {
             SuccessReason::Stop => Self::Stop,
@@ -157,7 +157,7 @@ impl From<&AfterMessage<EvmHaltReason>> for ExecutionResult {
         } = value;
 
         let result = match execution_result {
-            edr_eth::result::ExecutionResult::Success {
+            edr_evm::result::ExecutionResult::Success {
                 reason,
                 gas_used,
                 gas_refunded,
@@ -172,12 +172,12 @@ impl From<&AfterMessage<EvmHaltReason>> for ExecutionResult {
                     gas_refunded: BigInt::from(*gas_refunded),
                     logs,
                     output: match output {
-                        edr_eth::result::Output::Call(return_value) => {
+                        edr_evm::result::Output::Call(return_value) => {
                             let return_value = Uint8Array::with_data_copied(return_value);
 
                             Either::A(CallOutput { return_value })
                         }
-                        edr_eth::result::Output::Create(return_value, address) => {
+                        edr_evm::result::Output::Create(return_value, address) => {
                             let return_value = Uint8Array::with_data_copied(return_value);
 
                             Either::B(CreateOutput {
@@ -188,7 +188,7 @@ impl From<&AfterMessage<EvmHaltReason>> for ExecutionResult {
                     },
                 })
             }
-            edr_eth::result::ExecutionResult::Revert { gas_used, output } => {
+            edr_evm::result::ExecutionResult::Revert { gas_used, output } => {
                 let output = Uint8Array::with_data_copied(output);
 
                 Either3::B(RevertResult {
@@ -196,7 +196,7 @@ impl From<&AfterMessage<EvmHaltReason>> for ExecutionResult {
                     output,
                 })
             }
-            edr_eth::result::ExecutionResult::Halt { reason, gas_used } => Either3::C(HaltResult {
+            edr_evm::result::ExecutionResult::Halt { reason, gas_used } => Either3::C(HaltResult {
                 reason: ExceptionalHalt::from(*reason),
                 gas_used: BigInt::from(*gas_used),
             }),

package/src/serde.rs

@@ -1,4 +1,4 @@
-use edr_eth::hex;
+use edr_primitives::hex;
 use napi::bindgen_prelude::{BigInt, Uint8Array};
 use serde::Serializer;
 

package/src/solidity_tests/config.rs

@@ -1,7 +1,7 @@
 use std::{collections::HashMap, path::PathBuf};
 
 use derive_more::Debug;
-use edr_eth::hex;
+use edr_primitives::hex;
 use edr_solidity_tests::{
     executors::invariant::InvariantConfig,
     fuzz::FuzzConfig,
@@ -155,6 +155,11 @@ pub struct SolidityTestRunnerConfigArgs {
     /// A regex pattern to filter tests. If provided, only test methods that
     /// match the pattern will be executed and reported as a test result.
     pub test_pattern: Option<String>,
+    /// Controls whether to generate a gas report after running the tests.
+    /// Enabling this also enables collection of all traces and EVM isolation
+    /// mode.
+    /// Defaults to false.
+    pub generate_gas_report: Option<bool>,
 }
 
 impl SolidityTestRunnerConfigArgs {
@@ -200,6 +205,7 @@ impl SolidityTestRunnerConfigArgs {
             include_traces,
             observability,
             test_pattern,
+            generate_gas_report,
         } = self;
 
         let test_pattern = TestFilterConfig {
@@ -305,6 +311,7 @@ impl SolidityTestRunnerConfigArgs {
             ),
             on_collected_coverage_fn,
             test_pattern,
+            generate_gas_report,
         };
 
         Ok(config)

package/src/solidity_tests/l1.rs

@@ -1,10 +1,10 @@
 use std::{collections::BTreeMap, sync::Arc};
 
-use edr_eth::Bytes;
 use edr_napi_core::solidity::{
     config::{TestRunnerConfig, TracingConfigWithBuffers},
     SyncTestRunner, SyncTestRunnerFactory,
 };
+use edr_primitives::Bytes;
 use edr_solidity::artifacts::ArtifactId;
 use edr_solidity_tests::{
     contracts::ContractsByArtifact, decode::RevertDecoder, evm_context::L1EvmBuilder,

package/src/solidity_tests/op.rs

@@ -1,11 +1,11 @@
 use std::{collections::BTreeMap, sync::Arc};
 
-use edr_eth::Bytes;
 use edr_napi_core::solidity::{
     config::{TestRunnerConfig, TracingConfigWithBuffers},
     SyncTestRunner, SyncTestRunnerFactory,
 };
 use edr_op::solidity_tests::OpEvmBuilder;
+use edr_primitives::Bytes;
 use edr_solidity::artifacts::ArtifactId;
 use edr_solidity_tests::{
     contracts::ContractsByArtifact, decode::RevertDecoder, multi_runner::TestContract,

package/src/solidity_tests/test_results.rs

@@ -18,6 +18,7 @@ use napi_derive::napi;
 
 use crate::{
     cast::TryCast,
+    gas_report::GasReport,
     solidity_tests::{artifact::ArtifactId, config::IncludeTraces},
     trace::{solidity_stack_trace::SolidityStackTraceEntry, u256_to_bigint},
 };
@@ -717,3 +718,19 @@ impl From<traces::CallKind> for CallKind {
         }
     }
 }
+
+/// The result of a Solidity test run.
+#[napi(object)]
+pub struct SolidityTestResult {
+    /// Gas report, if it was generated.
+    #[napi(readonly)]
+    pub gas_report: Option<GasReport>,
+}
+
+impl From<edr_solidity_tests::multi_runner::SolidityTestResult> for SolidityTestResult {
+    fn from(value: edr_solidity_tests::multi_runner::SolidityTestResult) -> Self {
+        Self {
+            gas_report: value.gas_report.map(GasReport::from),
+        }
+    }
+}

package/src/solidity_tests.rs

@@ -9,7 +9,7 @@ pub mod test_results;
 
 use std::path::Path;
 
-use edr_eth::Bytes;
+use edr_primitives::Bytes;
 use edr_solidity::linker::{LinkOutput, Linker};
 use edr_solidity_tests::{constants::LIBRARY_DEPLOYER, contracts::ContractsByArtifact};
 use foundry_compilers::artifacts::Libraries;

package/src/trace/solidity_stack_trace.rs

@@ -3,7 +3,7 @@
 
 use std::convert::Infallible;
 
-use edr_eth::{hex, U256};
+use edr_primitives::{hex, U256};
 use napi::bindgen_prelude::{BigInt, Either25, FromNapiValue, ToNapiValue, Uint8Array, Undefined};
 use napi_derive::napi;
 use serde::{Serialize, Serializer};
@@ -848,7 +848,8 @@ const _: () = {
     assert_to_from_napi_value::<SolidityStackTraceEntry>();
 };
 
-/// Serializes a [`BigInt`] that represents an EVM value as a [`edr_eth::U256`].
+/// Serializes a [`BigInt`] that represents an EVM value as a
+/// [`edr_primitives::U256`].
 fn serialize_evm_value_bigint_using_u256<S>(bigint: &BigInt, s: S) -> Result<S::Ok, S::Error>
 where
     S: Serializer,

package/src/trace.rs

@@ -7,9 +7,9 @@
 
 use std::sync::Arc;
 
-use edr_eth::bytecode::opcode::OpCode;
 use edr_evm::trace::BeforeMessage;
 use edr_evm_spec::EvmHaltReason;
+use edr_primitives::bytecode::opcode::OpCode;
 use napi::bindgen_prelude::{BigInt, Either3, Uint8Array};
 use napi_derive::napi;
 
@@ -145,7 +145,7 @@ impl TracingStep {
     }
 }
 
-pub(crate) fn u256_to_bigint(v: &edr_eth::U256) -> BigInt {
+pub(crate) fn u256_to_bigint(v: &edr_primitives::U256) -> BigInt {
     BigInt {
         sign_bit: false,
         words: v.into_limbs().to_vec(),

package/src/withdrawal.rs

@@ -1,4 +1,4 @@
-use edr_eth::Address;
+use edr_primitives::Address;
 use napi::bindgen_prelude::{BigInt, Uint8Array};
 use napi_derive::napi;
 
@@ -16,21 +16,21 @@ pub struct Withdrawal {
     pub amount: BigInt,
 }
 
-impl From<edr_eth::withdrawal::Withdrawal> for Withdrawal {
-    fn from(withdrawal: edr_eth::withdrawal::Withdrawal) -> Self {
+impl From<edr_block_header::Withdrawal> for Withdrawal {
+    fn from(withdrawal: edr_block_header::Withdrawal) -> Self {
         Self {
             index: BigInt::from(withdrawal.index),
             validator_index: BigInt::from(withdrawal.validator_index),
             address: Uint8Array::with_data_copied(withdrawal.address),
             amount: BigInt {
                 sign_bit: false,
-                words: withdrawal.amount.as_limbs().to_vec(),
+                words: vec![withdrawal.amount],
             },
         }
     }
 }
 
-impl TryFrom<Withdrawal> for edr_eth::withdrawal::Withdrawal {
+impl TryFrom<Withdrawal> for edr_block_header::Withdrawal {
     type Error = napi::Error;
 
     fn try_from(value: Withdrawal) -> Result<Self, Self::Error> {