hardhat 3.4.5 → 3.5.1

package/src/internal/cli/error-handler.ts

@@ -1,3 +1,5 @@
+import type * as ClassifierT from "./telemetry/error-classification/classifier.js";
+
 import { styleText } from "node:util";
 
 import {
@@ -6,19 +8,24 @@ import {
 } from "@nomicfoundation/hardhat-errors";
 
 import { HARDHAT_NAME, HARDHAT_WEBSITE_URL } from "../constants.js";
-import { UsingHardhat2PluginError } from "../using-hardhat2-plugin-errors.js";
+
+// The classifier may import many unrelated things top-level to do its job, so
+// we load it lazily.
+let classifierModule: typeof ClassifierT | undefined;
 
 /**
  * The different categories of errors that can be handled by hardhat cli.
  * Each category has a different way of being formatted and displayed.
  * To add new categories, add a new entry to this enum and update the
- *  {@link getErrorWithCategory} and {@link getErrorMessages} functions
- * accordingly.
+ *  {@link getErrorWithCategory} function and the switch inside
+ * {@link printErrorMessages} accordingly.
  */
 enum ErrorCategory {
   HARDHAT = "HARDHAT",
   PLUGIN = "PLUGIN",
   COMMUNITY_PLUGIN = "COMMUNITY_PLUGIN",
+  HH2_TO_HH3_MIGRATION = "HH2_TO_HH3_MIGRATION",
+  CJS_TO_ESM_MIGRATION = "CJS_TO_ESM_MIGRATION",
   OTHER = "OTHER",
 }
 
@@ -35,55 +42,91 @@ type ErrorWithCategory =
       category: ErrorCategory.COMMUNITY_PLUGIN;
       categorizedError: HardhatPluginError;
     }
+  | {
+      category: ErrorCategory.HH2_TO_HH3_MIGRATION;
+      categorizedError: Error;
+    }
+  | {
+      category: ErrorCategory.CJS_TO_ESM_MIGRATION;
+      categorizedError: Error;
+    }
   | {
       category: ErrorCategory.OTHER;
       categorizedError: unknown;
     };
 
-/**
- * The different messages that can be displayed for each category of errors.
- *  - `formattedErrorMessage`: the main error message that is always displayed.
- *  - `showMoreInfoMessage`: an optional message that can be displayed to
- * provide more information about the error. It is only displayed when stack
- * traces are hidden.
- *  - `postErrorStackTraceMessage` an optional message that can be displayed
- * after the stack trace. It is only displayed when stack traces are shown.
- */
-interface ErrorMessages {
-  formattedErrorMessage: string;
-  showMoreInfoMessage?: string;
-  postErrorStackTraceMessage?: string;
-}
-
 /**
  * Formats and logs error messages based on the category the error belongs to.
  *
+ * For each category, we produce up to three pieces:
+ *  - `formattedErrorMessage`: the main error message that is always displayed.
+ *  - `showMoreInfoMessage`: an optional message that points the user at more
+ *    info. It is only displayed when the stack trace is hidden.
+ *  - `postErrorStackTraceMessage`: an optional message that is displayed after
+ *    the stack trace.
+ *
  * @param error the error to handle. Supported categories are defined in
  * {@link ErrorCategory}.
  * @param shouldShowStackTraces whether to show stack traces or not. If true,
  * the stack trace is always shown. If false, the stack trace is only shown for
- * errors of category {@link ErrorCategory.OTHER}.
+ * errors of category {@link ErrorCategory.OTHER},
+ * {@link ErrorCategory.HH2_TO_HH3_MIGRATION}, and
+ * {@link ErrorCategory.CJS_TO_ESM_MIGRATION}.
  * @param print the function used to print the error message, defaults to
  * `console.error`. Useful for testing to capture error messages.
  */
