hardhat 2.20.1 → 2.21.0-dev.1

package/src/internal/hardhat-network/provider/ethereumjs-workarounds.ts

@@ -1,21 +0,0 @@
-import { TransactionFactory } from "@nomicfoundation/ethereumjs-tx";
-import { BaseTransaction } from "@nomicfoundation/ethereumjs-tx/dist/cjs/baseTransaction";
-import {
-  TxOptions,
-  TypedTxData,
-} from "@nomicfoundation/ethereumjs-tx/dist/cjs/types";
-
-// This is a hack to prevent Block.fromBlockData from recreating our
-// transactions and changing their types. Note fromBlockData is used
-// by the BlockBuilder to update block it's building.
-const previousFromTxData = TransactionFactory.fromTxData;
-(TransactionFactory as any).fromTxData = function (
-  txData: TypedTxData,
-  txOptions?: TxOptions
-) {
-  if (txData instanceof BaseTransaction) {
-    return txData;
-  }
-
-  return previousFromTxData.call(this, txData, txOptions);
-};

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

@@ -1,142 +0,0 @@
-import {
-  bytesToHex as bufferToHex,
-  toBytes,
-} from "@nomicfoundation/ethereumjs-util";
-import { Bloom } from "@nomicfoundation/ethereumjs-vm";
-
-import { RpcLogOutput } from "./output";
-
-export const LATEST_BLOCK = -1n;
-
-export enum Type {
-  LOGS_SUBSCRIPTION = 0,
-  PENDING_TRANSACTION_SUBSCRIPTION = 1,
-  BLOCK_SUBSCRIPTION = 2,
-}
-
-export interface FilterCriteria {
-  fromBlock: bigint;
-  toBlock: bigint;
-  addresses: Uint8Array[];
-  normalizedTopics: Array<Array<Uint8Array | null> | null>;
-}
-
-export interface Filter {
-  id: bigint;
-  type: Type;
-  criteria?: FilterCriteria;
-  deadline: Date;
-  hashes: string[];
-  logs: RpcLogOutput[];
-  subscription: boolean;
-}
-
-export function bloomFilter(
-  bloom: Bloom,
-  addresses: Uint8Array[],
-  normalizedTopics: Array<Array<Uint8Array | null> | null>
-): boolean {
-  if (addresses.length > 0) {
-    let included = false;
-    for (const address of addresses) {
-      if (bloom.check(address)) {
-        included = true;
-        break;
-      }
-    }
-
-    if (!included) {
-      return false;
-    }
-  }
-
-  for (const sub of normalizedTopics) {
-    if (sub === null || sub.length === 0) {
-      continue;
-    }
-
-    let included = false;
-    for (const topic of sub) {
-      if (topic !== null && bloom.check(topic)) {
-        included = true;
-        break;
-      }
-    }
-
-    if (!included) {
-      return false;
-    }
-  }
-  return true;
-}
-
-export function filterLogs(
-  logs: RpcLogOutput[],
-  criteria: FilterCriteria
-): RpcLogOutput[] {
-  const filteredLogs: RpcLogOutput[] = [];
-  for (const log of logs) {
-    const blockNumber = BigInt(log.blockNumber!);
-    if (blockNumber < criteria.fromBlock) {
-      continue;
-    }
-
-    if (criteria.toBlock !== LATEST_BLOCK && blockNumber > criteria.toBlock) {
-      continue;
-    }
-
-    if (
-      criteria.addresses.length !== 0 &&
-      !includes(criteria.addresses, toBytes(log.address))
-    ) {
-      continue;
-    }
-
-    if (!topicMatched(criteria.normalizedTopics, log.topics)) {
-      continue;
-    }
-
-    filteredLogs.push(log);
-  }
-
-  return filteredLogs;
-}
-
-export function includes(addresses: Uint8Array[], a: Uint8Array): boolean {
-  for (const address of addresses) {
-    if (Buffer.compare(address, a) === 0) {
-      return true;
-    }
-  }
-
-  return false;
-}
-
-export function topicMatched(
-  normalizedTopics: Array<Array<Uint8Array | null> | null>,
-  logTopics: string[]
-): boolean {
-  for (let i = 0; i < normalizedTopics.length; i++) {
-    if (normalizedTopics.length > logTopics.length) {
-      return false;
-    }
-
-    const sub = normalizedTopics[i];
-    if (sub === null || sub.length === 0) {
-      continue;
-    }
-
-    let match: boolean = false;
-    for (const topic of sub) {
-      if (topic === null || logTopics[i] === bufferToHex(topic)) {
-        match = true;
-        break;
-      }
-    }
-    if (!match) {
-      return false;
-    }
-  }
-
-  return true;
-}

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

