hardhat 3.4.2 → 3.4.4

package/src/internal/builtin-plugins/network-manager/edr/utils/trace-formatters.ts

@@ -1,10 +1,11 @@
-import type { Colorizer } from "../../../../utils/colorizer.js";
 import type {
   LogTrace,
   CallTrace,
   DecodedTraceParameters,
 } from "@nomicfoundation/edr";
 
+import { styleText } from "node:util";
+
 import { LogKind, CallKind, IncludeTraces } from "@nomicfoundation/edr";
 import { bytesToHexString } from "@nomicfoundation/hardhat-utils/hex";
 
@@ -23,9 +24,10 @@ export function verbosityToIncludeTraces(verbosity: number): IncludeTraces {
 export function formatTraces(
   traces: CallTrace[],
   prefix: string,
-  colorizer: Colorizer,
+  // Allow passing a custom colorize function for testing purposes
+  colorize: typeof styleText = styleText,
 ): string {
-  const lines = traces.map((trace) => formatTrace(trace, colorizer));
+  const lines = traces.map((trace) => formatTrace(trace, colorize));
   const formattedTraces = formatNestedArray(lines, prefix);
   // Remove the trailing newline
   return formattedTraces.slice(0, -1);
@@ -52,9 +54,13 @@ function formatOutputs(outputs: string | Uint8Array): string | undefined {
   }
 }
 
-function formatLog(log: LogTrace, colorizer: Colorizer): string[] {
+function formatLog(
+  log: LogTrace,
+  // Allow passing a custom colorize function for testing purposes
+  colorize: typeof styleText,
+): string[] {
   const { parameters } = log;
-  const tag = colorizer.yellow("[event]");
+  const tag = colorize("yellow", "[event]");
   const lines = [];
 
   if (Array.isArray(parameters)) {
@@ -63,18 +69,18 @@ function formatLog(log: LogTrace, colorizer: Colorizer): string[] {
 
     for (let i = 0; i < topicCount; i++) {
       const prefix = i === 0 ? `${tag} topic 0` : `        topic ${i}`;
-      lines.push(`${prefix}: ${colorizer.cyan(hexValues[i])}`);
+      lines.push(`${prefix}: ${colorize("cyan", hexValues[i])}`);
     }
 
     if (hexValues.length > 0) {
       const dataPrefix = topicCount > 0 ? "           data" : `${tag}    data`;
       lines.push(
-        `${dataPrefix}: ${colorizer.cyan(hexValues[hexValues.length - 1])}`,
+        `${dataPrefix}: ${colorize("cyan", hexValues[hexValues.length - 1])}`,
       );
     }
   } else {
     lines.push(
-      `${tag} ${parameters.name}(${colorizer.cyan(parameters.arguments.join(", "))})`,
+      `${tag} ${parameters.name}(${colorize("cyan", parameters.arguments.join(", "))})`,
     );
   }
   return lines;
@@ -82,7 +88,7 @@ function formatLog(log: LogTrace, colorizer: Colorizer): string[] {
 
 function formatTrace(
   trace: CallTrace,
-  colorizer: Colorizer,
+  colorize: typeof styleText,
 ): NestedArray<string> {
   const {
     success,
@@ -95,14 +101,8 @@ function formatTrace(
     isCheatcode,
     outputs,
   } = trace;
-  let color;
-  if (isCheatcode) {
-    color = colorizer.blue;
-  } else if (success) {
-    color = colorizer.green;
-  } else {
-    color = colorizer.red;
-  }
+  const colorName = isCheatcode ? "blue" : success ? "green" : "red";
+  const color = (text: string) => colorize(colorName, text);
 
   const formattedInputs = formatInputs(inputs, color);
   const formattedOutputs = formatOutputs(outputs);
@@ -110,7 +110,7 @@ function formatTrace(
   let openingLine: string;
   let closingLine: string | undefined;
   if (kind === CallKind.Create) {
-    openingLine = `[${gasUsed}] ${colorizer.yellow("→ new")} ${contract ?? "<unknown>"}@${address}`;
+    openingLine = `[${gasUsed}] ${colorize("yellow", "→ new")} ${contract ?? "<unknown>"}@${address}`;
     // TODO: Uncomment this when the formattedInputs starts containing
     // the address of where the contract was deployed instead of the code.
     // if (formattedInputs !== undefined) {
@@ -125,11 +125,11 @@ function formatTrace(
       openingLine = `${openingLine} {value: ${value}}`;
     }
     if (kind === CallKind.StaticCall) {
-      openingLine = `${openingLine} ${colorizer.yellow("[staticcall]")}`;
+      openingLine = `${openingLine} ${colorize("yellow", "[staticcall]")}`;
     } else if (kind === CallKind.DelegateCall) {
-      openingLine = `${openingLine} ${colorizer.yellow("[delegatecall]")}`;
+      openingLine = `${openingLine} ${colorize("yellow", "[delegatecall]")}`;
     } else if (kind === CallKind.CallCode) {
-      openingLine = `${openingLine} ${colorizer.yellow("[callcode]")}`;
+      openingLine = `${openingLine} ${colorize("yellow", "[callcode]")}`;
     }
   }
   if (formattedOutputs !== undefined) {
@@ -147,9 +147,9 @@ function formatTrace(
   lines.push(openingLine);
   for (const child of trace.children) {
     if (child.kind === LogKind.Log) {
-      lines.push(formatLog(child, colorizer));
+      lines.push(formatLog(child, colorize));
     } else {
-      lines.push(formatTrace(child, colorizer));
+      lines.push(formatTrace(child, colorize));
     }
   }
   if (closingLine !== undefined) {

package/src/internal/builtin-plugins/network-manager/edr/utils/trace-output.ts

@@ -1,20 +1,21 @@
 import type { Response } from "@nomicfoundation/edr";
 
-import chalk from "chalk";
-import debug from "debug";
+import { styleText } from "node:util";
+
+import { createDebug } from "@nomicfoundation/hardhat-utils/debug";
 
 import { formatTraces } from "./trace-formatters.js";
 
-const log = debug("hardhat:core:hardhat-network:provider");
+const log = createDebug("hardhat:core:network-manager:edr:trace-output");
 
 // Rotating palette for per-connection coloring of trace headers.
 const LABEL_COLORS: Array<(text: string) => string> = [
-  chalk.cyan,
-  chalk.magenta,
-  chalk.blueBright,
-  chalk.yellowBright,
-  chalk.cyanBright,
-  chalk.magentaBright,
+  (text: string) => styleText("cyan", text),
+  (text: string) => styleText("magenta", text),
+  (text: string) => styleText("blueBright", text),
+  (text: string) => styleText("yellowBright", text),
+  (text: string) => styleText("cyanBright", text),
+  (text: string) => styleText("magentaBright", text),
 ];
 
 // Keyed by `network name` (not connection label) so the map stays bounded
@@ -107,10 +108,12 @@ export class TraceOutputManager {
       const coloredLabel = this.#labelColor(this.#connectionLabel);
       const prefix = callTraces.length > 1 ? "Traces from" : "Trace from";
       const coloredPrefix = this.#labelColor(prefix);
-      const styledMethod = failed ? chalk.red(method) : chalk.dim(method);
+      const styledMethod = failed
+        ? styleText("red", method)
+        : styleText("dim", method);
       const header = `${coloredPrefix} ${coloredLabel}: ${styledMethod}`;
 
-      this.#printLineFn(`${header}\n${formatTraces(callTraces, "  ", chalk)}`);
+      this.#printLineFn(`${header}\n${formatTraces(callTraces, "  ")}`);
     } catch (e) {
       log("Failed to get call traces: %O", e);
     }

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

@@ -2,13 +2,13 @@ import type { FSWatcher } from "chokidar";
 
 import path from "node:path";
 
+import { createDebug } from "@nomicfoundation/hardhat-utils/debug";
 import { watch } from "chokidar";
-import debug from "debug";
 
 export type BuildInfoWatcher = FSWatcher;
 export type BuildInfoHandler = (buildId: string) => Promise<void>;
 
-const log = debug("hardhat:core:tasks:node:artifacts");
+const log = createDebug("hardhat:core:tasks:node:artifacts");
 
 const STABILITY_THRESHOLD = 250;
 const POLL_INTERVAL = 50;

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

@@ -2,16 +2,17 @@ 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 { DebugLogger } from "@nomicfoundation/hardhat-utils/debug";
 import type * as MicroEthSignerT from "micro-eth-signer";
 
 import path from "node:path";
+import { styleText } from "node:util";
 
 import {
   readJsonFile,
   readJsonFileAsStream,
 } from "@nomicfoundation/hardhat-utils/fs";
 import { hexStringToBytes } from "@nomicfoundation/hardhat-utils/hex";
-import chalk from "chalk";
 
 // micro-eth-signer is known to be slow to load, so we lazy load it
 let microEthSigner: typeof MicroEthSignerT | undefined;
@@ -94,7 +95,7 @@ export async function formatEdrNetworkConfigAccounts(
 export function createBuildInfoUploadHandlerFrom(
   buildInfoDirPath: string,
   provider: EdrProvider,
-  log: debug.Debugger,
+  log: DebugLogger,
 ): (buildId: string) => Promise<void> {
   const buildInfoHandler = async (buildId: string) => {
     try {
@@ -116,7 +117,8 @@ export function createBuildInfoUploadHandlerFrom(
       log(`Added compiler result for ${buildId}`);
     } catch (error) {
       console.warn(
-        chalk.yellow(
+        styleText(
+          "yellow",
           `There was a problem adding the new compiler result for build ${buildId}.`,
         ),
       );
@@ -137,7 +139,8 @@ export function createBuildInfoUploadHandlerFrom(
 
 // NOTE: This function is exported for testing purposes only
 export function getPublicPrivateKeysWarning(): string {
-  return chalk.bold(
+  return styleText(
+    "bold",
     "WARNING: Funds sent on live network to accounts with publicly known private keys WILL BE LOST.",
   );
 }

package/src/internal/builtin-plugins/node/json-rpc/server.ts

@@ -5,12 +5,12 @@ import type { AddressInfo } from "node:net";
 
 import http from "node:http";
 
-import debug from "debug";
+import { createDebug } from "@nomicfoundation/hardhat-utils/debug";
 import { WebSocketServer } from "ws";
 
 import { JsonRpcHandler } from "./handler.js";
 
-const log = debug("hardhat:core:tasks:node:json-rpc:server");
+const log = createDebug("hardhat:core:tasks:node:json-rpc:server");
 
 export interface JsonRpcServerConfig {
   hostname: string;

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

@@ -3,14 +3,14 @@ import type { ChainType } from "../../../types/network.js";
 import type { NewTaskActionFunction } from "../../../types/tasks.js";
 
 import path from "node:path";
+import { styleText } from "node:util";
 
 import {
   assertHardhatInvariant,
   HardhatError,
 } from "@nomicfoundation/hardhat-errors";
+import { createDebug } from "@nomicfoundation/hardhat-utils/debug";
 import { ensureDir, exists } from "@nomicfoundation/hardhat-utils/fs";
-import chalk from "chalk";
-import debug from "debug";
 
 import { isSupportedChainType } from "../../edr/chain-type.js";
 import { BUILD_INFO_DIR_NAME } from "../artifacts/artifact-manager.js";
@@ -23,7 +23,7 @@ import {
 } from "./helpers.js";
 import { JsonRpcServerImplementation } from "./json-rpc/server.js";
 
-const log = debug("hardhat:core:tasks:node");
+const log = createDebug("hardhat:core:tasks:node");
 
 interface NodeActionArguments {
   hostname?: string;
@@ -143,7 +143,8 @@ const nodeAction: NewTaskActionFunction<NodeActionArguments> = async (
   const { port: actualPort, address: actualHostname } = await server.listen();
 
   console.log(
-    chalk.green(
+    styleText(
+      "green",
       `Started HTTP and WebSocket JSON-RPC server at http://${actualHostname}:${actualPort}/`,
     ),
   );

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

@@ -33,11 +33,13 @@ import type {
 
 import os from "node:os";
 import path from "node:path";
+import { styleText } from "node:util";
 
 import {
   assertHardhatInvariant,
   HardhatError,
 } from "@nomicfoundation/hardhat-errors";
+import { createDebug } from "@nomicfoundation/hardhat-utils/debug";
 import {
   exists,
   ensureDir,
@@ -54,8 +56,6 @@ import {
 import { shortenPath } from "@nomicfoundation/hardhat-utils/path";
 import { createSpinner } from "@nomicfoundation/hardhat-utils/spinner";
 import { pluralize } from "@nomicfoundation/hardhat-utils/string";
-import chalk from "chalk";
-import debug from "debug";
 import pMap from "p-map";
 
 import { FileBuildResultType } from "../../../../types/solidity/build-system.js";
@@ -71,6 +71,7 @@ import {
   getDuplicatedContractNamesDeclarationFile,
 } from "./artifacts.js";
 import { loadCache, saveCache } from "./cache.js";
+import { sortCompilationJobsByDescendingCost } from "./compilation-job-cost.js";
 import { CompilationJobImplementation } from "./compilation-job.js";
 import { downloadSolcCompilers, getCompiler } from "./compiler/index.js";
 import { buildDependencyGraph } from "./dependency-graph-building.js";
@@ -84,7 +85,7 @@ import {
 import { SolcConfigSelector } from "./solc-config-selection.js";
 import { shouldSuppressWarning } from "./warning-suppression.js";
 
-const log = debug("hardhat:core:solidity:build-system");
+const log = createDebug("hardhat:core:solidity:build-system");
 
 /**
  * Returns true if the given compiler config is a SolcSolidityCompilerConfig.
@@ -339,8 +340,18 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
         ),
       );
 
-      const results: CompilationResult[] = await pMap(
+      // We sort the compilation jobs in descending order of estimated
+      // compilation cost. This way we can use this algorithm:
+      // https://en.wikipedia.org/wiki/Longest-processing-time-first_scheduling
+      //
+      // Note that it works because pMap schedules the jobs in the order they
+      // are in the array.
+      const sortedCompilationJobs = sortCompilationJobsByDescendingCost(
         runnableCompilationJobs,
+      );
+
+      const results: CompilationResult[] = await pMap(
+        sortedCompilationJobs,
         async (runnableCompilationJob) => {
           const { output, compiler } = await this.runCompilationJob(
             runnableCompilationJob,
@@ -1356,13 +1367,14 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
           error.message;
 
         console.error(
-          errorMessage.replace(/^\w+:/, (t) => chalk.red.bold(t)).trimEnd() +
-            "\n",
+          errorMessage
+            .replace(/^\w+:/, (t) => styleText(["red", "bold"], t))
+            .trimEnd() + "\n",
         );
       } else {
         console.warn(
           (error.formattedMessage ?? error.message)
-            .replace(/^\w+:/, (t) => chalk.yellow.bold(t))
+            .replace(/^\w+:/, (t) => styleText(["yellow", "bold"], t))
             .trimEnd() + "\n",
         );
       }
@@ -1374,7 +1386,8 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
 
     if (hasConsoleErrors) {
       console.error(
-        chalk.red(
+        styleText(
+          "red",
           `The console.log call you made isn't supported. See https://hardhat.org/console-log for the list of supported methods.`,
         ),
       );
@@ -1467,7 +1480,8 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
         }
 
         console.log(
-          chalk.bold(
+          styleText(
+            "bold",
             `Compiled ${rootFiles} Solidity ${pluralize(
               options.scope === "contracts" ? "file" : "test file",
               rootFiles,

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

@@ -0,0 +1,61 @@
+import type { CompilationJob } from "../../../../types/solidity.js";
+
+import { SOLC_DEFAULT_OPTIMIZER_RUNS } from "../constants.js";
+
+// This doesn't need to be exact, it's used to account for the per-file
+// overhead, so that many small files don't look free
+const APPROXIMATE_AVERAGE_SIZE_OF_SOLIDITY_FILES = 10_000;
+
+export function estimateCompilationJobCost(job: CompilationJob): number {
+  let totalChars = 0;
+  let fileCount = 0;
+
+  for (const file of job.dependencyGraph.getAllFiles()) {
+    totalChars += file.content.text.length;
+    fileCount += 1;
+  }
+
+  const settings = job.solcConfig.settings ?? {};
+  const viaIR = settings.viaIR === true;
+  const optimizerEnabled = settings.optimizer?.enabled === true;
+  const optimizerRuns: number =
+    settings.optimizer?.runs ?? SOLC_DEFAULT_OPTIMIZER_RUNS;
+
+  const viaIRMultiplier = viaIR === true ? 6.0 : 1.0;
+  const optimizerMultiplier = optimizerEnabled ? 1.4 : 1.0;
+
+  // The optimizer `runs` is not the number of times that the optimizer is run.
+  // It represents how many times the contract will be run.
+  // While it has an effect in the compilation time, it's not linear nor
+  // dominant.
+  //
+  // We use Math.log10 and Math.min to represent that:
+  //   - increasing runs probably has diminishing impact in cost
+  //   - going from 1 -> 200 matters more than 200 -> 20_000
+  //   - runs should contribute weakly compared with viaIR
+  const runsMultiplier = optimizerEnabled
+    ? 1 + Math.min(0.12, Math.log10(Math.max(1, optimizerRuns)) * 0.04)
+    : 1.0;
+
+  const fileOverhead = APPROXIMATE_AVERAGE_SIZE_OF_SOLIDITY_FILES * fileCount;
+
+  return (
+    (totalChars + fileOverhead) *
+    viaIRMultiplier *
+    optimizerMultiplier *
+    runsMultiplier
+  );
+}
+
+/**
+ * Returns a new array containing the given compilation jobs sorted by their
+ * estimated cost in descending order. The input array is not mutated.
+ */
+export function sortCompilationJobsByDescendingCost(
+  compilationJobs: CompilationJob[],
+): CompilationJob[] {
+  return compilationJobs
+    .map((job) => ({ job, cost: estimateCompilationJobCost(job) }))
+    .sort((a, b) => b.cost - a.cost)
+    .map(({ job }) => job);
+}

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

@@ -3,6 +3,7 @@ import type {
   CompilerOutput,
 } from "../../../../../types/solidity/compiler-io.js";
 import type { Compiler } from "../../../../../types/solidity/compiler.js";
+import type { SemverVersion } from "@nomicfoundation/hardhat-utils/fast-semver";
 
 import { spawn } from "node:child_process";
 import fsPromises from "node:fs/promises";
@@ -16,13 +17,19 @@ import {
   assertHardhatInvariant,
 } from "@nomicfoundation/hardhat-errors";
 import { ensureError } from "@nomicfoundation/hardhat-utils/error";
+import {
+  greaterThanOrEqual,
+  parseVersion,
+} from "@nomicfoundation/hardhat-utils/fast-semver";
 import {
   mkdtemp,
   readJsonFileAsStream,
   remove,
 } from "@nomicfoundation/hardhat-utils/fs";
 import { createNonClosingWriter } from "@nomicfoundation/hardhat-utils/stream";
-import * as semver from "semver";
+
+const NO_IMPORT_CALLBACK_MIN_VERSION: SemverVersion = [0, 8, 22];
+const BASE_PATH_MIN_VERSION: SemverVersion = [0, 6, 9];
 
 /**
  * Spawns a compilation process and returns its output.
@@ -163,10 +170,17 @@ export class NativeCompiler implements Compiler {
     // Logic to make sure that solc default import callback is not being used.
     // If solcVersion is not defined or <= 0.6.8, do not add extra args.
     if (this.version !== undefined) {
-      if (semver.gte(this.version, "0.8.22")) {
+      const parsed = parseVersion(this.version);
+      if (parsed === undefined) {
+        throw new HardhatError(
+          HardhatError.ERRORS.CORE.SOLIDITY.INVALID_SOLC_VERSION,
+          { version: this.version },
+        );
+      }
+      if (greaterThanOrEqual(parsed, NO_IMPORT_CALLBACK_MIN_VERSION)) {
         // version >= 0.8.22
         args.push("--no-import-callback");
-      } else if (semver.gte(this.version, "0.6.9")) {
+      } else if (greaterThanOrEqual(parsed, BASE_PATH_MIN_VERSION)) {
         // version >= 0.6.9
         const tmpFolder = await mkdtemp("hardhat-solc-");
         args.push(`--base-path`);

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

@@ -11,6 +11,7 @@ import {
 } from "@nomicfoundation/hardhat-errors";
 import { bytesToHexString } from "@nomicfoundation/hardhat-utils/bytes";
 import { sha256 } from "@nomicfoundation/hardhat-utils/crypto";
+import { createDebug } from "@nomicfoundation/hardhat-utils/debug";
 import { ensureError } from "@nomicfoundation/hardhat-utils/error";
 import {
   chmod,
@@ -26,11 +27,12 @@ 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";
 
-const log = debug("hardhat:solidity:downloader");
+const log = createDebug(
+  "hardhat:core:solidity:build-system:compiler:downloader",
+);
 
 const COMPILER_REPOSITORY_URL = "https://binaries.soliditylang.org";
 const DEFAULT_COMPILER_DOWNLOAD_RETRY_COUNT = 3;

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

@@ -9,9 +9,9 @@ import {
   assertHardhatInvariant,
   HardhatError,
 } from "@nomicfoundation/hardhat-errors";
+import { createDebug } from "@nomicfoundation/hardhat-utils/debug";
 import { exists, isBinaryFile } from "@nomicfoundation/hardhat-utils/fs";
 import { getCacheDir } from "@nomicfoundation/hardhat-utils/global-dir";
-import debug from "debug";
 
 import { hasArm64MirrorBuild, hasOfficialArm64Build } from "../solc-info.js";
 
@@ -28,7 +28,7 @@ async function getGlobalCompilersCacheDir(): Promise<string> {
   return path.join(globalCompilersCacheDir, "compilers-v3");
 }
 
-const log = debug("hardhat:core:solidity:build-system:compiler");
+const log = createDebug("hardhat:core:solidity:build-system:compiler");
 
 /**
  * Returns true if a platform-specific build exists for the given version

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

@@ -1,8 +1,18 @@
 // This wrapper was created by extracting the parts of the solc-js package
 // (https://github.com/ethereum/solc-js) that we need to perform compilation.
 
-import { HardhatError } from "@nomicfoundation/hardhat-errors";
-import * as semver from "semver";
+import type { SemverVersion } from "@nomicfoundation/hardhat-utils/fast-semver";
+
+import {
+  HardhatError,
+  assertHardhatInvariant,
+} from "@nomicfoundation/hardhat-errors";
+import {
+  greaterThanOrEqual,
+  parseVersion,
+} from "@nomicfoundation/hardhat-utils/fast-semver";
+
+const VERSION_6: SemverVersion = [0, 6, 0];
 
 interface Solc {
   cwrap<T>(ident: string, returnType: string | null, argTypes: string[]): T;
@@ -36,8 +46,13 @@ export type CompileWrapper = (input: string) => string;
 
 export default function wrapper(solc: Solc): SolcWrapper {
   const version = bindVersion(solc);
-  const semverVersion = versionToSemver(version());
-  const isVersion6OrNewer = semver.gte(semverVersion, "0.6.0");
+  const rawVersion = version();
+  const parsedVersion = parseVersion(rawVersion);
+  assertHardhatInvariant(
+    parsedVersion !== undefined,
+    `Invalid solc version: ${rawVersion}`,
+  );
+  const isVersion6OrNewer = greaterThanOrEqual(parsedVersion, VERSION_6);
   const reset = bindReset(solc);
   const compile = bindCompile(solc, isVersion6OrNewer);
 
@@ -124,21 +139,3 @@ function bindCompile(
 
   return undefined;
 }
-
-function versionToSemver(version: string): string {
-  // FIXME: parse more detail, but this is a good start
-  const parsed = version.match(
-    /^([0-9]+\.[0-9]+\.[0-9]+)-([0-9a-f]{8})[/*].*$/,
-  );
-  if (parsed !== null) {
-    return parsed[1] + "+commit." + parsed[2];
-  }
-  if (version.indexOf("0.1.3-0") !== -1) {
-    return "0.1.3";
-  }
-  if (version.indexOf("0.3.5-0") !== -1) {
-    return "0.3.5";
-  }
-  // assume it is already semver compatible
-  return version;
-}

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

@@ -24,7 +24,10 @@ import type { Result } from "../../../../../types/utils.js";
 import path from "node:path";
 
 import { assertHardhatInvariant } from "@nomicfoundation/hardhat-errors";
-import { exists } from "@nomicfoundation/hardhat-utils/fs";
+import {
+  exists,
+  TrueCasePathResolver,
+} from "@nomicfoundation/hardhat-utils/fs";
 import { AsyncMutex } from "@nomicfoundation/hardhat-utils/synchronization";
 import { analyze } from "@nomicfoundation/solidity-analyzer";
 
@@ -82,6 +85,9 @@ export class ResolverImplementation implements Resolver {
    */
   readonly #fakeRootFile: ProjectResolvedFile;
 
+  readonly #trueCasePathResolver: TrueCasePathResolver =
+    new TrueCasePathResolver();
+
   /**
    * Creates a new resolver.
    *
@@ -221,6 +227,7 @@ export class ResolverImplementation implements Resolver {
     }
 
     const pathValidation = await validateFsPath(
+      this.#trueCasePathResolver,
       this.#projectRoot,
       relativeFilePath,
     );
@@ -839,6 +846,7 @@ export class ResolverImplementation implements Resolver {
     >
   > {
     const pathValidation = await validateFsPath(
+      this.#trueCasePathResolver,
       npmPackage.rootFsPath,
       relativeFsPathWithinPackage,
     );