hardhat 3.3.0 → 3.4.0

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

@@ -22,6 +22,7 @@ import type {
   CacheHitInfo,
 } from "../../../../types/solidity/build-system.js";
 import type {
+  ToolVersions,
   CompilationJob,
   Compiler,
   CompilerOutput,
@@ -57,6 +58,7 @@ import debug from "debug";
 import pMap from "p-map";
 
 import { FileBuildResultType } from "../../../../types/solidity/build-system.js";
+import { getHardhatVersion } from "../../../utils/package.js";
 import { DEFAULT_BUILD_PROFILE } from "../build-profiles.js";
 import { getSolcCompilerForConfig } from "../solidity-hooks.js";
 
@@ -153,15 +155,17 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
 
   public async getScope(fsPath: string): Promise<BuildScope> {
     if (
-      fsPath.startsWith(this.#options.solidityTestsPath) &&
+      fsPath.startsWith(this.#options.solidityTestsPath + path.sep) &&
       fsPath.endsWith(".sol")
     ) {
       return "tests";
     }
 
-    for (const sourcesPath of this.#options.soliditySourcesPaths) {
-      if (fsPath.startsWith(sourcesPath) && fsPath.endsWith(".t.sol")) {
-        return "tests";
+    if (fsPath.endsWith(".t.sol")) {
+      for (const sourcesPath of this.#options.soliditySourcesPaths) {
+        if (fsPath.startsWith(sourcesPath + path.sep)) {
+          return "tests";
+        }
       }
     }
 
@@ -172,10 +176,13 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
     options: { scope?: BuildScope } = {},
   ): Promise<string[]> {
     const scope = options.scope ?? "contracts";
+    const unified = !this.#options.solidityConfig.splitTestsCompilation;
+
+    this.#ensureSplitCompilationModeIfTestsScope(scope);
 
     switch (scope) {
-      case "contracts":
-        const localFilesToCompile = (
+      case "contracts": {
+        const localContractFiles = (
           await Promise.all(
             this.#options.soliditySourcesPaths.map((dir) =>
               getAllFilesMatching(
@@ -191,8 +198,30 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
             npmModuleToNpmRootPath,
           );
 
-        return [...localFilesToCompile, ...npmFilesToBuild];
-      case "tests":
+        if (!unified) {
+          return [...localContractFiles, ...npmFilesToBuild];
+        }
+
+        // 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 getAllFilesMatching(dir, (f) => f.endsWith(".t.sol"));
+            }),
+          ])
+        ).flat(1);
+
+        // Remove duplicates in case there is an intersection between
+        // the tests.solidity paths and the sources paths
+        return Array.from(
+          new Set([...localContractFiles, ...npmFilesToBuild, ...testFiles]),
+        );
+      }
+      case "tests": {
         let rootFilePaths = (
           await Promise.all([
             getAllFilesMatching(this.#options.solidityTestsPath, (f) =>
@@ -208,6 +237,7 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
         // the tests.solidity paths and the sources paths
         rootFilePaths = Array.from(new Set(rootFilePaths));
         return rootFilePaths;
+      }
     }
   }
 
@@ -219,12 +249,14 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
 
   public async build(
     rootFilePaths: string[],
-    _options?: BuildOptions,
+    options?: BuildOptions,
   ): Promise<CompilationJobCreationError | Map<string, FileBuildResult>> {
+    this.#ensureSplitCompilationModeIfTestsScope(options?.scope);
+
     return this.#hooks.runHandlerChain(
       "solidity",
       "build",
-      [rootFilePaths, _options],
+      [rootFilePaths, options],
       async (_context, nextRootFilePaths, nextOptions) =>
         this.#build(nextRootFilePaths, nextOptions),
     );
@@ -232,25 +264,27 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
 
   async #build(
     rootFilePaths: string[],
-    _options?: BuildOptions,
+    options?: BuildOptions,
   ): Promise<CompilationJobCreationError | Map<string, FileBuildResult>> {
-    const options: Required<BuildOptions> = {
+    const resolvedOptions: Required<BuildOptions> = {
       buildProfile: DEFAULT_BUILD_PROFILE,
       concurrency: Math.max(os.cpus().length - 1, 1),
       force: false,
       isolated: false,
       quiet: false,
       scope: "contracts",
-      ..._options,
+      ...options,
     };
 
-    await this.#downloadConfiguredCompilers(options.quiet);
+    await this.#downloadConfiguredCompilers(resolvedOptions.quiet);
 
-    const { buildProfile } = this.#getBuildProfile(options.buildProfile);
+    const { buildProfile } = this.#getBuildProfile(
+      resolvedOptions.buildProfile,
+    );
 
     const compilationJobsResult = await this.getCompilationJobs(
       rootFilePaths,
-      options,
+      resolvedOptions,
     );
 
     if (!compilationJobsResult.success) {
@@ -258,7 +292,7 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
     }
 
     const spinner = createSpinner({
-      text: `Compiling your Solidity ${options.scope}...`,
+      text: `Compiling your Solidity ${resolvedOptions.scope}...`,
       enabled: true,
     });
     spinner.start();
@@ -284,7 +318,7 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
         async (runnableCompilationJob) => {
           const { output, compiler } = await this.runCompilationJob(
             runnableCompilationJob,
-            options,
+            resolvedOptions,
           );
 
           return {
@@ -294,7 +328,7 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
           };
         },
         {
-          concurrency: options.concurrency,
+          concurrency: resolvedOptions.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,
@@ -319,7 +353,7 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
             const emitArtifactsResult = await this.emitArtifacts(
               compilationResult.compilationJob,
               compilationResult.compilerOutput,
-              options,
+              resolvedOptions,
             );
 
             const { artifactsPerFile } = emitArtifactsResult;
@@ -335,7 +369,7 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
               compilationResult,
               emitArtifactsResult,
               buildProfile.isolated,
-              options.scope,
+              resolvedOptions.scope,
             );
           }),
         );
@@ -403,10 +437,10 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
         });
       }
 
-      if (!options.quiet) {
+      if (!resolvedOptions.quiet) {
         if (isSuccessfulBuild) {
           await this.#printCompilationResult(runnableCompilationJobs, {
-            scope: options.scope,
+            scope: resolvedOptions.scope,
           });
         }
       }
