hardhat 3.11.1 → 3.13.0

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

@@ -10,6 +10,7 @@ import { styleText } from "node:util";
 import { bytesToHexString } from "@nomicfoundation/hardhat-utils/hex";
 
 import { sendErrorTelemetry } from "../../cli/telemetry/error-reporter/reporter.js";
+import { ALWAYS_COLLECT_STACK_TRACES_VERBOSITY } from "../../constants.js";
 import { SolidityTestStackTraceGenerationError } from "../network-manager/edr/stack-traces/stack-trace-generation-errors.js";
 import { encodeStackTraceEntry } from "../network-manager/edr/stack-traces/stack-trace-solidity-errors.js";
 import { formatTraces } from "../network-manager/edr/utils/trace-formatters.js";
@@ -17,6 +18,8 @@ import { formatTraces } from "../network-manager/edr/utils/trace-formatters.js";
 import { formatArtifactId } from "./formatters.js";
 import { getMessageFromLastStackTraceEntry } from "./stack-trace-solidity-errors.js";
 
+const RERUN_VERBOSITY_HINT = `Try rerunning your tests with -${"v".repeat(ALWAYS_COLLECT_STACK_TRACES_VERBOSITY)} or above.`;
+
 class Indenter {
   #indentation: number;
 
@@ -272,7 +275,7 @@ export async function* testReporter(
         reason =
           failure.reason?.startsWith("FFI is disabled") === true
             ? "FFI is disabled; set `test.solidity.ffi` to `true` in your Hardhat config to allow tests to call external commands"
-            : failure.reason ?? "Unknown error";
+            : (failure.reason ?? "Unknown error");
       }
       yield* output(indenter.t`${colorize("red", `Error: ${reason}`)}\n`);
       // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check -- Ignore Cases not matched: undefined
@@ -305,17 +308,13 @@ export async function* testReporter(
             yield* output(
               indenter.t`Stack Trace Warning: ${colorize("grey", "The test is not safe to replay because a fork url without a fork block number was provided.")}\n`,
             );
-            yield* output(
-              indenter.t`Try rerunning your tests with -vvv or above.\n`,
-            );
+            yield* output(indenter.t`${RERUN_VERBOSITY_HINT}\n`);
           }
           if (stackTrace.impureCheatcodes.length > 0) {
             yield* output(
               indenter.t`Stack Trace Warning: ${colorize("grey", `The test is not safe to replay because it uses impure cheatcodes: ${stackTrace.impureCheatcodes.join(", ")}`)}\n`,
             );
-            yield* output(
-              indenter.t`Try rerunning your tests with -vvv or above.\n`,
-            );
+            yield* output(indenter.t`${RERUN_VERBOSITY_HINT}\n`);
           }
           break;
         case "HeuristicFailed":

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

@@ -102,7 +102,8 @@ export function run(
 
       stream.destroy(
         new HardhatError(
-          HardhatError.ERRORS.CORE.SOLIDITY_TESTS.UNHANDLED_EDR_ERROR_SOLIDITY_TESTS,
+          HardhatError.ERRORS.CORE.SOLIDITY_TESTS
+            .UNHANDLED_EDR_ERROR_SOLIDITY_TESTS,
           {
             error: error.message,
           },

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

@@ -50,6 +50,7 @@ interface TestActionArguments {
   testFiles: string[];
   chainType: string;
   grep?: string;
+  grepExclude?: string;
   noCompile: boolean;
   testSummaryIndex: number;
 }
@@ -59,7 +60,7 @@ export interface SolidityTestRunResult extends TestRunResult {
 }
 
 const runSolidityTests: NewTaskActionFunction<TestActionArguments> = async (
-  { testFiles, chainType, grep, noCompile, testSummaryIndex },
+  { testFiles, chainType, grep, grepExclude, noCompile, testSummaryIndex },
   hre,
 ): Promise<Result<SolidityTestRunResult, SolidityTestRunResult>> => {
   // Set an environment variable that plugins can use to detect when a process is running tests
@@ -163,7 +164,8 @@ const runSolidityTests: NewTaskActionFunction<TestActionArguments> = async (
 
       if (notCompiledFiles.length > 0) {
         throw new HardhatError(
-          HardhatError.ERRORS.CORE.SOLIDITY_TESTS.SELECTED_TEST_FILES_NOT_COMPILED,
+          HardhatError.ERRORS.CORE.SOLIDITY_TESTS
+            .SELECTED_TEST_FILES_NOT_COMPILED,
           {
             files: notCompiledFiles.map((f) => `- ${f}`).join("\n"),
           },
@@ -251,6 +253,7 @@ const runSolidityTests: NewTaskActionFunction<TestActionArguments> = async (
       verbosity,
       observability: observabilityConfig,
       testPattern: grep,
+      excludeTestPattern: grepExclude,
       generateGasReport:
         hre.globalOptions.gasStats ||
         hre.globalOptions.gasStatsJson !== undefined,
@@ -416,7 +419,8 @@ async function validateThatProvidedFilesAreTests(
 
   if (nonTests.length > 0) {
     throw new HardhatError(
-      HardhatError.ERRORS.CORE.SOLIDITY_TESTS.SELECTED_FILES_ARE_NOT_SOLIDITY_TESTS,
+      HardhatError.ERRORS.CORE.SOLIDITY_TESTS
+        .SELECTED_FILES_ARE_NOT_SOLIDITY_TESTS,
       {
         files: nonTests.map((f) => `- ${f}`).join("\n"),
       },

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

@@ -85,8 +85,7 @@ declare module "../../../types/test.js" {
   }
 
   export type SolidityTestUserConfig =
-    | SolidityTestProfileUserConfig
-    | SolidityTestProfilesUserConfig;
+    SolidityTestProfileUserConfig | SolidityTestProfilesUserConfig;
 
   export interface HardhatTestUserConfig {
     solidity?: SolidityTestUserConfig;

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

@@ -29,6 +29,12 @@ const hardhatPlugin: HardhatPlugin = definePlugin({
         type: ArgumentType.STRING_WITHOUT_DEFAULT,
         defaultValue: undefined,
       })
+      .addOption({
+        name: "grepExclude",
+        description: "Skip tests matching the given string or regexp",
+        type: ArgumentType.STRING_WITHOUT_DEFAULT,
+        defaultValue: undefined,
+      })
       .addFlag({
         name: "noCompile",
         description: "Do not compile the project before running the tests",

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

@@ -24,6 +24,7 @@ interface TestActionArguments {
   testFiles: string[];
   chainType: string;
   grep: string | undefined;
+  grepExclude: string | undefined;
   noCompile: boolean;
 }
 
@@ -51,7 +52,7 @@ function isTestRunResult(
 }
 
 const runAllTests: NewTaskActionFunction<TestActionArguments> = async (
-  { testFiles, chainType, grep, noCompile, ...otherArgs },
+  { testFiles, chainType, grep, grepExclude, noCompile, ...otherArgs },
   hre,
 ): Promise<Result<void, void>> => {
   // If this code is executed, it means the user has not specified a test runner.
@@ -98,10 +99,17 @@ const runAllTests: NewTaskActionFunction<TestActionArguments> = async (
 
     const args: TaskArguments = {
       testFiles: files,
-      grep,
       noCompile: subtask.options.has("noCompile"),
     };
 
+    if (subtask.options.has("grep")) {
+      args.grep = grep;
+    }
+
+    if (subtask.options.has("grepExclude")) {
+      args.grepExclude = grepExclude;
+    }
+
     if (subtask.options.has("chainType")) {
       args.chainType = chainType;
     }

package/src/internal/cli/{error-handler.ts → error-handling/error-handler.ts}

@@ -1,4 +1,4 @@
-import type * as ClassifierT from "./telemetry/error-classification/classifier.js";
+import type * as ClassifierT from "../telemetry/error-classification/classifier.js";
 
 import { styleText } from "node:util";
 
@@ -7,7 +7,9 @@ import {
   HardhatPluginError,
 } from "@nomicfoundation/hardhat-errors";
 
-import { HARDHAT_NAME, HARDHAT_WEBSITE_URL } from "../constants.js";
+import { HARDHAT_NAME, HARDHAT_WEBSITE_URL } from "../../constants.js";
+
+import { detectNativeBindingFailure } from "./native-binding-error.js";
 
 // The classifier may import many unrelated things top-level to do its job, so
 // we load it lazily.
@@ -165,10 +167,24 @@ async function getErrorWithCategory(error: Error): Promise<ErrorWithCategory> {
     };
   }
 
+  const nativeBindingFailure = detectNativeBindingFailure(error);
+  if (nativeBindingFailure !== undefined) {
+    return {
+      category: ErrorCategory.HARDHAT,
+      categorizedError: new HardhatError(
+        HardhatError.ERRORS.CORE.GENERAL.NATIVE_BINDING_LOAD_FAILED,
+        {
+          parentPackage: nativeBindingFailure.parentPackage,
+          missingPackage: nativeBindingFailure.missingPackage,
+        },
+        error,
+      ),
+    };
+  }
+
   if (classifierModule === undefined) {
-    classifierModule = await import(
-      "./telemetry/error-classification/classifier.js"
-    );
+    classifierModule =
+      await import("../telemetry/error-classification/classifier.js");
   }
 
   // Pass `ignoreDevelopmentTimeFilter=true` so the migration footer also shows

package/src/internal/cli/error-handling/native-binding-error.ts

@@ -0,0 +1,78 @@
+/**
+ * The platform triple that napi-rs appends to the platform package name, e.g.
+ * `@nomicfoundation/edr-linux-x64-gnu`, `@scope/pkg-darwin-arm64`.
+ */
+const PLATFORM_SUFFIX_REGEX =
+  /-(?:android|darwin|freebsd|linux|win32)-(?:arm|arm64|ia32|x64|riscv64|ppc64|s390x)(?:-(?:gnu|musl|msvc|eabi|gnueabihf))?$/;
+
+/**
+ * Matches both the CJS (`Cannot find module 'x'`) and ESM
+ * (`Cannot find package 'x' imported from y`) forms.
+ */
+const MISSING_MODULE_REGEX = /Cannot find (?:module|package) '([^']+)'/g;
+
+/**
+ * The packages Hardhat itself ships a native binding for.
+ */
+const HARDHAT_NATIVE_BINDING_PACKAGES = [
+  "@nomicfoundation/edr",
+  "@nomicfoundation/solidity-analyzer",
+];
+
+export interface NativeBindingFailure {
+  /** The package whose loader failed, e.g. `@nomicfoundation/edr`. */
+  parentPackage: string;
+  /** The platform package that couldn't be found. */
+  missingPackage: string;
+}
+
+/**
+ * Detect whether a given error is a napi-rs native binding load failure.
+ *
+ * Packages like `@nomicfoundation/edr` and `@nomicfoundation/solidity-analyzer`
+ * ship one prebuilt binary per platform in a separate package, and their
+ * generated loader `require`s the one matching the current platform. When that
+ * package is missing from the installation the loader throws at import time, so
+ * the failure surfaces as an opaque `MODULE_NOT_FOUND` from deep inside
+ * `node_modules`.
+ */
+export function detectNativeBindingFailure(
+  error: Error,
+): NativeBindingFailure | undefined {
+  const chain = errorChain(error);
+
+  // Some link in the chain names the missing platform package.
+  for (const chainedError of chain) {
+    for (const match of chainedError.message.matchAll(MISSING_MODULE_REGEX)) {
+      const moduleName = match[1];
+
+      if (!PLATFORM_SUFFIX_REGEX.test(moduleName)) {
+        continue;
+      }
+
+      const parentPackage = moduleName.replace(PLATFORM_SUFFIX_REGEX, "");
+
+      if (!HARDHAT_NATIVE_BINDING_PACKAGES.includes(parentPackage)) {
+        continue;
+      }
+
+      return { missingPackage: moduleName, parentPackage };
+    }
+  }
+
+  return undefined;
+}
+
+function errorChain(error: Error): Error[] {
+  const chain: Error[] = [];
+  const seen = new Set<unknown>();
+  let current: unknown = error;
+
+  while (current instanceof Error && !seen.has(current)) {
+    seen.add(current);
+    chain.push(current);
+    current = current.cause;
+  }
+
+  return chain;
+}

package/src/internal/cli/hhu.ts

@@ -19,7 +19,7 @@ import { globalFlag } from "../core/config.js";
 import { TaskManagerImplementation } from "../core/tasks/task-manager.js";
 import { getHardhatVersion } from "../utils/package.js";
 
-import { printErrorMessages } from "./error-handler.js";
+import { printErrorMessages } from "./error-handling/error-handler.js";
 import { getGlobalHelpString } from "./help/get-global-help-string.js";
 import { getHelpString } from "./help/get-help-string.js";
 import {

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

@@ -13,6 +13,21 @@ import {
   type PackageJson,
 } from "@nomicfoundation/hardhat-utils/package";
 
+// Directories that may exist inside a template dir (build/tooling output,
+// dependencies) but are never part of the template itself. They are all
+// gitignored in the templates, but `getAllFilesMatching` does not honor
+// .gitignore, so we must exclude them explicitly.
+const IGNORED_TEMPLATE_DIRS = new Set([
+  "node_modules",
+  "artifacts",
+  "cache",
+  "types",
+  "dist",
+  "bundle",
+  "coverage",
+  "snapshots",
+]);
+
 /**
  * This type describes a hardhat project template. It consists of:
  * - name: The name of the template;
@@ -75,7 +90,7 @@ export async function getTemplates(): Promise<Template[]> {
           }
           return true;
         },
-        (dir) => path.basename(dir) !== "node_modules",
+        (dir) => !IGNORED_TEMPLATE_DIRS.has(path.basename(dir)),
       );
 
       const files = matchingFiles.map((f) => path.relative(pathToTemplate, f));

package/src/internal/cli/main.ts

@@ -28,7 +28,7 @@ import { warnAboutUnusedLoadedPlugins } from "../core/plugins/unused-plugins-war
 import { setGlobalHardhatRuntimeEnvironment } from "../global-hre-instance.js";
 import { createHardhatRuntimeEnvironment } from "../hre-initialization.js";
 
-import { printErrorMessages } from "./error-handler.js";
+import { printErrorMessages } from "./error-handling/error-handler.js";
 import { getGlobalHelpString } from "./help/get-global-help-string.js";
 import { getHelpString } from "./help/get-help-string.js";
 import {
@@ -123,7 +123,8 @@ export async function main(
 
           if (listTemplates) {
             throw new HardhatError(
-              HardhatError.ERRORS.CORE.ARGUMENTS.CANNOT_COMBINE_TEMPLATE_AND_TEMPLATES,
+              HardhatError.ERRORS.CORE.ARGUMENTS
+                .CANNOT_COMBINE_TEMPLATE_AND_TEMPLATES,
             );
           }
 
@@ -306,9 +307,9 @@ export async function main(
 
     const deprecatedConnectWasCalled = Boolean(
       "wasConnectCalled" in hre.network &&
-        hre.network.wasConnectCalled !== undefined &&
-        typeof hre.network.wasConnectCalled === "function" &&
-        hre.network.wasConnectCalled(),
+      hre.network.wasConnectCalled !== undefined &&
+      typeof hre.network.wasConnectCalled === "function" &&
+      hre.network.wasConnectCalled(),
     );
 
     if (deprecatedConnectWasCalled) {

package/src/internal/cli/telemetry/analytics/analytics.ts

@@ -81,6 +81,19 @@ export async function sendProjectTypeAnalytics(
   return await sendAnalytics(initAnalyticsEvent);
 }
 
+export async function sendNetworkAnalytics(
+  chainType: string,
+): Promise<boolean> {
+  const networkAnalyticsEvent: AnalyticsEvent = {
+    name: "network",
+    params: {
+      chainType,
+    },
+  };
+
+  return await sendAnalytics(networkAnalyticsEvent);
+}
+
 // Return a boolean for testing purposes to confirm whether analytics were sent based on the consent value and not in CI environments
 async function sendAnalytics(analyticsEvent: AnalyticsEvent): Promise<boolean> {
   if (!(await isTelemetryAllowed())) {

package/src/internal/cli/telemetry/analytics/types.ts

@@ -48,6 +48,12 @@ export type AnalyticsEvent =
         hardhatVersion: "hardhat-3";
         template: string;
       };
+    }
+  | {
+      name: "network";
+      params: {
+        chainType: string;
+      };
     };
 
 export interface Payload extends BasePayload {

package/src/internal/cli/telemetry/error-reporter/global-error-handlers.ts

@@ -22,8 +22,8 @@ function createUnhandledErrorListener(isPromiseRejection: boolean) {
         ? error
         : new Error(
             isObject(error) &&
-            "message" in error &&
-            typeof error.message === "string"
+              "message" in error &&
+              typeof error.message === "string"
               ? error.message
               : "Unknown error",
             { cause: error },

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

@@ -30,12 +30,10 @@ interface WordMatch {
 }
 
 export type AnonymizeEnvelopeResult =
-  | { success: true; envelope: Envelope }
-  | { success: false; error: string };
+  { success: true; envelope: Envelope } | { success: false; error: string };
 
 export type AnonymizeEventResult =
-  | { success: true; event: Event }
-  | { success: false; error: string };
+  { success: true; event: Event } | { success: false; error: string };
 
 const ANONYMIZED_MNEMONIC = "<mnemonic>";
 const MNEMONIC_PHRASE_LENGTH_THRESHOLD = 7;

package/src/internal/constants.ts

@@ -11,3 +11,14 @@ export const OPTIMISM_CHAIN_TYPE = "op";
 export const DEFAULT_NETWORK_NAME = "default";
 
 export const DEFAULT_VERBOSITY = 2;
+
+/**
+ * The verbosity level (`-vvvvv`) at and above which stack traces are always
+ * collected. Below it, stack traces are produced by re-running the failing
+ * test with tracing enabled — much cheaper, but tests with non-deterministic
+ * side effects (impure cheatcodes, a fork pinned to `latest`) can't be
+ * replayed and report an `UnsafeToReplay` warning instead. Always-on
+ * collection records step traces for every test, which balloons memory on
+ * large suites, so it's reserved for the highest verbosity.
+ */
+export const ALWAYS_COLLECT_STACK_TRACES_VERBOSITY = 5;

package/src/internal/core/config.ts

@@ -23,18 +23,52 @@ import {
 
 /**
  * Creates a configuration variable, which will be fetched at runtime.
+ *
+ * The second argument is an options object with an optional `format` (a
+ * template that must include the `{variable}` marker) and an optional
+ * `default` value. The default is used as a fallback when the variable can't
+ * be resolved from any other source (see {@link ConfigurationVariable.default}).
  */
 export function configVariable(
   name: string,
-  format: string = CONFIGURATION_VARIABLE_MARKER,
+  options?: { format?: string; default?: string },
+): ConfigurationVariable;
+/**
+ * @deprecated Passing the `format` as a string is deprecated. Pass an options
+ * object instead: `configVariable(name, { format })`.
+ */
+export function configVariable(
+  name: string,
+  format: string,
+): ConfigurationVariable;
+export function configVariable(
+  name: string,
+  formatOrOptions: string | { format?: string; default?: string } = {},
 ): ConfigurationVariable {
+  const { format = CONFIGURATION_VARIABLE_MARKER, default: defaultValue } =
+    typeof formatOrOptions === "string"
+      ? { format: formatOrOptions }
+      : formatOrOptions;
+
   if (!format.includes(CONFIGURATION_VARIABLE_MARKER)) {
     throw new HardhatError(
-      HardhatError.ERRORS.CORE.GENERAL.CONFIG_VARIABLE_FORMAT_MUST_INCLUDE_VARIABLE,
+      HardhatError.ERRORS.CORE.GENERAL
+        .CONFIG_VARIABLE_FORMAT_MUST_INCLUDE_VARIABLE,
       { format, marker: CONFIGURATION_VARIABLE_MARKER },
     );
   }
-  return { _type: "ConfigurationVariable", name, format };
+
+  const configurationVariable: ConfigurationVariable = {
+    _type: "ConfigurationVariable",
+    name,
+    format,
+  };
+
+  if (defaultValue !== undefined) {
+    configurationVariable.default = defaultValue;
+  }
+
+  return configurationVariable;
 }
 
 /**

package/src/internal/core/configuration-variables.ts

@@ -24,9 +24,7 @@ export function resolveConfigurationVariable(
   return new LazyResolvedConfigurationVariable(hooks, variable);
 }
 
-abstract class BaseResolvedConfigurationVariable
-  implements ResolvedConfigurationVariable
-{
+abstract class BaseResolvedConfigurationVariable implements ResolvedConfigurationVariable {
   public _type: "ResolvedConfigurationVariable" =
     "ResolvedConfigurationVariable";
 
@@ -115,6 +113,14 @@ export class LazyResolvedConfigurationVariable extends BaseResolvedConfiguration
   }
 
   protected async _getRawValue(): Promise<string> {
+    // Env vars take precedence over every configurationVariables plugin hook
+    // (e.g. keystore). Skip the hook chain entirely when the env var is set so
+    // plugins are not consulted and cannot override the env value.
+    const envValue = process.env[this.#variable.name];
+    if (typeof envValue === "string") {
+      return envValue;
+    }
+
     const mutex = LazyResolvedConfigurationVariable.#mutexes.get(this.#hooks);
     assertHardhatInvariant(mutex !== undefined, "Mutex must be defined");
 
@@ -125,7 +131,9 @@ export class LazyResolvedConfigurationVariable extends BaseResolvedConfiguration
           "fetchValue",
           [this.#variable],
           async (_context, v) => {
-            const value = process.env[v.name];
+            // Fall back to the default only when the env var is unset. An empty
+            // string still takes precedence
+            const value = process.env[v.name] ?? v.default;
 
             if (typeof value !== "string") {
               throw new HardhatError(

package/src/internal/core/hook-manager.ts

@@ -386,8 +386,7 @@ export class HookManagerImplementation implements HookManager {
     hookCategoryName: HookCategoryNameT,
   ): Promise<Array<Partial<HardhatHooks[HookCategoryNameT]>>> {
     const cached = this.#resolvedStaticCategories.get(hookCategoryName) as
-      | Array<Partial<HardhatHooks[HookCategoryNameT]>>
-      | undefined;
+      Array<Partial<HardhatHooks[HookCategoryNameT]>> | undefined;
 
     if (cached !== undefined) {
       return cached;
@@ -405,8 +404,7 @@ export class HookManagerImplementation implements HookManager {
     return await this.#mutex.exclusiveRun(async () => {
       // Re-check under the mutex in case another caller just populated it.
       const recheck = this.#resolvedStaticCategories.get(hookCategoryName) as
-        | Array<Partial<HardhatHooks[HookCategoryNameT]>>
-        | undefined;
+        Array<Partial<HardhatHooks[HookCategoryNameT]>> | undefined;
 
       if (recheck !== undefined) {
         return recheck;

package/src/internal/core/hre.ts

@@ -44,9 +44,7 @@ import { LazyUserInterruptionManager } from "./lazy-user-interruptions.js";
 import { resolvePluginList } from "./plugins/resolve-plugin-list.js";
 import { TaskManagerImplementation } from "./tasks/task-manager.js";
 
-export class HardhatRuntimeEnvironmentImplementation
-  implements HardhatRuntimeEnvironment
-{
+export class HardhatRuntimeEnvironmentImplementation implements HardhatRuntimeEnvironment {
   // NOTE: This is a small architectural violation, as these shouldn't be needed
   // here, because they are added by plugins. But as those plugins are builtin,
   // their type extensions also affect this module.

package/src/internal/core/lazy-user-interruptions.ts

@@ -3,8 +3,7 @@ import type { HookManager } from "../../types/hooks.js";
 import type { UserInterruptionManager } from "../../types/user-interruptions.js";
 
 let UserInterruptionManagerImplementation:
-  | typeof UserInterruptionManagerImplementationT
-  | undefined;
+  typeof UserInterruptionManagerImplementationT | undefined;
 
 export class LazyUserInterruptionManager implements UserInterruptionManager {
   readonly #hooks: HookManager;
@@ -59,9 +58,8 @@ export class LazyUserInterruptionManager implements UserInterruptionManager {
     // impl, so callers end up holding different impl instances and state,
     // which can cause concurrency issues.
     if (UserInterruptionManagerImplementation === undefined) {
-      ({ UserInterruptionManagerImplementation } = await import(
-        "./user-interruptions.js"
-      ));
+      ({ UserInterruptionManagerImplementation } =
+        await import("./user-interruptions.js"));
     }
 
     if (this.#userInterruptionManager === undefined) {

package/src/internal/core/tasks/builders.ts

@@ -31,9 +31,7 @@ import {
   validatePositionalArgument,
 } from "./validations.js";
 
-export class EmptyTaskDefinitionBuilderImplementation
-  implements EmptyTaskDefinitionBuilder
-{
+export class EmptyTaskDefinitionBuilderImplementation implements EmptyTaskDefinitionBuilder {
   readonly #id: string[];
 
   readonly #description: string;
@@ -56,12 +54,9 @@ export class EmptyTaskDefinitionBuilderImplementation
 
 export class NewTaskDefinitionBuilderImplementation<
   TaskArgumentsT extends TaskArguments = TaskArguments,
-  ActionTypeT extends
-    | "LAZY_ACTION"
-    | "INLINE_ACTION"
-    | "MISSING_ACTION" = "MISSING_ACTION",
-> implements NewTaskDefinitionBuilder<TaskArgumentsT, ActionTypeT>
-{
+  ActionTypeT extends "LAZY_ACTION" | "INLINE_ACTION" | "MISSING_ACTION" =
+    "MISSING_ACTION",
+> implements NewTaskDefinitionBuilder<TaskArgumentsT, ActionTypeT> {
   readonly #id: string[];
   readonly #usedNames: Set<string> = new Set();
 
@@ -280,8 +275,7 @@ export class NewTaskDefinitionBuilderImplementation<
     description?: string;
     type?: TypeT;
     defaultValue?:
-      | ArgumentTypeToValueType<TypeT>
-      | Array<ArgumentTypeToValueType<TypeT>>;
+      ArgumentTypeToValueType<TypeT> | Array<ArgumentTypeToValueType<TypeT>>;
     isVariadic: boolean;
   }): NewTaskDefinitionBuilder<
     ExtendTaskArguments<NameT, TypeT, TaskArgumentsT>,
@@ -330,12 +324,9 @@ export class NewTaskDefinitionBuilderImplementation<
 
 export class TaskOverrideDefinitionBuilderImplementation<
   TaskArgumentsT extends TaskArguments = TaskArguments,
-  ActionTypeT extends
-    | "LAZY_ACTION"
-    | "INLINE_ACTION"
-    | "MISSING_ACTION" = "MISSING_ACTION",
-> implements TaskOverrideDefinitionBuilder<TaskArgumentsT, ActionTypeT>
-{
+  ActionTypeT extends "LAZY_ACTION" | "INLINE_ACTION" | "MISSING_ACTION" =
+    "MISSING_ACTION",
+> implements TaskOverrideDefinitionBuilder<TaskArgumentsT, ActionTypeT> {
   readonly #id: string[];
 
   readonly #options: Record<string, OptionDefinition> = {};

package/src/internal/core/tasks/resolved-task.ts

@@ -208,7 +208,8 @@ export class ResolvedTask implements Task {
       value === undefined
     ) {
       throw new HardhatError(
-        HardhatError.ERRORS.CORE.TASK_DEFINITIONS.MISSING_VALUE_FOR_TASK_ARGUMENT,
+        HardhatError.ERRORS.CORE.TASK_DEFINITIONS
+          .MISSING_VALUE_FOR_TASK_ARGUMENT,
         {
           argument: argument.name,
           task: formatTaskId(this.id),

package/src/internal/core/tasks/task-manager.ts

@@ -265,7 +265,8 @@ export class TaskManagerImplementation implements TaskManager {
         task.positionalArguments.some((p) => p.name === optionName);
       if (hasArgument) {
         throw new HardhatError(
-          HardhatError.ERRORS.CORE.TASK_DEFINITIONS.TASK_OVERRIDE_OPTION_ALREADY_DEFINED,
+          HardhatError.ERRORS.CORE.TASK_DEFINITIONS
+            .TASK_OVERRIDE_OPTION_ALREADY_DEFINED,
           {
             actorFragment: getActorFragment(pluginId),
             option: optionName,