hardhat 3.3.0 → 3.4.1

package/src/internal/builtin-plugins/network-manager/request-handlers/handlers/gas/fixed-gas-price-handler.ts

@@ -14,16 +14,22 @@ import { getRequestParams } from "../../../json-rpc.js";
  * For `eth_sendTransaction` requests, it sets the gasPrice field with the value provided via the class constructor, if it hasn't been specified already.
  */
 export class FixedGasPriceHandler implements RequestHandler {
+  readonly #methods: ReadonlySet<string> = new Set(["eth_sendTransaction"]);
+
   readonly #gasPrice: PrefixedHexString;
 
   constructor(gasPrice: PrefixedHexString) {
     this.#gasPrice = gasPrice;
   }
 
+  public isSupportedMethod(jsonRpcRequest: JsonRpcRequest): boolean {
+    return this.#methods.has(jsonRpcRequest.method);
+  }
+
   public async handle(
     jsonRpcRequest: JsonRpcRequest,
   ): Promise<JsonRpcRequest | JsonRpcResponse> {
-    if (jsonRpcRequest.method !== "eth_sendTransaction") {
+    if (!this.isSupportedMethod(jsonRpcRequest)) {
       return jsonRpcRequest;
     }
 

package/src/internal/builtin-plugins/network-manager/request-handlers/types.ts

@@ -14,6 +14,16 @@ import type {
  *
  */
 export interface RequestHandler {
+  /**
+   * A guard to ensure the request is supported by the handler.
+   * If the handler does not support the request, then it can be safely
+   * skipped.
+   *
+   * @param jsonRpcRequest - The JSON-RPC request to check.
+   * @returns true if the method will be processed by the handler, false otherwise.
+   */
+  isSupportedMethod(jsonRpcRequest: JsonRpcRequest): boolean;
+
   handle(
     jsonRpcRequest: JsonRpcRequest,
   ): Promise<JsonRpcRequest | JsonRpcResponse>;

package/src/internal/builtin-plugins/network-manager/revert-error-code.ts

@@ -0,0 +1,2 @@
+// Error code used by geth/anvil for execution revert errors (e.g. Solidity reverts).
+export const REVERT_ERROR_CODE: number = 3;

package/src/internal/builtin-plugins/network-manager/type-extensions/config.ts

@@ -147,7 +147,7 @@ declare module "../../../../types/config.js" {
   export interface EdrNetworkForkingUserConfig {
     enabled?: boolean;
     url: SensitiveString;
-    blockNumber?: number;
+    blockNumber?: number | bigint;
     httpHeaders?: Record<string, string>;
   }
 

package/src/internal/builtin-plugins/network-manager/type-validation.ts

@@ -45,6 +45,10 @@ const nonnegativeIntSchema = z.number().int().nonnegative();
 const nonnegativeBigIntSchema = z.bigint().nonnegative();
 
 const blockNumberSchema = nonnegativeIntSchema;
+const forkingBlockNumberSchema = unionType(
+  [z.number().int().nonnegative().safe(), z.bigint().nonnegative()],
+  "Expected a nonnegative safe int or a nonnegative bigint",
+);
 const chainIdSchema = nonnegativeIntSchema;
 
 const chainTypeUserConfigSchema = unionType(
@@ -267,7 +271,7 @@ const edrNetworkAccountsUserConfigSchema = conditionalUnionType(
 const edrNetworkForkingUserConfigSchema = z.object({
   enabled: z.optional(z.boolean()),
   url: sensitiveUrlSchema,
-  blockNumber: z.optional(blockNumberSchema),
+  blockNumber: z.optional(forkingBlockNumberSchema),
   httpHeaders: z.optional(z.record(z.string())),
 });
 

package/src/internal/builtin-plugins/node/helpers.ts

@@ -16,7 +16,7 @@ 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/sentry/reporter.js";
+import { sendErrorTelemetry } from "../../cli/telemetry/error-reporter/reporter.js";
 import { isDefaultEdrNetworkHDAccountsConfig } from "../network-manager/edr/edr-provider.js";
 import { normalizeEdrNetworkAccountsConfig } from "../network-manager/edr/utils/convert-to-edr.js";
 

package/src/internal/builtin-plugins/node/index.ts

@@ -46,7 +46,7 @@ const hardhatPlugin: HardhatPlugin = {
         type: ArgumentType.INT,
         defaultValue: -1,
       })
-      .setAction(async () => import("./task-action.js"))
+      .setAction(async () => await import("./task-action.js"))
       .build(),
   ],
   dependencies: () => [import("../network-manager/index.js")],

package/src/internal/builtin-plugins/node/json-rpc/handler.ts

@@ -21,6 +21,7 @@ import {
   InvalidRequestError,
   ProviderError,
 } from "../../network-manager/provider-errors.js";
+import { REVERT_ERROR_CODE } from "../../network-manager/revert-error-code.js";
 
 export class JsonRpcHandler {
   readonly #provider: EthereumProvider;
@@ -256,8 +257,15 @@ const _handleError = (error: Error): JsonRpcResponse => {
   const txHash = extractTxHash(error);
   const returnData = extractReturnData(error);
 
-  // In case of non-hardhat error, treat it as internal and associate the appropriate error code.
-  if (!ProviderError.isProviderError(error)) {
+  // Check if this is a revert error (code 3) matching the geth/anvil convention.
+  const isRevertError =
+    "code" in error &&
+    typeof error.code === "number" &&
+    error.code === REVERT_ERROR_CODE;
+
+  // In case of non-hardhat error that is not a revert, treat it as internal
+  // and associate the appropriate error code.
+  if (!ProviderError.isProviderError(error) && !isRevertError) {
     error = new InternalError(undefined, error);
   }
 

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

@@ -106,10 +106,10 @@ const nodeAction: NewTaskActionFunction<NodeActionArguments> = async (
     );
   }
 
-  // NOTE: This is where we initialize the network; the connect method returns
+  // NOTE: This is where we initialize the network; the create method returns
   // a fully resolved networkConfig object which might be useful for display
   const { networkConfig, provider } =
-    await hre.network.connect(connectionParams);
+    await hre.network.create(connectionParams);
 
   assertHardhatInvariant(
     provider instanceof EdrProvider,

package/src/internal/builtin-plugins/run/index.ts

@@ -14,7 +14,7 @@ const hardhatPlugin: HardhatPlugin = {
         name: "noCompile",
         description: "Do not compile the project before running the script",
       })
-      .setAction(async () => import("./task-action.js"))
+      .setAction(async () => await import("./task-action.js"))
       .build(),
   ],
   dependencies: () => [import("../solidity/index.js")],

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

@@ -25,7 +25,8 @@ const runScriptWithHardhat: NewTaskActionFunction<RunActionArguments> = async (
   }
 
   if (!noCompile) {
-    await hre.tasks.getTask("build").run({ quiet: true, noTests: true });
+    const noTests = hre.config.solidity.splitTestsCompilation;
+    await hre.tasks.getTask("build").run({ quiet: true, noTests });
     console.log();
   }
 

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

@@ -117,6 +117,9 @@ export async function getBuildInfo(
     solcVersion: compilationJob.solcConfig.version,
     solcLongVersion: compilationJob.solcLongVersion,
     compilerType,
+    ...(compilationJob.toolVersions !== undefined
+      ? { toolVersions: compilationJob.toolVersions }
+      : {}),
     userSourceNameMap:
       compilationJob.dependencyGraph.getRootsUserSourceNameMap(),
     input: await compilationJob.getSolcInput(),

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,15 +198,41 @@ 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 await 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) =>
               f.endsWith(".sol"),
             ),
             ...this.#options.soliditySourcesPaths.map(async (dir) => {
-              return getAllFilesMatching(dir, (f) => f.endsWith(".t.sol"));
+              return await getAllFilesMatching(dir, (f) =>
+                f.endsWith(".t.sol"),
+              );
             }),
           ])
         ).flat(1);
@@ -208,6 +241,7 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
         // the tests.solidity paths and the sources paths
         rootFilePaths = Array.from(new Set(rootFilePaths));
         return rootFilePaths;
+      }
     }
   }
 
