hardhat 3.1.9 → 3.1.11

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

@@ -15,6 +15,8 @@ import type {
   ExtendTaskArguments,
   TaskArguments,
   LazyActionObject,
+  TaskAction,
+  TaskOverrideAction,
 } from "../../../types/tasks.js";
 
 import { HardhatError } from "@nomicfoundation/hardhat-errors";
@@ -54,7 +56,11 @@ export class EmptyTaskDefinitionBuilderImplementation
 
 export class NewTaskDefinitionBuilderImplementation<
   TaskArgumentsT extends TaskArguments = TaskArguments,
-> implements NewTaskDefinitionBuilder<TaskArgumentsT>
+  ActionTypeT extends
+    | "LAZY_ACTION"
+    | "INLINE_ACTION"
+    | "MISSING_ACTION" = "MISSING_ACTION",
+> implements NewTaskDefinitionBuilder<TaskArgumentsT, ActionTypeT>
 {
   readonly #id: string[];
   readonly #usedNames: Set<string> = new Set();
@@ -65,6 +71,7 @@ export class NewTaskDefinitionBuilderImplementation<
   #description: string;
 
   #action?: LazyActionObject<NewTaskActionFunction<TaskArgumentsT>>;
+  #inlineAction?: NewTaskActionFunction<TaskArgumentsT>;
 
   constructor(id: string | string[], description: string = "") {
     validateId(id);
@@ -80,10 +87,26 @@ export class NewTaskDefinitionBuilderImplementation<
 
   public setAction(
     action: LazyActionObject<NewTaskActionFunction<TaskArgumentsT>>,
-  ): this {
+  ): NewTaskDefinitionBuilder<TaskArgumentsT, "LAZY_ACTION"> {
+    this.#ensureNoActionSet();
+
     this.#action = action;
 
-    return this;
+    /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    -- Cast to update the ActionTypeT to the expected type for this scenario. */
+    return this as NewTaskDefinitionBuilder<TaskArgumentsT, "LAZY_ACTION">;
+  }
+
+  public setInlineAction(
+    inlineAction: NewTaskActionFunction<TaskArgumentsT>,
+  ): NewTaskDefinitionBuilder<TaskArgumentsT, "INLINE_ACTION"> {
+    this.#ensureNoActionSet();
+
+    this.#inlineAction = inlineAction;
+
+    /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    -- Cast to update the ActionTypeT to the expected type for this scenario. */
+    return this as NewTaskDefinitionBuilder<TaskArgumentsT, "INLINE_ACTION">;
   }
 
   public addOption<
@@ -104,7 +127,8 @@ export class NewTaskDefinitionBuilderImplementation<
     defaultValue: ArgumentTypeToValueType<TypeT>;
     hidden?: boolean;
   }): NewTaskDefinitionBuilder<
-    ExtendTaskArguments<NameT, TypeT, TaskArgumentsT>
+    ExtendTaskArguments<NameT, TypeT, TaskArgumentsT>,
+    ActionTypeT
   > {
     const argumentType = type ?? ArgumentType.STRING;
 
@@ -121,7 +145,13 @@ export class NewTaskDefinitionBuilderImplementation<
 
     this.#options[name] = optionDefinition;
 
-    return this;
+    /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    -- Cast to update the generic argument types. Propagate 'ActionTypeT' to preserve
+    the current action state for subsequent method calls. */
+    return this as NewTaskDefinitionBuilder<
+      ExtendTaskArguments<NameT, TypeT, TaskArgumentsT>,
+      ActionTypeT
+    >;
   }
 
   public addFlag<NameT extends string>(flagConfig: {
@@ -130,7 +160,8 @@ export class NewTaskDefinitionBuilderImplementation<
     description?: string;
     hidden?: boolean;
   }): NewTaskDefinitionBuilder<
