hardhat 3.0.6 → 3.0.8

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

@@ -1,19 +1,30 @@
 import type { EdrNetworkConfigOverride } from "../../../types/config.js";
 import type { NewTaskActionFunction } from "../../../types/tasks.js";
 
+import path from "node:path";
+
 import {
   assertHardhatInvariant,
   HardhatError,
 } from "@nomicfoundation/hardhat-errors";
-import { exists } from "@nomicfoundation/hardhat-utils/fs";
+import { ensureDir, exists } from "@nomicfoundation/hardhat-utils/fs";
 import chalk from "chalk";
+import debug from "debug";
 
 import { DEFAULT_NETWORK_NAME } from "../../constants.js";
 import { isSupportedChainType } from "../../edr/chain-type.js";
+import { BUILD_INFO_DIR_NAME } from "../artifacts/artifact-manager.js";
+import { EdrProvider } from "../network-manager/edr/edr-provider.js";
 
-import { formatEdrNetworkConfigAccounts } from "./helpers.js";
+import { watchBuildInfo } from "./artifacts/build-info-watcher.js";
+import {
+  createBuildInfoUploadHandlerFrom,
+  formatEdrNetworkConfigAccounts,
+} from "./helpers.js";
 import { JsonRpcServerImplementation } from "./json-rpc/server.js";
 
+const log = debug("hardhat:core:tasks:node");
+
 interface NodeActionArguments {
   hostname?: string;
   port: number;
@@ -94,6 +105,11 @@ const nodeAction: NewTaskActionFunction<NodeActionArguments> = async (
     override: networkConfigOverride,
   });
 
