Merge pull request #7061 from NomicFoundation/chore/remove-unneeded-network-config

chore: remove `enableRip7212` from EDR config

Author: kanej

.changeset/three-brooms-sip.md

@@ -0,0 +1,6 @@
+---
+"hardhat": patch
+---
+
+Remove `enableRip7212` from EDR network configuration ([#6182](https://github.com/NomicFoundation/hardhat/issues/6182))
+Remove `enableTransientStorage` from EDR network configuration ([#6182](https://github.com/NomicFoundation/hardhat/issues/6182))

v-next/hardhat/src/internal/builtin-plugins/network-manager/config-resolution.ts

@@ -86,18 +86,13 @@ export function resolveEdrNetwork(
       networkConfig.allowUnlimitedContractSize ?? false,
     blockGasLimit: BigInt(networkConfig.blockGasLimit ?? 30_000_000n),
     coinbase: resolveCoinbase(networkConfig.coinbase),
-    enableRip7212: networkConfig.enableRip7212 ?? false,
-    enableTransientStorage: networkConfig.enableTransientStorage ?? false,
+
     forking: resolveForkingConfig(
       networkConfig.forking,
       cachePath,
       resolveConfigurationVariable,
     ),
-    hardfork: resolveHardfork(
-      networkConfig.hardfork,
-      networkConfig.chainType,
-      networkConfig.enableTransientStorage,
-    ),
+    hardfork: resolveHardfork(networkConfig.hardfork, networkConfig.chainType),
     initialBaseFeePerGas: resolveInitialBaseFeePerGas(
       networkConfig.initialBaseFeePerGas,
     ),
@@ -276,7 +271,6 @@ export async function resolveChainDescriptors(
 export function resolveHardfork(
   hardfork: string | undefined,
   chainType: ChainType | undefined = GENERIC_CHAIN_TYPE,
-  _enableTransientStorage: boolean | undefined,
 ): string {
   if (hardfork !== undefined) {
     return hardfork;

v-next/hardhat/src/internal/builtin-plugins/network-manager/edr/edr-provider.ts

@@ -30,7 +30,6 @@ import {
   opHardforkFromString,
   l1GenesisState,
   l1HardforkFromString,
-  precompileP256Verify,
 } from "@ignored/edr-optimism";
 import {
   assertHardhatInvariant,
@@ -491,8 +490,6 @@ async function getProviderConfig(
       codeCoverage: coverageConfig,
     },
     ownedAccounts: ownedAccounts.map((account) => account.secretKey),
-    precompileOverrides: networkConfig.enableRip7212
-      ? [precompileP256Verify()]
-      : [],
+    precompileOverrides: [],
   };
 }

v-next/hardhat/src/internal/builtin-plugins/network-manager/type-extensions/config.ts

@@ -108,8 +108,6 @@ declare module "../../../../types/config.js" {
     allowUnlimitedContractSize?: boolean;
     blockGasLimit?: number | bigint;
     coinbase?: string;
-    enableRip7212?: boolean;
-    enableTransientStorage?: boolean;
     forking?: EdrNetworkForkingUserConfig;
     hardfork?: string;
     initialBaseFeePerGas?: number | bigint;
@@ -249,8 +247,6 @@ declare module "../../../../types/config.js" {
     allowUnlimitedContractSize: boolean;
     blockGasLimit: bigint;
     coinbase: Uint8Array;
-    enableRip7212: boolean;
-    enableTransientStorage: boolean;
     forking?: EdrNetworkForkingConfig;
     hardfork: string;
     initialBaseFeePerGas?: bigint;

v-next/hardhat/src/internal/builtin-plugins/network-manager/type-validation.ts

@@ -304,8 +304,6 @@ const edrNetworkUserConfigSchema = z.object({
   allowUnlimitedContractSize: z.optional(z.boolean()),
   blockGasLimit: z.optional(gasUnitUserConfigSchema),
   coinbase: z.optional(z.string()),
-  enableRip7212: z.optional(z.boolean()),
-  enableTransientStorage: z.optional(z.boolean()),
   forking: z.optional(edrNetworkForkingUserConfigSchema),
   hardfork: z.optional(z.string()),
   initialBaseFeePerGas: z.optional(gasUnitUserConfigSchema),
@@ -335,7 +333,6 @@ function refineEdrNetworkUserConfig(
       hardfork,
       minGasPrice,
       initialBaseFeePerGas,
-      enableTransientStorage,
     } = networkConfig;
 
     if (hardfork !== undefined && !isValidHardforkName(hardfork, chainType)) {
@@ -367,25 +364,6 @@ function refineEdrNetworkUserConfig(
           });
         }
       }
-
-      if (
-        !hardforkGte(resolvedHardfork, L1HardforkName.CANCUN, chainType) &&
-        enableTransientStorage === true
-      ) {
-        ctx.addIssue({
-          code: z.ZodIssueCode.custom,
-          message: `'enableTransientStorage' is not supported for hardforks before 'cancun'. Please use a hardfork from 'cancun' onwards to enable this feature.`,
-        });
-      }
-      if (
-        hardforkGte(resolvedHardfork, L1HardforkName.CANCUN, chainType) &&
-        enableTransientStorage === false
-      ) {
-        ctx.addIssue({
-          code: z.ZodIssueCode.custom,
-          message: `'enableTransientStorage' must be enabled for hardforks 'cancun' or later. To disable this feature, use a hardfork before 'cancun'.`,
-        });
-      }
     }
 
     if (

v-next/hardhat/test/internal/builtin-plugins/network-manager/config-resolution.ts

@@ -123,8 +123,6 @@ describe("config-resolution", () => {
         allowBlocksWithSameTimestamp: true,
         allowUnlimitedContractSize: true,
         blockGasLimit: 20_000_000,
-        enableRip7212: true,
-        enableTransientStorage: true,
         initialDate: new Date(),
         loggingEnabled: true,
         minGasPrice: 10,
@@ -158,11 +156,6 @@ describe("config-resolution", () => {
         // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- cast for testing
         BigInt(userConfig.blockGasLimit as number),
       );
-      assert.equal(edrNetworkConfig.enableRip7212, userConfig.enableRip7212);
-      assert.equal(
-        edrNetworkConfig.enableTransientStorage,
-        userConfig.enableTransientStorage,
-      );
       assert.equal(edrNetworkConfig.initialDate, userConfig.initialDate);
       assert.equal(edrNetworkConfig.loggingEnabled, userConfig.loggingEnabled);
       assert.equal(
@@ -202,8 +195,6 @@ describe("config-resolution", () => {
       assert.equal(edrNetworkConfig.allowBlocksWithSameTimestamp, false);
       assert.equal(edrNetworkConfig.allowUnlimitedContractSize, false);
       assert.equal(edrNetworkConfig.blockGasLimit, 30_000_000n);
-      assert.equal(edrNetworkConfig.enableRip7212, false);
-      assert.equal(edrNetworkConfig.enableTransientStorage, false);
       const initialDate = new Date(edrNetworkConfig.initialDate);
       assert.ok(
         Math.abs(initialDate.getTime() - now.getTime()) < 1000,
@@ -773,25 +764,21 @@ describe("config-resolution", () => {
 
   describe("resolveHardfork", () => {
     it("should return the hardfork if it is provided", () => {
-      let hardfork = resolveHardfork(
-        L1HardforkName.LONDON,
-        L1_CHAIN_TYPE,
-        true,
-      );
+      let hardfork = resolveHardfork(L1HardforkName.LONDON, L1_CHAIN_TYPE);
       assert.equal(hardfork, L1HardforkName.LONDON);
 
-      hardfork = resolveHardfork(L1HardforkName.LONDON, L1_CHAIN_TYPE, false);
+      hardfork = resolveHardfork(L1HardforkName.LONDON, L1_CHAIN_TYPE);
       assert.equal(hardfork, L1HardforkName.LONDON);
     });
 
     it("should return the current hardfork if no hardfork is provided", () => {
-      let hardfork = resolveHardfork(undefined, L1_CHAIN_TYPE, true);
+      let hardfork = resolveHardfork(undefined, L1_CHAIN_TYPE);
       assert.equal(hardfork, getCurrentHardfork(L1_CHAIN_TYPE));
 
-      hardfork = resolveHardfork(undefined, undefined, true);
+      hardfork = resolveHardfork(undefined, undefined);
       assert.equal(hardfork, getCurrentHardfork(L1_CHAIN_TYPE));
 
-      hardfork = resolveHardfork(undefined, OPTIMISM_CHAIN_TYPE, true);
+      hardfork = resolveHardfork(undefined, OPTIMISM_CHAIN_TYPE);
       assert.equal(hardfork, getCurrentHardfork(OPTIMISM_CHAIN_TYPE));
     });
   });

v-next/hardhat/test/internal/builtin-plugins/network-manager/network-manager.ts

@@ -1878,103 +1878,6 @@ describe("NetworkManagerImplementation", () => {
       });
     });
 
-    describe("enableRip7212", () => {
-      describe("edr config", () => {
-        it("should validate a valid network config", async () => {
-          let validationErrors = await validateNetworkUserConfig(
-            edrConfig({ enableRip7212: true }),
-          );
-
-          assertValidationErrors(validationErrors, []);
-
-          validationErrors = await validateNetworkUserConfig(
-            edrConfig({ enableRip7212: false }),
-          );
-
-          assertValidationErrors(validationErrors, []);
-        });
-
-        it("should not validate an invalid network config", async () => {
-          const validationErrors = await validateNetworkUserConfig(
-            edrConfig({ enableRip7212: "incorrect" }),
-          );
-
-          assertValidationErrors(validationErrors, [
-            {
-              path: ["networks", "hardhat", "enableRip7212"],
-              message: "Expected boolean, received string",
-            },
-          ]);
-        });
-      });
-    });
-
-    describe("enableTransientStorage", () => {
-      describe("edr config", () => {
-        it("should validate a valid network config", async () => {
-          let validationErrors = await validateNetworkUserConfig(
-            edrConfig({ enableTransientStorage: true }),
-          );
-
-          assertValidationErrors(validationErrors, []);
-
-          validationErrors = await validateNetworkUserConfig(
-            edrConfig({ enableTransientStorage: false, hardfork: "berlin" }),
-          );
-
-          assertValidationErrors(validationErrors, []);
-        });
-
-        it("should not validate an invalid network config", async () => {
-          let validationErrors = await validateNetworkUserConfig(
-            edrConfig({ enableTransientStorage: true, hardfork: "berlin" }),
-          );
-
-          assertValidationErrors(validationErrors, [
-            {
-              path: ["networks", "hardhat"],
-              message:
-                "'enableTransientStorage' is not supported for hardforks before 'cancun'. Please use a hardfork from 'cancun' onwards to enable this feature.",
-            },
-          ]);
-
-          validationErrors = await validateNetworkUserConfig(
-            edrConfig({ enableTransientStorage: false, hardfork: "cancun" }),
-          );
-
-          assertValidationErrors(validationErrors, [
-            {
-              path: ["networks", "hardhat"],
-              message:
-                "'enableTransientStorage' must be enabled for hardforks 'cancun' or later. To disable this feature, use a hardfork before 'cancun'.",
-            },
-          ]);
-
-          validationErrors = await validateNetworkUserConfig(
-            edrConfig({ enableTransientStorage: "incorrect" }),
-          );
-
-          assertValidationErrors(validationErrors, [
-            {
-              path: ["networks", "hardhat", "enableTransientStorage"],
-              message: "Expected boolean, received string",
-            },
-          ]);
-
-          validationErrors = await validateNetworkUserConfig(
-            edrConfig({ enableTransientStorage: "incorrect" }),
-          );
-
-          assertValidationErrors(validationErrors, [
-            {
-              path: ["networks", "hardhat", "enableTransientStorage"],
-              message: "Expected boolean, received string",
-            },
-          ]);
-        });
-      });
-    });
-
     describe("forking", () => {
       describe("edr config", () => {
         it("should validate a valid network config", async () => {