hardhat 2.20.0 → 2.21.0-dev.0

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

@@ -1,261 +0,0 @@
-import { Block } from "@nomicfoundation/ethereumjs-block";
-import { Common } from "@nomicfoundation/ethereumjs-common";
-import { TypedTransaction } from "@nomicfoundation/ethereumjs-tx";
-import { bytesToHex as bufferToHex } from "@nomicfoundation/ethereumjs-util";
-import { Bloom } from "@nomicfoundation/ethereumjs-vm";
-
-import { assertHardhatInvariant } from "../../core/errors";
-import { bloomFilter, filterLogs } from "./filter";
-import { FilterParams } from "./node-types";
-import { RpcLogOutput, RpcReceiptOutput } from "./output";
-
-interface Reservation {
-  first: bigint;
-  last: bigint;
-  interval: bigint;
-  previousBlockStateRoot: Buffer;
-  previousBlockTotalDifficulty: bigint;
-  previousBlockBaseFeePerGas: bigint | undefined;
-}
-
-export class BlockchainData {
-  private _blocksByNumber: Map<bigint, Block> = new Map();
-  private _blocksByHash: Map<string, Block> = new Map();
-  private _blocksByTransactions: Map<string, Block> = new Map();
-  private _transactions: Map<string, TypedTransaction> = new Map();
-  private _transactionReceipts: Map<string, RpcReceiptOutput> = new Map();
-  private _totalDifficulty: Map<string, bigint> = new Map();
-  private _blockReservations: Reservation[] = new Array();
-
-  constructor(private _common: Common) {}
-
-  public reserveBlocks(
-    first: bigint,
-    count: bigint,
-    interval: bigint,
-    previousBlockStateRoot: Buffer,
-    previousBlockTotalDifficulty: bigint,
-    previousBlockBaseFeePerGas: bigint | undefined
-  ) {
-    const reservation: Reservation = {
-      first,
-      last: first + count - 1n,
-      interval,
-      previousBlockStateRoot,
-      previousBlockTotalDifficulty,
-      previousBlockBaseFeePerGas,
-    };
-    this._blockReservations.push(reservation);
-  }
-
-  public getBlockByNumber(blockNumber: bigint) {
-    return this._blocksByNumber.get(blockNumber);
-  }
-
-  public getBlockByHash(blockHash: Uint8Array) {
-    return this._blocksByHash.get(bufferToHex(blockHash));
-  }
-
-  public getBlockByTransactionHash(transactionHash: Uint8Array) {
-    return this._blocksByTransactions.get(bufferToHex(transactionHash));
-  }
-
-  public getTransaction(transactionHash: Uint8Array) {
-    return this._transactions.get(bufferToHex(transactionHash));
-  }
-
-  public getTransactionReceipt(transactionHash: Uint8Array) {
-    return this._transactionReceipts.get(bufferToHex(transactionHash));
-  }
-
-  public getTotalDifficulty(blockHash: Uint8Array) {
-    return this._totalDifficulty.get(bufferToHex(blockHash));
-  }
-
-  public getLogs(filterParams: FilterParams) {
-    const logs: RpcLogOutput[] = [];
-    for (let i = filterParams.fromBlock; i <= filterParams.toBlock; i++) {
-      const block = this.getBlockByNumber(i);
-      if (
-        block === undefined ||
-        !bloomFilter(
-          new Bloom(block.header.logsBloom),
-          filterParams.addresses,
-          filterParams.normalizedTopics
-        )
-      ) {
-        continue;
-      }
-      for (const transaction of block.transactions) {
-        const receipt = this.getTransactionReceipt(transaction.hash());
-        if (receipt !== undefined) {
-          logs.push(
-            ...filterLogs(receipt.logs, {
-              fromBlock: filterParams.fromBlock,
-              toBlock: filterParams.toBlock,
-              addresses: filterParams.addresses,
-              normalizedTopics: filterParams.normalizedTopics,
-            })
-          );
-        }
-      }
-    }
-    return logs;
-  }
-
-  public addBlock(block: Block, totalDifficulty: bigint) {
-    const blockHash = bufferToHex(block.hash());
-    const blockNumber = block.header.number;
-    this._blocksByNumber.set(blockNumber, block);
-    this._blocksByHash.set(blockHash, block);
-    this._totalDifficulty.set(blockHash, totalDifficulty);
-
-    for (const transaction of block.transactions) {
-      const transactionHash = bufferToHex(transaction.hash());
-      this._transactions.set(transactionHash, transaction);
-      this._blocksByTransactions.set(transactionHash, block);
-    }
-  }
-
-  /**
-   * WARNING: this method can leave the blockchain in an invalid state where
-   * there are gaps between blocks. Ideally we should have a method that removes
-   * the given block and all the following blocks.
-   */
-  public removeBlock(block: Block) {
-    const blockHash = bufferToHex(block.hash());
-    const blockNumber = block.header.number;
-    this._blocksByNumber.delete(blockNumber);
-    this._blocksByHash.delete(blockHash);
-    this._totalDifficulty.delete(blockHash);
-
-    for (const transaction of block.transactions) {
-      const transactionHash = bufferToHex(transaction.hash());
-      this._transactions.delete(transactionHash);
-      this._transactionReceipts.delete(transactionHash);
-      this._blocksByTransactions.delete(transactionHash);
-    }
-  }
-
-  public addTransaction(transaction: TypedTransaction) {
-    this._transactions.set(bufferToHex(transaction.hash()), transaction);
-  }
-
-  public addTransactionReceipt(receipt: RpcReceiptOutput) {
-    this._transactionReceipts.set(receipt.transactionHash, receipt);
-  }
-
-  public isReservedBlock(blockNumber: bigint): boolean {
-    return this._findBlockReservation(blockNumber) !== -1;
-  }
-
-  private _findBlockReservation(blockNumber: bigint): number {
-    return this._blockReservations.findIndex(
-      (reservation) =>
-        reservation.first <= blockNumber && blockNumber <= reservation.last
-    );
-  }
-
-  /**
-   * WARNING: this method only removes the given reservation and can result in
-   * gaps in the reservations array. Ideally we should have a method that
-   * removes the given reservation and all the following reservations.
-   */
-  private _removeReservation(index: number): Reservation {
-    assertHardhatInvariant(
-      index in this._blockReservations,
-      `Reservation ${index} does not exist`
-    );
-    const reservation = this._blockReservations[index];
-
-    this._blockReservations.splice(index, 1);
-
-    return reservation;
-  }
-
-  /**
-   * Cancel and return the reservation that has block `blockNumber`
-   */
-  public cancelReservationWithBlock(blockNumber: bigint): Reservation {
-    return this._removeReservation(this._findBlockReservation(blockNumber));
-  }
-
-  public fulfillBlockReservation(blockNumber: bigint) {
-    // in addition to adding the given block, the reservation needs to be split
-    // in two in order to accomodate access to the given block.
-
-    const reservationIndex = this._findBlockReservation(blockNumber);
-    assertHardhatInvariant(
-      reservationIndex !== -1,
-      `No reservation to fill for block number ${blockNumber.toString()}`
-    );
-
-    // capture the timestamp before removing the reservation:
-    const timestamp = this._calculateTimestampForReservedBlock(blockNumber);
-
-    // split the block reservation:
-    const oldReservation = this._removeReservation(reservationIndex);
-
-    if (blockNumber !== oldReservation.first) {
-      this._blockReservations.push({
-        ...oldReservation,
-        last: blockNumber - 1n,
-      });
-    }
-
-    if (blockNumber !== oldReservation.last) {
-      this._blockReservations.push({
-        ...oldReservation,
-        first: blockNumber + 1n,
-      });
-    }
-
-    this.addBlock(
-      Block.fromBlockData(
-        {
-          header: {
-            number: blockNumber,
-            stateRoot: oldReservation.previousBlockStateRoot,
-            baseFeePerGas: oldReservation.previousBlockBaseFeePerGas,
-            timestamp,
-          },
-        },
-        {
-          common: this._common,
-          skipConsensusFormatValidation: true,
-        }
-      ),
-      oldReservation.previousBlockTotalDifficulty
-    );
-  }
-
-  private _calculateTimestampForReservedBlock(blockNumber: bigint): bigint {
-    const reservationIndex = this._findBlockReservation(blockNumber);
-
-    assertHardhatInvariant(
-      reservationIndex !== -1,
-      `Block ${blockNumber.toString()} does not lie within any of the reservations.`
-    );
-
-    const reservation = this._blockReservations[reservationIndex];
-
-    const blockNumberBeforeReservation = reservation.first - 1n;
-
-    const blockBeforeReservation = this.getBlockByNumber(
-      blockNumberBeforeReservation
-    );
-    assertHardhatInvariant(
-      blockBeforeReservation !== undefined,
-      `Reservation after block ${blockNumberBeforeReservation.toString()} cannot be created because that block does not exist`
-    );
-
-    const previousTimestamp = this.isReservedBlock(blockNumberBeforeReservation)
-      ? this._calculateTimestampForReservedBlock(blockNumberBeforeReservation)
-      : blockBeforeReservation.header.timestamp;
-
-    return (
-      previousTimestamp +
-      reservation.interval * (blockNumber - reservation.first + 1n)
-    );
-  }
-}

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

