hardhatjs 2.22.15

package/src/internal/hardhat-network/jsonrpc/handler.ts

@@ -0,0 +1,288 @@
+import { IncomingMessage, ServerResponse } from "http";
+import getRawBody from "raw-body";
+import WebSocket from "ws";
+import { JsonStreamStringify } from "json-stream-stringify";
+
+import { EIP1193Provider } from "../../../types";
+import {
+  InternalError,
+  InvalidJsonInputError,
+  InvalidRequestError,
+  ProviderError,
+} from "../../core/providers/errors";
+import {
+  FailedJsonRpcResponse,
+  isSuccessfulJsonResponse,
+  isValidJsonRequest,
+  isValidJsonResponse,
+  JsonRpcRequest,
+  JsonRpcResponse,
+} from "../../util/jsonrpc";
+
+/* eslint-disable @nomicfoundation/hardhat-internal-rules/only-hardhat-error */
+
+export class JsonRpcHandler {
+  constructor(private readonly _provider: EIP1193Provider) {}
+
+  public handleHttp = async (req: IncomingMessage, res: ServerResponse) => {
+    this._setCorsHeaders(res);
+    if (req.method === "OPTIONS") {
+      this._sendEmptyResponse(res);
+      return;
+    }
+
+    let jsonHttpRequest: any;
+    try {
+      jsonHttpRequest = await _readJsonHttpRequest(req);
+    } catch (error) {
+      this._sendResponse(res, _handleError(error));
+      return;
+    }
+
+    if (Array.isArray(jsonHttpRequest)) {
+      const responses = await Promise.all(
+        jsonHttpRequest.map((singleReq: any) =>
+          this._handleSingleRequest(singleReq)
+        )
+      );
+
+      this._sendResponse(res, responses);
+      return;
+    }
+
+    const rpcResp = await this._handleSingleRequest(jsonHttpRequest);
+
+    this._sendResponse(res, rpcResp);
+  };
+
+  public handleWs = async (ws: WebSocket) => {
+    const subscriptions: string[] = [];
+    let isClosed = false;
+
+    const listener = (payload: { subscription: string; result: any }) => {
+      // Don't attempt to send a message to the websocket if we already know it is closed,
+      // or the current websocket connection isn't interested in the particular subscription.
+      if (isClosed || !subscriptions.includes(payload.subscription)) {
+        return;
+      }
+
+      try {
+        ws.send(
+          JSON.stringify({
+            jsonrpc: "2.0",
+            method: "eth_subscription",
+            params: payload,
+          })
+        );
+      } catch (error) {
+        _handleError(error);
+      }
+    };
+
+    // Handle eth_subscribe notifications.
+    this._provider.addListener("notification", listener);
+
+    ws.on("message", async (msg) => {
+      let rpcReq: JsonRpcRequest | JsonRpcRequest[];
+      let rpcResp: JsonRpcResponse | JsonRpcResponse[];
+
+      try {
+        rpcReq = _readWsRequest(msg as string);
+
+        rpcResp = Array.isArray(rpcReq)
+          ? await Promise.all(
+              rpcReq.map((req) =>
+                this._handleSingleWsRequest(req, subscriptions)
+              )
+            )
+          : await this._handleSingleWsRequest(rpcReq, subscriptions);
+      } catch (error) {
+        rpcResp = _handleError(error);
+      }
+
+      ws.send(JSON.stringify(rpcResp));
+    });
+
+    ws.on("close", () => {
+      // Remove eth_subscribe listener.
+      this._provider.removeListener("notification", listener);
+
+      // Clear any active subscriptions for the closed websocket connection.
+      isClosed = true;
+      subscriptions.forEach(async (subscriptionId) => {
+        await this._provider.request({
+          method: "eth_unsubscribe",
+          params: [subscriptionId],
+        });
+      });
+    });
+  };
+
+  private _sendEmptyResponse(res: ServerResponse) {
+    res.writeHead(200);
+    res.end();
+  }
+
+  private _setCorsHeaders(res: ServerResponse) {
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Request-Method", "*");
+    res.setHeader("Access-Control-Allow-Methods", "OPTIONS, GET");
+    res.setHeader("Access-Control-Allow-Headers", "*");
+  }
+
+  private _sendResponse(
+    res: ServerResponse,
+    rpcResp: JsonRpcResponse | JsonRpcResponse[]
+  ) {
+    res.statusCode = 200;
+    res.setHeader("Content-Type", "application/json");
+    new JsonStreamStringify(rpcResp).pipe(res);
+  }
+
+  private async _handleSingleRequest(
+    req: JsonRpcRequest
+  ): Promise<JsonRpcResponse> {
+    if (!isValidJsonRequest(req)) {
+      return _handleError(new InvalidRequestError("Invalid request"));
+    }
+
+    const rpcReq: JsonRpcRequest = req;
+    let rpcResp: JsonRpcResponse | undefined;
+
+    try {
+      rpcResp = await this._handleRequest(rpcReq);
+    } catch (error) {
+      rpcResp = _handleError(error);
+    }
+
+    // Validate the RPC response.
+    if (!isValidJsonResponse(rpcResp)) {
+      // Malformed response coming from the provider, report to user as an internal error.
+      rpcResp = _handleError(new InternalError("Internal error"));
+    }
+
+    if (rpcReq !== undefined) {
+      rpcResp.id = rpcReq.id !== undefined ? rpcReq.id : null;
+    }
+
+    return rpcResp;
+  }
+
+  private async _handleSingleWsRequest(
+    rpcReq: JsonRpcRequest,
+    subscriptions: string[]
+  ) {
+    const rpcResp = await this._handleSingleRequest(rpcReq);
+
+    // If eth_subscribe was successful, keep track of the subscription id,
+    // so we can cleanup on websocket close.
+    if (
+      rpcReq.method === "eth_subscribe" &&
+      isSuccessfulJsonResponse(rpcResp)
+    ) {
+      subscriptions.push(rpcResp.result);
+    }
+
+    return rpcResp;
+  }
+
+  private _handleRequest = async (
+    req: JsonRpcRequest
+  ): Promise<JsonRpcResponse> => {
+    const result = await this._provider.request({
+      method: req.method,
+      params: req.params,
+    });
+
+    return {
+      jsonrpc: "2.0",
+      id: req.id,
+      result,
+    };
+  };
+}
+
+const _readJsonHttpRequest = async (req: IncomingMessage): Promise<any> => {
+  let json;
+
+  try {
+    const buf = await getRawBody(req);
+    const text = buf.toString();
+
+    json = JSON.parse(text);
+  } catch (error) {
+    if (error instanceof Error) {
+      throw new InvalidJsonInputError(`Parse error: ${error.message}`);
+    }
+
+    // eslint-disable-next-line @nomicfoundation/hardhat-internal-rules/only-hardhat-error
+    throw error;
+  }
+
+  return json;
+};
+
+const _readWsRequest = (msg: string): JsonRpcRequest | JsonRpcRequest[] => {
+  let json: any;
+  try {
+    json = JSON.parse(msg);
+  } catch (error) {
+    if (error instanceof Error) {
+      throw new InvalidJsonInputError(`Parse error: ${error.message}`);
+    }
+
+    // eslint-disable-next-line @nomicfoundation/hardhat-internal-rules/only-hardhat-error
+    throw error;
+  }
+
+  return json;
+};
+
+const _handleError = (error: any): JsonRpcResponse => {
+  // extract the relevant fields from the error before wrapping it
+  let txHash: string | undefined;
+  let returnData: string | undefined;
+
+  if (error.transactionHash !== undefined) {
+    txHash = error.transactionHash;
+  }
+  if (error.data !== undefined) {
+    if (error.data?.data !== undefined) {
+      returnData = error.data.data;
+    } else {
+      returnData = error.data;
+    }
+
+    if (txHash === undefined && error.data?.transactionHash !== undefined) {
+      txHash = error.data.transactionHash;
+    }
+  }
+
+  // In case of non-hardhat error, treat it as internal and associate the appropriate error code.
+  if (!ProviderError.isProviderError(error)) {
+    error = new InternalError(error);
+  }
+
+  const response: FailedJsonRpcResponse = {
+    jsonrpc: "2.0",
+    id: null,
+    error: {
+      code: error.code,
+      message: error.message,
+    },
+  };
+
+  response.error.data = {
+    message: error.message,
+  };
+
+  if (txHash !== undefined) {
+    response.error.data.txHash = txHash;
+  }
+
+  if (returnData !== undefined) {
+    response.error.data.data = returnData;
+  }
+
+  return response;
+};