+  assertHardhatInvariant(
+    provider instanceof EdrProvider,
+    "Provider must be EdrProvider, since only edr networks are supported",
+  );
+
   // NOTE: We enable logging for the node
   await provider.request({
     method: "hardhat_setLoggingEnabled",
@@ -112,7 +128,7 @@ const nodeAction: NewTaskActionFunction<NodeActionArguments> = async (
     }
   }
 
-  const server: JsonRpcServerImplementation = new JsonRpcServerImplementation({
+  const server = new JsonRpcServerImplementation({
     hostname,
     port: args.port,
     provider,
@@ -128,7 +144,16 @@ const nodeAction: NewTaskActionFunction<NodeActionArguments> = async (
 
   console.log();
 
-  // TODO(https://github.com/NomicFoundation/hardhat/issues/6040): Add build info watcher here
+  const buildInfoDirPath = path.join(
+    hre.config.paths.artifacts,
+    BUILD_INFO_DIR_NAME,
+  );
+  await ensureDir(buildInfoDirPath);
+
+  const buildInfoWatcher = await watchBuildInfo(
+    buildInfoDirPath,
+    createBuildInfoUploadHandlerFrom(buildInfoDirPath, provider, log),
+  );
 
   // NOTE: Before creating the node, we check if the input network config is of type edr.
   // We only proceed if it is. Hence, we can assume that the output network config is of type edr as well.
@@ -139,7 +164,8 @@ const nodeAction: NewTaskActionFunction<NodeActionArguments> = async (
 
   console.log(await formatEdrNetworkConfigAccounts(networkConfig.accounts));
 
-  await server.waitUntilClosed();
+  await server.afterClosed();
+  await buildInfoWatcher.close();
 };
 
 export default nodeAction;

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

@@ -15,6 +15,7 @@ import type {
   GetCompilationJobsResult,
   EmitArtifactsResult,
   RunCompilationJobResult,
+  BuildScope,
 } from "../../../../types/solidity/build-system.js";
 import type { CompilationJob } from "../../../../types/solidity/compilation-job.js";
 import type {
@@ -32,8 +33,10 @@ import {
 } from "@nomicfoundation/hardhat-errors";
 import {
   exists,
+  ensureDir,
   getAllDirectoriesMatching,
   getAllFilesMatching,
+  move,
   readJsonFile,
   remove,
   writeJsonFile,
@@ -41,6 +44,7 @@ import {
   writeUtf8File,
 } 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";
@@ -91,7 +95,6 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
   readonly #hooks: HookManager;
   readonly #options: SolidityBuildSystemOptions;
   #compileCache: CompileCache = {};
-  readonly #defaultConcurrency = Math.max(os.cpus().length - 1, 1);
   #downloadedCompilers = false;
 
   constructor(hooks: HookManager, options: SolidityBuildSystemOptions) {
@@ -99,37 +102,90 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
     this.#options = options;
   }
 
-  public async getRootFilePaths(): Promise<string[]> {
-    const localFilesToCompile = (
-      await Promise.all(
-        this.#options.soliditySourcesPaths.map((dir) =>
-          getAllFilesMatching(
-            dir,
-            (f) => f.endsWith(".sol") && !f.endsWith(".t.sol"),
-          ),
-        ),
-      )
-    ).flat(1);
+  public async getScope(fsPath: string): Promise<BuildScope> {
+    if (
+      fsPath.startsWith(this.#options.solidityTestsPath) &&
+      fsPath.endsWith(".sol")
+    ) {
+      return "tests";
+    }
 
-    const npmFilesToBuild = this.#options.solidityConfig.npmFilesToBuild.map(
-      npmModuleToNpmRootPath,
-    );
+    for (const sourcesPath of this.#options.soliditySourcesPaths) {
+      if (fsPath.startsWith(sourcesPath) && fsPath.endsWith(".t.sol")) {
+        return "tests";
+      }
+    }
+
+    return "contracts";
+  }
 
-    return [...localFilesToCompile, ...npmFilesToBuild];
+  public async getRootFilePaths(
+    options: { scope?: BuildScope } = {},
+  ): Promise<string[]> {
+    const scope = options.scope ?? "contracts";
+
+    switch (scope) {
+      case "contracts":
+        const localFilesToCompile = (
+          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,
+          );
+
+        return [...localFilesToCompile, ...npmFilesToBuild];
+      case "tests":
+        let rootFilePaths = (
+          await Promise.all([
+            getAllFilesMatching(this.#options.solidityTestsPath, (f) =>
+              f.endsWith(".sol"),
+            ),
+            ...this.#options.soliditySourcesPaths.map(async (dir) => {
+              return getAllFilesMatching(dir, (f) => f.endsWith(".t.sol"));
+            }),
+          ])
+        ).flat(1);
+
+        // NOTE: We remove duplicates in case there is an intersection between
+        // the tests.solidity paths and the sources paths
+        rootFilePaths = Array.from(new Set(rootFilePaths));
+        return rootFilePaths;
+    }
   }
 
   public async build(
     rootFilePaths: string[],
-    options?: BuildOptions,
+    _options?: BuildOptions,
   ): Promise<CompilationJobCreationError | Map<string, FileBuildResult>> {
-    if (options?.quiet !== true) {
-      console.log("Compiling your Solidity contracts...");
-    }
+    const options: Required<BuildOptions> = {
+      buildProfile: DEFAULT_BUILD_PROFILE,
+      concurrency: Math.max(os.cpus().length - 1, 1),
+      force: false,
+      isolated: false,
+      quiet: false,
+      scope: "contracts",
+      ..._options,
+    };
 
-    await this.#downloadConfiguredCompilers(options?.quiet);
+    const spinner = createSpinner({
+      text: `Compiling your Solidity ${options.scope}...`,
+      enabled: !options.quiet,
+    });
+
+    await this.#downloadConfiguredCompilers(options.quiet);
+
+    spinner.start();
 
-    const buildProfileName = options?.buildProfile ?? DEFAULT_BUILD_PROFILE;
-    const { buildProfile } = this.#getBuildProfile(buildProfileName);
+    const { buildProfile } = this.#getBuildProfile(options.buildProfile);
 
     const compilationJobsResult = await this.getCompilationJobs(
       rootFilePaths,
@@ -137,6 +193,7 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
     );
 
     if ("reason" in compilationJobsResult) {
+      spinner.stop();
       return compilationJobsResult;
     }
 
@@ -171,7 +228,7 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
         };
       },
       {
-        concurrency: options?.concurrency ?? this.#defaultConcurrency,
+        concurrency: options.concurrency,
         // An error when running the compiler is not a compilation failure, but
         // a fatal failure trying to run it, so we just throw on the first error
         stopOnError: true,
@@ -198,6 +255,7 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
           const emitArtifactsResult = await this.emitArtifacts(
             compilationResult.compilationJob,
             compilationResult.compilerOutput,
+            options,
           );
 
           const { artifactsPerFile } = emitArtifactsResult;
@@ -213,6 +271,7 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
             compilationResult,
             emitArtifactsResult,
             buildProfile.isolated,
+            options.scope,
           );
         }),
       );
@@ -222,6 +281,8 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
 
     const resultsMap: Map<string, FileBuildResult> = new Map();
 
+    spinner.stop();
+
     for (const result of results) {
       const contractArtifactsGenerated = isSuccessfulBuild
         ? contractArtifactsGeneratedByCompilationJob.get(result.compilationJob)
@@ -239,7 +300,6 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
       );
 
       this.#printSolcErrorsAndWarnings(errors);
-
       const successfulResult = !this.#hasCompilationErrors(
         result.compilerOutput,
       );
@@ -279,7 +339,7 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
       }
     }
 
