hardhat 3.3.0 → 3.4.0

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

@@ -0,0 +1,21 @@
+import type { CompilerInput } from "../../../types/solidity.js";
+
+export const DEFAULT_OUTPUT_SELECTION: CompilerInput["settings"]["outputSelection"] =
+  {
+    "*": {
+      "": ["ast"],
+      "*": [
+        "abi",
+        "evm.bytecode.linkReferences",
+        "evm.bytecode.object",
+        "evm.bytecode.opcodes",
+        "evm.bytecode.sourceMap",
+        "evm.deployedBytecode.immutableReferences",
+        "evm.deployedBytecode.linkReferences",
+        "evm.deployedBytecode.object",
+        "evm.deployedBytecode.opcodes",
+        "evm.deployedBytecode.sourceMap",
+        "evm.methodIdentifiers",
+      ],
+    },
+  };

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

@@ -1,8 +1,13 @@
-import type { HardhatRuntimeEnvironment } from "../../../../types/hre.js";
-import type { BuildScope } from "../../../../types/solidity.js";
+import type {
+  BuildScope,
+  SolidityBuildSystem,
+} from "../../../../types/solidity.js";
 import type { NewTaskActionFunction } from "../../../../types/tasks.js";
 
-import { HardhatError } from "@nomicfoundation/hardhat-errors";
+import {
+  assertHardhatInvariant,
+  HardhatError,
+} from "@nomicfoundation/hardhat-errors";
 import { resolveFromRoot } from "@nomicfoundation/hardhat-utils/path";
 
 import { throwIfSolidityBuildFailed } from "../build-results.js";
@@ -12,115 +17,395 @@ interface BuildActionArguments {
   force: boolean;
   files: string[];
   quiet: boolean;
-  defaultBuildProfile: string | undefined;
+  defaultBuildProfile: string;
   noTests: boolean;
   noContracts: boolean;
 }
 