package/src/internal/hardhat-network/jsonrpc/server.ts

@@ -0,0 +1,117 @@
+import type { Client as ClientT } from "undici";
+import type WsT from "ws";
+
+import debug from "debug";
+import http, { Server } from "http";
+import { AddressInfo } from "net";
+
+import {
+  EIP1193Provider,
+  JsonRpcServer as IJsonRpcServer,
+} from "../../../types";
+import { HttpProvider } from "../../core/providers/http";
+
+import { JsonRpcHandler } from "./handler";
+
+const log = debug("hardhat:core:hardhat-network:jsonrpc");
+
+export interface JsonRpcServerConfig {
+  hostname: string;
+  port: number;
+
+  provider: EIP1193Provider;
+}
+
+export class JsonRpcServer implements IJsonRpcServer {
+  private _config: JsonRpcServerConfig;
+  private _httpServer: Server;
+  private _wsServer: WsT.Server;
+
+  constructor(config: JsonRpcServerConfig) {
+    const { Server: WSServer } = require("ws") as typeof WsT;
+
+    this._config = config;
+
+    const handler = new JsonRpcHandler(config.provider);
+
+    this._httpServer = http.createServer();
+    this._wsServer = new WSServer({
+      server: this._httpServer,
+    });
+
+    this._httpServer.on("request", handler.handleHttp);
+    this._wsServer.on("connection", handler.handleWs);
+  }
+
+  public getProvider = (name = "json-rpc"): EIP1193Provider => {
+    const { Client } = require("undici") as { Client: typeof ClientT };
+    const { address, port } = this._httpServer.address() as AddressInfo;
+
+    const dispatcher = new Client(`http://${address}:${port}/`, {
+      keepAliveTimeout: 10,
+      keepAliveMaxTimeout: 10,
+    });
+
+    return new HttpProvider(
+      `http://${address}:${port}/`,
+      name,
+      {},
+      20000,
+      dispatcher
+    );
+  };
+
+  public listen = (): Promise<{ address: string; port: number }> => {
+    return new Promise((resolve) => {
+      log(`Starting JSON-RPC server on port ${this._config.port}`);
+      this._httpServer.listen(this._config.port, this._config.hostname, () => {
+        // We get the address and port directly from the server in order to handle random port allocation with `0`.
+        const address = this._httpServer.address() as AddressInfo; // TCP sockets return AddressInfo
+        resolve(address);
+      });
+    });
+  };
+
+  public waitUntilClosed = async () => {
+    const httpServerClosed = new Promise((resolve) => {
+      this._httpServer.once("close", resolve);
+    });
+
+    const wsServerClosed = new Promise((resolve) => {
+      this._wsServer.once("close", resolve);
+    });
+
+    await Promise.all([httpServerClosed, wsServerClosed]);
+  };
+
+  public close = async () => {
+    await Promise.all([
+      new Promise<void>((resolve, reject) => {
+        log("Closing JSON-RPC server");
+        this._httpServer.close((err) => {
+          if (err !== null && err !== undefined) {
+            log("Failed to close JSON-RPC server");
+            reject(err);
+            return;
+          }
+
+          log("JSON-RPC server closed");
+          resolve();
+        });
+      }),
+      new Promise<void>((resolve, reject) => {
+        log("Closing websocket server");
+        this._wsServer.close((err) => {
+          if (err !== null && err !== undefined) {
+            log("Failed to close websocket server");
+            reject(err);
+            return;
+          }
+
+          log("Websocket server closed");
+          resolve();
+        });
+      }),
+    ]);
+  };
+}

