hardhat 3.9.0 → 3.10.0

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

@@ -6,6 +6,10 @@ import console from "./console/index.js";
 import coverage from "./coverage/index.js";
 import flatten from "./flatten/index.js";
 import gasAnalytics from "./gas-analytics/index.js";
+// The hhu / `utils` feature is unreleased and intentionally not wired up yet.
+// To enable it, uncomment the three `hhu` lines (this import, the type re-export
+// below, and the `builtinPlugins` entry) and re-add `bin.hhu` in package.json.
+// import hhu from "./hhu/index.js";
 import networkManager from "./network-manager/index.js";
 import node from "./node/index.js";
 import run from "./run/index.js";
@@ -22,6 +26,7 @@ export type * from "./console/index.js";
 export type * from "./coverage/index.js";
 export type * from "./flatten/index.js";
 export type * from "./gas-analytics/index.js";
+// export type * from "./hhu/index.js";
 export type * from "./network-manager/index.js";
 export type * from "./node/index.js";
 export type * from "./run/index.js";
@@ -46,4 +51,5 @@ export const builtinPlugins: HardhatPlugin[] = [
   node,
   flatten,
   telemetry,
+  // hhu,
 ];

package/src/internal/builtin-plugins/network-manager/accounts/derive-private-keys.ts

@@ -10,7 +10,7 @@ let mnemonicToSeedSync: typeof Bip39T.mnemonicToSeedSync | undefined;
 // ethereum-cryptography/hdkey is known to be slow to load, so we lazy load it
 let HDKey: typeof HDKeyT | undefined;
 
