hardhat 2.20.0 → 2.21.0-dev.0

package/src/internal/hardhat-network/stack-traces/vm-tracer.ts

@@ -1,91 +1,44 @@
 import {
-  EVMResult,
-  getActivePrecompiles,
-  InterpreterStep,
-  Message,
-} from "@nomicfoundation/ethereumjs-evm";
-import { Address, bytesToBigInt } from "@nomicfoundation/ethereumjs-util";
-import { VM } from "@nomicfoundation/ethereumjs-vm";
+  CreateOutput,
+  ExecutionResult,
+  TracingMessage,
+  TracingStep,
+} from "@nomicfoundation/edr";
+
+import { bytesToBigInt } from "@nomicfoundation/ethereumjs-util";
+
 import { assertHardhatInvariant } from "../../core/errors";
+import { Exit, ExitCode } from "../provider/vm/exit";
 
 import {
   CallMessageTrace,
   CreateMessageTrace,
   isCreateTrace,
+  isHaltResult,
   isPrecompileTrace,
+  isSuccessResult,
   MessageTrace,
   PrecompileMessageTrace,
 } from "./message-trace";
 
 /* eslint-disable @nomicfoundation/hardhat-internal-rules/only-hardhat-error */
 
-const DUMMY_RETURN_DATA = Uint8Array.from([]);
+const DUMMY_RETURN_DATA = Buffer.from([]);
 const DUMMY_GAS_USED = 0n;
 
 export class VMTracer {
+  public tracingSteps: TracingStep[] = [];
+
   private _messageTraces: MessageTrace[] = [];
-  private _enabled = false;
   private _lastError: Error | undefined;
-  private _maxPrecompileNumber = getActivePrecompiles(this._vm.common).size;
-
-  constructor(
-    private readonly _vm: VM,
-    private readonly _getContractCode: (
-      address: Address
-    ) => Promise<Uint8Array>,
-    private readonly _throwErrors = true
-  ) {
-    this._beforeMessageHandler = this._beforeMessageHandler.bind(this);
-    this._stepHandler = this._stepHandler.bind(this);
-    this._afterMessageHandler = this._afterMessageHandler.bind(this);
-  }
-
-  public enableTracing() {
-    if (this._enabled) {
-      return;
-    }
-    assertHardhatInvariant(
-      this._vm.evm.events !== undefined,
-      "EVM should have an 'events' property"
-    );
-
-    this._vm.evm.events.on("beforeMessage", this._beforeMessageHandler);
-    this._vm.evm.events.on("step", this._stepHandler);
-    this._vm.evm.events.on("afterMessage", this._afterMessageHandler);
-    this._enabled = true;
-  }
-
-  public disableTracing() {
-    if (!this._enabled) {
-      return;
-    }
+  private _maxPrecompileNumber;
 
-    assertHardhatInvariant(
-      this._vm.evm.events !== undefined,
-      "EVM should have an 'events' property"
-    );
-
-    this._vm.evm.events.removeListener(
-      "beforeMessage",
-      this._beforeMessageHandler
-    );
-    this._vm.evm.events.removeListener("step", this._stepHandler);
-    this._vm.evm.events.removeListener(
-      "afterMessage",
-      this._afterMessageHandler
-    );
-    this._enabled = false;
-  }
-
-  public get enabled(): boolean {
-    return this._enabled;
+  constructor(private readonly _throwErrors = true) {
+    // TODO: temporarily hardcoded to remove the need of using ethereumjs' common and evm here
+    this._maxPrecompileNumber = 10;
   }
 
   public getLastTopLevelMessageTrace(): MessageTrace | undefined {
-    if (!this._enabled) {
-      throw new Error("You can't get a vm trace if the VMTracer is disabled");
-    }
-
     return this._messageTraces[0];
   }
 
@@ -101,9 +54,8 @@ export class VMTracer {
     return this._throwErrors || this._lastError === undefined;
   }
 
-  private async _beforeMessageHandler(message: Message, next: any) {
+  public async addBeforeMessage(message: TracingMessage) {
     if (!this._shouldKeepTracing()) {
-      next();
       return;
     }
 
@@ -112,13 +64,15 @@ export class VMTracer {
 
       if (message.depth === 0) {
         this._messageTraces = [];
+        this.tracingSteps = [];
       }
 
       if (message.to === undefined) {
         const createTrace: CreateMessageTrace = {
-          code: new Uint8Array(message.data),
+          code: message.data,
           steps: [],
           value: message.value,
+          exit: new Exit(ExitCode.SUCCESS),
           returnData: DUMMY_RETURN_DATA,
           numberOfSubtraces: 0,
           depth: message.depth,
@@ -128,13 +82,14 @@ export class VMTracer {
 
         trace = createTrace;
       } else {
-        const toAsBigInt = bytesToBigInt(message.to.toBytes());
+        const toAsBigInt = bytesToBigInt(message.to);
 
         if (toAsBigInt > 0 && toAsBigInt <= this._maxPrecompileNumber) {
           const precompileTrace: PrecompileMessageTrace = {
             precompile: Number(toAsBigInt),
-            calldata: new Uint8Array(message.data),
+            calldata: message.data,
             value: message.value,
+            exit: new Exit(ExitCode.SUCCESS),
             returnData: DUMMY_RETURN_DATA,
             depth: message.depth,
             gasUsed: DUMMY_GAS_USED,
@@ -144,19 +99,29 @@ export class VMTracer {
         } else {
           const codeAddress = message.codeAddress;
 
-          const code = await this._getContractCode(codeAddress);
+          // if we enter here, then `to` is not undefined, therefore
+          // `codeAddress` and `code` should be defined
+          assertHardhatInvariant(
+            codeAddress !== undefined,
+            "codeAddress should be defined"
+          );
+          assertHardhatInvariant(
+            message.code !== undefined,
+            "code should be defined"
+          );
 
           const callTrace: CallMessageTrace = {
-            code,
-            calldata: new Uint8Array(message.data),
+            code: message.code,
+            calldata: message.data,
             steps: [],
             value: message.value,
+            exit: new Exit(ExitCode.SUCCESS),
             returnData: DUMMY_RETURN_DATA,
-            address: message.to.toBytes(),
+            address: message.to,
             numberOfSubtraces: 0,
             depth: message.depth,
             gasUsed: DUMMY_GAS_USED,
-            codeAddress: codeAddress.toBytes(),
+            codeAddress,
           };
 
           trace = callTrace;
@@ -177,23 +142,22 @@ export class VMTracer {
       }
 
       this._messageTraces.push(trace);
-      next();
     } catch (error) {
       if (this._throwErrors) {
-        next(error);
+        throw error;
       } else {
         this._lastError = error as Error;
-        next();
       }
     }
   }
 
-  private async _stepHandler(step: InterpreterStep, next: any) {
+  public async addStep(step: TracingStep) {
     if (!this._shouldKeepTracing()) {
-      next();
       return;
     }
 
+    this.tracingSteps.push(step);
+
     try {
       const trace = this._messageTraces[this._messageTraces.length - 1];
 
@@ -203,46 +167,54 @@ export class VMTracer {
         );
       }
 
-      trace.steps.push({ pc: step.pc });
-      next();
+      trace.steps.push({ pc: Number(step.pc) });
     } catch (error) {
       if (this._throwErrors) {
-        next(error);
+        throw error;
       } else {
         this._lastError = error as Error;
-        next();
       }
     }
   }
 
-  private async _afterMessageHandler(result: EVMResult, next: any) {
+  public async addAfterMessage(result: ExecutionResult, haltOverride?: Exit) {
     if (!this._shouldKeepTracing()) {
-      next();
       return;
     }
 
     try {
       const trace = this._messageTraces[this._messageTraces.length - 1];
+      trace.gasUsed = result.result.gasUsed;
 
-      trace.error = result.execResult.exceptionError;
-      trace.returnData = result.execResult.returnValue;
-      trace.gasUsed = result.execResult.executionGasUsed;
+      const executionResult = result.result;
+      if (isSuccessResult(executionResult)) {
+        trace.exit = Exit.fromEdrSuccessReason(executionResult.reason);
+        trace.returnData = executionResult.output.returnValue;
 
-      if (isCreateTrace(trace)) {
-        trace.deployedContract = result?.createdAddress?.toBytes();
+        if (isCreateTrace(trace)) {
+          trace.deployedContract = (
+            executionResult.output as CreateOutput
+          ).address;
+        }
+      } else if (isHaltResult(executionResult)) {
+        trace.exit =
+          haltOverride ?? Exit.fromEdrExceptionalHalt(executionResult.reason);
+
+        trace.returnData = Buffer.from([]);
+      } else {
+        trace.exit = new Exit(ExitCode.REVERT);
+
+        trace.returnData = executionResult.output;
       }
 
       if (this._messageTraces.length > 1) {
         this._messageTraces.pop();
       }
-
-      next();
     } catch (error) {
       if (this._throwErrors) {
-        next(error);
+        throw error;
       } else {
         this._lastError = error as Error;
-        next();
       }
     }
   }

package/src/internal/util/date.ts

@@ -6,6 +6,10 @@ export function dateToTimestampSeconds(date: Date): number {
   return Math.floor(date.valueOf() / 1000);
 }
 
+export function timestampSecondsToDate(timestamp: number): Date {
+  return new Date(timestamp * 1000);
+}
+
 export function getDifferenceInSeconds(a: Date, b: Date): number {
   return Math.floor((a.valueOf() - b.valueOf()) / 1000);
 }

package/src/internal/util/hardforks.ts

@@ -1,4 +1,9 @@
+import { HardforkHistoryConfig } from "../../types/config";
+import { HARDHAT_NETWORK_SUPPORTED_HARDFORKS } from "../constants";
 import { assertHardhatInvariant } from "../core/errors";
+import { InternalError } from "../core/providers/errors";
+
+/* eslint-disable @nomicfoundation/hardhat-internal-rules/only-hardhat-error */
 
 export enum HardforkName {
   FRONTIER = "chainstart",
@@ -69,3 +74,50 @@ export function hardforkGte(
 
   return indexA >= indexB;
 }
+
+export function selectHardfork(
+  forkBlockNumber: bigint | undefined,
+  currentHardfork: string,
+  hardforkActivations: HardforkHistoryConfig | undefined,
+  blockNumber: bigint
+): string {
+  if (forkBlockNumber === undefined || blockNumber > forkBlockNumber) {
+    return currentHardfork;
+  }
+
+  if (hardforkActivations === undefined || hardforkActivations.size === 0) {
+    throw new InternalError(
+      `No known hardfork for execution on historical block ${blockNumber.toString()} (relative to fork block number ${forkBlockNumber}). The node was not configured with a hardfork activation history.  See http://hardhat.org/custom-hardfork-history`
+    );
+  }
+
+  /** search this._hardforkActivations for the highest block number that
+   * isn't higher than blockNumber, and then return that found block number's
+   * associated hardfork name. */
+  const hardforkHistory: Array<[name: string, block: number]> = Array.from(
+    hardforkActivations.entries()
+  );
+  const [hardfork, activationBlock] = hardforkHistory.reduce(
+    ([highestHardfork, highestBlock], [thisHardfork, thisBlock]) =>
+      thisBlock > highestBlock && thisBlock <= blockNumber
+        ? [thisHardfork, thisBlock]
+        : [highestHardfork, highestBlock]
+  );
+  if (hardfork === undefined || blockNumber < activationBlock) {
+    throw new InternalError(
+      `Could not find a hardfork to run for block ${blockNumber.toString()}, after having looked for one in the hardfork activation history, which was: ${JSON.stringify(
+        hardforkHistory
+      )}. For more information, see https://hardhat.org/hardhat-network/reference/#config`
+    );
+  }
+
+  if (!HARDHAT_NETWORK_SUPPORTED_HARDFORKS.includes(hardfork)) {
+    throw new InternalError(
+      `Tried to run a call or transaction in the context of a block whose hardfork is "${hardfork}", but Hardhat Network only supports the following hardforks: ${HARDHAT_NETWORK_SUPPORTED_HARDFORKS.join(
+        ", "
+      )}`
+    );
+  }
+
+  return hardfork;
+}

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

@@ -1,185 +0,0 @@
-import { Block, BlockHeader } from "@nomicfoundation/ethereumjs-block";
-import {
-  BlockchainInterface,
-  CasperConsensus,
-  CliqueConsensus,
-  Consensus,
-  EthashConsensus,
-} from "@nomicfoundation/ethereumjs-blockchain";
-import { Common, ConsensusAlgorithm } from "@nomicfoundation/ethereumjs-common";
-import { TypedTransaction } from "@nomicfoundation/ethereumjs-tx";
-
-import { assertHardhatInvariant } from "../../core/errors";
-import * as BigIntUtils from "../../util/bigint";
-import { BlockchainData } from "./BlockchainData";
-import { RpcReceiptOutput } from "./output";
-
-/* eslint-disable @nomicfoundation/hardhat-internal-rules/only-hardhat-error */
-
-export abstract class BlockchainBase {
-  public consensus: Consensus;
-  protected readonly _data: BlockchainData;
-
-  constructor(protected _common: Common) {
-    this._data = new BlockchainData(_common);
-
-    // copied from blockchain.ts in @nomicfoundation/ethereumjs-blockchain
-    switch (this._common.consensusAlgorithm()) {
-      case ConsensusAlgorithm.Casper:
-        this.consensus = new CasperConsensus();
-        break;
-      case ConsensusAlgorithm.Clique:
-        this.consensus = new CliqueConsensus();
-        break;
-      case ConsensusAlgorithm.Ethash:
-        this.consensus = new EthashConsensus();
-        break;
-      default:
-        throw new Error(
-          `consensus algorithm ${this._common.consensusAlgorithm()} not supported`
-        );
-    }
-  }
-
-  public abstract addBlock(block: Block): Promise<Block>;
-
-  public addTransactionReceipts(receipts: RpcReceiptOutput[]) {
-    for (const receipt of receipts) {
-      this._data.addTransactionReceipt(receipt);
-    }
-  }
-
-  public async delBlock(blockHash: Buffer) {
-    this.deleteBlock(blockHash);
-  }
-
-  public deleteBlock(blockHash: Buffer) {
-    const block = this._data.getBlockByHash(blockHash);
-    if (block === undefined) {
-      throw new Error("Block not found");
-    }
-    this._delBlock(block.header.number);
-  }
-
-  public async getBlock(
-    blockHashOrNumber: Buffer | bigint | number
-  ): Promise<Block> {
-    if (
-      (typeof blockHashOrNumber === "number" ||
-        BigIntUtils.isBigInt(blockHashOrNumber)) &&
-      this._data.isReservedBlock(BigInt(blockHashOrNumber))
-    ) {
-      this._data.fulfillBlockReservation(BigInt(blockHashOrNumber));
-    }
-
-    if (typeof blockHashOrNumber === "number") {
-      const blockByNumber = this._data.getBlockByNumber(
-        BigInt(blockHashOrNumber)
-      );
-      if (blockByNumber === undefined) {
-        throw new Error("Block not found");
-      }
-      return blockByNumber;
-    }
-    if (BigIntUtils.isBigInt(blockHashOrNumber)) {
-      const blockByNumber = this._data.getBlockByNumber(blockHashOrNumber);
-      if (blockByNumber === undefined) {
-        throw new Error("Block not found");
-      }
-      return blockByNumber;
-    }
-    const blockByHash = this._data.getBlockByHash(blockHashOrNumber);
-    if (blockByHash === undefined) {
-      throw new Error("Block not found");
-    }
-    return blockByHash;
-  }
-
-  public abstract getLatestBlockNumber(): bigint;
-
-  public async getLatestBlock(): Promise<Block> {
-    return this.getBlock(this.getLatestBlockNumber());
-  }
-
-  public getLocalTransaction(
-    transactionHash: Buffer
-  ): TypedTransaction | undefined {
-    return this._data.getTransaction(transactionHash);
-  }
-
-  public iterator(
-    _name: string,
-    _onBlock: (block: Block, reorg: boolean) => void | Promise<void>
-  ): Promise<number> {
-    throw new Error("Method not implemented.");
-  }
-
-  public async putBlock(block: Block): Promise<void> {
-    await this.addBlock(block);
-  }
-
-  public reserveBlocks(
-    count: bigint,
-    interval: bigint,
-    previousBlockStateRoot: Buffer,
-    previousBlockTotalDifficulty: bigint,
-    previousBlockBaseFeePerGas: bigint | undefined
-  ) {
-    this._data.reserveBlocks(
-      this.getLatestBlockNumber() + 1n,
-      count,
-      interval,
-      previousBlockStateRoot,
-      previousBlockTotalDifficulty,
-      previousBlockBaseFeePerGas
-    );
-  }
-
-  public copy(): BlockchainInterface {
-    throw new Error("Method not implemented.");
-  }
-
-  public validateHeader(
-    _header: BlockHeader,
-    _height?: bigint | undefined
-  ): Promise<void> {
-    throw new Error("Method not implemented.");
-  }
-
-  protected _delBlock(blockNumber: bigint): void {
-    let i = blockNumber;
-
-    while (i <= this.getLatestBlockNumber()) {
-      if (this._data.isReservedBlock(i)) {
-        const reservation = this._data.cancelReservationWithBlock(i);
-        i = reservation.last + 1n;
-      } else {
-        const current = this._data.getBlockByNumber(i);
-        if (current !== undefined) {
-          this._data.removeBlock(current);
-        }
-        i++;
-      }
-    }
-  }
-
-  protected async _computeTotalDifficulty(block: Block): Promise<bigint> {
-    const difficulty = block.header.difficulty;
-    const blockNumber = block.header.number;
-
-    if (blockNumber === 0n) {
-      return difficulty;
-    }
-
-    const parentBlock = await this.getBlock(blockNumber - 1n);
-
-    const parentHash = parentBlock.hash();
-    const parentTD = this._data.getTotalDifficulty(parentHash);
-    assertHardhatInvariant(
-      parentTD !== undefined,
-      "Parent block should have total difficulty"
-    );
-
-    return parentTD + difficulty;
-  }
-}