hardhat 3.1.9 → 3.1.11

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

@@ -7,13 +7,13 @@ import type {
   ResolvedUserRemapping,
   UnresolvedNpmUserRemapping,
   RemappedNpmPackagesGraphJson,
-  Result,
 } from "./types.js";
 import type {
   ResolvedFile,
   ResolvedNpmPackage,
   UserRemappingError,
 } from "../../../../../types/solidity.js";
+import type { Result } from "../../../../../types/utils.js";
 
 import path from "node:path";
 
@@ -37,6 +37,43 @@ import { UserRemappingType } from "./types.js";
 
 const HARDHAT_PROJECT_INPUT_SOURCE_NAME_ROOT = "project";
 
+/**
+ * Returns a normalized version of the path if it refers to a node_modules in
+ * the root directory (i.e. node_modules/...), or a `node_modules` directory
+ * in a parent directory (i.e. ../../node_modules/...).
+ *
+ * Otherwise returns `undefined`.
+ *
+ * @param pathToNormalize The path to normalize.
+ * @returns The normalized path (node_modules/...), or `undefined`.
+ */
+export function getNormalizeNodeModulesPath(
+  pathToNormalize: string,
+): string | undefined {
+  if (pathToNormalize.startsWith("node_modules/")) {
+    return pathToNormalize;
+  }
+
+  const normalized = path.posix.normalize(pathToNormalize);
+
+  if (!/^(?:\.\.\/)*node_modules\//.test(normalized)) {
+    return undefined;
+  }
+
+  return normalized.substring(normalized.indexOf("node_modules/"));
+}
+
+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 +92,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 +146,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 +165,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 +452,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 });
+    }
 