@@ -421,6 +455,8 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
     rootFilePaths: string[],
     options?: GetCompilationJobsOptions,
   ): Promise<CompilationJobCreationError | GetCompilationJobsResult> {
+    this.#ensureSplitCompilationModeIfTestsScope(options?.scope);
+
     await this.#downloadConfiguredCompilers(options?.quiet);
 
     const dependencyGraph = await buildDependencyGraph(
@@ -436,6 +472,11 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
 
     log(`Using build profile ${buildProfileName}`);
 
+    let toolVersions: ToolVersions | undefined;
+    if (buildProfile.toolVersionsInBuildInfo === true) {
+      toolVersions = { hardhat: await getHardhatVersion() };
+    }
+
     const solcConfigSelector = new SolcConfigSelector(
       buildProfileName,
       buildProfile,
@@ -533,6 +574,7 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
           longVersion,
           this.#hooks,
           sharedContentHashes,
+          toolVersions,
         );
 
         await individualJob.getBuildId(); // precompute
@@ -584,6 +626,26 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
         continue;
       }
 
+      // Validate output layout: if the cached layout doesn't match the
+      // expected layout for the current config, treat it as a miss.
+      // Pre-existing cache entries without these fields are also treated
+      // as misses.
+      const expectedLayout = await this.#getExpectedOutputLayout(
+        rootFile,
+        options?.scope ?? "contracts",
+      );
+
+      if (
+        cacheResult.artifactsDirectory === undefined ||
+        cacheResult.emitsTypeDeclarations === undefined ||
+        cacheResult.artifactsDirectory !== expectedLayout.artifactsDirectory ||
+        cacheResult.emitsTypeDeclarations !==
+          expectedLayout.emitsTypeDeclarations
+      ) {
+        rootFilesToCompile.add(rootFile);
+        continue;
+      }
+
       // If any of the emitted files are not present anymore, compile it
       const {
         artifactPaths,
@@ -687,6 +749,7 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
         longVersion,
         this.#hooks,
         sharedContentHashes,
+        toolVersions,
       );
 
       for (const [userSourceName, root] of subgraph.getRoots().entries()) {
@@ -808,6 +871,10 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
   ): Promise<EmitArtifactsResult> {
     const scope = options.scope ?? "contracts";
 
+    this.#ensureSplitCompilationModeIfTestsScope(scope);
+
+    const unified = !this.#options.solidityConfig.splitTestsCompilation;
+
     const artifactsPerFile = new Map<string, string[]>();
     const typeFilePaths = new Map<string, string>();
     const buildId = await runnableCompilationJob.getBuildId();
@@ -858,8 +925,15 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
 
       artifactsPerFile.set(formatRootPath(userSourceName, root), paths);
 
-      // Write the type declaration file, only for contracts
-      if (scope === "contracts") {
+      // In split mode, test roots are never part of a "contracts"-scoped pass,
+      // so the scope guard below is sufficient. In unified mode, both contract
+      // and test roots share the same pass, so we check individually.
+      const isTestRoot = unified
+        ? (await this.getScope(root.fsPath)) === "tests"
+        : false;
+
+      // Write the type declaration file for contract roots only.
+      if (scope === "contracts" && !isTestRoot) {
         const artifactsDeclarationFilePath = path.join(
           fileFolder,
           "artifacts.d.ts",
@@ -954,6 +1028,12 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
   }
 
   public async getArtifactsDirectory(scope: BuildScope): Promise<string> {
+    // In unified mode, both scopes point to the main artifacts directory
+    // because contract and test artifacts live together.
+    if (!this.#options.solidityConfig.splitTestsCompilation) {
+      return this.#options.artifactsPath;
+    }
+
     return scope === "contracts"
       ? this.#options.artifactsPath
       : path.join(this.#options.cachePath, "test-artifacts");
@@ -963,9 +1043,11 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
     rootFilePaths: string[],
     options: { scope?: BuildScope } = {},
   ): Promise<void> {
-    log(`Cleaning up artifacts`);
-
     const scope = options.scope ?? "contracts";
+
+    this.#ensureSplitCompilationModeIfTestsScope(scope);
+
+    log(`Cleaning up artifacts`);
     const artifactsDirectory = await this.getArtifactsDirectory(scope);
 
     const userSourceNames = rootFilePaths.map((rootFilePath) => {
@@ -1017,7 +1099,7 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
 
     // Get all the reachable build info files
     const buildInfoFiles = await getAllFilesMatching(buildInfosDir, (f) =>
-      f.startsWith(buildInfosDir),
+      f.startsWith(buildInfosDir + path.sep),
     );
 
     for (const buildInfoFile of buildInfoFiles) {
@@ -1141,6 +1223,34 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
     return `${error.type}: ${error.message}`.replace(/[:\s]*$/g, "").trim();
   }
 
+  async #getExpectedOutputLayout(
+    rootFilePath: string,
+    scope: BuildScope,
+  ): Promise<{ artifactsDirectory: string; emitsTypeDeclarations: boolean }> {
+    const artifactsDirectory = await this.getArtifactsDirectory(scope);
+
+    const unified = !this.#options.solidityConfig.splitTestsCompilation;
+
+    // In unified mode, test roots under contracts scope don't emit type
+    // declarations. In split mode, the scope alone determines this.
+    let emitsTypeDeclarations: boolean;
+    if (scope === "contracts") {
+      if (unified) {
+        const parsed = parseRootPath(rootFilePath);
+        const isTestRoot = isNpmParsedRootPath(parsed)
+          ? false
+          : (await this.getScope(parsed.fsPath)) === "tests";
+        emitsTypeDeclarations = !isTestRoot;
+      } else {
+        emitsTypeDeclarations = true;
+      }
+    } else {
+      emitsTypeDeclarations = false;
+    }
+
+    return { artifactsDirectory, emitsTypeDeclarations };
+  }
+
   async #cacheCompilationResult(
     indexedIndividualJobs: Map<string, CompilationJob>,
     result: CompilationResult,
@@ -1169,14 +1279,13 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
 
       const typeFilePath = emitArtifactsResult.typeFilePaths.get(rootFilePath);
 
-      // Type declaration file is not generated for solidity tests
-      assertHardhatInvariant(
-        scope === "tests" || typeFilePath !== undefined,
-        `No type file found on map for contract ${rootFilePath}`,
-      );
-
       const jobHash = await individualJob.getBuildId();
 
+      const expectedLayout = await this.#getExpectedOutputLayout(
+        rootFilePath,
+        scope,
+      );
+
       this.#compileCache[rootFilePath] = {
         jobHash,
         isolated,
@@ -1186,6 +1295,8 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
         buildInfoOutputPath: emitArtifactsResult.buildInfoOutputPath,
         typeFilePath,
         wasm: result.compiler.isSolcJs,
+        artifactsDirectory: expectedLayout.artifactsDirectory,
+        emitsTypeDeclarations: expectedLayout.emitsTypeDeclarations,
       };
     }
   }
@@ -1332,6 +1443,17 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
       }
     }
   }
