hardhatjs 2.22.15

package/src/internal/hardhat-network/provider/utils/convertToEdr.ts

@@ -0,0 +1,277 @@
+import type {
+  SpecId,
+  MineOrdering,
+  IntervalRange,
+  DebugTraceResult,
+  TracingMessage,
+  TracingMessageResult,
+  TracingStep,
+} from "@nomicfoundation/edr";
+import { Address } from "@nomicfoundation/ethereumjs-util";
+
+import { requireNapiRsModule } from "../../../../common/napi-rs";
+import { HardforkName } from "../../../util/hardforks";
+import { IntervalMiningConfig, MempoolOrder } from "../node-types";
+import { RpcDebugTraceOutput, RpcStructLog } from "../output";
+import {
+  MinimalEVMResult,
+  MinimalInterpreterStep,
+  MinimalMessage,
+} from "../vm/types";
+
+/* eslint-disable @nomicfoundation/hardhat-internal-rules/only-hardhat-error */
+
+export function ethereumsjsHardforkToEdrSpecId(hardfork: HardforkName): SpecId {
+  const { SpecId } = requireNapiRsModule(
+    "@nomicfoundation/edr"
+  ) as typeof import("@nomicfoundation/edr");
+
+  switch (hardfork) {
+    case HardforkName.FRONTIER:
+      return SpecId.Frontier;
+    case HardforkName.HOMESTEAD:
+      return SpecId.Homestead;
+    case HardforkName.DAO:
+      return SpecId.DaoFork;
+    case HardforkName.TANGERINE_WHISTLE:
+      return SpecId.Tangerine;
+    case HardforkName.SPURIOUS_DRAGON:
+      return SpecId.SpuriousDragon;
+    case HardforkName.BYZANTIUM:
+      return SpecId.Byzantium;
+    case HardforkName.CONSTANTINOPLE:
+      return SpecId.Constantinople;
+    case HardforkName.PETERSBURG:
+      return SpecId.Petersburg;
+    case HardforkName.ISTANBUL:
+      return SpecId.Istanbul;
+    case HardforkName.MUIR_GLACIER:
+      return SpecId.MuirGlacier;
+    case HardforkName.BERLIN:
+      return SpecId.Berlin;
+    case HardforkName.LONDON:
+      return SpecId.London;
+    case HardforkName.ARROW_GLACIER:
+      return SpecId.ArrowGlacier;
+    case HardforkName.GRAY_GLACIER:
+      return SpecId.GrayGlacier;
+    case HardforkName.MERGE:
+      return SpecId.Merge;
+    case HardforkName.SHANGHAI:
+      return SpecId.Shanghai;
+    case HardforkName.CANCUN:
+      return SpecId.Cancun;
+    default:
+      const _exhaustiveCheck: never = hardfork;
+      throw new Error(
+        `Unknown hardfork name '${hardfork as string}', this shouldn't happen`
+      );
+  }
+}
+
+export function edrSpecIdToEthereumHardfork(specId: SpecId): HardforkName {
+  const { SpecId } = requireNapiRsModule(
+    "@nomicfoundation/edr"
+  ) as typeof import("@nomicfoundation/edr");
+
+  switch (specId) {
+    case SpecId.Frontier:
+      return HardforkName.FRONTIER;
+    case SpecId.Homestead:
+      return HardforkName.HOMESTEAD;
+    case SpecId.DaoFork:
+      return HardforkName.DAO;
+    case SpecId.Tangerine:
+      return HardforkName.TANGERINE_WHISTLE;
+    case SpecId.SpuriousDragon:
+      return HardforkName.SPURIOUS_DRAGON;
+    case SpecId.Byzantium:
+      return HardforkName.BYZANTIUM;
+    case SpecId.Constantinople:
+      return HardforkName.CONSTANTINOPLE;
+    case SpecId.Petersburg:
+      return HardforkName.PETERSBURG;
+    case SpecId.Istanbul:
+      return HardforkName.ISTANBUL;
+    case SpecId.MuirGlacier:
+      return HardforkName.MUIR_GLACIER;
+    case SpecId.Berlin:
+      return HardforkName.BERLIN;
+    case SpecId.London:
+      return HardforkName.LONDON;
+    case SpecId.ArrowGlacier:
+      return HardforkName.ARROW_GLACIER;
+    case SpecId.GrayGlacier:
+      return HardforkName.GRAY_GLACIER;
+    case SpecId.Merge:
+      return HardforkName.MERGE;
+    case SpecId.Shanghai:
+      return HardforkName.SHANGHAI;
+    // HACK: EthereumJS doesn't support Cancun, so report Shanghai
+    case SpecId.Cancun:
+      return HardforkName.SHANGHAI;
+
+    default:
+      throw new Error(`Unknown spec id '${specId}', this shouldn't happen`);
+  }
+}
+
+export function ethereumjsIntervalMiningConfigToEdr(
+  config: IntervalMiningConfig
+): bigint | IntervalRange | undefined {
+  if (typeof config === "number") {
+    // Is interval mining disabled?
+    if (config === 0) {
+      return undefined;
+    } else {
+      return BigInt(config);
+    }
+  } else {
+    return {
+      min: BigInt(config[0]),
+      max: BigInt(config[1]),
+    };
+  }
+}
+
+export function ethereumjsMempoolOrderToEdrMineOrdering(
+  mempoolOrder: MempoolOrder
+): MineOrdering {
+  const { MineOrdering } = requireNapiRsModule(
+    "@nomicfoundation/edr"
+  ) as typeof import("@nomicfoundation/edr");
+
+  switch (mempoolOrder) {
+    case "fifo":
+      return MineOrdering.Fifo;
+    case "priority":
+      return MineOrdering.Priority;
+  }
+}
+
+export function edrRpcDebugTraceToHardhat(
+  rpcDebugTrace: DebugTraceResult
+): RpcDebugTraceOutput {
+  const structLogs = rpcDebugTrace.structLogs.map((log) => {
+    const result: RpcStructLog = {
+      depth: Number(log.depth),
+      gas: Number(log.gas),
+      gasCost: Number(log.gasCost),
+      op: log.opName,
+      pc: Number(log.pc),
+    };
+
+    if (log.memory !== undefined) {
+      result.memory = log.memory;
+    }
+
+    if (log.stack !== undefined) {
+      // Remove 0x prefix which is required by EIP-3155, but not expected by Hardhat.
+      result.stack = log.stack?.map((item) => item.slice(2));
+    }
+
+    if (log.storage !== undefined) {
+      result.storage = Object.fromEntries(
+        Object.entries(log.storage).map(([key, value]) => {
+          return [key.slice(2), value.slice(2)];
+        })
+      );
+    }
+
+    if (log.error !== undefined) {
+      result.error = {
+        message: log.error,
+      };
+    }
+
+    return result;
+  });
+
+  // REVM trace adds initial STOP that Hardhat doesn't expect
+  if (structLogs.length > 0 && structLogs[0].op === "STOP") {
+    structLogs.shift();
+  }
+
+  let returnValue = rpcDebugTrace.output?.toString("hex") ?? "";
+  if (returnValue === "0x") {
+    returnValue = "";
+  }
+
+  return {
+    failed: !rpcDebugTrace.pass,
+    gas: Number(rpcDebugTrace.gasUsed),
+    returnValue,
+    structLogs,
+  };
+}
+
+export function edrTracingStepToMinimalInterpreterStep(
+  step: TracingStep
+): MinimalInterpreterStep {
+  const minimalInterpreterStep: MinimalInterpreterStep = {
+    pc: Number(step.pc),
+    depth: step.depth,
+    opcode: {
+      name: step.opcode,
+    },
+    stack: step.stack,
+  };
+
+  if (step.memory !== undefined) {
+    minimalInterpreterStep.memory = step.memory;
+  }
+
+  return minimalInterpreterStep;
+}
+
+export function edrTracingMessageResultToMinimalEVMResult(
+  tracingMessageResult: TracingMessageResult
+): MinimalEVMResult {
+  const { result, contractAddress } = tracingMessageResult.executionResult;
+
+  // only SuccessResult has logs
+  const success = "logs" in result;
+
+  const minimalEVMResult: MinimalEVMResult = {
+    execResult: {
+      executionGasUsed: result.gasUsed,
+      success,
+    },
+  };
+
+  // only success and exceptional halt have reason
+  if ("reason" in result) {
+    minimalEVMResult.execResult.reason = result.reason;
+  }
+  if ("output" in result) {
+    const { output } = result;
+    if (Buffer.isBuffer(output)) {
+      minimalEVMResult.execResult.output = output;
+    } else {
+      minimalEVMResult.execResult.output = output.returnValue;
+    }
+  }
+
+  if (contractAddress !== undefined) {
+    minimalEVMResult.execResult.contractAddress = new Address(contractAddress);
+  }
+
+  return minimalEVMResult;
+}
+
+export function edrTracingMessageToMinimalMessage(
+  message: TracingMessage
+): MinimalMessage {
+  return {
+    to: message.to !== undefined ? new Address(message.to) : undefined,
+    codeAddress:
+      message.codeAddress !== undefined
+        ? new Address(message.codeAddress)
+        : undefined,
+    data: message.data,
+    value: message.value,
+    caller: new Address(message.caller),
+    gasLimit: message.gasLimit,
+    isStaticCall: message.isStaticCall,
+  };
+}

