hardhatjs 2.22.15

package/src/internal/core/jsonrpc/types/output/block.ts

@@ -0,0 +1,66 @@
+import * as t from "io-ts";
+
+import { nullable, optional } from "../../../../util/io-ts";
+import { rpcAddress, rpcData, rpcHash, rpcQuantity } from "../base-types";
+
+import { rpcTransaction } from "./transaction";
+
+const rpcWithdrawalItem = t.type(
+  {
+    index: rpcQuantity,
+    validatorIndex: rpcQuantity,
+    address: rpcAddress,
+    amount: rpcQuantity,
+  },
+  "RpcBlockWithdrawalItem"
+);
+
+const baseBlockResponse = {
+  number: nullable(rpcQuantity),
+  hash: nullable(rpcHash),
+  parentHash: rpcHash,
+  nonce: optional(rpcData),
+  sha3Uncles: rpcHash,
+  logsBloom: rpcData,
+  transactionsRoot: rpcHash,
+  stateRoot: rpcHash,
+  receiptsRoot: rpcHash,
+  miner: rpcAddress,
+  difficulty: rpcQuantity,
+  totalDifficulty: rpcQuantity,
+  extraData: rpcData,
+  size: rpcQuantity,
+  gasLimit: rpcQuantity,
+  gasUsed: rpcQuantity,
+  timestamp: rpcQuantity,
+  uncles: t.array(rpcHash, "HASH Array"),
+  mixHash: optional(rpcHash),
+  baseFeePerGas: optional(rpcQuantity),
+  withdrawals: optional(t.array(rpcWithdrawalItem)),
+  withdrawalsRoot: optional(rpcHash),
+  parentBeaconBlockRoot: optional(rpcHash),
+  blobGasUsed: optional(rpcQuantity),
+  excessBlobGas: optional(rpcQuantity),
+};
+
+export type RpcBlock = t.TypeOf<typeof rpcBlock>;
+
+export const rpcBlock = t.type(
+  {
+    ...baseBlockResponse,
+    transactions: t.array(rpcHash, "HASH Array"),
+  },
+  "RpcBlock"
+);
+
+export type RpcBlockWithTransactions = t.TypeOf<
+  typeof rpcBlockWithTransactions
+>;
+
+export const rpcBlockWithTransactions = t.type(
+  {
+    ...baseBlockResponse,
+    transactions: t.array(rpcTransaction, "RpcTransaction Array"),
+  },
+  "RpcBlockWithTransactions"
+);

package/src/internal/core/jsonrpc/types/output/decodeJsonRpcResponse.ts

@@ -0,0 +1,23 @@
+import * as t from "io-ts";
+import { PathReporter } from "io-ts/lib/PathReporter";
+
+import { InvalidResponseError } from "../../../providers/errors";
+
+/* eslint-disable @nomicfoundation/hardhat-internal-rules/only-hardhat-error */
+
+/**
+ * This function decodes an RPC out type, throwing InvalidResponseError if it's not valid.
+ */
+export function decodeJsonRpcResponse<T>(value: unknown, codec: t.Type<T>): T {
+  const result = codec.decode(value);
+
+  if (result.isLeft()) {
+    throw new InvalidResponseError(
+      `Invalid JSON-RPC response's result.
+
+Errors: ${PathReporter.report(result).join(", ")}`
+    );
+  }
+
+  return result.value;
+}

package/src/internal/core/jsonrpc/types/output/log.ts

@@ -0,0 +1,19 @@
+import * as t from "io-ts";
+
+import { nullable } from "../../../../util/io-ts";
+import { rpcAddress, rpcData, rpcHash, rpcQuantity } from "../base-types";
+
+export type RpcLog = t.TypeOf<typeof rpcLog>;
+export const rpcLog = t.type(
+  {
+    logIndex: nullable(rpcQuantity),
+    transactionIndex: nullable(rpcQuantity),
+    transactionHash: nullable(rpcHash),
+    blockHash: nullable(rpcHash),
+    blockNumber: nullable(rpcQuantity),
+    address: rpcAddress,
+    data: rpcData,
+    topics: t.array(rpcData, "RpcData Array"),
+  },
+  "RpcLog"
+);

package/src/internal/core/jsonrpc/types/output/metadata.ts

