hardhatjs 2.22.15

package/src/internal/util/lazy.ts

@@ -0,0 +1,247 @@
+import util, { InspectOptions } from "util";
+
+import { HardhatError } from "../core/errors";
+import { ERRORS } from "../core/errors-list";
+
+const inspect = Symbol.for("nodejs.util.inspect.custom");
+
+/**
+ * This module provides function to implement proxy-based object, functions, and
+ * classes (they are functions). They receive an initializer function that it's
+ * not used until someone interacts with the lazy element.
+ *
+ * This functions can also be used like a lazy `require`, creating a proxy that
+ * doesn't require the module until needed.
+ *
+ * The disadvantage of using this technique is that the type information is
+ * lost wrt `import`, as `require` returns an `any. If done with enough care,
+ * this can be manually fixed.
+ *
+ * TypeScript doesn't emit `require` calls for modules that are imported only
+ * because of their types. So if one uses lazyObject or lazyFunction along with
+ * a normal ESM import you can pass the module's type to this function.
+ *
+ * An example of this can be:
+ *
+ *    import findUpT from "find-up";
+ *    export const findUp = lazyFunction<typeof findUpT>(() => require("find-up"));
+ *
+ * You can also use it with named exports:
+ *
+ *    import { EthT } from "web3x/eth";
+ *    const Eth = lazyFunction<typeof EthT>(() => require("web3x/eth").Eth);
+ */
+
+export function lazyObject<T extends object>(objectCreator: () => T): T {
+  return createLazyProxy(
+    objectCreator,
+    (getRealTarget) => ({
+      [inspect](
+        depth: number,
+        options: InspectOptions,
+        inspectFn: (
+          object: any,
+          options: InspectOptions
+        ) => string = util.inspect
+      ) {
+        const realTarget = getRealTarget();
+        const newOptions = { ...options, depth };
+        return inspectFn(realTarget, newOptions);
+      },
+    }),
+    (object) => {
+      if (object instanceof Function) {
+        throw new HardhatError(ERRORS.GENERAL.UNSUPPORTED_OPERATION, {
+          operation: "Creating lazy functions or classes with lazyObject",
+        });
+      }
+
+      if (typeof object !== "object" || object === null) {
+        throw new HardhatError(ERRORS.GENERAL.UNSUPPORTED_OPERATION, {
+          operation: "Using lazyObject with anything other than objects",
+        });
+      }
+    }
+  );
+}
+
+// eslint-disable-next-line @typescript-eslint/ban-types
+export function lazyFunction<T extends Function>(functionCreator: () => T): T {
+  return createLazyProxy(
+    functionCreator,
+    (getRealTarget) => {
+      function dummyTarget() {}
+
+      (dummyTarget as any)[inspect] = function (
+        depth: number,
+        options: InspectOptions,
+        inspectFn: (
+          object: any,
+          options: InspectOptions
+        ) => string = util.inspect
+      ) {
+        const realTarget = getRealTarget();
+        const newOptions = { ...options, depth };
+        return inspectFn(realTarget, newOptions);
+      };
+
+      return dummyTarget;
+    },
+    (object) => {
+      if (!(object instanceof Function)) {
+        throw new HardhatError(ERRORS.GENERAL.UNSUPPORTED_OPERATION, {
+          operation:
+            "Using lazyFunction with anything other than functions or classes",
+        });
+      }
+    }
+  );
+}
+
+function createLazyProxy<ActualT extends GuardT, GuardT extends object>(
+  targetCreator: () => ActualT,
+  dummyTargetCreator: (getRealTarget: () => ActualT) => GuardT,
+  validator: (target: any) => void
+): ActualT {
+  let realTarget: ActualT | undefined;
+
+  const dummyTarget: ActualT = dummyTargetCreator(getRealTarget) as any;
+
+  function getRealTarget(): ActualT {
+    if (realTarget === undefined) {
+      const target = targetCreator();
+      validator(target);
+
+      // We copy all properties. We won't use them, but help us avoid Proxy
+      // invariant violations
+      const properties = Object.getOwnPropertyNames(target);
+      for (const property of properties) {
+        const descriptor = Object.getOwnPropertyDescriptor(target, property)!;
+        Object.defineProperty(dummyTarget, property, descriptor);
+      }
+
+      Object.setPrototypeOf(dummyTarget, Object.getPrototypeOf(target));
+
+      // Using a null prototype seems to tirgger a V8 bug, so we forbid it
+      // See: https://github.com/nodejs/node/issues/29730
+      if (Object.getPrototypeOf(target) === null) {
+        throw new HardhatError(ERRORS.GENERAL.UNSUPPORTED_OPERATION, {
+          operation:
+            "Using lazyFunction or lazyObject to construct objects/functions with prototype null",
+        });
+      }
+
+      if (!Object.isExtensible(target)) {
+        Object.preventExtensions(dummyTarget);
+      }
+
+      realTarget = target;
+    }
+
+    return realTarget;
+  }
+
+  const handler: ProxyHandler<ActualT> = {
+    defineProperty(target, property, descriptor) {
+      Reflect.defineProperty(dummyTarget, property, descriptor);
+      return Reflect.defineProperty(getRealTarget(), property, descriptor);
+    },
+
+    deleteProperty(target, property) {
+      Reflect.deleteProperty(dummyTarget, property);
+      return Reflect.deleteProperty(getRealTarget(), property);
+    },
+
+    get(target, property, receiver) {
+      // We have this short-circuit logic here to avoid a cyclic require when
+      // loading Web3.js.
+      //
+      // If a lazy object is somehow accessed while its real target is being
+      // created, it would trigger an endless loop of recreation, which node
+      // detects and resolve to an empty object.
+      //
+      // This happens with Web3.js because we a lazyObject that loads it,
+      // and expose it as `global.web3`. This Web3.js file accesses
+      // `global.web3` when it's being loaded, triggering the loop we mentioned
+      // before: https://github.com/ethereum/web3.js/blob/8574bd3bf11a2e9cf4bcf8850cab13e1db56653f/packages/web3-core-requestmanager/src/givenProvider.js#L41
+      //
+      // We just return `undefined` in that case, to not enter into the loop.
+      //
+      // **SUPER IMPORTANT NOTE:** Removing this is very tempting, I know. This
+      // is a horrible hack. The most obvious approach for doing so is to
+      // remove the `global` elements that trigger this crazy behavior right
+      // before doing our `require("web3")`, and restore them afterwards.
+      // **THIS IS NOT ENOUGH** Users, and libraries (!!!!), will have their own
+      // `require`s that we can't control and will trigger the same bug.
+      const stack = new Error().stack;
+      if (
+        stack !== undefined &&
+        stack.includes("givenProvider.js") &&
+        realTarget === undefined
+      ) {
+        return undefined;
+      }
+
+      return Reflect.get(getRealTarget(), property, receiver);
+    },
+
+    getOwnPropertyDescriptor(target, property) {
+      const descriptor = Reflect.getOwnPropertyDescriptor(
+        getRealTarget(),
+        property
+      );
+
+      if (descriptor !== undefined) {
+        Object.defineProperty(dummyTarget, property, descriptor);
+      }
+
+      return descriptor;
+    },
+
+    getPrototypeOf(_target) {
+      return Reflect.getPrototypeOf(getRealTarget());
+    },
+
+    has(target, property) {
+      return Reflect.has(getRealTarget(), property);
+    },
+
+    isExtensible(_target) {
+      return Reflect.isExtensible(getRealTarget());
+    },
+
+    ownKeys(_target) {
+      return Reflect.ownKeys(getRealTarget());
+    },
+
+    preventExtensions(_target) {
+      Object.preventExtensions(dummyTarget);
+      return Reflect.preventExtensions(getRealTarget());
+    },
+
+    set(target, property, value, receiver) {
+      Reflect.set(dummyTarget, property, value, receiver);
+      return Reflect.set(getRealTarget(), property, value, receiver);
+    },
+
+    setPrototypeOf(target, prototype) {
+      Reflect.setPrototypeOf(dummyTarget, prototype);
+      return Reflect.setPrototypeOf(getRealTarget(), prototype);
+    },
+  };
+
+  if (dummyTarget instanceof Function) {
+    // If dummy target is a function, the actual target must be a function too.
+    handler.apply = (target, thisArg: any, argArray?: any) => {
+      // eslint-disable-next-line @typescript-eslint/ban-types
+      return Reflect.apply(getRealTarget() as Function, thisArg, argArray);
+    };
+
+    handler.construct = (target, argArray: any, _newTarget?: any) => {
+      // eslint-disable-next-line @typescript-eslint/ban-types
+      return Reflect.construct(getRealTarget() as Function, argArray);
+    };
+  }
+
+  return new Proxy(dummyTarget, handler);
+}

