hardhat 3.4.2 → 3.4.3

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,
     );

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

@@ -1,11 +1,12 @@
 import type { ResolvedNpmPackage } from "../../../../../types/solidity.js";
 import type { Result } from "../../../../../types/utils.js";
+import type { TrueCasePathResolver } from "@nomicfoundation/hardhat-utils/fs";
 
 import { assertHardhatInvariant } from "@nomicfoundation/hardhat-errors";
 import { ensureError } from "@nomicfoundation/hardhat-utils/error";
 import {
   FileNotFoundError,
-  getFileTrueCase,
+  NotADirectoryError,
 } from "@nomicfoundation/hardhat-utils/fs";
 import { exports } from "resolve.exports";
 
@@ -15,6 +16,7 @@ export enum PathValidationErrorType {
 }
 
 export async function validateFsPath(
+  resolver: TrueCasePathResolver,
   from: string,
   relative: string,
 ): Promise<
@@ -26,14 +28,21 @@ export async function validateFsPath(
 > {
   let trueCaseFsPath: string;
   try {
-    trueCaseFsPath = await getFileTrueCase(from, relative);
+    trueCaseFsPath = await resolver.getFileTrueCase(from, relative);
   } catch (error) {
-    ensureError(error, FileNotFoundError);
+    ensureError(error);
 
-    return {
-      success: false,
-      error: { type: PathValidationErrorType.DOES_NOT_EXIST },
-    };
+    if (
+      error instanceof FileNotFoundError ||
+      error instanceof NotADirectoryError
+    ) {
+      return {
+        success: false,
+        error: { type: PathValidationErrorType.DOES_NOT_EXIST },
+      };
+    }
+
+    throw error;
   }
 
   if (relative !== trueCaseFsPath) {

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

@@ -1,19 +1,33 @@
+import type { SemverVersion } from "@nomicfoundation/hardhat-utils/fast-semver";
+
 import os from "node:os";
 
-import semver from "semver";
+import { HardhatError } from "@nomicfoundation/hardhat-errors";
+import {
+  greaterThanOrEqual,
+  lowerThan,
+  parseVersion,
+} from "@nomicfoundation/hardhat-utils/fast-semver";
 
 // The first solc version with official ARM64 Linux builds
-export const FIRST_OFFICIAL_ARM64_SOLC_VERSION = "0.8.31";
+export const FIRST_OFFICIAL_ARM64_SOLC_VERSION: SemverVersion = [0, 8, 31];
 
 // The lowest solc version available in the frozen ARM64 mirror repo
 // (https://github.com/NomicFoundation/solc-linux-arm64-mirror/tree/main/public/linux/aarch64)
-export const FIRST_ARM64_MIRROR_SOLC_VERSION = "0.5.0";
+export const FIRST_ARM64_MIRROR_SOLC_VERSION: SemverVersion = [0, 5, 0];
 
 /**
  * Determines if a solc version has an official ARM64 Linux build.
  */
 export function hasOfficialArm64Build(version: string): boolean {
-  return semver.gte(version, FIRST_OFFICIAL_ARM64_SOLC_VERSION);
+  const parsed = parseVersion(version);
+  if (parsed === undefined) {
+    throw new HardhatError(
+      HardhatError.ERRORS.CORE.SOLIDITY.INVALID_SOLC_VERSION,
+      { version },
+    );
+  }
+  return greaterThanOrEqual(parsed, FIRST_OFFICIAL_ARM64_SOLC_VERSION);
 }
 
 /**
@@ -21,9 +35,16 @@ export function hasOfficialArm64Build(version: string): boolean {
  * in the community mirror (versions 0.5.0–0.8.30).
  */
 export function hasArm64MirrorBuild(version: string): boolean {
+  const parsed = parseVersion(version);
+  if (parsed === undefined) {
+    throw new HardhatError(
+      HardhatError.ERRORS.CORE.SOLIDITY.INVALID_SOLC_VERSION,
+      { version },
+    );
+  }
   return (
-    semver.gte(version, FIRST_ARM64_MIRROR_SOLC_VERSION) === true &&
-    semver.lt(version, FIRST_OFFICIAL_ARM64_SOLC_VERSION) === true
+    greaterThanOrEqual(parsed, FIRST_ARM64_MIRROR_SOLC_VERSION) &&
+    lowerThan(parsed, FIRST_OFFICIAL_ARM64_SOLC_VERSION)
   );
 }
 

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

@@ -32,7 +32,10 @@ import {
   hasOfficialArm64Build,
   missesSomeOfficialNativeBuilds,
 } from "./build-system/solc-info.js";
-import { DEFAULT_OUTPUT_SELECTION } from "./constants.js";
+import {
+  DEFAULT_OUTPUT_SELECTION,
+  SOLC_DEFAULT_OPTIMIZER_RUNS,
+} from "./constants.js";
 
 /**
  * The top-level type SolidityUserConfig is a union type too complex for
@@ -542,7 +545,7 @@ function resolveSolidityCompilerConfig(
   if (production && isSolcSolidityCompilerUserConfig(compilerConfig)) {
     defaultSettings.optimizer = {
       enabled: true,
-      runs: 200,
+      runs: SOLC_DEFAULT_OPTIMIZER_RUNS,
     };
   }
 

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

@@ -19,3 +19,6 @@ export const DEFAULT_OUTPUT_SELECTION: CompilerInput["settings"]["outputSelectio
       ],
     },
   };
+
+// This is the default that solc uses, which we also use during resolution
+export const SOLC_DEFAULT_OPTIMIZER_RUNS = 200;

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

@@ -61,6 +61,7 @@ const solidityTestUserConfigType = z.object({
       dictionaryWeight: z.number().optional(),
       includeStorage: z.boolean().optional(),
       includePushBytes: z.boolean().optional(),
+      showLogs: z.boolean().optional(),
     })
     .optional(),
   forking: z