feat: fix and add tests

Author: schaable

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

@@ -121,9 +121,10 @@ export class NetworkManagerImplementation implements NetworkManager {
           HardhatError.ERRORS.NETWORK.INVALID_CONFIG_OVERRIDE,
           {
             errors: `\t${validationErrors
-              .map(
-                (error) =>
-                  `* Error in ${error.path.join(".")}: ${error.message}`,
+              .map((error) =>
+                error.path.length > 0
+                  ? `* Error in ${error.path.join(".")}: ${error.message}`
+                  : `* ${error.message}`,
               )
               .join("\n\t")}`,
           },

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

@@ -5,6 +5,7 @@ import type {
   NetworkUserConfig,
 } from "../../../types/config.js";
 import type { HardhatUserConfigValidationError } from "../../../types/hooks.js";
+import type { RefinementCtx } from "zod";
 
 import {
   getUnprefixedHexString,
@@ -211,71 +212,85 @@ const edrNetworkUserConfigSchema = z.object({
   throwOnTransactionFailures: z.optional(z.boolean()),
 });
 
-const networkUserConfigSchema = z
-  .discriminatedUnion("type", [
-    httpNetworkUserConfigSchema,
-    edrNetworkUserConfigSchema,
-  ])
-  // The superRefine is used to perform additional validation of correlated
-  // fields of the edr network that are not possible to express with Zod's
-  // built-in validation methods.
-  // Ideally, it should be applied to the edrNetworkUserConfigSchema, but it
-  // returns a ZodEffects, which is not compatible with the discriminatedUnion
-  // method, so it is applied to the networkUserConfigSchema instead.
-  .superRefine((networkConfig, ctx) => {
-    if (networkConfig.type === "edr") {
-      const {
-        hardfork = LATEST_HARDFORK,
-        minGasPrice,
-        initialBaseFeePerGas,
-        enableTransientStorage,
-      } = networkConfig;
-
-      if (hardforkGte(hardfork, HardforkName.LONDON)) {
-        if (minGasPrice !== undefined) {
-          ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            message:
-              "minGasPrice is not valid for networks with EIP-1559. Try an older hardfork or remove it.",
-          });
-        }
-      } else {
-        if (initialBaseFeePerGas !== undefined) {
-          ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            message:
-              "initialBaseFeePerGas is only valid for networks with EIP-1559. Try a newer hardfork or remove it.",
-          });
-        }
-      }
-
-      if (
-        !hardforkGte(hardfork, HardforkName.CANCUN) &&
-        enableTransientStorage === true
-      ) {
+const baseNetworkUserConfigSchema = z.discriminatedUnion("type", [
+  httpNetworkUserConfigSchema,
+  edrNetworkUserConfigSchema,
+]);
+
+function refineEdrNetworkUserConfig(
+  networkConfig: z.infer<typeof baseNetworkUserConfigSchema>,
+  ctx: RefinementCtx,
+): void {
+  if (networkConfig.type === "edr") {
+    const {
+      hardfork = LATEST_HARDFORK,
+      minGasPrice,
+      initialBaseFeePerGas,
+      enableTransientStorage,
+    } = networkConfig;
+
+    if (hardforkGte(hardfork, HardforkName.LONDON)) {
+      if (minGasPrice !== undefined) {
         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.`,
+          message:
+            "minGasPrice is not valid for networks with EIP-1559. Try an older hardfork or remove it.",
         });
       }
-      if (
-        hardforkGte(hardfork, HardforkName.CANCUN) &&
-        enableTransientStorage === false
-      ) {
+    } else {
+      if (initialBaseFeePerGas !== undefined) {
         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'.`,
+          message:
+            "initialBaseFeePerGas is only valid for networks with EIP-1559. Try a newer hardfork or remove it.",
         });
       }
     }
-  });
+
+    if (
+      !hardforkGte(hardfork, HardforkName.CANCUN) &&
+      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(hardfork, HardforkName.CANCUN) &&
+      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'.`,
+      });
+    }
+  }
+}
+
+// The superRefine is used to perform additional validation of correlated
+// fields of the edr network that are not possible to express with Zod's
+// built-in validation methods.
+// Ideally, it should be applied to the edrNetworkUserConfigSchema, but it
+// returns a ZodEffects, which is not compatible with the discriminatedUnion
+// method, so it is applied to the networkUserConfigSchema instead.
+const networkUserConfigSchema = baseNetworkUserConfigSchema.superRefine(
+  refineEdrNetworkUserConfig,
+);
 
 const userConfigSchema = z.object({
   defaultChainType: z.optional(chainTypeUserConfigSchema),
   defaultNetwork: z.optional(z.string()),
   networks: z.optional(z.record(networkUserConfigSchema)),
 });
 
+const networkConfigOverrideSchema = z
+  .discriminatedUnion("type", [
+    httpNetworkUserConfigSchema.strict(),
+    edrNetworkUserConfigSchema.strict(),
+  ])
+  .superRefine(refineEdrNetworkUserConfig);
+
 export async function validateNetworkUserConfig(
   userConfig: HardhatUserConfig,
 ): Promise<HardhatUserConfigValidationError[]> {
@@ -287,7 +302,7 @@ export async function validateNetworkConfigOverride(
 ): Promise<HardhatUserConfigValidationError[]> {
   return validateUserConfigZodType(
     networkConfigOverride,
-    networkUserConfigSchema,
+    networkConfigOverrideSchema,
   );
 }
 

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

@@ -5,7 +5,10 @@ import type {
   NetworkConnection,
   NetworkManager,
 } from "../../../../src/types/network.js";
-import type { NetworkConfig } from "@ignored/hardhat-vnext/types/config";
+import type {
+  HttpNetworkConfigOverride,
+  NetworkConfig,
+} from "@ignored/hardhat-vnext/types/config";
 
 import assert from "node:assert/strict";
 import { before, describe, it } from "node:test";
@@ -112,16 +115,20 @@ describe("NetworkManagerImplementation", () => {
     });
 
     it("should override the network's chain config with the specified chain config", async () => {
+      const httpConfigOverride: HttpNetworkConfigOverride = {
+        chainId: 1234,
+        timeout: 30_000, // specific to http networks
+      };
       const networkConnection = await networkManager.connect(
         "myNetwork",
         OPTIMISM_CHAIN_TYPE,
-        { chainId: 1234 },
+        httpConfigOverride,
       );
       assert.equal(networkConnection.networkName, "myNetwork");
       assert.equal(networkConnection.chainType, OPTIMISM_CHAIN_TYPE);
       assert.deepEqual(networkConnection.networkConfig, {
         ...networks.myNetwork,
-        chainId: 1234,
+        ...httpConfigOverride,
       });
     });
 
@@ -173,6 +180,21 @@ describe("NetworkManagerImplementation", () => {
       );
     });
 
+    it("should throw an error if the specified network config override has mixed properties from http and edr networks", async () => {
+      await assertRejectsWithHardhatError(
+        /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        -- Cast to test validation error */
+        networkManager.connect("myNetwork", OPTIMISM_CHAIN_TYPE, {
+          url: "http://localhost:8545",
+          hardfork: "cancun",
+        } as any),
+        HardhatError.ERRORS.NETWORK.INVALID_CONFIG_OVERRIDE,
+        {
+          errors: `\t* Unrecognized key(s) in object: 'hardfork'`,
+        },
+      );
+    });
+
     it("should throw an error if the specified chain type doesn't match the network's chain type", async () => {
       await assertRejectsWithHardhatError(
         networkManager.connect("myNetwork", L1_CHAIN_TYPE),