@@ -1,433 +0,0 @@
-import { Block } from "@nomicfoundation/ethereumjs-block";
-import {
-  BlockchainInterface,
-  BlockchainEvents,
-} from "@nomicfoundation/ethereumjs-blockchain";
-import { Common } from "@nomicfoundation/ethereumjs-common";
-import {
-  FeeMarketEIP1559TxData,
-  TypedTransaction,
-} from "@nomicfoundation/ethereumjs-tx";
-import {
-  Address,
-  AsyncEventEmitter,
-  equalsBytes,
-} from "@nomicfoundation/ethereumjs-util";
-
-import { RpcBlockWithTransactions } from "../../../core/jsonrpc/types/output/block";
-import { RpcTransactionReceipt } from "../../../core/jsonrpc/types/output/receipt";
-import { RpcTransaction } from "../../../core/jsonrpc/types/output/transaction";
-import { InternalError } from "../../../core/providers/errors";
-import { JsonRpcClient } from "../../jsonrpc/client";
-import { BlockchainBase } from "../BlockchainBase";
-import { FilterParams } from "../node-types";
-import {
-  remoteReceiptToRpcReceiptOutput,
-  RpcLogOutput,
-  RpcReceiptOutput,
-  shouldShowEffectiveGasPriceForHardfork,
-  shouldShowTransactionTypeForHardfork,
-  toRpcLogOutput,
-} from "../output";
-import { ReadOnlyValidEIP2930Transaction } from "../transactions/ReadOnlyValidEIP2930Transaction";
-import { ReadOnlyValidTransaction } from "../transactions/ReadOnlyValidTransaction";
-import { HardhatBlockchainInterface } from "../types/HardhatBlockchainInterface";
-
-import { ReadOnlyValidEIP1559Transaction } from "../transactions/ReadOnlyValidEIP1559Transaction";
-import { ReadOnlyValidUnknownTypeTransaction } from "../transactions/ReadOnlyValidUnknownTypeTransaction";
-import { rpcToBlockData } from "./rpcToBlockData";
-import { rpcToTxData } from "./rpcToTxData";
-
-/* eslint-disable @nomicfoundation/hardhat-internal-rules/only-hardhat-error */
-
-export class ForkBlockchain
-  extends BlockchainBase
-  implements HardhatBlockchainInterface
-{
-  private _latestBlockNumber = this._forkBlockNumber;
-  public events?: AsyncEventEmitter<BlockchainEvents> | undefined;
-
-  constructor(
-    private _jsonRpcClient: JsonRpcClient,
-    private _forkBlockNumber: bigint,
-    common: Common
-  ) {
-    super(common);
-  }
-
-  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 shallowCopy(): BlockchainInterface {
-    return this;
-  }
-
-  public getLatestBlockNumber(): bigint {
-    return this._latestBlockNumber;
-  }
-
-  public async getBlock(blockHashOrNumber: Buffer | bigint): Promise<Block> {
-    if (
-      typeof blockHashOrNumber === "bigint" &&
-      this._data.isReservedBlock(blockHashOrNumber)
-    ) {
-      this._data.fulfillBlockReservation(blockHashOrNumber);
-    }
-
-    let block: Block | undefined | null;
-    if (Buffer.isBuffer(blockHashOrNumber)) {
-      block = await this._getBlockByHash(blockHashOrNumber);
-      if (block === undefined) {
-        throw new Error("Block not found");
-      }
-      return block;
-    }
-
-    block = await this._getBlockByNumber(BigInt(blockHashOrNumber));
-    if (block === undefined) {
-      throw new Error("Block not found");
-    }
-    return block;
-  }
-
-  public async addBlock(block: Block): Promise<Block> {
-    const blockNumber = BigInt(block.header.number);
-    if (blockNumber !== this._latestBlockNumber + 1n) {
-      throw new Error(
-        `Invalid block number ${blockNumber}. Expected ${
-          this._latestBlockNumber + 1n
-        }`
-      );
-    }
-
-    // When forking a network whose consensus is not the classic PoW,
-    // we can't calculate the hash correctly.
-    // Thus, we avoid this check for the first block after the fork.
-    if (blockNumber > this._forkBlockNumber + 1n) {
-      const parent = await this.getLatestBlock();
-      if (!equalsBytes(block.header.parentHash, parent.hash())) {
-        throw new Error("Invalid parent hash");
-      }
-    }
-
-    this._latestBlockNumber++;
-    const totalDifficulty = await this._computeTotalDifficulty(block);
-    this._data.addBlock(block, totalDifficulty);
-    return block;
-  }
-
-  public reserveBlocks(
-    count: bigint,
-    interval: bigint,
-    previousBlockStateRoot: Buffer,
-    previousBlockTotalDifficulty: bigint,
-    previousBlockBaseFeePerGas: bigint | undefined
-  ) {
-    super.reserveBlocks(
-      count,
-      interval,
-      previousBlockStateRoot,
-      previousBlockTotalDifficulty,
-      previousBlockBaseFeePerGas
-    );
-    this._latestBlockNumber += count;
-  }
-
-  public deleteLaterBlocks(block: Block): void {
-    const blockNumber = block.header.number;
-    const savedBlock = this._data.getBlockByNumber(blockNumber);
-    if (
-      savedBlock === undefined ||
-      !equalsBytes(savedBlock.hash(), block.hash())
-    ) {
-      throw new Error("Invalid block");
-    }
-
-    const nextBlockNumber = blockNumber + 1n;
-    if (this._forkBlockNumber >= nextBlockNumber) {
-      throw new Error("Cannot delete remote block");
-    }
-
-    this._delBlock(nextBlockNumber);
-  }
-
-  public async getTotalDifficulty(blockHash: Buffer): Promise<bigint> {
-    let td = this._data.getTotalDifficulty(blockHash);
-    if (td !== undefined) {
-      return td;
-    }
-
-    // fetch block to check if it exists
-    await this.getBlock(blockHash);
-
-    td = this._data.getTotalDifficulty(blockHash);
-    if (td === undefined) {
-      throw new Error("This should never happen");
-    }
-    return td;
-  }
-
-  public async getTransaction(
-    transactionHash: Buffer
-  ): Promise<TypedTransaction | undefined> {
-    const tx = this.getLocalTransaction(transactionHash);
-    if (tx === undefined) {
-      const remote = await this._jsonRpcClient.getTransactionByHash(
-        transactionHash
-      );
-      return this._processRemoteTransaction(remote);
-    }
-    return tx;
-  }
-
-  public async getBlockByTransactionHash(
-    transactionHash: Buffer
-  ): Promise<Block | null> {
-    let block = this._data.getBlockByTransactionHash(transactionHash);
-    if (block === undefined) {
-      const remote = await this._jsonRpcClient.getTransactionByHash(
-        transactionHash
-      );
-      this._processRemoteTransaction(remote);
-      if (remote !== null && remote.blockHash !== null) {
-        await this.getBlock(remote.blockHash);
-        block = this._data.getBlockByTransactionHash(transactionHash);
-      }
-    }
-    return block ?? null;
-  }
-
-  public async getTransactionReceipt(
-    transactionHash: Buffer
-  ): Promise<RpcReceiptOutput | null> {
-    const local = this._data.getTransactionReceipt(transactionHash);
-    if (local !== undefined) {
-      return local;
-    }
-    const remote = await this._jsonRpcClient.getTransactionReceipt(
-      transactionHash
-    );
-    if (remote !== null) {
-      const receipt = await this._processRemoteReceipt(remote);
-      return receipt ?? null;
-    }
-
-    return null;
-  }
-
-  public getForkBlockNumber() {
-    return this._forkBlockNumber;
-  }
-
-  public async getLogs(filterParams: FilterParams): Promise<RpcLogOutput[]> {
-    if (filterParams.fromBlock <= this._forkBlockNumber) {
-      let toBlock = filterParams.toBlock;
-      let localLogs: RpcLogOutput[] = [];
-      if (toBlock > this._forkBlockNumber) {
-        toBlock = this._forkBlockNumber;
-        localLogs = this._data.getLogs({
-          ...filterParams,
-          fromBlock: this._forkBlockNumber + 1n,
-        });
-      }
-      const remoteLogs = await this._jsonRpcClient.getLogs({
-        fromBlock: filterParams.fromBlock,
-        toBlock,
-        address:
-          filterParams.addresses.length === 1
-            ? filterParams.addresses[0]
-            : filterParams.addresses,
-        topics: filterParams.normalizedTopics,
-      });
-      return remoteLogs.map(toRpcLogOutput).concat(localLogs);
-    }
-    return this._data.getLogs(filterParams);
-  }
-
-  private async _getBlockByHash(blockHash: Buffer) {
-    const block = this._data.getBlockByHash(blockHash);
-    if (block !== undefined) {
-      return block;
-    }
-    const rpcBlock = await this._jsonRpcClient.getBlockByHash(blockHash, true);
-    return this._processRemoteBlock(rpcBlock);
-  }
-
-  private async _getBlockByNumber(blockNumber: bigint) {
-    if (blockNumber > this._latestBlockNumber) {
-      return undefined;
-    }
-
-    try {
-      const block = await super.getBlock(blockNumber);
-      return block;
-    } catch {}
-
-    const rpcBlock = await this._jsonRpcClient.getBlockByNumber(
-      blockNumber,
-      true
-    );
-    return this._processRemoteBlock(rpcBlock);
-  }
-
-  private async _processRemoteBlock(rpcBlock: RpcBlockWithTransactions | null) {
-    if (
-      rpcBlock === null ||
-      rpcBlock.hash === null ||
-      rpcBlock.number === null ||
-      rpcBlock.number > this._forkBlockNumber
-    ) {
-      return undefined;
-    }
-
-    const common = this._common.copy();
-    // We set the common's hardfork depending on the remote block fields, to
-    // prevent ethereumjs from throwing if unsupported fields are passed.
-    // We use "berlin" for pre-EIP-1559 blocks (blocks without baseFeePerGas),
-    // "merge" for blocks that have baseFeePerGas but not withdrawals,
-    // and "shanghai" for blocks with withdrawals
-    if (rpcBlock.baseFeePerGas === undefined) {
-      common.setHardfork("berlin");
-    } else if (rpcBlock.withdrawals === undefined) {
-      // ethereumjs uses this name for the merge hardfork
-      common.setHardfork("mergeForkIdTransition");
-    } else if (rpcBlock.parentBeaconBlockRoot === undefined) {
-      common.setHardfork("shanghai");
-    } else {
-      common.setHardfork("cancun");
-    }
-
-    // we don't include the transactions to add our own custom tx objects,
-    // otherwise they are recreated with upstream classes
-    const blockData = rpcToBlockData({
-      ...rpcBlock,
-      transactions: [],
-    });
-
-    const block = Block.fromBlockData(blockData, {
-      common,
-
-      // We use freeze false here because we add the transactions manually
-      freeze: false,
-
-      // don't validate things like the size of `extraData` in the header
-      skipConsensusFormatValidation: true,
-    });
-
-    for (const transaction of rpcBlock.transactions) {
-      let tx;
-      if (transaction.type === undefined || transaction.type === 0n) {
-        tx = new ReadOnlyValidTransaction(
-          new Address(transaction.from),
-          rpcToTxData(transaction)
-        );
-      } else if (transaction.type === 1n) {
-        tx = new ReadOnlyValidEIP2930Transaction(
-          new Address(transaction.from),
-          rpcToTxData(transaction)
-        );
-      } else if (transaction.type === 2n) {
-        tx = new ReadOnlyValidEIP1559Transaction(
-          new Address(transaction.from),
-          rpcToTxData(transaction) as FeeMarketEIP1559TxData
-        );
-      } else {
-        // we try to interpret unknown txs as legacy transactions, to support
-        // networks like Arbitrum that have non-standards tx types
-        try {
-          tx = new ReadOnlyValidUnknownTypeTransaction(
-            new Address(transaction.from),
-            Number(transaction.type),
-            rpcToTxData(transaction)
-          );
-        } catch (e: any) {
-          throw new InternalError(
-            `Could not process transaction with type ${transaction.type.toString()}`,
-            e
-          );
-        }
-      }
-
-      block.transactions.push(tx);
-    }
-
-    this._data.addBlock(block, rpcBlock.totalDifficulty);
-    return block;
-  }
-
-  protected _delBlock(blockNumber: bigint): void {
-    if (blockNumber <= this._forkBlockNumber) {
-      throw new Error("Cannot delete remote block");
-    }
-    super._delBlock(blockNumber);
-    this._latestBlockNumber = blockNumber - 1n;
-  }
-
-  private _processRemoteTransaction(rpcTransaction: RpcTransaction | null) {
-    if (
-      rpcTransaction === null ||
-      rpcTransaction.blockNumber === null ||
-      rpcTransaction.blockNumber > this._forkBlockNumber
-    ) {
-      return undefined;
-    }
-
-    let transaction: TypedTransaction;
-
-    if (rpcTransaction.type === undefined || rpcTransaction.type === 0n) {
-      transaction = new ReadOnlyValidTransaction(
-        new Address(rpcTransaction.from),
-        rpcToTxData(rpcTransaction)
-      );
-    } else if (rpcTransaction.type === 1n) {
-      transaction = new ReadOnlyValidEIP2930Transaction(
-        new Address(rpcTransaction.from),
-        rpcToTxData(rpcTransaction)
-      );
-    } else if (rpcTransaction.type === 2n) {
-      transaction = new ReadOnlyValidEIP1559Transaction(
-        new Address(rpcTransaction.from),
-        rpcToTxData(rpcTransaction) as FeeMarketEIP1559TxData
-      );
-    } else {
-      transaction = new ReadOnlyValidUnknownTypeTransaction(
-        new Address(rpcTransaction.from),
-        Number(rpcTransaction.type),
-        rpcToTxData(rpcTransaction)
-      );
-    }
-
-    this._data.addTransaction(transaction);
-
-    return transaction;
-  }
-
-  private async _processRemoteReceipt(
-    txReceipt: RpcTransactionReceipt | null
-  ): Promise<RpcReceiptOutput | undefined> {
-    if (txReceipt === null || txReceipt.blockNumber > this._forkBlockNumber) {
-      return undefined;
-    }
-
-    const tx = await this.getTransaction(txReceipt.transactionHash);
-
-    const receipt = remoteReceiptToRpcReceiptOutput(
-      txReceipt,
-      tx!,
-      shouldShowTransactionTypeForHardfork(this._common),
-      shouldShowEffectiveGasPriceForHardfork(this._common)
-    );
-
-    this._data.addTransactionReceipt(receipt);
-    return receipt;
-  }
-}