hardhatjs 2.22.15

package/src/internal/util/global-dir.ts

@@ -0,0 +1,146 @@
+import type envPathsT from "env-paths";
+
+import debug from "debug";
+import fs from "fs-extra";
+import os from "os";
+import path from "path";
+
+const log = debug("hardhat:core:global-dir");
+
+async function generatePaths(packageName = "hardhat") {
+  const { default: envPaths } = await import("env-paths");
+  return envPaths(packageName);
+}
+
+function generatePathsSync(packageName = "hardhat") {
+  const envPaths: typeof envPathsT = require("env-paths");
+  return envPaths(packageName);
+}
+
+function getConfigDirSync(): string {
+  const { config } = generatePathsSync();
+  fs.ensureDirSync(config);
+  return config;
+}
+
+async function getDataDir(packageName?: string): Promise<string> {
+  const { data } = await generatePaths(packageName);
+  await fs.ensureDir(data);
+  return data;
+}
+
+export async function getCacheDir(): Promise<string> {
+  const { cache } = await generatePaths();
+  await fs.ensureDir(cache);
+  return cache;
+}
+
+export async function readAnalyticsId() {
+  const globalDataDir = await getDataDir();
+  const idFile = path.join(globalDataDir, "analytics.json");
+  return readId(idFile);
+}
+
+/**
+ * This is the first way that the analytics id was saved.
+ */
+export function readFirstLegacyAnalyticsId() {
+  const oldIdFile = path.join(os.homedir(), ".buidler", "config.json");
+  return readId(oldIdFile);
+}
+
+/**
+ * This is the same way the analytics id is saved now, but using buidler as the
+ * name of the project for env-paths
+ */
+export async function readSecondLegacyAnalyticsId() {
+  const globalDataDir = await getDataDir("buidler");
+  const idFile = path.join(globalDataDir, "analytics.json");
+  return readId(idFile);
+}
+
+async function readId(idFile: string): Promise<string | undefined> {
+  log(`Looking up Client Id at ${idFile}`);
+  let clientId: string;
+  try {
+    const data = await fs.readJSON(idFile, { encoding: "utf8" });
+    clientId = data.analytics.clientId;
+  } catch (error) {
+    return undefined;
+  }
+
+  log(`Client Id found: ${clientId}`);
+  return clientId;
+}
+
+export async function writeAnalyticsId(clientId: string) {
+  const globalDataDir = await getDataDir();
+  const idFile = path.join(globalDataDir, "analytics.json");
+  await fs.writeJSON(
+    idFile,
+    {
+      analytics: {
+        clientId,
+      },
+    },
+    { encoding: "utf-8", spaces: 2 }
+  );
+  log(`Stored clientId ${clientId}`);
+}
+
+export async function getCompilersDir() {
+  const cache = await getCacheDir();
+  // Note: we introduce `-v2` to invalidate all the previous compilers at once
+  const compilersCache = path.join(cache, "compilers-v2");
+  await fs.ensureDir(compilersCache);
+  return compilersCache;
+}
+
+/**
+ * Checks if the user has given (or refused) consent for telemetry.
+ *
+ * Returns undefined if it can't be determined.
+ */
+export function hasConsentedTelemetry(): boolean | undefined {
+  const configDir = getConfigDirSync();
+  const telemetryConsentPath = path.join(configDir, "telemetry-consent.json");
+
+  const fileExists = fs.pathExistsSync(telemetryConsentPath);
+
+  if (!fileExists) {
+    return undefined;
+  }
+
+  const { consent } = fs.readJSONSync(telemetryConsentPath);
+  return consent;
+}
+
+export function writeTelemetryConsent(consent: boolean) {
+  const configDir = getConfigDirSync();
+  const telemetryConsentPath = path.join(configDir, "telemetry-consent.json");
+
+  fs.writeJSONSync(telemetryConsentPath, { consent }, { spaces: 2 });
+}
+
+/**
+ * Checks if we have already prompted the user to install the Hardhat for VSCode extension.
+ */
+export function hasPromptedForHHVSCode(): boolean {
+  const configDir = getConfigDirSync();
+  const extensionPromptedPath = path.join(configDir, "extension-prompt.json");
+
+  const fileExists = fs.pathExistsSync(extensionPromptedPath);
+
+  return fileExists;
+}
+
+export function writePromptedForHHVSCode() {
+  const configDir = getConfigDirSync();
+  const extensionPromptedPath = path.join(configDir, "extension-prompt.json");
+
+  fs.writeFileSync(extensionPromptedPath, "{}");
+}
+
+export function getVarsFilePath(): string {
+  return path.join(getConfigDirSync(), "vars.json");
+}