package/src/internal/util/multi-process-mutex.ts

@@ -0,0 +1,133 @@
+/* eslint-disable @nomicfoundation/hardhat-internal-rules/only-hardhat-error */
+import debug from "debug";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+
+// Logic explanation: the fs.writeFile function, when used with the wx+ flag, performs an atomic operation to create a file.
+// If multiple processes try to create the same file simultaneously, only one will succeed.
+// This logic can be utilized to implement a mutex.
+// ATTENTION: in the current implementation, there's still a risk of two processes running simultaneously.
+// For example, if processA has locked the mutex and is running, processB will wait.
+// During this wait, processB continuously checks the elapsed time since the mutex lock file was created.
+// If an excessive amount of time has passed, processB will assume ownership of the mutex to avoid stale locks.
+// However, there's a possibility that processB might take ownership because the mutex creation file is outdated, even though processA is still running
+// For more info check the Nomic Notion page (internal link).
+
+const log = debug("hardhat:util:multi-process-mutex");
+const DEFAULT_MAX_MUTEX_LIFESPAN_IN_MS = 60000;
+const MUTEX_LOOP_WAITING_TIME_IN_MS = 100;
+
+export class MultiProcessMutex {
+  private _mutexFilePath: string;
+  private _mutexLifespanInMs: number;
+
+  constructor(mutexName: string, maxMutexLifespanInMs?: number) {
+    log(`Creating mutex with name '${mutexName}'`);
+
+    this._mutexFilePath = path.join(os.tmpdir(), `${mutexName}.txt`);
+    this._mutexLifespanInMs =
+      maxMutexLifespanInMs ?? DEFAULT_MAX_MUTEX_LIFESPAN_IN_MS;
+  }
+
+  public async use<T>(f: () => Promise<T>): Promise<T> {
+    log(`Starting mutex process with mutex file '${this._mutexFilePath}'`);
+
+    while (true) {
+      if (await this._tryToAcquireMutex()) {
+        // Mutex has been acquired
+        return this._executeFunctionAndReleaseMutex(f);
+      }
+
+      // Mutex not acquired
+      if (this._isMutexFileTooOld()) {
+        // If the mutex file is too old, it likely indicates a stale lock, so the file should be removed
+        log(
+          `Current mutex file is too old, removing it at path '${this._mutexFilePath}'`
+        );
+        this._deleteMutexFile();
+      } else {
+        // wait
+        await this._waitMs();
+      }
+    }
+  }
+
+  private async _tryToAcquireMutex() {
+    try {
+      // Create a file only if it does not exist
+      fs.writeFileSync(this._mutexFilePath, "", { flag: "wx+" });
+      return true;
+    } catch (error: any) {
+      if (error.code === "EEXIST") {
+        // File already exists, so the mutex is already acquired
+        return false;
+      }
+
+      throw error;
+    }
+  }
+
+  private async _executeFunctionAndReleaseMutex<T>(
+    f: () => Promise<T>
+  ): Promise<T> {
+    log(`Mutex acquired at path '${this._mutexFilePath}'`);
+
+    try {
+      const res = await f();
+
+      // Release the mutex
+      log(`Mutex released at path '${this._mutexFilePath}'`);
+      this._deleteMutexFile();
+
+      log(`Mutex released at path '${this._mutexFilePath}'`);
+
+      return res;
+    } catch (error: any) {
+      // Catch any error to avoid stale locks.
+      // Remove the mutex file and re-throw the error
+      this._deleteMutexFile();
+      throw error;
+    }
+  }
+
+  private _isMutexFileTooOld(): boolean {
+    let fileStat;
+    try {
+      fileStat = fs.statSync(this._mutexFilePath);
+    } catch (error: any) {
+      if (error.code === "ENOENT") {
+        // The file might have been deleted by another process while this function was trying to access it.
+        return false;
+      }
+
+      throw error;
+    }
+
+    const now = new Date();
+    const fileDate = new Date(fileStat.ctime);
+    const diff = now.getTime() - fileDate.getTime();
+
+    return diff > this._mutexLifespanInMs;
+  }
+
+  private _deleteMutexFile() {
+    try {
+      log(`Deleting mutex file at path '${this._mutexFilePath}'`);
+      fs.unlinkSync(this._mutexFilePath);
+    } catch (error: any) {
+      if (error.code === "ENOENT") {
+        // The file might have been deleted by another process while this function was trying to access it.
+        return;
+      }
+
+      throw error;
+    }
+  }
+
+  private async _waitMs() {
+    return new Promise((resolve) =>
+      setTimeout(resolve, MUTEX_LOOP_WAITING_TIME_IN_MS)
+    );
+  }
+}

