hardhat 3.1.4 → 3.1.6

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

@@ -1,5 +1,4 @@
 import type { CompileCache } from "./cache.js";
-import type { Compiler } from "./compiler/compiler.js";
 import type { DependencyGraphImplementation } from "./dependency-graph.js";
 import type { Artifact } from "../../../../types/artifacts.js";
 import type { SolcConfig, SolidityConfig } from "../../../../types/config.js";
@@ -16,13 +15,16 @@ import type {
   EmitArtifactsResult,
   RunCompilationJobResult,
   BuildScope,
+  CacheHitInfo,
 } from "../../../../types/solidity/build-system.js";
-import type { CompilationJob } from "../../../../types/solidity/compilation-job.js";
 import type {
+  CompilationJob,
+  Compiler,
   CompilerOutput,
   CompilerOutputError,
-} from "../../../../types/solidity/compiler-io.js";
-import type { SolidityBuildInfo } from "../../../../types/solidity.js";
+  DependencyGraph,
+  SolidityBuildInfo,
+} from "../../../../types/solidity.js";
 
 import os from "node:os";
 import path from "node:path";
@@ -62,7 +64,7 @@ import {
 } from "./artifacts.js";
 import { loadCache, saveCache } from "./cache.js";
 import { CompilationJobImplementation } from "./compilation-job.js";