@@ -1,140 +0,0 @@
-import { Block } from "@nomicfoundation/ethereumjs-block";
-import {
-  BlockchainInterface,
-  BlockchainEvents,
-} from "@nomicfoundation/ethereumjs-blockchain";
-import { Common } from "@nomicfoundation/ethereumjs-common";
-import { TypedTransaction } from "@nomicfoundation/ethereumjs-tx";
-import {
-  AsyncEventEmitter,
-  equalsBytes,
-  zeros,
-} from "@nomicfoundation/ethereumjs-util";
-
-import { BlockchainBase } from "./BlockchainBase";
-import { FilterParams } from "./node-types";
-import { RpcLogOutput } from "./output";
-import { HardhatBlockchainInterface } from "./types/HardhatBlockchainInterface";
-
-/* eslint-disable @nomicfoundation/hardhat-internal-rules/only-hardhat-error */
-
-export class HardhatBlockchain
-  extends BlockchainBase
-  implements HardhatBlockchainInterface
-{
-  private _length = 0n;
-  public events?: AsyncEventEmitter<BlockchainEvents> | undefined;
-
-  constructor(common: Common) {
-    super(common);
-  }
-
-  public shallowCopy(): BlockchainInterface {
-    return this;
-  }
-
-  public getIteratorHead(_name?: string | undefined): Promise<Block> {
-    throw new Error("Method not implemented.");
-  }
-
-  public setIteratorHead(_tag: string, _headHash: Uint8Array): Promise<void> {
-    throw new Error("Method not implemented.");
-  }
-
-  public getCanonicalHeadBlock(): Promise<Block> {
-    throw new Error("Method not implemented.");
-  }
-
-  public getLatestBlockNumber(): bigint {
-    return BigInt(this._length - 1n);
-  }
-
-  public async addBlock(block: Block): Promise<Block> {
-    this._validateBlock(block);
-    const totalDifficulty = await this._computeTotalDifficulty(block);
-    this._data.addBlock(block, totalDifficulty);
-    this._length += 1n;
-    return block;
-  }
-
-  public reserveBlocks(
-    count: bigint,
-    interval: bigint,
-    previousBlockStateRoot: Buffer,
-    previousBlockTotalDifficulty: bigint,
-    previousBlockBaseFeePerGas: bigint | undefined
-  ) {
-    super.reserveBlocks(
-      count,
-      interval,
-      previousBlockStateRoot,
-      previousBlockTotalDifficulty,
-      previousBlockBaseFeePerGas
-    );
-    this._length += count;
-  }
-
-  public deleteLaterBlocks(block: Block): void {
-    const actual = this._data.getBlockByHash(block.hash());
-    if (actual === undefined) {
-      throw new Error("Invalid block");
-    }
-
-    this._delBlock(actual.header.number + 1n);
-  }
-
-  public async getTotalDifficulty(blockHash: Buffer): Promise<bigint> {
-    const totalDifficulty = this._data.getTotalDifficulty(blockHash);
-    if (totalDifficulty === undefined) {
-      throw new Error("Block not found");
-    }
-    return totalDifficulty;
-  }
-
-  public async getTransaction(
-    transactionHash: Buffer
-  ): Promise<TypedTransaction | undefined> {
-    return this.getLocalTransaction(transactionHash);
-  }
-
-  public async getBlockByTransactionHash(
-    transactionHash: Buffer
-  ): Promise<Block | null> {
-    const block = this._data.getBlockByTransactionHash(transactionHash);
-    return block ?? null;
-  }
-
-  public async getTransactionReceipt(transactionHash: Buffer) {
-    return this._data.getTransactionReceipt(transactionHash) ?? null;
-  }
-
-  public async getLogs(filterParams: FilterParams): Promise<RpcLogOutput[]> {
-    return this._data.getLogs(filterParams);
-  }
-
-  private _validateBlock(block: Block) {
-    const blockNumber = block.header.number;
-    const parentHash = block.header.parentHash;
-    const parent = this._data.getBlockByNumber(BigInt(blockNumber - 1n));
-
-    if (BigInt(this._length) !== blockNumber) {
-      throw new Error(
-        `Invalid block number ${blockNumber}. Expected ${this._length}.`
-      );
-    }
-
-    if (
-      (blockNumber === 0n && !equalsBytes(parentHash, zeros(32))) ||
-      (blockNumber > 0 &&
-        parent !== undefined &&
-        !equalsBytes(parentHash, parent.hash()))
-    ) {
-      throw new Error("Invalid parent hash");
-    }
-  }
-
-  protected _delBlock(blockNumber: bigint): void {
-    super._delBlock(blockNumber);
-    this._length = blockNumber;
-  }
-}

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