-    ExtendTaskArguments<NameT, ArgumentType.FLAG, TaskArgumentsT>
+    ExtendTaskArguments<NameT, ArgumentType.FLAG, TaskArgumentsT>,
+    ActionTypeT
   > {
     return this.addOption({
       ...flagConfig,
@@ -146,7 +177,8 @@ export class NewTaskDefinitionBuilderImplementation<
     description?: string;
     defaultValue?: number;
   }): NewTaskDefinitionBuilder<
-    ExtendTaskArguments<NameT, ArgumentType.LEVEL, TaskArgumentsT>
+    ExtendTaskArguments<NameT, ArgumentType.LEVEL, TaskArgumentsT>,
+    ActionTypeT
   > {
     return this.addOption({
       ...levelConfig,
@@ -164,7 +196,8 @@ export class NewTaskDefinitionBuilderImplementation<
     type?: TypeT;
     defaultValue?: ArgumentTypeToValueType<TypeT>;
   }): NewTaskDefinitionBuilder<
-    ExtendTaskArguments<NameT, TypeT, TaskArgumentsT>
+    ExtendTaskArguments<NameT, TypeT, TaskArgumentsT>,
+    ActionTypeT
   > {
     return this.#addPositionalArgument({
       ...argConfig,
@@ -181,7 +214,8 @@ export class NewTaskDefinitionBuilderImplementation<
     type?: TypeT;
     defaultValue?: Array<ArgumentTypeToValueType<TypeT>>;
   }): NewTaskDefinitionBuilder<
-    ExtendTaskArguments<NameT, TypeT, TaskArgumentsT>
+    ExtendTaskArguments<NameT, TypeT[], TaskArgumentsT>,
+    ActionTypeT
   > {
     return this.#addPositionalArgument({
       ...argConfig,
@@ -189,8 +223,15 @@ export class NewTaskDefinitionBuilderImplementation<
     });
   }
 
