hardhat 2.19.0 → 2.19.2

package/src/builtin-tasks/test.ts

@@ -7,7 +7,11 @@ import { HARDHAT_NETWORK_NAME } from "../internal/constants";
 import { subtask, task } from "../internal/core/config/config-env";
 import { HardhatError } from "../internal/core/errors";
 import { ERRORS } from "../internal/core/errors-list";
-import { isRunningWithTypescript } from "../internal/core/typescript-support";
+import {
+  isJavascriptFile,
+  isRunningWithTypescript,
+  isTypescriptFile,
+} from "../internal/core/typescript-support";
 import { getForkCacheDirPath } from "../internal/hardhat-network/provider/utils/disk-cache";
 import { showForkRecommendationsBannerIfNecessary } from "../internal/hardhat-network/provider/utils/fork-recomendations-banner";
 import { pluralize } from "../internal/util/strings";
@@ -40,15 +44,16 @@ subtask(TASK_TEST_GET_TEST_FILES)
 
     const jsFiles = await getAllFilesMatching(
       config.paths.tests,
-      (f) => f.endsWith(".js") || f.endsWith(".cjs") || f.endsWith(".mjs")
+      isJavascriptFile
     );
 
     if (!isRunningWithTypescript(config)) {
       return jsFiles;
     }
 
