hardhat 2.10.2 → 2.11.0-dev.0

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(

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

@@ -1,8 +1,8 @@
-import { Block } from "@ethereumjs/block";
-import { TypedTransaction } from "@ethereumjs/tx";
+import { Block } from "@ignored/block";
+import { TypedTransaction } from "@ignored/tx";
+import { bufferToHex } from "@ignored/util";
 import ansiEscapes from "ansi-escapes";
 import chalk, { Chalk } from "chalk";
-import { BN, bufferToHex } from "ethereumjs-util";
 import util from "util";
 
 import { assertHardhatInvariant } from "../../../core/errors";
@@ -62,8 +62,8 @@ export class ModulesLogger {
   private _logs: Array<string | [string, string]> = [];
   private _titleLength = 0;
   private _currentIndent = 0;
-  private _emptyIntervalMinedBlocksRangeStart: number | undefined = undefined;
-  private _emptyHardhatMinedBlocksRangeStart: number | undefined = undefined;
+  private _emptyIntervalMinedBlocksRangeStart: bigint | undefined = undefined;
+  private _emptyHardhatMinedBlocksRangeStart: bigint | undefined = undefined;
   private _methodBeingCollapsed?: string;
   private _methodCollapsedCount: number = 0;
 
@@ -108,7 +108,8 @@ export class ModulesLogger {
 
         for (let i = 0; i < block.transactions.length; i++) {
           const tx = block.transactions[i];
-          const txGasUsed = results[i].gasUsed.toNumber();
+
+          const txGasUsed = results[i].totalGasSpent;
           const txTrace = traces[i];
           const code = codes[i];
 
@@ -133,7 +134,7 @@ export class ModulesLogger {
       "The array of codes should have the same length as the array of results"
     );
 
-    const blockNumber = result.block.header.number.toNumber();
+    const blockNumber = result.block.header.number;
     const isEmpty = result.block.transactions.length === 0;
 
     this._indent(() => {
@@ -155,7 +156,7 @@ export class ModulesLogger {
 
           for (let i = 0; i < block.transactions.length; i++) {
             const tx = block.transactions[i];
-            const txGasUsed = results[i].gasUsed.toNumber();
+            const txGasUsed = results[i].totalGasSpent;
             const txTrace = traces[i];
             const code = codes[i];
 
@@ -187,7 +188,7 @@ export class ModulesLogger {
 
         for (let i = 0; i < block.transactions.length; i++) {
           const tx = block.transactions[i];
-          const txGasUsed = results[i].gasUsed.toNumber();
+          const txGasUsed = results[i].totalGasSpent;
           const txTrace = traces[i];
           const code = codes[i];
 
@@ -204,7 +205,7 @@ export class ModulesLogger {
   public logSingleTransaction(
     tx: TypedTransaction,
     block: Block,
-    txGasUsed: number,
+    txGasUsed: bigint,
     txTrace: GatherTracesResult,
     code: Buffer
   ) {
@@ -217,14 +218,11 @@ export class ModulesLogger {
 
       this._logTxFrom(tx.getSenderAddress().toBuffer());
       this._logTxTo(tx.to?.toBuffer(), txTrace.trace);
-      this._logTxValue(new BN(tx.value));
-      this._logWithTitle(
-        "Gas used",
-        `${txGasUsed} of ${tx.gasLimit.toNumber()}`
-      );
+      this._logTxValue(tx.value);
+      this._logWithTitle("Gas used", `${txGasUsed} of ${tx.gasLimit}`);
 
       this._logWithTitle(
-        `Block #${block.header.number.toNumber()}`,
+        `Block #${block.header.number}`,
         bufferToHex(block.hash())
       );
 
@@ -238,7 +236,7 @@ export class ModulesLogger {
 
   public logCurrentlySentTransaction(
     tx: TypedTransaction,
-    txGasUsed: number,
+    txGasUsed: bigint,
     txTrace: GatherTracesResult,
     code: Buffer,
     block: Block
@@ -255,14 +253,11 @@ export class ModulesLogger {
 
       this._logTxFrom(tx.getSenderAddress().toBuffer());
       this._logTxTo(tx.to?.toBuffer(), txTrace.trace);
-      this._logTxValue(new BN(tx.value));
-      this._logWithTitle(
-        "Gas used",
-        `${txGasUsed} of ${tx.gasLimit.toNumber()}`
-      );
+      this._logTxValue(tx.value);
+      this._logWithTitle("Gas used", `${txGasUsed} of ${tx.gasLimit}`);
 
       this._logWithTitle(
-        `Block #${block.header.number.toNumber()}`,
+        `Block #${block.header.number}`,
         bufferToHex(block.hash())
       );
 
@@ -288,7 +283,7 @@ export class ModulesLogger {
 
       this._logTxFrom(callParams.from);
       this._logTxTo(callParams.to, trace);
-      this._logTxValue(new BN(callParams.value));
+      this._logTxValue(callParams.value);
 
       this._logConsoleLogMessages(consoleLogMessages);
 
@@ -310,7 +305,7 @@ export class ModulesLogger {
 
       this._logTxFrom(callParams.from);
       this._logTxTo(callParams.to, trace);
-      if (callParams.value.gtn(0)) {
+      if (callParams.value > 0n) {
         this._logTxValue(callParams.value);
       }
 
@@ -324,9 +319,9 @@ export class ModulesLogger {
   }
 
   public logMinedBlockNumber(
-    blockNumber: number,
+    blockNumber: bigint,
     isEmpty: boolean,
-    baseFeePerGas?: BN
+    baseFeePerGas?: bigint
   ) {
     if (isEmpty) {
       this._log(
@@ -400,9 +395,9 @@ export class ModulesLogger {
   }
 
   public printIntervalMinedBlockNumber(
-    blockNumber: number,
+    blockNumber: bigint,
     isEmpty: boolean,
-    baseFeePerGas?: BN
+    baseFeePerGas?: bigint
   ) {
     if (this._emptyIntervalMinedBlocksRangeStart !== undefined) {
       this._print(
@@ -433,7 +428,10 @@ export class ModulesLogger {
     }
   }
 
-  public logEmptyHardhatMinedBlock(blockNumber: number, baseFeePerGas?: BN) {
+  public logEmptyHardhatMinedBlock(
+    blockNumber: bigint,
+    baseFeePerGas?: bigint
+  ) {
     this._indent(() => {
       if (this._emptyHardhatMinedBlocksRangeStart !== undefined) {
         this._log(
@@ -568,7 +566,7 @@ export class ModulesLogger {
     tx: TypedTransaction,
     txTrace: GatherTracesResult,
     code: Buffer,
-    txGasUsed: number,
+    txGasUsed: bigint,
     {
       highlightTxHash,
     }: {
@@ -590,11 +588,8 @@ export class ModulesLogger {
       this._logContractAndFunctionName(txTrace.trace, code);
       this._logTxFrom(tx.getSenderAddress().toBuffer());
       this._logTxTo(tx.to?.toBuffer(), txTrace.trace);
-      this._logTxValue(new BN(tx.value));
-      this._logWithTitle(
-        "Gas used",
-        `${txGasUsed} of ${tx.gasLimit.toNumber()}`
-      );
+      this._logTxValue(tx.value);
+      this._logWithTitle("Gas used", `${txGasUsed} of ${tx.gasLimit}`);
 
       this._logConsoleLogMessages(txTrace.consoleLogMessages);
 
@@ -741,7 +736,7 @@ export class ModulesLogger {
     this._logWithTitle("To", toString);
   }
 
-  private _logTxValue(value: BN) {
+  private _logTxValue(value: bigint) {
     this._logWithTitle("Value", weiToHumanReadableString(value));
   }
 
@@ -750,9 +745,7 @@ export class ModulesLogger {
   }
 
   private _logBlockNumber(block: Block) {
-    this._log(
-      `Block #${block.header.number.toNumber()}: ${bufferToHex(block.hash())}`
-    );
+    this._log(`Block #${block.header.number}: ${bufferToHex(block.hash())}`);
   }
 
   private _logEmptyLineBetweenTransactions(

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

@@ -1,4 +1,4 @@
-import Common from "@ethereumjs/common";
+import { Common } from "@ignored/common";
 
 import { numberToRpcQuantity } from "../../../core/jsonrpc/types/base-types";
 import { validateParams } from "../../../core/jsonrpc/types/input/validation";

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

@@ -1,4 +1,5 @@
-import { Address, toRpcSig } from "ethereumjs-util";
+import { Address, toRpcSig } from "@ignored/util";
+
 import { rpcAddress, rpcData } from "../../../core/jsonrpc/types/base-types";
 import { validateParams } from "../../../core/jsonrpc/types/input/validation";
 import { MethodNotFoundError } from "../../../core/providers/errors";

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

@@ -1,4 +1,5 @@
-import { keccak256 } from "ethereumjs-util";
+import { arrToBufArr, bufArrToArr } from "@ignored/util";
+import { keccak256 } from "ethereum-cryptography/keccak";
 
 import {
   bufferToRpcData,
@@ -34,8 +35,8 @@ export class Web3Module {
 
   private async _clientVersionAction(): Promise<string> {
     const hardhatPackage = await getPackageJson();
-    const ethereumjsVMPackage = require("@ethereumjs/vm/package.json");
-    return `HardhatNetwork/${hardhatPackage.version}/@ethereumjs/vm/${ethereumjsVMPackage.version}`;
+    const ethereumjsVMPackage = require("@ignored/vm/package.json");
+    return `HardhatNetwork/${hardhatPackage.version}/@ignored/vm/${ethereumjsVMPackage.version}`;
   }
 
   // web3_sha3
@@ -45,6 +46,6 @@ export class Web3Module {
   }
 
   private async _sha3Action(buffer: Buffer): Promise<string> {
-    return bufferToRpcData(keccak256(buffer));
+    return bufferToRpcData(arrToBufArr(keccak256(bufArrToArr(buffer))));
   }
 }

package/src/internal/hardhat-network/provider/node-types.ts

@@ -1,12 +1,12 @@
 import type { ReturnData } from "./return-data";
 
-import { Block } from "@ethereumjs/block";
-import { RunBlockResult } from "@ethereumjs/vm/dist/runBlock";
-import { BN } from "ethereumjs-util";
+import { Block } from "@ignored/block";
+import { RunBlockResult } from "@ignored/vm";
 
 import { HARDHAT_MEMPOOL_SUPPORTED_ORDERS } from "../../constants";
 import { BuildInfo, HardhatNetworkChainsConfig } from "../../../types";
 import { MessageTrace } from "../stack-traces/message-trace";
+import { RandomBufferGenerator } from "./utils/random";
 
 export type NodeConfig = LocalNodeConfig | ForkedNodeConfig;
 
@@ -18,17 +18,17 @@ export function isForkedNodeConfig(
 
 interface CommonConfig {
   automine: boolean;
-  blockGasLimit: number;
+  blockGasLimit: bigint;
   chainId: number;
   genesisAccounts: GenesisAccount[];
   hardfork: string;
-  minGasPrice: BN;
+  minGasPrice: bigint;
   networkId: number;
   networkName: string;
   allowUnlimitedContractSize?: boolean;
   initialDate?: Date;
   tracingConfig?: TracingConfig;
-  initialBaseFeePerGas?: number;
+  initialBaseFeePerGas?: bigint;
   mempoolOrder: MempoolOrder;
   coinbase: string;
   chains: HardhatNetworkChainsConfig;
@@ -57,7 +57,7 @@ export type MempoolOrder = typeof HARDHAT_MEMPOOL_SUPPORTED_ORDERS[number];
 
 export interface GenesisAccount {
   privateKey: string;
-  balance: string | number | BN;
+  balance: string | number | bigint;
 }
 
 export type AccessListBufferItem = [Buffer, Buffer[]];
@@ -65,16 +65,16 @@ export type AccessListBufferItem = [Buffer, Buffer[]];
 export interface CallParams {
   to?: Buffer;
   from: Buffer;
-  gasLimit: BN;
-  value: BN;
+  gasLimit: bigint;
+  value: bigint;
   data: Buffer;
-  // We use this access list format because @ethereumjs/tx access list data
+  // We use this access list format because @ignored/tx access list data
   // forces us to use it or stringify them
   accessList?: AccessListBufferItem[];
   // Fee params
-  gasPrice?: BN;
-  maxFeePerGas?: BN;
-  maxPriorityFeePerGas?: BN;
+  gasPrice?: bigint;
+  maxFeePerGas?: bigint;
+  maxPriorityFeePerGas?: bigint;
 }
 
 export type TransactionParams =
@@ -86,19 +86,19 @@ interface BaseTransactionParams {
   // `to` should be undefined for contract creation
   to?: Buffer;
   from: Buffer;
-  gasLimit: BN;
-  value: BN;
+  gasLimit: bigint;
+  value: bigint;
   data: Buffer;
-  nonce: BN;
+  nonce: bigint;
 }
 
 export interface LegacyTransactionParams extends BaseTransactionParams {
-  gasPrice: BN;
+  gasPrice: bigint;
 }
 
 export interface AccessListTransactionParams extends BaseTransactionParams {
-  gasPrice: BN;
-  // We use this access list format because @ethereumjs/tx access list data
+  gasPrice: bigint;
+  // We use this access list format because @ignored/tx access list data
   // forces us to use it or stringify them
   accessList: AccessListBufferItem[];
   // We don't include chainId as it's not necessary, the node
@@ -107,13 +107,13 @@ export interface AccessListTransactionParams extends BaseTransactionParams {
 
 export interface EIP1559TransactionParams extends BaseTransactionParams {
   accessList: AccessListBufferItem[];
-  maxFeePerGas: BN;
-  maxPriorityFeePerGas: BN;
+  maxFeePerGas: bigint;
+  maxPriorityFeePerGas: bigint;
 }
 
 export interface FilterParams {
-  fromBlock: BN;
-  toBlock: BN;
+  fromBlock: bigint;
+  toBlock: bigint;
   addresses: Buffer[];
   normalizedTopics: Array<Array<Buffer | null> | null>;
 }
@@ -124,11 +124,12 @@ export interface Snapshot {
   latestBlock: Block;
   stateRoot: Buffer;
   txPoolSnapshotId: number;
-  blockTimeOffsetSeconds: BN;
-  nextBlockTimestamp: BN;
-  irregularStatesByBlockNumber: Map<string, Buffer>;
-  userProvidedNextBlockBaseFeePerGas: BN | undefined;
+  blockTimeOffsetSeconds: bigint;
+  nextBlockTimestamp: bigint;
+  irregularStatesByBlockNumber: Map<bigint, Buffer>;
+  userProvidedNextBlockBaseFeePerGas: bigint | undefined;
   coinbase: string;
+  mixHashGenerator: RandomBufferGenerator;
 }
 
 export type SendTransactionResult =
@@ -147,7 +148,7 @@ export interface RunCallResult extends GatherTracesResult {
 }
 
 export interface EstimateGasResult extends GatherTracesResult {
-  estimation: BN;
+  estimation: bigint;
 }
 
 export interface GatherTracesResult {
@@ -157,8 +158,8 @@ export interface GatherTracesResult {
 }
 
 export interface FeeHistory {
-  oldestBlock: BN;
-  baseFeePerGas: BN[];
+  oldestBlock: bigint;
+  baseFeePerGas: bigint[];
   gasUsedRatio: number[];
-  reward?: BN[][];
+  reward?: bigint[][];
 }