hardhat 3.1.8 → 3.1.10

package/src/internal/builtin-plugins/gas-analytics/gas-analytics-manager.ts

@@ -1,10 +1,10 @@
 import type { GasAnalyticsManager, GasMeasurement } from "./types.js";
-import type { TableItemV2 } from "@nomicfoundation/hardhat-utils/format";
+import type { TableItem } from "@nomicfoundation/hardhat-utils/format";
 
 import crypto from "node:crypto";
 import path from "node:path";
 
-import { formatTableV2 } from "@nomicfoundation/hardhat-utils/format";
+import { formatTable } from "@nomicfoundation/hardhat-utils/format";
 import {
   ensureDir,
   getAllFilesMatching,
@@ -142,8 +142,8 @@ export class GasAnalyticsManagerImplementation implements GasAnalyticsManager {
         const stats: GasStats = {
           min: Math.min(...gasValues),
           max: Math.max(...gasValues),
-          avg: roundTo(avg(gasValues), 2),
-          median: roundTo(median(gasValues), 2),
+          avg: Math.round(avg(gasValues)),
+          median: Math.round(median(gasValues)),
           calls: gasValues.length,
         };
 
@@ -209,7 +209,7 @@ export class GasAnalyticsManagerImplementation implements GasAnalyticsManager {
   public _generateGasStatsReport(
     gasStatsByContract: GasStatsByContract,
   ): string {
-    const rows: TableItemV2[] = [];
+    const rows: TableItem[] = [];
 
     if (gasStatsByContract.size > 0) {
       rows.push({ type: "title", text: chalk.bold("Gas Usage Statistics") });
@@ -279,7 +279,7 @@ export class GasAnalyticsManagerImplementation implements GasAnalyticsManager {
       }
     }
 
-    return formatTableV2(rows);
+    return formatTable(rows);
   }
 }
 
@@ -332,8 +332,3 @@ export function findDuplicates<T>(arr: T[]): T[] {
 
   return [...duplicates];
 }
-
-export function roundTo(value: number, decimals: number): number {
-  const factor = 10 ** decimals;
-  return Math.round(value * factor) / factor;
-}

package/src/internal/builtin-plugins/network-manager/hook-handlers/config.ts

@@ -38,33 +38,77 @@ export async function extendUserConfig(
   const networks: Record<string, NetworkUserConfig> =
     extendedConfig.networks ?? {};
 
-  const localhostConfig: Omit<HttpNetworkUserConfig, "url"> = {
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- This is always http
-    ...(networks.localhost as HttpNetworkUserConfig),
-  };
+  const localhostConfig: NetworkUserConfig | undefined = networks.localhost;
+  const defaultConfig: NetworkUserConfig | undefined = networks.default;
+  const nodeConfig: NetworkUserConfig | undefined = networks.node;
 
-  const defaultConfig: Partial<EdrNetworkUserConfig> = {
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- This is always edr
-    ...(networks.default as EdrNetworkUserConfig),
-  };
+  let extendedLocalhostConfig: NetworkUserConfig;
+  if (
+    localhostConfig === undefined ||
+    localhostConfig.type === undefined ||
+    localhostConfig.type === "http"
+  ) {
+    extendedLocalhostConfig = {
+      url: "http://localhost:8545",
+      type: "http",
+      /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        -- We cast it here because otherwise TS complains that some fields are
+        always overwritten, which is not true for js incomplete configs. */
+      ...(localhostConfig as Partial<HttpNetworkUserConfig>),
+    };
+  } else {
+    extendedLocalhostConfig = localhostConfig;
+  }
+
+  const defaultEdrNetworkConfigValues = {
+    chainId: 31337,
+    gas: "auto",
+    gasMultiplier: 1,
+    gasPrice: "auto",
+    type: "edr-simulated",
+  } as const;
+
+  let extendedDefaultConfig: NetworkUserConfig;
+  if (
+    defaultConfig === undefined ||
+    defaultConfig.type === undefined ||
+    defaultConfig.type === "edr-simulated"
+  ) {
+    extendedDefaultConfig = {
+      ...defaultEdrNetworkConfigValues,
+      /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        -- We cast it here because otherwise TS complains that some fields are
+        always overwritten, which is not true for js incomplete configs. */
+      ...(defaultConfig as Partial<EdrNetworkUserConfig>),
+    };
+  } else {
+    extendedDefaultConfig = defaultConfig;
+  }
+
+  let extendedNodeConfig: NetworkUserConfig;
+  if (
+    nodeConfig === undefined ||
+    nodeConfig.type === undefined ||
+    nodeConfig.type === "edr-simulated"
+  ) {
+    extendedNodeConfig = {
+      ...defaultEdrNetworkConfigValues,
+      /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        -- We cast it here because otherwise TS complains that url and http will
+        be always overwritten, which is not true for js incomplete configs. */
+      ...(nodeConfig as Partial<EdrNetworkUserConfig>),
+    };
+  } else {
+    extendedNodeConfig = nodeConfig;
+  }
 
   return {
     ...extendedConfig,
     networks: {
       ...networks,
-      localhost: {
-        url: "http://localhost:8545",
-        ...localhostConfig,
-        type: "http",
-      },
-      [DEFAULT_NETWORK_NAME]: {
-        chainId: 31337,
-        gas: "auto",
-        gasMultiplier: 1,
-        gasPrice: "auto",
-        ...defaultConfig,
-        type: "edr-simulated",
-      },
+      localhost: extendedLocalhostConfig,
+      [DEFAULT_NETWORK_NAME]: extendedDefaultConfig,
+      node: extendedNodeConfig,
     },
   };
 }

package/src/internal/builtin-plugins/network-manager/type-validation.ts

@@ -344,6 +344,15 @@ function refineEdrNetworkUserConfig(
   { defaultChainType = GENERIC_CHAIN_TYPE, networks = {} }: HardhatUserConfig,
   ctx: RefinementCtx,
 ): void {
+  const nodeNetwork = networks.node;
+  if (nodeNetwork !== undefined && nodeNetwork.type !== "edr-simulated") {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ["networks", "node", "type"],
+      message: "The node network type must be 'edr-simulated'",
+    });
+  }
+
   for (const [networkName, network] of Object.entries(networks)) {
     if (network.type === "edr-simulated") {
       const { chainType, hardfork, minGasPrice, initialBaseFeePerGas } =

package/src/internal/builtin-plugins/node/task-action.ts

@@ -12,7 +12,6 @@ import { ensureDir, exists } from "@nomicfoundation/hardhat-utils/fs";
 import chalk from "chalk";
 import debug from "debug";
 
-import { DEFAULT_NETWORK_NAME } from "../../constants.js";
 import { isSupportedChainType } from "../../edr/chain-type.js";
 import { BUILD_INFO_DIR_NAME } from "../artifacts/artifact-manager.js";
 import { EdrProvider } from "../network-manager/edr/edr-provider.js";
@@ -42,7 +41,7 @@ const nodeAction: NewTaskActionFunction<NodeActionArguments> = async (
   const network =
     hre.globalOptions.network !== undefined
       ? hre.globalOptions.network
-      : DEFAULT_NETWORK_NAME;
+      : "node";
 
   if (!(network in hre.config.networks)) {
     throw new HardhatError(HardhatError.ERRORS.CORE.NETWORK.NETWORK_NOT_FOUND, {
@@ -64,6 +63,7 @@ const nodeAction: NewTaskActionFunction<NodeActionArguments> = async (
   } = {
     network,
   };
+
   // NOTE: We create an empty network config override here. We add to it based
   // on the result of arguments parsing. We can expand the list of arguments
   // as much as needed.

package/src/internal/builtin-plugins/solidity/build-system/build-system.ts

@@ -418,6 +418,7 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
       rootFilePaths.toSorted(), // We sort them to have a deterministic order
       this.#options.projectRoot,
       readSourceFileFactory(this.#hooks),
+      this.#hooks,
     );
 
     const { buildProfileName, buildProfile } = this.#getBuildProfile(

package/src/internal/builtin-plugins/solidity/build-system/compiler/downloader.ts

@@ -152,13 +152,8 @@ export class CompilerDownloaderImplementation implements CompilerDownloader {
   readonly #platform: CompilerPlatform;
   readonly #compilersDir: string;
   readonly #downloadFunction: typeof download;
+  readonly #mutexCompilerList: MultiProcessMutex;
 
-  readonly #mutexCompiler = new MultiProcessMutex("compiler-download");
-  readonly #mutexCompilerList = new MultiProcessMutex("compiler-download-list");
-
-  /**
-   * Use CompilerDownloader.getConcurrencySafeDownloader instead
-   */
   constructor(
     platform: CompilerPlatform,
     compilersDir: string,
@@ -166,6 +161,9 @@ export class CompilerDownloaderImplementation implements CompilerDownloader {
   ) {
     this.#platform = platform;
     this.#compilersDir = compilersDir;
+    this.#mutexCompilerList = new MultiProcessMutex(
+      path.join(compilersDir, "compiler-download-list"),
+    );
     this.#downloadFunction = downloadFunction;
   }
 
@@ -200,11 +198,16 @@ export class CompilerDownloaderImplementation implements CompilerDownloader {
   }
 
   public async downloadCompiler(version: string): Promise<boolean> {
-    // Since only one process at a time can acquire the mutex, we avoid the risk of downloading the same compiler multiple times.
-    // This is because the mutex blocks access until a compiler has been fully downloaded, preventing any new process
-    // from checking whether that version of the compiler exists. Without mutex it might incorrectly
-    // return false, indicating that the compiler isn't present, even though it is currently being downloaded.
-    return this.#mutexCompiler.use(async () => {
+    // A per-version mutex ensures that only one process at a time can download a given compiler version,
+    // while still allowing different compiler versions to be downloaded in parallel.
+    // Without the mutex, a concurrent process might check whether a version exists, incorrectly
+    // find it missing (because another process is still downloading it), and start a redundant download.
+
+    const mutex = new MultiProcessMutex(
+      path.join(this.#compilersDir, `compiler-download-${version}`),
+    );
+
+    return mutex.use(async () => {
       const isCompilerDownloaded = await this.isCompilerDownloaded(version);
 
       if (isCompilerDownloaded === true) {

package/src/internal/builtin-plugins/solidity/build-system/dependency-graph-building.ts

@@ -1,3 +1,5 @@
+import type { RemappingsReaderFunction } from "./resolver/remapped-npm-packages-graph.js";
+import type { HookManager } from "../../../../types/hooks.js";
 import type { ResolvedFile } from "../../../../types/solidity/resolved-file.js";
 
 import { HardhatError } from "@nomicfoundation/hardhat-errors";
@@ -17,8 +19,28 @@ export async function buildDependencyGraph(
   rootFiles: string[],
   projectRoot: string,
   readFile: (absPath: string) => Promise<string>,
+  hookManager: HookManager,
 ): Promise<DependencyGraphImplementation> {
-  const resolver = await ResolverImplementation.create(projectRoot, readFile);
+  // Create the wrapper function that captures the hook manager
+  const remappingsReader: RemappingsReaderFunction = (
+    packageName,
+    packageVersion,
+    packagePath,
+    defaultBehavior,
+  ) =>
+    hookManager.runHandlerChain(
+      "solidity",
+      "readNpmPackageRemappings",
+      [packageName, packageVersion, packagePath],
+      async (_context, name, version, path) =>
+        defaultBehavior(name, version, path),
+    );
+
+  const resolver = await ResolverImplementation.create(
+    projectRoot,
+    readFile,
+    remappingsReader,
+  );
 
   const dependencyGraph = new DependencyGraphImplementation();
 

package/src/internal/builtin-plugins/solidity/build-system/resolver/dependency-resolver.ts

@@ -38,6 +38,7 @@ import { parseNpmDirectImport } from "./npm-module-parsing.js";
 import {
   isResolvedUserRemapping,
   RemappedNpmPackagesGraphImplementation,
+  type RemappingsReaderFunction,
 } from "./remapped-npm-packages-graph.js";
 import { applyValidRemapping, formatRemapping } from "./remappings.js";
 import {
@@ -86,14 +87,18 @@ export class ResolverImplementation implements Resolver {
    *
    * @param projectRoot The absolute path to the Hardhat project root.
    * @param readUtf8File A function that reads a UTF-8 file.
+   * @param remappingsReader Optional function to read remappings from packages.
    * @returns The resolver or the user remapping errors found.
    */
   public static async create(
     projectRoot: string,
     readUtf8File: (absPath: string) => Promise<string>,
+    remappingsReader?: RemappingsReaderFunction,
   ): Promise<Resolver> {
-    const map =
-      await RemappedNpmPackagesGraphImplementation.create(projectRoot);
+    const map = await RemappedNpmPackagesGraphImplementation.create(
+      projectRoot,
+      remappingsReader,
+    );
 
     return new ResolverImplementation(projectRoot, map, readUtf8File);
   }
@@ -691,6 +696,13 @@ export class ResolverImplementation implements Resolver {
       );
 
     if (dependencyResolution === undefined) {
+      // Check if the from file's package has foundry.toml
+      const foundryTomlPath = path.join(
+        from.package.rootFsPath,
+        "foundry.toml",
+      );
+      const fromHasFoundryToml = await exists(foundryTomlPath);
+
       return {
         success: false,
         error: {
@@ -698,6 +710,7 @@ export class ResolverImplementation implements Resolver {
           fromFsPath: from.fsPath,
           importPath,
           installationName: parsedDirectImport.package,
+          importerPackageHasFoundryToml: fromHasFoundryToml,
         },
       };
     }
@@ -1098,6 +1111,7 @@ export class ResolverImplementation implements Resolver {
           type: RootResolutionErrorType.NPM_ROOT_FILE_OF_UNINSTALLED_PACKAGE,
           npmModule,
           installationName: error.installationName,
+          projectHasFoundryToml: error.importerPackageHasFoundryToml,
         };
       }
       case ImportResolutionErrorType.IMPORT_WITH_REMAPPING_ERRORS: {

package/src/internal/builtin-plugins/solidity/build-system/resolver/error-messages.ts

@@ -57,7 +57,14 @@ Note that the npm module is being remapped by ${formatRemappingReference(error.u
     }
 
     case RootResolutionErrorType.NPM_ROOT_FILE_OF_UNINSTALLED_PACKAGE: {
-      return `The package "${error.installationName}" is not installed.`;
+      const baseMessage = `The package "${error.installationName}" is not installed.`;
+      if (error.projectHasFoundryToml === true) {
+        return `${baseMessage}
+
+Your project has a foundry.toml, and you may need to install the "@nomicfoundation/hardhat-foundry" plugin.
+Learn more about Hardhat's Foundry compatibility here: https://hardhat.org/foundry-compatibility`;
+      }
+      return baseMessage;
     }
 
     case RootResolutionErrorType.NPM_ROOT_FILE_RESOLUTION_WITH_REMAPPING_ERRORS: {
@@ -107,13 +114,13 @@ export function formatImportResolutionError(
     }
 
     case ImportResolutionErrorType.ILLEGAL_RELATIVE_IMPORT: {
-      return "The import has too many '../', and trying to leave its package.";
+      return "The import has too many '../' and is trying to leave its package.";
     }
 
     case ImportResolutionErrorType.RELATIVE_IMPORT_INTO_NODE_MODULES: {
       return `You are trying to import a file from your node_modules directory with its file system path.
 
-You should write your the path of your imports into npm modules just as you would do in JavaScript files.`;
+You should write your imports into npm modules just as you would do in JavaScript files.`;
     }
 
     case ImportResolutionErrorType.IMPORT_WITH_INVALID_NPM_SYNTAX: {
@@ -121,7 +128,14 @@ You should write your the path of your imports into npm modules just as you woul
     }
 
     case ImportResolutionErrorType.IMPORT_OF_UNINSTALLED_PACKAGE: {
-      return `The package "${error.installationName}" is not installed.`;
+      const baseMessage = `The package "${error.installationName}" is not installed.`;
+      if (error.importerPackageHasFoundryToml === true) {
+        return `${baseMessage}
+
+The file importing this package is inside a Foundry project (foundry.toml detected), and you may need to install the "@nomicfoundation/hardhat-foundry" plugin.
+Learn more about Hardhat's Foundry compatibility here: https://hardhat.org/foundry-compatibility`;
+      }
+      return baseMessage;
     }
 
     case ImportResolutionErrorType.IMPORT_WITH_REMAPPING_ERRORS: {
@@ -148,7 +162,7 @@ If you still want to be able to do it, try adding this remapping "${error.sugges
           ? "the package"
           : "the project";
 
-      const message = `The file ${error.packageExportsResolvedSubpath ?? error.subpath} doesn't exist within ${packageOrProject}.`;
+      const message = `The file "${error.packageExportsResolvedSubpath ?? error.subpath}" doesn't exist within ${packageOrProject}.`;
 
       return formatResolutionErrorRemappingsOrPackageExportsNotes({
         message,

package/src/internal/builtin-plugins/solidity/build-system/resolver/remapped-npm-packages-graph.ts

@@ -37,6 +37,17 @@ import { UserRemappingType } from "./types.js";
 
 const HARDHAT_PROJECT_INPUT_SOURCE_NAME_ROOT = "project";
 
+export type RemappingsReaderFunction = (
+  packageName: string,
+  packageVersion: string,
+  packagePath: string,
+  defaultBehavior: (
+    name: string,
+    version: string,
+    path: string,
+  ) => Promise<Array<{ remappings: string[]; source: string }>>,
+) => Promise<Array<{ remappings: string[]; source: string }>>;
+
 export function isResolvedUserRemapping(
   remapping: Remapping | ResolvedUserRemapping,
 ): remapping is ResolvedUserRemapping {
@@ -55,6 +66,11 @@ export class RemappedNpmPackagesGraphImplementation
    */
   readonly #hardhatProjectPackage: ResolvedNpmPackage;
 
+  /**
+   * The remappings reader function to use when reading package remappings.
+   */
+  readonly #remappingsReader: RemappingsReaderFunction;
+
   /**
    * This is a map of all the npm packages. Every package that has been
    * loaded by this class, is present in this map.
@@ -104,6 +120,12 @@ export class RemappedNpmPackagesGraphImplementation
 
   public static async create(
     projectRootPath: string,
+    remappingsReader: RemappingsReaderFunction = (
+      packageName,
+      packageVersion,
+      packagePath,
+      defaultBehavior,
+    ) => defaultBehavior(packageName, packageVersion, packagePath),
   ): Promise<RemappedNpmPackagesGraphImplementation> {
     const projectPackageJson = await readJsonFile<PackageJson>(
       path.join(projectRootPath, "package.json"),
@@ -117,11 +139,18 @@ export class RemappedNpmPackagesGraphImplementation
       inputSourceNameRoot: HARDHAT_PROJECT_INPUT_SOURCE_NAME_ROOT,
     };
 
-    return new RemappedNpmPackagesGraphImplementation(resolvedNpmPackage);
+    return new RemappedNpmPackagesGraphImplementation(
+      resolvedNpmPackage,
+      remappingsReader,
+    );
   }
 
-  private constructor(hardhatProjectPackage: ResolvedNpmPackage) {
+  private constructor(
+    hardhatProjectPackage: ResolvedNpmPackage,
+    remappingsReader: RemappingsReaderFunction,
+  ) {
     this.#hardhatProjectPackage = hardhatProjectPackage;
+    this.#remappingsReader = remappingsReader;
     this.#insertNewPackage(hardhatProjectPackage);
   }
 
@@ -397,41 +426,88 @@ export class RemappedNpmPackagesGraphImplementation
       UserRemappingError[]
     >
   > {
-    const remappingsTxtFiles = await getAllFilesMatching(
+    const allRemappings = await this.#remappingsReader(
+      npmPackage.name,
+      npmPackage.version,
       npmPackage.rootFsPath,
-      (f) => path.basename(f) === "remappings.txt",
-      (f) => !f.endsWith("node_modules"),
+      async (_packageName, _packageVersion, packagePath) =>
+        this.#defaultReadPackageRemappings(packagePath),
     );
 
-    const remappings = [];
-    const errors = [];
+    return this.#parseAndDeduplicateRemappings(npmPackage, allRemappings);
+  }
 
-    for (const remappingsTxtFsPath of remappingsTxtFiles) {
-      const packageRemappingsTxtContents =
-        await readUtf8File(remappingsTxtFsPath);
+  /**
+   * The default behavior of reading all the remappings.txt files in a package.
+   * @param packagePath The fs path to the root of the package.
+   * @returns An array with one entry per remappings.txt file, with the
+   * contents of the file and the fs path to the file.
+   */
+  async #defaultReadPackageRemappings(
+    packagePath: string,
+  ): Promise<Array<{ remappings: string[]; source: string }>> {
+    const remappingsTxtFiles = await getAllFilesMatching(
+      packagePath,
+      (f) => path.basename(f) === "remappings.txt",
+      (f) => !f.endsWith("node_modules"),
+    );
 
-      const rawUserRemappings = packageRemappingsTxtContents
+    const results: Array<{ remappings: string[]; source: string }> = [];
+    for (const file of remappingsTxtFiles) {
+      const contents = await readUtf8File(file);
+      const lines = contents
         .split("\n")
         .map((line) => line.trim())
-        .filter((line) => line !== "")
-        .filter((line) => !line.startsWith("#"));
+        .filter((line) => line !== "" && !line.startsWith("#"));
+      results.push({ remappings: lines, source: file });
+    }
+
+    return results;
+  }
 
-      for (const userRemapping of rawUserRemappings) {
-        const result = await this.#parseUserRemapping(
+  /**
+   * Parses and deduplicates by "context:prefix" all the remappings from the
+   * package.
+   *
+   * @param npmPackage The npm package.
+   * @param allRemappings An array with all the remappings.txt files in the
+   * package and their content.
+   * @returns A result with the parsed and deduplicated remappings, or an error
+   * if there was a problem parsing any of them.
+   */
+  #parseAndDeduplicateRemappings(
+    npmPackage: ResolvedNpmPackage,
+    allRemappings: Array<{ remappings: string[]; source: string }>,
+  ): Result<
+    Array<LocalUserRemapping | UnresolvedNpmUserRemapping>,
+    UserRemappingError[]
+  > {
+    const remappings: Array<LocalUserRemapping | UnresolvedNpmUserRemapping> =
+      [];
+    const errors: UserRemappingError[] = [];
+    const seen = new Set<string>(); // Track by "context:prefix"
+
+    for (const { remappings: remappingStrings, source } of allRemappings) {
+      for (const remappingString of remappingStrings) {
+        const result = this.#parseUserRemapping(
           npmPackage,
-          remappingsTxtFsPath,
-          userRemapping,
+          source,
+          remappingString,
         );
 
         if (!result.success) {
           errors.push(result.error);
-        } else {
-          // If parsing returned `undefined`, it means that it should be
-          // ignored.
-          if (result.value === undefined) {
-            continue;
-          }
+          continue;
+        }
+
+        if (result.value === undefined) {
+          continue;
+        }
 
+        // Deduplicate by (context + prefix) - first occurrence wins
+        const key = `${result.value.context}:${result.value.prefix}`;
+        if (!seen.has(key)) {
+          seen.add(key);
           remappings.push(result.value);
         }
       }
@@ -454,15 +530,13 @@ export class RemappedNpmPackagesGraphImplementation
    * @returns The parsed user remapping, or undefined if it should be ignored.
    * If the parsing and validation fails, an error is returned.
    */
-  async #parseUserRemapping(
+  #parseUserRemapping(
     npmPackage: ResolvedNpmPackage,
     sourceOfTheRemapping: string,
     remappingString: string,
-  ): Promise<
-    Result<
-      LocalUserRemapping | UnresolvedNpmUserRemapping | undefined,
-      UserRemappingError
-    >
+  ): Result<
+    LocalUserRemapping | UnresolvedNpmUserRemapping | undefined,
+    UserRemappingError
   > {
     // We first parse the remapping string and validate that it doesn't have
     // a context starting with `npm/`, and that the prefix and targets end in /.

package/src/internal/builtin-plugins/solidity/type-extensions.ts

@@ -242,5 +242,33 @@ declare module "../../../types/hooks.js" {
         nextSolcConfig: SolcConfig,
       ) => Promise<CompilerOutput>,
     ): Promise<CompilerOutput>;
+
+    /**
+     * Provide a handler for this hook to supply remappings for npm packages.
+     *
+     * This hook is called when the resolver needs to read remappings for a package.
+     * Handlers can provide remappings from alternative sources (e.g., foundry.toml)
+     * in addition to the default remappings.txt files.
+     *
+     * @param context The hook context.
+     * @param packageName The name of the npm package.
+     * @param packageVersion The version of the npm package.
+     * @param packagePath The absolute filesystem path to the package root.
+     * @param next A function to get remappings from other sources (including default behavior).
+     * @returns An array of remapping sources, each containing an array of remapping strings
+     *   and the source path they came from.
+     */
+    readNpmPackageRemappings: (
+      context: HookContext,
+      packageName: string,
+      packageVersion: string,
+      packagePath: string,
+      next: (
+        nextContext: HookContext,
+        nextPackageName: string,
+        nextPackageVersion: string,
+        nextPackagePath: string,
+      ) => Promise<Array<{ remappings: string[]; source: string }>>,
+    ) => Promise<Array<{ remappings: string[]; source: string }>>;
   }
 }

package/src/internal/builtin-plugins/solidity-test/config.ts

@@ -44,6 +44,7 @@ const solidityTestUserConfigType = z.object({
   coinbase: z.string().startsWith("0x").optional(),
   blockTimestamp: z.bigint().optional(),
   prevRandao: z.bigint().optional(),
+  gasLimit: z.bigint().optional(),
   blockGasLimit: z.bigint().or(z.literal(false)).optional(),
   fuzz: z
     .object({

package/src/internal/builtin-plugins/solidity-test/type-extensions.ts

@@ -35,6 +35,7 @@ declare module "../../../types/test.js" {
     coinbase?: string; // 0x-prefixed hex string
     blockTimestamp?: bigint;
     prevRandao?: bigint;
+    gasLimit?: bigint;
     blockGasLimit?: bigint | false;
 
     fuzz?: {