package/src/internal/hardhat-network/provider/fork/AccountState.ts

@@ -0,0 +1,28 @@
+import { Map as ImmutableMap, Record as ImmutableRecord } from "immutable";
+
+export interface AccountState {
+  nonce: string | undefined;
+  balance: string | undefined;
+  // a null value means that the slot was set to 0 (i.e. deleted)
+  storage: ImmutableMap<string, string | null>;
+  code: string | undefined;
+  storageCleared: boolean;
+}
+
+export const makeAccountState = ImmutableRecord<AccountState>({
+  nonce: undefined,
+  balance: undefined,
+  storage: ImmutableMap<string, string | null>(),
+  code: undefined,
+  storageCleared: false,
+});
+
+// used for deleted accounts
+// they need real values to avoid fetching the data from the remote node
+export const makeEmptyAccountState = ImmutableRecord<AccountState>({
+  nonce: "0x0",
+  balance: "0x0",
+  storage: ImmutableMap<string, string | null>(),
+  code: "0x",
+  storageCleared: true,
+});

package/src/internal/hardhat-network/provider/modules/logger.ts

@@ -0,0 +1,27 @@
+import ansiEscapes from "ansi-escapes";
+
+export function printLine(line: string) {
+  console.log(line);
+}
+
+export function replaceLastLine(newLine: string) {
+  if (process.stdout.isTTY === true) {
+    process.stdout.write(
+      // eslint-disable-next-line prefer-template
+      ansiEscapes.cursorHide +
+        ansiEscapes.cursorPrevLine +
+        newLine +
+        ansiEscapes.eraseEndLine +
+        "\n" +
+        ansiEscapes.cursorShow
+    );
+  } else {
+    process.stdout.write(`${newLine}\n`);
+  }
+}
+
+export interface LoggerConfig {
+  enabled: boolean;
+  printLineFn?: (line: string) => void;
+  replaceLastLineFn?: (line: string) => void;
+}

