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

package/src/internal/builtin-plugins/network-manager/edr/utils/convert-to-edr.ts

@@ -36,13 +36,24 @@ import {
   MERGE,
   SHANGHAI,
   CANCUN,
-  OPTIMISM_CHAIN_TYPE as EDR_OPTIMISM_CHAIN_TYPE,
+  OP_CHAIN_TYPE as EDR_OP_CHAIN_TYPE,
   L1_CHAIN_TYPE as EDR_L1_CHAIN_TYPE,
   GENERIC_CHAIN_TYPE as EDR_GENERIC_CHAIN_TYPE,
+  BEDROCK,
+  REGOLITH,
+  CANYON,
+  ECOTONE,
+  FJORD,
+  GRANITE,
+  HOLOCENE,
 } from "@ignored/edr-optimism";
 import { getUnprefixedHexString } from "@nomicfoundation/hardhat-utils/hex";
 
-import { L1_CHAIN_TYPE, OPTIMISM_CHAIN_TYPE } from "../../../../constants.js";
+import {
+  GENERIC_CHAIN_TYPE,
+  L1_CHAIN_TYPE,
+  OPTIMISM_CHAIN_TYPE,
+} from "../../../../constants.js";
 import { FixedValueConfigurationVariable } from "../../../../core/configuration-variables.js";
 import { derivePrivateKeys } from "../../accounts/derive-private-keys.js";
 import {
@@ -50,47 +61,84 @@ import {
   EDR_NETWORK_DEFAULT_PRIVATE_KEYS,
   isDefaultEdrNetworkHDAccountsConfig,
 } from "../edr-provider.js";
-import { HardforkName } from "../types/hardfork.js";
+import { L1HardforkName, OpHardforkName } from "../types/hardfork.js";
+
+import { getL1HardforkName, getOpHardforkName } from "./hardfork.js";
 
-import { getHardforkName } from "./hardfork.js";
+export function hardhatHardforkToEdrSpecId(
+  hardfork: string,
+  chainType: ChainType,
+): string {
+  return chainType === OPTIMISM_CHAIN_TYPE
+    ? hardhatOpHardforkToEdrSpecId(hardfork)
+    : hardhatL1HardforkToEdrSpecId(hardfork);
+}
+
+function hardhatOpHardforkToEdrSpecId(hardfork: string): string {
+  const hardforkName = getOpHardforkName(hardfork);
+
+  switch (hardforkName) {
+    case OpHardforkName.BEDROCK:
+      return BEDROCK;
+    case OpHardforkName.REGOLITH:
+      return REGOLITH;
+    case OpHardforkName.CANYON:
+      return CANYON;
+    case OpHardforkName.ECOTONE:
+      return ECOTONE;
+    case OpHardforkName.FJORD:
+      return FJORD;
+    case OpHardforkName.GRANITE:
+      return GRANITE;
+    case OpHardforkName.HOLOCENE:
+      return HOLOCENE;
+    // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check -- trust but verify
+    default:
+      const _exhaustiveCheck: never = hardforkName;
+      throw new Error(
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- we want to print the fork
+        `Unknown hardfork name '${hardforkName as string}', this shouldn't happen`,
+      );
+  }
+}
 
-export function hardhatHardforkToEdrSpecId(hardfork: string): string {
-  const hardforkName = getHardforkName(hardfork);
+function hardhatL1HardforkToEdrSpecId(hardfork: string): string {
+  const hardforkName = getL1HardforkName(hardfork);
 
   switch (hardforkName) {
-    case HardforkName.FRONTIER:
+    case L1HardforkName.FRONTIER:
       return FRONTIER;
-    case HardforkName.HOMESTEAD:
+    case L1HardforkName.HOMESTEAD:
       return HOMESTEAD;
-    case HardforkName.DAO:
+    case L1HardforkName.DAO:
       return DAO_FORK;
-    case HardforkName.TANGERINE_WHISTLE:
+    case L1HardforkName.TANGERINE_WHISTLE:
       return TANGERINE;
-    case HardforkName.SPURIOUS_DRAGON:
+    case L1HardforkName.SPURIOUS_DRAGON:
       return SPURIOUS_DRAGON;
-    case HardforkName.BYZANTIUM:
+    case L1HardforkName.BYZANTIUM:
       return BYZANTIUM;
-    case HardforkName.CONSTANTINOPLE:
+    case L1HardforkName.CONSTANTINOPLE:
       return CONSTANTINOPLE;
-    case HardforkName.PETERSBURG:
+    case L1HardforkName.PETERSBURG:
       return PETERSBURG;
-    case HardforkName.ISTANBUL:
+    case L1HardforkName.ISTANBUL:
       return ISTANBUL;
-    case HardforkName.MUIR_GLACIER:
+    case L1HardforkName.MUIR_GLACIER:
       return MUIR_GLACIER;
-    case HardforkName.BERLIN:
+    case L1HardforkName.BERLIN:
       return BERLIN;
-    case HardforkName.LONDON:
+    case L1HardforkName.LONDON:
       return LONDON;
-    case HardforkName.ARROW_GLACIER:
+    case L1HardforkName.ARROW_GLACIER:
       return ARROW_GLACIER;
-    case HardforkName.GRAY_GLACIER:
+    case L1HardforkName.GRAY_GLACIER:
       return GRAY_GLACIER;
-    case HardforkName.MERGE:
+    case L1HardforkName.MERGE:
       return MERGE;
-    case HardforkName.SHANGHAI:
+    case L1HardforkName.SHANGHAI:
       return SHANGHAI;
-    case HardforkName.CANCUN:
+    case L1HardforkName.CANCUN:
       return CANCUN;
     // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check -- trust but verify
     default:
@@ -102,49 +150,6 @@ export function hardhatHardforkToEdrSpecId(hardfork: string): string {
   }
 }
 
-export function edrSpecIdToHardhatHardfork(specId: string): HardforkName {
-  switch (specId) {
-    case FRONTIER:
-      return HardforkName.FRONTIER;
-    case HOMESTEAD:
-      return HardforkName.HOMESTEAD;
-    case DAO_FORK:
-      return HardforkName.DAO;
-    case TANGERINE:
-      return HardforkName.TANGERINE_WHISTLE;
-    case SPURIOUS_DRAGON:
-      return HardforkName.SPURIOUS_DRAGON;
-    case BYZANTIUM:
-      return HardforkName.BYZANTIUM;
-    case CONSTANTINOPLE:
-      return HardforkName.CONSTANTINOPLE;
-    case PETERSBURG:
-      return HardforkName.PETERSBURG;
-    case ISTANBUL:
-      return HardforkName.ISTANBUL;
-    case MUIR_GLACIER:
-      return HardforkName.MUIR_GLACIER;
-    case BERLIN:
-      return HardforkName.BERLIN;
-    case LONDON:
-      return HardforkName.LONDON;
-    case ARROW_GLACIER:
-      return HardforkName.ARROW_GLACIER;
-    case GRAY_GLACIER:
-      return HardforkName.GRAY_GLACIER;
-    case MERGE:
-      return HardforkName.MERGE;
-    case SHANGHAI:
-      return HardforkName.SHANGHAI;
-    // HACK: EthereumJS doesn't support Cancun, so report Shanghai
-    case CANCUN:
-      return HardforkName.SHANGHAI;
-
-    default:
-      throw new Error(`Unknown spec id '${specId}', this shouldn't happen`);
-  }
-}
-
 export function hardhatMiningIntervalToEdrMiningInterval(
   config: EdrNetworkMiningConfig["interval"],
 ): bigint | IntervalRange | undefined {
@@ -274,28 +279,32 @@ export async function normalizeEdrNetworkAccountsConfig(
 
 export function hardhatChainsToEdrChains(
   chains: EdrNetworkChainsConfig,
+  chainType: ChainType,
 ): ChainConfig[] {
-  const edrChains: ChainConfig[] = [];
-
-  for (const [chainId, hardforkConfig] of chains) {
-    const hardforks = [];
-
-    for (const [hardfork, blockNumber] of hardforkConfig.hardforkHistory) {
-      const specId = hardhatHardforkToEdrSpecId(getHardforkName(hardfork));
-
-      hardforks.push({
-        blockNumber: BigInt(blockNumber),
-        specId,
-      });
-    }
-
-    edrChains.push({
-      chainId: BigInt(chainId),
-      hardforks,
-    });
-  }
-
-  return edrChains;
+  return (
+    Array.from(chains)
+      // Skip chains that don't match the expected chain type
+      .filter(([_, config]) => {
+        if (chainType === GENERIC_CHAIN_TYPE) {
+          // When "generic" is requested, include both "generic" and "l1" chains
+          return (
+            config.chainType === GENERIC_CHAIN_TYPE ||
+            config.chainType === L1_CHAIN_TYPE
+          );
+        }
+
+        return config.chainType === chainType;
+      })
+      .map(([chainId, config]) => ({
+        chainId: BigInt(chainId),
+        hardforks: Array.from(config.hardforkHistory).map(
+          ([hardfork, blockNumber]) => ({
+            blockNumber: BigInt(blockNumber),
+            specId: hardhatHardforkToEdrSpecId(hardfork, config.chainType),
+          }),
+        ),
+      }))
+  );
 }
 
 export async function hardhatForkingConfigToEdrForkConfig(
@@ -321,11 +330,9 @@ export async function hardhatForkingConfigToEdrForkConfig(
   return fork;
 }
 
-export function hardhatChainTypeToEdrChainType(
-  chainType: ChainType | undefined,
-): string {
+export function hardhatChainTypeToEdrChainType(chainType: ChainType): string {
   if (chainType === OPTIMISM_CHAIN_TYPE) {
-    return EDR_OPTIMISM_CHAIN_TYPE;
+    return EDR_OP_CHAIN_TYPE;
   }
 
   if (chainType === L1_CHAIN_TYPE) {

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

@@ -1,16 +1,30 @@
 import { assertHardhatInvariant } from "@nomicfoundation/hardhat-errors";
 
-import { HardforkName } from "../types/hardfork.js";
+import { L1HardforkName, OpHardforkName } from "../types/hardfork.js";
 
-export function getHardforkName(name: string): HardforkName {
+export function getL1HardforkName(name: string): L1HardforkName {
   const hardforkName =
-    Object.values(HardforkName)[
-      Object.values<string>(HardforkName).indexOf(name)
+    Object.values(L1HardforkName)[
+      Object.values<string>(L1HardforkName).indexOf(name)
     ];
 
   assertHardhatInvariant(
     hardforkName !== undefined,
-    `Invalid harfork name ${name}`,
+    `Invalid hardfork name ${name}`,
+  );
+
+  return hardforkName;
+}
+
+export function getOpHardforkName(name: string): OpHardforkName {
+  const hardforkName =
+    Object.values(OpHardforkName)[
+      Object.values<string>(OpHardforkName).indexOf(name)
+    ];
+
+  assertHardhatInvariant(
+    hardforkName !== undefined,
+    `Invalid hardfork name ${name}`,
   );
 
   return hardforkName;

package/src/internal/builtin-plugins/network-manager/request-handlers/handlers/accounts/local-accounts.ts

@@ -314,42 +314,53 @@ export class LocalAccountsHandler extends ChainId implements RequestHandler {
     );
 
     let transaction;
+    // strict mode is not meant to be used in the context of hardhat
+    const strictMode = false;
     if (txData.maxFeePerGas !== undefined) {
-      transaction = Transaction.prepare({
-        type: "eip1559",
-        to: checksummedAddress,
-        nonce: txData.nonce,
-        chainId: txData.chainId ?? toBigInt(chainId),
-        value: txData.value !== undefined ? txData.value : 0n,
-        data: txData.data !== undefined ? bytesToHexString(txData.data) : "",
-        gasLimit: txData.gasLimit,
-        maxFeePerGas: txData.maxFeePerGas,
-        maxPriorityFeePerGas: txData.maxPriorityFeePerGas,
-        accessList: accessList ?? [],
-      });
+      transaction = Transaction.prepare(
+        {
+          type: "eip1559",
+          to: checksummedAddress,
+          nonce: txData.nonce,
+          chainId: txData.chainId ?? toBigInt(chainId),
+          value: txData.value !== undefined ? txData.value : 0n,
+          data: txData.data !== undefined ? bytesToHexString(txData.data) : "",
+          gasLimit: txData.gasLimit,
+          maxFeePerGas: txData.maxFeePerGas,
+          maxPriorityFeePerGas: txData.maxPriorityFeePerGas,
+          accessList: accessList ?? [],
+        },
+        strictMode,
+      );
     } else if (accessList !== undefined) {
-      transaction = Transaction.prepare({
-        type: "eip2930",
-        to: checksummedAddress,
-        nonce: txData.nonce,
-        chainId: txData.chainId ?? toBigInt(chainId),
-        value: txData.value !== undefined ? txData.value : 0n,
-        data: txData.data !== undefined ? bytesToHexString(txData.data) : "",
-        gasPrice: txData.gasPrice ?? 0n,
-        gasLimit: txData.gasLimit,
-        accessList,
-      });
+      transaction = Transaction.prepare(
+        {
+          type: "eip2930",
+          to: checksummedAddress,
+          nonce: txData.nonce,
+          chainId: txData.chainId ?? toBigInt(chainId),
+          value: txData.value !== undefined ? txData.value : 0n,
+          data: txData.data !== undefined ? bytesToHexString(txData.data) : "",
+          gasPrice: txData.gasPrice ?? 0n,
+          gasLimit: txData.gasLimit,
+          accessList,
+        },
+        strictMode,
+      );
     } else {
-      transaction = Transaction.prepare({
-        type: "legacy",
-        to: checksummedAddress,
-        nonce: txData.nonce,
-        chainId: txData.chainId ?? toBigInt(chainId),
-        value: txData.value !== undefined ? txData.value : 0n,
-        data: txData.data !== undefined ? bytesToHexString(txData.data) : "",
-        gasPrice: txData.gasPrice ?? 0n,
-        gasLimit: txData.gasLimit,
-      });
+      transaction = Transaction.prepare(
+        {
+          type: "legacy",
+          to: checksummedAddress,
+          nonce: txData.nonce,
+          chainId: txData.chainId ?? toBigInt(chainId),
+          value: txData.value !== undefined ? txData.value : 0n,
+          data: txData.data !== undefined ? bytesToHexString(txData.data) : "",
+          gasPrice: txData.gasPrice ?? 0n,
+          gasLimit: txData.gasLimit,
+        },
+        strictMode,
+      );
     }
 
     const signedTransaction = transaction.signBy(privateKey);

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

@@ -109,6 +109,7 @@ declare module "../../../../types/config.js" {
   >;
 
   export interface EdrNetworkChainUserConfig {
+    chainType?: ChainType;
     hardforkHistory?: HardforkHistoryUserConfig;
   }
 
@@ -227,6 +228,7 @@ declare module "../../../../types/config.js" {
   >;
 
   export interface EdrNetworkChainConfig {
+    chainType: ChainType;
     hardforkHistory: HardforkHistoryConfig;
   }
 

package/src/internal/builtin-plugins/network-manager/type-validation.ts

@@ -33,8 +33,10 @@ import {
 
 import {
   hardforkGte,
-  HardforkName,
-  LATEST_HARDFORK,
+  L1HardforkName,
+  isValidHardforkName,
+  getHardforks,
+  getCurrentHardfork,
 } from "./edr/types/hardfork.js";
 
 const nonnegativeNumberSchema = z.number().nonnegative();
@@ -43,7 +45,6 @@ const nonnegativeBigIntSchema = z.bigint().nonnegative();
 
 const blockNumberSchema = nonnegativeIntSchema;
 const chainIdSchema = nonnegativeIntSchema;
-const hardforkNameSchema = z.nativeEnum(HardforkName);
 
 const accountsPrivateKeyUserConfigSchema = unionType(
   [
@@ -139,12 +140,10 @@ const edrNetworkAccountsUserConfigSchema = conditionalUnionType(
   `Expected an array with with objects with private key and balance or Configuration Variables, or an object with HD account details`,
 );
 
-const hardforkHistoryUserConfigSchema = z.map(
-  hardforkNameSchema,
-  blockNumberSchema,
-);
+const hardforkHistoryUserConfigSchema = z.map(z.string(), blockNumberSchema);
 
 const edrNetworkChainUserConfigSchema = z.object({
+  chainType: z.optional(chainTypeUserConfigSchema),
   hardforkHistory: z.optional(hardforkHistoryUserConfigSchema),
 });
 
@@ -202,7 +201,7 @@ const edrNetworkUserConfigSchema = z.object({
   enableRip7212: z.optional(z.boolean()),
   enableTransientStorage: z.optional(z.boolean()),
   forking: z.optional(edrNetworkForkingUserConfigSchema),
-  hardfork: z.optional(hardforkNameSchema),
+  hardfork: z.optional(z.string()),
   initialBaseFeePerGas: z.optional(gasUnitUserConfigSchema),
   initialDate: z.optional(
     unionType([z.string(), z.instanceof(Date)], "Expected a string or a Date"),
@@ -221,54 +220,97 @@ const baseNetworkUserConfigSchema = z.discriminatedUnion("type", [
 ]);
 
 function refineEdrNetworkUserConfig(
-  networkConfig: z.infer<typeof baseNetworkUserConfigSchema>,
+  networkConfig: NetworkUserConfig,
   ctx: RefinementCtx,
 ): void {
   if (networkConfig.type === "edr") {
     const {
-      hardfork = LATEST_HARDFORK,
+      chainType = GENERIC_CHAIN_TYPE,
+      hardfork,
+      chains,
       minGasPrice,
       initialBaseFeePerGas,
       enableTransientStorage,
     } = networkConfig;
 
-    if (hardforkGte(hardfork, HardforkName.LONDON)) {
-      if (minGasPrice !== undefined) {
+    if (hardfork !== undefined && !isValidHardforkName(hardfork, chainType)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ["hardfork"],
+        message: `Invalid hardfork name ${hardfork} for chainType ${chainType}. Expected ${getHardforks(
+          chainType,
+        ).join(" | ")}.`,
+      });
+    }
+
+    if (chains !== undefined) {
+      Array.from(chains).forEach(([chainId, chainConfig], chainIdx) => {
+        if (chainConfig.hardforkHistory === undefined) {
+          return;
+        }
+
+        const type = chainConfig.chainType ?? GENERIC_CHAIN_TYPE;
+        Array.from(chainConfig.hardforkHistory).forEach(
+          ([name], hardforkIdx) => {
+            if (!isValidHardforkName(name, type)) {
+              ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: [
+                  "chains",
+                  chainIdx,
+                  "value",
+                  "hardforkHistory",
+                  hardforkIdx,
+                  "value",
+                ],
+                message: `Invalid hardfork name ${name} found in chain ${chainId}. Expected ${getHardforks(type).join(" | ")}.`,
+              });
+            }
+          },
+        );
+      });
+    }
+
+    const resolvedHardfork = hardfork ?? getCurrentHardfork(chainType);
+    if (chainType === L1_CHAIN_TYPE || chainType === GENERIC_CHAIN_TYPE) {
+      if (hardforkGte(resolvedHardfork, L1HardforkName.LONDON, chainType)) {
+        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(resolvedHardfork, L1HardforkName.CANCUN, chainType) &&
+        enableTransientStorage === true
+      ) {
         ctx.addIssue({
           code: z.ZodIssueCode.custom,
-          message:
-            "minGasPrice is not valid for networks with EIP-1559. Try an older hardfork or remove it.",
+          message: `'enableTransientStorage' is not supported for hardforks before 'cancun'. Please use a hardfork from 'cancun' onwards to enable this feature.`,
         });
       }
-    } else {
-      if (initialBaseFeePerGas !== undefined) {
+      if (
+        hardforkGte(resolvedHardfork, L1HardforkName.CANCUN, chainType) &&
+        enableTransientStorage === false
+      ) {
         ctx.addIssue({
           code: z.ZodIssueCode.custom,
-          message:
-            "initialBaseFeePerGas is only valid for networks with EIP-1559. Try a newer hardfork or remove it.",
+          message: `'enableTransientStorage' must be enabled for hardforks 'cancun' or later. To disable this feature, use a hardfork before 'cancun'.`,
         });
       }
     }
 
-    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'.`,
-      });
-    }
-
     if (
       typeof networkConfig.mining?.interval === "number" ||
       Array.isArray(networkConfig.mining?.interval)

package/src/internal/builtin-plugins/solidity-test/reporter.ts

@@ -176,9 +176,10 @@ export async function* testReporter(
         failure.counterexample !== undefined &&
         failure.counterexample !== null
       ) {
-        const counterexamples = Array.isArray(failure.counterexample)
-          ? failure.counterexample
-          : [failure.counterexample];
+        const counterexamples =
+          "sequence" in failure.counterexample
+            ? failure.counterexample.sequence
+            : [failure.counterexample];
 
         for (const counterexample of counterexamples) {
           const details = Object.entries(counterexample).map(

package/src/internal/builtin-plugins/solidity-test/stack-trace-solidity-errors.ts

@@ -46,13 +46,15 @@ export function getMessageFromLastStackTraceEntry(
     case StackTraceEntryType.DIRECT_LIBRARY_CALL_ERROR:
       return `Library was called directly`;
 
+    /* These types are not associate with a more detailed error message */
     case StackTraceEntryType.UNRECOGNIZED_CREATE_ERROR:
     case StackTraceEntryType.UNRECOGNIZED_CONTRACT_ERROR: {
-      return "Contract reverted without a reason string";
+      return undefined;
     }
 
+    /* These types are not associate with a more detailed error message */
     case StackTraceEntryType.REVERT_ERROR: {
-      return "Contract reverted without a reason string";
+      return undefined;
     }
 
     case StackTraceEntryType.PANIC_ERROR:

package/src/internal/builtin-plugins/telemetry/index.ts

@@ -0,0 +1,23 @@
+import type { HardhatPlugin } from "../../../types/plugins.js";
+
+import { task } from "../../core/config.js";
+
+const hardhatPlugin: HardhatPlugin = {
+  id: "builtin:telemetry",
+  tasks: [
+    task("telemetry", "Displays and modifies your telemetry settings")
+      .addFlag({
+        name: "enable",
+        description: "Enable telemetry",
+      })
+      .addFlag({
+        name: "disable",
+        description: "Disable telemetry",
+      })
+      .setAction(import.meta.resolve("./task-action.js"))
+      .build(),
+  ],
+  npmPackage: "hardhat",
+};
+
+export default hardhatPlugin;

package/src/internal/builtin-plugins/telemetry/task-action.ts

@@ -0,0 +1,45 @@
+import type { NewTaskActionFunction } from "../../../types/tasks.js";
+
+import {
+  isTelemetryAllowed,
+  setTelemetryEnabled,
+} from "../../cli/telemetry/telemetry-permissions.js";
+
+interface TelemetryActionArguments {
+  enable: boolean;
+  disable: boolean;
+}
+
+const configureTelemetry: NewTaskActionFunction<
+  TelemetryActionArguments
+> = async ({ enable, disable }) => {
+  if (enable && disable) {
+    console.error("Cannot enable and disable telemetry at the same time");
+    process.exitCode = 1;
+    return;
+  }
+
+  if (enable) {
+    console.log("Enabling telemetry...");
+    await setTelemetryEnabled(true);
+  }
+
+  if (disable) {
+    console.log("Disabling telemetry...");
+    await setTelemetryEnabled(false);
+  }
+
+  const consent = await isTelemetryAllowed();
+
+  if (consent) {
+    console.log(
+      "Telemetry is now enabled, to disable it run `npx hardhat telemetry --disable`",
+    );
+  } else {
+    console.log(
+      "Telemetry is now disabled, to enable it run `npx hardhat telemetry --enable`",
+    );
+  }
+};
+
+export default configureTelemetry;