hardhat 2.17.3 → 2.18.0

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/hardhat-network/provider/modules/base.ts

@@ -0,0 +1,156 @@
+import { Block } from "@nomicfoundation/ethereumjs-block";
+import {
+  bufferToHex,
+  toBuffer,
+  zeroAddress,
+} from "@nomicfoundation/ethereumjs-util";
+import {
+  OptionalRpcNewBlockTag,
+  RpcNewBlockTag,
+} from "../../../core/jsonrpc/types/input/blockTag";
+import { HardhatNode } from "../node";
+import * as BigIntUtils from "../../../util/bigint";
+import {
+  InvalidArgumentsError,
+  InvalidInputError,
+} from "../../../core/providers/errors";
+import { RpcCallRequest } from "../../../core/jsonrpc/types/input/callRequest";
+import { CallParams } from "../node-types";
+import { RpcAccessList } from "../../../core/jsonrpc/types/access-list";
+
+/* eslint-disable @nomicfoundation/hardhat-internal-rules/only-hardhat-error */
+
+export class Base {
+  constructor(protected readonly _node: HardhatNode) {}
+
+  public async resolveNewBlockTag(
+    newBlockTag: OptionalRpcNewBlockTag,
+    defaultValue: RpcNewBlockTag = "latest"
+  ): Promise<bigint | "pending"> {
+    if (newBlockTag === undefined) {
+      newBlockTag = defaultValue;
+    }
+
+    if (newBlockTag === "pending") {
+      return "pending";
+    }
+
+    if (newBlockTag === "latest") {
+      return this._node.getLatestBlockNumber();
+    }
+
+    if (newBlockTag === "earliest") {
+      return 0n;
+    }
+
+    if (newBlockTag === "safe" || newBlockTag === "finalized") {
+      this._checkPostMergeBlockTags(newBlockTag);
+
+      return this._node.getLatestBlockNumber();
+    }
+
+    if (!BigIntUtils.isBigInt(newBlockTag)) {
+      if ("blockNumber" in newBlockTag && "blockHash" in newBlockTag) {
+        throw new InvalidArgumentsError(
+          "Invalid block tag received. Only one of hash or block number can be used."
+        );
+      }
+
+      if ("blockNumber" in newBlockTag && "requireCanonical" in newBlockTag) {
+        throw new InvalidArgumentsError(
+          "Invalid block tag received. requireCanonical only works with hashes."
+        );
+      }
+    }
+
+    let block: Block | undefined;
+    if (BigIntUtils.isBigInt(newBlockTag)) {
+      block = await this._node.getBlockByNumber(newBlockTag);
+    } else if ("blockNumber" in newBlockTag) {
+      block = await this._node.getBlockByNumber(newBlockTag.blockNumber);
+    } else {
+      block = await this._node.getBlockByHash(newBlockTag.blockHash);
+    }
+
+    if (block === undefined) {
+      const latestBlock = this._node.getLatestBlockNumber();
+
+      throw new InvalidInputError(
+        `Received invalid block tag ${this._newBlockTagToString(
+          newBlockTag
+        )}. Latest block number is ${latestBlock.toString()}`
+      );
+    }
+
+    return block.header.number;
+  }
+
+  public async rpcCallRequestToNodeCallParams(
+    rpcCall: RpcCallRequest
+  ): Promise<CallParams> {
+    return {
+      to: rpcCall.to,
+      from:
+        rpcCall.from !== undefined
+          ? rpcCall.from
+          : await this._getDefaultCallFrom(),
+      data: rpcCall.data !== undefined ? rpcCall.data : toBuffer([]),
+      gasLimit:
+        rpcCall.gas !== undefined ? rpcCall.gas : this._node.getBlockGasLimit(),
+      value: rpcCall.value !== undefined ? rpcCall.value : 0n,
+      accessList:
+        rpcCall.accessList !== undefined
+          ? this._rpcAccessListToNodeAccessList(rpcCall.accessList)
+          : undefined,
+      gasPrice: rpcCall.gasPrice,
+      maxFeePerGas: rpcCall.maxFeePerGas,
+      maxPriorityFeePerGas: rpcCall.maxPriorityFeePerGas,
+    };
+  }
+
+  protected _rpcAccessListToNodeAccessList(
+    rpcAccessList: RpcAccessList
+  ): Array<[Buffer, Buffer[]]> {
+    return rpcAccessList.map((tuple) => [
+      tuple.address,
+      tuple.storageKeys ?? [],
+    ]);
+  }
+
+  protected _checkPostMergeBlockTags(blockTag: "safe" | "finalized") {
+    const isPostMerge = this._node.isPostMergeHardfork();
+    const hardfork = this._node.hardfork;
+
+    if (!isPostMerge) {
+      throw new InvalidArgumentsError(
+        `The '${blockTag}' block tag is not allowed in pre-merge hardforks. You are using the '${hardfork}' hardfork.`
+      );
+    }
+  }
+
+  protected _newBlockTagToString(tag: RpcNewBlockTag): string {
+    if (typeof tag === "string") {
+      return tag;
+    }
+
+    if (BigIntUtils.isBigInt(tag)) {
+      return tag.toString();
+    }
+
+    if ("blockNumber" in tag) {
+      return tag.blockNumber.toString();
+    }
+
+    return bufferToHex(tag.blockHash);
+  }
+
+  private async _getDefaultCallFrom(): Promise<Buffer> {
+    const localAccounts = await this._node.getLocalAccountAddresses();
+
+    if (localAccounts.length === 0) {
+      return toBuffer(zeroAddress());
+    }
+
+    return toBuffer(localAccounts[0]);
+  }
+}