-    if (options?.quiet !== true) {
+    if (!options.quiet) {
       if (isSuccessfulBuild) {
         await this.#printCompilationResult(runnableCompilationJobs);
       }
@@ -426,6 +486,11 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
         buildInfoOutputPath,
         typeFilePath,
       ]) {
+        // Type declaration file can be undefined (e.g. for solidity tests)
+        if (outputFilePath === undefined) {
+          continue;
+        }
+
         if (!(await exists(outputFilePath))) {
           rootFilesToCompile.add(rootFile);
           break;
@@ -603,18 +668,23 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
   public async emitArtifacts(
     runnableCompilationJob: CompilationJob,
     compilerOutput: CompilerOutput,
+    options: { scope?: BuildScope } = {},
   ): Promise<EmitArtifactsResult> {
+    const scope = options.scope ?? "contracts";
+
     const artifactsPerFile = new Map<string, string[]>();
     const typeFilePaths = new Map<string, string>();
     const buildId = await runnableCompilationJob.getBuildId();
 
+    const artifactsDirectory = await this.getArtifactsDirectory(scope);
+
     // We emit the artifacts for each root file, first emitting one artifact
     // for each contract, and then one declaration file for the entire file,
     // which defines their types and augments the ArtifactMap type.
     for (const [userSourceName, root] of runnableCompilationJob.dependencyGraph
       .getRoots()
       .entries()) {
-      const fileFolder = path.join(this.#options.artifactsPath, userSourceName);
+      const fileFolder = path.join(artifactsDirectory, userSourceName);
 
       // If the folder exists, we remove it first, as we don't want to leave
       // any old artifacts there.
@@ -652,45 +722,60 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
 
       artifactsPerFile.set(userSourceName, paths);
 
-      const artifactsDeclarationFilePath = path.join(
-        fileFolder,
-        "artifacts.d.ts",
-      );
-      typeFilePaths.set(userSourceName, artifactsDeclarationFilePath);
+      // Write the type declaration file, only for contracts
+      if (scope === "contracts") {
+        const artifactsDeclarationFilePath = path.join(
+          fileFolder,
+          "artifacts.d.ts",
+        );
+        typeFilePaths.set(userSourceName, artifactsDeclarationFilePath);
 
-      const artifactsDeclarationFile = getArtifactsDeclarationFile(artifacts);
+        const artifactsDeclarationFile = getArtifactsDeclarationFile(artifacts);
 
-      await writeUtf8File(
-        artifactsDeclarationFilePath,
-        artifactsDeclarationFile,
-      );
+        await writeUtf8File(
+          artifactsDeclarationFilePath,
+          artifactsDeclarationFile,
+        );
+      }
     }
 
     // Once we have emitted all the contract artifacts and its declaration
     // file, we emit the build info file and its output file.
     const buildInfoId = buildId;
 
-    const buildInfoPath = path.join(
-      this.#options.artifactsPath,
+    const buildInfoCacheDirPath = path.join(
+      this.#options.cachePath,
       `build-info`,
+    );
+
+    await ensureDir(buildInfoCacheDirPath);
+
+    const buildInfoCachePath = path.join(
+      buildInfoCacheDirPath,
       `${buildInfoId}.json`,
     );
 
-    const buildInfoOutputPath = path.join(
-      this.#options.artifactsPath,
-      `build-info`,
+    const buildInfoOutputCachePath = path.join(
+      buildInfoCacheDirPath,
       `${buildInfoId}.output.json`,
     );
 
     // BuildInfo and BuildInfoOutput files are large, so we write them
     // concurrently, and keep their lifetimes separated and small.
+    // NOTE: First, we write the build info file and its output to the cache
+    // directory. Once both are successfully written, we move them to the
+    // artifacts directory sequentially, ensuring the build info file is moved
+    // last. This approach minimizes the risk of having corrupted build info
+    // files in the artifacts directory and ensures other processes, like
+    // `hardhat node`, can safely monitor the build info file as an indicator
+    // for build completion.
     await Promise.all([
       (async () => {
         const buildInfo = await getBuildInfo(runnableCompilationJob);
 
         // TODO: Maybe formatting the build info is slow, but it's mostly
         // strings, so it probably shouldn't be a problem.
-        await writeJsonFile(buildInfoPath, buildInfo);
+        await writeJsonFile(buildInfoCachePath, buildInfo);
       })(),
       (async () => {
         const buildInfoOutput = await getBuildInfoOutput(
@@ -703,10 +788,24 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
         // TODO: Earlier in the build process, very similar files are created on disk by the
         // Compiler.  Instead of creating them again, we should consider copying/moving them.
         // This would require changing the format of the build info output file.
-        await writeJsonFileAsStream(buildInfoOutputPath, buildInfoOutput);
+        await writeJsonFileAsStream(buildInfoOutputCachePath, buildInfoOutput);
       })(),
     ]);
 
+    const buildInfoDirPath = path.join(artifactsDirectory, `build-info`);
+
+    await ensureDir(buildInfoDirPath);
+
+    const buildInfoPath = path.join(buildInfoDirPath, `${buildInfoId}.json`);
+
+    const buildInfoOutputPath = path.join(
+      buildInfoDirPath,
+      `${buildInfoId}.output.json`,
+    );
+
+    await move(buildInfoOutputCachePath, buildInfoOutputPath);
+    await move(buildInfoCachePath, buildInfoPath);
+
     return {
       artifactsPerFile,
       buildInfoPath,
@@ -715,55 +814,54 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
     };
   }
 
-  public async cleanupArtifacts(rootFilePaths: string[]): Promise<void> {
+  public async getArtifactsDirectory(scope: BuildScope): Promise<string> {
+    return scope === "contracts"
+      ? this.#options.artifactsPath
+      : path.join(this.#options.cachePath, "test-artifacts");
+  }
+
+  public async cleanupArtifacts(
+    rootFilePaths: string[],
+    options: { scope?: BuildScope } = {},
+  ): Promise<void> {
     log(`Cleaning up artifacts`);
 
+    const scope = options.scope ?? "contracts";
+    const artifactsDirectory = await this.getArtifactsDirectory(scope);
+
     const userSourceNames = rootFilePaths.map((rootFilePath) => {
       const parsed = parseRootPath(rootFilePath);
       return isNpmParsedRootPath(parsed)
         ? parsed.npmPath
-        : path.relative(this.#options.projectRoot, parsed.fsPath);
+        : toForwardSlash(
+            path.relative(this.#options.projectRoot, parsed.fsPath),
+          );
     });
 
     const userSourceNamesSet = new Set(userSourceNames);
 
     for (const file of await getAllDirectoriesMatching(
-      this.#options.artifactsPath,
+      artifactsDirectory,
       (d) => d.endsWith(".sol"),
     )) {
-      const relativePath = path.relative(this.#options.artifactsPath, file);
-
-      const testDirectorySubpath = path.relative(
-        this.#options.projectRoot,
-        this.#options.solidityTestsPath,
-      );
-      const hasTestFileExtension = file.endsWith(".t.sol");
-      const isInsideTestFolder = relativePath.startsWith(
-        testDirectorySubpath + path.sep,
+      const relativePath = toForwardSlash(
+        path.relative(artifactsDirectory, file),
       );
 
-      // Skip test artifacts, since our full compilation doesn't include them, they would incorrectly be marked for deletion
-      if (hasTestFileExtension || isInsideTestFolder) {
-        continue;
-      }
-
       if (!userSourceNamesSet.has(relativePath)) {
         await remove(file);
       }
     }
 
-    const buildInfosDir = path.join(this.#options.artifactsPath, `build-info`);
+    const buildInfosDir = path.join(artifactsDirectory, `build-info`);
 
     // TODO: This logic is duplicated with respect to the artifacts manager
     const artifactPaths = await getAllFilesMatching(
-      this.#options.artifactsPath,
+      artifactsDirectory,
       (p) =>
         p.endsWith(".json") && // Only consider json files
         // Ignore top level json files
-        p.indexOf(
-          path.sep,
-          this.#options.artifactsPath.length + path.sep.length,
-        ) !== -1,
+        p.indexOf(path.sep, artifactsDirectory.length + path.sep.length) !== -1,
       (dir) => dir !== buildInfosDir,
     );
 
@@ -793,40 +891,41 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
       }
     }
 
-    // Get duplicated contract names
-    const artifactNameCounts = new Map<string, number>();
-    for (const artifactPath of artifactPaths) {
-      const basename = path.basename(artifactPath);
-      const name = basename.substring(0, basename.indexOf("."));
+    // These steps only apply when compiling contracts
+    if (scope === "contracts") {
+      // Get duplicated contract names and write a top-level artifacts.d.ts file
+      const artifactNameCounts = new Map<string, number>();
+      for (const artifactPath of artifactPaths) {
+        const basename = path.basename(artifactPath);
+        const name = basename.substring(0, basename.indexOf("."));
 
-      let count = artifactNameCounts.get(name);
-      if (count === undefined) {
-        count = 0;
-      }
+        const count = artifactNameCounts.get(name) ?? 0;
 
-      artifactNameCounts.set(name, count + 1);
-    }
+        artifactNameCounts.set(name, count + 1);
+      }
 
-    const duplicatedNames = [...artifactNameCounts.entries()]
-      .filter(([_, count]) => count > 1)
-      .map(([name, _]) => name);
+      const duplicatedNames = [...artifactNameCounts.entries()]
+        .filter(([_, count]) => count > 1)
+        .map(([name, _]) => name);
 
-    const duplicatedContractNamesDeclarationFilePath = path.join(
-      this.#options.artifactsPath,
-      "artifacts.d.ts",
-    );
+      const duplicatedContractNamesDeclarationFilePath = path.join(
+        artifactsDirectory,
+        "artifacts.d.ts",
+      );
 
-    await writeUtf8File(
-      duplicatedContractNamesDeclarationFilePath,
-      getDuplicatedContractNamesDeclarationFile(duplicatedNames),
-    );
+      await writeUtf8File(
+        duplicatedContractNamesDeclarationFilePath,
+        getDuplicatedContractNamesDeclarationFile(duplicatedNames),
+      );
 
-    await this.#hooks.runHandlerChain(
-      "solidity",
-      "onCleanUpArtifacts",
-      [artifactPaths],
-      async () => {},
-    );
+      // Run the onCleanUpArtifacts hook
+      await this.#hooks.runHandlerChain(
+        "solidity",
+        "onCleanUpArtifacts",
+        [artifactPaths],
+        async () => {},
+      );
+    }
   }
 
   public async compileBuildInfo(
@@ -900,6 +999,7 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
     result: CompilationResult,
     emitArtifactsResult: EmitArtifactsResult,
     isolated: boolean,
+    scope: BuildScope,
   ): Promise<void> {
     const rootFilePaths = result.compilationJob.dependencyGraph
       .getRoots()
@@ -923,9 +1023,10 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
 
       const typeFilePath = emitArtifactsResult.typeFilePaths.get(rootFilePath);
 
+      // Type declaration file is not generated for solidity tests
       assertHardhatInvariant(
-        typeFilePath !== undefined,
-        `No type file found on map for ${rootFilePath}`,
+        scope === "tests" || typeFilePath !== undefined,
+        `No type file found on map for contract ${rootFilePath}`,
       );
 
       const jobHash = await individualJob.getBuildId();
@@ -985,7 +1086,7 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
     >();
 
     if (runnableCompilationJobs.length === 0) {
-      console.log("\nNothing to compile");
+      console.log("Nothing to compile");
     }
 
     for (const job of runnableCompilationJobs) {
@@ -1035,3 +1136,7 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
     }
   }
 }
+
+function toForwardSlash(str: string): string {
+  return str.split(/[\\\/]/).join(path.posix.sep);
+}

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

@@ -20,7 +20,7 @@ export interface CompileCacheEntry {
   buildInfoPath: string;
   buildInfoOutputPath: string;
   artifactPaths: string[];
-  typeFilePath: string;
+  typeFilePath?: string;
   wasm: boolean;
 }
 

package/src/internal/builtin-plugins/solidity/hook-handlers/hre.ts

@@ -13,6 +13,7 @@ import type {
   RunCompilationJobOptions,
   RunCompilationJobResult,
   SolidityBuildSystem,
+  BuildScope,
 } from "../../../../types/solidity/build-system.js";
 import type { CompilationJob } from "../../../../types/solidity/compilation-job.js";
 import type {
@@ -33,9 +34,16 @@ class LazySolidityBuildSystem implements SolidityBuildSystem {
     this.#options = options;
   }
 
-  public async getRootFilePaths(): Promise<string[]> {
+  public async getRootFilePaths(
+    options: { scope?: BuildScope } = {},
+  ): Promise<string[]> {
     const buildSystem = await this.#getBuildSystem();
-    return buildSystem.getRootFilePaths();
+    return buildSystem.getRootFilePaths(options);
+  }
+
+  public async getScope(fsPath: string): Promise<BuildScope> {
+    const buildSystem = await this.#getBuildSystem();
+    return buildSystem.getScope(fsPath);
   }
 
   public async build(
@@ -78,14 +86,18 @@ class LazySolidityBuildSystem implements SolidityBuildSystem {
   public async emitArtifacts(
     compilationJob: CompilationJob,
     compilerOutput: CompilerOutput,
+    options: { scope?: BuildScope } = {},
   ): Promise<EmitArtifactsResult> {
     const buildSystem = await this.#getBuildSystem();
-    return buildSystem.emitArtifacts(compilationJob, compilerOutput);
+    return buildSystem.emitArtifacts(compilationJob, compilerOutput, options);
   }
 
-  public async cleanupArtifacts(rootFilePaths: string[]): Promise<void> {
+  public async cleanupArtifacts(
+    rootFilePaths: string[],
+    options: { scope?: BuildScope } = {},
+  ): Promise<void> {
     const buildSystem = await this.#getBuildSystem();
-    return buildSystem.cleanupArtifacts(rootFilePaths);
+    return buildSystem.cleanupArtifacts(rootFilePaths, options);
   }
 
   public async compileBuildInfo(
@@ -96,6 +108,11 @@ class LazySolidityBuildSystem implements SolidityBuildSystem {
     return buildSystem.compileBuildInfo(buildInfo, options);
   }
 
+  public async getArtifactsDirectory(scope: BuildScope): Promise<string> {
+    const buildSystem = await this.#getBuildSystem();
+    return buildSystem.getArtifactsDirectory(scope);
+  }
+
   async #getBuildSystem(): Promise<SolidityBuildSystem> {
     const { SolidityBuildSystemImplementation } = await import(
       "../build-system/build-system.js"