@nomicfoundation/edr 0.12.0-next.10 → 0.12.0-next.15

package/index.d.ts

@@ -91,7 +91,9 @@ export enum SpecId {
   /** Cancun */
   Cancun = 17,
   /** Prague */
-  Prague = 18
+  Prague = 18,
+  /** Osaka */
+  Osaka = 19
 }
 /**
  * Tries to parse the provided string to create a [`SpecId`] instance.
@@ -125,6 +127,7 @@ export const MERGE: string
 export const SHANGHAI: string
 export const CANCUN: string
 export const PRAGUE: string
+export const OSAKA: string
 /** Enumeration of supported OP hardforks. */
 export enum OpHardfork {
   Bedrock = 100,
@@ -586,8 +589,6 @@ export interface SolidityTestRunnerConfigArgs {
   projectRoot: string
   /** Configures the permissions of cheat codes that access the file system. */
   fsPermissions?: Array<PathPermission>
-  /** Whether to support the `testFail` prefix. Defaults to false. */
-  testFail?: boolean
   /** Address labels for traces. Defaults to none. */
   labels?: Array<AddressLabel>
   /**
@@ -838,6 +839,12 @@ export interface InvariantConfigArgs {
    * Defaults to 5000.
    */
   shrinkRunLimit?: number
+  /**
+   * The maximum number of rejects via `vm.assume` which can be encountered
+   * during a single invariant run.
+   * Defaults to 65536.
+   */
+  maxAssumeRejects?: number
 }
 /** Settings to configure caching of remote RPC endpoints. */
 export interface StorageCachingConfig {
@@ -1003,7 +1010,7 @@ export enum TestStatus {
   /**Test skipped */
   Skipped = 'Skipped'
 }
-/** See [`edr_solidity_tests::result::TestKind::Standard`] */
+/** See [`edr_solidity_tests::result::TestKind::Unit`] */
 export interface StandardTestKind {
   /** The gas consumed by the test. */
   readonly consumedGas: bigint
@@ -1034,6 +1041,16 @@ export interface InvariantTestKind {
   readonly calls: bigint
   /** See [`edr_solidity_tests::result::TestKind::Invariant`] */
   readonly reverts: bigint
+  /** See [`edr_solidity_tests::result::TestKind::Invariant`] */
+  readonly metrics: Record<string, InvariantMetrics>
+  /** See [`edr_solidity_tests::result::TestKind::Invariant`] */
+  readonly failedCorpusReplays: bigint
+}
+/** See [`edr_solidity_tests::result::InvariantMetrics`] */
+export interface InvariantMetrics {
+  readonly calls: bigint
+  readonly reverts: bigint
+  readonly discards: bigint
 }
 /**
  * Original sequence size and sequence of calls used as a counter example

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, 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
+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, OSAKA, 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
@@ -340,6 +340,7 @@ module.exports.MERGE = MERGE
 module.exports.SHANGHAI = SHANGHAI
 module.exports.CANCUN = CANCUN
 module.exports.PRAGUE = PRAGUE
+module.exports.OSAKA = OSAKA
 module.exports.OpHardfork = OpHardfork
 module.exports.opHardforkFromString = opHardforkFromString
 module.exports.opHardforkToString = opHardforkToString

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nomicfoundation/edr",
-  "version": "0.12.0-next.10",
+  "version": "0.12.0-next.15",
   "devDependencies": {
     "@napi-rs/cli": "^2.18.4",
     "@nomicfoundation/ethereumjs-util": "^9.0.4",
@@ -36,8 +36,7 @@
   "files": [
     "index.js",
     "index.d.ts",
-    "src/",
-    "dist/src/"
+    "src/"
   ],
   "license": "MIT",
   "main": "index.js",
@@ -59,13 +58,13 @@
   "repository": "NomicFoundation/edr.git",
   "types": "index.d.ts",
   "dependencies": {
-    "@nomicfoundation/edr-darwin-arm64": "0.12.0-next.10",
-    "@nomicfoundation/edr-darwin-x64": "0.12.0-next.10",
-    "@nomicfoundation/edr-linux-arm64-gnu": "0.12.0-next.10",
-    "@nomicfoundation/edr-linux-arm64-musl": "0.12.0-next.10",
-    "@nomicfoundation/edr-linux-x64-gnu": "0.12.0-next.10",
-    "@nomicfoundation/edr-linux-x64-musl": "0.12.0-next.10",
-    "@nomicfoundation/edr-win32-x64-msvc": "0.12.0-next.10"
+    "@nomicfoundation/edr-darwin-arm64": "0.12.0-next.15",
+    "@nomicfoundation/edr-darwin-x64": "0.12.0-next.15",
+    "@nomicfoundation/edr-linux-arm64-gnu": "0.12.0-next.15",
+    "@nomicfoundation/edr-linux-arm64-musl": "0.12.0-next.15",
+    "@nomicfoundation/edr-linux-x64-gnu": "0.12.0-next.15",
+    "@nomicfoundation/edr-linux-x64-musl": "0.12.0-next.15",
+    "@nomicfoundation/edr-win32-x64-msvc": "0.12.0-next.15"
   },
   "scripts": {
     "artifacts": "napi artifacts",

package/src/account.rs

@@ -82,7 +82,7 @@ impl TryFrom<AccountOverride> for Predeploy {
     fn try_from(value: AccountOverride) -> Result<Self, Self::Error> {
         let (address, account_override) = value.try_into()?;
 
-        let storage = account_override.storage.unwrap_or_else(HashMap::new);
+        let storage = account_override.storage.unwrap_or_else(HashMap::default);
         let balance = account_override.balance.unwrap_or(U256::ZERO);
         let nonce = account_override.nonce.unwrap_or(0);
         let code = account_override.code.ok_or_else(|| {

package/src/chains/l1.rs

@@ -1,10 +1,10 @@
 use std::{str::FromStr, sync::Arc};
 
-use edr_chain_l1::L1ChainSpec;
-use edr_evm::eips::{
+use edr_blockchain_fork::eips::{
     eip2935::{HISTORY_STORAGE_ADDRESS, HISTORY_STORAGE_UNSUPPORTED_BYTECODE},
     eip4788::{BEACON_ROOTS_ADDRESS, BEACON_ROOTS_BYTECODE},
 };
+use edr_chain_l1::L1ChainSpec;
 use edr_napi_core::{
     logger::Logger,
     provider::{SyncProvider, SyncProviderFactory},
@@ -135,6 +135,8 @@ pub enum SpecId {
     Cancun = 17,
     /// Prague
     Prague = 18,
+    /// Osaka
+    Osaka = 19,
 }
 
 impl FromStr for SpecId {
@@ -142,25 +144,26 @@ impl FromStr for SpecId {
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         match s {
-            edr_chain_l1::hardfork::name::FRONTIER => Ok(SpecId::Frontier),
-            edr_chain_l1::hardfork::name::FRONTIER_THAWING => Ok(SpecId::FrontierThawing),
-            edr_chain_l1::hardfork::name::HOMESTEAD => Ok(SpecId::Homestead),
-            edr_chain_l1::hardfork::name::DAO_FORK => Ok(SpecId::DaoFork),
-            edr_chain_l1::hardfork::name::TANGERINE => Ok(SpecId::Tangerine),
-            edr_chain_l1::hardfork::name::SPURIOUS_DRAGON => Ok(SpecId::SpuriousDragon),
-            edr_chain_l1::hardfork::name::BYZANTIUM => Ok(SpecId::Byzantium),
-            edr_chain_l1::hardfork::name::CONSTANTINOPLE => Ok(SpecId::Constantinople),
-            edr_chain_l1::hardfork::name::PETERSBURG => Ok(SpecId::Petersburg),
-            edr_chain_l1::hardfork::name::ISTANBUL => Ok(SpecId::Istanbul),
-            edr_chain_l1::hardfork::name::MUIR_GLACIER => Ok(SpecId::MuirGlacier),
-            edr_chain_l1::hardfork::name::BERLIN => Ok(SpecId::Berlin),
-            edr_chain_l1::hardfork::name::LONDON => Ok(SpecId::London),
-            edr_chain_l1::hardfork::name::ARROW_GLACIER => Ok(SpecId::ArrowGlacier),
-            edr_chain_l1::hardfork::name::GRAY_GLACIER => Ok(SpecId::GrayGlacier),
-            edr_chain_l1::hardfork::name::MERGE => Ok(SpecId::Merge),
-            edr_chain_l1::hardfork::name::SHANGHAI => Ok(SpecId::Shanghai),
-            edr_chain_l1::hardfork::name::CANCUN => Ok(SpecId::Cancun),
-            edr_chain_l1::hardfork::name::PRAGUE => Ok(SpecId::Prague),
+            edr_chain_l1::chains::name::FRONTIER => Ok(SpecId::Frontier),
+            edr_chain_l1::chains::name::FRONTIER_THAWING => Ok(SpecId::FrontierThawing),
+            edr_chain_l1::chains::name::HOMESTEAD => Ok(SpecId::Homestead),
+            edr_chain_l1::chains::name::DAO_FORK => Ok(SpecId::DaoFork),
+            edr_chain_l1::chains::name::TANGERINE => Ok(SpecId::Tangerine),
+            edr_chain_l1::chains::name::SPURIOUS_DRAGON => Ok(SpecId::SpuriousDragon),
+            edr_chain_l1::chains::name::BYZANTIUM => Ok(SpecId::Byzantium),
+            edr_chain_l1::chains::name::CONSTANTINOPLE => Ok(SpecId::Constantinople),
+            edr_chain_l1::chains::name::PETERSBURG => Ok(SpecId::Petersburg),
+            edr_chain_l1::chains::name::ISTANBUL => Ok(SpecId::Istanbul),
+            edr_chain_l1::chains::name::MUIR_GLACIER => Ok(SpecId::MuirGlacier),
+            edr_chain_l1::chains::name::BERLIN => Ok(SpecId::Berlin),
+            edr_chain_l1::chains::name::LONDON => Ok(SpecId::London),
+            edr_chain_l1::chains::name::ARROW_GLACIER => Ok(SpecId::ArrowGlacier),
+            edr_chain_l1::chains::name::GRAY_GLACIER => Ok(SpecId::GrayGlacier),
+            edr_chain_l1::chains::name::MERGE => Ok(SpecId::Merge),
+            edr_chain_l1::chains::name::SHANGHAI => Ok(SpecId::Shanghai),
+            edr_chain_l1::chains::name::CANCUN => Ok(SpecId::Cancun),
+            edr_chain_l1::chains::name::PRAGUE => Ok(SpecId::Prague),
+            edr_chain_l1::chains::name::OSAKA => Ok(SpecId::Osaka),
             _ => Err(napi::Error::new(
                 napi::Status::InvalidArg,
                 format!("The provided hardfork `{s}` is not supported."),
@@ -191,6 +194,7 @@ impl From<SpecId> for edr_chain_l1::Hardfork {
             SpecId::Shanghai => edr_chain_l1::Hardfork::SHANGHAI,
             SpecId::Cancun => edr_chain_l1::Hardfork::CANCUN,
             SpecId::Prague => edr_chain_l1::Hardfork::PRAGUE,
+            SpecId::Osaka => edr_chain_l1::Hardfork::OSAKA,
         }
     }
 }
@@ -206,25 +210,26 @@ pub fn l1_hardfork_from_string(hardfork: String) -> napi::Result<SpecId> {
 #[napi(catch_unwind)]
 pub fn l1_hardfork_to_string(harfork: SpecId) -> &'static str {
     match harfork {
-        SpecId::Frontier => edr_chain_l1::hardfork::name::FRONTIER,
-        SpecId::FrontierThawing => edr_chain_l1::hardfork::name::FRONTIER_THAWING,
-        SpecId::Homestead => edr_chain_l1::hardfork::name::HOMESTEAD,
-        SpecId::DaoFork => edr_chain_l1::hardfork::name::DAO_FORK,
-        SpecId::Tangerine => edr_chain_l1::hardfork::name::TANGERINE,
-        SpecId::SpuriousDragon => edr_chain_l1::hardfork::name::SPURIOUS_DRAGON,
-        SpecId::Byzantium => edr_chain_l1::hardfork::name::BYZANTIUM,
-        SpecId::Constantinople => edr_chain_l1::hardfork::name::CONSTANTINOPLE,
-        SpecId::Petersburg => edr_chain_l1::hardfork::name::PETERSBURG,
-        SpecId::Istanbul => edr_chain_l1::hardfork::name::ISTANBUL,
-        SpecId::MuirGlacier => edr_chain_l1::hardfork::name::MUIR_GLACIER,
-        SpecId::Berlin => edr_chain_l1::hardfork::name::BERLIN,
-        SpecId::London => edr_chain_l1::hardfork::name::LONDON,
-        SpecId::ArrowGlacier => edr_chain_l1::hardfork::name::ARROW_GLACIER,
-        SpecId::GrayGlacier => edr_chain_l1::hardfork::name::GRAY_GLACIER,
-        SpecId::Merge => edr_chain_l1::hardfork::name::MERGE,
-        SpecId::Shanghai => edr_chain_l1::hardfork::name::SHANGHAI,
-        SpecId::Cancun => edr_chain_l1::hardfork::name::CANCUN,
-        SpecId::Prague => edr_chain_l1::hardfork::name::PRAGUE,
+        SpecId::Frontier => edr_chain_l1::chains::name::FRONTIER,
+        SpecId::FrontierThawing => edr_chain_l1::chains::name::FRONTIER_THAWING,
+        SpecId::Homestead => edr_chain_l1::chains::name::HOMESTEAD,
+        SpecId::DaoFork => edr_chain_l1::chains::name::DAO_FORK,
+        SpecId::Tangerine => edr_chain_l1::chains::name::TANGERINE,
+        SpecId::SpuriousDragon => edr_chain_l1::chains::name::SPURIOUS_DRAGON,
+        SpecId::Byzantium => edr_chain_l1::chains::name::BYZANTIUM,
+        SpecId::Constantinople => edr_chain_l1::chains::name::CONSTANTINOPLE,
+        SpecId::Petersburg => edr_chain_l1::chains::name::PETERSBURG,
+        SpecId::Istanbul => edr_chain_l1::chains::name::ISTANBUL,
+        SpecId::MuirGlacier => edr_chain_l1::chains::name::MUIR_GLACIER,
+        SpecId::Berlin => edr_chain_l1::chains::name::BERLIN,
+        SpecId::London => edr_chain_l1::chains::name::LONDON,
+        SpecId::ArrowGlacier => edr_chain_l1::chains::name::ARROW_GLACIER,
+        SpecId::GrayGlacier => edr_chain_l1::chains::name::GRAY_GLACIER,
+        SpecId::Merge => edr_chain_l1::chains::name::MERGE,
+        SpecId::Shanghai => edr_chain_l1::chains::name::SHANGHAI,
+        SpecId::Cancun => edr_chain_l1::chains::name::CANCUN,
+        SpecId::Prague => edr_chain_l1::chains::name::PRAGUE,
+        SpecId::Osaka => edr_chain_l1::chains::name::OSAKA,
     }
 }
 
@@ -240,7 +245,7 @@ macro_rules! export_spec_id {
     ($($variant:ident),*) => {
         $(
             #[napi]
-            pub const $variant: &str = edr_chain_l1::hardfork::name::$variant;
+            pub const $variant: &str = edr_chain_l1::chains::name::$variant;
         )*
     };
 }
@@ -264,5 +269,6 @@ export_spec_id!(
     MERGE,
     SHANGHAI,
     CANCUN,
-    PRAGUE
+    PRAGUE,
+    OSAKA
 );

package/src/config.rs

@@ -280,28 +280,28 @@ impl TryFrom<ForkConfig> for edr_provider::ForkConfig<String> {
                                         let condition = match condition {
                                             Either::A(HardforkActivationByBlockNumber {
                                                 block_number,
-                                            }) => edr_evm::hardfork::ForkCondition::Block(
+                                            }) => edr_chain_config::ForkCondition::Block(
                                                 block_number.try_cast()?,
                                             ),
                                             Either::B(HardforkActivationByTimestamp {
                                                 timestamp,
-                                            }) => edr_evm::hardfork::ForkCondition::Timestamp(
+                                            }) => edr_chain_config::ForkCondition::Timestamp(
                                                 timestamp.try_cast()?,
                                             ),
                                         };
 
-                                        Ok(edr_evm::hardfork::Activation {
+                                        Ok(edr_chain_config::HardforkActivation {
                                             condition,
                                             hardfork,
                                         })
                                     },
                                 )
                                 .collect::<napi::Result<Vec<_>>>()
-                                .map(edr_evm::hardfork::Activations::new)
+                                .map(edr_chain_config::HardforkActivations::new)
                                     })
                                     .transpose()?;
 
-                            let chain_config = edr_evm::hardfork::ChainOverride {
+                            let chain_config = edr_chain_config::ChainOverride {
                                 name,
                                 hardfork_activation_overrides,
                             };
@@ -339,7 +339,7 @@ impl From<MemPoolConfig> for edr_provider::MemPoolConfig {
     }
 }
 
-impl From<MineOrdering> for edr_evm::MineOrdering {
+impl From<MineOrdering> for edr_runtime::MineOrdering {
     fn from(value: MineOrdering) -> Self {
         match value {
             MineOrdering::Fifo => Self::Fifo,

package/src/context.rs

@@ -390,8 +390,8 @@ impl Context {
         }
 
         Ok(Self {
-            provider_factories: HashMap::new(),
-            solidity_test_runner_factories: HashMap::new(),
+            provider_factories: HashMap::default(),
+            solidity_test_runner_factories: HashMap::default(),
             #[cfg(feature = "tracing")]
             _tracing_write_guard: guard,
         })

package/src/mock/time.rs

@@ -1,11 +1,11 @@
 use std::sync::Arc;
 
-use edr_evm::spec::RuntimeSpec;
-use edr_evm_spec::ChainSpec;
+use edr_chain_spec::ChainSpec;
+use edr_chain_spec_block::BlockChainSpec;
 use edr_generic::GenericChainSpec;
 use edr_napi_core::logger::Logger;
 use edr_primitives::B256;
-use edr_rpc_spec::RpcSpec;
+use edr_rpc_spec::RpcBlockChainSpec;
 use napi::{bindgen_prelude::BigInt, tokio::runtime, Env, JsObject};
 use napi_derive::napi;
 
@@ -104,8 +104,8 @@ pub fn create_provider_with_mock_timer(
                     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 BlockChainSpec>::Block,
+                            <GenericChainSpec as RpcBlockChainSpec>::RpcBlock<B256>,
                             <GenericChainSpec as ChainSpec>::SignedTransaction,
                         >(event);
 

package/src/mock.rs

@@ -2,7 +2,7 @@ pub mod time;
 
 use std::sync::Arc;
 
-use edr_evm_spec::EvmHaltReason;
+use edr_chain_spec::EvmHaltReason;
 use edr_napi_core::provider::SyncProvider;
 use edr_rpc_client::jsonrpc;
 use edr_solidity::contract_decoder::ContractDecoder;

package/src/precompile.rs

@@ -1,4 +1,4 @@
-use edr_evm::precompile::{self, PrecompileFn, PrecompileWithAddress};
+use edr_precompile::PrecompileFn;
 use edr_primitives::Address;
 use napi::bindgen_prelude::Uint8Array;
 use napi_derive::napi;
@@ -24,11 +24,11 @@ impl Precompile {
     }
 }
 
-impl From<PrecompileWithAddress> for Precompile {
-    fn from(value: PrecompileWithAddress) -> Self {
+impl From<edr_precompile::Precompile> for Precompile {
+    fn from(value: edr_precompile::Precompile) -> Self {
         Self {
-            address: value.0,
-            precompile_fn: value.1,
+            address: *value.address(),
+            precompile_fn: value.into_precompile(),
         }
     }
 }
@@ -46,5 +46,5 @@ impl Precompile {
 /// secp256r1 precompile.
 #[napi(catch_unwind)]
 pub fn precompile_p256_verify() -> Precompile {
-    Precompile::from(precompile::secp256r1::P256VERIFY)
+    Precompile::from(edr_precompile::secp256r1::P256VERIFY)
 }

package/src/provider/response.rs

@@ -1,4 +1,4 @@
-use edr_evm_spec::EvmHaltReason;
+use edr_chain_spec::EvmHaltReason;
 use edr_napi_core::spec::SolidityTraceData;
 use edr_solidity::contract_decoder::NestedTraceDecoder as _;
 use napi::Either;

package/src/result.rs

@@ -1,5 +1,5 @@
-use edr_evm::trace::AfterMessage;
-use edr_evm_spec::EvmHaltReason;
+use edr_chain_spec::EvmHaltReason;
+use edr_runtime::trace::AfterMessage;
 use napi::{
     bindgen_prelude::{BigInt, Either3, Uint8Array},
     Either,
@@ -19,17 +19,17 @@ pub enum SuccessReason {
     SelfDestruct,
 }
 
-impl From<edr_evm::result::SuccessReason> for SuccessReason {
-    fn from(eval: edr_evm::result::SuccessReason) -> Self {
+impl From<edr_evm_spec::result::SuccessReason> for SuccessReason {
+    fn from(eval: edr_evm_spec::result::SuccessReason) -> Self {
         match eval {
-            edr_evm::result::SuccessReason::Stop => Self::Stop,
-            edr_evm::result::SuccessReason::Return => Self::Return,
-            edr_evm::result::SuccessReason::SelfDestruct => Self::SelfDestruct,
+            edr_evm_spec::result::SuccessReason::Stop => Self::Stop,
+            edr_evm_spec::result::SuccessReason::Return => Self::Return,
+            edr_evm_spec::result::SuccessReason::SelfDestruct => Self::SelfDestruct,
         }
     }
 }
 
-impl From<SuccessReason> for edr_evm::result::SuccessReason {
+impl From<SuccessReason> for edr_evm_spec::result::SuccessReason {
     fn from(value: SuccessReason) -> Self {
         match value {
             SuccessReason::Stop => Self::Stop,
@@ -112,7 +112,9 @@ impl From<EvmHaltReason> for ExceptionalHalt {
             EvmHaltReason::StackOverflow => ExceptionalHalt::StackOverflow,
             EvmHaltReason::OutOfOffset => ExceptionalHalt::OutOfOffset,
             EvmHaltReason::CreateCollision => ExceptionalHalt::CreateCollision,
-            EvmHaltReason::PrecompileError => ExceptionalHalt::PrecompileError,
+            EvmHaltReason::PrecompileError | EvmHaltReason::PrecompileErrorWithContext(_) => {
+                ExceptionalHalt::PrecompileError
+            }
             EvmHaltReason::NonceOverflow => ExceptionalHalt::NonceOverflow,
             EvmHaltReason::CreateContractSizeLimit => ExceptionalHalt::CreateContractSizeLimit,
             EvmHaltReason::CreateContractStartingWithEF => {
@@ -157,7 +159,7 @@ impl From<&AfterMessage<EvmHaltReason>> for ExecutionResult {
         } = value;
 
         let result = match execution_result {
-            edr_evm::result::ExecutionResult::Success {
+            edr_evm_spec::result::ExecutionResult::Success {
                 reason,
                 gas_used,
                 gas_refunded,
@@ -172,12 +174,12 @@ impl From<&AfterMessage<EvmHaltReason>> for ExecutionResult {
                     gas_refunded: BigInt::from(*gas_refunded),
                     logs,
                     output: match output {
-                        edr_evm::result::Output::Call(return_value) => {
+                        edr_evm_spec::result::Output::Call(return_value) => {
                             let return_value = Uint8Array::with_data_copied(return_value);
 
                             Either::A(CallOutput { return_value })
                         }
-                        edr_evm::result::Output::Create(return_value, address) => {
+                        edr_evm_spec::result::Output::Create(return_value, address) => {
                             let return_value = Uint8Array::with_data_copied(return_value);
 
                             Either::B(CreateOutput {
@@ -188,7 +190,7 @@ impl From<&AfterMessage<EvmHaltReason>> for ExecutionResult {
                     },
                 })
             }
-            edr_evm::result::ExecutionResult::Revert { gas_used, output } => {
+            edr_evm_spec::result::ExecutionResult::Revert { gas_used, output } => {
                 let output = Uint8Array::with_data_copied(output);
 
                 Either3::B(RevertResult {
@@ -196,10 +198,12 @@ impl From<&AfterMessage<EvmHaltReason>> for ExecutionResult {
                     output,
                 })
             }
-            edr_evm::result::ExecutionResult::Halt { reason, gas_used } => Either3::C(HaltResult {
-                reason: ExceptionalHalt::from(*reason),
-                gas_used: BigInt::from(*gas_used),
-            }),
+            edr_evm_spec::result::ExecutionResult::Halt { reason, gas_used } => {
+                Either3::C(HaltResult {
+                    reason: ExceptionalHalt::from(reason.clone()),
+                    gas_used: BigInt::from(*gas_used),
+                })
+            }
         };
 
         let contract_address = contract_address.as_ref().map(Uint8Array::with_data_copied);

package/src/solidity_tests/config.rs

@@ -8,7 +8,7 @@ use edr_solidity_tests::{
     inspectors::cheatcodes::{CheatsConfigOptions, ExecutionContextConfig},
     TestFilterConfig,
 };
-use foundry_cheatcodes::{FsPermissions, RpcEndpoint, RpcEndpoints};
+use foundry_cheatcodes::{FsPermissions, RpcEndpointUrl, RpcEndpoints};
 use napi::{
     bindgen_prelude::{BigInt, Uint8Array},
     tokio::runtime,
@@ -36,8 +36,6 @@ pub struct SolidityTestRunnerConfigArgs {
     pub project_root: String,
     /// Configures the permissions of cheat codes that access the file system.
     pub fs_permissions: Option<Vec<PathPermission>>,
-    /// Whether to support the `testFail` prefix. Defaults to false.
-    pub test_fail: Option<bool>,
     /// Address labels for traces. Defaults to none.
     pub labels: Option<Vec<AddressLabel>>,
     /// Whether to enable isolation of calls. In isolation mode all top-level
@@ -173,7 +171,6 @@ impl SolidityTestRunnerConfigArgs {
         let SolidityTestRunnerConfigArgs {
             project_root,
             fs_permissions,
-            test_fail,
             labels,
             isolate,
             ffi,
@@ -246,7 +243,7 @@ impl SolidityTestRunnerConfigArgs {
                     RpcEndpoints::new(
                         endpoints
                             .into_iter()
-                            .map(|(chain, url)| (chain, RpcEndpoint::Url(url))),
+                            .map(|(chain, url)| (chain, RpcEndpointUrl::new(url))),
                     )
                 })
                 .unwrap_or_default(),
@@ -267,6 +264,7 @@ impl SolidityTestRunnerConfigArgs {
                 .into_iter()
                 .map(|AddressLabel { address, label }| Ok((address.try_cast()?, label)))
                 .collect::<Result<_, napi::Error>>()?,
+            seed: fuzz.seed,
             allow_internal_expect_revert: allow_internal_expect_revert.unwrap_or(false),
         };
 
@@ -282,7 +280,6 @@ impl SolidityTestRunnerConfigArgs {
         let config = edr_napi_core::solidity::config::TestRunnerConfig {
             project_root: project_root.into(),
             include_traces: include_traces.unwrap_or_default().into(),
-            test_fail: test_fail.unwrap_or_default(),
             isolate,
             ffi,
             sender: sender.map(TryCast::try_cast).transpose()?,
@@ -370,7 +367,7 @@ impl TryFrom<FuzzConfigArgs> for FuzzConfig {
         } = value;
 
         let failure_persist_dir = failure_persist_dir.map(PathBuf::from);
-        let failure_persist_file = failure_persist_file.unwrap_or("failures".to_string());
+        let failure_persist_file = failure_persist_file.unwrap_or_else(|| "failures".to_string());
         let seed = seed
             .map(|s| {
                 s.parse().map_err(|_err| {
@@ -461,6 +458,10 @@ pub struct InvariantConfigArgs {
     /// process is disabled if set to 0.
     /// Defaults to 5000.
     pub shrink_run_limit: Option<u32>,
+    /// The maximum number of rejects via `vm.assume` which can be encountered
+    /// during a single invariant run.
+    /// Defaults to 65536.
+    pub max_assume_rejects: Option<u32>,
 }
 
 impl InvariantConfigArgs {
@@ -514,6 +515,7 @@ impl From<InvariantConfigArgs> for InvariantConfig {
             include_storage,
             include_push_bytes,
             shrink_run_limit,
+            max_assume_rejects,
         } = value;
 
         let failure_persist_dir = failure_persist_dir.map(PathBuf::from);
@@ -557,6 +559,10 @@ impl From<InvariantConfigArgs> for InvariantConfig {
             invariant.shrink_run_limit = shrink_run_limit;
         }
 
+        if let Some(max_assume_rejects) = max_assume_rejects {
+            invariant.max_assume_rejects = max_assume_rejects;
+        }
+
         invariant
     }
 }

package/src/solidity_tests/l1.rs

@@ -7,8 +7,12 @@ use edr_napi_core::solidity::{
 use edr_primitives::Bytes;
 use edr_solidity::artifacts::ArtifactId;
 use edr_solidity_tests::{
-    contracts::ContractsByArtifact, decode::RevertDecoder, evm_context::L1EvmBuilder,
-    multi_runner::TestContract, MultiContractRunner,
+    contracts::ContractsByArtifact,
+    decode::RevertDecoder,
+    evm_context::L1EvmBuilder,
+    multi_runner::TestContract,
+    revm::context::{BlockEnv, TxEnv},
+    MultiContractRunner,
 };
 use napi::tokio;
 use napi_derive::napi;
@@ -33,14 +37,14 @@ impl SyncTestRunnerFactory for L1TestRunnerFactory {
         let runner = tokio::task::block_in_place(|| {
             runtime
                 .block_on(MultiContractRunner::<
-                    edr_chain_l1::BlockEnv,
+                    BlockEnv,
                     (),
                     L1EvmBuilder,
                     edr_chain_l1::HaltReason,
                     edr_chain_l1::Hardfork,
                     _,
                     edr_chain_l1::InvalidTransaction,
-                    edr_chain_l1::TxEnv,
+                    TxEnv,
                 >::new(
                     config.try_into()?,
                     contracts,

package/src/solidity_tests/op.rs

@@ -4,11 +4,14 @@ use edr_napi_core::solidity::{
     config::{TestRunnerConfig, TracingConfigWithBuffers},
     SyncTestRunner, SyncTestRunnerFactory,
 };
-use edr_op::solidity_tests::OpEvmBuilder;
+use edr_op::{solidity_tests::OpEvmBuilder, transaction::OpTxEnv};
 use edr_primitives::Bytes;
 use edr_solidity::artifacts::ArtifactId;
 use edr_solidity_tests::{
-    contracts::ContractsByArtifact, decode::RevertDecoder, multi_runner::TestContract,
+    contracts::ContractsByArtifact,
+    decode::RevertDecoder,
+    multi_runner::TestContract,
+    revm::context::{BlockEnv, TxEnv},
     MultiContractRunner,
 };
 use napi::tokio;
@@ -34,14 +37,14 @@ impl SyncTestRunnerFactory for OpTestRunnerFactory {
         let runner = tokio::task::block_in_place(|| {
             runtime
                 .block_on(MultiContractRunner::<
-                    edr_op::BlockEnv,
+                    BlockEnv,
                     _,
                     OpEvmBuilder,
                     edr_op::HaltReason,
                     edr_op::Hardfork,
                     _,
-                    edr_op::transaction::InvalidTransaction,
-                    edr_op::transaction::OpTxEnv<edr_chain_l1::TxEnv>,
+                    edr_op::InvalidTransaction,
+                    OpTxEnv<TxEnv>,
                 >::new(
                     config.try_into()?,
                     contracts,

package/src/solidity_tests/runner.rs

@@ -1,6 +1,6 @@
 use std::sync::{Mutex, OnceLock};
 
-use edr_evm_spec::HaltReasonTrait;
+use edr_chain_spec::HaltReasonTrait;
 use edr_napi_core::solidity::config::TracingConfigWithBuffers;
 use edr_solidity::{
     artifacts::BuildInfoConfigWithBuffers,

package/src/solidity_tests/test_results.rs

@@ -264,7 +264,7 @@ impl TestResult {
                 }),
             decoded_logs: test_result.decoded_logs,
             kind: match test_result.kind {
-                edr_solidity_tests::result::TestKind::Standard(gas_consumed) => {
+                edr_solidity_tests::result::TestKind::Unit { gas: gas_consumed } => {
                     Either3::A(StandardTestKind {
                         consumed_gas: BigInt::from(gas_consumed),
                     })
@@ -283,11 +283,27 @@ impl TestResult {
                     runs,
                     calls,
                     reverts,
+                    metrics,
+                    failed_corpus_replays,
                 } => Either3::C(InvariantTestKind {
                     // usize as u64 is always safe
                     runs: BigInt::from(runs as u64),
                     calls: BigInt::from(calls as u64),
                     reverts: BigInt::from(reverts as u64),
+                    metrics: metrics
+                        .into_iter()
+                        .map(|(name, metric)| {
+                            (
+                                name,
+                                InvariantMetrics {
+                                    calls: BigInt::from(metric.calls as u64),
+                                    reverts: BigInt::from(metric.reverts as u64),
+                                    discards: BigInt::from(metric.discards as u64),
+                                },
+                            )
+                        })
+                        .collect(),
+                    failed_corpus_replays: BigInt::from(failed_corpus_replays as u64),
                 }),
             },
             duration_ns: BigInt::from(test_result.duration.as_nanos()),
@@ -336,7 +352,7 @@ impl From<edr_solidity_tests::result::TestStatus> for TestStatus {
     }
 }
 
-/// See [`edr_solidity_tests::result::TestKind::Standard`]
+/// See [`edr_solidity_tests::result::TestKind::Unit`]
 #[napi(object)]
 #[derive(Debug, Clone)]
 pub struct StandardTestKind {
@@ -397,6 +413,27 @@ pub struct InvariantTestKind {
     /// See [`edr_solidity_tests::result::TestKind::Invariant`]
     #[napi(readonly)]
     pub reverts: BigInt,
+    /// See [`edr_solidity_tests::result::TestKind::Invariant`]
+    #[napi(readonly)]
+    pub metrics: std::collections::HashMap<String, InvariantMetrics>,
+    /// See [`edr_solidity_tests::result::TestKind::Invariant`]
+    #[napi(readonly)]
+    pub failed_corpus_replays: BigInt,
+}
+
+/// See [`edr_solidity_tests::result::InvariantMetrics`]
+#[napi(object)]
+#[derive(Debug, Clone)]
+pub struct InvariantMetrics {
+    // Count of fuzzed selector calls.
+    #[napi(readonly)]
+    pub calls: BigInt,
+    // Count of fuzzed selector reverts.
+    #[napi(readonly)]
+    pub reverts: BigInt,
+    // Count of fuzzed selector discards (through assume cheatcodes).
+    #[napi(readonly)]
+    pub discards: BigInt,
 }
 
 /// Original sequence size and sequence of calls used as a counter example
@@ -543,10 +580,19 @@ impl CallTrace {
     /// Instantiates a `CallTrace` with the details from a node and the supplied
     /// children.
     fn new(node: &traces::CallTraceNode, children: Vec<Either<CallTrace, LogTrace>>) -> Self {
-        let contract = node.trace.decoded.label.clone();
+        let contract = node
+            .trace
+            .decoded
+            .as_ref()
+            .and_then(|decoded| decoded.label.clone());
         let address = node.trace.address.to_checksum(None);
 
-        let inputs = match &node.trace.decoded.call_data {
+        let inputs = match &node
+            .trace
+            .decoded
+            .as_ref()
+            .and_then(|decoded| decoded.call_data.as_ref())
+        {
             Some(traces::DecodedCallData { signature, args }) => {
                 let name = signature
                     .split('(')
@@ -559,7 +605,12 @@ impl CallTrace {
             None => Either::B(node.trace.data.as_ref().into()),
         };
 
-        let outputs = match &node.trace.decoded.return_data {
+        let outputs = match node
+            .trace
+            .decoded
+            .as_ref()
+            .and_then(|decoded| decoded.return_data.as_ref())
+        {
             Some(outputs) => Either::A(outputs.clone()),
             None => {
                 if node.kind().is_any_create() && node.trace.success {
@@ -676,7 +727,10 @@ impl CallTrace {
 
 impl From<&traces::CallLog> for LogTrace {
     fn from(log: &traces::CallLog) -> Self {
-        let decoded_log = log.decoded.name.clone().zip(log.decoded.params.as_ref());
+        let decoded_log = log
+            .decoded
+            .as_ref()
+            .and_then(|decoded| decoded.name.clone().zip(decoded.params.as_ref()));
 
         let parameters = decoded_log.map_or_else(
             || {

package/src/trace/exit.rs

@@ -3,7 +3,7 @@
 
 use std::fmt;
 
-use edr_evm_spec::EvmHaltReason;
+use edr_chain_spec::EvmHaltReason;
 use napi_derive::napi;
 
 #[napi]

package/src/trace.rs

@@ -7,9 +7,9 @@
 
 use std::sync::Arc;
 
-use edr_evm::trace::BeforeMessage;
-use edr_evm_spec::EvmHaltReason;
+use edr_chain_spec::EvmHaltReason;
 use edr_primitives::bytecode::opcode::OpCode;
+use edr_runtime::trace::BeforeMessage;
 use napi::bindgen_prelude::{BigInt, Either3, Uint8Array};
 use napi_derive::napi;
 
@@ -123,7 +123,7 @@ pub struct TracingStep {
 }
 
 impl TracingStep {
-    pub fn new(step: &edr_evm::trace::Step) -> Self {
+    pub fn new(step: &edr_runtime::trace::Step) -> Self {
         let stack = step.stack.full().map_or_else(
             || {
                 step.stack
@@ -162,11 +162,11 @@ pub struct TracingMessageResult {
 #[napi]
 #[derive(Clone)]
 pub struct RawTrace {
-    inner: Arc<edr_evm::trace::Trace<EvmHaltReason>>,
+    inner: Arc<edr_runtime::trace::Trace<EvmHaltReason>>,
 }
 
-impl From<Arc<edr_evm::trace::Trace<EvmHaltReason>>> for RawTrace {
-    fn from(value: Arc<edr_evm::trace::Trace<EvmHaltReason>>) -> Self {
+impl From<Arc<edr_runtime::trace::Trace<EvmHaltReason>>> for RawTrace {
+    fn from(value: Arc<edr_runtime::trace::Trace<EvmHaltReason>>) -> Self {
         Self { inner: value }
     }
 }
@@ -179,13 +179,15 @@ impl RawTrace {
             .messages
             .iter()
             .map(|message| match message {
-                edr_evm::trace::TraceMessage::Before(message) => {
+                edr_runtime::trace::TraceMessage::Before(message) => {
                     Either3::A(TracingMessage::from(message))
                 }
-                edr_evm::trace::TraceMessage::Step(step) => Either3::B(TracingStep::new(step)),
-                edr_evm::trace::TraceMessage::After(message) => Either3::C(TracingMessageResult {
-                    execution_result: ExecutionResult::from(message),
-                }),
+                edr_runtime::trace::TraceMessage::Step(step) => Either3::B(TracingStep::new(step)),
+                edr_runtime::trace::TraceMessage::After(message) => {
+                    Either3::C(TracingMessageResult {
+                        execution_result: ExecutionResult::from(message),
+                    })
+                }
             })
             .collect()
     }