hardhat 3.0.0-next.4 → 3.0.0-next.6

package/src/internal/builtin-plugins/network-manager/config-resolution.ts

@@ -18,6 +18,7 @@ import type {
   HttpNetworkConfig,
   HttpNetworkUserConfig,
 } from "../../../types/config.js";
+import type { ChainType } from "../../../types/network.js";
 
 import path from "node:path";
 
@@ -26,12 +27,22 @@ import {
   normalizeHexString,
 } from "@nomicfoundation/hardhat-utils/hex";
 
+import {
+  L1_CHAIN_TYPE,
+  OPTIMISM_CHAIN_TYPE,
+  GENERIC_CHAIN_TYPE,
+} from "../../constants.js";
+
 import { DEFAULT_HD_ACCOUNTS_CONFIG_PARAMS } from "./accounts/constants.js";
 import {
   DEFAULT_EDR_NETWORK_HD_ACCOUNTS_CONFIG_PARAMS,
   EDR_NETWORK_DEFAULT_COINBASE,
 } from "./edr/edr-provider.js";
-import { HardforkName, LATEST_HARDFORK } from "./edr/types/hardfork.js";
+import {
+  getCurrentHardfork,
+  L1HardforkName,
+  OpHardforkName,
+} from "./edr/types/hardfork.js";
 import { isHttpNetworkHdAccountsUserConfig } from "./type-validation.js";
 
 export function resolveHttpNetwork(
@@ -90,6 +101,7 @@ export function resolveEdrNetwork(
     ),
     hardfork: resolveHardfork(
       networkConfig.hardfork,
+      networkConfig.chainType,
       networkConfig.enableTransientStorage,
     ),
     initialBaseFeePerGas: resolveInitialBaseFeePerGas(
@@ -219,117 +231,116 @@ export function resolveCoinbase(
 export function resolveChains(
   chains: EdrNetworkChainsUserConfig | undefined,
 ): EdrNetworkChainsConfig {
+  /**
+   * Block numbers / timestamps were taken from:
+   *
+   * L1 / Generic:
+   * https://github.com/ethereumjs/ethereumjs-monorepo/tree/master/packages/common/src/chains.ts
+   * Op:
+   * https://github.com/ethereum-optimism/superchain-registry/tree/main/superchain/configs/mainnet
+   *
+   * To find hardfork activation blocks by timestamp, use:
+   * https://api-TESTNET.etherscan.io/api?module=block&action=getblocknobytime&timestamp=TIMESTAMP&closest=before&apikey=APIKEY
+   */
   const resolvedChains: EdrNetworkChainsConfig = new Map([
     [
-      // block numbers below were taken from https://github.com/ethereumjs/ethereumjs-monorepo/tree/master/packages/common/src/chains
       1, // mainnet
       {
+        chainType: L1_CHAIN_TYPE,
         hardforkHistory: new Map([
-          [HardforkName.FRONTIER, 0],
-          [HardforkName.HOMESTEAD, 1_150_000],
-          [HardforkName.DAO, 1_920_000],
-          [HardforkName.TANGERINE_WHISTLE, 2_463_000],
-          [HardforkName.SPURIOUS_DRAGON, 2_675_000],
-          [HardforkName.BYZANTIUM, 4_370_000],
-          [HardforkName.CONSTANTINOPLE, 7_280_000],
-          [HardforkName.PETERSBURG, 7_280_000],
-          [HardforkName.ISTANBUL, 9_069_000],
-          [HardforkName.MUIR_GLACIER, 9_200_000],
-          [HardforkName.BERLIN, 1_2244_000],
-          [HardforkName.LONDON, 12_965_000],
-          [HardforkName.ARROW_GLACIER, 13_773_000],
-          [HardforkName.GRAY_GLACIER, 15_050_000],
-          [HardforkName.MERGE, 15_537_394],
-          [HardforkName.SHANGHAI, 17_034_870],
-          [HardforkName.CANCUN, 19_426_589],
+          [L1HardforkName.FRONTIER, 0],
+          [L1HardforkName.HOMESTEAD, 1_150_000],
+          [L1HardforkName.DAO, 1_920_000],
+          [L1HardforkName.TANGERINE_WHISTLE, 2_463_000],
+          [L1HardforkName.SPURIOUS_DRAGON, 2_675_000],
+          [L1HardforkName.BYZANTIUM, 4_370_000],
+          [L1HardforkName.CONSTANTINOPLE, 7_280_000],
+          [L1HardforkName.PETERSBURG, 7_280_000],
+          [L1HardforkName.ISTANBUL, 9_069_000],
+          [L1HardforkName.MUIR_GLACIER, 9_200_000],
+          [L1HardforkName.BERLIN, 1_2244_000],
+          [L1HardforkName.LONDON, 12_965_000],
+          [L1HardforkName.ARROW_GLACIER, 13_773_000],
+          [L1HardforkName.GRAY_GLACIER, 15_050_000],
+          [L1HardforkName.MERGE, 15_537_394],
+          [L1HardforkName.SHANGHAI, 17_034_870],
+          [L1HardforkName.CANCUN, 19_426_589],
         ]),
       },
     ],
     [
-      3, // ropsten
+      5, // goerli
       {
+        chainType: L1_CHAIN_TYPE,
         hardforkHistory: new Map([
-          [HardforkName.BYZANTIUM, 1700000],
-          [HardforkName.CONSTANTINOPLE, 4230000],
-          [HardforkName.PETERSBURG, 4939394],
-          [HardforkName.ISTANBUL, 6485846],
-          [HardforkName.MUIR_GLACIER, 7117117],
-          [HardforkName.BERLIN, 9812189],
-          [HardforkName.LONDON, 10499401],
+          [L1HardforkName.ISTANBUL, 1_561_651],
+          [L1HardforkName.BERLIN, 4_460_644],
+          [L1HardforkName.LONDON, 5_062_605],
         ]),
       },
     ],
     [
-      4, // rinkeby
+      17000, // holesky
       {
+        chainType: L1_CHAIN_TYPE,
         hardforkHistory: new Map([
-          [HardforkName.BYZANTIUM, 1035301],
-          [HardforkName.CONSTANTINOPLE, 3660663],
-          [HardforkName.PETERSBURG, 4321234],
-          [HardforkName.ISTANBUL, 5435345],
-          [HardforkName.BERLIN, 8290928],
-          [HardforkName.LONDON, 8897988],
+          [L1HardforkName.MERGE, 0],
+          [L1HardforkName.SHANGHAI, 6_698],
+          [L1HardforkName.CANCUN, 894_732],
         ]),
       },
     ],
     [
-      5, // goerli
+      560048, // hoodi
       {
+        chainType: L1_CHAIN_TYPE,
         hardforkHistory: new Map([
-          [HardforkName.ISTANBUL, 1561651],
-          [HardforkName.BERLIN, 4460644],
-          [HardforkName.LONDON, 5062605],
+          [L1HardforkName.MERGE, 0],
+          [L1HardforkName.SHANGHAI, 0],
+          [L1HardforkName.CANCUN, 0],
         ]),
       },
     ],
     [
-      42, // kovan
+      11155111, // sepolia
       {
+        chainType: L1_CHAIN_TYPE,
         hardforkHistory: new Map([
-          [HardforkName.BYZANTIUM, 5067000],
-          [HardforkName.CONSTANTINOPLE, 9200000],
-          [HardforkName.PETERSBURG, 10255201],
-          [HardforkName.ISTANBUL, 14111141],
-          [HardforkName.BERLIN, 24770900],
-          [HardforkName.LONDON, 26741100],
+          [L1HardforkName.GRAY_GLACIER, 0],
+          [L1HardforkName.MERGE, 1_450_409],
+          [L1HardforkName.SHANGHAI, 2_990_908],
+          [L1HardforkName.CANCUN, 5_187_023],
         ]),
       },
     ],
     [
-      11155111, // sepolia
+      10, // op mainnet
       {
+        chainType: OPTIMISM_CHAIN_TYPE,
         hardforkHistory: new Map([
-          [HardforkName.GRAY_GLACIER, 0],
-          [HardforkName.MERGE, 1_450_409],
-          [HardforkName.SHANGHAI, 2_990_908],
-          [HardforkName.CANCUN, 5_187_023],
+          [OpHardforkName.BEDROCK, 105_235_063],
+          [OpHardforkName.REGOLITH, 105_235_063],
+          [OpHardforkName.CANYON, 114_696_812],
+          [OpHardforkName.ECOTONE, 117_387_812],
+          [OpHardforkName.FJORD, 122_514_212],
+          [OpHardforkName.GRANITE, 125_235_812],
+          [OpHardforkName.HOLOCENE, 130_423_412],
         ]),
       },
     ],
-    // TODO: the rest of this config is a temporary workaround,
-    // see https://github.com/NomicFoundation/edr/issues/522
-    [
-      10, // optimism mainnet
-      {
-        hardforkHistory: new Map([[HardforkName.SHANGHAI, 0]]),
-      },
-    ],
     [
-      11155420, // optimism sepolia
+      11155420, // op sepolia
       {
-        hardforkHistory: new Map([[HardforkName.SHANGHAI, 0]]),
-      },
-    ],
-    [
-      42161, // arbitrum one
-      {
-        hardforkHistory: new Map([[HardforkName.SHANGHAI, 0]]),
-      },
-    ],
-    [
-      421614, // arbitrum sepolia
-      {
-        hardforkHistory: new Map([[HardforkName.SHANGHAI, 0]]),
+        chainType: OPTIMISM_CHAIN_TYPE,
+        hardforkHistory: new Map([
+          [OpHardforkName.BEDROCK, 0],
+          [OpHardforkName.REGOLITH, 0],
+          [OpHardforkName.CANYON, 4_089_330],
+          [OpHardforkName.ECOTONE, 8_366_130],
+          [OpHardforkName.FJORD, 12_597_930],
+          [OpHardforkName.GRANITE, 15_837_930],
+          [OpHardforkName.HOLOCENE, 20_415_330],
+        ]),
       },
     ],
   ]);
@@ -340,6 +351,7 @@ export function resolveChains(
 
   chains.forEach((chainConfig, chainId) => {
     const resolvedChainConfig: EdrNetworkChainConfig = {
+      chainType: chainConfig.chainType ?? GENERIC_CHAIN_TYPE,
       hardforkHistory: new Map(),
     };
     if (chainConfig.hardforkHistory !== undefined) {
@@ -355,13 +367,14 @@ export function resolveChains(
 
 export function resolveHardfork(
   hardfork: string | undefined,
+  chainType: ChainType | undefined = GENERIC_CHAIN_TYPE,
   _enableTransientStorage: boolean | undefined,
 ): string {
   if (hardfork !== undefined) {
     return hardfork;
   }
 
-  return LATEST_HARDFORK;
+  return getCurrentHardfork(chainType);
 }
 
 export function resolveInitialBaseFeePerGas(

package/src/internal/builtin-plugins/network-manager/edr/edr-context.ts

@@ -4,8 +4,8 @@ import {
   genericChainProviderFactory,
   L1_CHAIN_TYPE,
   l1ProviderFactory,
-  OPTIMISM_CHAIN_TYPE,
-  optimismProviderFactory,
+  OP_CHAIN_TYPE,
+  opProviderFactory,
 } from "@ignored/edr-optimism";
 
 let _globalEdrContext: EdrContext | undefined;
@@ -22,8 +22,8 @@ export async function getGlobalEdrContext(): Promise<EdrContext> {
       l1ProviderFactory(),
     );
     await _globalEdrContext.registerProviderFactory(
-      OPTIMISM_CHAIN_TYPE,
-      optimismProviderFactory(),
+      OP_CHAIN_TYPE,
+      opProviderFactory(),
     );
   }
 

package/src/internal/builtin-plugins/network-manager/edr/edr-provider.ts

@@ -11,6 +11,7 @@ import type {
   RequestArguments,
   SuccessfulJsonRpcResponse,
 } from "../../../../types/providers.js";
+import type { RequireField } from "../../../../types/utils.js";
 import type { DefaultHDAccountsConfigParams } from "../accounts/constants.js";
 import type { JsonRpcRequestWrapperFunction } from "../network-manager.js";
 import type {
@@ -22,8 +23,8 @@ import type {
 } from "@ignored/edr-optimism";
 
 import {
-  optimismGenesisState,
-  optimismHardforkFromString,
+  opGenesisState,
+  opHardforkFromString,
   l1GenesisState,
   l1HardforkFromString,
 } from "@ignored/edr-optimism";
@@ -125,7 +126,7 @@ export const EDR_NETWORK_DEFAULT_PRIVATE_KEYS: string[] = [
 ];
 
 interface EdrProviderConfig {
-  networkConfig: EdrNetworkConfig;
+  networkConfig: RequireField<EdrNetworkConfig, "chainType">;
   loggerConfig?: LoggerConfig;
   tracingConfig?: TracingConfigWithBuffers;
   jsonRpcRequestWrapper?: JsonRpcRequestWrapperFunction;
@@ -382,23 +383,19 @@ export class EdrProvider extends BaseProvider {
 }
 
 async function getProviderConfig(
-  networkConfig: EdrNetworkConfig,
+  networkConfig: RequireField<EdrNetworkConfig, "chainType">,
 ): Promise<ProviderConfig> {
+  const specId = hardhatHardforkToEdrSpecId(
+    networkConfig.hardfork,
+    networkConfig.chainType,
+  );
+
   const genesisState =
     networkConfig.forking !== undefined
       ? [] // TODO: Add support for overriding remote fork state when the local fork is different
       : networkConfig.chainType === "optimism"
-        ? optimismGenesisState(
-            optimismHardforkFromString(
-              // TODO: Optimism conversion is not implemented yet
-              hardhatHardforkToEdrSpecId(networkConfig.hardfork),
-            ),
-          )
-        : l1GenesisState(
-            l1HardforkFromString(
-              hardhatHardforkToEdrSpecId(networkConfig.hardfork),
-            ),
-          );
+        ? opGenesisState(opHardforkFromString(specId))
+        : l1GenesisState(l1HardforkFromString(specId));
 
   return {
     allowBlocksWithSameTimestamp: networkConfig.allowBlocksWithSameTimestamp,
@@ -408,13 +405,16 @@ async function getProviderConfig(
     blockGasLimit: networkConfig.blockGasLimit,
     cacheDir: networkConfig.forking?.cacheDir,
     chainId: BigInt(networkConfig.chainId),
-    chains: hardhatChainsToEdrChains(networkConfig.chains),
+    chains: hardhatChainsToEdrChains(
+      networkConfig.chains,
+      networkConfig.chainType,
+    ),
     // TODO: remove this cast when EDR updates the interface to accept Uint8Array
     coinbase: Buffer.from(networkConfig.coinbase),
     enableRip7212: networkConfig.enableRip7212,
     fork: await hardhatForkingConfigToEdrForkConfig(networkConfig.forking),
     genesisState,
-    hardfork: hardhatHardforkToEdrSpecId(networkConfig.hardfork),
+    hardfork: specId,
     initialBaseFeePerGas: networkConfig.initialBaseFeePerGas,
     initialDate: BigInt(toSeconds(networkConfig.initialDate)),
     minGasPrice: networkConfig.minGasPrice,

package/src/internal/builtin-plugins/network-manager/edr/types/hardfork.ts

@@ -1,4 +1,8 @@
-export enum HardforkName {
+import type { ChainType } from "../../../../../types/network.js";
+
+import { OPTIMISM_CHAIN_TYPE } from "../../../../constants.js";
+
+export enum L1HardforkName {
   FRONTIER = "chainstart",
   HOMESTEAD = "homestead",
   DAO = "dao",
@@ -18,21 +22,84 @@ export enum HardforkName {
   CANCUN = "cancun",
 }
 
-const HARDFORK_ORDER = Object.values(HardforkName);
+export enum OpHardforkName {
+  BEDROCK = "bedrock",
+  REGOLITH = "regolith",
+  CANYON = "canyon",
+  ECOTONE = "ecotone",
+  FJORD = "fjord",
+  GRANITE = "granite",
+  HOLOCENE = "holocene",
+}
 
-export const LATEST_HARDFORK: HardforkName =
-  HARDFORK_ORDER[HARDFORK_ORDER.length - 1];
+const L1_HARDFORK_ORDER = Object.values(L1HardforkName);
+const OP_HARDFORK_ORDER = Object.values(OpHardforkName);
+
+export function getHardforks(chainType: ChainType): string[] {
+  return chainType === OPTIMISM_CHAIN_TYPE
+    ? OP_HARDFORK_ORDER
+    : L1_HARDFORK_ORDER;
+}
+
+const L1_LATEST_HARDFORK: L1HardforkName =
+  L1_HARDFORK_ORDER[L1_HARDFORK_ORDER.length - 1];
+const OP_LATEST_HARDFORK: OpHardforkName =
+  OP_HARDFORK_ORDER[OP_HARDFORK_ORDER.length - 1];
+
+export function getCurrentHardfork(chainType: ChainType): string {
+  return chainType === OPTIMISM_CHAIN_TYPE
+    ? OP_LATEST_HARDFORK
+    : L1_LATEST_HARDFORK;
+}
 
 /**
  * Check if `hardforkA` is greater than or equal to `hardforkB`,
  * that is, if it includes all its changes.
+ *
+ * This function is not type-safe, as it accepts any string as hardfork name.
+ * It is the caller's responsibility to ensure that the hardfork names are valid.
  */
 export function hardforkGte(
-  hardforkA: HardforkName,
-  hardforkB: HardforkName,
+  hardforkA: string,
+  hardforkB: string,
+  chainType: ChainType,
 ): boolean {
-  const indexA = HARDFORK_ORDER.lastIndexOf(hardforkA);
-  const indexB = HARDFORK_ORDER.lastIndexOf(hardforkB);
+  return chainType === OPTIMISM_CHAIN_TYPE
+    ? opHardforkGte(hardforkA, hardforkB)
+    : l1HardforkGte(hardforkA, hardforkB);
+}
+
+function opHardforkGte(hardforkA: string, hardforkB: string): boolean {
+  /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+  -- Cast is safe, as the function is only called with valid hardfork names. */
+  const indexA = OP_HARDFORK_ORDER.indexOf(hardforkA as OpHardforkName);
+  /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+  -- Cast is safe, as the function is only called with valid hardfork names. */
+  const indexB = OP_HARDFORK_ORDER.indexOf(hardforkB as OpHardforkName);
+
+  return indexA >= indexB;
+}
+
+function l1HardforkGte(hardforkA: string, hardforkB: string): boolean {
+  /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+  -- Cast is safe, as the function is only called with valid hardfork names. */
+  const indexA = L1_HARDFORK_ORDER.indexOf(hardforkA as L1HardforkName);
+  /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+  -- Cast is safe, as the function is only called with valid hardfork names. */
+  const indexB = L1_HARDFORK_ORDER.indexOf(hardforkB as L1HardforkName);
 
   return indexA >= indexB;
 }
+
+export function isValidHardforkName(
+  hardfork: string,
+  chainType: ChainType,
+): boolean {
+  return chainType === OPTIMISM_CHAIN_TYPE
+    ? /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      -- Cast is safe, as we're validating the hardfork name. */
+      OP_HARDFORK_ORDER.includes(hardfork as OpHardforkName)
+    : /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      -- Cast is safe, as we're validating the hardfork name. */
+      L1_HARDFORK_ORDER.includes(hardfork as L1HardforkName);
+}