package/src/internal/util/packageInfo.ts

@@ -0,0 +1,68 @@
+import findup from "find-up";
+import fsExtra from "fs-extra";
+import path from "path";
+
+import { assertHardhatInvariant } from "../core/errors";
+
+export function getPackageJsonPath(): string {
+  return findClosestPackageJson(__filename)!;
+}
+
+export function getPackageRoot(): string {
+  const packageJsonPath = getPackageJsonPath();
+
+  return path.dirname(packageJsonPath);
+}
+
+export interface PackageJson {
+  name: string;
+  version: string;
+  type?: "commonjs" | "module";
+  engines: {
+    node: string;
+  };
+}
+
+export function findClosestPackageJson(file: string): string | null {
+  return findup.sync("package.json", { cwd: path.dirname(file) });
+}
+
+export async function getPackageName(file: string): Promise<string> {
+  const packageJsonPath = findClosestPackageJson(file);
+  if (packageJsonPath !== null && packageJsonPath !== "") {
+    const packageJson: PackageJson = await fsExtra.readJSON(packageJsonPath);
+    return packageJson.name;
+  }
+  return "";
+}
+
+export async function getPackageJson(): Promise<PackageJson> {
+  const root = getPackageRoot();
+  return fsExtra.readJSON(path.join(root, "package.json"));
+}
+
+export function getHardhatVersion(): string {
+  const packageJsonPath = findClosestPackageJson(__filename);
+
+  assertHardhatInvariant(
+    packageJsonPath !== null,
+    "There should be a package.json in hardhat-core's root directory"
+  );
+
+  const packageJson = fsExtra.readJsonSync(packageJsonPath);
+  return packageJson.version;
+}
+
+/**
+ * Return the contents of the package.json in the user's project
+ */
+export function getProjectPackageJson(): Promise<any> {
+  const packageJsonPath = findup.sync("package.json");
+
+  assertHardhatInvariant(
+    packageJsonPath !== null,
+    "Expected a package.json file in the current directory or in an ancestor directory"
+  );
+
+  return fsExtra.readJson(packageJsonPath);
+}