package/src/internal/util/hardforks.ts

@@ -0,0 +1,123 @@
+import { HardforkHistoryConfig } from "../../types/config";
+import { HARDHAT_NETWORK_SUPPORTED_HARDFORKS } from "../constants";
+import { assertHardhatInvariant } from "../core/errors";
+import { InternalError } from "../core/providers/errors";
+
+/* eslint-disable @nomicfoundation/hardhat-internal-rules/only-hardhat-error */
+
+export enum HardforkName {
+  FRONTIER = "chainstart",
+  HOMESTEAD = "homestead",
+  DAO = "dao",
+  TANGERINE_WHISTLE = "tangerineWhistle",
+  SPURIOUS_DRAGON = "spuriousDragon",
+  BYZANTIUM = "byzantium",
+  CONSTANTINOPLE = "constantinople",
+  PETERSBURG = "petersburg",
+  ISTANBUL = "istanbul",
+  MUIR_GLACIER = "muirGlacier",
+  BERLIN = "berlin",
+  LONDON = "london",
+  ARROW_GLACIER = "arrowGlacier",
+  GRAY_GLACIER = "grayGlacier",
+  MERGE = "merge",
+  SHANGHAI = "shanghai",
+  CANCUN = "cancun",
+}
+
+const HARDFORKS_ORDER: HardforkName[] = [
+  HardforkName.FRONTIER,
+  HardforkName.HOMESTEAD,
+  HardforkName.DAO,
+  HardforkName.TANGERINE_WHISTLE,
+  HardforkName.SPURIOUS_DRAGON,
+  HardforkName.BYZANTIUM,
+  HardforkName.CONSTANTINOPLE,
+  HardforkName.PETERSBURG,
+  HardforkName.ISTANBUL,
+  HardforkName.MUIR_GLACIER,
+  HardforkName.BERLIN,
+  HardforkName.LONDON,
+  HardforkName.ARROW_GLACIER,
+  HardforkName.GRAY_GLACIER,
+  HardforkName.MERGE,
+  HardforkName.SHANGHAI,
+  HardforkName.CANCUN,
+];
+
+export function getHardforkName(name: string): HardforkName {
+  const hardforkName =
+    Object.values(HardforkName)[
+      Object.values<string>(HardforkName).indexOf(name)
+    ];
+
+  assertHardhatInvariant(
+    hardforkName !== undefined,
+    `Invalid harfork name ${name}`
+  );
+
+  return hardforkName;
+}
+
+/**
+ * Check if `hardforkA` is greater than or equal to `hardforkB`,
+ * that is, if it includes all its changes.
+ */
+export function hardforkGte(
+  hardforkA: HardforkName,
+  hardforkB: HardforkName
+): boolean {
+  // This function should not load any ethereumjs library, as it's used during
+  // the Hardhat initialization, and that would make it too slow.
+  const indexA = HARDFORKS_ORDER.lastIndexOf(hardforkA);
+  const indexB = HARDFORKS_ORDER.lastIndexOf(hardforkB);
+
+  return indexA >= indexB;
+}
+
+export function selectHardfork(
+  forkBlockNumber: bigint | undefined,
+  currentHardfork: string,
+  hardforkActivations: HardforkHistoryConfig | undefined,
+  blockNumber: bigint
+): string {
+  if (forkBlockNumber === undefined || blockNumber > forkBlockNumber) {
+    return currentHardfork;
+  }
+
+  if (hardforkActivations === undefined || hardforkActivations.size === 0) {
+    throw new InternalError(
+      `No known hardfork for execution on historical block ${blockNumber.toString()} (relative to fork block number ${forkBlockNumber}). The node was not configured with a hardfork activation history.  See http://hardhat.org/custom-hardfork-history`
+    );
+  }
+
+  /** search this._hardforkActivations for the highest block number that
+   * isn't higher than blockNumber, and then return that found block number's
+   * associated hardfork name. */
+  const hardforkHistory: Array<[name: string, block: number]> = Array.from(
+    hardforkActivations.entries()
+  );
+  const [hardfork, activationBlock] = hardforkHistory.reduce(
+    ([highestHardfork, highestBlock], [thisHardfork, thisBlock]) =>
+      thisBlock > highestBlock && thisBlock <= blockNumber
+        ? [thisHardfork, thisBlock]
+        : [highestHardfork, highestBlock]
+  );
+  if (hardfork === undefined || blockNumber < activationBlock) {
+    throw new InternalError(
+      `Could not find a hardfork to run for block ${blockNumber.toString()}, after having looked for one in the hardfork activation history, which was: ${JSON.stringify(
+        hardforkHistory
+      )}. For more information, see https://hardhat.org/hardhat-network/reference/#config`
+    );
+  }
+
+  if (!HARDHAT_NETWORK_SUPPORTED_HARDFORKS.includes(hardfork)) {
+    throw new InternalError(
+      `Tried to run a call or transaction in the context of a block whose hardfork is "${hardfork}", but Hardhat Network only supports the following hardforks: ${HARDHAT_NETWORK_SUPPORTED_HARDFORKS.join(
+        ", "
+      )}`
+    );
+  }
+
+  return hardfork;
+}

