hardhat 3.4.5 → 3.5.0

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(",")})`;
+}

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

@@ -0,0 +1,225 @@
+// The same patterns are reused for every source file, so compile each one once.
+const compiledGlobCache = new Map<string, RegExp>();
+
+/**
+ * Returns true when `path` should be included given user-supplied include and
+ * exclude glob lists. `include` is the gate: an empty `include` matches
+ * nothing. `exclude` then narrows the included set.
+ */
+export function isPathSelected(
+  path: string,
+  include: string[],
+  exclude: string[],
+): boolean {
+  if (include.length === 0) {
+    return false;
+  }
+
+  if (!matchesAny(path, include)) {
+    return false;
+  }
+
+  if (exclude.length > 0 && matchesAny(path, exclude)) {
+    return false;
+  }
+
+  return true;
+}
+
+/**
+ * Returns true if `value` matches at least one of the given glob patterns.
+ */
+function matchesAny(value: string, patterns: string[]): boolean {
+  for (const pattern of patterns) {
+    if (getCompiledGlob(pattern).test(value)) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Compiles a glob pattern into a regular expression. Supports `*`, `**`,
+ * `?`, `[abc]` (including `[a-z]` ranges and `[!abc]` / `[^abc]` negation),
+ * and `{a,b,c}` alternation.
+ */
+function globToRegExp(pattern: string): RegExp {
+  return new RegExp(`^${translateGlob(pattern)}$`);
+}
+
+function translateGlob(pattern: string): string {
+  let regex = "";
+  let i = 0;
+  while (i < pattern.length) {
+    const c = pattern[i];
+
+    if (c === "*") {
+      if (pattern[i + 1] === "*") {
+        // `**` as a full path segment matches zero or more directories,
+        // e.g. `**/x.sol` matches both `x.sol` and `a/b/x.sol`.
+        const afterSlash = i === 0 || pattern[i - 1] === "/";
+        const beforeSlash = pattern[i + 2] === "/";
+        if (afterSlash && beforeSlash) {
+          regex += "(?:.*/)?";
+          i += 3;
+        } else {
+          regex += ".*";
+          i += 2;
+        }
+      } else {
+        regex += "[^/]*";
+        i += 1;
+      }
+    } else if (c === "?") {
+      regex += "[^/]";
+      i += 1;
+    } else if (c === "[") {
+      const end = findCharClassEnd(pattern, i);
+      if (end !== -1) {
+        regex += translateCharClass(pattern.slice(i + 1, end));
+        i = end + 1;
+        continue;
+      }
+
+      regex += "\\[";
+      i += 1;
+    } else if (c === "{") {
+      const end = findBraceEnd(pattern, i);
+      if (end !== -1) {
+        const alternatives = splitBraceAlternatives(
+          pattern.slice(i + 1, end),
+        ).map(translateGlob);
+
+        regex += `(?:${alternatives.join("|")})`;
+        i = end + 1;
+
+        continue;
+      }
+
+      regex += "\\{";
+      i += 1;
+    } else if (/[.+^$()|\\\]}]/.test(c)) {
+      regex += `\\${c}`;
+      i += 1;
+    } else {
+      regex += c;
+      i += 1;
+    }
+  }
+
+  return regex;
+}
+
+/**
+ * Returns the index of the `]` that closes the character class opened at
+ * `start`, or -1 if none is found. E.g. for `a[bc]d` starting at 1, returns 4.
+ */
+function findCharClassEnd(pattern: string, start: number): number {
+  for (let i = start + 1; i < pattern.length; i++) {
+    if (pattern[i] === "]") {
+      return i;
+    }
+  }
+
+  return -1;
+}
+
+/**
+ * Returns the index of the `}` that closes the brace group opened at `start`,
+ * handling nested groups and skipping character classes, or -1 if unterminated.
+ * E.g. `{a,{b,c}}` returns the outer `}`; `{a[}]b}` skips the bracketed `}`.
+ */
+function findBraceEnd(pattern: string, start: number): number {
+  let depth = 1;
+  let i = start + 1;
+  while (i < pattern.length) {
+    const c = pattern[i];
+    if (c === "{") {
+      depth += 1;
+    } else if (c === "}") {
+      depth -= 1;
+      if (depth === 0) {
+        return i;
+      }
+    } else if (c === "[") {
+      const end = findCharClassEnd(pattern, i);
+      if (end !== -1) {
+        i = end;
+      }
+    }
+
+    i += 1;
+  }
+
+  return -1;
+}
+
+/**
+ * Splits a brace group's body on top-level commas, leaving commas inside
+ * nested braces or character classes untouched. E.g. `a,{b,c},[d,e]` →
+ * `["a", "{b,c}", "[d,e]"]`.
+ */
+function splitBraceAlternatives(inside: string): string[] {
+  const result: string[] = [];
+  let depth = 0;
+  let start = 0;
+  let i = 0;
+  while (i < inside.length) {
+    const c = inside[i];
+
+    if (c === "{") {
+      depth += 1;
+    } else if (c === "}") {
+      depth -= 1;
+    } else if (c === "[") {
+      const end = findCharClassEnd(inside, i);
+      if (end !== -1) {
+        i = end;
+      }
+    } else if (c === "," && depth === 0) {
+      result.push(inside.slice(start, i));
+      start = i + 1;
+    }
+
+    i += 1;
+  }
+
+  result.push(inside.slice(start));
+  return result;
+}
+
+/**
+ * Translates a glob character class body into a regex character class.
+ * E.g. `Mm` → `[Mm]`, `!ab` → `[^ab]`, `a-z` → `[a-z]`.
+ */
+function translateCharClass(content: string): string {
+  let negated = false;
+  let body = content;
+  if (body.startsWith("!") || body.startsWith("^")) {
+    negated = true;
+    body = body.slice(1);
+  }
+
+  let escaped = "";
+  for (const ch of body) {
+    if (ch === "\\" || ch === "]") {
+      escaped += `\\${ch}`;
+    } else {
+      escaped += ch;
+    }
+  }
+
+  return `(?!/)[${negated ? "^" : ""}${escaped}]`;
+}
+
+function getCompiledGlob(pattern: string): RegExp {
+  let compiled = compiledGlobCache.get(pattern);
+
+  if (compiled === undefined) {
+    compiled = globToRegExp(pattern);
+    compiledGlobCache.set(pattern, compiled);
+  }
+
+  return compiled;
+}

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

@@ -0,0 +1,120 @@
+import type { CollectedStruct } from "./ast-walker.js";
+import type { SolidityBuildInfoOutput } from "../../../../types/solidity/solidity-artifacts.js";
+import type { BuildInfoAndOutput } from "../edr-artifacts.js";
+
+import {
+  bytesIncludesUtf8String,
+  bytesToUtf8String,
+} from "@nomicfoundation/hardhat-utils/bytes";
+
+import { HARDHAT_PROJECT_INPUT_SOURCE_NAME_ROOT } from "../../solidity/constants.js";
+
+import {
+  buildUserDefinedValueTypeIndex,
+  extractStructsFromAst,
+} from "./ast-walker.js";
+import { canonicalizeStructs } from "./canonicalize.js";
+import { isPathSelected } from "./glob.js";
+
+export interface Eip712TypesConfig {
+  include: string[];
+  exclude: string[];
+}
+
+// When a transitive project file doesn't produce an artifact — and so is
+// missing from `inputToUserSource` — stripping this prefix recovers the
+// user-facing path that the user's include/exclude globs are written against.
+const PROJECT_INPUT_SOURCE_NAME_PREFIX = `${HARDHAT_PROJECT_INPUT_SOURCE_NAME_ROOT}/`;
+
+/**
+ * Walks every compiled source's AST, extracts every struct definition, and
+ * returns the flat list of canonical EIP-712 type strings expected by EDR's
+ * `eip712CanonicalTypes` config field. Only structs from sources matching
+ * `include`/`exclude` are emitted; non-selected sources still feed the dep
+ * graph so cross-file deps inline correctly.
+ *
+ * `inputToUserSource` maps solc input source names to user source names; it's
+ * built by the caller from the artifact set so we don't pay to parse every
+ * build info just to recover that mapping.
+ *
+ * When `include` is empty/unset the feature is off: collection short-circuits
+ * and returns an empty list without parsing any build info.
+ */
+export function collectEip712CanonicalTypes(
+  buildInfosAndOutputs: BuildInfoAndOutput[],
+  inputToUserSource: ReadonlyMap<string, string>,
+  config: Eip712TypesConfig,
+): string[] {
+  const { include, exclude } = config;
+
+  if (include.length === 0) {
+    return [];
+  }
+
+  const collected: CollectedStruct[] = [];
+  const selectedNames = new Set<string>();
+
+  for (const { buildInfo, output } of buildInfosAndOutputs) {
+    // Byte-level fast path: a build info whose source bytes don't contain
+    // `struct ` can't define any EIP-712 type, so skip JSON-parsing its output.
+    if (!bytesIncludesUtf8String(buildInfo, "struct ")) {
+      continue;
+    }
+
+    const parsedOutput: SolidityBuildInfoOutput = JSON.parse(
+      bytesToUtf8String(output),
+    );
+
+    const sources = parsedOutput.output.sources;
+    if (sources === undefined) {
+      continue;
+    }
+
+    // Two constraints determine the index's scope:
+    //
+    // 1. Per build info, not pooled across them. solc assigns node ids
+    //    fresh in each compilation, so the same numeric id can mean
+    //    different user-defined value types in different builds. Pooling
+    //    would let one compilation's definition silently overwrite
+    //    another's at the same key, mis-resolving `referencedDeclaration`.
+    //    See the test "scopes user-defined value type resolution per build
+    //    info when node ids collide" for a repro.
+    //
+    // 2. Whole build info, not narrowed to a subset of sources. A struct
+    //    member's `referencedDeclaration` can point at a user-defined
+    //    value type defined in any source within the same compilation, so
+    //    the index must cover every source in the build.
+    const userDefinedValueTypeI = buildUserDefinedValueTypeIndex(
+      Object.values(sources).map((s) => s.ast),
+    );
+
+    for (const [inputSourceName, source] of Object.entries(sources)) {
+      let userSourceName = inputToUserSource.get(inputSourceName);
+
+      if (userSourceName === undefined) {
+        userSourceName = inputSourceName.startsWith(
+          PROJECT_INPUT_SOURCE_NAME_PREFIX,
+        )
+          ? inputSourceName.slice(PROJECT_INPUT_SOURCE_NAME_PREFIX.length)
+          : inputSourceName;
+      }
+
+      // Collect every source so non-selected files can serve as dep targets;
+      // selection is enforced at emit time via `selectedNames`.
+      const structs = extractStructsFromAst(
+        source.ast,
+        userSourceName,
+        userDefinedValueTypeI,
+      );
+      collected.push(...structs);
+
+      if (isPathSelected(userSourceName, include, exclude)) {
+        for (const s of structs) {
+          selectedNames.add(s.name);
+        }
+      }
+    }
+  }
+
+  return canonicalizeStructs(collected, selectedNames);
+}