hardhat 3.9.1 → 3.11.0

package/src/internal/builtin-plugins/node/utils/resolve-node-connection-params.ts

@@ -0,0 +1,79 @@
+import type { EdrNetworkConfigOverride } from "../../../../types/config.js";
+import type { ChainType } from "../../../../types/network.js";
+
+import { HardhatError } from "@nomicfoundation/hardhat-errors";
+
+import { isSupportedChainType } from "../../../edr/chain-type.js";
+
+export interface NodeConnectionArguments {
+  chainType?: string;
+  chainId: number;
+  fork?: string;
+  forkBlockNumber: number;
+}
+
+export interface ResolvedNodeConnectionParams {
+  network: string;
+  chainType?: ChainType;
+  override?: EdrNetworkConfigOverride;
+}
+
+/**
+ * Resolves the arguments passed to the `node` task into the connection
+ * parameters used to create the underlying network connection.
+ */
+export function resolveNodeConnectionParams(
+  network: string,
+  args: NodeConnectionArguments,
+): ResolvedNodeConnectionParams {
+  const connectionParams: ResolvedNodeConnectionParams = {
+    network,
+  };
+
+  // NOTE: We create an empty network config override here. We add to it based
+  // on the result of arguments parsing. We can expand the list of arguments
+  // as much as needed.
+  const networkConfigOverride: EdrNetworkConfigOverride = {};
+
+  if (args.chainType !== undefined) {
+    if (!isSupportedChainType(args.chainType)) {
+      throw new HardhatError(
+        HardhatError.ERRORS.CORE.ARGUMENTS.INVALID_VALUE_FOR_TYPE,
+        {
+          value: args.chainType,
+          type: "ChainType",
+          name: "chainType",
+        },
+      );
+    }
+
+    connectionParams.chainType = args.chainType;
+  }
+
+  if (args.chainId !== -1) {
+    networkConfigOverride.chainId = args.chainId;
+  }
+
+  // NOTE: --fork-block-number is only valid if --fork is specified
+  if (args.fork !== undefined) {
+    networkConfigOverride.forking = {
+      enabled: true,
+      url: args.fork,
+      ...(args.forkBlockNumber !== -1
+        ? { blockNumber: args.forkBlockNumber }
+        : undefined),
+    };
+  } else if (args.forkBlockNumber !== -1) {
+    // NOTE: We could make the error more specific here.
+    throw new HardhatError(
+      HardhatError.ERRORS.CORE.ARGUMENTS.MISSING_VALUE_FOR_ARGUMENT,
+      {
+        argument: "fork",
+      },
+    );
+  }
+
+  connectionParams.override = networkConfigOverride;
+
+  return connectionParams;
+}

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

@@ -1327,20 +1327,63 @@ export class SolidityBuildSystemImplementation implements SolidityBuildSystem {
     options?: CompileBuildInfoOptions,
   ): Promise<CompilerOutput> {
     const quiet = options?.quiet ?? false;
+    const compilerType = buildInfo.compilerType ?? "solc";
 
-    // Build info recompilation is always solc-only: build info files are
-    // produced by solc and must be recompiled with the same solc version.
-    // We bypass both downloadCompilers and getCompiler hooks — this is a
-    // self-contained solc replay path, not plugin-configurable compilation.
-    await downloadSolcCompilers(new Set([buildInfo.solcVersion]), quiet);
+    if (compilerType === "solc") {
+      // Build info recompilation for solc is self-contained: solc build info
+      // files must be replayed with the same solc version. We bypass both
+      // downloadCompilers and getCompiler hooks to preserve the historical solc
+      // path and avoid making it depend on the current project config.
+      await downloadSolcCompilers(new Set([buildInfo.solcVersion]), quiet);
 
-    const compiler = await getCompiler(buildInfo.solcVersion, {
-      preferWasm: false,
-    });
+      const solcCompiler = await getCompiler(buildInfo.solcVersion, {
+        preferWasm: false,
+      });
+
+      return await solcCompiler.compile(buildInfo.input);
+    }
+
+    const partialCompilerConfig =
+      this.#getPartialSolidityCompilerConfigFromBuildInfo(buildInfo);
+
+    await this.#hooks.runParallelHandlers("solidity", "downloadCompilers", [
+      [partialCompilerConfig],
+      quiet,
+    ]);
+
+    const compiler = await this.#hooks.runHandlerChain(
+      "solidity",
+      "getCompiler",
+      [partialCompilerConfig],
+      async () => {
+        throw new HardhatError(
+          HardhatError.ERRORS.CORE.SOLIDITY.BUILD_INFO_COMPILER_TYPE_NOT_HANDLED,
+          {
+            compilerType,
+            version: buildInfo.solcVersion,
+          },
+        );
+      },
+    );
 
     return await compiler.compile(buildInfo.input);
   }
 
