hardhat 3.4.5 → 3.5.0

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

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

package/src/internal/builtin-plugins/solidity-test/eip712/ast-walker.ts

@@ -0,0 +1,324 @@
+import { isObject } from "@nomicfoundation/hardhat-utils/lang";
+
+/**
+ * A single field of a Solidity struct
+ */
+export interface StructMember {
+  name: string;
+  /**
+   * EIP-712 type string, or `undefined` if the type can't be encoded (e.g. mappings).
+   */
+  type: string | undefined;
+}
+
+/**
+ * A Solidity struct extracted from a source AST (Abstract Syntax Tree).
+ */
+export interface CollectedStruct {
+  name: string;
+  members: StructMember[];
+  /**
+   * Project-relative source path. Used for diagnostics only.
+   */
+  sourcePath: string;
+}
+
+/**
+ * A user-defined value type (`type Foo is bytes32;`) resolves to its
+ * underlying elementary type for EIP-712 encoding.
+ * The map is keyed by the user-defined value type definition's solc node id,
+ * which is what `referencedDeclaration` on a `UserDefinedTypeName` reference
+ * points to.
+ */
+export type UserDefinedValueTypeIndex = Map<number, Record<string, unknown>>;
+
+/**
+ * Walks every AST in the build and indexes every `UserDefinedValueTypeDefinition`
+ * by its node `id`, mapping to its `underlyingType` (an `ElementaryTypeName`).
+ *
+ * User-defined value types can sit at file scope or inside a contract, and a
+ * struct in one source may reference a user-defined value type defined in
+ * another, so this must run across every AST in the build — not just the ones
+ * matched by the user's include globs.
+ */
+export function buildUserDefinedValueTypeIndex(
+  asts: unknown[],
+): UserDefinedValueTypeIndex {
+  const index: UserDefinedValueTypeIndex = new Map();
+
+  for (const ast of asts) {
+    if (!isObject(ast) || ast.nodeType !== "SourceUnit") {
+      continue;
+    }
+
+    const topLevelNodes: unknown[] = Array.isArray(ast.nodes) ? ast.nodes : [];
+    for (const node of topLevelNodes) {
+      if (!isObject(node)) {
+        continue;
+      }
+
+      if (node.nodeType === "UserDefinedValueTypeDefinition") {
+        recordUserDefinedValueType(node, index);
+      } else if (node.nodeType === "ContractDefinition") {
+        const members: unknown[] = Array.isArray(node.nodes) ? node.nodes : [];
+        for (const member of members) {
+          if (
+            isObject(member) &&
+            member.nodeType === "UserDefinedValueTypeDefinition"
+          ) {
+            recordUserDefinedValueType(member, index);
+          }
+        }
+      }
+    }
+  }
+
+  return index;
+}
+
+function recordUserDefinedValueType(
+  node: Record<string, unknown>,
+  index: UserDefinedValueTypeIndex,
+): void {
+  if (
+    typeof node.id === "number" &&
+    isObject(node.underlyingType) &&
+    node.underlyingType.nodeType === "ElementaryTypeName"
+  ) {
+    index.set(node.id, node.underlyingType);
+  }
+}
+
+/**
+ * Returns every struct definition reachable from a solc source AST (Abstract Syntax Tree),
+ * including structs nested inside contracts.
+ */
+export function extractStructsFromAst(
+  ast: unknown,
+  sourcePath: string,
+  userDefinedValueTypeI: UserDefinedValueTypeIndex = new Map(),
+): CollectedStruct[] {
+  if (!isObject(ast) || ast.nodeType !== "SourceUnit") {
+    return [];
+  }
+
+  const results: CollectedStruct[] = [];
+  const topLevelNodes: unknown[] = Array.isArray(ast.nodes) ? ast.nodes : [];
+
+  for (const node of topLevelNodes) {
+    if (!isObject(node)) {
+      continue;
+    }
+
+    if (node.nodeType === "StructDefinition") {
+      const collected = collectStruct(node, sourcePath, userDefinedValueTypeI);
+      if (collected !== undefined) {
+        results.push(collected);
+      }
+    } else if (node.nodeType === "ContractDefinition") {
+      const members: unknown[] = Array.isArray(node.nodes) ? node.nodes : [];
+      for (const member of members) {
+        if (isObject(member) && member.nodeType === "StructDefinition") {
+          const collected = collectStruct(
+            member,
+            sourcePath,
+            userDefinedValueTypeI,
+          );
+          if (collected !== undefined) {
+            results.push(collected);
+          }
+        }
+      }
+    }
+  }
+
+  return results;
+}
+
+function collectStruct(
+  node: Record<string, unknown>,
+  sourcePath: string,
+  userDefinedValueTypeI: UserDefinedValueTypeIndex,
+): CollectedStruct | undefined {
+  if (typeof node.name !== "string") {
+    return undefined;
+  }
+
+  const memberNodes: unknown[] = Array.isArray(node.members)
+    ? node.members
+    : [];
+  const members: StructMember[] = [];
+
+  for (const memberNode of memberNodes) {
+    if (
+      !isObject(memberNode) ||
+      memberNode.nodeType !== "VariableDeclaration"
+    ) {
+      continue;
+    }
+
+    if (typeof memberNode.name !== "string") {
+      continue;
+    }
+
+    members.push({
+      name: memberNode.name,
+      type: encodeMemberType(memberNode.typeName, userDefinedValueTypeI),
+    });
+  }
+
+  return {
+    name: node.name,
+    members,
+    sourcePath,
+  };
+}
+
+/**
+ * Converts a solc `typeName` AST node into its EIP-712 type string, following
+ * the same conventions as `forge bind-json`:
+ *
+ *   - elementary types pass through (`address`, `uint256`, `string`, ...)
+ *   - enums                  → `uint8`
+ *   - contracts / interfaces → `address`
+ *   - structs                → bare name (`Wallet.Person` → `Person`)
+ *   - user-defined value types → underlying elementary type (`type Foo is bytes32` → `bytes32`)
+ *   - arrays                 → `T[]` (dynamic) or `T[N]` (fixed)
+ *   - mappings / functions   → `undefined` (not EIP-712 encodable)
+ */
+export function encodeMemberType(
+  typeName: unknown,
+  userDefinedValueTypeI: UserDefinedValueTypeIndex = new Map(),
+): string | undefined {
+  if (!isObject(typeName)) {
+    return undefined;
+  }
+
+  switch (typeName.nodeType) {
+    case "ElementaryTypeName": {
+      // Prefer `typeDescriptions.typeString` over `name`: solc emits the
+      // unresolved alias in `name` (`uint`, `int`, `byte`), but the canonical
+      // EIP-712 type is in `typeString` (`uint256`, `int256`, `bytes1`).
+      // `address payable` is the exception — `typeString` is `"address payable"`
+      // while the canonical EIP-712 type is just `address`.
+      const desc = isObject(typeName.typeDescriptions)
+        ? typeName.typeDescriptions
+        : undefined;
+      const typeString =
+        typeof desc?.typeString === "string" ? desc.typeString : undefined;
+      if (typeString !== undefined) {
+        return typeString.endsWith(" payable")
+          ? typeString.slice(0, -" payable".length)
+          : typeString;
+      }
+
+      return typeof typeName.name === "string" ? typeName.name : undefined;
+    }
+
+    case "UserDefinedTypeName": {
+      // `typeDescriptions.typeString` is the only reliable way to tell what
+      // kind of user-defined type this is — e.g. "struct Foo", "enum Bar",
+      // "contract Token". The AST node itself doesn't say. Note that solc
+      // emits the "contract " prefix for interface references as well.
+      const desc = isObject(typeName.typeDescriptions)
+        ? typeName.typeDescriptions
+        : undefined;
+      const typeString =
+        typeof desc?.typeString === "string" ? desc.typeString : "";
+
+      if (typeString.startsWith("enum ")) {
+        return "uint8";
+      }
+
+      if (typeString.startsWith("contract ")) {
+        return "address";
+      }
+
+      if (typeString.startsWith("struct ")) {
+        // EIP-712 references structs by their bare name, so strip both the
+        // "struct " prefix, any storage-location suffix solc may append
+        // ("memory", "storage", ...), and any qualifier ("Wallet.Person").
+        const remainder = typeString.slice("struct ".length).trim();
+        const namePart = remainder.split(/\s+/)[0];
+        const segments = namePart.split(".");
+        return segments[segments.length - 1];
+      }
+
+      // User-defined value types (`type Foo is bytes32;`, solc 0.8.8+).
+      // Resolve via `referencedDeclaration` against the build-wide
+      // user-defined value type index
+      // and recurse on the underlying elementary type — matching forge's
+      // `Resolver::resolve_type` so `Foo h` encodes as `bytes32 h`, not `Foo h`.
+      const refId =
+        typeof typeName.referencedDeclaration === "number"
+          ? typeName.referencedDeclaration
+          : isObject(typeName.pathNode) &&
+              typeof typeName.pathNode.referencedDeclaration === "number"
+            ? typeName.pathNode.referencedDeclaration
+            : undefined;
+
+      if (refId !== undefined) {
+        const underlying = userDefinedValueTypeI.get(refId);
+        if (underlying !== undefined) {
+          return encodeMemberType(underlying, userDefinedValueTypeI);
+        }
+      }
+
+      // Fallback when the reference can't be resolved (missing
+      // `referencedDeclaration`, or its definition wasn't in the build).
+      // Emitting the name lets the downstream encoder produce a clear error
+      // rather than failing silently here.
+      if (typeof typeName.name === "string") {
+        return typeName.name;
+      }
+
+      if (
+        isObject(typeName.pathNode) &&
+        typeof typeName.pathNode.name === "string"
+      ) {
+        const segments = typeName.pathNode.name.split(".");
+        return segments[segments.length - 1];
+      }
+
+      return undefined;
+    }
+
+    case "ArrayTypeName": {
+      const base = encodeMemberType(typeName.baseType, userDefinedValueTypeI);
+      if (base === undefined) {
+        return undefined;
+      }
+
+      // solc omits `length` entirely for dynamic arrays; it isn't emitted as `null`.
+      const length = typeName.length;
+      if (length === null || length === undefined) {
+        return `${base}[]`;
+      }
+
+      // Always read from typeString: `Literal.value` preserves source text
+      // (`0x100`, `1_000`) but typeString canonicalizes to decimal.
+      const desc = isObject(typeName.typeDescriptions)
+        ? typeName.typeDescriptions
+        : undefined;
+      const typeString =
+        typeof desc?.typeString === "string" ? desc.typeString : "";
+      const match = /\[(\d+)\]$/.exec(typeString);
+
+      if (match !== null) {
+        return `${base}[${match[1]}]`;
+      }
+
+      return undefined;
+    }
+
+    case "Mapping":
+      return undefined;
+
+    case "FunctionTypeName":
+      // EIP-712 can't encode function types.
+      return undefined;
+
+    default:
+      return undefined;
+  }
+}