hardhat 3.4.5 → 3.5.1

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

@@ -95,21 +95,6 @@ export function isSolcSolidityCompilerConfig(
   return config.type === undefined || config.type === "solc";
 }
 
-// Compiler warnings to suppress from build output.
-// Each rule specifies a warning message and the source file it applies to.
-// This allows suppressing known warnings from internal files (e.g., console.sol)
-// while still showing the same warning type from user code.
-export const SUPPRESSED_WARNINGS: Array<{
-  message: string;
-  sourceFile: string;
-}> = [
-  {
-    message:
-      "Natspec memory-safe-assembly special comment for inline assembly is deprecated and scheduled for removal. Use the memory-safe block annotation instead.",
-    sourceFile: path.normalize("hardhat/console.sol"),
-  },
-];
-
 interface CompilationResult {
   compilationJob: CompilationJob;
   compilerOutput: CompilerOutput;
@@ -123,6 +108,7 @@ export interface SolidityBuildSystemOptions {
   readonly artifactsPath: string;
   readonly cachePath: string;
   readonly solidityTestsPath: string;
+  readonly coverage: boolean;
 }
 
 /**
@@ -1417,6 +1403,7 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
       msg,
       this.#options.solidityTestsPath,
       this.#options.projectRoot,
+      this.#options.coverage,
     );
   }
 

package/src/internal/builtin-plugins/solidity/build-system/resolver/remapped-npm-packages-graph.ts

@@ -29,14 +29,13 @@ import {
 } from "@nomicfoundation/hardhat-utils/package";
 
 import { UserRemappingErrorType } from "../../../../../types/solidity.js";
+import { HARDHAT_PROJECT_INPUT_SOURCE_NAME_ROOT } from "../../constants.js";
 
 import { getNpmPackageName } from "./npm-module-parsing.js";
 import { parseRemappingString, selectBestRemapping } from "./remappings.js";
 import { sourceNamePathJoin } from "./source-name-utils.js";
 import { UserRemappingType } from "./types.js";
 
-const HARDHAT_PROJECT_INPUT_SOURCE_NAME_ROOT = "project";
-
 /**
  * Returns a normalized version of the path if it refers to a node_modules in
  * the root directory (i.e. node_modules/...), or a `node_modules` directory

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

@@ -1,97 +1,119 @@
 import path from "node:path";
 
-// Compiler warnings to suppress from build output.
-// Supports two types of suppression rules:
-//
-// 1. scope: 'specific-file' - Suppress warnings from specific file paths
-//    - Use this to suppress known warnings from internal/library files (e.g., console.sol)
-//    - The same warning type will still be shown for user code
-//
-// 2. scope: 'test-files' - Suppress warnings from all test files
-//    - Test files are identified as:
-//      * Files ending in .t.sol (e.g., Counter.t.sol)
-//      * Files inside test/contracts/ directory
-//        (e.g., test/contracts/Example.sol)
-//    - Use this for warnings that are acceptable in test code but not in production code
-//      (e.g., missing SPDX license identifiers or pragma statements)
-export const SUPPRESSED_WARNINGS: Array<
-  | {
-      message: string;
-      scope: "specific-file";
-      filePath: string;
-    }
-  | {
-      message: string;
-      scope: "test-files";
-    }
-> = [
+import { COVERAGE_LIBRARY_FILE_NAME } from "@nomicfoundation/edr";
+
+export const NATSPEC_MEMORY_SAFE_ASSEMBLY_WARNING =
+  "Natspec memory-safe-assembly special comment for inline assembly is deprecated and scheduled for removal. Use the memory-safe block annotation instead.";
+export const SPDX_WARNING = "SPDX license identifier not provided";
+export const PRAGMA_WARNING =
+  "Source file does not specify required compiler version";
+const CONTRACT_SIZE_WARNING = "Contract code size is";
+
+// Suppression rules are grouped by scope. Each array has its own match logic
+// in `shouldSuppressWarning` function; add new entries to the array that fits, or add
+// a new array + block for a new scope.
+
+// Warnings tied to a specific internal file (e.g. console.sol). Suppressed
+// only when the warning points at that file.
+const SPECIFIC_FILE_RULES: ReadonlyArray<{
+  message: string;
+  filePath: string;
+}> = [
   {
-    message:
-      "Natspec memory-safe-assembly special comment for inline assembly is deprecated and scheduled for removal. Use the memory-safe block annotation instead.",
-    scope: "specific-file",
+    message: NATSPEC_MEMORY_SAFE_ASSEMBLY_WARNING,
     // Normalize to handle different OS path separators
     filePath: path.normalize("hardhat/console.sol"),
   },
+];
+
+// Warnings acceptable in test files. Suppressed when the warning points at a
+// file ending in `.t.sol` or inside the configured Solidity test directory.
+const TEST_FILE_WARNING_MESSAGES: readonly string[] = [
+  SPDX_WARNING,
+  PRAGMA_WARNING,
+];
+
+// Warnings suppressed only when running with `--coverage`. An entry with no
+// `filePath` matches the message anywhere (e.g. contract-size warnings that
+// fire on user files as a side effect of instrumentation); an entry with a
+// `filePath` only matches when the diagnostic also points at that file
+// (e.g. the injected coverage library file, which users can't edit).
+const COVERAGE_MODE_RULES: ReadonlyArray<{
+  message: string;
+  filePath?: string;
+}> = [
+  { message: CONTRACT_SIZE_WARNING },
   {
-    message: "SPDX license identifier not provided",
-    scope: "test-files",
-  },
-  {
-    message: "Source file does not specify required compiler version",
-    scope: "test-files",
+    message: NATSPEC_MEMORY_SAFE_ASSEMBLY_WARNING,
+    filePath: COVERAGE_LIBRARY_FILE_NAME,
   },
 ];
 
 /**
- * Determines if a compiler warning should be suppressed based on the suppression rules.
+ * Determines if a compiler warning should be suppressed.
  *
  * @param errorMessage - The formatted error message from the compiler
  * @param absoluteSolidityTestsPath - Absolute path to the Solidity test directory
  * @param absoluteProjectRoot - Absolute path to the project root
+ * @param coverage - Whether the build is running with `--coverage` enabled
  * @returns true if the warning should be suppressed, false otherwise
  */
 export function shouldSuppressWarning(
   errorMessage: string,
   absoluteSolidityTestsPath: string,
   absoluteProjectRoot: string,
+  coverage: boolean,
 ): boolean {
-  // Compute relative path from project root to test directory.
-  // Example:
-  // 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(
-    path.relative(absoluteProjectRoot, absoluteSolidityTestsPath),
-    "/",
-  );
-
-  return SUPPRESSED_WARNINGS.some((rule) => {
-    if (!errorMessage.includes(rule.message)) {
-      return false;
-    }
+  // Warnings suppressed only when running with `--coverage`.
+  if (
+    coverage &&
+    COVERAGE_MODE_RULES.some(
+      (rule) =>
+        errorMessage.includes(rule.message) &&
+        (rule.filePath === undefined || errorMessage.includes(rule.filePath)),
+    )
+  ) {
+    return true;
+  }
 
-    if (rule.scope === "specific-file") {
-      return errorMessage.includes(rule.filePath);
-    }
+  // Warnings tied to a specific internal file (e.g. console.sol).
+  if (
+    SPECIFIC_FILE_RULES.some(
+      (rule) =>
+        errorMessage.includes(rule.message) &&
+        errorMessage.includes(rule.filePath),
+    )
+  ) {
+    return true;
+  }
 
-    // Check if the message contains a path to a test file
+  // Warnings allowed in test files.
+  if (TEST_FILE_WARNING_MESSAGES.some((m) => errorMessage.includes(m))) {
     // Test files are identified by:
     // - Ending in .t.sol (e.g., Counter.t.sol)
     // - Being inside the configured Solidity test directory
-
     if (/\.t\.sol(:|$|\s)/.test(errorMessage)) {
       return true;
     }
 
-    // Extract file path from error message
+    // Compute relative path from project root to test directory.
+    // Example:
+    // 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(
+      path.relative(absoluteProjectRoot, absoluteSolidityTestsPath),
+      "/",
+    );
+
+    // Extract file path from error message.
     // Format: "Warning: message\n  --> path/to/file.sol:line:column:"
     const pathMatches = errorMessage.match(/-->\s+([^\s:]+\.sol)/);
-
     if (pathMatches !== null) {
       return pathMatches[1].includes(relativeTestPath);
     }
+  }
 
-    return false;
-  });
+  return false;
 }

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

