hardhat 3.9.0 → 3.10.0

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

@@ -32,6 +32,22 @@ import { DEFAULT_TEST_PROFILE } from "./test-profiles.js";
 export const DEFAULT_FUZZ_SEED =
   "0x7727ea51af0441c20da14dcd68a15dac8c9ebd589c5be8fa8c87c1d3720450bc";
 
+const nonnegativeSafeIntOrBigInt = unionType(
+  [z.number().int().nonnegative().safe(), z.bigint().nonnegative()],
+  "Expected a nonnegative safe int or a nonnegative bigint",
+);
+
+const nonnegativeSafeIntOrSafeBigInt = unionType(
+  [
+    z.number().int().nonnegative().safe(),
+    z
+      .bigint()
+      .nonnegative()
+      .refine((value) => value <= BigInt(Number.MAX_SAFE_INTEGER)),
+  ],
+  "Expected a nonnegative safe int or a nonnegative safe bigint",
+);
+
 const solidityTestProfileUserConfigType = z.object({
   fsPermissions: z
     .object({
@@ -54,11 +70,9 @@ const solidityTestProfileUserConfigType = z.object({
   blockTimestamp: z.bigint().optional(),
   prevRandao: z.bigint().optional(),
   gasLimit: z.bigint().optional(),
+  memoryLimit: nonnegativeSafeIntOrBigInt.optional(),
   blockGasLimit: z.number().or(z.bigint()).or(z.literal(false)).optional(),
-  // TODO: widen back to .number().or(z.bigint()).or(z.literal(false))
-  // once Solidity test runner no longer breaks setUp() when
-  // disableTransactionGasCap is false. See PR #8301.
-  transactionGasCap: z.literal(false).optional(),
+  transactionGasCap: z.number().or(z.bigint()).or(z.literal(false)).optional(),
   fuzz: z
     .object({
       failurePersistDir: z.string().optional(),
@@ -70,6 +84,7 @@ const solidityTestProfileUserConfigType = z.object({
       includeStorage: z.boolean().optional(),
       includePushBytes: z.boolean().optional(),
       showLogs: z.boolean().optional(),
+      timeout: nonnegativeSafeIntOrSafeBigInt.optional(),
     })
     .optional(),
   forking: z
@@ -95,6 +110,7 @@ const solidityTestProfileUserConfigType = z.object({
       includeStorage: z.boolean().optional(),
       includePushBytes: z.boolean().optional(),
       shrinkRunLimit: z.number().optional(),
+      timeout: nonnegativeSafeIntOrSafeBigInt.optional(),
     })
     .optional(),
   eip712Types: z
@@ -225,12 +241,22 @@ export async function resolveSolidityTestUserConfig(
     resolveConfigurationVariable,
   );
 
+  const {
+    memoryLimit,
+    fuzz,
+    invariant,
+    eip712Types,
+    ...otherProfileUserConfig
+  } = profileUserConfig ?? {};
+
   const resolvedDefaultProfile = {
     rpcCachePath: defaultRpcCachePath,
-    ...profileUserConfig,
-    fuzz: resolveFuzzConfig(profileUserConfig?.fuzz),
+    ...otherProfileUserConfig,
+    memoryLimit: memoryLimit !== undefined ? BigInt(memoryLimit) : undefined,
+    fuzz: resolveFuzzConfig(fuzz),
+    invariant: resolveInvariantConfig(invariant),
     forking: resolvedForking,
-    eip712Types: resolveEip712TypesConfig(profileUserConfig?.eip712Types),
+    eip712Types: resolveEip712TypesConfig(eip712Types),
   };
 
   return {
@@ -254,9 +280,27 @@ export async function resolveSolidityTestUserConfig(
 export function resolveFuzzConfig(
   fuzzUserConfig: SolidityTestProfileUserConfig["fuzz"] = {},
 ): SolidityTestProfileConfig["fuzz"] {
+  const { seed, timeout, ...otherFuzzUserConfig } = fuzzUserConfig;
+
+  return {
+    ...otherFuzzUserConfig,
+    seed: seed ?? DEFAULT_FUZZ_SEED,
+    ...(timeout !== undefined ? { timeout: Number(timeout) } : {}),
+  };
+}
+
+export function resolveInvariantConfig(
+  invariantUserConfig: SolidityTestProfileUserConfig["invariant"],
+): SolidityTestProfileConfig["invariant"] {
+  if (invariantUserConfig === undefined) {
+    return undefined;
+  }
+
+  const { timeout, ...otherInvariantUserConfig } = invariantUserConfig;
+
   return {
-    ...fuzzUserConfig,
-    seed: fuzzUserConfig.seed ?? DEFAULT_FUZZ_SEED,
+    ...otherInvariantUserConfig,
+    ...(timeout !== undefined ? { timeout: Number(timeout) } : {}),
   };
 }
 

package/src/internal/builtin-plugins/solidity-test/eip712/canonicalize.ts

@@ -2,6 +2,12 @@ import type { CollectedStruct } from "./ast-walker.js";
 
 import { HardhatError } from "@nomicfoundation/hardhat-errors";
 
+export const SELECTED_CONFLICT_REMEDIATION =
+  "Rename one of the structs, or scope your `test.solidity.eip712Types.include` / `exclude` globs in `hardhat.config.ts` so that only one of them is selected.";
+
+export const DEPENDENCY_CONFLICT_REMEDIATION =
+  "Rename one of the structs so the name has a single definition. The clashing name is pulled in as a dependency of a selected struct, so if you don't need that selected struct, deselecting it with your `test.solidity.eip712Types.include` / `exclude` globs in `hardhat.config.ts` also resolves the conflict.";
+
 /**
  * Produces the flat list of canonical EIP-712 type strings expected by EDR.
  *
@@ -25,14 +31,28 @@ import { HardhatError } from "@nomicfoundation/hardhat-errors";
  * constructs and propagates `None` through the dep graph so dependents are
  * also dropped.
  *
- * Only names in `selectedNames` are emitted; non-selected structs still
- * participate in dep resolution so cross-file deps inline correctly.
+ * Selection is scoped by source, not by struct name: `selectedSources` holds
+ * the project-relative paths matched by the user's include/exclude globs. Only
+ * structs from those sources are emitted, but structs elsewhere still feed dep
+ * resolution so cross-file deps inline correctly. Scoping by source is what
+ * lets a non-selected file define a same-named struct without it being mistaken
+ * for selected.
  */
 export function canonicalizeStructs(
   structs: CollectedStruct[],
-  selectedNames: Set<string>,
+  selectedSources: Set<string>,
 ): string[] {
-  const byName = indexByName(structs, selectedNames);
+  // A name is "selected" if any of its definitions lives in a selected source.
+  // Drives what's emitted and, in `indexByName`, whether a selected definition
+  // exists to win a name collision.
+  const selectedNames = new Set<string>();
+  for (const struct of structs) {
+    if (selectedSources.has(struct.sourcePath)) {
+      selectedNames.add(struct.name);
+    }
+  }
+
+  const byName = indexByName(structs, selectedSources, selectedNames);
   const knownNames = new Set(byName.keys());
   const encodable = computeEncodable(byName, knownNames);
   const result: string[] = [];
@@ -189,15 +209,27 @@ function transitiveDeps(
  * non decodable definition silently win over an encodable one, dropping the
  * struct from the canonical output.
  *
- * Conflicts on a name reachable from any selected struct (selected roots plus
- * their transitive deps) throw, since the selected struct's inlined dep head
- * would otherwise depend on which conflicting copy happened to be seen first.
- * Conflicts on names truly unreachable from the selected set are silently
- * deduped (first wins). Selected structs are processed first so they win over
- * non-selected copies.
+ * A name clash aborts the run only when it could change the output; otherwise
+ * the first definition wins silently. Selection is scoped by source
+ * (`selectedSources`), not by name, so a non-selected source whose struct name
+ * collides with a selected one stays non-selected. `selectedNames` is the
+ * derived set of names with at least one selected definition. Selected structs
+ * are processed first, so the already-stored definition in any collision is
+ * selected when one exists. Two rules resolve conflicts:
+ *
+ *   - Both sides selected: throw immediately — genuinely ambiguous which to
+ *     emit.
+ *   - Current side non-selected: defer; the stored definition keeps the name.
+ *     Throw only if the name is reachable from a selected struct (its
+ *     transitive deps), since then which copy got inlined would depend on
+ *     iteration order. Names unreachable from the selected set are silently
+ *     deduped (first wins), so a non-selected struct that merely shares a
+ *     name with a selected root or an unreferenced struct never aborts the
+ *     run.
  */
 function indexByName(
   structs: CollectedStruct[],
+  selectedSources: Set<string>,
   selectedNames: Set<string>,
 ): Map<string, CollectedStruct> {
   const byName = new Map<string, CollectedStruct>();
@@ -209,8 +241,8 @@ function indexByName(
   >();
 
   const ordered = [
-    ...structs.filter((s) => selectedNames.has(s.name)),
-    ...structs.filter((s) => !selectedNames.has(s.name)),
+    ...structs.filter((s) => selectedSources.has(s.sourcePath)),
+    ...structs.filter((s) => !selectedSources.has(s.sourcePath)),
   ];
 
   for (const struct of ordered) {
@@ -228,24 +260,31 @@ function indexByName(
       continue;
     }
 
-    if (!selectedNames.has(struct.name)) {
-      if (!deferredConflicts.has(struct.name)) {
-        deferredConflicts.set(struct.name, {
+    if (selectedSources.has(struct.sourcePath)) {
+      // Selected-vs-selected conflict: both this and the stored definition are
+      // selected (selected structs come first), so it's ambiguous which to emit.
+      throw new HardhatError(
+        HardhatError.ERRORS.CORE.SOLIDITY_TESTS.EIP712_DUPLICATE_STRUCT_NAME,
+        {
+          name: struct.name,
           firstSource: sourceByName.get(struct.name) ?? "<unknown>",
           secondSource: struct.sourcePath,
-        });
-      }
-      continue;
+          remediation: SELECTED_CONFLICT_REMEDIATION,
+        },
+      );
     }
 
-    throw new HardhatError(
-      HardhatError.ERRORS.CORE.SOLIDITY_TESTS.EIP712_DUPLICATE_STRUCT_NAME,
-      {
-        name: struct.name,
+    // Non-selected side, so the stored definition (selected if the name has
+    // one, since selected sources come first) keeps the name. Defer: throw
+    // later only if the name is reachable from a selected struct. Sharing a
+    // name with a selected root or an unreferenced struct is harmless and
+    // must not abort.
+    if (!deferredConflicts.has(struct.name)) {
+      deferredConflicts.set(struct.name, {
         firstSource: sourceByName.get(struct.name) ?? "<unknown>",
         secondSource: struct.sourcePath,
-      },
-    );
+      });
+    }
   }
 
   if (deferredConflicts.size > 0) {
@@ -254,7 +293,7 @@ function indexByName(
       if (reachable.has(name)) {
         throw new HardhatError(
           HardhatError.ERRORS.CORE.SOLIDITY_TESTS.EIP712_DUPLICATE_STRUCT_NAME,
-          { name, ...sources },
+          { name, ...sources, remediation: DEPENDENCY_CONFLICT_REMEDIATION },
         );
       }
     }

package/src/internal/builtin-plugins/solidity-test/eip712/index.ts

@@ -2,10 +2,12 @@ import type { CollectedStruct } from "./ast-walker.js";
 import type { SolidityBuildInfoOutput } from "../../../../types/solidity/solidity-artifacts.js";
 import type { BuildInfoAndOutput } from "../edr-artifacts.js";
 
+import { HardhatError } from "@nomicfoundation/hardhat-errors";
 import {
   bytesIncludesUtf8String,
-  bytesToUtf8String,
+  parseJsonBytes,
 } from "@nomicfoundation/hardhat-utils/bytes";
+import { ensureError } from "@nomicfoundation/hardhat-utils/error";
 
 import { isPathSelected } from "../../../utils/glob.js";
 import { toUserSourceName } from "../../solidity/source-names.js";
@@ -35,11 +37,11 @@ export interface Eip712TypesConfig {
  * When `include` is empty/unset the feature is off: collection short-circuits
  * and returns an empty list without parsing any build info.
  */
-export function collectEip712CanonicalTypes(
+export async function collectEip712CanonicalTypes(
   buildInfosAndOutputs: BuildInfoAndOutput[],
   inputToUserSource: ReadonlyMap<string, string>,
   config: Eip712TypesConfig,
-): string[] {
+): Promise<string[]> {
   const { include, exclude } = config;
 
   if (include.length === 0) {
@@ -47,18 +49,26 @@ export function collectEip712CanonicalTypes(
   }
 
   const collected: CollectedStruct[] = [];
-  const selectedNames = new Set<string>();
+  const selectedSources = new Set<string>();
 
-  for (const { buildInfo, output } of buildInfosAndOutputs) {
+  for (const { buildInfoId, buildInfo, output } of buildInfosAndOutputs) {
     // Byte-level fast path: a build info whose source bytes don't contain
     // `struct ` can't define any EIP-712 type, so skip JSON-parsing its output.
     if (!bytesIncludesUtf8String(buildInfo, "struct ")) {
       continue;
     }
 
-    const parsedOutput: SolidityBuildInfoOutput = JSON.parse(
-      bytesToUtf8String(output),
-    );
+    let parsedOutput: SolidityBuildInfoOutput;
+    try {
+      parsedOutput = await parseJsonBytes<SolidityBuildInfoOutput>(output);
+    } catch (error) {
+      ensureError(error);
+      throw new HardhatError(
+        HardhatError.ERRORS.CORE.SOLIDITY.BUILD_INFO_OUTPUT_PARSE_ERROR,
+        { buildInfoId },
+        error,
+      );
+    }
 
     const sources = parsedOutput.output.sources;
     if (sources === undefined) {
@@ -92,7 +102,9 @@ export function collectEip712CanonicalTypes(
         toUserSourceName(inputSourceName);
 
       // Collect every source so non-selected files can serve as dep targets;
-      // selection is enforced at emit time via `selectedNames`.
+      // `selectedSources` enforces selection at emit time. Tracked per source,
+      // not per struct name, so a non-selected source defining a same-named
+      // struct isn't treated as selected (see `canonicalizeStructs`).
       const structs = extractStructsFromAst(
         source.ast,
         userSourceName,
@@ -101,12 +113,10 @@ export function collectEip712CanonicalTypes(
       collected.push(...structs);
 
       if (isPathSelected(userSourceName, include, exclude)) {
-        for (const s of structs) {
-          selectedNames.add(s.name);
-        }
+        selectedSources.add(userSourceName);
       }
     }
   }
 
-  return canonicalizeStructs(collected, selectedNames);
+  return canonicalizeStructs(collected, selectedSources);
 }

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

@@ -25,6 +25,7 @@ import { hexStringToBytes } from "@nomicfoundation/hardhat-utils/hex";
 import { DEFAULT_VERBOSITY, OPTIMISM_CHAIN_TYPE } from "../../constants.js";
 import { resolveHardfork } from "../network-manager/config-resolution.js";
 import { hardhatHardforkToEdrSpecId } from "../network-manager/edr/utils/convert-to-edr.js";
+import { warnIfExperimentalHardfork } from "../network-manager/edr/utils/hardfork.js";
 import { verbosityToIncludeTraces } from "../network-manager/edr/utils/trace-formatters.js";
 
 import { formatArtifactId } from "./formatters.js";
@@ -88,8 +89,11 @@ export async function solidityTestConfigToSolidityTestRunnerConfigArgs({
   const txOrigin = hexToBytes(config.txOrigin);
   const blockCoinbase = hexToBytes(config.coinbase);
 
+  const resolvedHardforkName = resolveHardfork(hardfork, chainType);
+  warnIfExperimentalHardfork(resolvedHardforkName, chainType);
+
   const resolvedHardfork = hardhatHardforkToEdrSpecId(
-    resolveHardfork(hardfork, chainType),
+    resolvedHardforkName,
     chainType,
   );
 

package/src/internal/builtin-plugins/solidity-test/inline-config/index.ts

@@ -10,7 +10,8 @@ import {
   HardhatError,
   assertHardhatInvariant,
 } from "@nomicfoundation/hardhat-errors";
-import { bytesToUtf8String } from "@nomicfoundation/hardhat-utils/bytes";
+import { parseJsonBytes } from "@nomicfoundation/hardhat-utils/bytes";
+import { ensureError } from "@nomicfoundation/hardhat-utils/error";
 
 import { getFullyQualifiedName } from "../../../../utils/contract-names.js";
 
@@ -48,11 +49,11 @@ interface CollectedOverrides {
  * in the solc AST. It only extracts them from the build info where each
  * test artifact's file was compiled as a root file.
  */
-export function getTestFunctionOverrides(
+export async function getTestFunctionOverrides(
   testSuiteArtifacts: EdrArtifactWithMetadata[],
   buildInfosAndOutputs: BuildInfoAndOutput[],
-): TestFunctionOverride[] {
-  const allRawOverrides = collectRawOverrides(
+): Promise<TestFunctionOverride[]> {
+  const allRawOverrides = await collectRawOverrides(
     testSuiteArtifacts,
     buildInfosAndOutputs,
   );
@@ -62,10 +63,10 @@ export function getTestFunctionOverrides(
   return buildTestFunctionOverrides(allRawOverrides);
 }
 
-function collectRawOverrides(
+async function collectRawOverrides(
   testSuiteArtifacts: EdrArtifactWithMetadata[],
   buildInfosAndOutputs: BuildInfoAndOutput[],
-): CollectedOverrides {
+): Promise<CollectedOverrides> {
   const overrides: RawInlineOverride[] = [];
   const methodIdentifiersByContract = new Map<string, Record<string, string>>();
 
@@ -153,9 +154,19 @@ function collectRawOverrides(
       continue;
     }
 
-    const buildInfoOutput: SolidityBuildInfoOutput = JSON.parse(
-      bytesToUtf8String(buildInfoAndOutput.output),
-    );
+    let buildInfoOutput: SolidityBuildInfoOutput;
+    try {
+      buildInfoOutput = await parseJsonBytes<SolidityBuildInfoOutput>(
+        buildInfoAndOutput.output,
+      );
+    } catch (error) {
+      ensureError(error);
+      throw new HardhatError(
+        HardhatError.ERRORS.CORE.SOLIDITY.BUILD_INFO_OUTPUT_PARSE_ERROR,
+        { buildInfoId },
+        error,
+      );
+    }
 
     for (const [
       inputSourceName,

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

@@ -6,6 +6,7 @@ import {
   StackTraceEntryType,
   CheatcodeErrorCode,
 } from "../network-manager/edr/stack-traces/solidity-stack-trace.js";
+import { getCheatcodeSuggestion } from "../network-manager/edr/stack-traces/stack-trace-solidity-errors.js";
 
 export function getMessageFromLastStackTraceEntry(
   stackTraceEntry: SolidityStackTraceEntry,
@@ -71,7 +72,11 @@ export function getMessageFromLastStackTraceEntry(
       if (stackTraceEntry.details !== undefined) {
         switch (stackTraceEntry.details.code) {
           case CheatcodeErrorCode.UnsupportedCheatcode:
-            return `Cheatcode '${stackTraceEntry.details.cheatcode}' is not supported by Hardhat.`;
+            const suggestion = getCheatcodeSuggestion(
+              stackTraceEntry.details.cheatcode,
+            );
+
+            return `Cheatcode '${stackTraceEntry.details.cheatcode}' is not supported by Hardhat.${suggestion.length > 0 ? " " + suggestion : ""}`;
           case CheatcodeErrorCode.MissingCheatcode:
             return `Cheatcode '${stackTraceEntry.details.cheatcode}' is not yet available in this version of Hardhat.`;
         }

package/src/internal/builtin-plugins/solidity-test/task-action.ts

@@ -231,12 +231,12 @@ const runSolidityTests: NewTaskActionFunction<TestActionArguments> = async (
     }
   }
 
-  const testFunctionOverrides = getTestFunctionOverrides(
+  const testFunctionOverrides = await getTestFunctionOverrides(
     testSuiteArtifacts,
     allBuildInfosAndOutputs,
   );
 
-  const eip712CanonicalTypes = collectEip712CanonicalTypes(
+  const eip712CanonicalTypes = await collectEip712CanonicalTypes(
     allBuildInfosAndOutputs,
     sourceNameToUserSourceName,
     eip712Types,

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

@@ -33,6 +33,7 @@ declare module "../../../types/test.js" {
     includeStorage?: boolean;
     includePushBytes?: boolean;
     shrinkRunLimit?: number;
+    timeout?: number | bigint;
   }
 
   export interface SolidityTestFuzzUserConfig {
@@ -45,6 +46,7 @@ declare module "../../../types/test.js" {
     includeStorage?: boolean;
     includePushBytes?: boolean;
     showLogs?: boolean;
+    timeout?: number | bigint;
   }
 
   export interface SolidityTestForkingUserConfig {
@@ -66,6 +68,7 @@ declare module "../../../types/test.js" {
     blockTimestamp?: bigint;
     prevRandao?: bigint;
     gasLimit?: bigint;
+    memoryLimit?: number | bigint;
     blockGasLimit?: number | bigint | false;
     transactionGasCap?: number | bigint | false;
     fuzz?: SolidityTestFuzzUserConfig;
@@ -108,6 +111,7 @@ declare module "../../../types/test.js" {
     includeStorage?: boolean;
     includePushBytes?: boolean;
     shrinkRunLimit?: number;
+    timeout?: number;
   }
 
   export interface SolidityTestFuzzConfig {
@@ -120,6 +124,7 @@ declare module "../../../types/test.js" {
     includeStorage?: boolean;
     includePushBytes?: boolean;
     showLogs?: boolean;
+    timeout?: number;
   }
 
   export interface SolidityTestForkingConfig {
@@ -142,6 +147,7 @@ declare module "../../../types/test.js" {
     blockTimestamp?: bigint;
     prevRandao?: bigint;
     gasLimit?: bigint;
+    memoryLimit?: bigint;
     blockGasLimit?: number | bigint | false;
     transactionGasCap?: number | bigint | false;
     fuzz: SolidityTestFuzzConfig;

package/src/internal/cli/help/get-global-help-string.ts

@@ -14,6 +14,7 @@ import {
 export async function getGlobalHelpString(
   rootTasks: Map<string, Task>,
   globalOptionDefinitions: GlobalOptionDefinitions,
+  { command = "hardhat" }: { command?: "hardhat" | "hhu" } = {},
 ): Promise<string> {
   const version = await getHardhatVersion();
 
@@ -27,7 +28,7 @@ export async function getGlobalHelpString(
 
   let output = `Hardhat version ${version}
 
-Usage: hardhat [GLOBAL OPTIONS] <TASK> [SUBTASK] [TASK OPTIONS] [--] [TASK ARGUMENTS]
+Usage: ${command} [GLOBAL OPTIONS] <TASK> [SUBTASK] [TASK OPTIONS] [--] [TASK ARGUMENTS]
 `;
 
   if (tasks.length > 0) {
@@ -40,7 +41,7 @@ Usage: hardhat [GLOBAL OPTIONS] <TASK> [SUBTASK] [TASK OPTIONS] [--] [TASK ARGUM
 
   output += getSection("GLOBAL OPTIONS", globalOptions, namePadding);
 
-  output += `\nTo get help for a specific task run: npx hardhat <TASK> [SUBTASK] --help`;
+  output += `\nTo get help for a specific task run: npx ${command} <TASK> [SUBTASK] --help`;
 
   return output;
 }

package/src/internal/cli/help/get-help-string.ts

@@ -16,6 +16,7 @@ import {
 export async function getHelpString(
   task: Task,
   globalOptionDefinitions: GlobalOptionDefinitions,
+  { command = "hardhat" }: { command?: "hardhat" | "hhu" } = {},
 ): Promise<string> {
   const { options, positionalArguments } = parseOptions(task);
 
@@ -34,20 +35,20 @@ export async function getHelpString(
   let output = `${styleText("bold", task.description)}`;
 
   if (task.isEmpty) {
-    output += `\n\nUsage: hardhat [GLOBAL OPTIONS] ${task.id.join(" ")} <SUBTASK> [SUBTASK OPTIONS] [--] [SUBTASK POSITIONAL ARGUMENTS]\n`;
+    output += `\n\nUsage: ${command} [GLOBAL OPTIONS] ${task.id.join(" ")} <SUBTASK> [SUBTASK OPTIONS] [--] [SUBTASK POSITIONAL ARGUMENTS]\n`;
 
     if (subtasks.length > 0) {
       output += getSection("AVAILABLE SUBTASKS", subtasks, namePadding);
 
       output += getSection("GLOBAL OPTIONS", globalOptions, namePadding);
 
-      output += `\nTo get help for a specific task run: npx hardhat ${task.id.join(" ")} <SUBTASK> --help`;
+      output += `\nTo get help for a specific task run: npx ${command} ${task.id.join(" ")} <SUBTASK> --help`;
     }
 
     return output;
   }
 
-  const usage = getUsageString(task, options, positionalArguments);
+  const usage = getUsageString(task, options, positionalArguments, { command });
 
   output += `\n\n${usage}\n`;
 

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

@@ -172,8 +172,9 @@ export function getUsageString(
   task: Task,
   options: ReturnType<typeof parseOptions>["options"],
   positionalArguments: ReturnType<typeof parseOptions>["positionalArguments"],
+  { command = "hardhat" }: { command?: "hardhat" | "hhu" } = {},
 ): string {
-  let output = `Usage: hardhat [GLOBAL OPTIONS] ${task.id.join(" ")}`;
+  let output = `Usage: ${command} [GLOBAL OPTIONS] ${task.id.join(" ")}`;
 
   if (options.length > 0) {
     output += ` ${options