hardhat 3.4.4 → 3.5.0

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;
+  }
+}

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

@@ -0,0 +1,317 @@
+import type { CollectedStruct } from "./ast-walker.js";
+
+import { HardhatError } from "@nomicfoundation/hardhat-errors";
+
+/**
+ * Produces the flat list of canonical EIP-712 type strings expected by EDR.
+ *
+ * Each encodable struct contributes one entry, built like this:
+ *   1. Start with the struct's own head: `Name(type1 name1,type2 name2,...)`.
+ *   2. If the struct has fields that reference other structs, append those
+ *      structs' heads after it, sorted alphabetically.
+ *
+ * Examples:
+ *   - `Person` has only primitive fields (address, string), so its entry is
+ *     just its own head:
+ *       `Person(address wallet,string name)`
+ *   - `Mail` has a `Person` field, so its entry is its head plus `Person`'s
+ *     head appended:
+ *       `Mail(Person from,Person to,string contents)Person(address wallet,string name)`
+ *
+ * Structs that contain members whose type cannot be EIP-712 encoded (mappings,
+ * function types, etc.) are dropped entirely, along with any structs that
+ * depend on them transitively. This matches `forge bind-json`'s behavior:
+ * `resolve_struct_eip712` returns `None` for any struct containing unsupported
+ * constructs and propagates `None` through the dep graph so dependents are
+ * also dropped.
+ *
+ * Only names in `selectedNames` are emitted; non-selected structs still
+ * participate in dep resolution so cross-file deps inline correctly.
+ */
+export function canonicalizeStructs(
+  structs: CollectedStruct[],
+  selectedNames: Set<string>,
+): string[] {
+  const byName = indexByName(structs, selectedNames);
+  const knownNames = new Set(byName.keys());
+  const encodable = computeEncodable(byName, knownNames);
+  const result: string[] = [];
+
+  for (const struct of byName.values()) {
+    if (!selectedNames.has(struct.name)) {
+      continue;
+    }
+
+    if (!encodable.has(struct.name)) {
+      continue;
+    }
+
+    const head = encodeStructHead(struct);
+    const deps = transitiveDeps(struct, byName)
+      .map((depName) => {
+        const def = byName.get(depName);
+        return def === undefined ? undefined : encodeStructHead(def);
+      })
+      .filter((s): s is string => s !== undefined);
+
+    deps.sort();
+
+    result.push(head + deps.join(""));
+  }
+
+  return result;
+}
+
+/**
+ * Returns the set of struct names that are EIP-712 encodable. A struct is
+ * encodable if none of its members has a non-decodable type (`type === undefined`,
+ * e.g. mappings or function types) AND every one of its struct deps — direct or
+ * transitive — is itself encodable.
+ */
+function computeEncodable(
+  byName: Map<string, CollectedStruct>,
+  knownNames: Set<string>,
+): Set<string> {
+  const encodable = new Set<string>(byName.keys());
+
+  for (const [name, struct] of byName) {
+    if (struct.members.some((m) => m.type === undefined)) {
+      encodable.delete(name);
+    }
+  }
+
+  const depsByName = new Map<string, string[]>();
+  for (const [name, struct] of byName) {
+    depsByName.set(name, directStructDeps(struct, knownNames));
+  }
+
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const name of [...encodable]) {
+      const deps = depsByName.get(name) ?? [];
+      if (deps.some((dep) => !encodable.has(dep))) {
+        encodable.delete(name);
+        changed = true;
+      }
+    }
+  }
+
+  return encodable;
+}
+
+/**
+ * Computes the EIP-712 `encodeType` string for one struct in isolation:
+ *   `Name(type1 name1,type2 name2,...)`.
+ * Members whose type is `undefined` (e.g. mappings) are dropped.
+ */
+function encodeStructHead(struct: CollectedStruct): string {
+  const memberSegments: string[] = [];
+  for (const member of struct.members) {
+    if (member.type === undefined) {
+      continue;
+    }
+
+    memberSegments.push(`${member.type} ${member.name}`);
+  }
+
+  return `${struct.name}(${memberSegments.join(",")})`;
+}
+
+/**
+ * Returns the names of all struct dependencies referenced by `struct`'s
+ * members. Considers the base type of arrays. Members whose base type does not
+ * resolve to a known struct (elementary types, address, etc.) are ignored.
+ */
+function directStructDeps(
+  struct: CollectedStruct,
+  knownStructNames: Set<string>,
+): string[] {
+  const deps = new Set<string>();
+  for (const member of struct.members) {
+    if (member.type === undefined) {
+      continue;
+    }
+
+    // Strip array suffixes: `Foo[]`, `Foo[3]`, `Foo[3][2]` → `Foo`.
+    const base = member.type.split("[")[0];
+
+    if (knownStructNames.has(base) && base !== struct.name) {
+      deps.add(base);
+    }
+  }
+
+  return [...deps];
+}
+
+/**
+ * Walks the dep graph from `root` and returns the set of all transitively
+ * referenced struct names (excluding the root itself).
+ */
+function transitiveDeps(
+  root: CollectedStruct,
+  byName: Map<string, CollectedStruct>,
+): string[] {
+  const visited = new Set<string>();
+  const knownNames = new Set(byName.keys());
+  const stack = directStructDeps(root, knownNames);
+
+  while (stack.length > 0) {
+    const next = stack.pop();
+
+    if (next === undefined || visited.has(next) || next === root.name) {
+      continue;
+    }
+
+    visited.add(next);
+
+    const def = byName.get(next);
+
+    if (def !== undefined) {
+      stack.push(...directStructDeps(def, knownNames));
+    }
+  }
+
+  return [...visited];
+}
+
+/**
+ * Builds a name → definition map from collected structs, throwing
+ * `EIP712_DUPLICATE_STRUCT_NAME` when two structs share a name but have
+ * different member lists. Definitions with identical members are silently
+ * deduplicated (same struct seen across multiple build infos / partial
+ * recompiles).
+ *
+ * The comparison uses the full member list — including members whose type
+ * isn't EIP-712 encodable (mappings, function types) — so that two structs
+ * differing only in unsupported members are detected as conflicting rather
+ * than collapsed into one. Comparing only the encoded head would let a
+ * non decodable definition silently win over an encodable one, dropping the
+ * struct from the canonical output.
+ *
+ * Conflicts on a name reachable from any selected struct (selected roots plus
+ * their transitive deps) throw, since the selected struct's inlined dep head
+ * would otherwise depend on which conflicting copy happened to be seen first.
+ * Conflicts on names truly unreachable from the selected set are silently
+ * deduped (first wins). Selected structs are processed first so they win over
+ * non-selected copies.
+ */
+function indexByName(
+  structs: CollectedStruct[],
+  selectedNames: Set<string>,
+): Map<string, CollectedStruct> {
+  const byName = new Map<string, CollectedStruct>();
+  const fingerprintByName = new Map<string, string>();
+  const sourceByName = new Map<string, string>();
+  const deferredConflicts = new Map<
+    string,
+    { firstSource: string; secondSource: string }
+  >();
+
+  const ordered = [
+    ...structs.filter((s) => selectedNames.has(s.name)),
+    ...structs.filter((s) => !selectedNames.has(s.name)),
+  ];
+
+  for (const struct of ordered) {
+    const fingerprint = fingerprintStruct(struct);
+    const existingFingerprint = fingerprintByName.get(struct.name);
+
+    if (existingFingerprint === undefined) {
+      byName.set(struct.name, struct);
+      fingerprintByName.set(struct.name, fingerprint);
+      sourceByName.set(struct.name, struct.sourcePath);
+      continue;
+    }
+
+    if (existingFingerprint === fingerprint) {
+      continue;
+    }
+
+    if (!selectedNames.has(struct.name)) {
+      if (!deferredConflicts.has(struct.name)) {
+        deferredConflicts.set(struct.name, {
+          firstSource: sourceByName.get(struct.name) ?? "<unknown>",
+          secondSource: struct.sourcePath,
+        });
+      }
+      continue;
+    }
+
+    throw new HardhatError(
+      HardhatError.ERRORS.CORE.SOLIDITY_TESTS.EIP712_DUPLICATE_STRUCT_NAME,
+      {
+        name: struct.name,
+        firstSource: sourceByName.get(struct.name) ?? "<unknown>",
+        secondSource: struct.sourcePath,
+      },
+    );
+  }
+
+  if (deferredConflicts.size > 0) {
+    const reachable = reachableFromSelected(byName, selectedNames);
+    for (const [name, sources] of deferredConflicts) {
+      if (reachable.has(name)) {
+        throw new HardhatError(
+          HardhatError.ERRORS.CORE.SOLIDITY_TESTS.EIP712_DUPLICATE_STRUCT_NAME,
+          { name, ...sources },
+        );
+      }
+    }
+  }
+
+  return byName;
+}
+
+/**
+ * Set of struct names transitively referenced by any struct in `selectedNames`.
+ * The walk uses whatever first-wins definition is in `byName`; that's enough
+ * for conflict detection since we only need to know whether a name is
+ * reachable, not which conflicting copy is the "right" one.
+ */
+function reachableFromSelected(
+  byName: Map<string, CollectedStruct>,
+  selectedNames: Set<string>,
+): Set<string> {
+  const knownNames = new Set(byName.keys());
+  const reachable = new Set<string>();
+  const stack: string[] = [];
+
+  for (const name of selectedNames) {
+    const root = byName.get(name);
+    if (root !== undefined) {
+      stack.push(...directStructDeps(root, knownNames));
+    }
+  }
+
+  while (stack.length > 0) {
+    const next = stack.pop();
+    if (next === undefined || reachable.has(next)) {
+      continue;
+    }
+
+    reachable.add(next);
+
+    const def = byName.get(next);
+    if (def !== undefined) {
+      stack.push(...directStructDeps(def, knownNames));
+    }
+  }
+
+  return reachable;
+}
+
+/**
+ * A stable string capturing every member of `struct`, used to detect
+ * conflicting definitions of the same name. Unlike `encodeStructHead`, this
+ * preserves members whose type can't be EIP-712 encoded — they're emitted with
+ * an `<unsupported>` sentinel — so structs that differ only in mapping or
+ * function-type members aren't collapsed together.
+ */
+function fingerprintStruct(struct: CollectedStruct): string {
+  const segments = struct.members.map(
+    (m) => `${m.type ?? "<unsupported>"} ${m.name}`,
+  );
+
+  return `${struct.name}(${segments.join(",")})`;
+}