package/src/internal/util/hash.ts

@@ -0,0 +1,16 @@
+/**
+ * This function hashes its input with a NON cryptographic.
+ *
+ * This function is useful for creating unique identifiers based on some
+ * input. You can be confident that there won't be any collision, as long
+ * as the input is not generated by an attacker.
+ *
+ * The exact algorithm being used shouldn't matter.
+ */
+export function createNonCryptographicHashBasedIdentifier(
+  input: Buffer
+): Buffer {
+  const { createHash } = require("crypto");
+
+  return createHash("md5").update(input).digest();
+}

package/src/internal/util/io-ts.ts

@@ -0,0 +1,47 @@
+import * as t from "io-ts";
+
+export function optionalOrNullable<TypeT, OutputT, InputT>(
+  codec: t.Type<TypeT, OutputT, InputT>,
+  name: string = `${codec.name} | undefined`
+): t.Type<TypeT | undefined, OutputT | undefined, InputT | undefined | null> {
+  return new t.Type(
+    name,
+    (u: unknown): u is TypeT | undefined => u === undefined || codec.is(u),
+    (i, c) => {
+      if (i === undefined || i === null) {
+        return t.success(undefined);
+      }
+      return codec.validate(i, c);
+    },
+    (a) => {
+      if (a === undefined) {
+        return undefined;
+      }
+      return codec.encode(a);
+    }
+  );
+}
+
+export function optional<TypeT, OutputT, InputT>(
+  codec: t.Type<TypeT, OutputT, InputT>,
+  name: string = `${codec.name} | undefined`
+): t.Type<TypeT | undefined, OutputT | undefined, InputT | undefined> {
+  return new t.Type(
+    name,
+    (u: unknown): u is TypeT | undefined => u === undefined || codec.is(u),
+    (u, c) => (u === undefined ? t.success(undefined) : codec.validate(u, c)),
+    (a) => (a === undefined ? undefined : codec.encode(a))
+  );
+}
+
+export function nullable<TypeT, OutputT, InputT>(
+  codec: t.Type<TypeT, OutputT, InputT>,
+  name: string = `${codec.name} | null`
+): t.Type<TypeT | null, OutputT | null, InputT | null> {
+  return new t.Type(
+    name,
+    (u: unknown): u is TypeT | null => u === null || codec.is(u),
+    (u, c) => (u === null ? t.success(null) : codec.validate(u, c)),
+    (a) => (a === null ? null : codec.encode(a))
+  );
+}

package/src/internal/util/jsonrpc.ts