@@ -1,5 +1,16 @@
 import type { CompilerInput } from "../../../types/solidity.js";
 
+/**
+ * The input source name prefix used for files belonging to the Hardhat
+ * project (as opposed to npm packages, which use `npm/<pkg>@<version>`).
+ *
+ * For example, a project file at `<root>/contracts/Foo.sol` has input
+ * source name `project/contracts/Foo.sol`. Part of the build-info format
+ * contract: changing this value would require a new build-info format
+ * version.
+ */
+export const HARDHAT_PROJECT_INPUT_SOURCE_NAME_ROOT = "project";
+
 export const DEFAULT_OUTPUT_SELECTION: CompilerInput["settings"]["outputSelection"] =
   {
     "*": {

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

@@ -152,7 +152,7 @@ class LazySolidityBuildSystem implements SolidityBuildSystem {
 
 export default async (): Promise<Partial<HardhatRuntimeEnvironmentHooks>> => {
   return {
-    created: async (_context, hre) => {
+    created: async (context, hre) => {
       hre.solidity = new LazySolidityBuildSystem(hre.hooks, {
         solidityConfig: hre.config.solidity,
         projectRoot: hre.config.paths.root,
@@ -160,6 +160,7 @@ export default async (): Promise<Partial<HardhatRuntimeEnvironmentHooks>> => {
         artifactsPath: hre.config.paths.artifacts,
         cachePath: hre.config.paths.cache,
         solidityTestsPath: hre.config.paths.tests.solidity,
+        coverage: context.globalOptions.coverage,
       });
     },
   };

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

@@ -53,6 +53,7 @@ const hardhatPlugin: HardhatPlugin = {
       ...buildTask,
       id: ["compile"],
       description: "Build project (alias for build)",
+      action: async () => await import("./tasks/compile.js"),
     },
   ],
   globalOptions: [

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

@@ -0,0 +1,12 @@
+import type { NewTaskActionFunction } from "../../../../types/tasks.js";
+
+/**
+ * Compile task action is an alias of the build task action, it invokes
+ * the build task to ensure any build overrides are properly executed when
+ * compile is run.
+ */
+const compileAction: NewTaskActionFunction = async (args, hre) => {
+  return await hre.tasks.getTask("build").run(args);
+};
+
+export default compileAction;

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

@@ -6,17 +6,19 @@ import type {
 } from "../../../types/config.js";
 import type { HardhatUserConfigValidationError } from "../../../types/hooks.js";
 import type {
-  SolidityTestConfig,
   SolidityTestForkingConfig,
-  SolidityTestUserConfig,
+  SolidityTestProfileConfig,
+  SolidityTestProfileUserConfig,
 } from "../../../types/test.js";
 
 import path from "node:path";
 
+import { assertHardhatInvariant } from "@nomicfoundation/hardhat-errors";
 import { isObject } from "@nomicfoundation/hardhat-utils/lang";
 import { resolveFromRoot } from "@nomicfoundation/hardhat-utils/path";
 import {
   conditionalUnionType,
+  incompatibleFieldType,
   sensitiveStringSchema,
   sensitiveUrlSchema,
   unionType,
@@ -24,11 +26,13 @@ import {
 } from "@nomicfoundation/hardhat-zod-utils";
 import { z } from "zod";
 
+import { DEFAULT_TEST_PROFILE } from "./test-profiles.js";
+
 // the keccak256 of "built for ethereum"
 export const DEFAULT_FUZZ_SEED =
   "0x7727ea51af0441c20da14dcd68a15dac8c9ebd589c5be8fa8c87c1d3720450bc";
 
-const solidityTestUserConfigType = z.object({
+const solidityTestProfileUserConfigType = z.object({
   fsPermissions: z
     .object({
       readWriteFile: z.array(z.string()).optional(),
@@ -50,7 +54,11 @@ const solidityTestUserConfigType = z.object({
   blockTimestamp: z.bigint().optional(),
   prevRandao: z.bigint().optional(),
   gasLimit: z.bigint().optional(),
-  blockGasLimit: z.bigint().or(z.literal(false)).optional(),
+  blockGasLimit: z.number().or(z.bigint()).or(z.literal(false)).optional(),
+  // TODO: widen back to .number().or(z.bigint()).or(z.literal(false))
+  // once Solidity test runner no longer breaks setUp() when
+  // disableTransactionGasCap is false. See PR #8301.
+  transactionGasCap: z.literal(false).optional(),
   fuzz: z
     .object({
       failurePersistDir: z.string().optional(),
@@ -89,8 +97,49 @@ const solidityTestUserConfigType = z.object({
       shrinkRunLimit: z.number().optional(),
     })
     .optional(),
+  eip712Types: z
+    .object({
+      include: z.array(z.string()).optional(),
+      exclude: z.array(z.string()).optional(),
+    })
+    .optional(),
 });
 
+const solidityTestFlatUserConfigType = solidityTestProfileUserConfigType.extend(
+  {
+    profiles: incompatibleFieldType(
+      "This field is incompatible with the flat solidity test config",
+    ),
+  },
+);
+
+const solidityTestProfilesUserConfigType = z.object({
+  profiles: z
+    .record(z.string(), solidityTestProfileUserConfigType)
+    .refine(
+      (profiles) => DEFAULT_TEST_PROFILE in profiles,
+      "A `default` profile is required when using `profiles`",
+    )
+    .refine(
+      (profiles) =>
+        !(DEFAULT_TEST_PROFILE in profiles) ||
+        Object.keys(profiles).every((name) => name === DEFAULT_TEST_PROFILE),
+      "Only the `default` profile is supported. Other profile names will be supported in a future release.",
+    ),
+});
+
+const solidityTestUserConfigType = conditionalUnionType(
+  [
+    [
+      (data) =>
+        isObject(data) && "profiles" in data && Object.keys(data).length === 1,
+      solidityTestProfilesUserConfigType,
+    ],
+    [isObject, solidityTestFlatUserConfigType],
+  ],
+  "Expected a Solidity test config or a `{ profiles: { ... } }` wrapper",
+);
+
 const userConfigType = z.object({
   paths: z
     .object({
@@ -111,7 +160,7 @@ const userConfigType = z.object({
 });
 
 export function resolveSolidityTestForkingConfig(
-  forkingUserConfig: SolidityTestUserConfig["forking"],
+  forkingUserConfig: SolidityTestProfileUserConfig["forking"],
   resolveConfigurationVariable: ConfigurationVariableResolver,
 ): SolidityTestForkingConfig | undefined {
   if (forkingUserConfig === undefined) {
@@ -159,16 +208,29 @@ export async function resolveSolidityTestUserConfig(
 
   const defaultRpcCachePath = path.join(resolvedConfig.paths.cache, "edr");
 
+  const solidityUserConfig = userConfig.test?.solidity;
+  let profileUserConfig: SolidityTestProfileUserConfig | undefined;
+  if (solidityUserConfig !== undefined && "profiles" in solidityUserConfig) {
+    profileUserConfig = solidityUserConfig.profiles[DEFAULT_TEST_PROFILE];
+    assertHardhatInvariant(
+      profileUserConfig !== undefined,
+      "default profile must be present when the profiles wrapper user config is supplied",
+    );
+  } else {
+    profileUserConfig = solidityUserConfig;
+  }
+
   const resolvedForking = resolveSolidityTestForkingConfig(
-    userConfig.test?.solidity?.forking,
+    profileUserConfig?.forking,
     resolveConfigurationVariable,
   );
 
-  const solidityTest = {
+  const resolvedDefaultProfile = {
     rpcCachePath: defaultRpcCachePath,
-    ...userConfig.test?.solidity,
-    fuzz: resolveFuzzConfig(userConfig.test?.solidity?.fuzz),
+    ...profileUserConfig,
+    fuzz: resolveFuzzConfig(profileUserConfig?.fuzz),
     forking: resolvedForking,
+    eip712Types: resolveEip712TypesConfig(profileUserConfig?.eip712Types),
   };
 
   return {
@@ -182,16 +244,27 @@ export async function resolveSolidityTestUserConfig(
     },
     test: {
       ...resolvedConfig.test,
-      solidity: solidityTest,
+      solidity: {
+        profiles: { [DEFAULT_TEST_PROFILE]: resolvedDefaultProfile },
+      },
     },
   };
 }
 
 export function resolveFuzzConfig(
-  fuzzUserConfig: SolidityTestUserConfig["fuzz"] = {},
-): SolidityTestConfig["fuzz"] {
+  fuzzUserConfig: SolidityTestProfileUserConfig["fuzz"] = {},
+): SolidityTestProfileConfig["fuzz"] {
   return {
     ...fuzzUserConfig,
     seed: fuzzUserConfig.seed ?? DEFAULT_FUZZ_SEED,
   };
 }
+
+export function resolveEip712TypesConfig(
+  eip712TypesUserConfig: SolidityTestProfileUserConfig["eip712Types"] = {},
+): SolidityTestProfileConfig["eip712Types"] {
+  return {
+    include: eip712TypesUserConfig.include ?? [],
+    exclude: eip712TypesUserConfig.exclude ?? [],
+  };
+}