@@ -0,0 +1,32 @@
+export interface HardhatMetadata {
+  // A string identifying the version of Hardhat, for debugging purposes,
+  // not meant to be displayed to users.
+  clientVersion: string;
+
+  // The chain's id. Used to sign transactions.
+  chainId: number;
+
+  // A 0x-prefixed hex-encoded 32 bytes id which uniquely identifies an instance/run
+  // of Hardhat Network. Running Hardhat Network more than once (even with the same version
+  // and parameters) will always result in different `instanceId`s.
+  // Running `hardhat_reset` will change the `instanceId` of an existing Hardhat Network.
+  instanceId: string;
+
+  // The latest block's number in Hardhat Network
+  latestBlockNumber: number;
+
+  // The latest block's hash in Hardhat Network
+  latestBlockHash: string;
+
+  // This field is only present when Hardhat Network is forking another chain.
+  forkedNetwork?: {
+    // The chainId of the network that is being forked
+    chainId: number;
+
+    // The number of the block that the network forked from.
+    forkBlockNumber: number;
+
+    // The hash of the block that the network forked from.
+    forkBlockHash: string;
+  };
+}

package/src/internal/core/jsonrpc/types/output/receipt.ts

@@ -0,0 +1,38 @@
+import * as t from "io-ts";
+
+import { nullable, optional } from "../../../../util/io-ts";
+import {
+  rpcAddress,
+  rpcData,
+  rpcHash,
+  rpcQuantity,
+  rpcQuantityAsNumber,
+} from "../base-types";
+
+import { rpcLog } from "./log";
+
+export type RpcTransactionReceipt = t.TypeOf<typeof rpcTransactionReceipt>;
+export const rpcTransactionReceipt = t.type(
+  {
+    transactionHash: rpcHash,
+    transactionIndex: rpcQuantity,
+    blockHash: rpcHash,
+    blockNumber: rpcQuantity,
+    from: rpcAddress,
+    to: nullable(rpcAddress),
+    cumulativeGasUsed: rpcQuantity,
+    gasUsed: rpcQuantity,
+    contractAddress: nullable(rpcAddress),
+    logs: t.array(rpcLog, "RpcLog Array"),
+    logsBloom: rpcData,
+    // This should be just optional, but Alchemy returns null
+    //
+    // It shouldn't accept a number, but that's what Erigon returns.
+    // See: https://github.com/ledgerwatch/erigon/issues/2288
+    status: optional(nullable(t.union([rpcQuantity, rpcQuantityAsNumber]))),
+    root: optional(rpcData),
+    type: optional(rpcQuantity),
+    effectiveGasPrice: optional(rpcQuantity),
+  },
+  "RpcTransactionReceipt"
+);

package/src/internal/core/jsonrpc/types/output/transaction.ts

@@ -0,0 +1,36 @@
+import * as t from "io-ts";
+
+import { nullable, optional } from "../../../../util/io-ts";
+import { rpcAccessList } from "../access-list";
+import { rpcAddress, rpcData, rpcHash, rpcQuantity } from "../base-types";
+
+export type RpcTransaction = t.TypeOf<typeof rpcTransaction>;
+export const rpcTransaction = t.type(
+  {
+    blockHash: nullable(rpcHash),
+    blockNumber: nullable(rpcQuantity),
+    from: rpcAddress,
+    gas: rpcQuantity,
+    gasPrice: rpcQuantity, // NOTE: Its meaning was changed by EIP-1559
+    hash: rpcHash,
+    input: rpcData,
+    nonce: rpcQuantity,
+    // This is also optional because Alchemy doesn't return to for deployment txs
+    to: optional(nullable(rpcAddress)),
+    transactionIndex: nullable(rpcQuantity),
+    value: rpcQuantity,
+    v: rpcQuantity,
+    r: rpcQuantity,
+    s: rpcQuantity,
+
+    // EIP-2929/2930 properties
+    type: optional(rpcQuantity),
+    chainId: optional(nullable(rpcQuantity)),
+    accessList: optional(rpcAccessList),
+
+    // EIP-1559 properties
+    maxFeePerGas: optional(rpcQuantity),
+    maxPriorityFeePerGas: optional(rpcQuantity),
+  },
+  "RpcTransaction"
+);

