hardhatjs 2.22.15

package/src/builtin-tasks/test.ts

@@ -0,0 +1,223 @@
+import type { MochaOptions } from "mocha";
+
+import chalk from "chalk";
+import path from "path";
+
+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 {
+  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";
+import { getAllFilesMatching } from "../internal/util/fs-utils";
+import { getProjectPackageJson } from "../internal/util/packageInfo";
+
+import {
+  TASK_COMPILE,
+  TASK_TEST,
+  TASK_TEST_GET_TEST_FILES,
+  TASK_TEST_RUN_MOCHA_TESTS,
+  TASK_TEST_RUN_SHOW_FORK_RECOMMENDATIONS,
+  TASK_TEST_SETUP_TEST_ENVIRONMENT,
+} from "./task-names";
+
+subtask(TASK_TEST_GET_TEST_FILES)
+  .addOptionalVariadicPositionalParam(
+    "testFiles",
+    "An optional list of files to test",
+    []
+  )
+  .setAction(async ({ testFiles }: { testFiles: string[] }, { config }) => {
+    if (testFiles.length !== 0) {
+      const testFilesAbsolutePaths = testFiles.map((x) =>
+        path.resolve(process.cwd(), x)
+      );
+
+      return testFilesAbsolutePaths;
+    }
+
+    const jsFiles = await getAllFilesMatching(
+      config.paths.tests,
+      isJavascriptFile
+    );
+
+    if (!isRunningWithTypescript(config)) {
+      return jsFiles;
+    }
+
+    const tsFiles = await getAllFilesMatching(
+      config.paths.tests,
+      isTypescriptFile
+    );
+
+    return [...jsFiles, ...tsFiles];
+  });
+
+subtask(TASK_TEST_SETUP_TEST_ENVIRONMENT, async () => {});
+
+let testsAlreadyRun = false;
+subtask(TASK_TEST_RUN_MOCHA_TESTS)
+  .addFlag("parallel", "Run tests in parallel")
+  .addFlag("bail", "Stop running tests after the first test failure")
+  .addOptionalParam(
+    "grep",
+    "Only run tests matching the given string or regexp"
+  )
+  .addOptionalVariadicPositionalParam(
+    "testFiles",
+    "An optional list of files to test",
+    []
+  )
+  .setAction(
+    async (
+      taskArgs: {
+        bail: boolean;
+        parallel: boolean;
+        testFiles: string[];
+        grep?: string;
+      },
+      { config }
+    ) => {
+      const { default: Mocha } = await import("mocha");
+
+      const mochaConfig: MochaOptions = { ...config.mocha };
+
+      if (taskArgs.grep !== undefined) {
+        mochaConfig.grep = taskArgs.grep;
+      }
+      if (taskArgs.bail) {
+        mochaConfig.bail = true;
+      }
+      if (taskArgs.parallel) {
+        mochaConfig.parallel = true;
+      }
+
+      if (mochaConfig.parallel === true) {
+        const mochaRequire = mochaConfig.require ?? [];
+        if (!mochaRequire.includes("hardhat/register")) {
+          mochaRequire.push("hardhat/register");
+        }
+        mochaConfig.require = mochaRequire;
+      }
+
+      const mocha = new Mocha(mochaConfig);
+      taskArgs.testFiles.forEach((file) => mocha.addFile(file));
+
+      // if the project is of type "module" or if there's some ESM test file,
+      // we call loadFilesAsync to enable Mocha's ESM support
+      const projectPackageJson = await getProjectPackageJson();
+      const isTypeModule = projectPackageJson.type === "module";
+      const hasEsmTest = taskArgs.testFiles.some((file) =>
+        file.endsWith(".mjs")
+      );
+      if (isTypeModule || hasEsmTest) {
+        // Because of the way the ESM cache works, loadFilesAsync doesn't work
+        // correctly if used twice within the same process, so we throw an error
+        // in that case
+        if (testsAlreadyRun) {
+          throw new HardhatError(
+            ERRORS.BUILTIN_TASKS.TEST_TASK_ESM_TESTS_RUN_TWICE
+          );
+        }
+        testsAlreadyRun = true;
+
+        // This instructs Mocha to use the more verbose file loading infrastructure
+        // which supports both ESM and CJS
+        await mocha.loadFilesAsync();
+      }
+
+      const testFailures = await new Promise<number>((resolve) => {
+        mocha.run(resolve);
+      });
+
+      mocha.dispose();
+
+      return testFailures;
+    }
+  );
+
+subtask(TASK_TEST_RUN_SHOW_FORK_RECOMMENDATIONS).setAction(
+  async (_, { config, network }) => {
+    if (network.name !== HARDHAT_NETWORK_NAME) {
+      return;
+    }
+
+    const forkCache = getForkCacheDirPath(config.paths);
+    await showForkRecommendationsBannerIfNecessary(network.config, forkCache);
+  }
+);
+
+task(TASK_TEST, "Runs mocha tests")
+  .addOptionalVariadicPositionalParam(
+    "testFiles",
+    "An optional list of files to test",
+    []
+  )
+  .addFlag("noCompile", "Don't compile before running this task")
+  .addFlag("parallel", "Run tests in parallel")
+  .addFlag("bail", "Stop running tests after the first test failure")
+  .addOptionalParam(
+    "grep",
+    "Only run tests matching the given string or regexp"
+  )
+  .setAction(
+    async (
+      {
+        testFiles,
+        noCompile,
+        parallel,
+        bail,
+        grep,
+      }: {
+        testFiles: string[];
+        noCompile: boolean;
+        parallel: boolean;
+        bail: boolean;
+        grep?: string;
+      },
+      { run, network }
+    ) => {
+      if (!noCompile) {
+        await run(TASK_COMPILE, { quiet: true });
+      }
+
+      const files = await run(TASK_TEST_GET_TEST_FILES, { testFiles });
+
+      await run(TASK_TEST_SETUP_TEST_ENVIRONMENT);
+
+      await run(TASK_TEST_RUN_SHOW_FORK_RECOMMENDATIONS);
+
+      const testFailures = await run(TASK_TEST_RUN_MOCHA_TESTS, {
+        testFiles: files,
+        parallel,
+        bail,
+        grep,
+      });
+
+      if (network.name === HARDHAT_NETWORK_NAME) {
+        const stackTracesFailures = await network.provider.send(
+          "hardhat_getStackTraceFailuresCount"
+        );
+
+        if (stackTracesFailures !== 0) {
+          console.warn(
+            chalk.yellow(
+              `Failed to generate ${stackTracesFailures} ${pluralize(
+                stackTracesFailures,
+                "stack trace"
+              )}. Run Hardhat with --verbose to learn more.`
+            )
+          );
+        }
+      }
+
+      process.exitCode = testFailures;
+      return testFailures;
+    }
+  );

package/src/builtin-tasks/utils/solidity-files-cache.ts

@@ -0,0 +1,145 @@
+import type { LoDashStatic } from "lodash";
+import type { ProjectPathsConfig, SolcConfig } from "../../types";
+
+import debug from "debug";
+import fsExtra from "fs-extra";
+import * as t from "io-ts";
+import * as path from "path";
+
+import { SOLIDITY_FILES_CACHE_FILENAME } from "../../internal/constants";
+
+const log = debug("hardhat:core:tasks:compile:cache");
+
+const FORMAT_VERSION = "hh-sol-cache-2";
+
+const CacheEntryCodec = t.type({
+  lastModificationDate: t.number,
+  contentHash: t.string,
+  sourceName: t.string,
+  solcConfig: t.any,
+  imports: t.array(t.string),
+  versionPragmas: t.array(t.string),
+  artifacts: t.array(t.string),
+});
+
+const CacheCodec = t.type({
+  _format: t.string,
+  files: t.record(t.string, CacheEntryCodec),
+});
+
+export interface CacheEntry {
+  lastModificationDate: number;
+  contentHash: string;
+  sourceName: string;
+  solcConfig: SolcConfig;
+  imports: string[];
+  versionPragmas: string[];
+  artifacts: string[];
+}
+
+export interface Cache {
+  _format: string;
+  files: Record<string, CacheEntry>;
+}
+
+export class SolidityFilesCache {
+  public static createEmpty(): SolidityFilesCache {
+    return new SolidityFilesCache({
+      _format: FORMAT_VERSION,
+      files: {},
+    });
+  }
+
+  public static async readFromFile(
+    solidityFilesCachePath: string
+  ): Promise<SolidityFilesCache> {
+    let cacheRaw: Cache = {
+      _format: FORMAT_VERSION,
+      files: {},
+    };
+    if (await fsExtra.pathExists(solidityFilesCachePath)) {
+      cacheRaw = await fsExtra.readJson(solidityFilesCachePath);
+    }
+
+    const result = CacheCodec.decode(cacheRaw);
+
+    if (result.isRight()) {
+      const solidityFilesCache = new SolidityFilesCache(result.value);
+      await solidityFilesCache.removeNonExistingFiles();
+      return solidityFilesCache;
+    }
+
+    log("There was a problem reading the cache");
+
+    return new SolidityFilesCache({
+      _format: FORMAT_VERSION,
+      files: {},
+    });
+  }
+
+  constructor(private _cache: Cache) {}
+
+  public async removeNonExistingFiles() {
+    await Promise.all(
+      Object.keys(this._cache.files).map(async (absolutePath) => {
+        if (!(await fsExtra.pathExists(absolutePath))) {
+          this.removeEntry(absolutePath);
+        }
+      })
+    );
+  }
+
+  public async writeToFile(solidityFilesCachePath: string) {
+    await fsExtra.outputJson(solidityFilesCachePath, this._cache, {
+      spaces: 2,
+    });
+  }
+
+  public addFile(absolutePath: string, entry: CacheEntry) {
+    this._cache.files[absolutePath] = entry;
+  }
+
+  public getEntries(): CacheEntry[] {
+    return Object.values(this._cache.files);
+  }
+
+  public getEntry(file: string): CacheEntry | undefined {
+    return this._cache.files[file];
+  }
+
+  public removeEntry(file: string) {
+    delete this._cache.files[file];
+  }
+
+  public hasFileChanged(
+    absolutePath: string,
+    contentHash: string,
+    solcConfig?: SolcConfig
+  ): boolean {
+    const isEqual = require("lodash/isEqual") as LoDashStatic["isEqual"];
+
+    const cacheEntry = this.getEntry(absolutePath);
+
+    if (cacheEntry === undefined) {
+      // new file or no cache available, assume it's new
+      return true;
+    }
+
+    if (cacheEntry.contentHash !== contentHash) {
+      return true;
+    }
+
+    if (
+      solcConfig !== undefined &&
+      !isEqual(solcConfig, cacheEntry.solcConfig)
+    ) {
+      return true;
+    }
+
+    return false;
+  }
+}
+
+export function getSolidityFilesCachePath(paths: ProjectPathsConfig): string {
+  return path.join(paths.cache, SOLIDITY_FILES_CACHE_FILENAME);
+}

package/src/builtin-tasks/utils/watch.ts

@@ -0,0 +1,64 @@
+import chalk from "chalk";
+import { FSWatcher } from "chokidar";
+import debug from "debug";
+import fsExtra from "fs-extra";
+import * as path from "path";
+
+import { BUILD_INFO_DIR_NAME } from "../../internal/constants";
+import { Reporter } from "../../internal/sentry/reporter";
+import { EIP1193Provider, ProjectPathsConfig } from "../../types";
+
+const log = debug("hardhat:core:compilation-watcher");
+
+export type Watcher = FSWatcher;
+
+export async function watchCompilerOutput(
+  provider: EIP1193Provider,
+  paths: ProjectPathsConfig
+): Promise<Watcher> {
+  const chokidar = await import("chokidar");
+
+  const buildInfoDir = path.join(paths.artifacts, BUILD_INFO_DIR_NAME);
+
+  const addCompilationResult = async (buildInfo: string) => {
+    try {
+      log("Adding new compilation result to the node");
+
+      const { input, output, solcVersion } = await fsExtra.readJSON(buildInfo, {
+        encoding: "utf8",
+      });
+
+      await provider.request({
+        method: "hardhat_addCompilationResult",
+        params: [solcVersion, input, output],
+      });
+    } catch (error) {
+      console.warn(
+        chalk.yellow(
+          "There was a problem adding the new compiler result. Run Hardhat with --verbose to learn more."
+        )
+      );
+
+      log(
+        "Last compilation result couldn't be added. Please report this to help us improve Hardhat.\n",
+        error
+      );
+
+      if (error instanceof Error) {
+        Reporter.reportError(error);
+      }
+    }
+  };
+
+  log(`Watching changes on '${buildInfoDir}'`);
+
+  return chokidar
+    .watch(buildInfoDir, {
+      ignoreInitial: true,
+      awaitWriteFinish: {
+        stabilityThreshold: 250,
+        pollInterval: 50,
+      },
+    })
+    .on("add", addCompilationResult);
+}

package/src/builtin-tasks/vars.ts

@@ -0,0 +1,54 @@
+import { HardhatError } from "../internal/core/errors";
+import { scope } from "../internal/core/config/config-env";
+import { ERRORS } from "../internal/core/errors-list";
+
+const varsScope = scope("vars", "Manage your configuration variables");
+
+varsScope
+  .task("set", "Set the value of a configuration variable")
+  .addPositionalParam("var", "The name of the variable")
+  .addOptionalPositionalParam(
+    "value",
+    "The value to store. Omit to be prompted for it."
+  )
+  .setAction(async () => {
+    throw new HardhatError(ERRORS.VARS.ONLY_MANAGED_IN_CLI);
+  });
+
+varsScope
+  .task("get", "Get the value of a configuration variable")
+  .addPositionalParam("var", "The name of the variable")
+  .setAction(async () => {
+    throw new HardhatError(ERRORS.VARS.ONLY_MANAGED_IN_CLI);
+  });
+
+varsScope
+  .task("list", "List all the configuration variables")
+  .setAction(async () => {
+    throw new HardhatError(ERRORS.VARS.ONLY_MANAGED_IN_CLI);
+  });
+
+varsScope
+  .task("delete", "Delete a configuration variable")
+  .addPositionalParam("var", "The name of the variable")
+  .setAction(async () => {
+    throw new HardhatError(ERRORS.VARS.ONLY_MANAGED_IN_CLI);
+  });
+
+varsScope
+  .task(
+    "path",
+    "Show the path of the file where all the configuration variables are stored"
+  )
+  .setAction(async () => {
+    throw new HardhatError(ERRORS.VARS.ONLY_MANAGED_IN_CLI);
+  });
+
+varsScope
+  .task(
+    "setup",
+    "Show how to setup the configuration variables used by this project"
+  )
+  .setAction(async () => {
+    throw new HardhatError(ERRORS.VARS.ONLY_MANAGED_IN_CLI);
+  });

package/src/common/bigInt.ts

@@ -0,0 +1,106 @@
+import type { BigNumber as EthersBigNumberType } from "ethers-v5";
+// eslint-disable-next-line import/no-extraneous-dependencies
+import type { BigNumber as BigNumberJsType } from "bignumber.js";
+// eslint-disable-next-line import/no-extraneous-dependencies
+import type { default as BNType } from "bn.js";
+
+import { HardhatError } from "../internal/core/errors";
+import { ERRORS } from "../internal/core/errors-list";
+
+export function normalizeToBigInt(
+  source:
+    | number
+    | bigint
+    | BNType
+    | EthersBigNumberType
+    | BigNumberJsType
+    | string
+): bigint {
+  switch (typeof source) {
+    case "object":
+      if (isBigNumber(source)) {
+        return BigInt(source.toString());
+      } else {
+        throw new HardhatError(ERRORS.GENERAL.INVALID_BIG_NUMBER, {
+          message: `Value ${JSON.stringify(
+            source
+          )} is of type "object" but is not an instanceof one of the known big number object types.`,
+        });
+      }
+    case "number":
+      if (!Number.isInteger(source)) {
+        throw new HardhatError(ERRORS.GENERAL.INVALID_BIG_NUMBER, {
+          message: `${source} is not an integer`,
+        });
+      }
+      if (!Number.isSafeInteger(source)) {
+        throw new HardhatError(ERRORS.GENERAL.INVALID_BIG_NUMBER, {
+          message: `Integer ${source} is unsafe. Consider using ${source}n instead. For more details, see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isSafeInteger`,
+        });
+      }
+    // `break;` intentionally omitted. fallthrough desired.
+    case "string":
+    case "bigint":
+      return BigInt(source);
+    default:
+      const _exhaustiveCheck: never = source;
+      throw new HardhatError(ERRORS.GENERAL.INVALID_BIG_NUMBER, {
+        message: `Unsupported type ${typeof source}`,
+      });
+  }
+}
+
+export function isBigNumber(source: any): boolean {
+  return (
+    typeof source === "bigint" ||
+    isEthersBigNumber(source) ||
+    isBN(source) ||
+    isBigNumberJsBigNumber(source)
+  );
+}
+
+function isBN(n: any) {
+  try {
+    // eslint-disable-next-line import/no-extraneous-dependencies
+    const BN: typeof BNType = require("bn.js");
+    return BN.isBN(n);
+  } catch (e) {
+    return false;
+  }
+}
+
+function isEthersBigNumber(n: any) {
+  try {
+    const BigNumber: typeof EthersBigNumberType =
+      // eslint-disable-next-line import/no-extraneous-dependencies
+      require("ethers").ethers.BigNumber;
+    return BigNumber.isBigNumber(n);
+  } catch (e) {
+    return false;
+  }
+}
+
+function isBigNumberJsBigNumber(n: any) {
+  try {
+    // eslint-disable-next-line import/no-extraneous-dependencies
+    const BigNumber: typeof BigNumberJsType = require("bignumber.js").BigNumber;
+    return BigNumber.isBigNumber(n);
+  } catch (e) {
+    return false;
+  }
+}
+
+export function formatNumberType(
+  n: string | bigint | BNType | EthersBigNumberType | BigNumberJsType
+): string {
+  if (typeof n === "object") {
+    if (isBN(n)) {
+      return "BN";
+    } else if (isEthersBigNumber(n)) {
+      return "ethers.BigNumber";
+    } else if (isBigNumberJsBigNumber(n)) {
+      return "bignumber.js";
+    }
+  }
+  return typeof n;
+}

package/src/common/index.ts

@@ -0,0 +1,2 @@
+export * from "./bigInt";
+export { CustomError } from "../internal/core/errors";

package/src/common/napi-rs.ts

@@ -0,0 +1,15 @@
+import { HardhatError } from "../internal/core/errors";
+import { ERRORS } from "../internal/core/errors-list";
+
+export function requireNapiRsModule(id: string): unknown {
+  try {
+    return require(id);
+  } catch (e: any) {
+    if (e.code === "MODULE_NOT_FOUND") {
+      throw new HardhatError(ERRORS.GENERAL.CORRUPTED_LOCKFILE);
+    }
+
+    // eslint-disable-next-line @nomicfoundation/hardhat-internal-rules/only-hardhat-error
+    throw e;
+  }
+}

package/src/config.ts

@@ -0,0 +1,2 @@
+export * from "./internal/core/config/config-env";
+export { HardhatUserConfig } from "./types";