-    const tsFiles = await getAllFilesMatching(config.paths.tests, (f) =>
-      f.endsWith(".ts")
+    const tsFiles = await getAllFilesMatching(
+      config.paths.tests,
+      isTypescriptFile
     );
 
     return [...jsFiles, ...tsFiles];

package/src/internal/artifacts.ts

@@ -154,14 +154,8 @@ export class Artifacts implements IArtifacts {
       return cached;
     }
 
-    const buildInfosDir = path.join(this._artifactsPath, BUILD_INFO_DIR_NAME);
-
-    const paths = await getAllFilesMatching(
-      this._artifactsPath,
-      (f) =>
-        f.endsWith(".json") &&
-        !f.startsWith(buildInfosDir) &&
-        !f.endsWith(".dbg.json")
+    const paths = await getAllFilesMatching(this._artifactsPath, (f) =>
+      this._isArtifactPath(f)
     );
 
     const result = paths.sort();
@@ -563,14 +557,8 @@ export class Artifacts implements IArtifacts {
       return cached;
     }
 
-    const buildInfosDir = path.join(this._artifactsPath, BUILD_INFO_DIR_NAME);
-
-    const paths = getAllFilesMatchingSync(
-      this._artifactsPath,
-      (f) =>
-        f.endsWith(".json") &&
-        !f.startsWith(buildInfosDir) &&
-        !f.endsWith(".dbg.json")
+    const paths = getAllFilesMatchingSync(this._artifactsPath, (f) =>
+      this._isArtifactPath(f)
     );
 
     const result = paths.sort();
@@ -934,6 +922,15 @@ Please replace "${contractName}" for the correct contract name wherever you are
 
     return undefined;
   }
+
+  private _isArtifactPath(file: string) {
+    return (
+      file.endsWith(".json") &&
+      file !== path.join(this._artifactsPath, "package.json") &&
+      !file.startsWith(path.join(this._artifactsPath, BUILD_INFO_DIR_NAME)) &&
+      !file.endsWith(".dbg.json")
+    );
+  }
 }
 
 /**

package/src/internal/cli/autocomplete.ts

@@ -2,7 +2,7 @@ import findup from "find-up";
 import * as fs from "fs-extra";
 import * as path from "path";
 
-import { HardhatRuntimeEnvironment } from "../../types";
+import { HardhatRuntimeEnvironment, TaskDefinition } from "../../types";
 import { HARDHAT_PARAM_DEFINITIONS } from "../core/params/hardhat-params";
 import { getCacheDir } from "../util/global-dir";
 import { createNonCryptographicHashBasedIdentifier } from "../util/hash";
@@ -22,19 +22,30 @@ interface CompletionEnv {
   point: number;
 }
 
+interface Task {
+  name: string;
+  description: string;
+  isSubtask: boolean;
+  paramDefinitions: {
+    [paramName: string]: {
+      name: string;
+      description: string;
+      isFlag: boolean;
+    };
+  };
+}
+
 interface CompletionData {
   networks: string[];
   tasks: {
-    [taskName: string]: {
+    [taskName: string]: Task;
+  };
+  scopes: {
+    [scopeName: string]: {
       name: string;
       description: string;
-      isSubtask: boolean;
-      paramDefinitions: {
-        [paramName: string]: {
-          name: string;
-          description: string;
-          isFlag: boolean;
-        };
+      tasks: {
+        [taskName: string]: Task;
       };
     };
   };
@@ -63,12 +74,12 @@ export async function complete({
     return [];
   }
 
-  const { networks, tasks } = completionData;
+  const { networks, tasks, scopes } = completionData;
 
   const words = line.split(/\s+/).filter((x) => x.length > 0);
 
   const wordsBeforeCursor = line.slice(0, point).split(/\s+/);
-  // examples:
+  // 'prev' and 'last' variables examples:
   // `hh compile --network|` => prev: "compile" last: "--network"
   // `hh compile --network |` => prev: "--network" last: ""
   // `hh compile --network ha|` => prev: "--network" last: "ha"
@@ -83,28 +94,58 @@ export async function complete({
     }))
     .filter((x) => !words.includes(x.name));
 
-  // check if the user entered a task
-  let task: string | undefined;
+  // Get the task or scope if the user has entered one
+  let taskName: string | undefined;
+  let scopeName: string | undefined;
+
   let index = 1;
   while (index < words.length) {
-    if (isGlobalFlag(words[index])) {
+    const word = words[index];
+
+    if (isGlobalFlag(word)) {
       index += 1;
-    } else if (isGlobalParam(words[index])) {
+    } else if (isGlobalParam(word)) {
       index += 2;
-    } else if (words[index].startsWith("--")) {
+    } else if (word.startsWith("--")) {
       index += 1;
     } else {
-      task = words[index];
-      break;
+      // Possible scenarios:
+      // - no task or scope: `hh `
+      // - only a task: `hh task `
+      // - only a scope: `hh scope `
+      // - both a scope and a task (the task always follow the scope): `hh scope task `
+      // Between a scope and a task there could be other words, e.g.: `hh scope --flag task `
+      if (scopeName === undefined) {
+        if (tasks[word] !== undefined) {
+          taskName = word;
+          break;
+        } else if (scopes[word] !== undefined) {
+          scopeName = word;
+        }
+      } else {
+        taskName = word;
+        break;
+      }
+
+      index += 1;
     }
   }
 
-  // if a task was found but it's equal to the last word, it means
-  // that the cursor is after the task, we ignore the task in this
-  // case because if you have a task `foo` and `foobar` and the
-  // line is: `hh foo|`, we want tasks to be suggested
-  if (task === last) {
-    task = undefined;
+  // If a task or a scope is found and it is equal to the last word,
+  // this indicates that the cursor is positioned after the task or scope.
+  // In this case, we ignore the task or scope. For instance, if you have a task or a scope named 'foo' and 'foobar',
+  // and the line is 'hh foo|', we want to suggest the value for 'foo' and 'foobar'.
+  // Possible scenarios:
+  // - no task or scope: `hh ` -> task and scope already undefined
+  // - only a task: `hh task ` -> task set to undefined, scope already undefined
+  // - only a scope: `hh scope ` -> scope set to undefined, task already undefined
+  // - both a scope and a task (the task always follow the scope): `hh scope task ` -> task set to undefined, scope stays defined
+  if (taskName === last || scopeName === last) {
+    if (taskName !== undefined && scopeName !== undefined) {
+      [taskName, scopeName] = [undefined, scopeName];
+    } else {
+      [taskName, scopeName] = [undefined, undefined];
+    }
   }
 
   if (prev === "--network") {
@@ -114,6 +155,16 @@ export async function complete({
     }));
   }
 
+  const scopeDefinition =
+    scopeName === undefined ? undefined : scopes[scopeName];
+
+  const taskDefinition =
+    taskName === undefined
+      ? undefined
+      : scopeDefinition === undefined
+      ? tasks[taskName]
+      : scopeDefinition.tasks[taskName];
+
   // if the previous word is a param, then a value is expected
   // we don't complete anything here
   if (prev.startsWith("-")) {
@@ -125,39 +176,60 @@ export async function complete({
     }
 
     const isTaskParam =
-      task !== undefined &&
-      tasks[task]?.paramDefinitions[paramName]?.isFlag === false;
+      taskDefinition?.paramDefinitions[paramName]?.isFlag === false;
 
     if (isTaskParam) {
       return HARDHAT_COMPLETE_FILES;
     }
   }
 
-  // if there's no task, we complete either tasks or params
-  if (task === undefined || tasks[task] === undefined) {
+  // If there's no task or scope, we complete either tasks and scopes or params
+  if (taskDefinition === undefined && scopeDefinition === undefined) {
+    if (last.startsWith("-")) {
+      return coreParams.filter((param) => startsWithLast(param.name));
+    }
+
     const taskSuggestions = Object.values(tasks)
       .filter((x) => !x.isSubtask)
       .map((x) => ({
         name: x.name,
         description: x.description,
       }));
-    if (last.startsWith("-")) {
-      return coreParams.filter((param) => startsWithLast(param.name));
-    }
-    return taskSuggestions.filter((x) => startsWithLast(x.name));
+
+    const scopeSuggestions = Object.values(scopes).map((x) => ({
+      name: x.name,
+      description: x.description,
+    }));
+
+    return taskSuggestions
+      .concat(scopeSuggestions)
+      .filter((x) => startsWithLast(x.name));
+  }
+
+  // If there's a scope but not a task, we complete with the scopes'tasks
+  if (taskDefinition === undefined && scopeDefinition !== undefined) {
+    return Object.values(scopes[scopeName!].tasks)
+      .filter((x) => !x.isSubtask)
+      .map((x) => ({
+        name: x.name,
+        description: x.description,
+      }))
+      .filter((x) => startsWithLast(x.name));
   }
 
   if (!last.startsWith("-")) {
     return HARDHAT_COMPLETE_FILES;
   }
 
-  // if there's a task and the last word starts with -, we complete its params and the global params
-  const taskParams = Object.values(tasks[task].paramDefinitions)
-    .map((param) => ({
-      name: ArgumentsParser.paramNameToCLA(param.name),
-      description: param.description,
-    }))
-    .filter((x) => !words.includes(x.name));
+  const taskParams =
+    taskDefinition === undefined
+      ? []
+      : Object.values(taskDefinition.paramDefinitions)
+          .map((param) => ({
+            name: ArgumentsParser.paramNameToCLA(param.name),
+            description: param.description,
+          }))
+          .filter((x) => !words.includes(x.name));
 
   return [...taskParams, ...coreParams].filter((suggestion) =>
     startsWithLast(suggestion.name)
@@ -195,20 +267,20 @@ async function getCompletionData(): Promise<CompletionData | undefined> {
 
   // we extract the tasks data explicitly to make sure everything
   // is serializable and to avoid saving unnecessary things from the HRE
-  const tasks: CompletionData["tasks"] = mapValues(hre.tasks, (task) => ({
-    name: task.name,
-    description: task.description ?? "",
-    isSubtask: task.isSubtask,
-    paramDefinitions: mapValues(task.paramDefinitions, (paramDefinition) => ({
-      name: paramDefinition.name,
-      description: paramDefinition.description ?? "",
-      isFlag: paramDefinition.isFlag,
-    })),
+  const tasks: CompletionData["tasks"] = mapValues(hre.tasks, (task) =>
+    getTaskFromTaskDefinition(task)
+  );
+
+  const scopes: CompletionData["scopes"] = mapValues(hre.scopes, (scope) => ({
+    name: scope.name,
+    description: scope.description ?? "",
+    tasks: mapValues(scope.tasks, (task) => getTaskFromTaskDefinition(task)),
   }));
 
   const completionData: CompletionData = {
     networks,
     tasks,
+    scopes,
   };
 
   await saveCachedCompletionData(projectId, completionData, mtimes);
@@ -216,6 +288,22 @@ async function getCompletionData(): Promise<CompletionData | undefined> {
   return completionData;
 }
 
+function getTaskFromTaskDefinition(taskDef: TaskDefinition): Task {
+  return {
+    name: taskDef.name,
+    description: taskDef.description ?? "",
+    isSubtask: taskDef.isSubtask,
+    paramDefinitions: mapValues(
+      taskDef.paramDefinitions,
+      (paramDefinition) => ({
+        name: paramDefinition.name,
+        description: paramDefinition.description ?? "",
+        isFlag: paramDefinition.isFlag,
+      })
+    ),
+  };
+}
+
 function getProjectId(): string | undefined {
   const packageJsonPath = findup.sync("package.json");
 

package/src/internal/cli/project-creation.ts

@@ -45,17 +45,17 @@ const HARDHAT_PACKAGE_NAME = "hardhat";
 const PROJECT_DEPENDENCIES: Dependencies = {};
 
 const ETHERS_PROJECT_DEPENDENCIES: Dependencies = {
-  "@nomicfoundation/hardhat-toolbox": "^3.0.0",
+  "@nomicfoundation/hardhat-toolbox": "^4.0.0",
 };
 
 const VIEM_PROJECT_DEPENDENCIES: Dependencies = {
-  "@nomicfoundation/hardhat-toolbox-viem": "^1.0.0",
+  "@nomicfoundation/hardhat-toolbox-viem": "^2.0.0",
 };
 
 const PEER_DEPENDENCIES: Dependencies = {
   hardhat: "^2.14.0",
   "@nomicfoundation/hardhat-network-helpers": "^1.0.0",
-  "@nomicfoundation/hardhat-verify": "^1.0.0",
+  "@nomicfoundation/hardhat-verify": "^2.0.0",
   chai: "^4.2.0",
   "hardhat-gas-reporter": "^1.0.8",
   "solidity-coverage": "^0.8.0",
@@ -65,9 +65,9 @@ const ETHERS_PEER_DEPENDENCIES: Dependencies = {
   "@nomicfoundation/hardhat-chai-matchers": "^2.0.0",
   "@nomicfoundation/hardhat-ethers": "^3.0.0",
   ethers: "^6.4.0",
-  "@typechain/hardhat": "^8.0.0",
-  typechain: "^8.1.0",
-  "@typechain/ethers-v6": "^0.4.0",
+  "@typechain/hardhat": "^9.0.0",
+  typechain: "^8.3.0",
+  "@typechain/ethers-v6": "^0.5.0",
 };
 
 const VIEM_PEER_DEPENDENCIES: Dependencies = {

package/src/internal/core/config/config-loading.ts

@@ -218,7 +218,10 @@ export function analyzeModuleNotFoundError(error: any, configPath: string) {
 
   const missingPeerDependencies: { [name: string]: string } = {};
   for (const [peerDependency, version] of Object.entries(peerDependencies)) {
-    const peerDependencyPackageJson = readPackageJson(peerDependency);
+    const peerDependencyPackageJson = readPackageJson(
+      peerDependency,
+      configPath
+    );
     if (peerDependencyPackageJson === undefined) {
       missingPeerDependencies[peerDependency] = version;
     }
@@ -244,10 +247,18 @@ interface PackageJson {
   };
 }
 
-function readPackageJson(packageName: string): PackageJson | undefined {
+function readPackageJson(
+  packageName: string,
+  configPath: string
+): PackageJson | undefined {
+  const resolve = require("resolve") as typeof import("resolve");
+
   try {
-    const packageJsonPath = require.resolve(
-      path.join(packageName, "package.json")
+    const packageJsonPath = resolve.sync(
+      path.join(packageName, "package.json"),
+      {
+        basedir: path.dirname(configPath),
+      }
     );
 
     return require(packageJsonPath);

package/src/internal/core/project-structure.ts

@@ -10,10 +10,12 @@ import { ERRORS } from "./errors-list";
 const JS_CONFIG_FILENAME = "hardhat.config.js";
 const CJS_CONFIG_FILENAME = "hardhat.config.cjs";
 const TS_CONFIG_FILENAME = "hardhat.config.ts";
+const CTS_CONFIG_FILENAME = "hardhat.config.cts";
 
 export function isCwdInsideProject() {
   return (
     findUp.sync(TS_CONFIG_FILENAME) !== null ||
+    findUp.sync(CTS_CONFIG_FILENAME) !== null ||
     findUp.sync(CJS_CONFIG_FILENAME) !== null ||
     findUp.sync(JS_CONFIG_FILENAME) !== null
   );
@@ -25,6 +27,11 @@ export function getUserConfigPath() {
     return tsConfigPath;
   }
 
+  const ctsConfigPath = findUp.sync(CTS_CONFIG_FILENAME);
+  if (ctsConfigPath !== null) {
+    return ctsConfigPath;
+  }
+
   const cjsConfigPath = findUp.sync(CJS_CONFIG_FILENAME);
   if (cjsConfigPath !== null) {
     return cjsConfigPath;

package/src/internal/core/providers/gas-providers.ts

@@ -254,6 +254,25 @@ export class AutomaticGasPriceProvider extends ProviderWrapper {
         ],
       })) as { baseFeePerGas: string[]; reward: string[][] };
 
+      let maxPriorityFeePerGas = rpcQuantityToBigInt(response.reward[0][0]);
+
+      if (maxPriorityFeePerGas === 0n) {
+        try {
+          const suggestedMaxPriorityFeePerGas =
+            (await this._wrappedProvider.request({
+              method: "eth_maxPriorityFeePerGas",
+              params: [],
+            })) as string;
+
+          maxPriorityFeePerGas = rpcQuantityToBigInt(
+            suggestedMaxPriorityFeePerGas
+          );
+        } catch {
+          // if eth_maxPriorityFeePerGas does not exist, use 1 wei
+          maxPriorityFeePerGas = 1n;
+        }
+      }
+
       return {
         // Each block increases the base fee by 1/8 at most, when full.
         // We have the next block's base fee, so we compute a cap for the
@@ -268,7 +287,7 @@ export class AutomaticGasPriceProvider extends ProviderWrapper {
             (AutomaticGasPriceProvider.EIP1559_BASE_FEE_MAX_FULL_BLOCKS_PREFERENCE -
               1n),
 
-        maxPriorityFeePerGas: rpcQuantityToBigInt(response.reward[0][0]),
+        maxPriorityFeePerGas,
       };
     } catch {
       this._nodeHasFeeHistory = false;

package/src/internal/core/typescript-support.ts

@@ -13,14 +13,14 @@ let cachedIsTypescriptSupported: boolean | undefined;
  */
 export function willRunWithTypescript(configPath?: string): boolean {
   const config = resolveConfigPath(configPath);
-  return isTypescriptFile(config);
+  return isNonEsmTypescriptFile(config);
 }
 
 /**
  * Returns true if an Hardhat is already running with typescript.
  */
 export function isRunningWithTypescript(config: HardhatConfig): boolean {
-  return isTypescriptFile(config.paths.configFile);
+  return isNonEsmTypescriptFile(config.paths.configFile);
 }
 
 export function isTypescriptSupported() {
@@ -80,6 +80,14 @@ export function loadTsNode(
   require(tsNodeRequirement);
 }
 
-function isTypescriptFile(path: string): boolean {
-  return path.endsWith(".ts");
+function isNonEsmTypescriptFile(path: string): boolean {
+  return /\.(ts|cts)$/i.test(path);
+}
+
+export function isTypescriptFile(path: string): boolean {
+  return /\.(ts|cts|mts)$/i.test(path);
+}
+
+export function isJavascriptFile(path: string): boolean {
+  return /\.(js|cjs|mjs)$/i.test(path);
 }

package/src/internal/solidity/compiler/downloader.ts

@@ -60,7 +60,11 @@ export interface ICompilerDownloader {
    * Downloads the compiler for a given version, which can later be obtained
    * with getCompiler.
    */
-  downloadCompiler(version: string): Promise<void>;
+  downloadCompiler(
+    version: string,
+    downloadStartedCb: (isCompilerDownloaded: boolean) => Promise<any>,
+    downloadEndedCb: (isCompilerDownloaded: boolean) => Promise<any>
+  ): Promise<void>;
 
   /**
    * Returns the compiler, which MUST be downloaded before calling this function.
@@ -146,8 +150,24 @@ export class CompilerDownloader implements ICompilerDownloader {
     return fsExtra.pathExists(downloadPath);
   }
 
-  public async downloadCompiler(version: string): Promise<void> {
+  public async downloadCompiler(
+    version: string,
+    downloadStartedCb: (isCompilerDownloaded: boolean) => Promise<any>,
+    downloadEndedCb: (isCompilerDownloaded: boolean) => Promise<any>
+  ): Promise<void> {
+    // Since only one process at a time can acquire the mutex, we avoid the risk of downloading the same compiler multiple times.
+    // This is because the mutex blocks access until a compiler has been fully downloaded, preventing any new process
+    // from checking whether that version of the compiler exists. Without mutex it might incorrectly
+    // return false, indicating that the compiler isn't present, even though it is currently being downloaded.
     await this._mutex.use(async () => {
+      const isCompilerDownloaded = await this.isCompilerDownloaded(version);
+
+      if (isCompilerDownloaded === true) {
+        return;
+      }
+
+      await downloadStartedCb(isCompilerDownloaded);
+
       let build = await this._getCompilerBuild(version);
 
       if (build === undefined && (await this._shouldDownloadCompilerList())) {
@@ -189,6 +209,8 @@ export class CompilerDownloader implements ICompilerDownloader {
       }
 
       await this._postProcessCompilerDownload(build, downloadPath);
+
+      await downloadEndedCb(isCompilerDownloaded);
     });
   }