package/src/internal/hardhat-network/provider/node-types.ts

@@ -0,0 +1,86 @@
+import { HARDHAT_MEMPOOL_SUPPORTED_ORDERS } from "../../constants";
+import { BuildInfo, HardhatNetworkChainsConfig } from "../../../types";
+
+export type NodeConfig = LocalNodeConfig | ForkedNodeConfig;
+
+interface CommonConfig {
+  automine: boolean;
+  blockGasLimit: number;
+  chainId: number;
+  genesisAccounts: GenesisAccount[];
+  hardfork: string;
+  minGasPrice: bigint;
+  networkId: number;
+  allowUnlimitedContractSize?: boolean;
+  initialDate?: Date;
+  tracingConfig?: TracingConfig;
+  initialBaseFeePerGas?: number;
+  mempoolOrder: MempoolOrder;
+  coinbase: string;
+  chains: HardhatNetworkChainsConfig;
+  allowBlocksWithSameTimestamp: boolean;
+  enableTransientStorage: boolean;
+}
+
+export type LocalNodeConfig = CommonConfig;
+
+export interface ForkConfig {
+  jsonRpcUrl: string;
+  blockNumber?: number;
+  httpHeaders?: { [name: string]: string };
+}
+
+export interface ForkedNodeConfig extends CommonConfig {
+  forkConfig: ForkConfig;
+  forkCachePath?: string;
+}
+
+export interface TracingConfig {
+  buildInfos?: BuildInfo[];
+  ignoreContracts?: boolean;
+}
+
+export type IntervalMiningConfig = number | [number, number];
+
+export type MempoolOrder = typeof HARDHAT_MEMPOOL_SUPPORTED_ORDERS[number];
+
+export interface GenesisAccount {
+  privateKey: string;
+  balance: string | number | bigint;
+}
+
+export type AccessListBufferItem = [Uint8Array, Uint8Array[]];
+
+export type TransactionParams =
+  | LegacyTransactionParams
+  | AccessListTransactionParams
+  | EIP1559TransactionParams;
+
+interface BaseTransactionParams {
+  // `to` should be undefined for contract creation
+  to?: Uint8Array;
+  from: Uint8Array;
+  gasLimit: bigint;
+  value: bigint;
+  data: Uint8Array;
+  nonce: bigint;
+}
+
+export interface LegacyTransactionParams extends BaseTransactionParams {
+  gasPrice: bigint;
+}
+
+export interface AccessListTransactionParams extends BaseTransactionParams {
+  gasPrice: bigint;
+  // We use this access list format because @nomicfoundation/ethereumjs-tx access list data
+  // forces us to use it or stringify them
+  accessList: AccessListBufferItem[];
+  // We don't include chainId as it's not necessary, the node
+  // already knows its chainId, and the Eth module must validate it
+}
+
+export interface EIP1559TransactionParams extends BaseTransactionParams {
+  accessList: AccessListBufferItem[];
+  maxFeePerGas: bigint;
+  maxPriorityFeePerGas: bigint;
+}

