hardhat 2.13.0-dev.2 → 2.13.0-dev.3

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

@@ -2,7 +2,6 @@ import debug from "debug";
 
 import {
   Artifacts as IArtifacts,
-  ArtifactsSource,
   EnvironmentExtender,
   ExperimentalHardhatNetworkMessageTraceHook,
   HardhatArguments,
@@ -13,6 +12,7 @@ import {
   ParamDefinition,
   RunSuperFunction,
   RunTaskFunction,
+  SubtaskArguments,
   TaskArguments,
   TaskDefinition,
   TasksMap,
@@ -21,6 +21,7 @@ import { Artifacts } from "../artifacts";
 import { MessageTrace } from "../hardhat-network/stack-traces/message-trace";
 import { lazyObject } from "../util/lazy";
 
+import { getHardhatVersion } from "../util/packageInfo";
 import { analyzeModuleNotFoundError } from "./config/config-loading";
 import { HardhatError } from "./errors";
 import { ERRORS } from "./errors-list";
@@ -51,6 +52,8 @@ export class Environment implements HardhatRuntimeEnvironment {
 
   public entryTaskProfile?: TaskProfile;
 
+  public version: string = getHardhatVersion();
+
   /**
    * Initializes the Hardhat Runtime Environment and the given
    * extender functions.
@@ -68,7 +71,6 @@ export class Environment implements HardhatRuntimeEnvironment {
     public readonly hardhatArguments: HardhatArguments,
     public readonly tasks: TasksMap,
     extenders: EnvironmentExtender[] = [],
-    artifactsExtensions: ArtifactsSource[] = [],
     experimentalHardhatNetworkMessageTraceHooks: ExperimentalHardhatNetworkMessageTraceHook[] = [],
     public readonly userConfig: HardhatUserConfig = {}
   ) {
@@ -87,7 +89,7 @@ export class Environment implements HardhatRuntimeEnvironment {
       });
     }
 
-    this.artifacts = new Artifacts(config.paths.artifacts, artifactsExtensions);
+    this.artifacts = new Artifacts(config.paths.artifacts);
 
     const provider = lazyObject(() => {
       log(`Creating provider for network ${networkName}`);
@@ -119,6 +121,7 @@ export class Environment implements HardhatRuntimeEnvironment {
    *
    * @param name The task's name.
    * @param taskArguments A map of task's arguments.
+   * @param subtaskArguments A map of subtasks to their arguments.
    *
    * @throws a HH303 if there aren't any defined tasks with the given name.
    * @returns a promise with the task's execution result.
@@ -126,6 +129,7 @@ export class Environment implements HardhatRuntimeEnvironment {
   public readonly run: RunTaskFunction = async (
     name,
     taskArguments = {},
+    subtaskArguments = {},
     callerTaskProfile?: TaskProfile
   ) => {
     const taskDefinition = this.tasks[name];
@@ -140,7 +144,8 @@ export class Environment implements HardhatRuntimeEnvironment {
 
     const resolvedTaskArguments = this._resolveValidTaskArguments(
       taskDefinition,
-      taskArguments
+      taskArguments,
+      subtaskArguments
     );
 
     let taskProfile: TaskProfile | undefined;
@@ -158,6 +163,7 @@ export class Environment implements HardhatRuntimeEnvironment {
       return await this._runTaskDefinition(
         taskDefinition,
         resolvedTaskArguments,
+        subtaskArguments,
         taskProfile
       );
     } catch (e) {
@@ -217,20 +223,23 @@ export class Environment implements HardhatRuntimeEnvironment {
   private async _runTaskDefinition(
     taskDefinition: TaskDefinition,
     taskArguments: TaskArguments,
+    subtaskArguments: SubtaskArguments,
     taskProfile?: TaskProfile
   ): Promise<any> {
     let runSuperFunction: any;
 
     if (taskDefinition instanceof OverriddenTaskDefinition) {
       runSuperFunction = async (
-        _taskArguments: TaskArguments = taskArguments
+        _taskArguments: TaskArguments = taskArguments,
+        _subtaskArguments: SubtaskArguments = subtaskArguments
       ) => {
         log("Running %s's super", taskDefinition.name);
 
         if (taskProfile === undefined) {
           return this._runTaskDefinition(
             taskDefinition.parentTaskDefinition,
-            _taskArguments
+            _taskArguments,
+            _subtaskArguments
           );
         }
 
@@ -241,6 +250,7 @@ export class Environment implements HardhatRuntimeEnvironment {
           return await this._runTaskDefinition(
             taskDefinition.parentTaskDefinition,
             _taskArguments,
+            _subtaskArguments,
             parentTaskProfile
           );
         } finally {
@@ -265,17 +275,30 @@ export class Environment implements HardhatRuntimeEnvironment {
     const previousRunSuper: any = globalAsAny.runSuper;
     globalAsAny.runSuper = runSuper;
 
-    let modifiedHreWithParentTaskProfile: any | undefined;
+    // We create a modified version of `this`, as we want to keep track of the
+    // `subtaskArguments` and `taskProfile` through `run` invocations. This
+    // way we keep track of callers's data, even when tasks are run in parallel.
+    //
+    // Note that for this to work we need to set the prototype later
+    let modifiedHre: any = {
+      ...this,
+      run: (
+        _name: string,
+        _taskArguments: TaskArguments,
+        _subtaskArguments: SubtaskArguments
+      ) =>
+        (this as any).run(
+          _name,
+          _taskArguments,
+          { ..._subtaskArguments, ...subtaskArguments }, // parent subtask args take precedence
+          taskProfile
+        ),
+    };
+
     if (this.hardhatArguments.flamegraph === true) {
-      // We create a modified version of `this`, as we want to keep track of the
-      // `taskProfile` and use it as `callerTaskProfile` if the action calls
-      // `run`, and add a few utility methods.
-      //
-      // Note that for this to work we need to set the prototype later
-      modifiedHreWithParentTaskProfile = {
-        ...this,
-        run: (_name: string, _taskArguments: TaskArguments) =>
-          (this as any).run(_name, _taskArguments, taskProfile),
+      // We modify the `this` again to add  a few utility methods.
+      modifiedHre = {
+        ...modifiedHre,
         adhocProfile: async (_name: string, f: () => Promise<any>) => {
           const adhocProfile = createTaskProfile(_name);
           taskProfile!.children.push(adhocProfile);
@@ -295,21 +318,17 @@ export class Environment implements HardhatRuntimeEnvironment {
           }
         },
       };
-
-      Object.setPrototypeOf(
-        modifiedHreWithParentTaskProfile,
-        Object.getPrototypeOf(this)
-      );
     }
 
+    Object.setPrototypeOf(modifiedHre, Object.getPrototypeOf(this));
+
     const uninjectFromGlobal =
-      modifiedHreWithParentTaskProfile?.injectToGlobal() ??
-      this.injectToGlobal();
+      modifiedHre?.injectToGlobal() ?? this.injectToGlobal();
 
     try {
       return await taskDefinition.action(
         taskArguments,
-        modifiedHreWithParentTaskProfile ?? this,
+        modifiedHre ?? this,
         runSuper
       );
     } finally {
@@ -333,9 +352,14 @@ export class Environment implements HardhatRuntimeEnvironment {
    */
   private _resolveValidTaskArguments(
     taskDefinition: TaskDefinition,
-    taskArguments: TaskArguments
+    taskArguments: TaskArguments,
+    subtaskArguments: SubtaskArguments
   ): TaskArguments {
-    const { paramDefinitions, positionalParamDefinitions } = taskDefinition;
+    const {
+      name: taskName,
+      paramDefinitions,
+      positionalParamDefinitions,
+    } = taskDefinition;
 
     const nonPositionalParamDefinitions = Object.values(paramDefinitions);
 
@@ -345,45 +369,26 @@ export class Environment implements HardhatRuntimeEnvironment {
       ...positionalParamDefinitions,
     ];
 
-    const initResolvedArguments: {
-      errors: HardhatError[];
-      values: TaskArguments;
-    } = { errors: [], values: {} };
+    const resolvedArguments: TaskArguments = {};
 
-    const resolvedArguments = allTaskParamDefinitions.reduce(
-      ({ errors, values }, paramDefinition) => {
-        try {
-          const paramName = paramDefinition.name;
-          const argumentValue = taskArguments[paramName];
-          const resolvedArgumentValue = this._resolveArgument(
-            paramDefinition,
-            argumentValue,
-            taskDefinition.name
-          );
-          if (resolvedArgumentValue !== undefined) {
-            values[paramName] = resolvedArgumentValue;
-          }
-        } catch (error) {
-          if (HardhatError.isHardhatError(error)) {
-            errors.push(error);
-          }
-        }
-        return { errors, values };
-      },
-      initResolvedArguments
-    );
+    for (const paramDefinition of allTaskParamDefinitions) {
+      const paramName = paramDefinition.name;
+      const argumentValue =
+        subtaskArguments[taskName]?.[paramName] ?? taskArguments[paramName];
 
-    const { errors: resolveErrors, values: resolvedValues } = resolvedArguments;
+      const resolvedArgumentValue = this._resolveArgument(
+        paramDefinition,
+        argumentValue,
+        taskDefinition.name
+      );
 
-    // if has argument errors, throw the first one
-    if (resolveErrors.length > 0) {
-      throw resolveErrors[0];
+      if (resolvedArgumentValue !== undefined) {
+        resolvedArguments[paramName] = resolvedArgumentValue;
+      }
     }
 
-    // append the rest of arguments that where not in the task param definitions
-    const resolvedTaskArguments = { ...taskArguments, ...resolvedValues };
-
-    return resolvedTaskArguments;
+    // We keep the args in taskArguments that were not resolved
+    return { ...taskArguments, ...resolvedArguments };
   }
 
   /**

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

@@ -29,10 +29,10 @@ export class TasksDSL {
    * @param action The task's action.
    * @returns A task definition.
    */
-  public task<ArgsT extends TaskArguments>(
+  public task<TaskArgumentsT extends TaskArguments>(
     name: string,
     description?: string,
-    action?: ActionType<ArgsT>
+    action?: ActionType<TaskArgumentsT>
   ): TaskDefinition;
 
   /**
@@ -46,15 +46,15 @@ export class TasksDSL {
    *
    * @returns A task definition.
    */
-  public task<ArgsT extends TaskArguments>(
+  public task<TaskArgumentsT extends TaskArguments>(
     name: string,
-    action: ActionType<ArgsT>
+    action: ActionType<TaskArgumentsT>
   ): TaskDefinition;
 
-  public task<ArgsT extends TaskArguments>(
+  public task<TaskArgumentsT extends TaskArguments>(
     name: string,
-    descriptionOrAction?: string | ActionType<ArgsT>,
-    action?: ActionType<ArgsT>
+    descriptionOrAction?: string | ActionType<TaskArgumentsT>,
+    action?: ActionType<TaskArgumentsT>
   ): TaskDefinition {
     return this._addTask(name, descriptionOrAction, action, false);
   }
@@ -70,10 +70,10 @@ export class TasksDSL {
    * @param action The task's action.
    * @returns A task definition.
    */
-  public subtask<ArgsT extends TaskArguments>(
+  public subtask<TaskArgumentsT extends TaskArguments>(
     name: string,
     description?: string,
-    action?: ActionType<ArgsT>
+    action?: ActionType<TaskArgumentsT>
   ): TaskDefinition;
 
   /**
@@ -87,14 +87,14 @@ export class TasksDSL {
    * @param action The task's action.
    * @returns A task definition.
    */
-  public subtask<ArgsT extends TaskArguments>(
+  public subtask<TaskArgumentsT extends TaskArguments>(
     name: string,
-    action: ActionType<ArgsT>
+    action: ActionType<TaskArgumentsT>
   ): TaskDefinition;
-  public subtask<ArgsT extends TaskArguments>(
+  public subtask<TaskArgumentsT extends TaskArguments>(
     name: string,
-    descriptionOrAction?: string | ActionType<ArgsT>,
-    action?: ActionType<ArgsT>
+    descriptionOrAction?: string | ActionType<TaskArgumentsT>,
+    action?: ActionType<TaskArgumentsT>
   ): TaskDefinition {
     return this._addTask(name, descriptionOrAction, action, true);
   }
@@ -108,10 +108,10 @@ export class TasksDSL {
     return this._tasks;
   }
 
-  private _addTask<ArgT extends TaskArguments>(
+  private _addTask<TaskArgumentsT extends TaskArguments>(
     name: string,
-    descriptionOrAction?: string | ActionType<ArgT>,
-    action?: ActionType<ArgT>,
+    descriptionOrAction?: string | ActionType<TaskArgumentsT>,
+    action?: ActionType<TaskArgumentsT>,
     isSubtask?: boolean
   ) {
     const parentTaskDefinition = this._tasks[name];

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

@@ -73,7 +73,9 @@ export class SimpleTaskDefinition implements TaskDefinition {
    * Sets the task's action.
    * @param action The action.
    */
-  public setAction<ArgsT extends TaskArguments>(action: ActionType<ArgsT>) {
+  public setAction<TaskArgumentsT extends TaskArguments>(
+    action: ActionType<TaskArgumentsT>
+  ) {
     // TODO: There's probably something bad here. See types.ts for more info.
     this.action = action;
     return this;
@@ -569,7 +571,9 @@ export class OverriddenTaskDefinition implements TaskDefinition {
    * Overrides the parent task's action.
    * @param action the action.
    */
-  public setAction<ArgsT extends TaskArguments>(action: ActionType<ArgsT>) {
+  public setAction<TaskArgumentsT extends TaskArguments>(
+    action: ActionType<TaskArgumentsT>
+  ) {
     // TODO: There's probably something bad here. See types.ts for more info.
     this._action = action;
     return this;

package/src/internal/hardhat-network/jsonrpc/handler.ts

@@ -82,40 +82,23 @@ export class JsonRpcHandler {
     this._provider.addListener("notification", listener);
 
     ws.on("message", async (msg) => {
-      let rpcReq: JsonRpcRequest | undefined;
-      let rpcResp: JsonRpcResponse | undefined;
+      let rpcReq: JsonRpcRequest | JsonRpcRequest[];
+      let rpcResp: JsonRpcResponse | JsonRpcResponse[];
 
       try {
         rpcReq = _readWsRequest(msg as string);
 
-        if (!isValidJsonRequest(rpcReq)) {
-          throw new InvalidRequestError("Invalid request");
-        }
-
-        rpcResp = await this._handleRequest(rpcReq);
-
-        // If eth_subscribe was successful, keep track of the subscription id,
-        // so we can cleanup on websocket close.
-        if (
-          rpcReq.method === "eth_subscribe" &&
-          isSuccessfulJsonResponse(rpcResp)
-        ) {
-          subscriptions.push(rpcResp.result);
-        }
+        rpcResp = Array.isArray(rpcReq)
+          ? await Promise.all(
+              rpcReq.map((req) =>
+                this._handleSingleWsRequest(req, subscriptions)
+              )
+            )
+          : await this._handleSingleWsRequest(rpcReq, subscriptions);
       } catch (error) {
         rpcResp = _handleError(error);
       }
 
-      // Validate the RPC response.
-      if (!isValidJsonResponse(rpcResp)) {
-        // Malformed response coming from the provider, report to user as an internal error.
-        rpcResp = _handleError(new InternalError("Internal error"));
-      }
-
-      if (rpcReq !== undefined) {
-        rpcResp.id = rpcReq.id;
-      }
-
       ws.send(JSON.stringify(rpcResp));
     });
 
@@ -155,7 +138,9 @@ export class JsonRpcHandler {
     res.end(JSON.stringify(rpcResp));
   }
 
-  private async _handleSingleRequest(req: any): Promise<JsonRpcResponse> {
+  private async _handleSingleRequest(
+    req: JsonRpcRequest
+  ): Promise<JsonRpcResponse> {
     if (!isValidJsonRequest(req)) {
       return _handleError(new InvalidRequestError("Invalid request"));
     }
@@ -182,6 +167,24 @@ export class JsonRpcHandler {
     return rpcResp;
   }
 
+  private async _handleSingleWsRequest(
+    rpcReq: JsonRpcRequest,
+    subscriptions: string[]
+  ) {
+    const rpcResp = await this._handleSingleRequest(rpcReq);
+
+    // If eth_subscribe was successful, keep track of the subscription id,
+    // so we can cleanup on websocket close.
+    if (
+      rpcReq.method === "eth_subscribe" &&
+      isSuccessfulJsonResponse(rpcResp)
+    ) {
+      subscriptions.push(rpcResp.result);
+    }
+
+    return rpcResp;
+  }
+
   private _handleRequest = async (
     req: JsonRpcRequest
   ): Promise<JsonRpcResponse> => {
@@ -218,7 +221,7 @@ const _readJsonHttpRequest = async (req: IncomingMessage): Promise<any> => {
   return json;
 };
 
-const _readWsRequest = (msg: string): JsonRpcRequest => {
+const _readWsRequest = (msg: string): JsonRpcRequest | JsonRpcRequest[] => {
   let json: any;
   try {
     json = JSON.parse(msg);

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

@@ -32,6 +32,7 @@ export class EvmModule {
     private readonly _node: HardhatNode,
     private readonly _miningTimer: MiningTimer,
     private readonly _logger: ModulesLogger,
+    private readonly _allowBlocksWithSameTimestamp: boolean,
     private readonly _experimentalHardhatNetworkMessageTraceHooks: BoundExperimentalHardhatNetworkMessageTraceHook[] = []
   ) {}
 
@@ -86,12 +87,23 @@ export class EvmModule {
     const latestBlock = await this._node.getLatestBlock();
     const increment = BigInt(timestamp) - latestBlock.header.timestamp;
 
-    if (increment <= 0n) {
+    if (increment < 0n) {
       throw new InvalidInputError(
-        `Timestamp ${timestamp.toString()} is lower than or equal to previous block's timestamp` +
-          ` ${latestBlock.header.timestamp}`
+        `Timestamp ${timestamp.toString()} is lower than the previous block's timestamp ${
+          latestBlock.header.timestamp
+        }`
       );
     }
+
+    if (!this._allowBlocksWithSameTimestamp && increment === 0n) {
+      throw new InvalidInputError(
+        `Timestamp ${timestamp.toString()} is equal to the previous block's timestamp.
+
+Enable the "allowBlocksWithSameTimestamp" option in the Hardhat network configuration to allow this.
+`
+      );
+    }
+
     this._node.setNextBlockTimestamp(BigInt(timestamp));
     return timestamp.toString();
   }

package/src/internal/hardhat-network/provider/node-types.ts

@@ -24,7 +24,6 @@ interface CommonConfig {
   hardfork: string;
   minGasPrice: bigint;
   networkId: number;
-  networkName: string;
   allowUnlimitedContractSize?: boolean;
   initialDate?: Date;
   tracingConfig?: TracingConfig;
@@ -32,6 +31,7 @@ interface CommonConfig {
   mempoolOrder: MempoolOrder;
   coinbase: string;
   chains: HardhatNetworkChainsConfig;
+  allowBlocksWithSameTimestamp: boolean;
 }
 
 export type LocalNodeConfig = CommonConfig;

package/src/internal/hardhat-network/provider/node.ts

@@ -146,6 +146,7 @@ export class HardhatNode extends EventEmitter {
       mempoolOrder,
       networkId,
       chainId,
+      allowBlocksWithSameTimestamp,
     } = config;
 
     let stateManager: StateManager;
@@ -293,6 +294,7 @@ export class HardhatNode extends EventEmitter {
       hardfork,
       hardforkActivations,
       mixHashGenerator,
+      allowBlocksWithSameTimestamp,
       tracingConfig,
       forkNetworkId,
       forkBlockNum,
@@ -378,6 +380,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
     public readonly hardfork: HardforkName,
     private readonly _hardforkActivations: HardforkHistoryConfig,
     private _mixHashGenerator: RandomBufferGenerator,
+    private _allowBlocksWithSameTimestamp: boolean,
     tracingConfig?: TracingConfig,
     private _forkNetworkId?: number,
     private _forkBlockNumber?: bigint,
@@ -494,7 +497,8 @@ Hardhat Network's forking functionality only works with blocks from at least spu
     const [, offsetShouldChange, newOffset] = timestampAndOffset;
 
     const needsTimestampIncrease =
-      await this._timestampClashesWithPreviousBlockOne(blockTimestamp);
+      !this._allowBlocksWithSameTimestamp &&
+      (await this._timestampClashesWithPreviousBlockOne(blockTimestamp));
     if (needsTimestampIncrease) {
       blockTimestamp += 1n;
     }