hardhat 3.2.0 → 3.3.0

package/src/internal/builtin-plugins/network-manager/request-handlers/handlers-array.ts

@@ -8,13 +8,20 @@ import { numberToHexString } from "@nomicfoundation/hardhat-utils/hex";
 
 import { isHttpNetworkHdAccountsConfig } from "../type-validation.js";
 
+import { AutomaticSenderHandler } from "./handlers/accounts/automatic-sender-handler.js";
+import { FixedSenderHandler } from "./handlers/accounts/fixed-sender-handler.js";
+import { HDWalletHandler } from "./handlers/accounts/hd-wallet-handler.js";
+import { LocalAccountsHandler } from "./handlers/accounts/local-accounts.js";
+import { ChainIdValidatorHandler } from "./handlers/chain-id/chain-id-handler.js";
+import { AutomaticGasHandler } from "./handlers/gas/automatic-gas-handler.js";
+import { AutomaticGasPriceHandler } from "./handlers/gas/automatic-gas-price-handler.js";
+import { FixedGasHandler } from "./handlers/gas/fixed-gas-handler.js";
+import { FixedGasPriceHandler } from "./handlers/gas/fixed-gas-price-handler.js";
+
 /**
  * This function returns an handlers array based on the values in the NetworkConnection and NetworkConfig.
  * The order of the handlers, if all are present, is: chain handler, gas handlers (gasPrice first, then gas), sender handler and accounts handler.
  * The order is important to get a correct result when the handlers are executed.
- * The handlers are imported dynamically because some might take a long time to load.
- * Out of the currently supported handlers, LocalAccountsHandler and, consequently, HDWalletHandler have been identified as the most expensive.
- * See https://github.com/NomicFoundation/hardhat/pull/6481 for more details.
  */
 export async function createHandlersArray<
   ChainTypeT extends ChainType | string,
