hardhat 3.4.5 → 3.5.1

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

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

@@ -1,6 +1,6 @@
 import type { Abi } from "../../../types/artifacts.js";
 import type { ChainType } from "../../../types/network.js";
-import type { SolidityTestConfig } from "../../../types/test.js";
+import type { SolidityTestProfileConfig } from "../../../types/test.js";
 import type {
   SolidityTestRunnerConfigArgs,
   PathPermission,
@@ -19,6 +19,7 @@ import {
   opHardforkFromString,
   l1HardforkFromString,
 } from "@nomicfoundation/edr";
+import { toBigInt } from "@nomicfoundation/hardhat-utils/bigint";
 import { hexStringToBytes } from "@nomicfoundation/hardhat-utils/hex";
 
 import { DEFAULT_VERBOSITY, OPTIMISM_CHAIN_TYPE } from "../../constants.js";
@@ -32,12 +33,13 @@ interface SolidityTestConfigParams {
   chainType: ChainType;
   projectRoot: string;
   hardfork?: string;
-  config: SolidityTestConfig;
+  config: Omit<SolidityTestProfileConfig, "eip712Types">;
   verbosity: number;
   observability?: ObservabilityConfig;
   testPattern?: string;
   generateGasReport: boolean;
   testFunctionOverrides?: TestFunctionOverride[];
+  eip712CanonicalTypes?: string[];
 }
 
 export async function solidityTestConfigToSolidityTestRunnerConfigArgs({
@@ -50,6 +52,7 @@ export async function solidityTestConfigToSolidityTestRunnerConfigArgs({
   testPattern,
   generateGasReport,
   testFunctionOverrides,
+  eip712CanonicalTypes,
 }: SolidityTestConfigParams): Promise<SolidityTestRunnerConfigArgs> {
   const fsPermissions: PathPermission[] | undefined = [
     config.fsPermissions?.readWriteFile?.map((p) => ({
@@ -98,8 +101,18 @@ export async function solidityTestConfigToSolidityTestRunnerConfigArgs({
   const includeTraces = verbosityToIncludeTraces(verbosity);
 
   const blockGasLimit =
-    config.blockGasLimit === false ? undefined : config.blockGasLimit;
-  const disableBlockGasLimit = config.blockGasLimit === false;
+    typeof config.blockGasLimit === "number" ||
+    typeof config.blockGasLimit === "bigint"
+      ? toBigInt(config.blockGasLimit)
+      : undefined;
+  const disableBlockGasLimit = blockGasLimit === undefined;
+
+  const transactionGasCap =
+    typeof config.transactionGasCap === "number" ||
+    typeof config.transactionGasCap === "bigint"
+      ? toBigInt(config.transactionGasCap)
+      : undefined;
+  const disableTransactionGasCap = transactionGasCap === undefined;
 
   const blockDifficulty = config.prevRandao;
 
@@ -136,6 +149,8 @@ export async function solidityTestConfigToSolidityTestRunnerConfigArgs({
     includeTraces,
     blockGasLimit,
     disableBlockGasLimit,
+    transactionGasCap,
+    disableTransactionGasCap,
     blockDifficulty,
     ethRpcUrl,
     forkBlockNumber,
@@ -145,15 +160,24 @@ export async function solidityTestConfigToSolidityTestRunnerConfigArgs({
       ? CollectStackTraces.Always
       : CollectStackTraces.OnFailure,
     testFunctionOverrides,
+    eip712CanonicalTypes,
   };
 }
 
 export function isTestSuiteArtifact(artifact: Artifact): boolean {
+  const bytecode = artifact.contract.bytecode;
+
+  // Skip abstract contracts and interfaces i.e. those with no bytecode
+  if (bytecode === "" || bytecode === "0x" || bytecode === undefined) {
+    return false;
+  }
+
   const abi: Abi = JSON.parse(artifact.contract.abi);
   return abi.some(({ type, name }) => {
     if (type === "function" && typeof name === "string") {
       return name.startsWith("test") || name.startsWith("invariant");
     }
+
     return false;
   });
 }

package/src/internal/builtin-plugins/solidity-test/task-action.ts

@@ -35,6 +35,7 @@ import {
   buildEdrArtifactsWithMetadata,
   getBuildInfosAndOutputs,
 } from "./edr-artifacts.js";
+import { collectEip712CanonicalTypes } from "./eip712/index.js";
 import {
   isTestSuiteArtifact,
   warnDeprecatedTestFail,
@@ -43,6 +44,7 @@ import {
 import { getTestFunctionOverrides } from "./inline-config/index.js";
 import { testReporter } from "./reporter.js";
 import { run } from "./runner.js";
+import { DEFAULT_TEST_PROFILE } from "./test-profiles.js";
 
 interface TestActionArguments {
   testFiles: string[];
@@ -200,7 +202,9 @@ const runSolidityTests: NewTaskActionFunction<TestActionArguments> = async (
   let includesFailures = false;
   let includesErrors = false;
 
-  const solidityTestConfig = hre.config.test.solidity;
+  const { eip712Types, ...solidityTestConfig } =
+    hre.config.test.solidity.profiles[DEFAULT_TEST_PROFILE];
+
   let observabilityConfig: ObservabilityConfig | undefined;
   if (hre.globalOptions.coverage) {
     const coverage = getCoverageManager(hre);
@@ -232,6 +236,12 @@ const runSolidityTests: NewTaskActionFunction<TestActionArguments> = async (
     allBuildInfosAndOutputs,
   );
 
+  const eip712CanonicalTypes = collectEip712CanonicalTypes(
+    allBuildInfosAndOutputs,
+    sourceNameToUserSourceName,
+    eip712Types,
+  );
+
   const testRunnerConfig =
     await solidityTestConfigToSolidityTestRunnerConfigArgs({
       chainType,
@@ -245,6 +255,7 @@ const runSolidityTests: NewTaskActionFunction<TestActionArguments> = async (
         hre.globalOptions.gasStats ||
         hre.globalOptions.gasStatsJson !== undefined,
       testFunctionOverrides,
+      eip712CanonicalTypes,
     });
   const tracingConfig: TracingConfigWithBuffers = {
     buildInfos: allBuildInfosAndOutputs.map(({ buildInfo, output }) => ({

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

@@ -0,0 +1 @@
+export const DEFAULT_TEST_PROFILE = "default";

package/src/internal/builtin-plugins/solidity-test/type-extensions.ts

@@ -14,7 +14,28 @@ declare module "../../../types/config.js" {
 }
 
 declare module "../../../types/test.js" {
-  export interface SolidityTestFuzzConfigBase {
+  export interface SolidityTestFsPermissionsUserConfig {
+    readWriteFile?: string[];
+    readFile?: string[];
+    writeFile?: string[];
+    dangerouslyReadWriteDirectory?: string[];
+    readDirectory?: string[];
+    dangerouslyWriteDirectory?: string[];
+  }
+
+  export interface SolidityTestInvariantUserConfig {
+    failurePersistDir?: string;
+    runs?: number;
+    depth?: number;
+    failOnRevert?: boolean;
+    callOverride?: boolean;
+    dictionaryWeight?: number;
+    includeStorage?: boolean;
+    includePushBytes?: boolean;
+    shrinkRunLimit?: number;
+  }
+
+  export interface SolidityTestFuzzUserConfig {
     failurePersistDir?: string;
     failurePersistFile?: string;
     runs?: number;
@@ -26,19 +47,14 @@ declare module "../../../types/test.js" {
     showLogs?: boolean;
   }
 
-  export interface SolidityTestFuzzConfig extends SolidityTestFuzzConfigBase {
-    seed: string;
+  export interface SolidityTestForkingUserConfig {
+    url?: SensitiveString;
+    blockNumber?: number | bigint;
+    rpcEndpoints?: Record<string, SensitiveString>;
   }
 
-  export interface SolidityTestConfigBase {
-    fsPermissions?: {
-      readWriteFile?: string[];
-      readFile?: string[];
-      writeFile?: string[];
-      dangerouslyReadWriteDirectory?: string[];
-      readDirectory?: string[];
-      dangerouslyWriteDirectory?: string[];
-    };
+  export interface SolidityTestProfileUserConfig {
+    fsPermissions?: SolidityTestFsPermissionsUserConfig;
     isolate?: boolean;
     ffi?: boolean;
     allowInternalExpectRevert?: boolean;
@@ -50,46 +66,97 @@ declare module "../../../types/test.js" {
     blockTimestamp?: bigint;
     prevRandao?: bigint;
     gasLimit?: bigint;
-    blockGasLimit?: bigint | false;
-
-    fuzz?: SolidityTestFuzzConfigBase;
-    invariant?: {
-      failurePersistDir?: string;
-      runs?: number;
-      depth?: number;
-      failOnRevert?: boolean;
-      callOverride?: boolean;
-      dictionaryWeight?: number;
-      includeStorage?: boolean;
-      includePushBytes?: boolean;
-      shrinkRunLimit?: number;
+    blockGasLimit?: number | bigint | false;
+    transactionGasCap?: number | bigint | false;
+    fuzz?: SolidityTestFuzzUserConfig;
+    invariant?: SolidityTestInvariantUserConfig;
+    forking?: SolidityTestForkingUserConfig;
+    eip712Types?: {
+      include?: string[];
+      exclude?: string[];
     };
   }
 
-  export interface SolidityTestForkingUserConfig {
-    url?: SensitiveString;
-    blockNumber?: number | bigint;
-    rpcEndpoints?: Record<string, SensitiveString>;
+  export interface SolidityTestProfilesUserConfig {
+    profiles: Record<string, SolidityTestProfileUserConfig>;
   }
 
-  export interface SolidityTestUserConfig extends SolidityTestConfigBase {
-    forking?: SolidityTestForkingUserConfig;
-  }
+  export type SolidityTestUserConfig =
+    | SolidityTestProfileUserConfig
+    | SolidityTestProfilesUserConfig;
 
   export interface HardhatTestUserConfig {
     solidity?: SolidityTestUserConfig;
   }
 
+  export interface SolidityTestFsPermissionsConfig {
+    readWriteFile?: string[];
+    readFile?: string[];
+    writeFile?: string[];
+    dangerouslyReadWriteDirectory?: string[];
+    readDirectory?: string[];
+    dangerouslyWriteDirectory?: string[];
+  }
+
+  export interface SolidityTestInvariantConfig {
+    failurePersistDir?: string;
+    runs?: number;
+    depth?: number;
+    failOnRevert?: boolean;
+    callOverride?: boolean;
+    dictionaryWeight?: number;
+    includeStorage?: boolean;
+    includePushBytes?: boolean;
+    shrinkRunLimit?: number;
+  }
+
+  export interface SolidityTestFuzzConfig {
+    failurePersistDir?: string;
+    failurePersistFile?: string;
+    runs?: number;
+    maxTestRejects?: number;
+    seed: string;
+    dictionaryWeight?: number;
+    includeStorage?: boolean;
+    includePushBytes?: boolean;
+    showLogs?: boolean;
+  }
+
   export interface SolidityTestForkingConfig {
     url?: ResolvedConfigurationVariable;
     blockNumber?: bigint;
     rpcEndpoints?: Record<string, ResolvedConfigurationVariable>;
   }
 
-  export interface SolidityTestConfig extends SolidityTestConfigBase {
+  export interface SolidityTestProfileConfig {
+    rpcCachePath: string;
+    fsPermissions?: SolidityTestFsPermissionsConfig;
+    isolate?: boolean;
+    ffi?: boolean;
+    allowInternalExpectRevert?: boolean;
+    from?: string; // 0x-prefixed hex string
+    txOrigin?: string; // 0x-prefixed hex string
+    initialBalance?: bigint;
+    blockBaseFeePerGas?: bigint;
+    coinbase?: string; // 0x-prefixed hex string
+    blockTimestamp?: bigint;
+    prevRandao?: bigint;
+    gasLimit?: bigint;
+    blockGasLimit?: number | bigint | false;
+    transactionGasCap?: number | bigint | false;
     fuzz: SolidityTestFuzzConfig;
+    invariant?: SolidityTestInvariantConfig;
     forking?: SolidityTestForkingConfig;
+    eip712Types: {
+      include: string[];
+      exclude: string[];
+    };
   }
+
+  export interface SolidityTestConfig {
+    profiles: Record<string, SolidityTestProfileConfig>;
+  }
+
   export interface HardhatTestConfig {
     solidity: SolidityTestConfig;
   }