package/src/internal/hardhat-network/provider/modules/debug.ts

@@ -1,4 +1,12 @@
 import { rpcHash } from "../../../core/jsonrpc/types/base-types";
+import {
+  OptionalRpcNewBlockTag,
+  optionalRpcNewBlockTag,
+} from "../../../core/jsonrpc/types/input/blockTag";
+import {
+  RpcCallRequest,
+  rpcCallRequest,
+} from "../../../core/jsonrpc/types/input/callRequest";
 import {
   rpcDebugTracingConfig,
   RpcDebugTracingConfig,
@@ -10,17 +18,22 @@ import {
 } from "../../../core/providers/errors";
 import { HardhatNode } from "../node";
 import { RpcDebugTraceOutput } from "../output";
+import { Base } from "./base";
 
 /* eslint-disable @nomicfoundation/hardhat-internal-rules/only-hardhat-error */
 
-export class DebugModule {
-  constructor(private readonly _node: HardhatNode) {}
+export class DebugModule extends Base {
+  constructor(_node: HardhatNode) {
+    super(_node);
+  }
 
   public async processRequest(
     method: string,
     params: any[] = []
   ): Promise<any> {
     switch (method) {
+      case "debug_traceCall":
+        return this._traceCallAction(...this._traceCallParams(params));
       case "debug_traceTransaction":
         return this._traceTransactionAction(
           ...this._traceTransactionParams(params)
@@ -30,6 +43,34 @@ export class DebugModule {
     throw new MethodNotFoundError(`Method ${method} not found`);
   }
 
+  // debug_traceCall
+
+  private _traceCallParams(
+    params: any[]
+  ): [RpcCallRequest, OptionalRpcNewBlockTag, RpcDebugTracingConfig] {
+    const validatedParams = validateParams(
+      params,
+      rpcCallRequest,
+      optionalRpcNewBlockTag,
+      rpcDebugTracingConfig
+    );
+
+    this._validateTracerParam(validatedParams[2]);
+
+    return validatedParams;
+  }
+
+  private async _traceCallAction(
+    callConfig: RpcCallRequest,
+    block: OptionalRpcNewBlockTag,
+    traceConfig: RpcDebugTracingConfig
+  ): Promise<RpcDebugTraceOutput> {
+    const callParams = await this.rpcCallRequestToNodeCallParams(callConfig);
+    const blockNumber = await this.resolveNewBlockTag(block);
+
+    return this._node.traceCall(callParams, blockNumber, traceConfig);
+  }
+
   // debug_traceTransaction
 
   private _traceTransactionParams(
@@ -46,6 +87,13 @@ export class DebugModule {
     return validatedParams;
   }
 
+  private async _traceTransactionAction(
+    hash: Buffer,
+    config: RpcDebugTracingConfig
+  ): Promise<RpcDebugTraceOutput> {
+    return this._node.traceTransaction(hash, config);
+  }
+
   private _validateTracerParam(config: RpcDebugTracingConfig) {
     if (config?.tracer !== undefined) {
       throw new InvalidArgumentsError(
@@ -53,11 +101,4 @@ export class DebugModule {
       );
     }
   }
-
-  private async _traceTransactionAction(
-    hash: Buffer,
-    config: RpcDebugTracingConfig
-  ): Promise<RpcDebugTraceOutput> {
-    return this._node.traceTransaction(hash, config);
-  }
 }