hardhat 2.6.8 → 2.8.0

package/src/internal/core/params/env-variables.ts

@@ -48,14 +48,19 @@ export function getEnvHardhatArguments(
       try {
         envArgs[paramName] = definition.type.parse(paramName, rawValue);
       } catch (error) {
-        throw new HardhatError(
-          ERRORS.ARGUMENTS.INVALID_ENV_VAR_VALUE,
-          {
-            varName: envVarName,
-            value: rawValue,
-          },
-          error
-        );
+        if (error instanceof Error) {
+          throw new HardhatError(
+            ERRORS.ARGUMENTS.INVALID_ENV_VAR_VALUE,
+            {
+              varName: envVarName,
+              value: rawValue,
+            },
+            error
+          );
+        }
+
+        // eslint-disable-next-line @nomiclabs/hardhat-internal-rules/only-hardhat-error
+        throw error;
       }
     } else {
       envArgs[paramName] = definition.defaultValue;

package/src/internal/core/params/hardhat-params.ts

@@ -78,8 +78,8 @@ export const HARDHAT_PARAM_DEFINITIONS: HardhatParamDefinitions = {
   tsconfig: {
     name: "tsconfig",
     defaultValue: undefined,
-    description: "Reserved hardhat argument -- Has no effect.",
-    type: types.string,
+    description: "A TypeScript config file.",
+    type: types.inputFile,
     isOptional: true,
     isFlag: false,
     isVariadic: false,

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

@@ -104,7 +104,7 @@ export class LocalAccountsProvider extends ProviderWrapperWithChainId {
       if (typeof data === "string") {
         try {
           typedMessage = JSON.parse(data);
-        } catch (error) {
+        } catch {
           throw new HardhatError(
             ERRORS.NETWORK.ETHSIGN_TYPED_DATA_V4_INVALID_DATA_PARAM
           );
@@ -219,7 +219,7 @@ export class LocalAccountsProvider extends ProviderWrapperWithChainId {
   private _getPrivateKeyForAddressOrNull(address: Buffer): Buffer | null {
     try {
       return this._getPrivateKeyForAddress(address);
-    } catch (e) {
+    } catch {
       return null;
     }
   }
@@ -253,6 +253,7 @@ export class LocalAccountsProvider extends ProviderWrapperWithChainId {
       gasLimit: transactionRequest.gas,
     };
 
+    // TODO: consider changing instances of "london" below to ["latest hardfork"]
     const common =
       chains.names[chainId] !== undefined
         ? new Common({ chain: chainId, hardfork: "london" })
@@ -347,7 +348,7 @@ abstract class SenderProvider extends ProviderWrapper {
     return this._wrappedProvider.request(args);
   }
 
-  protected abstract async _getSender(): Promise<string | undefined>;
+  protected abstract _getSender(): Promise<string | undefined>;
 }
 
 export class AutomaticSenderProvider extends SenderProvider {

package/src/internal/core/providers/backwards-compatibility.ts

@@ -56,7 +56,7 @@ export class BackwardsCompatibilityProviderAdapter
         method: request.method,
         params: request.params,
       });
-    } catch (error) {
+    } catch (error: any) {
       if (error.code === undefined) {
         // eslint-disable-next-line @nomiclabs/hardhat-internal-rules/only-hardhat-error
         throw error;

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

@@ -12,7 +12,7 @@ export abstract class ProviderWrapperWithChainId extends ProviderWrapper {
     if (this._chainId === undefined) {
       try {
         this._chainId = await this._getChainIdFromEthChainId();
-      } catch (error) {
+      } catch {
         // If eth_chainId fails we default to net_version
         this._chainId = await this._getChainIdFromEthNetVersion();
       }

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

@@ -13,7 +13,10 @@ import type {
 } from "../../../types";
 import { HARDHAT_NETWORK_NAME } from "../../constants";
 import { ModulesLogger } from "../../hardhat-network/provider/modules/logger";
-import { ForkConfig } from "../../hardhat-network/provider/node-types";
+import {
+  ForkConfig,
+  MempoolOrder,
+} from "../../hardhat-network/provider/node-types";
 import { getForkCacheDirPath } from "../../hardhat-network/provider/utils/disk-cache";
 import { parseDateString } from "../../util/date";
 
@@ -88,6 +91,9 @@ export function createProvider(
       hardhatNetConfig.throwOnCallFailures,
       hardhatNetConfig.mining.auto,
       hardhatNetConfig.mining.interval,
+      // This cast is valid because of the config validation and resolution
+      hardhatNetConfig.mining.mempool.order as MempoolOrder,
+      hardhatNetConfig.chains,
       new ModulesLogger(hardhatNetConfig.loggingEnabled),
       accounts,
       artifacts,
@@ -97,7 +103,8 @@ export function createProvider(
         : undefined,
       experimentalHardhatNetworkMessageTraceHooks,
       forkConfig,
-      paths !== undefined ? getForkCacheDirPath(paths) : undefined
+      paths !== undefined ? getForkCacheDirPath(paths) : undefined,
+      hardhatNetConfig.coinbase
     );
   } else {
     const HttpProvider = importProvider<

package/src/internal/core/providers/gas-providers.ts

@@ -86,9 +86,11 @@ abstract class MultipliedGasEstimationProvider extends ProviderWrapper {
 
       return numberToRpcQuantity(gas);
     } catch (error) {
-      if (error.message.toLowerCase().includes("execution error")) {
-        const blockGasLimit = await this._getBlockGasLimit();
-        return numberToRpcQuantity(blockGasLimit);
+      if (error instanceof Error) {
+        if (error.message.toLowerCase().includes("execution error")) {
+          const blockGasLimit = await this._getBlockGasLimit();
+          return numberToRpcQuantity(blockGasLimit);
+        }
       }
 
       // eslint-disable-next-line @nomiclabs/hardhat-internal-rules/only-hardhat-error
@@ -277,7 +279,7 @@ export class AutomaticGasPriceProvider extends ProviderWrapper {
 
         maxPriorityFeePerGas: rpcQuantityToBN(response.reward[0][0]),
       };
-    } catch (_error) {
+    } catch {
       this._nodeHasFeeHistory = false;
 
       return undefined;

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

@@ -171,7 +171,7 @@ export class HttpProvider extends EventEmitter implements EIP1193Provider {
       }
 
       return parseJsonResponse(await response.text());
-    } catch (error) {
+    } catch (error: any) {
       if (error.code === "ECONNREFUSED") {
         throw new HardhatError(
           ERRORS.NETWORK.NODE_IS_NOT_RUNNING,

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

@@ -11,7 +11,7 @@ export abstract class ProviderWrapper
     super(_wrappedProvider);
   }
 
-  public abstract async request(args: RequestArguments): Promise<unknown>;
+  public abstract request(args: RequestArguments): Promise<unknown>;
 
   protected _getParams<ParamsT extends any[] = any[]>(
     args: RequestArguments

package/src/internal/core/runtime-environment.ts

@@ -266,7 +266,9 @@ export class Environment implements HardhatRuntimeEnvironment {
             values[paramName] = resolvedArgumentValue;
           }
         } catch (error) {
-          errors.push(error);
+          if (HardhatError.isHardhatError(error)) {
+            errors.push(error);
+          }
         }
         return { errors, values };
       },

package/src/internal/core/typescript-support.ts

@@ -38,16 +38,16 @@ export function isTypescriptSupported() {
   return cachedIsTypescriptSupported;
 }
 
-export function loadTsNode() {
+export function loadTsNode(tsConfigPath?: string) {
   try {
     require.resolve("typescript");
-  } catch (error) {
+  } catch {
     throw new HardhatError(ERRORS.GENERAL.TYPESCRIPT_NOT_INSTALLED);
   }
 
   try {
     require.resolve("ts-node");
-  } catch (error) {
+  } catch {
     throw new HardhatError(ERRORS.GENERAL.TS_NODE_NOT_INSTALLED);
   }
 
@@ -58,6 +58,10 @@ export function loadTsNode() {
     return;
   }
 
+  if (tsConfigPath !== undefined) {
+    process.env.TS_NODE_PROJECT = tsConfigPath;
+  }
+
   // See: https://github.com/nomiclabs/hardhat/issues/265
   if (process.env.TS_NODE_FILES === undefined) {
     process.env.TS_NODE_FILES = "true";

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

@@ -317,7 +317,7 @@ export class JsonRpcClient {
   ): Promise<any> {
     try {
       return await this._httpProvider.request({ method, params });
-    } catch (err) {
+    } catch (err: any) {
       if (this._shouldRetry(isRetryCall, err)) {
         return this._send(method, params, true);
       }
@@ -429,7 +429,7 @@ export class JsonRpcClient {
           encoding: "utf8",
         }
       );
-    } catch (error) {
+    } catch (error: any) {
       if (error.code === "ENOENT") {
         return undefined;
       }

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

@@ -207,7 +207,12 @@ const _readJsonHttpRequest = async (req: IncomingMessage): Promise<any> => {
 
     json = JSON.parse(text);
   } catch (error) {
-    throw new InvalidJsonInputError(`Parse error: ${error.message}`);
+    if (error instanceof Error) {
+      throw new InvalidJsonInputError(`Parse error: ${error.message}`);
+    }
+
+    // eslint-disable-next-line @nomiclabs/hardhat-internal-rules/only-hardhat-error
+    throw error;
   }
 
   return json;
@@ -218,7 +223,12 @@ const _readWsRequest = (msg: string): JsonRpcRequest => {
   try {
     json = JSON.parse(msg);
   } catch (error) {
-    throw new InvalidJsonInputError(`Parse error: ${error.message}`);
+    if (error instanceof Error) {
+      throw new InvalidJsonInputError(`Parse error: ${error.message}`);
+    }
+
+    // eslint-disable-next-line @nomiclabs/hardhat-internal-rules/only-hardhat-error
+    throw error;
   }
 
   return json;

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

@@ -72,7 +72,7 @@ export class JsonRpcServer implements IJsonRpcServer {
 
   public close = async () => {
     await Promise.all([
-      new Promise((resolve, reject) => {
+      new Promise<void>((resolve, reject) => {
         log("Closing JSON-RPC server");
         this._httpServer.close((err) => {
           if (err !== null && err !== undefined) {
@@ -85,7 +85,7 @@ export class JsonRpcServer implements IJsonRpcServer {
           resolve();
         });
       }),
-      new Promise((resolve, reject) => {
+      new Promise<void>((resolve, reject) => {
         log("Closing websocket server");
         this._wsServer.close((err) => {
           if (err !== null && err !== undefined) {

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

@@ -2,7 +2,8 @@ import { TypedTransaction } from "@ethereumjs/tx";
 import { BN } from "ethereumjs-util";
 import Heap from "mnemonist/heap";
 
-import { InternalError } from "../../core/providers/errors";
+import { InternalError, InvalidInputError } from "../../core/providers/errors";
+import { MempoolOrder } from "./node-types";
 import { OrderedTransaction } from "./PoolState";
 
 function getEffectiveMinerFee(tx: OrderedTransaction, baseFee?: BN): BN {
@@ -38,6 +39,33 @@ function decreasingOrderEffectiveMinerFeeComparator(
   // in increasing order by orderId.
   return left.orderId - right.orderId;
 }
+
+function decreasingOrderComparator(
+  left: OrderedTransaction,
+  right: OrderedTransaction
+) {
+  return left.orderId - right.orderId;
+}
+
+function getOrderedTransactionHeap(
+  mempoolOrder: MempoolOrder,
+  baseFee?: BN
+): Heap<OrderedTransaction> {
+  switch (mempoolOrder) {
+    case "priority":
+      return new Heap<OrderedTransaction>((a, b) =>
+        decreasingOrderEffectiveMinerFeeComparator(a, b, baseFee)
+      );
+    case "fifo":
+      return new Heap<OrderedTransaction>((a, b) =>
+        decreasingOrderComparator(a, b)
+      );
+    default:
+      // eslint-disable-next-line @nomiclabs/hardhat-internal-rules/only-hardhat-error
+      throw new InvalidInputError(`Invalid mempool order: ${mempoolOrder}`);
+  }
+}
+
 /**
  * A queue of transactions in the order that they could be mined in the next
  * block.
@@ -67,11 +95,10 @@ export class TransactionQueue {
    */
   constructor(
     pendingTransactions: Map<string, OrderedTransaction[]>,
+    mempoolOrder: MempoolOrder,
     baseFee?: BN
   ) {
-    this._heap = new Heap<OrderedTransaction>((a, b) =>
-      decreasingOrderEffectiveMinerFeeComparator(a, b, baseFee)
-    );
+    this._heap = getOrderedTransactionHeap(mempoolOrder, baseFee);
 
     for (const [address, txList] of pendingTransactions) {
       if (baseFee === undefined && txList.some((tx) => tx.data.type === 2)) {

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

@@ -332,7 +332,7 @@ export class TxPool {
   private _getSenderAddress(tx: TypedTransaction): Address {
     try {
       return tx.getSenderAddress(); // verifies signature
-    } catch (e) {
+    } catch (e: any) {
       if (!tx.isSigned()) {
         throw new InvalidInputError("Invalid Signature");
       }

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

@@ -215,9 +215,7 @@ export class ForkBlockchain implements HardhatBlockchainInterface {
             : filterParams.addresses,
         topics: filterParams.normalizedTopics,
       });
-      return remoteLogs
-        .map((log, index) => toRpcLogOutput(log, index))
-        .concat(localLogs);
+      return remoteLogs.map(toRpcLogOutput).concat(localLogs);
     }
     return this._data.getLogs(filterParams);
   }
@@ -274,7 +272,7 @@ export class ForkBlockchain implements HardhatBlockchainInterface {
     // one for London.
     const common = this._common.copy();
     if (rpcBlock.baseFeePerGas !== undefined) {
-      common.setHardfork("london");
+      common.setHardfork("london"); // TODO: consider changing this to "latest hardfork"
     } else {
       common.setHardfork("berlin");
     }

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

@@ -959,29 +959,31 @@ export class EthModule {
       // AccessListEIP2930Transaction.fromSerializedTx and Transaction.fromSerializedTx
       // Please keep it updated.
 
-      if (error.message === "invalid remainder") {
-        throw new InvalidArgumentsError("Invalid transaction", error);
-      }
+      if (error instanceof Error) {
+        if (error.message === "invalid remainder") {
+          throw new InvalidArgumentsError("Invalid transaction", error);
+        }
 
-      if (error.message.includes("Incompatible EIP155")) {
-        throw new InvalidArgumentsError(
-          "Trying to send an incompatible EIP-155 transaction, signed for another chain.",
-          error
-        );
-      }
+        if (error.message.includes("Incompatible EIP155")) {
+          throw new InvalidArgumentsError(
+            "Trying to send an incompatible EIP-155 transaction, signed for another chain.",
+            error
+          );
+        }
 
-      if (
-        error.message.includes("TypedTransaction with ID") &&
-        error.message.includes(" unknown")
-      ) {
-        throw new InvalidArgumentsError(`Invalid transaction`, error);
-      }
+        if (
+          error.message.includes("TypedTransaction with ID") &&
+          error.message.includes(" unknown")
+        ) {
+          throw new InvalidArgumentsError(`Invalid transaction`, error);
+        }
 
-      if (error.message.includes("The chain ID does not match")) {
-        throw new InvalidArgumentsError(
-          `Trying to send a raw transaction with an invalid chainId. The expected chainId is ${this._common.chainIdBN()}`,
-          error
-        );
+        if (error.message.includes("The chain ID does not match")) {
+          throw new InvalidArgumentsError(
+            `Trying to send a raw transaction with an invalid chainId. The expected chainId is ${this._common.chainIdBN()}`,
+            error
+          );
+        }
       }
 
       throw error;
@@ -1065,7 +1067,7 @@ export class EthModule {
     if (typeof typedData === "string") {
       try {
         typedMessage = JSON.parse(typedData);
-      } catch (error) {
+      } catch {
         throw new InvalidInputError(
           `The message parameter is an invalid JSON. Either pass a valid JSON or a plain object conforming to EIP712 TypedData schema.`
         );

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

@@ -108,6 +108,9 @@ export class HardhatModule {
         return this._setNextBlockBaseFeePerGasAction(
           ...this._setNextBlockBaseFeePerGasParams(params)
         );
+
+      case "hardhat_setCoinbase":
+        return this._setCoinbaseAction(...this._setCoinbaseParams(params));
     }
 
     throw new MethodNotFoundError(`Method ${method} not found`);
@@ -242,7 +245,7 @@ export class HardhatModule {
 
     if (this._node.isEip1559Active()) {
       throw new InvalidInputError(
-        "hardhat_setMinGasPrice is not support when EIP-1559 is active"
+        "hardhat_setMinGasPrice is not supported when EIP-1559 is active"
       );
     }
 
@@ -346,6 +349,17 @@ export class HardhatModule {
     return true;
   }
 
+  // hardhat_setCoinbase
+
+  private _setCoinbaseParams(params: any[]): [Buffer] {
+    return validateParams(params, rpcAddress);
+  }
+
+  private async _setCoinbaseAction(address: Buffer) {
+    await this._node.setCoinbase(new Address(address));
+    return true;
+  }
+
   private async _logBlock(result: MineBlockResult) {
     const { block, traces } = result;
 

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

@@ -35,15 +35,19 @@ function printLine(line: string) {
 }
 
 function replaceLastLine(newLine: string) {
-  process.stdout.write(
-    // eslint-disable-next-line prefer-template
-    ansiEscapes.cursorHide +
-      ansiEscapes.cursorPrevLine +
-      newLine +
-      ansiEscapes.eraseEndLine +
-      "\n" +
-      ansiEscapes.cursorShow
-  );
+  if (process.stdout.isTTY === true) {
+    process.stdout.write(
+      // eslint-disable-next-line prefer-template
+      ansiEscapes.cursorHide +
+        ansiEscapes.cursorPrevLine +
+        newLine +
+        ansiEscapes.eraseEndLine +
+        "\n" +
+        ansiEscapes.cursorShow
+    );
+  } else {
+    process.stdout.write(`${newLine}\n`);
+  }
 }
 
 /**

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

@@ -2,7 +2,8 @@ import { Block } from "@ethereumjs/block";
 import { RunBlockResult } from "@ethereumjs/vm/dist/runBlock";
 import { BN } from "ethereumjs-util";
 
-import { BuildInfo } from "../../../types";
+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";
@@ -28,6 +29,9 @@ interface CommonConfig {
   initialDate?: Date;
   tracingConfig?: TracingConfig;
   initialBaseFeePerGas?: number;
+  mempoolOrder: MempoolOrder;
+  coinbase: string;
+  chains: HardhatNetworkChainsConfig;
 }
 
 export type LocalNodeConfig = CommonConfig;
@@ -48,6 +52,8 @@ export interface TracingConfig {
 
 export type IntervalMiningConfig = number | [number, number];
 
+export type MempoolOrder = typeof HARDHAT_MEMPOOL_SUPPORTED_ORDERS[number];
+
 export interface GenesisAccount {
   privateKey: string;
   balance: string | number | BN;
@@ -121,6 +127,7 @@ export interface Snapshot {
   nextBlockTimestamp: BN;
   irregularStatesByBlockNumber: Map<string, Buffer>;
   userProvidedNextBlockBaseFeePerGas: BN | undefined;
+  coinbase: string;
 }
 
 export type SendTransactionResult =