@@ -219,38 +253,42 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
 
   public async build(
     rootFilePaths: string[],
-    _options?: BuildOptions,
+    options?: BuildOptions,
   ): Promise<CompilationJobCreationError | Map<string, FileBuildResult>> {
-    return this.#hooks.runHandlerChain(
+    this.#ensureSplitCompilationModeIfTestsScope(options?.scope);
+
+    return await this.#hooks.runHandlerChain(
       "solidity",
       "build",
-      [rootFilePaths, _options],
+      [rootFilePaths, options],
       async (_context, nextRootFilePaths, nextOptions) =>
-        this.#build(nextRootFilePaths, nextOptions),
+        await this.#build(nextRootFilePaths, nextOptions),
     );
   }
 
   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 +296,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();
@@ -274,8 +312,9 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
       // NOTE: We precompute the build ids in parallel here, which are cached
       // internally in each compilation job
       await Promise.all(
-        runnableCompilationJobs.map(async (runnableCompilationJob) =>
-          runnableCompilationJob.getBuildId(),
+        runnableCompilationJobs.map(
+          async (runnableCompilationJob) =>
+            await runnableCompilationJob.getBuildId(),
         ),
       );
 
@@ -284,7 +323,7 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
         async (runnableCompilationJob) => {
           const { output, compiler } = await this.runCompilationJob(
             runnableCompilationJob,
-            options,
+            resolvedOptions,
           );
 
           return {
@@ -294,7 +333,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 +358,7 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
             const emitArtifactsResult = await this.emitArtifacts(
               compilationResult.compilationJob,
               compilationResult.compilerOutput,
-              options,
+              resolvedOptions,
             );
 
             const { artifactsPerFile } = emitArtifactsResult;
@@ -335,7 +374,7 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
               compilationResult,
               emitArtifactsResult,
               buildProfile.isolated,
-              options.scope,
+              resolvedOptions.scope,
             );
           }),
         );
