hardhat 3.4.5 → 3.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hardhat",
-  "version": "3.4.5",
+  "version": "3.5.0",
   "description": "Hardhat is an extensible developer tool that helps smart contract developers increase productivity by reliably bringing together the tools they want.",
   "homepage": "https://hardhat.org",
   "repository": {
@@ -44,7 +44,8 @@
     "./utils/result": "./dist/src/utils/result.js",
     "./types/runtime": "./dist/src/internal/deprecated-module-imported-from-hardhat2-plugin.js",
     "./builtin-tasks/task-names": "./dist/src/internal/deprecated-module-imported-from-hardhat2-plugin.js",
-    "./internal/artifacts": "./dist/src/internal/deprecated-module-imported-from-hardhat2-plugin.js"
+    "./internal/artifacts": "./dist/src/internal/deprecated-module-imported-from-hardhat2-plugin.js",
+    "./package.json": "./package.json"
   },
   "keywords": [
     "ethereum",
@@ -61,7 +62,7 @@
     "README.md"
   ],
   "devDependencies": {
-    "@nomicfoundation/hardhat-node-test-reporter": "^3.0.6",
+    "@nomicfoundation/hardhat-node-test-reporter": "^3.0.7",
     "@types/adm-zip": "^0.5.5",
     "@types/node": "^22.0.0",
     "@types/semver": "^7.5.8",
@@ -71,15 +72,15 @@
     "expect-type": "^1.2.1",
     "prettier": "3.2.5",
     "rimraf": "^5.0.5",
-    "typescript": "~5.8.0",
+    "typescript": "~6.0.3",
     "@nomicfoundation/hardhat-test-utils": "^2.0.3"
   },
   "dependencies": {
-    "@nomicfoundation/edr": "0.12.0-next.32",
-    "@nomicfoundation/hardhat-errors": "^3.0.12",
-    "@nomicfoundation/hardhat-utils": "^4.1.1",
-    "@nomicfoundation/hardhat-vendored": "^3.0.3",
-    "@nomicfoundation/hardhat-zod-utils": "^3.0.4",
+    "@nomicfoundation/edr": "0.12.0-next.33",
+    "@nomicfoundation/hardhat-errors": "^3.0.13",
+    "@nomicfoundation/hardhat-utils": "^4.1.2",
+    "@nomicfoundation/hardhat-vendored": "^3.0.4",
+    "@nomicfoundation/hardhat-zod-utils": "^3.0.5",
     "@nomicfoundation/solidity-analyzer": "^0.1.1",
     "@sentry/core": "^9.4.0",
     "adm-zip": "^0.4.16",
@@ -95,8 +96,8 @@
     "zod": "^3.23.8"
   },
   "scripts": {
-    "lint": "pnpm prettier --check && pnpm eslint",
-    "lint:fix": "pnpm prettier --write && pnpm eslint --fix",
+    "lint": "pnpm eslint && pnpm prettier --check",
+    "lint:fix": "pnpm eslint --fix && pnpm prettier --write",
     "eslint": "eslint \"src/**/*.ts\" \"test/**/*.ts\"",
     "postlint": "eslint \"templates/**/*.ts\"",
     "postlint:fix": "eslint --fix \"templates/**/*.ts\"",

package/src/config.ts

@@ -3,8 +3,6 @@ export * from "./internal/core/config.js";
 
 export type { HardhatUserConfig } from "./types/config.js";
 
-// NOTE: We export the built-in plugin types to load their type extensions
-export type * from "./internal/builtin-plugins/index.js";
 import type { HardhatUserConfig } from "./types/config.js";
 
 import { throwUsingHardhat2PluginError } from "./internal/using-hardhat2-plugin-errors.js";

package/src/hre.ts

@@ -1,6 +1,3 @@
-// NOTE: We export the built-in plugin types to load their type extensions
-export type * from "./internal/builtin-plugins/index.js";
-
 export { importUserConfig } from "./internal/config-loading.js";
 export { resolveHardhatConfigPath } from "./internal/config-loading.js";
 export { createHardhatRuntimeEnvironment } from "./internal/hre-initialization.js";

package/src/index.ts

@@ -10,9 +10,6 @@ import type { UserInterruptionManager } from "./types/user-interruptions.js";
 
 import { getOrCreateGlobalHardhatRuntimeEnvironment } from "./internal/hre-initialization.js";
 
-// NOTE: We export the built-in plugin types to load their type extensions
-export type * from "./internal/builtin-plugins/index.js";
-
 const hre: HardhatRuntimeEnvironment =
   // eslint-disable-next-line no-restricted-syntax -- Allow top-level await here
   await getOrCreateGlobalHardhatRuntimeEnvironment();

package/src/internal/builtin-global-options.ts

@@ -37,7 +37,8 @@ export const BUILTIN_GLOBAL_OPTIONS_DEFINITIONS: GlobalOptionDefinitions =
         pluginId: "builtin",
         option: globalFlag({
           name: "init",
-          description: "Initializes a Hardhat project.",
+          description:
+            "Initializes a Hardhat project. Supports `--template <name>` and `--templates`.",
         }),
       },
     ],

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/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/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/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

