hardhat 2.10.1 → 2.11.0-dev.0

package/src/internal/hardhat-network/provider/modules/eth.ts

@@ -1,18 +1,13 @@
-import { Block } from "@ethereumjs/block";
-import Common from "@ethereumjs/common";
-import {
-  Transaction,
-  TransactionFactory,
-  TypedTransaction,
-} from "@ethereumjs/tx";
+import { Block } from "@ignored/block";
+import { Common } from "@ignored/common";
+import { Transaction, TransactionFactory, TypedTransaction } from "@ignored/tx";
 import {
   Address,
-  BN,
   bufferToHex,
   toBuffer,
   toRpcSig,
   zeroAddress,
-} from "ethereumjs-util";
+} from "@ignored/util";
 import * as t from "io-ts";
 import cloneDeep from "lodash/cloneDeep";
 
@@ -86,6 +81,7 @@ import {
 
 import { assertHardhatNetworkInvariant } from "../utils/assertions";
 import { optional } from "../../../util/io-ts";
+import { BigIntUtils } from "../../../util/bigint";
 import { ModulesLogger } from "./logger";
 
 const EIP1559_MIN_HARDFORK = "london";
@@ -522,7 +518,7 @@ export class EthModule {
     }
 
     let block: Block | undefined;
-    let totalDifficulty: BN | undefined;
+    let totalDifficulty: bigint | undefined;
 
     if (numberOrPending === "pending") {
       [block, totalDifficulty] =
@@ -607,12 +603,12 @@ export class EthModule {
 
   // eth_getFilterChanges
 
-  private _getFilterChangesParams(params: any[]): [BN] {
+  private _getFilterChangesParams(params: any[]): [bigint] {
     return validateParams(params, rpcQuantity);
   }
 
   private async _getFilterChangesAction(
-    filterId: BN
+    filterId: bigint
   ): Promise<string[] | RpcLogOutput[] | null> {
     const changes = await this._node.getFilterChanges(filterId);
     if (changes === undefined) {
@@ -624,12 +620,12 @@ export class EthModule {
 
   // eth_getFilterLogs
 
-  private _getFilterLogsParams(params: any[]): [BN] {
+  private _getFilterLogsParams(params: any[]): [bigint] {
     return validateParams(params, rpcQuantity);
   }
 
   private async _getFilterLogsAction(
-    filterId: BN
+    filterId: bigint
   ): Promise<RpcLogOutput[] | null> {
     const changes = await this._node.getFilterLogs(filterId);
     if (changes === undefined) {
@@ -691,7 +687,7 @@ export class EthModule {
 
   private _getStorageAtParams(
     params: any[]
-  ): [Buffer, BN, OptionalRpcNewBlockTag] {
+  ): [Buffer, bigint, OptionalRpcNewBlockTag] {
     return validateParams(
       params,
       rpcAddress,
@@ -702,7 +698,7 @@ export class EthModule {
 
   private async _getStorageAtAction(
     address: Buffer,
-    slot: BN,
+    slot: bigint,
     blockTag: OptionalRpcNewBlockTag
   ): Promise<string> {
     const blockNumberOrPending = await this._resolveNewBlockTag(blockTag);
@@ -720,15 +716,15 @@ export class EthModule {
 
   private _getTransactionByBlockHashAndIndexParams(
     params: any[]
-  ): [Buffer, BN] {
+  ): [Buffer, bigint] {
     return validateParams(params, rpcHash, rpcQuantity);
   }
 
   private async _getTransactionByBlockHashAndIndexAction(
     hash: Buffer,
-    index: BN
+    index: bigint
   ): Promise<RpcTransactionOutput | null> {
-    const i = index.toNumber();
+    const i = Number(index);
     const block = await this._node.getBlockByHash(hash);
     if (block === undefined) {
       return null;
@@ -751,13 +747,13 @@ export class EthModule {
 
   private _getTransactionByBlockNumberAndIndexParams(
     params: any[]
-  ): [RpcOldBlockTag, BN] {
+  ): [RpcOldBlockTag, bigint] {
     return validateParams(params, rpcOldBlockTag, rpcQuantity);
   }
 
   private async _getTransactionByBlockNumberAndIndexAction(
     oldBlockTag: RpcOldBlockTag,
-    index: BN
+    index: bigint
   ): Promise<RpcTransactionOutput | null> {
     const numberOrPending = await this._resolveOldBlockTag(oldBlockTag);
     if (numberOrPending === undefined) {
@@ -765,7 +761,7 @@ export class EthModule {
     }
 
     const block = await this._node.getBlockByNumber(numberOrPending);
-    const i = index.toNumber();
+    const i = Number(index);
 
     if (block === undefined) {
       return null;
@@ -986,7 +982,7 @@ export class EthModule {
         }
 
         if (error.message.includes("The chain ID does not match")) {
-          const chainId = this._common.chainIdBN().toString();
+          const chainId = this._common.chainId();
           throw new InvalidArgumentsError(
             `Trying to send a raw transaction with an invalid chainId. The expected chainId is ${chainId}`,
             error
@@ -1017,10 +1013,10 @@ export class EthModule {
   private async _sendTransactionAction(
     transactionRequest: RpcTransactionRequest
   ): Promise<string> {
-    const expectedChainId = this._common.chainIdBN();
+    const expectedChainId = this._common.chainId();
     if (
       transactionRequest.chainId !== undefined &&
-      !transactionRequest.chainId.eq(expectedChainId)
+      transactionRequest.chainId !== expectedChainId
     ) {
       throw new InvalidArgumentsError(
         `Invalid chainId ${transactionRequest.chainId.toString()} provided, expected ${expectedChainId.toString()} instead.`
@@ -1143,21 +1139,21 @@ export class EthModule {
 
   // eth_uninstallFilter
 
-  private _uninstallFilterParams(params: any): [BN] {
+  private _uninstallFilterParams(params: any): [bigint] {
     return validateParams(params, rpcQuantity);
   }
 
-  private async _uninstallFilterAction(filterId: BN): Promise<boolean> {
+  private async _uninstallFilterAction(filterId: bigint): Promise<boolean> {
     return this._node.uninstallFilter(filterId, false);
   }
 
   // eth_unsubscribe
 
-  private _unsubscribeParams(params: any[]): [BN] {
+  private _unsubscribeParams(params: any[]): [bigint] {
     return validateParams(params, rpcQuantity);
   }
 
-  private async _unsubscribeAction(filterId: BN): Promise<boolean> {
+  private async _unsubscribeAction(filterId: bigint): Promise<boolean> {
     return this._node.uninstallFilter(filterId, true);
   }
 
@@ -1165,7 +1161,7 @@ export class EthModule {
 
   private _feeHistoryParams(
     params: any[]
-  ): [BN, RpcNewBlockTag, number[] | undefined] {
+  ): [bigint, RpcNewBlockTag, number[] | undefined] {
     const [blockCount, newestBlock, rewardPercentiles] = validateParams(
       params,
       rpcQuantity,
@@ -1173,11 +1169,11 @@ export class EthModule {
       optional(t.array(rpcFloat))
     );
 
-    if (blockCount.ltn(1)) {
+    if (blockCount < 1n) {
       throw new InvalidInputError(`blockCount should be at least 1`);
     }
 
-    if (blockCount.gtn(1024)) {
+    if (blockCount > 1024n) {
       throw new InvalidInputError(`blockCount should be at most 1024`);
     }
 
@@ -1206,7 +1202,7 @@ export class EthModule {
   }
 
   private async _feeHistoryAction(
-    blockCount: BN,
+    blockCount: bigint,
     newestBlock: RpcNewBlockTag,
     rewardPercentiles?: number[]
   ) {
@@ -1251,7 +1247,7 @@ export class EthModule {
       data: rpcCall.data !== undefined ? rpcCall.data : toBuffer([]),
       gasLimit:
         rpcCall.gas !== undefined ? rpcCall.gas : this._node.getBlockGasLimit(),
-      value: rpcCall.value !== undefined ? rpcCall.value : new BN(0),
+      value: rpcCall.value !== undefined ? rpcCall.value : 0n,
       accessList:
         rpcCall.accessList !== undefined
           ? this._rpcAccessListToNodeAccessList(rpcCall.accessList)
@@ -1270,7 +1266,7 @@ export class EthModule {
       from: rpcTx.from,
       gasLimit:
         rpcTx.gas !== undefined ? rpcTx.gas : this._node.getBlockGasLimit(),
-      value: rpcTx.value !== undefined ? rpcTx.value : new BN(0),
+      value: rpcTx.value !== undefined ? rpcTx.value : 0n,
       data: rpcTx.data !== undefined ? rpcTx.data : toBuffer([]),
       nonce:
         rpcTx.nonce !== undefined
@@ -1298,7 +1294,7 @@ export class EthModule {
         // than that, we adjust the tip to make the tx valid
         if (
           rpcTx.maxFeePerGas !== undefined &&
-          rpcTx.maxFeePerGas.lt(rpcTx.maxPriorityFeePerGas)
+          rpcTx.maxFeePerGas < rpcTx.maxPriorityFeePerGas
         ) {
           rpcTx.maxPriorityFeePerGas = rpcTx.maxFeePerGas;
         }
@@ -1312,9 +1308,7 @@ export class EthModule {
           "EIP-1559 transactions should only be sent if the next block has baseFeePerGas"
         );
 
-        rpcTx.maxFeePerGas = baseFeePerGas
-          .muln(2)
-          .add(rpcTx.maxPriorityFeePerGas);
+        rpcTx.maxFeePerGas = 2n * baseFeePerGas + rpcTx.maxPriorityFeePerGas;
       }
 
       return {
@@ -1354,7 +1348,7 @@ export class EthModule {
 
   private async _resolveOldBlockTag(
     oldBlockTag: RpcOldBlockTag
-  ): Promise<BN | "pending" | undefined> {
+  ): Promise<bigint | "pending" | undefined> {
     if (oldBlockTag === undefined || oldBlockTag === "latest") {
       return this._node.getLatestBlockNumber();
     }
@@ -1364,7 +1358,13 @@ export class EthModule {
     }
 
     if (oldBlockTag === "earliest") {
-      return new BN(0);
+      return 0n;
+    }
+
+    if (oldBlockTag === "safe" || oldBlockTag === "finalized") {
+      this._checkPostMergeBlockTags(oldBlockTag);
+
+      return this._node.getLatestBlockNumber();
     }
 
     const block = await this._node.getBlockByNumber(oldBlockTag);
@@ -1374,7 +1374,7 @@ export class EthModule {
   private async _resolveNewBlockTag(
     newBlockTag: OptionalRpcNewBlockTag,
     defaultValue: RpcNewBlockTag = "latest"
-  ): Promise<BN | "pending"> {
+  ): Promise<bigint | "pending"> {
     if (newBlockTag === undefined) {
       newBlockTag = defaultValue;
     }
@@ -1388,23 +1388,31 @@ export class EthModule {
     }
 
     if (newBlockTag === "earliest") {
-      return new BN(0);
+      return 0n;
     }
 
-    if ("blockNumber" in newBlockTag && "blockHash" in newBlockTag) {
-      throw new InvalidArgumentsError(
-        "Invalid block tag received. Only one of hash or block number can be used."
-      );
+    if (newBlockTag === "safe" || newBlockTag === "finalized") {
+      this._checkPostMergeBlockTags(newBlockTag);
+
+      return this._node.getLatestBlockNumber();
     }
 
-    if ("blockNumber" in newBlockTag && "requireCanonical" in newBlockTag) {
-      throw new InvalidArgumentsError(
-        "Invalid block tag received. requireCanonical only works with hashes."
-      );
+    if (!BigIntUtils.isBigInt(newBlockTag)) {
+      if ("blockNumber" in newBlockTag && "blockHash" in newBlockTag) {
+        throw new InvalidArgumentsError(
+          "Invalid block tag received. Only one of hash or block number can be used."
+        );
+      }
+
+      if ("blockNumber" in newBlockTag && "requireCanonical" in newBlockTag) {
+        throw new InvalidArgumentsError(
+          "Invalid block tag received. requireCanonical only works with hashes."
+        );
+      }
     }
 
     let block: Block | undefined;
-    if (BN.isBN(newBlockTag)) {
+    if (BigIntUtils.isBigInt(newBlockTag)) {
       block = await this._node.getBlockByNumber(newBlockTag);
     } else if ("blockNumber" in newBlockTag) {
       block = await this._node.getBlockByNumber(newBlockTag.blockNumber);
@@ -1427,7 +1435,7 @@ export class EthModule {
 
   private async _normalizeOldBlockTagForFilterRequest(
     blockTag: OptionalRpcOldBlockTag
-  ): Promise<BN> {
+  ): Promise<bigint> {
     if (
       blockTag === undefined ||
       blockTag === "latest" ||
@@ -1436,8 +1444,14 @@ export class EthModule {
       return LATEST_BLOCK;
     }
 
+    if (blockTag === "safe" || blockTag === "finalized") {
+      this._checkPostMergeBlockTags(blockTag);
+
+      return LATEST_BLOCK;
+    }
+
     if (blockTag === "earliest") {
-      return new BN(0);
+      return 0n;
     }
 
     return blockTag;
@@ -1448,7 +1462,7 @@ export class EthModule {
       return tag;
     }
 
-    if (BN.isBN(tag)) {
+    if (BigIntUtils.isBigInt(tag)) {
       return tag.toString();
     }
 
@@ -1548,7 +1562,7 @@ export class EthModule {
     if (singleTransactionMined) {
       const block = results[0].block;
       const tx = block.transactions[0];
-      const txGasUsed = results[0].blockResult.results[0].gasUsed.toNumber();
+      const txGasUsed = results[0].blockResult.results[0].totalGasSpent;
       const trace = results[0].traces[0];
       await this._logSingleTransaction(tx, block, txGasUsed, trace);
 
@@ -1570,11 +1584,11 @@ export class EthModule {
         const blockNumber = sentTxResult.block.header.number;
         const code = await this._node.getCodeFromTrace(
           sentTxTrace.trace,
-          new BN(blockNumber)
+          blockNumber
         );
 
         const { block, blockResult } = sentTxResult;
-        const gasUsed = blockResult.results[sentTxIndex].gasUsed.toNumber();
+        const gasUsed = blockResult.results[sentTxIndex].totalGasSpent;
         this._logger.logCurrentlySentTransaction(
           sentTx,
           gasUsed,
@@ -1591,12 +1605,12 @@ export class EthModule {
   private async _logSingleTransaction(
     tx: TypedTransaction,
     block: Block,
-    txGasUsed: number,
+    txGasUsed: bigint,
     txTrace: GatherTracesResult
   ) {
     const code = await this._node.getCodeFromTrace(
       txTrace.trace,
-      new BN(block.header.number)
+      block.header.number
     );
     this._logger.logSingleTransaction(tx, block, txGasUsed, txTrace, code);
 
@@ -1610,7 +1624,7 @@ export class EthModule {
     for (const txTrace of traces) {
       const code = await this._node.getCodeFromTrace(
         txTrace.trace,
-        new BN(block.header.number)
+        block.header.number
       );
 
       codes.push(code);
@@ -1702,7 +1716,7 @@ You can use them by running Hardhat Network with 'hardfork' ${ACCESS_LIST_MIN_HA
     if (
       rpcRequest.maxFeePerGas !== undefined &&
       rpcRequest.maxPriorityFeePerGas !== undefined &&
-      rpcRequest.maxPriorityFeePerGas.gt(rpcRequest.maxFeePerGas)
+      rpcRequest.maxPriorityFeePerGas > rpcRequest.maxFeePerGas
     ) {
       throw new InvalidInputError(
         `maxPriorityFeePerGas (${rpcRequest.maxPriorityFeePerGas.toString()}) is bigger than maxFeePerGas (${rpcRequest.maxFeePerGas.toString()})`
@@ -1713,7 +1727,7 @@ You can use them by running Hardhat Network with 'hardfork' ${ACCESS_LIST_MIN_HA
   // TODO: Find a better place for this
   private _validateEip155HardforkRequirement(tx: Transaction) {
     // 27 and 28 are only valid for non-EIP-155 legacy txs
-    if (tx.v!.eqn(27) || tx.v!.eqn(28)) {
+    if (tx.v === 27n || tx.v === 28n) {
       return;
     }
 
@@ -1747,4 +1761,15 @@ You can use them by running Hardhat Network with 'hardfork' ${EIP1559_MIN_HARDFO
       );
     }
   }
+
+  private _checkPostMergeBlockTags(blockTag: "safe" | "finalized") {
+    const isPostMerge = this._node.isPostMergeHardfork();
+    const hardfork = this._node.hardfork;
+
+    if (!isPostMerge) {
+      throw new InvalidArgumentsError(
+        `The '${blockTag}' block tag is not allowed in pre-merge hardforks. You are using the '${hardfork}' hardfork.`
+      );
+    }
+  }
 }

package/src/internal/hardhat-network/provider/modules/evm.ts

@@ -1,4 +1,3 @@
-import { BN } from "ethereumjs-util";
 import * as t from "io-ts";
 
 import { BoundExperimentalHardhatNetworkMessageTraceHook } from "../../../../types";
@@ -85,16 +84,15 @@ export class EvmModule {
     timestamp: RpcQuantityOrNumber
   ): Promise<string> {
     const latestBlock = await this._node.getLatestBlock();
-    const increment = new BN(timestamp).sub(
-      new BN(latestBlock.header.timestamp)
-    );
-    if (increment.lte(new BN(0))) {
+    const increment = BigInt(timestamp) - latestBlock.header.timestamp;
+
+    if (increment <= 0n) {
       throw new InvalidInputError(
         `Timestamp ${timestamp.toString()} is lower than or equal to previous block's timestamp` +
-          ` ${new BN(latestBlock.header.timestamp).toNumber()}`
+          ` ${latestBlock.header.timestamp}`
       );
     }
-    this._node.setNextBlockTimestamp(new BN(timestamp));
+    this._node.setNextBlockTimestamp(BigInt(timestamp));
     return timestamp.toString();
   }
 
@@ -107,7 +105,7 @@ export class EvmModule {
   private async _increaseTimeAction(
     increment: RpcQuantityOrNumber
   ): Promise<string> {
-    this._node.increaseTime(new BN(increment));
+    this._node.increaseTime(BigInt(increment));
     const totalIncrement = this._node.getTimeIncrement();
     // This RPC call is an exception: it returns a number in decimal
     return totalIncrement.toString();
@@ -123,21 +121,20 @@ export class EvmModule {
   }
 
   private async _mineAction(timestamp: RpcQuantityOrNumber): Promise<string> {
+    timestamp = BigInt(timestamp);
     // if timestamp is specified, make sure it is bigger than previous
     // block's timestamp
-    if (timestamp !== 0) {
+    if (timestamp !== 0n) {
       const latestBlock = await this._node.getLatestBlock();
-      const increment = new BN(timestamp).sub(
-        new BN(latestBlock.header.timestamp)
-      );
-      if (increment.lte(new BN(0))) {
+      const increment = timestamp - latestBlock.header.timestamp;
+      if (increment <= 0n) {
         throw new InvalidInputError(
           `Timestamp ${timestamp.toString()} is lower than previous block's timestamp` +
-            ` ${new BN(latestBlock.header.timestamp).toNumber()}`
+            ` ${latestBlock.header.timestamp}`
         );
       }
     }
-    const result = await this._node.mineBlock(new BN(timestamp));
+    const result = await this._node.mineBlock(timestamp);
 
     await this._logBlock(result);
 
@@ -146,12 +143,12 @@ export class EvmModule {
 
   // evm_revert
 
-  private _revertParams(params: any[]): [BN] {
+  private _revertParams(params: any[]): [bigint] {
     return validateParams(params, rpcQuantity);
   }
 
-  private async _revertAction(snapshotId: BN): Promise<boolean> {
-    return this._node.revertToSnapshot(snapshotId.toNumber());
+  private async _revertAction(snapshotId: bigint): Promise<boolean> {
+    return this._node.revertToSnapshot(Number(snapshotId));
   }
 
   // evm_snapshot
@@ -192,12 +189,12 @@ export class EvmModule {
 
   // evm_setBlockGasLimit
 
-  private _setBlockGasLimitParams(params: any[]): [BN] {
+  private _setBlockGasLimitParams(params: any[]): [bigint] {
     return validateParams(params, rpcQuantity);
   }
 
-  private async _setBlockGasLimitAction(blockGasLimit: BN): Promise<true> {
-    if (blockGasLimit.lte(new BN(0))) {
+  private async _setBlockGasLimitAction(blockGasLimit: bigint): Promise<true> {
+    if (blockGasLimit <= 0n) {
       throw new InvalidInputError("Block gas limit must be greater than 0");
     }
 
@@ -212,7 +209,7 @@ export class EvmModule {
     for (const txTrace of traces) {
       const code = await this._node.getCodeFromTrace(
         txTrace.trace,
-        new BN(block.header.number)
+        block.header.number
       );
 
       codes.push(code);

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

@@ -1,4 +1,4 @@
-import { Address, BN } from "ethereumjs-util";
+import { Address } from "@ignored/util";
 import * as t from "io-ts";
 
 import {
@@ -173,7 +173,7 @@ export class HardhatModule {
 
   private async _intervalMineAction(): Promise<boolean> {
     const result = await this._node.mineBlock();
-    const blockNumber = result.block.header.number.toNumber();
+    const blockNumber = result.block.header.number;
 
     const isEmpty = result.block.transactions.length === 0;
     if (isEmpty) {
@@ -238,12 +238,12 @@ export class HardhatModule {
 
   // hardhat_setMinGasPrice
 
-  private _setMinGasPriceParams(params: any[]): [BN] {
+  private _setMinGasPriceParams(params: any[]): [bigint] {
     return validateParams(params, rpcQuantity);
   }
 
-  private async _setMinGasPriceAction(minGasPrice: BN): Promise<true> {
-    if (minGasPrice.lt(new BN(0))) {
+  private async _setMinGasPriceAction(minGasPrice: bigint): Promise<true> {
+    if (minGasPrice < 0n) {
       throw new InvalidInputError("Minimum gas price cannot be negative");
     }
 
@@ -269,11 +269,11 @@ export class HardhatModule {
 
   // hardhat_setBalance
 
-  private _setBalanceParams(params: any[]): [Buffer, BN] {
+  private _setBalanceParams(params: any[]): [Buffer, bigint] {
     return validateParams(params, rpcAddress, rpcQuantity);
   }
 
-  private async _setBalanceAction(address: Buffer, newBalance: BN) {
+  private async _setBalanceAction(address: Buffer, newBalance: bigint) {
     await this._node.setAccountBalance(new Address(address), newBalance);
     return true;
   }
@@ -291,18 +291,18 @@ export class HardhatModule {
 
   // hardhat_setNonce
 
-  private _setNonceParams(params: any[]): [Buffer, BN] {
+  private _setNonceParams(params: any[]): [Buffer, bigint] {
     return validateParams(params, rpcAddress, rpcQuantity);
   }
 
-  private async _setNonceAction(address: Buffer, newNonce: BN) {
+  private async _setNonceAction(address: Buffer, newNonce: bigint) {
     await this._node.setNextConfirmedNonce(new Address(address), newNonce);
     return true;
   }
 
   // hardhat_setStorageAt
 
-  private _setStorageAtParams(params: any[]): [Buffer, BN, Buffer] {
+  private _setStorageAtParams(params: any[]): [Buffer, bigint, Buffer] {
     const [address, positionIndex, value] = validateParams(
       params,
       rpcAddress,
@@ -310,8 +310,8 @@ export class HardhatModule {
       rpcData
     );
 
-    const MAX_WORD_VALUE = new BN(2).pow(new BN(256));
-    if (positionIndex.gte(MAX_WORD_VALUE)) {
+    const MAX_WORD_VALUE = 2n ** 256n;
+    if (positionIndex >= MAX_WORD_VALUE) {
       throw new InvalidInputError(
         `Storage key must not be greater than or equal to 2^256. Received ${positionIndex.toString()}.`
       );
@@ -330,7 +330,7 @@ export class HardhatModule {
 
   private async _setStorageAtAction(
     address: Buffer,
-    positionIndex: BN,
+    positionIndex: bigint,
     value: Buffer
   ) {
     await this._node.setStorageAt(new Address(address), positionIndex, value);
@@ -338,11 +338,11 @@ export class HardhatModule {
   }
 
   // hardhat_setNextBlockBaseFeePerGas
-  private _setNextBlockBaseFeePerGasParams(params: any[]): [BN] {
+  private _setNextBlockBaseFeePerGasParams(params: any[]): [bigint] {
     return validateParams(params, rpcQuantity);
   }
 
-  private _setNextBlockBaseFeePerGasAction(baseFeePerGas: BN) {
+  private _setNextBlockBaseFeePerGasAction(baseFeePerGas: bigint) {
     if (!this._node.isEip1559Active()) {
       throw new InvalidInputError(
         "hardhat_setNextBlockBaseFeePerGas is disabled because EIP-1559 is not active"
@@ -365,7 +365,7 @@ export class HardhatModule {
   }
 
   // hardhat_mine
-  private async _hardhatMineAction(blockCount?: BN, interval?: BN) {
+  private async _hardhatMineAction(blockCount?: bigint, interval?: bigint) {
     const mineBlockResults = await this._node.mineBlocks(blockCount, interval);
 
     for (const [i, result] of mineBlockResults.entries()) {
@@ -381,7 +381,9 @@ export class HardhatModule {
 
     return true;
   }
-  private _hardhatMineParams(params: any[]): [BN | undefined, BN | undefined] {
+  private _hardhatMineParams(
+    params: any[]
+  ): [bigint | undefined, bigint | undefined] {
     return validateParams(params, optional(rpcQuantity), optional(rpcQuantity));
   }
 
@@ -395,7 +397,7 @@ export class HardhatModule {
     for (const txTrace of traces) {
       const code = await this._node.getCodeFromTrace(
         txTrace.trace,
-        new BN(block.header.number)
+        block.header.number
       );
 
       codes.push(code);
@@ -427,7 +429,7 @@ export class HardhatModule {
 
   private async _logHardhatMinedBlock(result: MineBlockResult) {
     const isEmpty = result.block.transactions.length === 0;
-    const blockNumber = result.block.header.number.toNumber();
+    const blockNumber = result.block.header.number;
 
     if (isEmpty) {
       this._logger.logEmptyHardhatMinedBlock(