package/src/internal/core/params/argumentTypes.ts

@@ -0,0 +1,327 @@
+import * as fs from "fs";
+import fsExtra from "fs-extra";
+
+import { ArgumentType, CLIArgumentType } from "../../../types";
+import { HardhatError } from "../errors";
+import { ERRORS } from "../errors-list";
+
+/**
+ * String type.
+ *
+ * Accepts any kind of string.
+ */
+export const string: CLIArgumentType<string> = {
+  name: "string",
+  parse: (argName, strValue) => strValue,
+  /**
+   * Check if argument value is of type "string"
+   *
+   * @param argName {string} argument's name - used for context in case of error.
+   * @param value {any} argument's value to validate.
+   *
+   * @throws HH301 if value is not of type "string"
+   */
+  validate: (argName: string, value: any): void => {
+    const isString = typeof value === "string";
+
+    if (!isString) {
+      throw new HardhatError(ERRORS.ARGUMENTS.INVALID_VALUE_FOR_TYPE, {
+        value,
+        name: argName,
+        type: string.name,
+      });
+    }
+  },
+};
+
+/**
+ * Boolean type.
+ *
+ * Accepts only 'true' or 'false' (case-insensitive).
+ * @throws HH301
+ */
+export const boolean: CLIArgumentType<boolean> = {
+  name: "boolean",
+  parse: (argName, strValue) => {
+    if (strValue.toLowerCase() === "true") {
+      return true;
+    }
+    if (strValue.toLowerCase() === "false") {
+      return false;
+    }
+
+    throw new HardhatError(ERRORS.ARGUMENTS.INVALID_VALUE_FOR_TYPE, {
+      value: strValue,
+      name: argName,
+      type: "boolean",
+    });
+  },
+  /**
+   * Check if argument value is of type "boolean"
+   *
+   * @param argName {string} argument's name - used for context in case of error.
+   * @param value {any} argument's value to validate.
+   *
+   * @throws HH301 if value is not of type "boolean"
+   */
+  validate: (argName: string, value: any): void => {
+    const isBoolean = typeof value === "boolean";
+
+    if (!isBoolean) {
+      throw new HardhatError(ERRORS.ARGUMENTS.INVALID_VALUE_FOR_TYPE, {
+        value,
+        name: argName,
+        type: boolean.name,
+      });
+    }
+  },
+};
+
+/**
+ * Int type.
+ * Accepts either a decimal string integer or hexadecimal string integer.
+ * @throws HH301
+ */
+export const int: CLIArgumentType<number> = {
+  name: "int",
+  parse: (argName, strValue) => {
+    const decimalPattern = /^\d+(?:[eE]\d+)?$/;
+    const hexPattern = /^0[xX][\dABCDEabcde]+$/;
+
+    if (
+      strValue.match(decimalPattern) === null &&
+      strValue.match(hexPattern) === null
+    ) {
+      throw new HardhatError(ERRORS.ARGUMENTS.INVALID_VALUE_FOR_TYPE, {
+        value: strValue,
+        name: argName,
+        type: int.name,
+      });
+    }
+
+    return Number(strValue);
+  },
+  /**
+   * Check if argument value is of type "int"
+   *
+   * @param argName {string} argument's name - used for context in case of error.
+   * @param value {any} argument's value to validate.
+   *
+   * @throws HH301 if value is not of type "int"
+   */
+  validate: (argName: string, value: any): void => {
+    const isInt = Number.isInteger(value);
+    if (!isInt) {
+      throw new HardhatError(ERRORS.ARGUMENTS.INVALID_VALUE_FOR_TYPE, {
+        value,
+        name: argName,
+        type: int.name,
+      });
+    }
+  },
+};
+
+/**
+ * BigInt type.
+ * Accepts either a decimal string integer or hexadecimal string integer.
+ * @throws HH301
+ */
+export const bigint: CLIArgumentType<bigint> = {
+  name: "bigint",
+  parse: (argName, strValue) => {
+    const decimalPattern = /^\d+(?:n)?$/;
+    const hexPattern = /^0[xX][\dABCDEabcde]+$/;
+
+    if (
+      strValue.match(decimalPattern) === null &&
+      strValue.match(hexPattern) === null
+    ) {
+      throw new HardhatError(ERRORS.ARGUMENTS.INVALID_VALUE_FOR_TYPE, {
+        value: strValue,
+        name: argName,
+        type: bigint.name,
+      });
+    }
+
+    return BigInt(strValue.replace("n", ""));
+  },
+  /**
+   * Check if argument value is of type "bigint".
+   *
+   * @param argName {string} argument's name - used for context in case of error.
+   * @param value {any} argument's value to validate.
+   *
+   * @throws HH301 if value is not of type "bigint"
+   */
+  validate: (argName: string, value: any): void => {
+    const isBigInt = typeof value === "bigint";
+    if (!isBigInt) {
+      throw new HardhatError(ERRORS.ARGUMENTS.INVALID_VALUE_FOR_TYPE, {
+        value,
+        name: argName,
+        type: bigint.name,
+      });
+    }
+  },
+};
+
+/**
+ * Float type.
+ * Accepts either a decimal string number or hexadecimal string number.
+ * @throws HH301
+ */
+export const float: CLIArgumentType<number> = {
+  name: "float",
+  parse: (argName, strValue) => {
+    const decimalPattern = /^(?:\d+(?:\.\d*)?|\.\d+)(?:[eE]\d+)?$/;
+    const hexPattern = /^0[xX][\dABCDEabcde]+$/;
+
+    if (
+      strValue.match(decimalPattern) === null &&
+      strValue.match(hexPattern) === null
+    ) {
+      throw new HardhatError(ERRORS.ARGUMENTS.INVALID_VALUE_FOR_TYPE, {
+        value: strValue,
+        name: argName,
+        type: float.name,
+      });
+    }
+
+    return Number(strValue);
+  },
+  /**
+   * Check if argument value is of type "float".
+   * Both decimal and integer number values are valid.
+   *
+   * @param argName {string} argument's name - used for context in case of error.
+   * @param value {any} argument's value to validate.
+   *
+   * @throws HH301 if value is not of type "number"
+   */
+  validate: (argName: string, value: any): void => {
+    const isFloatOrInteger = typeof value === "number" && !isNaN(value);
+
+    if (!isFloatOrInteger) {
+      throw new HardhatError(ERRORS.ARGUMENTS.INVALID_VALUE_FOR_TYPE, {
+        value,
+        name: argName,
+        type: float.name,
+      });
+    }
+  },
+};
+
+/**
+ * Input file type.
+ * Accepts a path to a readable file..
+ * @throws HH302
+ */
+export const inputFile: CLIArgumentType<string> = {
+  name: "inputFile",
+  parse(argName: string, strValue: string): string {
+    try {
+      fs.accessSync(strValue, fsExtra.constants.R_OK);
+      const stats = fs.lstatSync(strValue);
+
+      if (stats.isDirectory()) {
+        // This is caught and encapsulated in a hardhat error.
+        // eslint-disable-next-line @nomicfoundation/hardhat-internal-rules/only-hardhat-error
+        throw new Error(`${strValue} is a directory, not a file`);
+      }
+    } catch (error) {
+      if (error instanceof Error) {
+        throw new HardhatError(
+          ERRORS.ARGUMENTS.INVALID_INPUT_FILE,
+          {
+            name: argName,
+            value: strValue,
+          },
+          error
+        );
+      }
+
+      // eslint-disable-next-line @nomicfoundation/hardhat-internal-rules/only-hardhat-error
+      throw error;
+    }
+
+    return strValue;
+  },
+
+  /**
+   * Check if argument value is of type "inputFile"
+   * File string validation succeeds if it can be parsed, ie. is a valid accessible file dir
+   *
+   * @param argName {string} argument's name - used for context in case of error.
+   * @param value {any} argument's value to validate.
+   *
+   * @throws HH301 if value is not of type "inputFile"
+   */
+  validate: (argName: string, value: any): void => {
+    try {
+      inputFile.parse(argName, value);
+    } catch (error) {
+      // the input value is considered invalid, throw error.
+      if (error instanceof Error) {
+        throw new HardhatError(
+          ERRORS.ARGUMENTS.INVALID_VALUE_FOR_TYPE,
+          {
+            value,
+            name: argName,
+            type: inputFile.name,
+          },
+          error
+        );
+      }
+
+      // eslint-disable-next-line @nomicfoundation/hardhat-internal-rules/only-hardhat-error
+      throw error;
+    }
+  },
+};
+
+export const json: CLIArgumentType<any> = {
+  name: "json",
+  parse(argName: string, strValue: string): any {
+    try {
+      return JSON.parse(strValue);
+    } catch (error) {
+      if (error instanceof Error) {
+        throw new HardhatError(
+          ERRORS.ARGUMENTS.INVALID_JSON_ARGUMENT,
+          {
+            param: argName,
+            error: error.message,
+          },
+          error
+        );
+      }
+
+      // eslint-disable-next-line @nomicfoundation/hardhat-internal-rules/only-hardhat-error
+      throw error;
+    }
+  },
+
+  /**
+   * Check if argument value is of type "json". We consider everything except
+   * undefined to be json.
+   *
+   * @param argName {string} argument's name - used for context in case of error.
+   * @param value {any} argument's value to validate.
+   *
+   * @throws HH301 if value is not of type "json"
+   */
+  validate: (argName: string, value: any): void => {
+    if (value === undefined) {
+      throw new HardhatError(ERRORS.ARGUMENTS.INVALID_VALUE_FOR_TYPE, {
+        value,
+        name: argName,
+        type: json.name,
+      });
+    }
+  },
+};
+
+export const any: ArgumentType<any> = {
+  name: "any",
+  validate(_argName: string, _argumentValue: any) {},
+};