package/src/internal/util/platform.ts

@@ -0,0 +1,5 @@
+export function getRequireCachedFiles(): string[] {
+  return Object.keys(require.cache).filter(
+    (p) => !p.startsWith("internal") && (p.endsWith(".js") || p.endsWith(".ts"))
+  );
+}

package/src/internal/util/proxy.ts

@@ -0,0 +1,18 @@
+export function shouldUseProxy(url: string): boolean {
+  const { hostname } = new URL(url);
+  const noProxy = process.env.NO_PROXY;
+
+  if (hostname === "localhost" || hostname === "127.0.0.1" || noProxy === "*") {
+    return false;
+  }
+
+  if (noProxy !== undefined && noProxy !== "") {
+    const noProxyList = noProxy.split(",");
+
+    if (noProxyList.includes(hostname)) {
+      return false;
+    }
+  }
+
+  return true;
+}

package/src/internal/util/report-telemetry-consent.ts

@@ -0,0 +1,19 @@
+import { Analytics } from "../cli/analytics";
+
+async function main() {
+  // This default value shouldn't be necessary, but we add one to make it
+  // easier to recognize if the telemetry consent value is not passed.
+  const [telemetryConsent = "<undefined-telemetry-consent>"] =
+    process.argv.slice(2);
+
+  // we pass undefined as the telemetryConsent value because
+  // this hit is done before the consent is saved
+  const analytics = await Analytics.getInstance(undefined);
+
+  const [_, consentHitPromise] = await analytics.sendTelemetryConsentHit(
+    telemetryConsent as "yes" | "no"
+  );
+  await consentHitPromise;
+}
+
+main().catch(() => {});

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

