hardhat 2.6.8 → 2.7.0

package/src/internal/core/config/config-validation.ts

@@ -3,6 +3,7 @@ import { Context, getFunctionName, ValidationError } from "io-ts/lib";
 import { Reporter } from "io-ts/lib/Reporter";
 
 import {
+  HARDHAT_MEMPOOL_SUPPORTED_ORDERS,
   HARDHAT_NETWORK_NAME,
   HARDHAT_NETWORK_SUPPORTED_HARDFORKS,
 } from "../../constants";
@@ -53,6 +54,59 @@ function getErrorMessage(path: string, value: any, expectedType: string) {
   )} for ${path} - Expected a value of type ${expectedType}.`;
 }
 
+function getPrivateKeyError(index: number, network: string, message: string) {
+  return `Invalid account: #${index} for network: ${network} - ${message}`;
+}
+
+function validatePrivateKey(
+  privateKey: unknown,
+  index: number,
+  network: string,
+  errors: string[]
+) {
+  if (typeof privateKey !== "string") {
+    errors.push(
+      getPrivateKeyError(
+        index,
+        network,
+        `Expected string, received ${typeof privateKey}`
+      )
+    );
+  } else {
+    // private key validation
+    const pkWithPrefix = /^0x/.test(privateKey)
+      ? privateKey
+      : `0x${privateKey}`;
+
+    // 32 bytes = 64 characters + 2 char prefix = 66
+    if (pkWithPrefix.length < 66) {
+      errors.push(
+        getPrivateKeyError(
+          index,
+          network,
+          "private key too short, expected 32 bytes"
+        )
+      );
+    } else if (pkWithPrefix.length > 66) {
+      errors.push(
+        getPrivateKeyError(
+          index,
+          network,
+          "private key too long, expected 32 bytes"
+        )
+      );
+    } else if (hexString.decode(pkWithPrefix).isLeft()) {
+      errors.push(
+        getPrivateKeyError(
+          index,
+          network,
+          "invalid hex character(s) found in string"
+        )
+      );
+    }
+  }
+}
+
 export function failure(es: ValidationError[]): string[] {
   return es.map(getMessage);
 }
@@ -91,6 +145,27 @@ export const hexString = new t.Type<string>(
   t.identity
 );
 
