@nomicfoundation/edr 0.12.0-next.14 → 0.12.0-next.16

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,
@@ -333,6 +336,14 @@ export interface ProviderConfig {
   ownedAccounts: Array<string>
   /** Overrides for precompiles */
   precompileOverrides: Array<Precompile>
+  /**
+   * Transaction gas cap, introduced in [EIP-7825].
+   *
+   * When not set, will default to value defined by the used hardfork
+   *
+   * [EIP-7825]: https://eips.ethereum.org/EIPS/eip-7825
+   */
+  transactionGasCap?: bigint
 }
 /** Tracing config for Solidity stack trace generation. */
 export interface TracingConfigWithBuffers {
@@ -586,8 +597,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 +847,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 +1018,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 +1049,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.14",
+  "version": "0.12.0-next.16",
   "devDependencies": {
     "@napi-rs/cli": "^2.18.4",
     "@nomicfoundation/ethereumjs-util": "^9.0.4",
@@ -58,13 +58,13 @@
   "repository": "NomicFoundation/edr.git",
   "types": "index.d.ts",
   "dependencies": {
-    "@nomicfoundation/edr-darwin-arm64": "0.12.0-next.14",
-    "@nomicfoundation/edr-darwin-x64": "0.12.0-next.14",
-    "@nomicfoundation/edr-linux-arm64-gnu": "0.12.0-next.14",
-    "@nomicfoundation/edr-linux-arm64-musl": "0.12.0-next.14",
-    "@nomicfoundation/edr-linux-x64-gnu": "0.12.0-next.14",
-    "@nomicfoundation/edr-linux-x64-musl": "0.12.0-next.14",
-    "@nomicfoundation/edr-win32-x64-msvc": "0.12.0-next.14"
+    "@nomicfoundation/edr-darwin-arm64": "0.12.0-next.16",
+    "@nomicfoundation/edr-darwin-x64": "0.12.0-next.16",
+    "@nomicfoundation/edr-linux-arm64-gnu": "0.12.0-next.16",
+    "@nomicfoundation/edr-linux-arm64-musl": "0.12.0-next.16",
+    "@nomicfoundation/edr-linux-x64-gnu": "0.12.0-next.16",
+    "@nomicfoundation/edr-linux-x64-musl": "0.12.0-next.16",
+    "@nomicfoundation/edr-win32-x64-msvc": "0.12.0-next.16"
   },
   "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

@@ -135,6 +135,8 @@ pub enum SpecId {
     Cancun = 17,
     /// Prague
     Prague = 18,
+    /// Osaka
+    Osaka = 19,
 }
 
 impl FromStr for SpecId {
@@ -161,6 +163,7 @@ impl FromStr for SpecId {
             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,
         }
     }
 }
@@ -225,6 +229,7 @@ pub fn l1_hardfork_to_string(harfork: SpecId) -> &'static str {
         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,
     }
 }
 
@@ -264,5 +269,6 @@ export_spec_id!(
     MERGE,
     SHANGHAI,
     CANCUN,
-    PRAGUE
+    PRAGUE,
+    OSAKA
 );

package/src/chains/op.rs

