hardhat 2.17.0 → 2.17.2

package/src/builtin-tasks/flatten.ts

@@ -1,3 +1,4 @@
+import chalk from "chalk";
 import { subtask, task, types } from "../internal/core/config/config-env";
 import { HardhatError } from "../internal/core/errors";
 import { ERRORS } from "../internal/core/errors-list";
@@ -13,8 +14,23 @@ import {
   TASK_FLATTEN,
   TASK_FLATTEN_GET_DEPENDENCY_GRAPH,
   TASK_FLATTEN_GET_FLATTENED_SOURCE,
+  TASK_FLATTEN_GET_FLATTENED_SOURCE_AND_METADATA,
 } from "./task-names";
 
+interface FlattenMetadata {
+  filesWithoutLicenses: string[];
+  pragmaDirective: string;
+  filesWithoutPragmaDirectives: string[];
+  filesWithDifferentPragmaDirectives: string[];
+}
+
+// Match every group where a SPDX license is defined. The first captured group is the license.
+const SPDX_LICENSES_REGEX =
+  /^(?:\/\/|\/\*)\s*SPDX-License-Identifier:\s*([a-zA-Z\d+.-]+).*/gm;
+// Match every group where a pragma directive is defined. The first captured group is the pragma directive.
+const PRAGMA_DIRECTIVES_REGEX =
+  /^(?: |\t)*(pragma\s*abicoder\s*v(1|2)|pragma\s*experimental\s*ABIEncoderV2)\s*;/gim;
+
 function getSortedFiles(dependenciesGraph: DependencyGraph) {
   const tsort = require("tsort");
   const graph = tsort();
@@ -71,34 +87,187 @@ function getFileWithoutImports(resolvedFile: ResolvedFile) {
     .trim();
 }
 
+function getLicensesInfo(sortedFiles: ResolvedFile[]): [string[], string[]] {
+  const licenses: Set<string> = new Set();
+  const filesWithoutLicenses: Set<string> = new Set();
+
+  for (const file of sortedFiles) {
+    const matches = [...file.content.rawContent.matchAll(SPDX_LICENSES_REGEX)];
+
+    if (matches.length === 0) {
+      filesWithoutLicenses.add(file.sourceName);
+      continue;
+    }
+
+    for (const groups of matches) {
+      licenses.add(groups[1]);
+    }
+  }
+
+  // Sort alphabetically
+  return [Array.from(licenses).sort(), Array.from(filesWithoutLicenses).sort()];
+}
+
+function getLicensesHeader(licenses: string[]): string {
+  return licenses.length <= 0
+    ? ""
+    : `\n\n// SPDX-License-Identifier: ${licenses.join(" AND ")}`;
+}
+
+function removeUnnecessarySpaces(str: string): string {
+  return str.replace(/\s+/g, " ").trim();
+}
+
+function getPragmaAbicoderDirectiveInfo(
+  sortedFiles: ResolvedFile[]
+): [string, string[], string[]] {
+  let directive = "";
+  const directivesByImportance = [
+    "pragma abicoder v1",
+    "pragma experimental ABIEncoderV2",
+    "pragma abicoder v2",
+  ];
+  const filesWithoutPragmaDirectives: Set<string> = new Set();
+  const filesWithMostImportantDirective: Array<[string, string]> = []; // Every array element has the structure: [ fileName, fileMostImportantDirective ]
+
+  for (const file of sortedFiles) {
+    const matches = [
+      ...file.content.rawContent.matchAll(PRAGMA_DIRECTIVES_REGEX),
+    ];
+
+    if (matches.length === 0) {
+      filesWithoutPragmaDirectives.add(file.sourceName);
+      continue;
+    }
+
+    let fileMostImportantDirective = "";
+    for (const groups of matches) {
+      const normalizedPragma = removeUnnecessarySpaces(groups[1]);
+
+      // Update the most important pragma directive among all the files
+      if (
+        directivesByImportance.indexOf(normalizedPragma) >
+        directivesByImportance.indexOf(directive)
+      ) {
+        directive = normalizedPragma;
+      }
+
+      // Update the most important pragma directive for the current file
+      if (
+        directivesByImportance.indexOf(normalizedPragma) >
+        directivesByImportance.indexOf(fileMostImportantDirective)
+      ) {
+        fileMostImportantDirective = normalizedPragma;
+      }
+    }
+
+    // Add in the array the most important directive for the current file
+    filesWithMostImportantDirective.push([
+      file.sourceName,
+      fileMostImportantDirective,
+    ]);
+  }
+
+  // Add to the array the files that have a pragma directive which is not the same as the main one that
+  // is going to be used in the flatten file
+  const filesWithDifferentPragmaDirectives = filesWithMostImportantDirective
+    .filter(([, fileDirective]) => fileDirective !== directive)
+    .map(([fileName]) => fileName);
+
+  // Sort alphabetically
+  return [
+    directive,
+    Array.from(filesWithoutPragmaDirectives).sort(),
+    filesWithDifferentPragmaDirectives.sort(),
+  ];
+}
+
+function getPragmaAbicoderDirectiveHeader(pragmaDirective: string): string {
+  return pragmaDirective === "" ? "" : `\n\n${pragmaDirective};`;
+}
+
+function replaceLicenses(file: string): string {
+  return file.replaceAll(
+    SPDX_LICENSES_REGEX,
+    (...groups) => `// Original license: SPDX_License_Identifier: ${groups[1]}`
+  );
+}
+
+function replacePragmaAbicoderDirectives(file: string): string {
+  return file.replaceAll(PRAGMA_DIRECTIVES_REGEX, (...groups) => {
+    return `// Original pragma directive: ${removeUnnecessarySpaces(
+      groups[1]
+    )}`;
+  });
+}
+
 subtask(
-  TASK_FLATTEN_GET_FLATTENED_SOURCE,
-  "Returns all contracts and their dependencies flattened"
+  TASK_FLATTEN_GET_FLATTENED_SOURCE_AND_METADATA,
+  "Returns all contracts and their dependencies flattened. Also return metadata about pragma directives and SPDX licenses"
 )
   .addOptionalParam("files", undefined, undefined, types.any)
-  .setAction(async ({ files }: { files?: string[] }, { run }) => {
-    const dependencyGraph: DependencyGraph = await run(
-      TASK_FLATTEN_GET_DEPENDENCY_GRAPH,
-      { files }
-    );
+  .setAction(
+    async (
+      { files }: { files?: string[] },
+      { run }
+    ): Promise<[string, FlattenMetadata | null]> => {
+      const dependencyGraph: DependencyGraph = await run(
+        TASK_FLATTEN_GET_DEPENDENCY_GRAPH,
+        { files }
+      );
 
-    let flattened = "";
+      let flattened = "";
 
-    if (dependencyGraph.getResolvedFiles().length === 0) {
-      return flattened;
-    }
+      if (dependencyGraph.getResolvedFiles().length === 0) {
+        return [flattened, null];
+      }
+
+      const packageJson = await getPackageJson();
+      flattened += `// Sources flattened with hardhat v${packageJson.version} https://hardhat.org`;
+
+      const sortedFiles = getSortedFiles(dependencyGraph);
+
+      const [licenses, filesWithoutLicenses] = getLicensesInfo(sortedFiles);
+      const [
+        pragmaDirective,
+        filesWithoutPragmaDirectives,
+        filesWithDifferentPragmaDirectives,
+      ] = getPragmaAbicoderDirectiveInfo(sortedFiles);
 
-    const packageJson = await getPackageJson();
-    flattened += `// Sources flattened with hardhat v${packageJson.version} https://hardhat.org`;
+      flattened += getLicensesHeader(licenses);
+      flattened += getPragmaAbicoderDirectiveHeader(pragmaDirective);
 
-    const sortedFiles = getSortedFiles(dependencyGraph);
+      for (const file of sortedFiles) {
+        let tmpFile = getFileWithoutImports(file);
+        tmpFile = replaceLicenses(tmpFile);
+        tmpFile = replacePragmaAbicoderDirectives(tmpFile);
 
-    for (const file of sortedFiles) {
-      flattened += `\n\n// File ${file.getVersionedName()}\n`;
-      flattened += `\n${getFileWithoutImports(file)}\n`;
+        flattened += `\n\n// File ${file.getVersionedName()}\n`;
+        flattened += `\n${tmpFile}\n`;
+      }
+
+      return [
+        flattened.trim(),
+        {
+          filesWithoutLicenses,
+          pragmaDirective,
+          filesWithoutPragmaDirectives,
+          filesWithDifferentPragmaDirectives,
+        },
+      ];
     }
+  );
 
-    return flattened.trim();
+// The following task is kept for backwards-compatibility reasons
+subtask(
+  TASK_FLATTEN_GET_FLATTENED_SOURCE,
+  "Returns all contracts and their dependencies flattened"
+)
+  .addOptionalParam("files", undefined, undefined, types.any)
+  .setAction(async ({ files }: { files?: string[] }, { run }) => {
+    return (
+      await run(TASK_FLATTEN_GET_FLATTENED_SOURCE_AND_METADATA, { files })
+    )[0];
   });
 
 subtask(TASK_FLATTEN_GET_DEPENDENCY_GRAPH)
@@ -135,5 +304,45 @@ task(
     types.inputFile
   )
   .setAction(async ({ files }: { files: string[] | undefined }, { run }) => {
-    console.log(await run(TASK_FLATTEN_GET_FLATTENED_SOURCE, { files }));
+    const [flattenedFile, metadata]: [string, FlattenMetadata | null] =
+      await run(TASK_FLATTEN_GET_FLATTENED_SOURCE_AND_METADATA, { files });
+
+    console.log(flattenedFile);
+
+    if (metadata === null) return;
+
+    if (metadata.filesWithoutLicenses.length > 0) {
+      console.warn(
+        chalk.yellow(
+          `\nThe following file(s) do NOT specify SPDX licenses: ${metadata.filesWithoutLicenses.join(
+            ", "
+          )}`
+        )
+      );
+    }
+
+    if (
+      metadata.pragmaDirective !== "" &&
+      metadata.filesWithoutPragmaDirectives.length > 0
+    ) {
+      console.warn(
+        chalk.yellow(
+          `\nPragma abicoder directives are defined in some files, but they are not defined in the following ones: ${metadata.filesWithoutPragmaDirectives.join(
+            ", "
+          )}`
+        )
+      );
+    }
+
+    if (metadata.filesWithDifferentPragmaDirectives.length > 0) {
+      console.warn(
+        chalk.yellow(
+          `\nThe flattened file is using the pragma abicoder directive '${
+            metadata.pragmaDirective
+          }' but these files have a different pragma abicoder directive: ${metadata.filesWithDifferentPragmaDirectives.join(
+            ", "
+          )}`
+        )
+      );
+    }
   });

package/src/builtin-tasks/task-names.ts

@@ -14,6 +14,7 @@ export const TASK_COMPILE_SOLIDITY_GET_SOURCE_NAMES =
 export const TASK_COMPILE_SOLIDITY_READ_FILE = "compile:solidity:read-file";
 export const TASK_COMPILE_TRANSFORM_IMPORT_NAME =
   "compile:solidity:transform-import-name";
+export const TASK_COMPILE_GET_REMAPPINGS = "compile:solidity:get-remappings";
 export const TASK_COMPILE_SOLIDITY_GET_DEPENDENCY_GRAPH =
   "compile:solidity:get-dependency-graph";
 export const TASK_COMPILE_SOLIDITY_GET_COMPILATION_JOBS =
@@ -68,6 +69,8 @@ export const TASK_CONSOLE = "console";
 export const TASK_FLATTEN = "flatten";
 export const TASK_FLATTEN_GET_FLATTENED_SOURCE =
   "flatten:get-flattened-sources";
+export const TASK_FLATTEN_GET_FLATTENED_SOURCE_AND_METADATA =
+  "flatten:get-flattened-sources-and-metadata";
 export const TASK_FLATTEN_GET_DEPENDENCY_GRAPH = "flatten:get-dependency-graph";
 
 export const TASK_HELP = "help";

package/src/internal/artifacts.ts

@@ -78,7 +78,18 @@ export class Artifacts implements IArtifacts {
   }
 
   public async artifactExists(name: string): Promise<boolean> {
-    const artifactPath = await this._getArtifactPath(name);
+    let artifactPath;
+    try {
+      artifactPath = await this._getArtifactPath(name);
+    } catch (e) {
+      if (HardhatError.isHardhatError(e)) {
+        return false;
+      }
+
+      // eslint-disable-next-line @nomicfoundation/hardhat-internal-rules/only-hardhat-error
+      throw e;
+    }
+
     return fsExtra.pathExists(artifactPath);
   }
 
@@ -407,6 +418,7 @@ export class Artifacts implements IArtifacts {
 
   /**
    * Returns the absolute path to the given artifact
+   * @throws {HardhatError} If the name is not fully qualified.
    */
   public formArtifactPathFromFullyQualifiedName(
     fullyQualifiedName: string
@@ -490,6 +502,11 @@ export class Artifacts implements IArtifacts {
    * If the name is fully qualified, the path is computed from it.  If not, an
    * artifact that matches the given name is searched in the existing artifacts.
    * If there is an ambiguity, an error is thrown.
+   *
+   * @throws {HardhatError} with descriptor:
+   * - {@link ERRORS.ARTIFACTS.WRONG_CASING} if the path case doesn't match the one in the filesystem.
+   * - {@link ERRORS.ARTIFACTS.MULTIPLE_FOUND} if there are multiple artifacts matching the given contract name.
+   * - {@link ERRORS.ARTIFACTS.NOT_FOUND} if the artifact is not found.
    */
   private async _getArtifactPath(name: string): Promise<string> {
     const cached = this._cache?.artifactNameToArtifactPathCache.get(name);
@@ -603,6 +620,16 @@ export class Artifacts implements IArtifacts {
     return path.join(this._artifactsPath, sourceName, `${contractName}.json`);
   }
 
+  /**
+   * Returns the absolute path to the artifact that corresponds to the given
+   * fully qualified name.
+   * @param fullyQualifiedName The fully qualified name of the contract.
+   * @returns The absolute path to the artifact.
+   * @throws {HardhatError} with descriptor:
+   * - {@link ERRORS.CONTRACT_NAMES.INVALID_FULLY_QUALIFIED_NAME} If the name is not fully qualified.
+   * - {@link ERRORS.ARTIFACTS.WRONG_CASING} If the path case doesn't match the one in the filesystem.
+   * - {@link ERRORS.ARTIFACTS.NOT_FOUND} If the artifact is not found.
+   */
   private async _getValidArtifactPathFromFullyQualifiedName(
     fullyQualifiedName: string
   ): Promise<string> {
@@ -666,6 +693,9 @@ Please replace "${contractName}" for the correct contract name wherever you are
     }
   }
 
+  /**
+   * @throws {HardhatError} with a list of similar contract names.
+   */
   private _handleWrongArtifactForFullyQualifiedName(
     fullyQualifiedName: string
   ): never {
@@ -682,6 +712,9 @@ Please replace "${contractName}" for the correct contract name wherever you are
     });
   }
 
+  /**
+   * @throws {HardhatError} with a list of similar contract names.
+   */
   private _handleWrongArtifactForContractName(
     contractName: string,
     files: string[]
@@ -813,6 +846,12 @@ Please replace "${contractName}" for the correct contract name wherever you are
     return artifactPath.replace(/\.json$/, ".dbg.json");
   }
 
+  /**
+   * Gets the path to the artifact file for the given contract name.
+   * @throws {HardhatError} with descriptor:
+   * - {@link ERRORS.ARTIFACTS.NOT_FOUND} if there are no artifacts matching the given contract name.
+   * - {@link ERRORS.ARTIFACTS.MULTIPLE_FOUND} if there are multiple artifacts matching the given contract name.
+   */
   private _getArtifactPathFromFiles(
     contractName: string,
     files: string[]

package/src/internal/cli/analytics.ts

@@ -1,4 +1,3 @@
-import type AbortControllerT from "abort-controller";
 import type { request as RequestT } from "undici";
 
 import debug from "debug";
@@ -128,8 +127,6 @@ export class Analytics {
 
   private _sendHit(payload: AnalyticsPayload): [AbortAnalytics, Promise<void>] {
     const { request } = require("undici") as { request: typeof RequestT };
-    const AbortController =
-      require("abort-controller") as typeof AbortControllerT;
 
     const eventName = payload.events[0].name;
     log(`Sending hit for ${eventName}`);

package/src/internal/cli/project-creation.ts

@@ -315,7 +315,7 @@ async function createPackageJson() {
 function showStarOnGitHubMessage() {
   console.log(
     chalk.cyan("Give Hardhat a star on Github if you're enjoying it!") +
-      emoji(" 💞✨")
+      emoji(" ⭐️✨")
   );
   console.log();
   console.log(chalk.cyan("     https://github.com/NomicFoundation/hardhat"));

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

@@ -278,6 +278,16 @@ Rename the file to use the .cjs to fix this problem.`,
 To initialize the provider, make sure you first call \`.init()\` or any method that hits a node like request, send or sendAsync.`,
       shouldBeReported: true,
     },
+    INVALID_READ_OF_DIRECTORY: {
+      number: 22,
+      message:
+        "Invalid file path %absolutePath%. Attempting to read a directory instead of a file.",
+      title: "Invalid read: a directory cannot be read",
+      description: `An attempt was made to read a file, but a path to a directory was provided.
+
+Please double check the file path.`,
+      shouldBeReported: false,
+    },
   },
   NETWORK: {
     CONFIG_NOT_FOUND: {
@@ -585,6 +595,14 @@ Please double check your task definitions.`,
 What makes these types special is that they can be represented as strings, so you can write them down in the terminal.`,
       shouldBeReported: false,
     },
+    DEPRECATED_TRANSFORM_IMPORT_TASK: {
+      number: 213,
+      title: "Use of deprecated remapping task",
+      message:
+        "Task TASK_COMPILE_TRANSFORM_IMPORT_NAME is deprecated. Please update your @nomicfoundation/hardhat-foundry plugin version.",
+      description: `This task has been deprecated in favor of a new approach.`,
+      shouldBeReported: true,
+    },
   },
   ARGUMENTS: {
     INVALID_ENV_VAR_VALUE: {
@@ -855,6 +873,26 @@ Use a relative import instead of referencing the package's name.`,
 Please double check your imports and installed libraries.`,
       shouldBeReported: false,
     },
+    INVALID_IMPORT_OF_DIRECTORY: {
+      number: 414,
+      message:
+        "Invalid import %imported% from %from%. Attempting to import a directory. Directories cannot be imported.",
+      title: "Invalid import: a directory cannot be imported",
+      description: `A Solidity file is attempting to import a directory, which is not possible.
+
+Please double check your imports.`,
+      shouldBeReported: false,
+    },
+    AMBIGUOUS_SOURCE_NAMES: {
+      number: 415,
+      message:
+        "Two different source names (%sourcenames%) resolve to the same file (%file%).",
+      title: "Ambiguous source names",
+      description: `Two different source names map to the same file.
+
+This is probably caused by multiple remappings pointing to the same source file.`,
+      shouldBeReported: false,
+    },
   },
   SOLC: {
     INVALID_VERSION: {

package/src/internal/core/jsonrpc/types/base-types.ts

@@ -40,6 +40,17 @@ export const rpcStorageSlot = new t.Type<bigint>(
   t.identity
 );
 
+// This type is necessary because objects' keys need to be either strings or numbers to be properly handled by the 'io-ts' module.
+// If they are not defined as strings or numbers, the type definition will result in an empty object without the required properties.
+// For example, instead of displaying { ke1: value1 }, it will display {}
+export const rpcStorageSlotHexString = new t.Type<string>(
+  "Storage slot hex string",
+  (x): x is string => typeof x === "string",
+  (u, c) =>
+    validateRpcStorageSlotHexString(u) ? t.success(u) : t.failure(u, c),
+  t.identity
+);
+
 function validateStorageSlot(u: unknown, c: t.Context): t.Validation<bigint> {
   if (typeof u !== "string") {
     return t.failure(
@@ -185,6 +196,10 @@ export function rpcDataToBuffer(data: string): Buffer {
 
 // Type guards
 
+function validateRpcStorageSlotHexString(u: unknown): u is string {
+  return typeof u === "string" && /^0x([0-9a-fA-F]){64}$/.test(u);
+}
+
 function isRpcQuantityString(u: unknown): u is string {
   return (
     typeof u === "string" &&

package/src/internal/core/jsonrpc/types/input/callRequest.ts

@@ -2,7 +2,14 @@ import * as t from "io-ts";
 
 import { optionalOrNullable } from "../../../../util/io-ts";
 import { rpcAccessList } from "../access-list";
-import { rpcAddress, rpcData, rpcQuantity } from "../base-types";
+import {
+  rpcAddress,
+  rpcData,
+  rpcQuantity,
+  rpcStorageSlot,
+  rpcStorageSlotHexString,
+} from "../base-types";
+import { address } from "../../../config/config-validation";
 
 // Type used by eth_call and eth_estimateGas
 export const rpcCallRequest = t.type(
@@ -21,3 +28,30 @@ export const rpcCallRequest = t.type(
 );
 
 export type RpcCallRequest = t.TypeOf<typeof rpcCallRequest>;
+
+// Types used by eth_call to configure the state override set
+export const stateProperties = t.record(
+  rpcStorageSlotHexString,
+  rpcStorageSlot
+);
+
+export const stateOverrideOptions = t.type(
+  {
+    balance: optionalOrNullable(rpcQuantity),
+    nonce: optionalOrNullable(rpcQuantity),
+    code: optionalOrNullable(rpcData),
+    state: optionalOrNullable(stateProperties),
+    stateDiff: optionalOrNullable(stateProperties),
+  },
+  "stateOverrideOptions"
+);
+
+export const stateOverrideSet = t.record(address, stateOverrideOptions);
+export const optionalStateOverrideSet = optionalOrNullable(stateOverrideSet);
+
+export type StateProperties = t.TypeOf<typeof stateProperties>;
+export type StateOverrideOptions = t.TypeOf<typeof stateOverrideOptions>;
+export type StateOverrideSet = t.TypeOf<typeof stateOverrideSet>;
+export type OptionalStateOverrideSet = t.TypeOf<
+  typeof optionalStateOverrideSet
+>;

package/src/internal/core/jsonrpc/types/input/debugTraceTransaction.ts

@@ -5,6 +5,7 @@ import { optionalOrNullable } from "../../../../util/io-ts";
 export const rpcDebugTracingConfig = optionalOrNullable(
   t.type(
     {
+      tracer: optionalOrNullable(t.string),
       disableStorage: optionalOrNullable(t.boolean),
       disableMemory: optionalOrNullable(t.boolean),
       disableStack: optionalOrNullable(t.boolean),

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

@@ -116,6 +116,8 @@ export async function createProvider(
         forkConfig,
         forkCachePath:
           paths !== undefined ? getForkCacheDirPath(paths) : undefined,
+        enableTransientStorage:
+          hardhatNetConfig.enableTransientStorage ?? false,
       },
       new ModulesLogger(hardhatNetConfig.loggingEnabled),
       artifacts

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

@@ -203,7 +203,7 @@ export class HttpProvider extends EventEmitter implements EIP1193Provider {
         // 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);
+        const seconds = this._getRetryAfterSeconds(response, retryNumber);
         if (seconds !== undefined && this._shouldRetry(retryNumber, seconds)) {
           return await this._retry(request, seconds, retryNumber);
         }
@@ -272,12 +272,15 @@ export class HttpProvider extends EventEmitter implements EIP1193Provider {
   }
 
   private _getRetryAfterSeconds(
-    response: Undici.Dispatcher.ResponseData
+    response: Undici.Dispatcher.ResponseData,
+    retryNumber: number
   ): number | undefined {
     const header = response.headers["retry-after"];
 
     if (header === undefined || header === null || Array.isArray(header)) {
-      return undefined;
+      // if the response doesn't have a retry-after header, we do
+      // an exponential backoff
+      return Math.min(2 ** retryNumber, MAX_RETRY_AWAIT_SECONDS);
     }
 
     const parsed = parseInt(header, 10);

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

@@ -348,10 +348,30 @@ export class ForkBlockchain
       return undefined;
     }
 
-    const transaction = new ReadOnlyValidTransaction(
-      new Address(rpcTransaction.from),
-      rpcToTxData(rpcTransaction)
-    );
+    let transaction: TypedTransaction;
+
+    if (rpcTransaction.type === undefined || rpcTransaction.type === 0n) {
+      transaction = new ReadOnlyValidTransaction(
+        new Address(rpcTransaction.from),
+        rpcToTxData(rpcTransaction)
+      );
+    } else if (rpcTransaction.type === 1n) {
+      transaction = new ReadOnlyValidEIP2930Transaction(
+        new Address(rpcTransaction.from),
+        rpcToTxData(rpcTransaction)
+      );
+    } else if (rpcTransaction.type === 2n) {
+      transaction = new ReadOnlyValidEIP1559Transaction(
+        new Address(rpcTransaction.from),
+        rpcToTxData(rpcTransaction) as FeeMarketEIP1559TxData
+      );
+    } else {
+      transaction = new ReadOnlyValidUnknownTypeTransaction(
+        new Address(rpcTransaction.from),
+        Number(rpcTransaction.type),
+        rpcToTxData(rpcTransaction)
+      );
+    }
 
     this._data.addTransaction(transaction);
 

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

@@ -1,11 +1,20 @@
+import type { BigIntLike } from "@nomicfoundation/ethereumjs-util";
+
 import {
   AccessListEIP2930TxData,
   TxData,
 } from "@nomicfoundation/ethereumjs-tx";
 
-import { FeeMarketEIP1559TxData } from "@nomicfoundation/ethereumjs-tx/dist/types";
 import { RpcTransaction } from "../../../core/jsonrpc/types/output/transaction";
 
+// the FeeMarketEIP1559TxData interface from ethereum js also has a
+// `gasPrice?: never | null` property, which causes a compilation
+// error in the latest version of typescript
+interface FeeMarketEIP1559TxData extends AccessListEIP2930TxData {
+  maxPriorityFeePerGas?: BigIntLike;
+  maxFeePerGas?: BigIntLike;
+}
+
 export function rpcToTxData(
   rpcTransaction: RpcTransaction
 ): TxData | AccessListEIP2930TxData | FeeMarketEIP1559TxData {