hardhat 2.10.1 → 2.11.0-dev.0

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

@@ -1,9 +1,9 @@
-import { Block } from "@ethereumjs/block";
-import Common from "@ethereumjs/common";
-import { TypedTransaction } from "@ethereumjs/tx";
-import { Address, BN } from "ethereumjs-util";
+import { Block } from "@ignored/block";
+import { Common } from "@ignored/common";
+import { TypedTransaction } from "@ignored/tx";
+import { Address } from "@ignored/util";
 
-import { FeeMarketEIP1559TxData } from "@ethereumjs/tx/dist/types";
+import { FeeMarketEIP1559TxData } from "@ignored/tx/dist/types";
 import { RpcBlockWithTransactions } from "../../../core/jsonrpc/types/output/block";
 import { RpcTransactionReceipt } from "../../../core/jsonrpc/types/output/receipt";
 import { RpcTransaction } from "../../../core/jsonrpc/types/output/transaction";
@@ -37,24 +37,24 @@ export class ForkBlockchain
 
   constructor(
     private _jsonRpcClient: JsonRpcClient,
-    private _forkBlockNumber: BN,
+    private _forkBlockNumber: bigint,
     common: Common
   ) {
     super(common);
   }
 
-  public getLatestBlockNumber(): BN {
+  public getLatestBlockNumber(): bigint {
     return this._latestBlockNumber;
   }
 
   public async getBlock(
-    blockHashOrNumber: Buffer | number | BN
+    blockHashOrNumber: Buffer | bigint
   ): Promise<Block | null> {
     if (
-      (typeof blockHashOrNumber === "number" || BN.isBN(blockHashOrNumber)) &&
-      this._data.isReservedBlock(new BN(blockHashOrNumber))
+      typeof blockHashOrNumber === "bigint" &&
+      this._data.isReservedBlock(blockHashOrNumber)
     ) {
-      this._data.fulfillBlockReservation(new BN(blockHashOrNumber));
+      this._data.fulfillBlockReservation(blockHashOrNumber);
     }
 
     let block: Block | undefined | null;
@@ -63,42 +63,42 @@ export class ForkBlockchain
       return block ?? null;
     }
 
-    block = await this._getBlockByNumber(new BN(blockHashOrNumber));
+    block = await this._getBlockByNumber(BigInt(blockHashOrNumber));
     return block ?? null;
   }
 
   public async addBlock(block: Block): Promise<Block> {
-    const blockNumber = new BN(block.header.number);
-    if (!blockNumber.eq(this._latestBlockNumber.addn(1))) {
+    const blockNumber = BigInt(block.header.number);
+    if (blockNumber !== this._latestBlockNumber + 1n) {
       throw new Error(
-        `Invalid block number ${blockNumber.toNumber()}. Expected ${this._latestBlockNumber
-          .addn(1)
-          .toNumber()}`
+        `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.gt(this._forkBlockNumber.addn(1))) {
+    if (blockNumber > this._forkBlockNumber + 1n) {
       const parent = await this.getLatestBlock();
       if (!block.header.parentHash.equals(parent.hash())) {
         throw new Error("Invalid parent hash");
       }
     }
 
-    this._latestBlockNumber = this._latestBlockNumber.addn(1);
+    this._latestBlockNumber++;
     const totalDifficulty = await this._computeTotalDifficulty(block);
     this._data.addBlock(block, totalDifficulty);
     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,
@@ -107,25 +107,25 @@ export class ForkBlockchain
       previousBlockTotalDifficulty,
       previousBlockBaseFeePerGas
     );
-    this._latestBlockNumber = this._latestBlockNumber.add(count);
+    this._latestBlockNumber += count;
   }
 
   public deleteLaterBlocks(block: Block): void {
-    const blockNumber = new BN(block.header.number);
+    const blockNumber = block.header.number;
     const savedBlock = this._data.getBlockByNumber(blockNumber);
     if (savedBlock === undefined || !savedBlock.hash().equals(block.hash())) {
       throw new Error("Invalid block");
     }
 
-    const nextBlockNumber = blockNumber.addn(1);
-    if (this._forkBlockNumber.gte(nextBlockNumber)) {
+    const nextBlockNumber = blockNumber + 1n;
+    if (this._forkBlockNumber >= nextBlockNumber) {
       throw new Error("Cannot delete remote block");
     }
 
     this._delBlock(nextBlockNumber);
   }
 
-  public async getTotalDifficulty(blockHash: Buffer): Promise<BN> {
+  public async getTotalDifficulty(blockHash: Buffer): Promise<bigint> {
     let td = this._data.getTotalDifficulty(blockHash);
     if (td !== undefined) {
       return td;
@@ -194,14 +194,14 @@ export class ForkBlockchain
   }
 
   public async getLogs(filterParams: FilterParams): Promise<RpcLogOutput[]> {
-    if (filterParams.fromBlock.lte(this._forkBlockNumber)) {
+    if (filterParams.fromBlock <= this._forkBlockNumber) {
       let toBlock = filterParams.toBlock;
       let localLogs: RpcLogOutput[] = [];
-      if (toBlock.gt(this._forkBlockNumber)) {
+      if (toBlock > this._forkBlockNumber) {
         toBlock = this._forkBlockNumber;
         localLogs = this._data.getLogs({
           ...filterParams,
-          fromBlock: this._forkBlockNumber.addn(1),
+          fromBlock: this._forkBlockNumber + 1n,
         });
       }
       const remoteLogs = await this._jsonRpcClient.getLogs({
@@ -227,8 +227,8 @@ export class ForkBlockchain
     return this._processRemoteBlock(rpcBlock);
   }
 
-  private async _getBlockByNumber(blockNumber: BN) {
-    if (blockNumber.gt(this._latestBlockNumber)) {
+  private async _getBlockByNumber(blockNumber: bigint) {
+    if (blockNumber > this._latestBlockNumber) {
       return undefined;
     }
     const block = await super.getBlock(blockNumber);
@@ -247,19 +247,18 @@ export class ForkBlockchain
       rpcBlock === null ||
       rpcBlock.hash === null ||
       rpcBlock.number === null ||
-      rpcBlock.number.gt(this._forkBlockNumber)
+      rpcBlock.number > this._forkBlockNumber
     ) {
       return undefined;
     }
 
-    // We copy the common and set it to London or Berlin if the remote block
-    // had EIP-1559 activated or not. The reason for this is that ethereumjs
-    // throws if we have a base fee for an older hardfork, and set a default
-    // one for London.
-    const common = this._common.copy();
-    if (rpcBlock.baseFeePerGas !== undefined) {
-      common.setHardfork("london"); // TODO: consider changing this to "latest hardfork"
-    } else {
+    const forkNetworkId = this._jsonRpcClient.getNetworkId();
+    const common = new Common({ chain: forkNetworkId });
+
+    // We set the common's hardfork to Berlin if the remote block doesn't have
+    // EIP-1559 activated. The reason for this is that ethereumjs throws if we
+    // have a base fee for an older hardfork, and set a default one for London.
+    if (rpcBlock.baseFeePerGas === undefined) {
       common.setHardfork("berlin");
     }
 
@@ -275,21 +274,24 @@ export class ForkBlockchain
 
       // 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
+      consensusFormatValidation: false,
     });
 
     for (const transaction of rpcBlock.transactions) {
       let tx;
-      if (transaction.type === undefined || transaction.type.eqn(0)) {
+      if (transaction.type === undefined || transaction.type === 0n) {
         tx = new ReadOnlyValidTransaction(
           new Address(transaction.from),
           rpcToTxData(transaction)
         );
-      } else if (transaction.type.eqn(1)) {
+      } else if (transaction.type === 1n) {
         tx = new ReadOnlyValidEIP2930Transaction(
           new Address(transaction.from),
           rpcToTxData(transaction)
         );
-      } else if (transaction.type.eqn(2)) {
+      } else if (transaction.type === 2n) {
         tx = new ReadOnlyValidEIP1559Transaction(
           new Address(transaction.from),
           rpcToTxData(transaction) as FeeMarketEIP1559TxData
@@ -307,19 +309,19 @@ export class ForkBlockchain
     return block;
   }
 
-  protected _delBlock(blockNumber: BN): void {
-    if (blockNumber.lte(this._forkBlockNumber)) {
+  protected _delBlock(blockNumber: bigint): void {
+    if (blockNumber <= this._forkBlockNumber) {
       throw new Error("Cannot delete remote block");
     }
     super._delBlock(blockNumber);
-    this._latestBlockNumber = blockNumber.subn(1);
+    this._latestBlockNumber = blockNumber - 1n;
   }
 
   private _processRemoteTransaction(rpcTransaction: RpcTransaction | null) {
     if (
       rpcTransaction === null ||
       rpcTransaction.blockNumber === null ||
-      rpcTransaction.blockNumber.gt(this._forkBlockNumber)
+      rpcTransaction.blockNumber > this._forkBlockNumber
     ) {
       return undefined;
     }
@@ -337,7 +339,7 @@ export class ForkBlockchain
   private async _processRemoteReceipt(
     txReceipt: RpcTransactionReceipt | null
   ): Promise<RpcReceiptOutput | undefined> {
-    if (txReceipt === null || txReceipt.blockNumber.gt(this._forkBlockNumber)) {
+    if (txReceipt === null || txReceipt.blockNumber > this._forkBlockNumber) {
       return undefined;
     }
 

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

@@ -1,15 +1,15 @@
-import { DefaultStateManager } from "@ethereumjs/vm/dist/state";
-import { EIP2929StateManager } from "@ethereumjs/vm/dist/state/interface";
+import { StateManager } from "@ignored/statemanager";
 import {
   Account,
+  bigIntToHex,
+  bufferToBigInt,
   Address,
-  BN,
   bufferToHex,
-  keccak256,
   KECCAK256_NULL,
   toBuffer,
   unpadBuffer,
-} from "ethereumjs-util";
+} from "@ignored/util";
+import { keccak256 } from "ethereum-cryptography/keccak";
 import { Map as ImmutableMap, Record as ImmutableRecord } from "immutable";
 
 import { assertHardhatInvariant } from "../../../core/errors";
@@ -17,13 +17,13 @@ import { InternalError } from "../../../core/providers/errors";
 import { JsonRpcClient } from "../../jsonrpc/client";
 import { GenesisAccount } from "../node-types";
 import { makeAccount } from "../utils/makeAccount";
+import { randomHash } from "../utils/random";
 
 import {
   AccountState,
   makeAccountState,
   makeEmptyAccountState,
 } from "./AccountState";
-import { randomHash } from "./random";
 
 const encodeStorageKey = (address: Buffer, position: Buffer): string => {
   return `${address.toString("hex")}${unpadBuffer(position).toString("hex")}`;
@@ -42,14 +42,14 @@ const notCheckpointedError = (method: string) =>
 const notSupportedError = (method: string) =>
   new Error(`${method} is not supported when forking from remote network`);
 
-export class ForkStateManager implements EIP2929StateManager {
+export class ForkStateManager implements StateManager {
   private _state: State = ImmutableMap<string, ImmutableRecord<AccountState>>();
   private _initialStateRoot: string = randomHash();
   private _stateRoot: string = this._initialStateRoot;
   private _stateRootToState: Map<string, State> = new Map();
   private _originalStorageCache: Map<string, Buffer> = new Map();
   private _stateCheckpoints: string[] = [];
-  private _contextBlockNumber = this._forkBlockNumber.clone();
+  private _contextBlockNumber = this._forkBlockNumber;
   private _contextChanged = false;
 
   // used by the DefaultStateManager calls
@@ -60,7 +60,7 @@ export class ForkStateManager implements EIP2929StateManager {
 
   constructor(
     private readonly _jsonRpcClient: JsonRpcClient,
-    private readonly _forkBlockNumber: BN
+    private readonly _forkBlockNumber: bigint
   ) {
     this._state = ImmutableMap<string, ImmutableRecord<AccountState>>();
 
@@ -69,7 +69,7 @@ export class ForkStateManager implements EIP2929StateManager {
 
   public async initializeGenesisAccounts(genesisAccounts: GenesisAccount[]) {
     const accounts: Array<{ address: Address; account: Account }> = [];
-    const noncesPromises: Array<Promise<BN>> = [];
+    const noncesPromises: Array<Promise<bigint>> = [];
 
     for (const ga of genesisAccounts) {
       const account = makeAccount(ga);
@@ -118,10 +118,10 @@ export class ForkStateManager implements EIP2929StateManager {
     const localBalance = localAccount?.get("balance");
     const localCode = localAccount?.get("code");
 
-    let nonce: Buffer | BN | undefined =
+    let nonce: Buffer | bigint | undefined =
       localNonce !== undefined ? toBuffer(localNonce) : undefined;
 
-    let balance: Buffer | BN | undefined =
+    let balance: Buffer | bigint | undefined =
       localBalance !== undefined ? toBuffer(localBalance) : undefined;
 
     let code: Buffer | undefined =
@@ -205,7 +205,7 @@ export class ForkStateManager implements EIP2929StateManager {
 
     const remoteValue = await this._jsonRpcClient.getStorageAt(
       address,
-      new BN(key),
+      bufferToBigInt(key),
       this._contextBlockNumber
     );
 
@@ -266,15 +266,6 @@ export class ForkStateManager implements EIP2929StateManager {
       throw notCheckpointedError("commit");
     }
     this._stateCheckpoints.pop();
-
-    const storageMap = this._accessedStorage.pop();
-    if (storageMap !== undefined) {
-      (DefaultStateManager.prototype as any)._accessedStorageMerge.call(
-        this,
-        this._accessedStorage,
-        storageMap
-      );
-    }
   }
 
   public async revert(): Promise<void> {
@@ -323,8 +314,8 @@ export class ForkStateManager implements EIP2929StateManager {
     // From https://eips.ethereum.org/EIPS/eip-161
     // An account is considered empty when it has no code and zero nonce and zero balance.
     return (
-      new BN(account.nonce).eqn(0) &&
-      new BN(account.balance).eqn(0) &&
+      account.nonce === 0n &&
+      account.balance === 0n &&
       account.codeHash.equals(KECCAK256_NULL)
     );
   }
@@ -337,7 +328,7 @@ export class ForkStateManager implements EIP2929StateManager {
 
   public setBlockContext(
     stateRoot: Buffer,
-    blockNumber: BN,
+    blockNumber: bigint,
     irregularState?: Buffer
   ) {
     if (this._stateCheckpoints.length !== 0) {
@@ -349,11 +340,11 @@ export class ForkStateManager implements EIP2929StateManager {
       return;
     }
 
-    if (blockNumber.eq(this._forkBlockNumber)) {
+    if (blockNumber === this._forkBlockNumber) {
       this._setStateRoot(toBuffer(this._initialStateRoot));
       return;
     }
-    if (blockNumber.gt(this._forkBlockNumber)) {
+    if (blockNumber > this._forkBlockNumber) {
       this._setStateRoot(stateRoot);
       return;
     }
@@ -411,45 +402,14 @@ export class ForkStateManager implements EIP2929StateManager {
     return value;
   }
 
-  // the following methods are copied verbatim from
-  // DefaultStateManager
-
-  public isWarmedAddress(address: Buffer): boolean {
-    return DefaultStateManager.prototype.isWarmedAddress.call(this, address);
-  }
-
-  public addWarmedAddress(address: Buffer): void {
-    return DefaultStateManager.prototype.addWarmedAddress.call(this, address);
-  }
-
-  public isWarmedStorage(address: Buffer, slot: Buffer): boolean {
-    return DefaultStateManager.prototype.isWarmedStorage.call(
-      this,
-      address,
-      slot
-    );
-  }
-
-  public addWarmedStorage(address: Buffer, slot: Buffer): void {
-    return DefaultStateManager.prototype.addWarmedStorage.call(
-      this,
-      address,
-      slot
-    );
-  }
-
-  public clearWarmedAccounts(): void {
-    return DefaultStateManager.prototype.clearWarmedAccounts.call(this);
-  }
-
   private _putAccount(address: Address, account: Account): void {
     // Because the vm only ever modifies the nonce, balance and codeHash using this
     // method we ignore the stateRoot property
     const hexAddress = address.toString();
     let localAccount = this._state.get(hexAddress) ?? makeAccountState();
     localAccount = localAccount
-      .set("nonce", bufferToHex(account.nonce.toBuffer()))
-      .set("balance", bufferToHex(account.balance.toBuffer()));
+      .set("nonce", bigIntToHex(account.nonce))
+      .set("balance", bigIntToHex(account.balance));
 
     // Code is set to empty string here to prevent unnecessary
     // JsonRpcClient.getCode calls in getAccount method
@@ -468,4 +428,19 @@ export class ForkStateManager implements EIP2929StateManager {
     this._stateRoot = newRoot;
     this._state = state;
   }
+
+  public async hasStateRoot(root: Buffer): Promise<boolean> {
+    return this._state.has(bufferToHex(root));
+  }
+
+  public async flush(): Promise<void> {
+    // not implemented
+  }
+
+  public async modifyAccountFields(
+    _address: Address,
+    _accountFields: any
+  ): Promise<void> {
+    // not implemented
+  }
 }

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

@@ -1,4 +1,4 @@
-import { BlockData } from "@ethereumjs/block";
+import { BlockData } from "@ignored/block";
 
 import { RpcBlockWithTransactions } from "../../../core/jsonrpc/types/output/block";
 
@@ -13,7 +13,7 @@ export function rpcToBlockData(rpcBlock: RpcBlockWithTransactions): BlockData {
       stateRoot: rpcBlock.stateRoot,
       transactionsTrie: rpcBlock.transactionsRoot,
       receiptTrie: rpcBlock.receiptsRoot,
-      bloom: rpcBlock.logsBloom,
+      logsBloom: rpcBlock.logsBloom,
       difficulty: rpcBlock.difficulty,
       number: rpcBlock.number ?? undefined,
       gasLimit: rpcBlock.gasLimit,

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

@@ -1,12 +1,12 @@
-import { AccessListEIP2930TxData, TxData } from "@ethereumjs/tx";
+import { AccessListEIP2930TxData, TxData } from "@ignored/tx";
 
-import { FeeMarketEIP1559TxData } from "@ethereumjs/tx/dist/types";
+import { FeeMarketEIP1559TxData } from "@ignored/tx/dist/types";
 import { RpcTransaction } from "../../../core/jsonrpc/types/output/transaction";
 
 export function rpcToTxData(
   rpcTransaction: RpcTransaction
 ): TxData | AccessListEIP2930TxData | FeeMarketEIP1559TxData {
-  const isEip1559 = rpcTransaction.type?.eqn(2) ?? false;
+  const isEip1559 = rpcTransaction.type === 2n;
 
   return {
     gasLimit: rpcTransaction.gas,