@@ -8,7 +8,8 @@ use edr_napi_core::{
 use edr_op::{
     predeploys::{
         gas_price_oracle_code_ecotone, gas_price_oracle_code_fjord, gas_price_oracle_code_isthmus,
-        GAS_PRICE_ORACLE_ADDRESS,
+        l1_block_code_bedrock, l1_block_code_ecotone, l1_block_code_isthmus,
+        GAS_PRICE_ORACLE_ADDRESS, L1_BLOCK_PREDEPLOY_ADDRESS,
     },
     OpChainSpec,
 };
@@ -143,72 +144,13 @@ pub const OP_CHAIN_TYPE: &str = edr_op::CHAIN_TYPE;
 
 #[napi(catch_unwind)]
 pub fn op_genesis_state(hardfork: OpHardfork) -> Vec<AccountOverride> {
-    let l1_block_code = hex::decode(include_str!("../../data/op/predeploys/l1_block.txt"))
-        .expect("The bytecode for the L1Block predeploy should be a valid hex string");
+    let l1_block_code = l1_block_code(hardfork.into());
     let l1_block = AccountOverride {
-        address: hex!("4200000000000000000000000000000000000015").into(),
+        address: Uint8Array::with_data_copied(L1_BLOCK_PREDEPLOY_ADDRESS),
         balance: Some(BigInt::from(0u64)),
         nonce: Some(BigInt::from(0u64)),
-        code: Some(l1_block_code.into()),
-        storage: Some(vec![
-            StorageSlot {
-                index: BigInt::from(0u64),
-                // uint64 public number = 1
-                // uint64 public timestamp = 1
-                value: BigInt {
-                    words: vec![
-                        0x0000000000000001_u64, // least significative
-                        0x0000000000000001_u64,
-                    ],
-                    sign_bit: false,
-                },
-            },
-            StorageSlot {
-                index: BigInt::from(1u64),
-                // uint256 baseFee = 10 gwei
-                value: BigInt::from(0x00000002540be400_u64),
-            },
-            StorageSlot {
-                index: BigInt::from(2u64),
-                // bytes32 hash = 0
-                value: BigInt::from(0u64),
-            },
-            StorageSlot {
-                index: BigInt::from(3u64),
-                // uint64 sequenceNumber = 0
-                // uint32 blobBaseFeeScalar = 1014213
-                // uint32 baseFeeScalar = 5227
-                value: BigInt {
-                    words: vec![
-                        0x0000000000000000_u64, // least significative
-                        0x0000000000000000_u64,
-                        0x00000000000f79c5_u64,
-                        0x000000000000146b_u64,
-                    ],
-                    sign_bit: false,
-                },
-            },
-            StorageSlot {
-                index: BigInt::from(4u64),
-                // bytes32 batcherHash = 0
-                value: BigInt::from(0u64),
-            },
-            StorageSlot {
-                index: BigInt::from(5u64),
-                // uint256 l1FeeOverhead = 0
-                value: BigInt::from(0u64),
-            },
-            StorageSlot {
-                index: BigInt::from(6u64),
-                // uint256 l1FeeScalar = 0
-                value: BigInt::from(0u64),
-            },
-            StorageSlot {
-                index: BigInt::from(7u64),
-                // uint256 blobBaseFee = 10 gwei
-                value: BigInt::from(0x00000002540be400_u64),
-            },
-        ]),
+        code: Some(l1_block_code),
+        storage: Some(l1_block_storage(hardfork.into())),
     };
 
     /* The rest of the predeploys use a stubbed bytecode that reverts with a
@@ -315,6 +257,11 @@ pub fn op_genesis_state(hardfork: OpHardfork) -> Vec<AccountOverride> {
             hex!("4200000000000000000000000000000000000021"),
             "0x60806040526040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401603490607b565b60405180910390fd5b60006048601f836099565b91507f5072656465706c6f7920454153206973206e6f7420737570706f727465642e006000830152602082019050919050565b60006020820190508181036000830152609281603d565b9050919050565b60008282526020820190509291505056fea2646970667358221220afa6c1aa54a8b3f4f979e1297db5838a94353f3b77b5ecc164da19db26ea89f564736f6c63430008000033",
         ),
+        (
+            "OperatorFeeVault",
+            hex!("0x420000000000000000000000000000000000001b"),
+            "0x60806040526040517f08c379a000000000000000000000000000000000000000000000000000000000815260040160349060b9565b60405180910390fd5b5f82825260208201905092915050565b7f5072656465706c6f79204f70657261746f724665655661756c74206973206e6f5f8201527f7420737570706f727465642e0000000000000000000000000000000000000000602082015250565b5f60a5602c83603d565b915060ae82604d565b604082019050919050565b5f6020820190508181035f83015260ce81609b565b905091905056fea2646970667358221220dc3131d0ea77326c36012aee5dd9a870b6f07d76e6f55c8029da9d70a83f50c364736f6c634300081e0033",
+        ),
     ];
 
     let stubbed_predeploys = stubbed_predeploys_data
@@ -402,6 +349,85 @@ fn gas_price_oracle_isthmus() -> AccountOverride {
         }]),
     }
 }
+fn l1_block_storage(hardfork: edr_op::Hardfork) -> Vec<StorageSlot> {
+    let mut base_storage = vec![
+        StorageSlot {
+            index: BigInt::from(0u64),
+            // uint64 public number = 1
+            // uint64 public timestamp = 1
+            value: BigInt {
+                words: vec![
+                    0x0000000000000001_u64, // least significative
+                    0x0000000000000001_u64,
+                ],
+                sign_bit: false,
+            },
+        },
+        StorageSlot {
+            index: BigInt::from(1u64),
+            // uint256 baseFee = 10 gwei
+            value: BigInt::from(0x00000002540be400_u64),
+        },
+        StorageSlot {
+            index: BigInt::from(2u64),
+            // bytes32 hash = 0
+            value: BigInt::from(0u64),
+        },
+        StorageSlot {
+            index: BigInt::from(3u64),
+            // uint64 sequenceNumber = 0
+            // uint32 blobBaseFeeScalar = 1014213
+            // uint32 baseFeeScalar = 5227
+            value: BigInt {
+                words: vec![
+                    0x0000000000000000_u64, // least significative
+                    0x0000000000000000_u64,
+                    0x00000000000f79c5_u64,
+                    0x000000000000146b_u64,
+                ],
+                sign_bit: false,
+            },
+        },
+        StorageSlot {
+            index: BigInt::from(4u64),
+            // bytes32 batcherHash = 0
+            value: BigInt::from(0u64),
+        },
+        StorageSlot {
+            index: BigInt::from(5u64),
+            // uint256 l1FeeOverhead = 0
+            value: BigInt::from(0u64),
+        },
+        StorageSlot {
+            index: BigInt::from(6u64),
+            // uint256 l1FeeScalar = 0
+            value: BigInt::from(0u64),
+        },
+        StorageSlot {
+            index: BigInt::from(7u64),
+            // uint256 blobBaseFee = 10 gwei
+            value: BigInt::from(0x00000002540be400_u64),
+        },
+    ];
+    if hardfork >= edr_op::Hardfork::ISTHMUS {
+        base_storage.push(StorageSlot {
+            // Operator fee parameters
+            index: BigInt::from(8u64),
+            value: BigInt::from(0u64),
+        });
+    }
+    base_storage
+}
+
+fn l1_block_code(hardfork: edr_op::Hardfork) -> Uint8Array {
+    if hardfork >= edr_op::Hardfork::ISTHMUS {
+        l1_block_code_isthmus().into()
+    } else if hardfork >= edr_op::Hardfork::ECOTONE {
+        l1_block_code_ecotone().into()
+    } else {
+        l1_block_code_bedrock().into()
+    }
+}
 
 macro_rules! export_spec_id {
     ($($variant:ident,)*) => {

package/src/config.rs

@@ -242,6 +242,12 @@ pub struct ProviderConfig {
     pub owned_accounts: Vec<JsString>,
     /// Overrides for precompiles
     pub precompile_overrides: Vec<Reference<Precompile>>,
+    /// Transaction gas cap, introduced in [EIP-7825].
+    ///
+    /// When not set, will default to value defined by the used hardfork
+    ///
+    /// [EIP-7825]: https://eips.ethereum.org/EIPS/eip-7825
+    pub transaction_gas_cap: Option<BigInt>,
 }
 
 impl TryFrom<ForkConfig> for edr_provider::ForkConfig<String> {
@@ -339,7 +345,7 @@ impl From<MemPoolConfig> for edr_provider::MemPoolConfig {
     }
 }
 
-impl From<MineOrdering> for edr_runtime::MineOrdering {
+impl From<MineOrdering> for edr_block_miner::MineOrdering {
     fn from(value: MineOrdering) -> Self {
         match value {
             MineOrdering::Fifo => Self::Fifo,
@@ -619,6 +625,10 @@ impl ProviderConfig {
             observability: self.observability.resolve(env, runtime)?,
             owned_accounts,
             precompile_overrides,
+            transaction_gas_cap: self
+                .transaction_gas_cap
+                .map(TryCast::try_cast)
+                .transpose()?,
         })
     }
 }

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/precompile.rs

@@ -1,4 +1,4 @@
-use edr_precompile::{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(),
         }
     }
 }

package/src/result.rs

@@ -1,5 +1,5 @@
 use edr_chain_spec::EvmHaltReason;
-use edr_runtime::trace::AfterMessage;
+use edr_tracing::AfterMessage;
 use napi::{
     bindgen_prelude::{BigInt, Either3, Uint8Array},
     Either,
@@ -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 => {
@@ -198,7 +200,7 @@ impl From<&AfterMessage<EvmHaltReason>> for ExecutionResult {
             }
             edr_evm_spec::result::ExecutionResult::Halt { reason, gas_used } => {
                 Either3::C(HaltResult {
-                    reason: ExceptionalHalt::from(*reason),
+                    reason: ExceptionalHalt::from(reason.clone()),
                     gas_used: BigInt::from(*gas_used),
                 })
             }

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/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.rs

@@ -9,7 +9,7 @@ use std::sync::Arc;
 
 use edr_chain_spec::EvmHaltReason;
 use edr_primitives::bytecode::opcode::OpCode;
-use edr_runtime::trace::BeforeMessage;
+use edr_tracing::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_runtime::trace::Step) -> Self {
+    pub fn new(step: &edr_tracing::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_runtime::trace::Trace<EvmHaltReason>>,
+    inner: Arc<edr_tracing::Trace<EvmHaltReason>>,
 }
 
-impl From<Arc<edr_runtime::trace::Trace<EvmHaltReason>>> for RawTrace {
-    fn from(value: Arc<edr_runtime::trace::Trace<EvmHaltReason>>) -> Self {
+impl From<Arc<edr_tracing::Trace<EvmHaltReason>>> for RawTrace {
+    fn from(value: Arc<edr_tracing::Trace<EvmHaltReason>>) -> Self {
         Self { inner: value }
     }
 }
@@ -179,15 +179,13 @@ impl RawTrace {
             .messages
             .iter()
             .map(|message| match message {
-                edr_runtime::trace::TraceMessage::Before(message) => {
+                edr_tracing::TraceMessage::Before(message) => {
                     Either3::A(TracingMessage::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),
-                    })
-                }
+                edr_tracing::TraceMessage::Step(step) => Either3::B(TracingStep::new(step)),
+                edr_tracing::TraceMessage::After(message) => Either3::C(TracingMessageResult {
+                    execution_result: ExecutionResult::from(message),
+                }),
             })
             .collect()
     }