-const HD_PATH_REGEX = /^m(:?\/\d+'?)+\/?$/;
+const HD_PATH_REGEX = /^m(?:\/\d+'?)+\/?$/;
 
 export async function derivePrivateKeys(
   mnemonic: string,

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

@@ -59,6 +59,7 @@ import {
   hardhatForkingConfigToEdrForkConfig,
   resolveDefaultTransactionGasLimit,
 } from "./utils/convert-to-edr.js";
+import { warnIfExperimentalHardfork } from "./utils/hardfork.js";
 import { printLine, replaceLastLine } from "./utils/logger.js";
 
 const log = createDebug("hardhat:core:network-manager:edr:provider");
@@ -109,6 +110,8 @@ export class EdrProvider extends BaseProvider {
     const printLineFn = loggerConfig.printLineFn ?? printLine;
     const replaceLastLineFn = loggerConfig.replaceLastLineFn ?? replaceLastLine;
 
+    warnIfExperimentalHardfork(networkConfig.hardfork, networkConfig.chainType);
+
     const providerConfig = await getProviderConfig(
       networkConfig,
       coverageConfig,

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

@@ -42,7 +42,6 @@ import {
 } from "@nomicfoundation/edr";
 
 export {
-  SourceReference,
   StackTraceEntryType,
   CheatcodeErrorCode,
   stackTraceEntryTypeToString,
@@ -56,6 +55,7 @@ export {
 };
 
 export type {
+  SourceReference,
   CallstackEntryStackTraceEntry,
   UnrecognizedCreateCallstackEntryStackTraceEntry,
   UnrecognizedContractCallstackEntryStackTraceEntry,

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

@@ -21,6 +21,32 @@ import {
   UNRECOGNIZED_FUNCTION_NAME,
 } from "./solidity-stack-trace.js";
 
+interface CheatcodeSuggestion {
+  message: string;
+  docsUrl?: string;
+}
+
+const CHEATCODE_SUGGESTIONS: Record<string, CheatcodeSuggestion> = {
+  "eip712HashType(string,string)": {
+    message:
+      "Providing a path to a bindings file is not supported, please use the eip712HashType(string calldata typeNameOrDefinition) cheatcode instead.",
+    docsUrl:
+      "https://hardhat.org/docs/reference/cheatcodes/utilities/eip712-hash-type",
+  },
+};
+
+export function getCheatcodeSuggestion(cheatcode: string): string {
+  const suggestion = CHEATCODE_SUGGESTIONS[cheatcode];
+
+  if (suggestion === undefined) {
+    return "";
+  }
+
+  return suggestion.docsUrl !== undefined
+    ? `${suggestion.message} See ${suggestion.docsUrl} for more information.`
+    : suggestion.message;
+}
+
 export function createSolidityErrorWithStackTrace(
   fallbackMessage: string,
   stackTrace: SolidityStackTrace,
@@ -277,6 +303,13 @@ function getMessageFromLastStackTraceEntry(
         switch (stackTraceEntry.details.code) {
           case CheatcodeErrorCode.UnsupportedCheatcode:
             message = `Cheatcode '${stackTraceEntry.details.cheatcode}' is not supported by Hardhat.`;
+
+            const suggestion = getCheatcodeSuggestion(
+              stackTraceEntry.details.cheatcode,
+            );
+
+            message += suggestion.length > 0 ? " " + suggestion : "";
+
             break;
           case CheatcodeErrorCode.MissingCheatcode:
             message = `Cheatcode '${stackTraceEntry.details.cheatcode}' is not yet available in this version of Hardhat.`;

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

@@ -22,6 +22,7 @@ export enum L1HardforkName {
   CANCUN = "cancun",
   PRAGUE = "prague",
   OSAKA = "osaka",
+  AMSTERDAM = "amsterdam",
 }
 
 export enum OpHardforkName {
@@ -44,10 +45,26 @@ export function getHardforks(chainType: ChainType): string[] {
     : L1_HARDFORK_ORDER;
 }
 
+/**
+ * The latest *stable* hardforks. These are hardcoded (rather than derived from
+ * EDR's `l1HardforkLatest()`/`opLatestHardfork()`) so this module stays free of
+ * the native `@nomicfoundation/edr` addon on the config-resolution bootstrap
+ * path — see commit 2568ed1ba.
+ *
+ * They are NOT necessarily the last entry of the enum: the enum can contain
+ * experimental forks (e.g. Amsterdam) that EDR ships but hasn't promoted to
+ * latest yet. The invariant test in
+ * `test/.../edr/types/hardfork.ts` asserts these equal EDR's
+ * `l1HardforkLatest()`/`opLatestHardfork()` — bump them together when EDR
+ * promotes a fork.
+ */
+export const L1_LATEST_STABLE_HARDFORK: L1HardforkName = L1HardforkName.OSAKA;
+export const OP_LATEST_STABLE_HARDFORK: OpHardforkName = OpHardforkName.ISTHMUS;
+
 export function getCurrentHardfork(chainType: ChainType): string {
-  const order =
-    chainType === OPTIMISM_CHAIN_TYPE ? OP_HARDFORK_ORDER : L1_HARDFORK_ORDER;
-  return order[order.length - 1];
+  return chainType === OPTIMISM_CHAIN_TYPE
+    ? OP_LATEST_STABLE_HARDFORK
+    : L1_LATEST_STABLE_HARDFORK;
 }
 
 /**

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

@@ -40,6 +40,7 @@ import {
   CANCUN,
   PRAGUE,
   OSAKA,
+  AMSTERDAM,
   BEDROCK,
   REGOLITH,
   CANYON,
@@ -114,6 +115,8 @@ export function edrL1HardforkToHardhatL1HardforkName(
       return L1HardforkName.PRAGUE;
     case SpecId.Osaka:
       return L1HardforkName.OSAKA;
+    case SpecId.Amsterdam:
+      return L1HardforkName.AMSTERDAM;
     // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check -- trust but verify
     default:
       const _exhaustiveCheck: never = hardfork;
@@ -235,6 +238,8 @@ function hardhatL1HardforkToEdrSpecId(hardfork: string): string {
       return PRAGUE;
     case L1HardforkName.OSAKA:
       return OSAKA;
+    case L1HardforkName.AMSTERDAM:
+      return AMSTERDAM;
 
     // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check -- we want to print the fork
     default:

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

@@ -1,6 +1,15 @@
+import type { ChainType } from "../../../../../types/network.js";
+
+import { styleText } from "node:util";
+
 import { assertHardhatInvariant } from "@nomicfoundation/hardhat-errors";
 
-import { L1HardforkName, OpHardforkName } from "../types/hardfork.js";
+import {
+  getCurrentHardfork,
+  hardforkGte,
+  L1HardforkName,
+  OpHardforkName,
+} from "../types/hardfork.js";
 
 export function getL1HardforkName(name: string): L1HardforkName {
   const hardforkName =
@@ -16,6 +25,49 @@ export function getL1HardforkName(name: string): L1HardforkName {
   return hardforkName;
 }
 
+// Tracks which (chainType, hardfork) pairs have already been warned about, so
+// we only print the experimental-hardfork warning once per process.
+const warnedHardforks = new Set<string>();
+
+/**
+ * Prints a warning if `hardfork` is strictly beyond the latest stable hardfork
+ * for the given chain type (i.e. an experimental fork that EDR supports but
+ * hasn't promoted to latest yet). The warning is emitted at
+ * most once per (chainType, hardfork) pair for the lifetime of the process.
+ */
+export function warnIfExperimentalHardfork(
+  hardfork: string,
+  chainType: ChainType,
+  warn: (message: string) => void = (message) => console.error(message),
+): void {
+  const latestStable = getCurrentHardfork(chainType);
+
+  // Only warn for hardforks strictly beyond the latest stable one.
+  if (
+    hardfork === latestStable ||
+    !hardforkGte(hardfork, latestStable, chainType)
+  ) {
+    return;
+  }
+
+  const key = `${chainType}:${hardfork}`;
+
+  if (warnedHardforks.has(key)) {
+    return;
+  }
+
+  warnedHardforks.add(key);
+
+  warn(
+    styleText(["bold", "yellow"], "Warning:") +
+      ` you have configured the "${hardfork}" hardfork, which is experimental ` +
+      `and not yet finalized, so its behavior may change or be incomplete. ` +
+      `The latest stable hardfork is "${latestStable}". ` +
+      `Keep Hardhat up to date to track changes to "${hardfork}" and to pick up ` +
+      `its stable version once it activates on mainnet.\n`,
+  );
+}
+
 export function getOpHardforkName(name: string): OpHardforkName {
   const hardforkName =
     Object.values(OpHardforkName)[

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

@@ -1,8 +1,8 @@
 import type { HardhatPlugin } from "../../../types/plugins.js";
 
 import { definePlugin } from "../../../plugins.js";
-import { ArgumentType } from "../../../types/arguments.js";
-import { globalOption } from "../../core/config.js";
+
+import { NETWORK_GLOBAL_OPTION } from "./network-option.js";
 
 export type * from "./type-extensions/config.js";
 export type * from "./type-extensions/global-options.js";
@@ -16,14 +16,7 @@ const hardhatPlugin: HardhatPlugin = definePlugin({
     hre: () => import("./hook-handlers/hre.js"),
     network: () => import("./hook-handlers/network.js"),
   },
-  globalOptions: [
-    globalOption({
-      name: "network",
-      description: "The network to connect to",
-      type: ArgumentType.STRING_WITHOUT_DEFAULT,
-      defaultValue: undefined,
-    }),
-  ],
+  globalOptions: [NETWORK_GLOBAL_OPTION],
   npmPackage: "hardhat",
   dependencies: () => [import("../artifacts/index.js")],
 });

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

@@ -0,0 +1,17 @@
+import type { GlobalOptionDefinition } from "../../../types/arguments.js";
+
+import { ArgumentType } from "../../../types/arguments.js";
+import { globalOption } from "../../core/config.js";
+
+/**
+ * The `--network` global option, contributed by the network-manager plugin.
+ *
+ * Exported so the standalone hhu binary, which doesn't load the plugin, can
+ * reuse the exact same definition instead of duplicating it.
+ */
+export const NETWORK_GLOBAL_OPTION: GlobalOptionDefinition = globalOption({
+  name: "network",
+  description: "The network to connect to",
+  type: ArgumentType.STRING_WITHOUT_DEFAULT,
+  defaultValue: undefined,
+});

package/src/internal/builtin-plugins/network-manager/request-handlers/handlers/accounts/automatic-sender-handler.ts

@@ -1,32 +1,62 @@
-import { assertHardhatInvariant } from "@nomicfoundation/hardhat-errors";
+import type {
+  JsonRpcRequest,
+  JsonRpcResponse,
+} from "../../../../../../types/providers.js";
+
+import { isObject } from "@nomicfoundation/hardhat-utils/lang";
+
+import { getRequestParams } from "../../../json-rpc.js";
+import { InternalError } from "../../../provider-errors.js";
 
 import { SenderHandler } from "./sender.js";
 
 /**
  * This class automatically retrieves and caches the first available account from the connected provider.
- * It overrides the getSender method of the base class to request the list of accounts if the first account has not been fetched yet,
- * ensuring dynamic selection of the sender for all JSON-RPC requests without requiring manual input.
+ * On the first supported request, fetches and caches `eth_accounts` so callers don't need to set `from` manually.
+ * If `eth_accounts` responds with a non-array, it returns a JSON-RPC error.
  */
 export class AutomaticSenderHandler extends SenderHandler {
   #alreadyFetchedAccounts = false;
   #firstAccount: string | undefined;
 
-  protected async getSender(): Promise<string | undefined> {
+  public override async handle(
+    jsonRpcRequest: JsonRpcRequest,
+  ): Promise<JsonRpcRequest | JsonRpcResponse> {
+    if (!this.isSupportedMethod(jsonRpcRequest)) {
+      return jsonRpcRequest;
+    }
+
+    const [tx] = getRequestParams(jsonRpcRequest);
+    if (!isObject(tx) || tx.from !== undefined) {
+      // Skip the eth_accounts fetch when we won't need a sender anyway:
+      // the tx isn't an object, or it already carries a `from`.
+      return await super.handle(jsonRpcRequest);
+    }
+
     if (this.#alreadyFetchedAccounts === false) {
       const accounts = await this.provider.request({
         method: "eth_accounts",
       });
 
-      // TODO: This shouldn't be an exception but a failed JSON response!
-      assertHardhatInvariant(
-        Array.isArray(accounts),
-        "eth_accounts response should be an array",
-      );
+      if (!Array.isArray(accounts)) {
+        return {
+          jsonrpc: "2.0",
+          id: jsonRpcRequest.id,
+          error: {
+            code: InternalError.CODE,
+            message: "eth_accounts did not return an array of accounts",
+          },
+        };
+      }
 
       this.#firstAccount = accounts[0];
       this.#alreadyFetchedAccounts = true;
     }
 
+    return await super.handle(jsonRpcRequest);
+  }
+
+  protected async getSender(): Promise<string | undefined> {
     return this.#firstAccount;
   }
 }

package/src/internal/builtin-plugins/node/task-action.ts

@@ -1,5 +1,3 @@
-import type { EdrNetworkConfigOverride } from "../../../types/config.js";
-import type { ChainType } from "../../../types/network.js";
 import type { NewTaskActionFunction } from "../../../types/tasks.js";
 
 import path from "node:path";
@@ -12,7 +10,6 @@ import {
 import { createDebug } from "@nomicfoundation/hardhat-utils/debug";
 import { ensureDir, exists } from "@nomicfoundation/hardhat-utils/fs";
 
-import { isSupportedChainType } from "../../edr/chain-type.js";
 import { BUILD_INFO_DIR_NAME } from "../artifacts/artifact-manager.js";
 import { EdrProvider } from "../network-manager/edr/edr-provider.js";
 
@@ -22,6 +19,7 @@ import {
   formatEdrNetworkConfigAccounts,
 } from "./helpers.js";
 import { JsonRpcServerImplementation } from "./json-rpc/server.js";
+import { resolveNodeConnectionParams } from "./utils/resolve-node-connection-params.js";
 
 const log = createDebug("hardhat:core:tasks:node");
 
@@ -56,55 +54,7 @@ const nodeAction: NewTaskActionFunction<NodeActionArguments> = async (
     });
   }
 
-  const connectionParams: {
-    network: string;
-    chainType?: ChainType;
-    override?: EdrNetworkConfigOverride;
-  } = {
-    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",
-      },
-    );
-  }
+  const connectionParams = resolveNodeConnectionParams(network, args);
 
   // NOTE: This is where we initialize the network; the create method returns
   // a fully resolved networkConfig object which might be useful for display

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;