hardhat 2.8.4 → 2.9.0-dev.0

package/src/internal/core/providers/construction.ts

@@ -11,6 +11,7 @@ import type {
   NetworkConfig,
   ProjectPathsConfig,
 } from "../../../types";
+
 import { HARDHAT_NETWORK_NAME } from "../../constants";
 import { ModulesLogger } from "../../hardhat-network/provider/modules/logger";
 import {
@@ -190,7 +191,8 @@ export function applyProviderWrappers(
         accounts.mnemonic,
         accounts.path,
         accounts.initialIndex,
-        accounts.count
+        accounts.count,
+        accounts.passphrase
       );
     }
 

package/src/internal/core/providers/http.ts

@@ -1,5 +1,5 @@
 import { EventEmitter } from "events";
-import type { Response } from "node-fetch";
+import { Dispatcher, Pool } from "undici";
 
 import { EIP1193Provider, RequestArguments } from "../../../types";
 import {
@@ -13,6 +13,7 @@ import {
   parseJsonResponse,
   SuccessfulJsonRpcResponse,
 } from "../../util/jsonrpc";
+import { getHardhatVersion } from "../../util/packageInfo";
 import { HardhatError } from "../errors";
 import { ERRORS } from "../errors-list";
 
@@ -27,16 +28,40 @@ const MAX_RETRY_AWAIT_SECONDS = 5;
 
 const TOO_MANY_REQUEST_STATUS = 429;
 
+const hardhatVersion = getHardhatVersion();
+
 export class HttpProvider extends EventEmitter implements EIP1193Provider {
   private _nextRequestId = 1;
+  private _dispatcher: Dispatcher;
+  private _path: string;
+  private _authHeader: string | undefined;
 
   constructor(
     private readonly _url: string,
     private readonly _networkName: string,
     private readonly _extraHeaders: { [name: string]: string } = {},
-    private readonly _timeout = 20000
+    private readonly _timeout = 20000,
+    client: Dispatcher | undefined = undefined
   ) {
     super();
+    const url = new URL(this._url);
+    this._path = url.pathname;
+    this._authHeader =
+      url.username === ""
+        ? undefined
+        : `Basic ${Buffer.from(
+            `${url.username}:${url.password}`,
+            "utf-8"
+          ).toString("base64")}`;
+    try {
+      this._dispatcher = client ?? new Pool(url.origin);
+    } catch (e) {
+      if (e instanceof TypeError && e.message === "Invalid URL") {
+        e.message += ` ${url.origin}`;
+      }
+      // eslint-disable-next-line @nomiclabs/hardhat-internal-rules/only-hardhat-error
+      throw e;
+    }
   }
 
   public get url(): string {
@@ -134,28 +159,32 @@ export class HttpProvider extends EventEmitter implements EIP1193Provider {
     request: JsonRpcRequest | JsonRpcRequest[],
     retryNumber = 0
   ): Promise<JsonRpcResponse | JsonRpcResponse[]> {
-    const { default: fetch } = await import("node-fetch");
-
     try {
-      const response = await fetch(this._url, {
+      const response = await this._dispatcher.request({
         method: "POST",
+        path: this._path,
         body: JSON.stringify(request),
-        redirect: "follow",
-        timeout:
+        maxRedirections: 10,
+        headersTimeout:
           process.env.DO_NOT_SET_THIS_ENV_VAR____IS_HARDHAT_CI !== undefined
             ? 0
             : this._timeout,
         headers: {
           "Content-Type": "application/json",
+          "User-Agent": `hardhat ${hardhatVersion}`,
+          Authorization: this._authHeader,
           ...this._extraHeaders,
         },
       });
 
       if (this._isRateLimitResponse(response)) {
-        // Consume the response stream and discard its result
-        // See: https://github.com/node-fetch/node-fetch/issues/83
-        const _discarded = await response.text();
-
+        // "The Fetch Standard allows users to skip consuming the response body
+        // by relying on garbage collection to release connection resources.
+        // Undici does not do the same. Therefore, it is important to always
+        // either consume or cancel the response body."
+        // https://undici.nodejs.org/#/?id=garbage-collection
+        // It's not clear how to "cancel", so we'll just consume:
+        await response.body.text();
         const seconds = this._getRetryAfterSeconds(response);
         if (seconds !== undefined && this._shouldRetry(retryNumber, seconds)) {
           return await this._retry(request, seconds, retryNumber);
@@ -170,7 +199,7 @@ export class HttpProvider extends EventEmitter implements EIP1193Provider {
         );
       }
 
-      return parseJsonResponse(await response.text());
+      return parseJsonResponse(await response.body.text());
     } catch (error: any) {
       if (error.code === "ECONNREFUSED") {
         throw new HardhatError(
@@ -222,12 +251,14 @@ export class HttpProvider extends EventEmitter implements EIP1193Provider {
     return true;
   }
 
-  private _isRateLimitResponse(response: Response) {
-    return response.status === TOO_MANY_REQUEST_STATUS;
+  private _isRateLimitResponse(response: Dispatcher.ResponseData) {
+    return response.statusCode === TOO_MANY_REQUEST_STATUS;
   }
 
-  private _getRetryAfterSeconds(response: Response): number | undefined {
-    const header = response.headers.get("Retry-After");
+  private _getRetryAfterSeconds(
+    response: Dispatcher.ResponseData
+  ): number | undefined {
+    const header = response.headers["retry-after"];
 
     if (header === undefined || header === null) {
       return undefined;

package/src/internal/core/providers/util.ts

@@ -13,7 +13,8 @@ export function derivePrivateKeys(
   mnemonic: string,
   hdpath: string,
   initialIndex: number,
-  count: number
+  count: number,
+  passphrase: string
 ): Buffer[] {
   if (hdpath.match(HD_PATH_REGEX) === null) {
     throw new HardhatError(ERRORS.NETWORK.INVALID_HD_PATH, { path: hdpath });
@@ -28,7 +29,8 @@ export function derivePrivateKeys(
   for (let i = initialIndex; i < initialIndex + count; i++) {
     const privateKey = deriveKeyFromMnemonicAndPath(
       mnemonic,
-      hdpath + i.toString()
+      hdpath + i.toString(),
+      passphrase
     );
 
     if (privateKey === undefined) {
@@ -57,7 +59,8 @@ export function normalizeHardhatNetworkAccountsConfig(
     accountsConfig.mnemonic,
     accountsConfig.path,
     accountsConfig.initialIndex,
-    accountsConfig.count
+    accountsConfig.count,
+    accountsConfig.passphrase
   ).map((pk) => ({
     privateKey: bufferToHex(pk),
     balance: accountsConfig.accountsBalance ?? DEFAULT_HARDHAT_NETWORK_BALANCE,

package/src/internal/hardhat-network/jsonrpc/server.ts

@@ -1,7 +1,8 @@
+import type WsT from "ws";
+
 import debug from "debug";
 import http, { Server } from "http";
 import { AddressInfo } from "net";
-import type WsT from "ws";
 
 import {
   EIP1193Provider,

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

@@ -0,0 +1,137 @@
+import { Block } from "@ethereumjs/block";
+import Common from "@ethereumjs/common";
+import { TypedTransaction } from "@ethereumjs/tx";
+import { BN } from "ethereumjs-util";
+
+import { assertHardhatInvariant } from "../../core/errors";
+import { BlockchainData } from "./BlockchainData";
+import { RpcReceiptOutput } from "./output";
+
+/* eslint-disable @nomiclabs/hardhat-internal-rules/only-hardhat-error */
+
+export abstract class BlockchainBase {
+  protected readonly _data: BlockchainData;
+
+  constructor(protected _common: Common) {
+    this._data = new BlockchainData(_common);
+  }
+
+  public abstract addBlock(block: Block): Promise<Block>;
+
+  public addTransactionReceipts(receipts: RpcReceiptOutput[]) {
+    for (const receipt of receipts) {
+      this._data.addTransactionReceipt(receipt);
+    }
+  }
+
+  public async delBlock(blockHash: Buffer) {
+    this.deleteBlock(blockHash);
+  }
+
+  public deleteBlock(blockHash: Buffer) {
+    const block = this._data.getBlockByHash(blockHash);
+    if (block === undefined) {
+      throw new Error("Block not found");
+    }
+    this._delBlock(block.header.number);
+  }
+
+  public async getBlock(
+    blockHashOrNumber: Buffer | BN | number
+  ): Promise<Block | null> {
+    if (
+      (typeof blockHashOrNumber === "number" || BN.isBN(blockHashOrNumber)) &&
+      this._data.isReservedBlock(new BN(blockHashOrNumber))
+    ) {
+      this._data.fulfillBlockReservation(new BN(blockHashOrNumber));
+    }
+
+    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 abstract getLatestBlockNumber(): BN;
+
+  public async getLatestBlock(): Promise<Block> {
+    const block = await this.getBlock(this.getLatestBlockNumber());
+    if (block === null) {
+      throw new Error("Block not found");
+    }
+    return block;
+  }
+
+  public getLocalTransaction(
+    transactionHash: Buffer
+  ): TypedTransaction | undefined {
+    return this._data.getTransaction(transactionHash);
+  }
+
+  public iterator(
+    _name: string,
+    _onBlock: (block: Block, reorg: boolean) => void | Promise<void>
+  ): Promise<number | void> {
+    throw new Error("Method not implemented.");
+  }
+
+  public async putBlock(block: Block): Promise<void> {
+    await this.addBlock(block);
+  }
+
+  public reserveBlocks(
+    count: BN,
+    interval: BN,
+    previousBlockStateRoot: Buffer,
+    previousBlockTotalDifficulty: BN
+  ) {
+    this._data.reserveBlocks(
+      this.getLatestBlockNumber().addn(1),
+      count,
+      interval,
+      previousBlockStateRoot,
+      previousBlockTotalDifficulty
+    );
+  }
+
+  protected _delBlock(blockNumber: BN): void {
+    let i = blockNumber;
+
+    while (i.lte(this.getLatestBlockNumber())) {
+      if (this._data.isReservedBlock(i)) {
+        const reservation = this._data.cancelReservationWithBlock(i);
+        i = reservation.last.addn(1);
+      } else {
+        const current = this._data.getBlockByNumber(i);
+        if (current !== undefined) {
+          this._data.removeBlock(current);
+        }
+        i = i.addn(1);
+      }
+    }
+  }
+
+  protected async _computeTotalDifficulty(block: Block): Promise<BN> {
+    const difficulty = block.header.difficulty;
+    const blockNumber = block.header.number;
+
+    if (blockNumber.eqn(0)) {
+      return difficulty;
+    }
+
+    const parentBlock = await this.getBlock(blockNumber.subn(1));
+    assertHardhatInvariant(parentBlock !== null, "Parent block should exist");
+
+    const parentHash = parentBlock.hash();
+    const parentTD = this._data.getTotalDifficulty(parentHash);
+    assertHardhatInvariant(
+      parentTD !== undefined,
+      "Parent block should have total difficulty"
+    );
+
+    return parentTD.add(difficulty);
+  }
+}

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