hardhat 3.4.4 → 3.5.0

package/src/internal/builtin-plugins/network-manager/utils/apply-coverage-network-overrides.ts

@@ -0,0 +1,32 @@
+import type { EdrNetworkConfig } from "../../../../types/config.js";
+
+/**
+ * Returns a copy of the resolved EDR network config with coverage-specific
+ * overrides applied. When coverage is enabled and the user has not set the
+ * field explicitly:
+ *
+ * - `allowUnlimitedContractSize` defaults to `true`, because coverage
+ *   instrumentation can push the contract size over the limit.
+ * - `blockGasLimit` and `transactionGasCap` default to `false` (disabled),
+ *   so the added gas of coverage instrumentation does not push tests over
+ *   the per-block or EIP-7825 transaction caps.
+ *
+ * Explicit user values are preserved in all three cases.
+ *
+ * When coverage is disabled, the config is returned unchanged.
+ */
+export function applyCoverageNetworkOverrides(
+  config: EdrNetworkConfig,
+  shouldEnableCoverage: boolean,
+): EdrNetworkConfig {
+  if (!shouldEnableCoverage) {
+    return config;
+  }
+
+  return {
+    ...config,
+    allowUnlimitedContractSize: config.allowUnlimitedContractSize ?? true,
+    blockGasLimit: config.blockGasLimit ?? false,
+    transactionGasCap: config.transactionGasCap ?? false,
+  };
+}

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

@@ -269,6 +269,12 @@ const _handleError = (error: Error): JsonRpcResponse => {
     error = new InternalError(undefined, error);
   }
 
+  // Revert errors (code 3): return raw hex to match the geth/anvil convention
+  // that viem/ethers/web3.js rely on. Other errors keep the wrapper for diagnostics.
+  const data: unknown = isRevertError
+    ? returnData
+    : { message: error.message, txHash, data: returnData };
+
   const response: FailedJsonRpcResponse = {
     jsonrpc: "2.0",
     id: null,
@@ -278,11 +284,7 @@ const _handleError = (error: Error): JsonRpcResponse => {
           ? error.code
           : InternalError.CODE,
       message: error.message,
-      data: {
-        message: error.message,
-        txHash,
-        data: returnData,
-      },
+      data,
     },
   };
 

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

@@ -43,7 +43,6 @@ import { createDebug } from "@nomicfoundation/hardhat-utils/debug";
 import {
   exists,
   ensureDir,
-  getAllDirectoriesMatching,
   getAllFilesMatching,
   move,
   readJsonFile,
@@ -1098,29 +1097,46 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
 
     const userSourceNamesSet = new Set(userSourceNames);
 
-    for (const file of await getAllDirectoriesMatching(
+    const buildInfosDir = path.join(artifactsDirectory, `build-info`);
+
+    // We accept both `.json` files and per-file `artifacts.d.ts` files:
+    // source files that compile but produce no contracts emit only the
+    // declaration file, but their parent dir still belongs in the cleanup
+    // candidate set.
+    // TODO: This logic is originated with the artifacts manager, but now uses both json files and `artifacts.d.ts` as the test
+    const allArtifactFiles = await getAllFilesMatching(
       artifactsDirectory,
-      (d) => d.endsWith(".sol"),
-    )) {
+      (p) => {
+        // Ignore top level files (e.g. the project-wide artifacts.d.ts)
+        if (
+          p.indexOf(path.sep, artifactsDirectory.length + path.sep.length) ===
+          -1
+        ) {
+          return false;
+        }
+        return p.endsWith(".json") || path.basename(p) === "artifacts.d.ts";
+      },
+      (dir) => dir !== buildInfosDir,
+    );
+
+    const artifactDirs = new Set(
+      allArtifactFiles.map((file) => path.dirname(file)),
+    );
+    const removedDirs = new Set<string>();
+
+    for (const dir of artifactDirs) {
       const relativePath = toForwardSlash(
-        path.relative(artifactsDirectory, file),
+        path.relative(artifactsDirectory, dir),
       );
 
       if (!userSourceNamesSet.has(relativePath)) {
-        await remove(file);
+        await remove(dir);
+        removedDirs.add(dir);
       }
     }
 
-    const buildInfosDir = path.join(artifactsDirectory, `build-info`);
-
-    // TODO: This logic is duplicated with respect to the artifacts manager
-    const artifactPaths = await getAllFilesMatching(
-      artifactsDirectory,
-      (p) =>
-        p.endsWith(".json") && // Only consider json files
-        // Ignore top level json files
-        p.indexOf(path.sep, artifactsDirectory.length + path.sep.length) !== -1,
-      (dir) => dir !== buildInfosDir,
+    const artifactPaths = allArtifactFiles.filter(
+      (p) => p.endsWith(".json") && !removedDirs.has(path.dirname(p)),
     );
 
     const reachableBuildInfoIds = await Promise.all(

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
@@ -478,6 +477,13 @@ export class RemappedNpmPackagesGraphImplementation
       (f) => !f.endsWith("node_modules"),
     );
 
+    // Sort by path so the first-wins dedup downstream is deterministic across
+    // filesystems. We sort here (and not after hook composition) so that hooks
+    // can rely on the contract that remappings they append after next() come
+    // last — e.g. hardhat-foundry appends forge's remappings after the
+    // package's own remappings.txt files, expecting remappings.txt to win.
+    remappingsTxtFiles.sort();
+
     const results: Array<{ remappings: string[]; source: string }> = [];
     for (const file of remappingsTxtFiles) {
       const contents = await readUtf8File(file);

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/index.ts

@@ -3,7 +3,7 @@ import type { HardhatPlugin } from "../../../types/plugins.js";
 import { ArgumentType } from "../../../types/arguments.js";
 import { globalOption, task } from "../../core/config.js";
 
-import "./type-extensions.js";
+export type * from "./type-extensions.js";
 
 const buildTask = task("build", "Build project")
   .addFlag({
@@ -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/type-extensions.ts

@@ -11,7 +11,6 @@ import type {
   CompilerOutput,
 } from "../../../types/solidity.js";
 
-import "../../../types/config.js";
 declare module "../../../types/config.js" {
   /**
    * An interface with a key per compiler type.
@@ -318,21 +317,18 @@ declare module "../../../types/config.js" {
   }
 }
 
-import "../../../types/hre.js";
 declare module "../../../types/hre.js" {
   export interface HardhatRuntimeEnvironment {
     solidity: SolidityBuildSystem;
   }
 }
 
-import "../../../types/global-options.js";
 declare module "../../../types/global-options.js" {
   export interface GlobalOptions {
     buildProfile: string;
   }
 }
 
-import "../../../types/hooks.js";
 declare module "../../../types/hooks.js" {
   export interface HardhatHooks {
     solidity: SolidityHooks;

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 ?? [],
+  };
+}