-import { downloadConfiguredCompilers, getCompiler } from "./compiler/index.js";
+import { downloadSolcCompilers, getCompiler } from "./compiler/index.js";
 import { buildDependencyGraph } from "./dependency-graph-building.js";
 import { readSourceFileFactory } from "./read-source-file.js";
 import {
@@ -75,10 +77,24 @@ import { SolcConfigSelector } from "./solc-config-selection.js";
 
 const log = debug("hardhat:core:solidity:build-system");
 
+// Compiler warnings to suppress from build output.
+// Each rule specifies a warning message and the source file it applies to.
+// This allows suppressing known warnings from internal files (e.g., console.sol)
+// while still showing the same warning type from user code.
+export const SUPPRESSED_WARNINGS: Array<{
+  message: string;
+  sourceFile: string;
+}> = [
+  {
+    message:
+      "Natspec memory-safe-assembly special comment for inline assembly is deprecated and scheduled for removal. Use the memory-safe block annotation instead.",
+    sourceFile: path.normalize("hardhat/console.sol"),
+  },
+];
+
 interface CompilationResult {
   compilationJob: CompilationJob;
   compilerOutput: CompilerOutput;
-  cached: boolean;
   compiler: Compiler;
 }
 
@@ -91,11 +107,29 @@ export interface SolidityBuildSystemOptions {
   readonly solidityTestsPath: string;
 }
 
+/**
+ * Returns the formatted root path for a dependency graph that has exactly one
+ * root file.
+ *
+ * @param dependencyGraph A dependency graph with exactly one root file.
+ * @returns The formatted root path.
+ * @throws If the graph doesn't have exactly one root file.
+ */
+function getSingleRootFilePath(dependencyGraph: DependencyGraph): string {
+  assertHardhatInvariant(
+    dependencyGraph.getRoots().size === 1,
+    "dependency graph doesn't have exactly 1 root file",
+  );
+
+  const [userSourceName, root] = [...dependencyGraph.getRoots().entries()][0];
+  return formatRootPath(userSourceName, root);
+}
+
 export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
   readonly #hooks: HookManager;
   readonly #options: SolidityBuildSystemOptions;
   #compileCache: CompileCache = {};
-  #downloadedCompilers = false;
+  #configuredCompilersDownloaded = false;
 
   constructor(hooks: HookManager, options: SolidityBuildSystemOptions) {
     this.#hooks = hooks;
@@ -165,6 +199,19 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
   public async build(
     rootFilePaths: string[],
     _options?: BuildOptions,
+  ): Promise<CompilationJobCreationError | Map<string, FileBuildResult>> {
+    return this.#hooks.runHandlerChain(
+      "solidity",
+      "build",
+      [rootFilePaths, _options],
+      async (_context, nextRootFilePaths, nextOptions) =>
+        this.#build(nextRootFilePaths, nextOptions),
+    );
+  }
+
+  async #build(
+    rootFilePaths: string[],
+    _options?: BuildOptions,
   ): Promise<CompilationJobCreationError | Map<string, FileBuildResult>> {
     const options: Required<BuildOptions> = {
       buildProfile: DEFAULT_BUILD_PROFILE,
@@ -196,7 +243,7 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
     spinner.start();
 
     try {
-      const { compilationJobsPerFile, indexedIndividualJobs } =
+      const { compilationJobsPerFile, indexedIndividualJobs, cacheHits } =
         compilationJobsResult;
 
       const runnableCompilationJobs = [
@@ -222,7 +269,6 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
           return {
             compilationJob: runnableCompilationJob,
             compilerOutput: output,
-            cached: false,
             compiler,
           };
         },
@@ -234,13 +280,11 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
         },
       );
 
-      const uncachedResults = results.filter((result) => !result.cached);
-      const uncachedSuccessfulResults = uncachedResults.filter(
+      const successfulResults = results.filter(
         (result) => !this.#hasCompilationErrors(result.compilerOutput),
       );
 
-      const isSuccessfulBuild =
-        uncachedResults.length === uncachedSuccessfulResults.length;
+      const isSuccessfulBuild = results.length === successfulResults.length;
 
       const contractArtifactsGeneratedByCompilationJob: Map<
         CompilationJob,
@@ -319,18 +363,6 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
             continue;
           }
 
-          if (result.cached) {
-            resultsMap.set(formatRootPath(userSourceName, root), {
-              type: FileBuildResultType.CACHE_HIT,
-              compilationJob: result.compilationJob,
-              contractArtifactsGenerated:
-                contractArtifactsGenerated.get(userSourceName) ?? [],
-              warnings: errors,
-            });
-
-            continue;
-          }
-
           resultsMap.set(formatRootPath(userSourceName, root), {
             type: FileBuildResultType.BUILD_SUCCESS,
             compilationJob: result.compilationJob,
@@ -341,6 +373,15 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
         }
       }
 
+      // Add cache hits to the results map
+      for (const [rootFilePath, cacheHitInfo] of cacheHits.entries()) {
+        resultsMap.set(rootFilePath, {
+          type: FileBuildResultType.CACHE_HIT,
+          buildId: cacheHitInfo.buildId,
+          contractArtifactsGenerated: cacheHitInfo.artifactPaths,
+        });
+      }
+
       if (!options.quiet) {
         if (isSuccessfulBuild) {
           await this.#printCompilationResult(runnableCompilationJobs, {
@@ -438,14 +479,10 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
 
         await individualJob.getBuildId(); // precompute
 
-        assertHardhatInvariant(
-          subgraph.getRoots().size === 1,
-          "individual subgraph doesn't have exactly 1 root file",
+        indexedIndividualJobs.set(
+          getSingleRootFilePath(subgraph),
+          individualJob,
         );
-
-        const rootFilePath = Array.from(subgraph.getRoots().keys())[0];
-
-        indexedIndividualJobs.set(rootFilePath, individualJob);
       }),
     );
 
@@ -454,6 +491,7 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
 
     // Select which files to compile
     const rootFilesToCompile: Set<string> = new Set();
+    const cacheHits: Map<string, CacheHitInfo> = new Map();
 
     const isolated = buildProfile.isolated;
 
@@ -503,6 +541,16 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
           break;
         }
       }