+interface BuildActionResult {
+  contractRootPaths: string[];
+  testRootPaths: string[];
+}
+
 const buildAction: NewTaskActionFunction<BuildActionArguments> = async (
   args: BuildActionArguments,
   hre,
-) => {
-  let contractRootPaths: string[] = [];
-  let testRootPaths: string[] = [];
-  const allUsedFiles: string[] = [];
-
-  if (args.noContracts === false) {
-    const { rootPaths, usedFiles } = await buildForScope(
-      "contracts",
-      args,
-      hre,
+): Promise<BuildActionResult> => {
+  const buildProfile =
+    hre.globalOptions.buildProfile ?? args.defaultBuildProfile;
+
+  const files = normalizeRootPaths(args.files);
+
+  const partitionedFiles = await partitionRootPathsByScope(hre.solidity, files);
+
+  if (args.noContracts && partitionedFiles.contractRootPaths.length > 0) {
+    throw new HardhatError(
+      HardhatError.ERRORS.CORE.SOLIDITY.INCOMPATIBLE_FILES_WITH_BUILD_FLAGS,
+      {
+        files: partitionedFiles.contractRootPaths
+          .sort()
+          .map((f) => `- ${f}`)
+          .join("\n"),
+      },
     );
+  }
 
-    contractRootPaths = rootPaths;
-    allUsedFiles.push(...usedFiles);
+  if (args.noTests && partitionedFiles.testRootPaths.length > 0) {
+    throw new HardhatError(
+      HardhatError.ERRORS.CORE.SOLIDITY.INCOMPATIBLE_FILES_WITH_BUILD_FLAGS,
+      {
+        files: partitionedFiles.testRootPaths
+          .sort()
+          .map((f) => `- ${f}`)
+          .join("\n"),
+      },
+    );
   }
 
-  if (args.noTests === false) {
-    const { rootPaths, usedFiles } = await buildForScope("tests", args, hre);
+  if (hre.config.solidity.splitTestsCompilation) {
+    const contractRootPaths: string[] = [];
+    const testRootPaths: string[] = [];
 
-    testRootPaths = rootPaths;
-    allUsedFiles.push(...usedFiles);
-  }
+    const shouldBuildContracts =
+      !args.noContracts &&
+      (files.length === 0 || partitionedFiles.contractRootPaths.length > 0);
 
-  // If there's an unused file we fail
-  if (args.files.length !== 0) {
-    const files = new Set(args.files);
-    const usedFiles = new Set(allUsedFiles);
-    const unusedFiles = files.difference(usedFiles);
-
-    if (unusedFiles.size > 0) {
-      const list = [...unusedFiles]
-        .sort()
-        .map((f) => `- ${f}`)
-        .join("\n");
-
-      throw new HardhatError(
-        HardhatError.ERRORS.CORE.SOLIDITY.UNRECOGNIZED_FILES_NOT_COMPILED,
-        { files: list },
+    if (shouldBuildContracts) {
+      const contractBuildResults = await runSolidityBuild({
+        buildProfile,
+        files: partitionedFiles.contractRootPaths,
+        force: args.force,
+        isUnifiedModeOrScope: "contracts",
+        noContracts: args.noContracts,
+        noTests: args.noTests,
+        quiet: args.quiet,
+        solidity: hre.solidity,
+      });
+
+      assertHardhatInvariant(
+        contractBuildResults.testRootPaths.length === 0,
+        "The contracts scope should build no test in split test compilation mode",
       );
+
+      contractRootPaths.push(...contractBuildResults.contractRootPaths);
+      testRootPaths.push(...contractBuildResults.testRootPaths);
     }
+
+    const shouldBuildTests =
+      !args.noTests &&
+      (files.length === 0 || partitionedFiles.testRootPaths.length > 0);
+
+    if (shouldBuildTests) {
+      const testBuildResults = await runSolidityBuild({
+        buildProfile,
+        files: partitionedFiles.testRootPaths,
+        force: args.force,
+        isUnifiedModeOrScope: "tests",
+        noContracts: args.noContracts,
+        noTests: args.noTests,
+        quiet: args.quiet,
+        solidity: hre.solidity,
+      });
+
+      assertHardhatInvariant(
+        testBuildResults.contractRootPaths.length === 0,
+        "The tests scope should build no contract in split test compilation mode",
+      );
+
+      contractRootPaths.push(...testBuildResults.contractRootPaths);
+      testRootPaths.push(...testBuildResults.testRootPaths);
+    }
+
+    return { contractRootPaths, testRootPaths };
   }
 
-  return { contractRootPaths, testRootPaths };
+  return runSolidityBuild({
+    buildProfile,
+    files,
+    force: args.force,
+    isUnifiedModeOrScope: true,
+    noContracts: args.noContracts,
+    noTests: args.noTests,
+    quiet: args.quiet,
+    solidity: hre.solidity,
+  });
 };
 
-async function buildForScope(
-  scope: BuildScope,
-  { force, files, quiet, defaultBuildProfile }: BuildActionArguments,
-  { solidity, globalOptions }: HardhatRuntimeEnvironment,
-) {
-  const usedFiles = [];
+/**
+ * Runs a solidity build for a scope/unified mode.
+ *
+ * Note: The files array should be pre-classified by scope if using split
+ * compilation. i.e. it should only include files of the scope being used.
+ */
+async function runSolidityBuild({
+  buildProfile,
+  files,
+  force,
+  isUnifiedModeOrScope,
+  noContracts,
+  noTests,
+  quiet,
+  solidity,
+}: {
+  buildProfile: string;
+  files: string[];
+  force: boolean;
+  isUnifiedModeOrScope: true | BuildScope;
+  noContracts: boolean;
+  noTests: boolean;
+  quiet: boolean;
+  solidity: SolidityBuildSystem;
+}): Promise<{ contractRootPaths: string[]; testRootPaths: string[] }> {
+  const scope =
+    isUnifiedModeOrScope === true ? "contracts" : isUnifiedModeOrScope;
+
+  const { isFullBuild, contractRootPaths, testRootPaths } =
+    await getRootsToBuild({
+      solidity,
+      isUnifiedModeOrScope,
+      files,
+      noTests,
+      noContracts,
+    });
 
-  // If no specific files are passed, it means a full compilation, i.e. all source files
-  const isFullCompilation = files.length === 0;
+  // If there's nothing to build and this isn't a full build, we exit early.
+  // Full builds with no roots still need to run cleanup to remove stale
+  // artifacts.
+  if (
+    !isFullBuild &&
+    contractRootPaths.length === 0 &&
+    testRootPaths.length === 0
+  ) {
+    return { contractRootPaths, testRootPaths };
+  }
 
-  const rootPaths = [];
+  const results = await solidity.build(
+    [...contractRootPaths, ...testRootPaths],
+    {
+      force,
+      buildProfile,
+      quiet,
+      scope,
+    },
+  );
+
+  throwIfSolidityBuildFailed(solidity, results);
 
-  if (isFullCompilation) {
-    rootPaths.push(...(await solidity.getRootFilePaths({ scope })));
+  // We use the result keys in case a hook added or removed root files
+  const builtRootPaths = [...results.keys()];
+
+  if (isFullBuild) {
+    await solidity.cleanupArtifacts(builtRootPaths, {
+      scope,
+    });
+  }
+
+  const preBuildRoots = new Set([...contractRootPaths, ...testRootPaths]);
+  if (
+    builtRootPaths.length === preBuildRoots.size &&
+    builtRootPaths.every((p) => preBuildRoots.has(p))
+  ) {
+    return { contractRootPaths, testRootPaths };
+  }
+
+  return partitionRootPathsByScope(solidity, builtRootPaths);
+}
+
+/**
+ * Returns the files to build, classified by testRootPaths and
+ * contractRootPaths, and a boolean indicating if this represents a full build
+ * for the scope/unified build.
+ *
+ * Note: The files array should be pre-classified by scope if using split
+ * compilation. i.e. it should only include files of the scope being used.
+ */
+async function getRootsToBuild({
+  solidity,
+  isUnifiedModeOrScope,
+  files,
+  noTests,
+  noContracts,
+}: {
+  solidity: SolidityBuildSystem;
+  isUnifiedModeOrScope: true | BuildScope;
+  files: string[];
+  noTests: boolean;
+  noContracts: boolean;
+}): Promise<{
+  testRootPaths: string[];
+  contractRootPaths: string[];
+  isFullBuild: boolean;
+}> {
+  if (isUnifiedModeOrScope === true) {
+    return getRootsToBuildInUnifiedMode({
+      files,
+      noContracts,
+      noTests,
+      solidity,
+    });
+  }
+
+  return getRootsToBuildForScope({
+    files,
+    scope: isUnifiedModeOrScope,
+    solidity,
+  });
+}
+
+/**
+ * Returns the root files to build in unified mode. While they are returned
+ * classified as contractRootPaths and testRootPaths, they are expected to be
+ * build together. It also returns a boolean indicating if this represents a
+ * full unified build.
+ *
+ * Note: The files array should be normalized already.
+ */
+async function getRootsToBuildInUnifiedMode({
+  files,
+  noContracts,
+  noTests,
+  solidity,
+}: {
+  files: string[];
+  noContracts: boolean;
+  noTests: boolean;
+  solidity: SolidityBuildSystem;
+}): Promise<{
+  testRootPaths: string[];
+  contractRootPaths: string[];
+  isFullBuild: boolean;
+}> {
+  const isFullBuild = files.length === 0 && !noTests && !noContracts;
+
+  let rootFilePaths: string[];
+
+  if (isFullBuild) {
+    // In this mode, "contracts" also returns the tests
+    rootFilePaths = await solidity.getRootFilePaths({
+      scope: "contracts",
+    });
   } else {
-    for (const file of files) {
-      if (isNpmRootPath(file)) {
-        rootPaths.push(file);
+    const allRoots =
+      files.length > 0
+        ? files
+        : await solidity.getRootFilePaths({
+            scope: "contracts",
+          });
+
+    rootFilePaths = [];
+    for (const root of allRoots) {
+      if (isNpmRootPath(root)) {
+        // npm files are considered contract files, so we skip them if
+        // --no-contracts
+        if (!noContracts) {
+          rootFilePaths.push(root);
+        }
+
+        continue;
       }
 
-      const rootPath = resolveFromRoot(process.cwd(), file);
+      const scope = await solidity.getScope(root);
 
-      if ((await solidity.getScope(rootPath)) !== scope) {
+      if (noTests && scope === "tests") {
         continue;
       }
 
-      usedFiles.push(file);
-      rootPaths.push(rootPath);
-    }
+      if (noContracts && scope === "contracts") {
+        continue;
+      }
 
-    // If a file list has been passed but none match this scope, we don't run the build
-    if (rootPaths.length === 0) {
-      return { rootPaths, usedFiles };
+      rootFilePaths.push(root);
     }
   }
 
-  const buildProfile = globalOptions.buildProfile ?? defaultBuildProfile;
+  const partitionedRootPaths = await partitionRootPathsByScope(
+    solidity,
+    rootFilePaths,
+  );
 
-  const results = await solidity.build(rootPaths, {
-    force,
-    buildProfile,
-    quiet,
-    scope,
-  });
+  return {
+    isFullBuild,
+    ...partitionedRootPaths,
+  };
+}
 
-  throwIfSolidityBuildFailed(solidity, results);
+/**
+ * Returns the root files to build for a certain scope, and a boolean indicating
+ * if it's a full build for that scope.
+ *
+ * Note: The files array should be pre-classified by scope if using split
+ * compilation. i.e. it should only include files of the scope being used.
+ *
+ * Note: One of the returned arrays is always empty, depending on the scope
+ * being used.
+ */
+async function getRootsToBuildForScope({
+  files,
+  scope,
+  solidity,
+}: {
+  files: string[];
+  scope: BuildScope;
+  solidity: SolidityBuildSystem;
+}): Promise<{
+  isFullBuild: boolean;
+  contractRootPaths: string[];
+  testRootPaths: string[];
+}> {
+  const isFullBuild = files.length === 0;
+
+  const rootPaths = isFullBuild
+    ? await solidity.getRootFilePaths({ scope })
+    : files; // This is safe because the files have already been partitioned by scope
+
+  if (scope === "contracts") {
+    return { isFullBuild, contractRootPaths: rootPaths, testRootPaths: [] };
+  }
+
+  return { isFullBuild, contractRootPaths: [], testRootPaths: rootPaths };
+}
+
+/**
+ * Partitions root paths by scope, as returned by `solidity.getScope(rootPath)`.
+ */
+async function partitionRootPathsByScope(
+  solidity: SolidityBuildSystem,
+  rootPaths: string[],
+): Promise<{ contractRootPaths: string[]; testRootPaths: string[] }> {
+  const contractRootPaths: string[] = [];
+  const testRootPaths: string[] = [];
 
-  // If we recompiled the entire project we cleanup the artifacts
-  if (isFullCompilation) {
-    // 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 });
+  for (const rootPath of rootPaths) {
+    if (isNpmRootPath(rootPath)) {
+      contractRootPaths.push(rootPath);
+      continue;
+    }
+
+    const scope = await solidity.getScope(rootPath);
+    if (scope === "tests") {
+      testRootPaths.push(rootPath);
+    } else {
+      contractRootPaths.push(rootPath);
+    }
   }
 
-  return { rootPaths, usedFiles };
+  return { contractRootPaths, testRootPaths };
+}
+
+/**
+ * Normalizes the received root paths.
+ *
+ * If a file is an npm root path or absolute file path, it's returned as is.
+ * If it's a relative path it's resolved from the CWD.
+ */
+function normalizeRootPaths(files: string[]): string[] {
+  return files.map((f) => {
+    if (isNpmRootPath(f)) {
+      return f;
+    }
+
+    return resolveFromRoot(process.cwd(), f);
+  });
 }
 
 export default buildAction;

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

@@ -44,12 +44,34 @@ declare module "../../../types/config.js" {
    * Fields that all the object-typed variants of SolidityUserConfig share.
    *
    * Note: All the variants of SolidityUserConfig except for the string and
-   * array of strings MUST extend this interface. This is especially relevant
-   * for plugins creating their own `SingleVersionSolidityUserConfig` variant.
+   * array of strings MUST extend this interface. For plugins creating their
+   * own `SingleVersionSolidityUserConfig` variant, see
+   * {@link CommonSingleVersionSolidityUserConfig}.
    */
   export interface CommonSolidityUserConfig {
     isolated?: boolean;
     npmFilesToBuild?: string[];
+    /**
+     * Controls whether Solidity test files are compiled in a separate pass
+     * from contract files.
+     *
+     * When `false` (the default), contracts and tests are compiled together
+     * in a single pass.
+     *
+     * When `true`, contracts and tests are compiled separately.
+     */
+    splitTestsCompilation?: boolean;
+  }
+
+  /**
+   * Common fields for every SingleVersionSolidityUserConfig variant.
+   *
+   * NOTE: All the variants of SingleVersionSolidityUserConfig must extend this
+   * interface.
+   */
+  export interface CommonSingleVersionSolidityUserConfig
+    extends CommonSolidityUserConfig {
+    toolVersionsInBuildInfo?: boolean;
   }
 
   /**
@@ -110,7 +132,7 @@ declare module "../../../types/config.js" {
    */
   export interface SingleVersionSolcUserConfig
     extends SolcSolidityCompilerUserConfig,
-      CommonSolidityUserConfig {}
+      CommonSingleVersionSolidityUserConfig {}
 
   /**
    * Solc-specific SingleVersionSolidityUserConfig.
@@ -123,7 +145,7 @@ declare module "../../../types/config.js" {
   /**
    * A map from compiler type to its SingleVersionSolidityUserConfig type.
    *
-   * Note: The types MUST extend `CommonSolidityUserConfig`.
+   * Note: The types MUST extend `CommonSingleVersionSolidityUserConfig`.
    */
   export interface SingleVersionSolidityUserConfigPerType {
     solc: SolcSingleVersionSolidityUserConfig;
@@ -165,7 +187,9 @@ declare module "../../../types/config.js" {
    */
   export interface MultiVersionSolidityUserConfig
     extends MultiVersionSolcUserConfig,
-      CommonSolidityUserConfig {}
+      CommonSolidityUserConfig {
+    toolVersionsInBuildInfo?: boolean;
+  }
 
   /**
    * The type of a single-version build profile user config.
@@ -173,15 +197,17 @@ declare module "../../../types/config.js" {
   export type SingleVersionBuildProfileUserConfig =
     SolidityCompilerUserConfig & {
       isolated?: boolean;
+      toolVersionsInBuildInfo?: boolean;
     };
 
   /**
    * The type of a multi-version build profile user config.
+   * Mostly defined in `MultiVersionSolcUserConfig` for backwards compatibility
    */
-  /* eslint-disable-next-line @typescript-eslint/no-empty-interface -- Defined
-    in `MultiVersionSolcUserConfig` for backwards compatibility. */
   export interface MultiVersionBuildProfileUserConfig
-    extends MultiVersionSolcUserConfig {}
+    extends MultiVersionSolcUserConfig {
+    toolVersionsInBuildInfo?: boolean;
+  }
 
   /**
    * The type of the build profile version of the SolidityUserConfig.
@@ -259,6 +285,9 @@ declare module "../../../types/config.js" {
   export interface SolidityBuildProfileConfig {
     isolated: boolean;
     preferWasm: boolean;
+    // Note: This is optional for backwards compatibility.
+    // If `undefined` is present, it's equivalent to `false`.
+    toolVersionsInBuildInfo?: boolean;
     compilers: SolidityCompilerConfig[];
     overrides: Record<string, SolidityCompilerConfig>;
   }
@@ -270,6 +299,7 @@ declare module "../../../types/config.js" {
     profiles: Record<string, SolidityBuildProfileConfig>;
     npmFilesToBuild: string[];
     registeredCompilerTypes: SolidityCompilerType[];
+    splitTestsCompilation: boolean;
   }
 
   /**

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

@@ -19,6 +19,7 @@ import {
   conditionalUnionType,
   sensitiveStringSchema,
   sensitiveUrlSchema,
+  unionType,
   validateUserConfigZodType,
 } from "@nomicfoundation/hardhat-zod-utils";
 import { z } from "zod";
@@ -28,7 +29,6 @@ export const DEFAULT_FUZZ_SEED =
   "0x7727ea51af0441c20da14dcd68a15dac8c9ebd589c5be8fa8c87c1d3720450bc";
 
 const solidityTestUserConfigType = z.object({
-  timeout: z.number().optional(),
   fsPermissions: z
     .object({
       readWriteFile: z.array(z.string()).optional(),
@@ -66,7 +66,12 @@ const solidityTestUserConfigType = z.object({
   forking: z
     .object({
       url: z.optional(sensitiveUrlSchema),
-      blockNumber: z.bigint().optional(),
+      blockNumber: z.optional(
+        unionType(
+          [z.number().int().nonnegative().safe(), z.bigint().nonnegative()],
+          "Expected a nonnegative safe int or a nonnegative bigint",
+        ),
+      ),
       rpcEndpoints: z.record(sensitiveStringSchema).optional(),
     })
     .optional(),
@@ -122,6 +127,10 @@ export function resolveSolidityTestForkingConfig(
 
   return {
     ...forkingUserConfig,
+    blockNumber:
+      forkingUserConfig.blockNumber !== undefined
+        ? BigInt(forkingUserConfig.blockNumber)
+        : undefined,
     url:
       forkingUserConfig.url !== undefined
         ? resolveConfigurationVariable(forkingUserConfig.url)

package/src/internal/builtin-plugins/solidity-test/helpers.ts

@@ -1,4 +1,3 @@
-import type { RunOptions } from "./runner.js";
 import type { Abi } from "../../../types/artifacts.js";
 import type { ChainType } from "../../../types/network.js";
 import type { SolidityTestConfig } from "../../../types/test.js";
@@ -41,12 +40,6 @@ interface SolidityTestConfigParams {
   testFunctionOverrides?: TestFunctionOverride[];
 }
 
-export function solidityTestConfigToRunOptions(
-  config: SolidityTestConfig,
-): RunOptions {
-  return config;
-}
-
 export async function solidityTestConfigToSolidityTestRunnerConfigArgs({
   chainType,
   projectRoot,