hardhat 3.4.4 → 3.5.0

package/src/internal/builtin-plugins/coverage/instrumentation.ts

@@ -20,8 +20,6 @@ import {
  * @param sourceName The source name of the file, as present in the compilation
  *  job.
  * @param fileContent The contents of the file.
- * @param coverageLibraryPath The path to the coverage library. i.e. where to
- *  import it from.
  * @returns An object with the instrumented source and its metadata, and the
  *  solidity version used to instrument the sources.
  */
@@ -29,12 +27,10 @@ export function instrumentSolidityFileForCompilationJob({
   compilationJobSolcVersion,
   sourceName,
   fileContent,
-  coverageLibraryPath,
 }: {
   compilationJobSolcVersion: string;
   sourceName: string;
   fileContent: string;
-  coverageLibraryPath: string;
 }): {
   source: string;
   metadata: InstrumentationMetadata[];
@@ -64,7 +60,6 @@ export function instrumentSolidityFileForCompilationJob({
     fileContent,
     sourceName,
     instrumentationVersion,
-    coverageLibraryPath,
   );
 
   return { source, metadata, instrumentationVersion };

package/src/internal/builtin-plugins/coverage/type-extensions.ts

@@ -1,4 +1,3 @@
-import "../../../types/global-options.js";
 declare module "../../../types/global-options.js" {
   export interface GlobalOptions {
     coverage: boolean;

package/src/internal/builtin-plugins/gas-analytics/index.ts

@@ -3,7 +3,7 @@ import type { HardhatPlugin } from "../../../types/plugins.js";
 import { ArgumentType } from "../../../types/arguments.js";
 import { globalFlag, globalOption, overrideTask } from "../../core/config.js";
 
-import "./type-extensions.js";
+export type * from "./type-extensions.js";
 
 const hardhatPlugin: HardhatPlugin = {
   id: "builtin:gas-analytics",

package/src/internal/builtin-plugins/gas-analytics/snapshot-cheatcodes.ts

@@ -13,6 +13,7 @@ import {
   remove,
   writeJsonFile,
 } from "@nomicfoundation/hardhat-utils/fs";
+import { sanitizeFilename } from "@nomicfoundation/hardhat-utils/path";
 
 import {
   getFullyQualifiedName,
@@ -23,6 +24,16 @@ import { formatSectionHeader, getUserFqn } from "./helpers/utils.js";
 
 export const SNAPSHOT_CHEATCODES_DIR = "snapshots";
 
+export interface RenamedSnapshotGroup {
+  original: string;
+  sanitized: string;
+}
+
+export interface SanitizedSnapshotCheatcodes {
+  snapshotCheatcodes: SnapshotCheatcodesWithMetadataMap;
+  renamedGroups: RenamedSnapshotGroup[];
+}
+
 export type SnapshotCheatcodesMap = Map<
   string, // group
   Record<
@@ -68,6 +79,7 @@ export interface SnapshotCheatcodesCheckResult {
   passed: boolean;
   comparison: SnapshotCheatcodesComparison;
   written: boolean;
+  renamedGroups: RenamedSnapshotGroup[];
 }
 
 export function getSnapshotCheatcodesPath(
@@ -77,6 +89,53 @@ export function getSnapshotCheatcodesPath(
   return path.join(basePath, SNAPSHOT_CHEATCODES_DIR, filename);
 }
 
+/**
+ * Rekeys {@link snapshotCheatcodes} so each group name is safe to use as a
+ * filename component, returning the rekeyed map alongside the list of names
+ * that were actually changed by sanitization.
+ *
+ * @throws `SOLIDITY_TESTS.SNAPSHOT_GROUP_NAME_COLLISION` if two distinct
+ * original names sanitize to the same on-disk filename. Originals are
+ * sorted by codepoint in the error message so the same input always
+ * produces the same error text.
+ */
+export function sanitizeSnapshotCheatcodes(
+  snapshotCheatcodes: SnapshotCheatcodesWithMetadataMap,
+): SanitizedSnapshotCheatcodes {
+  const sanitizedSnapshotCheatcodes: SnapshotCheatcodesWithMetadataMap =
+    new Map();
+  const originalBySanitized = new Map<string, string>();
+  const renamedGroups: RenamedSnapshotGroup[] = [];
+
+  for (const [original, entries] of snapshotCheatcodes) {
+    const sanitizedName = sanitizeFilename(original);
+
+    const previousOriginal = originalBySanitized.get(sanitizedName);
+    if (previousOriginal !== undefined) {
+      const [nameA, nameB] =
+        previousOriginal < original
+          ? [previousOriginal, original]
+          : [original, previousOriginal];
+      throw new HardhatError(
+        HardhatError.ERRORS.CORE.SOLIDITY_TESTS.SNAPSHOT_GROUP_NAME_COLLISION,
+        { nameA, nameB, sanitized: sanitizedName },
+      );
+    }
+
+    originalBySanitized.set(sanitizedName, original);
+    sanitizedSnapshotCheatcodes.set(sanitizedName, entries);
+
+    if (sanitizedName !== original) {
+      renamedGroups.push({ original, sanitized: sanitizedName });
+    }
+  }
+
+  return {
+    snapshotCheatcodes: sanitizedSnapshotCheatcodes,
+    renamedGroups,
+  };
+}
+
 export function extractSnapshotCheatcodes(
   suiteResults: SuiteResult[],
 ): SnapshotCheatcodesWithMetadataMap {
@@ -295,7 +354,9 @@ export async function checkSnapshotCheatcodes(
   basePath: string,
   suiteResults: SuiteResult[],
 ): Promise<SnapshotCheatcodesCheckResult> {
-  const snapshotCheatcodes = extractSnapshotCheatcodes(suiteResults);
+  const { snapshotCheatcodes, renamedGroups } = sanitizeSnapshotCheatcodes(
+    extractSnapshotCheatcodes(suiteResults),
+  );
 
   let previousSnapshotCheatcodes;
   try {
@@ -316,6 +377,7 @@ export async function checkSnapshotCheatcodes(
           changed: [],
         },
         written,
+        renamedGroups,
       };
     }
 
@@ -338,6 +400,7 @@ export async function checkSnapshotCheatcodes(
     passed: comparison.changed.length === 0,
     comparison,
     written: hasAddedOrRemoved,
+    renamedGroups,
   };
 }
 
@@ -448,3 +511,29 @@ export function printSnapshotCheatcodeChanges(
     }
   }
 }
+
+export function logSnapshotRenameWarnings(
+  renamedGroups: RenamedSnapshotGroup[],
+  logger: typeof console.log = console.log,
+): void {
+  if (renamedGroups.length === 0) {
+    return;
+  }
+
+  logger(
+    styleText(
+      "yellow",
+      `Renamed ${renamedGroups.length} snapshot group name(s) for safe filesystem use:`,
+    ),
+  );
+  for (const { original, sanitized } of renamedGroups) {
+    logger(styleText("yellow", `  "${original}" → "${sanitized}"`));
+  }
+  logger(
+    styleText(
+      "yellow",
+      "If you'd like the on-disk filename(s) to match exactly, consider renaming the group(s) in Solidity.",
+    ),
+  );
+  logger();
+}

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

@@ -2,7 +2,10 @@ import type { TaskOverrideActionFunction } from "../../../../../types/tasks.js";
 import type { Result } from "../../../../../types/utils.js";
 import type { SolidityTestRunResult } from "../../../solidity-test/task-action.js";
 import type { FunctionGasSnapshotCheckResult } from "../../function-gas-snapshots.js";
-import type { SnapshotCheatcodesCheckResult } from "../../snapshot-cheatcodes.js";
+import type {
+  SnapshotCheatcodesCheckResult,
+  RenamedSnapshotGroup,
+} from "../../snapshot-cheatcodes.js";
 import type { SuiteResult } from "@nomicfoundation/edr";
 
 import { styleText } from "node:util";
@@ -20,6 +23,8 @@ import {
   checkSnapshotCheatcodes,
   extractSnapshotCheatcodes,
   logSnapshotCheatcodesSection,
+  logSnapshotRenameWarnings,
+  sanitizeSnapshotCheatcodes,
   writeSnapshotCheatcodes,
 } from "../../snapshot-cheatcodes.js";
 
@@ -30,6 +35,7 @@ interface GasAnalyticsTestActionArguments {
 
 export interface SnapshotResult {
   functionGasSnapshotsWritten: boolean;
+  renamedGroups: RenamedSnapshotGroup[];
 }
 
 export interface SnapshotCheckResult {
@@ -91,11 +97,14 @@ export async function handleSnapshot(
     await writeFunctionGasSnapshots(basePath, functionGasSnapshots);
   }
 
-  const snapshotCheatcodes = extractSnapshotCheatcodes(suiteResults);
+  const { snapshotCheatcodes, renamedGroups } = sanitizeSnapshotCheatcodes(
+    extractSnapshotCheatcodes(suiteResults),
+  );
   await writeSnapshotCheatcodes(basePath, snapshotCheatcodes);
 
   return {
     functionGasSnapshotsWritten: testsPassed,
+    renamedGroups,
   };
 }
 
@@ -107,6 +116,7 @@ export function logSnapshotResult(
     logger(styleText("green", "Function gas snapshots written successfully"));
     logger();
   }
+  logSnapshotRenameWarnings(result.renamedGroups, logger);
 }
 
 export async function handleSnapshotCheck(
@@ -164,6 +174,18 @@ export function logSnapshotCheckResult(
 
   logSnapshotCheatcodesSection(snapshotCheatcodesCheck, logger);
 
+  // Add an extra newline if only the rename warnings have output
+  // (logSnapshotCheatcodesSection adds one if it has output)
+  if (
+    !functionGasHasOutput &&
+    !snapshotCheatcodesHasOutput &&
+    snapshotCheatcodesCheck.renamedGroups.length > 0
+  ) {
+    logger();
+  }
+
+  logSnapshotRenameWarnings(snapshotCheatcodesCheck.renamedGroups, logger);
+
   if (!functionGasSnapshotsCheck.passed || !snapshotCheatcodesCheck.passed) {
     logger(
       styleText(

package/src/internal/builtin-plugins/gas-analytics/type-extensions.ts

@@ -1,4 +1,3 @@
-import "../../../types/global-options.js";
 declare module "../../../types/global-options.js" {
   export interface GlobalOptions {
     gasStats: boolean;

package/src/internal/builtin-plugins/index.ts

@@ -14,21 +14,21 @@ import solidityTest from "./solidity-test/index.js";
 import telemetry from "./telemetry/index.js";
 import test from "./test/index.js";
 
-// Note: When importing a plugin, you have to export its types, so that its
-// type extensions, if any, also get loaded.
+// NOTE: We export the built-in plugin types to have a centralized way to
+// re-export them and force their type extensions to be loaded.
 export type * from "./artifacts/index.js";
-export type * from "./solidity/index.js";
-export type * from "./test/index.js";
-export type * from "./solidity-test/index.js";
-export type * from "./gas-analytics/index.js";
-export type * from "./network-manager/index.js";
 export type * from "./clean/index.js";
 export type * from "./console/index.js";
-export type * from "./run/index.js";
-export type * from "./node/index.js";
-export type * from "./flatten/index.js";
 export type * from "./coverage/index.js";
+export type * from "./flatten/index.js";
+export type * from "./gas-analytics/index.js";
+export type * from "./network-manager/index.js";
+export type * from "./node/index.js";
+export type * from "./run/index.js";
+export type * from "./solidity/index.js";
+export type * from "./solidity-test/index.js";
 export type * from "./telemetry/index.js";
+export type * from "./test/index.js";
 
 // This array should be kept in order, respecting the dependencies between the
 // plugins.

package/src/internal/builtin-plugins/network-manager/config-resolution.ts

@@ -83,9 +83,12 @@ export function resolveEdrNetwork(
 
     allowBlocksWithSameTimestamp:
       networkConfig.allowBlocksWithSameTimestamp ?? false,
-    allowUnlimitedContractSize:
-      networkConfig.allowUnlimitedContractSize ?? false,
-    blockGasLimit: BigInt(networkConfig.blockGasLimit ?? 60_000_000n),
+    allowUnlimitedContractSize: networkConfig.allowUnlimitedContractSize,
+    blockGasLimit:
+      typeof networkConfig.blockGasLimit === "number" ||
+      typeof networkConfig.blockGasLimit === "bigint"
+        ? toBigInt(networkConfig.blockGasLimit)
+        : networkConfig.blockGasLimit,
     coinbase: resolveCoinbase(networkConfig.coinbase),
 
     forking: resolveForkingConfig(
@@ -108,6 +111,11 @@ export function resolveEdrNetwork(
     throwOnCallFailures: networkConfig.throwOnCallFailures ?? true,
     throwOnTransactionFailures:
       networkConfig.throwOnTransactionFailures ?? true,
+    transactionGasCap:
+      typeof networkConfig.transactionGasCap === "number" ||
+      typeof networkConfig.transactionGasCap === "bigint"
+        ? toBigInt(networkConfig.transactionGasCap)
+        : networkConfig.transactionGasCap,
   };
 }
 

package/src/internal/builtin-plugins/network-manager/edr/edr-constants.ts

@@ -8,6 +8,8 @@ import { DEFAULT_HD_ACCOUNTS_CONFIG_PARAMS } from "../accounts/constants.js";
 export const EDR_NETWORK_DEFAULT_COINBASE =
   "0xc014ba5ec014ba5ec014ba5ec014ba5ec014ba5e";
 
+export const DEFAULT_EDR_NETWORK_BLOCK_GAS_LIMIT = 60_000_000n;
+
 interface EdrNetworkDefaultHDAccountsConfigParams
   extends DefaultHDAccountsConfigParams {
   mnemonic: string;

package/src/internal/builtin-plugins/network-manager/edr/edr-provider.ts

@@ -45,6 +45,7 @@ import {
   UnknownError,
 } from "../provider-errors.js";
 
+import { DEFAULT_EDR_NETWORK_BLOCK_GAS_LIMIT } from "./edr-constants.js";
 import { getGenesisStateAndOwnedAccounts } from "./genesis-state.js";
 import { EdrProviderStackTraceGenerationError } from "./stack-traces/stack-trace-generation-errors.js";
 import { createSolidityErrorWithStackTrace } from "./stack-traces/stack-trace-solidity-errors.js";
@@ -56,6 +57,7 @@ import {
   hardhatMempoolOrderToEdrMineOrdering,
   hardhatHardforkToEdrSpecId,
   hardhatForkingConfigToEdrForkConfig,
+  resolveDefaultTransactionGasLimit,
 } from "./utils/convert-to-edr.js";
 import { printLine, replaceLastLine } from "./utils/logger.js";
 
@@ -457,6 +459,15 @@ export async function getProviderConfig(
     networkConfig.chainType,
   );
 
+  const genesisBlockGasLimit =
+    typeof networkConfig.blockGasLimit === "bigint"
+      ? networkConfig.blockGasLimit
+      : DEFAULT_EDR_NETWORK_BLOCK_GAS_LIMIT;
+
+  // EDR's mining block gas limit can be disabled in user config explicitly
+  const miningBlockGasLimit =
+    networkConfig.blockGasLimit === false ? undefined : genesisBlockGasLimit;
+
   const { genesisState, ownedAccounts } = await getGenesisStateAndOwnedAccounts(
     networkConfig.accounts,
     networkConfig.forking,
@@ -464,26 +475,43 @@ export async function getProviderConfig(
     specId,
   );
 
+  const forkConfig = await hardhatForkingConfigToEdrForkConfig(
+    networkConfig.forking,
+    chainDescriptors,
+    networkConfig.chainType,
+  );
+
+  const network =
+    forkConfig !== undefined
+      ? forkConfig
+      : {
+          genesisBlockGasLimit,
+          genesisBlockTime: BigInt(toSeconds(networkConfig.initialDate)),
+        };
+
+  const defaultTransactionGasLimit = resolveDefaultTransactionGasLimit({
+    chainType: networkConfig.chainType,
+    hardfork: networkConfig.hardfork,
+    blockGasLimit: genesisBlockGasLimit,
+    transactionGasCap: networkConfig.transactionGasCap,
+  });
+
   return {
     allowBlocksWithSameTimestamp: networkConfig.allowBlocksWithSameTimestamp,
-    allowUnlimitedContractSize: networkConfig.allowUnlimitedContractSize,
+    allowUnlimitedContractSize:
+      networkConfig.allowUnlimitedContractSize ?? false,
     bailOnCallFailure: networkConfig.throwOnCallFailures,
     bailOnTransactionFailure: networkConfig.throwOnTransactionFailures,
-    blockGasLimit: networkConfig.blockGasLimit,
     chainId: BigInt(networkConfig.chainId),
     coinbase: networkConfig.coinbase,
-    fork: await hardhatForkingConfigToEdrForkConfig(
-      networkConfig.forking,
-      chainDescriptors,
-      networkConfig.chainType,
-    ),
+    defaultTransactionGasLimit,
     genesisState: Array.from(genesisState.values()),
     hardfork: specId,
     initialBaseFeePerGas: networkConfig.initialBaseFeePerGas,
-    initialDate: BigInt(toSeconds(networkConfig.initialDate)),
     minGasPrice: networkConfig.minGasPrice,
     mining: {
       autoMine: networkConfig.mining.auto,
+      blockGasLimit: miningBlockGasLimit,
       interval: hardhatMiningIntervalToEdrMiningInterval(
         networkConfig.mining.interval,
       ),
@@ -493,6 +521,7 @@ export async function getProviderConfig(
         ),
       },
     },
+    network,
     networkId: BigInt(networkConfig.networkId),
     observability: {
       codeCoverage: coverageConfig,
@@ -501,5 +530,6 @@ export async function getProviderConfig(
     },
     ownedAccounts: ownedAccounts.map((account) => account.secretKey),
     precompileOverrides: [],
+    transactionGasCap: networkConfig.transactionGasCap,
   };
 }

package/src/internal/builtin-plugins/network-manager/edr/stack-traces/stack-trace-solidity-errors.ts

@@ -29,24 +29,23 @@ export function createSolidityErrorWithStackTrace(
 ): SolidityError {
   const originalPrepareStackTrace = Error.prepareStackTrace;
 
+  assertHardhatInvariant(
+    originalPrepareStackTrace !== undefined,
+    "Error.prepareStackTrace should be defined",
+  );
+
   try {
     Error.prepareStackTrace = (error, stack) => {
       // Skip error management related stack traces
-      const adjustedStack = stack.slice(1);
+      const [, ...adjustedStack] = stack;
 
+      const prefix = [];
       for (const entry of stackTrace) {
         const callsite = encodeStackTraceEntry(entry);
-        if (callsite !== undefined) {
-          adjustedStack.unshift(callsite);
-        }
+        if (callsite !== undefined) prefix.push(callsite);
       }
-
-      assertHardhatInvariant(
-        originalPrepareStackTrace !== undefined,
-        "Error.prepareStackTrace should be defined",
-      );
-
-      return originalPrepareStackTrace(error, adjustedStack);
+      prefix.reverse();
+      return originalPrepareStackTrace(error, [...prefix, ...adjustedStack]);
     };
 
     const message =

package/src/internal/builtin-plugins/network-manager/edr/utils/convert-to-edr.ts

@@ -62,7 +62,11 @@ import {
   EDR_NETWORK_DEFAULT_PRIVATE_KEYS,
   isDefaultEdrNetworkHDAccountsConfig,
 } from "../edr-constants.js";
-import { L1HardforkName, OpHardforkName } from "../types/hardfork.js";
+import {
+  hardforkGte,
+  L1HardforkName,
+  OpHardforkName,
+} from "../types/hardfork.js";
 
 import { getL1HardforkName, getOpHardforkName } from "./hardfork.js";
 
@@ -382,6 +386,44 @@ export async function hardhatForkingConfigToEdrForkConfig(
   return fork;
 }
 
+/**
+ * Resolves the default transaction gas limit used by RPC call and
+ * transaction requests that omit a `gas` field.
+ *
+ * When `transactionGasCap` is a bigint, that value wins. When it is
+ * `false`, the per-transaction cap is disabled and the block gas limit is
+ * used. When it is undefined, the hardfork-specific default applies:
+ * from L1's Osaka hardfork onwards, the EIP-7825 transaction gas cap of
+ * 16,777,216; otherwise the block gas limit.
+ */
+export function resolveDefaultTransactionGasLimit(params: {
+  chainType: ChainType;
+  hardfork: string;
+  blockGasLimit: bigint;
+  transactionGasCap: bigint | false | undefined;
+}): bigint {
+  const { chainType, hardfork, blockGasLimit, transactionGasCap } = params;
+
+  if (typeof transactionGasCap === "bigint") {
+    return transactionGasCap;
+  }
+
+  if (transactionGasCap === false) {
+    return blockGasLimit;
+  }
+
+  // TODO: OP UPGRADE 19 - update OP to also set a default transaction gas once enabled
+  if (chainType === OPTIMISM_CHAIN_TYPE) {
+    return blockGasLimit;
+  }
+
+  if (hardforkGte(hardfork, L1HardforkName.OSAKA, chainType)) {
+    return 16_777_216n; // EIP-7825 transaction gas cap
+  }
+
+  return blockGasLimit;
+}
+
 /**
  * Converts EDR's nested GasReport structure into a flat array of gas entries.
  * Filters out reverted transactions.

package/src/internal/builtin-plugins/network-manager/index.ts

@@ -3,10 +3,10 @@ import type { HardhatPlugin } from "../../../types/plugins.js";
 import { ArgumentType } from "../../../types/arguments.js";
 import { globalOption } from "../../core/config.js";
 
-import "./type-extensions/config.js";
-import "./type-extensions/global-options.js";
-import "./type-extensions/hooks.js";
-import "./type-extensions/hre.js";
+export type * from "./type-extensions/config.js";
+export type * from "./type-extensions/global-options.js";
+export type * from "./type-extensions/hooks.js";
+export type * from "./type-extensions/hre.js";
 
 const hardhatPlugin: HardhatPlugin = {
   id: "builtin:network-manager",

package/src/internal/builtin-plugins/network-manager/network-manager.ts

@@ -42,6 +42,7 @@ import { edrGasReportToHardhatGasMeasurements } from "./edr/utils/convert-to-edr
 import { verbosityToIncludeTraces } from "./edr/utils/trace-formatters.js";
 import { HttpProvider } from "./http-provider.js";
 import { NetworkConnectionImplementation } from "./network-connection.js";
+import { applyCoverageNetworkOverrides } from "./utils/apply-coverage-network-overrides.js";
 
 export type JsonRpcRequestWrapperFunction = (
   request: JsonRpcRequest,
@@ -360,12 +361,10 @@ export class NetworkManagerImplementation implements NetworkManager {
           // The resolvedNetworkConfig can have its chainType set to `undefined`
           // so we default to the default chain type here.
           networkConfig: {
-            ...resolvedNetworkConfig,
-            // When coverage is enabled, we set allowUnlimitedContractSize to true
-            // because the added coverage data can push the contract size over the limit.
-            allowUnlimitedContractSize: shouldEnableCoverage
-              ? true
-              : resolvedNetworkConfig.allowUnlimitedContractSize,
+            ...applyCoverageNetworkOverrides(
+              resolvedNetworkConfig,
+              shouldEnableCoverage,
+            ),
             chainType: resolvedChainType,
           },
           jsonRpcRequestWrapper,

package/src/internal/builtin-plugins/network-manager/type-extensions/config.ts

@@ -1,6 +1,5 @@
 import type { ChainType, DefaultChainType } from "../../../../types/network.js";
 
-import "../../../../types/config.js";
 declare module "../../../../types/config.js" {
   export interface HardhatUserConfig {
     chainDescriptors?: ChainDescriptorsUserConfig;
@@ -112,7 +111,7 @@ declare module "../../../../types/config.js" {
     // EDR network specific
     allowBlocksWithSameTimestamp?: boolean;
     allowUnlimitedContractSize?: boolean;
-    blockGasLimit?: number | bigint;
+    blockGasLimit?: number | bigint | false;
     coinbase?: string;
     forking?: EdrNetworkForkingUserConfig;
     hardfork?: string;
@@ -124,6 +123,7 @@ declare module "../../../../types/config.js" {
     networkId?: number;
     throwOnCallFailures?: boolean;
     throwOnTransactionFailures?: boolean;
+    transactionGasCap?: number | bigint | false;
   }
 
   export type EdrNetworkAccountsUserConfig =
@@ -256,8 +256,8 @@ declare module "../../../../types/config.js" {
 
     // EDR network specific
     allowBlocksWithSameTimestamp: boolean;
-    allowUnlimitedContractSize: boolean;
-    blockGasLimit: bigint;
+    allowUnlimitedContractSize?: boolean;
+    blockGasLimit?: bigint | false;
     coinbase: Uint8Array;
     forking?: EdrNetworkForkingConfig;
     hardfork: string;
@@ -269,6 +269,7 @@ declare module "../../../../types/config.js" {
     networkId: number;
     throwOnCallFailures: boolean;
     throwOnTransactionFailures: boolean;
+    transactionGasCap?: bigint | false;
   }
 
   export type EdrNetworkAccountsConfig =

package/src/internal/builtin-plugins/network-manager/type-extensions/global-options.ts

@@ -1,4 +1,3 @@
-import "../../../../types/global-options.js";
 declare module "../../../../types/global-options.js" {
   export interface GlobalOptions {
     network: string;

package/src/internal/builtin-plugins/network-manager/type-extensions/hooks.ts

@@ -9,7 +9,6 @@ import type {
 import type { CoverageData } from "../../coverage/types.js";
 import type { GasMeasurement } from "../../gas-analytics/types.js";
 
-import "../../../../types/hooks.js";
 declare module "../../../../types/hooks.js" {
   export interface HardhatHooks {
     network: NetworkHooks;

package/src/internal/builtin-plugins/network-manager/type-extensions/hre.ts

@@ -1,6 +1,5 @@
 import type { NetworkManager } from "../../../../types/network.js";
 
-import "../../../../types/hre.js";
 declare module "../../../../types/hre.js" {
   export interface HardhatRuntimeEnvironment {
     network: NetworkManager;

package/src/internal/builtin-plugins/network-manager/type-validation.ts

@@ -220,6 +220,11 @@ const gasUnitUserConfigSchema = unionType(
   "Expected a positive safe int or a positive bigint",
 );
 
+const gasLimitWithDisableUserConfigSchema = unionType(
+  [gasUnitUserConfigSchema, z.literal(false)],
+  "Expected `false`, a positive safe int, or a positive bigint",
+);
+
 const gasUserConfigSchema = unionType(
   [z.literal("auto"), gasUnitUserConfigSchema],
   "Expected 'auto', a positive safe int, or positive bigint",
@@ -311,7 +316,7 @@ const edrNetworkUserConfigSchema = z.object({
   // EDR network specific
   allowBlocksWithSameTimestamp: z.optional(z.boolean()),
   allowUnlimitedContractSize: z.optional(z.boolean()),
-  blockGasLimit: z.optional(gasUnitUserConfigSchema),
+  blockGasLimit: z.optional(gasLimitWithDisableUserConfigSchema),
   coinbase: z.optional(z.string()),
   forking: z.optional(edrNetworkForkingUserConfigSchema),
   hardfork: z.optional(z.string()),
@@ -325,6 +330,7 @@ const edrNetworkUserConfigSchema = z.object({
   networkId: z.optional(chainIdSchema),
   throwOnCallFailures: z.optional(z.boolean()),
   throwOnTransactionFailures: z.optional(z.boolean()),
+  transactionGasCap: z.optional(gasLimitWithDisableUserConfigSchema),
 });
 
 const networkUserConfigSchema = z.discriminatedUnion("type", [