@@ -1,48 +0,0 @@
-import { TypedTransaction } from "@nomicfoundation/ethereumjs-tx";
-import {
-  List as ImmutableList,
-  Map as ImmutableMap,
-  Record as ImmutableRecord,
-} from "immutable";
-
-import * as BigIntUtils from "../../util/bigint";
-
-export interface OrderedTransaction {
-  orderId: number;
-  data: TypedTransaction;
-}
-
-interface ImmutableOrderedTransaction {
-  orderId: number;
-  fakeFrom: string | undefined;
-  data: string;
-  txType: number;
-}
-
-export const makeSerializedTransaction =
-  ImmutableRecord<ImmutableOrderedTransaction>({
-    orderId: 0,
-    fakeFrom: undefined,
-    data: "",
-    txType: 0,
-  });
-
-export type SerializedTransaction =
-  ImmutableRecord<ImmutableOrderedTransaction>;
-export type SenderTransactions = ImmutableList<SerializedTransaction>;
-export type AddressToTransactions = ImmutableMap<string, SenderTransactions>;
-export type HashToTransaction = ImmutableMap<string, SerializedTransaction>;
-
-export interface PoolState {
-  pendingTransactions: AddressToTransactions; // address => list of serialized pending Transactions
-  queuedTransactions: AddressToTransactions; // address => list of serialized queued Transactions
-  hashToTransaction: HashToTransaction;
-  blockGasLimit: string;
-}
-
-export const makePoolState = ImmutableRecord<PoolState>({
-  pendingTransactions: ImmutableMap<string, SenderTransactions>(),
-  queuedTransactions: ImmutableMap<string, SenderTransactions>(),
-  hashToTransaction: ImmutableMap<string, SerializedTransaction>(),
-  blockGasLimit: BigIntUtils.toHex(9500000),
-});

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

