hardhat 3.0.0 → 3.0.1

package/src/internal/cli/help/utils.ts

@@ -24,7 +24,7 @@ export function parseGlobalOptions(
   return [...globalOptionDefinitions].map(([, { option }]) => ({
     name: toCommandLineOption(option.name),
     shortName: toShortCommandLineOption(option.shortName),
-    description: option.description,
+    description: trimFullStop(option.description),
   }));
 }
 
@@ -42,7 +42,7 @@ export function parseTasks(taskMap: Map<string, Task>): {
       continue;
     }
 
-    tasks.push({ name: taskName, description: task.description });
+    tasks.push({ name: taskName, description: trimFullStop(task.description) });
   }
 
   return { tasks, subtasks };
@@ -54,7 +54,7 @@ export function parseSubtasks(task: Task): ArgumentDescriptor[] {
   for (const [, subtask] of task.subtasks) {
     subtasks.push({
       name: subtask.id.join(" "),
-      description: subtask.description,
+      description: trimFullStop(subtask.description),
     });
   }
 
@@ -72,7 +72,7 @@ export function parseOptions(task: Task): {
     options.push({
       name: toCommandLineOption(optionName),
       shortName: toShortCommandLineOption(option.shortName),
-      description: option.description,
+      description: trimFullStop(option.description),
       type: option.type,
       ...(option.defaultValue !== undefined && {
         defaultValue: option.defaultValue,
@@ -83,7 +83,7 @@ export function parseOptions(task: Task): {
   for (const { name, description, defaultValue } of task.positionalArguments) {
     positionalArguments.push({
       name,
-      description,
+      description: trimFullStop(description),
       isRequired: defaultValue === undefined,
       ...(defaultValue !== undefined && {
         defaultValue: Array.isArray(defaultValue)
@@ -131,6 +131,10 @@ export function getSection(
     .join("\n")}\n`;
 }
 
+function trimFullStop(str: string): string {
+  return str.endsWith(".") ? str.slice(0, -1) : str;
+}
+
 function getNameString(name: string, shortName?: string): string {
   return shortName !== undefined ? [name, shortName].join(", ") : name;
 }

package/src/internal/cli/init/init.ts

@@ -7,6 +7,7 @@ import {
   assertHardhatInvariant,
   HardhatError,
 } from "@nomicfoundation/hardhat-errors";
+import { ensureError } from "@nomicfoundation/hardhat-utils/error";
 import {
   copy,
   ensureDir,
@@ -19,12 +20,17 @@ import {
 } from "@nomicfoundation/hardhat-utils/fs";
 import { resolveFromRoot } from "@nomicfoundation/hardhat-utils/path";
 import chalk from "chalk";
+import debug from "debug";
 import * as semver from "semver";
 
 import { findClosestHardhatConfig } from "../../config-loading.js";
 import { HARDHAT_NAME } from "../../constants.js";
-import { getHardhatVersion } from "../../utils/package.js";
+import {
+  getHardhatVersion,
+  getLatestHardhatVersion,
+} from "../../utils/package.js";
 import { sendProjectTypeAnalytics } from "../telemetry/analytics/analytics.js";
+import { sendErrorTelemetry } from "../telemetry/sentry/reporter.js";
 
 import {
   getDevDependenciesInstallationCommand,
@@ -52,6 +58,8 @@ export interface InitHardhatOptions {
   install?: boolean;
 }
 
+const log = debug("hardhat:cli:init");
+
 /**
  * initHardhat implements the project initialization wizard flow.
  *
@@ -164,24 +172,29 @@ export async function printWelcomeMessage(): Promise<void> {
     chalk.cyan(`👷 Welcome to ${HARDHAT_NAME} v${hardhatVersion} 👷\n`),
   );
 
-  // TODO: Disabled this until the first release of v3
-  // // Warn the user if they are using an outdated version of Hardhat
-  // try {
-  //   const latestHardhatVersion = await getLatestHardhatVersion();
-  //   if (hardhatVersion !== latestHardhatVersion) {
-  //     console.warn(
-  //       chalk.yellow.bold(
-  //         `⚠️ You are using an outdated version of Hardhat. The latest version is v${latestHardhatVersion}. Please consider upgrading to the latest version before continuing with the project initialization. ⚠️\n`,
-  //       ),
-  //     );
-  //   }
-  // } catch (e) {
-  //   console.warn(
-  //     chalk.yellow.bold(
-  //       `⚠️ We couldn't check if you are using the latest version of Hardhat. Please consider upgrading to the latest version if you are not using it yet. ⚠️\n`,
-  //     ),
-  //   );
-  // }
+  // Warn the user if they are using an outdated version of Hardhat
+  try {
+    const latestHardhatVersion = await getLatestHardhatVersion();
+    if (hardhatVersion !== latestHardhatVersion) {
+      console.warn(
+        chalk.yellow.bold(
+          `⚠️ You are using an outdated version of Hardhat. The latest version is v${latestHardhatVersion}. Please consider upgrading to the latest version before continuing with the project initialization. ⚠️\n`,
+        ),
+      );
+    }
+  } catch (error) {
+    ensureError(error);
+    try {
+      await sendErrorTelemetry(error);
+    } catch (e) {
+      log("Couldn't report error to sentry: %O", e);
+    }
+    console.warn(
+      chalk.yellow.bold(
+        `⚠️ We couldn't check if you are using the latest version of Hardhat. Please consider upgrading to the latest version if you are not using it yet. ⚠️\n`,
+      ),
+    );
+  }
 }
 
 /**

package/src/internal/cli/telemetry/sentry/anonymizer.ts

@@ -37,7 +37,6 @@ export type AnonymizeEventResult =
   | { success: true; event: Event }
   | { success: false; error: string };
 
-const ANONYMIZED_FILE = ANONYMIZED_PATH;
 const ANONYMIZED_MNEMONIC = "<mnemonic>";
 const MNEMONIC_PHRASE_LENGTH_THRESHOLD = 7;
 const MINIMUM_AMOUNT_OF_WORDS_TO_ANONYMIZE = 4;
@@ -57,7 +56,7 @@ export class Anonymizer {
   ): Promise<AnonymizeEnvelopeResult> {
     for (const item of envelope[1]) {
       if (item[0].type === "event") {
-        /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions 
+        /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions
           -- We know that the item is an event item */
         const eventItem = item as EventItem;
 
@@ -136,6 +135,16 @@ export class Anonymizer {
   public anonymizeErrorMessage(errorMessage: string): string {
     errorMessage = this.#anonymizeMnemonic(errorMessage);
 
+    // We intentionally replace the config path with its own
+    // anonymized token, to help differentiate the config
+    // file in exception reports while keeping it anonymized.
+    if (this.#configPath !== undefined) {
+      errorMessage = errorMessage.replaceAll(
+        this.#configPath,
+        "<hardhat-config-file>",
+      );
+    }
+
     // hide hex strings of 20 chars or more
     const hexRegex = /(0x)?[0-9A-Fa-f]{20,}/g;
 
@@ -144,6 +153,26 @@ export class Anonymizer {
     );
   }
 
+  public filterOutEventsWithExceptionsNotRaisedByHardhat(
+    envelope: Envelope,
+  ): Envelope {
+    /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions --
+      We are just filtering events in place, not changing any type */
+    envelope[1] = envelope[1].filter((item) => {
+      if (item[0].type !== "event") {
+        return true;
+      }
+
+      /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+          -- We know that the item is an event item */
+      const eventItem = item as EventItem;
+
+      return this.raisedByHardhat(eventItem[1]);
+    }) as any;
+
+    return envelope;
+  }
+
   public raisedByHardhat(event: Event): boolean {
     const exceptions = event?.exception?.values;
 
@@ -155,6 +184,10 @@ export class Anonymizer {
 
     const originalException = exceptions[exceptions.length - 1];
 
+    if (!this.#isErrorMessageAllowed(originalException)) {
+      return false;
+    }
+
     const frames = originalException?.stacktrace?.frames;
 
     if (frames === undefined) {
@@ -166,38 +199,94 @@ export class Anonymizer {
         continue;
       }
 
-      if (this.#errorRaisedByPackageToIgnore(frame.filename)) {
+      // We don't report errors from the Hardhat.config file
+      if (
+        this.#configPath !== undefined &&
+        this.#configPath.includes(frame.filename)
+      ) {
         return false;
       }
 
-      // we stop after finding either a hardhat file or a file from the user's
-      // project
-      if (this.#isHardhatFile(frame.filename)) {
-        return true;
-      }
+      if (this.#isPackageFile(frame.filename)) {
+        // We don't report errors from the ignored package list e.g. `ethers`
+        // even when buried as a subpackage of a hardhat package
+        if (this.#errorRaisedByPackageToIgnore(frame.filename)) {
+          return false;
+        }
 
-      if (frame.filename === ANONYMIZED_FILE) {
-        return false;
+        // We report errors from Hardhat packages, we exclude
+        // those from non-hardhat packages
+        return this.#isHardhatFile(frame.filename);
       }
 
-      if (
-        this.#configPath !== undefined &&
-        this.#configPath.includes(frame.filename)
-      ) {
+      // Error originating not in packages, but in the user project
+      // should be filtered.
+      if (this.#isUserProjectFile(frame.filename)) {
         return false;
       }
+
+      // Otherwise look at the next frame up
     }
 
     // if we didn't find any hardhat frame, we don't report the error
     return false;
   }
 
+  #isErrorMessageAllowed(originalException: Exception): boolean {
+    const exceptionType = originalException.type;
+    const exceptionMessage = originalException.value;
+
+    // Without an exception message, we can't filter so allow it
+    if (exceptionMessage === undefined) {
+      return true;
+    }
+
+    // Filter out required not defined in ES Modules errors
+    if (
+      exceptionType === "ReferenceError" &&
+      exceptionMessage ===
+        "require is not defined in ES module scope, you can use import instead"
+    ) {
+      return false;
+    }
+
+    // Filter out cannot find package when importing errors
+    if (
+      exceptionType === "Error" &&
+      /^Cannot find package '([^']+)' imported from .+$/.test(exceptionMessage)
+    ) {
+      return false;
+    }
+
+    // Filter out cannot find module errors
+    if (
+      exceptionType === "Error" &&
+      /^Cannot find module '([^']+)'/.test(exceptionMessage)
+    ) {
+      return false;
+    }
+
+    // Filter out "require() cannot be sued on an ESM graph"
+    if (
+      exceptionType === "Error" &&
+      exceptionMessage.startsWith(
+        "require() cannot be used on an ESM graph with top-level await. Use import() instead.",
+      )
+    ) {
+      return false;
+    }
+
+    return true;
+  }
+
   #errorRaisedByPackageToIgnore(filename: string): boolean {
+    // List of external packages that we don't want to report errors from
     const pkgsToIgnore: string[] = [
-      path.join("node_modules", "@ethersproject"), // List of external packages that we don't want to report errors from
+      path.join("node_modules", "@ethersproject"),
     ];
 
-    const pkgs = filename.match(/node_modules[\/\\][^\/\\]+/g); // Match path separators both for Windows and Unix
+    // Match path separators both for Windows and Unix
+    const pkgs = filename.match(/node_modules[\/\\][^\/\\]+/g);
 
     if (pkgs === null) {
       return false;
@@ -212,15 +301,26 @@ export class Anonymizer {
     const nomicFoundationPath = path.join("node_modules", "@nomicfoundation");
     const ignoredOrgPath = path.join("node_modules", "@ignored");
     const hardhatPath = path.join("node_modules", "hardhat");
+
     filename = filename.toLowerCase();
 
     return (
-      filename.startsWith(nomicFoundationPath) ||
-      filename.startsWith(ignoredOrgPath) ||
-      filename.startsWith(hardhatPath)
+      filename.includes(nomicFoundationPath) ||
+      filename.includes(ignoredOrgPath) ||
+      filename.includes(hardhatPath)
     );
   }
 
+  #isPackageFile(filename: string): boolean {
+    return filename.includes("node_modules");
+  }
+
+  #isUserProjectFile(filename: string): boolean {
+    const anonymizedUserPath = anonymizeUserPaths(filename);
+
+    return anonymizedUserPath === ANONYMIZED_PATH;
+  }
+
   async #anonymizeExceptions(exceptions: Exception[]): Promise<Exception[]> {
     const anonymizedExceptions = await Promise.all(
       exceptions.map((exception) => this.#anonymizeException(exception)),

package/src/internal/cli/telemetry/sentry/reporter.ts

@@ -89,7 +89,7 @@ class Reporter {
         SENTRY_DSN,
         release,
         environment,
-        this.#hardhatConfigPath,
+        () => this.#hardhatConfigPath,
       ),
       release,
       environment,

package/src/internal/cli/telemetry/sentry/subprocess.ts

@@ -24,6 +24,7 @@ if (process.argv.length !== 7) {
   process.exit(1);
 }
 
+log("Config path:", configPath);
 log("Received envelope to be sent to Sentry from a subprocess");
 
 init({
@@ -36,22 +37,31 @@ init({
 const envelope = JSON.parse(serializedEnvelope);
 
 const anonymizer = new Anonymizer(configPath);
-const anonymizeResult = await anonymizer.anonymizeEventsFromEnvelope(envelope);
 
-if (!anonymizeResult.success) {
-  log("Failed to anonymize envelope", anonymizeResult.error);
-  captureMessage(anonymizeResult.error);
+const filteredEnvelope =
+  anonymizer.filterOutEventsWithExceptionsNotRaisedByHardhat(envelope);
+
+if (filteredEnvelope[1].length === 0) {
+  log("The events weren't raised by Hardhat, so we don't report them");
 } else {
-  try {
-    log("Sending received envelope to Sentry");
+  const anonymizeResult =
+    await anonymizer.anonymizeEventsFromEnvelope(filteredEnvelope);
+
+  if (!anonymizeResult.success) {
+    log("Failed to anonymize envelope", anonymizeResult.error);
+    captureMessage(anonymizeResult.error);
+  } else {
+    try {
+      log("Sending received envelope to Sentry");
 
-    await sendEnvelopeToSentryBackend(dsn, anonymizeResult.envelope);
+      await sendEnvelopeToSentryBackend(dsn, anonymizeResult.envelope);
 
-    log("Successfully sent received envelope to Sentry");
-  } catch (e) {
-    log("Failed to send received envelope to Sentry", e);
+      log("Successfully sent received envelope to Sentry");
+    } catch (e) {
+      log("Failed to send received envelope to Sentry", e);
 
-    captureException(e);
+      captureException(e);
+    }
   }
 }
 

package/src/internal/cli/telemetry/sentry/transport.ts

@@ -32,7 +32,7 @@ export function createDetachedProcessTransport(
   dsn: string,
   release: string,
   environment: string,
-  configPath?: string,
+  getConfigPath: () => string | undefined,
 ): Transport {
   return {
     send: (envelope) => {
@@ -52,7 +52,7 @@ export function createDetachedProcessTransport(
       let args = [
         subprocessPath,
         serializedEnvelope,
-        configPath ?? "",
+        getConfigPath() ?? "",
         dsn,
         release,
         environment,

package/templates/hardhat-3/01-node-test-runner-viem/package.json

@@ -12,5 +12,15 @@
     "forge-std": "foundry-rs/forge-std#v1.9.4",
     "typescript": "~5.8.0",
     "viem": "^2.30.0"
+  },
+  "peerDependencies": {
+    "@nomicfoundation/hardhat-ignition-viem": "workspace:^3.0.0",
+    "@nomicfoundation/hardhat-keystore": "workspace:^3.0.0",
+    "@nomicfoundation/hardhat-network-helpers": "workspace:^3.0.0",
+    "@nomicfoundation/hardhat-node-test-runner": "workspace:^3.0.0",
+    "@nomicfoundation/hardhat-viem": "workspace:^3.0.0",
+    "@nomicfoundation/hardhat-viem-assertions": "workspace:^3.0.0",
+    "@nomicfoundation/hardhat-verify": "workspace:^3.0.0",
+    "@nomicfoundation/ignition-core": "workspace:^3.0.0"
   }
 }

package/templates/hardhat-3/02-mocha-ethers/package.json

@@ -8,7 +8,6 @@
     "hardhat": "workspace:^3.0.0",
     "@nomicfoundation/hardhat-toolbox-mocha-ethers": "workspace:^3.0.0",
     "@nomicfoundation/hardhat-ignition": "workspace:^3.0.0",
-    "@nomicfoundation/hardhat-ethers": "workspace:^4.0.0",
     "@types/chai": "^4.2.0",
     "@types/chai-as-promised": "^8.0.1",
     "@types/mocha": ">=10.0.10",
@@ -18,5 +17,17 @@
     "forge-std": "foundry-rs/forge-std#v1.9.4",
     "mocha": "^11.0.0",
     "typescript": "~5.8.0"
+  },
+  "peerDependencies": {
+    "@nomicfoundation/hardhat-ethers": "workspace:^4.0.0",
+    "@nomicfoundation/hardhat-ethers-chai-matchers": "workspace:^3.0.0",
+    "@nomicfoundation/hardhat-ignition": "workspace:^3.0.0",
+    "@nomicfoundation/hardhat-ignition-ethers": "workspace:^3.0.0",
+    "@nomicfoundation/hardhat-keystore": "workspace:^3.0.0",
+    "@nomicfoundation/hardhat-mocha": "workspace:^3.0.0",
+    "@nomicfoundation/hardhat-network-helpers": "workspace:^3.0.0",
+    "@nomicfoundation/hardhat-typechain": "workspace:^3.0.0",
+    "@nomicfoundation/hardhat-verify": "workspace:^3.0.0",
+    "@nomicfoundation/ignition-core": "workspace:^3.0.0"
   }
 }