hardhat 2.20.0 → 2.21.0-dev.0

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

@@ -0,0 +1,228 @@
+import {
+  SpecId,
+  MineOrdering,
+  IntervalRange,
+  DebugTraceResult,
+  TracingMessage,
+  TracingMessageResult,
+  TracingStep,
+} from "@nomicfoundation/edr";
+import { Address } from "@nomicfoundation/ethereumjs-util";
+
+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 {
+  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 {
+  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 {
+  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 {
+  return {
+    pc: Number(step.pc),
+    depth: step.depth,
+    opcode: {
+      name: step.opcode,
+    },
+    stack: step.stackTop !== undefined ? [step.stackTop] : [],
+  };
+}
+
+export function edrTracingMessageResultToMinimalEVMResult(
+  tracingMessageResult: TracingMessageResult
+): MinimalEVMResult {
+  return {
+    execResult: {
+      executionGasUsed: tracingMessageResult.executionResult.result.gasUsed,
+    },
+  };
+}
+
+export function edrTracingMessageToMinimalMessage(
+  message: TracingMessage
+): MinimalMessage {
+  return {
+    to: message.to !== undefined ? new Address(message.to) : undefined,
+    data: message.data,
+    value: message.value,
+    caller: new Address(message.caller),
+    gasLimit: message.gasLimit,
+  };
+}

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

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

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

@@ -2,19 +2,8 @@ import { Common } from "@nomicfoundation/ethereumjs-common";
 
 import { LocalNodeConfig } from "../node-types";
 import { HardforkName } from "../../../util/hardforks";
-import { assertTransientStorageCompatibility } from "../node";
-
-export function makeCommon({
-  chainId,
-  networkId,
-  hardfork,
-  enableTransientStorage,
-}: LocalNodeConfig) {
-  assertTransientStorageCompatibility(
-    enableTransientStorage,
-    hardfork as HardforkName
-  );
 
+export function makeCommon({ chainId, networkId, hardfork }: LocalNodeConfig) {
   const common = Common.custom(
     {
       chainId,

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

@@ -23,47 +23,49 @@ import {
 //  anymore, so this really should be revisited.
 const FORK_HTTP_TIMEOUT = 35000;
 
-export async function makeForkClient(
-  forkConfig: ForkConfig,
-  forkCachePath?: string
-): Promise<{
-  forkClient: JsonRpcClient;
+export async function makeForkProvider(forkConfig: ForkConfig): Promise<{
+  forkProvider: HttpProvider;
+  networkId: number;
   forkBlockNumber: bigint;
-  forkBlockTimestamp: number;
-  forkBlockHash: string;
+  latestBlockNumber: bigint;
+  maxReorg: bigint;
 }> {
-  const provider = new HttpProvider(
+  const forkProvider = new HttpProvider(
     forkConfig.jsonRpcUrl,
     HARDHAT_NETWORK_NAME,
     forkConfig.httpHeaders,
     FORK_HTTP_TIMEOUT
   );
 
-  const networkId = await getNetworkId(provider);
+  const networkId = await getNetworkId(forkProvider);
   const actualMaxReorg = getLargestPossibleReorg(networkId);
   const maxReorg = actualMaxReorg ?? FALLBACK_MAX_REORG;
 
-  const latestBlock = await getLatestBlockNumber(provider);
-  const lastSafeBlock = getLastSafeBlock(latestBlock, maxReorg);
+  const latestBlockNumber = await getLatestBlockNumber(forkProvider);
+  const lastSafeBlockNumber = getLastSafeBlockNumber(
+    latestBlockNumber,
+    maxReorg
+  );
 
   let forkBlockNumber;
   if (forkConfig.blockNumber !== undefined) {
-    if (forkConfig.blockNumber > latestBlock) {
+    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 ${latestBlock}`
+        `Trying to initialize a provider with block ${forkConfig.blockNumber} but the current block is ${latestBlockNumber}`
       );
     }
 
-    if (forkConfig.blockNumber > lastSafeBlock) {
-      const confirmations = latestBlock - BigInt(forkConfig.blockNumber) + 1n;
+    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 ${lastSafeBlock} or wait for the block to get ${
+Please use block number ${lastSafeBlockNumber} or wait for the block to get ${
             requiredConfirmations - confirmations
           } more confirmations.`
         )
@@ -72,10 +74,37 @@ Please use block number ${lastSafeBlock} or wait for the block to get ${
 
     forkBlockNumber = BigInt(forkConfig.blockNumber);
   } else {
-    forkBlockNumber = BigInt(lastSafeBlock);
+    forkBlockNumber = BigInt(lastSafeBlockNumber);
   }
 
-  const block = await getBlockByNumber(provider, forkBlockNumber);
+  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;
 
@@ -83,9 +112,9 @@ Please use block number ${lastSafeBlock} or wait for the block to get ${
     forkConfig.blockNumber !== undefined && forkCachePath !== undefined;
 
   const forkClient = new JsonRpcClient(
-    provider,
+    forkProvider,
     networkId,
-    latestBlock,
+    latestBlockNumber,
     maxReorg,
     cacheToDiskEnabled ? forkCachePath : undefined
   );
@@ -97,7 +126,15 @@ Please use block number ${lastSafeBlock} or wait for the block to get ${
     "Forked block should have a hash"
   );
 
-  return { forkClient, forkBlockNumber, forkBlockTimestamp, forkBlockHash };
+  const forkBlockStateRoot = block.stateRoot;
+
+  return {
+    forkClient,
+    forkBlockNumber,
+    forkBlockTimestamp,
+    forkBlockHash,
+    forkBlockStateRoot,
+  };
 }
 
 async function getBlockByNumber(
@@ -128,11 +165,13 @@ async function getLatestBlockNumber(provider: HttpProvider) {
   return latestBlock;
 }
 
-export function getLastSafeBlock(
-  latestBlock: bigint,
+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 latestBlock - maxReorg >= 0 ? latestBlock - maxReorg : latestBlock;
+  return latestBlockNumber - maxReorg >= 0
+    ? latestBlockNumber - maxReorg
+    : latestBlockNumber;
 }

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

@@ -22,6 +22,10 @@ export class RandomBufferGenerator {
     return valueToReturn;
   }
 
+  public seed(): Uint8Array {
+    return this._nextValue;
+  }
+
   public setNext(nextValue: Buffer) {
     this._nextValue = Buffer.from(nextValue);
   }
@@ -54,4 +58,7 @@ export const randomAddressString = () => {
   return bufferToHex(randomAddressBuffer());
 };
 
-export const randomAddressBuffer = () => randomHashBuffer().slice(0, 20);
+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

@@ -8,22 +8,22 @@
 export function getLargestPossibleReorg(networkId: number): bigint | undefined {
   // mainnet
   if (networkId === 1) {
-    return 5n;
+    return 32n;
   }
 
   // Kovan
   if (networkId === 42) {
-    return 5n;
+    return 32n;
   }
 
   // Goerli
   if (networkId === 5) {
-    return 5n;
+    return 32n;
   }
 
   // Rinkeby
   if (networkId === 4) {
-    return 5n;
+    return 32n;
   }
 
   // Ropsten
@@ -37,4 +37,4 @@ export function getLargestPossibleReorg(networkId: number): bigint | undefined {
   }
 }
 
-export const FALLBACK_MAX_REORG = 30n;
+export const FALLBACK_MAX_REORG = 128n;

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

@@ -0,0 +1,101 @@
+import { ExceptionalHalt, SuccessReason } from "@nomicfoundation/edr";
+
+export enum ExitCode {
+  SUCCESS,
+  REVERT,
+  OUT_OF_GAS,
+  INTERNAL_ERROR,
+  INVALID_OPCODE,
+  STACK_UNDERFLOW,
+  CODESIZE_EXCEEDS_MAXIMUM,
+  CREATE_COLLISION,
+  STATIC_STATE_CHANGE,
+}
+
+export class Exit {
+  public static fromEdrSuccessReason(reason: SuccessReason): Exit {
+    switch (reason) {
+      case SuccessReason.Stop:
+      case SuccessReason.Return:
+      case SuccessReason.SelfDestruct:
+        return new Exit(ExitCode.SUCCESS);
+    }
+
+    const _exhaustiveCheck: never = reason;
+  }
+
+  public static fromEdrExceptionalHalt(halt: ExceptionalHalt): Exit {
+    switch (halt) {
+      case ExceptionalHalt.OutOfGas:
+        return new Exit(ExitCode.OUT_OF_GAS);
+
+      case ExceptionalHalt.OpcodeNotFound:
+      case ExceptionalHalt.InvalidFEOpcode:
+      // Returned when an opcode is not implemented for the hardfork
+      case ExceptionalHalt.NotActivated:
+        return new Exit(ExitCode.INVALID_OPCODE);
+
+      case ExceptionalHalt.StackUnderflow:
+        return new Exit(ExitCode.STACK_UNDERFLOW);
+
+      case ExceptionalHalt.CreateCollision:
+        return new Exit(ExitCode.CREATE_COLLISION);
+
+      case ExceptionalHalt.CreateContractSizeLimit:
+        return new Exit(ExitCode.CODESIZE_EXCEEDS_MAXIMUM);
+
+      default: {
+        // eslint-disable-next-line @nomicfoundation/hardhat-internal-rules/only-hardhat-error
+        throw new Error(`Unmatched EDR exceptional halt: ${halt}`);
+      }
+    }
+  }
+
+  constructor(public kind: ExitCode) {}
+
+  public isError(): boolean {
+    return this.kind !== ExitCode.SUCCESS;
+  }
+
+  public getReason(): string {
+    switch (this.kind) {
+      case ExitCode.SUCCESS:
+        return "Success";
+      case ExitCode.REVERT:
+        return "Reverted";
+      case ExitCode.OUT_OF_GAS:
+        return "Out of gas";
+      case ExitCode.INTERNAL_ERROR:
+        return "Internal error";
+      case ExitCode.INVALID_OPCODE:
+        return "Invalid opcode";
+      case ExitCode.STACK_UNDERFLOW:
+        return "Stack underflow";
+      case ExitCode.CODESIZE_EXCEEDS_MAXIMUM:
+        return "Codesize exceeds maximum";
+      case ExitCode.CREATE_COLLISION:
+        return "Create collision";
+      case ExitCode.STATIC_STATE_CHANGE:
+        return "Static state change";
+    }
+
+    const _exhaustiveCheck: never = this.kind;
+  }
+
+  public getEdrExceptionalHalt(): ExceptionalHalt {
+    switch (this.kind) {
+      case ExitCode.OUT_OF_GAS:
+        return ExceptionalHalt.OutOfGas;
+      case ExitCode.INVALID_OPCODE:
+        return ExceptionalHalt.OpcodeNotFound;
+      case ExitCode.CODESIZE_EXCEEDS_MAXIMUM:
+        return ExceptionalHalt.CreateContractSizeLimit;
+      case ExitCode.CREATE_COLLISION:
+        return ExceptionalHalt.CreateCollision;
+
+      default:
+        // eslint-disable-next-line @nomicfoundation/hardhat-internal-rules/only-hardhat-error
+        throw new Error(`Unmatched exit code: ${this.kind}`);
+    }
+  }
+}

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

@@ -0,0 +1,101 @@
+import type { Provider as EdrProviderT } from "@nomicfoundation/edr";
+import type { Address } from "@nomicfoundation/ethereumjs-util";
+import type {
+  MinimalEVMResult,
+  MinimalInterpreterStep,
+  MinimalMessage,
+} from "./types";
+
+import { AsyncEventEmitter } from "@nomicfoundation/ethereumjs-util";
+
+/**
+ * Used by the provider to keep the `_vm` variable used by some plugins. This
+ * interface only has the things used by those plugins.
+ */
+export interface MinimalEthereumJsVm {
+  evm: {
+    events: AsyncEventEmitter<MinimalEthereumJsVmEvents>;
+  };
+  stateManager: {
+    putContractCode: (address: Address, code: Buffer) => Promise<void>;
+    getContractStorage: (address: Address, slotHash: Buffer) => Promise<Buffer>;
+    putContractStorage: (
+      address: Address,
+      slotHash: Buffer,
+      slotValue: Buffer
+    ) => Promise<void>;
+  };
+}
+
+// we need to use a type instead of an interface to satisfy the type constarint
+// of the AsyncEventEmitter type param
+// eslint-disable-next-line @typescript-eslint/consistent-type-definitions
+type MinimalEthereumJsVmEvents = {
+  beforeMessage: (
+    data: MinimalMessage,
+    resolve?: (result?: any) => void
+  ) => void;
+  afterMessage: (
+    data: MinimalEVMResult,
+    resolve?: (result?: any) => void
+  ) => void;
+  step: (
+    data: MinimalInterpreterStep,
+    resolve?: (result?: any) => void
+  ) => void;
+};
+
+export class MinimalEthereumJsVmEventEmitter extends AsyncEventEmitter<MinimalEthereumJsVmEvents> {}
+
+export function getMinimalEthereumJsVm(
+  provider: EdrProviderT
+): MinimalEthereumJsVm {
+  const minimalEthereumJsVm: MinimalEthereumJsVm = {
+    evm: {
+      events: new MinimalEthereumJsVmEventEmitter(),
+    },
+    stateManager: {
+      putContractCode: async (address: Address, code: Buffer) => {
+        await provider.handleRequest(
+          JSON.stringify({
+            method: "hardhat_setCode",
+            params: [`0x${address.toString()}`, `0x${code.toString("hex")}`],
+          })
+        );
+      },
+      getContractStorage: async (address: Address, slotHash: Buffer) => {
+        const responseObject = await provider.handleRequest(
+          JSON.stringify({
+            method: "eth_getStorageAt",
+            params: [
+              `0x${address.toString()}`,
+              `0x${slotHash.toString("hex")}`,
+            ],
+          })
+        );
+
+        const response = JSON.parse(responseObject.json);
+
+        return Buffer.from(response.result.slice(2), "hex");
+      },
+      putContractStorage: async (
+        address: Address,
+        slotHash: Buffer,
+        slotValue: Buffer
+      ) => {
+        await provider.handleRequest(
+          JSON.stringify({
+            method: "hardhat_setStorageAt",
+            params: [
+              `0x${address.toString()}`,
+              `0x${slotHash.toString("hex")}`,
+              `0x${slotValue.toString("hex")}`,
+            ],
+          })
+        );
+      },
+    },
+  };
+
+  return minimalEthereumJsVm;
+}

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

@@ -0,0 +1,31 @@
+import type { Address } from "@nomicfoundation/ethereumjs-util";
+
+/**
+ * These types are minimal versions of the values returned by ethereumjs
+ * in the event listeners.
+ */
+
+export interface MinimalInterpreterStep {
+  pc: number;
+  depth: number;
+  opcode: {
+    name: string;
+  };
+  stack: bigint[];
+}
+
+export interface MinimalExecResult {
+  executionGasUsed: bigint;
+}
+
+export interface MinimalEVMResult {
+  execResult: MinimalExecResult;
+}
+
+export interface MinimalMessage {
+  to?: Address;
+  value: bigint;
+  data: Uint8Array;
+  caller: Address;
+  gasLimit: bigint;
+}