Merge pull request #8371 from gultekinmakif/fix/genesis-state-merge

fix(network-manager): genesis-state merge map should use hex string

Author: schaable

.changeset/fair-mares-rest.md

@@ -0,0 +1,5 @@
+---
+"hardhat": patch
+---
+
+Account overrides that share an address with the network's built-in genesis accounts are now correctly merged into a single genesis entry.

packages/hardhat/src/internal/builtin-plugins/network-manager/edr/genesis-state.ts

@@ -12,6 +12,7 @@ import {
   opHardforkFromString,
   type AccountOverride,
 } from "@nomicfoundation/edr";
+import { bytesToHexString } from "@nomicfoundation/hardhat-utils/hex";
 import { AsyncMutex } from "@nomicfoundation/hardhat-utils/synchronization";
 import { hexToBytes } from "ethereum-cryptography/utils";
 
@@ -50,7 +51,7 @@ const genesisStateAndAccountsCache: WeakMap<
       Map<
         string,
         {
-          genesisState: Map<Uint8Array, AccountOverride>;
+          genesisState: Map<string, AccountOverride>;
           ownedAccounts: Array<{ secretKey: string; balance: bigint }>;
         }
       >
@@ -66,7 +67,7 @@ export async function getGenesisStateAndOwnedAccounts(
   chainType: ChainType,
   specId: string,
 ): Promise<{
-  genesisState: Map<Uint8Array, AccountOverride>;
+  genesisState: Map<string, AccountOverride>;
   ownedAccounts: Array<{ secretKey: string; balance: bigint }>;
 }> {
   const cached = genesisStateAndAccountsCache
@@ -131,7 +132,7 @@ async function createGenesisStateAndOwnedAccounts(
   chainType: ChainType,
   specId: string,
 ): Promise<{
-  genesisState: Map<Uint8Array, AccountOverride>;
+  genesisState: Map<string, AccountOverride>;
   ownedAccounts: Array<{ secretKey: string; balance: bigint }>;
 }> {
   if (microEthSignerAddress === undefined) {
@@ -142,7 +143,7 @@ async function createGenesisStateAndOwnedAccounts(
 
   const ownedAccounts = await hardhatAccountsToEdrOwnedAccounts(accountsConfig);
 
-  const genesisState: Map<Uint8Array, AccountOverride> = new Map(
+  const genesisState: Map<string, AccountOverride> = new Map(
     ownedAccounts.map(({ secretKey, balance }) => {
       const address = hexToBytes(addr.fromPrivateKey(secretKey));
       const accountOverride: AccountOverride = {
@@ -151,7 +152,7 @@ async function createGenesisStateAndOwnedAccounts(
         code: new Uint8Array(), // Empty account code, removing potential delegation code when forking
       };
 
-      return [address, accountOverride];
+      return [bytesToHexString(address), accountOverride];
     }),
   );
 
@@ -162,18 +163,25 @@ async function createGenesisStateAndOwnedAccounts(
         ? opGenesisState(opHardforkFromString(specId))
         : l1GenesisState(l1HardforkFromString(specId));
 
+  mergeGenesisState(genesisState, chainGenesisState);
+
+  return { genesisState, ownedAccounts };
+}
+
+export function mergeGenesisState(
+  genesisState: Map<string, AccountOverride>,
+  chainGenesisState: readonly AccountOverride[],
+): void {
   for (const account of chainGenesisState) {
-    const existingOverride = genesisState.get(account.address);
+    const addressKey = bytesToHexString(account.address);
+    const existingOverride = genesisState.get(addressKey);
     if (existingOverride !== undefined) {
       // Favor the genesis state specified by the user
-      account.balance = account.balance ?? existingOverride.balance;
-      account.nonce = account.nonce ?? existingOverride.nonce;
-      account.code = account.code ?? existingOverride.code;
-      account.storage = account.storage ?? existingOverride.storage;
-    } else {
-      genesisState.set(account.address, account);
+      account.balance = existingOverride.balance ?? account.balance;
+      account.nonce = existingOverride.nonce ?? account.nonce;
+      account.code = existingOverride.code ?? account.code;
+      account.storage = existingOverride.storage ?? account.storage;
     }
+    genesisState.set(addressKey, account);
   }
-
-  return { genesisState, ownedAccounts };
 }

packages/hardhat/test/internal/builtin-plugins/network-manager/edr/genesis-state.ts

@@ -1,11 +1,17 @@
 import type { EdrNetworkAccountsConfig } from "../../../../../src/types/config.js";
+import type { AccountOverride } from "@nomicfoundation/edr";
 
 import assert from "node:assert/strict";
-import { describe, it } from "node:test";
+import { beforeEach, describe, it } from "node:test";
 
 import { CANCUN, LONDON } from "@nomicfoundation/edr";
+import { bytesToHexString } from "@nomicfoundation/hardhat-utils/hex";
+import { hexToBytes } from "ethereum-cryptography/utils";
 
-import { getGenesisStateAndOwnedAccounts } from "../../../../../src/internal/builtin-plugins/network-manager/edr/genesis-state.js";
+import {
+  getGenesisStateAndOwnedAccounts,
+  mergeGenesisState,
+} from "../../../../../src/internal/builtin-plugins/network-manager/edr/genesis-state.js";
 import { L1_CHAIN_TYPE } from "../../../../../src/internal/constants.js";
 import { FixedValueConfigurationVariable } from "../../../../../src/internal/core/configuration-variables.js";
 
@@ -65,4 +71,47 @@ describe("getGenesisStateAndOwnedAccounts", () => {
     assert.notEqual(result2, result3);
     assert.notEqual(result3, result1);
   });
+
+  describe("mergeGenesisState", () => {
+    const address = hexToBytes("0x0000F90827F1C53a10cb7A02335B175320002935");
+    const addressKey = bytesToHexString(address);
+
+    let genesisState: Map<string, AccountOverride>;
+
+    beforeEach(() => {
+      genesisState = new Map();
+    });
+
+    it("when the chain list is empty, leaves the map untouched", () => {
+      genesisState.set(addressKey, { address, balance: 1n });
+      mergeGenesisState(genesisState, []);
+      assert.equal(genesisState.size, 1);
+      assert.equal(genesisState.get(addressKey)?.balance, 1n);
+    });
+
+    it("when the chain address is not in the map, adds it as a new entry", () => {
+      mergeGenesisState(genesisState, [{ address, balance: 42n }]);
+      assert.equal(genesisState.size, 1);
+      assert.equal(genesisState.get(addressKey)?.balance, 42n);
+    });
+
+    it("when a chain entry collides with an existing override, user wins overlapping fields and chain fills the gaps", () => {
+      genesisState.set(addressKey, { address, balance: 1n, nonce: 1n });
+
+      mergeGenesisState(genesisState, [
+        { address, balance: 9n, code: new Uint8Array([0x99]) },
+      ]);
+
+      const merged = genesisState.get(addressKey);
+      assert.ok(merged !== undefined, "merged entry must exist at the address");
+      assert.equal(genesisState.size, 1, "must not duplicate the entry");
+      assert.equal(merged.balance, 1n, "user wins on overlapping field");
+      assert.equal(merged.nonce, 1n, "user-only field stays");
+      assert.deepEqual(
+        merged.code,
+        new Uint8Array([0x99]),
+        "chain-only field fills in",
+      );
+    });
+  });
 });