hardhat 3.4.1 → 3.4.3

package/src/internal/builtin-plugins/network-manager/edr/types/hardfork.ts

@@ -1,12 +1,6 @@
 import type { ChainType } from "../../../../../types/network.js";
 
-import { l1HardforkLatest, opLatestHardfork } from "@nomicfoundation/edr";
-
 import { OPTIMISM_CHAIN_TYPE } from "../../../../constants.js";
-import {
-  edrL1HardforkToHardhatL1HardforkName,
-  edrOpHardforkToHardhatOpHardforkName,
-} from "../utils/convert-to-edr.js";
 
 export enum L1HardforkName {
   FRONTIER = "chainstart",
@@ -51,9 +45,9 @@ export function getHardforks(chainType: ChainType): string[] {
 }
 
 export function getCurrentHardfork(chainType: ChainType): string {
-  return chainType === OPTIMISM_CHAIN_TYPE
-    ? edrOpHardforkToHardhatOpHardforkName(opLatestHardfork())
-    : edrL1HardforkToHardhatL1HardforkName(l1HardforkLatest());
+  const order =
+    chainType === OPTIMISM_CHAIN_TYPE ? OP_HARDFORK_ORDER : L1_HARDFORK_ORDER;
+  return order[order.length - 1];
 }
 
 /**

package/src/internal/builtin-plugins/network-manager/edr/utils/convert-to-edr.ts

@@ -61,7 +61,7 @@ import {
   DEFAULT_EDR_NETWORK_BALANCE,
   EDR_NETWORK_DEFAULT_PRIVATE_KEYS,
   isDefaultEdrNetworkHDAccountsConfig,
-} from "../edr-provider.js";
+} from "../edr-constants.js";
 import { L1HardforkName, OpHardforkName } from "../types/hardfork.js";
 
 import { getL1HardforkName, getOpHardforkName } from "./hardfork.js";

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,22 +2,23 @@ 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;
 
 import { sendErrorTelemetry } from "../../cli/telemetry/error-reporter/reporter.js";
-import { isDefaultEdrNetworkHDAccountsConfig } from "../network-manager/edr/edr-provider.js";
+import { isDefaultEdrNetworkHDAccountsConfig } from "../network-manager/edr/edr-constants.js";
 import { normalizeEdrNetworkAccountsConfig } from "../network-manager/edr/utils/convert-to-edr.js";
 
 export async function formatEdrNetworkConfigAccounts(
@@ -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,
@@ -49,12 +51,11 @@ import {
   writeJsonFile,
   writeJsonFileAsStream,
   writeUtf8File,
+  readdirOrEmpty,
 } from "@nomicfoundation/hardhat-utils/fs";
 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";
@@ -70,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";
@@ -83,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.
@@ -176,23 +178,15 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
     options: { scope?: BuildScope } = {},
   ): Promise<string[]> {
     const scope = options.scope ?? "contracts";
-    const unified = !this.#options.solidityConfig.splitTestsCompilation;
 
     this.#ensureSplitCompilationModeIfTestsScope(scope);
 
+    const unified = !this.#options.solidityConfig.splitTestsCompilation;
+    const { localContractFiles, sourceTestFiles } =
+      await this.#getSoliditySourcesRootFilePaths();
+
     switch (scope) {
       case "contracts": {
-        const localContractFiles = (
-          await Promise.all(
-            this.#options.soliditySourcesPaths.map((dir) =>
-              getAllFilesMatching(
-                dir,
-                (f) => f.endsWith(".sol") && !f.endsWith(".t.sol"),
-              ),
-            ),
-          )
-        ).flat(1);
-
         const npmFilesToBuild =
           this.#options.solidityConfig.npmFilesToBuild.map(
             npmModuleToNpmRootPath,
@@ -204,18 +198,12 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
 
         // In unified mode, contracts scope returns all roots: contracts,
         // tests, and npm files.
-        const testFiles = (
-          await Promise.all([
-            getAllFilesMatching(this.#options.solidityTestsPath, (f) =>
-              f.endsWith(".sol"),
-            ),
-            ...this.#options.soliditySourcesPaths.map(async (dir) => {
-              return await getAllFilesMatching(dir, (f) =>
-                f.endsWith(".t.sol"),
-              );
-            }),
-          ])
-        ).flat(1);
+        const testFiles = [
+          ...(await getAllFilesMatching(this.#options.solidityTestsPath, (f) =>
+            f.endsWith(".sol"),
+          )),
+          ...sourceTestFiles,
+        ];
 
         // Remove duplicates in case there is an intersection between
         // the tests.solidity paths and the sources paths
@@ -224,18 +212,12 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
         );
       }
       case "tests": {
-        let rootFilePaths = (
-          await Promise.all([
-            getAllFilesMatching(this.#options.solidityTestsPath, (f) =>
-              f.endsWith(".sol"),
-            ),
-            ...this.#options.soliditySourcesPaths.map(async (dir) => {
-              return await getAllFilesMatching(dir, (f) =>
-                f.endsWith(".t.sol"),
-              );
-            }),
-          ])
-        ).flat(1);
+        let rootFilePaths = [
+          ...(await getAllFilesMatching(this.#options.solidityTestsPath, (f) =>
+            f.endsWith(".sol"),
+          )),
+          ...sourceTestFiles,
+        ];
 
         // NOTE: We remove duplicates in case there is an intersection between
         // the tests.solidity paths and the sources paths
@@ -245,6 +227,46 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
     }
   }
 
+  /**
+   * Returns all the root files from the different solidity source dirs in the
+   * config, partitioned into contract files and test files according to their
+   * extensions.
+   */
+  async #getSoliditySourcesRootFilePaths(): Promise<{
+    localContractFiles: string[];
+    sourceTestFiles: string[];
+  }> {
+    const sourceFileGroups = await Promise.all(
+      this.#options.soliditySourcesPaths.map(async (dir) => {
+        const localSolidityFiles = await getAllFilesMatching(dir, (f) =>
+          f.endsWith(".sol"),
+        );
+
+        const localContractFiles: string[] = [];
+        const sourceTestFiles: string[] = [];
+
+        for (const file of localSolidityFiles) {
+          if (file.endsWith(".t.sol")) {
+            sourceTestFiles.push(file);
+          } else {
+            localContractFiles.push(file);
+          }
+        }
+
+        return { localContractFiles, sourceTestFiles };
+      }),
+    );
+
+    return {
+      localContractFiles: sourceFileGroups.flatMap(
+        ({ localContractFiles }) => localContractFiles,
+      ),
+      sourceTestFiles: sourceFileGroups.flatMap(
+        ({ sourceTestFiles }) => sourceTestFiles,
+      ),
+    };
+  }
+
   public isSuccessfulBuildResult(
     buildResult: CompilationJobCreationError | Map<string, FileBuildResult>,
   ): buildResult is Map<string, FileBuildResult> {
@@ -318,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,
@@ -1102,18 +1134,23 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
       reachableBuildInfoIds.filter((id) => id !== undefined),
     );
 
-    // Get all the reachable build info files
-    const buildInfoFiles = await getAllFilesMatching(buildInfosDir, (f) =>
-      f.startsWith(buildInfosDir + path.sep),
-    );
+    // The build-info directory is expected to be flat: every build-info file
+    // lives directly under it, so a non-recursive `readdir` is enough.
+    const buildInfoFiles = await readdirOrEmpty(buildInfosDir);
 
     for (const buildInfoFile of buildInfoFiles) {
-      const basename = path.basename(buildInfoFile);
+      let id: string | undefined;
 
-      const id = basename.substring(0, basename.indexOf("."));
+      if (buildInfoFile.endsWith(".output.json")) {
+        id = buildInfoFile.slice(0, -".output.json".length);
+      } else if (buildInfoFile.endsWith(".json")) {
+        id = buildInfoFile.slice(0, -".json".length);
+      } else {
+        continue;
+      }
 
       if (!reachableBuildInfoIdsSet.has(id)) {
-        await remove(buildInfoFile);
+        await remove(path.join(buildInfosDir, buildInfoFile));
       }
     }
 
@@ -1330,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",
         );
       }
@@ -1348,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.`,
         ),
       );
@@ -1441,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);
+}