package/src/internal/hardhat-network/provider/output.ts

@@ -0,0 +1,141 @@
+// TODO: These types should be moved to core, and probably inferred by io-ts
+export interface RpcBlockOutput {
+  difficulty: string;
+  extraData: string;
+  gasLimit: string;
+  gasUsed: string;
+  hash: string | null;
+  logsBloom: string;
+  miner: string;
+  mixHash: string | null;
+  nonce: string | null;
+  number: string | null;
+  parentHash: string;
+  receiptsRoot: string;
+  sha3Uncles: string;
+  size: string;
+  stateRoot: string;
+  timestamp: string;
+  totalDifficulty: string;
+  transactions: string[] | RpcTransactionOutput[];
+  transactionsRoot: string;
+  uncles: string[];
+  baseFeePerGas?: string;
+  withdrawals?: RpcWithdrawalItem[];
+  withdrawalsRoot?: string;
+  parentBeaconBlockRoot?: string | null;
+  blobGasUsed?: string | null;
+  excessBlobGas?: string | null;
+}
+
+export type RpcTransactionOutput =
+  | LegacyRpcTransactionOutput
+  | AccessListEIP2930RpcTransactionOutput
+  | EIP1559RpcTransactionOutput;
+
+interface BaseRpcTransactionOutput {
+  blockHash: string | null;
+  blockNumber: string | null;
+  from: string;
+  gas: string;
+  hash: string;
+  input: string;
+  nonce: string;
+  r: string; // This is documented as DATA, but implementations use QUANTITY
+  s: string; // This is documented as DATA, but implementations use QUANTITY
+  to: string | null;
+  transactionIndex: string | null;
+  v: string;
+  value: string;
+  // Only shown if the local hardfork is at least Berlin, or if the (remote) tx has an access list
+  type?: string;
+}
+
+export interface LegacyRpcTransactionOutput extends BaseRpcTransactionOutput {
+  gasPrice: string;
+}
+
+export type RpcAccessListOutput = Array<{
+  address: string;
+  storageKeys: string[];
+}>;
+
+export interface AccessListEIP2930RpcTransactionOutput
+  extends BaseRpcTransactionOutput {
+  gasPrice: string;
+  accessList?: RpcAccessListOutput;
+  chainId: string;
+}
+
+export interface EIP1559RpcTransactionOutput extends BaseRpcTransactionOutput {
+  gasPrice: string;
+  maxFeePerGas: string;
+  maxPriorityFeePerGas: string;
+  accessList?: RpcAccessListOutput;
+  chainId: string;
+}
+
+export interface RpcReceiptOutput {
+  blockHash: string;
+  blockNumber: string;
+  contractAddress: string | null;
+  cumulativeGasUsed: string;
+  from: string;
+  gasUsed: string;
+  logs: RpcLogOutput[];
+  logsBloom: string;
+  to: string | null;
+  transactionHash: string;
+  transactionIndex: string;
+
+  // Only present after Byzantium
+  status?: string;
+
+  // Only present before Byzantium
+  root?: string;
+
+  // Only shown if the local hardfork is at least Berlin, or if the (remote) is not a legacy one
+  type?: string;
+
+  // Only shown if the local hardfork is at least London, or if the (remote) is EIP-1559
+  effectiveGasPrice?: string;
+}
+
+export interface RpcLogOutput {
+  address: string;
+  blockHash: string | null;
+  blockNumber: string | null;
+  data: string;
+  logIndex: string | null;
+  removed: boolean;
+  topics: string[];
+  transactionHash: string | null;
+  transactionIndex: string | null;
+}
+
+export interface RpcStructLog {
+  depth: number;
+  gas: number;
+  gasCost: number;
+  op: string;
+  pc: number;
+  memory?: string[];
+  stack?: string[];
+  storage?: Record<string, string>;
+  memSize?: number;
+  error?: object;
+}
+
+export interface RpcDebugTraceOutput {
+  failed: boolean;
+  gas: number;
+  returnValue: string;
+  structLogs: RpcStructLog[];
+}
+
+export interface RpcWithdrawalItem {
+  index: string;
+  validatorIndex: string;
+  address: string;
+  amount: string;
+}