hardhatjs 2.22.15

package/src/internal/core/jsonrpc/types/base-types.ts

@@ -0,0 +1,233 @@
+import {
+  bytesToHex as bufferToHex,
+  isValidAddress,
+  toBytes,
+} from "@nomicfoundation/ethereumjs-util";
+import * as t from "io-ts";
+
+import * as BigIntUtils from "../../../util/bigint";
+import { assertHardhatInvariant, HardhatError } from "../../errors";
+import { ERRORS } from "../../errors-list";
+
+const ADDRESS_LENGTH_BYTES = 20;
+const HASH_LENGTH_BYTES = 32;
+
+export const rpcQuantity = new t.Type<bigint>(
+  "QUANTITY",
+  BigIntUtils.isBigInt,
+  (u, c) => (isRpcQuantityString(u) ? t.success(BigInt(u)) : t.failure(u, c)),
+  t.identity
+);
+
+export const rpcData = new t.Type<Buffer>(
+  "DATA",
+  Buffer.isBuffer,
+  (u, c) =>
+    isRpcDataString(u) ? t.success(Buffer.from(toBytes(u))) : t.failure(u, c),
+  t.identity
+);
+
+export const rpcHash = new t.Type<Buffer>(
+  "HASH",
+  (v): v is Buffer => Buffer.isBuffer(v) && v.length === HASH_LENGTH_BYTES,
+  (u, c) =>
+    isRpcHashString(u) ? t.success(Buffer.from(toBytes(u))) : t.failure(u, c),
+  t.identity
+);
+
+export const rpcStorageSlot = new t.Type<bigint>(
+  "Storage slot",
+  BigIntUtils.isBigInt,
+  validateStorageSlot,
+  t.identity
+);
+
+// This type is necessary because objects' keys need to be either strings or numbers to be properly handled by the 'io-ts' module.
+// If they are not defined as strings or numbers, the type definition will result in an empty object without the required properties.
+// For example, instead of displaying { ke1: value1 }, it will display {}
+export const rpcStorageSlotHexString = new t.Type<string>(
+  "Storage slot hex string",
+  (x): x is string => typeof x === "string",
+  (u, c) =>
+    validateRpcStorageSlotHexString(u) ? t.success(u) : t.failure(u, c),
+  t.identity
+);
+
+function validateStorageSlot(u: unknown, c: t.Context): t.Validation<bigint> {
+  if (typeof u !== "string") {
+    return t.failure(
+      u,
+      c,
+      `Storage slot argument must be a string, got '${u as any}'`
+    );
+  }
+
+  if (u === "") {
+    return t.failure(u, c, "Storage slot argument cannot be an empty string");
+  }
+
+  if (u.startsWith("0x")) {
+    if (u.length > 66) {
+      return t.failure(
+        u,
+        c,
+        `Storage slot argument must have a length of at most 66 ("0x" + 32 bytes), but '${u}' has a length of ${u.length}`
+      );
+    }
+  } else {
+    if (u.length > 64) {
+      return t.failure(
+        u,
+        c,
+        `Storage slot argument must have a length of at most 64 (32 bytes), but '${u}' has a length of ${u.length}`
+      );
+    }
+  }
+
+  if (u.match(/^(0x)?([0-9a-fA-F]){0,64}$/) === null) {
+    return t.failure(
+      u,
+      c,
+      `Storage slot argument must be a valid hexadecimal, got '${u}'`
+    );
+  }
+
+  return t.success(u === "0x" ? 0n : BigInt(u.startsWith("0x") ? u : `0x${u}`));
+}
+
+export const rpcAddress = new t.Type<Buffer>(
+  "ADDRESS",
+  (v): v is Buffer => Buffer.isBuffer(v) && v.length === ADDRESS_LENGTH_BYTES,
+  (u, c) =>
+    isRpcAddressString(u)
+      ? t.success(Buffer.from(toBytes(u)))
+      : t.failure(u, c),
+  t.identity
+);
+
+export const rpcUnsignedInteger = new t.Type<number>(
+  "Unsigned integer",
+  isInteger,
+  (u, c) => (isInteger(u) && u >= 0 ? t.success(u) : t.failure(u, c)),
+  t.identity
+);
+
+export const rpcQuantityAsNumber = new t.Type<bigint>(
+  "Integer",
+  BigIntUtils.isBigInt,
+  (u, c) => (isInteger(u) ? t.success(BigInt(u)) : t.failure(u, c)),
+  t.identity
+);
+
+export const rpcFloat = new t.Type<number>(
+  "Float number",
+  isNumber,
+  (u, c) => (typeof u === "number" ? t.success(u) : t.failure(u, c)),
+  t.identity
+);
+
+// Conversion functions
+
+/**
+ * Transforms a QUANTITY into a number. It should only be used if you are 100% sure that the value
+ * fits in a number.
+ */
+export function rpcQuantityToNumber(quantity: string): number {
+  return Number(rpcQuantityToBigInt(quantity));
+}
+
+export function rpcQuantityToBigInt(quantity: string): bigint {
+  // We validate it in case a value gets here through a cast or any
+  if (!isRpcQuantityString(quantity)) {
+    throw new HardhatError(ERRORS.NETWORK.INVALID_RPC_QUANTITY_VALUE, {
+      value: quantity,
+    });
+  }
+
+  return BigInt(quantity);
+}
+
+export function numberToRpcQuantity(n: number | bigint): string {
+  assertHardhatInvariant(
+    typeof n === "number" || typeof n === "bigint",
+    "Expected number"
+  );
+
+  return `0x${n.toString(16)}`;
+}
+
+export function numberToRpcStorageSlot(n: number | bigint): string {
+  assertHardhatInvariant(
+    typeof n === "number" || typeof n === "bigint",
+    "Expected number"
+  );
+
+  return `0x${BigIntUtils.toEvmWord(n)}`;
+}
+
+/**
+ * Transforms a DATA into a number. It should only be used if you are 100% sure that the data
+ * represents a value fits in a number.
+ */
+export function rpcDataToNumber(data: string): number {
+  return Number(rpcDataToBigInt(data));
+}
+
+export function rpcDataToBigInt(data: string): bigint {
+  return data === "0x" ? 0n : BigInt(data);
+}
+
+export function bufferToRpcData(
+  buffer: Uint8Array,
+  padToBytes: number = 0
+): string {
+  let s = bufferToHex(buffer);
+  if (padToBytes > 0 && s.length < padToBytes * 2 + 2) {
+    s = `0x${"0".repeat(padToBytes * 2 + 2 - s.length)}${s.slice(2)}`;
+  }
+  return s;
+}
+
+export function rpcDataToBuffer(data: string): Buffer {
+  // We validate it in case a value gets here through a cast or any
+  if (!isRpcDataString(data)) {
+    throw new HardhatError(ERRORS.NETWORK.INVALID_RPC_DATA_VALUE, {
+      value: data,
+    });
+  }
+
+  return Buffer.from(toBytes(data));
+}
+
+// Type guards
+
+function validateRpcStorageSlotHexString(u: unknown): u is string {
+  return typeof u === "string" && /^0x([0-9a-fA-F]){64}$/.test(u);
+}
+
+function isRpcQuantityString(u: unknown): u is string {
+  return (
+    typeof u === "string" &&
+    u.match(/^0x(?:0|(?:[1-9a-fA-F][0-9a-fA-F]*))$/) !== null
+  );
+}
+
+function isRpcDataString(u: unknown): u is string {
+  return typeof u === "string" && u.match(/^0x(?:[0-9a-fA-F]{2})*$/) !== null;
+}
+
+function isRpcHashString(u: unknown): u is string {
+  return typeof u === "string" && u.length === 66 && isRpcDataString(u);
+}
+
+function isRpcAddressString(u: unknown): u is string {
+  return typeof u === "string" && isValidAddress(u);
+}
+
+function isInteger(num: unknown): num is number {
+  return Number.isInteger(num);
+}
+
+function isNumber(num: unknown): num is number {
+  return typeof num === "number";
+}

