hardhatjs 2.22.15

package/src/internal/solidity/resolver.ts

@@ -0,0 +1,563 @@
+import fsExtra from "fs-extra";
+import path from "path";
+import resolve from "resolve";
+
+import {
+  FileContent,
+  LibraryInfo,
+  ResolvedFile as IResolvedFile,
+} from "../../types/builtin-tasks";
+import {
+  includesOwnPackageName,
+  isAbsolutePathSourceName,
+  isLocalSourceName,
+  normalizeSourceName,
+  replaceBackslashes,
+  validateSourceNameExistenceAndCasing,
+  validateSourceNameFormat,
+} from "../../utils/source-names";
+import { assertHardhatInvariant, HardhatError } from "../core/errors";
+import { ERRORS } from "../core/errors-list";
+import { createNonCryptographicHashBasedIdentifier } from "../util/hash";
+
+import { getRealPath } from "../util/fs-utils";
+import { applyRemappings } from "../../utils/remappings";
+import { Parser } from "./parse";
+
+export interface ResolvedFilesMap {
+  [sourceName: string]: ResolvedFile;
+}
+
+const NODE_MODULES = "node_modules";
+
+export class ResolvedFile implements IResolvedFile {
+  public readonly library?: LibraryInfo;
+
+  constructor(
+    public readonly sourceName: string,
+    public readonly absolutePath: string,
+    public readonly content: FileContent,
+    public readonly contentHash: string,
+    public readonly lastModificationDate: Date,
+    libraryName?: string,
+    libraryVersion?: string
+  ) {
+    assertHardhatInvariant(
+      (libraryName === undefined && libraryVersion === undefined) ||
+        (libraryName !== undefined && libraryVersion !== undefined),
+      "Libraries should have both name and version, or neither one"
+    );
+
+    if (libraryName !== undefined && libraryVersion !== undefined) {
+      this.library = {
+        name: libraryName,
+        version: libraryVersion,
+      };
+    }
+  }
+
+  public getVersionedName() {
+    return (
+      this.sourceName +
+      (this.library !== undefined ? `@v${this.library.version}` : "")
+    );
+  }
+}
+
+export class Resolver {
+  private readonly _cache: Map<string, ResolvedFile> = new Map();
+
+  constructor(
+    private readonly _projectRoot: string,
+    private readonly _parser: Parser,
+    private readonly _remappings: Record<string, string>,
+    private readonly _readFile: (absolutePath: string) => Promise<string>,
+    private readonly _transformImportName: (
+      importName: string
+    ) => Promise<string>
+  ) {}
+
+  /**
+   * Resolves a source name into a ResolvedFile.
+   *
+   * @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;
+    }
+
+    const remappedSourceName = applyRemappings(this._remappings, sourceName);
+
+    validateSourceNameFormat(remappedSourceName);
+
+    let resolvedFile: ResolvedFile;
+
+    if (await isLocalSourceName(this._projectRoot, remappedSourceName)) {
+      resolvedFile = await this._resolveLocalSourceName(
+        sourceName,
+        remappedSourceName
+      );
+    } else {
+      resolvedFile = await this._resolveLibrarySourceName(
+        sourceName,
+        remappedSourceName
+      );
+    }
+
+    this._cache.set(sourceName, resolvedFile);
+    return resolvedFile;
+  }
+
+  /**
+   * Resolves an import from an already resolved file.
+   * @param from The file were the import statement is present.
+   * @param importName The path in the import statement.
+   */
+  public async resolveImport(
+    from: ResolvedFile,
+    importName: string
+  ): Promise<ResolvedFile> {
+    // sanity check for deprecated task
+    if (importName !== (await this._transformImportName(importName))) {
+      throw new HardhatError(
+        ERRORS.TASK_DEFINITIONS.DEPRECATED_TRANSFORM_IMPORT_TASK
+      );
+    }
+
+    const imported = applyRemappings(this._remappings, importName);
+
+    const scheme = this._getUriScheme(imported);
+    if (scheme !== undefined) {
+      throw new HardhatError(ERRORS.RESOLVER.INVALID_IMPORT_PROTOCOL, {
+        from: from.sourceName,
+        imported,
+        protocol: scheme,
+      });
+    }
+
+    if (replaceBackslashes(imported) !== imported) {
+      throw new HardhatError(ERRORS.RESOLVER.INVALID_IMPORT_BACKSLASH, {
+        from: from.sourceName,
+        imported,
+      });
+    }
+
+    if (isAbsolutePathSourceName(imported)) {
+      throw new HardhatError(ERRORS.RESOLVER.INVALID_IMPORT_ABSOLUTE_PATH, {
+        from: from.sourceName,
+        imported,
+      });
+    }
+
+    // Edge-case where an import can contain the current package's name in monorepos.
+    // The path can be resolved because there's a symlink in the node modules.
+    if (await includesOwnPackageName(imported)) {
+      throw new HardhatError(ERRORS.RESOLVER.INCLUDES_OWN_PACKAGE_NAME, {
+        from: from.sourceName,
+        imported,
+      });
+    }
+
+    try {
+      let sourceName: string;
+
+      const isRelativeImport = this._isRelativeImport(imported);
+
+      if (isRelativeImport) {
+        sourceName = await this._relativeImportToSourceName(from, imported);
+      } else {
+        sourceName = normalizeSourceName(importName); // The sourceName of the imported file is not transformed
+      }
+
+      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)
+      ) {
+        resolvedFile = await this._resolveLocalSourceName(
+          sourceName,
+          applyRemappings(this._remappings, sourceName)
+        );
+      } else {
+        resolvedFile = await this.resolveSourceName(sourceName);
+      }
+
+      this._cache.set(sourceName, resolvedFile);
+      return resolvedFile;
+    } catch (error) {
+      if (
+        HardhatError.isHardhatErrorType(
+          error,
+          ERRORS.RESOLVER.FILE_NOT_FOUND
+        ) ||
+        HardhatError.isHardhatErrorType(
+          error,
+          ERRORS.RESOLVER.LIBRARY_FILE_NOT_FOUND
+        )
+      ) {
+        if (imported !== importName) {
+          throw new HardhatError(
+            ERRORS.RESOLVER.IMPORTED_MAPPED_FILE_NOT_FOUND,
+            {
+              imported,
+              importName,
+              from: from.sourceName,
+            },
+            error
+          );
+        } else {
+          throw new HardhatError(
+            ERRORS.RESOLVER.IMPORTED_FILE_NOT_FOUND,
+            {
+              imported,
+              from: from.sourceName,
+            },
+            error
+          );
+        }
+      }
+
+      if (
+        HardhatError.isHardhatErrorType(
+          error,
+          ERRORS.RESOLVER.WRONG_SOURCE_NAME_CASING
+        )
+      ) {
+        throw new HardhatError(
+          ERRORS.RESOLVER.INVALID_IMPORT_WRONG_CASING,
+          {
+            imported,
+            from: from.sourceName,
+          },
+          error
+        );
+      }
+
+      if (
+        HardhatError.isHardhatErrorType(
+          error,
+          ERRORS.RESOLVER.LIBRARY_NOT_INSTALLED
+        )
+      ) {
+        throw new HardhatError(
+          ERRORS.RESOLVER.IMPORTED_LIBRARY_NOT_INSTALLED,
+          {
+            library: error.messageArguments.library,
+            from: from.sourceName,
+          },
+          error
+        );
+      }
+
+      if (
+        HardhatError.isHardhatErrorType(
+          error,
+          ERRORS.GENERAL.INVALID_READ_OF_DIRECTORY
+        )
+      ) {
+        throw new HardhatError(
+          ERRORS.RESOLVER.INVALID_IMPORT_OF_DIRECTORY,
+          {
+            imported,
+            from: from.sourceName,
+          },
+          error
+        );
+      }
+
+      // eslint-disable-next-line @nomicfoundation/hardhat-internal-rules/only-hardhat-error
+      throw error;
+    }
+  }
+
+  private async _resolveLocalSourceName(
+    sourceName: string,
+    remappedSourceName: string
+  ): Promise<ResolvedFile> {
+    await this._validateSourceNameExistenceAndCasing(
+      this._projectRoot,
+      remappedSourceName,
+      false
+    );
+
+    const absolutePath = path.join(this._projectRoot, remappedSourceName);
+    return this._resolveFile(sourceName, absolutePath);
+  }
+
+  private async _resolveLibrarySourceName(
+    sourceName: string,
+    remappedSourceName: string
+  ): Promise<ResolvedFile> {
+    const normalizedSourceName = remappedSourceName.replace(
+      /^node_modules\//,
+      ""
+    );
+    const libraryName = this._getLibraryName(normalizedSourceName);
+
+    let packageJsonPath;
+    try {
+      packageJsonPath = this._resolveNodeModulesFileFromProjectRoot(
+        path.join(libraryName, "package.json")
+      );
+    } catch (error) {
+      // if the project is using a dependency from hardhat itself but it can't
+      // be found, this means that a global installation is being used, so we
+      // resolve the dependency relative to this file
+      if (libraryName === "hardhat") {
+        const hardhatCoreDir = path.join(__dirname, "..", "..");
+        packageJsonPath = path.join(hardhatCoreDir, "package.json");
+      } else {
+        throw new HardhatError(
+          ERRORS.RESOLVER.LIBRARY_NOT_INSTALLED,
+          {
+            library: libraryName,
+          },
+          error as Error
+        );
+      }
+    }
+
+    let nodeModulesPath = path.dirname(path.dirname(packageJsonPath));
+    if (this._isScopedPackage(normalizedSourceName)) {
+      nodeModulesPath = path.dirname(nodeModulesPath);
+    }
+
+    let absolutePath: string;
+    if (path.basename(nodeModulesPath) !== NODE_MODULES) {
+      // this can happen in monorepos that use PnP, in those
+      // cases we handle resolution differently
+      const packageRoot = path.dirname(packageJsonPath);
+      const pattern = new RegExp(`^${libraryName}/?`);
+      const fileName = normalizedSourceName.replace(pattern, "");
+
+      await this._validateSourceNameExistenceAndCasing(
+        packageRoot,
+        // TODO: this is _not_ a source name; we should handle this scenario in
+        // a better way
+        fileName,
+        true
+      );
+      absolutePath = path.join(packageRoot, fileName);
+    } else {
+      await this._validateSourceNameExistenceAndCasing(
+        nodeModulesPath,
+        normalizedSourceName,
+        true
+      );
+      absolutePath = path.join(nodeModulesPath, normalizedSourceName);
+    }
+
+    const packageInfo: {
+      name: string;
+      version: string;
+    } = await fsExtra.readJson(packageJsonPath);
+    const libraryVersion = packageInfo.version;
+
+    return this._resolveFile(
+      sourceName,
+      // We resolve to the real path here, as we may be resolving a linked library
+      await getRealPath(absolutePath),
+      libraryName,
+      libraryVersion
+    );
+  }
+
+  private async _relativeImportToSourceName(
+    from: ResolvedFile,
+    imported: string
+  ): Promise<string> {
+    // This is a special case, were we turn relative imports from local files
+    // into library imports if necessary. The reason for this is that many
+    // users just do `import "../node_modules/lib/a.sol";`.
+    if (this._isRelativeImportToLibrary(from, imported)) {
+      return this._relativeImportToLibraryToSourceName(from, imported);
+    }
+
+    const sourceName = normalizeSourceName(
+      path.join(path.dirname(from.sourceName), imported)
+    );
+
+    // If the file with the import is local, and the normalized version
+    // starts with ../ means that it's trying to get outside of the project.
+    if (from.library === undefined && sourceName.startsWith("../")) {
+      throw new HardhatError(
+        ERRORS.RESOLVER.INVALID_IMPORT_OUTSIDE_OF_PROJECT,
+        { from: from.sourceName, imported }
+      );
+    }
+
+    if (
+      from.library !== undefined &&
+      !this._isInsideSameDir(from.sourceName, sourceName)
+    ) {
+      // If the file is being imported from a library, this means that it's
+      // trying to reach another one.
+      throw new HardhatError(ERRORS.RESOLVER.ILLEGAL_IMPORT, {
+        from: from.sourceName,
+        imported,
+      });
+    }
+
+    return sourceName;
+  }
+
+  private async _resolveFile(
+    sourceName: string,
+    absolutePath: string,
+    libraryName?: string,
+    libraryVersion?: string
+  ): Promise<ResolvedFile> {
+    const rawContent = await this._readFile(absolutePath);
+    const stats = await fsExtra.stat(absolutePath);
+    const lastModificationDate = new Date(stats.ctime);
+
+    const contentHash = createNonCryptographicHashBasedIdentifier(
+      Buffer.from(rawContent)
+    ).toString("hex");
+
+    const parsedContent = this._parser.parse(
+      rawContent,
+      absolutePath,
+      contentHash
+    );
+
+    const content = {
+      rawContent,
+      ...parsedContent,
+    };
+
+    return new ResolvedFile(
+      sourceName,
+      absolutePath,
+      content,
+      contentHash,
+      lastModificationDate,
+      libraryName,
+      libraryVersion
+    );
+  }
+
+  private _isRelativeImport(imported: string): boolean {
+    return imported.startsWith("./") || imported.startsWith("../");
+  }
+
+  private _resolveNodeModulesFileFromProjectRoot(fileName: string) {
+    return resolve.sync(fileName, {
+      basedir: this._projectRoot,
+      preserveSymlinks: true,
+    });
+  }
+
+  private _getLibraryName(sourceName: string): string {
+    let endIndex: number;
+    if (this._isScopedPackage(sourceName)) {
+      endIndex = sourceName.indexOf("/", sourceName.indexOf("/") + 1);
+    } else if (sourceName.indexOf("/") === -1) {
+      endIndex = sourceName.length;
+    } else {
+      endIndex = sourceName.indexOf("/");
+    }
+
+    return sourceName.slice(0, endIndex);
+  }
+
+  private _getUriScheme(s: string): string | undefined {
+    const re = /([a-zA-Z]+):\/\//;
+    const match = re.exec(s);
+    if (match === null) {
+      return undefined;
+    }
+
+    return match[1];
+  }
+
+  private _isInsideSameDir(sourceNameInDir: string, sourceNameToTest: string) {
+    const firstSlash = sourceNameInDir.indexOf("/");
+    const dir =
+      firstSlash !== -1
+        ? sourceNameInDir.substring(0, firstSlash)
+        : sourceNameInDir;
+
+    return sourceNameToTest.startsWith(dir);
+  }
+
+  private _isScopedPackage(packageOrPackageFile: string): boolean {
+    return packageOrPackageFile.startsWith("@");
+  }
+
+  private _isRelativeImportToLibrary(
+    from: ResolvedFile,
+    imported: string
+  ): boolean {
+    return (
+      this._isRelativeImport(imported) &&
+      from.library === undefined &&
+      imported.includes(`${NODE_MODULES}/`)
+    );
+  }
+
+  private _relativeImportToLibraryToSourceName(
+    from: ResolvedFile,
+    imported: string
+  ): string {
+    const sourceName = normalizeSourceName(
+      path.join(path.dirname(from.sourceName), imported)
+    );
+
+    const nmIndex = sourceName.indexOf(`${NODE_MODULES}/`);
+    return sourceName.substr(nmIndex + NODE_MODULES.length + 1);
+  }
+
+  private async _validateSourceNameExistenceAndCasing(
+    fromDir: string,
+    sourceName: string,
+    isLibrary: boolean
+  ) {
+    try {
+      await validateSourceNameExistenceAndCasing(fromDir, sourceName);
+    } catch (error) {
+      if (
+        HardhatError.isHardhatErrorType(
+          error,
+          ERRORS.SOURCE_NAMES.FILE_NOT_FOUND
+        )
+      ) {
+        throw new HardhatError(
+          isLibrary
+            ? ERRORS.RESOLVER.LIBRARY_FILE_NOT_FOUND
+            : ERRORS.RESOLVER.FILE_NOT_FOUND,
+          { file: sourceName },
+          error
+        );
+      }
+
+      if (
+        HardhatError.isHardhatErrorType(error, ERRORS.SOURCE_NAMES.WRONG_CASING)
+      ) {
+        throw new HardhatError(
+          ERRORS.RESOLVER.WRONG_SOURCE_NAME_CASING,
+          {
+            incorrect: sourceName,
+            correct: error.messageArguments.correct,
+          },
+          error
+        );
+      }
+
+      // eslint-disable-next-line @nomicfoundation/hardhat-internal-rules/only-hardhat-error
+      throw error;
+    }
+  }
+}