package/src/internal/hardhat-network/provider/utils/disk-cache.ts

@@ -0,0 +1,7 @@
+import path from "path";
+
+import { ProjectPathsConfig } from "../../../../types";
+
+export function getForkCacheDirPath(paths: ProjectPathsConfig): string {
+  return path.join(paths.cache, "hardhat-network-fork");
+}

package/src/internal/hardhat-network/provider/utils/fork-recomendations-banner.ts

@@ -0,0 +1,48 @@
+import chalk from "chalk";
+import fsExtra from "fs-extra";
+import path from "path";
+
+import { NetworkConfig } from "../../../../types";
+
+function getAlreadyShownFilePath(forkCachePath: string) {
+  return path.join(forkCachePath, "recommendations-already-shown.json");
+}
+
+function displayBanner() {
+  console.warn(
+    chalk.yellow(
+      `You're running a network fork starting from the latest block.
+Performance may degrade due to fetching data from the network with each run.
+If connecting to an archival node (e.g. Alchemy), we strongly recommend setting
+blockNumber to a fixed value to increase performance with a local cache.`
+    )
+  );
+}
+
+export async function showForkRecommendationsBannerIfNecessary(
+  currentNetworkConfig: NetworkConfig,
+  forkCachePath: string
+) {
+  if (!("forking" in currentNetworkConfig)) {
+    return;
+  }
+
+  if (currentNetworkConfig.forking?.enabled !== true) {
+    return;
+  }
+
+  if (currentNetworkConfig.forking?.blockNumber !== undefined) {
+    return;
+  }
+
+  const shownPath = getAlreadyShownFilePath(forkCachePath);
+
+  if (await fsExtra.pathExists(shownPath)) {
+    return;
+  }
+
+  displayBanner();
+
+  await fsExtra.ensureDir(path.dirname(shownPath));
+  await fsExtra.writeJSON(shownPath, true);
+}