package/src/internal/core/jsonrpc/types/input/blockTag.ts

@@ -0,0 +1,44 @@
+import * as t from "io-ts";
+
+import { optionalOrNullable } from "../../../../util/io-ts";
+import { rpcData, rpcQuantity } from "../base-types";
+
+export const rpcNewBlockTagObjectWithNumber = t.type({
+  blockNumber: rpcQuantity,
+});
+
+export const rpcNewBlockTagObjectWithHash = t.type({
+  blockHash: rpcData,
+  requireCanonical: optionalOrNullable(t.boolean),
+});
+
+export const rpcBlockTagName = t.keyof({
+  earliest: null,
+  latest: null,
+  pending: null,
+  safe: null,
+  finalized: null,
+});
+
+// This is the new kind of block tag as defined by https://github.com/ethereum/EIPs/blob/master/EIPS/eip-1898.md
+export const rpcNewBlockTag = t.union([
+  rpcQuantity,
+  rpcNewBlockTagObjectWithNumber,
+  rpcNewBlockTagObjectWithHash,
+  rpcBlockTagName,
+]);
+
+export type RpcNewBlockTag = t.TypeOf<typeof rpcNewBlockTag>;
+
+export const optionalRpcNewBlockTag = optionalOrNullable(rpcNewBlockTag);
+
+export type OptionalRpcNewBlockTag = t.TypeOf<typeof optionalRpcNewBlockTag>;
+
+// This is the old kind of block tag which is described in the ethereum wiki
+export const rpcOldBlockTag = t.union([rpcQuantity, rpcBlockTagName]);
+
+export type RpcOldBlockTag = t.TypeOf<typeof rpcOldBlockTag>;
+
+export const optionalRpcOldBlockTag = optionalOrNullable(rpcOldBlockTag);
+
+export type OptionalRpcOldBlockTag = t.TypeOf<typeof optionalRpcOldBlockTag>;