@@ -403,10 +442,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 +460,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 +477,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,
@@ -498,7 +544,7 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
           "getCompiler",
           [compilerConfig],
           async (_context, cfg) =>
-            getSolcCompilerForConfig(cfg, buildProfile.preferWasm),
+            await getSolcCompilerForConfig(cfg, buildProfile.preferWasm),
         );
         longVersion = compiler.longVersion;
         longVersionMap.set(compilerConfig.version, longVersion);
@@ -533,6 +579,7 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
           longVersion,
           this.#hooks,
           sharedContentHashes,
+          toolVersions,
         );
 
         await individualJob.getBuildId(); // precompute
@@ -584,6 +631,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 +754,7 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
         longVersion,
         this.#hooks,
         sharedContentHashes,
+        toolVersions,
       );
 
       for (const [userSourceName, root] of subgraph.getRoots().entries()) {
@@ -742,7 +810,7 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
       "getCompiler",
       [runnableCompilationJob.solcConfig],
       async (_context, cfg) =>
-        getSolcCompilerForConfig(cfg, buildProfile.preferWasm),
+        await getSolcCompilerForConfig(cfg, buildProfile.preferWasm),
     );
 
     log(
@@ -761,7 +829,7 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
       "invokeSolc",
       [compiler, input, runnableCompilationJob.solcConfig],
       async (_context, nextCompiler, nextSolcInput) => {
-        return nextCompiler.compile(nextSolcInput);
+        return await nextCompiler.compile(nextSolcInput);
       },
     );
 
@@ -808,6 +876,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 +930,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 +1033,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 +1048,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 +1104,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) {
@@ -1083,7 +1170,7 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
       preferWasm: false,
     });
 
-    return compiler.compile(buildInfo.input);
+    return await compiler.compile(buildInfo.input);
   }
 
   async #downloadConfiguredCompilers(quiet = false): Promise<void> {
@@ -1118,8 +1205,12 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
     );
   }
 
+  #isFatalError(error: CompilerOutputError): boolean {
+    return error.type !== "Warning" && error.severity === "error";
+  }
+
   #hasCompilationErrors(output: CompilerOutput): boolean {
-    return output.errors?.some((x: any) => x.severity === "error") ?? false;
+    return output.errors?.some((e) => this.#isFatalError(e)) ?? false;
   }
 
   /**
@@ -1141,6 +1232,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 +1288,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 +1304,8 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
         buildInfoOutputPath: emitArtifactsResult.buildInfoOutputPath,
         typeFilePath,
         wasm: result.compiler.isSolcJs,
+        artifactsDirectory: expectedLayout.artifactsDirectory,
+        emitsTypeDeclarations: expectedLayout.emitsTypeDeclarations,
       };
     }
   }
@@ -1203,7 +1323,7 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
     console.log();
 
     for (const error of filteredErrors) {
-      if (error.severity === "error") {
+      if (this.#isFatalError(error)) {
         const errorMessage: string =
           this.#getFormattedInternalCompilerErrorMessage(error) ??
           error.formattedMessage ??
@@ -1332,6 +1452,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`;