package/src/internal/core/params/env-variables.ts

@@ -0,0 +1,72 @@
+import ProcessEnv = NodeJS.ProcessEnv;
+
+import { HardhatArguments, HardhatParamDefinitions } from "../../../types";
+import { ArgumentsParser } from "../../cli/ArgumentsParser";
+import { unsafeObjectKeys } from "../../util/unsafe";
+import { HardhatError } from "../errors";
+import { ERRORS } from "../errors-list";
+
+const HARDHAT_ENV_ARGUMENT_PREFIX = "HARDHAT_";
+
+export function paramNameToEnvVariable(paramName: string): string {
+  // We create it starting from the result of ArgumentsParser.paramNameToCLA
+  // so it's easier to explain and understand their equivalences.
+  return ArgumentsParser.paramNameToCLA(paramName)
+    .replace(ArgumentsParser.PARAM_PREFIX, HARDHAT_ENV_ARGUMENT_PREFIX)
+    .replace(/-/g, "_")
+    .toUpperCase();
+}
+
+export function getEnvVariablesMap(hardhatArguments: HardhatArguments): {
+  [envVar: string]: string;
+} {
+  const values: { [envVar: string]: string } = {};
+
+  for (const [name, value] of Object.entries(hardhatArguments)) {
+    if (value === undefined) {
+      continue;
+    }
+
+    values[paramNameToEnvVariable(name)] = value.toString();
+  }
+
+  return values;
+}
+
+export function getEnvHardhatArguments(
+  paramDefinitions: HardhatParamDefinitions,
+  envVariables: ProcessEnv
+): HardhatArguments {
+  const envArgs: any = {};
+
+  for (const paramName of unsafeObjectKeys(paramDefinitions)) {
+    const definition = paramDefinitions[paramName];
+    const envVarName = paramNameToEnvVariable(paramName);
+    const rawValue = envVariables[envVarName];
+
+    if (rawValue !== undefined) {
+      try {
+        envArgs[paramName] = definition.type.parse(paramName, rawValue);
+      } catch (error) {
+        if (error instanceof Error) {
+          throw new HardhatError(
+            ERRORS.ARGUMENTS.INVALID_ENV_VAR_VALUE,
+            {
+              varName: envVarName,
+              value: rawValue,
+            },
+            error
+          );
+        }
+
+        // eslint-disable-next-line @nomicfoundation/hardhat-internal-rules/only-hardhat-error
+        throw error;
+      }
+    } else {
+      envArgs[paramName] = definition.defaultValue;
+    }
+  }
+
+  // TODO: This is a little type-unsafe, but we know we have all the needed arguments
+  return envArgs as HardhatArguments;
+}