-export function printErrorMessages(
+export async function printErrorMessages(
   error: Error,
   shouldShowStackTraces: boolean = false,
   print: (message: string | Error) => void = console.error,
-): void {
-  if (error instanceof UsingHardhat2PluginError) {
-    printUsingHardhat2Error(error, print);
-    return;
+): Promise<void> {
+  const { category, categorizedError } = await getErrorWithCategory(error);
+
+  let formattedErrorMessage: string;
+  let showMoreInfoMessage: string | undefined;
+  let postErrorStackTraceMessage: string | undefined;
+
+  switch (category) {
+    case ErrorCategory.HARDHAT:
+      formattedErrorMessage = `${styleText(["red", "bold"], `Error ${categorizedError.errorCode}:`)} ${categorizedError.formattedMessage}`;
+      showMoreInfoMessage = `For more info go to ${HARDHAT_WEBSITE_URL}${categorizedError.errorCode} or run ${HARDHAT_NAME} with --show-stack-traces`;
+      break;
+    case ErrorCategory.PLUGIN:
+      formattedErrorMessage = `${styleText(["red", "bold"], `Error ${categorizedError.errorCode} in plugin ${categorizedError.pluginId}:`)} ${categorizedError.formattedMessage}`;
+      showMoreInfoMessage = `For more info go to ${HARDHAT_WEBSITE_URL}${categorizedError.errorCode} or run ${HARDHAT_NAME} with --show-stack-traces`;
+      break;
+    case ErrorCategory.COMMUNITY_PLUGIN:
+      formattedErrorMessage = `${styleText(["red", "bold"], `Error in community plugin ${categorizedError.pluginId}:`)} ${categorizedError.message}`;
+      showMoreInfoMessage = `For more info run ${HARDHAT_NAME} with --show-stack-traces`;
+      break;
+    case ErrorCategory.HH2_TO_HH3_MIGRATION:
+      formattedErrorMessage = styleText(
+        ["red", "bold"],
+        `Hardhat 3 migration error:`,
+      );
+      postErrorStackTraceMessage = `It looks like you are migrating from Hardhat 2 to Hardhat 3. The following error often shows up during this kind of migration.\nPlease read https://hardhat.org/migrate-from-hardhat2 to learn how to migrate your project to Hardhat 3.`;
+      break;
+    case ErrorCategory.CJS_TO_ESM_MIGRATION:
+      formattedErrorMessage = styleText(
+        ["red", "bold"],
+        `Hardhat 3 migration error:`,
+      );
+      postErrorStackTraceMessage = `It looks like you are migrating from CommonJS to ESM. The following error often shows up during this kind of migration.\nPlease read https://hardhat.org/migrate-to-esm to learn how to migrate your project to ESM.`;
+      break;
+    case ErrorCategory.OTHER:
+      formattedErrorMessage = styleText(
+        ["red", "bold"],
+        `An unexpected error occurred:`,
+      );
+      postErrorStackTraceMessage = `If you think this is a bug in Hardhat, please report it here: ${HARDHAT_WEBSITE_URL}report-bug`;
+      break;
   }
 
   const showStackTraces =
     shouldShowStackTraces ||
-    getErrorWithCategory(error).category === ErrorCategory.OTHER;
-  const {
-    formattedErrorMessage,
-    showMoreInfoMessage,
-    postErrorStackTraceMessage,
-  } = getErrorMessages(error);
+    category === ErrorCategory.OTHER ||
+    category === ErrorCategory.HH2_TO_HH3_MIGRATION ||
+    category === ErrorCategory.CJS_TO_ESM_MIGRATION;
 
   print(formattedErrorMessage);
 
@@ -100,7 +143,7 @@ export function printErrorMessages(
   }
 }
 
-function getErrorWithCategory(error: Error): ErrorWithCategory {
+async function getErrorWithCategory(error: Error): Promise<ErrorWithCategory> {
   if (HardhatError.isHardhatError(error)) {
     if (error.pluginId === undefined) {
       return {
@@ -122,49 +165,37 @@ function getErrorWithCategory(error: Error): ErrorWithCategory {
     };
   }
 
+  if (classifierModule === undefined) {
+    classifierModule = await import(
+      "./telemetry/error-classification/classifier.js"
+    );
+  }
+
+  // Pass `ignoreDevelopmentTimeFilter=true` so the migration footer also shows
+  // when hardhat is run from inside its own monorepo — the dev-time filter is
+  // a telemetry concern (don't report to Sentry), unrelated to display routing.
+  const classifierCategory = classifierModule.classifyError(error, true);
+  if (
+    classifierCategory ===
+    classifierModule.ErrorCategory.HH2_TO_HH3_MIGRATION_ERROR
+  ) {
+    return {
+      category: ErrorCategory.HH2_TO_HH3_MIGRATION,
+      categorizedError: error,
+    };
+  }
+  if (
+    classifierCategory ===
+    classifierModule.ErrorCategory.CJS_TO_ESM_MIGRATION_ERROR
+  ) {
+    return {
+      category: ErrorCategory.CJS_TO_ESM_MIGRATION,
+      categorizedError: error,
+    };
+  }
+
   return {
     category: ErrorCategory.OTHER,
     categorizedError: error,
   };
 }
-
-function getErrorMessages(error: Error): ErrorMessages {
-  const { category, categorizedError } = getErrorWithCategory(error);
-  switch (category) {
-    case ErrorCategory.HARDHAT:
-      return {
-        formattedErrorMessage: `${styleText(["red", "bold"], `Error ${categorizedError.errorCode}:`)} ${categorizedError.formattedMessage}`,
-        showMoreInfoMessage: `For more info go to ${HARDHAT_WEBSITE_URL}${categorizedError.errorCode} or run ${HARDHAT_NAME} with --show-stack-traces`,
-      };
-    case ErrorCategory.PLUGIN:
-      return {
-        formattedErrorMessage: `${styleText(["red", "bold"], `Error ${categorizedError.errorCode} in plugin ${categorizedError.pluginId}:`)} ${categorizedError.formattedMessage}`,
-        showMoreInfoMessage: `For more info go to ${HARDHAT_WEBSITE_URL}${categorizedError.errorCode} or run ${HARDHAT_NAME} with --show-stack-traces`,
-      };
-    case ErrorCategory.COMMUNITY_PLUGIN:
-      return {
-        formattedErrorMessage: `${styleText(["red", "bold"], `Error in community plugin ${categorizedError.pluginId}:`)} ${categorizedError.message}`,
-        showMoreInfoMessage: `For more info run ${HARDHAT_NAME} with --show-stack-traces`,
-      };
-    case ErrorCategory.OTHER:
-      return {
-        formattedErrorMessage: styleText(
-          ["red", "bold"],
-          `An unexpected error occurred:`,
-        ),
-        postErrorStackTraceMessage: `If you think this is a bug in Hardhat, please report it here: ${HARDHAT_WEBSITE_URL}report-bug`,
-      };
-  }
-}
-function printUsingHardhat2Error(
-  error: UsingHardhat2PluginError,
-  print: (message: string | Error) => void = console.error,
-): void {
-  print(styleText(["red", "bold"], `Hardhat 3 installation error:`));
-  print("");
-  if (error.callerRelativePath !== undefined) {
-    print(error.message);
-  } else {
-    print(error.stack);
-  }
-}

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

@@ -35,6 +35,7 @@ import { sendErrorTelemetry } from "../telemetry/error-reporter/reporter.js";
 import {
   getDevDependenciesInstallationCommand,
   getPackageManager,
+  getVersion,
   installsPeerDependenciesByDefault,
 } from "./package-manager.js";
 import {
@@ -49,6 +50,10 @@ import {
 import { spawn } from "./subprocess.js";
 import { getTemplates } from "./template.js";
 
+export interface NonInteractiveInitHardhat3Options {
+  template: string;
+}
+
 export interface InitHardhatOptions {
   hardhatVersion?: "hardhat-2" | "hardhat-3";
   workspace?: string;
@@ -60,6 +65,61 @@ export interface InitHardhatOptions {
 
 const log = createDebug("hardhat:core:cli:init");
 
+export async function initHardhat3NonInteractive(
+  options: NonInteractiveInitHardhat3Options,
+): Promise<void> {
+  const [template, projectTypeAnalyticsPromise] = await getTemplate(
+    "hardhat-3",
+    options.template,
+    true,
+  );
+
+  const workspace = process.cwd();
+
+  try {
+    const configFilePath = await findClosestHardhatConfig(workspace);
+
+    throw new HardhatError(
+      HardhatError.ERRORS.CORE.GENERAL.HARDHAT_PROJECT_ALREADY_CREATED,
+      {
+        hardhatProjectRootPath: configFilePath,
+      },
+    );
+  } catch (err) {
+    if (
+      !HardhatError.isHardhatError(
+        err,
+        HardhatError.ERRORS.CORE.GENERAL.NO_CONFIG_FILE_FOUND,
+      )
+    ) {
+      throw err;
+    }
+  }
+
+  await assertNoNonInteractiveClashes(workspace, template);
+
+  console.log("Initializing project...");
+
+  await validatePackageJson(workspace, template.packageJson, true);
+
+  await copyProjectFilesNonInteractive(workspace, template);
+
+  console.log("Installing dependencies...");
+
+  await Promise.all([
+    installProjectDependencies({
+      workspace,
+      template,
+      install: true,
+      update: true,
+      formatSuccessMessage: false,
+    }),
+    projectTypeAnalyticsPromise,
+  ]);
+
+  console.log("Project initialized");
+}
+
 /**
  * initHardhat implements the project initialization wizard flow.
  *
@@ -126,7 +186,11 @@ export async function initHardhat(options?: InitHardhatOptions): Promise<void> {
     // Run them only if the user opts-in to it
     // Concurrently, await the analytics hit
     await Promise.all([
-      installProjectDependencies(workspace, template, options?.install),
+      installProjectDependencies({
+        workspace,
+        template,
+        install: options?.install,
+      }),
       projectTypeAnalyticsPromise,
     ]);
 
@@ -270,12 +334,17 @@ export async function getWorkspace(workspace?: string): Promise<string> {
  *
  * NOTE: This function is exported for testing purposes
  *
+ * @param hardhatVersion The version of Hardhat whose templates should be considered.
  * @param template The name of the template to use for the project initialization.
+ * @param includeAvailableTemplatesInErrors When true, a missing template throws
+ *   `TEMPLATE_NOT_FOUND_WITH_LIST_OF_OPTIONS` (which lists the available
+ *   templates) instead of the bare `TEMPLATE_NOT_FOUND`.
  * @returns A tuple with two elements: the template and a promise with the analytics hit.
  */
 export async function getTemplate(
   hardhatVersion: "hardhat-2" | "hardhat-3",
   template?: string,
+  includeAvailableTemplatesInErrors = false,
 ): Promise<[Template, Promise<boolean>]> {
   const templates = await getTemplates(hardhatVersion);
 
@@ -299,9 +368,38 @@ export async function getTemplate(
   // we wait for the GA hit before throwing
   await projectTypeAnalyticsPromise;
 
-  throw new HardhatError(HardhatError.ERRORS.CORE.GENERAL.TEMPLATE_NOT_FOUND, {
-    template,
-  });
+  if (!includeAvailableTemplatesInErrors) {
+    throw new HardhatError(
+      HardhatError.ERRORS.CORE.GENERAL.TEMPLATE_NOT_FOUND,
+      {
+        template,
+      },
+    );
+  }
+
+  const availableTemplates = templates.map((t) => `  - ${t.name}`).join("\n");
+  throw new HardhatError(
+    HardhatError.ERRORS.CORE.GENERAL.TEMPLATE_NOT_FOUND_WITH_LIST_OF_OPTIONS,
+    {
+      template,
+      availableTemplates,
+    },
+  );
+}
+
+/**
+ * Prints the list of available templates for the specified Hardhat version.
+ *
+ * @param hardhatVersion The version of Hardhat whose templates should be
+ *  printed.
+ */
+export async function printTemplatesList(
+  hardhatVersion: "hardhat-2" | "hardhat-3",
+  print: (message: string) => void = console.log,
+): Promise<void> {
+  const templates = await getTemplates(hardhatVersion);
+  const lines = templates.map((t) => `  - ${t.name}`).join("\n");
+  print(`Available templates:\n${lines}`);
 }
 
 /**
@@ -496,23 +594,100 @@ export async function copyProjectFiles(
   console.log(`✨ ${styleText("cyan", `Template files copied`)} ✨`);
 }
 
+// NOTE: This function is exported for testing purposes
+export async function assertNoNonInteractiveClashes(
+  workspace: string,
+  template: Template,
+): Promise<void> {
+  const clashes: string[] = [];
+
+  for (const relativeTemplatePath of template.files) {
+    const relativeWorkspacePath =
+      relativeTemplateToWorkspacePath(relativeTemplatePath);
+
+    if (
+      relativeWorkspacePath === "package.json" ||
+      relativeWorkspacePath === "README.md" ||
+      path.basename(relativeWorkspacePath) === ".gitignore"
+    ) {
+      continue;
+    }
+
+    if (await exists(path.join(workspace, relativeWorkspacePath))) {
+      clashes.push(relativeWorkspacePath);
+    }
+  }
+
+  if (clashes.length === 0) {
+    return;
+  }
+
+  throw new HardhatError(
+    HardhatError.ERRORS.CORE.GENERAL.NON_INTERACTIVE_INIT_WOULD_OVERWRITE_FILES,
+    {
+      files: clashes.map((f) => `  - ${f}`).join("\n"),
+    },
+  );
+}
+
+// NOTE: This function is exported for testing purposes
+export async function copyProjectFilesNonInteractive(
+  workspace: string,
+  template: Template,
+): Promise<void> {
+  for (const relativeTemplatePath of template.files) {
+    const relativeWorkspacePath =
+      relativeTemplateToWorkspacePath(relativeTemplatePath);
+    let absoluteWorkspacePath = path.join(workspace, relativeWorkspacePath);
+
+    if (path.basename(relativeWorkspacePath) === ".gitignore") {
+      if (await exists(absoluteWorkspacePath)) {
+        continue;
+      }
+    } else if (
+      relativeWorkspacePath === "README.md" &&
+      (await exists(absoluteWorkspacePath))
+    ) {
+      absoluteWorkspacePath = path.join(workspace, "HARDHAT.md");
+      if (await exists(absoluteWorkspacePath)) {
+        continue;
+      }
+    }
+
+    await ensureDir(path.dirname(absoluteWorkspacePath));
+    await copy(
+      path.join(template.path, relativeTemplatePath),
+      absoluteWorkspacePath,
+    );
+  }
+}
+
 /**
  * installProjectDependencies prints the commands to install the project dependencies
  * and runs them if the install option is true or if the user opts-in to it.
  *
  * NOTE: This function is exported for testing purposes
  *
- * @param workspace The path to the workspace to initialize the project in.
- * @param template The template to use for the project initialization.
- * @param install Whether to install the project dependencies.
- * @param update Whether to update the project dependencies.
+ * @param options The installation options.
+ * @param options.workspace The path to the workspace to initialize the project in.
+ * @param options.template The template to use for the project initialization.
+ * @param options.install Whether to install the project dependencies.
+ * @param options.update Whether to update the project dependencies.
+ * @param options.formatSuccessMessage Whether to format the success message or not.
  */
-export async function installProjectDependencies(
-  workspace: string,
-  template: Template,
-  install?: boolean,
-  update?: boolean,
-): Promise<void> {
+export async function installProjectDependencies({
+  workspace,
+  template,
+  install,
+  update,
+  formatSuccessMessage = true,
+}: {
+  workspace: string;
+  template: Template;
+  install?: boolean;
+  update?: boolean;
+  formatSuccessMessage?: boolean;
+}): Promise<void> {
   const pathToWorkspacePackageJson = path.join(workspace, "package.json");
 
   const workspacePkg: PackageJson = await readJsonFile(
@@ -520,6 +695,8 @@ export async function installProjectDependencies(
   );
 
   const packageManager = getPackageManager();
+  const packageManagerVersion = await getVersion(workspace, packageManager);
+  const packageManagerMajorVersion = packageManagerVersion?.[0];
 
   // Find the template dev dependencies that are not already installed
   const templateDependencies = template.packageJson.devDependencies ?? {};
@@ -556,6 +733,7 @@ export async function installProjectDependencies(
     const command = getDevDependenciesInstallationCommand(
       packageManager,
       dependenciesToInstall,
+      packageManagerMajorVersion,
     );
     const commandString = command.join(" ");
 
@@ -587,7 +765,11 @@ export async function installProjectDependencies(
         );
       }
 
-      console.log(`✨ ${styleText("cyan", `Dependencies installed`)} ✨`);
+      if (formatSuccessMessage) {
+        console.log(`✨ ${styleText("cyan", `Dependencies installed`)} ✨`);
+      } else {
+        console.log(`Dependencies installed`);
+      }
     }
   }
 
@@ -610,6 +792,7 @@ export async function installProjectDependencies(
     const command = getDevDependenciesInstallationCommand(
       packageManager,
       dependenciesToUpdate,
+      packageManagerMajorVersion,
     );
     const commandString = command.join(" ");
 
@@ -640,7 +823,11 @@ export async function installProjectDependencies(
         );
       }
 
-      console.log(`✨ ${styleText("cyan", `Dependencies updated`)} ✨`);
+      if (formatSuccessMessage) {
+        console.log(`✨ ${styleText("cyan", `Dependencies updated`)} ✨`);
+      } else {
+        console.log("Dependencies updated");
+      }
     }
   }
 }

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

@@ -104,11 +104,16 @@ export function getPackageManager(): PackageManager {
  *
  * @param packageManager The package manager to use.
  * @param dependencies The dependencies to install.
+ * @param packageManagerMajorVersion The major version of the package manager,
+ * if known. Used to opt into version-specific flags (e.g. pnpm 11's
+ * `--allow-build=esbuild`, required because `tsx` ships `esbuild` whose
+ * postinstall script is otherwise blocked).
  * @returns The installation command.
  */
 export function getDevDependenciesInstallationCommand(
   packageManager: PackageManager,
   dependencies: string[],
+  packageManagerMajorVersion?: number,
 ): string[] {
   const packageManagerToCommand: Record<PackageManager, string[]> = {
     npm: ["npm", "install", "--save-dev"],
@@ -118,6 +123,18 @@ export function getDevDependenciesInstallationCommand(
     bun: ["bun", "add", "--dev"],
   };
   const command = packageManagerToCommand[packageManager];
+
+  // NOTE: adding an unnecessary flag doesn't result in an error
+  // nor warning, so we don't check if hardhat or tsx are being
+  // installed.
+  if (
+    packageManager === "pnpm" &&
+    packageManagerMajorVersion !== undefined &&
+    packageManagerMajorVersion >= 11
+  ) {
+    command.push("--allow-build=esbuild");
+  }
+
   // We quote all the dependency identifiers so that they can be run on a shell
   // without semver symbols interfering with the command
   command.push(
@@ -205,7 +222,7 @@ export async function installsPeerDependenciesByDefault(
   }
 }
 
-async function getVersion(
+export async function getVersion(
   workspace: string,
   packageManager: PackageManager,
   version?: string,

package/src/internal/cli/main.ts

@@ -96,7 +96,70 @@ export async function main(
     }
 
     if (builtinGlobalOptions.init) {
-      const { initHardhat } = await import("./init/init.js");
+      const { initHardhat, initHardhat3NonInteractive, printTemplatesList } =
+        await import("./init/init.js");
+
+      let templateName: string | undefined;
+      let listTemplates = false;
+
+      for (let i = 0; i < cliArguments.length; i++) {
+        if (usedCliArguments[i]) {
+          continue;
+        }
+
+        if (cliArguments[i] === "--templates") {
+          usedCliArguments[i] = true;
+          listTemplates = true;
+        }
+      }
+
+      for (let i = 0; i < cliArguments.length; i++) {
+        if (usedCliArguments[i]) {
+          continue;
+        }
+
+        if (cliArguments[i] === "--template") {
+          usedCliArguments[i] = true;
+
+          if (templateName !== undefined) {
+            throw new HardhatError(
+              HardhatError.ERRORS.CORE.ARGUMENTS.DUPLICATED_NAME,
+              { name: "--template" },
+            );
+          }
+
+          if (listTemplates) {
+            throw new HardhatError(
+              HardhatError.ERRORS.CORE.ARGUMENTS.CANNOT_COMBINE_TEMPLATE_AND_TEMPLATES,
+            );
+          }
+
+          if (
+            usedCliArguments[i + 1] === undefined ||
+            usedCliArguments[i + 1] === true ||
+            cliArguments[i + 1] === undefined ||
+            cliArguments[i + 1].startsWith("-")
+          ) {
+            throw new HardhatError(
+              HardhatError.ERRORS.CORE.ARGUMENTS.MISSING_VALUE_FOR_ARGUMENT,
+              { argument: "--template" },
+            );
+          }
+
+          templateName = cliArguments[i + 1];
+          i++;
+          usedCliArguments[i] = true;
+        }
+      }
+
+      if (listTemplates) {
+        return await printTemplatesList("hardhat-3", print);
+      }
+
+      if (templateName !== undefined) {
+        return await initHardhat3NonInteractive({ template: templateName });
+      }
+
       return await initHardhat();
     }
 
@@ -255,7 +318,7 @@ export async function main(
     }
   } catch (error) {
     ensureError(error);
-    printErrorMessages(error, builtinGlobalOptions?.showStackTraces);
+    await printErrorMessages(error, builtinGlobalOptions?.showStackTraces);
 
     try {
       await sendErrorTelemetry(error);

package/src/internal/cli/telemetry/error-classification/classifier.ts

@@ -70,7 +70,8 @@ import {
  * @param error The error to classify.
  * @param ignoreDevelopmentTimeFilter If true, the classifier will ignore the
  * development-time filter, which is used to exclude errors that happen during
- * development of Hardhat itself. This is only meant to be used for testing.
+ * development of Hardhat itself. Set this from display-side callers (where the
+ * dev-time skip is irrelevant) and from tests.
  * @returns The error category.
  */
 export function classifyError(