+
+  #ensureSplitCompilationModeIfTestsScope(scope: BuildScope = "contracts") {
+    if (
+      scope === "tests" &&
+      !this.#options.solidityConfig.splitTestsCompilation
+    ) {
+      throw new HardhatError(
+        HardhatError.ERRORS.CORE.SOLIDITY.SPLIT_TESTS_COMPILATION_DISABLED,
+      );
+    }
+  }
 }
 
 function toForwardSlash(str: string): string {

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

@@ -23,6 +23,8 @@ export interface CompileCacheEntry {
   artifactPaths: string[];
   typeFilePath?: string;
   wasm: boolean;
+  artifactsDirectory?: string;
+  emitsTypeDeclarations?: boolean;
 }
 
 const CACHE_FILE_NAME = `compile-cache.json`;

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

@@ -5,6 +5,7 @@ import type { HookManager } from "../../../../types/hooks.js";
 import type { CompilationJob } from "../../../../types/solidity/compilation-job.js";
 import type { CompilerInput } from "../../../../types/solidity/compiler-io.js";
 import type { DependencyGraph } from "../../../../types/solidity/dependency-graph.js";
+import type { ToolVersions } from "../../../../types/solidity/solidity-artifacts.js";
 
 import { createHash } from "node:crypto";
 
@@ -16,6 +17,7 @@ import {
   ResolvedFileType,
   type ResolvedFile,
 } from "../../../../types/solidity.js";
+import { DEFAULT_OUTPUT_SELECTION } from "../constants.js";
 
 import { getEvmVersionFromSolcVersion } from "./solc-info.js";
 
@@ -23,6 +25,7 @@ export class CompilationJobImplementation implements CompilationJob {
   public readonly dependencyGraph: DependencyGraph;
   public readonly solcConfig: SolidityCompilerConfig;
   public readonly solcLongVersion: string;
+  public readonly toolVersions?: ToolVersions;
 
   readonly #hooks: HookManager;
   // This map is shared across compilation jobs and is meant to store content hashes of source files
@@ -38,12 +41,14 @@ export class CompilationJobImplementation implements CompilationJob {
     solcLongVersion: string,
     hooks: HookManager,
     sharedContentHashes: Map<string, string> = new Map(),
+    toolVersions?: ToolVersions,
   ) {
     this.dependencyGraph = dependencyGraph;
     this.solcConfig = solcConfig;
     this.solcLongVersion = solcLongVersion;
     this.#hooks = hooks;
     this.#sharedContentHashes = sharedContentHashes;
+    this.toolVersions = toolVersions;
   }
 
   public async getSolcInput(): Promise<CompilerInput> {
@@ -130,19 +135,14 @@ export class CompilationJobImplementation implements CompilationJob {
     // from other files (e.g. new Foo()), and it won't output its bytecode if
     // it's not asked for. This would prevent EDR from doing any runtime
     // analysis.
-    const outputSelection = await deepClone(settings.outputSelection ?? {});
+    const outputSelection: CompilerInput["settings"]["outputSelection"] =
+      await deepClone(settings.outputSelection ?? {});
     outputSelection["*"] ??= {};
     outputSelection["*"][""] ??= [];
     outputSelection["*"]["*"] ??= [];
 
-    outputSelection["*"][""].push("ast");
-    outputSelection["*"]["*"].push(
-      "abi",
-      "evm.bytecode",
-      "evm.deployedBytecode",
-      "evm.methodIdentifiers",
-      "metadata",
-    );
+    outputSelection["*"][""].push(...DEFAULT_OUTPUT_SELECTION["*"][""]);
+    outputSelection["*"]["*"].push(...DEFAULT_OUTPUT_SELECTION["*"]["*"]);
 
     const sources: { [sourceName: string]: { content: string } } = {};
 
@@ -257,6 +257,12 @@ export class CompilationJobImplementation implements CompilationJob {
       preimageObject.compilerType = compilerType;
     }
 
+    // Include tool versions in the preimage when present, so that
+    // different tool versions produce different build IDs.
+    if (this.toolVersions !== undefined) {
+      preimageObject.toolVersions = this.toolVersions;
+    }
+
     const preimage = JSON.stringify(preimageObject);
 
     const jobHash = await createNonCryptographicHashId(preimage);

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

@@ -205,13 +205,15 @@ export class DependencyGraphImplementation implements DependencyGraph {
   }
 
   public getAllRemappings(): readonly string[] {
-    return this.#dependenciesMap
-      .values()
-      .flatMap((dependencies) =>
-        dependencies.values().flatMap((remappings) => remappings.values()),
-      )
-      .toArray()
-      .sort();
+    return [
+      ...new Set(
+        this.#dependenciesMap
+          .values()
+          .flatMap((dependencies) =>
+            dependencies.values().flatMap((remappings) => remappings.values()),
+          ),
+      ),
+    ].sort();
   }
 
   public toJSON(): DependencyGraphImplementationJson {

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

@@ -107,6 +107,7 @@ const defaultEvmTargets: { [key: string]: string } = {
   "0.8.31": "osaka",
   "0.8.32": "osaka",
   "0.8.33": "osaka",
+  "0.8.34": "osaka",
 };
 
 export function getEvmVersionFromSolcVersion(

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

@@ -57,8 +57,8 @@ export function shouldSuppressWarning(
 ): boolean {
   // Compute relative path from project root to test directory.
   // Example:
-  // absoluteSolidityTestsPath: /workspaces/hardhat-4/v-next/example-project/test/contracts
-  // absoluteProjectRoot:       /workspaces/hardhat-4/v-next/example-project
+  // absoluteSolidityTestsPath: /workspaces/hardhat-4/packages/example-project/test/contracts
+  // absoluteProjectRoot:       /workspaces/hardhat-4/packages/example-project
   // relativeTestPath:          test/contracts/ - note the addition of the `/`
   // to avoid partial matches, e.g.: test/contractsUtils/
   const relativeTestPath = path.join(

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

@@ -32,6 +32,7 @@ import {
   hasOfficialArm64Build,
   missesSomeOfficialNativeBuilds,
 } from "./build-system/solc-info.js";
+import { DEFAULT_OUTPUT_SELECTION } from "./constants.js";
 
 /**
  * The top-level type SolidityUserConfig is a union type too complex for
@@ -80,6 +81,7 @@ const incompatibleCompilerFields = {
 const commonSolidityUserConfigFields = {
   isolated: z.boolean().optional(),
   npmFilesToBuild: z.array(z.string()).optional(),
+  splitTestsCompilation: z.boolean().optional(),
 };
 
 const commonSolidityCompilerUserConfigFields = {
@@ -119,12 +121,14 @@ const solidityCompilerUserConfigType = conditionalUnionType(
 const solcSingleVersionSolidityUserConfigType =
   solcSolidityCompilerUserConfigType.extend({
     ...commonSolidityUserConfigFields,
+    toolVersionsInBuildInfo: z.boolean().optional(),
     ...incompatibleVersionFields,
   });
 
 const otherSingleVersionSolidityUserConfigType =
   otherSolidityCompilerUserConfigType.extend({
     ...commonSolidityUserConfigFields,
+    toolVersionsInBuildInfo: z.boolean().optional(),
     ...incompatibleVersionFields,
   });
 
@@ -149,6 +153,7 @@ const multiVersionSolidityUserConfigType = z.object({
   compilers: z.array(solidityCompilerUserConfigType).nonempty(),
   overrides: z.record(z.string(), solidityCompilerUserConfigType).optional(),
   ...commonSolidityUserConfigFields,
+  toolVersionsInBuildInfo: z.boolean().optional(),
   ...incompatibleCompilerFields,
 });
 
@@ -163,6 +168,7 @@ const singleVersionBuildProfileUserConfigType = conditionalUnionType(
         (!("type" in data) || data.type === undefined || data.type === "solc"),
       solcSolidityCompilerUserConfigType.extend({
         isolated: z.boolean().optional(),
+        toolVersionsInBuildInfo: z.boolean().optional(),
         ...incompatibleVersionFields,
       }),
     ],
@@ -170,6 +176,7 @@ const singleVersionBuildProfileUserConfigType = conditionalUnionType(
       (data) => isObject(data) && "type" in data && data.type !== "solc",
       otherSolidityCompilerUserConfigType.extend({
         isolated: z.boolean().optional(),
+        toolVersionsInBuildInfo: z.boolean().optional(),
         ...incompatibleVersionFields,
       }),
     ],
@@ -182,6 +189,7 @@ const multiVersionBuildProfileUserConfigType = z.object({
   compilers: z.array(solidityCompilerUserConfigType).nonempty(),
   overrides: z.record(z.string(), solidityCompilerUserConfigType).optional(),
   isolated: z.boolean().optional(),
+  toolVersionsInBuildInfo: z.boolean().optional(),
   ...incompatibleCompilerFields,
 });
 
@@ -202,6 +210,7 @@ const buildProfilesSolidityUserConfigType = z.object({
       "Expected an object configuring one or more versions of Solidity",
     ),
   ),
+  ...commonSolidityUserConfigFields,
   ...incompatibleProfileFields,
 });
 
@@ -430,6 +439,7 @@ function resolveSolidityConfig(
       },
       npmFilesToBuild: [],
       registeredCompilerTypes: ["solc"],
+      splitTestsCompilation: false,
     };
   }
 
@@ -437,14 +447,20 @@ function resolveSolidityConfig(
   if ("version" in solidityConfig || "compilers" in solidityConfig) {
     return {
       profiles: {
-        default: resolveBuildProfileConfig(solidityConfig),
+        default: resolveBuildProfileConfig(
+          solidityConfig,
+          false,
+          solidityConfig.toolVersionsInBuildInfo,
+        ),
         production: resolveBuildProfileConfig(
           copyFromDefault(solidityConfig),
           true,
+          solidityConfig.toolVersionsInBuildInfo,
         ),
       },
       npmFilesToBuild: solidityConfig.npmFilesToBuild ?? [],
       registeredCompilerTypes: ["solc"],
+      splitTestsCompilation: solidityConfig.splitTestsCompilation ?? false,
     };
   }
 
@@ -457,6 +473,7 @@ function resolveSolidityConfig(
     profiles[profileName] = resolveBuildProfileConfig(
       profile,
       profileName === "production",
+      profile.toolVersionsInBuildInfo,
     );
   }
 
@@ -475,6 +492,7 @@ function resolveSolidityConfig(
     profiles,
     npmFilesToBuild: solidityConfig.npmFilesToBuild ?? [],
     registeredCompilerTypes: ["solc"],
+    splitTestsCompilation: solidityConfig.splitTestsCompilation ?? false,
   };
 }
 
@@ -483,6 +501,7 @@ function resolveBuildProfileConfig(
     | SingleVersionSolidityUserConfig
     | MultiVersionSolidityUserConfig,
   production: boolean = false,
+  toolVersionsInBuildInfo?: boolean,
 ): SolidityBuildProfileConfig {
   if ("version" in solidityConfig) {
     return {
@@ -490,6 +509,7 @@ function resolveBuildProfileConfig(
       overrides: {},
       isolated: solidityConfig.isolated ?? production,
       preferWasm: solidityConfig.preferWasm ?? false,
+      toolVersionsInBuildInfo: toolVersionsInBuildInfo ?? production,
     };
   }
 
@@ -507,6 +527,7 @@ function resolveBuildProfileConfig(
     ),
     isolated: solidityConfig.isolated ?? production,
     preferWasm: solidityConfig.preferWasm ?? false,
+    toolVersionsInBuildInfo: toolVersionsInBuildInfo ?? production,
   };
 }
 
@@ -515,18 +536,7 @@ function resolveSolidityCompilerConfig(
   production: boolean = false,
 ): SolidityCompilerConfig {
   const defaultSettings: SolidityCompilerConfig["settings"] = {
-    outputSelection: {
-      "*": {
-        "": ["ast"],
-        "*": [
-          "abi",
-          "evm.bytecode",
-          "evm.deployedBytecode",
-          "evm.methodIdentifiers",
-          "metadata",
-        ],
-      },
-    },
+    outputSelection: DEFAULT_OUTPUT_SELECTION,
   };
 
   if (production && isSolcSolidityCompilerUserConfig(compilerConfig)) {