@@ -1,158 +0,0 @@
-import { TypedTransaction } from "@nomicfoundation/ethereumjs-tx";
-import Heap from "mnemonist/heap";
-
-import { InternalError, InvalidInputError } from "../../core/providers/errors";
-import * as BigIntUtils from "../../util/bigint";
-import { MempoolOrder } from "./node-types";
-import { OrderedTransaction } from "./PoolState";
-
-function getEffectiveMinerFee(
-  tx: OrderedTransaction,
-  baseFee?: bigint
-): bigint {
-  // This mimics the EIP-1559 normalize_transaction function
-  const maxFeePerGas =
-    "gasPrice" in tx.data ? tx.data.gasPrice : tx.data.maxFeePerGas;
-
-  const maxPriorityFeePerGas =
-    "gasPrice" in tx.data ? tx.data.gasPrice : tx.data.maxPriorityFeePerGas;
-
-  if (baseFee === undefined) {
-    return maxFeePerGas;
-  }
-
-  return BigIntUtils.min(maxPriorityFeePerGas, maxFeePerGas - baseFee);
-}
-
-function decreasingOrderEffectiveMinerFeeComparator(
-  left: OrderedTransaction,
-  right: OrderedTransaction,
-  baseFee?: bigint
-) {
-  const leftEffectiveMinerFee = getEffectiveMinerFee(left, baseFee);
-  const rightEffectiveMinerFee = getEffectiveMinerFee(right, baseFee);
-
-  const cmp = BigIntUtils.cmp(rightEffectiveMinerFee, leftEffectiveMinerFee);
-
-  if (cmp !== 0) {
-    return cmp;
-  }
-
-  // If two txs have the same effective miner fee we want to sort them
-  // in increasing order by orderId.
-  return left.orderId - right.orderId;
-}
-
-function decreasingOrderComparator(
-  left: OrderedTransaction,
-  right: OrderedTransaction
-) {
-  return left.orderId - right.orderId;
-}
-
-function getOrderedTransactionHeap(
-  mempoolOrder: MempoolOrder,
-  baseFee?: bigint
-): Heap<OrderedTransaction> {
-  switch (mempoolOrder) {
-    case "priority":
-      return new Heap<OrderedTransaction>((a, b) =>
-        decreasingOrderEffectiveMinerFeeComparator(a, b, baseFee)
-      );
-    case "fifo":
-      return new Heap<OrderedTransaction>((a, b) =>
-        decreasingOrderComparator(a, b)
-      );
-    default:
-      // eslint-disable-next-line @nomicfoundation/hardhat-internal-rules/only-hardhat-error
-      throw new InvalidInputError(
-        `Invalid mempool order: ${mempoolOrder as any}`
-      );
-  }
-}
-
-/**
- * A queue of transactions in the order that they could be mined in the next
- * block.
- *
- * A transaction being part of this queue doesn't mean that it will be mined in
- * the next block, as it may not meet the required criteria to be included or
- * may not fit within the block.
- *
- * If after getting the next transaction in the queue you decided not to mine
- * it, the other transactions that belong to that sender MUST be removed from
- * the queue by calling the #removeLastSenderTransactions() method.
- **/
-export class TransactionQueue {
-  private readonly _queuedTransactions: Map<string, OrderedTransaction[]> =
-    new Map();
-
-  private readonly _heap: Heap<OrderedTransaction>;
-
-  private _lastTransactionSender?: string;
-
-  /**
-   * Creates a TransactionQueue.
-   *
-   * @param pendingTransactions A map of sender to a list of their transactions,
-   *  sorted by nonce and without nonce gaps.
-   * @param baseFee The base fee of the next block, if it's going to use EIP-1559
-   */
-  constructor(
-    pendingTransactions: Map<string, OrderedTransaction[]>,
-    mempoolOrder: MempoolOrder,
-    baseFee?: bigint
-  ) {
-    this._heap = getOrderedTransactionHeap(mempoolOrder, baseFee);
-
-    for (const [address, txList] of pendingTransactions) {
-      if (baseFee === undefined && txList.some((tx) => tx.data.type === 2)) {
-        // eslint-disable-next-line @nomicfoundation/hardhat-internal-rules/only-hardhat-error
-        throw new InternalError(
-          "Trying to initialize and sort a mempool with an EIP-1559 tx but no base fee"
-        );
-      }
-
-      const [firstTx, ...remainingTxs] = txList;
-      this._heap.push(firstTx);
-      this._queuedTransactions.set(address, remainingTxs);
-    }
-  }
-
-  public getNextTransaction(): TypedTransaction | undefined {
-    if (this._lastTransactionSender !== undefined) {
-      this._moveFirstEnqueuedTransactionToHeap(this._lastTransactionSender);
-    }
-
-    const nextTx = this._heap.pop();
-    if (nextTx === undefined) {
-      return undefined;
-    }
-
-    this._lastTransactionSender = nextTx.data.getSenderAddress().toString();
-    return nextTx.data;
-  }
-
-  public removeLastSenderTransactions() {
-    if (this._lastTransactionSender === undefined) {
-      // eslint-disable-next-line @nomicfoundation/hardhat-internal-rules/only-hardhat-error
-      throw new InternalError(
-        "TransactionQueue#removeLastSenderTransactions called before TransactionQueue#getNextTransaction"
-      );
-    }
-
-    this._queuedTransactions.delete(this._lastTransactionSender);
-    this._lastTransactionSender = undefined;
-  }
-
-  private _moveFirstEnqueuedTransactionToHeap(sender: string) {
-    const queue = this._queuedTransactions.get(sender);
-    if (queue === undefined || queue.length === 0) {
-      return;
-    }
-
-    const [first, ...rest] = queue;
-    this._heap.push(first);
-    this._queuedTransactions.set(sender, rest);
-  }
-}