package/src/internal/hardhat-network/provider/utils/getCurrentTimestamp.ts

@@ -0,0 +1,3 @@
+export function getCurrentTimestamp(): number {
+  return Math.ceil(new Date().getTime() / 1000);
+}

package/src/internal/hardhat-network/provider/utils/isHexPrefixed.ts

@@ -0,0 +1,3 @@
+export function isHexPrefixed(value: string) {
+  return value.toLowerCase().startsWith("0x");
+}

package/src/internal/hardhat-network/provider/utils/makeAccount.ts

@@ -0,0 +1,25 @@
+import {
+  Account,
+  Address,
+  privateToAddress,
+  toBytes,
+} from "@nomicfoundation/ethereumjs-util";
+
+import { GenesisAccount } from "../node-types";
+
+import { isHexPrefixed } from "./isHexPrefixed";
+
+export function makeAccount(ga: GenesisAccount) {
+  let balance: bigint;
+
+  if (typeof ga.balance === "string" && isHexPrefixed(ga.balance)) {
+    balance = BigInt(ga.balance);
+  } else {
+    balance = BigInt(ga.balance);
+  }
+
+  const account = Account.fromAccountData({ balance });
+  const pk = toBytes(ga.privateKey);
+  const address = new Address(privateToAddress(pk));
+  return { account, address };
+}

