feat: add local predeploys for soltests (#969)

Author: agostbiro

.changeset/fluffy-bags-tickle.md

@@ -0,0 +1,5 @@
+---
+"@nomicfoundation/edr": patch
+---
+
+Added support for local pre-deploys for Solidity tests.

.github/workflows/edr-ci.yml

@@ -200,7 +200,7 @@ jobs:
         run: pnpm install --frozen-lockfile --prefer-offline
 
       - name: Build edr_napi
-        run: cd crates/edr_napi && pnpm build:dev
+        run: cd crates/edr_napi && pnpm build:typingFile
 
       - name: Check that there are no uncommitted changes
         run: git diff --exit-code

crates/edr_napi/index.d.ts

@@ -590,6 +590,14 @@ export interface SolidityTestRunnerConfigArgs {
    * Defaults to 33_554_432 (2^25 = 32MiB).
    */
   memoryLimit?: bigint
+  /**
+   * The predeploys applied in local mode. Defaults to no predeploys.
+   * These should match the predeploys of the network in fork mode, so they
+   * aren't set in fork mode.
+   * The code must be set and non-empty. The nonce and the balance default to
+   * zero and storage defaults to empty.
+   */
+  localPredeploys?: Array<AccountOverride>
   /**
    * If set, all tests are run in fork mode using this url or remote name.
    * Defaults to none.

crates/edr_napi/package.json

@@ -54,18 +54,18 @@
   "scripts": {
     "artifacts": "napi artifacts",
     "build": "pnpm run build:publish",
-    "build:debug": "napi build --platform  --no-const-enum",
-    "build:dev": "napi build --platform  --release --no-const-enum",
-    "build:op": "napi build --platform --release --no-const-enum --features op",
+    "build:debug": "napi build --platform  --no-const-enum --features op",
+    "build:dev": "napi build --platform --release --no-const-enum --features op",
     "build:publish": "napi build --platform --profile napi-publish --no-const-enum ",
     "build:scenarios": "napi build --platform --release --no-const-enum --features scenarios",
     "build:tracing": "napi build --platform --release --no-const-enum --features tracing",
+    "build:typingFile": "napi build --platform --no-const-enum",
     "clean": "rm -rf @nomicfoundation/edr.node",
     "eslint": "eslint 'test/**/*.ts'",
     "lint": "pnpm run prettier && pnpm run eslint",
     "lint:fix": "pnpm run prettier --write",
     "prepublishOnly": "bash ../../scripts/prepublish.sh",
-    "pretest": "pnpm build:op",
+    "pretest": "pnpm build:dev",
     "prettier": "prettier --check \"test/**.ts\"",
     "test": "pnpm tsc && node --max-old-space-size=8192 node_modules/mocha/bin/_mocha --recursive \"test/**/*.ts\"",
     "testNoBuild": "pnpm tsc && node --max-old-space-size=8192 node_modules/mocha/bin/_mocha --recursive \"test/**/{,!(op)}.ts\"",

crates/edr_napi/src/account.rs

@@ -1,28 +1,120 @@
+use edr_eth::{HashMap, U256};
+use edr_solidity_tests::{backend::Predeploy, revm::state::AccountInfo};
 use napi::bindgen_prelude::{BigInt, Uint8Array};
 use napi_derive::napi;
 
+use crate::{
+    cast::TryCast,
+    serde::{
+        serialize_bigint_as_struct, serialize_optional_bigint_as_struct,
+        serialize_optional_uint8array_as_hex, serialize_uint8array_as_hex,
+    },
+};
+
 /// Specification of overrides for an account and its storage.
 #[napi(object)]
+#[derive(Clone, serde::Serialize)]
 pub struct AccountOverride {
     /// The account's address
+    #[serde(serialize_with = "serialize_uint8array_as_hex")]
     pub address: Uint8Array,
     /// If present, the overwriting balance.
+    #[serde(serialize_with = "serialize_optional_bigint_as_struct")]
     pub balance: Option<BigInt>,
     /// If present, the overwriting nonce.
+    #[serde(serialize_with = "serialize_optional_bigint_as_struct")]
     pub nonce: Option<BigInt>,
     /// If present, the overwriting code.
+    #[serde(serialize_with = "serialize_optional_uint8array_as_hex")]
     pub code: Option<Uint8Array>,
     /// BEWARE: This field is not supported yet. See <https://github.com/NomicFoundation/edr/issues/911>
     ///
     /// If present, the overwriting storage.
     pub storage: Option<Vec<StorageSlot>>,
 }
 
+impl TryFrom<AccountOverride> for (edr_eth::Address, edr_provider::AccountOverride) {
+    type Error = napi::Error;
+
+    fn try_from(value: AccountOverride) -> Result<Self, Self::Error> {
+        let AccountOverride {
+            address,
+            balance,
+            nonce,
+            code,
+            storage,
+        } = value;
+        let storage = storage
+            .map(|storage| {
+                storage
+                    .into_iter()
+                    .map(|StorageSlot { index, value }| {
+                        let value = value.try_cast()?;
+                        let slot = edr_evm::state::EvmStorageSlot::new(value);
+
+                        let index: edr_eth::U256 = index.try_cast()?;
+                        Ok((index, slot))
+                    })
+                    .collect::<napi::Result<_>>()
+            })
+            .transpose()?;
+
+        let account_override = edr_provider::AccountOverride {
+            balance: balance.map(TryCast::try_cast).transpose()?,
+            nonce: nonce.map(TryCast::try_cast).transpose()?,
+            code: code.map(TryCast::try_cast).transpose()?,
+            storage,
+        };
+
+        let address: edr_eth::Address = address.try_cast()?;
+
+        Ok((address, account_override))
+    }
+}
+
+impl TryFrom<AccountOverride> for Predeploy {
+    type Error = napi::Error;
+
+    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 balance = account_override.balance.unwrap_or(U256::ZERO);
+        let nonce = account_override.nonce.unwrap_or(0);
+        let code = account_override.code.ok_or_else(|| {
+            napi::Error::from_reason(format!("Predeploy with address '{address}' must have code"))
+        })?;
+
+        if code.is_empty() {
+            return Err(napi::Error::from_reason(
+                "Predeploy with address '{address}' must have non-empty code",
+            ));
+        }
+        let code_hash = code.hash_slow();
+
+        let account_info = AccountInfo {
+            balance,
+            nonce,
+            code_hash,
+            code: Some(code),
+        };
+
+        Ok(Self {
+            address,
+            account_info,
+            storage,
+        })
+    }
+}
+
 /// A description of a storage slot's state.
 #[napi(object)]
+#[derive(Clone, serde::Serialize)]
 pub struct StorageSlot {
     /// The storage slot's index
+    #[serde(serialize_with = "serialize_bigint_as_struct")]
     pub index: BigInt,
     /// The storage slot's value
+    #[serde(serialize_with = "serialize_bigint_as_struct")]
     pub value: BigInt,
 }

crates/edr_napi/src/config.rs

@@ -7,7 +7,7 @@ use std::{
 
 use edr_eth::{
     signature::{secret_key_from_str, SecretKey},
-    Bytes, HashSet,
+    Bytes, HashMap, HashSet,
 };
 use edr_provider::coverage::SyncOnCollectedCoverageCallback;
 use napi::{
@@ -19,12 +19,7 @@ use napi::{
 };
 use napi_derive::napi;
 
-use crate::{
-    account::{AccountOverride, StorageSlot},
-    block::BlobGas,
-    cast::TryCast,
-    precompile::Precompile,
-};
+use crate::{account::AccountOverride, block::BlobGas, cast::TryCast, precompile::Precompile};
 
 /// Specification of a chain with possible overrides.
 #[napi(object)]
@@ -437,42 +432,8 @@ impl ProviderConfig {
         let genesis_state = self
             .genesis_state
             .into_iter()
-            .map(
-                |AccountOverride {
-                     address,
-                     balance,
-                     nonce,
-                     code,
-                     storage,
-                 }| {
-                    let storage = storage
-                        .map(|storage| {
-                            storage
-                                .into_iter()
-                                .map(|StorageSlot { index, value }| {
-                                    let value = value.try_cast()?;
-                                    let slot = edr_evm::state::EvmStorageSlot::new(value);
-
-                                    let index: edr_eth::U256 = index.try_cast()?;
-                                    Ok((index, slot))
-                                })
-                                .collect::<napi::Result<_>>()
-                        })
-                        .transpose()?;
-
-                    let account_override = edr_provider::AccountOverride {
-                        balance: balance.map(TryCast::try_cast).transpose()?,
-                        nonce: nonce.map(TryCast::try_cast).transpose()?,
-                        code: code.map(TryCast::try_cast).transpose()?,
-                        storage,
-                    };
-
-                    let address: edr_eth::Address = address.try_cast()?;
-
-                    Ok((address, account_override))
-                },
-            )
-            .collect::<napi::Result<_>>()?;
+            .map(TryInto::try_into)
+            .collect::<napi::Result<HashMap<edr_eth::Address, edr_provider::AccountOverride>>>()?;
 
         let precompile_overrides = self
             .precompile_overrides

crates/edr_napi/src/solidity_tests/config.rs

@@ -15,6 +15,7 @@ use napi::{
 use napi_derive::napi;
 
 use crate::{
+    account::AccountOverride,
     cast::TryCast,
     serde::{
         serialize_optional_bigint_as_struct, serialize_optional_uint8array_as_hex,
@@ -102,6 +103,12 @@ pub struct SolidityTestRunnerConfigArgs {
     /// Defaults to 33_554_432 (2^25 = 32MiB).
     #[serde(serialize_with = "serialize_optional_bigint_as_struct")]
     pub memory_limit: Option<BigInt>,
+    /// The predeploys applied in local mode. Defaults to no predeploys.
+    /// These should match the predeploys of the network in fork mode, so they
+    /// aren't set in fork mode.
+    /// The code must be set and non-empty. The nonce and the balance default to
+    /// zero and storage defaults to empty.
+    pub local_predeploys: Option<Vec<AccountOverride>>,
     /// If set, all tests are run in fork mode using this url or remote name.
     /// Defaults to none.
     pub eth_rpc_url: Option<String>,
@@ -194,6 +201,7 @@ impl TryFrom<SolidityTestRunnerConfigArgs> for edr_napi_core::solidity::config::
             block_gas_limit,
             disable_block_gas_limit,
             memory_limit,
+            local_predeploys,
             eth_rpc_url,
             rpc_cache_path,
             fork_block_number,
@@ -216,6 +224,15 @@ impl TryFrom<SolidityTestRunnerConfigArgs> for edr_napi_core::solidity::config::
                 .transpose()?,
         };
 
+        let local_predeploys = local_predeploys
+            .map(|local_predeploys| {
+                local_predeploys
+                    .into_iter()
+                    .map(TryInto::try_into)
+                    .collect::<Result<Vec<_>, _>>()
+            })
+            .transpose()?;
+
         let invariant: InvariantConfig = fuzz
             .as_ref()
             .map(|f| invariant.clone().unwrap_or_default().defaults_from_fuzz(f))
@@ -278,6 +295,7 @@ impl TryFrom<SolidityTestRunnerConfigArgs> for edr_napi_core::solidity::config::
             block_gas_limit: block_gas_limit.map(TryCast::try_cast).transpose()?,
             disable_block_gas_limit,
             memory_limit: memory_limit.map(TryCast::try_cast).transpose()?,
+            local_predeploys,
             fork_url: eth_rpc_url,
             fork_block_number: fork_block_number.map(TryCast::try_cast).transpose()?,
             cheatcode,

crates/edr_napi/src/solidity_tests/l1.rs

@@ -42,7 +42,7 @@ impl SyncTestRunnerFactory for L1TestRunnerFactory {
                     edr_eth::l1::InvalidTransaction,
                     TxEnv,
                 >::new(
-                    config.into(),
+                    config.try_into()?,
                     contracts,
                     known_contracts,
                     libs_to_deploy,

crates/edr_napi/src/solidity_tests/op.rs

@@ -43,7 +43,7 @@ impl SyncTestRunnerFactory for OpTestRunnerFactory {
                     edr_op::transaction::InvalidTransaction,
                     edr_op::transaction::OpTxEnv<edr_eth::l1::TxEnv>,
                 >::new(
-                    config.into(),
+                    config.try_into()?,
                     contracts,
                     known_contracts,
                     libs_to_deploy,

crates/edr_napi_core/src/solidity/config.rs

@@ -2,6 +2,7 @@ use std::path::PathBuf;
 
 use edr_eth::{Address, U256};
 use edr_solidity_tests::{
+    backend::Predeploy,
     evm_context::HardforkTr,
     fuzz::{invariant::InvariantConfig, FuzzConfig},
     inspectors::cheatcodes::CheatsConfigOptions,
@@ -144,6 +145,10 @@ pub struct TestRunnerConfig {
     /// The memory limit of the EVM in bytes.
     /// Defaults to `33_554_432` (2^25 = 32MiB).
     pub memory_limit: Option<u64>,
+    /// The predeploys applied in local mode. Defaults to no predeploys.
+    /// These should match the predeploys of the network in fork mode, so they
+    /// aren't set in fork mode.
+    pub local_predeploys: Option<Vec<Predeploy>>,
     /// If set, all tests are run in fork mode using this url or remote name.
     /// Defaults to none.
     pub fork_url: Option<String>,
@@ -165,8 +170,10 @@ pub struct TestRunnerConfig {
     pub test_pattern: TestFilterConfig,
 }
 
-impl<HardforkT: HardforkTr> From<TestRunnerConfig> for SolidityTestRunnerConfig<HardforkT> {
-    fn from(value: TestRunnerConfig) -> Self {
+impl<HardforkT: HardforkTr> TryFrom<TestRunnerConfig> for SolidityTestRunnerConfig<HardforkT> {
+    type Error = napi::Error;
+
+    fn try_from(value: TestRunnerConfig) -> Result<Self, Self::Error> {
         let TestRunnerConfig {
             project_root,
             test_fail,
@@ -186,6 +193,7 @@ impl<HardforkT: HardforkTr> From<TestRunnerConfig> for SolidityTestRunnerConfig<
             block_gas_limit,
             disable_block_gas_limit,
             memory_limit,
+            local_predeploys,
             fork_url,
             fork_block_number,
             cheatcode: cheats_config_options,
@@ -259,18 +267,21 @@ impl<HardforkT: HardforkTr> From<TestRunnerConfig> for SolidityTestRunnerConfig<
             evm_opts.disable_block_gas_limit = disable_block_gas_limit;
         }
 
-        SolidityTestRunnerConfig {
+        let local_predeploys = local_predeploys.unwrap_or_default();
+
+        Ok(SolidityTestRunnerConfig {
             project_root,
             include_traces,
             test_fail,
             // TODO
             coverage: false,
             cheats_config_options,
             evm_opts,
+            local_predeploys,
             fuzz,
             invariant,
             // Solidity fuzz fixtures are not supported by the JS backend
             solidity_fuzz_fixtures: false,
-        }
+        })
     }
 }