package/src/internal/core/jsonrpc/types/input/callRequest.ts

@@ -0,0 +1,60 @@
+import * as t from "io-ts";
+
+import { optionalOrNullable } from "../../../../util/io-ts";
+import { rpcAccessList } from "../access-list";
+import {
+  rpcAddress,
+  rpcData,
+  rpcHash,
+  rpcQuantity,
+  rpcStorageSlot,
+  rpcStorageSlotHexString,
+} from "../base-types";
+import { address } from "../../../config/config-validation";
+
+// Type used by eth_call and eth_estimateGas
+export const rpcCallRequest = t.type(
+  {
+    from: optionalOrNullable(rpcAddress),
+    to: optionalOrNullable(rpcAddress),
+    gas: optionalOrNullable(rpcQuantity),
+    gasPrice: optionalOrNullable(rpcQuantity),
+    value: optionalOrNullable(rpcQuantity),
+    data: optionalOrNullable(rpcData),
+    accessList: optionalOrNullable(rpcAccessList),
+    maxFeePerGas: optionalOrNullable(rpcQuantity),
+    maxPriorityFeePerGas: optionalOrNullable(rpcQuantity),
+    blobs: optionalOrNullable(t.array(rpcData)),
+    blobVersionedHashes: optionalOrNullable(t.array(rpcHash)),
+  },
+  "RpcCallRequest"
+);
+
+export type RpcCallRequest = t.TypeOf<typeof rpcCallRequest>;
+
+// Types used by eth_call to configure the state override set
+export const stateProperties = t.record(
+  rpcStorageSlotHexString,
+  rpcStorageSlot
+);
+
+export const stateOverrideOptions = t.type(
+  {
+    balance: optionalOrNullable(rpcQuantity),
+    nonce: optionalOrNullable(rpcQuantity),
+    code: optionalOrNullable(rpcData),
+    state: optionalOrNullable(stateProperties),
+    stateDiff: optionalOrNullable(stateProperties),
+  },
+  "stateOverrideOptions"
+);
+
+export const stateOverrideSet = t.record(address, stateOverrideOptions);
+export const optionalStateOverrideSet = optionalOrNullable(stateOverrideSet);
+
+export type StateProperties = t.TypeOf<typeof stateProperties>;
+export type StateOverrideOptions = t.TypeOf<typeof stateOverrideOptions>;
+export type StateOverrideSet = t.TypeOf<typeof stateOverrideSet>;
+export type OptionalStateOverrideSet = t.TypeOf<
+  typeof optionalStateOverrideSet
+>;

