hardhat 2.10.1 → 2.11.0-dev.0

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);
 

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

@@ -1,10 +1,11 @@
-import Common from "@ethereumjs/common";
-import { TransactionFactory, TypedTransaction } from "@ethereumjs/tx";
-import { StateManager } from "@ethereumjs/vm/dist/state";
-import { Address, BN, bufferToHex, toBuffer } from "ethereumjs-util";
+import { Common } from "@ignored/common";
+import { TransactionFactory, TypedTransaction } from "@ignored/tx";
+import { StateManager } from "@ignored/statemanager";
+import { Address, bufferToHex, toBuffer } from "@ignored/util";
 import { List as ImmutableList, Record as ImmutableRecord } from "immutable";
 
 import { InvalidInputError } from "../../core/providers/errors";
+import { BigIntUtils } from "../../util/bigint";
 
 import {
   AddressToTransactions,
@@ -17,7 +18,6 @@ import {
 } from "./PoolState";
 import { FakeSenderAccessListEIP2930Transaction } from "./transactions/FakeSenderAccessListEIP2930Transaction";
 import { FakeSenderTransaction } from "./transactions/FakeSenderTransaction";
-import { bnToHex } from "./utils/bnToHex";
 import { reorganizeTransactionsLists } from "./utils/reorganizeTransactionsLists";
 import { FakeSenderEIP1559Transaction } from "./transactions/FakeSenderEIP1559Transaction";
 
@@ -35,7 +35,7 @@ export function serializeTransaction(
     orderId: tx.orderId,
     fakeFrom: isFake ? tx.data.getSenderAddress().toString() : undefined,
     data: rlpSerialization,
-    txType: tx.data.transactionType,
+    txType: tx.data.type,
   });
 }
 