@@ -0,0 +1,111 @@
+import { HardhatError } from "../core/errors";
+import { ERRORS } from "../core/errors-list";
+
+export interface JsonRpcRequest {
+  jsonrpc: string;
+  method: string;
+  params: any[];
+  id: number | string;
+}
+
+export interface SuccessfulJsonRpcResponse {
+  jsonrpc: string;
+  id: number | string;
+  result: any;
+}
+
+export interface FailedJsonRpcResponse {
+  jsonrpc: string;
+  id: number | string | null;
+  error: {
+    code: number;
+    message: string;
+    data?: any;
+  };
+}
+
+export type JsonRpcResponse = SuccessfulJsonRpcResponse | FailedJsonRpcResponse;
+
+export function parseJsonResponse(
+  text: string
+): JsonRpcResponse | JsonRpcResponse[] {
+  try {
+    const json = JSON.parse(text);
+
+    const responses = Array.isArray(json) ? json : [json];
+    for (const response of responses) {
+      if (!isValidJsonResponse(response)) {
+        // We are sending the proper error inside the catch part of the statement.
+        // We just need to raise anything here.
+        // eslint-disable-next-line @nomicfoundation/hardhat-internal-rules/only-hardhat-error
+        throw new Error();
+      }
+    }
+
+    return json;
+  } catch {
+    throw new HardhatError(ERRORS.NETWORK.INVALID_JSON_RESPONSE, {
+      response: text,
+    });
+  }
+}
+
+export function isValidJsonRequest(payload: any): boolean {
+  if (payload.jsonrpc !== "2.0") {
+    return false;
+  }
+
+  if (typeof payload.id !== "number" && typeof payload.id !== "string") {
+    return false;
+  }
+
+  if (typeof payload.method !== "string") {
+    return false;
+  }
+
+  if (payload.params !== undefined && !Array.isArray(payload.params)) {
+    return false;
+  }
+
+  return true;
+}
+
+export function isValidJsonResponse(payload: any) {
+  if (payload.jsonrpc !== "2.0") {
+    return false;
+  }
+
+  if (
+    typeof payload.id !== "number" &&
+    typeof payload.id !== "string" &&
+    payload.id !== null
+  ) {
+    return false;
+  }
+
+  if (payload.id === null && payload.error === undefined) {
+    return false;
+  }
+
+  if (payload.result === undefined && payload.error === undefined) {
+    return false;
+  }
+
+  if (payload.error !== undefined) {
+    if (typeof payload.error.code !== "number") {
+      return false;
+    }
+
+    if (typeof payload.error.message !== "string") {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+export function isSuccessfulJsonResponse(
+  payload: JsonRpcResponse
+): payload is SuccessfulJsonRpcResponse {
+  return "result" in payload;
+}

package/src/internal/util/keccak.ts

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

package/src/internal/util/keys-derivation.ts

@@ -0,0 +1,31 @@
+import type { mnemonicToSeedSync as mnemonicToSeedSyncT } from "ethereum-cryptography/bip39";
+import type { HDKey as HDKeyT } from "ethereum-cryptography/hdkey";
+
+export function deriveKeyFromMnemonicAndPath(
+  mnemonic: string,
+  hdPath: string,
+  passphrase: string
+): Buffer | undefined {
+  const {
+    mnemonicToSeedSync,
+  }: {
+    mnemonicToSeedSync: typeof mnemonicToSeedSyncT;
+  } = require("ethereum-cryptography/bip39");
+  // NOTE: If mnemonic has space or newline at the beginning or end, it will be trimmed.
+  // This is because mnemonic containing them may generate different private keys.
+  const trimmedMnemonic = mnemonic.trim();
+  const seed = mnemonicToSeedSync(trimmedMnemonic, passphrase);
+
+  const {
+    HDKey,
+  }: {
+    HDKey: typeof HDKeyT;
+  } = require("ethereum-cryptography/hdkey");
+
+  const masterKey = HDKey.fromMasterSeed(seed);
+  const derived = masterKey.derive(hdPath);
+
+  return derived.privateKey === null
+    ? undefined
+    : Buffer.from(derived.privateKey);
+}

package/src/internal/util/lang.ts

@@ -0,0 +1,21 @@
+export function fromEntries<T = any>(entries: Array<[string, any]>): T {
+  return Object.assign(
+    {},
+    ...entries.map(([name, value]) => ({
+      [name]: value,
+    }))
+  );
+}
+
+export function mapValues<T extends object, ResultT>(
+  o: T,
+  callback: (value: T[keyof T]) => ResultT[keyof ResultT]
+): ResultT {
+  const result: any = {};
+
+  for (const [key, value] of Object.entries(o)) {
+    result[key] = callback(value);
+  }
+
+  return result;
+}