package/src/internal/hardhat-network/provider/utils/makeCommon.ts

@@ -0,0 +1,20 @@
+import { Common } from "@nomicfoundation/ethereumjs-common";
+
+import { LocalNodeConfig } from "../node-types";
+import { HardforkName } from "../../../util/hardforks";
+
+export function makeCommon({ chainId, networkId, hardfork }: LocalNodeConfig) {
+  const common = Common.custom(
+    {
+      chainId,
+      networkId,
+    },
+    {
+      // ethereumjs uses this name for the merge hardfork
+      hardfork:
+        hardfork === HardforkName.MERGE ? "mergeForkIdTransition" : hardfork,
+    }
+  );
+
+  return common;
+}

package/src/internal/hardhat-network/provider/utils/makeForkClient.ts

@@ -0,0 +1,177 @@
+import chalk from "chalk";
+
+import { HARDHAT_NETWORK_NAME } from "../../../constants";
+import { assertHardhatInvariant } from "../../../core/errors";
+import {
+  numberToRpcQuantity,
+  rpcQuantityToNumber,
+} from "../../../core/jsonrpc/types/base-types";
+import { HttpProvider } from "../../../core/providers/http";
+import { JsonRpcClient } from "../../jsonrpc/client";
+import { ForkConfig } from "../node-types";
+import { RpcBlockOutput } from "../output";
+
+import {
+  FALLBACK_MAX_REORG,
+  getLargestPossibleReorg,
+} from "./reorgs-protection";
+
+// TODO: This is a temporarily measure.
+//  We must investigate why this timeouts so much. Apparently
+//  node-fetch doesn't handle timeouts so well. The option was
+//  removed in its new major version. UPDATE: we aren't even using node-fetch
+//  anymore, so this really should be revisited.
+const FORK_HTTP_TIMEOUT = 35000;
+
+export async function makeForkProvider(forkConfig: ForkConfig): Promise<{
+  forkProvider: HttpProvider;
+  networkId: number;
+  forkBlockNumber: bigint;
+  latestBlockNumber: bigint;
+  maxReorg: bigint;
+}> {
+  const forkProvider = new HttpProvider(
+    forkConfig.jsonRpcUrl,
+    HARDHAT_NETWORK_NAME,
+    forkConfig.httpHeaders,
+    FORK_HTTP_TIMEOUT
+  );
+
+  const networkId = await getNetworkId(forkProvider);
+  const actualMaxReorg = getLargestPossibleReorg(networkId);
+  const maxReorg = actualMaxReorg ?? FALLBACK_MAX_REORG;
+
+  const latestBlockNumber = await getLatestBlockNumber(forkProvider);
+  const lastSafeBlockNumber = getLastSafeBlockNumber(
+    latestBlockNumber,
+    maxReorg
+  );
+
+  let forkBlockNumber;
+  if (forkConfig.blockNumber !== undefined) {
+    if (forkConfig.blockNumber > latestBlockNumber) {
+      // eslint-disable-next-line @nomicfoundation/hardhat-internal-rules/only-hardhat-error
+      throw new Error(
+        `Trying to initialize a provider with block ${forkConfig.blockNumber} but the current block is ${latestBlockNumber}`
+      );
+    }
+
+    if (forkConfig.blockNumber > lastSafeBlockNumber) {
+      const confirmations =
+        latestBlockNumber - BigInt(forkConfig.blockNumber) + 1n;
+      const requiredConfirmations = maxReorg + 1n;
+      console.warn(
+        chalk.yellow(
+          `You are forking from block ${
+            forkConfig.blockNumber
+          }, which has less than ${requiredConfirmations} confirmations, and will affect Hardhat Network's performance.
+Please use block number ${lastSafeBlockNumber} or wait for the block to get ${
+            requiredConfirmations - confirmations
+          } more confirmations.`
+        )
+      );
+    }
+
+    forkBlockNumber = BigInt(forkConfig.blockNumber);
+  } else {
+    forkBlockNumber = BigInt(lastSafeBlockNumber);
+  }
+
+  return {
+    forkProvider,
+    networkId,
+    forkBlockNumber,
+    latestBlockNumber,
+    maxReorg,
+  };
+}
+
+export async function makeForkClient(
+  forkConfig: ForkConfig,
+  forkCachePath?: string
+): Promise<{
+  forkClient: JsonRpcClient;
+  forkBlockNumber: bigint;
+  forkBlockTimestamp: number;
+  forkBlockHash: string;
+  forkBlockStateRoot: string;
+}> {
+  const {
+    forkProvider,
+    networkId,
+    forkBlockNumber,
+    latestBlockNumber,
+    maxReorg,
+  } = await makeForkProvider(forkConfig);
+
+  const block = await getBlockByNumber(forkProvider, forkBlockNumber);
+
+  const forkBlockTimestamp = rpcQuantityToNumber(block.timestamp) * 1000;
+
+  const cacheToDiskEnabled =
+    forkConfig.blockNumber !== undefined && forkCachePath !== undefined;
+
+  const forkClient = new JsonRpcClient(
+    forkProvider,
+    networkId,
+    latestBlockNumber,
+    maxReorg,
+    cacheToDiskEnabled ? forkCachePath : undefined
+  );
+
+  const forkBlockHash = block.hash;
+
+  assertHardhatInvariant(
+    forkBlockHash !== null,
+    "Forked block should have a hash"
+  );
+
+  const forkBlockStateRoot = block.stateRoot;
+
+  return {
+    forkClient,
+    forkBlockNumber,
+    forkBlockTimestamp,
+    forkBlockHash,
+    forkBlockStateRoot,
+  };
+}
+
+async function getBlockByNumber(
+  provider: HttpProvider,
+  blockNumber: bigint
+): Promise<RpcBlockOutput> {
+  const rpcBlockOutput = (await provider.request({
+    method: "eth_getBlockByNumber",
+    params: [numberToRpcQuantity(blockNumber), false],
+  })) as RpcBlockOutput;
+
+  return rpcBlockOutput;
+}
+
+async function getNetworkId(provider: HttpProvider) {
+  const networkIdString = (await provider.request({
+    method: "net_version",
+  })) as string;
+  return parseInt(networkIdString, 10);
+}
+
+async function getLatestBlockNumber(provider: HttpProvider) {
+  const latestBlockString = (await provider.request({
+    method: "eth_blockNumber",
+  })) as string;
+
+  const latestBlock = BigInt(latestBlockString);
+  return latestBlock;
+}
+
+export function getLastSafeBlockNumber(
+  latestBlockNumber: bigint,
+  maxReorg: bigint
+): bigint {
+  // Design choice: if latestBlock - maxReorg results in a negative number then the latestBlock block will be used.
+  // This decision is based on the assumption that if maxReorg > latestBlock then there is a high probability that the fork is occurring on a devnet.
+  return latestBlockNumber - maxReorg >= 0
+    ? latestBlockNumber - maxReorg
+    : latestBlockNumber;
+}

