hardhat 2.8.4 → 2.9.0

package/src/internal/core/errors-list.ts

@@ -216,6 +216,19 @@ If you were trying to create a new project, please try again using Windows Subsy
 You can learn how to use Hardhat by reading the [Getting Started guide](../getting-started).`,
       shouldBeReported: false,
     },
+    CONFLICTING_FILES: {
+      number: 16,
+      message: `The directory %dest% contains files that could conflict:
+
+%conflicts%
+
+Either try using a new directory, or remove the files listed above.`,
+      title: "conflicting files during project creation",
+      description: `You are trying to create a new hardhat project, but there are existing files that would be overwritten by the creation process.
+
+Either try using a new directory name, or remove the conflicting files.`,
+      shouldBeReported: false,
+    },
   },
   NETWORK: {
     CONFIG_NOT_FOUND: {

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

@@ -307,13 +307,15 @@ export class HDWalletProvider extends LocalAccountsProvider {
     mnemonic: string,
     hdpath: string = "m/44'/60'/0'/0/",
     initialIndex: number = 0,
-    count: number = 10
+    count: number = 10,
+    passphrase: string = ""
   ) {
     const privateKeys = derivePrivateKeys(
       mnemonic,
       hdpath,
       initialIndex,
-      count
+      count,
+      passphrase
     );
 
     const { bufferToHex } = require("ethereumjs-util");

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,9 @@
+import type WsT from "ws";
+
 import debug from "debug";
 import http, { Server } from "http";
 import { AddressInfo } from "net";
-import type WsT from "ws";
+import { Client } from "undici";
 
 import {
   EIP1193Provider,
@@ -42,9 +44,20 @@ export class JsonRpcServer implements IJsonRpcServer {
   }
 
   public getProvider = (name = "json-rpc"): EIP1193Provider => {
-    const { address, port } = this._httpServer.address() as AddressInfo; // TCP sockets return AddressInfo
+    const { address, port } = this._httpServer.address() as AddressInfo;
+
+    const dispatcher = new Client(`http://${address}:${port}/`, {
+      keepAliveTimeout: 10,
+      keepAliveMaxTimeout: 10,
+    });
 
-    return new HttpProvider(`http://${address}:${port}/`, name);
+    return new HttpProvider(
+      `http://${address}:${port}/`,
+      name,
+      {},
+      20000,
+      dispatcher
+    );
   };
 
   public listen = (): Promise<{ address: string; port: number }> => {

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