+
+      // If file was not added to rootFilesToCompile, it's a cache hit
+      if (!rootFilesToCompile.has(rootFile)) {
+        // Extract buildId from buildInfoPath (format: <dir>/<buildId>.json)
+        const buildId = path.basename(cacheResult.buildInfoPath, ".json");
+        cacheHits.set(getSingleRootFilePath(compilationJob.dependencyGraph), {
+          buildId,
+          artifactPaths,
+        });
+      }
     }
 
     if (!isolated) {
@@ -518,12 +566,7 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
       // based on reference, and not by deep equality. It misses some merging
       // opportunities, but this is Hardhat v2's behavior and works well enough.
       for (const [config, subgraph] of subgraphsWithConfig) {
-        assertHardhatInvariant(
-          subgraph.getRoots().size === 1,
-          "there should be only 1 root file on subgraph",
-        );
-
-        const rootFile = Array.from(subgraph.getRoots().keys())[0];
+        const rootFile = getSingleRootFilePath(subgraph);
 
         // Skip root files with cache hit (should not recompile)
         if (!rootFilesToCompile.has(rootFile)) {
@@ -544,12 +587,7 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
       // isolated mode
       subgraphsWithConfig = subgraphsWithConfig.filter(
         ([_config, subgraph]) => {
-          assertHardhatInvariant(
-            subgraph.getRoots().size === 1,
-            "there should be only 1 root file on subgraph",
-          );
-
-          const rootFile = Array.from(subgraph.getRoots().keys())[0];
+          const rootFile = getSingleRootFilePath(subgraph);
 
           return rootFilesToCompile.has(rootFile);
         },
@@ -581,7 +619,7 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
       }
     }
 
-    return { compilationJobsPerFile, indexedIndividualJobs };
+    return { compilationJobsPerFile, indexedIndividualJobs, cacheHits };
   }
 
   #getBuildProfile(buildProfileName: string = DEFAULT_BUILD_PROFILE) {
@@ -633,9 +671,17 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
       "The long version of the compiler should match the long version of the compilation job",
     );
 
-    const output = await compiler.compile(
-      await runnableCompilationJob.getSolcInput(),
+    const input = await runnableCompilationJob.getSolcInput();
+
+    const output = await this.#hooks.runHandlerChain(
+      "solidity",
+      "invokeSolc",
+      [compiler, input, runnableCompilationJob.solcConfig],
+      async (_context, nextCompiler, nextSolcInput) => {
+        return nextCompiler.compile(nextSolcInput);
+      },
     );
+
     return { output, compiler };
   }
 
@@ -727,7 +773,7 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
         }
       }
 
-      artifactsPerFile.set(userSourceName, paths);
+      artifactsPerFile.set(formatRootPath(userSourceName, root), paths);
 
       // Write the type declaration file, only for contracts
       if (scope === "contracts") {
@@ -735,7 +781,10 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
           fileFolder,
           "artifacts.d.ts",
         );
-        typeFilePaths.set(userSourceName, artifactsDeclarationFilePath);
+        typeFilePaths.set(
+          formatRootPath(userSourceName, root),
+          artifactsDeclarationFilePath,
+        );
 
         const artifactsDeclarationFile = getArtifactsDeclarationFile(artifacts);
 
@@ -936,22 +985,31 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
   }
 
   public async compileBuildInfo(
-    _buildInfo: SolidityBuildInfo,
-    _options?: CompileBuildInfoOptions,
+    buildInfo: SolidityBuildInfo,
+    options?: CompileBuildInfoOptions,
   ): Promise<CompilerOutput> {
-    // TODO: Download the buildinfo compiler version
-    assertHardhatInvariant(false, "Method not implemented.");
+    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
+    await downloadSolcCompilers(new Set([buildInfo.solcVersion]), quiet);
+
+    const compiler = await getCompiler(buildInfo.solcVersion, {
+      preferWasm: false,
+    });
+
+    return compiler.compile(buildInfo.input);
   }
 
   async #downloadConfiguredCompilers(quiet = false): Promise<void> {
-    // TODO: For the alpha release, we always print this message
+    // We always print that we are downloading the compilers
     quiet = false;