-  public build(): NewTaskDefinition {
-    if (this.#action === undefined) {
+  public build(): ActionTypeT extends "LAZY_ACTION"
+    ? Extract<
+        NewTaskDefinition,
+        { action: LazyActionObject<NewTaskActionFunction> }
+      >
+    : ActionTypeT extends "INLINE_ACTION"
+      ? Extract<NewTaskDefinition, { inlineAction: NewTaskActionFunction }>
+      : never {
+    if (this.#action === undefined && this.#inlineAction === undefined) {
       throw new HardhatError(
         HardhatError.ERRORS.CORE.TASK_DEFINITIONS.NO_ACTION,
         {
@@ -199,18 +240,30 @@ export class NewTaskDefinitionBuilderImplementation<
       );
     }
 
+    /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    -- Cast the return value because TypeScript cannot verify that the object matches
+    the conditional type. */
     return {
       type: TaskDefinitionType.NEW_TASK,
       id: this.#id,
       description: this.#description,
       /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      -- The type of the action is narrowed in the setAction function to
+      -- The type of the action is narrowed in the setAction function or setInlineAction to
       improve the argument types. Once the task is built, we use the more
       general type to avoid having to parameterize the NewTaskDefinition */
-      action: this.#action as LazyActionObject<NewTaskActionFunction>,
+      ...((this.#action !== undefined
+        ? { action: this.#action }
+        : { inlineAction: this.#inlineAction }) as TaskAction),
       options: this.#options,
       positionalArguments: this.#positionalArgs,
-    };
+    } as ActionTypeT extends "LAZY_ACTION"
+      ? Extract<
+          NewTaskDefinition,
+          { action: LazyActionObject<NewTaskActionFunction> }
+        >
+      : ActionTypeT extends "INLINE_ACTION"
+        ? Extract<NewTaskDefinition, { inlineAction: NewTaskActionFunction }>
+        : never;
   }
 
   #addPositionalArgument<
@@ -231,7 +284,8 @@ export class NewTaskDefinitionBuilderImplementation<
       | Array<ArgumentTypeToValueType<TypeT>>;
     isVariadic: boolean;
   }): NewTaskDefinitionBuilder<
-    ExtendTaskArguments<NameT, TypeT, TaskArgumentsT>
+    ExtendTaskArguments<NameT, TypeT, TaskArgumentsT>,
+    ActionTypeT
   > {
     const argumentType = type ?? ArgumentType.STRING;
 
@@ -253,13 +307,34 @@ export class NewTaskDefinitionBuilderImplementation<
 
     this.#positionalArgs.push(positionalArgDef);
 
-    return this;
+    /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    -- Cast to update the generic argument types. Propagate 'ActionTypeT' to preserve
+    the current action state for subsequent method calls. */
+    return this as NewTaskDefinitionBuilder<
+      ExtendTaskArguments<NameT, TypeT, TaskArgumentsT>,
+      ActionTypeT
+    >;
+  }
+
+  #ensureNoActionSet(): void {
+    if (this.#action !== undefined || this.#inlineAction !== undefined) {
+      throw new HardhatError(
+        HardhatError.ERRORS.CORE.TASK_DEFINITIONS.ACTION_ALREADY_SET,
+        {
+          task: formatTaskId(this.#id),
+        },
+      );
+    }
   }
 }
 
 export class TaskOverrideDefinitionBuilderImplementation<
   TaskArgumentsT extends TaskArguments = TaskArguments,
-> implements TaskOverrideDefinitionBuilder<TaskArgumentsT>
+  ActionTypeT extends
+    | "LAZY_ACTION"
+    | "INLINE_ACTION"
+    | "MISSING_ACTION" = "MISSING_ACTION",
+> implements TaskOverrideDefinitionBuilder<TaskArgumentsT, ActionTypeT>
 {
   readonly #id: string[];
 
@@ -268,6 +343,7 @@ export class TaskOverrideDefinitionBuilderImplementation<
   #description?: string;
 
   #action?: LazyActionObject<TaskOverrideActionFunction<TaskArgumentsT>>;
+  #inlineAction?: TaskOverrideActionFunction<TaskArgumentsT>;
 
   constructor(id: string | string[]) {
     validateId(id);
@@ -282,10 +358,29 @@ export class TaskOverrideDefinitionBuilderImplementation<
 
   public setAction(
     action: LazyActionObject<TaskOverrideActionFunction<TaskArgumentsT>>,
-  ): this {
+  ): TaskOverrideDefinitionBuilder<TaskArgumentsT, "LAZY_ACTION"> {
+    this.#ensureNoActionSet();
+
     this.#action = action;
 
-    return this;
+    /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    -- Cast to update the ActionTypeT to the expected type for this scenario. */
+    return this as TaskOverrideDefinitionBuilder<TaskArgumentsT, "LAZY_ACTION">;
+  }
+
+  public setInlineAction(
+    inlineAction: TaskOverrideActionFunction<TaskArgumentsT>,
+  ): TaskOverrideDefinitionBuilder<TaskArgumentsT, "INLINE_ACTION"> {
+    this.#ensureNoActionSet();
+
+    this.#inlineAction = inlineAction;
+
+    /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    -- Cast to update the ActionTypeT to the expected type for this scenario. */
+    return this as TaskOverrideDefinitionBuilder<
+      TaskArgumentsT,
+      "INLINE_ACTION"
+    >;
   }
 
   public addOption<
@@ -306,7 +401,8 @@ export class TaskOverrideDefinitionBuilderImplementation<
     defaultValue: ArgumentTypeToValueType<TypeT>;
     hidden?: boolean;
   }): TaskOverrideDefinitionBuilder<
-    ExtendTaskArguments<NameT, TypeT, TaskArgumentsT>
+    ExtendTaskArguments<NameT, TypeT, TaskArgumentsT>,
+    ActionTypeT
   > {
     const argumentType = type ?? ArgumentType.STRING;
 
@@ -331,16 +427,23 @@ export class TaskOverrideDefinitionBuilderImplementation<
 
     this.#options[name] = optionDefinition;
 
-    return this;
+    /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    -- Cast to update the generic argument types. Propagate 'ActionTypeT' to preserve
+    the current action state for subsequent method calls. */
+    return this as TaskOverrideDefinitionBuilder<
+      ExtendTaskArguments<NameT, TypeT, TaskArgumentsT>,
+      ActionTypeT
+    >;
   }
 
   public addFlag<NameT extends string>(flagConfig: {
-    name: string;
+    name: NameT;
     shortName?: string;
     description?: string;
     hidden?: boolean;
   }): TaskOverrideDefinitionBuilder<
-    ExtendTaskArguments<NameT, ArgumentType.FLAG, TaskArgumentsT>
+    ExtendTaskArguments<NameT, ArgumentType.FLAG, TaskArgumentsT>,
+    ActionTypeT
   > {
     return this.addOption({
       ...flagConfig,
@@ -351,12 +454,13 @@ export class TaskOverrideDefinitionBuilderImplementation<
   }
 
   public addLevel<NameT extends string>(levelConfig: {
-    name: string;
+    name: NameT;
     shortName?: string;
     description?: string;
     defaultValue?: number;
   }): TaskOverrideDefinitionBuilder<
-    ExtendTaskArguments<NameT, ArgumentType.LEVEL, TaskArgumentsT>
+    ExtendTaskArguments<NameT, ArgumentType.LEVEL, TaskArgumentsT>,
+    ActionTypeT
   > {
     return this.addOption({
       ...levelConfig,
@@ -365,8 +469,18 @@ export class TaskOverrideDefinitionBuilderImplementation<
     });
   }
 
-  public build(): TaskOverrideDefinition {
-    if (this.#action === undefined) {
+  public build(): ActionTypeT extends "LAZY_ACTION"
+    ? Extract<
+        TaskOverrideDefinition,
+        { action: LazyActionObject<TaskOverrideActionFunction> }
+      >
+    : ActionTypeT extends "INLINE_ACTION"
+      ? Extract<
+          TaskOverrideDefinition,
+          { inlineAction: TaskOverrideActionFunction }
+        >
+      : never {
+    if (this.#action === undefined && this.#inlineAction === undefined) {
       throw new HardhatError(
         HardhatError.ERRORS.CORE.TASK_DEFINITIONS.NO_ACTION,
         {
@@ -375,16 +489,46 @@ export class TaskOverrideDefinitionBuilderImplementation<
       );
     }
 
+    /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    -- Cast the return value because TypeScript cannot verify that the object matches
+    the conditional type. */
     return {
       type: TaskDefinitionType.TASK_OVERRIDE,
       id: this.#id,
       description: this.#description,
       /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      -- The type of the action is narrowed in the setAction function to
+      -- The type of the action is narrowed in the setAction function or setInlineAction to
       improve the argument types. Once the task is built, we use the more
       general type to avoid having to parameterize the TaskOverrideDefinition */
-      action: this.#action as LazyActionObject<TaskOverrideActionFunction>,
+      ...((this.#action !== undefined
+        ? {
+            action: this.#action,
+          }
+        : {
+            inlineAction: this.#inlineAction,
+          }) as TaskOverrideAction),
       options: this.#options,
-    };
+    } as ActionTypeT extends "LAZY_ACTION"
+      ? Extract<
+          TaskOverrideDefinition,
+          { action: LazyActionObject<TaskOverrideActionFunction> }
+        >
+      : ActionTypeT extends "INLINE_ACTION"
+        ? Extract<
+            TaskOverrideDefinition,
+            { inlineAction: TaskOverrideActionFunction }
+          >
+        : never;
+  }
+
+  #ensureNoActionSet(): void {
+    if (this.#action !== undefined || this.#inlineAction !== undefined) {
+      throw new HardhatError(
+        HardhatError.ERRORS.CORE.TASK_DEFINITIONS.ACTION_ALREADY_SET,
+        {
+          task: formatTaskId(this.#id),
+        },
+      );
+    }
   }
 }

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

@@ -8,6 +8,7 @@ import type {
   LazyActionObject,
   NewTaskActionFunction,
   Task,
+  TaskAction,
   TaskActions,
   TaskArguments,
   TaskOverrideActionFunction,
@@ -36,7 +37,7 @@ export class ResolvedTask implements Task {
     return new ResolvedTask(
       id,
       description,
-      [{ pluginId, action: undefined }],
+      [{ pluginId, action: undefined, inlineAction: undefined }],
       new Map(),
       [],
       pluginId,
@@ -49,7 +50,7 @@ export class ResolvedTask implements Task {
     hre: HardhatRuntimeEnvironment,
     id: string[],
     description: string,
-    action: LazyActionObject<NewTaskActionFunction>,
+    taskAction: TaskAction,
     options: Record<string, OptionDefinition>,
     positionalArguments: PositionalArgumentDefinition[],
     pluginId?: string,
@@ -57,7 +58,12 @@ export class ResolvedTask implements Task {
     return new ResolvedTask(
       id,
       description,
-      [{ pluginId, action }],
+      [
+        {
+          pluginId,
+          ...taskAction,
+        },
+      ],
       new Map(Object.entries(options)),
       positionalArguments,
       pluginId,
@@ -80,7 +86,11 @@ export class ResolvedTask implements Task {
   }
 
   public get isEmpty(): boolean {
-    return this.actions.length === 1 && this.actions[0].action === undefined;
+    return (
+      this.actions.length === 1 &&
+      this.actions[0].action === undefined &&
+      this.actions[0].inlineAction === undefined
+    );
   }
 
   /**
@@ -142,17 +152,25 @@ export class ResolvedTask implements Task {
       nextTaskArguments: TaskArguments,
       currentIndex = this.actions.length - 1,
     ): Promise<any> => {
+      const currentTaskAction = this.actions[currentIndex];
+
+      let actionFn: NewTaskActionFunction | TaskOverrideActionFunction;
+
       // The first action may be empty if the task was originally an empty task
-      const currentAction =
-        this.actions[currentIndex].action ??
-        (async () => ({
-          default: () => {},
-        }));
+      if (currentTaskAction.inlineAction !== undefined) {
+        actionFn = currentTaskAction.inlineAction;
+      } else {
+        const action =
+          currentTaskAction.action ??
+          (async () => ({
+            default: () => {},
+          }));
 
-      const actionFn = await this.#resolveImportAction(
-        currentAction,
-        this.actions[currentIndex].pluginId,
-      );
+        actionFn = await this.#resolveImportAction(
+          action,
+          currentTaskAction.pluginId,
+        );
+      }
 
       if (currentIndex === 0) {
         /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions --

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

@@ -19,6 +19,7 @@ import { TaskDefinitionType } from "../../../types/tasks.js";
 import { ResolvedTask } from "./resolved-task.js";
 import { formatTaskId, getActorFragment } from "./utils.js";
 import {
+  validateAction,
   validateId,
   validateOption,
   validatePositionalArgument,
@@ -41,7 +42,7 @@ export class TaskManagerImplementation implements TaskManager {
       }
 
       for (const taskDefinition of plugin.tasks) {
-        this.#validateTaskDefinition(taskDefinition);
+        this.#validateTaskDefinition(taskDefinition, true);
         this.#reduceTaskDefinition(
           globalOptionDefinitions,
           taskDefinition,
@@ -52,7 +53,7 @@ export class TaskManagerImplementation implements TaskManager {
 
     // reduce global user defined tasks
     for (const taskDefinition of this.#hre.config.tasks) {
-      this.#validateTaskDefinition(taskDefinition);
+      this.#validateTaskDefinition(taskDefinition, false);
       this.#reduceTaskDefinition(globalOptionDefinitions, taskDefinition);
     }
   }
@@ -171,7 +172,9 @@ export class TaskManagerImplementation implements TaskManager {
           this.#hre,
           taskDefinition.id,
           taskDefinition.description,
-          taskDefinition.action,
+          taskDefinition.action !== undefined
+            ? { action: taskDefinition.action }
+            : { inlineAction: taskDefinition.inlineAction },
           taskDefinition.options,
           taskDefinition.positionalArguments,
           pluginId,
@@ -278,10 +281,18 @@ export class TaskManagerImplementation implements TaskManager {
       task.description = taskDefinition.description;
     }
 
-    task.actions.push({ pluginId, action: taskDefinition.action });
+    task.actions.push({
+      pluginId,
+      ...(taskDefinition.action !== undefined
+        ? { action: taskDefinition.action }
+        : { inlineAction: taskDefinition.inlineAction }),
+    });
   }
 
-  #validateTaskDefinition(taskDefinition: TaskDefinition): void {
+  #validateTaskDefinition(
+    taskDefinition: TaskDefinition,
+    isPlugin: boolean,
+  ): void {
     validateId(taskDefinition.id);
 
     // Empty tasks don't have actions, options, or positional arguments
@@ -289,6 +300,13 @@ export class TaskManagerImplementation implements TaskManager {
       return;
     }
 
+    validateAction(
+      taskDefinition.action,
+      taskDefinition.inlineAction,
+      taskDefinition.id,
+      isPlugin,
+    );
+
     const usedNames = new Set<string>();
 
     Object.values(taskDefinition.options).forEach((optionDefinition) =>

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

@@ -4,6 +4,12 @@ import type {
   OptionDefinition,
   PositionalArgumentDefinition,
 } from "../../../types/arguments.js";
+import type {
+  LazyActionObject,
+  NewTaskActionFunction,
+  TaskArguments,
+  TaskOverrideActionFunction,
+} from "../../../types/tasks.js";
 
 import { HardhatError } from "@nomicfoundation/hardhat-errors";
 
@@ -23,6 +29,40 @@ export function validateId(id: string | string[]): void {
   }
 }
 
+export function validateAction(
+  action:
+    | LazyActionObject<NewTaskActionFunction<TaskArguments>>
+    | LazyActionObject<TaskOverrideActionFunction<TaskArguments>>
+    | undefined,
+  inlineAction:
+    | NewTaskActionFunction<TaskArguments>
+    | TaskOverrideActionFunction<TaskArguments>
+    | undefined,
+  taskId: string[],
+  isPlugin: boolean,
+): void {
+  if (isPlugin && inlineAction !== undefined) {
+    throw new HardhatError(
+      HardhatError.ERRORS.CORE.TASK_DEFINITIONS.INLINE_ACTION_CANNOT_BE_USED_IN_PLUGINS,
+      { task: formatTaskId(taskId) },
+    );
+  }
+
+  if (action !== undefined && inlineAction !== undefined) {
+    throw new HardhatError(
+      HardhatError.ERRORS.CORE.TASK_DEFINITIONS.ACTION_AND_INLINE_ACTION_SET,
+      { task: formatTaskId(taskId) },
+    );
+  }
+
+  if (action === undefined && inlineAction === undefined) {
+    throw new HardhatError(
+      HardhatError.ERRORS.CORE.TASK_DEFINITIONS.NO_ACTION,
+      { task: formatTaskId(taskId) },
+    );
+  }
+}
+
 export function validateOption(
   { name, shortName, type, defaultValue }: OptionDefinition,
   usedNames: Set<string>,

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

@@ -121,7 +121,7 @@ async function defaultRequestSecretInput(
 
       assertHardhatInvariant(
         rlAsAny.output !== undefined,
-        "Espected readline output to be defined",
+        "Expected readline output to be defined",
       );
 
       // We show the initial message as is

package/src/internal/deprecated-module-imported-from-hardhat2-plugin.ts

@@ -0,0 +1,12 @@
+// This is an empty module that is used to exported it with a subpath that's
+// commonly used by Hardhat 2 plugins. This is to avoid the plugins breaking
+// when the `require` it, so that they have an opportunity to run a function
+// that throws a better error message.
+
+// The reason this module can be empty is that Hardhat 2 plugins are CJS modules
+// so they can destructure the require and get `undefined` values, instead of
+// a load-time error.
+
+// We could also throw from this file, but if it gets imported by an ESM module
+// you don't get an import-stack-trace, so you loose the possibility of figuring
+// out which plugin is triggering the error.