hardhat 3.1.9 → 3.1.10

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?: {

package/src/internal/cli/error-handler.ts

@@ -5,6 +5,7 @@ import {
 import chalk from "chalk";
 
 import { HARDHAT_NAME, HARDHAT_WEBSITE_URL } from "../constants.js";
+import { UsingHardhat2PluginError } from "../using-hardhat2-plugin-errors.js";
 
 /**
  * The different categories of errors that can be handled by hardhat cli.
@@ -69,6 +70,11 @@ export function printErrorMessages(
   shouldShowStackTraces: boolean = false,
   print: (message: string | Error) => void = console.error,
 ): void {
+  if (error instanceof UsingHardhat2PluginError) {
+    printUsingHardhat2Error(error, print);
+    return;
+  }
+
   const showStackTraces =
     shouldShowStackTraces ||
     getErrorWithCategory(error).category === ErrorCategory.OTHER;
@@ -146,3 +152,15 @@ function getErrorMessages(error: Error): ErrorMessages {
       };
   }
 }
+function printUsingHardhat2Error(
+  error: UsingHardhat2PluginError,
+  print: (message: string | Error) => void = console.error,
+): void {
+  print(chalk.red.bold(`Hardhat 3 installation error:`));
+  print("");
+  if (error.callerRelativePath !== undefined) {
+    print(error.message);
+  } else {
+    print(error.stack);
+  }
+}

package/src/internal/cli/telemetry/sentry/reporter.ts

@@ -8,6 +8,7 @@ import {
   ProviderError,
   UnknownError,
 } from "../../../builtin-plugins/network-manager/provider-errors.js";
+import { UsingHardhat2PluginError } from "../../../using-hardhat2-plugin-errors.js";
 import { getHardhatVersion } from "../../../utils/package.js";
 import { isTelemetryAllowed } from "../telemetry-permissions.js";
 
@@ -134,6 +135,10 @@ class Reporter {
       return false;
     }
 
+    if (error instanceof UsingHardhat2PluginError) {
+      return false;
+    }
+
     if (HardhatPluginError.isHardhatPluginError(error)) {
       // Don't log errors from third-party plugins
       return false;

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

@@ -18,9 +18,9 @@ import {
 } from "../../types/arguments.js";
 import {
   type EmptyTaskDefinition,
+  TaskDefinitionType,
   type NewTaskDefinition,
   type TaskDefinition,
-  TaskDefinitionType,
   type TaskOverrideDefinition,
 } from "../../types/tasks.js";
 
@@ -185,6 +185,7 @@ function validatePath(
 export function validateTasksConfig(
   tasks: TaskDefinition[],
   path: Array<string | number> = [],
+  isPlugin: boolean = false,
 ): HardhatUserConfigValidationError[] {
   const validationErrors: HardhatUserConfigValidationError[] = [];
 
@@ -207,13 +208,13 @@ export function validateTasksConfig(
       }
       case TaskDefinitionType.NEW_TASK: {
         validationErrors.push(
-          ...validateNewTask(task, [...path, "tasks", index]),
+          ...validateNewTask(task, [...path, "tasks", index], isPlugin),
         );
         break;
       }
       case TaskDefinitionType.TASK_OVERRIDE: {
         validationErrors.push(
-          ...validateTaskOverride(task, [...path, "tasks", index]),
+          ...validateTaskOverride(task, [...path, "tasks", index], isPlugin),
         );
         break;
       }
@@ -252,6 +253,7 @@ export function validateEmptyTask(
 export function validateNewTask(
   task: NewTaskDefinition,
   path: Array<string | number>,
+  isPlugin: boolean = false,
 ): HardhatUserConfigValidationError[] {
   const validationErrors: HardhatUserConfigValidationError[] = [];
 
@@ -272,13 +274,7 @@ export function validateNewTask(
     });
   }
 
-  if (typeof task.action !== "function") {
-    validationErrors.push({
-      path: [...path, "action"],
-      message:
-        "task action must be a lazy import function returning a module with a default export",
-    });
-  }
+  validationErrors.push(...validateActionFields(task, path, isPlugin));
 
   if (isObject(task.options)) {
     validationErrors.push(
@@ -308,6 +304,7 @@ export function validateNewTask(
 export function validateTaskOverride(
   task: TaskOverrideDefinition,
   path: Array<string | number>,
+  isPlugin: boolean = false,
 ): HardhatUserConfigValidationError[] {
   const validationErrors: HardhatUserConfigValidationError[] = [];
 
@@ -328,13 +325,7 @@ export function validateTaskOverride(
     });
   }
 
-  if (typeof task.action !== "function") {
-    validationErrors.push({
-      path: [...path, "action"],
-      message:
-        "task action must be a lazy import function returning a module with a default export",
-    });
-  }
+  validationErrors.push(...validateActionFields(task, path, isPlugin));
 
   if (isObject(task.options)) {
     validationErrors.push(
@@ -350,6 +341,60 @@ export function validateTaskOverride(
   return validationErrors;
 }
 
+function validateActionFields(
+  task: { action?: unknown; inlineAction?: unknown },
+  path: Array<string | number>,
+  isPlugin: boolean = false,
+): HardhatUserConfigValidationError[] {
+  const validationErrors: HardhatUserConfigValidationError[] = [];
+
+  // Mutual exclusivity: cannot have both action and inlineAction
+  if (task.action !== undefined && task.inlineAction !== undefined) {
+    validationErrors.push({
+      path: [...path],
+      message: 'task cannot define both "action" and "inlineAction"',
+    });
+  }
+
+  if (isPlugin && task.inlineAction !== undefined) {
+    validationErrors.push({
+      path: [...path, "inlineAction"],
+      message:
+        "plugins cannot use inline actions. Use a lazy action import instead",
+    });
+  }
+
+  // At least one action must be defined
+  if (task.action === undefined && task.inlineAction === undefined) {
+    validationErrors.push({
+      path: [...path, "action"],
+      message: 'task must define either "action" or "inlineAction"',
+    });
+  }
+
+  if (task.action !== undefined) {
+    if (typeof task.action !== "function") {
+      validationErrors.push({
+        path: [...path, "action"],
+        message:
+          "task action must be a lazy import function returning a module with a default export",
+      });
+    }
+  }
+
+  if (task.inlineAction !== undefined) {
+    if (typeof task.inlineAction !== "function") {
+      validationErrors.push({
+        path: [...path, "inlineAction"],
+        message:
+          "task inlineAction must be a function implementing the task's behavior",
+      });
+    }
+  }
+
+  return validationErrors;
+}
+
 export function validateOptions(
   options: Record<string, OptionDefinition>,
   path: Array<string | number>,
@@ -665,7 +710,11 @@ export function validatePluginsConfig(
     if (plugin.tasks !== undefined) {
       if (Array.isArray(plugin.tasks)) {
         validationErrors.push(
-          ...validateTasksConfig(plugin.tasks, [...path, "plugins", index]),
+          ...validateTasksConfig(
+            plugin.tasks,
+            [...path, "plugins", index],
+            true,
+          ),
         );
       } else {
         validationErrors.push({