+  #getPartialSolidityCompilerConfigFromBuildInfo(
+    buildInfo: SolidityBuildInfo,
+  ): SolidityCompilerConfig {
+    return {
+      /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions --
+      Build infos may come from setups whose compiler type is unknown to the
+      current Hardhat type definitions, but plugins can still handle them via
+      the compiler hooks. */
+      type: (buildInfo.compilerType ??
+        "solc") as SolidityCompilerConfig["type"],
+      version: buildInfo.solcVersion,
+      settings: buildInfo.input.settings,
+    };
+  }
+
   async #downloadConfiguredCompilers(quiet = false): Promise<void> {
     // We always print that we are downloading the compilers
     quiet = false;

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

@@ -32,6 +32,22 @@ import { DEFAULT_TEST_PROFILE } from "./test-profiles.js";
 export const DEFAULT_FUZZ_SEED =
   "0x7727ea51af0441c20da14dcd68a15dac8c9ebd589c5be8fa8c87c1d3720450bc";
 
+const nonnegativeSafeIntOrBigInt = unionType(
+  [z.number().int().nonnegative().safe(), z.bigint().nonnegative()],
+  "Expected a nonnegative safe int or a nonnegative bigint",
+);
+
+const nonnegativeSafeIntOrSafeBigInt = unionType(
+  [
+    z.number().int().nonnegative().safe(),
+    z
+      .bigint()
+      .nonnegative()
+      .refine((value) => value <= BigInt(Number.MAX_SAFE_INTEGER)),
+  ],
+  "Expected a nonnegative safe int or a nonnegative safe bigint",
+);
+
 const solidityTestProfileUserConfigType = z.object({
   fsPermissions: z
     .object({
@@ -54,6 +70,7 @@ const solidityTestProfileUserConfigType = z.object({
   blockTimestamp: z.bigint().optional(),
   prevRandao: z.bigint().optional(),
   gasLimit: z.bigint().optional(),
+  memoryLimit: nonnegativeSafeIntOrBigInt.optional(),
   blockGasLimit: z.number().or(z.bigint()).or(z.literal(false)).optional(),
   transactionGasCap: z.number().or(z.bigint()).or(z.literal(false)).optional(),
   fuzz: z
@@ -67,6 +84,7 @@ const solidityTestProfileUserConfigType = z.object({
       includeStorage: z.boolean().optional(),
       includePushBytes: z.boolean().optional(),
       showLogs: z.boolean().optional(),
+      timeout: nonnegativeSafeIntOrSafeBigInt.optional(),
     })
     .optional(),
   forking: z
@@ -92,6 +110,7 @@ const solidityTestProfileUserConfigType = z.object({
       includeStorage: z.boolean().optional(),
       includePushBytes: z.boolean().optional(),
       shrinkRunLimit: z.number().optional(),
+      timeout: nonnegativeSafeIntOrSafeBigInt.optional(),
     })
     .optional(),
   eip712Types: z
@@ -222,12 +241,22 @@ export async function resolveSolidityTestUserConfig(
     resolveConfigurationVariable,
   );
 
+  const {
+    memoryLimit,
+    fuzz,
+    invariant,
+    eip712Types,
+    ...otherProfileUserConfig
+  } = profileUserConfig ?? {};
+
   const resolvedDefaultProfile = {
     rpcCachePath: defaultRpcCachePath,
-    ...profileUserConfig,
-    fuzz: resolveFuzzConfig(profileUserConfig?.fuzz),
+    ...otherProfileUserConfig,
+    memoryLimit: memoryLimit !== undefined ? BigInt(memoryLimit) : undefined,
+    fuzz: resolveFuzzConfig(fuzz),
+    invariant: resolveInvariantConfig(invariant),
     forking: resolvedForking,
-    eip712Types: resolveEip712TypesConfig(profileUserConfig?.eip712Types),
+    eip712Types: resolveEip712TypesConfig(eip712Types),
   };
 
   return {
@@ -251,9 +280,27 @@ export async function resolveSolidityTestUserConfig(
 export function resolveFuzzConfig(
   fuzzUserConfig: SolidityTestProfileUserConfig["fuzz"] = {},
 ): SolidityTestProfileConfig["fuzz"] {
+  const { seed, timeout, ...otherFuzzUserConfig } = fuzzUserConfig;
+
+  return {
+    ...otherFuzzUserConfig,
+    seed: seed ?? DEFAULT_FUZZ_SEED,
+    ...(timeout !== undefined ? { timeout: Number(timeout) } : {}),
+  };
+}
+
+export function resolveInvariantConfig(
+  invariantUserConfig: SolidityTestProfileUserConfig["invariant"],
+): SolidityTestProfileConfig["invariant"] {
+  if (invariantUserConfig === undefined) {
+    return undefined;
+  }
+
+  const { timeout, ...otherInvariantUserConfig } = invariantUserConfig;
+
   return {
-    ...fuzzUserConfig,
-    seed: fuzzUserConfig.seed ?? DEFAULT_FUZZ_SEED,
+    ...otherInvariantUserConfig,
+    ...(timeout !== undefined ? { timeout: Number(timeout) } : {}),
   };
 }
 

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

@@ -2,6 +2,12 @@ import type { CollectedStruct } from "./ast-walker.js";
 
 import { HardhatError } from "@nomicfoundation/hardhat-errors";
 
+export const SELECTED_CONFLICT_REMEDIATION =
+  "Rename one of the structs, or scope your `test.solidity.eip712Types.include` / `exclude` globs in `hardhat.config.ts` so that only one of them is selected.";
+
+export const DEPENDENCY_CONFLICT_REMEDIATION =
+  "Rename one of the structs so the name has a single definition. The clashing name is pulled in as a dependency of a selected struct, so if you don't need that selected struct, deselecting it with your `test.solidity.eip712Types.include` / `exclude` globs in `hardhat.config.ts` also resolves the conflict.";
+
 /**
  * Produces the flat list of canonical EIP-712 type strings expected by EDR.
  *
@@ -25,14 +31,28 @@ import { HardhatError } from "@nomicfoundation/hardhat-errors";
  * 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.
+ * Selection is scoped by source, not by struct name: `selectedSources` holds
+ * the project-relative paths matched by the user's include/exclude globs. Only
+ * structs from those sources are emitted, but structs elsewhere still feed dep
+ * resolution so cross-file deps inline correctly. Scoping by source is what
+ * lets a non-selected file define a same-named struct without it being mistaken
+ * for selected.
  */
 export function canonicalizeStructs(
   structs: CollectedStruct[],
-  selectedNames: Set<string>,
+  selectedSources: Set<string>,
 ): string[] {
-  const byName = indexByName(structs, selectedNames);
+  // A name is "selected" if any of its definitions lives in a selected source.
+  // Drives what's emitted and, in `indexByName`, whether a selected definition
+  // exists to win a name collision.
+  const selectedNames = new Set<string>();
+  for (const struct of structs) {
+    if (selectedSources.has(struct.sourcePath)) {
+      selectedNames.add(struct.name);
+    }
+  }
+
+  const byName = indexByName(structs, selectedSources, selectedNames);
   const knownNames = new Set(byName.keys());
   const encodable = computeEncodable(byName, knownNames);
   const result: string[] = [];
@@ -189,15 +209,27 @@ function transitiveDeps(
  * 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.
+ * A name clash aborts the run only when it could change the output; otherwise
+ * the first definition wins silently. Selection is scoped by source
+ * (`selectedSources`), not by name, so a non-selected source whose struct name
+ * collides with a selected one stays non-selected. `selectedNames` is the
+ * derived set of names with at least one selected definition. Selected structs
+ * are processed first, so the already-stored definition in any collision is
+ * selected when one exists. Two rules resolve conflicts:
+ *
+ *   - Both sides selected: throw immediately — genuinely ambiguous which to
+ *     emit.
+ *   - Current side non-selected: defer; the stored definition keeps the name.
+ *     Throw only if the name is reachable from a selected struct (its
+ *     transitive deps), since then which copy got inlined would depend on
+ *     iteration order. Names unreachable from the selected set are silently
+ *     deduped (first wins), so a non-selected struct that merely shares a
+ *     name with a selected root or an unreferenced struct never aborts the
+ *     run.
  */
 function indexByName(
   structs: CollectedStruct[],
+  selectedSources: Set<string>,
   selectedNames: Set<string>,
 ): Map<string, CollectedStruct> {
   const byName = new Map<string, CollectedStruct>();
@@ -209,8 +241,8 @@ function indexByName(
   >();
 
   const ordered = [
-    ...structs.filter((s) => selectedNames.has(s.name)),
-    ...structs.filter((s) => !selectedNames.has(s.name)),
+    ...structs.filter((s) => selectedSources.has(s.sourcePath)),
+    ...structs.filter((s) => !selectedSources.has(s.sourcePath)),
   ];
 
   for (const struct of ordered) {
@@ -228,24 +260,31 @@ function indexByName(
       continue;
     }
 
-    if (!selectedNames.has(struct.name)) {
-      if (!deferredConflicts.has(struct.name)) {
-        deferredConflicts.set(struct.name, {
+    if (selectedSources.has(struct.sourcePath)) {
+      // Selected-vs-selected conflict: both this and the stored definition are
+      // selected (selected structs come first), so it's ambiguous which to emit.
+      throw new HardhatError(
+        HardhatError.ERRORS.CORE.SOLIDITY_TESTS.EIP712_DUPLICATE_STRUCT_NAME,
+        {
+          name: struct.name,
           firstSource: sourceByName.get(struct.name) ?? "<unknown>",
           secondSource: struct.sourcePath,
-        });
-      }
-      continue;
+          remediation: SELECTED_CONFLICT_REMEDIATION,
+        },
+      );
     }
 
-    throw new HardhatError(
-      HardhatError.ERRORS.CORE.SOLIDITY_TESTS.EIP712_DUPLICATE_STRUCT_NAME,
-      {
-        name: struct.name,
+    // Non-selected side, so the stored definition (selected if the name has
+    // one, since selected sources come first) keeps the name. Defer: throw
+    // later only if the name is reachable from a selected struct. Sharing a
+    // name with a selected root or an unreferenced struct is harmless and
+    // must not abort.
+    if (!deferredConflicts.has(struct.name)) {
+      deferredConflicts.set(struct.name, {
         firstSource: sourceByName.get(struct.name) ?? "<unknown>",
         secondSource: struct.sourcePath,
-      },
-    );
+      });
+    }
   }
 
   if (deferredConflicts.size > 0) {
@@ -254,7 +293,7 @@ function indexByName(
       if (reachable.has(name)) {
         throw new HardhatError(
           HardhatError.ERRORS.CORE.SOLIDITY_TESTS.EIP712_DUPLICATE_STRUCT_NAME,
-          { name, ...sources },
+          { name, ...sources, remediation: DEPENDENCY_CONFLICT_REMEDIATION },
         );
       }
     }

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

@@ -2,10 +2,12 @@ import type { CollectedStruct } from "./ast-walker.js";
 import type { SolidityBuildInfoOutput } from "../../../../types/solidity/solidity-artifacts.js";
 import type { BuildInfoAndOutput } from "../edr-artifacts.js";
 
+import { HardhatError } from "@nomicfoundation/hardhat-errors";
 import {
   bytesIncludesUtf8String,
-  bytesToUtf8String,
+  parseJsonBytes,
 } from "@nomicfoundation/hardhat-utils/bytes";
+import { ensureError } from "@nomicfoundation/hardhat-utils/error";
 
 import { isPathSelected } from "../../../utils/glob.js";
 import { toUserSourceName } from "../../solidity/source-names.js";
@@ -35,11 +37,11 @@ export interface Eip712TypesConfig {
  * 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(
+export async function collectEip712CanonicalTypes(
   buildInfosAndOutputs: BuildInfoAndOutput[],
   inputToUserSource: ReadonlyMap<string, string>,
   config: Eip712TypesConfig,
-): string[] {
+): Promise<string[]> {
   const { include, exclude } = config;
 
   if (include.length === 0) {
@@ -47,18 +49,26 @@ export function collectEip712CanonicalTypes(
   }
 
   const collected: CollectedStruct[] = [];
-  const selectedNames = new Set<string>();
+  const selectedSources = new Set<string>();
 
-  for (const { buildInfo, output } of buildInfosAndOutputs) {
+  for (const { buildInfoId, 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),
-    );
+    let parsedOutput: SolidityBuildInfoOutput;
+    try {
+      parsedOutput = await parseJsonBytes<SolidityBuildInfoOutput>(output);
+    } catch (error) {
+      ensureError(error);
+      throw new HardhatError(
+        HardhatError.ERRORS.CORE.SOLIDITY.BUILD_INFO_OUTPUT_PARSE_ERROR,
+        { buildInfoId },
+        error,
+      );
+    }
 
     const sources = parsedOutput.output.sources;
     if (sources === undefined) {
@@ -92,7 +102,9 @@ export function collectEip712CanonicalTypes(
         toUserSourceName(inputSourceName);
 
       // Collect every source so non-selected files can serve as dep targets;
-      // selection is enforced at emit time via `selectedNames`.
+      // `selectedSources` enforces selection at emit time. Tracked per source,
+      // not per struct name, so a non-selected source defining a same-named
+      // struct isn't treated as selected (see `canonicalizeStructs`).
       const structs = extractStructsFromAst(
         source.ast,
         userSourceName,
@@ -101,12 +113,10 @@ export function collectEip712CanonicalTypes(
       collected.push(...structs);
 
       if (isPathSelected(userSourceName, include, exclude)) {
-        for (const s of structs) {
-          selectedNames.add(s.name);
-        }
+        selectedSources.add(userSourceName);
       }
     }
   }
 
-  return canonicalizeStructs(collected, selectedNames);
+  return canonicalizeStructs(collected, selectedSources);
 }

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

@@ -25,6 +25,7 @@ import { hexStringToBytes } from "@nomicfoundation/hardhat-utils/hex";
 import { DEFAULT_VERBOSITY, OPTIMISM_CHAIN_TYPE } from "../../constants.js";
 import { resolveHardfork } from "../network-manager/config-resolution.js";
 import { hardhatHardforkToEdrSpecId } from "../network-manager/edr/utils/convert-to-edr.js";
+import { warnIfExperimentalHardfork } from "../network-manager/edr/utils/hardfork.js";
 import { verbosityToIncludeTraces } from "../network-manager/edr/utils/trace-formatters.js";
 
 import { formatArtifactId } from "./formatters.js";
@@ -88,8 +89,11 @@ export async function solidityTestConfigToSolidityTestRunnerConfigArgs({
   const txOrigin = hexToBytes(config.txOrigin);
   const blockCoinbase = hexToBytes(config.coinbase);
 
+  const resolvedHardforkName = resolveHardfork(hardfork, chainType);
+  warnIfExperimentalHardfork(resolvedHardforkName, chainType);
+
   const resolvedHardfork = hardhatHardforkToEdrSpecId(
-    resolveHardfork(hardfork, chainType),
+    resolvedHardforkName,
     chainType,
   );
 

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

@@ -10,7 +10,8 @@ import {
   HardhatError,
   assertHardhatInvariant,
 } from "@nomicfoundation/hardhat-errors";
-import { bytesToUtf8String } from "@nomicfoundation/hardhat-utils/bytes";
+import { parseJsonBytes } from "@nomicfoundation/hardhat-utils/bytes";
+import { ensureError } from "@nomicfoundation/hardhat-utils/error";
 
 import { getFullyQualifiedName } from "../../../../utils/contract-names.js";
 
@@ -48,11 +49,11 @@ interface CollectedOverrides {
  * in the solc AST. It only extracts them from the build info where each
  * test artifact's file was compiled as a root file.
  */
-export function getTestFunctionOverrides(
+export async function getTestFunctionOverrides(
   testSuiteArtifacts: EdrArtifactWithMetadata[],
   buildInfosAndOutputs: BuildInfoAndOutput[],
-): TestFunctionOverride[] {
-  const allRawOverrides = collectRawOverrides(
+): Promise<TestFunctionOverride[]> {
+  const allRawOverrides = await collectRawOverrides(
     testSuiteArtifacts,
     buildInfosAndOutputs,
   );
@@ -62,10 +63,10 @@ export function getTestFunctionOverrides(
   return buildTestFunctionOverrides(allRawOverrides);
 }
 
-function collectRawOverrides(
+async function collectRawOverrides(
   testSuiteArtifacts: EdrArtifactWithMetadata[],
   buildInfosAndOutputs: BuildInfoAndOutput[],
-): CollectedOverrides {
+): Promise<CollectedOverrides> {
   const overrides: RawInlineOverride[] = [];
   const methodIdentifiersByContract = new Map<string, Record<string, string>>();
 
@@ -153,9 +154,19 @@ function collectRawOverrides(
       continue;
     }
 
-    const buildInfoOutput: SolidityBuildInfoOutput = JSON.parse(
-      bytesToUtf8String(buildInfoAndOutput.output),
-    );
+    let buildInfoOutput: SolidityBuildInfoOutput;
+    try {
+      buildInfoOutput = await parseJsonBytes<SolidityBuildInfoOutput>(
+        buildInfoAndOutput.output,
+      );
+    } catch (error) {
+      ensureError(error);
+      throw new HardhatError(
+        HardhatError.ERRORS.CORE.SOLIDITY.BUILD_INFO_OUTPUT_PARSE_ERROR,
+        { buildInfoId },
+        error,
+      );
+    }
 
     for (const [
       inputSourceName,

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

@@ -231,12 +231,12 @@ const runSolidityTests: NewTaskActionFunction<TestActionArguments> = async (
     }
   }
 
-  const testFunctionOverrides = getTestFunctionOverrides(
+  const testFunctionOverrides = await getTestFunctionOverrides(
     testSuiteArtifacts,
     allBuildInfosAndOutputs,
   );
 
-  const eip712CanonicalTypes = collectEip712CanonicalTypes(
+  const eip712CanonicalTypes = await collectEip712CanonicalTypes(
     allBuildInfosAndOutputs,
     sourceNameToUserSourceName,
     eip712Types,

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

@@ -33,6 +33,7 @@ declare module "../../../types/test.js" {
     includeStorage?: boolean;
     includePushBytes?: boolean;
     shrinkRunLimit?: number;
+    timeout?: number | bigint;
   }
 
   export interface SolidityTestFuzzUserConfig {
@@ -45,6 +46,7 @@ declare module "../../../types/test.js" {
     includeStorage?: boolean;
     includePushBytes?: boolean;
     showLogs?: boolean;
+    timeout?: number | bigint;
   }
 
   export interface SolidityTestForkingUserConfig {
@@ -66,6 +68,7 @@ declare module "../../../types/test.js" {
     blockTimestamp?: bigint;
     prevRandao?: bigint;
     gasLimit?: bigint;
+    memoryLimit?: number | bigint;
     blockGasLimit?: number | bigint | false;
     transactionGasCap?: number | bigint | false;
     fuzz?: SolidityTestFuzzUserConfig;
@@ -108,6 +111,7 @@ declare module "../../../types/test.js" {
     includeStorage?: boolean;
     includePushBytes?: boolean;
     shrinkRunLimit?: number;
+    timeout?: number;
   }
 
   export interface SolidityTestFuzzConfig {
@@ -120,6 +124,7 @@ declare module "../../../types/test.js" {
     includeStorage?: boolean;
     includePushBytes?: boolean;
     showLogs?: boolean;
+    timeout?: number;
   }
 
   export interface SolidityTestForkingConfig {
@@ -142,6 +147,7 @@ declare module "../../../types/test.js" {
     blockTimestamp?: bigint;
     prevRandao?: bigint;
     gasLimit?: bigint;
+    memoryLimit?: bigint;
     blockGasLimit?: number | bigint | false;
     transactionGasCap?: number | bigint | false;
     fuzz: SolidityTestFuzzConfig;

package/templates/hardhat-3/01-node-test-runner-viem/package.json

@@ -5,7 +5,7 @@
   "description": "A TypeScript Hardhat project using Node Test Runner and Viem",
   "type": "module",
   "devDependencies": {
-    "hardhat": "workspace:^3.9.1",
+    "hardhat": "workspace:^3.11.0",
     "@nomicfoundation/hardhat-toolbox-viem": "workspace:^5.0.7",
     "@nomicfoundation/hardhat-ignition": "workspace:^3.1.8",
     "@types/node": "^22.8.5",

package/templates/hardhat-3/02-mocha-ethers/package.json

@@ -5,9 +5,9 @@
   "description": "A TypeScript Hardhat project using Mocha and Ethers.js",
   "type": "module",
   "devDependencies": {
-    "hardhat": "workspace:^3.9.1",
+    "hardhat": "workspace:^3.11.0",
     "@nomicfoundation/hardhat-toolbox-mocha-ethers": "workspace:^3.0.7",
-    "@nomicfoundation/hardhat-ethers": "workspace:^4.0.14",
+    "@nomicfoundation/hardhat-ethers": "workspace:^4.0.15",
     "@nomicfoundation/hardhat-ignition": "workspace:^3.1.8",
     "@types/chai": "^5.2.3",
     "@types/chai-as-promised": "^8.0.1",
@@ -20,7 +20,7 @@
     "typescript": "~6.0.3"
   },
   "peerDependencies": {
-    "@nomicfoundation/hardhat-ethers": "workspace:^4.0.14",
+    "@nomicfoundation/hardhat-ethers": "workspace:^4.0.15",
     "@nomicfoundation/hardhat-ethers-chai-matchers": "workspace:^3.0.11",
     "@nomicfoundation/hardhat-ignition": "workspace:^3.1.8",
     "@nomicfoundation/hardhat-ignition-ethers": "workspace:^3.1.6",

package/templates/hardhat-3/03-minimal/package.json

@@ -5,7 +5,7 @@
   "description": "A minimal Hardhat project",
   "type": "module",
   "devDependencies": {
-    "hardhat": "workspace:^3.9.1",
+    "hardhat": "workspace:^3.11.0",
     "@types/node": "^22.8.5",
     "typescript": "~6.0.3"
   }