hardhat 2.7.0 → 2.8.1

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

@@ -41,13 +41,13 @@ export function isTypescriptSupported() {
 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);
   }
 

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

@@ -20,7 +20,7 @@ import {
 
 /* eslint-disable @nomiclabs/hardhat-internal-rules/only-hardhat-error */
 
-export default class JsonRpcHandler {
+export class JsonRpcHandler {
   constructor(private readonly _provider: EIP1193Provider) {}
 
   public handleHttp = async (req: IncomingMessage, res: ServerResponse) => {
@@ -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

@@ -9,7 +9,7 @@ import {
 } from "../../../types";
 import { HttpProvider } from "../../core/providers/http";
 
-import JsonRpcHandler from "./handler";
+import { JsonRpcHandler } from "./handler";
 
 const log = debug("hardhat:core:hardhat-network:jsonrpc");
 
@@ -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/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

@@ -272,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

@@ -245,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"
       );
     }
 

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,8 +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";
@@ -31,6 +31,7 @@ interface CommonConfig {
   initialBaseFeePerGas?: number;
   mempoolOrder: MempoolOrder;
   coinbase: string;
+  chains: HardhatNetworkChainsConfig;
 }
 
 export type LocalNodeConfig = CommonConfig;

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

@@ -11,7 +11,7 @@ import Bloom from "@ethereumjs/vm/dist/bloom";
 import { EVMResult, ExecResult } from "@ethereumjs/vm/dist/evm/evm";
 import { ERROR } from "@ethereumjs/vm/dist/exceptions";
 import { RunBlockResult } from "@ethereumjs/vm/dist/runBlock";
-import { StateManager } from "@ethereumjs/vm/dist/state";
+import { DefaultStateManager, StateManager } from "@ethereumjs/vm/dist/state";
 import chalk from "chalk";
 import debug from "debug";
 import {
@@ -27,6 +27,8 @@ import {
 import EventEmitter from "events";
 
 import { CompilerInput, CompilerOutput } from "../../../types";
+import { HardforkHistoryConfig } from "../../../types/config";
+import { HARDHAT_NETWORK_SUPPORTED_HARDFORKS } from "../../constants";
 import {
   HARDHAT_NETWORK_DEFAULT_INITIAL_BASE_FEE_PER_GAS,
   HARDHAT_NETWORK_DEFAULT_MAX_PRIORITY_FEE_PER_GAS,
@@ -73,7 +75,6 @@ import { bloomFilter, Filter, filterLogs, LATEST_BLOCK, Type } from "./filter";
 import { ForkBlockchain } from "./fork/ForkBlockchain";
 import { ForkStateManager } from "./fork/ForkStateManager";
 import { HardhatBlockchain } from "./HardhatBlockchain";
-import { HardhatStateManager } from "./HardhatStateManager";
 import {
   CallParams,
   EstimateGasResult,
@@ -108,6 +109,7 @@ import { HardhatBlockchainInterface } from "./types/HardhatBlockchainInterface";
 import { getCurrentTimestamp } from "./utils/getCurrentTimestamp";
 import { makeCommon } from "./utils/makeCommon";
 import { makeForkClient } from "./utils/makeForkClient";
+import { makeStateTrie } from "./utils/makeStateTrie";
 import { makeForkCommon } from "./utils/makeForkCommon";
 import { putGenesisBlock } from "./utils/putGenesisBlock";
 import { txMapToArray } from "./utils/txMapToArray";
@@ -130,6 +132,8 @@ export class HardhatNode extends EventEmitter {
       tracingConfig,
       minGasPrice,
       mempoolOrder,
+      networkId,
+      chainId,
     } = config;
 
     let common: Common;
@@ -138,6 +142,8 @@ export class HardhatNode extends EventEmitter {
     let initialBlockTimeOffset: BN | undefined;
     let nextBlockBaseFeePerGas: BN | undefined;
     let forkNetworkId: number | undefined;
+    let forkBlockNum: number | undefined;
+    let hardforkActivations: HardforkHistoryConfig = new Map();
 
     const initialBaseFeePerGasConfig =
       config.initialBaseFeePerGas !== undefined
@@ -152,6 +158,7 @@ export class HardhatNode extends EventEmitter {
       common = await makeForkCommon(config);
 
       forkNetworkId = forkClient.getNetworkId();
+      forkBlockNum = forkBlockNumber.toNumber();
 
       this._validateHardforks(
         config.forkConfig.blockNumber,
@@ -189,12 +196,18 @@ export class HardhatNode extends EventEmitter {
           }
         }
       }
+
+      if (config.chains.has(forkNetworkId)) {
+        hardforkActivations = config.chains.get(forkNetworkId)!.hardforkHistory;
+      }
     } else {
-      const hardhatStateManager = new HardhatStateManager();
-      await hardhatStateManager.initializeGenesisAccounts(genesisAccounts);
+      const stateTrie = await makeStateTrie(genesisAccounts);
+      common = makeCommon(config, stateTrie);
 
-      const initialStateRoot = await hardhatStateManager.getStateRoot();
-      common = makeCommon(config, initialStateRoot);
+      stateManager = new DefaultStateManager({
+        common,
+        trie: stateTrie,
+      });
 
       const hardhatBlockchain = new HardhatBlockchain();
 
@@ -219,7 +232,6 @@ export class HardhatNode extends EventEmitter {
       }
 
       blockchain = hardhatBlockchain;
-      stateManager = hardhatStateManager;
     }
 
     const txPool = new TxPool(stateManager, new BN(blockGasLimit), common);
@@ -243,8 +255,12 @@ export class HardhatNode extends EventEmitter {
       mempoolOrder,
       config.coinbase,
       genesisAccounts,
+      networkId,
+      chainId,
+      hardforkActivations,
       tracingConfig,
       forkNetworkId,
+      forkBlockNum,
       nextBlockBaseFeePerGas
     );
 
@@ -268,7 +284,7 @@ The hardfork must be at least spuriousDragon, but ${common.hardfork()} was given
       let upstreamCommon: Common;
       try {
         upstreamCommon = new Common({ chain: remoteChainId });
-      } catch (error) {
+      } catch {
         // If ethereumjs doesn't have a common it will throw and we won't have
         // info about the activation block of each hardfork, so we don't run
         // this validation.
@@ -318,8 +334,12 @@ Hardhat Network's forking functionality only works with blocks from at least spu
     private _mempoolOrder: MempoolOrder,
     private _coinbase: string,
     genesisAccounts: GenesisAccount[],
+    private readonly _configNetworkId: number,
+    private readonly _configChainId: number,
+    private readonly _hardforkActivations: HardforkHistoryConfig,
     tracingConfig?: TracingConfig,
     private _forkNetworkId?: number,
+    private _forkBlockNumber?: number,
     nextBlockBaseFee?: BN
   ) {
     super();
@@ -369,7 +389,9 @@ Hardhat Network's forking functionality only works with blocks from at least spu
         error
       );
 
-      Reporter.reportError(error);
+      if (error instanceof Error) {
+        Reporter.reportError(error);
+      }
     }
   }
 
@@ -436,16 +458,21 @@ Hardhat Network's forking functionality only works with blocks from at least spu
     try {
       result = await this._mineBlockWithPendingTxs(blockTimestamp);
     } catch (err) {
-      if (err?.message.includes("sender doesn't have enough funds")) {
-        throw new InvalidInputError(err.message, err);
-      }
+      if (err instanceof Error) {
+        if (err?.message.includes("sender doesn't have enough funds")) {
+          throw new InvalidInputError(err.message, err);
+        }
 
-      // Some network errors are HardhatErrors, and can end up here when forking
-      if (HardhatError.isHardhatError(err)) {
-        throw err;
+        // Some network errors are HardhatErrors, and can end up here when forking
+        if (HardhatError.isHardhatError(err)) {
+          throw err;
+        }
+
+        throw new TransactionExecutionError(err);
       }
 
-      throw new TransactionExecutionError(err);
+      // eslint-disable-next-line @nomiclabs/hardhat-internal-rules/only-hardhat-error
+      throw err;
     }
 
     await this._saveBlockAsSuccessfullyRun(result.block, result.blockResult);
@@ -475,7 +502,10 @@ Hardhat Network's forking functionality only works with blocks from at least spu
       blockNumberOrPending
     );
 
-    if (call.gasPrice !== undefined || !this.isEip1559Active()) {
+    if (
+      call.gasPrice !== undefined ||
+      !this.isEip1559Active(blockNumberOrPending)
+    ) {
       txParams = {
         gasPrice: new BN(0),
         nonce,
@@ -1214,7 +1244,10 @@ Hardhat Network's forking functionality only works with blocks from at least spu
             "this._forkNetworkId should exist if the blockchain is an instance of ForkBlockchain"
           );
 
-          const common = getCommonForTracing(this._forkNetworkId, blockNumber);
+          const common = this._getCommonForTracing(
+            this._forkNetworkId,
+            blockNumber
+          );
 
           vm = new VM({
             common,
@@ -1508,7 +1541,12 @@ Hardhat Network's forking functionality only works with blocks from at least spu
     try {
       sender = tx.getSenderAddress(); // verifies signature as a side effect
     } catch (e) {
-      throw new InvalidInputError(e.message);
+      if (e instanceof Error) {
+        throw new InvalidInputError(e.message);
+      }
+
+      // eslint-disable-next-line @nomiclabs/hardhat-internal-rules/only-hardhat-error
+      throw e;
     }
 
     // validate nonce
@@ -2139,6 +2177,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
     const initialStateRoot = await this._stateManager.getStateRoot();
 
     let blockContext: Block | undefined;
+    let originalCommon: Common | undefined;
 
     try {
       if (blockNumberOrPending === "pending") {
@@ -2173,7 +2212,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
       // eth_call. This will make the BASEFEE option also return 0, which
       // shouldn't. See: https://github.com/nomiclabs/hardhat/issues/1688
       if (
-        this.isEip1559Active() &&
+        this.isEip1559Active(blockNumberOrPending) &&
         (blockContext.header.baseFeePerGas === undefined || forceBaseFeeZero)
       ) {
         blockContext = Block.fromBlockData(blockContext, {
@@ -2184,6 +2223,17 @@ Hardhat Network's forking functionality only works with blocks from at least spu
         (blockContext.header as any).baseFeePerGas = new BN(0);
       }
 
+      originalCommon = (this._vm as any)._common;
+      (this._vm as any)._common = new Common({
+        chain: {
+          // eslint-disable-next-line @typescript-eslint/dot-notation
+          ...this._vm._common["_chainParams"],
+          chainId: this._forkNetworkId ?? this._configChainId,
+          networkId: this._forkNetworkId ?? this._configNetworkId,
+        },
+        hardfork: this._selectHardfork(blockContext.header.number),
+      });
+
       return await this._vm.runTx({
         block: blockContext,
         tx,
@@ -2192,6 +2242,9 @@ Hardhat Network's forking functionality only works with blocks from at least spu
         skipBlockGasLimitValidation: true,
       });
     } finally {
+      if (originalCommon !== undefined) {
+        (this._vm as any)._common = originalCommon;
+      }
       await this._stateManager.setStateRoot(initialStateRoot);
     }
   }
@@ -2287,7 +2340,16 @@ Hardhat Network's forking functionality only works with blocks from at least spu
     );
   }
 
-  public isEip1559Active(): boolean {
+  public isEip1559Active(blockNumberOrPending?: BN | "pending"): boolean {
+    if (
+      blockNumberOrPending !== undefined &&
+      blockNumberOrPending !== "pending"
+    ) {
+      return this._vm._common.hardforkGteHardfork(
+        this._selectHardfork(blockNumberOrPending),
+        "london"
+      );
+    }
     return this._vm._common.gteHardfork("london");
   }
 
@@ -2297,7 +2359,10 @@ Hardhat Network's forking functionality only works with blocks from at least spu
   ): Promise<
     { gasPrice: BN } | { maxFeePerGas: BN; maxPriorityFeePerGas: BN }
   > {
-    if (!this.isEip1559Active() || callParams.gasPrice !== undefined) {
+    if (
+      !this.isEip1559Active(blockNumberOrPending) ||
+      callParams.gasPrice !== undefined
+    ) {
       return { gasPrice: callParams.gasPrice ?? (await this.getGasPrice()) };
     }
 
@@ -2327,18 +2392,71 @@ Hardhat Network's forking functionality only works with blocks from at least spu
 
     return { maxFeePerGas, maxPriorityFeePerGas };
   }
-}
 
-function getCommonForTracing(networkId: number, blockNumber: number): Common {
-  try {
-    const common = new Common({ chain: networkId });
+  private _selectHardfork(blockNumber: BN): string {
+    if (
+      this._forkBlockNumber === undefined ||
+      blockNumber.gte(new BN(this._forkBlockNumber))
+    ) {
+      return this._vm._common.hardfork() as HardforkName;
+    }
 
-    common.setHardfork(common.activeHardfork(blockNumber));
+    if (this._hardforkActivations.size === 0) {
+      throw new InternalError(
+        `No known hardfork for execution on historical block ${blockNumber.toString()} (relative to fork block number ${
+          this._forkBlockNumber
+        }). The node was not configured with a hardfork activation history.  See http://hardhat.org/hardhat-network/guides/mainnet-forking.html#using-a-custom-hardfork-history`
+      );
+    }
 
-    return common;
-  } catch (e) {
-    throw new InternalError(
-      `Network id ${networkId} does not correspond to a network that Hardhat can trace`
+    /** search this._hardforkActivations for the highest block number that
+     * isn't higher than blockNumber, and then return that found block number's
+     * associated hardfork name. */
+    const hardforkHistory: Array<[name: string, block: number]> = Array.from(
+      this._hardforkActivations.entries()
     );
+    const [hardfork, activationBlock] = hardforkHistory.reduce(
+      ([highestHardfork, highestBlock], [thisHardfork, thisBlock]) =>
+        thisBlock > highestBlock && new BN(thisBlock).lte(blockNumber)
+          ? [thisHardfork, thisBlock]
+          : [highestHardfork, highestBlock]
+    );
+    if (hardfork === undefined || blockNumber.ltn(activationBlock)) {
+      throw new InternalError(
+        `Could not find a hardfork to run for block ${blockNumber}, after having looked for one in the HardhatNode's hardfork activation history, which was: ${JSON.stringify(
+          hardforkHistory
+        )}. For more information, see https://hardhat.org/hardhat-network/reference/#config`
+      );
+    }
+
+    if (!HARDHAT_NETWORK_SUPPORTED_HARDFORKS.includes(hardfork)) {
+      throw new InternalError(
+        `Tried to run a call or transaction in the context of a block whose hardfork is "${hardfork}", but Hardhat Network only supports the following hardforks: ${HARDHAT_NETWORK_SUPPORTED_HARDFORKS.join(
+          ", "
+        )}`
+      );
+    }
+
+    return hardfork;
+  }
+
+  private _getCommonForTracing(networkId: number, blockNumber: number): Common {
+    try {
+      const common = new Common({
+        chain: {
+          // eslint-disable-next-line @typescript-eslint/dot-notation
+          ...Common["_getChainParams"]("mainnet"),
+          chainId: networkId,
+          networkId,
+        },
+        hardfork: this._selectHardfork(new BN(blockNumber)),
+      });
+
+      return common;
+    } catch {
+      throw new InternalError(
+        `Network id ${networkId} does not correspond to a network that Hardhat can trace`
+      );
+    }
   }
 }

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

@@ -11,6 +11,7 @@ import type {
   BoundExperimentalHardhatNetworkMessageTraceHook,
   EIP1193Provider,
   EthSubscription,
+  HardhatNetworkChainsConfig,
   RequestArguments,
 } from "../../../types";
 import {
@@ -85,6 +86,7 @@ export class HardhatNetworkProvider
     private readonly _automine: boolean,
     private readonly _intervalMining: IntervalMiningConfig,
     private readonly _mempoolOrder: MempoolOrder,
+    private readonly _chains: HardhatNetworkChainsConfig,
     private readonly _logger: ModulesLogger,
     private readonly _genesisAccounts: GenesisAccount[] = [],
     private readonly _artifacts?: Artifacts,
@@ -164,7 +166,7 @@ export class HardhatNetworkProvider
       this._logger.printFailedMethod(method);
       this._logger.printLogs();
 
-      if (!this._logger.isLoggedError(err)) {
+      if (err instanceof Error && !this._logger.isLoggedError(err)) {
         if (ProviderError.isProviderError(err)) {
           this._logger.printEmptyLine();
           this._logger.printErrorMessage(err.message);
@@ -242,6 +244,7 @@ export class HardhatNetworkProvider
       forkCachePath:
         this._forkConfig !== undefined ? this._forkCachePath : undefined,
       coinbase: this._coinbase,
+      chains: this._chains,
     };
 
     const [common, node] = await HardhatNode.create(config);

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

@@ -57,7 +57,7 @@ export class ReadOnlyValidEIP1559Transaction extends FeeMarketEIP1559Transaction
   constructor(sender: Address, data: FeeMarketEIP1559TxData = {}) {
     const fakeCommon = new Common({
       chain: "mainnet",
-      hardfork: "london",
+      hardfork: "london", // TODO: consider chaning this to ["latest hardfork"]
     });
 
     // this class should only be used with txs in a hardfork that

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

@@ -15,7 +15,7 @@ export function makeCommon(
     blockGasLimit,
     hardfork,
   }: LocalNodeConfig,
-  stateRoot: Buffer
+  stateTrie: any
 ) {
   const initialBlockTimestamp =
     initialDate !== undefined
@@ -35,7 +35,7 @@ export function makeCommon(
         difficulty: 1,
         nonce: "0x0000000000000042",
         extraData: "0x1234",
-        stateRoot: bufferToHex(stateRoot),
+        stateRoot: bufferToHex(stateTrie.root),
       },
     },
     hardfork

package/src/internal/hardhat-network/stack-traces/solidity-errors.ts

@@ -36,7 +36,7 @@ export async function wrapWithSolidityErrorsCorrection(
 
   try {
     return await f();
-  } catch (error) {
+  } catch (error: any) {
     if (error.stackTrace === undefined) {
       // eslint-disable-next-line @nomiclabs/hardhat-internal-rules/only-hardhat-error
       throw error;