package/src/internal/util/abi-helpers.ts

@@ -0,0 +1,55 @@
+import * as abi from "@ethersproject/abi";
+
+export class AbiHelpers {
+  /**
+   * Try to compute the selector for the function/event/error
+   * with the given name and param types. Return undefined
+   * if it cannot do it. This can happen if some ParamType is
+   * not understood by @ethersproject/abi
+   */
+  public static computeSelector(
+    name: string,
+    inputs: any[]
+  ): Uint8Array | undefined {
+    try {
+      const fragment = abi.FunctionFragment.from({
+        type: "function",
+        constant: true,
+        name,
+        inputs: inputs.map((i) => abi.ParamType.from(i)),
+      });
+      const selectorHex = abi.Interface.getSighash(fragment);
+
+      return Buffer.from(selectorHex.slice(2), "hex");
+    } catch {
+      return;
+    }
+  }
+
+  public static isValidCalldata(inputs: any[], calldata: Uint8Array): boolean {
+    try {
+      abi.defaultAbiCoder.decode(inputs, calldata);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  public static formatValues(values: any[]): string {
+    return values.map((x) => AbiHelpers._formatValue(x)).join(", ");
+  }
+
+  private static _formatValue(value: any): string {
+    // print nested values as [value1, value2, ...]
+    if (Array.isArray(value)) {
+      return `[${value.map((v) => AbiHelpers._formatValue(v)).join(", ")}]`;
+    }
+
+    // surround string values with quotes
+    if (typeof value === "string") {
+      return `"${value}"`;
+    }
+
+    return value.toString();
+  }
+}

package/src/internal/util/bigint.ts

@@ -0,0 +1,66 @@
+import { assertHardhatInvariant } from "../core/errors";
+
+export function min(x: bigint, y: bigint): bigint {
+  return x < y ? x : y;
+}
+
+export function max(x: bigint, y: bigint): bigint {
+  return x > y ? x : y;
+}
+
+export function isBigInt(x: unknown): x is bigint {
+  return typeof x === "bigint";
+}
+
+export function divUp(x: bigint, y: bigint): bigint {
+  let result = x / y;
+
+  if (x % y !== 0n) {
+    result = result + 1n;
+  }
+
+  return result;
+}
+
+export function cmp(a: bigint, b: bigint): number {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+
+/**
+ * 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 bufferToBigInt(x: Uint8Array): bigint {
+  const hex = `0x${Buffer.from(x).toString("hex")}`;
+  return hex === "0x" ? 0n : BigInt(hex);
+}
+
+export function fromBigIntLike(
+  x: string | number | bigint | Uint8Array | undefined
+): bigint | undefined {
+  if (x === undefined || typeof x === "bigint") {
+    return x;
+  }
+  if (typeof x === "number" || typeof x === "string") {
+    return BigInt(x);
+  }
+  if (x instanceof Uint8Array) {
+    return bufferToBigInt(x);
+  }
+
+  const exhaustiveCheck: never = x;
+  return exhaustiveCheck;
+}
+
+export function toHex(x: number | bigint): string {
+  assertHardhatInvariant(
+    x >= 0,
+    `toHex can only be used with non-negative numbers, but received ${x}`
+  );
+
+  return `0x${x.toString(16)}`;
+}