hardhat 2.8.4 → 2.9.0

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

@@ -1,60 +1,50 @@
 import { Block } from "@ethereumjs/block";
+import Common from "@ethereumjs/common";
 import { TypedTransaction } from "@ethereumjs/tx";
 import { BN, zeros } from "ethereumjs-util";
 
-import { BlockchainData } from "./BlockchainData";
+import { BlockchainBase } from "./BlockchainBase";
 import { FilterParams } from "./node-types";
-import { RpcLogOutput, RpcReceiptOutput } from "./output";
+import { RpcLogOutput } from "./output";
 import { HardhatBlockchainInterface } from "./types/HardhatBlockchainInterface";
 
 /* eslint-disable @nomiclabs/hardhat-internal-rules/only-hardhat-error */
 
-export class HardhatBlockchain implements HardhatBlockchainInterface {
-  private readonly _data = new BlockchainData();
+export class HardhatBlockchain
+  extends BlockchainBase
+  implements HardhatBlockchainInterface
+{
   private _length = 0;
 
-  public async getLatestBlock(): Promise<Block> {
-    const block = this._data.getBlockByNumber(new BN(this._length - 1));
-    if (block === undefined) {
-      throw new Error("No block available");
-    }
-    return block;
+  constructor(common: Common) {
+    super(common);
   }
 
-  public async getBlock(
-    blockHashOrNumber: Buffer | BN | number
-  ): Promise<Block | null> {
-    if (typeof blockHashOrNumber === "number") {
-      return this._data.getBlockByNumber(new BN(blockHashOrNumber)) ?? null;
-    }
-    if (BN.isBN(blockHashOrNumber)) {
-      return this._data.getBlockByNumber(blockHashOrNumber) ?? null;
-    }
-    return this._data.getBlockByHash(blockHashOrNumber) ?? null;
+  public getLatestBlockNumber(): BN {
+    return new BN(this._length - 1);
   }
 
   public async addBlock(block: Block): Promise<Block> {
     this._validateBlock(block);
-    const totalDifficulty = this._computeTotalDifficulty(block);
+    const totalDifficulty = await this._computeTotalDifficulty(block);
     this._data.addBlock(block, totalDifficulty);
     this._length += 1;
     return block;
   }
 
-  public async putBlock(block: Block): Promise<void> {
-    await this.addBlock(block);
-  }
-
-  public deleteBlock(blockHash: Buffer) {
-    const block = this._data.getBlockByHash(blockHash);
-    if (block === undefined) {
-      throw new Error("Block not found");
-    }
-    this._delBlock(block);
-  }
-
-  public async delBlock(blockHash: Buffer) {
-    this.deleteBlock(blockHash);
+  public reserveBlocks(
+    count: BN,
+    interval: BN,
+    previousBlockStateRoot: Buffer,
+    previousBlockTotalDifficulty: BN
+  ) {
+    super.reserveBlocks(
+      count,
+      interval,
+      previousBlockStateRoot,
+      previousBlockTotalDifficulty
+    );
+    this._length = this._length + count.toNumber();
   }
 
   public deleteLaterBlocks(block: Block): void {
@@ -62,12 +52,8 @@ export class HardhatBlockchain implements HardhatBlockchainInterface {
     if (actual === undefined) {
       throw new Error("Invalid block");
     }
-    const nextBlock = this._data.getBlockByNumber(
-      new BN(actual.header.number).addn(1)
-    );
-    if (nextBlock !== undefined) {
-      this._delBlock(nextBlock);
-    }
+
+    this._delBlock(actual.header.number.addn(1));
   }
 
   public async getTotalDifficulty(blockHash: Buffer): Promise<BN> {
@@ -84,12 +70,6 @@ export class HardhatBlockchain implements HardhatBlockchainInterface {
     return this.getLocalTransaction(transactionHash);
   }
 
-  public getLocalTransaction(
-    transactionHash: Buffer
-  ): TypedTransaction | undefined {
-    return this._data.getTransaction(transactionHash);
-  }
-
   public async getBlockByTransactionHash(
     transactionHash: Buffer
   ): Promise<Block | null> {
@@ -101,36 +81,21 @@ export class HardhatBlockchain implements HardhatBlockchainInterface {
     return this._data.getTransactionReceipt(transactionHash) ?? null;
   }
 
-  public addTransactionReceipts(receipts: RpcReceiptOutput[]) {
-    for (const receipt of receipts) {
-      this._data.addTransactionReceipt(receipt);
-    }
-  }
-
   public async getLogs(filterParams: FilterParams): Promise<RpcLogOutput[]> {
     return this._data.getLogs(filterParams);
   }
 
-  public iterator(
-    _name: string,
-    _onBlock: (block: Block, reorg: boolean) => void | Promise<void>
-  ): Promise<number | void> {
-    throw new Error("Method not implemented.");
-  }
-
-  public async getBaseFee(): Promise<BN> {
-    const latestBlock = await this.getLatestBlock();
-    return latestBlock.header.calcNextBaseFee();
-  }
-
   private _validateBlock(block: Block) {
     const blockNumber = block.header.number.toNumber();
     const parentHash = block.header.parentHash;
     const parent = this._data.getBlockByNumber(new BN(blockNumber - 1));
 
     if (this._length !== blockNumber) {
-      throw new Error("Invalid block number");
+      throw new Error(
+        `Invalid block number ${blockNumber}. Expected ${this._length}.`
+      );
     }
+
     if (
       (blockNumber === 0 && !parentHash.equals(zeros(32))) ||
       (blockNumber > 0 &&
@@ -141,26 +106,8 @@ export class HardhatBlockchain implements HardhatBlockchainInterface {
     }
   }
 
-  private _computeTotalDifficulty(block: Block): BN {
-    const difficulty = new BN(block.header.difficulty);
-    if (block.header.parentHash.equals(zeros(32))) {
-      return difficulty;
-    }
-    const parentTD = this._data.getTotalDifficulty(block.header.parentHash);
-    if (parentTD === undefined) {
-      throw new Error("This should never happen");
-    }
-    return parentTD.add(difficulty);
-  }
-
-  private _delBlock(block: Block): void {
-    const blockNumber = block.header.number.toNumber();
-    for (let i = blockNumber; i < this._length; i++) {
-      const current = this._data.getBlockByNumber(new BN(i));
-      if (current !== undefined) {
-        this._data.removeBlock(current);
-      }
-    }
-    this._length = blockNumber;
+  protected _delBlock(blockNumber: BN): void {
+    super._delBlock(blockNumber);
+    this._length = blockNumber.toNumber();
   }
 }

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

@@ -9,7 +9,7 @@ import { RpcTransactionReceipt } from "../../../core/jsonrpc/types/output/receip
 import { RpcTransaction } from "../../../core/jsonrpc/types/output/transaction";
 import { InternalError } from "../../../core/providers/errors";
 import { JsonRpcClient } from "../../jsonrpc/client";
-import { BlockchainData } from "../BlockchainData";
+import { BlockchainBase } from "../BlockchainBase";
 import { FilterParams } from "../node-types";
 import {
   remoteReceiptToRpcReceiptOutput,
@@ -29,28 +29,35 @@ import { rpcToTxData } from "./rpcToTxData";
 
 /* eslint-disable @nomiclabs/hardhat-internal-rules/only-hardhat-error */
 
-export class ForkBlockchain implements HardhatBlockchainInterface {
-  private _data = new BlockchainData();
+export class ForkBlockchain
+  extends BlockchainBase
+  implements HardhatBlockchainInterface
+{
   private _latestBlockNumber = this._forkBlockNumber;
 
   constructor(
     private _jsonRpcClient: JsonRpcClient,
     private _forkBlockNumber: BN,
-    private _common: Common
-  ) {}
+    common: Common
+  ) {
+    super(common);
+  }
 
-  public async getLatestBlock(): Promise<Block> {
-    const block = await this.getBlock(this._latestBlockNumber);
-    if (block === null) {
-      throw new Error("Block not found");
-    }
-    return block;
+  public getLatestBlockNumber(): BN {
+    return this._latestBlockNumber;
   }
 
   public async getBlock(
     blockHashOrNumber: Buffer | number | BN
   ): Promise<Block | null> {
-    let block: Block | undefined;
+    if (
+      (typeof blockHashOrNumber === "number" || BN.isBN(blockHashOrNumber)) &&
+      this._data.isReservedBlock(new BN(blockHashOrNumber))
+    ) {
+      this._data.fulfillBlockReservation(new BN(blockHashOrNumber));
+    }
+
+    let block: Block | undefined | null;
     if (Buffer.isBuffer(blockHashOrNumber)) {
       block = await this._getBlockByHash(blockHashOrNumber);
       return block ?? null;
@@ -63,7 +70,11 @@ export class ForkBlockchain implements HardhatBlockchainInterface {
   public async addBlock(block: Block): Promise<Block> {
     const blockNumber = new BN(block.header.number);
     if (!blockNumber.eq(this._latestBlockNumber.addn(1))) {
-      throw new Error("Invalid block number");
+      throw new Error(
+        `Invalid block number ${blockNumber.toNumber()}. Expected ${this._latestBlockNumber
+          .addn(1)
+          .toNumber()}`
+      );
     }
 
     // When forking a network whose consensus is not the classic PoW,
@@ -82,20 +93,19 @@ export class ForkBlockchain implements HardhatBlockchainInterface {
     return block;
   }
 
-  public async putBlock(block: Block): Promise<void> {
-    await this.addBlock(block);
-  }
-
-  public deleteBlock(blockHash: Buffer) {
-    const block = this._data.getBlockByHash(blockHash);
-    if (block === undefined) {
-      throw new Error("Block not found");
-    }
-    this._delBlock(block);
-  }
-
-  public async delBlock(blockHash: Buffer) {
-    this.deleteBlock(blockHash);
+  public reserveBlocks(
+    count: BN,
+    interval: BN,
+    previousBlockStateRoot: Buffer,
+    previousBlockTotalDifficulty: BN
+  ) {
+    super.reserveBlocks(
+      count,
+      interval,
+      previousBlockStateRoot,
+      previousBlockTotalDifficulty
+    );
+    this._latestBlockNumber = this._latestBlockNumber.add(count);
   }
 
   public deleteLaterBlocks(block: Block): void {
@@ -109,10 +119,8 @@ export class ForkBlockchain implements HardhatBlockchainInterface {
     if (this._forkBlockNumber.gte(nextBlockNumber)) {
       throw new Error("Cannot delete remote block");
     }
-    const nextBlock = this._data.getBlockByNumber(nextBlockNumber);
-    if (nextBlock !== undefined) {
-      return this._delBlock(nextBlock);
-    }
+
+    this._delBlock(nextBlockNumber);
   }
 
   public async getTotalDifficulty(blockHash: Buffer): Promise<BN> {
@@ -144,12 +152,6 @@ export class ForkBlockchain implements HardhatBlockchainInterface {
     return tx;
   }
 
-  public getLocalTransaction(
-    transactionHash: Buffer
-  ): TypedTransaction | undefined {
-    return this._data.getTransaction(transactionHash);
-  }
-
   public async getBlockByTransactionHash(
     transactionHash: Buffer
   ): Promise<Block | null> {
@@ -185,12 +187,6 @@ export class ForkBlockchain implements HardhatBlockchainInterface {
     return null;
   }
 
-  public addTransactionReceipts(receipts: RpcReceiptOutput[]) {
-    for (const receipt of receipts) {
-      this._data.addTransactionReceipt(receipt);
-    }
-  }
-
   public getForkBlockNumber() {
     return this._forkBlockNumber;
   }
@@ -220,18 +216,6 @@ export class ForkBlockchain implements HardhatBlockchainInterface {
     return this._data.getLogs(filterParams);
   }
 
-  public iterator(
-    _name: string,
-    _onBlock: (block: Block, reorg: boolean) => void | Promise<void>
-  ): Promise<number | void> {
-    throw new Error("Method not implemented.");
-  }
-
-  public async getBaseFee(): Promise<BN> {
-    const latestBlock = await this.getLatestBlock();
-    return latestBlock.header.calcNextBaseFee();
-  }
-
   private async _getBlockByHash(blockHash: Buffer) {
     const block = this._data.getBlockByHash(blockHash);
     if (block !== undefined) {
@@ -245,8 +229,8 @@ export class ForkBlockchain implements HardhatBlockchainInterface {
     if (blockNumber.gt(this._latestBlockNumber)) {
       return undefined;
     }
-    const block = this._data.getBlockByNumber(blockNumber);
-    if (block !== undefined) {
+    const block = await super.getBlock(blockNumber);
+    if (block !== null) {
       return block;
     }
     const rpcBlock = await this._jsonRpcClient.getBlockByNumber(
@@ -319,41 +303,12 @@ export class ForkBlockchain implements HardhatBlockchainInterface {
     return block;
   }
 
-  private async _computeTotalDifficulty(block: Block): Promise<BN> {
-    const difficulty = new BN(block.header.difficulty);
-    const blockNumber = new BN(block.header.number);
-    if (blockNumber.eqn(0)) {
-      return difficulty;
-    }
-
-    const parentBlock =
-      this._data.getBlockByNumber(blockNumber.subn(1)) ??
-      (await this.getBlock(blockNumber.subn(1)));
-    if (parentBlock === null) {
-      throw new Error("Block not found");
-    }
-    const parentHash = parentBlock.hash();
-    const parentTD = this._data.getTotalDifficulty(parentHash);
-    if (parentTD === undefined) {
-      throw new Error("This should never happen");
-    }
-    return parentTD.add(difficulty);
-  }
-
-  private _delBlock(block: Block): void {
-    if (new BN(block.header.number).lte(this._forkBlockNumber)) {
+  protected _delBlock(blockNumber: BN): void {
+    if (blockNumber.lte(this._forkBlockNumber)) {
       throw new Error("Cannot delete remote block");
     }
-
-    const blockNumber = block.header.number.toNumber();
-    for (let i = blockNumber; this._latestBlockNumber.gten(i); i++) {
-      const current = this._data.getBlockByNumber(new BN(i));
-      if (current !== undefined) {
-        this._data.removeBlock(current);
-      }
-    }
-
-    this._latestBlockNumber = new BN(blockNumber).subn(1);
+    super._delBlock(blockNumber);
+    this._latestBlockNumber = blockNumber.subn(1);
   }
 
   private _processRemoteTransaction(rpcTransaction: RpcTransaction | null) {

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

@@ -325,7 +325,7 @@ export class EthModule {
   }
 
   private async _blockNumberAction(): Promise<string> {
-    const blockNumber = await this._node.getLatestBlockNumber();
+    const blockNumber = this._node.getLatestBlockNumber();
     return numberToRpcQuantity(blockNumber);
   }
 
@@ -1405,7 +1405,7 @@ export class EthModule {
     }
 
     if (block === undefined) {
-      const latestBlock = await this._node.getLatestBlockNumber();
+      const latestBlock = this._node.getLatestBlockNumber();
 
       throw new InvalidInputError(
         `Received invalid block tag ${this._newBlockTagToString(

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

@@ -26,6 +26,7 @@ import {
   InvalidInputError,
   MethodNotFoundError,
 } from "../../../core/providers/errors";
+import { optional } from "../../../util/io-ts";
 import { MessageTrace } from "../../stack-traces/message-trace";
 import { HardhatNode } from "../node";
 import { ForkConfig, MineBlockResult } from "../node-types";
@@ -111,6 +112,9 @@ export class HardhatModule {
 
       case "hardhat_setCoinbase":
         return this._setCoinbaseAction(...this._setCoinbaseParams(params));
+
+      case "hardhat_mine":
+        return this._hardhatMineAction(...this._hardhatMineParams(params));
     }
 
     throw new MethodNotFoundError(`Method ${method} not found`);
@@ -173,14 +177,14 @@ export class HardhatModule {
 
     const isEmpty = result.block.transactions.length === 0;
     if (isEmpty) {
-      this._logger.printMinedBlockNumber(
+      this._logger.printIntervalMinedBlockNumber(
         blockNumber,
         isEmpty,
         result.block.header.baseFeePerGas
       );
     } else {
-      await this._logBlock(result);
-      this._logger.printMinedBlockNumber(blockNumber, isEmpty);
+      await this._logBlock(result, { isIntervalMined: true });
+      this._logger.printIntervalMinedBlockNumber(blockNumber, isEmpty);
       const printedSomething = this._logger.printLogs();
       if (printedSomething) {
         this._logger.printEmptyLine();
@@ -360,7 +364,31 @@ export class HardhatModule {
     return true;
   }
 
-  private async _logBlock(result: MineBlockResult) {
+  // hardhat_mine
+  private async _hardhatMineAction(blockCount?: BN, interval?: BN) {
+    const mineBlockResults = await this._node.mineBlocks(blockCount, interval);
+
+    for (const [i, result] of mineBlockResults.entries()) {
+      await this._logHardhatMinedBlock(result);
+
+      // print an empty line after logging blocks with txs,
+      // unless it's the last logged block
+      const isEmpty = result.block.transactions.length === 0;
+      if (!isEmpty && i + 1 < mineBlockResults.length) {
+        this._logger.logEmptyLine();
+      }
+    }
+
+    return true;
+  }
+  private _hardhatMineParams(params: any[]): [BN | undefined, BN | undefined] {
+    return validateParams(params, optional(rpcQuantity), optional(rpcQuantity));
+  }
+
+  private async _logBlock(
+    result: MineBlockResult,
+    { isIntervalMined }: { isIntervalMined: boolean }
+  ) {
     const { block, traces } = result;
 
     const codes: Buffer[] = [];
@@ -373,7 +401,11 @@ export class HardhatModule {
       codes.push(code);
     }
 
-    this._logger.logIntervalMinedBlock(result, codes);
+    if (isIntervalMined) {
+      this._logger.logIntervalMinedBlock(result, codes);
+    } else {
+      this._logger.logMinedBlock(result, codes);
+    }
 
     for (const txTrace of traces) {
       await this._runHardhatNetworkMessageTraceHooks(txTrace.trace, false);
@@ -392,4 +424,18 @@ export class HardhatModule {
       await hook(trace, isCall);
     }
   }
+
+  private async _logHardhatMinedBlock(result: MineBlockResult) {
+    const isEmpty = result.block.transactions.length === 0;
+    const blockNumber = result.block.header.number.toNumber();
+
+    if (isEmpty) {
+      this._logger.logEmptyHardhatMinedBlock(
+        blockNumber,
+        result.block.header.baseFeePerGas
+      );
+    } else {
+      await this._logBlock(result, { isIntervalMined: false });
+    }
+  }
 }

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

@@ -27,7 +27,8 @@ interface PrintOptions {
   color?: Chalk;
   replaceLastLine?: boolean;
   collapsePrintedMethod?: boolean;
-  collapseMinedBlock?: boolean;
+  collapseIntervalMinedBlock?: boolean;
+  collapseHardhatMinedBlock?: boolean;
 }
 
 function printLine(line: string) {
@@ -61,7 +62,8 @@ export class ModulesLogger {
   private _logs: Array<string | [string, string]> = [];
   private _titleLength = 0;
   private _currentIndent = 0;
-  private _emptyMinedBlocksRangeStart: number | undefined = undefined;
+  private _emptyIntervalMinedBlocksRangeStart: number | undefined = undefined;
+  private _emptyHardhatMinedBlocksRangeStart: number | undefined = undefined;
   private _methodBeingCollapsed?: string;
   private _methodCollapsedCount: number = 0;
 
@@ -395,18 +397,18 @@ export class ModulesLogger {
     return true;
   }
 
-  public printMinedBlockNumber(
+  public printIntervalMinedBlockNumber(
     blockNumber: number,
     isEmpty: boolean,
     baseFeePerGas?: BN
   ) {
-    if (this._emptyMinedBlocksRangeStart !== undefined) {
+    if (this._emptyIntervalMinedBlocksRangeStart !== undefined) {
       this._print(
-        `Mined empty block range #${this._emptyMinedBlocksRangeStart} to #${blockNumber}`,
-        { collapseMinedBlock: true, replaceLastLine: true }
+        `Mined empty block range #${this._emptyIntervalMinedBlocksRangeStart} to #${blockNumber}`,
+        { collapseIntervalMinedBlock: true, replaceLastLine: true }
       );
     } else {
-      this._emptyMinedBlocksRangeStart = blockNumber;
+      this._emptyIntervalMinedBlocksRangeStart = blockNumber;
 
       if (isEmpty) {
         this._print(
@@ -414,7 +416,7 @@ export class ModulesLogger {
             baseFeePerGas !== undefined ? ` with base fee ${baseFeePerGas}` : ""
           }`,
           {
-            collapseMinedBlock: true,
+            collapseIntervalMinedBlock: true,
           }
         );
 
@@ -422,11 +424,35 @@ export class ModulesLogger {
       }
 
       this._print(`Mined block #${blockNumber}`, {
-        collapseMinedBlock: true,
+        collapseIntervalMinedBlock: true,
       });
     }
   }
 
+  public logEmptyHardhatMinedBlock(blockNumber: number, baseFeePerGas?: BN) {
+    this._indent(() => {
+      if (this._emptyHardhatMinedBlocksRangeStart !== undefined) {
+        this._log(
+          `Mined empty block range #${this._emptyHardhatMinedBlocksRangeStart} to #${blockNumber}`,
+          { collapseHardhatMinedBlock: true, replaceLastLine: true }
+        );
+      } else {
+        this._emptyHardhatMinedBlocksRangeStart = blockNumber;
+
+        this._log(
+          `Mined empty block #${blockNumber}${
+            baseFeePerGas !== undefined ? ` with base fee ${baseFeePerGas}` : ""
+          }`,
+          {
+            collapseHardhatMinedBlock: true,
+          }
+        );
+
+        return;
+      }
+    });
+  }
+
   public printMetaMaskWarning() {
     const message =
       "If you are using MetaMask, you can learn how to fix this error here: https://hardhat.org/metamask-issue";
@@ -510,12 +536,19 @@ export class ModulesLogger {
     if (printOptions.collapsePrintedMethod !== true) {
       this._stopCollapsingMethod();
     }
-    if (printOptions.collapseMinedBlock !== true) {
-      this._emptyMinedBlocksRangeStart = undefined;
+    if (printOptions.collapseIntervalMinedBlock !== true) {
+      this._emptyIntervalMinedBlocksRangeStart = undefined;
+    }
+    if (printOptions.collapseHardhatMinedBlock !== true) {
+      this._emptyHardhatMinedBlocksRangeStart = undefined;
     }
     const formattedMessage = this._format(msg, printOptions);
 
-    this._logs.push(formattedMessage);
+    if (printOptions.replaceLastLine === true) {
+      this._logs[this._logs.length - 1] = formattedMessage;
+    } else {
+      this._logs.push(formattedMessage);
+    }
   }
 
   private _logError(err: Error) {
@@ -579,8 +612,11 @@ export class ModulesLogger {
     if (printOptions.collapsePrintedMethod !== true) {
       this._stopCollapsingMethod();
     }
-    if (printOptions.collapseMinedBlock !== true) {
-      this._emptyMinedBlocksRangeStart = undefined;
+    if (printOptions.collapseIntervalMinedBlock !== true) {
+      this._emptyIntervalMinedBlocksRangeStart = undefined;
+    }
+    if (printOptions.collapseHardhatMinedBlock !== true) {
+      this._emptyHardhatMinedBlocksRangeStart = undefined;
     }
     const formattedMessage = this._format(msg, printOptions);
 

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

@@ -1,3 +1,5 @@
+import type { ReturnData } from "./return-data";
+
 import { Block } from "@ethereumjs/block";
 import { RunBlockResult } from "@ethereumjs/vm/dist/runBlock";
 import { BN } from "ethereumjs-util";
@@ -6,8 +8,6 @@ import { HARDHAT_MEMPOOL_SUPPORTED_ORDERS } from "../../constants";
 import { BuildInfo, HardhatNetworkChainsConfig } from "../../../types";
 import { MessageTrace } from "../stack-traces/message-trace";
 
-import type { ReturnData } from "./return-data";
-
 export type NodeConfig = LocalNodeConfig | ForkedNodeConfig;
 
 export function isForkedNodeConfig(