hardhat 2.8.2 → 2.9.0-dev.0

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

@@ -1,12 +1,22 @@
 import { Block } from "@ethereumjs/block";
+import Common from "@ethereumjs/common";
 import { TypedTransaction } from "@ethereumjs/tx";
 import Bloom from "@ethereumjs/vm/dist/bloom";
 import { BN, bufferToHex } from "ethereumjs-util";
 
+import { assertHardhatInvariant } from "../../core/errors";
 import { bloomFilter, filterLogs } from "./filter";
 import { FilterParams } from "./node-types";
 import { RpcLogOutput, RpcReceiptOutput } from "./output";
 
+interface Reservation {
+  first: BN;
+  last: BN;
+  interval: BN;
+  previousBlockStateRoot: Buffer;
+  previousBlockTotalDifficulty: BN;
+}
+
 export class BlockchainData {
   private _blocksByNumber: Map<number, Block> = new Map();
   private _blocksByHash: Map<string, Block> = new Map();
@@ -14,6 +24,26 @@ export class BlockchainData {
   private _transactions: Map<string, TypedTransaction> = new Map();
   private _transactionReceipts: Map<string, RpcReceiptOutput> = new Map();
   private _totalDifficulty: Map<string, BN> = new Map();
+  private _blockReservations: Reservation[] = new Array();
+
+  constructor(private _common: Common) {}
+
+  public reserveBlocks(
+    first: BN,
+    count: BN,
+    interval: BN,
+    previousBlockStateRoot: Buffer,
+    previousBlockTotalDifficulty: BN
+  ) {
+    const reservation: Reservation = {
+      first,
+      last: first.add(count.subn(1)),
+      interval,
+      previousBlockStateRoot,
+      previousBlockTotalDifficulty,
+    };
+    this._blockReservations.push(reservation);
+  }
 
   public getBlockByNumber(blockNumber: BN) {
     return this._blocksByNumber.get(blockNumber.toNumber());
@@ -88,6 +118,11 @@ export class BlockchainData {
     }
   }
 
+  /**
+   * WARNING: this method can leave the blockchain in an invalid state where
+   * there are gaps between blocks. Ideally we should have a method that removes
+   * the given block and all the following blocks.
+   */
   public removeBlock(block: Block) {
     const blockHash = bufferToHex(block.hash());
     const blockNumber = new BN(block.header.number).toNumber();
@@ -110,4 +145,113 @@ export class BlockchainData {
   public addTransactionReceipt(receipt: RpcReceiptOutput) {
     this._transactionReceipts.set(receipt.transactionHash, receipt);
   }
+
+  public isReservedBlock(blockNumber: BN): boolean {
+    return this._findBlockReservation(blockNumber) !== -1;
+  }
+
+  private _findBlockReservation(blockNumber: BN): number {
+    return this._blockReservations.findIndex(
+      (reservation) =>
+        reservation.first.lte(blockNumber) && blockNumber.lte(reservation.last)
+    );
+  }
+
+  /**
+   * WARNING: this method only removes the given reservation and can result in
+   * gaps in the reservations array. Ideally we should have a method that
+   * removes the given reservation and all the following reservations.
+   */
+  private _removeReservation(index: number): Reservation {
+    assertHardhatInvariant(
+      index in this._blockReservations,
+      `Reservation ${index} does not exist`
+    );
+    const reservation = this._blockReservations[index];
+
+    this._blockReservations.splice(index, 1);
+
+    return reservation;
+  }
+
+  /**
+   * Cancel and return the reservation that has block `blockNumber`
+   */
+  public cancelReservationWithBlock(blockNumber: BN): Reservation {
+    return this._removeReservation(this._findBlockReservation(blockNumber));
+  }
+
+  public fulfillBlockReservation(blockNumber: BN) {
+    // in addition to adding the given block, the reservation needs to be split
+    // in two in order to accomodate access to the given block.
+
+    const reservationIndex = this._findBlockReservation(blockNumber);
+    assertHardhatInvariant(
+      reservationIndex !== -1,
+      `No reservation to fill for block number ${blockNumber}`
+    );
+
+    // capture the timestamp before removing the reservation:
+    const timestamp = this._calculateTimestampForReservedBlock(blockNumber);
+
+    // split the block reservation:
+    const oldReservation = this._removeReservation(reservationIndex);
+
+    if (!blockNumber.eq(oldReservation.first)) {
+      this._blockReservations.push({
+        ...oldReservation,
+        last: blockNumber.subn(1),
+      });
+    }
+
+    if (!blockNumber.eq(oldReservation.last)) {
+      this._blockReservations.push({
+        ...oldReservation,
+        first: blockNumber.addn(1),
+      });
+    }
+
+    this.addBlock(
+      Block.fromBlockData(
+        {
+          header: {
+            number: blockNumber,
+            stateRoot: oldReservation.previousBlockStateRoot,
+            timestamp,
+          },
+        },
+        { common: this._common }
+      ),
+      oldReservation.previousBlockTotalDifficulty
+    );
+  }
+
+  private _calculateTimestampForReservedBlock(blockNumber: BN): BN {
+    const reservationIndex = this._findBlockReservation(blockNumber);
+
+    assertHardhatInvariant(
+      reservationIndex !== -1,
+      `Block ${blockNumber.toString()} does not lie within any of the reservations.`
+    );
+
+    const reservation = this._blockReservations[reservationIndex];
+
+    const blockNumberBeforeReservation = reservation.first.subn(1);
+
+    const blockBeforeReservation = this.getBlockByNumber(
+      blockNumberBeforeReservation
+    );
+    assertHardhatInvariant(
+      blockBeforeReservation !== undefined,
+      `Reservation after block ${blockNumberBeforeReservation.toString()} cannot be created because that block does not exist`
+    );
+
+    const previousTimestamp = this.isReservedBlock(blockNumberBeforeReservation)
+      ? this._calculateTimestampForReservedBlock(blockNumberBeforeReservation)
+      : blockBeforeReservation.header.timestamp;
+
+    return previousTimestamp.add(
+      reservation.interval.mul(blockNumber.sub(reservation.first).addn(1))
+    );
+  }
 }

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