+function isAddress(v: unknown): v is string {
+  if (typeof v !== "string") {
+    return false;
+  }
+
+  const trimmed = v.trim();
+
+  return (
+    trimmed.match(HEX_STRING_REGEX) !== null &&
+    trimmed.startsWith("0x") &&
+    trimmed.length === 42
+  );
+}
+
+export const address = new t.Type<string>(
+  "address",
+  isAddress,
+  (u, c) => (isAddress(u) ? t.success(u) : t.failure(u, c)),
+  t.identity
+);
+
 export const decimalString = new t.Type<string>(
   "decimal string",
   isDecimalString,
@@ -123,6 +198,22 @@ const HardhatNetworkForkingConfig = t.type({
   blockNumber: optional(t.number),
 });
 
+const HardhatNetworkMempoolConfig = t.type({
+  order: optional(
+    t.keyof(
+      fromEntries(
+        HARDHAT_MEMPOOL_SUPPORTED_ORDERS.map((order) => [order, null])
+      )
+    )
+  ),
+});
+
+const HardhatNetworkMiningConfig = t.type({
+  auto: optional(t.boolean),
+  interval: optional(t.union([t.number, t.tuple([t.number, t.number])])),
+  mempool: optional(HardhatNetworkMempoolConfig),
+});
+
 const commonNetworkConfigFields = {
   chainId: optional(t.number),
   from: optional(t.string),
@@ -149,6 +240,8 @@ const HardhatNetworkConfig = t.type({
   initialDate: optional(t.string),
   loggingEnabled: optional(t.boolean),
   forking: optional(HardhatNetworkForkingConfig),
+  mining: optional(HardhatNetworkMiningConfig),
+  coinbase: optional(address),
 });
 
 const HDAccountsConfig = t.type({
@@ -224,7 +317,7 @@ export function validateConfig(config: any) {
 }
 
 export function getValidationErrors(config: any): string[] {
-  const errors = [];
+  const errors: string[] = [];
 
   // These can't be validated with io-ts
   if (config !== undefined && typeof config.networks === "object") {
@@ -237,8 +330,7 @@ export function getValidationErrors(config: any): string[] {
       }
 
       // Validating the accounts with io-ts leads to very confusing errors messages
-      const configExceptAccounts = { ...hardhatNetwork };
-      delete configExceptAccounts.accounts;
+      const { accounts, ...configExceptAccounts } = hardhatNetwork;
 
       const netConfigResult = HardhatNetworkConfig.decode(configExceptAccounts);
       if (netConfigResult.isLeft()) {
@@ -251,31 +343,37 @@ export function getValidationErrors(config: any): string[] {
         );
       }
 
-      if (Array.isArray(hardhatNetwork.accounts)) {
-        for (const account of hardhatNetwork.accounts) {
-          if (typeof account.privateKey !== "string") {
+      // manual validation of accounts
+      if (Array.isArray(accounts)) {
+        for (const [index, account] of accounts.entries()) {
+          if (typeof account !== "object") {
             errors.push(
-              getErrorMessage(
-                `HardhatConfig.networks.${HARDHAT_NETWORK_NAME}.accounts[].privateKey`,
-                account.privateKey,
-                "string"
+              getPrivateKeyError(
+                index,
+                HARDHAT_NETWORK_NAME,
+                `Expected object, received ${typeof account}`
               )
             );
+            continue;
           }
 
-          if (typeof account.balance !== "string") {
+          const { privateKey, balance } = account;
+
+          validatePrivateKey(privateKey, index, HARDHAT_NETWORK_NAME, errors);
+
+          if (typeof balance !== "string") {
             errors.push(
               getErrorMessage(
                 `HardhatConfig.networks.${HARDHAT_NETWORK_NAME}.accounts[].balance`,
-                account.balance,
+                balance,
                 "string"
               )
             );
-          } else if (decimalString.decode(account.balance).isLeft()) {
+          } else if (decimalString.decode(balance).isLeft()) {
             errors.push(
               getErrorMessage(
                 `HardhatConfig.networks.${HARDHAT_NETWORK_NAME}.accounts[].balance`,
-                account.balance,
+                balance,
                 "decimal(wei)"
               )
             );
@@ -340,7 +438,9 @@ export function getValidationErrors(config: any): string[] {
         }
       }
 
-      const netConfigResult = HttpNetworkConfig.decode(netConfig);
+      const { accounts, ...configExceptAccounts } = netConfig;
+
+      const netConfigResult = HttpNetworkConfig.decode(configExceptAccounts);
       if (netConfigResult.isLeft()) {
         errors.push(
           getErrorMessage(
@@ -350,6 +450,38 @@ export function getValidationErrors(config: any): string[] {
           )
         );
       }
+
+      // manual validation of accounts
+      if (Array.isArray(accounts)) {
+        accounts.forEach((privateKey, index) =>
+          validatePrivateKey(privateKey, index, networkName, errors)
+        );
+      } else if (typeof accounts === "object") {
+        const hdConfigResult = HDAccountsConfig.decode(accounts);
+        if (hdConfigResult.isLeft()) {
+          errors.push(
+            getErrorMessage(
+              `HardhatConfig.networks.${networkName}`,
+              accounts,
+              "HttpNetworkHDAccountsConfig"
+            )
+          );
+        }
+      } else if (typeof accounts === "string") {
+        if (accounts !== "remote") {
+          errors.push(
+            `Invalid 'accounts' entry for network '${networkName}': expected an array of accounts or the string 'remote', but got the string '${accounts}'`
+          );
+        }
+      } else if (accounts !== undefined) {
+        errors.push(
+          getErrorMessage(
+            `HardhatConfig.networks.${networkName}.accounts`,
+            accounts,
+            '"remote" | string[] | HttpNetworkHDAccountsConfig | undefined'
+          )
+        );
+      }
     }
   }
 

package/src/internal/core/config/default-config.ts

@@ -42,7 +42,13 @@ export const defaultHardhatNetworkParams: Omit<
   throwOnTransactionFailures: true,
   throwOnCallFailures: true,
   allowUnlimitedContractSize: false,
-  mining: { auto: true, interval: 0 },
+  mining: {
+    auto: true,
+    interval: 0,
+    mempool: {
+      order: "priority",
+    },
+  },
   accounts: defaultHardhatNetworkHdAccountsConfigParams,
   loggingEnabled: false,
   gasMultiplier: DEFAULT_GAS_MULTIPLIER,

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

@@ -571,7 +571,7 @@ Please double check how you invoked Hardhat or ran your task.`,
     },
     MISSING_TASK_ARGUMENT: {
       number: 306,
-      message: "Missing task argument %param%",
+      message: "The '%param%' parameter expects a value, but none was passed.",
       title: "Missing task argument",
       description: `You tried to run a task, but one of its required arguments was missing. 
 
@@ -884,7 +884,7 @@ Please use a newer, supported version.`,
   ARTIFACTS: {
     NOT_FOUND: {
       number: 700,
-      message: 'Artifact for contract "%contractName%" not found.',
+      message: 'Artifact for contract "%contractName%" not found. %suggestion%',
       title: "Artifact not found",
       description: `Tried to import a nonexistent artifact.
 

package/src/internal/core/jsonrpc/types/output/log.ts

@@ -6,6 +6,7 @@ import { rpcAddress, rpcData, rpcHash, rpcQuantity } from "../base-types";
 export type RpcLog = t.TypeOf<typeof rpcLog>;
 export const rpcLog = t.type(
   {
+    logIndex: nullable(rpcQuantity),
     transactionIndex: nullable(rpcQuantity),
     transactionHash: nullable(rpcHash),
     blockHash: nullable(rpcHash),

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/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,8 @@ 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,
       new ModulesLogger(hardhatNetConfig.loggingEnabled),
       accounts,
       artifacts,
@@ -97,7 +102,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/typescript-support.ts

@@ -38,7 +38,7 @@ export function isTypescriptSupported() {
   return cachedIsTypescriptSupported;
 }
 
-export function loadTsNode() {
+export function loadTsNode(tsConfigPath?: string) {
   try {
     require.resolve("typescript");
   } catch (error) {
@@ -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/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/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);
   }

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`);
@@ -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/node-types.ts

@@ -3,6 +3,7 @@ import { RunBlockResult } from "@ethereumjs/vm/dist/runBlock";
 import { BN } from "ethereumjs-util";
 
 import { BuildInfo } from "../../../types";
+import { HARDHAT_MEMPOOL_SUPPORTED_ORDERS } from "../../constants";
 import { MessageTrace } from "../stack-traces/message-trace";
 
 import type { ReturnData } from "./return-data";
@@ -28,6 +29,8 @@ interface CommonConfig {
   initialDate?: Date;
   tracingConfig?: TracingConfig;
   initialBaseFeePerGas?: number;
+  mempoolOrder: MempoolOrder;
+  coinbase: string;
 }
 
 export type LocalNodeConfig = CommonConfig;
@@ -48,6 +51,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 +126,7 @@ export interface Snapshot {
   nextBlockTimestamp: BN;
   irregularStatesByBlockNumber: Map<string, Buffer>;
   userProvidedNextBlockBaseFeePerGas: BN | undefined;
+  coinbase: string;
 }
 
 export type SendTransactionResult =

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

@@ -82,6 +82,7 @@ import {
   GatherTracesResult,
   GenesisAccount,
   isForkedNodeConfig,
+  MempoolOrder,
   MineBlockResult,
   NodeConfig,
   RunCallResult,
@@ -115,10 +116,6 @@ const log = debug("hardhat:core:hardhat-network:node");
 
 const ethSigUtil = require("eth-sig-util");
 
-export const COINBASE_ADDRESS = Address.fromString(
-  "0xc014ba5ec014ba5ec014ba5ec014ba5ec014ba5e"
-);
-
 /* eslint-disable @nomiclabs/hardhat-internal-rules/only-hardhat-error */
 
 export class HardhatNode extends EventEmitter {
@@ -132,6 +129,7 @@ export class HardhatNode extends EventEmitter {
       allowUnlimitedContractSize,
       tracingConfig,
       minGasPrice,
+      mempoolOrder,
     } = config;
 
     let common: Common;
@@ -242,6 +240,8 @@ export class HardhatNode extends EventEmitter {
       automine,
       minGasPrice,
       initialBlockTimeOffset,
+      mempoolOrder,
+      config.coinbase,
       genesisAccounts,
       tracingConfig,
       forkNetworkId,
@@ -315,6 +315,8 @@ Hardhat Network's forking functionality only works with blocks from at least spu
     private _automine: boolean,
     private _minGasPrice: BN,
     private _blockTimeOffsetSeconds: BN = new BN(0),
+    private _mempoolOrder: MempoolOrder,
+    private _coinbase: string,
     genesisAccounts: GenesisAccount[],
     tracingConfig?: TracingConfig,
     private _forkNetworkId?: number,
@@ -697,7 +699,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
   }
 
   public getCoinbaseAddress(): Address {
-    return COINBASE_ADDRESS;
+    return Address.fromString(this._coinbase);
   }
 
   public async getStorageAt(
@@ -870,6 +872,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
       irregularStatesByBlockNumber: this._irregularStatesByBlockNumber,
       userProvidedNextBlockBaseFeePerGas:
         this.getUserProvidedNextBlockBaseFeePerGas(),
+      coinbase: this.getCoinbaseAddress().toString(),
     };
 
     this._irregularStatesByBlockNumber = new Map(
@@ -924,6 +927,8 @@ Hardhat Network's forking functionality only works with blocks from at least spu
       this._resetUserProvidedNextBlockBaseFeePerGas();
     }
 
+    this._coinbase = snapshot.coinbase;
+
     // We delete this and the following snapshots, as they can only be used
     // once in Ganache
     this._snapshots.splice(snapshotIndex);
@@ -1349,6 +1354,10 @@ Hardhat Network's forking functionality only works with blocks from at least spu
     };
   }
 
+  public async setCoinbase(coinbase: Address) {
+    this._coinbase = coinbase.toString();
+  }
+
   private _getGasUsedRatio(block: Block): number {
     const FLOATS_PRECISION = 100_000;
 
@@ -1579,6 +1588,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
       const pendingTxs = this._txPool.getPendingTransactions();
       const transactionQueue = new TransactionQueue(
         pendingTxs,
+        this._mempoolOrder,
         headerData.baseFeePerGas
       );
 

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

@@ -292,18 +292,18 @@ export function getRpcReceiptOutputsFromLocalBlockExecution(
 ): RpcReceiptOutput[] {
   const receipts: RpcReceiptOutput[] = [];
 
-  let cumulativeGasUsed = new BN(0);
+  let blockLogIndex = 0;
 
   for (let i = 0; i < runBlockResult.results.length; i += 1) {
     const tx = block.transactions[i];
     const { createdAddress, gasUsed } = runBlockResult.results[i];
     const receipt = runBlockResult.receipts[i];
 
-    cumulativeGasUsed = cumulativeGasUsed.add(new BN(receipt.gasUsed));
-
-    const logs = receipt.logs.map((log, logIndex) =>
-      getRpcLogOutput(log, tx, block, i, logIndex)
-    );
+    const logs = receipt.logs.map((log) => {
+      const result = getRpcLogOutput(log, tx, block, i, blockLogIndex);
+      blockLogIndex += 1;
+      return result;
+    });
 
     const rpcReceipt: RpcReceiptOutput = {
       transactionHash: bufferToRpcData(tx.hash()),
@@ -312,7 +312,7 @@ export function getRpcReceiptOutputsFromLocalBlockExecution(
       blockNumber: numberToRpcQuantity(new BN(block.header.number)),
       from: bufferToRpcData(tx.getSenderAddress().toBuffer()),
       to: tx.to === undefined ? null : bufferToRpcData(tx.to.toBuffer()),
-      cumulativeGasUsed: numberToRpcQuantity(cumulativeGasUsed),
+      cumulativeGasUsed: numberToRpcQuantity(new BN(receipt.gasUsed)),
       gasUsed: numberToRpcQuantity(gasUsed),
       contractAddress:
         createdAddress !== undefined
@@ -395,7 +395,7 @@ export function remoteReceiptToRpcReceiptOutput(
   };
 }
 
-export function toRpcLogOutput(log: RpcLog, index?: number): RpcLogOutput {
+export function toRpcLogOutput(log: RpcLog): RpcLogOutput {
   return {
     removed: false,
     address: bufferToRpcData(log.address),
@@ -403,7 +403,7 @@ export function toRpcLogOutput(log: RpcLog, index?: number): RpcLogOutput {
     blockNumber:
       log.blockNumber !== null ? numberToRpcQuantity(log.blockNumber) : null,
     data: bufferToRpcData(log.data),
-    logIndex: index !== undefined ? numberToRpcQuantity(index) : null,
+    logIndex: log.logIndex !== null ? numberToRpcQuantity(log.logIndex) : null,
     transactionIndex:
       log.transactionIndex !== null
         ? numberToRpcQuantity(log.transactionIndex)

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

@@ -40,6 +40,7 @@ import {
   ForkConfig,
   GenesisAccount,
   IntervalMiningConfig,
+  MempoolOrder,
   NodeConfig,
   TracingConfig,
 } from "./node-types";
@@ -54,6 +55,8 @@ const PRIVATE_RPC_METHODS = new Set([
 
 /* eslint-disable @nomiclabs/hardhat-internal-rules/only-hardhat-error */
 
+export const DEFAULT_COINBASE = "0xc014ba5ec014ba5ec014ba5ec014ba5ec014ba5e";
+
 export class HardhatNetworkProvider
   extends EventEmitter
   implements EIP1193Provider
@@ -81,6 +84,7 @@ export class HardhatNetworkProvider
     private readonly _throwOnCallFailures: boolean,
     private readonly _automine: boolean,
     private readonly _intervalMining: IntervalMiningConfig,
+    private readonly _mempoolOrder: MempoolOrder,
     private readonly _logger: ModulesLogger,
     private readonly _genesisAccounts: GenesisAccount[] = [],
     private readonly _artifacts?: Artifacts,
@@ -88,7 +92,8 @@ export class HardhatNetworkProvider
     private readonly _initialDate?: Date,
     private readonly _experimentalHardhatNetworkMessageTraceHooks: BoundExperimentalHardhatNetworkMessageTraceHook[] = [],
     private _forkConfig?: ForkConfig,
-    private readonly _forkCachePath?: string
+    private readonly _forkCachePath?: string,
+    private readonly _coinbase = DEFAULT_COINBASE
   ) {
     super();
   }
@@ -227,6 +232,7 @@ export class HardhatNetworkProvider
       allowUnlimitedContractSize: this._allowUnlimitedContractSize,
       tracingConfig: await this._makeTracingConfig(),
       initialBaseFeePerGas: this._initialBaseFeePerGas,
+      mempoolOrder: this._mempoolOrder,
       hardfork: this._hardfork,
       networkName: this._networkName,
       chainId: this._chainId,
@@ -235,6 +241,7 @@ export class HardhatNetworkProvider
       forkConfig: this._forkConfig,
       forkCachePath:
         this._forkConfig !== undefined ? this._forkCachePath : undefined,
+      coinbase: this._coinbase,
     };
 
     const [common, node] = await HardhatNode.create(config);

package/src/register.ts

@@ -36,7 +36,7 @@ if (!HardhatContext.isCreated()) {
   }
 
   if (willRunWithTypescript(hardhatArguments.config)) {
-    loadTsNode();
+    loadTsNode(hardhatArguments.tsconfig);
   }
 
   const config = loadConfigAndTasks(hardhatArguments);