package/src/internal/hardhat-network/provider/utils/random.ts

@@ -0,0 +1,64 @@
+import type EthereumjsUtilT from "@nomicfoundation/ethereumjs-util";
+import type * as UtilKeccakT from "../../../util/keccak";
+
+export class RandomBufferGenerator {
+  private constructor(private _nextValue: Uint8Array) {}
+
+  public static create(seed: string): RandomBufferGenerator {
+    const { keccak256 } = require("../../../util/keccak") as typeof UtilKeccakT;
+
+    const nextValue = keccak256(Buffer.from(seed));
+
+    return new RandomBufferGenerator(nextValue);
+  }
+
+  public next(): Uint8Array {
+    const { keccak256 } = require("../../../util/keccak") as typeof UtilKeccakT;
+
+    const valueToReturn = this._nextValue;
+
+    this._nextValue = keccak256(this._nextValue);
+
+    return valueToReturn;
+  }
+
+  public seed(): Uint8Array {
+    return this._nextValue;
+  }
+
+  public setNext(nextValue: Buffer) {
+    this._nextValue = Buffer.from(nextValue);
+  }
+
+  public clone(): RandomBufferGenerator {
+    return new RandomBufferGenerator(this._nextValue);
+  }
+}
+
+export const randomHash = () => {
+  const { bytesToHex: bufferToHex } =
+    require("@nomicfoundation/ethereumjs-util") as typeof EthereumjsUtilT;
+  return bufferToHex(randomHashBuffer());
+};
+
+const generator = RandomBufferGenerator.create("seed");
+export const randomHashBuffer = (): Uint8Array => {
+  return generator.next();
+};
+
+export const randomAddress = () => {
+  const { Address } =
+    require("@nomicfoundation/ethereumjs-util") as typeof EthereumjsUtilT;
+  return new Address(randomAddressBuffer());
+};
+
+export const randomAddressString = () => {
+  const { bytesToHex: bufferToHex } =
+    require("@nomicfoundation/ethereumjs-util") as typeof EthereumjsUtilT;
+  return bufferToHex(randomAddressBuffer());
+};
+
+const addressGenerator = RandomBufferGenerator.create("seed");
+export const randomAddressBuffer = (): Uint8Array => {
+  return addressGenerator.next().slice(0, 20);
+};

