hardhat 3.5.0 → 3.6.0

package/src/internal/builtin-plugins/solidity/type-extensions.ts

@@ -5,10 +5,13 @@ import type {
   FileBuildResult,
   SolidityBuildSystem,
 } from "../../../types/solidity/build-system.js";
+import type { CompilationJob } from "../../../types/solidity/compilation-job.js";
+import type { CompilerOutputError } from "../../../types/solidity/compiler-io.js";
 import type {
   Compiler,
   CompilerInput,
   CompilerOutput,
+  ResolvedBuildOptions,
 } from "../../../types/solidity.js";
 
 declare module "../../../types/config.js" {
@@ -359,6 +362,7 @@ declare module "../../../types/hooks.js" {
      * @param compilerConfig The compiler configuration to get a compiler for.
      * @param next A function to call the next handler for this hook.
      * @returns A Compiler instance.
+     * @deprecated This hook will soon be removed.
      */
     getCompiler: (
       context: HookContext,
@@ -377,6 +381,8 @@ declare module "../../../types/hooks.js" {
      * @param artifactPaths The file paths of artifacts that remain after cleanup.
      * @param next A function to call the next handler for this hook, or the
      * default implementation if no more handlers exist.
+     * @deprecated This hook will soon be removed. Use
+     * `processArtifactsAfterSuccessfulBuild` instead.
      */
     onCleanUpArtifacts: (
       context: HookContext,
@@ -402,6 +408,7 @@ declare module "../../../types/hooks.js" {
      * default implementation if no more handlers exist.
      *
      * @returns The modified file content.
+     * @deprecated This hook will soon be removed.
      */
     preprocessProjectFileBeforeBuilding(
       context: HookContext,
@@ -427,6 +434,7 @@ declare module "../../../types/hooks.js" {
      * default implementation if no more handlers exist.
      *
      * @returns The modified solc input.
+     * @deprecated This hook will soon be removed.
      */
     preprocessSolcInputBeforeBuilding(
       context: HookContext,
@@ -437,6 +445,9 @@ declare module "../../../types/hooks.js" {
       ) => Promise<CompilerInput>,
     ): Promise<CompilerInput>;
 
+    /**
+     * @deprecated This hook will soon be removed.
+     */
     readSourceFile: (
       context: HookContext,
       absolutePath: string,
@@ -482,6 +493,7 @@ declare module "../../../types/hooks.js" {
      * @param solcConfig The compiler configuration (version, type, etc.).
      * @param next A function to call the next handler for this hook, or the
      * default implementation if no more handlers exist.
+     * @deprecated This hook will soon be removed. Use `getCompilationJobErrors` instead.
      */
     invokeSolc(
       context: HookContext,
@@ -510,6 +522,7 @@ declare module "../../../types/hooks.js" {
      * @param next A function to get remappings from other sources (including default behavior).
      * @returns An array of remapping sources, each containing an array of remapping strings
      *   and the source path they came from.
+     * @deprecated This hook will soon be removed.
      */
     readNpmPackageRemappings: (
       context: HookContext,
@@ -523,5 +536,61 @@ declare module "../../../types/hooks.js" {
         nextPackagePath: string,
       ) => Promise<Array<{ remappings: string[]; source: string }>>,
     ) => Promise<Array<{ remappings: string[]; source: string }>>;
+
+    /**
+     * Sequential hook run when a solidity build finished successfully,
+     * and the artifacts are ready to be processed by a plugin.
+     *
+     * This hook is only run for the "contracts" scope, and never includes
+     * test artifacts in its parameters.
+     *
+     * @param context The hook context.
+     * @param artifactPaths All the contract artifact paths, including
+     * pre-existing ones.
+     * @param buildRootFilePaths The root file paths provided to the build,
+     * as absolute paths or `npm:<package-name>/<file-path>` identifiers. In
+     * unified mode this may include test files.
+     * @param buildOptions The resolved options used during the build, with
+     * the build system's defaults filled in for any field the caller didn't
+     * provide.
+     */
+    processArtifactsAfterSuccessfulBuild(
+      context: HookContext,
+      artifactPaths: readonly string[],
+      buildRootFilePaths: readonly string[],
+      buildOptions: Readonly<ResolvedBuildOptions>,
+    ): Promise<void>;
+
+    /**
+     * A hook run to get and potentially process the errors of the compiler
+     * output after it was run by the build system.
+     *
+     * This hook allows plugin authors to process the compiler output errors
+     * list before it's used by the build system to report them to the users,
+     * but it doesn't let plugins alter the logic that determines if a
+     * compilation job succeeded or failed.
+     *
+     * This hook must not mutate the parameters passed to `next`. Doing so can
+     * have unexpected behavior, and will eventually crash Hardhat.
+     *
+     * The recommended way to use this hook is to call `next` first, and then
+     * work with the returned list.
+     *
+     * @param context The hook context.
+     * @param compilationJob The compilation job run by the build system.
+     * @param compilerOutput The output returned by the compiler.
+     * @param next A function to call the next handler for this hook.
+     * @returns The processed compiler output error list.
+     */
+    getCompilationJobErrors(
+      context: HookContext,
+      compilationJob: Readonly<CompilationJob>,
+      compilerOutput: Readonly<CompilerOutput>,
+      next: (
+        nextContext: HookContext,
+        nextCompilationJob: Readonly<CompilationJob>,
+        nextCompilerOutput: Readonly<CompilerOutput>,
+      ) => Promise<CompilerOutputError[]>,
+    ): Promise<CompilerOutputError[]>;
   }
 }

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/help/utils.ts

@@ -7,6 +7,8 @@ import type { Task } from "../../../types/tasks.js";
 
 import { camelToKebabCase } from "@nomicfoundation/hardhat-utils/string";
 
+import { isArgumentRequired } from "../../core/tasks/utils.js";
+
 export const GLOBAL_NAME_PADDING = 6;
 
 interface ArgumentDescriptor {
@@ -84,11 +86,16 @@ export function parseOptions(task: Task): {
     });
   }
 
-  for (const { name, description, defaultValue } of task.positionalArguments) {
+  for (const {
+    name,
+    description,
+    defaultValue,
+    type,
+  } of task.positionalArguments) {
     positionalArguments.push({
       name,
       description: trimFullStop(description),
-      isRequired: defaultValue === undefined,
+      isRequired: isArgumentRequired(type, defaultValue),
       ...(defaultValue !== undefined && {
         defaultValue: Array.isArray(defaultValue)
           ? defaultValue.join(", ")

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

@@ -14,11 +14,16 @@ import {
   copy,
   ensureDir,
   exists,
+  getAllFilesMatching,
   isDirectory,
   mkdir,
   readJsonFile,
+  remove,
+  symlink,
   writeJsonFile,
+  writeUtf8File,
 } from "@nomicfoundation/hardhat-utils/fs";
+import { findClosestPackageRoot } from "@nomicfoundation/hardhat-utils/package";
 import { resolveFromRoot } from "@nomicfoundation/hardhat-utils/path";
 import * as semver from "semver";
 
@@ -35,6 +40,7 @@ import { sendErrorTelemetry } from "../telemetry/error-reporter/reporter.js";
 import {
   getDevDependenciesInstallationCommand,
   getPackageManager,
+  getVersion,
   installsPeerDependenciesByDefault,
 } from "./package-manager.js";
 import {
@@ -590,6 +596,10 @@ export async function copyProjectFiles(
     await copy(absoluteTemplatePath, absoluteWorkspacePath);
   }
 
+  await installSkills(workspace, template, force);
+  await createClaudeMd(workspace, force);
+  await createDotClaude(workspace);
+
   console.log(`✨ ${styleText("cyan", `Template files copied`)} ✨`);
 }
 
@@ -659,6 +669,133 @@ export async function copyProjectFilesNonInteractive(
       absoluteWorkspacePath,
     );
   }
+
+  await installSkills(workspace, template);
+  await createClaudeMd(workspace);
+  await createDotClaude(workspace);
+}
+
+/**
+ * Skills published from `packages/hardhat/skills/` and the npm package whose presence
+ * in a template's dependencies opts that template into installing the skill.
+ * Each skill is tied to exactly one package so they can be versioned and
+ * upgraded independently.
+ */
+const SKILL_PACKAGES: ReadonlyArray<{
+  packageName: string;
+  skillName: string;
+}> = [
+  { packageName: "hardhat", skillName: "hardhat" },
+  {
+    packageName: "@nomicfoundation/hardhat-toolbox-viem",
+    skillName: "hardhat-toolbox-viem",
+  },
+  {
+    packageName: "@nomicfoundation/hardhat-toolbox-mocha-ethers",
+    skillName: "hardhat-toolbox-mocha-ethers",
+  },
+];
+
+/**
+ * For agent-aware templates (those that ship an `AGENTS.md`), copies any
+ * skills from `packages/hardhat/skills/` whose corresponding package is a template
+ * dependency into `<workspace>/.agents/skills/<skill-name>/`.
+ */
+async function installSkills(
+  workspace: string,
+  template: Template,
+  force?: boolean,
+): Promise<void> {
+  if (!template.files.includes("AGENTS.md")) {
+    return;
+  }
+
+  const deps = {
+    ...template.packageJson.dependencies,
+    ...template.packageJson.devDependencies,
+  };
+  const relevantSkills = SKILL_PACKAGES.filter(
+    ({ packageName }) => deps[packageName] !== undefined,
+  );
+  if (relevantSkills.length === 0) {
+    return;
+  }
+
+  const hardhatPackageRoot = await findClosestPackageRoot(import.meta.url);
+  const skillsRoot = path.join(hardhatPackageRoot, "skills");
+
+  for (const { skillName } of relevantSkills) {
+    const skillSrcDir = path.join(skillsRoot, skillName);
+    const skillDestDir = path.join(workspace, ".agents", "skills", skillName);
+    const skillFiles = await getAllFilesMatching(skillSrcDir);
+    for (const file of skillFiles) {
+      const dest = path.join(skillDestDir, path.relative(skillSrcDir, file));
+      if (force !== true && (await exists(dest))) {
+        continue;
+      }
+      await ensureDir(path.dirname(dest));
+      await copy(file, dest);
+    }
+  }
+}
+
+/**
+ * Creates a `CLAUDE.md` file if an `AGENTS.md` file exists. Uses a symlink
+ * except on Windows, where a file is created that references `AGENTS.md`.
+ * Overwrites an existing `CLAUDE.md` only if `force` is true.
+ */
+async function createClaudeMd(
+  workspace: string,
+  force?: boolean,
+): Promise<void> {
+  const agentsMdPath = path.join(workspace, "AGENTS.md");
+  if (!(await exists(agentsMdPath))) {
+    return;
+  }
+
+  const claudeMdPath = path.join(workspace, "CLAUDE.md");
+  if (await exists(claudeMdPath, { followSymlinks: false })) {
+    if (force !== true) {
+      return;
+    }
+    await remove(claudeMdPath);
+  }
+
+  if (process.platform === "win32") {
+    await writeUtf8File(claudeMdPath, "@AGENTS.md\n");
+  } else {
+    await symlink("AGENTS.md", claudeMdPath);
+  }
+}
+
+/**
+ * Creates `.claude` if `.agents` exists. Uses a symlink except on Windows,
+ * where the whole directory is copied. Does nothing if `.claude` already
+ * exists; the `force` flag is intentionally not used here because
+ * overwriting depends on whether the existing `.claude` is a file, directory,
+ * or symlink, and on the OS, which is more complexity than is worthwhile.
+ */
+async function createDotClaude(workspace: string): Promise<void> {
+  const agentsDirPath = path.join(workspace, ".agents");
+  if (!(await exists(agentsDirPath))) {
+    return;
+  }
+
+  const claudeDirPath = path.join(workspace, ".claude");
+  if (await exists(claudeDirPath, { followSymlinks: false })) {
+    return;
+  }
+
+  if (process.platform === "win32") {
+    const agentsFiles = await getAllFilesMatching(agentsDirPath);
+    for (const file of agentsFiles) {
+      const dest = path.join(claudeDirPath, path.relative(agentsDirPath, file));
+      await ensureDir(path.dirname(dest));
+      await copy(file, dest);
+    }
+  } else {
+    await symlink(".agents", claudeDirPath);
+  }
 }
 
 /**
@@ -694,6 +831,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 ?? {};
@@ -730,6 +869,7 @@ export async function installProjectDependencies({
     const command = getDevDependenciesInstallationCommand(
       packageManager,
       dependenciesToInstall,
+      packageManagerMajorVersion,
     );
     const commandString = command.join(" ");
 
@@ -788,6 +928,7 @@ export async function installProjectDependencies({
     const command = getDevDependenciesInstallationCommand(
       packageManager,
       dependenciesToUpdate,
+      packageManagerMajorVersion,
     );
     const commandString = command.join(" ");
 

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

@@ -40,6 +40,7 @@ import { parseArgumentValue } from "../core/arguments.js";
 import { buildGlobalOptionDefinitions } from "../core/global-options.js";
 import { resolveProjectRoot } from "../core/hre.js";
 import { resolvePluginList } from "../core/plugins/resolve-plugin-list.js";
+import { isArgumentRequired } from "../core/tasks/utils.js";
 import { setGlobalHardhatRuntimeEnvironment } from "../global-hre-instance.js";
 import { createHardhatRuntimeEnvironment } from "../hre-initialization.js";
 
@@ -318,7 +319,7 @@ export async function main(
     }
   } catch (error) {
     ensureError(error);
-    printErrorMessages(error, builtinGlobalOptions?.showStackTraces);
+    await printErrorMessages(error, builtinGlobalOptions?.showStackTraces);
 
     try {
       await sendErrorTelemetry(error);
@@ -767,8 +768,9 @@ function validateRequiredArguments(
   taskArguments: TaskArguments,
 ) {
   const missingRequiredArgument = argumentDefinitions.find(
-    ({ defaultValue, name }) =>
-      defaultValue === undefined && taskArguments[name] === undefined,
+    ({ defaultValue, name, type }) =>
+      isArgumentRequired(type, defaultValue) &&
+      taskArguments[name] === undefined,
   );
 
   if (missingRequiredArgument === undefined) {

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(