hardhat 3.1.9 → 3.1.11

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-results.ts

@@ -2,6 +2,7 @@ import type {
   CompilationJobCreationError,
   FailedFileBuildResult,
   FileBuildResult,
+  SolidityBuildSystem,
 } from "../../../types/solidity.js";
 
 import { HardhatError } from "@nomicfoundation/hardhat-errors";
@@ -22,9 +23,10 @@ type SuccessfulSolidityBuildResults = Map<
  * job failed.
  */
 export function throwIfSolidityBuildFailed(
+  solidity: SolidityBuildSystem,
   results: SolidityBuildResults,
 ): asserts results is SuccessfulSolidityBuildResults {
-  if ("reason" in results) {
+  if (!solidity.isSuccessfulBuildResult(results)) {
     throw new HardhatError(
       HardhatError.ERRORS.CORE.SOLIDITY.COMPILATION_JOB_CREATION_ERROR,
       {

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

@@ -208,6 +208,12 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
     }
   }
 
+  public isSuccessfulBuildResult(
+    buildResult: CompilationJobCreationError | Map<string, FileBuildResult>,
+  ): buildResult is Map<string, FileBuildResult> {
+    return buildResult instanceof Map;
+  }
+
   public async build(
     rootFilePaths: string[],
     _options?: BuildOptions,
@@ -244,7 +250,7 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
       options,
     );
 
-    if ("reason" in compilationJobsResult) {
+    if (!compilationJobsResult.success) {
       return compilationJobsResult;
     }
 
@@ -418,6 +424,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(
@@ -429,7 +436,6 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
     const solcConfigSelector = new SolcConfigSelector(
       buildProfileName,
       buildProfile,
-      dependencyGraph,
     );
 
     let subgraphsWithConfig: Array<
@@ -445,11 +451,11 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
       const configOrError =
         solcConfigSelector.selectBestSolcConfigForSingleRootGraph(subgraph);
 
-      if ("reason" in configOrError) {
+      if (!configOrError.success) {
         return configOrError;
       }
 
-      subgraphsWithConfig.push([configOrError, subgraph]);
+      subgraphsWithConfig.push([configOrError.config, subgraph]);
     }
 
     // get longVersion and isWasm from the compiler for each version
@@ -631,7 +637,12 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
       }
     }
 
-    return { compilationJobsPerFile, indexedIndividualJobs, cacheHits };
+    return {
+      success: true,
+      compilationJobsPerFile,
+      indexedIndividualJobs,
+      cacheHits,
+    };
   }
 
   #getBuildProfile(buildProfileName: string = DEFAULT_BUILD_PROFILE) {

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

@@ -66,7 +66,7 @@ async function spawnCompile(
       );
 
       const stdoutPipeline = subprocess.stdout.pipe(stdoutWriteStream);
-      // NOTE: Compiler warnings are NOT written to stder, they are returned via
+      // NOTE: Compiler warnings are NOT written to stderr, they are returned via
       // the `errors` field of the CompilerOutput instead
       const stderrPipeline = subprocess.stderr.pipe(
         createNonClosingWriter(process.stderr),

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

@@ -152,12 +152,8 @@ export class CompilerDownloaderImplementation implements CompilerDownloader {
   readonly #platform: CompilerPlatform;
   readonly #compilersDir: string;
   readonly #downloadFunction: typeof download;
+  readonly #mutexCompilerList: MultiProcessMutex;
 
-  readonly #mutexCompilerList = new MultiProcessMutex("compiler-download-list");
-
-  /**
-   * Use CompilerDownloader.getConcurrencySafeDownloader instead
-   */
   constructor(
     platform: CompilerPlatform,
     compilersDir: string,
@@ -165,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;
   }
 
@@ -204,7 +203,9 @@ export class CompilerDownloaderImplementation implements CompilerDownloader {
     // 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(`compiler-download-${version}`);
+    const mutex = new MultiProcessMutex(
+      path.join(this.#compilersDir, `compiler-download-${version}`),
+    );
 
     return mutex.use(async () => {
       const isCompilerDownloaded = await this.isCompilerDownloaded(version);

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/dependency-graph.ts

@@ -25,7 +25,7 @@ export class DependencyGraphImplementation implements DependencyGraph {
 
   /**
    * Adds a root file to the graph. All the roots of the dependency graph must
-   * be added before any dependencry.
+   * be added before any dependency.
    *
    * @param userSourceName The source name used to identify the file, as it
    * would appear in the artifacts and used by the user. This is not always the

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

@@ -4,7 +4,6 @@ import type {
   Remapping,
   ResolvedNpmUserRemapping,
   ResolvedUserRemapping,
-  Result,
 } from "./types.js";
 import type {
   ImportResolutionError,
@@ -20,6 +19,7 @@ import type {
   ProjectResolvedFile,
   NpmPackageResolvedFile,
 } from "../../../../../types/solidity/resolved-file.js";
+import type { Result } from "../../../../../types/utils.js";
 
 import path from "node:path";
 
@@ -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,