@@ -111,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;
@@ -123,6 +123,7 @@ declare module "../../../../types/config.js" {
     networkId?: number;
     throwOnCallFailures?: boolean;
     throwOnTransactionFailures?: boolean;
+    transactionGasCap?: number | bigint | false;
   }
 
   export type EdrNetworkAccountsUserConfig =
@@ -255,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;
@@ -268,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-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", [

package/src/internal/builtin-plugins/network-manager/utils/apply-coverage-network-overrides.ts

@@ -0,0 +1,32 @@
+import type { EdrNetworkConfig } from "../../../../types/config.js";
+
+/**
+ * Returns a copy of the resolved EDR network config with coverage-specific
+ * overrides applied. When coverage is enabled and the user has not set the
+ * field explicitly:
+ *
+ * - `allowUnlimitedContractSize` defaults to `true`, because coverage
+ *   instrumentation can push the contract size over the limit.
+ * - `blockGasLimit` and `transactionGasCap` default to `false` (disabled),
+ *   so the added gas of coverage instrumentation does not push tests over
+ *   the per-block or EIP-7825 transaction caps.
+ *
+ * Explicit user values are preserved in all three cases.
+ *
+ * When coverage is disabled, the config is returned unchanged.
+ */
+export function applyCoverageNetworkOverrides(
+  config: EdrNetworkConfig,
+  shouldEnableCoverage: boolean,
+): EdrNetworkConfig {
+  if (!shouldEnableCoverage) {
+    return config;
+  }
+
+  return {
+    ...config,
+    allowUnlimitedContractSize: config.allowUnlimitedContractSize ?? true,
+    blockGasLimit: config.blockGasLimit ?? false,
+    transactionGasCap: config.transactionGasCap ?? false,
+  };
+}

package/src/internal/builtin-plugins/node/json-rpc/handler.ts

@@ -269,6 +269,12 @@ const _handleError = (error: Error): JsonRpcResponse => {
     error = new InternalError(undefined, error);
   }
 
+  // Revert errors (code 3): return raw hex to match the geth/anvil convention
+  // that viem/ethers/web3.js rely on. Other errors keep the wrapper for diagnostics.
+  const data: unknown = isRevertError
+    ? returnData
+    : { message: error.message, txHash, data: returnData };
+
   const response: FailedJsonRpcResponse = {
     jsonrpc: "2.0",
     id: null,
@@ -278,11 +284,7 @@ const _handleError = (error: Error): JsonRpcResponse => {
           ? error.code
           : InternalError.CODE,
       message: error.message,
-      data: {
-        message: error.message,
-        txHash,
-        data: returnData,
-      },
+      data,
     },
   };
 

package/src/internal/builtin-plugins/solidity/build-system/resolver/remapped-npm-packages-graph.ts

@@ -29,14 +29,13 @@ import {
 } from "@nomicfoundation/hardhat-utils/package";
 
 import { UserRemappingErrorType } from "../../../../../types/solidity.js";
+import { HARDHAT_PROJECT_INPUT_SOURCE_NAME_ROOT } from "../../constants.js";
 
 import { getNpmPackageName } from "./npm-module-parsing.js";
 import { parseRemappingString, selectBestRemapping } from "./remappings.js";
 import { sourceNamePathJoin } from "./source-name-utils.js";
 import { UserRemappingType } from "./types.js";
 
-const HARDHAT_PROJECT_INPUT_SOURCE_NAME_ROOT = "project";
-
 /**
  * Returns a normalized version of the path if it refers to a node_modules in
  * the root directory (i.e. node_modules/...), or a `node_modules` directory