package/src/internal/core/jsonrpc/types/input/debugTraceTransaction.ts

@@ -0,0 +1,17 @@
+import * as t from "io-ts";
+
+import { optionalOrNullable } from "../../../../util/io-ts";
+
+export const rpcDebugTracingConfig = optionalOrNullable(
+  t.type(
+    {
+      tracer: optionalOrNullable(t.string),
+      disableStorage: optionalOrNullable(t.boolean),
+      disableMemory: optionalOrNullable(t.boolean),
+      disableStack: optionalOrNullable(t.boolean),
+    },
+    "RpcDebugTracingConfig"
+  )
+);
+
+export type RpcDebugTracingConfig = t.TypeOf<typeof rpcDebugTracingConfig>;

package/src/internal/core/jsonrpc/types/input/filterRequest.ts

@@ -0,0 +1,27 @@
+import * as t from "io-ts";
+
+import { optionalOrNullable } from "../../../../util/io-ts";
+import { rpcHash } from "../base-types";
+
+import { optionalRpcOldBlockTag } from "./blockTag";
+import { optionalRpcLogAddress } from "./logAddress";
+import { optionalRpcLogTopics } from "./logTopics";
+
+export const rpcFilterRequest = t.type(
+  {
+    fromBlock: optionalRpcOldBlockTag,
+    toBlock: optionalRpcOldBlockTag,
+    address: optionalRpcLogAddress,
+    topics: optionalRpcLogTopics,
+    blockHash: optionalOrNullable(rpcHash),
+  },
+  "RpcFilterRequest"
+);
+
+export type RpcFilterRequest = t.TypeOf<typeof rpcFilterRequest>;
+
+export const optionalRpcFilterRequest = optionalOrNullable(rpcFilterRequest);
+
+export type OptionalRpcFilterRequest = t.TypeOf<
+  typeof optionalRpcFilterRequest
+>;

package/src/internal/core/jsonrpc/types/input/hardhat-network.ts

@@ -0,0 +1,54 @@
+import * as t from "io-ts";
+
+import { optional } from "../../../../util/io-ts";
+import { rpcUnsignedInteger } from "../base-types";
+
+export const rpcForkConfig = optional(
+  t.type(
+    {
+      jsonRpcUrl: t.string,
+      blockNumber: optional(t.number),
+      httpHeaders: optional(t.record(t.string, t.string, "httpHeaders")),
+    },
+    "RpcForkConfig"
+  )
+);
+
+export type RpcForkConfig = t.TypeOf<typeof rpcForkConfig>;
+
+export const rpcHardhatNetworkConfig = t.type(
+  {
+    forking: optional(rpcForkConfig),
+  },
+  "HardhatNetworkConfig"
+);
+
+export type RpcHardhatNetworkConfig = t.TypeOf<typeof rpcHardhatNetworkConfig>;
+
+export const optionalRpcHardhatNetworkConfig = optional(
+  rpcHardhatNetworkConfig
+);
+
+const isNumberPair = (x: unknown): x is [number, number] =>
+  Array.isArray(x) &&
+  x.length === 2 &&
+  Number.isInteger(x[0]) &&
+  Number.isInteger(x[1]);
+
+// TODO: This can be simplified
+const rpcIntervalMiningRange = new t.Type<[number, number]>(
+  "Interval mining range",
+  isNumberPair,
+  (u, c) =>
+    isNumberPair(u) && u[0] >= 0 && u[1] >= u[0]
+      ? t.success(u)
+      : t.failure(u, c),
+  t.identity
+);
+
+export const rpcIntervalMining = t.union([
+  rpcUnsignedInteger,
+  rpcIntervalMiningRange,
+]);
+
+export type RpcIntervalMining = t.TypeOf<typeof rpcIntervalMining>;