-    if (this.#downloadedCompilers) {
+    if (this.#configuredCompilersDownloaded) {
       return;
     }
 
-    await downloadConfiguredCompilers(this.#getAllCompilerVersions(), quiet);
-    this.#downloadedCompilers = true;
+    await downloadSolcCompilers(this.#getAllCompilerVersions(), quiet);
+    this.#configuredCompilersDownloaded = true;
   }
 
   #getAllCompilerVersions(): Set<string> {
@@ -1008,11 +1066,10 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
     isolated: boolean,
     scope: BuildScope,
   ): Promise<void> {
-    const rootFilePaths = result.compilationJob.dependencyGraph
+    for (const [userSourceName, root] of result.compilationJob.dependencyGraph
       .getRoots()
-      .keys();
-
-    for (const rootFilePath of rootFilePaths) {
+      .entries()) {
+      const rootFilePath = formatRootPath(userSourceName, root);
       const individualJob = indexedIndividualJobs.get(rootFilePath);
 
       assertHardhatInvariant(
@@ -1055,9 +1112,14 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
       return;
     }
 
+    // Filter out specific warnings that should be suppressed
+    const filteredErrors = errors.filter(
+      (error) => !this.#shouldSuppressWarning(error),
+    );
+
     console.log();
 
-    for (const error of errors) {
+    for (const error of filteredErrors) {
       if (error.severity === "error") {
         const errorMessage: string =
           this.#getFormattedInternalCompilerErrorMessage(error) ??
@@ -1077,7 +1139,7 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
       }
     }
 
-    const hasConsoleErrors: boolean = errors.some((e) =>
+    const hasConsoleErrors: boolean = filteredErrors.some((e) =>
       this.#isConsoleLogError(e),
     );
 
@@ -1091,6 +1153,14 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
     }
   }
 
+  #shouldSuppressWarning(error: CompilerOutputError): boolean {
+    const msg = error.formattedMessage ?? error.message;
+
+    return SUPPRESSED_WARNINGS.some(
+      (rule) => msg.includes(rule.message) && msg.includes(rule.sourceFile),
+    );
+  }
+
   async #printCompilationResult(
     runnableCompilationJobs: CompilationJob[],
     options: { scope: BuildScope },

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

@@ -2,6 +2,7 @@ import type {
   CompilerInput,
   CompilerOutput,
 } from "../../../../../types/solidity/compiler-io.js";
+import type { Compiler } from "../../../../../types/solidity/compiler.js";
 
 import { spawn } from "node:child_process";
 import fsPromises from "node:fs/promises";
@@ -23,15 +24,6 @@ import {
 import { createNonClosingWriter } from "@nomicfoundation/hardhat-utils/stream";
 import * as semver from "semver";
 
-export interface Compiler {
-  readonly version: string;
-  readonly longVersion: string;
-  readonly compilerPath: string;
-  readonly isSolcJs: boolean;
-
-  compile(input: CompilerInput): Promise<CompilerOutput>;
-}
-
 /**
  * Spawns a compilation process and returns its output.
  *

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

@@ -1,4 +1,4 @@
-import type { Compiler } from "./compiler.js";
+import type { Compiler } from "../../../../../../src/types/solidity.js";
 
 import { execFile } from "node:child_process";
 import os from "node:os";
@@ -32,6 +32,8 @@ import { NativeCompiler, SolcJsCompiler } from "./compiler.js";
 const log = debug("hardhat:solidity:downloader");
 
 const COMPILER_REPOSITORY_URL = "https://binaries.soliditylang.org";
+const DEFAULT_COMPILER_DOWNLOAD_RETRY_COUNT = 3;
+const DEFAULT_COMPILER_DOWNLOAD_RETRY_DELAY_MS = 2000;
 
 // We use a mirror of nikitastupin/solc because downloading directly from
 // github has rate limiting issues
@@ -211,29 +213,27 @@ export class CompilerDownloaderImplementation implements CompilerDownloader {
 
       const build = await this.#getCompilerBuild(version);
 
-      let downloadPath: string;
-      try {
-        downloadPath = await this.#downloadCompiler(build);
-      } catch (e) {
-        ensureError(e);
-
-        throw new HardhatError(
-          HardhatError.ERRORS.CORE.SOLIDITY.DOWNLOAD_FAILED,
-          {
-            remoteVersion: build.longVersion,
-          },
-          e,
-        );
-      }
-
-      const verified = await this.#verifyCompilerDownload(build, downloadPath);
-      if (!verified) {
-        throw new HardhatError(
-          HardhatError.ERRORS.CORE.SOLIDITY.INVALID_DOWNLOAD,
-          {
-            remoteVersion: build.longVersion,
-          },
-        );
+      let downloadPath: string = "";
+      for (let i = 0; i <= DEFAULT_COMPILER_DOWNLOAD_RETRY_COUNT; i++) {
+        try {
+          downloadPath = await this.#downloadAndVerifyCompiler(build);
+          break;
+        } catch (e) {
+          if (i === DEFAULT_COMPILER_DOWNLOAD_RETRY_COUNT) {
+            ensureError(e);
+            throw e;
+          } else {
+            const attempt = i + 1;
+
+            log(
+              `Download or verification failed for solc ${version}, retrying (attempt ${attempt} of ${DEFAULT_COMPILER_DOWNLOAD_RETRY_COUNT})`,
+            );
+
+            await new Promise((resolve) =>
+              setTimeout(resolve, DEFAULT_COMPILER_DOWNLOAD_RETRY_DELAY_MS),
+            );
+          }
+        }
       }
 
       return this.#postProcessCompilerDownload(build, downloadPath);
@@ -391,6 +391,36 @@ export class CompilerDownloaderImplementation implements CompilerDownloader {
     }
   }
 
+  async #downloadAndVerifyCompiler(build: CompilerBuild): Promise<string> {
+    let downloadPath: string = "";
+
+    try {
+      downloadPath = await this.#downloadCompiler(build);
+    } catch (e) {
+      ensureError(e);
+
+      throw new HardhatError(
+        HardhatError.ERRORS.CORE.SOLIDITY.DOWNLOAD_FAILED,
+        {
+          remoteVersion: build.longVersion,
+        },
+        e,
+      );
+    }
+
+    const verified = await this.#verifyCompilerDownload(build, downloadPath);
+    if (!verified) {
+      throw new HardhatError(
+        HardhatError.ERRORS.CORE.SOLIDITY.INVALID_DOWNLOAD,
+        {
+          remoteVersion: build.longVersion,
+        },
+      );
+    }
+
+    return downloadPath;
+  }
+
   async #downloadCompiler(build: CompilerBuild): Promise<string> {
     // use the explicit URL if available or the default solc download URL if not
     const defaultUrl = `${COMPILER_REPOSITORY_URL}/${this.#platform}`;

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

@@ -1,3 +1,5 @@
+import type { Compiler } from "../../../../../types/solidity.js";
+
 import { execFile } from "node:child_process";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
@@ -11,7 +13,7 @@ import { exists, isBinaryFile } from "@nomicfoundation/hardhat-utils/fs";
 import { getCacheDir } from "@nomicfoundation/hardhat-utils/global-dir";
 import debug from "debug";
 
-import { NativeCompiler, SolcJsCompiler, type Compiler } from "./compiler.js";
+import { NativeCompiler, SolcJsCompiler } from "./compiler.js";
 import {
   CompilerDownloaderImplementation,
   CompilerPlatform,
@@ -26,7 +28,7 @@ async function getGlobalCompilersCacheDir(): Promise<string> {
 
 const log = debug("hardhat:core:solidity:build-system:compiler");
 
-export async function downloadConfiguredCompilers(
+export async function downloadSolcCompilers(
   versions: Set<string>,
   quiet: boolean,
 ): Promise<void> {

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

@@ -63,7 +63,7 @@ export function isNpmParsedRootPath(
 
 /**
  * Formats the path of a root file, making it compatible with the
- * SolidityBuildSystem APIs.
+ * SolidityBuildSystem APIs, which expect an absolute path or an npm: root path.
  *
  * @param userSourceName The user source name of the root file.
  * @param rootFile The root file.
@@ -74,7 +74,7 @@ export function formatRootPath(
   rootFile: ResolvedFile,
 ): string {
   if (rootFile.type !== ResolvedFileType.NPM_PACKAGE_FILE) {
-    return userSourceName;
+    return rootFile.fsPath;
   }
 
   return `npm:${userSourceName}`;

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

@@ -114,7 +114,10 @@ async function buildForScope(
 
   // If we recompiled the entire project we cleanup the artifacts
   if (isFullCompilation) {
-    await solidity.cleanupArtifacts(rootPaths, { scope });
+    // Use the root files from the build results, which may include
+    // additional files added by plugins hooking into solidity#build
+    const builtRootPaths = [...results.keys()];
+    await solidity.cleanupArtifacts(builtRootPaths, { scope });
   }
 
   return { rootPaths, usedFiles };

package/src/internal/builtin-plugins/solidity/type-extensions.ts

@@ -1,5 +1,15 @@
-import type { SolidityBuildSystem } from "../../../types/solidity/build-system.js";
-import type { CompilerInput } from "../../../types/solidity.js";
+import type { SolcConfig } from "../../../types/config.js";
+import type {
+  BuildOptions,
+  CompilationJobCreationError,
+  FileBuildResult,
+  SolidityBuildSystem,
+} from "../../../types/solidity/build-system.js";
+import type {
+  Compiler,
+  CompilerInput,
+  CompilerOutput,
+} from "../../../types/solidity.js";
 
 import "../../../types/config.js";
 declare module "../../../types/config.js" {
@@ -123,7 +133,10 @@ declare module "../../../types/hooks.js" {
     ) => Promise<void>;
 
     /**
-     * Hook triggered within the compilation job when its' solc input is first constructed.
+     * Hook triggered to preprocess a Solidity file and manipulate its contents
+     * before it is passed along for compilation. Only files directly under
+     * the Hardhat project are preprocessed, Solidity files from npm
+     * dependencies are not included.
      *
      * @param context The hook context.
      * @param inputSourceName The input source name of the project file.
@@ -177,5 +190,55 @@ declare module "../../../types/hooks.js" {
         nextAbsolutePath: string,
       ) => Promise<string>,
     ) => Promise<string>;
+
+    /**
+     * Hook triggered when a Solidity build process is run using the `build`
+     * method of the Solidity build system.
+     *
+     * @param context The hook context.
+     * @param rootFilePaths The files to build, which can be either absolute
+     * paths or `npm:<package-name>/<file-path>` URIs.
+     * @param options The options to use when building the files.
+     * @param next A function to call the next handler for this hook.
+     */
+    build: (
+      context: HookContext,
+      rootFilePaths: string[],
+      options: BuildOptions | undefined,
+      next: (
+        nextContext: HookContext,
+        nextRootFilePaths: string[],
+        nextOptions: BuildOptions | undefined,
+      ) => Promise<CompilationJobCreationError | Map<string, FileBuildResult>>,
+    ) => Promise<CompilationJobCreationError | Map<string, FileBuildResult>>;
+
+    /**
+     * Hook triggered to invoke a passed in Solc compiler on the
+     * Solc input generated for a given compilation job.
+     * This hook allows for manipulating the Solc input passed into the Solc
+     * compiler Hardhat has selected for the compilation job, and similarly to
+     * manipulate the Solc output.
+     *
+     * @param context The hook context.
+     * @param compile The Solc compiler selected by Hardhat for this compilation
+     * job.
+     * @param solcInput The solc input json constructed from the compilation
+     * job.
+     * @param solcConfig The configuration used to setup solc e.g. version.
+     * @param next A function to call the next handler for this hook, or the
+     * default implementation if no more handlers exist.
+     */
+    invokeSolc(
+      context: HookContext,
+      compiler: Compiler,
+      solcInput: CompilerInput,
+      solcConfig: SolcConfig,
+      next: (
+        nextContext: HookContext,
+        nextCompiler: Compiler,
+        nextSolcInput: CompilerInput,
+        nextSolcConfig: SolcConfig,
+      ) => Promise<CompilerOutput>,
+    ): Promise<CompilerOutput>;
   }
 }