hardhat 2.17.4 → 2.18.1

package/src/internal/core/errors-list.ts

@@ -613,8 +613,26 @@ Please double check your task definitions.`,
 What makes these types special is that they can be represented as strings, so you can write them down in the terminal.`,
       shouldBeReported: false,
     },
-    DEPRECATED_TRANSFORM_IMPORT_TASK: {
+    TASK_SCOPE_CLASH: {
       number: 213,
+      message:
+        "A clash was found while creating scope '%scopeName%', since a task with that name already exists.",
+      title: "Attempted to create a scope with a name already used by a task",
+      description: `You can't create a scope if a task with that name already exists.
+Please double check your task definitions.`,
+      shouldBeReported: false,
+    },
+    SCOPE_TASK_CLASH: {
+      number: 214,
+      message:
+        "A clash was found while creating task '%taskName%', since a scope with that name already exists.",
+      title: "Attempted to create a task with a name already used by a scope",
+      description: `You can't create a task if a scope with that name already exists.
+Please double check your task definitions.`,
+      shouldBeReported: false,
+    },
+    DEPRECATED_TRANSFORM_IMPORT_TASK: {
+      number: 215,
       title: "Use of deprecated remapping task",
       message:
         "Task TASK_COMPILE_TRANSFORM_IMPORT_NAME is deprecated. Please update your @nomicfoundation/hardhat-foundry plugin version.",
@@ -654,7 +672,7 @@ Please double check your arguments.`,
     },
     UNRECOGNIZED_TASK: {
       number: 303,
-      message: "Unrecognized task %task%",
+      message: "Unrecognized task '%task%'",
       title: "Unrecognized task",
       description: `Tried to run a nonexistent task.
 
@@ -756,6 +774,24 @@ This is not supported. Please run the help task to see the available options.`,
 This flag can only be used in typescript projects.`,
       shouldBeReported: false,
     },
+    UNRECOGNIZED_SCOPE: {
+      number: 314,
+      message: "Unrecognized scope '%scope%'",
+      title: "Unrecognized scope",
+      description: `Tried to run a task from a nonexistent scope.
+
+Please double check the scope of the task you are trying to run.`,
+      shouldBeReported: false,
+    },
+    UNRECOGNIZED_SCOPED_TASK: {
+      number: 315,
+      message: "Unrecognized task '%task%' under scope '%scope%'",
+      title: "Unrecognized scoped task",
+      description: `Tried to run a nonexistent scoped task.
+
+Please double check the name of the task you are trying to run.`,
+      shouldBeReported: false,
+    },
   },
   RESOLVER: {
     FILE_NOT_FOUND: {

package/src/internal/core/runtime-environment.ts

@@ -10,13 +10,14 @@ import {
   HardhatUserConfig,
   Network,
   ParamDefinition,
+  ProviderExtender,
   RunSuperFunction,
   RunTaskFunction,
   SubtaskArguments,
   TaskArguments,
   TaskDefinition,
   TasksMap,
-  ProviderExtender,
+  ScopesMap,
 } from "../../types";
 import { Artifacts } from "../artifacts";
 import { MessageTrace } from "../hardhat-network/stack-traces/message-trace";
@@ -34,6 +35,7 @@ import {
   createTaskProfile,
   TaskProfile,
 } from "./task-profiling";
+import { parseTaskIdentifier } from "./tasks/util";
 
 const log = debug("hardhat:core:hre");
 
@@ -65,6 +67,7 @@ export class Environment implements HardhatRuntimeEnvironment {
    * @param config The hardhat's config object.
    * @param hardhatArguments The parsed hardhat's arguments.
    * @param tasks A map of tasks.
+   * @param scopes A map of scopes.
    * @param environmentExtenders A list of environment extenders.
    * @param providerExtenders A list of provider extenders.
    */
@@ -72,6 +75,7 @@ export class Environment implements HardhatRuntimeEnvironment {
     public readonly config: HardhatConfig,
     public readonly hardhatArguments: HardhatArguments,
     public readonly tasks: TasksMap,
+    public readonly scopes: ScopesMap,
     environmentExtenders: EnvironmentExtender[] = [],
     experimentalHardhatNetworkMessageTraceHooks: ExperimentalHardhatNetworkMessageTraceHook[] = [],
     public readonly userConfig: HardhatUserConfig = {},
@@ -122,7 +126,7 @@ export class Environment implements HardhatRuntimeEnvironment {
   /**
    * Executes the task with the given name.
    *
-   * @param name The task's name.
+   * @param taskIdentifier The task or scoped task to be executed.
    * @param taskArguments A map of task's arguments.
    * @param subtaskArguments A map of subtasks to their arguments.
    *
@@ -130,18 +134,39 @@ export class Environment implements HardhatRuntimeEnvironment {
    * @returns a promise with the task's execution result.
    */
   public readonly run: RunTaskFunction = async (
-    name,
+    taskIdentifier,
     taskArguments = {},
     subtaskArguments = {},
     callerTaskProfile?: TaskProfile
   ) => {
-    const taskDefinition = this.tasks[name];
+    const { scope, task } = parseTaskIdentifier(taskIdentifier);
+
+    let taskDefinition;
+    if (scope === undefined) {
+      taskDefinition = this.tasks[task];
+      log("Running task %s", task);
+    } else {
+      const scopeDefinition = this.scopes[scope];
+      if (scopeDefinition === undefined) {
+        throw new HardhatError(ERRORS.ARGUMENTS.UNRECOGNIZED_SCOPE, {
+          scope,
+        });
+      }
 
-    log("Running task %s", name);
+      taskDefinition = scopeDefinition.tasks?.[task];
+      log("Running scoped task %s %s", scope, task);
+    }
 
     if (taskDefinition === undefined) {
+      if (scope !== undefined) {
+        throw new HardhatError(ERRORS.ARGUMENTS.UNRECOGNIZED_SCOPED_TASK, {
+          scope,
+          task,
+        });
+      }
+
       throw new HardhatError(ERRORS.ARGUMENTS.UNRECOGNIZED_TASK, {
-        task: name,
+        task,
       });
     }
 
@@ -153,7 +178,7 @@ export class Environment implements HardhatRuntimeEnvironment {
 
     let taskProfile: TaskProfile | undefined;
     if (this.hardhatArguments.flamegraph === true) {
-      taskProfile = createTaskProfile(name);
+      taskProfile = createTaskProfile(task);
 
       if (callerTaskProfile !== undefined) {
         callerTaskProfile.children.push(taskProfile);

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

@@ -1,14 +1,21 @@
 import {
   ActionType,
+  ScopeDefinition,
+  ScopesMap,
   TaskArguments,
   TaskDefinition,
+  TaskIdentifier,
   TasksMap,
 } from "../../../types";
+import { HardhatError, assertHardhatInvariant } from "../errors";
+import { ERRORS } from "../errors-list";
 
 import {
   OverriddenTaskDefinition,
+  SimpleScopeDefinition,
   SimpleTaskDefinition,
 } from "./task-definitions";
+import { parseTaskIdentifier } from "./util";
 
 /**
  * This class defines the DSL used in Hardhat config files
@@ -18,6 +25,7 @@ export class TasksDSL {
   public readonly internalTask = this.subtask;
 
   private readonly _tasks: TasksMap = {};
+  private readonly _scopes: ScopesMap = {};
 
   /**
    * Creates a task, overriding any previous task with the same name.
@@ -56,6 +64,8 @@ export class TasksDSL {
     descriptionOrAction?: string | ActionType<TaskArgumentsT>,
     action?: ActionType<TaskArgumentsT>
   ): TaskDefinition {
+    // if this function is updated, update the corresponding callback
+    // passed to `new SimpleScopeDefinition`
     return this._addTask(name, descriptionOrAction, action, false);
   }
 
@@ -96,9 +106,56 @@ export class TasksDSL {
     descriptionOrAction?: string | ActionType<TaskArgumentsT>,
     action?: ActionType<TaskArgumentsT>
   ): TaskDefinition {
+    // if this function is updated, update the corresponding callback
+    // passed to `new SimpleScopeDefinition`
     return this._addTask(name, descriptionOrAction, action, true);
   }
 
+  public scope(name: string, description?: string): ScopeDefinition {
+    if (this._tasks[name] !== undefined) {
+      throw new HardhatError(ERRORS.TASK_DEFINITIONS.TASK_SCOPE_CLASH, {
+        scopeName: name,
+      });
+    }
+
+    const scopeDefinition = this._scopes[name];
+
+    if (scopeDefinition !== undefined) {
+      // if the scope already exists, the only thing we might
+      // do is to update its description
+      if (description !== undefined) {
+        scopeDefinition.setDescription(description);
+      }
+
+      return scopeDefinition;
+    }
+
+    const scope = new SimpleScopeDefinition(
+      name,
+      description,
+      (taskName, descriptionOrAction, action) =>
+        // if this function is updated, update the dsl.task function too
+        this._addTask(
+          { scope: name, task: taskName },
+          descriptionOrAction,
+          action,
+          false
+        ),
+      (subtaskName, descriptionOrAction, action) =>
+        // if this function is updated, update the dsl.subtask function too
+        this._addTask(
+          { scope: name, task: subtaskName },
+          descriptionOrAction,
+          action,
+          true
+        )
+    );
+
+    this._scopes[name] = scope;
+
+    return scope;
+  }
+
   /**
    * Retrieves the task definitions.
    *
@@ -108,13 +165,41 @@ export class TasksDSL {
     return this._tasks;
   }
 
+  /**
+   * Retrieves the scoped task definitions.
+   *
+   * @returns The scoped tasks container.
+   */
+  public getScopesDefinitions(): ScopesMap {
+    return this._scopes;
+  }
+
+  public getTaskDefinition(
+    scope: string | undefined,
+    name: string
+  ): TaskDefinition | undefined {
+    if (scope === undefined) {
+      return this._tasks[name];
+    } else {
+      return this._scopes[scope]?.tasks?.[name];
+    }
+  }
+
   private _addTask<TaskArgumentsT extends TaskArguments>(
-    name: string,
+    taskIdentifier: TaskIdentifier,
     descriptionOrAction?: string | ActionType<TaskArgumentsT>,
     action?: ActionType<TaskArgumentsT>,
     isSubtask?: boolean
   ) {
-    const parentTaskDefinition = this._tasks[name];
+    const { scope, task } = parseTaskIdentifier(taskIdentifier);
+
+    if (scope === undefined && this._scopes[task] !== undefined) {
+      throw new HardhatError(ERRORS.TASK_DEFINITIONS.SCOPE_TASK_CLASH, {
+        taskName: task,
+      });
+    }
+
+    const parentTaskDefinition = this.getTaskDefinition(scope, task);
 
     let taskDefinition: TaskDefinition;
 
@@ -124,7 +209,7 @@ export class TasksDSL {
         isSubtask
       );
     } else {
-      taskDefinition = new SimpleTaskDefinition(name, isSubtask);
+      taskDefinition = new SimpleTaskDefinition(taskIdentifier, isSubtask);
     }
 
     if (descriptionOrAction instanceof Function) {
@@ -140,7 +225,17 @@ export class TasksDSL {
       taskDefinition.setAction(action);
     }
 
-    this._tasks[name] = taskDefinition;
+    if (scope === undefined) {
+      this._tasks[task] = taskDefinition;
+    } else {
+      const scopeDefinition = this._scopes[scope];
+      assertHardhatInvariant(
+        scopeDefinition !== undefined,
+        "It shouldn't be possible to create a task in a scope that doesn't exist"
+      );
+      scopeDefinition.tasks[task] = taskDefinition;
+    }
+
     return taskDefinition;
   }
 }

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

@@ -4,13 +4,17 @@ import {
   CLIArgumentType,
   ParamDefinition,
   ParamDefinitionsMap,
+  ScopeDefinition,
   TaskArguments,
   TaskDefinition,
+  TaskIdentifier,
+  TasksMap,
 } from "../../../types";
 import { HardhatError } from "../errors";
 import { ErrorDescriptor, ERRORS } from "../errors-list";
 import * as types from "../params/argumentTypes";
 import { HARDHAT_PARAM_DEFINITIONS } from "../params/hardhat-params";
+import { parseTaskIdentifier } from "./util";
 
 function isCLIArgumentType(
   type: ArgumentType<any>
@@ -26,6 +30,12 @@ function isCLIArgumentType(
  *
  */
 export class SimpleTaskDefinition implements TaskDefinition {
+  public get name() {
+    return this._task;
+  }
+  public get scope() {
+    return this._scope;
+  }
   public get description() {
     return this._description;
   }
@@ -36,6 +46,8 @@ export class SimpleTaskDefinition implements TaskDefinition {
   private _positionalParamNames: Set<string>;
   private _hasVariadicParam: boolean;
   private _hasOptionalPositionalParam: boolean;
+  private _scope?: string;
+  private _task: string;
   private _description?: string;
 
   /**
@@ -43,19 +55,22 @@ export class SimpleTaskDefinition implements TaskDefinition {
    *
    * This definition will have no params, and will throw a HH205 if executed.
    *
-   * @param name The task's name.
+   * @param taskIdentifier The task's identifier.
    * @param isSubtask `true` if the task is a subtask, `false` otherwise.
    */
   constructor(
-    public readonly name: string,
+    taskIdentifier: TaskIdentifier,
     public readonly isSubtask: boolean = false
   ) {
     this._positionalParamNames = new Set();
     this._hasVariadicParam = false;
     this._hasOptionalPositionalParam = false;
+    const { scope, task } = parseTaskIdentifier(taskIdentifier);
+    this._scope = scope;
+    this._task = task;
     this.action = () => {
       throw new HardhatError(ERRORS.TASK_DEFINITIONS.ACTION_NOT_SET, {
-        taskName: name,
+        taskName: this._task,
       });
     };
   }
@@ -562,6 +577,10 @@ export class OverriddenTaskDefinition implements TaskDefinition {
     this.parentTaskDefinition = parentTaskDefinition;
   }
 
+  /**
+   * Sets the task's description.
+   * @param description The description.
+   */
   public setDescription(description: string) {
     this._description = description;
     return this;
@@ -579,6 +598,13 @@ export class OverriddenTaskDefinition implements TaskDefinition {
     return this;
   }
 
+  /**
+   * Retrieves the parent task's scope.
+   */
+  public get scope() {
+    return this.parentTaskDefinition.scope;
+  }
+
   /**
    * Retrieves the parent task's name.
    */
@@ -734,3 +760,71 @@ export class OverriddenTaskDefinition implements TaskDefinition {
     });
   }
 }
+
+type AddTaskFunction = <TaskArgumentsT extends TaskArguments>(
+  name: string,
+  descriptionOrAction?: string | ActionType<TaskArgumentsT>,
+  action?: ActionType<TaskArgumentsT>
+) => TaskDefinition;
+
+export class SimpleScopeDefinition implements ScopeDefinition {
+  public tasks: TasksMap = {};
+
+  constructor(
+    public readonly name: string,
+    private _description: string | undefined,
+    private _addTask: AddTaskFunction,
+    private _addSubtask: AddTaskFunction
+  ) {}
+
+  public get description() {
+    return this._description;
+  }
+
+  public setDescription(description: string): this {
+    this._description = description;
+    return this;
+  }
+
+  public task<TaskArgumentsT extends TaskArguments>(
+    name: string,
+    description?: string,
+    action?: ActionType<TaskArgumentsT>
+  ): TaskDefinition;
+  public task<TaskArgumentsT extends TaskArguments>(
+    name: string,
+    action: ActionType<TaskArgumentsT>
+  ): TaskDefinition;
+  public task<TaskArgumentsT extends TaskArguments>(
+    name: string,
+    descriptionOrAction?: string | ActionType<TaskArgumentsT>,
+    action?: ActionType<TaskArgumentsT>
+  ) {
+    const task = this._addTask(name, descriptionOrAction, action);
+
+    this.tasks[name] = task;
+
+    return task;
+  }
+
+  public subtask<TaskArgumentsT extends TaskArguments>(
+    name: string,
+    description?: string,
+    action?: ActionType<TaskArgumentsT>
+  ): TaskDefinition;
+  public subtask<TaskArgumentsT extends TaskArguments>(
+    name: string,
+    action: ActionType<TaskArgumentsT>
+  ): TaskDefinition;
+  public subtask<TaskArgumentsT extends TaskArguments>(
+    name: string,
+    descriptionOrAction?: string | ActionType<TaskArgumentsT>,
+    action?: ActionType<TaskArgumentsT>
+  ) {
+    const subtask = this._addSubtask(name, descriptionOrAction, action);
+
+    this.tasks[name] = subtask;
+
+    return subtask;
+  }
+}

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

@@ -0,0 +1,18 @@
+import { TaskIdentifier } from "../../../types";
+
+export function parseTaskIdentifier(taskIdentifier: TaskIdentifier): {
+  scope: string | undefined;
+  task: string;
+} {
+  if (typeof taskIdentifier === "string") {
+    return {
+      scope: undefined,
+      task: taskIdentifier,
+    };
+  } else {
+    return {
+      scope: taskIdentifier.scope,
+      task: taskIdentifier.task,
+    };
+  }
+}

package/src/internal/lib/hardhat-lib.ts

@@ -40,6 +40,7 @@ if (HardhatContext.isCreated()) {
     resolvedConfig,
     hardhatArguments,
     ctx.tasksDSL.getTaskDefinitions(),
+    ctx.tasksDSL.getScopesDefinitions(),
     ctx.environmentExtenders,
     ctx.experimentalHardhatNetworkMessageTraceHooks,
     userConfig,

package/src/internal/sentry/anonymizer.ts

@@ -171,9 +171,11 @@ export class Anonymizer {
 
   private _isHardhatFile(filename: string): boolean {
     const nomiclabsPath = path.join("node_modules", "@nomiclabs");
+    const nomicFoundationPath = path.join("node_modules", "@nomicfoundation");
     const truffleContractPath = path.join(nomiclabsPath, "truffle-contract");
     const isHardhatFile =
-      filename.startsWith(nomiclabsPath) &&
+      (filename.startsWith(nomiclabsPath) ||
+        filename.startsWith(nomicFoundationPath)) &&
       !filename.startsWith(truffleContractPath);
 
     return isHardhatFile;

package/src/internal/solidity/compiler/solc-info.ts

@@ -0,0 +1,67 @@
+const defaultEvmTargets: { [key: string]: string } = {
+  "0.5.1": "byzantium",
+  "0.5.2": "byzantium",
+  "0.5.3": "byzantium",
+  "0.5.4": "byzantium",
+  "0.5.5": "petersburg",
+  "0.5.6": "petersburg",
+  "0.5.7": "petersburg",
+  "0.5.8": "petersburg",
+  "0.5.9": "petersburg",
+  "0.5.10": "petersburg",
+  "0.5.11": "petersburg",
+  "0.5.12": "petersburg",
+  "0.5.13": "petersburg",
+  "0.5.14": "istanbul",
+  "0.5.15": "istanbul",
+  "0.5.16": "istanbul",
+  "0.5.17": "istanbul",
+  "0.6.0": "istanbul",
+  "0.6.1": "istanbul",
+  "0.6.2": "istanbul",
+  "0.6.3": "istanbul",
+  "0.6.4": "istanbul",
+  "0.6.5": "istanbul",
+  "0.6.6": "istanbul",
+  "0.6.7": "istanbul",
+  "0.6.8": "istanbul",
+  "0.6.9": "istanbul",
+  "0.6.10": "istanbul",
+  "0.6.11": "istanbul",
+  "0.6.12": "istanbul",
+  "0.7.0": "istanbul",
+  "0.7.1": "istanbul",
+  "0.7.2": "istanbul",
+  "0.7.3": "istanbul",
+  "0.7.4": "istanbul",
+  "0.7.5": "istanbul",
+  "0.7.6": "istanbul",
+  "0.8.0": "istanbul",
+  "0.8.1": "istanbul",
+  "0.8.2": "istanbul",
+  "0.8.3": "istanbul",
+  "0.8.4": "istanbul",
+  "0.8.5": "berlin",
+  "0.8.6": "berlin",
+  "0.8.7": "london",
+  "0.8.8": "london",
+  "0.8.9": "london",
+  "0.8.10": "london",
+  "0.8.11": "london",
+  "0.8.12": "london",
+  "0.8.13": "london",
+  "0.8.14": "london",
+  "0.8.15": "london",
+  "0.8.16": "london",
+  "0.8.17": "london",
+  "0.8.18": "paris",
+  "0.8.19": "paris",
+  "0.8.20": "shanghai",
+  "0.8.21": "shanghai",
+};
+
+export function getEvmVersionFromSolcVersion(
+  solcVersion: string
+): string | undefined {
+  return defaultEvmTargets[solcVersion];
+}

package/src/register.ts

@@ -42,6 +42,7 @@ if (!HardhatContext.isCreated()) {
     resolvedConfig,
     hardhatArguments,
     ctx.tasksDSL.getTaskDefinitions(),
+    ctx.tasksDSL.getScopesDefinitions(),
     ctx.environmentExtenders,
     ctx.experimentalHardhatNetworkMessageTraceHooks,
     userConfig,

package/src/types/builtin-tasks/compile.ts

@@ -15,6 +15,11 @@ export interface ResolvedFile {
   getVersionedName(): string;
 }
 
+export type ArtifactsEmittedPerFile = Array<{
+  file: ResolvedFile;
+  artifactsEmitted: string[];
+}>;
+
 /**
  * Information about an npm library.
  */

package/src/types/runtime.ts

@@ -93,6 +93,26 @@ export interface ConfigurableTaskDefinition {
   addFlag(name: string, description?: string): this;
 }
 
+// type alias to get the overloaded function type
+// for 'task` and 'subtask'
+declare function addTask<TaskArgumentsT extends TaskArguments>(
+  name: string,
+  description?: string,
+  action?: ActionType<TaskArgumentsT>
+): ConfigurableTaskDefinition;
+declare function addTask<TaskArgumentsT extends TaskArguments>(
+  name: string,
+  action: ActionType<TaskArgumentsT>
+): ConfigurableTaskDefinition;
+type AddConfigurableTaskFunction = typeof addTask;
+
+export interface ConfigurableScopeDefinition {
+  setDescription(description: string): this;
+
+  task: AddConfigurableTaskFunction;
+  subtask: AddConfigurableTaskFunction;
+}
+
 export interface ParamDefinition<T> {
   name: string;
   defaultValue?: T;
@@ -118,6 +138,7 @@ export interface ParamDefinitionsMap {
 }
 
 export interface TaskDefinition extends ConfigurableTaskDefinition {
+  readonly scope?: string;
   readonly name: string;
   readonly description?: string;
   readonly action: ActionType<TaskArguments>;
@@ -130,6 +151,14 @@ export interface TaskDefinition extends ConfigurableTaskDefinition {
   readonly positionalParamDefinitions: Array<ParamDefinition<any>>;
 }
 
+export interface ScopeDefinition extends ConfigurableScopeDefinition {
+  readonly name: string;
+  readonly description?: string;
+  readonly tasks: TasksMap;
+}
+
+export type TaskIdentifier = string | { scope?: string; task: string };
+
 /**
  * @type TaskArguments {object-like} - the input arguments for a task.
  *
@@ -188,8 +217,12 @@ export interface TasksMap {
   [name: string]: TaskDefinition;
 }
 
+export interface ScopesMap {
+  [scopeName: string]: ScopeDefinition;
+}
+
 export type RunTaskFunction = (
-  name: string,
+  taskIdentifier: TaskIdentifier,
   taskArguments?: TaskArguments,
   subtaskArguments?: SubtaskArguments
 ) => Promise<any>;
@@ -199,6 +232,7 @@ export interface HardhatRuntimeEnvironment {
   readonly userConfig: HardhatUserConfig;
   readonly hardhatArguments: HardhatArguments;
   readonly tasks: TasksMap;
+  readonly scopes: ScopesMap;
   readonly run: RunTaskFunction;
   readonly network: Network;
   readonly artifacts: Artifacts;