package/src/internal/core/jsonrpc/types/input/logAddress.ts

@@ -0,0 +1,12 @@
+import * as t from "io-ts";
+
+import { optionalOrNullable } from "../../../../util/io-ts";
+import { rpcAddress } from "../base-types";
+
+export const rpcLogAddress = t.union([rpcAddress, t.array(rpcAddress)]);
+
+export type RpcLogAddress = t.TypeOf<typeof rpcLogAddress>;
+
+export const optionalRpcLogAddress = optionalOrNullable(rpcLogAddress);
+
+export type OptionalRpcLogAddress = t.TypeOf<typeof optionalRpcLogAddress>;

package/src/internal/core/jsonrpc/types/input/logTopics.ts

@@ -0,0 +1,14 @@
+import * as t from "io-ts";
+
+import { optionalOrNullable } from "../../../../util/io-ts";
+import { rpcHash } from "../base-types";
+
+export const rpcLogTopics = t.array(
+  t.union([t.null, rpcHash, t.array(t.union([t.null, rpcHash]))])
+);
+
+export type RpcLogTopics = t.TypeOf<typeof rpcLogTopics>;
+
+export const optionalRpcLogTopics = optionalOrNullable(rpcLogTopics);
+
+export type OptionalRpcLogTopics = t.TypeOf<typeof optionalRpcLogTopics>;

package/src/internal/core/jsonrpc/types/input/solc.ts

@@ -0,0 +1,22 @@
+import * as t from "io-ts";
+
+export const rpcCompilerInput = t.type(
+  {
+    language: t.string,
+    sources: t.any,
+    settings: t.any,
+  },
+  "RpcCompilerInput"
+);
+
+export type RpcCompilerInput = t.TypeOf<typeof rpcCompilerInput>;
+
+export const rpcCompilerOutput = t.type(
+  {
+    sources: t.any,
+    contracts: t.any,
+  },
+  "RpcCompilerOutput"
+);
+
+export type RpcCompilerOutput = t.TypeOf<typeof rpcCompilerOutput>;

package/src/internal/core/jsonrpc/types/input/subscribeRequest.ts

@@ -0,0 +1,21 @@
+import * as t from "io-ts";
+
+import { RpcFilterRequest } from "./filterRequest";
+
+// TODO: This types are incorrect. See: https://geth.ethereum.org/docs/rpc/pubsub
+// Actually, the logs filter is not of the same type as eth_newFilter
+
+export interface RpcSubscribe {
+  request: RpcFilterRequest;
+}
+
+export type RpcSubscribeRequest = t.TypeOf<typeof rpcSubscribeRequest>;
+
+export const rpcSubscribeRequest = t.keyof(
+  {
+    newHeads: null,
+    newPendingTransactions: null,
+    logs: null,
+  },
+  "RpcSubscribe"
+);

package/src/internal/core/jsonrpc/types/input/transactionRequest.ts