@@ -24,9 +31,6 @@ export async function createHandlersArray<
   const networkConfig = networkConnection.networkConfig;
 
   if (networkConfig.type === "http" && networkConfig.chainId !== undefined) {
-    const { ChainIdValidatorHandler } = await import(
-      "./handlers/chain-id/chain-id-handler.js"
-    );
     requestHandlers.push(
       new ChainIdValidatorHandler(
         networkConnection.provider,
@@ -39,9 +43,6 @@ export async function createHandlersArray<
     networkConfig.gasPrice === undefined ||
     networkConfig.gasPrice === "auto"
   ) {
-    const { AutomaticGasPriceHandler } = await import(
-      "./handlers/gas/automatic-gas-price-handler.js"
-    );
     // If you use a hook handler that signs locally, you are required to
     // have all the transaction fields available, including the
     // gasPrice / maxFeePerGas & maxPriorityFeePerGas.
@@ -56,18 +57,12 @@ export async function createHandlersArray<
       new AutomaticGasPriceHandler(networkConnection.provider),
     );
   } else {
-    const { FixedGasPriceHandler } = await import(
-      "./handlers/gas/fixed-gas-price-handler.js"
-    );
     requestHandlers.push(
       new FixedGasPriceHandler(numberToHexString(networkConfig.gasPrice)),
     );
   }
 
   if (networkConfig.gas === undefined || networkConfig.gas === "auto") {
-    const { AutomaticGasHandler } = await import(
-      "./handlers/gas/automatic-gas-handler.js"
-    );
     requestHandlers.push(
       new AutomaticGasHandler(
         networkConnection.provider,
@@ -75,25 +70,16 @@ export async function createHandlersArray<
       ),
     );
   } else {
-    const { FixedGasHandler } = await import(
-      "./handlers/gas/fixed-gas-handler.js"
-    );
     requestHandlers.push(
       new FixedGasHandler(numberToHexString(networkConfig.gas)),
     );
   }
 
   if (networkConfig.from === undefined) {
-    const { AutomaticSenderHandler } = await import(
-      "./handlers/accounts/automatic-sender-handler.js"
-    );
     requestHandlers.push(
       new AutomaticSenderHandler(networkConnection.provider),
     );
   } else {
-    const { FixedSenderHandler } = await import(
-      "./handlers/accounts/fixed-sender-handler.js"
-    );
     requestHandlers.push(
       new FixedSenderHandler(networkConnection.provider, networkConfig.from),
     );
@@ -103,9 +89,6 @@ export async function createHandlersArray<
     const accounts = networkConfig.accounts;
 
     if (Array.isArray(accounts)) {
-      const { LocalAccountsHandler } = await import(
-        "./handlers/accounts/local-accounts.js"
-      );
       const resolvedAccounts = await Promise.all(
         accounts.map((acc) => acc.getHexString()),
       );
@@ -114,9 +97,6 @@ export async function createHandlersArray<
         new LocalAccountsHandler(networkConnection.provider, resolvedAccounts),
       );
     } else if (isHttpNetworkHdAccountsConfig(accounts)) {
-      const { HDWalletHandler } = await import(
-        "./handlers/accounts/hd-wallet-handler.js"
-      );
       const hdWalletHandler = await HDWalletHandler.create(
         networkConnection.provider,
         await accounts.mnemonic.get(),

package/src/internal/builtin-plugins/node/artifacts/build-info-watcher.ts

@@ -2,6 +2,7 @@ import type { FSWatcher } from "chokidar";
 
 import path from "node:path";
 
+import { watch } from "chokidar";
 import debug from "debug";
 
 export type BuildInfoWatcher = FSWatcher;
@@ -59,8 +60,6 @@ export async function watchBuildInfo(
   buildInfoDirPath: string,
   handler: BuildInfoHandler,
 ): Promise<BuildInfoWatcher> {
-  const { watch } = await import("chokidar");
-
   // NOTE: Deleting the build info directory while it is being watched will
   // effectively cause the watcher to stop working.
   // NOTE: We use chokidar's `awaitWriteFinish` option because we are certain

package/src/internal/builtin-plugins/node/helpers.ts

@@ -2,6 +2,7 @@ import type { BuildInfo } from "../../../types/artifacts.js";
 import type { EdrNetworkAccountsConfig } from "../../../types/config.js";
 import type { SolidityBuildInfoOutput } from "../../../types/solidity.js";
 import type { EdrProvider } from "../network-manager/edr/edr-provider.js";
+import type * as MicroEthSignerT from "micro-eth-signer";
 
 import path from "node:path";
 
@@ -11,7 +12,9 @@ import {
 } from "@nomicfoundation/hardhat-utils/fs";
 import { hexStringToBytes } from "@nomicfoundation/hardhat-utils/hex";
 import chalk from "chalk";
-import { addr } from "micro-eth-signer";
+
+// micro-eth-signer is known to be slow to load, so we lazy load it
+let microEthSigner: typeof MicroEthSignerT | undefined;
 
 import { sendErrorTelemetry } from "../../cli/telemetry/sentry/reporter.js";
 import { isDefaultEdrNetworkHDAccountsConfig } from "../network-manager/edr/edr-provider.js";
@@ -48,8 +51,12 @@ export async function formatEdrNetworkConfigAccounts(
     maxPrefixLength = privateKeyPrefix.length;
   }
 
+  if (microEthSigner === undefined) {
+    microEthSigner = await import("micro-eth-signer");
+  }
+
   for (const [index, account] of accounts.entries()) {
-    const address = addr
+    const address = microEthSigner.addr
       .fromPrivateKey(hexStringToBytes(await account.privateKey.getHexString()))
       .toLowerCase();
     const balance = (BigInt(account.balance) / 10n ** 18n).toString(10);

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

@@ -1,4 +1,4 @@
-import type { Artifact, BuildInfo } from "../../../../types/artifacts.js";
+import type { Artifact } from "../../../../types/artifacts.js";
 import type { CompilationJob } from "../../../../types/solidity/compilation-job.js";
 import type {
   CompilerOutput,
@@ -107,11 +107,16 @@ declare module "hardhat/types/artifacts" {
 export async function getBuildInfo(
   compilationJob: CompilationJob,
 ): Promise<SolidityBuildInfo> {
-  const buildInfo: Required<BuildInfo> = {
+  // Defaulting to "solc" is safe here: if it's already "solc" or undefined,
+  // this doesn't alter the build info id.
+  const compilerType = compilationJob.solcConfig.type ?? "solc";
+
+  const buildInfo: SolidityBuildInfo = {
     _format: "hh3-sol-build-info-1",
     id: await compilationJob.getBuildId(),
     solcVersion: compilationJob.solcConfig.version,
     solcLongVersion: compilationJob.solcLongVersion,
+    compilerType,
     userSourceNameMap:
       compilationJob.dependencyGraph.getRootsUserSourceNameMap(),
     input: await compilationJob.getSolcInput(),

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

@@ -1,7 +1,11 @@
 import type { CompileCache } from "./cache.js";
 import type { DependencyGraphImplementation } from "./dependency-graph.js";
 import type { Artifact } from "../../../../types/artifacts.js";
-import type { SolcConfig, SolidityConfig } from "../../../../types/config.js";
+import type {
+  SolidityCompilerConfig,
+  SolcSolidityCompilerConfig,
+  SolidityConfig,
+} from "../../../../types/config.js";
 import type { HookManager } from "../../../../types/hooks.js";
 import type {
   SolidityBuildSystem,
@@ -54,6 +58,7 @@ import pMap from "p-map";
 
 import { FileBuildResultType } from "../../../../types/solidity/build-system.js";
 import { DEFAULT_BUILD_PROFILE } from "../build-profiles.js";
+import { getSolcCompilerForConfig } from "../solidity-hooks.js";
 
 import {
   getArtifactsDeclarationFile,
@@ -79,14 +84,12 @@ import { shouldSuppressWarning } from "./warning-suppression.js";
 const log = debug("hardhat:core:solidity:build-system");
 
 /**
- * Resolves the preferWasm setting for a given solc config, falling back
- * to the build profile's preferWasm if not set on the compiler.
+ * Returns true if the given compiler config is a SolcSolidityCompilerConfig.
  */
-function resolvePreferWasm(
-  solcConfig: SolcConfig,
-  buildProfilePreferWasm: boolean,
-): boolean {
-  return solcConfig.preferWasm ?? buildProfilePreferWasm;
+export function isSolcSolidityCompilerConfig(
+  config: SolidityCompilerConfig,
+): config is SolcSolidityCompilerConfig {
+  return config.type === undefined || config.type === "solc";
 }
 
 // Compiler warnings to suppress from build output.
@@ -439,7 +442,7 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
     );
 
     let subgraphsWithConfig: Array<
-      [SolcConfig, DependencyGraphImplementation]
+      [SolidityCompilerConfig, DependencyGraphImplementation]
     > = [];
     for (const [rootFile, resolvedFile] of dependencyGraph.getRoots()) {
       log(
@@ -459,19 +462,47 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
     }
 
     // get longVersion and isWasm from the compiler for each version
-    const solcVersionToLongVersion = new Map<string, string>();
-    const versionIsWasm = new Map<string, boolean>();
-    for (const [solcConfig] of subgraphsWithConfig) {
-      let solcLongVersion = solcVersionToLongVersion.get(solcConfig.version);
-
-      if (solcLongVersion === undefined) {
-        const compiler = await getCompiler(solcConfig.version, {
-          preferWasm: resolvePreferWasm(solcConfig, buildProfile.preferWasm),
-          compilerPath: solcConfig.path,
-        });
-        solcLongVersion = compiler.longVersion;
-        solcVersionToLongVersion.set(solcConfig.version, solcLongVersion);
-        versionIsWasm.set(solcConfig.version, compiler.isSolcJs);
+    // These maps are keyed by compiler type first, then version, to avoid
+    // collisions between different compiler types using the same version string.
+    const solidityVersionToLongVersionPerCompilerType = new Map<
+      string,
+      Map<string, string>
+    >();
+    const versionIsWasmPerCompilerType = new Map<
+      string,
+      Map<string, boolean>
+    >();
+    for (const [compilerConfig] of subgraphsWithConfig) {
+      const compilerType = compilerConfig.type ?? "solc";
+      let longVersionMap =
+        solidityVersionToLongVersionPerCompilerType.get(compilerType);
+      if (longVersionMap === undefined) {
+        longVersionMap = new Map();
+        solidityVersionToLongVersionPerCompilerType.set(
+          compilerType,
+          longVersionMap,
+        );
+      }
+
+      let isWasmMap = versionIsWasmPerCompilerType.get(compilerType);
+      if (isWasmMap === undefined) {
+        isWasmMap = new Map();
+        versionIsWasmPerCompilerType.set(compilerType, isWasmMap);
+      }
+
+      let longVersion = longVersionMap.get(compilerConfig.version);
+
+      if (longVersion === undefined) {
+        const compiler = await this.#hooks.runHandlerChain(
+          "solidity",
+          "getCompiler",
+          [compilerConfig],
+          async (_context, cfg) =>
+            getSolcCompilerForConfig(cfg, buildProfile.preferWasm),
+        );
+        longVersion = compiler.longVersion;
+        longVersionMap.set(compilerConfig.version, longVersion);
+        isWasmMap.set(compilerConfig.version, compiler.isSolcJs);
       }
     }
 
@@ -480,17 +511,26 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
     const sharedContentHashes = new Map<string, string>();
     await Promise.all(
       subgraphsWithConfig.map(async ([config, subgraph]) => {
-        const solcLongVersion = solcVersionToLongVersion.get(config.version);
+        const compilerType = config.type ?? "solc";
+        const longVersionMap =
+          solidityVersionToLongVersionPerCompilerType.get(compilerType);
+
+        assertHardhatInvariant(
+          longVersionMap !== undefined,
+          `No long version map for compiler type ${compilerType}`,
+        );
+
+        const longVersion = longVersionMap.get(config.version);
 
         assertHardhatInvariant(
-          solcLongVersion !== undefined,
-          "solcLongVersion should not be undefined",
+          longVersion !== undefined,
+          "longVersion should not be undefined",
         );
 
         const individualJob = new CompilationJobImplementation(
           subgraph,
           config,
-          solcLongVersion,
+          longVersion,
           this.#hooks,
           sharedContentHashes,
         );
@@ -516,7 +556,15 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
     for (const [rootFile, compilationJob] of indexedIndividualJobs.entries()) {
       const jobHash = await compilationJob.getBuildId();
       const cacheResult = this.#compileCache[rootFile];
-      const isWasm = versionIsWasm.get(compilationJob.solcConfig.version);
+      const compilerType = compilationJob.solcConfig.type ?? "solc";
+      const isWasmMap = versionIsWasmPerCompilerType.get(compilerType);
+
+      assertHardhatInvariant(
+        isWasmMap !== undefined,
+        `No isWasm map for compiler type ${compilerType}`,
+      );
+
+      const isWasm = isWasmMap.get(compilationJob.solcConfig.version);
 
       assertHardhatInvariant(
         isWasm !== undefined,
@@ -529,6 +577,7 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
         cacheResult === undefined ||
         cacheResult.jobHash !== jobHash ||
         cacheResult.isolated !== isolated ||
+        cacheResult.compilerType !== compilerType ||
         cacheResult.wasm !== isWasm
       ) {
         rootFilesToCompile.add(rootFile);
@@ -576,13 +625,15 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
       log(`Merging compilation jobs`);
 
       const mergedSubgraphsByConfig: Map<
-        SolcConfig,
+        SolidityCompilerConfig,
         DependencyGraphImplementation
       > = new Map();
 
-      // Note: This groups the subgraphs by solc config. It compares the configs
-      // based on reference, and not by deep equality. It misses some merging
-      // opportunities, but this is Hardhat v2's behavior and works well enough.
+      // Note: This groups the subgraphs by compiler config. It compares the
+      // configs based on reference, and not by deep equality. This is
+      // inherently type-aware: two configs with different types will always be
+      // different references. It misses some merging opportunities, but this is
+      // Hardhat v2's behavior and works well enough.
       for (const [config, subgraph] of subgraphsWithConfig) {
         const rootFile = getSingleRootFilePath(subgraph);
 
@@ -613,18 +664,27 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
     }
 
     const compilationJobsPerFile = new Map<string, CompilationJob>();
-    for (const [solcConfig, subgraph] of subgraphsWithConfig) {
-      const solcLongVersion = solcVersionToLongVersion.get(solcConfig.version);
+    for (const [compilerConfig, subgraph] of subgraphsWithConfig) {
+      const compilerType = compilerConfig.type ?? "solc";
+      const longVersionMap =
+        solidityVersionToLongVersionPerCompilerType.get(compilerType);
 
       assertHardhatInvariant(
-        solcLongVersion !== undefined,
-        "solcLongVersion should not be undefined",
+        longVersionMap !== undefined,
+        `No long version map for compiler type ${compilerType}`,
+      );
+
+      const longVersion = longVersionMap.get(compilerConfig.version);
+
+      assertHardhatInvariant(
+        longVersion !== undefined,
+        "longVersion should not be undefined",
       );
 
       const runnableCompilationJob = new CompilationJobImplementation(
         subgraph,
-        solcConfig,
-        solcLongVersion,
+        compilerConfig,
+        longVersion,
         this.#hooks,
         sharedContentHashes,
       );
@@ -677,19 +737,16 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
 
     const { buildProfile } = this.#getBuildProfile(options?.buildProfile);
 
-    const compiler = await getCompiler(
-      runnableCompilationJob.solcConfig.version,
-      {
-        preferWasm: resolvePreferWasm(
-          runnableCompilationJob.solcConfig,
-          buildProfile.preferWasm,
-        ),
-        compilerPath: runnableCompilationJob.solcConfig.path,
-      },
+    const compiler = await this.#hooks.runHandlerChain(
+      "solidity",
+      "getCompiler",
+      [runnableCompilationJob.solcConfig],
+      async (_context, cfg) =>
+        getSolcCompilerForConfig(cfg, buildProfile.preferWasm),
     );
 
     log(
-      `Compiling ${numberOfRootFiles} root files and ${numberOfFiles - numberOfRootFiles} dependency files with solc ${runnableCompilationJob.solcConfig.version} using ${compiler.compilerPath}`,
+      `Compiling ${numberOfRootFiles} root files and ${numberOfFiles - numberOfRootFiles} dependency files with ${runnableCompilationJob.solcConfig.type ?? "solc"} ${runnableCompilationJob.solcConfig.version} using ${compiler.compilerPath}`,
     );
 
     assertHardhatInvariant(
@@ -1016,8 +1073,10 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
   ): Promise<CompilerOutput> {
     const quiet = options?.quiet ?? false;
 
-    // We download the compiler for the build info as it may not be configured
-    // in the HH config, hence not downloaded with the other compilers
+    // Build info recompilation is always solc-only: build info files are
+    // produced by solc and must be recompiled with the same solc version.
+    // We bypass both downloadCompilers and getCompiler hooks — this is a
+    // self-contained solc replay path, not plugin-configurable compilation.
     await downloadSolcCompilers(new Set([buildInfo.solcVersion]), quiet);
 
     const compiler = await getCompiler(buildInfo.solcVersion, {
@@ -1034,20 +1093,17 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
       return;
     }
 
-    await downloadSolcCompilers(this.#getAllCompilerVersions(), quiet);
+    const allSolidityCompilerConfigs = this.#getAllSolidityCompilerConfigs();
+    await this.#hooks.runParallelHandlers("solidity", "downloadCompilers", [
+      allSolidityCompilerConfigs,
+      quiet,
+    ]);
     this.#configuredCompilersDownloaded = true;
   }
 
-  #getAllCompilerVersions(): Set<string> {
-    return new Set(
-      Object.values(this.#options.solidityConfig.profiles)
-        .map((profile) => [
-          ...profile.compilers.map((compiler) => compiler.version),
-          ...Object.values(profile.overrides).map(
-            (override) => override.version,
-          ),
-        ])
-        .flat(1),
+  #getAllSolidityCompilerConfigs(): SolidityCompilerConfig[] {
+    return Object.values(this.#options.solidityConfig.profiles).flatMap(
+      (profile) => [...profile.compilers, ...Object.values(profile.overrides)],
     );
   }
 
@@ -1124,6 +1180,7 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
       this.#compileCache[rootFilePath] = {
         jobHash,
         isolated,
+        compilerType: individualJob.solcConfig.type ?? "solc",
         artifactPaths,
         buildInfoPath: emitArtifactsResult.buildInfoPath,
         buildInfoOutputPath: emitArtifactsResult.buildInfoOutputPath,
@@ -1208,16 +1265,21 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
     }
 
     for (const job of runnableCompilationJobs) {
+      const compilerType = job.solcConfig.type ?? "solc";
       const solcVersion = job.solcConfig.version;
       const solcInput = await job.getSolcInput();
       const evmVersion =
         solcInput.settings.evmVersion ??
         `Check solc ${solcVersion}'s doc for its default evm version`;
 
-      let jobsPerVersion = jobsPerVersionAndEvmVersion.get(solcVersion);
+      // Group by compiler type + Solidity version to produce separate log
+      // lines for e.g. "solc 0.8.33" vs "solx 0.1.3 (Solidity 0.8.33)".
+      const groupKey = `${compilerType}#${solcVersion}`;
+
+      let jobsPerVersion = jobsPerVersionAndEvmVersion.get(groupKey);
       if (jobsPerVersion === undefined) {
         jobsPerVersion = new Map();
-        jobsPerVersionAndEvmVersion.set(solcVersion, jobsPerVersion);
+        jobsPerVersionAndEvmVersion.set(groupKey, jobsPerVersion);
       }
 
       let jobsPerEvmVersion = jobsPerVersion.get(evmVersion);
@@ -1229,10 +1291,11 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
       jobsPerEvmVersion.push(job);
     }
 
-    for (const solcVersion of [...jobsPerVersionAndEvmVersion.keys()].sort()) {
+    for (const groupKey of [...jobsPerVersionAndEvmVersion.keys()].sort()) {
       /* eslint-disable-next-line @typescript-eslint/no-non-null-assertion --
       This is a valid key, just sorted */
-      const jobsPerEvmVersion = jobsPerVersionAndEvmVersion.get(solcVersion)!;
+      const jobsPerEvmVersion = jobsPerVersionAndEvmVersion.get(groupKey)!;
+      const [compilerType, solidityVersion] = groupKey.split("#");
 
       for (const evmVersion of [...jobsPerEvmVersion.keys()].sort()) {
         /* eslint-disable-next-line @typescript-eslint/no-non-null-assertion --
@@ -1244,12 +1307,25 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
           0,
         );
 
+        // For solc, the compiler version is the Solidity version.
+        // For other compilers, extract the compiler's own version from the
+        // longVersion stored on the compilation job, and show the Solidity
+        // version separately.
+        let compilerLabel: string;
+        if (compilerType === "solc") {
+          compilerLabel = `solc ${solidityVersion}`;
+        } else {
+          const longVersion = jobs[0].solcLongVersion;
+          const compilerVersion = longVersion.split("+")[0];
+          compilerLabel = `${compilerType} ${compilerVersion} (Solidity ${solidityVersion})`;
+        }
+
         console.log(
           chalk.bold(
             `Compiled ${rootFiles} Solidity ${pluralize(
               options.scope === "contracts" ? "file" : "test file",
               rootFiles,
-            )} with solc ${solcVersion}`,
+            )} with ${compilerLabel}`,
           ),
           `(evm target: ${evmVersion})`,
         );

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

@@ -17,6 +17,7 @@ export type CompileCache = Record<string, CompileCacheEntry>;
 export interface CompileCacheEntry {
   jobHash: string;
   isolated: boolean;
+  compilerType: string;
   buildInfoPath: string;
   buildInfoOutputPath: string;
   artifactPaths: string[];

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

@@ -1,6 +1,6 @@
 import type { DependencyGraphImplementation } from "./dependency-graph.js";
 import type { BuildInfo } from "../../../../types/artifacts.js";
-import type { SolcConfig } from "../../../../types/config.js";
+import type { SolidityCompilerConfig } from "../../../../types/config.js";
 import type { HookManager } from "../../../../types/hooks.js";
 import type { CompilationJob } from "../../../../types/solidity/compilation-job.js";
 import type { CompilerInput } from "../../../../types/solidity/compiler-io.js";
@@ -21,7 +21,7 @@ import { getEvmVersionFromSolcVersion } from "./solc-info.js";
 
 export class CompilationJobImplementation implements CompilationJob {
   public readonly dependencyGraph: DependencyGraph;
-  public readonly solcConfig: SolcConfig;
+  public readonly solcConfig: SolidityCompilerConfig;
   public readonly solcLongVersion: string;
 
   readonly #hooks: HookManager;
@@ -34,7 +34,7 @@ export class CompilationJobImplementation implements CompilationJob {
 
   constructor(
     dependencyGraph: DependencyGraphImplementation,
-    solcConfig: SolcConfig,
+    solcConfig: SolidityCompilerConfig,
     solcLongVersion: string,
     hooks: HookManager,
     sharedContentHashes: Map<string, string> = new Map(),
@@ -236,17 +236,44 @@ export class CompilationJobImplementation implements CompilationJob {
     // Changing this shouldn't be taken lightly, as it makes reproducing
     // builds pretty difficult when upgrading Hardhat between versions that
     // change it.
-    const preimage = JSON.stringify({
+
+    const compilerType = this.solcConfig.type;
+
+    // We normalize solcConfig.type to `undefined` so that "solc" and undefined
+    // produce the same hash, for backwards compatibility.
+    const normalizedSolcConfig = { ...this.solcConfig, type: undefined };
+
+    const preimageObject: Record<string, unknown> = {
       format,
       solcLongVersion: this.solcLongVersion,
       smallerSolcInput,
-      solcConfig: this.solcConfig,
+      solcConfig: normalizedSolcConfig,
       userSourceNameMap: this.dependencyGraph.getRootsUserSourceNameMap(),
-    });
+    };
+
+    // Include compiler type in the preimage for non-solc types, so that
+    // different compiler types produce different build IDs.
+    if (compilerType !== undefined && compilerType !== "solc") {
+      preimageObject.compilerType = compilerType;
+    }
+
+    const preimage = JSON.stringify(preimageObject);
 
     const jobHash = await createNonCryptographicHashId(preimage);
 
-    return `solc-${this.solcConfig.version.replaceAll(".", "_")}-${jobHash}`;
+    const versionPart = this.solcConfig.version.replaceAll(".", "_");
+
+    // For non-solc compiler types, include the compiler type in the build ID.
+    // We keep the `solc-` prefix for all types to avoid breaking codepaths
+    // that look for it.
+    if (compilerType !== undefined && compilerType !== "solc") {
+      /* eslint-disable-next-line @typescript-eslint/restrict-template-expressions --
+        compilerType is `never` in the base type system (only "solc" is registered),
+        but plugins can extend SolidityCompilerConfigPerType to add new compiler types. */
+      return `solc-${versionPart}-${compilerType}-${jobHash}`;
+    }
+
+    return `solc-${versionPart}-${jobHash}`;
   }
 
   #getSourceContentHash(sourceName: string, text: string): any {

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

@@ -39,7 +39,7 @@ import * as semver from "semver";
  * @throws Error if the compilation process exits with a non-zero exit code.
  * @throws HardhatInvariantError if the any of the io streams are null.
  */
-async function spawnCompile(
+export async function spawnCompile(
   command: string,
   args: string[],
   input: CompilerInput,

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

@@ -25,6 +25,7 @@ import {
 import { getPrefixedHexString } from "@nomicfoundation/hardhat-utils/hex";
 import { download } from "@nomicfoundation/hardhat-utils/request";
 import { MultiProcessMutex } from "@nomicfoundation/hardhat-utils/synchronization";
+import AdmZip from "adm-zip";
 import debug from "debug";
 
 import { NativeCompiler, SolcJsCompiler } from "./compiler.js";
@@ -469,8 +470,6 @@ export class CompilerDownloaderImplementation implements CompilerDownloader {
       downloadPath.endsWith(".zip")
     ) {
       // some window builds are zipped, some are not
-      const { default: AdmZip } = await import("adm-zip");
-
       const solcFolder = path.join(this.#compilersDir, build.version);
       await ensureDir(solcFolder);