hardhat 2.11.0-dev.0 → 2.11.0

package/src/internal/solidity/parse.ts

@@ -1,9 +1,7 @@
-import debug from "debug";
+import type SolidityAnalyzerT from "@nomicfoundation/solidity-analyzer";
 
 import { SolidityFilesCache } from "../../builtin-tasks/utils/solidity-files-cache";
 
-const log = debug("hardhat:core:solidity:imports");
-
 interface ParsedData {
   imports: string[];
   versionPragmas: string[];
@@ -29,34 +27,9 @@ export class Parser {
       return cacheResult;
     }
 
-    let result;
-    try {
-      const parser = require("@solidity-parser/parser");
-      const ast = parser.parse(fileContent, { tolerant: true });
-
-      const imports: string[] = [];
-      const versionPragmas: string[] = [];
-
-      parser.visit(ast, {
-        ImportDirective: (node: { path: string }) => imports.push(node.path),
-        PragmaDirective: (node: { name: string; value: string }) => {
-          if (node.name === "solidity") {
-            versionPragmas.push(node.value);
-          }
-        },
-      });
-
-      result = { imports, versionPragmas };
-    } catch (error) {
-      log(
-        "Failed to parse Solidity file to extract its imports, using regex fallback\n",
-        error
-      );
-      result = {
-        imports: findImportsWithRegexps(fileContent),
-        versionPragmas: findVersionPragmasWithRegexps(fileContent),
-      };
-    }
+    const { analyze } =
+      require("@nomicfoundation/solidity-analyzer") as typeof SolidityAnalyzerT;
+    const result = analyze(fileContent);
 
     this._cache.set(contentHash, result);
 
@@ -94,42 +67,3 @@ export class Parser {
     return { imports, versionPragmas };
   }
 }
-
-function findImportsWithRegexps(fileContent: string): string[] {
-  const importsRegexp: RegExp =
-    /import\s+(?:(?:"([^;]*)"|'([^;]*)')(?:;|\s+as\s+[^;]*;)|.+from\s+(?:"(.*)"|'(.*)');)/g;
-
-  let imports: string[] = [];
-  let result: RegExpExecArray | null;
-
-  while (true) {
-    result = importsRegexp.exec(fileContent);
-    if (result === null) {
-      return imports;
-    }
-
-    imports = [
-      ...imports,
-      ...result.slice(1).filter((m: any) => m !== undefined),
-    ];
-  }
-}
-
-function findVersionPragmasWithRegexps(fileContent: string): string[] {
-  const versionPragmasRegexp: RegExp = /pragma\s+solidity\s+(.+?);/g;
-
-  let versionPragmas: string[] = [];
-  let result: RegExpExecArray | null;
-
-  while (true) {
-    result = versionPragmasRegexp.exec(fileContent);
-    if (result === null) {
-      return versionPragmas;
-    }
-
-    versionPragmas = [
-      ...versionPragmas,
-      ...result.slice(1).filter((m: any) => m !== undefined),
-    ];
-  }
-}

package/src/internal/solidity/resolver.ts

@@ -19,6 +19,7 @@ import { assertHardhatInvariant, HardhatError } from "../core/errors";
 import { ERRORS } from "../core/errors-list";
 import { createNonCryptographicHashBasedIdentifier } from "../util/hash";
 