@@ -0,0 +1,47 @@
+import * as t from "io-ts";
+
+import { optionalOrNullable } from "../../../../util/io-ts";
+import { rpcAccessList } from "../access-list";
+import { rpcAddress, rpcData, rpcHash, rpcQuantity } from "../base-types";
+
+// Type used by eth_sendTransaction
+export const rpcTransactionRequest = t.type(
+  {
+    from: rpcAddress,
+    to: optionalOrNullable(rpcAddress),
+    gas: optionalOrNullable(rpcQuantity),
+    gasPrice: optionalOrNullable(rpcQuantity),
+    value: optionalOrNullable(rpcQuantity),
+    nonce: optionalOrNullable(rpcQuantity),
+    data: optionalOrNullable(rpcData),
+    accessList: optionalOrNullable(rpcAccessList),
+    chainId: optionalOrNullable(rpcQuantity),
+    maxFeePerGas: optionalOrNullable(rpcQuantity),
+    maxPriorityFeePerGas: optionalOrNullable(rpcQuantity),
+    blobs: optionalOrNullable(t.array(rpcData)),
+    blobVersionedHashes: optionalOrNullable(t.array(rpcHash)),
+  },
+  "RpcTransactionRequest"
+);
+
+// This type represents possibly valid inputs to rpcTransactionRequest.
+// TODO: It can probably be inferred by io-ts.
+export interface RpcTransactionRequestInput {
+  from: string;
+  to?: string;
+  gas?: string;
+  gasPrice?: string;
+  value?: string;
+  nonce?: string;
+  data?: string;
+  accessList?: Array<{
+    address: string;
+    storageKeys: string[];
+  }>;
+  maxFeePerGas?: string;
+  maxPriorityFeePerGas?: string;
+  blobs?: string[];
+  blobVersionedHashes?: string[];
+}
+
+export type RpcTransactionRequest = t.TypeOf<typeof rpcTransactionRequest>;

package/src/internal/core/jsonrpc/types/input/validation.ts

@@ -0,0 +1,75 @@
+import * as t from "io-ts";
+import { PathReporter } from "io-ts/lib/PathReporter";
+
+import { InvalidArgumentsError } from "../../../providers/errors";
+
+/* eslint-disable @nomicfoundation/hardhat-internal-rules/only-hardhat-error */
+
+/**
+ * This function validates a list of params, throwing InvalidArgumentsError
+ * if the validation fails, and returning their already-parsed types if
+ * the validation succeeds.
+ *
+ * TODO: The type can probably be improved, removing the anys
+ */
+export function validateParams<
+  TypesT extends ReadonlyArray<t.Type<any, any, any>>
+>(
+  params: any[],
+  ...types: TypesT
+): {
+  [i in keyof TypesT]: TypesT[i] extends t.Type<infer TypeT, any, any>
+    ? TypeT
+    : never;
+} {
+  if (types === undefined && params.length > 0) {
+    throw new InvalidArgumentsError(
+      `No argument was expected and got ${params.length}`
+    );
+  }
+
+  let optionalParams = 0;
+  for (let i = types.length - 1; i >= 0; i--) {
+    if (types[i].is(undefined)) {
+      optionalParams += 1;
+    } else {
+      break;
+    }
+  }
+
+  if (optionalParams === 0) {
+    if (params.length !== types.length) {
+      throw new InvalidArgumentsError(
+        `Expected exactly ${types.length} arguments and got ${params.length}`
+      );
+    }
+  } else {
+    if (
+      params.length > types.length ||
+      params.length < types.length - optionalParams
+    ) {
+      throw new InvalidArgumentsError(
+        `Expected between ${types.length - optionalParams} and ${
+          types.length
+        } arguments and got ${params.length}`
+      );
+    }
+  }
+
+  const decoded: any[] = [];
+  for (let i = 0; i < types.length; i++) {
+    const result = types[i].decode(params[i]);
+
+    if (result.isLeft()) {
+      throw new InvalidArgumentsError(
+        `Errors encountered in param ${i}: ${PathReporter.report(result).join(
+          ", "
+        )}`
+      );
+    }
+
+    decoded.push(result.value);
+  }
+
+  return decoded as any;
+}