-      for (const userRemapping of rawUserRemappings) {
-        const result = await this.#parseUserRemapping(
+    return results;
+  }
+
+  /**
+   * 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 +556,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 /.
@@ -485,7 +585,7 @@ export class RemappedNpmPackagesGraphImplementation
     const prefix = remapping.prefix.endsWith("/")
       ? remapping.prefix
       : remapping.prefix + "/";
-    const target = remapping.target.endsWith("/")
+    let target = remapping.target.endsWith("/")
       ? remapping.target
       : remapping.target + "/";
 
@@ -494,12 +594,13 @@ export class RemappedNpmPackagesGraphImplementation
       path.dirname(sourceOfTheRemapping),
     );
 
-    // If the remapping's target starts with `node_modules/`, we treat
-    // it as trying to load an npm dependency, otherwise we treat it as a local
+    // If the remapping's target starts with `node_modules/`, we treat it as
+    // trying to load an npm dependency, otherwise we treat it as a local
     // remapping.
+    const normalizedNodeModulesTarget = getNormalizeNodeModulesPath(target);
 
     // Local remapping case
-    if (!target.startsWith("node_modules/")) {
+    if (normalizedNodeModulesTarget === undefined) {
       return {
         success: true,
         value: {
@@ -519,6 +620,9 @@ export class RemappedNpmPackagesGraphImplementation
           source: sourceOfTheRemapping,
         },
       };
+    } else {
+      // We update the target to the normalized version
+      target = normalizedNodeModulesTarget;
     }
 
     // If we are here the remapping is a npm remapping.
@@ -526,7 +630,7 @@ export class RemappedNpmPackagesGraphImplementation
     const targetWithoutNodeModules = target.substring("node_modules/".length);
 
     // If after doing that the prefix and target are the same, we skip it
-    // so that it doesn't even go unnecesarly go through a user remapping.
+    // so that it doesn't even go unnecessarily go through a user remapping.
     if (prefix === targetWithoutNodeModules) {
       return { success: true, value: undefined };
     }

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

@@ -10,13 +10,7 @@ import type {
   ResolvedFile,
   ResolvedNpmPackage,
 } from "../../../../../types/solidity/resolved-file.js";
-
-/**
- * A result that can either have a value or an error.
- */
-export type Result<ValueT, ErrorT> =
-  | { readonly success: true; readonly value: ValueT }
-  | { readonly success: false; readonly error: ErrorT };
+import type { Result } from "../../../../../types/utils.js";
 
 /**
  * A solc remapping.
@@ -96,7 +90,7 @@ export type InstallationName = string;
 
 /**
  * This interface represents a graph of all the npm packages that the Hardhat
- * project uses, including the Hardhat projecct itself, and their remappings.
+ * project uses, including the Hardhat project itself, and their remappings.
  *
  * This class guarantees that there's a single instance of any npm package per
  * each version. That means that, even if you have multiple installations of
@@ -109,7 +103,7 @@ export type InstallationName = string;
  * than expected, because:
  *  - Processing a remapping may require loading a new npm package, and this
  *    interface ensures its uniqueness.
- *  - Loading an npm package requires processing its remappigns.
+ *  - Loading an npm package requires processing its remappings.
  *  - Selecting the best user remapping for an import can require processing it
  *    and loading its npm package.
  *

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

@@ -1,5 +1,5 @@
-import type { Result } from "./types.js";
 import type { ResolvedNpmPackage } from "../../../../../types/solidity.js";
+import type { Result } from "../../../../../types/utils.js";
 
 import { assertHardhatInvariant } from "@nomicfoundation/hardhat-errors";
 import { ensureError } from "@nomicfoundation/hardhat-utils/error";

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

@@ -18,19 +18,17 @@ export class SolcConfigSelector {
 
   /**
    * Creates a new SolcConfigSelector that can be used to select the best solc
-   * configuration for subgraphs of the given dependency graph.
+   * configuration for single-root subgraphs to create their respective
+   * individual compilation jobs.
    *
-   * All the queries are done in the context of the given dependency graph, and
-   * using the same build profile.
+   * All the queries use the same build profile.
    *
    * @param buildProfileName The name of the build profile to use.
    * @param buildProfile  The build profile config.
-   * @param _dependencyGraph The entire dependency graph of the project.
    */
   constructor(
     buildProfileName: string,
     buildProfile: SolidityBuildProfileConfig,
-    _dependencyGraph: DependencyGraph,
   ) {
     this.#buildProfileName = buildProfileName;
     this.#buildProfile = buildProfile;
@@ -46,7 +44,7 @@ export class SolcConfigSelector {
    */
   public selectBestSolcConfigForSingleRootGraph(
     subgraph: DependencyGraph,
-  ): SolcConfig | CompilationJobCreationError {
+  ): { success: true; config: SolcConfig } | CompilationJobCreationError {
     const roots = subgraph.getRoots();
 
     assertHardhatInvariant(
@@ -56,11 +54,11 @@ export class SolcConfigSelector {
 
     const [userSourceName, root] = [...roots.entries()][0];
 
-    const allVersionPragamas = [...subgraph.getAllFiles()]
+    const allVersionPragmas = [...subgraph.getAllFiles()]
       .map(({ content }) => content.versionPragmas)
       .flat(1);
 
-    const versionRange = Array.from(new Set(allVersionPragamas)).join(" ");
+    const versionRange = Array.from(new Set(allVersionPragmas)).join(" ");
 
     const overriddenCompiler = this.#buildProfile.overrides[userSourceName];
 
@@ -75,7 +73,7 @@ export class SolcConfigSelector {
         );
       }
 
-      return overriddenCompiler;
+      return { success: true, config: overriddenCompiler };
     }
 
     // if there's no override, we find a compiler that matches the version range
@@ -100,9 +98,21 @@ export class SolcConfigSelector {
       `Matching config not found for version '${matchingVersion.toString()}'`,
     );
 
-    return matchingConfig;
+    return { success: true, config: matchingConfig };
   }
 
+  /**
+   * Returns a description of why we couldn't get a compiler configuration for
+   * the given root file and dependency subgraph.
+   *
+   * @param root The root file that created the single-root dependency subgraph
+   * @param dependencyGraph The dependency subgraph we couldn't get a compiler
+   *   configuration for
+   * @param compilerVersions The compiler versions that are configured for the
+   *   selected build profile. For overridden roots, it's a single one.
+   * @param overridden True if the root has an overridden config.
+   * @returns The error why we couldn't get a compiler configuration.
+   */
   #getCompilationJobCreationError(
     root: ResolvedFile,
     dependencyGraph: DependencyGraph,
@@ -110,27 +120,70 @@ export class SolcConfigSelector {
     overridden: boolean,
   ): CompilationJobCreationError {
     const rootVersionRange = root.content.versionPragmas.join(" ");
-    if (maxSatisfying(compilerVersions, rootVersionRange) === null) {
-      let reason: CompilationJobCreationErrorReason;
-      let formattedReason: string;
-      if (overridden) {
-        reason =
-          CompilationJobCreationErrorReason.INCOMPATIBLE_OVERRIDDEN_SOLC_VERSION;
-        formattedReason = `An override with incompatible solc version was found for this file.`;
-      } else {
-        reason =
-          CompilationJobCreationErrorReason.NO_COMPATIBLE_SOLC_VERSION_WITH_ROOT;
-        formattedReason = `No solc version enabled in this profile is compatible with this file.`;
+
+    // This logic is pretty different depending if we are dealing with a config
+    // override or not. If we are, we have a single compiler option, so things
+    // are simpler.
+
+    if (overridden) {
+      // The root may not be compatible with the override version
+      if (maxSatisfying(compilerVersions, rootVersionRange) === null) {
+        return {
+          success: false,
+          reason:
+            CompilationJobCreationErrorReason.INCOMPATIBLE_OVERRIDDEN_SOLC_VERSION,
+          rootFilePath: root.fsPath,
+          buildProfile: this.#buildProfileName,
+          formattedReason: `An override with incompatible solc version was found for this file.`,
+        };
       }
 
+      // A transitive dependency can have a pragma that's incompatible with
+      // the overridden version.
+      for (const transitiveDependency of this.#getTransitiveDependencies(
+        root,
+        dependencyGraph,
+      )) {
+        const depOwnRange =
+          transitiveDependency.dependency.content.versionPragmas.join(" ");
+
+        if (maxSatisfying(compilerVersions, depOwnRange) === null) {
+          return {
+            success: false,
+            reason:
+              CompilationJobCreationErrorReason.OVERRIDDEN_SOLC_VERSION_INCOMPATIBLE_WITH_DEPENDENCY,
+            rootFilePath: root.fsPath,
+            buildProfile: this.#buildProfileName,
+            incompatibleImportPath: transitiveDependency.fsPath,
+            formattedReason: `The compiler version override is incompatible with a dependency of this file:\n  * ${shortenPath(root.fsPath)}\n  * ${transitiveDependency.fsPath.map((s) => shortenPath(s)).join("\n  * ")}`,
+          };
+        }
+      }
+
+      // There's no other case. If the root and all the dependencies are
+      // compatible, and we still can choose a version, we have a bug.
+      /* c8 ignore next 5 */
+      assertHardhatInvariant(
+        false,
+        "Trying to get the error for an overridden solidity file that has no compatible config, but failed to detect it, as the root and all the dependencies are compatible with the overridden compiler config.",
+      );
+    }
+
+    // Non-overridden case: we first check if the root is compatible with any
+    // configured compiler
+    if (maxSatisfying(compilerVersions, rootVersionRange) === null) {
       return {
-        reason,
+        success: false,
+        reason:
+          CompilationJobCreationErrorReason.NO_COMPATIBLE_SOLC_VERSION_WITH_ROOT,
         rootFilePath: root.fsPath,
         buildProfile: this.#buildProfileName,
-        formattedReason,
+        formattedReason: `No solc version enabled in this profile is compatible with this file.`,
       };
     }
 
+    // We check all the transitive dependencies of the root to try to return
+    // the most specific error that we can.
     for (const transitiveDependency of this.#getTransitiveDependencies(
       root,
       dependencyGraph,
@@ -140,21 +193,59 @@ export class SolcConfigSelector {
           .map((pragmas) => pragmas.join(" "))
           .join(" ");
 
+      const depOwnRange =
+        transitiveDependency.dependency.content.versionPragmas.join(" ");
+
+      // A transitive dependency can have a pragma that's incompatible with
+      // all the configured compilers
+      if (maxSatisfying(compilerVersions, depOwnRange) === null) {
+        return {
+          success: false,
+          reason:
+            CompilationJobCreationErrorReason.NO_COMPATIBLE_SOLC_VERSION_WITH_DEPENDENCY,
+          rootFilePath: root.fsPath,
+          buildProfile: this.#buildProfileName,
+          incompatibleImportPath: transitiveDependency.fsPath,
+          formattedReason: `No solc version enabled in this profile is compatible with a dependency of this file:\n  * ${shortenPath(root.fsPath)}\n  * ${transitiveDependency.fsPath.map((s) => shortenPath(s)).join("\n  * ")}`,
+        };
+      }
+
+      // The root and the version ranges to get to this transitive dependency
+      // may be contradictory, so no version ever can satisfy them.
       if (!intersects(rootVersionRange, transitiveDependencyVersionRange)) {
         return {
+          success: false,
           reason: CompilationJobCreationErrorReason.IMPORT_OF_INCOMPATIBLE_FILE,
           rootFilePath: root.fsPath,
           buildProfile: this.#buildProfileName,
           incompatibleImportPath: transitiveDependency.fsPath,
-          formattedReason: `Following these imports leads to an incompatible solc version pragma that no version can satisfy:
-  * ${shortenPath(root.fsPath)}
-  * ${transitiveDependency.fsPath.map((s) => shortenPath(s)).join("\n  * ")}
-`,
+          formattedReason: `Following these imports leads to an incompatible solc version pragma that no version can satisfy:\n  * ${shortenPath(root.fsPath)}\n  * ${transitiveDependency.fsPath.map((s) => shortenPath(s)).join("\n  * ")}`,
+        };
+      }
+
+      // The root and the version ranges to get to this transitive dependency
+      // may not be compatible with any configured compiler.
+      const combinedRange = `${rootVersionRange} ${transitiveDependencyVersionRange}`;
+      if (maxSatisfying(compilerVersions, combinedRange) === null) {
+        return {
+          success: false,
+          reason:
+            CompilationJobCreationErrorReason.NO_COMPATIBLE_SOLC_VERSION_FOR_TRANSITIVE_IMPORT_PATH,
+          rootFilePath: root.fsPath,
+          buildProfile: this.#buildProfileName,
+          incompatibleImportPath: transitiveDependency.fsPath,
+          formattedReason: `No solc version enabled in this profile is compatible with this file and this import path:\n  * ${shortenPath(root.fsPath)}\n  * ${transitiveDependency.fsPath.map((s) => shortenPath(s)).join("\n  * ")}`,
         };
       }
     }
 
+    // This is a generic case that can happen when the incompatibilities exist
+    // but we can't detect them with the above algorithm. For example, if a
+    // root imports two compatible dependencies that are incompatible with each
+    // other. We could try and improve this error message, but it's
+    // computationally expensive and hard to express to the users.
     return {
+      success: false,
       reason:
         CompilationJobCreationErrorReason.NO_COMPATIBLE_SOLC_VERSION_FOUND,
       rootFilePath: root.fsPath,
@@ -163,6 +254,12 @@ export class SolcConfigSelector {
     };
   }
 
+  /**
+   * Returns a generator of all the transitive dependencies of a root file. For each
+   * dependency, it yields the sequence of fsPaths from the root to that dependency,
+   * along with the corresponding version pragma paths for each file in the import chain.
+   * The paths don't include the root itself.
+   */
   *#getTransitiveDependencies(
     root: ResolvedFile,
     dependencyGraph: DependencyGraph,
@@ -179,7 +276,7 @@ export class SolcConfigSelector {
         continue;
       }
 
-      visited.add(file);
+      visited = new Set([...visited, file]);
 
       yield {
         fsPath: [file.fsPath],

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

@@ -124,7 +124,7 @@ const buildProfilesSolidityUserConfigType = commonSolidityUserConfigType.extend(
   },
 );
 
-const soldityUserConfigType = conditionalUnionType(
+const solidityUserConfigType = conditionalUnionType(
   [
     [(data) => typeof data === "string", z.string()],
     [(data) => Array.isArray(data), z.array(z.string()).nonempty()],
@@ -159,7 +159,7 @@ const userConfigType = z.object({
       ).optional(),
     })
     .optional(),
-  solidity: soldityUserConfigType.optional(),
+  solidity: solidityUserConfigType.optional(),
 });
 
 export function validateSolidityUserConfig(

package/src/internal/builtin-plugins/solidity/hook-handlers/hre.ts

@@ -46,6 +46,14 @@ class LazySolidityBuildSystem implements SolidityBuildSystem {
     return buildSystem.getScope(fsPath);
   }
 
+  public isSuccessfulBuildResult(
+    buildResult: CompilationJobCreationError | Map<string, FileBuildResult>,
+  ): buildResult is Map<string, FileBuildResult> {
+    // Note: This duplicates the logic of the actual implementation because it's
+    // a synchronous method, so we can't import the implementation.
+    return buildResult instanceof Map;
+  }
+
   public async build(
     rootFiles: string[],
     options?: BuildOptions,

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

@@ -110,7 +110,7 @@ async function buildForScope(
     scope,
   });
 
-  throwIfSolidityBuildFailed(results);
+  throwIfSolidityBuildFailed(solidity, results);
 
   // If we recompiled the entire project we cleanup the artifacts
   if (isFullCompilation) {

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/edr-artifacts.ts

@@ -60,7 +60,7 @@ export async function getBuildInfos(
  */
 export async function getEdrArtifacts(
   artifactManager: ArtifactManager,
-): Promise<Array<{ edrAtifact: EdrArtifact; userSourceName: string }>> {
+): Promise<Array<{ edrArtifact: EdrArtifact; userSourceName: string }>> {
   const fullyQualifiedNames = await artifactManager.getAllFullyQualifiedNames();
 
   const artifacts = await Promise.all(
@@ -140,7 +140,7 @@ export async function getEdrArtifacts(
     // from an artifact id between the `run` call and the events emitted by the
     // test runner.
     return {
-      edrAtifact: {
+      edrArtifact: {
         id,
         contract,
       },