@@ -0,0 +1,119 @@
+import debug from "debug";
+import path from "path";
+
+import { HardhatArguments } from "../../types";
+import { isRunningHardhatCoreTests } from "../core/execution-mode";
+import { getEnvVariablesMap } from "../core/params/env-variables";
+
+const log = debug("hardhat:core:scripts-runner");
+
+export async function runScript(
+  scriptPath: string,
+  scriptArgs: string[] = [],
+  extraNodeArgs: string[] = [],
+  extraEnvVars: { [name: string]: string } = {}
+): Promise<number> {
+  const { fork } = await import("child_process");
+
+  return new Promise((resolve, reject) => {
+    const processExecArgv = withFixedInspectArg(process.execArgv);
+
+    const nodeArgs = [
+      ...processExecArgv,
+      ...getTsNodeArgsIfNeeded(
+        scriptPath,
+        extraEnvVars.HARDHAT_TYPECHECK === "true"
+      ),
+      ...extraNodeArgs,
+    ];
+
+    const envVars = { ...process.env, ...extraEnvVars };
+
+    const childProcess = fork(scriptPath, scriptArgs, {
+      stdio: "inherit",
+      execArgv: nodeArgs,
+      env: envVars,
+    });
+
+    childProcess.once("close", (status) => {
+      log(`Script ${scriptPath} exited with status code ${status ?? "null"}`);
+
+      resolve(status as number);
+    });
+    childProcess.once("error", reject);
+  });
+}
+
+export async function runScriptWithHardhat(
+  hardhatArguments: HardhatArguments,
+  scriptPath: string,
+  scriptArgs: string[] = [],
+  extraNodeArgs: string[] = [],
+  extraEnvVars: { [name: string]: string } = {}
+): Promise<number> {
+  log(`Creating Hardhat subprocess to run ${scriptPath}`);
+
+  return runScript(
+    scriptPath,
+    scriptArgs,
+    [
+      ...extraNodeArgs,
+      "--require",
+      path.join(__dirname, "..", "..", "register"),
+    ],
+    {
+      ...getEnvVariablesMap(hardhatArguments),
+      ...extraEnvVars,
+    }
+  );
+}
+
+/**
+ * Fix debugger "inspect" arg from process.argv, if present.
+ *
+ * When running this process with a debugger, a debugger port
+ * is specified via the "--inspect-brk=" arg param in some IDEs/setups.
+ *
+ * This normally works, but if we do a fork afterwards, we'll get an error stating
+ * that the port is already in use (since the fork would also use the same args,
+ * therefore the same port number). To prevent this issue, we could replace the port number with
+ * a different free one, or simply use the port-agnostic --inspect" flag, and leave the debugger
+ * port selection to the Node process itself, which will pick an empty AND valid one.
+ *
+ * This way, we can properly use the debugger for this process AND for the executed
+ * script itself - even if it's compiled using ts-node.
+ */
+function withFixedInspectArg(argv: string[]) {
+  const fixIfInspectArg = (arg: string) => {
+    if (arg.toLowerCase().includes("--inspect-brk=")) {
+      return "--inspect";
+    }
+    return arg;
+  };
+  return argv.map(fixIfInspectArg);
+}
+
+function getTsNodeArgsIfNeeded(
+  scriptPath: string,
+  shouldTypecheck: boolean
+): string[] {
+  if (process.execArgv.includes("ts-node/register")) {
+    return [];
+  }
+
+  // if we are running the tests we only want to transpile, or these tests
+  // take forever
+  if (isRunningHardhatCoreTests()) {
+    return ["--require", "ts-node/register/transpile-only"];
+  }
+
+  // If the script we are going to run is .ts we need ts-node
+  if (/\.tsx?$/i.test(scriptPath)) {
+    return [
+      "--require",
+      `ts-node/register${shouldTypecheck ? "" : "/transpile-only"}`,
+    ];
+  }
+
+  return [];
+}

package/src/internal/util/strings.ts

@@ -0,0 +1,31 @@
+/**
+ * Returns the plural form of a word.
+ *
+ * @param n The number of things to represent. This dictates whether to return
+ * the singular or plural form of the word.
+ * @param singular The singular form of the word.
+ * @param plural An optional plural form of the word. If non is given, the
+ * plural form is constructed by appending an "s" to the singular form.
+ */
+export function pluralize(n: number, singular: string, plural?: string) {
+  if (n === 1) {
+    return singular;
+  }
+
+  if (plural !== undefined) {
+    return plural;
+  }
+
+  return `${singular}s`;
+}
+
+/**
+ * Replaces all the instances of [[toReplace]] by [[replacement]] in [[str]].
+ */
+export function replaceAll(
+  str: string,
+  toReplace: string,
+  replacement: string
+) {
+  return str.split(toReplace).join(replacement);
+}

package/src/internal/util/unsafe.ts

@@ -0,0 +1,15 @@
+/**
+ * This function is a typed version of `Object.keys`. Note that it's type
+ * unsafe. You have to be sure that `o` has exactly the same keys as `T`.
+ */
+export const unsafeObjectKeys = Object.keys as <T>(
+  o: T
+) => Array<Extract<keyof T, string>>;
+
+/**
+ * This function is a typed version of `Object.entries`. Note that it's type
+ * unsafe. You have to be sure that `o` has exactly the same keys as `T`.
+ */
+export function unsafeObjectEntries<T extends object>(o: T) {
+  return Object.entries(o) as Array<[keyof T, T[keyof T]]>;
+}