+import { getRealPath } from "../util/fs-utils";
 import { Parser } from "./parse";
 
 export interface ResolvedFilesMap {
@@ -62,6 +63,8 @@ export class ResolvedFile implements IResolvedFile {
 }
 
 export class Resolver {
+  private readonly _cache: Map<string, ResolvedFile> = new Map();
+
   constructor(
     private readonly _projectRoot: string,
     private readonly _parser: Parser,
@@ -74,13 +77,23 @@ export class Resolver {
    * @param sourceName The source name as it would be provided to solc.
    */
   public async resolveSourceName(sourceName: string): Promise<ResolvedFile> {
+    const cached = this._cache.get(sourceName);
+    if (cached !== undefined) {
+      return cached;
+    }
+
     validateSourceNameFormat(sourceName);
 
+    let resolvedFile: ResolvedFile;
+
     if (await isLocalSourceName(this._projectRoot, sourceName)) {
-      return this._resolveLocalSourceName(sourceName);
+      resolvedFile = await this._resolveLocalSourceName(sourceName);
+    } else {
+      resolvedFile = await this._resolveLibrarySourceName(sourceName);
     }
 
-    return this._resolveLibrarySourceName(sourceName);
+    this._cache.set(sourceName, resolvedFile);
+    return resolvedFile;
   }
 
   /**
@@ -116,23 +129,38 @@ export class Resolver {
     }
 
     try {
-      if (!this._isRelativeImport(imported)) {
-        return await this.resolveSourceName(normalizeSourceName(imported));
+      let sourceName: string;
+
+      const isRelativeImport = this._isRelativeImport(imported);
+
+      if (isRelativeImport) {
+        sourceName = await this._relativeImportToSourceName(from, imported);
+      } else {
+        sourceName = normalizeSourceName(imported);
       }
 
-      const sourceName = await this._relativeImportToSourceName(from, imported);
+      const cached = this._cache.get(sourceName);
+      if (cached !== undefined) {
+        return cached;
+      }
+
+      let resolvedFile: ResolvedFile;
 
       // We have this special case here, because otherwise local relative
       // imports can be treated as library imports. For example if
       // `contracts/c.sol` imports `../non-existent/a.sol`
       if (
         from.library === undefined &&
+        isRelativeImport &&
         !this._isRelativeImportToLibrary(from, imported)
       ) {
-        return await this._resolveLocalSourceName(sourceName);
+        resolvedFile = await this._resolveLocalSourceName(sourceName);
+      } else {
+        resolvedFile = await this.resolveSourceName(sourceName);
       }
 
-      return await this.resolveSourceName(sourceName);
+      this._cache.set(sourceName, resolvedFile);
+      return resolvedFile;
     } catch (error) {
       if (
         HardhatError.isHardhatErrorType(
@@ -252,7 +280,7 @@ export class Resolver {
     return this._resolveFile(
       sourceName,
       // We resolve to the real path here, as we may be resolving a linked library
-      await fsExtra.realpath(path.join(nodeModulesPath, sourceName)),
+      await getRealPath(path.join(nodeModulesPath, sourceName)),
       libraryName,
       libraryVersion
     );

package/src/internal/util/bigint.ts

@@ -1,23 +1,18 @@
-import {
-  BigIntLike,
-  bufferToBigInt,
-  bufferToHex,
-  toBuffer,
-} from "@ignored/util";
+import { assertHardhatInvariant } from "../core/errors";
 
-function min(x: bigint, y: bigint): bigint {
+export function min(x: bigint, y: bigint): bigint {
   return x < y ? x : y;
 }
 
-function max(x: bigint, y: bigint): bigint {
+export function max(x: bigint, y: bigint): bigint {
   return x > y ? x : y;
 }
 
-function isBigInt(x: unknown): x is bigint {
+export function isBigInt(x: unknown): x is bigint {
   return typeof x === "bigint";
 }
 
-function divUp(x: bigint, y: bigint): bigint {
+export function divUp(x: bigint, y: bigint): bigint {
   let result = x / y;
 
   if (x % y !== 0n) {
@@ -27,31 +22,26 @@ function divUp(x: bigint, y: bigint): bigint {
   return result;
 }
 
-function cmp(a: bigint, b: bigint): number {
+export function cmp(a: bigint, b: bigint): number {
   return a < b ? -1 : a > b ? 1 : 0;
 }
 
-function mapNumberToBigInt<T>(x: number | T): bigint | T {
-  if (typeof x === "number") {
-    return BigInt(x);
-  }
-
-  return x;
-}
-
-function mapBigIntToNumber<T>(x: bigint | T): number | T {
-  if (typeof x === "bigint") {
-    return Number(x);
-  }
-
-  return x;
+/**
+ * Converts the number to a hexadecimal string with a length of 32
+ * bytes. This hex string is NOT 0x-prefixed.
+ */
+export function toEvmWord(x: bigint | number): string {
+  return x.toString(16).padStart(64, "0");
 }
 
-function toWord(x: bigint | number): string {
-  return x.toString(16).padStart(64, "0");
+function bufferToBigInt(x: Buffer): bigint {
+  const hex = `0x${x.toString("hex")}`;
+  return hex === "0x" ? 0n : BigInt(hex);
 }
 
-function fromBigIntLike(x: BigIntLike | undefined): bigint | undefined {
+export function fromBigIntLike(
+  x: string | number | bigint | Buffer | undefined
+): bigint | undefined {
   if (x === undefined || typeof x === "bigint") {
     return x;
   }
@@ -66,19 +56,11 @@ function fromBigIntLike(x: BigIntLike | undefined): bigint | undefined {
   return exhaustiveCheck;
 }
 
-function toHex(x: number | bigint): string {
-  return bufferToHex(toBuffer(x));
-}
+export function toHex(x: number | bigint): string {
+  assertHardhatInvariant(
+    x >= 0,
+    `toHex can only be used with non-negative numbers, but received ${x}`
+  );
 
-export const BigIntUtils = {
-  min,
-  max,
-  isBigInt,
-  divUp,
-  cmp,
-  mapNumberToBigInt,
-  mapBigIntToNumber,
-  toWord,
-  fromBigIntLike,
-  toHex,
-};
+  return `0x${x.toString(16)}`;
+}

package/src/internal/util/download.ts

@@ -7,8 +7,6 @@ import { getHardhatVersion } from "./packageInfo";
 
 const TEMP_FILE_PREFIX = "tmp-";
 
-const hardhatVersion = getHardhatVersion();
-
 function resolveTempFileName(filePath: string): string {
   const { dir, ext, name } = path.parse(filePath);
 
@@ -40,6 +38,8 @@ export async function download(
     return getGlobalDispatcher();
   }
 
+  const hardhatVersion = getHardhatVersion();
+
   // Fetch the url
   const response = await request(url, {
     dispatcher: chooseDispatcher(),

package/src/internal/util/fs-utils.ts

@@ -0,0 +1,223 @@
+import fsPromises from "fs/promises";
+import fs from "fs";
+import path from "path";
+import { CustomError } from "../core/errors";
+
+// We use this error to encapsulate any other error possibly thrown by node's
+// fs apis, as sometimes their errors don't have stack traces.
+export class FileSystemAccessError extends CustomError {}
+
+export class FileNotFoundError extends CustomError {
+  constructor(filePath: string, parent?: Error) {
+    super(`File ${filePath} not found`, parent);
+  }
+}
+export class InvalidDirectoryError extends CustomError {
+  constructor(filePath: string, parent: Error) {
+    super(`Invalid directory ${filePath}`, parent);
+  }
+}
+
+/**
+ * Returns the real path of absolutePath, resolving symlinks.
+ *
+ * @throws FileNotFoundError if absolutePath doesn't exist.
+ */
+export async function getRealPath(absolutePath: string): Promise<string> {
+  try {
+    // This method returns the actual casing.
+    // Please read Node.js' docs to learn more.
+    return await fsPromises.realpath(path.normalize(absolutePath));
+  } catch (e: any) {
+    if (e.code === "ENOENT") {
+      // eslint-disable-next-line @nomiclabs/hardhat-internal-rules/only-hardhat-error
+      throw new FileNotFoundError(absolutePath, e);
+    }
+
+    // eslint-disable-next-line @nomiclabs/hardhat-internal-rules/only-hardhat-error
+    throw new FileSystemAccessError(e.message, e);
+  }
+}
+
+/**
+ * Sync version of getRealPath
+ *
+ * @see getRealCase
+ */
+export function getRealPathSync(absolutePath: string): string {
+  try {
+    // This method returns the actual casing.
+    // Please read Node.js' docs to learn more.
+    return fs.realpathSync.native(path.normalize(absolutePath));
+  } catch (e: any) {
+    if (e.code === "ENOENT") {
+      // eslint-disable-next-line @nomiclabs/hardhat-internal-rules/only-hardhat-error
+      throw new FileNotFoundError(absolutePath, e);
+    }
+
+    // eslint-disable-next-line @nomiclabs/hardhat-internal-rules/only-hardhat-error
+    throw new FileSystemAccessError(e.message, e);
+  }
+}
+
+/**
+ * Returns an array of files (not dirs) that match a condition.
+ *
+ * @param absolutePathToDir A directory. If it doesn't exist `[]` is returned.
+ * @param matches A function to filter files (not directories)
+ * @returns An An array of absolute paths. Each file has its true case, except
+ *  for the initial absolutePathToDir part, which preserves the given casing.
+ *  No order is guaranteed.
+ */
+export async function getAllFilesMatching(
+  absolutePathToDir: string,
+  matches?: (absolutePathToFile: string) => boolean
+): Promise<string[]> {
+  const dir = await readdir(absolutePathToDir);
+
+  const results = await Promise.all(
+    dir.map(async (file) => {
+      const absolutePathToFile = path.join(absolutePathToDir, file);
+      const stats = await fsPromises.stat(absolutePathToFile);
+      if (stats.isDirectory()) {
+        const files = await getAllFilesMatching(absolutePathToFile, matches);
+        return files.flat();
+      } else if (matches === undefined || matches(absolutePathToFile)) {
+        return absolutePathToFile;
+      } else {
+        return [];
+      }
+    })
+  );
+
+  return results.flat();
+}
+
+/**
+ * Sync version of getAllFilesMatching
+ *
+ * @see getAllFilesMatching
+ */
+export function getAllFilesMatchingSync(
+  absolutePathToDir: string,
+  matches?: (absolutePathToFile: string) => boolean
+): string[] {
+  const dir = readdirSync(absolutePathToDir);
+
+  const results = dir.map((file) => {
+    const absolutePathToFile = path.join(absolutePathToDir, file);
+    const stats = fs.statSync(absolutePathToFile);
+    if (stats.isDirectory()) {
+      return getAllFilesMatchingSync(absolutePathToFile, matches).flat();
+    } else if (matches === undefined || matches(absolutePathToFile)) {
+      return absolutePathToFile;
+    } else {
+      return [];
+    }
+  });
+
+  return results.flat();
+}
+
+/**
+ * Returns the true case relative path of `relativePath` from `from`, without
+ * resolving symlinks.
+ */
+export async function getFileTrueCase(
+  from: string,
+  relativePath: string
+): Promise<string> {
+  const dirEntries = await readdir(from);
+
+  const parts = relativePath.split(path.sep);
+  const nextDirLowerCase = parts[0].toLowerCase();
+
+  for (const dirEntry of dirEntries) {
+    if (dirEntry.toLowerCase() === nextDirLowerCase) {
+      if (parts.length === 1) {
+        return dirEntry;
+      }
+
+      return path.join(
+        dirEntry,
+        await getFileTrueCase(
+          path.join(from, dirEntry),
+          path.relative(parts[0], relativePath)
+        )
+      );
+    }
+  }
+
+  // eslint-disable-next-line @nomiclabs/hardhat-internal-rules/only-hardhat-error
+  throw new FileNotFoundError(path.join(from, relativePath));
+}
+
+/**
+ * Sync version of getFileTrueCase
+ *
+ * @see getFileTrueCase
+ */
+export function getFileTrueCaseSync(
+  from: string,
+  relativePath: string
+): string {
+  const dirEntries = readdirSync(from);
+
+  const parts = relativePath.split(path.sep);
+  const nextDirLowerCase = parts[0].toLowerCase();
+
+  for (const dirEntry of dirEntries) {
+    if (dirEntry.toLowerCase() === nextDirLowerCase) {
+      if (parts.length === 1) {
+        return dirEntry;
+      }
+
+      return path.join(
+        dirEntry,
+        getFileTrueCaseSync(
+          path.join(from, dirEntry),
+          path.relative(parts[0], relativePath)
+        )
+      );
+    }
+  }
+
+  // eslint-disable-next-line @nomiclabs/hardhat-internal-rules/only-hardhat-error
+  throw new FileNotFoundError(path.join(from, relativePath));
+}
+
+async function readdir(absolutePathToDir: string) {
+  try {
+    return await fsPromises.readdir(absolutePathToDir);
+  } catch (e: any) {
+    if (e.code === "ENOENT") {
+      return [];
+    }
+
+    if (e.code === "ENOTDIR") {
+      // eslint-disable-next-line @nomiclabs/hardhat-internal-rules/only-hardhat-error
+      throw new InvalidDirectoryError(absolutePathToDir, e);
+    }
+
+    // eslint-disable-next-line @nomiclabs/hardhat-internal-rules/only-hardhat-error
+    throw new FileSystemAccessError(e.message, e);
+  }
+}
+
+function readdirSync(absolutePathToDir: string) {
+  try {
+    return fs.readdirSync(absolutePathToDir);
+  } catch (e: any) {
+    if (e.code === "ENOENT") {
+      return [];
+    }
+
+    if (e.code === "ENOTDIR") {
+      // eslint-disable-next-line @nomiclabs/hardhat-internal-rules/only-hardhat-error
+      throw new InvalidDirectoryError(absolutePathToDir, e);
+    }
+
+    // eslint-disable-next-line @nomiclabs/hardhat-internal-rules/only-hardhat-error
+    throw new FileSystemAccessError(e.message, e);
+  }
+}

package/src/internal/util/glob.ts

@@ -3,6 +3,15 @@ import type { IOptions as GlobOptions } from "glob";
 import * as path from "path";
 import util from "util";
 
+/**
+ * DO NOT USE THIS FUNCTION. It's SLOW and its semantics are optimized for
+ * user-facing CLI globs, not traversing the FS.
+ *
+ * It's not removed because unfortunately some plugins used it, like the truffle
+ * ones.
+ *
+ * @deprecated
+ */
 export async function glob(
   pattern: string,
   options: GlobOptions = {}
@@ -12,6 +21,10 @@ export async function glob(
   return files.map(path.normalize);
 }
 
+/**
+ * @deprecated
+ * @see glob
+ */
 export function globSync(pattern: string, options: GlobOptions = {}): string[] {
   const files = require("glob").sync(pattern, options);
   return files.map(path.normalize);

package/src/internal/util/keccak.ts

@@ -0,0 +1,5 @@
+import createKeccakHash from "keccak";
+
+export function keccak256(data: Buffer): Buffer {
+  return createKeccakHash("keccak256").update(data).digest();
+}

package/src/internal/util/scripts-runner.ts

@@ -20,7 +20,10 @@ export async function runScript(
 
     const nodeArgs = [
       ...processExecArgv,
-      ...getTsNodeArgsIfNeeded(scriptPath),
+      ...getTsNodeArgsIfNeeded(
+        scriptPath,
+        extraEnvVars.HARDHAT_TYPECHECK === "true"
+      ),
       ...extraNodeArgs,
     ];
 
@@ -33,7 +36,7 @@ export async function runScript(
     });
 
     childProcess.once("close", (status) => {
-      log(`Script ${scriptPath} exited with status code ${status}`);
+      log(`Script ${scriptPath} exited with status code ${status ?? "null"}`);
 
       resolve(status as number);
     });
@@ -90,7 +93,10 @@ function withFixedInspectArg(argv: string[]) {
   return argv.map(fixIfInspectArg);
 }
 
-function getTsNodeArgsIfNeeded(scriptPath: string): string[] {
+function getTsNodeArgsIfNeeded(
+  scriptPath: string,
+  shouldTypecheck: boolean
+): string[] {
   if (process.execArgv.includes("ts-node/register")) {
     return [];
   }
@@ -103,7 +109,10 @@ function getTsNodeArgsIfNeeded(scriptPath: string): string[] {
 
   // If the script we are going to run is .ts we need ts-node
   if (/\.tsx?$/i.test(scriptPath)) {
-    return ["--require", "ts-node/register"];
+    return [
+      "--require",
+      `ts-node/register${shouldTypecheck ? "" : "/transpile-only"}`,
+    ];
   }
 
   return [];

package/src/internal/util/wei-values.ts

@@ -17,7 +17,7 @@ export function weiToHumanReadableString(wei: bigint | number): string {
     return "0 ETH";
   }
 
-  if (wei < 10_0000n) {
+  if (wei < 100_000n) {
     return `${wei.toString()} wei`;
   }
 

package/src/profiling.ts

@@ -0,0 +1,37 @@
+import { assertHardhatInvariant } from "./internal/core/errors";
+
+/**
+ * Utility to create ad-hoc profiles when computing flamegraphs. You can think
+ * of these as virtual tasks that execute the function `f`.
+ *
+ * This is an **unstable** feature, only meant for development. DO NOT use in
+ * production code nor plugins.
+ *
+ * @param name The name of the profile. Think of it as a virtual task name.
+ * @param f The function you want to profile.
+ */
+export async function adhocProfile<T>(
+  name: string,
+  f: () => Promise<T>
+): Promise<T> {
+  const globalAsAny = global as any;
+  assertHardhatInvariant(
+    "adhocProfile" in globalAsAny,
+    "adhocProfile is missing. Are you running with --flamegraph?"
+  );
+  return globalAsAny.adhocProfile(name, f);
+}
+
+/**
+ * Sync version of adhocProfile
+ *
+ * @see adhocProfile
+ */
+export function adhocProfileSync<T>(name: string, f: () => T): T {
+  const globalAsAny = global as any;
+  assertHardhatInvariant(
+    "adhocProfileSync" in globalAsAny,
+    "adhocProfileSync is missing. Are you running with --flamegraph?"
+  );
+  return globalAsAny.adhocProfileSync(name, f);
+}

package/src/register.ts

@@ -13,9 +13,6 @@ import {
   disableReplWriterShowProxy,
   isNodeCalledWithoutAScript,
 } from "./internal/util/console";
-import { applyWorkaround } from "./internal/util/antlr-prototype-pollution-workaround";
-
-applyWorkaround();
 
 if (!HardhatContext.isCreated()) {
   require("source-map-support/register");
@@ -36,7 +33,7 @@ if (!HardhatContext.isCreated()) {
   }
 
   if (willRunWithTypescript(hardhatArguments.config)) {
-    loadTsNode(hardhatArguments.tsconfig);
+    loadTsNode(hardhatArguments.tsconfig, hardhatArguments.typecheck);
   }
 
   const { resolvedConfig, userConfig } = loadConfigAndTasks(hardhatArguments);