package/src/internal/hardhat-network/provider/utils/reorgs-protection.ts

@@ -0,0 +1,40 @@
+/**
+ * This function returns a number that should be safe to consider as the
+ * largest possible reorg in a network.
+ *
+ * If there's not such a number, or we aren't aware of it, this function
+ * returns undefined.
+ */
+export function getLargestPossibleReorg(networkId: number): bigint | undefined {
+  // mainnet
+  if (networkId === 1) {
+    return 32n;
+  }
+
+  // Kovan
+  if (networkId === 42) {
+    return 32n;
+  }
+
+  // Goerli
+  if (networkId === 5) {
+    return 32n;
+  }
+
+  // Rinkeby
+  if (networkId === 4) {
+    return 32n;
+  }
+
+  // Ropsten
+  if (networkId === 3) {
+    return 100n;
+  }
+
+  // xDai
+  if (networkId === 100) {
+    return 38n;
+  }
+}
+
+export const FALLBACK_MAX_REORG = 128n;

package/src/internal/hardhat-network/provider/vm/exit.ts

@@ -0,0 +1,7 @@
+import { requireNapiRsModule } from "../../../../common/napi-rs";
+
+const { ExitCode } = requireNapiRsModule(
+  "@nomicfoundation/edr"
+) as typeof import("@nomicfoundation/edr");
+
+export { ExitCode };