@@ -95,11 +95,11 @@ export class TxPool {
 
   constructor(
     private readonly _stateManager: StateManager,
-    blockGasLimit: BN,
+    blockGasLimit: bigint,
     common: Common
   ) {
     this._state = makePoolState({
-      blockGasLimit: bnToHex(blockGasLimit),
+      blockGasLimit: BigIntUtils.toHex(blockGasLimit),
     });
     this._deserializeTransaction = (tx) => deserializeTransaction(tx, common);
   }
@@ -111,9 +111,9 @@ export class TxPool {
 
     await this._validateTransaction(tx, senderAddress, nextConfirmedNonce);
 
-    const txNonce = new BN(tx.nonce);
+    const txNonce = tx.nonce;
 
-    if (txNonce.gt(nextPendingNonce)) {
+    if (txNonce > nextPendingNonce) {
       this._addQueuedTransaction(tx);
     } else {
       this._addPendingTransaction(tx);
@@ -238,7 +238,7 @@ export class TxPool {
    * Returns the next available nonce for an address, taking into account
    * its pending transactions.
    */
-  public async getNextPendingNonce(accountAddress: Address): Promise<BN> {
+  public async getNextPendingNonce(accountAddress: Address): Promise<bigint> {
     const pendingTxs = this._getPendingForAddress(accountAddress.toString());
     const lastPendingTx = pendingTxs?.last(undefined);
 
@@ -248,16 +248,16 @@ export class TxPool {
 
     const lastPendingTxNonce =
       this._deserializeTransaction(lastPendingTx).data.nonce;
-    return lastPendingTxNonce.addn(1);
+    return lastPendingTxNonce + 1n;
   }
 
-  public getBlockGasLimit(): BN {
-    return new BN(toBuffer(this._state.get("blockGasLimit")));
+  public getBlockGasLimit(): bigint {
+    return BigInt(this._state.get("blockGasLimit"));
   }
 
-  public setBlockGasLimit(newLimit: BN | number) {
+  public setBlockGasLimit(newLimit: bigint | number) {
     if (typeof newLimit === "number") {
-      newLimit = new BN(newLimit);
+      newLimit = BigInt(newLimit);
     }
 
     this._setBlockGasLimit(newLimit);
@@ -274,8 +274,8 @@ export class TxPool {
       const senderAccount = await this._stateManager.getAccount(
         Address.fromString(address)
       );
-      const senderNonce = new BN(senderAccount.nonce);
-      const senderBalance = new BN(senderAccount.balance);
+      const senderNonce = senderAccount.nonce;
+      const senderBalance = senderAccount.balance;
 
       let moveToQueued = false;
       for (const tx of txs) {
@@ -289,7 +289,7 @@ export class TxPool {
           continue;
         }
 
-        const txNonce = new BN(deserializedTx.data.nonce);
+        const txNonce = deserializedTx.data.nonce;
 
         if (
           !this._isTxValid(deserializedTx, txNonce, senderNonce, senderBalance)
@@ -298,7 +298,7 @@ export class TxPool {
 
           // if we are dropping a pending transaction with a valid nonce,
           // then we move all the following txs to the queued list
-          if (txNonce.gte(senderNonce)) {
+          if (txNonce >= senderNonce) {
             moveToQueued = true;
           }
         }
@@ -312,12 +312,12 @@ export class TxPool {
       const senderAccount = await this._stateManager.getAccount(
         Address.fromString(address)
       );
-      const senderNonce = new BN(senderAccount.nonce);
-      const senderBalance = new BN(senderAccount.balance);
+      const senderNonce = senderAccount.nonce;
+      const senderBalance = senderAccount.balance;
 
       for (const tx of txs) {
         const deserializedTx = this._deserializeTransaction(tx);
-        const txNonce = new BN(deserializedTx.data.nonce);
+        const txNonce = deserializedTx.data.nonce;
 
         if (
           !this._isTxValid(deserializedTx, txNonce, senderNonce, senderBalance)
@@ -420,7 +420,7 @@ export class TxPool {
   private async _validateTransaction(
     tx: TypedTransaction,
     senderAddress: Address,
-    senderNonce: BN
+    senderNonce: bigint
   ) {
     if (this._knownTransaction(tx)) {
       throw new InvalidInputError(
@@ -428,7 +428,7 @@ export class TxPool {
       );
     }
 
-    const txNonce = new BN(tx.nonce);
+    const txNonce = tx.nonce;
 
     // Geth returns this error if trying to create a contract and no data is provided
     if (tx.to === undefined && tx.data.length === 0) {
@@ -438,28 +438,28 @@ export class TxPool {
     }
 
     const senderAccount = await this._stateManager.getAccount(senderAddress);
-    const senderBalance = new BN(senderAccount.balance);
+    const senderBalance = senderAccount.balance;
 
     const maxFee = "gasPrice" in tx ? tx.gasPrice : tx.maxFeePerGas;
-    const txMaxUpfrontCost = tx.gasLimit.mul(maxFee).add(tx.value);
+    const txMaxUpfrontCost = tx.gasLimit * maxFee + tx.value;
 
-    if (txMaxUpfrontCost.gt(senderBalance)) {
+    if (txMaxUpfrontCost > senderBalance) {
       throw new InvalidInputError(
         `sender doesn't have enough funds to send tx. The max upfront cost is: ${txMaxUpfrontCost.toString()}` +
           ` and the sender's account only has: ${senderBalance.toString()}`
       );
     }
 
-    if (txNonce.lt(senderNonce)) {
+    if (txNonce < senderNonce) {
       throw new InvalidInputError(
         `Nonce too low. Expected nonce to be at least ${senderNonce.toString()} but got ${txNonce.toString()}.`
       );
     }
 
-    const gasLimit = new BN(tx.gasLimit);
+    const gasLimit = tx.gasLimit;
     const baseFee = tx.getBaseFee();
 
-    if (gasLimit.lt(baseFee)) {
+    if (gasLimit < baseFee) {
       throw new InvalidInputError(
         `Transaction requires at least ${baseFee.toString()} gas but got ${gasLimit.toString()}`
       );
@@ -467,7 +467,7 @@ export class TxPool {
 
     const blockGasLimit = this.getBlockGasLimit();
 
-    if (gasLimit.gt(blockGasLimit)) {
+    if (gasLimit > blockGasLimit) {
       throw new InvalidInputError(
         `Transaction gas limit is ${gasLimit.toString()} and exceeds block gas limit of ${blockGasLimit.toString()}`
       );
@@ -550,8 +550,8 @@ export class TxPool {
     );
   }
 
-  private _setBlockGasLimit(newLimit: BN) {
-    this._state = this._state.set("blockGasLimit", bnToHex(newLimit));
+  private _setBlockGasLimit(newLimit: bigint) {
+    this._state = this._state.set("blockGasLimit", BigIntUtils.toHex(newLimit));
   }
 
   private _deleteTransactionByHash(hash: Buffer) {
@@ -563,16 +563,16 @@ export class TxPool {
 
   private _isTxValid(
     tx: OrderedTransaction,
-    txNonce: BN,
-    senderNonce: BN,
-    senderBalance: BN
+    txNonce: bigint,
+    senderNonce: bigint,
+    senderBalance: bigint
   ): boolean {
-    const txGasLimit = new BN(tx.data.gasLimit);
+    const txGasLimit = tx.data.gasLimit;
 
     return (
-      txGasLimit.lte(this.getBlockGasLimit()) &&
-      txNonce.gte(senderNonce) &&
-      tx.data.getUpfrontCost().lte(senderBalance)
+      txGasLimit <= this.getBlockGasLimit() &&
+      txNonce >= senderNonce &&
+      tx.data.getUpfrontCost() <= senderBalance
     );
   }
 
@@ -580,9 +580,11 @@ export class TxPool {
    * Returns the next available nonce for an address, ignoring its
    * pending transactions.
    */
-  private async _getNextConfirmedNonce(accountAddress: Address): Promise<BN> {
+  private async _getNextConfirmedNonce(
+    accountAddress: Address
+  ): Promise<bigint> {
     const account = await this._stateManager.getAccount(accountAddress);
-    return new BN(account.nonce);
+    return account.nonce;
   }
 
   /**
@@ -633,8 +635,8 @@ export class TxPool {
       return;
     }
 
-    const existingTxEntry = txs.findEntry((tx) =>
-      this._deserializeTransaction(tx).data.nonce.eq(new BN(newTx.data.nonce))
+    const existingTxEntry = txs.findEntry(
+      (tx) => this._deserializeTransaction(tx).data.nonce === newTx.data.nonce
     );
 
     if (existingTxEntry === undefined) {
@@ -645,27 +647,23 @@ export class TxPool {
 
     const deserializedExistingTx = this._deserializeTransaction(existingTx);
 
-    const currentMaxFeePerGas = new BN(
+    const currentMaxFeePerGas =
       "gasPrice" in deserializedExistingTx.data
         ? deserializedExistingTx.data.gasPrice
-        : deserializedExistingTx.data.maxFeePerGas
-    );
+        : deserializedExistingTx.data.maxFeePerGas;
 
-    const currentPriorityFeePerGas = new BN(
+    const currentPriorityFeePerGas =
       "gasPrice" in deserializedExistingTx.data
         ? deserializedExistingTx.data.gasPrice
-        : deserializedExistingTx.data.maxPriorityFeePerGas
-    );
+        : deserializedExistingTx.data.maxPriorityFeePerGas;
 
-    const newMaxFeePerGas = new BN(
-      "gasPrice" in newTx.data ? newTx.data.gasPrice : newTx.data.maxFeePerGas
-    );
+    const newMaxFeePerGas =
+      "gasPrice" in newTx.data ? newTx.data.gasPrice : newTx.data.maxFeePerGas;
 
-    const newPriorityFeePerGas = new BN(
+    const newPriorityFeePerGas =
       "gasPrice" in newTx.data
         ? newTx.data.gasPrice
-        : newTx.data.maxPriorityFeePerGas
-    );
+        : newTx.data.maxPriorityFeePerGas;
 
     const minNewMaxFeePerGas = this._getMinNewFeePrice(currentMaxFeePerGas);
 
@@ -673,13 +671,13 @@ export class TxPool {
       currentPriorityFeePerGas
     );
 
-    if (newMaxFeePerGas.lt(minNewMaxFeePerGas)) {
+    if (newMaxFeePerGas < minNewMaxFeePerGas) {
       throw new InvalidInputError(
         `Replacement transaction underpriced. A gasPrice/maxFeePerGas of at least ${minNewMaxFeePerGas.toString()} is necessary to replace the existing transaction with nonce ${newTx.data.nonce.toString()}.`
       );
     }
 
-    if (newPriorityFeePerGas.lt(minNewPriorityFeePerGas)) {
+    if (newPriorityFeePerGas < minNewPriorityFeePerGas) {
       throw new InvalidInputError(
         `Replacement transaction underpriced. A gasPrice/maxPriorityFeePerGas of at least ${minNewPriorityFeePerGas.toString()} is necessary to replace the existing transaction with nonce ${newTx.data.nonce.toString()}.`
       );
@@ -692,13 +690,13 @@ export class TxPool {
     return newTxs;
   }
 
-  private _getMinNewFeePrice(feePrice: BN): BN {
-    let minNewPriorityFee = feePrice.muln(110);
+  private _getMinNewFeePrice(feePrice: bigint): bigint {
+    let minNewPriorityFee = feePrice * 110n;
 
-    if (minNewPriorityFee.modn(100) === 0) {
-      minNewPriorityFee = minNewPriorityFee.divn(100);
+    if (minNewPriorityFee % 100n === 0n) {
+      minNewPriorityFee = minNewPriorityFee / 100n;
     } else {
-      minNewPriorityFee = minNewPriorityFee.divn(100).addn(1);
+      minNewPriorityFee = minNewPriorityFee / 100n + 1n;
     }
 
     return minNewPriorityFee;

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

@@ -1,10 +1,10 @@
-import { TransactionFactory } from "@ethereumjs/tx";
-import { BaseTransaction } from "@ethereumjs/tx/dist/baseTransaction";
+import { TransactionFactory } from "@ignored/tx";
+import { BaseTransaction } from "@ignored/tx/dist/baseTransaction";
 import {
   AccessListEIP2930TxData,
   TxData,
   TxOptions,
-} from "@ethereumjs/tx/dist/types";
+} from "@ignored/tx/dist/types";
 
 // This is a hack to prevent Block.fromBlockData from recreating our
 // transactions and changing their types. Note fromBlockData is used

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

@@ -1,9 +1,9 @@
-import Bloom from "@ethereumjs/vm/dist/bloom";
-import { BN, bufferToHex, toBuffer } from "ethereumjs-util";
+import { bufferToHex, toBuffer } from "@ignored/util";
+import { Bloom } from "@ignored/vm";
 
 import { RpcLogOutput } from "./output";
 
-export const LATEST_BLOCK = new BN(-1);
+export const LATEST_BLOCK = -1n;
 
 export enum Type {
   LOGS_SUBSCRIPTION = 0,
@@ -12,14 +12,14 @@ export enum Type {
 }
 
 export interface FilterCriteria {
-  fromBlock: BN;
-  toBlock: BN;
+  fromBlock: bigint;
+  toBlock: bigint;
   addresses: Buffer[];
   normalizedTopics: Array<Array<Buffer | null> | null>;
 }
 
 export interface Filter {
-  id: BN;
+  id: bigint;
   type: Type;
   criteria?: FilterCriteria;
   deadline: Date;
@@ -73,15 +73,12 @@ export function filterLogs(
 ): RpcLogOutput[] {
   const filteredLogs: RpcLogOutput[] = [];
   for (const log of logs) {
-    const blockNumber = new BN(toBuffer(log.blockNumber!));
-    if (blockNumber.lt(criteria.fromBlock)) {
+    const blockNumber = BigInt(log.blockNumber!);
+    if (blockNumber < criteria.fromBlock) {
       continue;
     }
 
-    if (
-      !criteria.toBlock.eq(LATEST_BLOCK) &&
-      blockNumber.gt(criteria.toBlock)
-    ) {
+    if (criteria.toBlock !== LATEST_BLOCK && blockNumber > criteria.toBlock) {
       continue;
     }