hardhat 2.10.2 → 2.11.0-dev.0

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

@@ -1,8 +1,8 @@
-import { Block } from "@ethereumjs/block";
-import Common from "@ethereumjs/common";
-import { TypedTransaction } from "@ethereumjs/tx";
-import Bloom from "@ethereumjs/vm/dist/bloom";
-import { BN, bufferToHex } from "ethereumjs-util";
+import { Block } from "@ignored/block";
+import { Common } from "@ignored/common";
+import { TypedTransaction } from "@ignored/tx";
+import { bufferToHex } from "@ignored/util";
+import { Bloom } from "@ignored/vm";
 
 import { assertHardhatInvariant } from "../../core/errors";
 import { bloomFilter, filterLogs } from "./filter";
@@ -10,36 +10,36 @@ import { FilterParams } from "./node-types";
 import { RpcLogOutput, RpcReceiptOutput } from "./output";
 
 interface Reservation {
-  first: BN;
-  last: BN;
-  interval: BN;
+  first: bigint;
+  last: bigint;
+  interval: bigint;
   previousBlockStateRoot: Buffer;
-  previousBlockTotalDifficulty: BN;
-  previousBlockBaseFeePerGas: BN | undefined;
+  previousBlockTotalDifficulty: bigint;
+  previousBlockBaseFeePerGas: bigint | undefined;
 }
 
 export class BlockchainData {
-  private _blocksByNumber: Map<number, Block> = new Map();
+  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, BN> = new Map();
+  private _totalDifficulty: Map<string, bigint> = new Map();
   private _blockReservations: Reservation[] = new Array();
 
   constructor(private _common: Common) {}
 
   public reserveBlocks(
-    first: BN,
-    count: BN,
-    interval: BN,
+    first: bigint,
+    count: bigint,
+    interval: bigint,
     previousBlockStateRoot: Buffer,
-    previousBlockTotalDifficulty: BN,
-    previousBlockBaseFeePerGas: BN | undefined
+    previousBlockTotalDifficulty: bigint,
+    previousBlockBaseFeePerGas: bigint | undefined
   ) {
     const reservation: Reservation = {
       first,
-      last: first.add(count.subn(1)),
+      last: first + count - 1n,
       interval,
       previousBlockStateRoot,
       previousBlockTotalDifficulty,
@@ -48,8 +48,8 @@ export class BlockchainData {
     this._blockReservations.push(reservation);
   }
 
-  public getBlockByNumber(blockNumber: BN) {
-    return this._blocksByNumber.get(blockNumber.toNumber());
+  public getBlockByNumber(blockNumber: bigint) {
+    return this._blocksByNumber.get(blockNumber);
   }
 
   public getBlockByHash(blockHash: Buffer) {
@@ -74,16 +74,12 @@ export class BlockchainData {
 
   public getLogs(filterParams: FilterParams) {
     const logs: RpcLogOutput[] = [];
-    for (
-      let i = filterParams.fromBlock;
-      i.lte(filterParams.toBlock);
-      i = i.addn(1)
-    ) {
+    for (let i = filterParams.fromBlock; i <= filterParams.toBlock; i++) {
       const block = this.getBlockByNumber(i);
       if (
         block === undefined ||
         !bloomFilter(
-          new Bloom(block.header.bloom),
+          new Bloom(block.header.logsBloom),
           filterParams.addresses,
           filterParams.normalizedTopics
         )
@@ -107,9 +103,9 @@ export class BlockchainData {
     return logs;
   }
 
-  public addBlock(block: Block, totalDifficulty: BN) {
+  public addBlock(block: Block, totalDifficulty: bigint) {
     const blockHash = bufferToHex(block.hash());
-    const blockNumber = new BN(block.header.number).toNumber();
+    const blockNumber = block.header.number;
     this._blocksByNumber.set(blockNumber, block);
     this._blocksByHash.set(blockHash, block);
     this._totalDifficulty.set(blockHash, totalDifficulty);
@@ -128,7 +124,7 @@ export class BlockchainData {
    */
   public removeBlock(block: Block) {
     const blockHash = bufferToHex(block.hash());
-    const blockNumber = new BN(block.header.number).toNumber();
+    const blockNumber = block.header.number;
     this._blocksByNumber.delete(blockNumber);
     this._blocksByHash.delete(blockHash);
     this._totalDifficulty.delete(blockHash);
@@ -149,14 +145,14 @@ export class BlockchainData {
     this._transactionReceipts.set(receipt.transactionHash, receipt);
   }
 
-  public isReservedBlock(blockNumber: BN): boolean {
+  public isReservedBlock(blockNumber: bigint): boolean {
     return this._findBlockReservation(blockNumber) !== -1;
   }
 
-  private _findBlockReservation(blockNumber: BN): number {
+  private _findBlockReservation(blockNumber: bigint): number {
     return this._blockReservations.findIndex(
       (reservation) =>
-        reservation.first.lte(blockNumber) && blockNumber.lte(reservation.last)
+        reservation.first <= blockNumber && blockNumber <= reservation.last
     );
   }
 
@@ -180,11 +176,11 @@ export class BlockchainData {
   /**
    * Cancel and return the reservation that has block `blockNumber`
    */
-  public cancelReservationWithBlock(blockNumber: BN): Reservation {
+  public cancelReservationWithBlock(blockNumber: bigint): Reservation {
     return this._removeReservation(this._findBlockReservation(blockNumber));
   }
 
-  public fulfillBlockReservation(blockNumber: BN) {
+  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.
 
@@ -200,17 +196,17 @@ export class BlockchainData {
     // split the block reservation:
     const oldReservation = this._removeReservation(reservationIndex);
 
-    if (!blockNumber.eq(oldReservation.first)) {
+    if (blockNumber !== oldReservation.first) {
       this._blockReservations.push({
         ...oldReservation,
-        last: blockNumber.subn(1),
+        last: blockNumber - 1n,
       });
     }
 
-    if (!blockNumber.eq(oldReservation.last)) {
+    if (blockNumber !== oldReservation.last) {
       this._blockReservations.push({
         ...oldReservation,
-        first: blockNumber.addn(1),
+        first: blockNumber + 1n,
       });
     }
 
@@ -230,7 +226,7 @@ export class BlockchainData {
     );
   }
 
-  private _calculateTimestampForReservedBlock(blockNumber: BN): BN {
+  private _calculateTimestampForReservedBlock(blockNumber: bigint): bigint {
     const reservationIndex = this._findBlockReservation(blockNumber);
 
     assertHardhatInvariant(
@@ -240,7 +236,7 @@ export class BlockchainData {
 
     const reservation = this._blockReservations[reservationIndex];
 
-    const blockNumberBeforeReservation = reservation.first.subn(1);
+    const blockNumberBeforeReservation = reservation.first - 1n;
 
     const blockBeforeReservation = this.getBlockByNumber(
       blockNumberBeforeReservation
@@ -254,8 +250,9 @@ export class BlockchainData {
       ? this._calculateTimestampForReservedBlock(blockNumberBeforeReservation)
       : blockBeforeReservation.header.timestamp;
 
-    return previousTimestamp.add(
-      reservation.interval.mul(blockNumber.sub(reservation.first).addn(1))
+    return (
+      previousTimestamp +
+      reservation.interval * (blockNumber - reservation.first + 1n)
     );
   }
 }

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

@@ -1,7 +1,7 @@
-import { Block } from "@ethereumjs/block";
-import Common from "@ethereumjs/common";
-import { TypedTransaction } from "@ethereumjs/tx";
-import { BN, zeros } from "ethereumjs-util";
+import { Block } from "@ignored/block";
+import { Common } from "@ignored/common";
+import { TypedTransaction } from "@ignored/tx";
+import { zeros } from "@ignored/util";
 
 import { BlockchainBase } from "./BlockchainBase";
 import { FilterParams } from "./node-types";
@@ -14,30 +14,30 @@ export class HardhatBlockchain
   extends BlockchainBase
   implements HardhatBlockchainInterface
 {
-  private _length = 0;
+  private _length = 0n;
 
   constructor(common: Common) {
     super(common);
   }
 
-  public getLatestBlockNumber(): BN {
-    return new BN(this._length - 1);
+  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 += 1;
+    this._length += 1n;
     return block;
   }
 
   public reserveBlocks(
-    count: BN,
-    interval: BN,
+    count: bigint,
+    interval: bigint,
     previousBlockStateRoot: Buffer,
-    previousBlockTotalDifficulty: BN,
-    previousBlockBaseFeePerGas: BN | undefined
+    previousBlockTotalDifficulty: bigint,
+    previousBlockBaseFeePerGas: bigint | undefined
   ) {
     super.reserveBlocks(
       count,
@@ -46,7 +46,7 @@ export class HardhatBlockchain
       previousBlockTotalDifficulty,
       previousBlockBaseFeePerGas
     );
-    this._length = this._length + count.toNumber();
+    this._length += count;
   }
 
   public deleteLaterBlocks(block: Block): void {
@@ -55,10 +55,10 @@ export class HardhatBlockchain
       throw new Error("Invalid block");
     }
 
-    this._delBlock(actual.header.number.addn(1));
+    this._delBlock(actual.header.number + 1n);
   }
 
-  public async getTotalDifficulty(blockHash: Buffer): Promise<BN> {
+  public async getTotalDifficulty(blockHash: Buffer): Promise<bigint> {
     const totalDifficulty = this._data.getTotalDifficulty(blockHash);
     if (totalDifficulty === undefined) {
       throw new Error("Block not found");
@@ -88,18 +88,18 @@ export class HardhatBlockchain
   }
 
   private _validateBlock(block: Block) {
-    const blockNumber = block.header.number.toNumber();
+    const blockNumber = block.header.number;
     const parentHash = block.header.parentHash;
-    const parent = this._data.getBlockByNumber(new BN(blockNumber - 1));
+    const parent = this._data.getBlockByNumber(BigInt(blockNumber - 1n));
 
-    if (this._length !== blockNumber) {
+    if (BigInt(this._length) !== blockNumber) {
       throw new Error(
         `Invalid block number ${blockNumber}. Expected ${this._length}.`
       );
     }
 
     if (
-      (blockNumber === 0 && !parentHash.equals(zeros(32))) ||
+      (blockNumber === 0n && !parentHash.equals(zeros(32))) ||
       (blockNumber > 0 &&
         parent !== undefined &&
         !parentHash.equals(parent.hash()))
@@ -108,8 +108,8 @@ export class HardhatBlockchain
     }
   }
 
-  protected _delBlock(blockNumber: BN): void {
+  protected _delBlock(blockNumber: bigint): void {
     super._delBlock(blockNumber);
-    this._length = blockNumber.toNumber();
+    this._length = blockNumber;
   }
 }

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

@@ -1,12 +1,11 @@
-import { TypedTransaction } from "@ethereumjs/tx";
-import { BN } from "ethereumjs-util";
+import { TypedTransaction } from "@ignored/tx";
 import {
   List as ImmutableList,
   Map as ImmutableMap,
   Record as ImmutableRecord,
 } from "immutable";
 
-import { bnToHex } from "./utils/bnToHex";
+import { BigIntUtils } from "../../util/bigint";
 
 export interface OrderedTransaction {
   orderId: number;
@@ -45,5 +44,5 @@ export const makePoolState = ImmutableRecord<PoolState>({
   pendingTransactions: ImmutableMap<string, SenderTransactions>(),
   queuedTransactions: ImmutableMap<string, SenderTransactions>(),
   hashToTransaction: ImmutableMap<string, SerializedTransaction>(),
-  blockGasLimit: bnToHex(new BN(9500000)),
+  blockGasLimit: BigIntUtils.toHex(9500000),
 });

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

@@ -1,12 +1,15 @@
-import { TypedTransaction } from "@ethereumjs/tx";
-import { BN } from "ethereumjs-util";
+import { TypedTransaction } from "@ignored/tx";
 import Heap from "mnemonist/heap";
 
 import { InternalError, InvalidInputError } from "../../core/providers/errors";
+import { BigIntUtils } from "../../util/bigint";
 import { MempoolOrder } from "./node-types";
 import { OrderedTransaction } from "./PoolState";
 
-function getEffectiveMinerFee(tx: OrderedTransaction, baseFee?: BN): BN {
+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;
@@ -18,18 +21,18 @@ function getEffectiveMinerFee(tx: OrderedTransaction, baseFee?: BN): BN {
     return maxFeePerGas;
   }
 
-  return BN.min(maxPriorityFeePerGas, maxFeePerGas.sub(baseFee));
+  return BigIntUtils.min(maxPriorityFeePerGas, maxFeePerGas - baseFee);
 }
 
 function decreasingOrderEffectiveMinerFeeComparator(
   left: OrderedTransaction,
   right: OrderedTransaction,
-  baseFee?: BN
+  baseFee?: bigint
 ) {
   const leftEffectiveMinerFee = getEffectiveMinerFee(left, baseFee);
   const rightEffectiveMinerFee = getEffectiveMinerFee(right, baseFee);
 
-  const cmp = rightEffectiveMinerFee.cmp(leftEffectiveMinerFee);
+  const cmp = BigIntUtils.cmp(rightEffectiveMinerFee, leftEffectiveMinerFee);
 
   if (cmp !== 0) {
     return cmp;
@@ -49,7 +52,7 @@ function decreasingOrderComparator(
 
 function getOrderedTransactionHeap(
   mempoolOrder: MempoolOrder,
-  baseFee?: BN
+  baseFee?: bigint
 ): Heap<OrderedTransaction> {
   switch (mempoolOrder) {
     case "priority":
@@ -98,7 +101,7 @@ export class TransactionQueue {
   constructor(
     pendingTransactions: Map<string, OrderedTransaction[]>,
     mempoolOrder: MempoolOrder,
-    baseFee?: BN
+    baseFee?: bigint
   ) {
     this._heap = getOrderedTransactionHeap(mempoolOrder, baseFee);